simple-graph-query 2.8.1 → 3.0.0

package/dist/simple-graph-query.bundle.js

@@ -48438,6 +48438,7 @@ module.exports = function whichTypedArray(value) {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.NameNotFoundError = exports.ForgeExprEvaluator = exports.SUPPORTED_BUILTINS = void 0;
 exports.areTupleArraysEqual = areTupleArraysEqual;
+exports.unquoteStringLiteral = unquoteStringLiteral;
 const AbstractParseTreeVisitor_1 = __webpack_require__(/*! antlr4ts/tree/AbstractParseTreeVisitor */ "./node_modules/antlr4ts/tree/AbstractParseTreeVisitor.js");
 const utils_1 = __webpack_require__(/*! ./forge-antlr/utils */ "./src/forge-antlr/utils.ts");
 const lodash_1 = __webpack_require__(/*! lodash */ "./node_modules/lodash/lodash.js");
@@ -48475,17 +48476,72 @@ function extractNumber(val) {
 function isString(value) {
     return typeof value === "string";
 }
-// Helper to create a string key from a tuple for fast lookup
+// Helper to create a string key from a tuple for fast lookup.
+//
+// The key is JSON.stringify because it is type-preserving: the atom 1 and the
+// atom "1" must not collide (buildRelationCache coerces numeric-looking atoms
+// to numbers). Measurement also showed V8's stringify outruns hand-rolled
+// delimiter keys, so there is nothing to gain from a custom key function.
 function tupleToKey(tuple) {
     return JSON.stringify(tuple);
 }
+// Canonical-key side-channel: relationKeys maps a RELATION VALUE (an outer
+// Tuple[] array) to its tuples' canonical keys, index-aligned. Keys are
+// computed at most once per relation value; set operations (union,
+// intersection, difference, dedup, subset) then reuse them instead of
+// re-serializing every tuple on every operation.
+//
+// This is keyed on the outer array -- NOT per tuple -- deliberately:
+//  * Relation values are immutable-after-creation in this evaluator (every
+//    operator returns a fresh array; nothing splices/pushes into a result it
+//    has handed out), so an array's keys can never go stale.
+//  * Live entries number in the dozens (base relations + recent
+//    intermediates), so GC ephemeron processing stays trivially cheap. A
+//    per-TUPLE WeakMap memo was measured to be catastrophically slower
+//    (100k+ high-churn entries make major GCs ~10x more expensive).
+//  * The WeakMap drops entries automatically when intermediate results die,
+//    so this adds no leak, and nothing user-visible is attached to tuples.
+const relationKeys = new WeakMap();
+// Only relation values at least this large get registered in relationKeys.
+// Tiny relations (e.g. the singleton sets compared thousands of times inside
+// quantifier loops) are cheaper to re-serialize than to churn through
+// WeakMap.set; the side-channel exists to amortize keying of BULK relations.
+const KEY_REGISTER_MIN = 16;
+// Get the canonical keys for a relation value, computing (and, for bulk
+// relations, registering) them on first use. First use costs one stringify
+// per tuple (exactly what a single set operation used to cost); every later
+// operation on the same registered relation value gets its keys for free.
+function ensureKeys(tuples) {
+    let keys = relationKeys.get(tuples);
+    if (keys === undefined) {
+        keys = tuples.map((t) => JSON.stringify(t));
+        if (tuples.length >= KEY_REGISTER_MIN) {
+            relationKeys.set(tuples, keys);
+        }
+    }
+    return keys;
+}
 function areTuplesEqual(a, b) {
     return a.length === b.length && a.every((val, i) => val === b[i]);
 }
 function isTupleArraySubset(a, b) {
+    // Tiny operands (e.g. the singleton comparisons quantifier loops make
+    // thousands of times) can never be registered in relationKeys, so the key
+    // side-channel is pure overhead for them -- compare directly, with the
+    // short-circuit the direct path allows.
+    if (a.length < KEY_REGISTER_MIN && b.length < KEY_REGISTER_MIN) {
+        const bSet = new Set(b.map(tupleToKey));
+        return a.every((tupleA) => bSet.has(tupleToKey(tupleA)));
+    }
     // Optimize using Set for O(n) lookup instead of O(n²)
-    const bSet = new Set(b.map(tupleToKey));
-    return a.every((tupleA) => bSet.has(tupleToKey(tupleA)));
+    const bSet = new Set(ensureKeys(b));
+    const aKeys = ensureKeys(a);
+    for (let i = 0; i < a.length; i++) {
+        if (!bSet.has(aKeys[i])) {
+            return false;
+        }
+    }
+    return true;
 }
 function areTupleArraysEqual(a, b) {
     if (a.length !== b.length) {
@@ -48493,19 +48549,38 @@ function areTupleArraysEqual(a, b) {
     }
     return isTupleArraySubset(a, b) && isTupleArraySubset(b, a);
 }
-function deduplicateTuples(tuples) {
-    // Optimize using Set for O(n) deduplication instead of O(n²)
+// Deduplicate the concatenation of several tuple arrays (set semantics),
+// reusing each part's registered keys when available and registering the
+// result's keys so downstream operations get them for free.
+function deduplicateConcat(parts) {
     const seen = new Set();
     const result = [];
-    for (const tuple of tuples) {
-        const key = tupleToKey(tuple);
-        if (!seen.has(key)) {
-            seen.add(key);
-            result.push(tuple);
-        }
+    const resultKeys = [];
+    for (const part of parts) {
+        // Bulk parts go through ensureKeys so their keys are REGISTERED, not just
+        // consumed -- otherwise a relation reaching dedup via union would be
+        // re-serialized on every union until some other op registered it.
+        // Arrays below KEY_REGISTER_MIN are never registered, so skip the WeakMap
+        // machinery for them entirely -- this helper is called once per join
+        // inside quantifier loops, where even the probe is measurable overhead.
+        const partKeys = part.length >= KEY_REGISTER_MIN ? ensureKeys(part) : undefined;
+        for (let i = 0; i < part.length; i++) {
+            const key = partKeys !== undefined ? partKeys[i] : JSON.stringify(part[i]);
+            if (!seen.has(key)) {
+                seen.add(key);
+                result.push(part[i]);
+                resultKeys.push(key);
+            }
+        }
+    }
+    if (result.length >= KEY_REGISTER_MIN) {
+        relationKeys.set(result, resultKeys);
     }
     return result;
 }
+function deduplicateTuples(tuples) {
+    return deduplicateConcat([tuples]);
+}
 function getCombinations(arrays) {
     // first, turn each string[][] into a string[] by flattening
     const valueSets = arrays.map((tuple) => tuple.flat());
@@ -48545,10 +48620,11 @@ function transitiveClosure(pairs) {
         graph.get(from).add(to);
     }
     // Use more efficient BFS with index-based queue to avoid O(n) shift() operations
-    // NOTE: we use Set<string> instead of Set<[SingleValue, SingleValue]> since
-    // TS would compute equality over the object's reference instead of the value
-    // when the value is an array
-    const transitiveClosureSet = new Set();
+    // NOTE: no dedup set is needed here -- within one `start`, the `visited`
+    // check guarantees each `current` is emitted at most once, and pairs from
+    // different starts differ in their first element. So we can emit real
+    // tuples directly instead of round-tripping through JSON.stringify/parse.
+    const result = [];
     for (const start of graph.keys()) {
         const visited = new Set();
         const queue = [...(graph.get(start) ?? [])];
@@ -48558,7 +48634,7 @@ function transitiveClosure(pairs) {
             if (visited.has(current))
                 continue;
             visited.add(current);
-            transitiveClosureSet.add(JSON.stringify([start, current]));
+            result.push([start, current]);
             const neighbors = graph.get(current);
             if (neighbors) {
                 for (const neighbor of neighbors) {
@@ -48569,8 +48645,7 @@ function transitiveClosure(pairs) {
             }
         }
     }
-    // convert the result back to a Tuple[] and return
-    return Array.from(transitiveClosureSet).map((pair) => JSON.parse(pair));
+    return result;
 }
 function bitwidthWraparound(value, bitwidth) {
     const modulus = Math.pow(2, bitwidth); // total number of Int values
@@ -48593,6 +48668,74 @@ const SUPPORTED_BINARY_BUILTINS = ["add", "subtract", "multiply", "divide", "rem
 const SUPPORTED_UNARY_BUILTINS = ["abs", "sign", "floor", "ceil"];
 const SUPPORTED_SET_BUILTINS = ["min", "max"];
 exports.SUPPORTED_BUILTINS = SUPPORTED_BINARY_BUILTINS.concat(SUPPORTED_UNARY_BUILTINS, SUPPORTED_SET_BUILTINS);
+/**
+ * Levenshtein distance, abandoned early once it provably exceeds `limit`.
+ * Returns `limit + 1` in that case, which callers treat as "too far".
+ */
+function editDistance(a, b, limit) {
+    if (Math.abs(a.length - b.length) > limit) {
+        return limit + 1;
+    }
+    let previous = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i++) {
+        const current = [i];
+        let rowMin = i;
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            const value = Math.min(previous[j] + 1, // deletion
+            current[j - 1] + 1, // insertion
+            previous[j - 1] + cost // substitution
+            );
+            current.push(value);
+            rowMin = Math.min(rowMin, value);
+        }
+        if (rowMin > limit) {
+            return limit + 1; // no completion of this row can come back under the limit
+        }
+        previous = current;
+    }
+    return previous[b.length];
+}
+/**
+ * Strip the surrounding double quotes from a STRING_TOK and resolve its escape
+ * sequences. The lexer rule is `'"' (~["\\] | '\\' .)* '"'`, so a backslash
+ * always consumes exactly one following character.
+ */
+function unquoteStringLiteral(text) {
+    const body = text.slice(1, -1);
+    // Overwhelmingly the common case, and the only one worth optimizing: with no
+    // backslash there is nothing to resolve, so skip the scan entirely.
+    if (body.indexOf("\\") === -1) {
+        return body;
+    }
+    let out = "";
+    for (let i = 0; i < body.length; i++) {
+        if (body[i] !== "\\") {
+            out += body[i];
+            continue;
+        }
+        const escaped = body[++i];
+        switch (escaped) {
+            case "n":
+                out += "\n";
+                break;
+            case "t":
+                out += "\t";
+                break;
+            case "r":
+                out += "\r";
+                break;
+            case "0":
+                out += "\0";
+                break;
+            // `\"`, `\\`, and anything else stand for the character itself.
+            default:
+                out += escaped;
+                break;
+        }
+    }
+    return out;
+}
 /**
  * A recursive evaluator for Forge expressions.
  * This visitor walks the parse tree and prints the type of operation encountered.
@@ -48608,11 +48751,77 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
         // Index for relations: Map<relationName, Map<firstElement, Tuple[]>>
         // This allows O(1) lookup for patterns like atom.field
         this.relationIndexCache = null;
+        // Diagnostics accumulated during the current evaluation, keyed by name so a
+        // name referenced many times (e.g. inside a comprehension body) reports once.
+        this.diagnostics = new Map();
         this.instanceData = datum;
         this.environmentStack = [];
         this.freeVariableFinder = new ForgeExprFreeVariableFinder_1.ForgeExprFreeVariableFinder(datum);
         this.freeVariables = new Map();
     }
+    /** Diagnostics recorded since the last `resetDiagnostics()`. */
+    getDiagnostics() {
+        return Array.from(this.diagnostics.values());
+    }
+    /** Clear diagnostics. Callers that reuse an evaluator must call this per evaluation. */
+    resetDiagnostics() {
+        this.diagnostics.clear();
+    }
+    /**
+     * Record a name that could not be resolved against this instance.
+     *
+     * This is deliberately a warning rather than an error. The instance format
+     * carries only populated types and relations, so a sig with no atoms in this
+     * instance is indistinguishable from a typo — and a sig can empty out between
+     * frames of the same trace. Failing hard would break working selectors at
+     * exactly the frames where a set happens to be empty.
+     */
+    reportUnresolvedName(name) {
+        if (this.diagnostics.has(name)) {
+            return;
+        }
+        const suggestion = this.suggestName(name);
+        this.diagnostics.set(name, {
+            kind: "unresolved-name",
+            severity: "warning",
+            name,
+            message: `'${name}' does not name a type, relation, or atom in this instance; ` +
+                `it evaluates to the empty set.` +
+                (suggestion ? ` Did you mean '${suggestion}'?` : "") +
+                ` If you meant the string "${name}", write it in double quotes.`,
+            ...(suggestion !== undefined ? { suggestion } : {}),
+        });
+    }
+    /** Closest name in this instance within a small edit distance, if any. */
+    suggestName(name) {
+        this.buildRelationCache();
+        const candidates = new Set();
+        for (const t of this.instanceData.getTypes()) {
+            candidates.add(t.id);
+        }
+        for (const relationName of this.relationCache.keys()) {
+            candidates.add(relationName);
+        }
+        for (const atom of this.instanceData.getAtoms()) {
+            candidates.add(atom.id);
+        }
+        // Allow one edit for short names, two for longer ones. Without this bound
+        // every unresolved name would get a nonsense suggestion.
+        const maxDistance = name.length <= 4 ? 1 : 2;
+        let best;
+        let bestDistance = maxDistance + 1;
+        for (const candidate of candidates) {
+            if (Math.abs(candidate.length - name.length) >= bestDistance) {
+                continue; // length alone rules it out
+            }
+            const distance = editDistance(name, candidate, bestDistance);
+            if (distance < bestDistance) {
+                bestDistance = distance;
+                best = candidate;
+            }
+        }
+        return best;
+    }
     // helper function to build relation cache and indexes
     buildRelationCache() {
         if (this.relationCache !== null) {
@@ -48622,10 +48831,18 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
         this.relationIndexCache = new Map();
         const relations = this.instanceData.getRelations();
         for (const relation of relations) {
-            let relationAtoms = relation.tuples.map((tuple) => tuple.atoms);
-            // Convert numeric and boolean strings to their actual types
-            relationAtoms = relationAtoms.map((tuple) => tuple.map((value) => this.isConvertibleToNumber(value) ? Number(value) : value));
-            relationAtoms = relationAtoms.map((tuple) => tuple.map((value) => this.isConvertibleToBoolean(value) ? this.convertToBoolean(value) : value));
+            // Convert numeric and boolean strings to their actual types, in a
+            // single pass (one fresh tuple array per tuple, not one per coercion).
+            // Numeric-vs-boolean order matches the old two-pass behavior: the two
+            // predicates are disjoint (Number("true") is NaN), so checking numeric
+            // first is equivalent.
+            const relationAtoms = relation.tuples.map((tuple) => tuple.atoms.map((value) => {
+                if (this.isConvertibleToNumber(value))
+                    return Number(value);
+                if (this.isConvertibleToBoolean(value))
+                    return this.convertToBoolean(value);
+                return value;
+            }));
             // Relation NAMES are not unique — only the qualified id (`Sig<:label`) is.
             // e.g. `open util/ordering[A]` and `open util/ordering[B]` both expose a field
             // named `Next` (`A/Ord<:Next` and `B/Ord<:Next`). A bare-name reference must
@@ -48694,8 +48911,8 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 return atom.label !== undefined ? atom.label : atom.id;
             }
         }
-        // Fallback: return the value itself
-        console.error(`No atom found for value: ${value}`);
+        // Not an atom id. This is the normal case for a string literal — the label
+        // of `"Black"` is just `Black` — so it is not worth reporting.
         return value;
     }
     // helper function to get the label as string (used for @: and @str: operators)
@@ -48818,11 +49035,16 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
         return deduplicateTuples(result);
     }
     // helper function
-    cacheResult(ctx, freeVarsKey, result) {
+    cacheResult(ctx, freeVarsKey, result, diagnosticsBefore) {
         if (!this.cachedResults.has(ctx)) {
             this.cachedResults.set(ctx, new Map());
         }
-        this.cachedResults.get(ctx).set(freeVarsKey, result);
+        // Diagnostics raised while evaluating this subtree are cached with the
+        // result. Without this, evaluating the same expression twice would report
+        // an unresolved name only the first time, because the second call is a
+        // cache hit and never reaches visitName.
+        const diagnostics = Array.from(this.diagnostics.values()).filter((d) => !diagnosticsBefore.has(d.name));
+        this.cachedResults.get(ctx).set(freeVarsKey, { result, diagnostics });
     }
     // helper function
     getIden() {
@@ -48945,11 +49167,20 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
         const freeVarsKey = this.constructFreeVariableKey(freeVarValues);
         // check in the cache
         if (foundAllVars && this.cachedResults.has(ctx)) {
-            if (this.cachedResults.get(ctx).has(freeVarsKey)) {
-                // cache hit!
-                return this.cachedResults.get(ctx).get(freeVarsKey);
+            const cached = this.cachedResults.get(ctx).get(freeVarsKey);
+            if (cached !== undefined) {
+                // cache hit! Replay the diagnostics this subtree produced, so a repeat
+                // evaluation reports the same warnings as the first one.
+                for (const diagnostic of cached.diagnostics) {
+                    if (!this.diagnostics.has(diagnostic.name)) {
+                        this.diagnostics.set(diagnostic.name, diagnostic);
+                    }
+                }
+                return cached.result;
             }
         }
+        // Snapshot so we can attribute newly-raised diagnostics to this subtree.
+        const diagnosticsBefore = new Set(this.diagnostics.keys());
         // cache miss! compute results and store the result in the cache before
         // returning. Store the result only for this context node (not for the
         // children) to manage the cache size
@@ -49024,13 +49255,22 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                     total += bodyNumber;
                 }
                 this.environmentStack.pop();
-                this.cacheResult(ctx, freeVarsKey, total);
+                this.cacheResult(ctx, freeVarsKey, total, diagnosticsBefore);
                 return total;
             }
-            // Try to optimize numeric comparisons
+            // Try to optimize numeric comparisons.
+            //
+            // The optimizer generates ONLY the bindings that satisfy the comparison
+            // and marks each as true (skipping body evaluation). That is sound for
+            // quantifiers whose result depends on the *satisfying* bindings --
+            // `some`/`no`/`one`/`two`/`lone` (which count them) -- but NOT for `all`,
+            // whose result depends on the existence of a *falsifying* binding. If we
+            // discard the falsifying bindings, `all` never sees a counterexample and
+            // returns `!foundFalse === true` unconditionally. So exclude `all`.
             let product;
             let useOptimizedPath = false;
-            if (!isDisjoint && varNames.length >= 2 && (0, NumericConstraintOptimizer_1.areAllNumericSets)(quantifiedSets)) {
+            const isAllQuantifier = ctx.quant().ALL_TOK() !== undefined;
+            if (!isDisjoint && !isAllQuantifier && varNames.length >= 2 && (0, NumericConstraintOptimizer_1.areAllNumericSets)(quantifiedSets)) {
                 // Try to detect and optimize numeric comparison patterns
                 const pattern = (0, NumericConstraintOptimizer_1.detectNumericComparisonPattern)(barExpr, varNames);
                 if (pattern && pattern.type !== 'none') {
@@ -49102,13 +49342,13 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 if (ctx.quant().ALL_TOK() && foundFalse) {
                     this.environmentStack.pop();
                     const value = false;
-                    this.cacheResult(ctx, freeVarsKey, value);
+                    this.cacheResult(ctx, freeVarsKey, value, diagnosticsBefore);
                     return value;
                 }
                 if (ctx.quant().NO_TOK() && foundTrue) {
                     this.environmentStack.pop();
                     const value = false;
-                    this.cacheResult(ctx, freeVarsKey, value);
+                    this.cacheResult(ctx, freeVarsKey, value, diagnosticsBefore);
                     return value;
                 }
                 if (ctx.quant().mult()) {
@@ -49116,25 +49356,25 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                     if (multExpr.LONE_TOK() && result.length > 1) {
                         this.environmentStack.pop();
                         const value = false;
-                        this.cacheResult(ctx, freeVarsKey, value);
+                        this.cacheResult(ctx, freeVarsKey, value, diagnosticsBefore);
                         return value;
                     }
                     if (multExpr.SOME_TOK() && foundTrue) {
                         this.environmentStack.pop();
                         const value = true;
-                        this.cacheResult(ctx, freeVarsKey, value);
+                        this.cacheResult(ctx, freeVarsKey, value, diagnosticsBefore);
                         return value;
                     }
                     if (multExpr.ONE_TOK() && result.length > 1) {
                         this.environmentStack.pop();
                         const value = false;
-                        this.cacheResult(ctx, freeVarsKey, value);
+                        this.cacheResult(ctx, freeVarsKey, value, diagnosticsBefore);
                         return value;
                     }
                     if (multExpr.TWO_TOK() && result.length > 2) {
                         this.environmentStack.pop();
                         const value = false;
-                        this.cacheResult(ctx, freeVarsKey, value);
+                        this.cacheResult(ctx, freeVarsKey, value, diagnosticsBefore);
                         return value;
                     }
                 }
@@ -49142,34 +49382,34 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
             this.environmentStack.pop();
             if (ctx.quant().ALL_TOK()) {
                 const value = !foundFalse;
-                this.cacheResult(ctx, freeVarsKey, value);
+                this.cacheResult(ctx, freeVarsKey, value, diagnosticsBefore);
                 return value;
             }
             else if (ctx.quant().NO_TOK()) {
                 const value = !foundTrue;
-                this.cacheResult(ctx, freeVarsKey, value);
+                this.cacheResult(ctx, freeVarsKey, value, diagnosticsBefore);
                 return value;
             }
             else if (ctx.quant().mult()) {
                 const multExpr = ctx.quant().mult();
                 if (multExpr.LONE_TOK()) {
                     const value = result.length <= 1;
-                    this.cacheResult(ctx, freeVarsKey, value);
+                    this.cacheResult(ctx, freeVarsKey, value, diagnosticsBefore);
                     return value;
                 }
                 else if (multExpr.SOME_TOK()) {
                     const value = foundTrue;
-                    this.cacheResult(ctx, freeVarsKey, value);
+                    this.cacheResult(ctx, freeVarsKey, value, diagnosticsBefore);
                     return value;
                 }
                 else if (multExpr.ONE_TOK()) {
                     const value = result.length === 1;
-                    this.cacheResult(ctx, freeVarsKey, value);
+                    this.cacheResult(ctx, freeVarsKey, value, diagnosticsBefore);
                     return value;
                 }
                 else if (multExpr.TWO_TOK()) {
                     const value = result.length === 2;
-                    this.cacheResult(ctx, freeVarsKey, value);
+                    this.cacheResult(ctx, freeVarsKey, value, diagnosticsBefore);
                     return value;
                 }
             }
@@ -49181,7 +49421,7 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
         //console.log('childrenResults in expr:', childrenResults);
         if (results === undefined) {
             //console.log('returning childrenResults in expr:', childrenResults);
-            this.cacheResult(ctx, freeVarsKey, childrenResults);
+            this.cacheResult(ctx, freeVarsKey, childrenResults, diagnosticsBefore);
             return childrenResults;
         }
         if (isSingleValue(results)) {
@@ -49194,7 +49434,7 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
             results = results.concat(childrenResults);
         }
         //console.log('results being returned in expr:', results);
-        this.cacheResult(ctx, freeVarsKey, results);
+        this.cacheResult(ctx, freeVarsKey, results, diagnosticsBefore);
         return results;
     }
     visitExpr1(ctx) {
@@ -49502,25 +49742,21 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                     break;
                 case "in":
                 case "ni": {
-                    let membershipResult;
-                    // this should be true if the left value is equal to the right value,
-                    // or a subset of it
-                    if (isTupleArray(leftChildValue) && isTupleArray(rightChildValue)) {
-                        if (areTupleArraysEqual(leftChildValue, rightChildValue)) {
-                            membershipResult = true;
-                        }
-                        else {
-                            // check if left is subset of right
-                            membershipResult = isTupleArraySubset(leftChildValue, rightChildValue);
-                        }
-                    }
-                    else if (isTupleArray(rightChildValue)) {
-                        membershipResult = rightChildValue.some((tuple) => tuple.length === 1 && tuple[0] === leftChildValue);
-                    }
-                    else {
-                        // left is a tuple array but right is a single value, so false
-                        membershipResult = false;
-                    }
+                    // In Alloy/Forge everything is a relation, and a scalar is just a
+                    // singleton set. Lift any scalar operand to a singleton tuple so `in`
+                    // is uniformly subset:
+                    //   a in b     ({a} ⊆ {b})  -> equality when both are scalars
+                    //   a in {..}  ({a} ⊆ set)  -> membership
+                    //   {..} in b  (set ⊆ {b})  -> subset of a singleton
+                    // isTupleArraySubset already returns true for equal sets and for an
+                    // empty left-hand set, so a single subset check covers every case.
+                    const leftSet = isSingleValue(leftChildValue)
+                        ? [[leftChildValue]]
+                        : leftChildValue;
+                    const rightSet = isSingleValue(rightChildValue)
+                        ? [[rightChildValue]]
+                        : rightChildValue;
+                    const membershipResult = isTupleArraySubset(leftSet, rightSet);
                     results = ctx.compareOp()?.text === "ni" ? !membershipResult : membershipResult;
                     break;
                 }
@@ -49550,20 +49786,34 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
         if (ctx.SET_TOK()) {
             return childrenResults;
         }
-        if (ctx.ONE_TOK()) {
-            return isTupleArray(childrenResults) && childrenResults.length === 1;
-        }
-        if (ctx.TWO_TOK()) {
-            return isTupleArray(childrenResults) && childrenResults.length === 2;
-        }
-        if (ctx.NO_TOK()) {
-            return isTupleArray(childrenResults) && childrenResults.length === 0;
-        }
-        if (ctx.SOME_TOK()) {
-            return isTupleArray(childrenResults) && childrenResults.length > 0;
-        }
-        if (ctx.LONE_TOK()) {
-            return isTupleArray(childrenResults) && childrenResults.length <= 1;
+        // For the multiplicity checks, a bare scalar (atom or int) is a singleton
+        // set of size 1. A boolean is not a set, so it gets size -1 and every
+        // multiplicity below is false (matching the previous behavior).
+        if (ctx.ONE_TOK() ||
+            ctx.TWO_TOK() ||
+            ctx.NO_TOK() ||
+            ctx.SOME_TOK() ||
+            ctx.LONE_TOK()) {
+            const setSize = isTupleArray(childrenResults)
+                ? childrenResults.length
+                : isString(childrenResults) || isNumber(childrenResults)
+                    ? 1
+                    : -1;
+            if (ctx.ONE_TOK()) {
+                return setSize === 1;
+            }
+            if (ctx.TWO_TOK()) {
+                return setSize === 2;
+            }
+            if (ctx.NO_TOK()) {
+                return setSize === 0;
+            }
+            if (ctx.SOME_TOK()) {
+                return setSize > 0;
+            }
+            if (ctx.LONE_TOK()) {
+                return setSize === 0 || setSize === 1;
+            }
         }
         return childrenResults;
     }
@@ -49574,6 +49824,10 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
             const rightChildValue = this.visit(ctx.expr10());
             // should only work if arities are the same
             if (isSingleValue(leftChildValue) && isSingleValue(rightChildValue)) {
+                // Union has set semantics: two equal scalars collapse to one element.
+                if (leftChildValue === rightChildValue) {
+                    return [[leftChildValue]];
+                }
                 return [[leftChildValue], [rightChildValue]];
             }
             else if (isSingleValue(leftChildValue) && isTupleArray(rightChildValue)) {
@@ -49581,7 +49835,7 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                     return leftChildValue;
                 }
                 if (rightChildValue[0].length === 1) {
-                    return deduplicateTuples([[leftChildValue], ...rightChildValue]);
+                    return deduplicateConcat([[[leftChildValue]], rightChildValue]);
                 }
                 throw new Error("arity mismatch in set union!");
             }
@@ -49590,7 +49844,7 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                     return rightChildValue;
                 }
                 if (leftChildValue[0].length === 1) {
-                    return deduplicateTuples([...leftChildValue, [rightChildValue]]);
+                    return deduplicateConcat([leftChildValue, [[rightChildValue]]]);
                 }
                 throw new Error("arity mismatch in set union!");
             }
@@ -49605,7 +49859,7 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                     return leftChildValue;
                 }
                 if (leftChildValue[0].length === rightChildValue[0].length) {
-                    return deduplicateTuples([...leftChildValue, ...rightChildValue]);
+                    return deduplicateConcat([leftChildValue, rightChildValue]);
                 }
             }
             else {
@@ -49651,9 +49905,22 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                     return leftChildValue;
                 }
                 if (leftChildValue[0].length === rightChildValue[0].length) {
-                    // Optimize set difference using Set for O(n+m) instead of O(n*m)
-                    const rightSet = new Set(rightChildValue.map(tupleToKey));
-                    return leftChildValue.filter(tuple => !rightSet.has(tupleToKey(tuple)));
+                    // Optimize set difference using Set for O(n+m) instead of O(n*m),
+                    // reusing canonical keys instead of re-serializing each side.
+                    const rightSet = new Set(ensureKeys(rightChildValue));
+                    const leftKeys = ensureKeys(leftChildValue);
+                    const result = [];
+                    const resultKeys = [];
+                    for (let i = 0; i < leftChildValue.length; i++) {
+                        if (!rightSet.has(leftKeys[i])) {
+                            result.push(leftChildValue[i]);
+                            resultKeys.push(leftKeys[i]);
+                        }
+                    }
+                    if (result.length >= KEY_REGISTER_MIN) {
+                        relationKeys.set(result, resultKeys);
+                    }
+                    return result;
                 }
             }
             else {
@@ -49667,10 +49934,15 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
         const childrenResults = this.visitChildren(ctx);
         //console.log('childrenResults in expr9:', childrenResults);
         if (ctx.CARD_TOK()) {
-            if (!isTupleArray(childrenResults)) {
-                throw new Error("The cardinal operator must be applied to a set of tuples!");
+            if (isTupleArray(childrenResults)) {
+                return childrenResults.length;
+            }
+            // A scalar atom or int is a singleton set (cardinality 1). Booleans are
+            // formulas, not sets, so they remain an error.
+            if (isString(childrenResults) || isNumber(childrenResults)) {
+                return 1;
             }
-            return childrenResults.length;
+            throw new Error("The cardinal operator must be applied to a set of tuples!");
         }
         return childrenResults;
     }
@@ -49726,9 +49998,22 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                     return [];
                 }
                 if (leftChildValue[0].length === rightChildValue[0].length) {
-                    // Optimize set intersection using Set for O(n+m) instead of O(n*m)
-                    const rightSet = new Set(rightChildValue.map(tupleToKey));
-                    return leftChildValue.filter(tuple => rightSet.has(tupleToKey(tuple)));
+                    // Optimize set intersection using Set for O(n+m) instead of O(n*m),
+                    // reusing canonical keys instead of re-serializing each side.
+                    const rightSet = new Set(ensureKeys(rightChildValue));
+                    const leftKeys = ensureKeys(leftChildValue);
+                    const result = [];
+                    const resultKeys = [];
+                    for (let i = 0; i < leftChildValue.length; i++) {
+                        if (rightSet.has(leftKeys[i])) {
+                            result.push(leftChildValue[i]);
+                            resultKeys.push(leftKeys[i]);
+                        }
+                    }
+                    if (result.length >= KEY_REGISTER_MIN) {
+                        relationKeys.set(result, resultKeys);
+                    }
+                    return result;
                 }
             }
             else {
@@ -49889,63 +50174,36 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
             else {
                 throw new Error("Unknown label operator");
             }
-            try {
-                const innerResult = this.visit(innerExpr);
-                // Special case: if result is empty array, it means unknown identifier, so use the text
-                if (isTupleArray(innerResult) && innerResult.length === 0) {
-                    // For unknown identifiers, try to convert the text directly
-                    let text = innerExpr.text;
-                    // Remove parentheses if present
-                    if (text.startsWith('(') && text.endsWith(')')) {
-                        text = text.slice(1, -1);
-                    }
-                    try {
-                        return convertFunction(text);
-                    }
-                    catch (error) {
-                        // If conversion fails, fall back to string for unknown identifiers
-                        return text;
-                    }
-                }
-                if (isSingleValue(innerResult)) {
-                    return convertFunction(innerResult);
-                }
-                else if (isTupleArray(innerResult)) {
-                    // For single-element tuple arrays, return the converted label of the element
-                    if (innerResult.length === 1 && innerResult[0].length === 1) {
-                        return convertFunction(innerResult[0][0]);
-                    }
-                    // For multi-element cases, apply conversion to each tuple element
-                    return innerResult.map((tuple) => tuple.map((value) => convertFunction(value)));
-                }
-                throw new Error(`${operatorName} operator can only be applied to single values or tuple arrays`);
-            }
-            catch (error) {
-                // If evaluation fails due to unknown identifier, use the text as the label
-                if (error instanceof NameNotFoundError) {
-                    // Extract the identifier from the inner expression
-                    let identifierText = innerExpr.text;
-                    if (identifierText.startsWith('(') && identifierText.endsWith(')')) {
-                        identifierText = identifierText.slice(1, -1);
-                    }
-                    try {
-                        return convertFunction(identifierText);
-                    }
-                    catch (conversionError) {
-                        // If conversion fails, fall back to string for unknown identifiers
-                        return identifierText;
-                    }
+            const innerResult = this.visit(innerExpr);
+            if (isSingleValue(innerResult)) {
+                return convertFunction(innerResult);
+            }
+            else if (isTupleArray(innerResult)) {
+                // For single-element tuple arrays, return the converted label of the element
+                if (innerResult.length === 1 && innerResult[0].length === 1) {
+                    return convertFunction(innerResult[0][0]);
                 }
-                throw error;
+                // Otherwise convert elementwise. An empty operand yields an empty
+                // result — the operand evaluated fine, it just denotes nothing.
+                return innerResult.map((tuple) => tuple.map((value) => convertFunction(value)));
             }
+            throw new Error(`${operatorName} operator can only be applied to single values or tuple arrays`);
         }
         const childrenResults = this.visitChildren(ctx);
         //console.log('visitChildren result for', ctx.text, ':', childrenResults);
         if (ctx.TILDE_TOK()) {
             // this flips the order of the elements in the tuples of a relation if
             // the relation has arity 2
-            if (isTupleArray(childrenResults) && childrenResults.length > 0 && childrenResults[0].length === 2) {
-                return childrenResults.map((tuple) => [tuple[1], tuple[0]]);
+            if (isTupleArray(childrenResults)) {
+                // The transpose of the empty relation is the empty relation. Guarding
+                // only on `length > 0` made `~<empty>` throw (e.g. `~(left - left)`),
+                // even though `^`/`*` handle the empty relation fine.
+                if (childrenResults.length === 0) {
+                    return [];
+                }
+                if (childrenResults[0].length === 2) {
+                    return childrenResults.map((tuple) => [tuple[1], tuple[0]]);
+                }
             }
             throw new Error("expected the expression provided to ~ to have arity 2; bad arity received!");
         }
@@ -49959,15 +50217,9 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
             if (isTupleArray(childrenResults)) {
                 const transitiveClosureResult = transitiveClosure(childrenResults);
                 const idenResult = this.getIden();
-                // Optimize: Use Set for efficient deduplication instead of deduplicateTuples
-                const resultSet = new Set();
-                for (const tuple of idenResult) {
-                    resultSet.add(tupleToKey(tuple));
-                }
-                for (const tuple of transitiveClosureResult) {
-                    resultSet.add(tupleToKey(tuple));
-                }
-                return Array.from(resultSet).map(key => JSON.parse(key));
+                // Dedup while preserving the original tuple objects (and their
+                // memoized keys) -- avoids re-materializing every tuple via JSON.parse.
+                return deduplicateTuples(idenResult.concat(transitiveClosureResult));
             }
         }
         return childrenResults;
@@ -50041,6 +50293,14 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 // }
                 return value;
             }
+            // Handle none (the empty relation). Without this, `none` falls through to
+            // the string-literal branch below and evaluates to the string "none",
+            // which then pollutes every set operation it touches (e.g.
+            // `S + none` gains a spurious `["none"]` element and `#none` throws).
+            // The static analyzer already treats `none` as the empty set.
+            if (constant.NONE_TOK() !== undefined) {
+                return [];
+            }
             // Handle iden (identity relation)
             if (constant.IDEN_TOK() !== undefined) {
                 // The identity relation contains tuples (x, x) for every atom x in the universe
@@ -50077,6 +50337,12 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
                 }
                 return univRelation;
             }
+            // A double-quoted string literal. This is the ONLY way to write a string,
+            // so `"Black"` is a string regardless of whether the instance happens to
+            // contain a sig or atom named Black.
+            if (constant.STRING_TOK() !== undefined) {
+                return unquoteStringLiteral(constant.STRING_TOK().text);
+            }
             // Handle boolean constants
             if (constant.text === 'true') {
                 return true;
@@ -50323,15 +50589,15 @@ class ForgeExprEvaluator extends AbstractParseTreeVisitor_1.AbstractParseTreeVis
         if (exports.SUPPORTED_BUILTINS.includes(identifier)) {
             return identifier;
         }
-        // Check if this looks like a label identifier (for label comparison).
-        // Labels can be any alphanumeric string with underscores.
-        // This allows identifiers like "Black", "red", "my_label", "Color_123", etc.
-        // to be treated as string literals in label comparisons (e.g., @:y = Black).
-        const labelLikePattern = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
-        if (labelLikePattern.test(identifier)) {
-            return identifier;
-        }
-        throw new NameNotFoundError(`bad name ${identifier} referenced!`);
+        // Nothing in this instance answers to this name. Report it and evaluate to
+        // the empty relation rather than throwing: a selector is authored against a
+        // model but run against instances that vary, and a sig that is empty in this
+        // instance is absent from the instance data entirely. See
+        // `reportUnresolvedName`.
+        //
+        // Note this is NOT how string literals are written — use `"..."`.
+        this.reportUnresolvedName(identifier);
+        return [];
     }
     visitQualName(ctx) {
         // NOTE: this currently only supports Int; doesn't support other branches
@@ -50872,6 +51138,7 @@ exports.ForgeExprStaticAnalyzer = void 0;
 const AbstractParseTreeVisitor_1 = __webpack_require__(/*! antlr4ts/tree/AbstractParseTreeVisitor */ "./node_modules/antlr4ts/tree/AbstractParseTreeVisitor.js");
 const ForgeParser_1 = __webpack_require__(/*! ./forge-antlr/ForgeParser */ "./src/forge-antlr/ForgeParser.ts");
 const utils_1 = __webpack_require__(/*! ./forge-antlr/utils */ "./src/forge-antlr/utils.ts");
+const ForgeExprEvaluator_1 = __webpack_require__(/*! ./ForgeExprEvaluator */ "./src/ForgeExprEvaluator.ts");
 const UNKNOWN = { kind: "unknown" };
 // Helper that wraps the schema with O(1) lookups and lattice queries.
 class SchemaInfo {
@@ -51004,9 +51271,28 @@ function negationOperandText(ctx) {
 class ForgeExprStaticAnalyzer extends AbstractParseTreeVisitor_1.AbstractParseTreeVisitor {
     constructor(schema) {
         super();
+        // Variables bound by enclosing quantifiers / comprehensions. Consulted only
+        // for unresolved-name reporting, so a binder variable is not mistaken for a
+        // missing schema entity.
+        this.boundScopes = [];
+        // Names that resolve to nothing in the schema, in first-seen order.
+        this.unresolved = new Set();
         if (schema)
             this.schema = new SchemaInfo(schema);
     }
+    isBound(name) {
+        return this.boundScopes.some((scope) => scope.has(name));
+    }
+    /** Run `body` with `names` treated as bound. */
+    withBoundScope(names, body) {
+        this.boundScopes.push(names);
+        try {
+            return body();
+        }
+        finally {
+            this.boundScopes.pop();
+        }
+    }
     // Walk a nameList (`a, b, c`) and accumulate identifiers into `out`.
     collectNamesFromList(ctx, out) {
         out.add((0, utils_1.getIdentifierName)(ctx.name()));
@@ -51040,19 +51326,28 @@ class ForgeExprStaticAnalyzer extends AbstractParseTreeVisitor_1.AbstractParseTr
     }
     // Public entry: convert internal lattice value to a verdict + reason.
     analyze(ctx) {
+        this.unresolved.clear();
+        this.boundScopes.length = 0;
         const v = this.visit(ctx);
+        // Collected separately from the fold, which short-circuits. See
+        // `collectUnresolvedNames`.
+        this.boundScopes.length = 0;
+        this.collectUnresolvedNames(ctx);
+        const names = this.unresolved.size > 0
+            ? { unresolvedNames: Array.from(this.unresolved) }
+            : {};
         if (v.kind === "bool") {
             return v.value
-                ? { status: "tautology", reason: "expression folds to literal true" }
-                : { status: "unsat", reason: "expression folds to literal false" };
+                ? { status: "tautology", reason: "expression folds to literal true", ...names }
+                : { status: "unsat", reason: "expression folds to literal false", ...names };
         }
         if (v.kind === "empty") {
-            return { status: "empty", reason: "expression is provably the empty set" };
+            return { status: "empty", reason: "expression is provably the empty set", ...names };
         }
         if (v.kind === "ill-typed") {
-            return { status: "ill-typed", reason: v.reason };
+            return { status: "ill-typed", reason: v.reason, ...names };
         }
-        return { status: "unknown" };
+        return { status: "unknown", ...names };
     }
     // Arity of an Abstract when known; -1 means "not determinable".
     static arityOf(v) {
@@ -51110,8 +51405,8 @@ class ForgeExprStaticAnalyzer extends AbstractParseTreeVisitor_1.AbstractParseTr
         // Reserved-name check at the binder: under a schema, type/relation names
         // cannot be reused as quantified variables.
         const declListTop = ctx.quantDeclList();
+        const boundHere = new Set();
         if (declListTop) {
-            const boundHere = new Set();
             this.collectBoundNames(declListTop, boundHere);
             const reservedError = this.illTypedIfBindsReservedName(boundHere);
             if (reservedError)
@@ -51138,7 +51433,7 @@ class ForgeExprStaticAnalyzer extends AbstractParseTreeVisitor_1.AbstractParseTr
         // and would need the binding to be meaningful).
         let body = UNKNOWN;
         if (blockOrBar.BAR_TOK() && blockOrBar.expr()) {
-            body = this.visit(blockOrBar.expr());
+            body = this.withBoundScope(boundHere, () => this.visit(blockOrBar.expr()));
         }
         const mult = quant.mult();
         const isAll = quant.ALL_TOK() !== undefined;
@@ -51781,7 +52076,7 @@ class ForgeExprStaticAnalyzer extends AbstractParseTreeVisitor_1.AbstractParseTr
                 return reservedError;
             const blockOrBar = ctx.blockOrBar();
             if (blockOrBar && blockOrBar.BAR_TOK() && blockOrBar.expr()) {
-                const body = this.visit(blockOrBar.expr());
+                const body = this.withBoundScope(boundHere, () => this.visit(blockOrBar.expr()));
                 if (body.kind === "ill-typed")
                     return body;
                 if (body.kind === "bool" && !body.value)
@@ -51828,10 +52123,75 @@ class ForgeExprStaticAnalyzer extends AbstractParseTreeVisitor_1.AbstractParseTr
                         ? { kind: "typed", arity, columnTypes: cols }
                         : { kind: "typed", arity };
                 }
+                return UNKNOWN;
             }
         }
         return UNKNOWN;
     }
+    // ---------------------------------------------------------------------
+    // Unresolved-name collection
+    //
+    // This is a separate traversal rather than a side effect of the folding
+    // visitor above. Folding short-circuits — it returns as soon as one child
+    // settles the verdict — so names in the subtrees it skipped would never be
+    // seen. `{x : none, y : Playr | Foo = Foo}` folds to `empty` at the first
+    // decl and never looks at `Playr` or `Foo`. Reporting has to be complete
+    // regardless of how quickly the verdict is decided.
+    // ---------------------------------------------------------------------
+    /** Walk the whole tree, recording every name the schema does not declare. */
+    collectUnresolvedNames(node) {
+        if (!this.schema)
+            return;
+        if (node instanceof ForgeParser_1.NameContext) {
+            this.recordIfUnresolved((0, utils_1.getIdentifierName)(node));
+            return;
+        }
+        // A binder scopes its variables over the body but not over the domains it
+        // binds them from, and its declared names are binding occurrences rather
+        // than references — so neither is walked generically.
+        const binder = this.asBinder(node);
+        if (binder) {
+            const bound = new Set();
+            let decl = binder.declList;
+            while (decl) {
+                this.collectUnresolvedNames(decl.quantDecl().expr());
+                this.collectNamesFromList(decl.quantDecl().nameList(), bound);
+                decl = decl.quantDeclList();
+            }
+            if (binder.body) {
+                this.withBoundScope(bound, () => this.collectUnresolvedNames(binder.body));
+            }
+            return;
+        }
+        for (let i = 0; i < node.childCount; i++) {
+            this.collectUnresolvedNames(node.getChild(i));
+        }
+    }
+    /** The binder parts of a quantifier or set comprehension, if this node is one. */
+    asBinder(node) {
+        const isQuantifier = node instanceof ForgeParser_1.ExprContext && node.quant() !== undefined;
+        const isComprehension = node instanceof ForgeParser_1.Expr18Context && node.LEFT_CURLY_TOK() !== undefined;
+        if (!isQuantifier && !isComprehension)
+            return undefined;
+        const ctx = node;
+        const declList = ctx.quantDeclList();
+        if (!declList)
+            return undefined;
+        return { declList, body: ctx.blockOrBar() };
+    }
+    recordIfUnresolved(id) {
+        if (id === "true" || id === "false")
+            return;
+        if (this.isBound(id) || ForgeExprEvaluator_1.SUPPORTED_BUILTINS.includes(id))
+            return;
+        // Nothing in the schema answers to this name. Unlike the evaluator — which
+        // sees one instance and cannot tell a typo from a sig that is empty in this
+        // frame — a schema lists every declared entity, so this really is a name
+        // that does not exist.
+        if (this.schema.getType(id) || this.schema.getRelations(id).length > 0)
+            return;
+        this.unresolved.add(id);
+    }
 }
 exports.ForgeExprStaticAnalyzer = ForgeExprStaticAnalyzer;
 
@@ -52722,7 +53082,7 @@ ForgeLexer.OPEN_TOK = 1;
 ForgeLexer.LEFT_SQUARE_TOK = 2;
 ForgeLexer.RIGHT_SQUARE_TOK = 3;
 ForgeLexer.AS_TOK = 4;
-ForgeLexer.FILE_PATH_TOK = 5;
+ForgeLexer.STRING_TOK = 5;
 ForgeLexer.VAR_TOK = 6;
 ForgeLexer.ABSTRACT_TOK = 7;
 ForgeLexer.SIG_TOK = 8;
@@ -52841,7 +53201,7 @@ ForgeLexer.modeNames = [
     "DEFAULT_MODE",
 ];
 ForgeLexer.ruleNames = [
-    "OPEN_TOK", "LEFT_SQUARE_TOK", "RIGHT_SQUARE_TOK", "AS_TOK", "FILE_PATH_TOK",
+    "OPEN_TOK", "LEFT_SQUARE_TOK", "RIGHT_SQUARE_TOK", "AS_TOK", "STRING_TOK",
     "VAR_TOK", "ABSTRACT_TOK", "SIG_TOK", "LEFT_CURLY_TOK", "RIGHT_CURLY_TOK",
     "EXTENDS_TOK", "IN_TOK", "PLUS_TOK", "LONE_TOK", "SOME_TOK", "ONE_TOK",
     "TWO_TOK", "SET_TOK", "FUNC_TOK", "PFUNC_TOK", "DISJ_TOK", "COLON_TOK",
@@ -52881,7 +53241,7 @@ ForgeLexer._LITERAL_NAMES = [
 ];
 ForgeLexer._SYMBOLIC_NAMES = [
     undefined, "OPEN_TOK", "LEFT_SQUARE_TOK", "RIGHT_SQUARE_TOK", "AS_TOK",
-    "FILE_PATH_TOK", "VAR_TOK", "ABSTRACT_TOK", "SIG_TOK", "LEFT_CURLY_TOK",
+    "STRING_TOK", "VAR_TOK", "ABSTRACT_TOK", "SIG_TOK", "LEFT_CURLY_TOK",
     "RIGHT_CURLY_TOK", "EXTENDS_TOK", "IN_TOK", "PLUS_TOK", "LONE_TOK", "SOME_TOK",
     "ONE_TOK", "TWO_TOK", "SET_TOK", "FUNC_TOK", "PFUNC_TOK", "DISJ_TOK",
     "COLON_TOK", "WHEAT_TOK", "PRED_TOK", "DOT_TOK", "FUN_TOK", "LEFT_PAREN_TOK",
@@ -53894,7 +54254,7 @@ class ForgeParser extends Parser_1.Parser {
                         this.state = 220;
                         this.match(ForgeParser.OPEN_TOK);
                         this.state = 221;
-                        this.match(ForgeParser.FILE_PATH_TOK);
+                        this.match(ForgeParser.STRING_TOK);
                         this.state = 224;
                         this._errHandler.sync(this);
                         _la = this._input.LA(1);
@@ -55037,7 +55397,7 @@ class ForgeParser extends Parser_1.Parser {
         this.enterRule(_localctx, 46, ForgeParser.RULE_const);
         let _la;
         try {
-            this.state = 432;
+            this.state = 433;
             this._errHandler.sync(this);
             switch (this._input.LA(1)) {
                 case ForgeParser.NONE_TOK:
@@ -55078,6 +55438,13 @@ class ForgeParser extends Parser_1.Parser {
                         this.number();
                     }
                     break;
+                case ForgeParser.STRING_TOK:
+                    this.enterOuterAlt(_localctx, 5);
+                    {
+                        this.state = 432;
+                        this.match(ForgeParser.STRING_TOK);
+                    }
+                    break;
                 default:
                     throw new NoViableAltException_1.NoViableAltException(this);
             }
@@ -55105,13 +55472,13 @@ class ForgeParser extends Parser_1.Parser {
         try {
             this.enterOuterAlt(_localctx, 1);
             {
-                this.state = 434;
-                this.match(ForgeParser.ASSERT_TOK);
                 this.state = 435;
-                this.expr();
+                this.match(ForgeParser.ASSERT_TOK);
                 this.state = 436;
-                this.match(ForgeParser.IS_TOK);
+                this.expr();
                 this.state = 437;
+                this.match(ForgeParser.IS_TOK);
+                this.state = 438;
                 _la = this._input.LA(1);
                 if (!(((((_la - 40)) & ~0x1F) === 0 && ((1 << (_la - 40)) & ((1 << (ForgeParser.SAT_TOK - 40)) | (1 << (ForgeParser.UNSAT_TOK - 40)) | (1 << (ForgeParser.FORGE_ERROR_TOK - 40)))) !== 0))) {
                     this._errHandler.recoverInline(this);
@@ -55123,24 +55490,24 @@ class ForgeParser extends Parser_1.Parser {
                     this._errHandler.reportMatch(this);
                     this.consume();
                 }
-                this.state = 439;
+                this.state = 440;
                 this._errHandler.sync(this);
                 switch (this.interpreter.adaptivePredict(this._input, 48, this._ctx)) {
                     case 1:
                         {
-                            this.state = 438;
+                            this.state = 439;
                             this.scope();
                         }
                         break;
                 }
-                this.state = 443;
+                this.state = 444;
                 this._errHandler.sync(this);
                 _la = this._input.LA(1);
                 if (_la === ForgeParser.FOR_TOK) {
                     {
-                        this.state = 441;
-                        this.match(ForgeParser.FOR_TOK);
                         this.state = 442;
+                        this.match(ForgeParser.FOR_TOK);
+                        this.state = 443;
                         this.bounds();
                     }
                 }
@@ -55169,29 +55536,29 @@ class ForgeParser extends Parser_1.Parser {
         try {
             this.enterOuterAlt(_localctx, 1);
             {
-                this.state = 445;
-                this.match(ForgeParser.ASSERT_TOK);
                 this.state = 446;
+                this.match(ForgeParser.ASSERT_TOK);
+                this.state = 447;
                 this.match(ForgeParser.ALL_TOK);
-                this.state = 448;
+                this.state = 449;
                 this._errHandler.sync(this);
                 switch (this.interpreter.adaptivePredict(this._input, 50, this._ctx)) {
                     case 1:
                         {
-                            this.state = 447;
+                            this.state = 448;
                             this.match(ForgeParser.DISJ_TOK);
                         }
                         break;
                 }
-                this.state = 450;
-                this.quantDeclList();
                 this.state = 451;
-                this.match(ForgeParser.BAR_TOK);
+                this.quantDeclList();
                 this.state = 452;
-                this.expr();
+                this.match(ForgeParser.BAR_TOK);
                 this.state = 453;
-                this.match(ForgeParser.IS_TOK);
+                this.expr();
                 this.state = 454;
+                this.match(ForgeParser.IS_TOK);
+                this.state = 455;
                 _la = this._input.LA(1);
                 if (!(_la === ForgeParser.SUFFICIENT_TOK || _la === ForgeParser.NECESSARY_TOK)) {
                     this._errHandler.recoverInline(this);
@@ -55203,41 +55570,41 @@ class ForgeParser extends Parser_1.Parser {
                     this._errHandler.reportMatch(this);
                     this.consume();
                 }
-                this.state = 455;
-                this.match(ForgeParser.FOR_TOK);
                 this.state = 456;
+                this.match(ForgeParser.FOR_TOK);
+                this.state = 457;
                 this.name();
-                this.state = 461;
+                this.state = 462;
                 this._errHandler.sync(this);
                 _la = this._input.LA(1);
                 if (_la === ForgeParser.LEFT_SQUARE_TOK) {
                     {
-                        this.state = 457;
-                        this.match(ForgeParser.LEFT_SQUARE_TOK);
                         this.state = 458;
-                        this.exprList();
+                        this.match(ForgeParser.LEFT_SQUARE_TOK);
                         this.state = 459;
+                        this.exprList();
+                        this.state = 460;
                         this.match(ForgeParser.RIGHT_SQUARE_TOK);
                     }
                 }
-                this.state = 464;
+                this.state = 465;
                 this._errHandler.sync(this);
                 switch (this.interpreter.adaptivePredict(this._input, 52, this._ctx)) {
                     case 1:
                         {
-                            this.state = 463;
+                            this.state = 464;
                             this.scope();
                         }
                         break;
                 }
-                this.state = 468;
+                this.state = 469;
                 this._errHandler.sync(this);
                 _la = this._input.LA(1);
                 if (_la === ForgeParser.FOR_TOK) {
                     {
-                        this.state = 466;
-                        this.match(ForgeParser.FOR_TOK);
                         this.state = 467;
+                        this.match(ForgeParser.FOR_TOK);
+                        this.state = 468;
                         this.bounds();
                     }
                 }
@@ -55266,13 +55633,13 @@ class ForgeParser extends Parser_1.Parser {
         try {
             this.enterOuterAlt(_localctx, 1);
             {
-                this.state = 470;
-                this.match(ForgeParser.ASSERT_TOK);
                 this.state = 471;
-                this.expr();
+                this.match(ForgeParser.ASSERT_TOK);
                 this.state = 472;
-                this.match(ForgeParser.IS_TOK);
+                this.expr();
                 this.state = 473;
+                this.match(ForgeParser.IS_TOK);
+                this.state = 474;
                 _la = this._input.LA(1);
                 if (!(_la === ForgeParser.SUFFICIENT_TOK || _la === ForgeParser.NECESSARY_TOK)) {
                     this._errHandler.recoverInline(this);
@@ -55284,28 +55651,28 @@ class ForgeParser extends Parser_1.Parser {
                     this._errHandler.reportMatch(this);
                     this.consume();
                 }
-                this.state = 474;
-                this.match(ForgeParser.FOR_TOK);
                 this.state = 475;
+                this.match(ForgeParser.FOR_TOK);
+                this.state = 476;
                 this.name();
-                this.state = 477;
+                this.state = 478;
                 this._errHandler.sync(this);
                 switch (this.interpreter.adaptivePredict(this._input, 54, this._ctx)) {
                     case 1:
                         {
-                            this.state = 476;
+                            this.state = 477;
                             this.scope();
                         }
                         break;
                 }
-                this.state = 481;
+                this.state = 482;
                 this._errHandler.sync(this);
                 _la = this._input.LA(1);
                 if (_la === ForgeParser.FOR_TOK) {
                     {
-                        this.state = 479;
-                        this.match(ForgeParser.FOR_TOK);
                         this.state = 480;
+                        this.match(ForgeParser.FOR_TOK);
+                        this.state = 481;
                         this.bounds();
                     }
                 }
@@ -55334,13 +55701,13 @@ class ForgeParser extends Parser_1.Parser {
         try {
             this.enterOuterAlt(_localctx, 1);
             {
-                this.state = 483;
-                this.match(ForgeParser.ASSERT_TOK);
                 this.state = 484;
-                this.expr();
+                this.match(ForgeParser.ASSERT_TOK);
                 this.state = 485;
-                this.match(ForgeParser.IS_TOK);
+                this.expr();
                 this.state = 486;
+                this.match(ForgeParser.IS_TOK);
+                this.state = 487;
                 _la = this._input.LA(1);
                 if (!(_la === ForgeParser.CONSISTENT_TOK || _la === ForgeParser.INCONSISTENT_TOK)) {
                     this._errHandler.recoverInline(this);
@@ -55352,28 +55719,28 @@ class ForgeParser extends Parser_1.Parser {
                     this._errHandler.reportMatch(this);
                     this.consume();
                 }
-                this.state = 487;
-                this.match(ForgeParser.WITH_TOK);
                 this.state = 488;
+                this.match(ForgeParser.WITH_TOK);
+                this.state = 489;
                 this.name();
-                this.state = 490;
+                this.state = 491;
                 this._errHandler.sync(this);
                 switch (this.interpreter.adaptivePredict(this._input, 56, this._ctx)) {
                     case 1:
                         {
-                            this.state = 489;
+                            this.state = 490;
                             this.scope();
                         }
                         break;
                 }
-                this.state = 494;
+                this.state = 495;
                 this._errHandler.sync(this);
                 _la = this._input.LA(1);
                 if (_la === ForgeParser.FOR_TOK) {
                     {
-                        this.state = 492;
-                        this.match(ForgeParser.FOR_TOK);
                         this.state = 493;
+                        this.match(ForgeParser.FOR_TOK);
+                        this.state = 494;
                         this.bounds();
                     }
                 }
@@ -55402,31 +55769,31 @@ class ForgeParser extends Parser_1.Parser {
         try {
             this.enterOuterAlt(_localctx, 1);
             {
-                this.state = 496;
-                this.match(ForgeParser.TEST_TOK);
                 this.state = 497;
-                this.match(ForgeParser.SUITE_TOK);
+                this.match(ForgeParser.TEST_TOK);
                 this.state = 498;
-                this.match(ForgeParser.FOR_TOK);
+                this.match(ForgeParser.SUITE_TOK);
                 this.state = 499;
-                this.name();
+                this.match(ForgeParser.FOR_TOK);
                 this.state = 500;
+                this.name();
+                this.state = 501;
                 this.match(ForgeParser.LEFT_CURLY_TOK);
-                this.state = 504;
+                this.state = 505;
                 this._errHandler.sync(this);
                 _la = this._input.LA(1);
                 while (((((_la - 29)) & ~0x1F) === 0 && ((1 << (_la - 29)) & ((1 << (ForgeParser.ASSERT_TOK - 29)) | (1 << (ForgeParser.TEST_TOK - 29)) | (1 << (ForgeParser.EXPECT_TOK - 29)))) !== 0) || _la === ForgeParser.EXAMPLE_TOK) {
                     {
                         {
-                            this.state = 501;
+                            this.state = 502;
                             this.testConstruct();
                         }
                     }
-                    this.state = 506;
+                    this.state = 507;
                     this._errHandler.sync(this);
                     _la = this._input.LA(1);
                 }
-                this.state = 507;
+                this.state = 508;
                 this.match(ForgeParser.RIGHT_CURLY_TOK);
             }
         }
@@ -55450,48 +55817,48 @@ class ForgeParser extends Parser_1.Parser {
         let _localctx = new TestConstructContext(this._ctx, this.state);
         this.enterRule(_localctx, 58, ForgeParser.RULE_testConstruct);
         try {
-            this.state = 515;
+            this.state = 516;
             this._errHandler.sync(this);
             switch (this.interpreter.adaptivePredict(this._input, 59, this._ctx)) {
                 case 1:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 509;
+                        this.state = 510;
                         this.exampleDecl();
                     }
                     break;
                 case 2:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 510;
+                        this.state = 511;
                         this.testExpectDecl();
                     }
                     break;
                 case 3:
                     this.enterOuterAlt(_localctx, 3);
                     {
-                        this.state = 511;
+                        this.state = 512;
                         this.quantifiedPropertyDecl();
                     }
                     break;
                 case 4:
                     this.enterOuterAlt(_localctx, 4);
                     {
-                        this.state = 512;
+                        this.state = 513;
                         this.propertyDecl();
                     }
                     break;
                 case 5:
                     this.enterOuterAlt(_localctx, 5);
                     {
-                        this.state = 513;
+                        this.state = 514;
                         this.satisfiabilityDecl();
                     }
                     break;
                 case 6:
                     this.enterOuterAlt(_localctx, 6);
                     {
-                        this.state = 514;
+                        this.state = 515;
                         this.consistencyDecl();
                     }
                     break;
@@ -55519,7 +55886,7 @@ class ForgeParser extends Parser_1.Parser {
         try {
             this.enterOuterAlt(_localctx, 1);
             {
-                this.state = 519;
+                this.state = 520;
                 this._errHandler.sync(this);
                 switch (this._input.LA(1)) {
                     case ForgeParser.LONE_TOK:
@@ -55527,13 +55894,13 @@ class ForgeParser extends Parser_1.Parser {
                     case ForgeParser.ONE_TOK:
                     case ForgeParser.TWO_TOK:
                         {
-                            this.state = 517;
+                            this.state = 518;
                             this.mult();
                         }
                         break;
                     case ForgeParser.SET_TOK:
                         {
-                            this.state = 518;
+                            this.state = 519;
                             this.match(ForgeParser.SET_TOK);
                         }
                         break;
@@ -55542,9 +55909,9 @@ class ForgeParser extends Parser_1.Parser {
                     default:
                         break;
                 }
-                this.state = 521;
+                this.state = 522;
                 this.match(ForgeParser.ARROW_TOK);
-                this.state = 524;
+                this.state = 525;
                 this._errHandler.sync(this);
                 switch (this._input.LA(1)) {
                     case ForgeParser.LONE_TOK:
@@ -55552,16 +55919,17 @@ class ForgeParser extends Parser_1.Parser {
                     case ForgeParser.ONE_TOK:
                     case ForgeParser.TWO_TOK:
                         {
-                            this.state = 522;
+                            this.state = 523;
                             this.mult();
                         }
                         break;
                     case ForgeParser.SET_TOK:
                         {
-                            this.state = 523;
+                            this.state = 524;
                             this.match(ForgeParser.SET_TOK);
                         }
                         break;
+                    case ForgeParser.STRING_TOK:
                     case ForgeParser.LEFT_CURLY_TOK:
                     case ForgeParser.LEFT_PAREN_TOK:
                     case ForgeParser.NONE_TOK:
@@ -55613,7 +55981,7 @@ class ForgeParser extends Parser_1.Parser {
         try {
             this.enterOuterAlt(_localctx, 1);
             {
-                this.state = 526;
+                this.state = 527;
                 _la = this._input.LA(1);
                 if (!(_la === ForgeParser.IN_TOK || _la === ForgeParser.IS_TOK || ((((_la - 95)) & ~0x1F) === 0 && ((1 << (_la - 95)) & ((1 << (ForgeParser.EQ_TOK - 95)) | (1 << (ForgeParser.LT_TOK - 95)) | (1 << (ForgeParser.GT_TOK - 95)) | (1 << (ForgeParser.LEQ_TOK - 95)) | (1 << (ForgeParser.GEQ_TOK - 95)) | (1 << (ForgeParser.NI_TOK - 95)))) !== 0))) {
                     this._errHandler.recoverInline(this);
@@ -55649,11 +56017,11 @@ class ForgeParser extends Parser_1.Parser {
         try {
             this.enterOuterAlt(_localctx, 1);
             {
-                this.state = 528;
-                this.name();
                 this.state = 529;
-                this.match(ForgeParser.EQ_TOK);
+                this.name();
                 this.state = 530;
+                this.match(ForgeParser.EQ_TOK);
+                this.state = 531;
                 this.expr();
             }
         }
@@ -55680,23 +56048,23 @@ class ForgeParser extends Parser_1.Parser {
         try {
             this.enterOuterAlt(_localctx, 1);
             {
-                this.state = 532;
+                this.state = 533;
                 this.match(ForgeParser.LEFT_CURLY_TOK);
-                this.state = 536;
+                this.state = 537;
                 this._errHandler.sync(this);
                 _la = this._input.LA(1);
-                while (((((_la - 9)) & ~0x1F) === 0 && ((1 << (_la - 9)) & ((1 << (ForgeParser.LEFT_CURLY_TOK - 9)) | (1 << (ForgeParser.LONE_TOK - 9)) | (1 << (ForgeParser.SOME_TOK - 9)) | (1 << (ForgeParser.ONE_TOK - 9)) | (1 << (ForgeParser.TWO_TOK - 9)) | (1 << (ForgeParser.SET_TOK - 9)) | (1 << (ForgeParser.LEFT_PAREN_TOK - 9)) | (1 << (ForgeParser.NONE_TOK - 9)) | (1 << (ForgeParser.UNIV_TOK - 9)) | (1 << (ForgeParser.IDEN_TOK - 9)) | (1 << (ForgeParser.MINUS_TOK - 9)))) !== 0) || ((((_la - 49)) & ~0x1F) === 0 && ((1 << (_la - 49)) & ((1 << (ForgeParser.ALL_TOK - 49)) | (1 << (ForgeParser.LET_TOK - 49)) | (1 << (ForgeParser.BIND_TOK - 49)) | (1 << (ForgeParser.NEG_TOK - 49)) | (1 << (ForgeParser.ALWAYS_TOK - 49)) | (1 << (ForgeParser.EVENTUALLY_TOK - 49)) | (1 << (ForgeParser.AFTER_TOK - 49)) | (1 << (ForgeParser.BEFORE_TOK - 49)) | (1 << (ForgeParser.ONCE_TOK - 49)) | (1 << (ForgeParser.HISTORICALLY_TOK - 49)) | (1 << (ForgeParser.CARD_TOK - 49)) | (1 << (ForgeParser.TILDE_TOK - 49)))) !== 0) || ((((_la - 81)) & ~0x1F) === 0 && ((1 << (_la - 81)) & ((1 << (ForgeParser.EXP_TOK - 81)) | (1 << (ForgeParser.STAR_TOK - 81)) | (1 << (ForgeParser.AT_TOK - 81)) | (1 << (ForgeParser.BACKQUOTE_TOK - 81)) | (1 << (ForgeParser.THIS_TOK - 81)) | (1 << (ForgeParser.SEXPR_TOK - 81)) | (1 << (ForgeParser.GET_LABEL_TOK - 81)) | (1 << (ForgeParser.GET_LABEL_STR_TOK - 81)) | (1 << (ForgeParser.GET_LABEL_BOOL_TOK - 81)) | (1 << (ForgeParser.GET_LABEL_NUM_TOK - 81)) | (1 << (ForgeParser.NO_TOK - 81)) | (1 << (ForgeParser.SUM_TOK - 81)) | (1 << (ForgeParser.INT_TOK - 81)) | (1 << (ForgeParser.NUM_CONST_TOK - 81)) | (1 << (ForgeParser.QUOTED_IDENTIFIER_TOK - 81)) | (1 << (ForgeParser.IDENTIFIER_TOK - 81)))) !== 0)) {
+                while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << ForgeParser.STRING_TOK) | (1 << ForgeParser.LEFT_CURLY_TOK) | (1 << ForgeParser.LONE_TOK) | (1 << ForgeParser.SOME_TOK) | (1 << ForgeParser.ONE_TOK) | (1 << ForgeParser.TWO_TOK) | (1 << ForgeParser.SET_TOK) | (1 << ForgeParser.LEFT_PAREN_TOK))) !== 0) || ((((_la - 35)) & ~0x1F) === 0 && ((1 << (_la - 35)) & ((1 << (ForgeParser.NONE_TOK - 35)) | (1 << (ForgeParser.UNIV_TOK - 35)) | (1 << (ForgeParser.IDEN_TOK - 35)) | (1 << (ForgeParser.MINUS_TOK - 35)) | (1 << (ForgeParser.ALL_TOK - 35)) | (1 << (ForgeParser.LET_TOK - 35)) | (1 << (ForgeParser.BIND_TOK - 35)))) !== 0) || ((((_la - 67)) & ~0x1F) === 0 && ((1 << (_la - 67)) & ((1 << (ForgeParser.NEG_TOK - 67)) | (1 << (ForgeParser.ALWAYS_TOK - 67)) | (1 << (ForgeParser.EVENTUALLY_TOK - 67)) | (1 << (ForgeParser.AFTER_TOK - 67)) | (1 << (ForgeParser.BEFORE_TOK - 67)) | (1 << (ForgeParser.ONCE_TOK - 67)) | (1 << (ForgeParser.HISTORICALLY_TOK - 67)) | (1 << (ForgeParser.CARD_TOK - 67)) | (1 << (ForgeParser.TILDE_TOK - 67)) | (1 << (ForgeParser.EXP_TOK - 67)) | (1 << (ForgeParser.STAR_TOK - 67)) | (1 << (ForgeParser.AT_TOK - 67)) | (1 << (ForgeParser.BACKQUOTE_TOK - 67)) | (1 << (ForgeParser.THIS_TOK - 67)) | (1 << (ForgeParser.SEXPR_TOK - 67)) | (1 << (ForgeParser.GET_LABEL_TOK - 67)) | (1 << (ForgeParser.GET_LABEL_STR_TOK - 67)) | (1 << (ForgeParser.GET_LABEL_BOOL_TOK - 67)) | (1 << (ForgeParser.GET_LABEL_NUM_TOK - 67)))) !== 0) || ((((_la - 101)) & ~0x1F) === 0 && ((1 << (_la - 101)) & ((1 << (ForgeParser.NO_TOK - 101)) | (1 << (ForgeParser.SUM_TOK - 101)) | (1 << (ForgeParser.INT_TOK - 101)) | (1 << (ForgeParser.NUM_CONST_TOK - 101)) | (1 << (ForgeParser.QUOTED_IDENTIFIER_TOK - 101)) | (1 << (ForgeParser.IDENTIFIER_TOK - 101)))) !== 0)) {
                     {
                         {
-                            this.state = 533;
+                            this.state = 534;
                             this.expr();
                         }
                     }
-                    this.state = 538;
+                    this.state = 539;
                     this._errHandler.sync(this);
                     _la = this._input.LA(1);
                 }
-                this.state = 539;
+                this.state = 540;
                 this.match(ForgeParser.RIGHT_CURLY_TOK);
             }
         }
@@ -55720,22 +56088,22 @@ class ForgeParser extends Parser_1.Parser {
         let _localctx = new BlockOrBarContext(this._ctx, this.state);
         this.enterRule(_localctx, 68, ForgeParser.RULE_blockOrBar);
         try {
-            this.state = 544;
+            this.state = 545;
             this._errHandler.sync(this);
             switch (this._input.LA(1)) {
                 case ForgeParser.LEFT_CURLY_TOK:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 541;
+                        this.state = 542;
                         this.block();
                     }
                     break;
                 case ForgeParser.BAR_TOK:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 542;
-                        this.match(ForgeParser.BAR_TOK);
                         this.state = 543;
+                        this.match(ForgeParser.BAR_TOK);
+                        this.state = 544;
                         this.expr();
                     }
                     break;
@@ -55763,27 +56131,27 @@ class ForgeParser extends Parser_1.Parser {
         let _localctx = new QuantContext(this._ctx, this.state);
         this.enterRule(_localctx, 70, ForgeParser.RULE_quant);
         try {
-            this.state = 550;
+            this.state = 551;
             this._errHandler.sync(this);
             switch (this._input.LA(1)) {
                 case ForgeParser.ALL_TOK:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 546;
+                        this.state = 547;
                         this.match(ForgeParser.ALL_TOK);
                     }
                     break;
                 case ForgeParser.NO_TOK:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 547;
+                        this.state = 548;
                         this.match(ForgeParser.NO_TOK);
                     }
                     break;
                 case ForgeParser.SUM_TOK:
                     this.enterOuterAlt(_localctx, 3);
                     {
-                        this.state = 548;
+                        this.state = 549;
                         this.match(ForgeParser.SUM_TOK);
                     }
                     break;
@@ -55793,7 +56161,7 @@ class ForgeParser extends Parser_1.Parser {
                 case ForgeParser.TWO_TOK:
                     this.enterOuterAlt(_localctx, 4);
                     {
-                        this.state = 549;
+                        this.state = 550;
                         this.mult();
                     }
                     break;
@@ -55823,7 +56191,7 @@ class ForgeParser extends Parser_1.Parser {
         let _la;
         try {
             let _alt;
-            this.state = 567;
+            this.state = 568;
             this._errHandler.sync(this);
             switch (this._input.LA(1)) {
                 case ForgeParser.THIS_TOK:
@@ -55831,50 +56199,50 @@ class ForgeParser extends Parser_1.Parser {
                 case ForgeParser.IDENTIFIER_TOK:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 554;
+                        this.state = 555;
                         this._errHandler.sync(this);
                         _la = this._input.LA(1);
                         if (_la === ForgeParser.THIS_TOK) {
                             {
-                                this.state = 552;
-                                this.match(ForgeParser.THIS_TOK);
                                 this.state = 553;
+                                this.match(ForgeParser.THIS_TOK);
+                                this.state = 554;
                                 this.match(ForgeParser.SLASH_TOK);
                             }
                         }
-                        this.state = 561;
+                        this.state = 562;
                         this._errHandler.sync(this);
                         _alt = this.interpreter.adaptivePredict(this._input, 66, this._ctx);
                         while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
                             if (_alt === 1) {
                                 {
                                     {
-                                        this.state = 556;
-                                        this.name();
                                         this.state = 557;
+                                        this.name();
+                                        this.state = 558;
                                         this.match(ForgeParser.SLASH_TOK);
                                     }
                                 }
                             }
-                            this.state = 563;
+                            this.state = 564;
                             this._errHandler.sync(this);
                             _alt = this.interpreter.adaptivePredict(this._input, 66, this._ctx);
                         }
-                        this.state = 564;
+                        this.state = 565;
                         this.name();
                     }
                     break;
                 case ForgeParser.INT_TOK:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 565;
+                        this.state = 566;
                         this.match(ForgeParser.INT_TOK);
                     }
                     break;
                 case ForgeParser.SUM_TOK:
                     this.enterOuterAlt(_localctx, 3);
                     {
-                        this.state = 566;
+                        this.state = 567;
                         this.match(ForgeParser.SUM_TOK);
                     }
                     break;
@@ -55905,11 +56273,11 @@ class ForgeParser extends Parser_1.Parser {
         try {
             this.enterOuterAlt(_localctx, 1);
             {
-                this.state = 569;
-                this.match(ForgeParser.OPTION_TOK);
                 this.state = 570;
+                this.match(ForgeParser.OPTION_TOK);
+                this.state = 571;
                 this.qualName();
-                this.state = 577;
+                this.state = 578;
                 this._errHandler.sync(this);
                 switch (this._input.LA(1)) {
                     case ForgeParser.THIS_TOK:
@@ -55918,29 +56286,29 @@ class ForgeParser extends Parser_1.Parser {
                     case ForgeParser.QUOTED_IDENTIFIER_TOK:
                     case ForgeParser.IDENTIFIER_TOK:
                         {
-                            this.state = 571;
+                            this.state = 572;
                             this.qualName();
                         }
                         break;
-                    case ForgeParser.FILE_PATH_TOK:
+                    case ForgeParser.STRING_TOK:
                         {
-                            this.state = 572;
-                            this.match(ForgeParser.FILE_PATH_TOK);
+                            this.state = 573;
+                            this.match(ForgeParser.STRING_TOK);
                         }
                         break;
                     case ForgeParser.MINUS_TOK:
                     case ForgeParser.NUM_CONST_TOK:
                         {
-                            this.state = 574;
+                            this.state = 575;
                             this._errHandler.sync(this);
                             _la = this._input.LA(1);
                             if (_la === ForgeParser.MINUS_TOK) {
                                 {
-                                    this.state = 573;
+                                    this.state = 574;
                                     this.match(ForgeParser.MINUS_TOK);
                                 }
                             }
-                            this.state = 576;
+                            this.state = 577;
                             this.number();
                         }
                         break;
@@ -55972,7 +56340,7 @@ class ForgeParser extends Parser_1.Parser {
         try {
             this.enterOuterAlt(_localctx, 1);
             {
-                this.state = 579;
+                this.state = 580;
                 _la = this._input.LA(1);
                 if (!(_la === ForgeParser.QUOTED_IDENTIFIER_TOK || _la === ForgeParser.IDENTIFIER_TOK)) {
                     this._errHandler.recoverInline(this);
@@ -56006,24 +56374,24 @@ class ForgeParser extends Parser_1.Parser {
         let _localctx = new NameListContext(this._ctx, this.state);
         this.enterRule(_localctx, 78, ForgeParser.RULE_nameList);
         try {
-            this.state = 586;
+            this.state = 587;
             this._errHandler.sync(this);
             switch (this.interpreter.adaptivePredict(this._input, 70, this._ctx)) {
                 case 1:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 581;
+                        this.state = 582;
                         this.name();
                     }
                     break;
                 case 2:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 582;
-                        this.name();
                         this.state = 583;
-                        this.match(ForgeParser.COMMA_TOK);
+                        this.name();
                         this.state = 584;
+                        this.match(ForgeParser.COMMA_TOK);
+                        this.state = 585;
                         this.nameList();
                     }
                     break;
@@ -56049,24 +56417,24 @@ class ForgeParser extends Parser_1.Parser {
         let _localctx = new QualNameListContext(this._ctx, this.state);
         this.enterRule(_localctx, 80, ForgeParser.RULE_qualNameList);
         try {
-            this.state = 593;
+            this.state = 594;
             this._errHandler.sync(this);
             switch (this.interpreter.adaptivePredict(this._input, 71, this._ctx)) {
                 case 1:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 588;
+                        this.state = 589;
                         this.qualName();
                     }
                     break;
                 case 2:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 589;
-                        this.qualName();
                         this.state = 590;
-                        this.match(ForgeParser.COMMA_TOK);
+                        this.qualName();
                         this.state = 591;
+                        this.match(ForgeParser.COMMA_TOK);
+                        this.state = 592;
                         this.qualNameList();
                     }
                     break;
@@ -56092,24 +56460,24 @@ class ForgeParser extends Parser_1.Parser {
         let _localctx = new ParaDeclListContext(this._ctx, this.state);
         this.enterRule(_localctx, 82, ForgeParser.RULE_paraDeclList);
         try {
-            this.state = 600;
+            this.state = 601;
             this._errHandler.sync(this);
             switch (this.interpreter.adaptivePredict(this._input, 72, this._ctx)) {
                 case 1:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 595;
+                        this.state = 596;
                         this.paraDecl();
                     }
                     break;
                 case 2:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 596;
-                        this.paraDecl();
                         this.state = 597;
-                        this.match(ForgeParser.COMMA_TOK);
+                        this.paraDecl();
                         this.state = 598;
+                        this.match(ForgeParser.COMMA_TOK);
+                        this.state = 599;
                         this.paraDeclList();
                     }
                     break;
@@ -56135,24 +56503,24 @@ class ForgeParser extends Parser_1.Parser {
         let _localctx = new QuantDeclListContext(this._ctx, this.state);
         this.enterRule(_localctx, 84, ForgeParser.RULE_quantDeclList);
         try {
-            this.state = 607;
+            this.state = 608;
             this._errHandler.sync(this);
             switch (this.interpreter.adaptivePredict(this._input, 73, this._ctx)) {
                 case 1:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 602;
+                        this.state = 603;
                         this.quantDecl();
                     }
                     break;
                 case 2:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 603;
-                        this.quantDecl();
                         this.state = 604;
-                        this.match(ForgeParser.COMMA_TOK);
+                        this.quantDecl();
                         this.state = 605;
+                        this.match(ForgeParser.COMMA_TOK);
+                        this.state = 606;
                         this.quantDeclList();
                     }
                     break;
@@ -56178,24 +56546,24 @@ class ForgeParser extends Parser_1.Parser {
         let _localctx = new ArrowDeclListContext(this._ctx, this.state);
         this.enterRule(_localctx, 86, ForgeParser.RULE_arrowDeclList);
         try {
-            this.state = 614;
+            this.state = 615;
             this._errHandler.sync(this);
             switch (this.interpreter.adaptivePredict(this._input, 74, this._ctx)) {
                 case 1:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 609;
+                        this.state = 610;
                         this.arrowDecl();
                     }
                     break;
                 case 2:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 610;
-                        this.arrowDecl();
                         this.state = 611;
-                        this.match(ForgeParser.COMMA_TOK);
+                        this.arrowDecl();
                         this.state = 612;
+                        this.match(ForgeParser.COMMA_TOK);
+                        this.state = 613;
                         this.arrowDeclList();
                     }
                     break;
@@ -56221,24 +56589,24 @@ class ForgeParser extends Parser_1.Parser {
         let _localctx = new LetDeclListContext(this._ctx, this.state);
         this.enterRule(_localctx, 88, ForgeParser.RULE_letDeclList);
         try {
-            this.state = 621;
+            this.state = 622;
             this._errHandler.sync(this);
             switch (this.interpreter.adaptivePredict(this._input, 75, this._ctx)) {
                 case 1:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 616;
+                        this.state = 617;
                         this.letDecl();
                     }
                     break;
                 case 2:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 617;
-                        this.letDecl();
                         this.state = 618;
-                        this.match(ForgeParser.COMMA_TOK);
+                        this.letDecl();
                         this.state = 619;
+                        this.match(ForgeParser.COMMA_TOK);
+                        this.state = 620;
                         this.letDeclList();
                     }
                     break;
@@ -56264,24 +56632,24 @@ class ForgeParser extends Parser_1.Parser {
         let _localctx = new TypescopeListContext(this._ctx, this.state);
         this.enterRule(_localctx, 90, ForgeParser.RULE_typescopeList);
         try {
-            this.state = 628;
+            this.state = 629;
             this._errHandler.sync(this);
             switch (this.interpreter.adaptivePredict(this._input, 76, this._ctx)) {
                 case 1:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 623;
+                        this.state = 624;
                         this.typescope();
                     }
                     break;
                 case 2:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 624;
-                        this.typescope();
                         this.state = 625;
-                        this.match(ForgeParser.COMMA_TOK);
+                        this.typescope();
                         this.state = 626;
+                        this.match(ForgeParser.COMMA_TOK);
+                        this.state = 627;
                         this.typescopeList();
                     }
                     break;
@@ -56307,24 +56675,24 @@ class ForgeParser extends Parser_1.Parser {
         let _localctx = new ExprListContext(this._ctx, this.state);
         this.enterRule(_localctx, 92, ForgeParser.RULE_exprList);
         try {
-            this.state = 635;
+            this.state = 636;
             this._errHandler.sync(this);
             switch (this.interpreter.adaptivePredict(this._input, 77, this._ctx)) {
                 case 1:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 630;
+                        this.state = 631;
                         this.expr();
                     }
                     break;
                 case 2:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 631;
-                        this.expr();
                         this.state = 632;
-                        this.match(ForgeParser.COMMA_TOK);
+                        this.expr();
                         this.state = 633;
+                        this.match(ForgeParser.COMMA_TOK);
+                        this.state = 634;
                         this.exprList();
                     }
                     break;
@@ -56350,56 +56718,56 @@ class ForgeParser extends Parser_1.Parser {
         let _localctx = new ExprContext(this._ctx, this.state);
         this.enterRule(_localctx, 94, ForgeParser.RULE_expr);
         try {
-            this.state = 653;
+            this.state = 654;
             this._errHandler.sync(this);
             switch (this.interpreter.adaptivePredict(this._input, 79, this._ctx)) {
                 case 1:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 637;
+                        this.state = 638;
                         this.expr1(0);
                     }
                     break;
                 case 2:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 638;
-                        this.match(ForgeParser.LET_TOK);
                         this.state = 639;
-                        this.letDeclList();
+                        this.match(ForgeParser.LET_TOK);
                         this.state = 640;
+                        this.letDeclList();
+                        this.state = 641;
                         this.blockOrBar();
                     }
                     break;
                 case 3:
                     this.enterOuterAlt(_localctx, 3);
                     {
-                        this.state = 642;
-                        this.match(ForgeParser.BIND_TOK);
                         this.state = 643;
-                        this.letDeclList();
+                        this.match(ForgeParser.BIND_TOK);
                         this.state = 644;
+                        this.letDeclList();
+                        this.state = 645;
                         this.blockOrBar();
                     }
                     break;
                 case 4:
                     this.enterOuterAlt(_localctx, 4);
                     {
-                        this.state = 646;
+                        this.state = 647;
                         this.quant();
-                        this.state = 648;
+                        this.state = 649;
                         this._errHandler.sync(this);
                         switch (this.interpreter.adaptivePredict(this._input, 78, this._ctx)) {
                             case 1:
                                 {
-                                    this.state = 647;
+                                    this.state = 648;
                                     this.match(ForgeParser.DISJ_TOK);
                                 }
                                 break;
                         }
-                        this.state = 650;
-                        this.quantDeclList();
                         this.state = 651;
+                        this.quantDeclList();
+                        this.state = 652;
                         this.blockOrBar();
                     }
                     break;
@@ -56436,11 +56804,11 @@ class ForgeParser extends Parser_1.Parser {
             this.enterOuterAlt(_localctx, 1);
             {
                 {
-                    this.state = 656;
+                    this.state = 657;
                     this.expr1_5(0);
                 }
                 this._ctx._stop = this._input.tryLT(-1);
-                this.state = 663;
+                this.state = 664;
                 this._errHandler.sync(this);
                 _alt = this.interpreter.adaptivePredict(this._input, 80, this._ctx);
                 while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
@@ -56453,18 +56821,18 @@ class ForgeParser extends Parser_1.Parser {
                             {
                                 _localctx = new Expr1Context(_parentctx, _parentState);
                                 this.pushNewRecursionContext(_localctx, _startState, ForgeParser.RULE_expr1);
-                                this.state = 658;
+                                this.state = 659;
                                 if (!(this.precpred(this._ctx, 1))) {
                                     throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
                                 }
-                                this.state = 659;
-                                this.match(ForgeParser.OR_TOK);
                                 this.state = 660;
+                                this.match(ForgeParser.OR_TOK);
+                                this.state = 661;
                                 this.expr1_5(0);
                             }
                         }
                     }
-                    this.state = 665;
+                    this.state = 666;
                     this._errHandler.sync(this);
                     _alt = this.interpreter.adaptivePredict(this._input, 80, this._ctx);
                 }
@@ -56501,11 +56869,11 @@ class ForgeParser extends Parser_1.Parser {
             this.enterOuterAlt(_localctx, 1);
             {
                 {
-                    this.state = 667;
+                    this.state = 668;
                     this.expr2(0);
                 }
                 this._ctx._stop = this._input.tryLT(-1);
-                this.state = 674;
+                this.state = 675;
                 this._errHandler.sync(this);
                 _alt = this.interpreter.adaptivePredict(this._input, 81, this._ctx);
                 while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
@@ -56518,18 +56886,18 @@ class ForgeParser extends Parser_1.Parser {
                             {
                                 _localctx = new Expr1_5Context(_parentctx, _parentState);
                                 this.pushNewRecursionContext(_localctx, _startState, ForgeParser.RULE_expr1_5);
-                                this.state = 669;
+                                this.state = 670;
                                 if (!(this.precpred(this._ctx, 1))) {
                                     throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
                                 }
-                                this.state = 670;
-                                this.match(ForgeParser.XOR_TOK);
                                 this.state = 671;
+                                this.match(ForgeParser.XOR_TOK);
+                                this.state = 672;
                                 this.expr2(0);
                             }
                         }
                     }
-                    this.state = 676;
+                    this.state = 677;
                     this._errHandler.sync(this);
                     _alt = this.interpreter.adaptivePredict(this._input, 81, this._ctx);
                 }
@@ -56566,11 +56934,11 @@ class ForgeParser extends Parser_1.Parser {
             this.enterOuterAlt(_localctx, 1);
             {
                 {
-                    this.state = 678;
+                    this.state = 679;
                     this.expr3();
                 }
                 this._ctx._stop = this._input.tryLT(-1);
-                this.state = 685;
+                this.state = 686;
                 this._errHandler.sync(this);
                 _alt = this.interpreter.adaptivePredict(this._input, 82, this._ctx);
                 while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
@@ -56583,18 +56951,18 @@ class ForgeParser extends Parser_1.Parser {
                             {
                                 _localctx = new Expr2Context(_parentctx, _parentState);
                                 this.pushNewRecursionContext(_localctx, _startState, ForgeParser.RULE_expr2);
-                                this.state = 680;
+                                this.state = 681;
                                 if (!(this.precpred(this._ctx, 1))) {
                                     throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
                                 }
-                                this.state = 681;
-                                this.match(ForgeParser.IFF_TOK);
                                 this.state = 682;
+                                this.match(ForgeParser.IFF_TOK);
+                                this.state = 683;
                                 this.expr3();
                             }
                         }
                     }
-                    this.state = 687;
+                    this.state = 688;
                     this._errHandler.sync(this);
                     _alt = this.interpreter.adaptivePredict(this._input, 82, this._ctx);
                 }
@@ -56620,33 +56988,33 @@ class ForgeParser extends Parser_1.Parser {
         let _localctx = new Expr3Context(this._ctx, this.state);
         this.enterRule(_localctx, 102, ForgeParser.RULE_expr3);
         try {
-            this.state = 696;
+            this.state = 697;
             this._errHandler.sync(this);
             switch (this.interpreter.adaptivePredict(this._input, 84, this._ctx)) {
                 case 1:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 688;
+                        this.state = 689;
                         this.expr4(0);
                     }
                     break;
                 case 2:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 689;
-                        this.expr4(0);
                         this.state = 690;
-                        this.match(ForgeParser.IMP_TOK);
+                        this.expr4(0);
                         this.state = 691;
+                        this.match(ForgeParser.IMP_TOK);
+                        this.state = 692;
                         this.expr3();
-                        this.state = 694;
+                        this.state = 695;
                         this._errHandler.sync(this);
                         switch (this.interpreter.adaptivePredict(this._input, 83, this._ctx)) {
                             case 1:
                                 {
-                                    this.state = 692;
-                                    this.match(ForgeParser.ELSE_TOK);
                                     this.state = 693;
+                                    this.match(ForgeParser.ELSE_TOK);
+                                    this.state = 694;
                                     this.expr3();
                                 }
                                 break;
@@ -56686,11 +57054,11 @@ class ForgeParser extends Parser_1.Parser {
             this.enterOuterAlt(_localctx, 1);
             {
                 {
-                    this.state = 699;
+                    this.state = 700;
                     this.expr4_5();
                 }
                 this._ctx._stop = this._input.tryLT(-1);
-                this.state = 706;
+                this.state = 707;
                 this._errHandler.sync(this);
                 _alt = this.interpreter.adaptivePredict(this._input, 85, this._ctx);
                 while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
@@ -56703,18 +57071,18 @@ class ForgeParser extends Parser_1.Parser {
                             {
                                 _localctx = new Expr4Context(_parentctx, _parentState);
                                 this.pushNewRecursionContext(_localctx, _startState, ForgeParser.RULE_expr4);
-                                this.state = 701;
+                                this.state = 702;
                                 if (!(this.precpred(this._ctx, 1))) {
                                     throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
                                 }
-                                this.state = 702;
-                                this.match(ForgeParser.AND_TOK);
                                 this.state = 703;
+                                this.match(ForgeParser.AND_TOK);
+                                this.state = 704;
                                 this.expr4_5();
                             }
                         }
                     }
-                    this.state = 708;
+                    this.state = 709;
                     this._errHandler.sync(this);
                     _alt = this.interpreter.adaptivePredict(this._input, 85, this._ctx);
                 }
@@ -56740,57 +57108,57 @@ class ForgeParser extends Parser_1.Parser {
         let _localctx = new Expr4_5Context(this._ctx, this.state);
         this.enterRule(_localctx, 106, ForgeParser.RULE_expr4_5);
         try {
-            this.state = 726;
+            this.state = 727;
             this._errHandler.sync(this);
             switch (this.interpreter.adaptivePredict(this._input, 86, this._ctx)) {
                 case 1:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 709;
+                        this.state = 710;
                         this.expr5();
                     }
                     break;
                 case 2:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 710;
-                        this.expr5();
                         this.state = 711;
-                        this.match(ForgeParser.UNTIL_TOK);
+                        this.expr5();
                         this.state = 712;
+                        this.match(ForgeParser.UNTIL_TOK);
+                        this.state = 713;
                         this.expr5();
                     }
                     break;
                 case 3:
                     this.enterOuterAlt(_localctx, 3);
                     {
-                        this.state = 714;
-                        this.expr5();
                         this.state = 715;
-                        this.match(ForgeParser.RELEASE_TOK);
+                        this.expr5();
                         this.state = 716;
+                        this.match(ForgeParser.RELEASE_TOK);
+                        this.state = 717;
                         this.expr5();
                     }
                     break;
                 case 4:
                     this.enterOuterAlt(_localctx, 4);
                     {
-                        this.state = 718;
-                        this.expr5();
                         this.state = 719;
-                        this.match(ForgeParser.SINCE_TOK);
+                        this.expr5();
                         this.state = 720;
+                        this.match(ForgeParser.SINCE_TOK);
+                        this.state = 721;
                         this.expr5();
                     }
                     break;
                 case 5:
                     this.enterOuterAlt(_localctx, 5);
                     {
-                        this.state = 722;
-                        this.expr5();
                         this.state = 723;
-                        this.match(ForgeParser.TRIGGERED_TOK);
+                        this.expr5();
                         this.state = 724;
+                        this.match(ForgeParser.TRIGGERED_TOK);
+                        this.state = 725;
                         this.expr5();
                     }
                     break;
@@ -56816,9 +57184,10 @@ class ForgeParser extends Parser_1.Parser {
         let _localctx = new Expr5Context(this._ctx, this.state);
         this.enterRule(_localctx, 108, ForgeParser.RULE_expr5);
         try {
-            this.state = 743;
+            this.state = 744;
             this._errHandler.sync(this);
             switch (this._input.LA(1)) {
+                case ForgeParser.STRING_TOK:
                 case ForgeParser.LEFT_CURLY_TOK:
                 case ForgeParser.LONE_TOK:
                 case ForgeParser.SOME_TOK:
@@ -56850,70 +57219,70 @@ class ForgeParser extends Parser_1.Parser {
                 case ForgeParser.IDENTIFIER_TOK:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 728;
+                        this.state = 729;
                         this.expr6(0);
                     }
                     break;
                 case ForgeParser.NEG_TOK:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 729;
-                        this.match(ForgeParser.NEG_TOK);
                         this.state = 730;
+                        this.match(ForgeParser.NEG_TOK);
+                        this.state = 731;
                         this.expr5();
                     }
                     break;
                 case ForgeParser.ALWAYS_TOK:
                     this.enterOuterAlt(_localctx, 3);
                     {
-                        this.state = 731;
-                        this.match(ForgeParser.ALWAYS_TOK);
                         this.state = 732;
+                        this.match(ForgeParser.ALWAYS_TOK);
+                        this.state = 733;
                         this.expr5();
                     }
                     break;
                 case ForgeParser.EVENTUALLY_TOK:
                     this.enterOuterAlt(_localctx, 4);
                     {
-                        this.state = 733;
-                        this.match(ForgeParser.EVENTUALLY_TOK);
                         this.state = 734;
+                        this.match(ForgeParser.EVENTUALLY_TOK);
+                        this.state = 735;
                         this.expr5();
                     }
                     break;
                 case ForgeParser.AFTER_TOK:
                     this.enterOuterAlt(_localctx, 5);
                     {
-                        this.state = 735;
-                        this.match(ForgeParser.AFTER_TOK);
                         this.state = 736;
+                        this.match(ForgeParser.AFTER_TOK);
+                        this.state = 737;
                         this.expr5();
                     }
                     break;
                 case ForgeParser.BEFORE_TOK:
                     this.enterOuterAlt(_localctx, 6);
                     {
-                        this.state = 737;
-                        this.match(ForgeParser.BEFORE_TOK);
                         this.state = 738;
+                        this.match(ForgeParser.BEFORE_TOK);
+                        this.state = 739;
                         this.expr5();
                     }
                     break;
                 case ForgeParser.ONCE_TOK:
                     this.enterOuterAlt(_localctx, 7);
                     {
-                        this.state = 739;
-                        this.match(ForgeParser.ONCE_TOK);
                         this.state = 740;
+                        this.match(ForgeParser.ONCE_TOK);
+                        this.state = 741;
                         this.expr5();
                     }
                     break;
                 case ForgeParser.HISTORICALLY_TOK:
                     this.enterOuterAlt(_localctx, 8);
                     {
-                        this.state = 741;
-                        this.match(ForgeParser.HISTORICALLY_TOK);
                         this.state = 742;
+                        this.match(ForgeParser.HISTORICALLY_TOK);
+                        this.state = 743;
                         this.expr5();
                     }
                     break;
@@ -56953,11 +57322,11 @@ class ForgeParser extends Parser_1.Parser {
             this.enterOuterAlt(_localctx, 1);
             {
                 {
-                    this.state = 746;
+                    this.state = 747;
                     this.expr7();
                 }
                 this._ctx._stop = this._input.tryLT(-1);
-                this.state = 757;
+                this.state = 758;
                 this._errHandler.sync(this);
                 _alt = this.interpreter.adaptivePredict(this._input, 89, this._ctx);
                 while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
@@ -56970,27 +57339,27 @@ class ForgeParser extends Parser_1.Parser {
                             {
                                 _localctx = new Expr6Context(_parentctx, _parentState);
                                 this.pushNewRecursionContext(_localctx, _startState, ForgeParser.RULE_expr6);
-                                this.state = 748;
+                                this.state = 749;
                                 if (!(this.precpred(this._ctx, 1))) {
                                     throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
                                 }
-                                this.state = 750;
+                                this.state = 751;
                                 this._errHandler.sync(this);
                                 _la = this._input.LA(1);
                                 if (_la === ForgeParser.NEG_TOK) {
                                     {
-                                        this.state = 749;
+                                        this.state = 750;
                                         this.match(ForgeParser.NEG_TOK);
                                     }
                                 }
-                                this.state = 752;
-                                this.compareOp();
                                 this.state = 753;
+                                this.compareOp();
+                                this.state = 754;
                                 this.expr7();
                             }
                         }
                     }
-                    this.state = 759;
+                    this.state = 760;
                     this._errHandler.sync(this);
                     _alt = this.interpreter.adaptivePredict(this._input, 89, this._ctx);
                 }
@@ -57017,9 +57386,10 @@ class ForgeParser extends Parser_1.Parser {
         this.enterRule(_localctx, 112, ForgeParser.RULE_expr7);
         let _la;
         try {
-            this.state = 763;
+            this.state = 764;
             this._errHandler.sync(this);
             switch (this._input.LA(1)) {
+                case ForgeParser.STRING_TOK:
                 case ForgeParser.LEFT_CURLY_TOK:
                 case ForgeParser.LEFT_PAREN_TOK:
                 case ForgeParser.NONE_TOK:
@@ -57045,7 +57415,7 @@ class ForgeParser extends Parser_1.Parser {
                 case ForgeParser.IDENTIFIER_TOK:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 760;
+                        this.state = 761;
                         this.expr8(0);
                     }
                     break;
@@ -57057,7 +57427,7 @@ class ForgeParser extends Parser_1.Parser {
                 case ForgeParser.NO_TOK:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 761;
+                        this.state = 762;
                         _la = this._input.LA(1);
                         if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << ForgeParser.LONE_TOK) | (1 << ForgeParser.SOME_TOK) | (1 << ForgeParser.ONE_TOK) | (1 << ForgeParser.TWO_TOK) | (1 << ForgeParser.SET_TOK))) !== 0) || _la === ForgeParser.NO_TOK)) {
                             this._errHandler.recoverInline(this);
@@ -57069,7 +57439,7 @@ class ForgeParser extends Parser_1.Parser {
                             this._errHandler.reportMatch(this);
                             this.consume();
                         }
-                        this.state = 762;
+                        this.state = 763;
                         this.expr8(0);
                     }
                     break;
@@ -57109,11 +57479,11 @@ class ForgeParser extends Parser_1.Parser {
             this.enterOuterAlt(_localctx, 1);
             {
                 {
-                    this.state = 766;
+                    this.state = 767;
                     this.expr9();
                 }
                 this._ctx._stop = this._input.tryLT(-1);
-                this.state = 773;
+                this.state = 774;
                 this._errHandler.sync(this);
                 _alt = this.interpreter.adaptivePredict(this._input, 91, this._ctx);
                 while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
@@ -57126,11 +57496,11 @@ class ForgeParser extends Parser_1.Parser {
                             {
                                 _localctx = new Expr8Context(_parentctx, _parentState);
                                 this.pushNewRecursionContext(_localctx, _startState, ForgeParser.RULE_expr8);
-                                this.state = 768;
+                                this.state = 769;
                                 if (!(this.precpred(this._ctx, 1))) {
                                     throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
                                 }
-                                this.state = 769;
+                                this.state = 770;
                                 _la = this._input.LA(1);
                                 if (!(_la === ForgeParser.PLUS_TOK || _la === ForgeParser.MINUS_TOK)) {
                                     this._errHandler.recoverInline(this);
@@ -57142,12 +57512,12 @@ class ForgeParser extends Parser_1.Parser {
                                     this._errHandler.reportMatch(this);
                                     this.consume();
                                 }
-                                this.state = 770;
+                                this.state = 771;
                                 this.expr10(0);
                             }
                         }
                     }
-                    this.state = 775;
+                    this.state = 776;
                     this._errHandler.sync(this);
                     _alt = this.interpreter.adaptivePredict(this._input, 91, this._ctx);
                 }
@@ -57173,9 +57543,10 @@ class ForgeParser extends Parser_1.Parser {
         let _localctx = new Expr9Context(this._ctx, this.state);
         this.enterRule(_localctx, 116, ForgeParser.RULE_expr9);
         try {
-            this.state = 779;
+            this.state = 780;
             this._errHandler.sync(this);
             switch (this._input.LA(1)) {
+                case ForgeParser.STRING_TOK:
                 case ForgeParser.LEFT_CURLY_TOK:
                 case ForgeParser.LEFT_PAREN_TOK:
                 case ForgeParser.NONE_TOK:
@@ -57200,16 +57571,16 @@ class ForgeParser extends Parser_1.Parser {
                 case ForgeParser.IDENTIFIER_TOK:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 776;
+                        this.state = 777;
                         this.expr10(0);
                     }
                     break;
                 case ForgeParser.CARD_TOK:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 777;
-                        this.match(ForgeParser.CARD_TOK);
                         this.state = 778;
+                        this.match(ForgeParser.CARD_TOK);
+                        this.state = 779;
                         this.expr9();
                     }
                     break;
@@ -57248,11 +57619,11 @@ class ForgeParser extends Parser_1.Parser {
             this.enterOuterAlt(_localctx, 1);
             {
                 {
-                    this.state = 782;
+                    this.state = 783;
                     this.expr11(0);
                 }
                 this._ctx._stop = this._input.tryLT(-1);
-                this.state = 789;
+                this.state = 790;
                 this._errHandler.sync(this);
                 _alt = this.interpreter.adaptivePredict(this._input, 93, this._ctx);
                 while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
@@ -57265,18 +57636,18 @@ class ForgeParser extends Parser_1.Parser {
                             {
                                 _localctx = new Expr10Context(_parentctx, _parentState);
                                 this.pushNewRecursionContext(_localctx, _startState, ForgeParser.RULE_expr10);
-                                this.state = 784;
+                                this.state = 785;
                                 if (!(this.precpred(this._ctx, 1))) {
                                     throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
                                 }
-                                this.state = 785;
-                                this.match(ForgeParser.PPLUS_TOK);
                                 this.state = 786;
+                                this.match(ForgeParser.PPLUS_TOK);
+                                this.state = 787;
                                 this.expr11(0);
                             }
                         }
                     }
-                    this.state = 791;
+                    this.state = 792;
                     this._errHandler.sync(this);
                     _alt = this.interpreter.adaptivePredict(this._input, 93, this._ctx);
                 }
@@ -57313,11 +57684,11 @@ class ForgeParser extends Parser_1.Parser {
             this.enterOuterAlt(_localctx, 1);
             {
                 {
-                    this.state = 793;
+                    this.state = 794;
                     this.expr12(0);
                 }
                 this._ctx._stop = this._input.tryLT(-1);
-                this.state = 800;
+                this.state = 801;
                 this._errHandler.sync(this);
                 _alt = this.interpreter.adaptivePredict(this._input, 94, this._ctx);
                 while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
@@ -57330,18 +57701,18 @@ class ForgeParser extends Parser_1.Parser {
                             {
                                 _localctx = new Expr11Context(_parentctx, _parentState);
                                 this.pushNewRecursionContext(_localctx, _startState, ForgeParser.RULE_expr11);
-                                this.state = 795;
+                                this.state = 796;
                                 if (!(this.precpred(this._ctx, 1))) {
                                     throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
                                 }
-                                this.state = 796;
-                                this.match(ForgeParser.AMP_TOK);
                                 this.state = 797;
+                                this.match(ForgeParser.AMP_TOK);
+                                this.state = 798;
                                 this.expr12(0);
                             }
                         }
                     }
-                    this.state = 802;
+                    this.state = 803;
                     this._errHandler.sync(this);
                     _alt = this.interpreter.adaptivePredict(this._input, 94, this._ctx);
                 }
@@ -57378,11 +57749,11 @@ class ForgeParser extends Parser_1.Parser {
             this.enterOuterAlt(_localctx, 1);
             {
                 {
-                    this.state = 804;
+                    this.state = 805;
                     this.expr13(0);
                 }
                 this._ctx._stop = this._input.tryLT(-1);
-                this.state = 812;
+                this.state = 813;
                 this._errHandler.sync(this);
                 _alt = this.interpreter.adaptivePredict(this._input, 95, this._ctx);
                 while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
@@ -57395,18 +57766,18 @@ class ForgeParser extends Parser_1.Parser {
                             {
                                 _localctx = new Expr12Context(_parentctx, _parentState);
                                 this.pushNewRecursionContext(_localctx, _startState, ForgeParser.RULE_expr12);
-                                this.state = 806;
+                                this.state = 807;
                                 if (!(this.precpred(this._ctx, 1))) {
                                     throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
                                 }
-                                this.state = 807;
-                                this.arrowOp();
                                 this.state = 808;
+                                this.arrowOp();
+                                this.state = 809;
                                 this.expr13(0);
                             }
                         }
                     }
-                    this.state = 814;
+                    this.state = 815;
                     this._errHandler.sync(this);
                     _alt = this.interpreter.adaptivePredict(this._input, 95, this._ctx);
                 }
@@ -57444,11 +57815,11 @@ class ForgeParser extends Parser_1.Parser {
             this.enterOuterAlt(_localctx, 1);
             {
                 {
-                    this.state = 816;
+                    this.state = 817;
                     this.expr14(0);
                 }
                 this._ctx._stop = this._input.tryLT(-1);
-                this.state = 823;
+                this.state = 824;
                 this._errHandler.sync(this);
                 _alt = this.interpreter.adaptivePredict(this._input, 96, this._ctx);
                 while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
@@ -57461,11 +57832,11 @@ class ForgeParser extends Parser_1.Parser {
                             {
                                 _localctx = new Expr13Context(_parentctx, _parentState);
                                 this.pushNewRecursionContext(_localctx, _startState, ForgeParser.RULE_expr13);
-                                this.state = 818;
+                                this.state = 819;
                                 if (!(this.precpred(this._ctx, 1))) {
                                     throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
                                 }
-                                this.state = 819;
+                                this.state = 820;
                                 _la = this._input.LA(1);
                                 if (!(_la === ForgeParser.SUBT_TOK || _la === ForgeParser.SUPT_TOK)) {
                                     this._errHandler.recoverInline(this);
@@ -57477,12 +57848,12 @@ class ForgeParser extends Parser_1.Parser {
                                     this._errHandler.reportMatch(this);
                                     this.consume();
                                 }
-                                this.state = 820;
+                                this.state = 821;
                                 this.expr14(0);
                             }
                         }
                     }
-                    this.state = 825;
+                    this.state = 826;
                     this._errHandler.sync(this);
                     _alt = this.interpreter.adaptivePredict(this._input, 96, this._ctx);
                 }
@@ -57519,11 +57890,11 @@ class ForgeParser extends Parser_1.Parser {
             this.enterOuterAlt(_localctx, 1);
             {
                 {
-                    this.state = 827;
+                    this.state = 828;
                     this.expr15(0);
                 }
                 this._ctx._stop = this._input.tryLT(-1);
-                this.state = 836;
+                this.state = 837;
                 this._errHandler.sync(this);
                 _alt = this.interpreter.adaptivePredict(this._input, 97, this._ctx);
                 while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
@@ -57536,20 +57907,20 @@ class ForgeParser extends Parser_1.Parser {
                             {
                                 _localctx = new Expr14Context(_parentctx, _parentState);
                                 this.pushNewRecursionContext(_localctx, _startState, ForgeParser.RULE_expr14);
-                                this.state = 829;
+                                this.state = 830;
                                 if (!(this.precpred(this._ctx, 1))) {
                                     throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
                                 }
-                                this.state = 830;
-                                this.match(ForgeParser.LEFT_SQUARE_TOK);
                                 this.state = 831;
-                                this.exprList();
+                                this.match(ForgeParser.LEFT_SQUARE_TOK);
                                 this.state = 832;
+                                this.exprList();
+                                this.state = 833;
                                 this.match(ForgeParser.RIGHT_SQUARE_TOK);
                             }
                         }
                     }
-                    this.state = 838;
+                    this.state = 839;
                     this._errHandler.sync(this);
                     _alt = this.interpreter.adaptivePredict(this._input, 97, this._ctx);
                 }
@@ -57585,30 +57956,30 @@ class ForgeParser extends Parser_1.Parser {
             let _alt;
             this.enterOuterAlt(_localctx, 1);
             {
-                this.state = 846;
+                this.state = 847;
                 this._errHandler.sync(this);
                 switch (this.interpreter.adaptivePredict(this._input, 98, this._ctx)) {
                     case 1:
                         {
-                            this.state = 840;
+                            this.state = 841;
                             this.expr16(0);
                         }
                         break;
                     case 2:
                         {
-                            this.state = 841;
-                            this.name();
                             this.state = 842;
-                            this.match(ForgeParser.LEFT_SQUARE_TOK);
+                            this.name();
                             this.state = 843;
-                            this.exprList();
+                            this.match(ForgeParser.LEFT_SQUARE_TOK);
                             this.state = 844;
+                            this.exprList();
+                            this.state = 845;
                             this.match(ForgeParser.RIGHT_SQUARE_TOK);
                         }
                         break;
                 }
                 this._ctx._stop = this._input.tryLT(-1);
-                this.state = 853;
+                this.state = 854;
                 this._errHandler.sync(this);
                 _alt = this.interpreter.adaptivePredict(this._input, 99, this._ctx);
                 while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
@@ -57621,18 +57992,18 @@ class ForgeParser extends Parser_1.Parser {
                             {
                                 _localctx = new Expr15Context(_parentctx, _parentState);
                                 this.pushNewRecursionContext(_localctx, _startState, ForgeParser.RULE_expr15);
-                                this.state = 848;
+                                this.state = 849;
                                 if (!(this.precpred(this._ctx, 2))) {
                                     throw this.createFailedPredicateException("this.precpred(this._ctx, 2)");
                                 }
-                                this.state = 849;
-                                this.match(ForgeParser.DOT_TOK);
                                 this.state = 850;
+                                this.match(ForgeParser.DOT_TOK);
+                                this.state = 851;
                                 this.expr16(0);
                             }
                         }
                     }
-                    this.state = 855;
+                    this.state = 856;
                     this._errHandler.sync(this);
                     _alt = this.interpreter.adaptivePredict(this._input, 99, this._ctx);
                 }
@@ -57669,11 +58040,11 @@ class ForgeParser extends Parser_1.Parser {
             this.enterOuterAlt(_localctx, 1);
             {
                 {
-                    this.state = 857;
+                    this.state = 858;
                     this.expr17();
                 }
                 this._ctx._stop = this._input.tryLT(-1);
-                this.state = 863;
+                this.state = 864;
                 this._errHandler.sync(this);
                 _alt = this.interpreter.adaptivePredict(this._input, 100, this._ctx);
                 while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
@@ -57686,16 +58057,16 @@ class ForgeParser extends Parser_1.Parser {
                             {
                                 _localctx = new Expr16Context(_parentctx, _parentState);
                                 this.pushNewRecursionContext(_localctx, _startState, ForgeParser.RULE_expr16);
-                                this.state = 859;
+                                this.state = 860;
                                 if (!(this.precpred(this._ctx, 1))) {
                                     throw this.createFailedPredicateException("this.precpred(this._ctx, 1)");
                                 }
-                                this.state = 860;
+                                this.state = 861;
                                 this.match(ForgeParser.PRIME_TOK);
                             }
                         }
                     }
-                    this.state = 865;
+                    this.state = 866;
                     this._errHandler.sync(this);
                     _alt = this.interpreter.adaptivePredict(this._input, 100, this._ctx);
                 }
@@ -57722,9 +58093,10 @@ class ForgeParser extends Parser_1.Parser {
         this.enterRule(_localctx, 132, ForgeParser.RULE_expr17);
         let _la;
         try {
-            this.state = 869;
+            this.state = 870;
             this._errHandler.sync(this);
             switch (this._input.LA(1)) {
+                case ForgeParser.STRING_TOK:
                 case ForgeParser.LEFT_CURLY_TOK:
                 case ForgeParser.LEFT_PAREN_TOK:
                 case ForgeParser.NONE_TOK:
@@ -57742,7 +58114,7 @@ class ForgeParser extends Parser_1.Parser {
                 case ForgeParser.IDENTIFIER_TOK:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 866;
+                        this.state = 867;
                         this.expr18();
                     }
                     break;
@@ -57755,7 +58127,7 @@ class ForgeParser extends Parser_1.Parser {
                 case ForgeParser.GET_LABEL_NUM_TOK:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 867;
+                        this.state = 868;
                         _la = this._input.LA(1);
                         if (!(((((_la - 80)) & ~0x1F) === 0 && ((1 << (_la - 80)) & ((1 << (ForgeParser.TILDE_TOK - 80)) | (1 << (ForgeParser.EXP_TOK - 80)) | (1 << (ForgeParser.STAR_TOK - 80)) | (1 << (ForgeParser.GET_LABEL_TOK - 80)) | (1 << (ForgeParser.GET_LABEL_STR_TOK - 80)) | (1 << (ForgeParser.GET_LABEL_BOOL_TOK - 80)) | (1 << (ForgeParser.GET_LABEL_NUM_TOK - 80)))) !== 0))) {
                             this._errHandler.recoverInline(this);
@@ -57767,7 +58139,7 @@ class ForgeParser extends Parser_1.Parser {
                             this._errHandler.reportMatch(this);
                             this.consume();
                         }
-                        this.state = 868;
+                        this.state = 869;
                         this.expr17();
                     }
                     break;
@@ -57795,83 +58167,83 @@ class ForgeParser extends Parser_1.Parser {
         let _localctx = new Expr18Context(this._ctx, this.state);
         this.enterRule(_localctx, 134, ForgeParser.RULE_expr18);
         try {
-            this.state = 889;
+            this.state = 890;
             this._errHandler.sync(this);
             switch (this.interpreter.adaptivePredict(this._input, 102, this._ctx)) {
                 case 1:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 871;
+                        this.state = 872;
                         this.const();
                     }
                     break;
                 case 2:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 872;
+                        this.state = 873;
                         this.qualName();
                     }
                     break;
                 case 3:
                     this.enterOuterAlt(_localctx, 3);
                     {
-                        this.state = 873;
-                        this.match(ForgeParser.AT_TOK);
                         this.state = 874;
+                        this.match(ForgeParser.AT_TOK);
+                        this.state = 875;
                         this.name();
                     }
                     break;
                 case 4:
                     this.enterOuterAlt(_localctx, 4);
                     {
-                        this.state = 875;
-                        this.match(ForgeParser.BACKQUOTE_TOK);
                         this.state = 876;
+                        this.match(ForgeParser.BACKQUOTE_TOK);
+                        this.state = 877;
                         this.name();
                     }
                     break;
                 case 5:
                     this.enterOuterAlt(_localctx, 5);
                     {
-                        this.state = 877;
+                        this.state = 878;
                         this.match(ForgeParser.THIS_TOK);
                     }
                     break;
                 case 6:
                     this.enterOuterAlt(_localctx, 6);
                     {
-                        this.state = 878;
-                        this.match(ForgeParser.LEFT_CURLY_TOK);
                         this.state = 879;
-                        this.quantDeclList();
+                        this.match(ForgeParser.LEFT_CURLY_TOK);
                         this.state = 880;
-                        this.blockOrBar();
+                        this.quantDeclList();
                         this.state = 881;
+                        this.blockOrBar();
+                        this.state = 882;
                         this.match(ForgeParser.RIGHT_CURLY_TOK);
                     }
                     break;
                 case 7:
                     this.enterOuterAlt(_localctx, 7);
                     {
-                        this.state = 883;
-                        this.match(ForgeParser.LEFT_PAREN_TOK);
                         this.state = 884;
-                        this.expr();
+                        this.match(ForgeParser.LEFT_PAREN_TOK);
                         this.state = 885;
+                        this.expr();
+                        this.state = 886;
                         this.match(ForgeParser.RIGHT_PAREN_TOK);
                     }
                     break;
                 case 8:
                     this.enterOuterAlt(_localctx, 8);
                     {
-                        this.state = 887;
+                        this.state = 888;
                         this.block();
                     }
                     break;
                 case 9:
                     this.enterOuterAlt(_localctx, 9);
                     {
-                        this.state = 888;
+                        this.state = 889;
                         this.sexpr();
                     }
                     break;
@@ -57897,24 +58269,24 @@ class ForgeParser extends Parser_1.Parser {
         let _localctx = new ArrowExprContext(this._ctx, this.state);
         this.enterRule(_localctx, 136, ForgeParser.RULE_arrowExpr);
         try {
-            this.state = 896;
+            this.state = 897;
             this._errHandler.sync(this);
             switch (this.interpreter.adaptivePredict(this._input, 103, this._ctx)) {
                 case 1:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 891;
+                        this.state = 892;
                         this.qualName();
                     }
                     break;
                 case 2:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 892;
-                        this.qualName();
                         this.state = 893;
-                        this.match(ForgeParser.ARROW_TOK);
+                        this.qualName();
                         this.state = 894;
+                        this.match(ForgeParser.ARROW_TOK);
+                        this.state = 895;
                         this.arrowExpr();
                     }
                     break;
@@ -57942,7 +58314,7 @@ class ForgeParser extends Parser_1.Parser {
         try {
             this.enterOuterAlt(_localctx, 1);
             {
-                this.state = 898;
+                this.state = 899;
                 this.sexpr();
             }
         }
@@ -57968,7 +58340,7 @@ class ForgeParser extends Parser_1.Parser {
         try {
             this.enterOuterAlt(_localctx, 1);
             {
-                this.state = 900;
+                this.state = 901;
                 this.match(ForgeParser.SEXPR_TOK);
             }
         }
@@ -57995,18 +58367,18 @@ class ForgeParser extends Parser_1.Parser {
         try {
             this.enterOuterAlt(_localctx, 1);
             {
-                this.state = 902;
-                this.match(ForgeParser.INST_TOK);
                 this.state = 903;
-                this.name();
+                this.match(ForgeParser.INST_TOK);
                 this.state = 904;
+                this.name();
+                this.state = 905;
                 this.bounds();
-                this.state = 906;
+                this.state = 907;
                 this._errHandler.sync(this);
                 _la = this._input.LA(1);
                 if (_la === ForgeParser.FOR_TOK) {
                     {
-                        this.state = 905;
+                        this.state = 906;
                         this.scope();
                     }
                 }
@@ -58034,7 +58406,7 @@ class ForgeParser extends Parser_1.Parser {
         try {
             this.enterOuterAlt(_localctx, 1);
             {
-                this.state = 908;
+                this.state = 909;
                 this.arrowDecl();
             }
         }
@@ -58060,9 +58432,9 @@ class ForgeParser extends Parser_1.Parser {
         try {
             this.enterOuterAlt(_localctx, 1);
             {
-                this.state = 910;
-                this.match(ForgeParser.EVAL_TOK);
                 this.state = 911;
+                this.match(ForgeParser.EVAL_TOK);
+                this.state = 912;
                 this.expr();
             }
         }
@@ -58088,17 +58460,17 @@ class ForgeParser extends Parser_1.Parser {
         try {
             this.enterOuterAlt(_localctx, 1);
             {
-                this.state = 913;
-                this.match(ForgeParser.EXAMPLE_TOK);
                 this.state = 914;
-                this.name();
+                this.match(ForgeParser.EXAMPLE_TOK);
                 this.state = 915;
-                this.match(ForgeParser.IS_TOK);
+                this.name();
                 this.state = 916;
-                this.expr();
+                this.match(ForgeParser.IS_TOK);
                 this.state = 917;
-                this.match(ForgeParser.FOR_TOK);
+                this.expr();
                 this.state = 918;
+                this.match(ForgeParser.FOR_TOK);
+                this.state = 919;
                 this.bounds();
             }
         }
@@ -58124,15 +58496,15 @@ class ForgeParser extends Parser_1.Parser {
         try {
             this.enterOuterAlt(_localctx, 1);
             {
-                this.state = 920;
-                this.name();
                 this.state = 921;
-                this.match(ForgeParser.COLON_TOK);
+                this.name();
                 this.state = 922;
-                this.arrowExpr();
+                this.match(ForgeParser.COLON_TOK);
                 this.state = 923;
-                this.match(ForgeParser.EQ_TOK);
+                this.arrowExpr();
                 this.state = 924;
+                this.match(ForgeParser.EQ_TOK);
+                this.state = 925;
                 this.expr();
             }
         }
@@ -58156,24 +58528,24 @@ class ForgeParser extends Parser_1.Parser {
         let _localctx = new NumberListContext(this._ctx, this.state);
         this.enterRule(_localctx, 152, ForgeParser.RULE_numberList);
         try {
-            this.state = 931;
+            this.state = 932;
             this._errHandler.sync(this);
             switch (this.interpreter.adaptivePredict(this._input, 105, this._ctx)) {
                 case 1:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 926;
+                        this.state = 927;
                         this.number();
                     }
                     break;
                 case 2:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 927;
-                        this.number();
                         this.state = 928;
-                        this.match(ForgeParser.COMMA_TOK);
+                        this.number();
                         this.state = 929;
+                        this.match(ForgeParser.COMMA_TOK);
+                        this.state = 930;
                         this.numberList();
                     }
                     break;
@@ -58201,7 +58573,7 @@ class ForgeParser extends Parser_1.Parser {
         try {
             this.enterOuterAlt(_localctx, 1);
             {
-                this.state = 933;
+                this.state = 934;
                 this.match(ForgeParser.NUM_CONST_TOK);
             }
         }
@@ -58226,29 +58598,29 @@ class ForgeParser extends Parser_1.Parser {
         this.enterRule(_localctx, 156, ForgeParser.RULE_bounds);
         let _la;
         try {
-            this.state = 947;
+            this.state = 948;
             this._errHandler.sync(this);
             switch (this._input.LA(1)) {
                 case ForgeParser.LEFT_CURLY_TOK:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 935;
+                        this.state = 936;
                         this.match(ForgeParser.LEFT_CURLY_TOK);
-                        this.state = 939;
+                        this.state = 940;
                         this._errHandler.sync(this);
                         _la = this._input.LA(1);
                         while (_la === ForgeParser.MINUS_TOK || ((((_la - 74)) & ~0x1F) === 0 && ((1 << (_la - 74)) & ((1 << (ForgeParser.CARD_TOK - 74)) | (1 << (ForgeParser.BACKQUOTE_TOK - 74)) | (1 << (ForgeParser.THIS_TOK - 74)) | (1 << (ForgeParser.NO_TOK - 74)) | (1 << (ForgeParser.SUM_TOK - 74)) | (1 << (ForgeParser.INT_TOK - 74)))) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & ((1 << (ForgeParser.NUM_CONST_TOK - 107)) | (1 << (ForgeParser.QUOTED_IDENTIFIER_TOK - 107)) | (1 << (ForgeParser.IDENTIFIER_TOK - 107)))) !== 0)) {
                             {
                                 {
-                                    this.state = 936;
+                                    this.state = 937;
                                     this.bound();
                                 }
                             }
-                            this.state = 941;
+                            this.state = 942;
                             this._errHandler.sync(this);
                             _la = this._input.LA(1);
                         }
-                        this.state = 942;
+                        this.state = 943;
                         this.match(ForgeParser.RIGHT_CURLY_TOK);
                     }
                     break;
@@ -58260,16 +58632,16 @@ class ForgeParser extends Parser_1.Parser {
                 case ForgeParser.IDENTIFIER_TOK:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 944;
+                        this.state = 945;
                         this._errHandler.sync(this);
                         _la = this._input.LA(1);
                         if (_la === ForgeParser.EXACTLY_TOK) {
                             {
-                                this.state = 943;
+                                this.state = 944;
                                 this.match(ForgeParser.EXACTLY_TOK);
                             }
                         }
-                        this.state = 946;
+                        this.state = 947;
                         this.qualName();
                     }
                     break;
@@ -58297,31 +58669,31 @@ class ForgeParser extends Parser_1.Parser {
         let _localctx = new AtomNameOrNumberContext(this._ctx, this.state);
         this.enterRule(_localctx, 158, ForgeParser.RULE_atomNameOrNumber);
         try {
-            this.state = 954;
+            this.state = 955;
             this._errHandler.sync(this);
             switch (this._input.LA(1)) {
                 case ForgeParser.BACKQUOTE_TOK:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 949;
-                        this.match(ForgeParser.BACKQUOTE_TOK);
                         this.state = 950;
+                        this.match(ForgeParser.BACKQUOTE_TOK);
+                        this.state = 951;
                         this.name();
                     }
                     break;
                 case ForgeParser.NUM_CONST_TOK:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 951;
+                        this.state = 952;
                         this.number();
                     }
                     break;
                 case ForgeParser.MINUS_TOK:
                     this.enterOuterAlt(_localctx, 3);
                     {
-                        this.state = 952;
-                        this.match(ForgeParser.MINUS_TOK);
                         this.state = 953;
+                        this.match(ForgeParser.MINUS_TOK);
+                        this.state = 954;
                         this.number();
                     }
                     break;
@@ -58349,33 +58721,33 @@ class ForgeParser extends Parser_1.Parser {
         let _localctx = new BoundContext(this._ctx, this.state);
         this.enterRule(_localctx, 160, ForgeParser.RULE_bound);
         try {
-            this.state = 963;
+            this.state = 964;
             this._errHandler.sync(this);
             switch (this.interpreter.adaptivePredict(this._input, 110, this._ctx)) {
                 case 1:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 956;
-                        this.boundLHS();
                         this.state = 957;
-                        this.compareOp();
+                        this.boundLHS();
                         this.state = 958;
+                        this.compareOp();
+                        this.state = 959;
                         this.bindRHSUnion(0);
                     }
                     break;
                 case 2:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 960;
-                        this.match(ForgeParser.NO_TOK);
                         this.state = 961;
+                        this.match(ForgeParser.NO_TOK);
+                        this.state = 962;
                         this.boundLHS();
                     }
                     break;
                 case 3:
                     this.enterOuterAlt(_localctx, 3);
                     {
-                        this.state = 962;
+                        this.state = 963;
                         this.qualName();
                     }
                     break;
@@ -58402,15 +58774,15 @@ class ForgeParser extends Parser_1.Parser {
         this.enterRule(_localctx, 162, ForgeParser.RULE_boundLHS);
         let _la;
         try {
-            this.state = 975;
+            this.state = 976;
             this._errHandler.sync(this);
             switch (this._input.LA(1)) {
                 case ForgeParser.CARD_TOK:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 965;
-                        this.match(ForgeParser.CARD_TOK);
                         this.state = 966;
+                        this.match(ForgeParser.CARD_TOK);
+                        this.state = 967;
                         this.qualName();
                     }
                     break;
@@ -58421,7 +58793,7 @@ class ForgeParser extends Parser_1.Parser {
                 case ForgeParser.IDENTIFIER_TOK:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 967;
+                        this.state = 968;
                         this.qualName();
                     }
                     break;
@@ -58430,21 +58802,21 @@ class ForgeParser extends Parser_1.Parser {
                 case ForgeParser.NUM_CONST_TOK:
                     this.enterOuterAlt(_localctx, 3);
                     {
-                        this.state = 968;
+                        this.state = 969;
                         this.atomNameOrNumber();
-                        this.state = 971;
+                        this.state = 972;
                         this._errHandler.sync(this);
                         _la = this._input.LA(1);
                         do {
                             {
                                 {
-                                    this.state = 969;
-                                    this.match(ForgeParser.DOT_TOK);
                                     this.state = 970;
+                                    this.match(ForgeParser.DOT_TOK);
+                                    this.state = 971;
                                     this.qualName();
                                 }
                             }
-                            this.state = 973;
+                            this.state = 974;
                             this._errHandler.sync(this);
                             _la = this._input.LA(1);
                         } while (_la === ForgeParser.DOT_TOK);
@@ -58484,28 +58856,28 @@ class ForgeParser extends Parser_1.Parser {
             let _alt;
             this.enterOuterAlt(_localctx, 1);
             {
-                this.state = 983;
+                this.state = 984;
                 this._errHandler.sync(this);
                 switch (this.interpreter.adaptivePredict(this._input, 113, this._ctx)) {
                     case 1:
                         {
-                            this.state = 978;
+                            this.state = 979;
                             this.bindRHSProduct(0);
                         }
                         break;
                     case 2:
                         {
-                            this.state = 979;
-                            this.match(ForgeParser.LEFT_PAREN_TOK);
                             this.state = 980;
-                            this.bindRHSUnion(0);
+                            this.match(ForgeParser.LEFT_PAREN_TOK);
                             this.state = 981;
+                            this.bindRHSUnion(0);
+                            this.state = 982;
                             this.match(ForgeParser.RIGHT_PAREN_TOK);
                         }
                         break;
                 }
                 this._ctx._stop = this._input.tryLT(-1);
-                this.state = 990;
+                this.state = 991;
                 this._errHandler.sync(this);
                 _alt = this.interpreter.adaptivePredict(this._input, 114, this._ctx);
                 while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
@@ -58518,18 +58890,18 @@ class ForgeParser extends Parser_1.Parser {
                             {
                                 _localctx = new BindRHSUnionContext(_parentctx, _parentState);
                                 this.pushNewRecursionContext(_localctx, _startState, ForgeParser.RULE_bindRHSUnion);
-                                this.state = 985;
+                                this.state = 986;
                                 if (!(this.precpred(this._ctx, 2))) {
                                     throw this.createFailedPredicateException("this.precpred(this._ctx, 2)");
                                 }
-                                this.state = 986;
-                                this.match(ForgeParser.PLUS_TOK);
                                 this.state = 987;
+                                this.match(ForgeParser.PLUS_TOK);
+                                this.state = 988;
                                 this.bindRHSProduct(0);
                             }
                         }
                     }
-                    this.state = 992;
+                    this.state = 993;
                     this._errHandler.sync(this);
                     _alt = this.interpreter.adaptivePredict(this._input, 114, this._ctx);
                 }
@@ -58566,28 +58938,28 @@ class ForgeParser extends Parser_1.Parser {
             let _alt;
             this.enterOuterAlt(_localctx, 1);
             {
-                this.state = 999;
+                this.state = 1000;
                 this._errHandler.sync(this);
                 switch (this.interpreter.adaptivePredict(this._input, 115, this._ctx)) {
                     case 1:
                         {
-                            this.state = 994;
-                            this.match(ForgeParser.LEFT_PAREN_TOK);
                             this.state = 995;
-                            this.bindRHSProduct(0);
+                            this.match(ForgeParser.LEFT_PAREN_TOK);
                             this.state = 996;
+                            this.bindRHSProduct(0);
+                            this.state = 997;
                             this.match(ForgeParser.RIGHT_PAREN_TOK);
                         }
                         break;
                     case 2:
                         {
-                            this.state = 998;
+                            this.state = 999;
                             this.bindRHSProductBase();
                         }
                         break;
                 }
                 this._ctx._stop = this._input.tryLT(-1);
-                this.state = 1006;
+                this.state = 1007;
                 this._errHandler.sync(this);
                 _alt = this.interpreter.adaptivePredict(this._input, 116, this._ctx);
                 while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
@@ -58600,11 +58972,11 @@ class ForgeParser extends Parser_1.Parser {
                             {
                                 _localctx = new BindRHSProductContext(_parentctx, _parentState);
                                 this.pushNewRecursionContext(_localctx, _startState, ForgeParser.RULE_bindRHSProduct);
-                                this.state = 1001;
+                                this.state = 1002;
                                 if (!(this.precpred(this._ctx, 2))) {
                                     throw this.createFailedPredicateException("this.precpred(this._ctx, 2)");
                                 }
-                                this.state = 1002;
+                                this.state = 1003;
                                 _la = this._input.LA(1);
                                 if (!(_la === ForgeParser.ARROW_TOK || _la === ForgeParser.COMMA_TOK)) {
                                     this._errHandler.recoverInline(this);
@@ -58616,12 +58988,12 @@ class ForgeParser extends Parser_1.Parser {
                                     this._errHandler.reportMatch(this);
                                     this.consume();
                                 }
-                                this.state = 1003;
+                                this.state = 1004;
                                 this.bindRHSProductBase();
                             }
                         }
                     }
-                    this.state = 1008;
+                    this.state = 1009;
                     this._errHandler.sync(this);
                     _alt = this.interpreter.adaptivePredict(this._input, 116, this._ctx);
                 }
@@ -58647,7 +59019,7 @@ class ForgeParser extends Parser_1.Parser {
         let _localctx = new BindRHSProductBaseContext(this._ctx, this.state);
         this.enterRule(_localctx, 168, ForgeParser.RULE_bindRHSProductBase);
         try {
-            this.state = 1015;
+            this.state = 1016;
             this._errHandler.sync(this);
             switch (this._input.LA(1)) {
                 case ForgeParser.MINUS_TOK:
@@ -58655,7 +59027,7 @@ class ForgeParser extends Parser_1.Parser {
                 case ForgeParser.NUM_CONST_TOK:
                     this.enterOuterAlt(_localctx, 1);
                     {
-                        this.state = 1009;
+                        this.state = 1010;
                         this.atomNameOrNumber();
                     }
                     break;
@@ -58666,18 +59038,18 @@ class ForgeParser extends Parser_1.Parser {
                 case ForgeParser.IDENTIFIER_TOK:
                     this.enterOuterAlt(_localctx, 2);
                     {
-                        this.state = 1010;
+                        this.state = 1011;
                         this.qualName();
                     }
                     break;
                 case ForgeParser.LEFT_PAREN_TOK:
                     this.enterOuterAlt(_localctx, 3);
                     {
-                        this.state = 1011;
-                        this.match(ForgeParser.LEFT_PAREN_TOK);
                         this.state = 1012;
-                        this.bindRHSUnion(0);
+                        this.match(ForgeParser.LEFT_PAREN_TOK);
                         this.state = 1013;
+                        this.bindRHSUnion(0);
+                        this.state = 1014;
                         this.match(ForgeParser.RIGHT_PAREN_TOK);
                     }
                     break;
@@ -58852,7 +59224,7 @@ ForgeParser.OPEN_TOK = 1;
 ForgeParser.LEFT_SQUARE_TOK = 2;
 ForgeParser.RIGHT_SQUARE_TOK = 3;
 ForgeParser.AS_TOK = 4;
-ForgeParser.FILE_PATH_TOK = 5;
+ForgeParser.STRING_TOK = 5;
 ForgeParser.VAR_TOK = 6;
 ForgeParser.ABSTRACT_TOK = 7;
 ForgeParser.SIG_TOK = 8;
@@ -59083,7 +59455,7 @@ ForgeParser._LITERAL_NAMES = [
 ];
 ForgeParser._SYMBOLIC_NAMES = [
     undefined, "OPEN_TOK", "LEFT_SQUARE_TOK", "RIGHT_SQUARE_TOK", "AS_TOK",
-    "FILE_PATH_TOK", "VAR_TOK", "ABSTRACT_TOK", "SIG_TOK", "LEFT_CURLY_TOK",
+    "STRING_TOK", "VAR_TOK", "ABSTRACT_TOK", "SIG_TOK", "LEFT_CURLY_TOK",
     "RIGHT_CURLY_TOK", "EXTENDS_TOK", "IN_TOK", "PLUS_TOK", "LONE_TOK", "SOME_TOK",
     "ONE_TOK", "TWO_TOK", "SET_TOK", "FUNC_TOK", "PFUNC_TOK", "DISJ_TOK",
     "COLON_TOK", "WHEAT_TOK", "PRED_TOK", "DOT_TOK", "FUN_TOK", "LEFT_PAREN_TOK",
@@ -59105,7 +59477,7 @@ ForgeParser._SYMBOLIC_NAMES = [
 ];
 ForgeParser.VOCABULARY = new VocabularyImpl_1.VocabularyImpl(ForgeParser._LITERAL_NAMES, ForgeParser._SYMBOLIC_NAMES, []);
 ForgeParser._serializedATNSegments = 2;
-ForgeParser._serializedATNSegment0 = "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03t\u03FC\x04\x02" +
+ForgeParser._serializedATNSegment0 = "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03t\u03FD\x04\x02" +
     "\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04\x07" +
     "\t\x07\x04\b\t\b\x04\t\t\t\x04\n\t\n\x04\v\t\v\x04\f\t\f\x04\r\t\r\x04" +
     "\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t\x10\x04\x11\t\x11\x04\x12\t\x12\x04" +
@@ -59148,57 +59520,57 @@ ForgeParser._serializedATNSegment0 = "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\u
     "\n\x16\f\x16\x0E\x16\u0198\v\x16\x03\x16\x03\x16\x03\x17\x03\x17\x03\x17" +
     "\x03\x17\x05\x17\u01A0\n\x17\x03\x17\x03\x17\x05\x17\u01A4\n\x17\x03\x18" +
     "\x05\x18\u01A7\n\x18\x03\x18\x03\x18\x03\x18\x03\x19\x03\x19\x03\x19\x03" +
-    "\x19\x05\x19\u01B0\n\x19\x03\x19\x05\x19\u01B3\n\x19\x03\x1A\x03\x1A\x03" +
-    "\x1A\x03\x1A\x03\x1A\x05\x1A\u01BA\n\x1A\x03\x1A\x03\x1A\x05\x1A\u01BE" +
-    "\n\x1A\x03\x1B\x03\x1B\x03\x1B\x05\x1B\u01C3\n\x1B\x03\x1B\x03\x1B\x03" +
-    "\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x05" +
-    "\x1B\u01D0\n\x1B\x03\x1B\x05\x1B\u01D3\n\x1B\x03\x1B\x03\x1B\x05\x1B\u01D7" +
-    "\n\x1B\x03\x1C\x03\x1C\x03\x1C\x03\x1C\x03\x1C\x03\x1C\x03\x1C\x05\x1C" +
-    "\u01E0\n\x1C\x03\x1C\x03\x1C\x05\x1C\u01E4\n\x1C\x03\x1D\x03\x1D\x03\x1D" +
-    "\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x05\x1D\u01ED\n\x1D\x03\x1D\x03\x1D\x05" +
-    "\x1D\u01F1\n\x1D\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x07\x1E" +
-    "\u01F9\n\x1E\f\x1E\x0E\x1E\u01FC\v\x1E\x03\x1E\x03\x1E\x03\x1F\x03\x1F" +
-    "\x03\x1F\x03\x1F\x03\x1F\x03\x1F\x05\x1F\u0206\n\x1F\x03 \x03 \x05 \u020A" +
-    "\n \x03 \x03 \x03 \x05 \u020F\n \x03!\x03!\x03\"\x03\"\x03\"\x03\"\x03" +
-    "#\x03#\x07#\u0219\n#\f#\x0E#\u021C\v#\x03#\x03#\x03$\x03$\x03$\x05$\u0223" +
-    "\n$\x03%\x03%\x03%\x03%\x05%\u0229\n%\x03&\x03&\x05&\u022D\n&\x03&\x03" +
-    "&\x03&\x07&\u0232\n&\f&\x0E&\u0235\v&\x03&\x03&\x03&\x05&\u023A\n&\x03" +
-    "\'\x03\'\x03\'\x03\'\x03\'\x05\'\u0241\n\'\x03\'\x05\'\u0244\n\'\x03(" +
-    "\x03(\x03)\x03)\x03)\x03)\x03)\x05)\u024D\n)\x03*\x03*\x03*\x03*\x03*" +
-    "\x05*\u0254\n*\x03+\x03+\x03+\x03+\x03+\x05+\u025B\n+\x03,\x03,\x03,\x03" +
-    ",\x03,\x05,\u0262\n,\x03-\x03-\x03-\x03-\x03-\x05-\u0269\n-\x03.\x03." +
-    "\x03.\x03.\x03.\x05.\u0270\n.\x03/\x03/\x03/\x03/\x03/\x05/\u0277\n/\x03" +
-    "0\x030\x030\x030\x030\x050\u027E\n0\x031\x031\x031\x031\x031\x031\x03" +
-    "1\x031\x031\x031\x031\x051\u028B\n1\x031\x031\x031\x051\u0290\n1\x032" +
-    "\x032\x032\x032\x032\x032\x072\u0298\n2\f2\x0E2\u029B\v2\x033\x033\x03" +
-    "3\x033\x033\x033\x073\u02A3\n3\f3\x0E3\u02A6\v3\x034\x034\x034\x034\x03" +
-    "4\x034\x074\u02AE\n4\f4\x0E4\u02B1\v4\x035\x035\x035\x035\x035\x035\x05" +
-    "5\u02B9\n5\x055\u02BB\n5\x036\x036\x036\x036\x036\x036\x076\u02C3\n6\f" +
-    "6\x0E6\u02C6\v6\x037\x037\x037\x037\x037\x037\x037\x037\x037\x037\x03" +
-    "7\x037\x037\x037\x037\x037\x037\x057\u02D9\n7\x038\x038\x038\x038\x03" +
-    "8\x038\x038\x038\x038\x038\x038\x038\x038\x038\x038\x058\u02EA\n8\x03" +
-    "9\x039\x039\x039\x039\x059\u02F1\n9\x039\x039\x039\x079\u02F6\n9\f9\x0E" +
-    "9\u02F9\v9\x03:\x03:\x03:\x05:\u02FE\n:\x03;\x03;\x03;\x03;\x03;\x03;" +
-    "\x07;\u0306\n;\f;\x0E;\u0309\v;\x03<\x03<\x03<\x05<\u030E\n<\x03=\x03" +
-    "=\x03=\x03=\x03=\x03=\x07=\u0316\n=\f=\x0E=\u0319\v=\x03>\x03>\x03>\x03" +
-    ">\x03>\x03>\x07>\u0321\n>\f>\x0E>\u0324\v>\x03?\x03?\x03?\x03?\x03?\x03" +
-    "?\x03?\x07?\u032D\n?\f?\x0E?\u0330\v?\x03@\x03@\x03@\x03@\x03@\x03@\x07" +
-    "@\u0338\n@\f@\x0E@\u033B\v@\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x07" +
-    "A\u0345\nA\fA\x0EA\u0348\vA\x03B\x03B\x03B\x03B\x03B\x03B\x03B\x05B\u0351" +
-    "\nB\x03B\x03B\x03B\x07B\u0356\nB\fB\x0EB\u0359\vB\x03C\x03C\x03C\x03C" +
-    "\x03C\x07C\u0360\nC\fC\x0EC\u0363\vC\x03D\x03D\x03D\x05D\u0368\nD\x03" +
-    "E\x03E\x03E\x03E\x03E\x03E\x03E\x03E\x03E\x03E\x03E\x03E\x03E\x03E\x03" +
-    "E\x03E\x03E\x03E\x05E\u037C\nE\x03F\x03F\x03F\x03F\x03F\x05F\u0383\nF" +
-    "\x03G\x03G\x03H\x03H\x03I\x03I\x03I\x03I\x05I\u038D\nI\x03J\x03J\x03K" +
-    "\x03K\x03K\x03L\x03L\x03L\x03L\x03L\x03L\x03L\x03M\x03M\x03M\x03M\x03" +
-    "M\x03M\x03N\x03N\x03N\x03N\x03N\x05N\u03A6\nN\x03O\x03O\x03P\x03P\x07" +
-    "P\u03AC\nP\fP\x0EP\u03AF\vP\x03P\x03P\x05P\u03B3\nP\x03P\x05P\u03B6\n" +
-    "P\x03Q\x03Q\x03Q\x03Q\x03Q\x05Q\u03BD\nQ\x03R\x03R\x03R\x03R\x03R\x03" +
-    "R\x03R\x05R\u03C6\nR\x03S\x03S\x03S\x03S\x03S\x03S\x06S\u03CE\nS\rS\x0E" +
-    "S\u03CF\x05S\u03D2\nS\x03T\x03T\x03T\x03T\x03T\x03T\x05T\u03DA\nT\x03" +
-    "T\x03T\x03T\x07T\u03DF\nT\fT\x0ET\u03E2\vT\x03U\x03U\x03U\x03U\x03U\x03" +
-    "U\x05U\u03EA\nU\x03U\x03U\x03U\x07U\u03EF\nU\fU\x0EU\u03F2\vU\x03V\x03" +
-    "V\x03V\x03V\x03V\x03V\x05V\u03FA\nV\x03V\x02\x02\x11bdfjptxz|~\x80\x82" +
+    "\x19\x05\x19\u01B0\n\x19\x03\x19\x03\x19\x05\x19\u01B4\n\x19\x03\x1A\x03" +
+    "\x1A\x03\x1A\x03\x1A\x03\x1A\x05\x1A\u01BB\n\x1A\x03\x1A\x03\x1A\x05\x1A" +
+    "\u01BF\n\x1A\x03\x1B\x03\x1B\x03\x1B\x05\x1B\u01C4\n\x1B\x03\x1B\x03\x1B" +
+    "\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B" +
+    "\x05\x1B\u01D1\n\x1B\x03\x1B\x05\x1B\u01D4\n\x1B\x03\x1B\x03\x1B\x05\x1B" +
+    "\u01D8\n\x1B\x03\x1C\x03\x1C\x03\x1C\x03\x1C\x03\x1C\x03\x1C\x03\x1C\x05" +
+    "\x1C\u01E1\n\x1C\x03\x1C\x03\x1C\x05\x1C\u01E5\n\x1C\x03\x1D\x03\x1D\x03" +
+    "\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x05\x1D\u01EE\n\x1D\x03\x1D\x03\x1D" +
+    "\x05\x1D\u01F2\n\x1D\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x03\x1E\x07" +
+    "\x1E\u01FA\n\x1E\f\x1E\x0E\x1E\u01FD\v\x1E\x03\x1E\x03\x1E\x03\x1F\x03" +
+    "\x1F\x03\x1F\x03\x1F\x03\x1F\x03\x1F\x05\x1F\u0207\n\x1F\x03 \x03 \x05" +
+    " \u020B\n \x03 \x03 \x03 \x05 \u0210\n \x03!\x03!\x03\"\x03\"\x03\"\x03" +
+    "\"\x03#\x03#\x07#\u021A\n#\f#\x0E#\u021D\v#\x03#\x03#\x03$\x03$\x03$\x05" +
+    "$\u0224\n$\x03%\x03%\x03%\x03%\x05%\u022A\n%\x03&\x03&\x05&\u022E\n&\x03" +
+    "&\x03&\x03&\x07&\u0233\n&\f&\x0E&\u0236\v&\x03&\x03&\x03&\x05&\u023B\n" +
+    "&\x03\'\x03\'\x03\'\x03\'\x03\'\x05\'\u0242\n\'\x03\'\x05\'\u0245\n\'" +
+    "\x03(\x03(\x03)\x03)\x03)\x03)\x03)\x05)\u024E\n)\x03*\x03*\x03*\x03*" +
+    "\x03*\x05*\u0255\n*\x03+\x03+\x03+\x03+\x03+\x05+\u025C\n+\x03,\x03,\x03" +
+    ",\x03,\x03,\x05,\u0263\n,\x03-\x03-\x03-\x03-\x03-\x05-\u026A\n-\x03." +
+    "\x03.\x03.\x03.\x03.\x05.\u0271\n.\x03/\x03/\x03/\x03/\x03/\x05/\u0278" +
+    "\n/\x030\x030\x030\x030\x030\x050\u027F\n0\x031\x031\x031\x031\x031\x03" +
+    "1\x031\x031\x031\x031\x031\x051\u028C\n1\x031\x031\x031\x051\u0291\n1" +
+    "\x032\x032\x032\x032\x032\x032\x072\u0299\n2\f2\x0E2\u029C\v2\x033\x03" +
+    "3\x033\x033\x033\x033\x073\u02A4\n3\f3\x0E3\u02A7\v3\x034\x034\x034\x03" +
+    "4\x034\x034\x074\u02AF\n4\f4\x0E4\u02B2\v4\x035\x035\x035\x035\x035\x03" +
+    "5\x055\u02BA\n5\x055\u02BC\n5\x036\x036\x036\x036\x036\x036\x076\u02C4" +
+    "\n6\f6\x0E6\u02C7\v6\x037\x037\x037\x037\x037\x037\x037\x037\x037\x03" +
+    "7\x037\x037\x037\x037\x037\x037\x037\x057\u02DA\n7\x038\x038\x038\x03" +
+    "8\x038\x038\x038\x038\x038\x038\x038\x038\x038\x038\x038\x058\u02EB\n" +
+    "8\x039\x039\x039\x039\x039\x059\u02F2\n9\x039\x039\x039\x079\u02F7\n9" +
+    "\f9\x0E9\u02FA\v9\x03:\x03:\x03:\x05:\u02FF\n:\x03;\x03;\x03;\x03;\x03" +
+    ";\x03;\x07;\u0307\n;\f;\x0E;\u030A\v;\x03<\x03<\x03<\x05<\u030F\n<\x03" +
+    "=\x03=\x03=\x03=\x03=\x03=\x07=\u0317\n=\f=\x0E=\u031A\v=\x03>\x03>\x03" +
+    ">\x03>\x03>\x03>\x07>\u0322\n>\f>\x0E>\u0325\v>\x03?\x03?\x03?\x03?\x03" +
+    "?\x03?\x03?\x07?\u032E\n?\f?\x0E?\u0331\v?\x03@\x03@\x03@\x03@\x03@\x03" +
+    "@\x07@\u0339\n@\f@\x0E@\u033C\v@\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03" +
+    "A\x07A\u0346\nA\fA\x0EA\u0349\vA\x03B\x03B\x03B\x03B\x03B\x03B\x03B\x05" +
+    "B\u0352\nB\x03B\x03B\x03B\x07B\u0357\nB\fB\x0EB\u035A\vB\x03C\x03C\x03" +
+    "C\x03C\x03C\x07C\u0361\nC\fC\x0EC\u0364\vC\x03D\x03D\x03D\x05D\u0369\n" +
+    "D\x03E\x03E\x03E\x03E\x03E\x03E\x03E\x03E\x03E\x03E\x03E\x03E\x03E\x03" +
+    "E\x03E\x03E\x03E\x03E\x05E\u037D\nE\x03F\x03F\x03F\x03F\x03F\x05F\u0384" +
+    "\nF\x03G\x03G\x03H\x03H\x03I\x03I\x03I\x03I\x05I\u038E\nI\x03J\x03J\x03" +
+    "K\x03K\x03K\x03L\x03L\x03L\x03L\x03L\x03L\x03L\x03M\x03M\x03M\x03M\x03" +
+    "M\x03M\x03N\x03N\x03N\x03N\x03N\x05N\u03A7\nN\x03O\x03O\x03P\x03P\x07" +
+    "P\u03AD\nP\fP\x0EP\u03B0\vP\x03P\x03P\x05P\u03B4\nP\x03P\x05P\u03B7\n" +
+    "P\x03Q\x03Q\x03Q\x03Q\x03Q\x05Q\u03BE\nQ\x03R\x03R\x03R\x03R\x03R\x03" +
+    "R\x03R\x05R\u03C7\nR\x03S\x03S\x03S\x03S\x03S\x03S\x06S\u03CF\nS\rS\x0E" +
+    "S\u03D0\x05S\u03D3\nS\x03T\x03T\x03T\x03T\x03T\x03T\x05T\u03DB\nT\x03" +
+    "T\x03T\x03T\x07T\u03E0\nT\fT\x0ET\u03E3\vT\x03U\x03U\x03U\x03U\x03U\x03" +
+    "U\x05U\u03EB\nU\x03U\x03U\x03U\x07U\u03F0\nU\fU\x0EU\u03F3\vU\x03V\x03" +
+    "V\x03V\x03V\x03V\x03V\x05V\u03FB\nV\x03V\x02\x02\x11bdfjptxz|~\x80\x82" +
     "\x84\xA6\xA8W\x02\x02\x04\x02\x06\x02\b\x02\n\x02\f\x02\x0E\x02\x10\x02" +
     "\x12\x02\x14\x02\x16\x02\x18\x02\x1A\x02\x1C\x02\x1E\x02 \x02\"\x02$\x02" +
     "&\x02(\x02*\x02,\x02.\x020\x022\x024\x026\x028\x02:\x02<\x02>\x02@\x02" +
@@ -59210,7 +59582,7 @@ ForgeParser._serializedATNSegment0 = "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\u
     "\x04\x02\x10\x10\x12\x16\x05\x02\x10\x10\x12\x12\x14\x16\x03\x02 !\x03" +
     "\x02*.\x04\x02*+--\x03\x0245\x03\x0267\x05\x02\x0E\x0E))af\x03\x02no\x04" +
     "\x02\x10\x14gg\x04\x02\x0F\x0F((\x03\x02OP\x04\x02RT]`\x04\x02\\\\kk\x02" +
-    "\u044E\x02\xAC\x03\x02\x02\x02\x04\xBB\x03\x02\x02\x02\x06\xD0\x03\x02" +
+    "\u0450\x02\xAC\x03\x02\x02\x02\x04\xBB\x03\x02\x02\x02\x06\xD0\x03\x02" +
     "\x02\x02\b\xE4\x03\x02\x02\x02\n\xF7\x03\x02\x02\x02\f\xFA\x03\x02\x02" +
     "\x02\x0E\u011A\x03\x02\x02\x02\x10\u011C\x03\x02\x02\x02\x12\u011E\x03" +
     "\x02\x02\x02\x14\u0120\x03\x02\x02\x02\x16\u0123\x03\x02\x02\x02\x18\u012D" +
@@ -59218,28 +59590,28 @@ ForgeParser._serializedATNSegment0 = "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\u
     "\u0140\x03\x02\x02\x02 \u015D\x03\x02\x02\x02\"\u015F\x03\x02\x02\x02" +
     "$\u0168\x03\x02\x02\x02&\u0179\x03\x02\x02\x02(\u018A\x03\x02\x02\x02" +
     "*\u0192\x03\x02\x02\x02,\u01A3\x03\x02\x02\x02.\u01A6\x03\x02\x02\x02" +
-    "0\u01B2\x03\x02\x02\x022\u01B4\x03\x02\x02\x024\u01BF\x03\x02\x02\x02" +
-    "6\u01D8\x03\x02\x02\x028\u01E5\x03\x02\x02\x02:\u01F2\x03\x02\x02\x02" +
-    "<\u0205\x03\x02\x02\x02>\u0209\x03\x02\x02\x02@\u0210\x03\x02\x02\x02" +
-    "B\u0212\x03\x02\x02\x02D\u0216\x03\x02\x02\x02F\u0222\x03\x02\x02\x02" +
-    "H\u0228\x03\x02\x02\x02J\u0239\x03\x02\x02\x02L\u023B\x03\x02\x02\x02" +
-    "N\u0245\x03\x02\x02\x02P\u024C\x03\x02\x02\x02R\u0253\x03\x02\x02\x02" +
-    "T\u025A\x03\x02\x02\x02V\u0261\x03\x02\x02\x02X\u0268\x03\x02\x02\x02" +
-    "Z\u026F\x03\x02\x02\x02\\\u0276\x03\x02\x02\x02^\u027D\x03\x02\x02\x02" +
-    "`\u028F\x03\x02\x02\x02b\u0291\x03\x02\x02\x02d\u029C\x03\x02\x02\x02" +
-    "f\u02A7\x03\x02\x02\x02h\u02BA\x03\x02\x02\x02j\u02BC\x03\x02\x02\x02" +
-    "l\u02D8\x03\x02\x02\x02n\u02E9\x03\x02\x02\x02p\u02EB\x03\x02\x02\x02" +
-    "r\u02FD\x03\x02\x02\x02t\u02FF\x03\x02\x02\x02v\u030D\x03\x02\x02\x02" +
-    "x\u030F\x03\x02\x02\x02z\u031A\x03\x02\x02\x02|\u0325\x03\x02\x02\x02" +
-    "~\u0331\x03\x02\x02\x02\x80\u033C\x03\x02\x02\x02\x82\u0350\x03\x02\x02" +
-    "\x02\x84\u035A\x03\x02\x02\x02\x86\u0367\x03\x02\x02\x02\x88\u037B\x03" +
-    "\x02\x02\x02\x8A\u0382\x03\x02\x02\x02\x8C\u0384\x03\x02\x02\x02\x8E\u0386" +
-    "\x03\x02\x02\x02\x90\u0388\x03\x02\x02\x02\x92\u038E\x03\x02\x02\x02\x94" +
-    "\u0390\x03\x02\x02\x02\x96\u0393\x03\x02\x02\x02\x98\u039A\x03\x02\x02" +
-    "\x02\x9A\u03A5\x03\x02\x02\x02\x9C\u03A7\x03\x02\x02\x02\x9E\u03B5\x03" +
-    "\x02\x02\x02\xA0\u03BC\x03\x02\x02\x02\xA2\u03C5\x03\x02\x02\x02\xA4\u03D1" +
-    "\x03\x02\x02\x02\xA6\u03D9\x03\x02\x02\x02\xA8\u03E9\x03\x02\x02\x02\xAA" +
-    "\u03F9\x03\x02\x02\x02\xAC\xAE\x07\x1A\x02\x02\xAD\xAF\x05\x1C\x0F\x02" +
+    "0\u01B3\x03\x02\x02\x022\u01B5\x03\x02\x02\x024\u01C0\x03\x02\x02\x02" +
+    "6\u01D9\x03\x02\x02\x028\u01E6\x03\x02\x02\x02:\u01F3\x03\x02\x02\x02" +
+    "<\u0206\x03\x02\x02\x02>\u020A\x03\x02\x02\x02@\u0211\x03\x02\x02\x02" +
+    "B\u0213\x03\x02\x02\x02D\u0217\x03\x02\x02\x02F\u0223\x03\x02\x02\x02" +
+    "H\u0229\x03\x02\x02\x02J\u023A\x03\x02\x02\x02L\u023C\x03\x02\x02\x02" +
+    "N\u0246\x03\x02\x02\x02P\u024D\x03\x02\x02\x02R\u0254\x03\x02\x02\x02" +
+    "T\u025B\x03\x02\x02\x02V\u0262\x03\x02\x02\x02X\u0269\x03\x02\x02\x02" +
+    "Z\u0270\x03\x02\x02\x02\\\u0277\x03\x02\x02\x02^\u027E\x03\x02\x02\x02" +
+    "`\u0290\x03\x02\x02\x02b\u0292\x03\x02\x02\x02d\u029D\x03\x02\x02\x02" +
+    "f\u02A8\x03\x02\x02\x02h\u02BB\x03\x02\x02\x02j\u02BD\x03\x02\x02\x02" +
+    "l\u02D9\x03\x02\x02\x02n\u02EA\x03\x02\x02\x02p\u02EC\x03\x02\x02\x02" +
+    "r\u02FE\x03\x02\x02\x02t\u0300\x03\x02\x02\x02v\u030E\x03\x02\x02\x02" +
+    "x\u0310\x03\x02\x02\x02z\u031B\x03\x02\x02\x02|\u0326\x03\x02\x02\x02" +
+    "~\u0332\x03\x02\x02\x02\x80\u033D\x03\x02\x02\x02\x82\u0351\x03\x02\x02" +
+    "\x02\x84\u035B\x03\x02\x02\x02\x86\u0368\x03\x02\x02\x02\x88\u037C\x03" +
+    "\x02\x02\x02\x8A\u0383\x03\x02\x02\x02\x8C\u0385\x03\x02\x02\x02\x8E\u0387" +
+    "\x03\x02\x02\x02\x90\u0389\x03\x02\x02\x02\x92\u038F\x03\x02\x02\x02\x94" +
+    "\u0391\x03\x02\x02\x02\x96\u0394\x03\x02\x02\x02\x98\u039B\x03\x02\x02" +
+    "\x02\x9A\u03A6\x03\x02\x02\x02\x9C\u03A8\x03\x02\x02\x02\x9E\u03B6\x03" +
+    "\x02\x02\x02\xA0\u03BD\x03\x02\x02\x02\xA2\u03C6\x03\x02\x02\x02\xA4\u03D2" +
+    "\x03\x02\x02\x02\xA6\u03DA\x03\x02\x02\x02\xA8\u03EA\x03\x02\x02\x02\xAA" +
+    "\u03FA\x03\x02\x02\x02\xAC\xAE\x07\x1A\x02\x02\xAD\xAF\x05\x1C\x0F\x02" +
     "\xAE\xAD\x03\x02\x02\x02\xAE\xAF\x03\x02\x02\x02\xAF\xB3\x03\x02\x02\x02" +
     "\xB0\xB1\x05J&\x02\xB1\xB2\x07\x1B\x02\x02\xB2\xB4\x03\x02\x02\x02\xB3" +
     "\xB0\x03\x02\x02\x02\xB3\xB4\x03\x02\x02\x02\xB4\xB5\x03\x02\x02\x02\xB5" +
@@ -59351,272 +59723,273 @@ ForgeParser._serializedATNSegment0 = "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\u
     "\x05\\/\x02\u01A3\u019B\x03\x02\x02\x02\u01A3\u01A1\x03\x02\x02\x02\u01A4" +
     "-\x03\x02\x02\x02\u01A5\u01A7\x07$\x02\x02\u01A6\u01A5\x03\x02\x02\x02" +
     "\u01A6\u01A7\x03\x02\x02\x02\u01A7\u01A8\x03\x02\x02\x02\u01A8\u01A9\x05" +
-    "\x9CO\x02\u01A9\u01AA\x05J&\x02\u01AA/\x03\x02\x02\x02\u01AB\u01B3\x07" +
-    "%\x02\x02\u01AC\u01B3\x07&\x02\x02\u01AD\u01B3\x07\'\x02\x02\u01AE\u01B0" +
+    "\x9CO\x02\u01A9\u01AA\x05J&\x02\u01AA/\x03\x02\x02\x02\u01AB\u01B4\x07" +
+    "%\x02\x02\u01AC\u01B4\x07&\x02\x02\u01AD\u01B4\x07\'\x02\x02\u01AE\u01B0" +
     "\x07(\x02\x02\u01AF\u01AE\x03\x02\x02\x02\u01AF\u01B0\x03\x02\x02\x02" +
-    "\u01B0\u01B1\x03\x02\x02\x02\u01B1\u01B3\x05\x9CO\x02\u01B2\u01AB\x03" +
-    "\x02\x02\x02\u01B2\u01AC\x03\x02\x02\x02\u01B2\u01AD\x03\x02\x02\x02\u01B2" +
-    "\u01AF\x03\x02\x02\x02\u01B31\x03\x02\x02\x02\u01B4\u01B5\x07\x1F\x02" +
-    "\x02\u01B5\u01B6\x05`1\x02\u01B6\u01B7\x07)\x02\x02\u01B7\u01B9\t\x07" +
-    "\x02\x02\u01B8\u01BA\x05,\x17\x02\u01B9\u01B8\x03\x02\x02\x02\u01B9\u01BA" +
-    "\x03\x02\x02\x02\u01BA\u01BD\x03\x02";
-ForgeParser._serializedATNSegment1 = "\x02\x02\u01BB\u01BC\x07\"\x02\x02\u01BC\u01BE\x05\x9EP\x02\u01BD\u01BB" +
-    "\x03\x02\x02\x02\u01BD\u01BE\x03\x02\x02\x02\u01BE3\x03\x02\x02\x02\u01BF" +
-    "\u01C0\x07\x1F\x02\x02\u01C0\u01C2\x073\x02\x02\u01C1\u01C3\x07\x17\x02" +
-    "\x02\u01C2\u01C1\x03\x02\x02\x02\u01C2\u01C3\x03\x02\x02\x02\u01C3\u01C4" +
-    "\x03\x02\x02\x02\u01C4\u01C5\x05V,\x02\u01C5\u01C6\x072\x02\x02\u01C6" +
-    "\u01C7\x05`1\x02\u01C7\u01C8\x07)\x02\x02\u01C8\u01C9\t\b\x02\x02\u01C9" +
-    "\u01CA\x07\"\x02\x02\u01CA\u01CF\x05N(\x02\u01CB\u01CC\x07\x04\x02\x02" +
-    "\u01CC\u01CD\x05^0\x02\u01CD\u01CE\x07\x05\x02\x02\u01CE\u01D0\x03\x02" +
-    "\x02\x02\u01CF\u01CB\x03\x02\x02\x02\u01CF\u01D0\x03\x02\x02\x02\u01D0" +
-    "\u01D2\x03\x02\x02\x02\u01D1\u01D3\x05,\x17\x02\u01D2\u01D1\x03\x02\x02" +
-    "\x02\u01D2\u01D3\x03\x02\x02\x02\u01D3\u01D6\x03\x02\x02\x02\u01D4\u01D5" +
-    "\x07\"\x02\x02\u01D5\u01D7\x05\x9EP\x02\u01D6\u01D4\x03\x02\x02\x02\u01D6" +
-    "\u01D7\x03\x02\x02\x02\u01D75\x03\x02\x02\x02\u01D8\u01D9\x07\x1F\x02" +
-    "\x02\u01D9\u01DA\x05`1\x02\u01DA\u01DB\x07)\x02\x02\u01DB\u01DC\t\b\x02" +
-    "\x02\u01DC\u01DD\x07\"\x02\x02\u01DD\u01DF\x05N(\x02\u01DE\u01E0\x05," +
-    "\x17\x02\u01DF\u01DE\x03\x02\x02\x02\u01DF\u01E0\x03\x02\x02\x02\u01E0" +
-    "\u01E3\x03\x02\x02\x02\u01E1\u01E2\x07\"\x02\x02\u01E2\u01E4\x05\x9EP" +
-    "\x02\u01E3\u01E1\x03\x02\x02\x02\u01E3\u01E4\x03\x02\x02\x02\u01E47\x03" +
-    "\x02\x02\x02\u01E5\u01E6\x07\x1F\x02\x02\u01E6\u01E7\x05`1\x02\u01E7\u01E8" +
-    "\x07)\x02\x02\u01E8\u01E9\t\t\x02\x02\u01E9\u01EA\x078\x02\x02\u01EA\u01EC" +
-    "\x05N(\x02\u01EB\u01ED\x05,\x17\x02\u01EC\u01EB\x03\x02\x02\x02\u01EC" +
-    "\u01ED\x03\x02\x02\x02\u01ED\u01F0\x03\x02\x02\x02\u01EE\u01EF\x07\"\x02" +
-    "\x02\u01EF\u01F1\x05\x9EP\x02\u01F0\u01EE\x03\x02\x02\x02\u01F0\u01F1" +
-    "\x03\x02\x02\x02\u01F19\x03\x02\x02\x02\u01F2\u01F3\x07/\x02\x02\u01F3" +
-    "\u01F4\x071\x02\x02\u01F4\u01F5\x07\"\x02\x02\u01F5\u01F6\x05N(\x02\u01F6" +
-    "\u01FA\x07\v\x02\x02\u01F7\u01F9\x05<\x1F\x02\u01F8\u01F7\x03\x02\x02" +
-    "\x02\u01F9\u01FC\x03\x02\x02\x02\u01FA\u01F8\x03\x02\x02\x02\u01FA\u01FB" +
-    "\x03\x02\x02\x02\u01FB\u01FD\x03\x02\x02\x02\u01FC\u01FA\x03\x02\x02\x02" +
-    "\u01FD\u01FE\x07\f\x02\x02\u01FE;\x03\x02\x02\x02\u01FF\u0206\x05\x96" +
-    "L\x02\u0200\u0206\x05(\x15\x02\u0201\u0206\x054\x1B\x02\u0202\u0206\x05" +
-    "6\x1C\x02\u0203\u0206\x052\x1A\x02\u0204\u0206\x058\x1D\x02\u0205\u01FF" +
-    "\x03\x02\x02\x02\u0205\u0200\x03\x02\x02\x02\u0205\u0201\x03\x02\x02\x02" +
-    "\u0205\u0202\x03\x02\x02\x02\u0205\u0203\x03\x02\x02\x02\u0205\u0204\x03" +
-    "\x02\x02\x02\u0206=\x03\x02\x02\x02\u0207\u020A\x05\x10\t\x02\u0208\u020A" +
-    "\x07\x14\x02\x02\u0209\u0207\x03\x02\x02\x02\u0209\u0208\x03\x02\x02\x02" +
-    "\u0209\u020A\x03\x02\x02\x02\u020A\u020B\x03\x02\x02\x02\u020B\u020E\x07" +
-    "\\\x02\x02\u020C\u020F\x05\x10\t\x02\u020D\u020F\x07\x14\x02\x02\u020E" +
-    "\u020C\x03\x02\x02\x02\u020E\u020D\x03\x02\x02\x02\u020E\u020F\x03\x02" +
-    "\x02\x02\u020F?\x03\x02\x02\x02\u0210\u0211\t\n\x02\x02\u0211A\x03\x02" +
-    "\x02\x02\u0212\u0213\x05N(\x02\u0213\u0214\x07a\x02\x02\u0214\u0215\x05" +
-    "`1\x02\u0215C\x03\x02\x02\x02\u0216\u021A\x07\v\x02\x02\u0217\u0219\x05" +
-    "`1\x02\u0218\u0217\x03\x02\x02\x02\u0219\u021C\x03\x02\x02\x02\u021A\u0218" +
-    "\x03\x02\x02\x02\u021A\u021B\x03\x02\x02\x02\u021B\u021D\x03\x02\x02\x02" +
-    "\u021C\u021A\x03\x02\x02\x02\u021D\u021E\x07\f\x02\x02\u021EE\x03\x02" +
-    "\x02\x02\u021F\u0223\x05D#\x02\u0220\u0221\x072\x02\x02\u0221\u0223\x05" +
-    "`1\x02\u0222\u021F\x03\x02\x02\x02\u0222\u0220\x03\x02\x02\x02\u0223G" +
-    "\x03\x02\x02\x02\u0224\u0229\x073\x02\x02\u0225\u0229\x07g\x02\x02\u0226" +
-    "\u0229\x07h\x02\x02\u0227\u0229\x05\x10\t\x02\u0228\u0224\x03\x02\x02" +
-    "\x02\u0228\u0225\x03\x02\x02\x02\u0228\u0226\x03\x02\x02\x02\u0228\u0227" +
-    "\x03\x02\x02\x02\u0229I\x03\x02\x02\x02\u022A\u022B\x07W\x02\x02\u022B" +
-    "\u022D\x07l\x02\x02\u022C\u022A\x03\x02\x02\x02\u022C\u022D\x03\x02\x02" +
-    "\x02\u022D\u0233\x03\x02\x02\x02\u022E\u022F\x05N(\x02\u022F\u0230\x07" +
-    "l\x02\x02\u0230\u0232\x03\x02\x02\x02\u0231\u022E\x03\x02\x02\x02\u0232" +
-    "\u0235\x03\x02\x02\x02\u0233\u0231\x03\x02\x02\x02\u0233\u0234\x03\x02" +
-    "\x02\x02\u0234\u0236\x03\x02\x02\x02\u0235\u0233\x03\x02\x02\x02\u0236" +
-    "\u023A\x05N(\x02\u0237\u023A\x07i\x02\x02\u0238\u023A\x07h\x02\x02\u0239" +
-    "\u022C\x03\x02\x02\x02\u0239\u0237\x03\x02\x02\x02\u0239\u0238\x03\x02" +
-    "\x02\x02\u023AK\x03\x02\x02\x02\u023B\u023C\x07j\x02\x02\u023C\u0243\x05" +
-    "J&\x02\u023D\u0244\x05J&\x02\u023E\u0244\x07\x07\x02\x02\u023F\u0241\x07" +
-    "(\x02\x02\u0240\u023F\x03\x02\x02\x02\u0240\u0241\x03\x02\x02\x02\u0241" +
-    "\u0242\x03\x02\x02\x02\u0242\u0244\x05\x9CO\x02\u0243\u023D\x03\x02\x02" +
-    "\x02\u0243\u023E\x03\x02\x02\x02\u0243\u0240\x03\x02\x02\x02\u0244M\x03" +
-    "\x02\x02\x02\u0245\u0246\t\v\x02\x02\u0246O\x03\x02\x02\x02\u0247\u024D" +
-    "\x05N(\x02\u0248\u0249\x05N(\x02\u0249\u024A\x07k\x02\x02\u024A\u024B" +
-    "\x05P)\x02\u024B\u024D\x03\x02\x02\x02\u024C\u0247\x03\x02\x02\x02\u024C" +
-    "\u0248\x03\x02\x02\x02\u024DQ\x03\x02\x02\x02\u024E\u0254\x05J&\x02\u024F" +
-    "\u0250\x05J&\x02\u0250\u0251\x07k\x02\x02\u0251\u0252\x05R*\x02\u0252" +
-    "\u0254\x03\x02\x02\x02\u0253\u024E\x03\x02\x02\x02\u0253\u024F\x03\x02" +
-    "\x02\x02\u0254S\x03\x02\x02\x02\u0255\u025B\x05\x16\f\x02\u0256\u0257" +
-    "\x05\x16\f\x02\u0257\u0258\x07k\x02\x02\u0258\u0259\x05T+\x02\u0259\u025B" +
-    "\x03\x02\x02\x02\u025A\u0255\x03\x02\x02\x02\u025A\u0256\x03\x02\x02\x02" +
-    "\u025BU\x03\x02\x02\x02\u025C\u0262\x05\x18\r\x02\u025D\u025E\x05\x18" +
-    "\r\x02\u025E\u025F\x07k\x02\x02\u025F\u0260\x05V,\x02\u0260\u0262\x03" +
-    "\x02\x02\x02\u0261\u025C\x03\x02\x02\x02\u0261\u025D\x03\x02\x02\x02\u0262" +
-    "W\x03\x02\x02\x02\u0263\u0269\x05\x1A\x0E\x02\u0264\u0265\x05\x1A\x0E" +
-    "\x02\u0265\u0266\x07k\x02\x02\u0266\u0267\x05X-\x02\u0267\u0269\x03\x02" +
-    "\x02\x02\u0268\u0263\x03\x02\x02\x02\u0268\u0264\x03\x02\x02\x02\u0269" +
-    "Y\x03\x02\x02\x02\u026A\u0270\x05B\"\x02\u026B\u026C\x05B\"\x02\u026C" +
-    "\u026D\x07k\x02\x02\u026D\u026E\x05Z.\x02\u026E\u0270\x03\x02\x02\x02" +
-    "\u026F\u026A\x03\x02\x02\x02\u026F\u026B\x03\x02\x02\x02\u0270[\x03\x02" +
-    "\x02\x02\u0271\u0277\x05.\x18\x02\u0272\u0273\x05.\x18\x02\u0273\u0274" +
-    "\x07k\x02\x02\u0274\u0275\x05\\/\x02\u0275\u0277\x03\x02\x02\x02\u0276" +
-    "\u0271\x03\x02\x02\x02\u0276\u0272\x03\x02\x02\x02\u0277]\x03\x02\x02" +
-    "\x02\u0278\u027E\x05`1\x02\u0279\u027A\x05`1\x02\u027A\u027B\x07k\x02" +
-    "\x02\u027B\u027C\x05^0\x02\u027C\u027E\x03\x02\x02\x02\u027D\u0278\x03" +
-    "\x02\x02\x02\u027D\u0279\x03\x02\x02\x02\u027E_\x03\x02\x02\x02\u027F" +
-    "\u0290\x05b2\x02\u0280\u0281\x079\x02\x02\u0281\u0282\x05Z.\x02\u0282" +
-    "\u0283\x05F$\x02\u0283\u0290\x03\x02\x02\x02\u0284\u0285\x07:\x02\x02" +
-    "\u0285\u0286\x05Z.\x02\u0286\u0287\x05F$\x02\u0287\u0290\x03\x02\x02\x02" +
-    "\u0288\u028A\x05H%\x02\u0289\u028B\x07\x17\x02\x02\u028A\u0289\x03\x02" +
-    "\x02\x02\u028A\u028B\x03\x02\x02\x02\u028B\u028C\x03\x02\x02\x02\u028C" +
-    "\u028D\x05V,\x02\u028D\u028E\x05F$\x02\u028E\u0290\x03\x02\x02\x02\u028F" +
-    "\u027F\x03\x02\x02\x02\u028F\u0280\x03\x02\x02\x02\u028F\u0284\x03\x02" +
-    "\x02\x02\u028F\u0288\x03\x02\x02\x02\u0290a\x03\x02\x02\x02\u0291\u0292" +
-    "\b2\x01\x02\u0292\u0293\x05d3\x02\u0293\u0299\x03\x02\x02\x02\u0294\u0295" +
-    "\f\x03\x02\x02\u0295\u0296\x07;\x02\x02\u0296\u0298\x05d3\x02\u0297\u0294" +
-    "\x03\x02\x02\x02\u0298\u029B\x03\x02\x02\x02\u0299\u0297\x03\x02\x02\x02" +
-    "\u0299\u029A\x03\x02\x02\x02\u029Ac\x03\x02\x02\x02\u029B\u0299\x03\x02" +
-    "\x02\x02\u029C\u029D\b3\x01\x02\u029D\u029E\x05f4\x02\u029E\u02A4\x03" +
-    "\x02\x02\x02\u029F\u02A0\f\x03\x02\x02\u02A0\u02A1\x07<\x02\x02\u02A1" +
-    "\u02A3\x05f4\x02\u02A2\u029F\x03\x02\x02\x02\u02A3\u02A6\x03\x02\x02\x02" +
-    "\u02A4\u02A2\x03\x02\x02\x02\u02A4\u02A5\x03\x02\x02\x02\u02A5e\x03\x02" +
-    "\x02\x02\u02A6\u02A4\x03\x02\x02\x02\u02A7\u02A8\b4\x01\x02\u02A8\u02A9" +
-    "\x05h5\x02\u02A9\u02AF\x03\x02\x02\x02\u02AA\u02AB\f\x03\x02\x02\u02AB" +
-    "\u02AC\x07=\x02\x02\u02AC\u02AE\x05h5\x02\u02AD\u02AA\x03\x02\x02\x02" +
-    "\u02AE\u02B1\x03\x02\x02\x02\u02AF\u02AD\x03\x02\x02\x02\u02AF\u02B0\x03" +
-    "\x02\x02\x02\u02B0g\x03\x02\x02\x02\u02B1\u02AF\x03\x02\x02\x02\u02B2" +
-    "\u02BB\x05j6\x02\u02B3\u02B4\x05j6\x02\u02B4\u02B5\x07>\x02\x02\u02B5" +
-    "\u02B8\x05h5\x02\u02B6\u02B7\x07?\x02\x02\u02B7\u02B9\x05h5\x02\u02B8" +
-    "\u02B6\x03\x02\x02\x02\u02B8\u02B9\x03\x02\x02\x02\u02B9\u02BB\x03\x02" +
-    "\x02\x02\u02BA\u02B2\x03\x02\x02\x02\u02BA\u02B3\x03\x02\x02\x02\u02BB" +
-    "i\x03\x02\x02\x02\u02BC\u02BD\b6\x01\x02\u02BD\u02BE\x05l7\x02\u02BE\u02C4" +
-    "\x03\x02\x02\x02\u02BF\u02C0\f\x03\x02\x02\u02C0\u02C1\x07@\x02\x02\u02C1" +
-    "\u02C3\x05l7\x02\u02C2\u02BF\x03\x02\x02\x02\u02C3\u02C6\x03\x02\x02\x02" +
-    "\u02C4\u02C2\x03\x02\x02\x02\u02C4\u02C5\x03\x02\x02\x02\u02C5k\x03\x02" +
-    "\x02\x02\u02C6\u02C4\x03\x02\x02\x02\u02C7\u02D9\x05n8\x02\u02C8\u02C9" +
-    "\x05n8\x02\u02C9\u02CA\x07A\x02\x02\u02CA\u02CB\x05n8\x02\u02CB\u02D9" +
-    "\x03\x02\x02\x02\u02CC\u02CD\x05n8\x02\u02CD\u02CE\x07B\x02\x02\u02CE" +
-    "\u02CF\x05n8\x02\u02CF\u02D9\x03\x02\x02\x02\u02D0\u02D1\x05n8\x02\u02D1" +
-    "\u02D2\x07C\x02\x02\u02D2\u02D3\x05n8\x02\u02D3\u02D9\x03\x02\x02\x02" +
-    "\u02D4\u02D5\x05n8\x02\u02D5\u02D6\x07D\x02\x02\u02D6\u02D7\x05n8\x02" +
-    "\u02D7\u02D9\x03\x02\x02\x02\u02D8\u02C7\x03\x02\x02\x02\u02D8\u02C8\x03" +
-    "\x02\x02\x02\u02D8\u02CC\x03\x02\x02\x02\u02D8\u02D0\x03\x02\x02\x02\u02D8" +
-    "\u02D4\x03\x02\x02\x02\u02D9m\x03\x02\x02\x02\u02DA\u02EA\x05p9\x02\u02DB" +
-    "\u02DC\x07E\x02\x02\u02DC\u02EA\x05n8\x02\u02DD\u02DE\x07F\x02\x02\u02DE" +
-    "\u02EA\x05n8\x02\u02DF\u02E0\x07G\x02\x02\u02E0\u02EA\x05n8\x02\u02E1" +
-    "\u02E2\x07H\x02\x02\u02E2\u02EA\x05n8\x02\u02E3\u02E4\x07I\x02\x02\u02E4" +
-    "\u02EA\x05n8\x02\u02E5\u02E6\x07J\x02\x02\u02E6\u02EA\x05n8\x02\u02E7" +
-    "\u02E8\x07K\x02\x02\u02E8\u02EA\x05n8\x02\u02E9\u02DA\x03\x02\x02\x02" +
-    "\u02E9\u02DB\x03\x02\x02\x02\u02E9\u02DD\x03\x02\x02\x02\u02E9\u02DF\x03" +
-    "\x02\x02\x02\u02E9\u02E1\x03\x02\x02\x02\u02E9\u02E3\x03\x02\x02\x02\u02E9" +
-    "\u02E5\x03\x02\x02\x02\u02E9\u02E7\x03\x02\x02\x02\u02EAo\x03\x02\x02" +
-    "\x02\u02EB\u02EC\b9\x01\x02\u02EC\u02ED\x05r:\x02\u02ED\u02F7\x03\x02" +
-    "\x02\x02\u02EE\u02F0\f\x03\x02\x02\u02EF\u02F1\x07E\x02\x02\u02F0\u02EF" +
-    "\x03\x02\x02\x02\u02F0\u02F1\x03\x02\x02\x02\u02F1\u02F2\x03\x02\x02\x02" +
-    "\u02F2\u02F3\x05@!\x02\u02F3\u02F4\x05r:\x02\u02F4\u02F6\x03\x02\x02\x02" +
-    "\u02F5\u02EE\x03\x02\x02\x02\u02F6\u02F9\x03\x02\x02\x02\u02F7\u02F5\x03" +
-    "\x02\x02\x02\u02F7\u02F8\x03\x02\x02\x02\u02F8q\x03\x02\x02\x02\u02F9" +
-    "\u02F7\x03\x02\x02\x02\u02FA\u02FE\x05t;\x02\u02FB\u02FC\t\f\x02\x02\u02FC" +
-    "\u02FE\x05t;\x02\u02FD\u02FA\x03\x02\x02\x02\u02FD\u02FB\x03\x02\x02\x02" +
-    "\u02FEs\x03\x02\x02\x02\u02FF\u0300\b;\x01\x02\u0300\u0301\x05v<\x02\u0301" +
-    "\u0307\x03\x02\x02\x02\u0302\u0303\f\x03\x02\x02\u0303\u0304\t\r\x02\x02" +
-    "\u0304\u0306\x05x=\x02\u0305\u0302\x03\x02\x02\x02\u0306\u0309\x03\x02" +
-    "\x02\x02\u0307\u0305\x03\x02\x02\x02\u0307\u0308\x03\x02\x02\x02\u0308" +
-    "u\x03\x02\x02\x02\u0309\u0307\x03\x02\x02\x02\u030A\u030E\x05x=\x02\u030B" +
-    "\u030C\x07L\x02\x02\u030C\u030E\x05v<\x02\u030D\u030A\x03\x02\x02\x02" +
-    "\u030D\u030B\x03\x02\x02\x02\u030Ew\x03\x02\x02\x02\u030F\u0310\b=\x01" +
-    "\x02\u0310\u0311\x05z>\x02\u0311\u0317\x03\x02\x02\x02\u0312\u0313\f\x03" +
-    "\x02\x02\u0313\u0314\x07M\x02\x02\u0314\u0316\x05z>\x02\u0315\u0312\x03" +
-    "\x02\x02\x02\u0316\u0319\x03\x02\x02\x02\u0317\u0315\x03\x02\x02\x02\u0317" +
-    "\u0318\x03\x02\x02\x02\u0318y\x03\x02\x02\x02\u0319\u0317\x03\x02\x02" +
-    "\x02\u031A\u031B\b>\x01\x02\u031B\u031C\x05|?\x02\u031C\u0322\x03\x02" +
-    "\x02\x02\u031D\u031E\f\x03\x02\x02\u031E\u031F\x07N\x02\x02\u031F\u0321" +
-    "\x05|?\x02\u0320\u031D\x03\x02\x02\x02\u0321\u0324\x03\x02\x02\x02\u0322" +
-    "\u0320\x03\x02\x02\x02\u0322\u0323\x03\x02\x02\x02\u0323{\x03\x02\x02" +
-    "\x02\u0324\u0322\x03\x02\x02\x02\u0325\u0326\b?\x01\x02\u0326\u0327\x05" +
-    "~@\x02\u0327\u032E\x03\x02\x02\x02\u0328\u0329\f\x03\x02\x02\u0329\u032A" +
-    "\x05> \x02\u032A\u032B\x05~@\x02\u032B\u032D\x03\x02\x02\x02\u032C\u0328" +
-    "\x03\x02\x02\x02\u032D\u0330\x03\x02\x02\x02\u032E\u032C\x03\x02\x02\x02" +
-    "\u032E\u032F\x03\x02\x02\x02\u032F}\x03\x02\x02\x02\u0330\u032E\x03\x02" +
-    "\x02\x02\u0331\u0332\b@\x01\x02\u0332\u0333\x05\x80A\x02\u0333\u0339\x03" +
-    "\x02\x02\x02\u0334\u0335\f\x03\x02\x02\u0335\u0336\t\x0E\x02\x02\u0336" +
-    "\u0338\x05\x80A\x02\u0337\u0334\x03\x02\x02\x02\u0338\u033B\x03\x02\x02" +
-    "\x02\u0339\u0337\x03\x02\x02\x02\u0339\u033A\x03\x02\x02\x02\u033A\x7F" +
-    "\x03\x02\x02\x02\u033B\u0339\x03\x02\x02\x02\u033C\u033D\bA\x01\x02\u033D" +
-    "\u033E\x05\x82B\x02\u033E\u0346\x03\x02\x02\x02\u033F\u0340\f\x03\x02" +
-    "\x02\u0340\u0341\x07\x04\x02\x02\u0341\u0342\x05^0\x02\u0342\u0343\x07" +
-    "\x05\x02\x02\u0343\u0345\x03\x02\x02\x02\u0344\u033F\x03\x02\x02\x02\u0345" +
-    "\u0348\x03\x02\x02\x02\u0346\u0344\x03\x02\x02\x02\u0346\u0347\x03\x02" +
-    "\x02\x02\u0347\x81\x03\x02\x02\x02\u0348\u0346\x03\x02\x02\x02\u0349\u034A" +
-    "\bB\x01\x02\u034A\u0351\x05\x84C\x02\u034B\u034C\x05N(\x02\u034C\u034D" +
-    "\x07\x04\x02\x02\u034D\u034E\x05^0\x02\u034E\u034F\x07\x05\x02\x02\u034F" +
-    "\u0351\x03\x02\x02\x02\u0350\u0349\x03\x02\x02\x02\u0350\u034B\x03\x02" +
-    "\x02\x02\u0351\u0357\x03\x02\x02\x02\u0352\u0353\f\x04\x02\x02\u0353\u0354" +
-    "\x07\x1B\x02\x02\u0354\u0356\x05\x84C\x02\u0355\u0352\x03\x02\x02\x02" +
-    "\u0356\u0359\x03\x02\x02\x02\u0357\u0355\x03\x02\x02\x02\u0357\u0358\x03" +
-    "\x02\x02\x02\u0358\x83\x03\x02\x02\x02\u0359\u0357\x03\x02\x02\x02\u035A" +
-    "\u035B\bC\x01\x02\u035B\u035C\x05\x86D\x02\u035C\u0361\x03\x02\x02\x02" +
-    "\u035D\u035E\f\x03\x02\x02\u035E\u0360\x07Q\x02\x02\u035F\u035D\x03\x02" +
-    "\x02\x02\u0360\u0363\x03\x02\x02\x02\u0361\u035F\x03\x02\x02\x02\u0361" +
-    "\u0362\x03\x02\x02\x02\u0362\x85\x03\x02\x02\x02\u0363\u0361\x03\x02\x02" +
-    "\x02\u0364\u0368\x05\x88E\x02\u0365\u0366\t\x0F\x02\x02\u0366\u0368\x05" +
-    "\x86D\x02\u0367\u0364\x03\x02\x02\x02\u0367\u0365\x03\x02\x02\x02\u0368" +
-    "\x87\x03\x02\x02\x02\u0369\u037C\x050\x19\x02\u036A\u037C\x05J&\x02\u036B" +
-    "\u036C\x07U\x02\x02\u036C\u037C\x05N(\x02\u036D\u036E\x07V\x02\x02\u036E" +
-    "\u037C\x05N(\x02\u036F\u037C\x07W\x02\x02\u0370\u0371\x07\v\x02\x02\u0371" +
-    "\u0372\x05V,\x02\u0372\u0373\x05F$\x02\u0373\u0374\x07\f\x02\x02\u0374" +
-    "\u037C\x03\x02\x02\x02\u0375\u0376\x07\x1D\x02\x02\u0376\u0377\x05`1\x02" +
-    "\u0377\u0378\x07\x1E\x02\x02\u0378\u037C\x03\x02\x02\x02\u0379\u037C\x05" +
-    "D#\x02\u037A\u037C\x05\x8EH\x02\u037B\u0369\x03\x02\x02\x02\u037B\u036A" +
-    "\x03\x02\x02\x02\u037B\u036B\x03\x02\x02\x02\u037B\u036D\x03\x02\x02\x02" +
-    "\u037B\u036F\x03\x02\x02\x02\u037B\u0370\x03\x02\x02\x02\u037B\u0375\x03" +
-    "\x02\x02\x02\u037B\u0379\x03\x02\x02\x02\u037B\u037A\x03\x02\x02\x02\u037C" +
-    "\x89\x03\x02\x02\x02\u037D\u0383\x05J&\x02\u037E\u037F\x05J&\x02\u037F" +
-    "\u0380\x07\\\x02\x02\u0380\u0381\x05\x8AF\x02\u0381\u0383\x03\x02\x02" +
-    "\x02\u0382\u037D\x03\x02\x02\x02\u0382\u037E\x03\x02\x02\x02\u0383\x8B" +
-    "\x03\x02\x02\x02\u0384\u0385\x05\x8EH\x02\u0385\x8D\x03\x02\x02\x02\u0386" +
-    "\u0387\x07X\x02\x02\u0387\x8F\x03\x02\x02\x02\u0388\u0389\x07Y\x02\x02" +
-    "\u0389\u038A\x05N(\x02\u038A\u038C\x05\x9EP\x02\u038B\u038D\x05,\x17\x02" +
-    "\u038C\u038B\x03\x02\x02\x02\u038C\u038D\x03\x02\x02\x02\u038D\x91\x03" +
-    "\x02\x02\x02\u038E\u038F\x05\x1A\x0E\x02\u038F\x93\x03\x02\x02\x02\u0390" +
-    "\u0391\x07Z\x02\x02\u0391\u0392\x05`1\x02\u0392\x95\x03\x02\x02\x02\u0393" +
-    "\u0394\x07[\x02\x02\u0394\u0395\x05N(\x02\u0395\u0396\x07)\x02\x02\u0396" +
-    "\u0397\x05`1\x02\u0397\u0398\x07\"\x02\x02\u0398\u0399\x05\x9EP\x02\u0399" +
-    "\x97\x03\x02\x02\x02\u039A\u039B\x05N(\x02\u039B\u039C\x07\x18\x02\x02" +
-    "\u039C\u039D\x05\x8AF\x02\u039D\u039E\x07a\x02\x02\u039E\u039F\x05`1\x02" +
-    "\u039F\x99\x03\x02\x02\x02\u03A0\u03A6\x05\x9CO\x02\u03A1\u03A2\x05\x9C" +
-    "O\x02\u03A2\u03A3\x07k\x02\x02\u03A3\u03A4\x05\x9AN\x02\u03A4\u03A6\x03" +
-    "\x02\x02\x02\u03A5\u03A0\x03\x02\x02\x02\u03A5\u03A1\x03\x02\x02\x02\u03A6" +
-    "\x9B\x03\x02\x02\x02\u03A7\u03A8\x07m\x02\x02\u03A8\x9D\x03\x02\x02\x02" +
-    "\u03A9\u03AD\x07\v\x02\x02\u03AA\u03AC\x05\xA2R\x02\u03AB\u03AA\x03\x02" +
-    "\x02\x02\u03AC\u03AF\x03\x02\x02\x02\u03AD\u03AB\x03\x02\x02\x02\u03AD" +
-    "\u03AE\x03\x02\x02\x02\u03AE\u03B0\x03\x02\x02\x02\u03AF\u03AD\x03\x02" +
-    "\x02\x02\u03B0\u03B6\x07\f\x02\x02\u03B1\u03B3\x07$\x02\x02\u03B2\u03B1" +
-    "\x03\x02\x02\x02\u03B2\u03B3\x03\x02\x02\x02\u03B3\u03B4\x03\x02\x02\x02" +
-    "\u03B4\u03B6\x05J&\x02\u03B5\u03A9\x03\x02\x02\x02\u03B5\u03B2\x03\x02" +
-    "\x02\x02\u03B6\x9F\x03\x02\x02\x02\u03B7\u03B8\x07V\x02\x02\u03B8\u03BD" +
-    "\x05N(\x02\u03B9\u03BD\x05\x9CO\x02\u03BA\u03BB\x07(\x02\x02\u03BB\u03BD" +
-    "\x05\x9CO\x02\u03BC\u03B7\x03\x02\x02\x02\u03BC\u03B9\x03\x02\x02\x02" +
-    "\u03BC\u03BA\x03\x02\x02\x02\u03BD\xA1\x03\x02\x02\x02\u03BE\u03BF\x05" +
-    "\xA4S\x02\u03BF\u03C0\x05@!\x02\u03C0\u03C1\x05\xA6T\x02\u03C1\u03C6\x03" +
-    "\x02\x02\x02\u03C2\u03C3\x07g\x02\x02\u03C3\u03C6\x05\xA4S\x02\u03C4\u03C6" +
-    "\x05J&\x02\u03C5\u03BE\x03\x02\x02\x02\u03C5\u03C2\x03\x02\x02\x02\u03C5" +
-    "\u03C4\x03\x02\x02\x02\u03C6\xA3\x03\x02\x02\x02\u03C7\u03C8\x07L\x02" +
-    "\x02\u03C8\u03D2\x05J&\x02\u03C9\u03D2\x05J&\x02\u03CA\u03CD\x05\xA0Q" +
-    "\x02\u03CB\u03CC\x07\x1B\x02\x02\u03CC\u03CE\x05J&\x02\u03CD\u03CB\x03" +
-    "\x02\x02\x02\u03CE\u03CF\x03\x02\x02\x02\u03CF\u03CD\x03\x02\x02\x02\u03CF" +
-    "\u03D0\x03\x02\x02\x02\u03D0\u03D2\x03\x02\x02\x02\u03D1\u03C7\x03\x02" +
-    "\x02\x02\u03D1\u03C9\x03\x02\x02\x02\u03D1\u03CA\x03\x02\x02\x02\u03D2" +
-    "\xA5\x03\x02\x02\x02\u03D3\u03D4\bT\x01\x02\u03D4\u03DA\x05\xA8U\x02\u03D5" +
-    "\u03D6\x07\x1D\x02\x02\u03D6\u03D7\x05\xA6T\x02\u03D7\u03D8\x07\x1E\x02" +
-    "\x02\u03D8\u03DA\x03\x02\x02\x02\u03D9\u03D3\x03\x02\x02\x02\u03D9\u03D5" +
-    "\x03\x02\x02\x02\u03DA\u03E0\x03\x02\x02\x02\u03DB\u03DC\f\x04\x02\x02" +
-    "\u03DC\u03DD\x07\x0F\x02\x02\u03DD\u03DF\x05\xA8U\x02\u03DE\u03DB\x03" +
-    "\x02\x02\x02\u03DF\u03E2\x03\x02\x02\x02\u03E0\u03DE\x03\x02\x02\x02\u03E0" +
-    "\u03E1\x03\x02\x02\x02\u03E1\xA7\x03\x02\x02\x02\u03E2\u03E0\x03\x02\x02" +
-    "\x02\u03E3\u03E4\bU\x01\x02\u03E4\u03E5\x07\x1D\x02\x02\u03E5\u03E6\x05" +
-    "\xA8U\x02\u03E6\u03E7\x07\x1E\x02\x02\u03E7\u03EA\x03\x02\x02\x02\u03E8" +
-    "\u03EA\x05\xAAV\x02\u03E9\u03E3\x03\x02\x02\x02\u03E9\u03E8\x03\x02\x02" +
-    "\x02\u03EA\u03F0\x03\x02\x02\x02\u03EB\u03EC\f\x04\x02\x02\u03EC\u03ED" +
-    "\t\x10\x02\x02\u03ED\u03EF\x05\xAAV\x02\u03EE\u03EB\x03\x02\x02\x02\u03EF" +
-    "\u03F2\x03\x02\x02\x02\u03F0\u03EE\x03\x02\x02\x02\u03F0\u03F1\x03\x02" +
-    "\x02\x02\u03F1\xA9\x03\x02\x02\x02\u03F2\u03F0\x03\x02\x02\x02\u03F3\u03FA" +
-    "\x05\xA0Q\x02\u03F4\u03FA\x05J&\x02\u03F5\u03F6\x07\x1D\x02\x02\u03F6" +
-    "\u03F7\x05\xA6T\x02\u03F7\u03F8\x07\x1E\x02\x02\u03F8\u03FA\x03\x02\x02" +
-    "\x02\u03F9\u03F3\x03\x02\x02\x02\u03F9\u03F4\x03\x02\x02\x02\u03F9\u03F5" +
-    "\x03\x02\x02\x02\u03FA\xAB\x03\x02\x02\x02x\xAE\xB3\xB7\xC1\xC7\xCD\xD0" +
+    "\u01B0\u01B1\x03\x02\x02\x02\u01B1\u01B4\x05\x9CO\x02\u01B2\u01B4\x07" +
+    "\x07\x02\x02\u01B3\u01AB\x03\x02\x02\x02\u01B3\u01AC\x03\x02\x02\x02\u01B3" +
+    "\u01AD\x03\x02\x02\x02\u01B3\u01AF\x03\x02\x02\x02\u01B3\u01B2\x03\x02" +
+    "\x02\x02\u01B41\x03\x02\x02\x02\u01B5\u01B6\x07\x1F\x02\x02\u01B6\u01B7" +
+    "\x05`1\x02\u01B7\u01B8\x07)\x02\x02\u01B8\u01BA\t\x07\x02\x02\u01B9\u01BB" +
+    "\x05,\x17\x02\u01BA\u01B9";
+ForgeParser._serializedATNSegment1 = "\x03\x02\x02\x02\u01BA\u01BB\x03\x02\x02\x02\u01BB\u01BE\x03\x02\x02\x02" +
+    "\u01BC\u01BD\x07\"\x02\x02\u01BD\u01BF\x05\x9EP\x02\u01BE\u01BC\x03\x02" +
+    "\x02\x02\u01BE\u01BF\x03\x02\x02\x02\u01BF3\x03\x02\x02\x02\u01C0\u01C1" +
+    "\x07\x1F\x02\x02\u01C1\u01C3\x073\x02\x02\u01C2\u01C4\x07\x17\x02\x02" +
+    "\u01C3\u01C2\x03\x02\x02\x02\u01C3\u01C4\x03\x02\x02\x02\u01C4\u01C5\x03" +
+    "\x02\x02\x02\u01C5\u01C6\x05V,\x02\u01C6\u01C7\x072\x02\x02\u01C7\u01C8" +
+    "\x05`1\x02\u01C8\u01C9\x07)\x02\x02\u01C9\u01CA\t\b\x02\x02\u01CA\u01CB" +
+    "\x07\"\x02\x02\u01CB\u01D0\x05N(\x02\u01CC\u01CD\x07\x04\x02\x02\u01CD" +
+    "\u01CE\x05^0\x02\u01CE\u01CF\x07\x05\x02\x02\u01CF\u01D1\x03\x02\x02\x02" +
+    "\u01D0\u01CC\x03\x02\x02\x02\u01D0\u01D1\x03\x02\x02\x02\u01D1\u01D3\x03" +
+    "\x02\x02\x02\u01D2\u01D4\x05,\x17\x02\u01D3\u01D2\x03\x02\x02\x02\u01D3" +
+    "\u01D4\x03\x02\x02\x02\u01D4\u01D7\x03\x02\x02\x02\u01D5\u01D6\x07\"\x02" +
+    "\x02\u01D6\u01D8\x05\x9EP\x02\u01D7\u01D5\x03\x02\x02\x02\u01D7\u01D8" +
+    "\x03\x02\x02\x02\u01D85\x03\x02\x02\x02\u01D9\u01DA\x07\x1F\x02\x02\u01DA" +
+    "\u01DB\x05`1\x02\u01DB\u01DC\x07)\x02\x02\u01DC\u01DD\t\b\x02\x02\u01DD" +
+    "\u01DE\x07\"\x02\x02\u01DE\u01E0\x05N(\x02\u01DF\u01E1\x05,\x17\x02\u01E0" +
+    "\u01DF\x03\x02\x02\x02\u01E0\u01E1\x03\x02\x02\x02\u01E1\u01E4\x03\x02" +
+    "\x02\x02\u01E2\u01E3\x07\"\x02\x02\u01E3\u01E5\x05\x9EP\x02\u01E4\u01E2" +
+    "\x03\x02\x02\x02\u01E4\u01E5\x03\x02\x02\x02\u01E57\x03\x02\x02\x02\u01E6" +
+    "\u01E7\x07\x1F\x02\x02\u01E7\u01E8\x05`1\x02\u01E8\u01E9\x07)\x02\x02" +
+    "\u01E9\u01EA\t\t\x02\x02\u01EA\u01EB\x078\x02\x02\u01EB\u01ED\x05N(\x02" +
+    "\u01EC\u01EE\x05,\x17\x02\u01ED\u01EC\x03\x02\x02\x02\u01ED\u01EE\x03" +
+    "\x02\x02\x02\u01EE\u01F1\x03\x02\x02\x02\u01EF\u01F0\x07\"\x02\x02\u01F0" +
+    "\u01F2\x05\x9EP\x02\u01F1\u01EF\x03\x02\x02\x02\u01F1\u01F2\x03\x02\x02" +
+    "\x02\u01F29\x03\x02\x02\x02\u01F3\u01F4\x07/\x02\x02\u01F4\u01F5\x071" +
+    "\x02\x02\u01F5\u01F6\x07\"\x02\x02\u01F6\u01F7\x05N(\x02\u01F7\u01FB\x07" +
+    "\v\x02\x02\u01F8\u01FA\x05<\x1F\x02\u01F9\u01F8\x03\x02\x02\x02\u01FA" +
+    "\u01FD\x03\x02\x02\x02\u01FB\u01F9\x03\x02\x02\x02\u01FB\u01FC\x03\x02" +
+    "\x02\x02\u01FC\u01FE\x03\x02\x02\x02\u01FD\u01FB\x03\x02\x02\x02\u01FE" +
+    "\u01FF\x07\f\x02\x02\u01FF;\x03\x02\x02\x02\u0200\u0207\x05\x96L\x02\u0201" +
+    "\u0207\x05(\x15\x02\u0202\u0207\x054\x1B\x02\u0203\u0207\x056\x1C\x02" +
+    "\u0204\u0207\x052\x1A\x02\u0205\u0207\x058\x1D\x02\u0206\u0200\x03\x02" +
+    "\x02\x02\u0206\u0201\x03\x02\x02\x02\u0206\u0202\x03\x02\x02\x02\u0206" +
+    "\u0203\x03\x02\x02\x02\u0206\u0204\x03\x02\x02\x02\u0206\u0205\x03\x02" +
+    "\x02\x02\u0207=\x03\x02\x02\x02\u0208\u020B\x05\x10\t\x02\u0209\u020B" +
+    "\x07\x14\x02\x02\u020A\u0208\x03\x02\x02\x02\u020A\u0209\x03\x02\x02\x02" +
+    "\u020A\u020B\x03\x02\x02\x02\u020B\u020C\x03\x02\x02\x02\u020C\u020F\x07" +
+    "\\\x02\x02\u020D\u0210\x05\x10\t\x02\u020E\u0210\x07\x14\x02\x02\u020F" +
+    "\u020D\x03\x02\x02\x02\u020F\u020E\x03\x02\x02\x02\u020F\u0210\x03\x02" +
+    "\x02\x02\u0210?\x03\x02\x02\x02\u0211\u0212\t\n\x02\x02\u0212A\x03\x02" +
+    "\x02\x02\u0213\u0214\x05N(\x02\u0214\u0215\x07a\x02\x02\u0215\u0216\x05" +
+    "`1\x02\u0216C\x03\x02\x02\x02\u0217\u021B\x07\v\x02\x02\u0218\u021A\x05" +
+    "`1\x02\u0219\u0218\x03\x02\x02\x02\u021A\u021D\x03\x02\x02\x02\u021B\u0219" +
+    "\x03\x02\x02\x02\u021B\u021C\x03\x02\x02\x02\u021C\u021E\x03\x02\x02\x02" +
+    "\u021D\u021B\x03\x02\x02\x02\u021E\u021F\x07\f\x02\x02\u021FE\x03\x02" +
+    "\x02\x02\u0220\u0224\x05D#\x02\u0221\u0222\x072\x02\x02\u0222\u0224\x05" +
+    "`1\x02\u0223\u0220\x03\x02\x02\x02\u0223\u0221\x03\x02\x02\x02\u0224G" +
+    "\x03\x02\x02\x02\u0225\u022A\x073\x02\x02\u0226\u022A\x07g\x02\x02\u0227" +
+    "\u022A\x07h\x02\x02\u0228\u022A\x05\x10\t\x02\u0229\u0225\x03\x02\x02" +
+    "\x02\u0229\u0226\x03\x02\x02\x02\u0229\u0227\x03\x02\x02\x02\u0229\u0228" +
+    "\x03\x02\x02\x02\u022AI\x03\x02\x02\x02\u022B\u022C\x07W\x02\x02\u022C" +
+    "\u022E\x07l\x02\x02\u022D\u022B\x03\x02\x02\x02\u022D\u022E\x03\x02\x02" +
+    "\x02\u022E\u0234\x03\x02\x02\x02\u022F\u0230\x05N(\x02\u0230\u0231\x07" +
+    "l\x02\x02\u0231\u0233\x03\x02\x02\x02\u0232\u022F\x03\x02\x02\x02\u0233" +
+    "\u0236\x03\x02\x02\x02\u0234\u0232\x03\x02\x02\x02\u0234\u0235\x03\x02" +
+    "\x02\x02\u0235\u0237\x03\x02\x02\x02\u0236\u0234\x03\x02\x02\x02\u0237" +
+    "\u023B\x05N(\x02\u0238\u023B\x07i\x02\x02\u0239\u023B\x07h\x02\x02\u023A" +
+    "\u022D\x03\x02\x02\x02\u023A\u0238\x03\x02\x02\x02\u023A\u0239\x03\x02" +
+    "\x02\x02\u023BK\x03\x02\x02\x02\u023C\u023D\x07j\x02\x02\u023D\u0244\x05" +
+    "J&\x02\u023E\u0245\x05J&\x02\u023F\u0245\x07\x07\x02\x02\u0240\u0242\x07" +
+    "(\x02\x02\u0241\u0240\x03\x02\x02\x02\u0241\u0242\x03\x02\x02\x02\u0242" +
+    "\u0243\x03\x02\x02\x02\u0243\u0245\x05\x9CO\x02\u0244\u023E\x03\x02\x02" +
+    "\x02\u0244\u023F\x03\x02\x02\x02\u0244\u0241\x03\x02\x02\x02\u0245M\x03" +
+    "\x02\x02\x02\u0246\u0247\t\v\x02\x02\u0247O\x03\x02\x02\x02\u0248\u024E" +
+    "\x05N(\x02\u0249\u024A\x05N(\x02\u024A\u024B\x07k\x02\x02\u024B\u024C" +
+    "\x05P)\x02\u024C\u024E\x03\x02\x02\x02\u024D\u0248\x03\x02\x02\x02\u024D" +
+    "\u0249\x03\x02\x02\x02\u024EQ\x03\x02\x02\x02\u024F\u0255\x05J&\x02\u0250" +
+    "\u0251\x05J&\x02\u0251\u0252\x07k\x02\x02\u0252\u0253\x05R*\x02\u0253" +
+    "\u0255\x03\x02\x02\x02\u0254\u024F\x03\x02\x02\x02\u0254\u0250\x03\x02" +
+    "\x02\x02\u0255S\x03\x02\x02\x02\u0256\u025C\x05\x16\f\x02\u0257\u0258" +
+    "\x05\x16\f\x02\u0258\u0259\x07k\x02\x02\u0259\u025A\x05T+\x02\u025A\u025C" +
+    "\x03\x02\x02\x02\u025B\u0256\x03\x02\x02\x02\u025B\u0257\x03\x02\x02\x02" +
+    "\u025CU\x03\x02\x02\x02\u025D\u0263\x05\x18\r\x02\u025E\u025F\x05\x18" +
+    "\r\x02\u025F\u0260\x07k\x02\x02\u0260\u0261\x05V,\x02\u0261\u0263\x03" +
+    "\x02\x02\x02\u0262\u025D\x03\x02\x02\x02\u0262\u025E\x03\x02\x02\x02\u0263" +
+    "W\x03\x02\x02\x02\u0264\u026A\x05\x1A\x0E\x02\u0265\u0266\x05\x1A\x0E" +
+    "\x02\u0266\u0267\x07k\x02\x02\u0267\u0268\x05X-\x02\u0268\u026A\x03\x02" +
+    "\x02\x02\u0269\u0264\x03\x02\x02\x02\u0269\u0265\x03\x02\x02\x02\u026A" +
+    "Y\x03\x02\x02\x02\u026B\u0271\x05B\"\x02\u026C\u026D\x05B\"\x02\u026D" +
+    "\u026E\x07k\x02\x02\u026E\u026F\x05Z.\x02\u026F\u0271\x03\x02\x02\x02" +
+    "\u0270\u026B\x03\x02\x02\x02\u0270\u026C\x03\x02\x02\x02\u0271[\x03\x02" +
+    "\x02\x02\u0272\u0278\x05.\x18\x02\u0273\u0274\x05.\x18\x02\u0274\u0275" +
+    "\x07k\x02\x02\u0275\u0276\x05\\/\x02\u0276\u0278\x03\x02\x02\x02\u0277" +
+    "\u0272\x03\x02\x02\x02\u0277\u0273\x03\x02\x02\x02\u0278]\x03\x02\x02" +
+    "\x02\u0279\u027F\x05`1\x02\u027A\u027B\x05`1\x02\u027B\u027C\x07k\x02" +
+    "\x02\u027C\u027D\x05^0\x02\u027D\u027F\x03\x02\x02\x02\u027E\u0279\x03" +
+    "\x02\x02\x02\u027E\u027A\x03\x02\x02\x02\u027F_\x03\x02\x02\x02\u0280" +
+    "\u0291\x05b2\x02\u0281\u0282\x079\x02\x02\u0282\u0283\x05Z.\x02\u0283" +
+    "\u0284\x05F$\x02\u0284\u0291\x03\x02\x02\x02\u0285\u0286\x07:\x02\x02" +
+    "\u0286\u0287\x05Z.\x02\u0287\u0288\x05F$\x02\u0288\u0291\x03\x02\x02\x02" +
+    "\u0289\u028B\x05H%\x02\u028A\u028C\x07\x17\x02\x02\u028B\u028A\x03\x02" +
+    "\x02\x02\u028B\u028C\x03\x02\x02\x02\u028C\u028D\x03\x02\x02\x02\u028D" +
+    "\u028E\x05V,\x02\u028E\u028F\x05F$\x02\u028F\u0291\x03\x02\x02\x02\u0290" +
+    "\u0280\x03\x02\x02\x02\u0290\u0281\x03\x02\x02\x02\u0290\u0285\x03\x02" +
+    "\x02\x02\u0290\u0289\x03\x02\x02\x02\u0291a\x03\x02\x02\x02\u0292\u0293" +
+    "\b2\x01\x02\u0293\u0294\x05d3\x02\u0294\u029A\x03\x02\x02\x02\u0295\u0296" +
+    "\f\x03\x02\x02\u0296\u0297\x07;\x02\x02\u0297\u0299\x05d3\x02\u0298\u0295" +
+    "\x03\x02\x02\x02\u0299\u029C\x03\x02\x02\x02\u029A\u0298\x03\x02\x02\x02" +
+    "\u029A\u029B\x03\x02\x02\x02\u029Bc\x03\x02\x02\x02\u029C\u029A\x03\x02" +
+    "\x02\x02\u029D\u029E\b3\x01\x02\u029E\u029F\x05f4\x02\u029F\u02A5\x03" +
+    "\x02\x02\x02\u02A0\u02A1\f\x03\x02\x02\u02A1\u02A2\x07<\x02\x02\u02A2" +
+    "\u02A4\x05f4\x02\u02A3\u02A0\x03\x02\x02\x02\u02A4\u02A7\x03\x02\x02\x02" +
+    "\u02A5\u02A3\x03\x02\x02\x02\u02A5\u02A6\x03\x02\x02\x02\u02A6e\x03\x02" +
+    "\x02\x02\u02A7\u02A5\x03\x02\x02\x02\u02A8\u02A9\b4\x01\x02\u02A9\u02AA" +
+    "\x05h5\x02\u02AA\u02B0\x03\x02\x02\x02\u02AB\u02AC\f\x03\x02\x02\u02AC" +
+    "\u02AD\x07=\x02\x02\u02AD\u02AF\x05h5\x02\u02AE\u02AB\x03\x02\x02\x02" +
+    "\u02AF\u02B2\x03\x02\x02\x02\u02B0\u02AE\x03\x02\x02\x02\u02B0\u02B1\x03" +
+    "\x02\x02\x02\u02B1g\x03\x02\x02\x02\u02B2\u02B0\x03\x02\x02\x02\u02B3" +
+    "\u02BC\x05j6\x02\u02B4\u02B5\x05j6\x02\u02B5\u02B6\x07>\x02\x02\u02B6" +
+    "\u02B9\x05h5\x02\u02B7\u02B8\x07?\x02\x02\u02B8\u02BA\x05h5\x02\u02B9" +
+    "\u02B7\x03\x02\x02\x02\u02B9\u02BA\x03\x02\x02\x02\u02BA\u02BC\x03\x02" +
+    "\x02\x02\u02BB\u02B3\x03\x02\x02\x02\u02BB\u02B4\x03\x02\x02\x02\u02BC" +
+    "i\x03\x02\x02\x02\u02BD\u02BE\b6\x01\x02\u02BE\u02BF\x05l7\x02\u02BF\u02C5" +
+    "\x03\x02\x02\x02\u02C0\u02C1\f\x03\x02\x02\u02C1\u02C2\x07@\x02\x02\u02C2" +
+    "\u02C4\x05l7\x02\u02C3\u02C0\x03\x02\x02\x02\u02C4\u02C7\x03\x02\x02\x02" +
+    "\u02C5\u02C3\x03\x02\x02\x02\u02C5\u02C6\x03\x02\x02\x02\u02C6k\x03\x02" +
+    "\x02\x02\u02C7\u02C5\x03\x02\x02\x02\u02C8\u02DA\x05n8\x02\u02C9\u02CA" +
+    "\x05n8\x02\u02CA\u02CB\x07A\x02\x02\u02CB\u02CC\x05n8\x02\u02CC\u02DA" +
+    "\x03\x02\x02\x02\u02CD\u02CE\x05n8\x02\u02CE\u02CF\x07B\x02\x02\u02CF" +
+    "\u02D0\x05n8\x02\u02D0\u02DA\x03\x02\x02\x02\u02D1\u02D2\x05n8\x02\u02D2" +
+    "\u02D3\x07C\x02\x02\u02D3\u02D4\x05n8\x02\u02D4\u02DA\x03\x02\x02\x02" +
+    "\u02D5\u02D6\x05n8\x02\u02D6\u02D7\x07D\x02\x02\u02D7\u02D8\x05n8\x02" +
+    "\u02D8\u02DA\x03\x02\x02\x02\u02D9\u02C8\x03\x02\x02\x02\u02D9\u02C9\x03" +
+    "\x02\x02\x02\u02D9\u02CD\x03\x02\x02\x02\u02D9\u02D1\x03\x02\x02\x02\u02D9" +
+    "\u02D5\x03\x02\x02\x02\u02DAm\x03\x02\x02\x02\u02DB\u02EB\x05p9\x02\u02DC" +
+    "\u02DD\x07E\x02\x02\u02DD\u02EB\x05n8\x02\u02DE\u02DF\x07F\x02\x02\u02DF" +
+    "\u02EB\x05n8\x02\u02E0\u02E1\x07G\x02\x02\u02E1\u02EB\x05n8\x02\u02E2" +
+    "\u02E3\x07H\x02\x02\u02E3\u02EB\x05n8\x02\u02E4\u02E5\x07I\x02\x02\u02E5" +
+    "\u02EB\x05n8\x02\u02E6\u02E7\x07J\x02\x02\u02E7\u02EB\x05n8\x02\u02E8" +
+    "\u02E9\x07K\x02\x02\u02E9\u02EB\x05n8\x02\u02EA\u02DB\x03\x02\x02\x02" +
+    "\u02EA\u02DC\x03\x02\x02\x02\u02EA\u02DE\x03\x02\x02\x02\u02EA\u02E0\x03" +
+    "\x02\x02\x02\u02EA\u02E2\x03\x02\x02\x02\u02EA\u02E4\x03\x02\x02\x02\u02EA" +
+    "\u02E6\x03\x02\x02\x02\u02EA\u02E8\x03\x02\x02\x02\u02EBo\x03\x02\x02" +
+    "\x02\u02EC\u02ED\b9\x01\x02\u02ED\u02EE\x05r:\x02\u02EE\u02F8\x03\x02" +
+    "\x02\x02\u02EF\u02F1\f\x03\x02\x02\u02F0\u02F2\x07E\x02\x02\u02F1\u02F0" +
+    "\x03\x02\x02\x02\u02F1\u02F2\x03\x02\x02\x02\u02F2\u02F3\x03\x02\x02\x02" +
+    "\u02F3\u02F4\x05@!\x02\u02F4\u02F5\x05r:\x02\u02F5\u02F7\x03\x02\x02\x02" +
+    "\u02F6\u02EF\x03\x02\x02\x02\u02F7\u02FA\x03\x02\x02\x02\u02F8\u02F6\x03" +
+    "\x02\x02\x02\u02F8\u02F9\x03\x02\x02\x02\u02F9q\x03\x02\x02\x02\u02FA" +
+    "\u02F8\x03\x02\x02\x02\u02FB\u02FF\x05t;\x02\u02FC\u02FD\t\f\x02\x02\u02FD" +
+    "\u02FF\x05t;\x02\u02FE\u02FB\x03\x02\x02\x02\u02FE\u02FC\x03\x02\x02\x02" +
+    "\u02FFs\x03\x02\x02\x02\u0300\u0301\b;\x01\x02\u0301\u0302\x05v<\x02\u0302" +
+    "\u0308\x03\x02\x02\x02\u0303\u0304\f\x03\x02\x02\u0304\u0305\t\r\x02\x02" +
+    "\u0305\u0307\x05x=\x02\u0306\u0303\x03\x02\x02\x02\u0307\u030A\x03\x02" +
+    "\x02\x02\u0308\u0306\x03\x02\x02\x02\u0308\u0309\x03\x02\x02\x02\u0309" +
+    "u\x03\x02\x02\x02\u030A\u0308\x03\x02\x02\x02\u030B\u030F\x05x=\x02\u030C" +
+    "\u030D\x07L\x02\x02\u030D\u030F\x05v<\x02\u030E\u030B\x03\x02\x02\x02" +
+    "\u030E\u030C\x03\x02\x02\x02\u030Fw\x03\x02\x02\x02\u0310\u0311\b=\x01" +
+    "\x02\u0311\u0312\x05z>\x02\u0312\u0318\x03\x02\x02\x02\u0313\u0314\f\x03" +
+    "\x02\x02\u0314\u0315\x07M\x02\x02\u0315\u0317\x05z>\x02\u0316\u0313\x03" +
+    "\x02\x02\x02\u0317\u031A\x03\x02\x02\x02\u0318\u0316\x03\x02\x02\x02\u0318" +
+    "\u0319\x03\x02\x02\x02\u0319y\x03\x02\x02\x02\u031A\u0318\x03\x02\x02" +
+    "\x02\u031B\u031C\b>\x01\x02\u031C\u031D\x05|?\x02\u031D\u0323\x03\x02" +
+    "\x02\x02\u031E\u031F\f\x03\x02\x02\u031F\u0320\x07N\x02\x02\u0320\u0322" +
+    "\x05|?\x02\u0321\u031E\x03\x02\x02\x02\u0322\u0325\x03\x02\x02\x02\u0323" +
+    "\u0321\x03\x02\x02\x02\u0323\u0324\x03\x02\x02\x02\u0324{\x03\x02\x02" +
+    "\x02\u0325\u0323\x03\x02\x02\x02\u0326\u0327\b?\x01\x02\u0327\u0328\x05" +
+    "~@\x02\u0328\u032F\x03\x02\x02\x02\u0329\u032A\f\x03\x02\x02\u032A\u032B" +
+    "\x05> \x02\u032B\u032C\x05~@\x02\u032C\u032E\x03\x02\x02\x02\u032D\u0329" +
+    "\x03\x02\x02\x02\u032E\u0331\x03\x02\x02\x02\u032F\u032D\x03\x02\x02\x02" +
+    "\u032F\u0330\x03\x02\x02\x02\u0330}\x03\x02\x02\x02\u0331\u032F\x03\x02" +
+    "\x02\x02\u0332\u0333\b@\x01\x02\u0333\u0334\x05\x80A\x02\u0334\u033A\x03" +
+    "\x02\x02\x02\u0335\u0336\f\x03\x02\x02\u0336\u0337\t\x0E\x02\x02\u0337" +
+    "\u0339\x05\x80A\x02\u0338\u0335\x03\x02\x02\x02\u0339\u033C\x03\x02\x02" +
+    "\x02\u033A\u0338\x03\x02\x02\x02\u033A\u033B\x03\x02\x02\x02\u033B\x7F" +
+    "\x03\x02\x02\x02\u033C\u033A\x03\x02\x02\x02\u033D\u033E\bA\x01\x02\u033E" +
+    "\u033F\x05\x82B\x02\u033F\u0347\x03\x02\x02\x02\u0340\u0341\f\x03\x02" +
+    "\x02\u0341\u0342\x07\x04\x02\x02\u0342\u0343\x05^0\x02\u0343\u0344\x07" +
+    "\x05\x02\x02\u0344\u0346\x03\x02\x02\x02\u0345\u0340\x03\x02\x02\x02\u0346" +
+    "\u0349\x03\x02\x02\x02\u0347\u0345\x03\x02\x02\x02\u0347\u0348\x03\x02" +
+    "\x02\x02\u0348\x81\x03\x02\x02\x02\u0349\u0347\x03\x02\x02\x02\u034A\u034B" +
+    "\bB\x01\x02\u034B\u0352\x05\x84C\x02\u034C\u034D\x05N(\x02\u034D\u034E" +
+    "\x07\x04\x02\x02\u034E\u034F\x05^0\x02\u034F\u0350\x07\x05\x02\x02\u0350" +
+    "\u0352\x03\x02\x02\x02\u0351\u034A\x03\x02\x02\x02\u0351\u034C\x03\x02" +
+    "\x02\x02\u0352\u0358\x03\x02\x02\x02\u0353\u0354\f\x04\x02\x02\u0354\u0355" +
+    "\x07\x1B\x02\x02\u0355\u0357\x05\x84C\x02\u0356\u0353\x03\x02\x02\x02" +
+    "\u0357\u035A\x03\x02\x02\x02\u0358\u0356\x03\x02\x02\x02\u0358\u0359\x03" +
+    "\x02\x02\x02\u0359\x83\x03\x02\x02\x02\u035A\u0358\x03\x02\x02\x02\u035B" +
+    "\u035C\bC\x01\x02\u035C\u035D\x05\x86D\x02\u035D\u0362\x03\x02\x02\x02" +
+    "\u035E\u035F\f\x03\x02\x02\u035F\u0361\x07Q\x02\x02\u0360\u035E\x03\x02" +
+    "\x02\x02\u0361\u0364\x03\x02\x02\x02\u0362\u0360\x03\x02\x02\x02\u0362" +
+    "\u0363\x03\x02\x02\x02\u0363\x85\x03\x02\x02\x02\u0364\u0362\x03\x02\x02" +
+    "\x02\u0365\u0369\x05\x88E\x02\u0366\u0367\t\x0F\x02\x02\u0367\u0369\x05" +
+    "\x86D\x02\u0368\u0365\x03\x02\x02\x02\u0368\u0366\x03\x02\x02\x02\u0369" +
+    "\x87\x03\x02\x02\x02\u036A\u037D\x050\x19\x02\u036B\u037D\x05J&\x02\u036C" +
+    "\u036D\x07U\x02\x02\u036D\u037D\x05N(\x02\u036E\u036F\x07V\x02\x02\u036F" +
+    "\u037D\x05N(\x02\u0370\u037D\x07W\x02\x02\u0371\u0372\x07\v\x02\x02\u0372" +
+    "\u0373\x05V,\x02\u0373\u0374\x05F$\x02\u0374\u0375\x07\f\x02\x02\u0375" +
+    "\u037D\x03\x02\x02\x02\u0376\u0377\x07\x1D\x02\x02\u0377\u0378\x05`1\x02" +
+    "\u0378\u0379\x07\x1E\x02\x02\u0379\u037D\x03\x02\x02\x02\u037A\u037D\x05" +
+    "D#\x02\u037B\u037D\x05\x8EH\x02\u037C\u036A\x03\x02\x02\x02\u037C\u036B" +
+    "\x03\x02\x02\x02\u037C\u036C\x03\x02\x02\x02\u037C\u036E\x03\x02\x02\x02" +
+    "\u037C\u0370\x03\x02\x02\x02\u037C\u0371\x03\x02\x02\x02\u037C\u0376\x03" +
+    "\x02\x02\x02\u037C\u037A\x03\x02\x02\x02\u037C\u037B\x03\x02\x02\x02\u037D" +
+    "\x89\x03\x02\x02\x02\u037E\u0384\x05J&\x02\u037F\u0380\x05J&\x02\u0380" +
+    "\u0381\x07\\\x02\x02\u0381\u0382\x05\x8AF\x02\u0382\u0384\x03\x02\x02" +
+    "\x02\u0383\u037E\x03\x02\x02\x02\u0383\u037F\x03\x02\x02\x02\u0384\x8B" +
+    "\x03\x02\x02\x02\u0385\u0386\x05\x8EH\x02\u0386\x8D\x03\x02\x02\x02\u0387" +
+    "\u0388\x07X\x02\x02\u0388\x8F\x03\x02\x02\x02\u0389\u038A\x07Y\x02\x02" +
+    "\u038A\u038B\x05N(\x02\u038B\u038D\x05\x9EP\x02\u038C\u038E\x05,\x17\x02" +
+    "\u038D\u038C\x03\x02\x02\x02\u038D\u038E\x03\x02\x02\x02\u038E\x91\x03" +
+    "\x02\x02\x02\u038F\u0390\x05\x1A\x0E\x02\u0390\x93\x03\x02\x02\x02\u0391" +
+    "\u0392\x07Z\x02\x02\u0392\u0393\x05`1\x02\u0393\x95\x03\x02\x02\x02\u0394" +
+    "\u0395\x07[\x02\x02\u0395\u0396\x05N(\x02\u0396\u0397\x07)\x02\x02\u0397" +
+    "\u0398\x05`1\x02\u0398\u0399\x07\"\x02\x02\u0399\u039A\x05\x9EP\x02\u039A" +
+    "\x97\x03\x02\x02\x02\u039B\u039C\x05N(\x02\u039C\u039D\x07\x18\x02\x02" +
+    "\u039D\u039E\x05\x8AF\x02\u039E\u039F\x07a\x02\x02\u039F\u03A0\x05`1\x02" +
+    "\u03A0\x99\x03\x02\x02\x02\u03A1\u03A7\x05\x9CO\x02\u03A2\u03A3\x05\x9C" +
+    "O\x02\u03A3\u03A4\x07k\x02\x02\u03A4\u03A5\x05\x9AN\x02\u03A5\u03A7\x03" +
+    "\x02\x02\x02\u03A6\u03A1\x03\x02\x02\x02\u03A6\u03A2\x03\x02\x02\x02\u03A7" +
+    "\x9B\x03\x02\x02\x02\u03A8\u03A9\x07m\x02\x02\u03A9\x9D\x03\x02\x02\x02" +
+    "\u03AA\u03AE\x07\v\x02\x02\u03AB\u03AD\x05\xA2R\x02\u03AC\u03AB\x03\x02" +
+    "\x02\x02\u03AD\u03B0\x03\x02\x02\x02\u03AE\u03AC\x03\x02\x02\x02\u03AE" +
+    "\u03AF\x03\x02\x02\x02\u03AF\u03B1\x03\x02\x02\x02\u03B0\u03AE\x03\x02" +
+    "\x02\x02\u03B1\u03B7\x07\f\x02\x02\u03B2\u03B4\x07$\x02\x02\u03B3\u03B2" +
+    "\x03\x02\x02\x02\u03B3\u03B4\x03\x02\x02\x02\u03B4\u03B5\x03\x02\x02\x02" +
+    "\u03B5\u03B7\x05J&\x02\u03B6\u03AA\x03\x02\x02\x02\u03B6\u03B3\x03\x02" +
+    "\x02\x02\u03B7\x9F\x03\x02\x02\x02\u03B8\u03B9\x07V\x02\x02\u03B9\u03BE" +
+    "\x05N(\x02\u03BA\u03BE\x05\x9CO\x02\u03BB\u03BC\x07(\x02\x02\u03BC\u03BE" +
+    "\x05\x9CO\x02\u03BD\u03B8\x03\x02\x02\x02\u03BD\u03BA\x03\x02\x02\x02" +
+    "\u03BD\u03BB\x03\x02\x02\x02\u03BE\xA1\x03\x02\x02\x02\u03BF\u03C0\x05" +
+    "\xA4S\x02\u03C0\u03C1\x05@!\x02\u03C1\u03C2\x05\xA6T\x02\u03C2\u03C7\x03" +
+    "\x02\x02\x02\u03C3\u03C4\x07g\x02\x02\u03C4\u03C7\x05\xA4S\x02\u03C5\u03C7" +
+    "\x05J&\x02\u03C6\u03BF\x03\x02\x02\x02\u03C6\u03C3\x03\x02\x02\x02\u03C6" +
+    "\u03C5\x03\x02\x02\x02\u03C7\xA3\x03\x02\x02\x02\u03C8\u03C9\x07L\x02" +
+    "\x02\u03C9\u03D3\x05J&\x02\u03CA\u03D3\x05J&\x02\u03CB\u03CE\x05\xA0Q" +
+    "\x02\u03CC\u03CD\x07\x1B\x02\x02\u03CD\u03CF\x05J&\x02\u03CE\u03CC\x03" +
+    "\x02\x02\x02\u03CF\u03D0\x03\x02\x02\x02\u03D0\u03CE\x03\x02\x02\x02\u03D0" +
+    "\u03D1\x03\x02\x02\x02\u03D1\u03D3\x03\x02\x02\x02\u03D2\u03C8\x03\x02" +
+    "\x02\x02\u03D2\u03CA\x03\x02\x02\x02\u03D2\u03CB\x03\x02\x02\x02\u03D3" +
+    "\xA5\x03\x02\x02\x02\u03D4\u03D5\bT\x01\x02\u03D5\u03DB\x05\xA8U\x02\u03D6" +
+    "\u03D7\x07\x1D\x02\x02\u03D7\u03D8\x05\xA6T\x02\u03D8\u03D9\x07\x1E\x02" +
+    "\x02\u03D9\u03DB\x03\x02\x02\x02\u03DA\u03D4\x03\x02\x02\x02\u03DA\u03D6" +
+    "\x03\x02\x02\x02\u03DB\u03E1\x03\x02\x02\x02\u03DC\u03DD\f\x04\x02\x02" +
+    "\u03DD\u03DE\x07\x0F\x02\x02\u03DE\u03E0\x05\xA8U\x02\u03DF\u03DC\x03" +
+    "\x02\x02\x02\u03E0\u03E3\x03\x02\x02\x02\u03E1\u03DF\x03\x02\x02\x02\u03E1" +
+    "\u03E2\x03\x02\x02\x02\u03E2\xA7\x03\x02\x02\x02\u03E3\u03E1\x03\x02\x02" +
+    "\x02\u03E4\u03E5\bU\x01\x02\u03E5\u03E6\x07\x1D\x02\x02\u03E6\u03E7\x05" +
+    "\xA8U\x02\u03E7\u03E8\x07\x1E\x02\x02\u03E8\u03EB\x03\x02\x02\x02\u03E9" +
+    "\u03EB\x05\xAAV\x02\u03EA\u03E4\x03\x02\x02\x02\u03EA\u03E9\x03\x02\x02" +
+    "\x02\u03EB\u03F1\x03\x02\x02\x02\u03EC\u03ED\f\x04\x02\x02\u03ED\u03EE" +
+    "\t\x10\x02\x02\u03EE\u03F0\x05\xAAV\x02\u03EF\u03EC\x03\x02\x02\x02\u03F0" +
+    "\u03F3\x03\x02\x02\x02\u03F1\u03EF\x03\x02\x02\x02\u03F1\u03F2\x03\x02" +
+    "\x02\x02\u03F2\xA9\x03\x02\x02\x02\u03F3\u03F1\x03\x02\x02\x02\u03F4\u03FB" +
+    "\x05\xA0Q\x02\u03F5\u03FB\x05J&\x02\u03F6\u03F7\x07\x1D\x02\x02\u03F7" +
+    "\u03F8\x05\xA6T\x02\u03F8\u03F9\x07\x1E\x02\x02\u03F9\u03FB\x03\x02\x02" +
+    "\x02\u03FA\u03F4\x03\x02\x02\x02\u03FA\u03F5\x03\x02\x02\x02\u03FA\u03F6" +
+    "\x03\x02\x02\x02\u03FB\xAB\x03\x02\x02\x02x\xAE\xB3\xB7\xC1\xC7\xCD\xD0" +
     "\xD8\xDC\xE2\xE4\xF7\xFA\xFD\u0100\u0105\u0109\u010D\u0117\u011A\u0123" +
     "\u0128\u012D\u0132\u0137\u0144\u0148\u014C\u0155\u015A\u015D\u0161\u0168" +
     "\u016D\u0170\u0174\u0179\u017D\u0180\u0184\u018A\u018E\u0196\u019F\u01A3" +
-    "\u01A6\u01AF\u01B2\u01B9\u01BD\u01C2\u01CF\u01D2\u01D6\u01DF\u01E3\u01EC" +
-    "\u01F0\u01FA\u0205\u0209\u020E\u021A\u0222\u0228\u022C\u0233\u0239\u0240" +
-    "\u0243\u024C\u0253\u025A\u0261\u0268\u026F\u0276\u027D\u028A\u028F\u0299" +
-    "\u02A4\u02AF\u02B8\u02BA\u02C4\u02D8\u02E9\u02F0\u02F7\u02FD\u0307\u030D" +
-    "\u0317\u0322\u032E\u0339\u0346\u0350\u0357\u0361\u0367\u037B\u0382\u038C" +
-    "\u03A5\u03AD\u03B2\u03B5\u03BC\u03C5\u03CF\u03D1\u03D9\u03E0\u03E9\u03F0" +
-    "\u03F9";
+    "\u01A6\u01AF\u01B3\u01BA\u01BE\u01C3\u01D0\u01D3\u01D7\u01E0\u01E4\u01ED" +
+    "\u01F1\u01FB\u0206\u020A\u020F\u021B\u0223\u0229\u022D\u0234\u023A\u0241" +
+    "\u0244\u024D\u0254\u025B\u0262\u0269\u0270\u0277\u027E\u028B\u0290\u029A" +
+    "\u02A5\u02B0\u02B9\u02BB\u02C5\u02D9\u02EA\u02F1\u02F8\u02FE\u0308\u030E" +
+    "\u0318\u0323\u032F\u033A\u0347\u0351\u0358\u0362\u0368\u037C\u0383\u038D" +
+    "\u03A6\u03AE\u03B3\u03B6\u03BD\u03C6\u03D0\u03D2\u03DA\u03E1\u03EA\u03F1" +
+    "\u03FA";
 ForgeParser._serializedATN = Utils.join([
     ForgeParser._serializedATNSegment0,
     ForgeParser._serializedATNSegment1,
@@ -59767,7 +60140,7 @@ class ImportDeclContext extends ParserRuleContext_1.ParserRuleContext {
     name() {
         return this.tryGetRuleContext(0, NameContext);
     }
-    FILE_PATH_TOK() { return this.tryGetToken(ForgeParser.FILE_PATH_TOK, 0); }
+    STRING_TOK() { return this.tryGetToken(ForgeParser.STRING_TOK, 0); }
     constructor(parent, invokingState) {
         super(parent, invokingState);
     }
@@ -60605,6 +60978,7 @@ class ConstContext extends ParserRuleContext_1.ParserRuleContext {
         return this.tryGetRuleContext(0, NumberContext);
     }
     MINUS_TOK() { return this.tryGetToken(ForgeParser.MINUS_TOK, 0); }
+    STRING_TOK() { return this.tryGetToken(ForgeParser.STRING_TOK, 0); }
     constructor(parent, invokingState) {
         super(parent, invokingState);
     }
@@ -61220,7 +61594,7 @@ class OptionDeclContext extends ParserRuleContext_1.ParserRuleContext {
             return this.getRuleContext(i, QualNameContext);
         }
     }
-    FILE_PATH_TOK() { return this.tryGetToken(ForgeParser.FILE_PATH_TOK, 0); }
+    STRING_TOK() { return this.tryGetToken(ForgeParser.STRING_TOK, 0); }
     number() {
         return this.tryGetRuleContext(0, NumberContext);
     }
@@ -63337,6 +63711,11 @@ class SimpleGraphQueryEvaluator {
         // underlying IDataInstance -- callers must signal that themselves.
         this.cachedEvaluator = null;
         this.cachedEvaluatorDatum = null;
+        // Diagnostics from the most recent evaluateExpression call. Kept here rather
+        // than read back off the evaluator, because a failed evaluation discards the
+        // evaluator — and a query that warns and *then* errors is exactly when the
+        // warning is most worth keeping.
+        this.lastDiagnostics = [];
         this.datum = datum;
     }
     /**
@@ -63362,6 +63741,24 @@ class SimpleGraphQueryEvaluator {
         //////// This is empty on parse error? //TODO//////
         return tree;
     }
+    /**
+     * Evaluate `forgeExpr` and return both its value and any diagnostics raised
+     * along the way.
+     *
+     * Diagnostics are advisory and never change the value — today the only kind
+     * is an unresolved name, which evaluates to the empty set. Consumers should
+     * surface them to whoever authored the query; see {@link Diagnostic}.
+     *
+     * Note that an unresolved name is a warning rather than an error on purpose.
+     * An instance carries only populated types and relations, so a sig that is
+     * empty here looks exactly like a typo, and a sig can empty out between
+     * frames of one trace. Deciding which it is needs context this library does
+     * not have.
+     */
+    evaluateExpressionWithDiagnostics(forgeExpr) {
+        const value = this.evaluateExpression(forgeExpr);
+        return { value, diagnostics: this.lastDiagnostics };
+    }
     evaluateExpression(forgeExpr) {
         // Check cache first
         let tree;
@@ -63377,6 +63774,7 @@ class SimpleGraphQueryEvaluator {
             }
             catch (e) {
                 // if we can't parse the expression, we return an error
+                this.lastDiagnostics = []; // nothing was evaluated
                 return {
                     error: new Error(`Error parsing expression "${forgeExpr}"`)
                 };
@@ -63390,12 +63788,20 @@ class SimpleGraphQueryEvaluator {
             this.cachedEvaluatorDatum = this.datum;
         }
         const evaluator = this.cachedEvaluator;
+        // Diagnostics describe this evaluation, not the whole life of the reused
+        // evaluator, so clear whatever the previous call left behind.
+        evaluator.resetDiagnostics();
         try {
             let result = evaluator.visit(tree);
+            this.lastDiagnostics = evaluator.getDiagnostics();
             // ensure we're visiting an ExprContext
             return result;
         }
         catch (error) {
+            // Capture diagnostics BEFORE discarding the evaluator. A query that
+            // warns about an unresolved name and then fails for an unrelated reason
+            // should still surface the warning.
+            this.lastDiagnostics = evaluator.getDiagnostics();
             // The visit threw mid-traversal, so the evaluator's transient state
             // (environment stack) may be inconsistent. Discard the cached
             // evaluator so the next call rebuilds from a clean slate. The