looply-cli 0.0.0-stage → 0.2.0

package/dist/autonomy-controller.js

@@ -0,0 +1,517 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decideControllerRefusal = decideControllerRefusal;
+exports.decideAutonomyTick = decideAutonomyTick;
+const core_1 = require("@looply/core");
+/**
+ * A met goal against the lane's answer (M5-2). Exhaustive over the kinds, for
+ * the same reason the code table is: a kind nobody decided must not fall
+ * through to "close it".
+ */
+/** How many refused requirements a one-line hold names before it stops counting. */
+const MAX_NAMED_REFUSALS = 3;
+function decideThirdKey(publication) {
+    switch (publication.kind) {
+        case 'published':
+            /**
+             * 🔴 A PUBLICATION THAT OWES AN EVALUATOR VERDICT DOES NOT CLOSE A
+             * PURSUIT, AND THIS IS WHERE `OWNER_CHARTER.md` §4 BECOMES ENFORCEABLE.
+             *
+             * *"Required independent judgement must be freshly obtained, or reused
+             * only under an evidenced policy whose dependencies still hold. A ledger
+             * warning alone does not satisfy a required review."* When a refused
+             * candidate is carried onto the integration branch, `replayDecision`
+             * declines to carry the model's verdict — and the lane then re-gates and
+             * publishes on green, which is right. But no evaluator verdict is taken
+             * on the carried commit, by anything, ever. Closing the pursuit
+             * `satisfied` on that would be exactly the claim the charter forbids.
+             *
+             * ⚠️ A HOLD, NOT A REFUSAL, AND THE DIFFERENCE IS THE WHOLE DESIGN. The
+             * work stays published — nothing is reverted, nothing is frozen, and the
+             * charter says outright not to freeze working replay. What is withheld is
+             * the CLOSURE: the grant stays open and a person is told which commit is
+             * missing which verdict. `pending` and `unknown` already hold for softer
+             * reasons than this one.
+             */
+            /**
+             * F27: A VERDICT TAKEN ON THIS COMMIT IS NO LONGER OWED, and one that was not is bought.
+             * In a programme (`rejudge`) a goal-met Start judges the carried commit itself, so a new
+             * Start TAKES the verdict; before, nothing could, and the pursuit held for ever. Anywhere
+             * else a new Start would judge the run branch again, so it holds exactly as it did.
+             */
+            if (publication.reviewOwed !== undefined && publication.reviewTakenAt !== publication.sha) {
+                const owed = `met at this version and integrated at ${publication.sha}, but no evaluator verdict was taken ` +
+                    `on the carried candidate — ${publication.reviewOwed.because}`;
+                return publication.rejudge === true ? { next: `${owed}; the next Start judges that commit` } : { hold: owed };
+            }
+            /**
+             * 🔴 OWNER RULE #2's CONSUMER, AND IT IS A HOLD FOR THE SAME REASON THE
+             * ONE ABOVE IS.
+             *
+             * The lane regenerated requirement acceptance on this exact integrated
+             * revision. If a claim went STALE, or the lane REFUSED one — the goal no
+             * longer names it, the check that would prove it did not run at this tree,
+             * or the environment did not qualify — then the work is integrated and its
+             * requirements are not established, and closing the pursuit `satisfied`
+             * would be the claim the charter forbids.
+             *
+             * ⚠️ NOTHING IS REVERTED AND NOTHING IS FROZEN. The work stays published;
+             * what is withheld is the CLOSURE. The grant stays open, the ordinal is
+             * unspent, and a person is told which requirement is missing which
+             * evidence — re-examined next cadence.
+             *
+             * ⚠️ AND IT CANNOT FIRE ON A PROJECT THAT HOLDS NO CLAIMS. `requirements`
+             * is absent there, and an empty receipt has nothing stale and nothing
+             * refused. A mandatory requirement NOBODY claimed is not this branch's
+             * business: `coverageGate` blocks that with `no-requirement-receipt`,
+             * which is the gate that exists for it. A lane-side hold that fired
+             * whenever a project had no claims would be the reverted-safeguard shape
+             * this lane already measured once.
+             */
+            if (publication.requirements !== undefined) {
+                const r = publication.requirements;
+                if (r.stale !== null) {
+                    return {
+                        hold: `met at this version and integrated at ${publication.sha}, but the requirement claims cannot ` +
+                            `speak for it — ${(0, core_1.describeStaleness)(r.stale)}`,
+                    };
+                }
+                if (r.refused.length > 0) {
+                    const named = r.refused.slice(0, MAX_NAMED_REFUSALS).map(core_1.describeIntegratedRefusal).join('; ');
+                    const rest = r.refused.length - MAX_NAMED_REFUSALS;
+                    return {
+                        hold: `met at this version and integrated at ${publication.sha}, but ${r.refused.length} requirement ` +
+                            `claim(s) were not accepted on that revision: ${named}${rest > 0 ? ` (and ${rest} more)` : ''}`,
+                    };
+                }
+            }
+            /**
+             * 🔴 THE FOURTH KEY, WHERE THE CHARTER PUTS IT (F25). Programme mode judges the goal's
+             * strict coverage on the integrated tree (`withLaneCoverage`); a goal whose
+             * mandatory requirements are not all covered there is integrated but NOT satisfied —
+             * a hold, re-examined next cadence, so a dependent keeps waiting. `unavailable` holds
+             * too: coverage that could not be judged is not coverage.
+             */
+            /**
+             * F31 (soun-1): A PROGRAMME PUBLICATION WITH NO COVERAGE VERDICT IS A WIRING FAULT, and it
+             * holds. The worker defers its fourth key to the lane under programme mode; a third key that
+             * came back without the lane's verdict would otherwise close the goal on the run's word.
+             */
+            if (publication.coverage === undefined && publication.rejudge === true) {
+                return {
+                    hold: `met at this version and integrated at ${publication.sha}, but no requirement coverage was judged for it`,
+                };
+            }
+            if (publication.coverage !== undefined) {
+                if (publication.coverage.kind === 'unavailable') {
+                    return {
+                        hold: `met at this version and integrated at ${publication.sha}, but its requirement coverage could not be judged — ${publication.coverage.because}`,
+                    };
+                }
+                if (!publication.coverage.result.ok) {
+                    return {
+                        hold: `met at this version and integrated at ${publication.sha}, but on the integrated tree ` +
+                            ((0, core_1.describeCoverageBlock)(publication.coverage.result) ?? 'a mandatory requirement is not covered'),
+                    };
+                }
+            }
+            return {
+                state: 'satisfied',
+                because: `the goal was met at this version and its work was integrated at ${publication.sha}`,
+            };
+        case 'pending':
+            return { hold: `met at this version; awaiting integration of ${publication.branch}` };
+        case 'refused':
+            // A rebase is work only a new Start can do: it cuts from the moved base,
+            // re-compiles and re-implements. A red gate is a person's to read.
+            //
+            // 🔴 AND ONLY A START THAT JUDGES THE MOVED BASE DOES THAT (F27, corr-6). Anywhere else the
+            // new Start judged the same refused tree, said "met" again, and bought the next — every
+            // Start of the grant spent in a loop. So outside a programme a rebase HOLDS for a person.
+            return publication.rebase && publication.rejudge === true
+                ? { next: `met at this version; the lane refused ${publication.branch}: ${publication.because}` }
+                : {
+                    hold: `met at this version; the lane refused ${publication.branch}: ${publication.because}` +
+                        (publication.rebase ? ' — a new Start here would judge the same refused tree, so re-cutting it is a person\'s call' : ''),
+                };
+        case 'unknown':
+            return {
+                hold: publication.branch === undefined
+                    ? 'met at this version; the run named no branch, so its publication cannot be shown'
+                    : `met at this version; ${publication.branch} cannot be shown published`,
+            };
+        default: {
+            const never = publication;
+            throw new Error(`no controller decision for publication ${String(never)}`);
+        }
+    }
+}
+function decideControllerRefusal(code, facts) {
+    // M5-2: with the third key in hand, a met goal is decided by the lane, not by
+    // the run alone. Every other code — and every call without the facts — is
+    // the table below, unchanged.
+    if (facts !== undefined && code === 'goal_satisfied')
+        return decideThirdKey(facts.publication);
+    switch (code) {
+        case 'goal_satisfied':
+            // Both keys turned inside the Start. The controller does not re-check —
+            // it has no evaluator and no KEY 2 — it reports what the Start decided.
+            return { state: 'satisfied', because: 'the goal was met at this version' };
+        case 'human_required':
+            return { state: 'human_required', because: 'only a person can move this forward' };
+        case 'adaptive_budget_exhausted':
+            // NOT the Start budget. The plan was rethought as often as one version
+            // allows and the goal is still unmet; the grant may have Starts left, and
+            // recording the wrong reason would tell a person they had run out of
+            // something they had not.
+            return {
+                state: 'human_required',
+                because: 'the plan was rethought as often as this version allows and the goal is still unmet',
+            };
+        case 'goal_superseded':
+            return { state: 'superseded', because: 'the goal moved to a later version' };
+        case 'goal_abandoned':
+            return { state: 'abandoned', because: 'the goal was given up on' };
+        case 'evaluator_repository_changed':
+            // A safety stop. The evaluator may have written to the tree, and this
+            // machine cannot tell whether it did or a person did. Retrying would
+            // repeat the breach if it was the evaluator.
+            return {
+                state: 'human_required',
+                because: 'the repository changed while the goal was being evaluated',
+            };
+        case 'coverage_incomplete':
+            /**
+             * 🔴 NOT `satisfied`, AND THAT IS THE ENTIRE POINT OF D3.
+             *
+             * The work was delivered and checked — both keys inside the Start turned.
+             * What did not turn is the fourth: a MANDATORY requirement the goal named
+             * is not covered. Recording this as `satisfied` would let the controller
+             * close a pursuit on exactly the claim charter §5 decision 3 forbids.
+             *
+             * `human_required` rather than a retry, because the two ways forward —
+             * more work, or a person attesting what is already there — are both
+             * decisions this controller must not take on its own. The refusal names
+             * which requirements and why each one, so the person is not left guessing.
+             */
+            return {
+                state: 'human_required',
+                because: 'the work was delivered, but a mandatory requirement this goal names is not covered',
+            };
+        case 'run_refused':
+            // Deliberately not a claim about the goal. Three unrelated situations
+            // produce it, and none of them is "finished" — a person should look.
+            return { state: 'human_required', because: 'the run refused and did not say the goal was met' };
+        default: {
+            const never = code;
+            throw new Error(`no controller decision for refusal code ${String(never)}`);
+        }
+    }
+}
+/**
+ * ONE TICK. ONE ACTION.
+ *
+ * The order of the questions is the safety argument:
+ *
+ *   Local terminal truth first, so a machine that already knows the pursuit is
+ *   over stops without asking anybody's permission to stop.
+ *
+ *   Then the clock, which the machine owns a copy of and can check offline.
+ *
+ *   Then whatever is already in progress — because reading progress needs no
+ *   authority, and because acting on a Start that already exists is never
+ *   spending anything new.
+ *
+ *   Only then reconciliation, which gates everything that COSTS: reserving an
+ *   ordinal and executing one. A person can cancel between a reservation and
+ *   its execution, so both are gated, not just the first.
+ */
+function decideAutonomyTick(facts) {
+    if (facts.localState !== 'authorized') {
+        // Over locally. The only thing left is telling the server, and only if it
+        // has not already been told — a projection that kept retrying against a
+        // server that agrees would be a tick that never goes quiet.
+        if (facts.endingRecorded !== true) {
+            if (facts.serverKnowsItEnded === false) {
+                return {
+                    kind: 'project-terminal',
+                    state: facts.localState,
+                    because: `this pursuit ended as ${facts.localState}`,
+                };
+            }
+            if (facts.serverKnowsItEnded === true) {
+                // IT GOT THERE FIRST. Perhaps a person cancelled while this machine was
+                // deciding it was satisfied; perhaps an earlier report arrived and its
+                // answer was lost. Either way there is nothing left to tell anybody,
+                // and the local conclusion is left exactly as it was — what this
+                // machine concluded is history, and rewriting it to match would erase
+                // what actually happened here.
+                return {
+                    kind: 'accept-server-ending',
+                    state: facts.localState,
+                    because: `the server already knows this pursuit ended`,
+                };
+            }
+        }
+        return { kind: 'wait', because: `this pursuit is already ${facts.localState}` };
+    }
+    // The machine's own copy of the ceiling. Checked before the server is asked
+    // so that an expired grant stops even with the network down.
+    const expires = Date.parse(facts.expiresAt);
+    if (Number.isNaN(expires)) {
+        return { kind: 'hold', because: 'the expiry on this grant cannot be read' };
+    }
+    if (expires <= facts.now) {
+        return {
+            kind: 'terminal',
+            state: 'budget_exhausted',
+            because: 'the time this grant was given has run out',
+        };
+    }
+    // A BUDGET THAT CANNOT BE BELIEVED CANNOT BOUND ANYTHING.
+    //
+    // Checked before anything is spent and before anything is waited for: a
+    // forged or mutilated receipt is the one condition where carrying on would
+    // mean spending a person's Starts against a count that is not theirs. Waiting
+    // would not help — the bytes will not change — so this stops and says so.
+    if (facts.recordsDamaged !== undefined) {
+        return {
+            kind: 'terminal',
+            state: 'human_required',
+            because: `the record of what this grant has spent cannot be trusted — ${facts.recordsDamaged}`,
+        };
+    }
+    const ordinal = facts.unfinished[0];
+    // ── something is already under way ────────────────────────────────────────
+    if (ordinal !== undefined) {
+        const progress = facts.attempt;
+        if (progress === undefined) {
+            return { kind: 'hold', because: `nothing is known about Start ${ordinal}` };
+        }
+        switch (progress.kind) {
+            case 'unreadable':
+                // WEATHER, NOT DAMAGE. Something else is holding the file — an
+                // antivirus scanner, the search indexer, a backup agent — which on
+                // Windows is ordinary and clears in milliseconds. The bytes are not
+                // accused of anything, so nothing is concluded: no Start, no
+                // reservation, and above all no terminal. A pursuit ended over a
+                // file lock would be gone by the time the person read the message.
+                return { kind: 'hold', because: progress.because };
+            case 'corrupt':
+                // Never repaired, never guessed around. The receipts are the budget.
+                return {
+                    kind: 'terminal',
+                    state: 'human_required',
+                    because: `the record of Start ${ordinal} cannot be trusted — ${progress.because}`,
+                };
+            case 'active':
+                // Somebody is working, or might be. `unknown` lands here too: a pid
+                // this machine cannot probe is not evidence of death, and a second
+                // executor started on a guess is the failure 6D2B exists to prevent.
+                return {
+                    kind: 'wait',
+                    because: `attempt ${progress.attempt} of Start ${ordinal} is ${progress.liveness}`,
+                };
+            case 'run-started': {
+                // The Start did its one job. Whether the RUN has ended is a local
+                // question and needs no server.
+                const ended = facts.runEnded;
+                if (ended === undefined)
+                    return { kind: 'hold', because: 'the run was not looked up' };
+                if (!ended.ok)
+                    return { kind: 'hold', because: ended.because };
+                if (!ended.ended) {
+                    return { kind: 'wait', because: `run ${progress.runId} is still going` };
+                }
+                // The ONLY advance signal. Not a free lease, not a vanished child, not
+                // an acked command — a durable ending for this run.
+                return { kind: 'finish-ordinal', ordinal, runId: progress.runId };
+            }
+            case 'refused': {
+                // M5-2: with the third key in hand (`facts.publication`, supplied only
+                // when the caller integrates for itself), a met goal is `satisfied`
+                // only once the lane has PUBLISHED the run's branch. Until then the
+                // grant is held — re-examined next cadence, nothing spent — or, when
+                // the lane wants a rebase, this Start closes so the next one cuts
+                // from the moved base. Without the facts: today's mapping, byte for byte.
+                const decided = decideControllerRefusal(progress.code, facts.publication === undefined ? undefined : { publication: facts.publication });
+                if ('hold' in decided)
+                    return { kind: 'wait', because: decided.hold };
+                if ('next' in decided)
+                    return { kind: 'finish-ordinal', ordinal, runId: '' };
+                if ((0, core_1.isContinuableRefusal)(progress.code)) {
+                    // Continuable means this Start is over and the pursuit is not. The
+                    // ordinal still closes; a LATER tick reserves the next one, because
+                    // one tick is one transition.
+                    return { kind: 'finish-ordinal', ordinal, runId: '' };
+                }
+                return {
+                    kind: 'terminal',
+                    state: decided.state,
+                    because: decided.because,
+                    code: progress.code,
+                };
+            }
+            case 'exhausted':
+                // Three claimed attempts and not one durable outcome. Something about
+                // this machine is stopping the work from starting, and three more
+                // spawns would not find out what.
+                return {
+                    kind: 'terminal',
+                    state: 'human_required',
+                    because: `Start ${ordinal} was attempted ${progress.attempts} times and never began`,
+                };
+            case 'none':
+            case 'retryable': {
+                // The one place a reserved ordinal is actually executed — and it is
+                // gated on the server just as reserving is. A person can cancel
+                // between a reservation and its execution, and the budget being
+                // already spent is not permission to spend their evening too.
+                const gate = gateOn(facts.reconciliation, facts.humanHold, facts.approvalGate, facts.loopSafety, facts.programme === true);
+                if (gate)
+                    return gate;
+                const attempt = progress.kind === 'none' ? 1 : progress.nextAttempt;
+                return {
+                    kind: 'execute-attempt',
+                    ordinal,
+                    requestId: facts.requestIdFor(ordinal),
+                    attempt,
+                    // Programme mode: a gate that would have held, and did not, is a
+                    // decision this Start continues from. The tick reads which.
+                    ...(facts.programme === true &&
+                        facts.approvalGate !== undefined &&
+                        (0, core_1.approvalHold)(facts.approvalGate) !== null &&
+                        (0, core_1.continuationHold)(facts.approvalGate) === null
+                        ? { fromDecision: true }
+                        : {}),
+                };
+            }
+            default: {
+                const never = progress;
+                throw new Error(`no controller decision for progress ${String(never)}`);
+            }
+        }
+    }
+    // ── nothing under way: may another Start be bought? ───────────────────────
+    if (facts.startsConsumed >= facts.maxStarts) {
+        return {
+            kind: 'terminal',
+            state: 'budget_exhausted',
+            because: `all ${facts.maxStarts} Starts of this grant have been spent`,
+        };
+    }
+    const gate = gateOn(facts.reconciliation, facts.humanHold, facts.approvalGate, facts.loopSafety, facts.programme === true);
+    if (gate)
+        return gate;
+    return { kind: 'reserve-ordinal', ordinal: facts.startsConsumed + 1 };
+}
+/**
+ * Whether the server currently permits spending anything, or why not.
+ *
+ * Returns the action to take INSTEAD, or null when the way is clear. Written
+ * once and used by both spending paths so that reserving and executing can
+ * never come to different conclusions about the same answer.
+ */
+function gateOn(r, hold, approval, loopSafety, programme = false) {
+    /**
+     * HUMAN AUTHORITY FIRST, and reported ahead of a person's own pause.
+     *
+     * Both hold, so nothing about safety turns on the order. What turns on it is
+     * which sentence a person is shown, and this one is the more useful: a pause
+     * is cleared by resuming, and an outstanding approval is still there
+     * afterwards. Saying "paused" while the real blocker survives the resume
+     * would send somebody to press a button that changes nothing.
+     *
+     * EVERY ARM BUT `none` HOLDS, including the answered ones. A person who
+     * denied a deployment has not authorised this machine to spend their night
+     * trying something else — resuming is their next act, not a consequence of
+     * their last one. `approvalHold` is where that is decided, once.
+     */
+    /**
+     * BUT A GRANT THE SERVER HAS ALREADY ENDED IS OVER, HELD OR NOT (M6-4).
+     *
+     * Every arm below holds, and the holds are ordered by which sentence a
+     * person should see. An ending is not a hold: the server has already said
+     * this pursuit is finished — a person cancelled it on the phone, the goal
+     * was met, the budget ran out, the goal moved on — and no pause, stop or
+     * open question can make it live again. Answering the holds first was
+     * observed live (M6-3): a grant cancelled on the phone stayed `authorized`
+     * on the machine, and in `looply goal`, until somebody tapped resume,
+     * because the stop was answered before the server was looked at. Nothing
+     * could be spent meanwhile, so what was wrong was the record, not the
+     * spending — and the record is what the person reads.
+     *
+     * `unreachable` is NOT an ending and stays below: a person who paused
+     * should hear "paused" when the server merely cannot be reached. A version
+     * `mismatch` stays below too (a stated limit of M6-4, not a decision).
+     */
+    if (r.kind === 'ended')
+        return gateOnServer(r);
+    // PROGRAMME MODE, slice 1 (M6-7): under the opt-in the question is core's
+    // `continuationHold` — a valid decision does not hold — instead of
+    // `approvalHold`. Both are conclusions; this reducer keeps no vocabulary.
+    const outstanding = approval === undefined ? null : programme ? (0, core_1.continuationHold)(approval) : (0, core_1.approvalHold)(approval);
+    if (outstanding !== null) {
+        // NOT terminal, whatever the answer was. Even a denial leaves the pursuit
+        // alive: a grant ended here could not be resumed, and the person has
+        // refused one action rather than the whole night.
+        return { kind: 'hold', because: outstanding };
+    }
+    if (hold !== undefined) {
+        // NOT terminal. A person who paused may resume, and a grant ended here
+        // could not be resumed — they would have to authorize the whole thing
+        // again, having only asked the machine to wait.
+        //
+        // It gates BOTH spending paths, like every other gate here: an ordinal
+        // already bought is not permission to run it, because the tap that stopped
+        // things may have landed between the two.
+        return {
+            kind: 'hold',
+            because: hold.kind === 'stop'
+                ? `stopped${hold.actor ? ` by ${hold.actor}` : ''} — waiting for a person to resume`
+                : `paused${hold.actor ? ` by ${hold.actor}` : ''} — waiting for a person to resume`,
+        };
+    }
+    /**
+     * AND FINALLY: HAS REPEATING STOPPED BEING WORTH ANYTHING?
+     *
+     * Reported AFTER the two human authorities and before the server, and the
+     * order is about which sentence a person is shown rather than about safety —
+     * every arm here holds. A person who paused, or who has been asked a
+     * question, should hear about that first: those are things they can act on
+     * now, and a stuck detector's explanation is still true afterwards.
+     *
+     * NOT terminal, and that is the whole distinction the phase rests on. A
+     * safety hold is not a Goal failure and not a Goal completion: the pursuit
+     * stays alive, and one explicit Start from a person spends it. Ending the
+     * grant here would turn "this is not working" into "you may never try again".
+     */
+    if (loopSafety?.held === true) {
+        return { kind: 'hold', because: loopSafety.because };
+    }
+    return gateOnServer(r);
+}
+function gateOnServer(r) {
+    switch (r.kind) {
+        case 'active':
+            return null;
+        case 'ended':
+            // A person cancelled, the goal moved on, or it was given up. The machine
+            // stops locally now rather than waiting for a later projection to
+            // rediscover a fact it has already been told.
+            return { kind: 'terminal', state: r.state, because: r.because };
+        case 'mismatch':
+            // The server is describing a different grant than the one this machine
+            // holds. Not something to pick a side of.
+            return { kind: 'terminal', state: 'human_required', because: r.because };
+        case 'unreachable':
+            // NOT terminal. No new Start without current authorization, and no
+            // budget spent on a reservation that was never permitted.
+            return { kind: 'hold', because: r.because };
+        default: {
+            const never = r;
+            throw new Error(`no controller decision for reconciliation ${String(never)}`);
+        }
+    }
+}
+//# sourceMappingURL=autonomy-controller.js.map

package/dist/autonomy-controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"autonomy-controller.js","sourceRoot":"","sources":["../src/autonomy-controller.ts"],"names":[],"mappings":";;AAkaA,0DA4DC;AAoBD,gDA8LC;AAhrBD,uCAWsB;AAkOtB;;;;GAIG;AACH,oFAAoF;AACpF,MAAM,kBAAkB,GAAG,CAAC,CAAC;AAE7B,SAAS,cAAc,CAAC,WAAwB;IAC9C,QAAQ,WAAW,CAAC,IAAI,EAAE,CAAC;QACzB,KAAK,WAAW;YACd;;;;;;;;;;;;;;;;;;;eAmBG;YACH;;;;;eAKG;YACH,IAAI,WAAW,CAAC,UAAU,KAAK,SAAS,IAAI,WAAW,CAAC,aAAa,KAAK,WAAW,CAAC,GAAG,EAAE,CAAC;gBAC1F,MAAM,IAAI,GACR,yCAAyC,WAAW,CAAC,GAAG,uCAAuC;oBAC/F,8BAA8B,WAAW,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;gBACjE,OAAO,WAAW,CAAC,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,IAAI,qCAAqC,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;YAChH,CAAC;YACD;;;;;;;;;;;;;;;;;;;;;;;eAuBG;YACH,IAAI,WAAW,CAAC,YAAY,KAAK,SAAS,EAAE,CAAC;gBAC3C,MAAM,CAAC,GAAG,WAAW,CAAC,YAAY,CAAC;gBACnC,IAAI,CAAC,CAAC,KAAK,KAAK,IAAI,EAAE,CAAC;oBACrB,OAAO;wBACL,IAAI,EACF,yCAAyC,WAAW,CAAC,GAAG,sCAAsC;4BAC9F,kBAAkB,IAAA,wBAAiB,EAAC,CAAC,CAAC,KAAK,CAAC,EAAE;qBACjD,CAAC;gBACJ,CAAC;gBACD,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACzB,MAAM,KAAK,GAAG,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,kBAAkB,CAAC,CAAC,GAAG,CAAC,gCAAyB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;oBAC/F,MAAM,IAAI,GAAG,CAAC,CAAC,OAAO,CAAC,MAAM,GAAG,kBAAkB,CAAC;oBACnD,OAAO;wBACL,IAAI,EACF,yCAAyC,WAAW,CAAC,GAAG,SAAS,CAAC,CAAC,OAAO,CAAC,MAAM,eAAe;4BAChG,gDAAgD,KAAK,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,IAAI,QAAQ,CAAC,CAAC,CAAC,EAAE,EAAE;qBAClG,CAAC;gBACJ,CAAC;YACH,CAAC;YACD;;;;;;eAMG;YACH;;;;eAIG;YACH,IAAI,WAAW,CAAC,QAAQ,KAAK,SAAS,IAAI,WAAW,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;gBACvE,OAAO;oBACL,IAAI,EAAE,yCAAyC,WAAW,CAAC,GAAG,iDAAiD;iBAChH,CAAC;YACJ,CAAC;YACD,IAAI,WAAW,CAAC,QAAQ,KAAK,SAAS,EAAE,CAAC;gBACvC,IAAI,WAAW,CAAC,QAAQ,CAAC,IAAI,KAAK,aAAa,EAAE,CAAC;oBAChD,OAAO;wBACL,IAAI,EAAE,yCAAyC,WAAW,CAAC,GAAG,wDAAwD,WAAW,CAAC,QAAQ,CAAC,OAAO,EAAE;qBACrJ,CAAC;gBACJ,CAAC;gBACD,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,EAAE,CAAC;oBACpC,OAAO;wBACL,IAAI,EACF,yCAAyC,WAAW,CAAC,GAAG,+BAA+B;4BACvF,CAAC,IAAA,4BAAqB,EAAC,WAAW,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,wCAAwC,CAAC;qBACnG,CAAC;gBACJ,CAAC;YACH,CAAC;YACD,OAAO;gBACL,KAAK,EAAE,WAAW;gBAClB,OAAO,EAAE,mEAAmE,WAAW,CAAC,GAAG,EAAE;aAC9F,CAAC;QACJ,KAAK,SAAS;YACZ,OAAO,EAAE,IAAI,EAAE,gDAAgD,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC;QACxF,KAAK,SAAS;YACZ,yEAAyE;YACzE,mEAAmE;YACnE,EAAE;YACF,4FAA4F;YAC5F,wFAAwF;YACxF,0FAA0F;YAC1F,OAAO,WAAW,CAAC,MAAM,IAAI,WAAW,CAAC,OAAO,KAAK,IAAI;gBACvD,CAAC,CAAC,EAAE,IAAI,EAAE,yCAAyC,WAAW,CAAC,MAAM,KAAK,WAAW,CAAC,OAAO,EAAE,EAAE;gBACjG,CAAC,CAAC;oBACE,IAAI,EACF,yCAAyC,WAAW,CAAC,MAAM,KAAK,WAAW,CAAC,OAAO,EAAE;wBACrF,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,6FAA6F,CAAC,CAAC,CAAC,EAAE,CAAC;iBAC5H,CAAC;QACR,KAAK,SAAS;YACZ,OAAO;gBACL,IAAI,EACF,WAAW,CAAC,MAAM,KAAK,SAAS;oBAC9B,CAAC,CAAC,kFAAkF;oBACpF,CAAC,CAAC,wBAAwB,WAAW,CAAC,MAAM,4BAA4B;aAC7E,CAAC;QACJ,OAAO,CAAC,CAAC,CAAC;YACR,MAAM,KAAK,GAAU,WAAW,CAAC;YACjC,MAAM,IAAI,KAAK,CAAC,0CAA0C,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QAC7E,CAAC;IACH,CAAC;AACH,CAAC;AAgCD,SAAgB,uBAAuB,CAAC,IAAoB,EAAE,KAAgB;IAC5E,8EAA8E;IAC9E,0EAA0E;IAC1E,8BAA8B;IAC9B,IAAI,KAAK,KAAK,SAAS,IAAI,IAAI,KAAK,gBAAgB;QAAE,OAAO,cAAc,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC;IAC/F,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,gBAAgB;YACnB,wEAAwE;YACxE,wEAAwE;YACxE,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,kCAAkC,EAAE,CAAC;QAC7E,KAAK,gBAAgB;YACnB,OAAO,EAAE,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,qCAAqC,EAAE,CAAC;QACrF,KAAK,2BAA2B;YAC9B,uEAAuE;YACvE,0EAA0E;YAC1E,qEAAqE;YACrE,0BAA0B;YAC1B,OAAO;gBACL,KAAK,EAAE,gBAAgB;gBACvB,OAAO,EAAE,oFAAoF;aAC9F,CAAC;QACJ,KAAK,iBAAiB;YACpB,OAAO,EAAE,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,mCAAmC,EAAE,CAAC;QAC/E,KAAK,gBAAgB;YACnB,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,0BAA0B,EAAE,CAAC;QACrE,KAAK,8BAA8B;YACjC,sEAAsE;YACtE,qEAAqE;YACrE,6CAA6C;YAC7C,OAAO;gBACL,KAAK,EAAE,gBAAgB;gBACvB,OAAO,EAAE,2DAA2D;aACrE,CAAC;QACJ,KAAK,qBAAqB;YACxB;;;;;;;;;;;;eAYG;YACH,OAAO;gBACL,KAAK,EAAE,gBAAgB;gBACvB,OAAO,EAAE,oFAAoF;aAC9F,CAAC;QACJ,KAAK,aAAa;YAChB,sEAAsE;YACtE,qEAAqE;YACrE,OAAO,EAAE,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,kDAAkD,EAAE,CAAC;QAClG,OAAO,CAAC,CAAC,CAAC;YACR,MAAM,KAAK,GAAU,IAAI,CAAC;YAC1B,MAAM,IAAI,KAAK,CAAC,2CAA2C,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QAC9E,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,kBAAkB,CAAC,KAAsB;IACvD,IAAI,KAAK,CAAC,UAAU,KAAK,YAAY,EAAE,CAAC;QACtC,0EAA0E;QAC1E,wEAAwE;QACxE,4DAA4D;QAC5D,IAAI,KAAK,CAAC,cAAc,KAAK,IAAI,EAAE,CAAC;YAClC,IAAI,KAAK,CAAC,kBAAkB,KAAK,KAAK,EAAE,CAAC;gBACvC,OAAO;oBACL,IAAI,EAAE,kBAAkB;oBACxB,KAAK,EAAE,KAAK,CAAC,UAAU;oBACvB,OAAO,EAAE,yBAAyB,KAAK,CAAC,UAAU,EAAE;iBACrD,CAAC;YACJ,CAAC;YACD,IAAI,KAAK,CAAC,kBAAkB,KAAK,IAAI,EAAE,CAAC;gBACtC,wEAAwE;gBACxE,uEAAuE;gBACvE,qEAAqE;gBACrE,iEAAiE;gBACjE,sEAAsE;gBACtE,+BAA+B;gBAC/B,OAAO;oBACL,IAAI,EAAE,sBAAsB;oBAC5B,KAAK,EAAE,KAAK,CAAC,UAAU;oBACvB,OAAO,EAAE,6CAA6C;iBACvD,CAAC;YACJ,CAAC;QACH,CAAC;QACD,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,2BAA2B,KAAK,CAAC,UAAU,EAAE,EAAE,CAAC;IAClF,CAAC;IAED,4EAA4E;IAC5E,6DAA6D;IAC7D,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;IAC5C,IAAI,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;QAC1B,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,yCAAyC,EAAE,CAAC;IAC9E,CAAC;IACD,IAAI,OAAO,IAAI,KAAK,CAAC,GAAG,EAAE,CAAC;QACzB,OAAO;YACL,IAAI,EAAE,UAAU;YAChB,KAAK,EAAE,kBAAkB;YACzB,OAAO,EAAE,2CAA2C;SACrD,CAAC;IACJ,CAAC;IAED,0DAA0D;IAC1D,EAAE;IACF,wEAAwE;IACxE,2EAA2E;IAC3E,8EAA8E;IAC9E,0EAA0E;IAC1E,IAAI,KAAK,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;QACvC,OAAO;YACL,IAAI,EAAE,UAAU;YAChB,KAAK,EAAE,gBAAgB;YACvB,OAAO,EAAE,+DAA+D,KAAK,CAAC,cAAc,EAAE;SAC/F,CAAC;IACJ,CAAC;IAED,MAAM,OAAO,GAAG,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IAEpC,6EAA6E;IAC7E,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC;QAC/B,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,gCAAgC,OAAO,EAAE,EAAE,CAAC;QAC9E,CAAC;QAED,QAAQ,QAAQ,CAAC,IAAI,EAAE,CAAC;YACtB,KAAK,YAAY;gBACf,+DAA+D;gBAC/D,mEAAmE;gBACnE,oEAAoE;gBACpE,6DAA6D;gBAC7D,iEAAiE;gBACjE,mEAAmE;gBACnE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAC,OAAO,EAAE,CAAC;YAErD,KAAK,SAAS;gBACZ,qEAAqE;gBACrE,OAAO;oBACL,IAAI,EAAE,UAAU;oBAChB,KAAK,EAAE,gBAAgB;oBACvB,OAAO,EAAE,uBAAuB,OAAO,wBAAwB,QAAQ,CAAC,OAAO,EAAE;iBAClF,CAAC;YAEJ,KAAK,QAAQ;gBACX,oEAAoE;gBACpE,mEAAmE;gBACnE,qEAAqE;gBACrE,OAAO;oBACL,IAAI,EAAE,MAAM;oBACZ,OAAO,EAAE,WAAW,QAAQ,CAAC,OAAO,aAAa,OAAO,OAAO,QAAQ,CAAC,QAAQ,EAAE;iBACnF,CAAC;YAEJ,KAAK,aAAa,CAAC,CAAC,CAAC;gBACnB,kEAAkE;gBAClE,gCAAgC;gBAChC,MAAM,KAAK,GAAG,KAAK,CAAC,QAAQ,CAAC;gBAC7B,IAAI,KAAK,KAAK,SAAS;oBAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,2BAA2B,EAAE,CAAC;gBACvF,IAAI,CAAC,KAAK,CAAC,EAAE;oBAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC;gBAC/D,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;oBACjB,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,QAAQ,CAAC,KAAK,iBAAiB,EAAE,CAAC;gBAC3E,CAAC;gBACD,uEAAuE;gBACvE,oDAAoD;gBACpD,OAAO,EAAE,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,KAAK,EAAE,CAAC;YACpE,CAAC;YAED,KAAK,SAAS,CAAC,CAAC,CAAC;gBACf,uEAAuE;gBACvE,oEAAoE;gBACpE,oEAAoE;gBACpE,qEAAqE;gBACrE,kEAAkE;gBAClE,0EAA0E;gBAC1E,MAAM,OAAO,GAAG,uBAAuB,CACrC,QAAQ,CAAC,IAAI,EACb,KAAK,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,KAAK,CAAC,WAAW,EAAE,CACjF,CAAC;gBACF,IAAI,MAAM,IAAI,OAAO;oBAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,IAAI,EAAE,CAAC;gBACtE,IAAI,MAAM,IAAI,OAAO;oBAAE,OAAO,EAAE,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;gBAC7E,IAAI,IAAA,2BAAoB,EAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC;oBACxC,mEAAmE;oBACnE,oEAAoE;oBACpE,8BAA8B;oBAC9B,OAAO,EAAE,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;gBACxD,CAAC;gBACD,OAAO;oBACL,IAAI,EAAE,UAAU;oBAChB,KAAK,EAAE,OAAO,CAAC,KAAK;oBACpB,OAAO,EAAE,OAAO,CAAC,OAAO;oBACxB,IAAI,EAAE,QAAQ,CAAC,IAAI;iBACpB,CAAC;YACJ,CAAC;YAED,KAAK,WAAW;gBACd,sEAAsE;gBACtE,kEAAkE;gBAClE,kCAAkC;gBAClC,OAAO;oBACL,IAAI,EAAE,UAAU;oBAChB,KAAK,EAAE,gBAAgB;oBACvB,OAAO,EAAE,SAAS,OAAO,kBAAkB,QAAQ,CAAC,QAAQ,wBAAwB;iBACrF,CAAC;YAEJ,KAAK,MAAM,CAAC;YACZ,KAAK,WAAW,CAAC,CAAC,CAAC;gBACjB,oEAAoE;gBACpE,gEAAgE;gBAChE,gEAAgE;gBAChE,8DAA8D;gBAC9D,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,cAAc,EAAE,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,YAAY,EAAE,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,SAAS,KAAK,IAAI,CAAC,CAAC;gBAC3H,IAAI,IAAI;oBAAE,OAAO,IAAI,CAAC;gBACtB,MAAM,OAAO,GAAG,QAAQ,CAAC,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC;gBACpE,OAAO;oBACL,IAAI,EAAE,iBAAiB;oBACvB,OAAO;oBACP,SAAS,EAAE,KAAK,CAAC,YAAY,CAAC,OAAO,CAAC;oBACtC,OAAO;oBACP,iEAAiE;oBACjE,4DAA4D;oBAC5D,GAAG,CAAC,KAAK,CAAC,SAAS,KAAK,IAAI;wBAC5B,KAAK,CAAC,YAAY,KAAK,SAAS;wBAChC,IAAA,mBAAY,EAAC,KAAK,CAAC,YAAY,CAAC,KAAK,IAAI;wBACzC,IAAA,uBAAgB,EAAC,KAAK,CAAC,YAAY,CAAC,KAAK,IAAI;wBAC3C,CAAC,CAAC,EAAE,YAAY,EAAE,IAAa,EAAE;wBACjC,CAAC,CAAC,EAAE,CAAC;iBACR,CAAC;YACJ,CAAC;YAED,OAAO,CAAC,CAAC,CAAC;gBACR,MAAM,KAAK,GAAU,QAAQ,CAAC;gBAC9B,MAAM,IAAI,KAAK,CAAC,uCAAuC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YAC1E,CAAC;QACH,CAAC;IACH,CAAC;IAED,6EAA6E;IAC7E,IAAI,KAAK,CAAC,cAAc,IAAI,KAAK,CAAC,SAAS,EAAE,CAAC;QAC5C,OAAO;YACL,IAAI,EAAE,UAAU;YAChB,KAAK,EAAE,kBAAkB;YACzB,OAAO,EAAE,OAAO,KAAK,CAAC,SAAS,uCAAuC;SACvE,CAAC;IACJ,CAAC;IAED,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,cAAc,EAAE,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,YAAY,EAAE,KAAK,CAAC,UAAU,EAAE,KAAK,CAAC,SAAS,KAAK,IAAI,CAAC,CAAC;IAC3H,IAAI,IAAI;QAAE,OAAO,IAAI,CAAC;IAEtB,OAAO,EAAE,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,KAAK,CAAC,cAAc,GAAG,CAAC,EAAE,CAAC;AACxE,CAAC;AAED;;;;;;GAMG;AACH,SAAS,MAAM,CACb,CAAiB,EACjB,IAAiD,EACjD,QAAuB,EACvB,UAAyF,EACzF,SAAS,GAAG,KAAK;IAEjB;;;;;;;;;;;;;OAaG;IACH;;;;;;;;;;;;;;;;;OAiBG;IACH,IAAI,CAAC,CAAC,IAAI,KAAK,OAAO;QAAE,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC;IAC/C,0EAA0E;IAC1E,mEAAmE;IACnE,0EAA0E;IAC1E,MAAM,WAAW,GAAG,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAA,uBAAgB,EAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAA,mBAAY,EAAC,QAAQ,CAAC,CAAC;IACpH,IAAI,WAAW,KAAK,IAAI,EAAE,CAAC;QACzB,0EAA0E;QAC1E,qEAAqE;QACrE,kDAAkD;QAClD,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,CAAC;IAChD,CAAC;IACD,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACvB,uEAAuE;QACvE,sEAAsE;QACtE,gDAAgD;QAChD,EAAE;QACF,uEAAuE;QACvE,2EAA2E;QAC3E,0CAA0C;QAC1C,OAAO;YACL,IAAI,EAAE,MAAM;YACZ,OAAO,EACL,IAAI,CAAC,IAAI,KAAK,MAAM;gBAClB,CAAC,CAAC,UAAU,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,mCAAmC;gBACpF,CAAC,CAAC,SAAS,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,mCAAmC;SACxF,CAAC;IACJ,CAAC;IACD;;;;;;;;;;;;;OAaG;IACH,IAAI,UAAU,EAAE,IAAI,KAAK,IAAI,EAAE,CAAC;QAC9B,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,CAAC,OAAO,EAAE,CAAC;IACvD,CAAC;IACD,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC;AACzB,CAAC;AAED,SAAS,YAAY,CAAC,CAAiB;IACrC,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;QACf,KAAK,QAAQ;YACX,OAAO,IAAI,CAAC;QACd,KAAK,OAAO;YACV,yEAAyE;YACzE,kEAAkE;YAClE,8CAA8C;YAC9C,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC;QAClE,KAAK,UAAU;YACb,uEAAuE;YACvE,0CAA0C;YAC1C,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC;QAC3E,KAAK,aAAa;YAChB,mEAAmE;YACnE,0DAA0D;YAC1D,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC;QAC9C,OAAO,CAAC,CAAC,CAAC;YACR,MAAM,KAAK,GAAU,CAAC,CAAC;YACvB,MAAM,IAAI,KAAK,CAAC,6CAA6C,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;QAChF,CAAC;IACH,CAAC;AACH,CAAC"}