diff --git a/dist/index.d.ts b/dist/index.d.ts index f023ff7..11151ce 100644 --- a/dist/index.d.ts +++ b/dist/index.d.ts @@ -85,6 +85,11 @@ declare abstract class Text implements Iterable { */ iterLines(from?: number, to?: number): TextIterator; /** + Return the document as a string, using newline characters to + separate lines. + */ + toString(): string; + /** Convert the document to an array of lines (which can be deserialized again via [`Text.of`](https://codemirror.net/6/docs/ref/#state.Text^of)). */ @@ -252,7 +257,7 @@ plain object describing a change (a deletion, insertion, or replacement, depending on which fields are present), a [change set](https://codemirror.net/6/docs/ref/#state.ChangeSet), or an array of change specs. */ -declare type ChangeSpec = { +type ChangeSpec = { from: number; to?: number; insert?: string | Text; @@ -479,7 +484,7 @@ declare class EditorSelection { static range(anchor: number, head: number, goalColumn?: number, bidiLevel?: number): SelectionRange; } -declare type FacetConfig = { +type FacetConfig = { /** How to combine the input values into a single output value. When not given, the array of input values becomes the output. This @@ -523,11 +528,19 @@ Examples of uses of facets are the [tab size](https://codemirror.net/6/docs/ref/#state.EditorState^tabSize), [editor attributes](https://codemirror.net/6/docs/ref/#view.EditorView^editorAttributes), and [update listeners](https://codemirror.net/6/docs/ref/#view.EditorView^updateListener). + +Note that `Facet` instances can be used anywhere where +[`FacetReader`](https://codemirror.net/6/docs/ref/#state.FacetReader) is expected. */ -declare class Facet { +declare class Facet implements FacetReader { private isStatic; private constructor(); /** + Returns a facet reader for this facet, which can be used to + [read](https://codemirror.net/6/docs/ref/#state.EditorState.facet) it but not to define values for it. + */ + get reader(): FacetReader; + /** Define a new facet. */ static define(config?: FacetConfig): Facet; @@ -558,9 +571,24 @@ declare class Facet { */ from(field: StateField): Extension; from(field: StateField, get: (value: T) => Input): Extension; + tag: Output; } -declare type Slot = Facet | StateField | "doc" | "selection"; -declare type StateFieldSpec = { +/** +A facet reader can be used to fetch the value of a facet, though +[`EditorState.facet`](https://codemirror.net/6/docs/ref/#state.EditorState.facet) or as a dependency +in [`Facet.compute`](https://codemirror.net/6/docs/ref/#state.Facet.compute), but not to define new +values for the facet. +*/ +type FacetReader = { + /** + Dummy tag that makes sure TypeScript doesn't consider all object + types as conforming to this type. Not actually present on the + object. + */ + tag: Output; +}; +type Slot = FacetReader | StateField | "doc" | "selection"; +type StateFieldSpec = { /** Creates the initial value for the field when a state is created. */ @@ -635,7 +663,7 @@ providers](https://codemirror.net/6/docs/ref/#state.Facet.of), or objects with a `extension` property. Extensions can be nested in arrays arbitrarily deep—they will be flattened when processed. */ -declare type Extension = { +type Extension = { extension: Extension; } | readonly Extension[]; /** @@ -744,7 +772,10 @@ declare class StateEffect { is(type: StateEffectType): this is StateEffect; /** Define a new effect type. The type parameter indicates the type - of values that his effect holds. + of values that his effect holds. It should be a type that + doesn't include `undefined`, since that is used in + [mapping](https://codemirror.net/6/docs/ref/#state.StateEffect.map) to indicate that an effect is + removed. */ static define(spec?: StateEffectSpec): StateEffectType; /** @@ -1079,7 +1110,7 @@ declare class EditorState { /** Get the value of a state [facet](https://codemirror.net/6/docs/ref/#state.Facet). */ - facet(facet: Facet): Output; + facet(facet: FacetReader): Output; /** Convert this state to a JSON-serializable object. When custom fields should be serialized, you can pass them in as an object @@ -1281,7 +1312,7 @@ Subtype of [`Command`](https://codemirror.net/6/docs/ref/#view.Command) that doe to the actual editor view. Mostly useful to define commands that can be run and tested outside of a browser environment. */ -declare type StateCommand = (target: { +type StateCommand = (target: { state: EditorState; dispatch: (transaction: Transaction) => void; }) => boolean; @@ -1423,7 +1454,7 @@ interface RangeCursor { */ to: number; } -declare type RangeSetUpdate = { +type RangeSetUpdate = { /** An array of ranges to add. If given, this should be sorted by `from` position and `startSide` unless @@ -1502,8 +1533,7 @@ declare class RangeSet { static compare(oldSets: readonly RangeSet[], newSets: readonly RangeSet[], /** This indicates how the underlying data changed between these - ranges, and is needed to synchronize the iteration. `from` and - `to` are coordinates in the _new_ space, after these changes. + ranges, and is needed to synchronize the iteration. */ textDiff: ChangeDesc, comparator: RangeComparator, /** @@ -1543,129 +1573,632 @@ declare class RangeSet { static empty: RangeSet; } +/** +The [`TreeFragment.applyChanges`](#common.TreeFragment^applyChanges) +method expects changed ranges in this format. +*/ interface ChangedRange { + /** + The start of the change in the start document + */ fromA: number; + /** + The end of the change in the start document + */ toA: number; + /** + The start of the replacement in the new document + */ fromB: number; + /** + The end of the replacement in the new document + */ toB: number; } +/** +Tree fragments are used during [incremental +parsing](#common.Parser.startParse) to track parts of old trees +that can be reused in a new parse. An array of fragments is used +to track regions of an old tree whose nodes might be reused in new +parses. Use the static +[`applyChanges`](#common.TreeFragment^applyChanges) method to +update fragments for document changes. +*/ declare class TreeFragment { + /** + The start of the unchanged range pointed to by this fragment. + This refers to an offset in the _updated_ document (as opposed + to the original tree). + */ readonly from: number; + /** + The end of the unchanged range. + */ readonly to: number; + /** + The tree that this fragment is based on. + */ readonly tree: Tree; + /** + The offset between the fragment's tree and the document that + this fragment can be used against. Add this when going from + document to tree positions, subtract it to go from tree to + document positions. + */ readonly offset: number; - constructor(from: number, to: number, tree: Tree, offset: number, openStart?: boolean, openEnd?: boolean); + /** + Construct a tree fragment. You'll usually want to use + [`addTree`](#common.TreeFragment^addTree) and + [`applyChanges`](#common.TreeFragment^applyChanges) instead of + calling this directly. + */ + constructor( + /** + The start of the unchanged range pointed to by this fragment. + This refers to an offset in the _updated_ document (as opposed + to the original tree). + */ + from: number, + /** + The end of the unchanged range. + */ + to: number, + /** + The tree that this fragment is based on. + */ + tree: Tree, + /** + The offset between the fragment's tree and the document that + this fragment can be used against. Add this when going from + document to tree positions, subtract it to go from tree to + document positions. + */ + offset: number, openStart?: boolean, openEnd?: boolean); + /** + Whether the start of the fragment represents the start of a + parse, or the end of a change. (In the second case, it may not + be safe to reuse some nodes at the start, depending on the + parsing algorithm.) + */ get openStart(): boolean; + /** + Whether the end of the fragment represents the end of a + full-document parse, or the start of a change. + */ get openEnd(): boolean; - static addTree(tree: Tree, fragments?: readonly TreeFragment[], partial?: boolean): TreeFragment[]; + /** + Create a set of fragments from a freshly parsed tree, or update + an existing set of fragments by replacing the ones that overlap + with a tree with content from the new tree. When `partial` is + true, the parse is treated as incomplete, and the resulting + fragment has [`openEnd`](#common.TreeFragment.openEnd) set to + true. + */ + static addTree(tree: Tree, fragments?: readonly TreeFragment[], partial?: boolean): readonly TreeFragment[]; + /** + Apply a set of edits to an array of fragments, removing or + splitting fragments as necessary to remove edited ranges, and + adjusting offsets for fragments that moved. + */ static applyChanges(fragments: readonly TreeFragment[], changes: readonly ChangedRange[], minGap?: number): readonly TreeFragment[]; } +/** +Interface used to represent an in-progress parse, which can be +moved forward piece-by-piece. +*/ interface PartialParse { + /** + Advance the parse state by some amount. Will return the finished + syntax tree when the parse completes. + */ advance(): Tree | null; + /** + The position up to which the document has been parsed. Note + that, in multi-pass parsers, this will stay back until the last + pass has moved past a given position. + */ readonly parsedPos: number; + /** + Tell the parse to not advance beyond the given position. + `advance` will return a tree when the parse has reached the + position. Note that, depending on the parser algorithm and the + state of the parse when `stopAt` was called, that tree may + contain nodes beyond the position. It is an error to call + `stopAt` with a higher position than it's [current + value](#common.PartialParse.stoppedAt). + */ stopAt(pos: number): void; + /** + Reports whether `stopAt` has been called on this parse. + */ readonly stoppedAt: number | null; } +/** +A superclass that parsers should extend. +*/ declare abstract class Parser { + /** + Start a parse for a single tree. This is the method concrete + parser implementations must implement. Called by `startParse`, + with the optional arguments resolved. + */ abstract createParse(input: Input, fragments: readonly TreeFragment[], ranges: readonly { from: number; to: number; }[]): PartialParse; + /** + Start a parse, returning a [partial parse](#common.PartialParse) + object. [`fragments`](#common.TreeFragment) can be passed in to + make the parse incremental. + + By default, the entire input is parsed. You can pass `ranges`, + which should be a sorted array of non-empty, non-overlapping + ranges, to parse only those ranges. The tree returned in that + case will start at `ranges[0].from`. + */ startParse(input: Input | string, fragments?: readonly TreeFragment[], ranges?: readonly { from: number; to: number; }[]): PartialParse; + /** + Run a full parse, returning the resulting tree. + */ parse(input: Input | string, fragments?: readonly TreeFragment[], ranges?: readonly { from: number; to: number; }[]): Tree; } +/** +This is the interface parsers use to access the document. To run +Lezer directly on your own document data structure, you have to +write an implementation of it. +*/ interface Input { + /** + The length of the document. + */ readonly length: number; + /** + Get the chunk after the given position. The returned string + should start at `from` and, if that isn't the end of the + document, may be of any length greater than zero. + */ chunk(from: number): string; + /** + Indicates whether the chunks already end at line breaks, so that + client code that wants to work by-line can avoid re-scanning + them for line breaks. When this is true, the result of `chunk()` + should either be a single line break, or the content between + `from` and the next line break. + */ readonly lineChunks: boolean; + /** + Read the part of the document between the given positions. + */ read(from: number, to: number): string; } +/** +Parse wrapper functions are supported by some parsers to inject +additional parsing logic. +*/ type ParseWrapper = (inner: PartialParse, input: Input, fragments: readonly TreeFragment[], ranges: readonly { from: number; to: number; }[]) => PartialParse; - +/** +Each [node type](#common.NodeType) or [individual tree](#common.Tree) +can have metadata associated with it in props. Instances of this +class represent prop names. +*/ declare class NodeProp { + /** + Indicates whether this prop is stored per [node + type](#common.NodeType) or per [tree node](#common.Tree). + */ perNode: boolean; + /** + A method that deserializes a value of this prop from a string. + Can be used to allow a prop to be directly written in a grammar + file. + */ deserialize: (str: string) => T; + /** + Create a new node prop type. + */ constructor(config?: { + /** + The [deserialize](#common.NodeProp.deserialize) function to + use for this prop, used for example when directly providing + the prop from a grammar file. Defaults to a function that + raises an error. + */ deserialize?: (str: string) => T; + /** + By default, node props are stored in the [node + type](#common.NodeType). It can sometimes be useful to directly + store information (usually related to the parsing algorithm) + in [nodes](#common.Tree) themselves. Set this to true to enable + that for this prop. + */ perNode?: boolean; }); + /** + This is meant to be used with + [`NodeSet.extend`](#common.NodeSet.extend) or + [`LRParser.configure`](#lr.ParserConfig.props) to compute + prop values for each node type in the set. Takes a [match + object](#common.NodeType^match) or function that returns undefined + if the node type doesn't get this prop, and the prop's value if + it does. + */ add(match: { [selector: string]: T; } | ((type: NodeType) => T | undefined)): NodePropSource; + /** + Prop that is used to describe matching delimiters. For opening + delimiters, this holds an array of node names (written as a + space-separated string when declaring this prop in a grammar) + for the node types of closing delimiters that match it. + */ static closedBy: NodeProp; + /** + The inverse of [`closedBy`](#common.NodeProp^closedBy). This is + attached to closing delimiters, holding an array of node names + of types of matching opening delimiters. + */ static openedBy: NodeProp; + /** + Used to assign node types to groups (for example, all node + types that represent an expression could be tagged with an + `"Expression"` group). + */ static group: NodeProp; + /** + The hash of the [context](#lr.ContextTracker.constructor) + that the node was parsed in, if any. Used to limit reuse of + contextual nodes. + */ static contextHash: NodeProp; + /** + The distance beyond the end of the node that the tokenizer + looked ahead for any of the tokens inside the node. (The LR + parser only stores this when it is larger than 25, for + efficiency reasons.) + */ static lookAhead: NodeProp; + /** + This per-node prop is used to replace a given node, or part of a + node, with another tree. This is useful to include trees from + different languages in mixed-language parsers. + */ static mounted: NodeProp; } +/** +A mounted tree, which can be [stored](#common.NodeProp^mounted) on +a tree node to indicate that parts of its content are +represented by another tree. +*/ declare class MountedTree { + /** + The inner tree. + */ readonly tree: Tree; + /** + If this is null, this tree replaces the entire node (it will + be included in the regular iteration instead of its host + node). If not, only the given ranges are considered to be + covered by this tree. This is used for trees that are mixed in + a way that isn't strictly hierarchical. Such mounted trees are + only entered by [`resolveInner`](#common.Tree.resolveInner) + and [`enter`](#common.SyntaxNode.enter). + */ readonly overlay: readonly { from: number; to: number; }[] | null; + /** + The parser used to create this subtree. + */ readonly parser: Parser; - constructor(tree: Tree, overlay: readonly { + constructor( + /** + The inner tree. + */ + tree: Tree, + /** + If this is null, this tree replaces the entire node (it will + be included in the regular iteration instead of its host + node). If not, only the given ranges are considered to be + covered by this tree. This is used for trees that are mixed in + a way that isn't strictly hierarchical. Such mounted trees are + only entered by [`resolveInner`](#common.Tree.resolveInner) + and [`enter`](#common.SyntaxNode.enter). + */ + overlay: readonly { from: number; to: number; - }[] | null, parser: Parser); + }[] | null, + /** + The parser used to create this subtree. + */ + parser: Parser); } +/** +Type returned by [`NodeProp.add`](#common.NodeProp.add). Describes +whether a prop should be added to a given node type in a node set, +and what value it should have. +*/ type NodePropSource = (type: NodeType) => null | [NodeProp, any]; +/** +Each node in a syntax tree has a node type associated with it. +*/ declare class NodeType { + /** + The name of the node type. Not necessarily unique, but if the + grammar was written properly, different node types with the + same name within a node set should play the same semantic + role. + */ readonly name: string; + /** + The id of this node in its set. Corresponds to the term ids + used in the parser. + */ readonly id: number; + /** + Define a node type. + */ static define(spec: { + /** + The ID of the node type. When this type is used in a + [set](#common.NodeSet), the ID must correspond to its index in + the type array. + */ id: number; + /** + The name of the node type. Leave empty to define an anonymous + node. + */ name?: string; + /** + [Node props](#common.NodeProp) to assign to the type. The value + given for any given prop should correspond to the prop's type. + */ props?: readonly ([NodeProp, any] | NodePropSource)[]; + /** + Whether this is a [top node](#common.NodeType.isTop). + */ top?: boolean; + /** + Whether this node counts as an [error + node](#common.NodeType.isError). + */ error?: boolean; + /** + Whether this node is a [skipped](#common.NodeType.isSkipped) + node. + */ skipped?: boolean; }): NodeType; + /** + Retrieves a node prop for this type. Will return `undefined` if + the prop isn't present on this node. + */ prop(prop: NodeProp): T | undefined; + /** + True when this is the top node of a grammar. + */ get isTop(): boolean; + /** + True when this node is produced by a skip rule. + */ get isSkipped(): boolean; + /** + Indicates whether this is an error node. + */ get isError(): boolean; + /** + When true, this node type doesn't correspond to a user-declared + named node, for example because it is used to cache repetition. + */ get isAnonymous(): boolean; + /** + Returns true when this node's name or one of its + [groups](#common.NodeProp^group) matches the given string. + */ is(name: string | number): boolean; + /** + An empty dummy node type to use when no actual type is available. + */ static none: NodeType; + /** + Create a function from node types to arbitrary values by + specifying an object whose property names are node or + [group](#common.NodeProp^group) names. Often useful with + [`NodeProp.add`](#common.NodeProp.add). You can put multiple + names, separated by spaces, in a single property name to map + multiple node names to a single value. + */ static match(map: { [selector: string]: T; }): (node: NodeType) => T | undefined; } +/** +A node set holds a collection of node types. It is used to +compactly represent trees by storing their type ids, rather than a +full pointer to the type object, in a numeric array. Each parser +[has](#lr.LRParser.nodeSet) a node set, and [tree +buffers](#common.TreeBuffer) can only store collections of nodes +from the same set. A set can have a maximum of 2**16 (65536) node +types in it, so that the ids fit into 16-bit typed array slots. +*/ declare class NodeSet { + /** + The node types in this set, by id. + */ readonly types: readonly NodeType[]; - constructor(types: readonly NodeType[]); + /** + Create a set with the given types. The `id` property of each + type should correspond to its position within the array. + */ + constructor( + /** + The node types in this set, by id. + */ + types: readonly NodeType[]); + /** + Create a copy of this set with some node properties added. The + arguments to this method can be created with + [`NodeProp.add`](#common.NodeProp.add). + */ extend(...props: NodePropSource[]): NodeSet; } +/** +Options that control iteration. Can be combined with the `|` +operator to enable multiple ones. +*/ declare enum IterMode { + /** + When enabled, iteration will only visit [`Tree`](#common.Tree) + objects, not nodes packed into + [`TreeBuffer`](#common.TreeBuffer)s. + */ ExcludeBuffers = 1, + /** + Enable this to make iteration include anonymous nodes (such as + the nodes that wrap repeated grammar constructs into a balanced + tree). + */ IncludeAnonymous = 2, + /** + By default, regular [mounted](#common.NodeProp^mounted) nodes + replace their base node in iteration. Enable this to ignore them + instead. + */ IgnoreMounts = 4, + /** + This option only applies in + [`enter`](#common.SyntaxNode.enter)-style methods. It tells the + library to not enter mounted overlays if one covers the given + position. + */ IgnoreOverlays = 8 } +/** +A piece of syntax tree. There are two ways to approach these +trees: the way they are actually stored in memory, and the +convenient way. + +Syntax trees are stored as a tree of `Tree` and `TreeBuffer` +objects. By packing detail information into `TreeBuffer` leaf +nodes, the representation is made a lot more memory-efficient. + +However, when you want to actually work with tree nodes, this +representation is very awkward, so most client code will want to +use the [`TreeCursor`](#common.TreeCursor) or +[`SyntaxNode`](#common.SyntaxNode) interface instead, which provides +a view on some part of this data structure, and can be used to +move around to adjacent nodes. +*/ declare class Tree { + /** + The type of the top node. + */ readonly type: NodeType; + /** + This node's child nodes. + */ readonly children: readonly (Tree | TreeBuffer)[]; + /** + The positions (offsets relative to the start of this tree) of + the children. + */ readonly positions: readonly number[]; + /** + The total length of this tree + */ readonly length: number; - constructor(type: NodeType, children: readonly (Tree | TreeBuffer)[], positions: readonly number[], length: number, props?: readonly [NodeProp | number, any][]); + /** + Construct a new tree. See also [`Tree.build`](#common.Tree^build). + */ + constructor( + /** + The type of the top node. + */ + type: NodeType, + /** + This node's child nodes. + */ + children: readonly (Tree | TreeBuffer)[], + /** + The positions (offsets relative to the start of this tree) of + the children. + */ + positions: readonly number[], + /** + The total length of this tree + */ + length: number, + /** + Per-node [node props](#common.NodeProp) to associate with this node. + */ + props?: readonly [NodeProp | number, any][]); + /** + The empty tree + */ static empty: Tree; + /** + Get a [tree cursor](#common.TreeCursor) positioned at the top of + the tree. Mode can be used to [control](#common.IterMode) which + nodes the cursor visits. + */ cursor(mode?: IterMode): TreeCursor; + /** + Get a [tree cursor](#common.TreeCursor) pointing into this tree + at the given position and side (see + [`moveTo`](#common.TreeCursor.moveTo). + */ cursorAt(pos: number, side?: -1 | 0 | 1, mode?: IterMode): TreeCursor; + /** + Get a [syntax node](#common.SyntaxNode) object for the top of the + tree. + */ get topNode(): SyntaxNode; + /** + Get the [syntax node](#common.SyntaxNode) at the given position. + If `side` is -1, this will move into nodes that end at the + position. If 1, it'll move into nodes that start at the + position. With 0, it'll only enter nodes that cover the position + from both sides. + + Note that this will not enter + [overlays](#common.MountedTree.overlay), and you often want + [`resolveInner`](#common.Tree.resolveInner) instead. + */ resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode; + /** + Like [`resolve`](#common.Tree.resolve), but will enter + [overlaid](#common.MountedTree.overlay) nodes, producing a syntax node + pointing into the innermost overlaid tree at the given position + (with parent links going through all parent structure, including + the host trees). + */ resolveInner(pos: number, side?: -1 | 0 | 1): SyntaxNode; + /** + In some situations, it can be useful to iterate through all + nodes around a position, including those in overlays that don't + directly cover the position. This method gives you an iterator + that will produce all nodes, from small to big, around the given + position. + */ + resolveStack(pos: number, side?: -1 | 0 | 1): NodeIterator; + /** + Iterate over the tree and its children, calling `enter` for any + node that touches the `from`/`to` region (if given) before + running over such a node's children, and `leave` (if given) when + leaving the node. When `enter` returns `false`, that node will + not have its children iterated over (or `leave` called). + */ iterate(spec: { enter(node: SyntaxNodeRef): boolean | void; leave?(node: SyntaxNodeRef): void; @@ -1673,97 +2206,449 @@ declare class Tree { to?: number; mode?: IterMode; }): void; + /** + Get the value of the given [node prop](#common.NodeProp) for this + node. Works with both per-node and per-type props. + */ prop(prop: NodeProp): T | undefined; + /** + Returns the node's [per-node props](#common.NodeProp.perNode) in a + format that can be passed to the [`Tree`](#common.Tree) + constructor. + */ get propValues(): readonly [NodeProp | number, any][]; + /** + Balance the direct children of this tree, producing a copy of + which may have children grouped into subtrees with type + [`NodeType.none`](#common.NodeType^none). + */ balance(config?: { + /** + Function to create the newly balanced subtrees. + */ makeTree?: (children: readonly (Tree | TreeBuffer)[], positions: readonly number[], length: number) => Tree; }): Tree; + /** + Build a tree from a postfix-ordered buffer of node information, + or a cursor over such a buffer. + */ static build(data: BuildData): Tree; } +/** +Represents a sequence of nodes. +*/ +type NodeIterator = { + node: SyntaxNode; + next: NodeIterator | null; +}; type BuildData = { + /** + The buffer or buffer cursor to read the node data from. + + When this is an array, it should contain four values for every + node in the tree. + + - The first holds the node's type, as a node ID pointing into + the given `NodeSet`. + - The second holds the node's start offset. + - The third the end offset. + - The fourth the amount of space taken up in the array by this + node and its children. Since there's four values per node, + this is the total number of nodes inside this node (children + and transitive children) plus one for the node itself, times + four. + + Parent nodes should appear _after_ child nodes in the array. As + an example, a node of type 10 spanning positions 0 to 4, with + two children, of type 11 and 12, might look like this: + + [11, 0, 1, 4, 12, 2, 4, 4, 10, 0, 4, 12] + */ buffer: BufferCursor | readonly number[]; + /** + The node types to use. + */ nodeSet: NodeSet; + /** + The id of the top node type. + */ topID: number; + /** + The position the tree should start at. Defaults to 0. + */ start?: number; + /** + The position in the buffer where the function should stop + reading. Defaults to 0. + */ bufferStart?: number; + /** + The length of the wrapping node. The end offset of the last + child is used when not provided. + */ length?: number; + /** + The maximum buffer length to use. Defaults to + [`DefaultBufferLength`](#common.DefaultBufferLength). + */ maxBufferLength?: number; + /** + An optional array holding reused nodes that the buffer can refer + to. + */ reused?: readonly Tree[]; + /** + The first node type that indicates repeat constructs in this + grammar. + */ minRepeatType?: number; }; +/** +This is used by `Tree.build` as an abstraction for iterating over +a tree buffer. A cursor initially points at the very last element +in the buffer. Every time `next()` is called it moves on to the +previous one. +*/ interface BufferCursor { + /** + The current buffer position (four times the number of nodes + remaining). + */ pos: number; + /** + The node ID of the next node in the buffer. + */ id: number; + /** + The start position of the next node in the buffer. + */ start: number; + /** + The end position of the next node. + */ end: number; + /** + The size of the next node (the number of nodes inside, counting + the node itself, times 4). + */ size: number; + /** + Moves `this.pos` down by 4. + */ next(): void; + /** + Create a copy of this cursor. + */ fork(): BufferCursor; } +/** +Tree buffers contain (type, start, end, endIndex) quads for each +node. In such a buffer, nodes are stored in prefix order (parents +before children, with the endIndex of the parent indicating which +children belong to it). +*/ declare class TreeBuffer { + /** + The buffer's content. + */ readonly buffer: Uint16Array; + /** + The total length of the group of nodes in the buffer. + */ readonly length: number; + /** + The node set used in this buffer. + */ readonly set: NodeSet; - constructor(buffer: Uint16Array, length: number, set: NodeSet); + /** + Create a tree buffer. + */ + constructor( + /** + The buffer's content. + */ + buffer: Uint16Array, + /** + The total length of the group of nodes in the buffer. + */ + length: number, + /** + The node set used in this buffer. + */ + set: NodeSet); } +/** +The set of properties provided by both [`SyntaxNode`](#common.SyntaxNode) +and [`TreeCursor`](#common.TreeCursor). Note that, if you need +an object that is guaranteed to stay stable in the future, you +need to use the [`node`](#common.SyntaxNodeRef.node) accessor. +*/ interface SyntaxNodeRef { + /** + The start position of the node. + */ readonly from: number; + /** + The end position of the node. + */ readonly to: number; + /** + The type of the node. + */ readonly type: NodeType; + /** + The name of the node (`.type.name`). + */ readonly name: string; + /** + Get the [tree](#common.Tree) that represents the current node, + if any. Will return null when the node is in a [tree + buffer](#common.TreeBuffer). + */ readonly tree: Tree | null; + /** + Retrieve a stable [syntax node](#common.SyntaxNode) at this + position. + */ readonly node: SyntaxNode; + /** + Test whether the node matches a given context—a sequence of + direct parent nodes. Empty strings in the context array act as + wildcards, other strings must match the ancestor node's name. + */ matchContext(context: readonly string[]): boolean; } +/** +A syntax node provides an immutable pointer to a given node in a +tree. When iterating over large amounts of nodes, you may want to +use a mutable [cursor](#common.TreeCursor) instead, which is more +efficient. +*/ interface SyntaxNode extends SyntaxNodeRef { + /** + The node's parent node, if any. + */ parent: SyntaxNode | null; + /** + The first child, if the node has children. + */ firstChild: SyntaxNode | null; + /** + The node's last child, if available. + */ lastChild: SyntaxNode | null; + /** + The first child that ends after `pos`. + */ childAfter(pos: number): SyntaxNode | null; + /** + The last child that starts before `pos`. + */ childBefore(pos: number): SyntaxNode | null; + /** + Enter the child at the given position. If side is -1 the child + may end at that position, when 1 it may start there. + + This will by default enter + [overlaid](#common.MountedTree.overlay) + [mounted](#common.NodeProp^mounted) trees. You can set + `overlays` to false to disable that. + + Similarly, when `buffers` is false this will not enter + [buffers](#common.TreeBuffer), only [nodes](#common.Tree) (which + is mostly useful when looking for props, which cannot exist on + buffer-allocated nodes). + */ enter(pos: number, side: -1 | 0 | 1, mode?: IterMode): SyntaxNode | null; + /** + This node's next sibling, if any. + */ nextSibling: SyntaxNode | null; + /** + This node's previous sibling. + */ prevSibling: SyntaxNode | null; + /** + A [tree cursor](#common.TreeCursor) starting at this node. + */ cursor(mode?: IterMode): TreeCursor; + /** + Find the node around, before (if `side` is -1), or after (`side` + is 1) the given position. Will look in parent nodes if the + position is outside this node. + */ resolve(pos: number, side?: -1 | 0 | 1): SyntaxNode; + /** + Similar to `resolve`, but enter + [overlaid](#common.MountedTree.overlay) nodes. + */ resolveInner(pos: number, side?: -1 | 0 | 1): SyntaxNode; + /** + Move the position to the innermost node before `pos` that looks + like it is unfinished (meaning it ends in an error node or has a + child ending in an error node right at its end). + */ enterUnfinishedNodesBefore(pos: number): SyntaxNode; + /** + Get a [tree](#common.Tree) for this node. Will allocate one if it + points into a buffer. + */ toTree(): Tree; + /** + Get the first child of the given type (which may be a [node + name](#common.NodeType.name) or a [group + name](#common.NodeProp^group)). If `before` is non-null, only + return children that occur somewhere after a node with that name + or group. If `after` is non-null, only return children that + occur somewhere before a node with that name or group. + */ getChild(type: string | number, before?: string | number | null, after?: string | number | null): SyntaxNode | null; + /** + Like [`getChild`](#common.SyntaxNode.getChild), but return all + matching children, not just the first. + */ getChildren(type: string | number, before?: string | number | null, after?: string | number | null): SyntaxNode[]; - matchContext(context: readonly string[]): boolean; } +/** +A tree cursor object focuses on a given node in a syntax tree, and +allows you to move to adjacent nodes. +*/ declare class TreeCursor implements SyntaxNodeRef { + /** + The node's type. + */ type: NodeType; + /** + Shorthand for `.type.name`. + */ get name(): string; + /** + The start source offset of this node. + */ from: number; + /** + The end source offset. + */ to: number; private stack; private bufferNode; private yieldNode; private yieldBuf; private yield; + /** + Move the cursor to this node's first child. When this returns + false, the node has no child, and the cursor has not been moved. + */ firstChild(): boolean; + /** + Move the cursor to this node's last child. + */ lastChild(): boolean; + /** + Move the cursor to the first child that ends after `pos`. + */ childAfter(pos: number): boolean; + /** + Move to the last child that starts before `pos`. + */ childBefore(pos: number): boolean; + /** + Move the cursor to the child around `pos`. If side is -1 the + child may end at that position, when 1 it may start there. This + will also enter [overlaid](#common.MountedTree.overlay) + [mounted](#common.NodeProp^mounted) trees unless `overlays` is + set to false. + */ enter(pos: number, side: -1 | 0 | 1, mode?: IterMode): boolean; + /** + Move to the node's parent node, if this isn't the top node. + */ parent(): boolean; + /** + Move to this node's next sibling, if any. + */ nextSibling(): boolean; + /** + Move to this node's previous sibling, if any. + */ prevSibling(): boolean; private atLastNode; private move; + /** + Move to the next node in a + [pre-order](https://en.wikipedia.org/wiki/Tree_traversal#Pre-order,_NLR) + traversal, going from a node to its first child or, if the + current node is empty or `enter` is false, its next sibling or + the next sibling of the first parent node that has one. + */ next(enter?: boolean): boolean; + /** + Move to the next node in a last-to-first pre-order traveral. A + node is followed by its last child or, if it has none, its + previous sibling or the previous sibling of the first parent + node that has one. + */ prev(enter?: boolean): boolean; + /** + Move the cursor to the innermost node that covers `pos`. If + `side` is -1, it will enter nodes that end at `pos`. If it is 1, + it will enter nodes that start at `pos`. + */ moveTo(pos: number, side?: -1 | 0 | 1): this; + /** + Get a [syntax node](#common.SyntaxNode) at the cursor's current + position. + */ get node(): SyntaxNode; + /** + Get the [tree](#common.Tree) that represents the current node, if + any. Will return null when the node is in a [tree + buffer](#common.TreeBuffer). + */ get tree(): Tree | null; + /** + Iterate over the current node and all its descendants, calling + `enter` when entering a node and `leave`, if given, when leaving + one. When `enter` returns `false`, any children of that node are + skipped, and `leave` isn't called for it. + */ iterate(enter: (node: SyntaxNodeRef) => boolean | void, leave?: (node: SyntaxNodeRef) => void): void; + /** + Test whether the current node matches a given context—a sequence + of direct parent node names. Empty strings in the context array + are treated as wildcards. + */ matchContext(context: readonly string[]): boolean; } +/** +Objects returned by the function passed to +[`parseMixed`](#common.parseMixed) should conform to this +interface. +*/ interface NestedParse { + /** + The parser to use for the inner region. + */ parser: Parser; + /** + When this property is not given, the entire node is parsed with + this parser, and it is [mounted](#common.NodeProp^mounted) as a + non-overlay node, replacing its host node in tree iteration. + + When an array of ranges is given, only those ranges are parsed, + and the tree is mounted as an + [overlay](#common.MountedTree.overlay). + + When a function is given, that function will be called for + descendant nodes of the target node, not including child nodes + that are covered by another nested parse, to determine the + overlay ranges. When it returns true, the entire descendant is + included, otherwise just the range given. The mixed parser will + optimize range-finding in reused nodes, which means it's a good + idea to use a function here when the target node is expected to + have a large, deep structure. + */ overlay?: readonly { from: number; to: number; @@ -1772,79 +2657,293 @@ interface NestedParse { to: number; } | boolean); } +/** +Create a parse wrapper that, after the inner parse completes, +scans its tree for mixed language regions with the `nest` +function, runs the resulting [inner parses](#common.NestedParse), +and then [mounts](#common.NodeProp^mounted) their results onto the +tree. +*/ declare function parseMixed(nest: (node: SyntaxNodeRef, input: Input) => NestedParse | null): ParseWrapper; +/** +A parse stack. These are used internally by the parser to track +parsing progress. They also provide some properties and methods +that external code such as a tokenizer can use to get information +about the parse state. +*/ declare class Stack { + /** + The input position up to which this stack has parsed. + */ pos: number; + /** + The stack's current [context](#lr.ContextTracker) value, if + any. Its type will depend on the context tracker's type + parameter, or it will be `null` if there is no context + tracker. + */ get context(): any; + /** + Check if the given term would be able to be shifted (optionally + after some reductions) on this stack. This can be useful for + external tokenizers that want to make sure they only provide a + given token when it applies. + */ canShift(term: number): boolean; + /** + Get the parser used by this stack. + */ get parser(): LRParser; + /** + Test whether a given dialect (by numeric ID, as exported from + the terms file) is enabled. + */ dialectEnabled(dialectID: number): boolean; private shiftContext; private reduceContext; private updateContext; } +/** +[Tokenizers](#lr.ExternalTokenizer) interact with the input +through this interface. It presents the input as a stream of +characters, tracking lookahead and hiding the complexity of +[ranges](#common.Parser.parse^ranges) from tokenizer code. +*/ declare class InputStream { + /** + Backup chunk + */ private chunk2; private chunk2Pos; + /** + The character code of the next code unit in the input, or -1 + when the stream is at the end of the input. + */ next: number; + /** + The current position of the stream. Note that, due to parses + being able to cover non-contiguous + [ranges](#common.Parser.startParse), advancing the stream does + not always mean its position moves a single unit. + */ pos: number; private rangeIndex; private range; - peek(offset: number): any; + /** + Look at a code unit near the stream position. `.peek(0)` equals + `.next`, `.peek(-1)` gives you the previous character, and so + on. + + Note that looking around during tokenizing creates dependencies + on potentially far-away content, which may reduce the + effectiveness incremental parsing—when looking forward—or even + cause invalid reparses when looking backward more than 25 code + units, since the library does not track lookbehind. + */ + peek(offset: number): number; + /** + Accept a token. By default, the end of the token is set to the + current stream position, but you can pass an offset (relative to + the stream position) to change that. + */ acceptToken(token: number, endOffset?: number): void; private getChunk; private readNext; + /** + Move the stream forward N (defaults to 1) code units. Returns + the new value of [`next`](#lr.InputStream.next). + */ advance(n?: number): number; private setDone; } interface ExternalOptions { + /** + When set to true, mark this tokenizer as depending on the + current parse stack, which prevents its result from being cached + between parser actions at the same positions. + */ contextual?: boolean; + /** + By defaults, when a tokenizer returns a token, that prevents + tokenizers with lower precedence from even running. When + `fallback` is true, the tokenizer is allowed to run when a + previous tokenizer returned a token that didn't match any of the + current state's actions. + */ fallback?: boolean; + /** + When set to true, tokenizing will not stop after this tokenizer + has produced a token. (But it will still fail to reach this one + if a higher-precedence tokenizer produced a token.) + */ extend?: boolean; } +/** +`@external tokens` declarations in the grammar should resolve to +an instance of this class. +*/ declare class ExternalTokenizer { - constructor(token: (input: InputStream, stack: Stack) => void, options?: ExternalOptions); + /** + Create a tokenizer. The first argument is the function that, + given an input stream, scans for the types of tokens it + recognizes at the stream's position, and calls + [`acceptToken`](#lr.InputStream.acceptToken) when it finds + one. + */ + constructor( + /** + @internal + */ + token: (input: InputStream, stack: Stack) => void, options?: ExternalOptions); } +/** +Context trackers are used to track stateful context (such as +indentation in the Python grammar, or parent elements in the XML +grammar) needed by external tokenizers. You declare them in a +grammar file as `@context exportName from "module"`. + +Context values should be immutable, and can be updated (replaced) +on shift or reduce actions. + +The export used in a `@context` declaration should be of this +type. +*/ declare class ContextTracker { + /** + Define a context tracker. + */ constructor(spec: { + /** + The initial value of the context at the start of the parse. + */ start: T; + /** + Update the context when the parser executes a + [shift](https://en.wikipedia.org/wiki/LR_parser#Shift_and_reduce_actions) + action. + */ shift?(context: T, term: number, stack: Stack, input: InputStream): T; + /** + Update the context when the parser executes a reduce action. + */ reduce?(context: T, term: number, stack: Stack, input: InputStream): T; + /** + Update the context when the parser reuses a node from a tree + fragment. + */ reuse?(context: T, node: Tree, stack: Stack, input: InputStream): T; + /** + Reduce a context value to a number (for cheap storage and + comparison). Only needed for strict contexts. + */ hash?(context: T): number; + /** + By default, nodes can only be reused during incremental + parsing if they were created in the same context as the one in + which they are reused. Set this to false to disable that + check (and the overhead of storing the hashes). + */ strict?: boolean; }); } +/** +Configuration options when +[reconfiguring](#lr.LRParser.configure) a parser. +*/ interface ParserConfig { + /** + Node prop values to add to the parser's node set. + */ props?: readonly NodePropSource[]; + /** + The name of the `@top` declaration to parse from. If not + specified, the first top rule declaration in the grammar is + used. + */ top?: string; + /** + A space-separated string of dialects to enable. + */ dialect?: string; + /** + Replace the given external tokenizers with new ones. + */ tokenizers?: { from: ExternalTokenizer; to: ExternalTokenizer; }[]; + /** + Replace external specializers with new ones. + */ specializers?: { from: (value: string, stack: Stack) => number; to: (value: string, stack: Stack) => number; }[]; + /** + Replace the context tracker with a new one. + */ contextTracker?: ContextTracker; + /** + When true, the parser will raise an exception, rather than run + its error-recovery strategies, when the input doesn't match the + grammar. + */ strict?: boolean; + /** + Add a wrapper, which can extend parses created by this parser + with additional logic (usually used to add + [mixed-language](#common.parseMixed) parsing). + */ wrap?: ParseWrapper; + /** + The maximum length of the TreeBuffers generated in the output + tree. Defaults to 1024. + */ bufferLength?: number; } +/** +Holds the parse tables for a given grammar, as generated by +`lezer-generator`, and provides [methods](#common.Parser) to parse +content with. +*/ declare class LRParser extends Parser { + /** + The nodes used in the trees emitted by this parser. + */ readonly nodeSet: NodeSet; createParse(input: Input, fragments: readonly TreeFragment[], ranges: readonly { from: number; to: number; }[]): PartialParse; + /** + Configure the parser. Returns a new parser instance that has the + given settings modified. Settings not provided in `config` are + kept from the original parser. + */ configure(config: ParserConfig): LRParser; + /** + Tells you whether any [parse wrappers](#lr.ParserConfig.wrap) + are registered for this parser. + */ hasWrappers(): boolean; + /** + Returns the name associated with a given term. This will only + work for all terms when the parser was generated with the + `--names` option. By default, only the names of tagged terms are + stored. + */ getName(term: number): string; + /** + The type of top node produced by the parser. + */ get topNode(): NodeType; + /** + Used by the output of the parser generator. Not available to + user code. @hide + */ static deserialize(spec: any): LRParser; } @@ -1853,7 +2952,11 @@ declare class StyleModule { finish?(sel: string): string }) getRules(): string - static mount(root: Document | ShadowRoot | DocumentOrShadowRoot, module: StyleModule | ReadonlyArray): void + static mount( + root: Document | ShadowRoot | DocumentOrShadowRoot, + module: StyleModule | ReadonlyArray, + options?: {nonce?: string} + ): void static newName(): string } @@ -1861,7 +2964,47 @@ type StyleSpec = { [propOrSelector: string]: string | number | StyleSpec | null } -declare type Attrs = { +/** +Used to indicate [text direction](https://codemirror.net/6/docs/ref/#view.EditorView.textDirection). +*/ +declare enum Direction { + /** + Left-to-right. + */ + LTR = 0, + /** + Right-to-left. + */ + RTL = 1 +} +/** +Represents a contiguous range of text that has a single direction +(as in left-to-right or right-to-left). +*/ +declare class BidiSpan { + /** + The start of the span (relative to the start of the line). + */ + readonly from: number; + /** + The end of the span. + */ + readonly to: number; + /** + The ["bidi + level"](https://unicode.org/reports/tr9/#Basic_Display_Algorithm) + of the span (in this context, 0 means + left-to-right, 1 means right-to-left, 2 means left-to-right + number inside right-to-left text). + */ + readonly level: number; + /** + The direction of this span. + */ + get dir(): Direction; +} + +type Attrs = { [name: string]: string; }; @@ -1874,7 +3017,7 @@ interface Rect { readonly top: number; readonly bottom: number; } -declare type ScrollStrategy = "nearest" | "start" | "end" | "center"; +type ScrollStrategy = "nearest" | "start" | "end" | "center"; interface MarkDecorationSpec { /** @@ -1912,6 +3055,12 @@ interface MarkDecorationSpec { */ tagName?: string; /** + When using sets of decorations in + [`bidiIsolatedRanges`](https://codemirror.net/6/docs/ref/##view.EditorView^bidiIsolatedRanges), + this property provides the direction of the isolates. + */ + bidiIsolate?: Direction; + /** Decoration specs allow extra properties, which can be retrieved through the decoration's [`spec`](https://codemirror.net/6/docs/ref/#view.Decoration.spec) property. @@ -1929,10 +3078,20 @@ interface WidgetDecorationSpec { cursor is on the same position. Otherwise, it'll be drawn before it. When multiple widgets sit at the same position, their `side` values will determine their ordering—those with a lower value - come first. Defaults to 0. + come first. Defaults to 0. May not be more than 10000 or less + than -10000. */ side?: number; /** + By default, to avoid unintended mixing of block and inline + widgets, block widgets with a positive `side` are always drawn + after all inline widgets at that position, and those with a + non-positive side before inline widgets. Setting this option to + `true` for a block widget will turn this off and cause it to be + rendered between the inline widgets, ordered by `side`. + */ + inlineOrder?: boolean; + /** Determines whether this is a block widgets, which will be drawn between lines, or an inline widget (the default) which is drawn between the surrounding text. @@ -2033,6 +3192,13 @@ declare abstract class WidgetType { */ get estimatedHeight(): number; /** + For inline widgets that are displayed inline (as opposed to + `inline-block`) and introduce line breaks (through `
` tags + or textual newlines), this must indicate the amount of line + breaks they introduce. Defaults to 0. + */ + get lineBreaks(): number; + /** Can be used to configure which kinds of events inside the widget should be ignored by the editor. The default is to ignore all events. @@ -2057,7 +3223,7 @@ A decoration set represents a collection of decorated ranges, organized for efficient access and mapping. See [`RangeSet`](https://codemirror.net/6/docs/ref/#state.RangeSet) for its methods. */ -declare type DecorationSet = RangeSet; +type DecorationSet = RangeSet; /** The different types of blocks that can occur in an editor view. */ @@ -2156,7 +3322,7 @@ apply to the editor, and if it can, perform it as a side effect (which usually means [dispatching](https://codemirror.net/6/docs/ref/#view.EditorView.dispatch) a transaction) and return `true`. */ -declare type Command = (target: EditorView) => boolean; +type Command = (target: EditorView) => boolean; /** This is the interface plugin objects conform to. */ @@ -2191,6 +3357,12 @@ interface PluginSpec { */ eventHandlers?: DOMEventHandlers; /** + Registers [event observers](https://codemirror.net/6/docs/ref/#view.EditorView^domEventObservers) + for the plugin. Will, when called, have their `this` bound to + the plugin value. + */ + eventObservers?: DOMEventHandlers; + /** Specify that the plugin provides additional extensions when added to an editor configuration. */ @@ -2245,7 +3417,7 @@ interface MeasureRequest { */ key?: any; } -declare type AttrSource = Attrs | ((view: EditorView) => Attrs | null); +type AttrSource = Attrs | ((view: EditorView) => Attrs | null); /** View [plugins](https://codemirror.net/6/docs/ref/#view.ViewPlugin) are given instances of this class, which describe what happened, whenever the view is updated. @@ -2334,7 +3506,7 @@ interface MouseSelectionStyle { */ update: (update: ViewUpdate) => boolean | void; } -declare type MakeSelectionStyle = (view: EditorView, event: MouseEvent) => MouseSelectionStyle | null; +type MakeSelectionStyle = (view: EditorView, event: MouseEvent) => MouseSelectionStyle | null; /** Record used to represent information about a block-level element @@ -2359,58 +3531,28 @@ declare class BlockInfo { */ readonly height: number; /** - The type of element this is. When querying lines, this may be - an array of all the blocks that make up the line. - */ - readonly type: BlockType | readonly BlockInfo[]; - /** - The end of the element as a document position. - */ - get to(): number; - /** - The bottom position of the element. - */ - get bottom(): number; -} - -/** -Used to indicate [text direction](https://codemirror.net/6/docs/ref/#view.EditorView.textDirection). -*/ -declare enum Direction { - /** - Left-to-right. - */ - LTR = 0, - /** - Right-to-left. - */ - RTL = 1 -} -/** -Represents a contiguous range of text that has a single direction -(as in left-to-right or right-to-left). -*/ -declare class BidiSpan { - /** - The start of the span (relative to the start of the line). + The type of element this is. When querying lines, this may be + an array of all the blocks that make up the line. */ - readonly from: number; + get type(): BlockType | readonly BlockInfo[]; /** - The end of the span. + The end of the element as a document position. */ - readonly to: number; + get to(): number; /** - The ["bidi - level"](https://unicode.org/reports/tr9/#Basic_Display_Algorithm) - of the span (in this context, 0 means - left-to-right, 1 means right-to-left, 2 means left-to-right - number inside right-to-left text). + The bottom position of the element. */ - readonly level: number; + get bottom(): number; /** - The direction of this span. + If this is a widget block, this will return the widget + associated with it. */ - get dir(): Direction; + get widget(): WidgetType | null; + /** + If this is a textblock, this holds the number of line breaks + that appear in widgets inside the block. + */ + get widgetLineBreaks(): number; } /** @@ -2440,13 +3582,18 @@ interface EditorViewConfig extends EditorStateConfig { */ root?: Document | ShadowRoot; /** - Override the transaction [dispatch - function](https://codemirror.net/6/docs/ref/#view.EditorView.dispatch) for this editor view, which - is the way updates get routed to the view. Your implementation, - if provided, should probably call the view's [`update` - method](https://codemirror.net/6/docs/ref/#view.EditorView.update). + Override the way transactions are + [dispatched](https://codemirror.net/6/docs/ref/#view.EditorView.dispatch) for this editor view. + Your implementation, if provided, should probably call the + view's [`update` method](https://codemirror.net/6/docs/ref/#view.EditorView.update). */ - dispatch?: (tr: Transaction) => void; + dispatchTransactions?: (trs: readonly Transaction[], view: EditorView) => void; + /** + **Deprecated** single-transaction version of + `dispatchTransactions`. Will force transactions to be dispatched + one at a time when used. + */ + dispatch?: (tr: Transaction, view: EditorView) => void; } /** An editor view represents the editor's user interface. It holds @@ -2500,7 +3647,7 @@ declare class EditorView { composition there. */ get compositionStarted(): boolean; - private _dispatch; + private dispatchTransactions; private _root; /** The document or shadow root that the view lives in. @@ -2540,14 +3687,19 @@ declare class EditorView { constructor(config?: EditorViewConfig); /** All regular editor state updates should go through this. It - takes a transaction or transaction spec and updates the view to - show the new state produced by that transaction. Its - implementation can be overridden with an - [option](https://codemirror.net/6/docs/ref/#view.EditorView.constructor^config.dispatch). This - function is bound to the view instance, so it does not have to - be called as a method. + takes a transaction, array of transactions, or transaction spec + and updates the view to show the new state produced by that + transaction. Its implementation can be overridden with an + [option](https://codemirror.net/6/docs/ref/#view.EditorView.constructor^config.dispatchTransactions). + This function is bound to the view instance, so it does not have + to be called as a method. + + Note that when multiple `TransactionSpec` arguments are + provided, these define a single transaction (the specs will be + merged), not a sequence of transactions. */ dispatch(tr: Transaction): void; + dispatch(trs: readonly Transaction[]): void; dispatch(...specs: TransactionSpec[]): void; /** Update the view for the given array of transactions. This will @@ -2605,6 +3757,16 @@ declare class EditorView { bottom: number; }; /** + If the editor is transformed with CSS, this provides the scale + along the X axis. Otherwise, it will just be 1. Note that + transforms other than translation and scaling are not supported. + */ + get scaleX(): number; + /** + Provide the CSS transformed scale along the Y axis. + */ + get scaleY(): number; + /** Find the text line or block widget at the given vertical position (which is interpreted as relative to the [top of the document](https://codemirror.net/6/docs/ref/#view.EditorView.documentTop)). @@ -2726,6 +3888,14 @@ declare class EditorView { */ coordsAtPos(pos: number, side?: -1 | 1): Rect | null; /** + Return the rectangle around a given character. If `pos` does not + point in front of a character that is in the viewport and + rendered (i.e. not replaced, not a line break), this will return + null. For space characters that are a line wrap point, this will + return the position before the line break. + */ + coordsForChar(pos: number): Rect | null; + /** The default width of a character in the editor. May not accurately reflect the width of all characters (given variable width fonts or styling of invididual ranges). @@ -2841,13 +4011,26 @@ declare class EditorView { */ static domEventHandlers(handlers: DOMEventHandlers): Extension; /** + Create an extension that registers DOM event observers. Contrary + to event [handlers](https://codemirror.net/6/docs/ref/#view.EditorView^domEventHandlers), + observers can't be prevented from running by a higher-precedence + handler returning true. They also don't prevent other handlers + and observers from running when they return true, and should not + call `preventDefault`. + */ + static domEventObservers(observers: DOMEventHandlers): Extension; + /** An input handler can override the way changes to the editable DOM content are handled. Handlers are passed the document positions between which the change was found, and the new content. When one returns true, no further input handlers are called and the default behavior is prevented. + + The `insert` argument can be used to get the default transaction + that would be applied for this input. This can be useful when + dispatching the custom behavior as a separate transaction. */ - static inputHandler: Facet<(view: EditorView, from: number, to: number, text: string) => boolean, readonly ((view: EditorView, from: number, to: number, text: string) => boolean)[]>; + static inputHandler: Facet<(view: EditorView, from: number, to: number, text: string, insert: () => Transaction) => boolean, readonly ((view: EditorView, from: number, to: number, text: string, insert: () => Transaction) => boolean)[]>; /** This facet can be used to provide functions that create effects to be dispatched when the editor's focus state changes. @@ -2933,6 +4116,16 @@ declare class EditorView { */ static atomicRanges: Facet<(view: EditorView) => RangeSet, readonly ((view: EditorView) => RangeSet)[]>; /** + When range decorations add a `unicode-bidi: isolate` style, they + should also include a + [`bidiIsolate`](https://codemirror.net/6/docs/ref/#view.MarkDecorationSpec.bidiIsolate) property + in their decoration spec, and be exposed through this facet, so + that the editor can compute the proper text order. (Other values + for `unicode-bidi`, except of course `normal`, are not + supported.) + */ + static bidiIsolatedRanges: Facet DecorationSet), readonly (DecorationSet | ((view: EditorView) => DecorationSet))[]>; + /** Facet that allows extensions to provide additional scroll margins (space around the sides of the scrolling element that should be considered invisible). This can be useful when the @@ -2981,6 +4174,12 @@ declare class EditorView { [selector: string]: StyleSpec; }): Extension; /** + Provides a Content Security Policy nonce to use when creating + the style sheets for the editor. Holds the empty string when no + nonce has been provided. + */ + static cspNonce: Facet; + /** Facet that provides additional DOM attributes for the editor's editable DOM element. */ @@ -3024,7 +4223,7 @@ to hold the appropriate event object type. For unknown events, it is inferred to `any`, and should be explicitly set if you want type checking. */ -declare type DOMEventHandlers = { +type DOMEventHandlers = { [event in keyof DOMEventMap]?: (this: This, event: DOMEventMap[event], view: EditorView) => boolean | void; }; @@ -3109,6 +4308,13 @@ interface KeyBinding { selection can be undone). */ preventDefault?: boolean; + /** + When set to true, `stopPropagation` will be called on keyboard + events that have their `preventDefault` called in response to + this key binding (see also + [`preventDefault`](https://codemirror.net/6/docs/ref/#view.KeyBinding.preventDefault)). + */ + stopPropagation?: boolean; } /** Facet used for registering keymaps. @@ -3120,7 +4326,7 @@ for a given key, no further handlers are called. */ declare const keymap: Facet; -declare type SelectionConfig = { +type SelectionConfig = { /** The length of a full cursor blink cycle, in milliseconds. Defaults to 1200. Can be set to 0 to disable blinking. @@ -3226,6 +4432,9 @@ declare function tooltips(config?: { On iOS, which at the time of writing still doesn't properly support fixed positioning, the library always uses absolute positioning. + + If the tooltip parent element sits in a transformed element, the + library also falls back to absolute positioning. */ position?: "fixed" | "absolute"; /** @@ -3347,7 +4556,7 @@ interface TooltipView { Facet to which an extension can add a value to show a tooltip. */ declare const showTooltip: Facet; -declare type Handlers$1 = { +type Handlers$1 = { [event: string]: (view: EditorView, line: BlockInfo, event: Event) => boolean; }; interface LineNumberConfig { @@ -4098,7 +5307,7 @@ Default fold-related key bindings. - Ctrl-Alt-]: [`unfoldAll`](https://codemirror.net/6/docs/ref/#language.unfoldAll). */ declare const foldKeymap: readonly KeyBinding[]; -declare type Handlers = { +type Handlers = { [event: string]: (view: EditorView, line: BlockInfo, event: Event) => boolean; }; interface FoldGutterConfig { @@ -4295,7 +5504,7 @@ interface MatchResult { matched: boolean; } -declare type JuliaLanguageConfig = { +type JuliaLanguageConfig = { /** Enable keyword completion */ enableKeywordCompletion?: boolean; }; @@ -4366,120 +5575,24 @@ The default keymap. Includes all bindings from */ declare const defaultKeymap: readonly KeyBinding[]; -interface CompletionConfig { - /** - When enabled (defaults to true), autocompletion will start - whenever the user types something that can be completed. - */ - activateOnTyping?: boolean; - /** - By default, when completion opens, the first option is selected - and can be confirmed with - [`acceptCompletion`](https://codemirror.net/6/docs/ref/#autocomplete.acceptCompletion). When this - is set to false, the completion widget starts with no completion - selected, and the user has to explicitly move to a completion - before you can confirm one. - */ - selectOnOpen?: boolean; - /** - Override the completion sources used. By default, they will be - taken from the `"autocomplete"` [language - data](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt) (which should hold - [completion sources](https://codemirror.net/6/docs/ref/#autocomplete.CompletionSource) or arrays - of [completions](https://codemirror.net/6/docs/ref/#autocomplete.Completion)). - */ - override?: readonly CompletionSource[] | null; - /** - Determines whether the completion tooltip is closed when the - editor loses focus. Defaults to true. - */ - closeOnBlur?: boolean; - /** - The maximum number of options to render to the DOM. - */ - maxRenderedOptions?: number; - /** - Set this to false to disable the [default completion - keymap](https://codemirror.net/6/docs/ref/#autocomplete.completionKeymap). (This requires you to - add bindings to control completion yourself. The bindings should - probably have a higher precedence than other bindings for the - same keys.) - */ - defaultKeymap?: boolean; - /** - By default, completions are shown below the cursor when there is - space. Setting this to true will make the extension put the - completions above the cursor when possible. - */ - aboveCursor?: boolean; - /** - When given, this may return an additional CSS class to add to - the completion dialog element. - */ - tooltipClass?: (state: EditorState) => string; - /** - This can be used to add additional CSS classes to completion - options. - */ - optionClass?: (completion: Completion) => string; - /** - By default, the library will render icons based on the - completion's [type](https://codemirror.net/6/docs/ref/#autocomplete.Completion.type) in front of - each option. Set this to false to turn that off. - */ - icons?: boolean; - /** - This option can be used to inject additional content into - options. The `render` function will be called for each visible - completion, and should produce a DOM node to show. `position` - determines where in the DOM the result appears, relative to - other added widgets and the standard content. The default icons - have position 20, the label position 50, and the detail position - 80. - */ - addToOptions?: { - render: (completion: Completion, state: EditorState) => Node | null; - position: number; - }[]; - /** - By default, [info](https://codemirror.net/6/docs/ref/#autocomplet.Completion.info) tooltips are - placed to the side of the selected. This option can be used to - override that. It will be given rectangles for the list of - completions, the selected option, the info element, and the - availble [tooltip space](https://codemirror.net/6/docs/ref/#view.tooltips^config.tooltipSpace), - and should return style and/or class strings for the info - element. - */ - positionInfo?: (view: EditorView, list: Rect, option: Rect, info: Rect, space: Rect) => { - style?: string; - class?: string; - }; - /** - The comparison function to use when sorting completions with the same - match score. Defaults to using - [`localeCompare`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare). - */ - compareCompletions?: (a: Completion, b: Completion) => number; - /** - By default, commands relating to an open completion only take - effect 75 milliseconds after the completion opened, so that key - presses made before the user is aware of the tooltip don't go to - the tooltip. This option can be used to configure that delay. - */ - interactionDelay?: number; -} - /** Objects type used to represent individual completions. */ interface Completion { /** The label to show in the completion picker. This is what input - is matched agains to determine whether a completion matches (and + is matched against to determine whether a completion matches (and how well it matches). */ label: string; /** + An optional override for the completion's visible label. When + using this, matched characters will only be highlighted if you + provide a [`getMatch`](https://codemirror.net/6/docs/ref/#autocomplete.CompletionResult.getMatch) + function. + */ + displayLabel?: string; + /** An optional short piece of information to show (with a different style) after the label. */ @@ -4489,7 +5602,7 @@ interface Completion { a plain string or a function that'll render the DOM structure to show when invoked. */ - info?: string | ((completion: Completion) => (Node | null | Promise)); + info?: string | ((completion: Completion) => CompletionInfo | Promise); /** How to apply the completion. The default is to replace it with its [label](https://codemirror.net/6/docs/ref/#autocomplete.Completion.label). When this holds a @@ -4529,6 +5642,16 @@ interface Completion { section?: string | CompletionSection; } /** +The type returned from +[`Completion.info`](https://codemirror.net/6/docs/ref/#autocomplete.Completion.info). May be a DOM +node, null to indicate there is no info, or an object with an +optional `destroy` method that cleans up the node. +*/ +type CompletionInfo = Node | null | { + dom: Node; + destroy?(): void; +}; +/** Object used to describe a completion [section](https://codemirror.net/6/docs/ref/#autocomplete.Completion.section). It is recommended to create a shared object used by all the completions in a given @@ -4645,7 +5768,7 @@ may return its [result](https://codemirror.net/6/docs/ref/#autocomplete.Completi synchronously or as a promise. Returning null indicates no completions are available. */ -declare type CompletionSource = (context: CompletionContext) => CompletionResult | null | Promise; +type CompletionSource = (context: CompletionContext) => CompletionResult | null | Promise; /** Interface for objects returned by completion sources. */ @@ -4686,12 +5809,15 @@ interface CompletionResult { filter?: boolean; /** When [`filter`](https://codemirror.net/6/docs/ref/#autocomplete.CompletionResult.filter) is set to - `false`, this may be provided to compute the ranges on the label - that match the input. Should return an array of numbers where - each pair of adjacent numbers provide the start and end of a - range. + `false` or a completion has a + [`displayLabel`](https://codemirror.net/6/docs/ref/#autocomplete.Completion.displayLabel), this + may be provided to compute the ranges on the label that match + the input. Should return an array of numbers where each pair of + adjacent numbers provide the start and end of a range. The + second argument, the match found by the library, is only passed + when `filter` isn't `false`. */ - getMatch?: (completion: Completion) => readonly number[]; + getMatch?: (completion: Completion, matched?: readonly number[]) => readonly number[]; /** Synchronously update the completion result after typing or deletion. If given, this should not do any expensive work, since @@ -4714,6 +5840,116 @@ selection range that has the same text in front of it. */ declare function insertCompletionText(state: EditorState, text: string, from: number, to: number): TransactionSpec; +interface CompletionConfig { + /** + When enabled (defaults to true), autocompletion will start + whenever the user types something that can be completed. + */ + activateOnTyping?: boolean; + /** + By default, when completion opens, the first option is selected + and can be confirmed with + [`acceptCompletion`](https://codemirror.net/6/docs/ref/#autocomplete.acceptCompletion). When this + is set to false, the completion widget starts with no completion + selected, and the user has to explicitly move to a completion + before you can confirm one. + */ + selectOnOpen?: boolean; + /** + Override the completion sources used. By default, they will be + taken from the `"autocomplete"` [language + data](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt) (which should hold + [completion sources](https://codemirror.net/6/docs/ref/#autocomplete.CompletionSource) or arrays + of [completions](https://codemirror.net/6/docs/ref/#autocomplete.Completion)). + */ + override?: readonly CompletionSource[] | null; + /** + Determines whether the completion tooltip is closed when the + editor loses focus. Defaults to true. + */ + closeOnBlur?: boolean; + /** + The maximum number of options to render to the DOM. + */ + maxRenderedOptions?: number; + /** + Set this to false to disable the [default completion + keymap](https://codemirror.net/6/docs/ref/#autocomplete.completionKeymap). (This requires you to + add bindings to control completion yourself. The bindings should + probably have a higher precedence than other bindings for the + same keys.) + */ + defaultKeymap?: boolean; + /** + By default, completions are shown below the cursor when there is + space. Setting this to true will make the extension put the + completions above the cursor when possible. + */ + aboveCursor?: boolean; + /** + When given, this may return an additional CSS class to add to + the completion dialog element. + */ + tooltipClass?: (state: EditorState) => string; + /** + This can be used to add additional CSS classes to completion + options. + */ + optionClass?: (completion: Completion) => string; + /** + By default, the library will render icons based on the + completion's [type](https://codemirror.net/6/docs/ref/#autocomplete.Completion.type) in front of + each option. Set this to false to turn that off. + */ + icons?: boolean; + /** + This option can be used to inject additional content into + options. The `render` function will be called for each visible + completion, and should produce a DOM node to show. `position` + determines where in the DOM the result appears, relative to + other added widgets and the standard content. The default icons + have position 20, the label position 50, and the detail position + 80. + */ + addToOptions?: { + render: (completion: Completion, state: EditorState) => Node | null; + position: number; + }[]; + /** + By default, [info](https://codemirror.net/6/docs/ref/#autocomplete.Completion.info) tooltips are + placed to the side of the selected completion. This option can + be used to override that. It will be given rectangles for the + list of completions, the selected option, the info element, and + the availble [tooltip + space](https://codemirror.net/6/docs/ref/#view.tooltips^config.tooltipSpace), and should return + style and/or class strings for the info element. + */ + positionInfo?: (view: EditorView, list: Rect, option: Rect, info: Rect, space: Rect) => { + style?: string; + class?: string; + }; + /** + The comparison function to use when sorting completions with the same + match score. Defaults to using + [`localeCompare`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/localeCompare). + */ + compareCompletions?: (a: Completion, b: Completion) => number; + /** + By default, commands relating to an open completion only take + effect 75 milliseconds after the completion opened, so that key + presses made before the user is aware of the tooltip don't go to + the tooltip. This option can be used to configure that delay. + */ + interactionDelay?: number; + /** + When there are multiple asynchronous completion sources, this + controls how long the extension waits for a slow source before + displaying results from faster sources. Defaults to 100 + milliseconds. + */ + updateSyncTime?: number; +} + /** Convert a snippet template to a function that can [apply](https://codemirror.net/6/docs/ref/#autocomplete.Completion.apply) it. Snippets are written @@ -4747,7 +5983,7 @@ interpreted as indicating a placeholder. declare function snippet(template: string): (editor: { state: EditorState; dispatch: (tr: Transaction) => void; -}, completion: Completion, from: number, to: number) => void; +}, completion: Completion | null, from: number, to: number) => void; /** A command that clears the active snippet, if any. */ @@ -4761,6 +5997,16 @@ Move to the previous snippet field, if available. */ declare const prevSnippetField: StateCommand; /** +Check if there is an active snippet with a next field for +`nextSnippetField` to move to. +*/ +declare function hasNextSnippetField(state: EditorState): boolean; +/** +Returns true if there is an active snippet and a previous field +for `prevSnippetField` to move to. +*/ +declare function hasPrevSnippetField(state: EditorState): boolean; +/** A facet that can be used to configure the key bindings used by snippets. The default binds Tab to [`nextSnippetField`](https://codemirror.net/6/docs/ref/#autocomplete.nextSnippetField), Shift-Tab to @@ -4901,6 +6147,7 @@ type index_d_CloseBracketConfig = CloseBracketConfig; type index_d_Completion = Completion; type index_d_CompletionContext = CompletionContext; declare const index_d_CompletionContext: typeof CompletionContext; +type index_d_CompletionInfo = CompletionInfo; type index_d_CompletionResult = CompletionResult; type index_d_CompletionSection = CompletionSection; type index_d_CompletionSource = CompletionSource; @@ -4916,6 +6163,8 @@ declare const index_d_completionKeymap: typeof completionKeymap; declare const index_d_completionStatus: typeof completionStatus; declare const index_d_currentCompletions: typeof currentCompletions; declare const index_d_deleteBracketPair: typeof deleteBracketPair; +declare const index_d_hasNextSnippetField: typeof hasNextSnippetField; +declare const index_d_hasPrevSnippetField: typeof hasPrevSnippetField; declare const index_d_ifIn: typeof ifIn; declare const index_d_ifNotIn: typeof ifNotIn; declare const index_d_insertBracket: typeof insertBracket; @@ -4936,6 +6185,7 @@ declare namespace index_d { index_d_CloseBracketConfig as CloseBracketConfig, index_d_Completion as Completion, index_d_CompletionContext as CompletionContext, + index_d_CompletionInfo as CompletionInfo, index_d_CompletionResult as CompletionResult, index_d_CompletionSection as CompletionSection, index_d_CompletionSource as CompletionSource, @@ -4951,6 +6201,8 @@ declare namespace index_d { index_d_completionStatus as completionStatus, index_d_currentCompletions as currentCompletions, index_d_deleteBracketPair as deleteBracketPair, + index_d_hasNextSnippetField as hasNextSnippetField, + index_d_hasPrevSnippetField as hasPrevSnippetField, index_d_ifIn as ifIn, index_d_ifNotIn as ifNotIn, index_d_insertBracket as insertBracket, @@ -4969,7 +6221,7 @@ declare namespace index_d { }; } -declare type HighlightOptions = { +type HighlightOptions = { /** Determines whether, when nothing is selected, the word around the cursor is matched instead. Defaults to false. @@ -5032,7 +6284,7 @@ declare class Line { countIndent(to: number, from?: number, indent?: number): number; findColumn(goal: number): number; } -declare type BlockResult = boolean | null; +type BlockResult = boolean | null; declare class BlockContext implements PartialParse { readonly parser: MarkdownParser; private line; @@ -5093,7 +6345,7 @@ interface MarkdownConfig { remove?: readonly string[]; wrap?: ParseWrapper; } -declare type MarkdownExtension = MarkdownConfig | readonly MarkdownExtension[]; +type MarkdownExtension = MarkdownConfig | readonly MarkdownExtension[]; declare class MarkdownParser extends Parser { readonly nodeSet: NodeSet; createParse(input: Input, fragments: readonly TreeFragment[], ranges: readonly { @@ -5172,6 +6424,12 @@ declare function markdown(config?: { [`commonmarkLanguage`](https://codemirror.net/6/docs/ref/#lang-markdown.commonmarkLanguage). */ base?: Language; + /** + By default, the extension installs an autocompletion source that + completes HTML tags when a `<` is typed. Set this to false to + disable this. + */ + completeHTMLTags?: boolean; }): LanguageSupport; /** @@ -5195,14 +6453,14 @@ interface TagSpec { children?: readonly string[]; } -declare type NestedLang = { +type NestedLang = { tag: string; attrs?: (attrs: { [attr: string]: string; }) => boolean; parser: Parser; }; -declare type NestedAttr = { +type NestedAttr = { name: string; tagName?: string; parser: Parser; @@ -5254,6 +6512,7 @@ declare function html(config?: { nestedAttributes?: NestedAttr[]; }): LanguageSupport; +type Severity = "hint" | "info" | "warning" | "error"; /** Describes a problem or hint for a piece of code. */ @@ -5271,7 +6530,12 @@ interface Diagnostic { The severity of the problem. This will influence how it is displayed. */ - severity: "info" | "warning" | "error"; + severity: Severity; + /** + When given, add an extra CSS class to parts of the code that + this diagnostic applies to. + */ + markClass?: string; /** An optional source string indicating where the diagnostic is coming from. You can put the name of your linter here, if @@ -5308,7 +6572,7 @@ interface Action { */ apply: (view: EditorView, from: number, to: number) => void; } -declare type DiagnosticFilter = (diagnostics: readonly Diagnostic[]) => Diagnostic[]; +type DiagnosticFilter = (diagnostics: readonly Diagnostic[]) => Diagnostic[]; interface LintConfig { /** Time to wait (in milliseconds) after a change before running @@ -5341,7 +6605,7 @@ declare function setDiagnostics(state: EditorState, diagnostics: readonly Diagno /** The type of a function that produces diagnostics. */ -declare type LintSource = (view: EditorView) => readonly Diagnostic[] | Promise; +type LintSource = (view: EditorView) => readonly Diagnostic[] | Promise; /** Given a diagnostic source, this function returns an extension that enables linting with that source. It will be called whenever the @@ -5375,6 +6639,9 @@ Language support for CSS. */ declare function css(): LanguageSupport; +/** +Configuration for an [SQL Dialect](https://codemirror.net/6/docs/ref/#lang-sql.SQLDialect). +*/ declare type SQLDialectSpec = { /** A space-separated list of keywords for the dialect. @@ -5420,6 +6687,11 @@ declare type SQLDialectSpec = { */ charSetCasts?: boolean; /** + Enables string quoting syntax like `q'[str]'`, as used in + PL/SQL. + */ + plsqlQuotingMechanism?: boolean; + /** The set of characters that make up operators. Defaults to `"*+\-%<>!=&|~^/"`. */ @@ -5439,6 +6711,10 @@ declare type SQLDialectSpec = { to false. */ unquotedBitLiterals?: boolean; + /** + Controls whether bit values can contain other characters than 0 and 1. + Defaults to false. + */ treatBitsAsBytes?: boolean; }; /** @@ -5449,6 +6725,10 @@ declare class SQLDialect { The language for this dialect. */ readonly language: LRLanguage; + /** + The spec used to define this dialect. + */ + readonly spec: SQLDialectSpec; private constructor(); /** Returns the language for this dialect as an extension. @@ -5546,7 +6826,7 @@ interface Update { */ clientID: string; } -declare type CollabConfig = { +type CollabConfig = { /** The starting document version. Defaults to 0. */ diff --git a/dist/index.es.js b/dist/index.es.js index af64024..bb09c67 100644 --- a/dist/index.es.js +++ b/dist/index.es.js @@ -2,10 +2,6 @@ The data structure for documents. @nonabstract */ class Text { - /** - @internal - */ - constructor() { } /** Get the line description around the given position. */ @@ -100,7 +96,8 @@ class Text { return new LineCursor(inner); } /** - @internal + Return the document as a string, using newline characters to + separate lines. */ toString() { return this.sliceString(0); } /** @@ -113,6 +110,10 @@ class Text { return lines; } /** + @internal + */ + constructor() { } + /** Create a `Text` instance for the given array of lines. */ static of(text) { @@ -1311,12 +1312,12 @@ class SelectionRange { The anchor of the range—the side that doesn't move when you extend it. */ - get anchor() { return this.flags & 16 /* RangeFlag.Inverted */ ? this.to : this.from; } + get anchor() { return this.flags & 32 /* RangeFlag.Inverted */ ? this.to : this.from; } /** The head of the range, which is moved when the range is [extended](https://codemirror.net/6/docs/ref/#state.SelectionRange.extend). */ - get head() { return this.flags & 16 /* RangeFlag.Inverted */ ? this.from : this.to; } + get head() { return this.flags & 32 /* RangeFlag.Inverted */ ? this.from : this.to; } /** True when `anchor` and `head` are at the same position. */ @@ -1327,14 +1328,14 @@ class SelectionRange { the character before its position, 1 the character after, and 0 means no association. */ - get assoc() { return this.flags & 4 /* RangeFlag.AssocBefore */ ? -1 : this.flags & 8 /* RangeFlag.AssocAfter */ ? 1 : 0; } + get assoc() { return this.flags & 8 /* RangeFlag.AssocBefore */ ? -1 : this.flags & 16 /* RangeFlag.AssocAfter */ ? 1 : 0; } /** The bidirectional text level associated with this cursor, if any. */ get bidiLevel() { - let level = this.flags & 3 /* RangeFlag.BidiLevelMask */; - return level == 3 ? null : level; + let level = this.flags & 7 /* RangeFlag.BidiLevelMask */; + return level == 7 ? null : level; } /** The goal column (stored vertical offset) associated with a @@ -1343,8 +1344,8 @@ class SelectionRange { lines of different length. */ get goalColumn() { - let value = this.flags >> 5 /* RangeFlag.GoalColumnOffset */; - return value == 33554431 /* RangeFlag.NoGoalColumn */ ? undefined : value; + let value = this.flags >> 6 /* RangeFlag.GoalColumnOffset */; + return value == 16777215 /* RangeFlag.NoGoalColumn */ ? undefined : value; } /** Map this range through a change, producing a valid range in the @@ -1504,18 +1505,18 @@ class EditorSelection { safely ignore the optional arguments in most situations. */ static cursor(pos, assoc = 0, bidiLevel, goalColumn) { - return SelectionRange.create(pos, pos, (assoc == 0 ? 0 : assoc < 0 ? 4 /* RangeFlag.AssocBefore */ : 8 /* RangeFlag.AssocAfter */) | - (bidiLevel == null ? 3 : Math.min(2, bidiLevel)) | - ((goalColumn !== null && goalColumn !== void 0 ? goalColumn : 33554431 /* RangeFlag.NoGoalColumn */) << 5 /* RangeFlag.GoalColumnOffset */)); + return SelectionRange.create(pos, pos, (assoc == 0 ? 0 : assoc < 0 ? 8 /* RangeFlag.AssocBefore */ : 16 /* RangeFlag.AssocAfter */) | + (bidiLevel == null ? 7 : Math.min(6, bidiLevel)) | + ((goalColumn !== null && goalColumn !== void 0 ? goalColumn : 16777215 /* RangeFlag.NoGoalColumn */) << 6 /* RangeFlag.GoalColumnOffset */)); } /** Create a selection range. */ static range(anchor, head, goalColumn, bidiLevel) { - let flags = ((goalColumn !== null && goalColumn !== void 0 ? goalColumn : 33554431 /* RangeFlag.NoGoalColumn */) << 5 /* RangeFlag.GoalColumnOffset */) | - (bidiLevel == null ? 3 : Math.min(2, bidiLevel)); - return head < anchor ? SelectionRange.create(head, anchor, 16 /* RangeFlag.Inverted */ | 8 /* RangeFlag.AssocAfter */ | flags) - : SelectionRange.create(anchor, head, (head > anchor ? 4 /* RangeFlag.AssocBefore */ : 0) | flags); + let flags = ((goalColumn !== null && goalColumn !== void 0 ? goalColumn : 16777215 /* RangeFlag.NoGoalColumn */) << 6 /* RangeFlag.GoalColumnOffset */) | + (bidiLevel == null ? 7 : Math.min(6, bidiLevel)); + return head < anchor ? SelectionRange.create(head, anchor, 32 /* RangeFlag.Inverted */ | 16 /* RangeFlag.AssocAfter */ | flags) + : SelectionRange.create(anchor, head, (head > anchor ? 8 /* RangeFlag.AssocBefore */ : 0) | flags); } /** @internal @@ -1552,6 +1553,9 @@ Examples of uses of facets are the [tab size](https://codemirror.net/6/docs/ref/#state.EditorState^tabSize), [editor attributes](https://codemirror.net/6/docs/ref/#view.EditorView^editorAttributes), and [update listeners](https://codemirror.net/6/docs/ref/#view.EditorView^updateListener). + +Note that `Facet` instances can be used anywhere where +[`FacetReader`](https://codemirror.net/6/docs/ref/#state.FacetReader) is expected. */ class Facet { constructor( @@ -1579,6 +1583,11 @@ class Facet { this.extensions = typeof enables == "function" ? enables(this) : enables; } /** + Returns a facet reader for this facet, which can be used to + [read](https://codemirror.net/6/docs/ref/#state.EditorState.facet) it but not to define values for it. + */ + get reader() { return this; } + /** Define a new facet. */ static define(config = {}) { @@ -2156,7 +2165,10 @@ class StateEffect { is(type) { return this.type == type; } /** Define a new effect type. The type parameter indicates the type - of values that his effect holds. + of values that his effect holds. It should be a type that + doesn't include `undefined`, since that is used in + [mapping](https://codemirror.net/6/docs/ref/#state.StateEffect.map) to indicate that an effect is + removed. */ static define(spec = {}) { return new StateEffectType(spec.map || (v => v)); @@ -3299,8 +3311,7 @@ class RangeSet { static compare(oldSets, newSets, /** This indicates how the underlying data changed between these - ranges, and is needed to synchronize the iteration. `from` and - `to` are coordinates in the _new_ space, after these changes. + ranges, and is needed to synchronize the iteration. */ textDiff, comparator, /** @@ -3411,6 +3422,18 @@ A range set builder is a data structure that helps build up a an array of [`Range`](https://codemirror.net/6/docs/ref/#state.Range) objects. */ class RangeSetBuilder { + finishChunk(newArrays) { + this.chunks.push(new Chunk(this.from, this.to, this.value, this.maxPoint)); + this.chunkPos.push(this.chunkStart); + this.chunkStart = -1; + this.setMaxPoint = Math.max(this.setMaxPoint, this.maxPoint); + this.maxPoint = -1; + if (newArrays) { + this.from = []; + this.to = []; + this.value = []; + } + } /** Create an empty builder. */ @@ -3428,18 +3451,6 @@ class RangeSetBuilder { this.setMaxPoint = -1; this.nextLayer = null; } - finishChunk(newArrays) { - this.chunks.push(new Chunk(this.from, this.to, this.value, this.maxPoint)); - this.chunkPos.push(this.chunkStart); - this.chunkStart = -1; - this.setMaxPoint = Math.max(this.setMaxPoint, this.maxPoint); - this.maxPoint = -1; - if (newArrays) { - this.from = []; - this.to = []; - this.value = []; - } - } /** Add a range. Ranges should be added in sorted (by `from` and `value.startSide`) order. @@ -3799,7 +3810,7 @@ function compare(a, startA, b, startB, length, comparator) { let end = diff < 0 ? a.to + dPos : b.to, clipEnd = Math.min(end, endB); if (a.point || b.point) { if (!(a.point && b.point && (a.point == b.point || a.point.eq(b.point)) && - sameValues(a.activeForPoint(a.to + dPos), b.activeForPoint(b.to)))) + sameValues(a.activeForPoint(a.to), b.activeForPoint(b.to)))) comparator.comparePoint(pos, clipEnd, a.point, b.point); } else { @@ -3880,9 +3891,9 @@ function findColumn(string, col, tabSize, strict) { return strict === true ? -1 : string.length; } -// FIXME profile adding a per-Tree TreeNode cache, validating it by -// parent pointer -/// The default maximum length of a `TreeBuffer` node. +/** +The default maximum length of a `TreeBuffer` node. +*/ const DefaultBufferLength = 1024; let nextPropID = 0; class Range { @@ -3891,11 +3902,15 @@ class Range { this.to = to; } } -/// Each [node type](#common.NodeType) or [individual tree](#common.Tree) -/// can have metadata associated with it in props. Instances of this -/// class represent prop names. +/** +Each [node type](#common.NodeType) or [individual tree](#common.Tree) +can have metadata associated with it in props. Instances of this +class represent prop names. +*/ class NodeProp { - /// Create a new node prop type. + /** + Create a new node prop type. + */ constructor(config = {}) { this.id = nextPropID++; this.perNode = !!config.perNode; @@ -3903,13 +3918,15 @@ class NodeProp { throw new Error("This node type doesn't define a deserialize function"); }); } - /// This is meant to be used with - /// [`NodeSet.extend`](#common.NodeSet.extend) or - /// [`LRParser.configure`](#lr.ParserConfig.props) to compute - /// prop values for each node type in the set. Takes a [match - /// object](#common.NodeType^match) or function that returns undefined - /// if the node type doesn't get this prop, and the prop's value if - /// it does. + /** + This is meant to be used with + [`NodeSet.extend`](#common.NodeSet.extend) or + [`LRParser.configure`](#lr.ParserConfig.props) to compute + prop values for each node type in the set. Takes a [match + object](#common.NodeType^match) or function that returns undefined + if the node type doesn't get this prop, and the prop's value if + it does. + */ add(match) { if (this.perNode) throw new RangeError("Can't add per-node props to node types"); @@ -3921,77 +3938,117 @@ class NodeProp { }; } } -/// Prop that is used to describe matching delimiters. For opening -/// delimiters, this holds an array of node names (written as a -/// space-separated string when declaring this prop in a grammar) -/// for the node types of closing delimiters that match it. +/** +Prop that is used to describe matching delimiters. For opening +delimiters, this holds an array of node names (written as a +space-separated string when declaring this prop in a grammar) +for the node types of closing delimiters that match it. +*/ NodeProp.closedBy = new NodeProp({ deserialize: str => str.split(" ") }); -/// The inverse of [`closedBy`](#common.NodeProp^closedBy). This is -/// attached to closing delimiters, holding an array of node names -/// of types of matching opening delimiters. +/** +The inverse of [`closedBy`](#common.NodeProp^closedBy). This is +attached to closing delimiters, holding an array of node names +of types of matching opening delimiters. +*/ NodeProp.openedBy = new NodeProp({ deserialize: str => str.split(" ") }); -/// Used to assign node types to groups (for example, all node -/// types that represent an expression could be tagged with an -/// `"Expression"` group). +/** +Used to assign node types to groups (for example, all node +types that represent an expression could be tagged with an +`"Expression"` group). +*/ NodeProp.group = new NodeProp({ deserialize: str => str.split(" ") }); -/// The hash of the [context](#lr.ContextTracker.constructor) -/// that the node was parsed in, if any. Used to limit reuse of -/// contextual nodes. +/** +The hash of the [context](#lr.ContextTracker.constructor) +that the node was parsed in, if any. Used to limit reuse of +contextual nodes. +*/ NodeProp.contextHash = new NodeProp({ perNode: true }); -/// The distance beyond the end of the node that the tokenizer -/// looked ahead for any of the tokens inside the node. (The LR -/// parser only stores this when it is larger than 25, for -/// efficiency reasons.) +/** +The distance beyond the end of the node that the tokenizer +looked ahead for any of the tokens inside the node. (The LR +parser only stores this when it is larger than 25, for +efficiency reasons.) +*/ NodeProp.lookAhead = new NodeProp({ perNode: true }); -/// This per-node prop is used to replace a given node, or part of a -/// node, with another tree. This is useful to include trees from -/// different languages in mixed-language parsers. +/** +This per-node prop is used to replace a given node, or part of a +node, with another tree. This is useful to include trees from +different languages in mixed-language parsers. +*/ NodeProp.mounted = new NodeProp({ perNode: true }); -/// A mounted tree, which can be [stored](#common.NodeProp^mounted) on -/// a tree node to indicate that parts of its content are -/// represented by another tree. +/** +A mounted tree, which can be [stored](#common.NodeProp^mounted) on +a tree node to indicate that parts of its content are +represented by another tree. +*/ class MountedTree { constructor( - /// The inner tree. + /** + The inner tree. + */ tree, - /// If this is null, this tree replaces the entire node (it will - /// be included in the regular iteration instead of its host - /// node). If not, only the given ranges are considered to be - /// covered by this tree. This is used for trees that are mixed in - /// a way that isn't strictly hierarchical. Such mounted trees are - /// only entered by [`resolveInner`](#common.Tree.resolveInner) - /// and [`enter`](#common.SyntaxNode.enter). + /** + If this is null, this tree replaces the entire node (it will + be included in the regular iteration instead of its host + node). If not, only the given ranges are considered to be + covered by this tree. This is used for trees that are mixed in + a way that isn't strictly hierarchical. Such mounted trees are + only entered by [`resolveInner`](#common.Tree.resolveInner) + and [`enter`](#common.SyntaxNode.enter). + */ overlay, - /// The parser used to create this subtree. + /** + The parser used to create this subtree. + */ parser) { this.tree = tree; this.overlay = overlay; this.parser = parser; } + /** + @internal + */ + static get(tree) { + return tree && tree.props && tree.props[NodeProp.mounted.id]; + } } const noProps = Object.create(null); -/// Each node in a syntax tree has a node type associated with it. +/** +Each node in a syntax tree has a node type associated with it. +*/ class NodeType { - /// @internal + /** + @internal + */ constructor( - /// The name of the node type. Not necessarily unique, but if the - /// grammar was written properly, different node types with the - /// same name within a node set should play the same semantic - /// role. + /** + The name of the node type. Not necessarily unique, but if the + grammar was written properly, different node types with the + same name within a node set should play the same semantic + role. + */ name, - /// @internal + /** + @internal + */ props, - /// The id of this node in its set. Corresponds to the term ids - /// used in the parser. + /** + The id of this node in its set. Corresponds to the term ids + used in the parser. + */ id, - /// @internal + /** + @internal + */ flags = 0) { this.name = name; this.props = props; this.id = id; this.flags = flags; } - /// Define a node type. + /** + Define a node type. + */ static define(spec) { let props = spec.props && spec.props.length ? Object.create(null) : noProps; let flags = (spec.top ? 1 /* NodeFlag.Top */ : 0) | (spec.skipped ? 2 /* NodeFlag.Skipped */ : 0) | @@ -4009,20 +4066,32 @@ class NodeType { } return type; } - /// Retrieves a node prop for this type. Will return `undefined` if - /// the prop isn't present on this node. + /** + Retrieves a node prop for this type. Will return `undefined` if + the prop isn't present on this node. + */ prop(prop) { return this.props[prop.id]; } - /// True when this is the top node of a grammar. + /** + True when this is the top node of a grammar. + */ get isTop() { return (this.flags & 1 /* NodeFlag.Top */) > 0; } - /// True when this node is produced by a skip rule. + /** + True when this node is produced by a skip rule. + */ get isSkipped() { return (this.flags & 2 /* NodeFlag.Skipped */) > 0; } - /// Indicates whether this is an error node. + /** + Indicates whether this is an error node. + */ get isError() { return (this.flags & 4 /* NodeFlag.Error */) > 0; } - /// When true, this node type doesn't correspond to a user-declared - /// named node, for example because it is used to cache repetition. + /** + When true, this node type doesn't correspond to a user-declared + named node, for example because it is used to cache repetition. + */ get isAnonymous() { return (this.flags & 8 /* NodeFlag.Anonymous */) > 0; } - /// Returns true when this node's name or one of its - /// [groups](#common.NodeProp^group) matches the given string. + /** + Returns true when this node's name or one of its + [groups](#common.NodeProp^group) matches the given string. + */ is(name) { if (typeof name == 'string') { if (this.name == name) @@ -4032,12 +4101,14 @@ class NodeType { } return this.id == name; } - /// Create a function from node types to arbitrary values by - /// specifying an object whose property names are node or - /// [group](#common.NodeProp^group) names. Often useful with - /// [`NodeProp.add`](#common.NodeProp.add). You can put multiple - /// names, separated by spaces, in a single property name to map - /// multiple node names to a single value. + /** + Create a function from node types to arbitrary values by + specifying an object whose property names are node or + [group](#common.NodeProp^group) names. Often useful with + [`NodeProp.add`](#common.NodeProp.add). You can put multiple + names, separated by spaces, in a single property name to map + multiple node names to a single value. + */ static match(map) { let direct = Object.create(null); for (let prop in map) @@ -4052,29 +4123,39 @@ class NodeType { }; } } -/// An empty dummy node type to use when no actual type is available. +/** +An empty dummy node type to use when no actual type is available. +*/ NodeType.none = new NodeType("", Object.create(null), 0, 8 /* NodeFlag.Anonymous */); -/// A node set holds a collection of node types. It is used to -/// compactly represent trees by storing their type ids, rather than a -/// full pointer to the type object, in a numeric array. Each parser -/// [has](#lr.LRParser.nodeSet) a node set, and [tree -/// buffers](#common.TreeBuffer) can only store collections of nodes -/// from the same set. A set can have a maximum of 2**16 (65536) node -/// types in it, so that the ids fit into 16-bit typed array slots. +/** +A node set holds a collection of node types. It is used to +compactly represent trees by storing their type ids, rather than a +full pointer to the type object, in a numeric array. Each parser +[has](#lr.LRParser.nodeSet) a node set, and [tree +buffers](#common.TreeBuffer) can only store collections of nodes +from the same set. A set can have a maximum of 2**16 (65536) node +types in it, so that the ids fit into 16-bit typed array slots. +*/ class NodeSet { - /// Create a set with the given types. The `id` property of each - /// type should correspond to its position within the array. + /** + Create a set with the given types. The `id` property of each + type should correspond to its position within the array. + */ constructor( - /// The node types in this set, by id. + /** + The node types in this set, by id. + */ types) { this.types = types; for (let i = 0; i < types.length; i++) if (types[i].id != i) throw new RangeError("Node type ids should correspond to array positions when creating a node set"); } - /// Create a copy of this set with some node properties added. The - /// arguments to this method can be created with - /// [`NodeProp.add`](#common.NodeProp.add). + /** + Create a copy of this set with some node properties added. The + arguments to this method can be created with + [`NodeProp.add`](#common.NodeProp.add). + */ extend(...props) { let newTypes = []; for (let type of this.types) { @@ -4093,61 +4174,87 @@ class NodeSet { } } const CachedNode = new WeakMap(), CachedInnerNode = new WeakMap(); -/// Options that control iteration. Can be combined with the `|` -/// operator to enable multiple ones. +/** +Options that control iteration. Can be combined with the `|` +operator to enable multiple ones. +*/ var IterMode; (function (IterMode) { - /// When enabled, iteration will only visit [`Tree`](#common.Tree) - /// objects, not nodes packed into - /// [`TreeBuffer`](#common.TreeBuffer)s. + /** + When enabled, iteration will only visit [`Tree`](#common.Tree) + objects, not nodes packed into + [`TreeBuffer`](#common.TreeBuffer)s. + */ IterMode[IterMode["ExcludeBuffers"] = 1] = "ExcludeBuffers"; - /// Enable this to make iteration include anonymous nodes (such as - /// the nodes that wrap repeated grammar constructs into a balanced - /// tree). + /** + Enable this to make iteration include anonymous nodes (such as + the nodes that wrap repeated grammar constructs into a balanced + tree). + */ IterMode[IterMode["IncludeAnonymous"] = 2] = "IncludeAnonymous"; - /// By default, regular [mounted](#common.NodeProp^mounted) nodes - /// replace their base node in iteration. Enable this to ignore them - /// instead. + /** + By default, regular [mounted](#common.NodeProp^mounted) nodes + replace their base node in iteration. Enable this to ignore them + instead. + */ IterMode[IterMode["IgnoreMounts"] = 4] = "IgnoreMounts"; - /// This option only applies in - /// [`enter`](#common.SyntaxNode.enter)-style methods. It tells the - /// library to not enter mounted overlays if one covers the given - /// position. + /** + This option only applies in + [`enter`](#common.SyntaxNode.enter)-style methods. It tells the + library to not enter mounted overlays if one covers the given + position. + */ IterMode[IterMode["IgnoreOverlays"] = 8] = "IgnoreOverlays"; })(IterMode || (IterMode = {})); -/// A piece of syntax tree. There are two ways to approach these -/// trees: the way they are actually stored in memory, and the -/// convenient way. -/// -/// Syntax trees are stored as a tree of `Tree` and `TreeBuffer` -/// objects. By packing detail information into `TreeBuffer` leaf -/// nodes, the representation is made a lot more memory-efficient. -/// -/// However, when you want to actually work with tree nodes, this -/// representation is very awkward, so most client code will want to -/// use the [`TreeCursor`](#common.TreeCursor) or -/// [`SyntaxNode`](#common.SyntaxNode) interface instead, which provides -/// a view on some part of this data structure, and can be used to -/// move around to adjacent nodes. +/** +A piece of syntax tree. There are two ways to approach these +trees: the way they are actually stored in memory, and the +convenient way. + +Syntax trees are stored as a tree of `Tree` and `TreeBuffer` +objects. By packing detail information into `TreeBuffer` leaf +nodes, the representation is made a lot more memory-efficient. + +However, when you want to actually work with tree nodes, this +representation is very awkward, so most client code will want to +use the [`TreeCursor`](#common.TreeCursor) or +[`SyntaxNode`](#common.SyntaxNode) interface instead, which provides +a view on some part of this data structure, and can be used to +move around to adjacent nodes. +*/ class Tree { - /// Construct a new tree. See also [`Tree.build`](#common.Tree^build). + /** + Construct a new tree. See also [`Tree.build`](#common.Tree^build). + */ constructor( - /// The type of the top node. + /** + The type of the top node. + */ type, - /// This node's child nodes. + /** + This node's child nodes. + */ children, - /// The positions (offsets relative to the start of this tree) of - /// the children. + /** + The positions (offsets relative to the start of this tree) of + the children. + */ positions, - /// The total length of this tree + /** + The total length of this tree + */ length, - /// Per-node [node props](#common.NodeProp) to associate with this node. + /** + Per-node [node props](#common.NodeProp) to associate with this node. + */ props) { this.type = type; this.children = children; this.positions = positions; this.length = length; - /// @internal + /** + @internal + */ this.props = null; if (props && props.length) { this.props = Object.create(null); @@ -4155,9 +4262,11 @@ class Tree { this.props[typeof prop == "number" ? prop : prop.id] = value; } } - /// @internal + /** + @internal + */ toString() { - let mounted = this.prop(NodeProp.mounted); + let mounted = MountedTree.get(this); if (mounted && !mounted.overlay) return mounted.tree.toString(); let children = ""; @@ -4173,15 +4282,19 @@ class Tree { (/\W/.test(this.type.name) && !this.type.isError ? JSON.stringify(this.type.name) : this.type.name) + (children.length ? "(" + children + ")" : ""); } - /// Get a [tree cursor](#common.TreeCursor) positioned at the top of - /// the tree. Mode can be used to [control](#common.IterMode) which - /// nodes the cursor visits. + /** + Get a [tree cursor](#common.TreeCursor) positioned at the top of + the tree. Mode can be used to [control](#common.IterMode) which + nodes the cursor visits. + */ cursor(mode = 0) { return new TreeCursor(this.topNode, mode); } - /// Get a [tree cursor](#common.TreeCursor) pointing into this tree - /// at the given position and side (see - /// [`moveTo`](#common.TreeCursor.moveTo). + /** + Get a [tree cursor](#common.TreeCursor) pointing into this tree + at the given position and side (see + [`moveTo`](#common.TreeCursor.moveTo). + */ cursorAt(pos, side = 0, mode = 0) { let scope = CachedNode.get(this) || this.topNode; let cursor = new TreeCursor(scope); @@ -4189,51 +4302,70 @@ class Tree { CachedNode.set(this, cursor._tree); return cursor; } - /// Get a [syntax node](#common.SyntaxNode) object for the top of the - /// tree. + /** + Get a [syntax node](#common.SyntaxNode) object for the top of the + tree. + */ get topNode() { return new TreeNode(this, 0, 0, null); } - /// Get the [syntax node](#common.SyntaxNode) at the given position. - /// If `side` is -1, this will move into nodes that end at the - /// position. If 1, it'll move into nodes that start at the - /// position. With 0, it'll only enter nodes that cover the position - /// from both sides. - /// - /// Note that this will not enter - /// [overlays](#common.MountedTree.overlay), and you often want - /// [`resolveInner`](#common.Tree.resolveInner) instead. + /** + Get the [syntax node](#common.SyntaxNode) at the given position. + If `side` is -1, this will move into nodes that end at the + position. If 1, it'll move into nodes that start at the + position. With 0, it'll only enter nodes that cover the position + from both sides. + + Note that this will not enter + [overlays](#common.MountedTree.overlay), and you often want + [`resolveInner`](#common.Tree.resolveInner) instead. + */ resolve(pos, side = 0) { let node = resolveNode(CachedNode.get(this) || this.topNode, pos, side, false); CachedNode.set(this, node); return node; } - /// Like [`resolve`](#common.Tree.resolve), but will enter - /// [overlaid](#common.MountedTree.overlay) nodes, producing a syntax node - /// pointing into the innermost overlaid tree at the given position - /// (with parent links going through all parent structure, including - /// the host trees). + /** + Like [`resolve`](#common.Tree.resolve), but will enter + [overlaid](#common.MountedTree.overlay) nodes, producing a syntax node + pointing into the innermost overlaid tree at the given position + (with parent links going through all parent structure, including + the host trees). + */ resolveInner(pos, side = 0) { let node = resolveNode(CachedInnerNode.get(this) || this.topNode, pos, side, true); CachedInnerNode.set(this, node); return node; } - /// Iterate over the tree and its children, calling `enter` for any - /// node that touches the `from`/`to` region (if given) before - /// running over such a node's children, and `leave` (if given) when - /// leaving the node. When `enter` returns `false`, that node will - /// not have its children iterated over (or `leave` called). + /** + In some situations, it can be useful to iterate through all + nodes around a position, including those in overlays that don't + directly cover the position. This method gives you an iterator + that will produce all nodes, from small to big, around the given + position. + */ + resolveStack(pos, side = 0) { + return stackIterator(this, pos, side); + } + /** + Iterate over the tree and its children, calling `enter` for any + node that touches the `from`/`to` region (if given) before + running over such a node's children, and `leave` (if given) when + leaving the node. When `enter` returns `false`, that node will + not have its children iterated over (or `leave` called). + */ iterate(spec) { let { enter, leave, from = 0, to = this.length } = spec; - for (let c = this.cursor((spec.mode || 0) | IterMode.IncludeAnonymous);;) { + let mode = spec.mode || 0, anon = (mode & IterMode.IncludeAnonymous) > 0; + for (let c = this.cursor(mode | IterMode.IncludeAnonymous);;) { let entered = false; - if (c.from <= to && c.to >= from && (c.type.isAnonymous || enter(c) !== false)) { + if (c.from <= to && c.to >= from && (!anon && c.type.isAnonymous || enter(c) !== false)) { if (c.firstChild()) continue; entered = true; } for (;;) { - if (entered && leave && !c.type.isAnonymous) + if (entered && leave && (anon || !c.type.isAnonymous)) leave(c); if (c.nextSibling()) break; @@ -4243,14 +4375,18 @@ class Tree { } } } - /// Get the value of the given [node prop](#common.NodeProp) for this - /// node. Works with both per-node and per-type props. + /** + Get the value of the given [node prop](#common.NodeProp) for this + node. Works with both per-node and per-type props. + */ prop(prop) { return !prop.perNode ? this.type.prop(prop) : this.props ? this.props[prop.id] : undefined; } - /// Returns the node's [per-node props](#common.NodeProp.perNode) in a - /// format that can be passed to the [`Tree`](#common.Tree) - /// constructor. + /** + Returns the node's [per-node props](#common.NodeProp.perNode) in a + format that can be passed to the [`Tree`](#common.Tree) + constructor. + */ get propValues() { let result = []; if (this.props) @@ -4258,18 +4394,24 @@ class Tree { result.push([+id, this.props[id]]); return result; } - /// Balance the direct children of this tree, producing a copy of - /// which may have children grouped into subtrees with type - /// [`NodeType.none`](#common.NodeType^none). + /** + Balance the direct children of this tree, producing a copy of + which may have children grouped into subtrees with type + [`NodeType.none`](#common.NodeType^none). + */ balance(config = {}) { return this.children.length <= 8 /* Balance.BranchFactor */ ? this : balanceRange(NodeType.none, this.children, this.positions, 0, this.children.length, 0, this.length, (children, positions, length) => new Tree(this.type, children, positions, length, this.propValues), config.makeTree || ((children, positions, length) => new Tree(NodeType.none, children, positions, length))); } - /// Build a tree from a postfix-ordered buffer of node information, - /// or a cursor over such a buffer. + /** + Build a tree from a postfix-ordered buffer of node information, + or a cursor over such a buffer. + */ static build(data) { return buildTree(data); } } -/// The empty tree +/** +The empty tree +*/ Tree.empty = new Tree(NodeType.none, [], [], 0); class FlatBufferCursor { constructor(buffer, index) { @@ -4284,26 +4426,40 @@ class FlatBufferCursor { next() { this.index -= 4; } fork() { return new FlatBufferCursor(this.buffer, this.index); } } -/// Tree buffers contain (type, start, end, endIndex) quads for each -/// node. In such a buffer, nodes are stored in prefix order (parents -/// before children, with the endIndex of the parent indicating which -/// children belong to it). +/** +Tree buffers contain (type, start, end, endIndex) quads for each +node. In such a buffer, nodes are stored in prefix order (parents +before children, with the endIndex of the parent indicating which +children belong to it). +*/ class TreeBuffer { - /// Create a tree buffer. + /** + Create a tree buffer. + */ constructor( - /// The buffer's content. + /** + The buffer's content. + */ buffer, - /// The total length of the group of nodes in the buffer. + /** + The total length of the group of nodes in the buffer. + */ length, - /// The node set used in this buffer. + /** + The node set used in this buffer. + */ set) { this.buffer = buffer; this.length = length; this.set = set; } - /// @internal + /** + @internal + */ get type() { return NodeType.none; } - /// @internal + /** + @internal + */ toString() { let result = []; for (let index = 0; index < this.buffer.length;) { @@ -4312,7 +4468,9 @@ class TreeBuffer { } return result.join(","); } - /// @internal + /** + @internal + */ childString(index) { let id = this.buffer[index], endIndex = this.buffer[index + 3]; let type = this.set.types[id], result = type.name; @@ -4328,7 +4486,9 @@ class TreeBuffer { } return result + "(" + children.join(",") + ")"; } - /// @internal + /** + @internal + */ findChild(startIndex, endIndex, dir, pos, side) { let { buffer } = this, pick = -1; for (let i = startIndex; i != endIndex; i = buffer[i + 3]) { @@ -4340,7 +4500,9 @@ class TreeBuffer { } return pick; } - /// @internal + /** + @internal + */ slice(startI, endI, from) { let b = this.buffer; let copy = new Uint16Array(endI - startI), len = 0; @@ -4364,22 +4526,6 @@ function checkSide(side, pos, from, to) { case 4 /* Side.DontCare */: return true; } } -function enterUnfinishedNodesBefore(node, pos) { - let scan = node.childBefore(pos); - while (scan) { - let last = scan.lastChild; - if (!last || last.to != scan.to) - break; - if (last.type.isError && last.from == last.to) { - node = scan; - scan = last.prevSibling; - } - else { - scan = last; - } - } - return node; -} function resolveNode(node, pos, side, overlays) { var _a; // Move up to a node that actually holds the position, if possible @@ -4405,10 +4551,48 @@ function resolveNode(node, pos, side, overlays) { node = inner; } } -class TreeNode { +class BaseNode { + cursor(mode = 0) { return new TreeCursor(this, mode); } + getChild(type, before = null, after = null) { + let r = getChildren(this, type, before, after); + return r.length ? r[0] : null; + } + getChildren(type, before = null, after = null) { + return getChildren(this, type, before, after); + } + resolve(pos, side = 0) { + return resolveNode(this, pos, side, false); + } + resolveInner(pos, side = 0) { + return resolveNode(this, pos, side, true); + } + matchContext(context) { + return matchNodeContext(this, context); + } + enterUnfinishedNodesBefore(pos) { + let scan = this.childBefore(pos), node = this; + while (scan) { + let last = scan.lastChild; + if (!last || last.to != scan.to) + break; + if (last.type.isError && last.from == last.to) { + node = scan; + scan = last.prevSibling; + } + else { + scan = last; + } + } + return node; + } + get node() { return this; } + get next() { return this.parent; } +} +class TreeNode extends BaseNode { constructor(_tree, from, // Index in parent node, set to -1 if the node is not a direct child of _parent.node (overlay) index, _parent) { + super(); this._tree = _tree; this.from = from; this.index = index; @@ -4432,8 +4616,7 @@ class TreeNode { } else if ((mode & IterMode.IncludeAnonymous) || (!next.type.isAnonymous || hasChild(next))) { let mounted; - if (!(mode & IterMode.IgnoreMounts) && - next.props && (mounted = next.prop(NodeProp.mounted)) && !mounted.overlay) + if (!(mode & IterMode.IgnoreMounts) && (mounted = MountedTree.get(next)) && !mounted.overlay) return new TreeNode(mounted.tree, start, i, parent); let inner = new TreeNode(next, start, i, parent); return (mode & IterMode.IncludeAnonymous) || !inner.type.isAnonymous ? inner @@ -4457,7 +4640,7 @@ class TreeNode { childBefore(pos) { return this.nextChild(this._tree.children.length - 1, -1, pos, -2 /* Side.Before */); } enter(pos, side, mode = 0) { let mounted; - if (!(mode & IterMode.IgnoreOverlays) && (mounted = this._tree.prop(NodeProp.mounted)) && mounted.overlay) { + if (!(mode & IterMode.IgnoreOverlays) && (mounted = MountedTree.get(this._tree)) && mounted.overlay) { let rPos = pos - this.from; for (let { from, to } of mounted.overlay) { if ((side > 0 ? from <= rPos : from < rPos) && @@ -4482,27 +4665,12 @@ class TreeNode { get prevSibling() { return this._parent && this.index >= 0 ? this._parent.nextChild(this.index - 1, -1, 0, 4 /* Side.DontCare */) : null; } - cursor(mode = 0) { return new TreeCursor(this, mode); } get tree() { return this._tree; } toTree() { return this._tree; } - resolve(pos, side = 0) { - return resolveNode(this, pos, side, false); - } - resolveInner(pos, side = 0) { - return resolveNode(this, pos, side, true); - } - enterUnfinishedNodesBefore(pos) { return enterUnfinishedNodesBefore(this, pos); } - getChild(type, before = null, after = null) { - let r = getChildren(this, type, before, after); - return r.length ? r[0] : null; - } - getChildren(type, before = null, after = null) { - return getChildren(this, type, before, after); - } - /// @internal + /** + @internal + */ toString() { return this._tree.toString(); } - get node() { return this; } - matchContext(context) { return matchNodeContext(this, context); } } function getChildren(node, type, before, after) { let cur = node.cursor(), result = []; @@ -4541,11 +4709,12 @@ class BufferContext { this.start = start; } } -class BufferNode { +class BufferNode extends BaseNode { get name() { return this.type.name; } get from() { return this.context.start + this.context.buffer.buffer[this.index + 1]; } get to() { return this.context.start + this.context.buffer.buffer[this.index + 2]; } constructor(context, _parent, index) { + super(); this.context = context; this._parent = _parent; this.index = index; @@ -4587,7 +4756,6 @@ class BufferNode { return this.externalSibling(-1); return new BufferNode(this.context, this._parent, buffer.findChild(parentStart, this.index, -1, 0, 4 /* Side.DontCare */)); } - cursor(mode = 0) { return new TreeCursor(this, mode); } get tree() { return null; } toTree() { let children = [], positions = []; @@ -4600,39 +4768,84 @@ class BufferNode { } return new Tree(this.type, children, positions, this.to - this.from); } - resolve(pos, side = 0) { - return resolveNode(this, pos, side, false); - } - resolveInner(pos, side = 0) { - return resolveNode(this, pos, side, true); - } - enterUnfinishedNodesBefore(pos) { return enterUnfinishedNodesBefore(this, pos); } - /// @internal + /** + @internal + */ toString() { return this.context.buffer.childString(this.index); } - getChild(type, before = null, after = null) { - let r = getChildren(this, type, before, after); - return r.length ? r[0] : null; +} +function iterStack(heads) { + if (!heads.length) + return null; + if (heads.length == 1) + return heads[0]; + let pick = 0, picked = heads[0]; + for (let i = 1; i < heads.length; i++) { + let node = heads[i]; + if (node.from > picked.from || node.to < picked.to) { + picked = node; + pick = i; + } + } + let next = picked instanceof TreeNode && picked.index < 0 ? null : picked.parent; + let newHeads = heads.slice(); + if (next) + newHeads[pick] = next; + else + newHeads.splice(pick, 1); + return new StackIterator(newHeads, picked); +} +class StackIterator { + constructor(heads, node) { + this.heads = heads; + this.node = node; } - getChildren(type, before = null, after = null) { - return getChildren(this, type, before, after); + get next() { return iterStack(this.heads); } +} +function stackIterator(tree, pos, side) { + let inner = tree.resolveInner(pos, side), layers = null; + for (let scan = inner instanceof TreeNode ? inner : inner.context.parent; scan; scan = scan.parent) { + if (scan.index < 0) { // This is an overlay root + let parent = scan.parent; + (layers || (layers = [inner])).push(parent.resolve(pos, side)); + scan = parent; + } + else { + let mount = MountedTree.get(scan.tree); + // Relevant overlay branching off + if (mount && mount.overlay && mount.overlay[0].from <= pos && mount.overlay[mount.overlay.length - 1].to >= pos) { + let root = new TreeNode(mount.tree, mount.overlay[0].from + scan.from, 0, null); + (layers || (layers = [inner])).push(resolveNode(root, pos, side, false)); + } + } } - get node() { return this; } - matchContext(context) { return matchNodeContext(this, context); } + return layers ? iterStack(layers) : inner; } -/// A tree cursor object focuses on a given node in a syntax tree, and -/// allows you to move to adjacent nodes. +/** +A tree cursor object focuses on a given node in a syntax tree, and +allows you to move to adjacent nodes. +*/ class TreeCursor { - /// Shorthand for `.type.name`. + /** + Shorthand for `.type.name`. + */ get name() { return this.type.name; } - /// @internal + /** + @internal + */ constructor(node, - /// @internal + /** + @internal + */ mode = 0) { this.mode = mode; - /// @internal + /** + @internal + */ this.buffer = null; this.stack = []; - /// @internal + /** + @internal + */ this.index = 0; this.bufferNode = null; if (node instanceof TreeNode) { @@ -4674,11 +4887,15 @@ class TreeCursor { this.buffer = node.context; return this.yieldBuf(node.index, node.type); } - /// @internal + /** + @internal + */ toString() { return this.buffer ? this.buffer.buffer.childString(this.index) : this._tree.toString(); } - /// @internal + /** + @internal + */ enterChild(dir, pos, side) { if (!this.buffer) return this.yield(this._tree.nextChild(dir < 0 ? this._tree._tree.children.length - 1 : 0, dir, pos, side, this.mode)); @@ -4689,26 +4906,38 @@ class TreeCursor { this.stack.push(this.index); return this.yieldBuf(index); } - /// Move the cursor to this node's first child. When this returns - /// false, the node has no child, and the cursor has not been moved. + /** + Move the cursor to this node's first child. When this returns + false, the node has no child, and the cursor has not been moved. + */ firstChild() { return this.enterChild(1, 0, 4 /* Side.DontCare */); } - /// Move the cursor to this node's last child. + /** + Move the cursor to this node's last child. + */ lastChild() { return this.enterChild(-1, 0, 4 /* Side.DontCare */); } - /// Move the cursor to the first child that ends after `pos`. + /** + Move the cursor to the first child that ends after `pos`. + */ childAfter(pos) { return this.enterChild(1, pos, 2 /* Side.After */); } - /// Move to the last child that starts before `pos`. + /** + Move to the last child that starts before `pos`. + */ childBefore(pos) { return this.enterChild(-1, pos, -2 /* Side.Before */); } - /// Move the cursor to the child around `pos`. If side is -1 the - /// child may end at that position, when 1 it may start there. This - /// will also enter [overlaid](#common.MountedTree.overlay) - /// [mounted](#common.NodeProp^mounted) trees unless `overlays` is - /// set to false. + /** + Move the cursor to the child around `pos`. If side is -1 the + child may end at that position, when 1 it may start there. This + will also enter [overlaid](#common.MountedTree.overlay) + [mounted](#common.NodeProp^mounted) trees unless `overlays` is + set to false. + */ enter(pos, side, mode = this.mode) { if (!this.buffer) return this.yield(this._tree.enter(pos, side, mode)); return mode & IterMode.ExcludeBuffers ? false : this.enterChild(1, pos, side); } - /// Move to the node's parent node, if this isn't the top node. + /** + Move to the node's parent node, if this isn't the top node. + */ parent() { if (!this.buffer) return this.yieldNode((this.mode & IterMode.IncludeAnonymous) ? this._tree._parent : this._tree.parent); @@ -4718,7 +4947,9 @@ class TreeCursor { this.buffer = null; return this.yieldNode(parent); } - /// @internal + /** + @internal + */ sibling(dir) { if (!this.buffer) return !this._tree._parent ? false @@ -4737,9 +4968,13 @@ class TreeCursor { } return d < 0 ? this.yield(this.buffer.parent.nextChild(this.buffer.index + dir, dir, 0, 4 /* Side.DontCare */, this.mode)) : false; } - /// Move to this node's next sibling, if any. + /** + Move to this node's next sibling, if any. + */ nextSibling() { return this.sibling(1); } - /// Move to this node's previous sibling, if any. + /** + Move to this node's previous sibling, if any. + */ prevSibling() { return this.sibling(-1); } atLastNode(dir) { let index, parent, { buffer } = this; @@ -4781,20 +5016,26 @@ class TreeCursor { return false; } } - /// Move to the next node in a - /// [pre-order](https://en.wikipedia.org/wiki/Tree_traversal#Pre-order,_NLR) - /// traversal, going from a node to its first child or, if the - /// current node is empty or `enter` is false, its next sibling or - /// the next sibling of the first parent node that has one. + /** + Move to the next node in a + [pre-order](https://en.wikipedia.org/wiki/Tree_traversal#Pre-order,_NLR) + traversal, going from a node to its first child or, if the + current node is empty or `enter` is false, its next sibling or + the next sibling of the first parent node that has one. + */ next(enter = true) { return this.move(1, enter); } - /// Move to the next node in a last-to-first pre-order traveral. A - /// node is followed by its last child or, if it has none, its - /// previous sibling or the previous sibling of the first parent - /// node that has one. + /** + Move to the next node in a last-to-first pre-order traveral. A + node is followed by its last child or, if it has none, its + previous sibling or the previous sibling of the first parent + node that has one. + */ prev(enter = true) { return this.move(-1, enter); } - /// Move the cursor to the innermost node that covers `pos`. If - /// `side` is -1, it will enter nodes that end at `pos`. If it is 1, - /// it will enter nodes that start at `pos`. + /** + Move the cursor to the innermost node that covers `pos`. If + `side` is -1, it will enter nodes that end at `pos`. If it is 1, + it will enter nodes that start at `pos`. + */ moveTo(pos, side = 0) { // Move up to a node that actually holds the position, if possible while (this.from == this.to || @@ -4806,8 +5047,10 @@ class TreeCursor { while (this.enterChild(1, pos, side)) { } return this; } - /// Get a [syntax node](#common.SyntaxNode) at the cursor's current - /// position. + /** + Get a [syntax node](#common.SyntaxNode) at the cursor's current + position. + */ get node() { if (!this.buffer) return this._tree; @@ -4829,16 +5072,20 @@ class TreeCursor { result = new BufferNode(this.buffer, result, this.stack[i]); return this.bufferNode = new BufferNode(this.buffer, result, this.index); } - /// Get the [tree](#common.Tree) that represents the current node, if - /// any. Will return null when the node is in a [tree - /// buffer](#common.TreeBuffer). + /** + Get the [tree](#common.Tree) that represents the current node, if + any. Will return null when the node is in a [tree + buffer](#common.TreeBuffer). + */ get tree() { return this.buffer ? null : this._tree._tree; } - /// Iterate over the current node and all its descendants, calling - /// `enter` when entering a node and `leave`, if given, when leaving - /// one. When `enter` returns `false`, any children of that node are - /// skipped, and `leave` isn't called for it. + /** + Iterate over the current node and all its descendants, calling + `enter` when entering a node and `leave`, if given, when leaving + one. When `enter` returns `false`, any children of that node are + skipped, and `leave` isn't called for it. + */ iterate(enter, leave) { for (let depth = 0;;) { let mustLeave = false; @@ -4864,9 +5111,11 @@ class TreeCursor { } } } - /// Test whether the current node matches a given context—a sequence - /// of direct parent node names. Empty strings in the context array - /// are treated as wildcards. + /** + Test whether the current node matches a given context—a sequence + of direct parent node names. Empty strings in the context array + are treated as wildcards. + */ matchContext(context) { if (!this.buffer) return matchNodeContext(this.node, context); @@ -5141,9 +5390,11 @@ mkTree) { divide(children, positions, from, to, 0); return (mkTop || mkTree)(localChildren, localPositions, length); } -/// Provides a way to associate values with pieces of trees. As long -/// as that part of the tree is reused, the associated values can be -/// retrieved from an updated tree. +/** +Provides a way to associate values with pieces of trees. As long +as that part of the tree is reused, the associated values can be +retrieved from an updated tree. +*/ class NodeWeakMap { constructor() { this.map = new WeakMap(); @@ -5158,57 +5409,77 @@ class NodeWeakMap { let inner = this.map.get(buffer); return inner && inner.get(index); } - /// Set the value for this syntax node. + /** + Set the value for this syntax node. + */ set(node, value) { if (node instanceof BufferNode) this.setBuffer(node.context.buffer, node.index, value); else if (node instanceof TreeNode) this.map.set(node.tree, value); } - /// Retrieve value for this syntax node, if it exists in the map. + /** + Retrieve value for this syntax node, if it exists in the map. + */ get(node) { return node instanceof BufferNode ? this.getBuffer(node.context.buffer, node.index) : node instanceof TreeNode ? this.map.get(node.tree) : undefined; } - /// Set the value for the node that a cursor currently points to. + /** + Set the value for the node that a cursor currently points to. + */ cursorSet(cursor, value) { if (cursor.buffer) this.setBuffer(cursor.buffer.buffer, cursor.index, value); else this.map.set(cursor.tree, value); } - /// Retrieve the value for the node that a cursor currently points - /// to. + /** + Retrieve the value for the node that a cursor currently points + to. + */ cursorGet(cursor) { return cursor.buffer ? this.getBuffer(cursor.buffer.buffer, cursor.index) : this.map.get(cursor.tree); } } -/// Tree fragments are used during [incremental -/// parsing](#common.Parser.startParse) to track parts of old trees -/// that can be reused in a new parse. An array of fragments is used -/// to track regions of an old tree whose nodes might be reused in new -/// parses. Use the static -/// [`applyChanges`](#common.TreeFragment^applyChanges) method to -/// update fragments for document changes. +/** +Tree fragments are used during [incremental +parsing](#common.Parser.startParse) to track parts of old trees +that can be reused in a new parse. An array of fragments is used +to track regions of an old tree whose nodes might be reused in new +parses. Use the static +[`applyChanges`](#common.TreeFragment^applyChanges) method to +update fragments for document changes. +*/ class TreeFragment { - /// Construct a tree fragment. You'll usually want to use - /// [`addTree`](#common.TreeFragment^addTree) and - /// [`applyChanges`](#common.TreeFragment^applyChanges) instead of - /// calling this directly. + /** + Construct a tree fragment. You'll usually want to use + [`addTree`](#common.TreeFragment^addTree) and + [`applyChanges`](#common.TreeFragment^applyChanges) instead of + calling this directly. + */ constructor( - /// The start of the unchanged range pointed to by this fragment. - /// This refers to an offset in the _updated_ document (as opposed - /// to the original tree). + /** + The start of the unchanged range pointed to by this fragment. + This refers to an offset in the _updated_ document (as opposed + to the original tree). + */ from, - /// The end of the unchanged range. + /** + The end of the unchanged range. + */ to, - /// The tree that this fragment is based on. + /** + The tree that this fragment is based on. + */ tree, - /// The offset between the fragment's tree and the document that - /// this fragment can be used against. Add this when going from - /// document to tree positions, subtract it to go from tree to - /// document positions. + /** + The offset between the fragment's tree and the document that + this fragment can be used against. Add this when going from + document to tree positions, subtract it to go from tree to + document positions. + */ offset, openStart = false, openEnd = false) { this.from = from; this.to = to; @@ -5216,20 +5487,26 @@ class TreeFragment { this.offset = offset; this.open = (openStart ? 1 /* Open.Start */ : 0) | (openEnd ? 2 /* Open.End */ : 0); } - /// Whether the start of the fragment represents the start of a - /// parse, or the end of a change. (In the second case, it may not - /// be safe to reuse some nodes at the start, depending on the - /// parsing algorithm.) + /** + Whether the start of the fragment represents the start of a + parse, or the end of a change. (In the second case, it may not + be safe to reuse some nodes at the start, depending on the + parsing algorithm.) + */ get openStart() { return (this.open & 1 /* Open.Start */) > 0; } - /// Whether the end of the fragment represents the end of a - /// full-document parse, or the start of a change. + /** + Whether the end of the fragment represents the end of a + full-document parse, or the start of a change. + */ get openEnd() { return (this.open & 2 /* Open.End */) > 0; } - /// Create a set of fragments from a freshly parsed tree, or update - /// an existing set of fragments by replacing the ones that overlap - /// with a tree with content from the new tree. When `partial` is - /// true, the parse is treated as incomplete, and the resulting - /// fragment has [`openEnd`](#common.TreeFragment.openEnd) set to - /// true. + /** + Create a set of fragments from a freshly parsed tree, or update + an existing set of fragments by replacing the ones that overlap + with a tree with content from the new tree. When `partial` is + true, the parse is treated as incomplete, and the resulting + fragment has [`openEnd`](#common.TreeFragment.openEnd) set to + true. + */ static addTree(tree, fragments = [], partial = false) { let result = [new TreeFragment(0, tree.length, tree, 0, false, partial)]; for (let f of fragments) @@ -5237,9 +5514,11 @@ class TreeFragment { result.push(f); return result; } - /// Apply a set of edits to an array of fragments, removing or - /// splitting fragments as necessary to remove edited ranges, and - /// adjusting offsets for fragments that moved. + /** + Apply a set of edits to an array of fragments, removing or + splitting fragments as necessary to remove edited ranges, and + adjusting offsets for fragments that moved. + */ static applyChanges(fragments, changes, minGap = 128) { if (!changes.length) return fragments; @@ -5269,23 +5548,29 @@ class TreeFragment { return result; } } -/// A superclass that parsers should extend. +/** +A superclass that parsers should extend. +*/ class Parser { - /// Start a parse, returning a [partial parse](#common.PartialParse) - /// object. [`fragments`](#common.TreeFragment) can be passed in to - /// make the parse incremental. - /// - /// By default, the entire input is parsed. You can pass `ranges`, - /// which should be a sorted array of non-empty, non-overlapping - /// ranges, to parse only those ranges. The tree returned in that - /// case will start at `ranges[0].from`. + /** + Start a parse, returning a [partial parse](#common.PartialParse) + object. [`fragments`](#common.TreeFragment) can be passed in to + make the parse incremental. + + By default, the entire input is parsed. You can pass `ranges`, + which should be a sorted array of non-empty, non-overlapping + ranges, to parse only those ranges. The tree returned in that + case will start at `ranges[0].from`. + */ startParse(input, fragments, ranges) { if (typeof input == "string") input = new StringInput(input); ranges = !ranges ? [new Range(0, input.length)] : ranges.length ? ranges.map(r => new Range(r.from, r.to)) : [new Range(0, 0)]; return this.createParse(input, fragments || [], ranges); } - /// Run a full parse, returning the resulting tree. + /** + Run a full parse, returning the resulting tree. + */ parse(input, fragments, ranges) { let parse = this.startParse(input, fragments, ranges); for (;;) { @@ -5305,11 +5590,13 @@ class StringInput { read(from, to) { return this.string.slice(from, to); } } -/// Create a parse wrapper that, after the inner parse completes, -/// scans its tree for mixed language regions with the `nest` -/// function, runs the resulting [inner parses](#common.NestedParse), -/// and then [mounts](#common.NodeProp^mounted) their results onto the -/// tree. +/** +Create a parse wrapper that, after the inner parse completes, +scans its tree for mixed language regions with the `nest` +function, runs the resulting [inner parses](#common.NestedParse), +and then [mounts](#common.NodeProp^mounted) their results onto the +tree. +*/ function parseMixed(nest) { return (parse, input, fragments, ranges) => new MixedParse(parse, nest, input, fragments, ranges); } @@ -5320,6 +5607,8 @@ class InnerParse { this.overlay = overlay; this.target = target; this.ranges = ranges; + if (!ranges.length || ranges.some(r => r.from >= r.to)) + throw new RangeError("Invalid inner parse ranges given: " + JSON.stringify(ranges)); } } class ActiveOverlay { @@ -5699,53 +5988,79 @@ function enterFragments(mounts, ranges) { return result; } -/// A parse stack. These are used internally by the parser to track -/// parsing progress. They also provide some properties and methods -/// that external code such as a tokenizer can use to get information -/// about the parse state. +/** +A parse stack. These are used internally by the parser to track +parsing progress. They also provide some properties and methods +that external code such as a tokenizer can use to get information +about the parse state. +*/ class Stack { - /// @internal + /** + @internal + */ constructor( - /// The parse that this stack is part of @internal + /** + The parse that this stack is part of @internal + */ p, - /// Holds state, input pos, buffer index triplets for all but the - /// top state @internal + /** + Holds state, input pos, buffer index triplets for all but the + top state @internal + */ stack, - /// The current parse state @internal + /** + The current parse state @internal + */ state, // The position at which the next reduce should take place. This // can be less than `this.pos` when skipped expressions have been // added to the stack (which should be moved outside of the next // reduction) - /// @internal + /** + @internal + */ reducePos, - /// The input position up to which this stack has parsed. + /** + The input position up to which this stack has parsed. + */ pos, - /// The dynamic score of the stack, including dynamic precedence - /// and error-recovery penalties - /// @internal + /** + The dynamic score of the stack, including dynamic precedence + and error-recovery penalties + @internal + */ score, // The output buffer. Holds (type, start, end, size) quads // representing nodes created by the parser, where `size` is // amount of buffer array entries covered by this node. - /// @internal + /** + @internal + */ buffer, // The base offset of the buffer. When stacks are split, the split // instance shared the buffer history with its parent up to // `bufferBase`, which is the absolute offset (including the // offset of previous splits) into the buffer at which this stack // starts writing. - /// @internal + /** + @internal + */ bufferBase, - /// @internal + /** + @internal + */ curContext, - /// @internal + /** + @internal + */ lookAhead = 0, // A parent stack from which this was split off, if any. This is // set up so that it always points to a stack that has some // additional buffer content, never to a stack with an equal // `bufferBase`. - /// @internal + /** + @internal + */ parent) { this.p = p; this.stack = stack; @@ -5759,32 +6074,43 @@ class Stack { this.lookAhead = lookAhead; this.parent = parent; } - /// @internal + /** + @internal + */ toString() { return `[${this.stack.filter((_, i) => i % 3 == 0).concat(this.state)}]@${this.pos}${this.score ? "!" + this.score : ""}`; } // Start an empty stack - /// @internal + /** + @internal + */ static start(p, state, pos = 0) { let cx = p.parser.context; return new Stack(p, [], state, pos, pos, 0, [], 0, cx ? new StackContext(cx, cx.start) : null, 0, null); } - /// The stack's current [context](#lr.ContextTracker) value, if - /// any. Its type will depend on the context tracker's type - /// parameter, or it will be `null` if there is no context - /// tracker. + /** + The stack's current [context](#lr.ContextTracker) value, if + any. Its type will depend on the context tracker's type + parameter, or it will be `null` if there is no context + tracker. + */ get context() { return this.curContext ? this.curContext.context : null; } // Push a state onto the stack, tracking its start position as well // as the buffer base at that point. - /// @internal + /** + @internal + */ pushState(state, start) { this.stack.push(this.state, start, this.bufferBase + this.buffer.length); this.state = state; } // Apply a reduce action - /// @internal + /** + @internal + */ reduce(action) { - let depth = action >> 19 /* ReduceDepthShift */, type = action & 65535 /* ValueMask */; + var _a; + let depth = action >> 19 /* Action.ReduceDepthShift */, type = action & 65535 /* Action.ValueMask */; let { parser } = this.p; let dPrec = parser.dynamicPrecedence(type); if (dPrec) @@ -5803,15 +6129,29 @@ class Stack { // consume two extra frames (the dummy parent node for the skipped // expression and the state that we'll be staying in, which should // be moved to `this.state`). - let base = this.stack.length - ((depth - 1) * 3) - (action & 262144 /* StayFlag */ ? 6 : 0); - let start = this.stack[base - 2]; - let bufferBase = this.stack[base - 1], count = this.bufferBase + this.buffer.length - bufferBase; + let base = this.stack.length - ((depth - 1) * 3) - (action & 262144 /* Action.StayFlag */ ? 6 : 0); + let start = base ? this.stack[base - 2] : this.p.ranges[0].from, size = this.reducePos - start; + // This is a kludge to try and detect overly deep left-associative + // trees, which will not increase the parse stack depth and thus + // won't be caught by the regular stack-depth limit check. + if (size >= 2000 /* Recover.MinBigReduction */ && !((_a = this.p.parser.nodeSet.types[type]) === null || _a === void 0 ? void 0 : _a.isAnonymous)) { + if (start == this.p.lastBigReductionStart) { + this.p.bigReductionCount++; + this.p.lastBigReductionSize = size; + } + else if (this.p.lastBigReductionSize < size) { + this.p.bigReductionCount = 1; + this.p.lastBigReductionStart = start; + this.p.lastBigReductionSize = size; + } + } + let bufferBase = base ? this.stack[base - 1] : 0, count = this.bufferBase + this.buffer.length - bufferBase; // Store normal terms or `R -> R R` repeat reductions - if (type < parser.minRepeatTerm || (action & 131072 /* RepeatFlag */)) { - let pos = parser.stateFlag(this.state, 1 /* Skipped */) ? this.pos : this.reducePos; + if (type < parser.minRepeatTerm || (action & 131072 /* Action.RepeatFlag */)) { + let pos = parser.stateFlag(this.state, 1 /* StateFlag.Skipped */) ? this.pos : this.reducePos; this.storeNode(type, start, pos, count + 4, true); } - if (action & 262144 /* StayFlag */) { + if (action & 262144 /* Action.StayFlag */) { this.state = this.stack[base]; } else { @@ -5823,9 +6163,11 @@ class Stack { this.reduceContext(type, start); } // Shift a value into the buffer - /// @internal + /** + @internal + */ storeNode(term, start, end, size = 4, isReduce = false) { - if (term == 0 /* Err */ && + if (term == 0 /* Term.Err */ && (!this.stack.length || this.stack[this.stack.length - 1] < this.buffer.length + this.bufferBase)) { // Try to omit/merge adjacent error nodes let cur = this, top = this.buffer.length; @@ -5833,7 +6175,7 @@ class Stack { top = cur.bufferBase - cur.parent.bufferBase; cur = cur.parent; } - if (top > 0 && cur.buffer[top - 4] == 0 /* Err */ && cur.buffer[top - 1] > -1) { + if (top > 0 && cur.buffer[top - 4] == 0 /* Term.Err */ && cur.buffer[top - 1] > -1) { if (start == end) return; if (cur.buffer[top - 2] >= start) { @@ -5847,7 +6189,7 @@ class Stack { } else { // There may be skipped nodes that have to be moved forward let index = this.buffer.length; - if (index > 0 && this.buffer[index - 4] != 0 /* Err */) + if (index > 0 && this.buffer[index - 4] != 0 /* Term.Err */) while (index > 0 && this.buffer[index - 2] > end) { // Move this record forward this.buffer[index] = this.buffer[index - 4]; @@ -5865,41 +6207,46 @@ class Stack { } } // Apply a shift action - /// @internal - shift(action, next, nextEnd) { - let start = this.pos; - if (action & 131072 /* GotoFlag */) { - this.pushState(action & 65535 /* ValueMask */, this.pos); + /** + @internal + */ + shift(action, type, start, end) { + if (action & 131072 /* Action.GotoFlag */) { + this.pushState(action & 65535 /* Action.ValueMask */, this.pos); } - else if ((action & 262144 /* StayFlag */) == 0) { // Regular shift + else if ((action & 262144 /* Action.StayFlag */) == 0) { // Regular shift let nextState = action, { parser } = this.p; - if (nextEnd > this.pos || next <= parser.maxNode) { - this.pos = nextEnd; - if (!parser.stateFlag(nextState, 1 /* Skipped */)) - this.reducePos = nextEnd; + if (end > this.pos || type <= parser.maxNode) { + this.pos = end; + if (!parser.stateFlag(nextState, 1 /* StateFlag.Skipped */)) + this.reducePos = end; } this.pushState(nextState, start); - this.shiftContext(next, start); - if (next <= parser.maxNode) - this.buffer.push(next, start, nextEnd, 4); + this.shiftContext(type, start); + if (type <= parser.maxNode) + this.buffer.push(type, start, end, 4); } else { // Shift-and-stay, which means this is a skipped token - this.pos = nextEnd; - this.shiftContext(next, start); - if (next <= this.p.parser.maxNode) - this.buffer.push(next, start, nextEnd, 4); + this.pos = end; + this.shiftContext(type, start); + if (type <= this.p.parser.maxNode) + this.buffer.push(type, start, end, 4); } } // Apply an action - /// @internal - apply(action, next, nextEnd) { - if (action & 65536 /* ReduceFlag */) + /** + @internal + */ + apply(action, next, nextStart, nextEnd) { + if (action & 65536 /* Action.ReduceFlag */) this.reduce(action); else - this.shift(action, next, nextEnd); + this.shift(action, next, nextStart, nextEnd); } // Add a prebuilt (reused) node into the buffer. - /// @internal + /** + @internal + */ useNode(value, next) { let index = this.p.reused.length - 1; if (index < 0 || this.p.reused[index] != value) { @@ -5916,7 +6263,9 @@ class Stack { // Split the stack. Due to the buffer sharing and the fact // that `this.stack` tends to stay quite shallow, this isn't very // expensive. - /// @internal + /** + @internal + */ split() { let parent = this; let off = parent.buffer.length; @@ -5933,44 +6282,50 @@ class Stack { return new Stack(this.p, this.stack.slice(), this.state, this.reducePos, this.pos, this.score, buffer, base, this.curContext, this.lookAhead, parent); } // Try to recover from an error by 'deleting' (ignoring) one token. - /// @internal + /** + @internal + */ recoverByDelete(next, nextEnd) { let isNode = next <= this.p.parser.maxNode; if (isNode) this.storeNode(next, this.pos, nextEnd, 4); - this.storeNode(0 /* Err */, this.pos, nextEnd, isNode ? 8 : 4); + this.storeNode(0 /* Term.Err */, this.pos, nextEnd, isNode ? 8 : 4); this.pos = this.reducePos = nextEnd; - this.score -= 190 /* Delete */; + this.score -= 190 /* Recover.Delete */; } - /// Check if the given term would be able to be shifted (optionally - /// after some reductions) on this stack. This can be useful for - /// external tokenizers that want to make sure they only provide a - /// given token when it applies. + /** + Check if the given term would be able to be shifted (optionally + after some reductions) on this stack. This can be useful for + external tokenizers that want to make sure they only provide a + given token when it applies. + */ canShift(term) { for (let sim = new SimulatedStack(this);;) { - let action = this.p.parser.stateSlot(sim.state, 4 /* DefaultReduce */) || this.p.parser.hasAction(sim.state, term); - if ((action & 65536 /* ReduceFlag */) == 0) - return true; + let action = this.p.parser.stateSlot(sim.state, 4 /* ParseState.DefaultReduce */) || this.p.parser.hasAction(sim.state, term); if (action == 0) return false; + if ((action & 65536 /* Action.ReduceFlag */) == 0) + return true; sim.reduce(action); } } // Apply up to Recover.MaxNext recovery actions that conceptually // inserts some missing token or rule. - /// @internal + /** + @internal + */ recoverByInsert(next) { - if (this.stack.length >= 300 /* MaxInsertStackDepth */) + if (this.stack.length >= 300 /* Recover.MaxInsertStackDepth */) return []; let nextStates = this.p.parser.nextStates(this.state); - if (nextStates.length > 4 /* MaxNext */ << 1 || this.stack.length >= 120 /* DampenInsertStackDepth */) { + if (nextStates.length > 4 /* Recover.MaxNext */ << 1 || this.stack.length >= 120 /* Recover.DampenInsertStackDepth */) { let best = []; for (let i = 0, s; i < nextStates.length; i += 2) { if ((s = nextStates[i + 1]) != this.state && this.p.parser.hasAction(s, next)) best.push(nextStates[i], s); } - if (this.stack.length < 120 /* DampenInsertStackDepth */) - for (let i = 0; best.length < 4 /* MaxNext */ << 1 && i < nextStates.length; i += 2) { + if (this.stack.length < 120 /* Recover.DampenInsertStackDepth */) + for (let i = 0; best.length < 4 /* Recover.MaxNext */ << 1 && i < nextStates.length; i += 2) { let s = nextStates[i + 1]; if (!best.some((v, i) => (i & 1) && v == s)) best.push(nextStates[i], s); @@ -5978,79 +6333,129 @@ class Stack { nextStates = best; } let result = []; - for (let i = 0; i < nextStates.length && result.length < 4 /* MaxNext */; i += 2) { + for (let i = 0; i < nextStates.length && result.length < 4 /* Recover.MaxNext */; i += 2) { let s = nextStates[i + 1]; if (s == this.state) continue; let stack = this.split(); stack.pushState(s, this.pos); - stack.storeNode(0 /* Err */, stack.pos, stack.pos, 4, true); + stack.storeNode(0 /* Term.Err */, stack.pos, stack.pos, 4, true); stack.shiftContext(nextStates[i], this.pos); - stack.score -= 200 /* Insert */; + stack.reducePos = this.pos; + stack.score -= 200 /* Recover.Insert */; result.push(stack); } return result; } // Force a reduce, if possible. Return false if that can't // be done. - /// @internal + /** + @internal + */ forceReduce() { - let reduce = this.p.parser.stateSlot(this.state, 5 /* ForcedReduce */); - if ((reduce & 65536 /* ReduceFlag */) == 0) - return false; let { parser } = this.p; + let reduce = parser.stateSlot(this.state, 5 /* ParseState.ForcedReduce */); + if ((reduce & 65536 /* Action.ReduceFlag */) == 0) + return false; if (!parser.validAction(this.state, reduce)) { - let depth = reduce >> 19 /* ReduceDepthShift */, term = reduce & 65535 /* ValueMask */; + let depth = reduce >> 19 /* Action.ReduceDepthShift */, term = reduce & 65535 /* Action.ValueMask */; let target = this.stack.length - depth * 3; - if (target < 0 || parser.getGoto(this.stack[target], term, false) < 0) - return false; - this.storeNode(0 /* Err */, this.reducePos, this.reducePos, 4, true); - this.score -= 100 /* Reduce */; + if (target < 0 || parser.getGoto(this.stack[target], term, false) < 0) { + let backup = this.findForcedReduction(); + if (backup == null) + return false; + reduce = backup; + } + this.storeNode(0 /* Term.Err */, this.pos, this.pos, 4, true); + this.score -= 100 /* Recover.Reduce */; } this.reducePos = this.pos; this.reduce(reduce); return true; } - /// @internal + /** + Try to scan through the automaton to find some kind of reduction + that can be applied. Used when the regular ForcedReduce field + isn't a valid action. @internal + */ + findForcedReduction() { + let { parser } = this.p, seen = []; + let explore = (state, depth) => { + if (seen.includes(state)) + return; + seen.push(state); + return parser.allActions(state, (action) => { + if (action & (262144 /* Action.StayFlag */ | 131072 /* Action.GotoFlag */)) ; + else if (action & 65536 /* Action.ReduceFlag */) { + let rDepth = (action >> 19 /* Action.ReduceDepthShift */) - depth; + if (rDepth > 1) { + let term = action & 65535 /* Action.ValueMask */, target = this.stack.length - rDepth * 3; + if (target >= 0 && parser.getGoto(this.stack[target], term, false) >= 0) + return (rDepth << 19 /* Action.ReduceDepthShift */) | 65536 /* Action.ReduceFlag */ | term; + } + } + else { + let found = explore(action, depth + 1); + if (found != null) + return found; + } + }); + }; + return explore(this.state, 0); + } + /** + @internal + */ forceAll() { - while (!this.p.parser.stateFlag(this.state, 2 /* Accepting */)) { + while (!this.p.parser.stateFlag(this.state, 2 /* StateFlag.Accepting */)) { if (!this.forceReduce()) { - this.storeNode(0 /* Err */, this.pos, this.pos, 4, true); + this.storeNode(0 /* Term.Err */, this.pos, this.pos, 4, true); break; } } return this; } - /// Check whether this state has no further actions (assumed to be a direct descendant of the - /// top state, since any other states must be able to continue - /// somehow). @internal + /** + Check whether this state has no further actions (assumed to be a direct descendant of the + top state, since any other states must be able to continue + somehow). @internal + */ get deadEnd() { if (this.stack.length != 3) return false; let { parser } = this.p; - return parser.data[parser.stateSlot(this.state, 1 /* Actions */)] == 65535 /* End */ && - !parser.stateSlot(this.state, 4 /* DefaultReduce */); + return parser.data[parser.stateSlot(this.state, 1 /* ParseState.Actions */)] == 65535 /* Seq.End */ && + !parser.stateSlot(this.state, 4 /* ParseState.DefaultReduce */); } - /// Restart the stack (put it back in its start state). Only safe - /// when this.stack.length == 3 (state is directly below the top - /// state). @internal + /** + Restart the stack (put it back in its start state). Only safe + when this.stack.length == 3 (state is directly below the top + state). @internal + */ restart() { + this.storeNode(0 /* Term.Err */, this.pos, this.pos, 4, true); this.state = this.stack[0]; this.stack.length = 0; } - /// @internal - sameState(other) { - if (this.state != other.state || this.stack.length != other.stack.length) + /** + @internal + */ + sameState(other) { + if (this.state != other.state || this.stack.length != other.stack.length) return false; for (let i = 0; i < this.stack.length; i += 3) if (this.stack[i] != other.stack[i]) return false; return true; } - /// Get the parser used by this stack. + /** + Get the parser used by this stack. + */ get parser() { return this.p.parser; } - /// Test whether a given dialect (by numeric ID, as exported from - /// the terms file) is enabled. + /** + Test whether a given dialect (by numeric ID, as exported from + the terms file) is enabled. + */ dialectEnabled(dialectID) { return this.p.parser.dialect.flags[dialectID]; } shiftContext(term, start) { if (this.curContext) @@ -6060,17 +6465,21 @@ class Stack { if (this.curContext) this.updateContext(this.curContext.tracker.reduce(this.curContext.context, term, this, this.p.stream.reset(start))); } - /// @internal + /** + @internal + */ emitContext() { let last = this.buffer.length - 1; if (last < 0 || this.buffer[last] != -3) - this.buffer.push(this.curContext.hash, this.reducePos, this.reducePos, -3); + this.buffer.push(this.curContext.hash, this.pos, this.pos, -3); } - /// @internal + /** + @internal + */ emitLookAhead() { let last = this.buffer.length - 1; if (last < 0 || this.buffer[last] != -4) - this.buffer.push(this.lookAhead, this.reducePos, this.reducePos, -4); + this.buffer.push(this.lookAhead, this.pos, this.pos, -4); } updateContext(context) { if (context != this.curContext.context) { @@ -6080,14 +6489,18 @@ class Stack { this.curContext = newCx; } } - /// @internal + /** + @internal + */ setLookAhead(lookAhead) { if (lookAhead > this.lookAhead) { this.emitLookAhead(); this.lookAhead = lookAhead; } } - /// @internal + /** + @internal + */ close() { if (this.curContext && this.curContext.tracker.strict) this.emitContext(); @@ -6102,15 +6515,6 @@ class StackContext { this.hash = tracker.strict ? tracker.hash(context) : 0; } } -var Recover; -(function (Recover) { - Recover[Recover["Insert"] = 200] = "Insert"; - Recover[Recover["Delete"] = 190] = "Delete"; - Recover[Recover["Reduce"] = 100] = "Reduce"; - Recover[Recover["MaxNext"] = 4] = "MaxNext"; - Recover[Recover["MaxInsertStackDepth"] = 300] = "MaxInsertStackDepth"; - Recover[Recover["DampenInsertStackDepth"] = 120] = "DampenInsertStackDepth"; -})(Recover || (Recover = {})); // Used to cheaply run some reductions to scan ahead without mutating // an entire stack class SimulatedStack { @@ -6121,7 +6525,7 @@ class SimulatedStack { this.base = this.stack.length; } reduce(action) { - let term = action & 65535 /* ValueMask */, depth = action >> 19 /* ReduceDepthShift */; + let term = action & 65535 /* Action.ValueMask */, depth = action >> 19 /* Action.ReduceDepthShift */; if (depth == 0) { if (this.stack == this.start.stack) this.stack = this.stack.slice(); @@ -6172,6 +6576,42 @@ class StackBufferCursor { } } +// See lezer-generator/src/encode.ts for comments about the encoding +// used here +function decodeArray(input, Type = Uint16Array) { + if (typeof input != "string") + return input; + let array = null; + for (let pos = 0, out = 0; pos < input.length;) { + let value = 0; + for (;;) { + let next = input.charCodeAt(pos++), stop = false; + if (next == 126 /* Encode.BigValCode */) { + value = 65535 /* Encode.BigVal */; + break; + } + if (next >= 92 /* Encode.Gap2 */) + next--; + if (next >= 34 /* Encode.Gap1 */) + next--; + let digit = next - 32 /* Encode.Start */; + if (digit >= 46 /* Encode.Base */) { + digit -= 46 /* Encode.Base */; + stop = true; + } + value += digit; + if (stop) + break; + value *= 46 /* Encode.Base */; + } + if (array) + array[out++] = value; + else + array = new Type(value); + } + return array; +} + class CachedToken { constructor() { this.start = -1; @@ -6184,30 +6624,48 @@ class CachedToken { } } const nullToken = new CachedToken; -/// [Tokenizers](#lr.ExternalTokenizer) interact with the input -/// through this interface. It presents the input as a stream of -/// characters, tracking lookahead and hiding the complexity of -/// [ranges](#common.Parser.parse^ranges) from tokenizer code. +/** +[Tokenizers](#lr.ExternalTokenizer) interact with the input +through this interface. It presents the input as a stream of +characters, tracking lookahead and hiding the complexity of +[ranges](#common.Parser.parse^ranges) from tokenizer code. +*/ class InputStream { - /// @internal + /** + @internal + */ constructor( - /// @internal + /** + @internal + */ input, - /// @internal + /** + @internal + */ ranges) { this.input = input; this.ranges = ranges; - /// @internal + /** + @internal + */ this.chunk = ""; - /// @internal + /** + @internal + */ this.chunkOff = 0; - /// Backup chunk + /** + Backup chunk + */ this.chunk2 = ""; this.chunk2Pos = 0; - /// The character code of the next code unit in the input, or -1 - /// when the stream is at the end of the input. + /** + The character code of the next code unit in the input, or -1 + when the stream is at the end of the input. + */ this.next = -1; - /// @internal + /** + @internal + */ this.token = nullToken; this.rangeIndex = 0; this.pos = this.chunkPos = ranges[0].from; @@ -6215,7 +6673,9 @@ class InputStream { this.end = ranges[ranges.length - 1].to; this.readNext(); } - /// @internal + /** + @internal + */ resolveOffset(offset, assoc) { let range = this.range, index = this.rangeIndex; let pos = this.pos + offset; @@ -6235,7 +6695,9 @@ class InputStream { } return pos; } - /// @internal + /** + @internal + */ clipPos(pos) { if (pos >= this.range.from && pos < this.range.to) return pos; @@ -6244,15 +6706,17 @@ class InputStream { return Math.max(pos, range.from); return this.end; } - /// Look at a code unit near the stream position. `.peek(0)` equals - /// `.next`, `.peek(-1)` gives you the previous character, and so - /// on. - /// - /// Note that looking around during tokenizing creates dependencies - /// on potentially far-away content, which may reduce the - /// effectiveness incremental parsing—when looking forward—or even - /// cause invalid reparses when looking backward more than 25 code - /// units, since the library does not track lookbehind. + /** + Look at a code unit near the stream position. `.peek(0)` equals + `.next`, `.peek(-1)` gives you the previous character, and so + on. + + Note that looking around during tokenizing creates dependencies + on potentially far-away content, which may reduce the + effectiveness incremental parsing—when looking forward—or even + cause invalid reparses when looking backward more than 25 code + units, since the library does not track lookbehind. + */ peek(offset) { let idx = this.chunkOff + offset, pos, result; if (idx >= 0 && idx < this.chunk.length) { @@ -6281,9 +6745,11 @@ class InputStream { this.token.lookAhead = pos + 1; return result; } - /// Accept a token. By default, the end of the token is set to the - /// current stream position, but you can pass an offset (relative to - /// the stream position) to change that. + /** + Accept a token. By default, the end of the token is set to the + current stream position, but you can pass an offset (relative to + the stream position) to change that. + */ acceptToken(token, endOffset = 0) { let end = endOffset ? this.resolveOffset(endOffset, -1) : this.pos; if (end == null || end < this.token.start) @@ -6318,8 +6784,10 @@ class InputStream { } return this.next = this.chunk.charCodeAt(this.chunkOff); } - /// Move the stream forward N (defaults to 1) code units. Returns - /// the new value of [`next`](#lr.InputStream.next). + /** + Move the stream forward N (defaults to 1) code units. Returns + the new value of [`next`](#lr.InputStream.next). + */ advance(n = 1) { this.chunkOff += n; while (this.pos + n >= this.range.to) { @@ -6340,7 +6808,9 @@ class InputStream { this.chunk = ""; return this.next = -1; } - /// @internal + /** + @internal + */ reset(pos, token) { if (token) { this.token = token; @@ -6372,7 +6842,9 @@ class InputStream { } return this; } - /// @internal + /** + @internal + */ read(from, to) { if (from >= this.chunkPos && to <= this.chunkPos + this.chunk.length) return this.chunk.slice(from - this.chunkPos, to - this.chunkPos); @@ -6390,25 +6862,67 @@ class InputStream { return result; } } -/// @internal +/** +@internal +*/ class TokenGroup { constructor(data, id) { this.data = data; this.id = id; } - token(input, stack) { readToken(this.data, input, stack, this.id); } + token(input, stack) { + let { parser } = stack.p; + readToken(this.data, input, stack, this.id, parser.data, parser.tokenPrecTable); + } } TokenGroup.prototype.contextual = TokenGroup.prototype.fallback = TokenGroup.prototype.extend = false; -/// `@external tokens` declarations in the grammar should resolve to -/// an instance of this class. +/** +@hide +*/ +class LocalTokenGroup { + constructor(data, precTable, elseToken) { + this.precTable = precTable; + this.elseToken = elseToken; + this.data = typeof data == "string" ? decodeArray(data) : data; + } + token(input, stack) { + let start = input.pos, skipped = 0; + for (;;) { + let atEof = input.next < 0, nextPos = input.resolveOffset(1, 1); + readToken(this.data, input, stack, 0, this.data, this.precTable); + if (input.token.value > -1) + break; + if (this.elseToken == null) + return; + if (!atEof) + skipped++; + if (nextPos == null) + break; + input.reset(nextPos, input.token); + } + if (skipped) { + input.reset(start, input.token); + input.acceptToken(this.elseToken, skipped); + } + } +} +LocalTokenGroup.prototype.contextual = TokenGroup.prototype.fallback = TokenGroup.prototype.extend = false; +/** +`@external tokens` declarations in the grammar should resolve to +an instance of this class. +*/ class ExternalTokenizer { - /// Create a tokenizer. The first argument is the function that, - /// given an input stream, scans for the types of tokens it - /// recognizes at the stream's position, and calls - /// [`acceptToken`](#lr.InputStream.acceptToken) when it finds - /// one. + /** + Create a tokenizer. The first argument is the function that, + given an input stream, scans for the types of tokens it + recognizes at the stream's position, and calls + [`acceptToken`](#lr.InputStream.acceptToken) when it finds + one. + */ constructor( - /// @internal + /** + @internal + */ token, options = {}) { this.token = token; this.contextual = !!options.contextual; @@ -6436,8 +6950,8 @@ class ExternalTokenizer { // This function interprets that data, running through a stream as // long as new states with the a matching group mask can be reached, // and updating `input.token` when it matches a token. -function readToken(data, input, stack, group) { - let state = 0, groupMask = 1 << group, { parser } = stack.p, { dialect } = parser; +function readToken(data, input, stack, group, precTable, precOffset) { + let state = 0, groupMask = 1 << group, { dialect } = stack.p.parser; scan: for (;;) { if ((groupMask & data[state]) == 0) break; @@ -6449,14 +6963,15 @@ function readToken(data, input, stack, group) { if ((data[i + 1] & groupMask) > 0) { let term = data[i]; if (dialect.allows(term) && - (input.token.value == -1 || input.token.value == term || parser.overrides(term, input.token.value))) { + (input.token.value == -1 || input.token.value == term || + overrides(term, input.token.value, precTable, precOffset))) { input.acceptToken(term); break; } } let next = input.next, low = 0, high = data[state + 2]; // Special case for EOF - if (input.next < 0 && high > low && data[accEnd + high * 3 - 3] == 65535 /* End */ && data[accEnd + high * 3 - 3] == 65535 /* End */) { + if (input.next < 0 && high > low && data[accEnd + high * 3 - 3] == 65535 /* Seq.End */ && data[accEnd + high * 3 - 3] == 65535 /* Seq.End */) { state = data[accEnd + high * 3 - 1]; continue scan; } @@ -6478,50 +6993,20 @@ function readToken(data, input, stack, group) { break; } } - -// See lezer-generator/src/encode.ts for comments about the encoding -// used here -function decodeArray(input, Type = Uint16Array) { - if (typeof input != "string") - return input; - let array = null; - for (let pos = 0, out = 0; pos < input.length;) { - let value = 0; - for (;;) { - let next = input.charCodeAt(pos++), stop = false; - if (next == 126 /* BigValCode */) { - value = 65535 /* BigVal */; - break; - } - if (next >= 92 /* Gap2 */) - next--; - if (next >= 34 /* Gap1 */) - next--; - let digit = next - 32 /* Start */; - if (digit >= 46 /* Base */) { - digit -= 46 /* Base */; - stop = true; - } - value += digit; - if (stop) - break; - value *= 46 /* Base */; - } - if (array) - array[out++] = value; - else - array = new Type(value); - } - return array; +function findOffset(data, start, term) { + for (let i = start, next; (next = data[i]) != 65535 /* Seq.End */; i++) + if (next == term) + return i - start; + return -1; +} +function overrides(token, prev, tableData, tableOffset) { + let iPrev = findOffset(tableData, tableOffset, prev); + return iPrev < 0 || findOffset(tableData, tableOffset, token) < iPrev; } // Environment variable used to control console output const verbose = typeof process != "undefined" && process.env && /\bparse\b/.test(process.env.LOG); let stackIDs = null; -var Safety; -(function (Safety) { - Safety[Safety["Margin"] = 25] = "Margin"; -})(Safety || (Safety = {})); function cutAt(tree, pos, side) { let cursor = tree.cursor(IterMode.IncludeAnonymous); cursor.moveTo(pos); @@ -6529,8 +7014,8 @@ function cutAt(tree, pos, side) { if (!(side < 0 ? cursor.childBefore(pos) : cursor.childAfter(pos))) for (;;) { if ((side < 0 ? cursor.to < pos : cursor.from > pos) && !cursor.type.isError) - return side < 0 ? Math.max(0, Math.min(cursor.to - 1, pos - 25 /* Margin */)) - : Math.min(tree.length, Math.max(cursor.from + 1, pos + 25 /* Margin */)); + return side < 0 ? Math.max(0, Math.min(cursor.to - 1, pos - 25 /* Safety.Margin */)) + : Math.min(tree.length, Math.max(cursor.from + 1, pos + 25 /* Safety.Margin */)); if (side < 0 ? cursor.prevSibling() : cursor.nextSibling()) break; if (!cursor.parent()) @@ -6634,7 +7119,7 @@ class TokenCache { let actionIndex = 0; let main = null; let { parser } = stack.p, { tokenizers } = parser; - let mask = parser.stateSlot(stack.state, 3 /* TokenizerMask */); + let mask = parser.stateSlot(stack.state, 3 /* ParseState.TokenizerMask */); let context = stack.curContext ? stack.curContext.hash : 0; let lookAhead = 0; for (let i = 0; i < tokenizers.length; i++) { @@ -6648,9 +7133,9 @@ class TokenCache { token.mask = mask; token.context = context; } - if (token.lookAhead > token.end + 25 /* Margin */) + if (token.lookAhead > token.end + 25 /* Safety.Margin */) lookAhead = Math.max(token.lookAhead, lookAhead); - if (token.value != 0 /* Err */) { + if (token.value != 0 /* Term.Err */) { let startIndex = actionIndex; if (token.extended > -1) actionIndex = this.addActions(stack, token.extended, token.end, actionIndex); @@ -6681,7 +7166,7 @@ class TokenCache { let main = new CachedToken, { pos, p } = stack; main.start = pos; main.end = Math.min(pos + 1, p.stream.end); - main.value = pos == p.stream.end ? p.parser.eofTerm : 0 /* Err */; + main.value = pos == p.stream.end ? p.parser.eofTerm : 0 /* Term.Err */; return main; } updateCachedToken(token, tokenizer, stack) { @@ -6693,7 +7178,7 @@ class TokenCache { if (parser.specialized[i] == token.value) { let result = parser.specializers[i](this.stream.read(token.start, token.end), stack); if (result >= 0 && stack.p.parser.dialect.allows(result >> 1)) { - if ((result & 1) == 0 /* Specialize */) + if ((result & 1) == 0 /* Specialize.Specialize */) token.value = result >> 1; else token.extended = result >> 1; @@ -6702,7 +7187,7 @@ class TokenCache { } } else { - token.value = 0 /* Err */; + token.value = 0 /* Term.Err */; token.end = this.stream.clipPos(start + 1); } } @@ -6719,13 +7204,13 @@ class TokenCache { addActions(stack, token, end, index) { let { state } = stack, { parser } = stack.p, { data } = parser; for (let set = 0; set < 2; set++) { - for (let i = parser.stateSlot(state, set ? 2 /* Skip */ : 1 /* Actions */);; i += 3) { - if (data[i] == 65535 /* End */) { - if (data[i + 1] == 1 /* Next */) { + for (let i = parser.stateSlot(state, set ? 2 /* ParseState.Skip */ : 1 /* ParseState.Actions */);; i += 3) { + if (data[i] == 65535 /* Seq.End */) { + if (data[i + 1] == 1 /* Seq.Next */) { i = pair(data, i + 2); } else { - if (index == 0 && data[i + 1] == 2 /* Other */) + if (index == 0 && data[i + 1] == 2 /* Seq.Other */) index = this.putAction(pair(data, i + 2), token, end, index); break; } @@ -6737,20 +7222,6 @@ class TokenCache { return index; } } -var Rec; -(function (Rec) { - Rec[Rec["Distance"] = 5] = "Distance"; - Rec[Rec["MaxRemainingPerStep"] = 3] = "MaxRemainingPerStep"; - // When two stacks have been running independently long enough to - // add this many elements to their buffers, prune one. - Rec[Rec["MinBufferLengthPrune"] = 500] = "MinBufferLengthPrune"; - Rec[Rec["ForceReduceLimit"] = 10] = "ForceReduceLimit"; - // Once a stack reaches this depth (in .stack.length) force-reduce - // it back to CutTo to avoid creating trees that overflow the stack - // on recursive traversal. - Rec[Rec["CutDepth"] = 15000] = "CutDepth"; - Rec[Rec["CutTo"] = 9000] = "CutTo"; -})(Rec || (Rec = {})); class Parse { constructor(parser, input, fragments, ranges) { this.parser = parser; @@ -6761,6 +7232,9 @@ class Parse { this.minStackPos = 0; this.reused = []; this.stoppedAt = null; + this.lastBigReductionStart = -1; + this.lastBigReductionSize = 0; + this.bigReductionCount = 0; this.stream = new InputStream(input, ranges); this.tokens = new TokenCache(parser, this.stream); this.topTerm = parser.top[1]; @@ -6783,6 +7257,18 @@ class Parse { // This will hold stacks beyond `pos`. let newStacks = this.stacks = []; let stopped, stoppedTokens; + // If a large amount of reductions happened with the same start + // position, force the stack out of that production in order to + // avoid creating a tree too deep to recurse through. + // (This is an ugly kludge, because unfortunately there is no + // straightforward, cheap way to check for this happening, due to + // the history of reductions only being available in an + // expensive-to-access format in the stack buffers.) + if (this.bigReductionCount > 300 /* Rec.MaxLeftAssociativeReductionCount */ && stacks.length == 1) { + let [s] = stacks; + while (s.forceReduce() && s.stack.length && s.stack[s.stack.length - 2] >= this.lastBigReductionStart) { } + this.bigReductionCount = this.lastBigReductionSize = 0; + } // Keep advancing any stacks at `pos` until they either move // forward or can't be advanced. Gather stacks that can't be // advanced further in `stopped`. @@ -6810,24 +7296,30 @@ class Parse { } if (!newStacks.length) { let finished = stopped && findFinished(stopped); - if (finished) + if (finished) { + if (verbose) + console.log("Finish with " + this.stackID(finished)); return this.stackToTree(finished); + } if (this.parser.strict) { if (verbose && stopped) console.log("Stuck with token " + (this.tokens.mainToken ? this.parser.getName(this.tokens.mainToken.value) : "none")); throw new SyntaxError("No parse at " + pos); } if (!this.recovering) - this.recovering = 5 /* Distance */; + this.recovering = 5 /* Rec.Distance */; } if (this.recovering && stopped) { let finished = this.stoppedAt != null && stopped[0].pos > this.stoppedAt ? stopped[0] : this.runRecovery(stopped, stoppedTokens, newStacks); - if (finished) + if (finished) { + if (verbose) + console.log("Force-finish " + this.stackID(finished)); return this.stackToTree(finished.forceAll()); + } } if (this.recovering) { - let maxRemaining = this.recovering == 1 ? 1 : this.recovering * 3 /* MaxRemainingPerStep */; + let maxRemaining = this.recovering == 1 ? 1 : this.recovering * 3 /* Rec.MaxRemainingPerStep */; if (newStacks.length > maxRemaining) { newStacks.sort((a, b) => b.score - a.score); while (newStacks.length > maxRemaining) @@ -6845,7 +7337,7 @@ class Parse { for (let j = i + 1; j < newStacks.length; j++) { let other = newStacks[j]; if (stack.sameState(other) || - stack.buffer.length > 500 /* MinBufferLengthPrune */ && other.buffer.length > 500 /* MinBufferLengthPrune */) { + stack.buffer.length > 500 /* Rec.MinBufferLengthPrune */ && other.buffer.length > 500 /* Rec.MinBufferLengthPrune */) { if (((stack.score - other.score) || (stack.buffer.length - other.buffer.length)) > 0) { newStacks.splice(j--, 1); } @@ -6856,6 +7348,8 @@ class Parse { } } } + if (newStacks.length > 12 /* Rec.MaxStackCount */) + newStacks.splice(12 /* Rec.MaxStackCount */, newStacks.length - 12 /* Rec.MaxStackCount */); } this.minStackPos = newStacks[0].pos; for (let i = 1; i < newStacks.length; i++) @@ -6896,25 +7390,26 @@ class Parse { break; } } - let defaultReduce = parser.stateSlot(stack.state, 4 /* DefaultReduce */); + let defaultReduce = parser.stateSlot(stack.state, 4 /* ParseState.DefaultReduce */); if (defaultReduce > 0) { stack.reduce(defaultReduce); if (verbose) - console.log(base + this.stackID(stack) + ` (via always-reduce ${parser.getName(defaultReduce & 65535 /* ValueMask */)})`); + console.log(base + this.stackID(stack) + ` (via always-reduce ${parser.getName(defaultReduce & 65535 /* Action.ValueMask */)})`); return true; } - if (stack.stack.length >= 15000 /* CutDepth */) { - while (stack.stack.length > 9000 /* CutTo */ && stack.forceReduce()) { } + if (stack.stack.length >= 9000 /* Rec.CutDepth */) { + while (stack.stack.length > 6000 /* Rec.CutTo */ && stack.forceReduce()) { } } let actions = this.tokens.getActions(stack); for (let i = 0; i < actions.length;) { let action = actions[i++], term = actions[i++], end = actions[i++]; let last = i == actions.length || !split; let localStack = last ? stack : stack.split(); - localStack.apply(action, term, end); + let main = this.tokens.mainToken; + localStack.apply(action, term, main ? main.start : localStack.pos, end); if (verbose) - console.log(base + this.stackID(localStack) + ` (via ${(action & 65536 /* ReduceFlag */) == 0 ? "shift" - : `reduce of ${parser.getName(action & 65535 /* ValueMask */)}`} for ${parser.getName(term)} @ ${start}${localStack == stack ? "" : ", split"})`); + console.log(base + this.stackID(localStack) + ` (via ${(action & 65536 /* Action.ReduceFlag */) == 0 ? "shift" + : `reduce of ${parser.getName(action & 65535 /* Action.ValueMask */)}`} for ${parser.getName(term)} @ ${start}${localStack == stack ? "" : ", split"})`); if (last) return true; else if (localStack.pos > start) @@ -6955,7 +7450,7 @@ class Parse { continue; } let force = stack.split(), forceBase = base; - for (let j = 0; force.forceReduce() && j < 10 /* ForceReduceLimit */; j++) { + for (let j = 0; force.forceReduce() && j < 10 /* Rec.ForceReduceLimit */; j++) { if (verbose) console.log(forceBase + this.stackID(force) + " (via force-reduce)"); let done = this.advanceFully(force, newStacks); @@ -6972,7 +7467,7 @@ class Parse { if (this.stream.end > stack.pos) { if (tokenEnd == stack.pos) { tokenEnd++; - token = 0 /* Err */; + token = 0 /* Term.Err */; } stack.recoverByDelete(token, tokenEnd); if (verbose) @@ -7024,18 +7519,22 @@ class Dialect { allows(term) { return !this.disabled || this.disabled[term] == 0; } } const id = x => x; -/// Context trackers are used to track stateful context (such as -/// indentation in the Python grammar, or parent elements in the XML -/// grammar) needed by external tokenizers. You declare them in a -/// grammar file as `@context exportName from "module"`. -/// -/// Context values should be immutable, and can be updated (replaced) -/// on shift or reduce actions. -/// -/// The export used in a `@context` declaration should be of this -/// type. +/** +Context trackers are used to track stateful context (such as +indentation in the Python grammar, or parent elements in the XML +grammar) needed by external tokenizers. You declare them in a +grammar file as `@context exportName from "module"`. + +Context values should be immutable, and can be updated (replaced) +on shift or reduce actions. + +The export used in a `@context` declaration should be of this +type. +*/ class ContextTracker { - /// Define a context tracker. + /** + Define a context tracker. + */ constructor(spec) { this.start = spec.start; this.shift = spec.shift || id; @@ -7045,17 +7544,23 @@ class ContextTracker { this.strict = spec.strict !== false; } } -/// Holds the parse tables for a given grammar, as generated by -/// `lezer-generator`, and provides [methods](#common.Parser) to parse -/// content with. +/** +Holds the parse tables for a given grammar, as generated by +`lezer-generator`, and provides [methods](#common.Parser) to parse +content with. +*/ class LRParser extends Parser { - /// @internal + /** + @internal + */ constructor(spec) { super(); - /// @internal + /** + @internal + */ this.wrappers = []; - if (spec.version != 14 /* Version */) - throw new RangeError(`Parser version (${spec.version}) doesn't match runtime version (${14 /* Version */})`); + if (spec.version != 14 /* File.Version */) + throw new RangeError(`Parser version (${spec.version}) doesn't match runtime version (${14 /* File.Version */})`); let nodeNames = spec.nodeNames.split(" "); this.minRepeatTerm = nodeNames.length; for (let i = 0; i < spec.repeatNodeCount; i++) @@ -7124,7 +7629,9 @@ class LRParser extends Parser { parse = w(parse, input, fragments, ranges); return parse; } - /// Get a goto table entry @internal + /** + Get a goto table entry @internal + */ getGoto(state, term, loose = false) { let table = this.goto; if (term >= table[0]) @@ -7141,60 +7648,76 @@ class LRParser extends Parser { return -1; } } - /// Check if this state has an action for a given terminal @internal + /** + Check if this state has an action for a given terminal @internal + */ hasAction(state, terminal) { let data = this.data; for (let set = 0; set < 2; set++) { - for (let i = this.stateSlot(state, set ? 2 /* Skip */ : 1 /* Actions */), next;; i += 3) { - if ((next = data[i]) == 65535 /* End */) { - if (data[i + 1] == 1 /* Next */) + for (let i = this.stateSlot(state, set ? 2 /* ParseState.Skip */ : 1 /* ParseState.Actions */), next;; i += 3) { + if ((next = data[i]) == 65535 /* Seq.End */) { + if (data[i + 1] == 1 /* Seq.Next */) next = data[i = pair(data, i + 2)]; - else if (data[i + 1] == 2 /* Other */) + else if (data[i + 1] == 2 /* Seq.Other */) return pair(data, i + 2); else break; } - if (next == terminal || next == 0 /* Err */) + if (next == terminal || next == 0 /* Term.Err */) return pair(data, i + 1); } } return 0; } - /// @internal + /** + @internal + */ stateSlot(state, slot) { - return this.states[(state * 6 /* Size */) + slot]; + return this.states[(state * 6 /* ParseState.Size */) + slot]; } - /// @internal + /** + @internal + */ stateFlag(state, flag) { - return (this.stateSlot(state, 0 /* Flags */) & flag) > 0; + return (this.stateSlot(state, 0 /* ParseState.Flags */) & flag) > 0; } - /// @internal + /** + @internal + */ validAction(state, action) { - if (action == this.stateSlot(state, 4 /* DefaultReduce */)) - return true; - for (let i = this.stateSlot(state, 1 /* Actions */);; i += 3) { - if (this.data[i] == 65535 /* End */) { - if (this.data[i + 1] == 1 /* Next */) + return !!this.allActions(state, a => a == action ? true : null); + } + /** + @internal + */ + allActions(state, action) { + let deflt = this.stateSlot(state, 4 /* ParseState.DefaultReduce */); + let result = deflt ? action(deflt) : undefined; + for (let i = this.stateSlot(state, 1 /* ParseState.Actions */); result == null; i += 3) { + if (this.data[i] == 65535 /* Seq.End */) { + if (this.data[i + 1] == 1 /* Seq.Next */) i = pair(this.data, i + 2); else - return false; + break; } - if (action == pair(this.data, i + 1)) - return true; + result = action(pair(this.data, i + 1)); } + return result; } - /// Get the states that can follow this one through shift actions or - /// goto jumps. @internal + /** + Get the states that can follow this one through shift actions or + goto jumps. @internal + */ nextStates(state) { let result = []; - for (let i = this.stateSlot(state, 1 /* Actions */);; i += 3) { - if (this.data[i] == 65535 /* End */) { - if (this.data[i + 1] == 1 /* Next */) + for (let i = this.stateSlot(state, 1 /* ParseState.Actions */);; i += 3) { + if (this.data[i] == 65535 /* Seq.End */) { + if (this.data[i + 1] == 1 /* Seq.Next */) i = pair(this.data, i + 2); else break; } - if ((this.data[i + 2] & (65536 /* ReduceFlag */ >> 16)) == 0) { + if ((this.data[i + 2] & (65536 /* Action.ReduceFlag */ >> 16)) == 0) { let value = this.data[i + 1]; if (!result.some((v, i) => (i & 1) && v == value)) result.push(this.data[i], value); @@ -7202,14 +7725,11 @@ class LRParser extends Parser { } return result; } - /// @internal - overrides(token, prev) { - let iPrev = findOffset(this.data, this.tokenPrecTable, prev); - return iPrev < 0 || findOffset(this.data, this.tokenPrecTable, token) < iPrev; - } - /// Configure the parser. Returns a new parser instance that has the - /// given settings modified. Settings not provided in `config` are - /// kept from the original parser. + /** + Configure the parser. Returns a new parser instance that has the + given settings modified. Settings not provided in `config` are + kept from the original parser. + */ configure(config) { // Hideous reflection-based kludge to make it easy to create a // slightly modified copy of a parser. @@ -7250,29 +7770,41 @@ class LRParser extends Parser { copy.bufferLength = config.bufferLength; return copy; } - /// Tells you whether any [parse wrappers](#lr.ParserConfig.wrap) - /// are registered for this parser. + /** + Tells you whether any [parse wrappers](#lr.ParserConfig.wrap) + are registered for this parser. + */ hasWrappers() { return this.wrappers.length > 0; } - /// Returns the name associated with a given term. This will only - /// work for all terms when the parser was generated with the - /// `--names` option. By default, only the names of tagged terms are - /// stored. + /** + Returns the name associated with a given term. This will only + work for all terms when the parser was generated with the + `--names` option. By default, only the names of tagged terms are + stored. + */ getName(term) { return this.termNames ? this.termNames[term] : String(term <= this.maxNode && this.nodeSet.types[term].name || term); } - /// The eof term id is always allocated directly after the node - /// types. @internal + /** + The eof term id is always allocated directly after the node + types. @internal + */ get eofTerm() { return this.maxNode + 1; } - /// The type of top node produced by the parser. + /** + The type of top node produced by the parser. + */ get topNode() { return this.nodeSet.types[this.top[1]]; } - /// @internal + /** + @internal + */ dynamicPrecedence(term) { let prec = this.dynamicPrecedences; return prec == null ? 0 : prec[term] || 0; } - /// @internal + /** + @internal + */ parseDialect(dialect) { let values = Object.keys(this.dialects), flags = values.map(() => false); if (dialect) @@ -7284,30 +7816,26 @@ class LRParser extends Parser { let disabled = null; for (let i = 0; i < values.length; i++) if (!flags[i]) { - for (let j = this.dialects[values[i]], id; (id = this.data[j++]) != 65535 /* End */;) + for (let j = this.dialects[values[i]], id; (id = this.data[j++]) != 65535 /* Seq.End */;) (disabled || (disabled = new Uint8Array(this.maxTerm + 1)))[id] = 1; } return new Dialect(dialect, flags, disabled); } - /// Used by the output of the parser generator. Not available to - /// user code. + /** + Used by the output of the parser generator. Not available to + user code. @hide + */ static deserialize(spec) { return new LRParser(spec); } } function pair(data, off) { return data[off] | (data[off + 1] << 16); } -function findOffset(data, start, term) { - for (let i = start, next; (next = data[i]) != 65535 /* End */; i++) - if (next == term) - return i - start; - return -1; -} function findFinished(stacks) { let best = null; for (let stack of stacks) { let stopped = stack.p.stoppedAt; if ((stack.pos == stack.p.stream.end || stopped != null && stack.pos > stopped) && - stack.p.parser.stateFlag(stack.state, 2 /* Accepting */) && + stack.p.parser.stateFlag(stack.state, 2 /* StateFlag.Accepting */) && (!best || best.score < stack.score)) best = stack; } @@ -7315,32 +7843,32 @@ function findFinished(stacks) { } function getSpecializer(spec) { if (spec.external) { - let mask = spec.extend ? 1 /* Extend */ : 0 /* Specialize */; + let mask = spec.extend ? 1 /* Specialize.Extend */ : 0 /* Specialize.Specialize */; return (value, stack) => (spec.external(value, stack) << 1) | mask; } return spec.get; } // This file was generated by lezer-generator. You probably shouldn't edit it. -const immediateParen = 245, - immediateColon = 246, - immediateBrace = 247, - immediateBracket = 248, - immediateSingleQuote = 249, - immediateDoubleQuote = 250, - immediateBackquote = 251, - immediateDot = 252, - nowhitespace = 253, - newline$1$1 = 254, - word$1 = 255, +const immediateParen = 247, + immediateColon = 248, + immediateBrace = 249, + immediateBracket = 250, + immediateSingleQuote = 251, + immediateDoubleQuote = 252, + immediateBackquote = 253, + immediateDot = 254, + nowhitespace = 255, + newline$1$1 = 256, + word$1 = 257, Identifier$1$1 = 1, BlockComment$1$1 = 2, - tripleStringContent$1 = 256, - stringContent$1 = 257, - commandStringContent$1 = 258, - tripleStringContentWithoutInterpolation$1 = 259, - stringContentWithoutInterpolation$1 = 260, - commandStringContentWithoutInterpolation$1 = 261; + tripleStringContent$1 = 258, + stringContent$1 = 259, + commandStringContent$1 = 260, + tripleStringContentWithoutInterpolation$1 = 261, + stringContentWithoutInterpolation$1 = 262, + commandStringContentWithoutInterpolation$1 = 263; // UNICODE CODEPOINTS @@ -7804,26 +8332,26 @@ const layoutExtra = new ExternalTokenizer( ); // This file was generated by lezer-generator. You probably shouldn't edit it. -const spec_Identifier = {__proto__:null,if:14, elseif:20, else:24, end:26, try:30, catch:34, finally:40, for:44, primitive:74, type:76, abstract:84, mutable:90, struct:92, module:98, baremodule:104, macro:110, in:132, isa:134, function:152, do:164, where:170, true:204, false:204, begin:264, while:320, let:326, const:334, global:342, local:346, quote:350, break:354, continue:358, return:362, using:366, import:368, as:376, export:384}; +const spec_Identifier = {__proto__:null,if:14, elseif:20, else:24, end:26, try:30, catch:34, finally:42, for:46, primitive:76, type:78, abstract:86, mutable:92, struct:94, module:100, baremodule:106, macro:112, in:134, isa:136, function:154, do:166, where:172, true:206, false:206, begin:266, while:324, let:330, const:338, global:346, local:350, quote:354, break:358, continue:362, return:366, using:370, import:372, as:380, export:388}; const parser$7 = LRParser.deserialize({ version: 14, - states: "%<^Q$tQNSOOOOQj'#IP'#IPOOQj'#Gt'#GtO${QNSO'#IOO*cQNTO'#DoO*mQNTO'#DoO/eQNTO'#IRO0OQMyO'#IlOOQk'#Il'#IlO0TQNTO'#IlOOQk'#Do'#DoO:sQNTO'#DoO>{QNQO'#DtOOQk'#Ib'#IbO@WQNUO'#EWO@bONzO'#EhO@mONYO'#ElO@xO!!^O'#EmOATQMyO'#EoODRQNTO'#EoODYQMyO'#EnOGsQNQO'#FiOOQk'#I['#I[OLwQNTO'#I[ONrQNTO'#IOO! tQNSO'#IOOOQk'#IS'#ISO!!OQNTO'#GfO!#hQNTO'#GfO!$}QNQO'#GjO!(`QMxO'#GnO!(eQNTO'#IROOQk'#IR'#IRO! YQNSO'#IOO! YQNSO'#IOQOQMxOOO!(oQNQO'#CbOOQk'#Is'#IsO!$}QNQO'#FxO!,QQNQO'#F|O!/cQNQO'#GOOOQk'#GS'#GSOOQk'#GU'#GUO!2tQNTO'#GWO!4TQNQO'#GYO!4]QNQO'#GcO!4eQNSO'#CaO!4rQNSO'#CjO!5PQNQO'#DQO!5UQNQO'#DVO!5ZQNQO'#DYO!6}QNQO'#DYO!7SQNQO'#D^O!7XQNQO'#DaO!8eQNQO'#DdO!:]QNQO'#DyO!:gQNQO'#CqO!(oQNQO'#FqO!:oQNSO'#FtO!4kQNSO'#GQO!4kQNSO'#GeO!>rQNSO-E:rO!>|QNTO,5>TO!@tQNSO,5>TO!?vQNSO,5>TO!AOQNSO,5>jO!5ZQNQO,59fO!AjQNUO,59iOOQh'#Cw'#CwOOQh'#Cx'#CxO!AqQMxO,59gO!AvQMxO,5:iO!A{QMyO,5:iO!BTQMxO,59jO!BYQMxO,5jO!$}QNQO'#HdO#2TQNSO,5yQMyO'#I[O$?TQNSO,5:eO$?_QNQO'#CtO$?oQ!LjO'#CsO$?zQNSO,59]O$@UQNTO'#FsO!4kQNSO,5<]O$BvQMyO'#CzO$COQMzO'#FwO$C^QMzO'#FvO!4kQNSO,5<`O$CiQMzO,5<`O$CqQNQO,5TO$DoQNSO,5>TOOQj,5>T,5>TO$EaQNSO1G4UO$EwQNSO1G4UO$KYQNTO1G/QO%!dQNTO1G/TOOQk'#E`'#E`OOQk1G0e1G0eO%#YQM}O1G/RO%#aQNQO'#DtOOQk'#Iv'#IvO%#hQNTO1G0TO!AvQMxO1G0TO%,VQNQO1G/UO%,aQNQO'#DlOOQk1G1u1G1uO%/xQNTO'#CyOOQk1G1t1G1tOOQk1G4r1G4rO%4kQNQO,59aO%7|QNQO'#IuOOQ`,5:a,5:aO%8_QNQO'#DvOOQk1G1s1G1sO%8gQNQO,5?`O%8wQMxO,5?`O%OOOQk-E;b-E;bO%NyQNTO1G2QOOQk1G2Q1G2QO&!XQNSO1G2QO&&|QNTO1G2rO&)aQNTO1G2rO&+tQNTO1G2rO&+{QNTO1G2rO&.YQNTO1G2rO&.gQNTO1G2rO&0wQNTO1G2rO&1RQNTO1G2rO&3iQNTO1G2rO&3pQNTO1G2rO&5XQNRO1G2sOOQk1G2w1G2wO&7cQNTO1G2rO&7sQM|O1G2mOOQk-E;f-E;fOOQk'#Je'#JeO&7xQNTO1G2lOOQk1G2l1G2lP]QNSO'#GtOOQk,5POOQk,5>P,5>POOQk-E;c-E;cO()^QNQO1G2gOOQk1G2e1G2eOOQk,5>R,5>ROOQk-E;e-E;eOOQh,59O,59OOOQh-E:s-E:sOOQk7+$R7+$RO()kQNQO7+$RO()pQNTO,59POOQh,59R,59RO(,hQNTO'#CnOOQh,59W,59WO(2SQNSO,59WOOQh,59Z,59ZOOQk7+$[7+$[O(2ZQNQO7+$[O(2`QNQO7+$rOOQk7+$w7+$wO%!wQM}O1G/RO(2eQNQO,5>pO(2oQMxO,5>pOOQk7+$z7+$zO(2zQNQO7+$zOOQk7+%O7+%OOOQk7+%R7+%RO(3PQM|O1G/mO(3[QNQO1G/nOOQa1G/q1G/qO$9rQNQO,5:YO(3fQNQO1G/sO(3yQMxO1G/sOOQa1G/s1G/sO!4kQNSO7+%UO(4RQNTO'#IvOOQj1G0Y1G0YOOQj1G0S1G0SOOQk7+%k7+%kOOQj'#EU'#EUO!4kQNSO7+%kO(9jQNTO1G.yOOQj,5=|,5=|OOQj-E;`-E;`O(<_QNQO7+$cOOQk7+$c7+$cOOQk7+'c7+'cO([AN>[OOQkAN>qAN>qOOQj,5=i,5=iOOQj-E:{-E:{OOQk7+%q7+%qOOQi7+%|7+%|OOQi7+%{7+%{O+3uQNRO7+%}OOQi7+%}7+%}O+4VQMxO7+%}O+4[QMxO7+%}O+4dQMxO7+%}O(JTQMxO,5:}OOQi,5:},5:}OOQi7+&R7+&RO+4lQNRO7+&RO+9`QNRO,5;oO+9jQMxO,5;oO+9rQNRO1G0jOOQ`,5=j,5=jO+:PQMxO1G5TO+:_QNQO1G5TOOQ`-E:|-E:|O+QOOQk,5>Q,5>QO,#QQNTO,5>QOOQk-E;d-E;dOOQk1G2h1G2hO,#XQNRO1G/oOOQaAN>`AN>`O,#cQNQOAN>`O,#jQNQO<OO/$hQNRO,5>OO/&fQNRO,5>OO/'PQNTO,5>OO/(qQNTO,5>OO/*lQNRO,5>OO/+YQNTO1G2QO//`QNRO1G2QO/0PQNTO1G2QO/1xQNRO1G2QO/2fQNTO1G2QO/8]QNRO1G2QO/8jQNRO1G2QO/:hQNRO1G2rO/:oQNTO1G2rO/:vQNRO1G2rO/{QNRO1G1cO4?`QNRO1G1cO4?pQNRO1G1cO4@QQNRO1G1cO4@bQNRO1G1cO4AyQNRO1G1cO'9yQNQO,5;zO1LOQNQO,5;zO)/`QNQO,5;zO(NjQNQO,5;zO'9yQNQO7+'OO1LOQNQO7+'OO*DSQNQO7+'OO)/`QNQO7+'OO)6|QNQO7+'OO(NjQNQO7+'OO)3cQNQO7+'OO4BZQNRO1G1fO4E[QNRO1G1fO4GSQNRO1G1fO4GpQNRO1G1fO4J_QNRO<XQNRO1G2rO7>cQNRO1G2rO7>mQNRO1G2rO7>wQNRO1G2rO7ByQNRO1G2rO7DtQNRO1G2rO7FiQNRO1G2rO7HTQNRO1G2rO7H[QNRO1G2rO7HcQNRO1G2rO7HjQNRO1G2rO7HqQNRO1G2rO7HxQNRO1G2rO7IYQNRO1G2rO7IjQNRO1G2rO7IzQNRO1G2rO7J[QNQO'#FZO68QQNQO'#FZO7MpQNQO'#FZO64lQNQO'#FZO#-XQNQO,5=ZO6<|QNQO,5=ZO#-XQNQO7+(_O6<|QNQO7+(_O'IZQNQO7+(_O'N^QNQO7+(_O7J[QNQO,5;yO7MpQNQO,5;yO7J[QNQO,5;wO68QQNQO,5;wO7MpQNQO,5;wO64lQNQO,5;wO7J[QNQO,5;wO68QQNQO,5;wO7MpQNQO,5;wO64lQNQO,5;wO7J[QNQO,5;wO68QQNQO,5;wO7MpQNQO,5;wO64lQNQO,5;wO7J[QNQO,5;wO68QQNQO,5;wO7MpQNQO,5;wO64lQNQO,5;wO7J[QNQO,5;wO68QQNQO,5;wO7MpQNQO,5;wO64lQNQO,5;wO7J[QNQO,5;wO68QQNQO,5;wO7MpQNQO,5;wO64lQNQO,5;wO7J[QNQO,5;wO68QQNQO,5;wO7MpQNQO,5;wO64lQNQO,5;wO7J[QNQO,5;wO68QQNQO,5;wO7MpQNQO,5;wO64lQNQO,5;wO7J[QNQO,5;wO68QQNQO,5;wO7MpQNQO,5;wO64lQNQO,5;wO7J[QNQO,5;wO68QQNQO,5;wO7MpQNQO,5;wO64lQNQO,5;wO7J[QNQO,5;wO68QQNQO,5;wO7MpQNQO,5;wO64lQNQO,5;wO8#UQNRO1G2uO8%pQNRO1G2uO8&WQNRO<QQNRO1G1cO8?uQNRO1G1cO8@VQNRO1G1cO8@^QNRO1G1cO8@eQNRO1G1cO8@lQNRO1G1cO8BdQNRO1G1cO8DXQNRO1G1cO8E|QNRO1G1cO8GhQNRO1G1cO8GrQNRO1G1cO8G|QNRO1G1cO8HWQNRO1G1cO8HbQNRO1G1cO8J`QNRO1G1cO8LTQNRO1G1cO8MxQNRO1G1cO9 dQNRO1G1cO9 kQNRO1G1cO9 rQNRO1G1cO9 yQNRO1G1cO9!QQNRO1G1cO9!XQNRO1G1cO9!iQNRO1G1cO9!yQNRO1G1cO9#gQNRO1G1cO7J[QNQO,5;zO7MpQNQO,5;zO7J[QNQO7+'OO68QQNQO7+'OO7MpQNQO7+'OO64lQNQO7+'OO9#wQNRO1G1fO9%iQNRO1G1fO9&SQNRO<hO!w([O]&rP~P]O&t!rO&|!fO&}!gO']'zO~P!$}O!d(bO&{(_O'y(`O~O'W(cO]&rP~P]OP$gXV$gX]$gX_$gXf$gXu$gXx$gXz$gX}$gX!O$gX!R$gX!U$gX!X$gX!n$gX#Y$gX#Z$gX#x$gX$f$gX$i$gX$m$gX$q$gX$s$gX$u$gX$w$gX$y$gX${$gX$}$gX%O$gX%W$gX&h$gX&t$gX&w$gX&z$gX&{$gX'S$gX'_$gX'n$gX's$gX'u$gX'v$gX~P#A{O&_=QO&g=QO~O&{(gO&h$kX&t$kX'W$kX~O'W(hO&h$jX&t$jX~O&hPO&tPO~O](lO~O](mO~O&z#hO&{#hO&^&]a&h&]a&t&]aY&]a[&]a]&]aa&]ad&]a~P#FTO&z#hO&{#hO&^&]a&h&]a&t&]aY&]a[&]a]&]aa&]ad&]a~O&^&riY&ri[&ri]&ria&rid&ri~P]O&hPO&tPO&^&riY&ri[&ri]&ria&rid&ri~O&a!lO&b!kO&f'vO!dni!eni!fni!gni&^ni&cni&hni&tni&zni&{ni'Pni'Qni'Rni'Wni'^ni'ani'bni'cni'dni'eni'fni'{ni'|ni'}ni(Oni(Tnifni']niPniVni_niunixnizni}ni!Oni!Rni!Uni!Xni!nni#Yni#Zni#xni$fni$ini$mni$qni$sni$uni$wni$yni${ni$}ni%Oni%Wni&wni'Sni'Xni'_ni'nni'sni'uni'vniYni[ni]nianidni(Pni'Zni~O&_ni&gni&|ni&}ni!wni~P$FcO&a!lO&b!kO&f'vO!dqi!eqi!fqi!gqi&^qi&cqi&hqi&tqi&zqi&{qi'Pqi'Qqi'Rqi'Wqi'^qi'aqi'bqi'cqi'dqi'eqi'fqi'{qi'|qi'}qi(Oqi(Tqifqi']qiPqiVqi_qiuqixqizqi}qi!Oqi!Rqi!Uqi!Xqi!nqi#Yqi#Zqi#xqi$fqi$iqi$mqi$qqi$sqi$uqi$wqi$yqi${qi$}qi%Oqi%Wqi&wqi'Sqi'Xqi'_qi'nqi'sqi'uqi'vqiYqi[qi]qiaqidqi(Pqi'Zqi~O&_qi&gqi&|qi&}qi!wqi~P$KmO&i(oO'P=jO'R(pO&_!ra&g!ra~O'n^O~P%!wO'](tO~P;aO!t(vO!d!qi!e!qi!f!qi!g!qi&^!qi&_!qi&a!qi&b!qi&c!qi&f!qi&g!qi&h!qi&t!qi&z!qi&{!qi&|!qi&}!qi'P!qi'Q!qi'R!qi'W!qi'^!qi'a!qi'b!qi'c!qi'd!qi'e!qi'f!qi'{!qi'|!qi'}!qi(O!qi(T!qif!qi']!qiP!qiV!qi_!qiu!qix!qiz!qi}!qi!O!qi!R!qi!U!qi!X!qi!n!qi#Y!qi#Z!qi#x!qi$f!qi$i!qi$m!qi$q!qi$s!qi$u!qi$w!qi$y!qi${!qi$}!qi%O!qi%W!qi&w!qi'S!qi'X!qi'_!qi'n!qi's!qi'u!qi'v!qiY!qi[!qi]!qia!qid!qi(P!qi'Z!qi!w!qi~OP(|OVtO])OO_!POf!YOu!QOx)POz!RO}!TO!O!SO!R!UO!U!VO!X!WO!duO!euO!fYO!gYO!n!XO#Y)OO#Z)OO#x)OO$f!ZO$i![O$mvO'c?OO'd>rO'e?[O'f?WO'{>zO'|?dO'}?hO(ODQOf&SX'X&SX~P#)VO'X*PO~P#-XO&t*QO'X*PO~O&_*SO&f*TO!d$VX!e$VX!f$VX!g$VX&^$VX&c$VX&d#cX&e#cX&h$VX&t$VX&z$VX&{$VX'P$VX'Q$VX'R$VX'W$VX'^$VX'a$VX'b$VX'c$VX'd$VX'e$VX'f$VX'{$VX'|$VX'}$VX(O$VX(T$VXf$VX']$VXP$VXV$VX_$VXu$VXx$VXz$VX}$VX!O$VX!R$VX!U$VX!X$VX!n$VX#Y$VX#Z$VX#x$VX$f$VX$i$VX$m$VX$q$VX$s$VX$u$VX$w$VX$y$VX${$VX$}$VX%O$VX%W$VX&w$VX'S$VX'X$VX'_$VX'n$VX's$VX'u$VX'v$VXY$VX[$VX]$VXa$VXd$VX(P$VX'Z$VX~O!duO!euO!f#oO!g#pO&c#tO'P#mO'QVO'R#vO'^#jO'aWO'bWO'c#lO'd#iO'e#oO'{#kO'|#qO'}#rO(O#sO(T#uO&^&Wa&h&Wa&t&Wa&z&Wa&{&Wa'W&WaY&Wa[&Wa]&Waa&Wad&Wa~O'f#nO~P%LrO&z#hO&{#hO&^$ni&h$ni&t$niY$ni[$ni]$nia$nid$ni~P#FTO&^$ni&h$ni&t$niY$ni[$ni]$nia$nid$ni~O&z#hO&{#hO~P& mO&c#tO(T#uO!d%`i!e%`i!f%`i!g%`i&^%`i&h%`i&t%`i&z%`i&{%`i'P%`i'Q%`i'R%`i'W%`i'^%`i'a%`i'b%`i'c%`i'e%`i'f%`i'{%`i'|%`i'}%`i(O%`if%`i']%`iP%`iV%`i_%`iu%`ix%`iz%`i}%`i!O%`i!R%`i!U%`i!X%`i!n%`i#Y%`i#Z%`i#x%`i$f%`i$i%`i$m%`i$q%`i$s%`i$u%`i$w%`i$y%`i${%`i$}%`i%O%`i%W%`i&w%`i'S%`i'X%`i'_%`i'n%`i's%`i'u%`i'v%`iY%`i[%`i]%`ia%`id%`i(P%`i'Z%`i~O'd%`i~P&!cO&c#tO'd#iO(T#uO!d%`i!e%`i!f%`i!g%`i&^%`i&h%`i&t%`i&z%`i&{%`i'P%`i'Q%`i'R%`i'W%`i'a%`i'b%`i'c%`i'e%`i'f%`i'{%`i'|%`i'}%`i(O%`iY%`i[%`i]%`ia%`id%`i']%`i'Z%`i'X%`i(P%`i~O'^%`i~P&'TO!duO!euO!f#oO!g#pO&c#tO'P#mO'QVO'R#vO'^#jO'aWO'bWO'c#lO'd#iO'e#oO'{#kO'|#qO'}#rO(O#sO(T#uO&^%`i&h%`i&t%`i&z%`i&{%`i'W%`iY%`i[%`i]%`ia%`id%`i']%`i'Z%`i'X%`i(P%`i~O'f%`i~P&)hO'^#jO~P&'TO&c#tO(T#uO!d%`i!e%`i!f%`i!g%`i&^%`i&h%`i&t%`i&z%`i&{%`i'P%`i'Q%`i'R%`i'W%`i'a%`i'b%`i'e%`i'f%`i'{%`i'|%`i'}%`i(O%`iY%`i[%`i]%`ia%`id%`i']%`i'Z%`i'X%`i(P%`i~O'^#jO'c#lO'd#iO~P&,SO'f#nO~P&)hO&c#tO'P#mO'QVO'R#vO'^#jO'aWO'bWO'c#lO'd#iO(T#uO!d%`i!e%`i&^%`i&h%`i&t%`i&z%`i&{%`i'W%`i'e%`i'f%`i'{%`i'|%`i'}%`i(O%`iY%`i[%`i]%`ia%`id%`i']%`i'Z%`i'X%`i(P%`i~O!f#oO!g#pO~P&.nO!f%`i!g%`i~P&.nO!duO!euO!f#oO!g#pO&c#tO'P#mO'QVO'R#vO'^#jO'aWO'bWO'c#lO'd#iO'e#oO'}#rO(T#uO&^%`i&h%`i&t%`i&z%`i&{%`i'W%`i'f%`i'{%`i(O%`iY%`i[%`i]%`ia%`id%`i']%`i'Z%`i'X%`i(P%`i~O'|#qO~P&1]O'|%`i~P&1]O!duO!euO!f4eO!g4lO&c#tO'P4VO'QVO'R5RO'^3pO'aWO'bWO'c4OO'd3iO'e4eO'f4^O'{3wO'|4sO'}4zO(OC`O(T#uO~O(P*UO~P&3wO&c#tO'QVO'aWO'bWO(T#uO!d%`i!e%`i!f%`i!g%`i&^%`i&h%`i&t%`i&z%`i&{%`i'R%`i'W%`i'e%`i'f%`i'{%`i'|%`i'}%`i(O%`iY%`i[%`i]%`ia%`id%`i']%`i'Z%`i'X%`i(P%`i~O'P#mO'^#jO'c#lO'd#iO~P&5`O&i*VO~O!t(vO!d%Yi!e%Yi!f%Yi!g%Yi&^%Yi&c%Yi&h%Yi&t%Yi&z%Yi&{%Yi'P%Yi'Q%Yi'R%Yi'W%Yi'^%Yi'a%Yi'b%Yi'c%Yi'd%Yi'e%Yi'f%Yi'{%Yi'|%Yi'}%Yi(O%Yi(T%Yif%Yi']%YiP%YiV%Yi_%Yiu%Yix%Yiz%Yi}%Yi!O%Yi!R%Yi!U%Yi!X%Yi!n%Yi#Y%Yi#Z%Yi#x%Yi$f%Yi$i%Yi$m%Yi$q%Yi$s%Yi$u%Yi$w%Yi$y%Yi${%Yi$}%Yi%O%Yi%W%Yi&w%Yi'S%Yi'X%Yi'_%Yi'n%Yi's%Yi'u%Yi'v%YiY%Yi[%Yi]%Yia%Yid%Yi(P%Yi'Z%Yi~OP*XO~OP*YO'Q$aO~O'W'`O!d%Pa!e%Pa!f%Pa!g%Pa&^%Pa&c%Pa&h%Pa&t%Pa&z%Pa&{%Pa'P%Pa'Q%Pa'R%Pa'^%Pa'a%Pa'b%Pa'c%Pa'd%Pa'e%Pa'f%Pa'{%Pa'|%Pa'}%Pa(O%Pa(T%Paf%Pa']%PaP%PaV%Pa_%Pau%Pax%Paz%Pa}%Pa!O%Pa!R%Pa!U%Pa!X%Pa!n%Pa#Y%Pa#Z%Pa#x%Pa$f%Pa$i%Pa$m%Pa$q%Pa$s%Pa$u%Pa$w%Pa$y%Pa${%Pa$}%Pa%O%Pa%W%Pa&w%Pa'S%Pa'X%Pa'_%Pa'n%Pa's%Pa'u%Pa'v%PaY%Pa[%Pa]%Paa%Pad%Pa(P%Pa'Z%Pa~O'R*]O~OP*^O~OP*_O'n^O~O'W'dO!d%Vi!e%Vi!f%Vi!g%Vi&^%Vi&c%Vi&h%Vi&t%Vi&z%Vi&{%Vi'P%Vi'Q%Vi'R%Vi'^%Vi'a%Vi'b%Vi'c%Vi'd%Vi'e%Vi'f%Vi'{%Vi'|%Vi'}%Vi(O%Vi(T%Vif%Vi']%ViP%ViV%Vi_%Viu%Vix%Viz%Vi}%Vi!O%Vi!R%Vi!U%Vi!X%Vi!n%Vi#Y%Vi#Z%Vi#x%Vi$f%Vi$i%Vi$m%Vi$q%Vi$s%Vi$u%Vi$w%Vi$y%Vi${%Vi$}%Vi%O%Vi%W%Vi&w%Vi'S%Vi'X%Vi'_%Vi'n%Vi's%Vi'u%Vi'v%ViY%Vi[%Vi]%Via%Vid%Vi(P%Vi'Z%Vi~OY'iO['jO]*cO~OVtO_!POf!YOu!QOxgOz!RO}!TO!O!SO!R!UO!U!VO!X!WO!duO!euO!fYO!gYO!n!XO#YfO#ZfO#x!^O$f!ZO$i![O$mvO$qwO$sxO$u!]O$wyO$yzO${{O$}|O%O|O%W}O&hPO&tPO&w[O&zYO&{YO'PSO'QVO'RTO'SeO'^YO'_ZO'aWO'bXO'cYO'dYO'eYO'fYO'n^O's_O'u`O'vaO]&rPd&rP~OP*gO~P&FoO]*kO~O]*kOd'nO~OxwX~P$4[Ox*mO~O]{X~P$4[O]*nO~O'Q*oO~O&t%xO'W*pO']%zO~O']%uO~O]*rO~O]*tO~O]*uO~O'Q*vO~O'S*wO~O&a(SO&b(RO&f>QO&z*yO&{*yO&t'[X']'[X~O&t*zO']*|O~O]+RO~OP+SO'Y%lO~O!duO!euO!f#oO!g#pO&c#tO'P#mO'QVO'R#vO'^#jO'aWO'bWO'c#lO'd#iO'e#oO'f#nO'{#kO'|#qO'}#rO(O#sO(T#uO~O&z%qO&{%qO'W&yX&t&yX']&yX~P&MVO'W*pO~O]+YO~O]+ZO~OP%UO'P%TO~O'W(hO&h$ja&t$ja~O]+_O~O&^&rqY&rq[&rq]&rqa&rqd&rq~P]O&_7lO&g7lO~O&hPO&tPO&|!fO&}!gO~PDbO!t(vO!d!qq!e!qq!f!qq!g!qq&^!qq&_!qq&a!qq&b!qq&c!qq&f!qq&g!qq&h!qq&t!qq&z!qq&{!qq&|!qq&}!qq'P!qq'Q!qq'R!qq'W!qq'^!qq'a!qq'b!qq'c!qq'd!qq'e!qq'f!qq'{!qq'|!qq'}!qq(O!qq(T!qqf!qq']!qqP!qqV!qq_!qqu!qqx!qqz!qq}!qq!O!qq!R!qq!U!qq!X!qq!n!qq#Y!qq#Z!qq#x!qq$f!qq$i!qq$m!qq$q!qq$s!qq$u!qq$w!qq$y!qq${!qq$}!qq%O!qq%W!qq&w!qq'S!qq'X!qq'_!qq'n!qq's!qq'u!qq'v!qqY!qq[!qq]!qqa!qqd!qq(P!qq'Z!qq!w!qq~OP$OXV$OX]$OX_$OXf$OXf'`Xu$OXx$OXz$OX}$OX!O$OX!R$OX!U$OX!X$OX!d$OX!d'`X!e$OX!e'`X!f$OX!f'`X!g$OX!g'`X!n$OX#Y$OX#Z$OX#x$OX$f$OX$i$OX$m$OX$q$OX$s$OX$u$OX$w$OX$y$OX${$OX$}$OX%O$OX%W$OX&_'`X&a'`X&b'`X&c'`X&f'`X&g'`X&w$OX&z$OX&z'`X&{$OX&{'`X&|'`X&}'`X'P$OX'P'`X'Q$OX'Q'`X'R$OX'R'`X'S$OX'W'`X'X'`X'^$OX'^'`X'_$OX'a$OX'a'`X'b$OX'b'`X'c$OX'c'`X'd$OX'd'`X'e$OX'e'`X'f$OX'f'`X'n$OX's$OX'u$OX'v$OX'{'`X'|'`X'}'`X(O'`X(T'`X&t'`X']'`X~OP$OXV$OX]$OX_$OXu$OXx$OXz$OX}$OX!O$OX!R$OX!U$OX!X$OX!d!cX!e!cX!f!cX!g!cX!n$OX#Y$OX#Z$OX#x$OX$f$OX$i$OX$m$OX$q$OX$s$OX$u$OX$w$OX$y$OX${$OX$}$OX%O$OX%W$OX&_!cX&a!cX&b!cX&c!cX&f!cX&g!cX&w$OX&z!cX&{!cX&|!cX&}!cX'P!cX'Q!cX'R!cX'S$OX'W!cX'X!cX'^!cX'_$OX'a!cX'b!cX'c!cX'd!cX'e!cX'f!cX'n$OX's$OX'u$OX'v$OX'{!cX'|!cX'}!cX(O!cX(T!cX&t!cX']!cX~Of!cX~P'-lOf'TX!d'TX!e'TX!f'TX!g'TX&c'TX&z'TX&{'TX'P'TX'Q'TX'R'TX'W'TX'X'TX'^'TX'a'TX'b'TX'c'TX'd'TX'e'TX'f'TX'{'TX'|'TX'}'TX(O'TX(T'TX&t'TX']'TXP'TXV'TX]'TX_'TXu'TXx'TXz'TX}'TX!O'TX!R'TX!U'TX!X'TX!n'TX#Y'TX#Z'TX#x'TX$f'TX$i'TX$m'TX$q'TX$s'TX$u'TX$w'TX$y'TX${'TX$}'TX%O'TX%W'TX&w'TX'S'TX'_'TX'n'TX's'TX'u'TX'v'TX(P'TX'Z'TX~O&_+hO&a+jO&b+gO&f+fO&g+hO&|!fO&}!gO~P'2ZO&t+pO&|!fO&}!gO']+sO~P%(qOf'oX!d'oX!e'oX!f'oX!g'oX&_'oX&a'oX&b'oX&c'oX&d#cX&e#cX&f'oX&g'oX&z'oX&{'oX&|'oX&}'oX'P'oX'Q'oX'R'oX'W'oX'X'oX'^'oX'a'oX'b'oX'c'oX'd'oX'e'oX'f'oX'{'oX'|'oX'}'oX(O'oX(T'oX&t'oX']'oX~O(Q+vO~P'7`OP>SOVtO])OO_!POf!YOu!QOx)POz!RO}!TO!O!SO!R!UO!U!VO!X!WO!duO!euO!fYO!gYO!n!XO#Y)OO#Z)OO#x)OO$f!ZO$i![O$mVOVtO])OO_!POf!YOu!QOx)POz!RO}!TO!O!SO!R!UO!U!VO!X!WO!duO!euO!fYO!gYO!n!XO#Y)OO#Z)OO#x)OO$f!ZO$i![O$mUOVtO])OO_!POf!YOu!QOx)POz!RO}!TO!O!SO!R!UO!U!VO!X!WO!duO!euO!fYO!gYO!n!XO#Y)OO#Z)OO#x)OO$f!ZO$i![O$mvO$qwO$sxO$u!]O$wyO$yzO${{O$}|O%O|O%W}O&w({O&zYO&{YO'PSO'QVO'RTO'S(}O'^YO'_7uO'aWO'b7sO'cYO'dYO'eYO'fYO'n^O's_O'u`O'vaO~O'X.}O~P)/`O'W/OO'X.}O~OV/SOf,jO'W'xX'X'xX~OPCxOVtO])OO_!POf!YOu!QOx)POz!RO}!TO!O!SO!R!UO!U!VO!X!WO!duO!euO!fYO!gYO!n!XO#Y)OO#Z)OO#x)OO$f!ZO$i![O$mvO$qUOVtO])OO_!POf!YOu!QOx)POz!RO}!TO!O!SO!R!UO!U!VO!X!WO!duO!euO!fYO!gYO!n!XO#Y)OO#Z)OO#x)OO$f!ZO$i![O$mvO$qxO'aWO'bWO'c?QO'd>tO'e?^O'f?YO'{>|O'|?fO'}?jO(ODSO(T#uO~OV!kaf!ka&t!ka']!ka'X!ka~P):yO'W,rOV!jif!ji&t!ji']!ji'X!ji~O&t&xq&t'hq']&xq']'hq~O&|!fO&}!gO~P!$}O&t'hi']'hi~P!D{O!duO!euO!f?_O!g?cO&c#tO'P?VO'QVO'R?oO'^>yO'aWO'bWO'c?RO'd>uO'e?_O'f?ZO'{>}O'|?gO'}?kO(ODTO(T#uO~O']/nO~P)=vO&^%ci&h%ci&t%ci'W%ci'f%ciY%ci[%ci]%cia%cid%ci'Z%ci']%ci'X%ci(P%ci~P%CRO&z#hO&{#hO&^%gy&h%gy&t%gyY%gy[%gy]%gya%gyd%gy~P#FTO&z/pO&{/pO~O&i(oO'P%TO'R7oO~O!duO!euO&c#tO'QVO'aWO'bWO(T#uO&^%ay&h%ay&t%ay&z%ay&{%ay'W%ay'f%ay'{%ayY%ay[%ay]%aya%ayd%ay']%ay'Z%ay'X%ay(P%ay~O!f#oO!g#pO'P#mO'R#vO'^#jO'c#lO'd#iO'e#oO'|#qO'}#rO(O#sO~P)AfOP'^O&g!nO'Q$aO~O%S/tO'W/rO!d(WX!e(WX!f(WX!g(WX&^(WX&c(WX&h(WX&t(WX&z(WX&{(WX'P(WX'R(WX'^(WX'a(WX'b(WX'c(WX'd(WX'e(WX'f(WX'{(WX'|(WX'}(WX(O(WX(T(WXf(WX'](WXP(WXV(WX_(WXu(WXx(WXz(WX}(WX!O(WX!R(WX!U(WX!X(WX!n(WX#Y(WX#Z(WX#x(WX$f(WX$i(WX$m(WX$q(WX$s(WX$u(WX$w(WX$y(WX${(WX$}(WX%O(WX%W(WX&w(WX'S(WX'X(WX'_(WX'n(WX's(WX'u(WX'v(WXY(WX[(WX](WXa(WXd(WX(P(WX'Z(WX~O'Q'_O~P)DUO%S/tO'Q'_O~O'W/rO!d(WX!e(WX!f(WX!g(WX&^(WX&c(WX&h(WX&t(WX&z(WX&{(WX'P(WX'Q(WX'R(WX'^(WX'a(WX'b(WX'c(WX'd(WX'e(WX'f(WX'{(WX'|(WX'}(WX(O(WX(T(WXf(WX'](WXP(WXV(WX_(WXu(WXx(WXz(WX}(WX!O(WX!R(WX!U(WX!X(WX!n(WX#Y(WX#Z(WX#x(WX$f(WX$i(WX$m(WX$q(WX$s(WX$u(WX$w(WX$y(WX${(WX$}(WX%O(WX%W(WX&w(WX'S(WX'X(WX'_(WX'n(WX's(WX'u(WX'v(WXY(WX[(WX](WXa(WXd(WX(P(WX'Z(WX~O'Q(WX~P)DUO&t&xi']&xi~P!D{O&z/vO&{/vO'W/wO'X/yO~P'D^O'X/yO~O'W/zO'X/yO~O'W/wO'X/yO~O&a(SO&b(RO&f>QO&t!bi']!bi~O&|!fO&}!gO'PCVO'R=hO']/{O~P!7^O]/}O~O]0OO~O'W-yOP!uaV!ua]!ua_!uaf!uau!uax!uaz!ua}!ua!O!ua!R!ua!U!ua!X!ua!d!ua!e!ua!f!ua!g!ua!n!ua#Y!ua#Z!ua#x!ua$f!ua$i!ua$m!ua$q!ua$s!ua$u!ua$w!ua$y!ua${!ua$}!ua%O!ua%W!ua&h!ua&t!ua&w!ua&z!ua&{!ua'P!ua'Q!ua'R!ua'S!ua'^!ua'_!ua'a!ua'b!ua'c!ua'd!ua'e!ua'f!ua'n!ua's!ua'u!ua'v!ua~O]0RO~O&i(oO'P=jO'R(pO'n^O&_#Ua&g#Ua~O'W0WO'X0VO~P%(qO&t+pO&|!fO&}!gO']0[O~P%(qO!t(vOf#Ti!d#Ti!e#Ti!f#Ti!g#Ti&_#Ti&a#Ti&b#Ti&c#Ti&f#Ti&g#Ti&z#Ti&{#Ti&|#Ti&}#Ti'P#Ti'Q#Ti'R#Ti'W#Ti'X#Ti'^#Ti'a#Ti'b#Ti'c#Ti'd#Ti'e#Ti'f#Ti'{#Ti'|#Ti'}#Ti(O#Ti(T#Ti&t#Ti']#TiP#TiV#Ti]#Ti_#Tiu#Tix#Tiz#Ti}#Ti!O#Ti!R#Ti!U#Ti!X#Ti!n#Ti#Y#Ti#Z#Ti#x#Ti$f#Ti$i#Ti$m#Ti$q#Ti$s#Ti$u#Ti$w#Ti$y#Ti${#Ti$}#Ti%O#Ti%W#Ti&w#Ti'S#Ti'_#Ti'n#Ti's#Ti'u#Ti'v#Ti(P#Ti'Z#Ti~O&|!fO&}!gO~P)6|O&|!fO&}!gO&t'qa&t'wa']'qa']'wa~P%(qO'W0dO&t'qa&t'wa']'qa']'wa~OPCxOVtO])OO_!POf!YOu!QOx)POz!RO}!TO!O!SO!R!UO!U!VO!X!WO!duO!euO!fYO!gYO!n!XO#Y)OO#Z)OO#x)OO$f!ZO$i![O$mvO$qTOVtO])OO_!POf!YOu!QOx)POz!RO}!TO!O!SO!R!UO!U!VO!X!WO!duO!euO!fYO!gYO!n!XO#Y)OO#Z)OO#x)OO$f!ZO$i![O$m`O&{>`O&t'rX']'rX~P+:uO']1vO~P*,bO&|!fO&}!gO&t'qa']'qa~P%(qO'W1yO&t'qa']'qa~O'W%xa'X%xa~P+)eO'X1|O~P)6|O'X2OO~P(NjO!duO!euO!f9_O!g9fO&c,eO'P9PO'QVO'R9{O'^8jO'aWO'bWO'c8xO'd8cO'e9_O'{8qO'|9mO'}9tO(OCdO(T,fO~OP&PaV&Pa]&Pa_&Paf&Pau&Pax&Paz&Pa}&Pa!O&Pa!R&Pa!U&Pa!X&Pa!n&Pa#Y&Pa#Z&Pa#x&Pa$f&Pa$i&Pa$m&Pa$q&Pa$s&Pa$u&Pa$w&Pa$y&Pa${&Pa$}&Pa%O&Pa%W&Pa&w&Pa&z&Pa&{&Pa'S&Pa'W&Pa'X&Pa'_&Pa'f&Pa'n&Pa's&Pa'u&Pa'v&Pa&t&Pa']&Pa(P&Pa'Z&Pa~P+=sO&z.vO&{.vO'W.tOP#{iV#{i]#{i_#{if#{iu#{ix#{iz#{i}#{i!O#{i!R#{i!U#{i!X#{i!n#{i#Y#{i#Z#{i#x#{i$f#{i$i#{i$m#{i$q#{i$s#{i$u#{i$w#{i$y#{i${#{i$}#{i%O#{i%W#{i&w#{i'S#{i'X#{i'_#{i'f#{i'n#{i's#{i'u#{i'v#{i&t#{i']#{i(P#{i'Z#{i~P+=sO&z.vO&{.vOP#{iV#{i]#{i_#{if#{iu#{ix#{iz#{i}#{i!O#{i!R#{i!U#{i!X#{i!d#{i!e#{i!f#{i!g#{i!n#{i#Y#{i#Z#{i#x#{i$f#{i$i#{i$m#{i$q#{i$s#{i$u#{i$w#{i$y#{i${#{i$}#{i%O#{i%W#{i&c#{i&w#{i'P#{i'Q#{i'R#{i'S#{i'W#{i'X#{i'^#{i'_#{i'a#{i'b#{i'c#{i'd#{i'e#{i'f#{i'n#{i's#{i'u#{i'v#{i'{#{i'|#{i'}#{i(O#{i(T#{i&t#{i']#{i(P#{i'Z#{i~O!duO!euO!f9aO!g9hO&c,eO'P9RO'QVO'R9}O'^8lO'aWO'bWO'c8zO'd8eO'e9aO'f9YO'{8sO'|9oO'}9vO(OCfO(T,fO~OV#qaf#qa'W#qa'X#qa~P+I^O'W2SO~O'W1]OV#lif#li'X#li&t#li']#li~O&z#hO&{#hO&^%g!Z&h%g!Z&t%g!ZY%g!Z[%g!Z]%g!Za%g!Zd%g!Z~P#FTO%S/tO!d&Ya!e&Ya!f&Ya!g&Ya&^&Ya&c&Ya&h&Ya&t&Ya&z&Ya&{&Ya'P&Ya'R&Ya'W&Ya'^&Ya'a&Ya'b&Ya'c&Ya'd&Ya'e&Ya'f&Ya'{&Ya'|&Ya'}&Ya(O&Ya(T&Yaf&Ya']&YaP&YaV&Ya_&Yau&Yax&Yaz&Ya}&Ya!O&Ya!R&Ya!U&Ya!X&Ya!n&Ya#Y&Ya#Z&Ya#x&Ya$f&Ya$i&Ya$m&Ya$q&Ya$s&Ya$u&Ya$w&Ya$y&Ya${&Ya$}&Ya%O&Ya%W&Ya&w&Ya'S&Ya'X&Ya'_&Ya'n&Ya's&Ya'u&Ya'v&YaY&Ya[&Ya]&Yaa&Yad&Ya(P&Ya'Z&Ya~O'Q'_O~P+L]O'Q&Ya~P+L]O'W!]i'X!]i~P+)eO'X2XO~P)/`O'X2YO~P)/`O'W2ZO'X2YO~O&|!fO&}!gO'Z2_O~P)6|O'W2`O'Z2_O~O&t'qq&t'wq']'qq']'wq~O&|!fO&}!gO~P)/`O&|!fO&}!gO&t'qi']'qi~P%(qOf$Si'W$Si'X$Si'f$Si&t$Si']$Si~P*5lO'W!^i'X!^i~P+)eO!duO!euO&c,eO'QVO'aWO'bWO(T,fOf$Qy&z$Qy&{$Qy'W$Qy'X$Qy'f$Qy'{$Qy&t$Qy']$Qy~O!f,`O!g,aO'P,^O'R,kO'^,ZO'c,]O'd,YO'e,`O'|,bO'},cO(O,dO~P,%zO&|!fO&}!gO&t'wa']'wa~P%(qO'W2dO&t'wa']'wa~OV#mif#mi'W#mi'X#mi&t#mi']#mi~P+I^O'X2eO~P)/`O'W#Qi'X#Qi~P+)eO'W%}a'Z%}a~P+)eO&|!fO&}!gO'Z2fO~P)6|O&|!fO&}!gO&t'wi']'wi~P%(qOP%_XV%_X_%_Xf%_Xf'`Xu%_Xx%_Xz%_X}%_X!O%_X!R%_X!U%_X!X%_X!d%_X!d'`X!e%_X!e'`X!f%_X!f'`X!g%_X!g'`X!n%_X#Y%_X#Z%_X#x%_X$f%_X$i%_X$m%_X$q%_X$s%_X$u%_X$w%_X$y%_X${%_X$}%_X%O%_X%W%_X&_'`X&a'`X&b'`X&c'`X&f'`X&g'`X&t'`X&w%_X&z%_X&z'`X&{%_X&{'`X&|'`X&}'`X'P%_X'P'`X'Q%_X'Q'`X'R%_X'R'`X'S%_X'W'`X']'`X'^%_X'^'`X'_%_X'a%_X'a'`X'b%_X'b'`X'c%_X'c'`X'd%_X'd'`X'e%_X'e'`X'f%_X'f'`X'n%_X's%_X'u%_X'v%_X'{'`X'|'`X'}'`X(O'`X(T'`X'X'`X~OP'`XV'`X_'`Xf'`Xu'`Xx'`Xz'`X}'`X!O'`X!R'`X!U'`X!X'`X!n'`X#Y'`X#Z'`X#x'`X$f'`X$i'`X$m'`X$q'`X$s'`X$u'`X$w'`X$y'`X${'`X$}'`X%O'`X%W'`X&w'`X'S'`X'_'`X'n'`X's'`X'u'`X'v'`X~P0TOV'`X~P,*SOP%_XV%_X_%_Xf%_Xu%_Xx%_Xz%_X}%_X!O%_X!R%_X!U%_X!X%_X!d%_X!d'`X!e%_X!e'`X!f%_X!f'`X!g%_X!g'`X!n%_X#Y%_X#Z%_X#x%_X$f%_X$i%_X$m%_X$q%_X$s%_X$u%_X$w%_X$y%_X${%_X$}%_X%O%_X%W%_X&_'`X&a'`X&b'`X&c'`X&f'`X&g'`X&t'`X&w%_X&z%_X&{%_X&|'`X&}'`X'P%_X'P'`X'Q%_X'Q'`X'R%_X'R'`X'S%_X']'`X'^%_X'^'`X'_%_X'a%_X'a'`X'b%_X'b'`X'c%_X'c'`X'd%_X'd'`X'e%_X'e'`X'f%_X'f'`X'n%_X's%_X'u%_X'v%_X'{'`X'|'`X'}'`X(O'`X(T'`X'X'`X'W'`X~OV'`Xf'`X~P,2XO(P'`X'Z'`X&h'`X~P,2XOP%_X_%_Xf!cXu%_Xx%_Xz%_X}%_X!O%_X!R%_X!U%_X!X%_X!d!cX!e!cX!f!cX!g!cX!n%_X#Y%_X#Z%_X#x%_X$f%_X$i%_X$m%_X$q%_X$s%_X$u%_X$w%_X$y%_X${%_X$}%_X%O%_X%W%_X&_!cX&a!cX&b!cX&c!cX&f!cX&g!cX&t!cX&w%_X&z!cX&{!cX&|!cX&}!cX'P!cX'Q!cX'R!cX'S%_X'W!cX']!cX'^!cX'_%_X'a!cX'b!cX'c!cX'd!cX'e!cX'f!cX'n%_X's%_X'u%_X'v%_X'{!cX'|!cX'}!cX(O!cX(T!cX'X!cX~OV%_X~P,8SOV!cX~P,8SOP%_X_%_Xu%_Xx%_Xz%_X}%_X!O%_X!R%_X!U%_X!X%_X!d!cX!e!cX!f!cX!g!cX!n%_X#Y%_X#Z%_X#x%_X$f%_X$i%_X$m%_X$q%_X$s%_X$u%_X$w%_X$y%_X${%_X$}%_X%O%_X%W%_X&_!cX&a!cX&b!cX&c!cX&f!cX&g!cX&t!cX&w%_X&z%_X&{%_X&|!cX&}!cX'P!cX'Q!cX'R!cX'S%_X']!cX'^!cX'_%_X'a!cX'b!cX'c!cX'd!cX'e!cX'f!cX'n%_X's%_X'u%_X'v%_X'{!cX'|!cX'}!cX(O!cX(T!cX'X!cX'W!cX~OV!cXf!cX~P,hO!d$pa!d'OX!e$pa!e'OX!f$pa!f'OX!g$pa!g'OX&c$pa&c'OX&z'OX&{'OX&|'OX&}'OX'P$pa'P'OX'Q$pa'Q'OX'R$pa'R'OX'W'OX'^$pa'^'OX'a$pa'a'OX'b$pa'b'OX'c$pa'c'OX'd$pa'd'OX'e$pa'e'OX'f$pa'f'OX'{$pa'{'OX'|$pa'|'OX'}$pa'}'OX(O$pa(O'OX(P$pa(T$pa(T'OXV$paf$pa&t$pa']$pa'X$pa~P$>hO!d$pa!d'OX!e$pa!e'OX!f$pa!f'OX!g$pa!g'OX&c$pa&c'OX&z'OX&{'OX&|'OX&}'OX'P$pa'P'OX'Q$pa'Q'OX'R$pa'R'OX'W$pa'W'OX'Z$pa'^$pa'^'OX'a$pa'a'OX'b$pa'b'OX'c$pa'c'OX'd$pa'd'OX'e$pa'e'OX'f$pa'f'OX'{$pa'{'OX'|$pa'|'OX'}$pa'}'OX(O$pa(O'OX(T$pa(T'OX&t$pa']$pa'X$pa(P$pa&h$paV$paf$pa~P$>hO(Q#[OP$raV$raY$ra[$ra]$ra_$raf$rau$rax$raz$ra}$ra!O$ra!R$ra!U$ra!X$ra!d$ra!d'OX!e$ra!e'OX!f$ra!f'OX!g$ra!g'OX!n$ra#Y$ra#Z$ra#x$ra$f$ra$i$ra$m$ra$q$ra$s$ra$u$ra$w$ra$y$ra${$ra$}$ra%O$ra%W$ra&c$ra&c'OX&h$ra&t$ra&w$ra&z$ra&z'OX&{$ra&{'OX'P$ra'P'OX'Q$ra'Q'OX'R$ra'R'OX'S$ra'W'OX'^$ra'^'OX'_$ra'a$ra'a'OX'b$ra'b'OX'c$ra'c'OX'd$ra'd'OX'e$ra'e'OX'f$ra'f'OX'n$ra's$ra'u$ra'v$ra'{$ra'{'OX'|$ra'|'OX'}$ra'}'OX(O$ra(O'OX(T$ra(T'OX'X$ra']$ra(P$ra~P$:YO(Q#[O!d$ra!d'OX!e$ra!e'OX!f$ra!f'OX!g$ra!g'OX&c$ra&c'OX&z'OX&{'OX'P$ra'P'OX'Q$ra'Q'OX'R$ra'R'OX'W'OX'^$ra'^'OX'a$ra'a'OX'b$ra'b'OX'c$ra'c'OX'd$ra'd'OX'e$ra'e'OX'f$ra'f'OX'{$ra'{'OX'|$ra'|'OX'}$ra'}'OX(O$ra(O'OX(P$ra(T$ra(T'OXV$raf$ra&t$ra']$ra'X$ra~P$:YO(Q#[O!d$ra!d'OX!e$ra!e'OX!f$ra!f'OX!g$ra!g'OX&c$ra&c'OX&z'OX&{'OX'P$ra'P'OX'Q$ra'Q'OX'R$ra'R'OX'W$ra'W'OX'Z$ra'^$ra'^'OX'a$ra'a'OX'b$ra'b'OX'c$ra'c'OX'd$ra'd'OX'e$ra'e'OX'f$ra'f'OX'{$ra'{'OX'|$ra'|'OX'}$ra'}'OX(O$ra(O'OX(T$ra(T'OX&t$ra']$ra'X$ra(P$ra&h$raV$raf$ra~P$:YOP$raV$raY$ra[$ra]$ra_$raf$rau$rax$raz$ra}$ra!O$ra!R$ra!U$ra!X$ra!d$ra!d'OX!e$ra!e'OX!f$ra!f'OX!g$ra!g'OX!n$ra#Y$ra#Z$ra#x$ra$f$ra$i$ra$m$ra$q$ra$s$ra$u$ra$w$ra$y$ra${$ra$}$ra%O$ra%W$ra&c$ra&c'OX&h$ra&t$ra&w$ra&z$ra&z'OX&{$ra&{'OX&|'OX&}'OX'P$ra'P'OX'Q$ra'Q'OX'R$ra'R'OX'S$ra'W'OX'^$ra'^'OX'_$ra'a$ra'a'OX'b$ra'b'OX'c$ra'c'OX'd$ra'd'OX'e$ra'e'OX'f$ra'f'OX'n$ra's$ra'u$ra'v$ra'{$ra'{'OX'|$ra'|'OX'}$ra'}'OX(O$ra(O'OX(T$ra(T'OX'X$ra']$ra(P$ra~P$>hO!d$ra!d'OX!e$ra!e'OX!f$ra!f'OX!g$ra!g'OX&c$ra&c'OX&z'OX&{'OX&|'OX&}'OX'P$ra'P'OX'Q$ra'Q'OX'R$ra'R'OX'W'OX'^$ra'^'OX'a$ra'a'OX'b$ra'b'OX'c$ra'c'OX'd$ra'd'OX'e$ra'e'OX'f$ra'f'OX'{$ra'{'OX'|$ra'|'OX'}$ra'}'OX(O$ra(O'OX(P$ra(T$ra(T'OXV$raf$ra&t$ra']$ra'X$ra~P$>hO!d$ra!d'OX!e$ra!e'OX!f$ra!f'OX!g$ra!g'OX&c$ra&c'OX&z'OX&{'OX&|'OX&}'OX'P$ra'P'OX'Q$ra'Q'OX'R$ra'R'OX'W$ra'W'OX'Z$ra'^$ra'^'OX'a$ra'a'OX'b$ra'b'OX'c$ra'c'OX'd$ra'd'OX'e$ra'e'OX'f$ra'f'OX'{$ra'{'OX'|$ra'|'OX'}$ra'}'OX(O$ra(O'OX(T$ra(T'OX&t$ra']$ra'X$ra(P$ra&h$raV$raf$ra~P$>hO'W3XOf$za&t$za&z$za&{$za']$za'X$za~P!BgO!f4`O!g4gO'P4QO'R4|O'W3UO'^3kO'c3yO'd3dO'e4`O'f4XO'{3rO'|4nO'}4uO(OCZOP$zaV$za_$zaf$zau$zax$zaz$za}$za!O$za!R$za!U$za!X$za!n$za#Y$za#Z$za#x$za$f$za$i$za$m$za$q$za$s$za$u$za$w$za$y$za${$za$}$za%O$za%W$za&w$za'S$za'_$za'n$za's$za'u$za'v$za~P$'lO!duO!euO!f4aO!g4hO&c#tO'P4RO'QVO'R4}O'^3lO'aWO'bWO'c3zO'd3eO'e4aO'f4YO'{3sO'|4oO'}4vO(OC[O(T#uO~O'W3VOV$zaf$za&t$za&z$za&{$za']$za'X$za~P.WO'W3YO(P$za'Z$za&t$za']$za'X$za&h$za~P'FwO&_ni~P$4_O&_!iO&g!iO&|!fO&}!gO~P$FcO&_qi~P$4_O&_!iO&g!iO&|!fO&}!gO~P$KmOP!hiV!hi]!hi_!hif!hiu!hix!hiz!hi}!hi!O!hi!R!hi!U!hi!X!hi!d!hi!e!hi!f!hi!g!hi!n!hi!w!hi#Y!hi#Z!hi#x!hi$f!hi$i!hi$m!hi$q!hi$s!hi$u!hi$w!hi$y!hi${!hi$}!hi%O!hi%W!hi&h!hi&t!hi&w!hi&z!hi&{!hi'P!hi'Q!hi'R!hi'S!hi'^!hi'_!hi'a!hi'b!hi'c!hi'd!hi'e!hi'f!hi'n!hi's!hi'u!hi'v!hi~P%=]O&z8QO&{8QOf%bi&t%bi'W%bi']%bi'X%bi~P!BgO&z8RO&{8ROP%biV%bi_%bif%biu%bix%biz%bi}%bi!O%bi!R%bi!U%bi!X%bi!n%bi#Y%bi#Z%bi#x%bi$f%bi$i%bi$m%bi$q%bi$s%bi$u%bi$w%bi$y%bi${%bi$}%bi%O%bi%W%bi&t%bi&w%bi'S%bi'W%bi'X%bi'_%bi'n%bi's%bi'u%bi'v%bi&^%bi&h%bi']%biY%bi[%bi]%bia%bid%bi(P%bi'Z%bi~P(8YO&z8SO&{8SOV%bif%bi&t%bi'W%bi']%bi'X%bi~P.WO'f4[O~P/J|O'W%`i'Z%`i&t%`i']%`i'X%`i(P%`i&h%`i~P'FwO(P%`i~P&3wO&c#tO'P4PO'QVO'R4{O'^3jO'aWO'bWO'c3xO'd3cO(T#uOf%`i!d%`i!e%`i&t%`i&z%`i&{%`i'W%`i']%`i'e%`i'f%`i'{%`i'|%`i'}%`i(O%`i'X%`i~O!f4_O!g4fO~P09VO&c#tO'P4QO'QVO'R4|O'^3kO'aWO'bWO'c3yO'd3dO(T#uOP%`iV%`i_%`if%`iu%`ix%`iz%`i}%`i!O%`i!R%`i!U%`i!X%`i!d%`i!e%`i!n%`i#Y%`i#Z%`i#x%`i$f%`i$i%`i$m%`i$q%`i$s%`i$u%`i$w%`i$y%`i${%`i$}%`i%O%`i%W%`i&t%`i&w%`i&z%`i&{%`i'S%`i'W%`i'X%`i'_%`i'e%`i'f%`i'n%`i's%`i'u%`i'v%`i'{%`i'|%`i'}%`i(O%`i&^%`i&h%`i']%`iY%`i[%`i]%`ia%`id%`i(P%`i'Z%`i~O!f4`O!g4gO~P0;QO&c#tO'P4RO'QVO'R4}O'^3lO'aWO'bWO'c3zO'd3eO(T#uOV%`if%`i!d%`i!e%`i&t%`i&z%`i&{%`i'W%`i']%`i'e%`i'f%`i'{%`i'|%`i'}%`i(O%`i'X%`i~O!f4aO!g4hO~P0?rO&c#tO'P4SO'QVO'R5OO'^3mO'aWO'bWO'c3{O'd3fO(T#uOV%`if%`i!d%`i!e%`i&t%`i'W%`i']%`i'e%`i'f%`i'{%`i'|%`i'}%`i(O%`i'X%`i~O!f4bO!g4iO~P0ApO&c#tO'P4TO'QVO'R5PO'^3nO'aWO'bWO'c3|O'd3gO(T#uOP%`iV%`iY%`i[%`i]%`i_%`if%`iu%`ix%`iz%`i}%`i!O%`i!R%`i!U%`i!X%`i!d%`i!e%`i!n%`i#Y%`i#Z%`i#x%`i$f%`i$i%`i$m%`i$q%`i$s%`i$u%`i$w%`i$y%`i${%`i$}%`i%O%`i%W%`i&h%`i&t%`i&w%`i&z%`i&{%`i'S%`i'_%`i'e%`i'f%`i'n%`i's%`i'u%`i'v%`i'{%`i'|%`i'}%`i(O%`i~O!f4cO!g4jO~P0ChO&c#tO'P4UO'QVO'R5QO'^3oO'aWO'bWO'c3}O'd3hO(T#uO!d%`i!e%`i'W%`i'Z%`i'e%`i'f%`i'{%`i'|%`i'}%`i(O%`i&t%`i']%`i'X%`i(P%`i&h%`i~O!f4dO!g4kO~P0GpO&c#tO'P4VO'QVO'R5RO'^3pO'aWO'bWO'c4OO'd3iO(T#uO!d%`i!e%`i'e%`i'f%`i'{%`i'|%`i'}%`i(O%`i(P%`i~O!f4eO!g4lO~P0IkO!f%`i!g%`i~P09VO!f%`i!g%`i~P0;QO!f%`i!g%`i~P0?rO!f%`i!g%`i~P0ApO!f%`i!g%`i~P0ChO!f%`i!g%`i~P0GpO!f%`i!g%`i~P0IkO!duO!euO!f4_O!g4fO&c#tO'P4PO'QVO'R4{O'^3jO'aWO'bWO'c3xO'd3cO'e4_O'}4tO(T#uOf%`i&t%`i&z%`i&{%`i'W%`i']%`i'f%`i'{%`i(O%`i'X%`i~O'|4mO~P0LlO!duO!euO!f4`O!g4gO&c#tO'P4QO'QVO'R4|O'^3kO'aWO'bWO'c3yO'd3dO'e4`O'}4uO(T#uOP%`iV%`i_%`if%`iu%`ix%`iz%`i}%`i!O%`i!R%`i!U%`i!X%`i!n%`i#Y%`i#Z%`i#x%`i$f%`i$i%`i$m%`i$q%`i$s%`i$u%`i$w%`i$y%`i${%`i$}%`i%O%`i%W%`i&t%`i&w%`i&z%`i&{%`i'S%`i'W%`i'X%`i'_%`i'f%`i'n%`i's%`i'u%`i'v%`i'{%`i(O%`i&^%`i&h%`i']%`iY%`i[%`i]%`ia%`id%`i(P%`i'Z%`i~O'|4nO~P0NgO!duO!euO!f4aO!g4hO&c#tO'P4RO'QVO'R4}O'^3lO'aWO'bWO'c3zO'd3eO'e4aO'}4vO(T#uOV%`if%`i&t%`i&z%`i&{%`i'W%`i']%`i'f%`i'{%`i(O%`i'X%`i~O'|4oO~P1%XO!duO!euO!f4bO!g4iO&c#tO'P4SO'QVO'R5OO'^3mO'aWO'bWO'c3{O'd3fO'e4bO'}4wO(T#uOV%`if%`i&t%`i'W%`i']%`i'f%`i'{%`i(O%`i'X%`i~O'|4pO~P1'VO!duO!euO!f4cO!g4jO&c#tO'P4TO'QVO'R5PO'^3nO'aWO'bWO'c3|O'd3gO'e4cO'}4xO(T#uOP%`iV%`iY%`i[%`i]%`i_%`if%`iu%`ix%`iz%`i}%`i!O%`i!R%`i!U%`i!X%`i!n%`i#Y%`i#Z%`i#x%`i$f%`i$i%`i$m%`i$q%`i$s%`i$u%`i$w%`i$y%`i${%`i$}%`i%O%`i%W%`i&h%`i&t%`i&w%`i&z%`i&{%`i'S%`i'_%`i'f%`i'n%`i's%`i'u%`i'v%`i'{%`i(O%`i~O'|4qO~P1(}O!duO!euO!f4dO!g4kO&c#tO'P4UO'QVO'R5QO'^3oO'aWO'bWO'c3}O'd3hO'e4dO'}4yO(T#uO'W%`i'Z%`i'f%`i'{%`i(O%`i&t%`i']%`i'X%`i(P%`i&h%`i~O'|4rO~P1-VO!duO!euO!f4eO!g4lO&c#tO'P4VO'QVO'R5RO'^3pO'aWO'bWO'c4OO'd3iO'e4eO'}4zO(T#uO'f%`i'{%`i(O%`i(P%`i~O'|4sO~P1/QO'|%`i~P0LlO'|%`i~P0NgO'|%`i~P1%XO'|%`i~P1'VO'|%`i~P1(}O'|%`i~P1-VO'|%`i~P1/QO&c#tO'QVO'aWO'bWO(T#uOf%`i!d%`i!e%`i!f%`i!g%`i&t%`i&z%`i&{%`i'R%`i'W%`i']%`i'e%`i'f%`i'{%`i'|%`i'}%`i(O%`i'X%`i~O'P4PO'^3jO'c3xO'd3cO~P11lO'P4QO'^3kO'c3yO'd3dOP%`iV%`i_%`if%`iu%`ix%`iz%`i}%`i!O%`i!R%`i!U%`i!X%`i!n%`i#Y%`i#Z%`i#x%`i$f%`i$i%`i$m%`i$q%`i$s%`i$u%`i$w%`i$y%`i${%`i$}%`i%O%`i%W%`i&w%`i'S%`i'_%`i'n%`i's%`i'u%`i'v%`i~P&5`O'P4RO'^3lO'c3zO'd3eOV%`i~P11lO'P4SO'QVO'aWO'bWO~P0-UO'P4TO'QVO'aWO'bWO~P0.|O'P4UO'QVO'aWO'bWO~P03UO&c#tO'QVO'aWO'bWO(T#uO!d%`i!e%`i!f%`i!g%`i'R%`i'e%`i'f%`i'{%`i'|%`i'}%`i(O%`i(P%`i~O'P4VO'^3pO'c4OO'd3iO~P17kO&_(PO&g(PO~O&_7kO&g7kO~OP'`XV'`X]'`X_'`Xu'`Xx'`Xz'`X}'`X!O'`X!R'`X!U'`X!X'`X!n'`X#Y'`X#Z'`X#x'`X$f'`X$i'`X$m'`X$q'`X$s'`X$u'`X$w'`X$y'`X${'`X$}'`X%O'`X%W'`X&w'`X'S'`X'_'`X'n'`X's'`X'u'`X'v'`X(P'`X'Z'`X~P''|OV'`X~P''|OP$OXV$OX]$OX_$OXf$OXu$OXx$OXz$OX}$OX!O$OX!R$OX!U$OX!X$OX!d$OX!d'`X!e$OX!e'`X!f$OX!f'`X!g$OX!g'`X!n$OX#Y$OX#Z$OX#x$OX$f$OX$i$OX$m$OX$q$OX$s$OX$u$OX$w$OX$y$OX${$OX$}$OX%O$OX%W$OX&_'`X&a'`X&b'`X&c'`X&f'`X&g'`X&w$OX&z$OX&{$OX&|'`X&}'`X'P$OX'P'`X'Q$OX'Q'`X'R$OX'R'`X'S$OX'W'`X'X'`X'^$OX'^'`X'_$OX'a$OX'a'`X'b$OX'b'`X'c$OX'c'`X'd$OX'd'`X'e$OX'e'`X'f$OX'f'`X'n$OX's$OX'u$OX'v$OX'{'`X'|'`X'}'`X(O'`X(T'`X&t'`X']'`X~OV'`Xf'`X~P1TOVtO])OO_!POf!YOu!QOx)POz!RO}!TO!O!SO!R!UO!U!VO!X!WO!duO!euO!fYO!gYO!n!XO#Y)OO#Z)OO#x)OO$f!ZO$i![O$mWO&z8QO&{8QOf%ci&t%ci'W%ci']%ci'f%ci'X%ci~P/)_O!duO!euO&c#tO'QVO'aWO'bWO(T#uOP%ciV%ci_%cif%ciu%cix%ciz%ci}%ci!O%ci!R%ci!U%ci!X%ci!n%ci#Y%ci#Z%ci#x%ci$f%ci$i%ci$m%ci$q%ci$s%ci$u%ci$w%ci$y%ci${%ci$}%ci%O%ci%W%ci&t%ci&w%ci'S%ci'_%ci'f%ci'n%ci's%ci'u%ci'v%ci&h%ciY%ci[%ci]%ci~O!f4`O!g4gO&z8RO&{8RO'P4QO'R4|O'^3kO'c3yO'd3dO'e4`O'{3rO'|4nO'}4uO(OCZO'W%ci'X%ci&^%ci']%cia%cid%ci(P%ci'Z%ci~P2!hO&z8SO&{8SOV%cif%ci&t%ci'W%ci']%ci'f%ci'X%ci~P/#ZO!f4cO!g4jO&z8TO&{8TO'P4TO'R5PO'^3nO'c3|O'd3gO'e4cO'{3uO'|4qO'}4xO(OC^O~P2!hO!duO!euO&c#tO'QVO'aWO'bWO(T#uOf%ay&t%ay&z%ay&{%ay'W%ay']%ay'f%ay'{%ay'X%ay~O!f4_O!g4fO'P4PO'R4{O'^3jO'c3xO'd3cO'e4_O'|4mO'}4tO(OCYO~P2(yO!f4`O!g4gO'P4QO'R4|O'^3kO'c3yO'd3dO'e4`O'|4nO'}4uO(OCZOP%ayV%ay_%ayf%ayu%ayx%ayz%ay}%ay!O%ay!R%ay!U%ay!X%ay!n%ay#Y%ay#Z%ay#x%ay$f%ay$i%ay$m%ay$q%ay$s%ay$u%ay$w%ay$y%ay${%ay$}%ay%O%ay%W%ay&w%ay'S%ay'_%ay'n%ay's%ay'u%ay'v%ay~P)AfO!f4aO!g4hO'P4RO'R4}O'^3lO'c3zO'd3eO'e4aO'|4oO'}4vO(OC[OV%ay~P2(yO!duO!euO&c#tO'QVO'aWO'bWO(T#uOV%ayf%ay&t%ay']%ay'f%ay'{%ay'X%ay~O!f4bO!g4iO'P4SO'R5OO'^3mO'c3{O'd3fO'e4bO'|4pO'}4wO(OC]O'W%ay~P2.rO!duO!euO&c#tO'QVO'aWO'bWO(T#uOP%ayV%ay_%ayf%ayu%ayx%ayz%ay}%ay!O%ay!R%ay!U%ay!X%ay!n%ay#Y%ay#Z%ay#x%ay$f%ay$i%ay$m%ay$q%ay$s%ay$u%ay$w%ay$y%ay${%ay$}%ay%O%ay%W%ay&t%ay&w%ay&z%ay&{%ay'S%ay'_%ay'f%ay'n%ay's%ay'u%ay'v%ay'{%ay~O!f4cO!g4jO'P4TO'R5PO'^3nO'c3|O'd3gO'e4cO'|4qO'}4xO(OC^OY%ay[%ay]%ay&h%ay~P20jO!duO!euO&c#tO'QVO'aWO'bWO(T#uO'f%ay'{%ay&t%ay']%ay(P%ay~O!f4dO!g4kO'P4UO'R5QO'^3oO'c3}O'd3hO'e4dO'|4rO'}4yO(OC_O'W%ay'Z%ay'X%ay&h%ay~P24rO!duO!euO!f4eO!g4lO&c#tO'P4VO'QVO'R5RO'^3pO'aWO'bWO'c4OO'd3iO'e4eO'|4sO'}4zO(OC`O(T#uO~O'f%ay'{%ay(P%ay~P26mO&z;{O&{;{O'f9WOP$RiV$Ri]$Ri_$Rif$Riu$Rix$Riz$Ri}$Ri!O$Ri!R$Ri!U$Ri!X$Ri!n$Ri#Y$Ri#Z$Ri#x$Ri$f$Ri$i$Ri$m$Ri$q$Ri$s$Ri$u$Ri$w$Ri$y$Ri${$Ri$}$Ri%O$Ri%W$Ri&t$Ri&w$Ri'S$Ri'W$Ri'X$Ri'_$Ri'n$Ri's$Ri'u$Ri'v$Ri']$Ri(P$Ri'Z$Ri~P+=sO!duO!euO!f9`O!g9gO&c,eO&z;|O&{;|O'P9QO'QVO'R9|O'^8kO'aWO'bWO'c8yO'd8dO'e9`O'{8rO'|9nO'}9uO(OCeO(T,fO~O'f9XOV$Rif$Ri'W$Ri'X$Ri&t$Ri']$Ri~P2;VO&z;}O&{;}O'W$Ri'X$Ri'Z$Ri&t$Ri']$Ri~P*A{O!duO!euO!f9dO!g9kO&c,eO&z[O&{>[O'P=`O'QVO'R=fO'^=]O'aWO'bWO'c=_O'd=[O'e=bO'{=^O'|=dO'}=eO(ODPO(T#uO~O'f=aO(P%bi&t%bi']%bi~P5JgO&z=ZO&{=ZO!d$ni!e$ni!f$ni!g$ni&c$ni'P$ni'Q$ni'R$ni'W$ni'^$ni'a$ni'b$ni'c$ni'd$ni'e$ni'f$ni'{$ni'|$ni'}$ni(O$ni(T$ni(P$ni'Z$ni']$ni'X$ni~P& mO'd=[O&t%`i&z%`i&{%`i']%`i'^%`i'c%`i~P05PO!duO!euO!f=bO!g=cO&c#tO'P=`O'QVO'R=fO'^=]O'aWO'bWO'c=_O'd=[O'e=bO'{=^O'|=dO'}=eO(ODPO(T#uO&t%`i&z%`i&{%`i']%`i(P%`i~O'f%`i~P5NnO'^=]O'd=[O&t%`i&z%`i&{%`i']%`i'c%`i~P05PO'^=]O'c=_O'd=[O&t%`i&z%`i&{%`i']%`i~P05PO'f=aO~P5NnO&c#tO'P=`O'QVO'R=fO'^=]O'aWO'bWO'c=_O'd=[O(T#uO!d%`i!e%`i&t%`i&z%`i&{%`i']%`i'e%`i'f%`i'{%`i'|%`i'}%`i(O%`i(P%`i~O!f=bO!g=cO~P6#nO!f%`i!g%`i~P6#nO!duO!euO!f=bO!g=cO&c#tO'P=`O'QVO'R=fO'^=]O'aWO'bWO'c=_O'd=[O'e=bO'}=eO(T#uO&t%`i&z%`i&{%`i']%`i'f%`i'{%`i(O%`i(P%`i~O'|=dO~P6%mO'|%`i~P6%mO(P8UO~P&3wO(P8VO~P&3wO(P8WO~P&3wO(P8XO~P&3wO(P8YO~P&3wO(P8ZO~P&3wO(P8[O~P&3wO'P=`O'^=]O'c=_O'd=[O&t%`i&z%`i&{%`i']%`i~P17kO'Q8]O~O!duO!euO!f=bO!g=cO&c#tO'P=`O'QVO'R=fO'^=]O'aWO'bWO'c=_O'd=[O'e=bO'{=^O'|=dO'}=eO(ODPO(T#uO~O&z=lO&{=lO'f=aO&t&yX']&yX~P6)_O(Q8_O&_'oX&d#cX&e#cX&g'oX~P'=fO(Q8`OV'oX~P'7`O!d'oX!e'oX!f'oX!g'oX&_'oX&a'oX&b'oX&c'oX&d#cX&e#cX&f'oX&g'oX&z'oX&{'oX&|'oX&}'oX'P'oX'Q'oX'R'oX'X'oX'^'oX'a'oX'b'oX'c'oX'd'oX'e'oX'f'oX'{'oX'|'oX'}'oX(O'oX(T'oX&t'oX']'oX~O(Q8aO'W'oX'Z'oX~P6+nOV'oXf'oX!d'oX!e'oX!f'oX!g'oX&_'oX&a'oX&b'oX&c'oX&d#cX&e#cX&f'oX&g'oX&t'oX&z'oX&{'oX&|'oX&}'oX'P'oX'Q'oX'R'oX'X'oX'^'oX'a'oX'b'oX'c'oX'd'oX'e'oX'f'oX'{'oX'|'oX'}'oX(O'oX(T'oX~O(Q8bOP'oX]'oX_'oXu'oXx'oXz'oX}'oX!O'oX!R'oX!U'oX!X'oX!n'oX#Y'oX#Z'oX#x'oX$f'oX$i'oX$m'oX$q'oX$s'oX$u'oX$w'oX$y'oX${'oX$}'oX%O'oX%W'oX&w'oX'S'oX'_'oX'n'oX's'oX'u'oX'v'oX~P6.XO(Q8_O~O(Q8`O~O(Q8aO~O(Q8bO~O'f%ci(P%ci&t%ci']%ci~P5JgO!f=bO!g=cO'P=`O'R=fO'^=]O'c=_O'd=[O'e=bO'|=dO'}=eO(ODPO&z%ay&{%ay~P24rOPCxOVtO])OO_!POf!YOu!QOx)POz!RO}!TO!O!SO!R!UO!U!VO!X!WO!duO!euO!fYO!gYO!n!XO#Y)OO#Z)OO#x)OO$f!ZO$i![O$mvO$qvO'aWO'bWO'c?OO'd>rO'e?[O'{>zO'|?dO'}?hO(ODQO(T#uO~O'f?WOP%biV%bi_%bif%biu%bix%biz%bi}%bi!O%bi!R%bi!U%bi!X%bi!n%bi#Y%bi#Z%bi#x%bi$f%bi$i%bi$m%bi$q%bi$s%bi$u%bi$w%bi$y%bi${%bi$}%bi%O%bi%W%bi&t%bi&w%bi'S%bi'X%bi'_%bi'n%bi's%bi'u%bi'v%bi~P6@_O!duO!euO!f?]O!g?aO&c#tO&z@qO&{@qO'P?TO'QVO'R?mO'^>wO'aWO'bWO'c?PO'd>sO'e?]O'{>{O'|?eO'}?iO(ODRO(T#uO~O'f?XOV%bif%bi&t%bi']%bi'X%bi~P6D^O&c#tO'd>rO(T#uOP%`iV%`i_%`if%`iu%`ix%`iz%`i}%`i!O%`i!R%`i!U%`i!X%`i!d%`i!e%`i!f%`i!g%`i!n%`i#Y%`i#Z%`i#x%`i$f%`i$i%`i$m%`i$q%`i$s%`i$u%`i$w%`i$y%`i${%`i$}%`i%O%`i%W%`i&t%`i&w%`i&z%`i&{%`i'P%`i'Q%`i'R%`i'S%`i'X%`i'_%`i'a%`i'b%`i'c%`i'e%`i'f%`i'n%`i's%`i'u%`i'v%`i'{%`i'|%`i'}%`i(O%`i~O'^%`i~P6FXO&c#tO'd>sO(T#uOV%`if%`i!d%`i!e%`i!f%`i!g%`i&t%`i&z%`i&{%`i'P%`i'Q%`i'R%`i']%`i'a%`i'b%`i'c%`i'e%`i'f%`i'{%`i'|%`i'}%`i(O%`i'X%`i~O'^%`i~P6JWO&c#tO'd>tO(T#uOV%`if%`i!d%`i!e%`i!f%`i!g%`i&t%`i'P%`i'Q%`i'R%`i']%`i'a%`i'b%`i'c%`i'e%`i'f%`i'{%`i'|%`i'}%`i(O%`i'X%`i~O'^%`i~P6LRO&c#tO'd>uO(T#uO!d%`i!e%`i!f%`i!g%`i'P%`i'Q%`i'R%`i']%`i'a%`i'b%`i'c%`i'e%`i'f%`i'{%`i'|%`i'}%`i(O%`i&t%`i~O'^%`i~P6MvO!duO!euO!f?[O!g?`O&c#tO'P?SO'QVO'R?lO'^>vO'aWO'bWO'c?OO'd>rO'e?[O'{>zO'|?dO'}?hO(ODQO(T#uOP%`iV%`i_%`if%`iu%`ix%`iz%`i}%`i!O%`i!R%`i!U%`i!X%`i!n%`i#Y%`i#Z%`i#x%`i$f%`i$i%`i$m%`i$q%`i$s%`i$u%`i$w%`i$y%`i${%`i$}%`i%O%`i%W%`i&t%`i&w%`i&z%`i&{%`i'S%`i'X%`i'_%`i'n%`i's%`i'u%`i'v%`i~O'f%`i~P7 bO!duO!euO!f?]O!g?aO&c#tO'P?TO'QVO'R?mO'^>wO'aWO'bWO'c?PO'd>sO'e?]O'{>{O'|?eO'}?iO(ODRO(T#uOV%`if%`i&t%`i&z%`i&{%`i']%`i'X%`i~O'f%`i~P7%aO!duO!euO!f?^O!g?bO&c#tO'P?UO'QVO'R?nO'^>xO'aWO'bWO'c?QO'd>tO'e?^O'{>|O'|?fO'}?jO(ODSO(T#uOV%`if%`i&t%`i']%`i'X%`i~O'f%`i~P7'[O!duO!euO!f?_O!g?cO&c#tO'P?VO'QVO'R?oO'^>yO'aWO'bWO'c?RO'd>uO'e?_O'{>}O'|?gO'}?kO(ODTO(T#uO']%`i&t%`i~O'f%`i~P7)PO'^>vO~P6FXO'^>wO~P6JWO'^>xO~P6LRO'^>yO~P6MvO&c#tO'^>vO'c?OO'd>rO(T#uOP%`iV%`i_%`if%`iu%`ix%`iz%`i}%`i!O%`i!R%`i!U%`i!X%`i!d%`i!e%`i!f%`i!g%`i!n%`i#Y%`i#Z%`i#x%`i$f%`i$i%`i$m%`i$q%`i$s%`i$u%`i$w%`i$y%`i${%`i$}%`i%O%`i%W%`i&t%`i&w%`i&z%`i&{%`i'R%`i'S%`i'X%`i'_%`i'e%`i'f%`i'n%`i's%`i'u%`i'v%`i'{%`i'|%`i'}%`i(O%`i~O'P%`i'Q%`i'a%`i'b%`i~P7+XO&c#tO'^>wO'c?PO'd>sO(T#uOV%`if%`i!d%`i!e%`i!f%`i!g%`i&t%`i&z%`i&{%`i'R%`i']%`i'e%`i'f%`i'{%`i'|%`i'}%`i(O%`i'X%`i~O'P%`i'Q%`i'a%`i'b%`i~P7/WO&c#tO'^>xO'c?QO'd>tO(T#uOV%`if%`i!d%`i!e%`i!f%`i!g%`i&t%`i'R%`i']%`i'e%`i'f%`i'{%`i'|%`i'}%`i(O%`i'X%`i~O'P%`i'Q%`i'a%`i'b%`i~P71RO&c#tO'^>yO'c?RO'd>uO(T#uO!d%`i!e%`i!f%`i!g%`i'R%`i']%`i'e%`i'f%`i'{%`i'|%`i'}%`i(O%`i&t%`i~O'P%`i'Q%`i'a%`i'b%`i~P72vO'f?WO~P7 bO'f?XO~P7%aO'f?YO~P7'[O'f?ZO~P7)PO&c#tO'P?SO'QVO'R?lO'^>vO'aWO'bWO'c?OO'd>rO(T#uOP%`iV%`i_%`if%`iu%`ix%`iz%`i}%`i!O%`i!R%`i!U%`i!X%`i!d%`i!e%`i!n%`i#Y%`i#Z%`i#x%`i$f%`i$i%`i$m%`i$q%`i$s%`i$u%`i$w%`i$y%`i${%`i$}%`i%O%`i%W%`i&t%`i&w%`i&z%`i&{%`i'S%`i'X%`i'_%`i'e%`i'f%`i'n%`i's%`i'u%`i'v%`i'{%`i'|%`i'}%`i(O%`i~O!f?[O!g?`O~P75OO&c#tO'P?TO'QVO'R?mO'^>wO'aWO'bWO'c?PO'd>sO(T#uOV%`if%`i!d%`i!e%`i&t%`i&z%`i&{%`i']%`i'e%`i'f%`i'{%`i'|%`i'}%`i(O%`i'X%`i~O!f?]O!g?aO~P78}O&c#tO'P?UO'QVO'R?nO'^>xO'aWO'bWO'c?QO'd>tO(T#uOV%`if%`i!d%`i!e%`i&t%`i']%`i'e%`i'f%`i'{%`i'|%`i'}%`i(O%`i'X%`i~O!f?^O!g?bO~P7:xO&c#tO'P?VO'QVO'R?oO'^>yO'aWO'bWO'c?RO'd>uO(T#uO!d%`i!e%`i']%`i'e%`i'f%`i'{%`i'|%`i'}%`i(O%`i&t%`i~O!f?_O!g?cO~P7vO'aWO'bWO'c?OO'd>rO'e?[O'}?hO(T#uOP%`iV%`i_%`if%`iu%`ix%`iz%`i}%`i!O%`i!R%`i!U%`i!X%`i!n%`i#Y%`i#Z%`i#x%`i$f%`i$i%`i$m%`i$q%`i$s%`i$u%`i$w%`i$y%`i${%`i$}%`i%O%`i%W%`i&t%`i&w%`i&z%`i&{%`i'S%`i'X%`i'_%`i'f%`i'n%`i's%`i'u%`i'v%`i'{%`i(O%`i~O'|?dO~P7?RO!duO!euO!f?]O!g?aO&c#tO'P?TO'QVO'R?mO'^>wO'aWO'bWO'c?PO'd>sO'e?]O'}?iO(T#uOV%`if%`i&t%`i&z%`i&{%`i']%`i'f%`i'{%`i(O%`i'X%`i~O'|?eO~P7CQO!duO!euO!f?^O!g?bO&c#tO'P?UO'QVO'R?nO'^>xO'aWO'bWO'c?QO'd>tO'e?^O'}?jO(T#uOV%`if%`i&t%`i']%`i'f%`i'{%`i(O%`i'X%`i~O'|?fO~P7D{O!duO!euO!f?_O!g?cO&c#tO'P?VO'QVO'R?oO'^>yO'aWO'bWO'c?RO'd>uO'e?_O'}?kO(T#uO']%`i'f%`i'{%`i(O%`i&t%`i~O'|?gO~P7FpO'|%`i~P7?RO'|%`i~P7CQO'|%`i~P7D{O'|%`i~P7FpO'P?SO'QVO'aWO'bWO~P7+XO'P?TO'QVO'aWO'bWO~P7/WO'P?UO'QVO'aWO'bWO~P71RO'P?VO'QVO'aWO'bWO~P72vOPCwOVtO])OO_!POf!YOu!QOx)POz!RO}!TO!O!SO!R!UO!U!VO!X!WO!duO!euO!fYO!gYO!n!XO#Y)OO#Z)OO#x)OO$f!ZO$i![O$mvO'c?OO'd>rO'e?[O'|?dO'}?hO(ODQO'X%ay~P20jO!f?]O!g?aO'P?TO'R?mO'^>wO'c?PO'd>sO'e?]O'|?eO'}?iO(ODRO&z%ay&{%ay~P2.rO!f?^O!g?bO'P?UO'R?nO'^>xO'c?QO'd>tO'e?^O'|?fO'}?jO(ODSO~P2.rO!duO!euO!f?_O!g?cO&c#tO'P?VO'QVO'R?oO'^>yO'aWO'bWO'c?RO'd>uO'e?_O'|?gO'}?kO(ODTO(T#uO~O']%ay'f%ay'{%ay&t%ay~P8(tO!duO!euO!fAbO!gAfO&c,eO&zBxO&{BxO'PAYO'QVO'RArO'^@|O'aWO'bWO'cAUO'd@xO'eAbO'{AQO'|AjO'}AnO(ODUO(T,fO~O'fA^OV$Rif$Ri&t$Ri']$Ri'X$Ri~P8*`O&zByO&{ByO(P$Ri&t$Ri']$Ri~P+:uO&c,eO'd@xO(T,fOV$Pif$Pi!d$Pi!e$Pi!f$Pi!g$Pi&t$Pi&z$Pi&{$Pi'P$Pi'Q$Pi'R$Pi']$Pi'a$Pi'b$Pi'c$Pi'e$Pi'f$Pi'{$Pi'|$Pi'}$Pi(O$Pi'X$Pi~O'^$Pi~P8,nO&c,eO'd@yO(T,fOV$Pif$Pi!d$Pi!e$Pi!f$Pi!g$Pi&t$Pi'P$Pi'Q$Pi'R$Pi']$Pi'a$Pi'b$Pi'c$Pi'e$Pi'f$Pi'{$Pi'|$Pi'}$Pi(O$Pi'X$Pi~O'^$Pi~P8.iO'd@zO&t$Pi&z$Pi&{$Pi']$Pi'^$Pi'c$Pi~P3?kO&c,eO'd@{O(T,fO!d$Pi!e$Pi!f$Pi!g$Pi&t$Pi'P$Pi'Q$Pi'R$Pi']$Pi'a$Pi'b$Pi'c$Pi'e$Pi'f$Pi'{$Pi'|$Pi'}$Pi(O$Pi~O'^$Pi~P80wO!duO!euO!fAbO!gAfO&c,eO'PAYO'QVO'RArO'^@|O'aWO'bWO'cAUO'd@xO'eAbO'{AQO'|AjO'}AnO(ODUO(T,fOV$Pif$Pi&t$Pi&z$Pi&{$Pi']$Pi'X$Pi~O'f$Pi~P82cO!duO!euO!fAcO!gAgO&c,eO'PAZO'QVO'RAsO'^@}O'aWO'bWO'cAVO'd@yO'eAcO'{ARO'|AkO'}AoO(ODVO(T,fOV$Pif$Pi&t$Pi']$Pi'X$Pi~O'f$Pi~P84^O!duO!euO!fAdO!gAhO&c,eO'PA[O'QVO'RAtO'^AOO'aWO'bWO'cAWO'd@zO'eAdO'{ASO'|AlO'}ApO(ODWO(T,fO&t$Pi&z$Pi&{$Pi']$Pi(P$Pi~O'f$Pi~P86RO!duO!euO!fAeO!gAiO&c,eO'PA]O'QVO'RAuO'^APO'aWO'bWO'cAXO'd@{O'eAeO'{ATO'|AmO'}AqO(ODXO(T,fO&t$Pi']$Pi~O'f$Pi~P87vO'^@|O~P8,nO'^@}O~P8.iO'^AOO'd@zO&t$Pi&z$Pi&{$Pi']$Pi'c$Pi~P3?kO'^APO~P80wO&c,eO'^@|O'cAUO'd@xO(T,fOV$Pif$Pi!d$Pi!e$Pi!f$Pi!g$Pi&t$Pi&z$Pi&{$Pi'R$Pi']$Pi'e$Pi'f$Pi'{$Pi'|$Pi'}$Pi(O$Pi'X$Pi~O'P$Pi'Q$Pi'a$Pi'b$Pi~P8:bO&c,eO'^@}O'cAVO'd@yO(T,fOV$Pif$Pi!d$Pi!e$Pi!f$Pi!g$Pi&t$Pi'R$Pi']$Pi'e$Pi'f$Pi'{$Pi'|$Pi'}$Pi(O$Pi'X$Pi~O'P$Pi'Q$Pi'a$Pi'b$Pi~P8<]O'^AOO'cAWO'd@zO&t$Pi&z$Pi&{$Pi']$Pi~P3?kO&c,eO'^APO'cAXO'd@{O(T,fO!d$Pi!e$Pi!f$Pi!g$Pi&t$Pi'R$Pi']$Pi'e$Pi'f$Pi'{$Pi'|$Pi'}$Pi(O$Pi~O'P$Pi'Q$Pi'a$Pi'b$Pi~P8>kO'fA^O~P82cO'fA_O~P84^O'fA`O~P86RO'fAaO~P87vO&c,eO'PAYO'QVO'RArO'^@|O'aWO'bWO'cAUO'd@xO(T,fOV$Pif$Pi!d$Pi!e$Pi&t$Pi&z$Pi&{$Pi']$Pi'e$Pi'f$Pi'{$Pi'|$Pi'}$Pi(O$Pi'X$Pi~O!fAbO!gAfO~P8@sO&c,eO'PAZO'QVO'RAsO'^@}O'aWO'bWO'cAVO'd@yO(T,fOV$Pif$Pi!d$Pi!e$Pi&t$Pi']$Pi'e$Pi'f$Pi'{$Pi'|$Pi'}$Pi(O$Pi'X$Pi~O!fAcO!gAgO~P8BnO&c,eO'PA[O'QVO'RAtO'^AOO'aWO'bWO'cAWO'd@zO(T,fO!d$Pi!e$Pi&t$Pi&z$Pi&{$Pi']$Pi'e$Pi'f$Pi'{$Pi'|$Pi'}$Pi(O$Pi(P$Pi~O!fAdO!gAhO~P8DcO&c,eO'PA]O'QVO'RAuO'^APO'aWO'bWO'cAXO'd@{O(T,fO!d$Pi!e$Pi&t$Pi']$Pi'e$Pi'f$Pi'{$Pi'|$Pi'}$Pi(O$Pi~O!fAeO!gAiO~P8FWO!f$Pi!g$Pi~P8@sO!f$Pi!g$Pi~P8BnO!f$Pi!g$Pi~P8DcO!f$Pi!g$Pi~P8FWO!duO!euO!fAbO!gAfO&c,eO'PAYO'QVO'RArO'^@|O'aWO'bWO'cAUO'd@xO'eAbO'}AnO(T,fOV$Pif$Pi&t$Pi&z$Pi&{$Pi']$Pi'f$Pi'{$Pi(O$Pi'X$Pi~O'|AjO~P8HlO!duO!euO!fAcO!gAgO&c,eO'PAZO'QVO'RAsO'^@}O'aWO'bWO'cAVO'd@yO'eAcO'}AoO(T,fOV$Pif$Pi&t$Pi']$Pi'f$Pi'{$Pi(O$Pi'X$Pi~O'|AkO~P8JgO!duO!euO!fAdO!gAhO&c,eO'PA[O'QVO'RAtO'^AOO'aWO'bWO'cAWO'd@zO'eAdO'}ApO(T,fO&t$Pi&z$Pi&{$Pi']$Pi'f$Pi'{$Pi(O$Pi(P$Pi~O'|AlO~P8L[O!duO!euO!fAeO!gAiO&c,eO'PA]O'QVO'RAuO'^APO'aWO'bWO'cAXO'd@{O'eAeO'}AqO(T,fO&t$Pi']$Pi'f$Pi'{$Pi(O$Pi~O'|AmO~P8NPO'|$Pi~P8HlO'|$Pi~P8JgO'|$Pi~P8L[O'|$Pi~P8NPO'PAYO'QVO'aWO'bWO~P8:bO'PAZO'QVO'aWO'bWO~P8<]O'PA[O'^AOO'cAWO'd@zO&t$Pi&z$Pi&{$Pi']$Pi~P4@rO'PA]O'QVO'aWO'bWO~P8>kOV$Sif$Si&t$Si']$Si'f$Si'X$Si~P8*`O!duO!euO!fAdO!gAhO&c,eO'PA[O'QVO'RAtO'^AOO'aWO'bWO'cAWO'd@zO'eAdO'|AlO'}ApO(ODWO(T,fO~O&zByO&{ByO'{ASO'f$Si(P$Si&t$Si']$Si~P9$_O!fAbO!gAfO'PAYO'RArO'^@|O'cAUO'd@xO'eAbO'|AjO'}AnO(ODUO']$Qy~P5%yO!fAcO!gAgO'PAZO'RAsO'^@}O'cAVO'd@yO'eAcO'|AkO'}AoO(ODVO~P4NcO&t$Qy&z$Qy&{$Qy']$Qy'f$Qy'{$Qy(P$Qy~P9$_O!duO!euO!fAeO!gAiO&c,eO'PA]O'QVO'RAuO'^APO'aWO'bWO'cAXO'd@{O'eAeO'|AmO'}AqO(ODXO(T,fO~O&t$Qy']$Qy'f$Qy'{$Qy~P9(^O&_=PO&g=PO&a!cX&b!cX&f!cX~O&_=QO&g=QO&z!cX&{!cX~P1GZO(Q=WO~O(P>]O~P&3wO&tii']ii~P)=vOV>aOf,jO&t'xX']'xX'X'xX~OV>aOf,jO&t'xa']'xa'X'xa~O'fAaO'{ATO&t#Wi']#Wi~P9(^O!duO!euO&c,eO'QVO'aWO'bWO(T,fO~O!fAcO!gAgO'PAZO'RAsO'^@}O'cAVO'd@yO'eAcO'fA_O'{ARO'|AkO'}AoO(ODVOV#qaf#qa&t#qa']#qa'X#qa~P9,VO(Q>pO~O(Q>qO~O(Q>pOP'OXV'OX_'OXf'OXu'OXx'OXz'OX}'OX!O'OX!R'OX!U'OX!X'OX!d'OX!e'OX!f'OX!g'OX!n'OX#Y'OX#Z'OX#x'OX$f'OX$i'OX$m'OX$q'OX$s'OX$u'OX$w'OX$y'OX${'OX$}'OX%O'OX%W'OX&c'OX&t'OX&w'OX&z'OX&{'OX'P'OX'Q'OX'R'OX'S'OX'X'OX'^'OX'_'OX'a'OX'b'OX'c'OX'd'OX'e'OX'f'OX'n'OX's'OX'u'OX'v'OX'{'OX'|'OX'}'OX(O'OX(T'OX~P$:YO(Q>qOV'OXf'OX!d'OX!e'OX!f'OX!g'OX&c'OX&t'OX'P'OX'Q'OX'R'OX']'OX'^'OX'a'OX'b'OX'c'OX'd'OX'e'OX'f'OX'{'OX'|'OX'}'OX(O'OX(T'OX'X'OX&z'OX&{'OX~P$:YO(Q=WO!d'OX!e'OX!f'OX!g'OX&c'OX'P'OX'Q'OX'R'OX'^'OX'a'OX'b'OX'c'OX'd'OX'e'OX'f'OX'{'OX'|'OX'}'OX(O'OX(P'OX(T'OX&t'OX&z'OX&{'OX']'OX~P$:YO(P@rO~P&3wO(P@sO~P&3wO(P@tO~P&3wO(P@uO~P&3wO(Q@vO']'oX~P6.XO(Q@wO!d'oX!e'oX!f'oX!g'oX&_'oX&a'oX&b'oX&c'oX&d#cX&e#cX&f'oX&g'oX&|'oX&}'oX'P'oX'Q'oX'R'oX'^'oX'a'oX'b'oX'c'oX'd'oX'e'oX'f'oX'{'oX'|'oX'}'oX(O'oX(P'oX(T'oX&t'oX&z'oX&{'oX']'oX~O(Q@vO~O(Q@wO~O(PBzO~P+'|O(PB{O~P+'|O(PB|O~P+'|O(PB}O~P+'|O'e~", - goto: "))j(YPPPPP(Z4]P@_@cP@gPP(ZP@mP@p@sP(ZP@yAVHsIWJgJgKzLW!+l!2|!3_!+l!@Z!@}PP!MPP!@}P!MS!@}PP!MV!@}P!M]!@}P!M`!@}P!Mc!Mf!Mf!Mn!Mq!Mf!Mz!Mf!NZ!NaPPPP#-Z#5P#5n#5r#5v!@}P#6W#6Z#6^#=p#>OP#>b#6ZP#>e#>h#Cl$!V$!Y$!]$'a$'a$,e$,h$8|$'a$9P$9S$>k$>{PP$,h$?X$?a$?d$,h$,h$?g$LP%*e%6h%6h%6k$'a%6n$'a$'a%;v%h%=d#>h#>h#>h%CO#>h%Cb%Hf%Hl%Hl%Hp#>h&!U!+l!+l!+l&!X!+l!+l!+l&!a(ZP&!g(ZP&!j&!m(ZP&!s&$l(ZP(ZP(ZP(ZP(ZP(ZP(ZPP&&x&&{&'ZP&&x&'a(ZP&'g&'g&.g&5g&5j&'g&5n&'g&'g&'g&=W&'g&=l&'g&Dl&Ea&Fd&Fj&F{&GS&GY&G`&Gf&Gu&Hc&Hi&Hw&I_&Ie&Ik&Iq&Iw&I}&JT&J_&Jh&Jn&Ju&J|&KT&K[&Kb&Kk&Kq&Kw&K}&L{&MS&M[&Mb&MiPPPPPPPPPPPPPPPPPPPP&Nd' {P'!}'3iP'?m'?tPPPP'@cPPPP'HZ'3i(']PPPP('iPPP('qPPPPPP([>]>`>a>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}?O?P?Q?R?S?T?U?V?W?X?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o@l@m@n@o@p@q@r@s@t@u@v@w@x@y@z@{@|@}AOAPAQARASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuBxByBzB{B|B}CWCYCZC[C]C^C_C`CdCeCfCgChCiCjDPDQDRDSDTDUDVDWDX9P!OOR[eklmtvwx{!O!P!Z!]!^!_!r#[#b#e#f#h#i#j#k#l#m#n#o#p#q#r#s#v#{$l$m$p$r$}%O%Q%S%W%`%g%k%l%q%v%x&g&m&q']'f'i'j'm'n'|(a(d(g(k(n(v({(})Q)R)S)b)f)j)l)q)s)t){*Q*U*i*p*w*}+T+d+p+v+y,Q,V,Y,Z,[,],^,_,`,a,b,c,d,h,k,m,u,w,y-U-W-h-y-}.O.S.V.X.Z.i.o.t.v/O/S/b/i/p/v/w0d0i0k0o0r0w1Q1S1V1Z1`1j1k1m1q1u1w1y1}2P2S2Z2`2d2g2r2s2t2u2v2w2x2y2z2{2|2}3O3Q3R3S3T3U3V3W3X3Y3`3a3b3c3d3e3f3g3h3i3j3k3l3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R7m7y7z7{7|7}8O8P8Q8R8S8T8U8V8W8X8Y8Z8[8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8o8p8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R;{;|;}[>]>`>a>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}?O?P?Q?R?S?T?U?V?W?X?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o@l@m@n@o@p@q@r@s@t@u@v@w@x@y@z@{@|@}AOAPAQARASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuBxByBzB{B|B}CWCYCZC[C]C^C_C`CdCeCfCgChCiCjDPDQDRDSDTDUDVDWDXT'g$f'hT'f$f'hQ'l$fR*d'hR'q$gR*i'mQ'p$gR*l'qQ%Q!YQ)c%tQ+V(cR/k,r/lfOR[eklmtvwx{!O!P!S!X!Z!]!^!_!d!e!m!r!z#[#b#e#f#h#i#j#k#l#m#n#o#p#q#r#s#v#{$h$i$l$m$n$p$r$}%O%Q%S%W%`%g%l%q%v%x&g&m&q']'f'i'j'm'n'|(P(Y(a(d(g(k(n(v)b)f)j)l)q)s)t){*Q*U*i*p*}+T+d+k,m,u,w,y-U-W-h-y/i/p1`2r2s2t2u2v2w2x2y2z2{2|2}3O3Q3R3S3T3U3V3W3X3Y3`3a3b3c3d3e3f3g3h3i3j3k3l3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R7k7l7m8Q8R8S8T8U8V8W8X8Y8Z8[[>]>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}?O?P?Q?R?S?T?U?V?W?X?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o@p@q@r@s@t@uCWCYCZC[C]C^C_C`DPDQDRDSDTS%P!Y(cS&r#d+{T=i%t,rs!x[!r$l%O%g%v%x&q)f)j)l*p,u,w,y-h[>]>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}?O?P?Q?R?S?T?U?V?W?X?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o@p@q@r@s@t@uCWCYCZC[C]C^C_C`DPDQDRDSDTW$Ww`>a@l@m@n@o@v@w@x@y@z@{@|@}AOAPAQARASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuBxByBzB{B|B}CdCeCfCgChCiCjDUDVDWDXS-j*v8]Q/q-ZQ0S-|U5][>]>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}?O?P?Q?R?S?T?U?V?W?X?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o@p@q@r@s@t@uCWCYCZC[C]C^C_C`DPDQDRDSDTS(q%f*oQ)r&_S-j*v8]Q/q-ZR0S-|/lfOR[eklmtvwx{!O!P!S!X!Z!]!^!_!d!e!m!r!z#[#b#e#f#h#i#j#k#l#m#n#o#p#q#r#s#v#{$h$i$l$m$n$p$r$}%O%Q%S%W%`%g%l%q%v%x&g&m&q']'f'i'j'm'n'|(P(Y(a(d(g(k(n(v)b)f)j)l)q)s)t){*Q*U*i*p*}+T+d+k,m,u,w,y-U-W-h-y/i/p1`2r2s2t2u2v2w2x2y2z2{2|2}3O3Q3R3S3T3U3V3W3X3Y3`3a3b3c3d3e3f3g3h3i3j3k3l3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R7k7l7m8Q8R8S8T8U8V8W8X8Y8Z8[[>]>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}?O?P?Q?R?S?T?U?V?W?X?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o@p@q@r@s@t@uCWCYCZC[C]C^C_C`DPDQDRDSDT[$v!W$u*y*z-s/|S(q%f*o+S)O%k({(})Q)R)S*w+p+v+y,Q,V,Y,Z,[,],^,_,`,a,b,c,d,h,k-}.O.S.V.X.Z.i.o.t.v/O/S/b/v/w0d0i0k0o0r0w1Q1S1V1Z1j1k1m1q1u1w1y1}2P2S2Z2`2d2g7y7z7{7|7}8O8P8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8o8p8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R;{;|;}`>a@l@m@n@o@v@w@x@y@z@{@|@}AOAPAQARASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuBxByBzB{B|B}CdCeCfCgChCiCjDUDVDWDXS-j*v8]Q/q-ZR0S-|Q)Z%kQ+n({Q-n*wS.^+p.OQ0X-}Q0c.XQ1t0dQ1x0kQ2b1yQ2c2SR2h2d9P]OR[eklmtvwx{!O!P!Z!]!^!_!r#[#b#e#f#h#i#j#k#l#m#n#o#p#q#r#s#v#{$l$m$p$r$}%O%Q%S%W%`%g%k%l%q%v%x&g&m&q']'f'i'j'm'n'|(a(d(g(k(n(v({(})Q)R)S)b)f)j)l)q)s)t){*Q*U*i*p*w*}+T+d+p+v+y,Q,V,Y,Z,[,],^,_,`,a,b,c,d,h,k,m,u,w,y-U-W-h-y-}.O.S.V.X.Z.i.o.t.v/O/S/b/i/p/v/w0d0i0k0o0r0w1Q1S1V1Z1`1j1k1m1q1u1w1y1}2P2S2Z2`2d2g2r2s2t2u2v2w2x2y2z2{2|2}3O3Q3R3S3T3U3V3W3X3Y3`3a3b3c3d3e3f3g3h3i3j3k3l3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R7m7y7z7{7|7}8O8P8Q8R8S8T8U8V8W8X8Y8Z8[8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8o8p8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R;{;|;}[>]>`>a>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}?O?P?Q?R?S?T?U?V?W?X?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o@l@m@n@o@p@q@r@s@t@u@v@w@x@y@z@{@|@}AOAPAQARASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuBxByBzB{B|B}CWCYCZC[C]C^C_C`CdCeCfCgChCiCjDPDQDRDSDTDUDVDWDXR's$hR'u$iQ$m!SR'|$nR$p!UR$r!VR$w!W]$v!W$u*y*z-s/|R-o*w_.|,V/O/w1S1j1k2ZQ%m!lQ'[#}Q*x(SQ+S([R-P)uX(U$u*z-s/|/lfOR[eklmtvwx{!O!P!S!X!Z!]!^!_!d!e!m!r!z#[#b#e#f#h#i#j#k#l#m#n#o#p#q#r#s#v#{$h$i$l$m$n$p$r$}%O%Q%S%W%`%g%l%q%v%x&g&m&q']'f'i'j'm'n'|(P(Y(a(d(g(k(n(v)b)f)j)l)q)s)t){*Q*U*i*p*}+T+d+k,m,u,w,y-U-W-h-y/i/p1`2r2s2t2u2v2w2x2y2z2{2|2}3O3Q3R3S3T3U3V3W3X3Y3`3a3b3c3d3e3f3g3h3i3j3k3l3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R7k7l7m8Q8R8S8T8U8V8W8X8Y8Z8[[>]>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}?O?P?Q?R?S?T?U?V?W?X?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o@p@q@r@s@t@uCWCYCZC[C]C^C_C`DPDQDRDSDTQ!|^[$v!W$u*y*z-s/|+S)O%k({(})Q)R)S*w+p+v+y,Q,V,Y,Z,[,],^,_,`,a,b,c,d,h,k-}.O.S.V.X.Z.i.o.t.v/O/S/b/v/w0d0i0k0o0r0w1Q1S1V1Z1j1k1m1q1u1w1y1}2P2S2Z2`2d2g7y7z7{7|7}8O8P8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8o8p8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R;{;|;}`>a@l@m@n@o@v@w@x@y@z@{@|@}AOAPAQARASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuBxByBzB{B|B}CdCeCfCgChCiCjDUDVDWDXQ-a*]Q1e/rR1g/t%jnORmvwx{!O!P!]!^!_#[#e#f#h#i#j#k#l#m#n#o#p#q#r#v$m$p$r$}%O%Q%S%W%`%l%q&g&q']'f'j'm'n'|(d(g(k(n)s)t){*U*i*}+T+d,m,u-U/i/p1`2v2|2}3Y3h3o3v3}4U4]4d4k4r4y5Q8Zj#jCX#s%x)j)q,w3i3p3w4O4V4^4e4l4s4z5R8[=W=[=]=^=_=`=a=b=c=d=e=f=l>[>]>n>o>u>y>}?R?V?Z?_?c?g?k?o@uCWCYCZC[C]C^C_C`DPDQDRDSDTvCn#b&m*Q-W>k>p>r>v>z?O?S?W?[?`?d?h?l@p@r!]Co)b>l>m>q>s>t>w>x>{>|?P?Q?T?U?X?Y?]?^?a?b?e?f?i?j?m?n@q@s@tS!p[[>]>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}?O?P?Q?R?S?T?U?V?W?X?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o@p@q@r@s@t@uCWCYCZC[C]C^C_C`DPDQDRDSDTR$|!Xi!jU$j$x%b%c%n'r't5k5l5m5nQ(u%iQ*W'ZQ+e(wQ0].QQ1P.yR1p0^R+d(vR+T([+T)W%k({(})Q)R)S*w+p+v+y,Q,V,Y,Z,[,],^,_,`,a,b,c,d,h,k-}.O.S.V.X.Z.i.o.t.v/O/S/b/v/w0d0i0k0o0r0w1Q1S1V1Z1j1k1m1q1u1w1y1}2P2S2Z2`2d2g7y7z7{7|7}8O8P8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8o8p8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R;{;|;}`>a@l@m@n@o@v@w@x@y@z@{@|@}AOAPAQARASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuBxByBzB{B|B}CdCeCfCgChCiCjDUDVDWDX.zkOR[eklmtvwx{!O!P!Z!]!^!_!r#[#b#e#f#h#i#j#k#l#m#n#o#p#q#r#s#v#{$l$m$p$r$}%O%Q%S%W%`%g%l%q%v%x&g&m&q']'f'i'j'm'n'|(a(d(g(k(n(v)b)f)j)l)q)s)t){*Q*U*i*p*}+T+d,m,u,w,y-U-W-h-y/i/p1`2r2s2t2u2v2w2x2y2z2{2|2}3O3Q3R3S3T3U3V3W3X3Y3`3a3b3c3d3e3f3g3h3i3j3k3l3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R7m8Q8R8S8T8U8V8W8X8Y8Z8[[>]>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}?O?P?Q?R?S?T?U?V?W?X?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o@p@q@r@s@t@uCWCYCZC[C]C^C_C`DPDQDRDSDTQ$e}Q(r%f+S)Q%k({(})Q)R)S*w+p+v+y,Q,V,Y,Z,[,],^,_,`,a,b,c,d,h,k-}.O.S.V.X.Z.i.o.t.v/O/S/b/v/w0d0i0k0o0r0w1Q1S1V1Z1j1k1m1q1u1w1y1}2P2S2Z2`2d2g7y7z7{7|7}8O8P8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8o8p8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R;{;|;}`>a@l@m@n@o@v@w@x@y@z@{@|@}AOAPAQARASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuBxByBzB{B|B}CdCeCfCgChCiCjDUDVDWDXQ*_'dQ-a*]Q0T-|Q1e/rR1g/tR!}^R!|^+T)R%k({(})Q)R)S*w+p+v+y,Q,V,Y,Z,[,],^,_,`,a,b,c,d,h,k-}.O.S.V.X.Z.i.o.t.v/O/S/b/v/w0d0i0k0o0r0w1Q1S1V1Z1j1k1m1q1u1w1y1}2P2S2Z2`2d2g7y7z7{7|7}8O8P8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8o8p8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R;{;|;}`>a@l@m@n@o@v@w@x@y@z@{@|@}AOAPAQARASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuBxByBzB{B|B}CdCeCfCgChCiCjDUDVDWDX+T)O%k({(})Q)R)S*w+p+v+y,Q,V,Y,Z,[,],^,_,`,a,b,c,d,h,k-}.O.S.V.X.Z.i.o.t.v/O/S/b/v/w0d0i0k0o0r0w1Q1S1V1Z1j1k1m1q1u1w1y1}2P2S2Z2`2d2g7y7z7{7|7}8O8P8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8o8p8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R;{;|;}`>a@l@m@n@o@v@w@x@y@z@{@|@}AOAPAQARASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuBxByBzB{B|B}CdCeCfCgChCiCjDUDVDWDXR0Y-}/lfOR[eklmtvwx{!O!P!S!X!Z!]!^!_!d!e!m!r!z#[#b#e#f#h#i#j#k#l#m#n#o#p#q#r#s#v#{$h$i$l$m$n$p$r$}%O%Q%S%W%`%g%l%q%v%x&g&m&q']'f'i'j'm'n'|(P(Y(a(d(g(k(n(v)b)f)j)l)q)s)t){*Q*U*i*p*}+T+d+k,m,u,w,y-U-W-h-y/i/p1`2r2s2t2u2v2w2x2y2z2{2|2}3O3Q3R3S3T3U3V3W3X3Y3`3a3b3c3d3e3f3g3h3i3j3k3l3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R7k7l7m8Q8R8S8T8U8V8W8X8Y8Z8[[>]>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}?O?P?Q?R?S?T?U?V?W?X?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o@p@q@r@s@t@uCWCYCZC[C]C^C_C`DPDQDRDSDT+T)O%k({(})Q)R)S*w+p+v+y,Q,V,Y,Z,[,],^,_,`,a,b,c,d,h,k-}.O.S.V.X.Z.i.o.t.v/O/S/b/v/w0d0i0k0o0r0w1Q1S1V1Z1j1k1m1q1u1w1y1}2P2S2Z2`2d2g7y7z7{7|7}8O8P8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8o8p8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R;{;|;}`>a@l@m@n@o@v@w@x@y@z@{@|@}AOAPAQARASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuBxByBzB{B|B}CdCeCfCgChCiCjDUDVDWDXR%e!eR+i(z!W)U%k({)S*w+p+v,Y,Z,[,],^,_,`,a,b,c,k-}.O.X0d0k0o1V1y2S2dS.P+h.RQ.x,Rz>W(})Q)R,Q.t.v7y8_8c8j8q8x9P9W9_9f9m9t9{;{X/S1Z7z7{8`8d8e8k8l8r8s8y8z9Q9R9X9Y9`9a9g9h9n9o9u9v9|9};|Y,V,h.S.V.i/O/b/v/w0r1Q1S1j1k1m1q1u1}2Z2`2g7|7}8a8f8g8m8n8t8u8{8|9S9T9Z9[9b9c9i9j9p9q9w9x:O:P;}Z+y.o0w2P8O8b8h8o8v8}9U9]9d9k9r9y:Qa@l@m@v@x@y@|@}AQARAUAVAYAZA^A_AbAcAfAgAjAkAnAoArAsBxBzB{#gCz,d.Z0i1w8P8i8p8w9O9V9^9e9l9s9z:R`@n@o@w@z@{AOAPASATAWAXA[A]A`AaAdAeAhAiAlAmApAqAtAuByB|B}CdCeCfCgChCiCjDUDVDWDXm+m({+p.O.X.Z/b0d0i0k1u1w1y2S2de+q({+r+t+u.O.c.e/b0Z1W]#S_`a#Q#U#XR)q&YR/o,z/lfOR[eklmtvwx{!O!P!S!X!Z!]!^!_!d!e!m!r!z#[#b#e#f#h#i#j#k#l#m#n#o#p#q#r#s#v#{$h$i$l$m$n$p$r$}%O%Q%S%W%`%g%l%q%v%x&g&m&q']'f'i'j'm'n'|(P(Y(a(d(g(k(n(v)b)f)j)l)q)s)t){*Q*U*i*p*}+T+d+k,m,u,w,y-U-W-h-y/i/p1`2r2s2t2u2v2w2x2y2z2{2|2}3O3Q3R3S3T3U3V3W3X3Y3`3a3b3c3d3e3f3g3h3i3j3k3l3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R7k7l7m8Q8R8S8T8U8V8W8X8Y8Z8[[>]>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}?O?P?Q?R?S?T?U?V?W?X?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o@p@q@r@s@t@uCWCYCZC[C]C^C_C`DPDQDRDSDTS&r#d+{+T)O%k({(})Q)R)S*w+p+v+y,Q,V,Y,Z,[,],^,_,`,a,b,c,d,h,k-}.O.S.V.X.Z.i.o.t.v/O/S/b/v/w0d0i0k0o0r0w1Q1S1V1Z1j1k1m1q1u1w1y1}2P2S2Z2`2d2g7y7z7{7|7}8O8P8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8o8p8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R;{;|;}`>a@l@m@n@o@v@w@x@y@z@{@|@}AOAPAQARASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuBxByBzB{B|B}CdCeCfCgChCiCjDUDVDWDX9udOR[eklmtvwx{!O!P!S!X!Z!]!^!_!d!e!m!r!z#[#b#d#e#f#h#i#j#k#l#m#n#o#p#q#r#s#v#{$h$i$l$m$n$p$r$}%O%Q%S%W%`%g%k%l%q%v%x&g&m&q']'f'i'j'm'n'|(P(Y(a(d(g(k(n(v({(})Q)R)S)b)f)j)l)q)s)t){*Q*U*i*p*w*}+T+d+k+p+v+y+{,Q,V,Y,Z,[,],^,_,`,a,b,c,d,h,k,m,u,w,y-U-W-h-y-}.O.S.V.X.Z.i.o.t.v/O/S/b/i/p/v/w0d0i0k0o0r0w1Q1S1V1Z1`1j1k1m1q1u1w1y1}2P2S2Z2`2d2g2r2s2t2u2v2w2x2y2z2{2|2}3O3Q3R3S3T3U3V3W3X3Y3`3a3b3c3d3e3f3g3h3i3j3k3l3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R7k7l7m7y7z7{7|7}8O8P8Q8R8S8T8U8V8W8X8Y8Z8[8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8o8p8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R;{;|;}[>]>`>a>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}?O?P?Q?R?S?T?U?V?W?X?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o@l@m@n@o@p@q@r@s@t@u@v@w@x@y@z@{@|@}AOAPAQARASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuBxByBzB{B|B}CWCYCZC[C]C^C_C`CdCeCfCgChCiCjDPDQDRDSDTDUDVDWDX9RbO[emtvwx!O!P!S!X!Z!]!^!d!e!m!r!z#[#b#d#e#f#h#i#j#k#l#m#n#o#p#q#r#s#v$h$i$l$m$n$p$r$}%O%Q%S%W%`%g%k%l%q%v%x&g&m&q']'f'i'j'm'n'|(P(Y(a(d(g(k(n(v({(})S)b)f)j)l)q)s)t){*Q*U*i*p*w*}+T+d+k+p+v+y+{,V,Y,Z,[,],^,_,`,a,b,c,d,h,k,m,u,w,y-U-W-h-y-}.O.S.V.X.Z.i.o.t.v/O/S/b/i/p/v/w0d0i0k0o0r0w1Q1S1V1Z1`1j1k1m1q1u1w1y1}2P2S2Z2`2d2g2r2s2t2u2v3Q3R3S3T3U3V3W3X3Y3`3a3b3c3d3e3f3g3h3i3j3k3l3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R7k7l7m7y7z7{7|7}8O8P8Q8R8S8T8U8V8W8X8Y8Z8[8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8o8p8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R;{;|;}[>]>`>a>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}?O?P?Q?R?S?T?U?V?W?X?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o@l@m@n@o@p@q@r@s@t@u@v@w@x@y@z@{@|@}AOAPAQARASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuBxByBzB{B|B}CWCYCZC[C]C^C_C`CdCeCfCgChCiCjDPDQDRDSDTDUDVDWDXR&e#^R&e#_+S)O%k({(})Q)R)S*w+p+v+y,Q,V,Y,Z,[,],^,_,`,a,b,c,d,h,k-}.O.S.V.X.Z.i.o.t.v/O/S/b/v/w0d0i0k0o0r0w1Q1S1V1Z1j1k1m1q1u1w1y1}2P2S2Z2`2d2g7y7z7{7|7}8O8P8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8o8p8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R;{;|;}`>a@l@m@n@o@v@w@x@y@z@{@|@}AOAPAQARASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuBxByBzB{B|B}CdCeCfCgChCiCjDUDVDWDXT/c,j1]U,X)T-k0UW/Q,X/RCcCkTCc+l+xQ/d,jR2V1]R1Z/cS(b%P=iR1[/cX/Q,X/RCcCkQ+z(}V0u.o0w2PQ.T+jR.z,SR0T.sT,T)Q)RU,P)Q)R,QR0}.vU,O)Q)R,QR1O.v!W)S%k({)S*w+p+v,Y,Z,[,],^,_,`,a,b,c,k-}.O.X0d0k0o1V1y2S2dz7y(})Q)R,Q.t.v7y8_8c8j8q8x9P9W9_9f9m9t9{;{a@m@y@}ARAVAZA_AcAgAkAoAsB{t@n.Z0i1w@n@w@zAOASAWA[A`AdAhAlApAtByB|m@o>`@o@{APATAXA]AaAeAiAmAqAuB}^.h+v8_8`8a8b@v@w_1{0o;{;|;}`>a@l@m@n@o@v@w@x@y@z@{@|@}AOAPAQARASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuBxByBzB{B|B}CdCeCfCgChCiCjDUDVDWDXQ&s#dR.r+{T&r#d+{/lfOR[eklmtvwx{!O!P!S!X!Z!]!^!_!d!e!m!r!z#[#b#e#f#h#i#j#k#l#m#n#o#p#q#r#s#v#{$h$i$l$m$n$p$r$}%O%Q%S%W%`%g%l%q%v%x&g&m&q']'f'i'j'm'n'|(P(Y(a(d(g(k(n(v)b)f)j)l)q)s)t){*Q*U*i*p*}+T+d+k,m,u,w,y-U-W-h-y/i/p1`2r2s2t2u2v2w2x2y2z2{2|2}3O3Q3R3S3T3U3V3W3X3Y3`3a3b3c3d3e3f3g3h3i3j3k3l3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R7k7l7m8Q8R8S8T8U8V8W8X8Y8Z8[[>]>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}?O?P?Q?R?S?T?U?V?W?X?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o@p@q@r@s@t@uCWCYCZC[C]C^C_C`DPDQDRDSDTT&r#d+{R)[%kQ#ceV*O&m*Q-WQ(a%PR7m=iR%S!ZR%X![Q%V![R+](h!OrO!O!P!]!^$m$p$r$}%Q%S%W'f'j'm'n'|(d(k*i*}+T+dQ!bRU#zkl#{W$Uv[>]>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}?O?P?Q?R?S?T?U?V?W?X?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o@p@q@r@s@t@uCWCYCZC[C]C^C_C`DPDQDRDSDT.{lOR[eklmtvwx{!O!P!Z!]!^!_!r#[#b#e#f#h#i#j#k#l#m#n#o#p#q#r#s#v#{$l$m$p$r$}%O%Q%S%W%`%g%l%q%v%x&g&m&q']'f'i'j'm'n'|(a(d(g(k(n(v)b)f)j)l)q)s)t){*Q*U*i*p*}+T+d,m,u,w,y-U-W-h-y/i/p1`2r2s2t2u2v2w2x2y2z2{2|2}3O3Q3R3S3T3U3V3W3X3Y3`3a3b3c3d3e3f3g3h3i3j3k3l3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R7m8Q8R8S8T8U8V8W8X8Y8Z8[[>]>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}?O?P?Q?R?S?T?U?V?W?X?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o@p@q@r@s@t@uCWCYCZC[C]C^C_C`DPDQDRDSDTR(r'WT$Okl$fmORmvwx{!O!P!]!^!_#[#e#f#h#i#j#k#l#m#n#o#p#q#r#v$m$p$r$}%O%Q%S%W%`&q']'f'j'm'n'|(d(k(n)s)t*U*i*}+T+d,u/pjt!Z'i3T3g3n3u3|4T4[4c4j4q4x5P8T8Y>jv>k#b&m*Q-W>k>p>r>v>z?O?S?W?[?`?d?h?l@p@rn>l>l>q>s>w>{?P?T?X?]?a?e?i?m@q@sl>m)b>m>t>x>|?Q?U?Y?^?b?f?j?n@t!U>n#s3i3p3w4O4V4^4e4l4s4z5R8[>nCYCZC[C]C^C_C`DPDQDRDSDTn>o)q=l>o>u>y>}?R?V?Z?_?c?g?k?o@uuCW%x)j,w=W=[=]=^=_=`=a=b=c=d=e=f>[>]CW`&a#[3Q3R3S3T=W>p>qa,|)s8Q8R8S8T>[@p@q.{oOR[eklmtvwx{!O!P!Z!]!^!_!r#[#b#e#f#h#i#j#k#l#m#n#o#p#q#r#s#v#{$l$m$p$r$}%O%Q%S%W%`%g%l%q%v%x&g&m&q']'f'i'j'm'n'|(a(d(g(k(n(v)b)f)j)l)q)s)t){*Q*U*i*p*}+T+d,m,u,w,y-U-W-h-y/i/p1`2r2s2t2u2v2w2x2y2z2{2|2}3O3Q3R3S3T3U3V3W3X3Y3`3a3b3c3d3e3f3g3h3i3j3k3l3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R7m8Q8R8S8T8U8V8W8X8Y8Z8[[>]>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}?O?P?Q?R?S?T?U?V?W?X?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o@p@q@r@s@t@uCWCYCZC[C]C^C_C`DPDQDRDSDT!OrO!O!P!]!^$m$p$r$}%Q%S%W'f'j'm'n'|(d(k*i*}+T+dQ!bRZ%_!_#e%`'](n!ORO!O!P!]!^$m$p$r$}%Q%S%W'f'j'm'n'|(d(k*i*}+T+dQ!_RW#ehiqrW%[#e%`'](nW%`!`!a!b!cR(n%aQ'h$fR*b'hS,W)T)[U/P,W/x1lS/x-k-oT1l0U0YS,n)])^R/j,nQ*{(VR-t*{Q,s)cR/l,sQ)a%rR,p)aQ%w!qU)g%w)m*qQ)m%|T*q'x(^Q!t[[&O!t&Q&S'w(s=RQ&Q!vQ&S!yU'w$l%O&qQ(s%gR=Rj>k>l>m>n>oCWQ$Rtb$Svwxr>s>t>uQ&z#jQ&{#kQ&|#lQ&}#mQ'O#nQ'P#oQ'Q#pQ'R#qQ'S#rQ'T#sQ'V#vU(]%O&q,uQ)]%lQ)_%qU)y&g){-UQ*e'iQ+U(aQ+[(gS+a(v-yQ,q)bQ,z)qQ,{)sQ,})tQ-[*UU/f,m/i1`Q1a/pU5SOC`Q>P=fU>R%x)j,wQ>^>[Q>_>]Q?p>pQ?q>qQ?r>vQ?s>wQ?t>xQ?u>yQ?v>zQ?w>{Q?x>|Q?y>}Q?z?OQ?{?PQ?|?QQ?}?RQ@O?SQ@P?TQ@Q?UQ@R?VQ@S?WQ@T?XQ@U?YQ@V?ZQ@W?[Q@X?]Q@Y?^Q@Z?_Q@[?`Q@]?aQ@^?bQ@_?cQ@`?dQ@a?eQ@b?fQ@c?gQ@d?hQ@e?iQ@f?jQ@g?kQ@h?lQ@i?mQ@j?nQ@k?oQAv@pQAw@qQAx@rQAy@sQAz@tQA{@uQCaDPQCb=lQCsDQQCtDRQCuDSRCvDT.zpOR[eklmtvwx{!O!P!Z!]!^!_!r#[#b#e#f#h#i#j#k#l#m#n#o#p#q#r#s#v#{$l$m$p$r$}%O%Q%S%W%`%g%l%q%v%x&g&m&q']'f'i'j'm'n'|(a(d(g(k(n(v)b)f)j)l)q)s)t){*Q*U*i*p*}+T+d,m,u,w,y-U-W-h-y/i/p1`2r2s2t2u2v2w2x2y2z2{2|2}3O3Q3R3S3T3U3V3W3X3Y3`3a3b3c3d3e3f3g3h3i3j3k3l3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R7m8Q8R8S8T8U8V8W8X8Y8Z8[[>]>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}?O?P?Q?R?S?T?U?V?W?X?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o@p@q@r@s@t@uCWCYCZC[C]C^C_C`DPDQDRDSDT+T)W%k({(})Q)R)S*w+p+v+y,Q,V,Y,Z,[,],^,_,`,a,b,c,d,h,k-}.O.S.V.X.Z.i.o.t.v/O/S/b/v/w0d0i0k0o0r0w1Q1S1V1Z1j1k1m1q1u1w1y1}2P2S2Z2`2d2g7y7z7{7|7}8O8P8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8o8p8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R;{;|;}`>a@l@m@n@o@v@w@x@y@z@{@|@}AOAPAQARASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuBxByBzB{B|B}CdCeCfCgChCiCjDUDVDWDXZ!y[$l%O&q[>]>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}?O?P?Q?R?S?T?U?V?W?X?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o@p@q@r@s@t@uCWCYCZC[C]C^C_C`DPDQDRDSDTS$j!S$nQ$x!XQ%b!dS%c!e7lW%n!m!z(Y+kQ'r$hQ't$iQ5k=PQ5l=QQ5m(PR5n7kQ)T%kb+l({+p.O.X0d0k1y2S2dQ+x(}U+})Q)R,Qh,U)S7y7z7{7|7}8O8P@l@m@n@oQ-k*wQ.g+vW.m+y.o0w2P^.{,V/O/w1S1j1k2Zh/T,Y8c8d8e8f8g8h8i@x@y@z@{Q/U,ZQ/V,[Q/W,]Q/X,^Q/Y,_Q/Z,`Q/[,aQ/],bQ/^,cQ/_,dQ/a,hQ/e,kQ0U-}Q0_.SQ0a.VU0f.Z0i1wU0p.i0r1}Q0z.tQ0|.vQ1U/SQ1h/vQ1z0oQ2Q1QQ2R1VQ2U1ZQ2[1mU2]1q2`2gQ:_8_Q:`8`Q:a8aQ:b8bQ:c8jQ:d8kQ:e8lQ:f8mQ:g8nQ:h8oQ:i8pQ:j8qQ:k8rQ:l8sQ:m8tQ:n8uQ:o8vQ:p8wQ:q8xQ:r8yQ:s8zQ:t8{Q:u8|Q:v8}Q:w9OQ:x9PQ:y9QQ:z9RQ:{9SQ:|9TQ:}9UQ;O9VQ;P9WQ;Q9XQ;R9YQ;S9ZQ;T9[Q;U9]Q;V9^Q;W9_Q;X9`Q;Y9aQ;Z9bQ;[9cQ;]9dQ;^9eQ;_9fQ;`9gQ;a9hQ;b9iQ;c9jQ;d9kQ;e9lQ;f9mQ;g9nQ;h9oQ;i9pQ;j9qQ;k9rQ;l9sQ;m9tQ;n9uQ;o9vQ;p9wQ;q9xQ;r9yQ;s9zQ;t9{Q;u9|Q;v9}Q;w:OQ;x:PQ;y:QQ;z:RQbCdQ>cCeQ>dCfQ>eCgQ>fChQ>gCiQ>hCjS>i/b1uQA|@vQA}@wQBO@|QBP@}QBQAOQBRAPQBSAQQBTARQBUASQBVATQBWAUQBXAVQBYAWQBZAXQB[AYQB]AZQB^A[QB_A]QB`A^QBaA_QBbA`QBcAaQBdAbQBeAcQBfAdQBgAeQBhAfQBiAgQBjAhQBkAiQBlAjQBmAkQBnAlQBoAmQBpAnQBqAoQBrApQBsAqQBtArQBuAsQBvAtQBwAuQCOBxQCPByQCQBzQCRB{QCSB|QCTB}QCl>`QCm>aQC{DUQC|DVQC}DWRDODXQ$t!WW(T$u*z-s/|R-p*yQ(V$uV-q*z-s/|:UYOR[^eklmtvwx{!O!P!S!W!X!Z!]!^!_!d!e!m!r!z#[#b#e#f#h#i#j#k#l#m#n#o#p#q#r#s#v#{$h$i$l$m$n$p$r$u$}%O%Q%S%W%`%g%k%l%q%v%x&g&m&q']'f'i'j'm'n'|(P(Y(a(d(g(k(n(v({(})Q)R)S)b)f)j)l)q)s)t){*Q*U*]*i*p*w*y*z*}+T+d+k+p+v+y,Q,V,Y,Z,[,],^,_,`,a,b,c,d,h,k,m,u,w,y-U-W-h-s-y-}.O.S.V.X.Z.i.o.t.v/O/S/b/i/p/r/t/v/w/|0d0i0k0o0r0w1Q1S1V1Z1`1j1k1m1q1u1w1y1}2P2S2Z2`2d2g2r2s2t2u2v2w2x2y2z2{2|2}3O3Q3R3S3T3U3V3W3X3Y3`3a3b3c3d3e3f3g3h3i3j3k3l3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R7k7l7m7y7z7{7|7}8O8P8Q8R8S8T8U8V8W8X8Y8Z8[8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8o8p8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R;{;|;}[>]>`>a>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}?O?P?Q?R?S?T?U?V?W?X?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o@l@m@n@o@p@q@r@s@t@u@v@w@x@y@z@{@|@}AOAPAQARASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuBxByBzB{B|B}CWCYCZC[C]C^C_C`CdCeCfCgChCiCjDPDQDRDSDTDUDVDWDX!S#mh!`$S$_%]&`&t&v&{'O'P'Q'R'S'V(],{,}-[1a5S5T5U5w5|l,^)T+l-k.g/V/Y/Z/[/]/^/e0U1z2Rl4P!o5f5p5y5}6Y6o6v6}7U7]7d:S:Wr4Q#a#w+U+a5g5q5t5z6Z6p6w7O7V7^7e:T:Xj4R5h5r5u5{6[6q6x7P7W7_7f:U:Yf4S5i5v6]6r6y7Q7X7`7g8^:Zj4T$R%R*e5s6^6s6z7R7Y7a7h:V:[n4U)])_)y+[/f5j5x6_6t6{7S7Z7b7i:]z4V'T6`6u6|7T7[7c7j:^=x=y=z={=|=}>OCaCsCtCuCvl9P+x+}0z0|:_:j;P;W;_;f;m;tip9T/a0_0a0p1h2Q2[2]:n;T;[;c;j;q;x<`f9U.m:b:o;U;];d;k;r;yb>c>d>e>f>g>hC{C|C}DOf=`=m=p=s=t=u=v=w>P>R>^>_f?S&k?p?v@S@W@[@`@d@hAvAxd?T?q?w@T@X@]@a@e@iAwAyb?U,q?x@U@Y@^@b@f@jAzd?V,z?y@V@Z@_@c@g@kA{CbdAYA|BSB`BdBhBlBpBtCOCQbAZBTBaBeBiBmBqBuCRCmfA[0fA}BUBbBfBjBnBrBvCPCScA]BVBcBgBkBoBsBwCTCl:UYOR[^eklmtvwx{!O!P!S!W!X!Z!]!^!_!d!e!m!r!z#[#b#e#f#h#i#j#k#l#m#n#o#p#q#r#s#v#{$h$i$l$m$n$p$r$u$}%O%Q%S%W%`%g%k%l%q%v%x&g&m&q']'f'i'j'm'n'|(P(Y(a(d(g(k(n(v({(})Q)R)S)b)f)j)l)q)s)t){*Q*U*]*i*p*w*y*z*}+T+d+k+p+v+y,Q,V,Y,Z,[,],^,_,`,a,b,c,d,h,k,m,u,w,y-U-W-h-s-y-}.O.S.V.X.Z.i.o.t.v/O/S/b/i/p/r/t/v/w/|0d0i0k0o0r0w1Q1S1V1Z1`1j1k1m1q1u1w1y1}2P2S2Z2`2d2g2r2s2t2u2v2w2x2y2z2{2|2}3O3Q3R3S3T3U3V3W3X3Y3`3a3b3c3d3e3f3g3h3i3j3k3l3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R7k7l7m7y7z7{7|7}8O8P8Q8R8S8T8U8V8W8X8Y8Z8[8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8o8p8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R;{;|;}[>]>`>a>j>k>l>m>n>o>p>q>r>s>t>u>v>w>x>y>z>{>|>}?O?P?Q?R?S?T?U?V?W?X?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o@l@m@n@o@p@q@r@s@t@u@v@w@x@y@z@{@|@}AOAPAQARASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuBxByBzB{B|B}CWCYCZC[C]C^C_C`CdCeCfCgChCiCjDPDQDRDSDTDUDVDWDX|#oh!`$S$_%]&`&t&v&{'O'R'S(],{,}-[1a5S5T5U5w5|f,`)T+l-k.g/V/Y/]/^0U1z2Rf4_!o5f5p5y5}6Y6o7U7]:S:Wl4`#a#w+U+a5g5q5t5z6Z6p7V7^:T:Xd4a5h5r5u5{6[6q7W7_:U:Y`4b5i5v6]6r7X7`8^:Zd4c$R%R*e5s6^6s7Y7a:V:[h4d)])_)y+[/f5j5x6_6t7Z7b:]t4e'T6`6u7[7c:^=x=y=z={=|=}>OCaCsCtCuCvf9_+x+}0z0|:_:j;P;f;mij9c/a0_0a0p1h2Q2[2]:n;T;j;q<``9d.m:b:o;U;k;rb>c>d>e>f>g>hC{C|C}DO`=b=m=p=s=v=w>R>^>_`?[&k?p?v@S@`@dAvAx^?]?q?w@T@a@eAwAy[?^,q?x@U@b@fAz^?_,z?y@V@c@gA{Cb^AbA|BSB`BlBpCOCQ[AcBTBaBmBqCRCm`Ad0fA}BUBbBnBrCPCS]AeBVBcBoBsCTClU!v[%g`>a@l@m@n@o@v@w@x@y@z@{@|@}AOAPAQARASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuBxByBzB{B|B}CdCeCfCgChCiCjDUDVDWDXQ.Q+hR0^.RS+t({.OR.`+pQ+o({S._+p.O^0b.X0d0k1u1y2S2dU0g.Z0i1wR1X/bS#P_#QS#T`#UT#Wa#XT+u({/bW,g)T+l-k0UR.l+xR.y,RR-Y*Sg$Yw ArgumentList ListCompherension ForClause IfClause Parameters FunctionDefinition function Definition TypedExpression CallExpression BroadcastDot DoClause do DoClauseArguments CallExpression where TypeParameters MacroExpression MacroIdentifier MacroName Operator MacroFieldExpression FieldExpression SubscriptExpression AssignmentExpression Symbol SymbolName CallExpression BroadcastDot ArgumentList AssignmentExpression Parameters BooleanLiteral Character String $ ( ) TripleString CommandString PrefixedString Prefix FieldEpxression String TripleString CommandString ParenthesizedExpression TupleExpression ArrayExpression ArrayComprehensionExpression ForClause ForBinding AssignOperator = ∈ IfClause MatrixExpression MatrixRow GeneratorExpression TypedExpression ParameterizedIdentifier TypeArgumentList begin MacroFieldName MacroArgumentList AssignmentExpression BareTupleExpression UnaryExpression Operator BinaryExpression TernaryExpression FunctionExpression AssignmentExpression CoefficientExpression TransposeExpression Coefficient CallExpression FieldExpression ParenthesizedExpression SpreadExpression AssignmentExpression ArrayExpression ArrayComprehensionExpression MatrixExpression MatrixRow GeneratorExpression TypedExpression ParameterizedIdentifier AssignOperator WhileStatement while WhileBinding LetStatement let LetBinding VariableDeclaration ConstStatement const AssignmentExpression BareTupleExpression GlobalStatement global LocalStatement local QuoteStatement quote BreakStatement break ContinueStatement continue ReturnStatement return ImportStatement using import Import ScopedIdentifier RenamedIdentifier as SelectedImport RenamedImport ExportStatement export CompoundExpression MacroExpression MacroFieldExpression MacroFieldName MacroArgumentList UnaryExpression Operator BinaryExpression TernaryExpression FunctionExpression AssignmentExpression CoefficientExpression TransposeExpression SpreadExpression FunctionAssignmentExpression", - maxTerm: 331, + states: "%?dQ$tQNSOOOOQj'#IR'#IROOQj'#Gv'#GvO${QNSO'#IQO*cQNTO'#DpO*mQNTO'#DpO/eQNTO'#ITO0OQMyO'#InOOQk'#In'#InO0TQNTO'#InOOQk'#Dp'#DpO;VQNTO'#DpO>{QNQO'#DuOOQk'#Id'#IdO@WQNUO'#EXO@bONzO'#EiO@mONYO'#EmO@xO!!^O'#EnOATQMyO'#EpOD[QNTO'#EpODcQMyO'#EoOG|QNQO'#FjOOQk'#I^'#I^OJgQNTO'#I^O! qQNTO'#I^O!#lQNTO'#IQO!$nQNSO'#IQOOQk'#IU'#IUO!$xQNTO'#GhO!&bQNTO'#GhO!'wQNQO'#GlO!+YQMxO'#GpO!+_QNTO'#ITOOQk'#IT'#ITO!$SQNSO'#IQO!$SQNSO'#IQQOQMxOOO!+iQNQO'#CbOOQk'#Iu'#IuO!'wQNQO'#FzO!.zQNQO'#GOO!2]QNQO'#GQOOQk'#GU'#GUOOQk'#GW'#GWO!5nQNTO'#GYO!6}QNQO'#G[O!7VQNQO'#GeO!7_QNSO'#CaO!7lQNSO'#CjO!7|QNQO'#DRO!8RQNQO'#DWO!8WQNQO'#DZO!9zQNQO'#DZO!:PQNQO'#D_O!:UQNQO'#DbO!;bQNQO'#DeO!=YQNQO'#DzO!=dQNQO'#CrO!+iQNQO'#FsO!=lQNSO'#FvO!7eQNSO'#GSO!7eQNSO'#GgO!=|QNSO-E:tO!>jQNTO,5>VO!@bQNSO,5>VO!?dQNSO,5>VO!@lQNSO,5>lO!8WQNQO,59gO!AWQNUO,59jOOQh'#Cx'#CxOOQh'#Cy'#CyO!A_QMxO,59hO!AdQMxO,5:jO!AiQMyO,5:jO!AqQMxO,59kO!AvQMxO,5<]O!8WQNQO,5lO!'wQNQO'#HfO#2uQNSO,5PQNTO,5=WOOQj-E;i-E;iO#C}QNTO,58|O#HYQNRO'#F}O#HdQMxO'#F|OOQk,5VO$FXQNSO,5>VOOQj,5>V,5>VO$FyQNSO1G4WO$GaQNSO1G4WO$LrQNTO1G/RO%#|QNTO1G/UOOQk'#Ea'#EaOOQk1G0f1G0fO%$rQM}O1G/SO%$yQNQO'#DuOOQk'#Ix'#IxO%%QQNTO1G0UO!AdQMxO1G0UO%-oQNQO1G/VO%-yQNQO'#DmOOQk1G1w1G1wO%.TQNTO'#CzOOQk1G1u1G1uO%2vQNTO1G1vOOQk1G4t1G4tO#.PQNQO,59bO%7|QNQO'#IwOOQ`,5:b,5:bO%8_QNQO'#DwOOQk1G1t1G1tO%8gQNQO,5?bO%8wQMxO,5?bO%QOOQk-E;d-E;dO&#PQNTO1G2SOOQk1G2S1G2SO&$_QNSO1G2SO&)SQNTO1G2tO&+gQNTO1G2tO&-zQNTO1G2tO&.RQNTO1G2tO&0`QNTO1G2tO&0mQNTO1G2tO&2}QNTO1G2tO&3XQNTO1G2tO&5oQNTO1G2tO&5vQNTO1G2tO&7_QNRO1G2uOOQk1G2y1G2yO&9iQNTO1G2tO&9yQM|O1G2oOOQk-E;h-E;hOOQk'#Jg'#JgO&:OQNTO1G2nOOQk1G2n1G2nP]QNSO'#GvOOQk,5oQNQO,5tQNQO'#HgO&>|QNTO,5ROOQk,5>R,5>ROOQk-E;e-E;eO(+oQNQO1G2iOOQk1G2g1G2gOOQk,5>T,5>TOOQk-E;g-E;gOOQh,59O,59OOOQh-E:u-E:uOOQk7+$R7+$RO(+|QNQO7+$RO(,RQNTO,59POOQh,59R,59RO(.yQNTO'#CnOOQh,59W,59WO(4hQNSO,59WOOQh,59Z,59ZOOQh,59[,59[OOQk7+$[7+$[O(4oQNQO7+$[O(4tQNQO7+$[O(4|QNQO7+$sOOQk7+$x7+$xO%$aQM}O1G/SO(5RQNQO,5>rO(5]QMxO,5>rOOQk7+${7+${O(5hQNQO7+${OOQk7+%P7+%POOQk7+%S7+%SO(5mQM|O1G/nO(5xQNQO1G/oOOQa1G/r1G/rO$:gQNQO,5:ZO(6SQNQO1G/tO(6gQMxO1G/tOOQa1G/t1G/tO!7eQNSO7+%VO(6oQNTO'#IxOOQj1G0Z1G0ZOOQj1G0T1G0TOOQk7+%l7+%lOOQj'#EV'#EVO!7eQNSO7+%lO(O,5>OOOQj-E;b-E;bO(>{QNQO7+$dOOQk7+$d7+$dOOQk7+'e7+'eO(?QQNTO1G2PO(?_QMzO1G2POOQb,5>P,5>POOQb-E;c-E;cOOQk7+'h7+'hO(?mQNQO7+'hO(?rQNTO'#IyOOQj'#Iy'#IyO(BgQNSO'#ESO!7eQNSO,5:lOOQk<]AN>]OOQkAN>rAN>rO+6kQNTO<SOOQk,5>S,5>SO,%^QNTO,5>SOOQk-E;f-E;fOOQk1G2j1G2jO,%eQNRO1G/pOOQaAN>aAN>aO,%oQNQOAN>aO,%vQNQO<jQNRO,5QO/1^QNRO,5>QO/3[QNRO,5>QO/3uQNTO,5>QO/6SQNTO,5>QO/6gQNTO,5>QO/7{QNRO,5>QO/8iQNTO1G2SO/OQNRO1G2tO0BWQNTO1G2tO0DeQNTO1G2tO0FPQNRO1G2tO0F^QNRO1G2tO0FwQNTO1G2tO0GOQNRO1G2tO0GlQNRO1G2tO0HSQNTO1G2tO0HZQNTO1G2tO0HbQNRO1G2tO0JYQNRO1G2tO0NzQNTO1G2tO1!xQNRO1G2tO1$pQNRO1G2tO1(xQNTO1G2tO1+VQNTO1G2tO1,nQNRO1G2tO1,xQNRO1G2tO1-SQNTO1G2tO1-^QNRO1G2tO1-hQNRO1G2tO1-rQNTO1G2tO1-|QNTO1G2tO1.WQNRO1G2tO10UQNRO1G2tO14vQNTO1G2tO16tQNRO1G2tO18lQNRO1G2tO1PQNRO<TQNRO1G1dO3?lQNRO1G1dO3?sQNRO1G1dO3BeQNRO1G1dO3BuQNRO1G1dO3B|QNRO1G1dO3CTQNRO1G1dO3C[QNRO1G1dO3CcQNRO1G1dO3CjQNRO1G1dO3F[QNRO1G1dO3HSQNRO1G1dO3I}QNRO1G1dO3KrQNRO1G1dO4 tQNRO1G1dO4#`QNRO1G1dO4#mQNRO1G1dO4&nQNRO1G1dO4&uQNRO1G1dO4&|QNRO1G1dO4'TQNRO1G1dO4'[QNRO1G1dO4'cQNRO1G1dO4+nQNRO1G1dO4-lQNRO1G1dO4/dQNRO1G1dO41_QNRO1G1dO43SQNRO1G1dO47UQNRO1G1dO48mQNRO1G1dO48wQNRO1G1dO49RQNRO1G1dO49]QNRO1G1dO49gQNRO1G1dO49qQNRO1G1dO49{QNRO1G1dO4:VQNRO1G1dO4>hQNRO1G1dO4@fQNRO1G1dO4B^QNRO1G1dO4DXQNRO1G1dO4E|QNRO1G1dO4JOQNRO1G1dO4KgQNRO1G1dO4KnQNRO1G1dO4KuQNRO1G1dO4K|QNRO1G1dO4LTQNRO1G1dO4L[QNRO1G1dO4LcQNRO1G1dO4LjQNRO1G1dO4LqQNRO1G1dO5 fQNRO1G1dO5 yQNRO1G1dO5!ZQNRO1G1dO5!kQNRO1G1dO5!{QNRO1G1dO5$dQNRO1G1dO'<_QNQO,5;{O2.VQNQO,5;{O)2XQNQO,5;{O)#cQNQO,5;{O'<_QNQO7+'PO2.VQNQO7+'PO*FrQNQO7+'PO)2XQNQO7+'PO)9uQNQO7+'PO)#cQNQO7+'PO)6[QNQO7+'PO5$tQNRO1G1gO5'uQNRO1G1gO5)mQNRO1G1gO5*ZQNRO1G1gO5,xQNRO<QQNTO'#EpO5>eQNRO'#EpO5@dQNTO'#EpO5DmQMxO'#GpO5DrQMxO'#GpO5DwQMxO'#GpO5D|QMxO'#GpO!'wQNQO'#FzO!'wQNQO'#FzO!'wQNQO'#FzO!.zQNQO'#GOO!.zQNQO'#GOO!.zQNQO'#GOO5ERQNQO'#GOO5HdQNQO'#GOO5KuQNQO'#GOO5ERQNQO'#GOO5ERQNQO'#GOO5HdQNQO'#GOO5KuQNQO'#GOO!2]QNQO'#GQO!2]QNQO'#GQO!2]QNQO'#GQO6 WQNQO'#GQO6$iQNQO'#GQO6'zQNQO'#GQO6 WQNQO'#GQO6 WQNQO'#GQO6$iQNQO'#GQO6'zQNQO'#GQO!8WQNQO,59gO!8WQNQO,59gO!8WQNQO,59gO!AWQNUO,59jO6+]QMxO,5:aO6+eQNQO,5=[O!'wQNQO'#HfO6.vQNTO,5gQMxO,5:SO6?yQNRO'#IXO6@^QNRO'#EpO6@qQNRO'#EpO6CUQNRO'#EpO6EoQNRO'#EpO6HQQMxO'#F`O6HVQMxO'#F`O6H[QMxO'#F`O6HaQMxO'#F`O6+eQNQO,5=]O6+eQNQO7+(aO6HfQNRO1G2wO6HvQNRO<wQNRO<mQNRO<PO'T({O&a!sa&i!sa~O'p^O~P%$aO'_)PO~P;aO!u)RO!e!ri!f!ri!g!ri!h!ri!x!ri&`!ri&a!ri&c!ri&d!ri&e!ri&h!ri&i!ri&j!ri&v!ri&|!ri&}!ri'O!ri'P!ri'R!ri'S!ri'T!ri'Y!ri'`!ri'c!ri'd!ri'e!ri'f!ri'g!ri'h!ri'}!ri(O!ri(P!ri(Q!ri(V!rig!ri'_!riP!riV!ri_!riv!riy!ri{!ri!O!ri!P!ri!S!ri!V!ri!Y!ri!o!ri#Z!ri#[!ri#y!ri$h!ri$k!ri$o!ri$s!ri$u!ri$w!ri$y!ri${!ri$}!ri%P!ri%Q!ri%Y!ri&y!ri'U!ri'Z!ri'a!ri'p!ri'u!ri'w!ri'x!riY!ri[!ri]!ria!rie!ri(R!ri']!ri~OP)XOVuO])ZO_!QOg!ZOv!ROy)[O{!SO!O!UO!P!TO!S!VO!V!WO!Y!XO!evO!fvO!gYO!hYO!o!YO#Z)ZO#[)ZO#y)ZO$h![O$k!]O$o=OO$s=RO$u=]O$w!^O$yzO${{O$}3UO%P}O%Q}O%Y!OO&y)WO&|YO&}YO'RCnO'SVO'TCoO'U)YO'`YO'a)UO'cWO'd)TO'eYO'fYO'gYO'hYO'p^O'u_O'w`O'xaO~O'Y)eO'Z)dO~P%*ZO'O!gO'P!hO~P#.PO!enX!fnX!gnX!hnX&`nX&enX&jnX&vnX&|nX&}nX'RnX'SnX'TnX'YnX'`nX'cnX'dnX'enX'fnX'gnX'hnX'}nX(OnX(PnX(QnX(VnX'_nXgnXPnXVnX_nXvnXynX{nX!OnX!PnX!SnX!VnX!YnX!onX#ZnX#[nX#ynX$hnX$knX$onX$snX$unX$wnX$ynX${nX$}nX%PnX%QnX%YnX&ynX'UnX'ZnX'anX'pnX'unX'wnX'xnXYnX[nX]nXanXenX!xnX']nX(RnX~P$5PO&c!mO&d!lO&h(QO!e$di!f$di!g$di!h$di&`$di&a$di&e$di&i$di&j$di&v$di&|$di&}$di'O$di'P$di'R$di'S$di'T$di'Y$di'`$di'c$di'd$di'e$di'f$di'g$di'h$di'}$di(O$di(P$di(Q$di(V$dig$di'_$diP$diV$di_$div$diy$di{$di!O$di!P$di!S$di!V$di!Y$di!o$di#Z$di#[$di#y$di$h$di$k$di$o$di$s$di$u$di$w$di$y$di${$di$}$di%P$di%Q$di%Y$di&y$di'U$di'Z$di'a$di'p$di'u$di'w$di'x$diY$di[$di]$dia$die$di(R$di']$di!x$di~OV)mOg%yO&v'kX'_'kX'Z'kX~OP=|O&y%QO~O&v&za&v'ja'_&za'_'ja~P!DiO'Y)qO&v&za&v'ja'_&za'_'ja~OPCpOVuO_!QOg!ZOv!ROyhO{!SO!O!UO!P!TO!S!VO!V!WO!Y!XO!evO!fvO!gYO!hYO!o!YO#ZfO#[fO#y!_O$h![O$k!]O$owO$s=XO$u=cO$w!^O$yzO${{O$}|O%P}O%Q}O%Y!OO&y[O&|YO&}YO'O!gO'P!hO'RSO'SVO'TTO'UeO'`YO'aZO'cWO'dXO'eYO'fYO'gYO'hYO'p^O'u_O'w`O'xaO~O'_)tO~P%9YO&v)uO'_)tO~O'Y)wO&v'jX'_'jX~O&aii&cii&dii&hii&iii'Oii'Pii~O!eii!fii!gii!hii&`ii&eii&jii&vii&|ii&}ii'Rii'Sii'Tii'Yii'`ii'cii'dii'eii'fii'gii'hii'}ii(Oii(Pii(Qii(S!ii(Viigii'_iiPiiVii_iiviiyii{ii!Oii!Pii!Sii!Vii!Yii!oii#Zii#[ii#yii$hii$kii$oii$sii$uii$wii$yii${ii$}ii%Pii%Qii%Yii&yii'Uii'Zii'aii'pii'uii'wii'xiiYii[ii]iiaiieii(Rii']ii~P%=]O&v!tO'_)yO~O&v!tO'_)zO~O&y){O~O&k(zO~O!evO!fvO!g#qO!h#rO&e#vO&|*OO&}*OO'R#oO'SVO'T#xO'`#lO'cWO'dWO'e#nO'f#kO'g#qO'}#mO(O#sO(P#tO(Q#uO(V#wO~O'h#pO&`%di&j%di&v%di'Y%diY%di[%di]%dia%die%di']%di'_%di'Z%di(R%di~P%CRO&p*PO~O&o*QO~O&q*RO~O'Z*TO~P#.PO'Y*UO'Z*TO~O'Z*WO~O!g?rO!h?vO'R?jO'T@SO'`?^O'e?fO'f?YO'g?rO'h?nO'}?bO(O?zO(P@OO(QDjOg&UX'Z&UX~P#&YO'Z*YO~P#*[O&v*ZO'Z*YO~O!evO!fvO!g4qO!h4xO&e#vO'R4cO'SVO'T5_O'Y3gO'`3|O'cWO'dWO'e4[O'f3uO'g4qO'h4jO'}4TO(O5PO(P5WO(QCxO(V#wO~O&`%ii&j%ii&v%iiY%ii[%ii]%iia%iie%ii~P%GmO&|*]O&}*]O~O&a=hO&i=hO~O&a*^O&h*_O!e$WX!f$WX!g$WX!h$WX&`$WX&e$WX&f#dX&g#dX&j$WX&v$WX&|$WX&}$WX'R$WX'S$WX'T$WX'Y$WX'`$WX'c$WX'd$WX'e$WX'f$WX'g$WX'h$WX'}$WX(O$WX(P$WX(Q$WX(V$WXg$WX'_$WXP$WXV$WX_$WXv$WXy$WX{$WX!O$WX!P$WX!S$WX!V$WX!Y$WX!o$WX#Z$WX#[$WX#y$WX$h$WX$k$WX$o$WX$s$WX$u$WX$w$WX$y$WX${$WX$}$WX%P$WX%Q$WX%Y$WX&y$WX'U$WX'Z$WX'a$WX'p$WX'u$WX'w$WX'x$WXY$WX[$WX]$WXa$WXe$WX(R$WX']$WX~O!evO!fvO!g#qO!h#rO&e#vO'R#oO'SVO'T#xO'`#lO'cWO'dWO'e#nO'f#kO'g#qO'}#mO(O#sO(P#tO(Q#uO(V#wO&`&Ya&j&Ya&v&Ya&|&Ya&}&Ya'Y&YaY&Ya[&Ya]&Yaa&Yae&Ya~O'h#pO~P%NxO&|#jO&}#jO&`$pi&j$pi&v$piY$pi[$pi]$pia$pie$pi~P#FuO&`$pi&j$pi&v$piY$pi[$pi]$pia$pie$pi~O&|#jO&}#jO~P&#sO&e#vO(V#wO!e%bi!f%bi!g%bi!h%bi&`%bi&j%bi&v%bi&|%bi&}%bi'R%bi'S%bi'T%bi'Y%bi'`%bi'c%bi'd%bi'e%bi'g%bi'h%bi'}%bi(O%bi(P%bi(Q%big%bi'_%biP%biV%bi_%biv%biy%bi{%bi!O%bi!P%bi!S%bi!V%bi!Y%bi!o%bi#Z%bi#[%bi#y%bi$h%bi$k%bi$o%bi$s%bi$u%bi$w%bi$y%bi${%bi$}%bi%P%bi%Q%bi%Y%bi&y%bi'U%bi'Z%bi'a%bi'p%bi'u%bi'w%bi'x%biY%bi[%bi]%bia%bie%bi(R%bi']%bi~O'f%bi~P&$iO&e#vO'f#kO(V#wO!e%bi!f%bi!g%bi!h%bi&`%bi&j%bi&v%bi&|%bi&}%bi'R%bi'S%bi'T%bi'Y%bi'c%bi'd%bi'e%bi'g%bi'h%bi'}%bi(O%bi(P%bi(Q%biY%bi[%bi]%bia%bie%bi'_%bi']%bi'Z%bi(R%bi~O'`%bi~P&)ZO!evO!fvO!g#qO!h#rO&e#vO'R#oO'SVO'T#xO'`#lO'cWO'dWO'e#nO'f#kO'g#qO'}#mO(O#sO(P#tO(Q#uO(V#wO&`%bi&j%bi&v%bi&|%bi&}%bi'Y%biY%bi[%bi]%bia%bie%bi'_%bi']%bi'Z%bi(R%bi~O'h%bi~P&+nO'`#lO~P&)ZO&e#vO(V#wO!e%bi!f%bi!g%bi!h%bi&`%bi&j%bi&v%bi&|%bi&}%bi'R%bi'S%bi'T%bi'Y%bi'c%bi'd%bi'g%bi'h%bi'}%bi(O%bi(P%bi(Q%biY%bi[%bi]%bia%bie%bi'_%bi']%bi'Z%bi(R%bi~O'`#lO'e#nO'f#kO~P&.YO'h#pO~P&+nO&e#vO'R#oO'SVO'T#xO'`#lO'cWO'dWO'e#nO'f#kO(V#wO!e%bi!f%bi&`%bi&j%bi&v%bi&|%bi&}%bi'Y%bi'g%bi'h%bi'}%bi(O%bi(P%bi(Q%biY%bi[%bi]%bia%bie%bi'_%bi']%bi'Z%bi(R%bi~O!g#qO!h#rO~P&0tO!g%bi!h%bi~P&0tO!evO!fvO!g#qO!h#rO&e#vO'R#oO'SVO'T#xO'`#lO'cWO'dWO'e#nO'f#kO'g#qO(P#tO(V#wO&`%bi&j%bi&v%bi&|%bi&}%bi'Y%bi'h%bi'}%bi(Q%biY%bi[%bi]%bia%bie%bi'_%bi']%bi'Z%bi(R%bi~O(O#sO~P&3cO(O%bi~P&3cO!evO!fvO!g4rO!h4yO&e#vO'R4dO'SVO'T5`O'`3}O'cWO'dWO'e4]O'f3vO'g4rO'h4kO'}4UO(O5QO(P5XO(QCyO(V#wO~O(R*`O~P&5}O&e#vO'SVO'cWO'dWO(V#wO!e%bi!f%bi!g%bi!h%bi&`%bi&j%bi&v%bi&|%bi&}%bi'T%bi'Y%bi'g%bi'h%bi'}%bi(O%bi(P%bi(Q%biY%bi[%bi]%bia%bie%bi'_%bi']%bi'Z%bi(R%bi~O'R#oO'`#lO'e#nO'f#kO~P&7fO&k*aO~O!u)RO!e%[i!f%[i!g%[i!h%[i&`%[i&e%[i&j%[i&v%[i&|%[i&}%[i'R%[i'S%[i'T%[i'Y%[i'`%[i'c%[i'd%[i'e%[i'f%[i'g%[i'h%[i'}%[i(O%[i(P%[i(Q%[i(V%[ig%[i'_%[iP%[iV%[i_%[iv%[iy%[i{%[i!O%[i!P%[i!S%[i!V%[i!Y%[i!o%[i#Z%[i#[%[i#y%[i$h%[i$k%[i$o%[i$s%[i$u%[i$w%[i$y%[i${%[i$}%[i%P%[i%Q%[i%Y%[i&y%[i'U%[i'Z%[i'a%[i'p%[i'u%[i'w%[i'x%[iY%[i[%[i]%[ia%[ie%[i(R%[i']%[i~OP*cO~OP*dO'S$cO~O'Y'hO!e%Ra!f%Ra!g%Ra!h%Ra&`%Ra&e%Ra&j%Ra&v%Ra&|%Ra&}%Ra'R%Ra'S%Ra'T%Ra'`%Ra'c%Ra'd%Ra'e%Ra'f%Ra'g%Ra'h%Ra'}%Ra(O%Ra(P%Ra(Q%Ra(V%Rag%Ra'_%RaP%RaV%Ra_%Rav%Ray%Ra{%Ra!O%Ra!P%Ra!S%Ra!V%Ra!Y%Ra!o%Ra#Z%Ra#[%Ra#y%Ra$h%Ra$k%Ra$o%Ra$s%Ra$u%Ra$w%Ra$y%Ra${%Ra$}%Ra%P%Ra%Q%Ra%Y%Ra&y%Ra'U%Ra'Z%Ra'a%Ra'p%Ra'u%Ra'w%Ra'x%RaY%Ra[%Ra]%Raa%Rae%Ra(R%Ra']%Ra~O'T*gO~OP*hO~OP*iO'p^O~O'Y'lO!e%Xi!f%Xi!g%Xi!h%Xi&`%Xi&e%Xi&j%Xi&v%Xi&|%Xi&}%Xi'R%Xi'S%Xi'T%Xi'`%Xi'c%Xi'd%Xi'e%Xi'f%Xi'g%Xi'h%Xi'}%Xi(O%Xi(P%Xi(Q%Xi(V%Xig%Xi'_%XiP%XiV%Xi_%Xiv%Xiy%Xi{%Xi!O%Xi!P%Xi!S%Xi!V%Xi!Y%Xi!o%Xi#Z%Xi#[%Xi#y%Xi$h%Xi$k%Xi$o%Xi$s%Xi$u%Xi$w%Xi$y%Xi${%Xi$}%Xi%P%Xi%Q%Xi%Y%Xi&y%Xi'U%Xi'Z%Xi'a%Xi'p%Xi'u%Xi'w%Xi'x%XiY%Xi[%Xi]%Xia%Xie%Xi(R%Xi']%Xi~OY'qO['rO]*mO~OVuO_!QOg!ZOv!ROyhO{!SO!O!UO!P!TO!S!VO!V!WO!Y!XO!evO!fvO!gYO!hYO!o!YO#ZfO#[fO#y!_O$h![O$k!]O$owO$sxO$uyO$w!^O$yzO${{O$}|O%P}O%Q}O%Y!OO&jPO&vPO&y[O&|YO&}YO'RSO'SVO'TTO'UeO'`YO'aZO'cWO'dXO'eYO'fYO'gYO'hYO'p^O'u_O'w`O'xaO[&tP]&tPe&tP~OP*qO~P&HuO]&tPe&tP~P]O]*vO~O]*vOe'wO~O['vO]*vOe'wO~OyxX~P$5POy*yO~O]|X~P$5PO]*zO~O'S*{O~O&v%}O'Y*|O'_&PO~O'_%zO~O]+OO~O]+QO~O]+RO~O'S+SO~O'U+TO~O&c(^O&d(]O&h>fO&|+VO&}+VO&v'^X'_'^X~O&v+WO'_+YO~O]+_O~OP+`O'[%pO~O!evO!fvO!g#qO!h#rO&e#vO'R#oO'SVO'T#xO'`#lO'cWO'dWO'e#nO'f#kO'g#qO'h#pO'}#mO(O#sO(P#tO(Q#uO(V#wO~O&|%vO&}%vO'Y&{X&v&{X'_&{X~P' uO'Y*|O~O]+fO~O]+gO~OP%WO&y$nO~P!;lO'Y(sO&j$la&v$la~O]+lO~O&`&tqY&tq[&tq]&tqa&tqe&tq~P]O&a7|O&i7|O~O&jPO&vPO'O!gO'P!hO~PDkO!u)RO!e!rq!f!rq!g!rq!h!rq!x!rq&`!rq&a!rq&c!rq&d!rq&e!rq&h!rq&i!rq&j!rq&v!rq&|!rq&}!rq'O!rq'P!rq'R!rq'S!rq'T!rq'Y!rq'`!rq'c!rq'd!rq'e!rq'f!rq'g!rq'h!rq'}!rq(O!rq(P!rq(Q!rq(V!rqg!rq'_!rqP!rqV!rq_!rqv!rqy!rq{!rq!O!rq!P!rq!S!rq!V!rq!Y!rq!o!rq#Z!rq#[!rq#y!rq$h!rq$k!rq$o!rq$s!rq$u!rq$w!rq$y!rq${!rq$}!rq%P!rq%Q!rq%Y!rq&y!rq'U!rq'Z!rq'a!rq'p!rq'u!rq'w!rq'x!rqY!rq[!rq]!rqa!rqe!rq(R!rq']!rq~OP$PXV$PX]$PX_$PXg$PXg'bXv$PXy$PX{$PX!O$PX!P$PX!S$PX!V$PX!Y$PX!e$PX!e'bX!f$PX!f'bX!g$PX!g'bX!h$PX!h'bX!o$PX#Z$PX#[$PX#y$PX$h$PX$k$PX$o$PX$s$PX$u$PX$w$PX$y$PX${$PX$}$PX%P$PX%Q$PX%Y$PX&a'bX&c'bX&d'bX&e'bX&h'bX&i'bX&y$PX&|$PX&|'bX&}$PX&}'bX'O'bX'R$PX'R'bX'S$PX'S'bX'T$PX'T'bX'U$PX'Y'bX'Z'bX'`$PX'`'bX'a$PX'c$PX'c'bX'd$PX'd'bX'e$PX'e'bX'f$PX'f'bX'g$PX'g'bX'h$PX'h'bX'p$PX'u$PX'w$PX'x$PX'}'bX(O'bX(P'bX(Q'bX(V'bX&v'bX'_'bX~OP$PXV$PX]$PX_$PXv$PXy$PX{$PX!O$PX!P$PX!S$PX!V$PX!Y$PX!e!dX!f!dX!g!dX!h!dX!o$PX#Z$PX#[$PX#y$PX$h$PX$k$PX$o$PX$s$PX$u$PX$w$PX$y$PX${$PX$}$PX%P$PX%Q$PX%Y$PX&a!dX&c!dX&d!dX&e!dX&h!dX&i!dX&y$PX&|!dX&}!dX'O!dX'R!dX'S!dX'T!dX'U$PX'Y!dX'Z!dX'`!dX'a$PX'c!dX'd!dX'e!dX'f!dX'g!dX'h!dX'p$PX'u$PX'w$PX'x$PX'}!dX(O!dX(P!dX(Q!dX(V!dX&v!dX'_!dX~Og!dX~P'0ZOg'VX!e'VX!f'VX!g'VX!h'VX&e'VX&|'VX&}'VX'R'VX'S'VX'T'VX'Y'VX'Z'VX'`'VX'c'VX'd'VX'e'VX'f'VX'g'VX'h'VX'}'VX(O'VX(P'VX(Q'VX(V'VX&v'VX'_'VXP'VXV'VX]'VX_'VXv'VXy'VX{'VX!O'VX!P'VX!S'VX!V'VX!Y'VX!o'VX#Z'VX#['VX#y'VX$h'VX$k'VX$o'VX$s'VX$u'VX$w'VX$y'VX${'VX$}'VX%P'VX%Q'VX%Y'VX&y'VX'U'VX'a'VX'p'VX'u'VX'w'VX'x'VX(R'VX']'VX~O&a+uO&c+wO&d+tO&h+sO&i+uO'O!gO~P'4uO&v+}O'O!gO'P!hO'_,QO~P%*ZOg'qX!e'qX!f'qX!g'qX!h'qX&a'qX&c'qX&d'qX&e'qX&f#dX&g#dX&h'qX&i'qX&|'qX&}'qX'O'qX'R'qX'S'qX'T'qX'Y'qX'Z'qX'`'qX'c'qX'd'qX'e'qX'f'qX'g'qX'h'qX'}'qX(O'qX(P'qX(Q'qX(V'qX&v'qX'_'qX~O(S,TO~P'9wOP>hOVuO])ZO_!QOg!ZOv!ROy)[O{!SO!O!UO!P!TO!S!VO!V!WO!Y!XO!evO!fvO!gYO!hYO!o!YO#Z)ZO#[)ZO#y)ZO$h![O$k!]O$o=PO$s=SO$u=^O$w!^O$yzO${{O$}3VO%P}O%Q}O%Y!OO&y)WO&|YO&}YO'RCnO'SVO'TCoO'U)YO'`YO'aYO'cWO'd8SO'eYO'fYO'gYO'hYO'p^O'u_O'w`O'xaO~O'Z,UO~P'<_Og'qX!e'qX!f'qX!g'qX!h'qX&c'qX&d'qX&e'qX&h'qX&|'qX&}'qX'O'qX'R'qX'S'qX'T'qX'Y'qX'Z'qX'`'qX'c'qX'd'qX'e'qX'f'qX'g'qX'h'qX'}'qX(O'qX(P'qX(Q'qX(V'qX&v'qX'_'qXP'qXV'qX]'qX_'qXv'qXy'qX{'qX!O'qX!P'qX!S'qX!V'qX!Y'qX!o'qX#Z'qX#['qX#y'qX$h'qX$k'qX$o'qX$s'qX$u'qX$w'qX$y'qX${'qX$}'qX%P'qX%Q'qX%Y'qX&y'qX'U'qX'a'qX'p'qX'u'qX'w'qX'x'qX(R'qX']'qX~O&a,YO&i,YO~P'?zO&a,`O&c,aO&h,ZO&e!zX'Y!zX'Z!zX'}!zX(O!zX(P!zX(Q!zX(V!zX&v!zX'_!zX(R!zX']!zX~P'<_O&a,`O&c,aO&e!zX'Y!zX'Z!zX'}!zX(O!zX(P!zX(Q!zX(V!zX&v!zX'_!zX(R!zX']!zX~P'<_Og,wO!evO!fvO!g,mO!h,nO&e,rO'R,kO'SVO'T,xO'`,hO'cWO'dWO'e,jO'f,gO'g,mO'h,lO'},iO(O,oO(P,pO(Q,qO(V,sO~O&|,uO&},uO'Y,dO'Z,vO~P'FoO(S,TO~O&a,YO&i,YO~P'4uO'Z,vO~O'Y,yO'Z,vO~O'Y,dO'Z,vO~O!evO!fvO!g4qO!h4xO&e#vO'R4cO'SVO'T5_O'`3|O'cWO'dWO'e4[O'f3uO'g4qO'h4jO'}4TO(O5PO(P5WO(QCxO(V#wO~O'Y,zO'],|O~P'IYO'Y,zO'],|O~O&vji'Yji'_ji~P'IYOV)mOg%yO&v'ka'_'ka'Z'ka~OPDYOVuO_!QOg!ZOv!ROyhO{!SO!O!UO!P!TO!S!VO!V!WO!Y!XO!evO!fvO!gYO!hYO!o!YO#ZfO#[fO#y!_O$h![O$k!]O$o=QO$s=WO$u=bO$w!^O$yzO${{O$}3XO%P}O%Q}O%Y!OO&y[O&|YO&}YO'RSO'SVO'TTO'UeO'`YO'a2}O'cWO'd2yO'eYO'fYO'gYO'hYO'p^O'u_O'w`O'xaO~O'Y-POV!kag!ka&v!ka'_!ka'Z!ka~O&v&zi&v'ji'_&zi'_'ji~O&v&zi&v'ji'_&zi'_'ji~P!DiO'_-TO~P%9YO&v'ja'_'ja~P!DiO'Y-WO&v'ja'_'ja~OPCpOVuO_!QOg!ZOv!ROyhO{!SO!O!UO!P!TO!S!VO!V!WO!Y!XO!evO!fvO!gYO!hYO!o!YO#ZfO#[fO#y!_O$h![O$k!]O$owO$s=[O$u=fO$w!^O$yzO${{O$}3ZO%P}O%Q}O%Y!OO&y[O&|YO&}YO'RSO'SVO'TTO'UeO'`YO'a3OO'cWO'd2zO'eYO'fYO'gYO'hYO'p^O'u_O'w`O'xaO~O'u-[O~O'w-]O~O'x-^O~O'Y&Ta'Z&Ta~P'IYO'Z-_O~P#.PO'Z-aO~P#*[O'S-gO~O%U'kO'S'gO!e&Za!f&Za!g&Za!h&Za&`&Za&e&Za&j&Za&v&Za&|&Za&}&Za'R&Za'T&Za'Y&Za'`&Za'c&Za'd&Za'e&Za'f&Za'g&Za'h&Za'}&Za(O&Za(P&Za(Q&Za(V&Zag&Za'_&ZaP&ZaV&Za_&Zav&Zay&Za{&Za!O&Za!P&Za!S&Za!V&Za!Y&Za!o&Za#Z&Za#[&Za#y&Za$h&Za$k&Za$o&Za$s&Za$u&Za$w&Za$y&Za${&Za$}&Za%P&Za%Q&Za%Y&Za&y&Za'U&Za'Z&Za'a&Za'p&Za'u&Za'w&Za'x&ZaY&Za[&Za]&Zaa&Zae&Za(R&Za']&Za~OP-jO'S-iO'p^O~P?SO]-oO~OPXaVXaYXa[Xa]Xa_XagXavXayXa{Xa!OXa!PXa!SXa!VXa!YXa!oXa#ZXa#[Xa#yXa$hXa$kXa$oXa$sXa$uXa$wXa$yXa${Xa$}Xa%PXa%QXa%YXa&jXa&vXa&yXa&|Xa&}Xa'UXa'aXa'pXa'uXa'wXa'xXa~P#BmO(S#]OPbXVbX[bX['QX]bX]'QX_bXebXe'QXgbXvbXybX{bX!ObX!PbX!SbX!VbX!YbX!ebX!e'QX!fbX!f'QX!gbX!g'QX!hbX!h'QX!obX#ZbX#[bX#ybX$hbX$kbX$obX$sbX$ubX$wbX$ybX${bX$}bX%PbX%QbX%YbX&e'QX&jbX&j'QX&vbX&v'QX&ybX&|bX&|'QX&}bX&}'QX'RbX'R'QX'SbX'S'QX'TbX'T'QX'UbX'Y'QX'`bX'`'QX'abX'cbX'c'QX'dbX'd'QX'ebX'e'QX'fbX'f'QX'gbX'g'QX'hbX'h'QX'pbX'ubX'wbX'xbX'}'QX(O'QX(P'QX(Q'QX(V'QX~P$:}OPcO~P&HuO]-qO~O]-qOe'wO~O]-sO~O&v&za'_&za~P!DiO'Y-uO&v&za'_&za~O]-vO~O&k(zO'R>RO'T8PO~O'Y-zO'Z-yO~P%*ZO'O!gO'P!hO'RCmO'T={O'_.PO~P!:ZO&v.QO'_.PO~OP'nXV'nX]'nX_'nXg'nXv'nXy'nX{'nX!O'nX!P'nX!S'nX!V'nX!Y'nX!e'nX!f'nX!g'nX!h'nX!o'nX!u'lX!x'nX#Z'nX#['nX#y'nX$h'nX$k'nX$o'nX$s'nX$u'nX$w'nX$y'nX${'nX$}'nX%P'nX%Q'nX%Y'nX&a'lX&c'lX&d'lX&h'lX&i'lX&j'nX&v'nX&y'nX&|'nX&}'nX'O'lX'P'lX'R'nX'S'nX'T'nX'U'nX'`'nX'a'nX'c'nX'd'nX'e'nX'f'nX'g'nX'h'nX'p'nX'u'nX'w'nX'x'nX~O!evO!fvO!g4mO!h4tO&e#vO'R4_O'SVO'T5ZO'`3xO'cWO'dWO'e4WO'f3qO'g4mO'h4fO'}4PO(O4{O(P5SO(QCtO(V#wO~OPhiVhi]hi_highivhiyhi{hi!Ohi!Phi!Shi!Vhi!Yhi!ohi#Zhi#[hi#yhi$hhi$khi$ohi$shi$uhi$whi$yhi${hi$}hi%Phi%Qhi%Yhi&jhi&vhi&yhi&|hi&}hi'Uhi'Yhi'ahi'phi'uhi'whi'xhi~P(:vO].UO~O&j$mi&v$mi'Y$mi~P'IYO&}.VO&j$mi&v$mi'Y$mi~O].WO~OP'mXV'mX]'mX_'mXg'mXv'mXy'mX{'mX!O'mX!P'mX!S'mX!V'mX!Y'mX!o'mX#Z'mX#['mX#y'mX$h'mX$k'mX$o'mX$s'mX$u'mX$w'mX$y'mX${'mX$}'mX%P'mX%Q'mX%Y'mX&j'mX&v'mX&y'mX&|'mX&}'mX'U'mX'Y'mX'a'mX'p'mX'u'mX'w'mX'x'mX~P(:vO'Y.XOP!vXV!vX]!vX_!vXg!vXv!vXy!vX{!vX!O!vX!P!vX!S!vX!V!vX!Y!vX!e!vX!f!vX!g!vX!h!vX!o!vX#Z!vX#[!vX#y!vX$h!vX$k!vX$o!vX$s!vX$u!vX$w!vX$y!vX${!vX$}!vX%P!vX%Q!vX%Y!vX&j!vX&v!vX&y!vX&|!vX&}!vX'R!vX'S!vX'T!vX'U!vX'`!vX'a!vX'c!vX'd!vX'e!vX'f!vX'g!vX'h!vX'p!vX'u!vX'w!vX'x!vX~O'S.[O~O'U.]O~O&y.^O~O&a.aO&i.aO~O'[.bO~O&|.eO&}.eO&v'tX'Y'tX'_'tX~P'FoO'_.fO&v'sX'_'sX~O&v.iO'Y.gO'_.kO&v'sX'_'sX~O'O!gO'P!hO&v#YX'_#YX~P%*ZO&v+}O'_.pO~Og#ja!e#ja!f#ja!g#ja!h#ja&a#ja&c#ja&d#ja&e#ja&h#ja&i#ja&|#ja&}#ja'O#ja'R#ja'S#ja'T#ja'Y#ja'Z#ja'`#ja'c#ja'd#ja'e#ja'f#ja'g#ja'h#ja'}#ja(O#ja(P#ja(Q#ja(S#Wa(V#ja&v#ja'_#jaP#jaV#ja]#ja_#jav#jay#ja{#ja!O#ja!P#ja!S#ja!V#ja!Y#ja!o#ja#Z#ja#[#ja#y#ja$h#ja$k#ja$o#ja$s#ja$u#ja$w#ja$y#ja${#ja$}#ja%P#ja%Q#ja%Y#ja&y#ja'U#ja'a#ja'p#ja'u#ja'w#ja'x#ja(R#ja']#ja~O&v+}O'_.rO~O&v+}O'_.tO~O!evO!fvO&e,rO'SVO'cWO'dWO(V,sOP%}XV%}X]%}X_%}Xv%}Xy%}X{%}X!O%}X!P%}X!S%}X!V%}X!Y%}X!o%}X#Z%}X#[%}X#y%}X$h%}X$k%}X$o%}X$s%}X$u%}X$w%}X$y%}X${%}X$}%}X%P%}X%Q%}X%Y%}X&v%}X&y%}X&|%}X&}%}X'U%}X'a%}X'p%}X'u%}X'w%}X'x%}X~Og,wO!g9qO!h9xO'R9cO'T:_O'Y.wO'Z.yO'`8|O'e9[O'f8uO'g9qO'h9jO'}9TO(O:PO(P:WO(QC}O~P(M^OP>kOVuO])ZO_!QOg!ZOv!ROy)[O{!SO!O!UO!P!TO!S!VO!V!WO!Y!XO!evO!fvO!gYO!hYO!o!YO#Z)ZO#[)ZO#y)ZO$h![O$k!]O$o=PO$s=YO$u=dO$w!^O$yzO${{O$}3]O%P}O%Q}O%Y!OO&y)WO&|YO&}YO'RCnO'SVO'TCoO'U)YO'`YO'aYO'cWO'd8SO'eYO'fYO'gYO'hYO'p^O'u_O'w`O'xaO~O&v#tX'Z#tX~P)#cO&v.}O'Z/PO~O'S/RO~O&|/UO&}/UOP&QXV&QX]&QX_&QXg&QXv&QXy&QX{&QX!O&QX!P&QX!S&QX!V&QX!Y&QX!o&QX#Z&QX#[&QX#y&QX$h&QX$k&QX$o&QX$s&QX$u&QX$w&QX$y&QX${&QX$}&QX%P&QX%Q&QX%Y&QX&y&QX'U&QX'Z&QX'a&QX'p&QX'u&QX'w&QX'x&QX&v&QX'_&QX(R&QX']&QX~O!evO!fvO!g9qO!h9xO&e,rO'R9cO'SVO'T:_O'Y/SO'`8|O'cWO'dWO'e9[O'f8uO'g9qO'h9jO'}9TO(O:PO(P:WO(QC}O(V,sO~P)'`O!e&QX!f&QX!g&QX!h&QX&e&QX'R&QX'S&QX'T&QX'Y&QX'`&QX'c&QX'd&QX'e&QX'f&QX'g&QX'h&QX'}&QX(O&QX(P&QX(Q&QX(V&QX~P)'`O&e#{X'Y#{X'Z#{X'}#{X(O#{X(P#{X(Q#{X(V#{X&v#{X'_#{X(R#{X']#{X~P'<_O(V,sOg$Oa!e$Oa!f$Oa!g$Oa!h$Oa&e$Oa&|$Oa&}$Oa'R$Oa'S$Oa'T$Oa'Y$Oa'Z$Oa'`$Oa'c$Oa'd$Oa'e$Oa'f$Oa'g$Oa'h$Oa'}$Oa(O$Oa(P$Oa(Q$Oa&v$Oa'_$OaP$OaV$Oa]$Oa_$Oav$Oay$Oa{$Oa!O$Oa!P$Oa!S$Oa!V$Oa!Y$Oa!o$Oa#Z$Oa#[$Oa#y$Oa$h$Oa$k$Oa$o$Oa$s$Oa$u$Oa$w$Oa$y$Oa${$Oa$}$Oa%P$Oa%Q$Oa%Y$Oa&y$Oa'U$Oa'a$Oa'p$Oa'u$Oa'w$Oa'x$Oa(R$Oa']$Oa~OP>jOVuO])ZO_!QOg!ZOv!ROy)[O{!SO!O!UO!P!TO!S!VO!V!WO!Y!XO!evO!fvO!gYO!hYO!o!YO#Z)ZO#[)ZO#y)ZO$h![O$k!]O$owO$sxO$uyO$w!^O$yzO${{O$}|O%P}O%Q}O%Y!OO&y)WO&|YO&}YO'RCnO'SVO'TCoO'U)YO'`YO'a8XO'cWO'd8VO'eYO'fYO'gYO'hYO'p^O'u_O'w`O'xaO~O'Z/]O~P)2XO'Y/^O'Z/]O~OV/bOg,wO'Y'zX'Z'zX~OPDbOVuO])ZO_!QOg!ZOv!ROy)[O{!SO!O!UO!P!TO!S!VO!V!WO!Y!XO!evO!fvO!gYO!hYO!o!YO#Z)ZO#[)ZO#y)ZO$h![O$k!]O$owO$s=[O$u=fO$w!^O$yzO${{O$}3[O%P}O%Q}O%Y!OO&y)WO&|YO&}YO'RCnO'SVO'TCoO'U)YO'`YO'a8[O'cWO'd8WO'eYO'fYO'gYO'hYO'p^O'u_O'w`O'xaO~O(T/nO~OP>jOVuO])ZO_!QOg!ZOv!ROy)[O{!SO!O!UO!P!TO!S!VO!V!WO!Y!XO!evO!fvO!gYO!hYO!o!YO#Z)ZO#[)ZO#y)ZO$h![O$k!]O$owO$s=ZO$u=eO$w!^O$yzO${{O$}3ZO%P}O%Q}O%Y!OO&y)WO&|YO&}YO'RCnO'SVO'TCoO'U)YO'`YO'a8[O'cWO'd8WO'eYO'fYO'gYO'hYO'p^O'u_O'w`O'xaO~OP/qO&y/pO~O'O!gO'P!hO']/vO~P#.PO'Y/wO']/vO~O!evO!fvO!g?tO!h?xO&e#vO'R?lO'SVO'T@UO'`?`O'cWO'dWO'e?hO'f?[O'g?tO'h?pO'}?dO(O?|O(P@QO(QDlO(V#wO~OV!lag!la&v!la'_!la'Z!la~P)=xO'Y-POV!kig!ki&v!ki'_!ki'Z!ki~O&v&zq&v'jq'_&zq'_'jq~O'O!gO'P!hO~P!'wO&v'ji'_'ji~P!DiO!evO!fvO!g?uO!h?yO&e#vO'R?mO'SVO'T@VO'`?aO'cWO'dWO'e?iO'f?]O'g?uO'h?qO'}?eO(O?}O(P@RO(QDmO(V#wO~O'_/|O~P)@uO&`%ei&j%ei&v%ei'Y%ei'h%eiY%ei[%ei]%eia%eie%ei']%ei'_%ei'Z%ei(R%ei~P%CRO&`%iy&j%iy&v%iyY%iy[%iy]%iya%iye%iy~P%GmO&k(zO'R&wO'T8QO~O!evO!fvO&e#vO'SVO'cWO'dWO(V#wO&`%cy&j%cy&v%cy&|%cy&}%cy'Y%cy'h%cy'}%cyY%cy[%cy]%cya%cye%cy'_%cy']%cy'Z%cy(R%cy~O!g#qO!h#rO'R#oO'T#xO'`#lO'e#nO'f#kO'g#qO(O#sO(P#tO(Q#uO~P)DVOP'fO&i!pO'S$cO~O%U0RO'Y0PO!e(YX!f(YX!g(YX!h(YX&`(YX&e(YX&j(YX&v(YX&|(YX&}(YX'R(YX'T(YX'`(YX'c(YX'd(YX'e(YX'f(YX'g(YX'h(YX'}(YX(O(YX(P(YX(Q(YX(V(YXg(YX'_(YXP(YXV(YX_(YXv(YXy(YX{(YX!O(YX!P(YX!S(YX!V(YX!Y(YX!o(YX#Z(YX#[(YX#y(YX$h(YX$k(YX$o(YX$s(YX$u(YX$w(YX$y(YX${(YX$}(YX%P(YX%Q(YX%Y(YX&y(YX'U(YX'Z(YX'a(YX'p(YX'u(YX'w(YX'x(YXY(YX[(YX](YXa(YXe(YX(R(YX'](YX~O'S'gO~P)FuO%U0RO'S'gO~O'Y0PO!e(YX!f(YX!g(YX!h(YX&`(YX&e(YX&j(YX&v(YX&|(YX&}(YX'R(YX'S(YX'T(YX'`(YX'c(YX'd(YX'e(YX'f(YX'g(YX'h(YX'}(YX(O(YX(P(YX(Q(YX(V(YXg(YX'_(YXP(YXV(YX_(YXv(YXy(YX{(YX!O(YX!P(YX!S(YX!V(YX!Y(YX!o(YX#Z(YX#[(YX#y(YX$h(YX$k(YX$o(YX$s(YX$u(YX$w(YX$y(YX${(YX$}(YX%P(YX%Q(YX%Y(YX&y(YX'U(YX'Z(YX'a(YX'p(YX'u(YX'w(YX'x(YXY(YX[(YX](YXa(YXe(YX(R(YX'](YX~O'S(YX~P)FuO]0SO~O&v&zi'_&zi~P!DiO&|0UO&}0UO'Y0VO'Z0XO~P'FoO'Z0XO~O'Y0YO'Z0XO~O'Y0VO'Z0XO~O&c(^O&d(]O&h>fO&v!ci'_!ci~O'O!gO'P!hO'RCmO'T={O'_0ZO~P!:ZO]0]O~O]0^O~O'Y.XOP!vaV!va]!va_!vag!vav!vay!va{!va!O!va!P!va!S!va!V!va!Y!va!e!va!f!va!g!va!h!va!o!va#Z!va#[!va#y!va$h!va$k!va$o!va$s!va$u!va$w!va$y!va${!va$}!va%P!va%Q!va%Y!va&j!va&v!va&y!va&|!va&}!va'R!va'S!va'T!va'U!va'`!va'a!va'c!va'd!va'e!va'f!va'g!va'h!va'p!va'u!va'w!va'x!va~O]0bO~O&k(zO'R>QO'T8RO'p^O&a#Va&i#Va~O'Y0gO'Z0fO~P%*ZO&v+}O'O!gO'P!hO'_0kO~P%*ZO!u)ROg#Ui!e#Ui!f#Ui!g#Ui!h#Ui&a#Ui&c#Ui&d#Ui&e#Ui&h#Ui&i#Ui&|#Ui&}#Ui'O#Ui'R#Ui'S#Ui'T#Ui'Y#Ui'Z#Ui'`#Ui'c#Ui'd#Ui'e#Ui'f#Ui'g#Ui'h#Ui'}#Ui(O#Ui(P#Ui(Q#Ui(V#Ui&v#Ui'_#UiP#UiV#Ui]#Ui_#Uiv#Uiy#Ui{#Ui!O#Ui!P#Ui!S#Ui!V#Ui!Y#Ui!o#Ui#Z#Ui#[#Ui#y#Ui$h#Ui$k#Ui$o#Ui$s#Ui$u#Ui$w#Ui$y#Ui${#Ui$}#Ui%P#Ui%Q#Ui%Y#Ui&y#Ui'U#Ui'a#Ui'p#Ui'u#Ui'w#Ui'x#Ui(R#Ui']#Ui~O'O!gO'P!hO~P)9uO'O!gO'P!hO&v'sa&v'ya'_'sa'_'ya~P%*ZO'Y0sO&v'sa&v'ya'_'sa'_'ya~OPDbOVuO])ZO_!QOg!ZOv!ROy)[O{!SO!O!UO!P!TO!S!VO!V!WO!Y!XO!evO!fvO!gYO!hYO!o!YO#Z)ZO#[)ZO#y)ZO$h![O$k!]O$owO$s=XO$u=cO$w!^O$yzO${{O$}|O%P}O%Q}O%Y!OO&y)WO&|YO&}YO'O!gO'P!hO'RCnO'SVO'TCoO'U)YO'`YO'a8XO'cWO'd8VO'eYO'fYO'gYO'hYO'p^O'u_O'w`O'xaO~O'_0wO~P*/TO&v0xO'_0wO~O'Y0zO&v'sX'_'sX~Og#ji!e#ji!f#ji!g#ji!h#ji&a#ji&c#ji&d#ji&e#ji&h#ji&i#ji&|#ji&}#ji'O#ji'R#ji'S#ji'T#ji'Y#ji'Z#ji'`#ji'c#ji'd#ji'e#ji'f#ji'g#ji'h#ji'}#ji(O#ji(P#ji(Q#ji(S#Wi(V#ji&v#ji'_#jiP#jiV#ji]#ji_#jiv#jiy#ji{#ji!O#ji!P#ji!S#ji!V#ji!Y#ji!o#ji#Z#ji#[#ji#y#ji$h#ji$k#ji$o#ji$s#ji$u#ji$w#ji$y#ji${#ji$}#ji%P#ji%Q#ji%Y#ji&y#ji'U#ji'a#ji'p#ji'u#ji'w#ji'x#ji(R#ji']#ji~O&v+}O'_0|O~O&v+}O'_0}O~O!evO!fvO!g,mO!h,nO&e,rO&|1OO&}1OO'R,kO'SVO'T,xO'`,hO'cWO'dWO'e,jO'f,gO'g,mO'},iO(O,oO(P,pO(Q,qO(V,sO~O'h,lOg$Si'Y$Si'Z$Si&v$Si'_$Si~P*8[O'Z1QO~P)9uO'Y1RO'Z1QO~O'Z1TO~O!g9vO!h9}O'R9hO'T:dO'`9RO'e9aO'f8zO'g9vO'h9oO'}9YO(O:UO(P:]O(QDSOg%}X'Z%}X~P(M^O'Z1VO~P)#cO&v1WO'Z1VO~O&k1YO~O'Y/SOP#}aV#}a]#}a_#}ag#}av#}ay#}a{#}a!O#}a!P#}a!S#}a!V#}a!Y#}a!e#}a!f#}a!g#}a!h#}a!o#}a#Z#}a#[#}a#y#}a$h#}a$k#}a$o#}a$s#}a$u#}a$w#}a$y#}a${#}a$}#}a%P#}a%Q#}a%Y#}a&e#}a&y#}a&|#}a&}#}a'R#}a'S#}a'T#}a'U#}a'Z#}a'`#}a'a#}a'c#}a'd#}a'e#}a'f#}a'g#}a'h#}a'p#}a'u#}a'w#}a'x#}a'}#}a(O#}a(P#}a(Q#}a(V#}a&v#}a'_#}a(R#}a']#}a~O!u)ROg!zi!e!zi!f!zi!g!zi!h!zi&e!zi&|!zi&}!zi'R!zi'S!zi'T!zi'Y!zi'Z!zi'`!zi'c!zi'd!zi'e!zi'f!zi'g!zi'h!zi'}!zi(O!zi(P!zi(Q!zi(V!zi&v!zi'_!ziP!ziV!zi]!zi_!ziv!ziy!zi{!zi!O!zi!P!zi!S!zi!V!zi!Y!zi!o!zi#Z!zi#[!zi#y!zi$h!zi$k!zi$o!zi$s!zi$u!zi$w!zi$y!zi${!zi$}!zi%P!zi%Q!zi%Y!zi&y!zi'U!zi'a!zi'p!zi'u!zi'w!zi'x!zi(R!zi']!zi~O!evO!fvO!g9tO!h9{O&e,rO'R9fO'SVO'T:bO'`9PO'cWO'dWO'e9_O'f8xO'g9tO'h9mO'}9WO(O:SO(P:ZO(QDQO(V,sO~O&|1aO&}1aO'Y%la'Z%la~P*DkO'Z1bO~P)2XOV/bOg,wO'Y'za'Z'za~OP>iOVuO])ZO_!QOg!ZOv!ROy)[O{!SO!O!UO!P!TO!S!VO!V!WO!Y!XO!evO!fvO!gYO!hYO!o!YO#Z)ZO#[)ZO#y)ZO$h![O$k!]O$o=QO$s=VO$u=aO$w!^O$yzO${{O$}3XO%P}O%Q}O%Y!OO&y)WO&|YO&}YO'RCnO'SVO'TCoO'U)YO'`YO'a8ZO'cWO'd8UO'eYO'fYO'gYO'hYO'p^O'u_O'w`O'xaO~O&e,rO(V,sOg$Qi!e$Qi!f$Qi!g$Qi!h$Qi&|$Qi&}$Qi'R$Qi'S$Qi'T$Qi'Y$Qi'Z$Qi'`$Qi'c$Qi'd$Qi'e$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi&v$Qi'_$QiP$QiV$Qi]$Qi_$Qiv$Qiy$Qi{$Qi!O$Qi!P$Qi!S$Qi!V$Qi!Y$Qi!o$Qi#Z$Qi#[$Qi#y$Qi$h$Qi$k$Qi$o$Qi$s$Qi$u$Qi$w$Qi$y$Qi${$Qi$}$Qi%P$Qi%Q$Qi%Y$Qi&y$Qi'U$Qi'a$Qi'p$Qi'u$Qi'w$Qi'x$Qi(R$Qi']$Qi~O'f$Qi~P*JWO&e,rO'f,gO(V,sOg$Qi!e$Qi!f$Qi!g$Qi!h$Qi&|$Qi&}$Qi'R$Qi'S$Qi'T$Qi'Y$Qi'Z$Qi'c$Qi'd$Qi'e$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi&v$Qi'_$Qi~O'`$Qi~P*NfO!evO!fvO!g,mO!h,nO&e,rO'R,kO'SVO'T,xO'`,hO'cWO'dWO'e,jO'f,gO'g,mO'},iO(O,oO(P,pO(Q,qO(V,sOg$Qi&|$Qi&}$Qi'Y$Qi'Z$Qi&v$Qi'_$Qi~O'h$Qi~P+!aO'`,hO~P*NfO&e,rO(V,sOg$Qi!e$Qi!f$Qi!g$Qi!h$Qi&|$Qi&}$Qi'R$Qi'S$Qi'T$Qi'Y$Qi'Z$Qi'c$Qi'd$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi&v$Qi'_$Qi~O'`,hO'e,jO'f,gO~P+$cO'h,lO~P+!aO&e,rO'R,kO'SVO'T,xO'`,hO'cWO'dWO'e,jO'f,gO(V,sOg$Qi!e$Qi!f$Qi&|$Qi&}$Qi'Y$Qi'Z$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi&v$Qi'_$Qi~O!g,mO!h,nO~P+&eO!g$Qi!h$Qi~P+&eO!evO!fvO!g,mO!h,nO&e,rO'R,kO'SVO'T,xO'`,hO'cWO'dWO'e,jO'f,gO'g,mO(P,pO(V,sOg$Qi&|$Qi&}$Qi'Y$Qi'Z$Qi'h$Qi'}$Qi(Q$Qi&v$Qi'_$Qi~O(O,oO~P+(jO(O$Qi~P+(jO!evO!fvO!g9wO!h:OO&e,rO'R9iO'SVO'T:eO'`9SO'cWO'dWO'e9bO'f8{O'g9wO'h9pO'}9ZO(O:VO(P:^O(QDTO(V,sO~O(R1fO~P+*lO!evO!fvO!g9uO!h9|O&e,rO'R9gO'SVO'T:cO'`9QO'cWO'dWO'e9`O'f8yO'g9uO'h9nO'}9XO(O:TO(P:[O(QDRO(V,sO~O'Y$]i'Z$]i~P+,TO&v+}O'O!gO'P!hO'_1iO~P)2XO!e1kO&}(iO'{(jO~O'Y1lOV#mag#ma'Z#ma&v#ma'_#ma~O&e,rO'SVO'cWO'dWO(V,sOg$Qi!e$Qi!f$Qi!g$Qi!h$Qi&|$Qi&}$Qi'T$Qi'Y$Qi'Z$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi&v$Qi'_$Qi~O'R,kO'`,hO'e,jO'f,gO~P+.pO'Y%ma']%ma~P'IYO'O!gO'P!hO']1nO~P#.POP1pO'S-iO'p^O~P?SO'Y0PO!e(Ya!f(Ya!g(Ya!h(Ya&`(Ya&e(Ya&j(Ya&v(Ya&|(Ya&}(Ya'R(Ya'S(Ya'T(Ya'`(Ya'c(Ya'd(Ya'e(Ya'f(Ya'g(Ya'h(Ya'}(Ya(O(Ya(P(Ya(Q(Ya(V(Yag(Ya'_(YaP(YaV(Ya_(Yav(Yay(Ya{(Ya!O(Ya!P(Ya!S(Ya!V(Ya!Y(Ya!o(Ya#Z(Ya#[(Ya#y(Ya$h(Ya$k(Ya$o(Ya$s(Ya$u(Ya$w(Ya$y(Ya${(Ya$}(Ya%P(Ya%Q(Ya%Y(Ya&y(Ya'U(Ya'Z(Ya'a(Ya'p(Ya'u(Ya'w(Ya'x(YaY(Ya[(Ya](Yaa(Yae(Ya(R(Ya'](Ya~OP1tO'SVO'p^O~P?SO'Z1vO~P)2XO'Y1wO'Z1vO~O&j$my&v$my'Y$my~P'IYO&|1zO&}1zO'Y1xO'Z1{O~P'FoO'Z1{O~O'Y1|O'Z1{O~O'Y1xO'Z1{O~O!u)ROg#Uq!e#Uq!f#Uq!g#Uq!h#Uq&a#Uq&c#Uq&d#Uq&e#Uq&h#Uq&i#Uq&|#Uq&}#Uq'O#Uq'R#Uq'S#Uq'T#Uq'Y#Uq'Z#Uq'`#Uq'c#Uq'd#Uq'e#Uq'f#Uq'g#Uq'h#Uq'}#Uq(O#Uq(P#Uq(Q#Uq(V#Uq&v#Uq'_#UqP#UqV#Uq]#Uq_#Uqv#Uqy#Uq{#Uq!O#Uq!P#Uq!S#Uq!V#Uq!Y#Uq!o#Uq#Z#Uq#[#Uq#y#Uq$h#Uq$k#Uq$o#Uq$s#Uq$u#Uq$w#Uq$y#Uq${#Uq$}#Uq%P#Uq%Q#Uq%Y#Uq&y#Uq'U#Uq'a#Uq'p#Uq'u#Uq'w#Uq'x#Uq(R#Uq']#Uq~O'Y2OO']2QO~P+,TO'Y2OO']2QO~O&v#Xi'Y#Xi'_#Xi~P+,TO&v'si&v'yi'_'si'_'yi~O'O!gO'P!hO&v'si&v'yi'_'si'_'yi~P%*ZO!evO!fvO!gAzO!hBOO&e,rO'RArO'SVO'TB[O'`AfO'cWO'dWO'eAnO'fAbO'gAzO'hAvO'}AjO(OBSO(PBWO(QDpO(V,sO~O&|>tO&}>tO&v'tX'_'tX~P+=uO'_2TO~P*/TO'O!gO'P!hO&v'sa'_'sa~P%*ZO'Y2WO&v'sa'_'sa~O'Y%za'Z%za~P+,TO'Z2ZO~P)9uO'Z2]O~P)#cO!evO!fvO!g9qO!h9xO&e,rO'R9cO'SVO'T:_O'`8|O'cWO'dWO'e9[O'f8uO'g9qO'}9TO(O:PO(P:WO(QC}O(V,sO~OP&RaV&Ra]&Ra_&Rag&Rav&Ray&Ra{&Ra!O&Ra!P&Ra!S&Ra!V&Ra!Y&Ra!o&Ra#Z&Ra#[&Ra#y&Ra$h&Ra$k&Ra$o&Ra$s&Ra$u&Ra$w&Ra$y&Ra${&Ra$}&Ra%P&Ra%Q&Ra%Y&Ra&y&Ra&|&Ra&}&Ra'U&Ra'Y&Ra'Z&Ra'a&Ra'h&Ra'p&Ra'u&Ra'w&Ra'x&Ra&v&Ra'_&Ra(R&Ra']&Ra~P+@sO&|/UO&}/UO'Y/SOP#|iV#|i]#|i_#|ig#|iv#|iy#|i{#|i!O#|i!P#|i!S#|i!V#|i!Y#|i!o#|i#Z#|i#[#|i#y#|i$h#|i$k#|i$o#|i$s#|i$u#|i$w#|i$y#|i${#|i$}#|i%P#|i%Q#|i%Y#|i&y#|i'U#|i'Z#|i'a#|i'h#|i'p#|i'u#|i'w#|i'x#|i&v#|i'_#|i(R#|i']#|i~P+@sO&|/UO&}/UOP#|iV#|i]#|i_#|ig#|iv#|iy#|i{#|i!O#|i!P#|i!S#|i!V#|i!Y#|i!e#|i!f#|i!g#|i!h#|i!o#|i#Z#|i#[#|i#y#|i$h#|i$k#|i$o#|i$s#|i$u#|i$w#|i$y#|i${#|i$}#|i%P#|i%Q#|i%Y#|i&e#|i&y#|i'R#|i'S#|i'T#|i'U#|i'Y#|i'Z#|i'`#|i'a#|i'c#|i'd#|i'e#|i'f#|i'g#|i'h#|i'p#|i'u#|i'w#|i'x#|i'}#|i(O#|i(P#|i(Q#|i(V#|i&v#|i'_#|i(R#|i']#|i~O!evO!fvO!g9sO!h9zO&e,rO'R9eO'SVO'T:aO'`9OO'cWO'dWO'e9^O'f8wO'g9sO'h9lO'}9VO(O:RO(P:YO(QDPO(V,sO~OV#rag#ra'Y#ra'Z#ra~P+L^O'Y2aO~O'Y1lOV#mig#mi'Z#mi&v#mi'_#mi~O%U0RO!e&[a!f&[a!g&[a!h&[a&`&[a&e&[a&j&[a&v&[a&|&[a&}&[a'R&[a'T&[a'Y&[a'`&[a'c&[a'd&[a'e&[a'f&[a'g&[a'h&[a'}&[a(O&[a(P&[a(Q&[a(V&[ag&[a'_&[aP&[aV&[a_&[av&[ay&[a{&[a!O&[a!P&[a!S&[a!V&[a!Y&[a!o&[a#Z&[a#[&[a#y&[a$h&[a$k&[a$o&[a$s&[a$u&[a$w&[a$y&[a${&[a$}&[a%P&[a%Q&[a%Y&[a&y&[a'U&[a'Z&[a'a&[a'p&[a'u&[a'w&[a'x&[aY&[a[&[a]&[aa&[ae&[a(R&[a']&[a~O'S'gO~P+NiO'S&[a~P+NiO'Y!^i'Z!^i~P+,TO'Z2fO~P)2XO'Z2gO~P)2XO'Y2hO'Z2gO~O'O!gO'P!hO']2lO~P)9uO'Y2mO']2lO~O&v'sq&v'yq'_'sq'_'yq~O'O!gO'P!hO~P)2XO'O!gO'P!hO&v'si'_'si~P%*ZOg$Ti'Y$Ti'Z$Ti'h$Ti&v$Ti'_$Ti~P*8[O'Y!_i'Z!_i~P+,TO!evO!fvO&e,rO'SVO'cWO'dWO(V,sOg$Ry&|$Ry&}$Ry'Y$Ry'Z$Ry'h$Ry'}$Ry&v$Ry'_$Ry~O!g,mO!h,nO'R,kO'T,xO'`,hO'e,jO'f,gO'g,mO(O,oO(P,pO(Q,qO~P,(WO'O!gO'P!hO&v'ya'_'ya~P%*ZO'Y2qO&v'ya'_'ya~OV#nig#ni'Y#ni'Z#ni&v#ni'_#ni~P+L^O'Z2rO~P)2XO'Y#Ri'Z#Ri~P+,TO'Y&Pa']&Pa~P+,TO'O!gO'P!hO']2sO~P)9uO'O!gO'P!hO&v'yi'_'yi~P%*ZOP%aXV%aX_%aXg%aXg'bXv%aXy%aX{%aX!O%aX!P%aX!S%aX!V%aX!Y%aX!e%aX!e'bX!f%aX!f'bX!g%aX!g'bX!h%aX!h'bX!o%aX#Z%aX#[%aX#y%aX$h%aX$k%aX$o%aX$s%aX$u%aX$w%aX$y%aX${%aX$}%aX%P%aX%Q%aX%Y%aX&a'bX&c'bX&d'bX&e'bX&h'bX&i'bX&v'bX&y%aX&|%aX&|'bX&}%aX&}'bX'O'bX'P'bX'R%aX'R'bX'S%aX'S'bX'T%aX'T'bX'U%aX'Y'bX'_'bX'`%aX'`'bX'a%aX'c%aX'c'bX'd%aX'd'bX'e%aX'e'bX'f%aX'f'bX'g%aX'g'bX'h%aX'h'bX'p%aX'u%aX'w%aX'x%aX'}'bX(O'bX(P'bX(Q'bX(V'bX'Z'bX~OP'bXV'bX_'bXg'bXv'bXy'bX{'bX!O'bX!P'bX!S'bX!V'bX!Y'bX!o'bX#Z'bX#['bX#y'bX$h'bX$k'bX$o'bX$s'bX$u'bX$w'bX$y'bX${'bX$}'bX%P'bX%Q'bX%Y'bX&y'bX'U'bX'a'bX'p'bX'u'bX'w'bX'x'bX~P0TOV'bX~P,,`OP%aXV%aX_%aXg%aXv%aXy%aX{%aX!O%aX!P%aX!S%aX!V%aX!Y%aX!e%aX!e'bX!f%aX!f'bX!g%aX!g'bX!h%aX!h'bX!o%aX#Z%aX#[%aX#y%aX$h%aX$k%aX$o%aX$s%aX$u%aX$w%aX$y%aX${%aX$}%aX%P%aX%Q%aX%Y%aX&a'bX&c'bX&d'bX&e'bX&h'bX&i'bX&v'bX&y%aX&|%aX&}%aX'O'bX'P'bX'R%aX'R'bX'S%aX'S'bX'T%aX'T'bX'U%aX'_'bX'`%aX'`'bX'a%aX'c%aX'c'bX'd%aX'd'bX'e%aX'e'bX'f%aX'f'bX'g%aX'g'bX'h%aX'h'bX'p%aX'u%aX'w%aX'x%aX'}'bX(O'bX(P'bX(Q'bX(V'bX'Z'bX'Y'bX~OV'bXg'bX~P,4eO&`'bX&j'bX(R'bX']'bXY'bX['bX]'bXa'bXe'bX~P,4eOP%aX_%aXg!dXv%aXy%aX{%aX!O%aX!P%aX!S%aX!V%aX!Y%aX!e!dX!f!dX!g!dX!h!dX!o%aX#Z%aX#[%aX#y%aX$h%aX$k%aX$o%aX$s%aX$u%aX$w%aX$y%aX${%aX$}%aX%P%aX%Q%aX%Y%aX&a!dX&c!dX&d!dX&e!dX&h!dX&i!dX&v!dX&y%aX&|!dX&}!dX'O!dX'P!dX'R!dX'S!dX'T!dX'U%aX'Y!dX'_!dX'`!dX'a%aX'c!dX'd!dX'e!dX'f!dX'g!dX'h!dX'p%aX'u%aX'w%aX'x%aX'}!dX(O!dX(P!dX(Q!dX(V!dX'Z!dX~OV%aX~P,:rOV!dX~P,:rOP%aX_%aXv%aXy%aX{%aX!O%aX!P%aX!S%aX!V%aX!Y%aX!e!dX!f!dX!g!dX!h!dX!o%aX#Z%aX#[%aX#y%aX$h%aX$k%aX$o%aX$s%aX$u%aX$w%aX$y%aX${%aX$}%aX%P%aX%Q%aX%Y%aX&a!dX&c!dX&d!dX&e!dX&h!dX&i!dX&v!dX&y%aX&|%aX&}%aX'O!dX'P!dX'R!dX'S!dX'T!dX'U%aX'_!dX'`!dX'a%aX'c!dX'd!dX'e!dX'f!dX'g!dX'h!dX'p%aX'u%aX'w%aX'x%aX'}!dX(O!dX(P!dX(Q!dX(V!dX'Z!dX'Y!dX~OV!dXg!dX~P,?eO&|%aX&}%aX~P6YOP`O&e#vO'`3|O'e4[O'f3uO(V#wO!e%bi!f%bi!g%bi!h%bi&`%bi&j%bi&v%bi'T%bi'Y%bi'g%bi'h%bi'}%bi(O%bi(P%bi(Q%bi']%bi'_%bi'Z%bi(R%biY%bi[%bi]%bia%bie%bi~O'R%bi'S%bi'c%bi'd%bi~P0BhO&e#vO(V#wO!e%bi!f%bi!g%bi!h%bi'R%bi'S%bi'T%bi'c%bi'd%bi'g%bi'h%bi'}%bi(O%bi(P%bi(Q%bi(R%bi~O'`3}O'e4]O'f3vO~P0DuOg%bi&v%bi&|%bi&}%bi'Y%bi'_%bi'Z%bi~P!BTO'h4fO~P0$sOV%big%bi&v%bi&|%bi&}%bi'Y%bi'_%bi'Z%bi~P.?[OV%big%bi&v%bi'Y%bi'_%bi'Z%bi~P.AYO'h4iO~P0*oO'h4jO~P0.wO(R%bi~P&5}O&e#vO'R4^O'SVO'T5YO'`3wO'cWO'dWO'e4VO'f3pO(V#wOg%bi!e%bi!f%bi&v%bi&|%bi&}%bi'Y%bi'_%bi'g%bi'h%bi'}%bi(O%bi(P%bi(Q%bi'Z%bi~O!g4lO!h4sO~P0HiO&e#vO'R4_O'SVO'T5ZO'`3xO'cWO'dWO'e4WO'f3qO(V#wOP%biV%bi_%big%biv%biy%bi{%bi!O%bi!P%bi!S%bi!V%bi!Y%bi!e%bi!f%bi!o%bi#Z%bi#[%bi#y%bi$h%bi$k%bi$o%bi$s%bi$u%bi$w%bi$y%bi${%bi$}%bi%P%bi%Q%bi%Y%bi&v%bi&y%bi&|%bi&}%bi'U%bi'Y%bi'Z%bi'a%bi'g%bi'h%bi'p%bi'u%bi'w%bi'x%bi'}%bi(O%bi(P%bi(Q%bi&`%bi&j%bi'_%biY%bi[%bi]%bia%bie%bi(R%bi']%bi~O!g4mO!h4tO~P0JdO&e#vO'R4`O'SVO'T5[O'`3yO'cWO'dWO'e4XO'f3rO(V#wOV%big%bi!e%bi!f%bi&v%bi&|%bi&}%bi'Y%bi'_%bi'g%bi'h%bi'}%bi(O%bi(P%bi(Q%bi'Z%bi~O!g4nO!h4uO~P1 UO&e#vO'R4aO'SVO'T5]O'`3zO'cWO'dWO'e4YO'f3sO(V#wOV%big%bi!e%bi!f%bi&v%bi'Y%bi'_%bi'g%bi'h%bi'}%bi(O%bi(P%bi(Q%bi'Z%bi~O!g4oO!h4vO~P1#SO&e#vO'R4bO'SVO'T5^O'`3{O'cWO'dWO'e4ZO'f3tO(V#wOP%biV%biY%bi[%bi]%bi_%big%biv%biy%bi{%bi!O%bi!P%bi!S%bi!V%bi!Y%bi!e%bi!f%bi!o%bi#Z%bi#[%bi#y%bi$h%bi$k%bi$o%bi$s%bi$u%bi$w%bi$y%bi${%bi$}%bi%P%bi%Q%bi%Y%bi&j%bi&v%bi&y%bi&|%bi&}%bi'U%bi'a%bi'g%bi'h%bi'p%bi'u%bi'w%bi'x%bi'}%bi(O%bi(P%bi(Q%bi~O!g4pO!h4wO~P1$zO&e#vO'R4cO'SVO'T5_O'`3|O'cWO'dWO'e4[O'f3uO(V#wO!e%bi!f%bi&`%bi&j%bi&v%bi'Y%bi'g%bi'h%bi'}%bi(O%bi(P%bi(Q%bi']%bi'_%bi'Z%bi(R%biY%bi[%bi]%bia%bie%bi~O!g4qO!h4xO~P1)SO&e#vO'R4dO'SVO'T5`O'`3}O'cWO'dWO'e4]O'f3vO(V#wO!e%bi!f%bi'g%bi'h%bi'}%bi(O%bi(P%bi(Q%bi(R%bi~O!g4rO!h4yO~P1+aO!g%bi!h%bi~P0HiO!g%bi!h%bi~P0JdO!g%bi!h%bi~P1 UO!g%bi!h%bi~P1#SO!g%bi!h%bi~P1$zO!g%bi!h%bi~P1)SO!g%bi!h%bi~P1+aO!evO!fvO!g4lO!h4sO&e#vO'R4^O'SVO'T5YO'`3wO'cWO'dWO'e4VO'f3pO'g4lO(P5RO(V#wOg%bi&v%bi&|%bi&}%bi'Y%bi'_%bi'h%bi'}%bi(Q%bi'Z%bi~O(O4zO~P1.bO!evO!fvO!g4mO!h4tO&e#vO'R4_O'SVO'T5ZO'`3xO'cWO'dWO'e4WO'f3qO'g4mO(P5SO(V#wOP%biV%bi_%big%biv%biy%bi{%bi!O%bi!P%bi!S%bi!V%bi!Y%bi!o%bi#Z%bi#[%bi#y%bi$h%bi$k%bi$o%bi$s%bi$u%bi$w%bi$y%bi${%bi$}%bi%P%bi%Q%bi%Y%bi&v%bi&y%bi&|%bi&}%bi'U%bi'Y%bi'Z%bi'a%bi'h%bi'p%bi'u%bi'w%bi'x%bi'}%bi(Q%bi&`%bi&j%bi'_%biY%bi[%bi]%bia%bie%bi(R%bi']%bi~O(O4{O~P10]O!evO!fvO!g4nO!h4uO&e#vO'R4`O'SVO'T5[O'`3yO'cWO'dWO'e4XO'f3rO'g4nO(P5TO(V#wOV%big%bi&v%bi&|%bi&}%bi'Y%bi'_%bi'h%bi'}%bi(Q%bi'Z%bi~O(O4|O~P14}O!evO!fvO!g4oO!h4vO&e#vO'R4aO'SVO'T5]O'`3zO'cWO'dWO'e4YO'f3sO'g4oO(P5UO(V#wOV%big%bi&v%bi'Y%bi'_%bi'h%bi'}%bi(Q%bi'Z%bi~O(O4}O~P16{O!evO!fvO!g4pO!h4wO&e#vO'R4bO'SVO'T5^O'`3{O'cWO'dWO'e4ZO'f3tO'g4pO(P5VO(V#wOP%biV%biY%bi[%bi]%bi_%big%biv%biy%bi{%bi!O%bi!P%bi!S%bi!V%bi!Y%bi!o%bi#Z%bi#[%bi#y%bi$h%bi$k%bi$o%bi$s%bi$u%bi$w%bi$y%bi${%bi$}%bi%P%bi%Q%bi%Y%bi&j%bi&v%bi&y%bi&|%bi&}%bi'U%bi'a%bi'h%bi'p%bi'u%bi'w%bi'x%bi'}%bi(Q%bi~O(O5OO~P18sO!evO!fvO!g4qO!h4xO&e#vO'R4cO'SVO'T5_O'`3|O'cWO'dWO'e4[O'f3uO'g4qO(P5WO(V#wO&`%bi&j%bi&v%bi'Y%bi'h%bi'}%bi(Q%bi']%bi'_%bi'Z%bi(R%biY%bi[%bi]%bia%bie%bi~O(O5PO~P1<{O!evO!fvO!g4rO!h4yO&e#vO'R4dO'SVO'T5`O'`3}O'cWO'dWO'e4]O'f3vO'g4rO(P5XO(V#wO'h%bi'}%bi(Q%bi(R%bi~O(O5QO~P1?YO(O%bi~P1.bO(O%bi~P10]O(O%bi~P14}O(O%bi~P16{O(O%bi~P18sO(O%bi~P1<{O(O%bi~P1?YO&e#vO'SVO'cWO'dWO(V#wOg%bi!e%bi!f%bi!g%bi!h%bi&v%bi&|%bi&}%bi'T%bi'Y%bi'_%bi'g%bi'h%bi'}%bi(O%bi(P%bi(Q%bi'Z%bi~O'R4^O'`3wO'e4VO'f3pO~P1AtO'R4_O'`3xO'e4WO'f3qOP%biV%bi_%big%biv%biy%bi{%bi!O%bi!P%bi!S%bi!V%bi!Y%bi!o%bi#Z%bi#[%bi#y%bi$h%bi$k%bi$o%bi$s%bi$u%bi$w%bi$y%bi${%bi$}%bi%P%bi%Q%bi%Y%bi&y%bi'U%bi'a%bi'p%bi'u%bi'w%bi'x%bi~P&7fO'R4`O'`3yO'e4XO'f3rOV%bi~P1AtO'R4aO'SVO'cWO'dWO~P0`O'R4cO'SVO'cWO'dWO~P0BhO&e#vO'SVO'cWO'dWO(V#wO!e%bi!f%bi!g%bi!h%bi'T%bi'g%bi'h%bi'}%bi(O%bi(P%bi(Q%bi(R%bi~O'R4dO'`3}O'e4]O'f3vO~P1GsO&a(ZO&i(ZO~O&a7{O&i7{O~O&a7}O&i7}O~OP'bXV'bX]'bX_'bXv'bXy'bX{'bX!O'bX!P'bX!S'bX!V'bX!Y'bX!o'bX#Z'bX#['bX#y'bX$h'bX$k'bX$o'bX$s'bX$u'bX$w'bX$y'bX${'bX$}'bX%P'bX%Q'bX%Y'bX&y'bX'U'bX'a'bX'p'bX'u'bX'w'bX'x'bX(R'bX']'bX~P'*nOV'bX~P'*nOP$PXV$PX]$PX_$PXg$PXv$PXy$PX{$PX!O$PX!P$PX!S$PX!V$PX!Y$PX!e$PX!e'bX!f$PX!f'bX!g$PX!g'bX!h$PX!h'bX!o$PX#Z$PX#[$PX#y$PX$h$PX$k$PX$o$PX$s$PX$u$PX$w$PX$y$PX${$PX$}$PX%P$PX%Q$PX%Y$PX&a'bX&c'bX&d'bX&e'bX&h'bX&i'bX&y$PX&|$PX&}$PX'O'bX'R$PX'R'bX'S$PX'S'bX'T$PX'T'bX'U$PX'Y'bX'Z'bX'`$PX'`'bX'a$PX'c$PX'c'bX'd$PX'd'bX'e$PX'e'bX'f$PX'f'bX'g$PX'g'bX'h$PX'h'bX'p$PX'u$PX'w$PX'x$PX'}'bX(O'bX(P'bX(Q'bX(V'bX&v'bX'_'bX~OV'bXg'bX~P1LdO&|'bX&}'bX(R'bX']'bX~P1LdOg$PX(R!dX']!dX~P'0ZOP$PXV!dX]$PX_$PXg!dXv$PXy$PX{$PX!O$PX!P$PX!S$PX!V$PX!Y$PX!e!dX!f!dX!g!dX!h!dX!o$PX#Z$PX#[$PX#y$PX$h$PX$k$PX$o$PX$s$PX$u$PX$w$PX$y$PX${$PX$}$PX%P$PX%Q$PX%Y$PX&a!dX&c!dX&d!dX&e!dX&h!dX&i!dX&y$PX'O!dX'R!dX'S!dX'T!dX'U$PX'Y!dX'Z!dX'`!dX'a$PX'c!dX'd!dX'e!dX'f!dX'g!dX'h!dX'p$PX'u$PX'w$PX'x$PX'}!dX(O!dX(P!dX(Q!dX(V!dX&v!dX'_!dX~O&|!dX&}!dX~P2$oO&|$PX&}$PX~P2$oO!e!dX!f!dX!g!dX!h!dX&c!dX&d!dX&e!dX&h!dX'O!dX'R!dX'S!dX'T!dX'`!dX'c!dX'd!dX'e!dX'f!dX'g!dX'h!dX'}!dX(O!dX(P!dX(Q!dX(R!dX(V!dX'Y!dX'Z!dX']!dX&v!dX'_!dX~OP$PXV$PX]$PX_$PXg$PXv$PXy$PX{$PX!O$PX!P$PX!S$PX!V$PX!Y$PX!o$PX#Z$PX#[$PX#y$PX$h$PX$k$PX$o$PX$s$PX$u$PX$w$PX$y$PX${$PX$}$PX%P$PX%Q$PX%Y$PX&a!dX&i!dX&y$PX&|$PX&}$PX'U$PX'a$PX'p$PX'u$PX'w$PX'x$PX~P2)eOP>iOVuO])ZO_!QOg!ZOv!ROy)[O{!SO!O!UO!P!TO!S!VO!V!WO!Y!XO!evO!fvO!gYO!hYO!o!YO#Z)ZO#[)ZO#y)ZO$h![O$k!]O$o=QO$s=TO$u=_O$w!^O$yzO${{O$}3WO%P}O%Q}O%Y!OO&y)WO&|YO&}YO'RCnO'SVO'TCoO'U)YO'`YO'a8YO'cWO'd8TO'eYO'fYO'gYO'hYO'p^O'u_O'w`O'xaO~OVhighi&vhi'Yhi'_hi'Zhi~P.AYO&|8dO&}8dOg%ei&v%ei'Y%ei'_%ei'h%ei'Z%ei~P/6nO!evO!fvO&e#vO'SVO'cWO'dWO(V#wOP%eiV%ei_%eig%eiv%eiy%ei{%ei!O%ei!P%ei!S%ei!V%ei!Y%ei!o%ei#Z%ei#[%ei#y%ei$h%ei$k%ei$o%ei$s%ei$u%ei$w%ei$y%ei${%ei$}%ei%P%ei%Q%ei%Y%ei&v%ei&y%ei'U%ei'a%ei'h%ei'p%ei'u%ei'w%ei'x%ei&j%eiY%ei[%ei]%ei~O!g4mO!h4tO&|8eO&}8eO'R4_O'T5ZO'`3xO'e4WO'f3qO'g4mO'}4PO(O4{O(P5SO(QCtO'Y%ei'Z%ei&`%ei'_%eia%eie%ei(R%ei']%ei~P22oO&|8fO&}8fOV%eig%ei&v%ei'Y%ei'_%ei'h%ei'Z%ei~P/0PO!g4pO!h4wO&|8gO&}8gO'R4bO'T5^O'`3{O'e4ZO'f3tO'g4pO'}4SO(O5OO(P5VO(QCwO~P22oO!evO!fvO&e#vO'SVO'cWO'dWO(V#wOg%cy&v%cy&|%cy&}%cy'Y%cy'_%cy'h%cy'}%cy'Z%cy~O!g4lO!h4sO'R4^O'T5YO'`3wO'e4VO'f3pO'g4lO(O4zO(P5RO(QCsO~P29QO!g4mO!h4tO'R4_O'T5ZO'`3xO'e4WO'f3qO'g4mO(O4{O(P5SO(QCtOP%cyV%cy_%cyg%cyv%cyy%cy{%cy!O%cy!P%cy!S%cy!V%cy!Y%cy!o%cy#Z%cy#[%cy#y%cy$h%cy$k%cy$o%cy$s%cy$u%cy$w%cy$y%cy${%cy$}%cy%P%cy%Q%cy%Y%cy&y%cy'U%cy'a%cy'p%cy'u%cy'w%cy'x%cy~P)DVO!g4nO!h4uO'R4`O'T5[O'`3yO'e4XO'f3rO'g4nO(O4|O(P5TO(QCuOV%cy~P29QO!evO!fvO&e#vO'SVO'cWO'dWO(V#wOV%cyg%cy&v%cy'_%cy'h%cy'}%cy'Z%cy~O!g4oO!h4vO'R4aO'T5]O'`3zO'e4YO'f3sO'g4oO(O4}O(P5UO(QCvO'Y%cy~P2>yO!evO!fvO&e#vO'SVO'cWO'dWO(V#wOP%cyV%cy_%cyg%cyv%cyy%cy{%cy!O%cy!P%cy!S%cy!V%cy!Y%cy!o%cy#Z%cy#[%cy#y%cy$h%cy$k%cy$o%cy$s%cy$u%cy$w%cy$y%cy${%cy$}%cy%P%cy%Q%cy%Y%cy&v%cy&y%cy&|%cy&}%cy'U%cy'a%cy'h%cy'p%cy'u%cy'w%cy'x%cy'}%cy~O!g4pO!h4wO'R4bO'T5^O'`3{O'e4ZO'f3tO'g4pO(O5OO(P5VO(QCwOY%cy[%cy]%cy&j%cy~P2@qO!evO!fvO&e#vO'SVO'cWO'dWO(V#wO&v%cy'h%cy'}%cy'_%cy(R%cy~O!g4qO!h4xO'R4cO'T5_O'`3|O'e4[O'f3uO'g4qO(O5PO(P5WO(QCxO&`%cy&j%cy'Y%cy']%cy'Z%cyY%cy[%cy]%cya%cye%cy~P2DyO!evO!fvO!g4rO!h4yO&e#vO'R4dO'SVO'T5`O'`3}O'cWO'dWO'e4]O'f3vO'g4rO(O5QO(P5XO(QCyO(V#wO~O'h%cy'}%cy(R%cy~P2GWO&|<_O&}<_O'h9jOP$SiV$Si]$Si_$Sig$Siv$Siy$Si{$Si!O$Si!P$Si!S$Si!V$Si!Y$Si!o$Si#Z$Si#[$Si#y$Si$h$Si$k$Si$o$Si$s$Si$u$Si$w$Si$y$Si${$Si$}$Si%P$Si%Q$Si%Y$Si&v$Si&y$Si'U$Si'Y$Si'Z$Si'a$Si'p$Si'u$Si'w$Si'x$Si'_$Si(R$Si']$Si~P+@sO!evO!fvO!g9rO!h9yO&e,rO&|<`O&}<`O'R9dO'SVO'T:`O'`8}O'cWO'dWO'e9]O'f8vO'g9rO'}9UO(O:QO(P:XO(QDOO(V,sO~O'h9kOV$Sig$Si'Y$Si'Z$Si&v$Si'_$Si~P2KpO&|[O'`8|O'f8uOP$QiV$Qi]$Qi_$Qiv$Qiy$Qi{$Qi!O$Qi!P$Qi!S$Qi!V$Qi!Y$Qi!o$Qi#Z$Qi#[$Qi#y$Qi$h$Qi$k$Qi$o$Qi$s$Qi$u$Qi$w$Qi$y$Qi${$Qi$}$Qi%P$Qi%Q$Qi%Y$Qi&y$Qi'U$Qi'a$Qi'e$Qi'p$Qi'u$Qi'w$Qi'x$Qi(R$Qi']$Qi~P+$cO'`8}O'f8vOV$Qi'e$Qi~P+$cO'`9OO~P3$rO'`9PO~P3&jO'`9QO~P3(eO'`9RO~P3*YO'`9SO~P3.[O'`8|O'e9[O'f8uOP$QiV$Qi]$Qi_$Qiv$Qiy$Qi{$Qi!O$Qi!P$Qi!S$Qi!V$Qi!Y$Qi!o$Qi#Z$Qi#[$Qi#y$Qi$h$Qi$k$Qi$o$Qi$s$Qi$u$Qi$w$Qi$y$Qi${$Qi$}$Qi%P$Qi%Q$Qi%Y$Qi&y$Qi'U$Qi'a$Qi'p$Qi'u$Qi'w$Qi'x$Qi(R$Qi']$Qi~P+$cO'`8}O'e9]O'f8vOV$Qi~P+$cO&e,rO'`9OO'e9^O'f8wO(V,sOV$Qig$Qi!e$Qi!f$Qi!g$Qi!h$Qi'T$Qi'Y$Qi'Z$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi&v$Qi'_$Qi~O'R$Qi'S$Qi'c$Qi'd$Qi~P3FlO&e,rO'`9PO'e9_O'f8xO(V,sO!e$Qi!f$Qi!g$Qi!h$Qi&|$Qi&}$Qi'T$Qi'Y$Qi'Z$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi']$Qi&v$Qi'_$Qi~O'R$Qi'S$Qi'c$Qi'd$Qi~P3HdO&e,rO'`9QO'e9`O'f8yO(V,sO!e$Qi!f$Qi!g$Qi!h$Qi'T$Qi'Y$Qi'Z$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi']$Qi&v$Qi'_$Qi~O'R$Qi'S$Qi'c$Qi'd$Qi~P3J_O&e,rO'`9RO'e9aO'f8zO(V,sOP$QiV$Qi]$Qi_$Qig$Qiv$Qiy$Qi{$Qi!O$Qi!P$Qi!S$Qi!V$Qi!Y$Qi!e$Qi!f$Qi!g$Qi!h$Qi!o$Qi#Z$Qi#[$Qi#y$Qi$h$Qi$k$Qi$o$Qi$s$Qi$u$Qi$w$Qi$y$Qi${$Qi$}$Qi%P$Qi%Q$Qi%Y$Qi&v$Qi&y$Qi&|$Qi&}$Qi'T$Qi'U$Qi'Z$Qi'a$Qi'g$Qi'h$Qi'p$Qi'u$Qi'w$Qi'x$Qi'}$Qi(O$Qi(P$Qi(Q$Qi~O'R$Qi'S$Qi'c$Qi'd$Qi~P3LSO&e,rO(V,sO!e$Qi!f$Qi!g$Qi!h$Qi'R$Qi'S$Qi'T$Qi'c$Qi'd$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi(R$Qi~O'`9SO'e9bO'f8{O~P4!UO'h9jOP$QiV$Qi]$Qi_$Qig$Qiv$Qiy$Qi{$Qi!O$Qi!P$Qi!S$Qi!V$Qi!Y$Qi!o$Qi#Z$Qi#[$Qi#y$Qi$h$Qi$k$Qi$o$Qi$s$Qi$u$Qi$w$Qi$y$Qi${$Qi$}$Qi%P$Qi%Q$Qi%Y$Qi&v$Qi&y$Qi&|$Qi&}$Qi'U$Qi'Y$Qi'Z$Qi'a$Qi'p$Qi'u$Qi'w$Qi'x$Qi'_$Qi(R$Qi']$Qi~P+@sO'h9kO~P32tO'h9lO~P34rO'h9mO~P36jO'h9nO~P38eO'h9oO~P3:YO(R$Qi~P+*lO&e,rO'R9cO'SVO'T:_O'`8|O'cWO'dWO'e9[O'f8uO(V,sOP$QiV$Qi]$Qi_$Qig$Qiv$Qiy$Qi{$Qi!O$Qi!P$Qi!S$Qi!V$Qi!Y$Qi!e$Qi!f$Qi!o$Qi#Z$Qi#[$Qi#y$Qi$h$Qi$k$Qi$o$Qi$s$Qi$u$Qi$w$Qi$y$Qi${$Qi$}$Qi%P$Qi%Q$Qi%Y$Qi&v$Qi&y$Qi&|$Qi&}$Qi'U$Qi'Y$Qi'Z$Qi'a$Qi'g$Qi'h$Qi'p$Qi'u$Qi'w$Qi'x$Qi'}$Qi(O$Qi(P$Qi(Q$Qi'_$Qi(R$Qi']$Qi~O!g9qO!h9xO~P4'jO&e,rO'R9dO'SVO'T:`O'`8}O'cWO'dWO'e9]O'f8vO(V,sOV$Qig$Qi!e$Qi!f$Qi&|$Qi&}$Qi'Y$Qi'Z$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi&v$Qi'_$Qi~O!g9rO!h9yO~P4+xO&e,rO'R9eO'SVO'T:aO'`9OO'cWO'dWO'e9^O'f8wO(V,sOV$Qig$Qi!e$Qi!f$Qi'Y$Qi'Z$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi&v$Qi'_$Qi~O!g9sO!h9zO~P4-vO&e,rO'R9fO'SVO'T:bO'`9PO'cWO'dWO'e9_O'f8xO(V,sO!e$Qi!f$Qi&|$Qi&}$Qi'Y$Qi'Z$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi']$Qi&v$Qi'_$Qi~O!g9tO!h9{O~P4/nO&e,rO'R9gO'SVO'T:cO'`9QO'cWO'dWO'e9`O'f8yO(V,sO!e$Qi!f$Qi'Y$Qi'Z$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi']$Qi&v$Qi'_$Qi~O!g9uO!h9|O~P41iO&e,rO'R9hO'SVO'T:dO'`9RO'cWO'dWO'e9aO'f8zO(V,sOP$QiV$Qi]$Qi_$Qig$Qiv$Qiy$Qi{$Qi!O$Qi!P$Qi!S$Qi!V$Qi!Y$Qi!e$Qi!f$Qi!o$Qi#Z$Qi#[$Qi#y$Qi$h$Qi$k$Qi$o$Qi$s$Qi$u$Qi$w$Qi$y$Qi${$Qi$}$Qi%P$Qi%Q$Qi%Y$Qi&v$Qi&y$Qi&|$Qi&}$Qi'U$Qi'Z$Qi'a$Qi'g$Qi'h$Qi'p$Qi'u$Qi'w$Qi'x$Qi'}$Qi(O$Qi(P$Qi(Q$Qi~O!g9vO!h9}O~P43^O&e,rO'R9iO'SVO'T:eO'`9SO'cWO'dWO'e9bO'f8{O(V,sO!e$Qi!f$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi(R$Qi~O!g9wO!h:OO~P47`O!g$Qi!h$Qi~P4'jO!g$Qi!h$Qi~P4+xO!g$Qi!h$Qi~P4-vO!g$Qi!h$Qi~P4/nO!g$Qi!h$Qi~P41iO!g$Qi!h$Qi~P43^O!g$Qi!h$Qi~P47`O!evO!fvO!g9qO!h9xO&e,rO'R9cO'SVO'T:_O'`8|O'cWO'dWO'e9[O'f8uO'g9qO(P:WO(V,sOP$QiV$Qi]$Qi_$Qig$Qiv$Qiy$Qi{$Qi!O$Qi!P$Qi!S$Qi!V$Qi!Y$Qi!o$Qi#Z$Qi#[$Qi#y$Qi$h$Qi$k$Qi$o$Qi$s$Qi$u$Qi$w$Qi$y$Qi${$Qi$}$Qi%P$Qi%Q$Qi%Y$Qi&v$Qi&y$Qi&|$Qi&}$Qi'U$Qi'Y$Qi'Z$Qi'a$Qi'h$Qi'p$Qi'u$Qi'w$Qi'x$Qi'}$Qi(Q$Qi'_$Qi(R$Qi']$Qi~O(O:PO~P4:aO!evO!fvO!g9rO!h9yO&e,rO'R9dO'SVO'T:`O'`8}O'cWO'dWO'e9]O'f8vO'g9rO(P:XO(V,sOV$Qig$Qi&|$Qi&}$Qi'Y$Qi'Z$Qi'h$Qi'}$Qi(Q$Qi&v$Qi'_$Qi~O(O:QO~P4>oO!evO!fvO!g9sO!h9zO&e,rO'R9eO'SVO'T:aO'`9OO'cWO'dWO'e9^O'f8wO'g9sO(P:YO(V,sOV$Qig$Qi'Y$Qi'Z$Qi'h$Qi'}$Qi(Q$Qi&v$Qi'_$Qi~O(O:RO~P4@mO!evO!fvO!g9tO!h9{O&e,rO'R9fO'SVO'T:bO'`9PO'cWO'dWO'e9_O'f8xO'g9tO(P:ZO(V,sO&|$Qi&}$Qi'Y$Qi'Z$Qi'h$Qi'}$Qi(Q$Qi']$Qi&v$Qi'_$Qi~O(O:SO~P4BeO!evO!fvO!g9uO!h9|O&e,rO'R9gO'SVO'T:cO'`9QO'cWO'dWO'e9`O'f8yO'g9uO(P:[O(V,sO'Y$Qi'Z$Qi'h$Qi'}$Qi(Q$Qi']$Qi&v$Qi'_$Qi~O(O:TO~P4D`O!evO!fvO!g9vO!h9}O&e,rO'R9hO'SVO'T:dO'`9RO'cWO'dWO'e9aO'f8zO'g9vO(P:]O(V,sOP$QiV$Qi]$Qi_$Qig$Qiv$Qiy$Qi{$Qi!O$Qi!P$Qi!S$Qi!V$Qi!Y$Qi!o$Qi#Z$Qi#[$Qi#y$Qi$h$Qi$k$Qi$o$Qi$s$Qi$u$Qi$w$Qi$y$Qi${$Qi$}$Qi%P$Qi%Q$Qi%Y$Qi&v$Qi&y$Qi&|$Qi&}$Qi'U$Qi'Z$Qi'a$Qi'h$Qi'p$Qi'u$Qi'w$Qi'x$Qi'}$Qi(Q$Qi~O(O:UO~P4FTO!evO!fvO!g9wO!h:OO&e,rO'R9iO'SVO'T:eO'`9SO'cWO'dWO'e9bO'f8{O'g9wO(P:^O(V,sO'h$Qi'}$Qi(Q$Qi(R$Qi~O(O:VO~P4JVO(O$Qi~P4:aO(O$Qi~P4>oO(O$Qi~P4@mO(O$Qi~P4BeO(O$Qi~P4D`O(O$Qi~P4FTO(O$Qi~P4JVO'R9cO'`8|O'e9[O'f8uOP$QiV$Qi]$Qi_$Qiv$Qiy$Qi{$Qi!O$Qi!P$Qi!S$Qi!V$Qi!Y$Qi!o$Qi#Z$Qi#[$Qi#y$Qi$h$Qi$k$Qi$o$Qi$s$Qi$u$Qi$w$Qi$y$Qi${$Qi$}$Qi%P$Qi%Q$Qi%Y$Qi&y$Qi'U$Qi'a$Qi'p$Qi'u$Qi'w$Qi'x$Qi(R$Qi']$Qi~P+.pO'R9dO'`8}O'e9]O'f8vOV$Qi~P+.pO'R9eO'SVO'cWO'dWO~P3FlO'R9fO'SVO'cWO'dWO~P3HdO'R9gO'SVO'cWO'dWO~P3J_O'R9hO'SVO'cWO'dWO~P3LSO&e,rO'SVO'cWO'dWO(V,sO!e$Qi!f$Qi!g$Qi!h$Qi'T$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi(R$Qi~O'R9iO'`9SO'e9bO'f8{O~P5#]O&|<_O&}<_OP$TiV$Ti]$Ti_$Tig$Tiv$Tiy$Ti{$Ti!O$Ti!P$Ti!S$Ti!V$Ti!Y$Ti!o$Ti#Z$Ti#[$Ti#y$Ti$h$Ti$k$Ti$o$Ti$s$Ti$u$Ti$w$Ti$y$Ti${$Ti$}$Ti%P$Ti%Q$Ti%Y$Ti&v$Ti&y$Ti'U$Ti'Y$Ti'Z$Ti'a$Ti'h$Ti'p$Ti'u$Ti'w$Ti'x$Ti'_$Ti(R$Ti']$Ti~P+@sOV$Tig$Ti'Y$Ti'Z$Ti'h$Ti&v$Ti'_$Ti~P2KpO!evO!fvO!g9tO!h9{O&e,rO'R9fO'SVO'T:bO'`9PO'cWO'dWO'e9_O'f8xO'g9tO'}9WO(O:SO(P:ZO(QDQO(V,sO~O&|pO&}>pO'R=tO'SVO'T=zO'`=qO'cWO'dWO'e=sO'f=pO'g=vO'}=rO(O=xO(P=yO(QDiO(V#wO~O'h=uO(R%di&v%di'_%di~P61[O&a!eO&i!eO~O&a=iO&i=iO~O&a=gO&i=gO~O&|=oO&}=oO!e$pi!f$pi!g$pi!h$pi&e$pi'R$pi'S$pi'T$pi'Y$pi'`$pi'c$pi'd$pi'e$pi'f$pi'g$pi'h$pi'}$pi(O$pi(P$pi(Q$pi(V$pi(R$pi']$pi'_$pi'Z$pi~P&#sO'f=pO&v%bi&|%bi&}%bi'_%bi'`%bi'e%bi~P0DuO!evO!fvO!g=vO!h=wO&e#vO'R=tO'SVO'T=zO'`=qO'cWO'dWO'e=sO'f=pO'g=vO'}=rO(O=xO(P=yO(QDiO(V#wO&v%bi&|%bi&}%bi'_%bi(R%bi~O'h%bi~P65{O'`=qO'f=pO&v%bi&|%bi&}%bi'_%bi'e%bi~P0DuO'`=qO'e=sO'f=pO&v%bi&|%bi&}%bi'_%bi~P0DuO'h=uO~P65{O&e#vO'R=tO'SVO'T=zO'`=qO'cWO'dWO'e=sO'f=pO(V#wO!e%bi!f%bi&v%bi&|%bi&}%bi'_%bi'g%bi'h%bi'}%bi(O%bi(P%bi(Q%bi(R%bi~O!g=vO!h=wO~P68{O!g%bi!h%bi~P68{O!evO!fvO!g=vO!h=wO&e#vO'R=tO'SVO'T=zO'`=qO'cWO'dWO'e=sO'f=pO'g=vO(P=yO(V#wO&v%bi&|%bi&}%bi'_%bi'h%bi'}%bi(Q%bi(R%bi~O(O=xO~P6:zO(O%bi~P6:zO(R8hO~P&5}O(R8iO~P&5}O(R8jO~P&5}O(R8kO~P&5}O(R8lO~P&5}O(R8mO~P&5}O(R8nO~P&5}O'R=tO'`=qO'e=sO'f=pO&v%bi&|%bi&}%bi'_%bi~P1GsO'S8oO~O!evO!fvO!g=vO!h=wO&e#vO'R=tO'SVO'T=zO'`=qO'cWO'dWO'e=sO'f=pO'g=vO'}=rO(O=xO(P=yO(QDiO(V#wO~O&|=}O&}=}O'h=uO&v&{X'_&{X~P6>lO(S8qO&a'qX&f#dX&g#dX&i'qX~P'?zO(S8rOV'qX~P'9wO!e'qX!f'qX!g'qX!h'qX&a'qX&c'qX&d'qX&e'qX&f#dX&g#dX&h'qX&i'qX&|'qX&}'qX'O'qX'R'qX'S'qX'T'qX'Z'qX'`'qX'c'qX'd'qX'e'qX'f'qX'g'qX'h'qX'}'qX(O'qX(P'qX(Q'qX(V'qX&v'qX'_'qX~O(S8sO'Y'qX']'qX~P6@{OV'qXg'qX!e'qX!f'qX!g'qX!h'qX&a'qX&c'qX&d'qX&e'qX&f#dX&g#dX&h'qX&i'qX&v'qX&|'qX&}'qX'O'qX'R'qX'S'qX'T'qX'Z'qX'`'qX'c'qX'd'qX'e'qX'f'qX'g'qX'h'qX'}'qX(O'qX(P'qX(Q'qX(V'qX~O(S8tOP'qX]'qX_'qXv'qXy'qX{'qX!O'qX!P'qX!S'qX!V'qX!Y'qX!o'qX#Z'qX#['qX#y'qX$h'qX$k'qX$o'qX$s'qX$u'qX$w'qX$y'qX${'qX$}'qX%P'qX%Q'qX%Y'qX&y'qX'U'qX'a'qX'p'qX'u'qX'w'qX'x'qX~P6CcO(S8qO~O(S8rO~O(S8sO~O(S8tO~O'h%ei(R%ei&v%ei'_%ei~P61[O!g=vO!h=wO'R=tO'T=zO'`=qO'e=sO'f=pO'g=vO(O=xO(P=yO(QDiO&|%cy&}%cy~P2DyOPDbOVuO])ZO_!QOg!ZOv!ROy)[O{!SO!O!UO!P!TO!S!VO!V!WO!Y!XO!evO!fvO!gYO!hYO!o!YO#Z)ZO#[)ZO#y)ZO$h![O$k!]O$owO$s=[O$u=fO$w!^O$yzO${{O$}3ZO%P}O%Q}O%Y!OO&y)WO&|YO&}YO'RCnO'SVO'TCoO'U)YO'`YO'a8[O'cWO'd8WO'eYO'fYO'gYO'hYO'p^O'u_O'w`O'xaO~OPDaOVuO])ZO_!QOg!ZOv!ROy)[O{!SO!O!UO!P!TO!S!VO!V!WO!Y!XO!evO!fvO!gYO!hYO!o!YO#Z)ZO#[)ZO#y)ZO$h![O$k!]O$o=QO$s=WO$u=bO$w!^O$yzO${{O$}3XO%P}O%Q}O%Y!OO&y)WO&|YO&}YO'RCnO'SVO'TCoO'U)YO'`YO'a8ZO'cWO'd8UO'eYO'fYO'gYO'hYO'p^O'u_O'w`O'xaO~O(RUO!evO!fvO!g?uO!h?yO&e#vO'R?mO'SVO'T@VO'`?aO'cWO'dWO'e?iO'f?]O'g?uO'}?eO(O?}O(P@RO(QDmO(V#wO'_%bi&v%bi~O'h%bi~P7?yO'`?^O~P7/RO'`?_O~P73QO'`?`O~P74{O'`?aO~P76pO&e#vO'`?^O'e?fO'f?YO(V#wOP%biV%bi_%big%biv%biy%bi{%bi!O%bi!P%bi!S%bi!V%bi!Y%bi!e%bi!f%bi!g%bi!h%bi!o%bi#Z%bi#[%bi#y%bi$h%bi$k%bi$o%bi$s%bi$u%bi$w%bi$y%bi${%bi$}%bi%P%bi%Q%bi%Y%bi&v%bi&y%bi&|%bi&}%bi'T%bi'U%bi'Z%bi'a%bi'g%bi'h%bi'p%bi'u%bi'w%bi'x%bi'}%bi(O%bi(P%bi(Q%bi~O'R%bi'S%bi'c%bi'd%bi~P7BRO&e#vO'`?_O'e?gO'f?ZO(V#wOV%big%bi!e%bi!f%bi!g%bi!h%bi&v%bi&|%bi&}%bi'T%bi'_%bi'g%bi'h%bi'}%bi(O%bi(P%bi(Q%bi'Z%bi~O'R%bi'S%bi'c%bi'd%bi~P7FQO&e#vO'`?`O'e?hO'f?[O(V#wOV%big%bi!e%bi!f%bi!g%bi!h%bi&v%bi'T%bi'_%bi'g%bi'h%bi'}%bi(O%bi(P%bi(Q%bi'Z%bi~O'R%bi'S%bi'c%bi'd%bi~P7G{O&e#vO'`?aO'e?iO'f?]O(V#wO!e%bi!f%bi!g%bi!h%bi'T%bi'_%bi'g%bi'h%bi'}%bi(O%bi(P%bi(Q%bi&v%bi~O'R%bi'S%bi'c%bi'd%bi~P7IpO'h?nO~P78[O'h?oO~P7UO'h?qO~P7?yO&e#vO'R?jO'SVO'T@SO'`?^O'cWO'dWO'e?fO'f?YO(V#wOP%biV%bi_%big%biv%biy%bi{%bi!O%bi!P%bi!S%bi!V%bi!Y%bi!e%bi!f%bi!o%bi#Z%bi#[%bi#y%bi$h%bi$k%bi$o%bi$s%bi$u%bi$w%bi$y%bi${%bi$}%bi%P%bi%Q%bi%Y%bi&v%bi&y%bi&|%bi&}%bi'U%bi'Z%bi'a%bi'g%bi'h%bi'p%bi'u%bi'w%bi'x%bi'}%bi(O%bi(P%bi(Q%bi~O!g?rO!h?vO~P7KxO&e#vO'R?kO'SVO'T@TO'`?_O'cWO'dWO'e?gO'f?ZO(V#wOV%big%bi!e%bi!f%bi&v%bi&|%bi&}%bi'_%bi'g%bi'h%bi'}%bi(O%bi(P%bi(Q%bi'Z%bi~O!g?sO!h?wO~P8 wO&e#vO'R?lO'SVO'T@UO'`?`O'cWO'dWO'e?hO'f?[O(V#wOV%big%bi!e%bi!f%bi&v%bi'_%bi'g%bi'h%bi'}%bi(O%bi(P%bi(Q%bi'Z%bi~O!g?tO!h?xO~P8#rO&e#vO'R?mO'SVO'T@VO'`?aO'cWO'dWO'e?iO'f?]O(V#wO!e%bi!f%bi'_%bi'g%bi'h%bi'}%bi(O%bi(P%bi(Q%bi&v%bi~O!g?uO!h?yO~P8%gO!g%bi!h%bi~P7KxO!g%bi!h%bi~P8 wO!g%bi!h%bi~P8#rO!g%bi!h%bi~P8%gO!evO!fvO!g?rO!h?vO&e#vO'R?jO'SVO'T@SO'`?^O'cWO'dWO'e?fO'f?YO'g?rO(P@OO(V#wOP%biV%bi_%big%biv%biy%bi{%bi!O%bi!P%bi!S%bi!V%bi!Y%bi!o%bi#Z%bi#[%bi#y%bi$h%bi$k%bi$o%bi$s%bi$u%bi$w%bi$y%bi${%bi$}%bi%P%bi%Q%bi%Y%bi&v%bi&y%bi&|%bi&}%bi'U%bi'Z%bi'a%bi'h%bi'p%bi'u%bi'w%bi'x%bi'}%bi(Q%bi~O(O?zO~P8'{O!evO!fvO!g?sO!h?wO&e#vO'R?kO'SVO'T@TO'`?_O'cWO'dWO'e?gO'f?ZO'g?sO(P@PO(V#wOV%big%bi&v%bi&|%bi&}%bi'_%bi'h%bi'}%bi(Q%bi'Z%bi~O(O?{O~P8+zO!evO!fvO!g?tO!h?xO&e#vO'R?lO'SVO'T@UO'`?`O'cWO'dWO'e?hO'f?[O'g?tO(P@QO(V#wOV%big%bi&v%bi'_%bi'h%bi'}%bi(Q%bi'Z%bi~O(O?|O~P8-uO!evO!fvO!g?uO!h?yO&e#vO'R?mO'SVO'T@VO'`?aO'cWO'dWO'e?iO'f?]O'g?uO(P@RO(V#wO'_%bi'h%bi'}%bi(Q%bi&v%bi~O(O?}O~P8/jO(O%bi~P8'{O(O%bi~P8+zO(O%bi~P8-uO(O%bi~P8/jO'R?jO'SVO'cWO'dWO~P7BRO'R?kO'SVO'cWO'dWO~P7FQO'R?lO'SVO'cWO'dWO~P7G{O'R?mO'SVO'cWO'dWO~P7IpOPDaOVuO])ZO_!QOg!ZOv!ROy)[O{!SO!O!UO!P!TO!S!VO!V!WO!Y!XO!evO!fvO!gYO!hYO!o!YO#Z)ZO#[)ZO#y)ZO$h![O$k!]O$o=QO$s=UO$u=`O$w!^O$yzO${{O$}3WO%P}O%Q}O%Y!OO&y)WO&|YO&}YO'RCnO'SVO'TCoO'U)YO'`YO'a8YO'cWO'd8TO'eYO'fYO'gYO'hYO'p^O'u_O'w`O'xaO~OPDbOVuO])ZO_!QOg!ZOv!ROy)[O{!SO!O!UO!P!TO!S!VO!V!WO!Y!XO!evO!fvO!gYO!hYO!o!YO#Z)ZO#[)ZO#y)ZO$h![O$k!]O$owO$s=XO$u=cO$w!^O$yzO${{O$}|O%P}O%Q}O%Y!OO&y)WO&|YO&}YO'RCnO'SVO'TCoO'U)YO'`YO'a8XO'cWO'd8VO'eYO'fYO'gYO'hYO'p^O'u_O'w`O'xaO~OP%eiV%ei_%eig%eiv%eiy%ei{%ei!O%ei!P%ei!S%ei!V%ei!Y%ei!o%ei#Z%ei#[%ei#y%ei$h%ei$k%ei$o%ei$s%ei$u%ei$w%ei$y%ei${%ei$}%ei%P%ei%Q%ei%Y%ei&v%ei&y%ei'U%ei'Z%ei'a%ei'h%ei'p%ei'u%ei'w%ei'x%ei~P7)XOV%eig%ei&v%ei'_%ei'h%ei'Z%ei~P7-WO!g?rO!h?vO'R?jO'T@SO'`?^O'e?fO'f?YO'g?rO(O?zO(P@OO(QDjO'Z%cy~P2@qO!g?sO!h?wO'R?kO'T@TO'`?_O'e?gO'f?ZO'g?sO(O?{O(P@PO(QDkO&|%cy&}%cy~P2>yO!g?tO!h?xO'R?lO'T@UO'`?`O'e?hO'f?[O'g?tO(O?|O(P@QO(QDlO~P2>yO!evO!fvO!g?uO!h?yO&e#vO'R?mO'SVO'T@VO'`?aO'cWO'dWO'e?iO'f?]O'g?uO(O?}O(P@RO(QDmO(V#wO~O'_%cy'h%cy'}%cy&v%cy~P8?nO!evO!fvO!gAxO!hA|O&e,rO&|C`O&}C`O'RApO'SVO'TBYO'`AdO'cWO'dWO'eAlO'fA`O'gAxO'}AhO(OBQO(PBUO(QDnO(V,sO~O'hAtOV$Sig$Si&v$Si'_$Si'Z$Si~P8AYO&|CaO&}CaO(R$Si&v$Si'_$Si~P+=uO&e,rO'fA`O(V,sOV$Qig$Qi!e$Qi!f$Qi!g$Qi!h$Qi&v$Qi&|$Qi&}$Qi'R$Qi'S$Qi'T$Qi'_$Qi'c$Qi'd$Qi'e$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi'Z$Qi~O'`$Qi~P8ChO&e,rO'fAaO(V,sOV$Qig$Qi!e$Qi!f$Qi!g$Qi!h$Qi&v$Qi'R$Qi'S$Qi'T$Qi'_$Qi'c$Qi'd$Qi'e$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi'Z$Qi~O'`$Qi~P8EcO'fAbO&v$Qi&|$Qi&}$Qi'_$Qi'`$Qi'e$Qi~P4!UO&e,rO'fAcO(V,sO!e$Qi!f$Qi!g$Qi!h$Qi&v$Qi'R$Qi'S$Qi'T$Qi'_$Qi'c$Qi'd$Qi'e$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi~O'`$Qi~P8GqO!evO!fvO!gAxO!hA|O&e,rO'RApO'SVO'TBYO'`AdO'cWO'dWO'eAlO'fA`O'gAxO'}AhO(OBQO(PBUO(QDnO(V,sOV$Qig$Qi&v$Qi&|$Qi&}$Qi'_$Qi'Z$Qi~O'h$Qi~P8I]O!evO!fvO!gAyO!hA}O&e,rO'RAqO'SVO'TBZO'`AeO'cWO'dWO'eAmO'fAaO'gAyO'}AiO(OBRO(PBVO(QDoO(V,sOV$Qig$Qi&v$Qi'_$Qi'Z$Qi~O'h$Qi~P8KWO!evO!fvO!gAzO!hBOO&e,rO'RArO'SVO'TB[O'`AfO'cWO'dWO'eAnO'fAbO'gAzO'}AjO(OBSO(PBWO(QDpO(V,sO&v$Qi&|$Qi&}$Qi'_$Qi(R$Qi~O'h$Qi~P8L{O!evO!fvO!gA{O!hBPO&e,rO'RAsO'SVO'TB]O'`AgO'cWO'dWO'eAoO'fAcO'gA{O'}AkO(OBTO(PBXO(QDqO(V,sO&v$Qi'_$Qi~O'h$Qi~P8NpO'`AdO~P8ChO'`AeO~P8EcO'`AfO'fAbO&v$Qi&|$Qi&}$Qi'_$Qi'e$Qi~P4!UO'`AgO~P8GqO&e,rO'`AdO'eAlO'fA`O(V,sOV$Qig$Qi!e$Qi!f$Qi!g$Qi!h$Qi&v$Qi&|$Qi&}$Qi'T$Qi'_$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi'Z$Qi~O'R$Qi'S$Qi'c$Qi'd$Qi~P9#[O&e,rO'`AeO'eAmO'fAaO(V,sOV$Qig$Qi!e$Qi!f$Qi!g$Qi!h$Qi&v$Qi'T$Qi'_$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi'Z$Qi~O'R$Qi'S$Qi'c$Qi'd$Qi~P9%VO'`AfO'eAnO'fAbO&v$Qi&|$Qi&}$Qi'_$Qi~P4!UO&e,rO'`AgO'eAoO'fAcO(V,sO!e$Qi!f$Qi!g$Qi!h$Qi&v$Qi'T$Qi'_$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi~O'R$Qi'S$Qi'c$Qi'd$Qi~P9'eO'hAtO~P8I]O'hAuO~P8KWO'hAvO~P8L{O'hAwO~P8NpO&e,rO'RApO'SVO'TBYO'`AdO'cWO'dWO'eAlO'fA`O(V,sOV$Qig$Qi!e$Qi!f$Qi&v$Qi&|$Qi&}$Qi'_$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi'Z$Qi~O!gAxO!hA|O~P9)mO&e,rO'RAqO'SVO'TBZO'`AeO'cWO'dWO'eAmO'fAaO(V,sOV$Qig$Qi!e$Qi!f$Qi&v$Qi'_$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi'Z$Qi~O!gAyO!hA}O~P9+hO&e,rO'RArO'SVO'TB[O'`AfO'cWO'dWO'eAnO'fAbO(V,sO!e$Qi!f$Qi&v$Qi&|$Qi&}$Qi'_$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi(R$Qi~O!gAzO!hBOO~P9-]O&e,rO'RAsO'SVO'TB]O'`AgO'cWO'dWO'eAoO'fAcO(V,sO!e$Qi!f$Qi&v$Qi'_$Qi'g$Qi'h$Qi'}$Qi(O$Qi(P$Qi(Q$Qi~O!gA{O!hBPO~P9/QO!g$Qi!h$Qi~P9)mO!g$Qi!h$Qi~P9+hO!g$Qi!h$Qi~P9-]O!g$Qi!h$Qi~P9/QO!evO!fvO!gAxO!hA|O&e,rO'RApO'SVO'TBYO'`AdO'cWO'dWO'eAlO'fA`O'gAxO(PBUO(V,sOV$Qig$Qi&v$Qi&|$Qi&}$Qi'_$Qi'h$Qi'}$Qi(Q$Qi'Z$Qi~O(OBQO~P91fO!evO!fvO!gAyO!hA}O&e,rO'RAqO'SVO'TBZO'`AeO'cWO'dWO'eAmO'fAaO'gAyO(PBVO(V,sOV$Qig$Qi&v$Qi'_$Qi'h$Qi'}$Qi(Q$Qi'Z$Qi~O(OBRO~P93aO!evO!fvO!gAzO!hBOO&e,rO'RArO'SVO'TB[O'`AfO'cWO'dWO'eAnO'fAbO'gAzO(PBWO(V,sO&v$Qi&|$Qi&}$Qi'_$Qi'h$Qi'}$Qi(Q$Qi(R$Qi~O(OBSO~P95UO!evO!fvO!gA{O!hBPO&e,rO'RAsO'SVO'TB]O'`AgO'cWO'dWO'eAoO'fAcO'gA{O(PBXO(V,sO&v$Qi'_$Qi'h$Qi'}$Qi(Q$Qi~O(OBTO~P96yO(O$Qi~P91fO(O$Qi~P93aO(O$Qi~P95UO(O$Qi~P96yO'RApO'SVO'cWO'dWO~P9#[O'RAqO'SVO'cWO'dWO~P9%VO'RArO'`AfO'eAnO'fAbO&v$Qi&|$Qi&}$Qi'_$Qi~P5#]O'RAsO'SVO'cWO'dWO~P9'eOV$Tig$Ti&v$Ti'_$Ti'h$Ti'Z$Ti~P8AYO!evO!fvO!gAzO!hBOO&e,rO'RArO'SVO'TB[O'`AfO'cWO'dWO'eAnO'fAbO'gAzO(OBSO(PBWO(QDpO(V,sO~O&|CaO&}CaO'}AjO'h$Ti(R$Ti&v$Ti'_$Ti~P9;XO!gAxO!hA|O'RApO'TBYO'`AdO'eAlO'fA`O'gAxO(OBQO(PBUO(QDnO'_$Ry~P56dO!gAyO!hA}O'RAqO'TBZO'`AeO'eAmO'fAaO'gAyO(OBRO(PBVO(QDoO~P50|O&v$Ry&|$Ry&}$Ry'_$Ry'h$Ry'}$Ry(R$Ry~P9;XO!evO!fvO!gA{O!hBPO&e,rO'RAsO'SVO'TB]O'`AgO'cWO'dWO'eAoO'fAcO'gA{O(OBTO(PBXO(QDqO(V,sO~O&v$Ry'_$Ry'h$Ry'}$Ry~P9?WO&a=gO&i=gO&c!dX&d!dX&h!dX~O&a=hO&i=hO~P60iO&a=iO&i=iOg!dX&|!dX&}!dXP!dXV!dX]!dX_!dXv!dXy!dX{!dX!O!dX!P!dX!S!dX!V!dX!Y!dX!o!dX#Z!dX#[!dX#y!dX$h!dX$k!dX$o!dX$s!dX$u!dX$w!dX$y!dX${!dX$}!dX%P!dX%Q!dX%Y!dX&y!dX'U!dX'a!dX'p!dX'u!dX'w!dX'x!dX~P2)eO&a=jO&i=jOg!dX&|!dX&}!dXP!dXV!dX]!dX_!dXv!dXy!dX{!dX!O!dX!P!dX!S!dX!V!dX!Y!dX!o!dX#Z!dX#[!dX#y!dX$h!dX$k!dX$o!dX$s!dX$u!dX$w!dX$y!dX${!dX$}!dX%P!dX%Q!dX%Y!dX&y!dX'U!dX'a!dX'p!dX'u!dX'w!dX'x!dX~P2)eO(S=lO!e'QX!f'QX!g'QX!h'QX&e'QX'R'QX'S'QX'T'QX'`'QX'c'QX'd'QX'e'QX'f'QX'g'QX'h'QX'}'QX(O'QX(P'QX(Q'QX(R'QX(V'QX&v'QX&|'QX&}'QX'_'QX~P$:}O(S=lO~O(R>qO~P&5}O&vji'_ji~P)@uOV>uOg,wO&v'zX'_'zX'Z'zX~OV>uOg,wO&v'za'_'za'Z'za~O'hAwO'}AkO&v#Xi'_#Xi~P9?WO!evO!fvO&e,rO'SVO'cWO'dWO(V,sO~O!gAyO!hA}O'RAqO'TBZO'`AeO'eAmO'fAaO'gAyO'hAuO'}AiO(OBRO(PBVO(QDoOV#rag#ra&v#ra'_#ra'Z#ra~P9JRO(S?UOP'QXV'QX_'QXg'QXv'QXy'QX{'QX!O'QX!P'QX!S'QX!V'QX!Y'QX!e'QX!f'QX!g'QX!h'QX!o'QX#Z'QX#['QX#y'QX$h'QX$k'QX$o'QX$s'QX$u'QX$w'QX$y'QX${'QX$}'QX%P'QX%Q'QX%Y'QX&e'QX&v'QX&y'QX&|'QX&}'QX'R'QX'S'QX'T'QX'U'QX'Z'QX'`'QX'a'QX'c'QX'd'QX'e'QX'f'QX'g'QX'h'QX'p'QX'u'QX'w'QX'x'QX'}'QX(O'QX(P'QX(Q'QX(V'QX~P$:}O(S?VOV'QXg'QX!e'QX!f'QX!g'QX!h'QX&e'QX&v'QX'R'QX'S'QX'T'QX'_'QX'`'QX'c'QX'd'QX'e'QX'f'QX'g'QX'h'QX'}'QX(O'QX(P'QX(Q'QX(V'QX'Z'QX&|'QX&}'QX~P$:}O(S?UO~O(S?VO~O(RAYO~P&5}O(RAZO~P&5}O(RA[O~P&5}O(RA]O~P&5}O(SA^O'_'qX~P6CcO(SA_O!e'qX!f'qX!g'qX!h'qX&a'qX&c'qX&d'qX&e'qX&f#dX&g#dX&h'qX&i'qX'O'qX'R'qX'S'qX'T'qX'`'qX'c'qX'd'qX'e'qX'f'qX'g'qX'h'qX'}'qX(O'qX(P'qX(Q'qX(R'qX(V'qX&v'qX&|'qX&}'qX'_'qX~O(SA^O~O(SA_O~O(RCbO~P+*lO(RCcO~P+*lO(RCdO~P+*lO(RCeO~P+*lOy!g!h'P'g&}&|'a'c'S(Q(R&s&|~", + goto: ")/_([PPPPP(]4bP@g@kP@oPP(]P@uP@x@{ARP(]PA]AiI`IsKSLhMxNU!-q!5[!5m!-q!Br!CfPP# kP!CfP# n!CfPP# q!CfP# w!CfP# z!CfP# }#!Q#!Q#!Y#!]#!Q#!f#!Q#!x##OPPPP#0R#7w#8f#8j#8n!CfP#9O#9R#9U#@u#AXP#Ak#9RP#An#Aq#Fu$%c$%f$%i$*m$*m$/q$/t$p>q>t>u?O?P?Q?R?S?T?U?V?W?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}@O@P@Q@R@S@T@U@VASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuAvAwAxAyAzA{A|A}BOBPBQBRBSBTBUBVBWBXBYBZB[B]C`CaCbCcCdCeCqCsCtCuCvCwCxCyC}DODPDQDRDSDTDiDjDkDlDmDnDoDpDq9V!POR[elmnuwxy|!P!Q![!^!_!`!t#]#b#d#g#h#j#k#l#m#n#o#p#q#r#s#t#u#x#}$n$o$r$t%P%Q%S%U%[%d%k%o%p%v%{%}&k&q&y'e'n'q'r'u'v'w(W(k(n(q(v(y)R)W)Y)])^)_)m)q)u)w)|*O*U*Z*]*`*s*|+T+Z+a+q+},T,W,_,d,g,h,i,j,k,l,m,n,o,p,q,u,x,z-S-U-W-`-b-u.V.X.].^.b.e.g.i.w.}/S/U/^/b/p/w0U0V0s0x0z1O1R1W1a1c1f1j1o1w1x1z2O2S2U2W2[2^2a2h2m2q2t3P3Q3R3S3T3U3V3W3X3Y3Z3[3]3_3`3a3b3c3d3e3f3g3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R5S5T5U5V5W5X5Y5Z5[5]5^5_5`8O8]8^8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R:S:T:U:V:W:X:Y:Z:[:]:^:_:`:a:b:c:d:e<_<`p>q>t>u?O?P?Q?R?S?T?U?V?W?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}@O@P@Q@R@S@T@U@VASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuAvAwAxAyAzA{A|A}BOBPBQBRBSBTBUBVBWBXBYBZB[B]C`CaCbCcCdCeCqCsCtCuCvCwCxCyC}DODPDQDRDSDTDiDjDkDlDmDnDoDpDqT'o$h'pT'n$h'pQ't$hR*n'pR'{$iR*s'uQ'z$iR*x'{Q'y$iS*w'z'{R-r*xQ%S!ZQ)n%yQ+c(mR/y-P0OfOR[elmnuwxy|!P!Q!T!Y![!]!^!_!`!e!f!n!o!t!{#]#b#d#g#h#j#k#l#m#n#o#p#q#r#s#t#u#x#}$j$k$n$o$p$r$t%P%Q%S%U%[%d%k%p%v%{%}&k&q&y'e'n'q'r'u'v'w(W(Z(d(k(n(q(s(v(y)R)m)q)u)w)|*O*U*Z*]*`*s*|+Z+a+q+x,z-S-U-W-`-b-u.V.X/w1o3P3Q3R3S3T3U3V3W3X3Y3Z3[3]3_3`3a3b3c3d3e3f3g3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R5S5T5U5V5W5X5Y5Z5[5]5^5_5`7{7|7}8O8d8e8f8g8h8i8j8k8l8m8np>q?O?P?Q?R?S?T?U?V?W?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}@O@P@Q@R@S@T@U@VAWAXAYAZA[A]CqCsCtCuCvCwCxCyDiDjDkDlDmS%R!Z(mS&z#f,YT=|%y-Ps!y[!t$n%Q%k%{%}&y)q)u)w*|-S-U-W-up>q?O?P?Q?R?S?T?U?V?W?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}@O@P@Q@R@S@T@U@VAWAXAYAZA[A]CqCsCtCuCvCwCxCyDiDjDkDlDmW$Yx=R=S=TW$^y=]=^=_[$x!X$w+V+W.Q0[S%X!](sS&z#f,YS(|%j*{+S)Z%o)W)Y)])^)_+T+},T,W,_,d,g,h,i,j,k,l,m,n,o,p,q,u,x.].^.b.e.g.i.w.}/S/U/^/b/p0U0V0s0x0z1O1R1W1a1c1f1j1w1x1z2O2S2U2W2[2^2a2h2m2q2t8]8^8_8`8a8b8c8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R:S:T:U:V:W:X:Y:Z:[:]:^:_:`:a:b:c:d:e<_<`t>uASATAUAVA^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuAvAwAxAyAzA{A|A}BOBPBQBRBSBTBUBVBWBXBYBZB[B]C`CaCbCcCdCeC}DODPDQDRDSDTDnDoDpDqS-w+S8oQ0O-gQ0c.[U5j=U=X=YS5k=V=ZS5l=W=[U5p=`=c=dS5q=a=eT5r=b=f0PfOR[elmnuwxy|!P!Q!T!Y![!]!^!_!`!e!f!n!o!t!{#]#b#d#g#h#j#k#l#m#n#o#p#q#r#s#t#u#x#}$j$k$n$o$p$r$t%P%Q%S%U%[%d%k%p%v%{%}&k&q&y'e'n'q'r'u'v'w(W(Z(d(k(n(q(s(v(y)R)m)q)u)w)|*O*U*Z*]*`*s*|+Z+a+q+x,z-S-U-W-`-b-u.V.X/w1o3P3Q3R3S3T3U3V3W3X3Y3Z3[3]3_3`3a3b3c3d3e3f3g3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R5S5T5U5V5W5X5Y5Z5[5]5^5_5`7{7|7}8O8d8e8f8g8h8i8j8k8l8m8np>q?O?P?Q?R?S?T?U?V?W?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}@O@P@Q@R@S@T@U@VAWAXAYAZA[A]CqCsCtCuCvCwCxCyDiDjDkDlDmS(|%j*{Q)}&dS-w+S8oQ0O-gR0c.[0OfOR[elmnuwxy|!P!Q!T!Y![!]!^!_!`!e!f!n!o!t!{#]#b#d#g#h#j#k#l#m#n#o#p#q#r#s#t#u#x#}$j$k$n$o$p$r$t%P%Q%S%U%[%d%k%p%v%{%}&k&q&y'e'n'q'r'u'v'w(W(Z(d(k(n(q(s(v(y)R)m)q)u)w)|*O*U*Z*]*`*s*|+Z+a+q+x,z-S-U-W-`-b-u.V.X/w1o3P3Q3R3S3T3U3V3W3X3Y3Z3[3]3_3`3a3b3c3d3e3f3g3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R5S5T5U5V5W5X5Y5Z5[5]5^5_5`7{7|7}8O8d8e8f8g8h8i8j8k8l8m8np>q?O?P?Q?R?S?T?U?V?W?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}@O@P@Q@R@S@T@U@VAWAXAYAZA[A]CqCsCtCuCvCwCxCyDiDjDkDlDm[$x!X$w+V+W.Q0[S(|%j*{+S)Z%o)W)Y)])^)_+T+},T,W,_,d,g,h,i,j,k,l,m,n,o,p,q,u,x.].^.b.e.g.i.w.}/S/U/^/b/p0U0V0s0x0z1O1R1W1a1c1f1j1w1x1z2O2S2U2W2[2^2a2h2m2q2t8]8^8_8`8a8b8c8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R:S:T:U:V:W:X:Y:Z:[:]:^:_:`:a:b:c:d:e<_<`t>uASATAUAVA^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuAvAwAxAyAzA{A|A}BOBPBQBRBSBTBUBVBWBXBYBZB[B]C`CaCbCcCdCeC}DODPDQDRDSDTDnDoDpDqS-w+S8oQ0O-gR0c.[Q)f%oQ+{)WQ-{+TS.l+}.^Q0h.]Q0r.gQ2R0sQ2V0zQ2o2WQ2p2aR2u2q9V]OR[elmnuwxy|!P!Q![!^!_!`!t#]#b#d#g#h#j#k#l#m#n#o#p#q#r#s#t#u#x#}$n$o$r$t%P%Q%S%U%[%d%k%o%p%v%{%}&k&q&y'e'n'q'r'u'v'w(W(k(n(q(v(y)R)W)Y)])^)_)m)q)u)w)|*O*U*Z*]*`*s*|+T+Z+a+q+},T,W,_,d,g,h,i,j,k,l,m,n,o,p,q,u,x,z-S-U-W-`-b-u.V.X.].^.b.e.g.i.w.}/S/U/^/b/p/w0U0V0s0x0z1O1R1W1a1c1f1j1o1w1x1z2O2S2U2W2[2^2a2h2m2q2t3P3Q3R3S3T3U3V3W3X3Y3Z3[3]3_3`3a3b3c3d3e3f3g3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R5S5T5U5V5W5X5Y5Z5[5]5^5_5`8O8]8^8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R:S:T:U:V:W:X:Y:Z:[:]:^:_:`:a:b:c:d:e<_<`p>q>t>u?O?P?Q?R?S?T?U?V?W?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}@O@P@Q@R@S@T@U@VASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuAvAwAxAyAzA{A|A}BOBPBQBRBSBTBUBVBWBXBYBZB[B]C`CaCbCcCdCeCqCsCtCuCvCwCxCyC}DODPDQDRDSDTDiDjDkDlDmDnDoDpDqR'}$jR(P$kQ$o!TR(W$pR$r!VR$t!WR$y!X]$x!X$w+V+W.Q0[R-|+T_/[,d/^0V1c1w1x2hQ%q!mQ&v#eQ'd$PQ+U(^Q+`(fR+i(rX(`$w+W.Q0[0OfOR[elmnuwxy|!P!Q!T!Y![!]!^!_!`!e!f!n!o!t!{#]#b#d#g#h#j#k#l#m#n#o#p#q#r#s#t#u#x#}$j$k$n$o$p$r$t%P%Q%S%U%[%d%k%p%v%{%}&k&q&y'e'n'q'r'u'v'w(W(Z(d(k(n(q(s(v(y)R)m)q)u)w)|*O*U*Z*]*`*s*|+Z+a+q+x,z-S-U-W-`-b-u.V.X/w1o3P3Q3R3S3T3U3V3W3X3Y3Z3[3]3_3`3a3b3c3d3e3f3g3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R5S5T5U5V5W5X5Y5Z5[5]5^5_5`7{7|7}8O8d8e8f8g8h8i8j8k8l8m8np>q?O?P?Q?R?S?T?U?V?W?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}@O@P@Q@R@S@T@U@VAWAXAYAZA[A]CqCsCtCuCvCwCxCyDiDjDkDlDmQ!}^[$x!X$w+V+W.Q0[+S)Z%o)W)Y)])^)_+T+},T,W,_,d,g,h,i,j,k,l,m,n,o,p,q,u,x.].^.b.e.g.i.w.}/S/U/^/b/p0U0V0s0x0z1O1R1W1a1c1f1j1w1x1z2O2S2U2W2[2^2a2h2m2q2t8]8^8_8`8a8b8c8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R:S:T:U:V:W:X:Y:Z:[:]:^:_:`:a:b:c:d:e<_<`t>uASATAUAVA^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuAvAwAxAyAzA{A|A}BOBPBQBRBSBTBUBVBWBXBYBZB[B]C`CaCbCcCdCeC}DODPDQDRDSDTDnDoDpDqQ-m*gQ1r0PR1t0R%poORnwxy|!P!Q!^!_!`#]#d#g#h#j#k#l#m#n#o#p#q#r#s#t#x$o$r$t%P%Q%S%U%[%d%p%v&k&y'e'n'r'u'v'w(W(n(q(v(y*O*U*]*`*s+Z+a+q,z-S-`.V/w1o3T3Z3[3g3u3|4T4[4c4j4q4x5P5W5_8m=O=P=Q=R=S=T=U=V=W=X=Y=Z=[=]=^=_=`=a=b=c=d=e=f=m=o?WQ${!YS%l!j%nQ'b$OQ+Z(bQ+[(cQ-e*^![p>q?S?T?]?a?e?i?m?q?u?y?}@R@VA]CqCsCtCuCvCwCxCyDiDjDkDlDmvDZ#b&q*Z-b?P?U?Y?^?b?f?j?n?r?v?z@O@SAWAY!]D[)m?Q?R?V?Z?[?_?`?c?d?g?h?k?l?o?p?s?t?w?x?{?|@P@Q@T@UAXAZA[S!r[p>q?O?P?Q?R?S?T?U?V?W?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}@O@P@Q@R@S@T@U@VAWAXAYAZA[A]CqCsCtCuCvCwCxCyDiDjDkDlDm!^gOR!P!Q!^!_!`#g$o$r$t%P%S%U%[%d'e'n'r'u'v'w(W(n(v(y*s+Z+a+qQ%O!YT%Y!](sq!kU$l$z%V%f%g%r%t'|(O5x5y5z5{5|5}Q)Q%mQ*b'cQ+r)SQ0l.`Q1`/XR1}0mR+q)RR+a(f+T)c%o)W)Y)])^)_+T+},T,W,_,d,g,h,i,j,k,l,m,n,o,p,q,u,x.].^.b.e.g.i.w.}/S/U/^/b/p0U0V0s0x0z1O1R1W1a1c1f1j1w1x1z2O2S2U2W2[2^2a2h2m2q2t8]8^8_8`8a8b8c8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R:S:T:U:V:W:X:Y:Z:[:]:^:_:`:a:b:c:d:e<_<`t>uASATAUAVA^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuAvAwAxAyAzA{A|A}BOBPBQBRBSBTBUBVBWBXBYBZB[B]C`CaCbCcCdCeC}DODPDQDRDSDTDnDoDpDq/QlOR[elmnuwxy|!P!Q![!^!_!`!t#]#b#d#g#h#j#k#l#m#n#o#p#q#r#s#t#u#x#}$n$o$r$t%P%Q%S%U%[%d%k%p%v%{%}&k&q&y'e'n'q'r'u'v'w(W(k(n(q(v(y)R)m)q)u)w)|*O*U*Z*]*`*s*|+Z+a+q,z-S-U-W-`-b-u.V.X/w1o3P3Q3R3S3T3U3V3W3X3Y3Z3[3]3_3`3a3b3c3d3e3f3g3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R5S5T5U5V5W5X5Y5Z5[5]5^5_5`8O8d8e8f8g8h8i8j8k8l8m8np>q?O?P?Q?R?S?T?U?V?W?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}@O@P@Q@R@S@T@U@VAWAXAYAZA[A]CqCsCtCuCvCwCxCyDiDjDkDlDmQ$g!OQ(}%j+S)]%o)W)Y)])^)_+T+},T,W,_,d,g,h,i,j,k,l,m,n,o,p,q,u,x.].^.b.e.g.i.w.}/S/U/^/b/p0U0V0s0x0z1O1R1W1a1c1f1j1w1x1z2O2S2U2W2[2^2a2h2m2q2t8]8^8_8`8a8b8c8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R:S:T:U:V:W:X:Y:Z:[:]:^:_:`:a:b:c:d:e<_<`t>uASATAUAVA^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuAvAwAxAyAzA{A|A}BOBPBQBRBSBTBUBVBWBXBYBZB[B]C`CaCbCcCdCeC}DODPDQDRDSDTDnDoDpDqQ*i'lQ-m*gQ0d.[Q1r0PR1t0RR#O^R!}^+T)^%o)W)Y)])^)_+T+},T,W,_,d,g,h,i,j,k,l,m,n,o,p,q,u,x.].^.b.e.g.i.w.}/S/U/^/b/p0U0V0s0x0z1O1R1W1a1c1f1j1w1x1z2O2S2U2W2[2^2a2h2m2q2t8]8^8_8`8a8b8c8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R:S:T:U:V:W:X:Y:Z:[:]:^:_:`:a:b:c:d:e<_<`t>uASATAUAVA^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuAvAwAxAyAzA{A|A}BOBPBQBRBSBTBUBVBWBXBYBZB[B]C`CaCbCcCdCeC}DODPDQDRDSDTDnDoDpDq+T)Z%o)W)Y)])^)_+T+},T,W,_,d,g,h,i,j,k,l,m,n,o,p,q,u,x.].^.b.e.g.i.w.}/S/U/^/b/p0U0V0s0x0z1O1R1W1a1c1f1j1w1x1z2O2S2U2W2[2^2a2h2m2q2t8]8^8_8`8a8b8c8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R:S:T:U:V:W:X:Y:Z:[:]:^:_:`:a:b:c:d:e<_<`t>uASATAUAVA^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuAvAwAxAyAzA{A|A}BOBPBQBRBSBTBUBVBWBXBYBZB[B]C`CaCbCcCdCeC}DODPDQDRDSDTDnDoDpDqR0i.]0OfOR[elmnuwxy|!P!Q!T!Y![!]!^!_!`!e!f!n!o!t!{#]#b#d#g#h#j#k#l#m#n#o#p#q#r#s#t#u#x#}$j$k$n$o$p$r$t%P%Q%S%U%[%d%k%p%v%{%}&k&q&y'e'n'q'r'u'v'w(W(Z(d(k(n(q(s(v(y)R)m)q)u)w)|*O*U*Z*]*`*s*|+Z+a+q+x,z-S-U-W-`-b-u.V.X/w1o3P3Q3R3S3T3U3V3W3X3Y3Z3[3]3_3`3a3b3c3d3e3f3g3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R5S5T5U5V5W5X5Y5Z5[5]5^5_5`7{7|7}8O8d8e8f8g8h8i8j8k8l8m8np>q?O?P?Q?R?S?T?U?V?W?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}@O@P@Q@R@S@T@U@VAWAXAYAZA[A]CqCsCtCuCvCwCxCyDiDjDkDlDm+T)Z%o)W)Y)])^)_+T+},T,W,_,d,g,h,i,j,k,l,m,n,o,p,q,u,x.].^.b.e.g.i.w.}/S/U/^/b/p0U0V0s0x0z1O1R1W1a1c1f1j1w1x1z2O2S2U2W2[2^2a2h2m2q2t8]8^8_8`8a8b8c8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R:S:T:U:V:W:X:Y:Z:[:]:^:_:`:a:b:c:d:e<_<`t>uASATAUAVA^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuAvAwAxAyAzA{A|A}BOBPBQBRBSBTBUBVBWBXBYBZB[B]C`CaCbCcCdCeC}DODPDQDRDSDTDnDoDpDqT%i!f=jR+v)V!W)a%o)W)_+T+},T,g,h,i,j,k,l,m,n,o,p,x.].^.g0s0z1O1f2W2a2qS._+u.aQ/W,`z>l)Y)])^,_/S/U8]8q8u8|9T9[9c9j9q9x:P:W:_<_m/b1j8^8_8r8v8w8}9O9U9V9]9^9d9e9k9l9r9s9y9z:Q:R:X:Y:`:a<`n,d,u.b.e.w/^/p0U0V1R1a1c1w1x1z2O2S2[2h2m2t8`8a8s8x8y9P9Q9W9X9_9`9f9g9m9n9t9u9{9|:S:T:Z:[:b:co,W.}1W2^8b8t8z9R9Y9a9h9o9v9}:U:]:duASATA^A`AaAdAeAhAiAlAmApAqAtAuAxAyA|A}BQBRBUBVBYBZC`CbCc#gDd,q.i0x2U8c8{9S9Z9b9i9p9w:O:V:^:etAUAVA_AbAcAfAgAjAkAnAoArAsAvAwAzA{BOBPBSBTBWBXB[B]CaCdCeC}DODPDQDRDSDTDnDoDpDqm+z)W+}.^.g.i/p0s0x0z2S2U2W2a2qe,O)W,P,R,S.^.q.s/p0j1g]#T_`a#R#V#YR)|&_R/}-X0OfOR[elmnuwxy|!P!Q!T!Y![!]!^!_!`!e!f!n!o!t!{#]#b#d#g#h#j#k#l#m#n#o#p#q#r#s#t#u#x#}$j$k$n$o$p$r$t%P%Q%S%U%[%d%k%p%v%{%}&k&q&y'e'n'q'r'u'v'w(W(Z(d(k(n(q(s(v(y)R)m)q)u)w)|*O*U*Z*]*`*s*|+Z+a+q+x,z-S-U-W-`-b-u.V.X/w1o3P3Q3R3S3T3U3V3W3X3Y3Z3[3]3_3`3a3b3c3d3e3f3g3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R5S5T5U5V5W5X5Y5Z5[5]5^5_5`7{7|7}8O8d8e8f8g8h8i8j8k8l8m8np>q?O?P?Q?R?S?T?U?V?W?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}@O@P@Q@R@S@T@U@VAWAXAYAZA[A]CqCsCtCuCvCwCxCyDiDjDkDlDmS&z#f,Y+T)Z%o)W)Y)])^)_+T+},T,W,_,d,g,h,i,j,k,l,m,n,o,p,q,u,x.].^.b.e.g.i.w.}/S/U/^/b/p0U0V0s0x0z1O1R1W1a1c1f1j1w1x1z2O2S2U2W2[2^2a2h2m2q2t8]8^8_8`8a8b8c8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R:S:T:U:V:W:X:Y:Z:[:]:^:_:`:a:b:c:d:e<_<`t>uASATAUAVA^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuAvAwAxAyAzA{A|A}BOBPBQBRBSBTBUBVBWBXBYBZB[B]C`CaCbCcCdCeC}DODPDQDRDSDTDnDoDpDq:XdOR[elmnuwxy|!P!Q!T!Y![!]!^!_!`!e!f!n!o!t!{#]#b#d#f#g#h#j#k#l#m#n#o#p#q#r#s#t#u#x#}$j$k$n$o$p$r$t%P%Q%S%U%[%d%k%o%p%v%{%}&k&q&y'e'n'q'r'u'v'w(W(Z(d(k(n(q(s(v(y)R)W)Y)])^)_)m)q)u)w)|*O*U*Z*]*`*s*|+T+Z+a+q+x+},T,W,Y,_,d,g,h,i,j,k,l,m,n,o,p,q,u,x,z-S-U-W-`-b-u.V.X.].^.b.e.g.i.w.}/S/U/^/b/p/w0U0V0s0x0z1O1R1W1a1c1f1j1o1w1x1z2O2S2U2W2[2^2a2h2m2q2t3P3Q3R3S3T3U3V3W3X3Y3Z3[3]3_3`3a3b3c3d3e3f3g3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R5S5T5U5V5W5X5Y5Z5[5]5^5_5`7{7|7}8O8]8^8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R:S:T:U:V:W:X:Y:Z:[:]:^:_:`:a:b:c:d:e<_<`p>q>t>u?O?P?Q?R?S?T?U?V?W?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}@O@P@Q@R@S@T@U@VASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuAvAwAxAyAzA{A|A}BOBPBQBRBSBTBUBVBWBXBYBZB[B]C`CaCbCcCdCeCqCsCtCuCvCwCxCyC}DODPDQDRDSDTDiDjDkDlDmDnDoDpDq9ebO[enuwxy!P!Q!T!Y![!]!^!_!e!f!n!o!t!{#]#b#d#f#g#h#j#k#l#m#n#o#p#q#r#s#t#u#x$j$k$n$o$p$r$t%P%Q%S%U%[%d%k%o%p%v%{%}&k&q&y'e'n'q'r'u'v'w(W(Z(d(k(n(q(s(v(y)R)W)Y)_)m)q)u)w)|*O*U*Z*]*`*s*|+T+Z+a+q+x+},T,W,Y,d,g,h,i,j,k,l,m,n,o,p,q,u,x,z-S-U-W-`-b-u.V.X.].^.b.e.g.i.w.}/S/U/^/b/p/w0U0V0s0x0z1O1R1W1a1c1f1j1o1w1x1z2O2S2U2W2[2^2a2h2m2q2t3P3Q3R3S3T3_3`3a3b3c3d3e3f3g3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R5S5T5U5V5W5X5Y5Z5[5]5^5_5`7{7|7}8O8]8^8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R:S:T:U:V:W:X:Y:Z:[:]:^:_:`:a:b:c:d:e<_<`p>q>t>u?O?P?Q?R?S?T?U?V?W?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}@O@P@Q@R@S@T@U@VASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuAvAwAxAyAzA{A|A}BOBPBQBRBSBTBUBVBWBXBYBZB[B]C`CaCbCcCdCeCqCsCtCuCvCwCxCyC}DODPDQDRDSDTDiDjDkDlDmDnDoDpDqR&i#^R&i#_+S)Z%o)W)Y)])^)_+T+},T,W,_,d,g,h,i,j,k,l,m,n,o,p,q,u,x.].^.b.e.g.i.w.}/S/U/^/b/p0U0V0s0x0z1O1R1W1a1c1f1j1w1x1z2O2S2U2W2[2^2a2h2m2q2t8]8^8_8`8a8b8c8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R:S:T:U:V:W:X:Y:Z:[:]:^:_:`:a:b:c:d:e<_<`t>uASATAUAVA^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuAvAwAxAyAzA{A|A}BOBPBQBRBSBTBUBVBWBXBYBZB[B]C`CaCbCcCdCeC}DODPDQDRDSDTDnDoDpDqT/q,w1lU,f)`-x0eW/`,f/aC|DUTC|+y,VQ/r,wR2d1lR1j/qS(l%R=|R1k/qX/`,f/aC|DUQ,X)YV1U.}1W2^Q.c+wR/Y,aR0d/RT,b)])^U,^)])^,_R1^/UU,])])^,_R1_/U!W)_%o)W)_+T+},T,g,h,i,j,k,l,m,n,o,p,x.].^.g0s0z1O1f2W2a2qz8])Y)])^,_/S/U8]8q8u8|9T9[9c9j9q9x:P:W:_<_uATAaAeAiAmAqAuAyA}BRBVBZCctAU.i0x2UAUA_AbAfAjAnArAvAzBOBSBWB[CaCdmAV>tAVAcAgAkAoAsAwA{BPBTBXB]Ce^.v,T8q8r8s8tA^A__2Y1O<_<`t>uASATAUAVA^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuAvAwAxAyAzA{A|A}BOBPBQBRBSBTBUBVBWBXBYBZB[B]C`CaCbCcCdCeC}DODPDQDRDSDTDnDoDpDqQ&{#fR/Q,YT&z#f,Y0OfOR[elmnuwxy|!P!Q!T!Y![!]!^!_!`!e!f!n!o!t!{#]#b#d#g#h#j#k#l#m#n#o#p#q#r#s#t#u#x#}$j$k$n$o$p$r$t%P%Q%S%U%[%d%k%p%v%{%}&k&q&y'e'n'q'r'u'v'w(W(Z(d(k(n(q(s(v(y)R)m)q)u)w)|*O*U*Z*]*`*s*|+Z+a+q+x,z-S-U-W-`-b-u.V.X/w1o3P3Q3R3S3T3U3V3W3X3Y3Z3[3]3_3`3a3b3c3d3e3f3g3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R5S5T5U5V5W5X5Y5Z5[5]5^5_5`7{7|7}8O8d8e8f8g8h8i8j8k8l8m8np>q?O?P?Q?R?S?T?U?V?W?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}@O@P@Q@R@S@T@U@VAWAXAYAZA[A]CqCsCtCuCvCwCxCyDiDjDkDlDmT&z#f,YR)g%oQ#ceV*X&q*Z-bQ(k%RR8O=|R%U![R%]!]Q%Z!]R+j(s!QsO!P!Q!^!_$o$r$t%P%S%U%['n'r'u'v'w(W(n(v*s+Z+a+qQ!cRU#|lm#}W$Ww=O=P=Qf$Zx=R=S=T=U=V=W=X=Y=Z=[f$_y=]=^=_=`=a=b=c=d=e=fY%c!`#g%d'e(yZ'P#j3m3n3o=o!QjO!P!Q!^!_$o$r$t%P%S%U%['n'r'u'v'w(W(n(v*s+Z+a+qQ!bRU#zlm#}b$Vwxy=X=Z=[=c=e=fb$b|3U3V3W3X3Y3Z3[3]Y%b!`#g%d'e(yQ&u#dQ'Q#jQ-d*]U5d=O=R=]Y5e=P=S=Y=^=db5f=Q=T=U=V=W=_=`=a=bQ6`3mQ6a3nQ6b3oR>S=oR$f}Q$d}S'f$c-iQ*d'hT-k*g0PQ$e}R*e'hQ-l*gR1q0P/RqOR[elmnuwxy|!P!Q![!^!_!`!t#]#b#d#g#h#j#k#l#m#n#o#p#q#r#s#t#u#x#}$n$o$r$t%P%Q%S%U%[%d%k%p%v%{%}&k&q&y'e'n'q'r'u'v'w(W(k(n(q(v(y)R)m)q)u)w)|*O*U*Z*]*`*s*|+Z+a+q,z-S-U-W-`-b-u.V.X/w1o3P3Q3R3S3T3U3V3W3X3Y3Z3[3]3_3`3a3b3c3d3e3f3g3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R5S5T5U5V5W5X5Y5Z5[5]5^5_5`8O8d8e8f8g8h8i8j8k8l8m8np>q?O?P?Q?R?S?T?U?V?W?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}@O@P@Q@R@S@T@U@VAWAXAYAZA[A]CqCsCtCuCvCwCxCyDiDjDkDlDm/RmOR[elmnuwxy|!P!Q![!^!_!`!t#]#b#d#g#h#j#k#l#m#n#o#p#q#r#s#t#u#x#}$n$o$r$t%P%Q%S%U%[%d%k%p%v%{%}&k&q&y'e'n'q'r'u'v'w(W(k(n(q(v(y)R)m)q)u)w)|*O*U*Z*]*`*s*|+Z+a+q,z-S-U-W-`-b-u.V.X/w1o3P3Q3R3S3T3U3V3W3X3Y3Z3[3]3_3`3a3b3c3d3e3f3g3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R5S5T5U5V5W5X5Y5Z5[5]5^5_5`8O8d8e8f8g8h8i8j8k8l8m8np>q?O?P?Q?R?S?T?U?V?W?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}@O@P@Q@R@S@T@U@VAWAXAYAZA[A]CqCsCtCuCvCwCxCyDiDjDkDlDmR(}'`T$Qlm$dnORnwxy|!P!Q!^!_!`#]#g#h#j#k#l#m#n#o#p#q#r#s#t#x$o$r$t%P%Q%S%U%[%d&y'e'n'r'u'v'w(W(n(v(y*O*`*s+Z+a+q-S=O=P=Q=R=S=T=U=V=W=X=Y=Z=[=]=^=_=`=a=b=c=d=e=f=m=o![3P[!t$n%k%{)q)w*|-W-u3P3U3_3f3o3p3w4O4V4^4e4l4s4z5R5Y8d8hp>qCq`&f#]3_3`3a3b=l?U?Va-Z*O8d8e8f8g>pAWAX/RpOR[elmnuwxy|!P!Q![!^!_!`!t#]#b#d#g#h#j#k#l#m#n#o#p#q#r#s#t#u#x#}$n$o$r$t%P%Q%S%U%[%d%k%p%v%{%}&k&q&y'e'n'q'r'u'v'w(W(k(n(q(v(y)R)m)q)u)w)|*O*U*Z*]*`*s*|+Z+a+q,z-S-U-W-`-b-u.V.X/w1o3P3Q3R3S3T3U3V3W3X3Y3Z3[3]3_3`3a3b3c3d3e3f3g3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R5S5T5U5V5W5X5Y5Z5[5]5^5_5`8O8d8e8f8g8h8i8j8k8l8m8np>q?O?P?Q?R?S?T?U?V?W?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}@O@P@Q@R@S@T@U@VAWAXAYAZA[A]CqCsCtCuCvCwCxCyDiDjDkDlDm!QsO!P!Q!^!_$o$r$t%P%S%U%['n'r'u'v'w(W(n(v*s+Z+a+qQ!cRZ%c!`#g%d'e(y!QRO!P!Q!^!_$o$r$t%P%S%U%['n'r'u'v'w(W(n(v*s+Z+a+qQ!`RW#gijrsW%`#g%d'e(yW%d!a!b!c!dR(y%eQ'p$hR*l'pS,e)`)gU/_,e0W1yS0W-x-|T1y0e0iS,{)h)iR/x,{Q+X(aR.R+XQ-Q)nR/z-QQ)l%wR,})lQ%|!sU)r%|)x*}Q)x&RT*}(S(hQ!v[[&T!v&V&X(R)O=kQ&V!xQ&X!zU(R$n%Q&yQ)O%kR=kO=lQ>T=qQ>U=rQ>V=sQ>W=tQ>X=uQ>Y=vQ>Z=wQ>[=xQ>]=yQ>^CsQ>_CtQ>`CuQ>aCvQ>bCwQ>cCxQ>dCyQ>e=zU>g%})u-UQ>r>pQ>s>qQ@W?UQ@X?VQ@Y?^Q@Z?_Q@[?`Q@]?aQ@^?bQ@_?cQ@`?dQ@a?eQ@b?fQ@c?gQ@d?hQ@e?iQ@f?jQ@g?kQ@h?lQ@i?mQ@j?nQ@k?oQ@l?pQ@m?qQ@n?rQ@o?sQ@p?tQ@q?uQ@r?vQ@s?wQ@t?xQ@u?yQ@v?zQ@w?{Q@x?|Q@y?}Q@z@OQ@{@PQ@|@QQ@}@RQAO@SQAP@TQAQ@UQAR@VQB^AWQB_AXQB`AYQBaAZQBbA[QBcA]QCzDiQC{=}QD]DjQD^DkQD_DlRD`Dm/QqOR[elmnuwxy|!P!Q![!^!_!`!t#]#b#d#g#h#j#k#l#m#n#o#p#q#r#s#t#u#x#}$n$o$r$t%P%Q%S%U%[%d%k%p%v%{%}&k&q&y'e'n'q'r'u'v'w(W(k(n(q(v(y)R)m)q)u)w)|*O*U*Z*]*`*s*|+Z+a+q,z-S-U-W-`-b-u.V.X/w1o3P3Q3R3S3T3U3V3W3X3Y3Z3[3]3_3`3a3b3c3d3e3f3g3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R5S5T5U5V5W5X5Y5Z5[5]5^5_5`8O8d8e8f8g8h8i8j8k8l8m8np>q?O?P?Q?R?S?T?U?V?W?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}@O@P@Q@R@S@T@U@VAWAXAYAZA[A]CqCsCtCuCvCwCxCyDiDjDkDlDm+T)c%o)W)Y)])^)_+T+},T,W,_,d,g,h,i,j,k,l,m,n,o,p,q,u,x.].^.b.e.g.i.w.}/S/U/^/b/p0U0V0s0x0z1O1R1W1a1c1f1j1w1x1z2O2S2U2W2[2^2a2h2m2q2t8]8^8_8`8a8b8c8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R:S:T:U:V:W:X:Y:Z:[:]:^:_:`:a:b:c:d:e<_<`t>uASATAUAVA^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuAvAwAxAyAzA{A|A}BOBPBQBRBSBTBUBVBWBXBYBZB[B]C`CaCbCcCdCeC}DODPDQDRDSDTDnDoDpDqZ!z[$n%Q&yp>q?O?P?Q?R?S?T?U?V?W?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}@O@P@Q@R@S@T@U@VAWAXAYAZA[A]CqCsCtCuCvCwCxCyDiDjDkDlDmS$l!T$pQ$z!YS%V!](sQ%f!eS%g!f7|W%r!n!{(d+xQ%t!oQ'|$jQ(O$kQ5x=gQ5y=hQ5z=iQ5{(ZQ5|7{T5}7}=jQ)`%ob+y)W+}.^.g0s0z2W2a2qQ,V)YU,[)])^,_h,c)_8]8^8_8`8a8b8cASATAUAVQ-x+TQ.u,TW.{,W.}1W2^^/Z,d/^0V1c1w1x2hh/c,g8u8v8w8x8y8z8{A`AaAbAcQ/d,hQ/e,iQ/f,jQ/g,kQ/h,lQ/i,mQ/j,nQ/k,oQ/l,pQ/m,qQ/o,uQ/s,xQ0e.]Q0n.bQ0p.eU0u.i0x2UU1P.w1R2[Q1Z/SQ1]/UQ1e/bQ1u0UQ2X1OQ2_1aQ2`1fQ2c1jQ2i1zU2j2O2m2tQ:q8qQ:r8rQ:s8sQ:t8tQ:u8|Q:v8}Q:w9OQ:x9PQ:y9QQ:z9RQ:{9SQ:|9TQ:}9UQ;O9VQ;P9WQ;Q9XQ;R9YQ;S9ZQ;T9[Q;U9]Q;V9^Q;W9_Q;X9`Q;Y9aQ;Z9bQ;[9cQ;]9dQ;^9eQ;_9fQ;`9gQ;a9hQ;b9iQ;c9jQ;d9kQ;e9lQ;f9mQ;g9nQ;h9oQ;i9pQ;j9qQ;k9rQ;l9sQ;m9tQ;n9uQ;o9vQ;p9wQ;q9xQ;r9yQ;s9zQ;t9{Q;u9|Q;v9}Q;w:OQ;x:PQ;y:QQ;z:RQ;{:SQ;|:TQ;}:UQvC}Q>wDOQ>xDPQ>yDQQ>zDRQ>{DSQ>|DTS>}/p2SQBdA^QBeA_QBfAdQBgAeQBhAfQBiAgQBjAhQBkAiQBlAjQBmAkQBnAlQBoAmQBpAnQBqAoQBrApQBsAqQBtArQBuAsQBvAtQBwAuQBxAvQByAwQBzAxQB{AyQB|AzQB}A{QCOA|QCPA}QCQBOQCRBPQCSBQQCTBRQCUBSQCVBTQCWBUQCXBVQCYBWQCZBXQC[BYQC]BZQC^B[QC_B]QCfC`QCgCaQChCbQCiCcQCjCdQCkCeQDV>tQDW>uQDeDnQDfDoQDgDpRDhDqQ$v!XW(_$w+W.Q0[R-}+VQ(a$wV.O+W.Q0[:hYOR[^elmnuwxy|!P!Q!T!X!Y![!]!^!_!`!e!f!n!o!t!{#]#b#d#g#h#j#k#l#m#n#o#p#q#r#s#t#u#x#}$j$k$n$o$p$r$t$w%P%Q%S%U%[%d%k%o%p%v%{%}&k&q&y'e'n'q'r'u'v'w(W(Z(d(k(n(q(s(v(y)R)W)Y)])^)_)m)q)u)w)|*O*U*Z*]*`*g*s*|+T+V+W+Z+a+q+x+},T,W,_,d,g,h,i,j,k,l,m,n,o,p,q,u,x,z-S-U-W-`-b-u.Q.V.X.].^.b.e.g.i.w.}/S/U/^/b/p/w0P0R0U0V0[0s0x0z1O1R1W1a1c1f1j1o1w1x1z2O2S2U2W2[2^2a2h2m2q2t3P3Q3R3S3T3U3V3W3X3Y3Z3[3]3_3`3a3b3c3d3e3f3g3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R5S5T5U5V5W5X5Y5Z5[5]5^5_5`7{7|7}8O8]8^8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R:S:T:U:V:W:X:Y:Z:[:]:^:_:`:a:b:c:d:e<_<`p>q>t>u?O?P?Q?R?S?T?U?V?W?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}@O@P@Q@R@S@T@U@VASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuAvAwAxAyAzA{A|A}BOBPBQBRBSBTBUBVBWBXBYBZB[B]C`CaCbCcCdCeCqCsCtCuCvCwCxCyC}DODPDQDRDSDTDiDjDkDlDmDnDoDpDq!O#oi!a$U$a%a&e&|'O'T'W'X'Y'Z'['_(g-Y-h5a5b5c6W6^l,k)`+y-x.u/e/h/i/j/k/l/s0e2X2`l4^!q5s6P6Z6_6j7P7W7_7f7m7t:f:jr4_#a#y+b+n5t6Q6T6[6k7Q7X7`7g7n7u:g:kj4`5u6R6U6]6l7R7Y7a7h7o7v:h:lf4a5v6V6m7S7Z7b7i7p7w8p:mj4b$T%T*o6S6n7T7[7c7j7q7x:i:nv4c&t)h)j*S+h-c/t0_5w6X6Y6o7U7]7d7k7r7y:oz4d']6p7V7^7e7l7s7z:p>^>_>`>a>b>c>dCzD]D^D_D`l9c,V,[1Z1]:q:|;c;j;q;x}p9g/o0n0p1P1u2_2i2j;Q;g;n;u;|v>w>x>y>z>{>|DeDfDgDhf=t>O>U>X>Y>Z>[>]>e>g>r>sf?j&o@W@^@j@n@r@v@zAOB^B`d?k@X@_@k@o@s@w@{APB_Bab?l-O@`@l@p@t@x@|AQBbd?m-X@a@m@q@u@y@}ARBcC{dApBdBjBvBzCOCSCWC[CfChbAqBkBwB{CPCTCXC]CiDWfAr0uBeBlBxB|CQCUCYC^CgCjcAsBmByB}CRCVCZC_CkDV:hYOR[^elmnuwxy|!P!Q!T!X!Y![!]!^!_!`!e!f!n!o!t!{#]#b#d#g#h#j#k#l#m#n#o#p#q#r#s#t#u#x#}$j$k$n$o$p$r$t$w%P%Q%S%U%[%d%k%o%p%v%{%}&k&q&y'e'n'q'r'u'v'w(W(Z(d(k(n(q(s(v(y)R)W)Y)])^)_)m)q)u)w)|*O*U*Z*]*`*g*s*|+T+V+W+Z+a+q+x+},T,W,_,d,g,h,i,j,k,l,m,n,o,p,q,u,x,z-S-U-W-`-b-u.Q.V.X.].^.b.e.g.i.w.}/S/U/^/b/p/w0P0R0U0V0[0s0x0z1O1R1W1a1c1f1j1o1w1x1z2O2S2U2W2[2^2a2h2m2q2t3P3Q3R3S3T3U3V3W3X3Y3Z3[3]3_3`3a3b3c3d3e3f3g3m3n3o3p3q3r3s3t3u3v3w3x3y3z3{3|3}4O4P4Q4R4S4T4U4V4W4X4Y4Z4[4]4^4_4`4a4b4c4d4e4f4g4h4i4j4k4l4m4n4o4p4q4r4s4t4u4v4w4x4y4z4{4|4}5O5P5Q5R5S5T5U5V5W5X5Y5Z5[5]5^5_5`7{7|7}8O8]8^8_8`8a8b8c8d8e8f8g8h8i8j8k8l8m8n8q8r8s8t8u8v8w8x8y8z8{8|8}9O9P9Q9R9S9T9U9V9W9X9Y9Z9[9]9^9_9`9a9b9c9d9e9f9g9h9i9j9k9l9m9n9o9p9q9r9s9t9u9v9w9x9y9z9{9|9}:O:P:Q:R:S:T:U:V:W:X:Y:Z:[:]:^:_:`:a:b:c:d:e<_<`p>q>t>u?O?P?Q?R?S?T?U?V?W?Y?Z?[?]?^?_?`?a?b?c?d?e?f?g?h?i?j?k?l?m?n?o?p?q?r?s?t?u?v?w?x?y?z?{?|?}@O@P@Q@R@S@T@U@VASATAUAVAWAXAYAZA[A]A^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuAvAwAxAyAzA{A|A}BOBPBQBRBSBTBUBVBWBXBYBZB[B]C`CaCbCcCdCeCqCsCtCuCvCwCxCyC}DODPDQDRDSDTDiDjDkDlDmDnDoDpDqx#qi!a$U$a%a&e&|'O'T'W'Z'[(g-Y-h5a5b5c6W6^f,m)`+y-x.u/e/h/k/l0e2X2`f4l!q5s6P6Z6_6j7P7f7m:f:jl4m#a#y+b+n5t6Q6T6[6k7Q7g7n:g:kd4n5u6R6U6]6l7R7h7o:h:l`4o5v6V6m7S7i7p8p:md4p$T%T*o6S6n7T7j7q:i:np4q&t)h)j*S+h-c/t0_5w6X6Y6o7U7k7r:ot4r']6p7V7l7s:p>^>_>`>a>b>c>dCzD]D^D_D`f9q,V,[1Z1]:q:|;c;x}j9u/o0n0p1P1u2_2i2j;Q;g;|v>w>x>y>z>{>|DeDfDgDh`=v>O>U>X>[>]>g>r>s`?r&o@W@^@j@v@zB^B`^?s@X@_@k@w@{B_Ba[?t-O@`@l@x@|Bb^?u-X@a@m@y@}BcC{^AxBdBjBvCSCWCfCh[AyBkBwCTCXCiDW`Az0uBeBlBxCUCYCgCj]A{BmByCVCZCkDVU!x[%kt>uASATAUAVA^A_A`AaAbAcAdAeAfAgAhAiAjAkAlAmAnAoApAqArAsAtAuAvAwAxAyAzA{A|A}BOBPBQBRBSBTBUBVBWBXBYBZB[B]C`CaCbCcCdCeC}DODPDQDRDSDTDnDoDpDqQ.`+uR0m.aS,R)W.^R.n+}Q+|)WS.m+}.^^0q.g0s0z2S2W2a2qU0v.i0x2UR1h/pS#Q_#RS#U`#VT#Xa#YT,S)W/pW,t)`+y-x0eR.z,VR/X,`R-f*^g$[x=R=S=T=U=V=W=X=Y=Z=[g$`y=]=^=_=`=a=b=c=d=e=fR-n*gR'c$O", + nodeNames: "⚠ Identifier BlockComment Comment SourceFile IfStatement IfClause if ElseifClause IfClause elseif ElseClause else end TryStatement try CatchClause catch CatchBinding TryElseClause FinallyClause finally ForStatement for ForBinding TupleExpression AssignmentExpression LonelyType :: <: Type InterpolationExpression FieldExpression FieldName QuoteExpression SubscriptExpression ListCompherension PrimitiveDefinition primitive type Definition Number AbstractDefinition abstract Definition StructDefinition mutable struct Definition ModuleDefinition module Definition BareModuleDefinition baremodule Definition MacroDefinition macro Definition FieldExpression SubscriptExpression AssignmentExpression AssignmentExpression ParameterizedIdentifier TypeArgumentList ParenthesizedExpression AssignmentExpression Operator in isa pipe< pipe> ArgumentList ListCompherension ForClause IfClause Parameters FunctionDefinition function Definition TypedExpression CallExpression BroadcastDot DoClause do DoClauseArguments CallExpression where TypeParameters MacroExpression MacroIdentifier MacroName Operator MacroFieldExpression FieldExpression SubscriptExpression AssignmentExpression Symbol SymbolName CallExpression BroadcastDot ArgumentList AssignmentExpression Parameters BooleanLiteral Character String $ ( ) TripleString CommandString PrefixedString Prefix FieldEpxression String TripleString CommandString ParenthesizedExpression TupleExpression ArrayExpression ArrayComprehensionExpression ForClause ForBinding AssignOperator = ∈ IfClause MatrixExpression MatrixRow GeneratorExpression TypedExpression ParameterizedIdentifier TypeArgumentList begin MacroFieldName MacroArgumentList AssignmentExpression BareTupleExpression UnaryExpression Operator BinaryExpression TernaryExpression FunctionExpression AssignmentExpression CoefficientExpression TransposeExpression Coefficient CallExpression FieldExpression ParenthesizedExpression SpreadExpression AssignmentExpression ArrayExpression ArrayComprehensionExpression MatrixExpression MatrixRow GeneratorExpression TypedExpression SubtypedExpression ParameterizedIdentifier AssignOperator WhileStatement while WhileBinding LetStatement let LetBinding VariableDeclaration ConstStatement const AssignmentExpression BareTupleExpression GlobalStatement global LocalStatement local QuoteStatement quote BreakStatement break ContinueStatement continue ReturnStatement return ImportStatement using import Import ScopedIdentifier RenamedIdentifier as SelectedImport RenamedImport ExportStatement export CompoundExpression MacroExpression MacroFieldExpression MacroFieldName MacroArgumentList UnaryExpression Operator BinaryExpression TernaryExpression FunctionExpression AssignmentExpression CoefficientExpression TransposeExpression SpreadExpression FunctionAssignmentExpression", + maxTerm: 333, nodeProps: [ - ["closedBy", -2,5,8,"end else elseif",-15,11,19,21,36,41,44,48,51,54,75,81,159,162,174,193,"end",14,"end catch finally",16,"end finally",-9,34,58,93,118,119,126,151,152,153,"]",-2,62,131,"}",-7,63,70,99,116,128,148,155,")"], - ["group", -35,7,10,12,13,15,17,20,22,37,38,42,45,46,49,52,55,66,67,76,82,85,132,160,163,167,171,173,175,177,179,181,183,184,188,192,"keyword",-9,27,28,65,90,105,106,107,123,124,"operator"] + ["closedBy", -2,5,8,"end else elseif",-15,11,20,22,37,42,45,49,52,55,76,82,161,164,176,195,"end",14,"end catch else finally",16,"end else finally",19,"finally end",-9,35,59,94,119,120,127,152,153,154,"]",-2,63,132,"}",-7,64,71,100,117,129,149,156,")"], + ["group", -35,7,10,12,13,15,17,21,23,38,39,43,46,47,50,53,56,67,68,77,83,86,133,162,165,169,173,175,177,179,181,183,185,186,190,194,"keyword",-9,28,29,66,91,106,107,108,124,125,"operator"] ], skippedNodes: [0,2,3], repeatNodeCount: 36, - tokenData: "#%S~R.[XYHwYZHwpqHwqrJursK[stKotuLWuvL]vwLjwxLzxyNWyzN]z{L]{|Nb|}Nj}!ONo!O!P! _!P!Q!He!Q!R!Me!R![!N_![!]#!c!]!^#!s!^!_#!x!_!`##b!`!a!Js!b!c##o!}#O##t#O#P!Kc#P#Q##y#Q#R!Kh#S#T#$O#o#p#$T#p#q#$Y#q#r#$v#r#s!Lx$r$s!KR$w$x!L_%o%p!Kc&a&bL]%!]%!^!Kc%#t%#u! T%#u%#v!MP%#v%#w! T%#w%#x!MP%#x%#y! T%$O%$P! T%$P%$Q! T%$Q%$R! T%$R%$S! T%$S%$T! T%$U%$V! T%$W%$X! T%$X%$Y! T%$Y%$Z! T%$[%$]! T%$_%$`! T%$`%$a! T%$a%$b! T%$b%$c! T%$d%$e! T%$r%$s! T%$s%$t! T%$v%$w! T%$w%$x! T%$z%${! T%$|%$}! T%$}%%O! T%%P%%Q! T%%R%%S! T%%S%%T! T%%T%%U! T%%U%%V! T%%V%%W! T%%W%%X! T%%Y%%Z! T%%[%%]! T%%b%%c! T%%c%%d! T%%d%%e! T%%e%%f! T%%h%%i! T%%j%%k! T%%|%%}! T%%}%&O!MP%&O%&P! T%&P%&Q! T%&Q%&R! T%&R%&S! T%&S%&T! T%&T%&U! T%&U%&V! T%&V%&W! T%&W%&X! T%&X%&Y! T%&b%&c#${%&c%&dKV%&d%&eKV%&e%&fKV%&f%&gKV%&g%&hKV%&m%&n!L_%&n%&o!L_%&q%&r!Kc%&r%&s!Kc%&s%&t!Kc%&t%&u!KR%&u%&v!KR%&v%&w!KR%&w%&xKV%'O%'P!Kc%'P%'QKV%'Q%'RKV%'R%'S!Kc%'S%'T!L_%'T%'U!Kc%'U%'V!L_%'c%'dKV%'d%'e!L_%'f%'gKV%'g%'hKV%'i%'jKV%'j%'kKV%'l%'m!Kc%'m%'nKV%'n%'o!MU%'o%'pKV%'p%'qKV%'q%'rKV%'r%'sKV%'s%'tKV%'t%'uKV%'u%'vKV%'v%'wKV%'w%'xKV%'x%'yKV%'y%'zKV%'z%'{KV%'{%'|!L_%'|%'}KV%'}%(OKV%(O%(PKV%(P%(QKV%(Q%(RLe%(R%(SLe%(S%(TKV%(T%(UKV%(U%(VKV%(V%(WKV%(W%(XKV%(X%(YKV%(Y%(ZKV%(Z%([KV%([%(]KV%(]%(^KV%(^%(_KV%(_%(`KV%(`%(aKV%(a%(bKV%(b%(cKV%(c%(dKV%(d%(eKV%(e%(fKV%(f%(gKV%(g%(hKV%(h%(iKV%(i%(jKV%(j%(kKV%(k%(lKV%(l%(mKV%(m%(nKV%(n%(oKV%(o%(pKV%(p%(qKV%(q%(rKV%(r%(sKV%(s%(tKV%(t%(uKV%(u%(vKV%(v%(wKV%(w%(xKV%(x%(yKV%(y%(zKV%(z%({KV%({%(|KV%(|%(}KV%(}%)OKV%)O%)PKV%)P%)QKV%)Q%)RKV%)R%)SKV%)S%)TKV%)T%)UKV%)U%)VKV%)V%)WKV%)W%)XKV%)X%)YKV%)Y%)ZKV%)Z%)[KV%)]%)^!Kc%)^%)_!L_%)_%)`KV%)`%)aKV%)a%)bKV%)b%)cKV%)c%)d!Kc%)d%)e!L_%)e%)f!L_%)f%)g!L_%)g%)h!Kc%)h%)i!Kc%)i%)j!Kc%)j%)k!Kc%)k%)l!Kc%)l%)mKV%)n%)o!L_%)o%)p!L_%)p%)q!Kc%)q%)r!Kc%)r%)sKV%)s%)tKV%)y%)zKV%)|%)}KV%*O%*PKV%*Q%*RKV%*R%*SKV%*S%*TKV%*T%*UKV%*U%*VKV%*V%*WKV%*W%*XKV%*X%*YKV%*]%*^!M]%*^%*_!Kc%*_%*`!L_%*f%*g!Kc%*g%*h!Kc%*h%*i!Kc%*i%*j!Kc%*k%*l!Kc%*l%*m!Kc%*m%*n!Kc%*n%*o!Kc%*o%*pKV%*p%*q!L_%*q%*r!Kc%*r%*sKV%*s%*tKV%*t%*u!Kc%*u%*v!L_%*w%*xKV%*x%*yKV%*y%*zKV%*z%*{KV%*{%*|KV%*|%*}KV%*}%+OKV%+O%+PKV%+P%+QKV%+Q%+RKV%+R%+SKV%+S%+TKV%+T%+UKV%+U%+VKV%+V%+WKV%+W%+XKV%+X%+YKV%+Y%+ZKV%+Z%+[KV%+[%+]KV%+]%+^KV%+^%+_KV%+_%+`KV%+`%+aKV%+a%+bKV%+f%+gKV%+g%+hKV%+h%+iKV%+i%+jKV%+j%+kKV%+k%+lKV%+l%+mKV%+m%+nKV%+n%+oKV%+o%+pKV%+p%+qKV%+q%+rKV%+r%+sKV%+s%+tKV%:y%:z!Kc%F[%F]KV%Fb%FcKV%Fc%FdKV%Fk%Fl!Kc%Fl%FmKV%Fo%Fp!Kc%Fp%Fq!Kc%Fq%Fr!Kc%G[%G]!MP%G]%G^!MP%Ga%Gb! T%Gb%Gc! T%Gc%Gd! T%Ge%Gf! T%Gf%Gg! T%Gg%Gh! T%Gh%Gi! T%Gi%Gj! T%Gj%Gk! T%Gk%Gl! T%MW%MX! T%MX%MY! T%MY%MZ! T%MZ%M[! T%M[%M]! T%M]%M^! T%M^%M_! T%M_%M`! T%M`%Ma!MP%Ma%Mb!MP%Mb%Mc!MP%Mc%Md!MP%Md%Me! T%Me%Mf! T%Mf%Mg! T%Mg%Mh! T%Mh%Mi! T%Mi%Mj! T%Mj%Mk!MP%Mk%Ml!MP%Ml%Mm! T%Mm%Mn! T%Mn%Mo! T%Mo%Mp! T%Mp%Mq! T%Mu%Mv! T%Mv%Mw! T%Mw%Mx! T%Mx%My! T%Nn%No! T%No%Np! T%Np%Nq! T%Nq%Nr! T%Nr%Ns! T%Ns%Nt!MP%Nt%Nu! T%Nu%Nv! T%Nv%Nw!MP%Nw%Nx!MP%Nx%Ny! T%Ny%Nz!MP%Nz%N{! T%N{%N|!MP%N|%N}! T%N}& O! T& O& P!MP& P& Q!MP& Q& R! T& R& S! T& S& T!MP& T& U!MP& U& V! T& V& W! T& W& X!MP& X& Y!MP& Y& Z! T& Z& [! T& [& ]!MP& ]& ^!MP& ^& _! T& _& `!MP& `& a! T& a& b!MP& b& c! T& c& d! T& d& e! T& e& f! T& f& g! T& g& h! T& h& i! T& i& j! T& j& k!MP& k& l!MP& l& m! T&#V&#WKV&#W&#X!Kc&#[&#]!Kc&#^&#_!Kc&#_&#`!Kc&#`&#aKV&#a&#bKV&$R&$SKV&$T&$UKV&$U&$VKV&$V&$WKV&$f&$g! T&$h&$i!Kc&$i&$j!Kc&$l&$m!L_&$m&$n!L_&$y&$z!Kc&$z&${!L_&%a&%b!Kc&%f&%g!L_&%g&%h!L_&%h&%i!L_&%i&%j!L_&%j&%k!L_&%k&%l!L_&%l&%m!L_&%m&%n!L_&%n&%o!L_&%o&%p!L_&%p&%q!L_&%q&%r!L_&%r&%s!L_&%t&%u!Kc&%u&%v!Kc&%v&%w!Kc&%w&%x!Kc&%x&%y!Kc&%y&%z!Kc&%z&%{!Kc&%{&%|!Kc&%|&%}!Kc&%}&&O!L_&&O&&P!L_&&P&&Q!Kc&&Q&&R!Kc&&R&&S!Kc&&U&&V!Kc&&V&&W!L_&&W&&X!L_&&X&&Y!Kc&&Y&&Z!Kc&&Z&&[!L_&&`&&a!L_&&a&&b!Kc&&b&&c!L_&&c&&d!Kc&&d&&e!Kc&&e&&f!L_&&f&&g!L_&&g&&h!Kc&&h&&i!L_&&i&&j!Kc&&j&&k!L_&&k&&l!Kc&&l&&m!L_&&m&&n!L_&&n&&o!Kc&&p&&q!Kc&&q&&r!L_&&r&&s!Kc&&s&&t!L_&&t&&u!Kc&&u&&v!Kc&&v&&w!Kc&&w&&x!L_&&x&&y!L_&&y&&z!L_&&|&&}KV&&}&'OKV&'Q&'RKV&'R&'SKV&'S&'TKV&'T&'UKV&'U&'VKV&'V&'WKV&'W&'XKV&'X&'YKV&'Y&'ZKV&'Z&'[KV&'[&']Le&']&'^KV&'^&'_KV&'_&'`KV&'`&'aKV&'a&'bKV&'b&'cKV&'c&'dKV&'d&'eKV&'e&'fKV&'f&'gKV&'g&'hKV&'h&'iKV&'i&'jKV&'j&'kKV&'k&'lKV&'l&'mKV&'m&'nKV&'n&'oKV&'o&'pKV&'p&'qKV&'q&'rKV&'r&'sKV&'s&'tKV&'t&'uKV&'u&'vKV&'v&'wKV&'w&'xKV&'x&'yKV&'y&'zKV&'z&'{KV&'{&'|KV&'|&'}KV&'}&(OKV&(O&(PKV&(P&(QKV&(Q&(RKV&(R&(SKV&(S&(TKV&(T&(UKV&(U&(VKV&(V&(WKV&(W&(XKV&(X&(YKV&(Y&(ZKV&(Z&([KV&([&(]KV&(]&(^KV&(^&(_KV&(_&(`KV&(`&(aKV&(a&(bKV&(b&(cKV&(c&(dKV&(d&(eKV&(e&(fKV&(f&(gKV&(g&(hKV&(h&(iKV&(i&(jKV&(j&(kKV&(k&(lKV&(l&(mKV&(m&(nKV&(n&(oKV&(o&(pKV&(p&(qKV&(q&(rKV&(r&(sKV&(s&(tKV&(t&(uKV&(u&(vKV&(v&(wKV&(w&(xKV&(x&(yKV&(y&(zKV&(z&({KV&({&(|KV&(|&(}KV&(}&)OKV&)O&)PKV&)P&)QKV&)Q&)RKV&)R&)SKV&)S&)TKV&)T&)UKV&)U&)VKV&)V&)WKV&)W&)XKV&)X&)YKV&)Y&)ZKV&)Z&)[KV&)[&)]KV&)]&)^KV&)^&)_KV&)_&)`KV&)`&)aKV&)a&)bKV&)b&)cKV&)c&)dKV&)d&)eKV&)e&)fKV&)g&)h!Kc&*T&*UKV&*U&*VKV&*V&*WKV&*W&*XKV&+`&+a! T&+a&+b! T&+b&+c! T&+c&+d! T&+d&+e! T&+e&+f! T&+f&+g! T&+g&+h! T&+h&+i! T&+i&+j! T&+j&+k! T&+k&+l! T&+l&+m! T&+m&+n! T&+n&+o! T&+o&+p! T&+p&+q! T&+q&+r! T&+r&+s! T&+s&+t! T&+t&+u! T&+w&+x! T&+x&+y! T&+y&+z! T&+z&+{! T&+{&+|! T&+|&+}! T?MX?MY! T?MY?MZ!MP?MZ?M[! T?M[?M]!MP~H|T&q~XYI]YZI]pqI]![!]Io!a!bJZ~I`TXYI]YZI]pqI]![!]Io!a!bJZ~IrRXYI{YZI{pqI{~JQR(P~XYI{YZI{pqI{~J^RXYJgYZJgpqJg~JlR(O~XYJgYZJgpqJg~JzP'_~!_!`J}PKSP'eP!_!`KVPK[O'eP~KaP's~rsKd~KgPrsKj~KoO'u~~KtSR~OYKoZ;'SKo;'S;=`LQ<%lOKo~LTP;=`<%lKo~L]O'P~~LbP'c~!_!`Le~LjO&z~~LoQ'c~vwLu!_!`Le~LzO'}~RMPU(RQOwMcx#OMc#O#PMn#P;'SMc;'S;=`NQ<%lOMcPMfPwxMiPMnO#ZPPMqTOwMcwxMix;'SMc;'S;=`NQ<%lOMcPNTP;=`<%lMc~N]O&w~~NbO']~~NgP'b~!_!`Le~NoO'W~~NtR'b~}!ON}!_!`Le!`!a! Y~! QP!`!a! T~! YO'f~~! _O(Q~~! d-w'Q~qrJuuvL]vwL]z{L]{|Nb}!O!G}!O!P!HY!P!Q!He!Q![!Hv!^!_!Is!_!`!Jc!`!a!Js#O#P!Kc#Q#R!Kh#p#q!Kp#r#s!Lx$r$s!KR$w$x!L_%o%p!Kc&a&bL]%!]%!^!Kc%#t%#u! T%#u%#v!MP%#v%#w! T%#w%#x!MP%#x%#y! T%$O%$P! T%$P%$Q! T%$Q%$R! T%$R%$S! T%$S%$T! T%$U%$V! T%$W%$X! T%$X%$Y! T%$Y%$Z! T%$[%$]! T%$_%$`! T%$`%$a! T%$a%$b! T%$b%$c! T%$d%$e! T%$r%$s! T%$s%$t! T%$v%$w! T%$w%$x! T%$z%${! T%$|%$}! T%$}%%O! T%%P%%Q! T%%R%%S! T%%S%%T! T%%T%%U! T%%U%%V! T%%V%%W! T%%W%%X! T%%Y%%Z! T%%[%%]! T%%b%%c! T%%c%%d! T%%d%%e! T%%e%%f! T%%h%%i! T%%j%%k! T%%|%%}! T%%}%&O!MP%&O%&P! T%&P%&Q! T%&Q%&R! T%&R%&S! T%&S%&T! T%&T%&U! T%&U%&V! T%&V%&W! T%&W%&X! T%&X%&Y! T%&b%&cKV%&c%&dKV%&d%&eKV%&e%&fKV%&f%&gKV%&g%&hKV%&m%&n!L_%&n%&o!L_%&q%&r!Kc%&r%&s!Kc%&s%&t!Kc%&t%&u!KR%&u%&v!KR%&v%&w!KR%&w%&xKV%'O%'P!Kc%'P%'QKV%'Q%'RKV%'R%'S!Kc%'S%'T!L_%'T%'U!Kc%'U%'V!L_%'c%'dKV%'d%'e!L_%'f%'gKV%'g%'hKV%'i%'jKV%'j%'kKV%'l%'m!Kc%'m%'nKV%'n%'o!MU%'o%'pKV%'p%'qKV%'q%'rKV%'r%'sKV%'s%'tKV%'t%'uKV%'u%'vKV%'v%'wKV%'w%'xKV%'x%'yKV%'y%'zKV%'z%'{KV%'{%'|!L_%'|%'}KV%'}%(OKV%(O%(PKV%(P%(QKV%(Q%(RLe%(R%(SLe%(S%(TKV%(T%(UKV%(U%(VKV%(V%(WKV%(W%(XKV%(X%(YKV%(Y%(ZKV%(Z%([KV%([%(]KV%(]%(^KV%(^%(_KV%(_%(`KV%(`%(aKV%(a%(bKV%(b%(cKV%(c%(dKV%(d%(eKV%(e%(fKV%(f%(gKV%(g%(hKV%(h%(iKV%(i%(jKV%(j%(kKV%(k%(lKV%(l%(mKV%(m%(nKV%(n%(oKV%(o%(pKV%(p%(qKV%(q%(rKV%(r%(sKV%(s%(tKV%(t%(uKV%(u%(vKV%(v%(wKV%(w%(xKV%(x%(yKV%(y%(zKV%(z%({KV%({%(|KV%(|%(}KV%(}%)OKV%)O%)PKV%)P%)QKV%)Q%)RKV%)R%)SKV%)S%)TKV%)T%)UKV%)U%)VKV%)V%)WKV%)W%)XKV%)X%)YKV%)Y%)ZKV%)Z%)[KV%)]%)^!Kc%)^%)_!L_%)_%)`KV%)`%)aKV%)a%)bKV%)b%)cKV%)c%)d!Kc%)d%)e!L_%)e%)f!L_%)f%)g!L_%)g%)h!Kc%)h%)i!Kc%)i%)j!Kc%)j%)k!Kc%)k%)l!Kc%)l%)mKV%)n%)o!L_%)o%)p!L_%)p%)q!Kc%)q%)r!Kc%)r%)sKV%)s%)tKV%)y%)zKV%)|%)}KV%*O%*PKV%*Q%*RKV%*R%*SKV%*S%*TKV%*T%*UKV%*U%*VKV%*V%*WKV%*W%*XKV%*X%*YKV%*]%*^!M]%*^%*_!Kc%*_%*`!L_%*f%*g!Kc%*g%*h!Kc%*h%*i!Kc%*i%*j!Kc%*k%*l!Kc%*l%*m!Kc%*m%*n!Kc%*n%*o!Kc%*o%*pKV%*p%*q!L_%*q%*r!Kc%*r%*sKV%*s%*tKV%*t%*u!Kc%*u%*v!L_%*w%*xKV%*x%*yKV%*y%*zKV%*z%*{KV%*{%*|KV%*|%*}KV%*}%+OKV%+O%+PKV%+P%+QKV%+Q%+RKV%+R%+SKV%+S%+TKV%+T%+UKV%+U%+VKV%+V%+WKV%+W%+XKV%+X%+YKV%+Y%+ZKV%+Z%+[KV%+[%+]KV%+]%+^KV%+^%+_KV%+_%+`KV%+`%+aKV%+a%+bKV%+f%+gKV%+g%+hKV%+h%+iKV%+i%+jKV%+j%+kKV%+k%+lKV%+l%+mKV%+m%+nKV%+n%+oKV%+o%+pKV%+p%+qKV%+q%+rKV%+r%+sKV%+s%+tKV%:y%:z!Kc%F[%F]KV%Fb%FcKV%Fc%FdKV%Fk%Fl!Kc%Fl%FmKV%Fo%Fp!Kc%Fp%Fq!Kc%Fq%Fr!Kc%G[%G]!MP%G]%G^!MP%Ga%Gb! T%Gb%Gc! T%Gc%Gd! T%Ge%Gf! T%Gf%Gg! T%Gg%Gh! T%Gh%Gi! T%Gi%Gj! T%Gj%Gk! T%Gk%Gl! T%MW%MX! T%MX%MY! T%MY%MZ! T%MZ%M[! T%M[%M]! T%M]%M^! T%M^%M_! T%M_%M`! T%M`%Ma!MP%Ma%Mb!MP%Mb%Mc!MP%Mc%Md!MP%Md%Me! T%Me%Mf! T%Mf%Mg! T%Mg%Mh! T%Mh%Mi! T%Mi%Mj! T%Mj%Mk!MP%Mk%Ml!MP%Ml%Mm! T%Mm%Mn! T%Mn%Mo! T%Mo%Mp! T%Mp%Mq! T%Mu%Mv! T%Mv%Mw! T%Mw%Mx! T%Mx%My! T%Nn%No! T%No%Np! T%Np%Nq! T%Nq%Nr! T%Nr%Ns! T%Ns%Nt!MP%Nt%Nu! T%Nu%Nv! T%Nv%Nw!MP%Nw%Nx!MP%Nx%Ny! T%Ny%Nz!MP%Nz%N{! T%N{%N|!MP%N|%N}! T%N}& O! T& O& P!MP& P& Q!MP& Q& R! T& R& S! T& S& T!MP& T& U!MP& U& V! T& V& W! T& W& X!MP& X& Y!MP& Y& Z! T& Z& [! T& [& ]!MP& ]& ^!MP& ^& _! T& _& `!MP& `& a! T& a& b!MP& b& c! T& c& d! T& d& e! T& e& f! T& f& g! T& g& h! T& h& i! T& i& j! T& j& k!MP& k& l!MP& l& m! T&#V&#WKV&#W&#X!Kc&#[&#]!Kc&#^&#_!Kc&#_&#`!Kc&#`&#aKV&#a&#bKV&$R&$SKV&$T&$UKV&$U&$VKV&$V&$WKV&$f&$g! T&$h&$i!Kc&$i&$j!Kc&$l&$m!L_&$m&$n!L_&$y&$z!Kc&$z&${!L_&%a&%b!Kc&%f&%g!L_&%g&%h!L_&%h&%i!L_&%i&%j!L_&%j&%k!L_&%k&%l!L_&%l&%m!L_&%m&%n!L_&%n&%o!L_&%o&%p!L_&%p&%q!L_&%q&%r!L_&%r&%s!L_&%t&%u!Kc&%u&%v!Kc&%v&%w!Kc&%w&%x!Kc&%x&%y!Kc&%y&%z!Kc&%z&%{!Kc&%{&%|!Kc&%|&%}!Kc&%}&&O!L_&&O&&P!L_&&P&&Q!Kc&&Q&&R!Kc&&R&&S!Kc&&U&&V!Kc&&V&&W!L_&&W&&X!L_&&X&&Y!Kc&&Y&&Z!Kc&&Z&&[!L_&&`&&a!L_&&a&&b!Kc&&b&&c!L_&&c&&d!Kc&&d&&e!Kc&&e&&f!L_&&f&&g!L_&&g&&h!Kc&&h&&i!L_&&i&&j!Kc&&j&&k!L_&&k&&l!Kc&&l&&m!L_&&m&&n!L_&&n&&o!Kc&&p&&q!Kc&&q&&r!L_&&r&&s!Kc&&s&&t!L_&&t&&u!Kc&&u&&v!Kc&&v&&w!Kc&&w&&x!L_&&x&&y!L_&&y&&z!L_&&|&&}KV&&}&'OKV&'Q&'RKV&'R&'SKV&'S&'TKV&'T&'UKV&'U&'VKV&'V&'WKV&'W&'XKV&'X&'YKV&'Y&'ZKV&'Z&'[KV&'[&']Le&']&'^KV&'^&'_KV&'_&'`KV&'`&'aKV&'a&'bKV&'b&'cKV&'c&'dKV&'d&'eKV&'e&'fKV&'f&'gKV&'g&'hKV&'h&'iKV&'i&'jKV&'j&'kKV&'k&'lKV&'l&'mKV&'m&'nKV&'n&'oKV&'o&'pKV&'p&'qKV&'q&'rKV&'r&'sKV&'s&'tKV&'t&'uKV&'u&'vKV&'v&'wKV&'w&'xKV&'x&'yKV&'y&'zKV&'z&'{KV&'{&'|KV&'|&'}KV&'}&(OKV&(O&(PKV&(P&(QKV&(Q&(RKV&(R&(SKV&(S&(TKV&(T&(UKV&(U&(VKV&(V&(WKV&(W&(XKV&(X&(YKV&(Y&(ZKV&(Z&([KV&([&(]KV&(]&(^KV&(^&(_KV&(_&(`KV&(`&(aKV&(a&(bKV&(b&(cKV&(c&(dKV&(d&(eKV&(e&(fKV&(f&(gKV&(g&(hKV&(h&(iKV&(i&(jKV&(j&(kKV&(k&(lKV&(l&(mKV&(m&(nKV&(n&(oKV&(o&(pKV&(p&(qKV&(q&(rKV&(r&(sKV&(s&(tKV&(t&(uKV&(u&(vKV&(v&(wKV&(w&(xKV&(x&(yKV&(y&(zKV&(z&({KV&({&(|KV&(|&(}KV&(}&)OKV&)O&)PKV&)P&)QKV&)Q&)RKV&)R&)SKV&)S&)TKV&)T&)UKV&)U&)VKV&)V&)WKV&)W&)XKV&)X&)YKV&)Y&)ZKV&)Z&)[KV&)[&)]KV&)]&)^KV&)^&)_KV&)_&)`KV&)`&)aKV&)a&)bKV&)b&)cKV&)c&)dKV&)d&)eKV&)e&)fKV&)g&)h!Kc&*T&*UKV&*U&*VKV&*V&*WKV&*W&*XKV&+`&+a! T&+a&+b! T&+b&+c! T&+c&+d! T&+d&+e! T&+e&+f! T&+f&+g! T&+g&+h! T&+h&+i! T&+i&+j! T&+j&+k! T&+k&+l! T&+l&+m! T&+m&+n! T&+n&+o! T&+o&+p! T&+p&+q! T&+q&+r! T&+r&+s! T&+s&+t! T&+t&+u! T&+w&+x! T&+x&+y! T&+y&+z! T&+z&+{! T&+{&+|! T&+|&+}! T?MX?MY! T?MY?MZ!MP?MZ?M[! T?M[?M]!MP~!HSQ'b~}!ON}!_!`Le~!H]P!O!P!H`~!HeO(T~~!HjQ'c~!P!Q!Hp!_!`Le~!HsP!_!`Le~!H{Sx~!Q![!Hv!g!h!IX#R#S!Hv#X#Y!IX~!I[R{|!Ie}!O!Ie!Q![!Ik~!IhP!Q![!Ik~!IpPx~!Q![!Ik~!IxS'eP![!]KV!^!_!JU!_!`KV#p#q!J^~!JZP'^~!_!`Le~!JcO!f~~!JhQ&z~!_!`J}!`!a!Jn~!JsO'{~~!JxR'eP![!]!KR!_!`KV!`!a!KW~!KWO'_~~!K]Q'^~!_!`Le!`!a!JU~!KhO'c~~!KmP'd~!_!`Le~!KuS'b~{|!LR!_!`!Ld!`!a!Lj#p#q!Lo~!LUP{|!LX~!L[P#p#q!L_~!LdO'a~~!LgP#p#qLe~!LoO!g~~!LrQ!_!`!Ld#p#q!L_~!MPO&z~'_~~!MUO'd~~!M]O'eP'a~~!MbP'a~!_!`Le~!MjVx~!O!P!NP!Q![!N_!g!h!IX!z!{!Ns#R#S!N_#X#Y!IX#l#m!Ns~!NURx~!Q![!Hv!g!h!IX#X#Y!IX~!NdTx~!O!P!NP!Q![!N_!g!h!IX#R#S!N_#X#Y!IX~!NvR!Q![# P!c!i# P#T#Z# P~# UWx~!Q![# P!c!g# P!g!h# n!h!i# P#R#S# P#T#X# P#X#Y# n#Y#Z# P~# sYx~{|!Ie}!O!Ie!Q![# P!c!g# P!g!h# n!h!i# P#R#S# P#T#X# P#X#Y# n#Y#Z# P~#!hQ'R~![!]#!n!_!`Le~#!sO&|~~#!xO&t~~#!}S'eP![!]##Z!^!_!JU!_!`KV#p#q!J^~##bO&}~'eP~##iQ&{~&z~!_!`J}!`!a!Jn~##tO'n~~##yO'S~~#$OO'X~~#$TO'v~~#$YO'Y~~#$_S'b~{|!LR!_!`!Ld!`!a!Lj#p#q#$k~#$pQ'|~!_!`!Ld#p#q!L_~#${O'Z~R#%SO'yQ'eP", + tokenData: "#%S~R.[XYHwYZHwpqHwqrJursK[stKotuLWuvL]vwLjwxLzxyNWyzN]z{L]{|Nb|}Nj}!ONo!O!P! _!P!Q!He!Q!R!Me!R![!N_![!]#!c!]!^#!s!^!_#!x!_!`##b!`!a!Js!b!c##o!}#O##t#O#P!Kc#P#Q##y#Q#R!Kh#S#T#$O#o#p#$T#p#q#$Y#q#r#$v#r#s!Lx$r$s!KR$w$x!L_%o%p!Kc&a&bL]%!]%!^!Kc%#t%#u! T%#u%#v!MP%#v%#w! T%#w%#x!MP%#x%#y! T%$O%$P! T%$P%$Q! T%$Q%$R! T%$R%$S! T%$S%$T! T%$U%$V! T%$W%$X! T%$X%$Y! T%$Y%$Z! T%$[%$]! T%$_%$`! T%$`%$a! T%$a%$b! T%$b%$c! T%$d%$e! T%$r%$s! T%$s%$t! T%$v%$w! T%$w%$x! T%$z%${! T%$|%$}! T%$}%%O! T%%P%%Q! T%%R%%S! T%%S%%T! T%%T%%U! T%%U%%V! T%%V%%W! T%%W%%X! T%%Y%%Z! T%%[%%]! T%%b%%c! T%%c%%d! T%%d%%e! T%%e%%f! T%%h%%i! T%%j%%k! T%%|%%}! T%%}%&O!MP%&O%&P! T%&P%&Q! T%&Q%&R! T%&R%&S! T%&S%&T! T%&T%&U! T%&U%&V! T%&V%&W! T%&W%&X! T%&X%&Y! T%&b%&c#${%&c%&dKV%&d%&eKV%&e%&fKV%&f%&gKV%&g%&hKV%&m%&n!L_%&n%&o!L_%&q%&r!Kc%&r%&s!Kc%&s%&t!Kc%&t%&u!KR%&u%&v!KR%&v%&w!KR%&w%&xKV%'O%'P!Kc%'P%'QKV%'Q%'RKV%'R%'S!Kc%'S%'T!L_%'T%'U!Kc%'U%'V!L_%'c%'dKV%'d%'e!L_%'f%'gKV%'g%'hKV%'i%'jKV%'j%'kKV%'l%'m!Kc%'m%'nKV%'n%'o!MU%'o%'pKV%'p%'qKV%'q%'rKV%'r%'sKV%'s%'tKV%'t%'uKV%'u%'vKV%'v%'wKV%'w%'xKV%'x%'yKV%'y%'zKV%'z%'{KV%'{%'|!L_%'|%'}KV%'}%(OKV%(O%(PKV%(P%(QKV%(Q%(RLe%(R%(SLe%(S%(TKV%(T%(UKV%(U%(VKV%(V%(WKV%(W%(XKV%(X%(YKV%(Y%(ZKV%(Z%([KV%([%(]KV%(]%(^KV%(^%(_KV%(_%(`KV%(`%(aKV%(a%(bKV%(b%(cKV%(c%(dKV%(d%(eKV%(e%(fKV%(f%(gKV%(g%(hKV%(h%(iKV%(i%(jKV%(j%(kKV%(k%(lKV%(l%(mKV%(m%(nKV%(n%(oKV%(o%(pKV%(p%(qKV%(q%(rKV%(r%(sKV%(s%(tKV%(t%(uKV%(u%(vKV%(v%(wKV%(w%(xKV%(x%(yKV%(y%(zKV%(z%({KV%({%(|KV%(|%(}KV%(}%)OKV%)O%)PKV%)P%)QKV%)Q%)RKV%)R%)SKV%)S%)TKV%)T%)UKV%)U%)VKV%)V%)WKV%)W%)XKV%)X%)YKV%)Y%)ZKV%)Z%)[KV%)]%)^!Kc%)^%)_!L_%)_%)`KV%)`%)aKV%)a%)bKV%)b%)cKV%)c%)d!Kc%)d%)e!L_%)e%)f!L_%)f%)g!L_%)g%)h!Kc%)h%)i!Kc%)i%)j!Kc%)j%)k!Kc%)k%)l!Kc%)l%)mKV%)n%)o!L_%)o%)p!L_%)p%)q!Kc%)q%)r!Kc%)r%)sKV%)s%)tKV%)y%)zKV%)|%)}KV%*O%*PKV%*Q%*RKV%*R%*SKV%*S%*TKV%*T%*UKV%*U%*VKV%*V%*WKV%*W%*XKV%*X%*YKV%*]%*^!M]%*^%*_!Kc%*_%*`!L_%*f%*g!Kc%*g%*h!Kc%*h%*i!Kc%*i%*j!Kc%*k%*l!Kc%*l%*m!Kc%*m%*n!Kc%*n%*o!Kc%*o%*pKV%*p%*q!L_%*q%*r!Kc%*r%*sKV%*s%*tKV%*t%*u!Kc%*u%*v!L_%*w%*xKV%*x%*yKV%*y%*zKV%*z%*{KV%*{%*|KV%*|%*}KV%*}%+OKV%+O%+PKV%+P%+QKV%+Q%+RKV%+R%+SKV%+S%+TKV%+T%+UKV%+U%+VKV%+V%+WKV%+W%+XKV%+X%+YKV%+Y%+ZKV%+Z%+[KV%+[%+]KV%+]%+^KV%+^%+_KV%+_%+`KV%+`%+aKV%+a%+bKV%+f%+gKV%+g%+hKV%+h%+iKV%+i%+jKV%+j%+kKV%+k%+lKV%+l%+mKV%+m%+nKV%+n%+oKV%+o%+pKV%+p%+qKV%+q%+rKV%+r%+sKV%+s%+tKV%:y%:z!Kc%F[%F]KV%Fb%FcKV%Fc%FdKV%Fk%Fl!Kc%Fl%FmKV%Fo%Fp!Kc%Fp%Fq!Kc%Fq%Fr!Kc%G[%G]!MP%G]%G^!MP%Ga%Gb! T%Gb%Gc! T%Gc%Gd! T%Ge%Gf! T%Gf%Gg! T%Gg%Gh! T%Gh%Gi! T%Gi%Gj! T%Gj%Gk! T%Gk%Gl! T%MW%MX! T%MX%MY! T%MY%MZ! T%MZ%M[! T%M[%M]! T%M]%M^! T%M^%M_! T%M_%M`! T%M`%Ma!MP%Ma%Mb!MP%Mb%Mc!MP%Mc%Md!MP%Md%Me! T%Me%Mf! T%Mf%Mg! T%Mg%Mh! T%Mh%Mi! T%Mi%Mj! T%Mj%Mk!MP%Mk%Ml!MP%Ml%Mm! T%Mm%Mn! T%Mn%Mo! T%Mo%Mp! T%Mp%Mq! T%Mu%Mv! T%Mv%Mw! T%Mw%Mx! T%Mx%My! T%Nn%No! T%No%Np! T%Np%Nq! T%Nq%Nr! T%Nr%Ns! T%Ns%Nt!MP%Nt%Nu! T%Nu%Nv! T%Nv%Nw!MP%Nw%Nx!MP%Nx%Ny! T%Ny%Nz!MP%Nz%N{! T%N{%N|!MP%N|%N}! T%N}& O! T& O& P!MP& P& Q!MP& Q& R! T& R& S! T& S& T!MP& T& U!MP& U& V! T& V& W! T& W& X!MP& X& Y!MP& Y& Z! T& Z& [! T& [& ]!MP& ]& ^!MP& ^& _! T& _& `!MP& `& a! T& a& b!MP& b& c! T& c& d! T& d& e! T& e& f! T& f& g! T& g& h! T& h& i! T& i& j! T& j& k!MP& k& l!MP& l& m! T&#V&#WKV&#W&#X!Kc&#[&#]!Kc&#^&#_!Kc&#_&#`!Kc&#`&#aKV&#a&#bKV&$R&$SKV&$T&$UKV&$U&$VKV&$V&$WKV&$f&$g! T&$h&$i!Kc&$i&$j!Kc&$l&$m!L_&$m&$n!L_&$y&$z!Kc&$z&${!L_&%a&%b!Kc&%f&%g!L_&%g&%h!L_&%h&%i!L_&%i&%j!L_&%j&%k!L_&%k&%l!L_&%l&%m!L_&%m&%n!L_&%n&%o!L_&%o&%p!L_&%p&%q!L_&%q&%r!L_&%r&%s!L_&%t&%u!Kc&%u&%v!Kc&%v&%w!Kc&%w&%x!Kc&%x&%y!Kc&%y&%z!Kc&%z&%{!Kc&%{&%|!Kc&%|&%}!Kc&%}&&O!L_&&O&&P!L_&&P&&Q!Kc&&Q&&R!Kc&&R&&S!Kc&&U&&V!Kc&&V&&W!L_&&W&&X!L_&&X&&Y!Kc&&Y&&Z!Kc&&Z&&[!L_&&`&&a!L_&&a&&b!Kc&&b&&c!L_&&c&&d!Kc&&d&&e!Kc&&e&&f!L_&&f&&g!L_&&g&&h!Kc&&h&&i!L_&&i&&j!Kc&&j&&k!L_&&k&&l!Kc&&l&&m!L_&&m&&n!L_&&n&&o!Kc&&p&&q!Kc&&q&&r!L_&&r&&s!Kc&&s&&t!L_&&t&&u!Kc&&u&&v!Kc&&v&&w!Kc&&w&&x!L_&&x&&y!L_&&y&&z!L_&&|&&}KV&&}&'OKV&'Q&'RKV&'R&'SKV&'S&'TKV&'T&'UKV&'U&'VKV&'V&'WKV&'W&'XKV&'X&'YKV&'Y&'ZKV&'Z&'[KV&'[&']Le&']&'^KV&'^&'_KV&'_&'`KV&'`&'aKV&'a&'bKV&'b&'cKV&'c&'dKV&'d&'eKV&'e&'fKV&'f&'gKV&'g&'hKV&'h&'iKV&'i&'jKV&'j&'kKV&'k&'lKV&'l&'mKV&'m&'nKV&'n&'oKV&'o&'pKV&'p&'qKV&'q&'rKV&'r&'sKV&'s&'tKV&'t&'uKV&'u&'vKV&'v&'wKV&'w&'xKV&'x&'yKV&'y&'zKV&'z&'{KV&'{&'|KV&'|&'}KV&'}&(OKV&(O&(PKV&(P&(QKV&(Q&(RKV&(R&(SKV&(S&(TKV&(T&(UKV&(U&(VKV&(V&(WKV&(W&(XKV&(X&(YKV&(Y&(ZKV&(Z&([KV&([&(]KV&(]&(^KV&(^&(_KV&(_&(`KV&(`&(aKV&(a&(bKV&(b&(cKV&(c&(dKV&(d&(eKV&(e&(fKV&(f&(gKV&(g&(hKV&(h&(iKV&(i&(jKV&(j&(kKV&(k&(lKV&(l&(mKV&(m&(nKV&(n&(oKV&(o&(pKV&(p&(qKV&(q&(rKV&(r&(sKV&(s&(tKV&(t&(uKV&(u&(vKV&(v&(wKV&(w&(xKV&(x&(yKV&(y&(zKV&(z&({KV&({&(|KV&(|&(}KV&(}&)OKV&)O&)PKV&)P&)QKV&)Q&)RKV&)R&)SKV&)S&)TKV&)T&)UKV&)U&)VKV&)V&)WKV&)W&)XKV&)X&)YKV&)Y&)ZKV&)Z&)[KV&)[&)]KV&)]&)^KV&)^&)_KV&)_&)`KV&)`&)aKV&)a&)bKV&)b&)cKV&)c&)dKV&)d&)eKV&)e&)fKV&)g&)h!Kc&*T&*UKV&*U&*VKV&*V&*WKV&*W&*XKV&+`&+a! T&+a&+b! T&+b&+c! T&+c&+d! T&+d&+e! T&+e&+f! T&+f&+g! T&+g&+h! T&+h&+i! T&+i&+j! T&+j&+k! T&+k&+l! T&+l&+m! T&+m&+n! T&+n&+o! T&+o&+p! T&+p&+q! T&+q&+r! T&+r&+s! T&+s&+t! T&+t&+u! T&+w&+x! T&+x&+y! T&+y&+z! T&+z&+{! T&+{&+|! T&+|&+}! T?MX?MY! T?MY?MZ!MP?MZ?M[! T?M[?M]!MP~H|T&s~XYI]YZI]pqI]![!]Io!a!bJZ~I`TXYI]YZI]pqI]![!]Io!a!bJZ~IrRXYI{YZI{pqI{~JQR(R~XYI{YZI{pqI{~J^RXYJgYZJgpqJg~JlR(Q~XYJgYZJgpqJg~JzP'a~!_!`J}PKSP'gP!_!`KVPK[O'gP~KaP'u~rsKd~KgPrsKj~KoO'w~~KtSR~OYKoZ;'SKo;'S;=`LQ<%lOKo~LTP;=`<%lKo~L]O'R~~LbP'e~!_!`Le~LjO&|~~LoQ'e~vwLu!_!`Le~LzO(P~RMPU(TQOwMcx#OMc#O#PMn#P;'SMc;'S;=`NQ<%lOMcPMfPwxMiPMnO#[PPMqTOwMcwxMix;'SMc;'S;=`NQ<%lOMcPNTP;=`<%lMc~N]O&y~~NbO'_~~NgP'd~!_!`Le~NoO'Y~~NtR'd~}!ON}!_!`Le!`!a! Y~! QP!`!a! T~! YO'h~~! _O(S~~! d-w'S~qrJuuvL]vwL]z{L]{|Nb}!O!G}!O!P!HY!P!Q!He!Q![!Hv!^!_!Is!_!`!Jc!`!a!Js#O#P!Kc#Q#R!Kh#p#q!Kp#r#s!Lx$r$s!KR$w$x!L_%o%p!Kc&a&bL]%!]%!^!Kc%#t%#u! T%#u%#v!MP%#v%#w! T%#w%#x!MP%#x%#y! T%$O%$P! T%$P%$Q! T%$Q%$R! T%$R%$S! T%$S%$T! T%$U%$V! T%$W%$X! T%$X%$Y! T%$Y%$Z! T%$[%$]! T%$_%$`! T%$`%$a! T%$a%$b! T%$b%$c! T%$d%$e! T%$r%$s! T%$s%$t! T%$v%$w! T%$w%$x! T%$z%${! T%$|%$}! T%$}%%O! T%%P%%Q! T%%R%%S! T%%S%%T! T%%T%%U! T%%U%%V! T%%V%%W! T%%W%%X! T%%Y%%Z! T%%[%%]! T%%b%%c! T%%c%%d! T%%d%%e! T%%e%%f! T%%h%%i! T%%j%%k! T%%|%%}! T%%}%&O!MP%&O%&P! T%&P%&Q! T%&Q%&R! T%&R%&S! T%&S%&T! T%&T%&U! T%&U%&V! T%&V%&W! T%&W%&X! T%&X%&Y! T%&b%&cKV%&c%&dKV%&d%&eKV%&e%&fKV%&f%&gKV%&g%&hKV%&m%&n!L_%&n%&o!L_%&q%&r!Kc%&r%&s!Kc%&s%&t!Kc%&t%&u!KR%&u%&v!KR%&v%&w!KR%&w%&xKV%'O%'P!Kc%'P%'QKV%'Q%'RKV%'R%'S!Kc%'S%'T!L_%'T%'U!Kc%'U%'V!L_%'c%'dKV%'d%'e!L_%'f%'gKV%'g%'hKV%'i%'jKV%'j%'kKV%'l%'m!Kc%'m%'nKV%'n%'o!MU%'o%'pKV%'p%'qKV%'q%'rKV%'r%'sKV%'s%'tKV%'t%'uKV%'u%'vKV%'v%'wKV%'w%'xKV%'x%'yKV%'y%'zKV%'z%'{KV%'{%'|!L_%'|%'}KV%'}%(OKV%(O%(PKV%(P%(QKV%(Q%(RLe%(R%(SLe%(S%(TKV%(T%(UKV%(U%(VKV%(V%(WKV%(W%(XKV%(X%(YKV%(Y%(ZKV%(Z%([KV%([%(]KV%(]%(^KV%(^%(_KV%(_%(`KV%(`%(aKV%(a%(bKV%(b%(cKV%(c%(dKV%(d%(eKV%(e%(fKV%(f%(gKV%(g%(hKV%(h%(iKV%(i%(jKV%(j%(kKV%(k%(lKV%(l%(mKV%(m%(nKV%(n%(oKV%(o%(pKV%(p%(qKV%(q%(rKV%(r%(sKV%(s%(tKV%(t%(uKV%(u%(vKV%(v%(wKV%(w%(xKV%(x%(yKV%(y%(zKV%(z%({KV%({%(|KV%(|%(}KV%(}%)OKV%)O%)PKV%)P%)QKV%)Q%)RKV%)R%)SKV%)S%)TKV%)T%)UKV%)U%)VKV%)V%)WKV%)W%)XKV%)X%)YKV%)Y%)ZKV%)Z%)[KV%)]%)^!Kc%)^%)_!L_%)_%)`KV%)`%)aKV%)a%)bKV%)b%)cKV%)c%)d!Kc%)d%)e!L_%)e%)f!L_%)f%)g!L_%)g%)h!Kc%)h%)i!Kc%)i%)j!Kc%)j%)k!Kc%)k%)l!Kc%)l%)mKV%)n%)o!L_%)o%)p!L_%)p%)q!Kc%)q%)r!Kc%)r%)sKV%)s%)tKV%)y%)zKV%)|%)}KV%*O%*PKV%*Q%*RKV%*R%*SKV%*S%*TKV%*T%*UKV%*U%*VKV%*V%*WKV%*W%*XKV%*X%*YKV%*]%*^!M]%*^%*_!Kc%*_%*`!L_%*f%*g!Kc%*g%*h!Kc%*h%*i!Kc%*i%*j!Kc%*k%*l!Kc%*l%*m!Kc%*m%*n!Kc%*n%*o!Kc%*o%*pKV%*p%*q!L_%*q%*r!Kc%*r%*sKV%*s%*tKV%*t%*u!Kc%*u%*v!L_%*w%*xKV%*x%*yKV%*y%*zKV%*z%*{KV%*{%*|KV%*|%*}KV%*}%+OKV%+O%+PKV%+P%+QKV%+Q%+RKV%+R%+SKV%+S%+TKV%+T%+UKV%+U%+VKV%+V%+WKV%+W%+XKV%+X%+YKV%+Y%+ZKV%+Z%+[KV%+[%+]KV%+]%+^KV%+^%+_KV%+_%+`KV%+`%+aKV%+a%+bKV%+f%+gKV%+g%+hKV%+h%+iKV%+i%+jKV%+j%+kKV%+k%+lKV%+l%+mKV%+m%+nKV%+n%+oKV%+o%+pKV%+p%+qKV%+q%+rKV%+r%+sKV%+s%+tKV%:y%:z!Kc%F[%F]KV%Fb%FcKV%Fc%FdKV%Fk%Fl!Kc%Fl%FmKV%Fo%Fp!Kc%Fp%Fq!Kc%Fq%Fr!Kc%G[%G]!MP%G]%G^!MP%Ga%Gb! T%Gb%Gc! T%Gc%Gd! T%Ge%Gf! T%Gf%Gg! T%Gg%Gh! T%Gh%Gi! T%Gi%Gj! T%Gj%Gk! T%Gk%Gl! T%MW%MX! T%MX%MY! T%MY%MZ! T%MZ%M[! T%M[%M]! T%M]%M^! T%M^%M_! T%M_%M`! T%M`%Ma!MP%Ma%Mb!MP%Mb%Mc!MP%Mc%Md!MP%Md%Me! T%Me%Mf! T%Mf%Mg! T%Mg%Mh! T%Mh%Mi! T%Mi%Mj! T%Mj%Mk!MP%Mk%Ml!MP%Ml%Mm! T%Mm%Mn! T%Mn%Mo! T%Mo%Mp! T%Mp%Mq! T%Mu%Mv! T%Mv%Mw! T%Mw%Mx! T%Mx%My! T%Nn%No! T%No%Np! T%Np%Nq! T%Nq%Nr! T%Nr%Ns! T%Ns%Nt!MP%Nt%Nu! T%Nu%Nv! T%Nv%Nw!MP%Nw%Nx!MP%Nx%Ny! T%Ny%Nz!MP%Nz%N{! T%N{%N|!MP%N|%N}! T%N}& O! T& O& P!MP& P& Q!MP& Q& R! T& R& S! T& S& T!MP& T& U!MP& U& V! T& V& W! T& W& X!MP& X& Y!MP& Y& Z! T& Z& [! T& [& ]!MP& ]& ^!MP& ^& _! T& _& `!MP& `& a! T& a& b!MP& b& c! T& c& d! T& d& e! T& e& f! T& f& g! T& g& h! T& h& i! T& i& j! T& j& k!MP& k& l!MP& l& m! T&#V&#WKV&#W&#X!Kc&#[&#]!Kc&#^&#_!Kc&#_&#`!Kc&#`&#aKV&#a&#bKV&$R&$SKV&$T&$UKV&$U&$VKV&$V&$WKV&$f&$g! T&$h&$i!Kc&$i&$j!Kc&$l&$m!L_&$m&$n!L_&$y&$z!Kc&$z&${!L_&%a&%b!Kc&%f&%g!L_&%g&%h!L_&%h&%i!L_&%i&%j!L_&%j&%k!L_&%k&%l!L_&%l&%m!L_&%m&%n!L_&%n&%o!L_&%o&%p!L_&%p&%q!L_&%q&%r!L_&%r&%s!L_&%t&%u!Kc&%u&%v!Kc&%v&%w!Kc&%w&%x!Kc&%x&%y!Kc&%y&%z!Kc&%z&%{!Kc&%{&%|!Kc&%|&%}!Kc&%}&&O!L_&&O&&P!L_&&P&&Q!Kc&&Q&&R!Kc&&R&&S!Kc&&U&&V!Kc&&V&&W!L_&&W&&X!L_&&X&&Y!Kc&&Y&&Z!Kc&&Z&&[!L_&&`&&a!L_&&a&&b!Kc&&b&&c!L_&&c&&d!Kc&&d&&e!Kc&&e&&f!L_&&f&&g!L_&&g&&h!Kc&&h&&i!L_&&i&&j!Kc&&j&&k!L_&&k&&l!Kc&&l&&m!L_&&m&&n!L_&&n&&o!Kc&&p&&q!Kc&&q&&r!L_&&r&&s!Kc&&s&&t!L_&&t&&u!Kc&&u&&v!Kc&&v&&w!Kc&&w&&x!L_&&x&&y!L_&&y&&z!L_&&|&&}KV&&}&'OKV&'Q&'RKV&'R&'SKV&'S&'TKV&'T&'UKV&'U&'VKV&'V&'WKV&'W&'XKV&'X&'YKV&'Y&'ZKV&'Z&'[KV&'[&']Le&']&'^KV&'^&'_KV&'_&'`KV&'`&'aKV&'a&'bKV&'b&'cKV&'c&'dKV&'d&'eKV&'e&'fKV&'f&'gKV&'g&'hKV&'h&'iKV&'i&'jKV&'j&'kKV&'k&'lKV&'l&'mKV&'m&'nKV&'n&'oKV&'o&'pKV&'p&'qKV&'q&'rKV&'r&'sKV&'s&'tKV&'t&'uKV&'u&'vKV&'v&'wKV&'w&'xKV&'x&'yKV&'y&'zKV&'z&'{KV&'{&'|KV&'|&'}KV&'}&(OKV&(O&(PKV&(P&(QKV&(Q&(RKV&(R&(SKV&(S&(TKV&(T&(UKV&(U&(VKV&(V&(WKV&(W&(XKV&(X&(YKV&(Y&(ZKV&(Z&([KV&([&(]KV&(]&(^KV&(^&(_KV&(_&(`KV&(`&(aKV&(a&(bKV&(b&(cKV&(c&(dKV&(d&(eKV&(e&(fKV&(f&(gKV&(g&(hKV&(h&(iKV&(i&(jKV&(j&(kKV&(k&(lKV&(l&(mKV&(m&(nKV&(n&(oKV&(o&(pKV&(p&(qKV&(q&(rKV&(r&(sKV&(s&(tKV&(t&(uKV&(u&(vKV&(v&(wKV&(w&(xKV&(x&(yKV&(y&(zKV&(z&({KV&({&(|KV&(|&(}KV&(}&)OKV&)O&)PKV&)P&)QKV&)Q&)RKV&)R&)SKV&)S&)TKV&)T&)UKV&)U&)VKV&)V&)WKV&)W&)XKV&)X&)YKV&)Y&)ZKV&)Z&)[KV&)[&)]KV&)]&)^KV&)^&)_KV&)_&)`KV&)`&)aKV&)a&)bKV&)b&)cKV&)c&)dKV&)d&)eKV&)e&)fKV&)g&)h!Kc&*T&*UKV&*U&*VKV&*V&*WKV&*W&*XKV&+`&+a! T&+a&+b! T&+b&+c! T&+c&+d! T&+d&+e! T&+e&+f! T&+f&+g! T&+g&+h! T&+h&+i! T&+i&+j! T&+j&+k! T&+k&+l! T&+l&+m! T&+m&+n! T&+n&+o! T&+o&+p! T&+p&+q! T&+q&+r! T&+r&+s! T&+s&+t! T&+t&+u! T&+w&+x! T&+x&+y! T&+y&+z! T&+z&+{! T&+{&+|! T&+|&+}! T?MX?MY! T?MY?MZ!MP?MZ?M[! T?M[?M]!MP~!HSQ'd~}!ON}!_!`Le~!H]P!O!P!H`~!HeO(V~~!HjQ'e~!P!Q!Hp!_!`Le~!HsP!_!`Le~!H{Sy~!Q![!Hv!g!h!IX#R#S!Hv#X#Y!IX~!I[R{|!Ie}!O!Ie!Q![!Ik~!IhP!Q![!Ik~!IpPy~!Q![!Ik~!IxS'gP![!]KV!^!_!JU!_!`KV#p#q!J^~!JZP'`~!_!`Le~!JcO!g~~!JhQ&|~!_!`J}!`!a!Jn~!JsO'}~~!JxR'gP![!]!KR!_!`KV!`!a!KW~!KWO'a~~!K]Q'`~!_!`Le!`!a!JU~!KhO'e~~!KmP'f~!_!`Le~!KuS'd~{|!LR!_!`!Ld!`!a!Lj#p#q!Lo~!LUP{|!LX~!L[P#p#q!L_~!LdO'c~~!LgP#p#qLe~!LoO!h~~!LrQ!_!`!Ld#p#q!L_~!MPO&|~'a~~!MUO'f~~!M]O'gP'c~~!MbP'c~!_!`Le~!MjVy~!O!P!NP!Q![!N_!g!h!IX!z!{!Ns#R#S!N_#X#Y!IX#l#m!Ns~!NURy~!Q![!Hv!g!h!IX#X#Y!IX~!NdTy~!O!P!NP!Q![!N_!g!h!IX#R#S!N_#X#Y!IX~!NvR!Q![# P!c!i# P#T#Z# P~# UWy~!Q![# P!c!g# P!g!h# n!h!i# P#R#S# P#T#X# P#X#Y# n#Y#Z# P~# sYy~{|!Ie}!O!Ie!Q![# P!c!g# P!g!h# n!h!i# P#R#S# P#T#X# P#X#Y# n#Y#Z# P~#!hQ'T~![!]#!n!_!`Le~#!sO'O~~#!xO&v~~#!}S'gP![!]##Z!^!_!JU!_!`KV#p#q!J^~##bO'P~'gP~##iQ&}~&|~!_!`J}!`!a!Jn~##tO'p~~##yO'U~~#$OO'Z~~#$TO'x~~#$YO'[~~#$_S'd~{|!LR!_!`!Ld!`!a!Lj#p#q#$k~#$pQ(O~!_!`!Ld#p#q!L_~#${O']~R#%SO'{Q'gP", tokenizers: [layoutExtra, newline$3, word, Identifier$3, BlockComment$2, tripleStringContent, stringContent, commandStringContent, tripleStringContentWithoutInterpolation, stringContentWithoutInterpolation, commandStringContentWithoutInterpolation, 0, 1], topRules: {"SourceFile":[0,4]}, - dynamicPrecedences: {"30":2,"33":2,"95":10,"143":5,"189":1,"204":5,"207":2,"302":1,"304":1,"305":10,"308":1,"318":1,"326":1,"328":10,"329":10,"331":1}, - specialized: [{term: 1, get: value => spec_Identifier[value] || -1}], - tokenPrec: 51925 + dynamicPrecedences: {"31":2,"34":2,"96":10,"144":5,"191":1,"206":5,"304":1,"306":1,"307":10,"310":1,"320":1,"328":1,"330":10,"331":10,"333":1}, + specialized: [{term: 1, get: (value) => spec_Identifier[value] || -1}], + tokenPrec: 53216 }); const C = "\u037c"; @@ -7890,7 +8418,7 @@ class StyleModule { return C + id.toString(36) } - // :: (union, union<[StyleModule], StyleModule>) + // :: (union, union<[StyleModule], StyleModule>, ?{nonce: ?string}) // // Mount the given set of modules in the given DOM root, which ensures // that the CSS rules defined by the module are available in that @@ -7903,25 +8431,34 @@ class StyleModule { // modules. If you call this function multiple times for the same root // in a way that changes the order of already mounted modules, the old // order will be changed. - static mount(root, modules) { - (root[SET] || new StyleSet(root)).mount(Array.isArray(modules) ? modules : [modules]); + // + // If a Content Security Policy nonce is provided, it is added to + // the `