@stevenvo780/st-lang 4.3.0 → 4.5.0

package/dist/profiles/mu-calculus/wellformed.js

@@ -0,0 +1,160 @@
+"use strict";
+// ============================================================
+// μ-calculus — well-formedness y alternation depth
+// ============================================================
+// Una fórmula μ-cálculo es bien formada cuando:
+//   1. Es "cerrada": cada `var` ligada referencia un `μ`/`ν` que la
+//      envuelve sintácticamente.
+//   2. Es "positiva": cada variable ligada aparece bajo un número PAR
+//      de negaciones desde su binder. Esto garantiza monotonía del
+//      funcional asociado y la existencia de los puntos fijos por
+//      Knaster-Tarski.
+//
+// Alternation depth: máxima profundidad de anidamiento alternante
+// μ/ν con variables libres del binder externo. Aproximación estándar
+// (Niwiński/Emerson-Lei): si el body de un μX contiene νY donde Y
+// depende sintácticamente de X (o viceversa), la profundidad sube.
+// Aquí usamos la versión sintáctica simple: cuento bindings μ/ν
+// distintos en el camino raíz→hoja, contando saltos μ↔ν.
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isWellFormed = isWellFormed;
+exports.freeVars = freeVars;
+exports.isClosed = isClosed;
+exports.isPositive = isPositive;
+exports.alternationDepth = alternationDepth;
+/**
+ * Verifica que una fórmula sea sintácticamente bien formada:
+ *  - Cerrada (sin variables libres).
+ *  - Positiva en cada variable ligada (paridad par de negaciones).
+ *  - Sin shadowing nocivo: rebindings ocultan al outer, lo cual es
+ *    legal pero detectable. Aquí lo permitimos.
+ */
+function isWellFormed(phi) {
+    return isClosed(phi) && isPositive(phi);
+}
+/** Variables libres del término. */
+function freeVars(phi) {
+    const out = new Set();
+    collectFree(phi, new Set(), out);
+    return out;
+}
+function collectFree(phi, bound, out) {
+    switch (phi.kind) {
+        case 'atom':
+            return;
+        case 'var':
+            if (!bound.has(phi.name))
+                out.add(phi.name);
+            return;
+        case 'not':
+            collectFree(phi.arg, bound, out);
+            return;
+        case 'and':
+        case 'or':
+            collectFree(phi.left, bound, out);
+            collectFree(phi.right, bound, out);
+            return;
+        case 'box':
+        case 'diamond':
+            collectFree(phi.arg, bound, out);
+            return;
+        case 'mu':
+        case 'nu': {
+            const nextBound = new Set(bound);
+            nextBound.add(phi.bind);
+            collectFree(phi.body, nextBound, out);
+            return;
+        }
+    }
+}
+/** Una fórmula es cerrada cuando no tiene variables libres. */
+function isClosed(phi) {
+    return freeVars(phi).size === 0;
+}
+/**
+ * Una fórmula es positiva cuando toda `var X` ligada por un μ/ν
+ * aparece bajo un número par de negaciones desde su binder.
+ *
+ * Implementación: caminamos el AST con un map `binder → paridad`
+ * (0 = par, 1 = impar) que se actualiza al cruzar un `not`. Cuando
+ * vemos `var X`, miramos su binder más cercano y verificamos que
+ * su paridad relativa sea par.
+ */
+function isPositive(phi) {
+    return checkPositive(phi, new Map(), 0);
+}
+function checkPositive(phi, parityAt, parityHere) {
+    switch (phi.kind) {
+        case 'atom':
+            return true;
+        case 'var': {
+            const parityAtBinder = parityAt.get(phi.name);
+            if (parityAtBinder === undefined) {
+                // Variable libre: no es responsabilidad de positividad detectarlo.
+                return true;
+            }
+            // Paridad relativa = (parityHere - parityAtBinder) mod 2.
+            return (parityHere - parityAtBinder) % 2 === 0;
+        }
+        case 'not':
+            return checkPositive(phi.arg, parityAt, (parityHere + 1) % 2);
+        case 'and':
+        case 'or':
+            return (checkPositive(phi.left, parityAt, parityHere) &&
+                checkPositive(phi.right, parityAt, parityHere));
+        case 'box':
+        case 'diamond':
+            return checkPositive(phi.arg, parityAt, parityHere);
+        case 'mu':
+        case 'nu': {
+            const next = new Map(parityAt);
+            next.set(phi.bind, parityHere);
+            return checkPositive(phi.body, next, parityHere);
+        }
+    }
+}
+/**
+ * Profundidad de alternancia μ/ν. Métrica clásica:
+ *   ad(p) = ad(X) = 0
+ *   ad(¬φ) = ad(◇φ) = ad(□φ) = ad(φ)
+ *   ad(φ ∧ ψ) = ad(φ ∨ ψ) = max(ad(φ), ad(ψ))
+ *   ad(μX. φ) = max(1, ad(φ), 1 + maxNuAlt(φ))
+ *   ad(νX. φ) = max(1, ad(φ), 1 + maxMuAlt(φ))
+ * donde `maxNuAlt(φ)` es la profundidad considerando solo subfórmulas
+ * con binder ν cuyo cuerpo menciona la variable ligada externamente,
+ * y simétrico para μ.
+ *
+ * Aquí usamos la versión simplificada y muy usada en práctica
+ * (Cleaveland/Steffen): contar el cambio de tipo de binder en el
+ * camino sintáctico raíz→hoja.
+ */
+function alternationDepth(phi) {
+    return computeDepth(phi, null);
+}
+function computeDepth(phi, lastBinder) {
+    switch (phi.kind) {
+        case 'atom':
+        case 'var':
+            return 0;
+        case 'not':
+        case 'box':
+        case 'diamond':
+            return computeDepth(phi.arg, lastBinder);
+        case 'and':
+        case 'or':
+            return Math.max(computeDepth(phi.left, lastBinder), computeDepth(phi.right, lastBinder));
+        case 'mu': {
+            const inner = computeDepth(phi.body, 'mu');
+            // Mismo tipo de binder consecutivo: pertenece al mismo "segmento"
+            // y no aporta alternancia adicional. Cambio (o segmento inicial)
+            // suma 1 nivel al conteo del cuerpo.
+            return lastBinder === 'mu' ? inner : 1 + inner;
+        }
+        case 'nu': {
+            const inner = computeDepth(phi.body, 'nu');
+            return lastBinder === 'nu' ? inner : 1 + inner;
+        }
+    }
+}
+//# sourceMappingURL=wellformed.js.map

package/dist/profiles/mu-calculus/wellformed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wellformed.js","sourceRoot":"","sources":["../../../src/profiles/mu-calculus/wellformed.ts"],"names":[],"mappings":"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"}

package/dist/profiles/sequent-lk/cut-elimination.d.ts

@@ -0,0 +1,11 @@
+import { LKProof } from './types';
+/**
+ * Elimina todos los cortes de la derivacion. Devuelve una derivacion
+ * estructuralmente equivalente al mismo secuente sin nodos `cut`.
+ *
+ * Implementacion: eliminamos primero los cortes interiores (de las
+ * hojas hacia la raiz) y luego reducimos el cut de la raiz aplicando
+ * la regla principal correspondiente.
+ */
+export declare function eliminateCut(proof: LKProof): LKProof;
+//# sourceMappingURL=cut-elimination.d.ts.map

package/dist/profiles/sequent-lk/cut-elimination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cut-elimination.d.ts","sourceRoot":"","sources":["../../../src/profiles/sequent-lk/cut-elimination.ts"],"names":[],"mappings":"AA0BA,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AA+JlC;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAsBpD"}

package/dist/profiles/sequent-lk/cut-elimination.js

@@ -0,0 +1,216 @@
+"use strict";
+// ============================================================
+// LK — Eliminacion de cortes (Hauptsatz de Gentzen, 1934)
+// ============================================================
+//
+// El teorema fundamental dice que toda derivacion LK puede
+// transformarse en una sin cortes. La prueba procede por
+// induccion lexicografica sobre (rango, grado) del cut superior:
+//
+//   * rango = altura del cut en el arbol
+//   * grado = profundidad de la formula cortada
+//
+// La implementacion aqui combina dos estrategias:
+//
+//   1. Reducciones "principales": cuando la formula cortada es
+//      principal en ambas premisas, se aplica la regla de
+//      reduccion correspondiente al conectivo (notable: ∧/∨/→/¬).
+//   2. Reduccion estructural: para casos en que la reescritura
+//      directa no aplica (ej. cuts internos en sub-derivaciones
+//      con weakenings/contractions implicitas), reusamos el
+//      prover cut-free `proveLK` como oraculo: por el Hauptsatz,
+//      si el secuente es derivable con cortes, lo es sin ellos,
+//      y `proveLK` es completo para LK clasico cut-free.
+//
+// El resultado garantiza `hasCut(out) === false` cuando la entrada
+// es valida y derivable.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eliminateCut = eliminateCut;
+const util_1 = require("./util");
+const prover_1 = require("./prover");
+function eliminateCutAtRoot(proof) {
+    if (proof.rule !== 'cut')
+        return proof;
+    const [p1, p2] = proof.premises;
+    if (!p1 || !p2 || !proof.cutFormula)
+        return proof;
+    const A = proof.cutFormula;
+    const ak = (0, util_1.lkKey)(A);
+    // Caso axioma: A ⊢ A   cut   A, Σ ⊢ Π   ⟹   A, Σ ⊢ Π  (= p2)
+    if (p1.rule === 'axiom' && p1.principalFormula && (0, util_1.lkKey)(p1.principalFormula) === ak) {
+        return p2;
+    }
+    if (p2.rule === 'axiom' && p2.principalFormula && (0, util_1.lkKey)(p2.principalFormula) === ak) {
+        return p1;
+    }
+    // Reduccion principal por conectivo del cut formula.
+    // Solo aplicable cuando A es principal en ambas premisas.
+    const principalOnLeft = p1.principalFormula && (0, util_1.lkKey)(p1.principalFormula) === ak;
+    const principalOnRight = p2.principalFormula && (0, util_1.lkKey)(p2.principalFormula) === ak;
+    if (principalOnLeft && principalOnRight) {
+        switch (A.kind) {
+            case 'not': {
+                // p1 termina en notR: Γ ⊢ ¬B, Δ por premisa B, Γ ⊢ Δ
+                // p2 termina en notL: ¬B, Σ ⊢ Π por premisa Σ ⊢ B, Π
+                // Reescribimos como cut sobre B:
+                //   Σ ⊢ B, Π   cut   B, Γ ⊢ Δ   ⟹   Σ, Γ ⊢ Π, Δ
+                const sub1 = p2.premises[0];
+                const sub2 = p1.premises[0];
+                if (!sub1 || !sub2)
+                    break;
+                const newCut = {
+                    goal: proof.goal,
+                    rule: 'cut',
+                    cutFormula: A.arg,
+                    premises: [sub1, sub2],
+                };
+                return eliminateCut(newCut);
+            }
+            case 'and': {
+                // p1 termina en andR con A = B∧C, premisas: Γ ⊢ B, Δ y Γ ⊢ C, Δ
+                // p2 termina en andL con premisa B, C, Σ ⊢ Π
+                // Cut sobre B y C:
+                //   Γ ⊢ B, Δ   cut_B   ( Γ ⊢ C, Δ   cut_C   B, C, Σ ⊢ Π )
+                const subB = p1.premises[0];
+                const subC = p1.premises[1];
+                const subBC = p2.premises[0];
+                if (!subB || !subC || !subBC)
+                    break;
+                const innerCut = {
+                    goal: {
+                        left: [
+                            ...subC.goal.left,
+                            ...subBC.goal.left.filter((f) => (0, util_1.lkKey)(f) !== (0, util_1.lkKey)(A.right)),
+                        ],
+                        right: [
+                            ...subC.goal.right.filter((f) => (0, util_1.lkKey)(f) !== (0, util_1.lkKey)(A.right)),
+                            ...subBC.goal.right,
+                        ],
+                    },
+                    rule: 'cut',
+                    cutFormula: A.right,
+                    premises: [subC, subBC],
+                };
+                const outerCut = {
+                    goal: proof.goal,
+                    rule: 'cut',
+                    cutFormula: A.left,
+                    premises: [subB, innerCut],
+                };
+                return eliminateCut(outerCut);
+            }
+            case 'or': {
+                // p1 termina en orR con A = B∨C, premisa: Γ ⊢ B, C, Δ
+                // p2 termina en orL: premisas B, Σ ⊢ Π y C, Σ ⊢ Π
+                const subBC = p1.premises[0];
+                const subB = p2.premises[0];
+                const subC = p2.premises[1];
+                if (!subBC || !subB || !subC)
+                    break;
+                // Cut sobre B y luego C:
+                const innerCut = {
+                    goal: {
+                        left: [
+                            ...subBC.goal.left,
+                            ...subC.goal.left.filter((f) => (0, util_1.lkKey)(f) !== (0, util_1.lkKey)(A.right)),
+                        ],
+                        right: [
+                            ...subBC.goal.right.filter((f) => (0, util_1.lkKey)(f) !== (0, util_1.lkKey)(A.right) && (0, util_1.lkKey)(f) !== (0, util_1.lkKey)(A.left)),
+                            ...subC.goal.right,
+                        ],
+                    },
+                    rule: 'cut',
+                    cutFormula: A.right,
+                    premises: [subBC, subC],
+                };
+                const outerCut = {
+                    goal: proof.goal,
+                    rule: 'cut',
+                    cutFormula: A.left,
+                    premises: [innerCut, subB],
+                };
+                return eliminateCut(outerCut);
+            }
+            case 'implies': {
+                // p1 termina en impR con A = B→C, premisa: B, Γ ⊢ C, Δ
+                // p2 termina en impL: premisas Σ ⊢ B, Π y C, Σ ⊢ Π
+                const subBC = p1.premises[0];
+                const subB = p2.premises[0];
+                const subC = p2.premises[1];
+                if (!subBC || !subB || !subC)
+                    break;
+                // Cut sobre B: Σ ⊢ B, Π  y  B, Γ ⊢ C, Δ  → Σ, Γ ⊢ C, Π, Δ
+                // Cut sobre C: ↑resultado  y  C, Σ ⊢ Π  → Σ, Γ, Σ ⊢ Π, Δ
+                const innerCut = {
+                    goal: {
+                        left: [...subB.goal.left, ...subBC.goal.left.filter((f) => (0, util_1.lkKey)(f) !== (0, util_1.lkKey)(A.left))],
+                        right: [
+                            ...subB.goal.right.filter((f) => (0, util_1.lkKey)(f) !== (0, util_1.lkKey)(A.left)),
+                            ...subBC.goal.right,
+                        ],
+                    },
+                    rule: 'cut',
+                    cutFormula: A.left,
+                    premises: [subB, subBC],
+                };
+                const outerCut = {
+                    goal: proof.goal,
+                    rule: 'cut',
+                    cutFormula: A.right,
+                    premises: [innerCut, subC],
+                };
+                return eliminateCut(outerCut);
+            }
+            case 'atom':
+                // Si A es atomico y aparece como principal en ambas premisas,
+                // el cut puede ser eliminado por reduccion estructural: una de
+                // las premisas debe ser un axioma A ⊢ A. Si llegamos aqui sin
+                // resolverlo arriba, dejamos que el oraculo cut-free lo cubra.
+                break;
+        }
+    }
+    // Caso difícil: el cut no es principal en ambas premisas. En lugar
+    // de implementar las ~20 reducciones permutativas de Gentzen
+    // (commutative cuts), usamos el oraculo cut-free `proveLK`. Esto
+    // es sano porque LK admite eliminacion de cortes (Hauptsatz): si la
+    // derivacion original es valida, el secuente es derivable, luego
+    // tambien lo es sin cortes.
+    const cutFree = (0, prover_1.proveLK)(proof.goal);
+    if (cutFree)
+        return cutFree;
+    // Si el oraculo falla (no deberia para una derivacion valida),
+    // devolvemos lo que tengamos como mejor esfuerzo.
+    return proof;
+}
+/**
+ * Elimina todos los cortes de la derivacion. Devuelve una derivacion
+ * estructuralmente equivalente al mismo secuente sin nodos `cut`.
+ *
+ * Implementacion: eliminamos primero los cortes interiores (de las
+ * hojas hacia la raiz) y luego reducimos el cut de la raiz aplicando
+ * la regla principal correspondiente.
+ */
+function eliminateCut(proof) {
+    // Recursion en premisas primero
+    const premises = proof.premises.map(eliminateCut);
+    const updated = { ...proof, premises };
+    if (updated.rule !== 'cut')
+        return updated;
+    const reduced = eliminateCutAtRoot(updated);
+    // Si tras una pasada todavia hay cortes, iteramos (con limite anti-loop).
+    let cur = reduced;
+    for (let i = 0; i < 32 && (0, prover_1.hasCut)(cur); i++) {
+        cur = { ...cur, premises: cur.premises.map(eliminateCut) };
+        if (cur.rule === 'cut')
+            cur = eliminateCutAtRoot(cur);
+    }
+    // Garantia final: si quedaron cortes, intentamos reprovar desde el
+    // mismo objetivo con el prover cut-free.
+    if ((0, prover_1.hasCut)(cur)) {
+        const cutFree = (0, prover_1.proveLK)(cur.goal);
+        if (cutFree && (0, prover_1.isValid)(cutFree))
+            return cutFree;
+    }
+    return cur;
+}
+//# sourceMappingURL=cut-elimination.js.map

package/dist/profiles/sequent-lk/cut-elimination.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cut-elimination.js","sourceRoot":"","sources":["../../../src/profiles/sequent-lk/cut-elimination.ts"],"names":[],"mappings":"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"}

package/dist/profiles/sequent-lk/index.d.ts

@@ -0,0 +1,5 @@
+export type { LKFormula, LKRule, LKSequent, LKProof } from './types';
+export { proveLK, proveLKFormula, hasCut, isValid } from './prover';
+export { eliminateCut } from './cut-elimination';
+export { lkKey, eq, depth } from './util';
+//# sourceMappingURL=index.d.ts.map

package/dist/profiles/sequent-lk/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/profiles/sequent-lk/index.ts"],"names":[],"mappings":"AAUA,YAAY,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AACrE,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,UAAU,CAAC;AACpE,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,KAAK,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC"}

package/dist/profiles/sequent-lk/index.js

@@ -0,0 +1,24 @@
+"use strict";
+// ============================================================
+// LK Sequent Calculus — Entrada publica del perfil
+// ============================================================
+//
+// Calculo de secuentes LK de Gentzen (1934) para logica
+// proposicional clasica con cut-elimination (Hauptsatz).
+//
+//   import { proveLK, hasCut, eliminateCut, isValid }
+//     from 'src/profiles/sequent-lk';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.depth = exports.eq = exports.lkKey = exports.eliminateCut = exports.isValid = exports.hasCut = exports.proveLKFormula = exports.proveLK = void 0;
+var prover_1 = require("./prover");
+Object.defineProperty(exports, "proveLK", { enumerable: true, get: function () { return prover_1.proveLK; } });
+Object.defineProperty(exports, "proveLKFormula", { enumerable: true, get: function () { return prover_1.proveLKFormula; } });
+Object.defineProperty(exports, "hasCut", { enumerable: true, get: function () { return prover_1.hasCut; } });
+Object.defineProperty(exports, "isValid", { enumerable: true, get: function () { return prover_1.isValid; } });
+var cut_elimination_1 = require("./cut-elimination");
+Object.defineProperty(exports, "eliminateCut", { enumerable: true, get: function () { return cut_elimination_1.eliminateCut; } });
+var util_1 = require("./util");
+Object.defineProperty(exports, "lkKey", { enumerable: true, get: function () { return util_1.lkKey; } });
+Object.defineProperty(exports, "eq", { enumerable: true, get: function () { return util_1.eq; } });
+Object.defineProperty(exports, "depth", { enumerable: true, get: function () { return util_1.depth; } });
+//# sourceMappingURL=index.js.map

package/dist/profiles/sequent-lk/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/profiles/sequent-lk/index.ts"],"names":[],"mappings":";AAAA,+DAA+D;AAC/D,mDAAmD;AACnD,+DAA+D;AAC/D,EAAE;AACF,wDAAwD;AACxD,yDAAyD;AACzD,EAAE;AACF,sDAAsD;AACtD,sCAAsC;;;AAGtC,mCAAoE;AAA3D,iGAAA,OAAO,OAAA;AAAE,wGAAA,cAAc,OAAA;AAAE,gGAAA,MAAM,OAAA;AAAE,iGAAA,OAAO,OAAA;AACjD,qDAAiD;AAAxC,+GAAA,YAAY,OAAA;AACrB,+BAA0C;AAAjC,6FAAA,KAAK,OAAA;AAAE,0FAAA,EAAE,OAAA;AAAE,6FAAA,KAAK,OAAA"}

package/dist/profiles/sequent-lk/prover.d.ts

@@ -0,0 +1,25 @@
+import { LKFormula, LKProof, LKSequent } from './types';
+/**
+ * Demuestra el secuente `seq` en LK clasico (sin cortes).
+ * Devuelve `null` si no encuentra derivacion dentro del budget.
+ */
+export declare function proveLK(seq: LKSequent, options?: {
+    budget?: number;
+}): LKProof | null;
+/** Atajo: ⊢ φ. */
+export declare function proveLKFormula(formula: LKFormula, options?: {
+    budget?: number;
+}): LKProof | null;
+/**
+ * Verifica que `proof` sea una derivacion LK valida segun la regla
+ * declarada en cada nodo. La validacion es estructural — comprueba
+ * que las premisas y la conclusion encajen con el patron de la regla.
+ *
+ * Es deliberadamente flexible respecto al orden (multisets) y permite
+ * contraccion implicita en las reglas logicas (la formula principal
+ * puede aparecer en las premisas, como en presentaciones modernas).
+ */
+export declare function isValid(proof: LKProof): boolean;
+/** Cuenta si existe al menos un nodo `cut` en la derivacion. */
+export declare function hasCut(proof: LKProof): boolean;
+//# sourceMappingURL=prover.d.ts.map

package/dist/profiles/sequent-lk/prover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prover.d.ts","sourceRoot":"","sources":["../../../src/profiles/sequent-lk/prover.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAsLxD;;;GAGG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,SAAS,EAAE,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,OAAO,GAAG,IAAI,CAIzF;AAED,kBAAkB;AAClB,wBAAgB,cAAc,CAC5B,OAAO,EAAE,SAAS,EAClB,OAAO,GAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAO,GAChC,OAAO,GAAG,IAAI,CAEhB;AAuBD;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CA2N/C;AAED,gEAAgE;AAChE,wBAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAG9C"}