semantifold 0.4.0 → 0.6.0

package/build/src/frontends/zig.js

@@ -0,0 +1,970 @@
+// @ts-check
+import { isZigIdentifier } from "../backends/identifiers.js";
+import { generateZigProject } from "../backends/zig.js";
+import { zigRuntime } from "../backends/zig-runtime.js";
+import { maximumZigSourceLength } from "../backends/zig-validation.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";
+import { parseZigCst } from "./zig-parser.js";
+import { collectZigBindingUsage } from "../zig-bindings.js";
+/** @typedef {import("./zig-parser.js").CstNode} CstNode */
+/** @typedef {import("../semantic/types.js").Expression} Expression */
+/** @typedef {import("../semantic/types.js").Statement} Statement */
+/** @typedef {import("../semantic/types.js").FunctionReturnTypeName} Scalar */
+const binaryOperations = new Map([
+    ["+", "Add"], ["-", "Subtract"], ["*", "Multiply"], ["==", "Equal"], ["!=", "NotEqual"],
+    ["<", "LessThan"], ["<=", "LessThanOrEqual"], [">", "GreaterThan"], [">=", "GreaterThanOrEqual"],
+    ["and", "And"], ["or", "Or"]
+]);
+const helperOperations = new Map([
+    ["semantifold_integer_add", "Add"], ["semantifold_integer_subtract", "Subtract"],
+    ["semantifold_integer_multiply", "Multiply"], ["semantifold_string_concat", "Add"],
+    ["semantifold_string_equal", "Equal"], ["semantifold_string_not_equal", "NotEqual"]
+]);
+const operationSpellings = new Map([
+    ["IntegerAdd", "semantifold_integer_add"], ["IntegerSubtract", "semantifold_integer_subtract"],
+    ["IntegerMultiply", "semantifold_integer_multiply"], ["IntegerNegate", "semantifold_integer_negate"],
+    ["IntegerEqual", "=="], ["IntegerNotEqual", "!="], ["IntegerLessThan", "<"],
+    ["IntegerLessThanOrEqual", "<="], ["IntegerGreaterThan", ">"], ["IntegerGreaterThanOrEqual", ">="],
+    ["BooleanEqual", "=="], ["BooleanNotEqual", "!="], ["BooleanAnd", "and"], ["BooleanOr", "or"], ["BooleanNot", "!"],
+    ["StringConcat", "semantifold_string_concat"], ["StringEqual", "semantifold_string_equal"],
+    ["StringNotEqual", "semantifold_string_not_equal"]
+]);
+/** Consumes the complete qualified Zig CST and retains exact generated-shell constraints. */
+class ZigReader {
+    /**
+     * Creates a reader over one complete parser snapshot.
+     * @param {string} filename - Logical source filename.
+     * @param {string} source - Exact Zig source text.
+     */
+    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<Expression, {node: CstNode, spelling: string}>} */
+        this.operations = new Map();
+        /** @type {Map<Statement, {node: CstNode, type: string}>} */
+        this.prints = new Map();
+        /** @type {Map<string, Scalar>} */
+        this.functions = new Map();
+        /** @type {Map<import("../semantic/types.js").Parameter | import("../semantic/types.js").LocalDeclaration, "use" | "address" | "none">} */
+        this.scaffolds = new Map();
+    }
+    /**
+     * Converts a parser node boundary to a semantic location.
+     * @param {CstNode} node - Parser node.
+     * @returns {import("../semantic/types.js").SourceLocation} UTF-16 location.
+     */
+    location(node) {
+        return { filename: this.filename, start: indexedPointAt(this.coordinates, node.startIndex), end: indexedPointAt(this.coordinates, node.endIndex) };
+    }
+    /**
+     * Reads the exact source spelling owned by a parser node.
+     * @param {CstNode} node - Parser node.
+     * @returns {string} Node source text.
+     */
+    text(node) {
+        return this.source.slice(node.startIndex, node.endIndex);
+    }
+    /**
+     * Reads one generated line-comment marker independent of the source newline convention.
+     * @param {CstNode} node - Marker comment node.
+     * @returns {string} Marker spelling without a parser-owned trailing carriage return.
+     */
+    marker(node) {
+        return this.text(node).replace(/\r$/u, "");
+    }
+    /**
+     * Raises a located unsupported-syntax diagnostic.
+     * @param {CstNode} node - Rejected parser node.
+     * @param {string} [detail] - Diagnostic detail.
+     * @returns {never} This function always throws.
+     */
+    fail(node, detail = node.type) {
+        unsupportedSyntax("zig", detail, this.location(node));
+    }
+    /**
+     * Exhaustively rejects recovery, unexpected extras, directives, and excessive nesting.
+     * @param {CstNode} node - Current CST node.
+     * @param {number} [depth] - Current nesting depth.
+     */
+    validateTree(node, depth = 0) {
+        if (depth > 512)
+            this.fail(node, "Zig 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: "zig", location: this.location(node), message: `Zig parser recovery at '${node.type}'.` });
+        }
+        if (node.extra && node.type != "comment")
+            this.fail(node, "unexpected extra parser child");
+        if (node.type == "comment" && (/^\s*\/\/[/!]/u.test(this.text(node)) || /^\s*\/\/\s*zig fmt:/u.test(this.text(node)))) {
+            this.fail(node, "doc or formatter-directive comment");
+        }
+    }
+    /**
+     * Returns every non-comment child without hiding syntax edges.
+     * @param {CstNode} node - Parent parser node.
+     * @returns {CstNode[]} Ordered non-comment children.
+     */
+    parts(node) {
+        return node.children.map(({ node: child }) => child).filter(child => child.type != "comment");
+    }
+    /**
+     * Retains compiler-owned scaffold markers while ignoring ordinary inert comments.
+     * @param {CstNode} node - Parent parser node.
+     * @returns {CstNode[]} Complete significant child list.
+     */
+    significant(node) {
+        return node.children.map(({ node: child }) => child).filter(child => child.type != "comment" || /semantifold:/u.test(this.text(child)));
+    }
+    /**
+     * Requires exactly one parser field edge.
+     * @param {CstNode} node - Parent parser node.
+     * @param {string} name - Required field name.
+     * @returns {CstNode} Field child.
+     */
+    field(node, name) {
+        const edges = node.children.filter(({ field }) => field == name);
+        if (edges.length != 1)
+            this.fail(node, `expected one '${name}' field`);
+        return edges[0].node;
+    }
+    /**
+     * Requires an exact ordered child/token shape.
+     * @param {CstNode} node - Parser node to check.
+     * @param {(CstNode | string)[]} expected - Expected node identities or token types.
+     */
+    shape(node, expected) {
+        const parts = this.parts(node);
+        if (parts.length != expected.length || parts.some((child, index) => typeof expected[index] == "string" ? child.type != expected[index] || !child.named && this.text(child) != expected[index] : child !== expected[index])) {
+            this.fail(node, `${node.type} child shape`);
+        }
+    }
+    /**
+     * Validates and returns one ordinary Zig identifier.
+     * @param {CstNode} node - Candidate identifier node.
+     * @returns {string} Validated identifier.
+     */
+    identifier(node) {
+        const name = this.text(node);
+        if (node.type != "identifier" || !isZigIdentifier(name))
+            this.fail(node, "reserved or unsupported identifier");
+        return name;
+    }
+    /**
+     * Converts an exact source scalar annotation.
+     * @param {CstNode} node - Type node.
+     * @param {boolean} [allowVoid] - Whether void is valid here.
+     * @returns {import("../semantic/types.js").SemanticFunctionReturnType} Semantic type.
+     */
+    type(node, allowVoid = false) {
+        const spelling = this.text(node);
+        if (allowVoid && node.type == "builtin_type" && spelling == "void") {
+            this.shape(node, ["void"]);
+            return withParserRanges({ kind: "TypeReference", name: "void" }, { type: this.location(node) });
+        }
+        if (node.type == "builtin_type" && ["i64", "bool"].includes(spelling)) {
+            if (spelling == "bool")
+                this.shape(node, ["bool"]);
+            else if (node.children.length)
+                this.fail(node, "scalar type shape");
+        }
+        else if (node.type == "slice_type" && spelling == "[]const u8") {
+            this.shape(node, ["[", "]", "const", this.parts(node)[3]]);
+            const child = this.parts(node)[3];
+            if (child.type != "builtin_type" || this.text(child) != "u8" || child.children.length)
+                this.fail(child, "immutable UTF-8 slice element");
+        }
+        else
+            return missingType("zig", allowVoid ? "function return" : "scalar", this.location(node));
+        const type = sourceScalarType("zig", spelling, this.location(node));
+        if (!type)
+            return missingType("zig", "scalar", this.location(node));
+        return type;
+    }
+    /**
+     * Decomposes an exact direct call.
+     * @param {CstNode} node - Call expression node.
+     * @returns {{name: CstNode, arguments: CstNode[]}} Callee and ordered arguments.
+     */
+    call(node) {
+        if (node.type != "call_expression")
+            this.fail(node, "direct call required");
+        const name = this.field(node, "function");
+        const parts = this.parts(node);
+        const argumentsAndCommas = parts.slice(2, -1);
+        const args = argumentsAndCommas.filter((_part, index) => index % 2 == 0);
+        this.shape(node, [name, "(", ...args.flatMap((argument, index) => index ? [",", argument] : [argument]), ")"]);
+        return { name, arguments: args };
+    }
+    /**
+     * Decodes one bounded ordinary Zig string literal.
+     * @param {CstNode} node - String node.
+     * @returns {string} Unicode scalar value.
+     */
+    string(node) {
+        if (node.type != "string")
+            this.fail(node, "ordinary UTF-8 string literal required");
+        const parts = this.parts(node);
+        this.shape(node, ['"', ...parts.slice(1, -1), '"']);
+        let value = "";
+        for (const part of parts.slice(1, -1)) {
+            const spelling = this.text(part);
+            if (part.type == "string_content") {
+                if (/[\r\n]/u.test(spelling))
+                    this.fail(part, "raw string line terminator");
+                value += spelling;
+            }
+            else if (part.type == "escape_sequence") {
+                const simple = new Map([["\\n", "\n"], ["\\r", "\r"], ["\\t", "\t"], ["\\\\", "\\"], ['\\"', '"']]);
+                if (simple.has(spelling))
+                    value += simple.get(spelling);
+                else if (/^\\x[0-9a-fA-F]{2}$/u.test(spelling)) {
+                    const scalar = Number.parseInt(spelling.slice(2), 16);
+                    if (scalar > 127)
+                        this.fail(part, "non-ASCII byte escape");
+                    value += String.fromCodePoint(scalar);
+                }
+                else if (/^\\u\{[0-9a-fA-F]{1,6}\}$/u.test(spelling)) {
+                    const scalar = Number.parseInt(spelling.slice(3, -1), 16);
+                    if (scalar > 0x10FFFF || scalar >= 0xD800 && scalar <= 0xDFFF)
+                        this.fail(part, "non-scalar Unicode escape");
+                    value += String.fromCodePoint(scalar);
+                }
+                else
+                    this.fail(part, "unsupported string escape");
+            }
+            else
+                this.fail(part, "string child");
+        }
+        if (!hasOnlyUnicodeScalars(value))
+            this.fail(node, "non-scalar string value");
+        return value;
+    }
+    /**
+     * Converts one supported scalar expression.
+     * @param {CstNode} node - Expression node.
+     * @returns {Expression} Semantic expression.
+     */
+    expression(node) {
+        const location = this.location(node);
+        if (node.type == "parenthesized_expression") {
+            const parts = this.parts(node);
+            this.shape(node, ["(", parts[1], ")"]);
+            return this.expression(parts[1]);
+        }
+        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 == "integer") {
+            const spelling = this.text(node);
+            const value = Number(spelling);
+            if (!/^(?:0|[1-9][0-9]*)$/u.test(spelling) || !Number.isSafeInteger(value))
+                this.fail(node, "non-safe or noncanonical i64 literal");
+            return withParserRanges({ kind: "IntegerLiteral", location, value }, { literal: location });
+        }
+        if (node.type == "boolean") {
+            const spelling = this.text(node);
+            if (spelling != "true" && spelling != "false")
+                this.fail(node, "Boolean literal spelling");
+            this.shape(node, [spelling]);
+            return withParserRanges({ kind: "BooleanLiteral", location, value: spelling == "true" }, { literal: location });
+        }
+        if (node.type == "string")
+            return withParserRanges({ kind: "StringLiteral", location, value: this.string(node) }, { literal: location });
+        if (node.type == "unary_expression" || node.type == "error_union_type") {
+            const parts = this.parts(node);
+            const operator = node.type == "unary_expression" ? this.field(node, "operator") : parts[0];
+            const operand = node.type == "unary_expression" ? this.field(node, "argument") : this.field(node, "ok");
+            this.shape(node, [operator, operand]);
+            if (operator.type != "-" && operator.type != "!")
+                this.fail(operator, "unary operator");
+            return this.unary(node, operator.type == "-" ? "Negate" : "Not", this.expression(operand), operator);
+        }
+        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)
+                this.fail(operator, "unsupported binary operator");
+            return this.binary(node, intent, this.expression(left), this.expression(right), operator);
+        }
+        if (node.type == "call_expression") {
+            const call = this.call(node);
+            if (call.name.type != "identifier")
+                this.fail(call.name, "direct function call required");
+            const name = this.text(call.name);
+            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]), call.name);
+            }
+            const intent = helperOperations.get(name);
+            if (intent) {
+                if (call.arguments.length != 2)
+                    this.fail(node, "operator helper arity");
+                return this.binary(node, intent, this.expression(call.arguments[0]), this.expression(call.arguments[1]), call.name);
+            }
+            if (name.startsWith("semantifold_"))
+                this.fail(call.name, "support helper outside its exact semantic role");
+            const callee = this.identifier(call.name);
+            return withParserRanges({ kind: "CallExpression", location, callee, arguments: call.arguments.map(argument => this.expression(argument)) }, { callee: this.location(call.name) });
+        }
+        return this.fail(node);
+    }
+    /**
+     * Adapts one typed binary operator.
+     * @param {CstNode} node - Whole expression node.
+     * @param {string} intent - Shared operator intent.
+     * @param {Expression} left - Left operand.
+     * @param {Expression} right - Right operand.
+     * @param {CstNode} operator - Source operator occurrence.
+     * @returns {Expression} Adapted semantic expression.
+     */
+    binary(node, intent, left, right, operator) {
+        const expression = /** @type {Expression} */ (withAdaptedOperation(withParserRanges({ kind: "BinaryExpression", location: this.location(node), left, right }, { operator: this.location(operator) }), /** @type {import("../semantic/operators.js").AdaptedOperation} */ (intent)));
+        this.operations.set(expression, { node: operator, spelling: this.text(operator) });
+        return expression;
+    }
+    /**
+     * Adapts one typed unary operator.
+     * @param {CstNode} node - Whole expression node.
+     * @param {"Negate" | "Not"} intent - Shared operator intent.
+     * @param {Expression} operand - Converted operand.
+     * @param {CstNode} operator - Source operator occurrence.
+     * @returns {Expression} Adapted semantic expression.
+     */
+    unary(node, intent, operand, operator) {
+        const expression = /** @type {Expression} */ (withAdaptedOperation(withParserRanges({ kind: "UnaryExpression", location: this.location(node), operand }, { operator: this.location(operator) }), intent));
+        this.operations.set(expression, { node: operator, spelling: this.text(operator) });
+        return expression;
+    }
+    /**
+     * Converts one supported statement.
+     * @param {CstNode} node - Statement node.
+     * @returns {Statement} Semantic statement.
+     */
+    statement(node) {
+        const location = this.location(node);
+        const parts = this.parts(node);
+        if (node.type == "variable_declaration") {
+            if (["const", "var"].includes(parts[0]?.type)) {
+                const typeNode = node.children.find(({ field }) => field == "type")?.node;
+                if (!typeNode)
+                    return missingType("zig", "local", location);
+                const name = parts[1];
+                const value = parts[5];
+                this.shape(node, [parts[0], name, ":", typeNode, "=", value, ";"]);
+                return withParserRanges({ kind: "LocalDeclaration", location, name: this.identifier(name), type: /** @type {import("../semantic/types.js").TypeReference} */ (this.type(typeNode)), mutable: parts[0].type == "var",
+                    initializer: this.expression(value) }, { name: this.location(name), operator: this.location(parts[4]) });
+            }
+            const targetNode = parts[0];
+            const value = parts[2];
+            this.shape(node, [targetNode, "=", value, ";"]);
+            const target = withParserRanges({ kind: /** @type {const} */ ("IdentifierExpression"), location: this.location(targetNode), name: this.identifier(targetNode) }, { name: this.location(targetNode) });
+            return withParserRanges({ kind: "AssignmentStatement", location, target, expression: this.expression(value) }, { operator: this.location(parts[1]) });
+        }
+        if (node.type == "if_statement")
+            return this.conditional(node);
+        if (node.type != "expression_statement")
+            this.fail(node, "explicit statement required");
+        const expression = parts[0];
+        this.shape(node, [expression, ";"]);
+        if (expression.type == "return_expression") {
+            const returned = this.parts(expression);
+            if (returned.length == 1) {
+                this.shape(expression, ["return"]);
+                return { kind: "ReturnStatement", location };
+            }
+            this.shape(expression, ["return", returned[1]]);
+            return { kind: "ReturnStatement", location, expression: this.expression(returned[1]) };
+        }
+        if (expression.type != "call_expression")
+            this.fail(expression, "direct void call statement required");
+        const call = this.call(expression);
+        const name = this.text(call.name);
+        if (/^semantifold_print_(?:integer|boolean|string)$/u.test(name)) {
+            if (call.name.type != "identifier" || call.arguments.length != 1)
+                this.fail(expression, "exact print helper call required");
+            const statement = { kind: /** @type {const} */ ("PrintStatement"), location, expression: this.expression(call.arguments[0]) };
+            this.prints.set(statement, { node: call.name, type: name.slice("semantifold_print_".length) });
+            return statement;
+        }
+        const value = this.expression(expression);
+        if (value.kind != "CallExpression")
+            this.fail(expression, "direct void call statement required");
+        return { kind: "ExpressionStatement", location, expression: value };
+    }
+    /**
+     * Converts one strict Boolean conditional.
+     * @param {CstNode} node - If-statement node.
+     * @returns {import("../semantic/types.js").IfStatement} Semantic conditional.
+     */
+    conditional(node) {
+        const condition = this.field(node, "condition");
+        const body = this.field(node, "body");
+        const alternative = this.parts(node).find(child => child.type == "else_clause");
+        this.shape(node, ["if", "(", condition, ")", body, ...(alternative ? [alternative] : [])]);
+        const statement = { kind: /** @type {const} */ ("IfStatement"), location: this.location(node), condition: this.expression(condition), consequent: this.blockExpression(body) };
+        if (!alternative)
+            return statement;
+        const branch = this.field(alternative, "alternative");
+        this.shape(alternative, ["else", branch]);
+        if (branch.type != "labeled_statement")
+            this.fail(branch, "braced else block required");
+        const block = this.parts(branch)[0];
+        this.shape(branch, [block]);
+        return { ...statement, alternate: this.block(block) };
+    }
+    /**
+     * Unwraps one braced conditional block expression.
+     * @param {CstNode} node - Block-expression node.
+     * @returns {import("../semantic/types.js").Block} Semantic block.
+     */
+    blockExpression(node) {
+        if (node.type != "block_expression")
+            this.fail(node, "braced conditional block required");
+        const block = this.parts(node)[0];
+        this.shape(node, [block]);
+        return this.block(block);
+    }
+    /**
+     * Converts one lexical block while consuming exact compiler scaffolds.
+     * @param {CstNode} node - Block node.
+     * @param {number} [skip] - Fixed leading generated statements to omit.
+     * @param {import("../semantic/types.js").Parameter[]} [parameters] - Parameters requiring scaffold checks.
+     * @returns {import("../semantic/types.js").Block} Semantic block.
+     */
+    block(node, skip = 0, parameters = []) {
+        if (node.type != "block")
+            this.fail(node, "braced block required");
+        const parts = this.parts(node);
+        this.shape(node, ["{", ...parts.slice(1, -1), "}"]);
+        const sourceStatements = this.significant(node).slice(1 + skip, -1);
+        return { kind: "Block", location: this.location(node), statements: this.generated
+                ? this.generatedStatements(sourceStatements, parameters)
+                : this.directStatements(sourceStatements, parameters) };
+    }
+    /**
+     * Converts the legacy direct statement shape when diagnosing a missing generated marker.
+     * @param {CstNode[]} sourceStatements - Ordered direct children.
+     * @param {import("../semantic/types.js").Parameter[]} parameters - Function parameters.
+     * @returns {Statement[]} Semantic statements.
+     */
+    directStatements(sourceStatements, parameters) {
+        let cursor = 0;
+        for (const parameter of parameters) {
+            const kind = sourceStatements[cursor] ? this.useScaffold(sourceStatements[cursor], parameter.name) : undefined;
+            this.scaffolds.set(parameter, kind ?? "none");
+            if (kind)
+                cursor += 1;
+        }
+        /** @type {Statement[]} */
+        const statements = [];
+        while (cursor < sourceStatements.length) {
+            const statement = this.statement(sourceStatements[cursor]);
+            statements.push(statement);
+            cursor += 1;
+            if (statement.kind == "LocalDeclaration") {
+                const kind = sourceStatements[cursor] ? this.useScaffold(sourceStatements[cursor], statement.name) : undefined;
+                this.scaffolds.set(statement, kind ?? "none");
+                if (kind)
+                    cursor += 1;
+            }
+        }
+        return statements;
+    }
+    /**
+     * Reconstructs complete generated statement regions before canonical whole-CST verification.
+     * @param {CstNode[]} sourceStatements - Significant direct block children.
+     * @param {import("../semantic/types.js").Parameter[]} parameters - Function parameters.
+     * @returns {Statement[]} Reconstructed semantic statements.
+     */
+    generatedStatements(sourceStatements, parameters) {
+        /** @type {Statement[]} */
+        const statements = [];
+        let cursor = 0;
+        for (const parameter of parameters) {
+            const kind = sourceStatements[cursor] ? this.useScaffold(sourceStatements[cursor], parameter.name) : undefined;
+            this.scaffolds.set(parameter, kind ?? "none");
+            if (kind)
+                cursor += 1;
+        }
+        while (cursor < sourceStatements.length) {
+            const begin = sourceStatements[cursor++];
+            const match = begin.type == "comment" &&
+                /^\/\/ semantifold:ordered-expression:zig:v1 begin ([0-9]{6}) ([0-9a-f]{64})$/u.exec(this.marker(begin));
+            if (!match)
+                this.fail(begin, "complete generated ordered statement region required");
+            const outerExpressions = this.temporaryExpressions;
+            const outerNames = this.temporaryNames;
+            this.temporaryExpressions = new Map();
+            this.temporaryNames = new Set();
+            while (cursor < sourceStatements.length && this.temporaryDeclaration(sourceStatements[cursor])) {
+                cursor = this.readTemporary(sourceStatements, cursor);
+            }
+            const consumer = sourceStatements[cursor++];
+            if (!consumer)
+                this.fail(begin, "missing generated ordered consumer");
+            const statement = this.statement(consumer);
+            if (this.temporaryExpressions.size != 0)
+                this.fail(consumer, "unconsumed generated ordered temporary");
+            if (statement.kind == "LocalDeclaration") {
+                const kind = sourceStatements[cursor] ? this.useScaffold(sourceStatements[cursor], statement.name) : undefined;
+                this.scaffolds.set(statement, kind ?? "none");
+                if (kind)
+                    cursor += 1;
+            }
+            const end = sourceStatements[cursor++];
+            if (!end || end.type != "comment" || this.marker(end) !=
+                `// semantifold:ordered-expression:zig:v1 end ${match[1]} ${match[2]}`)
+                this.fail(end ?? begin, "generated ordered marker pair");
+            this.temporaryExpressions = outerExpressions;
+            this.temporaryNames = outerNames;
+            statements.push(statement);
+        }
+        return statements;
+    }
+    /**
+     * Identifies a reserved ordered temporary declaration at the current region level.
+     * @param {CstNode} node - Candidate direct child.
+     * @returns {boolean} Whether it declares a reserved ordered temporary.
+     */
+    temporaryDeclaration(node) {
+        const parts = this.parts(node);
+        return node.type == "variable_declaration" && ["const", "var"].includes(parts[0]?.type) &&
+            parts[1]?.type == "identifier" && this.text(parts[1]).startsWith("semantifold_ordered_");
+    }
+    /**
+     * Expands one typed ordered temporary and an optional conditional Boolean RHS.
+     * @param {CstNode[]} nodes - Current region children.
+     * @param {number} cursor - Temporary declaration position.
+     * @returns {number} Next unconsumed position.
+     */
+    readTemporary(nodes, cursor) {
+        const node = nodes[cursor++];
+        const parts = this.parts(node);
+        const nameNode = parts[1];
+        const name = this.text(nameNode);
+        const typeNode = this.field(node, "type");
+        const value = parts[5];
+        this.shape(node, [parts[0], nameNode, ":", typeNode, "=", value, ";"]);
+        this.type(typeNode);
+        if (!/^semantifold_ordered_[0-9]{6}$/u.test(name) || this.temporaryNames?.has(name)) {
+            this.fail(nameNode, "generated ordered temporary declaration");
+        }
+        this.temporaryNames?.add(name);
+        let expression = this.expression(value);
+        const branch = nodes[cursor];
+        if (branch && this.shortCircuitBranch(branch, name)) {
+            const condition = this.field(branch, "condition");
+            const body = this.field(branch, "body");
+            const conditionParts = this.parts(condition);
+            const isOr = conditionParts[0]?.type == "!";
+            const target = isOr ? this.field(condition, condition.type == "unary_expression" ? "argument" : "ok") : condition;
+            this.shape(branch, ["if", "(", condition, ")", body]);
+            if (target.type != "identifier" || this.text(target) != name)
+                this.fail(target, "generated short-circuit temporary test");
+            if (isOr)
+                this.shape(condition, [conditionParts[0], target]);
+            if (isOr && conditionParts[0]?.type != "!")
+                this.fail(conditionParts[0] ?? condition, "generated short-circuit negation");
+            if (body.type != "block_expression")
+                this.fail(body, "generated short-circuit block");
+            const block = this.parts(body)[0];
+            this.shape(body, [block]);
+            if (block.type != "block")
+                this.fail(block, "generated short-circuit block");
+            const inside = this.significant(block).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(block, "generated short-circuit final assignment");
+            const assignment = inside[offset];
+            const assignmentParts = this.parts(assignment);
+            const left = assignmentParts[0];
+            const right = assignmentParts[2];
+            this.shape(assignment, [left, "=", right, ";"]);
+            if (left.type != "identifier" || this.text(left) != name)
+                this.fail(left, "generated short-circuit result write");
+            if (right.type != "binary_expression")
+                this.fail(right, "generated short-circuit result expression");
+            const repeated = this.field(right, "left");
+            const operand = this.field(right, "right");
+            const operator = this.field(right, "operator");
+            const spelling = isOr ? "or" : "and";
+            this.shape(right, [repeated, spelling, operand]);
+            if (repeated.type != "identifier" || this.text(repeated) != name)
+                this.fail(repeated, "generated short-circuit consumed value");
+            expression = this.binary(right, isOr ? "Or" : "And", expression, this.expression(operand), operator);
+            cursor += 1;
+        }
+        this.temporaryExpressions?.set(name, expression);
+        return cursor;
+    }
+    /**
+     * Distinguishes an internal conditional RHS from the following semantic `if` consumer using only direct CST structure.
+     * @param {CstNode} node - Candidate conditional.
+     * @param {string} name - Ordered Boolean result name.
+     * @returns {boolean} Whether the node has the complete outer shape of a short-circuit update.
+     */
+    shortCircuitBranch(node, name) {
+        if (node.type != "if_statement" || this.parts(node).some(child => child.type == "else_clause"))
+            return false;
+        const body = node.children.find(({ field }) => field == "body")?.node;
+        if (body?.type != "block_expression")
+            return false;
+        const block = this.parts(body)[0];
+        if (block?.type != "block")
+            return false;
+        const inside = this.significant(block).slice(1, -1);
+        const final = inside.at(-1);
+        const finalParts = final ? this.parts(final) : [];
+        return inside.length > 0 && !inside.some(child => child.type == "comment") && final?.type == "variable_declaration" &&
+            finalParts[0]?.type == "identifier" && this.text(finalParts[0]) == name && finalParts[1]?.type == "=";
+    }
+    /**
+     * Recognizes one exact generated unused or unmutated binding scaffold.
+     * @param {CstNode} node - Candidate statement node.
+     * @param {string} name - Binding name.
+     * @returns {"use" | "address" | undefined} Scaffold form when matched.
+     */
+    useScaffold(node, name) {
+        const parts = this.parts(node);
+        if (node.type != "variable_declaration" || parts.length != 4 || parts[0].type != "identifier" || this.text(parts[0]) != "_" || parts[1].type != "=" || parts[3].type != ";")
+            return undefined;
+        if (parts[2].type == "identifier" && this.text(parts[2]) == name)
+            return "use";
+        if (parts[2].type == "reference_expression") {
+            const reference = this.parts(parts[2]);
+            if (reference.length == 2 && reference[0].type == "&" && reference[1].type == "identifier" && this.text(reference[1]) == name)
+                return "address";
+        }
+        return undefined;
+    }
+    /**
+     * Converts one canonical top-level semantic function.
+     * @param {CstNode} node - Function declaration node.
+     * @returns {import("../semantic/types.js").FunctionDeclaration} Semantic function.
+     */
+    function(node) {
+        const name = this.field(node, "name");
+        const parameters = this.parts(node).find(child => child.type == "parameters");
+        const returnType = this.field(node, "type");
+        const body = this.field(node, "body");
+        if (!parameters)
+            this.fail(node, "parameter list required");
+        this.shape(node, ["fn", name, parameters, returnType, body]);
+        const parameterParts = this.parts(parameters);
+        const declarations = parameterParts.slice(1, -1).filter((_part, index) => index % 2 == 0);
+        this.shape(parameters, ["(", ...declarations.flatMap((parameter, index) => index ? [",", parameter] : [parameter]), ")"]);
+        const converted = declarations.map(parameter => {
+            if (parameter.type != "parameter")
+                this.fail(parameter, "required typed parameter");
+            const parameterName = this.field(parameter, "name");
+            const type = this.field(parameter, "type");
+            this.shape(parameter, [parameterName, ":", type]);
+            return withParserRanges({ kind: /** @type {const} */ ("Parameter"), location: this.location(parameter), name: this.identifier(parameterName), type: /** @type {import("../semantic/types.js").TypeReference} */ (this.type(type)) }, { name: this.location(parameterName) });
+        });
+        return withParserRanges({ kind: "FunctionDeclaration", location: this.location(node), name: this.identifier(name), parameters: converted,
+            returnType: this.type(returnType, true), body: this.block(body, 0, converted) }, { name: this.location(name) });
+    }
+    /**
+     * Compares every node, token, and field against canonical generated support.
+     * @param {CstNode} actual - Source subtree.
+     * @param {CstNode} expected - Canonical subtree.
+     * @param {ZigReader} canonical - Reader owning the canonical source.
+     */
+    compareTree(actual, expected, canonical) {
+        if (actual.type != expected.type || actual.named != expected.named || actual.extra != expected.extra)
+            this.fail(actual, "modified Zig support node");
+        const left = this.significant(actual);
+        const right = canonical.significant(expected);
+        if (left.length != right.length)
+            this.fail(actual, "modified Zig support children");
+        if (!left.length) {
+            const actualText = actual.type == "comment" && /semantifold:/u.test(this.text(actual)) ? this.marker(actual) : this.text(actual);
+            const expectedText = expected.type == "comment" && /semantifold:/u.test(canonical.text(expected)) ? canonical.marker(expected) : canonical.text(expected);
+            if (actualText != expectedText)
+                this.fail(actual, "modified Zig support token");
+        }
+        left.forEach((child, index) => {
+            const expectedChild = right[index];
+            if (!expectedChild || actual.children.find(edge => edge.node === child)?.field != expected.children.find(edge => edge.node === expectedChild)?.field) {
+                this.fail(child, "modified Zig support field");
+            }
+            this.compareTree(child, expectedChild, canonical);
+        });
+    }
+    /**
+     * Resolves a validated expression's scalar result.
+     * @param {Expression} expression - Semantic expression.
+     * @param {Map<string, Scalar>} bindings - Visible binding types.
+     * @returns {Scalar} Scalar result name.
+     */
+    expressionType(expression, bindings) {
+        if (expression.kind == "StringLiteral")
+            return "string";
+        if (expression.kind == "IntegerLiteral")
+            return "integer";
+        if (expression.kind == "BooleanLiteral")
+            return "boolean";
+        if (expression.kind == "BinaryExpression" || expression.kind == "UnaryExpression")
+            return expression.type;
+        if (expression.kind != "CallExpression" && expression.kind != "IdentifierExpression")
+            throw new Error("Validated Zig source exposed a collection expression.");
+        const type = expression.kind == "CallExpression" ? this.functions.get(expression.callee) : bindings.get(expression.name);
+        if (!type)
+            throw new Error("Validated Zig expression lost its scalar binding.");
+        return type;
+    }
+    /**
+     * Requires each typed operation to retain the one exact Zig operator/helper spelling that implements it.
+     * @param {Expression} expression - Resolved scalar expression.
+     */
+    validateOperationExpression(expression) {
+        if (expression.kind == "CallExpression") {
+            expression.arguments.forEach(argument => this.validateOperationExpression(argument));
+            return;
+        }
+        if (expression.kind == "UnaryExpression") {
+            const identity = this.operations.get(expression);
+            const expected = operationSpellings.get(expression.operation);
+            if (!identity)
+                throw new Error("Resolved Zig unary operation lost its parser identity.");
+            if (identity.spelling != expected)
+                this.fail(identity.node, `exact ${expression.operation} Zig operator/helper required`);
+            this.validateOperationExpression(expression.operand);
+            return;
+        }
+        if (expression.kind == "BinaryExpression") {
+            const identity = this.operations.get(expression);
+            const expected = operationSpellings.get(expression.operation);
+            if (!identity)
+                throw new Error("Resolved Zig binary operation lost its parser identity.");
+            if (identity.spelling != expected)
+                this.fail(identity.node, `exact ${expression.operation} Zig operator/helper required`);
+            this.validateOperationExpression(expression.left);
+            this.validateOperationExpression(expression.right);
+        }
+    }
+    /**
+     * Validates operation identity throughout one lexical block.
+     * @param {import("../semantic/types.js").Block} block - Block whose expressions must retain exact Zig identity.
+     */
+    validateOperations(block) {
+        for (const statement of block.statements) {
+            if (statement.kind == "LocalDeclaration")
+                this.validateOperationExpression(statement.initializer);
+            else if (statement.kind == "AssignmentStatement" || statement.kind == "ExpressionStatement" || statement.kind == "PrintStatement") {
+                this.validateOperationExpression(statement.expression);
+            }
+            else if (statement.kind == "ReturnStatement") {
+                if (statement.expression)
+                    this.validateOperationExpression(statement.expression);
+            }
+            else if (statement.kind == "IfStatement") {
+                this.validateOperationExpression(statement.condition);
+                this.validateOperations(statement.consequent);
+                if (statement.alternate)
+                    this.validateOperations(statement.alternate);
+            }
+        }
+    }
+    /**
+     * Confirms each generated output helper matches its semantic operand.
+     * @param {import("../semantic/types.js").Block} block - Block to inspect.
+     * @param {Map<string, Scalar>} inherited - Visible binding types.
+     */
+    validatePrints(block, inherited) {
+        const bindings = new Map(inherited);
+        for (const statement of block.statements) {
+            if (statement.kind == "LocalDeclaration") {
+                bindings.set(statement.name, /** @type {import("../semantic/types.js").TypeReference} */ (statement.type).name);
+            }
+            else if (statement.kind == "PrintStatement") {
+                const print = this.prints.get(statement);
+                if (!print || this.expressionType(statement.expression, bindings) != print.type)
+                    this.fail(print?.node ?? /** @type {CstNode} */ ({}), "print helper scalar mismatch");
+            }
+            else if (statement.kind == "IfStatement") {
+                this.validatePrints(statement.consequent, bindings);
+                if (statement.alternate)
+                    this.validatePrints(statement.alternate, bindings);
+            }
+        }
+    }
+    /**
+     * Confirms all and only compiler-required binding scaffolds are present.
+     * @param {import("../semantic/types.js").FunctionDeclaration | import("../semantic/types.js").EntryPoint} owner - Function or entry owner.
+     */
+    validateScaffolds(owner) {
+        const usage = collectZigBindingUsage(owner.body);
+        const parameters = owner.kind == "FunctionDeclaration" ? owner.parameters : [];
+        for (const parameter of parameters) {
+            const expected = usage.reads.has(parameter.name) ? "none" : "use";
+            if (this.scaffolds.get(parameter) != expected)
+                unsupportedSyntax("zig", `incorrect unused-parameter scaffold for '${parameter.name}'`, parameter.location);
+        }
+        /**
+         * Checks local scaffolds recursively.
+         * @param {import("../semantic/types.js").Block} block - Block to inspect.
+         */
+        const visit = (block) => {
+            for (const statement of block.statements) {
+                if (statement.kind == "LocalDeclaration") {
+                    const expected = statement.mutable && !usage.writes.has(statement.name) ? "address" :
+                        !statement.mutable && !usage.reads.has(statement.name) ? "use" : "none";
+                    if (this.scaffolds.get(statement) != expected)
+                        unsupportedSyntax("zig", `incorrect local binding scaffold for '${statement.name}'`, statement.location);
+                }
+                else if (statement.kind == "IfStatement") {
+                    visit(statement.consequent);
+                    if (statement.alternate)
+                        visit(statement.alternate);
+                }
+            }
+        };
+        visit(owner.body);
+    }
+    /**
+     * Converts a complete canonical Zig project entry.
+     * @param {CstNode} root - Source-file root.
+     * @returns {import("../semantic/types.js").SemanticModule} Validated semantic module.
+     */
+    module(root) {
+        this.validateTree(root);
+        if (root.type != "source_file")
+            this.fail(root, "Zig source root required");
+        const canonical = new ZigReader(this.filename, zigRuntime);
+        const support = canonical.significant(parseZigCst(zigRuntime).root);
+        const nodes = this.significant(root);
+        if (nodes.length < support.length + 2)
+            this.fail(root, "complete Zig runtime, ordered marker, and main shell required");
+        support.forEach((expected, index) => this.compareTree(nodes[index], expected, canonical));
+        const programMarker = nodes[support.length];
+        if (programMarker.type != "comment" || this.marker(programMarker) != "// semantifold:program:zig:v1") {
+            this.fail(programMarker, "exact generated Zig ordered-expression marker required");
+        }
+        this.generated = true;
+        const definitions = nodes.slice(support.length + 1);
+        /** @type {CstNode | undefined} */
+        let main;
+        /** @type {CstNode[]} */
+        const functions = [];
+        for (const node of definitions) {
+            if (node.type != "function_declaration")
+                this.fail(node, "top-level free functions only");
+            const name = this.text(this.field(node, "name"));
+            if (name == "main") {
+                if (main)
+                    this.fail(node, "duplicate main");
+                main = node;
+            }
+            else {
+                if (main)
+                    this.fail(node, "semantic function after main");
+                functions.push(node);
+            }
+        }
+        if (!main)
+            this.fail(root, "canonical pub fn main() void required");
+        const mainParts = this.parts(main);
+        const mainName = this.field(main, "name");
+        const parameters = mainParts.find(child => child.type == "parameters");
+        const returnType = this.field(main, "type");
+        const body = this.field(main, "body");
+        if (!parameters)
+            this.fail(main, "main parameters");
+        this.shape(main, ["pub", "fn", mainName, parameters, returnType, body]);
+        if (this.text(mainName) != "main")
+            this.fail(mainName, "main name");
+        this.shape(parameters, ["(", ")"]);
+        this.type(returnType, true);
+        if (this.text(returnType) != "void")
+            this.fail(returnType, "main return type");
+        const bodyParts = this.parts(body);
+        const deferNode = bodyParts[1];
+        const shellSource = "pub fn main() void {\n    defer semantifold_arena.deinit();\n}\n";
+        const shellReader = new ZigReader(this.filename, shellSource);
+        const shellMain = shellReader.parts(parseZigCst(shellSource).root)[0];
+        const expectedDefer = shellReader.parts(shellReader.field(shellMain, "body"))[1];
+        if (!deferNode)
+            this.fail(body, "arena lifetime defer required");
+        this.compareTree(deferNode, expectedDefer, shellReader);
+        const module = validateParsedModule({ kind: "Module", location: this.location(root), functions: functions.map(node => this.function(node)),
+            entryPoint: { kind: "EntryPoint", location: this.location(main), body: this.block(body, 1) } }, "zig");
+        this.functions = new Map(module.functions.map(declaration => [declaration.name,
+            /** @type {import("../semantic/types.js").TypeReference} */ (declaration.returnType).name]));
+        for (const declaration of module.functions)
+            this.validateOperations(declaration.body);
+        this.validateOperations(module.entryPoint.body);
+        for (const declaration of module.functions)
+            this.validatePrints(declaration.body, new Map(declaration.parameters.map(parameter => [parameter.name,
+                /** @type {import("../semantic/types.js").TypeReference} */ (parameter.type).name])));
+        this.validatePrints(module.entryPoint.body, new Map());
+        for (const declaration of module.functions)
+            this.validateScaffolds(declaration);
+        this.validateScaffolds(module.entryPoint);
+        const canonicalSource = generateZigProject({ module }).artifacts[1]?.content;
+        if (typeof canonicalSource != "string")
+            throw new Error("Zig backend returned a nontext entry artifact.");
+        this.compareTree(root, parseZigCst(canonicalSource).root, new ZigReader(this.filename, canonicalSource));
+        return module;
+    }
+}
+/**
+ * Parses only the qualified frozen Zig CST and rejects unsupported input before adaptation.
+ * @param {{filename: string, source: string}} input - Exact source request.
+ * @returns {import("../semantic/types.js").SemanticModule} Zig semantic module.
+ */
+export function parseZig({ filename, source }) {
+    const coordinates = createCoordinateIndex(source);
+    const location = { filename, start: indexedPointAt(coordinates, 0), end: indexedPointAt(coordinates, source.length) };
+    if (!hasOnlyUnicodeScalars(source)) {
+        const offset = source.search(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/u);
+        throw new SemantifoldDiagnostic({ code: "PARSE_ERROR", language: "zig", message: "Zig source contains a lone UTF-16 surrogate.",
+            location: { filename, start: indexedPointAt(coordinates, offset), end: indexedPointAt(coordinates, offset + 1) } });
+    }
+    if (source.length > maximumZigSourceLength)
+        return unsupportedSyntax("zig", "source exceeds the 1000000 UTF-16 input limit", location);
+    let snapshot;
+    try {
+        snapshot = parseZigCst(source);
+    }
+    catch (error) {
+        throw new SemantifoldDiagnostic({ code: "PARSE_ERROR", language: "zig", location,
+            cause: error instanceof Error ? error : undefined, message: "The qualified Zig parser could not produce a complete CST." });
+    }
+    const reader = new ZigReader(filename, source);
+    try {
+        return reader.module(snapshot.root);
+    }
+    catch (error) {
+        if (reader.generated && error instanceof SemantifoldDiagnostic && error.language == "zig" &&
+            error.code != "PARSE_ERROR" && error.code != "UNSUPPORTED_SYNTAX") {
+            return unsupportedSyntax("zig", `invalid generated ordered scaffold: ${error.code}`, error.location ?? location);
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zig.js","sourceRoot":"","sources":["../../../src/frontends/zig.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,EAAC,eAAe,EAAC,MAAM,4BAA4B,CAAA;AAC1D,OAAO,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAA;AACrD,OAAO,EAAC,UAAU,EAAC,MAAM,4BAA4B,CAAA;AACrD,OAAO,EAAC,sBAAsB,EAAC,MAAM,+BAA+B,CAAA;AACpE,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;AAC7C,OAAO,EAAC,WAAW,EAAC,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAC,sBAAsB,EAAC,MAAM,oBAAoB,CAAA;AAEzD,2DAA2D;AAC3D,sEAAsE;AACtE,oEAAoE;AACpE,8EAA8E;AAE9E,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,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC;CAC7B,CAAC,CAAA;AACF,MAAM,gBAAgB,GAAG,IAAI,GAAG,CAAC;IAC/B,CAAC,yBAAyB,EAAE,KAAK,CAAC,EAAE,CAAC,8BAA8B,EAAE,UAAU,CAAC;IAChF,CAAC,8BAA8B,EAAE,UAAU,CAAC,EAAE,CAAC,2BAA2B,EAAE,KAAK,CAAC;IAClF,CAAC,0BAA0B,EAAE,OAAO,CAAC,EAAE,CAAC,8BAA8B,EAAE,UAAU,CAAC;CACpF,CAAC,CAAA;AACF,MAAM,kBAAkB,GAAG,IAAI,GAAG,CAAC;IACjC,CAAC,YAAY,EAAE,yBAAyB,CAAC,EAAE,CAAC,iBAAiB,EAAE,8BAA8B,CAAC;IAC9F,CAAC,iBAAiB,EAAE,8BAA8B,CAAC,EAAE,CAAC,eAAe,EAAE,4BAA4B,CAAC;IACpG,CAAC,cAAc,EAAE,IAAI,CAAC,EAAE,CAAC,iBAAiB,EAAE,IAAI,CAAC,EAAE,CAAC,iBAAiB,EAAE,GAAG,CAAC;IAC3E,CAAC,wBAAwB,EAAE,IAAI,CAAC,EAAE,CAAC,oBAAoB,EAAE,GAAG,CAAC,EAAE,CAAC,2BAA2B,EAAE,IAAI,CAAC;IAClG,CAAC,cAAc,EAAE,IAAI,CAAC,EAAE,CAAC,iBAAiB,EAAE,IAAI,CAAC,EAAE,CAAC,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC,WAAW,EAAE,IAAI,CAAC,EAAE,CAAC,YAAY,EAAE,GAAG,CAAC;IAClH,CAAC,cAAc,EAAE,2BAA2B,CAAC,EAAE,CAAC,aAAa,EAAE,0BAA0B,CAAC;IAC1F,CAAC,gBAAgB,EAAE,8BAA8B,CAAC;CACnD,CAAC,CAAA;AAEF,6FAA6F;AAC7F,MAAM,SAAS;IACb;;;;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,iEAAiE;QACjE,IAAI,CAAC,UAAU,GAAG,IAAI,GAAG,EAAE,CAAA;QAC3B,4DAA4D;QAC5D,IAAI,CAAC,MAAM,GAAG,IAAI,GAAG,EAAE,CAAA;QACvB,kCAAkC;QAClC,IAAI,CAAC,SAAS,GAAG,IAAI,GAAG,EAAE,CAAA;QAC1B,0IAA0I;QAC1I,IAAI,CAAC,SAAS,GAAG,IAAI,GAAG,EAAE,CAAA;IAC5B,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;;;;OAIG;IACH,MAAM,CAAC,IAAI;QACT,OAAO,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,CAAA;IAC5C,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;;;;OAIG;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,IAAI,CAAC,IAAI,IAAI,SAAS,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,sBAAsB,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;YACtH,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,oCAAoC,CAAC,CAAA;QACvD,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,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,IAAI,SAAS,CAAC,CAAA;IAC7F,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,KAAK,CAAC,EAAE,CAChE,KAAK,CAAC,IAAI,IAAI,SAAS,IAAI,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;IACtE,CAAC;IAED;;;;;OAKG;IACH,KAAK,CAAC,IAAI,EAAE,IAAI;QACd,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,EAAC,KAAK,EAAC,EAAE,EAAE,CAAC,KAAK,IAAI,IAAI,CAAC,CAAA;QAE9D,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,iBAAiB,IAAI,SAAS,CAAC,CAAA;QACtE,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA;IACtB,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,IAAI,EAAE,QAAQ;QAClB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QAE9B,IAAI,KAAK,CAAC,MAAM,IAAI,QAAQ,CAAC,MAAM,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CACjE,OAAO,QAAQ,CAAC,KAAK,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,IAAI,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,KAAK,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC;YACzJ,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,IAAI,CAAC,IAAI,cAAc,CAAC,CAAA;QAC7C,CAAC;IACH,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;;;;;OAKG;IACH,IAAI,CAAC,IAAI,EAAE,SAAS,GAAG,KAAK;QAC1B,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QAEhC,IAAI,SAAS,IAAI,IAAI,CAAC,IAAI,IAAI,cAAc,IAAI,QAAQ,IAAI,MAAM,EAAE,CAAC;YACnE,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,MAAM,CAAC,CAAC,CAAA;YAC1B,OAAO,gBAAgB,CAAC,EAAC,IAAI,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,EAAC,EAAE,EAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAC,CAAC,CAAA;QAC7F,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,IAAI,cAAc,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;YACtE,IAAI,QAAQ,IAAI,MAAM;gBAAE,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,MAAM,CAAC,CAAC,CAAA;iBAC7C,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM;gBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,mBAAmB,CAAC,CAAA;QACrE,CAAC;aAAM,IAAI,IAAI,CAAC,IAAI,IAAI,YAAY,IAAI,QAAQ,IAAI,YAAY,EAAE,CAAC;YACjE,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;YAC1D,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAA;YAEjC,IAAI,KAAK,CAAC,IAAI,IAAI,cAAc,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,IAAI,IAAI,KAAK,CAAC,QAAQ,CAAC,MAAM;gBAAE,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,+BAA+B,CAAC,CAAA;QAC1I,CAAC;;YAAM,OAAO,WAAW,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAA;QAC/F,MAAM,IAAI,GAAG,gBAAgB,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAA;QAEnE,IAAI,CAAC,IAAI;YAAE,OAAO,WAAW,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAA;QACnE,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;;OAIG;IACH,IAAI,CAAC,IAAI;QACP,IAAI,IAAI,CAAC,IAAI,IAAI,iBAAiB;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,sBAAsB,CAAC,CAAA;QAC3E,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,UAAU,CAAC,CAAA;QACzC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QAC9B,MAAM,kBAAkB,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;QAC7C,MAAM,IAAI,GAAG,kBAAkB,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,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAA;QAC9G,OAAO,EAAC,IAAI,EAAE,SAAS,EAAE,IAAI,EAAC,CAAA;IAChC,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,IAAI;QACT,IAAI,IAAI,CAAC,IAAI,IAAI,QAAQ;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,wCAAwC,CAAC,CAAA;QACpF,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,IAAI,KAAK,GAAG,EAAE,CAAA;QAEd,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACtC,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAEhC,IAAI,IAAI,CAAC,IAAI,IAAI,gBAAgB,EAAE,CAAC;gBAClC,IAAI,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC;oBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,4BAA4B,CAAC,CAAA;gBAC3E,KAAK,IAAI,QAAQ,CAAA;YACnB,CAAC;iBAAM,IAAI,IAAI,CAAC,IAAI,IAAI,iBAAiB,EAAE,CAAC;gBAC1C,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC,CAAA;gBAEnG,IAAI,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;oBAAE,KAAK,IAAI,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;qBAClD,IAAI,sBAAsB,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;oBAC/C,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;oBAErD,IAAI,MAAM,GAAG,GAAG;wBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,uBAAuB,CAAC,CAAA;oBAC1D,KAAK,IAAI,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,CAAA;gBACvC,CAAC;qBAAM,IAAI,4BAA4B,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;oBACvD,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAA;oBAEzD,IAAI,MAAM,GAAG,QAAQ,IAAI,MAAM,IAAI,MAAM,IAAI,MAAM,IAAI,MAAM;wBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,2BAA2B,CAAC,CAAA;oBAC3G,KAAK,IAAI,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,CAAA;gBACvC,CAAC;;oBAAM,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,2BAA2B,CAAC,CAAA;YACrD,CAAC;;gBAAM,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,cAAc,CAAC,CAAA;QACxC,CAAC;QACD,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,yBAAyB,CAAC,CAAA;QAC7E,OAAO,KAAK,CAAA;IACd,CAAC;IAED;;;;OAIG;IACH,UAAU,CAAC,IAAI;QACb,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;QAEpC,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,CAAC,CAAA;QAClC,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,SAAS,EAAE,CAAC;YAC3B,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAChC,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAA;YAE9B,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,KAAK,CAAC;gBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,sCAAsC,CAAC,CAAA;YACnI,OAAO,gBAAgB,CAAC,EAAC,IAAI,EAAE,gBAAgB,EAAE,QAAQ,EAAE,KAAK,EAAC,EAAE,EAAC,OAAO,EAAE,QAAQ,EAAC,CAAC,CAAA;QACzF,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,IAAI,SAAS,EAAE,CAAC;YAC3B,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAEhC,IAAI,QAAQ,IAAI,MAAM,IAAI,QAAQ,IAAI,OAAO;gBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,0BAA0B,CAAC,CAAA;YAC1F,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAA;YAC5B,OAAO,gBAAgB,CAAC,EAAC,IAAI,EAAE,gBAAgB,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,IAAI,MAAM,EAAC,EAAE,EAAC,OAAO,EAAE,QAAQ,EAAC,CAAC,CAAA;QAC7G,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,IAAI,QAAQ;YAAE,OAAO,gBAAgB,CAAC,EAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,EAAE,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAC,EAAE,EAAC,OAAO,EAAE,QAAQ,EAAC,CAAC,CAAA;QACpI,IAAI,IAAI,CAAC,IAAI,IAAI,kBAAkB,IAAI,IAAI,CAAC,IAAI,IAAI,kBAAkB,EAAE,CAAC;YACvE,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;YAC9B,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,IAAI,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;YAC1F,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,IAAI,kBAAkB,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;YAEvG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAA;YACrC,IAAI,QAAQ,CAAC,IAAI,IAAI,GAAG,IAAI,QAAQ,CAAC,IAAI,IAAI,GAAG;gBAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,gBAAgB,CAAC,CAAA;YACvF,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,OAAO,CAAC,EAAE,QAAQ,CAAC,CAAA;QACtG,CAAC;QACD,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,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,6BAA6B,CAAC,CAAA;YAC/D,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,CAAA;QAC3F,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,IAAI,iBAAiB,EAAE,CAAC;YACnC,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAE5B,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,YAAY;gBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,+BAA+B,CAAC,CAAA;YACzF,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAEjC,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,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAA;YAClF,CAAC;YACD,MAAM,MAAM,GAAG,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;YAEzC,IAAI,MAAM,EAAE,CAAC;gBACX,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,IAAI,CAAC;oBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,uBAAuB,CAAC,CAAA;gBACxE,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAA;YACrH,CAAC;YACD,IAAI,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC;gBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,gDAAgD,CAAC,CAAA;YAC3G,MAAM,MAAM,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAEzC,OAAO,gBAAgB,CAAC,EAAC,IAAI,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,EAAC,EAAE,EAAC,MAAM,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EAAC,CAAC,CAAA;QAC/K,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,MAAM,UAAU,GAAG,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,EACxJ,EAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAC,CAAC,EAAE,kEAAkE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAA;QAErH,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,UAAU,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAC,CAAC,CAAA;QAChF,OAAO,UAAU,CAAA;IACnB,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ;QACnC,MAAM,UAAU,GAAG,yBAAyB,CAAC,CAAC,oBAAoB,CAAC,gBAAgB,CAAC,EAAC,IAAI,EAAE,iBAAiB,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,EAAC,EACnJ,EAAC,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAA;QAEhD,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,UAAU,EAAE,EAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAC,CAAC,CAAA;QAChF,OAAO,UAAU,CAAA;IACnB,CAAC;IAED;;;;OAIG;IACH,SAAS,CAAC,IAAI;QACZ,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;QACpC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QAE9B,IAAI,IAAI,CAAC,IAAI,IAAI,sBAAsB,EAAE,CAAC;YACxC,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC;gBAC9C,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAC,KAAK,EAAC,EAAE,EAAE,CAAC,KAAK,IAAI,MAAM,CAAC,EAAE,IAAI,CAAA;gBAEvE,IAAI,CAAC,QAAQ;oBAAE,OAAO,WAAW,CAAC,KAAK,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAA;gBAC3D,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;gBACrB,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;gBAEtB,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC,CAAA;gBAClE,OAAO,gBAAgB,CAAC,EAAC,IAAI,EAAE,kBAAkB,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,2DAA2D,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,KAAK;oBAChN,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,KAAK,CAAC,CAAC,CAAC,CAAC,EAAC,CAAC,CAAA;YACzG,CAAC;YACD,MAAM,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;YAC3B,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;YAEtB,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,UAAU,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC,CAAA;YAC/C,MAAM,MAAM,GAAG,gBAAgB,CAAC,EAAC,IAAI,EAAE,oBAAoB,CAAC,CAAC,sBAAsB,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,EAAC,EAAE,EAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAC,CAAC,CAAA;YAEjM,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,KAAK,CAAC,CAAC,CAAC,CAAC,EAAC,CAAC,CAAA;QACnJ,CAAC;QACD,IAAI,IAAI,CAAC,IAAI,IAAI,cAAc;YAAE,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAA;QAC9D,IAAI,IAAI,CAAC,IAAI,IAAI,sBAAsB;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,6BAA6B,CAAC,CAAA;QACvF,MAAM,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;QAE3B,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC,CAAA;QACnC,IAAI,UAAU,CAAC,IAAI,IAAI,mBAAmB,EAAE,CAAC;YAC3C,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAA;YAEvC,IAAI,QAAQ,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;gBACzB,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAA;gBAClC,OAAO,EAAC,IAAI,EAAE,iBAAiB,EAAE,QAAQ,EAAC,CAAA;YAC5C,CAAC;YACD,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;YAC/C,OAAO,EAAC,IAAI,EAAE,iBAAiB,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAC,CAAA;QACtF,CAAC;QACD,IAAI,UAAU,CAAC,IAAI,IAAI,iBAAiB;YAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,qCAAqC,CAAC,CAAA;QACtG,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAA;QAClC,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QAEjC,IAAI,iDAAiD,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YACjE,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,YAAY,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,IAAI,CAAC;gBAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,kCAAkC,CAAC,CAAA;YAC3H,MAAM,SAAS,GAAG,EAAC,IAAI,EAAE,oBAAoB,CAAC,CAAC,gBAAgB,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAAC,CAAA;YAE3H,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,EAAE,EAAC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,oBAAoB,CAAC,MAAM,CAAC,EAAC,CAAC,CAAA;YAC5F,OAAO,SAAS,CAAA;QAClB,CAAC;QACD,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,UAAU,CAAC,CAAA;QAEzC,IAAI,KAAK,CAAC,IAAI,IAAI,gBAAgB;YAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,qCAAqC,CAAC,CAAA;QAChG,OAAO,EAAC,IAAI,EAAE,qBAAqB,EAAE,QAAQ,EAAE,UAAU,EAAE,KAAK,EAAC,CAAA;IACnE,CAAC;IAED;;;;OAIG;IACH,WAAW,CAAC,IAAI;QACd,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,WAAW,CAAC,CAAA;QAC/C,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;QACrC,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,IAAI,aAAa,CAAC,CAAA;QAE/E,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;QAC1F,MAAM,SAAS,GAAG,EAAC,IAAI,EAAE,oBAAoB,CAAC,CAAC,aAAa,CAAC,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,UAAU,EAAE,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,EAAC,CAAA;QAE5K,IAAI,CAAC,WAAW;YAAE,OAAO,SAAS,CAAA;QAClC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,aAAa,CAAC,CAAA;QAErD,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;QACzC,IAAI,MAAM,CAAC,IAAI,IAAI,mBAAmB;YAAE,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,4BAA4B,CAAC,CAAA;QACvF,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAA;QAEnC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,CAAC,CAAA;QAC3B,OAAO,EAAC,GAAG,SAAS,EAAE,SAAS,EAAE,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,EAAC,CAAA;IACrD,CAAC;IAED;;;;OAIG;IACH,eAAe,CAAC,IAAI;QAClB,IAAI,IAAI,CAAC,IAAI,IAAI,kBAAkB;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,mCAAmC,CAAC,CAAA;QACzF,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAA;QAEjC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,CAAA;QACzB,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAA;IAC1B,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,IAAI,EAAE,IAAI,GAAG,CAAC,EAAE,UAAU,GAAG,EAAE;QACnC,IAAI,IAAI,CAAC,IAAI,IAAI,OAAO;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,uBAAuB,CAAC,CAAA;QAClE,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,MAAM,gBAAgB,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,EAAE,CAAC,CAAC,CAAC,CAAA;QACnE,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,gBAAgB,EAAE,UAAU,CAAC;gBACxD,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,gBAAgB,EAAE,UAAU,CAAC,EAAC,CAAA;IAC1D,CAAC;IAED;;;;;OAKG;IACH,gBAAgB,CAAC,gBAAgB,EAAE,UAAU;QAC3C,IAAI,MAAM,GAAG,CAAC,CAAA;QAEd,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,MAAM,IAAI,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;YAE9G,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,IAAI,MAAM,CAAC,CAAA;YAC7C,IAAI,IAAI;gBAAE,MAAM,IAAI,CAAC,CAAA;QACvB,CAAC;QACD,0BAA0B;QAC1B,MAAM,UAAU,GAAG,EAAE,CAAA;QAErB,OAAO,MAAM,GAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC;YACxC,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAA;YAE1D,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAA;YAC1B,MAAM,IAAI,CAAC,CAAA;YACX,IAAI,SAAS,CAAC,IAAI,IAAI,kBAAkB,EAAE,CAAC;gBACzC,MAAM,IAAI,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;gBAE9G,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,IAAI,MAAM,CAAC,CAAA;gBAC7C,IAAI,IAAI;oBAAE,MAAM,IAAI,CAAC,CAAA;YACvB,CAAC;QACH,CAAC;QACD,OAAO,UAAU,CAAA;IACnB,CAAC;IAED;;;;;OAKG;IACH,mBAAmB,CAAC,gBAAgB,EAAE,UAAU;QAC9C,0BAA0B;QAC1B,MAAM,UAAU,GAAG,EAAE,CAAA;QACrB,IAAI,MAAM,GAAG,CAAC,CAAA;QAEd,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,MAAM,IAAI,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;YAE9G,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,IAAI,MAAM,CAAC,CAAA;YAC7C,IAAI,IAAI;gBAAE,MAAM,IAAI,CAAC,CAAA;QACvB,CAAC;QACD,OAAO,MAAM,GAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC;YACxC,MAAM,KAAK,GAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAAA;YACxC,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,IAAI,SAAS;gBACnC,+EAA+E,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAA;YAE1G,IAAI,CAAC,KAAK;gBAAE,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,sDAAsD,CAAC,CAAA;YACpF,MAAM,gBAAgB,GAAG,IAAI,CAAC,oBAAoB,CAAA;YAClD,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,gBAAgB,CAAC,MAAM,IAAI,IAAI,CAAC,oBAAoB,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;gBAC/F,MAAM,GAAG,IAAI,CAAC,aAAa,CAAC,gBAAgB,EAAE,MAAM,CAAC,CAAA;YACvD,CAAC;YACD,MAAM,QAAQ,GAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAAA;YAE3C,IAAI,CAAC,QAAQ;gBAAE,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,oCAAoC,CAAC,CAAA;YACrE,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,wCAAwC,CAAC,CAAA;YACtG,IAAI,SAAS,CAAC,IAAI,IAAI,kBAAkB,EAAE,CAAC;gBACzC,MAAM,IAAI,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,gBAAgB,CAAC,MAAM,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;gBAE9G,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,IAAI,MAAM,CAAC,CAAA;gBAC7C,IAAI,IAAI;oBAAE,MAAM,IAAI,CAAC,CAAA;YACvB,CAAC;YACD,MAAM,GAAG,GAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAAA;YAEtC,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,IAAI,IAAI,SAAS,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC;gBACnD,gDAAgD,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,EAAE;gBAAE,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,KAAK,EAAE,+BAA+B,CAAC,CAAA;YAClI,IAAI,CAAC,oBAAoB,GAAG,gBAAgB,CAAA;YAC5C,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,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QAE9B,OAAO,IAAI,CAAC,IAAI,IAAI,sBAAsB,IAAI,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC;YACrF,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,IAAI,YAAY,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,sBAAsB,CAAC,CAAA;IAC5F,CAAC;IAED;;;;;OAKG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM;QACzB,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,CAAA;QAC5B,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QAC9B,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;QACzB,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QAChC,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;QACzC,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAA;QAEtB,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC,CAAA;QACtE,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QACnB,IAAI,CAAC,iCAAiC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,cAAc,EAAE,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YACpF,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,yCAAyC,CAAC,CAAA;QAChE,CAAC;QACD,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,IAAI,IAAI,CAAC,kBAAkB,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,CAAC;YACpD,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;YACjD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;YACvC,MAAM,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAA;YAC5C,MAAM,IAAI,GAAG,cAAc,CAAC,CAAC,CAAC,EAAE,IAAI,IAAI,GAAG,CAAA;YAC3C,MAAM,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,SAAS,CAAC,IAAI,IAAI,kBAAkB,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;YAEjH,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC,CAAA;YACrD,IAAI,MAAM,CAAC,IAAI,IAAI,YAAY,IAAI,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,IAAI;gBAAE,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,wCAAwC,CAAC,CAAA;YACzH,IAAI,IAAI;gBAAE,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,cAAc,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAA;YAC5D,IAAI,IAAI,IAAI,cAAc,CAAC,CAAC,CAAC,EAAE,IAAI,IAAI,GAAG;gBAAE,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,SAAS,EAAE,kCAAkC,CAAC,CAAA;YACzH,IAAI,IAAI,CAAC,IAAI,IAAI,kBAAkB;gBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,+BAA+B,CAAC,CAAA;YACrF,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAA;YAEjC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,CAAA;YACzB,IAAI,KAAK,CAAC,IAAI,IAAI,OAAO;gBAAE,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,+BAA+B,CAAC,CAAA;YAC5E,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;YACnD,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,KAAK,EAAE,0CAA0C,CAAC,CAAA;YAC7F,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,CAAC,CAAA;YACjC,MAAM,eAAe,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAA;YAC9C,MAAM,IAAI,GAAG,eAAe,CAAC,CAAC,CAAC,CAAA;YAC/B,MAAM,KAAK,GAAG,eAAe,CAAC,CAAC,CAAC,CAAA;YAEhC,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,CAAC,CAAC,CAAA;YAC/C,IAAI,IAAI,CAAC,IAAI,IAAI,YAAY,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI;gBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,sCAAsC,CAAC,CAAA;YACjH,IAAI,KAAK,CAAC,IAAI,IAAI,mBAAmB;gBAAE,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,2CAA2C,CAAC,CAAA;YACpG,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;YAC1C,MAAM,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,OAAO,CAAC,CAAA;YAC1C,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,UAAU,CAAC,CAAA;YAC9C,MAAM,QAAQ,GAAG,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAA;YAEpC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC,CAAA;YAChD,IAAI,QAAQ,CAAC,IAAI,IAAI,YAAY,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,IAAI;gBAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,wCAAwC,CAAC,CAAA;YAC/H,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,CAAA;YACpG,MAAM,IAAI,CAAC,CAAA;QACb,CAAC;QACD,IAAI,CAAC,oBAAoB,EAAE,GAAG,CAAC,IAAI,EAAE,UAAU,CAAC,CAAA;QAChD,OAAO,MAAM,CAAA;IACf,CAAC;IAED;;;;;OAKG;IACH,kBAAkB,CAAC,IAAI,EAAE,IAAI;QAC3B,IAAI,IAAI,CAAC,IAAI,IAAI,cAAc,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,IAAI,aAAa,CAAC;YAAE,OAAO,KAAK,CAAA;QAC5G,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,EAAC,KAAK,EAAC,EAAE,EAAE,CAAC,KAAK,IAAI,MAAM,CAAC,EAAE,IAAI,CAAA;QAEnE,IAAI,IAAI,EAAE,IAAI,IAAI,kBAAkB;YAAE,OAAO,KAAK,CAAA;QAClD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAA;QAEjC,IAAI,KAAK,EAAE,IAAI,IAAI,OAAO;YAAE,OAAO,KAAK,CAAA;QACxC,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAA;QACnD,MAAM,KAAK,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAA;QAC3B,MAAM,UAAU,GAAG,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAA;QAEjD,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,IAAI,SAAS,CAAC,IAAI,KAAK,EAAE,IAAI,IAAI,sBAAsB;YACjH,UAAU,CAAC,CAAC,CAAC,EAAE,IAAI,IAAI,YAAY,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,IAAI,UAAU,CAAC,CAAC,CAAC,EAAE,IAAI,IAAI,GAAG,CAAA;IACzG,CAAC;IAED;;;;;OAKG;IACH,WAAW,CAAC,IAAI,EAAE,IAAI;QACpB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QAE9B,IAAI,IAAI,CAAC,IAAI,IAAI,sBAAsB,IAAI,KAAK,CAAC,MAAM,IAAI,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,YAAY,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,GAAG,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,GAAG;YAAE,OAAO,SAAS,CAAA;QAC7L,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,YAAY,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI;YAAE,OAAO,KAAK,CAAA;QAC9E,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,sBAAsB,EAAE,CAAC;YAC5C,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;YAEtC,IAAI,SAAS,CAAC,MAAM,IAAI,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,GAAG,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,YAAY,IAAI,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI;gBAAE,OAAO,SAAS,CAAA;QACjJ,CAAC;QACD,OAAO,SAAS,CAAA;IAClB,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,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,IAAI,YAAY,CAAC,CAAA;QAC7E,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;QAC3C,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;QAErC,IAAI,CAAC,UAAU;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,yBAAyB,CAAC,CAAA;QAC3D,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC,CAAA;QAC5D,MAAM,cAAc,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAA;QAC7C,MAAM,YAAY,GAAG,cAAc,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;QAEzF,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,GAAG,EAAE,GAAG,YAAY,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,CAAA;QACzH,MAAM,SAAS,GAAG,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE;YAC7C,IAAI,SAAS,CAAC,IAAI,IAAI,WAAW;gBAAE,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,0BAA0B,CAAC,CAAA;YACnF,MAAM,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,MAAM,CAAC,CAAA;YACnD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,MAAM,CAAC,CAAA;YAE1C,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,aAAa,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC,CAAA;YACjD,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,aAAa,CAAC,EAAE,IAAI,EAAE,2DAA2D,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAC,EAAE,EAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,EAAC,CAAC,CAAA;QAC1Q,CAAC,CAAC,CAAA;QAEF,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,UAAU,EAAE,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,EAAE,SAAS,CAAC,EAAC,EAAE,EAAC,IAAI,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAC,CAAC,CAAA;IAChH,CAAC;IAED;;;;;OAKG;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,2BAA2B,CAAC,CAAA;QACpJ,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,+BAA+B,CAAC,CAAA;QACnF,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC;YACjB,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,IAAI,SAAS,IAAI,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;YAChI,MAAM,YAAY,GAAG,QAAQ,CAAC,IAAI,IAAI,SAAS,IAAI,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;YAEzJ,IAAI,UAAU,IAAI,YAAY;gBAAE,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,4BAA4B,CAAC,CAAA;QACjF,CAAC;QACD,IAAI,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;YAC5B,MAAM,aAAa,GAAG,KAAK,CAAC,KAAK,CAAC,CAAA;YAElC,IAAI,CAAC,aAAa,IAAI,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,KAAK,CAAC,EAAE,KAAK,IAAI,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,KAAK,aAAa,CAAC,EAAE,KAAK,EAAE,CAAC;gBACrJ,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,4BAA4B,CAAC,CAAA;YAChD,CAAC;YACD,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,aAAa,EAAE,SAAS,CAAC,CAAA;QACnD,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;;OAKG;IACH,cAAc,CAAC,UAAU,EAAE,QAAQ;QACjC,IAAI,UAAU,CAAC,IAAI,IAAI,eAAe;YAAE,OAAO,QAAQ,CAAA;QACvD,IAAI,UAAU,CAAC,IAAI,IAAI,gBAAgB;YAAE,OAAO,SAAS,CAAA;QACzD,IAAI,UAAU,CAAC,IAAI,IAAI,gBAAgB;YAAE,OAAO,SAAS,CAAA;QACzD,IAAI,UAAU,CAAC,IAAI,IAAI,kBAAkB,IAAI,UAAU,CAAC,IAAI,IAAI,iBAAiB;YAAE,OAAO,UAAU,CAAC,IAAI,CAAA;QACzG,IAAI,UAAU,CAAC,IAAI,IAAI,gBAAgB,IAAI,UAAU,CAAC,IAAI,IAAI,sBAAsB;YAAE,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAA;QAC9J,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,IAAI,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,CAAA;QAExH,IAAI,CAAC,IAAI;YAAE,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAA;QAC/E,OAAO,IAAI,CAAA;IACb,CAAC;IAED;;;OAGG;IACH,2BAA2B,CAAC,UAAU;QACpC,IAAI,UAAU,CAAC,IAAI,IAAI,gBAAgB,EAAE,CAAC;YACxC,UAAU,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,2BAA2B,CAAC,QAAQ,CAAC,CAAC,CAAA;YACpF,OAAM;QACR,CAAC;QACD,IAAI,UAAU,CAAC,IAAI,IAAI,iBAAiB,EAAE,CAAC;YACzC,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;YAChD,MAAM,QAAQ,GAAG,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,CAAA;YAE7D,IAAI,CAAC,QAAQ;gBAAE,MAAM,IAAI,KAAK,CAAC,wDAAwD,CAAC,CAAA;YACxF,IAAI,QAAQ,CAAC,QAAQ,IAAI,QAAQ;gBAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,UAAU,CAAC,SAAS,+BAA+B,CAAC,CAAA;YACzH,IAAI,CAAC,2BAA2B,CAAC,UAAU,CAAC,OAAO,CAAC,CAAA;YACpD,OAAM;QACR,CAAC;QACD,IAAI,UAAU,CAAC,IAAI,IAAI,kBAAkB,EAAE,CAAC;YAC1C,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;YAChD,MAAM,QAAQ,GAAG,kBAAkB,CAAC,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,CAAA;YAE7D,IAAI,CAAC,QAAQ;gBAAE,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAA;YACzF,IAAI,QAAQ,CAAC,QAAQ,IAAI,QAAQ;gBAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,UAAU,CAAC,SAAS,+BAA+B,CAAC,CAAA;YACzH,IAAI,CAAC,2BAA2B,CAAC,UAAU,CAAC,IAAI,CAAC,CAAA;YACjD,IAAI,CAAC,2BAA2B,CAAC,UAAU,CAAC,KAAK,CAAC,CAAA;QACpD,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,kBAAkB,CAAC,KAAK;QACtB,KAAK,MAAM,SAAS,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;YACzC,IAAI,SAAS,CAAC,IAAI,IAAI,kBAAkB;gBAAE,IAAI,CAAC,2BAA2B,CAAC,SAAS,CAAC,WAAW,CAAC,CAAA;iBAC5F,IAAI,SAAS,CAAC,IAAI,IAAI,qBAAqB,IAAI,SAAS,CAAC,IAAI,IAAI,qBAAqB,IAAI,SAAS,CAAC,IAAI,IAAI,gBAAgB,EAAE,CAAC;gBAClI,IAAI,CAAC,2BAA2B,CAAC,SAAS,CAAC,UAAU,CAAC,CAAA;YACxD,CAAC;iBAAM,IAAI,SAAS,CAAC,IAAI,IAAI,iBAAiB,EAAE,CAAC;gBAC/C,IAAI,SAAS,CAAC,UAAU;oBAAE,IAAI,CAAC,2BAA2B,CAAC,SAAS,CAAC,UAAU,CAAC,CAAA;YAClF,CAAC;iBAAM,IAAI,SAAS,CAAC,IAAI,IAAI,aAAa,EAAE,CAAC;gBAC3C,IAAI,CAAC,2BAA2B,CAAC,SAAS,CAAC,SAAS,CAAC,CAAA;gBACrD,IAAI,CAAC,kBAAkB,CAAC,SAAS,CAAC,UAAU,CAAC,CAAA;gBAC7C,IAAI,SAAS,CAAC,SAAS;oBAAE,IAAI,CAAC,kBAAkB,CAAC,SAAS,CAAC,SAAS,CAAC,CAAA;YACvE,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;OAIG;IACH,cAAc,CAAC,KAAK,EAAE,SAAS;QAC7B,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,CAAA;QAEnC,KAAK,MAAM,SAAS,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;YACzC,IAAI,SAAS,CAAC,IAAI,IAAI,kBAAkB,EAAE,CAAC;gBACzC,QAAQ,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,EAAE,2DAA2D,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAA;YACjH,CAAC;iBAAM,IAAI,SAAS,CAAC,IAAI,IAAI,gBAAgB,EAAE,CAAC;gBAC9C,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAA;gBAExC,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,UAAU,EAAE,QAAQ,CAAC,IAAI,KAAK,CAAC,IAAI;oBAAE,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,IAAI,sBAAsB,CAAC,CAAC,EAAE,CAAC,EAAE,8BAA8B,CAAC,CAAA;YACxK,CAAC;iBAAM,IAAI,SAAS,CAAC,IAAI,IAAI,aAAa,EAAE,CAAC;gBAC3C,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAA;gBACnD,IAAI,SAAS,CAAC,SAAS;oBAAE,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAA;YAC7E,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;OAGG;IACH,iBAAiB,CAAC,KAAK;QACrB,MAAM,KAAK,GAAG,sBAAsB,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QAChD,MAAM,UAAU,GAAG,KAAK,CAAC,IAAI,IAAI,qBAAqB,CAAC,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,CAAA;QAE9E,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;YACnC,MAAM,QAAQ,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAA;YAEjE,IAAI,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,QAAQ;gBAAE,iBAAiB,CAAC,KAAK,EAAE,4CAA4C,SAAS,CAAC,IAAI,GAAG,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAA;QAC5J,CAAC;QACD;;;WAGG;QACH,MAAM,KAAK,GAAG,CAAC,KAAK,EAAE,EAAE;YACtB,KAAK,MAAM,SAAS,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;gBACzC,IAAI,SAAS,CAAC,IAAI,IAAI,kBAAkB,EAAE,CAAC;oBACzC,MAAM,QAAQ,GAAG,SAAS,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;wBACnF,CAAC,SAAS,CAAC,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAA;oBAEzE,IAAI,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,QAAQ;wBAAE,iBAAiB,CAAC,KAAK,EAAE,yCAAyC,SAAS,CAAC,IAAI,GAAG,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAA;gBACzJ,CAAC;qBAAM,IAAI,SAAS,CAAC,IAAI,IAAI,aAAa,EAAE,CAAC;oBAC3C,KAAK,CAAC,SAAS,CAAC,UAAU,CAAC,CAAA;oBAC3B,IAAI,SAAS,CAAC,SAAS;wBAAE,KAAK,CAAC,SAAS,CAAC,SAAS,CAAC,CAAA;gBACrD,CAAC;YACH,CAAC;QACH,CAAC,CAAA;QAED,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;IACnB,CAAC;IAED;;;;OAIG;IACH,MAAM,CAAC,IAAI;QACT,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAA;QACvB,IAAI,IAAI,CAAC,IAAI,IAAI,aAAa;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,0BAA0B,CAAC,CAAA;QAC3E,MAAM,SAAS,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAA;QAC1D,MAAM,OAAO,GAAG,SAAS,CAAC,WAAW,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CAAA;QACnE,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAA;QAEpC,IAAI,KAAK,CAAC,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,CAAC;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,+DAA+D,CAAC,CAAA;QACvH,OAAO,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAA;QACzF,MAAM,aAAa,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;QAE3C,IAAI,aAAa,CAAC,IAAI,IAAI,SAAS,IAAI,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,+BAA+B,EAAE,CAAC;YACrG,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,wDAAwD,CAAC,CAAA;QACpF,CAAC;QACD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAA;QACrB,MAAM,WAAW,GAAG,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC,CAAA;QACnD,kCAAkC;QAClC,IAAI,IAAI,CAAA;QACR,wBAAwB;QACxB,MAAM,SAAS,GAAG,EAAE,CAAA;QAEpB,KAAK,MAAM,IAAI,IAAI,WAAW,EAAE,CAAC;YAC/B,IAAI,IAAI,CAAC,IAAI,IAAI,sBAAsB;gBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,+BAA+B,CAAC,CAAA;YACzF,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAA;YAEhD,IAAI,IAAI,IAAI,MAAM,EAAE,CAAC;gBACnB,IAAI,IAAI;oBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,gBAAgB,CAAC,CAAA;gBAC3C,IAAI,GAAG,IAAI,CAAA;YACb,CAAC;iBAAM,CAAC;gBACN,IAAI,IAAI;oBAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,8BAA8B,CAAC,CAAA;gBACzD,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YACtB,CAAC;QACH,CAAC;QACD,IAAI,CAAC,IAAI;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,uCAAuC,CAAC,CAAA;QACnE,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QAClC,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;QACzC,MAAM,UAAU,GAAG,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,IAAI,YAAY,CAAC,CAAA;QACtE,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;QAC3C,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;QAErC,IAAI,CAAC,UAAU;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,iBAAiB,CAAC,CAAA;QACnD,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC,CAAA;QACvE,IAAI,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,MAAM;YAAE,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAA;QACnE,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAA;QAClC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,CAAA;QAC3B,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,MAAM;YAAE,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,kBAAkB,CAAC,CAAA;QAC9E,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QAClC,MAAM,SAAS,GAAG,SAAS,CAAC,CAAC,CAAC,CAAA;QAC9B,MAAM,WAAW,GAAG,kEAAkE,CAAA;QACtF,MAAM,WAAW,GAAG,IAAI,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAA;QAC7D,MAAM,SAAS,GAAG,WAAW,CAAC,KAAK,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAA;QACrE,MAAM,aAAa,GAAG,WAAW,CAAC,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;QAEhF,IAAI,CAAC,SAAS;YAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,+BAA+B,CAAC,CAAA;QAChE,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,aAAa,EAAE,WAAW,CAAC,CAAA;QACvD,MAAM,MAAM,GAAG,oBAAoB,CAAC,EAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YACvI,UAAU,EAAE,EAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,EAAC,EAAC,EAAE,KAAK,CAAC,CAAA;QAErG,IAAI,CAAC,SAAS,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,SAAS,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,WAAW,CAAC,IAAI;YAC5E,2DAA2D,CAAC,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAA;QAC9F,KAAK,MAAM,WAAW,IAAI,MAAM,CAAC,SAAS;YAAE,IAAI,CAAC,kBAAkB,CAAC,WAAW,CAAC,IAAI,CAAC,CAAA;QACrF,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAA;QAC/C,KAAK,MAAM,WAAW,IAAI,MAAM,CAAC,SAAS;YAAE,IAAI,CAAC,cAAc,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,CAAC,WAAW,CAAC,UAAU,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,IAAI;gBAC/I,2DAA2D,CAAC,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAA;QACvF,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,EAAE,CAAC,CAAA;QACtD,KAAK,MAAM,WAAW,IAAI,MAAM,CAAC,SAAS;YAAE,IAAI,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAA;QAC/E,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,UAAU,CAAC,CAAA;QACzC,MAAM,eAAe,GAAG,kBAAkB,CAAC,EAAC,MAAM,EAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,CAAA;QAE1E,IAAI,OAAO,eAAe,IAAI,QAAQ;YAAE,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAA;QACzG,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,WAAW,CAAC,eAAe,CAAC,CAAC,IAAI,EAAE,IAAI,SAAS,CAAC,IAAI,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC,CAAA;QACxG,OAAO,MAAM,CAAA;IACf,CAAC;CACF;AAED;;;;GAIG;AACH,MAAM,UAAU,QAAQ,CAAC,EAAC,QAAQ,EAAE,MAAM,EAAC;IACzC,MAAM,WAAW,GAAG,qBAAqB,CAAC,MAAM,CAAC,CAAA;IACjD,MAAM,QAAQ,GAAG,EAAC,QAAQ,EAAE,KAAK,EAAE,cAAc,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,cAAc,CAAC,WAAW,EAAE,MAAM,CAAC,MAAM,CAAC,EAAC,CAAA;IAEnH,IAAI,CAAC,qBAAqB,CAAC,MAAM,CAAC,EAAE,CAAC;QACnC,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;QAAE,OAAO,iBAAiB,CAAC,KAAK,EAAE,+CAA+C,EAAE,QAAQ,CAAC,CAAA;IACtI,IAAI,QAAQ,CAAA;IAEZ,IAAI,CAAC;QACH,QAAQ,GAAG,WAAW,CAAC,MAAM,CAAC,CAAA;IAChC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,qBAAqB,CAAC,EAAC,IAAI,EAAE,aAAa,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ;YAC7E,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,EAAE,OAAO,EAAE,4DAA4D,EAAC,CAAC,CAAA;IAC9H,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,QAAQ,CAAC,CAAA;QAClH,CAAC;QACD,MAAM,KAAK,CAAA;IACb,CAAC;AACH,CAAC","sourcesContent":["// @ts-check\n\nimport {isZigIdentifier} from \"../backends/identifiers.js\"\nimport {generateZigProject} from \"../backends/zig.js\"\nimport {zigRuntime} from \"../backends/zig-runtime.js\"\nimport {maximumZigSourceLength} from \"../backends/zig-validation.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\"\nimport {parseZigCst} from \"./zig-parser.js\"\nimport {collectZigBindingUsage} from \"../zig-bindings.js\"\n\n/** @typedef {import(\"./zig-parser.js\").CstNode} CstNode */\n/** @typedef {import(\"../semantic/types.js\").Expression} Expression */\n/** @typedef {import(\"../semantic/types.js\").Statement} Statement */\n/** @typedef {import(\"../semantic/types.js\").FunctionReturnTypeName} Scalar */\n\nconst binaryOperations = new Map([\n  [\"+\", \"Add\"], [\"-\", \"Subtract\"], [\"*\", \"Multiply\"], [\"==\", \"Equal\"], [\"!=\", \"NotEqual\"],\n  [\"<\", \"LessThan\"], [\"<=\", \"LessThanOrEqual\"], [\">\", \"GreaterThan\"], [\">=\", \"GreaterThanOrEqual\"],\n  [\"and\", \"And\"], [\"or\", \"Or\"]\n])\nconst helperOperations = new Map([\n  [\"semantifold_integer_add\", \"Add\"], [\"semantifold_integer_subtract\", \"Subtract\"],\n  [\"semantifold_integer_multiply\", \"Multiply\"], [\"semantifold_string_concat\", \"Add\"],\n  [\"semantifold_string_equal\", \"Equal\"], [\"semantifold_string_not_equal\", \"NotEqual\"]\n])\nconst operationSpellings = new Map([\n  [\"IntegerAdd\", \"semantifold_integer_add\"], [\"IntegerSubtract\", \"semantifold_integer_subtract\"],\n  [\"IntegerMultiply\", \"semantifold_integer_multiply\"], [\"IntegerNegate\", \"semantifold_integer_negate\"],\n  [\"IntegerEqual\", \"==\"], [\"IntegerNotEqual\", \"!=\"], [\"IntegerLessThan\", \"<\"],\n  [\"IntegerLessThanOrEqual\", \"<=\"], [\"IntegerGreaterThan\", \">\"], [\"IntegerGreaterThanOrEqual\", \">=\"],\n  [\"BooleanEqual\", \"==\"], [\"BooleanNotEqual\", \"!=\"], [\"BooleanAnd\", \"and\"], [\"BooleanOr\", \"or\"], [\"BooleanNot\", \"!\"],\n  [\"StringConcat\", \"semantifold_string_concat\"], [\"StringEqual\", \"semantifold_string_equal\"],\n  [\"StringNotEqual\", \"semantifold_string_not_equal\"]\n])\n\n/** Consumes the complete qualified Zig CST and retains exact generated-shell constraints. */\nclass ZigReader {\n  /**\n   * Creates a reader over one complete parser snapshot.\n   * @param {string} filename - Logical source filename.\n   * @param {string} source - Exact Zig source text.\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<Expression, {node: CstNode, spelling: string}>} */\n    this.operations = new Map()\n    /** @type {Map<Statement, {node: CstNode, type: string}>} */\n    this.prints = new Map()\n    /** @type {Map<string, Scalar>} */\n    this.functions = new Map()\n    /** @type {Map<import(\"../semantic/types.js\").Parameter | import(\"../semantic/types.js\").LocalDeclaration, \"use\" | \"address\" | \"none\">} */\n    this.scaffolds = new Map()\n  }\n\n  /**\n   * Converts a parser node boundary to a semantic location.\n   * @param {CstNode} node - Parser node.\n   * @returns {import(\"../semantic/types.js\").SourceLocation} UTF-16 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 the exact source spelling owned by a parser node.\n   * @param {CstNode} node - Parser node.\n   * @returns {string} Node source text.\n   */\n  text(node) {\n    return this.source.slice(node.startIndex, node.endIndex)\n  }\n\n  /**\n   * Reads one generated line-comment marker independent of the source newline convention.\n   * @param {CstNode} node - Marker comment node.\n   * @returns {string} Marker spelling without a parser-owned trailing carriage return.\n   */\n  marker(node) {\n    return this.text(node).replace(/\\r$/u, \"\")\n  }\n\n  /**\n   * Raises a located unsupported-syntax diagnostic.\n   * @param {CstNode} node - Rejected parser node.\n   * @param {string} [detail] - Diagnostic detail.\n   * @returns {never} This function always throws.\n   */\n  fail(node, detail = node.type) {\n    unsupportedSyntax(\"zig\", detail, this.location(node))\n  }\n\n  /**\n   * Exhaustively rejects recovery, unexpected extras, directives, and excessive nesting.\n   * @param {CstNode} node - Current CST node.\n   * @param {number} [depth] - Current nesting depth.\n   */\n  validateTree(node, depth = 0) {\n    if (depth > 512) this.fail(node, \"Zig 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: \"zig\", location: this.location(node), message: `Zig 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\" && (/^\\s*\\/\\/[/!]/u.test(this.text(node)) || /^\\s*\\/\\/\\s*zig fmt:/u.test(this.text(node)))) {\n      this.fail(node, \"doc or formatter-directive comment\")\n    }\n  }\n\n  /**\n   * Returns every non-comment child without hiding syntax edges.\n   * @param {CstNode} node - Parent parser node.\n   * @returns {CstNode[]} Ordered non-comment children.\n   */\n  parts(node) {\n    return node.children.map(({node: child}) => child).filter(child => child.type != \"comment\")\n  }\n\n  /**\n   * Retains compiler-owned scaffold markers while ignoring ordinary inert comments.\n   * @param {CstNode} node - Parent parser node.\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:/u.test(this.text(child)))\n  }\n\n  /**\n   * Requires exactly one parser field edge.\n   * @param {CstNode} node - Parent parser node.\n   * @param {string} name - Required field name.\n   * @returns {CstNode} Field child.\n   */\n  field(node, name) {\n    const edges = node.children.filter(({field}) => field == name)\n\n    if (edges.length != 1) this.fail(node, `expected one '${name}' field`)\n    return edges[0].node\n  }\n\n  /**\n   * Requires an exact ordered child/token shape.\n   * @param {CstNode} node - Parser node to check.\n   * @param {(CstNode | string)[]} expected - Expected node identities or token types.\n   */\n  shape(node, expected) {\n    const parts = this.parts(node)\n\n    if (parts.length != expected.length || parts.some((child, index) =>\n      typeof expected[index] == \"string\" ? child.type != expected[index] || !child.named && this.text(child) != expected[index] : child !== expected[index])) {\n      this.fail(node, `${node.type} child shape`)\n    }\n  }\n\n  /**\n   * Validates and returns one ordinary Zig identifier.\n   * @param {CstNode} node - Candidate identifier node.\n   * @returns {string} Validated identifier.\n   */\n  identifier(node) {\n    const name = this.text(node)\n\n    if (node.type != \"identifier\" || !isZigIdentifier(name)) this.fail(node, \"reserved or unsupported identifier\")\n    return name\n  }\n\n  /**\n   * Converts an exact source scalar annotation.\n   * @param {CstNode} node - Type node.\n   * @param {boolean} [allowVoid] - Whether void is valid here.\n   * @returns {import(\"../semantic/types.js\").SemanticFunctionReturnType} Semantic type.\n   */\n  type(node, allowVoid = false) {\n    const spelling = this.text(node)\n\n    if (allowVoid && node.type == \"builtin_type\" && spelling == \"void\") {\n      this.shape(node, [\"void\"])\n      return withParserRanges({kind: \"TypeReference\", name: \"void\"}, {type: this.location(node)})\n    }\n    if (node.type == \"builtin_type\" && [\"i64\", \"bool\"].includes(spelling)) {\n      if (spelling == \"bool\") this.shape(node, [\"bool\"])\n      else if (node.children.length) this.fail(node, \"scalar type shape\")\n    } else if (node.type == \"slice_type\" && spelling == \"[]const u8\") {\n      this.shape(node, [\"[\", \"]\", \"const\", this.parts(node)[3]])\n      const child = this.parts(node)[3]\n\n      if (child.type != \"builtin_type\" || this.text(child) != \"u8\" || child.children.length) this.fail(child, \"immutable UTF-8 slice element\")\n    } else return missingType(\"zig\", allowVoid ? \"function return\" : \"scalar\", this.location(node))\n    const type = sourceScalarType(\"zig\", spelling, this.location(node))\n\n    if (!type) return missingType(\"zig\", \"scalar\", this.location(node))\n    return type\n  }\n\n  /**\n   * Decomposes an exact direct call.\n   * @param {CstNode} node - Call expression node.\n   * @returns {{name: CstNode, arguments: CstNode[]}} Callee and ordered arguments.\n   */\n  call(node) {\n    if (node.type != \"call_expression\") this.fail(node, \"direct call required\")\n    const name = this.field(node, \"function\")\n    const parts = this.parts(node)\n    const argumentsAndCommas = parts.slice(2, -1)\n    const args = argumentsAndCommas.filter((_part, index) => index % 2 == 0)\n\n    this.shape(node, [name, \"(\", ...args.flatMap((argument, index) => index ? [\",\", argument] : [argument]), \")\"])\n    return {name, arguments: args}\n  }\n\n  /**\n   * Decodes one bounded ordinary Zig string literal.\n   * @param {CstNode} node - String node.\n   * @returns {string} Unicode scalar value.\n   */\n  string(node) {\n    if (node.type != \"string\") this.fail(node, \"ordinary UTF-8 string literal required\")\n    const parts = this.parts(node)\n\n    this.shape(node, ['\"', ...parts.slice(1, -1), '\"'])\n    let value = \"\"\n\n    for (const part of parts.slice(1, -1)) {\n      const spelling = this.text(part)\n\n      if (part.type == \"string_content\") {\n        if (/[\\r\\n]/u.test(spelling)) this.fail(part, \"raw string line terminator\")\n        value += spelling\n      } else if (part.type == \"escape_sequence\") {\n        const simple = new Map([[\"\\\\n\", \"\\n\"], [\"\\\\r\", \"\\r\"], [\"\\\\t\", \"\\t\"], [\"\\\\\\\\\", \"\\\\\"], ['\\\\\"', '\"']])\n\n        if (simple.has(spelling)) value += simple.get(spelling)\n        else if (/^\\\\x[0-9a-fA-F]{2}$/u.test(spelling)) {\n          const scalar = Number.parseInt(spelling.slice(2), 16)\n\n          if (scalar > 127) this.fail(part, \"non-ASCII byte escape\")\n          value += String.fromCodePoint(scalar)\n        } else if (/^\\\\u\\{[0-9a-fA-F]{1,6}\\}$/u.test(spelling)) {\n          const scalar = Number.parseInt(spelling.slice(3, -1), 16)\n\n          if (scalar > 0x10FFFF || scalar >= 0xD800 && scalar <= 0xDFFF) this.fail(part, \"non-scalar Unicode escape\")\n          value += String.fromCodePoint(scalar)\n        } else this.fail(part, \"unsupported string escape\")\n      } else this.fail(part, \"string child\")\n    }\n    if (!hasOnlyUnicodeScalars(value)) this.fail(node, \"non-scalar string value\")\n    return value\n  }\n\n  /**\n   * Converts one supported scalar expression.\n   * @param {CstNode} node - Expression node.\n   * @returns {Expression} Semantic expression.\n   */\n  expression(node) {\n    const location = this.location(node)\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])\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 == \"integer\") {\n      const spelling = this.text(node)\n      const value = Number(spelling)\n\n      if (!/^(?:0|[1-9][0-9]*)$/u.test(spelling) || !Number.isSafeInteger(value)) this.fail(node, \"non-safe or noncanonical i64 literal\")\n      return withParserRanges({kind: \"IntegerLiteral\", location, value}, {literal: location})\n    }\n    if (node.type == \"boolean\") {\n      const spelling = this.text(node)\n\n      if (spelling != \"true\" && spelling != \"false\") this.fail(node, \"Boolean literal spelling\")\n      this.shape(node, [spelling])\n      return withParserRanges({kind: \"BooleanLiteral\", location, value: spelling == \"true\"}, {literal: location})\n    }\n    if (node.type == \"string\") return withParserRanges({kind: \"StringLiteral\", location, value: this.string(node)}, {literal: location})\n    if (node.type == \"unary_expression\" || node.type == \"error_union_type\") {\n      const parts = this.parts(node)\n      const operator = node.type == \"unary_expression\" ? this.field(node, \"operator\") : parts[0]\n      const operand = node.type == \"unary_expression\" ? this.field(node, \"argument\") : this.field(node, \"ok\")\n\n      this.shape(node, [operator, operand])\n      if (operator.type != \"-\" && operator.type != \"!\") this.fail(operator, \"unary operator\")\n      return this.unary(node, operator.type == \"-\" ? \"Negate\" : \"Not\", this.expression(operand), operator)\n    }\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) this.fail(operator, \"unsupported binary operator\")\n      return this.binary(node, intent, this.expression(left), this.expression(right), operator)\n    }\n    if (node.type == \"call_expression\") {\n      const call = this.call(node)\n\n      if (call.name.type != \"identifier\") this.fail(call.name, \"direct function call required\")\n      const name = this.text(call.name)\n\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]), call.name)\n      }\n      const intent = helperOperations.get(name)\n\n      if (intent) {\n        if (call.arguments.length != 2) this.fail(node, \"operator helper arity\")\n        return this.binary(node, intent, this.expression(call.arguments[0]), this.expression(call.arguments[1]), call.name)\n      }\n      if (name.startsWith(\"semantifold_\")) this.fail(call.name, \"support helper outside its exact semantic role\")\n      const callee = this.identifier(call.name)\n\n      return withParserRanges({kind: \"CallExpression\", location, callee, arguments: call.arguments.map(argument => this.expression(argument))}, {callee: this.location(call.name)})\n    }\n    return this.fail(node)\n  }\n\n  /**\n   * Adapts one typed binary operator.\n   * @param {CstNode} node - Whole expression node.\n   * @param {string} intent - Shared operator intent.\n   * @param {Expression} left - Left operand.\n   * @param {Expression} right - Right operand.\n   * @param {CstNode} operator - Source operator occurrence.\n   * @returns {Expression} Adapted semantic expression.\n   */\n  binary(node, intent, left, right, operator) {\n    const expression = /** @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    this.operations.set(expression, {node: operator, spelling: this.text(operator)})\n    return expression\n  }\n\n  /**\n   * Adapts one typed unary operator.\n   * @param {CstNode} node - Whole expression node.\n   * @param {\"Negate\" | \"Not\"} intent - Shared operator intent.\n   * @param {Expression} operand - Converted operand.\n   * @param {CstNode} operator - Source operator occurrence.\n   * @returns {Expression} Adapted semantic expression.\n   */\n  unary(node, intent, operand, operator) {\n    const expression = /** @type {Expression} */ (withAdaptedOperation(withParserRanges({kind: \"UnaryExpression\", location: this.location(node), operand},\n      {operator: this.location(operator)}), intent))\n\n    this.operations.set(expression, {node: operator, spelling: this.text(operator)})\n    return expression\n  }\n\n  /**\n   * Converts one supported statement.\n   * @param {CstNode} node - Statement node.\n   * @returns {Statement} Semantic statement.\n   */\n  statement(node) {\n    const location = this.location(node)\n    const parts = this.parts(node)\n\n    if (node.type == \"variable_declaration\") {\n      if ([\"const\", \"var\"].includes(parts[0]?.type)) {\n        const typeNode = node.children.find(({field}) => field == \"type\")?.node\n\n        if (!typeNode) return missingType(\"zig\", \"local\", location)\n        const name = parts[1]\n        const value = parts[5]\n\n        this.shape(node, [parts[0], name, \":\", typeNode, \"=\", value, \";\"])\n        return withParserRanges({kind: \"LocalDeclaration\", location, name: this.identifier(name), type: /** @type {import(\"../semantic/types.js\").TypeReference} */ (this.type(typeNode)), mutable: parts[0].type == \"var\",\n          initializer: this.expression(value)}, {name: this.location(name), operator: this.location(parts[4])})\n      }\n      const targetNode = parts[0]\n      const value = parts[2]\n\n      this.shape(node, [targetNode, \"=\", value, \";\"])\n      const target = withParserRanges({kind: /** @type {const} */ (\"IdentifierExpression\"), location: this.location(targetNode), name: this.identifier(targetNode)}, {name: this.location(targetNode)})\n\n      return withParserRanges({kind: \"AssignmentStatement\", location, target, expression: this.expression(value)}, {operator: this.location(parts[1])})\n    }\n    if (node.type == \"if_statement\") return this.conditional(node)\n    if (node.type != \"expression_statement\") this.fail(node, \"explicit statement required\")\n    const expression = parts[0]\n\n    this.shape(node, [expression, \";\"])\n    if (expression.type == \"return_expression\") {\n      const returned = this.parts(expression)\n\n      if (returned.length == 1) {\n        this.shape(expression, [\"return\"])\n        return {kind: \"ReturnStatement\", location}\n      }\n      this.shape(expression, [\"return\", returned[1]])\n      return {kind: \"ReturnStatement\", location, expression: this.expression(returned[1])}\n    }\n    if (expression.type != \"call_expression\") this.fail(expression, \"direct void call statement required\")\n    const call = this.call(expression)\n    const name = this.text(call.name)\n\n    if (/^semantifold_print_(?:integer|boolean|string)$/u.test(name)) {\n      if (call.name.type != \"identifier\" || call.arguments.length != 1) this.fail(expression, \"exact print helper call required\")\n      const statement = {kind: /** @type {const} */ (\"PrintStatement\"), location, expression: this.expression(call.arguments[0])}\n\n      this.prints.set(statement, {node: call.name, type: name.slice(\"semantifold_print_\".length)})\n      return statement\n    }\n    const value = this.expression(expression)\n\n    if (value.kind != \"CallExpression\") this.fail(expression, \"direct void call statement required\")\n    return {kind: \"ExpressionStatement\", location, expression: value}\n  }\n\n  /**\n   * Converts one strict Boolean conditional.\n   * @param {CstNode} node - If-statement node.\n   * @returns {import(\"../semantic/types.js\").IfStatement} Semantic conditional.\n   */\n  conditional(node) {\n    const condition = this.field(node, \"condition\")\n    const body = this.field(node, \"body\")\n    const alternative = this.parts(node).find(child => child.type == \"else_clause\")\n\n    this.shape(node, [\"if\", \"(\", condition, \")\", body, ...(alternative ? [alternative] : [])])\n    const statement = {kind: /** @type {const} */ (\"IfStatement\"), location: this.location(node), condition: this.expression(condition), consequent: this.blockExpression(body)}\n\n    if (!alternative) return statement\n    const branch = this.field(alternative, \"alternative\")\n\n    this.shape(alternative, [\"else\", branch])\n    if (branch.type != \"labeled_statement\") this.fail(branch, \"braced else block required\")\n    const block = this.parts(branch)[0]\n\n    this.shape(branch, [block])\n    return {...statement, alternate: this.block(block)}\n  }\n\n  /**\n   * Unwraps one braced conditional block expression.\n   * @param {CstNode} node - Block-expression node.\n   * @returns {import(\"../semantic/types.js\").Block} Semantic block.\n   */\n  blockExpression(node) {\n    if (node.type != \"block_expression\") this.fail(node, \"braced conditional block required\")\n    const block = this.parts(node)[0]\n\n    this.shape(node, [block])\n    return this.block(block)\n  }\n\n  /**\n   * Converts one lexical block while consuming exact compiler scaffolds.\n   * @param {CstNode} node - Block node.\n   * @param {number} [skip] - Fixed leading generated statements to omit.\n   * @param {import(\"../semantic/types.js\").Parameter[]} [parameters] - Parameters requiring scaffold checks.\n   * @returns {import(\"../semantic/types.js\").Block} Semantic block.\n   */\n  block(node, skip = 0, parameters = []) {\n    if (node.type != \"block\") this.fail(node, \"braced block required\")\n    const parts = this.parts(node)\n\n    this.shape(node, [\"{\", ...parts.slice(1, -1), \"}\"])\n    const sourceStatements = this.significant(node).slice(1 + skip, -1)\n    return {kind: \"Block\", location: this.location(node), statements: this.generated\n      ? this.generatedStatements(sourceStatements, parameters)\n      : this.directStatements(sourceStatements, parameters)}\n  }\n\n  /**\n   * Converts the legacy direct statement shape when diagnosing a missing generated marker.\n   * @param {CstNode[]} sourceStatements - Ordered direct children.\n   * @param {import(\"../semantic/types.js\").Parameter[]} parameters - Function parameters.\n   * @returns {Statement[]} Semantic statements.\n   */\n  directStatements(sourceStatements, parameters) {\n    let cursor = 0\n\n    for (const parameter of parameters) {\n      const kind = sourceStatements[cursor] ? this.useScaffold(sourceStatements[cursor], parameter.name) : undefined\n\n      this.scaffolds.set(parameter, kind ?? \"none\")\n      if (kind) cursor += 1\n    }\n    /** @type {Statement[]} */\n    const statements = []\n\n    while (cursor < sourceStatements.length) {\n      const statement = this.statement(sourceStatements[cursor])\n\n      statements.push(statement)\n      cursor += 1\n      if (statement.kind == \"LocalDeclaration\") {\n        const kind = sourceStatements[cursor] ? this.useScaffold(sourceStatements[cursor], statement.name) : undefined\n\n        this.scaffolds.set(statement, kind ?? \"none\")\n        if (kind) cursor += 1\n      }\n    }\n    return statements\n  }\n\n  /**\n   * Reconstructs complete generated statement regions before canonical whole-CST verification.\n   * @param {CstNode[]} sourceStatements - Significant direct block children.\n   * @param {import(\"../semantic/types.js\").Parameter[]} parameters - Function parameters.\n   * @returns {Statement[]} Reconstructed semantic statements.\n   */\n  generatedStatements(sourceStatements, parameters) {\n    /** @type {Statement[]} */\n    const statements = []\n    let cursor = 0\n\n    for (const parameter of parameters) {\n      const kind = sourceStatements[cursor] ? this.useScaffold(sourceStatements[cursor], parameter.name) : undefined\n\n      this.scaffolds.set(parameter, kind ?? \"none\")\n      if (kind) cursor += 1\n    }\n    while (cursor < sourceStatements.length) {\n      const begin = sourceStatements[cursor++]\n      const match = begin.type == \"comment\" &&\n        /^\\/\\/ semantifold:ordered-expression:zig:v1 begin ([0-9]{6}) ([0-9a-f]{64})$/u.exec(this.marker(begin))\n\n      if (!match) this.fail(begin, \"complete generated ordered statement region required\")\n      const outerExpressions = this.temporaryExpressions\n      const outerNames = this.temporaryNames\n\n      this.temporaryExpressions = new Map()\n      this.temporaryNames = new Set()\n      while (cursor < sourceStatements.length && this.temporaryDeclaration(sourceStatements[cursor])) {\n        cursor = this.readTemporary(sourceStatements, cursor)\n      }\n      const consumer = sourceStatements[cursor++]\n\n      if (!consumer) this.fail(begin, \"missing generated ordered consumer\")\n      const statement = this.statement(consumer)\n\n      if (this.temporaryExpressions.size != 0) this.fail(consumer, \"unconsumed generated ordered temporary\")\n      if (statement.kind == \"LocalDeclaration\") {\n        const kind = sourceStatements[cursor] ? this.useScaffold(sourceStatements[cursor], statement.name) : undefined\n\n        this.scaffolds.set(statement, kind ?? \"none\")\n        if (kind) cursor += 1\n      }\n      const end = sourceStatements[cursor++]\n\n      if (!end || end.type != \"comment\" || this.marker(end) !=\n        `// semantifold:ordered-expression:zig:v1 end ${match[1]} ${match[2]}`) this.fail(end ?? begin, \"generated ordered marker pair\")\n      this.temporaryExpressions = outerExpressions\n      this.temporaryNames = outerNames\n      statements.push(statement)\n    }\n    return statements\n  }\n\n  /**\n   * Identifies a reserved ordered temporary declaration at the current region level.\n   * @param {CstNode} node - Candidate direct child.\n   * @returns {boolean} Whether it declares a reserved ordered temporary.\n   */\n  temporaryDeclaration(node) {\n    const parts = this.parts(node)\n\n    return node.type == \"variable_declaration\" && [\"const\", \"var\"].includes(parts[0]?.type) &&\n      parts[1]?.type == \"identifier\" && this.text(parts[1]).startsWith(\"semantifold_ordered_\")\n  }\n\n  /**\n   * Expands one typed ordered temporary and an optional conditional Boolean RHS.\n   * @param {CstNode[]} nodes - Current region children.\n   * @param {number} cursor - Temporary declaration position.\n   * @returns {number} Next unconsumed position.\n   */\n  readTemporary(nodes, cursor) {\n    const node = nodes[cursor++]\n    const parts = this.parts(node)\n    const nameNode = parts[1]\n    const name = this.text(nameNode)\n    const typeNode = this.field(node, \"type\")\n    const value = parts[5]\n\n    this.shape(node, [parts[0], nameNode, \":\", typeNode, \"=\", value, \";\"])\n    this.type(typeNode)\n    if (!/^semantifold_ordered_[0-9]{6}$/u.test(name) || this.temporaryNames?.has(name)) {\n      this.fail(nameNode, \"generated ordered temporary declaration\")\n    }\n    this.temporaryNames?.add(name)\n    let expression = this.expression(value)\n    const branch = nodes[cursor]\n\n    if (branch && this.shortCircuitBranch(branch, name)) {\n      const condition = this.field(branch, \"condition\")\n      const body = this.field(branch, \"body\")\n      const conditionParts = this.parts(condition)\n      const isOr = conditionParts[0]?.type == \"!\"\n      const target = isOr ? this.field(condition, condition.type == \"unary_expression\" ? \"argument\" : \"ok\") : condition\n\n      this.shape(branch, [\"if\", \"(\", condition, \")\", body])\n      if (target.type != \"identifier\" || this.text(target) != name) this.fail(target, \"generated short-circuit temporary test\")\n      if (isOr) this.shape(condition, [conditionParts[0], target])\n      if (isOr && conditionParts[0]?.type != \"!\") this.fail(conditionParts[0] ?? condition, \"generated short-circuit negation\")\n      if (body.type != \"block_expression\") this.fail(body, \"generated short-circuit block\")\n      const block = this.parts(body)[0]\n\n      this.shape(body, [block])\n      if (block.type != \"block\") this.fail(block, \"generated short-circuit block\")\n      const inside = this.significant(block).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(block, \"generated short-circuit final assignment\")\n      const assignment = inside[offset]\n      const assignmentParts = this.parts(assignment)\n      const left = assignmentParts[0]\n      const right = assignmentParts[2]\n\n      this.shape(assignment, [left, \"=\", right, \";\"])\n      if (left.type != \"identifier\" || this.text(left) != name) this.fail(left, \"generated short-circuit result write\")\n      if (right.type != \"binary_expression\") this.fail(right, \"generated short-circuit result expression\")\n      const repeated = this.field(right, \"left\")\n      const operand = this.field(right, \"right\")\n      const operator = this.field(right, \"operator\")\n      const spelling = isOr ? \"or\" : \"and\"\n\n      this.shape(right, [repeated, spelling, operand])\n      if (repeated.type != \"identifier\" || this.text(repeated) != name) this.fail(repeated, \"generated short-circuit consumed value\")\n      expression = this.binary(right, isOr ? \"Or\" : \"And\", expression, this.expression(operand), operator)\n      cursor += 1\n    }\n    this.temporaryExpressions?.set(name, expression)\n    return cursor\n  }\n\n  /**\n   * Distinguishes an internal conditional RHS from the following semantic `if` consumer using only direct CST structure.\n   * @param {CstNode} node - Candidate conditional.\n   * @param {string} name - Ordered Boolean result name.\n   * @returns {boolean} Whether the node has the complete outer shape of a short-circuit update.\n   */\n  shortCircuitBranch(node, name) {\n    if (node.type != \"if_statement\" || this.parts(node).some(child => child.type == \"else_clause\")) return false\n    const body = node.children.find(({field}) => field == \"body\")?.node\n\n    if (body?.type != \"block_expression\") return false\n    const block = this.parts(body)[0]\n\n    if (block?.type != \"block\") return false\n    const inside = this.significant(block).slice(1, -1)\n    const final = inside.at(-1)\n    const finalParts = final ? this.parts(final) : []\n\n    return inside.length > 0 && !inside.some(child => child.type == \"comment\") && final?.type == \"variable_declaration\" &&\n      finalParts[0]?.type == \"identifier\" && this.text(finalParts[0]) == name && finalParts[1]?.type == \"=\"\n  }\n\n  /**\n   * Recognizes one exact generated unused or unmutated binding scaffold.\n   * @param {CstNode} node - Candidate statement node.\n   * @param {string} name - Binding name.\n   * @returns {\"use\" | \"address\" | undefined} Scaffold form when matched.\n   */\n  useScaffold(node, name) {\n    const parts = this.parts(node)\n\n    if (node.type != \"variable_declaration\" || parts.length != 4 || parts[0].type != \"identifier\" || this.text(parts[0]) != \"_\" || parts[1].type != \"=\" || parts[3].type != \";\") return undefined\n    if (parts[2].type == \"identifier\" && this.text(parts[2]) == name) return \"use\"\n    if (parts[2].type == \"reference_expression\") {\n      const reference = this.parts(parts[2])\n\n      if (reference.length == 2 && reference[0].type == \"&\" && reference[1].type == \"identifier\" && this.text(reference[1]) == name) return \"address\"\n    }\n    return undefined\n  }\n\n  /**\n   * Converts one canonical top-level semantic function.\n   * @param {CstNode} node - Function declaration node.\n   * @returns {import(\"../semantic/types.js\").FunctionDeclaration} Semantic function.\n   */\n  function(node) {\n    const name = this.field(node, \"name\")\n    const parameters = this.parts(node).find(child => child.type == \"parameters\")\n    const returnType = this.field(node, \"type\")\n    const body = this.field(node, \"body\")\n\n    if (!parameters) this.fail(node, \"parameter list required\")\n    this.shape(node, [\"fn\", name, parameters, returnType, body])\n    const parameterParts = this.parts(parameters)\n    const declarations = parameterParts.slice(1, -1).filter((_part, index) => index % 2 == 0)\n\n    this.shape(parameters, [\"(\", ...declarations.flatMap((parameter, index) => index ? [\",\", parameter] : [parameter]), \")\"])\n    const converted = declarations.map(parameter => {\n      if (parameter.type != \"parameter\") this.fail(parameter, \"required typed parameter\")\n      const parameterName = this.field(parameter, \"name\")\n      const type = this.field(parameter, \"type\")\n\n      this.shape(parameter, [parameterName, \":\", type])\n      return withParserRanges({kind: /** @type {const} */ (\"Parameter\"), location: this.location(parameter), name: this.identifier(parameterName), type: /** @type {import(\"../semantic/types.js\").TypeReference} */ (this.type(type))}, {name: this.location(parameterName)})\n    })\n\n    return withParserRanges({kind: \"FunctionDeclaration\", location: this.location(node), name: this.identifier(name), parameters: converted,\n      returnType: this.type(returnType, true), body: this.block(body, 0, converted)}, {name: this.location(name)})\n  }\n\n  /**\n   * Compares every node, token, and field against canonical generated support.\n   * @param {CstNode} actual - Source subtree.\n   * @param {CstNode} expected - Canonical subtree.\n   * @param {ZigReader} canonical - Reader owning the canonical source.\n   */\n  compareTree(actual, expected, canonical) {\n    if (actual.type != expected.type || actual.named != expected.named || actual.extra != expected.extra) this.fail(actual, \"modified Zig support node\")\n    const left = this.significant(actual)\n    const right = canonical.significant(expected)\n\n    if (left.length != right.length) this.fail(actual, \"modified Zig support children\")\n    if (!left.length) {\n      const actualText = actual.type == \"comment\" && /semantifold:/u.test(this.text(actual)) ? this.marker(actual) : this.text(actual)\n      const expectedText = expected.type == \"comment\" && /semantifold:/u.test(canonical.text(expected)) ? canonical.marker(expected) : canonical.text(expected)\n\n      if (actualText != expectedText) this.fail(actual, \"modified Zig support token\")\n    }\n    left.forEach((child, index) => {\n      const expectedChild = right[index]\n\n      if (!expectedChild || actual.children.find(edge => edge.node === child)?.field != expected.children.find(edge => edge.node === expectedChild)?.field) {\n        this.fail(child, \"modified Zig support field\")\n      }\n      this.compareTree(child, expectedChild, canonical)\n    })\n  }\n\n  /**\n   * Resolves a validated expression's scalar result.\n   * @param {Expression} expression - Semantic expression.\n   * @param {Map<string, Scalar>} bindings - Visible binding types.\n   * @returns {Scalar} Scalar result name.\n   */\n  expressionType(expression, bindings) {\n    if (expression.kind == \"StringLiteral\") return \"string\"\n    if (expression.kind == \"IntegerLiteral\") return \"integer\"\n    if (expression.kind == \"BooleanLiteral\") return \"boolean\"\n    if (expression.kind == \"BinaryExpression\" || expression.kind == \"UnaryExpression\") return expression.type\n    if (expression.kind != \"CallExpression\" && expression.kind != \"IdentifierExpression\") throw new Error(\"Validated Zig source exposed a collection expression.\")\n    const type = expression.kind == \"CallExpression\" ? this.functions.get(expression.callee) : bindings.get(expression.name)\n\n    if (!type) throw new Error(\"Validated Zig expression lost its scalar binding.\")\n    return type\n  }\n\n  /**\n   * Requires each typed operation to retain the one exact Zig operator/helper spelling that implements it.\n   * @param {Expression} expression - Resolved scalar expression.\n   */\n  validateOperationExpression(expression) {\n    if (expression.kind == \"CallExpression\") {\n      expression.arguments.forEach(argument => this.validateOperationExpression(argument))\n      return\n    }\n    if (expression.kind == \"UnaryExpression\") {\n      const identity = this.operations.get(expression)\n      const expected = operationSpellings.get(expression.operation)\n\n      if (!identity) throw new Error(\"Resolved Zig unary operation lost its parser identity.\")\n      if (identity.spelling != expected) this.fail(identity.node, `exact ${expression.operation} Zig operator/helper required`)\n      this.validateOperationExpression(expression.operand)\n      return\n    }\n    if (expression.kind == \"BinaryExpression\") {\n      const identity = this.operations.get(expression)\n      const expected = operationSpellings.get(expression.operation)\n\n      if (!identity) throw new Error(\"Resolved Zig binary operation lost its parser identity.\")\n      if (identity.spelling != expected) this.fail(identity.node, `exact ${expression.operation} Zig operator/helper required`)\n      this.validateOperationExpression(expression.left)\n      this.validateOperationExpression(expression.right)\n    }\n  }\n\n  /**\n   * Validates operation identity throughout one lexical block.\n   * @param {import(\"../semantic/types.js\").Block} block - Block whose expressions must retain exact Zig identity.\n   */\n  validateOperations(block) {\n    for (const statement of block.statements) {\n      if (statement.kind == \"LocalDeclaration\") this.validateOperationExpression(statement.initializer)\n      else if (statement.kind == \"AssignmentStatement\" || statement.kind == \"ExpressionStatement\" || statement.kind == \"PrintStatement\") {\n        this.validateOperationExpression(statement.expression)\n      } else if (statement.kind == \"ReturnStatement\") {\n        if (statement.expression) this.validateOperationExpression(statement.expression)\n      } else if (statement.kind == \"IfStatement\") {\n        this.validateOperationExpression(statement.condition)\n        this.validateOperations(statement.consequent)\n        if (statement.alternate) this.validateOperations(statement.alternate)\n      }\n    }\n  }\n\n  /**\n   * Confirms each generated output helper matches its semantic operand.\n   * @param {import(\"../semantic/types.js\").Block} block - Block to inspect.\n   * @param {Map<string, Scalar>} inherited - Visible binding types.\n   */\n  validatePrints(block, inherited) {\n    const bindings = new Map(inherited)\n\n    for (const statement of block.statements) {\n      if (statement.kind == \"LocalDeclaration\") {\n        bindings.set(statement.name, /** @type {import(\"../semantic/types.js\").TypeReference} */ (statement.type).name)\n      } else if (statement.kind == \"PrintStatement\") {\n        const print = this.prints.get(statement)\n\n        if (!print || this.expressionType(statement.expression, bindings) != print.type) this.fail(print?.node ?? /** @type {CstNode} */ ({}), \"print helper scalar mismatch\")\n      } else if (statement.kind == \"IfStatement\") {\n        this.validatePrints(statement.consequent, bindings)\n        if (statement.alternate) this.validatePrints(statement.alternate, bindings)\n      }\n    }\n  }\n\n  /**\n   * Confirms all and only compiler-required binding scaffolds are present.\n   * @param {import(\"../semantic/types.js\").FunctionDeclaration | import(\"../semantic/types.js\").EntryPoint} owner - Function or entry owner.\n   */\n  validateScaffolds(owner) {\n    const usage = collectZigBindingUsage(owner.body)\n    const parameters = owner.kind == \"FunctionDeclaration\" ? owner.parameters : []\n\n    for (const parameter of parameters) {\n      const expected = usage.reads.has(parameter.name) ? \"none\" : \"use\"\n\n      if (this.scaffolds.get(parameter) != expected) unsupportedSyntax(\"zig\", `incorrect unused-parameter scaffold for '${parameter.name}'`, parameter.location)\n    }\n    /**\n     * Checks local scaffolds recursively.\n     * @param {import(\"../semantic/types.js\").Block} block - Block to inspect.\n     */\n    const visit = (block) => {\n      for (const statement of block.statements) {\n        if (statement.kind == \"LocalDeclaration\") {\n          const expected = statement.mutable && !usage.writes.has(statement.name) ? \"address\" :\n            !statement.mutable && !usage.reads.has(statement.name) ? \"use\" : \"none\"\n\n          if (this.scaffolds.get(statement) != expected) unsupportedSyntax(\"zig\", `incorrect local binding scaffold for '${statement.name}'`, statement.location)\n        } else if (statement.kind == \"IfStatement\") {\n          visit(statement.consequent)\n          if (statement.alternate) visit(statement.alternate)\n        }\n      }\n    }\n\n    visit(owner.body)\n  }\n\n  /**\n   * Converts a complete canonical Zig project entry.\n   * @param {CstNode} root - Source-file root.\n   * @returns {import(\"../semantic/types.js\").SemanticModule} Validated semantic module.\n   */\n  module(root) {\n    this.validateTree(root)\n    if (root.type != \"source_file\") this.fail(root, \"Zig source root required\")\n    const canonical = new ZigReader(this.filename, zigRuntime)\n    const support = canonical.significant(parseZigCst(zigRuntime).root)\n    const nodes = this.significant(root)\n\n    if (nodes.length < support.length + 2) this.fail(root, \"complete Zig runtime, ordered marker, and main shell required\")\n    support.forEach((expected, index) => this.compareTree(nodes[index], expected, canonical))\n    const programMarker = nodes[support.length]\n\n    if (programMarker.type != \"comment\" || this.marker(programMarker) != \"// semantifold:program:zig:v1\") {\n      this.fail(programMarker, \"exact generated Zig ordered-expression marker required\")\n    }\n    this.generated = true\n    const definitions = nodes.slice(support.length + 1)\n    /** @type {CstNode | undefined} */\n    let main\n    /** @type {CstNode[]} */\n    const functions = []\n\n    for (const node of definitions) {\n      if (node.type != \"function_declaration\") this.fail(node, \"top-level free functions only\")\n      const name = this.text(this.field(node, \"name\"))\n\n      if (name == \"main\") {\n        if (main) this.fail(node, \"duplicate main\")\n        main = node\n      } else {\n        if (main) this.fail(node, \"semantic function after main\")\n        functions.push(node)\n      }\n    }\n    if (!main) this.fail(root, \"canonical pub fn main() void required\")\n    const mainParts = this.parts(main)\n    const mainName = this.field(main, \"name\")\n    const parameters = mainParts.find(child => child.type == \"parameters\")\n    const returnType = this.field(main, \"type\")\n    const body = this.field(main, \"body\")\n\n    if (!parameters) this.fail(main, \"main parameters\")\n    this.shape(main, [\"pub\", \"fn\", mainName, parameters, returnType, body])\n    if (this.text(mainName) != \"main\") this.fail(mainName, \"main name\")\n    this.shape(parameters, [\"(\", \")\"])\n    this.type(returnType, true)\n    if (this.text(returnType) != \"void\") this.fail(returnType, \"main return type\")\n    const bodyParts = this.parts(body)\n    const deferNode = bodyParts[1]\n    const shellSource = \"pub fn main() void {\\n    defer semantifold_arena.deinit();\\n}\\n\"\n    const shellReader = new ZigReader(this.filename, shellSource)\n    const shellMain = shellReader.parts(parseZigCst(shellSource).root)[0]\n    const expectedDefer = shellReader.parts(shellReader.field(shellMain, \"body\"))[1]\n\n    if (!deferNode) this.fail(body, \"arena lifetime defer required\")\n    this.compareTree(deferNode, expectedDefer, shellReader)\n    const module = validateParsedModule({kind: \"Module\", location: this.location(root), functions: functions.map(node => this.function(node)),\n      entryPoint: {kind: \"EntryPoint\", location: this.location(main), body: this.block(body, 1)}}, \"zig\")\n\n    this.functions = new Map(module.functions.map(declaration => [declaration.name,\n      /** @type {import(\"../semantic/types.js\").TypeReference} */ (declaration.returnType).name]))\n    for (const declaration of module.functions) this.validateOperations(declaration.body)\n    this.validateOperations(module.entryPoint.body)\n    for (const declaration of module.functions) this.validatePrints(declaration.body, new Map(declaration.parameters.map(parameter => [parameter.name,\n      /** @type {import(\"../semantic/types.js\").TypeReference} */ (parameter.type).name])))\n    this.validatePrints(module.entryPoint.body, new Map())\n    for (const declaration of module.functions) this.validateScaffolds(declaration)\n    this.validateScaffolds(module.entryPoint)\n    const canonicalSource = generateZigProject({module}).artifacts[1]?.content\n\n    if (typeof canonicalSource != \"string\") throw new Error(\"Zig backend returned a nontext entry artifact.\")\n    this.compareTree(root, parseZigCst(canonicalSource).root, new ZigReader(this.filename, canonicalSource))\n    return module\n  }\n}\n\n/**\n * Parses only the qualified frozen Zig CST and rejects unsupported input before adaptation.\n * @param {{filename: string, source: string}} input - Exact source request.\n * @returns {import(\"../semantic/types.js\").SemanticModule} Zig semantic module.\n */\nexport function parseZig({filename, source}) {\n  const coordinates = createCoordinateIndex(source)\n  const location = {filename, start: indexedPointAt(coordinates, 0), end: indexedPointAt(coordinates, source.length)}\n\n  if (!hasOnlyUnicodeScalars(source)) {\n    const offset = source.search(/[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?<![\\uD800-\\uDBFF])[\\uDC00-\\uDFFF]/u)\n\n    throw new SemantifoldDiagnostic({code: \"PARSE_ERROR\", language: \"zig\", message: \"Zig source contains a lone UTF-16 surrogate.\",\n      location: {filename, start: indexedPointAt(coordinates, offset), end: indexedPointAt(coordinates, offset + 1)}})\n  }\n  if (source.length > maximumZigSourceLength) return unsupportedSyntax(\"zig\", \"source exceeds the 1000000 UTF-16 input limit\", location)\n  let snapshot\n\n  try {\n    snapshot = parseZigCst(source)\n  } catch (error) {\n    throw new SemantifoldDiagnostic({code: \"PARSE_ERROR\", language: \"zig\", location,\n      cause: error instanceof Error ? error : undefined, message: \"The qualified Zig parser could not produce a complete CST.\"})\n  }\n  const reader = new ZigReader(filename, source)\n\n  try {\n    return reader.module(snapshot.root)\n  } catch (error) {\n    if (reader.generated && error instanceof SemantifoldDiagnostic && error.language == \"zig\" &&\n      error.code != \"PARSE_ERROR\" && error.code != \"UNSUPPORTED_SYNTAX\") {\n      return unsupportedSyntax(\"zig\", `invalid generated ordered scaffold: ${error.code}`, error.location ?? location)\n    }\n    throw error\n  }\n}\n"]}