@seljs/runtime 1.0.0

package/dist/analysis/round-planner.js

@@ -0,0 +1,69 @@
+import { createLogger } from "../debug.js";
+import { ExecutionLimitError } from "../errors/index.js";
+const debug = createLogger("analysis:plan");
+/**
+ * Plans execution rounds from a dependency graph using topological sorting.
+ *
+ * Groups independent calls into parallel rounds, ensuring all dependencies
+ * of a call are executed in previous rounds. Enforces limits on the number
+ * of rounds and total calls to prevent excessive execution.
+ *
+ * @param graph Dependency graph representing calls and their relationships.
+ * @param limits Optional limits for maximum rounds and total calls.
+ * @returns Execution plan containing planned rounds, total calls, and maximum depth.
+ * @throws ExecutionLimitError If total calls exceed maxCalls or rounds exceed maxRounds.
+ */
+export const planRounds = (graph, limits = {}) => {
+    const maxRounds = limits.maxRounds ?? 10;
+    const maxCalls = limits.maxCalls ?? 100;
+    const totalCalls = graph.nodes.size;
+    if (totalCalls > maxCalls) {
+        throw new ExecutionLimitError(`Execution limit exceeded: ${String(totalCalls)} calls exceeds maxCalls (${String(maxCalls)})`, { limitType: "maxCalls", limit: maxCalls, actual: totalCalls });
+    }
+    if (totalCalls === 0) {
+        return { rounds: [], totalCalls: 0, maxDepth: 0 };
+    }
+    const inDegree = new Map();
+    for (const nodeId of graph.nodes.keys()) {
+        inDegree.set(nodeId, graph.edges.get(nodeId)?.size ?? 0);
+    }
+    const rounds = [];
+    const processed = new Set();
+    while (processed.size < totalCalls) {
+        const readyNodes = [];
+        for (const [nodeId, degree] of inDegree) {
+            if (degree === 0 && !processed.has(nodeId)) {
+                readyNodes.push(nodeId);
+            }
+        }
+        if (readyNodes.length === 0) {
+            break;
+        }
+        if (rounds.length >= maxRounds) {
+            throw new ExecutionLimitError(`Execution limit exceeded: requires more than maxRounds (${String(maxRounds)}) rounds`, {
+                limitType: "maxRounds",
+                limit: maxRounds,
+                actual: rounds.length + 1,
+            });
+        }
+        const round = {
+            roundNumber: rounds.length,
+            calls: readyNodes
+                .map((id) => graph.nodes.get(id)?.call)
+                .filter((c) => c !== undefined),
+        };
+        rounds.push(round);
+        for (const nodeId of readyNodes) {
+            processed.add(nodeId);
+            const node = graph.nodes.get(nodeId);
+            if (!node) {
+                continue;
+            }
+            for (const dependentId of node.dependedOnBy) {
+                inDegree.set(dependentId, (inDegree.get(dependentId) ?? 0) - 1);
+            }
+        }
+    }
+    debug("planned %d rounds for %d calls (max depth=%d)", rounds.length, totalCalls, rounds.length);
+    return { rounds, totalCalls, maxDepth: rounds.length };
+};

package/dist/analysis/types.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Represents a contract call found in AST traversal.
+ * Contains all information needed to execute the call and track dependencies.
+ */
+export interface CollectedCall {
+    /**
+     * Unique identifier: "contract:method:serializedArgs"
+     */
+    id: string;
+    /**
+     * Contract name: e.g., "erc20_usdc"
+     */
+    contract: string;
+    /**
+     * Method name: e.g., "balanceOf"
+     */
+    method: string;
+    /**
+     * Arguments with type and dependency information
+     */
+    args: CallArgument[];
+    /**
+     * Reference to original AST node for error reporting
+     */
+    astNode: unknown;
+}
+/**
+ * Argument to a contract call with type information.
+ * Tracks whether the argument is a literal, variable, or result of another call.
+ */
+export interface CallArgument {
+    /**
+     * Type of argument: literal value, variable reference, or call result
+     */
+    type: "literal" | "variable" | "call_result";
+    /**
+     * Literal value (when type is "literal")
+     */
+    value?: unknown;
+    /**
+     * Variable name (when type is "variable")
+     */
+    variableName?: string;
+    /**
+     * Call ID this depends on (when type is "call_result")
+     */
+    dependsOnCallId?: string;
+}
+/**
+ * Dependency graph for all collected calls.
+ * Maps call IDs to their nodes and dependency relationships.
+ */
+export interface DependencyGraph {
+    /**
+     * Call ID to graph node mapping
+     */
+    nodes: Map<string, GraphNode>;
+    /**
+     * Call ID to set of call IDs it depends on
+     */
+    edges: Map<string, Set<string>>;
+}
+/**
+ * Single node in the dependency graph.
+ * Tracks both incoming and outgoing dependencies.
+ */
+export interface GraphNode {
+    /**
+     * The original collected call
+     */
+    call: CollectedCall;
+    /**
+     * Call IDs this call depends on (must complete first)
+     */
+    dependsOn: string[];
+    /**
+     * Call IDs that depend on this call (will execute after)
+     */
+    dependedOnBy: string[];
+}
+/**
+ * Execution plan with rounds of parallel calls.
+ * Result of topological sorting the dependency graph.
+ */
+export interface ExecutionPlan {
+    /**
+     * Rounds of calls to execute in sequence
+     */
+    rounds: ExecutionRound[];
+    /**
+     * Total number of calls across all rounds
+     */
+    totalCalls: number;
+    /**
+     * Number of rounds (maximum dependency depth)
+     */
+    maxDepth: number;
+}
+/**
+ * Single round of calls that can execute in parallel.
+ * All calls in a round have no dependencies on each other.
+ */
+export interface ExecutionRound {
+    /**
+     * Round number (0-indexed)
+     */
+    roundNumber: number;
+    /**
+     * Calls that can execute in parallel this round
+     */
+    calls: CollectedCall[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/analysis/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/analysis/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC7B;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;IAEX;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,IAAI,EAAE,YAAY,EAAE,CAAC;IAErB;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC5B;;OAEG;IACH,IAAI,EAAE,SAAS,GAAG,UAAU,GAAG,aAAa,CAAC;IAE7C;;OAEG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;IAEhB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC/B;;OAEG;IACH,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAE9B;;OAEG;IACH,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;CAChC;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACzB;;OAEG;IACH,IAAI,EAAE,aAAa,CAAC;IAEpB;;OAEG;IACH,SAAS,EAAE,MAAM,EAAE,CAAC;IAEpB;;OAEG;IACH,YAAY,EAAE,MAAM,EAAE,CAAC;CACvB;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC7B;;OAEG;IACH,MAAM,EAAE,cAAc,EAAE,CAAC;IAEzB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC9B;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;OAEG;IACH,KAAK,EAAE,aAAa,EAAE,CAAC;CACvB"}

package/dist/analysis/types.js

@@ -0,0 +1 @@
+export {};

package/dist/debug.d.ts

@@ -0,0 +1,13 @@
+import createDebug from "debug";
+/**
+ * Creates a namespaced debug logger for a SEL module.
+ *
+ * Enable via the `DEBUG` environment variable:
+ * - `DEBUG=sel:*`           — all SEL logging
+ * - `DEBUG=sel:evaluate`    — only evaluate flow
+ * - `DEBUG=sel:execute:*`   — all execution sub-loggers
+ *
+ * @param namespace - Module namespace (e.g. "evaluate", "execute:round")
+ */
+export declare const createLogger: (namespace: string) => createDebug.Debugger;
+//# sourceMappingURL=debug.d.ts.map

package/dist/debug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug.d.ts","sourceRoot":"","sources":["../src/debug.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,OAAO,CAAC;AAEhC;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,GAAI,WAAW,MAAM,KAAG,WAAW,CAAC,QAC7B,CAAC"}

package/dist/debug.js

@@ -0,0 +1,12 @@
+import createDebug from "debug";
+/**
+ * Creates a namespaced debug logger for a SEL module.
+ *
+ * Enable via the `DEBUG` environment variable:
+ * - `DEBUG=sel:*`           — all SEL logging
+ * - `DEBUG=sel:evaluate`    — only evaluate flow
+ * - `DEBUG=sel:execute:*`   — all execution sub-loggers
+ *
+ * @param namespace - Module namespace (e.g. "evaluate", "execute:round")
+ */
+export const createLogger = (namespace) => createDebug(`sel:${namespace}`);

package/dist/environment/context.d.ts

@@ -0,0 +1,3 @@
+import type { CelCodecRegistry } from "@seljs/checker";
+export declare const normalizeContextForEvaluation: (context: Record<string, unknown>, variableTypes: Map<string, string>, codecRegistry: CelCodecRegistry) => Record<string, unknown>;
+//# sourceMappingURL=context.d.ts.map

package/dist/environment/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/environment/context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD,eAAO,MAAM,6BAA6B,GACzC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,eAAe,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAClC,eAAe,gBAAgB,KAC7B,MAAM,CAAC,MAAM,EAAE,OAAO,CASxB,CAAC"}

package/dist/environment/context.js

@@ -0,0 +1,8 @@
+export const normalizeContextForEvaluation = (context, variableTypes, codecRegistry) => {
+    const normalized = {};
+    for (const [key, value] of Object.entries(context)) {
+        const type = variableTypes.get(key);
+        normalized[key] = codecRegistry.resolve(type ?? "dyn").parse(value);
+    }
+    return normalized;
+};

package/dist/environment/contract-caller.d.ts

@@ -0,0 +1,25 @@
+import type { CelCodecRegistry } from "@seljs/checker";
+import type { ContractSchema, MethodSchema } from "@seljs/schema";
+import type { Abi, Address, PublicClient } from "viem";
+/**
+ * Tracks total RPC calls (pre-executed + live) across a single evaluation.
+ * Create one per `evaluate()` call and pass it through the handler closure.
+ */
+export declare class CallCounter {
+    private readonly maxCalls;
+    private count;
+    constructor(maxCalls: number, initialCount?: number);
+    increment(contractName: string, methodName: string): void;
+}
+export declare const executeContractCall: (contract: ContractSchema, method: MethodSchema, args: unknown[], options: {
+    executionCache?: Map<string, unknown>;
+    client?: PublicClient;
+    codecRegistry?: CelCodecRegistry;
+    callCounter?: CallCounter;
+}) => Promise<unknown>;
+export declare const resolveExecutionBlockNumber: (client: PublicClient) => Promise<bigint | undefined>;
+export declare const buildContractInfoMap: (contracts: ContractSchema[]) => Map<string, {
+    abi: Abi;
+    address: Address;
+}>;
+//# sourceMappingURL=contract-caller.d.ts.map

package/dist/environment/contract-caller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract-caller.d.ts","sourceRoot":"","sources":["../../src/environment/contract-caller.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAClE,OAAO,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAIvD;;;GAGG;AACH,qBAAa,WAAW;IAGtB,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAF1B,OAAO,CAAC,KAAK,CAAK;gBAEA,QAAQ,EAAE,MAAM,EACjC,YAAY,GAAE,MAAU;IAKlB,SAAS,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;CAqBhE;AAED,eAAO,MAAM,mBAAmB,GAC/B,UAAU,cAAc,EACxB,QAAQ,YAAY,EACpB,MAAM,OAAO,EAAE,EACf,SAAS;IACR,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACtC,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,aAAa,CAAC,EAAE,gBAAgB,CAAC;IACjC,WAAW,CAAC,EAAE,WAAW,CAAC;CAC1B,KAEC,OAAO,CAAC,OAAO,CAwDjB,CAAC;AAEF,eAAO,MAAM,2BAA2B,GACvC,QAAQ,YAAY,KAClB,OAAO,CAAC,MAAM,GAAG,SAAS,CAe5B,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAChC,WAAW,cAAc,EAAE,KACzB,GAAG,CAAC,MAAM,EAAE;IAAE,GAAG,EAAE,GAAG,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAQ5C,CAAC"}

package/dist/environment/contract-caller.js

@@ -0,0 +1,85 @@
+import { readContract } from "viem/actions";
+import { createReplayCallId } from "./replay-cache.js";
+import { createLogger } from "../debug.js";
+import { ExecutionLimitError, SELContractError } from "../errors/index.js";
+const debug = createLogger("contract-caller");
+/**
+ * Tracks total RPC calls (pre-executed + live) across a single evaluation.
+ * Create one per `evaluate()` call and pass it through the handler closure.
+ */
+export class CallCounter {
+    maxCalls;
+    count = 0;
+    constructor(maxCalls, initialCount = 0) {
+        this.maxCalls = maxCalls;
+        this.count = initialCount;
+    }
+    increment(contractName, methodName) {
+        this.count++;
+        if (this.count > this.maxCalls) {
+            throw new ExecutionLimitError(`Execution limit exceeded: ${String(this.count)} calls exceeds maxCalls (${String(this.maxCalls)})`, {
+                limitType: "maxCalls",
+                limit: this.maxCalls,
+                actual: this.count,
+            });
+        }
+        debug("call count: %d/%d (%s.%s)", this.count, this.maxCalls, contractName, methodName);
+    }
+}
+export const executeContractCall = async (contract, method, args, options) => {
+    const normalizedArgs = options.codecRegistry
+        ? args.map((arg, i) => options.codecRegistry.encode(method.params[i]?.type ?? "dyn", arg))
+        : args;
+    if (options.executionCache) {
+        const callId = createReplayCallId(contract.name, method.name, normalizedArgs);
+        if (options.executionCache.has(callId)) {
+            debug("cache hit: %s.%s", contract.name, method.name);
+            return options.executionCache.get(callId);
+        }
+        debug("cache miss: %s.%s — executing live", contract.name, method.name);
+    }
+    if (!options.client) {
+        throw new SELContractError("No client provided for contract call. Provide a client in SELRuntime config or evaluate() context.", {
+            contractName: contract.name,
+            methodName: method.name,
+        });
+    }
+    // Count live RPC calls against the limit
+    options.callCounter?.increment(contract.name, method.name);
+    try {
+        return await readContract(options.client, {
+            address: contract.address,
+            abi: [method.abi],
+            functionName: method.name,
+            args: normalizedArgs,
+        });
+    }
+    catch (error) {
+        if (error instanceof SELContractError) {
+            throw error;
+        }
+        throw new SELContractError(`Contract call failed: ${contract.name}.${method.name}`, {
+            cause: error,
+            contractName: contract.name,
+            methodName: method.name,
+        });
+    }
+};
+export const resolveExecutionBlockNumber = async (client) => {
+    const clientWithGetBlockNumber = client;
+    if (typeof clientWithGetBlockNumber.getBlockNumber === "function") {
+        return await clientWithGetBlockNumber.getBlockNumber();
+    }
+    if (typeof clientWithGetBlockNumber.request === "function") {
+        return undefined;
+    }
+    return 0n;
+};
+export const buildContractInfoMap = (contracts) => {
+    const map = new Map();
+    for (const contract of contracts) {
+        const abi = contract.methods.map((m) => m.abi);
+        map.set(contract.name, { abi, address: contract.address });
+    }
+    return map;
+};

package/dist/environment/environment.d.ts

@@ -0,0 +1,81 @@
+import type { SELRuntimeConfig } from "./types.js";
+import type { EvaluateOptions, EvaluateResult } from "../execution/types.js";
+import type { TypeCheckResult } from "@marcbachmann/cel-js";
+export declare class SELRuntime {
+    private readonly env;
+    private readonly client?;
+    private readonly schema;
+    private readonly variableTypes;
+    private readonly maxRounds;
+    private readonly maxCalls;
+    private readonly multicallOptions?;
+    private readonly contractBindings;
+    private readonly codecRegistry;
+    /**
+     * Per-evaluation mutable state.
+     *
+     * These fields are set before CEL evaluation and cleared in `finally`.
+     * They exist because the contract call handler closure (created in the
+     * constructor) needs access to per-evaluation context, but CEL's
+     * `Environment.parse()` returns a function that doesn't accept extra
+     * parameters beyond the variable bindings.
+     *
+     * Thread safety: The `mutex` field serializes concurrent `evaluate()`
+     * calls, ensuring these fields are never accessed concurrently.
+     *
+     * TODO: Consider refactoring to pass an EvaluationContext object through
+     * the handler closure instead of mutating instance state. This would
+     * eliminate the need for the mutex and make the code more testable.
+     * See .omc/drafts/context-object-spike.md for preliminary analysis.
+     */
+    private currentCache?;
+    private currentClient?;
+    private currentCallCounter?;
+    /** Mutex to serialize concurrent evaluate() calls (protects current* fields) */
+    private mutex;
+    /**
+     * Creates a new immutable SEL runtime with Solidity types pre-registered.
+     *
+     * Initializes the underlying CEL runtime, registers all Solidity primitive types,
+     * and processes any contracts and variables from the schema. After construction,
+     * the environment is fully configured and immutable.
+     *
+     * @param config - Configuration containing the SEL schema, optional viem client,
+     *   multicall settings, and CEL/execution limits (maxRounds defaults to 10, maxCalls to 100)
+     */
+    constructor(config: SELRuntimeConfig);
+    /**
+     * Type-checks an expression against registered variables and contract methods.
+     *
+     * @param expression - A CEL expression string to type-check
+     * @returns The type-check result containing validity, inferred type, and any errors
+     * @throws {@link SELTypeError} If the expression contains unrecoverable type errors
+     */
+    check(expression: string): TypeCheckResult;
+    /**
+     * Evaluates a SEL expression, executing any embedded contract calls on-chain.
+     *
+     * When contract calls are present, the full pipeline runs:
+     * 1. Parse the expression and collect contract calls from the AST
+     * 2. Type-check against registered variables and contract methods
+     * 3. Build a dependency graph and plan execution rounds
+     * 4. Execute contract calls via multicall3 batching at a pinned block number
+     * 5. Evaluate the CEL expression with resolved contract results and context values
+     * 6. Unwrap Solidity wrapper types back to native JS values (BigInt, string, etc.)
+     *
+     * @param expression A CEL expression string
+     * @param context Variable bindings for evaluation
+     * @param options Optional client override
+     * @returns An {@link EvaluateResult} containing the value and optional execution metadata
+     * @throws {@link SELParseError} If the expression has invalid syntax
+     * @throws {@link SELTypeError} If type-checking fails
+     * @throws {@link SELContractError} If a contract call fails or no client is available
+     * @throws {@link SELEvaluationError} If CEL evaluation fails
+     */
+    evaluate<T = unknown>(expression: string, context?: Record<string, unknown>, options?: EvaluateOptions): Promise<EvaluateResult<T>>;
+    private planExecution;
+    private executeContractCalls;
+    private doEvaluate;
+    private findContract;
+}
+//# sourceMappingURL=environment.d.ts.map

package/dist/environment/environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../src/environment/environment.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAoB,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAErE,OAAO,KAAK,EACX,eAAe,EACf,cAAc,EAEd,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAe,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAezE,qBAAa,UAAU;IACtB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAc;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAe;IACvC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAY;IACnC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA6B;IAC3D,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAC,CAAmB;IACrD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAA0B;IAC3D,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAmB;IAEjD;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,YAAY,CAAC,CAAuB;IAC5C,OAAO,CAAC,aAAa,CAAC,CAAe;IACrC,OAAO,CAAC,kBAAkB,CAAC,CAAc;IAEzC,gFAAgF;IAChF,OAAO,CAAC,KAAK,CAAqB;IAElC;;;;;;;;;OASG;gBACgB,MAAM,EAAE,gBAAgB;IAgE3C;;;;;;OAMG;IACI,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe;IAQjD;;;;;;;;;;;;;;;;;;;OAmBG;IACU,QAAQ,CAAC,CAAC,GAAG,OAAO,EAChC,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,OAAO,CAAC,EAAE,eAAe,GACvB,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAiB7B,OAAO,CAAC,aAAa;YA+CP,oBAAoB;YA0FpB,UAAU;IAyExB,OAAO,CAAC,YAAY;CAGpB"}