DuyTa
/

Graduation

Model card Files Files and versions Community

Graduation / ui /node_modules /.vite /deps /@codemirror_lang-python.js

DuyTa's picture

Upload folder using huggingface_hub

bc20498 verified 6 months ago

history blame contribute delete

109 kB

	import {
	completeFromList,
	ifNotIn,
	snippetCompletion
	} from "./chunk-IPAQR4PO.js";
	import {
	DefaultBufferLength,
	IterMode,
	LRLanguage,
	LanguageSupport,
	NodeProp,
	NodeSet,
	NodeType,
	NodeWeakMap,
	Parser,
	Tree,
	delimitedIndent,
	foldInside,
	foldNodeProp,
	indentNodeProp,
	styleTags,
	syntaxTree,
	tags
	} from "./chunk-AHXJAWF2.js";
	import "./chunk-UKXRAEWG.js";
	import "./chunk-3BHLKIA4.js";
	import "./chunk-TNDHKS54.js";

	// node_modules/@lezer/lr/dist/index.js
	var Stack = class _Stack {
	/**
	@internal
	*/
	constructor(p, stack, state, reducePos, pos, score, buffer, bufferBase, curContext, lookAhead = 0, parent) {
	this.p = p;
	this.stack = stack;
	this.state = state;
	this.reducePos = reducePos;
	this.pos = pos;
	this.score = score;
	this.buffer = buffer;
	this.bufferBase = bufferBase;
	this.curContext = curContext;
	this.lookAhead = lookAhead;
	this.parent = parent;
	}
	/**
	@internal
	*/
	toString() {
	return `[${this.stack.filter((_, i) => i % 3 == 0).concat(this.state)}]@${this.pos}${this.score ? "!" + this.score : ""}`;
	}
	// Start an empty stack
	/**
	@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.
	*/
	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
	*/
	pushState(state, start) {
	this.stack.push(this.state, start, this.bufferBase + this.buffer.length);
	this.state = state;
	}
	// Apply a reduce action
	/**
	@internal
	*/
	reduce(action) {
	var _a;
	let depth = action >> 19, type = action & 65535;
	let { parser: parser2 } = this.p;
	if (this.reducePos < this.pos - 25)
	this.setLookAhead(this.pos);
	let dPrec = parser2.dynamicPrecedence(type);
	if (dPrec)
	this.score += dPrec;
	if (depth == 0) {
	this.pushState(parser2.getGoto(this.state, type, true), this.reducePos);
	if (type < parser2.minRepeatTerm)
	this.storeNode(type, this.reducePos, this.reducePos, 4, true);
	this.reduceContext(type, this.reducePos);
	return;
	}
	let base = this.stack.length - (depth - 1) * 3 - (action & 262144 ? 6 : 0);
	let start = base ? this.stack[base - 2] : this.p.ranges[0].from, size = this.reducePos - start;
	if (size >= 2e3 && !((_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;
	if (type < parser2.minRepeatTerm \|\| action & 131072) {
	let pos = parser2.stateFlag(
	this.state,
	1
	/* StateFlag.Skipped */
	) ? this.pos : this.reducePos;
	this.storeNode(type, start, pos, count + 4, true);
	}
	if (action & 262144) {
	this.state = this.stack[base];
	} else {
	let baseStateID = this.stack[base - 3];
	this.state = parser2.getGoto(baseStateID, type, true);
	}
	while (this.stack.length > base)
	this.stack.pop();
	this.reduceContext(type, start);
	}
	// Shift a value into the buffer
	/**
	@internal
	*/
	storeNode(term, start, end, size = 4, isReduce = false) {
	if (term == 0 && (!this.stack.length \|\| this.stack[this.stack.length - 1] < this.buffer.length + this.bufferBase)) {
	let cur = this, top = this.buffer.length;
	if (top == 0 && cur.parent) {
	top = cur.bufferBase - cur.parent.bufferBase;
	cur = cur.parent;
	}
	if (top > 0 && cur.buffer[top - 4] == 0 && cur.buffer[top - 1] > -1) {
	if (start == end)
	return;
	if (cur.buffer[top - 2] >= start) {
	cur.buffer[top - 2] = end;
	return;
	}
	}
	}
	if (!isReduce \|\| this.pos == end) {
	this.buffer.push(term, start, end, size);
	} else {
	let index = this.buffer.length;
	if (index > 0 && this.buffer[index - 4] != 0)
	while (index > 0 && this.buffer[index - 2] > end) {
	this.buffer[index] = this.buffer[index - 4];
	this.buffer[index + 1] = this.buffer[index - 3];
	this.buffer[index + 2] = this.buffer[index - 2];
	this.buffer[index + 3] = this.buffer[index - 1];
	index -= 4;
	if (size > 4)
	size -= 4;
	}
	this.buffer[index] = term;
	this.buffer[index + 1] = start;
	this.buffer[index + 2] = end;
	this.buffer[index + 3] = size;
	}
	}
	// Apply a shift action
	/**
	@internal
	*/
	shift(action, type, start, end) {
	if (action & 131072) {
	this.pushState(action & 65535, this.pos);
	} else if ((action & 262144) == 0) {
	let nextState = action, { parser: parser2 } = this.p;
	if (end > this.pos \|\| type <= parser2.maxNode) {
	this.pos = end;
	if (!parser2.stateFlag(
	nextState,
	1
	/* StateFlag.Skipped */
	))
	this.reducePos = end;
	}
	this.pushState(nextState, start);
	this.shiftContext(type, start);
	if (type <= parser2.maxNode)
	this.buffer.push(type, start, end, 4);
	} else {
	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, nextStart, nextEnd) {
	if (action & 65536)
	this.reduce(action);
	else
	this.shift(action, next, nextStart, nextEnd);
	}
	// Add a prebuilt (reused) node into the buffer.
	/**
	@internal
	*/
	useNode(value, next) {
	let index = this.p.reused.length - 1;
	if (index < 0 \|\| this.p.reused[index] != value) {
	this.p.reused.push(value);
	index++;
	}
	let start = this.pos;
	this.reducePos = this.pos = start + value.length;
	this.pushState(next, start);
	this.buffer.push(
	index,
	start,
	this.reducePos,
	-1
	/* size == -1 means this is a reused value */
	);
	if (this.curContext)
	this.updateContext(this.curContext.tracker.reuse(this.curContext.context, value, this, this.p.stream.reset(this.pos - value.length)));
	}
	// 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
	*/
	split() {
	let parent = this;
	let off = parent.buffer.length;
	while (off > 0 && parent.buffer[off - 2] > parent.reducePos)
	off -= 4;
	let buffer = parent.buffer.slice(off), base = parent.bufferBase + off;
	while (parent && base == parent.bufferBase)
	parent = parent.parent;
	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
	*/
	recoverByDelete(next, nextEnd) {
	let isNode = next <= this.p.parser.maxNode;
	if (isNode)
	this.storeNode(next, this.pos, nextEnd, 4);
	this.storeNode(0, this.pos, nextEnd, isNode ? 8 : 4);
	this.pos = this.reducePos = nextEnd;
	this.score -= 190;
	}
	/**
	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
	/* ParseState.DefaultReduce */
	) \|\| this.p.parser.hasAction(sim.state, term);
	if (action == 0)
	return false;
	if ((action & 65536) == 0)
	return true;
	sim.reduce(action);
	}
	}
	// Apply up to Recover.MaxNext recovery actions that conceptually
	// inserts some missing token or rule.
	/**
	@internal
	*/
	recoverByInsert(next) {
	if (this.stack.length >= 300)
	return [];
	let nextStates = this.p.parser.nextStates(this.state);
	if (nextStates.length > 4 << 1 \|\| this.stack.length >= 120) {
	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)
	for (let i = 0; best.length < 4 << 1 && i < nextStates.length; i += 2) {
	let s = nextStates[i + 1];
	if (!best.some((v, i2) => i2 & 1 && v == s))
	best.push(nextStates[i], s);
	}
	nextStates = best;
	}
	let result = [];
	for (let i = 0; i < nextStates.length && result.length < 4; i += 2) {
	let s = nextStates[i + 1];
	if (s == this.state)
	continue;
	let stack = this.split();
	stack.pushState(s, this.pos);
	stack.storeNode(0, stack.pos, stack.pos, 4, true);
	stack.shiftContext(nextStates[i], this.pos);
	stack.reducePos = this.pos;
	stack.score -= 200;
	result.push(stack);
	}
	return result;
	}
	// Force a reduce, if possible. Return false if that can't
	// be done.
	/**
	@internal
	*/
	forceReduce() {
	let { parser: parser2 } = this.p;
	let reduce = parser2.stateSlot(
	this.state,
	5
	/* ParseState.ForcedReduce */
	);
	if ((reduce & 65536) == 0)
	return false;
	if (!parser2.validAction(this.state, reduce)) {
	let depth = reduce >> 19, term = reduce & 65535;
	let target = this.stack.length - depth * 3;
	if (target < 0 \|\| parser2.getGoto(this.stack[target], term, false) < 0) {
	let backup = this.findForcedReduction();
	if (backup == null)
	return false;
	reduce = backup;
	}
	this.storeNode(0, this.pos, this.pos, 4, true);
	this.score -= 100;
	}
	this.reducePos = this.pos;
	this.reduce(reduce);
	return true;
	}
	/**
	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: parser2 } = this.p, seen = [];
	let explore = (state, depth) => {
	if (seen.includes(state))
	return;
	seen.push(state);
	return parser2.allActions(state, (action) => {
	if (action & (262144 \| 131072)) ;
	else if (action & 65536) {
	let rDepth = (action >> 19) - depth;
	if (rDepth > 1) {
	let term = action & 65535, target = this.stack.length - rDepth * 3;
	if (target >= 0 && parser2.getGoto(this.stack[target], term, false) >= 0)
	return rDepth << 19 \| 65536 \| 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
	/* StateFlag.Accepting */
	)) {
	if (!this.forceReduce()) {
	this.storeNode(0, 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
	*/
	get deadEnd() {
	if (this.stack.length != 3)
	return false;
	let { parser: parser2 } = this.p;
	return parser2.data[parser2.stateSlot(
	this.state,
	1
	/* ParseState.Actions */
	)] == 65535 && !parser2.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() {
	this.storeNode(0, 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)
	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 parser() {
	return this.p.parser;
	}
	/**
	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)
	this.updateContext(this.curContext.tracker.shift(this.curContext.context, term, this, this.p.stream.reset(start)));
	}
	reduceContext(term, start) {
	if (this.curContext)
	this.updateContext(this.curContext.tracker.reduce(this.curContext.context, term, this, this.p.stream.reset(start)));
	}
	/**
	@internal
	*/
	emitContext() {
	let last = this.buffer.length - 1;
	if (last < 0 \|\| this.buffer[last] != -3)
	this.buffer.push(this.curContext.hash, this.pos, this.pos, -3);
	}
	/**
	@internal
	*/
	emitLookAhead() {
	let last = this.buffer.length - 1;
	if (last < 0 \|\| this.buffer[last] != -4)
	this.buffer.push(this.lookAhead, this.pos, this.pos, -4);
	}
	updateContext(context) {
	if (context != this.curContext.context) {
	let newCx = new StackContext(this.curContext.tracker, context);
	if (newCx.hash != this.curContext.hash)
	this.emitContext();
	this.curContext = newCx;
	}
	}
	/**
	@internal
	*/
	setLookAhead(lookAhead) {
	if (lookAhead > this.lookAhead) {
	this.emitLookAhead();
	this.lookAhead = lookAhead;
	}
	}
	/**
	@internal
	*/
	close() {
	if (this.curContext && this.curContext.tracker.strict)
	this.emitContext();
	if (this.lookAhead > 0)
	this.emitLookAhead();
	}
	};
	var StackContext = class {
	constructor(tracker, context) {
	this.tracker = tracker;
	this.context = context;
	this.hash = tracker.strict ? tracker.hash(context) : 0;
	}
	};
	var SimulatedStack = class {
	constructor(start) {
	this.start = start;
	this.state = start.state;
	this.stack = start.stack;
	this.base = this.stack.length;
	}
	reduce(action) {
	let term = action & 65535, depth = action >> 19;
	if (depth == 0) {
	if (this.stack == this.start.stack)
	this.stack = this.stack.slice();
	this.stack.push(this.state, 0, 0);
	this.base += 3;
	} else {
	this.base -= (depth - 1) * 3;
	}
	let goto = this.start.p.parser.getGoto(this.stack[this.base - 3], term, true);
	this.state = goto;
	}
	};
	var StackBufferCursor = class _StackBufferCursor {
	constructor(stack, pos, index) {
	this.stack = stack;
	this.pos = pos;
	this.index = index;
	this.buffer = stack.buffer;
	if (this.index == 0)
	this.maybeNext();
	}
	static create(stack, pos = stack.bufferBase + stack.buffer.length) {
	return new _StackBufferCursor(stack, pos, pos - stack.bufferBase);
	}
	maybeNext() {
	let next = this.stack.parent;
	if (next != null) {
	this.index = this.stack.bufferBase - next.bufferBase;
	this.stack = next;
	this.buffer = next.buffer;
	}
	}
	get id() {
	return this.buffer[this.index - 4];
	}
	get start() {
	return this.buffer[this.index - 3];
	}
	get end() {
	return this.buffer[this.index - 2];
	}
	get size() {
	return this.buffer[this.index - 1];
	}
	next() {
	this.index -= 4;
	this.pos -= 4;
	if (this.index == 0)
	this.maybeNext();
	}
	fork() {
	return new _StackBufferCursor(this.stack, this.pos, this.index);
	}
	};
	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) {
	value = 65535;
	break;
	}
	if (next >= 92)
	next--;
	if (next >= 34)
	next--;
	let digit = next - 32;
	if (digit >= 46) {
	digit -= 46;
	stop = true;
	}
	value += digit;
	if (stop)
	break;
	value *= 46;
	}
	if (array)
	array[out++] = value;
	else
	array = new Type(value);
	}
	return array;
	}
	var CachedToken = class {
	constructor() {
	this.start = -1;
	this.value = -1;
	this.end = -1;
	this.extended = -1;
	this.lookAhead = 0;
	this.mask = 0;
	this.context = 0;
	}
	};
	var nullToken = new CachedToken();
	var InputStream = class {
	/**
	@internal
	*/
	constructor(input, ranges) {
	this.input = input;
	this.ranges = ranges;
	this.chunk = "";
	this.chunkOff = 0;
	this.chunk2 = "";
	this.chunk2Pos = 0;
	this.next = -1;
	this.token = nullToken;
	this.rangeIndex = 0;
	this.pos = this.chunkPos = ranges[0].from;
	this.range = ranges[0];
	this.end = ranges[ranges.length - 1].to;
	this.readNext();
	}
	/**
	@internal
	*/
	resolveOffset(offset, assoc) {
	let range = this.range, index = this.rangeIndex;
	let pos = this.pos + offset;
	while (pos < range.from) {
	if (!index)
	return null;
	let next = this.ranges[--index];
	pos -= range.from - next.to;
	range = next;
	}
	while (assoc < 0 ? pos > range.to : pos >= range.to) {
	if (index == this.ranges.length - 1)
	return null;
	let next = this.ranges[++index];
	pos += next.from - range.to;
	range = next;
	}
	return pos;
	}
	/**
	@internal
	*/
	clipPos(pos) {
	if (pos >= this.range.from && pos < this.range.to)
	return pos;
	for (let range of this.ranges)
	if (range.to > pos)
	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.
	*/
	peek(offset) {
	let idx = this.chunkOff + offset, pos, result;
	if (idx >= 0 && idx < this.chunk.length) {
	pos = this.pos + offset;
	result = this.chunk.charCodeAt(idx);
	} else {
	let resolved = this.resolveOffset(offset, 1);
	if (resolved == null)
	return -1;
	pos = resolved;
	if (pos >= this.chunk2Pos && pos < this.chunk2Pos + this.chunk2.length) {
	result = this.chunk2.charCodeAt(pos - this.chunk2Pos);
	} else {
	let i = this.rangeIndex, range = this.range;
	while (range.to <= pos)
	range = this.ranges[++i];
	this.chunk2 = this.input.chunk(this.chunk2Pos = pos);
	if (pos + this.chunk2.length > range.to)
	this.chunk2 = this.chunk2.slice(0, range.to - pos);
	result = this.chunk2.charCodeAt(0);
	}
	}
	if (pos >= this.token.lookAhead)
	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.
	*/
	acceptToken(token, endOffset = 0) {
	let end = endOffset ? this.resolveOffset(endOffset, -1) : this.pos;
	if (end == null \|\| end < this.token.start)
	throw new RangeError("Token end out of bounds");
	this.token.value = token;
	this.token.end = end;
	}
	/**
	Accept a token ending at a specific given position.
	*/
	acceptTokenTo(token, endPos) {
	this.token.value = token;
	this.token.end = endPos;
	}
	getChunk() {
	if (this.pos >= this.chunk2Pos && this.pos < this.chunk2Pos + this.chunk2.length) {
	let { chunk, chunkPos } = this;
	this.chunk = this.chunk2;
	this.chunkPos = this.chunk2Pos;
	this.chunk2 = chunk;
	this.chunk2Pos = chunkPos;
	this.chunkOff = this.pos - this.chunkPos;
	} else {
	this.chunk2 = this.chunk;
	this.chunk2Pos = this.chunkPos;
	let nextChunk = this.input.chunk(this.pos);
	let end = this.pos + nextChunk.length;
	this.chunk = end > this.range.to ? nextChunk.slice(0, this.range.to - this.pos) : nextChunk;
	this.chunkPos = this.pos;
	this.chunkOff = 0;
	}
	}
	readNext() {
	if (this.chunkOff >= this.chunk.length) {
	this.getChunk();
	if (this.chunkOff == this.chunk.length)
	return this.next = -1;
	}
	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).
	*/
	advance(n = 1) {
	this.chunkOff += n;
	while (this.pos + n >= this.range.to) {
	if (this.rangeIndex == this.ranges.length - 1)
	return this.setDone();
	n -= this.range.to - this.pos;
	this.range = this.ranges[++this.rangeIndex];
	this.pos = this.range.from;
	}
	this.pos += n;
	if (this.pos >= this.token.lookAhead)
	this.token.lookAhead = this.pos + 1;
	return this.readNext();
	}
	setDone() {
	this.pos = this.chunkPos = this.end;
	this.range = this.ranges[this.rangeIndex = this.ranges.length - 1];
	this.chunk = "";
	return this.next = -1;
	}
	/**
	@internal
	*/
	reset(pos, token) {
	if (token) {
	this.token = token;
	token.start = pos;
	token.lookAhead = pos + 1;
	token.value = token.extended = -1;
	} else {
	this.token = nullToken;
	}
	if (this.pos != pos) {
	this.pos = pos;
	if (pos == this.end) {
	this.setDone();
	return this;
	}
	while (pos < this.range.from)
	this.range = this.ranges[--this.rangeIndex];
	while (pos >= this.range.to)
	this.range = this.ranges[++this.rangeIndex];
	if (pos >= this.chunkPos && pos < this.chunkPos + this.chunk.length) {
	this.chunkOff = pos - this.chunkPos;
	} else {
	this.chunk = "";
	this.chunkOff = 0;
	}
	this.readNext();
	}
	return this;
	}
	/**
	@internal
	*/
	read(from, to) {
	if (from >= this.chunkPos && to <= this.chunkPos + this.chunk.length)
	return this.chunk.slice(from - this.chunkPos, to - this.chunkPos);
	if (from >= this.chunk2Pos && to <= this.chunk2Pos + this.chunk2.length)
	return this.chunk2.slice(from - this.chunk2Pos, to - this.chunk2Pos);
	if (from >= this.range.from && to <= this.range.to)
	return this.input.read(from, to);
	let result = "";
	for (let r of this.ranges) {
	if (r.from >= to)
	break;
	if (r.to > from)
	result += this.input.read(Math.max(r.from, from), Math.min(r.to, to));
	}
	return result;
	}
	};
	var TokenGroup = class {
	constructor(data, id2) {
	this.data = data;
	this.id = id2;
	}
	token(input, stack) {
	let { parser: parser2 } = stack.p;
	readToken(this.data, input, stack, this.id, parser2.data, parser2.tokenPrecTable);
	}
	};
	TokenGroup.prototype.contextual = TokenGroup.prototype.fallback = TokenGroup.prototype.extend = false;
	var LocalTokenGroup = class {
	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;
	var ExternalTokenizer = class {
	/**
	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(token, options = {}) {
	this.token = token;
	this.contextual = !!options.contextual;
	this.fallback = !!options.fallback;
	this.extend = !!options.extend;
	}
	};
	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;
	let accEnd = data[state + 1];
	for (let i = state + 3; i < accEnd; i += 2)
	if ((data[i + 1] & groupMask) > 0) {
	let term = data[i];
	if (dialect.allows(term) && (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];
	if (input.next < 0 && high > low && data[accEnd + high * 3 - 3] == 65535) {
	state = data[accEnd + high * 3 - 1];
	continue scan;
	}
	for (; low < high; ) {
	let mid = low + high >> 1;
	let index = accEnd + mid + (mid << 1);
	let from = data[index], to = data[index + 1] \|\| 65536;
	if (next < from)
	high = mid;
	else if (next >= to)
	low = mid + 1;
	else {
	state = data[index + 2];
	input.advance();
	continue scan;
	}
	}
	break;
	}
	}
	function findOffset(data, start, term) {
	for (let i = start, next; (next = data[i]) != 65535; 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;
	}
	var verbose = typeof process != "undefined" && process.env && /\bparse\b/.test(process.env.LOG);
	var stackIDs = null;
	function cutAt(tree, pos, side) {
	let cursor = tree.cursor(IterMode.IncludeAnonymous);
	cursor.moveTo(pos);
	for (; ; ) {
	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
	/* Lookahead.Margin */
	)) : Math.min(tree.length, Math.max(
	cursor.from + 1,
	pos + 25
	/* Lookahead.Margin */
	));
	if (side < 0 ? cursor.prevSibling() : cursor.nextSibling())
	break;
	if (!cursor.parent())
	return side < 0 ? 0 : tree.length;
	}
	}
	}
	var FragmentCursor = class {
	constructor(fragments, nodeSet) {
	this.fragments = fragments;
	this.nodeSet = nodeSet;
	this.i = 0;
	this.fragment = null;
	this.safeFrom = -1;
	this.safeTo = -1;
	this.trees = [];
	this.start = [];
	this.index = [];
	this.nextFragment();
	}
	nextFragment() {
	let fr = this.fragment = this.i == this.fragments.length ? null : this.fragments[this.i++];
	if (fr) {
	this.safeFrom = fr.openStart ? cutAt(fr.tree, fr.from + fr.offset, 1) - fr.offset : fr.from;
	this.safeTo = fr.openEnd ? cutAt(fr.tree, fr.to + fr.offset, -1) - fr.offset : fr.to;
	while (this.trees.length) {
	this.trees.pop();
	this.start.pop();
	this.index.pop();
	}
	this.trees.push(fr.tree);
	this.start.push(-fr.offset);
	this.index.push(0);
	this.nextStart = this.safeFrom;
	} else {
	this.nextStart = 1e9;
	}
	}
	// `pos` must be >= any previously given `pos` for this cursor
	nodeAt(pos) {
	if (pos < this.nextStart)
	return null;
	while (this.fragment && this.safeTo <= pos)
	this.nextFragment();
	if (!this.fragment)
	return null;
	for (; ; ) {
	let last = this.trees.length - 1;
	if (last < 0) {
	this.nextFragment();
	return null;
	}
	let top = this.trees[last], index = this.index[last];
	if (index == top.children.length) {
	this.trees.pop();
	this.start.pop();
	this.index.pop();
	continue;
	}
	let next = top.children[index];
	let start = this.start[last] + top.positions[index];
	if (start > pos) {
	this.nextStart = start;
	return null;
	}
	if (next instanceof Tree) {
	if (start == pos) {
	if (start < this.safeFrom)
	return null;
	let end = start + next.length;
	if (end <= this.safeTo) {
	let lookAhead = next.prop(NodeProp.lookAhead);
	if (!lookAhead \|\| end + lookAhead < this.fragment.to)
	return next;
	}
	}
	this.index[last]++;
	if (start + next.length >= Math.max(this.safeFrom, pos)) {
	this.trees.push(next);
	this.start.push(start);
	this.index.push(0);
	}
	} else {
	this.index[last]++;
	this.nextStart = start + next.length;
	}
	}
	}
	};
	var TokenCache = class {
	constructor(parser2, stream) {
	this.stream = stream;
	this.tokens = [];
	this.mainToken = null;
	this.actions = [];
	this.tokens = parser2.tokenizers.map((_) => new CachedToken());
	}
	getActions(stack) {
	let actionIndex = 0;
	let main = null;
	let { parser: parser2 } = stack.p, { tokenizers } = parser2;
	let mask = parser2.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++) {
	if ((1 << i & mask) == 0)
	continue;
	let tokenizer = tokenizers[i], token = this.tokens[i];
	if (main && !tokenizer.fallback)
	continue;
	if (tokenizer.contextual \|\| token.start != stack.pos \|\| token.mask != mask \|\| token.context != context) {
	this.updateCachedToken(token, tokenizer, stack);
	token.mask = mask;
	token.context = context;
	}
	if (token.lookAhead > token.end + 25)
	lookAhead = Math.max(token.lookAhead, lookAhead);
	if (token.value != 0) {
	let startIndex = actionIndex;
	if (token.extended > -1)
	actionIndex = this.addActions(stack, token.extended, token.end, actionIndex);
	actionIndex = this.addActions(stack, token.value, token.end, actionIndex);
	if (!tokenizer.extend) {
	main = token;
	if (actionIndex > startIndex)
	break;
	}
	}
	}
	while (this.actions.length > actionIndex)
	this.actions.pop();
	if (lookAhead)
	stack.setLookAhead(lookAhead);
	if (!main && stack.pos == this.stream.end) {
	main = new CachedToken();
	main.value = stack.p.parser.eofTerm;
	main.start = main.end = stack.pos;
	actionIndex = this.addActions(stack, main.value, main.end, actionIndex);
	}
	this.mainToken = main;
	return this.actions;
	}
	getMainToken(stack) {
	if (this.mainToken)
	return this.mainToken;
	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;
	return main;
	}
	updateCachedToken(token, tokenizer, stack) {
	let start = this.stream.clipPos(stack.pos);
	tokenizer.token(this.stream.reset(start, token), stack);
	if (token.value > -1) {
	let { parser: parser2 } = stack.p;
	for (let i = 0; i < parser2.specialized.length; i++)
	if (parser2.specialized[i] == token.value) {
	let result = parser2.specializers[i](this.stream.read(token.start, token.end), stack);
	if (result >= 0 && stack.p.parser.dialect.allows(result >> 1)) {
	if ((result & 1) == 0)
	token.value = result >> 1;
	else
	token.extended = result >> 1;
	break;
	}
	}
	} else {
	token.value = 0;
	token.end = this.stream.clipPos(start + 1);
	}
	}
	putAction(action, token, end, index) {
	for (let i = 0; i < index; i += 3)
	if (this.actions[i] == action)
	return index;
	this.actions[index++] = action;
	this.actions[index++] = token;
	this.actions[index++] = end;
	return index;
	}
	addActions(stack, token, end, index) {
	let { state } = stack, { parser: parser2 } = stack.p, { data } = parser2;
	for (let set = 0; set < 2; set++) {
	for (let i = parser2.stateSlot(
	state,
	set ? 2 : 1
	/* ParseState.Actions */
	); ; i += 3) {
	if (data[i] == 65535) {
	if (data[i + 1] == 1) {
	i = pair(data, i + 2);
	} else {
	if (index == 0 && data[i + 1] == 2)
	index = this.putAction(pair(data, i + 2), token, end, index);
	break;
	}
	}
	if (data[i] == token)
	index = this.putAction(pair(data, i + 1), token, end, index);
	}
	}
	return index;
	}
	};
	var Parse = class {
	constructor(parser2, input, fragments, ranges) {
	this.parser = parser2;
	this.input = input;
	this.ranges = ranges;
	this.recovering = 0;
	this.nextStackID = 9812;
	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(parser2, this.stream);
	this.topTerm = parser2.top[1];
	let { from } = ranges[0];
	this.stacks = [Stack.start(this, parser2.top[0], from)];
	this.fragments = fragments.length && this.stream.end - from > parser2.bufferLength * 4 ? new FragmentCursor(fragments, parser2.nodeSet) : null;
	}
	get parsedPos() {
	return this.minStackPos;
	}
	// Move the parser forward. This will process all parse stacks at
	// `this.pos` and try to advance them to a further position. If no
	// stack for such a position is found, it'll start error-recovery.
	//
	// When the parse is finished, this will return a syntax tree. When
	// not, it returns `null`.
	advance() {
	let stacks = this.stacks, pos = this.minStackPos;
	let newStacks = this.stacks = [];
	let stopped, stoppedTokens;
	if (this.bigReductionCount > 300 && 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;
	}
	for (let i = 0; i < stacks.length; i++) {
	let stack = stacks[i];
	for (; ; ) {
	this.tokens.mainToken = null;
	if (stack.pos > pos) {
	newStacks.push(stack);
	} else if (this.advanceStack(stack, newStacks, stacks)) {
	continue;
	} else {
	if (!stopped) {
	stopped = [];
	stoppedTokens = [];
	}
	stopped.push(stack);
	let tok = this.tokens.getMainToken(stack);
	stoppedTokens.push(tok.value, tok.end);
	}
	break;
	}
	}
	if (!newStacks.length) {
	let finished = stopped && findFinished(stopped);
	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;
	}
	if (this.recovering && stopped) {
	let finished = this.stoppedAt != null && stopped[0].pos > this.stoppedAt ? stopped[0] : this.runRecovery(stopped, stoppedTokens, newStacks);
	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;
	if (newStacks.length > maxRemaining) {
	newStacks.sort((a, b) => b.score - a.score);
	while (newStacks.length > maxRemaining)
	newStacks.pop();
	}
	if (newStacks.some((s) => s.reducePos > pos))
	this.recovering--;
	} else if (newStacks.length > 1) {
	outer: for (let i = 0; i < newStacks.length - 1; i++) {
	let stack = newStacks[i];
	for (let j = i + 1; j < newStacks.length; j++) {
	let other = newStacks[j];
	if (stack.sameState(other) \|\| stack.buffer.length > 500 && other.buffer.length > 500) {
	if ((stack.score - other.score \|\| stack.buffer.length - other.buffer.length) > 0) {
	newStacks.splice(j--, 1);
	} else {
	newStacks.splice(i--, 1);
	continue outer;
	}
	}
	}
	}
	if (newStacks.length > 12)
	newStacks.splice(
	12,
	newStacks.length - 12
	/* Rec.MaxStackCount */
	);
	}
	this.minStackPos = newStacks[0].pos;
	for (let i = 1; i < newStacks.length; i++)
	if (newStacks[i].pos < this.minStackPos)
	this.minStackPos = newStacks[i].pos;
	return null;
	}
	stopAt(pos) {
	if (this.stoppedAt != null && this.stoppedAt < pos)
	throw new RangeError("Can't move stoppedAt forward");
	this.stoppedAt = pos;
	}
	// Returns an updated version of the given stack, or null if the
	// stack can't advance normally. When `split` and `stacks` are
	// given, stacks split off by ambiguous operations will be pushed to
	// `split`, or added to `stacks` if they move `pos` forward.
	advanceStack(stack, stacks, split) {
	let start = stack.pos, { parser: parser2 } = this;
	let base = verbose ? this.stackID(stack) + " -> " : "";
	if (this.stoppedAt != null && start > this.stoppedAt)
	return stack.forceReduce() ? stack : null;
	if (this.fragments) {
	let strictCx = stack.curContext && stack.curContext.tracker.strict, cxHash = strictCx ? stack.curContext.hash : 0;
	for (let cached = this.fragments.nodeAt(start); cached; ) {
	let match = this.parser.nodeSet.types[cached.type.id] == cached.type ? parser2.getGoto(stack.state, cached.type.id) : -1;
	if (match > -1 && cached.length && (!strictCx \|\| (cached.prop(NodeProp.contextHash) \|\| 0) == cxHash)) {
	stack.useNode(cached, match);
	if (verbose)
	console.log(base + this.stackID(stack) + ` (via reuse of ${parser2.getName(cached.type.id)})`);
	return true;
	}
	if (!(cached instanceof Tree) \|\| cached.children.length == 0 \|\| cached.positions[0] > 0)
	break;
	let inner = cached.children[0];
	if (inner instanceof Tree && cached.positions[0] == 0)
	cached = inner;
	else
	break;
	}
	}
	let defaultReduce = parser2.stateSlot(
	stack.state,
	4
	/* ParseState.DefaultReduce */
	);
	if (defaultReduce > 0) {
	stack.reduce(defaultReduce);
	if (verbose)
	console.log(base + this.stackID(stack) + ` (via always-reduce ${parser2.getName(
	defaultReduce & 65535
	/* Action.ValueMask */
	)})`);
	return true;
	}
	if (stack.stack.length >= 8400) {
	while (stack.stack.length > 6e3 && 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();
	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) == 0 ? "shift" : `reduce of ${parser2.getName(
	action & 65535
	/* Action.ValueMask */
	)}`} for ${parser2.getName(term)} @ ${start}${localStack == stack ? "" : ", split"})`);
	if (last)
	return true;
	else if (localStack.pos > start)
	stacks.push(localStack);
	else
	split.push(localStack);
	}
	return false;
	}
	// Advance a given stack forward as far as it will go. Returns the
	// (possibly updated) stack if it got stuck, or null if it moved
	// forward and was given to `pushStackDedup`.
	advanceFully(stack, newStacks) {
	let pos = stack.pos;
	for (; ; ) {
	if (!this.advanceStack(stack, null, null))
	return false;
	if (stack.pos > pos) {
	pushStackDedup(stack, newStacks);
	return true;
	}
	}
	}
	runRecovery(stacks, tokens, newStacks) {
	let finished = null, restarted = false;
	for (let i = 0; i < stacks.length; i++) {
	let stack = stacks[i], token = tokens[i << 1], tokenEnd = tokens[(i << 1) + 1];
	let base = verbose ? this.stackID(stack) + " -> " : "";
	if (stack.deadEnd) {
	if (restarted)
	continue;
	restarted = true;
	stack.restart();
	if (verbose)
	console.log(base + this.stackID(stack) + " (restarted)");
	let done = this.advanceFully(stack, newStacks);
	if (done)
	continue;
	}
	let force = stack.split(), forceBase = base;
	for (let j = 0; force.forceReduce() && j < 10; j++) {
	if (verbose)
	console.log(forceBase + this.stackID(force) + " (via force-reduce)");
	let done = this.advanceFully(force, newStacks);
	if (done)
	break;
	if (verbose)
	forceBase = this.stackID(force) + " -> ";
	}
	for (let insert of stack.recoverByInsert(token)) {
	if (verbose)
	console.log(base + this.stackID(insert) + " (via recover-insert)");
	this.advanceFully(insert, newStacks);
	}
	if (this.stream.end > stack.pos) {
	if (tokenEnd == stack.pos) {
	tokenEnd++;
	token = 0;
	}
	stack.recoverByDelete(token, tokenEnd);
	if (verbose)
	console.log(base + this.stackID(stack) + ` (via recover-delete ${this.parser.getName(token)})`);
	pushStackDedup(stack, newStacks);
	} else if (!finished \|\| finished.score < stack.score) {
	finished = stack;
	}
	}
	return finished;
	}
	// Convert the stack's buffer to a syntax tree.
	stackToTree(stack) {
	stack.close();
	return Tree.build({
	buffer: StackBufferCursor.create(stack),
	nodeSet: this.parser.nodeSet,
	topID: this.topTerm,
	maxBufferLength: this.parser.bufferLength,
	reused: this.reused,
	start: this.ranges[0].from,
	length: stack.pos - this.ranges[0].from,
	minRepeatType: this.parser.minRepeatTerm
	});
	}
	stackID(stack) {
	let id2 = (stackIDs \|\| (stackIDs = /* @__PURE__ */ new WeakMap())).get(stack);
	if (!id2)
	stackIDs.set(stack, id2 = String.fromCodePoint(this.nextStackID++));
	return id2 + stack;
	}
	};
	function pushStackDedup(stack, newStacks) {
	for (let i = 0; i < newStacks.length; i++) {
	let other = newStacks[i];
	if (other.pos == stack.pos && other.sameState(stack)) {
	if (newStacks[i].score < stack.score)
	newStacks[i] = stack;
	return;
	}
	}
	newStacks.push(stack);
	}
	var Dialect = class {
	constructor(source, flags, disabled) {
	this.source = source;
	this.flags = flags;
	this.disabled = disabled;
	}
	allows(term) {
	return !this.disabled \|\| this.disabled[term] == 0;
	}
	};
	var id = (x) => x;
	var ContextTracker = class {
	/**
	Define a context tracker.
	*/
	constructor(spec) {
	this.start = spec.start;
	this.shift = spec.shift \|\| id;
	this.reduce = spec.reduce \|\| id;
	this.reuse = spec.reuse \|\| id;
	this.hash = spec.hash \|\| (() => 0);
	this.strict = spec.strict !== false;
	}
	};
	var LRParser = class _LRParser extends Parser {
	/**
	@internal
	*/
	constructor(spec) {
	super();
	this.wrappers = [];
	if (spec.version != 14)
	throw new RangeError(`Parser version (${spec.version}) doesn't match runtime version (${14})`);
	let nodeNames = spec.nodeNames.split(" ");
	this.minRepeatTerm = nodeNames.length;
	for (let i = 0; i < spec.repeatNodeCount; i++)
	nodeNames.push("");
	let topTerms = Object.keys(spec.topRules).map((r) => spec.topRules[r][1]);
	let nodeProps = [];
	for (let i = 0; i < nodeNames.length; i++)
	nodeProps.push([]);
	function setProp(nodeID, prop, value) {
	nodeProps[nodeID].push([prop, prop.deserialize(String(value))]);
	}
	if (spec.nodeProps)
	for (let propSpec of spec.nodeProps) {
	let prop = propSpec[0];
	if (typeof prop == "string")
	prop = NodeProp[prop];
	for (let i = 1; i < propSpec.length; ) {
	let next = propSpec[i++];
	if (next >= 0) {
	setProp(next, prop, propSpec[i++]);
	} else {
	let value = propSpec[i + -next];
	for (let j = -next; j > 0; j--)
	setProp(propSpec[i++], prop, value);
	i++;
	}
	}
	}
	this.nodeSet = new NodeSet(nodeNames.map((name, i) => NodeType.define({
	name: i >= this.minRepeatTerm ? void 0 : name,
	id: i,
	props: nodeProps[i],
	top: topTerms.indexOf(i) > -1,
	error: i == 0,
	skipped: spec.skippedNodes && spec.skippedNodes.indexOf(i) > -1
	})));
	if (spec.propSources)
	this.nodeSet = this.nodeSet.extend(...spec.propSources);
	this.strict = false;
	this.bufferLength = DefaultBufferLength;
	let tokenArray = decodeArray(spec.tokenData);
	this.context = spec.context;
	this.specializerSpecs = spec.specialized \|\| [];
	this.specialized = new Uint16Array(this.specializerSpecs.length);
	for (let i = 0; i < this.specializerSpecs.length; i++)
	this.specialized[i] = this.specializerSpecs[i].term;
	this.specializers = this.specializerSpecs.map(getSpecializer);
	this.states = decodeArray(spec.states, Uint32Array);
	this.data = decodeArray(spec.stateData);
	this.goto = decodeArray(spec.goto);
	this.maxTerm = spec.maxTerm;
	this.tokenizers = spec.tokenizers.map((value) => typeof value == "number" ? new TokenGroup(tokenArray, value) : value);
	this.topRules = spec.topRules;
	this.dialects = spec.dialects \|\| {};
	this.dynamicPrecedences = spec.dynamicPrecedences \|\| null;
	this.tokenPrecTable = spec.tokenPrec;
	this.termNames = spec.termNames \|\| null;
	this.maxNode = this.nodeSet.types.length - 1;
	this.dialect = this.parseDialect();
	this.top = this.topRules[Object.keys(this.topRules)[0]];
	}
	createParse(input, fragments, ranges) {
	let parse = new Parse(this, input, fragments, ranges);
	for (let w of this.wrappers)
	parse = w(parse, input, fragments, ranges);
	return parse;
	}
	/**
	Get a goto table entry @internal
	*/
	getGoto(state, term, loose = false) {
	let table = this.goto;
	if (term >= table[0])
	return -1;
	for (let pos = table[term + 1]; ; ) {
	let groupTag = table[pos++], last = groupTag & 1;
	let target = table[pos++];
	if (last && loose)
	return target;
	for (let end = pos + (groupTag >> 1); pos < end; pos++)
	if (table[pos] == state)
	return target;
	if (last)
	return -1;
	}
	}
	/**
	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 : 1
	/* ParseState.Actions */
	), next; ; i += 3) {
	if ((next = data[i]) == 65535) {
	if (data[i + 1] == 1)
	next = data[i = pair(data, i + 2)];
	else if (data[i + 1] == 2)
	return pair(data, i + 2);
	else
	break;
	}
	if (next == terminal \|\| next == 0)
	return pair(data, i + 1);
	}
	}
	return 0;
	}
	/**
	@internal
	*/
	stateSlot(state, slot) {
	return this.states[state * 6 + slot];
	}
	/**
	@internal
	*/
	stateFlag(state, flag) {
	return (this.stateSlot(
	state,
	0
	/* ParseState.Flags */
	) & flag) > 0;
	}
	/**
	@internal
	*/
	validAction(state, action) {
	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) : void 0;
	for (let i = this.stateSlot(
	state,
	1
	/* ParseState.Actions */
	); result == null; i += 3) {
	if (this.data[i] == 65535) {
	if (this.data[i + 1] == 1)
	i = pair(this.data, i + 2);
	else
	break;
	}
	result = action(pair(this.data, i + 1));
	}
	return result;
	}
	/**
	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
	/* ParseState.Actions */
	); ; i += 3) {
	if (this.data[i] == 65535) {
	if (this.data[i + 1] == 1)
	i = pair(this.data, i + 2);
	else
	break;
	}
	if ((this.data[i + 2] & 65536 >> 16) == 0) {
	let value = this.data[i + 1];
	if (!result.some((v, i2) => i2 & 1 && v == value))
	result.push(this.data[i], value);
	}
	}
	return result;
	}
	/**
	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) {
	let copy = Object.assign(Object.create(_LRParser.prototype), this);
	if (config.props)
	copy.nodeSet = this.nodeSet.extend(...config.props);
	if (config.top) {
	let info = this.topRules[config.top];
	if (!info)
	throw new RangeError(`Invalid top rule name ${config.top}`);
	copy.top = info;
	}
	if (config.tokenizers)
	copy.tokenizers = this.tokenizers.map((t) => {
	let found = config.tokenizers.find((r) => r.from == t);
	return found ? found.to : t;
	});
	if (config.specializers) {
	copy.specializers = this.specializers.slice();
	copy.specializerSpecs = this.specializerSpecs.map((s, i) => {
	let found = config.specializers.find((r) => r.from == s.external);
	if (!found)
	return s;
	let spec = Object.assign(Object.assign({}, s), { external: found.to });
	copy.specializers[i] = getSpecializer(spec);
	return spec;
	});
	}
	if (config.contextTracker)
	copy.context = config.contextTracker;
	if (config.dialect)
	copy.dialect = this.parseDialect(config.dialect);
	if (config.strict != null)
	copy.strict = config.strict;
	if (config.wrap)
	copy.wrappers = copy.wrappers.concat(config.wrap);
	if (config.bufferLength != null)
	copy.bufferLength = config.bufferLength;
	return copy;
	}
	/**
	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.
	*/
	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
	*/
	get eofTerm() {
	return this.maxNode + 1;
	}
	/**
	The type of top node produced by the parser.
	*/
	get topNode() {
	return this.nodeSet.types[this.top[1]];
	}
	/**
	@internal
	*/
	dynamicPrecedence(term) {
	let prec = this.dynamicPrecedences;
	return prec == null ? 0 : prec[term] \|\| 0;
	}
	/**
	@internal
	*/
	parseDialect(dialect) {
	let values = Object.keys(this.dialects), flags = values.map(() => false);
	if (dialect)
	for (let part of dialect.split(" ")) {
	let id2 = values.indexOf(part);
	if (id2 >= 0)
	flags[id2] = true;
	}
	let disabled = null;
	for (let i = 0; i < values.length; i++)
	if (!flags[i]) {
	for (let j = this.dialects[values[i]], id2; (id2 = this.data[j++]) != 65535; )
	(disabled \|\| (disabled = new Uint8Array(this.maxTerm + 1)))[id2] = 1;
	}
	return new Dialect(dialect, flags, disabled);
	}
	/**
	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 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
	/* StateFlag.Accepting */
	) && (!best \|\| best.score < stack.score))
	best = stack;
	}
	return best;
	}
	function getSpecializer(spec) {
	if (spec.external) {
	let mask = spec.extend ? 1 : 0;
	return (value, stack) => spec.external(value, stack) << 1 \| mask;
	}
	return spec.get;
	}

	// node_modules/@lezer/python/dist/index.js
	var printKeyword = 1;
	var indent = 194;
	var dedent = 195;
	var newline$1 = 196;
	var blankLineStart = 197;
	var newlineBracketed = 198;
	var eof = 199;
	var stringContent = 200;
	var Escape = 2;
	var replacementStart = 3;
	var stringEnd = 201;
	var ParenL = 24;
	var ParenthesizedExpression = 25;
	var TupleExpression = 49;
	var ComprehensionExpression = 50;
	var BracketL = 55;
	var ArrayExpression = 56;
	var ArrayComprehensionExpression = 57;
	var BraceL = 59;
	var DictionaryExpression = 60;
	var DictionaryComprehensionExpression = 61;
	var SetExpression = 62;
	var SetComprehensionExpression = 63;
	var ArgList = 65;
	var subscript = 238;
	var String$1 = 71;
	var stringStart = 241;
	var stringStartD = 242;
	var stringStartL = 243;
	var stringStartLD = 244;
	var stringStartR = 245;
	var stringStartRD = 246;
	var stringStartRL = 247;
	var stringStartRLD = 248;
	var FormatString = 72;
	var stringStartF = 249;
	var stringStartFD = 250;
	var stringStartFL = 251;
	var stringStartFLD = 252;
	var stringStartFR = 253;
	var stringStartFRD = 254;
	var stringStartFRL = 255;
	var stringStartFRLD = 256;
	var FormatReplacement = 73;
	var nestedFormatReplacement = 77;
	var importList = 263;
	var TypeParamList = 112;
	var ParamList = 130;
	var SequencePattern = 151;
	var MappingPattern = 152;
	var PatternArgList = 155;
	var newline = 10;
	var carriageReturn = 13;
	var space = 32;
	var tab = 9;
	var hash = 35;
	var parenOpen = 40;
	var dot = 46;
	var braceOpen = 123;
	var braceClose = 125;
	var singleQuote = 39;
	var doubleQuote = 34;
	var backslash = 92;
	var letter_o = 111;
	var letter_x = 120;
	var letter_N = 78;
	var letter_u = 117;
	var letter_U = 85;
	var bracketed = /* @__PURE__ */ new Set([
	ParenthesizedExpression,
	TupleExpression,
	ComprehensionExpression,
	importList,
	ArgList,
	ParamList,
	ArrayExpression,
	ArrayComprehensionExpression,
	subscript,
	SetExpression,
	SetComprehensionExpression,
	FormatString,
	FormatReplacement,
	nestedFormatReplacement,
	DictionaryExpression,
	DictionaryComprehensionExpression,
	SequencePattern,
	MappingPattern,
	PatternArgList,
	TypeParamList
	]);
	function isLineBreak(ch) {
	return ch == newline \|\| ch == carriageReturn;
	}
	function isHex(ch) {
	return ch >= 48 && ch <= 57 \|\| ch >= 65 && ch <= 70 \|\| ch >= 97 && ch <= 102;
	}
	var newlines = new ExternalTokenizer((input, stack) => {
	let prev;
	if (input.next < 0) {
	input.acceptToken(eof);
	} else if (stack.context.flags & cx_Bracketed) {
	if (isLineBreak(input.next)) input.acceptToken(newlineBracketed, 1);
	} else if (((prev = input.peek(-1)) < 0 \|\| isLineBreak(prev)) && stack.canShift(blankLineStart)) {
	let spaces = 0;
	while (input.next == space \|\| input.next == tab) {
	input.advance();
	spaces++;
	}
	if (input.next == newline \|\| input.next == carriageReturn \|\| input.next == hash)
	input.acceptToken(blankLineStart, -spaces);
	} else if (isLineBreak(input.next)) {
	input.acceptToken(newline$1, 1);
	}
	}, { contextual: true });
	var indentation = new ExternalTokenizer((input, stack) => {
	let context = stack.context;
	if (context.flags) return;
	let prev = input.peek(-1);
	if (prev == newline \|\| prev == carriageReturn) {
	let depth = 0, chars = 0;
	for (; ; ) {
	if (input.next == space) depth++;
	else if (input.next == tab) depth += 8 - depth % 8;
	else break;
	input.advance();
	chars++;
	}
	if (depth != context.indent && input.next != newline && input.next != carriageReturn && input.next != hash) {
	if (depth < context.indent) input.acceptToken(dedent, -chars);
	else input.acceptToken(indent);
	}
	}
	});
	var cx_Bracketed = 1;
	var cx_String = 2;
	var cx_DoubleQuote = 4;
	var cx_Long = 8;
	var cx_Raw = 16;
	var cx_Format = 32;
	function Context(parent, indent2, flags) {
	this.parent = parent;
	this.indent = indent2;
	this.flags = flags;
	this.hash = (parent ? parent.hash + parent.hash << 8 : 0) + indent2 + (indent2 << 4) + flags + (flags << 6);
	}
	var topIndent = new Context(null, 0, 0);
	function countIndent(space2) {
	let depth = 0;
	for (let i = 0; i < space2.length; i++)
	depth += space2.charCodeAt(i) == tab ? 8 - depth % 8 : 1;
	return depth;
	}
	var stringFlags = new Map([
	[stringStart, 0],
	[stringStartD, cx_DoubleQuote],
	[stringStartL, cx_Long],
	[stringStartLD, cx_Long \| cx_DoubleQuote],
	[stringStartR, cx_Raw],
	[stringStartRD, cx_Raw \| cx_DoubleQuote],
	[stringStartRL, cx_Raw \| cx_Long],
	[stringStartRLD, cx_Raw \| cx_Long \| cx_DoubleQuote],
	[stringStartF, cx_Format],
	[stringStartFD, cx_Format \| cx_DoubleQuote],
	[stringStartFL, cx_Format \| cx_Long],
	[stringStartFLD, cx_Format \| cx_Long \| cx_DoubleQuote],
	[stringStartFR, cx_Format \| cx_Raw],
	[stringStartFRD, cx_Format \| cx_Raw \| cx_DoubleQuote],
	[stringStartFRL, cx_Format \| cx_Raw \| cx_Long],
	[stringStartFRLD, cx_Format \| cx_Raw \| cx_Long \| cx_DoubleQuote]
	].map(([term, flags]) => [term, flags \| cx_String]));
	var trackIndent = new ContextTracker({
	start: topIndent,
	reduce(context, term, _, input) {
	if (context.flags & cx_Bracketed && bracketed.has(term) \|\| (term == String$1 \|\| term == FormatString) && context.flags & cx_String)
	return context.parent;
	return context;
	},
	shift(context, term, stack, input) {
	if (term == indent)
	return new Context(context, countIndent(input.read(input.pos, stack.pos)), 0);
	if (term == dedent)
	return context.parent;
	if (term == ParenL \|\| term == BracketL \|\| term == BraceL \|\| term == replacementStart)
	return new Context(context, 0, cx_Bracketed);
	if (stringFlags.has(term))
	return new Context(context, 0, stringFlags.get(term) \| context.flags & cx_Bracketed);
	return context;
	},
	hash(context) {
	return context.hash;
	}
	});
	var legacyPrint = new ExternalTokenizer((input) => {
	for (let i = 0; i < 5; i++) {
	if (input.next != "print".charCodeAt(i)) return;
	input.advance();
	}
	if (/\w/.test(String.fromCharCode(input.next))) return;
	for (let off = 0; ; off++) {
	let next = input.peek(off);
	if (next == space \|\| next == tab) continue;
	if (next != parenOpen && next != dot && next != newline && next != carriageReturn && next != hash)
	input.acceptToken(printKeyword);
	return;
	}
	});
	var strings = new ExternalTokenizer((input, stack) => {
	let { flags } = stack.context;
	let quote = flags & cx_DoubleQuote ? doubleQuote : singleQuote;
	let long = (flags & cx_Long) > 0;
	let escapes = !(flags & cx_Raw);
	let format = (flags & cx_Format) > 0;
	let start = input.pos;
	for (; ; ) {
	if (input.next < 0) {
	break;
	} else if (format && input.next == braceOpen) {
	if (input.peek(1) == braceOpen) {
	input.advance(2);
	} else {
	if (input.pos == start) {
	input.acceptToken(replacementStart, 1);
	return;
	}
	break;
	}
	} else if (escapes && input.next == backslash) {
	if (input.pos == start) {
	input.advance();
	let escaped = input.next;
	if (escaped >= 0) {
	input.advance();
	skipEscape(input, escaped);
	}
	input.acceptToken(Escape);
	return;
	}
	break;
	} else if (input.next == quote && (!long \|\| input.peek(1) == quote && input.peek(2) == quote)) {
	if (input.pos == start) {
	input.acceptToken(stringEnd, long ? 3 : 1);
	return;
	}
	break;
	} else if (input.next == newline) {
	if (long) {
	input.advance();
	} else if (input.pos == start) {
	input.acceptToken(stringEnd);
	return;
	}
	break;
	} else {
	input.advance();
	}
	}
	if (input.pos > start) input.acceptToken(stringContent);
	});
	function skipEscape(input, ch) {
	if (ch == letter_o) {
	for (let i = 0; i < 2 && input.next >= 48 && input.next <= 55; i++) input.advance();
	} else if (ch == letter_x) {
	for (let i = 0; i < 2 && isHex(input.next); i++) input.advance();
	} else if (ch == letter_u) {
	for (let i = 0; i < 4 && isHex(input.next); i++) input.advance();
	} else if (ch == letter_U) {
	for (let i = 0; i < 8 && isHex(input.next); i++) input.advance();
	} else if (ch == letter_N) {
	if (input.next == braceOpen) {
	input.advance();
	while (input.next >= 0 && input.next != braceClose && input.next != singleQuote && input.next != doubleQuote && input.next != newline) input.advance();
	if (input.next == braceClose) input.advance();
	}
	}
	}
	var pythonHighlighting = styleTags({
	'async "" "*" FormatConversion FormatSpec': tags.modifier,
	"for while if elif else try except finally return raise break continue with pass assert await yield match case": tags.controlKeyword,
	"in not and or is del": tags.operatorKeyword,
	"from def class global nonlocal lambda": tags.definitionKeyword,
	import: tags.moduleKeyword,
	"with as print": tags.keyword,
	Boolean: tags.bool,
	None: tags.null,
	VariableName: tags.variableName,
	"CallExpression/VariableName": tags.function(tags.variableName),
	"FunctionDefinition/VariableName": tags.function(tags.definition(tags.variableName)),
	"ClassDefinition/VariableName": tags.definition(tags.className),
	PropertyName: tags.propertyName,
	"CallExpression/MemberExpression/PropertyName": tags.function(tags.propertyName),
	Comment: tags.lineComment,
	Number: tags.number,
	String: tags.string,
	FormatString: tags.special(tags.string),
	Escape: tags.escape,
	UpdateOp: tags.updateOperator,
	"ArithOp!": tags.arithmeticOperator,
	BitOp: tags.bitwiseOperator,
	CompareOp: tags.compareOperator,
	AssignOp: tags.definitionOperator,
	Ellipsis: tags.punctuation,
	At: tags.meta,
	"( )": tags.paren,
	"[ ]": tags.squareBracket,
	"{ }": tags.brace,
	".": tags.derefOperator,
	", ;": tags.separator
	});
	var spec_identifier = { __proto__: null, await: 44, or: 54, and: 56, in: 60, not: 62, is: 64, if: 70, else: 72, lambda: 76, yield: 94, from: 96, async: 102, for: 104, None: 162, True: 164, False: 164, del: 178, pass: 182, break: 186, continue: 190, return: 194, raise: 202, import: 206, as: 208, global: 212, nonlocal: 214, assert: 218, type: 223, elif: 236, while: 240, try: 246, except: 248, finally: 250, with: 254, def: 258, class: 268, match: 279, case: 285 };
	var parser = LRParser.deserialize({
	version: 14,
	states: "##jO`QeOOP$}OSOOO&WQtO'#HUOOQS'#Co'#CoOOQS'#Cp'#CpO'vQdO'#CnOUQtO'#HTOOQS'#HU'#HUOOQS'#DU'#DUOOQS'#HT'#HTOrQdO'#D_O+VQdO'#DfO+gQdO'#DjO+zOWO'#DuO,VOWO'#DvO.[QtO'#GuOOQS'#Gu'#GuO'vQdO'#GtO0ZQtO'#GtOOQS'#Eb'#EbO0rQdO'#EcOOQS'#Gs'#GsO0\|QdO'#GrOOQV'#Gr'#GrO1XQdO'#FYOOQS'#G^'#G^O1^QdO'#FXOOQV'#IS'#ISOOQV'#Gq'#GqOOQV'#Fq'#FqQ`QeOOO'vQdO'#CqO1lQdO'#C}O1sQdO'#DRO2RQdO'#HYO2cQtO'#EVO'vQdO'#EWOOQS'#EY'#EYOOQS'#E['#E[OOQS'#E^'#E^O2wQdO'#E`O3_QdO'#EdO3rQdO'#EfO3zQtO'#EfO1XQdO'#EiO0rQdO'#ElO1XQdO'#EnO0rQdO'#EtO0rQdO'#EwO4VQdO'#EyO4^QdO'#FOO4iQdO'#EzO0rQdO'#FOO1XQdO'#FQO1XQdO'#FVO4nQdO'#F[P4uOdO'#GpPOOO)CBd)CBdOOQS'#Ce'#CeOOQS'#Cf'#CfOOQS'#Cg'#CgOOQS'#Ch'#ChOOQS'#Ci'#CiOOQS'#Cj'#CjOOQS'#Cl'#ClO'vQdO,59OO'vQdO,59OO'vQdO,59OO'vQdO,59OO'vQdO,59OO'vQdO,59OO5QQdO'#DoOOQS,5:Y,5:YO5eQdO'#HdOOQS,5:],5:]O5rQ!fO,5:]O5wQtO,59YO1lQdO,59bO1lQdO,59bO1lQdO,59bO8gQdO,59bO8lQdO,59bO8sQdO,59jO8zQdO'#HTO:QQdO'#HSOOQS'#HS'#HSOOQS'#D['#D[O:iQdO,59aO'vQdO,59aO:wQdO,59aOOQS,59y,59yO:\|QdO,5:RO'vQdO,5:ROOQS,5:Q,5:QO;[QdO,5:QO;aQdO,5:XO'vQdO,5:XO'vQdO,5:VOOQS,5:U,5:UO;rQdO,5:UO;wQdO,5:WOOOW'#Fy'#FyO;\|OWO,5:aOOQS,5:a,5:aO<XQdO'#HwOOOW'#Dw'#DwOOOW'#Fz'#FzO<iOWO,5:bOOQS,5:b,5:bOOQS'#F}'#F}O<wQtO,5:iO?iQtO,5=`O@SQ#xO,5=`O@sQtO,5=`OOQS,5:},5:}OA[QeO'#GWOBnQdO,5;^OOQV,5=^,5=^OByQtO'#IPOChQdO,5;tOOQS-E:[-E:[OOQV,5;s,5;sO4dQdO'#FQOOQV-E9o-E9oOCpQtO,59]OEwQtO,59iOFbQdO'#HVOFmQdO'#HVO1XQdO'#HVOFxQdO'#DTOGQQdO,59mOGVQdO'#HZO'vQdO'#HZO0rQdO,5=tOOQS,5=t,5=tO0rQdO'#EROOQS'#ES'#ESOGtQdO'#GPOHUQdO,58\|OHUQdO,58\|OxQdO,5:oOHdQtO'#H]OOQS,5:r,5:rOOQS,5:z,5:zOHwQdO,5;OOIYQdO'#IOO1XQdO'#H}OOQS,5;Q,5;QOOQS'#GT'#GTOInQtO,5;QOI\|QdO,5;QOJRQdO'#IQOOQS,5;T,5;TOJaQdO'#H\|OOQS,5;W,5;WOJrQdO,5;YO4iQdO,5;`O4iQdO,5;cOJzQtO'#ITO'vQdO'#ITOKUQdO,5;eO4VQdO,5;eO0rQdO,5;jO1XQdO,5;lOKZQeO'#EuOLgQgO,5;fO!!hQdO'#IUO4iQdO,5;jO!!sQdO,5;lO!!{QdO,5;qO!#WQtO,5;vO'vQdO,5;vPOOO,5=[,5=[P!#_OSO,5=[P!#dOdO,5=[O!&XQtO1G.jO!&`QtO1G.jO!)PQtO1G.jO!)ZQtO1G.jO!+tQtO1G.jO!,XQtO1G.jO!,lQdO'#HcO!,zQtO'#GuO0rQdO'#HcO!-UQdO'#HbOOQS,5:Z,5:ZO!-^QdO,5:ZO!-cQdO'#HeO!-nQdO'#HeO!.RQdO,5>OOOQS'#Ds'#DsOOQS1G/w1G/wOOQS1G.\|1G.\|O!/RQtO1G.\|O!/YQtO1G.\|O1lQdO1G.\|O!/uQdO1G/UOOQS'#DZ'#DZO0rQdO,59tOOQS1G.{1G.{O!/\|QdO1G/eO!0^QdO1G/eO!0fQdO1G/fO'vQdO'#H[O!0kQdO'#H[O!0pQtO1G.{O!1QQdO,59iO!2WQdO,5=zO!2hQdO,5=zO!2pQdO1G/mO!2uQtO1G/mOOQS1G/l1G/lO!3VQdO,5=uO!3\|QdO,5=uO0rQdO1G/qO!4kQdO1G/sO!4pQtO1G/sO!5QQtO1G/qOOQS1G/p1G/pOOQS1G/r1G/rOOOW-E9w-E9wOOQS1G/{1G/{O!5bQdO'#HxO0rQdO'#HxO!5sQdO,5>cOOOW-E9x-E9xOOQS1G/\|1G/\|OOQS-E9{-E9{O!6RQ#xO1G2zO!6rQtO1G2zO'vQdO,5<jOOQS,5<j,5<jOOQS-E9\|-E9\|OOQS,5<r,5<rOOQS-E:U-E:UOOQV1G0x1G0xO1XQdO'#GRO!7ZQtO,5>kOOQS1G1`1G1`O!7xQdO1G1`OOQS'#DV'#DVO0rQdO,5=qOOQS,5=q,5=qO!7}QdO'#FrO!8YQdO,59oO!8bQdO1G/XO!8lQtO,5=uOOQS1G3`1G3`OOQS,5:m,5:mO!9]QdO'#GtOOQS,5<k,5<kOOQS-E9}-E9}O!9nQdO1G.hOOQS1G0Z1G0ZO!9\|QdO,5=wO!:^QdO,5=wO0rQdO1G0jO0rQdO1G0jO!:oQdO,5>jO!;QQdO,5>jO1XQdO,5>jO!;cQdO,5>iOOQS-E:R-E:RO!;hQdO1G0lO!;sQdO1G0lO!;xQdO,5>lO!<WQdO,5>lO!<fQdO,5>hO!<\|QdO,5>hO!=_QdO'#EpO0rQdO1G0tO!=jQdO1G0tO!=oQgO1G0zO!AmQgO1G0}O!EhQdO,5>oO!ErQdO,5>oO!EzQtO,5>oO0rQdO1G1PO!FUQdO1G1PO4iQdO1G1UO!!sQdO1G1WOOQV,5;a,5;aO!FZQfO,5;aO!F`QgO1G1QO!JaQdO'#GZO4iQdO1G1QO4iQdO1G1QO!JqQdO,5>pO!KOQdO,5>pO1XQdO,5>pOOQV1G1U1G1UO!KWQdO'#FSO!KiQ!fO1G1WO!KqQdO1G1WOOQV1G1]1G1]O4iQdO1G1]O!KvQdO1G1]O!LOQdO'#F^OOQV1G1b1G1bO!#WQtO1G1bPOOO1G2v1G2vP!LTOSO1G2vOOQS,5=},5=}OOQS'#Dp'#DpO0rQdO,5=}O!LYQdO,5=\|O!LmQdO,5=\|OOQS1G/u1G/uO!LuQdO,5>PO!MVQdO,5>PO!M_QdO,5>PO!MrQdO,5>PO!NSQdO,5>POOQS1G3j1G3jOOQS7+$h7+$hO!8bQdO7+$pO# uQdO1G.\|O# \|QdO1G.\|OOQS1G/`1G/`OOQS,5<`,5<`O'vQdO,5<`OOQS7+%P7+%PO#!TQdO7+%POOQS-E9r-E9rOOQS7+%Q7+%QO#!eQdO,5=vO'vQdO,5=vOOQS7+$g7+$gO#!jQdO7+%PO#!rQdO7+%QO#!wQdO1G3fOOQS7+%X7+%XO##XQdO1G3fO##aQdO7+%XOOQS,5<_,5<_O'vQdO,5<_O##fQdO1G3aOOQS-E9q-E9qO#$]QdO7+%]OOQS7+%_7+%_O#$kQdO1G3aO#%YQdO7+%_O#%_QdO1G3gO#%oQdO1G3gO#%wQdO7+%]O#%\|QdO,5>dO#&gQdO,5>dO#&gQdO,5>dOOQS'#Dx'#DxO#&xO&jO'#DzO#'TO`O'#HyOOOW1G3}1G3}O#'YQdO1G3}O#'bQdO1G3}O#'mQ#xO7+(fO#(^QtO1G2UP#(wQdO'#GOOOQS,5<m,5<mOOQS-E:P-E:POOQS7+&z7+&zOOQS1G3]1G3]OOQS,5<^,5<^OOQS-E9p-E9pOOQS7+$s7+$sO#)UQdO,5=`O#)oQdO,5=`O#QQtO,5<aO#eQdO1G3cOOQS-E9s-E9sOOQS7+&U7+&UO#uQdO7+&UO#+TQdO,5<nO#+iQdO1G4UOOQS-E:Q-E:QO#+zQdO1G4UOOQS1G4T1G4TOOQS7+&W7+&WO#,]QdO7+&WOOQS,5<p,5<pO#,hQdO1G4WOOQS-E:S-E:SOOQS,5<l,5<lO#,vQdO1G4SOOQS-E:O-E:OO1XQdO'#EqO#-^QdO'#EqO#-iQdO'#IRO#-qQdO,5;[OOQS7+&`7+&`O0rQdO7+&`O#-vQgO7+&fO!JdQdO'#GXO4iQdO7+&fO4iQdO7+&iO#1tQtO,5<tO'vQdO,5<tO#2OQdO1G4ZOOQS-E:W-E:WO#2YQdO1G4ZO4iQdO7+&kO0rQdO7+&kOOQV7+&p7+&pO!KiQ!fO7+&rO!KqQdO7+&rO`QeO1G0{OOQV-E:X-E:XO4iQdO7+&lO4iQdO7+&lOOQV,5<u,5<uO#2bQdO,5<uO!JdQdO,5<uOOQV7+&l7+&lO#2mQgO7+&lO#6hQdO,5<vO#6sQdO1G4[OOQS-E:Y-E:YO#7QQdO1G4[O#7YQdO'#IWO#7hQdO'#IWO1XQdO'#IWOOQS'#IW'#IWO#7sQdO'#IVOOQS,5;n,5;nO#7{QdO,5;nO0rQdO'#FUOOQV7+&r7+&rO4iQdO7+&rOOQV7+&w7+&wO4iQdO7+&wO#8QQfO,5;xOOQV7+&\|7+&\|POOO7+(b7+(bO#8VQdO1G3iOOQS,5<c,5<cO#8eQdO1G3hOOQS-E9u-E9uO#8xQdO,5<dO#9TQdO,5<dO#9hQdO1G3kOOQS-E9v-E9vO#9xQdO1G3kO#:QQdO1G3kO#:bQdO1G3kO#9xQdO1G3kOOQS<<H[<<H[O#:mQtO1G1zOOQS<<Hk<<HkP#:zQdO'#FtO8sQdO1G3bO#;XQdO1G3bO#;^QdO<<HkOOQS<<Hl<<HlO#;nQdO7+)QOOQS<<Hs<<HsO#<OQtO1G1yP#<oQdO'#FsO#<\|QdO7+)RO#=^QdO7+)RO#=fQdO<<HwO#=kQdO7+({OOQS<<Hy<<HyO#>bQdO,5<bO'vQdO,5<bOOQS-E9t-E9tOOQS<<Hw<<HwOOQS,5<g,5<gO0rQdO,5<gO#>gQdO1G4OOOQS-E9y-E9yO#?QQdO1G4OO<XQdO'#H{OOOO'#D{'#D{OOOO'#F\|'#F\|O#?cO&jO,5:fOOOW,5>e,5>eOOOW7+)i7+)iO#?nQdO7+)iO#?vQdO1G2zO#@aQdO1G2zP'vQdO'#FuO0rQdO<<IpO1XQdO1G2YP1XQdO'#GSO#@rQdO7+)pO#ATQdO7+)pOOQS<<Ir<<IrP1XQdO'#GUP0rQdO'#GQOOQS,5;],5;]O#AfQdO,5>mO#AtQdO,5>mOOQS1G0v1G0vOOQS<<Iz<<IzOOQV-E:V-E:VO4iQdO<<JQOOQV,5<s,5<sO4iQdO,5<sOOQV<<JQ<<JQOOQV<<JT<<JTO#A\|QtO1G2`P#BWQdO'#GYO#B_QdO7+)uO#BiQgO<<JVO4iQdO<<JVOOQV<<J^<<J^O4iQdO<<J^O!KiQ!fO<<J^O#FdQgO7+&gOOQV<<JW<<JWO#FnQgO<<JWOOQV1G2a1G2aO1XQdO1G2aO#JiQdO1G2aO4iQdO<<JWO1XQdO1G2bP0rQdO'#G[O#JtQdO7+)vO#KRQdO7+)vOOQS'#FT'#FTO0rQdO,5>rO#KZQdO,5>rOOQS,5>r,5>rO#KfQdO,5>qO#KwQdO,5>qOOQS1G1Y1G1YOOQS,5;p,5;pOOQV<<Jc<<JcO#LPQdO1G1dOOQS7+)T7+)TP#LUQdO'#FwO#LfQdO1G2OO#LyQdO1G2OO#MZQdO1G2OP#MfQdO'#FxO#MsQdO7+)VO#NTQdO7+)VO#NTQdO7+)VO#N]QdO7+)VO#NmQdO7+(\|O8sQdO7+(\|OOQSAN>VAN>VO$ WQdO<<LmOOQSAN>cAN>cO0rQdO1G1\|O$ hQtO1G1\|P$ rQdO'#FvOOQS1G2R1G2RP$!PQdO'#F{O$!^QdO7+)jO$!wQdO,5>gOOOO-E9z-E9zOOOW<<MT<<MTO$#VQdO7+(fOOQSAN?[AN?[OOQS7+'t7+'tO$#pQdO<<M[OOQS,5<q,5<qO$$RQdO1G4XOOQS-E:T-E:TOOQVAN?lAN?lOOQV1G2_1G2_O4iQdOAN?qO$$aQgOAN?qOOQVAN?xAN?xO4iQdOAN?xOOQV<<JR<<JRO4iQdOAN?rO4iQdO7+'{OOQV7+'{7+'{O1XQdO7+'{OOQVAN?rAN?rOOQS7+'\|7+'\|O$([QdO<<MbOOQS1G4^1G4^O0rQdO1G4^OOQS,5<w,5<wO$(iQdO1G4]OOQS-E:Z-E:ZOOQU'#G_'#G_O$(zQfO7+'OO$)VQdO'#F_O$^QdO7+'jO$nQdO7+'jOOQS7+'j7+'jO$yQdO<<LqO$+ZQdO<<LqO$+ZQdO<<LqO$+cQdO'#H^OOQS<<Lh<<LhO$+mQdO<<LhOOQS7+'h7+'hOOQS'#D\|'#D\|OOOO1G4R1G4RO$,WQdO1G4RO$,`QdO1G4RP!=_QdO'#GVOOQVG25]G25]O4iQdOG25]OOQVG25dG25dOOQVG25^G25^OOQV<<Kg<<KgO4iQdO<<KgOOQS7+)x7+)xP$,kQdO'#G]OOQU-E:]-E:]OOQV<<Jj<<JjO$-_QtO'#FaOOQS'#Fc'#FcO$-oQdO'#FbO$.aQdO'#FbOOQS'#Fb'#FbO$.fQdO'#IYO$)VQdO'#FiO$)VQdO'#FiO$.}QdO'#FjO$)VQdO'#FkO$/UQdO'#IZOOQS'#IZ'#IZO$/sQdO,5;yOOQS<<KU<<KUO$/{QdO<<KUO$0]QdOANB]O$0mQdOANB]O$0uQdO'#H_OOQS'#H_'#H_O1sQdO'#DcO$1`QdO,5=xOOQSANBSANBSOOOO7+)m7+)mO$1wQdO7+)mOOQVLDwLD*wOOQVANARANARO5rQ!fO'#GaO$2PQtO,5<SO$)VQdO'#FmOOQS,5<W,5<WOOQS'#Fd'#FdO$2qQdO,5;\|O$2vQdO,5;\|OOQS'#Fg'#FgO$)VQdO'#G`O$3hQdO,5<QO$4SQdO,5>tO$4dQdO,5>tO1XQdO,5<PO$4uQdO,5<TO$4zQdO,5<TO$)VQdO'#I[O$5PQdO'#I[O$5UQdO,5<UOOQS,5<V,5<VO'vQdO'#FpOOQU1G1e1G1eO4iQdO1G1eOOQSAN@pAN@pO$5ZQdOG27wO$5kQdO,59}OOQS1G3d1G3dOOOO<<MX<<MXOOQS,5<{,5<{OOQS-E:_-E:_O$5pQtO'#FaO$5wQdO'#I]O$6VQdO'#I]O$6_QdO,5<XOOQS1G1h1G1hO$6dQdO1G1hO$6iQdO,5<zOOQS-E:^-E:^O$7TQdO,5=OO$7lQdO1G4`OOQS-E:b-E:bOOQS1G1k1G1kOOQS1G1o1G1oO$7\|QdO,5>vO$)VQdO,5>vOOQS1G1p1G1pO$8[QtO,5<[OOQU7+'P7+'PO$+cQdO1G/iO$)VQdO,5<YO$8cQdO,5>wO$8jQdO,5>wOOQS1G1s1G1sOOQS7+'S7+'SP$)VQdO'#GdO$8rQdO1G4bO$8\|QdO1G4bO$9UQdO1G4bOOQS7+%T7+%TO$9dQdO1G1tO$9rQtO'#FaO$9yQdO,5<}OOQS,5<},5<}O$:XQdO1G4cOOQS-E:a-E:aO$)VQdO,5<\|O$:`QdO,5<\|O$:eQdO7+)\|OOQS-E:`-E:`O$:oQdO7+)\|O$)VQdO,5<ZP$)VQdO'#GcO$:wQdO1G2hO$)VQdO1G2hP$;VQdO'#GbO$;^QdO<<MhO$;hQdO1G1uO$;vQdO7+(SO8sQdO'#C}O8sQdO,59bO8sQdO,59bO8sQdO,59bO$<UQtO,5=`O8sQdO1G.\|O0rQdO1G/XO0rQdO7+$pP$<iQdO'#GOO'vQdO'#GtO$<vQdO,59bO$<{QdO,59bO$=SQdO,59mO$=XQdO1G/UO1sQdO'#DRO8sQdO,59j",
	stateData: "$=r~O%cOS%^OSSOS%]PQ~OPdOVaOfoOhYOopOs!POvqO!PrO!Q{O!T!SO!U!RO!XZO!][O!h`O!r`O!s`O!t`O!{tO!}uO#PvO#RwO#TxO#XyO#ZzO#^\|O#_\|O#a}O#c!OO#l!QO#o!TO#s!UO#u!VO#z!WO#}hO$P!XO%oRO%pRO%tSO%uWO&Z]O&[]O&]]O&^]O&_]O&`]O&a]O&b]O&c^O&d^O&e^O&f^O&g^O&h^O&i^O&j^O~O%]!YO~OV!aO_!aOa!bOh!iO!X!kO!f!mO%j![O%k!]O%l!^O%m!_O%n!_O%o!`O%p!`O%q!aO%r!aO%s!aO~Ok%xXl%xXm%xXn%xXo%xXp%xXs%xXz%xX{%xX!x%xX#g%xX%[%xX%_%xX%z%xXg%xX!T%xX!U%xX%{%xX!W%xX![%xX!Q%xX#[%xXt%xX!m%xX~P%SOfoOhYO!XZO!][O!h`O!r`O!s`O!t`O%oRO%pRO%tSO%uWO&Z]O&[]O&]]O&^]O&_]O&`]O&a]O&b]O&c^O&d^O&e^O&f^O&g^O&h^O&i^O&j^O~Oz%wX{%wX#g%wX%[%wX%_%wX%z%wX~Ok!pOl!qOm!oOn!oOo!rOp!sOs!tO!x%wX~P)pOV!zOg!\|Oo0cOv0qO!PrO~P'vOV#OOo0cOv0qO!W#PO~P'vOV#SOa#TOo0cOv0qO![#UO~P'vOQ#XO%`#XO%a#ZO~OQ#^OR#[O%`#^O%a#`O~OV%iX_%iXa%iXh%iXk%iXl%iXm%iXn%iXo%iXp%iXs%iXz%iX!X%iX!f%iX%j%iX%k%iX%l%iX%m%iX%n%iX%o%iX%p%iX%q%iX%r%iX%s%iXg%iX!T%iX!U%iX~O&Z]O&[]O&]]O&^]O&_]O&`]O&a]O&b]O&c^O&d^O&e^O&f^O&g^O&h^O&i^O&j^O{%iX!x%iX#g%iX%[%iX%_%iX%z%iX%{%iX!W%iX![%iX!Q%iX#[%iXt%iX!m%iX~P,eOz#dO{%hX!x%hX#g%hX%[%hX%_%hX%z%hX~Oo0cOv0qO~P'vO#g#gO%[#iO%_#iO~O%uWO~O!T#nO#u!VO#z!WO#}hO~OopO~P'vOV#sOa#tO%uWO{wP~OV#xOo0cOv0qO!Q#yO~P'vO{#{O!x$QO%z#\|O#g!yX%[!yX%_!yX~OV#xOo0cOv0qO#g#SX%[#SX%_#SX~P'vOo0cOv0qO#g#WX%[#WX%_#WX~P'vOh$WO%uWO~O!f$YO!r$YO%uWO~OV$eO~P'vO!U$gO#s$hO#u$iO~O{$jO~OV$qO~P'vOS$sO%[$rO%c$tO~OV$}Oa$}Og%POo0cOv0qO~P'vOo0cOv0qO{%SO~P'vO&Y%UO~Oa!bOh!iO!X!kO!f!mOVba_bakbalbambanbaobapbasbazba{ba!xba#gba%[ba%_ba%jba%kba%lba%mba%nba%oba%pba%qba%rba%sba%zbagba!Tba!Uba%{ba!Wba![ba!Qba#[batba!mba~On%ZO~Oo%ZO~P'vOo0cO~P'vOk0eOl0fOm0dOn0dOo0mOp0nOs0rOg%wX!T%wX!U%wX%{%wX!W%wX![%wX!Q%wX#[%wX!m%wX~P)pO%{%]Og%vXz%vX!T%vX!U%vX!W%vX{%vX~Og%_Oz%`O!T%dO!U%cO~Og%_O~Oz%gO!T%dO!U%cO!W&SX~O!W%kO~Oz%lO{%nO!T%dO!U%cO![%}X~O![%rO~O![%sO~OQ#XO%`#XO%a%uO~OV%wOo0cOv0qO!PrO~P'vOQ#^OR#[O%`#^O%a%zO~OV!qa_!qaa!qah!qak!qal!qam!qan!qao!qap!qas!qaz!qa{!qa!X!qa!f!qa!x!qa#g!qa%[!qa%_!qa%j!qa%k!qa%l!qa%m!qa%n!qa%o!qa%p!qa%q!qa%r!qa%s!qa%z!qag!qa!T!qa!U!qa%{!qa!W!qa![!qa!Q!qa#[!qat!qa!m!qa~P#yOz%\|O{%ha!x%ha#g%ha%[%ha%_%ha%z%ha~P%SOV&OOopOvqO{%ha!x%ha#g%ha%[%ha%_%ha%z%ha~P'vOz%\|O{%ha!x%ha#g%ha%[%ha%_%ha%z%ha~OPdOVaOopOvqO!PrO!Q{O!{tO!}uO#PvO#RwO#TxO#XyO#ZzO#^\|O#_\|O#a}O#c!OO#g$zX%[$zX%_$zX~P'vO#g#gO%[&TO%_&TO~O!f&UOh&sX%[&sXz&sX#[&sX#g&sX%_&sX#Z&sXg&sX~Oh!iO%[&WO~Okealeameaneaoeapeaseazea{ea!xea#gea%[ea%_ea%zeagea!Tea!Uea%{ea!Wea![ea!Qea#[eatea!mea~P%SOsqazqa{qa#gqa%[qa%_qa%zqa~Ok!pOl!qOm!oOn!oOo!rOp!sO!xqa~PE`O%z&YOz%yX{%yX~O%uWOz%yX{%yX~Oz&]O{wX~O{&_O~Oz%lO#g%}X%[%}X%_%}Xg%}X{%}X![%}X!m%}X%z%}X~OV0lOo0cOv0qO!PrO~P'vO%z#\|O#gUa%[Ua%_Ua~Oz&hO#g&PX%[&PX%_&PXn&PX~P%SOz&kO!Q&jO#g#Wa%[#Wa%_#Wa~Oz&lO#[&nO#g&rX%[&rX%_&rXg&rX~O!f$YO!r$YO#Z&qO%uWO~O#Z&qO~Oz&sO#g&tX%[&tX%_&tX~Oz&uO#g&pX%[&pX%_&pX{&pX~O!X&wO%z&xO~Oz&\|On&wX~P%SOn'PO~OPdOVaOopOvqO!PrO!Q{O!{tO!}uO#PvO#RwO#TxO#XyO#ZzO#^\|O#_\|O#a}O#c!OO%['UO~P'vOt'YO#p'WO#q'XOP#naV#naf#nah#nao#nas#nav#na!P#na!Q#na!T#na!U#na!X#na!]#na!h#na!r#na!s#na!t#na!{#na!}#na#P#na#R#na#T#na#X#na#Z#na#^#na#_#na#a#na#c#na#l#na#o#na#s#na#u#na#z#na#}#na$P#na%X#na%o#na%p#na%t#na%u#na&Z#na&[#na&]#na&^#na&_#na&`#na&a#na&b#na&c#na&d#na&e#na&f#na&g#na&h#na&i#na&j#na%Z#na%_#na~Oz'ZO#[']O{&xX~Oh'_O!X&wO~Oh!iO{$jO!X&wO~O{'eO~P%SO%['hO~OS'iO%['hO~OV!aO_!aOa!bOh!iO!X!kO!f!mO%l!^O%m!_O%n!_O%o!`O%p!`O%q!aO%r!aO%s!aOkWilWimWinWioWipWisWizWi{Wi!xWi#gWi%[Wi%_Wi%jWi%zWigWi!TWi!UWi%{Wi!WWi![Wi!QWi#[WitWi!mWi~O%k!]O~P!#lO%kWi~P!#lOV!aO_!aOa!bOh!iO!X!kO!f!mO%o!`O%p!`O%q!aO%r!aO%s!aOkWilWimWinWioWipWisWizWi{Wi!xWi#gWi%[Wi%_Wi%jWi%kWi%lWi%zWigWi!TWi!UWi%{Wi!WWi![Wi!QWi#[WitWi!mWi~O%m!_O%n!_O~P!&gO%mWi%nWi~P!&gOa!bOh!iO!X!kO!f!mOkWilWimWinWioWipWisWizWi{Wi!xWi#gWi%[Wi%_Wi%jWi%kWi%lWi%mWi%nWi%oWi%pWi%zWigWi!TWi!UWi%{Wi!WWi![Wi!QWi#[WitWi!mWi~OV!aO_!aO%q!aO%r!aO%s!aO~P!)eOVWi_Wi%qWi%rWi%sWi~P!)eO!T%dO!U%cOg&VXz&VX~O%z'kO%{'kO~P,eOz'mOg&UX~Og'oO~Oz'pO{'rO!W&XX~Oo0cOv0qOz'pO{'sO!W&XX~P'vO!W'uO~Om!oOn!oOo!rOp!sOkjisjizji{ji!xji#gji%[ji%_ji%zji~Ol!qO~P!.WOlji~P!.WOk0eOl0fOm0dOn0dOo0mOp0nO~Ot'wO~P!/aOV'\|Og'}Oo0cOv0qO~P'vOg'}Oz(OO~Og(QO~O!U(SO~Og(TOz(OO!T%dO!U%cO~P%SOk0eOl0fOm0dOn0dOo0mOp0nOgqa!Tqa!Uqa%{qa!Wqa![qa!Qqa#[qatqa!mqa~PE`OV'\|Oo0cOv0qO!W&Sa~P'vOz(WO!W&Sa~O!W(XO~Oz(WO!T%dO!U%cO!W&Sa~P%SOV(]Oo0cOv0qO![%}a#g%}a%[%}a%_%}ag%}a{%}a!m%}a%z%}a~P'vOz(^O![%}a#g%}a%[%}a%_%}ag%}a{%}a!m%}a%z%}a~O![(aO~Oz(^O!T%dO!U%cO![%}a~P%SOz(dO!T%dO!U%cO![&Ta~P%SOz(gO{&lX![&lX!m&lX%z&lX~O{(kO![(mO!m(nO%z(jO~OV&OOopOvqO{%hi!x%hi#g%hi%[%hi%_%hi%z%hi~P'vOz(pO{%hi!x%hi#g%hi%[%hi%_%hi%z%hi~O!f&UOh&sa%[&saz&sa#[&sa#g&sa%_&sa#Z&sag&sa~O%[(uO~OV#sOa#tO%uWO~Oz&]O{wa~OopOvqO~P'vOz(^O#g%}a%[%}a%_%}ag%}a{%}a![%}a!m%}a%z%}a~P%SOz(zO#g%hX%[%hX%_%hX%z%hX~O%z#\|O#gUi%[Ui%_Ui~O#g&Pa%[&Pa%_&Pan&Pa~P'vOz(}O#g&Pa%[&Pa%_&Pan&Pa~O%uWO#g&ra%[&ra%_&rag&ra~Oz)SO#g&ra%[&ra%_&rag&ra~Og)VO~OV)WOh$WO%uWO~O#Z)XO~O%uWO#g&ta%[&ta%_&ta~Oz)ZO#g&ta%[&ta%_&ta~Oo0cOv0qO#g&pa%[&pa%_&pa{&pa~P'vOz)^O#g&pa%[&pa%_&pa{&pa~OV)`Oa)`O%uWO~O%z)eO~Ot)hO#j)gOP#hiV#hif#hih#hio#his#hiv#hi!P#hi!Q#hi!T#hi!U#hi!X#hi!]#hi!h#hi!r#hi!s#hi!t#hi!{#hi!}#hi#P#hi#R#hi#T#hi#X#hi#Z#hi#^#hi#_#hi#a#hi#c#hi#l#hi#o#hi#s#hi#u#hi#z#hi#}#hi$P#hi%X#hi%o#hi%p#hi%t#hi%u#hi&Z#hi&[#hi&]#hi&^#hi&_#hi&`#hi&a#hi&b#hi&c#hi&d#hi&e#hi&f#hi&g#hi&h#hi&i#hi&j#hi%Z#hi%_#hi~Ot)iOP#kiV#kif#kih#kio#kis#kiv#ki!P#ki!Q#ki!T#ki!U#ki!X#ki!]#ki!h#ki!r#ki!s#ki!t#ki!{#ki!}#ki#P#ki#R#ki#T#ki#X#ki#Z#ki#^#ki#_#ki#a#ki#c#ki#l#ki#o#ki#s#ki#u#ki#z#ki#}#ki$P#ki%X#ki%o#ki%p#ki%t#ki%u#ki&Z#ki&[#ki&]#ki&^#ki&_#ki&`#ki&a#ki&b#ki&c#ki&d#ki&e#ki&f#ki&g#ki&h#ki&i#ki&j#ki%Z#ki%_#ki~OV)kOn&wa~P'vOz)lOn&wa~Oz)lOn&wa~P%SOn)pO~O%Y)tO~Ot)wO#p'WO#q)vOP#niV#nif#nih#nio#nis#niv#ni!P#ni!Q#ni!T#ni!U#ni!X#ni!]#ni!h#ni!r#ni!s#ni!t#ni!{#ni!}#ni#P#ni#R#ni#T#ni#X#ni#Z#ni#^#ni#_#ni#a#ni#c#ni#l#ni#o#ni#s#ni#u#ni#z#ni#}#ni$P#ni%X#ni%o#ni%p#ni%t#ni%u#ni&Z#ni&[#ni&]#ni&^#ni&_#ni&`#ni&a#ni&b#ni&c#ni&d#ni&e#ni&f#ni&g#ni&h#ni&i#ni&j#ni%Z#ni%_#ni~OV)zOo0cOv0qO{$jO~P'vOo0cOv0qO{&xa~P'vOzOO{&xa~OVSOaTOgWO%qUO%uWO~O{$jO&{YO~Oh'_O~Oh!iO{$jO~O%[_O~O%[aO~OV$}Oa$}Oo0cOv0qOg&Ua~P'vOzdOg&Ua~Oo0cOv0qO{gO!W&Xa~P'vOzhO!W&Xa~Oo0cOv0qOzhO{kO!W&Xa~P'vOo0cOv0qOzhO!W&Xa~P'vOzhO{kO!W&Xa~Om0dOn0dOo0mOp0nOgjikjisjizji!Tji!Uji%{ji!Wji{ji![ji#gji%[ji%_ji!Qji#[jitji!mji%zji~Ol0fO~P!N_Olji~P!N_OV'\|OgpOo0cOv0qO~P'vOnrO~OgpOztO~OguO~OV'\|Oo0cOv0qO!W&Si~P'vOzvO!W&Si~O!WwO~OV(]Oo0cOv0qO![%}i#g%}i%[%}i%_%}ig%}i{%}i!m%}i%z%}i~P'vOzzO!T%dO!U%cO![&Ti~Oz}O![%}i#g%}i%[%}i%_%}ig%}i{%}i!m%}i%z%}i~O![+OO~Oa+QOo0cOv0qO![&Ti~P'vOzzO![&Ti~O![+SO~OV+UOo0cOv0qO{&la![&la!m&la%z&la~P'vOz+VO{&la![&la!m&la%z&la~O!]+YO&n+[O![!nX~O![+^O~O{(kO![+_O~O{(kO![+_O!m+`O~OV&OOopOvqO{%hq!x%hq#g%hq%[%hq%_%hq%z%hq~P'vOz$ri{$ri!x$ri#g$ri%[$ri%_$ri%z$ri~P%SOV&OOopOvqO~P'vOV&OOo0cOv0qO#g%ha%[%ha%_%ha%z%ha~P'vOz+aO#g%ha%[%ha%_%ha%z%ha~Oz$ia#g$ia%[$ia%_$ian$ia~P%SO#g&Pi%[&Pi%_&Pin&Pi~P'vOz+dO#g#Wq%[#Wq%_#Wq~O#[+eOz$va#g$va%[$va%_$vag$va~O%uWO#g&ri%[&ri%_&rig&ri~Oz+gO#g&ri%[&ri%_&rig&ri~OV+iOh$WO%uWO~O%uWO#g&ti%[&ti%_&ti~Oo0cOv0qO#g&pi%[&pi%_&pi{&pi~P'vO{#{Oz#eX!W#eX~Oz+mO!W&uX~O!W+oO~Ot+rO#j)gOP#hqV#hqf#hqh#hqo#hqs#hqv#hq!P#hq!Q#hq!T#hq!U#hq!X#hq!]#hq!h#hq!r#hq!s#hq!t#hq!{#hq!}#hq#P#hq#R#hq#T#hq#X#hq#Z#hq#^#hq#_#hq#a#hq#c#hq#l#hq#o#hq#s#hq#u#hq#z#hq#}#hq$P#hq%X#hq%o#hq%p#hq%t#hq%u#hq&Z#hq&[#hq&]#hq&^#hq&_#hq&`#hq&a#hq&b#hq&c#hq&d#hq&e#hq&f#hq&g#hq&h#hq&i#hq&j#hq%Z#hq%_#hq~On$\|az$\|a~P%SOV)kOn&wi~P'vOz+yOn&wi~Oz,TO{$jO#[,TO~O#q,VOP#nqV#nqf#nqh#nqo#nqs#nqv#nq!P#nq!Q#nq!T#nq!U#nq!X#nq!]#nq!h#nq!r#nq!s#nq!t#nq!{#nq!}#nq#P#nq#R#nq#T#nq#X#nq#Z#nq#^#nq#_#nq#a#nq#c#nq#l#nq#o#nq#s#nq#u#nq#z#nq#}#nq$P#nq%X#nq%o#nq%p#nq%t#nq%u#nq&Z#nq&[#nq&]#nq&^#nq&_#nq&`#nq&a#nq&b#nq&c#nq&d#nq&e#nq&f#nq&g#nq&h#nq&i#nq&j#nq%Z#nq%_#nq~O#[,WOz%Oa{%Oa~Oo0cOv0qO{&xi~P'vOz,YO{&xi~O{#{O%z,[Og&zXz&zX~O%uWOg&zXz&zX~Oz,`Og&yX~Og,bO~O%Y,eO~O!T%dO!U%cOg&Viz&Vi~OV$}Oa$}Oo0cOv0qOg&Ui~P'vO{,hOz$la!W$la~Oo0cOv0qO{,iOz$la!W$la~P'vOo0cOv0qO{gO!W&Xi~P'vOz,lO!W&Xi~Oo0cOv0qOz,lO!W&Xi~P'vOz,lO{,oO!W&Xi~Og$hiz$hi!W$hi~P%SOV'\|Oo0cOv0qO~P'vOn,qO~OV'\|Og,rOo0cOv0qO~P'vOV'\|Oo0cOv0qO!W&Sq~P'vOz$gi![$gi#g$gi%[$gi%_$gig$gi{$gi!m$gi%z$gi~P%SOV(]Oo0cOv0qO~P'vOa+QOo0cOv0qO![&Tq~P'vOz,sO![&Tq~O![,tO~OV(]Oo0cOv0qO![%}q#g%}q%[%}q%_%}qg%}q{%}q!m%}q%z%}q~P'vO{,uO~OV+UOo0cOv0qO{&li![&li!m&li%z&li~P'vOz,zO{&li![&li!m&li%z&li~O!]+YO&n+[O![!na~O{(kO![,}O~OV&OOo0cOv0qO#g%hi%[%hi%_%hi%z%hi~P'vOz-OO#g%hi%[%hi%_%hi%z%hi~O%uWO#g&rq%[&rq%_&rqg&rq~Oz-RO#g&rq%[&rq%_&rqg&rq~OV)`Oa)`O%uWO!W&ua~Oz-TO!W&ua~On$\|iz$\|i~P%SOV)kO~P'vOV)kOn&wq~P'vOt-XOP#myV#myf#myh#myo#mys#myv#my!P#my!Q#my!T#my!U#my!X#my!]#my!h#my!r#my!s#my!t#my!{#my!}#my#P#my#R#my#T#my#X#my#Z#my#^#my#_#my#a#my#c#my#l#my#o#my#s#my#u#my#z#my#}#my$P#my%X#my%o#my%p#my%t#my%u#my&Z#my&[#my&]#my&^#my&_#my&`#my&a#my&b#my&c#my&d#my&e#my&f#my&g#my&h#my&i#my&j#my%Z#my%_#my~O%Z-]O%_-]O~P`O#q-^OP#nyV#nyf#nyh#nyo#nys#nyv#ny!P#ny!Q#ny!T#ny!U#ny!X#ny!]#ny!h#ny!r#ny!s#ny!t#ny!{#ny!}#ny#P#ny#R#ny#T#ny#X#ny#Z#ny#^#ny#_#ny#a#ny#c#ny#l#ny#o#ny#s#ny#u#ny#z#ny#}#ny$P#ny%X#ny%o#ny%p#ny%t#ny%u#ny&Z#ny&[#ny&]#ny&^#ny&_#ny&`#ny&a#ny&b#ny&c#ny&d#ny&e#ny&f#ny&g#ny&h#ny&i#ny&j#ny%Z#ny%_#ny~Oz-aO{$jO#[-aO~Oo0cOv0qO{&xq~P'vOz-dO{&xq~O%z,[Og&zaz&za~OVSOaTO%qUO%uWOg&ya~Oz-hOg&ya~O$S-lO~OV$}Oa$}Oo0cOv0qO~P'vOo0cOv0qO{-mOz$li!W$li~P'vOo0cOv0qOz$li!W$li~P'vO{-mOz$li!W$li~Oo0cOv0qO{gO~P'vOo0cOv0qO{gO!W&Xq~P'vOz-pO!W&Xq~Oo0cOv0qOz-pO!W&Xq~P'vOs-sO!T%dO!U%cOg&Oq!W&Oq![&Oqz&Oq~P!/aOa+QOo0cOv0qO![&Ty~P'vOz$ji![$ji~P%SOa+QOo0cOv0qO~P'vOV+UOo0cOv0qO~P'vOV+UOo0cOv0qO{&lq![&lq!m&lq%z&lq~P'vO{(kO![-xO!m-yO%z-wO~OV&OOo0cOv0qO#g%hq%[%hq%_%hq%z%hq~P'vO%uWO#g&ry%[&ry%_&ryg&ry~OV)`Oa)`O%uWO!W&ui~Ot-}OP#m!RV#m!Rf#m!Rh#m!Ro#m!Rs#m!Rv#m!R!P#m!R!Q#m!R!T#m!R!U#m!R!X#m!R!]#m!R!h#m!R!r#m!R!s#m!R!t#m!R!{#m!R!}#m!R#P#m!R#R#m!R#T#m!R#X#m!R#Z#m!R#^#m!R#_#m!R#a#m!R#c#m!R#l#m!R#o#m!R#s#m!R#u#m!R#z#m!R#}#m!R$P#m!R%X#m!R%o#m!R%p#m!R%t#m!R%u#m!R&Z#m!R&[#m!R&]#m!R&^#m!R&_#m!R&`#m!R&a#m!R&b#m!R&c#m!R&d#m!R&e#m!R&f#m!R&g#m!R&h#m!R&i#m!R&j#m!R%Z#m!R%_#m!R~Oo0cOv0qO{&xy~P'vOVSOaTO%qUO%uWOg&yi~O$S-lO%Z.VO%_.VO~OV.aOh._O!X.^O!].`O!h.YO!s.[O!t.[O%p.XO%uWO&Z]O&[]O&]]O&^]O&_]O&`]O&a]O&b]O~Oo0cOv0qOz$lq!W$lq~P'vO{.fOz$lq!W$lq~Oo0cOv0qO{gO!W&Xy~P'vOz.gO!W&Xy~Oo0cOv.kO~P'vOs-sO!T%dO!U%cOg&Oy!W&Oy![&Oyz&Oy~P!/aO{(kO![.nO~O{(kO![.nO!m.oO~OVSOaTO%qUO%uWO~Oh.tO!f.rOz$TX#[$TX%j$TXg$TX~Os$TX{$TX!W$TX![$TX~P$,yO%o.vO%p.vOs$UXz$UX{$UX#[$UX%j$UX!W$UXg$UX![$UX~O!h.xO~Oz.\|O#[/OO%j.yOs&\|X{&\|X!W&\|Xg&\|X~Oa/RO~P$)cOh.tOs&}Xz&}X{&}X#[&}X%j&}X!W&}Xg&}X![&}X~Os/VO{$jO~Oo0cOv0qOz$ly!W$ly~P'vOo0cOv0qO{gO!W&X!R~P'vOz/ZO!W&X!R~Og&RXs&RX!T&RX!U&RX!W&RX![&RXz&RX~P!/aOs-sO!T%dO!U%cOg&Qa!W&Qa![&Qaz&Qa~O{(kO![/^O~O!f.rOh$[as$[az$[a{$[a#[$[a%j$[a!W$[ag$[a![$[a~O!h/eO~O%o.vO%p.vOs$Uaz$Ua{$Ua#[$Ua%j$Ua!W$Uag$Ua![$Ua~O%j.yOs$Yaz$Ya{$Ya#[$Ya!W$Yag$Ya![$Ya~Os&\|a{&\|a!W&\|ag&\|a~P$)VOz/jOs&\|a{&\|a!W&\|ag&\|a~O!W/mO~Og/mO~O{/oO~O![/pO~Oo0cOv0qO{*gO!W&X!Z~P'vO{/sO~O%z/tO~P$,yOz/uO#[/OO%j.yOg'PX~Oz/uOg'PX~Og/wO~O!h/xO~O#[/OOs%Saz%Sa{%Sa%j%Sa!W%Sag%Sa![%Sa~O#[/OO%j.yOs%Waz%Wa{%Wa!W%Wag%Wa~Os&\|i{&\|i!W&\|ig&\|i~P$)VOz/zO#[/OO%j.yO!['Oa~O{$da~P%SOg'Pa~P$)VOz0SOg'Pa~Oa0UO!['Oi~P$)cOz0WO!['Oi~Oz0WO#[/OO%j.yO!['Oi~O#[/OO%j.yOg$biz$bi~O%z0ZO~P$,yO#[/OO%j.yOg%Vaz%Va~Og'Pi~P$)VO{0^O~Oa0UO!['Oq~P$)cOz0`O!['Oq~O#[/OO%j.yOz%Ui![%Ui~Oa0UO~P$)cOa0UO!['Oy~P$)cO#[/OO%j.yOg$ciz$ci~O#[/OO%j.yOz%Uq![%Uq~Oz+aO#g%ha%[%ha%_%ha%z%ha~P%SOV&OOo0cOv0qO~P'vOn0hO~Oo0hO~P'vO{0iO~Ot0jO~P!/aO&]&Z&j&h&i&g&f&d&e&c&b&`&a&_&^&[%u~",
	goto: "!=l'QPPPPPP'RP'Zs+]+v,b,}-kP.YP'Z.y.y'ZPPP'Z2cPPPPPP2c5VPP5VP7g7p=xPP={>m>pPP'Z'ZPP?PPP'Z'ZPP'Z'Z'Z'Z'Z?T?}'ZP@QP@WD_G{HPPHSH^Hb'ZPPPHeHn'RP'R'RP'RP'RP'RP'RP'R'R'RP'RPP'RPP'RP'RPHtIQIYPIaIgPIaPIaIaPPPIaPKuPLOLYL`KuPIaLiPIaPLpLvPLzM`M}NhLzLzNnN{LzLzLzLz! a! g! j! o! r! \|!!S!!`!!r!!x!#S!#Y!#v!#\|!$S!$^!$d!$j!$\|!%W!%^!%d!%n!%t!%z!&Q!&W!&^!&h!&n!&x!'O!'X!'_!'n!'v!(Q!(XPPPPPPPPPPP!(_!(b!(h!(q!({!)WPPPPPPPPPPPP!-z!/`!3`!6pPP!6x!7X!7b!8Z!8Q!8d!8j!8m!8p!8s!8{!9lPPPPPPPPPPPPPPPPP!9o!9s!9yP!:_!:c!:o!:x!;U!;l!;o!;r!;x!<O!<U!<XP!<a!<j!=f!=i]eOn#g$j)t,P'}`OTYZ[adnoprtxy}!P!Q!R!U!X!c!d!e!f!g!h!i!k!o!p!q!s!t!z#O#S#T#[#d#g#x#y#{#}$Q$e$g$h$j$q$}%S%Z%^%`%c%g%l%n%w%\|&O&Z&_&h&j&k&u&x&\|'P'W'Z'l'm'p'r's'w'\|(O(S(W(](^(d(g(p(r(z(})^)e)g)k)l)p)t)zOYdghkqrtvyz}+Q+U+V+Y+a+c+d+k+x+y,P,X,Y,],g,h,i,k,l,o,q,s,u,w,y,z-O-d-f-m-p-s.f.g/V/Z/s0c0d0e0f0h0i0j0k0l0n0r}!cQ#c#p$R$d$p%e%j%p%q&`'O'g(q(\|)jox+w,v/q0g!P!dQ#c#p$R$d$p$u%e%j%p%q&`'O'g(q(\|)jox+w,v/q0g!R!eQ#c#p$R$d$p$u$v%e%j%p%q&`'O'g(q(\|)jox+w,v/q0g!T!fQ#c#p$R$d$p$u$v$w%e%j%p%q&`'O'g(q(\|)jox+w,v/q0g!V!gQ#c#p$R$d$p$u$v$w$x%e%j%p%q&`'O'g(q(\|)jox+w,v/q0g!X!hQ#c#p$R$d$p$u$v$w$x$y%e%j%p%q&`'O'g(q(\|)jox+w,v/q0g!]!hQ!n#c#p$R$d$p$u$v$w$x$y$z%e%j%p%q&`'O'g(q(\|)jox+w,v/q0g'}TOTYZ[adnoprtxy}!P!Q!R!U!X!c!d!e!f!g!h!i!k!o!p!q!s!t!z#O#S#T#[#d#g#x#y#{#}$Q$e$g$h$j$q$}%S%Z%^%`%c%g%l%n%w%\|&O&Z&_&h&j&k&u&x&\|'P'W'Z'l'm'p'r's'w'\|(O(S(W(](^(d(g(p(r(z(})^)e)g)k)l)p)t)zOYdghkqrtvyz}+Q+U+V+Y+a+c+d+k+x+y,P,X,Y,],g,h,i,k,l,o,q,s,u,w,y,z-O-d-f-m-p-s.f.g/V/Z/s0c0d0e0f0h0i0j0k0l0n0r&cVOYZ[dnprxy}!P!Q!U!i!k!o!p!q!s!t#[#d#g#y#{#}$Q$h$j$}%S%Z%^%`%g%l%n%w%\|&Z&_&j&k&u&x'P'W'Z'l'm'p'r's'w(O(W(^(d(g(p(r(z)^)e)g)p)t)zOYdghkqrtvyz}+U+V+Y+a+d+k,P,X,Y,],g,h,i,k,l,o,q,s,u,w,y,z-O-d-f-m-p-s.f.g/Z/s0c0d0e0f0h0i0j0k0n0r%mXOYZ[dnrxy}!P!Q!U!i!k#[#d#g#y#{#}$Q$h$j$}%S%^%`%g%l%n%w%\|&Z&_&j&k&u&x'P'W'Z'l'm'p'r's'w(O(W(^(d(g(p(r(z)^)e)g)p)t)zOYdghkqtvyz}+U+V+Y+a+d+k,P,X,Y,],g,h,i,k,l,o,s,u,w,y,z-O-d-f-m-p.f.g/Z0i0j0kQ#vqQ/[.kR0o0q't`OTYZ[adnoprtxy}!P!Q!R!U!X!c!d!e!f!g!h!k!o!p!q!s!t!z#O#S#T#[#d#g#x#y#{#}$Q$e$g$h$j$q$}%S%Z%^%`%c%g%l%n%w%\|&O&Z&_&h&j&k&u&x&\|'P'W'Z'l'p'r's'w'\|(O(S(W(](^(d(g(p(r(z(})^)e)g)k)l)p)t)zOYghkqrtvyz}+Q+U+V+Y+a+c+d+k+x+y,P,X,Y,],h,i,k,l,o,q,s,u,w,y,z-O-d-f-m-p-s.f.g/V/Z/s0c0d0e0f0h0i0j0k0l0n0rh#jhz{$W$Z&l&q)S)X+f+g-RW#rq&].k0qQ$]\|Q$a!OQ$n!VQ$o!WW$\|!i'md,gS&[#s#tQ'S$iQ(s&UQ)U&nU)Y&s)Z+jW)a&w+m-T-{QQ']WR'_,`-h.TQ+l)`S,_STQ-Q+eQ-_,TQ-c,WQ.R-al.W-l.^._.a.z.\|/R/j/o/t/y0U0Z0^Q/S.`Q/a.tQ/l/OU0P/u0S0[X0V/z0W0_0`R&Z#r!_!wYZ!P!Q!k%S%`%g'p'r's(O(W)gghkqtv,h,i,k,l,o-m-p.f.g/ZR%^!vQ!{YQ%x#[Q&d#}Q&g$QR,{+YT.j-s/s![!jQ!n#c#p$R$d$p$u$v$w$x$y$z%e%j%p%q&`'O'g(q(\|)jox+w,v/q0gQ&X#kQ'c$oR^'dR'l$\|Q%V!mR/_.r'\|_OTYZ[adnoprtxy}!P!Q!R!U!X!c!d!e!f!g!h!i!k!o!p!q!s!t!z#O#S#T#[#d#g#x#y#{#}$Q$e$g$h$j$q$}%S%Z%^%`%c%g%l%n%w%\|&O&Z&_&h&j&k&u&x&\|'P'W'Z'l'm'p'r's'w'\|(O(S(W(](^(d(g(p(r(z(})^)e)g)k)l)p)t)zOYdghkqrtvyz}+Q+U+V+Y+a+c+d+k+x+y,P,X,Y,],g,h,i,k,l,o,q,s,u,w,y,z-O-d-f-m-p-s.f.g/V/Z/s0c0d0e0f0h0i0j0k0l0n0rS#a_#b!P.[-l.^._.`.a.t.z.\|/R/j/o/t/u/y/z0S0U0W0Z0[0^0_0`'\|_OTYZ[adnoprtxy}!P!Q!R!U!X!c!d!e!f!g!h!i!k!o!p!q!s!t!z#O#S#T#[#d#g#x#y#{#}$Q$e$g$h$j$q$}%S%Z%^%`%c%g%l%n%w%\|&O&Z&_&h&j&k&u&x&\|'P'W'Z'l'm'p'r's'w'\|(O(S(W(](^(d(g(p(r(z(})^)e)g)k)l)p)t)zOYdghkqrtvyz}+Q+U+V+Y+a+c+d+k+x+y,P,X,Y,],g,h,i,k,l,o,q,s,u,w,y,z-O-d-f-m-p-s.f.g/V/Z/s0c0d0e0f0h0i0j0k0l0n0rT#a_#bT#^^#_R(o%xa(l%x(n(o+`,{-y-z.oT+[(k+]R-z,{Q$PsQ+l)aR,^RX#}s$O$P&fQ&y$aQ'a$nQ'd$oR)s'SQ)b&wV-S+m-T-{ZgOn$j)t,PXkOn)t,PQ$k!TQ&z$bQ&{$cQ'^$mQ'b$oQ)q'RQ)x'WQ){'XQ)\|'YQZ'`S]'c'dQ+s)gQ+u)hQ+v)iQ+z)oS+\|)r[Q,Q)vQ,R)wS,S)y)zQ,d^Q-V+rQ-W+tQ-Y+{S-Z+},OQ-`,UQ-b,VQ-\|-XQ.O-[Q.P-^Q.Q-_Q.p-}Q.q.RQ/W.dR/r/XWkOn)t,PR#mjQ'`$nS)r'S'aR,O)sQ,]RR-f,^Q['`Q+})rR-[,OZiOjn)t,PQ'f$pR`'gT-j,e-ku.c-l.^._.a.t.z.\|/R/j/o/t/u/y0S0U0Z0[0^t.c-l.^._.a.t.z.\|/R/j/o/t/u/y0S0U0Z0[0^Q/S.`X0V/z0W0_0`!P.Z-l.^._.`.a.t.z.\|/R/j/o/t/u/y/z0S0U0W0Z0[0^0_0`Q.w.YR/f.xg.z.].{/b/i/n/\|0O0Q0]0a0bu.b-l.^._.a.t.z.\|/R/j/o/t/u/y0S0U0Z0[0^X.u.W.b/a0PR/c.tV0R/u0S0[R/X.dQnOS#on,PR,P)tQ&^#uR(x&^S%m#R#wS(_%m(bT(b%p&`Q%a!yQ%h!}W(P%a%h(U(YQ(U%eR(Y%jQ&i$RR)O&iQ(e%qQ{(`T+R(e{Q'n%ORe'nS'q%R%SYi'qj,m-q.hUj'r's'tU,mklmS-q,n,oR.h-rQ#Y]R%t#YQ#_^R%y#_Q(h%vS+W(h+XR+X(iQ+](kR,\|+]Q#b_R%{#bQ#ebQ%}#cW&Q#e%}({+bQ({&cR+b0gQ$OsS&e$O&fR&f$PQ&v$_R)_&vQ&V#jR(t&VQ&m$VS)T&m+hR+h)UQ$Z{R&p$ZQ&t$]R)[&tQ+n)bR-U+nQ#hfR&S#hQ)f&zR+q)fQ&}$dS)m&})nR)n'OQ'V$kR)u'VQ'[$lSP'[,ZR,ZQQ,aVR-i,aWjOn)t,PR#ljQ-k,eR.U-kd.{.]/b/i/n/\|0O0Q0]0a0bR/h.{U.s.W/a0PR/`.sQ/{/nS0X/{0YR0Y/\|S/v/b/cR0T/vQ.}.]R/k.}R!ZPXmOn)t,PWlOn)t,PR'T$jYfOn$j)t,PR&R#g[sOn#g$j)t,PR&d#}&bQOYZ[dnprxy}!P!Q!U!i!k!o!p!q!s!t#[#d#g#y#{#}$Q$h$j$}%S%Z%^%`%g%l%n%w%\|&Z&_&j&k&u&x'P'W'Z'l'm'p'r's'w(O(W(^(d(g(p(r(z)^)e)g)p)t)zOYdghkqrtvyz}+U+V+Y+a+d+k,P,X,Y,],g,h,i,k,l,o,q,s,u,w,y,z-O-d-f-m-p-s.f.g/Z/s0c0d0e0f0h0i0j0k0n0rQ!nTQ#caQ#poU$Rt%c(SS$d!R$gQ$p!XQ$u!cQ$v!dQ$w!eQ$x!fQ$y!gQ$z!hQ%e!zQ%j#OQ%p#SQ%q#TQ&`#xQ'O$eQ'g$qQ(q&OU(\|&h(}+cW)j&\|)l+x+yQo'\|Qx(]Q+w)kQ,v+QQ/q/VR0g0lQ!yYQ!}ZQ$b!PQ$c!QQ%R!kQ't%S^'{%`%g(O(Wqtv^f'ph,k,l-p.g/ZQl'rQm'sQ+t)gQ,jgQ,nkQ-n,hQ-o,iQ-r,oQ.e-mR/Y.f[bOn#g$j)t,P!^!vYZ!P!Q!k%S%`%g'p'r's(O(W)gghkqtv,h,i,k,l,o-m-p.f.g/ZQ#R[Q#fdS#wrxQ$UyW$_}$Q'P)pS$l!U$hW${!i'md,gS%v#[+Y`&P#d%\|(p(r(z+a-O0kQ&a#yQ&b#{Q&c#}Q'j$}Q'z%^W([%l(^y}Q(`%nQ(i%wQ(v&ZS(y&_0iQ)P&jQ)Q&kU)]&u)^+kQ)d&xQ)y'WY)}'ZO,X,Y-dQb'lSn'w0jW+P(dz,s,wW+T(g+V,y,zQ+p)eQ,U)zQ,cYQ,x+UQ-P+dQ-e,]Q-v,uR.S-fhUOn#d#g$j%\|&_'w(p(r)t,P%S!uYZ[drxy}!P!Q!U!i!k#[#y#{#}$Q$h$}%S%^%`%g%l%n%w&Z&j&k&u&x'P'W'Z'l'm'p'r's(O(W(^(d(g(z)^)e)g)p)zOYdghkqtvyz}+U+V+Y+a+d+k,X,Y,],g,h,i,k,l,o,s,u,w,y,z-O-d-f-m-p.f.g/Z0i0j0kQ#qpW%W!o!s0d0nQ%X!pQ%Y!qQ%[!tQ%f0cS'v%Z0hQ'x0eQ'y0fQ,prQ-u,qS.i-s/sR0p0rU#uq.k0qR(w&][cOn#g$j)t,PZ!xY#[#}$Q+YQ#W[Q#zrR$TxQ%b!yQ%i!}Q%o#RQ'j${Q(V%eQ(Z%jQ(c%pQ(f%qQ\|(`Q,fbQ-t,pQ.m-uR/].lQ$StQ(R%cRs(SQ.l-sR/}/sR#QZR#V[R%Q!iQ%O!iVc'md,g!]!lQ!n#c#p$R$d$p$u$v$w$x$y$z%e%j%p%q&`'O'g(q(\|)jox+w,v/q0gR%T!kT#]^#_Q%x#[R,{+YQ(m%xS+_(n(oQ,}+`Q-x,{S.n-y-zR/^.oT+Z(k+]Q$`}Q&g$QQ)o'PR+{)pQ$XzQ)W&qR+i)XQ$XzQ&o$WQ)W&qR+i)XQ#khW$Vz$W&q)XQ$[{Q&r$ZZ)R&l)S+f+g-RR$^\|R)c&wXlOn)t,PQ$f!RR'Q$gQ$m!UR'R$hRX'_QV'_V-g,`-h.TQ.d-lQ/P.^R/Q._U.]-l.^._Q/U.aQ/b.tQ/g.zU/i.\|/j/yQ/n/RQ/\|/oQ0O/tU0Q/u0S0[Q0]0UQ0a0ZR0b0^R/T.`R/d.t",
	nodeNames: "⚠ print Escape { Comment Script AssignStatement * BinaryExpression BitOp BitOp BitOp BitOp ArithOp ArithOp @ ArithOp ** UnaryExpression ArithOp BitOp AwaitExpression await ) ( ParenthesizedExpression BinaryExpression or and CompareOp in not is UnaryExpression ConditionalExpression if else LambdaExpression lambda ParamList VariableName AssignOp , : NamedExpression AssignOp YieldExpression yield from TupleExpression ComprehensionExpression async for LambdaExpression ] [ ArrayExpression ArrayComprehensionExpression } { DictionaryExpression DictionaryComprehensionExpression SetExpression SetComprehensionExpression CallExpression ArgList AssignOp MemberExpression . PropertyName Number String FormatString FormatReplacement FormatSelfDoc FormatConversion FormatSpec FormatReplacement FormatSelfDoc ContinuedString Ellipsis None Boolean TypeDef AssignOp UpdateStatement UpdateOp ExpressionStatement DeleteStatement del PassStatement pass BreakStatement break ContinueStatement continue ReturnStatement return YieldStatement PrintStatement RaiseStatement raise ImportStatement import as ScopeStatement global nonlocal AssertStatement assert TypeDefinition type TypeParamList TypeParam StatementGroup ; IfStatement Body elif WhileStatement while ForStatement TryStatement try except finally WithStatement with FunctionDefinition def ParamList AssignOp TypeDef ClassDefinition class DecoratedStatement Decorator At MatchStatement match MatchBody MatchClause case CapturePattern LiteralPattern ArithOp ArithOp AsPattern OrPattern LogicOp AttributePattern SequencePattern MappingPattern StarPattern ClassPattern PatternArgList KeywordPattern KeywordPattern Guard",
	maxTerm: 277,
	context: trackIndent,
	nodeProps: [
	["isolate", -5, 4, 71, 72, 73, 77, ""],
	["group", -15, 6, 85, 87, 88, 90, 92, 94, 96, 98, 99, 100, 102, 105, 108, 110, "Statement Statement", -22, 8, 18, 21, 25, 40, 49, 50, 56, 57, 60, 61, 62, 63, 64, 67, 70, 71, 72, 79, 80, 81, 82, "Expression", -10, 114, 116, 119, 121, 122, 126, 128, 133, 135, 138, "Statement", -9, 143, 144, 147, 148, 150, 151, 152, 153, 154, "Pattern"],
	["openedBy", 23, "(", 54, "[", 58, "{"],
	["closedBy", 24, ")", 55, "]", 59, "}"]
	],
	propSources: [pythonHighlighting],
	skippedNodes: [0, 4],
	repeatNodeCount: 34,
	tokenData: "!2\|~R!`OX%TXY%oY[%T[]%o]p%Tpq%oqr'ars)Ystxtu%Tuv,dvw-hwx.Uxy/tyz0[z{0r{\|2S\|}2p}!O3W!O!P4_!P!Q:Z!Q!R;k!R![>_![!]Do!]!^Es!^!_FZ!_!`Gk!`!aHX!a!b%T!b!cIf!c!dJU!d!eK^!e!hJU!h!i!#f!i!tJU!t!u!,\|!u!wJU!w!x!.t!x!}JU!}#O!0S#O#P&o#P#Q!0j#Q#R!1Q#R#SJU#S#T%T#T#UJU#U#VK^#V#YJU#Y#Z!#f#Z#fJU#f#g!,\|#g#iJU#i#j!.t#j#oJU#o#p!1n#p#q!1s#q#r!2a#r#s!2f#s$g%T$g;'SJU;'S;=`KW<%lOJU`%YT&n`O#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%T`%lP;=`<%l%To%v]&n`%c_OX%TXY%oY[%T[]%o]p%Tpq%oq#O%T#O#P&o#P#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%To&tX&n`OY%TYZ%oZ]%T]^%o^#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tc'f[&n`O!_%T!_!`([!`#T%T#T#U(r#U#f%T#f#g(r#g#h(r#h#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tc(cTmR&n`O#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tc(yT!mR&n`O#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk)aV&n`&[ZOr%Trs)vs#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk){V&n`Or%Trsbs#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%TkiT&n`&^ZO#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%To+PZS_&n`OYxYZ%TZ]x]^%T^#ox#o#p+r#p#qx#q#r+r#r;'Sx;'S;=`,^<%lOx_+wTS_OY+rZ]+r^;'S+r;'S;=`,W<%lO+r_,ZP;=`<%l+ro,aP;=`<%lxj,kV%rQ&n`O!_%T!_!`-Q!`#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tj-XT!xY&n`O#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tj-oV%lQ&n`O!_%T!_!`-Q!`#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk.]V&n`&ZZOw%Twx.rx#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk.wV&n`Ow%Twx/^x#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk/eT&n`&]ZO#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk/{ThZ&n`O#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tc0cTgR&n`O#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk0yXVZ&n`Oz%Tz{1f{!_%T!_!`-Q!`#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk1mVaR&n`O!_%T!_!`-Q!`#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk2ZV%oZ&n`O!_%T!_!`-Q!`#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tc2wTzR&n`O#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%To3_W%pZ&n`O!_%T!_!`-Q!`!a3w!a#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Td4OT&{S&n`O#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk4fX!fQ&n`O!O%T!O!P5R!P!Q%T!Q![6T![#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk5WV&n`O!O%T!O!P5m!P#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk5tT!rZ&n`O#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Ti6[a!hX&n`O!Q%T!Q![6T![!g%T!g!h7a!h!l%T!l!m9s!m#R%T#R#S6T#S#X%T#X#Y7a#Y#^%T#^#_9s#_#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Ti7fZ&n`O{%T{\|8X\|}%T}!O8X!O!Q%T!Q![8s![#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Ti8^V&n`O!Q%T!Q![8s![#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Ti8z]!hX&n`O!Q%T!Q![8s![!l%T!l!m9s!m#R%T#R#S8s#S#^%T#^#_9s#_#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Ti9zT!hX&n`O#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk:bX%qR&n`O!P%T!P!Q:}!Q!_%T!_!`-Q!`#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tj;UV%sQ&n`O!_%T!_!`-Q!`#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Ti;ro!hX&n`O!O%T!O!P=s!P!Q%T!Q![>_![!d%T!d!e?q!e!g%T!g!h7a!h!l%T!l!m9s!m!q%T!q!rA]!r!z%T!z!{Bq!{#R%T#R#S>_#S#U%T#U#V?q#V#X%T#X#Y7a#Y#^%T#^#_9s#_#c%T#c#dA]#d#l%T#l#mBq#m#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Ti=xV&n`O!Q%T!Q![6T![#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Ti>fc!hX&n`O!O%T!O!P=s!P!Q%T!Q![>_![!g%T!g!h7a!h!l%T!l!m9s!m#R%T#R#S>_#S#X%T#X#Y7a#Y#^%T#^#_9s#_#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Ti?vY&n`O!Q%T!Q!R@f!R!S@f!S#R%T#R#S@f#S#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Ti@mY!hX&n`O!Q%T!Q!R@f!R!S@f!S#R%T#R#S@f#S#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%TiAbX&n`O!Q%T!Q!YA}!Y#R%T#R#SA}#S#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%TiBUX!hX&n`O!Q%T!Q!YA}!Y#R%T#R#SA}#S#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%TiBv]&n`O!Q%T!Q![Co![!c%T!c!iCo!i#R%T#R#SCo#S#T%T#T#ZCo#Z#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%TiCv]!hX&n`O!Q%T!Q![Co![!c%T!c!iCo!i#R%T#R#SCo#S#T%T#T#ZCo#Z#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%ToDvV{_&n`O!_%T!_!`E]!`#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%TcEdT%{R&n`O#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%TkEzT#gZ&n`O#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%TkFbXmR&n`O!^%T!^!_F}!_!`([!`!a([!a#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%TjGUV%mQ&n`O!_%T!_!`-Q!`#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%TkGrV%zZ&n`O!_%T!_!`([!`#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%TkH`WmR&n`O!_%T!_!`([!`!aHx!a#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%TjIPV%nQ&n`O!_%T!_!`-Q!`#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%TkIoV_Q#}P&n`O!_%T!_!`-Q!`#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%ToJ_]&n`&YS%uZO!Q%T!Q![JU![!c%T!c!}JU!}#R%T#R#SJU#S#T%T#T#oJU#p#q%T#r$g%T$g;'SJU;'S;=`KW<%lOJUoKZP;=`<%lJUoKge&n`&YS%uZOr%Trs)Ysw%Twx.Ux!Q%T!Q![JU![!c%T!c!tJU!t!uLx!u!}JU!}#R%T#R#SJU#S#T%T#T#fJU#f#gLx#g#oJU#p#q%T#r$g%T$g;'SJU;'S;=`KW<%lOJUoMRa&n`&YS%uZOr%TrsNWsw%Twx! vx!Q%T!Q![JU![!c%T!c!}JU!}#R%T#R#SJU#S#T%T#T#oJU#p#q%T#r$g%T$g;'SJU;'S;=`KW<%lOJUkN_V&n`&`ZOr%TrsNts#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%TkNyV&n`Or%Trs! `s#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk! gT&n`&bZO#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk! }V&n`&_ZOw%Twx!!dx#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk!!iV&n`Ow%Twx!#Ox#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk!#VT&n`&aZO#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%To!#oe&n`&YS%uZOr%Trs!%Qsw%Twx!&px!Q%T!Q![JU![!c%T!c!tJU!t!u!(`!u!}JU!}#R%T#R#SJU#S#T%T#T#fJU#f#g!(`#g#oJU#p#q%T#r$g%T$g;'SJU;'S;=`KW<%lOJUk!%XV&n`&dZOr%Trs!%ns#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk!%sV&n`Or%Trs!&Ys#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk!&aT&n`&fZO#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk!&wV&n`&cZOw%Twx!'^x#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk!'cV&n`Ow%Twx!'xx#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk!(PT&n`&eZO#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%To!(ia&n`&YS%uZOr%Trs!)nsw%Twx!+^x!Q%T!Q![JU![!c%T!c!}JU!}#R%T#R#SJU#S#T%T#T#oJU#p#q%T#r$g%T$g;'SJU;'S;=`KW<%lOJUk!)uV&n`&hZOr%Trs![s#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk!aV&n`Or%Trs!vs#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk!}T&n`&jZO#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk!+eV&n`&gZOw%Twx!+zx#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk!,PV&n`Ow%Twx!,fx#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tk!,mT&n`&iZO#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%To!-Vi&n`&YS%uZOr%TrsNWsw%Twx! vx!Q%T!Q![JU![!c%T!c!dJU!d!eLx!e!hJU!h!i!(`!i!}JU!}#R%T#R#SJU#S#T%T#T#UJU#U#VLx#V#YJU#Y#Z!(`#Z#oJU#p#q%T#r$g%T$g;'SJU;'S;=`KW<%lOJUo!.}a&n`&YS%uZOr%Trs)Ysw%Twx.Ux!Q%T!Q![JU![!c%T!c!}JU!}#R%T#R#SJU#S#T%T#T#oJU#p#q%T#r$g%T$g;'SJU;'S;=`KW<%lOJUk!0ZT!XZ&n`O#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tc!0qT!WR&n`O#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%Tj!1XV%kQ&n`O!_%T!_!`-Q!`#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%T~!1sO!]~k!1zV%jR&n`O!_%T!_!`-Q!`#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%T~!2fO![~i!2mT%tX&n`O#o%T#p#q%T#r;'S%T;'S;=`%i<%lO%T",
	tokenizers: [legacyPrint, indentation, newlines, strings, 0, 1, 2, 3, 4],
	topRules: { "Script": [0, 5] },
	specialized: [{ term: 221, get: (value) => spec_identifier[value] \|\| -1 }],
	tokenPrec: 7652
	});

	// node_modules/@codemirror/lang-python/dist/index.js
	var cache = new NodeWeakMap();
	var ScopeNodes = /* @__PURE__ */ new Set([
	"Script",
	"Body",
	"FunctionDefinition",
	"ClassDefinition",
	"LambdaExpression",
	"ForStatement",
	"MatchClause"
	]);
	function defID(type) {
	return (node, def, outer) => {
	if (outer)
	return false;
	let id2 = node.node.getChild("VariableName");
	if (id2)
	def(id2, type);
	return true;
	};
	}
	var gatherCompletions = {
	FunctionDefinition: defID("function"),
	ClassDefinition: defID("class"),
	ForStatement(node, def, outer) {
	if (outer)
	for (let child = node.node.firstChild; child; child = child.nextSibling) {
	if (child.name == "VariableName")
	def(child, "variable");
	else if (child.name == "in")
	break;
	}
	},
	ImportStatement(_node, def) {
	var _a, _b;
	let { node } = _node;
	let isFrom = ((_a = node.firstChild) === null \|\| _a === void 0 ? void 0 : _a.name) == "from";
	for (let ch = node.getChild("import"); ch; ch = ch.nextSibling) {
	if (ch.name == "VariableName" && ((_b = ch.nextSibling) === null \|\| _b === void 0 ? void 0 : _b.name) != "as")
	def(ch, isFrom ? "variable" : "namespace");
	}
	},
	AssignStatement(node, def) {
	for (let child = node.node.firstChild; child; child = child.nextSibling) {
	if (child.name == "VariableName")
	def(child, "variable");
	else if (child.name == ":" \|\| child.name == "AssignOp")
	break;
	}
	},
	ParamList(node, def) {
	for (let prev = null, child = node.node.firstChild; child; child = child.nextSibling) {
	if (child.name == "VariableName" && (!prev \|\| !/\*\|AssignOp/.test(prev.name)))
	def(child, "variable");
	prev = child;
	}
	},
	CapturePattern: defID("variable"),
	AsPattern: defID("variable"),
	__proto__: null
	};
	function getScope(doc, node) {
	let cached = cache.get(node);
	if (cached)
	return cached;
	let completions = [], top = true;
	function def(node2, type) {
	let name = doc.sliceString(node2.from, node2.to);
	completions.push({ label: name, type });
	}
	node.cursor(IterMode.IncludeAnonymous).iterate((node2) => {
	if (node2.name) {
	let gather = gatherCompletions[node2.name];
	if (gather && gather(node2, def, top) \|\| !top && ScopeNodes.has(node2.name))
	return false;
	top = false;
	} else if (node2.to - node2.from > 8192) {
	for (let c of getScope(doc, node2.node))
	completions.push(c);
	return false;
	}
	});
	cache.set(node, completions);
	return completions;
	}
	var Identifier = /^[\w\xa1-\uffff][\w\d\xa1-\uffff]*$/;
	var dontComplete = ["String", "FormatString", "Comment", "PropertyName"];
	function localCompletionSource(context) {
	let inner = syntaxTree(context.state).resolveInner(context.pos, -1);
	if (dontComplete.indexOf(inner.name) > -1)
	return null;
	let isWord = inner.name == "VariableName" \|\| inner.to - inner.from < 20 && Identifier.test(context.state.sliceDoc(inner.from, inner.to));
	if (!isWord && !context.explicit)
	return null;
	let options = [];
	for (let pos = inner; pos; pos = pos.parent) {
	if (ScopeNodes.has(pos.name))
	options = options.concat(getScope(context.state.doc, pos));
	}
	return {
	options,
	from: isWord ? inner.from : context.pos,
	validFor: Identifier
	};
	}
	var globals = [
	"__annotations__",
	"__builtins__",
	"__debug__",
	"__doc__",
	"__import__",
	"__name__",
	"__loader__",
	"__package__",
	"__spec__",
	"False",
	"None",
	"True"
	].map((n) => ({ label: n, type: "constant" })).concat([
	"ArithmeticError",
	"AssertionError",
	"AttributeError",
	"BaseException",
	"BlockingIOError",
	"BrokenPipeError",
	"BufferError",
	"BytesWarning",
	"ChildProcessError",
	"ConnectionAbortedError",
	"ConnectionError",
	"ConnectionRefusedError",
	"ConnectionResetError",
	"DeprecationWarning",
	"EOFError",
	"Ellipsis",
	"EncodingWarning",
	"EnvironmentError",
	"Exception",
	"FileExistsError",
	"FileNotFoundError",
	"FloatingPointError",
	"FutureWarning",
	"GeneratorExit",
	"IOError",
	"ImportError",
	"ImportWarning",
	"IndentationError",
	"IndexError",
	"InterruptedError",
	"IsADirectoryError",
	"KeyError",
	"KeyboardInterrupt",
	"LookupError",
	"MemoryError",
	"ModuleNotFoundError",
	"NameError",
	"NotADirectoryError",
	"NotImplemented",
	"NotImplementedError",
	"OSError",
	"OverflowError",
	"PendingDeprecationWarning",
	"PermissionError",
	"ProcessLookupError",
	"RecursionError",
	"ReferenceError",
	"ResourceWarning",
	"RuntimeError",
	"RuntimeWarning",
	"StopAsyncIteration",
	"StopIteration",
	"SyntaxError",
	"SyntaxWarning",
	"SystemError",
	"SystemExit",
	"TabError",
	"TimeoutError",
	"TypeError",
	"UnboundLocalError",
	"UnicodeDecodeError",
	"UnicodeEncodeError",
	"UnicodeError",
	"UnicodeTranslateError",
	"UnicodeWarning",
	"UserWarning",
	"ValueError",
	"Warning",
	"ZeroDivisionError"
	].map((n) => ({ label: n, type: "type" }))).concat([
	"bool",
	"bytearray",
	"bytes",
	"classmethod",
	"complex",
	"float",
	"frozenset",
	"int",
	"list",
	"map",
	"memoryview",
	"object",
	"range",
	"set",
	"staticmethod",
	"str",
	"super",
	"tuple",
	"type"
	].map((n) => ({ label: n, type: "class" }))).concat([
	"abs",
	"aiter",
	"all",
	"anext",
	"any",
	"ascii",
	"bin",
	"breakpoint",
	"callable",
	"chr",
	"compile",
	"delattr",
	"dict",
	"dir",
	"divmod",
	"enumerate",
	"eval",
	"exec",
	"exit",
	"filter",
	"format",
	"getattr",
	"globals",
	"hasattr",
	"hash",
	"help",
	"hex",
	"id",
	"input",
	"isinstance",
	"issubclass",
	"iter",
	"len",
	"license",
	"locals",
	"max",
	"min",
	"next",
	"oct",
	"open",
	"ord",
	"pow",
	"print",
	"property",
	"quit",
	"repr",
	"reversed",
	"round",
	"setattr",
	"slice",
	"sorted",
	"sum",
	"vars",
	"zip"
	].map((n) => ({ label: n, type: "function" })));
	var snippets = [
	snippetCompletion("def ${name}(${params}):\n ${}", {
	label: "def",
	detail: "function",
	type: "keyword"
	}),
	snippetCompletion("for ${name} in ${collection}:\n ${}", {
	label: "for",
	detail: "loop",
	type: "keyword"
	}),
	snippetCompletion("while ${}:\n ${}", {
	label: "while",
	detail: "loop",
	type: "keyword"
	}),
	snippetCompletion("try:\n ${}\nexcept ${error}:\n ${}", {
	label: "try",
	detail: "/ except block",
	type: "keyword"
	}),
	snippetCompletion("if ${}:\n \n", {
	label: "if",
	detail: "block",
	type: "keyword"
	}),
	snippetCompletion("if ${}:\n ${}\nelse:\n ${}", {
	label: "if",
	detail: "/ else block",
	type: "keyword"
	}),
	snippetCompletion("class ${name}:\n def __init__(self, ${params}):\n ${}", {
	label: "class",
	detail: "definition",
	type: "keyword"
	}),
	snippetCompletion("import ${module}", {
	label: "import",
	detail: "statement",
	type: "keyword"
	}),
	snippetCompletion("from ${module} import ${names}", {
	label: "from",
	detail: "import",
	type: "keyword"
	})
	];
	var globalCompletion = ifNotIn(dontComplete, completeFromList(globals.concat(snippets)));
	function innerBody(context) {
	let { node, pos } = context;
	let lineIndent = context.lineIndent(pos, -1);
	let found = null;
	for (; ; ) {
	let before = node.childBefore(pos);
	if (!before) {
	break;
	} else if (before.name == "Comment") {
	pos = before.from;
	} else if (before.name == "Body") {
	if (context.baseIndentFor(before) + context.unit <= lineIndent)
	found = before;
	node = before;
	} else if (before.type.is("Statement")) {
	node = before;
	} else {
	break;
	}
	}
	return found;
	}
	function indentBody(context, node) {
	let base = context.baseIndentFor(node);
	let line = context.lineAt(context.pos, -1), to = line.from + line.text.length;
	if (/^\s*($\|#)/.test(line.text) && context.node.to < to + 100 && !/\S/.test(context.state.sliceDoc(to, context.node.to)) && context.lineIndent(context.pos, -1) <= base)
	return null;
	if (/^\s*(else:\|elif \|except \|finally:)/.test(context.textAfter) && context.lineIndent(context.pos, -1) > base)
	return null;
	return base + context.unit;
	}
	var pythonLanguage = LRLanguage.define({
	name: "python",
	parser: parser.configure({
	props: [
	indentNodeProp.add({
	Body: (context) => {
	var _a;
	let inner = innerBody(context);
	return (_a = indentBody(context, inner \|\| context.node)) !== null && _a !== void 0 ? _a : context.continue();
	},
	IfStatement: (cx) => /^\s*(else:\|elif )/.test(cx.textAfter) ? cx.baseIndent : cx.continue(),
	"ForStatement WhileStatement": (cx) => /^\s*else:/.test(cx.textAfter) ? cx.baseIndent : cx.continue(),
	TryStatement: (cx) => /^\s*(except \|finally:\|else:)/.test(cx.textAfter) ? cx.baseIndent : cx.continue(),
	"TupleExpression ComprehensionExpression ParamList ArgList ParenthesizedExpression": delimitedIndent({ closing: ")" }),
	"DictionaryExpression DictionaryComprehensionExpression SetExpression SetComprehensionExpression": delimitedIndent({ closing: "}" }),
	"ArrayExpression ArrayComprehensionExpression": delimitedIndent({ closing: "]" }),
	"String FormatString": () => null,
	Script: (context) => {
	var _a;
	let inner = innerBody(context);
	return (_a = inner && indentBody(context, inner)) !== null && _a !== void 0 ? _a : context.continue();
	}
	}),
	foldNodeProp.add({
	"ArrayExpression DictionaryExpression SetExpression TupleExpression": foldInside,
	Body: (node, state) => ({ from: node.from + 1, to: node.to - (node.to == state.doc.length ? 0 : 1) })
	})
	]
	}),
	languageData: {
	closeBrackets: {
	brackets: ["(", "[", "{", "'", '"', "'''", '"""'],
	stringPrefixes: [
	"f",
	"fr",
	"rf",
	"r",
	"u",
	"b",
	"br",
	"rb",
	"F",
	"FR",
	"RF",
	"R",
	"U",
	"B",
	"BR",
	"RB"
	]
	},
	commentTokens: { line: "#" },
	indentOnInput: /^\s*([\}\]\)]\|else:\|elif \|except \|finally:)$/
	}
	});
	function python() {
	return new LanguageSupport(pythonLanguage, [
	pythonLanguage.data.of({ autocomplete: localCompletionSource }),
	pythonLanguage.data.of({ autocomplete: globalCompletion })
	]);
	}
	export {
	globalCompletion,
	localCompletionSource,
	python,
	pythonLanguage
	};
	//# sourceMappingURL=@codemirror_lang-python.js.map