semantifold 0.2.0 → 0.3.0

package/build/src/frontends/cpp.js

@@ -0,0 +1,784 @@
+// @ts-check
+import { generateCpp } from "../backends/cpp.js";
+import { OrderedExpressionPlanner } from "../backends/ordered-expressions.js";
+import { maximumCppSourceLength } from "../backends/cpp-validation.js";
+import { validateNativeGraph } from "../backends/native-validation.js";
+import { cppRuntime } from "../backends/cpp-runtime.js";
+import { validateBackendModule } from "../backends/shared.js";
+import { isCppIdentifier } from "../backends/identifiers.js";
+import { parseCppCst } from "./cpp-parser.js";
+import { missingType, SemantifoldDiagnostic, unsupportedSyntax } from "../diagnostic.js";
+import { createCoordinateIndex, indexedPointAt } from "../semantic/location.js";
+import { withAdaptedOperation } from "../semantic/operators.js";
+import { withParserRanges } from "../semantic/provenance.js";
+import { hasOnlyUnicodeScalars } from "../semantic/scalars.js";
+import { validateParsedModule } from "../semantic/validate.js";
+import { sourceScalarType } from "./scalars.js";
+/** @typedef {import("./cpp-parser.js").CstNode} CstNode */
+/** @typedef {import("../semantic/types.js").Expression} Expression */
+/** @typedef {import("../semantic/types.js").Statement} Statement */
+const binaryOperations = new Map([
+    ["+", "Add"], ["-", "Subtract"], ["*", "Multiply"], ["==", "Equal"], ["!=", "NotEqual"],
+    ["<", "LessThan"], ["<=", "LessThanOrEqual"], [">", "GreaterThan"], [">=", "GreaterThanOrEqual"],
+    ["&&", "And"], ["||", "Or"]
+]);
+const helpers = new Map([
+    ["semantifold_integer_add", "PhpAdd"], ["semantifold_integer_subtract", "Subtract"],
+    ["semantifold_integer_multiply", "Multiply"], ["semantifold_string_concat", "StringConcat"],
+    ["semantifold_string_equal", "StringEqual"], ["semantifold_string_not_equal", "StringNotEqual"]
+]);
+/** Strict field-and-token consumer for the private frozen CPP CST. */
+export class CppReader {
+    /**
+     * Owns source content and its coordinate index, never native parser handles.
+     * @param {string} filename - Original filename.
+     * @param {string} source - Exact original source.
+     */
+    constructor(filename, source) {
+        this.filename = filename;
+        this.source = source;
+        this.coordinates = createCoordinateIndex(source);
+        this.generated = false;
+        /** @type {Map<string, Expression> | undefined} */
+        this.temporaryExpressions = undefined;
+        /** @type {Set<string> | undefined} */
+        this.temporaryNames = undefined;
+        /** @type {Map<Statement, {node: CstNode, type: string}>} */
+        this.printTypes = new Map();
+        /** @type {Set<string>} */
+        this.declaredFunctions = new Set();
+    }
+    /**
+     * Locates one parser-owned range in UTF-16 coordinates.
+     * @param {CstNode} node - Parser node.
+     * @returns {import("../semantic/types.js").SourceLocation} Verified location.
+     */
+    location(node) {
+        return { filename: this.filename, start: indexedPointAt(this.coordinates, node.startIndex), end: indexedPointAt(this.coordinates, node.endIndex) };
+    }
+    /**
+     * Reads only the spelling of an already recognized parser node.
+     * @param {CstNode} node - Parser node.
+     * @returns {string} Exact token spelling.
+     */
+    text(node) {
+        return this.source.slice(node.startIndex, node.endIndex);
+    }
+    /**
+     * Rejects a located source-profile violation.
+     * @param {CstNode} node - Rejected node.
+     * @param {string} [detail] - Profile violation.
+     * @returns {never} Always throws.
+     */
+    fail(node, detail = node.type) {
+        unsupportedSyntax("cpp", detail, this.location(node));
+    }
+    /**
+     * Traverses all edges before interpreting any source meaning.
+     * @param {CstNode} node - Current parser node.
+     * @param {number} [depth] - Bounded CST traversal depth.
+     * @returns {void}
+     */
+    validateTree(node, depth = 0) {
+        if (depth > 512)
+            this.fail(node, "CPP CST exceeds the 512-level traversal limit");
+        for (const { node: child } of node.children)
+            this.validateTree(child, depth + 1);
+        if (node.error || node.missing || node.hasError) {
+            throw new SemantifoldDiagnostic({ code: "PARSE_ERROR", language: "cpp", location: this.location(node), message: `CPP parser recovery at '${node.type}'.` });
+        }
+        if (node.extra && node.type != "comment")
+            this.fail(node, "unexpected extra parser child");
+        if ((node.type == "comment" || node.type == "string_content") && /\?\?[=/'()!<>-]/u.test(this.text(node))) {
+            this.fail(node, "trigraph preprocessing");
+        }
+        if (node.type == "comment") {
+            const text = this.text(node);
+            // A terminal CR belongs to ordinary CRLF; content after a bare CR is not a CPP line comment.
+            if (/\\(?:\r\n?|\n)/u.test(text) || text.startsWith("//") && /\r(?!\n|$)/u.test(text)) {
+                this.fail(node, "preprocessing-sensitive comment");
+            }
+        }
+    }
+    /**
+     * Separates harmless comments after every child has been validated.
+     * @param {CstNode} node - Parent node.
+     * @returns {CstNode[]} Ordered structural children.
+     */
+    parts(node) {
+        return node.children.map(({ node: child }) => child).filter((child) => child.type != "comment");
+    }
+    /**
+     * Requires one exact field rather than searching descendants.
+     * @param {CstNode} node - Field owner.
+     * @param {string} name - Field name.
+     * @returns {CstNode} Sole field child.
+     */
+    field(node, name) {
+        const matches = node.children.filter(({ field }) => field == name);
+        if (matches.length != 1)
+            return this.fail(node, `expected one '${name}' field`);
+        return matches[0].node;
+    }
+    /**
+     * Consumes every structural child, including punctuation.
+     * @param {CstNode} node - Shape owner.
+     * @param {(CstNode | string)[]} expected - Ordered nodes or token kinds.
+     * @returns {void}
+     */
+    shape(node, expected) {
+        const children = this.parts(node);
+        if (children.length != expected.length || children.some((child, index) => typeof expected[index] == "string" ? child.type != expected[index] : child !== expected[index]))
+            this.fail(node, `${node.type} child shape`);
+    }
+    /**
+     * Requires an ordinary caller identifier outside the protected namespace.
+     * @param {CstNode} node - Identifier token.
+     * @returns {string} Accepted spelling.
+     */
+    identifier(node) {
+        const name = this.text(node);
+        if (node.type != "identifier" || !isCppIdentifier(name))
+            this.fail(node, "reserved or unsupported identifier");
+        return name;
+    }
+    /**
+     * Converts only the canonical scalar type spellings.
+     * @param {CstNode} node - Type token.
+     * @returns {import("../semantic/types.js").TypeReference} Semantic scalar.
+     */
+    type(node) {
+        const spelling = node.type == "qualified_identifier" ? this.qualified(node) : this.text(node);
+        if (node.type != "qualified_identifier" && (node.type != "primitive_type" || spelling != "bool"))
+            this.fail(node, "scalar type shape");
+        const type = sourceScalarType("cpp", spelling, this.location(node));
+        if (!type)
+            return this.fail(node, "unsupported scalar type");
+        return type;
+    }
+    /**
+     * Reads exactly one std-qualified scalar name from CPP fields and punctuation.
+     * @param {CstNode} node - Qualified grammar node.
+     * @returns {string} Canonical qualified scalar spelling.
+     */
+    qualified(node) {
+        const scope = this.field(node, "scope");
+        const name = this.field(node, "name");
+        this.shape(node, [scope, "::", name]);
+        if (scope.type != "namespace_identifier" || this.text(scope) != "std" ||
+            !["type_identifier", "identifier"].includes(name.type) || !["int64_t", "string"].includes(this.text(name)))
+            this.fail(node, "qualified scalar name");
+        return "std::" + this.text(name);
+    }
+    /**
+     * Converts a direct function call's exact argument list.
+     * @param {CstNode} node - Call node.
+     * @returns {{name: CstNode, arguments: CstNode[]}} Parsed call shape.
+     */
+    call(node) {
+        if (node.type != "call_expression")
+            return this.fail(node, "direct call required");
+        const name = this.field(node, "function");
+        const list = this.field(node, "arguments");
+        this.shape(node, [name, list]);
+        if (!["identifier", "qualified_identifier"].includes(name.type) || list.type != "argument_list")
+            this.fail(node, "direct call shape");
+        const parts = this.parts(list);
+        const args = parts.slice(1, -1).filter((_part, index) => index % 2 == 0);
+        this.shape(list, ["(", ...args.flatMap((arg, index) => index == 0 ? [arg] : [",", arg]), ")"]);
+        return { arguments: args, name };
+    }
+    /**
+     * Decodes a parser-backed ordinary CPP string token as UTF-8 bytes.
+     * @param {CstNode} node - String literal.
+     * @returns {string} Complete Unicode scalar value.
+     */
+    string(node) {
+        if (node.type != "string_literal")
+            return this.fail(node, "ordinary string literal required");
+        const parts = this.parts(node);
+        if (parts[0]?.type != '"' || parts.at(-1)?.type != '"')
+            this.fail(node, "prefixed string literal");
+        const bytes = [];
+        for (let index = 1; index < parts.length - 1; index++) {
+            const child = parts[index];
+            const text = this.text(child);
+            if (child.type == "string_content") {
+                if (/[\r\n]/u.test(text))
+                    this.fail(child, "raw line terminator in string literal");
+                for (const byte of new TextEncoder().encode(text))
+                    bytes.push(byte);
+            }
+            else if (child.type == "escape_sequence") {
+                const simple = new Map([["a", 7], ["b", 8], ["f", 12], ["n", 10], ["r", 13], ["t", 9], ["v", 11], ["\\", 92], ['"', 34], ["'", 39], ["?", 63]]);
+                const value = text.slice(1);
+                if (text[0] != "\\")
+                    this.fail(child, "invalid escape");
+                if (simple.has(value))
+                    bytes.push(/** @type {number} */ (simple.get(value)));
+                else if (/^[0-7]{1,3}$/u.test(value) || /^x[0-9a-fA-F]+$/u.test(value)) {
+                    const next = parts[index + 1];
+                    // CPP consumes every adjacent hex digit; the frozen grammar caps each escape node at four.
+                    if (value.startsWith("x") && next.type == "string_content" && next.startIndex == child.endIndex && /^[0-9a-fA-F]/u.test(this.text(next))) {
+                        this.fail(child, "hexadecimal escape split by parser boundary");
+                    }
+                    const number = Number.parseInt(value[0] == "x" ? value.slice(1) : value, value[0] == "x" ? 16 : 8);
+                    if (number > 255)
+                        this.fail(child, "escape outside byte range");
+                    bytes.push(number);
+                }
+                else
+                    this.fail(child, "unsupported escape");
+            }
+            else
+                this.fail(child, "string child");
+        }
+        try {
+            return new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(new Uint8Array(bytes));
+        }
+        catch (error) {
+            if (error instanceof TypeError)
+                return this.fail(node, "invalid UTF-8 literal bytes");
+            throw error;
+        }
+    }
+    /**
+     * Converts supported expressions without assuming CPP argument evaluation order.
+     * @param {CstNode} node - Expression node.
+     * @param {boolean} [nested] - Whether a semantic call would have unspecified order.
+     * @returns {Expression} Semantic expression.
+     */
+    expression(node, nested = false) {
+        const location = this.location(node);
+        if (node.type == "condition_clause") {
+            const value = this.field(node, "value");
+            this.shape(node, ["(", value, ")"]);
+            return this.expression(value, nested);
+        }
+        if (node.type == "parenthesized_expression") {
+            const parts = this.parts(node);
+            this.shape(node, ["(", parts[1], ")"]);
+            return this.expression(parts[1], nested);
+        }
+        if (node.type == "identifier") {
+            const temporary = this.temporaryExpressions?.get(this.text(node));
+            if (temporary) {
+                this.temporaryExpressions?.delete(this.text(node));
+                return temporary;
+            }
+            return withParserRanges({ kind: "IdentifierExpression", location, name: this.identifier(node) }, { name: location });
+        }
+        if (node.type == "true" || node.type == "false") {
+            if (this.text(node) != node.type)
+                this.fail(node, "noncanonical Boolean literal spelling");
+            return withParserRanges({ kind: "BooleanLiteral", location, value: node.type == "true" }, { literal: location });
+        }
+        if (node.type == "number_literal")
+            this.fail(node, "integer literal requires exact std::int64_t construction");
+        if (node.type == "binary_expression") {
+            const left = this.field(node, "left");
+            const right = this.field(node, "right");
+            const operator = this.field(node, "operator");
+            const intent = binaryOperations.get(operator.type);
+            this.shape(node, [left, operator, right]);
+            if (!intent)
+                return this.fail(operator, "unsupported binary operator");
+            return this.binary(node, intent, this.expression(left, true), this.expression(right, true), operator);
+        }
+        if (node.type == "unary_expression") {
+            const operator = this.field(node, "operator");
+            const argument = this.field(node, "argument");
+            this.shape(node, [operator, argument]);
+            if (!["-", "!"].includes(operator.type))
+                this.fail(operator, "unsupported unary operator");
+            return this.unary(node, operator.type == "-" ? "Negate" : "Not", this.expression(argument, true), operator);
+        }
+        if (node.type == "call_expression") {
+            const call = this.call(node);
+            const name = this.text(call.name);
+            if (call.name.type == "qualified_identifier") {
+                const qualified = this.qualified(call.name);
+                if (qualified == "std::int64_t") {
+                    if (call.arguments.length != 1 || call.arguments[0].type != "number_literal")
+                        this.fail(node, "exact integer literal construction");
+                    const spelling = this.text(call.arguments[0]);
+                    if (!/^(?:0|[1-9][0-9]*)$/u.test(spelling) || !Number.isSafeInteger(Number(spelling)))
+                        this.fail(call.arguments[0], "non-safe or noncanonical integer");
+                    return withParserRanges({ kind: "IntegerLiteral", location, value: Number(spelling) }, { literal: location });
+                }
+                if (qualified == "std::string") {
+                    if (call.arguments.length != 2 || call.arguments[1].type != "number_literal")
+                        this.fail(node, "byte-counted string literal construction");
+                    const value = this.string(call.arguments[0]);
+                    const length = this.text(call.arguments[1]);
+                    if (length != String(Buffer.byteLength(value, "utf8")))
+                        this.fail(node, "string literal byte count");
+                    return withParserRanges({ kind: "StringLiteral", location, value }, { literal: location });
+                }
+                this.fail(call.name, "qualified user call");
+            }
+            // Generated operations are separate temporary initializers; only exact scalar literal constructions may nest as calls.
+            if (nested)
+                this.fail(node, "caller call in unspecified-order expression");
+            if (name == "semantifold_integer_negate") {
+                if (call.arguments.length != 1)
+                    this.fail(node, "negation helper arity");
+                return this.unary(node, "Negate", this.expression(call.arguments[0], true), call.name);
+            }
+            const intent = helpers.get(name);
+            if (intent) {
+                if (call.arguments.length != 2)
+                    this.fail(node, "scalar helper arity");
+                return this.binary(node, intent, this.expression(call.arguments[0], true), this.expression(call.arguments[1], true), call.name);
+            }
+            if (call.arguments.length != 2)
+                this.fail(node, "semantic call arity");
+            const callee = this.identifier(call.name);
+            if (!this.generated && !this.declaredFunctions.has(callee))
+                this.fail(call.name, "implicit function declaration");
+            return withParserRanges({ kind: "CallExpression", location, callee,
+                arguments: call.arguments.map((argument) => this.expression(argument, true)) }, { callee: this.location(call.name) });
+        }
+        return this.fail(node);
+    }
+    /**
+     * Records parser intent before shared type resolution.
+     * @param {CstNode} node - Owning expression.
+     * @param {string} intent - Adapted operation.
+     * @param {Expression} left - Left operand.
+     * @param {Expression} right - Right operand.
+     * @param {CstNode} operator - Operator token.
+     * @returns {Expression} Pending binary expression.
+     */
+    binary(node, intent, left, right, operator) {
+        return /** @type {Expression} */ (withAdaptedOperation(withParserRanges({ kind: "BinaryExpression", location: this.location(node), left, right }, { operator: this.location(operator) }), /** @type {import("../semantic/operators.js").AdaptedOperation} */ (intent)));
+    }
+    /**
+     * Records parser intent for a unary operation.
+     * @param {CstNode} node - Owning expression.
+     * @param {"Negate" | "Not"} intent - Adapted operation.
+     * @param {Expression} operand - Operand.
+     * @param {CstNode} operator - Operator token.
+     * @returns {Expression} Pending unary expression.
+     */
+    unary(node, intent, operand, operator) {
+        return /** @type {Expression} */ (withAdaptedOperation(withParserRanges({ kind: "UnaryExpression", location: this.location(node), operand }, { operator: this.location(operator) }), intent));
+    }
+    /**
+     * Converts one initialized declaration or executable statement.
+     * @param {CstNode} node - Statement node.
+     * @returns {Statement} Semantic statement.
+     */
+    statement(node) {
+        const location = this.location(node);
+        if (node.type == "declaration") {
+            const typeNode = node.children.find(({ field }) => field == "type")?.node;
+            if (!typeNode)
+                return missingType("cpp", "local", location);
+            const declarator = this.field(node, "declarator");
+            const parts = this.parts(node);
+            const immutable = parts[0].type == "type_qualifier";
+            this.shape(node, [...(immutable ? [parts[0]] : []), typeNode, declarator, ";"]);
+            if (immutable && this.text(parts[0]) != "const")
+                this.fail(parts[0], "local qualifier");
+            if (declarator.type != "init_declarator")
+                this.fail(declarator, "initialized simple local required");
+            const name = this.field(declarator, "declarator");
+            const value = this.field(declarator, "value");
+            this.shape(declarator, [name, "=", value]);
+            return withParserRanges({ kind: "LocalDeclaration", location, name: this.identifier(name), type: this.type(typeNode), mutable: !immutable,
+                initializer: this.expression(value) }, { name: this.location(name), operator: this.location(this.parts(declarator)[1]) });
+        }
+        if (node.type == "return_statement") {
+            const parts = this.parts(node);
+            this.shape(node, ["return", parts[1], ";"]);
+            return { kind: "ReturnStatement", location, expression: this.expression(parts[1]) };
+        }
+        if (node.type == "if_statement") {
+            const condition = this.field(node, "condition");
+            const consequence = this.field(node, "consequence");
+            const alternative = node.children.find(({ field }) => field == "alternative")?.node;
+            this.shape(node, ["if", condition, consequence, ...(alternative ? [alternative] : [])]);
+            const statement = { kind: /** @type {const} */ ("IfStatement"), location, condition: this.expression(condition), consequent: this.block(consequence) };
+            if (!alternative)
+                return statement;
+            const branch = this.parts(alternative)[1];
+            this.shape(alternative, ["else", branch]);
+            return { ...statement, alternate: branch.type == "if_statement"
+                    ? { kind: "Block", location: this.location(branch), statements: [this.statement(branch)] } : this.block(branch) };
+        }
+        if (node.type == "expression_statement") {
+            const expression = this.parts(node)[0];
+            this.shape(node, [expression, ";"]);
+            if (expression.type == "assignment_expression") {
+                const left = this.field(expression, "left");
+                const right = this.field(expression, "right");
+                const operator = this.field(expression, "operator");
+                this.shape(expression, [left, "=", right]);
+                const target = withParserRanges({ kind: /** @type {const} */ ("IdentifierExpression"), name: this.identifier(left), location: this.location(left) }, { name: this.location(left) });
+                return withParserRanges({ kind: "AssignmentStatement", location, target, expression: this.expression(right) }, { operator: this.location(operator) });
+            }
+            const call = this.call(expression);
+            if (!/^semantifold_print_(?:integer|boolean|string)$/u.test(this.text(call.name)) || call.arguments.length != 1)
+                this.fail(node, "print scaffold");
+            const value = this.expression(call.arguments[0]);
+            const statement = { kind: /** @type {const} */ ("PrintStatement"), location, expression: value };
+            this.printTypes.set(statement, { node: call.name, type: this.text(call.name).slice("semantifold_print_".length) });
+            return statement;
+        }
+        return this.fail(node);
+    }
+    /**
+     * Converts one lexical braced block in source order.
+     * @param {CstNode} node - Block node.
+     * @returns {import("../semantic/types.js").Block} Semantic block.
+     */
+    block(node) {
+        if (node.type != "compound_statement")
+            this.fail(node, "braced block required");
+        const parts = this.parts(node);
+        this.shape(node, ["{", ...parts.slice(1, -1), "}"]);
+        return { kind: "Block", location: this.location(node), statements: this.generated
+                ? this.generatedStatements(node.children.map(({ node: child }) => child).slice(1, -1))
+                : parts.slice(1, -1).map((child) => this.statement(child)) };
+    }
+    /**
+     * Converts one namespace-scope semantic function.
+     * @param {CstNode} node - Function definition.
+     * @returns {import("../semantic/types.js").FunctionDeclaration} Semantic function.
+     */
+    function(node) {
+        const type = this.field(node, "type");
+        const declarator = this.field(node, "declarator");
+        const body = this.field(node, "body");
+        this.shape(node, [type, declarator, body]);
+        if (declarator.type != "function_declarator")
+            this.fail(node, "namespace-scope function required");
+        const name = this.field(declarator, "declarator");
+        const parameters = this.field(declarator, "parameters");
+        this.shape(declarator, [name, parameters]);
+        const parts = this.parts(parameters);
+        this.shape(parameters, ["(", "parameter_declaration", ",", "parameter_declaration", ")"]);
+        const converted = [parts[1], parts[3]].map((parameter) => {
+            const typeNode = this.field(parameter, "type");
+            const nameNode = this.field(parameter, "declarator");
+            this.shape(parameter, [typeNode, nameNode]);
+            return withParserRanges({ kind: /** @type {const} */ ("Parameter"), location: this.location(parameter), name: this.identifier(nameNode), type: this.type(typeNode) }, { name: this.location(nameNode) });
+        });
+        this.declaredFunctions.add(this.identifier(name));
+        return withParserRanges({ kind: "FunctionDeclaration", location: this.location(node), name: this.identifier(name), parameters: converted,
+            returnType: this.type(type), body: this.block(body) }, { name: this.location(name) });
+    }
+    /**
+     * Removes only the exact parameterless main and zero-status scaffolding.
+     * @param {CstNode} node - Entry definition.
+     * @returns {import("../semantic/types.js").EntryPoint} Semantic entry.
+     */
+    main(node) {
+        const type = this.field(node, "type");
+        const declarator = this.field(node, "declarator");
+        const body = this.field(node, "body");
+        this.shape(node, [type, declarator, body]);
+        const name = this.field(declarator, "declarator");
+        const parameters = this.field(declarator, "parameters");
+        this.shape(declarator, [name, parameters]);
+        if (this.text(type) != "int" || this.text(name) != "main")
+            this.fail(node, "main signature");
+        this.shape(parameters, ["(", ")"]);
+        if (body.type != "compound_statement")
+            this.fail(body, "braced main required");
+        const parts = this.parts(body);
+        const status = parts.at(-2);
+        if (!status)
+            this.fail(body, "main status");
+        this.shape(body, ["{", ...parts.slice(1, -1), "}"]);
+        this.shape(status, ["return", "number_literal", ";"]);
+        if (this.text(this.parts(status)[1]) != "0")
+            this.fail(status, "entry status");
+        return { kind: "EntryPoint", location: this.location(node), body: { kind: "Block", location: this.location(body),
+                statements: this.generated ? this.generatedStatements(body.children.map(({ node: child }) => child).filter((child) => child.startIndex > body.startIndex && child.endIndex <= status.startIndex))
+                    : parts.slice(1, -2).map((child) => this.statement(child)) } };
+    }
+    /**
+     * Converts one complete translation unit after exhaustive recovery rejection.
+     * @param {CstNode} root - Frozen translation unit.
+     * @returns {import("../semantic/types.js").SemanticModule} Validated semantic module.
+     */
+    module(root) {
+        this.validateTree(root);
+        this.generated = root.children.some(({ node }) => node.type == "comment" && this.text(node) == "/* semantifold:program:cpp:v1 */");
+        if (root.type != "translation_unit")
+            this.fail(root, "translation unit required");
+        const runtime = new CppReader(this.filename, cppRuntime);
+        const expected = runtime.significant(parseCppCst(cppRuntime).root);
+        const actual = this.significant(root).filter((node) => !(node.type == "comment" && this.text(node) == "/* semantifold:program:cpp:v1 */"));
+        if (actual.length < expected.length)
+            this.fail(root, "complete CPP runtime required");
+        expected.forEach((node, index) => this.compareTree(actual[index], node, runtime));
+        const remaining = actual.slice(expected.length);
+        if (!this.generated)
+            for (const node of remaining)
+                this.rejectScaffoldComments(node);
+        const definitions = remaining.filter((node) => node.type != "comment" && (!this.generated || node.type != "declaration"));
+        if (definitions.some((node) => node.type != "function_definition"))
+            this.fail(root, "translation unit members");
+        if (definitions.length < 2)
+            this.fail(root, "semantic function and main required");
+        const module = { kind: /** @type {const} */ ("Module"), location: this.location(root), functions: definitions.slice(0, -1).map((node) => this.function(node)),
+            entryPoint: this.main(definitions[definitions.length - 1]) };
+        if (this.generated)
+            validateNativeGraph(module, "cpp");
+        const validated = validateParsedModule(module, "cpp");
+        this.validatePrintTypes(validated);
+        if (this.generated) {
+            validateBackendModule(validated, "cpp");
+            const canonical = generateCpp(validated);
+            if (typeof canonical != "string")
+                throw new Error("CPP backend returned a nontext entry artifact.");
+            this.compareTree(root, parseCppCst(canonical).root, new CppReader(this.filename, canonical));
+        }
+        return validated;
+    }
+    /**
+     * Checks native print helper selection after semantic scalar resolution.
+     * @param {import("../semantic/types.js").SemanticModule} module - Resolved module.
+     * @returns {void}
+     */
+    validatePrintTypes(module) {
+        const planner = new OrderedExpressionPlanner(module, "cpp");
+        /**
+         * Checks one lexical block with its visible scalar bindings.
+         * @param {import("../semantic/types.js").Block} block - Semantic block.
+         * @param {Map<string, import("../semantic/types.js").SemanticTypeName>} inherited - Visible bindings.
+         * @returns {void}
+         */
+        const visit = (block, inherited) => {
+            const bindings = new Map(inherited);
+            for (const statement of block.statements) {
+                if (statement.kind == "LocalDeclaration")
+                    bindings.set(statement.name, statement.type.name);
+                if (statement.kind == "PrintStatement") {
+                    const expected = this.printTypes.get(statement);
+                    if (!expected)
+                        throw new Error("CPP print statement lost its parser helper identity.");
+                    if (planner.type(statement.expression, bindings) != expected.type)
+                        this.fail(expected.node, "print helper scalar mismatch");
+                }
+                if (statement.kind == "IfStatement") {
+                    visit(statement.consequent, bindings);
+                    if (statement.alternate)
+                        visit(statement.alternate, bindings);
+                }
+            }
+        };
+        for (const declaration of module.functions)
+            visit(declaration.body, new Map(declaration.parameters.map((parameter) => [parameter.name, parameter.type.name])));
+        visit(module.entryPoint.body, new Map());
+    }
+    /**
+     * Rejects profile-looking comments outside a complete canonical generated program.
+     * @param {CstNode} node - Current node.
+     * @returns {void}
+     */
+    rejectScaffoldComments(node) {
+        if (node.type == "comment" && /semantifold:|@semantifold/u.test(this.text(node)))
+            this.fail(node, "unrecognized scaffold comment");
+        for (const { node: child } of node.children)
+            this.rejectScaffoldComments(child);
+    }
+    /**
+     * Retains every scaffold comment and structural edge, ignoring only ordinary comments.
+     * @param {CstNode} node - CST parent.
+     * @returns {CstNode[]} Complete significant child list.
+     */
+    significant(node) {
+        return node.children.map(({ node: child }) => child).filter((child) => child.type != "comment" || /semantifold:|@semantifold/u.test(this.text(child)));
+    }
+    /**
+     * Verifies every token, field, type, use, ordering edge and consumer against the canonical plan.
+     * This checks the original CST; it never recovers meaning from generated source text.
+     * @param {CstNode} actual - Original tree node.
+     * @param {CstNode} expected - Canonical tree node for the reconstructed semantics.
+     * @param {CppReader} canonical - Canonical token reader.
+     * @returns {void}
+     */
+    compareTree(actual, expected, canonical) {
+        if (actual.type != expected.type || actual.named != expected.named || actual.extra != expected.extra)
+            this.fail(actual, "generated scaffold node shape");
+        const left = this.significant(actual);
+        const right = canonical.significant(expected);
+        if (left.length != right.length)
+            this.fail(actual, "generated scaffold child count");
+        if (!left.length && this.text(actual) != canonical.text(expected))
+            this.fail(actual, "generated scaffold token, type, order or consumer");
+        left.forEach((child, index) => {
+            if (actual.children.find((edge) => edge.node === child)?.field != expected.children.find((edge) => edge.node === right[index])?.field)
+                this.fail(child, "generated scaffold field");
+            this.compareTree(child, right[index], canonical);
+        });
+    }
+    /**
+     * Recognizes the shape of an inert generated unused-binding cast; canonical comparison checks its exact target and placement.
+     * @param {CstNode} node - Candidate statement.
+     * @returns {boolean} Whether this is a discard-shaped candidate.
+     */
+    discard(node) {
+        return node.type == "expression_statement" && this.parts(node)[0]?.type == "cast_expression";
+    }
+    /**
+     * Reconstructs paired statement regions before mandatory whole-CST canonical verification.
+     * @param {CstNode[]} children - Ordered block children without braces or main cleanup.
+     * @returns {Statement[]} Candidate semantic statements.
+     */
+    generatedStatements(children) {
+        const nodes = children.filter((node) => node.type != "comment" || /semantifold:|@semantifold/u.test(this.text(node)));
+        /** @type {Statement[]} */
+        const statements = [];
+        let cursor = 0;
+        while (cursor < nodes.length && this.discard(nodes[cursor]))
+            cursor++;
+        while (cursor < nodes.length) {
+            const begin = nodes[cursor++];
+            const match = begin.type == "comment" && /^\/\* semantifold:ordered-expression:cpp:v1 begin ([0-9]{6}) ([0-9a-f]{64}) \*\/$/u.exec(this.text(begin));
+            if (!match)
+                this.fail(begin, "complete ordered statement region required");
+            const outer = this.temporaryExpressions;
+            const outerNames = this.temporaryNames;
+            this.temporaryExpressions = new Map();
+            this.temporaryNames = new Set();
+            while (cursor < nodes.length && this.temporaryDeclaration(nodes[cursor]))
+                cursor = this.readTemporary(nodes, cursor);
+            const consumer = nodes[cursor++];
+            if (!consumer)
+                this.fail(begin, "missing ordered consumer");
+            const statement = this.statement(consumer);
+            if (this.temporaryExpressions.size != 0)
+                this.fail(consumer, "unconsumed ordered temporary");
+            if (statement.kind == "LocalDeclaration" && nodes[cursor] && this.discard(nodes[cursor]))
+                cursor++;
+            const end = nodes[cursor++];
+            if (!end || end.type != "comment" || this.text(end) != `/* semantifold:ordered-expression:cpp:v1 end ${match[1]} ${match[2]} */`)
+                this.fail(end ?? begin, "ordered marker pair");
+            this.temporaryExpressions = outer;
+            this.temporaryNames = outerNames;
+            statements.push(statement);
+        }
+        return statements;
+    }
+    /**
+     * Identifies only a declaration at the current region level, without descendant searching.
+     * @param {CstNode} node - Candidate node.
+     * @returns {boolean} Whether the direct initialized name uses the reserved prefix.
+     */
+    temporaryDeclaration(node) {
+        if (node.type != "declaration")
+            return false;
+        const declarator = node.children.find(({ field }) => field == "declarator")?.node;
+        const name = declarator?.children.find(({ field }) => field == "declarator")?.node;
+        return name?.type == "identifier" && this.text(name).startsWith("semantifold_ordered_");
+    }
+    /**
+     * Expands one candidate temporary, including its conditional RHS, retaining original operation tokens.
+     * @param {CstNode[]} nodes - Current lexical sequence.
+     * @param {number} cursor - Declaration position.
+     * @returns {number} Next unconsumed position.
+     */
+    readTemporary(nodes, cursor) {
+        const node = nodes[cursor++];
+        const declarator = this.field(node, "declarator");
+        const nameNode = this.field(declarator, "declarator");
+        const name = this.text(nameNode);
+        const type = this.field(node, "type");
+        const value = this.field(declarator, "value");
+        this.shape(node, [type, declarator, ";"]);
+        this.shape(declarator, [nameNode, "=", value]);
+        this.type(type);
+        if (!/^semantifold_ordered_[0-9]{6}$/u.test(name) || this.temporaryNames?.has(name))
+            this.fail(nameNode, "ordered temporary declaration");
+        this.temporaryNames?.add(name);
+        let expression = this.expression(value);
+        const branch = nodes[cursor];
+        if (branch?.type == "if_statement" && ["identifier", "true", "false"].includes(value.type)) {
+            const condition = this.field(branch, "condition");
+            const body = this.field(branch, "consequence");
+            this.shape(branch, ["if", condition, body]);
+            this.shape(condition, ["(", this.parts(condition)[1], ")"]);
+            const test = this.parts(condition)[1];
+            const isOr = test.type == "unary_expression";
+            const target = isOr ? this.field(test, "argument") : test;
+            if (target.type != "identifier" || this.text(target) != name)
+                this.fail(target, "short-circuit temporary test");
+            if (isOr)
+                this.shape(test, ["!", target]);
+            if (body.type != "compound_statement")
+                this.fail(body, "short-circuit block");
+            const inside = this.significant(body).slice(1, -1);
+            let offset = 0;
+            while (offset < inside.length && this.temporaryDeclaration(inside[offset]))
+                offset = this.readTemporary(inside, offset);
+            if (offset != inside.length - 1)
+                this.fail(body, "short-circuit final write");
+            const assignment = inside[offset];
+            this.shape(assignment, ["assignment_expression", ";"]);
+            const assigned = this.parts(assignment)[0];
+            const left = this.field(assigned, "left");
+            const right = this.field(assigned, "right");
+            this.shape(assigned, [left, "=", right]);
+            if (left.type != "identifier" || this.text(left) != name)
+                this.fail(left, "short-circuit result write");
+            this.shape(right, ["(", "binary_expression", ")"]);
+            const binary = this.parts(right)[1];
+            const repeated = this.field(binary, "left");
+            const operand = this.field(binary, "right");
+            const operator = this.field(binary, "operator");
+            this.shape(binary, [repeated, isOr ? "||" : "&&", operand]);
+            if (repeated.type != "identifier" || this.text(repeated) != name)
+                this.fail(repeated, "short-circuit consumed value");
+            expression = this.binary(node, isOr ? "Or" : "And", expression, this.expression(operand), operator);
+            cursor++;
+        }
+        this.temporaryExpressions?.set(name, expression);
+        return cursor;
+    }
+}
+/**
+ * Parses only the frozen legacy CST, with no source-text recovery path.
+ * @param {{filename: string, source: string}} input - Exact caller source.
+ * @returns {import("../semantic/types.js").SemanticModule} Parsed C++ semantics.
+ */
+export function parseCpp({ filename, source }) {
+    if (!hasOnlyUnicodeScalars(source)) {
+        const coordinates = createCoordinateIndex(source);
+        const offset = source.search(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u);
+        throw new SemantifoldDiagnostic({ code: "PARSE_ERROR", language: "cpp", message: "CPP source contains a lone UTF-16 surrogate.",
+            location: { filename, start: indexedPointAt(coordinates, offset), end: indexedPointAt(coordinates, offset + 1) } });
+    }
+    if (source.length > maximumCppSourceLength) {
+        const coordinates = createCoordinateIndex(source);
+        return unsupportedSyntax("cpp", "source exceeds the frozen CPP parser's 32767 UTF-16 input limit", {
+            filename, start: indexedPointAt(coordinates, 0), end: indexedPointAt(coordinates, source.length)
+        });
+    }
+    let snapshot;
+    try {
+        snapshot = parseCppCst(source);
+    }
+    catch (error) {
+        const coordinates = createCoordinateIndex(source);
+        throw new SemantifoldDiagnostic({ code: "PARSE_ERROR", language: "cpp",
+            cause: error instanceof Error ? error : undefined, message: "The qualified CPP parser could not produce a complete CST.",
+            location: { filename, start: indexedPointAt(coordinates, 0), end: indexedPointAt(coordinates, source.length) } });
+    }
+    const reader = new CppReader(filename, source);
+    try {
+        return reader.module(snapshot.root);
+    }
+    catch (error) {
+        if (reader.generated && error instanceof SemantifoldDiagnostic && error.language == "cpp" &&
+            error.code != "PARSE_ERROR" && error.code != "UNSUPPORTED_SYNTAX") {
+            return unsupportedSyntax("cpp", `invalid generated ordered scaffold: ${error.code}`, error.location ?? reader.location(snapshot.root));
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cpp.js","sourceRoot":"","sources":["../../../src/frontends/cpp.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAA;AAC9C,OAAO,EAAC,wBAAwB,EAAC,MAAM,oCAAoC,CAAA;AAC3E,OAAO,EAAC,sBAAsB,EAAC,MAAM,+BAA+B,CAAA;AACpE,OAAO,EAAC,mBAAmB,EAAC,MAAM,kCAAkC,CAAA;AACpE,OAAO,EAAC,UAAU,EAAC,MAAM,4BAA4B,CAAA;AACrD,OAAO,EAAC,qBAAqB,EAAC,MAAM,uBAAuB,CAAA;AAC3D,OAAO,EAAC,eAAe,EAAC,MAAM,4BAA4B,CAAA;AAC1D,OAAO,EAAC,WAAW,EAAC,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAC,WAAW,EAAE,qBAAqB,EAAE,iBAAiB,EAAC,MAAM,kBAAkB,CAAA;AACtF,OAAO,EAAC,qBAAqB,EAAE,cAAc,EAAC,MAAM,yBAAyB,CAAA;AAC7E,OAAO,EAAC,oBAAoB,EAAC,MAAM,0BAA0B,CAAA;AAC7D,OAAO,EAAC,gBAAgB,EAAC,MAAM,2BAA2B,CAAA;AAC1D,OAAO,EAAC,qBAAqB,EAAC,MAAM,wBAAwB,CAAA;AAC5D,OAAO,EAAC,oBAAoB,EAAC,MAAM,yBAAyB,CAAA;AAC5D,OAAO,EAAC,gBAAgB,EAAC,MAAM,cAAc,CAAA;AAE7C,2DAA2D;AAC3D,sEAAsE;AACtE,oEAAoE;AAEpE,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAAC;IAC/B,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,CAAC,GAAG,EAAE,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,UAAU,CAAC;IACvF,CAAC,GAAG,EAAE,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,iBAAiB,CAAC,EAAE,CAAC,GAAG,EAAE,aAAa,CAAC,EAAE,CAAC,IAAI,EAAE,oBAAoB,CAAC;IAChG,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC;CAC5B,CAAC,CAAA;AACF,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC;IACtB,CAAC,yBAAyB,EAAE,QAAQ,CAAC,EAAE,CAAC,8BAA8B,EAAE,UAAU,CAAC;IACnF,CAAC,8BAA8B,EAAE,UAAU,CAAC,EAAE,CAAC,2BAA2B,EAAE,cAAc,CAAC;IAC3F,CAAC,0BAA0B,EAAE,aAAa,CAAC,EAAE,CAAC,8BAA8B,EAAE,gBAAgB,CAAC;CAChG,CAAC,CAAA;AAEF,sEAAsE;AACtE,MAAM,OAAO,SAAS;IACpB;;;;OAIG;IACH,YAAY,QAAQ,EAAE,MAAM;QAC1B,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAA;QACxB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;QACpB,IAAI,CAAC,WAAW,GAAG,qBAAqB,CAAC,MAAM,CAAC,CAAA;QAChD,IAAI,CAAC,SAAS,GAAG,KAAK,CAAA;QACtB,kDAAkD;QAClD,IAAI,CAAC,oBAAoB,GAAG,SAAS,CAAA;QACrC,sCAAsC;QACtC,IAAI,CAAC,cAAc,GAAG,SAAS,CAAA;QAC/B,4DAA4D;QAC5D,IAAI,CAAC,UAAU,GAAG,IAAI,GAAG,EAAE,CAAA;QAC3B,0BAA0B;QAC1B,IAAI,CAAC,iBAAiB,GAAG,IAAI,GAAG,EAAE,CAAA;IACpC,CAAC;IAED;;;;OAIG;IACH,QAAQ,CAAC,IAAI;QACX,OAAO,EAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,KAAK,EAAE,cAAc,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE,GAAG,EAAE,cAAc,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,QAAQ,CAAC,EAAC,CAAA;IAClJ,CAAC;IAED;;;;OAIG;IACH,IAAI,CAAC,IAAI;QACP,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAA;IAC1D,CAAC;IAED;;;;;OAKG;IACH,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC,IAAI;QAC3B,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAA;IACvD,CAAC;IAED;;;;;OAKG;IACH,YAAY,CAAC,IAAI,EAAE,KAAK,GAAG,CAAC;QAC1B,IAAI,KAAK,GAAG,GAAG;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,+CAA+C,CAAC,CAAA;QACjF,KAAK,MAAM,EAAC,IAAI,EAAE,KAAK,EAAC,IAAI,IAAI,CAAC,QAAQ;YAAE,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,CAAC,CAAC,CAAA;QAC9E,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,OAAO,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAChD,MAAM,IAAI,qBAAqB,CAAC,EAAC,IAAI,EAAE,aAAa,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,2BAA2B,IAAI,CAAC,IAAI,IAAI,EAAC,CAAC,CAAA;QAC3J,CAAC;QACD,IAAI,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,IAAI,IAAI,SAAS;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,+BAA+B,CAAC,CAAA;QAC1F,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,SAAS,IAAI,IAAI,CAAC,IAAI,IAAI,gBAAgB,CAAC,IAAI,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;YAC1G,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,wBAAwB,CAAC,CAAA;QAC3C,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,IAAI,SAAS,EAAE,CAAC;YAC3B,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAE5B,6FAA6F;YAC7F,IAAI,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;gBACtF,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,iCAAiC,CAAC,CAAA;YACpD,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,IAAI;QACR,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAC,IAAI,EAAE,KAAK,EAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,IAAI,SAAS,CAAC,CAAA;IAC/F,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,IAAI,EAAE,IAAI;QACd,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAC,KAAK,EAAC,EAAE,EAAE,CAAC,KAAK,IAAI,IAAI,CAAC,CAAA;QAEhE,IAAI,OAAO,CAAC,MAAM,IAAI,CAAC;YAAE,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,iBAAiB,IAAI,SAAS,CAAC,CAAA;QAC/E,OAAO,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA;IACxB,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,IAAI,EAAE,QAAQ;QAClB,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QAEjC,IAAI,QAAQ,CAAC,MAAM,IAAI,QAAQ,CAAC,MAAM,IAAI,QAAQ,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CACvE,OAAO,QAAQ,CAAC,KAAK,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK,QAAQ,CAAC,KAAK,CAAC,CAAC;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,IAAI,cAAc,CAAC,CAAA;IAChJ,CAAC;IAED;;;;OAIG;IACH,UAAU,CAAC,IAAI;QACb,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QAE5B,IAAI,IAAI,CAAC,IAAI,IAAI,YAAY,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,oCAAoC,CAAC,CAAA;QAC9G,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;OAIG;IACH,IAAI,CAAC,IAAI;QACP,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,IAAI,sBAAsB,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QAE7F,IAAI,IAAI,CAAC,IAAI,IAAI,sBAAsB,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,gBAAgB,IAAI,QAAQ,IAAI,MAAM,CAAC;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,mBAAmB,CAAC,CAAA;QACtI,MAAM,IAAI,GAAG,gBAAgB,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAA;QAEnE,IAAI,CAAC,IAAI;YAAE,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,yBAAyB,CAAC,CAAA;QAC5D,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;OAIG;IACH,SAAS,CAAC,IAAI;QACZ,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;QACvC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;QAErC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAA;QACrC,IAAI,KAAK,CAAC,IAAI,IAAI,sBAAsB,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,KAAK;YACnE,CAAC,CAAC,iBAAiB,EAAE,YAAY,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,uBAAuB,CAAC,CAAA;QACtJ,OAAO,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAClC,CAAC;IAED;;;;OAIG;IACH,IAAI,CAAC,IAAI;QACP,IAAI,IAAI,CAAC,IAAI,IAAI,iBAAiB;YAAE,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,sBAAsB,CAAC,CAAA;QAClF,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,UAAU,CAAC,CAAA;QACzC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,WAAW,CAAC,CAAA;QAE1C,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAA;QAC9B,IAAI,CAAC,CAAC,YAAY,EAAE,sBAAsB,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,IAAI,eAAe;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,mBAAmB,CAAC,CAAA;QACrI,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QAC9B,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,GAAG,CAAC,IAAI,CAAC,CAAC,CAAA;QAExE,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAA;QAC9F,OAAO,EAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAC,CAAA;IAChC,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,IAAI;QACT,IAAI,IAAI,CAAC,IAAI,IAAI,gBAAgB;YAAE,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,kCAAkC,CAAC,CAAA;QAC7F,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QAE9B,IAAI,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,IAAI,GAAG,IAAI,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,IAAI,GAAG;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,yBAAyB,CAAC,CAAA;QAClG,MAAM,KAAK,GAAG,EAAE,CAAA;QAEhB,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC;YACtD,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAA;YAC1B,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;YAE7B,IAAI,KAAK,CAAC,IAAI,IAAI,gBAAgB,EAAE,CAAC;gBACnC,IAAI,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC;oBAAE,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,uCAAuC,CAAC,CAAA;gBACnF,KAAK,MAAM,IAAI,IAAI,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC;oBAAE,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YACrE,CAAC;iBACI,IAAI,KAAK,CAAC,IAAI,IAAI,iBAAiB,EAAE,CAAC;gBACzC,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,CAAC,CAAA;gBAC/I,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;gBAE3B,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI;oBAAE,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAA;gBACvD,IAAI,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC;oBAAE,KAAK,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;qBACvE,IAAI,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,kBAAkB,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;oBACvE,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAA;oBAE7B,2FAA2F;oBAC3F,IAAI,KAAK,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,IAAI,CAAC,IAAI,IAAI,gBAAgB,IAAI,IAAI,CAAC,UAAU,IAAI,KAAK,CAAC,QAAQ,IAAI,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;wBACzI,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,6CAA6C,CAAC,CAAA;oBACjE,CAAC;oBACD,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;oBAElG,IAAI,MAAM,GAAG,GAAG;wBAAE,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,2BAA2B,CAAC,CAAA;oBAC/D,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;gBACpB,CAAC;;oBAAM,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,oBAAoB,CAAC,CAAA;YAC/C,CAAC;;gBAAM,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,cAAc,CAAC,CAAA;QACzC,CAAC;QACD,IAAI,CAAC;YACH,OAAO,IAAI,WAAW,CAAC,OAAO,EAAE,EAAC,KAAK,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAC,CAAC,CAAC,MAAM,CAAC,IAAI,UAAU,CAAC,KAAK,CAAC,CAAC,CAAA;QAC/F,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,KAAK,YAAY,SAAS;gBAAE,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,6BAA6B,CAAC,CAAA;YACrF,MAAM,KAAK,CAAA;QACb,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK;QAC7B,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;QAEpC,IAAI,IAAI,CAAC,IAAI,IAAI,kBAAkB,EAAE,CAAC;YACpC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;YAEvC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC,CAAA;YACnC,OAAO,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;QACvC,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,IAAI,0BAA0B,EAAE,CAAC;YAC5C,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;YAE9B,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAA;YACtC,OAAO,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAA;QAC1C,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,IAAI,YAAY,EAAE,CAAC;YAC9B,MAAM,SAAS,GAAG,IAAI,CAAC,oBAAoB,EAAE,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAA;YAEjE,IAAI,SAAS,EAAE,CAAC;gBACd,IAAI,CAAC,oBAAoB,EAAE,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAA;gBAClD,OAAO,SAAS,CAAA;YAClB,CAAC;YACD,OAAO,gBAAgB,CAAC,EAAC,IAAI,EAAE,sBAAsB,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAC,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAC,CAAC,CAAA;QAClH,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,IAAI,MAAM,IAAI,IAAI,CAAC,IAAI,IAAI,OAAO,EAAE,CAAC;YAChD,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI;gBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,uCAAuC,CAAC,CAAA;YAC1F,OAAO,gBAAgB,CAAC,EAAC,IAAI,EAAE,gBAAgB,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,CAAC,IAAI,IAAI,MAAM,EAAC,EAAE,EAAC,OAAO,EAAE,QAAQ,EAAC,CAAC,CAAA;QAC9G,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,IAAI,gBAAgB;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,0DAA0D,CAAC,CAAA;QAC9G,IAAI,IAAI,CAAC,IAAI,IAAI,mBAAmB,EAAE,CAAC;YACrC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;YACrC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO,CAAC,CAAA;YACvC,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,UAAU,CAAC,CAAA;YAC7C,MAAM,MAAM,GAAG,gBAAgB,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;YAElD,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAA;YACzC,IAAI,CAAC,MAAM;gBAAE,OAAO,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,6BAA6B,CAAC,CAAA;YACtE,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,QAAQ,CAAC,CAAA;QACvG,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,IAAI,kBAAkB,EAAE,CAAC;YACpC,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,UAAU,CAAC,CAAA;YAC7C,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,UAAU,CAAC,CAAA;YAE7C,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAA;YACtC,IAAI,CAAC,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC;gBAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,4BAA4B,CAAC,CAAA;YAC1F,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,QAAQ,CAAC,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC,EAAE,QAAQ,CAAC,CAAA;QAC7G,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,IAAI,iBAAiB,EAAE,CAAC;YACnC,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAC5B,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAEjC,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,sBAAsB,EAAE,CAAC;gBAC7C,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;gBAE3C,IAAI,SAAS,IAAI,cAAc,EAAE,CAAC;oBAChC,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,IAAI,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,gBAAgB;wBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,oCAAoC,CAAC,CAAA;oBACnI,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAA;oBAE7C,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;wBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,kCAAkC,CAAC,CAAA;oBACvJ,OAAO,gBAAgB,CAAC,EAAC,IAAI,EAAE,gBAAgB,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,CAAC,QAAQ,CAAC,EAAC,EAAE,EAAC,OAAO,EAAE,QAAQ,EAAC,CAAC,CAAA;gBAC3G,CAAC;gBACD,IAAI,SAAS,IAAI,aAAa,EAAE,CAAC;oBAC/B,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,IAAI,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,gBAAgB;wBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,0CAA0C,CAAC,CAAA;oBACzI,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAA;oBAC5C,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAA;oBAE3C,IAAI,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC;wBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,2BAA2B,CAAC,CAAA;oBACpG,OAAO,gBAAgB,CAAC,EAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,EAAE,KAAK,EAAC,EAAE,EAAC,OAAO,EAAE,QAAQ,EAAC,CAAC,CAAA;gBACxF,CAAC;gBACD,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,qBAAqB,CAAC,CAAA;YAC7C,CAAC;YACD,uHAAuH;YACvH,IAAI,MAAM;gBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,6CAA6C,CAAC,CAAA;YAC1E,IAAI,IAAI,IAAI,4BAA4B,EAAE,CAAC;gBACzC,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,IAAI,CAAC;oBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,uBAAuB,CAAC,CAAA;gBACxE,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAA;YACxF,CAAC;YACD,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;YAEhC,IAAI,MAAM,EAAE,CAAC;gBACX,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,IAAI,CAAC;oBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,qBAAqB,CAAC,CAAA;gBACtE,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAA;YACjI,CAAC;YACD,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,IAAI,CAAC;gBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,qBAAqB,CAAC,CAAA;YACtE,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAEzC,IAAI,CAAC,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,MAAM,CAAC;gBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,+BAA+B,CAAC,CAAA;YACjH,OAAO,gBAAgB,CAAC,EAAC,IAAI,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM;gBAC/D,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,EAAC,EAAE,EAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EAAC,CAAC,CAAA;QACtH,CAAC;QACD,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IACxB,CAAC;IAED;;;;;;;;OAQG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ;QACxC,OAAO,yBAAyB,CAAC,CAAC,oBAAoB,CAAC,gBAAgB,CAAC,EAAC,IAAI,EAAE,kBAAkB,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,KAAK,EAAC,EAC5I,EAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAC,CAAC,EAAE,kEAAkE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;IACvH,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ;QACnC,OAAO,yBAAyB,CAAC,CAAC,oBAAoB,CAAC,gBAAgB,CAAC,EAAC,IAAI,EAAE,iBAAiB,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,EAAC,EACvI,EAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAA;IAClD,CAAC;IAED;;;;OAIG;IACH,SAAS,CAAC,IAAI;QACZ,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;QAEpC,IAAI,IAAI,CAAC,IAAI,IAAI,aAAa,EAAE,CAAC;YAC/B,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAC,KAAK,EAAC,EAAE,EAAE,CAAC,KAAK,IAAI,MAAM,CAAC,EAAE,IAAI,CAAA;YAEvE,IAAI,CAAC,QAAQ;gBAAE,OAAO,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAA;YAC3D,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,YAAY,CAAC,CAAA;YACjD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;YAC9B,MAAM,SAAS,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,gBAAgB,CAAA;YAEnD,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC,CAAA;YAC/E,IAAI,SAAS,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,OAAO;gBAAE,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,iBAAiB,CAAC,CAAA;YACvF,IAAI,UAAU,CAAC,IAAI,IAAI,iBAAiB;gBAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,mCAAmC,CAAC,CAAA;YACpG,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,YAAY,CAAC,CAAA;YACjD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,OAAO,CAAC,CAAA;YAE7C,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAA;YAC1C,OAAO,gBAAgB,CAAC,EAAC,IAAI,EAAE,kBAAkB,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC,SAAS;gBACtI,WAAW,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,EAAC,EAAE,EAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,EAAC,CAAC,CAAA;QAC1H,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,IAAI,kBAAkB,EAAE,CAAC;YACpC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;YAE9B,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAA;YAC3C,OAAO,EAAC,IAAI,EAAE,iBAAiB,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAC,CAAA;QACnF,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,IAAI,cAAc,EAAE,CAAC;YAChC,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,WAAW,CAAC,CAAA;YAC/C,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,aAAa,CAAC,CAAA;YACnD,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAC,KAAK,EAAC,EAAE,EAAE,CAAC,KAAK,IAAI,aAAa,CAAC,EAAE,IAAI,CAAA;YAEjF,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,WAAW,EAAE,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;YACvF,MAAM,SAAS,GAAG,EAAC,IAAI,EAAE,oBAAoB,CAAC,CAAC,aAAa,CAAC,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,UAAU,EAAE,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,EAAC,CAAA;YAEpJ,IAAI,CAAC,WAAW;gBAAE,OAAO,SAAS,CAAA;YAClC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAA;YAEzC,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;YACzC,OAAO,EAAC,GAAG,SAAS,EAAE,SAAS,EAAE,MAAM,CAAC,IAAI,IAAI,cAAc;oBAC5D,CAAC,CAAC,EAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,UAAU,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,EAAC,CAAA;QAClH,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,IAAI,sBAAsB,EAAE,CAAC;YACxC,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAA;YAEtC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC,CAAA;YACnC,IAAI,UAAU,CAAC,IAAI,IAAI,uBAAuB,EAAE,CAAC;gBAC/C,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,MAAM,CAAC,CAAA;gBAC3C,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,OAAO,CAAC,CAAA;gBAC7C,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,UAAU,CAAC,CAAA;gBAEnD,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAA;gBAC1C,MAAM,MAAM,GAAG,gBAAgB,CAAC,EAAC,IAAI,EAAE,oBAAoB,CAAC,CAAC,sBAAsB,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAC,EAAE,EAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAC,CAAC,CAAA;gBAE/K,OAAO,gBAAgB,CAAC,EAAC,IAAI,EAAE,qBAAqB,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,EAAC,EAAE,EAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAC,CAAC,CAAA;YACnJ,CAAC;YACD,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;YAElC,IAAI,CAAC,iDAAiD,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,IAAI,CAAC;gBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAA;YAClJ,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAA;YAEhD,MAAM,SAAS,GAAG,EAAC,IAAI,EAAE,oBAAoB,CAAC,CAAC,gBAAgB,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAC,CAAA;YAE9F,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,SAAS,EAAE,EAAC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,oBAAoB,CAAC,MAAM,CAAC,EAAC,CAAC,CAAA;YAChH,OAAO,SAAS,CAAA;QAClB,CAAC;QACD,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IACxB,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,IAAI;QACR,IAAI,IAAI,CAAC,IAAI,IAAI,oBAAoB;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,uBAAuB,CAAC,CAAA;QAC/E,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QAE9B,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAA;QACnD,OAAO,EAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,UAAU,EAAE,IAAI,CAAC,SAAS;gBAC9E,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAC,IAAI,EAAE,KAAK,EAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;gBACpF,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAC,CAAA;IAC/D,CAAC;IAED;;;;OAIG;IACH,QAAQ,CAAC,IAAI;QACX,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;QACrC,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,YAAY,CAAC,CAAA;QACjD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;QAErC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC,CAAA;QAC1C,IAAI,UAAU,CAAC,IAAI,IAAI,qBAAqB;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,mCAAmC,CAAC,CAAA;QAClG,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,YAAY,CAAC,CAAA;QACjD,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,YAAY,CAAC,CAAA;QAEvD,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAA;QAC1C,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAA;QAEpC,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,GAAG,EAAE,uBAAuB,EAAE,GAAG,EAAE,uBAAuB,EAAE,GAAG,CAAC,CAAC,CAAA;QACzF,MAAM,SAAS,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE;YACvD,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,MAAM,CAAC,CAAA;YAC9C,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,YAAY,CAAC,CAAA;YAEpD,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAA;YAC3C,OAAO,gBAAgB,CAAC,EAAC,IAAI,EAAE,oBAAoB,CAAC,CAAC,WAAW,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAC,EAAE,EAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAC,CAAC,CAAA;QACtM,CAAC,CAAC,CAAA;QAEF,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAA;QACjD,OAAO,gBAAgB,CAAC,EAAC,IAAI,EAAE,qBAAqB,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,UAAU,EAAE,SAAS;YACrI,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAC,EAAE,EAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAC,CAAC,CAAA;IACtF,CAAC;IAED;;;;OAIG;IACH,IAAI,CAAC,IAAI;QACP,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;QACrC,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,YAAY,CAAC,CAAA;QACjD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;QAErC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC,CAAA;QAC1C,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,YAAY,CAAC,CAAA;QACjD,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,YAAY,CAAC,CAAA;QAEvD,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAA;QAC1C,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,MAAM;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAA;QAC5F,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAA;QAClC,IAAI,IAAI,CAAC,IAAI,IAAI,oBAAoB;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,sBAAsB,CAAC,CAAA;QAC9E,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QAC9B,MAAM,MAAM,GAAG,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;QAE3B,IAAI,CAAC,MAAM;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,aAAa,CAAC,CAAA;QAC3C,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAA;QACnD,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,gBAAgB,EAAE,GAAG,CAAC,CAAC,CAAA;QACrD,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG;YAAE,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;QAC9E,OAAO,EAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,EAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;gBAC5G,UAAU,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAC,IAAI,EAAE,KAAK,EAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CACjH,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,KAAK,CAAC,QAAQ,IAAI,MAAM,CAAC,UAAU,CAAC,CAAC;oBAC3E,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAC,EAAC,CAAA;IAClE,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,IAAI;QACT,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAA;QACvB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAC,IAAI,EAAC,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,IAAI,SAAS,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,kCAAkC,CAAC,CAAA;QAChI,IAAI,IAAI,CAAC,IAAI,IAAI,kBAAkB;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,2BAA2B,CAAC,CAAA;QACjF,MAAM,OAAO,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAA;QACxD,MAAM,QAAQ,GAAG,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CAAA;QAClE,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,IAAI,SAAS,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,kCAAkC,CAAC,CAAC,CAAA;QAE1I,IAAI,MAAM,CAAC,MAAM,GAAG,QAAQ,CAAC,MAAM;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,+BAA+B,CAAC,CAAA;QACrF,QAAQ,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,CAAA;QACjF,MAAM,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAA;QAE/C,IAAI,CAAC,IAAI,CAAC,SAAS;YAAE,KAAK,MAAM,IAAI,IAAI,SAAS;gBAAE,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAA;QACpF,MAAM,WAAW,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,IAAI,SAAS,IAAI,CAAC,CAAC,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,IAAI,IAAI,aAAa,CAAC,CAAC,CAAA;QAEzH,IAAI,WAAW,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,IAAI,qBAAqB,CAAC;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,0BAA0B,CAAC,CAAA;QAC/G,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,qCAAqC,CAAC,CAAA;QAClF,MAAM,MAAM,GAAG,EAAC,IAAI,EAAE,oBAAoB,CAAC,CAAC,QAAQ,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YAC1J,UAAU,EAAE,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,EAAC,CAAA;QAE7D,IAAI,IAAI,CAAC,SAAS;YAAE,mBAAmB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;QACtD,MAAM,SAAS,GAAG,oBAAoB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;QAErD,IAAI,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAA;QAClC,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,qBAAqB,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;YACvC,MAAM,SAAS,GAAG,WAAW,CAAC,SAAS,CAAC,CAAA;YAExC,IAAI,OAAO,SAAS,IAAI,QAAQ;gBAAE,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAA;YACnG,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,WAAW,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,IAAI,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAA;QAC9F,CAAC;QACD,OAAO,SAAS,CAAA;IAClB,CAAC;IAED;;;;OAIG;IACH,kBAAkB,CAAC,MAAM;QACvB,MAAM,OAAO,GAAG,IAAI,wBAAwB,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;QAC3D;;;;;WAKG;QACH,MAAM,KAAK,GAAG,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE;YACjC,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,CAAA;YAEnC,KAAK,MAAM,SAAS,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;gBACzC,IAAI,SAAS,CAAC,IAAI,IAAI,kBAAkB;oBAAE,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;gBAC3F,IAAI,SAAS,CAAC,IAAI,IAAI,gBAAgB,EAAE,CAAC;oBACvC,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,CAAA;oBAE/C,IAAI,CAAC,QAAQ;wBAAE,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAA;oBACtF,IAAI,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,UAAU,EAAE,QAAQ,CAAC,IAAI,QAAQ,CAAC,IAAI;wBAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,8BAA8B,CAAC,CAAA;gBAC7H,CAAC;gBACD,IAAI,SAAS,CAAC,IAAI,IAAI,aAAa,EAAE,CAAC;oBACpC,KAAK,CAAC,SAAS,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAA;oBACrC,IAAI,SAAS,CAAC,SAAS;wBAAE,KAAK,CAAC,SAAS,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAA;gBAC/D,CAAC;YACH,CAAC;QACH,CAAC,CAAA;QAED,KAAK,MAAM,WAAW,IAAI,MAAM,CAAC,SAAS;YAAE,KAAK,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,CAAC,WAAW,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,IAAI,EAAE,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAA;QAC9J,KAAK,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,EAAE,CAAC,CAAA;IAC1C,CAAC;IAED;;;;OAIG;IACH,sBAAsB,CAAC,IAAI;QACzB,IAAI,IAAI,CAAC,IAAI,IAAI,SAAS,IAAI,4BAA4B,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,+BAA+B,CAAC,CAAA;QAClI,KAAK,MAAM,EAAC,IAAI,EAAE,KAAK,EAAC,IAAI,IAAI,CAAC,QAAQ;YAAE,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAA;IAC/E,CAAC;IAED;;;;OAIG;IACH,WAAW,CAAC,IAAI;QACd,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,EAAC,IAAI,EAAE,KAAK,EAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAClE,KAAK,CAAC,IAAI,IAAI,SAAS,IAAI,4BAA4B,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;IACnF,CAAC;IAED;;;;;;;OAOG;IACH,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,SAAS;QACrC,IAAI,MAAM,CAAC,IAAI,IAAI,QAAQ,CAAC,IAAI,IAAI,MAAM,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK,IAAI,MAAM,CAAC,KAAK,IAAI,QAAQ,CAAC,KAAK;YAAE,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,+BAA+B,CAAC,CAAA;QACxJ,MAAM,IAAI,GAAG,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAA;QACrC,MAAM,KAAK,GAAG,SAAS,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAA;QAE7C,IAAI,IAAI,CAAC,MAAM,IAAI,KAAK,CAAC,MAAM;YAAE,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,gCAAgC,CAAC,CAAA;QACpF,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC;YAAE,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,mDAAmD,CAAC,CAAA;QACzI,IAAI,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;YAC5B,IAAI,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,KAAK,CAAC,EAAE,KAAK,IAAI,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK;gBAAE,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,0BAA0B,CAAC,CAAA;YACnL,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,CAAA;QAClD,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;OAIG;IACH,OAAO,CAAC,IAAI;QACV,OAAO,IAAI,CAAC,IAAI,IAAI,sBAAsB,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,IAAI,iBAAiB,CAAA;IAC9F,CAAC;IAED;;;;OAIG;IACH,mBAAmB,CAAC,QAAQ;QAC1B,MAAM,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,IAAI,SAAS,IAAI,4BAA4B,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;QACrH,0BAA0B;QAC1B,MAAM,UAAU,GAAG,EAAE,CAAA;QACrB,IAAI,MAAM,GAAG,CAAC,CAAA;QAEd,OAAO,MAAM,GAAG,KAAK,CAAC,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;YAAE,MAAM,EAAE,CAAA;QACrE,OAAO,MAAM,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;YAC7B,MAAM,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,CAAA;YAC7B,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,IAAI,SAAS,IAAI,oFAAoF,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAA;YAEpJ,IAAI,CAAC,KAAK;gBAAE,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,4CAA4C,CAAC,CAAA;YAC1E,MAAM,KAAK,GAAG,IAAI,CAAC,oBAAoB,CAAA;YACvC,MAAM,UAAU,GAAG,IAAI,CAAC,cAAc,CAAA;YAEtC,IAAI,CAAC,oBAAoB,GAAG,IAAI,GAAG,EAAE,CAAA;YACrC,IAAI,CAAC,cAAc,GAAG,IAAI,GAAG,EAAE,CAAA;YAC/B,OAAO,MAAM,GAAG,KAAK,CAAC,MAAM,IAAI,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;gBAAE,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;YACpH,MAAM,QAAQ,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,CAAA;YAEhC,IAAI,CAAC,QAAQ;gBAAE,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,0BAA0B,CAAC,CAAA;YAC3D,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAA;YAE1C,IAAI,IAAI,CAAC,oBAAoB,CAAC,IAAI,IAAI,CAAC;gBAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,8BAA8B,CAAC,CAAA;YAC5F,IAAI,SAAS,CAAC,IAAI,IAAI,kBAAkB,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;gBAAE,MAAM,EAAE,CAAA;YAClG,MAAM,GAAG,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,CAAA;YAE3B,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,IAAI,IAAI,SAAS,IAAI,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,gDAAgD,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK;gBAAE,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,KAAK,EAAE,qBAAqB,CAAC,CAAA;YAChL,IAAI,CAAC,oBAAoB,GAAG,KAAK,CAAA;YACjC,IAAI,CAAC,cAAc,GAAG,UAAU,CAAA;YAChC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;QAC5B,CAAC;QACD,OAAO,UAAU,CAAA;IACnB,CAAC;IAED;;;;OAIG;IACH,oBAAoB,CAAC,IAAI;QACvB,IAAI,IAAI,CAAC,IAAI,IAAI,aAAa;YAAE,OAAO,KAAK,CAAA;QAC5C,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAC,KAAK,EAAC,EAAE,EAAE,CAAC,KAAK,IAAI,YAAY,CAAC,EAAE,IAAI,CAAA;QAC/E,MAAM,IAAI,GAAG,UAAU,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAC,KAAK,EAAC,EAAE,EAAE,CAAC,KAAK,IAAI,YAAY,CAAC,EAAE,IAAI,CAAA;QAEhF,OAAO,IAAI,EAAE,IAAI,IAAI,YAAY,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,UAAU,CAAC,sBAAsB,CAAC,CAAA;IACzF,CAAC;IAED;;;;;OAKG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM;QACzB,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,CAAA;QAC5B,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,YAAY,CAAC,CAAA;QACjD,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,YAAY,CAAC,CAAA;QACrD,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QAChC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;QACrC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,OAAO,CAAC,CAAA;QAE7C,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,UAAU,EAAE,GAAG,CAAC,CAAC,CAAA;QACzC,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,QAAQ,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAA;QAC9C,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QACf,IAAI,CAAC,iCAAiC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,cAAc,EAAE,GAAG,CAAC,IAAI,CAAC;YAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,+BAA+B,CAAC,CAAA;QACzI,IAAI,CAAC,cAAc,EAAE,GAAG,CAAC,IAAI,CAAC,CAAA;QAC9B,IAAI,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAA;QACvC,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,CAAA;QAE5B,IAAI,MAAM,EAAE,IAAI,IAAI,cAAc,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;YAC3F,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;YACjD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;YAE9C,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC,CAAA;YAC3C,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAA;YAC3D,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAA;YACrC,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,IAAI,kBAAkB,CAAA;YAC5C,MAAM,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA;YAEzD,IAAI,MAAM,CAAC,IAAI,IAAI,YAAY,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI;gBAAE,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,8BAA8B,CAAC,CAAA;YAC/G,IAAI,IAAI;gBAAE,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,CAAA;YACzC,IAAI,IAAI,CAAC,IAAI,IAAI,oBAAoB;gBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,qBAAqB,CAAC,CAAA;YAC7E,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;YAClD,IAAI,MAAM,GAAG,CAAC,CAAA;YAEd,OAAO,MAAM,GAAG,MAAM,CAAC,MAAM,IAAI,IAAI,CAAC,oBAAoB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;gBAAE,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;YACvH,IAAI,MAAM,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC;gBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,2BAA2B,CAAC,CAAA;YAC7E,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,CAAA;YAEjC,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,uBAAuB,EAAE,GAAG,CAAC,CAAC,CAAA;YACtD,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAA;YAC1C,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAA;YACzC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAA;YAE3C,IAAI,CAAC,KAAK,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,CAAA;YACxC,IAAI,IAAI,CAAC,IAAI,IAAI,YAAY,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI;gBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,4BAA4B,CAAC,CAAA;YACvG,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,GAAG,EAAE,mBAAmB,EAAE,GAAG,CAAC,CAAC,CAAA;YAClD,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;YACnC,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;YAC3C,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;YAC3C,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;YAE/C,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAA;YAC3D,IAAI,QAAQ,CAAC,IAAI,IAAI,YAAY,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,IAAI;gBAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,8BAA8B,CAAC,CAAA;YACrH,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,CAAA;YACnG,MAAM,EAAE,CAAA;QACV,CAAC;QACD,IAAI,CAAC,oBAAoB,EAAE,GAAG,CAAC,IAAI,EAAE,UAAU,CAAC,CAAA;QAChD,OAAO,MAAM,CAAA;IACf,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,UAAU,QAAQ,CAAC,EAAC,QAAQ,EAAE,MAAM,EAAC;IACzC,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,EAAE,CAAC;QACnC,MAAM,WAAW,GAAG,qBAAqB,CAAC,MAAM,CAAC,CAAA;QACjD,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,yEAAyE,CAAC,CAAA;QAEvG,MAAM,IAAI,qBAAqB,CAAC,EAAC,IAAI,EAAE,aAAa,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,8CAA8C;YAC5H,QAAQ,EAAE,EAAC,QAAQ,EAAE,KAAK,EAAE,cAAc,CAAC,WAAW,EAAE,MAAM,CAAC,EAAE,GAAG,EAAE,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,CAAC,CAAC,EAAC,EAAC,CAAC,CAAA;IACpH,CAAC;IACD,IAAI,MAAM,CAAC,MAAM,GAAG,sBAAsB,EAAE,CAAC;QAC3C,MAAM,WAAW,GAAG,qBAAqB,CAAC,MAAM,CAAC,CAAA;QAEjD,OAAO,iBAAiB,CAAC,KAAK,EAAE,iEAAiE,EAAE;YACjG,QAAQ,EAAE,KAAK,EAAE,cAAc,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,cAAc,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC;SACjG,CAAC,CAAA;IACJ,CAAC;IACD,IAAI,QAAQ,CAAA;IAEZ,IAAI,CAAC;QACH,QAAQ,GAAG,WAAW,CAAC,MAAM,CAAC,CAAA;IAChC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,WAAW,GAAG,qBAAqB,CAAC,MAAM,CAAC,CAAA;QAEjD,MAAM,IAAI,qBAAqB,CAAC,EAAC,IAAI,EAAE,aAAa,EAAE,QAAQ,EAAE,KAAK;YACnE,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,EAAE,OAAO,EAAE,4DAA4D;YACxH,QAAQ,EAAE,EAAC,QAAQ,EAAE,KAAK,EAAE,cAAc,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,cAAc,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,EAAC,EAAC,CAAC,CAAA;IAClH,CAAC;IACD,MAAM,MAAM,GAAG,IAAI,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAA;IAE9C,IAAI,CAAC;QACH,OAAO,MAAM,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;IACrC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,MAAM,CAAC,SAAS,IAAI,KAAK,YAAY,qBAAqB,IAAI,KAAK,CAAC,QAAQ,IAAI,KAAK;YACvF,KAAK,CAAC,IAAI,IAAI,aAAa,IAAI,KAAK,CAAC,IAAI,IAAI,oBAAoB,EAAE,CAAC;YACpE,OAAO,iBAAiB,CAAC,KAAK,EAAE,uCAAuC,KAAK,CAAC,IAAI,EAAE,EAAE,KAAK,CAAC,QAAQ,IAAI,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAA;QACxI,CAAC;QACD,MAAM,KAAK,CAAA;IACb,CAAC;AACH,CAAC","sourcesContent":["// @ts-check\n\nimport {generateCpp} from \"../backends/cpp.js\"\nimport {OrderedExpressionPlanner} from \"../backends/ordered-expressions.js\"\nimport {maximumCppSourceLength} from \"../backends/cpp-validation.js\"\nimport {validateNativeGraph} from \"../backends/native-validation.js\"\nimport {cppRuntime} from \"../backends/cpp-runtime.js\"\nimport {validateBackendModule} from \"../backends/shared.js\"\nimport {isCppIdentifier} from \"../backends/identifiers.js\"\nimport {parseCppCst} from \"./cpp-parser.js\"\nimport {missingType, SemantifoldDiagnostic, unsupportedSyntax} from \"../diagnostic.js\"\nimport {createCoordinateIndex, indexedPointAt} from \"../semantic/location.js\"\nimport {withAdaptedOperation} from \"../semantic/operators.js\"\nimport {withParserRanges} from \"../semantic/provenance.js\"\nimport {hasOnlyUnicodeScalars} from \"../semantic/scalars.js\"\nimport {validateParsedModule} from \"../semantic/validate.js\"\nimport {sourceScalarType} from \"./scalars.js\"\n\n/** @typedef {import(\"./cpp-parser.js\").CstNode} CstNode */\n/** @typedef {import(\"../semantic/types.js\").Expression} Expression */\n/** @typedef {import(\"../semantic/types.js\").Statement} Statement */\n\nconst binaryOperations = new Map([\n  [\"+\", \"Add\"], [\"-\", \"Subtract\"], [\"*\", \"Multiply\"], [\"==\", \"Equal\"], [\"!=\", \"NotEqual\"],\n  [\"<\", \"LessThan\"], [\"<=\", \"LessThanOrEqual\"], [\">\", \"GreaterThan\"], [\">=\", \"GreaterThanOrEqual\"],\n  [\"&&\", \"And\"], [\"||\", \"Or\"]\n])\nconst helpers = new Map([\n  [\"semantifold_integer_add\", \"PhpAdd\"], [\"semantifold_integer_subtract\", \"Subtract\"],\n  [\"semantifold_integer_multiply\", \"Multiply\"], [\"semantifold_string_concat\", \"StringConcat\"],\n  [\"semantifold_string_equal\", \"StringEqual\"], [\"semantifold_string_not_equal\", \"StringNotEqual\"]\n])\n\n/** Strict field-and-token consumer for the private frozen CPP CST. */\nexport class CppReader {\n  /**\n   * Owns source content and its coordinate index, never native parser handles.\n   * @param {string} filename - Original filename.\n   * @param {string} source - Exact original source.\n   */\n  constructor(filename, source) {\n    this.filename = filename\n    this.source = source\n    this.coordinates = createCoordinateIndex(source)\n    this.generated = false\n    /** @type {Map<string, Expression> | undefined} */\n    this.temporaryExpressions = undefined\n    /** @type {Set<string> | undefined} */\n    this.temporaryNames = undefined\n    /** @type {Map<Statement, {node: CstNode, type: string}>} */\n    this.printTypes = new Map()\n    /** @type {Set<string>} */\n    this.declaredFunctions = new Set()\n  }\n\n  /**\n   * Locates one parser-owned range in UTF-16 coordinates.\n   * @param {CstNode} node - Parser node.\n   * @returns {import(\"../semantic/types.js\").SourceLocation} Verified location.\n   */\n  location(node) {\n    return {filename: this.filename, start: indexedPointAt(this.coordinates, node.startIndex), end: indexedPointAt(this.coordinates, node.endIndex)}\n  }\n\n  /**\n   * Reads only the spelling of an already recognized parser node.\n   * @param {CstNode} node - Parser node.\n   * @returns {string} Exact token spelling.\n   */\n  text(node) {\n    return this.source.slice(node.startIndex, node.endIndex)\n  }\n\n  /**\n   * Rejects a located source-profile violation.\n   * @param {CstNode} node - Rejected node.\n   * @param {string} [detail] - Profile violation.\n   * @returns {never} Always throws.\n   */\n  fail(node, detail = node.type) {\n    unsupportedSyntax(\"cpp\", detail, this.location(node))\n  }\n\n  /**\n   * Traverses all edges before interpreting any source meaning.\n   * @param {CstNode} node - Current parser node.\n   * @param {number} [depth] - Bounded CST traversal depth.\n   * @returns {void}\n   */\n  validateTree(node, depth = 0) {\n    if (depth > 512) this.fail(node, \"CPP CST exceeds the 512-level traversal limit\")\n    for (const {node: child} of node.children) this.validateTree(child, depth + 1)\n    if (node.error || node.missing || node.hasError) {\n      throw new SemantifoldDiagnostic({code: \"PARSE_ERROR\", language: \"cpp\", location: this.location(node), message: `CPP parser recovery at '${node.type}'.`})\n    }\n    if (node.extra && node.type != \"comment\") this.fail(node, \"unexpected extra parser child\")\n    if ((node.type == \"comment\" || node.type == \"string_content\") && /\\?\\?[=/'()!<>-]/u.test(this.text(node))) {\n      this.fail(node, \"trigraph preprocessing\")\n    }\n    if (node.type == \"comment\") {\n      const text = this.text(node)\n\n      // A terminal CR belongs to ordinary CRLF; content after a bare CR is not a CPP line comment.\n      if (/\\\\(?:\\r\\n?|\\n)/u.test(text) || text.startsWith(\"//\") && /\\r(?!\\n|$)/u.test(text)) {\n        this.fail(node, \"preprocessing-sensitive comment\")\n      }\n    }\n  }\n\n  /**\n   * Separates harmless comments after every child has been validated.\n   * @param {CstNode} node - Parent node.\n   * @returns {CstNode[]} Ordered structural children.\n   */\n  parts(node) {\n    return node.children.map(({node: child}) => child).filter((child) => child.type != \"comment\")\n  }\n\n  /**\n   * Requires one exact field rather than searching descendants.\n   * @param {CstNode} node - Field owner.\n   * @param {string} name - Field name.\n   * @returns {CstNode} Sole field child.\n   */\n  field(node, name) {\n    const matches = node.children.filter(({field}) => field == name)\n\n    if (matches.length != 1) return this.fail(node, `expected one '${name}' field`)\n    return matches[0].node\n  }\n\n  /**\n   * Consumes every structural child, including punctuation.\n   * @param {CstNode} node - Shape owner.\n   * @param {(CstNode | string)[]} expected - Ordered nodes or token kinds.\n   * @returns {void}\n   */\n  shape(node, expected) {\n    const children = this.parts(node)\n\n    if (children.length != expected.length || children.some((child, index) =>\n      typeof expected[index] == \"string\" ? child.type != expected[index] : child !== expected[index])) this.fail(node, `${node.type} child shape`)\n  }\n\n  /**\n   * Requires an ordinary caller identifier outside the protected namespace.\n   * @param {CstNode} node - Identifier token.\n   * @returns {string} Accepted spelling.\n   */\n  identifier(node) {\n    const name = this.text(node)\n\n    if (node.type != \"identifier\" || !isCppIdentifier(name)) this.fail(node, \"reserved or unsupported identifier\")\n    return name\n  }\n\n  /**\n   * Converts only the canonical scalar type spellings.\n   * @param {CstNode} node - Type token.\n   * @returns {import(\"../semantic/types.js\").TypeReference} Semantic scalar.\n   */\n  type(node) {\n    const spelling = node.type == \"qualified_identifier\" ? this.qualified(node) : this.text(node)\n\n    if (node.type != \"qualified_identifier\" && (node.type != \"primitive_type\" || spelling != \"bool\")) this.fail(node, \"scalar type shape\")\n    const type = sourceScalarType(\"cpp\", spelling, this.location(node))\n\n    if (!type) return this.fail(node, \"unsupported scalar type\")\n    return type\n  }\n\n  /**\n   * Reads exactly one std-qualified scalar name from CPP fields and punctuation.\n   * @param {CstNode} node - Qualified grammar node.\n   * @returns {string} Canonical qualified scalar spelling.\n   */\n  qualified(node) {\n    const scope = this.field(node, \"scope\")\n    const name = this.field(node, \"name\")\n\n    this.shape(node, [scope, \"::\", name])\n    if (scope.type != \"namespace_identifier\" || this.text(scope) != \"std\" ||\n      ![\"type_identifier\", \"identifier\"].includes(name.type) || ![\"int64_t\", \"string\"].includes(this.text(name))) this.fail(node, \"qualified scalar name\")\n    return \"std::\" + this.text(name)\n  }\n\n  /**\n   * Converts a direct function call's exact argument list.\n   * @param {CstNode} node - Call node.\n   * @returns {{name: CstNode, arguments: CstNode[]}} Parsed call shape.\n   */\n  call(node) {\n    if (node.type != \"call_expression\") return this.fail(node, \"direct call required\")\n    const name = this.field(node, \"function\")\n    const list = this.field(node, \"arguments\")\n\n    this.shape(node, [name, list])\n    if (![\"identifier\", \"qualified_identifier\"].includes(name.type) || list.type != \"argument_list\") this.fail(node, \"direct call shape\")\n    const parts = this.parts(list)\n    const args = parts.slice(1, -1).filter((_part, index) => index % 2 == 0)\n\n    this.shape(list, [\"(\", ...args.flatMap((arg, index) => index == 0 ? [arg] : [\",\", arg]), \")\"])\n    return {arguments: args, name}\n  }\n\n  /**\n   * Decodes a parser-backed ordinary CPP string token as UTF-8 bytes.\n   * @param {CstNode} node - String literal.\n   * @returns {string} Complete Unicode scalar value.\n   */\n  string(node) {\n    if (node.type != \"string_literal\") return this.fail(node, \"ordinary string literal required\")\n    const parts = this.parts(node)\n\n    if (parts[0]?.type != '\"' || parts.at(-1)?.type != '\"') this.fail(node, \"prefixed string literal\")\n    const bytes = []\n\n    for (let index = 1; index < parts.length - 1; index++) {\n      const child = parts[index]\n      const text = this.text(child)\n\n      if (child.type == \"string_content\") {\n        if (/[\\r\\n]/u.test(text)) this.fail(child, \"raw line terminator in string literal\")\n        for (const byte of new TextEncoder().encode(text)) bytes.push(byte)\n      }\n      else if (child.type == \"escape_sequence\") {\n        const simple = new Map([[\"a\", 7], [\"b\", 8], [\"f\", 12], [\"n\", 10], [\"r\", 13], [\"t\", 9], [\"v\", 11], [\"\\\\\", 92], ['\"', 34], [\"'\", 39], [\"?\", 63]])\n        const value = text.slice(1)\n\n        if (text[0] != \"\\\\\") this.fail(child, \"invalid escape\")\n        if (simple.has(value)) bytes.push(/** @type {number} */ (simple.get(value)))\n        else if (/^[0-7]{1,3}$/u.test(value) || /^x[0-9a-fA-F]+$/u.test(value)) {\n          const next = parts[index + 1]\n\n          // CPP consumes every adjacent hex digit; the frozen grammar caps each escape node at four.\n          if (value.startsWith(\"x\") && next.type == \"string_content\" && next.startIndex == child.endIndex && /^[0-9a-fA-F]/u.test(this.text(next))) {\n            this.fail(child, \"hexadecimal escape split by parser boundary\")\n          }\n          const number = Number.parseInt(value[0] == \"x\" ? value.slice(1) : value, value[0] == \"x\" ? 16 : 8)\n\n          if (number > 255) this.fail(child, \"escape outside byte range\")\n          bytes.push(number)\n        } else this.fail(child, \"unsupported escape\")\n      } else this.fail(child, \"string child\")\n    }\n    try {\n      return new TextDecoder(\"utf-8\", {fatal: true, ignoreBOM: true}).decode(new Uint8Array(bytes))\n    } catch (error) {\n      if (error instanceof TypeError) return this.fail(node, \"invalid UTF-8 literal bytes\")\n      throw error\n    }\n  }\n\n  /**\n   * Converts supported expressions without assuming CPP argument evaluation order.\n   * @param {CstNode} node - Expression node.\n   * @param {boolean} [nested] - Whether a semantic call would have unspecified order.\n   * @returns {Expression} Semantic expression.\n   */\n  expression(node, nested = false) {\n    const location = this.location(node)\n\n    if (node.type == \"condition_clause\") {\n      const value = this.field(node, \"value\")\n\n      this.shape(node, [\"(\", value, \")\"])\n      return this.expression(value, nested)\n    }\n    if (node.type == \"parenthesized_expression\") {\n      const parts = this.parts(node)\n\n      this.shape(node, [\"(\", parts[1], \")\"])\n      return this.expression(parts[1], nested)\n    }\n    if (node.type == \"identifier\") {\n      const temporary = this.temporaryExpressions?.get(this.text(node))\n\n      if (temporary) {\n        this.temporaryExpressions?.delete(this.text(node))\n        return temporary\n      }\n      return withParserRanges({kind: \"IdentifierExpression\", location, name: this.identifier(node)}, {name: location})\n    }\n    if (node.type == \"true\" || node.type == \"false\") {\n      if (this.text(node) != node.type) this.fail(node, \"noncanonical Boolean literal spelling\")\n      return withParserRanges({kind: \"BooleanLiteral\", location, value: node.type == \"true\"}, {literal: location})\n    }\n    if (node.type == \"number_literal\") this.fail(node, \"integer literal requires exact std::int64_t construction\")\n    if (node.type == \"binary_expression\") {\n      const left = this.field(node, \"left\")\n      const right = this.field(node, \"right\")\n      const operator = this.field(node, \"operator\")\n      const intent = binaryOperations.get(operator.type)\n\n      this.shape(node, [left, operator, right])\n      if (!intent) return this.fail(operator, \"unsupported binary operator\")\n      return this.binary(node, intent, this.expression(left, true), this.expression(right, true), operator)\n    }\n    if (node.type == \"unary_expression\") {\n      const operator = this.field(node, \"operator\")\n      const argument = this.field(node, \"argument\")\n\n      this.shape(node, [operator, argument])\n      if (![\"-\", \"!\"].includes(operator.type)) this.fail(operator, \"unsupported unary operator\")\n      return this.unary(node, operator.type == \"-\" ? \"Negate\" : \"Not\", this.expression(argument, true), operator)\n    }\n    if (node.type == \"call_expression\") {\n      const call = this.call(node)\n      const name = this.text(call.name)\n\n      if (call.name.type == \"qualified_identifier\") {\n        const qualified = this.qualified(call.name)\n\n        if (qualified == \"std::int64_t\") {\n          if (call.arguments.length != 1 || call.arguments[0].type != \"number_literal\") this.fail(node, \"exact integer literal construction\")\n          const spelling = this.text(call.arguments[0])\n\n          if (!/^(?:0|[1-9][0-9]*)$/u.test(spelling) || !Number.isSafeInteger(Number(spelling))) this.fail(call.arguments[0], \"non-safe or noncanonical integer\")\n          return withParserRanges({kind: \"IntegerLiteral\", location, value: Number(spelling)}, {literal: location})\n        }\n        if (qualified == \"std::string\") {\n          if (call.arguments.length != 2 || call.arguments[1].type != \"number_literal\") this.fail(node, \"byte-counted string literal construction\")\n          const value = this.string(call.arguments[0])\n          const length = this.text(call.arguments[1])\n\n          if (length != String(Buffer.byteLength(value, \"utf8\"))) this.fail(node, \"string literal byte count\")\n          return withParserRanges({kind: \"StringLiteral\", location, value}, {literal: location})\n        }\n        this.fail(call.name, \"qualified user call\")\n      }\n      // Generated operations are separate temporary initializers; only exact scalar literal constructions may nest as calls.\n      if (nested) this.fail(node, \"caller call in unspecified-order expression\")\n      if (name == \"semantifold_integer_negate\") {\n        if (call.arguments.length != 1) this.fail(node, \"negation helper arity\")\n        return this.unary(node, \"Negate\", this.expression(call.arguments[0], true), call.name)\n      }\n      const intent = helpers.get(name)\n\n      if (intent) {\n        if (call.arguments.length != 2) this.fail(node, \"scalar helper arity\")\n        return this.binary(node, intent, this.expression(call.arguments[0], true), this.expression(call.arguments[1], true), call.name)\n      }\n      if (call.arguments.length != 2) this.fail(node, \"semantic call arity\")\n      const callee = this.identifier(call.name)\n\n      if (!this.generated && !this.declaredFunctions.has(callee)) this.fail(call.name, \"implicit function declaration\")\n      return withParserRanges({kind: \"CallExpression\", location, callee,\n        arguments: call.arguments.map((argument) => this.expression(argument, true))}, {callee: this.location(call.name)})\n    }\n    return this.fail(node)\n  }\n\n  /**\n   * Records parser intent before shared type resolution.\n   * @param {CstNode} node - Owning expression.\n   * @param {string} intent - Adapted operation.\n   * @param {Expression} left - Left operand.\n   * @param {Expression} right - Right operand.\n   * @param {CstNode} operator - Operator token.\n   * @returns {Expression} Pending binary expression.\n   */\n  binary(node, intent, left, right, operator) {\n    return /** @type {Expression} */ (withAdaptedOperation(withParserRanges({kind: \"BinaryExpression\", location: this.location(node), left, right},\n      {operator: this.location(operator)}), /** @type {import(\"../semantic/operators.js\").AdaptedOperation} */ (intent)))\n  }\n\n  /**\n   * Records parser intent for a unary operation.\n   * @param {CstNode} node - Owning expression.\n   * @param {\"Negate\" | \"Not\"} intent - Adapted operation.\n   * @param {Expression} operand - Operand.\n   * @param {CstNode} operator - Operator token.\n   * @returns {Expression} Pending unary expression.\n   */\n  unary(node, intent, operand, operator) {\n    return /** @type {Expression} */ (withAdaptedOperation(withParserRanges({kind: \"UnaryExpression\", location: this.location(node), operand},\n      {operator: this.location(operator)}), intent))\n  }\n\n  /**\n   * Converts one initialized declaration or executable statement.\n   * @param {CstNode} node - Statement node.\n   * @returns {Statement} Semantic statement.\n   */\n  statement(node) {\n    const location = this.location(node)\n\n    if (node.type == \"declaration\") {\n      const typeNode = node.children.find(({field}) => field == \"type\")?.node\n\n      if (!typeNode) return missingType(\"cpp\", \"local\", location)\n      const declarator = this.field(node, \"declarator\")\n      const parts = this.parts(node)\n      const immutable = parts[0].type == \"type_qualifier\"\n\n      this.shape(node, [...(immutable ? [parts[0]] : []), typeNode, declarator, \";\"])\n      if (immutable && this.text(parts[0]) != \"const\") this.fail(parts[0], \"local qualifier\")\n      if (declarator.type != \"init_declarator\") this.fail(declarator, \"initialized simple local required\")\n      const name = this.field(declarator, \"declarator\")\n      const value = this.field(declarator, \"value\")\n\n      this.shape(declarator, [name, \"=\", value])\n      return withParserRanges({kind: \"LocalDeclaration\", location, name: this.identifier(name), type: this.type(typeNode), mutable: !immutable,\n        initializer: this.expression(value)}, {name: this.location(name), operator: this.location(this.parts(declarator)[1])})\n    }\n    if (node.type == \"return_statement\") {\n      const parts = this.parts(node)\n\n      this.shape(node, [\"return\", parts[1], \";\"])\n      return {kind: \"ReturnStatement\", location, expression: this.expression(parts[1])}\n    }\n    if (node.type == \"if_statement\") {\n      const condition = this.field(node, \"condition\")\n      const consequence = this.field(node, \"consequence\")\n      const alternative = node.children.find(({field}) => field == \"alternative\")?.node\n\n      this.shape(node, [\"if\", condition, consequence, ...(alternative ? [alternative] : [])])\n      const statement = {kind: /** @type {const} */ (\"IfStatement\"), location, condition: this.expression(condition), consequent: this.block(consequence)}\n\n      if (!alternative) return statement\n      const branch = this.parts(alternative)[1]\n\n      this.shape(alternative, [\"else\", branch])\n      return {...statement, alternate: branch.type == \"if_statement\"\n        ? {kind: \"Block\", location: this.location(branch), statements: [this.statement(branch)]} : this.block(branch)}\n    }\n    if (node.type == \"expression_statement\") {\n      const expression = this.parts(node)[0]\n\n      this.shape(node, [expression, \";\"])\n      if (expression.type == \"assignment_expression\") {\n        const left = this.field(expression, \"left\")\n        const right = this.field(expression, \"right\")\n        const operator = this.field(expression, \"operator\")\n\n        this.shape(expression, [left, \"=\", right])\n        const target = withParserRanges({kind: /** @type {const} */ (\"IdentifierExpression\"), name: this.identifier(left), location: this.location(left)}, {name: this.location(left)})\n\n        return withParserRanges({kind: \"AssignmentStatement\", location, target, expression: this.expression(right)}, {operator: this.location(operator)})\n      }\n      const call = this.call(expression)\n\n      if (!/^semantifold_print_(?:integer|boolean|string)$/u.test(this.text(call.name)) || call.arguments.length != 1) this.fail(node, \"print scaffold\")\n      const value = this.expression(call.arguments[0])\n\n      const statement = {kind: /** @type {const} */ (\"PrintStatement\"), location, expression: value}\n\n      this.printTypes.set(statement, {node: call.name, type: this.text(call.name).slice(\"semantifold_print_\".length)})\n      return statement\n    }\n    return this.fail(node)\n  }\n\n  /**\n   * Converts one lexical braced block in source order.\n   * @param {CstNode} node - Block node.\n   * @returns {import(\"../semantic/types.js\").Block} Semantic block.\n   */\n  block(node) {\n    if (node.type != \"compound_statement\") this.fail(node, \"braced block required\")\n    const parts = this.parts(node)\n\n    this.shape(node, [\"{\", ...parts.slice(1, -1), \"}\"])\n    return {kind: \"Block\", location: this.location(node), statements: this.generated\n      ? this.generatedStatements(node.children.map(({node: child}) => child).slice(1, -1))\n      : parts.slice(1, -1).map((child) => this.statement(child))}\n  }\n\n  /**\n   * Converts one namespace-scope semantic function.\n   * @param {CstNode} node - Function definition.\n   * @returns {import(\"../semantic/types.js\").FunctionDeclaration} Semantic function.\n   */\n  function(node) {\n    const type = this.field(node, \"type\")\n    const declarator = this.field(node, \"declarator\")\n    const body = this.field(node, \"body\")\n\n    this.shape(node, [type, declarator, body])\n    if (declarator.type != \"function_declarator\") this.fail(node, \"namespace-scope function required\")\n    const name = this.field(declarator, \"declarator\")\n    const parameters = this.field(declarator, \"parameters\")\n\n    this.shape(declarator, [name, parameters])\n    const parts = this.parts(parameters)\n\n    this.shape(parameters, [\"(\", \"parameter_declaration\", \",\", \"parameter_declaration\", \")\"])\n    const converted = [parts[1], parts[3]].map((parameter) => {\n      const typeNode = this.field(parameter, \"type\")\n      const nameNode = this.field(parameter, \"declarator\")\n\n      this.shape(parameter, [typeNode, nameNode])\n      return withParserRanges({kind: /** @type {const} */ (\"Parameter\"), location: this.location(parameter), name: this.identifier(nameNode), type: this.type(typeNode)}, {name: this.location(nameNode)})\n    })\n\n    this.declaredFunctions.add(this.identifier(name))\n    return withParserRanges({kind: \"FunctionDeclaration\", location: this.location(node), name: this.identifier(name), parameters: converted,\n      returnType: this.type(type), body: this.block(body)}, {name: this.location(name)})\n  }\n\n  /**\n   * Removes only the exact parameterless main and zero-status scaffolding.\n   * @param {CstNode} node - Entry definition.\n   * @returns {import(\"../semantic/types.js\").EntryPoint} Semantic entry.\n   */\n  main(node) {\n    const type = this.field(node, \"type\")\n    const declarator = this.field(node, \"declarator\")\n    const body = this.field(node, \"body\")\n\n    this.shape(node, [type, declarator, body])\n    const name = this.field(declarator, \"declarator\")\n    const parameters = this.field(declarator, \"parameters\")\n\n    this.shape(declarator, [name, parameters])\n    if (this.text(type) != \"int\" || this.text(name) != \"main\") this.fail(node, \"main signature\")\n    this.shape(parameters, [\"(\", \")\"])\n    if (body.type != \"compound_statement\") this.fail(body, \"braced main required\")\n    const parts = this.parts(body)\n    const status = parts.at(-2)\n\n    if (!status) this.fail(body, \"main status\")\n    this.shape(body, [\"{\", ...parts.slice(1, -1), \"}\"])\n    this.shape(status, [\"return\", \"number_literal\", \";\"])\n    if (this.text(this.parts(status)[1]) != \"0\") this.fail(status, \"entry status\")\n    return {kind: \"EntryPoint\", location: this.location(node), body: {kind: \"Block\", location: this.location(body),\n      statements: this.generated ? this.generatedStatements(body.children.map(({node: child}) => child).filter((child) =>\n        child.startIndex > body.startIndex && child.endIndex <= status.startIndex))\n        : parts.slice(1, -2).map((child) => this.statement(child))}}\n  }\n\n  /**\n   * Converts one complete translation unit after exhaustive recovery rejection.\n   * @param {CstNode} root - Frozen translation unit.\n   * @returns {import(\"../semantic/types.js\").SemanticModule} Validated semantic module.\n   */\n  module(root) {\n    this.validateTree(root)\n    this.generated = root.children.some(({node}) => node.type == \"comment\" && this.text(node) == \"/* semantifold:program:cpp:v1 */\")\n    if (root.type != \"translation_unit\") this.fail(root, \"translation unit required\")\n    const runtime = new CppReader(this.filename, cppRuntime)\n    const expected = runtime.significant(parseCppCst(cppRuntime).root)\n    const actual = this.significant(root).filter((node) => !(node.type == \"comment\" && this.text(node) == \"/* semantifold:program:cpp:v1 */\"))\n\n    if (actual.length < expected.length) this.fail(root, \"complete CPP runtime required\")\n    expected.forEach((node, index) => this.compareTree(actual[index], node, runtime))\n    const remaining = actual.slice(expected.length)\n\n    if (!this.generated) for (const node of remaining) this.rejectScaffoldComments(node)\n    const definitions = remaining.filter((node) => node.type != \"comment\" && (!this.generated || node.type != \"declaration\"))\n\n    if (definitions.some((node) => node.type != \"function_definition\")) this.fail(root, \"translation unit members\")\n    if (definitions.length < 2) this.fail(root, \"semantic function and main required\")\n    const module = {kind: /** @type {const} */ (\"Module\"), location: this.location(root), functions: definitions.slice(0, -1).map((node) => this.function(node)),\n      entryPoint: this.main(definitions[definitions.length - 1])}\n\n    if (this.generated) validateNativeGraph(module, \"cpp\")\n    const validated = validateParsedModule(module, \"cpp\")\n\n    this.validatePrintTypes(validated)\n    if (this.generated) {\n      validateBackendModule(validated, \"cpp\")\n      const canonical = generateCpp(validated)\n\n      if (typeof canonical != \"string\") throw new Error(\"CPP backend returned a nontext entry artifact.\")\n      this.compareTree(root, parseCppCst(canonical).root, new CppReader(this.filename, canonical))\n    }\n    return validated\n  }\n\n  /**\n   * Checks native print helper selection after semantic scalar resolution.\n   * @param {import(\"../semantic/types.js\").SemanticModule} module - Resolved module.\n   * @returns {void}\n   */\n  validatePrintTypes(module) {\n    const planner = new OrderedExpressionPlanner(module, \"cpp\")\n    /**\n     * Checks one lexical block with its visible scalar bindings.\n     * @param {import(\"../semantic/types.js\").Block} block - Semantic block.\n     * @param {Map<string, import(\"../semantic/types.js\").SemanticTypeName>} inherited - Visible bindings.\n     * @returns {void}\n     */\n    const visit = (block, inherited) => {\n      const bindings = new Map(inherited)\n\n      for (const statement of block.statements) {\n        if (statement.kind == \"LocalDeclaration\") bindings.set(statement.name, statement.type.name)\n        if (statement.kind == \"PrintStatement\") {\n          const expected = this.printTypes.get(statement)\n\n          if (!expected) throw new Error(\"CPP print statement lost its parser helper identity.\")\n          if (planner.type(statement.expression, bindings) != expected.type) this.fail(expected.node, \"print helper scalar mismatch\")\n        }\n        if (statement.kind == \"IfStatement\") {\n          visit(statement.consequent, bindings)\n          if (statement.alternate) visit(statement.alternate, bindings)\n        }\n      }\n    }\n\n    for (const declaration of module.functions) visit(declaration.body, new Map(declaration.parameters.map((parameter) => [parameter.name, parameter.type.name])))\n    visit(module.entryPoint.body, new Map())\n  }\n\n  /**\n   * Rejects profile-looking comments outside a complete canonical generated program.\n   * @param {CstNode} node - Current node.\n   * @returns {void}\n   */\n  rejectScaffoldComments(node) {\n    if (node.type == \"comment\" && /semantifold:|@semantifold/u.test(this.text(node))) this.fail(node, \"unrecognized scaffold comment\")\n    for (const {node: child} of node.children) this.rejectScaffoldComments(child)\n  }\n\n  /**\n   * Retains every scaffold comment and structural edge, ignoring only ordinary comments.\n   * @param {CstNode} node - CST parent.\n   * @returns {CstNode[]} Complete significant child list.\n   */\n  significant(node) {\n    return node.children.map(({node: child}) => child).filter((child) =>\n      child.type != \"comment\" || /semantifold:|@semantifold/u.test(this.text(child)))\n  }\n\n  /**\n   * Verifies every token, field, type, use, ordering edge and consumer against the canonical plan.\n   * This checks the original CST; it never recovers meaning from generated source text.\n   * @param {CstNode} actual - Original tree node.\n   * @param {CstNode} expected - Canonical tree node for the reconstructed semantics.\n   * @param {CppReader} canonical - Canonical token reader.\n   * @returns {void}\n   */\n  compareTree(actual, expected, canonical) {\n    if (actual.type != expected.type || actual.named != expected.named || actual.extra != expected.extra) this.fail(actual, \"generated scaffold node shape\")\n    const left = this.significant(actual)\n    const right = canonical.significant(expected)\n\n    if (left.length != right.length) this.fail(actual, \"generated scaffold child count\")\n    if (!left.length && this.text(actual) != canonical.text(expected)) this.fail(actual, \"generated scaffold token, type, order or consumer\")\n    left.forEach((child, index) => {\n      if (actual.children.find((edge) => edge.node === child)?.field != expected.children.find((edge) => edge.node === right[index])?.field) this.fail(child, \"generated scaffold field\")\n      this.compareTree(child, right[index], canonical)\n    })\n  }\n\n  /**\n   * Recognizes the shape of an inert generated unused-binding cast; canonical comparison checks its exact target and placement.\n   * @param {CstNode} node - Candidate statement.\n   * @returns {boolean} Whether this is a discard-shaped candidate.\n   */\n  discard(node) {\n    return node.type == \"expression_statement\" && this.parts(node)[0]?.type == \"cast_expression\"\n  }\n\n  /**\n   * Reconstructs paired statement regions before mandatory whole-CST canonical verification.\n   * @param {CstNode[]} children - Ordered block children without braces or main cleanup.\n   * @returns {Statement[]} Candidate semantic statements.\n   */\n  generatedStatements(children) {\n    const nodes = children.filter((node) => node.type != \"comment\" || /semantifold:|@semantifold/u.test(this.text(node)))\n    /** @type {Statement[]} */\n    const statements = []\n    let cursor = 0\n\n    while (cursor < nodes.length && this.discard(nodes[cursor])) cursor++\n    while (cursor < nodes.length) {\n      const begin = nodes[cursor++]\n      const match = begin.type == \"comment\" && /^\\/\\* semantifold:ordered-expression:cpp:v1 begin ([0-9]{6}) ([0-9a-f]{64}) \\*\\/$/u.exec(this.text(begin))\n\n      if (!match) this.fail(begin, \"complete ordered statement region required\")\n      const outer = this.temporaryExpressions\n      const outerNames = this.temporaryNames\n\n      this.temporaryExpressions = new Map()\n      this.temporaryNames = new Set()\n      while (cursor < nodes.length && this.temporaryDeclaration(nodes[cursor])) cursor = this.readTemporary(nodes, cursor)\n      const consumer = nodes[cursor++]\n\n      if (!consumer) this.fail(begin, \"missing ordered consumer\")\n      const statement = this.statement(consumer)\n\n      if (this.temporaryExpressions.size != 0) this.fail(consumer, \"unconsumed ordered temporary\")\n      if (statement.kind == \"LocalDeclaration\" && nodes[cursor] && this.discard(nodes[cursor])) cursor++\n      const end = nodes[cursor++]\n\n      if (!end || end.type != \"comment\" || this.text(end) != `/* semantifold:ordered-expression:cpp:v1 end ${match[1]} ${match[2]} */`) this.fail(end ?? begin, \"ordered marker pair\")\n      this.temporaryExpressions = outer\n      this.temporaryNames = outerNames\n      statements.push(statement)\n    }\n    return statements\n  }\n\n  /**\n   * Identifies only a declaration at the current region level, without descendant searching.\n   * @param {CstNode} node - Candidate node.\n   * @returns {boolean} Whether the direct initialized name uses the reserved prefix.\n   */\n  temporaryDeclaration(node) {\n    if (node.type != \"declaration\") return false\n    const declarator = node.children.find(({field}) => field == \"declarator\")?.node\n    const name = declarator?.children.find(({field}) => field == \"declarator\")?.node\n\n    return name?.type == \"identifier\" && this.text(name).startsWith(\"semantifold_ordered_\")\n  }\n\n  /**\n   * Expands one candidate temporary, including its conditional RHS, retaining original operation tokens.\n   * @param {CstNode[]} nodes - Current lexical sequence.\n   * @param {number} cursor - Declaration position.\n   * @returns {number} Next unconsumed position.\n   */\n  readTemporary(nodes, cursor) {\n    const node = nodes[cursor++]\n    const declarator = this.field(node, \"declarator\")\n    const nameNode = this.field(declarator, \"declarator\")\n    const name = this.text(nameNode)\n    const type = this.field(node, \"type\")\n    const value = this.field(declarator, \"value\")\n\n    this.shape(node, [type, declarator, \";\"])\n    this.shape(declarator, [nameNode, \"=\", value])\n    this.type(type)\n    if (!/^semantifold_ordered_[0-9]{6}$/u.test(name) || this.temporaryNames?.has(name)) this.fail(nameNode, \"ordered temporary declaration\")\n    this.temporaryNames?.add(name)\n    let expression = this.expression(value)\n    const branch = nodes[cursor]\n\n    if (branch?.type == \"if_statement\" && [\"identifier\", \"true\", \"false\"].includes(value.type)) {\n      const condition = this.field(branch, \"condition\")\n      const body = this.field(branch, \"consequence\")\n\n      this.shape(branch, [\"if\", condition, body])\n      this.shape(condition, [\"(\", this.parts(condition)[1], \")\"])\n      const test = this.parts(condition)[1]\n      const isOr = test.type == \"unary_expression\"\n      const target = isOr ? this.field(test, \"argument\") : test\n\n      if (target.type != \"identifier\" || this.text(target) != name) this.fail(target, \"short-circuit temporary test\")\n      if (isOr) this.shape(test, [\"!\", target])\n      if (body.type != \"compound_statement\") this.fail(body, \"short-circuit block\")\n      const inside = this.significant(body).slice(1, -1)\n      let offset = 0\n\n      while (offset < inside.length && this.temporaryDeclaration(inside[offset])) offset = this.readTemporary(inside, offset)\n      if (offset != inside.length - 1) this.fail(body, \"short-circuit final write\")\n      const assignment = inside[offset]\n\n      this.shape(assignment, [\"assignment_expression\", \";\"])\n      const assigned = this.parts(assignment)[0]\n      const left = this.field(assigned, \"left\")\n      const right = this.field(assigned, \"right\")\n\n      this.shape(assigned, [left, \"=\", right])\n      if (left.type != \"identifier\" || this.text(left) != name) this.fail(left, \"short-circuit result write\")\n      this.shape(right, [\"(\", \"binary_expression\", \")\"])\n      const binary = this.parts(right)[1]\n      const repeated = this.field(binary, \"left\")\n      const operand = this.field(binary, \"right\")\n      const operator = this.field(binary, \"operator\")\n\n      this.shape(binary, [repeated, isOr ? \"||\" : \"&&\", operand])\n      if (repeated.type != \"identifier\" || this.text(repeated) != name) this.fail(repeated, \"short-circuit consumed value\")\n      expression = this.binary(node, isOr ? \"Or\" : \"And\", expression, this.expression(operand), operator)\n      cursor++\n    }\n    this.temporaryExpressions?.set(name, expression)\n    return cursor\n  }\n}\n\n/**\n * Parses only the frozen legacy CST, with no source-text recovery path.\n * @param {{filename: string, source: string}} input - Exact caller source.\n * @returns {import(\"../semantic/types.js\").SemanticModule} Parsed C++ semantics.\n */\nexport function parseCpp({filename, source}) {\n  if (!hasOnlyUnicodeScalars(source)) {\n    const coordinates = createCoordinateIndex(source)\n    const offset = source.search(/[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?<![\\uD800-\\uDBFF])[\\uDC00-\\uDFFF]/u)\n\n    throw new SemantifoldDiagnostic({code: \"PARSE_ERROR\", language: \"cpp\", message: \"CPP source contains a lone UTF-16 surrogate.\",\n      location: {filename, start: indexedPointAt(coordinates, offset), end: indexedPointAt(coordinates, offset + 1)}})\n  }\n  if (source.length > maximumCppSourceLength) {\n    const coordinates = createCoordinateIndex(source)\n\n    return unsupportedSyntax(\"cpp\", \"source exceeds the frozen CPP parser's 32767 UTF-16 input limit\", {\n      filename, start: indexedPointAt(coordinates, 0), end: indexedPointAt(coordinates, source.length)\n    })\n  }\n  let snapshot\n\n  try {\n    snapshot = parseCppCst(source)\n  } catch (error) {\n    const coordinates = createCoordinateIndex(source)\n\n    throw new SemantifoldDiagnostic({code: \"PARSE_ERROR\", language: \"cpp\",\n      cause: error instanceof Error ? error : undefined, message: \"The qualified CPP parser could not produce a complete CST.\",\n      location: {filename, start: indexedPointAt(coordinates, 0), end: indexedPointAt(coordinates, source.length)}})\n  }\n  const reader = new CppReader(filename, source)\n\n  try {\n    return reader.module(snapshot.root)\n  } catch (error) {\n    if (reader.generated && error instanceof SemantifoldDiagnostic && error.language == \"cpp\" &&\n      error.code != \"PARSE_ERROR\" && error.code != \"UNSUPPORTED_SYNTAX\") {\n      return unsupportedSyntax(\"cpp\", `invalid generated ordered scaffold: ${error.code}`, error.location ?? reader.location(snapshot.root))\n    }\n    throw error\n  }\n}\n"]}