@woosh/meep-engine 3.15.0 → 3.17.0

package/src/core/model/node-graph/visual/layout/NodeGraphLayoutOptions.d.ts

@@ -0,0 +1,175 @@
+/**
+ * Every number the layout is allowed to be tuned by.
+ *
+ * They live in one place because they are not independent: the room a channel has for tracks is set
+ * by `layer_gap`, the room a wire lane has is set by `wire_gap`, and a router told to bend for less
+ * than it costs to go around will do neither well. Somebody changing one of these needs to see the
+ * others.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class NodeGraphLayoutOptions {
+    /**
+     * @param {Partial<NodeGraphLayoutOptions>} [overrides]
+     * @returns {NodeGraphLayoutOptions}
+     */
+    static from(overrides?: Partial<NodeGraphLayoutOptions>): NodeGraphLayoutOptions;
+    /**
+     * Horizontal gap between one column of boxes and the next.
+     *
+     * This is the width of the channel every edge crossing that boundary has to share, so it is
+     * also what limits how many wires can run side by side without one of them having to detour.
+     *
+     * @type {number}
+     */
+    layer_gap: number;
+    /**
+     * Vertical gap between two node boxes sharing a column.
+     * @type {number}
+     */
+    node_gap: number;
+    /**
+     * Vertical room reserved for one wire passing through a column it does not stop at.
+     *
+     * An edge spanning several columns gets a lane of this height in each one it crosses, which is
+     * what keeps a long edge from being drawn over the boxes it passes.
+     *
+     * @type {number}
+     */
+    wire_gap: number;
+    /**
+     * How far outside a box the router runs alongside it, and how far a wire leaves its port before
+     * it is allowed to turn.
+     *
+     * It is one number because it is one line: the grid's line around a box is where a wire
+     * alongside it runs, and it is also the first place a wire leaving a port can turn. A wire on
+     * the box boundary reads as touching it, and a wire that turns the moment it leaves a port
+     * makes it hard to see which port it belongs to.
+     *
+     * @type {number}
+     */
+    clearance: number;
+    /**
+     * Routing tracks placed across each channel, on top of the lines the boxes themselves induce.
+     *
+     * A channel with no tracks can only be crossed at the x of some box edge, and every wire
+     * turning in that channel has to turn at the same place. Eight is enough for the graphs seen in
+     * practice and cheap — a track is one column of grid vertices.
+     *
+     * @type {number}
+     */
+    channel_tracks: number;
+    /**
+     * What a ninety degree turn costs the router, in the same units as length.
+     *
+     * The router minimises length plus bends, and the ratio between them is the whole character of
+     * the result: at zero it produces staircases, and at a very large value it produces long
+     * detours to save a corner. This is roughly a quarter of a channel — a wire will go a third of
+     * the way across a channel to avoid a bend, and no further.
+     *
+     * @type {number}
+     */
+    bend_penalty: number;
+    /**
+     * What crossing another wire costs the router, in the same units as length.
+     *
+     * A crossing is the one thing in a drawing that costs the reader more than a bend: following a
+     * wire through a corner is easy, following it through another wire means deciding which of the
+     * two lines leaving the crossing is the one being followed. So this is above the bend penalty,
+     * and a wire will go about half a channel out of its way to avoid one crossing — and any
+     * distance at all to avoid six, which is what the reader would otherwise get from a wire that
+     * had a route of the same length round the outside and no reason to take it.
+     *
+     * @type {number}
+     */
+    crossing_penalty: number;
+    /**
+     * Rounds of improvement after the negotiation has settled.
+     *
+     * Negotiation asks a wire to look again only when it is sharing a line, so a wire that was
+     * routed early — before most of what it now crosses existed — and shares nothing is never asked
+     * again. Each round here re-routes every wire in turn with all the others present, keeping the
+     * new route only where it is cheaper, and stops as soon as a round changes nothing. Cost can
+     * only fall, so this always settles; the number here is what bounds it on a graph where it is
+     * slow to.
+     *
+     * @type {number}
+     */
+    improvement_rounds: number;
+    /**
+     * Rounds of rip-up and reroute.
+     *
+     * The loop stops as soon as nothing is shared, and each round after the first only asks the
+     * wires still in an argument, so on a graph whose wires mostly fit this costs very little.
+     * Congestion that survives six rounds is congestion the placement created and the router cannot
+     * fix.
+     *
+     * This is the number to lower on a graph where every wire is fighting — hundreds of them
+     * through one channel, which is what a node with a hundred consumers produces. There the whole
+     * set is re-routed every round and the work is rounds times wires times the size of the grid.
+     *
+     * @type {number}
+     */
+    congestion_iterations: number;
+    /**
+     * What a wire pays, per round, for standing on a vertex another wire is already using.
+     *
+     * It starts low deliberately. A first round that already forbids sharing routes every wire
+     * around whatever was routed before it, and the order wires happen to be visited in then
+     * decides the drawing. Starting cheap lets every wire take the route it actually wants, and
+     * raising the price each round makes the ones that want it least give way first.
+     *
+     * @type {number}
+     */
+    present_cost: number;
+    /**
+     * Factor the present cost is multiplied by after each round.
+     * @type {number}
+     */
+    present_growth: number;
+    /**
+     * What a vertex remembers, per round, about having been fought over.
+     *
+     * Present cost alone oscillates: two wires swap places every round, each taking the route the
+     * other just left. History is what breaks the tie — a vertex that has been contested stays
+     * expensive even once it is free, so the pair separates instead of trading.
+     *
+     * @type {number}
+     */
+    history_rate: number;
+    /**
+     * Largest radius a corner of a route is rounded by when it becomes a curve.
+     *
+     * The actual radius is this or half the shorter of the two legs, whichever is smaller, so a
+     * short jog becomes a single smooth S and a long run stays straight until it turns.
+     *
+     * @type {number}
+     */
+    corner_radius: number;
+    /**
+     * Ordering passes over the layers.
+     * @type {number}
+     */
+    order_sweeps: number;
+    /**
+     * Ceiling on the routing grid, in vertices.
+     *
+     * The grid is the product of two coordinate lists, so it grows as the square of the graph. Past
+     * this the port lines are dropped and wires reach their ports by a stub instead — a slightly
+     * worse drawing, rather than a layout that takes a minute.
+     *
+     * @type {number}
+     */
+    max_grid_vertices: number;
+    /**
+     * Ceiling on the states one route may expand before it gives up and takes a direct path.
+     *
+     * A route that cannot be found is not worth an unbounded search; the graph it is in is one the
+     * router has already failed to make readable.
+     *
+     * @type {number}
+     */
+    max_route_expansions: number;
+}
+//# sourceMappingURL=NodeGraphLayoutOptions.d.ts.map

package/src/core/model/node-graph/visual/layout/NodeGraphLayoutOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeGraphLayoutOptions.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/NodeGraphLayoutOptions.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH;IA8KI;;;OAGG;IACH,wBAHW,QAAQ,sBAAsB,CAAC,GAC7B,sBAAsB,CAclC;IA5LD;;;;;;;OAOG;IACH,WAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,UAFU,MAAM,CAEF;IAEd;;;;;;;OAOG;IACH,UAFU,MAAM,CAEF;IAEd;;;;;;;;;;OAUG;IACH,WAFU,MAAM,CAED;IAEf;;;;;;;;OAQG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;;;;;;;OASG;IACH,cAFU,MAAM,CAEE;IAElB;;;;;;;;;;;OAWG;IACH,kBAFU,MAAM,CAEM;IAEtB;;;;;;;;;;;OAWG;IACH,oBAFU,MAAM,CAEO;IAEvB;;;;;;;;;;;;;OAaG;IACH,uBAFU,MAAM,CAEU;IAE1B;;;;;;;;;OASG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,gBAFU,MAAM,CAEG;IAEnB;;;;;;;;OAQG;IACH,cAFU,MAAM,CAEC;IAEjB;;;;;;;OAOG;IACH,eAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,cAFU,MAAM,CAEC;IAEjB;;;;;;;;OAQG;IACH,mBAFU,MAAM,CAEY;IAE5B;;;;;;;OAOG;IACH,sBAFU,MAAM,CAEc;CAmBjC"}

package/src/core/model/node-graph/visual/layout/NodeGraphLayoutOptions.js

@@ -0,0 +1,203 @@
+/**
+ * Every number the layout is allowed to be tuned by.
+ *
+ * They live in one place because they are not independent: the room a channel has for tracks is set
+ * by `layer_gap`, the room a wire lane has is set by `wire_gap`, and a router told to bend for less
+ * than it costs to go around will do neither well. Somebody changing one of these needs to see the
+ * others.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class NodeGraphLayoutOptions {
+
+    /**
+     * Horizontal gap between one column of boxes and the next.
+     *
+     * This is the width of the channel every edge crossing that boundary has to share, so it is
+     * also what limits how many wires can run side by side without one of them having to detour.
+     *
+     * @type {number}
+     */
+    layer_gap = 140;
+
+    /**
+     * Vertical gap between two node boxes sharing a column.
+     * @type {number}
+     */
+    node_gap = 44;
+
+    /**
+     * Vertical room reserved for one wire passing through a column it does not stop at.
+     *
+     * An edge spanning several columns gets a lane of this height in each one it crosses, which is
+     * what keeps a long edge from being drawn over the boxes it passes.
+     *
+     * @type {number}
+     */
+    wire_gap = 20;
+
+    /**
+     * How far outside a box the router runs alongside it, and how far a wire leaves its port before
+     * it is allowed to turn.
+     *
+     * It is one number because it is one line: the grid's line around a box is where a wire
+     * alongside it runs, and it is also the first place a wire leaving a port can turn. A wire on
+     * the box boundary reads as touching it, and a wire that turns the moment it leaves a port
+     * makes it hard to see which port it belongs to.
+     *
+     * @type {number}
+     */
+    clearance = 24;
+
+    /**
+     * Routing tracks placed across each channel, on top of the lines the boxes themselves induce.
+     *
+     * A channel with no tracks can only be crossed at the x of some box edge, and every wire
+     * turning in that channel has to turn at the same place. Eight is enough for the graphs seen in
+     * practice and cheap — a track is one column of grid vertices.
+     *
+     * @type {number}
+     */
+    channel_tracks = 8;
+
+    /**
+     * What a ninety degree turn costs the router, in the same units as length.
+     *
+     * The router minimises length plus bends, and the ratio between them is the whole character of
+     * the result: at zero it produces staircases, and at a very large value it produces long
+     * detours to save a corner. This is roughly a quarter of a channel — a wire will go a third of
+     * the way across a channel to avoid a bend, and no further.
+     *
+     * @type {number}
+     */
+    bend_penalty = 40;
+
+    /**
+     * What crossing another wire costs the router, in the same units as length.
+     *
+     * A crossing is the one thing in a drawing that costs the reader more than a bend: following a
+     * wire through a corner is easy, following it through another wire means deciding which of the
+     * two lines leaving the crossing is the one being followed. So this is above the bend penalty,
+     * and a wire will go about half a channel out of its way to avoid one crossing — and any
+     * distance at all to avoid six, which is what the reader would otherwise get from a wire that
+     * had a route of the same length round the outside and no reason to take it.
+     *
+     * @type {number}
+     */
+    crossing_penalty = 60;
+
+    /**
+     * Rounds of improvement after the negotiation has settled.
+     *
+     * Negotiation asks a wire to look again only when it is sharing a line, so a wire that was
+     * routed early — before most of what it now crosses existed — and shares nothing is never asked
+     * again. Each round here re-routes every wire in turn with all the others present, keeping the
+     * new route only where it is cheaper, and stops as soon as a round changes nothing. Cost can
+     * only fall, so this always settles; the number here is what bounds it on a graph where it is
+     * slow to.
+     *
+     * @type {number}
+     */
+    improvement_rounds = 4;
+
+    /**
+     * Rounds of rip-up and reroute.
+     *
+     * The loop stops as soon as nothing is shared, and each round after the first only asks the
+     * wires still in an argument, so on a graph whose wires mostly fit this costs very little.
+     * Congestion that survives six rounds is congestion the placement created and the router cannot
+     * fix.
+     *
+     * This is the number to lower on a graph where every wire is fighting — hundreds of them
+     * through one channel, which is what a node with a hundred consumers produces. There the whole
+     * set is re-routed every round and the work is rounds times wires times the size of the grid.
+     *
+     * @type {number}
+     */
+    congestion_iterations = 6;
+
+    /**
+     * What a wire pays, per round, for standing on a vertex another wire is already using.
+     *
+     * It starts low deliberately. A first round that already forbids sharing routes every wire
+     * around whatever was routed before it, and the order wires happen to be visited in then
+     * decides the drawing. Starting cheap lets every wire take the route it actually wants, and
+     * raising the price each round makes the ones that want it least give way first.
+     *
+     * @type {number}
+     */
+    present_cost = 8;
+
+    /**
+     * Factor the present cost is multiplied by after each round.
+     * @type {number}
+     */
+    present_growth = 2;
+
+    /**
+     * What a vertex remembers, per round, about having been fought over.
+     *
+     * Present cost alone oscillates: two wires swap places every round, each taking the route the
+     * other just left. History is what breaks the tie — a vertex that has been contested stays
+     * expensive even once it is free, so the pair separates instead of trading.
+     *
+     * @type {number}
+     */
+    history_rate = 4;
+
+    /**
+     * Largest radius a corner of a route is rounded by when it becomes a curve.
+     *
+     * The actual radius is this or half the shorter of the two legs, whichever is smaller, so a
+     * short jog becomes a single smooth S and a long run stays straight until it turns.
+     *
+     * @type {number}
+     */
+    corner_radius = 30;
+
+    /**
+     * Ordering passes over the layers.
+     * @type {number}
+     */
+    order_sweeps = 8;
+
+    /**
+     * Ceiling on the routing grid, in vertices.
+     *
+     * The grid is the product of two coordinate lists, so it grows as the square of the graph. Past
+     * this the port lines are dropped and wires reach their ports by a stub instead — a slightly
+     * worse drawing, rather than a layout that takes a minute.
+     *
+     * @type {number}
+     */
+    max_grid_vertices = 1 << 18;
+
+    /**
+     * Ceiling on the states one route may expand before it gives up and takes a direct path.
+     *
+     * A route that cannot be found is not worth an unbounded search; the graph it is in is one the
+     * router has already failed to make readable.
+     *
+     * @type {number}
+     */
+    max_route_expansions = 200000;
+
+    /**
+     * @param {Partial<NodeGraphLayoutOptions>} [overrides]
+     * @returns {NodeGraphLayoutOptions}
+     */
+    static from(overrides) {
+        const r = new NodeGraphLayoutOptions();
+
+        if (overrides !== undefined) {
+            for (const key in overrides) {
+                if (key in r) {
+                    r[key] = overrides[key];
+                }
+            }
+        }
+
+        return r;
+    }
+}

package/src/core/model/node-graph/visual/layout/RouteGrid.d.ts

@@ -0,0 +1,226 @@
+/**
+ * Coordinates nearer than this to one another are the same coordinate.
+ *
+ * Two lines a fraction of a unit apart are one line to anybody looking at the drawing, and keeping
+ * both of them costs a whole row or column of the grid. It is also how far inside a box a line has
+ * to be before it counts as inside: a lane placed exactly a clearance from a box lands a rounding
+ * error either side of the box's own clearance line, and a line that is inside by less than this
+ * is on the edge.
+ *
+ * @type {number}
+ */
+export const ROUTE_GRID_EPSILON: number;
+/**
+ * The space wires are allowed to occupy.
+ *
+ * A **sparse grid**: not a fine mesh over the drawing, but the few horizontal and vertical lines
+ * that are actually worth travelling along — the edges of the boxes and a margin around them, the
+ * heights the ports sit at, the lanes the layout reserved for wires passing through a column, and a
+ * handful of tracks across each channel. Every route that is worth having runs along some of these
+ * and turns where two of them meet, so a grid made of only these has every good route in it and is
+ * a hundredth the size of a mesh fine enough to hold them.
+ *
+ * This is the Hanan grid of the obstacles, which is the standard construction: for a set of
+ * rectangles, an optimal rectilinear route between any two points on it exists on the grid their
+ * own edges induce, so nothing is lost by refusing to leave it.
+ *
+ * **Obstacles block edges, not vertices.** A wire crosses a box by travelling along a line that
+ * passes through it, and whether that is possible is a property of the line between two grid
+ * points rather than of the points themselves — both ends of a line straddling a box are outside
+ * it. Marking the crossing itself is what makes a box solid, and it is also what lets the grid stay
+ * sparse: a grid that had to make every crossing land on a blocked vertex would need a line at
+ * every box edge, and there are four of those per box.
+ *
+ * **Occupancy is per edge as well**, for the same reason: two wires sharing a length of line
+ * overlap and are drawn on top of each other, and two wires meeting at a point merely cross, which
+ * is legal and costs the reader nothing. Counting points would make the router pay to avoid a
+ * crossing and then take a detour to do it.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class RouteGrid {
+    /**
+     * Index of the grid line at or immediately below `value`.
+     *
+     * Clamped rather than reported as absent: a point off the end of the grid belongs to the line at
+     * that end, which is what every caller here wants and what a bare lower bound does not say.
+     *
+     * @param {Float64Array} axis
+     * @param {number} value
+     * @returns {number}
+     */
+    static floor_index(axis: Float64Array, value: number): number;
+    /**
+     * Index of the grid line nearest `value`.
+     *
+     * @param {Float64Array} axis
+     * @param {number} value
+     * @returns {number}
+     */
+    static nearest_index(axis: Float64Array, value: number): number;
+    /**
+     * @param {Float64Array} xs ascending, distinct
+     * @param {Float64Array} ys ascending, distinct
+     */
+    constructor(xs: Float64Array, ys: Float64Array);
+    /**
+     * Ascending, distinct.
+     * @type {Float64Array}
+     */
+    xs: Float64Array;
+    /**
+     * @type {Float64Array}
+     */
+    ys: Float64Array;
+    /**
+     * @type {number}
+     */
+    nx: number;
+    /**
+     * @type {number}
+     */
+    ny: number;
+    /**
+     * @type {number}
+     */
+    vertex_count: number;
+    /**
+     * Whether the line from vertex `v` to the vertex right of it passes through a box.
+     * @type {BitSet}
+     */
+    blocked_h: BitSet;
+    /**
+     * Whether the line from vertex `v` to the vertex below it passes through a box.
+     * @type {BitSet}
+     */
+    blocked_v: BitSet;
+    /**
+     * Wires currently occupying each rightward line.
+     * @type {Int32Array}
+     */
+    use_h: Int32Array;
+    /**
+     * @type {Int32Array}
+     */
+    use_v: Int32Array;
+    /**
+     * What each rightward line remembers about having been fought over. See
+     * {@link NodeGraphLayoutOptions#history_rate}.
+     * @type {Float32Array}
+     */
+    history_h: Float32Array;
+    /**
+     * @type {Float32Array}
+     */
+    history_v: Float32Array;
+    /**
+     * Wires passing straight through each vertex horizontally — in along one rightward line and
+     * out along the next, without turning.
+     *
+     * This is what a crossing is made of. Wires are confined to the grid lines, so two of them can
+     * only cross at a vertex, and they cross there exactly when one goes straight through it one
+     * way and the other goes straight through it the other way. Every other way two wires can meet
+     * at a vertex is either a shared line, which {@link use_h} already counts, or two corners
+     * touching, which the curves they become pull apart.
+     *
+     * A wire's stub counts as the direction it arrives from: a wire leaving a port on the right of
+     * a box and carrying straight on has gone straight through the vertex where it met the grid.
+     *
+     * @type {Int32Array}
+     */
+    through_h: Int32Array;
+    /**
+     * @type {Int32Array}
+     */
+    through_v: Int32Array;
+    /**
+     * The net every wire on each rightward line belongs to, when they all belong to one — the
+     * wires that leave one port together are a net — and -1 otherwise.
+     *
+     * Wires of one net are one signal, and where they run along the same line they are one line
+     * that forks, not two wires drawn on top of each other. So a wire is charged for sharing a
+     * line only with wires of other nets, and this is what says how many of those there are: the
+     * wires on the line, less the ones of the net that holds it. A line with wires of several nets
+     * on it is held by whichever claimed it first; the others count as sharing, which they are.
+     *
+     * @type {Int32Array}
+     */
+    owner_h: Int32Array;
+    /**
+     * @type {Int32Array}
+     */
+    owner_v: Int32Array;
+    /**
+     * How many of the wires on each rightward line belong to the net that holds it.
+     * @type {Int32Array}
+     */
+    owned_h: Int32Array;
+    /**
+     * @type {Int32Array}
+     */
+    owned_v: Int32Array;
+    /**
+     * Forget every route, keeping the obstacles and everything the grid has learned about
+     * congestion. This is what a round of rip-up and reroute starts with.
+     * @returns {void}
+     */
+    clear_use(): void;
+    /**
+     * Wires of other nets on the rightward line from vertex `v`: what a wire of `net` shares it
+     * with. See {@link owner_h}.
+     *
+     * @param {number} v
+     * @param {number} net
+     * @returns {number}
+     */
+    foreign_h(v: number, net: number): number;
+    /**
+     * @param {number} v
+     * @param {number} net
+     * @returns {number}
+     */
+    foreign_v(v: number, net: number): number;
+    /**
+     * Put a wire of `net` on the rightward line from vertex `v`, or take it off.
+     *
+     * @param {number} v
+     * @param {number} net
+     * @param {number} delta 1 or -1
+     * @returns {void}
+     */
+    claim_h(v: number, net: number, delta: number): void;
+    /**
+     * @param {number} v
+     * @param {number} net
+     * @param {number} delta 1 or -1
+     * @returns {void}
+     */
+    claim_v(v: number, net: number, delta: number): void;
+    /**
+     * @param {number} x
+     * @returns {number}
+     */
+    nearest_x(x: number): number;
+    /**
+     * @param {number} y
+     * @returns {number}
+     */
+    nearest_y(y: number): number;
+    /**
+     * Mark every line crossing the given rectangle as impassable.
+     *
+     * A line is impassable when it enters the rectangle's interior. Lines running along an edge of
+     * it — to within {@link ROUTE_GRID_EPSILON} — are left alone: the rectangle handed here is
+     * already the box grown by its clearance, so its edges are where a wire is meant to run.
+     *
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} x1
+     * @param {number} y1
+     * @returns {void}
+     */
+    block_rectangle(x0: number, y0: number, x1: number, y1: number): void;
+}
+import { BitSet } from "../../../../binary/BitSet.js";
+//# sourceMappingURL=RouteGrid.d.ts.map

package/src/core/model/node-graph/visual/layout/RouteGrid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RouteGrid.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/model/node-graph/visual/layout/RouteGrid.js"],"names":[],"mappings":"AAMA;;;;;;;;;;GAUG;AACH,iCAFU,MAAM,CAEsB;AAiCtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;IAoNI;;;;;;;;;OASG;IACH,yBAJW,YAAY,SACZ,MAAM,GACJ,MAAM,CAOlB;IAED;;;;;;OAMG;IACH,2BAJW,YAAY,SACZ,MAAM,GACJ,MAAM,CAUlB;IAjID;;;OAGG;IACH,gBAHW,YAAY,MACZ,YAAY,EA+BtB;IAlJD;;;OAGG;IACH,IAFU,YAAY,CAEnB;IAEH;;OAEG;IACH,IAFU,YAAY,CAEnB;IAEH;;OAEG;IACH,IAFU,MAAM,CAET;IAEP;;OAEG;IACH,IAFU,MAAM,CAET;IAEP;;OAEG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,WAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,WAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,OAFU,UAAU,CAEd;IAEN;;OAEG;IACH,OAFU,UAAU,CAEd;IAEN;;;;OAIG;IACH,WAFU,YAAY,CAEZ;IAEV;;OAEG;IACH,WAFU,YAAY,CAEZ;IAEV;;;;;;;;;;;;;;OAcG;IACH,WAFU,UAAU,CAEV;IAEV;;OAEG;IACH,WAFU,UAAU,CAEV;IAEV;;;;;;;;;;;OAWG;IACH,SAFU,UAAU,CAEZ;IAER;;OAEG;IACH,SAFU,UAAU,CAEZ;IAER;;;OAGG;IACH,SAFU,UAAU,CAEZ;IAER;;OAEG;IACH,SAFU,UAAU,CAEZ;IAqCR;;;;OAIG;IACH,aAFa,IAAI,CAchB;IAED;;;;;;;OAOG;IACH,aAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,aAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,WALW,MAAM,OACN,MAAM,SACN,MAAM,GACJ,IAAI,CAIhB;IAED;;;;;OAKG;IACH,WALW,MAAM,OACN,MAAM,SACN,MAAM,GACJ,IAAI,CAIhB;IAoCD;;;OAGG;IACH,aAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,aAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;;;OAYG;IACH,oBANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,IAAI,CAmDhB;CACJ;uBApZsB,8BAA8B"}