https://lucace-inception-flap-scanner.hf.space/node_modules/.vite/deps/ethers.js?v=4134b4c7

1import { n as __exportAll } from "/node_modules/.vite/deps/rolldown-runtime-EAsCxrDo.js?v=6a21e4cf";
2//#region node_modules/ethers/lib.esm/_version.js
3/**
4*  The current version of Ethers.
5*/
6var version = "6.17.0";
7//#endregion
8//#region node_modules/ethers/lib.esm/utils/properties.js
9/**
10*  Property helper functions.
11*
12*  @_subsection api/utils:Properties  [about-properties]
13*/
14function checkType(value, type, name) {
15	const types = type.split("|").map((t) => t.trim());
16	for (let i = 0; i < types.length; i++) switch (type) {
17		case "any": return;
18		case "bigint":
19		case "boolean":
20		case "number":
21		case "string": if (typeof value === type) return;
22	}
23	const error = /* @__PURE__ */ new Error(`invalid value for type ${type}`);
24	error.code = "INVALID_ARGUMENT";
25	error.argument = `value.${name}`;
26	error.value = value;
27	throw error;
28}
29/**
30*  Resolves to a new object that is a copy of %%value%%, but with all
31*  values resolved.
32*/
33async function resolveProperties(value) {
34	const keys = Object.keys(value);
35	return (await Promise.all(keys.map((k) => Promise.resolve(value[k])))).reduce((accum, v, index) => {
36		accum[keys[index]] = v;
37		return accum;
38	}, {});
39}
40/**
41*  Assigns the %%values%% to %%target%% as read-only values.
42*
43*  It %%types%% is specified, the values are checked.
44*/
45function defineProperties(target, values, types) {
46	for (let key in values) {
47		let value = values[key];
48		const type = types ? types[key] : null;
49		if (type) checkType(value, type, key);
50		Object.defineProperty(target, key, {
51			enumerable: true,
52			value,
53			writable: false
54		});
55	}
56}
57//#endregion
58//#region node_modules/ethers/lib.esm/utils/errors.js
59/**
60*  All errors in ethers include properties to ensure they are both
61*  human-readable (i.e. ``.message``) and machine-readable (i.e. ``.code``).
62*
63*  The [[isError]] function can be used to check the error ``code`` and
64*  provide a type guard for the properties present on that error interface.
65*
66*  @_section: api/utils/errors:Errors  [about-errors]
67*/
68function stringify$1(value, seen) {
69	if (value == null) return "null";
70	if (seen == null) seen = /* @__PURE__ */ new Set();
71	if (typeof value === "object") {
72		if (seen.has(value)) return "[Circular]";
73		seen.add(value);
74	}
75	if (Array.isArray(value)) return "[ " + value.map((v) => stringify$1(v, seen)).join(", ") + " ]";
76	if (value instanceof Uint8Array) {
77		const HEX = "0123456789abcdef";
78		let result = "0x";
79		for (let i = 0; i < value.length; i++) {
80			result += HEX[value[i] >> 4];
81			result += HEX[value[i] & 15];
82		}
83		return result;
84	}
85	if (typeof value === "object" && typeof value.toJSON === "function") return stringify$1(value.toJSON(), seen);
86	switch (typeof value) {
87		case "boolean":
88		case "number":
89		case "symbol": return value.toString();
90		case "bigint": return BigInt(value).toString();
91		case "string": return JSON.stringify(value);
92		case "object": {
93			const keys = Object.keys(value);
94			keys.sort();
95			return "{ " + keys.map((k) => `${stringify$1(k, seen)}: ${stringify$1(value[k], seen)}`).join(", ") + " }";
96		}
97	}
98	return `[ COULD NOT SERIALIZE ]`;
99}
100/**
101*  Returns true if the %%error%% matches an error thrown by ethers
102*  that matches the error %%code%%.
103*
104*  In TypeScript environments, this can be used to check that %%error%%
105*  matches an EthersError type, which means the expected properties will
106*  be set.
107*
108*  @See [ErrorCodes](api:ErrorCode)
109*  @example
110*    try {
111*      // code....
112*    } catch (e) {
113*      if (isError(e, "CALL_EXCEPTION")) {
114*          // The Type Guard has validated this object
115*          console.log(e.data);
116*      }
117*    }
118*/
119function isError(error, code) {
120	return error && error.code === code;
121}
122/**
123*  Returns true if %%error%% is a [[CallExceptionError].
124*/
125function isCallException(error) {
126	return isError(error, "CALL_EXCEPTION");
127}
128/**
129*  Returns a new Error configured to the format ethers emits errors, with
130*  the %%message%%, [[api:ErrorCode]] %%code%% and additional properties
131*  for the corresponding EthersError.
132*
133*  Each error in ethers includes the version of ethers, a
134*  machine-readable [[ErrorCode]], and depending on %%code%%, additional
135*  required properties. The error message will also include the %%message%%,
136*  ethers version, %%code%% and all additional properties, serialized.
137*/
138function makeError(message, code, info) {
139	let shortMessage = message;
140	{
141		const details = [];
142		if (info) {

143			if ("message" in info || "code" in info || "name" in info) throw new Error(`value will overwrite populated values: ${stringify$1(info)}`);
144			for (const key in info) {
145				if (key === "shortMessage") continue;
146				const value = info[key];
147				details.push(key + "=" + stringify$1(value));
148			}
149		}
150		details.push(`code=${code}`);
151		details.push(`version=${version}`);
152		if (details.length) message += " (" + details.join(", ") + ")";
153	}
154	let error;
155	switch (code) {
156		case "INVALID_ARGUMENT":
157			error = new TypeError(message);
158			break;
159		case "NUMERIC_FAULT":
160		case "BUFFER_OVERRUN":
161			error = new RangeError(message);
162			break;
163		default: error = new Error(message);
164	}
165	defineProperties(error, { code });
166	if (info) Object.assign(error, info);
167	if (error.shortMessage == null) defineProperties(error, { shortMessage });
168	return error;
169}
170/**
171*  Throws an EthersError with %%message%%, %%code%% and additional error
172*  %%info%% when %%check%% is falsish..
173*
174*  @see [[api:makeError]]
175*/
176function assert(check, message, code, info) {
177	if (!check) throw makeError(message, code, info);
178}
179/**
180*  A simple helper to simply ensuring provided arguments match expected
181*  constraints, throwing if not.
182*
183*  In TypeScript environments, the %%check%% has been asserted true, so
184*  any further code does not need additional compile-time checks.
185*/
186function assertArgument(check, message, name, value) {
187	assert(check, message, "INVALID_ARGUMENT", {
188		argument: name,
189		value
190	});
191}
192function assertArgumentCount(count, expectedCount, message) {
193	if (message == null) message = "";
194	if (message) message = ": " + message;
195	assert(count >= expectedCount, "missing argument" + message, "MISSING_ARGUMENT", {
196		count,
197		expectedCount
198	});
199	assert(count <= expectedCount, "too many arguments" + message, "UNEXPECTED_ARGUMENT", {
200		count,
201		expectedCount
202	});
203}
204var _normalizeForms = [
205	"NFD",
206	"NFC",
207	"NFKD",
208	"NFKC"
209].reduce((accum, form) => {
210	try {
211		/* c8 ignore start */
212		if ("test".normalize(form) !== "test") throw new Error("bad");
213		/* c8 ignore stop */
214		if (form === "NFD") {
215			/* c8 ignore start */
216			if (String.fromCharCode(233).normalize("NFD") !== String.fromCharCode(101, 769)) throw new Error("broken");
217		}
218		accum.push(form);
219	} catch (error) {}
220	return accum;
221}, []);
222/**
223*  Throws if the normalization %%form%% is not supported.
224*/
225function assertNormalize(form) {
226	assert(_normalizeForms.indexOf(form) >= 0, "platform missing String.prototype.normalize", "UNSUPPORTED_OPERATION", {
227		operation: "String.prototype.normalize",
228		info: { form }
229	});
230}
231/**
232*  Many classes use file-scoped values to guard the constructor,
233*  making it effectively private. This facilitates that pattern
234*  by ensuring the %%givenGaurd%% matches the file-scoped %%guard%%,
235*  throwing if not, indicating the %%className%% if provided.
236*/
237function assertPrivate(givenGuard, guard, className) {
238	if (className == null) className = "";
239	if (givenGuard !== guard) {
240		let method = className, operation = "new";
241		if (className) {
242			method += ".";
243			operation += " " + className;
244		}
245		assert(false, `private constructor; use ${method}from* methods`, "UNSUPPORTED_OPERATION", { operation });
246	}
247}
248//#endregion
249//#region node_modules/ethers/lib.esm/utils/data.js
250/**
251*  Some data helpers.
252*
253*
254*  @_subsection api/utils:Data Helpers  [about-data]
255*/
256function _getBytes(value, name, copy) {
257	if (value instanceof Uint8Array) {
258		if (copy) return new Uint8Array(value);
259		return value;
260	}
261	if (typeof value === "string" && value.length % 2 === 0 && value.match(/^0x[0-9a-f]*$/i)) {
262		const result = new Uint8Array((value.length - 2) / 2);
263		let offset = 2;
264		for (let i = 0; i < result.length; i++) {
265			result[i] = parseInt(value.substring(offset, offset + 2), 16);
266			offset += 2;
267		}
268		return result;
269	}
270	assertArgument(false, "invalid BytesLike value", name || "value", value);
271}
272/**
273*  Get a typed Uint8Array for %%value%%. If already a Uint8Array
274*  the original %%value%% is returned; if a copy is required use
275*  [[getBytesCopy]].
276*
277*  @see: getBytesCopy
278*/
279function getBytes(value, name) {
280	return _getBytes(value, name, false);
281}
282/**
283*  Get a typed Uint8Array for %%value%%, creating a copy if necessary
284*  to prevent any modifications of the returned value from being
285*  reflected elsewhere.
286*
287*  @see: getBytes
288*/
289function getBytesCopy(value, name) {
290	return _getBytes(value, name, true);
291}
292/**
293*  Returns true if %%value%% is a valid [[HexString]].
294*
295*  If %%length%% is ``true`` or a //number//, it also checks that
296*  %%value%% is a valid [[DataHexString]] of %%length%% (if a //number//)
297*  bytes of data (e.g. ``0x1234`` is 2 bytes).
298*/
299function isHexString(value, length) {
300	if (typeof value !== "string" || !value.match(/^0x[0-9A-Fa-f]*$/)) return false;

301	if (typeof length === "number" && value.length !== 2 + 2 * length) return false;
302	if (length === true && value.length % 2 !== 0) return false;
303	return true;
304}
305/**
306*  Returns true if %%value%% is a valid representation of arbitrary
307*  data (i.e. a valid [[DataHexString]] or a Uint8Array).
308*/
309function isBytesLike(value) {
310	return isHexString(value, true) || value instanceof Uint8Array;
311}
312var HexCharacters = "0123456789abcdef";
313/**
314*  Returns a [[DataHexString]] representation of %%data%%.
315*/
316function hexlify(data) {
317	const bytes = getBytes(data);
318	let result = "0x";
319	for (let i = 0; i < bytes.length; i++) {
320		const v = bytes[i];
321		result += HexCharacters[(v & 240) >> 4] + HexCharacters[v & 15];
322	}
323	return result;
324}
325/**
326*  Returns a [[DataHexString]] by concatenating all values
327*  within %%data%%.
328*/
329function concat(datas) {
330	return "0x" + datas.map((d) => hexlify(d).substring(2)).join("");
331}
332/**
333*  Returns the length of %%data%%, in bytes.
334*/
335function dataLength(data) {
336	if (isHexString(data, true)) return (data.length - 2) / 2;
337	return getBytes(data).length;
338}
339/**
340*  Returns a [[DataHexString]] by slicing %%data%% from the %%start%%
341*  offset to the %%end%% offset.
342*
343*  By default %%start%% is 0 and %%end%% is the length of %%data%%.
344*/
345function dataSlice(data, start, end) {
346	const bytes = getBytes(data);
347	if (end != null && end > bytes.length) assert(false, "cannot slice beyond data bounds", "BUFFER_OVERRUN", {
348		buffer: bytes,
349		length: bytes.length,
350		offset: end
351	});
352	return hexlify(bytes.slice(start == null ? 0 : start, end == null ? bytes.length : end));
353}
354/**
355*  Return the [[DataHexString]] result by stripping all **leading**
356** zero bytes from %%data%%.
357*/
358function stripZerosLeft(data) {
359	let bytes = hexlify(data).substring(2);
360	while (bytes.startsWith("00")) bytes = bytes.substring(2);
361	return "0x" + bytes;
362}
363function zeroPad(data, length, left) {
364	const bytes = getBytes(data);
365	assert(length >= bytes.length, "padding exceeds data length", "BUFFER_OVERRUN", {
366		buffer: new Uint8Array(bytes),
367		length,
368		offset: length + 1
369	});
370	const result = new Uint8Array(length);
371	result.fill(0);
372	if (left) result.set(bytes, length - bytes.length);
373	else result.set(bytes, 0);
374	return hexlify(result);
375}
376/**
377*  Return the [[DataHexString]] of %%data%% padded on the **left**
378*  to %%length%% bytes.
379*
380*  If %%data%% already exceeds %%length%%, a [[BufferOverrunError]] is
381*  thrown.
382*
383*  This pads data the same as **values** are in Solidity
384*  (e.g. ``uint128``).
385*/
386function zeroPadValue(data, length) {
387	return zeroPad(data, length, true);
388}
389/**
390*  Return the [[DataHexString]] of %%data%% padded on the **right**
391*  to %%length%% bytes.
392*
393*  If %%data%% already exceeds %%length%%, a [[BufferOverrunError]] is
394*  thrown.
395*
396*  This pads data the same as **bytes** are in Solidity
397*  (e.g. ``bytes16``).
398*/
399function zeroPadBytes(data, length) {
400	return zeroPad(data, length, false);
401}
402//#endregion
403//#region node_modules/ethers/lib.esm/utils/maths.js
404/**
405*  Some mathematic operations.
406*
407*  @_subsection: api/utils:Math Helpers  [about-maths]
408*/
409var BN_0$10 = BigInt(0);
410var BN_1$5 = BigInt(1);
411var maxValue = 9007199254740991;
412/**
413*  Convert %%value%% from a twos-compliment representation of %%width%%
414*  bits to its value.
415*
416*  If the highest bit is ``1``, the result will be negative.
417*/
418function fromTwos(_value, _width) {
419	const value = getUint(_value, "value");
420	const width = BigInt(getNumber(_width, "width"));
421	assert(value >> width === BN_0$10, "overflow", "NUMERIC_FAULT", {
422		operation: "fromTwos",
423		fault: "overflow",
424		value: _value
425	});
426	if (value >> width - BN_1$5) {
427		const mask = (BN_1$5 << width) - BN_1$5;
428		return -((~value & mask) + BN_1$5);
429	}
430	return value;
431}
432/**
433*  Convert %%value%% to a twos-compliment representation of
434*  %%width%% bits.
435*
436*  The result will always be positive.
437*/
438function toTwos(_value, _width) {
439	let value = getBigInt(_value, "value");
440	const width = BigInt(getNumber(_width, "width"));
441	const limit = BN_1$5 << width - BN_1$5;
442	if (value < BN_0$10) {
443		value = -value;
444		assert(value <= limit, "too low", "NUMERIC_FAULT", {
445			operation: "toTwos",
446			fault: "overflow",
447			value: _value
448		});
449		const mask = (BN_1$5 << width) - BN_1$5;
450		return (~value & mask) + BN_1$5;
451	} else assert(value < limit, "too high", "NUMERIC_FAULT", {
452		operation: "toTwos",
453		fault: "overflow",
454		value: _value
455	});
456	return value;
457}
458/**

459*  Mask %%value%% with a bitmask of %%bits%% ones.
460*/
461function mask(_value, _bits) {
462	return getUint(_value, "value") & (BN_1$5 << BigInt(getNumber(_bits, "bits"))) - BN_1$5;
463}
464/**
465*  Gets a BigInt from %%value%%. If it is an invalid value for
466*  a BigInt, then an ArgumentError will be thrown for %%name%%.
467*/
468function getBigInt(value, name) {
469	switch (typeof value) {
470		case "bigint": return value;
471		case "number":
472			assertArgument(Number.isInteger(value), "underflow", name || "value", value);
473			assertArgument(value >= -9007199254740991 && value <= maxValue, "overflow", name || "value", value);
474			return BigInt(value);
475		case "string": try {
476			if (value === "") throw new Error("empty string");
477			if (value[0] === "-" && value[1] !== "-") return -BigInt(value.substring(1));
478			return BigInt(value);
479		} catch (e) {
480			assertArgument(false, `invalid BigNumberish string: ${e.message}`, name || "value", value);
481		}
482	}
483	assertArgument(false, "invalid BigNumberish value", name || "value", value);
484}
485/**
486*  Returns %%value%% as a bigint, validating it is valid as a bigint
487*  value and that it is positive.
488*/
489function getUint(value, name) {
490	const result = getBigInt(value, name);
491	assert(result >= BN_0$10, "unsigned value cannot be negative", "NUMERIC_FAULT", {
492		fault: "overflow",
493		operation: "getUint",
494		value
495	});
496	return result;
497}
498var Nibbles$1 = "0123456789abcdef";
499function toBigInt(value) {
500	if (value instanceof Uint8Array) {
501		let result = "0x0";
502		for (const v of value) {
503			result += Nibbles$1[v >> 4];
504			result += Nibbles$1[v & 15];
505		}
506		return BigInt(result);
507	}
508	return getBigInt(value);
509}
510/**
511*  Gets a //number// from %%value%%. If it is an invalid value for
512*  a //number//, then an ArgumentError will be thrown for %%name%%.
513*/
514function getNumber(value, name) {
515	switch (typeof value) {
516		case "bigint":
517			assertArgument(value >= -9007199254740991 && value <= maxValue, "overflow", name || "value", value);
518			return Number(value);
519		case "number":
520			assertArgument(Number.isInteger(value), "underflow", name || "value", value);
521			assertArgument(value >= -9007199254740991 && value <= maxValue, "overflow", name || "value", value);
522			return value;
523		case "string": try {
524			if (value === "") throw new Error("empty string");
525			return getNumber(BigInt(value), name);
526		} catch (e) {
527			assertArgument(false, `invalid numeric string: ${e.message}`, name || "value", value);
528		}
529	}
530	assertArgument(false, "invalid numeric value", name || "value", value);
531}
532/**
533*  Converts %%value%% to a number. If %%value%% is a Uint8Array, it
534*  is treated as Big Endian data. Throws if the value is not safe.
535*/
536function toNumber(value) {
537	return getNumber(toBigInt(value));
538}
539/**
540*  Converts %%value%% to a Big Endian hexstring, optionally padded to
541*  %%width%% bytes.
542*/
543function toBeHex(_value, _width) {
544	const value = getUint(_value, "value");
545	let result = value.toString(16);
546	if (_width == null) {
547		if (result.length % 2) result = "0" + result;
548	} else {
549		const width = getNumber(_width, "width");
550		if (width === 0 && value === BN_0$10) return "0x";
551		assert(width * 2 >= result.length, `value exceeds width (${width} bytes)`, "NUMERIC_FAULT", {
552			operation: "toBeHex",
553			fault: "overflow",
554			value: _value
555		});
556		while (result.length < width * 2) result = "0" + result;
557	}
558	return "0x" + result;
559}
560/**
561*  Converts %%value%% to a Big Endian Uint8Array.
562*/
563function toBeArray(_value, _width) {
564	const value = getUint(_value, "value");
565	if (value === BN_0$10) {
566		const width = _width != null ? getNumber(_width, "width") : 0;
567		return new Uint8Array(width);
568	}
569	let hex = value.toString(16);
570	if (hex.length % 2) hex = "0" + hex;
571	if (_width != null) {
572		const width = getNumber(_width, "width");
573		while (hex.length < width * 2) hex = "00" + hex;
574		assert(width * 2 === hex.length, `value exceeds width (${width} bytes)`, "NUMERIC_FAULT", {
575			operation: "toBeArray",
576			fault: "overflow",
577			value: _value
578		});
579	}
580	const result = new Uint8Array(hex.length / 2);
581	for (let i = 0; i < result.length; i++) {
582		const offset = i * 2;
583		result[i] = parseInt(hex.substring(offset, offset + 2), 16);
584	}
585	return result;
586}
587/**
588*  Returns a [[HexString]] for %%value%% safe to use as a //Quantity//.
589*
590*  A //Quantity// does not have and leading 0 values unless the value is
591*  the literal value `0x0`. This is most commonly used for JSSON-RPC
592*  numeric values.
593*/
594function toQuantity(value) {
595	let result = hexlify(isBytesLike(value) ? value : toBeArray(value)).substring(2);
596	while (result.startsWith("0")) result = result.substring(1);
597	if (result === "") result = "0";
598	return "0x" + result;
599}
600//#endregion
601//#region node_modules/ethers/lib.esm/utils/base58.js
602/**
603*  The [Base58 Encoding](link-base58) scheme allows a **numeric** value
604*  to be encoded as a compact string using a radix of 58 using only
605*  alpha-numeric characters. Confusingly similar characters are omitted
606*  (i.e. ``"l0O"``).
607*
608*  Note that Base58 encodes a **numeric** value, not arbitrary bytes,
609*  since any zero-bytes on the left would get removed. To mitigate this
610*  issue most schemes that use Base58 choose specific high-order values
611*  to ensure non-zero prefixes.
612*
613*  @_subsection: api/utils:Base58 Encoding [about-base58]
614*/
615var Alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
616var Lookup = null;
617function getAlpha(letter) {
618	if (Lookup == null) {
619		Lookup = {};
620		for (let i = 0; i < 58; i++) Lookup[Alphabet[i]] = BigInt(i);
621	}
622	const result = Lookup[letter];
623	assertArgument(result != null, `invalid base58 value`, "letter", letter);
624	return result;
625}
626var BN_0$9 = BigInt(0);
627var BN_58 = BigInt(58);
628/**
629*  Encode %%value%% as a Base58-encoded string.
630*/
631function encodeBase58(_value) {
632	const bytes = getBytes(_value);
633	let value = toBigInt(bytes);
634	let result = "";
635	while (value) {
636		result = Alphabet[Number(value % BN_58)] + result;
637		value /= BN_58;
638	}
639	for (let i = 0; i < bytes.length; i++) {
640		if (bytes[i]) break;
641		result = Alphabet[0] + result;
642	}
643	return result;
644}
645/**
646*  Decode the Base58-encoded %%value%%.
647*/
648function decodeBase58(value) {
649	let result = BN_0$9;
650	for (let i = 0; i < value.length; i++) {
651		result *= BN_58;
652		result += getAlpha(value[i]);
653	}
654	return result;
655}
656//#endregion
657//#region node_modules/ethers/lib.esm/utils/base64-browser.js
658function decodeBase64(textData) {
659	textData = atob(textData);
660	const data = new Uint8Array(textData.length);
661	for (let i = 0; i < textData.length; i++) data[i] = textData.charCodeAt(i);
662	return getBytes(data);
663}
664function encodeBase64(_data) {
665	const data = getBytes(_data);
666	let textData = "";
667	for (let i = 0; i < data.length; i++) textData += String.fromCharCode(data[i]);
668	return btoa(textData);
669}
670//#endregion
671//#region node_modules/ethers/lib.esm/utils/events.js
672/**
673*  Events allow for applications to use the observer pattern, which
674*  allows subscribing and publishing events, outside the normal
675*  execution paths.
676*
677*  @_section api/utils/events:Events  [about-events]
678*/
679/**
680*  When an [[EventEmitterable]] triggers a [[Listener]], the
681*  callback always ahas one additional argument passed, which is
682*  an **EventPayload**.
683*/
684var EventPayload = class {
685	/**
686	*  The event filter.
687	*/
688	filter;
689	/**
690	*  The **EventEmitterable**.
691	*/
692	emitter;
693	#listener;
694	/**
695	*  Create a new **EventPayload** for %%emitter%% with
696	*  the %%listener%% and for %%filter%%.
697	*/
698	constructor(emitter, listener, filter) {
699		this.#listener = listener;
700		defineProperties(this, {
701			emitter,
702			filter
703		});
704	}
705	/**
706	*  Unregister the triggered listener for future events.
707	*/
708	async removeListener() {
709		if (this.#listener == null) return;
710		await this.emitter.off(this.filter, this.#listener);
711	}
712};
713//#endregion
714//#region node_modules/ethers/lib.esm/utils/utf8.js
715/**

716*  Using strings in Ethereum (or any security-basd system) requires
717*  additional care. These utilities attempt to mitigate some of the
718*  safety issues as well as provide the ability to recover and analyse
719*  strings.
720*
721*  @_subsection api/utils:Strings and UTF-8  [about-strings]
722*/
723function errorFunc(reason, offset, bytes, output, badCodepoint) {
724	assertArgument(false, `invalid codepoint at offset ${offset}; ${reason}`, "bytes", bytes);
725}
726function ignoreFunc(reason, offset, bytes, output, badCodepoint) {
727	if (reason === "BAD_PREFIX" || reason === "UNEXPECTED_CONTINUE") {
728		let i = 0;
729		for (let o = offset + 1; o < bytes.length; o++) {
730			if (bytes[o] >> 6 !== 2) break;
731			i++;
732		}
733		return i;
734	}
735	if (reason === "OVERRUN") return bytes.length - offset - 1;
736	return 0;
737}
738function replaceFunc(reason, offset, bytes, output, badCodepoint) {
739	if (reason === "OVERLONG") {
740		assertArgument(typeof badCodepoint === "number", "invalid bad code point for replacement", "badCodepoint", badCodepoint);
741		output.push(badCodepoint);
742		return 0;
743	}
744	output.push(65533);
745	return ignoreFunc(reason, offset, bytes, output, badCodepoint);
746}
747/**
748*  A handful of popular, built-in UTF-8 error handling strategies.
749*
750*  **``"error"``** - throws on ANY illegal UTF-8 sequence or
751*  non-canonical (overlong) codepoints (this is the default)
752*
753*  **``"ignore"``** - silently drops any illegal UTF-8 sequence
754*  and accepts non-canonical (overlong) codepoints
755*
756*  **``"replace"``** - replace any illegal UTF-8 sequence with the
757*  UTF-8 replacement character (i.e. ``"\\ufffd"``) and accepts
758*  non-canonical (overlong) codepoints
759*
760*  @returns: Record<"error" | "ignore" | "replace", Utf8ErrorFunc>
761*/
762var Utf8ErrorFuncs = Object.freeze({
763	error: errorFunc,
764	ignore: ignoreFunc,
765	replace: replaceFunc
766});
767function getUtf8CodePoints(_bytes, onError) {
768	if (onError == null) onError = Utf8ErrorFuncs.error;
769	const bytes = getBytes(_bytes, "bytes");
770	const result = [];
771	let i = 0;
772	while (i < bytes.length) {
773		const c = bytes[i++];
774		if (c >> 7 === 0) {
775			result.push(c);
776			continue;
777		}
778		let extraLength = null;
779		let overlongMask = null;
780		if ((c & 224) === 192) {
781			extraLength = 1;
782			overlongMask = 127;
783		} else if ((c & 240) === 224) {
784			extraLength = 2;
785			overlongMask = 2047;
786		} else if ((c & 248) === 240) {
787			extraLength = 3;
788			overlongMask = 65535;
789		} else {
790			if ((c & 192) === 128) i += onError("UNEXPECTED_CONTINUE", i - 1, bytes, result);
791			else i += onError("BAD_PREFIX", i - 1, bytes, result);
792			continue;
793		}
794		if (i - 1 + extraLength >= bytes.length) {
795			i += onError("OVERRUN", i - 1, bytes, result);
796			continue;
797		}
798		let res = c & (1 << 8 - extraLength - 1) - 1;
799		for (let j = 0; j < extraLength; j++) {
800			let nextChar = bytes[i];
801			if ((nextChar & 192) != 128) {
802				i += onError("MISSING_CONTINUE", i, bytes, result);
803				res = null;
804				break;
805			}
806			res = res << 6 | nextChar & 63;
807			i++;
808		}
809		if (res === null) continue;
810		if (res > 1114111) {
811			i += onError("OUT_OF_RANGE", i - 1 - extraLength, bytes, result, res);
812			continue;
813		}
814		if (res >= 55296 && res <= 57343) {
815			i += onError("UTF16_SURROGATE", i - 1 - extraLength, bytes, result, res);
816			continue;
817		}
818		if (res <= overlongMask) {
819			i += onError("OVERLONG", i - 1 - extraLength, bytes, result, res);
820			continue;
821		}
822		result.push(res);
823	}
824	return result;
825}
826/**
827*  Returns the UTF-8 byte representation of %%str%%.
828*
829*  If %%form%% is specified, the string is normalized.
830*/
831function toUtf8Bytes(str, form) {
832	assertArgument(typeof str === "string", "invalid string value", "str", str);
833	if (form != null) {
834		assertNormalize(form);
835		str = str.normalize(form);
836	}
837	let result = [];
838	for (let i = 0; i < str.length; i++) {
839		const c = str.charCodeAt(i);
840		if (c < 128) result.push(c);
841		else if (c < 2048) {
842			result.push(c >> 6 | 192);
843			result.push(c & 63 | 128);
844		} else if ((c & 64512) == 55296) {
845			i++;
846			const c2 = str.charCodeAt(i);
847			assertArgument(i < str.length && (c2 & 64512) === 56320, "invalid surrogate pair", "str", str);
848			const pair = 65536 + ((c & 1023) << 10) + (c2 & 1023);
849			result.push(pair >> 18 | 240);
850			result.push(pair >> 12 & 63 | 128);
851			result.push(pair >> 6 & 63 | 128);
852			result.push(pair & 63 | 128);
853		} else {
854			result.push(c >> 12 | 224);
855			result.push(c >> 6 & 63 | 128);
856			result.push(c & 63 | 128);
857		}
858	}
859	return new Uint8Array(result);
860}
861function _toUtf8String(codePoints) {
862	return codePoints.map((codePoint) => {
863		if (codePoint <= 65535) return String.fromCharCode(codePoint);
864		codePoint -= 65536;
865		return String.fromCharCode((codePoint >> 10 & 1023) + 55296, (codePoint & 1023) + 56320);
866	}).join("");
867}
868/**
869*  Returns the string represented by the UTF-8 data %%bytes%%.
870*
871*  When %%onError%% function is specified, it is called on UTF-8
872*  errors allowing recovery using the [[Utf8ErrorFunc]] API.
873*  (default: [error](Utf8ErrorFuncs))
874*/
875function toUtf8String(bytes, onError) {
876	return _toUtf8String(getUtf8CodePoints(bytes, onError));
877}
878/**
879*  Returns the UTF-8 code-points for %%str%%.
880*
881*  If %%form%% is specified, the string is normalized.
882*/
883function toUtf8CodePoints(str, form) {
884	return getUtf8CodePoints(toUtf8Bytes(str, form));
885}
886//#endregion
887//#region node_modules/ethers/lib.esm/utils/geturl-browser.js
888function createGetUrl(options) {
889	async function getUrl(req, _signal) {
890		assert(_signal == null || !_signal.cancelled, "request cancelled before sending", "CANCELLED");
891		const protocol = req.url.split(":")[0].toLowerCase();
892		assert(protocol === "http" || protocol === "https", `unsupported protocol ${protocol}`, "UNSUPPORTED_OPERATION", {
893			info: { protocol },
894			operation: "request"
895		});
896		assert(protocol === "https" || !req.credentials || req.allowInsecureAuthentication, "insecure authorized connections unsupported", "UNSUPPORTED_OPERATION", { operation: "request" });
897		let error = null;
898		const controller = new AbortController();
899		const timer = setTimeout(() => {
900			error = makeError("request timeout", "TIMEOUT");
901			controller.abort();
902		}, req.timeout);
903		if (_signal) _signal.addListener(() => {
904			error = makeError("request cancelled", "CANCELLED");
905			controller.abort();
906		});
907		const init = Object.assign({}, options, {
908			method: req.method,
909			headers: new Headers(Array.from(req)),
910			body: req.body || void 0,
911			signal: controller.signal
912		});
913		let resp;
914		try {
915			resp = await fetch(req.url, init);
916		} catch (_error) {
917			clearTimeout(timer);
918			if (error) throw error;
919			throw _error;
920		}
921		clearTimeout(timer);
922		const headers = {};

923		resp.headers.forEach((value, key) => {
924			headers[key.toLowerCase()] = value;
925		});
926		const respBody = await resp.arrayBuffer();
927		const body = respBody == null ? null : new Uint8Array(respBody);
928		return {
929			statusCode: resp.status,
930			statusMessage: resp.statusText,
931			headers,
932			body
933		};
934	}
935	return getUrl;
936}
937//#endregion
938//#region node_modules/ethers/lib.esm/utils/fetch.js
939/**
940*  Fetching content from the web is environment-specific, so Ethers
941*  provides an abstraction that each environment can implement to provide
942*  this service.
943*
944*  On [Node.js](link-node), the ``http`` and ``https`` libs are used to
945*  create a request object, register event listeners and process data
946*  and populate the [[FetchResponse]].
947*
948*  In a browser, the [DOM fetch](link-js-fetch) is used, and the resulting
949*  ``Promise`` is waited on to retrieve the payload.
950*
951*  The [[FetchRequest]] is responsible for handling many common situations,
952*  such as redirects, server throttling, authentication, etc.
953*
954*  It also handles common gateways, such as IPFS and data URIs.
955*
956*  @_section api/utils/fetching:Fetching Web Content  [about-fetch]
957*/
958var MAX_ATTEMPTS = 12;
959var SLOT_INTERVAL = 250;
960var defaultGetUrlFunc = createGetUrl();
961var reData = /* @__PURE__ */ new RegExp("^data:([^;:]*)?(;base64)?,(.*)$", "i");
962var reIpfs = /* @__PURE__ */ new RegExp("^ipfs://(ipfs/)?(.*)$", "i");
963var locked$5 = false;
964async function dataGatewayFunc(url, signal) {
965	try {
966		const match = url.match(reData);
967		if (!match) throw new Error("invalid data");
968		return new FetchResponse(200, "OK", { "content-type": match[1] || "text/plain" }, match[2] ? decodeBase64(match[3]) : unpercent(match[3]));
969	} catch (error) {
970		return new FetchResponse(599, "BAD REQUEST (invalid data: URI)", {}, null, new FetchRequest(url));
971	}
972}
973/**
974*  Returns a [[FetchGatewayFunc]] for fetching content from a standard
975*  IPFS gateway hosted at %%baseUrl%%.
976*/
977function getIpfsGatewayFunc(baseUrl) {
978	async function gatewayIpfs(url, signal) {
979		try {
980			const match = url.match(reIpfs);
981			if (!match) throw new Error("invalid link");
982			return new FetchRequest(`${baseUrl}${match[2]}`);
983		} catch (error) {
984			return new FetchResponse(599, "BAD REQUEST (invalid IPFS URI)", {}, null, new FetchRequest(url));
985		}
986	}
987	return gatewayIpfs;
988}
989var Gateways = {
990	"data": dataGatewayFunc,
991	"ipfs": getIpfsGatewayFunc("https://gateway.ipfs.io/ipfs/")
992};
993var fetchSignals = /* @__PURE__ */ new WeakMap();
994/**
995*  @_ignore
996*/
997var FetchCancelSignal = class {
998	#listeners;
999	#cancelled;
1000	constructor(request) {
1001		this.#listeners = [];
1002		this.#cancelled = false;
1003		fetchSignals.set(request, () => {
1004			if (this.#cancelled) return;
1005			this.#cancelled = true;
1006			for (const listener of this.#listeners) setTimeout(() => {
1007				listener();
1008			}, 0);
1009			this.#listeners = [];
1010		});
1011	}
1012	addListener(listener) {
1013		assert(!this.#cancelled, "singal already cancelled", "UNSUPPORTED_OPERATION", { operation: "fetchCancelSignal.addCancelListener" });
1014		this.#listeners.push(listener);
1015	}
1016	get cancelled() {
1017		return this.#cancelled;
1018	}
1019	checkSignal() {
1020		assert(!this.cancelled, "cancelled", "CANCELLED", {});
1021	}
1022};
1023function checkSignal(signal) {
1024	if (signal == null) throw new Error("missing signal; should not happen");
1025	signal.checkSignal();
1026	return signal;
1027}
1028/**
1029*  Represents a request for a resource using a URI.
1030*
1031*  By default, the supported schemes are ``HTTP``, ``HTTPS``, ``data:``,
1032*  and ``IPFS:``.
1033*
1034*  Additional schemes can be added globally using [[registerGateway]].
1035*
1036*  @example:
1037*    req = new FetchRequest("https://www.ricmoo.com")
1038*    resp = await req.send()
1039*    resp.body.length
1040*    //_result:
1041*/
1042var FetchRequest = class FetchRequest {
1043	#allowInsecure;
1044	#gzip;
1045	#headers;
1046	#method;
1047	#timeout;
1048	#url;
1049	#body;
1050	#bodyType;
1051	#creds;
1052	#preflight;
1053	#process;
1054	#retry;
1055	#signal;
1056	#throttle;
1057	#getUrlFunc;
1058	/**
1059	*  The fetch URL to request.
1060	*/
1061	get url() {
1062		return this.#url;
1063	}
1064	set url(url) {
1065		this.#url = String(url);
1066	}
1067	/**
1068	*  The fetch body, if any, to send as the request body. //(default: null)//
1069	*
1070	*  When setting a body, the intrinsic ``Content-Type`` is automatically
1071	*  set and will be used if **not overridden** by setting a custom
1072	*  header.
1073	*
1074	*  If %%body%% is null, the body is cleared (along with the
1075	*  intrinsic ``Content-Type``).
1076	*
1077	*  If %%body%% is a string, the intrinsic ``Content-Type`` is set to
1078	*  ``text/plain``.
1079	*
1080	*  If %%body%% is a Uint8Array, the intrinsic ``Content-Type`` is set to
1081	*  ``application/octet-stream``.
1082	*
1083	*  If %%body%% is any other object, the intrinsic ``Content-Type`` is
1084	*  set to ``application/json``.
1085	*/
1086	get body() {
1087		if (this.#body == null) return null;
1088		return new Uint8Array(this.#body);
1089	}
1090	set body(body) {
1091		if (body == null) {
1092			this.#body = void 0;
1093			this.#bodyType = void 0;
1094		} else if (typeof body === "string") {
1095			this.#body = toUtf8Bytes(body);
1096			this.#bodyType = "text/plain";
1097		} else if (body instanceof Uint8Array) {
1098			this.#body = body;
1099			this.#bodyType = "application/octet-stream";
1100		} else if (typeof body === "object") {
1101			this.#body = toUtf8Bytes(JSON.stringify(body));
1102			this.#bodyType = "application/json";
1103		} else throw new Error("invalid body");
1104	}
1105	/**
1106	*  Returns true if the request has a body.
1107	*/
1108	hasBody() {
1109		return this.#body != null;
1110	}

1111	/**
1112	*  The HTTP method to use when requesting the URI. If no method
1113	*  has been explicitly set, then ``GET`` is used if the body is
1114	*  null and ``POST`` otherwise.
1115	*/
1116	get method() {
1117		if (this.#method) return this.#method;
1118		if (this.hasBody()) return "POST";
1119		return "GET";
1120	}
1121	set method(method) {
1122		if (method == null) method = "";
1123		this.#method = String(method).toUpperCase();
1124	}
1125	/**
1126	*  The headers that will be used when requesting the URI. All
1127	*  keys are lower-case.
1128	*
1129	*  This object is a copy, so any changes will **NOT** be reflected
1130	*  in the ``FetchRequest``.
1131	*
1132	*  To set a header entry, use the ``setHeader`` method.
1133	*/
1134	get headers() {
1135		const headers = Object.assign({}, this.#headers);
1136		if (this.#creds) headers["authorization"] = `Basic ${encodeBase64(toUtf8Bytes(this.#creds))}`;
1137		if (this.allowGzip) headers["accept-encoding"] = "gzip";
1138		if (headers["content-type"] == null && this.#bodyType) headers["content-type"] = this.#bodyType;
1139		if (this.body) headers["content-length"] = String(this.body.length);
1140		return headers;
1141	}
1142	/**
1143	*  Get the header for %%key%%, ignoring case.
1144	*/
1145	getHeader(key) {
1146		return this.headers[key.toLowerCase()];
1147	}
1148	/**
1149	*  Set the header for %%key%% to %%value%%. All values are coerced
1150	*  to a string.
1151	*/
1152	setHeader(key, value) {
1153		this.#headers[String(key).toLowerCase()] = String(value);
1154	}
1155	/**
1156	*  Clear all headers, resetting all intrinsic headers.
1157	*/
1158	clearHeaders() {
1159		this.#headers = {};
1160	}
1161	[Symbol.iterator]() {
1162		const headers = this.headers;
1163		const keys = Object.keys(headers);
1164		let index = 0;
1165		return { next: () => {
1166			if (index < keys.length) {
1167				const key = keys[index++];
1168				return {
1169					value: [key, headers[key]],
1170					done: false
1171				};
1172			}
1173			return {
1174				value: void 0,
1175				done: true
1176			};
1177		} };
1178	}
1179	/**
1180	*  The value that will be sent for the ``Authorization`` header.
1181	*
1182	*  To set the credentials, use the ``setCredentials`` method.
1183	*/
1184	get credentials() {
1185		return this.#creds || null;
1186	}
1187	/**
1188	*  Sets an ``Authorization`` for %%username%% with %%password%%.
1189	*/
1190	setCredentials(username, password) {
1191		assertArgument(!username.match(/:/), "invalid basic authentication username", "username", "[REDACTED]");
1192		this.#creds = `${username}:${password}`;
1193	}

1194	/**
1195	*  Enable and request gzip-encoded responses. The response will
1196	*  automatically be decompressed. //(default: true)//
1197	*/
1198	get allowGzip() {
1199		return this.#gzip;
1200	}
1201	set allowGzip(value) {
1202		this.#gzip = !!value;
1203	}
1204	/**
1205	*  Allow ``Authentication`` credentials to be sent over insecure
1206	*  channels. //(default: false)//
1207	*/
1208	get allowInsecureAuthentication() {
1209		return !!this.#allowInsecure;
1210	}
1211	set allowInsecureAuthentication(value) {
1212		this.#allowInsecure = !!value;
1213	}
1214	/**
1215	*  The timeout (in milliseconds) to wait for a complete response.
1216	*  //(default: 5 minutes)//
1217	*/
1218	get timeout() {
1219		return this.#timeout;
1220	}
1221	set timeout(timeout) {
1222		assertArgument(timeout >= 0, "timeout must be non-zero", "timeout", timeout);
1223		this.#timeout = timeout;
1224	}
1225	/**
1226	*  This function is called prior to each request, for example
1227	*  during a redirection or retry in case of server throttling.
1228	*
1229	*  This offers an opportunity to populate headers or update
1230	*  content before sending a request.
1231	*/
1232	get preflightFunc() {
1233		return this.#preflight || null;
1234	}
1235	set preflightFunc(preflight) {
1236		this.#preflight = preflight;
1237	}
1238	/**
1239	*  This function is called after each response, offering an
1240	*  opportunity to provide client-level throttling or updating
1241	*  response data.
1242	*
1243	*  Any error thrown in this causes the ``send()`` to throw.
1244	*
1245	*  To schedule a retry attempt (assuming the maximum retry limit
1246	*  has not been reached), use [[response.throwThrottleError]].
1247	*/
1248	get processFunc() {
1249		return this.#process || null;
1250	}
1251	set processFunc(process) {
1252		this.#process = process;
1253	}
1254	/**
1255	*  This function is called on each retry attempt.
1256	*/
1257	get retryFunc() {
1258		return this.#retry || null;
1259	}
1260	set retryFunc(retry) {
1261		this.#retry = retry;
1262	}
1263	/**
1264	*  This function is called to fetch content from HTTP and
1265	*  HTTPS URLs and is platform specific (e.g. nodejs vs
1266	*  browsers).
1267	*
1268	*  This is by default the currently registered global getUrl
1269	*  function, which can be changed using [[registerGetUrl]].
1270	*  If this has been set, setting is to ``null`` will cause
1271	*  this FetchRequest (and any future clones) to revert back to
1272	*  using the currently registered global getUrl function.
1273	*
1274	*  Setting this is generally not necessary, but may be useful
1275	*  for developers that wish to intercept requests or to
1276	*  configurege a proxy or other agent.
1277	*/
1278	get getUrlFunc() {
1279		return this.#getUrlFunc || defaultGetUrlFunc;
1280	}
1281	set getUrlFunc(value) {
1282		this.#getUrlFunc = value;
1283	}
1284	/**
1285	*  Create a new FetchRequest instance with default values.
1286	*
1287	*  Once created, each property may be set before issuing a
1288	*  ``.send()`` to make the request.
1289	*/
1290	constructor(url) {
1291		this.#url = String(url);
1292		this.#allowInsecure = false;
1293		this.#gzip = true;
1294		this.#headers = {};
1295		this.#method = "";
1296		this.#timeout = 3e5;
1297		this.#throttle = {
1298			slotInterval: SLOT_INTERVAL,
1299			maxAttempts: MAX_ATTEMPTS
1300		};
1301		this.#getUrlFunc = null;
1302	}
1303	toString() {
1304		return `<FetchRequest method=${JSON.stringify(this.method)} url=${JSON.stringify(this.url)} headers=${JSON.stringify(this.headers)} body=${this.#body ? hexlify(this.#body) : "null"}>`;
1305	}
1306	/**
1307	*  Update the throttle parameters used to determine maximum
1308	*  attempts and exponential-backoff properties.
1309	*/
1310	setThrottleParams(params) {
1311		if (params.slotInterval != null) this.#throttle.slotInterval = params.slotInterval;
1312		if (params.maxAttempts != null) this.#throttle.maxAttempts = params.maxAttempts;
1313	}
1314	async #send(attempt, expires, delay, _request, _response) {
1315		if (attempt >= this.#throttle.maxAttempts) return _response.makeServerError("exceeded maximum retry limit");
1316		assert(getTime$2() <= expires, "timeout", "TIMEOUT", {
1317			operation: "request.send",
1318			reason: "timeout",
1319			request: _request
1320		});
1321		if (delay > 0) await wait(delay);
1322		let req = this.clone();
1323		const scheme = (req.url.split(":")[0] || "").toLowerCase();
1324		if (scheme in Gateways) {
1325			const result = await Gateways[scheme](req.url, checkSignal(_request.#signal));
1326			if (result instanceof FetchResponse) {
1327				let response = result;
1328				if (this.processFunc) {
1329					checkSignal(_request.#signal);
1330					try {
1331						response = await this.processFunc(req, response);
1332					} catch (error) {
1333						if (error.throttle == null || typeof error.stall !== "number") response.makeServerError("error in post-processing function", error).assertOk();
1334					}
1335				}
1336				return response;
1337			}
1338			req = result;
1339		}
1340		if (this.preflightFunc) req = await this.preflightFunc(req);
1341		const resp = await this.getUrlFunc(req, checkSignal(_request.#signal));
1342		let response = new FetchResponse(resp.statusCode, resp.statusMessage, resp.headers, resp.body, _request);
1343		if ([
1344			301,
1345			302,
1346			307,
1347			308
1348		].indexOf(response.statusCode) >= 0) {
1349			try {
1350				const location = response.headers.location || "";
1351				return req.redirect(location).#send(attempt + 1, expires, 0, _request, response);
1352			} catch (error) {}
1353			return response;
1354		} else if (response.statusCode === 429) {
1355			if (this.retryFunc == null || await this.retryFunc(req, response, attempt)) {
1356				const retryAfter = response.headers["retry-after"];
1357				let delay = this.#throttle.slotInterval * Math.trunc(Math.random() * Math.pow(2, attempt));
1358				if (typeof retryAfter === "string" && retryAfter.match(/^[1-9][0-9]*$/)) delay = parseInt(retryAfter);
1359				return req.clone().#send(attempt + 1, expires, delay, _request, response);
1360			}
1361		}
1362		if (this.processFunc) {
1363			checkSignal(_request.#signal);
1364			try {
1365				response = await this.processFunc(req, response);
1366			} catch (error) {
1367				if (error.throttle == null || typeof error.stall !== "number") response.makeServerError("error in post-processing function", error).assertOk();
1368				let delay = this.#throttle.slotInterval * Math.trunc(Math.random() * Math.pow(2, attempt));
1369				if (error.stall >= 0) delay = error.stall;
1370				return req.clone().#send(attempt + 1, expires, delay, _request, response);
1371			}
1372		}
1373		return response;
1374	}

1375	/**
1376	*  Resolves to the response by sending the request.
1377	*/
1378	send() {
1379		assert(this.#signal == null, "request already sent", "UNSUPPORTED_OPERATION", { operation: "fetchRequest.send" });
1380		this.#signal = new FetchCancelSignal(this);
1381		return this.#send(0, getTime$2() + this.timeout, 0, this, new FetchResponse(0, "", {}, null, this));
1382	}
1383	/**
1384	*  Cancels the inflight response, causing a ``CANCELLED``
1385	*  error to be rejected from the [[send]].
1386	*/
1387	cancel() {
1388		assert(this.#signal != null, "request has not been sent", "UNSUPPORTED_OPERATION", { operation: "fetchRequest.cancel" });
1389		const signal = fetchSignals.get(this);
1390		if (!signal) throw new Error("missing signal; should not happen");
1391		signal();
1392	}
1393	/**
1394	*  Returns a new [[FetchRequest]] that represents the redirection
1395	*  to %%location%%.
1396	*/
1397	redirect(location) {
1398		const current = this.url.split(":")[0].toLowerCase();
1399		const target = location.split(":")[0].toLowerCase();
1400		assert((current !== "https" || target !== "http") && location.match(/^https?:/), `unsupported redirect`, "UNSUPPORTED_OPERATION", { operation: `redirect(${this.method} ${JSON.stringify(this.url)} => ${JSON.stringify(location)})` });
1401		const req = new FetchRequest(location);
1402		req.method = this.method;
1403		req.allowGzip = this.allowGzip;
1404		req.timeout = this.timeout;
1405		req.#headers = Object.assign({}, this.#headers);
1406		if (this.#body) req.#body = new Uint8Array(this.#body);
1407		req.#bodyType = this.#bodyType;
1408		return req;
1409	}
1410	/**
1411	*  Create a new copy of this request.
1412	*/
1413	clone() {
1414		const clone = new FetchRequest(this.url);
1415		clone.#method = this.#method;
1416		if (this.#body) clone.#body = this.#body;
1417		clone.#bodyType = this.#bodyType;
1418		clone.#headers = Object.assign({}, this.#headers);
1419		clone.#creds = this.#creds;
1420		if (this.allowGzip) clone.allowGzip = true;
1421		clone.timeout = this.timeout;
1422		if (this.allowInsecureAuthentication) clone.allowInsecureAuthentication = true;
1423		clone.#preflight = this.#preflight;
1424		clone.#process = this.#process;
1425		clone.#retry = this.#retry;
1426		clone.#throttle = Object.assign({}, this.#throttle);
1427		clone.#getUrlFunc = this.#getUrlFunc;
1428		return clone;
1429	}
1430	/**
1431	*  Locks all static configuration for gateways and FetchGetUrlFunc
1432	*  registration.
1433	*/
1434	static lockConfig() {
1435		locked$5 = true;
1436	}
1437	/**
1438	*  Get the current Gateway function for %%scheme%%.
1439	*/
1440	static getGateway(scheme) {
1441		return Gateways[scheme.toLowerCase()] || null;
1442	}
1443	/**
1444	*  Use the %%func%% when fetching URIs using %%scheme%%.
1445	*
1446	*  This method affects all requests globally.
1447	*
1448	*  If [[lockConfig]] has been called, no change is made and this
1449	*  throws.
1450	*/
1451	static registerGateway(scheme, func) {
1452		scheme = scheme.toLowerCase();
1453		if (scheme === "http" || scheme === "https") throw new Error(`cannot intercept ${scheme}; use registerGetUrl`);
1454		if (locked$5) throw new Error("gateways locked");
1455		Gateways[scheme] = func;
1456	}
1457	/**
1458	*  Use %%getUrl%% when fetching URIs over HTTP and HTTPS requests.
1459	*
1460	*  This method affects all requests globally.
1461	*
1462	*  If [[lockConfig]] has been called, no change is made and this
1463	*  throws.
1464	*/
1465	static registerGetUrl(getUrl) {
1466		if (locked$5) throw new Error("gateways locked");
1467		defaultGetUrlFunc = getUrl;
1468	}
1469	/**
1470	*  Creates a getUrl function that fetches content from HTTP and
1471	*  HTTPS URLs.
1472	*
1473	*  The available %%options%% are dependent on the platform
1474	*  implementation of the default getUrl function.
1475	*
1476	*  This is not generally something that is needed, but is useful
1477	*  when trying to customize simple behaviour when fetching HTTP
1478	*  content.
1479	*/
1480	static createGetUrlFunc(options) {
1481		return createGetUrl(options);
1482	}
1483	/**
1484	*  Creates a function that can "fetch" data URIs.
1485	*
1486	*  Note that this is automatically done internally to support
1487	*  data URIs, so it is not necessary to register it.
1488	*
1489	*  This is not generally something that is needed, but may
1490	*  be useful in a wrapper to perfom custom data URI functionality.
1491	*/
1492	static createDataGateway() {
1493		return dataGatewayFunc;
1494	}
1495	/**
1496	*  Creates a function that will fetch IPFS (unvalidated) from
1497	*  a custom gateway baseUrl.
1498	*
1499	*  The default IPFS gateway used internally is
1500	*  ``"https:/\/gateway.ipfs.io/ipfs/"``.
1501	*/
1502	static createIpfsGatewayFunc(baseUrl) {
1503		return getIpfsGatewayFunc(baseUrl);
1504	}
1505};
1506/**
1507*  The response for a FetchRequest.
1508*/
1509var FetchResponse = class FetchResponse {
1510	#statusCode;
1511	#statusMessage;
1512	#headers;
1513	#body;
1514	#request;
1515	#error;
1516	toString() {
1517		return `<FetchResponse status=${this.statusCode} body=${this.#body ? hexlify(this.#body) : "null"}>`;
1518	}

1519	/**
1520	*  The response status code.
1521	*/
1522	get statusCode() {
1523		return this.#statusCode;
1524	}
1525	/**
1526	*  The response status message.
1527	*/
1528	get statusMessage() {
1529		return this.#statusMessage;
1530	}
1531	/**
1532	*  The response headers. All keys are lower-case.
1533	*/
1534	get headers() {
1535		return Object.assign({}, this.#headers);
1536	}
1537	/**
1538	*  The response body, or ``null`` if there was no body.
1539	*/
1540	get body() {
1541		return this.#body == null ? null : new Uint8Array(this.#body);
1542	}
1543	/**
1544	*  The response body as a UTF-8 encoded string, or the empty
1545	*  string (i.e. ``""``) if there was no body.
1546	*
1547	*  An error is thrown if the body is invalid UTF-8 data.
1548	*/
1549	get bodyText() {
1550		try {
1551			return this.#body == null ? "" : toUtf8String(this.#body);
1552		} catch (error) {
1553			assert(false, "response body is not valid UTF-8 data", "UNSUPPORTED_OPERATION", {
1554				operation: "bodyText",
1555				info: { response: this }
1556			});
1557		}
1558	}
1559	/**
1560	*  The response body, decoded as JSON.
1561	*
1562	*  An error is thrown if the body is invalid JSON-encoded data
1563	*  or if there was no body.
1564	*/
1565	get bodyJson() {
1566		try {
1567			return JSON.parse(this.bodyText);
1568		} catch (error) {
1569			assert(false, "response body is not valid JSON", "UNSUPPORTED_OPERATION", {
1570				operation: "bodyJson",
1571				info: { response: this }
1572			});
1573		}
1574	}
1575	[Symbol.iterator]() {
1576		const headers = this.headers;
1577		const keys = Object.keys(headers);
1578		let index = 0;
1579		return { next: () => {
1580			if (index < keys.length) {
1581				const key = keys[index++];
1582				return {
1583					value: [key, headers[key]],
1584					done: false
1585				};
1586			}
1587			return {
1588				value: void 0,
1589				done: true
1590			};
1591		} };
1592	}
1593	constructor(statusCode, statusMessage, headers, body, request) {
1594		this.#statusCode = statusCode;
1595		this.#statusMessage = statusMessage;
1596		this.#headers = Object.keys(headers).reduce((accum, k) => {
1597			accum[k.toLowerCase()] = String(headers[k]);
1598			return accum;
1599		}, {});
1600		this.#body = body == null ? null : new Uint8Array(body);
1601		this.#request = request || null;
1602		this.#error = { message: "" };
1603	}
1604	/**
1605	*  Return a Response with matching headers and body, but with
1606	*  an error status code (i.e. 599) and %%message%% with an
1607	*  optional %%error%%.
1608	*/
1609	makeServerError(message, error) {
1610		let statusMessage;
1611		if (!message) {
1612			message = `${this.statusCode} ${this.statusMessage}`;
1613			statusMessage = `CLIENT ESCALATED SERVER ERROR (${message})`;
1614		} else statusMessage = `CLIENT ESCALATED SERVER ERROR (${this.statusCode} ${this.statusMessage}; ${message})`;
1615		const response = new FetchResponse(599, statusMessage, this.headers, this.body, this.#request || void 0);
1616		response.#error = {
1617			message,
1618			error
1619		};
1620		return response;
1621	}
1622	/**
1623	*  If called within a [request.processFunc](FetchRequest-processFunc)
1624	*  call, causes the request to retry as if throttled for %%stall%%
1625	*  milliseconds.
1626	*/
1627	throwThrottleError(message, stall) {
1628		if (stall == null) stall = -1;
1629		else assertArgument(Number.isInteger(stall) && stall >= 0, "invalid stall timeout", "stall", stall);
1630		const error = new Error(message || "throttling requests");
1631		defineProperties(error, {
1632			stall,
1633			throttle: true
1634		});
1635		throw error;
1636	}
1637	/**
1638	*  Get the header value for %%key%%, ignoring case.
1639	*/
1640	getHeader(key) {
1641		return this.headers[key.toLowerCase()];
1642	}
1643	/**
1644	*  Returns true if the response has a body.
1645	*/
1646	hasBody() {
1647		return this.#body != null;
1648	}
1649	/**
1650	*  The request made for this response.
1651	*/
1652	get request() {
1653		return this.#request;
1654	}
1655	/**
1656	*  Returns true if this response was a success statusCode.
1657	*/
1658	ok() {
1659		return this.#error.message === "" && this.statusCode >= 200 && this.statusCode < 300;
1660	}
1661	/**
1662	*  Throws a ``SERVER_ERROR`` if this response is not ok.
1663	*/
1664	assertOk() {
1665		if (this.ok()) return;
1666		let { message, error } = this.#error;
1667		if (message === "") message = `server response ${this.statusCode} ${this.statusMessage}`;
1668		let requestUrl = null;
1669		if (this.request) requestUrl = this.request.url;
1670		let responseBody = null;
1671		try {
1672			if (this.#body) responseBody = toUtf8String(this.#body);
1673		} catch (e) {}
1674		assert(false, message, "SERVER_ERROR", {
1675			request: this.request || "unknown request",
1676			response: this,
1677			error,
1678			info: {
1679				requestUrl,
1680				responseBody,
1681				responseStatus: `${this.statusCode} ${this.statusMessage}`
1682			}
1683		});
1684	}
1685};
1686function getTime$2() {
1687	return (/* @__PURE__ */ new Date()).getTime();
1688}
1689function unpercent(value) {
1690	return toUtf8Bytes(value.replace(/%([0-9a-f][0-9a-f])/gi, (all, code) => {
1691		return String.fromCharCode(parseInt(code, 16));
1692	}));
1693}
1694function wait(delay) {
1695	return new Promise((resolve) => setTimeout(resolve, delay));
1696}
1697//#endregion
1698//#region node_modules/ethers/lib.esm/utils/fixednumber.js
1699/**
1700*  The **FixedNumber** class permits using values with decimal places,
1701*  using fixed-pont math.
1702*
1703*  Fixed-point math is still based on integers under-the-hood, but uses an
1704*  internal offset to store fractional components below, and each operation
1705*  corrects for this after each operation.
1706*
1707*  @_section: api/utils/fixed-point-math:Fixed-Point Maths  [about-fixed-point-math]
1708*/
1709var BN_N1 = BigInt(-1);
1710var BN_0$8 = BigInt(0);
1711var BN_1$4 = BigInt(1);
1712var BN_5 = BigInt(5);
1713var _guard$5 = {};
1714var Zeros$1 = "0000";
1715while (Zeros$1.length < 80) Zeros$1 += Zeros$1;
1716function getTens(decimals) {
1717	let result = Zeros$1;
1718	while (result.length < decimals) result += result;
1719	return BigInt("1" + result.substring(0, decimals));
1720}
1721function checkValue(val, format, safeOp) {
1722	const width = BigInt(format.width);
1723	if (format.signed) {
1724		const limit = BN_1$4 << width - BN_1$4;
1725		assert(safeOp == null || val >= -limit && val < limit, "overflow", "NUMERIC_FAULT", {
1726			operation: safeOp,
1727			fault: "overflow",
1728			value: val
1729		});
1730		if (val > BN_0$8) val = fromTwos(mask(val, width), width);
1731		else val = -fromTwos(mask(-val, width), width);
1732	} else {
1733		const limit = BN_1$4 << width;
1734		assert(safeOp == null || val >= 0 && val < limit, "overflow", "NUMERIC_FAULT", {
1735			operation: safeOp,
1736			fault: "overflow",
1737			value: val
1738		});
1739		val = (val % limit + limit) % limit & limit - BN_1$4;
1740	}
1741	return val;
1742}
1743function getFormat(value) {
1744	if (typeof value === "number") value = `fixed128x${value}`;
1745	let signed = true;
1746	let width = 128;
1747	let decimals = 18;
1748	if (typeof value === "string") {
1749		if (value === "fixed") {} else if (value === "ufixed") signed = false;

1750		else {
1751			const match = value.match(/^(u?)fixed([0-9]+)x([0-9]+)$/);
1752			assertArgument(match, "invalid fixed format", "format", value);
1753			signed = match[1] !== "u";
1754			width = parseInt(match[2]);
1755			decimals = parseInt(match[3]);
1756		}
1757	} else if (value) {
1758		const v = value;
1759		const check = (key, type, defaultValue) => {
1760			if (v[key] == null) return defaultValue;
1761			assertArgument(typeof v[key] === type, "invalid fixed format (" + key + " not " + type + ")", "format." + key, v[key]);
1762			return v[key];
1763		};
1764		signed = check("signed", "boolean", signed);
1765		width = check("width", "number", width);
1766		decimals = check("decimals", "number", decimals);
1767	}
1768	assertArgument(width % 8 === 0, "invalid FixedNumber width (not byte aligned)", "format.width", width);
1769	assertArgument(decimals <= 80, "invalid FixedNumber decimals (too large)", "format.decimals", decimals);
1770	const name = (signed ? "" : "u") + "fixed" + String(width) + "x" + String(decimals);
1771	return {
1772		signed,
1773		width,
1774		decimals,
1775		name
1776	};
1777}
1778function toString(val, decimals) {
1779	let negative = "";
1780	if (val < BN_0$8) {
1781		negative = "-";
1782		val *= BN_N1;
1783	}
1784	let str = val.toString();
1785	if (decimals === 0) return negative + str;
1786	while (str.length <= decimals) str = Zeros$1 + str;
1787	const index = str.length - decimals;
1788	str = str.substring(0, index) + "." + str.substring(index);
1789	while (str[0] === "0" && str[1] !== ".") str = str.substring(1);
1790	while (str[str.length - 1] === "0" && str[str.length - 2] !== ".") str = str.substring(0, str.length - 1);
1791	return negative + str;
1792}
1793/**
1794*  A FixedNumber represents a value over its [[FixedFormat]]
1795*  arithmetic field.
1796*
1797*  A FixedNumber can be used to perform math, losslessly, on
1798*  values which have decmial places.
1799*
1800*  A FixedNumber has a fixed bit-width to store values in, and stores all
1801*  values internally by multiplying the value by 10 raised to the power of
1802*  %%decimals%%.
1803*
1804*  If operations are performed that cause a value to grow too high (close to
1805*  positive infinity) or too low (close to negative infinity), the value
1806*  is said to //overflow//.
1807*
1808*  For example, an 8-bit signed value, with 0 decimals may only be within
1809*  the range ``-128`` to ``127``; so ``-128 - 1`` will overflow and become
1810*  ``127``. Likewise, ``127 + 1`` will overflow and become ``-127``.
1811*
1812*  Many operation have a normal and //unsafe// variant. The normal variant
1813*  will throw a [[NumericFaultError]] on any overflow, while the //unsafe//
1814*  variant will silently allow overflow, corrupting its value value.
1815*
1816*  If operations are performed that cause a value to become too small
1817*  (close to zero), the value loses precison and is said to //underflow//.
1818*
1819*  For example, a value with 1 decimal place may store a number as small
1820*  as ``0.1``, but the value of ``0.1 / 2`` is ``0.05``, which cannot fit
1821*  into 1 decimal place, so underflow occurs which means precision is lost
1822*  and the value becomes ``0``.
1823*
1824*  Some operations have a normal and //signalling// variant. The normal
1825*  variant will silently ignore underflow, while the //signalling// variant
1826*  will thow a [[NumericFaultError]] on underflow.
1827*/
1828var FixedNumber = class FixedNumber {
1829	/**
1830	*  The specific fixed-point arithmetic field for this value.
1831	*/
1832	format;
1833	#format;
1834	#val;
1835	#tens;
1836	/**
1837	*  This is a property so console.log shows a human-meaningful value.
1838	*
1839	*  @private
1840	*/
1841	_value;
1842	/**
1843	*  @private
1844	*/
1845	constructor(guard, value, format) {
1846		assertPrivate(guard, _guard$5, "FixedNumber");
1847		this.#val = value;
1848		this.#format = format;
1849		const _value = toString(value, format.decimals);
1850		defineProperties(this, {
1851			format: format.name,
1852			_value
1853		});
1854		this.#tens = getTens(format.decimals);
1855	}
1856	/**
1857	*  If true, negative values are permitted, otherwise only
1858	*  positive values and zero are allowed.
1859	*/
1860	get signed() {
1861		return this.#format.signed;
1862	}
1863	/**
1864	*  The number of bits available to store the value.
1865	*/
1866	get width() {
1867		return this.#format.width;
1868	}
1869	/**
1870	*  The number of decimal places in the fixed-point arithment field.
1871	*/
1872	get decimals() {
1873		return this.#format.decimals;
1874	}
1875	/**
1876	*  The value as an integer, based on the smallest unit the
1877	*  [[decimals]] allow.
1878	*/
1879	get value() {
1880		return this.#val;
1881	}
1882	#checkFormat(other) {
1883		assertArgument(this.format === other.format, "incompatible format; use fixedNumber.toFormat", "other", other);
1884	}
1885	#checkValue(val, safeOp) {
1886		val = checkValue(val, this.#format, safeOp);
1887		return new FixedNumber(_guard$5, val, this.#format);
1888	}
1889	#add(o, safeOp) {
1890		this.#checkFormat(o);
1891		return this.#checkValue(this.#val + o.#val, safeOp);
1892	}
1893	/**
1894	*  Returns a new [[FixedNumber]] with the result of %%this%% added
1895	*  to %%other%%, ignoring overflow.
1896	*/
1897	addUnsafe(other) {
1898		return this.#add(other);
1899	}
1900	/**
1901	*  Returns a new [[FixedNumber]] with the result of %%this%% added
1902	*  to %%other%%. A [[NumericFaultError]] is thrown if overflow
1903	*  occurs.
1904	*/
1905	add(other) {
1906		return this.#add(other, "add");
1907	}
1908	#sub(o, safeOp) {
1909		this.#checkFormat(o);
1910		return this.#checkValue(this.#val - o.#val, safeOp);
1911	}
1912	/**
1913	*  Returns a new [[FixedNumber]] with the result of %%other%% subtracted
1914	*  from %%this%%, ignoring overflow.
1915	*/
1916	subUnsafe(other) {
1917		return this.#sub(other);
1918	}
1919	/**
1920	*  Returns a new [[FixedNumber]] with the result of %%other%% subtracted
1921	*  from %%this%%. A [[NumericFaultError]] is thrown if overflow
1922	*  occurs.
1923	*/
1924	sub(other) {
1925		return this.#sub(other, "sub");
1926	}
1927	#mul(o, safeOp) {
1928		this.#checkFormat(o);
1929		return this.#checkValue(this.#val * o.#val / this.#tens, safeOp);
1930	}
1931	/**
1932	*  Returns a new [[FixedNumber]] with the result of %%this%% multiplied
1933	*  by %%other%%, ignoring overflow and underflow (precision loss).
1934	*/
1935	mulUnsafe(other) {
1936		return this.#mul(other);
1937	}
1938	/**
1939	*  Returns a new [[FixedNumber]] with the result of %%this%% multiplied
1940	*  by %%other%%. A [[NumericFaultError]] is thrown if overflow
1941	*  occurs.
1942	*/

1943	mul(other) {
1944		return this.#mul(other, "mul");
1945	}
1946	/**
1947	*  Returns a new [[FixedNumber]] with the result of %%this%% multiplied
1948	*  by %%other%%. A [[NumericFaultError]] is thrown if overflow
1949	*  occurs or if underflow (precision loss) occurs.
1950	*/
1951	mulSignal(other) {
1952		this.#checkFormat(other);
1953		const value = this.#val * other.#val;
1954		assert(value % this.#tens === BN_0$8, "precision lost during signalling mul", "NUMERIC_FAULT", {
1955			operation: "mulSignal",
1956			fault: "underflow",
1957			value: this
1958		});
1959		return this.#checkValue(value / this.#tens, "mulSignal");
1960	}
1961	#div(o, safeOp) {
1962		assert(o.#val !== BN_0$8, "division by zero", "NUMERIC_FAULT", {
1963			operation: "div",
1964			fault: "divide-by-zero",
1965			value: this
1966		});
1967		this.#checkFormat(o);
1968		return this.#checkValue(this.#val * this.#tens / o.#val, safeOp);
1969	}
1970	/**
1971	*  Returns a new [[FixedNumber]] with the result of %%this%% divided
1972	*  by %%other%%, ignoring underflow (precision loss). A
1973	*  [[NumericFaultError]] is thrown if overflow occurs.
1974	*/
1975	divUnsafe(other) {
1976		return this.#div(other);
1977	}
1978	/**
1979	*  Returns a new [[FixedNumber]] with the result of %%this%% divided
1980	*  by %%other%%, ignoring underflow (precision loss). A
1981	*  [[NumericFaultError]] is thrown if overflow occurs.
1982	*/
1983	div(other) {
1984		return this.#div(other, "div");
1985	}
1986	/**
1987	*  Returns a new [[FixedNumber]] with the result of %%this%% divided
1988	*  by %%other%%. A [[NumericFaultError]] is thrown if underflow
1989	*  (precision loss) occurs.
1990	*/
1991	divSignal(other) {
1992		assert(other.#val !== BN_0$8, "division by zero", "NUMERIC_FAULT", {
1993			operation: "div",
1994			fault: "divide-by-zero",
1995			value: this
1996		});
1997		this.#checkFormat(other);
1998		const value = this.#val * this.#tens;
1999		assert(value % other.#val === BN_0$8, "precision lost during signalling div", "NUMERIC_FAULT", {
2000			operation: "divSignal",
2001			fault: "underflow",
2002			value: this
2003		});
2004		return this.#checkValue(value / other.#val, "divSignal");
2005	}
2006	/**
2007	*  Returns a comparison result between %%this%% and %%other%%.
2008	*
2009	*  This is suitable for use in sorting, where ``-1`` implies %%this%%
2010	*  is smaller, ``1`` implies %%this%% is larger and ``0`` implies
2011	*  both are equal.
2012	*/
2013	cmp(other) {
2014		let a = this.value, b = other.value;
2015		const delta = this.decimals - other.decimals;
2016		if (delta > 0) b *= getTens(delta);
2017		else if (delta < 0) a *= getTens(-delta);
2018		if (a < b) return -1;
2019		if (a > b) return 1;
2020		return 0;
2021	}
2022	/**
2023	*  Returns true if %%other%% is equal to %%this%%.
2024	*/
2025	eq(other) {
2026		return this.cmp(other) === 0;
2027	}
2028	/**
2029	*  Returns true if %%other%% is less than to %%this%%.
2030	*/
2031	lt(other) {
2032		return this.cmp(other) < 0;
2033	}
2034	/**
2035	*  Returns true if %%other%% is less than or equal to %%this%%.
2036	*/
2037	lte(other) {
2038		return this.cmp(other) <= 0;
2039	}
2040	/**
2041	*  Returns true if %%other%% is greater than to %%this%%.
2042	*/
2043	gt(other) {
2044		return this.cmp(other) > 0;
2045	}
2046	/**
2047	*  Returns true if %%other%% is greater than or equal to %%this%%.
2048	*/
2049	gte(other) {
2050		return this.cmp(other) >= 0;
2051	}
2052	/**
2053	*  Returns a new [[FixedNumber]] which is the largest **integer**
2054	*  that is less than or equal to %%this%%.
2055	*
2056	*  The decimal component of the result will always be ``0``.
2057	*/
2058	floor() {
2059		let val = this.#val;
2060		if (this.#val < BN_0$8) val -= this.#tens - BN_1$4;
2061		val = this.#val / this.#tens * this.#tens;
2062		return this.#checkValue(val, "floor");
2063	}
2064	/**
2065	*  Returns a new [[FixedNumber]] which is the smallest **integer**
2066	*  that is greater than or equal to %%this%%.
2067	*
2068	*  The decimal component of the result will always be ``0``.
2069	*/
2070	ceiling() {
2071		let val = this.#val;
2072		if (this.#val > BN_0$8) val += this.#tens - BN_1$4;
2073		val = this.#val / this.#tens * this.#tens;
2074		return this.#checkValue(val, "ceiling");
2075	}
2076	/**
2077	*  Returns a new [[FixedNumber]] with the decimal component
2078	*  rounded up on ties at %%decimals%% places.
2079	*/
2080	round(decimals) {
2081		if (decimals == null) decimals = 0;
2082		if (decimals >= this.decimals) return this;
2083		const delta = this.decimals - decimals;
2084		const bump = BN_5 * getTens(delta - 1);
2085		let value = this.value + bump;
2086		const tens = getTens(delta);
2087		value = value / tens * tens;
2088		checkValue(value, this.#format, "round");
2089		return new FixedNumber(_guard$5, value, this.#format);
2090	}
2091	/**
2092	*  Returns true if %%this%% is equal to ``0``.
2093	*/
2094	isZero() {
2095		return this.#val === BN_0$8;
2096	}

2097	/**
2098	*  Returns true if %%this%% is less than ``0``.
2099	*/
2100	isNegative() {
2101		return this.#val < BN_0$8;
2102	}
2103	/**
2104	*  Returns the string representation of %%this%%.
2105	*/
2106	toString() {
2107		return this._value;
2108	}
2109	/**
2110	*  Returns a float approximation.
2111	*
2112	*  Due to IEEE 754 precission (or lack thereof), this function
2113	*  can only return an approximation and most values will contain
2114	*  rounding errors.
2115	*/
2116	toUnsafeFloat() {
2117		return parseFloat(this.toString());
2118	}
2119	/**
2120	*  Return a new [[FixedNumber]] with the same value but has had
2121	*  its field set to %%format%%.
2122	*
2123	*  This will throw if the value cannot fit into %%format%%.
2124	*/
2125	toFormat(format) {
2126		return FixedNumber.fromString(this.toString(), format);
2127	}
2128	/**
2129	*  Creates a new [[FixedNumber]] for %%value%% divided by
2130	*  %%decimal%% places with %%format%%.
2131	*
2132	*  This will throw a [[NumericFaultError]] if %%value%% (once adjusted
2133	*  for %%decimals%%) cannot fit in %%format%%, either due to overflow
2134	*  or underflow (precision loss).
2135	*/
2136	static fromValue(_value, _decimals, _format) {
2137		const decimals = _decimals == null ? 0 : getNumber(_decimals);
2138		const format = getFormat(_format);
2139		let value = getBigInt(_value, "value");
2140		const delta = decimals - format.decimals;
2141		if (delta > 0) {
2142			const tens = getTens(delta);
2143			assert(value % tens === BN_0$8, "value loses precision for format", "NUMERIC_FAULT", {
2144				operation: "fromValue",
2145				fault: "underflow",
2146				value: _value
2147			});
2148			value /= tens;
2149		} else if (delta < 0) value *= getTens(-delta);
2150		checkValue(value, format, "fromValue");
2151		return new FixedNumber(_guard$5, value, format);
2152	}
2153	/**
2154	*  Creates a new [[FixedNumber]] for %%value%% with %%format%%.
2155	*
2156	*  This will throw a [[NumericFaultError]] if %%value%% cannot fit
2157	*  in %%format%%, either due to overflow or underflow (precision loss).
2158	*/
2159	static fromString(_value, _format) {
2160		const match = _value.match(/^(-?)([0-9]*)\.?([0-9]*)$/);
2161		assertArgument(match && match[2].length + match[3].length > 0, "invalid FixedNumber string value", "value", _value);
2162		const format = getFormat(_format);
2163		let whole = match[2] || "0", decimal = match[3] || "";
2164		while (decimal.length < format.decimals) decimal += Zeros$1;
2165		assert(decimal.substring(format.decimals).match(/^0*$/), "too many decimals for format", "NUMERIC_FAULT", {
2166			operation: "fromString",
2167			fault: "underflow",
2168			value: _value
2169		});
2170		decimal = decimal.substring(0, format.decimals);
2171		const value = BigInt(match[1] + whole + decimal);
2172		checkValue(value, format, "fromString");
2173		return new FixedNumber(_guard$5, value, format);
2174	}
2175	/**
2176	*  Creates a new [[FixedNumber]] with the big-endian representation
2177	*  %%value%% with %%format%%.
2178	*
2179	*  This will throw a [[NumericFaultError]] if %%value%% cannot fit
2180	*  in %%format%% due to overflow.
2181	*/
2182	static fromBytes(_value, _format) {
2183		let value = toBigInt(getBytes(_value, "value"));
2184		const format = getFormat(_format);
2185		if (format.signed) value = fromTwos(value, format.width);
2186		checkValue(value, format, "fromBytes");
2187		return new FixedNumber(_guard$5, value, format);
2188	}
2189};
2190//#endregion
2191//#region node_modules/ethers/lib.esm/utils/rlp-decode.js
2192function hexlifyByte(value) {
2193	let result = value.toString(16);
2194	while (result.length < 2) result = "0" + result;
2195	return "0x" + result;
2196}
2197function unarrayifyInteger(data, offset, length) {
2198	let result = 0;
2199	for (let i = 0; i < length; i++) result = result * 256 + data[offset + i];
2200	return result;
2201}
2202function _decodeChildren(data, offset, childOffset, length) {
2203	const result = [];
2204	while (childOffset < offset + 1 + length) {
2205		const decoded = _decode(data, childOffset);
2206		result.push(decoded.result);
2207		childOffset += decoded.consumed;
2208		assert(childOffset <= offset + 1 + length, "child data too short", "BUFFER_OVERRUN", {
2209			buffer: data,
2210			length,
2211			offset
2212		});
2213	}
2214	return {
2215		consumed: 1 + length,
2216		result
2217	};
2218}
2219function _decode(data, offset) {
2220	assert(data.length !== 0, "data too short", "BUFFER_OVERRUN", {
2221		buffer: data,
2222		length: 0,
2223		offset: 1
2224	});
2225	const checkOffset = (offset) => {
2226		assert(offset <= data.length, "data short segment too short", "BUFFER_OVERRUN", {
2227			buffer: data,
2228			length: data.length,
2229			offset
2230		});
2231	};
2232	if (data[offset] >= 248) {
2233		const lengthLength = data[offset] - 247;
2234		checkOffset(offset + 1 + lengthLength);
2235		const length = unarrayifyInteger(data, offset + 1, lengthLength);
2236		checkOffset(offset + 1 + lengthLength + length);
2237		return _decodeChildren(data, offset, offset + 1 + lengthLength, lengthLength + length);
2238	} else if (data[offset] >= 192) {
2239		const length = data[offset] - 192;
2240		checkOffset(offset + 1 + length);
2241		return _decodeChildren(data, offset, offset + 1, length);
2242	} else if (data[offset] >= 184) {
2243		const lengthLength = data[offset] - 183;
2244		checkOffset(offset + 1 + lengthLength);
2245		const length = unarrayifyInteger(data, offset + 1, lengthLength);
2246		checkOffset(offset + 1 + lengthLength + length);
2247		const result = hexlify(data.slice(offset + 1 + lengthLength, offset + 1 + lengthLength + length));
2248		return {
2249			consumed: 1 + lengthLength + length,
2250			result
2251		};
2252	} else if (data[offset] >= 128) {
2253		const length = data[offset] - 128;
2254		checkOffset(offset + 1 + length);
2255		const result = hexlify(data.slice(offset + 1, offset + 1 + length));
2256		return {
2257			consumed: 1 + length,
2258			result
2259		};
2260	}
2261	return {
2262		consumed: 1,
2263		result: hexlifyByte(data[offset])
2264	};
2265}
2266/**
2267*  Decodes %%data%% into the structured data it represents.
2268*/
2269function decodeRlp(_data) {
2270	const data = getBytes(_data, "data");
2271	const decoded = _decode(data, 0);
2272	assertArgument(decoded.consumed === data.length, "unexpected junk after rlp payload", "data", _data);
2273	return decoded.result;
2274}
2275//#endregion
2276//#region node_modules/ethers/lib.esm/utils/rlp-encode.js
2277function arrayifyInteger(value) {
2278	const result = [];
2279	while (value) {
2280		result.unshift(value & 255);
2281		value >>= 8;
2282	}
2283	return result;
2284}
2285function _encode(object) {
2286	if (Array.isArray(object)) {
2287		let payload = [];
2288		object.forEach(function(child) {
2289			payload = payload.concat(_encode(child));
2290		});
2291		if (payload.length <= 55) {
2292			payload.unshift(192 + payload.length);
2293			return payload;
2294		}
2295		const length = arrayifyInteger(payload.length);
2296		length.unshift(247 + length.length);
2297		return length.concat(payload);
2298	}
2299	const data = Array.prototype.slice.call(getBytes(object, "object"));
2300	if (data.length === 1 && data[0] <= 127) return data;
2301	else if (data.length <= 55) {
2302		data.unshift(128 + data.length);
2303		return data;
2304	}
2305	const length = arrayifyInteger(data.length);
2306	length.unshift(183 + length.length);
2307	return length.concat(data);
2308}
2309var nibbles = "0123456789abcdef";
2310/**
2311*  Encodes %%object%% as an RLP-encoded [[DataHexString]].
2312*/
2313function encodeRlp(object) {

2314	let result = "0x";
2315	for (const v of _encode(object)) {
2316		result += nibbles[v >> 4];
2317		result += nibbles[v & 15];
2318	}
2319	return result;
2320}
2321//#endregion
2322//#region node_modules/ethers/lib.esm/utils/units.js
2323/**
2324*  Most interactions with Ethereum requires integer values, which use
2325*  the smallest magnitude unit.
2326*
2327*  For example, imagine dealing with dollars and cents. Since dollars
2328*  are divisible, non-integer values are possible, such as ``$10.77``.
2329*  By using the smallest indivisible unit (i.e. cents), the value can
2330*  be kept as the integer ``1077``.
2331*
2332*  When receiving decimal input from the user (as a decimal string),
2333*  the value should be converted to an integer and when showing a user
2334*  a value, the integer value should be converted to a decimal string.
2335*
2336*  This creates a clear distinction, between values to be used by code
2337*  (integers) and values used for display logic to users (decimals).
2338*
2339*  The native unit in Ethereum, //ether// is divisible to 18 decimal places,
2340*  where each individual unit is called a //wei//.
2341*
2342*  @_subsection api/utils:Unit Conversion  [about-units]
2343*/
2344var names = [
2345	"wei",
2346	"kwei",
2347	"mwei",
2348	"gwei",
2349	"szabo",
2350	"finney",
2351	"ether"
2352];
2353/**
2354*  Converts %%value%% into a //decimal string//, assuming %%unit%% decimal
2355*  places. The %%unit%% may be the number of decimal places or the name of
2356*  a unit (e.g. ``"gwei"`` for 9 decimal places).
2357*
2358*/
2359function formatUnits(value, unit) {
2360	let decimals = 18;
2361	if (typeof unit === "string") {
2362		const index = names.indexOf(unit);
2363		assertArgument(index >= 0, "invalid unit", "unit", unit);
2364		decimals = 3 * index;
2365	} else if (unit != null) decimals = getNumber(unit, "unit");
2366	return FixedNumber.fromValue(value, decimals, {
2367		decimals,
2368		width: 512
2369	}).toString();
2370}
2371/**
2372*  Converts the //decimal string// %%value%% to a BigInt, assuming
2373*  %%unit%% decimal places. The %%unit%% may the number of decimal places
2374*  or the name of a unit (e.g. ``"gwei"`` for 9 decimal places).
2375*/
2376function parseUnits(value, unit) {
2377	assertArgument(typeof value === "string", "value must be a string", "value", value);
2378	let decimals = 18;
2379	if (typeof unit === "string") {
2380		const index = names.indexOf(unit);
2381		assertArgument(index >= 0, "invalid unit", "unit", unit);
2382		decimals = 3 * index;
2383	} else if (unit != null) decimals = getNumber(unit, "unit");
2384	return FixedNumber.fromString(value, {
2385		decimals,
2386		width: 512
2387	}).value;
2388}
2389/**
2390*  Converts %%value%% into a //decimal string// using 18 decimal places.
2391*/
2392function formatEther(wei) {
2393	return formatUnits(wei, 18);
2394}
2395/**
2396*  Converts the //decimal string// %%ether%% to a BigInt, using 18
2397*  decimal places.
2398*/
2399function parseEther(ether) {
2400	return parseUnits(ether, 18);
2401}
2402//#endregion
2403//#region node_modules/ethers/lib.esm/utils/uuid.js
2404/**
2405*  Explain UUID and link to RFC here.
2406*
2407*  @_subsection: api/utils:UUID  [about-uuid]
2408*/
2409/**
2410*  Returns the version 4 [[link-uuid]] for the %%randomBytes%%.
2411*
2412*  @see: https://www.ietf.org/rfc/rfc4122.txt (Section 4.4)
2413*/
2414function uuidV4(randomBytes) {
2415	const bytes = getBytes(randomBytes, "randomBytes");
2416	bytes[6] = bytes[6] & 15 | 64;
2417	bytes[8] = bytes[8] & 63 | 128;
2418	const value = hexlify(bytes);
2419	return [
2420		value.substring(2, 10),
2421		value.substring(10, 14),
2422		value.substring(14, 18),
2423		value.substring(18, 22),
2424		value.substring(22, 34)
2425	].join("-");
2426}
2427var Padding = /* @__PURE__ */ new Uint8Array(32);
2428var passProperties$1 = ["then"];
2429var _guard$4 = {};
2430var resultNames = /* @__PURE__ */ new WeakMap();
2431function getNames(result) {
2432	return resultNames.get(result);
2433}
2434function setNames(result, names) {
2435	resultNames.set(result, names);
2436}
2437function throwError(name, error) {
2438	const wrapped = /* @__PURE__ */ new Error(`deferred error during ABI decoding triggered accessing ${name}`);
2439	wrapped.error = error;
2440	throw wrapped;
2441}
2442function toObject(names, items, deep) {
2443	if (names.indexOf(null) >= 0) return items.map((item, index) => {
2444		if (item instanceof Result) return toObject(getNames(item), item, deep);
2445		return item;
2446	});
2447	return names.reduce((accum, name, index) => {
2448		let item = items.getValue(name);
2449		if (!(name in accum)) {

2450			if (deep && item instanceof Result) item = toObject(getNames(item), item, deep);
2451			accum[name] = item;
2452		}
2453		return accum;
2454	}, {});
2455}
2456/**
2457*  A [[Result]] is a sub-class of Array, which allows accessing any
2458*  of its values either positionally by its index or, if keys are
2459*  provided by its name.
2460*
2461*  @_docloc: api/abi
2462*/
2463var Result = class Result extends Array {
2464	#names;
2465	/**
2466	*  @private
2467	*/
2468	constructor(...args) {
2469		const guard = args[0];
2470		let items = args[1];
2471		let names = (args[2] || []).slice();
2472		let wrap = true;
2473		if (guard !== _guard$4) {
2474			items = args;
2475			names = [];
2476			wrap = false;
2477		}
2478		super(items.length);
2479		items.forEach((item, index) => {
2480			this[index] = item;
2481		});
2482		const nameCounts = names.reduce((accum, name) => {
2483			if (typeof name === "string") accum.set(name, (accum.get(name) || 0) + 1);
2484			return accum;
2485		}, /* @__PURE__ */ new Map());
2486		setNames(this, Object.freeze(items.map((item, index) => {
2487			const name = names[index];
2488			if (name != null && nameCounts.get(name) === 1) return name;
2489			return null;
2490		})));
2491		this.#names = [];
2492		if (this.#names == null) this.#names;
2493		if (!wrap) return;
2494		Object.freeze(this);
2495		const proxy = new Proxy(this, { get: (target, prop, receiver) => {
2496			if (typeof prop === "string") {
2497				if (prop.match(/^[0-9]+$/)) {
2498					const index = getNumber(prop, "%index");
2499					if (index < 0 || index >= this.length) throw new RangeError("out of result range");
2500					const item = target[index];
2501					if (item instanceof Error) throwError(`index ${index}`, item);
2502					return item;
2503				}
2504				if (passProperties$1.indexOf(prop) >= 0) return Reflect.get(target, prop, receiver);
2505				const value = target[prop];
2506				if (value instanceof Function) return function(...args) {
2507					return value.apply(this === receiver ? target : this, args);
2508				};
2509				else if (!(prop in target)) return target.getValue.apply(this === receiver ? target : this, [prop]);
2510			}
2511			return Reflect.get(target, prop, receiver);
2512		} });
2513		setNames(proxy, getNames(this));
2514		return proxy;
2515	}
2516	/**
2517	*  Returns the Result as a normal Array. If %%deep%%, any children
2518	*  which are Result objects are also converted to a normal Array.
2519	*
2520	*  This will throw if there are any outstanding deferred
2521	*  errors.
2522	*/
2523	toArray(deep) {
2524		const result = [];
2525		this.forEach((item, index) => {
2526			if (item instanceof Error) throwError(`index ${index}`, item);
2527			if (deep && item instanceof Result) item = item.toArray(deep);
2528			result.push(item);
2529		});
2530		return result;
2531	}
2532	/**
2533	*  Returns the Result as an Object with each name-value pair. If
2534	*  %%deep%%, any children which are Result objects are also
2535	*  converted to an Object.
2536	*
2537	*  This will throw if any value is unnamed, or if there are
2538	*  any outstanding deferred errors.
2539	*/
2540	toObject(deep) {
2541		const names = getNames(this);
2542		return names.reduce((accum, name, index) => {
2543			assert(name != null, `value at index ${index} unnamed`, "UNSUPPORTED_OPERATION", { operation: "toObject()" });
2544			return toObject(names, this, deep);
2545		}, {});
2546	}
2547	/**
2548	*  @_ignore
2549	*/
2550	slice(start, end) {
2551		if (start == null) start = 0;
2552		if (start < 0) {
2553			start += this.length;
2554			if (start < 0) start = 0;
2555		}
2556		if (end == null) end = this.length;
2557		if (end < 0) {
2558			end += this.length;
2559			if (end < 0) end = 0;
2560		}
2561		if (end > this.length) end = this.length;
2562		const _names = getNames(this);
2563		const result = [], names = [];
2564		for (let i = start; i < end; i++) {
2565			result.push(this[i]);
2566			names.push(_names[i]);
2567		}
2568		return new Result(_guard$4, result, names);
2569	}
2570	/**
2571	*  @_ignore
2572	*/
2573	filter(callback, thisArg) {
2574		const _names = getNames(this);
2575		const result = [], names = [];
2576		for (let i = 0; i < this.length; i++) {
2577			const item = this[i];
2578			if (item instanceof Error) throwError(`index ${i}`, item);
2579			if (callback.call(thisArg, item, i, this)) {
2580				result.push(item);
2581				names.push(_names[i]);
2582			}
2583		}
2584		return new Result(_guard$4, result, names);
2585	}
2586	/**
2587	*  @_ignore
2588	*/
2589	map(callback, thisArg) {
2590		const result = [];
2591		for (let i = 0; i < this.length; i++) {
2592			const item = this[i];
2593			if (item instanceof Error) throwError(`index ${i}`, item);
2594			result.push(callback.call(thisArg, item, i, this));
2595		}
2596		return result;
2597	}

2598	/**
2599	*  Returns the value for %%name%%.
2600	*
2601	*  Since it is possible to have a key whose name conflicts with
2602	*  a method on a [[Result]] or its superclass Array, or any
2603	*  JavaScript keyword, this ensures all named values are still
2604	*  accessible by name.
2605	*/
2606	getValue(name) {
2607		const index = getNames(this).indexOf(name);
2608		if (index === -1) return;
2609		const value = this[index];
2610		if (value instanceof Error) throwError(`property ${JSON.stringify(name)}`, value.error);
2611		return value;
2612	}
2613	/**
2614	*  Creates a new [[Result]] for %%items%% with each entry
2615	*  also accessible by its corresponding name in %%keys%%.
2616	*/
2617	static fromItems(items, keys) {
2618		return new Result(_guard$4, items, keys);
2619	}
2620};
2621/**
2622*  Returns all errors found in a [[Result]].
2623*
2624*  Since certain errors encountered when creating a [[Result]] do
2625*  not impact the ability to continue parsing data, they are
2626*  deferred until they are actually accessed. Hence a faulty string
2627*  in an Event that is never used does not impact the program flow.
2628*
2629*  However, sometimes it may be useful to access, identify or
2630*  validate correctness of a [[Result]].
2631*
2632*  @_docloc api/abi
2633*/
2634function checkResultErrors(result) {
2635	const errors = [];
2636	const checkErrors = function(path, object) {
2637		if (!Array.isArray(object)) return;
2638		for (let key in object) {
2639			const childPath = path.slice();
2640			childPath.push(key);
2641			try {
2642				checkErrors(childPath, object[key]);
2643			} catch (error) {
2644				errors.push({
2645					path: childPath,
2646					error
2647				});
2648			}
2649		}
2650	};
2651	checkErrors([], result);
2652	return errors;
2653}
2654function getValue$1(value) {
2655	let bytes = toBeArray(value);
2656	assert(bytes.length <= 32, "value out-of-bounds", "BUFFER_OVERRUN", {
2657		buffer: bytes,
2658		length: 32,
2659		offset: bytes.length
2660	});
2661	if (bytes.length !== 32) bytes = getBytesCopy(concat([Padding.slice(bytes.length % 32), bytes]));
2662	return bytes;
2663}
2664/**
2665*  @_ignore
2666*/
2667var Coder = class {
2668	name;
2669	type;
2670	localName;
2671	dynamic;
2672	constructor(name, type, localName, dynamic) {
2673		defineProperties(this, {
2674			name,
2675			type,
2676			localName,
2677			dynamic
2678		}, {
2679			name: "string",
2680			type: "string",
2681			localName: "string",
2682			dynamic: "boolean"
2683		});
2684	}
2685	_throwError(message, value) {
2686		assertArgument(false, message, this.localName, value);
2687	}
2688};
2689/**
2690*  @_ignore
2691*/
2692var Writer = class {
2693	#data;
2694	#dataLength;
2695	constructor() {
2696		this.#data = [];
2697		this.#dataLength = 0;
2698	}
2699	get data() {
2700		return concat(this.#data);
2701	}
2702	get length() {
2703		return this.#dataLength;
2704	}
2705	#writeData(data) {
2706		this.#data.push(data);
2707		this.#dataLength += data.length;
2708		return data.length;
2709	}
2710	appendWriter(writer) {
2711		return this.#writeData(getBytesCopy(writer.data));
2712	}
2713	writeBytes(value) {
2714		let bytes = getBytesCopy(value);
2715		const paddingOffset = bytes.length % 32;
2716		if (paddingOffset) bytes = getBytesCopy(concat([bytes, Padding.slice(paddingOffset)]));
2717		return this.#writeData(bytes);
2718	}
2719	writeValue(value) {
2720		return this.#writeData(getValue$1(value));
2721	}
2722	writeUpdatableValue() {
2723		const offset = this.#data.length;
2724		this.#data.push(Padding);
2725		this.#dataLength += 32;
2726		return (value) => {
2727			this.#data[offset] = getValue$1(value);
2728		};
2729	}
2730};
2731/**
2732*  @_ignore
2733*/
2734var Reader = class Reader {
2735	allowLoose;
2736	#data;
2737	#offset;
2738	#bytesRead;
2739	#parent;
2740	#maxInflation;
2741	constructor(data, allowLoose, maxInflation) {
2742		defineProperties(this, { allowLoose: !!allowLoose });
2743		this.#data = getBytesCopy(data);
2744		this.#bytesRead = 0;
2745		this.#parent = null;
2746		this.#maxInflation = maxInflation != null ? maxInflation : 1024;
2747		this.#offset = 0;
2748	}
2749	get data() {
2750		return hexlify(this.#data);
2751	}
2752	get dataLength() {
2753		return this.#data.length;
2754	}
2755	get consumed() {
2756		return this.#offset;
2757	}
2758	get bytes() {
2759		return new Uint8Array(this.#data);
2760	}
2761	#incrementBytesRead(count) {
2762		if (this.#parent) return this.#parent.#incrementBytesRead(count);
2763		this.#bytesRead += count;
2764		assert(this.#maxInflation < 1 || this.#bytesRead <= this.#maxInflation * this.dataLength, `compressed ABI data exceeds inflation ratio of ${this.#maxInflation} ( see: https:/\/github.com/ethers-io/ethers.js/issues/4537 )`, "BUFFER_OVERRUN", {
2765			buffer: getBytesCopy(this.#data),
2766			offset: this.#offset,
2767			length: count,
2768			info: {
2769				bytesRead: this.#bytesRead,
2770				dataLength: this.dataLength
2771			}
2772		});
2773	}
2774	#peekBytes(offset, length, loose) {
2775		let alignedLength = Math.ceil(length / 32) * 32;
2776		if (this.#offset + alignedLength > this.#data.length) {
2777			if (this.allowLoose && loose && this.#offset + length <= this.#data.length) alignedLength = length;
2778			else assert(false, "data out-of-bounds", "BUFFER_OVERRUN", {
2779				buffer: getBytesCopy(this.#data),
2780				length: this.#data.length,
2781				offset: this.#offset + alignedLength
2782			});
2783		}
2784		return this.#data.slice(this.#offset, this.#offset + alignedLength);
2785	}
2786	subReader(offset) {
2787		const reader = new Reader(this.#data.slice(this.#offset + offset), this.allowLoose, this.#maxInflation);
2788		reader.#parent = this;
2789		return reader;
2790	}
2791	readBytes(length, loose) {
2792		let bytes = this.#peekBytes(0, length, !!loose);
2793		this.#incrementBytesRead(length);
2794		this.#offset += bytes.length;
2795		return bytes.slice(0, length);
2796	}
2797	readValue() {
2798		return toBigInt(this.readBytes(32));
2799	}
2800	readIndex() {
2801		return toNumber(this.readBytes(32));
2802	}
2803};
2804//#endregion
2805//#region node_modules/@noble/hashes/esm/_assert.js
2806function number(n) {
2807	if (!Number.isSafeInteger(n) || n < 0) throw new Error(`Wrong positive integer: ${n}`);
2808}
2809function bytes(b, ...lengths) {
2810	if (!(b instanceof Uint8Array)) throw new Error("Expected Uint8Array");
2811	if (lengths.length > 0 && !lengths.includes(b.length)) throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
2812}
2813function hash(hash) {
2814	if (typeof hash !== "function" || typeof hash.create !== "function") throw new Error("Hash should be wrapped by utils.wrapConstructor");
2815	number(hash.outputLen);
2816	number(hash.blockLen);
2817}
2818function exists(instance, checkFinished = true) {
2819	if (instance.destroyed) throw new Error("Hash instance has been destroyed");
2820	if (checkFinished && instance.finished) throw new Error("Hash#digest() has already been called");
2821}
2822function output(out, instance) {
2823	bytes(out);
2824	const min = instance.outputLen;
2825	if (out.length < min) throw new Error(`digestInto() expects output buffer of length at least ${min}`);
2826}
2827//#endregion
2828//#region node_modules/@noble/hashes/esm/crypto.js
2829var crypto$1 = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
2830//#endregion

2831//#region node_modules/@noble/hashes/esm/utils.js
2832/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
2833var u8a$1 = (a) => a instanceof Uint8Array;
2834var u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
2835var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
2836var rotr = (word, shift) => word << 32 - shift | word >>> shift;
2837if (!(new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)) throw new Error("Non little-endian hardware is not supported");
2838var nextTick = async () => {};
2839async function asyncLoop(iters, tick, cb) {
2840	let ts = Date.now();
2841	for (let i = 0; i < iters; i++) {
2842		cb(i);
2843		const diff = Date.now() - ts;
2844		if (diff >= 0 && diff < tick) continue;
2845		await /* @__PURE__ */ nextTick();
2846		ts += diff;
2847	}
2848}
2849/**
2850* @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
2851*/
2852function utf8ToBytes$1(str) {
2853	if (typeof str !== "string") throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
2854	return new Uint8Array(new TextEncoder().encode(str));
2855}
2856/**
2857* Normalizes (non-hex) string or Uint8Array to Uint8Array.
2858* Warning: when Uint8Array is passed, it would NOT get copied.
2859* Keep in mind for future mutable operations.
2860*/
2861function toBytes(data) {
2862	if (typeof data === "string") data = utf8ToBytes$1(data);
2863	if (!u8a$1(data)) throw new Error(`expected Uint8Array, got ${typeof data}`);
2864	return data;
2865}
2866/**
2867* Copies several Uint8Arrays into one.
2868*/
2869function concatBytes$1(...arrays) {
2870	const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));
2871	let pad = 0;
2872	arrays.forEach((a) => {
2873		if (!u8a$1(a)) throw new Error("Uint8Array expected");
2874		r.set(a, pad);
2875		pad += a.length;
2876	});
2877	return r;
2878}
2879var Hash = class {
2880	clone() {
2881		return this._cloneInto();
2882	}
2883};
2884var toStr = {}.toString;
2885function checkOpts(defaults, opts) {
2886	if (opts !== void 0 && toStr.call(opts) !== "[object Object]") throw new Error("Options should be object or undefined");
2887	return Object.assign(defaults, opts);
2888}
2889function wrapConstructor(hashCons) {
2890	const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
2891	const tmp = hashCons();
2892	hashC.outputLen = tmp.outputLen;
2893	hashC.blockLen = tmp.blockLen;
2894	hashC.create = () => hashCons();
2895	return hashC;
2896}
2897/**
2898* Secure PRNG. Uses `crypto.getRandomValues`, which defers to OS.
2899*/
2900function randomBytes$2(bytesLength = 32) {
2901	if (crypto$1 && typeof crypto$1.getRandomValues === "function") return crypto$1.getRandomValues(new Uint8Array(bytesLength));
2902	throw new Error("crypto.getRandomValues must be defined");
2903}
2904//#endregion
2905//#region node_modules/@noble/hashes/esm/hmac.js
2906var HMAC = class extends Hash {
2907	constructor(hash$2, _key) {
2908		super();
2909		this.finished = false;
2910		this.destroyed = false;
2911		hash(hash$2);
2912		const key = toBytes(_key);
2913		this.iHash = hash$2.create();
2914		if (typeof this.iHash.update !== "function") throw new Error("Expected instance of class which extends utils.Hash");
2915		this.blockLen = this.iHash.blockLen;
2916		this.outputLen = this.iHash.outputLen;
2917		const blockLen = this.blockLen;
2918		const pad = new Uint8Array(blockLen);
2919		pad.set(key.length > blockLen ? hash$2.create().update(key).digest() : key);
2920		for (let i = 0; i < pad.length; i++) pad[i] ^= 54;
2921		this.iHash.update(pad);
2922		this.oHash = hash$2.create();
2923		for (let i = 0; i < pad.length; i++) pad[i] ^= 106;
2924		this.oHash.update(pad);
2925		pad.fill(0);
2926	}
2927	update(buf) {
2928		exists(this);
2929		this.iHash.update(buf);
2930		return this;
2931	}
2932	digestInto(out) {
2933		exists(this);
2934		bytes(out, this.outputLen);
2935		this.finished = true;
2936		this.iHash.digestInto(out);
2937		this.oHash.update(out);
2938		this.oHash.digestInto(out);
2939		this.destroy();
2940	}
2941	digest() {
2942		const out = new Uint8Array(this.oHash.outputLen);
2943		this.digestInto(out);
2944		return out;
2945	}
2946	_cloneInto(to) {
2947		to || (to = Object.create(Object.getPrototypeOf(this), {}));
2948		const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
2949		to = to;
2950		to.finished = finished;
2951		to.destroyed = destroyed;
2952		to.blockLen = blockLen;
2953		to.outputLen = outputLen;
2954		to.oHash = oHash._cloneInto(to.oHash);

vendor: 6,356 bytes, lines 2955-3210

2955		to.iHash = iHash._cloneInto(to.iHash);
2956		return to;
2957	}
2958	destroy() {
2959		this.destroyed = true;
2960		this.oHash.destroy();
2961		this.iHash.destroy();
2962	}
2963};
2964/**
2965* HMAC: RFC2104 message authentication code.
2966* @param hash - function that would be used e.g. sha256
2967* @param key - message key
2968* @param message - message data
2969*/
2970var hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
2971hmac.create = (hash, key) => new HMAC(hash, key);
2972//#endregion
2973//#region node_modules/@noble/hashes/esm/pbkdf2.js
2974function pbkdf2Init(hash$1, _password, _salt, _opts) {
2975	hash(hash$1);
2976	const { c, dkLen, asyncTick } = checkOpts({
2977		dkLen: 32,
2978		asyncTick: 10
2979	}, _opts);
2980	number(c);
2981	number(dkLen);
2982	number(asyncTick);
2983	if (c < 1) throw new Error("PBKDF2: iterations (c) should be >= 1");
2984	const password = toBytes(_password);
2985	const salt = toBytes(_salt);
2986	const DK = new Uint8Array(dkLen);
2987	const PRF = hmac.create(hash$1, password);
2988	return {
2989		c,
2990		dkLen,
2991		asyncTick,
2992		DK,
2993		PRF,
2994		PRFSalt: PRF._cloneInto().update(salt)
2995	};
2996}
2997function pbkdf2Output(PRF, PRFSalt, DK, prfW, u) {
2998	PRF.destroy();
2999	PRFSalt.destroy();
3000	if (prfW) prfW.destroy();
3001	u.fill(0);
3002	return DK;
3003}
3004/**
3005* PBKDF2-HMAC: RFC 2898 key derivation function
3006* @param hash - hash function that would be used e.g. sha256
3007* @param password - password from which a derived key is generated
3008* @param salt - cryptographic salt
3009* @param opts - {c, dkLen} where c is work factor and dkLen is output message size
3010*/
3011function pbkdf2$1(hash, password, salt, opts) {
3012	const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
3013	let prfW;
3014	const arr = /* @__PURE__ */ new Uint8Array(4);
3015	const view = createView(arr);
3016	const u = new Uint8Array(PRF.outputLen);
3017	for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
3018		const Ti = DK.subarray(pos, pos + PRF.outputLen);
3019		view.setInt32(0, ti, false);
3020		(prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
3021		Ti.set(u.subarray(0, Ti.length));
3022		for (let ui = 1; ui < c; ui++) {
3023			PRF._cloneInto(prfW).update(u).digestInto(u);
3024			for (let i = 0; i < Ti.length; i++) Ti[i] ^= u[i];
3025		}
3026	}
3027	return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
3028}
3029//#endregion
3030//#region node_modules/@noble/hashes/esm/_sha2.js
3031function setBigUint64(view, byteOffset, value, isLE) {
3032	if (typeof view.setBigUint64 === "function") return view.setBigUint64(byteOffset, value, isLE);
3033	const _32n = BigInt(32);
3034	const _u32_max = BigInt(4294967295);
3035	const wh = Number(value >> _32n & _u32_max);
3036	const wl = Number(value & _u32_max);
3037	const h = isLE ? 4 : 0;
3038	const l = isLE ? 0 : 4;
3039	view.setUint32(byteOffset + h, wh, isLE);
3040	view.setUint32(byteOffset + l, wl, isLE);
3041}
3042var SHA2 = class extends Hash {
3043	constructor(blockLen, outputLen, padOffset, isLE) {
3044		super();
3045		this.blockLen = blockLen;
3046		this.outputLen = outputLen;
3047		this.padOffset = padOffset;
3048		this.isLE = isLE;
3049		this.finished = false;
3050		this.length = 0;
3051		this.pos = 0;
3052		this.destroyed = false;
3053		this.buffer = new Uint8Array(blockLen);
3054		this.view = createView(this.buffer);
3055	}
3056	update(data) {
3057		exists(this);
3058		const { view, buffer, blockLen } = this;
3059		data = toBytes(data);
3060		const len = data.length;
3061		for (let pos = 0; pos < len;) {
3062			const take = Math.min(blockLen - this.pos, len - pos);
3063			if (take === blockLen) {
3064				const dataView = createView(data);
3065				for (; blockLen <= len - pos; pos += blockLen) this.process(dataView, pos);
3066				continue;
3067			}
3068			buffer.set(data.subarray(pos, pos + take), this.pos);
3069			this.pos += take;
3070			pos += take;
3071			if (this.pos === blockLen) {
3072				this.process(view, 0);
3073				this.pos = 0;
3074			}
3075		}
3076		this.length += data.length;
3077		this.roundClean();
3078		return this;
3079	}
3080	digestInto(out) {
3081		exists(this);
3082		output(out, this);
3083		this.finished = true;
3084		const { buffer, view, blockLen, isLE } = this;
3085		let { pos } = this;
3086		buffer[pos++] = 128;
3087		this.buffer.subarray(pos).fill(0);
3088		if (this.padOffset > blockLen - pos) {
3089			this.process(view, 0);
3090			pos = 0;
3091		}
3092		for (let i = pos; i < blockLen; i++) buffer[i] = 0;
3093		setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
3094		this.process(view, 0);
3095		const oview = createView(out);
3096		const len = this.outputLen;
3097		if (len % 4) throw new Error("_sha2: outputLen should be aligned to 32bit");
3098		const outLen = len / 4;
3099		const state = this.get();
3100		if (outLen > state.length) throw new Error("_sha2: outputLen bigger than state");
3101		for (let i = 0; i < outLen; i++) oview.setUint32(4 * i, state[i], isLE);
3102	}
3103	digest() {
3104		const { buffer, outputLen } = this;
3105		this.digestInto(buffer);
3106		const res = buffer.slice(0, outputLen);
3107		this.destroy();
3108		return res;
3109	}
3110	_cloneInto(to) {
3111		to || (to = new this.constructor());
3112		to.set(...this.get());
3113		const { blockLen, buffer, length, finished, destroyed, pos } = this;
3114		to.length = length;
3115		to.pos = pos;
3116		to.finished = finished;
3117		to.destroyed = destroyed;
3118		if (length % blockLen) to.buffer.set(buffer);
3119		return to;
3120	}
3121};
3122//#endregion
3123//#region node_modules/@noble/hashes/esm/sha256.js
3124var Chi = (a, b, c) => a & b ^ ~a & c;
3125var Maj = (a, b, c) => a & b ^ a & c ^ b & c;
3126var SHA256_K = /* @__PURE__ */ new Uint32Array([
3127	1116352408,
3128	1899447441,
3129	3049323471,
3130	3921009573,
3131	961987163,
3132	1508970993,
3133	2453635748,
3134	2870763221,
3135	3624381080,
3136	310598401,
3137	607225278,
3138	1426881987,
3139	1925078388,
3140	2162078206,
3141	2614888103,
3142	3248222580,
3143	3835390401,
3144	4022224774,
3145	264347078,
3146	604807628,
3147	770255983,
3148	1249150122,
3149	1555081692,
3150	1996064986,
3151	2554220882,
3152	2821834349,
3153	2952996808,
3154	3210313671,
3155	3336571891,
3156	3584528711,
3157	113926993,
3158	338241895,
3159	666307205,
3160	773529912,
3161	1294757372,
3162	1396182291,
3163	1695183700,
3164	1986661051,
3165	2177026350,
3166	2456956037,
3167	2730485921,
3168	2820302411,
3169	3259730800,
3170	3345764771,
3171	3516065817,
3172	3600352804,
3173	4094571909,
3174	275423344,
3175	430227734,
3176	506948616,
3177	659060556,
3178	883997877,
3179	958139571,
3180	1322822218,
3181	1537002063,
3182	1747873779,
3183	1955562222,
3184	2024104815,
3185	2227730452,
3186	2361852424,
3187	2428436474,
3188	2756734187,
3189	3204031479,
3190	3329325298
3191]);
3192var IV = /* @__PURE__ */ new Uint32Array([
3193	1779033703,
3194	3144134277,
3195	1013904242,
3196	2773480762,
3197	1359893119,
3198	2600822924,
3199	528734635,
3200	1541459225
3201]);
3202var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
3203var SHA256 = class extends SHA2 {
3204	constructor() {
3205		super(64, 32, 8, false);
3206		this.A = IV[0] | 0;
3207		this.B = IV[1] | 0;
3208		this.C = IV[2] | 0;
3209		this.D = IV[3] | 0;
3210		this.E = IV[4] | 0;

3211		this.F = IV[5] | 0;
3212		this.G = IV[6] | 0;
3213		this.H = IV[7] | 0;
3214	}
3215	get() {
3216		const { A, B, C, D, E, F, G, H } = this;
3217		return [
3218			A,
3219			B,
3220			C,
3221			D,
3222			E,
3223			F,
3224			G,
3225			H
3226		];
3227	}
3228	set(A, B, C, D, E, F, G, H) {
3229		this.A = A | 0;
3230		this.B = B | 0;
3231		this.C = C | 0;
3232		this.D = D | 0;
3233		this.E = E | 0;
3234		this.F = F | 0;
3235		this.G = G | 0;
3236		this.H = H | 0;
3237	}
3238	process(view, offset) {
3239		for (let i = 0; i < 16; i++, offset += 4) SHA256_W[i] = view.getUint32(offset, false);
3240		for (let i = 16; i < 64; i++) {
3241			const W15 = SHA256_W[i - 15];
3242			const W2 = SHA256_W[i - 2];
3243			const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
3244			const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
3245			SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
3246		}
3247		let { A, B, C, D, E, F, G, H } = this;
3248		for (let i = 0; i < 64; i++) {
3249			const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
3250			const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
3251			const T2 = (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + Maj(A, B, C) | 0;
3252			H = G;
3253			G = F;
3254			F = E;
3255			E = D + T1 | 0;
3256			D = C;
3257			C = B;
3258			B = A;
3259			A = T1 + T2 | 0;
3260		}
3261		A = A + this.A | 0;
3262		B = B + this.B | 0;
3263		C = C + this.C | 0;
3264		D = D + this.D | 0;
3265		E = E + this.E | 0;
3266		F = F + this.F | 0;
3267		G = G + this.G | 0;
3268		H = H + this.H | 0;
3269		this.set(A, B, C, D, E, F, G, H);
3270	}
3271	roundClean() {
3272		SHA256_W.fill(0);
3273	}
3274	destroy() {
3275		this.set(0, 0, 0, 0, 0, 0, 0, 0);
3276		this.buffer.fill(0);
3277	}
3278};
3279/**
3280* SHA2-256 hash function
3281* @param message - data that would be hashed
3282*/
3283var sha256$1 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
3284//#endregion
3285//#region node_modules/@noble/hashes/esm/_u64.js
3286var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
3287var _32n = /* @__PURE__ */ BigInt(32);
3288function fromBig(n, le = false) {
3289	if (le) return {
3290		h: Number(n & U32_MASK64),
3291		l: Number(n >> _32n & U32_MASK64)
3292	};
3293	return {
3294		h: Number(n >> _32n & U32_MASK64) | 0,
3295		l: Number(n & U32_MASK64) | 0
3296	};
3297}
3298function split$1(lst, le = false) {
3299	let Ah = new Uint32Array(lst.length);
3300	let Al = new Uint32Array(lst.length);
3301	for (let i = 0; i < lst.length; i++) {
3302		const { h, l } = fromBig(lst[i], le);
3303		[Ah[i], Al[i]] = [h, l];
3304	}
3305	return [Ah, Al];
3306}
3307var toBig = (h, l) => BigInt(h >>> 0) << _32n | BigInt(l >>> 0);
3308var shrSH = (h, _l, s) => h >>> s;
3309var shrSL = (h, l, s) => h << 32 - s | l >>> s;
3310var rotrSH = (h, l, s) => h >>> s | l << 32 - s;
3311var rotrSL = (h, l, s) => h << 32 - s | l >>> s;
3312var rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
3313var rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
3314var rotr32H = (_h, l) => l;
3315var rotr32L = (h, _l) => h;
3316var rotlSH = (h, l, s) => h << s | l >>> 32 - s;
3317var rotlSL = (h, l, s) => l << s | h >>> 32 - s;
3318var rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
3319var rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
3320function add(Ah, Al, Bh, Bl) {
3321	const l = (Al >>> 0) + (Bl >>> 0);
3322	return {
3323		h: Ah + Bh + (l / 2 ** 32 | 0) | 0,
3324		l: l | 0
3325	};
3326}
3327var add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
3328var add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
3329var add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
3330var add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
3331var add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
3332var add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
3333var u64 = {
3334	fromBig,
3335	split: split$1,
3336	toBig,
3337	shrSH,
3338	shrSL,
3339	rotrSH,
3340	rotrSL,
3341	rotrBH,
3342	rotrBL,
3343	rotr32H,
3344	rotr32L,
3345	rotlSH,
3346	rotlSL,
3347	rotlBH,
3348	rotlBL,
3349	add,
3350	add3L,
3351	add3H,
3352	add4L,
3353	add4H,
3354	add5H,
3355	add5L
3356};
3357//#endregion
3358//#region node_modules/@noble/hashes/esm/sha512.js
3359var [SHA512_Kh, SHA512_Kl] = /* @__PURE__ */ (() => u64.split([
3360	"0x428a2f98d728ae22",
3361	"0x7137449123ef65cd",
3362	"0xb5c0fbcfec4d3b2f",
3363	"0xe9b5dba58189dbbc",
3364	"0x3956c25bf348b538",
3365	"0x59f111f1b605d019",
3366	"0x923f82a4af194f9b",
3367	"0xab1c5ed5da6d8118",
3368	"0xd807aa98a3030242",
3369	"0x12835b0145706fbe",
3370	"0x243185be4ee4b28c",
3371	"0x550c7dc3d5ffb4e2",

3372	"0x72be5d74f27b896f",
3373	"0x80deb1fe3b1696b1",
3374	"0x9bdc06a725c71235",
3375	"0xc19bf174cf692694",
3376	"0xe49b69c19ef14ad2",
3377	"0xefbe4786384f25e3",
3378	"0x0fc19dc68b8cd5b5",
3379	"0x240ca1cc77ac9c65",
3380	"0x2de92c6f592b0275",
3381	"0x4a7484aa6ea6e483",
3382	"0x5cb0a9dcbd41fbd4",
3383	"0x76f988da831153b5",
3384	"0x983e5152ee66dfab",
3385	"0xa831c66d2db43210",
3386	"0xb00327c898fb213f",
3387	"0xbf597fc7beef0ee4",
3388	"0xc6e00bf33da88fc2",
3389	"0xd5a79147930aa725",
3390	"0x06ca6351e003826f",
3391	"0x142929670a0e6e70",
3392	"0x27b70a8546d22ffc",
3393	"0x2e1b21385c26c926",
3394	"0x4d2c6dfc5ac42aed",
3395	"0x53380d139d95b3df",
3396	"0x650a73548baf63de",
3397	"0x766a0abb3c77b2a8",
3398	"0x81c2c92e47edaee6",
3399	"0x92722c851482353b",
3400	"0xa2bfe8a14cf10364",
3401	"0xa81a664bbc423001",
3402	"0xc24b8b70d0f89791",
3403	"0xc76c51a30654be30",
3404	"0xd192e819d6ef5218",
3405	"0xd69906245565a910",
3406	"0xf40e35855771202a",
3407	"0x106aa07032bbd1b8",
3408	"0x19a4c116b8d2d0c8",
3409	"0x1e376c085141ab53",
3410	"0x2748774cdf8eeb99",
3411	"0x34b0bcb5e19b48a8",
3412	"0x391c0cb3c5c95a63",
3413	"0x4ed8aa4ae3418acb",
3414	"0x5b9cca4f7763e373",
3415	"0x682e6ff3d6b2b8a3",
3416	"0x748f82ee5defb2fc",
3417	"0x78a5636f43172f60",
3418	"0x84c87814a1f0ab72",
3419	"0x8cc702081a6439ec",
3420	"0x90befffa23631e28",
3421	"0xa4506cebde82bde9",
3422	"0xbef9a3f7b2c67915",
3423	"0xc67178f2e372532b",
3424	"0xca273eceea26619c",
3425	"0xd186b8c721c0c207",
3426	"0xeada7dd6cde0eb1e",
3427	"0xf57d4f7fee6ed178",
3428	"0x06f067aa72176fba",
3429	"0x0a637dc5a2c898a6",
3430	"0x113f9804bef90dae",
3431	"0x1b710b35131c471b",
3432	"0x28db77f523047d84",
3433	"0x32caab7b40c72493",
3434	"0x3c9ebe0a15c9bebc",
3435	"0x431d67c49c100d4c",
3436	"0x4cc5d4becb3e42b6",
3437	"0x597f299cfc657e2a",
3438	"0x5fcb6fab3ad6faec",
3439	"0x6c44198c4a475817"
3440].map((n) => BigInt(n))))();
3441var SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
3442var SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
3443var SHA512 = class extends SHA2 {
3444	constructor() {
3445		super(128, 64, 16, false);
3446		this.Ah = 1779033703;
3447		this.Al = -205731576;
3448		this.Bh = -1150833019;
3449		this.Bl = -2067093701;
3450		this.Ch = 1013904242;
3451		this.Cl = -23791573;
3452		this.Dh = -1521486534;
3453		this.Dl = 1595750129;
3454		this.Eh = 1359893119;

3455		this.El = -1377402159;
3456		this.Fh = -1694144372;
3457		this.Fl = 725511199;
3458		this.Gh = 528734635;
3459		this.Gl = -79577749;
3460		this.Hh = 1541459225;
3461		this.Hl = 327033209;
3462	}
3463	get() {
3464		const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
3465		return [
3466			Ah,
3467			Al,
3468			Bh,
3469			Bl,
3470			Ch,
3471			Cl,
3472			Dh,
3473			Dl,
3474			Eh,
3475			El,
3476			Fh,
3477			Fl,
3478			Gh,
3479			Gl,
3480			Hh,
3481			Hl
3482		];
3483	}
3484	set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
3485		this.Ah = Ah | 0;
3486		this.Al = Al | 0;
3487		this.Bh = Bh | 0;
3488		this.Bl = Bl | 0;
3489		this.Ch = Ch | 0;
3490		this.Cl = Cl | 0;
3491		this.Dh = Dh | 0;
3492		this.Dl = Dl | 0;
3493		this.Eh = Eh | 0;
3494		this.El = El | 0;
3495		this.Fh = Fh | 0;
3496		this.Fl = Fl | 0;
3497		this.Gh = Gh | 0;
3498		this.Gl = Gl | 0;
3499		this.Hh = Hh | 0;
3500		this.Hl = Hl | 0;
3501	}
3502	process(view, offset) {
3503		for (let i = 0; i < 16; i++, offset += 4) {
3504			SHA512_W_H[i] = view.getUint32(offset);
3505			SHA512_W_L[i] = view.getUint32(offset += 4);
3506		}
3507		for (let i = 16; i < 80; i++) {
3508			const W15h = SHA512_W_H[i - 15] | 0;
3509			const W15l = SHA512_W_L[i - 15] | 0;
3510			const s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);
3511			const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);
3512			const W2h = SHA512_W_H[i - 2] | 0;
3513			const W2l = SHA512_W_L[i - 2] | 0;
3514			const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);
3515			const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);
3516			const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
3517			const SUMh = u64.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
3518			SHA512_W_H[i] = SUMh | 0;
3519			SHA512_W_L[i] = SUMl | 0;
3520		}
3521		let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
3522		for (let i = 0; i < 80; i++) {
3523			const sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);
3524			const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);
3525			const CHIh = Eh & Fh ^ ~Eh & Gh;
3526			const CHIl = El & Fl ^ ~El & Gl;
3527			const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
3528			const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
3529			const T1l = T1ll | 0;
3530			const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);
3531			const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.rotrBL(Ah, Al, 39);
3532			const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch;
3533			const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl;
3534			Hh = Gh | 0;
3535			Hl = Gl | 0;
3536			Gh = Fh | 0;
3537			Gl = Fl | 0;
3538			Fh = Eh | 0;
3539			Fl = El | 0;
3540			({h: Eh, l: El} = u64.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
3541			Dh = Ch | 0;
3542			Dl = Cl | 0;
3543			Ch = Bh | 0;
3544			Cl = Bl | 0;
3545			Bh = Ah | 0;
3546			Bl = Al | 0;
3547			const All = u64.add3L(T1l, sigma0l, MAJl);
3548			Ah = u64.add3H(All, T1h, sigma0h, MAJh);
3549			Al = All | 0;
3550		}
3551		({h: Ah, l: Al} = u64.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
3552		({h: Bh, l: Bl} = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
3553		({h: Ch, l: Cl} = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
3554		({h: Dh, l: Dl} = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
3555		({h: Eh, l: El} = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
3556		({h: Fh, l: Fl} = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
3557		({h: Gh, l: Gl} = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
3558		({h: Hh, l: Hl} = u64.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
3559		this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
3560	}
3561	roundClean() {
3562		SHA512_W_H.fill(0);
3563		SHA512_W_L.fill(0);
3564	}
3565	destroy() {
3566		this.buffer.fill(0);
3567		this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
3568	}
3569};
3570var sha512$1 = /* @__PURE__ */ wrapConstructor(() => new SHA512());
3571//#endregion
3572//#region node_modules/ethers/lib.esm/crypto/crypto-browser.js
3573function getGlobal$1() {
3574	if (typeof self !== "undefined") return self;
3575	if (typeof window !== "undefined") return window;
3576	if (typeof global !== "undefined") return global;
3577	throw new Error("unable to locate global object");
3578}
3579var anyGlobal = getGlobal$1();
3580var crypto = anyGlobal.crypto || anyGlobal.msCrypto;
3581function createHash(algo) {
3582	switch (algo) {
3583		case "sha256": return sha256$1.create();
3584		case "sha512": return sha512$1.create();
3585	}
3586	assertArgument(false, "invalid hashing algorithm name", "algorithm", algo);
3587}
3588function createHmac(_algo, key) {
3589	const algo = {
3590		sha256: sha256$1,
3591		sha512: sha512$1
3592	}[_algo];
3593	assertArgument(algo != null, "invalid hmac algorithm", "algorithm", _algo);
3594	return hmac.create(algo, key);
3595}
3596function pbkdf2Sync(password, salt, iterations, keylen, _algo) {
3597	const algo = {
3598		sha256: sha256$1,
3599		sha512: sha512$1
3600	}[_algo];
3601	assertArgument(algo != null, "invalid pbkdf2 algorithm", "algorithm", _algo);

vendor: 6,084 bytes, lines 3602-3806

3602	return pbkdf2$1(algo, password, salt, {
3603		c: iterations,
3604		dkLen: keylen
3605	});
3606}
3607function randomBytes$1(length) {
3608	assert(crypto != null, "platform does not support secure random numbers", "UNSUPPORTED_OPERATION", { operation: "randomBytes" });
3609	assertArgument(Number.isInteger(length) && length > 0 && length <= 1024, "invalid length", "length", length);
3610	const result = new Uint8Array(length);
3611	crypto.getRandomValues(result);
3612	return result;
3613}
3614//#endregion
3615//#region node_modules/ethers/lib.esm/crypto/hmac.js
3616/**
3617*  An **HMAC** enables verification that a given key was used
3618*  to authenticate a payload.
3619*
3620*  See: [[link-wiki-hmac]]
3621*
3622*  @_subsection: api/crypto:HMAC  [about-hmac]
3623*/
3624var locked$4 = false;
3625var _computeHmac = function(algorithm, key, data) {
3626	return createHmac(algorithm, key).update(data).digest();
3627};
3628var __computeHmac = _computeHmac;
3629/**
3630*  Return the HMAC for %%data%% using the %%key%% key with the underlying
3631*  %%algo%% used for compression.
3632*
3633*  @example:
3634*    key = id("some-secret")
3635*
3636*    // Compute the HMAC
3637*    computeHmac("sha256", key, "0x1337")
3638*    //_result:
3639*
3640*    // To compute the HMAC of UTF-8 data, the data must be
3641*    // converted to UTF-8 bytes
3642*    computeHmac("sha256", key, toUtf8Bytes("Hello World"))
3643*    //_result:
3644*
3645*/
3646function computeHmac(algorithm, _key, _data) {
3647	const key = getBytes(_key, "key");
3648	const data = getBytes(_data, "data");
3649	return hexlify(__computeHmac(algorithm, key, data));
3650}
3651computeHmac._ = _computeHmac;
3652computeHmac.lock = function() {
3653	locked$4 = true;
3654};
3655computeHmac.register = function(func) {
3656	if (locked$4) throw new Error("computeHmac is locked");
3657	__computeHmac = func;
3658};
3659Object.freeze(computeHmac);
3660//#endregion
3661//#region node_modules/@noble/hashes/esm/sha3.js
3662var [SHA3_PI, SHA3_ROTL, _SHA3_IOTA] = [
3663	[],
3664	[],
3665	[]
3666];
3667var _0n$4 = /* @__PURE__ */ BigInt(0);
3668var _1n$5 = /* @__PURE__ */ BigInt(1);
3669var _2n$3 = /* @__PURE__ */ BigInt(2);
3670var _7n = /* @__PURE__ */ BigInt(7);
3671var _256n = /* @__PURE__ */ BigInt(256);
3672var _0x71n = /* @__PURE__ */ BigInt(113);
3673for (let round = 0, R = _1n$5, x = 1, y = 0; round < 24; round++) {
3674	[x, y] = [y, (2 * x + 3 * y) % 5];
3675	SHA3_PI.push(2 * (5 * y + x));
3676	SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
3677	let t = _0n$4;
3678	for (let j = 0; j < 7; j++) {
3679		R = (R << _1n$5 ^ (R >> _7n) * _0x71n) % _256n;
3680		if (R & _2n$3) t ^= _1n$5 << (_1n$5 << /* @__PURE__ */ BigInt(j)) - _1n$5;
3681	}
3682	_SHA3_IOTA.push(t);
3683}
3684var [SHA3_IOTA_H, SHA3_IOTA_L] = /* @__PURE__ */ split$1(_SHA3_IOTA, true);
3685var rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
3686var rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
3687function keccakP(s, rounds = 24) {
3688	const B = /* @__PURE__ */ new Uint32Array(10);
3689	for (let round = 24 - rounds; round < 24; round++) {
3690		for (let x = 0; x < 10; x++) B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
3691		for (let x = 0; x < 10; x += 2) {
3692			const idx1 = (x + 8) % 10;
3693			const idx0 = (x + 2) % 10;
3694			const B0 = B[idx0];
3695			const B1 = B[idx0 + 1];
3696			const Th = rotlH(B0, B1, 1) ^ B[idx1];
3697			const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
3698			for (let y = 0; y < 50; y += 10) {
3699				s[x + y] ^= Th;
3700				s[x + y + 1] ^= Tl;
3701			}
3702		}
3703		let curH = s[2];
3704		let curL = s[3];
3705		for (let t = 0; t < 24; t++) {
3706			const shift = SHA3_ROTL[t];
3707			const Th = rotlH(curH, curL, shift);
3708			const Tl = rotlL(curH, curL, shift);
3709			const PI = SHA3_PI[t];
3710			curH = s[PI];
3711			curL = s[PI + 1];
3712			s[PI] = Th;
3713			s[PI + 1] = Tl;
3714		}
3715		for (let y = 0; y < 50; y += 10) {
3716			for (let x = 0; x < 10; x++) B[x] = s[y + x];
3717			for (let x = 0; x < 10; x++) s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
3718		}
3719		s[0] ^= SHA3_IOTA_H[round];
3720		s[1] ^= SHA3_IOTA_L[round];
3721	}
3722	B.fill(0);
3723}
3724var Keccak = class Keccak extends Hash {
3725	constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
3726		super();
3727		this.blockLen = blockLen;
3728		this.suffix = suffix;
3729		this.outputLen = outputLen;
3730		this.enableXOF = enableXOF;
3731		this.rounds = rounds;
3732		this.pos = 0;
3733		this.posOut = 0;
3734		this.finished = false;
3735		this.destroyed = false;
3736		number(outputLen);
3737		if (0 >= this.blockLen || this.blockLen >= 200) throw new Error("Sha3 supports only keccak-f1600 function");
3738		this.state = /* @__PURE__ */ new Uint8Array(200);
3739		this.state32 = u32(this.state);
3740	}
3741	keccak() {
3742		keccakP(this.state32, this.rounds);
3743		this.posOut = 0;
3744		this.pos = 0;
3745	}
3746	update(data) {
3747		exists(this);
3748		const { blockLen, state } = this;
3749		data = toBytes(data);
3750		const len = data.length;
3751		for (let pos = 0; pos < len;) {
3752			const take = Math.min(blockLen - this.pos, len - pos);
3753			for (let i = 0; i < take; i++) state[this.pos++] ^= data[pos++];
3754			if (this.pos === blockLen) this.keccak();
3755		}
3756		return this;
3757	}
3758	finish() {
3759		if (this.finished) return;
3760		this.finished = true;
3761		const { state, suffix, pos, blockLen } = this;
3762		state[pos] ^= suffix;
3763		if ((suffix & 128) !== 0 && pos === blockLen - 1) this.keccak();
3764		state[blockLen - 1] ^= 128;
3765		this.keccak();
3766	}
3767	writeInto(out) {
3768		exists(this, false);
3769		bytes(out);
3770		this.finish();
3771		const bufferOut = this.state;
3772		const { blockLen } = this;
3773		for (let pos = 0, len = out.length; pos < len;) {
3774			if (this.posOut >= blockLen) this.keccak();
3775			const take = Math.min(blockLen - this.posOut, len - pos);
3776			out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
3777			this.posOut += take;
3778			pos += take;
3779		}
3780		return out;
3781	}
3782	xofInto(out) {
3783		if (!this.enableXOF) throw new Error("XOF is not possible for this instance");
3784		return this.writeInto(out);
3785	}
3786	xof(bytes) {
3787		number(bytes);
3788		return this.xofInto(new Uint8Array(bytes));
3789	}
3790	digestInto(out) {
3791		output(out, this);
3792		if (this.finished) throw new Error("digest() was already called");
3793		this.writeInto(out);
3794		this.destroy();
3795		return out;
3796	}
3797	digest() {
3798		return this.digestInto(new Uint8Array(this.outputLen));
3799	}
3800	destroy() {
3801		this.destroyed = true;
3802		this.state.fill(0);
3803	}
3804	_cloneInto(to) {
3805		const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
3806		to || (to = new Keccak(blockLen, suffix, outputLen, enableXOF, roun

3806ds));
3807		to.state32.set(this.state32);
3808		to.pos = this.pos;
3809		to.posOut = this.posOut;
3810		to.finished = this.finished;
3811		to.rounds = rounds;
3812		to.suffix = suffix;
3813		to.outputLen = outputLen;
3814		to.enableXOF = enableXOF;
3815		to.destroyed = this.destroyed;
3816		return to;
3817	}
3818};
3819var gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(blockLen, suffix, outputLen));
3820/**
3821* keccak-256 hash function. Different from SHA3-256.
3822* @param message - that would be hashed
3823*/
3824var keccak_256 = /* @__PURE__ */ gen(1, 136, 32);
3825//#endregion
3826//#region node_modules/ethers/lib.esm/crypto/keccak.js
3827/**
3828*  Cryptographic hashing functions
3829*
3830*  @_subsection: api/crypto:Hash Functions [about-crypto-hashing]
3831*/
3832var locked$3 = false;
3833var _keccak256 = function(data) {
3834	return keccak_256(data);
3835};
3836var __keccak256 = _keccak256;
3837/**
3838*  Compute the cryptographic KECCAK256 hash of %%data%%.
3839*
3840*  The %%data%% **must** be a data representation, to compute the
3841*  hash of UTF-8 data use the [[id]] function.
3842*
3843*  @returns DataHexstring
3844*  @example:
3845*    keccak256("0x")
3846*    //_result:
3847*
3848*    keccak256("0x1337")
3849*    //_result:
3850*
3851*    keccak256(new Uint8Array([ 0x13, 0x37 ]))
3852*    //_result:
3853*
3854*    // Strings are assumed to be DataHexString, otherwise it will
3855*    // throw. To hash UTF-8 data, see the note above.
3856*    keccak256("Hello World")
3857*    //_error:
3858*/
3859function keccak256(_data) {
3860	const data = getBytes(_data, "data");
3861	return hexlify(__keccak256(data));
3862}
3863keccak256._ = _keccak256;
3864keccak256.lock = function() {
3865	locked$3 = true;
3866};
3867keccak256.register = function(func) {
3868	if (locked$3) throw new TypeError("keccak256 is locked");
3869	__keccak256 = func;
3870};
3871Object.freeze(keccak256);
3872//#endregion
3873//#region node_modules/@noble/hashes/esm/ripemd160.js
3874var Rho = /* @__PURE__ */ new Uint8Array([
3875	7,
3876	4,
3877	13,
3878	1,
3879	10,
3880	6,
3881	15,
3882	3,
3883	12,
3884	0,
3885	9,
3886	5,
3887	2,
3888	14,
3889	11,
3890	8
3891]);
3892var Id = /* @__PURE__ */ Uint8Array.from({ length: 16 }, (_, i) => i);
3893var Pi = /* @__PURE__ */ Id.map((i) => (9 * i + 5) % 16);
3894var idxL = [Id];
3895var idxR = [Pi];
3896for (let i = 0; i < 4; i++) for (let j of [idxL, idxR]) j.push(j[i].map((k) => Rho[k]));
3897var shifts = /* @__PURE__ */ [
3898	[
3899		11,
3900		14,
3901		15,
3902		12,
3903		5,
3904		8,
3905		7,
3906		9,
3907		11,
3908		13,
3909		14,
3910		15,
3911		6,
3912		7,
3913		9,
3914		8
3915	],
3916	[
3917		12,
3918		13,
3919		11,
3920		15,
3921		6,
3922		9,
3923		9,
3924		7,
3925		12,
3926		15,
3927		11,
3928		13,
3929		7,
3930		8,
3931		7,
3932		7
3933	],
3934	[
3935		13,
3936		15,
3937		14,
3938		11,
3939		7,
3940		7,
3941		6,
3942		8,
3943		13,
3944		14,
3945		13,
3946		12,
3947		5,
3948		5,
3949		6,
3950		9
3951	],
3952	[
3953		14,
3954		11,
3955		12,
3956		14,
3957		8,
3958		6,
3959		5,
3960		5,
3961		15,
3962		12,
3963		15,
3964		14,
3965		9,
3966		9,
3967		8,
3968		6
3969	],
3970	[
3971		15,
3972		12,
3973		13,
3974		13,
3975		9,
3976		5,
3977		8,
3978		6,
3979		14,
3980		11,
3981		12,
3982		11,
3983		8,
3984		6,
3985		5,
3986		5
3987	]
3988].map((i) => new Uint8Array(i));
3989var shiftsL = /* @__PURE__ */ idxL.map((idx, i) => idx.map((j) => shifts[i][j]));
3990var shiftsR = /* @__PURE__ */ idxR.map((idx, i) => idx.map((j) => shifts[i][j]));
3991var Kl = /* @__PURE__ */ new Uint32Array([
3992	0,
3993	1518500249,
3994	1859775393,
3995	2400959708,
3996	2840853838
3997]);
3998var Kr = /* @__PURE__ */ new Uint32Array([
3999	1352829926,
4000	1548603684,
4001	1836072691,
4002	2053994217,
4003	0
4004]);
4005var rotl$1 = (word, shift) => word << shift | word >>> 32 - shift;
4006function f(group, x, y, z) {
4007	if (group === 0) return x ^ y ^ z;
4008	else if (group === 1) return x & y | ~x & z;
4009	else if (group === 2) return (x | ~y) ^ z;
4010	else if (group === 3) return x & z | y & ~z;
4011	else return x ^ (y | ~z);
4012}
4013var BUF = /* @__PURE__ */ new Uint32Array(16);
4014var RIPEMD160 = class extends SHA2 {
4015	constructor() {
4016		super(64, 20, 8, true);
4017		this.h0 = 1732584193;
4018		this.h1 = -271733879;

4019		this.h2 = -1732584194;
4020		this.h3 = 271733878;
4021		this.h4 = -1009589776;
4022	}
4023	get() {
4024		const { h0, h1, h2, h3, h4 } = this;
4025		return [
4026			h0,
4027			h1,
4028			h2,
4029			h3,
4030			h4
4031		];
4032	}
4033	set(h0, h1, h2, h3, h4) {
4034		this.h0 = h0 | 0;
4035		this.h1 = h1 | 0;
4036		this.h2 = h2 | 0;
4037		this.h3 = h3 | 0;
4038		this.h4 = h4 | 0;
4039	}
4040	process(view, offset) {
4041		for (let i = 0; i < 16; i++, offset += 4) BUF[i] = view.getUint32(offset, true);
4042		let al = this.h0 | 0, ar = al, bl = this.h1 | 0, br = bl, cl = this.h2 | 0, cr = cl, dl = this.h3 | 0, dr = dl, el = this.h4 | 0, er = el;
4043		for (let group = 0; group < 5; group++) {
4044			const rGroup = 4 - group;
4045			const hbl = Kl[group], hbr = Kr[group];
4046			const rl = idxL[group], rr = idxR[group];
4047			const sl = shiftsL[group], sr = shiftsR[group];
4048			for (let i = 0; i < 16; i++) {
4049				const tl = rotl$1(al + f(group, bl, cl, dl) + BUF[rl[i]] + hbl, sl[i]) + el | 0;
4050				al = el, el = dl, dl = rotl$1(cl, 10) | 0, cl = bl, bl = tl;
4051			}
4052			for (let i = 0; i < 16; i++) {
4053				const tr = rotl$1(ar + f(rGroup, br, cr, dr) + BUF[rr[i]] + hbr, sr[i]) + er | 0;
4054				ar = er, er = dr, dr = rotl$1(cr, 10) | 0, cr = br, br = tr;
4055			}
4056		}
4057		this.set(this.h1 + cl + dr | 0, this.h2 + dl + er | 0, this.h3 + el + ar | 0, this.h4 + al + br | 0, this.h0 + bl + cr | 0);
4058	}
4059	roundClean() {
4060		BUF.fill(0);
4061	}
4062	destroy() {
4063		this.destroyed = true;
4064		this.buffer.fill(0);
4065		this.set(0, 0, 0, 0, 0);
4066	}
4067};
4068/**
4069* RIPEMD-160 - a hash function from 1990s.
4070* @param message - msg that would be hashed
4071*/
4072var ripemd160$1 = /* @__PURE__ */ wrapConstructor(() => new RIPEMD160());
4073//#endregion
4074//#region node_modules/ethers/lib.esm/crypto/ripemd160.js
4075var locked$2 = false;
4076var _ripemd160 = function(data) {
4077	return ripemd160$1(data);
4078};
4079var __ripemd160 = _ripemd160;
4080/**
4081*  Compute the cryptographic RIPEMD-160 hash of %%data%%.
4082*
4083*  @_docloc: api/crypto:Hash Functions
4084*  @returns DataHexstring
4085*
4086*  @example:
4087*    ripemd160("0x")
4088*    //_result:
4089*
4090*    ripemd160("0x1337")
4091*    //_result:
4092*
4093*    ripemd160(new Uint8Array([ 0x13, 0x37 ]))
4094*    //_result:
4095*
4096*/
4097function ripemd160(_data) {
4098	const data = getBytes(_data, "data");
4099	return hexlify(__ripemd160(data));
4100}
4101ripemd160._ = _ripemd160;
4102ripemd160.lock = function() {
4103	locked$2 = true;
4104};
4105ripemd160.register = function(func) {
4106	if (locked$2) throw new TypeError("ripemd160 is locked");
4107	__ripemd160 = func;
4108};
4109Object.freeze(ripemd160);
4110//#endregion
4111//#region node_modules/ethers/lib.esm/crypto/pbkdf2.js
4112/**
4113*  A **Password-Based Key-Derivation Function** is designed to create
4114*  a sequence of bytes suitible as a **key** from a human-rememberable
4115*  password.
4116*
4117*  @_subsection: api/crypto:Passwords  [about-pbkdf]
4118*/
4119var locked$1 = false;
4120var _pbkdf2 = function(password, salt, iterations, keylen, algo) {
4121	return pbkdf2Sync(password, salt, iterations, keylen, algo);
4122};
4123var __pbkdf2 = _pbkdf2;
4124/**
4125*  Return the [[link-pbkdf2]] for %%keylen%% bytes for %%password%% using
4126*  the %%salt%% and using %%iterations%% of %%algo%%.
4127*
4128*  This PBKDF is outdated and should not be used in new projects, but is
4129*  required to decrypt older files.
4130*
4131*  @example:
4132*    // The password must be converted to bytes, and it is generally
4133*    // best practices to ensure the string has been normalized. Many
4134*    // formats explicitly indicate the normalization form to use.
4135*    password = "hello"
4136*    passwordBytes = toUtf8Bytes(password, "NFKC")
4137*
4138*    salt = id("some-salt")
4139*
4140*    // Compute the PBKDF2
4141*    pbkdf2(passwordBytes, salt, 1024, 16, "sha256")
4142*    //_result:
4143*/
4144function pbkdf2(_password, _salt, iterations, keylen, algo) {
4145	const password = getBytes(_password, "password");
4146	const salt = getBytes(_salt, "salt");
4147	return hexlify(__pbkdf2(password, salt, iterations, keylen, algo));
4148}
4149pbkdf2._ = _pbkdf2;
4150pbkdf2.lock = function() {
4151	locked$1 = true;
4152};
4153pbkdf2.register = function(func) {
4154	if (locked$1) throw new Error("pbkdf2 is locked");
4155	__pbkdf2 = func;
4156};
4157Object.freeze(pbkdf2);
4158//#endregion
4159//#region node_modules/ethers/lib.esm/crypto/random.js
4160/**
4161*  A **Cryptographically Secure Random Value** is one that has been
4162*  generated with additional care take to prevent side-channels
4163*  from allowing others to detect it and prevent others from through
4164*  coincidence generate the same values.
4165*
4166*  @_subsection: api/crypto:Random Values  [about-crypto-random]
4167*/
4168var locked = false;

4169var _randomBytes = function(length) {
4170	return new Uint8Array(randomBytes$1(length));
4171};
4172var __randomBytes = _randomBytes;
4173/**
4174*  Return %%length%% bytes of cryptographically secure random data.
4175*
4176*  @example:
4177*    randomBytes(8)
4178*    //_result:
4179*/
4180function randomBytes(length) {
4181	return __randomBytes(length);
4182}
4183randomBytes._ = _randomBytes;
4184randomBytes.lock = function() {
4185	locked = true;
4186};
4187randomBytes.register = function(func) {
4188	if (locked) throw new Error("randomBytes is locked");
4189	__randomBytes = func;
4190};
4191Object.freeze(randomBytes);
4192//#endregion
4193//#region node_modules/@noble/hashes/esm/scrypt.js
4194var rotl = (a, b) => a << b | a >>> 32 - b;
4195function XorAndSalsa(prev, pi, input, ii, out, oi) {
4196	let y00 = prev[pi++] ^ input[ii++], y01 = prev[pi++] ^ input[ii++];
4197	let y02 = prev[pi++] ^ input[ii++], y03 = prev[pi++] ^ input[ii++];
4198	let y04 = prev[pi++] ^ input[ii++], y05 = prev[pi++] ^ input[ii++];
4199	let y06 = prev[pi++] ^ input[ii++], y07 = prev[pi++] ^ input[ii++];
4200	let y08 = prev[pi++] ^ input[ii++], y09 = prev[pi++] ^ input[ii++];
4201	let y10 = prev[pi++] ^ input[ii++], y11 = prev[pi++] ^ input[ii++];
4202	let y12 = prev[pi++] ^ input[ii++], y13 = prev[pi++] ^ input[ii++];
4203	let y14 = prev[pi++] ^ input[ii++], y15 = prev[pi++] ^ input[ii++];
4204	let x00 = y00, x01 = y01, x02 = y02, x03 = y03, x04 = y04, x05 = y05, x06 = y06, x07 = y07, x08 = y08, x09 = y09, x10 = y10, x11 = y11, x12 = y12, x13 = y13, x14 = y14, x15 = y15;
4205	for (let i = 0; i < 8; i += 2) {
4206		x04 ^= rotl(x00 + x12 | 0, 7);
4207		x08 ^= rotl(x04 + x00 | 0, 9);
4208		x12 ^= rotl(x08 + x04 | 0, 13);
4209		x00 ^= rotl(x12 + x08 | 0, 18);
4210		x09 ^= rotl(x05 + x01 | 0, 7);
4211		x13 ^= rotl(x09 + x05 | 0, 9);
4212		x01 ^= rotl(x13 + x09 | 0, 13);
4213		x05 ^= rotl(x01 + x13 | 0, 18);
4214		x14 ^= rotl(x10 + x06 | 0, 7);
4215		x02 ^= rotl(x14 + x10 | 0, 9);
4216		x06 ^= rotl(x02 + x14 | 0, 13);
4217		x10 ^= rotl(x06 + x02 | 0, 18);
4218		x03 ^= rotl(x15 + x11 | 0, 7);
4219		x07 ^= rotl(x03 + x15 | 0, 9);
4220		x11 ^= rotl(x07 + x03 | 0, 13);
4221		x15 ^= rotl(x11 + x07 | 0, 18);
4222		x01 ^= rotl(x00 + x03 | 0, 7);
4223		x02 ^= rotl(x01 + x00 | 0, 9);
4224		x03 ^= rotl(x02 + x01 | 0, 13);
4225		x00 ^= rotl(x03 + x02 | 0, 18);
4226		x06 ^= rotl(x05 + x04 | 0, 7);
4227		x07 ^= rotl(x06 + x05 | 0, 9);
4228		x04 ^= rotl(x07 + x06 | 0, 13);
4229		x05 ^= rotl(x04 + x07 | 0, 18);
4230		x11 ^= rotl(x10 + x09 | 0, 7);
4231		x08 ^= rotl(x11 + x10 | 0, 9);
4232		x09 ^= rotl(x08 + x11 | 0, 13);
4233		x10 ^= rotl(x09 + x08 | 0, 18);
4234		x12 ^= rotl(x15 + x14 | 0, 7);
4235		x13 ^= rotl(x12 + x15 | 0, 9);
4236		x14 ^= rotl(x13 + x12 | 0, 13);
4237		x15 ^= rotl(x14 + x13 | 0, 18);
4238	}
4239	out[oi++] = y00 + x00 | 0;
4240	out[oi++] = y01 + x01 | 0;
4241	out[oi++] = y02 + x02 | 0;
4242	out[oi++] = y03 + x03 | 0;
4243	out[oi++] = y04 + x04 | 0;
4244	out[oi++] = y05 + x05 | 0;
4245	out[oi++] = y06 + x06 | 0;
4246	out[oi++] = y07 + x07 | 0;
4247	out[oi++] = y08 + x08 | 0;
4248	out[oi++] = y09 + x09 | 0;
4249	out[oi++] = y10 + x10 | 0;
4250	out[oi++] = y11 + x11 | 0;
4251	out[oi++] = y12 + x12 | 0;
4252	out[oi++] = y13 + x13 | 0;
4253	out[oi++] = y14 + x14 | 0;
4254	out[oi++] = y15 + x15 | 0;
4255}
4256function BlockMix(input, ii, out, oi, r) {
4257	let head = oi + 0;
4258	let tail = oi + 16 * r;
4259	for (let i = 0; i < 16; i++) out[tail + i] = input[ii + (2 * r - 1) * 16 + i];
4260	for (let i = 0; i < r; i++, head += 16, ii += 16) {
4261		XorAndSalsa(out, tail, input, ii, out, head);
4262		if (i > 0) tail += 16;
4263		XorAndSalsa(out, head, input, ii += 16, out, tail);
4264	}
4265}
4266function scryptInit(password, salt, _opts) {
4267	const { N, r, p, dkLen, asyncTick, maxmem, onProgress } = checkOpts({
4268		dkLen: 32,
4269		asyncTick: 10,
4270		maxmem: 1024 ** 3 + 1024
4271	}, _opts);
4272	number(N);
4273	number(r);
4274	number(p);
4275	number(dkLen);
4276	number(asyncTick);
4277	number(maxmem);
4278	if (onProgress !== void 0 && typeof onProgress !== "function") throw new Error("progressCb should be function");
4279	const blockSize = 128 * r;
4280	const blockSize32 = blockSize / 4;
4281	if (N <= 1 || (N & N - 1) !== 0 || N >= 2 ** (blockSize / 8) || N > 2 ** 32) throw new Error("Scrypt: N must be larger than 1, a power of 2, less than 2^(128 * r / 8) and less than 2^32");
4282	if (p < 0 || p > (2 ** 32 - 1) * 32 / blockSize) throw new Error("Scrypt: p must be a positive integer less than or equal to ((2^32 - 1) * 32) / (128 * r)");
4283	if (dkLen < 0 || dkLen > (2 ** 32 - 1) * 32) throw new Error("Scrypt: dkLen should be positive integer less than or equal to (2^32 - 1) * 32");
4284	const memUsed = blockSize * (N + p);
4285	if (memUsed > maxmem) throw new Error(`Scrypt: parameters too large, ${memUsed} (128 * r * (N + p)) > ${maxmem} (maxmem)`);

vendor: 3,839 bytes, lines 4286-4416

4286	const B = pbkdf2$1(sha256$1, password, salt, {
4287		c: 1,
4288		dkLen: blockSize * p
4289	});
4290	const B32 = u32(B);
4291	const V = u32(new Uint8Array(blockSize * N));
4292	const tmp = u32(new Uint8Array(blockSize));
4293	let blockMixCb = () => {};
4294	if (onProgress) {
4295		const totalBlockMix = 2 * N * p;
4296		const callbackPer = Math.max(Math.floor(totalBlockMix / 1e4), 1);
4297		let blockMixCnt = 0;
4298		blockMixCb = () => {
4299			blockMixCnt++;
4300			if (onProgress && (!(blockMixCnt % callbackPer) || blockMixCnt === totalBlockMix)) onProgress(blockMixCnt / totalBlockMix);
4301		};
4302	}
4303	return {
4304		N,
4305		r,
4306		p,
4307		dkLen,
4308		blockSize32,
4309		V,
4310		B32,
4311		B,
4312		tmp,
4313		blockMixCb,
4314		asyncTick
4315	};
4316}
4317function scryptOutput(password, dkLen, B, V, tmp) {
4318	const res = pbkdf2$1(sha256$1, password, B, {
4319		c: 1,
4320		dkLen
4321	});
4322	B.fill(0);
4323	V.fill(0);
4324	tmp.fill(0);
4325	return res;
4326}
4327/**
4328* Scrypt KDF from RFC 7914.
4329* @param password - pass
4330* @param salt - salt
4331* @param opts - parameters
4332* - `N` is cpu/mem work factor (power of 2 e.g. 2**18)
4333* - `r` is block size (8 is common), fine-tunes sequential memory read size and performance
4334* - `p` is parallelization factor (1 is common)
4335* - `dkLen` is output key length in bytes e.g. 32.
4336* - `asyncTick` - (default: 10) max time in ms for which async function can block execution
4337* - `maxmem` - (default: `1024 ** 3 + 1024` aka 1GB+1KB). A limit that the app could use for scrypt
4338* - `onProgress` - callback function that would be executed for progress report
4339* @returns Derived key
4340*/
4341function scrypt$1(password, salt, opts) {
4342	const { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb } = scryptInit(password, salt, opts);
4343	for (let pi = 0; pi < p; pi++) {
4344		const Pi = blockSize32 * pi;
4345		for (let i = 0; i < blockSize32; i++) V[i] = B32[Pi + i];
4346		for (let i = 0, pos = 0; i < N - 1; i++) {
4347			BlockMix(V, pos, V, pos += blockSize32, r);
4348			blockMixCb();
4349		}
4350		BlockMix(V, (N - 1) * blockSize32, B32, Pi, r);
4351		blockMixCb();
4352		for (let i = 0; i < N; i++) {
4353			const j = B32[Pi + blockSize32 - 16] % N;
4354			for (let k = 0; k < blockSize32; k++) tmp[k] = B32[Pi + k] ^ V[j * blockSize32 + k];
4355			BlockMix(tmp, 0, B32, Pi, r);
4356			blockMixCb();
4357		}
4358	}
4359	return scryptOutput(password, dkLen, B, V, tmp);
4360}
4361/**
4362* Scrypt KDF from RFC 7914.
4363*/
4364async function scryptAsync(password, salt, opts) {
4365	const { N, r, p, dkLen, blockSize32, V, B32, B, tmp, blockMixCb, asyncTick } = scryptInit(password, salt, opts);
4366	for (let pi = 0; pi < p; pi++) {
4367		const Pi = blockSize32 * pi;
4368		for (let i = 0; i < blockSize32; i++) V[i] = B32[Pi + i];
4369		let pos = 0;
4370		await asyncLoop(N - 1, asyncTick, () => {
4371			BlockMix(V, pos, V, pos += blockSize32, r);
4372			blockMixCb();
4373		});
4374		BlockMix(V, (N - 1) * blockSize32, B32, Pi, r);
4375		blockMixCb();
4376		await asyncLoop(N, asyncTick, () => {
4377			const j = B32[Pi + blockSize32 - 16] % N;
4378			for (let k = 0; k < blockSize32; k++) tmp[k] = B32[Pi + k] ^ V[j * blockSize32 + k];
4379			BlockMix(tmp, 0, B32, Pi, r);
4380			blockMixCb();
4381		});
4382	}
4383	return scryptOutput(password, dkLen, B, V, tmp);
4384}
4385//#endregion
4386//#region node_modules/ethers/lib.esm/crypto/scrypt.js
4387var lockedSync = false;
4388var lockedAsync = false;
4389var _scryptAsync = async function(passwd, salt, N, r, p, dkLen, onProgress) {
4390	return await scryptAsync(passwd, salt, {
4391		N,
4392		r,
4393		p,
4394		dkLen,
4395		onProgress
4396	});
4397};
4398var _scryptSync = function(passwd, salt, N, r, p, dkLen) {
4399	return scrypt$1(passwd, salt, {
4400		N,
4401		r,
4402		p,
4403		dkLen
4404	});
4405};
4406var __scryptAsync = _scryptAsync;
4407var __scryptSync = _scryptSync;
4408/**
4409*  The [[link-wiki-scrypt]] uses a memory and cpu hard method of
4410*  derivation to increase the resource cost to brute-force a password
4411*  for a given key.
4412*
4413*  This means this algorithm is intentionally slow, and can be tuned to
4414*  become slower. As computation and memory speed improve over time,
4415*  increasing the difficulty maintains the cost of an attacker.
4416*

4417*  For example, if a target time of 5 seconds is used, a legitimate user
4418*  which knows their password requires only 5 seconds to unlock their
4419*  account. A 6 character password has 68 billion possibilities, which
4420*  would require an attacker to invest over 10,000 years of CPU time. This
4421*  is of course a crude example (as password generally aren't random),
4422*  but demonstrates to value of imposing large costs to decryption.
4423*
4424*  For this reason, if building a UI which involved decrypting or
4425*  encrypting datsa using scrypt, it is recommended to use a
4426*  [[ProgressCallback]] (as event short periods can seem lik an eternity
4427*  if the UI freezes). Including the phrase //"decrypting"// in the UI
4428*  can also help, assuring the user their waiting is for a good reason.
4429*
4430*  @_docloc: api/crypto:Passwords
4431*
4432*  @example:
4433*    // The password must be converted to bytes, and it is generally
4434*    // best practices to ensure the string has been normalized. Many
4435*    // formats explicitly indicate the normalization form to use.
4436*    password = "hello"
4437*    passwordBytes = toUtf8Bytes(password, "NFKC")
4438*
4439*    salt = id("some-salt")
4440*
4441*    // Compute the scrypt
4442*    scrypt(passwordBytes, salt, 1024, 8, 1, 16)
4443*    //_result:
4444*/
4445async function scrypt(_passwd, _salt, N, r, p, dkLen, progress) {
4446	const passwd = getBytes(_passwd, "passwd");
4447	const salt = getBytes(_salt, "salt");
4448	return hexlify(await __scryptAsync(passwd, salt, N, r, p, dkLen, progress));
4449}
4450scrypt._ = _scryptAsync;
4451scrypt.lock = function() {
4452	lockedAsync = true;
4453};
4454scrypt.register = function(func) {
4455	if (lockedAsync) throw new Error("scrypt is locked");
4456	__scryptAsync = func;
4457};
4458Object.freeze(scrypt);
4459/**
4460*  Provides a synchronous variant of [[scrypt]].
4461*
4462*  This will completely lock up and freeze the UI in a browser and will
4463*  prevent any event loop from progressing. For this reason, it is
4464*  preferred to use the [async variant](scrypt).
4465*
4466*  @_docloc: api/crypto:Passwords
4467*
4468*  @example:
4469*    // The password must be converted to bytes, and it is generally
4470*    // best practices to ensure the string has been normalized. Many
4471*    // formats explicitly indicate the normalization form to use.
4472*    password = "hello"
4473*    passwordBytes = toUtf8Bytes(password, "NFKC")
4474*
4475*    salt = id("some-salt")
4476*
4477*    // Compute the scrypt
4478*    scryptSync(passwordBytes, salt, 1024, 8, 1, 16)
4479*    //_result:
4480*/
4481function scryptSync(_passwd, _salt, N, r, p, dkLen) {
4482	const passwd = getBytes(_passwd, "passwd");
4483	const salt = getBytes(_salt, "salt");
4484	return hexlify(__scryptSync(passwd, salt, N, r, p, dkLen));
4485}
4486scryptSync._ = _scryptSync;
4487scryptSync.lock = function() {
4488	lockedSync = true;
4489};
4490scryptSync.register = function(func) {
4491	if (lockedSync) throw new Error("scryptSync is locked");
4492	__scryptSync = func;
4493};
4494Object.freeze(scryptSync);
4495//#endregion
4496//#region node_modules/ethers/lib.esm/crypto/sha2.js
4497var _sha256 = function(data) {
4498	return createHash("sha256").update(data).digest();
4499};
4500var _sha512 = function(data) {
4501	return createHash("sha512").update(data).digest();
4502};
4503var __sha256 = _sha256;
4504var __sha512 = _sha512;
4505var locked256 = false;
4506var locked512 = false;
4507/**
4508*  Compute the cryptographic SHA2-256 hash of %%data%%.
4509*
4510*  @_docloc: api/crypto:Hash Functions
4511*  @returns DataHexstring
4512*
4513*  @example:
4514*    sha256("0x")
4515*    //_result:
4516*
4517*    sha256("0x1337")
4518*    //_result:
4519*
4520*    sha256(new Uint8Array([ 0x13, 0x37 ]))
4521*    //_result:
4522*
4523*/
4524function sha256(_data) {
4525	const data = getBytes(_data, "data");
4526	return hexlify(__sha256(data));
4527}
4528sha256._ = _sha256;
4529sha256.lock = function() {
4530	locked256 = true;
4531};
4532sha256.register = function(func) {
4533	if (locked256) throw new Error("sha256 is locked");
4534	__sha256 = func;
4535};
4536Object.freeze(sha256);
4537/**
4538*  Compute the cryptographic SHA2-512 hash of %%data%%.
4539*
4540*  @_docloc: api/crypto:Hash Functions
4541*  @returns DataHexstring
4542*
4543*  @example:
4544*    sha512("0x")
4545*    //_result:
4546*
4547*    sha512("0x1337")
4548*    //_result:
4549*
4550*    sha512(new Uint8Array([ 0x13, 0x37 ]))
4551*    //_result:
4552*/
4553function sha512(_data) {
4554	const data = getBytes(_data, "data");
4555	return hexlify(__sha512(data));
4556}
4557sha512._ = _sha512;
4558sha512.lock = function() {
4559	locked512 = true;
4560};
4561sha512.register = function(func) {
4562	if (locked512) throw new Error("sha512 is locked");
4563	__sha512 = func;
4564};
4565Object.freeze(sha256);
4566//#endregion
4567//#region node_modules/@noble/curves/esm/abstract/utils.js

4568var utils_exports = /* @__PURE__ */ __exportAll({
4569	bitGet: () => bitGet,
4570	bitLen: () => bitLen,
4571	bitMask: () => bitMask,
4572	bitSet: () => bitSet,
4573	bytesToHex: () => bytesToHex,
4574	bytesToNumberBE: () => bytesToNumberBE,
4575	bytesToNumberLE: () => bytesToNumberLE,
4576	concatBytes: () => concatBytes,
4577	createHmacDrbg: () => createHmacDrbg,
4578	ensureBytes: () => ensureBytes,
4579	equalBytes: () => equalBytes,
4580	hexToBytes: () => hexToBytes,
4581	hexToNumber: () => hexToNumber,
4582	numberToBytesBE: () => numberToBytesBE,
4583	numberToBytesLE: () => numberToBytesLE,
4584	numberToHexUnpadded: () => numberToHexUnpadded,
4585	numberToVarBytesBE: () => numberToVarBytesBE,
4586	utf8ToBytes: () => utf8ToBytes,
4587	validateObject: () => validateObject
4588});
4589/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
4590var _0n$3 = BigInt(0);
4591var _1n$4 = BigInt(1);
4592var _2n$2 = BigInt(2);
4593var u8a = (a) => a instanceof Uint8Array;
4594var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
4595/**
4596* @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
4597*/
4598function bytesToHex(bytes) {
4599	if (!u8a(bytes)) throw new Error("Uint8Array expected");
4600	let hex = "";
4601	for (let i = 0; i < bytes.length; i++) hex += hexes[bytes[i]];
4602	return hex;
4603}
4604function numberToHexUnpadded(num) {
4605	const hex = num.toString(16);
4606	return hex.length & 1 ? `0${hex}` : hex;
4607}
4608function hexToNumber(hex) {
4609	if (typeof hex !== "string") throw new Error("hex string expected, got " + typeof hex);
4610	return BigInt(hex === "" ? "0" : `0x${hex}`);
4611}
4612/**
4613* @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
4614*/
4615function hexToBytes(hex) {
4616	if (typeof hex !== "string") throw new Error("hex string expected, got " + typeof hex);
4617	const len = hex.length;
4618	if (len % 2) throw new Error("padded hex string expected, got unpadded hex of length " + len);
4619	const array = new Uint8Array(len / 2);
4620	for (let i = 0; i < array.length; i++) {
4621		const j = i * 2;
4622		const hexByte = hex.slice(j, j + 2);
4623		const byte = Number.parseInt(hexByte, 16);
4624		if (Number.isNaN(byte) || byte < 0) throw new Error("Invalid byte sequence");
4625		array[i] = byte;
4626	}
4627	return array;
4628}
4629function bytesToNumberBE(bytes) {
4630	return hexToNumber(bytesToHex(bytes));
4631}
4632function bytesToNumberLE(bytes) {
4633	if (!u8a(bytes)) throw new Error("Uint8Array expected");
4634	return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));
4635}
4636function numberToBytesBE(n, len) {
4637	return hexToBytes(n.toString(16).padStart(len * 2, "0"));
4638}
4639function numberToBytesLE(n, len) {
4640	return numberToBytesBE(n, len).reverse();
4641}
4642function numberToVarBytesBE(n) {
4643	return hexToBytes(numberToHexUnpadded(n));
4644}
4645/**
4646* Takes hex string or Uint8Array, converts to Uint8Array.
4647* Validates output length.
4648* Will throw error for other types.
4649* @param title descriptive title for an error e.g. 'private key'
4650* @param hex hex string or Uint8Array
4651* @param expectedLength optional, will compare to result array's length
4652* @returns
4653*/
4654function ensureBytes(title, hex, expectedLength) {
4655	let res;
4656	if (typeof hex === "string") try {
4657		res = hexToBytes(hex);
4658	} catch (e) {
4659		throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
4660	}
4661	else if (u8a(hex)) res = Uint8Array.from(hex);
4662	else throw new Error(`${title} must be hex string or Uint8Array`);
4663	const len = res.length;
4664	if (typeof expectedLength === "number" && len !== expectedLength) throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
4665	return res;
4666}
4667/**
4668* Copies several Uint8Arrays into one.
4669*/
4670function concatBytes(...arrays) {
4671	const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));
4672	let pad = 0;
4673	arrays.forEach((a) => {
4674		if (!u8a(a)) throw new Error("Uint8Array expected");
4675		r.set(a, pad);
4676		pad += a.length;
4677	});
4678	return r;
4679}
4680function equalBytes(b1, b2) {
4681	if (b1.length !== b2.length) return false;
4682	for (let i = 0; i < b1.length; i++) if (b1[i] !== b2[i]) return false;
4683	return true;
4684}
4685/**
4686* @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
4687*/
4688function utf8ToBytes(str) {
4689	if (typeof str !== "string") throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
4690	return new Uint8Array(new TextEncoder().encode(str));
4691}
4692/**
4693* Calculates amount of bits in a bigint.
4694* Same as `n.toString(2).length`
4695*/
4696function bitLen(n) {
4697	let len = 0;
4698	for (; n > _0n$3; n >>= _1n$4, len += 1);
4699	return len;
4700}
4701/**
4702* Gets single bit at position.
4703* NOTE: first bit position is 0 (same as arrays)
4704* Same as `!!+Array.from(n.toString(2)).reverse()[pos]`
4705*/
4706function bitGet(n, pos) {
4707	return n >> BigInt(pos) & _1n$4;
4708}
4709/**
4710* Sets single bit at position.
4711*/
4712var bitSet = (n, pos, value) => {
4713	return n | (value ? _1n$4 : _0n$3) << BigInt(pos);
4714};
4715/**
4716* Calculate mask for N bits. Not using ** operator with bigints because of old engines.
4717* Same as BigInt(`0b${Array(i).fill('1').join('')}`)
4718*/
4719var bitMask = (n) => (_2n$2 << BigInt(n - 1)) - _1n$4;
4720var u8n = (data) => new Uint8Array(data);

vendor: 10,484 bytes, lines 4721-5059

4721var u8fr = (arr) => Uint8Array.from(arr);
4722/**
4723* Minimal HMAC-DRBG from NIST 800-90 for RFC6979 sigs.
4724* @returns function that will call DRBG until 2nd arg returns something meaningful
4725* @example
4726*   const drbg = createHmacDRBG<Key>(32, 32, hmac);
4727*   drbg(seed, bytesToKey); // bytesToKey must return Key or undefined
4728*/
4729function createHmacDrbg(hashLen, qByteLen, hmacFn) {
4730	if (typeof hashLen !== "number" || hashLen < 2) throw new Error("hashLen must be a number");
4731	if (typeof qByteLen !== "number" || qByteLen < 2) throw new Error("qByteLen must be a number");
4732	if (typeof hmacFn !== "function") throw new Error("hmacFn must be a function");
4733	let v = u8n(hashLen);
4734	let k = u8n(hashLen);
4735	let i = 0;
4736	const reset = () => {
4737		v.fill(1);
4738		k.fill(0);
4739		i = 0;
4740	};
4741	const h = (...b) => hmacFn(k, v, ...b);
4742	const reseed = (seed = u8n()) => {
4743		k = h(u8fr([0]), seed);
4744		v = h();
4745		if (seed.length === 0) return;
4746		k = h(u8fr([1]), seed);
4747		v = h();
4748	};
4749	const gen = () => {
4750		if (i++ >= 1e3) throw new Error("drbg: tried 1000 values");
4751		let len = 0;
4752		const out = [];
4753		while (len < qByteLen) {
4754			v = h();
4755			const sl = v.slice();
4756			out.push(sl);
4757			len += v.length;
4758		}
4759		return concatBytes(...out);
4760	};
4761	const genUntil = (seed, pred) => {
4762		reset();
4763		reseed(seed);
4764		let res = void 0;
4765		while (!(res = pred(gen()))) reseed();
4766		reset();
4767		return res;
4768	};
4769	return genUntil;
4770}
4771var validatorFns = {
4772	bigint: (val) => typeof val === "bigint",
4773	function: (val) => typeof val === "function",
4774	boolean: (val) => typeof val === "boolean",
4775	string: (val) => typeof val === "string",
4776	stringOrUint8Array: (val) => typeof val === "string" || val instanceof Uint8Array,
4777	isSafeInteger: (val) => Number.isSafeInteger(val),
4778	array: (val) => Array.isArray(val),
4779	field: (val, object) => object.Fp.isValid(val),
4780	hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
4781};
4782function validateObject(object, validators, optValidators = {}) {
4783	const checkField = (fieldName, type, isOptional) => {
4784		const checkVal = validatorFns[type];
4785		if (typeof checkVal !== "function") throw new Error(`Invalid validator "${type}", expected function`);
4786		const val = object[fieldName];
4787		if (isOptional && val === void 0) return;
4788		if (!checkVal(val, object)) throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);
4789	};
4790	for (const [fieldName, type] of Object.entries(validators)) checkField(fieldName, type, false);
4791	for (const [fieldName, type] of Object.entries(optValidators)) checkField(fieldName, type, true);
4792	return object;
4793}
4794//#endregion
4795//#region node_modules/@noble/curves/esm/abstract/modular.js
4796/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
4797var _0n$2 = BigInt(0);
4798var _1n$3 = BigInt(1);
4799var _2n$1 = BigInt(2);
4800var _3n$1 = BigInt(3);
4801var _4n = BigInt(4);
4802var _5n = BigInt(5);
4803var _8n = BigInt(8);
4804var _9n = BigInt(9);
4805var _16n = BigInt(16);
4806function mod(a, b) {
4807	const result = a % b;
4808	return result >= _0n$2 ? result : b + result;
4809}
4810/**
4811* Efficiently raise num to power and do modular division.
4812* Unsafe in some contexts: uses ladder, so can expose bigint bits.
4813* @example
4814* pow(2n, 6n, 11n) // 64n % 11n == 9n
4815*/
4816function pow(num, power, modulo) {
4817	if (modulo <= _0n$2 || power < _0n$2) throw new Error("Expected power/modulo > 0");
4818	if (modulo === _1n$3) return _0n$2;
4819	let res = _1n$3;
4820	while (power > _0n$2) {
4821		if (power & _1n$3) res = res * num % modulo;
4822		num = num * num % modulo;
4823		power >>= _1n$3;
4824	}
4825	return res;
4826}
4827function pow2(x, power, modulo) {
4828	let res = x;
4829	while (power-- > _0n$2) {
4830		res *= res;
4831		res %= modulo;
4832	}
4833	return res;
4834}
4835function invert(number, modulo) {
4836	if (number === _0n$2 || modulo <= _0n$2) throw new Error(`invert: expected positive integers, got n=${number} mod=${modulo}`);
4837	let a = mod(number, modulo);
4838	let b = modulo;
4839	let x = _0n$2, y = _1n$3, u = _1n$3, v = _0n$2;
4840	while (a !== _0n$2) {
4841		const q = b / a;
4842		const r = b % a;
4843		const m = x - u * q;
4844		const n = y - v * q;
4845		b = a, a = r, x = u, y = v, u = m, v = n;
4846	}
4847	if (b !== _1n$3) throw new Error("invert: does not exist");
4848	return mod(x, modulo);
4849}
4850/**
4851* Tonelli-Shanks square root search algorithm.
4852* 1. https://eprint.iacr.org/2012/685.pdf (page 12)
4853* 2. Square Roots from 1; 24, 51, 10 to Dan Shanks
4854* Will start an infinite loop if field order P is not prime.
4855* @param P field order
4856* @returns function that takes field Fp (created from P) and number n
4857*/
4858function tonelliShanks(P) {
4859	const legendreC = (P - _1n$3) / _2n$1;
4860	let Q, S, Z;
4861	for (Q = P - _1n$3, S = 0; Q % _2n$1 === _0n$2; Q /= _2n$1, S++);
4862	for (Z = _2n$1; Z < P && pow(Z, legendreC, P) !== P - _1n$3; Z++);
4863	if (S === 1) {
4864		const p1div4 = (P + _1n$3) / _4n;
4865		return function tonelliFast(Fp, n) {
4866			const root = Fp.pow(n, p1div4);
4867			if (!Fp.eql(Fp.sqr(root), n)) throw new Error("Cannot find square root");
4868			return root;
4869		};
4870	}
4871	const Q1div2 = (Q + _1n$3) / _2n$1;
4872	return function tonelliSlow(Fp, n) {
4873		if (Fp.pow(n, legendreC) === Fp.neg(Fp.ONE)) throw new Error("Cannot find square root");
4874		let r = S;
4875		let g = Fp.pow(Fp.mul(Fp.ONE, Z), Q);
4876		let x = Fp.pow(n, Q1div2);
4877		let b = Fp.pow(n, Q);
4878		while (!Fp.eql(b, Fp.ONE)) {
4879			if (Fp.eql(b, Fp.ZERO)) return Fp.ZERO;
4880			let m = 1;
4881			for (let t2 = Fp.sqr(b); m < r; m++) {
4882				if (Fp.eql(t2, Fp.ONE)) break;
4883				t2 = Fp.sqr(t2);
4884			}
4885			const ge = Fp.pow(g, _1n$3 << BigInt(r - m - 1));
4886			g = Fp.sqr(ge);
4887			x = Fp.mul(x, ge);
4888			b = Fp.mul(b, g);
4889			r = m;
4890		}
4891		return x;
4892	};
4893}
4894function FpSqrt(P) {
4895	if (P % _4n === _3n$1) {
4896		const p1div4 = (P + _1n$3) / _4n;
4897		return function sqrt3mod4(Fp, n) {
4898			const root = Fp.pow(n, p1div4);
4899			if (!Fp.eql(Fp.sqr(root), n)) throw new Error("Cannot find square root");
4900			return root;
4901		};
4902	}
4903	if (P % _8n === _5n) {
4904		const c1 = (P - _5n) / _8n;
4905		return function sqrt5mod8(Fp, n) {
4906			const n2 = Fp.mul(n, _2n$1);
4907			const v = Fp.pow(n2, c1);
4908			const nv = Fp.mul(n, v);
4909			const i = Fp.mul(Fp.mul(nv, _2n$1), v);
4910			const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));
4911			if (!Fp.eql(Fp.sqr(root), n)) throw new Error("Cannot find square root");
4912			return root;
4913		};
4914	}
4915	if (P % _16n === _9n) {}
4916	return tonelliShanks(P);
4917}
4918var FIELD_FIELDS = [
4919	"create",
4920	"isValid",
4921	"is0",
4922	"neg",
4923	"inv",
4924	"sqrt",
4925	"sqr",
4926	"eql",
4927	"add",
4928	"sub",
4929	"mul",
4930	"pow",
4931	"div",
4932	"addN",
4933	"subN",
4934	"mulN",
4935	"sqrN"
4936];
4937function validateField(field) {
4938	return validateObject(field, FIELD_FIELDS.reduce((map, val) => {
4939		map[val] = "function";
4940		return map;
4941	}, {
4942		ORDER: "bigint",
4943		MASK: "bigint",
4944		BYTES: "isSafeInteger",
4945		BITS: "isSafeInteger"
4946	}));
4947}
4948/**
4949* Same as `pow` but for Fp: non-constant-time.
4950* Unsafe in some contexts: uses ladder, so can expose bigint bits.
4951*/
4952function FpPow(f, num, power) {
4953	if (power < _0n$2) throw new Error("Expected power > 0");
4954	if (power === _0n$2) return f.ONE;
4955	if (power === _1n$3) return num;
4956	let p = f.ONE;
4957	let d = num;
4958	while (power > _0n$2) {
4959		if (power & _1n$3) p = f.mul(p, d);
4960		d = f.sqr(d);
4961		power >>= _1n$3;
4962	}
4963	return p;
4964}
4965/**
4966* Efficiently invert an array of Field elements.
4967* `inv(0)` will return `undefined` here: make sure to throw an error.
4968*/
4969function FpInvertBatch(f, nums) {
4970	const tmp = new Array(nums.length);
4971	const lastMultiplied = nums.reduce((acc, num, i) => {
4972		if (f.is0(num)) return acc;
4973		tmp[i] = acc;
4974		return f.mul(acc, num);
4975	}, f.ONE);
4976	const inverted = f.inv(lastMultiplied);
4977	nums.reduceRight((acc, num, i) => {
4978		if (f.is0(num)) return acc;
4979		tmp[i] = f.mul(acc, tmp[i]);
4980		return f.mul(acc, num);
4981	}, inverted);
4982	return tmp;
4983}
4984function nLength(n, nBitLength) {
4985	const _nBitLength = nBitLength !== void 0 ? nBitLength : n.toString(2).length;
4986	return {
4987		nBitLength: _nBitLength,
4988		nByteLength: Math.ceil(_nBitLength / 8)
4989	};
4990}
4991/**
4992* Initializes a finite field over prime. **Non-primes are not supported.**
4993* Do not init in loop: slow. Very fragile: always run a benchmark on a change.
4994* Major performance optimizations:
4995* * a) denormalized operations like mulN instead of mul
4996* * b) same object shape: never add or remove keys
4997* * c) Object.freeze
4998* @param ORDER prime positive bigint
4999* @param bitLen how many bits the field consumes
5000* @param isLE (def: false) if encoding / decoding should be in little-endian
5001* @param redef optional faster redefinitions of sqrt and other methods
5002*/
5003function Field(ORDER, bitLen, isLE = false, redef = {}) {
5004	if (ORDER <= _0n$2) throw new Error(`Expected Field ORDER > 0, got ${ORDER}`);
5005	const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen);
5006	if (BYTES > 2048) throw new Error("Field lengths over 2048 bytes are not supported");
5007	const sqrtP = FpSqrt(ORDER);
5008	const f = Object.freeze({
5009		ORDER,
5010		BITS,
5011		BYTES,
5012		MASK: bitMask(BITS),
5013		ZERO: _0n$2,
5014		ONE: _1n$3,
5015		create: (num) => mod(num, ORDER),
5016		isValid: (num) => {
5017			if (typeof num !== "bigint") throw new Error(`Invalid field element: expected bigint, got ${typeof num}`);
5018			return _0n$2 <= num && num < ORDER;
5019		},
5020		is0: (num) => num === _0n$2,
5021		isOdd: (num) => (num & _1n$3) === _1n$3,
5022		neg: (num) => mod(-num, ORDER),
5023		eql: (lhs, rhs) => lhs === rhs,
5024		sqr: (num) => mod(num * num, ORDER),
5025		add: (lhs, rhs) => mod(lhs + rhs, ORDER),
5026		sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
5027		mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
5028		pow: (num, power) => FpPow(f, num, power),
5029		div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
5030		sqrN: (num) => num * num,
5031		addN: (lhs, rhs) => lhs + rhs,
5032		subN: (lhs, rhs) => lhs - rhs,
5033		mulN: (lhs, rhs) => lhs * rhs,
5034		inv: (num) => invert(num, ORDER),
5035		sqrt: redef.sqrt || ((n) => sqrtP(f, n)),
5036		invertBatch: (lst) => FpInvertBatch(f, lst),
5037		cmov: (a, b, c) => c ? b : a,
5038		toBytes: (num) => isLE ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES),
5039		fromBytes: (bytes) => {
5040			if (bytes.length !== BYTES) throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes.length}`);
5041			return isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);
5042		}
5043	});
5044	return Object.freeze(f);
5045}
5046/**
5047* Returns total number of bytes consumed by the field element.
5048* For example, 32 bytes for usual 256-bit weierstrass curve.
5049* @param fieldOrder number of field elements, usually CURVE.n
5050* @returns byte length of field
5051*/
5052function getFieldBytesLength(fieldOrder) {
5053	if (typeof fieldOrder !== "bigint") throw new Error("field order must be bigint");
5054	const bitLength = fieldOrder.toString(2).length;
5055	return Math.ceil(bitLength / 8);
5056}
5057/**
5058* Returns minimal amount of bytes that can be safely reduced
5059* by field order.

5060* Should be 2^-128 for 128-bit curve such as P256.
5061* @param fieldOrder number of field elements, usually CURVE.n
5062* @returns byte length of target hash
5063*/
5064function getMinHashLength(fieldOrder) {
5065	const length = getFieldBytesLength(fieldOrder);
5066	return length + Math.ceil(length / 2);
5067}
5068/**
5069* "Constant-time" private key generation utility.
5070* Can take (n + n/2) or more bytes of uniform input e.g. from CSPRNG or KDF
5071* and convert them into private scalar, with the modulo bias being negligible.
5072* Needs at least 48 bytes of input for 32-byte private key.
5073* https://research.kudelskisecurity.com/2020/07/28/the-definitive-guide-to-modulo-bias-and-how-to-avoid-it/
5074* FIPS 186-5, A.2 https://csrc.nist.gov/publications/detail/fips/186/5/final
5075* RFC 9380, https://www.rfc-editor.org/rfc/rfc9380#section-5
5076* @param hash hash output from SHA3 or a similar function
5077* @param groupOrder size of subgroup - (e.g. secp256k1.CURVE.n)
5078* @param isLE interpret hash bytes as LE num
5079* @returns valid private scalar
5080*/
5081function mapHashToField(key, fieldOrder, isLE = false) {
5082	const len = key.length;
5083	const fieldLen = getFieldBytesLength(fieldOrder);
5084	const minLen = getMinHashLength(fieldOrder);
5085	if (len < 16 || len < minLen || len > 1024) throw new Error(`expected ${minLen}-1024 bytes of input, got ${len}`);
5086	const reduced = mod(isLE ? bytesToNumberBE(key) : bytesToNumberLE(key), fieldOrder - _1n$3) + _1n$3;
5087	return isLE ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
5088}
5089//#endregion
5090//#region node_modules/@noble/curves/esm/abstract/curve.js
5091/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
5092var _0n$1 = BigInt(0);
5093var _1n$2 = BigInt(1);
5094function wNAF(c, bits) {
5095	const constTimeNegate = (condition, item) => {
5096		const neg = item.negate();
5097		return condition ? neg : item;
5098	};
5099	const opts = (W) => {
5100		return {
5101			windows: Math.ceil(bits / W) + 1,
5102			windowSize: 2 ** (W - 1)
5103		};
5104	};
5105	return {
5106		constTimeNegate,
5107		unsafeLadder(elm, n) {
5108			let p = c.ZERO;
5109			let d = elm;
5110			while (n > _0n$1) {
5111				if (n & _1n$2) p = p.add(d);
5112				d = d.double();
5113				n >>= _1n$2;
5114			}
5115			return p;
5116		},
5117		/**
5118		* Creates a wNAF precomputation window. Used for caching.
5119		* Default window size is set by `utils.precompute()` and is equal to 8.
5120		* Number of precomputed points depends on the curve size:
5121		* 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
5122		* - 𝑊 is the window size
5123		* - 𝑛 is the bitlength of the curve order.
5124		* For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
5125		* @returns precomputed point tables flattened to a single array
5126		*/
5127		precomputeWindow(elm, W) {
5128			const { windows, windowSize } = opts(W);
5129			const points = [];
5130			let p = elm;
5131			let base = p;
5132			for (let window = 0; window < windows; window++) {
5133				base = p;
5134				points.push(base);
5135				for (let i = 1; i < windowSize; i++) {
5136					base = base.add(p);
5137					points.push(base);
5138				}
5139				p = base.double();
5140			}
5141			return points;
5142		},
5143		/**
5144		* Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
5145		* @param W window size
5146		* @param precomputes precomputed tables
5147		* @param n scalar (we don't check here, but should be less than curve order)
5148		* @returns real and fake (for const-time) points
5149		*/
5150		wNAF(W, precomputes, n) {
5151			const { windows, windowSize } = opts(W);
5152			let p = c.ZERO;
5153			let f = c.BASE;
5154			const mask = BigInt(2 ** W - 1);
5155			const maxNumber = 2 ** W;
5156			const shiftBy = BigInt(W);
5157			for (let window = 0; window < windows; window++) {
5158				const offset = window * windowSize;
5159				let wbits = Number(n & mask);
5160				n >>= shiftBy;
5161				if (wbits > windowSize) {
5162					wbits -= maxNumber;
5163					n += _1n$2;
5164				}
5165				const offset1 = offset;
5166				const offset2 = offset + Math.abs(wbits) - 1;
5167				const cond1 = window % 2 !== 0;
5168				const cond2 = wbits < 0;
5169				if (wbits === 0) f = f.add(constTimeNegate(cond1, precomputes[offset1]));
5170				else p = p.add(constTimeNegate(cond2, precomputes[offset2]));
5171			}
5172			return {
5173				p,
5174				f
5175			};
5176		},
5177		wNAFCached(P, precomputesMap, n, transform) {
5178			const W = P._WINDOW_SIZE || 1;
5179			let comp = precomputesMap.get(P);
5180			if (!comp) {

5181				comp = this.precomputeWindow(P, W);
5182				if (W !== 1) precomputesMap.set(P, transform(comp));
5183			}
5184			return this.wNAF(W, comp, n);
5185		}
5186	};
5187}
5188function validateBasic(curve) {
5189	validateField(curve.Fp);
5190	validateObject(curve, {
5191		n: "bigint",
5192		h: "bigint",
5193		Gx: "field",
5194		Gy: "field"
5195	}, {
5196		nBitLength: "isSafeInteger",
5197		nByteLength: "isSafeInteger"
5198	});
5199	return Object.freeze({
5200		...nLength(curve.n, curve.nBitLength),
5201		...curve,
5202		p: curve.Fp.ORDER
5203	});
5204}
5205//#endregion
5206//#region node_modules/@noble/curves/esm/abstract/weierstrass.js
5207/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
5208function validatePointOpts(curve) {
5209	const opts = validateBasic(curve);
5210	validateObject(opts, {
5211		a: "field",
5212		b: "field"
5213	}, {
5214		allowedPrivateKeyLengths: "array",
5215		wrapPrivateKey: "boolean",
5216		isTorsionFree: "function",
5217		clearCofactor: "function",
5218		allowInfinityPoint: "boolean",
5219		fromBytes: "function",
5220		toBytes: "function"
5221	});
5222	const { endo, Fp, a } = opts;
5223	if (endo) {
5224		if (!Fp.eql(a, Fp.ZERO)) throw new Error("Endomorphism can only be defined for Koblitz curves that have a=0");
5225		if (typeof endo !== "object" || typeof endo.beta !== "bigint" || typeof endo.splitScalar !== "function") throw new Error("Expected endomorphism with beta: bigint and splitScalar: function");
5226	}
5227	return Object.freeze({ ...opts });
5228}
5229var { bytesToNumberBE: b2n, hexToBytes: h2b } = utils_exports;
5230var DER = {
5231	Err: class DERErr extends Error {
5232		constructor(m = "") {
5233			super(m);
5234		}
5235	},
5236	_parseInt(data) {
5237		const { Err: E } = DER;
5238		if (data.length < 2 || data[0] !== 2) throw new E("Invalid signature integer tag");

vendor: 14,427 bytes, lines 5239-5698

5239		const len = data[1];
5240		const res = data.subarray(2, len + 2);
5241		if (!len || res.length !== len) throw new E("Invalid signature integer: wrong length");
5242		if (res[0] & 128) throw new E("Invalid signature integer: negative");
5243		if (res[0] === 0 && !(res[1] & 128)) throw new E("Invalid signature integer: unnecessary leading zero");
5244		return {
5245			d: b2n(res),
5246			l: data.subarray(len + 2)
5247		};
5248	},
5249	toSig(hex) {
5250		const { Err: E } = DER;
5251		const data = typeof hex === "string" ? h2b(hex) : hex;
5252		if (!(data instanceof Uint8Array)) throw new Error("ui8a expected");
5253		let l = data.length;
5254		if (l < 2 || data[0] != 48) throw new E("Invalid signature tag");
5255		if (data[1] !== l - 2) throw new E("Invalid signature: incorrect length");
5256		const { d: r, l: sBytes } = DER._parseInt(data.subarray(2));
5257		const { d: s, l: rBytesLeft } = DER._parseInt(sBytes);
5258		if (rBytesLeft.length) throw new E("Invalid signature: left bytes after parsing");
5259		return {
5260			r,
5261			s
5262		};
5263	},
5264	hexFromSig(sig) {
5265		const slice = (s) => Number.parseInt(s[0], 16) & 8 ? "00" + s : s;
5266		const h = (num) => {
5267			const hex = num.toString(16);
5268			return hex.length & 1 ? `0${hex}` : hex;
5269		};
5270		const s = slice(h(sig.s));
5271		const r = slice(h(sig.r));
5272		const shl = s.length / 2;
5273		const rhl = r.length / 2;
5274		const sl = h(shl);
5275		const rl = h(rhl);
5276		return `30${h(rhl + shl + 4)}02${rl}${r}02${sl}${s}`;
5277	}
5278};
5279var _0n = BigInt(0);
5280var _1n$1 = BigInt(1);
5281var _3n = BigInt(3);
5282function weierstrassPoints(opts) {
5283	const CURVE = validatePointOpts(opts);
5284	const { Fp } = CURVE;
5285	const toBytes = CURVE.toBytes || ((_c, point, _isCompressed) => {
5286		const a = point.toAffine();
5287		return concatBytes(Uint8Array.from([4]), Fp.toBytes(a.x), Fp.toBytes(a.y));
5288	});
5289	const fromBytes = CURVE.fromBytes || ((bytes) => {
5290		const tail = bytes.subarray(1);
5291		return {
5292			x: Fp.fromBytes(tail.subarray(0, Fp.BYTES)),
5293			y: Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES))
5294		};
5295	});
5296	/**
5297	* y² = x³ + ax + b: Short weierstrass curve formula
5298	* @returns y²
5299	*/
5300	function weierstrassEquation(x) {
5301		const { a, b } = CURVE;
5302		const x2 = Fp.sqr(x);
5303		const x3 = Fp.mul(x2, x);
5304		return Fp.add(Fp.add(x3, Fp.mul(x, a)), b);
5305	}
5306	if (!Fp.eql(Fp.sqr(CURVE.Gy), weierstrassEquation(CURVE.Gx))) throw new Error("bad generator point: equation left != right");
5307	function isWithinCurveOrder(num) {
5308		return typeof num === "bigint" && _0n < num && num < CURVE.n;
5309	}
5310	function assertGE(num) {
5311		if (!isWithinCurveOrder(num)) throw new Error("Expected valid bigint: 0 < bigint < curve.n");
5312	}
5313	function normPrivateKeyToScalar(key) {
5314		const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n } = CURVE;
5315		if (lengths && typeof key !== "bigint") {
5316			if (key instanceof Uint8Array) key = bytesToHex(key);
5317			if (typeof key !== "string" || !lengths.includes(key.length)) throw new Error("Invalid key");
5318			key = key.padStart(nByteLength * 2, "0");
5319		}
5320		let num;
5321		try {
5322			num = typeof key === "bigint" ? key : bytesToNumberBE(ensureBytes("private key", key, nByteLength));
5323		} catch (error) {
5324			throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);
5325		}
5326		if (wrapPrivateKey) num = mod(num, n);
5327		assertGE(num);
5328		return num;
5329	}
5330	const pointPrecomputes = /* @__PURE__ */ new Map();
5331	function assertPrjPoint(other) {
5332		if (!(other instanceof Point)) throw new Error("ProjectivePoint expected");
5333	}
5334	/**
5335	* Projective Point works in 3d / projective (homogeneous) coordinates: (x, y, z) ∋ (x=x/z, y=y/z)
5336	* Default Point works in 2d / affine coordinates: (x, y)
5337	* We're doing calculations in projective, because its operations don't require costly inversion.
5338	*/
5339	class Point {
5340		constructor(px, py, pz) {
5341			this.px = px;
5342			this.py = py;
5343			this.pz = pz;
5344			if (px == null || !Fp.isValid(px)) throw new Error("x required");
5345			if (py == null || !Fp.isValid(py)) throw new Error("y required");
5346			if (pz == null || !Fp.isValid(pz)) throw new Error("z required");
5347		}
5348		static fromAffine(p) {
5349			const { x, y } = p || {};
5350			if (!p || !Fp.isValid(x) || !Fp.isValid(y)) throw new Error("invalid affine point");
5351			if (p instanceof Point) throw new Error("projective point not allowed");
5352			const is0 = (i) => Fp.eql(i, Fp.ZERO);
5353			if (is0(x) && is0(y)) return Point.ZERO;
5354			return new Point(x, y, Fp.ONE);
5355		}
5356		get x() {
5357			return this.toAffine().x;
5358		}
5359		get y() {
5360			return this.toAffine().y;
5361		}
5362		/**
5363		* Takes a bunch of Projective Points but executes only one
5364		* inversion on all of them. Inversion is very slow operation,
5365		* so this improves performance massively.
5366		* Optimization: converts a list of projective points to a list of identical points with Z=1.
5367		*/
5368		static normalizeZ(points) {
5369			const toInv = Fp.invertBatch(points.map((p) => p.pz));
5370			return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
5371		}
5372		/**
5373		* Converts hash string or Uint8Array to Point.
5374		* @param hex short/long ECDSA hex
5375		*/
5376		static fromHex(hex) {
5377			const P = Point.fromAffine(fromBytes(ensureBytes("pointHex", hex)));
5378			P.assertValidity();
5379			return P;
5380		}
5381		static fromPrivateKey(privateKey) {
5382			return Point.BASE.multiply(normPrivateKeyToScalar(privateKey));
5383		}
5384		_setWindowSize(windowSize) {
5385			this._WINDOW_SIZE = windowSize;
5386			pointPrecomputes.delete(this);
5387		}
5388		assertValidity() {
5389			if (this.is0()) {
5390				if (CURVE.allowInfinityPoint && !Fp.is0(this.py)) return;
5391				throw new Error("bad point: ZERO");
5392			}
5393			const { x, y } = this.toAffine();
5394			if (!Fp.isValid(x) || !Fp.isValid(y)) throw new Error("bad point: x or y not FE");
5395			const left = Fp.sqr(y);
5396			const right = weierstrassEquation(x);
5397			if (!Fp.eql(left, right)) throw new Error("bad point: equation left != right");
5398			if (!this.isTorsionFree()) throw new Error("bad point: not in prime-order subgroup");
5399		}
5400		hasEvenY() {
5401			const { y } = this.toAffine();
5402			if (Fp.isOdd) return !Fp.isOdd(y);
5403			throw new Error("Field doesn't support isOdd");
5404		}
5405		/**
5406		* Compare one point to another.
5407		*/
5408		equals(other) {
5409			assertPrjPoint(other);
5410			const { px: X1, py: Y1, pz: Z1 } = this;
5411			const { px: X2, py: Y2, pz: Z2 } = other;
5412			const U1 = Fp.eql(Fp.mul(X1, Z2), Fp.mul(X2, Z1));
5413			const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1));
5414			return U1 && U2;
5415		}
5416		/**
5417		* Flips point to one corresponding to (x, -y) in Affine coordinates.
5418		*/
5419		negate() {
5420			return new Point(this.px, Fp.neg(this.py), this.pz);
5421		}
5422		double() {
5423			const { a, b } = CURVE;
5424			const b3 = Fp.mul(b, _3n);
5425			const { px: X1, py: Y1, pz: Z1 } = this;
5426			let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO;
5427			let t0 = Fp.mul(X1, X1);
5428			let t1 = Fp.mul(Y1, Y1);
5429			let t2 = Fp.mul(Z1, Z1);
5430			let t3 = Fp.mul(X1, Y1);
5431			t3 = Fp.add(t3, t3);
5432			Z3 = Fp.mul(X1, Z1);
5433			Z3 = Fp.add(Z3, Z3);
5434			X3 = Fp.mul(a, Z3);
5435			Y3 = Fp.mul(b3, t2);
5436			Y3 = Fp.add(X3, Y3);
5437			X3 = Fp.sub(t1, Y3);
5438			Y3 = Fp.add(t1, Y3);
5439			Y3 = Fp.mul(X3, Y3);
5440			X3 = Fp.mul(t3, X3);
5441			Z3 = Fp.mul(b3, Z3);
5442			t2 = Fp.mul(a, t2);
5443			t3 = Fp.sub(t0, t2);
5444			t3 = Fp.mul(a, t3);
5445			t3 = Fp.add(t3, Z3);
5446			Z3 = Fp.add(t0, t0);
5447			t0 = Fp.add(Z3, t0);
5448			t0 = Fp.add(t0, t2);
5449			t0 = Fp.mul(t0, t3);
5450			Y3 = Fp.add(Y3, t0);
5451			t2 = Fp.mul(Y1, Z1);
5452			t2 = Fp.add(t2, t2);
5453			t0 = Fp.mul(t2, t3);
5454			X3 = Fp.sub(X3, t0);
5455			Z3 = Fp.mul(t2, t1);
5456			Z3 = Fp.add(Z3, Z3);
5457			Z3 = Fp.add(Z3, Z3);
5458			return new Point(X3, Y3, Z3);
5459		}
5460		add(other) {
5461			assertPrjPoint(other);
5462			const { px: X1, py: Y1, pz: Z1 } = this;
5463			const { px: X2, py: Y2, pz: Z2 } = other;
5464			let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO;
5465			const a = CURVE.a;
5466			const b3 = Fp.mul(CURVE.b, _3n);
5467			let t0 = Fp.mul(X1, X2);
5468			let t1 = Fp.mul(Y1, Y2);
5469			let t2 = Fp.mul(Z1, Z2);
5470			let t3 = Fp.add(X1, Y1);
5471			let t4 = Fp.add(X2, Y2);
5472			t3 = Fp.mul(t3, t4);
5473			t4 = Fp.add(t0, t1);
5474			t3 = Fp.sub(t3, t4);
5475			t4 = Fp.add(X1, Z1);
5476			let t5 = Fp.add(X2, Z2);
5477			t4 = Fp.mul(t4, t5);
5478			t5 = Fp.add(t0, t2);
5479			t4 = Fp.sub(t4, t5);
5480			t5 = Fp.add(Y1, Z1);
5481			X3 = Fp.add(Y2, Z2);
5482			t5 = Fp.mul(t5, X3);
5483			X3 = Fp.add(t1, t2);
5484			t5 = Fp.sub(t5, X3);
5485			Z3 = Fp.mul(a, t4);
5486			X3 = Fp.mul(b3, t2);
5487			Z3 = Fp.add(X3, Z3);
5488			X3 = Fp.sub(t1, Z3);
5489			Z3 = Fp.add(t1, Z3);
5490			Y3 = Fp.mul(X3, Z3);
5491			t1 = Fp.add(t0, t0);
5492			t1 = Fp.add(t1, t0);
5493			t2 = Fp.mul(a, t2);
5494			t4 = Fp.mul(b3, t4);
5495			t1 = Fp.add(t1, t2);
5496			t2 = Fp.sub(t0, t2);
5497			t2 = Fp.mul(a, t2);
5498			t4 = Fp.add(t4, t2);
5499			t0 = Fp.mul(t1, t4);
5500			Y3 = Fp.add(Y3, t0);
5501			t0 = Fp.mul(t5, t4);
5502			X3 = Fp.mul(t3, X3);
5503			X3 = Fp.sub(X3, t0);
5504			t0 = Fp.mul(t3, t1);
5505			Z3 = Fp.mul(t5, Z3);
5506			Z3 = Fp.add(Z3, t0);
5507			return new Point(X3, Y3, Z3);
5508		}
5509		subtract(other) {
5510			return this.add(other.negate());
5511		}
5512		is0() {
5513			return this.equals(Point.ZERO);
5514		}
5515		wNAF(n) {
5516			return wnaf.wNAFCached(this, pointPrecomputes, n, (comp) => {
5517				const toInv = Fp.invertBatch(comp.map((p) => p.pz));
5518				return comp.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
5519			});
5520		}
5521		/**
5522		* Non-constant-time multiplication. Uses double-and-add algorithm.
5523		* It's faster, but should only be used when you don't care about
5524		* an exposed private key e.g. sig verification, which works over *public* keys.
5525		*/
5526		multiplyUnsafe(n) {
5527			const I = Point.ZERO;
5528			if (n === _0n) return I;
5529			assertGE(n);
5530			if (n === _1n$1) return this;
5531			const { endo } = CURVE;
5532			if (!endo) return wnaf.unsafeLadder(this, n);
5533			let { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);
5534			let k1p = I;
5535			let k2p = I;
5536			let d = this;
5537			while (k1 > _0n || k2 > _0n) {
5538				if (k1 & _1n$1) k1p = k1p.add(d);
5539				if (k2 & _1n$1) k2p = k2p.add(d);
5540				d = d.double();
5541				k1 >>= _1n$1;
5542				k2 >>= _1n$1;
5543			}
5544			if (k1neg) k1p = k1p.negate();
5545			if (k2neg) k2p = k2p.negate();
5546			k2p = new Point(Fp.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
5547			return k1p.add(k2p);
5548		}
5549		/**
5550		* Constant time multiplication.
5551		* Uses wNAF method. Windowed method may be 10% faster,
5552		* but takes 2x longer to generate and consumes 2x memory.
5553		* Uses precomputes when available.
5554		* Uses endomorphism for Koblitz curves.
5555		* @param scalar by which the point would be multiplied
5556		* @returns New point
5557		*/
5558		multiply(scalar) {
5559			assertGE(scalar);
5560			let n = scalar;
5561			let point, fake;
5562			const { endo } = CURVE;
5563			if (endo) {
5564				const { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);
5565				let { p: k1p, f: f1p } = this.wNAF(k1);
5566				let { p: k2p, f: f2p } = this.wNAF(k2);
5567				k1p = wnaf.constTimeNegate(k1neg, k1p);
5568				k2p = wnaf.constTimeNegate(k2neg, k2p);
5569				k2p = new Point(Fp.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
5570				point = k1p.add(k2p);
5571				fake = f1p.add(f2p);
5572			} else {
5573				const { p, f } = this.wNAF(n);
5574				point = p;
5575				fake = f;
5576			}
5577			return Point.normalizeZ([point, fake])[0];
5578		}
5579		/**
5580		* Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.
5581		* Not using Strauss-Shamir trick: precomputation tables are faster.
5582		* The trick could be useful if both P and Q are not G (not in our case).
5583		* @returns non-zero affine point
5584		*/
5585		multiplyAndAddUnsafe(Q, a, b) {
5586			const G = Point.BASE;
5587			const mul = (P, a) => a === _0n || a === _1n$1 || !P.equals(G) ? P.multiplyUnsafe(a) : P.multiply(a);
5588			const sum = mul(this, a).add(mul(Q, b));
5589			return sum.is0() ? void 0 : sum;
5590		}
5591		toAffine(iz) {
5592			const { px: x, py: y, pz: z } = this;
5593			const is0 = this.is0();
5594			if (iz == null) iz = is0 ? Fp.ONE : Fp.inv(z);
5595			const ax = Fp.mul(x, iz);
5596			const ay = Fp.mul(y, iz);
5597			const zz = Fp.mul(z, iz);
5598			if (is0) return {
5599				x: Fp.ZERO,
5600				y: Fp.ZERO
5601			};
5602			if (!Fp.eql(zz, Fp.ONE)) throw new Error("invZ was invalid");
5603			return {
5604				x: ax,
5605				y: ay
5606			};
5607		}
5608		isTorsionFree() {
5609			const { h: cofactor, isTorsionFree } = CURVE;
5610			if (cofactor === _1n$1) return true;
5611			if (isTorsionFree) return isTorsionFree(Point, this);
5612			throw new Error("isTorsionFree() has not been declared for the elliptic curve");
5613		}
5614		clearCofactor() {
5615			const { h: cofactor, clearCofactor } = CURVE;
5616			if (cofactor === _1n$1) return this;
5617			if (clearCofactor) return clearCofactor(Point, this);
5618			return this.multiplyUnsafe(CURVE.h);
5619		}
5620		toRawBytes(isCompressed = true) {
5621			this.assertValidity();
5622			return toBytes(Point, this, isCompressed);
5623		}
5624		toHex(isCompressed = true) {
5625			return bytesToHex(this.toRawBytes(isCompressed));
5626		}
5627	}
5628	Point.BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);
5629	Point.ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO);
5630	const _bits = CURVE.nBitLength;
5631	const wnaf = wNAF(Point, CURVE.endo ? Math.ceil(_bits / 2) : _bits);
5632	return {
5633		CURVE,
5634		ProjectivePoint: Point,
5635		normPrivateKeyToScalar,
5636		weierstrassEquation,
5637		isWithinCurveOrder
5638	};
5639}
5640function validateOpts(curve) {
5641	const opts = validateBasic(curve);
5642	validateObject(opts, {
5643		hash: "hash",
5644		hmac: "function",
5645		randomBytes: "function"
5646	}, {
5647		bits2int: "function",
5648		bits2int_modN: "function",
5649		lowS: "boolean"
5650	});
5651	return Object.freeze({
5652		lowS: true,
5653		...opts
5654	});
5655}
5656function weierstrass(curveDef) {
5657	const CURVE = validateOpts(curveDef);
5658	const { Fp, n: CURVE_ORDER } = CURVE;
5659	const compressedLen = Fp.BYTES + 1;
5660	const uncompressedLen = 2 * Fp.BYTES + 1;
5661	function isValidFieldElement(num) {
5662		return _0n < num && num < Fp.ORDER;
5663	}
5664	function modN(a) {
5665		return mod(a, CURVE_ORDER);
5666	}
5667	function invN(a) {
5668		return invert(a, CURVE_ORDER);
5669	}
5670	const { ProjectivePoint: Point, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints({
5671		...CURVE,
5672		toBytes(_c, point, isCompressed) {
5673			const a = point.toAffine();
5674			const x = Fp.toBytes(a.x);
5675			const cat = concatBytes;
5676			if (isCompressed) return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
5677			else return cat(Uint8Array.from([4]), x, Fp.toBytes(a.y));
5678		},
5679		fromBytes(bytes) {
5680			const len = bytes.length;
5681			const head = bytes[0];
5682			const tail = bytes.subarray(1);
5683			if (len === compressedLen && (head === 2 || head === 3)) {
5684				const x = bytesToNumberBE(tail);
5685				if (!isValidFieldElement(x)) throw new Error("Point is not on curve");
5686				const y2 = weierstrassEquation(x);
5687				let y = Fp.sqrt(y2);
5688				const isYOdd = (y & _1n$1) === _1n$1;
5689				if ((head & 1) === 1 !== isYOdd) y = Fp.neg(y);
5690				return {
5691					x,
5692					y
5693				};
5694			} else if (len === uncompressedLen && head === 4) return {
5695				x: Fp.fromBytes(tail.subarray(0, Fp.BYTES)),
5696				y: Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES))
5697			};
5698			else throw new Error(`Point of length ${len}

5698 was invalid. Expected ${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes`);
5699		}
5700	});
5701	const numToNByteStr = (num) => bytesToHex(numberToBytesBE(num, CURVE.nByteLength));
5702	function isBiggerThanHalfOrder(number) {
5703		return number > CURVE_ORDER >> _1n$1;
5704	}
5705	function normalizeS(s) {
5706		return isBiggerThanHalfOrder(s) ? modN(-s) : s;
5707	}
5708	const slcNum = (b, from, to) => bytesToNumberBE(b.slice(from, to));
5709	/**
5710	* ECDSA signature with its (r, s) properties. Supports DER & compact representations.
5711	*/
5712	class Signature {
5713		constructor(r, s, recovery) {
5714			this.r = r;
5715			this.s = s;
5716			this.recovery = recovery;
5717			this.assertValidity();
5718		}
5719		static fromCompact(hex) {
5720			const l = CURVE.nByteLength;
5721			hex = ensureBytes("compactSignature", hex, l * 2);
5722			return new Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
5723		}
5724		static fromDER(hex) {
5725			const { r, s } = DER.toSig(ensureBytes("DER", hex));
5726			return new Signature(r, s);
5727		}
5728		assertValidity() {
5729			if (!isWithinCurveOrder(this.r)) throw new Error("r must be 0 < r < CURVE.n");
5730			if (!isWithinCurveOrder(this.s)) throw new Error("s must be 0 < s < CURVE.n");
5731		}
5732		addRecoveryBit(recovery) {
5733			return new Signature(this.r, this.s, recovery);
5734		}
5735		recoverPublicKey(msgHash) {
5736			const { r, s, recovery: rec } = this;
5737			const h = bits2int_modN(ensureBytes("msgHash", msgHash));
5738			if (rec == null || ![
5739				0,
5740				1,
5741				2,
5742				3
5743			].includes(rec)) throw new Error("recovery id invalid");
5744			const radj = rec === 2 || rec === 3 ? r + CURVE.n : r;
5745			if (radj >= Fp.ORDER) throw new Error("recovery id 2 or 3 invalid");
5746			const prefix = (rec & 1) === 0 ? "02" : "03";
5747			const R = Point.fromHex(prefix + numToNByteStr(radj));
5748			const ir = invN(radj);
5749			const u1 = modN(-h * ir);
5750			const u2 = modN(s * ir);
5751			const Q = Point.BASE.multiplyAndAddUnsafe(R, u1, u2);
5752			if (!Q) throw new Error("point at infinify");
5753			Q.assertValidity();
5754			return Q;
5755		}
5756		hasHighS() {
5757			return isBiggerThanHalfOrder(this.s);
5758		}
5759		normalizeS() {
5760			return this.hasHighS() ? new Signature(this.r, modN(-this.s), this.recovery) : this;
5761		}
5762		toDERRawBytes() {
5763			return hexToBytes(this.toDERHex());
5764		}
5765		toDERHex() {
5766			return DER.hexFromSig({
5767				r: this.r,
5768				s: this.s
5769			});
5770		}
5771		toCompactRawBytes() {
5772			return hexToBytes(this.toCompactHex());
5773		}
5774		toCompactHex() {
5775			return numToNByteStr(this.r) + numToNByteStr(this.s);
5776		}
5777	}
5778	const utils = {
5779		isValidPrivateKey(privateKey) {
5780			try {
5781				normPrivateKeyToScalar(privateKey);
5782				return true;
5783			} catch (error) {
5784				return false;
5785			}
5786		},
5787		normPrivateKeyToScalar,
5788		/**
5789		* Produces cryptographically secure private key from random of size
5790		* (groupLen + ceil(groupLen / 2)) with modulo bias being negligible.
5791		*/
5792		randomPrivateKey: () => {
5793			const length = getMinHashLength(CURVE.n);
5794			return mapHashToField(CURVE.randomBytes(length), CURVE.n);
5795		},
5796		/**
5797		* Creates precompute table for an arbitrary EC point. Makes point "cached".
5798		* Allows to massively speed-up `point.multiply(scalar)`.
5799		* @returns cached point
5800		* @example
5801		* const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));
5802		* fast.multiply(privKey); // much faster ECDH now
5803		*/
5804		precompute(windowSize = 8, point = Point.BASE) {
5805			point._setWindowSize(windowSize);
5806			point.multiply(BigInt(3));
5807			return point;
5808		}
5809	};
5810	/**
5811	* Computes public key for a private key. Checks for validity of the private key.
5812	* @param privateKey private key
5813	* @param isCompressed whether to return compact (default), or full key
5814	* @returns Public key, full when isCompressed=false; short when isCompressed=true
5815	*/
5816	function getPublicKey(privateKey, isCompressed = true) {
5817		return Point.fromPrivateKey(privateKey).toRawBytes(isCompressed);
5818	}
5819	/**
5820	* Quick and dirty check for item being public key. Does not validate hex, or being on-curve.
5821	*/
5822	function isProbPub(item) {
5823		const arr = item instanceof Uint8Array;
5824		const str = typeof item === "string";
5825		const len = (arr || str) && item.length;
5826		if (arr) return len === compressedLen || len === uncompressedLen;
5827		if (str) return len === 2 * compressedLen || len === 2 * uncompressedLen;
5828		if (item instanceof Point) return true;
5829		return false;

vendor: 4,793 bytes, lines 5830-5963

5830	}
5831	/**
5832	* ECDH (Elliptic Curve Diffie Hellman).
5833	* Computes shared public key from private key and public key.
5834	* Checks: 1) private key validity 2) shared key is on-curve.
5835	* Does NOT hash the result.
5836	* @param privateA private key
5837	* @param publicB different public key
5838	* @param isCompressed whether to return compact (default), or full key
5839	* @returns shared public key
5840	*/
5841	function getSharedSecret(privateA, publicB, isCompressed = true) {
5842		if (isProbPub(privateA)) throw new Error("first arg must be private key");
5843		if (!isProbPub(publicB)) throw new Error("second arg must be public key");
5844		return Point.fromHex(publicB).multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
5845	}
5846	const bits2int = CURVE.bits2int || function(bytes) {
5847		const num = bytesToNumberBE(bytes);
5848		const delta = bytes.length * 8 - CURVE.nBitLength;
5849		return delta > 0 ? num >> BigInt(delta) : num;
5850	};
5851	const bits2int_modN = CURVE.bits2int_modN || function(bytes) {
5852		return modN(bits2int(bytes));
5853	};
5854	const ORDER_MASK = bitMask(CURVE.nBitLength);
5855	/**
5856	* Converts to bytes. Checks if num in `[0..ORDER_MASK-1]` e.g.: `[0..2^256-1]`.
5857	*/
5858	function int2octets(num) {
5859		if (typeof num !== "bigint") throw new Error("bigint expected");
5860		if (!(_0n <= num && num < ORDER_MASK)) throw new Error(`bigint expected < 2^${CURVE.nBitLength}`);
5861		return numberToBytesBE(num, CURVE.nByteLength);
5862	}
5863	function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
5864		if (["recovered", "canonical"].some((k) => k in opts)) throw new Error("sign() legacy options not supported");
5865		const { hash, randomBytes } = CURVE;
5866		let { lowS, prehash, extraEntropy: ent } = opts;
5867		if (lowS == null) lowS = true;
5868		msgHash = ensureBytes("msgHash", msgHash);
5869		if (prehash) msgHash = ensureBytes("prehashed msgHash", hash(msgHash));
5870		const h1int = bits2int_modN(msgHash);
5871		const d = normPrivateKeyToScalar(privateKey);
5872		const seedArgs = [int2octets(d), int2octets(h1int)];
5873		if (ent != null) {
5874			const e = ent === true ? randomBytes(Fp.BYTES) : ent;
5875			seedArgs.push(ensureBytes("extraEntropy", e));
5876		}
5877		const seed = concatBytes(...seedArgs);
5878		const m = h1int;
5879		function k2sig(kBytes) {
5880			const k = bits2int(kBytes);
5881			if (!isWithinCurveOrder(k)) return;
5882			const ik = invN(k);
5883			const q = Point.BASE.multiply(k).toAffine();
5884			const r = modN(q.x);
5885			if (r === _0n) return;
5886			const s = modN(ik * modN(m + r * d));
5887			if (s === _0n) return;
5888			let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n$1);
5889			let normS = s;
5890			if (lowS && isBiggerThanHalfOrder(s)) {
5891				normS = normalizeS(s);
5892				recovery ^= 1;
5893			}
5894			return new Signature(r, normS, recovery);
5895		}
5896		return {
5897			seed,
5898			k2sig
5899		};
5900	}
5901	const defaultSigOpts = {
5902		lowS: CURVE.lowS,
5903		prehash: false
5904	};
5905	const defaultVerOpts = {
5906		lowS: CURVE.lowS,
5907		prehash: false
5908	};
5909	/**
5910	* Signs message hash with a private key.
5911	* ```
5912	* sign(m, d, k) where
5913	*   (x, y) = G × k
5914	*   r = x mod n
5915	*   s = (m + dr)/k mod n
5916	* ```
5917	* @param msgHash NOT message. msg needs to be hashed to `msgHash`, or use `prehash`.
5918	* @param privKey private key
5919	* @param opts lowS for non-malleable sigs. extraEntropy for mixing randomness into k. prehash will hash first arg.
5920	* @returns signature with recovery param
5921	*/
5922	function sign(msgHash, privKey, opts = defaultSigOpts) {
5923		const { seed, k2sig } = prepSig(msgHash, privKey, opts);
5924		const C = CURVE;
5925		return createHmacDrbg(C.hash.outputLen, C.nByteLength, C.hmac)(seed, k2sig);
5926	}
5927	Point.BASE._setWindowSize(8);
5928	/**
5929	* Verifies a signature against message hash and public key.
5930	* Rejects lowS signatures by default: to override,
5931	* specify option `{lowS: false}`. Implements section 4.1.4 from https://www.secg.org/sec1-v2.pdf:
5932	*
5933	* ```
5934	* verify(r, s, h, P) where
5935	*   U1 = hs^-1 mod n
5936	*   U2 = rs^-1 mod n
5937	*   R = U1⋅G - U2⋅P
5938	*   mod(R.x, n) == r
5939	* ```
5940	*/
5941	function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {
5942		const sg = signature;
5943		msgHash = ensureBytes("msgHash", msgHash);
5944		publicKey = ensureBytes("publicKey", publicKey);
5945		if ("strict" in opts) throw new Error("options.strict was renamed to lowS");
5946		const { lowS, prehash } = opts;
5947		let _sig = void 0;
5948		let P;
5949		try {
5950			if (typeof sg === "string" || sg instanceof Uint8Array) try {
5951				_sig = Signature.fromDER(sg);
5952			} catch (derError) {
5953				if (!(derError instanceof DER.Err)) throw derError;
5954				_sig = Signature.fromCompact(sg);
5955			}
5956			else if (typeof sg === "object" && typeof sg.r === "bigint" && typeof sg.s === "bigint") {
5957				const { r, s } = sg;
5958				_sig = new Signature(r, s);
5959			} else throw new Error("PARSE");
5960			P = Point.fromHex(publicKey);
5961		} catch (error) {
5962			if (error.message === "PARSE") throw new Error(`signature must be Signature instance, Uint8Array or hex string`);
5963			return false;

5964		}
5965		if (lowS && _sig.hasHighS()) return false;
5966		if (prehash) msgHash = CURVE.hash(msgHash);
5967		const { r, s } = _sig;
5968		const h = bits2int_modN(msgHash);
5969		const is = invN(s);
5970		const u1 = modN(h * is);
5971		const u2 = modN(r * is);
5972		const R = Point.BASE.multiplyAndAddUnsafe(P, u1, u2)?.toAffine();
5973		if (!R) return false;
5974		return modN(R.x) === r;
5975	}
5976	return {
5977		CURVE,
5978		getPublicKey,
5979		getSharedSecret,
5980		sign,
5981		verify,
5982		ProjectivePoint: Point,
5983		Signature,
5984		utils
5985	};
5986}
5987//#endregion
5988//#region node_modules/@noble/curves/esm/_shortw_utils.js
5989/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
5990function getHash(hash) {
5991	return {
5992		hash,
5993		hmac: (key, ...msgs) => hmac(hash, key, concatBytes$1(...msgs)),
5994		randomBytes: randomBytes$2
5995	};
5996}
5997function createCurve(curveDef, defHash) {
5998	const create = (hash) => weierstrass({
5999		...curveDef,
6000		...getHash(hash)
6001	});
6002	return Object.freeze({
6003		...create(defHash),
6004		create
6005	});
6006}
6007//#endregion
6008//#region node_modules/@noble/curves/esm/secp256k1.js
6009/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
6010var secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
6011var secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
6012var _1n = BigInt(1);
6013var _2n = BigInt(2);
6014var divNearest = (a, b) => (a + b / _2n) / b;
6015/**
6016* √n = n^((p+1)/4) for fields p = 3 mod 4. We unwrap the loop and multiply bit-by-bit.
6017* (P+1n/4n).toString(2) would produce bits [223x 1, 0, 22x 1, 4x 0, 11, 00]
6018*/
6019function sqrtMod(y) {
6020	const P = secp256k1P;
6021	const _3n = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
6022	const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
6023	const b2 = y * y * y % P;
6024	const b3 = b2 * b2 * y % P;
6025	const b11 = pow2(pow2(pow2(b3, _3n, P) * b3 % P, _3n, P) * b3 % P, _2n, P) * b2 % P;
6026	const b22 = pow2(b11, _11n, P) * b11 % P;
6027	const b44 = pow2(b22, _22n, P) * b22 % P;
6028	const b88 = pow2(b44, _44n, P) * b44 % P;
6029	const root = pow2(pow2(pow2(pow2(pow2(pow2(b88, _88n, P) * b88 % P, _44n, P) * b44 % P, _3n, P) * b3 % P, _23n, P) * b22 % P, _6n, P) * b2 % P, _2n, P);
6030	if (!Fp.eql(Fp.sqr(root), y)) throw new Error("Cannot find square root");
6031	return root;
6032}
6033var Fp = Field(secp256k1P, void 0, void 0, { sqrt: sqrtMod });
6034var secp256k1 = createCurve({
6035	a: BigInt(0),
6036	b: BigInt(7),
6037	Fp,
6038	n: secp256k1N,
6039	Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"),
6040	Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"),
6041	h: BigInt(1),
6042	lowS: true,
6043	/**
6044	* secp256k1 belongs to Koblitz curves: it has efficiently computable endomorphism.
6045	* Endomorphism uses 2x less RAM, speeds up precomputation by 2x and ECDH / key recovery by 20%.
6046	* For precomputed wNAF it trades off 1/2 init time & 1/3 ram for 20% perf hit.
6047	* Explanation: https://gist.github.com/paulmillr/eb670806793e84df628a7c434a873066
6048	*/
6049	endo: {
6050		beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
6051		splitScalar: (k) => {
6052			const n = secp256k1N;
6053			const a1 = BigInt("0x3086d221a7d46bcde86c90e49284eb15");
6054			const b1 = -_1n * BigInt("0xe4437ed6010e88286f547fa90abfe4c3");
6055			const a2 = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8");
6056			const b2 = a1;
6057			const POW_2_128 = BigInt("0x100000000000000000000000000000000");
6058			const c1 = divNearest(b2 * k, n);
6059			const c2 = divNearest(-b1 * k, n);
6060			let k1 = mod(k - c1 * a1 - c2 * a2, n);
6061			let k2 = mod(-c1 * b1 - c2 * b2, n);
6062			const k1neg = k1 > POW_2_128;
6063			const k2neg = k2 > POW_2_128;
6064			if (k1neg) k1 = n - k1;
6065			if (k2neg) k2 = n - k2;
6066			if (k1 > POW_2_128 || k2 > POW_2_128) throw new Error("splitScalar: Endomorphism failed, k=" + k);
6067			return {
6068				k1neg,
6069				k1,
6070				k2neg,
6071				k2
6072			};
6073		}
6074	}
6075}, sha256$1);
6076secp256k1.ProjectivePoint;
6077//#endregion
6078//#region node_modules/ethers/lib.esm/constants/addresses.js
6079/**
6080*  A constant for the zero address.
6081*
6082*  (**i.e.** ``"0x0000000000000000000000000000000000000000"``)
6083*/
6084var ZeroAddress = "0x0000000000000000000000000000000000000000";
6085//#endregion
6086//#region node_modules/ethers/lib.esm/constants/hashes.js
6087/**
6088*  A constant for the zero hash.
6089*
6090*  (**i.e.** ``"0x0000000000000000000000000000000000000000000000000000000000000000"``)
6091*/
6092var ZeroHash = "0x0000000000000000000000000000000000000000000000000000000000000000";
6093//#endregion
6094//#region node_modules/ethers/lib.esm/constants/numbers.js
6095/**
6096*  A constant for the order N for the secp256k1 curve.
6097*
6098*  (**i.e.** ``0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n``)
6099*/
6100var N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
6101/**
6102*  A constant for the number of wei in a single ether.
6103*
6104*  (**i.e.** ``1000000000000000000n``)
6105*/
6106var WeiPerEther = BigInt("1000000000000000000");
6107/**
6108*  A constant for the maximum value for a ``uint256``.
6109*
6110*  (**i.e.** ``0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn``)
6111*/
6112var MaxUint256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
6113/**
6114*  A constant for the minimum value for an ``int256``.
6115*
6116*  (**i.e.** ``-8000000000000000000000000000000000000000000000000000000000000000n``)
6117*/
6118var MinInt256 = BigInt("0x8000000000000000000000000000000000000000000000000000000000000000") * BigInt(-1);
6119/**
6120*  A constant for the maximum value for an ``int256``.
6121*
6122*  (**i.e.** ``0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn``)
6123*/
6124var MaxInt256 = BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
6125//#endregion
6126//#region node_modules/ethers/lib.esm/constants/strings.js
6127/**
6128*  A constant for the ether symbol (normalized using NFKC).
6129*
6130*  (**i.e.** ``"\\u039e"``)
6131*/
6132var EtherSymbol = "Ξ";
6133/**
6134*  A constant for the [[link-eip-191]] personal message prefix.
6135*
6136*  (**i.e.** ``"\\x19Ethereum Signed Message:\\n"``)
6137*/
6138var MessagePrefix = "�Ethereum Signed Message:\n";
6139//#endregion
6140//#region node_modules/ethers/lib.esm/crypto/signature.js
6141var BN_0$7 = BigInt(0);
6142var BN_1$3 = BigInt(1);
6143var BN_2$3 = BigInt(2);
6144var BN_27$1 = BigInt(27);
6145var BN_28$1 = BigInt(28);
6146var BN_35$1 = BigInt(35);
6147var BN_N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
6148var BN_N_2 = BN_N / BN_2$3;
6149var inspect$3 = Symbol.for("nodejs.util.inspect.custom");
6150var _guard$3 = {};
6151function toUint256(value) {
6152	return zeroPadValue(toBeArray(value), 32);
6153}
6154/**
6155*  A Signature  @TODO
6156*
6157*
6158*  @_docloc: api/crypto:Signing
6159*/
6160var Signature = class Signature {
6161	#r;
6162	#s;
6163	#v;
6164	#networkV;
6165	/**
6166	*  The ``r`` value for a signature.
6167	*
6168	*  This represents the ``x`` coordinate of a "reference" or
6169	*  challenge point, from which the ``y`` can be computed.
6170	*/
6171	get r() {
6172		return this.#r;
6173	}
6174	set r(value) {
6175		assertArgument(dataLength(value) === 32, "invalid r", "value", value);
6176		this.#r = hexlify(value);
6177	}
6178	/**
6179	*  The ``s`` value for a signature.
6180	*/
6181	get s() {
6182		assertArgument(parseInt(this.#s.substring(0, 3)) < 8, "non-canonical s; use ._s", "s", this.#s);
6183		return this.#s;
6184	}
6185	set s(_value) {
6186		assertArgument(dataLength(_value) === 32, "invalid s", "value", _value);
6187		this.#s = hexlify(_value);
6188	}
6189	/**
6190	*  Return the s value, unchecked for EIP-2 compliance.
6191	*
6192	*  This should generally not be used and is for situations where
6193	*  a non-canonical S value might be relevant, such as Frontier blocks
6194	*  that were mined prior to EIP-2 or invalid Authorization List
6195	*  signatures.
6196	*/
6197	get _s() {
6198		return this.#s;
6199	}
6200	/**
6201	*  Returns true if the Signature is valid for [[link-eip-2]] signatures.
6202	*/
6203	isValid() {
6204		return BigInt(this.#s) <= BN_N_2;
6205	}

6206	/**
6207	*  The ``v`` value for a signature.
6208	*
6209	*  Since a given ``x`` value for ``r`` has two possible values for
6210	*  its correspondin ``y``, the ``v`` indicates which of the two ``y``
6211	*  values to use.
6212	*
6213	*  It is normalized to the values ``27`` or ``28`` for legacy
6214	*  purposes.
6215	*/
6216	get v() {
6217		return this.#v;
6218	}
6219	set v(value) {
6220		const v = getNumber(value, "value");
6221		assertArgument(v === 27 || v === 28, "invalid v", "v", value);
6222		this.#v = v;
6223	}
6224	/**
6225	*  The EIP-155 ``v`` for legacy transactions. For non-legacy
6226	*  transactions, this value is ``null``.
6227	*/
6228	get networkV() {
6229		return this.#networkV;
6230	}
6231	/**
6232	*  The chain ID for EIP-155 legacy transactions. For non-legacy
6233	*  transactions, this value is ``null``.
6234	*/
6235	get legacyChainId() {
6236		const v = this.networkV;
6237		if (v == null) return null;
6238		return Signature.getChainId(v);
6239	}
6240	/**
6241	*  The ``yParity`` for the signature.
6242	*
6243	*  See ``v`` for more details on how this value is used.
6244	*/
6245	get yParity() {
6246		return this.v === 27 ? 0 : 1;
6247	}
6248	/**
6249	*  The [[link-eip-2098]] compact representation of the ``yParity``
6250	*  and ``s`` compacted into a single ``bytes32``.
6251	*/
6252	get yParityAndS() {
6253		const yParityAndS = getBytes(this.s);
6254		if (this.yParity) yParityAndS[0] |= 128;
6255		return hexlify(yParityAndS);
6256	}
6257	/**
6258	*  The [[link-eip-2098]] compact representation.
6259	*/
6260	get compactSerialized() {
6261		return concat([this.r, this.yParityAndS]);
6262	}
6263	/**
6264	*  The serialized representation.
6265	*/
6266	get serialized() {
6267		return concat([
6268			this.r,
6269			this.s,
6270			this.yParity ? "0x1c" : "0x1b"
6271		]);
6272	}
6273	/**
6274	*  @private
6275	*/
6276	constructor(guard, r, s, v) {
6277		assertPrivate(guard, _guard$3, "Signature");
6278		this.#r = r;
6279		this.#s = s;
6280		this.#v = v;
6281		this.#networkV = null;
6282	}
6283	/**
6284	*  Returns the canonical signature.
6285	*
6286	*  This is only necessary when dealing with legacy transaction which
6287	*  did not enforce canonical S values (i.e. [[link-eip-2]]. Most
6288	*  developers should never require this.
6289	*/
6290	getCanonical() {
6291		if (this.isValid()) return this;
6292		const s = BN_N - BigInt(this._s);
6293		const v = 55 - this.v;
6294		const result = new Signature(_guard$3, this.r, toUint256(s), v);
6295		if (this.networkV) result.#networkV = this.networkV;
6296		return result;
6297	}
6298	/**
6299	*  Returns a new identical [[Signature]].
6300	*/
6301	clone() {
6302		const clone = new Signature(_guard$3, this.r, this._s, this.v);
6303		if (this.networkV) clone.#networkV = this.networkV;
6304		return clone;
6305	}
6306	/**
6307	*  Returns a representation that is compatible with ``JSON.stringify``.
6308	*/
6309	toJSON() {
6310		const networkV = this.networkV;
6311		return {
6312			_type: "signature",
6313			networkV: networkV != null ? networkV.toString() : null,
6314			r: this.r,
6315			s: this._s,
6316			v: this.v
6317		};
6318	}
6319	[inspect$3]() {
6320		return this.toString();
6321	}
6322	toString() {
6323		if (this.isValid()) return `Signature { r: ${this.r}, s: ${this._s}, v: ${this.v} }`;
6324		return `Signature { r: ${this.r}, s: ${this._s}, v: ${this.v}, valid: false }`;
6325	}
6326	/**
6327	*  Compute the chain ID from the ``v`` in a legacy EIP-155 transactions.
6328	*
6329	*  @example:
6330	*    Signature.getChainId(45)
6331	*    //_result:
6332	*
6333	*    Signature.getChainId(46)
6334	*    //_result:
6335	*/
6336	static getChainId(v) {
6337		const bv = getBigInt(v, "v");
6338		if (bv == BN_27$1 || bv == BN_28$1) return BN_0$7;
6339		assertArgument(bv >= BN_35$1, "invalid EIP-155 v", "v", v);
6340		return (bv - BN_35$1) / BN_2$3;
6341	}
6342	/**
6343	*  Compute the ``v`` for a chain ID for a legacy EIP-155 transactions.
6344	*
6345	*  Legacy transactions which use [[link-eip-155]] hijack the ``v``
6346	*  property to include the chain ID.
6347	*
6348	*  @example:
6349	*    Signature.getChainIdV(5, 27)
6350	*    //_result:
6351	*
6352	*    Signature.getChainIdV(5, 28)
6353	*    //_result:
6354	*
6355	*/
6356	static getChainIdV(chainId, v) {
6357		return getBigInt(chainId) * BN_2$3 + BigInt(35 + v - 27);
6358	}
6359	/**
6360	*  Compute the normalized legacy transaction ``v`` from a ``yParirty``,
6361	*  a legacy transaction ``v`` or a legacy [[link-eip-155]] transaction.
6362	*
6363	*  @example:
6364	*    // The values 0 and 1 imply v is actually yParity
6365	*    Signature.getNormalizedV(0)
6366	*    //_result:
6367	*
6368	*    // Legacy non-EIP-1559 transaction (i.e. 27 or 28)
6369	*    Signature.getNormalizedV(27)
6370	*    //_result:
6371	*
6372	*    // Legacy EIP-155 transaction (i.e. >= 35)
6373	*    Signature.getNormalizedV(46)
6374	*    //_result:
6375	*
6376	*    // Invalid values throw
6377	*    Signature.getNormalizedV(5)
6378	*    //_error:
6379	*/
6380	static getNormalizedV(v) {
6381		const bv = getBigInt(v);
6382		if (bv === BN_0$7 || bv === BN_27$1) return 27;
6383		if (bv === BN_1$3 || bv === BN_28$1) return 28;
6384		assertArgument(bv >= BN_35$1, "invalid v", "v", v);
6385		return bv & BN_1$3 ? 27 : 28;
6386	}

vendor: 8,405 bytes, lines 6387-6647

6387	/**
6388	*  Creates a new [[Signature]].
6389	*
6390	*  If no %%sig%% is provided, a new [[Signature]] is created
6391	*  with default values.
6392	*
6393	*  If %%sig%% is a string, it is parsed.
6394	*/
6395	static from(sig) {
6396		function assertError(check, message) {
6397			assertArgument(check, message, "signature", sig);
6398		}
6399		if (sig == null) return new Signature(_guard$3, ZeroHash, ZeroHash, 27);
6400		if (typeof sig === "string") {
6401			const bytes = getBytes(sig, "signature");
6402			if (bytes.length === 64) {
6403				const r = hexlify(bytes.slice(0, 32));
6404				const s = bytes.slice(32, 64);
6405				const v = s[0] & 128 ? 28 : 27;
6406				s[0] &= 127;
6407				return new Signature(_guard$3, r, hexlify(s), v);
6408			}
6409			if (bytes.length === 65) {
6410				const r = hexlify(bytes.slice(0, 32));
6411				const s = hexlify(bytes.slice(32, 64));
6412				const v = Signature.getNormalizedV(bytes[64]);
6413				return new Signature(_guard$3, r, s, v);
6414			}
6415			assertError(false, "invalid raw signature length");
6416		}
6417		if (sig instanceof Signature) return sig.clone();
6418		const _r = sig.r;
6419		assertError(_r != null, "missing r");
6420		const r = toUint256(_r);
6421		const s = (function(s, yParityAndS) {
6422			if (s != null) return toUint256(s);
6423			if (yParityAndS != null) {
6424				assertError(isHexString(yParityAndS, 32), "invalid yParityAndS");
6425				const bytes = getBytes(yParityAndS);
6426				bytes[0] &= 127;
6427				return hexlify(bytes);
6428			}
6429			assertError(false, "missing s");
6430		})(sig.s, sig.yParityAndS);
6431		const { networkV, v } = (function(_v, yParityAndS, yParity) {
6432			if (_v != null) {
6433				const v = getBigInt(_v);
6434				return {
6435					networkV: v >= BN_35$1 ? v : void 0,
6436					v: Signature.getNormalizedV(v)
6437				};
6438			}
6439			if (yParityAndS != null) {
6440				assertError(isHexString(yParityAndS, 32), "invalid yParityAndS");
6441				return { v: getBytes(yParityAndS)[0] & 128 ? 28 : 27 };
6442			}
6443			if (yParity != null) {
6444				switch (getNumber(yParity, "sig.yParity")) {
6445					case 0: return { v: 27 };
6446					case 1: return { v: 28 };
6447				}
6448				assertError(false, "invalid yParity");
6449			}
6450			assertError(false, "missing v");
6451		})(sig.v, sig.yParityAndS, sig.yParity);
6452		const result = new Signature(_guard$3, r, s, v);
6453		if (networkV) result.#networkV = networkV;
6454		assertError(sig.yParity == null || getNumber(sig.yParity, "sig.yParity") === result.yParity, "yParity mismatch");
6455		assertError(sig.yParityAndS == null || sig.yParityAndS === result.yParityAndS, "yParityAndS mismatch");
6456		return result;
6457	}
6458};
6459//#endregion
6460//#region node_modules/ethers/lib.esm/crypto/signing-key.js
6461/**
6462*  Add details about signing here.
6463*
6464*  @_subsection: api/crypto:Signing  [about-signing]
6465*/
6466/**
6467*  A **SigningKey** provides high-level access to the elliptic curve
6468*  cryptography (ECC) operations and key management.
6469*/
6470var SigningKey = class SigningKey {
6471	#privateKey;
6472	/**
6473	*  Creates a new **SigningKey** for %%privateKey%%.
6474	*/
6475	constructor(privateKey) {
6476		assertArgument(dataLength(privateKey) === 32, "invalid private key", "privateKey", "[REDACTED]");
6477		this.#privateKey = hexlify(privateKey);
6478	}
6479	/**
6480	*  The private key.
6481	*/
6482	get privateKey() {
6483		return this.#privateKey;
6484	}
6485	/**
6486	*  The uncompressed public key.
6487	*
6488	* This will always begin with the prefix ``0x04`` and be 132
6489	* characters long (the ``0x`` prefix and 130 hexadecimal nibbles).
6490	*/
6491	get publicKey() {
6492		return SigningKey.computePublicKey(this.#privateKey);
6493	}
6494	/**
6495	*  The compressed public key.
6496	*
6497	*  This will always begin with either the prefix ``0x02`` or ``0x03``
6498	*  and be 68 characters long (the ``0x`` prefix and 33 hexadecimal
6499	*  nibbles)
6500	*/
6501	get compressedPublicKey() {
6502		return SigningKey.computePublicKey(this.#privateKey, true);
6503	}
6504	/**
6505	*  Return the signature of the signed %%digest%%.
6506	*/
6507	sign(digest) {
6508		assertArgument(dataLength(digest) === 32, "invalid digest length", "digest", digest);
6509		const sig = secp256k1.sign(getBytesCopy(digest), getBytesCopy(this.#privateKey), { lowS: true });
6510		return Signature.from({
6511			r: toBeHex(sig.r, 32),
6512			s: toBeHex(sig.s, 32),
6513			v: sig.recovery ? 28 : 27
6514		});
6515	}
6516	/**
6517	*  Returns the [[link-wiki-ecdh]] shared secret between this
6518	*  private key and the %%other%% key.
6519	*
6520	*  The %%other%% key may be any type of key, a raw public key,
6521	*  a compressed/uncompressed pubic key or aprivate key.
6522	*
6523	*  Best practice is usually to use a cryptographic hash on the
6524	*  returned value before using it as a symetric secret.
6525	*
6526	*  @example:
6527	*    sign1 = new SigningKey(id("some-secret-1"))
6528	*    sign2 = new SigningKey(id("some-secret-2"))
6529	*
6530	*    // Notice that privA.computeSharedSecret(pubB)...
6531	*    sign1.computeSharedSecret(sign2.publicKey)
6532	*    //_result:
6533	*
6534	*    // ...is equal to privB.computeSharedSecret(pubA).
6535	*    sign2.computeSharedSecret(sign1.publicKey)
6536	*    //_result:
6537	*/
6538	computeSharedSecret(other) {
6539		const pubKey = SigningKey.computePublicKey(other);
6540		return hexlify(secp256k1.getSharedSecret(getBytesCopy(this.#privateKey), getBytes(pubKey), false));
6541	}
6542	/**
6543	*  Compute the public key for %%key%%, optionally %%compressed%%.
6544	*
6545	*  The %%key%% may be any type of key, a raw public key, a
6546	*  compressed/uncompressed public key or private key.
6547	*
6548	*  @example:
6549	*    sign = new SigningKey(id("some-secret"));
6550	*
6551	*    // Compute the uncompressed public key for a private key
6552	*    SigningKey.computePublicKey(sign.privateKey)
6553	*    //_result:
6554	*
6555	*    // Compute the compressed public key for a private key
6556	*    SigningKey.computePublicKey(sign.privateKey, true)
6557	*    //_result:
6558	*
6559	*    // Compute the uncompressed public key
6560	*    SigningKey.computePublicKey(sign.publicKey, false);
6561	*    //_result:
6562	*
6563	*    // Compute the Compressed a public key
6564	*    SigningKey.computePublicKey(sign.publicKey, true);
6565	*    //_result:
6566	*/
6567	static computePublicKey(key, compressed) {
6568		let bytes = getBytes(key, "key");
6569		if (bytes.length === 32) return hexlify(secp256k1.getPublicKey(bytes, !!compressed));
6570		if (bytes.length === 64) {
6571			const pub = /* @__PURE__ */ new Uint8Array(65);
6572			pub[0] = 4;
6573			pub.set(bytes, 1);
6574			bytes = pub;
6575		}
6576		return hexlify(secp256k1.ProjectivePoint.fromHex(bytes).toRawBytes(compressed));
6577	}
6578	/**
6579	*  Returns the public key for the private key which produced the
6580	*  %%signature%% for the given %%digest%%.
6581	*
6582	*  @example:
6583	*    key = new SigningKey(id("some-secret"))
6584	*    digest = id("hello world")
6585	*    sig = key.sign(digest)
6586	*
6587	*    // Notice the signer public key...
6588	*    key.publicKey
6589	*    //_result:
6590	*
6591	*    // ...is equal to the recovered public key
6592	*    SigningKey.recoverPublicKey(digest, sig)
6593	*    //_result:
6594	*
6595	*/
6596	static recoverPublicKey(digest, signature) {
6597		assertArgument(dataLength(digest) === 32, "invalid digest length", "digest", digest);
6598		const sig = Signature.from(signature);
6599		let secpSig = secp256k1.Signature.fromCompact(getBytesCopy(concat([sig.r, sig.s])));
6600		secpSig = secpSig.addRecoveryBit(sig.yParity);
6601		const pubKey = secpSig.recoverPublicKey(getBytesCopy(digest));
6602		assertArgument(pubKey != null, "invalid signature for digest", "signature", signature);
6603		return "0x" + pubKey.toHex(false);
6604	}
6605	/**
6606	*  Returns the point resulting from adding the ellipic curve points
6607	*  %%p0%% and %%p1%%.
6608	*
6609	*  This is not a common function most developers should require, but
6610	*  can be useful for certain privacy-specific techniques.
6611	*
6612	*  For example, it is used by [[HDNodeWallet]] to compute child
6613	*  addresses from parent public keys and chain codes.
6614	*/
6615	static addPoints(p0, p1, compressed) {
6616		const pub0 = secp256k1.ProjectivePoint.fromHex(SigningKey.computePublicKey(p0).substring(2));
6617		const pub1 = secp256k1.ProjectivePoint.fromHex(SigningKey.computePublicKey(p1).substring(2));
6618		return "0x" + pub0.add(pub1).toHex(!!compressed);
6619	}
6620};
6621//#endregion
6622//#region node_modules/ethers/lib.esm/crypto/index.js
6623/**
6624*  Once called, prevents any future change to the underlying cryptographic
6625*  primitives using the ``.register`` feature for hooks.
6626*/
6627function lock() {
6628	computeHmac.lock();
6629	keccak256.lock();
6630	pbkdf2.lock();
6631	randomBytes.lock();
6632	ripemd160.lock();
6633	scrypt.lock();
6634	scryptSync.lock();
6635	sha256.lock();
6636	sha512.lock();
6637	randomBytes.lock();
6638}
6639//#endregion
6640//#region node_modules/ethers/lib.esm/address/address.js
6641var BN_0$6 = BigInt(0);
6642var BN_36 = BigInt(36);
6643function getChecksumAddress(address) {
6644	address = address.toLowerCase();
6645	const chars = address.substring(2).split("");
6646	const expanded = /* @__PURE__ */ new Uint8Array(40);
6647	for (let i = 0; i < 40;

6647 i++) expanded[i] = chars[i].charCodeAt(0);
6648	const hashed = getBytes(keccak256(expanded));
6649	for (let i = 0; i < 40; i += 2) {
6650		if (hashed[i >> 1] >> 4 >= 8) chars[i] = chars[i].toUpperCase();
6651		if ((hashed[i >> 1] & 15) >= 8) chars[i + 1] = chars[i + 1].toUpperCase();
6652	}
6653	return "0x" + chars.join("");
6654}
6655var ibanLookup = {};
6656for (let i = 0; i < 10; i++) ibanLookup[String(i)] = String(i);
6657for (let i = 0; i < 26; i++) ibanLookup[String.fromCharCode(65 + i)] = String(10 + i);
6658var safeDigits = 15;
6659function ibanChecksum(address) {
6660	address = address.toUpperCase();
6661	address = address.substring(4) + address.substring(0, 2) + "00";
6662	let expanded = address.split("").map((c) => {
6663		return ibanLookup[c];
6664	}).join("");
6665	while (expanded.length >= safeDigits) {
6666		let block = expanded.substring(0, safeDigits);
6667		expanded = parseInt(block, 10) % 97 + expanded.substring(block.length);
6668	}
6669	let checksum = String(98 - parseInt(expanded, 10) % 97);
6670	while (checksum.length < 2) checksum = "0" + checksum;
6671	return checksum;
6672}
6673var Base36 = (function() {
6674	const result = {};
6675	for (let i = 0; i < 36; i++) {
6676		const key = "0123456789abcdefghijklmnopqrstuvwxyz"[i];
6677		result[key] = BigInt(i);
6678	}
6679	return result;
6680})();
6681function fromBase36(value) {
6682	value = value.toLowerCase();
6683	let result = BN_0$6;
6684	for (let i = 0; i < value.length; i++) result = result * BN_36 + Base36[value[i]];
6685	return result;
6686}
6687/**
6688*  Returns a normalized and checksumed address for %%address%%.
6689*  This accepts non-checksum addresses, checksum addresses and
6690*  [[getIcapAddress]] formats.
6691*
6692*  The checksum in Ethereum uses the capitalization (upper-case

6693*  vs lower-case) of the characters within an address to encode
6694*  its checksum, which offers, on average, a checksum of 15-bits.
6695*
6696*  If %%address%% contains both upper-case and lower-case, it is
6697*  assumed to already be a checksum address and its checksum is
6698*  validated, and if the address fails its expected checksum an
6699*  error is thrown.
6700*
6701*  If you wish the checksum of %%address%% to be ignore, it should
6702*  be converted to lower-case (i.e. ``.toLowercase()``) before
6703*  being passed in. This should be a very rare situation though,
6704*  that you wish to bypass the safegaurds in place to protect
6705*  against an address that has been incorrectly copied from another
6706*  source.
6707*
6708*  @example:
6709*    // Adds the checksum (via upper-casing specific letters)
6710*    getAddress("0x8ba1f109551bd432803012645ac136ddd64dba72")
6711*    //_result:
6712*
6713*    // Converts ICAP address and adds checksum
6714*    getAddress("XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36");
6715*    //_result:
6716*
6717*    // Throws an error if an address contains mixed case,
6718*    // but the checksum fails
6719*    getAddress("0x8Ba1f109551bD432803012645Ac136ddd64DBA72")
6720*    //_error:
6721*/
6722function getAddress(address) {
6723	assertArgument(typeof address === "string", "invalid address", "address", address);
6724	if (address.match(/^(0x)?[0-9a-fA-F]{40}$/)) {
6725		if (!address.startsWith("0x")) address = "0x" + address;
6726		const result = getChecksumAddress(address);
6727		assertArgument(!address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) || result === address, "bad address checksum", "address", address);
6728		return result;
6729	}
6730	if (address.match(/^XE[0-9]{2}[0-9A-Za-z]{30,31}$/)) {
6731		assertArgument(address.substring(2, 4) === ibanChecksum(address), "bad icap checksum", "address", address);
6732		let result = fromBase36(address.substring(4)).toString(16);
6733		while (result.length < 40) result = "0" + result;
6734		return getChecksumAddress("0x" + result);
6735	}
6736	assertArgument(false, "invalid address", "address", address);
6737}
6738/**
6739*  The [ICAP Address format](link-icap) format is an early checksum
6740*  format which attempts to be compatible with the banking
6741*  industry [IBAN format](link-wiki-iban) for bank accounts.
6742*
6743*  It is no longer common or a recommended format.
6744*
6745*  @example:
6746*    getIcapAddress("0x8ba1f109551bd432803012645ac136ddd64dba72");
6747*    //_result:
6748*
6749*    getIcapAddress("XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36");
6750*    //_result:
6751*
6752*    // Throws an error if the ICAP checksum is wrong
6753*    getIcapAddress("XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK37");
6754*    //_error:
6755*/
6756function getIcapAddress(address) {
6757	let base36 = BigInt(getAddress(address)).toString(36).toUpperCase();
6758	while (base36.length < 30) base36 = "0" + base36;
6759	return "XE" + ibanChecksum("XE00" + base36) + base36;
6760}
6761//#endregion
6762//#region node_modules/ethers/lib.esm/address/contract-address.js
6763/**
6764*  Returns the address that would result from a ``CREATE`` for %%tx%%.
6765*
6766*  This can be used to compute the address a contract will be
6767*  deployed to by an EOA when sending a deployment transaction (i.e.
6768*  when the ``to`` address is ``null``).
6769*
6770*  This can also be used to compute the address a contract will be
6771*  deployed to by a contract, by using the contract's address as the
6772*  ``to`` and the contract's nonce.
6773*
6774*  @example
6775*    from = "0x8ba1f109551bD432803012645Ac136ddd64DBA72";
6776*    nonce = 5;
6777*
6778*    getCreateAddress({ from, nonce });
6779*    //_result:
6780*/
6781function getCreateAddress(tx) {
6782	const from = getAddress(tx.from);
6783	let nonceHex = getBigInt(tx.nonce, "tx.nonce").toString(16);
6784	if (nonceHex === "0") nonceHex = "0x";
6785	else if (nonceHex.length % 2) nonceHex = "0x0" + nonceHex;
6786	else nonceHex = "0x" + nonceHex;
6787	return getAddress(dataSlice(keccak256(encodeRlp([from, nonceHex])), 12));
6788}
6789/**
6790*  Returns the address that would result from a ``CREATE2`` operation
6791*  with the given %%from%%, %%salt%% and %%initCodeHash%%.
6792*
6793*  To compute the %%initCodeHash%% from a contract's init code, use
6794*  the [[keccak256]] function.
6795*
6796*  For a quick overview and example of ``CREATE2``, see [[link-ricmoo-wisps]].
6797*
6798*  @example
6799*    // The address of the contract
6800*    from = "0x8ba1f109551bD432803012645Ac136ddd64DBA72"
6801*
6802*    // The salt
6803*    salt = id("HelloWorld")
6804*
6805*    // The hash of the initCode

6806*    initCode = "0x6394198df16000526103ff60206004601c335afa6040516060f3";
6807*    initCodeHash = keccak256(initCode)
6808*
6809*    getCreate2Address(from, salt, initCodeHash)
6810*    //_result:
6811*/
6812function getCreate2Address(_from, _salt, _initCodeHash) {
6813	const from = getAddress(_from);
6814	const salt = getBytes(_salt, "salt");
6815	const initCodeHash = getBytes(_initCodeHash, "initCodeHash");
6816	assertArgument(salt.length === 32, "salt must be 32 bytes", "salt", _salt);
6817	assertArgument(initCodeHash.length === 32, "initCodeHash must be 32 bytes", "initCodeHash", _initCodeHash);
6818	return getAddress(dataSlice(keccak256(concat([
6819		"0xff",
6820		from,
6821		salt,
6822		initCodeHash
6823	])), 12));
6824}
6825//#endregion
6826//#region node_modules/ethers/lib.esm/address/checks.js
6827/**
6828*  Returns true if %%value%% is an object which implements the
6829*  [[Addressable]] interface.
6830*
6831*  @example:
6832*    // Wallets and AbstractSigner sub-classes
6833*    isAddressable(Wallet.createRandom())
6834*    //_result:
6835*
6836*    // Contracts
6837*    contract = new Contract("dai.tokens.ethers.eth", [ ], provider)
6838*    isAddressable(contract)
6839*    //_result:
6840*/
6841function isAddressable(value) {
6842	return value && typeof value.getAddress === "function";
6843}
6844/**
6845*  Returns true if %%value%% is a valid address.
6846*
6847*  @example:
6848*    // Valid address
6849*    isAddress("0x8ba1f109551bD432803012645Ac136ddd64DBA72")
6850*    //_result:
6851*
6852*    // Valid ICAP address
6853*    isAddress("XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36")
6854*    //_result:
6855*
6856*    // Invalid checksum
6857*    isAddress("0x8Ba1f109551bD432803012645Ac136ddd64DBa72")
6858*    //_result:
6859*
6860*    // Invalid ICAP checksum
6861*    isAddress("0x8Ba1f109551bD432803012645Ac136ddd64DBA72")
6862*    //_result:
6863*
6864*    // Not an address (an ENS name requires a provided and an
6865*    // asynchronous API to access)
6866*    isAddress("ricmoo.eth")
6867*    //_result:
6868*/
6869function isAddress(value) {
6870	try {
6871		getAddress(value);
6872		return true;
6873	} catch (error) {}
6874	return false;
6875}
6876async function checkAddress(target, promise) {
6877	const result = await promise;
6878	if (result == null || result === "0x0000000000000000000000000000000000000000") {
6879		assert(typeof target !== "string", "unconfigured name", "UNCONFIGURED_NAME", { value: target });
6880		assertArgument(false, "invalid AddressLike value; did not resolve to a value address", "target", target);
6881	}
6882	return getAddress(result);
6883}
6884/**
6885*  Resolves to an address for the %%target%%, which may be any
6886*  supported address type, an [[Addressable]] or a Promise which
6887*  resolves to an address.
6888*
6889*  If an ENS name is provided, but that name has not been correctly
6890*  configured a [[UnconfiguredNameError]] is thrown.
6891*
6892*  @example:
6893*    addr = "0x6B175474E89094C44Da98b954EedeAC495271d0F"
6894*
6895*    // Addresses are return synchronously
6896*    resolveAddress(addr, provider)
6897*    //_result:
6898*
6899*    // Address promises are resolved asynchronously
6900*    resolveAddress(Promise.resolve(addr))
6901*    //_result:
6902*
6903*    // ENS names are resolved asynchronously
6904*    resolveAddress("dai.tokens.ethers.eth", provider)
6905*    //_result:
6906*
6907*    // Addressable objects are resolved asynchronously
6908*    contract = new Contract(addr, [ ])
6909*    resolveAddress(contract, provider)
6910*    //_result:
6911*
6912*    // Unconfigured ENS names reject
6913*    resolveAddress("nothing-here.ricmoo.eth", provider)
6914*    //_error:
6915*
6916*    // ENS names require a NameResolver object passed in
6917*    // (notice the provider was omitted)
6918*    resolveAddress("nothing-here.ricmoo.eth")
6919*    //_error:
6920*/
6921function resolveAddress(target, resolver) {
6922	if (typeof target === "string") {
6923		if (target.match(/^0x[0-9a-f]{40}$/i)) return getAddress(target);
6924		assert(resolver != null, "ENS resolution requires a provider", "UNSUPPORTED_OPERATION", { operation: "resolveName" });
6925		return checkAddress(target, resolver.resolveName(target));
6926	} else if (isAddressable(target)) return checkAddress(target, target.getAddress());
6927	else if (target && typeof target.then === "function") return checkAddress(target, target);
6928	assertArgument(false, "unsupported addressable value", "target", target);
6929}
6930//#endregion
6931//#region node_modules/ethers/lib.esm/abi/typed.js
6932/**
6933*  A Typed object allows a value to have its type explicitly
6934*  specified.
6935*
6936*  For example, in Solidity, the value ``45`` could represent a
6937*  ``uint8`` or a ``uint256``. The value ``0x1234`` could represent
6938*  a ``bytes2`` or ``bytes``.
6939*
6940*  Since JavaScript has no meaningful way to explicitly inform any
6941*  APIs which what the type is, this allows transparent interoperation
6942*  with Soldity.
6943*
6944*  @_subsection: api/abi:Typed Values
6945*/
6946var _gaurd = {};
6947function n(value, width) {
6948	let signed = false;

6949	if (width < 0) {
6950		signed = true;
6951		width *= -1;
6952	}
6953	return new Typed(_gaurd, `${signed ? "" : "u"}int${width}`, value, {
6954		signed,
6955		width
6956	});
6957}
6958function b(value, size) {
6959	return new Typed(_gaurd, `bytes${size ? size : ""}`, value, { size });
6960}
6961var _typedSymbol = Symbol.for("_ethers_typed");
6962/**
6963*  The **Typed** class to wrap values providing explicit type information.
6964*/
6965var Typed = class Typed {
6966	/**
6967	*  The type, as a Solidity-compatible type.
6968	*/
6969	type;
6970	/**
6971	*  The actual value.
6972	*/
6973	value;
6974	#options;
6975	/**
6976	*  @_ignore:
6977	*/
6978	_typedSymbol;
6979	/**
6980	*  @_ignore:
6981	*/
6982	constructor(gaurd, type, value, options) {
6983		if (options == null) options = null;
6984		assertPrivate(_gaurd, gaurd, "Typed");
6985		defineProperties(this, {
6986			_typedSymbol,
6987			type,
6988			value
6989		});
6990		this.#options = options;
6991		this.format();
6992	}
6993	/**
6994	*  Format the type as a Human-Readable type.
6995	*/
6996	format() {
6997		if (this.type === "array") throw new Error("");
6998		else if (this.type === "dynamicArray") throw new Error("");
6999		else if (this.type === "tuple") return `tuple(${this.value.map((v) => v.format()).join(",")})`;
7000		return this.type;
7001	}
7002	/**
7003	*  The default value returned by this type.
7004	*/
7005	defaultValue() {
7006		return 0;
7007	}
7008	/**
7009	*  The minimum value for numeric types.
7010	*/
7011	minValue() {
7012		return 0;
7013	}
7014	/**
7015	*  The maximum value for numeric types.
7016	*/
7017	maxValue() {
7018		return 0;
7019	}
7020	/**
7021	*  Returns ``true`` and provides a type guard is this is a [[TypedBigInt]].
7022	*/
7023	isBigInt() {
7024		return !!this.type.match(/^u?int[0-9]+$/);
7025	}
7026	/**
7027	*  Returns ``true`` and provides a type guard is this is a [[TypedData]].
7028	*/
7029	isData() {
7030		return this.type.startsWith("bytes");
7031	}
7032	/**
7033	*  Returns ``true`` and provides a type guard is this is a [[TypedString]].
7034	*/
7035	isString() {
7036		return this.type === "string";
7037	}
7038	/**
7039	*  Returns the tuple name, if this is a tuple. Throws otherwise.
7040	*/
7041	get tupleName() {
7042		if (this.type !== "tuple") throw TypeError("not a tuple");
7043		return this.#options;
7044	}
7045	/**
7046	*  Returns the length of the array type or ``-1`` if it is dynamic.
7047	*
7048	*  Throws if the type is not an array.
7049	*/
7050	get arrayLength() {
7051		if (this.type !== "array") throw TypeError("not an array");
7052		if (this.#options === true) return -1;
7053		if (this.#options === false) return this.value.length;
7054		return null;
7055	}
7056	/**

7057	*  Returns a new **Typed** of %%type%% with the %%value%%.
7058	*/
7059	static from(type, value) {
7060		return new Typed(_gaurd, type, value);
7061	}
7062	/**
7063	*  Return a new ``uint8`` type for %%v%%.
7064	*/
7065	static uint8(v) {
7066		return n(v, 8);
7067	}
7068	/**
7069	*  Return a new ``uint16`` type for %%v%%.
7070	*/
7071	static uint16(v) {
7072		return n(v, 16);
7073	}
7074	/**
7075	*  Return a new ``uint24`` type for %%v%%.
7076	*/
7077	static uint24(v) {
7078		return n(v, 24);
7079	}
7080	/**
7081	*  Return a new ``uint32`` type for %%v%%.
7082	*/
7083	static uint32(v) {
7084		return n(v, 32);
7085	}
7086	/**
7087	*  Return a new ``uint40`` type for %%v%%.
7088	*/
7089	static uint40(v) {
7090		return n(v, 40);
7091	}
7092	/**
7093	*  Return a new ``uint48`` type for %%v%%.
7094	*/
7095	static uint48(v) {
7096		return n(v, 48);
7097	}
7098	/**
7099	*  Return a new ``uint56`` type for %%v%%.
7100	*/
7101	static uint56(v) {
7102		return n(v, 56);
7103	}
7104	/**
7105	*  Return a new ``uint64`` type for %%v%%.
7106	*/
7107	static uint64(v) {
7108		return n(v, 64);
7109	}
7110	/**
7111	*  Return a new ``uint72`` type for %%v%%.
7112	*/
7113	static uint72(v) {
7114		return n(v, 72);
7115	}
7116	/**
7117	*  Return a new ``uint80`` type for %%v%%.
7118	*/
7119	static uint80(v) {
7120		return n(v, 80);
7121	}
7122	/**
7123	*  Return a new ``uint88`` type for %%v%%.
7124	*/
7125	static uint88(v) {
7126		return n(v, 88);
7127	}
7128	/**
7129	*  Return a new ``uint96`` type for %%v%%.
7130	*/
7131	static uint96(v) {
7132		return n(v, 96);
7133	}
7134	/**
7135	*  Return a new ``uint104`` type for %%v%%.
7136	*/
7137	static uint104(v) {
7138		return n(v, 104);
7139	}
7140	/**
7141	*  Return a new ``uint112`` type for %%v%%.
7142	*/
7143	static uint112(v) {
7144		return n(v, 112);
7145	}
7146	/**
7147	*  Return a new ``uint120`` type for %%v%%.
7148	*/
7149	static uint120(v) {
7150		return n(v, 120);
7151	}
7152	/**
7153	*  Return a new ``uint128`` type for %%v%%.
7154	*/
7155	static uint128(v) {
7156		return n(v, 128);
7157	}
7158	/**
7159	*  Return a new ``uint136`` type for %%v%%.
7160	*/
7161	static uint136(v) {
7162		return n(v, 136);
7163	}
7164	/**
7165	*  Return a new ``uint144`` type for %%v%%.
7166	*/
7167	static uint144(v) {
7168		return n(v, 144);
7169	}
7170	/**
7171	*  Return a new ``uint152`` type for %%v%%.
7172	*/
7173	static uint152(v) {
7174		return n(v, 152);
7175	}
7176	/**
7177	*  Return a new ``uint160`` type for %%v%%.
7178	*/
7179	static uint160(v) {
7180		return n(v, 160);
7181	}
7182	/**
7183	*  Return a new ``uint168`` type for %%v%%.
7184	*/
7185	static uint168(v) {
7186		return n(v, 168);
7187	}
7188	/**
7189	*  Return a new ``uint176`` type for %%v%%.
7190	*/
7191	static uint176(v) {
7192		return n(v, 176);
7193	}
7194	/**
7195	*  Return a new ``uint184`` type for %%v%%.
7196	*/
7197	static uint184(v) {
7198		return n(v, 184);
7199	}
7200	/**
7201	*  Return a new ``uint192`` type for %%v%%.
7202	*/
7203	static uint192(v) {
7204		return n(v, 192);
7205	}
7206	/**
7207	*  Return a new ``uint200`` type for %%v%%.
7208	*/
7209	static uint200(v) {
7210		return n(v, 200);
7211	}
7212	/**
7213	*  Return a new ``uint208`` type for %%v%%.
7214	*/
7215	static uint208(v) {
7216		return n(v, 208);
7217	}
7218	/**
7219	*  Return a new ``uint216`` type for %%v%%.
7220	*/
7221	static uint216(v) {
7222		return n(v, 216);
7223	}
7224	/**
7225	*  Return a new ``uint224`` type for %%v%%.
7226	*/
7227	static uint224(v) {
7228		return n(v, 224);
7229	}
7230	/**
7231	*  Return a new ``uint232`` type for %%v%%.
7232	*/
7233	static uint232(v) {
7234		return n(v, 232);
7235	}
7236	/**
7237	*  Return a new ``uint240`` type for %%v%%.
7238	*/
7239	static uint240(v) {
7240		return n(v, 240);
7241	}
7242	/**
7243	*  Return a new ``uint248`` type for %%v%%.
7244	*/
7245	static uint248(v) {
7246		return n(v, 248);
7247	}
7248	/**
7249	*  Return a new ``uint256`` type for %%v%%.
7250	*/
7251	static uint256(v) {
7252		return n(v, 256);
7253	}
7254	/**
7255	*  Return a new ``uint256`` type for %%v%%.
7256	*/
7257	static uint(v) {
7258		return n(v, 256);
7259	}
7260	/**
7261	*  Return a new ``int8`` type for %%v%%.
7262	*/
7263	static int8(v) {
7264		return n(v, -8);
7265	}
7266	/**
7267	*  Return a new ``int16`` type for %%v%%.
7268	*/
7269	static int16(v) {
7270		return n(v, -16);
7271	}
7272	/**
7273	*  Return a new ``int24`` type for %%v%%.
7274	*/
7275	static int24(v) {
7276		return n(v, -24);
7277	}
7278	/**
7279	*  Return a new ``int32`` type for %%v%%.
7280	*/
7281	static int32(v) {
7282		return n(v, -32);
7283	}
7284	/**
7285	*  Return a new ``int40`` type for %%v%%.
7286	*/
7287	static int40(v) {
7288		return n(v, -40);
7289	}
7290	/**
7291	*  Return a new ``int48`` type for %%v%%.
7292	*/
7293	static int48(v) {
7294		return n(v, -48);
7295	}
7296	/**
7297	*  Return a new ``int56`` type for %%v%%.
7298	*/
7299	static int56(v) {
7300		return n(v, -56);
7301	}
7302	/**
7303	*  Return a new ``int64`` type for %%v%%.
7304	*/
7305	static int64(v) {
7306		return n(v, -64);
7307	}
7308	/**
7309	*  Return a new ``int72`` type for %%v%%.
7310	*/
7311	static int72(v) {
7312		return n(v, -72);
7313	}
7314	/**
7315	*  Return a new ``int80`` type for %%v%%.
7316	*/
7317	static int80(v) {
7318		return n(v, -80);
7319	}
7320	/**
7321	*  Return a new ``int88`` type for %%v%%.
7322	*/
7323	static int88(v) {
7324		return n(v, -88);
7325	}
7326	/**
7327	*  Return a new ``int96`` type for %%v%%.
7328	*/
7329	static int96(v) {
7330		return n(v, -96);
7331	}
7332	/**
7333	*  Return a new ``int104`` type for %%v%%.
7334	*/
7335	static int104(v) {
7336		return n(v, -104);
7337	}
7338	/**
7339	*  Return a new ``int112`` type for %%v%%.
7340	*/
7341	static int112(v) {
7342		return n(v, -112);
7343	}
7344	/**
7345	*  Return a new ``int120`` type for %%v%%.
7346	*/
7347	static int120(v) {
7348		return n(v, -120);
7349	}
7350	/**
7351	*  Return a new ``int128`` type for %%v%%.
7352	*/
7353	static int128(v) {
7354		return n(v, -128);
7355	}
7356	/**
7357	*  Return a new ``int136`` type for %%v%%.
7358	*/
7359	static int136(v) {
7360		return n(v, -136);
7361	}
7362	/**
7363	*  Return a new ``int144`` type for %%v%%.
7364	*/
7365	static int144(v) {
7366		return n(v, -144);
7367	}
7368	/**
7369	*  Return a new ``int52`` type for %%v%%.
7370	*/
7371	static int152(v) {
7372		return n(v, -152);
7373	}
7374	/**
7375	*  Return a new ``int160`` type for %%v%%.
7376	*/
7377	static int160(v) {
7378		return n(v, -160);
7379	}
7380	/**
7381	*  Return a new ``int168`` type for %%v%%.
7382	*/
7383	static int168(v) {
7384		return n(v, -168);
7385	}
7386	/**
7387	*  Return a new ``int176`` type for %%v%%.
7388	*/
7389	static int176(v) {
7390		return n(v, -176);
7391	}
7392	/**
7393	*  Return a new ``int184`` type for %%v%%.
7394	*/
7395	static int184(v) {
7396		return n(v, -184);
7397	}
7398	/**
7399	*  Return a new ``int92`` type for %%v%%.
7400	*/
7401	static int192(v) {
7402		return n(v, -192);
7403	}
7404	/**
7405	*  Return a new ``int200`` type for %%v%%.
7406	*/
7407	static int200(v) {
7408		return n(v, -200);
7409	}
7410	/**
7411	*  Return a new ``int208`` type for %%v%%.
7412	*/
7413	static int208(v) {
7414		return n(v, -208);
7415	}
7416	/**
7417	*  Return a new ``int216`` type for %%v%%.
7418	*/
7419	static int216(v) {
7420		return n(v, -216);
7421	}
7422	/**
7423	*  Return a new ``int224`` type for %%v%%.
7424	*/
7425	static int224(v) {
7426		return n(v, -224);
7427	}
7428	/**
7429	*  Return a new ``int232`` type for %%v%%.
7430	*/
7431	static int232(v) {
7432		return n(v, -232);
7433	}
7434	/**
7435	*  Return a new ``int240`` type for %%v%%.
7436	*/
7437	static int240(v) {
7438		return n(v, -240);
7439	}
7440	/**
7441	*  Return a new ``int248`` type for %%v%%.
7442	*/
7443	static int248(v) {
7444		return n(v, -248);
7445	}
7446	/**
7447	*  Return a new ``int256`` type for %%v%%.
7448	*/
7449	static int256(v) {
7450		return n(v, -256);
7451	}
7452	/**
7453	*  Return a new ``int256`` type for %%v%%.
7454	*/
7455	static int(v) {
7456		return n(v, -256);
7457	}
7458	/**
7459	*  Return a new ``bytes1`` type for %%v%%.
7460	*/
7461	static bytes1(v) {
7462		return b(v, 1);
7463	}
7464	/**
7465	*  Return a new ``bytes2`` type for %%v%%.
7466	*/
7467	static bytes2(v) {
7468		return b(v, 2);
7469	}
7470	/**
7471	*  Return a new ``bytes3`` type for %%v%%.
7472	*/
7473	static bytes3(v) {
7474		return b(v, 3);
7475	}
7476	/**
7477	*  Return a new ``bytes4`` type for %%v%%.
7478	*/
7479	static bytes4(v) {
7480		return b(v, 4);
7481	}
7482	/**
7483	*  Return a new ``bytes5`` type for %%v%%.
7484	*/
7485	static bytes5(v) {
7486		return b(v, 5);
7487	}
7488	/**
7489	*  Return a new ``bytes6`` type for %%v%%.
7490	*/
7491	static bytes6(v) {
7492		return b(v, 6);
7493	}
7494	/**
7495	*  Return a new ``bytes7`` type for %%v%%.
7496	*/
7497	static bytes7(v) {
7498		return b(v, 7);
7499	}
7500	/**
7501	*  Return a new ``bytes8`` type for %%v%%.
7502	*/
7503	static bytes8(v) {
7504		return b(v, 8);
7505	}
7506	/**
7507	*  Return a new ``bytes9`` type for %%v%%.
7508	*/
7509	static bytes9(v) {
7510		return b(v, 9);
7511	}
7512	/**
7513	*  Return a new ``bytes10`` type for %%v%%.
7514	*/
7515	static bytes10(v) {
7516		return b(v, 10);
7517	}
7518	/**
7519	*  Return a new ``bytes11`` type for %%v%%.
7520	*/
7521	static bytes11(v) {
7522		return b(v, 11);
7523	}
7524	/**
7525	*  Return a new ``bytes12`` type for %%v%%.
7526	*/
7527	static bytes12(v) {
7528		return b(v, 12);
7529	}
7530	/**
7531	*  Return a new ``bytes13`` type for %%v%%.
7532	*/
7533	static bytes13(v) {
7534		return b(v, 13);
7535	}
7536	/**
7537	*  Return a new ``bytes14`` type for %%v%%.
7538	*/
7539	static bytes14(v) {
7540		return b(v, 14);
7541	}
7542	/**
7543	*  Return a new ``bytes15`` type for %%v%%.
7544	*/
7545	static bytes15(v) {
7546		return b(v, 15);
7547	}
7548	/**
7549	*  Return a new ``bytes16`` type for %%v%%.
7550	*/
7551	static bytes16(v) {
7552		return b(v, 16);
7553	}
7554	/**
7555	*  Return a new ``bytes17`` type for %%v%%.
7556	*/
7557	static bytes17(v) {
7558		return b(v, 17);
7559	}
7560	/**
7561	*  Return a new ``bytes18`` type for %%v%%.
7562	*/
7563	static bytes18(v) {
7564		return b(v, 18);
7565	}
7566	/**
7567	*  Return a new ``bytes19`` type for %%v%%.
7568	*/
7569	static bytes19(v) {
7570		return b(v, 19);
7571	}
7572	/**
7573	*  Return a new ``bytes20`` type for %%v%%.
7574	*/
7575	static bytes20(v) {
7576		return b(v, 20);
7577	}
7578	/**
7579	*  Return a new ``bytes21`` type for %%v%%.
7580	*/
7581	static bytes21(v) {
7582		return b(v, 21);
7583	}
7584	/**
7585	*  Return a new ``bytes22`` type for %%v%%.
7586	*/
7587	static bytes22(v) {
7588		return b(v, 22);
7589	}
7590	/**
7591	*  Return a new ``bytes23`` type for %%v%%.
7592	*/
7593	static bytes23(v) {
7594		return b(v, 23);
7595	}
7596	/**
7597	*  Return a new ``bytes24`` type for %%v%%.
7598	*/
7599	static bytes24(v) {
7600		return b(v, 24);
7601	}
7602	/**
7603	*  Return a new ``bytes25`` type for %%v%%.
7604	*/
7605	static bytes25(v) {
7606		return b(v, 25);
7607	}
7608	/**
7609	*  Return a new ``bytes26`` type for %%v%%.
7610	*/
7611	static bytes26(v) {
7612		return b(v, 26);
7613	}
7614	/**
7615	*  Return a new ``bytes27`` type for %%v%%.
7616	*/
7617	static bytes27(v) {
7618		return b(v, 27);
7619	}
7620	/**
7621	*  Return a new ``bytes28`` type for %%v%%.
7622	*/
7623	static bytes28(v) {
7624		return b(v, 28);
7625	}
7626	/**
7627	*  Return a new ``bytes29`` type for %%v%%.
7628	*/
7629	static bytes29(v) {
7630		return b(v, 29);
7631	}
7632	/**
7633	*  Return a new ``bytes30`` type for %%v%%.
7634	*/
7635	static bytes30(v) {
7636		return b(v, 30);
7637	}
7638	/**
7639	*  Return a new ``bytes31`` type for %%v%%.
7640	*/
7641	static bytes31(v) {
7642		return b(v, 31);
7643	}
7644	/**
7645	*  Return a new ``bytes32`` type for %%v%%.
7646	*/
7647	static bytes32(v) {
7648		return b(v, 32);
7649	}
7650	/**
7651	*  Return a new ``address`` type for %%v%%.
7652	*/
7653	static address(v) {
7654		return new Typed(_gaurd, "address", v);
7655	}
7656	/**
7657	*  Return a new ``bool`` type for %%v%%.
7658	*/
7659	static bool(v) {
7660		return new Typed(_gaurd, "bool", !!v);
7661	}
7662	/**
7663	*  Return a new ``bytes`` type for %%v%%.
7664	*/
7665	static bytes(v) {
7666		return new Typed(_gaurd, "bytes", v);
7667	}
7668	/**
7669	*  Return a new ``string`` type for %%v%%.
7670	*/
7671	static string(v) {
7672		return new Typed(_gaurd, "string", v);
7673	}
7674	/**
7675	*  Return a new ``array`` type for %%v%%, allowing %%dynamic%% length.
7676	*/
7677	static array(v, dynamic) {
7678		throw new Error("not implemented yet");
7679	}
7680	/**
7681	*  Return a new ``tuple`` type for %%v%%, with the optional %%name%%.
7682	*/
7683	static tuple(v, name) {
7684		throw new Error("not implemented yet");
7685	}
7686	/**
7687	*  Return a new ``uint8`` type for %%v%%.
7688	*/
7689	static overrides(v) {
7690		return new Typed(_gaurd, "overrides", Object.assign({}, v));
7691	}
7692	/**
7693	*  Returns true only if %%value%% is a [[Typed]] instance.
7694	*/
7695	static isTyped(value) {
7696		return value && typeof value === "object" && "_typedSymbol" in value && value._typedSymbol === _typedSymbol;
7697	}

7698	/**
7699	*  If the value is a [[Typed]] instance, validates the underlying value
7700	*  and returns it, otherwise returns value directly.
7701	*
7702	*  This is useful for functions that with to accept either a [[Typed]]
7703	*  object or values.
7704	*/
7705	static dereference(value, type) {
7706		if (Typed.isTyped(value)) {
7707			if (value.type !== type) throw new Error(`invalid type: expecetd ${type}, got ${value.type}`);
7708			return value.value;
7709		}
7710		return value;
7711	}
7712};
7713//#endregion
7714//#region node_modules/ethers/lib.esm/abi/coders/address.js
7715/**
7716*  @_ignore
7717*/
7718var AddressCoder = class extends Coder {
7719	constructor(localName) {
7720		super("address", "address", localName, false);
7721	}
7722	defaultValue() {
7723		return "0x0000000000000000000000000000000000000000";
7724	}
7725	encode(writer, _value) {
7726		let value = Typed.dereference(_value, "string");
7727		try {
7728			value = getAddress(value);
7729		} catch (error) {
7730			return this._throwError(error.message, _value);
7731		}
7732		return writer.writeValue(value);
7733	}
7734	decode(reader) {
7735		return getAddress(toBeHex(reader.readValue(), 20));
7736	}
7737};
7738//#endregion
7739//#region node_modules/ethers/lib.esm/abi/coders/anonymous.js
7740/**
7741*  Clones the functionality of an existing Coder, but without a localName
7742*
7743*  @_ignore
7744*/
7745var AnonymousCoder = class extends Coder {
7746	coder;
7747	constructor(coder) {
7748		super(coder.name, coder.type, "_", coder.dynamic);
7749		this.coder = coder;
7750	}
7751	defaultValue() {
7752		return this.coder.defaultValue();
7753	}
7754	encode(writer, value) {
7755		return this.coder.encode(writer, value);
7756	}
7757	decode(reader) {
7758		return this.coder.decode(reader);
7759	}
7760};
7761//#endregion
7762//#region node_modules/ethers/lib.esm/abi/coders/array.js
7763/**
7764*  @_ignore
7765*/
7766function pack(writer, coders, values) {
7767	let arrayValues = [];
7768	if (Array.isArray(values)) arrayValues = values;
7769	else if (values && typeof values === "object") {
7770		let unique = {};
7771		arrayValues = coders.map((coder) => {
7772			const name = coder.localName;
7773			assert(name, "cannot encode object for signature with missing names", "INVALID_ARGUMENT", {
7774				argument: "values",
7775				info: { coder },
7776				value: values
7777			});
7778			assert(!unique[name], "cannot encode object for signature with duplicate names", "INVALID_ARGUMENT", {
7779				argument: "values",
7780				info: { coder },
7781				value: values
7782			});
7783			unique[name] = true;
7784			return values[name];
7785		});
7786	} else assertArgument(false, "invalid tuple value", "tuple", values);
7787	assertArgument(coders.length === arrayValues.length, "types/value length mismatch", "tuple", values);
7788	let staticWriter = new Writer();
7789	let dynamicWriter = new Writer();
7790	let updateFuncs = [];
7791	coders.forEach((coder, index) => {
7792		let value = arrayValues[index];
7793		if (coder.dynamic) {
7794			let dynamicOffset = dynamicWriter.length;
7795			coder.encode(dynamicWriter, value);
7796			let updateFunc = staticWriter.writeUpdatableValue();
7797			updateFuncs.push((baseOffset) => {
7798				updateFunc(baseOffset + dynamicOffset);
7799			});
7800		} else coder.encode(staticWriter, value);
7801	});
7802	updateFuncs.forEach((func) => {
7803		func(staticWriter.length);
7804	});
7805	let length = writer.appendWriter(staticWriter);
7806	length += writer.appendWriter(dynamicWriter);
7807	return length;
7808}
7809/**
7810*  @_ignore
7811*/
7812function unpack(reader, coders) {
7813	let values = [];
7814	let keys = [];
7815	let baseReader = reader.subReader(0);
7816	coders.forEach((coder) => {
7817		let value = null;
7818		if (coder.dynamic) {
7819			let offset = reader.readIndex();
7820			let offsetReader = baseReader.subReader(offset);
7821			try {
7822				value = coder.decode(offsetReader);
7823			} catch (error) {
7824				if (isError(error, "BUFFER_OVERRUN")) throw error;
7825				value = error;
7826				value.baseType = coder.name;
7827				value.name = coder.localName;
7828				value.type = coder.type;
7829			}
7830		} else try {
7831			value = coder.decode(reader);
7832		} catch (error) {
7833			if (isError(error, "BUFFER_OVERRUN")) throw error;
7834			value = error;
7835			value.baseType = coder.name;
7836			value.name = coder.localName;
7837			value.type = coder.type;
7838		}
7839		if (value == void 0) throw new Error("investigate");
7840		values.push(value);
7841		keys.push(coder.localName || null);
7842	});
7843	return Result.fromItems(values, keys);
7844}
7845/**
7846*  @_ignore
7847*/
7848var ArrayCoder = class extends Coder {
7849	coder;
7850	length;
7851	constructor(coder, length, localName) {
7852		const type = coder.type + "[" + (length >= 0 ? length : "") + "]";
7853		const dynamic = length === -1 || coder.dynamic;
7854		super("array", type, localName, dynamic);
7855		defineProperties(this, {
7856			coder,
7857			length
7858		});
7859	}
7860	defaultValue() {

7861		const defaultChild = this.coder.defaultValue();
7862		const result = [];
7863		for (let i = 0; i < this.length; i++) result.push(defaultChild);
7864		return result;
7865	}
7866	encode(writer, _value) {
7867		const value = Typed.dereference(_value, "array");
7868		if (!Array.isArray(value)) this._throwError("expected array value", value);
7869		let count = this.length;
7870		if (count === -1) {
7871			count = value.length;
7872			writer.writeValue(value.length);
7873		}
7874		assertArgumentCount(value.length, count, "coder array" + (this.localName ? " " + this.localName : ""));
7875		let coders = [];
7876		for (let i = 0; i < value.length; i++) coders.push(this.coder);
7877		return pack(writer, coders, value);
7878	}
7879	decode(reader) {
7880		let count = this.length;
7881		if (count === -1) {
7882			count = reader.readIndex();
7883			assert(count * 32 <= reader.dataLength, "insufficient data length", "BUFFER_OVERRUN", {
7884				buffer: reader.bytes,
7885				offset: count * 32,
7886				length: reader.dataLength
7887			});
7888		}
7889		let coders = [];
7890		for (let i = 0; i < count; i++) coders.push(new AnonymousCoder(this.coder));
7891		return unpack(reader, coders);
7892	}
7893};
7894//#endregion
7895//#region node_modules/ethers/lib.esm/abi/coders/boolean.js
7896/**
7897*  @_ignore
7898*/
7899var BooleanCoder = class extends Coder {
7900	constructor(localName) {
7901		super("bool", "bool", localName, false);
7902	}
7903	defaultValue() {
7904		return false;
7905	}
7906	encode(writer, _value) {
7907		const value = Typed.dereference(_value, "bool");
7908		return writer.writeValue(value ? 1 : 0);
7909	}
7910	decode(reader) {
7911		return !!reader.readValue();
7912	}
7913};
7914//#endregion
7915//#region node_modules/ethers/lib.esm/abi/coders/bytes.js
7916/**
7917*  @_ignore
7918*/
7919var DynamicBytesCoder = class extends Coder {
7920	constructor(type, localName) {
7921		super(type, type, localName, true);
7922	}
7923	defaultValue() {
7924		return "0x";
7925	}
7926	encode(writer, value) {
7927		value = getBytesCopy(value);
7928		let length = writer.writeValue(value.length);
7929		length += writer.writeBytes(value);
7930		return length;
7931	}
7932	decode(reader) {
7933		return reader.readBytes(reader.readIndex(), true);
7934	}
7935};
7936/**
7937*  @_ignore
7938*/
7939var BytesCoder = class extends DynamicBytesCoder {
7940	constructor(localName) {
7941		super("bytes", localName);
7942	}
7943	decode(reader) {
7944		return hexlify(super.decode(reader));
7945	}
7946};
7947//#endregion
7948//#region node_modules/ethers/lib.esm/abi/coders/fixed-bytes.js
7949/**
7950*  @_ignore
7951*/
7952var FixedBytesCoder = class extends Coder {
7953	size;
7954	constructor(size, localName) {
7955		let name = "bytes" + String(size);
7956		super(name, name, localName, false);
7957		defineProperties(this, { size }, { size: "number" });
7958	}
7959	defaultValue() {
7960		return "0x0000000000000000000000000000000000000000000000000000000000000000".substring(0, 2 + this.size * 2);
7961	}
7962	encode(writer, _value) {
7963		let data = getBytesCopy(Typed.dereference(_value, this.type));
7964		if (data.length !== this.size) this._throwError("incorrect data length", _value);
7965		return writer.writeBytes(data);
7966	}
7967	decode(reader) {
7968		return hexlify(reader.readBytes(this.size));
7969	}
7970};
7971//#endregion
7972//#region node_modules/ethers/lib.esm/abi/coders/null.js
7973var Empty = new Uint8Array([]);
7974/**
7975*  @_ignore
7976*/
7977var NullCoder = class extends Coder {
7978	constructor(localName) {
7979		super("null", "", localName, false);
7980	}
7981	defaultValue() {
7982		return null;
7983	}
7984	encode(writer, value) {
7985		if (value != null) this._throwError("not null", value);
7986		return writer.writeBytes(Empty);
7987	}
7988	decode(reader) {
7989		reader.readBytes(0);
7990		return null;
7991	}
7992};
7993//#endregion
7994//#region node_modules/ethers/lib.esm/abi/coders/number.js
7995var BN_0$5 = BigInt(0);
7996var BN_1$2 = BigInt(1);
7997var BN_MAX_UINT256$1 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
7998/**
7999*  @_ignore
8000*/
8001var NumberCoder = class extends Coder {
8002	size;
8003	signed;
8004	constructor(size, signed, localName) {
8005		const name = (signed ? "int" : "uint") + size * 8;
8006		super(name, name, localName, false);
8007		defineProperties(this, {
8008			size,
8009			signed
8010		}, {
8011			size: "number",
8012			signed: "boolean"
8013		});
8014	}
8015	defaultValue() {
8016		return 0;
8017	}
8018	encode(writer, _value) {
8019		let value = getBigInt(Typed.dereference(_value, this.type));
8020		let maxUintValue = mask(BN_MAX_UINT256$1, 256);
8021		if (this.signed) {
8022			let bounds = mask(maxUintValue, this.size * 8 - 1);
8023			if (value > bounds || value < -(bounds + BN_1$2)) this._throwError("value out-of-bounds", _value);
8024			value = toTwos(value, 256);
8025		} else if (value < BN_0$5 || value > mask(maxUintValue, this.size * 8)) this._throwError("value out-of-bounds", _value);
8026		return writer.writeValue(value);
8027	}
8028	decode(reader) {
8029		let value = mask(reader.readValue(), this.size * 8);
8030		if (this.signed) value = fromTwos(value, this.size * 8);
8031		return value;
8032	}
8033};
8034//#endregion
8035//#region node_modules/ethers/lib.esm/abi/coders/string.js
8036/**
8037*  @_ignore
8038*/
8039var StringCoder = class extends DynamicBytesCoder {
8040	constructor(localName) {
8041		super("string", localName);
8042	}
8043	defaultValue() {
8044		return "";
8045	}
8046	encode(writer, _value) {
8047		return super.encode(writer, toUtf8Bytes(Typed.dereference(_value, "string")));
8048	}
8049	decode(reader) {
8050		return toUtf8String(super.decode(reader));
8051	}
8052};
8053//#endregion
8054//#region node_modules/ethers/lib.esm/abi/coders/tuple.js
8055/**
8056*  @_ignore
8057*/
8058var TupleCoder = class extends Coder {
8059	coders;
8060	constructor(coders, localName) {
8061		let dynamic = false;

8062		const types = [];
8063		coders.forEach((coder) => {
8064			if (coder.dynamic) dynamic = true;
8065			types.push(coder.type);
8066		});
8067		const type = "tuple(" + types.join(",") + ")";
8068		super("tuple", type, localName, dynamic);
8069		defineProperties(this, { coders: Object.freeze(coders.slice()) });
8070	}
8071	defaultValue() {
8072		const values = [];
8073		this.coders.forEach((coder) => {
8074			values.push(coder.defaultValue());
8075		});
8076		const uniqueNames = this.coders.reduce((accum, coder) => {
8077			const name = coder.localName;
8078			if (name) {
8079				if (!accum[name]) accum[name] = 0;
8080				accum[name]++;
8081			}
8082			return accum;
8083		}, {});
8084		this.coders.forEach((coder, index) => {
8085			let name = coder.localName;
8086			if (!name || uniqueNames[name] !== 1) return;
8087			if (name === "length") name = "_length";
8088			if (values[name] != null) return;
8089			values[name] = values[index];
8090		});
8091		return Object.freeze(values);
8092	}
8093	encode(writer, _value) {
8094		const value = Typed.dereference(_value, "tuple");
8095		return pack(writer, this.coders, value);
8096	}
8097	decode(reader) {
8098		return unpack(reader, this.coders);
8099	}
8100};
8101//#endregion
8102//#region node_modules/ethers/lib.esm/transaction/accesslist.js
8103function accessSetify(addr, storageKeys) {
8104	return {
8105		address: getAddress(addr),
8106		storageKeys: storageKeys.map((storageKey, index) => {
8107			assertArgument(isHexString(storageKey, 32), "invalid slot", `storageKeys[${index}]`, storageKey);
8108			return storageKey.toLowerCase();
8109		})
8110	};
8111}
8112/**
8113*  Returns a [[AccessList]] from any ethers-supported access-list structure.
8114*/
8115function accessListify(value) {
8116	if (Array.isArray(value)) return value.map((set, index) => {
8117		if (Array.isArray(set)) {
8118			assertArgument(set.length === 2, "invalid slot set", `value[${index}]`, set);
8119			return accessSetify(set[0], set[1]);
8120		}
8121		assertArgument(set != null && typeof set === "object", "invalid address-slot set", "value", value);
8122		return accessSetify(set.address, set.storageKeys);
8123	});
8124	assertArgument(value != null && typeof value === "object", "invalid access list", "value", value);
8125	const result = Object.keys(value).map((addr) => {
8126		const storageKeys = value[addr].reduce((accum, storageKey) => {
8127			accum[storageKey] = true;
8128			return accum;
8129		}, {});
8130		return accessSetify(addr, Object.keys(storageKeys).sort());
8131	});
8132	result.sort((a, b) => a.address.localeCompare(b.address));
8133	return result;
8134}
8135//#endregion
8136//#region node_modules/ethers/lib.esm/transaction/authorization.js
8137function authorizationify(auth) {
8138	return {
8139		address: getAddress(auth.address),
8140		nonce: getBigInt(auth.nonce != null ? auth.nonce : 0),
8141		chainId: getBigInt(auth.chainId != null ? auth.chainId : 0),
8142		signature: Signature.from(auth.signature)
8143	};
8144}
8145//#endregion
8146//#region node_modules/ethers/lib.esm/transaction/address.js
8147/**
8148*  Returns the address for the %%key%%.
8149*
8150*  The key may be any standard form of public key or a private key.
8151*/
8152function computeAddress(key) {
8153	let pubkey;
8154	if (typeof key === "string") pubkey = SigningKey.computePublicKey(key, false);
8155	else pubkey = key.publicKey;
8156	return getAddress(keccak256("0x" + pubkey.substring(4)).substring(26));
8157}
8158/**
8159*  Returns the recovered address for the private key that was
8160*  used to sign %%digest%% that resulted in %%signature%%.
8161*/
8162function recoverAddress(digest, signature) {
8163	return computeAddress(SigningKey.recoverPublicKey(digest, signature));
8164}
8165//#endregion
8166//#region node_modules/ethers/lib.esm/transaction/transaction.js
8167var BN_0$4 = BigInt(0);
8168var BN_2$2 = BigInt(2);
8169var BN_27 = BigInt(27);
8170var BN_28 = BigInt(28);
8171var BN_35 = BigInt(35);
8172var BN_MAX_UINT = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
8173var inspect$2 = Symbol.for("nodejs.util.inspect.custom");
8174var BLOB_SIZE = 131072;
8175var CELL_COUNT = 128;
8176function getKzgLibrary(kzg) {
8177	const blobToKzgCommitment = (blob) => {
8178		if ("computeBlobProof" in kzg) {
8179			if ("blobToKzgCommitment" in kzg && typeof kzg.blobToKzgCommitment === "function") return getBytes(kzg.blobToKzgCommitment(hexlify(blob)));
8180		} else if ("blobToKzgCommitment" in kzg && typeof kzg.blobToKzgCommitment === "function") return getBytes(kzg.blobToKzgCommitment(blob));
8181		if ("blobToKZGCommitment" in kzg && typeof kzg.blobToKZGCommitment === "function") return getBytes(kzg.blobToKZGCommitment(hexlify(blob)));
8182		assertArgument(false, "unsupported KZG library", "kzg", kzg);
8183	};
8184	const computeBlobKzgProof = (blob, commitment) => {
8185		if ("computeBlobProof" in kzg && typeof kzg.computeBlobProof === "function") return getBytes(kzg.computeBlobProof(hexlify(blob), hexlify(commitment)));
8186		if ("computeBlobKzgProof" in kzg && typeof kzg.computeBlobKzgProof === "function") return kzg.computeBlobKzgProof(blob, commitment);
8187		if ("computeBlobKZGProof" in kzg && typeof kzg.computeBlobKZGProof === "function") return getBytes(kzg.computeBlobKZGProof(hexlify(blob), hexlify(commitment)));
8188		assertArgument(false, "unsupported KZG library", "kzg", kzg);
8189	};
8190	return {
8191		blobToKzgCommitment,
8192		computeBlobKzgProof
8193	};
8194}
8195function getVersionedHash(version, hash) {
8196	let versioned = version.toString(16);
8197	while (versioned.length < 2) versioned = "0" + versioned;
8198	versioned += sha256(hash).substring(4);
8199	return "0x" + versioned;
8200}
8201function handleAddress(value) {
8202	if (value === "0x") return null;
8203	return getAddress(value);
8204}
8205function handleAccessList(value, param) {
8206	try {
8207		return accessListify(value);
8208	} catch (error) {
8209		assertArgument(false, error.message, param, value);
8210	}
8211}
8212function handleAuthorizationList(value, param) {
8213	try {
8214		if (!Array.isArray(value)) throw new Error("authorizationList: invalid array");
8215		const result = [];
8216		for (let i = 0; i < value.length; i++) {
8217			const auth = value[i];
8218			if (!Array.isArray(auth)) throw new Error(`authorization[${i}

8218]: invalid array`);
8219			if (auth.length !== 6) throw new Error(`authorization[${i}]: wrong length`);
8220			if (!auth[1]) throw new Error(`authorization[${i}]: null address`);
8221			result.push({
8222				address: handleAddress(auth[1]),
8223				nonce: handleUint(auth[2], "nonce"),
8224				chainId: handleUint(auth[0], "chainId"),
8225				signature: Signature.from({
8226					yParity: handleNumber(auth[3], "yParity"),
8227					r: zeroPadValue(auth[4], 32),
8228					s: zeroPadValue(auth[5], 32)
8229				})
8230			});
8231		}
8232		return result;
8233	} catch (error) {
8234		assertArgument(false, error.message, param, value);
8235	}
8236}
8237function handleNumber(_value, param) {
8238	if (_value === "0x") return 0;
8239	return getNumber(_value, param);
8240}
8241function handleUint(_value, param) {
8242	if (_value === "0x") return BN_0$4;
8243	const value = getBigInt(_value, param);
8244	assertArgument(value <= BN_MAX_UINT, "value exceeds uint size", param, value);
8245	return value;
8246}
8247function formatNumber(_value, name) {
8248	const value = getBigInt(_value, "value");
8249	const result = toBeArray(value);
8250	assertArgument(result.length <= 32, `value too large`, `tx.${name}`, value);
8251	return result;
8252}
8253function formatAccessList(value) {
8254	return accessListify(value).map((set) => [set.address, set.storageKeys]);
8255}
8256function formatAuthorizationList(value) {
8257	return value.map((a) => {
8258		return [
8259			formatNumber(a.chainId, "chainId"),
8260			a.address,
8261			formatNumber(a.nonce, "nonce"),
8262			formatNumber(a.signature.yParity, "yParity"),
8263			toBeArray(a.signature.r),
8264			toBeArray(a.signature._s)
8265		];
8266	});
8267}
8268function formatHashes(value, param) {
8269	assertArgument(Array.isArray(value), `invalid ${param}`, "value", value);
8270	for (let i = 0; i < value.length; i++) assertArgument(isHexString(value[i], 32), "invalid ${ param } hash", `value[${i}]`, value[i]);
8271	return value;
8272}
8273function _parseLegacy(data) {
8274	const fields = decodeRlp(data);
8275	assertArgument(Array.isArray(fields) && (fields.length === 9 || fields.length === 6), "invalid field count for legacy transaction", "data", data);
8276	const tx = {
8277		type: 0,
8278		nonce: handleNumber(fields[0], "nonce"),
8279		gasPrice: handleUint(fields[1], "gasPrice"),
8280		gasLimit: handleUint(fields[2], "gasLimit"),
8281		to: handleAddress(fields[3]),
8282		value: handleUint(fields[4], "value"),
8283		data: hexlify(fields[5]),
8284		chainId: BN_0$4
8285	};
8286	if (fields.length === 6) return tx;
8287	const v = handleUint(fields[6], "v");
8288	const r = handleUint(fields[7], "r");
8289	const s = handleUint(fields[8], "s");
8290	if (r === BN_0$4 && s === BN_0$4) tx.chainId = v;
8291	else {
8292		let chainId = (v - BN_35) / BN_2$2;
8293		if (chainId < BN_0$4) chainId = BN_0$4;
8294		tx.chainId = chainId;
8295		assertArgument(chainId !== BN_0$4 || v === BN_27 || v === BN_28, "non-canonical legacy v", "v", fields[6]);
8296		tx.signature = Signature.from({
8297			r: zeroPadValue(fields[7], 32),
8298			s: zeroPadValue(fields[8], 32),
8299			v
8300		});
8301	}
8302	return tx;
8303}
8304function _serializeLegacy(tx, sig) {
8305	const fields = [
8306		formatNumber(tx.nonce, "nonce"),
8307		formatNumber(tx.gasPrice || 0, "gasPrice"),
8308		formatNumber(tx.gasLimit, "gasLimit"),
8309		tx.to || "0x",
8310		formatNumber(tx.value, "value"),
8311		tx.data
8312	];
8313	let chainId = BN_0$4;
8314	if (tx.chainId != BN_0$4) {
8315		chainId = getBigInt(tx.chainId, "tx.chainId");
8316		assertArgument(!sig || sig.networkV == null || sig.legacyChainId === chainId, "tx.chainId/sig.v mismatch", "sig", sig);
8317	} else if (tx.signature) {
8318		const legacy = tx.signature.legacyChainId;
8319		if (legacy != null) chainId = legacy;
8320	}
8321	if (!sig) {
8322		if (chainId !== BN_0$4) {
8323			fields.push(toBeArray(chainId));
8324			fields.push("0x");
8325			fields.push("0x");
8326		}
8327		return encodeRlp(fields);
8328	}
8329	let v = BigInt(27 + sig.yParity);
8330	if (chainId !== BN_0$4) v = Signature.getChainIdV(chainId, sig.v);
8331	else if (BigInt(sig.v) !== v) assertArgument(false, "tx.chainId/sig.v mismatch", "sig", sig);
8332	fields.push(toBeArray(v));
8333	fields.push(toBeArray(sig.r));
8334	fields.push(toBeArray(sig._s));
8335	return encodeRlp(fields);
8336}
8337function _parseEipSignature(tx, fields) {
8338	let yParity;
8339	try {
8340		yParity = handleNumber(fields[0], "yParity");
8341		if (yParity !== 0 && yParity !== 1) throw new Error("bad yParity");
8342	} catch (error) {
8343		assertArgument(false, "invalid yParity", "yParity", fields[0]);
8344	}
8345	const r = zeroPadValue(fields[1], 32);
8346	const s = zeroPadValue(fields[2], 32);
8347	tx.signature = Signature.from({
8348		r,
8349		s,
8350		yParity
8351	});
8352}
8353function _parseEip1559(data) {
8354	const fields = decodeRlp(getBytes(data).slice(1));
8355	assertArgument(Array.isArray(fields) && (fields.length === 9 || fields.length === 12), "invalid field count for transaction type: 2", "data", hexlify(data));
8356	const tx = {
8357		type: 2,
8358		chainId: handleUint(fields[0], "chainId"),
8359		nonce: handleNumber(fields[1], "nonce"),
8360		maxPriorityFeePerGas: handleUint(fields[2], "maxPriorityFeePerGas"),
8361		maxFeePerGas: handleUint(fields[3], "maxFeePerGas"),
8362		gasPrice: null,

vendor: 4,896 bytes, lines 8363-8477

8363		gasLimit: handleUint(fields[4], "gasLimit"),
8364		to: handleAddress(fields[5]),
8365		value: handleUint(fields[6], "value"),
8366		data: hexlify(fields[7]),
8367		accessList: handleAccessList(fields[8], "accessList")
8368	};
8369	if (fields.length === 9) return tx;
8370	_parseEipSignature(tx, fields.slice(9));
8371	return tx;
8372}
8373function _serializeEip1559(tx, sig) {
8374	const fields = [
8375		formatNumber(tx.chainId, "chainId"),
8376		formatNumber(tx.nonce, "nonce"),
8377		formatNumber(tx.maxPriorityFeePerGas || 0, "maxPriorityFeePerGas"),
8378		formatNumber(tx.maxFeePerGas || 0, "maxFeePerGas"),
8379		formatNumber(tx.gasLimit, "gasLimit"),
8380		tx.to || "0x",
8381		formatNumber(tx.value, "value"),
8382		tx.data,
8383		formatAccessList(tx.accessList || [])
8384	];
8385	if (sig) {
8386		fields.push(formatNumber(sig.yParity, "yParity"));
8387		fields.push(toBeArray(sig.r));
8388		fields.push(toBeArray(sig.s));
8389	}
8390	return concat(["0x02", encodeRlp(fields)]);
8391}
8392function _parseEip2930(data) {
8393	const fields = decodeRlp(getBytes(data).slice(1));
8394	assertArgument(Array.isArray(fields) && (fields.length === 8 || fields.length === 11), "invalid field count for transaction type: 1", "data", hexlify(data));
8395	const tx = {
8396		type: 1,
8397		chainId: handleUint(fields[0], "chainId"),
8398		nonce: handleNumber(fields[1], "nonce"),
8399		gasPrice: handleUint(fields[2], "gasPrice"),
8400		gasLimit: handleUint(fields[3], "gasLimit"),
8401		to: handleAddress(fields[4]),
8402		value: handleUint(fields[5], "value"),
8403		data: hexlify(fields[6]),
8404		accessList: handleAccessList(fields[7], "accessList")
8405	};
8406	if (fields.length === 8) return tx;
8407	_parseEipSignature(tx, fields.slice(8));
8408	return tx;
8409}
8410function _serializeEip2930(tx, sig) {
8411	const fields = [
8412		formatNumber(tx.chainId, "chainId"),
8413		formatNumber(tx.nonce, "nonce"),
8414		formatNumber(tx.gasPrice || 0, "gasPrice"),
8415		formatNumber(tx.gasLimit, "gasLimit"),
8416		tx.to || "0x",
8417		formatNumber(tx.value, "value"),
8418		tx.data,
8419		formatAccessList(tx.accessList || [])
8420	];
8421	if (sig) {
8422		fields.push(formatNumber(sig.yParity, "recoveryParam"));
8423		fields.push(toBeArray(sig.r));
8424		fields.push(toBeArray(sig.s));
8425	}
8426	return concat(["0x01", encodeRlp(fields)]);
8427}
8428function _parseEip4844(data) {
8429	let fields = decodeRlp(getBytes(data).slice(1));
8430	let typeName = "3";
8431	let blobWrapperVersion = null;
8432	let blobs = null;
8433	if (fields.length === 4 && Array.isArray(fields[0])) {
8434		typeName = "3 (network format)";
8435		const fBlobs = fields[1], fCommits = fields[2], fProofs = fields[3];
8436		assertArgument(Array.isArray(fBlobs), "invalid network format: blobs not an array", "fields[1]", fBlobs);
8437		assertArgument(Array.isArray(fCommits), "invalid network format: commitments not an array", "fields[2]", fCommits);
8438		assertArgument(Array.isArray(fProofs), "invalid network format: proofs not an array", "fields[3]", fProofs);
8439		assertArgument(fBlobs.length === fCommits.length, "invalid network format: blobs/commitments length mismatch", "fields", fields);
8440		assertArgument(fBlobs.length === fProofs.length, "invalid network format: blobs/proofs length mismatch", "fields", fields);
8441		blobs = [];
8442		for (let i = 0; i < fields[1].length; i++) blobs.push({
8443			data: fBlobs[i],
8444			commitment: fCommits[i],
8445			proof: fProofs[i]
8446		});
8447		fields = fields[0];
8448	} else if (fields.length === 5 && Array.isArray(fields[0])) {
8449		typeName = "3 (EIP-7594 network format)";
8450		blobWrapperVersion = getNumber(fields[1]);
8451		const fBlobs = fields[2], fCommits = fields[3], fProofs = fields[4];
8452		assertArgument(blobWrapperVersion === 1, `unsupported EIP-7594 network format version: ${blobWrapperVersion}`, "fields[1]", blobWrapperVersion);
8453		assertArgument(Array.isArray(fBlobs), "invalid EIP-7594 network format: blobs not an array", "fields[2]", fBlobs);
8454		assertArgument(Array.isArray(fCommits), "invalid EIP-7594 network format: commitments not an array", "fields[3]", fCommits);
8455		assertArgument(Array.isArray(fProofs), "invalid EIP-7594 network format: proofs not an array", "fields[4]", fProofs);
8456		assertArgument(fBlobs.length === fCommits.length, "invalid network format: blobs/commitments length mismatch", "fields", fields);
8457		assertArgument(fBlobs.length * CELL_COUNT === fProofs.length, "invalid network format: blobs/proofs length mismatch", "fields", fields);
8458		blobs = [];
8459		for (let i = 0; i < fBlobs.length; i++) {
8460			const proof = [];
8461			for (let j = 0; j < CELL_COUNT; j++) proof.push(fProofs[i * CELL_COUNT + j]);
8462			blobs.push({
8463				data: fBlobs[i],
8464				commitment: fCommits[i],
8465				proof: concat(proof)
8466			});
8467		}
8468		fields = fields[0];
8469	}
8470	assertArgument(Array.isArray(fields) && (fields.length === 11 || fields.length === 14), `invalid field count for transaction type: ${typeName}`, "data", hexlify(data));
8471	const tx = {
8472		type: 3,
8473		chainId: handleUint(fields[0], "chainId"),
8474		nonce: handleNumber(fields[1], "nonce"),
8475		maxPriorityFeePerGas: handleUint(fields[2], "maxPriorityFeePerGas"),
8476		maxFeePerGas: handleUint(fields[3], "maxFeePerGas"),
8477		gasPrice: null,

8478		gasLimit: handleUint(fields[4], "gasLimit"),
8479		to: handleAddress(fields[5]),
8480		value: handleUint(fields[6], "value"),
8481		data: hexlify(fields[7]),
8482		accessList: handleAccessList(fields[8], "accessList"),
8483		maxFeePerBlobGas: handleUint(fields[9], "maxFeePerBlobGas"),
8484		blobVersionedHashes: fields[10],
8485		blobWrapperVersion
8486	};
8487	if (blobs) tx.blobs = blobs;
8488	assertArgument(tx.to != null, `invalid address for transaction type: ${typeName}`, "data", data);
8489	assertArgument(Array.isArray(tx.blobVersionedHashes), "invalid blobVersionedHashes: must be an array", "data", data);
8490	for (let i = 0; i < tx.blobVersionedHashes.length; i++) assertArgument(isHexString(tx.blobVersionedHashes[i], 32), `invalid blobVersionedHash at index ${i}: must be length 32`, "data", data);
8491	if (fields.length === 11) return tx;
8492	_parseEipSignature(tx, fields.slice(11));
8493	return tx;
8494}
8495function _serializeEip4844(tx, sig, blobs) {
8496	const fields = [
8497		formatNumber(tx.chainId, "chainId"),
8498		formatNumber(tx.nonce, "nonce"),
8499		formatNumber(tx.maxPriorityFeePerGas || 0, "maxPriorityFeePerGas"),
8500		formatNumber(tx.maxFeePerGas || 0, "maxFeePerGas"),
8501		formatNumber(tx.gasLimit, "gasLimit"),
8502		tx.to || "0x0000000000000000000000000000000000000000",
8503		formatNumber(tx.value, "value"),
8504		tx.data,
8505		formatAccessList(tx.accessList || []),
8506		formatNumber(tx.maxFeePerBlobGas || 0, "maxFeePerBlobGas"),
8507		formatHashes(tx.blobVersionedHashes || [], "blobVersionedHashes")
8508	];
8509	if (sig) {
8510		fields.push(formatNumber(sig.yParity, "yParity"));
8511		fields.push(toBeArray(sig.r));
8512		fields.push(toBeArray(sig.s));
8513		if (blobs) {
8514			if (tx.blobWrapperVersion != null) {
8515				const wrapperVersion = toBeArray(tx.blobWrapperVersion);
8516				const cellProofs = [];
8517				for (const { proof } of blobs) {
8518					const p = getBytes(proof);
8519					const cellSize = p.length / CELL_COUNT;
8520					for (let i = 0; i < p.length; i += cellSize) cellProofs.push(p.subarray(i, i + cellSize));
8521				}
8522				return concat(["0x03", encodeRlp([
8523					fields,
8524					wrapperVersion,
8525					blobs.map((b) => b.data),
8526					blobs.map((b) => b.commitment),
8527					cellProofs
8528				])]);
8529			}
8530			return concat(["0x03", encodeRlp([
8531				fields,
8532				blobs.map((b) => b.data),
8533				blobs.map((b) => b.commitment),
8534				blobs.map((b) => b.proof)
8535			])]);
8536		}
8537	}
8538	return concat(["0x03", encodeRlp(fields)]);
8539}
8540function _parseEip7702(data) {
8541	const fields = decodeRlp(getBytes(data).slice(1));
8542	assertArgument(Array.isArray(fields) && (fields.length === 10 || fields.length === 13), "invalid field count for transaction type: 4", "data", hexlify(data));
8543	const tx = {
8544		type: 4,
8545		chainId: handleUint(fields[0], "chainId"),
8546		nonce: handleNumber(fields[1], "nonce"),
8547		maxPriorityFeePerGas: handleUint(fields[2], "maxPriorityFeePerGas"),
8548		maxFeePerGas: handleUint(fields[3], "maxFeePerGas"),
8549		gasPrice: null,
8550		gasLimit: handleUint(fields[4], "gasLimit"),
8551		to: handleAddress(fields[5]),
8552		value: handleUint(fields[6], "value"),
8553		data: hexlify(fields[7]),
8554		accessList: handleAccessList(fields[8], "accessList"),
8555		authorizationList: handleAuthorizationList(fields[9], "authorizationList")
8556	};
8557	if (fields.length === 10) return tx;
8558	_parseEipSignature(tx, fields.slice(10));
8559	return tx;
8560}
8561function _serializeEip7702(tx, sig) {
8562	const fields = [
8563		formatNumber(tx.chainId, "chainId"),
8564		formatNumber(tx.nonce, "nonce"),
8565		formatNumber(tx.maxPriorityFeePerGas || 0, "maxPriorityFeePerGas"),
8566		formatNumber(tx.maxFeePerGas || 0, "maxFeePerGas"),
8567		formatNumber(tx.gasLimit, "gasLimit"),
8568		tx.to || "0x",
8569		formatNumber(tx.value, "value"),
8570		tx.data,
8571		formatAccessList(tx.accessList || []),
8572		formatAuthorizationList(tx.authorizationList || [])
8573	];
8574	if (sig) {
8575		fields.push(formatNumber(sig.yParity, "yParity"));
8576		fields.push(toBeArray(sig.r));
8577		fields.push(toBeArray(sig.s));
8578	}
8579	return concat(["0x04", encodeRlp(fields)]);
8580}
8581/**
8582*  A **Transaction** describes an operation to be executed on
8583*  Ethereum by an Externally Owned Account (EOA). It includes
8584*  who (the [[to]] address), what (the [[data]]) and how much (the
8585*  [[value]] in ether) the operation should entail.
8586*
8587*  @example:
8588*    tx = new Transaction()
8589*    //_result:
8590*
8591*    tx.data = "0x1234";
8592*    //_result:
8593*/
8594var Transaction = class Transaction {
8595	#type;
8596	#to;
8597	#data;
8598	#nonce;

vendor: 1,952 bytes, lines 8599-8704

8599	#gasLimit;
8600	#gasPrice;
8601	#maxPriorityFeePerGas;
8602	#maxFeePerGas;
8603	#value;
8604	#chainId;
8605	#sig;
8606	#accessList;
8607	#maxFeePerBlobGas;
8608	#blobVersionedHashes;
8609	#kzg;
8610	#blobs;
8611	#auths;
8612	#blobWrapperVersion;
8613	/**
8614	*  The transaction type.
8615	*
8616	*  If null, the type will be automatically inferred based on
8617	*  explicit properties.
8618	*/
8619	get type() {
8620		return this.#type;
8621	}
8622	set type(value) {
8623		switch (value) {
8624			case null:
8625				this.#type = null;
8626				break;
8627			case 0:
8628			case "legacy":
8629				this.#type = 0;
8630				break;
8631			case 1:
8632			case "berlin":
8633			case "eip-2930":
8634				this.#type = 1;
8635				break;
8636			case 2:
8637			case "london":
8638			case "eip-1559":
8639				this.#type = 2;
8640				break;
8641			case 3:
8642			case "cancun":
8643			case "eip-4844":
8644				this.#type = 3;
8645				break;
8646			case 4:
8647			case "pectra":
8648			case "eip-7702":
8649				this.#type = 4;
8650				break;
8651			default: assertArgument(false, "unsupported transaction type", "type", value);
8652		}
8653	}
8654	/**
8655	*  The name of the transaction type.
8656	*/
8657	get typeName() {
8658		switch (this.type) {
8659			case 0: return "legacy";
8660			case 1: return "eip-2930";
8661			case 2: return "eip-1559";
8662			case 3: return "eip-4844";
8663			case 4: return "eip-7702";
8664		}
8665		return null;
8666	}
8667	/**
8668	*  The ``to`` address for the transaction or ``null`` if the
8669	*  transaction is an ``init`` transaction.
8670	*/
8671	get to() {
8672		const value = this.#to;
8673		if (value == null && this.type === 3) return ZeroAddress;
8674		return value;
8675	}
8676	set to(value) {
8677		this.#to = value == null ? null : getAddress(value);
8678	}
8679	/**
8680	*  The transaction nonce.
8681	*/
8682	get nonce() {
8683		return this.#nonce;
8684	}
8685	set nonce(value) {
8686		this.#nonce = getNumber(value, "value");
8687	}
8688	/**
8689	*  The gas limit.
8690	*/
8691	get gasLimit() {
8692		return this.#gasLimit;
8693	}
8694	set gasLimit(value) {
8695		this.#gasLimit = getBigInt(value);
8696	}
8697	/**
8698	*  The gas price.
8699	*
8700	*  On legacy networks this defines the fee that will be paid. On
8701	*  EIP-1559 networks, this should be ``null``.
8702	*/
8703	get gasPrice() {
8704		const value = this.#gasPrice;

8705		if (value == null && (this.type === 0 || this.type === 1)) return BN_0$4;
8706		return value;
8707	}
8708	set gasPrice(value) {
8709		this.#gasPrice = value == null ? null : getBigInt(value, "gasPrice");
8710	}
8711	/**
8712	*  The maximum priority fee per unit of gas to pay. On legacy
8713	*  networks this should be ``null``.
8714	*/
8715	get maxPriorityFeePerGas() {
8716		const value = this.#maxPriorityFeePerGas;
8717		if (value == null) {
8718			if (this.type === 2 || this.type === 3) return BN_0$4;
8719			return null;
8720		}
8721		return value;
8722	}
8723	set maxPriorityFeePerGas(value) {
8724		this.#maxPriorityFeePerGas = value == null ? null : getBigInt(value, "maxPriorityFeePerGas");
8725	}
8726	/**
8727	*  The maximum total fee per unit of gas to pay. On legacy
8728	*  networks this should be ``null``.
8729	*/
8730	get maxFeePerGas() {
8731		const value = this.#maxFeePerGas;
8732		if (value == null) {
8733			if (this.type === 2 || this.type === 3) return BN_0$4;
8734			return null;
8735		}
8736		return value;
8737	}
8738	set maxFeePerGas(value) {
8739		this.#maxFeePerGas = value == null ? null : getBigInt(value, "maxFeePerGas");
8740	}
8741	/**
8742	*  The transaction data. For ``init`` transactions this is the
8743	*  deployment code.
8744	*/
8745	get data() {
8746		return this.#data;
8747	}
8748	set data(value) {
8749		this.#data = hexlify(value);
8750	}
8751	/**
8752	*  The amount of ether (in wei) to send in this transactions.
8753	*/
8754	get value() {
8755		return this.#value;
8756	}
8757	set value(value) {
8758		this.#value = getBigInt(value, "value");
8759	}
8760	/**
8761	*  The chain ID this transaction is valid on.
8762	*/
8763	get chainId() {
8764		return this.#chainId;
8765	}
8766	set chainId(value) {
8767		this.#chainId = getBigInt(value);
8768	}
8769	/**
8770	*  If signed, the signature for this transaction.
8771	*/
8772	get signature() {
8773		return this.#sig || null;
8774	}
8775	set signature(value) {
8776		this.#sig = value == null ? null : Signature.from(value);
8777	}
8778	isValid() {
8779		const sig = this.signature;
8780		if (sig && !sig.isValid()) return false;
8781		const auths = this.authorizationList;
8782		if (auths) {
8783			for (const auth of auths) if (!auth.signature.isValid()) return false;
8784		}
8785		return true;
8786	}
8787	/**
8788	*  The access list.
8789	*
8790	*  An access list permits discounted (but pre-paid) access to
8791	*  bytecode and state variable access within contract execution.
8792	*/
8793	get accessList() {
8794		const value = this.#accessList || null;
8795		if (value == null) {
8796			if (this.type === 1 || this.type === 2 || this.type === 3) return [];
8797			return null;
8798		}
8799		return value;
8800	}
8801	set accessList(value) {
8802		this.#accessList = value == null ? null : accessListify(value);
8803	}
8804	get authorizationList() {
8805		const value = this.#auths || null;
8806		if (value == null) {
8807			if (this.type === 4) return [];
8808		}
8809		return value;
8810	}
8811	set authorizationList(auths) {
8812		this.#auths = auths == null ? null : auths.map((a) => authorizationify(a));
8813	}
8814	/**
8815	*  The max fee per blob gas for Cancun transactions.
8816	*/
8817	get maxFeePerBlobGas() {
8818		const value = this.#maxFeePerBlobGas;
8819		if (value == null && this.type === 3) return BN_0$4;
8820		return value;
8821	}
8822	set maxFeePerBlobGas(value) {
8823		this.#maxFeePerBlobGas = value == null ? null : getBigInt(value, "maxFeePerBlobGas");
8824	}
8825	/**
8826	*  The BLOb versioned hashes for Cancun transactions.
8827	*/
8828	get blobVersionedHashes() {
8829		let value = this.#blobVersionedHashes;
8830		if (value == null && this.type === 3) return [];
8831		return value;
8832	}
8833	set blobVersionedHashes(value) {
8834		if (value != null) {
8835			assertArgument(Array.isArray(value), "blobVersionedHashes must be an Array", "value", value);
8836			value = value.slice();
8837			for (let i = 0; i < value.length; i++) assertArgument(isHexString(value[i], 32), "invalid blobVersionedHash", `value[${i}]`, value[i]);
8838		}
8839		this.#blobVersionedHashes = value;
8840	}
8841	/**
8842	*  The BLObs for the Transaction, if any.
8843	*
8844	*  If ``blobs`` is non-``null``, then the [[seriailized]]
8845	*  will return the network formatted sidecar, otherwise it
8846	*  will return the standard [[link-eip-2718]] payload. The
8847	*  [[unsignedSerialized]] is unaffected regardless.
8848	*
8849	*  When setting ``blobs``, either fully valid [[Blob]] objects
8850	*  may be specified (i.e. correctly padded, with correct
8851	*  committments and proofs) or a raw [[BytesLike]] may
8852	*  be provided.
8853	*
8854	*  If raw [[BytesLike]] are provided, the [[kzg]] property **must**
8855	*  be already set. The blob will be correctly padded and the
8856	*  [[KzgLibrary]] will be used to compute the committment and
8857	*  proof for the blob.
8858	*
8859	*  A BLOb is a sequence of field elements, each of which must
8860	*  be within the BLS field modulo, so some additional processing
8861	*  may be required to encode arbitrary data to ensure each 32 byte
8862	*  field is within the valid range.
8863	*
8864	*  Setting this automatically populates [[blobVersionedHashes]],
8865	*  overwriting any existing values. Setting this to ``null``
8866	*  does **not** remove the [[blobVersionedHashes]], leaving them
8867	*  present.
8868	*/
8869	get blobs() {
8870		if (this.#blobs == null) return null;
8871		return this.#blobs.map((b) => Object.assign({}, b));
8872	}
8873	set blobs(_blobs) {
8874		if (_blobs == null) {
8875			this.#blobs = null;
8876			return;
8877		}
8878		const blobs = [];
8879		const versionedHashes = [];
8880		for (let i = 0; i < _blobs.length; i++) {
8881			const blob = _blobs[i];
8882			if (isBytesLike(blob)) {
8883				assert(this.#kzg, "adding a raw blob requires a KZG library", "UNSUPPORTED_OPERATION", { operation: "set blobs()" });
8884				let data = getBytes(blob);
8885				assertArgument(data.length <= BLOB_SIZE, "blob is too large", `blobs[${i}]`, blob);
8886				if (data.length !== BLOB_SIZE) {
8887					const padded = new Uint8Array(BLOB_SIZE);
8888					padded.set(data);
8889					data = padded;
8890				}
8891				const commit = this.#kzg.blobToKzgCommitment(data);
8892				const proof = hexlify(this.#kzg.computeBlobKzgProof(data, commit));
8893				blobs.push({
8894					data: hexlify(data),
8895					commitment: hexlify(commit),
8896					proof
8897				});
8898				versionedHashes.push(getVersionedHash(1, commit));
8899			} else {
8900				const data = hexlify(blob.data);
8901				const commitment = hexlify(blob.commitment);
8902				const proof = hexlify(blob.proof);
8903				blobs.push({
8904					data,
8905					commitment,
8906					proof
8907				});
8908				versionedHashes.push(getVersionedHash(1, commitment));
8909			}
8910		}
8911		this.#blobs = blobs;
8912		this.#blobVersionedHashes = versionedHashes;
8913	}
8914	get kzg() {
8915		return this.#kzg;
8916	}
8917	set kzg(kzg) {
8918		if (kzg == null) this.#kzg = null;
8919		else this.#kzg = getKzgLibrary(kzg);
8920	}
8921	get blobWrapperVersion() {
8922		return this.#blobWrapperVersion;
8923	}
8924	set blobWrapperVersion(value) {
8925		this.#blobWrapperVersion = value;
8926	}

8927	/**
8928	*  Creates a new Transaction with default values.
8929	*/
8930	constructor() {
8931		this.#type = null;
8932		this.#to = null;
8933		this.#nonce = 0;
8934		this.#gasLimit = BN_0$4;
8935		this.#gasPrice = null;
8936		this.#maxPriorityFeePerGas = null;
8937		this.#maxFeePerGas = null;
8938		this.#data = "0x";
8939		this.#value = BN_0$4;
8940		this.#chainId = BN_0$4;
8941		this.#sig = null;
8942		this.#accessList = null;
8943		this.#maxFeePerBlobGas = null;
8944		this.#blobVersionedHashes = null;
8945		this.#kzg = null;
8946		this.#blobs = null;
8947		this.#auths = null;
8948		this.#blobWrapperVersion = null;
8949	}
8950	/**
8951	*  The transaction hash, if signed. Otherwise, ``null``.
8952	*/
8953	get hash() {
8954		if (this.signature == null) return null;
8955		return keccak256(this.#getSerialized(true, false));
8956	}
8957	/**
8958	*  The pre-image hash of this transaction.
8959	*
8960	*  This is the digest that a [[Signer]] must sign to authorize
8961	*  this transaction.
8962	*/
8963	get unsignedHash() {
8964		return keccak256(this.unsignedSerialized);
8965	}
8966	/**
8967	*  The sending address, if signed. Otherwise, ``null``.
8968	*/
8969	get from() {
8970		if (this.signature == null) return null;
8971		return recoverAddress(this.unsignedHash, this.signature.getCanonical());
8972	}
8973	/**
8974	*  The public key of the sender, if signed. Otherwise, ``null``.
8975	*/
8976	get fromPublicKey() {
8977		if (this.signature == null) return null;
8978		return SigningKey.recoverPublicKey(this.unsignedHash, this.signature.getCanonical());
8979	}
8980	/**
8981	*  Returns true if signed.
8982	*
8983	*  This provides a Type Guard that properties requiring a signed
8984	*  transaction are non-null.
8985	*/
8986	isSigned() {
8987		return this.signature != null;
8988	}
8989	#getSerialized(signed, sidecar) {
8990		assert(!signed || this.signature != null, "cannot serialize unsigned transaction; maybe you meant .unsignedSerialized", "UNSUPPORTED_OPERATION", { operation: ".serialized" });
8991		const sig = signed ? this.signature : null;
8992		switch (this.inferType()) {
8993			case 0: return _serializeLegacy(this, sig);
8994			case 1: return _serializeEip2930(this, sig);
8995			case 2: return _serializeEip1559(this, sig);
8996			case 3: return _serializeEip4844(this, sig, sidecar ? this.blobs : null);
8997			case 4: return _serializeEip7702(this, sig);
8998		}
8999		assert(false, "unsupported transaction type", "UNSUPPORTED_OPERATION", { operation: ".serialized" });
9000	}
9001	/**
9002	*  The serialized transaction.
9003	*
9004	*  This throws if the transaction is unsigned. For the pre-image,
9005	*  use [[unsignedSerialized]].
9006	*/
9007	get serialized() {
9008		return this.#getSerialized(true, true);
9009	}
9010	/**
9011	*  The transaction pre-image.
9012	*
9013	*  The hash of this is the digest which needs to be signed to
9014	*  authorize this transaction.
9015	*/
9016	get unsignedSerialized() {
9017		return this.#getSerialized(false, false);
9018	}
9019	/**
9020	*  Return the most "likely" type; currently the highest
9021	*  supported transaction type.
9022	*/
9023	inferType() {
9024		const types = this.inferTypes();
9025		if (types.indexOf(2) >= 0) return 2;
9026		return types.pop();
9027	}
9028	/**
9029	*  Validates the explicit properties and returns a list of compatible
9030	*  transaction types.
9031	*/
9032	inferTypes() {
9033		const hasGasPrice = this.gasPrice != null;
9034		const hasFee = this.maxFeePerGas != null || this.maxPriorityFeePerGas != null;
9035		const hasAccessList = this.accessList != null;
9036		const hasBlob = this.#maxFeePerBlobGas != null || this.#blobVersionedHashes;
9037		if (this.maxFeePerGas != null && this.maxPriorityFeePerGas != null) assert(this.maxFeePerGas >= this.maxPriorityFeePerGas, "priorityFee cannot be more than maxFee", "BAD_DATA", { value: this });
9038		assert(!hasFee || this.type !== 0 && this.type !== 1, "transaction type cannot have maxFeePerGas or maxPriorityFeePerGas", "BAD_DATA", { value: this });
9039		assert(this.type !== 0 || !hasAccessList, "legacy transaction cannot have accessList", "BAD_DATA", { value: this });
9040		const types = [];
9041		if (this.type != null) types.push(this.type);
9042		else if (this.authorizationList && this.authorizationList.length) types.push(4);
9043		else if (hasFee) types.push(2);
9044		else if (hasGasPrice) {
9045			types.push(1);
9046			if (!hasAccessList) types.push(0);
9047		} else if (hasAccessList) {
9048			types.push(1);
9049			types.push(2);
9050		} else if (hasBlob && this.to) types.push(3);
9051		else {
9052			types.push(0);
9053			types.push(1);
9054			types.push(2);
9055			types.push(3);
9056		}
9057		types.sort();
9058		return types;
9059	}
9060	/**
9061	*  Returns true if this transaction is a legacy transaction (i.e.
9062	*  ``type === 0``).
9063	*
9064	*  This provides a Type Guard that the related properties are
9065	*  non-null.
9066	*/
9067	isLegacy() {
9068		return this.type === 0;
9069	}
9070	/**
9071	*  Returns true if this transaction is berlin hardform transaction (i.e.
9072	*  ``type === 1``).
9073	*
9074	*  This provides a Type Guard that the related properties are
9075	*  non-null.
9076	*/
9077	isBerlin() {
9078		return this.type === 1;
9079	}
9080	/**
9081	*  Returns true if this transaction is london hardform transaction (i.e.
9082	*  ``type === 2``).
9083	*
9084	*  This provides a Type Guard that the related properties are
9085	*  non-null.
9086	*/
9087	isLondon() {
9088		return this.type === 2;
9089	}

9090	/**
9091	*  Returns true if this transaction is an [[link-eip-4844]] BLOB
9092	*  transaction.
9093	*
9094	*  This provides a Type Guard that the related properties are
9095	*  non-null.
9096	*/
9097	isCancun() {
9098		return this.type === 3;
9099	}
9100	/**
9101	*  Create a copy of this transaciton.
9102	*/
9103	clone() {
9104		return Transaction.from(this);
9105	}
9106	/**
9107	*  Return a JSON-friendly object.
9108	*/
9109	toJSON() {
9110		const s = (v) => {
9111			if (v == null) return null;
9112			return v.toString();
9113		};
9114		return {
9115			type: this.type,
9116			to: this.to,
9117			data: this.data,
9118			nonce: this.nonce,
9119			gasLimit: s(this.gasLimit),
9120			gasPrice: s(this.gasPrice),
9121			maxPriorityFeePerGas: s(this.maxPriorityFeePerGas),
9122			maxFeePerGas: s(this.maxFeePerGas),
9123			value: s(this.value),
9124			chainId: s(this.chainId),
9125			sig: this.signature ? this.signature.toJSON() : null,
9126			accessList: this.accessList
9127		};
9128	}
9129	[inspect$2]() {
9130		return this.toString();
9131	}
9132	toString() {
9133		const output = [];
9134		const add = (key) => {
9135			let value = this[key];
9136			if (typeof value === "string") value = JSON.stringify(value);
9137			output.push(`${key}: ${value}`);
9138		};
9139		if (this.type) add("type");
9140		add("to");
9141		add("data");
9142		add("nonce");
9143		add("gasLimit");
9144		add("value");
9145		if (this.chainId != null) add("chainId");
9146		if (this.signature) {
9147			add("from");
9148			output.push(`signature: ${this.signature.toString()}`);
9149		}
9150		const auths = this.authorizationList;
9151		if (auths) {
9152			const outputAuths = [];
9153			for (const auth of auths) {
9154				const o = [];
9155				o.push(`address: ${JSON.stringify(auth.address)}`);
9156				if (auth.nonce != null) o.push(`nonce: ${auth.nonce}`);
9157				if (auth.chainId != null) o.push(`chainId: ${auth.chainId}`);
9158				if (auth.signature) o.push(`signature: ${auth.signature.toString()}`);
9159				outputAuths.push(`Authorization { ${o.join(", ")} }`);
9160			}
9161			output.push(`authorizations: [ ${outputAuths.join(", ")} ]`);
9162		}
9163		return `Transaction { ${output.join(", ")} }`;
9164	}
9165	/**
9166	*  Create a **Transaction** from a serialized transaction or a
9167	*  Transaction-like object.
9168	*/
9169	static from(tx) {
9170		if (tx == null) return new Transaction();
9171		if (typeof tx === "string") {
9172			const payload = getBytes(tx);
9173			if (payload[0] >= 127) return Transaction.from(_parseLegacy(payload));
9174			switch (payload[0]) {
9175				case 1: return Transaction.from(_parseEip2930(payload));
9176				case 2: return Transaction.from(_parseEip1559(payload));
9177				case 3: return Transaction.from(_parseEip4844(payload));
9178				case 4: return Transaction.from(_parseEip7702(payload));
9179			}
9180			assert(false, "unsupported transaction type", "UNSUPPORTED_OPERATION", { operation: "from" });
9181		}
9182		const result = new Transaction();
9183		if (tx.type != null) result.type = tx.type;
9184		if (tx.to != null) result.to = tx.to;
9185		if (tx.nonce != null) result.nonce = tx.nonce;
9186		if (tx.gasLimit != null) result.gasLimit = tx.gasLimit;
9187		if (tx.gasPrice != null) result.gasPrice = tx.gasPrice;
9188		if (tx.maxPriorityFeePerGas != null) result.maxPriorityFeePerGas = tx.maxPriorityFeePerGas;
9189		if (tx.maxFeePerGas != null) result.maxFeePerGas = tx.maxFeePerGas;
9190		if (tx.maxFeePerBlobGas != null) result.maxFeePerBlobGas = tx.maxFeePerBlobGas;
9191		if (tx.data != null) result.data = tx.data;
9192		if (tx.value != null) result.value = tx.value;
9193		if (tx.chainId != null) result.chainId = tx.chainId;
9194		if (tx.signature != null) result.signature = Signature.from(tx.signature);
9195		if (tx.accessList != null) result.accessList = tx.accessList;
9196		if (tx.authorizationList != null) result.authorizationList = tx.authorizationList;
9197		if (tx.blobVersionedHashes != null) result.blobVersionedHashes = tx.blobVersionedHashes;
9198		if (tx.kzg != null) result.kzg = tx.kzg;
9199		if (tx.blobWrapperVersion != null) result.blobWrapperVersion = tx.blobWrapperVersion;
9200		if (tx.blobs != null) result.blobs = tx.blobs;
9201		if (tx.hash != null) {
9202			assertArgument(result.isSigned(), "unsigned transaction cannot define '.hash'", "tx", tx);
9203			assertArgument(result.hash === tx.hash, "hash mismatch", "tx", tx);
9204		}
9205		if (tx.from != null) {
9206			assertArgument(result.isSigned(), "unsigned transaction cannot define '.from'", "tx", tx);
9207			assertArgument(result.from.toLowerCase() === (tx.from || "").toLowerCase(), "from mismatch", "tx", tx);
9208		}
9209		return result;
9210	}
9211};
9212//#endregion
9213//#region node_modules/ethers/lib.esm/hash/authorization.js
9214/**
9215*  Computes the [[link-eip-7702]] authorization digest to sign.
9216*/
9217function hashAuthorization(auth) {
9218	assertArgument(typeof auth.address === "string", "invalid address for hashAuthorization", "auth.address", auth);
9219	return keccak256(concat(["0x05", encodeRlp([
9220		auth.chainId != null ? toBeArray(auth.chainId) : "0x",
9221		getAddress(auth.address),
9222		auth.nonce != null ? toBeArray(auth.nonce) : "0x"

9223	])]));
9224}
9225/**
9226*  Return the address of the private key that produced
9227*  the signature %%sig%% during signing for %%message%%.
9228*/
9229function verifyAuthorization(auth, sig) {
9230	return recoverAddress(hashAuthorization(auth), sig);
9231}
9232//#endregion
9233//#region node_modules/ethers/lib.esm/hash/id.js
9234/**
9235*  A simple hashing function which operates on UTF-8 strings to
9236*  compute an 32-byte identifier.
9237*
9238*  This simply computes the [UTF-8 bytes](toUtf8Bytes) and computes
9239*  the [[keccak256]].
9240*
9241*  @example:
9242*    id("hello world")
9243*    //_result:
9244*/
9245function id(value) {
9246	return keccak256(toUtf8Bytes(value));
9247}
9248//#endregion
9249//#region node_modules/@adraffy/ens-normalize/dist/index.mjs
9250var COMPRESSED$1 = "

vendor: 20,100 bytes, line 9250

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

9250";
9251var FENCED = /* @__PURE__ */ new Map([
9252	[8217, "apostrophe"],
9253	[8260, "fraction slash"],
9254	[12539, "middle dot"]
9255]);
9256var NSM_MAX = 4;
9257function decode_arithmetic(bytes) {
9258	let pos = 0;
9259	function u16() {
9260		return bytes[pos++] << 8 | bytes[pos++];
9261	}
9262	let symbol_count = u16();
9263	let total = 1;
9264	let acc = [0, 1];
9265	for (let i = 1; i < symbol_count; i++) acc.push(total += u16());
9266	let skip = u16();
9267	let pos_payload = pos;
9268	pos += skip;
9269	let read_width = 0;
9270	let read_buffer = 0;
9271	function read_bit() {
9272		if (read_width == 0) {
9273			read_buffer = read_buffer << 8 | bytes[pos++];
9274			read_width = 8;
9275		}
9276		return read_buffer >> --read_width & 1;
9277	}
9278	const N = 31;
9279	const FULL = 2 ** N;
9280	const HALF = FULL >>> 1;
9281	const QRTR = HALF >> 1;
9282	const MASK = FULL - 1;
9283	let register = 0;
9284	for (let i = 0; i < N; i++) register = register << 1 | read_bit();
9285	let symbols = [];
9286	let low = 0;
9287	let range = FULL;
9288	while (true) {
9289		let value = Math.floor(((register - low + 1) * total - 1) / range);
9290		let start = 0;
9291		let end = symbol_count;
9292		while (end - start > 1) {
9293			let mid = start + end >>> 1;
9294			if (value < acc[mid]) end = mid;
9295			else start = mid;
9296		}
9297		if (start == 0) break;
9298		symbols.push(start);
9299		let a = low + Math.floor(range * acc[start] / total);
9300		let b = low + Math.floor(range * acc[start + 1] / total) - 1;
9301		while (((a ^ b) & HALF) == 0) {
9302			register = register << 1 & MASK | read_bit();
9303			a = a << 1 & MASK;
9304			b = b << 1 & MASK | 1;
9305		}
9306		while (a & ~b & QRTR) {
9307			register = register & HALF | register << 1 & MASK >>> 1 | read_bit();
9308			a = a << 1 ^ HALF;
9309			b = (b ^ HALF) << 1 | HALF | 1;
9310		}
9311		low = a;
9312		range = 1 + b - a;
9313	}
9314	let offset = symbol_count - 4;
9315	return symbols.map((x) => {
9316		switch (x - offset) {
9317			case 3: return offset + 65792 + (bytes[pos_payload++] << 16 | bytes[pos_payload++] << 8 | bytes[pos_payload++]);
9318			case 2: return offset + 256 + (bytes[pos_payload++] << 8 | bytes[pos_payload++]);
9319			case 1: return offset + bytes[pos_payload++];
9320			default: return x - 1;
9321		}
9322	});
9323}
9324function read_payload(v) {
9325	let pos = 0;
9326	return () => v[pos++];
9327}
9328function read_compressed_payload(s) {
9329	return read_payload(decode_arithmetic(unsafe_atob(s)));
9330}
9331function unsafe_atob(s) {
9332	let lookup = [];
9333	[..."ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"].forEach((c, i) => lookup[c.charCodeAt(0)] = i);
9334	let n = s.length;
9335	let ret = new Uint8Array(6 * n >> 3);
9336	for (let i = 0, pos = 0, width = 0, carry = 0; i < n; i++) {
9337		carry = carry << 6 | lookup[s.charCodeAt(i)];
9338		width += 6;
9339		if (width >= 8) ret[pos++] = carry >> (width -= 8);
9340	}
9341	return ret;
9342}
9343function signed(i) {
9344	return i & 1 ? ~i >> 1 : i >> 1;
9345}
9346function read_deltas(n, next) {
9347	let v = Array(n);
9348	for (let i = 0, x = 0; i < n; i++) v[i] = x += signed(next());
9349	return v;
9350}
9351function read_sorted(next, prev = 0) {
9352	let ret = [];
9353	while (true) {
9354		let x = next();
9355		let n = next();
9356		if (!n) break;
9357		prev += x;
9358		for (let i = 0; i < n; i++) ret.push(prev + i);
9359		prev += n + 1;
9360	}
9361	return ret;
9362}
9363function read_sorted_arrays(next) {
9364	return read_array_while(() => {
9365		let v = read_sorted(next);
9366		if (v.length) return v;
9367	});
9368}
9369function read_mapped(next) {
9370	let ret = [];
9371	while (true) {
9372		let w = next();
9373		if (w == 0) break;
9374		ret.push(read_linear_table(w, next));
9375	}
9376	while (true) {
9377		let w = next() - 1;
9378		if (w < 0) break;
9379		ret.push(read_replacement_table(w, next));
9380	}
9381	return ret.flat();
9382}
9383function read_array_while(next) {
9384	let v = [];
9385	while (true) {
9386		let x = next(v.length);
9387		if (!x) break;
9388		v.push(x);
9389	}
9390	return v;
9391}
9392function read_transposed(n, w, next) {
9393	let m = Array(n).fill().map(() => []);
9394	for (let i = 0; i < w; i++) read_deltas(n, next).forEach((x, j) => m[j].push(x));
9395	return m;
9396}
9397function read_linear_table(w, next) {
9398	let dx = 1 + next();
9399	let dy = next();
9400	let vN = read_array_while(next);
9401	return read_transposed(vN.length, 1 + w, next).flatMap((v, i) => {
9402		let [x, ...ys] = v;
9403		return Array(vN[i]).fill().map((_, j) => {
9404			let j_dy = j * dy;
9405			return [x + j * dx, ys.map((y) => y + j_dy)];
9406		});
9407	});
9408}
9409function read_replacement_table(w, next) {
9410	return read_transposed(1 + next(), 1 + w, next).map((v) => [v[0], v.slice(1)]);
9411}
9412function read_trie(next) {
9413	let ret = [];
9414	let sorted = read_sorted(next);
9415	expand(decode([]), []);
9416	return ret;
9417	function decode(Q) {
9418		return {
9419			S: next(),
9420			B: read_array_while(() => {
9421				let cps = read_sorted(next).map((i) => sorted[i]);
9422				if (cps.length) return decode(cps);
9423			}),
9424			Q
9425		};
9426	}
9427	function expand({ S, B }, cps, saved) {
9428		if (S & 4 && saved === cps[cps.length - 1]) return;
9429		if (S & 2) saved = cps[cps.length - 1];
9430		if (S & 1) ret.push(cps);
9431		for (let br of B) for (let cp of br.Q) expand(br, [...cps, cp], saved);
9432	}
9433}
9434function hex_cp(cp) {
9435	return cp.toString(16).toUpperCase().padStart(2, "0");
9436}
9437function quote_cp(cp) {
9438	return `{${hex_cp(cp)}}`;
9439}
9440function explode_cp(s) {
9441	let cps = [];
9442	for (let pos = 0, len = s.length; pos < len;) {
9443		let cp = s.codePointAt(pos);
9444		pos += cp < 65536 ? 1 : 2;
9445		cps.push(cp);
9446	}
9447	return cps;
9448}
9449function str_from_cps(cps) {
9450	const chunk = 4096;
9451	let len = cps.length;
9452	if (len < chunk) return String.fromCodePoint(...cps);
9453	let buf = [];
9454	for (let i = 0; i < len;) buf.push(String.fromCodePoint(...cps.slice(i, i += chunk)));
9455	return buf.join("");
9456}
9457function compare_arrays(a, b) {
9458	let n = a.length;
9459	let c = n - b.length;
9460	for (let i = 0; c == 0 && i < n; i++) c = a[i] - b[i];
9461	return c;
9462}
9463var COMPRESSED = "AEUDWAHSCGYATwDVADIAdgAiADQAFAAtABQAIQAPACcADQASAAsAGQAJABIACQARAAUACwAFAAwABQAQAAMABwAEAAoABQAJAAIACgABAAQAFAALAAIACwABAAIAAQAHAAMAAwAEAAsADAAMAAwACwANAA0AAwAKAAkABAAdAAYAZwDTAecDNACxCmIB8xhZAqfoC190UGcThgBurwf7PT09Pb09AjgJum8OjDllxHYUKXAPxzq6tABAxgK8ysUvWAgMPT09PT09PSs6LT2HcgWXWwFLoSMEEEl5RFVMKvO0XQ8ExDdJMnIgPi89uj00MsvBXxEPAGPCDwBnQKoEbwRwBHEEcgRzBHQEdQR2BHcEeAR6BHsEfAR+BIAEgfndBQoBYgULAWIFDAFiBNcE2ATZBRAFEQUvBdALFAsVDPcNBw13DYcOMA4xDjMB4BllHI0B2grbAMDpHLkQ7QHVAPRNQQFnGRUEg0yEB2uaJEMAJpIBpob5A

9463ERSMAKNoAXqaQLRBMCzEiC+AZ4EWRJJFbEu7QDQLARtEbgECxDwAb/RyAk1AV4nD2cEQQKTAzsAGpobPgAahAGPCrysdy0OAKwAfFIcBAQFUmoA/PtZADkBIadVj2UMUgx5Il4ANQC9vLIBDAHUGVsQ8wCzfQIbGVcCHBZHAZ8CBAgXOhG7AqMZ4M7+1M0UAPDNAWsC+mcJDe8AAQA99zkEXLICyQozAo6lAobcP5JvjQLFzwKD9gU/OD8FEQCtEQL6bW+nAKUEvzjDHsuRyUvOFHcacUz5AqIFRSE2kzsBEQCuaQL5DQTlcgO6twSpTiUgCwIFCAUXBHQEqQV6swAVxUlmTmsCwjqsP/wKJQmXb793UgZBEBsnpRD3DDMBtQE7De1L2ATxBjsEyR99GRkPzZWcCKUt3QztJuMuoYBaI/UqgwXtS/Q83QtNUWgPWQtlCeM6Y4FOAyEBDSKLCt0NOQhtEPMKyWsN5RFFBzkD1UmaAKUHAQsRHTUVtSYQYqwLCTl3Bvsa9guPJq8TKXr8BdMaIQZNASka/wDPLueFsFoxXBxPXwYDCyUjxxSoUCANJUC3eEgaGwcVJakCkUNwSodRNh6TIfY8PQ1mLhNRfAf1PAUZTwuBPJ5Gq0UOEdI+jT1IIklMLAQ1fywvJ4sJzw+FDLl8cgFZCSEJsQxxEzERFzfFCDkHGS2XJCcVCCFGlWCaBPefA/MT0QMLBT8JQQcTA7UcLRMuFSkFDYEk1wLzNtUuswKPVoABFwXLDyUf3xBQR+AO6QibAmUDgyXrAC0VIQAXIpsIQ2MAX4/YUwUuywjHamwjdANnFOdhEXMHkQ5XB6ccMxW/HOFwyF4Lhggoo68JWwF1CZkBXwTjCAk1W4ygIEFnU4tYGJsgYUE/XfwCMQxlFZ9EvYd4AosPaxIbATUBcwc5DQECdxHtEWsQlQjrhgQ1tTP4OiUETyGDIBEKJwNPbM4LJyb5DPhpAaMSYgMMND137merYLYkF/0HGTLFQWAh8QuST80MnBrBGEJULhnkB78D8xrzJ+pBVwX/A6MDEzpNM+4EvQtpCIsJPwBJDqMXB9cYagpxjNABMYsBt5kDV5GDAm+PBjcHCwBnC4cFeeUAHQKnCKMABQDPA1cAOQKtB50AGQCFQQE9AycvASHlAo8DkwgxywGVLwHzKQQbwwwVAPc3bkoCw7ECgGpmogXdWAKOAkk1AU0lBAVOR1EDr3HhANsASwYT30cBFatKyxrjQwHfbysAxwD7AAU1BwVBAc0B820AtwFfCzEJorO1AU3pKQCDABVrAdcCiQDdADUAf/EBUwBNBVn5BdMCT0kBETEYK1dhAbsDHwEzAQ0AeQbLjaXJBx8EbQfTAhAbFeEC7y4HtQEDIt8TzULFAr3eVaFgAmSBAmJCW02vWzcgAqH3AmiYAmYJAp+EOBsLAmY7AmYmBG4EfwN/EwN+kjkGOXcXOYI6IyMCbB0CMjY4CgJtxwJtru+KM2dFKwFnAN4A4QBKBQeYDI0A/gvCAA21AncvAnaiPwJ5S0MCeLodXNtFrkbXAnw/AnrIAn0JAnzwBVkFIEgASH1jJAKBbQKAAAKABQJ/rklYSlsVF0rMAtEBAtDMSycDiE8Dh+ZExZEyAvKhXQMDA65LzkwtJQPPTUxNrwKLPwKK2MEbBx1DZwW3Ao43Ao5cQJeBAo7ZAo5ceFG0UzUKUtRUhQKT+wKTDADpABxVHlWvVdAGLBsplYYy4XhmRTs5ApefAu+yWCGoAFklApaPApZ8nACpWaxaCYFNADsClrUClk5cRFzRApnLAplkXMpdBxkCnJs5wjqdApwWAp+bAp64igAdDzEqDwKd8QKekgC1PWE0Ye8CntMCoG4BqQKenx8Cnk6lY8hkJyUrAievAiZ+AqD7AqBMAqLdAqHEAqYvAqXOAqf/AH0Cp/JofGixAANJahxq0QKs4wKsrgKtZwKtAgJXHQJV3AKx4dcDH05slwKyvQ0CsugXbOBtY21IXwMlzQK2XDs/bpADKUUCuF4CuUcVArkqd3A2cOECvRkCu9pwlgMyEQK+iHICAzNxAr4acyJzTwLDywLDBHOCdEs1RXTgAzynAzyaAz2/AsV8AsZHAsYQiQLIaVECyEQCyU8CyS4CZJ0C3dJ4eWF4rnklS9ADGKNnAgJh9BnzlSR7C16SXrsRAs9rAs9sL0tT0vMTnwDGrQLPcwEp6gNOEn5LBQLcJwLbigLSTwNSXANTXwEBA1WMgIk/AMsW7WBFghyC04LOg40C2scC2d6EEIRJpzwDhqUALwNkDoZxWfkAVQLfZQLeuHN3AuIv7RQB8zAnAfSbAfLShwLr8wLpcHkC6vkC6uQA+UcBuQLuiQLrnJaqlwMC7j8DheCYeXDgcaEC8wMAaQOOFpmTAvcTA5FuA5KHAveYAvnZAvhmmhyaq7s3mx4DnYMC/voBGwA5nxyfswMFjQOmagOm2QDRxQMGaqGIogUJAwxJAtQAPwMA4UEXUwER8wNrB5dnBQCTLSu3r73bAYmZFH8RBDkB+ykFIQ6dCZ8Akv0TtRQrxQL3LScApQC3BbmOkRc/xqdtQS4UJo0uAUMBgPwBtSYAdQMOBG0ALAIWDKEAAAoCPQJqA90DfgSRASBFBSF8CgAFAEQAEwA2EgJ3AQAF1QNr7wrFAgD3Cp8nv7G35QGRIUFCAekUfxE0wIkABAAbAFoCRQKEiwAGOlM6lI1tALg6jzrQAI04wTrcAKUA6ADLATqBOjs5/Dn5O3aJOls7nok6bzkYAVYBMwFsBS81XTWeNa01ZjV1NbY1xTWCNZE10jXhNZ41rTXuNf01sjXBNgI2ETXGNdU2FjYnNd417TYuNj02LjUtITY6Nj02PDbJNwgEkDxXNjg23TcgNw82yiA3iTcwCgSwPGc2JDcZN2w6jTchQtRDB0LgQwscDw8JmyhtKFFVBgDpfwDpsAD+mxQ91wLpNSMArQC9BbeOkRdLxptzBL8MDAMMAQgDAAkKCwsLCQoGBAVVBI/DvwDz9b29kaUCb0QtsRTNLt4eGBcSHAMZFhYZEhYEARAEBUEcQRxBHEEcQRxBHEEaQRxBHEFCSTxBPElISUhBNkM2QTYbNklISVmBVIgELgEaJZkC7aMAoQCjBcGOmxdNxrsBvwGJAaQcEZ0ePCklMAAhMvAIMAL54gC7Bm8EescjzQMpARQpKgDUHqSvAj5Gqwr7YrMUACT9AN3rpF27H7fsd/twPt4l+UW1yQYKBt2Cgy7qJpGiLcdE2P1cQSImUbqJ6ICH27H4knQMIRMrFkHu3sx6tC35Y+eLIh4e4CMKJ4DfyV+8mfta499RCAJ0xfeZR8PsoYOApva9pjGn4PhvyZS7/h5JLuhaucfjuU+Z584wwqNO4hWYmaBCcjgQPale1bjoHzMUbut/zTgxHxBnAyrdKpF4IRMASLBtD/jviyLeCgj8twWjAd3HchN/uqaeRYeHJgl7JEY9/cTrvtfybx/r3Y/NtxJ9dp+MTVmiS9bwBH73s8Di56/Ma+mTPMHq4T1yEG1fWcqr0u+hrGnJEvU1JJAm/maQSrKrazIyvSkDFkj8UUlfBq8baniTGPng6YZRL661rDNw4w/1g2figG0IhXnL7wosd/sVNo5dYSmMBTP5c7rYLjRdCwg8quwljOMPf63D8ICAL0r71XRiyFHdgwHbwfgnPOf4Lzjf2v+j+IiDHG2isp5yUnzSDyDRb4i/Vs0qHSHq8PiEQ/JnBP7PxnjN0j6gT4AVAeRx/1o9VnEUlUwvFrzJqHk9jxAw4sYxCnrxaeBdCFFKbnE7z+x54F5W7ZZsU6kx8Qocul6FoAHHy01FGL/nne61mn4+uYXfQ1Uccn+HMLKE+cZzT8BB1E3FRskOgJrRsq25rauLm8+uamXpkS/bTy6y1wDbCrW4eD532kTWrtNUmVVZOIn/C+/JR9KVR5iG9TY8iaT67ubm/whL1xbKZoqtY+a6fNxMJrg211bGYJDUkYMNWA0BMB++9zOm6Eik4roqs9CCEFW0lyAK0PbvlzvoxrZuY/OEhNW/l/63U15Od/RSvmDvXpGLiVmeGi5PDSH2bYz5o2g6wFDQ2FbZgYgTF8rPlvA1ifjZD3NLtFdXdpSIJvgKR7GpjJWG7GZGawPomIH8B5tUmtHH9LpM+/KQKunEPa1GiQkCXv4Cnm9DLORo2joicHdPDZ64obQrPZ5bgqckkj0G6/NEiPYBY4bCkL7W8G5YzsUb6GakFjykSPkT7JGeLeB6uJOGMm+x7N381BCDfbJFx0dtLgV9Q477BfL1fvitX5anV/oYfxeYl+eF5x5bB8+Ep/L2nsmd56aKF4aAD4GbJWsdKyBW22xEmAD3XdbtsMyAFoR5mOla0gEd9U/YVB7zvHGpHbQonay9Sv0bQ8iZ8piaXVrKc5AG1AmqqgaEvzHSP2Wux7aZTWh6quVDVU01JtMIVRdCFwlSbbqqhoFlyzsotQzRexFvZ/MqUSFu3OhRIuNBbufvBpdVgb8XdGJ48/lJPCZ7dsOujTTbKPSEvGXkOnG2Xdi8/nM3EMRqITd5QeU7iOjKqC7URJY6TnLsHij22xAHKnVRD5MDtBYnoGFqZGMDmXCW6Oj+BAWw14hESY/xLF6bLku06AHkiXTHPCFZ0f9YSqqo27eAhhS67OrA2Het4M9JM3jm/yRX6bYxnfmzYl5qQdHxN08FsNuWDrWd4vMUY2QD3hr8vS73SCTkFoXZR3xNzOQt8d/6HfjBmXqvrE6EGkLzK6YK2U2/ksU/iUH+LvVIsJI+ri2AL/klo+ShdDyfs5A83i2prkMs51IKR7ZcqjZJi5X3+bd8GlyWvtddxKEoEqSgEO7A8jIgf2nH0h8FjM7oB6yte3X5mpL0i/E4Rx0CotKnILJj/vJqo4VkPQ93jRtRVfaitQPqldl5xRYPq8387Z0DcnZvOeION0Ht1+P27kFLGQIcLBX4FG3sffccNHh5cPfzp9INoRtqVtdViJfg8RjnXiIz/MNqEN6zvzX3hMzyWC7oSoXIT14ubc0abPX8Rp9GVa5NI/8iv+6ela1oTncbdimRKnrbRffDR/X4nH+bgqAuHWl7hOaeXPWVzIeRl7ga+JzD4Sx3mlj/q6Ra/E2HhDf21eEzTLNGfCZsY+/yxZzQzIAuijG65ii4O/waAJCrEJaWd/DRAKMQ5678Dw5AT7RCKzdadIwd8LsD+DgPBASmWsUlf8R0k1w/2k4lO2Wpb4zMI6EJVJs0xk/wn8/fRUPqrDKhbjHR41SqgFMx5RGMPuduFwlu5lK89tW11sTqiX/5EfGs5nO+y9FKvgXKPOEmgE05EKNL6Sjb3xS40H3BVPhm0ESOZgAjZoymc8be0inDVo4JdJVf+NKd3tN/CaB7GShhH27qf95NoFZVX/6ZkR2lX+CgWrQ2INgkh+bbMz68+uJ3Clsh8HSMPEQtAt+BBE6fXDab7KIlsKxU1lIXW/KWVstpdPanJ0pdXpQinDyUQjtY7ZVcfiecRxRDMAUhHFU2cEaciQ+htiPMPx1kdvtWG9T44w3r037ljHBFJdYR0r55qvMRixtAEFJAqA4T1ES87FAx7UozXasytg8MftZYt0rjYgLe6EJ5aWvy2qscBSBQ7yehoJIA3wIIZ9ukfkyBb6qnue5ko8W50rpV4kXqWjI5nbGRXrNW0tBZHXlY48nSgcUXBHWT4GcgLZJoLlKJnV96kCYpq9eWHh7xJzkCAyrQuQ5AJ0qq/uZ3toJglNterev+Qm0KXxPg/+YbFRJdfhbp1wOnVOEYdVHTya6CtO0afhEaBhx3oHwCb5Kq6RwHDzFMl2vfjL8GwzcCoTj7wZe+UFnYDV2yKpPU9dba29gYBdNqJg/KXozO+CJTlKmlKhnqTf5doeS35DZFV+cYJQVjd+oVY/Gtc/6XPzUxb1gMqf6cEjNNoRC8AObrp+fx0cVtGu4ffC2TgXRC8zPl8moUHCB5HZ25d87mlsiiK0aNwBtcEQjRNBT/QrXbw/8aVXdKMHn9EqYEKEyxSGTpYQOaes1G1Qq8pDgqkZtlO2HRyCXpmeM7TSrRPkAh004BfisVpF6zP44n2Jvxz/gOVocNCyy9V6lkod28QM4pbaMvVJigD/w3BrsjSJrXlqc4ulBYOCceiBN4b/gHajYyupbhEt63a619Ay4wsL6a6w6B+A7TnoyE7BliWHJfzVxxIKM/W3M/J8Bx99Op863Q8eNuIMGRx++VbYfjm+VGYBA3Ap/KEu/wxBNBpJJncwHPG45V8Gh98ZIrGCc20MwijGowZbcS7d1nEgcOW5cddZpHL2XPAIRbColiheZzXTvBxZOY3iMSDSKDrICyJ/iQs1vdplVdH/JrLJsQ2jtTnfCrITIghq3KFX3qAgLWAIp8IffNSdTYptnbGfc8s+qcr3zyzyHp1aJg+jxTF4kD1ry5Wauv5V3xnOGwTFecNzXSLHBW20/pCQjk4uorD0plIhMSTc79+/r4RKPClRYTBYex1Ob5crtfvRQBBv6re/6FhtCqtduag67glqRA77/3ulblh9YRtMdDxkCyJDeNnAuCLPQFmdRRWJtH20Z8DstfJf+5oj5SSB64d0iF5/Ya4KfTWxfivj9Ap2/zbYaTo/1gO3tM6RYsCZharMBFr7Fm61mLSrQnEI4OF1gbVS4k/JE9UotOrnLJZuswoWodCSV8zbybkJSVIP7n8UaE9xCR39rJZmf27HOAPVOGc9pdkQUcRrI0qyVF9Z3j1RHDbxIfwbWzmPVjwIdPJvtmBYwEQIUsIW1S939hcVikK00ozPRI02cqhzVUNzpOxVdrwRPvlh1aIOf0xFEqD3YkGnCnFah/cFN3J2gB7N+bZSGawwkKFu1tpQMrp1W+27YNkyT0TpcFpTqgOqqLabrgcCUPxh97mREOGy4xItzQ9xSl6rq+8BZsHcrQFReS+QeMxJ3P6CnL9EP/eOLDjumLhvrcQrpPiknsofbzBv9gTP0lU+TIVwE6E7CcKfT36q+ZiEOHJ9ayf0dyUJLezAb2M8aNHwd0+OJmsVgTzRWA";
9464var S0 = 44032;
9465var L0 = 4352;
9466var V0 = 4449;
9467var T0 = 4519;
9468var T_COUNT = 28;
9469var N_COUNT = 588;
9470var S1 = 55204;
9471var L1 = 4371;
9472var V1 = 4470;
9473var T1$1 = 4547;
9474function unpack_cc(packed) {
9475	return packed >> 24 & 255;
9476}
9477function unpack_cp(packed) {
9478	return packed & 16777215;
9479}
9480var SHIFTED_RANK;
9481var EXCLUSIONS;
9482var DECOMP;
9483var RECOMP;
9484function init$1() {
9485	let r = read_compressed_payload(COMPRESSED);
9486	SHIFTED_RANK = new Map(read_sorted_arrays(r).flatMap((v, i) => v.map((x) => [x, i + 1 << 24])));
9487	EXCLUSIONS = new Set(read_sorted(r));
9488	DECOMP = /* @__PURE__ */ new Map();
9489	RECOMP = /* @__PURE__ */ new Map();
9490	for (let [cp, cps] of read_mapped(r)) {
9491		if (!EXCLUSIONS.has(cp) && cps.length == 2) {
9492			let [a, b] = cps;
9493			let bucket = RECOMP.get(a);
9494			if (!bucket) {
9495				bucket = /* @__PURE__ */ new Map();
9496				RECOMP.set(a, bucket);
9497			}
9498			bucket.set(b, cp);
9499		}
9500		DECOMP.set(cp, cps.reverse());
9501	}
9502}
9503function is_hangul(cp) {
9504	return cp >= S0 && cp < S1;
9505}
9506function compose_pair(a, b) {
9507	if (a >= L0 && a < L1 && b >= V0 && b < V1) return S0 + (a - L0) * N_COUNT + (b - V0) * T_COUNT;
9508	else if (is_hangul(a) && b > T0 && b < T1$1 && (a - S0) % T_COUNT == 0) return a + (b - T0);
9509	else {
9510		let recomp = RECOMP.get(a);
9511		if (recomp) {
9512			recomp = recomp.get(b);
9513			if (recomp) return recomp;
9514		}
9515		return -1;
9516	}
9517}
9518function decomposed(cps) {
9519	if (!SHIFTED_RANK) init$1();
9520	let ret = [];
9521	let buf = [];
9522	let check_order = false;

9523	function add(cp) {
9524		let cc = SHIFTED_RANK.get(cp);
9525		if (cc) {
9526			check_order = true;
9527			cp |= cc;
9528		}
9529		ret.push(cp);
9530	}
9531	for (let cp of cps) while (true) {
9532		if (cp < 128) ret.push(cp);
9533		else if (is_hangul(cp)) {
9534			let s_index = cp - S0;
9535			let l_index = s_index / N_COUNT | 0;
9536			let v_index = s_index % N_COUNT / T_COUNT | 0;
9537			let t_index = s_index % T_COUNT;
9538			add(L0 + l_index);
9539			add(V0 + v_index);
9540			if (t_index > 0) add(T0 + t_index);
9541		} else {
9542			let mapped = DECOMP.get(cp);
9543			if (mapped) buf.push(...mapped);
9544			else add(cp);
9545		}
9546		if (!buf.length) break;
9547		cp = buf.pop();
9548	}
9549	if (check_order && ret.length > 1) {
9550		let prev_cc = unpack_cc(ret[0]);
9551		for (let i = 1; i < ret.length; i++) {
9552			let cc = unpack_cc(ret[i]);
9553			if (cc == 0 || prev_cc <= cc) {
9554				prev_cc = cc;
9555				continue;
9556			}
9557			let j = i - 1;
9558			while (true) {
9559				let tmp = ret[j + 1];
9560				ret[j + 1] = ret[j];
9561				ret[j] = tmp;
9562				if (!j) break;
9563				prev_cc = unpack_cc(ret[--j]);
9564				if (prev_cc <= cc) break;
9565			}
9566			prev_cc = unpack_cc(ret[i]);
9567		}
9568	}
9569	return ret;
9570}
9571function composed_from_decomposed(v) {
9572	let ret = [];
9573	let stack = [];
9574	let prev_cp = -1;
9575	let prev_cc = 0;
9576	for (let packed of v) {
9577		let cc = unpack_cc(packed);
9578		let cp = unpack_cp(packed);
9579		if (prev_cp == -1) {
9580			if (cc == 0) prev_cp = cp;
9581			else ret.push(cp);
9582		} else if (prev_cc > 0 && prev_cc >= cc) {
9583			if (cc == 0) {
9584				ret.push(prev_cp, ...stack);
9585				stack.length = 0;
9586				prev_cp = cp;
9587			} else stack.push(cp);
9588			prev_cc = cc;
9589		} else {
9590			let composed = compose_pair(prev_cp, cp);
9591			if (composed >= 0) prev_cp = composed;
9592			else if (prev_cc == 0 && cc == 0) {
9593				ret.push(prev_cp);
9594				prev_cp = cp;
9595			} else {
9596				stack.push(cp);
9597				prev_cc = cc;
9598			}
9599		}
9600	}
9601	if (prev_cp >= 0) ret.push(prev_cp, ...stack);
9602	return ret;
9603}
9604function nfd(cps) {
9605	return decomposed(cps).map(unpack_cp);
9606}
9607function nfc(cps) {
9608	return composed_from_decomposed(decomposed(cps));
9609}
9610var HYPHEN = 45;
9611var STOP_CH = ".";
9612var FE0F = 65039;
9613var UNIQUE_PH = 1;
9614var Array_from = (x) => Array.from(x);
9615function group_has_cp(g, cp) {
9616	return g.P.has(cp) || g.Q.has(cp);
9617}
9618var Emoji = class extends Array {
9619	get is_emoji() {
9620		return true;
9621	}
9622};
9623var MAPPED;
9624var IGNORED;
9625var CM;
9626var NSM;
9627var ESCAPE;
9628var GROUPS;
9629var WHOLE_VALID;
9630var WHOLE_MAP;
9631var VALID;
9632var EMOJI_LIST;
9633var EMOJI_ROOT;
9634function init() {
9635	if (MAPPED) return;
9636	let r = read_compressed_payload(COMPRESSED$1);
9637	const read_sorted_array = () => read_sorted(r);
9638	const read_sorted_set = () => new Set(read_sorted_array());
9639	const set_add_many = (set, v) => v.forEach((x) => set.add(x));
9640	MAPPED = new Map(read_mapped(r));
9641	IGNORED = read_sorted_set();
9642	CM = read_sorted_array();
9643	NSM = new Set(read_sorted_array().map((i) => CM[i]));
9644	CM = new Set(CM);
9645	ESCAPE = read_sorted_set();
9646	read_sorted_set();
9647	let chunks = read_sorted_arrays(r);
9648	let unrestricted = r();
9649	const read_chunked = () => {
9650		let set = /* @__PURE__ */ new Set();
9651		read_sorted_array().forEach((i) => set_add_many(set, chunks[i]));
9652		set_add_many(set, read_sorted_array());
9653		return set;
9654	};
9655	GROUPS = read_array_while((i) => {
9656		let N = read_array_while(r).map((x) => x + 96);
9657		if (N.length) {
9658			let R = i >= unrestricted;
9659			N[0] -= 32;
9660			N = str_from_cps(N);
9661			if (R) N = `Restricted[${N}]`;
9662			let P = read_chunked();
9663			let Q = read_chunked();
9664			let M = !r();
9665			return {
9666				N,
9667				P,
9668				Q,
9669				M,
9670				R
9671			};
9672		}
9673	});
9674	WHOLE_VALID = read_sorted_set();
9675	WHOLE_MAP = /* @__PURE__ */ new Map();
9676	let wholes = read_sorted_array().concat(Array_from(WHOLE_VALID)).sort((a, b) => a - b);
9677	wholes.forEach((cp, i) => {
9678		let d = r();
9679		let w = wholes[i] = d ? wholes[i - d] : {
9680			V: [],
9681			M: /* @__PURE__ */ new Map()
9682		};
9683		w.V.push(cp);
9684		if (!WHOLE_VALID.has(cp)) WHOLE_MAP.set(cp, w);
9685	});
9686	for (let { V, M } of new Set(WHOLE_MAP.values())) {
9687		let recs = [];
9688		for (let cp of V) {
9689			let gs = GROUPS.filter((g) => group_has_cp(g, cp));
9690			let rec = recs.find(({ G }) => gs.some((g) => G.has(g)));
9691			if (!rec) {
9692				rec = {
9693					G: /* @__PURE__ */ new Set(),
9694					V: []
9695				};
9696				recs.push(rec);
9697			}
9698			rec.V.push(cp);

9699			set_add_many(rec.G, gs);
9700		}
9701		let union = recs.flatMap((x) => Array_from(x.G));
9702		for (let { G, V } of recs) {
9703			let complement = new Set(union.filter((g) => !G.has(g)));
9704			for (let cp of V) M.set(cp, complement);
9705		}
9706	}
9707	VALID = /* @__PURE__ */ new Set();
9708	let multi = /* @__PURE__ */ new Set();
9709	const add_to_union = (cp) => VALID.has(cp) ? multi.add(cp) : VALID.add(cp);
9710	for (let g of GROUPS) {
9711		for (let cp of g.P) add_to_union(cp);
9712		for (let cp of g.Q) add_to_union(cp);
9713	}
9714	for (let cp of VALID) if (!WHOLE_MAP.has(cp) && !multi.has(cp)) WHOLE_MAP.set(cp, UNIQUE_PH);
9715	set_add_many(VALID, nfd(VALID));
9716	EMOJI_LIST = read_trie(r).map((v) => Emoji.from(v)).sort(compare_arrays);
9717	EMOJI_ROOT = /* @__PURE__ */ new Map();
9718	for (let cps of EMOJI_LIST) {
9719		let prev = [EMOJI_ROOT];
9720		for (let cp of cps) {
9721			let next = prev.map((node) => {
9722				let child = node.get(cp);
9723				if (!child) {
9724					child = /* @__PURE__ */ new Map();
9725					node.set(cp, child);
9726				}
9727				return child;
9728			});
9729			if (cp === FE0F) prev.push(...next);
9730			else prev = next;
9731		}
9732		for (let x of prev) x.V = cps;
9733	}
9734}
9735function quoted_cp(cp) {
9736	return (should_escape(cp) ? "" : `${bidi_qq(safe_str_from_cps([cp]))} `) + quote_cp(cp);
9737}
9738function bidi_qq(s) {
9739	return `"${s}"\u200E`;
9740}
9741function check_label_extension(cps) {
9742	if (cps.length >= 4 && cps[2] == HYPHEN && cps[3] == HYPHEN) throw new Error(`invalid label extension: "${str_from_cps(cps.slice(0, 4))}"`);
9743}
9744function check_leading_underscore(cps) {
9745	const UNDERSCORE = 95;
9746	for (let i = cps.lastIndexOf(UNDERSCORE); i > 0;) if (cps[--i] !== UNDERSCORE) throw new Error("underscore allowed only at start");
9747}
9748function check_fenced(cps) {
9749	let cp = cps[0];
9750	let prev = FENCED.get(cp);
9751	if (prev) throw error_placement(`leading ${prev}`);
9752	let n = cps.length;
9753	let last = -1;
9754	for (let i = 1; i < n; i++) {
9755		cp = cps[i];
9756		let match = FENCED.get(cp);
9757		if (match) {
9758			if (last == i) throw error_placement(`${prev} + ${match}`);
9759			last = i + 1;
9760			prev = match;
9761		}
9762	}
9763	if (last == n) throw error_placement(`trailing ${prev}`);
9764}
9765function safe_str_from_cps(cps, max = Infinity, quoter = quote_cp) {
9766	let buf = [];
9767	if (is_combining_mark(cps[0])) buf.push("◌");
9768	if (cps.length > max) {
9769		max >>= 1;
9770		cps = [
9771			...cps.slice(0, max),
9772			8230,
9773			...cps.slice(-max)
9774		];
9775	}
9776	let prev = 0;
9777	let n = cps.length;
9778	for (let i = 0; i < n; i++) {
9779		let cp = cps[i];
9780		if (should_escape(cp)) {
9781			buf.push(str_from_cps(cps.slice(prev, i)));
9782			buf.push(quoter(cp));
9783			prev = i + 1;
9784		}
9785	}
9786	buf.push(str_from_cps(cps.slice(prev, n)));
9787	return buf.join("");
9788}
9789function is_combining_mark(cp, only_nsm) {
9790	init();
9791	return only_nsm ? NSM.has(cp) : CM.has(cp);
9792}
9793function should_escape(cp) {
9794	init();
9795	return ESCAPE.has(cp);
9796}
9797function ens_normalize(name) {
9798	return flatten(split(name, nfc, filter_fe0f));
9799}
9800function split(name, nf, ef) {
9801	if (!name) return [];
9802	init();
9803	let offset = 0;
9804	return name.split(STOP_CH).map((label) => {
9805		let input = explode_cp(label);
9806		let info = {
9807			input,
9808			offset
9809		};
9810		offset += input.length + 1;
9811		try {
9812			let tokens = info.tokens = tokens_from_str(input, nf, ef);
9813			let token_count = tokens.length;
9814			let type;
9815			if (!token_count) throw new Error(`empty label`);
9816			let norm = info.output = tokens.flat();
9817			check_leading_underscore(norm);
9818			if (!(info.emoji = token_count > 1 || tokens[0].is_emoji) && norm.every((cp) => cp < 128)) {
9819				check_label_extension(norm);
9820				type = "ASCII";
9821			} else {
9822				let chars = tokens.flatMap((x) => x.is_emoji ? [] : x);
9823				if (!chars.length) type = "Emoji";
9824				else {
9825					if (CM.has(norm[0])) throw error_placement("leading combining mark");
9826					for (let i = 1; i < token_count; i++) {
9827						let cps = tokens[i];
9828						if (!cps.is_emoji && CM.has(cps[0])) throw error_placement(`emoji + comb

9828ining mark: "${str_from_cps(tokens[i - 1])} + ${safe_str_from_cps([cps[0]])}"`);
9829					}
9830					check_fenced(norm);
9831					let unique = Array_from(new Set(chars));
9832					let [g] = determine_group(unique);
9833					check_group(g, chars);
9834					check_whole(g, unique);
9835					type = g.N;
9836				}
9837			}
9838			info.type = type;
9839		} catch (err) {
9840			info.error = err;
9841		}
9842		return info;
9843	});
9844}
9845function check_whole(group, unique) {
9846	let maker;
9847	let shared = [];
9848	for (let cp of unique) {
9849		let whole = WHOLE_MAP.get(cp);
9850		if (whole === UNIQUE_PH) return;
9851		if (whole) {
9852			let set = whole.M.get(cp);
9853			maker = maker ? maker.filter((g) => set.has(g)) : Array_from(set);
9854			if (!maker.length) return;
9855		} else shared.push(cp);
9856	}
9857	if (maker) {
9858		for (let g of maker) if (shared.every((cp) => group_has_cp(g, cp))) throw new Error(`whole-script confusable: ${group.N}/${g.N}`);
9859	}
9860}
9861function determine_group(unique) {
9862	let groups = GROUPS;
9863	for (let cp of unique) {
9864		let gs = groups.filter((g) => group_has_cp(g, cp));
9865		if (!gs.length) {
9866			if (!GROUPS.some((g) => group_has_cp(g, cp))) throw error_disallowed(cp);
9867			else throw error_group_member(groups[0], cp);
9868		}
9869		groups = gs;
9870		if (gs.length == 1) break;
9871	}
9872	return groups;
9873}
9874function flatten(split) {
9875	return split.map(({ input, error, output }) => {
9876		if (error) {
9877			let msg = error.message;
9878			throw new Error(split.length == 1 ? msg : `Invalid label ${bidi_qq(safe_str_from_cps(input, 63))}: ${msg}`);
9879		}
9880		return str_from_cps(output);
9881	}).join(STOP_CH);
9882}
9883function error_disallowed(cp) {
9884	return /* @__PURE__ */ new Error(`disallowed character: ${quoted_cp(cp)}`);
9885}
9886function error_group_member(g, cp) {
9887	let quoted = quoted_cp(cp);
9888	let gg = GROUPS.find((g) => g.P.has(cp));
9889	if (gg) quoted = `${gg.N} ${quoted}`;
9890	return /* @__PURE__ */ new Error(`illegal mixture: ${g.N} + ${quoted}`);
9891}
9892function error_placement(where) {
9893	return /* @__PURE__ */ new Error(`illegal placement: ${where}`);
9894}
9895function check_group(g, cps) {
9896	for (let cp of cps) if (!group_has_cp(g, cp)) throw error_group_member(g, cp);
9897	if (g.M) {
9898		let decomposed = nfd(cps);
9899		for (let i = 1, e = decomposed.length; i < e; i++) if (NSM.has(decomposed[i])) {
9900			let j = i + 1;
9901			for (let cp; j < e && NSM.has(cp = decomposed[j]); j++) for (let k = i; k < j; k++) if (decomposed[k] == cp) throw new Error(`duplicate non-spacing marks: ${quoted_cp(cp)}`);
9902			if (j - i > NSM_MAX) throw new Error(`excessive non-spacing marks: ${bidi_qq(safe_str_from_cps(decomposed.slice(i - 1, j)))} (${j - i}/${NSM_MAX})`);
9903			i = j;
9904		}
9905	}
9906}
9907function tokens_from_str(input, nf, ef) {
9908	let ret = [];
9909	let chars = [];
9910	input = input.slice().reverse();
9911	while (input.length) {
9912		let emoji = consume_emoji_reversed(input);
9913		if (emoji) {
9914			if (chars.length) {
9915				ret.push(nf(chars));
9916				chars = [];
9917			}
9918			ret.push(ef(emoji));
9919		} else {
9920			let cp = input.pop();
9921			if (VALID.has(cp)) chars.push(cp);
9922			else {
9923				let cps = MAPPED.get(cp);
9924				if (cps) chars.push(...cps);
9925				else if (!IGNORED.has(cp)) throw error_disallowed(cp);
9926			}
9927		}
9928	}
9929	if (chars.length) ret.push(nf(chars));
9930	return ret;
9931}
9932function filter_fe0f(cps) {
9933	return cps.filter((cp) => cp != FE0F);
9934}
9935function consume_emoji_reversed(cps, eaten) {
9936	let node = EMOJI_ROOT;
9937	let emoji;
9938	let pos = cps.length;
9939	while (pos) {
9940		node = node.get(cps[--pos]);
9941		if (!node) break;
9942		let { V } = node;
9943		if (V) {
9944			emoji = V;
9945			if (eaten) eaten.push(...cps.slice(pos).reverse());
9946			cps.length = pos;
9947		}
9948	}
9949	return emoji;
9950}
9951//#endregion
9952//#region node_modules/ethers/lib.esm/hash/namehash.js
9953var Zeros = /* @__PURE__ */ new Uint8Array(32);
9954Zeros.fill(0);
9955function checkComponent(comp) {
9956	assertArgument(comp.length !== 0, "invalid ENS name; empty component", "comp", comp);
9957	return comp;
9958}
9959function ensNameSplit(name) {
9960	const bytes = toUtf8Bytes(ensNormalize(name));
9961	const comps = [];
9962	if (name.length === 0) return comps;
9963	let last = 0;
9964	for (let i = 0; i < bytes.length; i++) if (bytes[i] === 46) {
9965		comps.push(checkComponent(bytes.slice(last, i)));
9966		last = i + 1;
9967	}
9968	assertArgument(last < bytes.length, "invalid ENS name; empty component", "name", name);
9969	comps.push(checkComponent(bytes.slice(last)));
9970	return comps;
9971}
9972/**
9973*  Returns the ENS %%name%% normalized.
9974*/
9975function ensNormalize(name) {
9976	try {
9977		if (name.length === 0) throw new Error("empty label");
9978		return ens_normalize(name);
9979	} catch (error) {
9980		assertArgument(false, `invalid ENS name (${error.message})`, "name", name);
9981	}
9982}
9983/**
9984*  Returns ``true`` if %%name%% is a valid ENS name.
9985*/
9986function isValidName(name) {
9987	try {
9988		return ensNameSplit(name).length !== 0;
9989	} catch (error) {}
9990	return false;

9991}
9992/**
9993*  Returns the [[link-namehash]] for %%name%%.
9994*/
9995function namehash(name) {
9996	assertArgument(typeof name === "string", "invalid ENS name; not a string", "name", name);
9997	assertArgument(name.length, `invalid ENS name (empty label)`, "name", name);
9998	let result = Zeros;
9999	const comps = ensNameSplit(name);
10000	while (comps.length) result = keccak256(concat([result, keccak256(comps.pop())]));
10001	return hexlify(result);
10002}
10003/**
10004*  Returns the DNS encoded %%name%%.
10005*
10006*  This is used for various parts of ENS name resolution, such
10007*  as the wildcard resolution.
10008*/
10009function dnsEncode(name, _maxLength) {
10010	const length = _maxLength != null ? _maxLength : 63;
10011	assertArgument(length <= 255, "DNS encoded label cannot exceed 255", "length", length);
10012	return hexlify(concat(ensNameSplit(name).map((comp) => {
10013		assertArgument(comp.length <= length, `label ${JSON.stringify(name)} exceeds ${length} bytes`, "name", name);
10014		const bytes = new Uint8Array(comp.length + 1);
10015		bytes.set(comp, 1);
10016		bytes[0] = bytes.length - 1;
10017		return bytes;
10018	}))) + "00";
10019}
10020//#endregion
10021//#region node_modules/ethers/lib.esm/hash/message.js
10022/**
10023*  Computes the [[link-eip-191]] personal-sign message digest to sign.
10024*
10025*  This prefixes the message with [[MessagePrefix]] and the decimal length
10026*  of %%message%% and computes the [[keccak256]] digest.
10027*
10028*  If %%message%% is a string, it is converted to its UTF-8 bytes
10029*  first. To compute the digest of a [[DataHexString]], it must be converted
10030*  to [bytes](getBytes).
10031*
10032*  @example:
10033*    hashMessage("Hello World")
10034*    //_result:
10035*
10036*    // Hashes the SIX (6) string characters, i.e.
10037*    // [ "0", "x", "4", "2", "4", "3" ]
10038*    hashMessage("0x4243")
10039*    //_result:
10040*
10041*    // Hashes the TWO (2) bytes [ 0x42, 0x43 ]...
10042*    hashMessage(getBytes("0x4243"))
10043*    //_result:
10044*
10045*    // ...which is equal to using data
10046*    hashMessage(new Uint8Array([ 0x42, 0x43 ]))
10047*    //_result:
10048*
10049*/
10050function hashMessage(message) {
10051	if (typeof message === "string") message = toUtf8Bytes(message);
10052	return keccak256(concat([
10053		toUtf8Bytes(MessagePrefix),
10054		toUtf8Bytes(String(message.length)),
10055		message
10056	]));
10057}
10058/**
10059*  Return the address of the private key that produced
10060*  the signature %%sig%% during signing for %%message%%.
10061*/
10062function verifyMessage(message, sig) {
10063	return recoverAddress(hashMessage(message), sig);
10064}
10065//#endregion
10066//#region node_modules/ethers/lib.esm/hash/solidity.js
10067var regexBytes = /* @__PURE__ */ new RegExp("^bytes([0-9]+)$");
10068var regexNumber = /* @__PURE__ */ new RegExp("^(u?int)([0-9]*)$");
10069var regexArray = /* @__PURE__ */ new RegExp("^(.*)\\[([0-9]*)\\]$");
10070function _pack(type, value, isArray) {
10071	switch (type) {
10072		case "address":
10073			if (isArray) return getBytes(zeroPadValue(value, 32));
10074			return getBytes(getAddress(value));
10075		case "string": return toUtf8Bytes(value);
10076		case "bytes": return getBytes(value);
10077		case "bool":
10078			value = !!value ? "0x01" : "0x00";
10079			if (isArray) return getBytes(zeroPadValue(value, 32));
10080			return getBytes(value);
10081	}
10082	let match = type.match(regexNumber);
10083	if (match) {
10084		let signed = match[1] === "int";
10085		let size = parseInt(match[2] || "256");
10086		assertArgument((!match[2] || match[2] === String(size)) && size % 8 === 0 && size !== 0 && size <= 256, "invalid number type", "type", type);
10087		if (isArray) size = 256;
10088		if (signed) value = toTwos(value, size);
10089		return getBytes(zeroPadValue(toBeArray(value), size / 8));
10090	}
10091	match = type.match(regexBytes);
10092	if (match) {
10093		const size = parseInt(match[1]);
10094		assertArgument(String(size) === match[1] && size !== 0 && size <= 32, "invalid bytes type", "type", type);
10095		assertArgument(dataLength(value) === size, `invalid value for ${type}`, "value", value);
10096		if (isArray) return getBytes(zeroPadBytes(value, 32));
10097		return value;
10098	}
10099	match = type.match(regexArray);
10100	if (match && Array.isArray(value)) {
10101		const baseType = match[1];
10102		assertArgument(parseInt(match[2] || String(value.length)) === value.length, `invalid array length for ${type}`, "value", value);
10103		const result = [];
10104		value.forEach(function(value) {
10105			result.push(_pack(baseType, value, true));
10106		});
10107		return getBytes(concat(result));
10108	}
10109	assertArgument(false, "invalid type", "type", type);
10110}
10111/**
10112*   Computes the [[link-solc-packed]] representation of %%values%%
10113*   respectively to their %%types%%.
10114*
10115*   @example:
10116*       addr = "0x8ba1f109551bd432803012645ac136ddd64dba72"
10117*       solidityPacked([ "address", "uint" ], [ addr, 45 ]);
10118*       //_result:
10119*/
10120function solidityPacked(types, values) {
10121	assertArgument(types.length === values.length, "wrong number of values; expected ${ types.length }", "values", values);
10122	const tight = [];

10123	types.forEach(function(type, index) {
10124		tight.push(_pack(type, values[index]));
10125	});
10126	return hexlify(concat(tight));
10127}
10128/**
10129*   Computes the [[link-solc-packed]] [[keccak256]] hash of %%values%%
10130*   respectively to their %%types%%.
10131*
10132*   @example:
10133*       addr = "0x8ba1f109551bd432803012645ac136ddd64dba72"
10134*       solidityPackedKeccak256([ "address", "uint" ], [ addr, 45 ]);
10135*       //_result:
10136*/
10137function solidityPackedKeccak256(types, values) {
10138	return keccak256(solidityPacked(types, values));
10139}
10140/**
10141*   Computes the [[link-solc-packed]] [[sha256]] hash of %%values%%
10142*   respectively to their %%types%%.
10143*
10144*   @example:
10145*       addr = "0x8ba1f109551bd432803012645ac136ddd64dba72"
10146*       solidityPackedSha256([ "address", "uint" ], [ addr, 45 ]);
10147*       //_result:
10148*/
10149function solidityPackedSha256(types, values) {
10150	return sha256(solidityPacked(types, values));
10151}
10152//#endregion
10153//#region node_modules/ethers/lib.esm/hash/typed-data.js
10154var padding = /* @__PURE__ */ new Uint8Array(32);
10155padding.fill(0);
10156var BN__1 = BigInt(-1);
10157var BN_0$3 = BigInt(0);
10158var BN_1$1 = BigInt(1);
10159var BN_MAX_UINT256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
10160function hexPadRight(value) {
10161	const bytes = getBytes(value);
10162	const padOffset = bytes.length % 32;
10163	if (padOffset) return concat([bytes, padding.slice(padOffset)]);
10164	return hexlify(bytes);
10165}
10166var hexTrue = toBeHex(BN_1$1, 32);
10167var hexFalse = toBeHex(BN_0$3, 32);
10168var domainFieldTypes = {
10169	name: "string",
10170	version: "string",
10171	chainId: "uint256",
10172	verifyingContract: "address",
10173	salt: "bytes32"
10174};
10175var domainFieldNames = [
10176	"name",
10177	"version",
10178	"chainId",
10179	"verifyingContract",
10180	"salt"
10181];
10182function checkString(key) {
10183	return function(value) {
10184		assertArgument(typeof value === "string", `invalid domain value for ${JSON.stringify(key)}`, `domain.${key}`, value);
10185		return value;
10186	};
10187}
10188var domainChecks = {
10189	name: checkString("name"),
10190	version: checkString("version"),

10191	chainId: function(_value) {
10192		const value = getBigInt(_value, "domain.chainId");
10193		assertArgument(value >= 0, "invalid chain ID", "domain.chainId", _value);
10194		if (Number.isSafeInteger(value)) return Number(value);
10195		return toQuantity(value);
10196	},
10197	verifyingContract: function(value) {
10198		try {
10199			return getAddress(value).toLowerCase();
10200		} catch (error) {}
10201		assertArgument(false, `invalid domain value "verifyingContract"`, "domain.verifyingContract", value);
10202	},
10203	salt: function(value) {
10204		const bytes = getBytes(value, "domain.salt");
10205		assertArgument(bytes.length === 32, `invalid domain value "salt"`, "domain.salt", value);
10206		return hexlify(bytes);
10207	}
10208};
10209function getBaseEncoder(type) {
10210	{
10211		const match = type.match(/^(u?)int(\d+)$/);
10212		if (match) {
10213			const signed = match[1] === "";
10214			const width = parseInt(match[2]);
10215			assertArgument(width % 8 === 0 && width !== 0 && width <= 256 && match[2] === String(width), "invalid numeric width", "type", type);
10216			const boundsUpper = mask(BN_MAX_UINT256, signed ? width - 1 : width);
10217			const boundsLower = signed ? (boundsUpper + BN_1$1) * BN__1 : BN_0$3;
10218			return function(_value) {
10219				const value = getBigInt(_value, "value");
10220				assertArgument(value >= boundsLower && value <= boundsUpper, `value out-of-bounds for ${type}`, "value", value);
10221				return toBeHex(signed ? toTwos(value, 256) : value, 32);
10222			};
10223		}
10224	}
10225	{
10226		const match = type.match(/^bytes(\d+)$/);
10227		if (match) {
10228			const width = parseInt(match[1]);
10229			assertArgument(width !== 0 && width <= 32 && match[1] === String(width), "invalid bytes width", "type", type);
10230			return function(value) {
10231				assertArgument(getBytes(value).length === width, `invalid length for ${type}`, "value", value);
10232				return hexPadRight(value);
10233			};
10234		}
10235	}
10236	switch (type) {
10237		case "address": return function(value) {
10238			return zeroPadValue(getAddress(value), 32);
10239		};
10240		case "bool": return function(value) {
10241			return !value ? hexFalse : hexTrue;
10242		};
10243		case "bytes": return function(value) {
10244			return keccak256(value);
10245		};
10246		case "string": return function(value) {
10247			return id(value);
10248		};
10249	}
10250	return null;
10251}
10252function encodeType(name, fields) {
10253	return `${name}(${fields.map(({ name, type }) => type + " " + name).join(",")})`;
10254}
10255function splitArray(type) {
10256	const match = type.match(/^([^\x5b]*)((\x5b\d*\x5d)*)(\x5b(\d*)\x5d)$/);
10257	if (match) return {
10258		base: match[1],
10259		index: match[2] + match[4],
10260		array: {
10261			base: match[1],
10262			prefix: match[1] + match[2],
10263			count: match[5] ? parseInt(match[5]) : -1
10264		}
10265	};
10266	return { base: type };
10267}
10268/**
10269*  A **TypedDataEncode** prepares and encodes [[link-eip-712]] payloads
10270*  for signed typed data.
10271*
10272*  This is useful for those that wish to compute various components of a
10273*  typed data hash, primary types, or sub-components, but generally the
10274*  higher level [[Signer-signTypedData]] is more useful.
10275*/
10276var TypedDataEncoder = class TypedDataEncoder {
10277	/**
10278	*  The primary type for the structured [[types]].
10279	*
10280	*  This is derived automatically from the [[types]], since no
10281	*  recursion is possible, once the DAG for the types is consturcted
10282	*  internally, the primary type must be the only remaining type with
10283	*  no parent nodes.
10284	*/
10285	primaryType;
10286	#types;
10287	/**
10288	*  The types.
10289	*/
10290	get types() {
10291		return JSON.parse(this.#types);
10292	}
10293	#fullTypes;
10294	#encoderCache;
10295	/**
10296	*  Create a new **TypedDataEncoder** for %%types%%.
10297	*
10298	*  This performs all necessary checking that types are valid and
10299	*  do not violate the [[link-eip-712]] structural constraints as
10300	*  well as computes the [[primaryType]].
10301	*/
10302	constructor(_types) {
10303		this.#fullTypes = /* @__PURE__ */ new Map();
10304		this.#encoderCache = /* @__PURE__ */ new Map();
10305		const links = /* @__PURE__ */ new Map();
10306		const parents = /* @__PURE__ */ new Map();
10307		const subtypes = /* @__PURE__ */ new Map();
10308		const types = {};
10309		Object.keys(_types).forEach((type) => {
10310			types[type] = _types[type].map(({ name, type }) => {
10311				let { base, index } = splitArray(type);
10312				if (base === "int" && !_types["int"]) base = "int256";
10313				if (base === "uint" && !_types["uint"]) base = "uint256";
10314				return {
10315					name,
10316					type: base + (index || "")
10317				};
10318			});

vendor: 4,133 bytes, lines 10319-10438

10319			links.set(type, /* @__PURE__ */ new Set());
10320			parents.set(type, []);
10321			subtypes.set(type, /* @__PURE__ */ new Set());
10322		});
10323		this.#types = JSON.stringify(types);
10324		for (const name in types) {
10325			const uniqueNames = /* @__PURE__ */ new Set();
10326			for (const field of types[name]) {
10327				assertArgument(!uniqueNames.has(field.name), `duplicate variable name ${JSON.stringify(field.name)} in ${JSON.stringify(name)}`, "types", _types);
10328				uniqueNames.add(field.name);
10329				const baseType = splitArray(field.type).base;
10330				assertArgument(baseType !== name, `circular type reference to ${JSON.stringify(baseType)}`, "types", _types);
10331				if (getBaseEncoder(baseType)) continue;
10332				assertArgument(parents.has(baseType), `unknown type ${JSON.stringify(baseType)}`, "types", _types);
10333				parents.get(baseType).push(name);
10334				links.get(name).add(baseType);
10335			}
10336		}
10337		const primaryTypes = Array.from(parents.keys()).filter((n) => parents.get(n).length === 0);
10338		assertArgument(primaryTypes.length !== 0, "missing primary type", "types", _types);
10339		assertArgument(primaryTypes.length === 1, `ambiguous primary types or unused types: ${primaryTypes.map((t) => JSON.stringify(t)).join(", ")}`, "types", _types);
10340		defineProperties(this, { primaryType: primaryTypes[0] });
10341		function checkCircular(type, found) {
10342			assertArgument(!found.has(type), `circular type reference to ${JSON.stringify(type)}`, "types", _types);
10343			found.add(type);
10344			for (const child of links.get(type)) {
10345				if (!parents.has(child)) continue;
10346				checkCircular(child, found);
10347				for (const subtype of found) subtypes.get(subtype).add(child);
10348			}
10349			found.delete(type);
10350		}
10351		checkCircular(this.primaryType, /* @__PURE__ */ new Set());
10352		for (const [name, set] of subtypes) {
10353			const st = Array.from(set);
10354			st.sort();
10355			this.#fullTypes.set(name, encodeType(name, types[name]) + st.map((t) => encodeType(t, types[t])).join(""));
10356		}
10357	}
10358	/**
10359	*  Returnthe encoder for the specific %%type%%.
10360	*/
10361	getEncoder(type) {
10362		let encoder = this.#encoderCache.get(type);
10363		if (!encoder) {
10364			encoder = this.#getEncoder(type);
10365			this.#encoderCache.set(type, encoder);
10366		}
10367		return encoder;
10368	}
10369	#getEncoder(type) {
10370		{
10371			const encoder = getBaseEncoder(type);
10372			if (encoder) return encoder;
10373		}
10374		const array = splitArray(type).array;
10375		if (array) {
10376			const subtype = array.prefix;
10377			const subEncoder = this.getEncoder(subtype);
10378			return (value) => {
10379				assertArgument(array.count === -1 || array.count === value.length, `array length mismatch; expected length ${array.count}`, "value", value);
10380				let result = value.map(subEncoder);
10381				if (this.#fullTypes.has(subtype)) result = result.map(keccak256);
10382				return keccak256(concat(result));
10383			};
10384		}
10385		const fields = this.types[type];
10386		if (fields) {
10387			const encodedType = id(this.#fullTypes.get(type));
10388			return (value) => {
10389				const values = fields.map(({ name, type }) => {
10390					const result = this.getEncoder(type)(value[name]);
10391					if (this.#fullTypes.has(type)) return keccak256(result);
10392					return result;
10393				});
10394				values.unshift(encodedType);
10395				return concat(values);
10396			};
10397		}
10398		assertArgument(false, `unknown type: ${type}`, "type", type);
10399	}
10400	/**
10401	*  Return the full type for %%name%%.
10402	*/
10403	encodeType(name) {
10404		const result = this.#fullTypes.get(name);
10405		assertArgument(result, `unknown type: ${JSON.stringify(name)}`, "name", name);
10406		return result;
10407	}
10408	/**
10409	*  Return the encoded %%value%% for the %%type%%.
10410	*/
10411	encodeData(type, value) {
10412		return this.getEncoder(type)(value);
10413	}
10414	/**
10415	*  Returns the hash of %%value%% for the type of %%name%%.
10416	*/
10417	hashStruct(name, value) {
10418		return keccak256(this.encodeData(name, value));
10419	}
10420	/**
10421	*  Return the fulled encoded %%value%% for the [[types]].
10422	*/
10423	encode(value) {
10424		return this.encodeData(this.primaryType, value);
10425	}
10426	/**
10427	*  Return the hash of the fully encoded %%value%% for the [[types]].
10428	*/
10429	hash(value) {
10430		return this.hashStruct(this.primaryType, value);
10431	}
10432	/**
10433	*  @_ignore:
10434	*/
10435	_visit(type, value, callback) {
10436		if (getBaseEncoder(type)) return callback(type, value);
10437		const array = splitArray(type).array;
10438		if (array) {

10439			assertArgument(array.count === -1 || array.count === value.length, `array length mismatch; expected length ${array.count}`, "value", value);
10440			return value.map((v) => this._visit(array.prefix, v, callback));
10441		}
10442		const fields = this.types[type];
10443		if (fields) return fields.reduce((accum, { name, type }) => {
10444			accum[name] = this._visit(type, value[name], callback);
10445			return accum;
10446		}, {});
10447		assertArgument(false, `unknown type: ${type}`, "type", type);
10448	}
10449	/**
10450	*  Call %%calback%% for each value in %%value%%, passing the type and
10451	*  component within %%value%%.
10452	*
10453	*  This is useful for replacing addresses or other transformation that
10454	*  may be desired on each component, based on its type.
10455	*/
10456	visit(value, callback) {
10457		return this._visit(this.primaryType, value, callback);
10458	}
10459	/**
10460	*  Create a new **TypedDataEncoder** for %%types%%.
10461	*/
10462	static from(types) {
10463		return new TypedDataEncoder(types);
10464	}
10465	/**
10466	*  Return the primary type for %%types%%.
10467	*/
10468	static getPrimaryType(types) {
10469		return TypedDataEncoder.from(types).primaryType;
10470	}
10471	/**
10472	*  Return the hashed struct for %%value%% using %%types%% and %%name%%.
10473	*/
10474	static hashStruct(name, types, value) {
10475		return TypedDataEncoder.from(types).hashStruct(name, value);
10476	}
10477	/**
10478	*  Return the domain hash for %%domain%%.
10479	*/
10480	static hashDomain(domain) {
10481		const domainFields = [];
10482		for (const name in domain) {
10483			if (domain[name] == null) continue;
10484			const type = domainFieldTypes[name];
10485			assertArgument(type, `invalid typed-data domain key: ${JSON.stringify(name)}`, "domain", domain);
10486			domainFields.push({
10487				name,
10488				type
10489			});
10490		}
10491		domainFields.sort((a, b) => {
10492			return domainFieldNames.indexOf(a.name) - domainFieldNames.indexOf(b.name);
10493		});
10494		return TypedDataEncoder.hashStruct("EIP712Domain", { EIP712Domain: domainFields }, domain);
10495	}
10496	/**
10497	*  Return the fully encoded [[link-eip-712]] %%value%% for %%types%% with %%domain%%.
10498	*/
10499	static encode(domain, types, value) {
10500		return concat([
10501			"0x1901",
10502			TypedDataEncoder.hashDomain(domain),
10503			TypedDataEncoder.from(types).hash(value)
10504		]);
10505	}
10506	/**
10507	*  Return the hash of the fully encoded [[link-eip-712]] %%value%% for %%types%% with %%domain%%.
10508	*/
10509	static hash(domain, types, value) {
10510		return keccak256(TypedDataEncoder.encode(domain, types, value));
10511	}
10512	/**
10513	* Resolves to the value from resolving all addresses in %%value%% for
10514	* %%types%% and the %%domain%%.
10515	*/
10516	static async resolveNames(domain, types, value, resolveName) {
10517		domain = Object.assign({}, domain);
10518		for (const key in domain) if (domain[key] == null) delete domain[key];
10519		const ensCache = {};
10520		if (domain.verifyingContract && !isHexString(domain.verifyingContract, 20)) ensCache[domain.verifyingContract] = "0x";
10521		const encoder = TypedDataEncoder.from(types);
10522		encoder.visit(value, (type, value) => {
10523			if (type === "address" && !isHexString(value, 20)) ensCache[value] = "0x";
10524			return value;
10525		});
10526		for (const name in ensCache) ensCache[name] = await resolveName(name);
10527		if (domain.verifyingContract && ensCache[domain.verifyingContract]) domain.verifyingContract = ensCache[domain.verifyingContract];
10528		value = encoder.visit(value, (type, value) => {
10529			if (type === "address" && ensCache[value]) return ensCache[value];
10530			return value;
10531		});
10532		return {
10533			domain,
10534			value
10535		};
10536	}
10537	/**
10538	*  Returns the JSON-encoded payload expected by nodes which implement
10539	*  the JSON-RPC [[link-eip-712]] method.
10540	*/
10541	static getPayload(domain, types, value) {
10542		TypedDataEncoder.hashDomain(domain);
10543		const domainValues = {};
10544		const domainTypes = [];
10545		domainFieldNames.forEach((name) => {
10546			const value = domain[name];
10547			if (value == null) return;
10548			domainValues[name] = domainChecks[name](value);
10549			domainTypes.push({
10550				name,
10551				type: domainFieldTypes[name]
10552			});
10553		});
10554		const encoder = TypedDataEncoder.from(types);
10555		types = encoder.types;
10556		const typesWithDomain = Object.assign({}, types);
10557		assertArgument(typesWithDomain.EIP712Domain == null, "types must not contain EIP712Domain type", "types.EIP712Domain", types);
10558		typesWithDomain.EIP712Domain = domainTypes;
10559		encoder.encode(value);
10560		return {
10561			types: typesWithDomain,
10562			domain: domainValues,
10563			primaryType: encoder.primaryType,
10564			message: encoder.visit(value, (type, value) => {
10565				if (type.match(/^bytes(\d*)/)) return hexlify(getBytes(value));
10566				if (type.match(/^u?int/)) return getBigInt(value).toString();
10567				switch (type) {
10568					case "address": return value.toLowerCase();
10569					case "bool": return !!value;
10570					case "string":
10571						assertArgument(typeof value === "string", "invalid string", "value", value);
10572						return value;
10573				}
10574				assertArgument(false, "unsupported type", "type", type);
10575			})
10576		};
10577	}
10578};
10579/**
10580*  Compute the address used to sign the typed data for the %%signature%%.
10581*/
10582function verifyTypedData(domain, types, value, signature) {
10583	return recoverAddress(TypedDataEncoder.hash(domain, types, value), signature);
10584}
10585//#endregion
10586//#region node_modules/ethers/lib.esm/abi/fragments.js
10587/**
10588*  A fragment is a single item from an ABI, which may represent any of:
10589*
10590*  - [Functions](FunctionFragment)
10591*  - [Events](EventFragment)
10592*  - [Constructors](ConstructorFragment)
10593*  - Custom [Errors](ErrorFragment)
10594*  - [Fallback or Receive](FallbackFragment) functions
10595*
10596*  @_subsection api/abi/abi-coder:Fragments  [about-fragments]
10597*/
10598function setify(items) {
10599	const result = /* @__PURE__ */ new Set();

10600	items.forEach((k) => result.add(k));
10601	return Object.freeze(result);
10602}
10603var KwVisibDeploy = setify("external public payable override".split(" "));
10604var _kwVisib = "constant external internal payable private public pure view override";
10605var KwVisib = setify(_kwVisib.split(" "));
10606var _kwTypes = "constructor error event fallback function receive struct";
10607var KwTypes = setify(_kwTypes.split(" "));
10608var _kwModifiers = "calldata memory storage payable indexed";
10609var KwModifiers = setify(_kwModifiers.split(" "));
10610var Keywords = setify([
10611	_kwTypes,
10612	_kwModifiers,
10613	"tuple returns",
10614	_kwVisib
10615].join(" ").split(" "));
10616var SimpleTokens = {
10617	"(": "OPEN_PAREN",
10618	")": "CLOSE_PAREN",
10619	"[": "OPEN_BRACKET",
10620	"]": "CLOSE_BRACKET",
10621	",": "COMMA",
10622	"@": "AT"
10623};
10624var regexWhitespacePrefix = /* @__PURE__ */ new RegExp("^(\\s*)");
10625var regexNumberPrefix = /* @__PURE__ */ new RegExp("^([0-9]+)");
10626var regexIdPrefix = /* @__PURE__ */ new RegExp("^([a-zA-Z$_][a-zA-Z0-9$_]*)");
10627var regexId = /* @__PURE__ */ new RegExp("^([a-zA-Z$_][a-zA-Z0-9$_]*)$");
10628var regexType = /* @__PURE__ */ new RegExp("^(address|bool|bytes([0-9]*)|string|u?int([0-9]*))$");
10629var TokenString = class TokenString {
10630	#offset;
10631	#tokens;
10632	get offset() {
10633		return this.#offset;
10634	}
10635	get length() {
10636		return this.#tokens.length - this.#offset;
10637	}
10638	constructor(tokens) {
10639		this.#offset = 0;
10640		this.#tokens = tokens.slice();
10641	}
10642	clone() {
10643		return new TokenString(this.#tokens);
10644	}
10645	reset() {
10646		this.#offset = 0;
10647	}
10648	#subTokenString(from = 0, to = 0) {
10649		return new TokenString(this.#tokens.slice(from, to).map((t) => {
10650			return Object.freeze(Object.assign({}, t, {
10651				match: t.match - from,
10652				linkBack: t.linkBack - from,
10653				linkNext: t.linkNext - from
10654			}));
10655		}));
10656	}
10657	popKeyword(allowed) {
10658		const top = this.peek();
10659		if (top.type !== "KEYWORD" || !allowed.has(top.text)) throw new Error(`expected keyword ${top.text}`);
10660		return this.pop().text;
10661	}
10662	popType(type) {
10663		if (this.peek().type !== type) {
10664			const top = this.peek();
10665			throw new Error(`expected ${type}; got ${top.type} ${JSON.stringify(top.text)}`);
10666		}
10667		return this.pop().text;
10668	}
10669	popParen() {
10670		const top = this.peek();
10671		if (top.type !== "OPEN_PAREN") throw new Error("bad start");
10672		const result = this.#subTokenString(this.#offset + 1, top.match + 1);
10673		this.#offset = top.match + 1;
10674		return result;
10675	}
10676	popParams() {
10677		const top = this.peek();
10678		if (top.type !== "OPEN_PAREN") throw new Error("bad start");
10679		const result = [];
10680		while (this.#offset < top.match - 1) {
10681			const link = this.peek().linkNext;
10682			result.push(this.#subTokenString(this.#offset + 1, link));
10683			this.#offset = link;
10684		}
10685		this.#offset = top.match + 1;
10686		return result;
10687	}
10688	peek() {
10689		if (this.#offset >= this.#tokens.length) throw new Error("out-of-bounds");
10690		return this.#tokens[this.#offset];
10691	}
10692	peekKeyword(allowed) {
10693		const top = this.peekType("KEYWORD");
10694		return top != null && allowed.has(top) ? top : null;
10695	}
10696	peekType(type) {
10697		if (this.length === 0) return null;
10698		const top = this.peek();
10699		return top.type === type ? top.text : null;
10700	}
10701	pop() {
10702		const result = this.peek();
10703		this.#offset++;
10704		return result;
10705	}
10706	toString() {
10707		const tokens = [];
10708		for (let i = this.#offset; i < this.#tokens.length; i++) {
10709			const token = this.#tokens[i];
10710			tokens.push(`${token.type}:${token.text}`);
10711		}
10712		return `<TokenString ${tokens.join(" ")}>`;
10713	}
10714};
10715function lex(text) {
10716	const tokens = [];
10717	const throwError = (message) => {
10718		const token = offset < text.length ? JSON.stringify(text[offset]) : "$EOI";
10719		throw new Error(`invalid token ${token} at ${offset}: ${message}`);
10720	};
10721	let brackets = [];
10722	let commas = [];
10723	let offset = 0;
10724	while (offset < text.length) {
10725		let cur = text.substring(offset);
10726		let match = cur.match(regexWhitespacePrefix);
10727		if (match) {
10728			offset += match[1].length;
10729			cur = text.substring(offset);
10730		}
10731		const token = {
10732			depth: brackets.length,
10733			linkBack: -1,
10734			linkNext: -1,
10735			match: -1,
10736			type: "",
10737			text: "",
10738			offset,
10739			value: -1
10740		};
10741		tokens.push(token);
10742		let type = SimpleTokens[cur[0]] || "";
10743		if (type) {
10744			token.type = type;
10745			token.text = cur[0];
10746			offset++;
10747			if (type === "OPEN_PAREN") {
10748				brackets.push(tokens.length - 1);
10749				commas.push(tokens.length - 1);
10750			} else if (type == "CLOSE_PAREN") {
10751				if (brackets.length === 0) throwError("no matching open bracket");
10752				token.match = brackets.pop();
10753				tokens[token.match].match = tokens.length - 1;
10754				token.depth--;
10755				token.linkBack = commas.pop();
10756				tokens[token.linkBack].linkNext = tokens.length - 1;
10757			} else if (type === "COMMA") {
10758				token.linkBack = commas.pop();
10759				tokens[token.linkBack].linkNext = tokens.length - 1;
10760				commas.push(tokens.length - 1);
10761			} else if (type === "OPEN_BRACKET") token.type = "BRACKET";
10762			else if (type === "CLOSE_BRACKET") {
10763				let suffix = tokens.pop().text;
10764				if (tokens.length > 0 && tokens[tokens.length - 1].type === "NUMBER") {
10765					const value = tokens.pop().text;
10766					suffix = value + suffix;
10767					tokens[tokens.length - 1].value = getNumber(value);
10768				}
10769				if (tokens.length === 0 || tokens[tokens.length - 1].type !== "BRACKET") throw new Error("missing opening bracket");
10770				tokens[tokens.length - 1].text += suffix;
10771			}
10772			continue;
10773		}
10774		match = cur.match(regexIdPrefix);
10775		if (match) {
10776			token.text = match[1];
10777			offset += token.text.length;
10778			if (Keywords.has(token.text)) {
10779				token.type = "KEYWORD";
10780				continue;
10781			}
10782			if (token.text.match(regexType)) {
10783				token.type = "TYPE";
10784				continue;
10785			}
10786			token.type = "ID";
10787			continue;
10788		}
10789		match = cur.match(regexNumberPrefix);
10790		if (match) {
10791			token.text = match[1];
10792			token.type = "NUMBER";
10793			offset += token.text.length;
10794			continue;
10795		}
10796		throw new Error(`unexpected token ${JSON.stringify(cur[0])} at position ${offset}`);
10797	}
10798	return new TokenString(tokens.map((t) => Object.freeze(t)));
10799}
10800function allowSingle(set, allowed) {
10801	let included = [];
10802	for (const key in allowed.keys()) if (set.has(key)) included.push(key);
10803	if (included.length > 1) throw new Error(`conflicting types: ${included.join(", ")}`);
10804}
10805function consumeName(type, tokens) {
10806	if (tokens.peekKeyword(KwTypes)) {
10807		const keyword = tokens.pop().text;
10808		if (keyword !== type) throw new Error(`expected ${type}, got ${keyword}`);
10809	}
10810	return tokens.popType("ID");
10811}
10812function consumeKeywords(tokens, allowed) {
10813	const keywords = /* @__PURE__ */ new Set();
10814	while (true) {
10815		const keyword = tokens.peekType("KEYWORD");
10816		if (keyword == null || allowed && !allowed.has(keyword)) break;
10817		tokens.pop();
10818		if (keywords.has(keyword)) throw new Error(`duplicate keywords: ${JSON.stringify(keyword)}`);
10819		keywords.add(keyword);
10820	}
10821	return Object.freeze(keywords);
10822}
10823function consumeMutability(tokens) {
10824	let modifiers = consumeKeywords(tokens, KwVisib);
10825	allowSingle(modifiers, setify("constant payable nonpayable".split(" ")));
10826	allowSingle(modifiers, setify("pure view payable nonpayable".split(" ")));
10827	if (modifiers.has("view")) return "view";
10828	if (modifiers.has("pure")) return "pure";
10829	if (modifiers.has("payable")) return "payable";
10830	if (modifiers.has("nonpayable")) return "nonpayable";
10831	if (modifiers.has("constant")) return "view";
10832	return "nonpayable";
10833}
10834function consumeParams(tokens, allowIndexed) {
10835	return tokens.popParams().map((t) => ParamType.from(t, allowIndexed));
10836}
10837function consumeGas(tokens) {
10838	if (tokens.peekType("AT")) {
10839		tokens.pop();
10840		if (tokens.peekType("NUMBER")) return getBigInt(tokens.pop().text);
10841		throw new Error("invalid gas");
10842	}
10843	return null;
10844}
10845function consumeEoi(tokens) {
10846	if (tokens.length) throw new Error(`unexpected tokens at offset ${tokens.offset}: ${tokens.toString()}`);
10847}
10848var regexArrayType = /* @__PURE__ */ new RegExp(/^(.*)\[([0-9]*)\]$/);
10849function verifyBasicType(type) {
10850	const match = type.match(regexType);
10851	assertArgument(match, "invalid type", "type", type);
10852	if (type === "uint") return "uint256";
10853	if (type === "int") return "int256";
10854	if (match[2]) {
10855		const length = parseInt(match[2]);
10856		assertArgument(length !== 0 && length <= 32, "invalid bytes length", "type", type);
10857	} else if (match[3]) {
10858		const size = parseInt(match[3]);
10859		assertArgument(size !== 0 && size <= 256 && size % 8 === 0, "invalid numeric width", "type", type);
10860	}
10861	return type;
10862}
10863var _guard$2 = {};
10864var internal$1 = Symbol.for("_ethers_internal");
10865var ParamTypeInternal = "_ParamTypeInternal";
10866var ErrorFragmentInternal = "_ErrorInternal";
10867var EventFragmentInternal = "_EventInternal";
10868var ConstructorFragmentInternal = "_ConstructorInternal";
10869var FallbackFragmentInternal = "_FallbackInternal";
10870var FunctionFragmentInternal = "_FunctionInternal";
10871var StructFragmentInternal = "_StructInternal";
10872/**
10873*  Each input and output of a [[Fragment]] is an Array of **ParamType**.
10874*/
10875var ParamType = class ParamType {
10876	/**
10877	*  The local name of the parameter (or ``""`` if unbound)
10878	*/
10879	name;
10880	/**
10881	*  The fully qualified type (e.g. ``"address"``, ``"tuple(address)"``,
10882	*  ``"uint256[3][]"``)
10883	*/
10884	type;
10885	/**
10886	*  The base type (e.g. ``"address"``, ``"tuple"``, ``"array"``)
10887	*/
10888	baseType;
10889	/**
10890	*  True if the parameters is indexed.
10891	*
10892	*  For non-indexable types this is ``null``.
10893	*/
10894	indexed;
10895	/**
10896	*  The components for the tuple.
10897	*
10898	*  For non-tuple types this is ``null``.
10899	*/
10900	components;
10901	/**
10902	*  The array length, or ``-1`` for dynamic-lengthed arrays.
10903	*
10904	*  For non-array types this is ``null``.
10905	*/
10906	arrayLength;
10907	/**
10908	*  The type of each child in the array.
10909	*
10910	*  For non-array types this is ``null``.
10911	*/
10912	arrayChildren;
10913	/**
10914	*  @private
10915	*/
10916	constructor(guard, name, type, baseType, indexed, components, arrayLength, arrayChildren) {
10917		assertPrivate(guard, _guard$2, "ParamType");
10918		Object.defineProperty(this, internal$1, { value: ParamTypeInternal });
10919		if (components) components = Object.freeze(components.slice());
10920		if (baseType === "array") {
10921			if (arrayLength == null || arrayChildren == null) throw new Error("");
10922		} else if (arrayLength != null || arrayChildren != null) throw new Error("");
10923		if (baseType === "tuple") {
10924			if (components == null) throw new Error("");
10925		} else if (components != null) throw new Error("");
10926		defineProperties(this, {
10927			name,
10928			type,
10929			baseType,
10930			indexed,

10931			components,
10932			arrayLength,
10933			arrayChildren
10934		});
10935	}
10936	/**
10937	*  Return a string representation of this type.
10938	*
10939	*  For example,
10940	*
10941	*  ``sighash" => "(uint256,address)"``
10942	*
10943	*  ``"minimal" => "tuple(uint256,address) indexed"``
10944	*
10945	*  ``"full" => "tuple(uint256 foo, address bar) indexed baz"``
10946	*/
10947	format(format) {
10948		if (format == null) format = "sighash";
10949		if (format === "json") {
10950			const name = this.name || "";
10951			if (this.isArray()) {
10952				const result = JSON.parse(this.arrayChildren.format("json"));
10953				result.name = name;
10954				result.type += `[${this.arrayLength < 0 ? "" : String(this.arrayLength)}]`;
10955				return JSON.stringify(result);
10956			}
10957			const result = {
10958				type: this.baseType === "tuple" ? "tuple" : this.type,
10959				name
10960			};
10961			if (typeof this.indexed === "boolean") result.indexed = this.indexed;
10962			if (this.isTuple()) result.components = this.components.map((c) => JSON.parse(c.format(format)));
10963			return JSON.stringify(result);
10964		}
10965		let result = "";
10966		if (this.isArray()) {
10967			result += this.arrayChildren.format(format);
10968			result += `[${this.arrayLength < 0 ? "" : String(this.arrayLength)}]`;
10969		} else if (this.isTuple()) result += "(" + this.components.map((comp) => comp.format(format)).join(format === "full" ? ", " : ",") + ")";
10970		else result += this.type;
10971		if (format !== "sighash") {
10972			if (this.indexed === true) result += " indexed";
10973			if (format === "full" && this.name) result += " " + this.name;
10974		}
10975		return result;
10976	}
10977	/**
10978	*  Returns true if %%this%% is an Array type.
10979	*
10980	*  This provides a type gaurd ensuring that [[arrayChildren]]
10981	*  and [[arrayLength]] are non-null.
10982	*/
10983	isArray() {
10984		return this.baseType === "array";
10985	}
10986	/**
10987	*  Returns true if %%this%% is a Tuple type.
10988	*
10989	*  This provides a type gaurd ensuring that [[components]]
10990	*  is non-null.
10991	*/
10992	isTuple() {
10993		return this.baseType === "tuple";
10994	}
10995	/**
10996	*  Returns true if %%this%% is an Indexable type.
10997	*
10998	*  This provides a type gaurd ensuring that [[indexed]]
10999	*  is non-null.
11000	*/
11001	isIndexable() {
11002		return this.indexed != null;
11003	}
11004	/**
11005	*  Walks the **ParamType** with %%value%%, calling %%process%%
11006	*  on each type, destructing the %%value%% recursively.
11007	*/
11008	walk(value, process) {
11009		if (this.isArray()) {
11010			if (!Array.isArray(value)) throw new Error("invalid array value");
11011			if (this.arrayLength !== -1 && value.length !== this.arrayLength) throw new Error("array is wrong length");
11012			const _this = this;
11013			return value.map((v) => _this.arrayChildren.walk(v, process));
11014		}
11015		if (this.isTuple()) {
11016			if (!Array.isArray(value)) throw new Error("invalid tuple value");
11017			if (value.length !== this.components.length) throw new Error("array is wrong length");
11018			const _this = this;
11019			return value.map((v, i) => _this.components[i].walk(v, process));
11020		}
11021		return process(this.type, value);
11022	}
11023	#walkAsync(promises, value, process, setValue) {
11024		if (this.isArray()) {
11025			if (!Array.isArray(value)) throw new Error("invalid array value");
11026			if (this.arrayLength !== -1 && value.length !== this.arrayLength) throw new Error("array is wrong length");
11027			const childType = this.arrayChildren;
11028			const result = value.slice();
11029			result.forEach((value, index) => {
11030				childType.#walkAsync(promises, value, process, (value) => {
11031					result[index] = value;
11032				});
11033			});
11034			setValue(result);
11035			return;
11036		}
11037		if (this.isTuple()) {
11038			const components = this.components;
11039			let result;
11040			if (Array.isArray(value)) result = value.slice();
11041			else {
11042				if (value == null || typeof value !== "object") throw new Error("invalid tuple value");
11043				result = components.map((param) => {
11044					if (!param.name) throw new Error("cannot use object value with unnamed components");
11045					if (!(param.name in value)) throw new Error(`missing value for component ${param.name}`);
11046					return value[param.name];
11047				});
11048			}
11049			if (result.length !== this.components.length) throw new Error("array is wrong length");
11050			result.forEach((value, index) => {
11051				components[index].#walkAsync(promises, value, process, (value) => {
11052					result[index] = value;
11053				});
11054			});
11055			setValue(result);
11056			return;
11057		}
11058		const result = process(this.type, value);
11059		if (result.then) promises.push((async function() {
11060			setValue(await result);
11061		})());
11062		else setValue(result);
11063	}
11064	/**
11065	*  Walks the **ParamType** with %%value%%, asynchronously calling
11066	*  %%process%% on each type, destructing the %%value%% recursively.
11067	*
11068	*  This can be used to resolve ENS names by walking and resolving each
11069	*  ``"address"`` type.
11070	*/
11071	async walkAsync(value, process) {
11072		const promises = [];
11073		const result = [value];
11074		this.#walkAsync(promises, value, process, (value) => {
11075			result[0] = value;
11076		});
11077		if (promises.length) await Promise.all(promises);
11078		return result[0];
11079	}
11080	/**
11081	*  Creates a new **ParamType** for %%obj%%.
11082	*
11083	*  If %%allowIndexed%% then the ``indexed`` keyword is permitted,
11084	*  otherwise the ``indexed`` keyword will throw an error.
11085	*/
11086	static from(obj, allowIndexed) {
11087		if (ParamType.isParamType(obj)) return obj;
11088		if (typeof obj === "string") try {
11089			return ParamType.from(lex(obj), allowIndexed);
11090		} catch (error) {
11091			assertArgument(false, "invalid param type", "obj", obj);
11092		}
11093		else if (obj instanceof TokenString) {
11094			let type = "", baseType = "";
11095			let comps = null;
11096			if (consumeKeywords(obj, setify(["tuple"])).has("tuple") || obj.peekType("OPEN_PAREN")) {
11097				baseType = "tuple";
11098				comps = obj.popParams().map((t) => ParamType.from(t));
11099				type = `tuple(${comps.map((c) => c.format()).join(",")})`;
11100			} else {
11101				type = verifyBasicType(obj.popType("TYPE"));
11102				baseType = type;
11103			}
11104			let arrayChildren = null;
11105			let arrayLength = null;
11106			while (obj.length && obj.peekType("BRACKET")) {
11107				const bracket = obj.pop();
11108				arrayChildren = new ParamType(_guard$2, "", type, baseType, null, comps, arrayLength, arrayChildren);
11109				arrayLength = bracket.value;
11110				type += bracket.text;
11111				baseType = "array";
11112				comps = null;
11113			}
11114			let indexed = null;
11115			if (consumeKeywords(obj, KwModifiers).has("indexed")) {
11116				if (!allowIndexed) throw new Error("");
11117				indexed = true;
11118			}
11119			const name = obj.peekType("ID") ? obj.pop().text : "";
11120			if (obj.length) throw new Error("leftover tokens");
11121			return new ParamType(_guard$2, name, type, baseType, indexed, comps, arrayLength, arrayChildren);
11122		}
11123		const name = obj.name;
11124		assertArgument(!name || typeof name === "string" && name.match(regexId), "invalid name", "obj.name", name);
11125		let indexed = obj.indexed;
11126		if (indexed != null) {
11127			assertArgument(allowIndexed, "parameter cannot be indexed", "obj.indexed", obj.indexed);
11128			indexed = !!indexed;
11129		}
11130		let type = obj.type;
11131		let arrayMatch = type.match(regexArrayType);
11132		if (arrayMatch) {
11133			const arrayLength = parseInt(arrayMatch[2] || "-1");
11134			const arrayChildren = ParamType.from({
11135				type: arrayMatch[1],
11136				components: obj.components
11137			});
11138			return new ParamType(_guard$2, name || "", type, "array", indexed, null, arrayLength, arrayChildren);
11139		}
11140		if (type === "tuple" || type.startsWith("tuple(") || type.startsWith("(")) {
11141			const comps = obj.components != null ? obj.components.map((c) => ParamType.from(c)) : null;
11142			return new ParamType(_guard$2, name || "", type, "tuple", indexed, comps, null, null);
11143		}
11144		type = verifyBasicType(obj.type);
11145		return new ParamType(_guard$2, name || "", type, type, indexed, null, null, null);
11146	}
11147	/**
11148	*  Returns true if %%value%% is a **ParamType**.
11149	*/
11150	static isParamType(value) {
11151		return value && value[internal$1] === ParamTypeInternal;
11152	}
11153};
11154/**
11155*  An abstract class to represent An individual fragment from a parse ABI.
11156*/
11157var Fragment = class Fragment {
11158	/**
11159	*  The type of the fragment.
11160	*/
11161	type;
11162	/**
11163	*  The inputs for the fragment.
11164	*/
11165	inputs;
11166	/**
11167	*  @private
11168	*/
11169	constructor(guard, type, inputs) {
11170		assertPrivate(guard, _guard$2, "Fragment");
11171		inputs = Object.freeze(inputs.slice());
11172		defineProperties(this, {
11173			type,
11174			inputs
11175		});
11176	}
11177	/**
11178	*  Creates a new **Fragment** for %%obj%%, wich can be any supp

11178orted
11179	*  ABI frgament type.
11180	*/
11181	static from(obj) {
11182		if (typeof obj === "string") {
11183			try {
11184				Fragment.from(JSON.parse(obj));
11185			} catch (e) {}
11186			return Fragment.from(lex(obj));
11187		}
11188		if (obj instanceof TokenString) switch (obj.peekKeyword(KwTypes)) {
11189			case "constructor": return ConstructorFragment.from(obj);
11190			case "error": return ErrorFragment.from(obj);
11191			case "event": return EventFragment.from(obj);
11192			case "fallback":
11193			case "receive": return FallbackFragment.from(obj);
11194			case "function": return FunctionFragment.from(obj);
11195			case "struct": return StructFragment.from(obj);
11196		}
11197		else if (typeof obj === "object") {
11198			switch (obj.type) {
11199				case "constructor": return ConstructorFragment.from(obj);
11200				case "error": return ErrorFragment.from(obj);
11201				case "event": return EventFragment.from(obj);
11202				case "fallback":
11203				case "receive": return FallbackFragment.from(obj);
11204				case "function": return FunctionFragment.from(obj);
11205				case "struct": return StructFragment.from(obj);
11206			}
11207			assert(false, `unsupported type: ${obj.type}`, "UNSUPPORTED_OPERATION", { operation: "Fragment.from" });
11208		}
11209		assertArgument(false, "unsupported frgament object", "obj", obj);
11210	}
11211	/**
11212	*  Returns true if %%value%% is a [[ConstructorFragment]].
11213	*/
11214	static isConstructor(value) {
11215		return ConstructorFragment.isFragment(value);
11216	}
11217	/**
11218	*  Returns true if %%value%% is an [[ErrorFragment]].
11219	*/
11220	static isError(value) {
11221		return ErrorFragment.isFragment(value);
11222	}
11223	/**
11224	*  Returns true if %%value%% is an [[EventFragment]].
11225	*/
11226	static isEvent(value) {
11227		return EventFragment.isFragment(value);
11228	}
11229	/**
11230	*  Returns true if %%value%% is a [[FunctionFragment]].
11231	*/
11232	static isFunction(value) {
11233		return FunctionFragment.isFragment(value);
11234	}
11235	/**
11236	*  Returns true if %%value%% is a [[StructFragment]].
11237	*/
11238	static isStruct(value) {
11239		return StructFragment.isFragment(value);
11240	}
11241};
11242/**
11243*  An abstract class to represent An individual fragment
11244*  which has a name from a parse ABI.
11245*/
11246var NamedFragment = class extends Fragment {
11247	/**
11248	*  The name of the fragment.
11249	*/
11250	name;
11251	/**
11252	*  @private
11253	*/
11254	constructor(guard, type, name, inputs) {
11255		super(guard, type, inputs);
11256		assertArgument(typeof name === "string" && name.match(regexId), "invalid identifier", "name", name);
11257		inputs = Object.freeze(inputs.slice());
11258		defineProperties(this, { name });
11259	}
11260};
11261function joinParams(format, params) {
11262	return "(" + params.map((p) => p.format(format)).join(format === "full" ? ", " : ",") + ")";
11263}
11264/**
11265*  A Fragment which represents a //Custom Error//.
11266*/
11267var ErrorFragment = class ErrorFragment extends NamedFragment {
11268	/**
11269	*  @private
11270	*/
11271	constructor(guard, name, inputs) {
11272		super(guard, "error", name, inputs);
11273		Object.defineProperty(this, internal$1, { value: ErrorFragmentInternal });
11274	}
11275	/**
11276	*  The Custom Error selector.
11277	*/
11278	get selector() {
11279		return id(this.format("sighash")).substring(0, 10);
11280	}
11281	/**
11282	*  Returns a string representation of this fragment as %%format%%.
11283	*/
11284	format(format) {
11285		if (format == null) format = "sighash";
11286		if (format === "json") return JSON.stringify({
11287			type: "error",
11288			name: this.name,
11289			inputs: this.inputs.map((input) => JSON.parse(input.format(format)))
11290		});
11291		const result = [];
11292		if (format !== "sighash") result.push("error");
11293		result.push(this.name + joinParams(format, this.inputs));
11294		return result.join(" ");
11295	}
11296	/**
11297	*  Returns a new **ErrorFragment** for %%obj%%.
11298	*/
11299	static from(obj) {
11300		if (ErrorFragment.isFragment(obj)) return obj;
11301		if (typeof obj === "string") return ErrorFragment.from(lex(obj));
11302		else if (obj instanceof TokenString) {
11303			const name = consumeName("error", obj);
11304			const inputs = consumeParams(obj);
11305			consumeEoi(obj);
11306			return new ErrorFragment(_guard$2, name, inputs);
11307		}
11308		return new ErrorFragment(_guard$2, obj.name, obj.inputs ? obj.inputs.map(ParamType.from) : []);
11309	}
11310	/**
11311	*  Returns ``true`` and provides a type guard if %%value%% is an
11312	*  **ErrorFragment**.
11313	*/
11314	static isFragment(value) {
11315		return value && value[internal$1] === ErrorFragmentInternal;
11316	}
11317};
11318/**
11319*  A Fragment which represents an Event.
11320*/
11321var EventFragment = class EventFragment extends NamedFragment {
11322	/**
11323	*  Whether this event is anonymous.
11324	*/
11325	anonymous;
11326	/**
11327	*  @private
11328	*/
11329	constructor(guard, name, inputs, anonymous) {
11330		super(guard, "event", name, inputs);
11331		Object.defineProperty(this, internal$1, { value: EventFragmentInternal });
11332		defineProperties(this, { anonymous });
11333	}
11334	/**
11335	*  The Event topic hash.
11336	*/
11337	get topicHash() {
11338		return id(this.format("sighash"));
11339	}
11340	/**
11341	*  Returns a string representation of this event as %%format%%.
11342	*/
11343	format(format) {
11344		if (format == null) format = "sighash";
11345		if (format === "json") return JSON.stringify({
11346			type: "event",
11347			anonymous: this.anonymous,
11348			name: this.name,
11349			inputs: this.inputs.map((i) => JSON.parse(i.format(format)))
11350		});
11351		const result = [];
11352		if (format !== "sighash") result.push("event");
11353		result.push(this.name + joinParams(format, this.inputs));
11354		if (format !== "sighash" && this.anonymous) result.push("anonymous");
11355		return result.join(" ");
11356	}
11357	/**
11358	*  Return the topic hash for an event with %%name%% and %%params%%.
11359	*/
11360	static getTopicHash(name, params) {
11361		params = (params || []).map((p) => ParamType.from(p));
11362		return new EventFragment(_guard$2, name, params, false).topicHash;
11363	}
11364	/**
11365	*  Returns a new **EventFragment** for %%obj%%.
11366	*/
11367	static from(obj) {

11368		if (EventFragment.isFragment(obj)) return obj;
11369		if (typeof obj === "string") try {
11370			return EventFragment.from(lex(obj));
11371		} catch (error) {
11372			assertArgument(false, "invalid event fragment", "obj", obj);
11373		}
11374		else if (obj instanceof TokenString) {
11375			const name = consumeName("event", obj);
11376			const inputs = consumeParams(obj, true);
11377			const anonymous = !!consumeKeywords(obj, setify(["anonymous"])).has("anonymous");
11378			consumeEoi(obj);
11379			return new EventFragment(_guard$2, name, inputs, anonymous);
11380		}
11381		return new EventFragment(_guard$2, obj.name, obj.inputs ? obj.inputs.map((p) => ParamType.from(p, true)) : [], !!obj.anonymous);
11382	}
11383	/**
11384	*  Returns ``true`` and provides a type guard if %%value%% is an
11385	*  **EventFragment**.
11386	*/
11387	static isFragment(value) {
11388		return value && value[internal$1] === EventFragmentInternal;
11389	}
11390};
11391/**
11392*  A Fragment which represents a constructor.
11393*/
11394var ConstructorFragment = class ConstructorFragment extends Fragment {
11395	/**
11396	*  Whether the constructor can receive an endowment.
11397	*/
11398	payable;
11399	/**
11400	*  The recommended gas limit for deployment or ``null``.
11401	*/
11402	gas;
11403	/**
11404	*  @private
11405	*/
11406	constructor(guard, type, inputs, payable, gas) {
11407		super(guard, type, inputs);
11408		Object.defineProperty(this, internal$1, { value: ConstructorFragmentInternal });
11409		defineProperties(this, {
11410			payable,
11411			gas
11412		});
11413	}
11414	/**
11415	*  Returns a string representation of this constructor as %%format%%.
11416	*/
11417	format(format) {
11418		assert(format != null && format !== "sighash", "cannot format a constructor for sighash", "UNSUPPORTED_OPERATION", { operation: "format(sighash)" });
11419		if (format === "json") return JSON.stringify({
11420			type: "constructor",
11421			stateMutability: this.payable ? "payable" : "undefined",
11422			payable: this.payable,
11423			gas: this.gas != null ? this.gas : void 0,
11424			inputs: this.inputs.map((i) => JSON.parse(i.format(format)))
11425		});
11426		const result = [`constructor${joinParams(format, this.inputs)}`];
11427		if (this.payable) result.push("payable");
11428		if (this.gas != null) result.push(`@${this.gas.toString()}`);
11429		return result.join(" ");
11430	}
11431	/**
11432	*  Returns a new **ConstructorFragment** for %%obj%%.
11433	*/
11434	static from(obj) {
11435		if (ConstructorFragment.isFragment(obj)) return obj;
11436		if (typeof obj === "string") try {
11437			return ConstructorFragment.from(lex(obj));
11438		} catch (error) {
11439			assertArgument(false, "invalid constuctor fragment", "obj", obj);
11440		}
11441		else if (obj instanceof TokenString) {
11442			consumeKeywords(obj, setify(["constructor"]));
11443			const inputs = consumeParams(obj);
11444			const payable = !!consumeKeywords(obj, KwVisibDeploy).has("payable");
11445			const gas = consumeGas(obj);
11446			consumeEoi(obj);
11447			return new ConstructorFragment(_guard$2, "constructor", inputs, payable, gas);
11448		}
11449		return new ConstructorFragment(_guard$2, "constructor", obj.inputs ? obj.inputs.map(ParamType.from) : [], !!obj.payable, obj.gas != null ? obj.gas : null);
11450	}
11451	/**
11452	*  Returns ``true`` and provides a type guard if %%value%% is a
11453	*  **ConstructorFragment**.
11454	*/
11455	static isFragment(value) {
11456		return value && value[internal$1] === ConstructorFragmentInternal;
11457	}
11458};
11459/**
11460*  A Fragment which represents a method.
11461*/
11462var FallbackFragment = class FallbackFragment extends Fragment {
11463	/**
11464	*  If the function can be sent value during invocation.
11465	*/
11466	payable;
11467	constructor(guard, inputs, payable) {
11468		super(guard, "fallback", inputs);
11469		Object.defineProperty(this, internal$1, { value: FallbackFragmentInternal });
11470		defineProperties(this, { payable });
11471	}
11472	/**
11473	*  Returns a string representation of this fallback as %%format%%.
11474	*/
11475	format(format) {
11476		const type = this.inputs.length === 0 ? "receive" : "fallback";
11477		if (format === "json") {
11478			const stateMutability = this.payable ? "payable" : "nonpayable";
11479			return JSON.stringify({
11480				type,
11481				stateMutability
11482			});
11483		}
11484		return `${type}()${this.payable ? " payable" : ""}`;
11485	}
11486	/**
11487	*  Returns a new **FallbackFragment** for %%obj%%.
11488	*/
11489	static from(obj) {
11490		if (FallbackFragment.isFragment(obj)) return obj;
11491		if (typeof obj === "string") try {
11492			return FallbackFragment.from(lex(obj));
11493		} catch (error) {
11494			assertArgument(false, "invalid fallback fragment", "obj", obj);
11495		}
11496		else if (obj instanceof TokenString) {
11497			const errorObj = obj.toString();
11498			assertArgument(obj.peekKeyword(setify(["fallback", "receive"])), "type must be fallback or receive", "obj", errorObj);
11499			if (obj.popKeyword(setify(["fallback", "receive"])) === "receive") {
11500				const inputs = consumeParams(obj);
11501				assertArgument(inputs.length === 0, `receive cannot have arguments`, "obj.inputs", inputs);
11502				consumeKeywords(obj, setify(["payable"]));
11503				consumeEoi(obj);
11504				return new FallbackFragment(_guard$2, [], true);
11505			}
11506			let inputs = consumeParams(obj);
11507			if (inputs.length) assertArgument(inputs.length === 1 && inputs[0].type === "bytes", "invalid fallback inputs", "obj.inputs", inputs.map((i) => i.format("minimal")).join(", "));
11508			else inputs = [ParamType.from("bytes")];
11509			const mutability = consumeMutability(obj);

11510			assertArgument(mutability === "nonpayable" || mutability === "payable", "fallback cannot be constants", "obj.stateMutability", mutability);
11511			if (consumeKeywords(obj, setify(["returns"])).has("returns")) {
11512				const outputs = consumeParams(obj);
11513				assertArgument(outputs.length === 1 && outputs[0].type === "bytes", "invalid fallback outputs", "obj.outputs", outputs.map((i) => i.format("minimal")).join(", "));
11514			}
11515			consumeEoi(obj);
11516			return new FallbackFragment(_guard$2, inputs, mutability === "payable");
11517		}
11518		if (obj.type === "receive") return new FallbackFragment(_guard$2, [], true);
11519		if (obj.type === "fallback") {
11520			const inputs = [ParamType.from("bytes")];
11521			const payable = obj.stateMutability === "payable";
11522			return new FallbackFragment(_guard$2, inputs, payable);
11523		}
11524		assertArgument(false, "invalid fallback description", "obj", obj);
11525	}
11526	/**
11527	*  Returns ``true`` and provides a type guard if %%value%% is a
11528	*  **FallbackFragment**.
11529	*/
11530	static isFragment(value) {
11531		return value && value[internal$1] === FallbackFragmentInternal;
11532	}
11533};
11534/**
11535*  A Fragment which represents a method.
11536*/
11537var FunctionFragment = class FunctionFragment extends NamedFragment {
11538	/**
11539	*  If the function is constant (e.g. ``pure`` or ``view`` functions).
11540	*/
11541	constant;
11542	/**
11543	*  The returned types for the result of calling this function.
11544	*/
11545	outputs;
11546	/**
11547	*  The state mutability (e.g. ``payable``, ``nonpayable``, ``view``
11548	*  or ``pure``)
11549	*/
11550	stateMutability;
11551	/**
11552	*  If the function can be sent value during invocation.
11553	*/
11554	payable;
11555	/**
11556	*  The recommended gas limit to send when calling this function.
11557	*/
11558	gas;
11559	/**
11560	*  @private
11561	*/
11562	constructor(guard, name, stateMutability, inputs, outputs, gas) {
11563		super(guard, "function", name, inputs);
11564		Object.defineProperty(this, internal$1, { value: FunctionFragmentInternal });
11565		outputs = Object.freeze(outputs.slice());
11566		const constant = stateMutability === "view" || stateMutability === "pure";
11567		const payable = stateMutability === "payable";
11568		defineProperties(this, {
11569			constant,
11570			gas,
11571			outputs,
11572			payable,
11573			stateMutability
11574		});
11575	}
11576	/**
11577	*  The Function selector.
11578	*/
11579	get selector() {
11580		return id(this.format("sighash")).substring(0, 10);
11581	}
11582	/**
11583	*  Returns a string representation of this function as %%format%%.
11584	*/
11585	format(format) {
11586		if (format == null) format = "sighash";
11587		if (format === "json") return JSON.stringify({
11588			type: "function",
11589			name: this.name,
11590			constant: this.constant,
11591			stateMutability: this.stateMutability !== "nonpayable" ? this.stateMutability : void 0,
11592			payable: this.payable,
11593			gas: this.gas != null ? this.gas : void 0,
11594			inputs: this.inputs.map((i) => JSON.parse(i.format(format))),
11595			outputs: this.outputs.map((o) => JSON.parse(o.format(format)))
11596		});
11597		const result = [];
11598		if (format !== "sighash") result.push("function");
11599		result.push(this.name + joinParams(format, this.inputs));
11600		if (format !== "sighash") {
11601			if (this.stateMutability !== "nonpayable") result.push(this.stateMutability);
11602			if (this.outputs && this.outputs.length) {
11603				result.push("returns");
11604				result.push(joinParams(format, this.outputs));
11605			}
11606			if (this.gas != null) result.push(`@${this.gas.toString()}`);
11607		}
11608		return result.join(" ");
11609	}
11610	/**
11611	*  Return the selector for a function with %%name%% and %%params%%.
11612	*/
11613	static getSelector(name, params) {
11614		params = (params || []).map((p) => ParamType.from(p));
11615		return new FunctionFragment(_guard$2, name, "view", params, [], null).selector;
11616	}
11617	/**
11618	*  Returns a new **FunctionFragment** for %%obj%%.
11619	*/
11620	static from(obj) {
11621		if (FunctionFragment.isFragment(obj)) return obj;
11622		if (typeof obj === "string") try {
11623			return FunctionFragment.from(lex(obj));
11624		} catch (error) {
11625			assertArgument(false, "invalid function fragment", "obj", obj);
11626		}
11627		else if (obj instanceof TokenString) {
11628			const name = consumeName("function", obj);
11629			const inputs = consumeParams(obj);
11630			const mutability = consumeMutability(obj);
11631			let outputs = [];
11632			if (consumeKeywords(obj, setify(["returns"])).has("returns")) outputs = consumeParams(obj);
11633			const gas = consumeGas(obj);
11634			consumeEoi(obj);
11635			return new FunctionFragment(_guard$2, name, mutability, inputs, outputs, gas);
11636		}
11637		let stateMutability = obj.stateMutability;
11638		if (stateMutability == null) {
11639			stateMutability = "payable";
11640			if (typeof obj.constant === "boolean") {
11641				stateMutability = "view";
11642				if (!obj.constant) {
11643					stateMutability = "payable";
11644					if (typeof obj.payable === "boolean" && !obj.payable) stateMutability = "nonpayable";
11645				}
11646			} else if (typeof obj.payable === "boolean" && !obj.payable) stateMutability = "nonpayable";
11647		}
11648		return new FunctionFragment(_guard$2, obj.name, stateMutability, obj.inputs ? obj.inputs.map(ParamType.from) : [], obj.outputs ? obj.outputs.map(ParamType.from) : [], obj.gas != null ? obj.gas : null);
11649	}
11650	/**
11651	*  Returns ``true`` and provides a type guard if %%value%% is a
11652	*  **FunctionFragment**.
11653	*/
11654	static isFragment(value) {
11655		return value && value[internal$1] === FunctionFragmentInternal;
11656	}
11657};
11658/**
11659*  A Fragment which represents a structure.
11660*/
11661var StructFragment = class StructFragment extends NamedFragment {
11662	/**
11663	*  @private
11664	*/
11665	constructor(guard, name, inputs) {
11666		super(guard, "struct", name, inputs);
11667		Object.defineProperty(this, internal$1, { value: StructFragmentInternal });
11668	}
11669	/**
11670	*  Returns a string representation of this struct as %%format%%.
11671	*/
11672	format() {
11673		throw new Error("@TODO");
11674	}
11675	/**
11676	*  Returns a new **StructFragment** for %%obj%%.
11677	*/
11678	static from(obj) {
11679		if (typeof obj === "string") try {
11680			return StructFragment.from(lex(obj));
11681		} catch (error) {
11682			assertArgument(false, "invalid struct fragment", "obj", obj);
11683		}
11684		else if (obj instanceof TokenString) {
11685			const name = consumeName("struct", obj);
11686			const inputs = consumeParams(obj);
11687			consumeEoi(obj);
11688			return new StructFragment(_guard$2, name, inputs);
11689		}
11690		return new StructFragment(_guard$2, obj.name, obj.inputs ? obj.inputs.map(ParamType.from) : []);
11691	}
11692	/**
11693	*  Returns ``true`` and provides a type guard if %%value%% is a
11694	*  **StructFragment**.
11695	*/
11696	static isFragment(value) {
11697		return value && value[internal$1] === StructFragmentInternal;
11698	}
11699};
11700//#endregion
11701//#region node_modules/ethers/lib.esm/abi/abi-coder.js
11702/**
11703*  When sending values to or receiving values from a [[Contract]], the
11704*  data is generally encoded using the [ABI standard](link-solc-abi).
11705*
11706*  The AbiCoder provides a utility to encode values to ABI data and
11707*  decode values from ABI data.
11708*
11709*  Most of the time, developers should favour the [[Contract]] class,
11710*  which further abstracts a lot of the finer details of ABI data.
11711*
11712*  @_section api/abi/abi-coder:ABI Encoding
11713*/
11714var PanicReasons$1 = /* @__PURE__ */ new Map();
11715PanicReasons$1.set(0, "GENERIC_PANIC");
11716PanicReasons$1.set(1, "ASSERT_FALSE");
11717PanicReasons$1.set(17, "OVERFLOW");
11718PanicReasons$1.set(18, "DIVIDE_BY_ZERO");
11719PanicReasons$1.set(33, "ENUM_RANGE_ERROR");
11720PanicReasons$1.set(34, "BAD_STORAGE_DATA");
11721PanicReasons$1.set(49, "STACK_UNDERFLOW");
11722PanicReasons$1.set(50, "ARRAY_RANGE_ERROR");
11723PanicReasons$1.set(65, "OUT_OF_MEMORY");
11724PanicReasons$1.set(81, "UNINITIALIZED_FUNCTION_CALL");
11725var paramTypeBytes = /* @__PURE__ */ new RegExp(/^bytes([0-9]*)$/);
11726var paramTypeNumber = /* @__PURE__ */ new RegExp(/^(u?int)([0-9]*)$/);
11727var defaultCoder = null;
11728var defaultMaxInflation = 1024;
11729function getBuiltinCallException(action, tx, data, abiCoder) {
11730	let message = "missing revert data";
11731	let reason = null;
11732	const invocation = null;
11733	let revert = null;
11734	if (data) {
11735		message = "execution reverted";
11736		const bytes = getBytes(data);
11737		data = hexlify(data);
11738		if (bytes.length === 0) {

11739			message += " (no data present; likely require(false) occurred";
11740			reason = "require(false)";
11741		} else if (bytes.length % 32 !== 4) message += " (could not decode reason; invalid data length)";
11742		else if (hexlify(bytes.slice(0, 4)) === "0x08c379a0") try {
11743			reason = abiCoder.decode(["string"], bytes.slice(4))[0];
11744			revert = {
11745				signature: "Error(string)",
11746				name: "Error",
11747				args: [reason]
11748			};
11749			message += `: ${JSON.stringify(reason)}`;
11750		} catch (error) {
11751			message += " (could not decode reason; invalid string data)";
11752		}
11753		else if (hexlify(bytes.slice(0, 4)) === "0x4e487b71") try {
11754			const code = Number(abiCoder.decode(["uint256"], bytes.slice(4))[0]);
11755			revert = {
11756				signature: "Panic(uint256)",
11757				name: "Panic",
11758				args: [code]
11759			};
11760			reason = `Panic due to ${PanicReasons$1.get(code) || "UNKNOWN"}(${code})`;
11761			message += `: ${reason}`;
11762		} catch (error) {
11763			message += " (could not decode panic code)";
11764		}
11765		else message += " (unknown custom error)";
11766	}
11767	const transaction = {
11768		to: tx.to ? getAddress(tx.to) : null,
11769		data: tx.data || "0x"
11770	};
11771	if (tx.from) transaction.from = getAddress(tx.from);
11772	return makeError(message, "CALL_EXCEPTION", {
11773		action,
11774		data,
11775		reason,
11776		transaction,
11777		invocation,
11778		revert
11779	});
11780}
11781/**
11782*  The **AbiCoder** is a low-level class responsible for encoding JavaScript
11783*  values into binary data and decoding binary data into JavaScript values.
11784*/
11785var AbiCoder = class AbiCoder {
11786	#getCoder(param) {
11787		if (param.isArray()) return new ArrayCoder(this.#getCoder(param.arrayChildren), param.arrayLength, param.name);
11788		if (param.isTuple()) return new TupleCoder(param.components.map((c) => this.#getCoder(c)), param.name);
11789		switch (param.baseType) {
11790			case "address": return new AddressCoder(param.name);
11791			case "bool": return new BooleanCoder(param.name);
11792			case "string": return new StringCoder(param.name);
11793			case "bytes": return new BytesCoder(param.name);
11794			case "": return new NullCoder(param.name);
11795		}
11796		let match = param.type.match(paramTypeNumber);
11797		if (match) {
11798			let size = parseInt(match[2] || "256");
11799			assertArgument(size !== 0 && size <= 256 && size % 8 === 0, "invalid " + match[1] + " bit length", "param", param);
11800			return new NumberCoder(size / 8, match[1] === "int", param.name);
11801		}
11802		match = param.type.match(paramTypeBytes);
11803		if (match) {
11804			let size = parseInt(match[1]);
11805			assertArgument(size !== 0 && size <= 32, "invalid bytes length", "param", param);
11806			return new FixedBytesCoder(size, param.name);
11807		}
11808		assertArgument(false, "invalid type", "type", param.type);
11809	}
11810	/**
11811	*  Get the default values for the given %%types%%.
11812	*
11813	*  For example, a ``uint`` is by default ``0`` and ``bool``
11814	*  is by default ``false``.
11815	*/
11816	getDefaultValue(types) {
11817		return new TupleCoder(types.map((type) => this.#getCoder(ParamType.from(type))), "_").defaultValue();
11818	}
11819	/**
11820	*  Encode the %%values%% as the %%types%% into ABI data.
11821	*
11822	*  @returns DataHexstring
11823	*/
11824	encode(types, values) {
11825		assertArgumentCount(values.length, types.length, "types/values length mismatch");
11826		const coder = new TupleCoder(types.map((type) => this.#getCoder(ParamType.from(type))), "_");
11827		const writer = new Writer();
11828		coder.encode(writer, values);
11829		return writer.data;
11830	}
11831	/**
11832	*  Decode the ABI %%data%% as the %%types%% into values.
11833	*
11834	*  If %%loose%% decoding is enabled, then strict padding is
11835	*  not enforced. Some older versions of Solidity incorrectly
11836	*  padded event data emitted from ``external`` functions.
11837	*/
11838	decode(types, data, loose) {
11839		return new TupleCoder(types.map((type) => this.#getCoder(ParamType.from(type))), "_").decode(new Reader(data, loose, defaultMaxInflation));
11840	}
11841	static _setDefaultMaxInflation(value) {
11842		assertArgument(typeof value === "number" && Number.isInteger(value), "invalid defaultMaxInflation factor", "value", value);
11843		defaultMaxInflation = value;
11844	}
11845	/**
11846	*  Returns the shared singleton instance of a default [[AbiCoder]].
11847	*
11848	*  On the first call, the instance is created internally.
11849	*/
11850	static defaultAbiCoder() {
11851		if (defaultCoder == null) defaultCoder = new AbiCoder();
11852		return defaultCoder;
11853	}

11854	/**
11855	*  Returns an ethers-compatible [[CallExceptionError]] Error for the given
11856	*  result %%data%% for the [[CallExceptionAction]] %%action%% against
11857	*  the Transaction %%tx%%.
11858	*/
11859	static getBuiltinCallException(action, tx, data) {
11860		return getBuiltinCallException(action, tx, data, AbiCoder.defaultAbiCoder());
11861	}
11862};
11863//#endregion
11864//#region node_modules/ethers/lib.esm/abi/bytes32.js
11865/**
11866*  About bytes32 strings...
11867*
11868*  @_docloc: api/utils:Bytes32 Strings
11869*/
11870/**
11871*  Encodes %%text%% as a Bytes32 string.
11872*/
11873function encodeBytes32String(text) {
11874	const bytes = toUtf8Bytes(text);
11875	if (bytes.length > 31) throw new Error("bytes32 string must be less than 32 bytes");
11876	return zeroPadBytes(bytes, 32);
11877}
11878/**
11879*  Encodes the Bytes32-encoded %%bytes%% into a string.
11880*/
11881function decodeBytes32String(_bytes) {
11882	const data = getBytes(_bytes, "bytes");
11883	if (data.length !== 32) throw new Error("invalid bytes32 - not 32 bytes long");
11884	if (data[31] !== 0) throw new Error("invalid bytes32 string - no null terminator");
11885	let length = 31;
11886	while (data[length - 1] === 0) length--;
11887	return toUtf8String(data.slice(0, length));
11888}
11889//#endregion
11890//#region node_modules/ethers/lib.esm/abi/interface.js
11891/**
11892*  The Interface class is a low-level class that accepts an
11893*  ABI and provides all the necessary functionality to encode
11894*  and decode paramaters to and results from methods, events
11895*  and errors.
11896*
11897*  It also provides several convenience methods to automatically
11898*  search and find matching transactions and events to parse them.
11899*
11900*  @_subsection api/abi:Interfaces  [interfaces]
11901*/
11902/**
11903*  When using the [[Interface-parseLog]] to automatically match a Log to its event
11904*  for parsing, a **LogDescription** is returned.
11905*/
11906var LogDescription = class {
11907	/**
11908	*  The matching fragment for the ``topic0``.
11909	*/
11910	fragment;
11911	/**
11912	*  The name of the Event.
11913	*/
11914	name;
11915	/**
11916	*  The full Event signature.
11917	*/
11918	signature;
11919	/**
11920	*  The topic hash for the Event.
11921	*/
11922	topic;
11923	/**
11924	*  The arguments passed into the Event with ``emit``.
11925	*/
11926	args;
11927	/**
11928	*  @_ignore:
11929	*/
11930	constructor(fragment, topic, args) {
11931		const name = fragment.name, signature = fragment.format();
11932		defineProperties(this, {
11933			fragment,
11934			name,
11935			signature,
11936			topic,
11937			args
11938		});
11939	}
11940};
11941/**
11942*  When using the [[Interface-parseTransaction]] to automatically match
11943*  a transaction data to its function for parsing,
11944*  a **TransactionDescription** is returned.
11945*/
11946var TransactionDescription = class {
11947	/**
11948	*  The matching fragment from the transaction ``data``.
11949	*/
11950	fragment;
11951	/**
11952	*  The name of the Function from the transaction ``data``.
11953	*/
11954	name;
11955	/**
11956	*  The arguments passed to the Function from the transaction ``data``.
11957	*/
11958	args;
11959	/**
11960	*  The full Function signature from the transaction ``data``.
11961	*/
11962	signature;
11963	/**
11964	*  The selector for the Function from the transaction ``data``.
11965	*/
11966	selector;
11967	/**
11968	*  The ``value`` (in wei) from the transaction.
11969	*/
11970	value;
11971	/**
11972	*  @_ignore:
11973	*/
11974	constructor(fragment, selector, args, value) {
11975		const name = fragment.name, signature = fragment.format();
11976		defineProperties(this, {
11977			fragment,
11978			name,
11979			args,
11980			signature,
11981			selector,
11982			value
11983		});
11984	}
11985};
11986/**
11987*  When using the [[Interface-parseError]] to automatically match an
11988*  error for a call result for parsing, an **ErrorDescription** is returned.
11989*/
11990var ErrorDescription = class {
11991	/**
11992	*  The matching fragment.
11993	*/
11994	fragment;
11995	/**
11996	*  The name of the Error.
11997	*/
11998	name;
11999	/**
12000	*  The arguments passed to the Error with ``revert``.
12001	*/
12002	args;
12003	/**
12004	*  The full Error signature.
12005	*/
12006	signature;
12007	/**
12008	*  The selector for the Error.
12009	*/
12010	selector;
12011	/**
12012	*  @_ignore:
12013	*/
12014	constructor(fragment, selector, args) {
12015		const name = fragment.name, signature = fragment.format();
12016		defineProperties(this, {
12017			fragment,
12018			name,
12019			args,
12020			signature,
12021			selector
12022		});
12023	}
12024};
12025/**
12026*  An **Indexed** is used as a value when a value that does not
12027*  fit within a topic (i.e. not a fixed-length, 32-byte type). It
12028*  is the ``keccak256`` of the value, and used for types such as
12029*  arrays, tuples, bytes and strings.
12030*/
12031var Indexed = class {
12032	/**
12033	*  The ``keccak256`` of the value logged.
12034	*/
12035	hash;
12036	/**
12037	*  @_ignore:
12038	*/
12039	_isIndexed;
12040	/**
12041	*  Returns ``true`` if %%value%% is an **Indexed**.
12042	*
12043	*  This provides a Type Guard for property access.
12044	*/
12045	static isIndexed(value) {
12046		return !!(value && value._isIndexed);
12047	}
12048	/**
12049	*  @_ignore:
12050	*/
12051	constructor(hash) {
12052		defineProperties(this, {
12053			hash,
12054			_isIndexed: true
12055		});
12056	}
12057};
12058var PanicReasons = {
12059	"0": "generic panic",
12060	"1": "assert(false)",
12061	"17": "arithmetic overflow",
12062	"18": "division or modulo by zero",
12063	"33": "enum overflow",

12064	"34": "invalid encoded storage byte array accessed",
12065	"49": "out-of-bounds array access; popping on an empty array",
12066	"50": "out-of-bounds access of an array or bytesN",
12067	"65": "out of memory",
12068	"81": "uninitialized function"
12069};
12070var BuiltinErrors = {
12071	"0x08c379a0": {
12072		signature: "Error(string)",
12073		name: "Error",
12074		inputs: ["string"],
12075		reason: (message) => {
12076			return `reverted with reason string ${JSON.stringify(message)}`;
12077		}
12078	},
12079	"0x4e487b71": {
12080		signature: "Panic(uint256)",
12081		name: "Panic",
12082		inputs: ["uint256"],
12083		reason: (code) => {
12084			let reason = "unknown panic code";
12085			if (code >= 0 && code <= 255 && PanicReasons[code.toString()]) reason = PanicReasons[code.toString()];
12086			return `reverted with panic code 0x${code.toString(16)} (${reason})`;
12087		}
12088	}
12089};
12090/**
12091*  An Interface abstracts many of the low-level details for
12092*  encoding and decoding the data on the blockchain.
12093*
12094*  An ABI provides information on how to encode data to send to
12095*  a Contract, how to decode the results and events and how to
12096*  interpret revert errors.
12097*
12098*  The ABI can be specified by [any supported format](InterfaceAbi).
12099*/
12100var Interface = class Interface {
12101	/**
12102	*  All the Contract ABI members (i.e. methods, events, errors, etc).
12103	*/
12104	fragments;
12105	/**
12106	*  The Contract constructor.
12107	*/
12108	deploy;
12109	/**
12110	*  The Fallback method, if any.
12111	*/
12112	fallback;
12113	/**
12114	*  If receiving ether is supported.
12115	*/
12116	receive;
12117	#errors;
12118	#events;
12119	#functions;
12120	#abiCoder;
12121	/**
12122	*  Create a new Interface for the %%fragments%%.
12123	*/
12124	constructor(fragments) {
12125		let abi = [];
12126		if (typeof fragments === "string") abi = JSON.parse(fragments);
12127		else abi = fragments;
12128		this.#functions = /* @__PURE__ */ new Map();
12129		this.#errors = /* @__PURE__ */ new Map();
12130		this.#events = /* @__PURE__ */ new Map();
12131		const frags = [];
12132		for (const a of abi) try {
12133			frags.push(Fragment.from(a));
12134		} catch (error) {
12135			console.log(`[Warning] Invalid Fragment ${JSON.stringify(a)}:`, error.message);
12136		}
12137		defineProperties(this, { fragments: Object.freeze(frags) });
12138		let fallback = null;
12139		let receive = false;
12140		this.#abiCoder = this.getAbiCoder();
12141		this.fragments.forEach((fragment, index) => {
12142			let bucket;
12143			switch (fragment.type) {
12144				case "constructor":
12145					if (this.deploy) {
12146						console.log("duplicate definition - constructor");
12147						return;
12148					}
12149					defineProperties(this, { deploy: fragment });
12150					return;
12151				case "fallback":
12152					if (fragment.inputs.length === 0) receive = true;
12153					else {
12154						assertArgument(!fallback || fragment.payable !== fallback.payable, "conflicting fallback fragments", `fragments[${index}]`, fragment);
12155						fallback = fragment;
12156						receive = fallback.payable;
12157					}
12158					return;
12159				case "function":
12160					bucket = this.#functions;
12161					break;
12162				case "event":
12163					bucket = this.#events;
12164					break;
12165				case "error":
12166					bucket = this.#errors;
12167					break;
12168				default: return;
12169			}
12170			const signature = fragment.format();
12171			if (bucket.has(signature)) return;
12172			bucket.set(signature, fragment);
12173		});
12174		if (!this.deploy) defineProperties(this, { deploy: ConstructorFragment.from("constructor()") });
12175		defineProperties(this, {
12176			fallback,
12177			receive
12178		});
12179	}
12180	/**
12181	*  Returns the entire Human-Readable ABI, as an array of
12182	*  signatures, optionally as %%minimal%% strings, which
12183	*  removes parameter names and unneceesary spaces.
12184	*/
12185	format(minimal) {
12186		const format = minimal ? "minimal" : "full";
12187		return this.fragments.map((f) => f.format(format));
12188	}
12189	/**
12190	*  Return the JSON-encoded ABI. This is the format Solidiy
12191	*  returns.
12192	*/
12193	formatJson() {
12194		const abi = this.fragments.map((f) => f.format("json"));
12195		return JSON.stringify(abi.map((j) => JSON.parse(j)));
12196	}
12197	/**
12198	*  The ABI coder that will be used to encode and decode binary
12199	*  data.
12200	*/
12201	getAbiCoder() {
12202		return AbiCoder.defaultAbiCoder();
12203	}
12204	#getFunction(key, values, forceUnique) {
12205		if (isHexString(key)) {
12206			const selector = key.toLowerCase();
12207			for (const fragment of this.#functions.values()) if (selector === fragment.selector) return fragment;
12208			return null;
12209		}
12210		if (key.indexOf("(") === -1) {
12211			const matching = [];
12212			for (const [name, fragment] of this.#functions) if (name.split("(")[0] === key) matching.push(fragment);
12213			if (values) {

12214				const lastValue = values.length > 0 ? values[values.length - 1] : null;
12215				let valueLength = values.length;
12216				let allowOptions = true;
12217				if (Typed.isTyped(lastValue) && lastValue.type === "overrides") {
12218					allowOptions = false;
12219					valueLength--;
12220				}
12221				for (let i = matching.length - 1; i >= 0; i--) {
12222					const inputs = matching[i].inputs.length;
12223					if (inputs !== valueLength && (!allowOptions || inputs !== valueLength - 1)) matching.splice(i, 1);
12224				}
12225				for (let i = matching.length - 1; i >= 0; i--) {
12226					const inputs = matching[i].inputs;
12227					for (let j = 0; j < values.length; j++) {
12228						if (!Typed.isTyped(values[j])) continue;
12229						if (j >= inputs.length) {
12230							if (values[j].type === "overrides") continue;
12231							matching.splice(i, 1);
12232							break;
12233						}
12234						if (values[j].type !== inputs[j].baseType) {
12235							matching.splice(i, 1);
12236							break;
12237						}
12238					}
12239				}
12240			}
12241			if (matching.length === 1 && values && values.length !== matching[0].inputs.length) {
12242				const lastArg = values[values.length - 1];
12243				if (lastArg == null || Array.isArray(lastArg) || typeof lastArg !== "object") matching.splice(0, 1);
12244			}
12245			if (matching.length === 0) return null;
12246			if (matching.length > 1 && forceUnique) assertArgument(false, `ambiguous function description (i.e. matches ${matching.map((m) => JSON.stringify(m.format())).join(", ")})`, "key", key);
12247			return matching[0];
12248		}
12249		const result = this.#functions.get(FunctionFragment.from(key).format());
12250		if (result) return result;
12251		return null;
12252	}
12253	/**
12254	*  Get the function name for %%key%%, which may be a function selector,
12255	*  function name or function signature that belongs to the ABI.
12256	*/
12257	getFunctionName(key) {
12258		const fragment = this.#getFunction(key, null, false);
12259		assertArgument(fragment, "no matching function", "key", key);
12260		return fragment.name;
12261	}
12262	/**
12263	*  Returns true if %%key%% (a function selector, function name or
12264	*  function signature) is present in the ABI.
12265	*
12266	*  In the case of a function name, the name may be ambiguous, so
12267	*  accessing the [[FunctionFragment]] may require refinement.
12268	*/
12269	hasFunction(key) {
12270		return !!this.#getFunction(key, null, false);
12271	}
12272	/**
12273	*  Get the [[FunctionFragment]] for %%key%%, which may be a function
12274	*  selector, function name or function signature that belongs to the ABI.
12275	*
12276	*  If %%values%% is provided, it will use the Typed API to handle
12277	*  ambiguous cases where multiple functions match by name.
12278	*
12279	*  If the %%key%% and %%values%% do not refine to a single function in
12280	*  the ABI, this will throw.
12281	*/
12282	getFunction(key, values) {
12283		return this.#getFunction(key, values || null, true);
12284	}
12285	/**
12286	*  Iterate over all functions, calling %%callback%%, sorted by their name.
12287	*/
12288	forEachFunction(callback) {
12289		const names = Array.from(this.#functions.keys());
12290		names.sort((a, b) => a.localeCompare(b));
12291		for (let i = 0; i < names.length; i++) {
12292			const name = names[i];
12293			callback(this.#functions.get(name), i);
12294		}
12295	}
12296	#getEvent(key, values, forceUnique) {
12297		if (isHexString(key)) {
12298			const eventTopic = key.toLowerCase();
12299			for (const fragment of this.#events.values()) if (eventTopic === fragment.topicHash) return fragment;
12300			return null;
12301		}
12302		if (key.indexOf("(") === -1) {
12303			const matching = [];
12304			for (const [name, fragment] of this.#events) if (name.split("(")[0] === key) matching.push(fragment);
12305			if (values) {
12306				for (let i = matching.length - 1; i >= 0; i--) if (matching[i].inputs.length < values.length) matching.splice(i, 1);
12307				for (let i = matching.length - 1; i >= 0; i--) {
12308					const inputs = matching[i].inputs;
12309					for (let j = 0; j < values.length; j++) {
12310						if (!Typed.isTyped(values[j])) continue;
12311						if (values[j].type !== inputs[j].baseType) {
12312							matching.splice(i, 1);
12313							break;
12314						}
12315					}
12316				}
12317			}
12318			if (matching.length === 0) return null;
12319			if (matching.length > 1 && forceUnique) assertArgument(false, `ambiguous event description (i.e. matches ${matching.map((m) => JSON.stringify(m.format())).join(", ")})`, "key", key);
12320			return matching[0];
12321		}
12322		const result = this.#events.get(EventFragment.from(key).format());
12323		if (result) return result;
12324		return null;
12325	}

12326	/**
12327	*  Get the event name for %%key%%, which may be a topic hash,
12328	*  event name or event signature that belongs to the ABI.
12329	*/
12330	getEventName(key) {
12331		const fragment = this.#getEvent(key, null, false);
12332		assertArgument(fragment, "no matching event", "key", key);
12333		return fragment.name;
12334	}
12335	/**
12336	*  Returns true if %%key%% (an event topic hash, event name or
12337	*  event signature) is present in the ABI.
12338	*
12339	*  In the case of an event name, the name may be ambiguous, so
12340	*  accessing the [[EventFragment]] may require refinement.
12341	*/
12342	hasEvent(key) {
12343		return !!this.#getEvent(key, null, false);
12344	}
12345	/**
12346	*  Get the [[EventFragment]] for %%key%%, which may be a topic hash,
12347	*  event name or event signature that belongs to the ABI.
12348	*
12349	*  If %%values%% is provided, it will use the Typed API to handle
12350	*  ambiguous cases where multiple events match by name.
12351	*
12352	*  If the %%key%% and %%values%% do not refine to a single event in
12353	*  the ABI, this will throw.
12354	*/
12355	getEvent(key, values) {
12356		return this.#getEvent(key, values || null, true);
12357	}
12358	/**
12359	*  Iterate over all events, calling %%callback%%, sorted by their name.
12360	*/
12361	forEachEvent(callback) {
12362		const names = Array.from(this.#events.keys());
12363		names.sort((a, b) => a.localeCompare(b));
12364		for (let i = 0; i < names.length; i++) {
12365			const name = names[i];
12366			callback(this.#events.get(name), i);
12367		}
12368	}
12369	/**
12370	*  Get the [[ErrorFragment]] for %%key%%, which may be an error
12371	*  selector, error name or error signature that belongs to the ABI.
12372	*
12373	*  If %%values%% is provided, it will use the Typed API to handle
12374	*  ambiguous cases where multiple errors match by name.
12375	*
12376	*  If the %%key%% and %%values%% do not refine to a single error in
12377	*  the ABI, this will throw.
12378	*/
12379	getError(key, values) {
12380		if (isHexString(key)) {
12381			const selector = key.toLowerCase();
12382			if (BuiltinErrors[selector]) return ErrorFragment.from(BuiltinErrors[selector].signature);
12383			for (const fragment of this.#errors.values()) if (selector === fragment.selector) return fragment;
12384			return null;
12385		}
12386		if (key.indexOf("(") === -1) {
12387			const matching = [];
12388			for (const [name, fragment] of this.#errors) if (name.split("(")[0] === key) matching.push(fragment);
12389			if (matching.length === 0) {
12390				if (key === "Error") return ErrorFragment.from("error Error(string)");
12391				if (key === "Panic") return ErrorFragment.from("error Panic(uint256)");
12392				return null;
12393			} else if (matching.length > 1) assertArgument(false, `ambiguous error description (i.e. ${matching.map((m) => JSON.stringify(m.format())).join(", ")})`, "name", key);
12394			return matching[0];
12395		}
12396		key = ErrorFragment.from(key).format();
12397		if (key === "Error(string)") return ErrorFragment.from("error Error(string)");
12398		if (key === "Panic(uint256)") return ErrorFragment.from("error Panic(uint256)");
12399		const result = this.#errors.get(key);
12400		if (result) return result;
12401		return null;
12402	}
12403	/**
12404	*  Iterate over all errors, calling %%callback%%, sorted by their name.
12405	*/
12406	forEachError(callback) {
12407		const names = Array.from(this.#errors.keys());
12408		names.sort((a, b) => a.localeCompare(b));
12409		for (let i = 0; i < names.length; i++) {
12410			const name = names[i];
12411			callback(this.#errors.get(name), i);
12412		}
12413	}
12414	_decodeParams(params, data) {
12415		return this.#abiCoder.decode(params, data);
12416	}
12417	_encodeParams(params, values) {
12418		return this.#abiCoder.encode(params, values);
12419	}
12420	/**
12421	*  Encodes a ``tx.data`` object for deploying the Contract with
12422	*  the %%values%% as the constructor arguments.
12423	*/
12424	encodeDeploy(values) {
12425		return this._encodeParams(this.deploy.inputs, values || []);
12426	}
12427	/**
12428	*  Decodes the result %%data%% (e.g. from an ``eth_call``) for the
12429	*  specified error (see [[getError]] for valid values for
12430	*  %%key%%).
12431	*
12432	*  Most developers should prefer the [[parseCallResult]] method instead,
12433	*  which will automatically detect a ``CALL_EXCEPTION`` and throw the
12434	*  corresponding error.
12435	*/
12436	decodeErrorResult(fragment, data) {
12437		if (typeof fragment === "string") {
12438			const f = this.getError(fragment);
12439			assertArgument(f, "unknown error", "fragment", fragment);
12440			fragment = f;
12441		}
12442		assertArgument(dataSlice(data, 0, 4) === fragment.selector, `data signature does not match error ${fragment.name}.`, "data", data);
12443		return this._decodeParams(fragment.inputs, dataSlice(data, 4));
12444	}
12445	/**
12446	*  Encodes the transaction revert data for a call result that
12447	*  reverted from the the Contract with the sepcified %%error%%
12448	*  (see [[getError]] for valid values for %%fragment%%) with the %%values%%.
12449	*
12450	*  This is generally not used by most developers, unless trying to mock
12451	*  a result from a Contract.
12452	*/
12453	encodeErrorResult(fragment, values) {
12454		if (typeof fragment === "string") {
12455			const f = this.getError(fragment);
12456			assertArgument(f, "unknown error", "fragment", fragment);
12457			fragment = f;
12458		}
12459		return concat([fragment.selector, this._encodeParams(fragment.inputs, values || [])]);
12460	}
12461	/**
12462	*  Decodes the %%data%% from a transaction ``tx.data`` for
12463	*  the function specified (see [[getFunction]] for valid values
12464	*  for %%fragment%%).
12465	*
12466	*  Most developers should prefer the [[parseTransaction]] method
12467	*  instead, which will automatically detect the fragment.
12468	*/
12469	decodeFunctionData(fragment, data) {
12470		if (typeof fragment === "string") {
12471			const f = this.getFunction(fragment);
12472			assertArgument(f, "unknown function", "fragment", fragment);
12473			fragment = f;
12474		}
12475		assertArgument(dataSlice(data, 0, 4) === fragment.selector, `data signature does not match function ${fragment.name}.`, "data", data);
12476		return this._decodeParams(fragment.inputs, dataSlice(data, 4));
12477	}
12478	/**
12479	*  Encodes the ``tx.data`` for a transaction that calls the function
12480	*  specified (see [[getFunction]] for valid values for %%fragment%%) with
12481	*  the %%values%%.
12482	*/
12483	encodeFunctionData(fragment, values) {
12484		if (typeof fragment === "string") {
12485			const f = this.getFunction(fragment);
12486			assertArgument(f, "unknown function", "fragment", fragment);
12487			fragment = f;
12488		}
12489		return concat([fragment.selector, this._encodeParams(fragment.inputs, values || [])]);
12490	}
12491	/**
12492	*  Decodes the result %%data%% (e.g. from an ``eth_call``) for the
12493	*  specified function (see [[getFunction]] for valid values for
12494	*  %%key%%).
12495	*
12496	*  Most developers should prefer the [[parseCallResult]] method instead,
12497	*  which will automatically detect a ``CALL_EXCEPTION`` and throw the
12498	*  corresponding error.
12499	*/
12500	decodeFunctionResult(fragment, data) {
12501		if (typeof fragment === "string") {
12502			const f = this.getFunction(fragment);
12503			assertArgument(f, "unknown function", "fragment", fragment);
12504			fragment = f;
12505		}

12506		let message = "invalid length for result data";
12507		const bytes = getBytesCopy(data);
12508		if (bytes.length % 32 === 0) try {
12509			return this.#abiCoder.decode(fragment.outputs, bytes);
12510		} catch (error) {
12511			message = "could not decode result data";
12512		}
12513		assert(false, message, "BAD_DATA", {
12514			value: hexlify(bytes),
12515			info: {
12516				method: fragment.name,
12517				signature: fragment.format()
12518			}
12519		});
12520	}
12521	makeError(_data, tx) {
12522		const data = getBytes(_data, "data");
12523		const error = AbiCoder.getBuiltinCallException("call", tx, data);
12524		if (error.message.startsWith("execution reverted (unknown custom error)")) {
12525			const selector = hexlify(data.slice(0, 4));
12526			const ef = this.getError(selector);
12527			if (ef) try {
12528				const args = this.#abiCoder.decode(ef.inputs, data.slice(4));
12529				error.revert = {
12530					name: ef.name,
12531					signature: ef.format(),
12532					args
12533				};
12534				error.reason = error.revert.signature;
12535				error.message = `execution reverted: ${error.reason}`;
12536			} catch (e) {
12537				error.message = `execution reverted (coult not decode custom error)`;
12538			}
12539		}
12540		const parsed = this.parseTransaction(tx);
12541		if (parsed) error.invocation = {
12542			method: parsed.name,
12543			signature: parsed.signature,
12544			args: parsed.args
12545		};
12546		return error;
12547	}
12548	/**
12549	*  Encodes the result data (e.g. from an ``eth_call``) for the
12550	*  specified function (see [[getFunction]] for valid values
12551	*  for %%fragment%%) with %%values%%.
12552	*
12553	*  This is generally not used by most developers, unless trying to mock
12554	*  a result from a Contract.
12555	*/
12556	encodeFunctionResult(fragment, values) {
12557		if (typeof fragment === "string") {
12558			const f = this.getFunction(fragment);
12559			assertArgument(f, "unknown function", "fragment", fragment);
12560			fragment = f;
12561		}
12562		return hexlify(this.#abiCoder.encode(fragment.outputs, values || []));
12563	}
12564	encodeFilterTopics(fragment, values) {
12565		if (typeof fragment === "string") {
12566			const f = this.getEvent(fragment);
12567			assertArgument(f, "unknown event", "eventFragment", fragment);
12568			fragment = f;
12569		}
12570		assert(values.length <= fragment.inputs.length, `too many arguments for ${fragment.format()}`, "UNEXPECTED_ARGUMENT", {
12571			count: values.length,
12572			expectedCount: fragment.inputs.length
12573		});
12574		const topics = [];
12575		if (!fragment.anonymous) topics.push(fragment.topicHash);
12576		const encodeTopic = (param, value) => {
12577			if (param.type === "string") return id(value);
12578			else if (param.type === "bytes") return keccak256(hexlify(value));
12579			if (param.type === "bool" && typeof value === "boolean") value = value ? "0x01" : "0x00";
12580			else if (param.type.match(/^u?int/)) value = toBeHex(value);
12581			else if (param.type.match(/^bytes/)) value = zeroPadBytes(value, 32);
12582			else if (param.type === "address") this.#abiCoder.encode(["address"], [value]);
12583			return zeroPadValue(hexlify(value), 32);
12584		};
12585		values.forEach((value, index) => {
12586			const param = fragment.inputs[index];
12587			if (!param.indexed) {
12588				assertArgument(value == null, "cannot filter non-indexed parameters; must be null", "contract." + param.name, value);
12589				return;
12590			}
12591			if (value == null) topics.push(null);
12592			else if (param.baseType === "array" || param.baseType === "tuple") assertArgument(false, "filtering with tuples or arrays not supported", "contract." + param.name, value);
12593			else if (Array.isArray(value)) topics.push(value.map((value) => encodeTopic(param, value)));
12594			else topics.push(encodeTopic(param, value));
12595		});
12596		while (topics.length && topics[topics.length - 1] === null) topics.pop();
12597		return topics;
12598	}
12599	encodeEventLog(fragment, values) {
12600		if (typeof fragment === "string") {
12601			const f = this.getEvent(fragment);
12602			assertArgument(f, "unknown event", "eventFragment", fragment);
12603			fragment = f;
12604		}
12605		const topics = [];
12606		const dataTypes = [];
12607		const dataValues = [];
12608		if (!fragment.anonymous) topics.push(fragment.topicHash);
12609		assertArgument(values.length === fragment.inputs.length, "event arguments/values mismatch", "values", values);
12610		fragment.inputs.forEach((param, index) => {
12611			const value = values[index];
12612			if (param.indexed) {
12613				if (param.type === "string") topics.push(id(value));
12614				else if (param.type === "bytes") topics.push(keccak256(value));
12615				else if (param.baseType === "tuple" || param.baseType === "array") throw new Error("not implemented");
12616				else topics.push(this.#abiCoder.encode([param.type], [value]));
12617			} else {
12618				dataTypes.push(param);
12619				dataValues.push(value);
12620			}
12621		});
12622		return {

12623			data: this.#abiCoder.encode(dataTypes, dataValues),
12624			topics
12625		};
12626	}
12627	decodeEventLog(fragment, data, topics) {
12628		if (typeof fragment === "string") {
12629			const f = this.getEvent(fragment);
12630			assertArgument(f, "unknown event", "eventFragment", fragment);
12631			fragment = f;
12632		}
12633		if (topics != null && !fragment.anonymous) {
12634			const eventTopic = fragment.topicHash;
12635			assertArgument(isHexString(topics[0], 32) && topics[0].toLowerCase() === eventTopic, "fragment/topic mismatch", "topics[0]", topics[0]);
12636			topics = topics.slice(1);
12637		}
12638		const indexed = [];
12639		const nonIndexed = [];
12640		const dynamic = [];
12641		fragment.inputs.forEach((param, index) => {
12642			if (param.indexed) {
12643				if (param.type === "string" || param.type === "bytes" || param.baseType === "tuple" || param.baseType === "array") {
12644					indexed.push(ParamType.from({
12645						type: "bytes32",
12646						name: param.name
12647					}));
12648					dynamic.push(true);
12649				} else {
12650					indexed.push(param);
12651					dynamic.push(false);
12652				}
12653			} else {
12654				nonIndexed.push(param);
12655				dynamic.push(false);
12656			}
12657		});
12658		const resultIndexed = topics != null ? this.#abiCoder.decode(indexed, concat(topics)) : null;
12659		const resultNonIndexed = this.#abiCoder.decode(nonIndexed, data, true);
12660		const values = [];
12661		const keys = [];
12662		let nonIndexedIndex = 0, indexedIndex = 0;
12663		fragment.inputs.forEach((param, index) => {
12664			let value = null;
12665			if (param.indexed) {
12666				if (resultIndexed == null) value = new Indexed(null);
12667				else if (dynamic[index]) value = new Indexed(resultIndexed[indexedIndex++]);
12668				else try {
12669					value = resultIndexed[indexedIndex++];
12670				} catch (error) {
12671					value = error;
12672				}
12673			} else try {
12674				value = resultNonIndexed[nonIndexedIndex++];
12675			} catch (error) {
12676				value = error;
12677			}
12678			values.push(value);
12679			keys.push(param.name || null);
12680		});
12681		return Result.fromItems(values, keys);
12682	}
12683	/**
12684	*  Parses a transaction, finding the matching function and extracts
12685	*  the parameter values along with other useful function details.
12686	*
12687	*  If the matching function cannot be found, return null.
12688	*/
12689	parseTransaction(tx) {
12690		const data = getBytes(tx.data, "tx.data");
12691		const value = getBigInt(tx.value != null ? tx.value : 0, "tx.value");
12692		const fragment = this.getFunction(hexlify(data.slice(0, 4)));
12693		if (!fragment) return null;
12694		const args = this.#abiCoder.decode(fragment.inputs, data.slice(4));
12695		return new TransactionDescription(fragment, fragment.selector, args, value);
12696	}
12697	parseCallResult(data) {
12698		throw new Error("@TODO");
12699	}
12700	/**
12701	*  Parses a receipt log, finding the matching event and extracts
12702	*  the parameter values along with other useful event details.
12703	*
12704	*  If the matching event cannot be found, returns null.
12705	*/
12706	parseLog(log) {
12707		const fragment = this.getEvent(log.topics[0]);
12708		if (!fragment || fragment.anonymous) return null;
12709		return new LogDescription(fragment, fragment.topicHash, this.decodeEventLog(fragment, log.data, log.topics));
12710	}
12711	/**
12712	*  Parses a revert data, finding the matching error and extracts
12713	*  the parameter values along with other useful error details.
12714	*
12715	*  If the matching error cannot be found, returns null.
12716	*/
12717	parseError(data) {
12718		const hexData = hexlify(data);
12719		const fragment = this.getError(dataSlice(hexData, 0, 4));
12720		if (!fragment) return null;
12721		const args = this.#abiCoder.decode(fragment.inputs, dataSlice(hexData, 4));
12722		return new ErrorDescription(fragment, fragment.selector, args);
12723	}
12724	/**
12725	*  Creates a new [[Interface]] from the ABI %%value%%.
12726	*
12727	*  The %%value%% may be provided as an existing [[Interface]] object,
12728	*  a JSON-encoded ABI or any Human-Readable ABI format.
12729	*/
12730	static from(value) {
12731		if (value instanceof Interface) return value;
12732		if (typeof value === "string") return new Interface(JSON.parse(value));
12733		if (typeof value.formatJson === "function") return new Interface(value.formatJson());
12734		if (typeof value.format === "function") return new Interface(value.format("json"));
12735		return new Interface(value);
12736	}
12737};
12738//#endregion
12739//#region node_modules/ethers/lib.esm/providers/provider.js
12740var BN_0$2 = BigInt(0);
12741function getValue(value) {
12742	if (value == null) return null;
12743	return value;
12744}
12745function toJson(value) {
12746	if (value == null) return null;
12747	return value.toString();
12748}
12749/**
12750*  A **FeeData** wraps all the fee-related values associated with
12751*  the network.
12752*/
12753var FeeData = class {
12754	/**
12755	*  The gas price for legacy networks.
12756	*/
12757	gasPrice;
12758	/**
12759	*  The maximum fee to pay per gas.
12760	*
12761	*  The base fee per gas is defined by the network and based on
12762	*  congestion, increasing the cost during times of heavy load
12763	*  and lowering when less busy.
12764	*
12765	*  The actual fee per gas will be the base fee for the block
12766	*  and the priority fee, up to the max fee per gas.
12767	*
12768	*  This will be ``null`` on legacy networks (i.e. [pre-EIP-1559](link-eip-1559))
12769	*/
12770	maxFeePerGas;
12771	/**
12772	*  The additional amout to pay per gas to encourage a validator
12773	*  to include the transaction.
12774	*
12775	*  The purpose of this is to compensate the validator for the
12776	*  adjusted risk for including a given transaction.
12777	*
12778	*  This will be ``null`` on legacy networks (i.e. [pre-EIP-1559](link-eip-1559))
12779	*/
12780	maxPriorityFeePerGas;
12781	/**
12782	*  Creates a new FeeData for %%gasPrice%%, %%maxFeePerGas%% and
12783	*  %%maxPriorityFeePerGas%%.
12784	*/
12785	constructor(gasPrice, maxFeePerGas, maxPriorityFeePerGas) {
12786		defineProperties(this, {
12787			gasPrice: getValue(gasPrice),
12788			maxFeePerGas: getValue(maxFeePerGas),
12789			maxPriorityFeePerGas: getValue(maxPriorityFeePerGas)
12790		});
12791	}
12792	/**
12793	*  Returns a JSON-friendly value.
12794	*/
12795	toJSON() {
12796		const { gasPrice, maxFeePerGas, maxPriorityFeePerGas } = this;
12797		return {
12798			_type: "FeeData",
12799			gasPrice: toJson(gasPrice),
12800			maxFeePerGas: toJson(maxFeePerGas),
12801			maxPriorityFeePerGas: toJson(maxPriorityFeePerGas)
12802		};
12803	}
12804};
12805/**
12806*  Returns a copy of %%req%% with all properties coerced to their strict
12807*  types.
12808*/
12809function copyRequest(req) {
12810	const result = {};
12811	if (req.to) result.to = req.to;
12812	if (req.from) result.from = req.from;
12813	if (req.data) result.data = hexlify(req.data);
12814	const bigIntKeys = "chainId,gasLimit,gasPrice,maxFeePerBlobGas,maxFeePerGas,maxPriorityFeePerGas,value".split(/,/);
12815	for (const key of bigIntKeys) {
12816		if (!(key in req) || req[key] == null) continue;
12817		result[key] = getBigInt(req[key], `request.${key}`);
12818	}
12819	const numberKeys = "type,nonce".split(/,/);
12820	for (const key of numberKeys) {
12821		if (!(key in req) || req[key] == null) continue;
12822		result[key] = getNumber(req[key], `request.${key}`);
12823	}
12824	if (req.accessList) result.accessList = accessListify(req.accessList);
12825	if (req.authorizationList) result.authorizationList = req.authorizationList.slice();
12826	if ("blockTag" in req) result.blockTag = req.blockTag;
12827	if ("enableCcipRead" in req) result.enableCcipRead = !!req.enableCcipRead;
12828	if ("customData" in req) result.customData = req.customData;
12829	if ("blobVersionedHashes" in req && req.blobVersionedHashes) result.blobVersionedHashes = req.blobVersionedHashes.slice();
12830	if ("kzg" in req) result.kzg = req.kzg;
12831	if ("blobWrapperVersion" in req) result.blobWrapperVersion = req.blobWrapperVersion;
12832	if ("blobs" in req && req.blobs) result.blobs = req.blobs.map((b) => {
12833		if (isBytesLike(b)) return hexlify(b);
12834		return Object.assign({}, b);
12835	});
12836	return result;
12837}
12838/**
12839*  A **Block** represents the data associated with a full block on
12840*  Ethereum.
12841*/
12842var Block = class {
12843	/**
12844	*  The provider connected to the block used to fetch additional details
12845	*  if necessary.
12846	*/
12847	provider;
12848	/**
12849	*  The block number, sometimes called the block height. This is a
12850	*  sequential number that is one higher than the parent block.
12851	*/
12852	number;
12853	/**
12854	*  The block hash.
12855	*
12856	*  This hash includes all properties, so can be safely used to identify
12857	*  an exact set of block properties.
12858	*/
12859	hash;
12860	/**
12861	*  The timestamp for this block, which is the number of seconds since
12862	*  epoch that this block was included.
12863	*/
12864	timestamp;
12865	/**
12866	*  The block hash of the parent block.
12867	*/
12868	parentHash;
12869	/**
12870	*  The hash tree root of the parent beacon block for the given
12871	*  execution block. See [[link-eip-4788]].
12872	*/
12873	parentBeaconBlockRoot;
12874	/**
12875	*  The nonce.
12876	*
12877	*  On legacy networks, this is the random number inserted which
12878	*  permitted the difficulty target to be reached.
12879	*/
12880	nonce;
12881	/**
12882	*  The difficulty target.
12883	*
12884	*  On legacy networks, this is the proof-of-work target required
12885	*  for a block to meet the protocol rules to be included.
12886	*
12887	*  On modern networks, this is a random number arrived at using
12888	*  randao.  @TODO: Find links?
12889	*/
12890	difficulty;
12891	/**
12892	*  The total gas limit for this block.
12893	*/
12894	gasLimit;
12895	/**
12896	*  The total gas used in this block.
12897	*/
12898	gasUsed;
12899	/**
12900	*  The root hash for the global state after applying changes
12901	*  in this block.
12902	*/
12903	stateRoot;
12904	/**
12905	*  The hash of the transaction receipts trie.
12906	*/
12907	receiptsRoot;
12908	/**
12909	*  The hash of the transactions.
12910	*/
12911	transactionsRoot;
12912	/**
12913	*  The total amount of blob gas consumed by the transactions
12914	*  within the block. See [[link-eip-4844]].
12915	*/
12916	blobGasUsed;
12917	/**

12918	*  The running total of blob gas consumed in excess of the
12919	*  target, prior to the block. See [[link-eip-4844]].
12920	*/
12921	excessBlobGas;
12922	/**
12923	*  The miner coinbase address, wihch receives any subsidies for
12924	*  including this block.
12925	*/
12926	miner;
12927	/**
12928	*  The latest RANDAO mix of the post beacon state of
12929	*  the previous block.
12930	*/
12931	prevRandao;
12932	/**
12933	*  Any extra data the validator wished to include.
12934	*/
12935	extraData;
12936	/**
12937	*  The base fee per gas that all transactions in this block were
12938	*  charged.
12939	*
12940	*  This adjusts after each block, depending on how congested the network
12941	*  is.
12942	*/
12943	baseFeePerGas;
12944	#transactions;
12945	/**
12946	*  Create a new **Block** object.
12947	*
12948	*  This should generally not be necessary as the unless implementing a
12949	*  low-level library.
12950	*/
12951	constructor(block, provider) {
12952		this.#transactions = block.transactions.map((tx) => {
12953			if (typeof tx !== "string") return new TransactionResponse(tx, provider);
12954			return tx;
12955		});
12956		defineProperties(this, {
12957			provider,
12958			hash: getValue(block.hash),
12959			number: block.number,
12960			timestamp: block.timestamp,
12961			parentHash: block.parentHash,
12962			parentBeaconBlockRoot: block.parentBeaconBlockRoot,
12963			nonce: block.nonce,
12964			difficulty: block.difficulty,
12965			gasLimit: block.gasLimit,
12966			gasUsed: block.gasUsed,
12967			blobGasUsed: block.blobGasUsed,
12968			excessBlobGas: block.excessBlobGas,
12969			miner: block.miner,
12970			prevRandao: getValue(block.prevRandao),
12971			extraData: block.extraData,
12972			baseFeePerGas: getValue(block.baseFeePerGas),
12973			stateRoot: block.stateRoot,
12974			receiptsRoot: block.receiptsRoot,
12975			transactionsRoot: block.transactionsRoot
12976		});
12977	}
12978	/**
12979	*  Returns the list of transaction hashes, in the order
12980	*  they were executed within the block.
12981	*/
12982	get transactions() {
12983		return this.#transactions.map((tx) => {
12984			if (typeof tx === "string") return tx;
12985			return tx.hash;
12986		});
12987	}
12988	/**
12989	*  Returns the complete transactions, in the order they
12990	*  were executed within the block.
12991	*
12992	*  This is only available for blocks which prefetched
12993	*  transactions, by passing ``true`` to %%prefetchTxs%%
12994	*  into [[Provider-getBlock]].
12995	*/
12996	get prefetchedTransactions() {
12997		const txs = this.#transactions.slice();
12998		if (txs.length === 0) return [];
12999		assert(typeof txs[0] === "object", "transactions were not prefetched with block request", "UNSUPPORTED_OPERATION", { operation: "transactionResponses()" });
13000		return txs;
13001	}
13002	/**
13003	*  Returns a JSON-friendly value.
13004	*/
13005	toJSON() {
13006		const { baseFeePerGas, difficulty, extraData, gasLimit, gasUsed, hash, miner, prevRandao, nonce, number, parentHash, parentBeaconBlockRoot, stateRoot, receiptsRoot, transactionsRoot, timestamp, transactions } = this;
13007		return {
13008			_type: "Block",
13009			baseFeePerGas: toJson(baseFeePerGas),
13010			difficulty: toJson(difficulty),
13011			extraData,
13012			gasLimit: toJson(gasLimit),
13013			gasUsed: toJson(gasUsed),
13014			blobGasUsed: toJson(this.blobGasUsed),
13015			excessBlobGas: toJson(this.excessBlobGas),
13016			hash,
13017			miner,
13018			prevRandao,
13019			nonce,
13020			number,
13021			parentHash,
13022			timestamp,
13023			parentBeaconBlockRoot,
13024			stateRoot,
13025			receiptsRoot,
13026			transactionsRoot,
13027			transactions
13028		};
13029	}
13030	[Symbol.iterator]() {
13031		let index = 0;
13032		const txs = this.transactions;
13033		return { next: () => {
13034			if (index < this.length) return {
13035				value: txs[index++],
13036				done: false
13037			};
13038			return {
13039				value: void 0,
13040				done: true
13041			};
13042		} };
13043	}
13044	/**
13045	*  The number of transactions in this block.
13046	*/
13047	get length() {
13048		return this.#transactions.length;
13049	}
13050	/**
13051	*  The [[link-js-date]] this block was included at.
13052	*/
13053	get date() {
13054		if (this.timestamp == null) return null;
13055		return /* @__PURE__ */ new Date(this.timestamp * 1e3);
13056	}
13057	/**
13058	*  Get the transaction at %%indexe%% within this block.
13059	*/
13060	async getTransaction(indexOrHash) {
13061		let tx = void 0;
13062		if (typeof indexOrHash === "number") tx = this.#transactions[indexOrHash];
13063		else {
13064			const hash = indexOrHash.toLowerCase();
13065			for (const v of this.#transactions) if (typeof v === "string") {
13066				if (v !== hash) continue;
13067				tx = v;
13068				break;
13069			} else {
13070				if (v.hash !== hash) continue;
13071				tx = v;
13072				break;
13073			}
13074		}
13075		if (tx == null) throw new Error("no such tx");
13076		if (typeof tx === "string") return await this.provider.getTransaction(tx);
13077		else return tx;
13078	}
13079	/**
13080	*  If a **Block** was fetched with a request to include the transactions
13081	*  this will allow synchronous access to those transactions.
13082	*
13083	*  If the transactions were not prefetched, this will throw.
13084	*/
13085	getPrefetchedTransaction(indexOrHash) {
13086		const txs = this.prefetchedTransactions;
13087		if (typeof indexOrHash === "number") return txs[indexOrHash];
13088		indexOrHash = indexOrHash.toLowerCase();
13089		for (const tx of txs) if (tx.hash === indexOrHash) return tx;
13090		assertArgument(false, "no matching transaction", "indexOrHash", indexOrHash);
13091	}
13092	/**
13093	*  Returns true if this block been mined. This provides a type guard
13094	*  for all properties on a [[MinedBlock]].
13095	*/
13096	isMined() {
13097		return !!this.hash;
13098	}
13099	/**
13100	*  Returns true if this block is an [[link-eip-2930]] block.
13101	*/
13102	isLondon() {
13103		return !!this.baseFeePerGas;
13104	}
13105	/**
13106	*  @_ignore:
13107	*/
13108	orphanedEvent() {
13109		if (!this.isMined()) throw new Error("");
13110		return createOrphanedBlockFilter(this);
13111	}
13112};
13113/**
13114*  A **Log** in Ethereum represents an event that has been included in a
13115*  transaction using the ``LOG*`` opcodes, which are most commonly used by
13116*  Solidity's emit for announcing events.
13117*/
13118var Log = class {
13119	/**
13120	*  The provider connected to the log used to fetch additional details
13121	*  if necessary.
13122	*/
13123	provider;
13124	/**
13125	*  The transaction hash of the transaction this log occurred in. Use the
13126	*  [[Log-getTransaction]] to get the [[TransactionResponse]].
13127	*/
13128	transactionHash;
13129	/**
13130	*  The block hash of the block this log occurred in. Use the
13131	*  [[Log-getBlock]] to get the [[Block]].
13132	*/
13133	blockHash;
13134	/**
13135	*  The block number of the block this log occurred in. It is preferred
13136	*  to use the [[Block-hash]] when fetching the related [[Block]],
13137	*  since in the case of an orphaned block, the block at that height may
13138	*  have changed.
13139	*/
13140	blockNumber;
13141	/**
13142	*  If the **Log** represents a block that was removed due to an orphaned
13143	*  block, this will be true.
13144	*
13145	*  This can only happen within an orphan event listener.
13146	*/
13147	removed;
13148	/**
13149	*  The address of the contract that emitted this log.
13150	*/
13151	address;
13152	/**
13153	*  The data included in this log when it was emitted.
13154	*/
13155	data;
13156	/**
13157	*  The indexed topics included in this log when it was emitted.
13158	*
13159	*  All topics are included in the bloom filters, so they can be
13160	*  efficiently filtered using the [[Provider-getLogs]] method.
13161	*/
13162	topics;
13163	/**
13164	*  The index within the block this log occurred at. This is generally
13165	*  not useful to developers, but can be used with the various roots
13166	*  to proof inclusion within a block.
13167	*/
13168	index;
13169	/**
13170	*  The index within the transaction of this log.
13171	*/
13172	transactionIndex;
13173	/**
13174	*  @_ignore:
13175	*/
13176	constructor(log, provider) {
13177		this.provider = provider;
13178		const topics = Object.freeze(log.topics.slice());
13179		defineProperties(this, {
13180			transactionHash: log.transactionHash,
13181			blockHash: log.blockHash,
13182			blockNumber: log.blockNumber,
13183			removed: log.removed,
13184			address: log.address,
13185			data: log.data,
13186			topics,
13187			index: log.index,
13188			transactionIndex: log.transactionIndex
13189		});
13190	}
13191	/**
13192	*  Returns a JSON-compatible object.
13193	*/
13194	toJSON() {
13195		const { address, blockHash, blockNumber, data, index, removed, topics, transactionHash, transactionIndex } = this;
13196		return {
13197			_type: "log",
13198			address,
13199			blockHash,
13200			blockNumber,
13201			data,
13202			index,
13203			removed,
13204			topics,
13205			transactionHash,
13206			transactionIndex
13207		};
13208	}
13209	/**
13210	*  Returns the block that this log occurred in.
13211	*/
13212	async getBlock() {
13213		const block = await this.provider.getBlock(this.blockHash);
13214		assert(!!block, "failed to find transaction", "UNKNOWN_ERROR", {});
13215		return block;
13216	}
13217	/**
13218	*  Returns the transaction that this log occurred in.
13219	*/
13220	async getTransaction() {
13221		const tx = await this.provider.getTransaction(this.transactionHash);
13222		assert(!!tx, "failed to find transaction", "UNKNOWN_ERROR", {});
13223		return tx;
13224	}
13225	/**
13226	*  Returns the transaction receipt fot the transaction that this
13227	*  log occurred in.
13228	*/
13229	async getTransactionReceipt() {
13230		const receipt = await this.provider.getTransactionReceipt(this.transactionHash);
13231		assert(!!receipt, "failed to find transaction receipt", "UNKNOWN_ERROR", {});
13232		return receipt;
13233	}

13234	/**
13235	*  @_ignore:
13236	*/
13237	removedEvent() {
13238		return createRemovedLogFilter(this);
13239	}
13240};
13241/**
13242*  A **TransactionReceipt** includes additional information about a
13243*  transaction that is only available after it has been mined.
13244*/
13245var TransactionReceipt = class {
13246	/**
13247	*  The provider connected to the log used to fetch additional details
13248	*  if necessary.
13249	*/
13250	provider;
13251	/**
13252	*  The address the transaction was sent to.
13253	*/
13254	to;
13255	/**
13256	*  The sender of the transaction.
13257	*/
13258	from;
13259	/**
13260	*  The address of the contract if the transaction was directly
13261	*  responsible for deploying one.
13262	*
13263	*  This is non-null **only** if the ``to`` is empty and the ``data``
13264	*  was successfully executed as initcode.
13265	*/
13266	contractAddress;
13267	/**
13268	*  The transaction hash.
13269	*/
13270	hash;
13271	/**
13272	*  The index of this transaction within the block transactions.
13273	*/
13274	index;
13275	/**
13276	*  The block hash of the [[Block]] this transaction was included in.
13277	*/
13278	blockHash;
13279	/**
13280	*  The block number of the [[Block]] this transaction was included in.
13281	*/
13282	blockNumber;
13283	/**
13284	*  The bloom filter bytes that represent all logs that occurred within
13285	*  this transaction. This is generally not useful for most developers,
13286	*  but can be used to validate the included logs.
13287	*/
13288	logsBloom;
13289	/**
13290	*  The actual amount of gas used by this transaction.
13291	*
13292	*  When creating a transaction, the amount of gas that will be used can
13293	*  only be approximated, but the sender must pay the gas fee for the
13294	*  entire gas limit. After the transaction, the difference is refunded.
13295	*/
13296	gasUsed;
13297	/**
13298	*  The gas used for BLObs. See [[link-eip-4844]].
13299	*/
13300	blobGasUsed;
13301	/**
13302	*  The amount of gas used by all transactions within the block for this
13303	*  and all transactions with a lower ``index``.
13304	*
13305	*  This is generally not useful for developers but can be used to
13306	*  validate certain aspects of execution.
13307	*/
13308	cumulativeGasUsed;
13309	/**
13310	*  The actual gas price used during execution.
13311	*
13312	*  Due to the complexity of [[link-eip-1559]] this value can only
13313	*  be caluclated after the transaction has been mined, snce the base
13314	*  fee is protocol-enforced.
13315	*/
13316	gasPrice;
13317	/**
13318	*  The price paid per BLOB in gas. See [[link-eip-4844]].
13319	*/
13320	blobGasPrice;
13321	/**
13322	*  The [[link-eip-2718]] transaction type.
13323	*/
13324	type;
13325	/**
13326	*  The status of this transaction, indicating success (i.e. ``1``) or
13327	*  a revert (i.e. ``0``).
13328	*
13329	*  This is available in post-byzantium blocks, but some backends may
13330	*  backfill this value.
13331	*/
13332	status;
13333	/**
13334	*  The root hash of this transaction.
13335	*
13336	*  This is no present and was only included in pre-byzantium blocks, but
13337	*  could be used to validate certain parts of the receipt.
13338	*/
13339	root;
13340	#logs;
13341	/**
13342	*  @_ignore:
13343	*/
13344	constructor(tx, provider) {
13345		this.#logs = Object.freeze(tx.logs.map((log) => {
13346			return new Log(log, provider);
13347		}));
13348		let gasPrice = BN_0$2;
13349		if (tx.effectiveGasPrice != null) gasPrice = tx.effectiveGasPrice;
13350		else if (tx.gasPrice != null) gasPrice = tx.gasPrice;
13351		defineProperties(this, {
13352			provider,
13353			to: tx.to,
13354			from: tx.from,
13355			contractAddress: tx.contractAddress,
13356			hash: tx.hash,
13357			index: tx.index,
13358			blockHash: tx.blockHash,
13359			blockNumber: tx.blockNumber,
13360			logsBloom: tx.logsBloom,
13361			gasUsed: tx.gasUsed,
13362			cumulativeGasUsed: tx.cumulativeGasUsed,
13363			blobGasUsed: tx.blobGasUsed,
13364			gasPrice,
13365			blobGasPrice: tx.blobGasPrice,
13366			type: tx.type,
13367			status: tx.status,
13368			root: tx.root
13369		});
13370	}
13371	/**
13372	*  The logs for this transaction.
13373	*/
13374	get logs() {
13375		return this.#logs;
13376	}
13377	/**
13378	*  Returns a JSON-compatible representation.
13379	*/
13380	toJSON() {
13381		const { to, from, contractAddress, hash, index, blockHash, blockNumber, logsBloom, logs, status, root } = this;
13382		return {
13383			_type: "TransactionReceipt",
13384			blockHash,
13385			blockNumber,
13386			contractAddress,
13387			cumulativeGasUsed: toJson(this.cumulativeGasUsed),
13388			from,
13389			gasPrice: toJson(this.gasPrice),
13390			blobGasUsed: toJson(this.blobGasUsed),
13391			blobGasPrice: toJson(this.blobGasPrice),
13392			gasUsed: toJson(this.gasUsed),
13393			hash,
13394			index,
13395			logs,
13396			logsBloom,
13397			root,
13398			status,
13399			to
13400		};
13401	}
13402	/**
13403	*  @_ignore:
13404	*/
13405	get length() {
13406		return this.logs.length;
13407	}
13408	[Symbol.iterator]() {
13409		let index = 0;
13410		return { next: () => {
13411			if (index < this.length) return {
13412				value: this.logs[index++],
13413				done: false
13414			};
13415			return {
13416				value: void 0,
13417				done: true
13418			};
13419		} };
13420	}
13421	/**

13422	*  The total fee for this transaction, in wei.
13423	*/
13424	get fee() {
13425		return this.gasUsed * this.gasPrice;
13426	}
13427	/**
13428	*  Resolves to the block this transaction occurred in.
13429	*/
13430	async getBlock() {
13431		const block = await this.provider.getBlock(this.blockHash);
13432		if (block == null) throw new Error("TODO");
13433		return block;
13434	}
13435	/**
13436	*  Resolves to the transaction this transaction occurred in.
13437	*/
13438	async getTransaction() {
13439		const tx = await this.provider.getTransaction(this.hash);
13440		if (tx == null) throw new Error("TODO");
13441		return tx;
13442	}
13443	/**
13444	*  Resolves to the return value of the execution of this transaction.
13445	*
13446	*  Support for this feature is limited, as it requires an archive node
13447	*  with the ``debug_`` or ``trace_`` API enabled.
13448	*/
13449	async getResult() {
13450		return await this.provider.getTransactionResult(this.hash);
13451	}
13452	/**
13453	*  Resolves to the number of confirmations this transaction has.
13454	*/
13455	async confirmations() {
13456		return await this.provider.getBlockNumber() - this.blockNumber + 1;
13457	}
13458	/**
13459	*  @_ignore:
13460	*/
13461	removedEvent() {
13462		return createRemovedTransactionFilter(this);
13463	}
13464	/**
13465	*  @_ignore:
13466	*/
13467	reorderedEvent(other) {
13468		assert(!other || other.isMined(), "unmined 'other' transction cannot be orphaned", "UNSUPPORTED_OPERATION", { operation: "reorderedEvent(other)" });
13469		return createReorderedTransactionFilter(this, other);
13470	}
13471};
13472/**
13473*  A **TransactionResponse** includes all properties about a transaction
13474*  that was sent to the network, which may or may not be included in a
13475*  block.
13476*
13477*  The [[TransactionResponse-isMined]] can be used to check if the
13478*  transaction has been mined as well as type guard that the otherwise
13479*  possibly ``null`` properties are defined.
13480*/
13481var TransactionResponse = class TransactionResponse {
13482	/**
13483	*  The provider this is connected to, which will influence how its
13484	*  methods will resolve its async inspection methods.
13485	*/
13486	provider;
13487	/**
13488	*  The block number of the block that this transaction was included in.
13489	*
13490	*  This is ``null`` for pending transactions.
13491	*/
13492	blockNumber;
13493	/**
13494	*  The blockHash of the block that this transaction was included in.
13495	*
13496	*  This is ``null`` for pending transactions.
13497	*/
13498	blockHash;
13499	/**
13500	*  The index within the block that this transaction resides at.
13501	*/
13502	index;
13503	/**
13504	*  The transaction hash.
13505	*/
13506	hash;
13507	/**
13508	*  The [[link-eip-2718]] transaction envelope type. This is
13509	*  ``0`` for legacy transactions types.
13510	*/
13511	type;
13512	/**
13513	*  The receiver of this transaction.
13514	*
13515	*  If ``null``, then the transaction is an initcode transaction.
13516	*  This means the result of executing the [[data]] will be deployed
13517	*  as a new contract on chain (assuming it does not revert) and the
13518	*  address may be computed using [[getCreateAddress]].
13519	*/
13520	to;
13521	/**
13522	*  The sender of this transaction. It is implicitly computed
13523	*  from the transaction pre-image hash (as the digest) and the
13524	*  [[signature]] using ecrecover.
13525	*/
13526	from;
13527	/**
13528	*  The nonce, which is used to prevent replay attacks and offer
13529	*  a method to ensure transactions from a given sender are explicitly
13530	*  ordered.
13531	*
13532	*  When sending a transaction, this must be equal to the number of
13533	*  transactions ever sent by [[from]].
13534	*/
13535	nonce;
13536	/**
13537	*  The maximum units of gas this transaction can consume. If execution
13538	*  exceeds this, the entries transaction is reverted and the sender
13539	*  is charged for the full amount, despite not state changes being made.
13540	*/
13541	gasLimit;
13542	/**
13543	*  The gas price can have various values, depending on the network.
13544	*
13545	*  In modern networks, for transactions that are included this is
13546	*  the //effective gas price// (the fee per gas that was actually
13547	*  charged), while for transactions that have not been included yet
13548	*  is the [[maxFeePerGas]].
13549	*
13550	*  For legacy transactions, or transactions on legacy networks, this
13551	*  is the fee that will be charged per unit of gas the transaction
13552	*  consumes.
13553	*/
13554	gasPrice;
13555	/**
13556	*  The maximum priority fee (per unit of gas) to allow a
13557	*  validator to charge the sender. This is inclusive of the
13558	*  [[maxFeeFeePerGas]].
13559	*/
13560	maxPriorityFeePerGas;
13561	/**
13562	*  The maximum fee (per unit of gas) to allow this transaction
13563	*  to charge the sender.
13564	*/
13565	maxFeePerGas;
13566	/**
13567	*  The [[link-eip-4844]] max fee per BLOb gas.
13568	*/
13569	maxFeePerBlobGas;
13570	/**
13571	*  The data.
13572	*/
13573	data;
13574	/**
13575	*  The value, in wei. Use [[formatEther]] to format this value
13576	*  as ether.
13577	*/
13578	value;
13579	/**
13580	*  The chain ID.
13581	*/
13582	chainId;
13583	/**
13584	*  The signature.
13585	*/
13586	signature;
13587	/**
13588	*  The [[link-eip-2930]] access list for transaction types that
13589	*  support it, otherwise ``null``.
13590	*/
13591	accessList;
13592	/**
13593	*  The [[link-eip-4844]] BLOb versioned hashes.
13594	*/
13595	blobVersionedHashes;
13596	/**
13597	*  The [[link-eip-7702]] authorizations (if any).
13598	*/
13599	authorizationList;
13600	#startBlock;
13601	/**
13602	*  @_ignore:
13603	*/
13604	constructor(tx, provider) {
13605		this.provider = provider;
13606		this.blockNumber = tx.blockNumber != null ? tx.blockNumber : null;
13607		this.blockHash = tx.blockHash != null ? tx.blockHash : null;
13608		this.hash = tx.hash;
13609		this.index = tx.index;
13610		this.type = tx.type;
13611		this.from = tx.from;
13612		this.to = tx.to || null;
13613		this.gasLimit = tx.gasLimit;
13614		this.nonce = tx.nonce;
13615		this.data = tx.data;
13616		this.value = tx.value;
13617		this.gasPrice = tx.gasPrice;
13618		this.maxPriorityFeePerGas = tx.maxPriorityFeePerGas != null ? tx.maxPriorityFeePerGas : null;
13619		this.maxFeePerGas = tx.maxFeePerGas != null ? tx.maxFeePerGas : null;
13620		this.maxFeePerBlobGas = tx.maxFeePerBlobGas != null ? tx.maxFeePerBlobGas : null;
13621		this.chainId = tx.chainId;
13622		this.signature = tx.signature;
13623		this.accessList = tx.accessList != null ? tx.accessList : null;
13624		this.blobVersionedHashes = tx.blobVersionedHashes != null ? tx.blobVersionedHashes : null;
13625		this.authorizationList = tx.authorizationList != null ? tx.authorizationList : null;
13626		this.#startBlock = -1;
13627	}
13628	/**
13629	*  Returns a JSON-compatible representation of this transaction.
13630	*/
13631	toJSON() {
13632		const { blockNumber, blockHash, index, hash, type, to, from, nonce, data, signature, accessList, blobVersionedHashes } = this;
13633		return {
13634			_type: "TransactionResponse",
13635			accessList,
13636			blockNumber,
13637			blockHash,
13638			blobVersionedHashes,
13639			chainId: toJson(this.chainId),
13640			data,
13641			from,
13642			gasLimit: toJson(this.gasLimit),
13643			gasPrice: toJson(this.gasPrice),
13644			hash,
13645			maxFeePerGas: toJson(this.maxFeePerGas),
13646			maxPriorityFeePerGas: toJson(this.maxPriorityFeePerGas),
13647			maxFeePerBlobGas: toJson(this.maxFeePerBlobGas),
13648			nonce,
13649			signature,
13650			to,
13651			index,
13652			type,
13653			value: toJson(this.value)
13654		};
13655	}
13656	/**
13657	*  Resolves to the Block that this transaction was included in.
13658	*
13659	*  This will return null if the transaction has not been included yet.
13660	*/
13661	async getBlock() {
13662		let blockNumber = this.blockNumber;
13663		if (blockNumber == null) {
13664			const tx = await this.getTransaction();
13665			if (tx) blockNumber = tx.blockNumber;
13666		}
13667		if (blockNumber == null) return null;
13668		const block = this.provider.getBlock(blockNumber);
13669		if (block == null) throw new Error("TODO");
13670		return block;
13671	}
13672	/**
13673	*  Resolves to this transaction being re-requested from the
13674	*  provider. This can be used if you have an unmined transaction
13675	*  and wish to get an up-to-date populated instance.
13676	*/
13677	async getTransaction() {
13678		return this.provider.getTransaction(this.hash);
13679	}
13680	/**
13681	*  Resolve to the number of confirmations this transaction has.
13682	*/
13683	async confirmations() {
13684		if (this.blockNumber == null) {
13685			const { tx, blockNumber } = await resolveProperties({
13686				tx: this.getTransaction(),
13687				blockNumber: this.provider.getBlockNumber()
13688			});
13689			if (tx == null || tx.blockNumber == null) return 0;
13690			return blockNumber - tx.blockNumber + 1;
13691		}
13692		return await this.provider.getBlockNumber() - this.blockNumber + 1;
13693	}
13694	/**
13695	*  Resolves once this transaction has been mined and has
13696	*  %%confirms%% blocks including it (default: ``1``) with an
13697	*  optional %%timeout%%.
13698	*
13699	*  This can resolve to ``null`` only if %%confirms%% is ``0``
13700	*  and the transaction has not been mined, otherwise this will
13701	*  wait until enough confirmations have completed.
13702	*/
13703	async wait(_confirms, _timeout) {
13704		const confirms = _confirms == null ? 1 : _confirms;
13705		const timeout = _timeout == null ? 0 : _timeout;
13706		let startBlock = this.#startBlock;
13707		let nextScan = -1;
13708		let stopScanning = startBlock === -1 ? true : false;

13709		const checkReplacement = async () => {
13710			if (stopScanning) return null;
13711			const { blockNumber, nonce } = await resolveProperties({
13712				blockNumber: this.provider.getBlockNumber(),
13713				nonce: this.provider.getTransactionCount(this.from)
13714			});
13715			if (nonce < this.nonce) {
13716				startBlock = blockNumber;
13717				return;
13718			}
13719			if (stopScanning) return null;
13720			const mined = await this.getTransaction();
13721			if (mined && mined.blockNumber != null) return;
13722			if (nextScan === -1) {
13723				nextScan = startBlock - 3;
13724				if (nextScan < this.#startBlock) nextScan = this.#startBlock;
13725			}
13726			while (nextScan <= blockNumber) {
13727				if (stopScanning) return null;
13728				const block = await this.provider.getBlock(nextScan, true);
13729				if (block == null) return;
13730				for (const hash of block) if (hash === this.hash) return;
13731				for (let i = 0; i < block.length; i++) {
13732					const tx = await block.getTransaction(i);
13733					if (tx.from === this.from && tx.nonce === this.nonce) {
13734						if (stopScanning) return null;
13735						const receipt = await this.provider.getTransactionReceipt(tx.hash);
13736						if (receipt == null) return;
13737						if (blockNumber - receipt.blockNumber + 1 < confirms) return;
13738						let reason = "replaced";
13739						if (tx.data === this.data && tx.to === this.to && tx.value === this.value) reason = "repriced";
13740						else if (tx.data === "0x" && tx.from === tx.to && tx.value === BN_0$2) reason = "cancelled";
13741						assert(false, "transaction was replaced", "TRANSACTION_REPLACED", {
13742							cancelled: reason === "replaced" || reason === "cancelled",
13743							reason,
13744							replacement: tx.replaceableTransaction(startBlock),
13745							hash: tx.hash,
13746							receipt
13747						});
13748					}
13749				}
13750				nextScan++;
13751			}
13752		};
13753		const checkReceipt = (receipt) => {
13754			if (receipt == null || receipt.status !== 0) return receipt;
13755			assert(false, "transaction execution reverted", "CALL_EXCEPTION", {
13756				action: "sendTransaction",
13757				data: null,
13758				reason: null,
13759				invocation: null,
13760				revert: null,
13761				transaction: {
13762					to: receipt.to,
13763					from: receipt.from,
13764					data: ""
13765				},
13766				receipt
13767			});
13768		};
13769		const receipt = await this.provider.getTransactionReceipt(this.hash);
13770		if (confirms === 0) return checkReceipt(receipt);
13771		if (receipt) {
13772			if (confirms === 1 || await receipt.confirmations() >= confirms) return checkReceipt(receipt);
13773		} else {
13774			await checkReplacement();
13775			if (confirms === 0) return null;
13776		}
13777		return await new Promise((resolve, reject) => {
13778			const cancellers = [];
13779			const cancel = () => {
13780				cancellers.forEach((c) => c());
13781			};
13782			cancellers.push(() => {
13783				stopScanning = true;
13784			});
13785			if (timeout > 0) {
13786				const timer = setTimeout(() => {
13787					cancel();
13788					reject(makeError("wait for transaction timeout", "TIMEOUT"));
13789				}, timeout);
13790				cancellers.push(() => {
13791					clearTimeout(timer);
13792				});
13793			}
13794			const txListener = async (receipt) => {
13795				if (await receipt.confirmations() >= confirms) {
13796					cancel();
13797					try {
13798						resolve(checkReceipt(receipt));
13799					} catch (error) {
13800						reject(error);
13801					}
13802				}
13803			};
13804			cancellers.push(() => {
13805				this.provider.off(this.hash, txListener);
13806			});
13807			this.provider.on(this.hash, txListener);
13808			if (startBlock >= 0) {
13809				const replaceListener = async () => {
13810					try {
13811						await checkReplacement();
13812					} catch (error) {
13813						if (isError(error, "TRANSACTION_REPLACED")) {
13814							cancel();
13815							reject(error);
13816							return;
13817						}
13818					}
13819					if (!stopScanning) this.provider.once("block", replaceListener);
13820				};
13821				cancellers.push(() => {
13822					this.provider.off("block", replaceListener);
13823				});
13824				this.provider.once("block", replaceListener);
13825			}
13826		});
13827	}
13828	/**
13829	*  Returns ``true`` if this transaction has been included.
13830	*
13831	*  This is effective only as of the time the TransactionResponse
13832	*  was instantiated. To get up-to-date information, use
13833	*  [[getTransaction]].
13834	*
13835	*  This provides a Type Guard that this transaction will have
13836	*  non-null property values for properties that are null for
13837	*  unmined transactions.
13838	*/
13839	isMined() {
13840		return this.blockHash != null;
13841	}

13842	/**
13843	*  Returns true if the transaction is a legacy (i.e. ``type == 0``)
13844	*  transaction.
13845	*
13846	*  This provides a Type Guard that this transaction will have
13847	*  the ``null``-ness for hardfork-specific properties set correctly.
13848	*/
13849	isLegacy() {
13850		return this.type === 0;
13851	}
13852	/**
13853	*  Returns true if the transaction is a Berlin (i.e. ``type == 1``)
13854	*  transaction. See [[link-eip-2070]].
13855	*
13856	*  This provides a Type Guard that this transaction will have
13857	*  the ``null``-ness for hardfork-specific properties set correctly.
13858	*/
13859	isBerlin() {
13860		return this.type === 1;
13861	}
13862	/**
13863	*  Returns true if the transaction is a London (i.e. ``type == 2``)
13864	*  transaction. See [[link-eip-1559]].
13865	*
13866	*  This provides a Type Guard that this transaction will have
13867	*  the ``null``-ness for hardfork-specific properties set correctly.
13868	*/
13869	isLondon() {
13870		return this.type === 2;
13871	}
13872	/**
13873	*  Returns true if hte transaction is a Cancun (i.e. ``type == 3``)
13874	*  transaction. See [[link-eip-4844]].
13875	*/
13876	isCancun() {
13877		return this.type === 3;
13878	}
13879	/**
13880	*  Returns a filter which can be used to listen for orphan events
13881	*  that evict this transaction.
13882	*/
13883	removedEvent() {
13884		assert(this.isMined(), "unmined transaction canot be orphaned", "UNSUPPORTED_OPERATION", { operation: "removeEvent()" });
13885		return createRemovedTransactionFilter(this);
13886	}
13887	/**
13888	*  Returns a filter which can be used to listen for orphan events
13889	*  that re-order this event against %%other%%.
13890	*/
13891	reorderedEvent(other) {
13892		assert(this.isMined(), "unmined transaction canot be orphaned", "UNSUPPORTED_OPERATION", { operation: "removeEvent()" });
13893		assert(!other || other.isMined(), "unmined 'other' transaction canot be orphaned", "UNSUPPORTED_OPERATION", { operation: "removeEvent()" });
13894		return createReorderedTransactionFilter(this, other);
13895	}
13896	/**
13897	*  Returns a new TransactionResponse instance which has the ability to
13898	*  detect (and throw an error) if the transaction is replaced, which
13899	*  will begin scanning at %%startBlock%%.
13900	*
13901	*  This should generally not be used by developers and is intended
13902	*  primarily for internal use. Setting an incorrect %%startBlock%% can
13903	*  have devastating performance consequences if used incorrectly.
13904	*/
13905	replaceableTransaction(startBlock) {
13906		assertArgument(Number.isInteger(startBlock) && startBlock >= 0, "invalid startBlock", "startBlock", startBlock);
13907		const tx = new TransactionResponse(this, this.provider);
13908		tx.#startBlock = startBlock;
13909		return tx;
13910	}
13911};
13912function createOrphanedBlockFilter(block) {
13913	return {
13914		orphan: "drop-block",
13915		hash: block.hash,
13916		number: block.number
13917	};
13918}
13919function createReorderedTransactionFilter(tx, other) {
13920	return {
13921		orphan: "reorder-transaction",
13922		tx,
13923		other
13924	};
13925}
13926function createRemovedTransactionFilter(tx) {
13927	return {
13928		orphan: "drop-transaction",
13929		tx
13930	};
13931}
13932function createRemovedLogFilter(log) {
13933	return {
13934		orphan: "drop-log",
13935		log: {
13936			transactionHash: log.transactionHash,
13937			blockHash: log.blockHash,
13938			blockNumber: log.blockNumber,
13939			address: log.address,
13940			data: log.data,
13941			topics: Object.freeze(log.topics.slice()),
13942			index: log.index
13943		}
13944	};
13945}
13946//#endregion
13947//#region node_modules/ethers/lib.esm/contract/wrappers.js
13948/**
13949*  An **EventLog** contains additional properties parsed from the [[Log]].
13950*/
13951var EventLog = class extends Log {
13952	/**
13953	*  The Contract Interface.
13954	*/
13955	interface;
13956	/**
13957	*  The matching event.
13958	*/
13959	fragment;
13960	/**
13961	*  The parsed arguments passed to the event by ``emit``.
13962	*/
13963	args;
13964	/**
13965	* @_ignore:
13966	*/
13967	constructor(log, iface, fragment) {
13968		super(log, log.provider);
13969		const args = iface.decodeEventLog(fragment, log.data, log.topics);
13970		defineProperties(this, {
13971			args,
13972			fragment,
13973			interface: iface
13974		});
13975	}
13976	/**
13977	*  The name of the event.
13978	*/
13979	get eventName() {
13980		return this.fragment.name;
13981	}
13982	/**
13983	*  The signature of the event.
13984	*/
13985	get eventSignature() {
13986		return this.fragment.format();
13987	}
13988};
13989/**
13990*  An **EventLog** contains additional properties parsed from the [[Log]].
13991*/
13992var UndecodedEventLog = class extends Log {
13993	/**
13994	*  The error encounted when trying to decode the log.
13995	*/
13996	error;
13997	/**
13998	* @_ignore:
13999	*/
14000	constructor(log, error) {
14001		super(log, log.provider);
14002		defineProperties(this, { error });
14003	}
14004};
14005/**
14006*  A **ContractTransactionReceipt** includes the parsed logs from a
14007*  [[TransactionReceipt]].
14008*/
14009var ContractTransactionReceipt = class extends TransactionReceipt {
14010	#iface;
14011	/**
14012	*  @_ignore:
14013	*/
14014	constructor(iface, provider, tx) {
14015		super(tx, provider);
14016		this.#iface = iface;
14017	}

14018	/**
14019	*  The parsed logs for any [[Log]] which has a matching event in the
14020	*  Contract ABI.
14021	*/
14022	get logs() {
14023		return super.logs.map((log) => {
14024			const fragment = log.topics.length ? this.#iface.getEvent(log.topics[0]) : null;
14025			if (fragment) try {
14026				return new EventLog(log, this.#iface, fragment);
14027			} catch (error) {
14028				return new UndecodedEventLog(log, error);
14029			}
14030			return log;
14031		});
14032	}
14033};
14034/**
14035*  A **ContractTransactionResponse** will return a
14036*  [[ContractTransactionReceipt]] when waited on.
14037*/
14038var ContractTransactionResponse = class extends TransactionResponse {
14039	#iface;
14040	/**
14041	*  @_ignore:
14042	*/
14043	constructor(iface, provider, tx) {
14044		super(tx, provider);
14045		this.#iface = iface;
14046	}
14047	/**
14048	*  Resolves once this transaction has been mined and has
14049	*  %%confirms%% blocks including it (default: ``1``) with an
14050	*  optional %%timeout%%.
14051	*
14052	*  This can resolve to ``null`` only if %%confirms%% is ``0``
14053	*  and the transaction has not been mined, otherwise this will
14054	*  wait until enough confirmations have completed.
14055	*/
14056	async wait(confirms, timeout) {
14057		const receipt = await super.wait(confirms, timeout);
14058		if (receipt == null) return null;
14059		return new ContractTransactionReceipt(this.#iface, this.provider, receipt);
14060	}
14061};
14062/**
14063*  A **ContractUnknownEventPayload** is included as the last parameter to
14064*  Contract Events when the event does not match any events in the ABI.
14065*/
14066var ContractUnknownEventPayload = class extends EventPayload {
14067	/**
14068	*  The log with no matching events.
14069	*/
14070	log;
14071	/**
14072	*  @_event:
14073	*/
14074	constructor(contract, listener, filter, log) {
14075		super(contract, listener, filter);
14076		defineProperties(this, { log });
14077	}
14078	/**
14079	*  Resolves to the block the event occured in.
14080	*/
14081	async getBlock() {
14082		return await this.log.getBlock();
14083	}
14084	/**
14085	*  Resolves to the transaction the event occured in.
14086	*/
14087	async getTransaction() {
14088		return await this.log.getTransaction();
14089	}
14090	/**
14091	*  Resolves to the transaction receipt the event occured in.
14092	*/
14093	async getTransactionReceipt() {
14094		return await this.log.getTransactionReceipt();
14095	}
14096};
14097/**
14098*  A **ContractEventPayload** is included as the last parameter to
14099*  Contract Events when the event is known.
14100*/
14101var ContractEventPayload = class extends ContractUnknownEventPayload {
14102	/**
14103	*  @_ignore:
14104	*/
14105	constructor(contract, listener, filter, fragment, _log) {
14106		super(contract, listener, filter, new EventLog(_log, contract.interface, fragment));
14107		const args = contract.interface.decodeEventLog(fragment, this.log.data, this.log.topics);
14108		defineProperties(this, {
14109			args,
14110			fragment
14111		});
14112	}
14113	/**
14114	*  The event name.
14115	*/
14116	get eventName() {
14117		return this.fragment.name;
14118	}
14119	/**
14120	*  The event signature.
14121	*/
14122	get eventSignature() {
14123		return this.fragment.format();
14124	}
14125};
14126//#endregion
14127//#region node_modules/ethers/lib.esm/contract/contract.js
14128var BN_0$1 = BigInt(0);
14129function canCall(value) {
14130	return value && typeof value.call === "function";
14131}
14132function canEstimate(value) {
14133	return value && typeof value.estimateGas === "function";
14134}
14135function canResolve(value) {
14136	return value && typeof value.resolveName === "function";
14137}
14138function canSend(value) {
14139	return value && typeof value.sendTransaction === "function";
14140}
14141function getResolver(value) {
14142	if (value != null) {
14143		if (canResolve(value)) return value;
14144		if (value.provider) return value.provider;
14145	}
14146}
14147var PreparedTopicFilter = class {
14148	#filter;
14149	fragment;
14150	constructor(contract, fragment, args) {
14151		defineProperties(this, { fragment });
14152		if (fragment.inputs.length < args.length) throw new Error("too many arguments");
14153		const runner = getRunner(contract.runner, "resolveName");
14154		const resolver = canResolve(runner) ? runner : null;
14155		this.#filter = (async function() {
14156			const resolvedArgs = await Promise.all(fragment.inputs.map((param, index) => {
14157				if (args[index] == null) return null;
14158				return param.walkAsync(args[index], (type, value) => {
14159					if (type === "address") {
14160						if (Array.isArray(value)) return Promise.all(value.map((v) => resolveAddress(v, resolver)));
14161						return resolveAddress(value, resolver);
14162					}
14163					return value;
14164				});
14165			}));
14166			return contract.interface.encodeFilterTopics(fragment, resolvedArgs);
14167		})();
14168	}
14169	getTopicFilter() {
14170		return this.#filter;
14171	}
14172};
14173function getRunner(value, feature) {
14174	if (value == null) return null;
14175	if (typeof value[feature] === "function") return value;
14176	if (value.provider && typeof value.provider[feature] === "function") return value.provider;
14177	return null;
14178}
14179function getProvider(value) {
14180	if (value == null) return null;
14181	return value.provider || null;
14182}
14183/**
14184*  @_ignore:
14185*/
14186async function copyOverrides(arg, allowed) {
14187	const _overrides = Typed.dereference(arg, "overrides");
14188	assertArgument(typeof _overrides === "object", "invalid overrides parameter", "overrides", arg);
14189	const overrides = copyRequest(_overrides);
14190	assertArgument(overrides.to == null || (allowed || []).indexOf("to") >= 0, "cannot override to", "overrides.to", overrides.to);
14191	assertArgument(overrides.data == null || (allowed || []).indexOf("data") >= 0, "cannot override data", "overrides.data", overrides.data);
14192	if (overrides.from) overrides.from = overrides.from;
14193	return overrides;
14194}
14195/**
14196*  @_ignore:
14197*/
14198async function resolveArgs(_runner, inputs, args) {
14199	const runner = getRunner(_runner, "resolveName");
14200	const resolver = canResolve(runner) ? runner : null;
14201	return await Promise.all(inputs.map((param, index) => {
14202		return param.walkAsync(args[index], (type, value) => {
14203			value = Typed.dereference(value, type);
14204			if (type === "address") return resolveAddress(value, resolver);
14205			return value;
14206		});
14207	}));
14208}
14209function buildWrappedFallback(contract) {
14210	const populateTransaction = async function(overrides) {
14211		const tx = await copyOverrides(overrides, ["data"]);
14212		tx.to = await contract.getAddress();
14213		if (tx.from) tx.from = await resolveAddress(tx.from, getResolver(contract.runner));
14214		const iface = contract.interface;
14215		const noValue = getBigInt(tx.value || BN_0$1, "overrides.value") === BN_0$1;
14216		const noData = (tx.data || "0x") === "0x";
14217		if (iface.fallback && !iface.fallback.payable && iface.receive && !noData && !noValue) assertArgument(false, "cannot send data to receive or send value to non-payable fallback", "overrides", overrides);
14218		assertArgument(iface.fallback || noData, "cannot send data to receive-only contract", "overrides.data", tx.data);
14219		assertArgument(iface.receive || iface.fallback && iface.fallback.payable || noValue, "cannot send value to non-payable fallback", "overrides.value", tx.value);
14220		assertArgument(iface.fallback || noData, "cannot send data to receive-only contract", "overrides.data", tx.data);
14221		return tx;
14222	};
14223	const staticCall = async function(overrides) {
14224		const runner = getRunner(contract.runner, "call");
14225		assert(canCall(runner), "contract runner does not support calling", "UNSUPPORTED_OPERATION", { operation: "call" });
14226		const tx = await populateTransaction(overrides);
14227		try {
14228			return await runner.call(tx);
14229		} catch (error) {
14230			if (isCallException(error) && error.data) throw contract.interface.makeError(error.data, tx);
14231			throw error;
14232		}
14233	};
14234	const send = async function(overrides) {
14235		const runner = contract.runner;
14236		assert(canSend(runner), "contract runner does not support sending transactions", "UNSUPPORTED_OPERATION", { operation: "sendTransaction" });
14237		const tx = await runner.sendTransaction(await populateTransaction(overrides));
14238		const provider = getProvider(contract.runner);
14239		return new ContractTransactionResponse(contract.interface, provider, tx);
14240	};
14241	const estimateGas = async function(overrides) {
14242		const runner = getRunner(contract.runner, "estimateGas");
14243		assert(canEstimate(runner), "contract runner does not support gas estimation", "UNSUPPORTED_OPERATION", { operation: "estimateGas" });
14244		return await runner.estimateGas(await populateTransaction(overrides));
14245	};
14246	const method = async (overrides) => {
14247		return await send(overrides);
14248	};
14249	defineProperties(method, {
14250		_contract: contract,
14251		estimateGas,
14252		populateTransaction,
14253		send,
14254		staticCall
14255	});
14256	return method;
14257}
14258function buildWrappedMethod(contract, key) {
14259	const getFragment = function(...args) {
14260		const fragment = contract.interface.getFunction(key, args);
14261		assert(fragment, "no matching fragment", "UNSUPPORTED_OPERATION", {
14262			operation: "fragment",
14263			info: {
14264				key,
14265				args
14266			}
14267		});
14268		return fragment;
14269	};
14270	const populateTransaction = async function(...args) {
14271		const fragment = getFragment(...args);
14272		let overrides = {};
14273		if (fragment.inputs.length + 1 === args.length) {
14274			overrides = await copyOverrides(args.pop());
14275			if (overrides.from) overrides.from = await resolveAddress(overrides.from, getResolver(contract.runner));
14276		}
14277		if (fragment.inputs.length !== args.length) throw new Error("internal error: fragment inputs doesn't match arguments; should not happen");
14278		const resolvedArgs = await resolveArgs(contract.runner, fragment.inputs, args);
14279		return Object.assign({}, overrides, await resolveProperties({
14280			to: contract.getAddress(),
14281			data: contract.interface.encodeFunctionData(fragment, resolvedArgs)
14282		}));
14283	};
14284	const staticCall = async function(...args) {
14285		const result = await staticCallResult(...args);
14286		if (result.length === 1) return result[0];
14287		return result;
14288	};
14289	const send = async function(...args) {
14290		const runner = contract.runner;
14291		assert(canSend(runner), "contract runner does not support sending transactions", "UNSUPPORTED_OPERATION", { operation: "sendTransaction" });
14292		const tx = await runner.sendTransaction(await populateTransaction(...args));
14293		const provider = getProvider(contract.runner);
14294		return new ContractTransactionResponse(contract.interface, provider, tx);
14295	};
14296	const estimateGas = async function(...args) {
14297		const runner = getRunner(contract.runner, "estimateGas");
14298		assert(canEstimate(runner), "contract runner does not support gas estimation", "UNSUPPORTED_OPERATION", { operation: "estimateGas" });
14299		return await runner.estimateGas(await populateTransaction(...args));
14300	};
14301	const staticCallResult = async function(...args) {
14302		const runner = getRunner(contract.runner, "call");
14303		assert(canCall(runner), "contract runner does not support calling", "UNSUPPORTED_OPERATION", { operation: "call" });
14304		const tx = await populateTransaction(...args);

14305		let result = "0x";
14306		try {
14307			result = await runner.call(tx);
14308		} catch (error) {
14309			if (isCallException(error) && error.data) throw contract.interface.makeError(error.data, tx);
14310			throw error;
14311		}
14312		const fragment = getFragment(...args);
14313		return contract.interface.decodeFunctionResult(fragment, result);
14314	};
14315	const method = async (...args) => {
14316		if (getFragment(...args).constant) return await staticCall(...args);
14317		return await send(...args);
14318	};
14319	defineProperties(method, {
14320		name: contract.interface.getFunctionName(key),
14321		_contract: contract,
14322		_key: key,
14323		getFragment,
14324		estimateGas,
14325		populateTransaction,
14326		send,
14327		staticCall,
14328		staticCallResult
14329	});
14330	Object.defineProperty(method, "fragment", {
14331		configurable: false,
14332		enumerable: true,
14333		get: () => {
14334			const fragment = contract.interface.getFunction(key);
14335			assert(fragment, "no matching fragment", "UNSUPPORTED_OPERATION", {
14336				operation: "fragment",
14337				info: { key }
14338			});
14339			return fragment;
14340		}
14341	});
14342	return method;
14343}
14344function buildWrappedEvent(contract, key) {
14345	const getFragment = function(...args) {
14346		const fragment = contract.interface.getEvent(key, args);
14347		assert(fragment, "no matching fragment", "UNSUPPORTED_OPERATION", {
14348			operation: "fragment",
14349			info: {
14350				key,
14351				args
14352			}
14353		});
14354		return fragment;
14355	};
14356	const method = function(...args) {
14357		return new PreparedTopicFilter(contract, getFragment(...args), args);
14358	};
14359	defineProperties(method, {
14360		name: contract.interface.getEventName(key),
14361		_contract: contract,
14362		_key: key,
14363		getFragment
14364	});
14365	Object.defineProperty(method, "fragment", {
14366		configurable: false,
14367		enumerable: true,
14368		get: () => {
14369			const fragment = contract.interface.getEvent(key);
14370			assert(fragment, "no matching fragment", "UNSUPPORTED_OPERATION", {
14371				operation: "fragment",
14372				info: { key }
14373			});
14374			return fragment;
14375		}
14376	});
14377	return method;
14378}
14379var internal = Symbol.for("_ethersInternal_contract");
14380var internalValues = /* @__PURE__ */ new WeakMap();
14381function setInternal(contract, values) {
14382	internalValues.set(contract[internal], values);
14383}
14384function getInternal(contract) {
14385	return internalValues.get(contract[internal]);
14386}
14387function isDeferred(value) {
14388	return value && typeof value === "object" && "getTopicFilter" in value && typeof value.getTopicFilter === "function" && value.fragment;
14389}
14390async function getSubInfo(contract, event) {
14391	let topics;
14392	let fragment = null;
14393	if (Array.isArray(event)) {
14394		const topicHashify = function(name) {
14395			if (isHexString(name, 32)) return name;
14396			const fragment = contract.interface.getEvent(name);
14397			assertArgument(fragment, "unknown fragment", "name", name);
14398			return fragment.topicHash;
14399		};
14400		topics = event.map((e) => {
14401			if (e == null) return null;
14402			if (Array.isArray(e)) return e.map(topicHashify);
14403			return topicHashify(e);
14404		});
14405	} else if (event === "*") topics = [null];
14406	else if (typeof event === "string") {
14407		if (isHexString(event, 32)) topics = [event];
14408		else {
14409			fragment = contract.interface.getEvent(event);
14410			assertArgument(fragment, "unknown fragment", "event", event);
14411			topics = [fragment.topicHash];
14412		}
14413	} else if (isDeferred(event)) topics = await event.getTopicFilter();
14414	else if ("fragment" in event) {
14415		fragment = event.fragment;
14416		topics = [fragment.topicHash];
14417	} else assertArgument(false, "unknown event name", "event", event);
14418	topics = topics.map((t) => {
14419		if (t == null) return null;
14420		if (Array.isArray(t)) {
14421			const items = Array.from(new Set(t.map((t) => t.toLowerCase())).values());
14422			if (items.length === 1) return items[0];
14423			items.sort();
14424			return items;
14425		}
14426		return t.toLowerCase();
14427	});
14428	const tag = topics.map((t) => {
14429		if (t == null) return "null";
14430		if (Array.isArray(t)) return t.join("|");
14431		return t;
14432	}).join("&");
14433	return {
14434		fragment,
14435		tag,
14436		topics
14437	};
14438}
14439async function hasSub(contract, event) {
14440	const { subs } = getInternal(contract);
14441	return subs.get((await getSubInfo(contract, event)).tag) || null;
14442}
14443async function getSub(contract, operation, event) {
14444	const provider = getProvider(contract.runner);
14445	assert(provider, "contract runner does not support subscribing", "UNSUPPORTED_OPERATION", { operation });
14446	const { fragment, tag, topics } = await getSubInfo(contract, event);
14447	const { addr, subs } = getInternal(contract);
14448	let sub = subs.get(tag);
14449	if (!sub) {
14450		const filter = {
14451			address: addr ? addr : contract,
14452			topics
14453		};
14454		const listener = (log) => {
14455			let foundFragment = fragment;
14456			if (foundFragment == null) try {
14457				foundFragment = contract.interface.getEvent(log.topics[0]);
14458			} catch (error) {}
14459			if (foundFragment) {
14460				const _foundFragment = foundFragment;
14461				emit(contract, event, fragment ? contract.interface.decodeEventLog(fragment, log.data, log.to

14461pics) : [], (listener) => {
14462					return new ContractEventPayload(contract, listener, event, _foundFragment, log);
14463				});
14464			} else emit(contract, event, [], (listener) => {
14465				return new ContractUnknownEventPayload(contract, listener, event, log);
14466			});
14467		};
14468		let starting = [];
14469		const start = () => {
14470			if (starting.length) return;
14471			starting.push(provider.on(filter, listener));
14472		};
14473		const stop = async () => {
14474			if (starting.length == 0) return;
14475			let started = starting;
14476			starting = [];
14477			await Promise.all(started);
14478			provider.off(filter, listener);
14479		};
14480		sub = {
14481			tag,
14482			listeners: [],
14483			start,
14484			stop
14485		};
14486		subs.set(tag, sub);
14487	}
14488	return sub;
14489}
14490var lastEmit = Promise.resolve();
14491async function _emit(contract, event, args, payloadFunc) {
14492	await lastEmit;
14493	const sub = await hasSub(contract, event);
14494	if (!sub) return false;
14495	const count = sub.listeners.length;
14496	sub.listeners = sub.listeners.filter(({ listener, once }) => {
14497		const passArgs = Array.from(args);
14498		if (payloadFunc) passArgs.push(payloadFunc(once ? null : listener));
14499		try {
14500			listener.call(contract, ...passArgs);
14501		} catch (error) {}
14502		return !once;
14503	});
14504	if (sub.listeners.length === 0) {
14505		sub.stop();
14506		getInternal(contract).subs.delete(sub.tag);
14507	}
14508	return count > 0;
14509}
14510async function emit(contract, event, args, payloadFunc) {
14511	try {
14512		await lastEmit;
14513	} catch (error) {}
14514	const resultPromise = _emit(contract, event, args, payloadFunc);
14515	lastEmit = resultPromise;
14516	return await resultPromise;
14517}
14518var passProperties = ["then"];
14519var BaseContract = class BaseContract {
14520	/**
14521	*  The target to connect to.
14522	*
14523	*  This can be an address, ENS name or any [[Addressable]], such as
14524	*  another contract. To get the resolved address, use the ``getAddress``
14525	*  method.
14526	*/
14527	target;
14528	/**
14529	*  The contract Interface.
14530	*/
14531	interface;
14532	/**
14533	*  The connected runner. This is generally a [[Provider]] or a
14534	*  [[Signer]], which dictates what operations are supported.
14535	*
14536	*  For example, a **Contract** connected to a [[Provider]] may
14537	*  only execute read-only operations.
14538	*/
14539	runner;
14540	/**
14541	*  All the Events available on this contract.
14542	*/
14543	filters;
14544	/**
14545	*  @_ignore:
14546	*/
14547	[internal];
14548	/**
14549	*  The fallback or receive function if any.
14550	*/
14551	fallback;
14552	/**
14553	*  Creates a new contract connected to %%target%% with the %%abi%% and
14554	*  optionally connected to a %%runner%% to perform operations on behalf
14555	*  of.
14556	*/
14557	constructor(target, abi, runner, _deployTx) {
14558		assertArgument(typeof target === "string" || isAddressable(target), "invalid value for Contract target", "target", target);
14559		if (runner == null) runner = null;
14560		const iface = Interface.from(abi);
14561		defineProperties(this, {
14562			target,
14563			runner,
14564			interface: iface
14565		});
14566		Object.defineProperty(this, internal, { value: {} });
14567		let addrPromise;
14568		let addr = null;
14569		let deployTx = null;
14570		if (_deployTx) {
14571			const provider = getProvider(runner);
14572			deployTx = new ContractTransactionResponse(this.interface, provider, _deployTx);
14573		}
14574		let subs = /* @__PURE__ */ new Map();
14575		if (typeof target === "string") {
14576			if (isHexString(target)) {
14577				addr = target;
14578				addrPromise = Promise.resolve(target);
14579			} else {
14580				const resolver = getRunner(runner, "resolveName");
14581				if (!canResolve(resolver)) throw makeError("contract runner does not support name resolution", "UNSUPPORTED_OPERATION", { operation: "resolveName" });
14582				addrPromise = resolver.resolveName(target).then((addr) => {
14583					if (addr == null) throw makeError("an ENS name used for a contract target must be correctly configured", "UNCONFIGURED_NAME", { value: target });
14584					getInternal(this).addr = addr;
14585					return addr;
14586				});
14587			}
14588		} else addrPromise = target.getAddress().then((addr) => {
14589			if (addr == null) throw new Error("TODO");
14590			getInternal(this).addr = addr;
14591			return addr;
14592		});
14593		setInternal(this, {
14594			addrPromise,
14595			addr,
14596			deployTx,
14597			subs
14598		});
14599		const filters = new Proxy({}, {
14600			get: (target, prop, receiver) => {
14601				if (typeof prop === "symbol" || passProperties.indexOf(prop) >= 0) return Reflect.get(target, prop, receiver);
14602				try {
14603					return this.getEvent(prop);
14604				} catch (error) {
14605					if (!isError(error, "INVALID_ARGUMENT") || error.argument !== "key") throw error;
14606				}
14607			},
14608			has: (target, prop) => {
14609				if (passProperties.indexOf(prop) >= 0) return Reflect.has(target, prop);
14610				return Reflect.has(target, prop) || this.interface.hasEvent(String(prop));
14611			}
14612		});
14613		defineProperties(this, { filters });
14614		defineProperties(this, { fallback: iface.receive || iface.fallback ? buildWrappedFallback(this) : null });
14615		return new Proxy(this, {
14616			get: (target, prop, receiver) => {
14617				if (typeof prop === "symbol" || prop in target || passProperties.indexOf(prop) >= 0) return Reflect.get(target, prop, receiver);

14618				try {
14619					return target.getFunction(prop);
14620				} catch (error) {
14621					if (!isError(error, "INVALID_ARGUMENT") || error.argument !== "key") throw error;
14622				}
14623			},
14624			has: (target, prop) => {
14625				if (typeof prop === "symbol" || prop in target || passProperties.indexOf(prop) >= 0) return Reflect.has(target, prop);
14626				return target.interface.hasFunction(prop);
14627			}
14628		});
14629	}
14630	/**
14631	*  Return a new Contract instance with the same target and ABI, but
14632	*  a different %%runner%%.
14633	*/
14634	connect(runner) {
14635		return new BaseContract(this.target, this.interface, runner);
14636	}
14637	/**
14638	*  Return a new Contract instance with the same ABI and runner, but
14639	*  a different %%target%%.
14640	*/
14641	attach(target) {
14642		return new BaseContract(target, this.interface, this.runner);
14643	}
14644	/**
14645	*  Return the resolved address of this Contract.
14646	*/
14647	async getAddress() {
14648		return await getInternal(this).addrPromise;
14649	}
14650	/**
14651	*  Return the deployed bytecode or null if no bytecode is found.
14652	*/
14653	async getDeployedCode() {
14654		const provider = getProvider(this.runner);
14655		assert(provider, "runner does not support .provider", "UNSUPPORTED_OPERATION", { operation: "getDeployedCode" });
14656		const code = await provider.getCode(await this.getAddress());
14657		if (code === "0x") return null;
14658		return code;
14659	}
14660	/**
14661	*  Resolve to this Contract once the bytecode has been deployed, or
14662	*  resolve immediately if already deployed.
14663	*/
14664	async waitForDeployment() {
14665		const deployTx = this.deploymentTransaction();
14666		if (deployTx) {
14667			await deployTx.wait();
14668			return this;
14669		}
14670		if (await this.getDeployedCode() != null) return this;
14671		const provider = getProvider(this.runner);
14672		assert(provider != null, "contract runner does not support .provider", "UNSUPPORTED_OPERATION", { operation: "waitForDeployment" });
14673		return new Promise((resolve, reject) => {
14674			const checkCode = async () => {
14675				try {
14676					if (await this.getDeployedCode() != null) return resolve(this);
14677					provider.once("block", checkCode);
14678				} catch (error) {
14679					reject(error);
14680				}
14681			};
14682			checkCode();
14683		});
14684	}
14685	/**
14686	*  Return the transaction used to deploy this contract.
14687	*
14688	*  This is only available if this instance was returned from a
14689	*  [[ContractFactory]].
14690	*/
14691	deploymentTransaction() {
14692		return getInternal(this).deployTx;
14693	}
14694	/**
14695	*  Return the function for a given name. This is useful when a contract
14696	*  method name conflicts with a JavaScript name such as ``prototype`` or
14697	*  when using a Contract programmatically.
14698	*/
14699	getFunction(key) {
14700		if (typeof key !== "string") key = key.format();
14701		return buildWrappedMethod(this, key);
14702	}
14703	/**
14704	*  Return the event for a given name. This is useful when a contract
14705	*  event name conflicts with a JavaScript name such as ``prototype`` or
14706	*  when using a Contract programmatically.
14707	*/
14708	getEvent(key) {
14709		if (typeof key !== "string") key = key.format();
14710		return buildWrappedEvent(this, key);
14711	}
14712	/**
14713	*  @_ignore:
14714	*/
14715	async queryTransaction(hash) {
14716		throw new Error("@TODO");
14717	}
14718	/**
14719	*  Provide historic access to event data for %%event%% in the range
14720	*  %%fromBlock%% (default: ``0``) to %%toBlock%% (default: ``"latest"``)
14721	*  inclusive.
14722	*/
14723	async queryFilter(event, fromBlock, toBlock) {
14724		if (fromBlock == null) fromBlock = 0;
14725		if (toBlock == null) toBlock = "latest";
14726		const { addr, addrPromise } = getInternal(this);
14727		const address = addr ? addr : await addrPromise;
14728		const { fragment, topics } = await getSubInfo(this, event);
14729		const filter = {
14730			address,
14731			topics,
14732			fromBlock,
14733			toBlock
14734		};
14735		const provider = getProvider(this.runner);
14736		assert(provider, "contract runner does not have a provider", "UNSUPPORTED_OPERATION", { operation: "queryFilter" });
14737		return (await provider.getLogs(filter)).map((log) => {
14738			let foundFragment = fragment;
14739			if (foundFragment == null) try {
14740				foundFragment = this.interface.getEvent(log.topics[0]);
14741			} catch (error) {}
14742			if (foundFragment) try {
14743				return new EventLog(log, this.interface, foundFragment);
14744			} catch (error) {
14745				return new UndecodedEventLog(log, error);
14746			}
14747			return new Log(log, provider);
14748		});
14749	}
14750	/**
14751	*  Add an event %%listener%% for the %%event%%.
14752	*/
14753	async on(event, listener) {
14754		const sub = await getSub(this, "on", event);
14755		sub.listeners.push({
14756			listener,
14757			once: false
14758		});
14759		sub.start();
14760		return this;
14761	}
14762	/**
14763	*  Add an event %%listener%% for the %%event%%, but remove the listener
14764	*  after it is fired once.
14765	*/
14766	async once(event, listener) {
14767		const sub = await getSub(this, "once", event);
14768		sub.listeners.push({
14769			listener,
14770			once: true
14771		});
14772		sub.start();
14773		return this;
14774	}
14775	/**
14776	*  Emit an %%event%% calling all listeners with %%args%%.
14777	*
14778	*  Resolves to ``true`` if any listeners were called.
14779	*/
14780	async emit(event, ...args) {
14781		return await emit(this, event, args, null);
14782	}
14783	/**
14784	*  Resolves to the number of listeners of %%event%% or the total number
14785	*  of listeners if unspecified.
14786	*/
14787	async listenerCount(event) {
14788		if (event) {
14789			const sub = await hasSub(this, event);
14790			if (!sub) return 0;
14791			return sub.listeners.length;
14792		}
14793		const { subs } = getInternal(this);
14794		let total = 0;
14795		for (const { listeners } of subs.values()) total += listeners.length;
14796		return total;
14797	}

14798	/**
14799	*  Resolves to the listeners subscribed to %%event%% or all listeners
14800	*  if unspecified.
14801	*/
14802	async listeners(event) {
14803		if (event) {
14804			const sub = await hasSub(this, event);
14805			if (!sub) return [];
14806			return sub.listeners.map(({ listener }) => listener);
14807		}
14808		const { subs } = getInternal(this);
14809		let result = [];
14810		for (const { listeners } of subs.values()) result = result.concat(listeners.map(({ listener }) => listener));
14811		return result;
14812	}
14813	/**
14814	*  Remove the %%listener%% from the listeners for %%event%% or remove
14815	*  all listeners if unspecified.
14816	*/
14817	async off(event, listener) {
14818		const sub = await hasSub(this, event);
14819		if (!sub) return this;
14820		if (listener) {
14821			const index = sub.listeners.map(({ listener }) => listener).indexOf(listener);
14822			if (index >= 0) sub.listeners.splice(index, 1);
14823		}
14824		if (listener == null || sub.listeners.length === 0) {
14825			sub.stop();
14826			getInternal(this).subs.delete(sub.tag);
14827		}
14828		return this;
14829	}
14830	/**
14831	*  Remove all the listeners for %%event%% or remove all listeners if
14832	*  unspecified.
14833	*/
14834	async removeAllListeners(event) {
14835		if (event) {
14836			const sub = await hasSub(this, event);
14837			if (!sub) return this;
14838			sub.stop();
14839			getInternal(this).subs.delete(sub.tag);
14840		} else {
14841			const { subs } = getInternal(this);
14842			for (const { tag, stop } of subs.values()) {
14843				stop();
14844				subs.delete(tag);
14845			}
14846		}
14847		return this;
14848	}
14849	/**
14850	*  Alias for [on].
14851	*/
14852	async addListener(event, listener) {
14853		return await this.on(event, listener);
14854	}
14855	/**
14856	*  Alias for [off].
14857	*/
14858	async removeListener(event, listener) {
14859		return await this.off(event, listener);
14860	}
14861	/**
14862	*  Create a new Class for the %%abi%%.
14863	*/
14864	static buildClass(abi) {
14865		class CustomContract extends BaseContract {
14866			constructor(address, runner = null) {
14867				super(address, abi, runner);
14868			}
14869		}
14870		return CustomContract;
14871	}
14872	/**
14873	*  Create a new BaseContract with a specified Interface.
14874	*/
14875	static from(target, abi, runner) {
14876		if (runner == null) runner = null;
14877		return new this(target, abi, runner);
14878	}
14879};
14880function _ContractBase() {
14881	return BaseContract;
14882}
14883/**
14884*  A [[BaseContract]] with no type guards on its methods or events.
14885*/
14886var Contract = class extends _ContractBase() {};
14887//#endregion
14888//#region node_modules/ethers/lib.esm/contract/factory.js
14889/**
14890*  A **ContractFactory** is used to deploy a Contract to the blockchain.
14891*/
14892var ContractFactory = class ContractFactory {
14893	/**
14894	*  The Contract Interface.
14895	*/
14896	interface;
14897	/**
14898	*  The Contract deployment bytecode. Often called the initcode.
14899	*/
14900	bytecode;
14901	/**
14902	*  The ContractRunner to deploy the Contract as.
14903	*/
14904	runner;
14905	/**
14906	*  Create a new **ContractFactory** with %%abi%% and %%bytecode%%,
14907	*  optionally connected to %%runner%%.
14908	*
14909	*  The %%bytecode%% may be the ``bytecode`` property within the
14910	*  standard Solidity JSON output.
14911	*/
14912	constructor(abi, bytecode, runner) {
14913		const iface = Interface.from(abi);
14914		if (bytecode instanceof Uint8Array) bytecode = hexlify(getBytes(bytecode));
14915		else {
14916			if (typeof bytecode === "object") bytecode = bytecode.object;
14917			if (!bytecode.startsWith("0x")) bytecode = "0x" + bytecode;
14918			bytecode = hexlify(getBytes(bytecode));
14919		}
14920		defineProperties(this, {
14921			bytecode,
14922			interface: iface,
14923			runner: runner || null
14924		});
14925	}
14926	attach(target) {
14927		return new BaseContract(target, this.interface, this.runner);
14928	}
14929	/**
14930	*  Resolves to the transaction to deploy the contract, passing %%args%%
14931	*  into the constructor.
14932	*/
14933	async getDeployTransaction(...args) {
14934		let overrides = {};
14935		const fragment = this.interface.deploy;
14936		if (fragment.inputs.length + 1 === args.length) overrides = await copyOverrides(args.pop());
14937		if (fragment.inputs.length !== args.length) throw new Error("incorrect number of arguments to constructor");
14938		const resolvedArgs = await resolveArgs(this.runner, fragment.inputs, args);
14939		const data = concat([this.bytecode, this.interface.encodeDeploy(resolvedArgs)]);
14940		return Object.assign({}, overrides, { data });
14941	}
14942	/**
14943	*  Resolves to the Contract deployed by passing %%args%% into the
14944	*  constructor.
14945	*
14946	*  This will resolve to the Contract before it has been deployed to the
14947	*  network, so the [[BaseContract-waitForDeployment]] should be used before
14948	*  sending any transactions to it.
14949	*/
14950	async deploy(...args) {
14951		const tx = await this.getDeployTransaction(...args);
14952		assert(this.runner && typeof this.runner.sendTransaction === "function", "factory runner does not support sending transactions", "UNSUPPORTED_OPERATION", { operation: "sendTransaction" });
14953		const sentTx = await this.runner.sendTransaction(tx);
14954		return new BaseContract(getCreateAddress(sentTx), this.interface, this.runner, sentTx);
14955	}
14956	/**
14957	*  Return a new **ContractFactory** with the same ABI and bytecode,
14958	*  but connected to %%runner%%.
14959	*/
14960	connect(runner) {
14961		return new ContractFactory(this.interface, this.bytecode, runner);
14962	}
14963	/**

14964	*  Create a new **ContractFactory** from the standard Solidity JSON output.
14965	*/
14966	static fromSolidity(output, runner) {
14967		assertArgument(output != null, "bad compiler output", "output", output);
14968		if (typeof output === "string") output = JSON.parse(output);
14969		const abi = output.abi;
14970		let bytecode = "";
14971		if (output.bytecode) bytecode = output.bytecode;
14972		else if (output.evm && output.evm.bytecode) bytecode = output.evm.bytecode;
14973		return new this(abi, bytecode, runner);
14974	}
14975};
14976//#endregion
14977//#region node_modules/ethers/lib.esm/providers/ens-resolver.js
14978/**
14979*  ENS is a service which allows easy-to-remember names to map to
14980*  network addresses.
14981*
14982*  @_section: api/providers/ens-resolver:ENS Resolver  [about-ens-rsolver]
14983*/
14984var BN_60 = BigInt(60);
14985function getIpfsLink(link) {
14986	if (link.match(/^ipfs:\/\/ipfs\//i)) link = link.substring(12);
14987	else if (link.match(/^ipfs:\/\//i)) link = link.substring(7);
14988	else assertArgument(false, "unsupported IPFS format", "link", link);
14989	return `https:/\/gateway.ipfs.io/ipfs/${link}`;
14990}
14991/**
14992*  A provider plugin super-class for processing multicoin address types.
14993*/
14994var MulticoinProviderPlugin = class {
14995	/**
14996	*  The name.
14997	*/
14998	name;
14999	/**
15000	*  Creates a new **MulticoinProviderPluing** for %%name%%.
15001	*/
15002	constructor(name) {
15003		defineProperties(this, { name });
15004	}
15005	connect(provider) {
15006		return this;
15007	}
15008	/**
15009	*  Returns ``true`` if %%coinType%% is supported by this plugin.
15010	*/
15011	supportsCoinType(coinType) {
15012		return false;
15013	}
15014	/**
15015	*  Resolves to the encoded %%address%% for %%coinType%%.
15016	*/
15017	async encodeAddress(coinType, address) {
15018		throw new Error("unsupported coin");
15019	}
15020	/**
15021	*  Resolves to the decoded %%data%% for %%coinType%%.
15022	*/
15023	async decodeAddress(coinType, data) {
15024		throw new Error("unsupported coin");
15025	}
15026};
15027var matcherIpfs = /* @__PURE__ */ new RegExp("^(ipfs)://(.*)$", "i");
15028var matchers = [
15029	/* @__PURE__ */ new RegExp("^(https)://(.*)$", "i"),
15030	/* @__PURE__ */ new RegExp("^(data):(.*)$", "i"),
15031	matcherIpfs,
15032	/* @__PURE__ */ new RegExp("^eip155:[0-9]+/(erc[0-9]+):(.*)$", "i")
15033];
15034function isEvmCoinType(coinType) {
15035	return coinType === BN_60 || coinType >= 2147483648 && coinType <= 4294967295;
15036}
15037/**
15038*  A connected object to a resolved ENS name resolver, which can be
15039*  used to query additional details.
15040*/
15041var EnsResolver = class EnsResolver {
15042	/**
15043	*  The connected provider.
15044	*/
15045	provider;
15046	/**
15047	*  The address of the resolver.
15048	*/
15049	address;
15050	/**
15051	*  The name this resolver was resolved against.
15052	*/
15053	name;
15054	#supports2544;
15055	#resolver;
15056	constructor(provider, address, name, supportsWildcard) {
15057		defineProperties(this, {
15058			provider,
15059			address,
15060			name
15061		});
15062		this.#supports2544 = supportsWildcard != null ? Promise.resolve(supportsWildcard) : null;
15063		this.#resolver = new Contract(address, [
15064			"function supportsInterface(bytes4) view returns (bool)",
15065			"function resolve(bytes, bytes) view returns (bytes)",
15066			"function addr(bytes32) view returns (address)",
15067			"function addr(bytes32, uint) view returns (bytes)",
15068			"function text(bytes32, string) view returns (string)",
15069			"function contenthash(bytes32) view returns (bytes)",
15070			"function name(bytes32) view returns (string)"
15071		], provider);
15072	}
15073	/**
15074	*  Resolves to true if the resolver supports wildcard resolution.
15075	*/
15076	async supportsWildcard() {
15077		if (this.#supports2544 == null) this.#supports2544 = (async () => {
15078			try {
15079				return await this.#resolver.supportsInterface("0x9061b923");
15080			} catch (error) {
15081				if (isError(error, "CALL_EXCEPTION")) return false;
15082				this.#supports2544 = null;
15083				throw error;
15084			}
15085		})();
15086		return await this.#supports2544;
15087	}
15088	async #fetch(funcName, params) {
15089		params = (params || []).slice();
15090		const iface = this.#resolver.interface;
15091		params.unshift(namehash(this.name));
15092		let fragment = null;
15093		if (await this.supportsWildcard()) {
15094			fragment = iface.getFunction(funcName);
15095			assert(fragment, "missing fragment", "UNKNOWN_ERROR", { info: { funcName } });
15096			params = [dnsEncode(this.name, 255), iface.encodeFunctionData(fragment, params)];
15097			funcName = "resolve(bytes,bytes)";
15098		}
15099		params.push({ enableCcipRead: true });
15100		try {
15101			const result = await this.#resolver[funcName](...params);
15102			if (fragment) return iface.decodeFunctionResult(fragment, result)[0];
15103			return result;
15104		} catch (error) {
15105			if (!isError(error, "CALL_EXCEPTION")) throw error;
15106		}
15107		return null;
15108	}

15109	/**
15110	*  Resolves to the address for %%coinType%% or null if the
15111	*  provided %%coinType%% has not been configured.
15112	*/
15113	async getAddress(_coinType) {
15114		const coinType = _coinType == null ? BN_60 : getBigInt(_coinType);
15115		if (coinType === BN_60) try {
15116			const result = await this.#fetch("addr(bytes32)");
15117			if (result == null || result === "0x0000000000000000000000000000000000000000") return null;
15118			return result;
15119		} catch (error) {
15120			if (isError(error, "CALL_EXCEPTION")) return null;
15121			throw error;
15122		}
15123		if (isEvmCoinType(coinType)) {
15124			const data = await this.#fetch("addr(bytes32,uint)", [coinType]);
15125			if (isHexString(data, 20)) return getAddress(data);
15126			return null;
15127		}
15128		if (coinType >= 0 && coinType < 2147483648) {
15129			let ethCoinType = coinType + BigInt(2147483648);
15130			const data = await this.#fetch("addr(bytes32,uint)", [ethCoinType]);
15131			if (isHexString(data, 20)) return getAddress(data);
15132		}
15133		let coinPlugin = null;
15134		for (const plugin of this.provider.plugins) {
15135			if (!(plugin instanceof MulticoinProviderPlugin)) continue;
15136			if (coinType <= 2147483648 && plugin.supportsCoinType(Number(coinType))) {
15137				coinPlugin = plugin;
15138				break;
15139			}
15140		}
15141		if (coinPlugin == null) return null;
15142		const data = await this.#fetch("addr(bytes32,uint)", [coinType]);
15143		if (data == null || data === "0x") return null;
15144		if (coinType < 2147483648) {
15145			const address = await coinPlugin.decodeAddress(Number(coinType), data);
15146			if (address != null) return address;
15147		}
15148		assert(false, `invalid coin data`, "UNSUPPORTED_OPERATION", {
15149			operation: `getAddress(${coinType})`,
15150			info: {
15151				coinType,
15152				data
15153			}
15154		});
15155	}
15156	/**
15157	*  Resolves to the EIP-634 text record for %%key%%, or ``null``
15158	*  if unconfigured.
15159	*/
15160	async getText(key) {
15161		const data = await this.#fetch("text(bytes32,string)", [key]);
15162		if (data == null || data === "0x") return null;
15163		return data;
15164	}
15165	/**
15166	*  Rsolves to the content-hash or ``null`` if unconfigured.
15167	*/
15168	async getContentHash() {
15169		const data = await this.#fetch("contenthash(bytes32)");
15170		if (data == null || data === "0x") return null;
15171		const ipfs = data.match(/^0x(e3010170|e5010172)(([0-9a-f][0-9a-f])([0-9a-f][0-9a-f])([0-9a-f]*))$/);
15172		if (ipfs) {
15173			const scheme = ipfs[1] === "e3010170" ? "ipfs" : "ipns";
15174			const length = parseInt(ipfs[4], 16);
15175			if (ipfs[5].length === length * 2) return `${scheme}:/\/${encodeBase58("0x" + ipfs[2])}`;
15176		}
15177		const swarm = data.match(/^0xe40101fa011b20([0-9a-f]*)$/);
15178		if (swarm && swarm[1].length === 64) return `bzz:/\/${swarm[1]}`;
15179		assert(false, `invalid or unsupported content hash data`, "UNSUPPORTED_OPERATION", {
15180			operation: "getContentHash()",
15181			info: { data }
15182		});
15183	}
15184	async getName() {
15185		return await this.#fetch("name(bytes32)");
15186	}
15187	/**
15188	*  Resolves to the avatar url or ``null`` if the avatar is either
15189	*  unconfigured or incorrectly configured (e.g. references an NFT
15190	*  not owned by the address).
15191	*
15192	*  If diagnosing issues with configurations, the [[_getAvatar]]
15193	*  method may be useful.
15194	*/
15195	async getAvatar() {
15196		return (await this._getAvatar()).url;
15197	}
15198	/**
15199	*  When resolving an avatar, there are many steps involved, such
15200	*  fetching metadata and possibly validating ownership of an
15201	*  NFT.
15202	*
15203	*  This method can be used to examine each step and the value it
15204	*  was working from.
15205	*/
15206	async _getAvatar() {
15207		const linkage = [{
15208			type: "name",
15209			value: this.name
15210		}];
15211		try {
15212			const avatar = await this.getText("avatar");
15213			if (avatar == null) {
15214				linkage.push({
15215					type: "!avatar",
15216					value: ""
15217				});
15218				return {
15219					url: null,
15220					linkage
15221				};
15222			}
15223			linkage.push({
15224				type: "avatar",
15225				value: avatar
15226			});
15227			for (let i = 0; i < matchers.length; i++) {
15228				const match = avatar.match(matchers[i]);
15229				if (match == null) continue;
15230				const scheme = match[1].toLowerCase();
15231				switch (scheme) {
15232					case "https":
15233					case "data":
15234						linkage.push({
15235							type: "url",
15236							value: avatar
15237						});
15238						return {
15239							linkage,
15240							url: avatar
15241						};
15242					case "ipfs": {
15243						const url = getIpfsLink(avatar);
15244						linkage.push({
15245							type: "ipfs",
15246							value: avatar
15247						});
15248						linkage.push({
15249							type: "url",
15250							value: url
15251						});
15252						return {
15253							linkage,
15254							url
15255						};
15256					}
15257					case "erc721":
15258					case "erc1155": {
15259						const selector = scheme === "erc721" ? "tokenURI(uint256)" : "uri(uint256)";
15260						linkage.push({
15261							type: scheme,
15262							value: avatar
15263						});
15264						const owner = await this.getAddress();
15265						if (owner == null) {
15266							linkage.push({
15267								type: "!owner",
15268								value: ""
15269							});
15270							return {
15271								url: null,
15272								linkage
15273							};
15274						}
15275						const comps = (match[2] || "").split("/");
15276						if (comps.length !== 2) {
15277							linkage.push({
15278								type: `!${scheme}caip`,
15279								value: match[2] || ""
15280							});
15281							return {
15282								url: null,
15283								linkage
15284							};
15285						}
15286						const tokenId = comps[1];
15287						const contract = new Contract(comps[0], [
15288							"function tokenURI(uint) view returns (string)",
15289							"function ownerOf(uint) view returns (address)",
15290							"function uri(uint) view returns (string)",
15291							"function balanceOf(address, uint256) view returns (uint)"
15292						], this.provider);
15293						if (scheme === "erc721") {
15294							const tokenOwner = await contract.ownerOf(tokenId);
15295							if (owner !== tokenOwner) {
15296								linkage.push({
15297									type: "!owner",
15298									value: tokenOwner
15299								});
15300								return {
15301									url: null,
15302									linkage
15303								};
15304							}
15305							linkage.push({
15306								type: "owner",
15307								value: tokenOwner
15308							});
15309						} else if (scheme === "erc1155") {
15310							const balance = await contract.balanceOf(owner, tokenId);
15311							if (!balance) {
15312								linkage.push({
15313									type: "!balance",
15314									value: "0"
15315								});
15316								return {
15317									url: null,
15318									linkage
15319								};
15320							}
15321							linkage.push({
15322								type: "balance",
15323								value: balance.toString()
15324							});
15325						}
15326						let metadataUrl = await contract[selector](tokenId);
15327						if (metadataUrl == null || metadataUrl === "0x") {
15328							linkage.push({
15329								type: "!metadata-url",
15330								value: ""
15331							});
15332							return {
15333								url: null,
15334								linkage
15335							};
15336						}
15337						linkage.push({
15338							type: "metadata-url-base",
15339							value: metadataUrl
15340						});
15341						if (scheme === "erc1155") {
15342							metadataUrl = metadataUrl.replace("{id}", toBeHex(tokenId, 32).substring(2));
15343							linkage.push({
15344								type: "metadata-url-expanded",
15345								value: metadataUrl
15346							});
15347						}
15348						if (metadataUrl.match(/^ipfs:/i)) metadataUrl = getIpfsLink(metadataUrl);
15349						linkage.push({
15350							type: "metadata-url",
15351							value: metadataUrl
15352						});
15353						let metadata = {};
15354						const response = await new FetchRequest(metadataUrl).send();
15355						response.assertOk();
15356						try {
15357							metadata = response.bodyJson;
15358						} catch (error) {
15359							try {
15360								linkage.push({
15361									type: "!metadata",
15362									value: response.bodyText
15363								});
15364							} catch (error) {
15365								const bytes = response.body;
15366								if (bytes) linkage.push({
15367									type: "!metadata",
15368									value: hexlify(bytes)
15369								});
15370								return {
15371									url: null,
15372									linkage
15373								};
15374							}
15375							return {
15376								url: null,
15377								linkage
15378							};
15379						}
15380						if (!metadata) {
15381							linkage.push({
15382								type: "!metadata",
15383								value: ""
15384							});
15385							return {
15386								url: null,
15387								linkage
15388							};
15389						}
15390						linkage.push({
15391							type: "metadata",
15392							value: JSON.stringify(metadata)
15393						});
15394						let imageUrl = metadata.image;
15395						if (typeof imageUrl !== "string") {
15396							linkage.push({
15397								type: "!imageUrl",
15398								value: ""
15399							});
15400							return {
15401								url: null,
15402								linkage
15403							};
15404						}
15405						if (imageUrl.match(/^(https:\/\/|data:)/i)) {} else {
15406							if (imageUrl.match(matcherIpfs) == null) {
15407								linkage.push({
15408									type: "!imageUrl-ipfs",
15409									value: imageUrl
15410								});
15411								return {
15412									url: null,
15413									linkage
15414								};
15415							}
15416							linkage.push({
15417								type: "imageUrl-ipfs",
15418								value: imageUrl
15419							});
15420							imageUrl = getIpfsLink(imageUrl);
15421						}
15422						linkage.push({
15423							type: "url",
15424							value: imageUrl
15425						});
15426						return {
15427							linkage,
15428							url: imageUrl
15429						};
15430					}
15431				}
15432			}
15433		} catch (error) {}
15434		return {
15435			linkage,
15436			url: null
15437		};
15438	}
15439	static async getEnsAddress(provider) {
15440		const network = await provider.getNetwork();
15441		const ensPlugin = network.getPlugin("org.ethers.plugins.network.Ens");
15442		assert(ensPlugin, "network does not support ENS", "UNSUPPORTED_OPERATION", {
15443			operation: "getEnsAddress",
15444			info: { network }
15445		});
15446		return ensPlugin.address;
15447	}
15448	static async getUniversalResolverAddress(provider) {
15449		const ensPlugin = (await provider.getNetwork()).getPlugin("org.ethers.plugins.network.Ens");
15450		if (ensPlugin && ensPlugin.universalResolver) return ensPlugin.universalResolver;
15451		return null;
15452	}
15453	static async #getResolver(provider, name) {

15454		const ensAddr = await EnsResolver.getEnsAddress(provider);
15455		try {
15456			const addr = await new Contract(ensAddr, ["function resolver(bytes32) view returns (address)"], provider).resolver(namehash(name), { enableCcipRead: true });
15457			if (addr === "0x0000000000000000000000000000000000000000") return null;
15458			return addr;
15459		} catch (error) {
15460			throw error;
15461		}
15462	}
15463	static async lookupAddress(provider, address, _coinType) {
15464		const coinType = _coinType == null ? BN_60 : getBigInt(_coinType);
15465		if (isEvmCoinType(coinType)) address = getAddress(address);
15466		const universal = await createUniversal(provider);
15467		if (universal) try {
15468			const addr = (await universal.reverse(address, coinType, { enableCcipRead: true })).primary;
15469			if (!isValidName(addr)) return null;
15470			return addr;
15471		} catch (e) {
15472			if (isError(e, "CALL_EXCEPTION") && e.reason === "ResolverNotFound(bytes)") return null;
15473			throw e;
15474		}
15475		assert(coinType === BN_60, "lookupAddress coinType requires ENS Universal Resolver", "UNSUPPORTED_OPERATION", { operation: "lookupAddress" });
15476		try {
15477			const resolver = await EnsResolver.fromName(provider, `${address.toLowerCase().substring(2)}.addr.reverse`);
15478			if (!resolver) return null;
15479			const name = await resolver.getName();
15480			if (name == null || !isValidName(name)) return null;
15481			if (await provider.resolveName(name) !== address) return null;
15482			return name;
15483		} catch (error) {
15484			if (isError(error, "BAD_DATA") && error.value === "0x") return null;
15485			if (isError(error, "CALL_EXCEPTION")) return null;
15486			throw error;
15487		}
15488	}
15489	/**
15490	*  Resolve to the ENS resolver for %%name%% using %%provider%% or
15491	*  ``null`` if unconfigured.
15492	*/
15493	static async fromName(provider, name) {
15494		const universal = await createUniversal(provider);
15495		if (universal) {
15496			let dnsName;
15497			try {
15498				dnsName = dnsEncode(ensNormalize(name), 255);
15499			} catch (error) {
15500				return null;
15501			}
15502			const result = await universal.requireResolver(dnsName);
15503			return new EnsResolver(provider, result.resolver, name, result.extended);
15504		}
15505		let currentName = name;
15506		while (true) {
15507			if (currentName === "" || currentName === ".") return null;
15508			if (name !== "eth" && currentName === "eth") return null;
15509			const addr = await EnsResolver.#getResolver(provider, currentName);
15510			if (addr != null) {
15511				const resolver = new EnsResolver(provider, addr, name);
15512				if (currentName !== name && !await resolver.supportsWildcard()) return null;
15513				return resolver;
15514			}
15515			currentName = currentName.split(".").slice(1).join(".");
15516		}
15517	}
15518};
15519async function createUniversal(provider) {
15520	const address = await EnsResolver.getUniversalResolverAddress(provider);
15521	if (!address) return null;
15522	return new Contract(address, [
15523		"function requireResolver(bytes) view returns ((bytes name, uint256 offset, bytes32 node, address resolver, bool extended))",
15524		"function findResolver(bytes) view returns (address resolver, bytes32 node, uint offset)",
15525		"function resolve(bytes name, bytes data) view returns (bytes result, address resolver)",
15526		"function reverse(bytes name, uint coinType) view returns (string primary, address resolver, address reverseResolver)",
15527		"error ResolverNotFound(bytes name)",
15528		"error ResolverNotContract(bytes name, address resolver)",
15529		"error ReverseAddressMismatch(string primary, bytes primaryAddress)",
15530		"error HttpError(uint16 statusCode, string statusMessage)"
15531	], provider);
15532}
15533//#endregion
15534//#region node_modules/ethers/lib.esm/providers/format.js
15535/**
15536*  @_ignore
15537*/
15538var BN_0 = BigInt(0);
15539function allowNull(format, nullValue) {
15540	return (function(value) {
15541		if (value == null) return nullValue;
15542		return format(value);
15543	});
15544}
15545function arrayOf(format, allowNull) {
15546	return ((array) => {
15547		if (allowNull && array == null) return null;
15548		if (!Array.isArray(array)) throw new Error("not an array");
15549		return array.map((i) => format(i));
15550	});
15551}
15552function object(format, altNames) {
15553	return ((value) => {
15554		const result = {};
15555		for (const key in format) {
15556			let srcKey = key;
15557			if (altNames && key in altNames && !(srcKey in value)) {
15558				for (const altKey of altNames[key]) if (altKey in value) {
15559					srcKey = altKey;
15560					break;
15561				}
15562			}
15563			try {
15564				const nv = format[key](value[srcKey]);
15565				if (nv !== void 0) result[key] = nv;
15566			} catch (error) {
15567				assert(false, `invalid value for value.${key} (${error instanceof Error ? error.message : "not-an-error"})`, "BAD_DATA", { value });
15568			}
15569		}
15570		return result;
15571	});
15572}
15573function formatBoolean(value) {
15574	switch (value) {
15575		case true:
15576		case "true": return true;
15577		case false:
15578		case "false": return false;

15579	}
15580	assertArgument(false, `invalid boolean; ${JSON.stringify(value)}`, "value", value);
15581}
15582function formatData(value) {
15583	assertArgument(isHexString(value, true), "invalid data", "value", value);
15584	return value;
15585}
15586function formatHash(value) {
15587	assertArgument(isHexString(value, 32), "invalid hash", "value", value);
15588	return value;
15589}
15590var _formatLog = object({
15591	address: getAddress,
15592	blockHash: formatHash,
15593	blockNumber: getNumber,
15594	data: formatData,
15595	index: getNumber,
15596	removed: allowNull(formatBoolean, false),
15597	topics: arrayOf(formatHash),
15598	transactionHash: formatHash,
15599	transactionIndex: getNumber
15600}, { index: ["logIndex"] });
15601function formatLog(value) {
15602	return _formatLog(value);
15603}
15604var _formatBlock = object({
15605	hash: allowNull(formatHash),
15606	parentHash: formatHash,
15607	parentBeaconBlockRoot: allowNull(formatHash, null),
15608	number: getNumber,
15609	timestamp: getNumber,
15610	nonce: allowNull(formatData),
15611	difficulty: getBigInt,
15612	gasLimit: getBigInt,
15613	gasUsed: getBigInt,
15614	stateRoot: allowNull(formatHash, null),
15615	receiptsRoot: allowNull(formatHash, null),
15616	transactionsRoot: allowNull(formatHash, null),
15617	blobGasUsed: allowNull(getBigInt, null),
15618	excessBlobGas: allowNull(getBigInt, null),
15619	miner: allowNull(getAddress),
15620	prevRandao: allowNull(formatHash, null),
15621	extraData: formatData,
15622	baseFeePerGas: allowNull(getBigInt)
15623}, { prevRandao: ["mixHash"] });
15624function formatBlock(value) {
15625	const result = _formatBlock(value);
15626	result.transactions = value.transactions.map((tx) => {
15627		if (typeof tx === "string") return tx;
15628		return formatTransactionResponse(tx);
15629	});
15630	return result;
15631}
15632var _formatReceiptLog = object({
15633	transactionIndex: getNumber,
15634	blockNumber: getNumber,
15635	transactionHash: formatHash,
15636	address: getAddress,
15637	topics: arrayOf(formatHash),
15638	data: formatData,
15639	index: getNumber,
15640	blockHash: formatHash
15641}, { index: ["logIndex"] });
15642function formatReceiptLog(value) {
15643	return _formatReceiptLog(value);
15644}
15645var _formatTransactionReceipt = object({
15646	to: allowNull(getAddress, null),
15647	from: allowNull(getAddress, null),
15648	contractAddress: allowNull(getAddress, null),
15649	index: getNumber,
15650	root: allowNull(hexlify),
15651	gasUsed: getBigInt,
15652	blobGasUsed: allowNull(getBigInt, null),
15653	logsBloom: allowNull(formatData),
15654	blockHash: formatHash,
15655	hash: formatHash,
15656	logs: arrayOf(formatReceiptLog),
15657	blockNumber: getNumber,
15658	cumulativeGasUsed: getBigInt,
15659	effectiveGasPrice: allowNull(getBigInt),
15660	blobGasPrice: allowNull(getBigInt, null),
15661	status: allowNull(getNumber),
15662	type: allowNull(getNumber, 0)
15663}, {
15664	effectiveGasPrice: ["gasPrice"],
15665	hash: ["transactionHash"],
15666	index: ["transactionIndex"]
15667});
15668function formatTransactionReceipt(value) {
15669	return _formatTransactionReceipt(value);
15670}
15671function formatTransactionResponse(value) {
15672	if (value.to && getBigInt(value.to) === BN_0) value.to = "0x0000000000000000000000000000000000000000";
15673	const result = object({
15674		hash: formatHash,
15675		index: allowNull(getNumber, void 0),
15676		type: (value) => {
15677			if (value === "0x" || value == null) return 0;
15678			return getNumber(value);
15679		},
15680		accessList: allowNull(accessListify, null),
15681		blobVersionedHashes: allowNull(arrayOf(formatHash, true), null),
15682		authorizationList: allowNull(arrayOf((v) => {
15683			let sig;
15684			if (v.signature) sig = v.signature;
15685			else {
15686				let yParity = v.yParity;
15687				if (yParity === "0x1b") yParity = 0;
15688				else if (yParity === "0x1c") yParity = 1;
15689				sig = Object.assign({}, v, { yParity });
15690			}
15691			return {
15692				address: getAddress(v.address),
15693				chainId: getBigInt(v.chainId),
15694				nonce: getBigInt(v.nonce),
15695				signature: Signature.from(sig)
15696			};
15697		}, false), null),
15698		blockHash: allowNull(formatHash, null),
15699		blockNumber: allowNull(getNumber, null),
15700		transactionIndex: allowNull(getNumber, null),
15701		from: getAddress,
15702		gasPrice: allowNull(getBigInt),
15703		maxPriorityFeePerGas: allowNull(getBigInt),
15704		maxFeePerGas: allowNull(getBigInt),
15705		maxFeePerBlobGas: allowNull(getBigInt, null),
15706		gasLimit: getBigInt,
15707		to: allowNull(getAddress, null),
15708		value: getBigInt,
15709		nonce: getNumber,
15710		data: formatData,
15711		creates: allowNull(getAddress, null),
15712		chainId: allowNull(getBigInt, null)
15713	}, {
15714		data: ["input"],
15715		gasLimit: ["gas"],
15716		index: ["transactionIndex"]
15717	})(value);
15718	if (result.to == null && result.creates == null) result.creates = getCreateAddress(result);
15719	if ((value.type === 1 || value.type === 2) && value.accessList == null) result.accessList = [];
15720	if (value.signature) result.signature = Signature.from(value.signature);
15721	else result.signature = Signature.from(value);
15722	if (result.chainId == null) {
15723		const chainId = result.signature.legacyChainId;
15724		if (chainId != null) result.chainId = chainId;
15725	}
15726	if (result.blockHash && getBigInt(result.blockHash) === BN_0) result.blockHash = null;
15727	return result;
15728}
15729//#endregion
15730//#region node_modules/ethers/lib.esm/providers/plugins-network.js
15731var EnsAddress = "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e";
15732var inspect$1 = Symbol.for("nodejs.util.inspect.custom");
15733/**
15734*  A **NetworkPlugin** provides additional functionality on a [[Network]].
15735*/
15736var NetworkPlugin = class NetworkPlugin {
15737	/**
15738	*  The name of the plugin.
15739	*
15740	*  It is recommended to use reverse-domain-notation, which permits
15741	*  unique names with a known authority as well as hierarchal entries.
15742	*/
15743	name;
15744	/**

15745	*  Creates a new **NetworkPlugin**.
15746	*/
15747	constructor(name) {
15748		defineProperties(this, { name });
15749	}
15750	[inspect$1]() {
15751		return this.toString();
15752	}
15753	toString() {
15754		return `${this.name} { }`;
15755	}
15756	/**
15757	*  Creates a copy of this plugin.
15758	*/
15759	clone() {
15760		return new NetworkPlugin(this.name);
15761	}
15762};
15763/**
15764*  A **GasCostPlugin** allows a network to provide alternative values when
15765*  computing the intrinsic gas required for a transaction.
15766*/
15767var GasCostPlugin = class GasCostPlugin extends NetworkPlugin {
15768	/**
15769	*  The block number to treat these values as valid from.
15770	*
15771	*  This allows a hardfork to have updated values included as well as
15772	*  mulutiple hardforks to be supported.
15773	*/
15774	effectiveBlock;
15775	/**
15776	*  The transactions base fee.
15777	*/
15778	txBase;
15779	/**
15780	*  The fee for creating a new account.
15781	*/
15782	txCreate;
15783	/**
15784	*  The fee per zero-byte in the data.
15785	*/
15786	txDataZero;
15787	/**
15788	*  The fee per non-zero-byte in the data.
15789	*/
15790	txDataNonzero;
15791	/**
15792	*  The fee per storage key in the [[link-eip-2930]] access list.
15793	*/
15794	txAccessListStorageKey;
15795	/**
15796	*  The fee per address in the [[link-eip-2930]] access list.
15797	*/
15798	txAccessListAddress;
15799	/**
15800	*  Creates a new GasCostPlugin from %%effectiveBlock%% until the
15801	*  latest block or another GasCostPlugin supercedes that block number,
15802	*  with the associated %%costs%%.
15803	*/
15804	constructor(effectiveBlock, costs) {
15805		if (effectiveBlock == null) effectiveBlock = 0;
15806		super(`org.ethers.network.plugins.GasCost#${effectiveBlock || 0}`);
15807		const props = { effectiveBlock };
15808		function set(name, nullish) {
15809			let value = (costs || {})[name];
15810			if (value == null) value = nullish;
15811			assertArgument(typeof value === "number", `invalud value for ${name}`, "costs", costs);
15812			props[name] = value;
15813		}
15814		set("txBase", 21e3);
15815		set("txCreate", 32e3);
15816		set("txDataZero", 4);
15817		set("txDataNonzero", 16);
15818		set("txAccessListStorageKey", 1900);
15819		set("txAccessListAddress", 2400);
15820		defineProperties(this, props);
15821	}
15822	toString() {
15823		return `${this.name} { txBase: ${this.txBase}, txCreate: ${this.txCreate}, txDataZero: ${this.txDataZero}, txAccessListStorageKey: ${this.txAccessListStorageKey}, txAccessListAddress: ${this.txAccessListAddress} }`;
15824	}
15825	clone() {
15826		return new GasCostPlugin(this.effectiveBlock, this);
15827	}
15828};
15829/**
15830*  An **EnsPlugin** allows a [[Network]] to specify the ENS Registry
15831*  Contract address and the target network to use when using that
15832*  contract.
15833*
15834*  Various testnets have their own instance of the contract to use, but
15835*  in general, the mainnet instance supports multi-chain addresses and
15836*  should be used.
15837*/
15838var EnsPlugin = class EnsPlugin extends NetworkPlugin {
15839	/**
15840	*  The ENS Registrty Contract address.
15841	*/
15842	address;
15843	/**
15844	*  The chain ID that the ENS contract lives on.
15845	*/
15846	targetNetwork;
15847	/**
15848	*  The Universal Resolver Contract Address.
15849	*/
15850	universalResolver;
15851	/**
15852	*  Creates a new **EnsPlugin** connected to %%address%% on the
15853	*  %%targetNetwork%%. The default ENS address and mainnet is used
15854	*  if unspecified.
15855	*/
15856	constructor(address, targetNetwork, universalResolver) {
15857		super("org.ethers.plugins.network.Ens");
15858		defineProperties(this, {
15859			address: address || EnsAddress,
15860			targetNetwork: targetNetwork == null ? 1 : targetNetwork,
15861			universalResolver
15862		});
15863	}
15864	toString() {
15865		return `${this.name} { address: ${this.address}, targetNetwork: ${this.targetNetwork}, universalResolver: ${this.universalResolver} }`;
15866	}
15867	clone() {
15868		return new EnsPlugin(this.address, this.targetNetwork, this.universalResolver);
15869	}
15870};
15871/**
15872*  A **FeeDataNetworkPlugin** allows a network to provide and alternate
15873*  means to specify its fee data.
15874*
15875*  For example, a network which does not support [[link-eip-1559]] may
15876*  choose to use a Gas Station site to approximate the gas price.
15877*/
15878var FeeDataNetworkPlugin = class FeeDataNetworkPlugin extends NetworkPlugin {
15879	#feeDataFunc;
15880	/**
15881	*  The fee data function provided to the constructor.
15882	*/
15883	get feeDataFunc() {
15884		return this.#feeDataFunc;
15885	}
15886	/**
15887	*  Creates a new **FeeDataNetworkPlugin**.
15888	*/
15889	constructor(feeDataFunc) {
15890		super("org.ethers.plugins.network.FeeData");
15891		this.#feeDataFunc = feeDataFunc;
15892	}
15893	/**
15894	*  Resolves to the fee data.
15895	*/
15896	async getFeeData(provider) {
15897		return await this.#feeDataFunc(provider);
15898	}
15899	clone() {
15900		return new FeeDataNetworkPlugin(this.#feeDataFunc);
15901	}
15902};
15903var FetchUrlFeeDataNetworkPlugin = class extends NetworkPlugin {
15904	#url;

15905	#processFunc;
15906	/**
15907	*  The URL to initialize the FetchRequest with in %%processFunc%%.
15908	*/
15909	get url() {
15910		return this.#url;
15911	}
15912	/**
15913	*  The callback to use when computing the FeeData.
15914	*/
15915	get processFunc() {
15916		return this.#processFunc;
15917	}
15918	/**
15919	*  Creates a new **FetchUrlFeeDataNetworkPlugin** which will
15920	*  be used when computing the fee data for the network.
15921	*/
15922	constructor(url, processFunc) {
15923		super("org.ethers.plugins.network.FetchUrlFeeDataPlugin");
15924		this.#url = url;
15925		this.#processFunc = processFunc;
15926	}
15927	toString() {
15928		return `${this.name} { url: ${this.url} }`;
15929	}
15930	clone() {
15931		return this;
15932	}
15933};
15934//#endregion
15935//#region node_modules/ethers/lib.esm/providers/network.js
15936/**
15937*  A **Network** encapsulates the various properties required to
15938*  interact with a specific chain.
15939*
15940*  @_subsection: api/providers:Networks  [networks]
15941*/
15942var inspect = Symbol.for("nodejs.util.inspect.custom");
15943var Networks = /* @__PURE__ */ new Map();
15944/**
15945*  A **Network** provides access to a chain's properties and allows
15946*  for plug-ins to extend functionality.
15947*/
15948var Network = class Network {
15949	#name;
15950	#chainId;
15951	#plugins;
15952	/**
15953	*  Creates a new **Network** for %%name%% and %%chainId%%.
15954	*/
15955	constructor(name, chainId) {
15956		this.#name = name;
15957		this.#chainId = getBigInt(chainId);
15958		this.#plugins = /* @__PURE__ */ new Map();
15959	}
15960	[inspect]() {
15961		return this.toString();
15962	}
15963	toString() {
15964		const plugins = [];
15965		for (const plugin of this.#plugins.values()) plugins.push(plugin.toString());
15966		return `Network { name: ${this.name}, chainId: ${this.chainId}, plugins: [ ${plugins.join(", ")} ] }`;
15967	}
15968	/**
15969	*  Returns a JSON-compatible representation of a Network.
15970	*/
15971	toJSON() {
15972		return {
15973			name: this.name,
15974			chainId: String(this.chainId)
15975		};
15976	}
15977	/**
15978	*  The network common name.
15979	*
15980	*  This is the canonical name, as networks migh have multiple
15981	*  names.
15982	*/
15983	get name() {
15984		return this.#name;
15985	}
15986	set name(value) {
15987		this.#name = value;
15988	}
15989	/**
15990	*  The network chain ID.
15991	*/
15992	get chainId() {
15993		return this.#chainId;
15994	}
15995	set chainId(value) {
15996		this.#chainId = getBigInt(value, "chainId");
15997	}
15998	/**
15999	*  Returns true if %%other%% matches this network. Any chain ID
16000	*  must match, and if no chain ID is present, the name must match.
16001	*
16002	*  This method does not currently check for additional properties,
16003	*  such as ENS address or plug-in compatibility.
16004	*/
16005	matches(other) {
16006		if (other == null) return false;
16007		if (typeof other === "string") {
16008			try {
16009				return this.chainId === getBigInt(other);
16010			} catch (error) {}
16011			return this.name === other;
16012		}
16013		if (typeof other === "number" || typeof other === "bigint") {
16014			try {
16015				return this.chainId === getBigInt(other);
16016			} catch (error) {}
16017			return false;
16018		}
16019		if (typeof other === "object") {
16020			if (other.chainId != null) {
16021				try {
16022					return this.chainId === getBigInt(other.chainId);
16023				} catch (error) {}
16024				return false;
16025			}
16026			if (other.name != null) return this.name === other.name;
16027			return false;
16028		}
16029		return false;
16030	}
16031	/**
16032	*  Returns the list of plugins currently attached to this Network.
16033	*/
16034	get plugins() {
16035		return Array.from(this.#plugins.values());
16036	}
16037	/**
16038	*  Attach a new %%plugin%% to this Network. The network name
16039	*  must be unique, excluding any fragment.
16040	*/
16041	attachPlugin(plugin) {
16042		if (this.#plugins.get(plugin.name)) throw new Error(`cannot replace existing plugin: ${plugin.name} `);
16043		this.#plugins.set(plugin.name, plugin.clone());
16044		return this;
16045	}
16046	/**
16047	*  Return the plugin, if any, matching %%name%% exactly. Plugins
16048	*  with fragments will not be returned unless %%name%% includes
16049	*  a fragment.
16050	*/
16051	getPlugin(name) {
16052		return this.#plugins.get(name) || null;
16053	}
16054	/**
16055	*  Gets a list of all plugins that match %%name%%, with otr without
16056	*  a fragment.
16057	*/
16058	getPlugins(basename) {
16059		return this.plugins.filter((p) => p.name.split("#")[0] === basename);
16060	}
16061	/**
16062	*  Create a copy of this Network.
16063	*/
16064	clone() {
16065		const clone = new Network(this.name, this.chainId);
16066		this.plugins.forEach((plugin) => {
16067			clone.attachPlugin(plugin.clone());
16068		});
16069		return clone;
16070	}
16071	/**
16072	*  Compute the intrinsic gas required for a transaction.
16073	*
16074	*  A GasCostPlugin can be attached to override the default
16075	*  values.
16076	*/
16077	computeIntrinsicGas(tx) {
16078		const costs = this.getPlugin("org.ethers.plugins.network.GasCost") || new GasCostPlugin();
16079		let gas = costs.txBase;
16080		if (tx.to == null) gas += costs.txCreate;
16081		if (tx.data) for (let i = 2; i < tx.data.length; i += 2) if (tx.data.substring(i, i + 2) === "00") gas += costs.txDataZero;
16082		else gas += costs.txDataNonzero;
16083		if (tx.accessList) {
16084			const accessList = accessListify(tx.accessList);
16085			for (const addr in accessList) gas += costs.txAccessListAddress + costs.txAccessListStorageKey * accessList[addr].storageKeys.length;
16086		}
16087		return gas;
16088	}
16089	/**
16090	*  Returns a new Network for the %%network%% name or chainId.
16091	*/
16092	static from(network) {
16093		injectCommonNetworks();
16094		if (network == null) return Network.from("mainnet");
16095		if (typeof network === "number") network = BigInt(network);
16096		if (typeof network === "string" || typeof network === "bigint") {
16097			const networkFunc = Networks.get(network);
16098			if (networkFunc) return networkFunc();
16099			if (typeof network === "bigint") return new Network("unknown", network);
16100			assertArgument(false, "unknown network", "network", network);
16101		}
16102		if (typeof network.clone === "function") return network.clone();
16103		if (typeof network === "object") {
16104			assertArgument(typeof network.name === "string" && typeof network.chainId === "number", "invalid network object name or chainId", "network", network);
16105			const custom = new Network(network.name, network.chainId);
16106			const n = network;
16107			if (n.ensAddress || n.ensNetwork != null || n.ensUniversalResolver) custom.attachPlugin(new EnsPlugin(n.ensAddress, n.ensNetwork, n.ensUniversalResolver));
16108			return custom;
16109		}
16110		assertArgument(false, "invalid network", "network", network);
16111	}
16112	/**
16113	*  Register %%nameOrChainId%% with a function which returns
16114	*  an instance of a Network representing that chain.
16115	*/
16116	static register(nameOrChainId, networkFunc) {
16117		if (typeof nameOrChainId === "number") nameOrChainId = BigInt(nameOrChainId);
16118		const existing = Networks.get(nameOrChainId);
16119		if (existing) assertArgument(false, `conflicting network for ${JSON.stringify(existing.name)}`, "nameOrChainId", nameOrChainId);
16120		Networks.set(nameOrChainId, networkFunc);
16121	}
16122};
16123function parseUnits$1(_value, decimals) {

16124	const value = String(_value);
16125	if (!value.match(/^[0-9.]+$/)) throw new Error(`invalid gwei value: ${_value}`);
16126	const comps = value.split(".");
16127	if (comps.length === 1) comps.push("");
16128	if (comps.length !== 2) throw new Error(`invalid gwei value: ${_value}`);
16129	while (comps[1].length < decimals) comps[1] += "0";
16130	if (comps[1].length > 9) {
16131		let frac = BigInt(comps[1].substring(0, 9));
16132		if (!comps[1].substring(9).match(/^0+$/)) frac++;
16133		comps[1] = frac.toString();
16134	}
16135	return BigInt(comps[0] + comps[1]);
16136}
16137function getGasStationPlugin(url) {
16138	return new FetchUrlFeeDataNetworkPlugin(url, async (fetchFeeData, provider, request) => {
16139		request.setHeader("User-Agent", "ethers");
16140		let response;
16141		try {
16142			const [_response, _feeData] = await Promise.all([request.send(), fetchFeeData()]);
16143			response = _response;
16144			const payload = response.bodyJson.standard;
16145			return {
16146				gasPrice: _feeData.gasPrice,
16147				maxFeePerGas: parseUnits$1(payload.maxFee, 9),
16148				maxPriorityFeePerGas: parseUnits$1(payload.maxPriorityFee, 9)
16149			};
16150		} catch (error) {
16151			assert(false, `error encountered with polygon gas station (${JSON.stringify(request.url)})`, "SERVER_ERROR", {
16152				request,
16153				response,
16154				error
16155			});
16156		}
16157	});
16158}
16159var injected = false;
16160function injectCommonNetworks() {
16161	if (injected) return;
16162	injected = true;
16163	function registerEth(name, chainId, options) {
16164		const func = function() {
16165			const network = new Network(name, chainId);
16166			if (options.ensNetwork != null) network.attachPlugin(new EnsPlugin(null, options.ensNetwork, options.ensUniversalResolver));
16167			network.attachPlugin(new GasCostPlugin());
16168			(options.plugins || []).forEach((plugin) => {
16169				network.attachPlugin(plugin);
16170			});
16171			return network;
16172		};
16173		Network.register(name, func);
16174		Network.register(chainId, func);
16175		if (options.altNames) options.altNames.forEach((name) => {
16176			Network.register(name, func);
16177		});
16178	}
16179	const ensUniversalResolver = "0xeEeEEEeE14D718C2B47D9923Deab1335E144EeEe";
16180	registerEth("mainnet", 1, {
16181		ensUniversalResolver,
16182		ensNetwork: 1,
16183		altNames: ["homestead"]
16184	});
16185	registerEth("ropsten", 3, { ensNetwork: 3 });
16186	registerEth("rinkeby", 4, { ensNetwork: 4 });
16187	registerEth("goerli", 5, { ensNetwork: 5 });
16188	registerEth("kovan", 42, { ensNetwork: 42 });
16189	registerEth("sepolia", 11155111, {
16190		ensUniversalResolver,
16191		ensNetwork: 11155111
16192	});
16193	registerEth("holesky", 17e3, { ensNetwork: 17e3 });
16194	registerEth("classic", 61, {});

16195	registerEth("classicKotti", 6, {});
16196	registerEth("arbitrum", 42161, { ensNetwork: 1 });
16197	registerEth("arbitrum-goerli", 421613, {});
16198	registerEth("arbitrum-sepolia", 421614, {});
16199	registerEth("base", 8453, { ensNetwork: 1 });
16200	registerEth("base-goerli", 84531, {});
16201	registerEth("base-sepolia", 84532, {});
16202	registerEth("bnb", 56, { ensNetwork: 1 });
16203	registerEth("bnbt", 97, {});
16204	registerEth("filecoin", 314, {});
16205	registerEth("filecoin-calibration", 314159, {});
16206	registerEth("linea", 59144, { ensNetwork: 1 });
16207	registerEth("linea-goerli", 59140, {});
16208	registerEth("linea-sepolia", 59141, {});
16209	registerEth("matic", 137, {
16210		ensNetwork: 1,
16211		plugins: [getGasStationPlugin("https://gasstation.polygon.technology/v2")]
16212	});
16213	registerEth("matic-amoy", 80002, {});
16214	registerEth("matic-mumbai", 80001, {
16215		altNames: ["maticMumbai", "maticmum"],
16216		plugins: [getGasStationPlugin("https://gasstation-testnet.polygon.technology/v2")]
16217	});
16218	registerEth("optimism", 10, {
16219		ensNetwork: 1,
16220		plugins: []
16221	});
16222	registerEth("optimism-goerli", 420, {});
16223	registerEth("optimism-sepolia", 11155420, {});
16224	registerEth("xdai", 100, { ensNetwork: 1 });
16225}
16226//#endregion
16227//#region node_modules/ethers/lib.esm/providers/subscriber-polling.js
16228function copy$2(obj) {
16229	return JSON.parse(JSON.stringify(obj));
16230}
16231/**
16232*  A **PollingBlockSubscriber** polls at a regular interval for a change
16233*  in the block number.
16234*
16235*  @_docloc: api/providers/abstract-provider
16236*/
16237var PollingBlockSubscriber = class {
16238	#provider;
16239	#poller;
16240	#interval;
16241	#blockNumber;
16242	/**
16243	*  Create a new **PollingBlockSubscriber** attached to %%provider%%.
16244	*/
16245	constructor(provider) {
16246		this.#provider = provider;
16247		this.#poller = null;
16248		this.#interval = 4e3;
16249		this.#blockNumber = -2;
16250	}
16251	/**
16252	*  The polling interval.
16253	*/
16254	get pollingInterval() {
16255		return this.#interval;
16256	}
16257	set pollingInterval(value) {
16258		this.#interval = value;
16259	}
16260	async #poll() {
16261		try {
16262			const blockNumber = await this.#provider.getBlockNumber();
16263			if (this.#blockNumber === -2) {
16264				this.#blockNumber = blockNumber;
16265				return;
16266			}
16267			if (blockNumber !== this.#blockNumber) {
16268				for (let b = this.#blockNumber + 1; b <= blockNumber; b++) {
16269					if (this.#poller == null) return;
16270					await this.#provider.emit("block", b);
16271				}
16272				this.#blockNumber = blockNumber;
16273			}
16274		} catch (error) {}
16275		if (this.#poller == null) return;
16276		this.#poller = this.#provider._setTimeout(this.#poll.bind(this), this.#interval);
16277	}
16278	start() {
16279		if (this.#poller) return;
16280		this.#poller = this.#provider._setTimeout(this.#poll.bind(this), this.#interval);
16281		this.#poll();
16282	}
16283	stop() {
16284		if (!this.#poller) return;
16285		this.#provider._clearTimeout(this.#poller);
16286		this.#poller = null;
16287	}
16288	pause(dropWhilePaused) {
16289		this.stop();
16290		if (dropWhilePaused) this.#blockNumber = -2;
16291	}
16292	resume() {
16293		this.start();
16294	}
16295};
16296/**
16297*  An **OnBlockSubscriber** can be sub-classed, with a [[_poll]]
16298*  implmentation which will be called on every new block.
16299*
16300*  @_docloc: api/providers/abstract-provider
16301*/
16302var OnBlockSubscriber = class {
16303	#provider;
16304	#poll;
16305	#running;
16306	/**
16307	*  Create a new **OnBlockSubscriber** attached to %%provider%%.
16308	*/
16309	constructor(provider) {
16310		this.#provider = provider;
16311		this.#running = false;
16312		this.#poll = (blockNumber) => {
16313			this._poll(blockNumber, this.#provider);
16314		};
16315	}
16316	/**
16317	*  Called on every new block.
16318	*/
16319	async _poll(blockNumber, provider) {
16320		throw new Error("sub-classes must override this");
16321	}
16322	start() {
16323		if (this.#running) return;
16324		this.#running = true;
16325		this.#poll(-2);
16326		this.#provider.on("block", this.#poll);
16327	}
16328	stop() {
16329		if (!this.#running) return;
16330		this.#running = false;
16331		this.#provider.off("block", this.#poll);
16332	}
16333	pause(dropWhilePaused) {
16334		this.stop();
16335	}
16336	resume() {
16337		this.start();
16338	}
16339};
16340var PollingBlockTagSubscriber = class extends OnBlockSubscriber {
16341	#tag;
16342	#lastBlock;
16343	constructor(provider, tag) {
16344		super(provider);
16345		this.#tag = tag;
16346		this.#lastBlock = -2;
16347	}
16348	pause(dropWhilePaused) {
16349		if (dropWhilePaused) this.#lastBlock = -2;
16350		super.pause(dropWhilePaused);
16351	}
16352	async _poll(blockNumber, provider) {
16353		const block = await provider.getBlock(this.#tag);
16354		if (block == null) return;
16355		if (this.#lastBlock === -2) this.#lastBlock = block.number;
16356		else if (block.number > this.#lastBlock) {
16357			provider.emit(this.#tag, block.number);
16358			this.#lastBlock = block.number;
16359		}
16360	}
16361};
16362/**
16363*  @_ignore:
16364*
16365*  @_docloc: api/providers/abstract-provider
16366*/
16367var PollingOrphanSubscriber = class extends OnBlockSubscriber {
16368	#filter;

16369	constructor(provider, filter) {
16370		super(provider);
16371		this.#filter = copy$2(filter);
16372	}
16373	async _poll(blockNumber, provider) {
16374		throw new Error("@TODO");
16375	}
16376};
16377/**
16378*  A **PollingTransactionSubscriber** will poll for a given transaction
16379*  hash for its receipt.
16380*
16381*  @_docloc: api/providers/abstract-provider
16382*/
16383var PollingTransactionSubscriber = class extends OnBlockSubscriber {
16384	#hash;
16385	/**
16386	*  Create a new **PollingTransactionSubscriber** attached to
16387	*  %%provider%%, listening for %%hash%%.
16388	*/
16389	constructor(provider, hash) {
16390		super(provider);
16391		this.#hash = hash;
16392	}
16393	async _poll(blockNumber, provider) {
16394		const tx = await provider.getTransactionReceipt(this.#hash);
16395		if (tx) provider.emit(this.#hash, tx);
16396	}
16397};
16398/**
16399*  A **PollingEventSubscriber** will poll for a given filter for its logs.
16400*
16401*  @_docloc: api/providers/abstract-provider
16402*/
16403var PollingEventSubscriber = class {
16404	#provider;
16405	#filter;
16406	#poller;
16407	#running;
16408	#blockNumber;
16409	/**
16410	*  Create a new **PollingTransactionSubscriber** attached to
16411	*  %%provider%%, listening for %%filter%%.
16412	*/
16413	constructor(provider, filter) {
16414		this.#provider = provider;
16415		this.#filter = copy$2(filter);
16416		this.#poller = this.#poll.bind(this);
16417		this.#running = false;
16418		this.#blockNumber = -2;
16419	}
16420	async #poll(blockNumber) {
16421		if (this.#blockNumber === -2) return;
16422		const filter = copy$2(this.#filter);
16423		filter.fromBlock = this.#blockNumber + 1;
16424		filter.toBlock = blockNumber;
16425		const logs = await this.#provider.getLogs(filter);
16426		if (logs.length === 0) {
16427			if (this.#blockNumber < blockNumber - 60) this.#blockNumber = blockNumber - 60;
16428			return;
16429		}
16430		for (const log of logs) {
16431			this.#provider.emit(this.#filter, log);
16432			this.#blockNumber = log.blockNumber;
16433		}
16434	}
16435	start() {
16436		if (this.#running) return;
16437		this.#running = true;
16438		if (this.#blockNumber === -2) this.#provider.getBlockNumber().then((blockNumber) => {
16439			this.#blockNumber = blockNumber;
16440		});
16441		this.#provider.on("block", this.#poller);
16442	}
16443	stop() {
16444		if (!this.#running) return;
16445		this.#running = false;
16446		this.#provider.off("block", this.#poller);
16447	}
16448	pause(dropWhilePaused) {
16449		this.stop();
16450		if (dropWhilePaused) this.#blockNumber = -2;
16451	}
16452	resume() {
16453		this.start();
16454	}
16455};
16456//#endregion
16457//#region node_modules/ethers/lib.esm/providers/abstract-provider.js
16458/**
16459*  The available providers should suffice for most developers purposes,
16460*  but the [[AbstractProvider]] class has many features which enable
16461*  sub-classing it for specific purposes.
16462*
16463*  @_section: api/providers/abstract-provider: Subclassing Provider  [abstract-provider]
16464*/
16465var BN_2$1 = BigInt(2);
16466var MAX_CCIP_REDIRECTS = 10;
16467function stall$4(duration) {
16468	return new Promise((resolve) => {
16469		setTimeout(resolve, duration);
16470	});
16471}
16472function isPromise$1(value) {
16473	return value && typeof value.then === "function";
16474}
16475function getTag(prefix, value) {
16476	return prefix + ":" + JSON.stringify(value, (k, v) => {
16477		if (v == null) return "null";
16478		if (typeof v === "bigint") return `bigint:${v.toString()}`;
16479		if (typeof v === "string") return v.toLowerCase();
16480		if (typeof v === "object" && !Array.isArray(v)) {
16481			const keys = Object.keys(v);
16482			keys.sort();
16483			return keys.reduce((accum, key) => {
16484				accum[key] = v[key];
16485				return accum;
16486			}, {});
16487		}
16488		return v;
16489	});
16490}
16491/**
16492*  An **UnmanagedSubscriber** is useful for events which do not require
16493*  any additional management, such as ``"debug"`` which only requires
16494*  emit in synchronous event loop triggered calls.
16495*/
16496var UnmanagedSubscriber = class {
16497	/**
16498	*  The name fof the event.
16499	*/
16500	name;
16501	/**
16502	*  Create a new UnmanagedSubscriber with %%name%%.
16503	*/
16504	constructor(name) {
16505		defineProperties(this, { name });
16506	}
16507	start() {}
16508	stop() {}
16509	pause(dropWhilePaused) {}
16510	resume() {}
16511};
16512function copy$1(value) {
16513	return JSON.parse(JSON.stringify(value));
16514}
16515function concisify(items) {
16516	items = Array.from(new Set(items).values());
16517	items.sort();
16518	return items;
16519}
16520async function getSubscription(_event, provider) {
16521	if (_event == null) throw new Error("invalid event");
16522	if (Array.isArray(_event)) _event = { topics: _event };
16523	if (typeof _event === "string") switch (_event) {
16524		case "block":
16525		case "debug":
16526		case "error":
16527		case "finalized":
16528		case "network":
16529		case "pending":
16530		case "safe": return {
16531			type: _event,
16532			tag: _event
16533		};
16534	}
16535	if (isHexString(_event, 32)) {
16536		const hash = _event.toLowerCase();
16537		return {
16538			type: "transaction",
16539			tag: getTag("tx", { hash }),
16540			hash
16541		};
16542	}
16543	if (_event.orphan) {
16544		const event = _event;
16545		return {
16546			type: "orphan",
16547			tag: getTag("orphan", event),
16548			filter: copy$1(event)
16549		};
16550	}
16551	if (_event.address || _event.topics) {
16552		const event = _event;
16553		const filter = { topics: (event.topics || []).map((t) => {
16554			if (t == null) return null;
16555			if (Array.isArray(t)) return concisify(t.map((t) => t.toLowerCase()));
16556			return t.toLowerCase();
16557		}) };
16558		if (event.address) {
16559			const addresses = [];
16560			const promises = [];
16561			const addAddress = (addr) => {
16562				if (isHexString(addr)) addresses.push(addr);
16563				else promises.push((async () => {
16564					addresses.push(await resolveAddress(addr, provider));
16565				})());
16566			};
16567			if (Array.isArray(event.address)) event.address.forEach(addAddress);
16568			else addAddress(event.address);
16569			if (promises.length) await Promise.all(promises);
16570			filter.address = concisify(addresses.map((a) => a.toLowerCase()));
16571		}
16572		return {
16573			filter,
16574			tag: getTag("event", filter),
16575			type: "event"
16576		};
16577	}
16578	assertArgument(false, "unknown ProviderEvent", "event", _event);
16579}
16580function getTime$1() {
16581	return (/* @__PURE__ */ new Date()).getTime();
16582}
16583var defaultOptions$1 = {
16584	cacheTimeout: 250,
16585	pollingInterval: 4e3
16586};
16587/**
16588*  An **AbstractProvider** provides a base class for other sub-classes to
16589*  implement the [[Provider]] API by normalizing input arguments and
16590*  formatting output results as well as tracking events for consistent
16591*  behaviour on an eventually-consistent network.
16592*/
16593var AbstractProvider = class {
16594	#subs;
16595	#plugins;
16596	#pausedState;
16597	#destroyed;
16598	#networkPromise;
16599	#anyNetwork;
16600	#performCache;
16601	#lastBlockNumber;
16602	#nextTimer;
16603	#timers;
16604	#disableCcipRead;
16605	#requestRate;
16606	#requestTimes;
16607	#options;
16608	/**
16609	*  Create a new **AbstractProvider** connected to %%network%%, or

16610	*  use the various network detection capabilities to discover the
16611	*  [[Network]] if necessary.
16612	*/
16613	constructor(_network, options) {
16614		this.#options = Object.assign({}, defaultOptions$1, options || {});
16615		if (_network === "any") {
16616			this.#anyNetwork = true;
16617			this.#networkPromise = null;
16618		} else if (_network) {
16619			const network = Network.from(_network);
16620			this.#anyNetwork = false;
16621			this.#networkPromise = Promise.resolve(network);
16622			setTimeout(() => {
16623				this.emit("network", network, null);
16624			}, 0);
16625		} else {
16626			this.#anyNetwork = false;
16627			this.#networkPromise = null;
16628		}
16629		this.#lastBlockNumber = -1;
16630		this.#performCache = /* @__PURE__ */ new Map();
16631		this.#subs = /* @__PURE__ */ new Map();
16632		this.#plugins = /* @__PURE__ */ new Map();
16633		this.#pausedState = null;
16634		this.#destroyed = false;
16635		this.#nextTimer = 1;
16636		this.#timers = /* @__PURE__ */ new Map();
16637		this.#disableCcipRead = false;
16638		this.#requestRate = 0;
16639		this.#requestTimes = [];
16640	}
16641	/**
16642	*  Limit the number of requests per second. (default: no limit)
16643	*/
16644	get _requestRate() {
16645		const value = this.#requestRate;
16646		if (value == 0) return null;
16647		return value;
16648	}
16649	set _requestRate(value) {
16650		if (value == null || value < 0) value = 0;
16651		this.#requestRate = getNumber(value);
16652	}
16653	get pollingInterval() {
16654		return this.#options.pollingInterval;
16655	}
16656	/**
16657	*  Returns ``this``, to allow an **AbstractProvider** to implement
16658	*  the [[ContractRunner]] interface.
16659	*/
16660	get provider() {
16661		return this;
16662	}
16663	/**
16664	*  Returns all the registered plug-ins.
16665	*/
16666	get plugins() {
16667		return Array.from(this.#plugins.values());
16668	}
16669	/**
16670	*  Attach a new plug-in.
16671	*/
16672	attachPlugin(plugin) {
16673		if (this.#plugins.get(plugin.name)) throw new Error(`cannot replace existing plugin: ${plugin.name} `);
16674		this.#plugins.set(plugin.name, plugin.connect(this));
16675		return this;
16676	}
16677	/**
16678	*  Get a plugin by name.
16679	*/
16680	getPlugin(name) {
16681		return this.#plugins.get(name) || null;
16682	}
16683	/**
16684	*  Prevent any CCIP-read operation, regardless of whether requested
16685	*  in a [[call]] using ``enableCcipRead``.
16686	*/
16687	get disableCcipRead() {
16688		return this.#disableCcipRead;
16689	}
16690	set disableCcipRead(value) {
16691		this.#disableCcipRead = !!value;
16692	}
16693	#getDelay() {
16694		let requestRate = this.#requestRate;
16695		if (requestRate === 0) return 0;
16696		const requests = this.#requestTimes;
16697		const now = getTime$1();
16698		requests.push(now);
16699		const scanTime = now - 1e3;
16700		while (requests.length && requests[0] < scanTime) requests.shift();
16701		if (requests.length < requestRate) return 0;
16702		return requests[0] + 1e3 - now;
16703	}
16704	async #perform(req) {
16705		const timeout = this.#options.cacheTimeout;
16706		if (timeout < 0) {
16707			const delay = this.#getDelay();
16708			if (delay) await stall$4(delay);
16709			return await this._perform(req);
16710		}
16711		const tag = getTag(req.method, req);
16712		let perform = this.#performCache.get(tag);
16713		if (!perform) {
16714			const delay = this.#getDelay();
16715			if (delay) await stall$4(delay);
16716			perform = this._perform(req);
16717			this.#performCache.set(tag, perform);
16718			setTimeout(() => {
16719				if (this.#performCache.get(tag) === perform) this.#performCache.delete(tag);
16720			}, timeout);
16721		}
16722		return await perform;
16723	}
16724	/**
16725	*  Resolves to the data for executing the CCIP-read operations.
16726	*/
16727	async ccipReadFetch(tx, calldata, urls) {
16728		if (this.disableCcipRead || urls.length === 0 || tx.to == null) return null;
16729		const sender = tx.to.toLowerCase();
16730		const data = calldata.toLowerCase();
16731		const errorMessages = [];
16732		for (let i = 0; i < urls.length; i++) {
16733			const url = urls[i];
16734			const request = new FetchRequest(url.replace("{sender}", sender).replace("{data}", data));
16735			if (url.indexOf("{data}") === -1) request.body = {
16736				data,
16737				sender
16738			};
16739			this.emit("debug", {
16740				action: "sendCcipReadFetchRequest",
16741				request,
16742				index: i,
16743				urls
16744			});
16745			let errorMessage = "unknown error";
16746			let resp;
16747			try {
16748				resp = await request.send();
16749			} catch (error) {
16750				errorMessages.push(error.message);
16751				this.emit("debug", {
16752					action: "receiveCcipReadFetchError",
16753					request,
16754					result: { error }
16755				});
16756				continue;
16757			}
16758			try {
16759				const result = resp.bodyJson;
16760				if (result.data) {

16761					this.emit("debug", {
16762						action: "receiveCcipReadFetchResult",
16763						request,
16764						result
16765					});
16766					return result.data;
16767				}
16768				if (result.message) errorMessage = result.message;
16769				this.emit("debug", {
16770					action: "receiveCcipReadFetchError",
16771					request,
16772					result
16773				});
16774			} catch (error) {}
16775			assert(resp.statusCode < 400 || resp.statusCode >= 500, `response not found during CCIP fetch: ${errorMessage}`, "OFFCHAIN_FAULT", {
16776				reason: "404_MISSING_RESOURCE",
16777				transaction: tx,
16778				info: {
16779					url,
16780					errorMessage
16781				}
16782			});
16783			errorMessages.push(errorMessage);
16784		}
16785		assert(false, `error encountered during CCIP fetch: ${errorMessages.map((m) => JSON.stringify(m)).join(", ")}`, "OFFCHAIN_FAULT", {
16786			reason: "500_SERVER_ERROR",
16787			transaction: tx,
16788			info: {
16789				urls,
16790				errorMessages
16791			}
16792		});
16793	}
16794	/**
16795	*  Provides the opportunity for a sub-class to wrap a block before
16796	*  returning it, to add additional properties or an alternate
16797	*  sub-class of [[Block]].
16798	*/
16799	_wrapBlock(value, network) {
16800		return new Block(formatBlock(value), this);
16801	}
16802	/**
16803	*  Provides the opportunity for a sub-class to wrap a log before
16804	*  returning it, to add additional properties or an alternate
16805	*  sub-class of [[Log]].
16806	*/
16807	_wrapLog(value, network) {
16808		return new Log(formatLog(value), this);
16809	}
16810	/**
16811	*  Provides the opportunity for a sub-class to wrap a transaction
16812	*  receipt before returning it, to add additional properties or an
16813	*  alternate sub-class of [[TransactionReceipt]].
16814	*/
16815	_wrapTransactionReceipt(value, network) {
16816		return new TransactionReceipt(formatTransactionReceipt(value), this);
16817	}
16818	/**
16819	*  Provides the opportunity for a sub-class to wrap a transaction
16820	*  response before returning it, to add additional properties or an
16821	*  alternate sub-class of [[TransactionResponse]].
16822	*/
16823	_wrapTransactionResponse(tx, network) {
16824		return new TransactionResponse(formatTransactionResponse(tx), this);
16825	}
16826	/**
16827	*  Resolves to the Network, forcing a network detection using whatever
16828	*  technique the sub-class requires.
16829	*
16830	*  Sub-classes **must** override this.
16831	*/
16832	_detectNetwork() {
16833		assert(false, "sub-classes must implement this", "UNSUPPORTED_OPERATION", { operation: "_detectNetwork" });
16834	}
16835	/**
16836	*  Sub-classes should use this to perform all built-in operations. All
16837	*  methods sanitizes and normalizes the values passed into this.
16838	*
16839	*  Sub-classes **must** override this.
16840	*/
16841	async _perform(req) {
16842		assert(false, `unsupported method: ${req.method}`, "UNSUPPORTED_OPERATION", {
16843			operation: req.method,
16844			info: req
16845		});
16846	}
16847	async getBlockNumber() {
16848		const blockNumber = getNumber(await this.#perform({ method: "getBlockNumber" }), "%response");
16849		if (this.#lastBlockNumber >= 0) this.#lastBlockNumber = blockNumber;
16850		return blockNumber;
16851	}
16852	/**
16853	*  Returns or resolves to the address for %%address%%, resolving ENS
16854	*  names and [[Addressable]] objects and returning if already an
16855	*  address.
16856	*/
16857	_getAddress(address) {
16858		return resolveAddress(address, this);
16859	}
16860	/**
16861	*  Returns or resolves to a valid block tag for %%blockTag%%, resolving
16862	*  negative values and returning if already a valid block tag.
16863	*/
16864	_getBlockTag(blockTag) {
16865		if (blockTag == null) return "latest";
16866		switch (blockTag) {
16867			case "earliest": return "0x0";
16868			case "finalized":
16869			case "latest":
16870			case "pending":
16871			case "safe": return blockTag;
16872		}
16873		if (isHexString(blockTag)) {
16874			if (isHexString(blockTag, 32)) return blockTag;
16875			return toQuantity(blockTag);
16876		}
16877		if (typeof blockTag === "bigint") blockTag = getNumber(blockTag, "blockTag");
16878		if (typeof blockTag === "number") {
16879			if (blockTag >= 0) return toQuantity(blockTag);
16880			if (this.#lastBlockNumber >= 0) return toQuantity(this.#lastBlockNumber + blockTag);
16881			return this.getBlockNumber().then((b) => toQuantity(b + blockTag));
16882		}
16883		assertArgument(false, "invalid blockTag", "blockTag", blockTag);
16884	}
16885	/**
16886	*  Returns or resolves to a filter for %%filter%%, resolving any ENS
16887	*  names or [[Addressable]] object and returning if already a valid
16888	*  filter.
16889	*/
16890	_getFilter(filter) {
16891		const topics = (filter.topics || []).map((t) => {
16892			if (t == null) return null;
16893			if (Array.isArray(t)) return concisify(t.map((t) => t.toLowerCase()));
16894			return t.toLowerCase();
16895		});
16896		const blockHash = "blockHash" in filter ? filter.blockHash : void 0;
16897		const resolve = (_address, fromBlock, toBlock) => {
16898			let address = void 0;
16899			switch (_address.length) {
16900				case 0: break;
16901				case 1:
16902					address = _address[0];
16903					break;
16904				default:
16905					_address.sort();
16906					address = _address;
16907			}
16908			if (blockHash) {
16909				if (fromBlock != null || toBlock != null) throw new Error("invalid filter");
16910			}
16911			const filter = {};

16912			if (address) filter.address = address;
16913			if (topics.length) filter.topics = topics;
16914			if (fromBlock) filter.fromBlock = fromBlock;
16915			if (toBlock) filter.toBlock = toBlock;
16916			if (blockHash) filter.blockHash = blockHash;
16917			return filter;
16918		};
16919		let address = [];
16920		if (filter.address) {
16921			if (Array.isArray(filter.address)) for (const addr of filter.address) address.push(this._getAddress(addr));
16922			else address.push(this._getAddress(filter.address));
16923		}
16924		let fromBlock = void 0;
16925		if ("fromBlock" in filter) fromBlock = this._getBlockTag(filter.fromBlock);
16926		let toBlock = void 0;
16927		if ("toBlock" in filter) toBlock = this._getBlockTag(filter.toBlock);
16928		if (address.filter((a) => typeof a !== "string").length || fromBlock != null && typeof fromBlock !== "string" || toBlock != null && typeof toBlock !== "string") return Promise.all([
16929			Promise.all(address),
16930			fromBlock,
16931			toBlock
16932		]).then((result) => {
16933			return resolve(result[0], result[1], result[2]);
16934		});
16935		return resolve(address, fromBlock, toBlock);
16936	}
16937	/**
16938	*  Returns or resolves to a transaction for %%request%%, resolving
16939	*  any ENS names or [[Addressable]] and returning if already a valid
16940	*  transaction.
16941	*/
16942	_getTransactionRequest(_request) {
16943		const request = copyRequest(_request);
16944		const promises = [];
16945		["to", "from"].forEach((key) => {
16946			if (request[key] == null) return;
16947			const addr = resolveAddress(request[key], this);
16948			if (isPromise$1(addr)) promises.push((async function() {
16949				request[key] = await addr;
16950			})());
16951			else request[key] = addr;
16952		});
16953		if (request.blockTag != null) {
16954			const blockTag = this._getBlockTag(request.blockTag);
16955			if (isPromise$1(blockTag)) promises.push((async function() {
16956				request.blockTag = await blockTag;
16957			})());
16958			else request.blockTag = blockTag;
16959		}
16960		if (promises.length) return (async function() {
16961			await Promise.all(promises);
16962			return request;
16963		})();
16964		return request;
16965	}
16966	async getNetwork() {
16967		if (this.#networkPromise == null) {
16968			const detectNetwork = (async () => {
16969				try {
16970					const network = await this._detectNetwork();
16971					this.emit("network", network, null);
16972					return network;
16973				} catch (error) {
16974					if (this.#networkPromise === detectNetwork) this.#networkPromise = null;
16975					throw error;
16976				}
16977			})();
16978			this.#networkPromise = detectNetwork;
16979			return (await detectNetwork).clone();
16980		}
16981		const networkPromise = this.#networkPromise;
16982		const [expected, actual] = await Promise.all([networkPromise, this._detectNetwork()]);
16983		if (expected.chainId !== actual.chainId) {
16984			if (this.#anyNetwork) {
16985				this.emit("network", actual, expected);
16986				if (this.#networkPromise === networkPromise) this.#networkPromise = Promise.resolve(actual);
16987			} else assert(false, `network changed: ${expected.chainId} => ${actual.chainId} `, "NETWORK_ERROR", { event: "changed" });
16988		}
16989		return expected.clone();
16990	}
16991	async getFeeData() {
16992		const network = await this.getNetwork();
16993		const getFeeDataFunc = async () => {
16994			const { _block, gasPrice, priorityFee } = await resolveProperties({
16995				_block: this.#getBlock("latest", false),
16996				gasPrice: (async () => {
16997					try {
16998						return getBigInt(await this.#perform({ method: "getGasPrice" }), "%response");
16999					} catch (error) {}
17000					return null;
17001				})(),
17002				priorityFee: (async () => {
17003					try {
17004						return getBigInt(await this.#perform({ method: "getPriorityFee" }), "%response");
17005					} catch (error) {}
17006					return null;
17007				})()
17008			});
17009			let maxFeePerGas = null;
17010			let maxPriorityFeePerGas = null;
17011			const block = this._wrapBlock(_block, network);
17012			if (block && block.baseFeePerGas) {
17013				maxPriorityFeePerGas = priorityFee != null ? priorityFee : BigInt("1000000000");
17014				maxFeePerGas = block.baseFeePerGas * BN_2$1 + maxPriorityFeePerGas;
17015			}
17016			return new FeeData(gasPrice, maxFeePerGas, maxPriorityFeePerGas);
17017		};
17018		const plugin = network.getPlugin("org.ethers.plugins.network.FetchUrlFeeDataPlugin");
17019		if (plugin) {
17020			const req = new FetchRequest(plugin.url);
17021			const feeData = await plugin.processFunc(getFeeDataFunc, this, req);
17022			return new FeeData(feeData.gasPrice, feeData.maxFeePerGas, feeData.maxPriorityFeePerGas);
17023		}
17024		return await getFeeDataFunc();
17025	}
17026	async estimateGas(_tx) {
17027		let tx = this._getTransactionRequest(_tx);

vendor: 6,332 bytes, lines 17028-17230

17028		if (isPromise$1(tx)) tx = await tx;
17029		return getBigInt(await this.#perform({
17030			method: "estimateGas",
17031			transaction: tx
17032		}), "%response");
17033	}
17034	async #call(tx, blockTag, attempt) {
17035		assert(attempt < MAX_CCIP_REDIRECTS, "CCIP read exceeded maximum redirections", "OFFCHAIN_FAULT", {
17036			reason: "TOO_MANY_REDIRECTS",
17037			transaction: Object.assign({}, tx, {
17038				blockTag,
17039				enableCcipRead: true
17040			})
17041		});
17042		const transaction = copyRequest(tx);
17043		try {
17044			const delay = this.#getDelay();
17045			if (delay) await stall$4(delay);
17046			return hexlify(await this._perform({
17047				method: "call",
17048				transaction,
17049				blockTag
17050			}));
17051		} catch (error) {
17052			if (!this.disableCcipRead && isCallException(error) && error.data && attempt >= 0 && blockTag === "latest" && transaction.to != null && dataSlice(error.data, 0, 4) === "0x556f1830") {
17053				const data = error.data;
17054				const txSender = await resolveAddress(transaction.to, this);
17055				let ccipArgs;
17056				try {
17057					ccipArgs = parseOffchainLookup(dataSlice(error.data, 4));
17058				} catch (error) {
17059					assert(false, error.message, "OFFCHAIN_FAULT", {
17060						reason: "BAD_DATA",
17061						transaction,
17062						info: { data }
17063					});
17064				}
17065				assert(ccipArgs.sender.toLowerCase() === txSender.toLowerCase(), "CCIP Read sender mismatch", "CALL_EXCEPTION", {
17066					action: "call",
17067					data,
17068					reason: "OffchainLookup",
17069					transaction,
17070					invocation: null,
17071					revert: {
17072						signature: "OffchainLookup(address,string[],bytes,bytes4,bytes)",
17073						name: "OffchainLookup",
17074						args: ccipArgs.errorArgs
17075					}
17076				});
17077				const ccipResult = await this.ccipReadFetch(transaction, ccipArgs.calldata, ccipArgs.urls);
17078				assert(ccipResult != null, "CCIP Read failed to fetch data", "OFFCHAIN_FAULT", {
17079					reason: "FETCH_FAILED",
17080					transaction,
17081					info: {
17082						data: error.data,
17083						errorArgs: ccipArgs.errorArgs
17084					}
17085				});
17086				const tx = {
17087					to: txSender,
17088					data: concat([ccipArgs.selector, encodeBytes([ccipResult, ccipArgs.extraData])])
17089				};
17090				this.emit("debug", {
17091					action: "sendCcipReadCall",
17092					transaction: tx
17093				});
17094				try {
17095					const result = await this.#call(tx, blockTag, attempt + 1);
17096					this.emit("debug", {
17097						action: "receiveCcipReadCallResult",
17098						transaction: Object.assign({}, tx),
17099						result
17100					});
17101					return result;
17102				} catch (error) {
17103					this.emit("debug", {
17104						action: "receiveCcipReadCallError",
17105						transaction: Object.assign({}, tx),
17106						error
17107					});
17108					throw error;
17109				}
17110			}
17111			throw error;
17112		}
17113	}
17114	async #checkNetwork(promise) {
17115		const { value } = await resolveProperties({
17116			network: this.getNetwork(),
17117			value: promise
17118		});
17119		return value;
17120	}
17121	async call(_tx) {
17122		const { tx, blockTag } = await resolveProperties({
17123			tx: this._getTransactionRequest(_tx),
17124			blockTag: this._getBlockTag(_tx.blockTag)
17125		});
17126		return await this.#checkNetwork(this.#call(tx, blockTag, _tx.enableCcipRead ? 0 : -1));
17127	}
17128	async #getAccountValue(request, _address, _blockTag) {
17129		let address = this._getAddress(_address);
17130		let blockTag = this._getBlockTag(_blockTag);
17131		if (typeof address !== "string" || typeof blockTag !== "string") [address, blockTag] = await Promise.all([address, blockTag]);
17132		return await this.#checkNetwork(this.#perform(Object.assign(request, {
17133			address,
17134			blockTag
17135		})));
17136	}
17137	async getBalance(address, blockTag) {
17138		return getBigInt(await this.#getAccountValue({ method: "getBalance" }, address, blockTag), "%response");
17139	}
17140	async getTransactionCount(address, blockTag) {
17141		return getNumber(await this.#getAccountValue({ method: "getTransactionCount" }, address, blockTag), "%response");
17142	}
17143	async getCode(address, blockTag) {
17144		return hexlify(await this.#getAccountValue({ method: "getCode" }, address, blockTag));
17145	}
17146	async getStorage(address, _position, blockTag) {
17147		const position = getBigInt(_position, "position");
17148		return hexlify(await this.#getAccountValue({
17149			method: "getStorage",
17150			position
17151		}, address, blockTag));
17152	}
17153	async broadcastTransaction(signedTx) {
17154		const { blockNumber, hash, network } = await resolveProperties({
17155			blockNumber: this.getBlockNumber(),
17156			hash: this._perform({
17157				method: "broadcastTransaction",
17158				signedTransaction: signedTx
17159			}),
17160			network: this.getNetwork()
17161		});
17162		const tx = Transaction.from(signedTx);
17163		if (tx.hash !== hash) throw new Error("@TODO: the returned hash did not match");
17164		return this._wrapTransactionResponse(tx, network).replaceableTransaction(blockNumber);
17165	}
17166	async #getBlock(block, includeTransactions) {
17167		if (isHexString(block, 32)) return await this.#perform({
17168			method: "getBlock",
17169			blockHash: block,
17170			includeTransactions
17171		});
17172		let blockTag = this._getBlockTag(block);
17173		if (typeof blockTag !== "string") blockTag = await blockTag;
17174		return await this.#perform({
17175			method: "getBlock",
17176			blockTag,
17177			includeTransactions
17178		});
17179	}
17180	async getBlock(block, prefetchTxs) {
17181		const { network, params } = await resolveProperties({
17182			network: this.getNetwork(),
17183			params: this.#getBlock(block, !!prefetchTxs)
17184		});
17185		if (params == null) return null;
17186		return this._wrapBlock(params, network);
17187	}
17188	async getTransaction(hash) {
17189		const { network, params } = await resolveProperties({
17190			network: this.getNetwork(),
17191			params: this.#perform({
17192				method: "getTransaction",
17193				hash
17194			})
17195		});
17196		if (params == null) return null;
17197		return this._wrapTransactionResponse(params, network);
17198	}
17199	async getTransactionReceipt(hash) {
17200		const { network, params } = await resolveProperties({
17201			network: this.getNetwork(),
17202			params: this.#perform({
17203				method: "getTransactionReceipt",
17204				hash
17205			})
17206		});
17207		if (params == null) return null;
17208		if (params.gasPrice == null && params.effectiveGasPrice == null) {
17209			const tx = await this.#perform({
17210				method: "getTransaction",
17211				hash
17212			});
17213			if (tx == null) throw new Error("report this; could not find tx or effectiveGasPrice");
17214			params.effectiveGasPrice = tx.gasPrice;
17215		}
17216		return this._wrapTransactionReceipt(params, network);
17217	}
17218	async getTransactionResult(hash) {
17219		const { result } = await resolveProperties({
17220			network: this.getNetwork(),
17221			result: this.#perform({
17222				method: "getTransactionResult",
17223				hash
17224			})
17225		});
17226		if (result == null) return null;
17227		return hexlify(result);
17228	}
17229	async getLogs(_filter) {
17230		let filter = this._getFilter(_filter);

17231		if (isPromise$1(filter)) filter = await filter;
17232		const { network, params } = await resolveProperties({
17233			network: this.getNetwork(),
17234			params: this.#perform({
17235				method: "getLogs",
17236				filter
17237			})
17238		});
17239		return params.map((p) => this._wrapLog(p, network));
17240	}
17241	_getProvider(chainId) {
17242		assert(false, "provider cannot connect to target network", "UNSUPPORTED_OPERATION", { operation: "_getProvider()" });
17243	}
17244	async getResolver(name) {
17245		return await EnsResolver.fromName(this, name);
17246	}
17247	async getAvatar(name) {
17248		const resolver = await this.getResolver(name);
17249		if (resolver) return await resolver.getAvatar();
17250		return null;
17251	}
17252	async resolveName(name, coinType) {
17253		const resolver = await this.getResolver(name);
17254		if (resolver) return await resolver.getAddress(coinType);
17255		return null;
17256	}
17257	async lookupAddress(address, coinType) {
17258		return await EnsResolver.lookupAddress(this, address, coinType);
17259	}
17260	async waitForTransaction(hash, _confirms, timeout) {
17261		const confirms = _confirms != null ? _confirms : 1;
17262		if (confirms === 0) return this.getTransactionReceipt(hash);
17263		return new Promise(async (resolve, reject) => {
17264			let timer = null;
17265			const listener = (async (blockNumber) => {
17266				try {
17267					const receipt = await this.getTransactionReceipt(hash);
17268					if (receipt != null) {
17269						if (blockNumber - receipt.blockNumber + 1 >= confirms) {
17270							resolve(receipt);
17271							if (timer) {
17272								clearTimeout(timer);
17273								timer = null;
17274							}
17275							return;
17276						}
17277					}
17278				} catch (error) {
17279					console.log("EEE", error);
17280				}
17281				this.once("block", listener);
17282			});
17283			if (timeout != null) timer = setTimeout(() => {
17284				if (timer == null) return;
17285				timer = null;
17286				this.off("block", listener);
17287				reject(makeError("timeout", "TIMEOUT", { reason: "timeout" }));
17288			}, timeout);
17289			listener(await this.getBlockNumber());
17290		});
17291	}
17292	async waitForBlock(blockTag) {
17293		assert(false, "not implemented yet", "NOT_IMPLEMENTED", { operation: "waitForBlock" });
17294	}
17295	/**
17296	*  Clear a timer created using the [[_setTimeout]] method.
17297	*/
17298	_clearTimeout(timerId) {
17299		const timer = this.#timers.get(timerId);
17300		if (!timer) return;
17301		if (timer.timer) clearTimeout(timer.timer);
17302		this.#timers.delete(timerId);
17303	}
17304	/**
17305	*  Create a timer that will execute %%func%% after at least %%timeout%%
17306	*  (in ms). If %%timeout%% is unspecified, then %%func%% will execute
17307	*  in the next event loop.
17308	*
17309	*  [Pausing](AbstractProvider-paused) the provider will pause any
17310	*  associated timers.
17311	*/
17312	_setTimeout(_func, timeout) {
17313		if (timeout == null) timeout = 0;
17314		const timerId = this.#nextTimer++;
17315		const func = () => {
17316			this.#timers.delete(timerId);
17317			_func();
17318		};
17319		if (this.paused) this.#timers.set(timerId, {
17320			timer: null,
17321			func,
17322			time: timeout
17323		});
17324		else {
17325			const timer = setTimeout(func, timeout);
17326			this.#timers.set(timerId, {
17327				timer,
17328				func,
17329				time: getTime$1()
17330			});
17331		}
17332		return timerId;
17333	}
17334	/**
17335	*  Perform %%func%% on each subscriber.
17336	*/
17337	_forEachSubscriber(func) {
17338		for (const sub of this.#subs.values()) func(sub.subscriber);
17339	}
17340	/**
17341	*  Sub-classes may override this to customize subscription
17342	*  implementations.
17343	*/
17344	_getSubscriber(sub) {
17345		switch (sub.type) {
17346			case "debug":
17347			case "error":
17348			case "network": return new UnmanagedSubscriber(sub.type);
17349			case "block": {
17350				const subscriber = new PollingBlockSubscriber(this);
17351				subscriber.pollingInterval = this.pollingInterval;
17352				return subscriber;
17353			}
17354			case "safe":
17355			case "finalized": return new PollingBlockTagSubscriber(this, sub.type);
17356			case "event": return new PollingEventSubscriber(this, sub.filter);
17357			case "transaction": return new PollingTransactionSubscriber(this, sub.hash);
17358			case "orphan": return new PollingOrphanSubscriber(this, sub.filter);
17359		}
17360		throw new Error(`unsupported event: ${sub.type}`);
17361	}
17362	/**
17363	*  If a [[Subscriber]] fails and needs to replace itself, this
17364	*  method may be used.
17365	*
17366	*  For example, this is used for providers when using the
17367	*  ``eth_getFilterChanges`` method, which can return null if state
17368	*  filters are not supported by the backend, allowing the Subscriber
17369	*  to swap in a [[PollingEventSubscriber]].
17370	*/
17371	_recoverSubscriber(oldSub, newSub) {
17372		for (const sub of this.#subs.values()) if (sub.subscriber === oldSub) {
17373			if (sub.started) sub.subscriber.stop();
17374			sub.subscriber = newSub;
17375			if (sub.started) newSub.start();
17376			if (this.#pausedState != null) newSub.pause(this.#pausedState);
17377			break;
17378		}
17379	}
17380	async #hasSub(event, emitArgs) {
17381		let sub = await getSubscription(event, this);
17382		if (sub.type === "event" && emitArgs && emitArgs.length > 0 && emitArgs[0].removed === true) sub = await getSubscription({
17383			orphan: "drop-log",
17384			log: emitArgs[0]
17385		}, this);
17386		return this.#subs.get(sub.tag) || null;
17387	}
17388	async #getSub(event) {
17389		const subscription = await getSubscription(event, this);
17390		const tag = subscription.tag;
17391		let sub = this.#subs.get(tag);
17392		if (!sub) {
17393			sub = {
17394				subscriber: this._getSubscriber(subscription),
17395				tag,
17396				addressableMap: /* @__PURE__ */ new WeakMap(),
17397				nameMap: /* @__PURE__ */ new Map(),
17398				started: false,
17399				listeners: []
17400			};
17401			this.#subs.set(tag, sub);
17402		}
17403		return sub;
17404	}
17405	async on(event, listener) {
17406		const sub = await this.#getSub(event);
17407		sub.listeners.push({
17408			listener,
17409			once: false
17410		});
17411		if (!sub.started) {
17412			sub.subscriber.start();
17413			sub.started = true;
17414			if (this.#pausedState != null) sub.subscriber.pause(this.#pausedState);
17415		}
17416		return this;
17417	}
17418	async once(event, listener) {
17419		const sub = await this.#getSub(event);
17420		sub.listeners.push({
17421			listener,
17422			once: true
17423		});
17424		if (!sub.started) {
17425			sub.subscriber.start();
17426			sub.started = true;
17427			if (this.#pausedState != null) sub.subscriber.pause(this.#pausedState);
17428		}
17429		return this;
17430	}
17431	async emit(event, ...args) {
17432		const sub = await this.#hasSub(event, args);
17433		if (!sub || sub.listeners.length === 0) return false;

17434		const count = sub.listeners.length;
17435		sub.listeners = sub.listeners.filter(({ listener, once }) => {
17436			const payload = new EventPayload(this, once ? null : listener, event);
17437			try {
17438				listener.call(this, ...args, payload);
17439			} catch (error) {}
17440			return !once;
17441		});
17442		if (sub.listeners.length === 0) {
17443			if (sub.started) sub.subscriber.stop();
17444			this.#subs.delete(sub.tag);
17445		}
17446		return count > 0;
17447	}
17448	async listenerCount(event) {
17449		if (event) {
17450			const sub = await this.#hasSub(event);
17451			if (!sub) return 0;
17452			return sub.listeners.length;
17453		}
17454		let total = 0;
17455		for (const { listeners } of this.#subs.values()) total += listeners.length;
17456		return total;
17457	}
17458	async listeners(event) {
17459		if (event) {
17460			const sub = await this.#hasSub(event);
17461			if (!sub) return [];
17462			return sub.listeners.map(({ listener }) => listener);
17463		}
17464		let result = [];
17465		for (const { listeners } of this.#subs.values()) result = result.concat(listeners.map(({ listener }) => listener));
17466		return result;
17467	}
17468	async off(event, listener) {
17469		const sub = await this.#hasSub(event);
17470		if (!sub) return this;
17471		if (listener) {
17472			const index = sub.listeners.map(({ listener }) => listener).indexOf(listener);
17473			if (index >= 0) sub.listeners.splice(index, 1);
17474		}
17475		if (!listener || sub.listeners.length === 0) {
17476			if (sub.started) sub.subscriber.stop();
17477			this.#subs.delete(sub.tag);
17478		}
17479		return this;
17480	}
17481	async removeAllListeners(event) {
17482		if (event) {
17483			const { tag, started, subscriber } = await this.#getSub(event);
17484			if (started) subscriber.stop();
17485			this.#subs.delete(tag);
17486		} else for (const [tag, { started, subscriber }] of this.#subs) {
17487			if (started) subscriber.stop();
17488			this.#subs.delete(tag);
17489		}
17490		return this;
17491	}
17492	async addListener(event, listener) {
17493		return await this.on(event, listener);
17494	}
17495	async removeListener(event, listener) {
17496		return this.off(event, listener);
17497	}
17498	/**
17499	*  If this provider has been destroyed using the [[destroy]] method.
17500	*
17501	*  Once destroyed, all resources are reclaimed, internal event loops
17502	*  and timers are cleaned up and no further requests may be sent to
17503	*  the provider.
17504	*/
17505	get destroyed() {
17506		return this.#destroyed;
17507	}
17508	/**
17509	*  Sub-classes may use this to shutdown any sockets or release their
17510	*  resources and reject any pending requests.
17511	*
17512	*  Sub-classes **must** call ``super.destroy()``.
17513	*/
17514	destroy() {
17515		this.removeAllListeners();
17516		for (const timerId of this.#timers.keys()) this._clearTimeout(timerId);
17517		this.#destroyed = true;
17518	}
17519	/**
17520	*  Whether the provider is currently paused.
17521	*
17522	*  A paused provider will not emit any events, and generally should
17523	*  not make any requests to the network, but that is up to sub-classes
17524	*  to manage.
17525	*
17526	*  Setting ``paused = true`` is identical to calling ``.pause(false)``,
17527	*  which will buffer any events that occur while paused until the
17528	*  provider is unpaused.
17529	*/
17530	get paused() {
17531		return this.#pausedState != null;
17532	}
17533	set paused(pause) {
17534		if (!!pause === this.paused) return;
17535		if (this.paused) this.resume();
17536		else this.pause(false);
17537	}
17538	/**
17539	*  Pause the provider. If %%dropWhilePaused%%, any events that occur
17540	*  while paused are dropped, otherwise all events will be emitted once
17541	*  the provider is unpaused.
17542	*/
17543	pause(dropWhilePaused) {
17544		this.#lastBlockNumber = -1;
17545		if (this.#pausedState != null) {
17546			if (this.#pausedState == !!dropWhilePaused) return;
17547			assert(false, "cannot change pause type; resume first", "UNSUPPORTED_OPERATION", { operation: "pause" });
17548		}
17549		this._forEachSubscriber((s) => s.pause(dropWhilePaused));
17550		this.#pausedState = !!dropWhilePaused;
17551		for (const timer of this.#timers.values()) {
17552			if (timer.timer) clearTimeout(timer.timer);
17553			timer.time = getTime$1() - timer.time;
17554		}
17555	}
17556	/**
17557	*  Resume the provider.
17558	*/
17559	resume() {
17560		if (this.#pausedState == null) return;
17561		this._forEachSubscriber((s) => s.resume());
17562		this.#pausedState = null;
17563		for (const timer of this.#timers.values()) {
17564			let timeout = timer.time;
17565			if (timeout < 0) timeout = 0;
17566			timer.time = getTime$1();
17567			setTimeout(timer.func, timeout);
17568		}
17569	}
17570};
17571function _parseString(result, start) {
17572	try {
17573		const bytes = _parseBytes(result, start);
17574		if (bytes) return toUtf8String(bytes);
17575	} catch (error) {}
17576	return null;
17577}
17578function _parseBytes(result, start) {
17579	if (result === "0x") return null;
17580	try {
17581		const offset = getNumber(dataSlice(result, start, start + 32));
17582		const length = getNumber(dataSlice(result, offset, offset + 32));
17583		return dataSlice(result, offset + 32, offset + 32 + length);
17584	} catch (error) {}
17585	return null;
17586}
17587function numPad(value) {
17588	const result = toBeArray(value);
17589	if (result.length > 32) throw new Error("internal; should not happen");
17590	const padded = /* @__PURE__ */ new Uint8Array(32);
17591	padded.set(result, 32 - result.length);
17592	return padded;
17593}
17594function bytesPad(value) {
17595	if (value.length % 32 === 0) return value;
17596	const result = new Uint8Array(Math.ceil(value.length / 32) * 32);
17597	result.set(value);
17598	return result;
17599}
17600var empty = new Uint8Array([]);
17601function encodeBytes(datas) {
17602	const result = [];
17603	let byteCount = 0;
17604	for (let i = 0; i < datas.length; i++) {
17605		result.push(empty);
17606		byteCount += 32;
17607	}
17608	for (let i = 0; i < datas.length; i++) {
17609		const data = getBytes(datas[i]);
17610		result[i] = numPad(byteCount);
17611		result.push(numPad(data.length));
17612		result.push(bytesPad(data));
17613		byteCount += 32 + Math.ceil(data.length / 32) * 32;
17614	}
17615	return concat(result);
17616}
17617var zeros = "0x0000000000000000000000000000000000000000000000000000000000000000";
17618function parseOffchainLookup(data) {
17619	const result = {
17620		sender: "",
17621		urls: [],
17622		calldata: "",
17623		selector: "",
17624		extraData: "",
17625		errorArgs: []
17626	};
17627	assert(dataLength(data) >= 160, "insufficient OffchainLookup data", "OFFCHAIN_FAULT", { reason: "insufficient OffchainLookup data" });
17628	const sender = dataSlice(data, 0, 32);
17629	assert(dataSlice(sender, 0, 12) === dataSlice(zeros, 0, 12), "corrupt OffchainLookup sender", "OFFCHAIN_FAULT", { reason: "corrupt OffchainLookup sender" });
17630	result.sender = dataSlice(sender, 12);
17631	try {
17632		const urls = [];
17633		const urlsOffset = getNumber(dataSlice(data, 32, 64));
17634		const urlsLength = getNumber(dataSlice(data, urlsOffset, urlsOffset + 32));
17635		const urlsData = dataSlice(data, urlsOffset + 32);
17636		for (let u = 0; u < urlsLength; u++) {
17637			const url = _parseString(urlsData, u * 32);
17638			if (url == null) throw new Error("abort");
17639			urls.push(url);
17640		}
17641		result.urls = urls;
17642	} catch (error) {
17643		assert(false, "corrupt OffchainLookup urls", "OFFCHAIN_FAULT", { reason: "corrupt OffchainLookup urls" });
17644	}
17645	try {
17646		const calldata = _parseBytes(data, 64);
17647		if (calldata == null) throw new Error("abort");
17648		result.calldata = calldata;
17649	} catch (error) {
17650		assert(false, "corrupt OffchainLookup calldata", "OFFCHAIN_FAULT", { reason: "corrupt OffchainLookup calldata" });
17651	}
17652	assert(dataSlice(data, 100, 128) === dataSlice(zeros, 0, 28), "corrupt OffchainLookup callbaackSelector", "OFFCHAIN_FAULT", { reason: "corrupt OffchainLookup callbaackSelector" });
17653	result.selector = dataSlice(data, 96, 100);
17654	try {
17655		const extraData = _parseBytes(data, 128);
17656		if (extraData == null) throw new Error("abort");
17657		result.extraData = extraData;
17658	} catch (error) {
17659		assert(false, "corrupt OffchainLookup extraData", "OFFCHAIN_FAULT", { reason: "corrupt OffchainLookup extraData" });
17660	}

17661	result.errorArgs = "sender,urls,calldata,selector,extraData".split(/,/).map((k) => result[k]);
17662	return result;
17663}
17664//#endregion
17665//#region node_modules/ethers/lib.esm/providers/abstract-signer.js
17666/**
17667*  Generally the [[Wallet]] and [[JsonRpcSigner]] and their sub-classes
17668*  are sufficient for most developers, but this is provided to
17669*  fascilitate more complex Signers.
17670*
17671*  @_section: api/providers/abstract-signer: Subclassing Signer [abstract-signer]
17672*/
17673function checkProvider(signer, operation) {
17674	if (signer.provider) return signer.provider;
17675	assert(false, "missing provider", "UNSUPPORTED_OPERATION", { operation });
17676}
17677async function populate(signer, tx) {
17678	let pop = copyRequest(tx);
17679	if (pop.to != null) pop.to = resolveAddress(pop.to, signer);
17680	if (pop.from != null) {
17681		const from = pop.from;
17682		pop.from = Promise.all([signer.getAddress(), resolveAddress(from, signer)]).then(([address, from]) => {
17683			assertArgument(address.toLowerCase() === from.toLowerCase(), "transaction from mismatch", "tx.from", from);
17684			return address;
17685		});
17686	} else pop.from = signer.getAddress();
17687	return await resolveProperties(pop);
17688}
17689/**
17690*  An **AbstractSigner** includes most of teh functionality required
17691*  to get a [[Signer]] working as expected, but requires a few
17692*  Signer-specific methods be overridden.
17693*
17694*/
17695var AbstractSigner = class {
17696	/**
17697	*  The provider this signer is connected to.
17698	*/
17699	provider;
17700	/**
17701	*  Creates a new Signer connected to %%provider%%.
17702	*/
17703	constructor(provider) {
17704		defineProperties(this, { provider: provider || null });
17705	}
17706	async getNonce(blockTag) {
17707		return checkProvider(this, "getTransactionCount").getTransactionCount(await this.getAddress(), blockTag);
17708	}
17709	async populateCall(tx) {
17710		return await populate(this, tx);
17711	}
17712	async populateTransaction(tx) {
17713		const provider = checkProvider(this, "populateTransaction");
17714		const pop = await populate(this, tx);
17715		if (pop.nonce == null) pop.nonce = await this.getNonce("pending");
17716		if (pop.gasLimit == null) pop.gasLimit = await this.estimateGas(p

17716op);
17717		const network = await this.provider.getNetwork();
17718		if (pop.chainId != null) assertArgument(getBigInt(pop.chainId) === network.chainId, "transaction chainId mismatch", "tx.chainId", tx.chainId);
17719		else pop.chainId = network.chainId;
17720		const hasEip1559 = pop.maxFeePerGas != null || pop.maxPriorityFeePerGas != null;
17721		if (pop.gasPrice != null && (pop.type === 2 || hasEip1559)) assertArgument(false, "eip-1559 transaction do not support gasPrice", "tx", tx);
17722		else if ((pop.type === 0 || pop.type === 1) && hasEip1559) assertArgument(false, "pre-eip-1559 transaction do not support maxFeePerGas/maxPriorityFeePerGas", "tx", tx);
17723		if ((pop.type === 2 || pop.type == null) && pop.maxFeePerGas != null && pop.maxPriorityFeePerGas != null) pop.type = 2;
17724		else if (pop.type === 0 || pop.type === 1) {
17725			const feeData = await provider.getFeeData();
17726			assert(feeData.gasPrice != null, "network does not support gasPrice", "UNSUPPORTED_OPERATION", { operation: "getGasPrice" });
17727			if (pop.gasPrice == null) pop.gasPrice = feeData.gasPrice;
17728		} else {
17729			const feeData = await provider.getFeeData();
17730			if (pop.type == null) {
17731				if (feeData.maxFeePerGas != null && feeData.maxPriorityFeePerGas != null) {
17732					if (pop.authorizationList && pop.authorizationList.length) pop.type = 4;
17733					else pop.type = 2;
17734					if (pop.gasPrice != null) {
17735						const gasPrice = pop.gasPrice;
17736						delete pop.gasPrice;
17737						pop.maxFeePerGas = gasPrice;
17738						pop.maxPriorityFeePerGas = gasPrice;
17739					} else {
17740						if (pop.maxFeePerGas == null) pop.maxFeePerGas = feeData.maxFeePerGas;
17741						if (pop.maxPriorityFeePerGas == null) pop.maxPriorityFeePerGas = feeData.maxPriorityFeePerGas;
17742					}
17743				} else if (feeData.gasPrice != null) {
17744					assert(!hasEip1559, "network does not support EIP-1559", "UNSUPPORTED_OPERATION", { operation: "populateTransaction" });
17745					if (pop.gasPrice == null) pop.gasPrice = feeData.gasPrice;
17746					pop.type = 0;
17747				} else assert(false, "failed to get consistent fee data", "UNSUPPORTED_OPERATION", { operation: "signer.getFeeData" });
17748			} else if (pop.type === 2 || pop.type === 3 || pop.type === 4) {
17749				if (pop.maxFeePerGas == null) pop.maxFeePerGas = feeData.maxFeePerGas;
17750				if (pop.maxPriorityFeePerGas == null) pop.maxPriorityFeePerGas = feeData.maxPriorityFeePerGas;
17751			}
17752		}
17753		return await resolveProperties(pop);
17754	}
17755	async populateAuthorization(_auth) {
17756		const auth = Object.assign({}, _auth);
17757		if (auth.chainId == null) auth.chainId = (await checkProvider(this, "getNetwork").getNetwork()).chainId;
17758		if (auth.nonce == null) auth.nonce = await this.getNonce();
17759		return auth;
17760	}
17761	async estimateGas(tx) {
17762		return checkProvider(this, "estimateGas").estimateGas(await this.populateCall(tx));
17763	}
17764	async call(tx) {
17765		return checkProvider(this, "call").call(await this.populateCall(tx));
17766	}
17767	async resolveName(name) {
17768		return await checkProvider(this, "resolveName").resolveName(name);
17769	}
17770	async sendTransaction(tx) {
17771		const provider = checkProvider(this, "sendTransaction");
17772		const pop = await this.populateTransaction(tx);
17773		delete pop.from;
17774		const txObj = Transaction.from(pop);
17775		return await provider.broadcastTransaction(await this.signTransaction(txObj));
17776	}
17777	authorize(authorization) {
17778		assert(false, "authorization not implemented for this signer", "UNSUPPORTED_OPERATION", { operation: "authorize" });
17779	}
17780};
17781/**
17782*  A **VoidSigner** is a class designed to allow an address to be used
17783*  in any API which accepts a Signer, but for which there are no
17784*  credentials available to perform any actual signing.
17785*
17786*  This for example allow impersonating an account for the purpose of
17787*  static calls or estimating gas, but does not allow sending transactions.
17788*/
17789var VoidSigner = class VoidSigner extends AbstractSigner {
17790	/**
17791	*  The signer address.
17792	*/
17793	address;
17794	/**
17795	*  Creates a new **VoidSigner** with %%address%% attached to
17796	*  %%provider%%.
17797	*/
17798	constructor(address, provider) {
17799		super(provider);
17800		defineProperties(this, { address });
17801	}
17802	async getAddress() {
17803		return this.address;
17804	}
17805	connect(provider) {
17806		return new VoidSigner(this.address, provider);
17807	}
17808	#throwUnsupported(suffix, operation) {
17809		assert(false, `VoidSigner cannot sign ${suffix}`, "UNSUPPORTED_OPERATION", { operation });
17810	}
17811	async signTransaction(tx) {
17812		this.#throwUnsupported("transactions", "signTransaction");
17813	}
17814	async signMessage(message) {
17815		this.#throwUnsupported("messages", "signMessage");
17816	}
17817	async signTypedData(domain, types, value) {
17818		this.#throwUnsupported("typed-data", "signTypedData");
17819	}
17820};
17821//#endregion
17822//#region node_modules/ethers/lib.esm/providers/community.js
17823/**
17824*  There are many awesome community services that provide Ethereum
17825*  nodes both for developers just starting out and for large-scale
17826*  communities.
17827*
17828*  @_section: api/providers/thirdparty: Community Providers  [thirdparty]
17829*/
17830var shown = /* @__PURE__ */ new Set();
17831/**
17832*  Displays a warning in the console when the community resource is
17833*  being used too heavily by the app, recommending the developer
17834*  acquire their own credentials instead of using the community
17835*  credentials.
17836*
17837*  The notification will only occur once per service.
17838*/
17839function showThrottleMessage(service) {
17840	if (shown.has(service)) return;
17841	shown.add(service);
17842	console.log("========= NOTICE =========");
17843	console.log(`Request-Rate Exceeded for ${service} (this message will not be repeated)`);
17844	console.log("");
17845	console.log("The default API keys for each service are provided as a highly-throttled,");
17846	console.log("community resource for low-traffic projects and early prototyping.");
17847	console.log("");
17848	console.log("While your application will continue to function, we highly recommended");
17849	console.log("signing up for your own API keys to improve performance, increase your");
17850	console.log("request rate/limit and enable other perks, such as metrics and advanced APIs.");
17851	console.log("");
17852	console.log("For more details: https://docs.ethers.org/api-keys/");
17853	console.log("==========================");
17854}
17855//#endregion

17856//#region node_modules/ethers/lib.esm/providers/subscriber-filterid.js
17857function copy(obj) {
17858	return JSON.parse(JSON.stringify(obj));
17859}
17860/**
17861*  Some backends support subscribing to events using a Filter ID.
17862*
17863*  When subscribing with this technique, the node issues a unique
17864*  //Filter ID//. At this point the node dedicates resources to
17865*  the filter, so that periodic calls to follow up on the //Filter ID//
17866*  will receive any events since the last call.
17867*
17868*  @_docloc: api/providers/abstract-provider
17869*/
17870var FilterIdSubscriber = class {
17871	#provider;
17872	#filterIdPromise;
17873	#poller;
17874	#running;
17875	#network;
17876	#hault;
17877	/**
17878	*  Creates a new **FilterIdSubscriber** which will used [[_subscribe]]
17879	*  and [[_emitResults]] to setup the subscription and provide the event
17880	*  to the %%provider%%.
17881	*/
17882	constructor(provider) {
17883		this.#provider = provider;
17884		this.#filterIdPromise = null;
17885		this.#poller = this.#poll.bind(this);
17886		this.#running = false;
17887		this.#network = null;
17888		this.#hault = false;
17889	}
17890	/**
17891	*  Sub-classes **must** override this to begin the subscription.
17892	*/
17893	_subscribe(provider) {
17894		throw new Error("subclasses must override this");
17895	}
17896	/**
17897	*  Sub-classes **must** override this handle the events.
17898	*/
17899	_emitResults(provider, result) {
17900		throw new Error("subclasses must override this");
17901	}
17902	/**
17903	*  Sub-classes **must** override this handle recovery on errors.
17904	*/
17905	_recover(provider) {
17906		throw new Error("subclasses must override this");
17907	}
17908	async #poll(blockNumber) {
17909		try {
17910			if (this.#filterIdPromise == null) this.#filterIdPromise = this._subscribe(this.#provider);
17911			let filterId = null;
17912			try {
17913				filterId = await this.#filterIdPromise;
17914			} catch (error) {
17915				if (!isError(error, "UNSUPPORTED_OPERATION") || error.operation !== "eth_newFilter") throw error;
17916			}
17917			if (filterId == null) {
17918				this.#filterIdPromise = null;
17919				this.#provider._recoverSubscriber(this, this._recover(this.#provider));
17920				return;
17921			}
17922			const network = await this.#provider.getNetwork();
17923			if (!this.#network) this.#network = network;
17924			if (this.#network.chainId !== network.chainId) throw new Error("chaid changed");
17925			if (this.#hault) return;
17926			const result = await this.#provider.send("eth_getFilterChanges", [filterId]);
17927			await this._emitResults(this.#provider, result);
17928		} catch (error) {
17929			console.log("@TODO", error);
17930		}
17931		this.#provider.once("block", this.#poller);
17932	}
17933	#teardown() {
17934		const filterIdPromise = this.#filterIdPromise;
17935		if (filterIdPromise) {
17936			this.#filterIdPromise = null;
17937			filterIdPromise.then((filterId) => {
17938				if (this.#provider.destroyed) return;
17939				this.#provider.send("eth_uninstallFilter", [filterId]);
17940			});
17941		}
17942	}
17943	start() {
17944		if (this.#running) return;
17945		this.#running = true;
17946		this.#poll(-2);
17947	}
17948	stop() {
17949		if (!this.#running) return;
17950		this.#running = false;
17951		this.#hault = true;
17952		this.#teardown();
17953		this.#provider.off("block", this.#poller);
17954	}
17955	pause(dropWhilePaused) {
17956		if (dropWhilePaused) this.#teardown();
17957		this.#provider.off("block", this.#poller);
17958	}
17959	resume() {
17960		this.start();
17961	}
17962};
17963/**
17964*  A **FilterIdSubscriber** for receiving contract events.
17965*
17966*  @_docloc: api/providers/abstract-provider
17967*/
17968var FilterIdEventSubscriber = class extends FilterIdSubscriber {
17969	#event;
17970	/**
17971	*  Creates a new **FilterIdEventSubscriber** attached to %%provider%%
17972	*  listening for %%filter%%.
17973	*/
17974	constructor(provider, filter) {
17975		super(provider);
17976		this.#event = copy(filter);
17977	}
17978	_recover(provider) {
17979		return new PollingEventSubscriber(provider, this.#event);
17980	}
17981	async _subscribe(provider) {
17982		return await provider.send("eth_newFilter", [this.#event]);
17983	}
17984	async _emitResults(provider, results) {
17985		for (const result of results) provider.emit(this.#event, provider._wrapLog(result, provider._network));
17986	}
17987};
17988/**
17989*  A **FilterIdSubscriber** for receiving pending transactions events.
17990*
17991*  @_docloc: api/providers/abstract-provider
17992*/
17993var FilterIdPendingSubscriber = class extends FilterIdSubscriber {
17994	async _subscribe(provider) {
17995		return await provider.send("eth_newPendingTransactionFilter", []);
17996	}
17997	async _emitResults(provider, results) {
17998		for (const result of results) provider.emit("pending", result);
17999	}
18000};
18001//#endregion

18002//#region node_modules/ethers/lib.esm/providers/provider-jsonrpc.js
18003/**
18004*  One of the most common ways to interact with the blockchain is
18005*  by a node running a JSON-RPC interface which can be connected to,
18006*  based on the transport, using:
18007*
18008*  - HTTP or HTTPS - [[JsonRpcProvider]]
18009*  - WebSocket - [[WebSocketProvider]]
18010*  - IPC - [[IpcSocketProvider]]
18011*
18012* @_section: api/providers/jsonrpc:JSON-RPC Provider  [about-jsonrpcProvider]
18013*/
18014var Primitive = "bigint,boolean,function,number,string,symbol".split(/,/g);
18015function deepCopy(value) {
18016	if (value == null || Primitive.indexOf(typeof value) >= 0) return value;
18017	if (typeof value.getAddress === "function") return value;
18018	if (Array.isArray(value)) return value.map(deepCopy);
18019	if (typeof value === "object") return Object.keys(value).reduce((accum, key) => {
18020		accum[key] = value[key];
18021		return accum;
18022	}, {});
18023	throw new Error(`should not happen: ${value} (${typeof value})`);
18024}
18025function stall$3(duration) {
18026	return new Promise((resolve) => {
18027		setTimeout(resolve, duration);
18028	});
18029}
18030function getLowerCase(value) {
18031	if (value) return value.toLowerCase();
18032	return value;
18033}
18034function isPollable(value) {
18035	return value && typeof value.pollingInterval === "number";
18036}
18037var defaultOptions = {
18038	polling: false,
18039	staticNetwork: null,
18040	batchStallTime: 10,
18041	batchMaxSize: 1 << 20,
18042	batchMaxCount: 100,
18043	cacheTimeout: 250,
18044	pollingInterval: 4e3
18045};
18046var JsonRpcSigner = class extends AbstractSigner {
18047	address;
18048	constructor(provider, address) {
18049		super(provider);
18050		address = getAddress(address);
18051		defineProperties(this, { address });
18052	}
18053	connect(provider) {
18054		assert(false, "cannot reconnect JsonRpcSigner", "UNSUPPORTED_OPERATION", { operation: "signer.connect" });
18055	}
18056	async getAddress() {
18057		return this.address;
18058	}
18059	async populateTransaction(tx) {
18060		return await this.populateCall(tx);
18061	}
18062	async sendUncheckedTransaction(_tx) {
18063		const tx = deepCopy(_tx);
18064		const promises = [];
18065		if (tx.from) {
18066			const _from = tx.from;
18067			promises.push((async () => {
18068				const from = await resolveAddress(_from, this.provider);
18069				assertArgument(from != null && from.toLowerCase() === this.address.toLowerCase(), "from address mismatch", "transaction", _tx);
18070				tx.from = from;
18071			})());
18072		} else tx.from = this.address;
18073		if (tx.gasLimit == null) promises.push((async () => {
18074			tx.gasLimit = await this.provider.estimateGas({
18075				...tx,
18076				from: this.address
18077			});
18078		})());
18079		if (tx.to != null) {
18080			const _to = tx.to;
18081			promises.push((async () => {
18082				tx.to = await resolveAddress(_to, this.provider);
18083			})());
18084		}
18085		if (promises.length) await Promise.all(promises);
18086		const hexTx = this.provider.getRpcTransaction(tx);
18087		return this.provider.send("eth_sendTransaction", [hexTx]);
18088	}
18089	async sendTransaction(tx) {
18090		const blockNumber = await this.provider.getBlockNumber();
18091		const hash = await this.sendUncheckedTransaction(tx);
18092		return await new Promise((resolve, reject) => {
18093			const timeouts = [1e3, 100];
18094			let invalids = 0;
18095			const checkTx = async () => {
18096				try {
18097					const tx = await this.provider.getTransaction(hash);
18098					if (tx != null) {
18099						resolve(tx.replaceableTransaction(blockNumber));
18100						return;
18101					}
18102				} catch (error) {
18103					if (isError(error, "CANCELLED") || isError(error, "BAD_DATA") || isError(error, "NETWORK_ERROR") || isError(error, "UNSUPPORTED_OPERATION")) {
18104						if (error.info == null) error.info = {};
18105						error.info.sendTransactionHash = hash;
18106						reject(error);
18107						return;
18108					}
18109					if (isError(error, "INVALID_ARGUMENT")) {
18110						invalids++;
18111						if (error.info == null) error.info = {};
18112						error.info.sendTransactionHash = hash;
18113						if (invalids > 10) {
18114							reject(error);
18115							return;
18116						}
18117					}
18118					this.provider.emit("error", makeError("failed to fetch transation after sending (will try again)", "UNKNOWN_ERROR", { error }));
18119				}
18120				this.provider._setTimeout(() => {
18121					checkTx();
18122				}, timeouts.pop() || 4e3);
18123			};
18124			checkTx();
18125		});
18126	}
18127	async signTransaction(_tx) {
18128		const tx = deepCopy(_tx);
18129		if (tx.from) {
18130			const from = await resolveAddress(tx.from, this.provider);
18131			assertArgument(from != null && from.toLowerCase() === this.address.toLowerCase(), "from address mismatch", "transaction", _tx);
18132			tx.from = from;
18133		} else tx.from = this.address;
18134		const hexTx = this.provider.getRpcTransaction(tx);
18135		return await this.provider.send("eth_signTransaction", [hexTx]);
18136	}
18137	async signMessage(_message) {
18138		const message = typeof _message === "string" ? toUtf8Bytes(_message) : _message;
18139		return await this.provider.send("personal_sign", [hexlify(message), this.address.toLowerCase()]);
18140	}
18141	async signTypedData(domain, types, _value) {
18142		const value = deepCopy(_value);
18143		const populated = await TypedDataEncoder.resolveNames(domain, types, value, async (value) => {
18144			const address = await resolveAddress(value);
18145			assertArgument(address != null, "TypedData does not support null address", "value", value);
18146			return address;
18147		});
18148		return await this.provider.send("eth_signTypedData_v4", [this.address.toLowerCase(), JSON.stringify(TypedDataEncoder.getPayload(populated.domain, types, populated.value))]);
18149	}
18150	async unlock(password) {
18151		return this.provider.send("personal_unlockAccount", [
18152			this.address.toLowerCase(),
18153			password,
18154			null
18155		]);
18156	}
18157	async _legacySignMessage(_message) {
18158		const message = typeof _message === "string" ? toUtf8Bytes(_message) : _message;
18159		return await this.provider.send("eth_sign", [this.address.toLowerCase(), hexlify(message)]);
18160	}
18161};
18162/**
18163*  The JsonRpcApiProvider is an abstract class and **MUST** be
18164*  sub-classed.
18165*
18166*  It provides the base for all JSON-RPC-based Provider interaction.
18167*
18168*  Sub-classing Notes:
18169*  - a sub-class MUST override _send
18170*  - a sub-class MUST call the `_start()` method once connected
18171*/
18172var JsonRpcApiProvider = class extends AbstractProvider {
18173	#options;
18174	#nextId;
18175	#payloads;
18176	#drainTimer;
18177	#notReady;
18178	#network;
18179	#pendingDetectNetwork;
18180	#scheduleDrain() {
18181		if (this.#drainTimer) return;
18182		const stallTime = this._getOption("batchMaxCount") === 1 ? 0 : this._getOption("batchStallTime");
18183		this.#drainTimer = setTimeout(() => {
18184			this.#drainTimer = null;
18185			const payloads = this.#payloads;
18186			this.#payloads = [];
18187			while (payloads.length) {
18188				const batch = [payloads.shift()];
18189				while (payloads.length) {
18190					if (batch.length === this.#options.batchMaxCount) break;
18191					batch.push(payloads.shift());
18192					if (JSON.stringify(batch.map((p) => p.payload)).length > this.#options.batchMaxSize) {
18193						payloads.unshift(batch.pop());
18194						break;
18195					}
18196				}
18197				(async () => {
18198					const payload = batch.length === 1 ? batch[0].payload : batch.map((p) => p.payload);

vendor: 2,536 bytes, lines 18199-18284

18199					this.emit("debug", {
18200						action: "sendRpcPayload",
18201						payload
18202					});
18203					try {
18204						const result = await this._send(payload);
18205						this.emit("debug", {
18206							action: "receiveRpcResult",
18207							result
18208						});
18209						for (const { resolve, reject, payload } of batch) {
18210							if (this.destroyed) {
18211								reject(makeError("provider destroyed; cancelled request", "UNSUPPORTED_OPERATION", { operation: payload.method }));
18212								continue;
18213							}
18214							const resp = result.filter((r) => r.id === payload.id)[0];
18215							if (resp == null) {
18216								const error = makeError("missing response for request", "BAD_DATA", {
18217									value: result,
18218									info: { payload }
18219								});
18220								this.emit("error", error);
18221								reject(error);
18222								continue;
18223							}
18224							if ("error" in resp) {
18225								reject(this.getRpcError(payload, resp));
18226								continue;
18227							}
18228							resolve(resp.result);
18229						}
18230					} catch (error) {
18231						this.emit("debug", {
18232							action: "receiveRpcError",
18233							error
18234						});
18235						for (const { reject } of batch) reject(error);
18236					}
18237				})();
18238			}
18239		}, stallTime);
18240	}
18241	constructor(network, options) {
18242		super(network, options);
18243		this.#nextId = 1;
18244		this.#options = Object.assign({}, defaultOptions, options || {});
18245		this.#payloads = [];
18246		this.#drainTimer = null;
18247		this.#network = null;
18248		this.#pendingDetectNetwork = null;
18249		{
18250			let resolve = null;
18251			const promise = new Promise((_resolve) => {
18252				resolve = _resolve;
18253			});
18254			this.#notReady = {
18255				promise,
18256				resolve
18257			};
18258		}
18259		const staticNetwork = this._getOption("staticNetwork");
18260		if (typeof staticNetwork === "boolean") {
18261			assertArgument(!staticNetwork || network !== "any", "staticNetwork cannot be used on special network 'any'", "options", options);
18262			if (staticNetwork && network != null) this.#network = Network.from(network);
18263		} else if (staticNetwork) {
18264			assertArgument(network == null || staticNetwork.matches(network), "staticNetwork MUST match network object", "options", options);
18265			this.#network = staticNetwork;
18266		}
18267	}
18268	/**
18269	*  Returns the value associated with the option %%key%%.
18270	*
18271	*  Sub-classes can use this to inquire about configuration options.
18272	*/
18273	_getOption(key) {
18274		return this.#options[key];
18275	}
18276	/**
18277	*  Gets the [[Network]] this provider has committed to. On each call, the network
18278	*  is detected, and if it has changed, the call will reject.
18279	*/
18280	get _network() {
18281		assert(this.#network, "network is not available yet", "NETWORK_ERROR");
18282		return this.#network;
18283	}
18284	/**

18285	*  Resolves to the non-normalized value by performing %%req%%.
18286	*
18287	*  Sub-classes may override this to modify behavior of actions,
18288	*  and should generally call ``super._perform`` as a fallback.
18289	*/
18290	async _perform(req) {
18291		if (req.method === "call" || req.method === "estimateGas") {
18292			let tx = req.transaction;
18293			if (tx && tx.type != null && getBigInt(tx.type)) {
18294				if (tx.maxFeePerGas == null && tx.maxPriorityFeePerGas == null) {
18295					const feeData = await this.getFeeData();
18296					if (feeData.maxFeePerGas == null && feeData.maxPriorityFeePerGas == null) req = Object.assign({}, req, { transaction: Object.assign({}, tx, { type: void 0 }) });
18297				}
18298			}
18299		}
18300		const request = this.getRpcRequest(req);
18301		if (request != null) return await this.send(request.method, request.args);
18302		return super._perform(req);
18303	}
18304	/**
18305	*  Sub-classes may override this; it detects the *actual* network that
18306	*  we are **currently** connected to.
18307	*
18308	*  Keep in mind that [[send]] may only be used once [[ready]], otherwise the
18309	*  _send primitive must be used instead.
18310	*/
18311	async _detectNetwork() {
18312		const network = this._getOption("staticNetwork");
18313		if (network) {
18314			if (network === true) {
18315				if (this.#network) return this.#network;
18316			} else return network;
18317		}
18318		if (this.#pendingDetectNetwork) return await this.#pendingDetectNetwork;
18319		if (this.ready) {
18320			this.#pendingDetectNetwork = (async () => {
18321				try {
18322					const result = Network.from(getBigInt(await this.send("eth_chainId", [])));
18323					this.#pendingDetectNetwork = null;
18324					return result;
18325				} catch (error) {
18326					this.#pendingDetectNetwork = null;
18327					throw error;
18328				}
18329			})();
18330			return await this.#pendingDetectNetwork;
18331		}
18332		this.#pendingDetectNetwork = (async () => {
18333			const payload = {
18334				id: this.#nextId++,
18335				method: "eth_chainId",
18336				params: [],
18337				jsonrpc: "2.0"
18338			};
18339			this.emit("debug", {
18340				action: "sendRpcPayload",
18341				payload
18342			});
18343			let result;
18344			try {
18345				result = (await this._send(payload))[0];
18346				this.#pendingDetectNetwork = null;
18347			} catch (error) {
18348				this.#pendingDetectNetwork = null;
18349				this.emit("debug", {
18350					action: "receiveRpcError",
18351					error
18352				});
18353				throw error;
18354			}
18355			this.emit("debug", {
18356				action: "receiveRpcResult",
18357				result
18358			});
18359			if ("result" in result) return Network.from(getBigInt(result.result));
18360			throw this.getRpcError(payload, result);
18361		})();
18362		return await this.#pendingDetectNetwork;
18363	}
18364	/**
18365	*  Sub-classes **MUST** call this. Until [[_start]] has been called, no calls
18366	*  will be passed to [[_send]] from [[send]]. If it is overridden, then
18367	*  ``super._start()`` **MUST** be called.
18368	*
18369	*  Calling it multiple times is safe and has no effect.
18370	*/
18371	_start() {
18372		if (this.#notReady == null || this.#notReady.resolve == null) return;
18373		this.#notReady.resolve();
18374		this.#notReady = null;
18375		(async () => {
18376			while (this.#network == null && !this.destroyed) try {
18377				this.#network = await this._detectNetwork();
18378			} catch (error) {
18379				if (this.destroyed) break;
18380				console.log("JsonRpcProvider failed to detect network and cannot start up; retry in 1s (perhaps the URL is wrong or the node is not started)");
18381				this.emit("error", makeError("failed to bootstrap network detection", "NETWORK_ERROR", {
18382					event: "initial-network-discovery",
18383					info: { error }
18384				}));
18385				await stall$3(1e3);
18386			}
18387			this.#scheduleDrain();
18388		})();
18389	}
18390	/**
18391	*  Resolves once the [[_start]] has been called. This can be used in
18392	*  sub-classes to defer sending data until the connection has been
18393	*  established.
18394	*/
18395	async _waitUntilReady() {
18396		if (this.#notReady == null) return;
18397		return await this.#notReady.promise;
18398	}
18399	/**
18400	*  Return a Subscriber that will manage the %%sub%%.
18401	*
18402	*  Sub-classes may override this to modify the behavior of
18403	*  subscription management.
18404	*/
18405	_getSubscriber(sub) {
18406		if (sub.type === "pending") return new FilterIdPendingSubscriber(this);
18407		if (sub.type === "event") {
18408			if (this._getOption("polling")) return new PollingEventSubscriber(this, sub.filter);
18409			return new FilterIdEventSubscriber(this, sub.filter);
18410		}
18411		if (sub.type === "orphan" && sub.filter.orphan === "drop-log") return new UnmanagedSubscriber("orphan");
18412		return super._getSubscriber(sub);
18413	}
18414	/**
18415	*  Returns true only if the [[_start]] has been called.
18416	*/
18417	get ready() {
18418		return this.#notReady == null;
18419	}

18420	/**
18421	*  Returns %%tx%% as a normalized JSON-RPC transaction request,
18422	*  which has all values hexlified and any numeric values converted
18423	*  to Quantity values.
18424	*/
18425	getRpcTransaction(tx) {
18426		const result = {};
18427		[
18428			"chainId",
18429			"gasLimit",
18430			"gasPrice",
18431			"type",
18432			"maxFeePerGas",
18433			"maxPriorityFeePerGas",
18434			"nonce",
18435			"value"
18436		].forEach((key) => {
18437			if (tx[key] == null) return;
18438			let dstKey = key;
18439			if (key === "gasLimit") dstKey = "gas";
18440			result[dstKey] = toQuantity(getBigInt(tx[key], `tx.${key}`));
18441		});
18442		[
18443			"from",
18444			"to",
18445			"data"
18446		].forEach((key) => {
18447			if (tx[key] == null) return;
18448			result[key] = hexlify(tx[key]);
18449		});
18450		if (tx.accessList) result["accessList"] = accessListify(tx.accessList);
18451		if (tx.blobVersionedHashes) result["blobVersionedHashes"] = tx.blobVersionedHashes.map((h) => h.toLowerCase());
18452		if (tx.authorizationList) result["authorizationList"] = tx.authorizationList.map((_a) => {
18453			const a = authorizationify(_a);
18454			return {
18455				address: a.address,
18456				nonce: toQuantity(a.nonce),
18457				chainId: toQuantity(a.chainId),
18458				yParity: toQuantity(a.signature.yParity),
18459				r: toQuantity(a.signature.r),
18460				s: toQuantity(a.signature.s)
18461			};
18462		});
18463		return result;
18464	}
18465	/**
18466	*  Returns the request method and arguments required to perform
18467	*  %%req%%.
18468	*/
18469	getRpcRequest(req) {
18470		switch (req.method) {
18471			case "chainId": return {
18472				method: "eth_chainId",
18473				args: []
18474			};
18475			case "getBlockNumber": return {
18476				method: "eth_blockNumber",
18477				args: []
18478			};
18479			case "getGasPrice": return {
18480				method: "eth_gasPrice",
18481				args: []
18482			};
18483			case "getPriorityFee": return {
18484				method: "eth_maxPriorityFeePerGas",
18485				args: []
18486			};
18487			case "getBalance": return {
18488				method: "eth_getBalance",
18489				args: [getLowerCase(req.address), req.blockTag]
18490			};
18491			case "getTransactionCount": return {
18492				method: "eth_getTransactionCount",
18493				args: [getLowerCase(req.address), req.blockTag]
18494			};
18495			case "getCode": return {
18496				method: "eth_getCode",
18497				args: [getLowerCase(req.address), req.blockTag]
18498			};
18499			case "getStorage": return {
18500				method: "eth_getStorageAt",
18501				args: [
18502					getLowerCase(req.address),
18503					"0x" + req.position.toString(16),
18504					req.blockTag
18505				]
18506			};
18507			case "broadcastTransaction": return {
18508				method: "eth_sendRawTransaction",
18509				args: [req.signedTransaction]
18510			};
18511			case "getBlock":
18512				if ("blockTag" in req) return {
18513					method: "eth_getBlockByNumber",
18514					args: [req.blockTag, !!req.includeTransactions]
18515				};
18516				else if ("blockHash" in req) return {
18517					method: "eth_getBlockByHash",
18518					args: [req.blockHash, !!req.includeTransactions]
18519				};
18520				break;
18521			case "getTransaction": return {
18522				method: "eth_getTransactionByHash",
18523				args: [req.hash]
18524			};
18525			case "getTransactionReceipt": return {
18526				method: "eth_getTransactionReceipt",
18527				args: [req.hash]
18528			};
18529			case "call": return {
18530				method: "eth_call",
18531				args: [this.getRpcTransaction(req.transaction), req.blockTag]
18532			};
18533			case "estimateGas": return {
18534				method: "eth_estimateGas",
18535				args: [this.getRpcTransaction(req.transaction)]
18536			};
18537			case "getLogs":
18538				if (req.filter && req.filter.address != null) {
18539					if (Array.isArray(req.filter.address)) req.filter.address = req.filter.address.map(getLowerCase);
18540					else req.filter.address = getLowerCase(req.filter.address);
18541				}
18542				return {
18543					method: "eth_getLogs",
18544					args: [req.filter]
18545				};
18546		}
18547		return null;
18548	}
18549	/**
18550	*  Returns an ethers-style Error for the given JSON-RPC error
18551	*  %%payload%%, coalescing the various strings and error shapes
18552	*  that different nodes return, coercing them into a machine-readable
18553	*  standardized error.
18554	*/
18555	getRpcError(payload, _error) {
18556		const { method } = payload;
18557		const { error } = _error;
18558		if (method === "eth_estimateGas" && error.message) {
18559			const msg = error.message;
18560			if (!msg.match(/revert/i) && msg.match(/insufficient funds/i)) return makeError("insufficient funds", "INSUFFICIENT_FUNDS", {
18561				transaction: payload.params[0],
18562				info: {
18563					payload,
18564					error
18565				}
18566			});
18567			else if (msg.match(/nonce/i) && msg.match(/too low/i)) return makeError("nonce has already been used", "NONCE_EXPIRED", {
18568				transaction: payload.params[0],
18569				info: {
18570					payload,
18571					error
18572				}
18573			});
18574		}
18575		if (method === "eth_call" || method === "eth_estimateGas") {
18576			const result = spelunkData(error);
18577			const e = AbiCoder.getBuiltinCallException(method === "eth_call" ? "call" : "estimateGas", payload.params[0], result ? result.data : null);
18578			e.info = {
18579				error,
18580				payload
18581			};
18582			return e;
18583		}
18584		const message = JSON.stringify(spelunkMessage(error));
18585		if (typeof error.message === "string" && error.message.match(/user denied|ethers-user-denied/i)) return makeError(`user rejected action`, "ACTION_REJECTED", {
18586			action: {
18587				eth_sign: "signMessage",
18588				personal_sign: "signMessage",
18589				eth_signTypedData_v4: "signTypedData",
18590				eth_signTransaction: "signTransaction",
18591				eth_sendTransaction: "sendTransaction",
18592				eth_requestAccounts: "requestAccess",
18593				wallet_requestAccounts: "requestAccess"
18594			}[method] || "unknown",
18595			reason: "rejected",
18596			info: {
18597				payload,
18598				error
18599			}
18600		});
18601		if (method === "eth_sendRawTransaction" || method === "eth_sendTransaction") {
18602			const transaction = payload.params[0];
18603			if (message.match(/insufficient funds|base fee exceeds gas limit/i)) return makeError("insufficient funds for intrinsic transaction cost", "INSUFFICIENT_FUNDS", {
18604				transaction,
18605				info: { error }
18606			});
18607			if (message.match(/nonce/i) && message.match(/too low/i)) return makeError("nonce has already been used", "NONCE_EXPIRED", {
18608				transaction,
18609				info: { error }
18610			});
18611			if (message.match(/replacement transaction/i) && message.match(/underpriced/i)) return makeError("replacement fee too low", "REPLACEMENT_UNDERPRICED", {
18612				transaction,
18613				info: { error }
18614			});
18615			if (message.match(/only replay-protected/i)) return makeError("legacy pre-eip-155 transactions not supported", "UNSUPPORTED_OPERATION", {
18616				operation: method,
18617				info: {
18618					transaction,
18619					info: { error }
18620				}
18621			});
18622		}
18623		let unsupported = !!message.match(/the method .* does not exist/i);
18624		if (!unsupported) {
18625			if (error && error.details && error.details.startsWith("Unauthorized method:")) unsupported = true;
18626		}
18627		if (unsupported) return makeError("unsupported operation", "UNSUPPORTED_OPERATION", {
18628			operation: payload.method,
18629			info: {
18630				error,
18631				payload
18632			}
18633		});
18634		return makeError("could not coalesce error", "UNKNOWN_ERROR", {
18635			error,
18636			payload
18637		});
18638	}
18639	/**
18640	*  Requests the %%method%% with %%params%% via the JSON-RPC protocol
18641	*  over the underlying channel. This can be used to call methods
18642	*  on the backend that do not have a high-level API within the Provider
18643	*  API.
18644	*
18645	*  This method queues requests according to the batch constraints
18646	*  in the options, assigns the request a unique ID.
18647	*
18648	*  **Do NOT override** this method in sub-classes; instead
18649	*  override [[_send]] or force the options values in the
18650	*  call to the constructor to modify this method's behavior.
18651	*/
18652	send(method, params) {
18653		if (this.destroyed) return Promise.reject(makeError("provider destroyed; cancelled request", "UNSUPPORTED_OPERATION", { operation: method }));
18654		const id = this.#nextId++;
18655		const promise = new Promise((resolve, reject) => {
18656			this.#payloads.push({
18657				resolve,
18658				reject,
18659				payload: {
18660					method,
18661					params,
18662					id,
18663					jsonrpc: "2.0"
18664				}
18665			});
18666		});
18667		this.#scheduleDrain();
18668		return promise;
18669	}

18670	/**
18671	*  Resolves to the [[Signer]] account for  %%address%% managed by
18672	*  the client.
18673	*
18674	*  If the %%address%% is a number, it is used as an index in the
18675	*  the accounts from [[listAccounts]].
18676	*
18677	*  This can only be used on clients which manage accounts (such as
18678	*  Geth with imported account or MetaMask).
18679	*
18680	*  Throws if the account doesn't exist.
18681	*/
18682	async getSigner(address) {
18683		if (address == null) address = 0;
18684		const accountsPromise = this.send("eth_accounts", []);
18685		if (typeof address === "number") {
18686			const accounts = await accountsPromise;
18687			if (address >= accounts.length) throw new Error("no such account");
18688			return new JsonRpcSigner(this, accounts[address]);
18689		}
18690		const { accounts } = await resolveProperties({
18691			network: this.getNetwork(),
18692			accounts: accountsPromise
18693		});
18694		address = getAddress(address);
18695		for (const account of accounts) if (getAddress(account) === address) return new JsonRpcSigner(this, address);
18696		throw new Error("invalid account");
18697	}
18698	async listAccounts() {
18699		return (await this.send("eth_accounts", [])).map((a) => new JsonRpcSigner(this, a));
18700	}
18701	destroy() {
18702		if (this.#drainTimer) {
18703			clearTimeout(this.#drainTimer);
18704			this.#drainTimer = null;
18705		}
18706		for (const { payload, reject } of this.#payloads) reject(makeError("provider destroyed; cancelled request", "UNSUPPORTED_OPERATION", { operation: payload.method }));
18707		this.#payloads = [];
18708		super.destroy();
18709	}
18710};
18711/**
18712*  @_ignore:
18713*/
18714var JsonRpcApiPollingProvider = class extends JsonRpcApiProvider {
18715	#pollingInterval;
18716	constructor(network, options) {
18717		super(network, options);
18718		let pollingInterval = this._getOption("pollingInterval");
18719		if (pollingInterval == null) pollingInterval = defaultOptions.pollingInterval;
18720		this.#pollingInterval = pollingInterval;
18721	}
18722	_getSubscriber(sub) {
18723		const subscriber = super._getSubscriber(sub);
18724		if (isPollable(subscriber)) subscriber.pollingInterval = this.#pollingInterval;
18725		return subscriber;
18726	}
18727	/**
18728	*  The polling interval (default: 4000 ms)
18729	*/
18730	get pollingInterval() {
18731		return this.#pollingInterval;
18732	}
18733	set pollingInterval(value) {
18734		if (!Number.isInteger(value) || value < 0) throw new Error("invalid interval");
18735		this.#pollingInterval = value;
18736		this._forEachSubscriber((sub) => {
18737			if (isPollable(sub)) sub.pollingInterval = this.#pollingInterval;
18738		});
18739	}
18740};
18741/**
18742*  The JsonRpcProvider is one of the most common Providers,
18743*  which performs all operations over HTTP (or HTTPS) requests.
18744*
18745*  Events are processed by polling the backend for the current block
18746*  number; when it advances, all block-base events are then checked
18747*  for updates.
18748*/
18749var JsonRpcProvider = class extends JsonRpcApiPollingProvider {
18750	#connect;
18751	constructor(url, network, options) {
18752		if (url == null) url = "http://localhost:8545";
18753		super(network, options);
18754		if (typeof url === "string") this.#connect = new FetchRequest(url);
18755		else this.#connect = url.clone();
18756	}
18757	_getConnection() {
18758		return this.#connect.clone();
18759	}
18760	async send(method, params) {
18761		await this._start();
18762		return await super.send(method, params);
18763	}
18764	async _send(payload) {
18765		const request = this._getConnection();
18766		request.body = JSON.stringify(payload);
18767		request.setHeader("content-type", "application/json");
18768		const response = await request.send();
18769		response.assertOk();
18770		let resp = response.bodyJson;

18771		if (!Array.isArray(resp)) resp = [resp];
18772		return resp;
18773	}
18774};
18775function spelunkData(value) {
18776	if (value == null) return null;
18777	if (typeof value.message === "string" && value.message.match(/revert/i) && isHexString(value.data)) return {
18778		message: value.message,
18779		data: value.data
18780	};
18781	if (typeof value === "object") {
18782		for (const key in value) {
18783			const result = spelunkData(value[key]);
18784			if (result) return result;
18785		}
18786		return null;
18787	}
18788	if (typeof value === "string") try {
18789		return spelunkData(JSON.parse(value));
18790	} catch (error) {}
18791	return null;
18792}
18793function _spelunkMessage(value, result) {
18794	if (value == null) return;
18795	if (typeof value.message === "string") result.push(value.message);
18796	if (typeof value === "object") for (const key in value) _spelunkMessage(value[key], result);
18797	if (typeof value === "string") try {
18798		return _spelunkMessage(JSON.parse(value), result);
18799	} catch (error) {}
18800}
18801function spelunkMessage(value) {
18802	const result = [];
18803	_spelunkMessage(value, result);
18804	return result;
18805}
18806//#endregion
18807//#region node_modules/ethers/lib.esm/providers/provider-ankr.js
18808/**
18809*  [[link-ankr]] provides a third-party service for connecting to
18810*  various blockchains over JSON-RPC.
18811*
18812*  **Supported Networks**
18813*
18814*  - Ethereum Mainnet (``mainnet``)
18815*  - Goerli Testnet (``goerli``)
18816*  - Sepolia Testnet (``sepolia``)
18817*  - Arbitrum (``arbitrum``)
18818*  - Base (``base``)
18819*  - Base Goerlia Testnet (``base-goerli``)
18820*  - Base Sepolia Testnet (``base-sepolia``)
18821*  - BNB (``bnb``)
18822*  - BNB Testnet (``bnbt``)
18823*  - Filecoin (``filecoin``)
18824*  - Filecoin Calibration Testnet (``filecoin-calibration``)
18825*  - Optimism (``optimism``)
18826*  - Optimism Goerli Testnet (``optimism-goerli``)
18827*  - Optimism Sepolia Testnet (``optimism-sepolia``)
18828*  - Polygon (``matic``)
18829*  - Polygon Mumbai Testnet (``matic-mumbai``)
18830*
18831*  @_subsection: api/providers/thirdparty:Ankr  [providers-ankr]
18832*/
18833var defaultApiKey$2 = "9f7d929b018cdffb338517efa06f58359e86ff1ffd350bc889738523659e7972";
18834function getHost$5(name) {
18835	switch (name) {
18836		case "mainnet": return "rpc.ankr.com/eth";
18837		case "goerli": return "rpc.ankr.com/eth_goerli";
18838		case "sepolia": return "rpc.ankr.com/eth_sepolia";
18839		case "arbitrum": return "rpc.ankr.com/arbitrum";
18840		case "base": return "rpc.ankr.com/base";
18841		case "base-goerli": return "rpc.ankr.com/base_goerli";
18842		case "base-sepolia": return "rpc.ankr.com/base_sepolia";
18843		case "bnb": return "rpc.ankr.com/bsc";
18844		case "bnbt": return "rpc.ankr.com/bsc_testnet_chapel";
18845		case "filecoin": return "rpc.ankr.com/filecoin";
18846		case "filecoin-calibration": return "rpc.ankr.com/filecoin_testnet";
18847		case "matic": return "rpc.ankr.com/polygon";
18848		case "matic-mumbai": return "rpc.ankr.com/polygon_mumbai";
18849		case "optimism": return "rpc.ankr.com/optimism";
18850		case "optimism-goerli": return "rpc.ankr.com/optimism_testnet";
18851		case "optimism-sepolia": return "rpc.ankr.com/optimism_sepolia";
18852	}
18853	assertArgument(false, "unsupported network", "network", name);
18854}
18855/**
18856*  The **AnkrProvider** connects to the [[link-ankr]]
18857*  JSON-RPC end-points.
18858*
18859*  By default, a highly-throttled API key is used, which is
18860*  appropriate for quick prototypes and simple scripts. To
18861*  gain access to an increased rate-limit, it is highly
18862*  recommended to [sign up here](link-ankr-signup).
18863*/
18864var AnkrProvider = class AnkrProvider extends JsonRpcProvider {
18865	/**
18866	*  The API key for the Ankr connection.
18867	*/
18868	apiKey;
18869	/**
18870	*  Create a new **AnkrProvider**.
18871	*
18872	*  By default connecting to ``mainnet`` with a highly throttled
18873	*  API key.
18874	*/
18875	constructor(_network, apiKey) {
18876		if (_network == null) _network = "mainnet";
18877		const network = Network.from(_network);
18878		if (apiKey == null) apiKey = defaultApiKey$2;
18879		const options = {
18880			polling: true,
18881			staticNetwork: network
18882		};
18883		const request = AnkrProvider.getRequest(network, apiKey);
18884		super(request, network, options);
18885		defineProperties(this, { apiKey });
18886	}
18887	_getProvider(chainId) {
18888		try {
18889			return new AnkrProvider(chainId, this.apiKey);
18890		} catch (error) {}
18891		return super._getProvider(chainId);
18892	}
18893	/**
18894	*  Returns a prepared request for connecting to %%network%% with
18895	*  %%apiKey%%.
18896	*/

18897	static getRequest(network, apiKey) {
18898		if (apiKey == null) apiKey = defaultApiKey$2;
18899		const request = new FetchRequest(`https:/\/${getHost$5(network.name)}/${apiKey}`);
18900		request.allowGzip = true;
18901		if (apiKey === defaultApiKey$2) request.retryFunc = async (request, response, attempt) => {
18902			showThrottleMessage("AnkrProvider");
18903			return true;
18904		};
18905		return request;
18906	}
18907	getRpcError(payload, error) {
18908		if (payload.method === "eth_sendRawTransaction") {
18909			if (error && error.error && error.error.message === "INTERNAL_ERROR: could not replace existing tx") error.error.message = "replacement transaction underpriced";
18910		}
18911		return super.getRpcError(payload, error);
18912	}
18913	isCommunityResource() {
18914		return this.apiKey === defaultApiKey$2;
18915	}
18916};
18917//#endregion
18918//#region node_modules/ethers/lib.esm/providers/provider-alchemy.js
18919/**
18920*  [[link-alchemy]] provides a third-party service for connecting to
18921*  various blockchains over JSON-RPC.
18922*
18923*  **Supported Networks**
18924*
18925*  - Ethereum Mainnet (``mainnet``)
18926*  - Goerli Testnet (``goerli``)
18927*  - Sepolia Testnet (``sepolia``)
18928*  - Arbitrum (``arbitrum``)
18929*  - Arbitrum Goerli Testnet (``arbitrum-goerli``)
18930*  - Arbitrum Sepolia Testnet (``arbitrum-sepolia``)
18931*  - Base (``base``)
18932*  - Base Goerlia Testnet (``base-goerli``)
18933*  - Base Sepolia Testnet (``base-sepolia``)
18934*  - Optimism (``optimism``)
18935*  - Optimism Goerli Testnet (``optimism-goerli``)
18936*  - Optimism Sepolia Testnet (``optimism-sepolia``)
18937*  - Polygon (``matic``)
18938*  - Polygon Amoy Testnet (``matic-amoy``)
18939*  - Polygon Mumbai Testnet (``matic-mumbai``)
18940*
18941*  @_subsection: api/providers/thirdparty:Alchemy  [providers-alchemy]
18942*/
18943var defaultApiKey$1 = "_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC";
18944function getHost$4(name) {
18945	switch (name) {
18946		case "mainnet": return "eth-mainnet.g.alchemy.com";
18947		case "goerli": return "eth-goerli.g.alchemy.com";
18948		case "sepolia": return "eth-sepolia.g.alchemy.com";
18949		case "arbitrum": return "arb-mainnet.g.alchemy.com";
18950		case "arbitrum-goerli": return "arb-goerli.g.alchemy.com";
18951		case "arbitrum-sepolia": return "arb-sepolia.g.alchemy.com";
18952		case "base": return "base-mainnet.g.alchemy.com";
18953		case "base-goerli": return "base-goerli.g.alchemy.com";
18954		case "base-sepolia": return "base-sepolia.g.alchemy.com";
18955		case "bnb": return "bnb-mainnet.g.alchemy.com";
18956		case "bnbt": return "bnb-testnet.g.alchemy.com";
18957		case "matic": return "polygon-mainnet.g.alchemy.com";
18958		case "matic-amoy": return "polygon-amoy.g.alchemy.com";
18959		case "matic-mumbai": return "polygon-mumbai.g.alchemy.com";
18960		case "optimism": return "opt-mainnet.g.alchemy.com";
18961		case "optimism-goerli": return "opt-goerli.g.alchemy.com";
18962		case "optimism-sepolia": return "opt-sepolia.g.alchemy.com";
18963	}
18964	assertArgument(false, "unsupported network", "network", name);
18965}
18966/**
18967*  The **AlchemyProvider** connects to the [[link-alchemy]]
18968*  JSON-RPC end-points.
18969*
18970*  By default, a highly-throttled API key is used, which is
18971*  appropriate for quick prototypes and simple scripts. To
18972*  gain access to an increased rate-limit, it is highly
18973*  recommended to [sign up here](link-alchemy-signup).
18974*
18975*  @_docloc: api/providers/thirdparty
18976*/
18977var AlchemyProvider = class AlchemyProvider extends JsonRpcProvider {
18978	apiKey;
18979	constructor(_network, apiKey) {
18980		if (_network == null) _network = "mainnet";
18981		const network = Network.from(_network);
18982		if (apiKey == null) apiKey = defaultApiKey$1;
18983		const request = AlchemyProvider.getRequest(network, apiKey);
18984		super(request, network, { staticNetwork: network });
18985		defineProperties(this, { apiKey });
18986	}
18987	_getProvider(chainId) {
18988		try {
18989			return new AlchemyProvider(chainId, this.apiKey);
18990		} catch (error) {}
18991		return super._getProvider(chainId);
18992	}
18993	async _perform(req) {
18994		if (req.method === "getTransactionResult") {
18995			const { trace, tx } = await resolveProperties({
18996				trace: this.send("trace_transaction", [req.hash]),
18997				tx: this.getTransaction(req.hash)
18998			});
18999			if (trace == null || tx == null) return null;
19000			let data;
19001			let error = false;
19002			try {
19003				data = trace[0].result.output;
19004				error = trace[0].error === "Reverted";
19005			} catch (error) {}
19006			if (data) {
19007				assert(!error, "an error occurred during transaction executions", "CALL_EXCEPTION", {
19008					action: "getTransactionResult",
19009					data,
19010					reason: null,
19011					transaction: tx,
19012					invocation: null,
19013					revert: null
19014				});
19015				return data;
19016			}
19017			assert(false, "could not parse trace result", "BAD_DATA", { value: trace });
19018		}
19019		return await super._perform(req);
19020	}
19021	isCommunityResource() {
19022		return this.apiKey === defaultApiKey$1;
19023	}

19024	static getRequest(network, apiKey) {
19025		if (apiKey == null) apiKey = defaultApiKey$1;
19026		const request = new FetchRequest(`https:/\/${getHost$4(network.name)}/v2/${apiKey}`);
19027		request.allowGzip = true;
19028		if (apiKey === defaultApiKey$1) request.retryFunc = async (request, response, attempt) => {
19029			showThrottleMessage("alchemy");
19030			return true;
19031		};
19032		return request;
19033	}
19034};
19035//#endregion
19036//#region node_modules/ethers/lib.esm/providers/provider-chainstack.js
19037/**
19038*  [[link-chainstack]] provides a third-party service for connecting to
19039*  various blockchains over JSON-RPC.
19040*
19041*  **Supported Networks**
19042*
19043*  - Ethereum Mainnet (``mainnet``)
19044*  - Arbitrum (``arbitrum``)
19045*  - BNB Smart Chain Mainnet (``bnb``)
19046*  - Polygon (``matic``)
19047*
19048*  @_subsection: api/providers/thirdparty:Chainstack  [providers-chainstack]
19049*/
19050function getApiKey(name) {
19051	switch (name) {
19052		case "mainnet": return "39f1d67cedf8b7831010a665328c9197";
19053		case "arbitrum": return "0550c209db33c3abf4cc927e1e18cea1";
19054		case "bnb": return "98b5a77e531614387366f6fc5da097f8";
19055		case "matic": return "cd9d4d70377471aa7c142ec4a4205249";
19056	}
19057	assertArgument(false, "unsupported network", "network", name);
19058}
19059function getHost$3(name) {
19060	switch (name) {
19061		case "mainnet": return "ethereum-mainnet.core.chainstack.com";
19062		case "arbitrum": return "arbitrum-mainnet.core.chainstack.com";
19063		case "bnb": return "bsc-mainnet.core.chainstack.com";
19064		case "matic": return "polygon-mainnet.core.chainstack.com";
19065	}
19066	assertArgument(false, "unsupported network", "network", name);
19067}
19068/**
19069*  The **ChainstackProvider** connects to the [[link-chainstack]]
19070*  JSON-RPC end-points.
19071*
19072*  By default, a highly-throttled API key is used, which is
19073*  appropriate for quick prototypes and simple scripts. To
19074*  gain access to an increased rate-limit, it is highly
19075*  recommended to [sign up here](link-chainstack).
19076*/
19077var ChainstackProvider = class ChainstackProvider extends JsonRpcProvider {
19078	/**
19079	*  The API key for the Chainstack connection.
19080	*/
19081	apiKey;
19082	/**
19083	*  Creates a new **ChainstackProvider**.
19084	*/
19085	constructor(_network, apiKey) {
19086		if (_network == null) _network = "mainnet";
19087		const network = Network.from(_network);
19088		if (apiKey == null) apiKey = getApiKey(network.name);
19089		const request = ChainstackProvider.getRequest(network, apiKey);
19090		super(request, network, { staticNetwork: network });
19091		defineProperties(this, { apiKey });
19092	}
19093	_getProvider(chainId) {
19094		try {
19095			return new ChainstackProvider(chainId, this.apiKey);
19096		} catch (error) {}
19097		return super._getProvider(chainId);
19098	}
19099	isCommunityResource() {
19100		return this.apiKey === getApiKey(this._network.name);
19101	}
19102	/**
19103	*  Returns a prepared request for connecting to %%network%%
19104	*  with %%apiKey%% and %%projectSecret%%.
19105	*/
19106	static getRequest(network, apiKey) {
19107		if (apiKey == null) apiKey = getApiKey(network.name);
19108		const request = new FetchRequest(`https:/\/${getHost$3(network.name)}/${apiKey}`);
19109		request.allowGzip = true;
19110		if (apiKey === getApiKey(network.name)) request.retryFunc = async (request, response, attempt) => {
19111			showThrottleMessage("ChainstackProvider");
19112			return true;
19113		};
19114		return request;
19115	}
19116};
19117//#endregion
19118//#region node_modules/ethers/lib.esm/providers/provider-cloudflare.js
19119/**
19120*  About Cloudflare
19121*
19122*  @_subsection: api/providers/thirdparty:Cloudflare  [providers-cloudflare]
19123*/
19124/**
19125*  About Cloudflare...
19126*/
19127var CloudflareProvider = class extends JsonRpcProvider {
19128	constructor(_network) {
19129		if (_network == null) _network = "mainnet";
19130		const network = Network.from(_network);
19131		assertArgument(network.name === "mainnet", "unsupported network", "network", _network);
19132		super("https://cloudflare-eth.com/", network, { staticNetwork: network });
19133	}
19134};
19135//#endregion
19136//#region node_modules/ethers/lib.esm/providers/provider-etherscan.js
19137/**
19138*  [[link-etherscan]] provides a third-party service for connecting to
19139*  various blockchains over a combination of JSON-RPC and custom API
19140*  endpoints.
19141*
19142*  **Supported Networks**
19143*
19144*  - Ethereum Mainnet (``mainnet``)
19145*  - Goerli Testnet (``goerli``)
19146*  - Sepolia Testnet (``sepolia``)
19147*  - Holesky Testnet (``holesky``)
19148*  - Arbitrum (``arbitrum``)
19149*  - Arbitrum Goerli Testnet (``arbitrum-goerli``)
19150*  - Base (``base``)
19151*  - Base Sepolia Testnet (``base-sepolia``)
19152*  - BNB Smart Chain Mainnet (``bnb``)
19153*  - BNB Smart Chain Testnet (``bnbt``)
19154*  - Optimism (``optimism``)
19155*  - Optimism Goerli Testnet (``optimism-goerli``)
19156*  - Polygon (``matic``)
19157*  - Polygon Mumbai Testnet (``matic-mumbai``)
19158*  - Polygon Amoy Testnet (``matic-amoy``)
19159*
19160*  @_subsection api/providers/thirdparty:Etherscan  [providers-etherscan]
19161*/
19162var Supported = "1 11155111 17000 560048 2741 11124 33111 33139 42170 42161 421614 43114 43113 8453 84532 80069 80094 199 1029 81457 168587773 56 97 42220 11142220 252 2523 100 999 737373 747474 59144 59141 5000 5003 43521 143 10143 1287 1284 1285 10 111

1916255420 204 5611 80002 137 534352 534351 1329 1328 146 14601 988 2201 1923 1924 167013 167000 130 1301 480 4801 51 50 324 300".split(/ /g);
19163var THROTTLE = 2e3;
19164function isPromise(value) {
19165	return value && typeof value.then === "function";
19166}
19167var EtherscanPluginId = "org.ethers.plugins.provider.Etherscan";
19168/**
19169*  A Network can include an **EtherscanPlugin** to provide
19170*  a custom base URL.
19171*
19172*  @_docloc: api/providers/thirdparty:Etherscan
19173*/
19174var EtherscanPlugin = class EtherscanPlugin extends NetworkPlugin {
19175	/**
19176	*  The Etherscan API base URL.
19177	*/
19178	baseUrl;
19179	/**
19180	*  Creates a new **EtherscanProvider** which will use
19181	*  %%baseUrl%%.
19182	*/
19183	constructor(baseUrl) {
19184		super(EtherscanPluginId);
19185		defineProperties(this, { baseUrl });
19186	}
19187	clone() {
19188		return new EtherscanPlugin(this.baseUrl);
19189	}
19190};
19191var skipKeys = ["enableCcipRead"];
19192var nextId = 1;
19193/**
19194*  The **EtherscanBaseProvider** is the super-class of
19195*  [[EtherscanProvider]], which should generally be used instead.
19196*
19197*  Since the **EtherscanProvider** includes additional code for
19198*  [[Contract]] access, in //rare cases// that contracts are not
19199*  used, this class can reduce code size.
19200*
19201*  @_docloc: api/providers/thirdparty:Etherscan
19202*/
19203var EtherscanProvider = class extends AbstractProvider {
19204	/**
19205	*  The connected network.
19206	*/
19207	network;
19208	/**
19209	*  The API key or null if using the community provided bandwidth.
19210	*/
19211	apiKey;
19212	#plugin;
19213	/**
19214	*  Creates a new **EtherscanBaseProvider**.
19215	*/
19216	constructor(_network, _apiKey) {
19217		const apiKey = _apiKey != null ? _apiKey : null;
19218		super();
19219		const network = Network.from(_network);
19220		assertArgument(Supported.indexOf(`${network.chainId}`) >= 0, "unsupported network", "network", network);
19221		this.#plugin = network.getPlugin(EtherscanPluginId);
19222		defineProperties(this, {
19223			apiKey,
19224			network
19225		});
19226	}
19227	/**
19228	*  Returns the base URL.
19229	*
19230	*  If an [[EtherscanPlugin]] is configured on the
19231	*  [[EtherscanBaseProvider_network]], returns the plugin's
19232	*  baseUrl.
19233	*
19234	*  Deprecated; for Etherscan v2 the base is no longer a simply
19235	*  host, but instead a URL including a chainId parameter. Changing
19236	*  this to return a URL prefix could break some libraries, so it
19237	*  is left intact but will be removed in the future as it is unused.
19238	*/
19239	getBaseUrl() {
19240		if (this.#plugin) return this.#plugin.baseUrl;
19241		switch (this.network.name) {
19242			case "mainnet": return "https://api.etherscan.io";
19243			case "goerli": return "https://api-goerli.etherscan.io";
19244			case "sepolia": return "https://api-sepolia.etherscan.io";
19245			case "holesky": return "https://api-holesky.etherscan.io";
19246			case "arbitrum": return "https://api.arbiscan.io";
19247			case "arbitrum-goerli": return "https://api-goerli.arbiscan.io";
19248			case "base": return "https://api.basescan.org";
19249			case "base-sepolia": return "https://api-sepolia.basescan.org";
19250			case "bnb": return "https://api.bscscan.com";
19251			case "bnbt": return "https://api-testnet.bscscan.com";
19252			case "matic": return "https://api.polygonscan.com";
19253			case "matic-amoy": return "https://api-amoy.polygonscan.com";
19254			case "matic-mumbai": return "https://api-testnet.polygonscan.com";
19255			case "optimism": return "https://api-optimistic.etherscan.io";
19256			case "optimism-goerli": return "https://api-goerli-optimistic.etherscan.io";
19257		}
19258		assertArgument(false, "unsupported network", "network", this.network);
19259	}
19260	/**
19261	*  Returns the URL for the %%module%% and %%params%%.
19262	*/
19263	getUrl(module, params) {
19264		let query = Object.keys(params).reduce((accum, key) => {
19265			const value = params[key];
19266			if (value != null) accum += `&${key}=${value}`;
19267			return accum;
19268		}, "");
19269		if (this.apiKey) query += `&apikey=${this.apiKey}`;
19270		return `https:/\/api.etherscan.io/v2/api?chainid=${this.network.chainId}&module=${module}${query}`;
19271	}
19272	/**
19273	*  Returns the URL for using POST requests.
19274	*/
19275	getPostUrl() {
19276		return `https:/\/api.etherscan.io/v2/api?chainid=${this.network.chainId}`;
19277	}
19278	/**
19279	*  Returns the parameters for using POST requests.
19280	*/
19281	getPostData(module, params) {
19282		params.module = module;
19283		params.apikey = this.apiKey;
19284		params.chainid = this.network.chainId;
19285		return params;
19286	}
19287	async detectNetwork() {
19288		return this.network;
19289	}
19290	/**
19291	*  Resolves to the result of calling %%module%% with %%params%%.
19292	*
19293	*  If %%post%%, the request is made as a POST request.
19294	*/
19295	async fetch(module, params, post) {
19296		const id = nextId++;
19297		const url = post ? this.getPostUrl() : this.getUrl(module, params);
19298		const payload = post ? this.getPostData(module, params) : null;

19299		this.emit("debug", {
19300			action: "sendRequest",
19301			id,
19302			url,
19303			payload
19304		});
19305		const request = new FetchRequest(url);
19306		request.setThrottleParams({ slotInterval: 1e3 });
19307		request.retryFunc = (req, resp, attempt) => {
19308			if (this.isCommunityResource()) showThrottleMessage("Etherscan");
19309			return Promise.resolve(true);
19310		};
19311		request.processFunc = async (request, response) => {
19312			const result = response.hasBody() ? JSON.parse(toUtf8String(response.body)) : {};
19313			const throttle = (typeof result.result === "string" ? result.result : "").toLowerCase().indexOf("rate limit") >= 0;
19314			if (module === "proxy") {
19315				if (result && result.status == 0 && result.message == "NOTOK" && throttle) {
19316					this.emit("debug", {
19317						action: "receiveError",
19318						id,
19319						reason: "proxy-NOTOK",
19320						error: result
19321					});
19322					response.throwThrottleError(result.result, THROTTLE);
19323				}
19324			} else if (throttle) {
19325				this.emit("debug", {
19326					action: "receiveError",
19327					id,
19328					reason: "null result",
19329					error: result.result
19330				});
19331				response.throwThrottleError(result.result, THROTTLE);
19332			}
19333			return response;
19334		};
19335		if (payload) {
19336			request.setHeader("content-type", "application/x-www-form-urlencoded; charset=UTF-8");
19337			request.body = Object.keys(payload).map((k) => `${k}=${payload[k]}`).join("&");
19338		}
19339		const response = await request.send();
19340		try {
19341			response.assertOk();
19342		} catch (error) {
19343			this.emit("debug", {
19344				action: "receiveError",
19345				id,
19346				error,
19347				reason: "assertOk"
19348			});
19349			assert(false, "response error", "SERVER_ERROR", {
19350				request,
19351				response
19352			});
19353		}
19354		if (!response.hasBody()) {
19355			this.emit("debug", {
19356				action: "receiveError",
19357				id,
19358				error: "missing body",
19359				reason: "null body"
19360			});
19361			assert(false, "missing response", "SERVER_ERROR", {
19362				request,
19363				response
19364			});
19365		}
19366		const result = JSON.parse(toUtf8String(response.body));
19367		if (module === "proxy") {
19368			if (result.jsonrpc != "2.0") {
19369				this.emit("debug", {
19370					action: "receiveError",
19371					id,
19372					result,
19373					reason: "invalid JSON-RPC"
19374				});
19375				assert(false, "invalid JSON-RPC response (missing jsonrpc='2.0')", "SERVER_ERROR", {
19376					request,
19377					response,
19378					info: { result }
19379				});
19380			}
19381			if (result.error) {
19382				this.emit("debug", {
19383					action: "receiveError",
19384					id,
19385					result,
19386					reason: "JSON-RPC error"
19387				});
19388				assert(false, "error response", "SERVER_ERROR", {
19389					request,
19390					response,
19391					info: { result }
19392				});
19393			}
19394			this.emit("debug", {
19395				action: "receiveRequest",
19396				id,
19397				result
19398			});
19399			return result.result;
19400		} else {
19401			if (result.status == 0 && (result.message === "No records found" || result.message === "No transactions found")) {
19402				this.emit("debug", {
19403					action: "receiveRequest",
19404					id,
19405					result
19406				});
19407				return result.result;
19408			}
19409			if (result.status != 1 || typeof result.message === "string" && !result.message.match(/^OK/)) {
19410				this.emit("debug", {
19411					action: "receiveError",
19412					id,
19413					result
19414				});
19415				assert(false, "error response", "SERVER_ERROR", {
19416					request,
19417					response,
19418					info: { result }
19419				});
19420			}
19421			this.emit("debug", {
19422				action: "receiveRequest",
19423				id,
19424				result
19425			});
19426			return result.result;
19427		}
19428	}
19429	/**
19430	*  Returns %%transaction%% normalized for the Etherscan API.
19431	*/
19432	_getTransactionPostData(transaction) {
19433		const result = {};
19434		for (let key in transaction) {
19435			if (skipKeys.indexOf(key) >= 0) continue;
19436			if (transaction[key] == null) continue;
19437			let value = transaction[key];
19438			if (key === "type" && value === 0) continue;
19439			if (key === "blockTag" && value === "latest") continue;
19440			if ({
19441				type: true,
19442				gasLimit: true,
19443				gasPrice: true,
19444				maxFeePerGas: true,
19445				maxPriorityFeePerGas: true,
19446				nonce: true,
19447				value: true
19448			}[key]) value = toQuantity(value);
19449			else if (key === "accessList") value = "[" + accessListify(value).map((set) => {
19450				return `{address:"${set.address}",storageKeys:["${set.storageKeys.join("\",\"")}"]}`;
19451			}).join(",") + "]";
19452			else if (key === "blobVersionedHashes") {
19453				if (value.length === 0) continue;
19454				assert(false, "Etherscan API does not support blobVersionedHashes", "UNSUPPORTED_OPERATION", {
19455					operation: "_getTransactionPostData",
19456					info: { transaction }
19457				});
19458			} else value = hexlify(value);
19459			result[key] = value;
19460		}
19461		return result;
19462	}

19463	/**
19464	*  Throws the normalized Etherscan error.
19465	*/
19466	_checkError(req, error, transaction) {
19467		let message = "";
19468		if (isError(error, "SERVER_ERROR")) {
19469			try {
19470				message = error.info.result.error.message;
19471			} catch (e) {}
19472			if (!message) try {
19473				message = error.info.message;
19474			} catch (e) {}
19475		}
19476		if (req.method === "estimateGas") {
19477			if (!message.match(/revert/i) && message.match(/insufficient funds/i)) assert(false, "insufficient funds", "INSUFFICIENT_FUNDS", { transaction: req.transaction });
19478		}
19479		if (req.method === "call" || req.method === "estimateGas") {
19480			if (message.match(/execution reverted/i)) {
19481				let data = "";
19482				try {
19483					data = error.info.result.error.data;
19484				} catch (error) {}
19485				const e = AbiCoder.getBuiltinCallException(req.method, req.transaction, data);
19486				e.info = {
19487					request: req,
19488					error
19489				};
19490				throw e;
19491			}
19492		}
19493		if (message) {
19494			if (req.method === "broadcastTransaction") {
19495				const transaction = Transaction.from(req.signedTransaction);
19496				if (message.match(/replacement/i) && message.match(/underpriced/i)) assert(false, "replacement fee too low", "REPLACEMENT_UNDERPRICED", { transaction });
19497				if (message.match(/insufficient funds/)) assert(false, "insufficient funds for intrinsic transaction cost", "INSUFFICIENT_FUNDS", { transaction });
19498				if (message.match(/same hash was already imported|transaction nonce is too low|nonce too low/)) assert(false, "nonce has already been used", "NONCE_EXPIRED", { transaction });
19499			}
19500		}
19501		throw error;
19502	}
19503	async _detectNetwork() {
19504		return this.network;
19505	}
19506	async _perform(req) {
19507		switch (req.method) {
19508			case "chainId": return this.network.chainId;
19509			case "getBlockNumber": return this.fetch("proxy", { action: "eth_blockNumber" });
19510			case "getGasPrice": return this.fetch("proxy", { action: "eth_gasPrice" });
19511			case "getPriorityFee": if (this.network.name === "mainnet") return "1000000000";
19512			else if (this.network.name === "optimism") return "1000000";
19513			else throw new Error("fallback onto the AbstractProvider default");
19514			case "getBalance": return this.fetch("account", {
19515				action: "balance",
19516				address: req.address,
19517				tag: req.blockTag
19518			});
19519			case "getTransactionCount": return this.fetch("proxy", {
19520				action: "eth_getTransactionCount",
19521				address: req.address,
19522				tag: req.blockTag
19523			});
19524			case "getCode": return this.fetch("proxy", {
19525				action: "eth_getCode",
19526				address: req.address,
19527				tag: req.blockTag
19528			});
19529			case "getStorage": return this.fetch("proxy", {
19530				action: "eth_getStorageAt",
19531				address: req.address,
19532				position: req.position,
19533				tag: req.blockTag
19534			});
19535			case "broadcastTransaction": return this.fetch("proxy", {
19536				action: "eth_sendRawTransaction",
19537				hex: req.signedTransaction
19538			}, true).catch((error) => {
19539				return this._checkError(req, error, req.signedTransaction);
19540			});
19541			case "getBlock":
19542				if ("blockTag" in req) return this.fetch("proxy", {
19543					action: "eth_getBlockByNumber",
19544					tag: req.blockTag,
19545					boolean: req.includeTransactions ? "true" : "false"
19546				});
19547				assert(false, "getBlock by blockHash not supported by Etherscan", "UNSUPPORTED_OPERATION", { operation: "getBlock(blockHash)" });
19548			case "getTransaction": return this.fetch("proxy", {
19549				action: "eth_getTransactionByHash",
19550				txhash: req.hash
19551			});
19552			case "getTransactionReceipt": return this.fetch("proxy", {
19553				action: "eth_getTransactionReceipt",
19554				txhash: req.hash
19555			});
19556			case "call": {
19557				if (req.blockTag !== "latest") throw new Error("EtherscanProvider does not support blockTag for call");
19558				const postData = this._getTransactionPostData(req.transaction);
19559				postData.module = "proxy";
19560				postData.action = "eth_call";
19561				try {
19562					return await this.fetch("proxy", postData, true);
19563				} catch (error) {
19564					return this._checkError(req, error, req.transaction);
19565				}
19566			}
19567			case "estimateGas": {
19568				const postData = this._getTransactionPostData(req.transaction);
19569				postData.module = "proxy";
19570				postData.action = "eth_estimateGas";
19571				try {
19572					return await this.fetch("proxy", postData, true);
19573				} catch (error) {
19574					return this._checkError(req, error, req.transaction);
19575				}
19576			}
19577		}
19578		return super._perform(req);
19579	}
19580	async getNetwork() {
19581		return this.network;
19582	}
19583	/**
19584	*  Resolves to the current price of ether.
19585	*
19586	*  This returns ``0`` on any network other than ``mainnet``.
19587	*/
19588	async getEtherPrice() {
19589		if (this.network.name !== "mainnet") return 0;
19590		return parseFloat((await this.fetch("stats", { action: "ethprice" })).ethusd);
19591	}
19592	/**
19593	*  Resolves to a [Contract]] for %%address%%, using the
19594	*  Etherscan API to retreive the Contract ABI.
19595	*/
19596	async getContract(_address) {
19597		let address = this._getAddress(_address);

19598		if (isPromise(address)) address = await address;
19599		try {
19600			const resp = await this.fetch("contract", {
19601				action: "getabi",
19602				address
19603			});
19604			const abi = JSON.parse(resp);
19605			return new Contract(address, abi, this);
19606		} catch (error) {
19607			return null;
19608		}
19609	}
19610	isCommunityResource() {
19611		return this.apiKey == null;
19612	}
19613};
19614//#endregion
19615//#region node_modules/ethers/lib.esm/providers/ws-browser.js
19616function getGlobal() {
19617	if (typeof self !== "undefined") return self;
19618	if (typeof window !== "undefined") return window;
19619	if (typeof global !== "undefined") return global;
19620	throw new Error("unable to locate global object");
19621}
19622var _WebSocket = getGlobal().WebSocket;
19623//#endregion
19624//#region node_modules/ethers/lib.esm/providers/provider-socket.js
19625/**
19626*  Generic long-lived socket provider.
19627*
19628*  Sub-classing notes
19629*  - a sub-class MUST call the `_start()` method once connected
19630*  - a sub-class MUST override the `_write(string)` method
19631*  - a sub-class MUST call `_processMessage(string)` for each message
19632*
19633*  @_subsection: api/providers/abstract-provider:Socket Providers  [about-socketProvider]
19634*/
19635/**
19636*  A **SocketSubscriber** uses a socket transport to handle events and
19637*  should use [[_emit]] to manage the events.
19638*/
19639var SocketSubscriber = class {
19640	#provider;
19641	#filter;
19642	/**
19643	*  The filter.
19644	*/
19645	get filter() {
19646		return JSON.parse(this.#filter);
19647	}
19648	#filterId;
19649	#paused;
19650	#emitPromise;
19651	/**
19652	*  Creates a new **SocketSubscriber** attached to %%provider%% listening
19653	*  to %%filter%%.
19654	*/
19655	constructor(provider, filter) {
19656		this.#provider = provider;
19657		this.#filter = JSON.stringify(filter);
19658		this.#filterId = null;
19659		this.#paused = null;
19660		this.#emitPromise = null;
19661	}
19662	start() {
19663		this.#filterId = this.#provider.send("eth_subscribe", this.filter).then((filterId) => {
19664			this.#provider._register(filterId, this);
19665			return filterId;
19666		});
19667	}
19668	stop() {
19669		this.#filterId.then((filterId) => {
19670			if (this.#provider.destroyed) return;
19671			this.#provider.send("eth_unsubscribe", [filterId]);
19672		});
19673		this.#filterId = null;
19674	}
19675	pause(dropWhilePaused) {
19676		assert(dropWhilePaused, "preserve logs while paused not supported by SocketSubscriber yet", "UNSUPPORTED_OPERATION", { operation: "pause(false)" });
19677		this.#paused = !!dropWhilePaused;
19678	}
19679	resume() {
19680		this.#paused = null;
19681	}
19682	/**
19683	*  @_ignore:
19684	*/
19685	_handleMessage(message) {
19686		if (this.#filterId == null) return;
19687		if (this.#paused === null) {
19688			let emitPromise = this.#emitPromise;
19689			if (emitPromise == null) emitPromise = this._emit(this.#provider, message);
19690			else emitPromise = emitPromise.then(async () => {
19691				await this._emit(this.#provider, message);
19692			});
19693			this.#emitPromise = emitPromise.then(() => {
19694				if (this.#emitPromise === emitPromise) this.#emitPromise = null;
19695			});
19696		}
19697	}
19698	/**
19699	*  Sub-classes **must** override this to emit the events on the
19700	*  provider.
19701	*/
19702	async _emit(provider, message) {
19703		throw new Error("sub-classes must implemente this; _emit");
19704	}
19705};
19706/**
19707*  A **SocketBlockSubscriber** listens for ``newHeads`` events and emits
19708*  ``"block"`` events.
19709*/
19710var SocketBlockSubscriber = class extends SocketSubscriber {
19711	/**
19712	*  @_ignore:
19713	*/
19714	constructor(provider) {
19715		super(provider, ["newHeads"]);
19716	}
19717	async _emit(provider, message) {
19718		provider.emit("block", parseInt(message.number));
19719	}
19720};
19721/**
19722*  A **SocketPendingSubscriber** listens for pending transacitons and emits
19723*  ``"pending"`` events.
19724*/
19725var SocketPendingSubscriber = class extends SocketSubscriber {
19726	/**
19727	*  @_ignore:
19728	*/
19729	constructor(provider) {
19730		super(provider, ["newPendingTransactions"]);
19731	}
19732	async _emit(provider, message) {
19733		provider.emit("pending", message);
19734	}
19735};
19736/**
19737*  A **SocketEventSubscriber** listens for event logs.
19738*/
19739var SocketEventSubscriber = class extends SocketSubscriber {
19740	#logFilter;
19741	/**
19742	*  The filter.
19743	*/
19744	get logFilter() {
19745		return JSON.parse(this.#logFilter);
19746	}
19747	/**
19748	*  @_ignore:
19749	*/
19750	constructor(provider, filter) {
19751		super(provider, ["logs", filter]);
19752		this.#logFilter = JSON.stringify(filter);
19753	}
19754	async _emit(provider, message) {
19755		provider.emit(this.logFilter, provider._wrapLog(message, provider._network));
19756	}
19757};
19758/**
19759*  A **SocketProvider** is backed by a long-lived connection over a
19760*  socket, which can subscribe and receive real-time messages over
19761*  its communication channel.
19762*/
19763var SocketProvider = class extends JsonRpcApiProvider {
19764	#callbacks;
19765	#subs;
19766	#pending;
19767	/**
19768	*  Creates a new **SocketProvider** connected to %%network%%.
19769	*
19770	*  If unspecified, the network will be discovered.
19771	*/
19772	constructor(network, _options) {
19773		const options = Object.assign({}, _options != null ? _options : {});
19774		assertArgument(options.batchMaxCount == null || options.batchMaxCount === 1, "sockets-based providers do not support batches", "options.batchMaxCount", _options);
19775		options.batchMaxCount = 1;
19776		if (options.staticNetwork == null) options.staticNetwork = true;
19777		super(network, options);
19778		this.#callbacks = /* @__PURE__ */ new Map();
19779		this.#subs = /* @__PURE__ */ new Map();
19780		this.#pending = /* @__PURE__ */ new Map();
19781	}
19782	_getSubscriber(sub) {
19783		switch (sub.type) {
19784			case "close": return new UnmanagedSubscriber("close");
19785			case "block": return new SocketBlockSubscriber(this);
19786			case "pending": return new SocketPendingSubscriber(this);

vendor: 6,468 bytes, lines 19787-19982

19787			case "event": return new SocketEventSubscriber(this, sub.filter);
19788			case "orphan": if (sub.filter.orphan === "drop-log") return new UnmanagedSubscriber("drop-log");
19789		}
19790		return super._getSubscriber(sub);
19791	}
19792	/**
19793	*  Register a new subscriber. This is used internalled by Subscribers
19794	*  and generally is unecessary unless extending capabilities.
19795	*/
19796	_register(filterId, subscriber) {
19797		this.#subs.set(filterId, subscriber);
19798		const pending = this.#pending.get(filterId);
19799		if (pending) {
19800			for (const message of pending) subscriber._handleMessage(message);
19801			this.#pending.delete(filterId);
19802		}
19803	}
19804	async _send(payload) {
19805		assertArgument(!Array.isArray(payload), "WebSocket does not support batch send", "payload", payload);
19806		const promise = new Promise((resolve, reject) => {
19807			this.#callbacks.set(payload.id, {
19808				payload,
19809				resolve,
19810				reject
19811			});
19812		});
19813		await this._waitUntilReady();
19814		await this._write(JSON.stringify(payload));
19815		return [await promise];
19816	}
19817	/**
19818	*  Sub-classes **must** call this with messages received over their
19819	*  transport to be processed and dispatched.
19820	*/
19821	async _processMessage(message) {
19822		const result = JSON.parse(message);
19823		if (result && typeof result === "object" && "id" in result) {
19824			const callback = this.#callbacks.get(result.id);
19825			if (callback == null) {
19826				this.emit("error", makeError("received result for unknown id", "UNKNOWN_ERROR", {
19827					reasonCode: "UNKNOWN_ID",
19828					result
19829				}));
19830				return;
19831			}
19832			this.#callbacks.delete(result.id);
19833			callback.resolve(result);
19834		} else if (result && result.method === "eth_subscription") {
19835			const filterId = result.params.subscription;
19836			const subscriber = this.#subs.get(filterId);
19837			if (subscriber) subscriber._handleMessage(result.params.result);
19838			else {
19839				let pending = this.#pending.get(filterId);
19840				if (pending == null) {
19841					pending = [];
19842					this.#pending.set(filterId, pending);
19843				}
19844				pending.push(result.params.result);
19845			}
19846		} else {
19847			this.emit("error", makeError("received unexpected message", "UNKNOWN_ERROR", {
19848				reasonCode: "UNEXPECTED_MESSAGE",
19849				result
19850			}));
19851			return;
19852		}
19853	}
19854	/**
19855	*  Sub-classes **must** override this to send %%message%% over their
19856	*  transport.
19857	*/
19858	async _write(message) {
19859		throw new Error("sub-classes must override this");
19860	}
19861};
19862//#endregion
19863//#region node_modules/ethers/lib.esm/providers/provider-websocket.js
19864/**
19865*  A JSON-RPC provider which is backed by a WebSocket.
19866*
19867*  WebSockets are often preferred because they retain a live connection
19868*  to a server, which permits more instant access to events.
19869*
19870*  However, this incurs higher server infrasturture costs, so additional
19871*  resources may be required to host your own WebSocket nodes and many
19872*  third-party services charge additional fees for WebSocket endpoints.
19873*/
19874var WebSocketProvider = class extends SocketProvider {
19875	#connect;
19876	#websocket;
19877	get websocket() {
19878		if (this.#websocket == null) throw new Error("websocket closed");
19879		return this.#websocket;
19880	}
19881	constructor(url, network, options) {
19882		super(network, options);
19883		if (typeof url === "string") {
19884			this.#connect = () => {
19885				return new _WebSocket(url);
19886			};
19887			this.#websocket = this.#connect();
19888		} else if (typeof url === "function") {
19889			this.#connect = url;
19890			this.#websocket = url();
19891		} else {
19892			this.#connect = null;
19893			this.#websocket = url;
19894		}
19895		this.websocket.onopen = async () => {
19896			try {
19897				await this._start();
19898				this.resume();
19899			} catch (error) {
19900				console.log("failed to start WebsocketProvider", error);
19901			}
19902		};
19903		this.websocket.onmessage = (message) => {
19904			this._processMessage(message.data);
19905		};
19906	}
19907	async _write(message) {
19908		this.websocket.send(message);
19909	}
19910	async destroy() {
19911		if (this.#websocket != null) {
19912			this.#websocket.close();
19913			this.#websocket = null;
19914		}
19915		super.destroy();
19916	}
19917};
19918//#endregion
19919//#region node_modules/ethers/lib.esm/providers/provider-infura.js
19920/**
19921*  [[link-infura]] provides a third-party service for connecting to
19922*  various blockchains over JSON-RPC.
19923*
19924*  **Supported Networks**
19925*
19926*  - Ethereum Mainnet (``mainnet``)
19927*  - Goerli Testnet (``goerli``)
19928*  - Sepolia Testnet (``sepolia``)
19929*  - Arbitrum (``arbitrum``)
19930*  - Arbitrum Goerli Testnet (``arbitrum-goerli``)
19931*  - Arbitrum Sepolia Testnet (``arbitrum-sepolia``)
19932*  - Base (``base``)
19933*  - Base Goerlia Testnet (``base-goerli``)
19934*  - Base Sepolia Testnet (``base-sepolia``)
19935*  - BNB Smart Chain Mainnet (``bnb``)
19936*  - BNB Smart Chain Testnet (``bnbt``)
19937*  - Linea (``linea``)
19938*  - Linea Goerli Testnet (``linea-goerli``)
19939*  - Linea Sepolia Testnet (``linea-sepolia``)
19940*  - Optimism (``optimism``)
19941*  - Optimism Goerli Testnet (``optimism-goerli``)
19942*  - Optimism Sepolia Testnet (``optimism-sepolia``)
19943*  - Polygon (``matic``)
19944*  - Polygon Amoy Testnet (``matic-amoy``)
19945*  - Polygon Mumbai Testnet (``matic-mumbai``)
19946*
19947*  @_subsection: api/providers/thirdparty:INFURA  [providers-infura]
19948*/
19949var defaultProjectId = "84842078b09946638c03157f83405213";
19950function getHost$2(name) {
19951	switch (name) {
19952		case "mainnet": return "mainnet.infura.io";
19953		case "goerli": return "goerli.infura.io";
19954		case "sepolia": return "sepolia.infura.io";
19955		case "arbitrum": return "arbitrum-mainnet.infura.io";
19956		case "arbitrum-goerli": return "arbitrum-goerli.infura.io";
19957		case "arbitrum-sepolia": return "arbitrum-sepolia.infura.io";
19958		case "base": return "base-mainnet.infura.io";
19959		case "base-goerlia":
19960		case "base-goerli": return "base-goerli.infura.io";
19961		case "base-sepolia": return "base-sepolia.infura.io";
19962		case "bnb": return "bsc-mainnet.infura.io";
19963		case "bnbt": return "bsc-testnet.infura.io";
19964		case "linea": return "linea-mainnet.infura.io";
19965		case "linea-goerli": return "linea-goerli.infura.io";
19966		case "linea-sepolia": return "linea-sepolia.infura.io";
19967		case "matic": return "polygon-mainnet.infura.io";
19968		case "matic-amoy": return "polygon-amoy.infura.io";
19969		case "matic-mumbai": return "polygon-mumbai.infura.io";
19970		case "optimism": return "optimism-mainnet.infura.io";
19971		case "optimism-goerli": return "optimism-goerli.infura.io";
19972		case "optimism-sepolia": return "optimism-sepolia.infura.io";
19973	}
19974	assertArgument(false, "unsupported network", "network", name);
19975}
19976/**
19977*  The **InfuraWebSocketProvider** connects to the [[link-infura]]
19978*  WebSocket end-points.
19979*
19980*  By default, a highly-throttled API key is used, which is
19981*  appropriate for quick prototypes and simple scripts. To
19982*  gain access to an increased rate-limit, it is highly

19983*  recommended to [sign up here](link-infura-signup).
19984*/
19985var InfuraWebSocketProvider = class extends WebSocketProvider {
19986	/**
19987	*  The Project ID for the INFURA connection.
19988	*/
19989	projectId;
19990	/**
19991	*  The Project Secret.
19992	*
19993	*  If null, no authenticated requests are made. This should not
19994	*  be used outside of private contexts.
19995	*/
19996	projectSecret;
19997	/**
19998	*  Creates a new **InfuraWebSocketProvider**.
19999	*/
20000	constructor(network, projectId) {
20001		const provider = new InfuraProvider(network, projectId);
20002		const req = provider._getConnection();
20003		assert(!req.credentials, "INFURA WebSocket project secrets unsupported", "UNSUPPORTED_OPERATION", { operation: "InfuraProvider.getWebSocketProvider()" });
20004		const url = req.url.replace(/^http/i, "ws").replace("/v3/", "/ws/v3/");
20005		super(url, provider._network);
20006		defineProperties(this, {
20007			projectId: provider.projectId,
20008			projectSecret: provider.projectSecret
20009		});
20010	}
20011	isCommunityResource() {
20012		return this.projectId === defaultProjectId;
20013	}
20014};
20015/**
20016*  The **InfuraProvider** connects to the [[link-infura]]
20017*  JSON-RPC end-points.
20018*
20019*  By default, a highly-throttled API key is used, which is
20020*  appropriate for quick prototypes and simple scripts. To
20021*  gain access to an increased rate-limit, it is highly
20022*  recommended to [sign up here](link-infura-signup).
20023*/
20024var InfuraProvider = class InfuraProvider extends JsonRpcProvider {
20025	/**
20026	*  The Project ID for the INFURA connection.
20027	*/
20028	projectId;
20029	/**
20030	*  The Project Secret.
20031	*
20032	*  If null, no authenticated requests are made. This should not
20033	*  be used outside of private contexts.
20034	*/
20035	projectSecret;
20036	/**
20037	*  Creates a new **InfuraProvider**.
20038	*/
20039	constructor(_network, projectId, projectSecret) {
20040		if (_network == null) _network = "mainnet";
20041		const network = Network.from(_network);
20042		if (projectId == null) projectId = defaultProjectId;
20043		if (projectSecret == null) projectSecret = null;
20044		const request = InfuraProvider.getRequest(network, projectId, projectSecret);
20045		super(request, network, { staticNetwork: network });
20046		defineProperties(this, {
20047			projectId,
20048			projectSecret
20049		});
20050	}
20051	_getProvider(chainId) {
20052		try {
20053			return new InfuraProvider(chainId, this.projectId, this.projectSecret);
20054		} catch (error) {}
20055		return super._getProvider(chainId);
20056	}
20057	isCommunityResource() {
20058		return this.projectId === defaultProjectId;
20059	}
20060	/**
20061	*  Creates a new **InfuraWebSocketProvider**.
20062	*/
20063	static getWebSocketProvider(network, projectId) {
20064		return new InfuraWebSocketProvider(network, projectId);
20065	}
20066	/**
20067	*  Returns a prepared request for connecting to %%network%%
20068	*  with %%projectId%% and %%projectSecret%%.
20069	*/
20070	static getRequest(network, projectId, projectSecret) {
20071		if (projectId == null) projectId = defaultProjectId;
20072		if (projectSecret == null) projectSecret = null;
20073		const request = new FetchRequest(`https:/\/${getHost$2(network.name)}/v3/${projectId}`);
20074		request.allowGzip = true;
20075		if (projectSecret) request.setCredentials("", projectSecret);
20076		if (projectId === defaultProjectId) request.retryFunc = async (request, response, attempt) => {
20077			showThrottleMessage("InfuraProvider");
20078			return true;
20079		};
20080		return request;
20081	}
20082};
20083//#endregion
20084//#region node_modules/ethers/lib.esm/providers/provider-quicknode.js
20085/**
20086*  [[link-quicknode]] provides a third-party service for connecting to
20087*  various blockchains over JSON-RPC.
20088*
20089*  **Supported Networks**
20090*
20091*  - Ethereum Mainnet (``mainnet``)
20092*  - Goerli Testnet (``goerli``)
20093*  - Sepolia Testnet (``sepolia``)
20094*  - Holesky Testnet (``holesky``)
20095*  - Arbitrum (``arbitrum``)
20096*  - Arbitrum Goerli Testnet (``arbitrum-goerli``)
20097*  - Arbitrum Sepolia Testnet (``arbitrum-sepolia``)
20098*  - Base Mainnet (``base``);
20099*  - Base Goerli Testnet (``base-goerli``);
20100*  - Base Sepolia Testnet (``base-sepolia``);
20101*  - BNB Smart Chain Mainnet (``bnb``)
20102*  - BNB Smart Chain Testnet (``bnbt``)
20103*  - Optimism (``optimism``)
20104*  - Optimism Goerli Testnet (``optimism-goerli``)
20105*  - Optimism Sepolia Testnet (``optimism-sepolia``)
20106*  - Polygon (``matic``)
20107*  - Polygon Mumbai Testnet (``matic-mumbai``)
20108*
20109*  @_subsection: api/providers/thirdparty:QuickNode  [providers-quicknode]
20110*/
20111var defaultToken = "919b412a057b5e9c9b6dce193c5a60242d6efadb";
20112function getHost$1(name) {
20113	switch (name) {
20114		case "mainnet": return "ethers.quiknode.pro";
20115		case "goerli": return "ethers.ethereum-goerli.quiknode.pro";
20116		case "sepolia": return "ethers.ethereum-sepolia.quiknode.pro";
20117		case "holesky": return "ethers.ethereum-holesky.quiknode.pro";
20118		case "arbitrum": return "ethers.arbitrum-mainnet.quiknode.pro";
20119		case "arbitrum-goerli": return "ethers.arbitrum-goerli.quiknode.pro";
20120		case "arbitrum-sepolia": return "ethers.arbitrum-sepolia.quiknode.pro";
20121		case "base": return "ethers.base-mainnet.quiknode.pro";
20122		case "base-goerli": return "ethers.base-goerli.quiknode.pro";
20123		case "base-spolia": return "ethers.base-sepolia.quiknode.pro";
20124		case "bnb": return "ethers.bsc.quiknode.pro";
20125		case "bnbt": return "ethers.bsc-testnet.quiknode.pro";
20126		case "matic": return "ethers.matic.quiknode.pro";
20127		case "matic-mumbai": return "ethers.matic-testnet.quiknode.pro";
20128		case "optimism": return "ethers.optimism.quiknode.pro";
20129		case "optimism-goerli": return "ethers.optimism-goerli.quiknode.pro";
20130		case "optimism-sepolia": return "ethers.optimism-sepolia.quiknode.pro";
20131		case "xdai": return "ethers.xdai.quiknode.pro";
20132	}
20133	assertArgument(false, "unsupported network", "network", name);
20134}
20135/**
20136*  The **QuickNodeProvider** connects to the [[link-quicknode]]
20137*  JSON-RPC end-points.
20138*
20139*  By default, a highly-throttled API token is used, which is
20140*  appropriate for quick prototypes and simple scripts. To
20141*  gain access to an increased rate-limit, it is highly

20142*  recommended to [sign up here](link-quicknode).
20143*/
20144var QuickNodeProvider = class QuickNodeProvider extends JsonRpcProvider {
20145	/**
20146	*  The API token.
20147	*/
20148	token;
20149	/**
20150	*  Creates a new **QuickNodeProvider**.
20151	*/
20152	constructor(_network, token) {
20153		if (_network == null) _network = "mainnet";
20154		const network = Network.from(_network);
20155		if (token == null) token = defaultToken;
20156		const request = QuickNodeProvider.getRequest(network, token);
20157		super(request, network, { staticNetwork: network });
20158		defineProperties(this, { token });
20159	}
20160	_getProvider(chainId) {
20161		try {
20162			return new QuickNodeProvider(chainId, this.token);
20163		} catch (error) {}
20164		return super._getProvider(chainId);
20165	}
20166	isCommunityResource() {
20167		return this.token === defaultToken;
20168	}
20169	/**
20170	*  Returns a new request prepared for %%network%% and the
20171	*  %%token%%.
20172	*/
20173	static getRequest(network, token) {
20174		if (token == null) token = defaultToken;
20175		const request = new FetchRequest(`https:/\/${getHost$1(network.name)}/${token}`);
20176		request.allowGzip = true;
20177		if (token === defaultToken) request.retryFunc = async (request, response, attempt) => {
20178			showThrottleMessage("QuickNodeProvider");
20179			return true;
20180		};
20181		return request;
20182	}
20183};
20184//#endregion
20185//#region node_modules/ethers/lib.esm/providers/provider-fallback.js
20186/**
20187*  A **FallbackProvider** provides resilience, security and performance
20188*  in a way that is customizable and configurable.
20189*
20190*  @_section: api/providers/fallback-provider:Fallback Provider [about-fallback-provider]
20191*/
20192var BN_1 = BigInt("1");
20193var BN_2 = BigInt("2");
20194function shuffle(array) {
20195	for (let i = array.length - 1; i > 0; i--) {
20196		const j = Math.floor(Math.random() * (i + 1));
20197		const tmp = array[i];
20198		array[i] = array[j];
20199		array[j] = tmp;
20200	}
20201}
20202function stall$2(duration) {
20203	return new Promise((resolve) => {
20204		setTimeout(resolve, duration);
20205	});
20206}
20207function getTime() {
20208	return (/* @__PURE__ */ new Date()).getTime();
20209}
20210function stringify(value) {
20211	return JSON.stringify(value, (key, value) => {
20212		if (typeof value === "bigint") return {
20213			type: "bigint",
20214			value: value.toString()
20215		};
20216		return value;
20217	});
20218}
20219var defaultConfig = {
20220	stallTimeout: 400,
20221	priority: 1,
20222	weight: 1
20223};
20224var defaultState = {
20225	blockNumber: -2,
20226	requests: 0,
20227	lateResponses: 0,
20228	errorResponses: 0,
20229	outOfSync: -1,
20230	unsupportedEvents: 0,
20231	rollingDuration: 0,
20232	score: 0,
20233	_network: null,
20234	_updateNumber: null,
20235	_totalTime: 0,
20236	_lastFatalError: null,
20237	_lastFatalErrorTimestamp: 0
20238};
20239async function waitForSync(config, blockNumber) {
20240	while (config.blockNumber < 0 || config.blockNumber < blockNumber) {
20241		if (!config._updateNumber) config._updateNumber = (async () => {
20242			try {
20243				const blockNumber = await config.provider.getBlockNumber();
20244				if (blockNumber > config.blockNumber) config.blockNumber = blockNumber;
20245			} catch (error) {
20246				config.blockNumber = -2;
20247				config._lastFatalError = error;
20248				config._lastFatalErrorTimestamp = getTime();
20249			}
20250			config._updateNumber = null;
20251		})();
20252		await config._updateNumber;
20253		config.outOfSync++;
20254		if (config._lastFatalError) break;
20255	}
20256}
20257function _normalize(value) {
20258	if (value == null) return "null";
20259	if (Array.isArray(value)) return "[" + value.map(_normalize).join(",") + "]";
20260	if (typeof value === "object" && typeof value.toJSON === "function") return _normalize(value.toJSON());
20261	switch (typeof value) {
20262		case "boolean":
20263		case "symbol": return value.toString();
20264		case "bigint":
20265		case "number": return BigInt(value).toString();
20266		case "string": return JSON.stringify(value);
20267		case "object": {
20268			const keys = Object.keys(value);
20269			keys.sort();
20270			return "{" + keys.map((k) => `${JSON.stringify(k)}:${_normalize(value[k])}`).join(",") + "}";
20271		}
20272	}
20273	console.log("Could not serialize", value);
20274	throw new Error("Hmm...");
20275}
20276function normalizeResult(method, value) {
20277	if ("error" in value) {
20278		const error = value.error;
20279		let tag;
20280		if (isError(error, "CALL_EXCEPTION")) tag = _normalize(Object.assign({}, error, {
20281			shortMessage: void 0,
20282			reason: void 0,
20283			info: void 0
20284		}));
20285		else tag = _normalize(error);
20286		return {
20287			tag,
20288			value: error
20289		};
20290	}
20291	const result = value.result;
20292	return {
20293		tag: _normalize(result),
20294		value: result
20295	};
20296}
20297function checkQuorum(quorum, results) {
20298	const tally = /* @__PURE__ */ new Map();
20299	for (const { value, tag, weight } of results) {
20300		const t = tally.get(tag) || {
20301			value,
20302			weight: 0
20303		};
20304		t.weight += weight;
20305		tally.set(tag, t);
20306	}
20307	let best = null;
20308	for (const r of tally.values()) if (r.weight >= quorum && (!best || r.weight > best.weight)) best = r;
20309	if (best) return best.value;
20310}
20311function getMedian(quorum, results) {
20312	let resultWeight = 0;
20313	const errorMap = /* @__PURE__ */ new Map();
20314	let bestError = null;
20315	const values = [];
20316	for (const { value, tag, weight } of results) if (value instanceof Error) {
20317		const e = errorMap.get(tag) || {
20318			value,
20319			weight: 0
20320		};
20321		e.weight += weight;
20322		errorMap.set(tag, e);
20323		if (bestError == null || e.weight > bestError.weight) bestError = e;
20324	} else {
20325		values.push(BigInt(value));
20326		resultWeight += weight;
20327	}
20328	if (resultWeight < quorum) {
20329		if (bestError && bestError.weight >= quorum) return bestError.value;
20330		return;
20331	}
20332	values.sort((a, b) => a < b ? -1 : b > a ? 1 : 0);
20333	const mid = Math.floor(values.length / 2);
20334	if (values.length % 2) return values[mid];
20335	return (values[mid - 1] + values[mid] + BN_1) / BN_2;
20336}
20337function getAnyResult(quorum, results) {
20338	const result = checkQuorum(quorum, results);
20339	if (result !== void 0) return result;
20340	for (const r of results) if (r.value) return r.value;
20341}
20342function getFuzzyMode(quorum, results) {
20343	if (quorum === 1) return getNumber(getMedian(quorum, results), "%internal");
20344	const tally = /* @__PURE__ */ new Map();
20345	const add = (result, weight) => {
20346		const t = tally.get(result) || {
20347			result,
20348			weight: 0
20349		};
20350		t.weight += weight;
20351		tally.set(result, t);
20352	};
20353	for (const { weight, value } of results) {
20354		const r = getNumber(value);
20355		add(r - 1, weight);
20356		add(r, weight);
20357		add(r + 1, weight);
20358	}
20359	let bestWeight = 0;
20360	let bestResult = void 0;
20361	for (const { weight, result } of tally.values()) if (weight >= quorum && (weight > bestWeight || bestResult != null && weight === bestWeight && result > bestResult)) {
20362		bestWeight = weight;
20363		bestResult = result;
20364	}
20365	return bestResult;
20366}
20367/**
20368*  A **FallbackProvider** manages several [[Providers]] providing
20369*  resilience by switching between slow or misbehaving nodes, security
20370*  by requiring multiple backends to aggree and performance by allowing
20371*  faster backends to respond earlier.
20372*
20373*/
20374var FallbackProvider = class extends AbstractProvider {
20375	/**
20376	*  The number of backends that must agree on a value before it is
20377	*  accpeted.
20378	*/
20379	quorum;
20380	/**
20381	*  @_ignore:
20382	*/
20383	eventQuorum;
20384	/**
20385	*  @_ignore:
20386	*/
20387	eventWorkers;
20388	#configs;

20389	#height;
20390	#initialSyncPromise;
20391	/**
20392	*  Creates a new **FallbackProvider** with %%providers%% connected to
20393	*  %%network%%.
20394	*
20395	*  If a [[Provider]] is included in %%providers%%, defaults are used
20396	*  for the configuration.
20397	*/
20398	constructor(providers, network, options) {
20399		super(network, options);
20400		this.#configs = providers.map((p) => {
20401			if (p instanceof AbstractProvider) return Object.assign({ provider: p }, defaultConfig, defaultState);
20402			else return Object.assign({}, defaultConfig, p, defaultState);
20403		});
20404		this.#height = -2;
20405		this.#initialSyncPromise = null;
20406		if (options && options.quorum != null) this.quorum = options.quorum;
20407		else this.quorum = Math.ceil(this.#configs.reduce((accum, config) => {
20408			accum += config.weight;
20409			return accum;
20410		}, 0) / 2);
20411		this.eventQuorum = 1;
20412		this.eventWorkers = 1;
20413		assertArgument(this.quorum <= this.#configs.reduce((a, c) => a + c.weight, 0), "quorum exceed provider weight", "quorum", this.quorum);
20414	}
20415	get providerConfigs() {
20416		return this.#configs.map((c) => {
20417			const result = Object.assign({}, c);
20418			for (const key in result) if (key[0] === "_") delete result[key];
20419			return result;
20420		});
20421	}
20422	async _detectNetwork() {
20423		return Network.from(getBigInt(await this._perform({ method: "chainId" })));
20424	}
20425	/**
20426	*  Transforms a %%req%% into the correct method call on %%provider%%.
20427	*/
20428	async _translatePerform(provider, req) {
20429		switch (req.method) {
20430			case "broadcastTransaction": return await provider.broadcastTransaction(req.signedTransaction);
20431			case "call": return await provider.call(Object.assign({}, req.transaction, { blockTag: req.blockTag }));
20432			case "chainId": return (await provider.getNetwork()).chainId;
20433			case "estimateGas": return await provider.estimateGas(req.transaction);
20434			case "getBalance": return await provider.getBalance(req.address, req.blockTag);
20435			case "getBlock": {
20436				const block = "blockHash" in req ? req.blockHash : req.blockTag;
20437				return await provider.getBlock(block, req.includeTransactions);
20438			}
20439			case "getBlockNumber": return await provider.getBlockNumber();
20440			case "getCode": return await provider.getCode(req.address, req.blockTag);
20441			case "getGasPrice": return (await provider.getFeeData()).gasPrice;
20442			case "getPriorityFee": return (await provider.getFeeData()).maxPriorityFeePerGas;
20443			case "getLogs": return await provider.getLogs(req.filter);
20444			case "getStorage": return await provider.getStorage(req.address, req.position, req.blockTag);
20445			case "getTransaction": return await provider.getTransaction(req.hash);
20446			case "getTransactionCount": return await provider.getTransactionCount(req.address, req.blockTag);
20447			case "getTransactionReceipt": return await provider.getTransactionReceipt(req.hash);
20448			case "getTransactionResult": return await provider.getTransactionResult(req.hash);
20449		}
20450	}
20451	#getNextConfig(running) {
20452		const configs = Array.from(running).map((r) => r.config);
20453		const allConfigs = this.#configs.slice();
20454		shuffle(allConfigs);
20455		allConfigs.sort((a, b) => a.priority - b.priority);
20456		for (const config of allConfigs) {
20457			if (config._lastFatalError) continue;
20458			if (configs.indexOf(config) === -1) return config;
20459		}
20460		return null;
20461	}
20462	#addRunner(running, req) {
20463		const config = this.#getNextConfig(running);
20464		if (config == null) return null;
20465		const runner = {
20466			config,
20467			result: null,
20468			didBump: false,
20469			perform: null,
20470			staller: null
20471		};
20472		const now = getTime();
20473		runner.perform = (async () => {
20474			try {
20475				config.requests++;
20476				const result = await this._translatePerform(config.provider, req);
20477				runner.result = { result };
20478			} catch (error) {
20479				config.errorResponses++;
20480				runner.result = { error };
20481			}
20482			const dt = getTime() - now;
20483			config._totalTime += dt;
20484			config.rollingDuration = .95 * config.rollingDuration + .05 * dt;
20485			runner.perform = null;
20486		})();
20487		runner.staller = (async () => {
20488			await stall$2(config.stallTimeout);
20489			runner.staller = null;
20490		})();
20491		running.add(runner);
20492		return runner;
20493	}
20494	async #initialSync() {
20495		let initialSync = this.#initialSyncPromise;
20496		if (!initialSync) {
20497			const promises = [];

20498			this.#configs.forEach((config) => {
20499				promises.push((async () => {
20500					await waitForSync(config, 0);
20501					if (!config._lastFatalError) config._network = await config.provider.getNetwork();
20502				})());
20503			});
20504			this.#initialSyncPromise = initialSync = (async () => {
20505				await Promise.all(promises);
20506				let chainId = null;
20507				for (const config of this.#configs) {
20508					if (config._lastFatalError) continue;
20509					const network = config._network;
20510					if (chainId == null) chainId = network.chainId;
20511					else if (network.chainId !== chainId) assert(false, "cannot mix providers on different networks", "UNSUPPORTED_OPERATION", { operation: "new FallbackProvider" });
20512				}
20513			})();
20514		}
20515		await initialSync;
20516	}
20517	async #checkQuorum(running, req) {
20518		const results = [];
20519		for (const runner of running) if (runner.result != null) {
20520			const { tag, value } = normalizeResult(req.method, runner.result);
20521			results.push({
20522				tag,
20523				value,
20524				weight: runner.config.weight
20525			});
20526		}
20527		if (results.reduce((a, r) => a + r.weight, 0) < this.quorum) return;
20528		switch (req.method) {
20529			case "getBlockNumber": {
20530				if (this.#height === -2) this.#height = Math.ceil(getNumber(getMedian(this.quorum, this.#configs.filter((c) => !c._lastFatalError).map((c) => ({
20531					value: c.blockNumber,
20532					tag: getNumber(c.blockNumber).toString(),
20533					weight: c.weight
20534				})))));
20535				const mode = getFuzzyMode(this.quorum, results);
20536				if (mode === void 0) return;
20537				if (mode > this.#height) this.#height = mode;
20538				return this.#height;
20539			}
20540			case "getGasPrice":
20541			case "getPriorityFee":
20542			case "estimateGas": return getMedian(this.quorum, results);
20543			case "getBlock":
20544				if ("blockTag" in req && req.blockTag === "pending") return getAnyResult(this.quorum, results);
20545				return checkQuorum(this.quorum, results);
20546			case "call":
20547			case "chainId":
20548			case "getBalance":
20549			case "getTransactionCount":
20550			case "getCode":
20551			case "getStorage":
20552			case "getTransaction":
20553			case "getTransactionReceipt":
20554			case "getLogs": return checkQuorum(this.quorum, results);
20555			case "broadcastTransaction": return getAnyResult(this.quorum, results);
20556		}
20557		assert(false, "unsupported method", "UNSUPPORTED_OPERATION", { operation: `_perform(${stringify(req.method)})` });
20558	}
20559	async #waitForQuorum(running, req) {
20560		if (running.size === 0) throw new Error("no runners?!");
20561		const interesting = [];
20562		let newRunners = 0;
20563		for (const runner of running) {
20564			if (runner.perform) interesting.push(runner.perform);
20565			if (runner.staller) {
20566				interesting.push(runner.staller);
20567				continue;
20568			}
20569			if (runner.didBump) continue;
20570			runner.didBump = true;
20571			newRunners++;
20572		}
20573		const value = await this.#checkQuorum(running, req);
20574		if (value !== void 0) {
20575			if (value instanceof Error) throw value;
20576			return value;
20577		}
20578		for (let i = 0; i < newRunners; i++) this.#addRunner(running, req);
20579		assert(interesting.length > 0, "quorum not met", "SERVER_ERROR", {
20580			request: "%sub-requests",
20581			info: {
20582				request: req,
20583				results: Array.from(running).map((r) => stringify(r.result))
20584			}
20585		});
20586		await Promise.race(interesting);
20587		return await this.#waitForQuorum(running, req);
20588	}
20589	async _perform(req) {
20590		if (req.method === "broadcastTransaction") {
20591			const results = this.#configs.map((c) => null);
20592			const broadcasts = this.#configs.map(async ({ provider, weight }, index) => {
20593				try {
20594					const result = await provider._perform(req);
20595					results[index] = Object.assign(normalizeResult(req.method, { result }), { weight });
20596				} catch (error) {
20597					results[index] = Object.assign(normalizeResult(req.method, { error }), { weight });
20598				}
20599			});
20600			while (true) {
20601				const done = results.filter((r) => r != null);
20602				for (const { value } of done) if (!(value instanceof Error)) return value;
20603				const result = checkQuorum(this.quorum, results.filter((r) => r != null));
20604				if (isError(result, "INSUFFICIENT_FUNDS")) throw result;
20605				const waiting = broadcasts.filter((b, i) => results[i] == null);
20606				if (waiting.length === 0) break;
20607				await Promise.race(waiting);
20608			}
20609			const result = getAnyResult(this.quorum, results);
20610			assert(result !== void 0, "problem multi-broadcasting", "SERVER_ERROR", {
20611				request: "%sub-requests",
20612				info: {
20613					request: req,
20614					results: results.map(stringify)
20615				}
20616			});
20617			if (result instanceof Error) throw result;
20618			return result;
20619		}
20620		await this.#initialSync();
20621		const running = /* @__PURE__ */ new Set();
20622		let inflightQuorum = 0;
20623		while (true) {
20624			const runner = this.#addRunner(running, req);
20625			if (runner == null) break;
20626			inflightQuorum += runner.config.weight;
20627			if (inflightQuorum >= this.quorum) break;
20628		}
20629		const result = await this.#waitForQuorum(running, req);
20630		for (const runner of running) if (runner.perform && runner.result == null) runner.config.lateResponses++;
20631		return result;
20632	}
20633	async destroy() {
20634		for (const { provider } of this.#configs) provider.destroy();
20635		super.destroy();
20636	}
20637};
20638//#endregion

20639//#region node_modules/ethers/lib.esm/providers/default-provider.js
20640function isWebSocketLike(value) {
20641	return value && typeof value.send === "function" && typeof value.close === "function";
20642}
20643var Testnets = "goerli kovan sepolia classicKotti optimism-goerli arbitrum-goerli matic-mumbai bnbt".split(" ");
20644/**
20645*  Returns a default provider for %%network%%.
20646*
20647*  If %%network%% is a [[WebSocketLike]] or string that begins with
20648*  ``"ws:"`` or ``"wss:"``, a [[WebSocketProvider]] is returned backed
20649*  by that WebSocket or URL.
20650*
20651*  If %%network%% is a string that begins with ``"HTTP:"`` or ``"HTTPS:"``,
20652*  a [[JsonRpcProvider]] is returned connected to that URL.
20653*
20654*  Otherwise, a default provider is created backed by well-known public
20655*  Web3 backends (such as [[link-infura]]) using community-provided API
20656*  keys.
20657*
20658*  The %%options%% allows specifying custom API keys per backend (setting
20659*  an API key to ``"-"`` will omit that provider) and ``options.exclusive``
20660*  can be set to either a backend name or and array of backend names, which
20661*  will whitelist **only** those backends.
20662*
20663*  Current backend strings supported are:
20664*  - ``"alchemy"``
20665*  - ``"ankr"``
20666*  - ``"cloudflare"``
20667*  - ``"chainstack"``
20668*  - ``"etherscan"``
20669*  - ``"infura"``
20670*  - ``"publicPolygon"``
20671*  - ``"quicknode"``
20672*
20673*  @example:
20674*    // Connect to a local Geth node
20675*    provider = getDefaultProvider("http://localhost:8545/");
20676*
20677*    // Connect to Ethereum mainnet with any current and future
20678*    // third-party services available
20679*    provider = getDefaultProvider("mainnet");
20680*
20681*    // Connect to Polygon, but only allow Etherscan and
20682*    // INFURA and use "MY_API_KEY" in calls to Etherscan.
20683*    provider = getDefaultProvider("matic", {
20684*      etherscan: "MY_API_KEY",
20685*      exclusive: [ "etherscan", "infura" ]
20686*    });
20687*/
20688function getDefaultProvider(network, options) {
20689	if (options == null) options = {};
20690	const allowService = (name) => {
20691		if (options[name] === "-") return false;
20692		if (typeof options.exclusive === "string") return name === options.exclusive;
20693		if (Array.isArray(options.exclusive)) return options.exclusive.indexOf(name) !== -1;
20694		return true;
20695	};
20696	if (typeof network === "string" && network.match(/^https?:/)) return new JsonRpcProvider(network);
20697	if (typeof network === "string" && network.match(/^wss?:/) || isWebSocketLike(network)) return new WebSocketProvider(network);
20698	let staticNetwork = null;
20699	try {
20700		staticNetwork = Network.from(network);
20701	} catch (error) {}
20702	const providers = [];
20703	if (allowService("publicPolygon") && staticNetwork) {
20704		if (staticNetwork.name === "matic") providers.push(new JsonRpcProvider("https://polygon-rpc.com/", staticNetwork, { staticNetwork }));
20705		else if (staticNetwork.name === "matic-amoy") providers.push(new JsonRpcProvider("https://rpc-amoy.polygon.technology/", staticNetwork, { staticNetwork }));
20706	}
20707	if (allowService("alchemy")) try {
20708		providers.push(new AlchemyProvider(network, options.alchemy));
20709	} catch (error) {}
20710	if (allowService("ankr") && options.ankr != null) try {
20711		providers.push(new AnkrProvider(network, options.ankr));
20712	} catch (error) {}
20713	if (allowService("chainstack")) try {
20714		providers.push(new ChainstackProvider(network, options.chainstack));
20715	} catch (error) {}
20716	if (allowService("cloudflare")) try {
20717		providers.push(new CloudflareProvider(network));
20718	} catch (error) {}
20719	if (allowService("etherscan")) try {
20720		providers.push(new EtherscanProvider(network, options.etherscan));
20721	} catch (error) {}
20722	if (allowService("infura")) try {
20723		let projectId = options.infura;
20724		let projectSecret = void 0;
20725		if (typeof projectId === "object") {
20726			projectSecret = projectId.projectSecret;
20727			projectId = projectId.projectId;
20728		}
20729		providers.push(new InfuraProvider(network, projectId, projectSecret));
20730	} catch (error) {}
20731	if (allowService("quicknode")) try {
20732		let token = options.quicknode;
20733		providers.push(new QuickNodeProvider(network, token));
20734	} catch (error) {}
20735	assert(providers.length, "unsupported default network", "UNSUPPORTED_OPERATION", { operation: "getDefaultProvider" });
20736	if (providers.length === 1) return providers[0];
20737	let quorum = Math.floor(providers.length / 2);
20738	if (quorum > 2) quorum = 2;
20739	if (staticNetwork && Testnets.indexOf(staticNetwork.name) !== -1) quorum = 1;
20740	if (options && options.quorum) quorum = options.quorum;
20741	return new FallbackProvider(providers, void 0, { quorum });
20742}
20743//#endregion
20744//#region node_modules/ethers/lib.esm/providers/signer-noncemanager.js
20745/**
20746*  A **NonceManager** wraps another [[Signer]] and automatically manages
20747*  the nonce, ensuring serialized and sequential nonces are used during
20748*  transaction.
20749*/
20750var NonceManager = class NonceManager extends AbstractSigner {
20751	/**
20752	*  The Signer being managed.
20753	*/
20754	signer;
20755	#noncePromise;
20756	#delta;
20757	/**
20758	*  Creates a new **NonceManager** to manage %%signer%%.
20759	*/
20760	constructor(signer) {
20761		super(signer.provider);
20762		defineProperties(this, { signer });
20763		this.#noncePromise = null;
20764		this.#delta = 0;
20765	}
20766	async getAddress() {
20767		return this.signer.getAddress();
20768	}
20769	connect(provider) {
20770		return new NonceManager(this.signer.connect(provider));
20771	}
20772	async getNonce(blockTag) {
20773		if (blockTag === "pending") {
20774			if (this.#noncePromise == null) this.#noncePromise = super.getNonce("pending");
20775			const delta = this.#delta;
20776			return await this.#noncePromise + delta;
20777		}
20778		return super.getNonce(blockTag);
20779	}
20780	/**
20781	*  Manually increment the nonce. This may be useful when managng
20782	*  offline transactions.
20783	*/
20784	increment() {
20785		this.#delta++;
20786	}
20787	/**
20788	*  Resets the nonce, causing the **NonceManager** to reload the current
20789	*  nonce from the blockchain on the next transaction.
20790	*/
20791	reset() {
20792		this.#delta = 0;
20793		this.#noncePromise = null;
20794	}
20795	async sendTransaction(tx) {
20796		const noncePromise = this.getNonce("pending");
20797		this.increment();
20798		tx = await this.signer.populateTransaction(tx);
20799		tx.nonce = await noncePromise;
20800		return await this.signer.sendTransaction(tx);
20801	}
20802	signTransaction(tx) {
20803		return this.signer.signTransaction(tx);
20804	}
20805	signMessage(message) {

20806		return this.signer.signMessage(message);
20807	}
20808	signTypedData(domain, types, value) {
20809		return this.signer.signTypedData(domain, types, value);
20810	}
20811};
20812//#endregion
20813//#region node_modules/ethers/lib.esm/providers/provider-browser.js
20814/**
20815*  A **BrowserProvider** is intended to wrap an injected provider which
20816*  adheres to the [[link-eip-1193]] standard, which most (if not all)
20817*  currently do.
20818*/
20819var BrowserProvider = class BrowserProvider extends JsonRpcApiPollingProvider {
20820	#request;
20821	#providerInfo;
20822	/**
20823	*  Connect to the %%ethereum%% provider, optionally forcing the
20824	*  %%network%%.
20825	*/
20826	constructor(ethereum, network, _options) {
20827		const options = Object.assign({}, _options != null ? _options : {}, { batchMaxCount: 1 });
20828		assertArgument(ethereum && ethereum.request, "invalid EIP-1193 provider", "ethereum", ethereum);
20829		super(network, options);
20830		this.#providerInfo = null;
20831		if (_options && _options.providerInfo) this.#providerInfo = _options.providerInfo;
20832		this.#request = async (method, params) => {
20833			const payload = {
20834				method,
20835				params
20836			};
20837			this.emit("debug", {
20838				action: "sendEip1193Request",
20839				payload
20840			});
20841			try {
20842				const result = await ethereum.request(payload);
20843				this.emit("debug", {
20844					action: "receiveEip1193Result",
20845					result
20846				});
20847				return result;
20848			} catch (e) {
20849				const error = new Error(e.message);
20850				error.code = e.code;
20851				error.data = e.data;
20852				error.payload = payload;
20853				this.emit("debug", {
20854					action: "receiveEip1193Error",
20855					error
20856				});
20857				throw error;
20858			}
20859		};
20860	}
20861	get providerInfo() {
20862		return this.#providerInfo;
20863	}
20864	async send(method, params) {
20865		await this._start();
20866		return await super.send(method, params);
20867	}
20868	async _send(payload) {
20869		assertArgument(!Array.isArray(payload), "EIP-1193 does not support batch request", "payload", payload);
20870		try {
20871			const result = await this.#request(payload.method, payload.params || []);
20872			return [{
20873				id: payload.id,
20874				result
20875			}];
20876		} catch (e) {
20877			return [{
20878				id: payload.id,
20879				error: {
20880					code: e.code,
20881					data: e.data,
20882					message: e.message
20883				}
20884			}];
20885		}
20886	}
20887	getRpcError(payload, error) {
20888		error = JSON.parse(JSON.stringify(error));
20889		switch (error.error.code || -1) {
20890			case 4001:
20891				error.error.message = `ethers-user-denied: ${error.error.message}`;
20892				break;
20893			case 4200: error.error.message = `ethers-unsupported: ${error.error.message}`;
20894		}
20895		return super.getRpcError(payload, error);
20896	}
20897	/**
20898	*  Resolves to ``true`` if the provider manages the %%address%%.
20899	*/
20900	async hasSigner(address) {
20901		if (address == null) address = 0;
20902		const accounts = await this.send("eth_accounts", []);
20903		if (typeof address === "number") return accounts.length > address;
20904		address = address.toLowerCase();
20905		return accounts.filter((a) => a.toLowerCase() === address).length !== 0;
20906	}
20907	async getSigner(address) {
20908		if (address == null) address = 0;
20909		if (!await this.hasSigner(address)) try {
20910			await this.#request("eth_requestAccounts", []);
20911		} catch (error) {
20912			const payload = error.payload;
20913			throw this.getRpcError(payload, {
20914				id: payload.id,
20915				error
20916			});
20917		}
20918		return await super.getSigner(address);
20919	}
20920	/**
20921	*  Discover and connect to a Provider in the Browser using the
20922	*  [[link-eip-6963]] discovery mechanism. If no providers are
20923	*  present, ``null`` is resolved.
20924	*/
20925	static async discover(options) {
20926		if (options == null) options = {};
20927		if (options.provider) return new BrowserProvider(options.provider);
20928		const context = options.window ? options.window : typeof window !== "undefined" ? window : null;
20929		if (context == null) return null;
20930		const anyProvider = options.anyProvider;
20931		if (anyProvider && context.ethereum) return new BrowserProvider(context.ethereum);
20932		if (!("addEventListener" in context && "dispatchEvent" in context && "removeEventListener" in context)) return null;
20933		const timeout = options.timeout ? options.timeout : 300;
20934		if (timeout === 0) return null;
20935		return await new Promise((resolve, reject) => {
20936			let found = [];
20937			const addProvider = (event) => {
20938				found.push(event.detail);
20939				if (anyProvider) finalize();
20940			};
20941			const finalize = () => {
20942				clearTimeout(timer);
20943				if (found.length) {
20944					if (options && options.filter) {
20945						const filtered = options.filter(found.map((i) => Object.assign({}, i.info)));
20946						if (filtered == null) resolve(null);
20947						else if (filtered instanceof BrowserProvider) resolve(filtered);
20948						else {
20949							let match = null;
20950							if (filtered.uuid) match = found.filter((f) =>

20950 filtered.uuid === f.info.uuid)[0];
20951							if (match) {
20952								const { provider, info } = match;
20953								resolve(new BrowserProvider(provider, void 0, { providerInfo: info }));
20954							} else reject(makeError("filter returned unknown info", "UNSUPPORTED_OPERATION", { value: filtered }));
20955						}
20956					} else {
20957						const { provider, info } = found[0];
20958						resolve(new BrowserProvider(provider, void 0, { providerInfo: info }));
20959					}
20960				} else resolve(null);
20961				context.removeEventListener("eip6963:announceProvider", addProvider);
20962			};
20963			const timer = setTimeout(() => {
20964				finalize();
20965			}, timeout);
20966			context.addEventListener("eip6963:announceProvider", addProvider);
20967			context.dispatchEvent(new Event("eip6963:requestProvider"));
20968		});
20969	}
20970};
20971//#endregion
20972//#region node_modules/ethers/lib.esm/providers/provider-blockscout.js
20973/**
20974*  [[link-blockscout]] provides a third-party service for connecting to
20975*  various blockchains over JSON-RPC.
20976*
20977*  **Supported Networks**
20978*
20979*  - Ethereum Mainnet (``mainnet``)
20980*  - Sepolia Testnet (``sepolia``)
20981*  - Holesky Testnet (``holesky``)
20982*  - Ethereum Classic (``classic``)
20983*  - Arbitrum (``arbitrum``)
20984*  - Base (``base``)
20985*  - Base Sepolia Testnet (``base-sepolia``)
20986*  - Gnosis (``xdai``)
20987*  - Optimism (``optimism``)
20988*  - Optimism Sepolia Testnet (``optimism-sepolia``)
20989*  - Polygon (``matic``)
20990*
20991*  @_subsection: api/providers/thirdparty:Blockscout  [providers-blockscout]
20992*/
20993function getUrl(name) {
20994	switch (name) {
20995		case "mainnet": return "https://eth.blockscout.com/api/eth-rpc";
20996		case "sepolia": return "https://eth-sepolia.blockscout.com/api/eth-rpc";
20997		case "holesky": return "https://eth-holesky.blockscout.com/api/eth-rpc";
20998		case "classic": return "https://etc.blockscout.com/api/eth-rpc";
20999		case "arbitrum": return "https://arbitrum.blockscout.com/api/eth-rpc";
21000		case "base": return "https://base.blockscout.com/api/eth-rpc";
21001		case "base-sepolia": return "https://base-sepolia.blockscout.com/api/eth-rpc";
21002		case "matic": return "https://polygon.blockscout.com/api/eth-rpc";
21003		case "optimism": return "https://optimism.blockscout.com/api/eth-rpc";
21004		case "optimism-sepolia": return "https://optimism-sepolia.blockscout.com/api/eth-rpc";
21005		case "xdai": return "https://gnosis.blockscout.com/api/eth-rpc";
21006	}
21007	assertArgument(false, "unsupported network", "network", name);
21008}
21009var defaultApiKey = "proapi_gwcAAagyQKJ4r2KrAATyyCshiyUEpWfr2x7aKDOWFc56ZY8mBFcT9KZuP5Ce2jIfr_kHzUm";
21010/**
21011*  The **BlockscoutProvider** connects to the [[link-blockscout]]
21012*  JSON-RPC end-points.
21013*
21014*  By default, a highly-throttled API key is used, which is
21015*  appropriate for quick prototypes and simple scripts. To
21016*  gain access to an increased rate-limit, it is highly
21017*  recommended to [sign up here](link-blockscout-signup).
21018*/
21019var BlockscoutProvider = class BlockscoutProvider extends JsonRpcProvider {
21020	/**
21021	*  The API key.
21022	*/
21023	apiKey;
21024	/**
21025	*  Creates a new **BlockscoutProvider**.
21026	*/
21027	constructor(_network, apiKey) {
21028		if (_network == null) _network = "mainnet";
21029		const network = Network.from(_network);
21030		if (apiKey == null) apiKey = defaultApiKey;
21031		const request = BlockscoutProvider.getRequest(network);
21032		super(request, network, { staticNetwork: network });
21033		defineProperties(this, { apiKey });
21034	}
21035	_getProvider(chainId) {
21036		try {
21037			return new BlockscoutProvider(chainId, this.apiKey);
21038		} catch (error) {}
21039		return super._getProvider(chainId);
21040	}
21041	isCommunityResource() {
21042		return this.apiKey === null;
21043	}
21044	getRpcRequest(req) {
21045		const resp = super.getRpcRequest(req);
21046		if (resp && resp.method === "eth_estimateGas" && resp.args.length == 1) {
21047			resp.args = resp.args.slice();
21048			resp.args.push("latest");
21049		}
21050		return resp;
21051	}
21052	getRpcError(payload, _error) {
21053		const error = _error ? _error.error : null;
21054		if (error && error.code === -32015 && !isHexString(error.data || "", true)) {
21055			const panicCodes = {
21056				"assert(false)": "01",
21057				"arithmetic underflow or overflow": "11",
21058				"division or modulo by zero": "12",
21059				"out-of-bounds array access; popping on an empty array": "31",
21060				"out-of-bounds access of an array or bytesN": "32"
21061			};
21062			let panicCode = "";
21063			if (error.message === "VM execution error.") panicCode = panicCodes[error.data] || "";
21064			else if (panicCodes[error.message || ""]) panicCode = panicCodes[error.message || ""];
21065			if (panicCode) {
21066				error.message += ` (reverted: ${error.data})`;
21067				error.data = "0x4e487b7100000000000000000000000000000000000000000000000000000000000000" + panicCode;
21068			}
21069		} else if (error && error.code === -32e3) {
21070			if (error.message === "wrong transaction nonce") error.message += " 

21070(nonce too low)";
21071		}
21072		return super.getRpcError(payload, _error);
21073	}
21074	/**
21075	*  Returns a prepared request for connecting to %%network%%
21076	*  with %%apiKey%%.
21077	*/
21078	static getRequest(network) {
21079		const request = new FetchRequest(getUrl(network.name));
21080		request.allowGzip = true;
21081		return request;
21082	}
21083};
21084//#endregion
21085//#region node_modules/ethers/lib.esm/providers/provider-pocket.js
21086/**
21087*  [[link-pocket]] provides a third-party service for connecting to
21088*  various blockchains over JSON-RPC.
21089*
21090*  **Supported Networks**
21091*
21092*  - Ethereum Mainnet (``mainnet``)
21093*  - Goerli Testnet (``goerli``)
21094*  - Polygon (``matic``)
21095*  - Arbitrum (``arbitrum``)
21096*
21097*  @_subsection: api/providers/thirdparty:Pocket  [providers-pocket]
21098*/
21099var defaultApplicationId = "62e1ad51b37b8e00394bda3b";
21100function getHost(name) {
21101	switch (name) {
21102		case "mainnet": return "eth-mainnet.gateway.pokt.network";
21103		case "goerli": return "eth-goerli.gateway.pokt.network";
21104		case "matic": return "poly-mainnet.gateway.pokt.network";
21105		case "matic-mumbai": return "polygon-mumbai-rpc.gateway.pokt.network";
21106	}
21107	assertArgument(false, "unsupported network", "network", name);
21108}
21109/**
21110*  The **PocketProvider** connects to the [[link-pocket]]
21111*  JSON-RPC end-points.
21112*
21113*  By default, a highly-throttled API key is used, which is
21114*  appropriate for quick prototypes and simple scripts. To
21115*  gain access to an increased rate-limit, it is highly
21116*  recommended to [sign up here](link-pocket-signup).
21117*/
21118var PocketProvider = class PocketProvider extends JsonRpcProvider {
21119	/**
21120	*  The Application ID for the Pocket connection.
21121	*/
21122	applicationId;
21123	/**
21124	*  The Application Secret for making authenticated requests
21125	*  to the Pocket connection.
21126	*/
21127	applicationSecret;
21128	/**
21129	*  Create a new **PocketProvider**.
21130	*
21131	*  By default connecting to ``mainnet`` with a highly throttled
21132	*  API key.
21133	*/
21134	constructor(_network, applicationId, applicationSecret) {
21135		if (_network == null) _network = "mainnet";
21136		const network = Network.from(_network);
21137		if (applicationId == null) applicationId = defaultApplicationId;
21138		if (applicationSecret == null) applicationSecret = null;
21139		const options = { staticNetwork: network };
21140		const request = PocketProvider.getRequest(network, applicationId, applicationSecret);
21141		super(request, network, options);
21142		defineProperties(this, {
21143			applicationId,
21144			applicationSecret
21145		});
21146	}
21147	_getProvider(chainId) {
21148		try {
21149			return new PocketProvider(chainId, this.applicationId, this.applicationSecret);
21150		} catch (error) {}
21151		return super._getProvider(chainId);
21152	}
21153	/**
21154	*  Returns a prepared request for connecting to %%network%% with
21155	*  %%applicationId%%.
21156	*/
21157	static getRequest(network, applicationId, applicationSecret) {
21158		if (applicationId == null) applicationId = defaultApplicationId;
21159		const request = new FetchRequest(`https:/\/${getHost(network.name)}/v1/lb/${applicationId}`);
21160		request.allowGzip = true;
21161		if (applicationSecret) request.setCredentials("", applicationSecret);
21162		if (applicationId === defaultApplicationId) request.retryFunc = async (request, response, attempt) => {
21163			showThrottleMessage("PocketProvider");
21164			return true;
21165		};
21166		return request;
21167	}
21168	isCommunityResource() {
21169		return this.applicationId === defaultApplicationId;
21170	}
21171};
21172//#endregion
21173//#region node_modules/ethers/lib.esm/providers/provider-ipcsocket-browser.js
21174var IpcSocketProvider = void 0;
21175//#endregion
21176//#region node_modules/ethers/lib.esm/wallet/base-wallet.js
21177/**
21178*  The **BaseWallet** is a stream-lined implementation of a
21179*  [[Signer]] that operates with a private key.
21180*
21181*  It is preferred to use the [[Wallet]] class, as it offers
21182*  additional functionality and simplifies loading a variety
21183*  of JSON formats, Mnemonic Phrases, etc.
21184*
21185*  This class may be of use for those attempting to implement
21186*  a minimal Signer.
21187*/
21188var BaseWallet = class BaseWallet extends AbstractSigner {
21189	/**
21190	*  The wallet address.
21191	*/
21192	address;
21193	#signingKey;
21194	/**
21195	*  Creates a new BaseWallet for %%privateKey%%, optionally
21196	*  connected to %%provider%%.
21197	*
21198	*  If %%provider%% is not specified, only offline methods can
21199	*  be used.
21200	*/
21201	constructor(privateKey, provider) {
21202		super(provider);
21203		assertArgument(privateKey && typeof privateKey.sign === "function", "invalid private key", "privateKey", "[ REDACTED ]");
21204		this.#signingKey = privateKey;
21205		const address = computeAddress(this.signingKey.publicKey);
21206		defineProperties(this, { address });
21207	}
21208	/**
21209	*  The [[SigningKey]] used for signing payloads.
21210	*/
21211	get signingKey() {
21212		return this.#signingKey;
21213	}
21214	/**
21215	*  The private key for this wallet.
21216	*/
21217	get privateKey() {
21218		return this.signingKey.privateKey;
21219	}
21220	async getAddress() {
21221		return this.address;
21222	}
21223	connect(provider) {
21224		return new BaseWallet(this.#signingKey, provider);
21225	}
21226	async signTransaction(tx) {
21227		tx = copyRequest(tx);
21228		const { to, from } = await resolveProperties({
21229			to: tx.to ? resolveAddress(tx.to, this) : void 0,
21230			from: tx.from ? resolveAddress(tx.from, this) : void 0
21231		});
21232		if (to != null) tx.to = to;
21233		if (from != null) tx.from = from;
21234		if (tx.from != null) {
21235			assertArgument(getAddress(tx.from) === this.address, "transaction from address mismatch", "tx.from", tx.from);
21236			delete tx.from;
21237		}
21238		const btx = Transaction.from(tx);
21239		btx.signature = this.signingKey.sign(btx.unsignedHash);
21240		return btx.serialized;
21241	}
21242	async signMessage(message) {
21243		return this.signMessageSync(message);
21244	}
21245	/**
21246	*  Returns the signature for %%message%% signed with this wallet.
21247	*/
21248	signMessageSync(message) {
21249		return this.signingKey.sign(hashMessage(message)).serialized;
21250	}
21251	/**
21252	*  Returns the Authorization for %%auth%%.
21253	*/
21254	authorizeSync(auth) {
21255		assertArgument(typeof auth.address === "string", "invalid address for authorizeSync", "auth.address", auth);
21256		const signature = this.signingKey.sign(hashAuthorization(auth));
21257		return Object.assign({}, {
21258			address: getAddress(auth.address),
21259			nonce: getBigInt(auth.nonce || 0),
21260			chainId: getBigInt(auth.chainId || 0)
21261		}, { signature });
21262	}
21263	/**
21264	*  Resolves to the Authorization for %%auth%%.
21265	*/
21266	async authorize(auth) {
21267		auth = Object.assign({}, auth, { address: await resolveAddress(auth.address, this) });
21268		return this.authorizeSync(await this.populateAuthorization(auth));
21269	}
21270	async signTypedData(domain, types, value) {
21271		const populated = await TypedDataEncoder.resolveNames(domain, types, value, async (name) => {
21272			assert(this.provider != null, "cannot resolve ENS names without a provider", "UNSUPPORTED_OPERATION", {
21273				operation: "resolveName",
21274				info: { name }
21275			});
21276			const address = await this.provider.resolveName(name);
21277			assert(address != null, "unconfigured ENS name", "UNCONFIGURED_NAME", { value: name });
21278			return address;
21279		});
21280		return this.signingKey.sign(TypedDataEncoder.hash(populated.domain, types, populated.value)).serialized;
21281	}
21282};
21283//#endregion
21284//#region node_modules/ethers/lib.esm/wordlists/decode-owl.js
21285var subsChrs = " !#$%&'()*+,-./<=>?@[]^_`{|}~";
21286var Word = /^[a-z]*$/i;
21287function unfold(words, sep) {
21288	let initial = 97;
21289	return words.reduce((accum, word) => {
21290		if (word === sep) initial++;
21291		else if (word.match(Word)) accum.push(String.fromCharCode(initial) + word);
21292		else {
21293			initial = 97;
21294			accum.push(word);
21295		}
21296		return accum;
21297	}, []);
21298}
21299/**
21300*  @_ignore
21301*/
21302function decode(data, subs) {
21303	for (let i = 28; i >= 0;

21303 i--) data = data.split(subsChrs[i]).join(subs.substring(2 * i, 2 * i + 2));
21304	const clumps = [];
21305	const leftover = data.replace(/(:|([0-9])|([A-Z][a-z]*))/g, (all, item, semi, word) => {
21306		if (semi) for (let i = parseInt(semi); i >= 0; i--) clumps.push(";");
21307		else clumps.push(item.toLowerCase());
21308		return "";
21309	});
21310	/* c8 ignore start */
21311	if (leftover) throw new Error(`leftovers: ${JSON.stringify(leftover)}`);
21312	/* c8 ignore stop */
21313	return unfold(unfold(clumps, ";"), ":");
21314}
21315/**
21316*  @_ignore
21317*/
21318function decodeOwl(data) {
21319	assertArgument(data[0] === "0", "unsupported auwl data", "data", data);
21320	return decode(data.substring(59), data.substring(1, 59));
21321}
21322//#endregion
21323//#region node_modules/ethers/lib.esm/wordlists/wordlist.js
21324/**
21325*  A Wordlist represents a collection of language-specific
21326*  words used to encode and devoce [[link-bip-39]] encoded data
21327*  by mapping words to 11-bit values and vice versa.
21328*/
21329var Wordlist = class {
21330	locale;
21331	/**
21332	*  Creates a new Wordlist instance.
21333	*
21334	*  Sub-classes MUST call this if they provide their own constructor,
21335	*  passing in the locale string of the language.
21336	*
21337	*  Generally there is no need to create instances of a Wordlist,
21338	*  since each language-specific Wordlist creates an instance and
21339	*  there is no state kept internally, so they are safe to share.
21340	*/
21341	constructor(locale) {
21342		defineProperties(this, { locale });
21343	}
21344	/**
21345	*  Sub-classes may override this to provide a language-specific
21346	*  method for spliting %%phrase%% into individual words.
21347	*
21348	*  By default, %%phrase%% is split using any sequences of
21349	*  white-space as defined by regular expressions (i.e. ``/\s+/``).
21350	*/
21351	split(phrase) {
21352		return phrase.toLowerCase().split(/\s+/g);
21353	}
21354	/**
21355	*  Sub-classes may override this to provider a language-specific
21356	*  method for joining %%words%% into a phrase.
21357	*
21358	*  By default, %%words%% are joined by a single space.
21359	*/
21360	join(words) {
21361		return words.join(" ");
21362	}
21363};
21364//#endregion
21365//#region node_modules/ethers/lib.esm/wordlists/wordlist-owl.js
21366/**
21367*  An OWL format Wordlist is an encoding method that exploits
21368*  the general locality of alphabetically sorted words to
21369*  achieve a simple but effective means of compression.
21370*
21371*  This class is generally not useful to most developers as
21372*  it is used mainly internally to keep Wordlists for languages
21373*  based on ASCII-7 small.
21374*
21375*  If necessary, there are tools within the ``generation/`` folder
21376*  to create the necessary data.
21377*/
21378var WordlistOwl = class extends Wordlist {
21379	#data;
21380	#checksum;
21381	/**
21382	*  Creates a new Wordlist for %%locale%% using the OWL %%data%%
21383	*  and validated against the %%checksum%%.
21384	*/
21385	constructor(locale, data, checksum) {
21386		super(locale);
21387		this.#data = data;
21388		this.#checksum = checksum;
21389		this.#words = null;
21390	}
21391	/**
21392	*  The OWL-encoded data.
21393	*/
21394	get _data() {
21395		return this.#data;
21396	}
21397	/**
21398	*  Decode all the words for the wordlist.
21399	*/
21400	_decodeWords() {
21401		return decodeOwl(this.#data);
21402	}
21403	#words;
21404	#loadWords() {
21405		if (this.#words == null) {
21406			const words = this._decodeWords();
21407			/* c8 ignore start */
21408			if (id(words.join("\n") + "\n") !== this.#checksum) throw new Error(`BIP39 Wordlist for ${this.locale} FAILED`);
21409			/* c8 ignore stop */
21410			this.#words = words;
21411		}
21412		return this.#words;
21413	}
21414	getWord(index) {
21415		const words = this.#loadWords();
21416		assertArgument(index >= 0 && index < words.length, `invalid word index: ${index}`, "index", index);
21417		return words[index];
21418	}
21419	getWordIndex(word) {
21420		return this.#loadWords().indexOf(word);
21421	}
21422};
21423//#endregion
21424//#region node_modules/ethers/lib.esm/wordlists/lang-en.js
21425var words = "0erleonalorenseinceregesticitStanvetearctssi#ch2Athck&tneLl0And#Il.yLeOutO=S|S%b/ra@SurdU'0Ce[Cid|CountCu'Hie=IdOu,-Qui*Ro[TT]T%T*[Tu$0AptDD-tD*[Ju,M.UltV<)Vi)0Rob-0FairF%dRaid0A(EEntRee0Ead0MRRp%tS!_rmBumCoholErtI&LLeyLowMo,O}PhaReadySoT Ways0A>urAz(gOngOuntU'd0Aly,Ch%Ci|G G!GryIm$K!Noun)Nu$O` Sw T&naTiqueXietyY1ArtOlogyPe?P!Pro=Ril1ChCt-EaEnaGueMMedM%MyOundR<+Re,Ri=RowTTefa@Ti,Tw%k0KPe@SaultSetSi,SumeThma0H!>OmTa{T&dT.udeTra@0Ct]D.Gu,NtTh%ToTumn0Era+OcadoOid0AkeA*AyEsomeFulKw?d0Is:ByChel%C#D+GL<)Lc#y~MbooN<aNn RRelyRga(R*lSeS-SketTt!3A^AnAutyCau'ComeEfF%eG(Ha=H(dLie=LowLtN^Nef./TrayTt Twe&Y#d3Cyc!DKeNdOlogyRdR`Tt _{AdeAmeAnketA,EakE[IndOodO[omOu'Ue

21425UrUsh_rdAtDyIlMbNeNusOkO,Rd R(gRrowSsTtomUn)XY_{etA(AndA[A=EadEezeI{Id+IefIghtIngIskOccoliOk&OnzeOomO` OwnUsh2Bb!DdyD+tFf$oIldLbLkL!tNd!Nk Rd&Rg R,SS(e[SyTt Y Zz:Bba+B(B!CtusGeKe~LmM aMpNN$N)lNdyNn#NoeNvasNy#Pab!P.$Pta(RRb#RdRgoRpetRryRtSeShS(o/!Su$TT$ogT^Teg%yTt!UghtU'Ut]Ve3Il(gL yM|NsusNturyRe$Rta(_irAlkAmp]An+AosApt Ar+A'AtEapE{Ee'EfErryE,I{&IefIldIm}yOi)Oo'R#-U{!UnkUrn0G?Nnam#Rc!Tiz&TyVil_imApArifyAwAyE<ErkEv I{I|IffImbIn-IpO{OgO'O`OudOwnUbUmpU, Ut^_^A,C#utDeFfeeIlInL!@L%LumnMb(eMeMf%tM-Mm#Mp<yNc tNdu@NfirmNg*[N}@Nsid NtrolNv()OkOlPp PyR$ReRnR*@/Tt#U^UntryUp!Ur'Us(V Yo>_{Ad!AftAmA}AshAt AwlAzyEamEd.EekEwI{etImeIspIt-OpO[Ou^OwdUci$UelUi'Umb!Un^UshYY,$2BeLtu*PPbo?dRiousRr|Rta(R=Sh]/omTe3C!:DMa+MpN)Ng R(gShUght WnY3AlBa>BrisCadeCemb CideCl(eC%a>C*a'ErF&'F(eFyG*eLayLiv M<dMi'Ni$Nti,NyP?tP&dPos.P`PutyRi=ScribeS tSignSkSpair/royTailTe@VelopVi)Vo>3AgramAlAm#dAryCeE'lEtFf G.$Gn.yLemmaNn NosaurRe@RtSag*eScov Sea'ShSmi[S%d Splay/<)V tVideV%)Zzy5Ct%Cum|G~Lph(Ma(Na>NkeyN%OrSeUb!Ve_ftAg#AmaA,-AwEamE[IftIllInkIpI=OpUmY2CkMbNeR(g/T^Ty1Arf1Nam-:G G!RlyRnR`Sily/Sy1HoOlogyOnomy0GeItUca>1F%t0G1GhtTh 2BowD E@r-Eg<tEm|Eph<tEvat%I>Se0B?kBodyBra)Er+Ot]PloyPow Pty0Ab!A@DD![D%'EmyErgyF%)Ga+G(eH<)JoyLi,OughR-hRollSu*T Ti*TryVelope1Isode0U$Uip0AA'OdeOs]R%Upt0CapeSayS&)Ta>0Ern$H-s1Id&)IlOkeOl=1A@Amp!Ce[Ch<+C.eCludeCu'Ecu>Erci'Hau,Hib.I!I,ItOt-P<dPe@Pi*Pla(Po'P*[T&dTra0EEbrow:Br-CeCultyDeIntI`~L'MeMilyMousNNcyNtasyRmSh]TT$Th TigueUltV%.e3Atu*Bru?yD $EEdElMa!N)/iv$T^V W3B Ct]EldGu*LeLmLt N$NdNeNg NishReRmR,Sc$ShTT}[X_gAmeAshAtAv%EeIghtIpOatO{O%Ow UidUshY_mCusGIlLd~owOdOtR)Re,R+tRkRtu}RumRw?dSsil/ UndX_gi!AmeEqu|EshI&dIn+OgOntO,OwnOz&U.2ElNNnyRna)RyTu*:D+tInLaxy~ yMePRa+Rba+Rd&Rl-Rm|SSpTeTh U+Ze3N $NiusN*Nt!Nu(e/u*2O,0AntFtGg!Ng RaffeRlVe_dAn)A*A[IdeImp'ObeOomOryO=OwUe_tDde[LdOdO'RillaSpelSsipV nWn_bA)A(AntApeA[Av.yEatE&IdIefItOc yOupOwUnt_rdE[IdeIltIt?N3M:B.IrLfMm M, NdPpyRb%RdRshR=,TVeWkZ?d3AdAl`ArtAvyD+hogIght~oLmetLpNRo3Dd&Gh~NtPRe/%y5BbyCkeyLdLeLiday~owMeNeyOdPeRnRr%R'Sp.$/TelUrV 5BGeM<Mb!M%Nd*dNgryNtRd!RryRtSb<d3Brid:1EOn0EaEntifyLe2N%e4LLeg$L}[0A+Ita>M&'Mu}Pa@Po'Pro=Pul'0ChCludeComeC*a'DexD-a>Do%Du,ryF<tFl-tF%mHa!H .Iti$Je@JuryMa>N Noc|PutQuiryS<eSe@SideSpi*/$lTa@T e,ToVe,V.eVol=3On0L<dOla>Sue0Em1Ory:CketGu?RZz3AlousAns~yWel9BInKeUr}yY5D+I)MpNg!Ni%Nk/:Ng?oo3EnEpT^upY3CkDD}yNdNgdomSsTT^&TeTt&Wi4EeIfeO{Ow:BBelB%Dd DyKeMpNgua+PtopR+T T(UghUndryVaWWnWsu.Y Zy3Ad AfArnA=Ctu*FtGG$G&dIsu*M#NdNg`NsOp?dSs#Tt Vel3ArB tyBr?yC&'FeFtGhtKeMbM.NkOnQuid/Tt!VeZ?d5AdAnB, C$CkG-NelyNgOpTt yUdUn+VeY$5CkyGga+Mb N?N^Xury3R-s:Ch(eDG-G}tIdIlInJ%KeMm$NNa+Nda>NgoNs]Nu$P!Rb!R^Rg(R(eRketRria+SkSs/ T^T i$ThTrixTt XimumZe3AdowAnAsu*AtCh<-D$DiaLodyLtMb M%yNt]NuRcyR+R.RryShSsa+T$Thod3Dd!DnightLk~]M-NdNimumN%Nu>Rac!Rr%S ySs/akeXXedXtu*5Bi!DelDifyMM|N.%NkeyN, N`OnR$ReRn(gSqu.oTh T]T%Unta(U'VeVie5ChFf(LeLtiplySc!SeumShroomS-/Tu$3Self/ yTh:I=MePk(Rrow/yT]Tu*3ArCkEdGati=G!@I` PhewR=/TTw%kUtr$V WsXt3CeGht5B!I'M(eeOd!Rm$R`SeTab!TeTh(gTi)VelW5C!?Mb R'T:K0EyJe@Li+Scu*S =Ta(Vious0CurE<Tob 0Or1FF Fi)T&2L1Ay0DI=Ymp-0It0CeEI#L(eLy1EnEraIn]Po'T]1An+B.Ch?dD D(?yG<I|Ig($Ph<0Tr-h0H 0Tdo%T TputTside0AlEnEr0NN 0Yg&0/ 0O}:CtDd!GeIrLa)LmNdaNelN-N` P RadeR|RkRrotRtySsT^ThTi|TrolTt nU'VeYm|3A)AnutArAs<tL-<NN$tyNcilOp!Pp [email protected]#T2O}OtoRa'Ys-$0AnoCn-Ctu*E)GGe#~LotNkO} Pe/olT^Zza_)A}tA,-A>AyEa'Ed+U{UgUn+2EmEtIntL?LeLi)NdNyOlPul?Rt]S.]Ssib!/TatoTt yV tyWd W _@i)Ai'Ed-tEf Epa*Es|EttyEv|I)IdeIm?yIntI%.yIs#Iva>IzeOb!mO)[Odu)Of.OgramOje@Omo>OofOp tyOsp O>@OudOvide2Bl-Dd(g~LpL'Mpk(N^PilPpyR^a'R.yRpo'R'ShTZz!3Ramid:99Al.yAntumArt E,]I{ItIzO>:Bb.Cco#CeCkD?DioIlInI'~yMpN^NdomN+PidReTeTh V&WZ%3AdyAlAs#BelBuildC$lCei=CipeC%dCyc!Du)F!@F%mFu'G]G*tGul?Je@LaxLea'LiefLyMa(Memb M(dMo=Nd NewNtOp&PairPeatPla)P%tQui*ScueSemb!Si,Sour)Sp#'SultTi*T*atTurnUn]Ve$ViewW?d2Y`m0BBb#CeChDeD+F!GhtGidNgOtPp!SkTu$V$V 5AdA,BotBu,CketM<)OfOkieOmSeTa>UghUndU>Y$5Bb DeGLeNNwayR$:DDd!D}[FeIlLadLm#L#LtLu>MeMp!NdTisfyToshiU)Usa+VeY1A!AnA*Att E}HemeHoolI&)I[%sOrp]OutRapRe&RiptRub1AAr^As#AtC#dC*tCt]Cur.yEdEkGm|Le@~M(?Ni%N'Nt&)RiesRvi)Ss]Tt!TupV&_dowAftAllowA*EdEllEriffIeldIftI}IpIv O{OeOotOpOrtOuld O=RimpRugUff!Y0Bl(gCkDeE+GhtGnL|Lk~yLv Mil?Mp!N)NgR&/ Tua>XZe1A>

21425Et^IIllInIrtUll0AbAmEepEnd I)IdeIghtImOg<OtOwUsh0AllArtI!OkeOo`0A{AkeApIffOw0ApCc Ci$CkDaFtL?Ldi LidLut]L=Me#eNgOnRryRtUlUndUpUr)U`0A)A*Ati$AwnEakEci$EedEllEndH eI)Id IkeInIr.L.OilOns%O#OrtOtRayReadR(gY0Ua*UeezeUir*l_b!AdiumAffA+AirsAmpAndArtA>AyEakEelEmEpE*oI{IllIngO{Oma^O}OolOryO=Ra>gyReetRikeR#gRugg!Ud|[email protected])[ChDd&Ff G?G+,ItMm NNnyN'tP PplyP*meReRfa)R+Rpri'RroundR=ySpe@/a(1AllowAmpApArmE?EetIftImIngIt^Ord1MbolMptomRup/em:B!Ck!GIlL|LkNkPeR+tSk/eTtooXi3A^Am~NN<tNnisNtRm/Xt_nkAtEmeEnE%yE*EyIngIsOughtReeRi=RowUmbUnd 0CketDeG LtMb MeNyPRedSsueT!5A,BaccoDayDdl EGe` I!tK&MatoM%rowNeNgueNightOlO`PP-Pp!R^RnadoRtoi'SsT$Uri,W?dW WnY_{AdeAff-Ag-A(Ansf ApAshA=lAyEatEeEndI$IbeI{Igg ImIpOphyOub!U{UeUlyUmpetU,U`Y2BeIt]Mb!NaN}lRkeyRnRt!1El=EntyI)InI,O1PeP-$:5Ly5B*lla0Ab!Awa*C!Cov D DoFairFoldHappyIf%mIqueItIv 'KnownLo{TilUsu$Veil1Da>GradeHoldOnP Set1B<Ge0A+EEdEfulE![U$0Il.y:C<tCuumGueLidL!yL=NNishP%Rious/Ult3H-!L=tNd%Ntu*NueRbRifyRs]RyS'lT <3Ab!Br<tCiousCt%yDeoEw~a+Nta+Ol(Rtu$RusSaS.Su$T$Vid5C$I)IdLc<oLumeTeYa+:GeG#ItLk~LnutNtRfa*RmRri%ShSp/eT VeY3Al`Ap#ArA'lA` BDd(gEk&dIrdLcome/T_!AtEatEelEnE*IpIsp 0DeD`FeLd~NNdowNeNgNkNn Nt ReSdomSeShT}[5LfM<Nd OdOlRdRkRldRryR`_pE{E,!I,I>Ong::Rd3Ar~ow9UUngU`:3BraRo9NeO";
21426var checksum = "0x3c8acc1e7b08d8e76f9fda015ef48dc8c710a73cb7e0f77b2c18a9b5a7adde60";
21427var wordlist = null;
21428/**
21429*  The [[link-bip39-en]] for [mnemonic phrases](link-bip-39).
21430*
21431*  @_docloc: api/wordlists
21432*/
21433var LangEn = class LangEn extends WordlistOwl {
21434	/**
21435	*  Creates a new instance of the English language Wordlist.
21436	*
21437	*  This should be unnecessary most of the time as the exported
21438	*  [[langEn]] should suffice.
21439	*
21440	*  @_ignore:
21441	*/
21442	constructor() {
21443		super("en", words, checksum);
21444	}
21445	/**
21446	*  Returns a singleton instance of a ``LangEn``, creating it
21447	*  if this is the first time being called.
21448	*/
21449	static wordlist() {
21450		if (wordlist == null) wordlist = new LangEn();

21451		return wordlist;
21452	}
21453};
21454//#endregion
21455//#region node_modules/ethers/lib.esm/wallet/mnemonic.js
21456function getUpperMask(bits) {
21457	return (1 << bits) - 1 << 8 - bits & 255;
21458}
21459function getLowerMask(bits) {
21460	return (1 << bits) - 1 & 255;
21461}
21462function mnemonicToEntropy(mnemonic, wordlist) {
21463	assertNormalize("NFKD");
21464	if (wordlist == null) wordlist = LangEn.wordlist();
21465	const words = wordlist.split(mnemonic);
21466	assertArgument(words.length % 3 === 0 && words.length >= 12 && words.length <= 24, "invalid mnemonic length", "mnemonic", "[ REDACTED ]");
21467	const entropy = new Uint8Array(Math.ceil(11 * words.length / 8));
21468	let offset = 0;
21469	for (let i = 0; i < words.length; i++) {
21470		let index = wordlist.getWordIndex(words[i].normalize("NFKD"));
21471		assertArgument(index >= 0, `invalid mnemonic word at index ${i}`, "mnemonic", "[ REDACTED ]");
21472		for (let bit = 0; bit < 11; bit++) {
21473			if (index & 1 << 10 - bit) entropy[offset >> 3] |= 1 << 7 - offset % 8;
21474			offset++;
21475		}
21476	}
21477	const entropyBits = 32 * words.length / 3;
21478	const checksumMask = getUpperMask(words.length / 3);
21479	assertArgument((getBytes(sha256(entropy.slice(0, entropyBits / 8)))[0] & checksumMask) === (entropy[entropy.length - 1] & checksumMask), "invalid mnemonic checksum", "mnemonic", "[ REDACTED ]");
21480	return hexlify(entropy.slice(0, entropyBits / 8));
21481}
21482function entropyToMnemonic(entropy, wordlist) {
21483	assertArgument(entropy.length % 4 === 0 && entropy.length >= 16 && entropy.length <= 32, "invalid entropy size", "entropy", "[ REDACTED ]");
21484	if (wordlist == null) wordlist = LangEn.wordlist();
21485	const indices = [0];
21486	let remainingBits = 11;
21487	for (let i = 0; i < entropy.length; i++) if (remainingBits > 8) {
21488		indices[indices.length - 1] <<= 8;
21489		indices[indices.length - 1] |= entropy[i];
21490		remainingBits -= 8;
21491	} else {
21492		indices[indices.length - 1] <<= remainingBits;
21493		indices[indices.length - 1] |= entropy[i] >> 8 - remainingBits;
21494		indices.push(entropy[i] & getLowerMask(8 - remainingBits));
21495		remainingBits += 3;
21496	}
21497	const checksumBits = entropy.length / 4;
21498	const checksum = parseInt(sha256(entropy).substring(2, 4), 16) & getUpperMask(checksumBits);
21499	indices[indices.length - 1] <<= checksumBits;
21500	indices[indices.length - 1] |= checksum >> 8 - checksumBits;

21501	return wordlist.join(indices.map((index) => wordlist.getWord(index)));
21502}
21503var _guard$1 = {};
21504/**
21505*  A **Mnemonic** wraps all properties required to compute [[link-bip-39]]
21506*  seeds and convert between phrases and entropy.
21507*/
21508var Mnemonic = class Mnemonic {
21509	/**
21510	*  The mnemonic phrase of 12, 15, 18, 21 or 24 words.
21511	*
21512	*  Use the [[wordlist]] ``split`` method to get the individual words.
21513	*/
21514	phrase;
21515	/**
21516	*  The password used for this mnemonic. If no password is used this
21517	*  is the empty string (i.e. ``""``) as per the specification.
21518	*/
21519	password;
21520	/**
21521	*  The wordlist for this mnemonic.
21522	*/
21523	wordlist;
21524	/**
21525	*  The underlying entropy which the mnemonic encodes.
21526	*/
21527	entropy;
21528	/**
21529	*  @private
21530	*/
21531	constructor(guard, entropy, phrase, password, wordlist) {
21532		if (password == null) password = "";
21533		if (wordlist == null) wordlist = LangEn.wordlist();
21534		assertPrivate(guard, _guard$1, "Mnemonic");
21535		defineProperties(this, {
21536			phrase,
21537			password,
21538			wordlist,
21539			entropy
21540		});
21541	}
21542	/**
21543	*  Returns the seed for the mnemonic.
21544	*/
21545	computeSeed() {
21546		const salt = toUtf8Bytes("mnemonic" + this.password, "NFKD");
21547		return pbkdf2(toUtf8Bytes(this.phrase, "NFKD"), salt, 2048, 64, "sha512");
21548	}
21549	/**
21550	*  Creates a new Mnemonic for the %%phrase%%.
21551	*
21552	*  The default %%password%% is the empty string and the default
21553	*  wordlist is the [English wordlists](LangEn).
21554	*/
21555	static fromPhrase(phrase, password, wordlist) {
21556		const entropy = mnemonicToEntropy(phrase, wordlist);
21557		phrase = entropyToMnemonic(getBytes(entropy), wordlist);
21558		return new Mnemonic(_guard$1, entropy, phrase, password, wordlist);
21559	}
21560	/**
21561	*  Create a new **Mnemonic** from the %%entropy%%.
21562	*
21563	*  The default %%password%% is the empty string and the default
21564	*  wordlist is the [English wordlists](LangEn).
21565	*/
21566	static fromEntropy(_entropy, password, wordlist) {
21567		const entropy = getBytes(_entropy, "entropy");
21568		const phrase = entropyToMnemonic(entropy, wordlist);
21569		return new Mnemonic(_guard$1, hexlify(entropy), phrase, password, wordlist);
21570	}
21571	/**
21572	*  Returns the phrase for %%mnemonic%%.
21573	*/
21574	static entropyToPhrase(_entropy, wordlist) {
21575		return entropyToMnemonic(getBytes(_entropy, "entropy"), wordlist);
21576	}
21577	/**
21578	*  Returns the entropy for %%phrase%%.
21579	*/
21580	static phraseToEntropy(phrase, wordlist) {
21581		return mnemonicToEntropy(phrase, wordlist);
21582	}
21583	/**
21584	*  Returns true if %%phrase%% is a valid [[link-bip-39]] phrase.
21585	*
21586	*  This checks all the provided words belong to the %%wordlist%%,
21587	*  that the length is valid and the checksum is correct.
21588	*/
21589	static isValidMnemonic(phrase, wordlist) {
21590		try {
21591			mnemonicToEntropy(phrase, wordlist);
21592			return true;
21593		} catch (error) {}
21594		return false;
21595	}
21596};
21597//#endregion
21598//#region node_modules/aes-js/lib.esm/aes.js
21599/*! MIT License. Copyright 2015-2022 Richard Moore <[email protected]>. See LICENSE.txt. */
21600var __classPrivateFieldGet$2 = function(receiver, state, kind, f) {
21601	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
21602	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
21603	return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
21604};
21605var __classPrivateFieldSet$2 = function(receiver, state, value, kind, f) {
21606	if (kind === "m") throw new TypeError("Private method is not writable");
21607	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
21608	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
21609	return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
21610};
21611var _AES_key;
21612var _AES_Kd;
21613var _AES_Ke;
21614var numberOfRounds = {
21615	16: 10,
21616	24: 12,
21617	32: 14
21618};
21619var rcon = [
21620	1,
21621	2,
21622	4,
21623	8,
21624	16,
21625	32,
21626	64,
21627	128,
21628	27,
21629	54,
21630	108,
21631	216,
21632	171,
21633	77,
21634	154,
21635	47,
21636	94,
21637	188,
21638	99,
21639	198,
21640	151,
21641	53,
21642	106,
21643	212,
21644	179,
21645	125,
21646	250,
21647	239,
21648	197,
21649	145
21650];
21651var S = [
21652	99,
21653	124,
21654	119,
21655	123,
21656	242,
21657	107,
21658	111,
21659	197,
21660	48,
21661	1,
21662	103,
21663	43,
21664	254,
21665	215,
21666	171,
21667	118,
21668	202,
21669	130,
21670	201,
21671	125,
21672	250,
21673	89,
21674	71,
21675	240,
21676	173,
21677	212,
21678	162,
21679	175,
21680	156,
21681	164,
21682	114,
21683	192,
21684	183,
21685	253,
21686	147,
21687	38,
21688	54,
21689	63,
21690	247,
21691	204,
21692	52,
21693	165,
21694	229,
21695	241,
21696	113,
21697	216,
21698	49,
21699	21,
21700	4,
21701	199,
21702	35,
21703	195,
21704	24,
21705	150,
21706	5,
21707	154,
21708	7,

21709	18,
21710	128,
21711	226,
21712	235,
21713	39,
21714	178,
21715	117,
21716	9,
21717	131,
21718	44,
21719	26,
21720	27,
21721	110,
21722	90,
21723	160,
21724	82,
21725	59,
21726	214,
21727	179,
21728	41,
21729	227,
21730	47,
21731	132,
21732	83,
21733	209,
21734	0,
21735	237,
21736	32,
21737	252,
21738	177,
21739	91,
21740	106,
21741	203,
21742	190,
21743	57,
21744	74,
21745	76,
21746	88,
21747	207,
21748	208,
21749	239,
21750	170,
21751	251,
21752	67,
21753	77,
21754	51,
21755	133,
21756	69,
21757	249,
21758	2,
21759	127,
21760	80,
21761	60,
21762	159,
21763	168,
21764	81,
21765	163,
21766	64,
21767	143,
21768	146,
21769	157,
21770	56,
21771	245,
21772	188,
21773	182,
21774	218,
21775	33,
21776	16,
21777	255,
21778	243,
21779	210,
21780	205,
21781	12,
21782	19,
21783	236,
21784	95,
21785	151,
21786	68,
21787	23,
21788	196,
21789	167,
21790	126,
21791	61,
21792	100,
21793	93,
21794	25,
21795	115,
21796	96,
21797	129,
21798	79,
21799	220,
21800	34,
21801	42,
21802	144,
21803	136,
21804	70,
21805	238,
21806	184,
21807	20,
21808	222,
21809	94,
21810	11,
21811	219,
21812	224,
21813	50,
21814	58,
21815	10,
21816	73,
21817	6,
21818	36,
21819	92,
21820	194,
21821	211,
21822	172,
21823	98,
21824	145,
21825	149,
21826	228,
21827	121,
21828	231,
21829	200,
21830	55,
21831	109,
21832	141,
21833	213,
21834	78,
21835	169,
21836	108,
21837	86,
21838	244,
21839	234,
21840	101,
21841	122,
21842	174,
21843	8,
21844	186,
21845	120,
21846	37,
21847	46,
21848	28,
21849	166,
21850	180,
21851	198,
21852	232,
21853	221,
21854	116,
21855	31,
21856	75,
21857	189,
21858	139,
21859	138,
21860	112,
21861	62,
21862	181,
21863	102,
21864	72,
21865	3,
21866	246,
21867	14,
21868	97,
21869	53,
21870	87,
21871	185,
21872	134,
21873	193,
21874	29,
21875	158,
21876	225,
21877	248,
21878	152,
21879	17,
21880	105,
21881	217,
21882	142,
21883	148,
21884	155,
21885	30,
21886	135,
21887	233,
21888	206,
21889	85,
21890	40,
21891	223,
21892	140,
21893	161,
21894	137,
21895	13,
21896	191,
21897	230,
21898	66,
21899	104,
21900	65,
21901	153,
21902	45,
21903	15,
21904	176,
21905	84,
21906	187,
21907	22
21908];
21909var Si = [
21910	82,
21911	9,
21912	106,
21913	213,
21914	48,
21915	54,
21916	165,
21917	56,
21918	191,
21919	64,
21920	163,
21921	158,
21922	129,
21923	243,
21924	215,
21925	251,
21926	124,
21927	227,
21928	57,
21929	130,
21930	155,
21931	47,
21932	255,
21933	135,
21934	52,
21935	142,
21936	67,
21937	68,
21938	196,
21939	222,
21940	233,
21941	203,
21942	84,
21943	123,
21944	148,
21945	50,
21946	166,
21947	194,
21948	35,
21949	61,
21950	238,
21951	76,
21952	149,
21953	11,
21954	66,
21955	250,
21956	195,
21957	78,
21958	8,
21959	46,
21960	161,
21961	102,
21962	40,
21963	217,
21964	36,
21965	178,
21966	118,
21967	91,
21968	162,
21969	73,
21970	109,
21971	139,
21972	209,
21973	37,
21974	114,
21975	248,
21976	246,
21977	100,
21978	134,
21979	104,
21980	152,
21981	22,
21982	212,
21983	164,
21984	92,
21985	204,
21986	93,
21987	101,
21988	182,
21989	146,
21990	108,
21991	112,
21992	72,
21993	80,
21994	253,
21995	237,
21996	185,
21997	218,
21998	94,
21999	21,
22000	70,
22001	87,
22002	167,
22003	141,
22004	157,
22005	132,
22006	144,
22007	216,
22008	171,
22009	0,
22010	140,
22011	188,
22012	211,
22013	10,
22014	247,
22015	228,
22016	88,
22017	5,
22018	184,
22019	179,
22020	69,
22021	6,
22022	208,
22023	44,
22024	30,
22025	143,
22026	202,
22027	63,
22028	15,
22029	2,
22030	193,
22031	175,
22032	189,
22033	3,
22034	1,
22035	19,
22036	138,
22037	107,
22038	58,
22039	145,
22040	17,
22041	65,
22042	79,
22043	103,
22044	220,
22045	234,
22046	151,
22047	242,
22048	207,
22049	206,
22050	240,
22051	180,
22052	230,
22053	115,
22054	150,
22055	172,
22056	116,
22057	34,
22058	231,
22059	173,
22060	53,
22061	133,
22062	226,
22063	249,
22064	55,
22065	232,
22066	28,
22067	117,
22068	223,
22069	110,
22070	71,
22071	241,
22072	26,
22073	113,
22074	29,
22075	41,
22076	197,
22077	137,
22078	111,
22079	183,
22080	98,
22081	14,
22082	170,
22083	24,
22084	190,
22085	27,
22086	252,
22087	86,
22088	62,
22089	75,
22090	198,
22091	210,
22092	121,
22093	32,
22094	154,
22095	219,
22096	192,
22097	254,
22098	120,
22099	205,
22100	90,
22101	244,
22102	31,
22103	221,
22104	168,
22105	51,
22106	136,
22107	7,
22108	199,
22109	49,
22110	177,
22111	18,
22112	16,
22113	89,
22114	39,
22115	128,
22116	236,
22117	95,
22118	96,
22119	81,
22120	127,
22121	169,
22122	25,
22123	181,
22124	74,
22125	13,
22126	45,
22127	229,
22128	122,
22129	159,
22130	147,
22131	201,
22132	156,
22133	239,
22134	160,
22135	224,
22136	59,
22137	77,
22138	174,
22139	42,
22140	245,
22141	176,
22142	200,
22143	235,
22144	187,
22145	60,
22146	131,
22147	83,
22148	153,
22149	97,
22150	23,
22151	43,
22152	4,
22153	126,
22154	186,
22155	119,
22156	214,
22157	38,
22158	225,
22159	105,
22160	20,
22161	99,
22162	85,
22163	33,
22164	12,
22165	125
22166];
22167var T1 = [
22168	3328402341,
22169	4168907908,
22170	4000806809,
22171	4135287693,
22172	4294111757,
22173	3597364157,
22174	3731845041,
22175	2445657428,
22176	1613770832,
22177	33620227,
22178	3462883241,
22179	1445669757,
22180	3892248089,
22181	3050821474,
22182	1303096294,
22183	3967186586,
22184	2412431941,
22185	528646813,
22186	2311702848,
22187	4202528135,
22188	4026202645,
22189	2992200171,
22190	2387036105,
22191	4226871307,
22192	1101901292,
22193	3017069671,
22194	1604494077,
22195	1169141738,
22196	597466303,
22197	1403299063,
22198	3832705686,
22199	2613100635,
22200	1974974402,
22201	3791519004,
22202	1033081774,
22203	1277568618,
22204	1815492186,
22205	2118074177,
22206	4126668546,
22207	2211236943,
22208	1748251740,
22209	1369810420,
22210	3521504564,
22211	4193382664,
22212	3799085459,
22213	2883115123,
22214	1647391059,
22215	706024767,
22216	134480908,
22217	2512897874,
22218	1176707941,
22219	2646852446,
22220	806885416,
22221	932615841,
22222	168101135,
22223	798661301,
22224	235341577,
22225	605164086,
22226	461406363,
22227	3756188221,
22228	3454790438,
22229	1311188841,
22230	2142417613,
22231	3933566367,
22232	302582043,
22233	495158174,
22234	1479289972,
22235	874125870,
22236	907746093,
22237	3698224818,
22238	3025820398,
22239	1537253627,
22240	2756858614,
22241	1983593293,
22242	3084310113,
22243	2108928974,
22244	1378429307,
22245	3722699582,
22246	1580150641,
22247	327451799,
22248	2790478837,
22249	3117535592,
22250	0,
22251	3253595436,
22252	1075847264,
22253	3825007647,
22254	2041688520,
22255	3059440621,
22256	3563743934,
22257	2378943302,
22258	1740553945,
22259	1916352843,
22260	2487896798,
22261	2555137236,
22262	2958579944,
22263	2244988746,
22264	3151024235,
22265	3320835882,
22266	1336584933,
22267	3992714006,
22268	2252555205,
22269	2588757463,
22270	1714631509,
22271	293963156,
22272	2319795663,
22273	3925473552,
22274	67240454,
22275	4269768577,
22276	2689618160,
22277	2017213508,
22278	631218106,
22279	1269344483,
22280	2723238387,
22281	1571005438,
22282	2151694528,
22283	93294474,
22284	1066570413,
22285	563977660,
22286	1882732616,
22287	4059428100,
22288	1673313503,
22289	2008463041,
22290	2950355573,
22291	1109467491,
22292	537923632,
22293	3858759450,
22294	4260623118,
22295	3218264685,
22296	2177748300,
22297	403442708,
22298	638784309,
22299	3287084079,
22300	3193921505,
22301	899127202,
22302	2286175436,
22303	773265209,
22304	2479146071,
22305	1437050866,
22306	4236148354,
22307	2050833735,
22308	3362022572,
22309	3126681063,
22310	840505643,
22311	3866325909,
22312	3227541664,
22313	427917720,
22314	2655997905,
22315	2749160575,
22316	1143087718,
22317	1412049534,
22318	999329963,
22319	193497219,
22320	2353415882,
22321	3354324521,
22322	1807268051,

22323	672404540,
22324	2816401017,
22325	3160301282,
22326	369822493,
22327	2916866934,
22328	3688947771,
22329	1681011286,
22330	1949973070,
22331	336202270,
22332	2454276571,
22333	201721354,
22334	1210328172,
22335	3093060836,
22336	2680341085,
22337	3184776046,
22338	1135389935,
22339	3294782118,
22340	965841320,
22341	831886756,
22342	3554993207,
22343	4068047243,
22344	3588745010,
22345	2345191491,
22346	1849112409,
22347	3664604599,
22348	26054028,
22349	2983581028,
22350	2622377682,
22351	1235855840,
22352	3630984372,
22353	2891339514,
22354	4092916743,
22355	3488279077,
22356	3395642799,
22357	4101667470,
22358	1202630377,
22359	268961816,
22360	1874508501,
22361	4034427016,
22362	1243948399,
22363	1546530418,
22364	941366308,
22365	1470539505,
22366	1941222599,
22367	2546386513,
22368	3421038627,
22369	2715671932,
22370	3899946140,
22371	1042226977,
22372	2521517021,
22373	1639824860,
22374	227249030,
22375	260737669,
22376	3765465232,
22377	2084453954,
22378	1907733956,
22379	3429263018,
22380	2420656344,
22381	100860677,
22382	4160157185,
22383	470683154,
22384	3261161891,
22385	1781871967,
22386	2924959737,
22387	1773779408,
22388	394692241,
22389	2579611992,
22390	974986535,
22391	664706745,
22392	3655459128,
22393	3958962195,
22394	731420851,
22395	571543859,
22396	3530123707,
22397	2849626480,
22398	126783113,
22399	865375399,
22400	765172662,
22401	1008606754,
22402	361203602,
22403	3387549984,
22404	2278477385,
22405	2857719295,
22406	1344809080,
22407	2782912378,
22408	59542671,
22409	1503764984,
22410	160008576,
22411	437062935,
22412	1707065306,
22413	3622233649,
22414	2218934982,
22415	3496503480,
22416	2185314755,
22417	697932208,
22418	1512910199,
22419	504303377,
22420	2075177163,
22421	2824099068,
22422	1841019862,
22423	739644986
22424];
22425var T2 = [
22426	2781242211,
22427	2230877308,
22428	2582542199,
22429	2381740923,
22430	234877682,
22431	3184946027,
22432	2984144751,
22433	1418839493,
22434	1348481072,
22435	50462977,
22436	2848876391,
22437	2102799147,
22438	434634494,
22439	1656084439,
22440	3863849899,
22441	2599188086,
22442	1167051466,
22443	2636087938,
22444	1082771913,
22445	2281340285,
22446	368048890,
22447	3954334041,
22448	3381544775,
22449	201060592,
22450	3963727277,
22451	1739838676,
22452	4250903202,
22453	3930435503,
22454	3206782108,
22455	4149453988,
22456	2531553906,
22457	1536934080,
22458	3262494647,
22459	484572669,
22460	2923271059,
22461	1783375398,
22462	1517041206,
22463	1098792767,
22464	49674231,
22465	1334037708,
22466	1550332980,
22467	4098991525,
22468	886171109,
22469	150598129,
22470	2481090929,
22471	1940642008,
22472	1398944049,
22473	1059722517,
22474	201851908,
22475	1385547719,
22476	1699095331,
22477	1587397571,
22478	674240536,
22479	2704774806,
22480	252314885,
22481	3039795866,
22482	151914247,
22483	908333586,
22484	2602270848,
22485	1038082786,
22486	651029483,
22487	1766729511,
22488	3447698098,
22489	2682942837,
22490	454166793,
22491	2652734339,
22492	1951935532,
22493	775166490,
22494	758520603,
22495	3000790638,
22496	4004797018,
22497	4217086112,
22498	4137964114,
22499	1299594043,
22500	1639438038,
22501	3464344499,
22502	2068982057,
22503	1054729187,
22504	1901997871,
22505	2534638724,
22506	4121318227,
22507	1757008337,
22508	0,
22509	750906861,
22510	1614815264,
22511	535035132,
22512	3363418545,
22513	3988151131,
22514	3201591914,
22515	1183697867,
22516	3647454910,
22517	1265776953,
22518	3734260298,
22519	3566750796,
22520	3903871064,
22521	1250283471,
22522	1807470800,
22523	717615087,
22524	3847203498,
22525	384695291,
22526	3313910595,
22527	3617213773,
22528	1432761139,
22529	2484176261,
22530	3481945413,
22531	283769337,
22532	100925954,
22533	2180939647,
22534	4037038160,
22535	1148730428,
22536	3123027871,
22537	3813386408,
22538	4087501137,
22539	4267549603,
22540	3229630528,
22541	2315620239,
22542	2906624658,
22543	3156319645,
22544	1215313976,

22545	82966005,
22546	3747855548,
22547	3245848246,
22548	1974459098,
22549	1665278241,
22550	807407632,
22551	451280895,
22552	251524083,
22553	1841287890,
22554	1283575245,
22555	337120268,
22556	891687699,
22557	801369324,
22558	3787349855,
22559	2721421207,
22560	3431482436,
22561	959321879,
22562	1469301956,
22563	4065699751,
22564	2197585534,
22565	1199193405,
22566	2898814052,
22567	3887750493,
22568	724703513,
22569	2514908019,
22570	2696962144,
22571	2551808385,
22572	3516813135,
22573	2141445340,
22574	1715741218,
22575	2119445034,
22576	2872807568,
22577	2198571144,
22578	3398190662,
22579	700968686,
22580	3547052216,
22581	1009259540,
22582	2041044702,
22583	3803995742,
22584	487983883,
22585	1991105499,
22586	1004265696,
22587	1449407026,
22588	1316239930,
22589	504629770,
22590	3683797321,
22591	168560134,
22592	1816667172,
22593	3837287516,
22594	1570751170,
22595	1857934291,
22596	4014189740,
22597	2797888098,
22598	2822345105,
22599	2754712981,
22600	936633572,
22601	2347923833,
22602	852879335,
22603	1133234376,
22604	1500395319,
22605	3084545389,
22606	2348912013,
22607	1689376213,
22608	3533459022,
22609	3762923945,
22610	3034082412,
22611	4205598294,
22612	133428468,
22613	634383082,
22614	2949277029,
22615	2398386810,
22616	3913789102,
22617	403703816,
22618	3580869306,
22619	2297460856,
22620	1867130149,
22621	1918643758,
22622	607656988,
22623	4049053350,
22624	3346248884,
22625	1368901318,
22626	600565992,
22627	2090982877,
22628	2632479860,
22629	557719327,

22630	3717614411,
22631	3697393085,
22632	2249034635,
22633	2232388234,
22634	2430627952,
22635	1115438654,
22636	3295786421,
22637	2865522278,
22638	3633334344,
22639	84280067,
22640	33027830,
22641	303828494,
22642	2747425121,
22643	1600795957,
22644	4188952407,
22645	3496589753,
22646	2434238086,
22647	1486471617,
22648	658119965,
22649	3106381470,
22650	953803233,
22651	334231800,
22652	3005978776,
22653	857870609,
22654	3151128937,
22655	1890179545,
22656	2298973838,
22657	2805175444,
22658	3056442267,
22659	574365214,
22660	2450884487,
22661	550103529,
22662	1233637070,
22663	4289353045,
22664	2018519080,
22665	2057691103,
22666	2399374476,
22667	4166623649,
22668	2148108681,
22669	387583245,
22670	3664101311,
22671	836232934,
22672	3330556482,
22673	3100665960,
22674	3280093505,
22675	2955516313,
22676	2002398509,
22677	287182607,
22678	3413881008,
22679	4238890068,
22680	3597515707,
22681	975967766
22682];
22683var T3 = [
22684	1671808611,
22685	2089089148,
22686	2006576759,
22687	2072901243,
22688	4061003762,
22689	1807603307,
22690	1873927791,
22691	3310653893,
22692	810573872,
22693	16974337,
22694	1739181671,
22695	729634347,
22696	4263110654,
22697	3613570519,
22698	2883997099,
22699	1989864566,
22700	3393556426,
22701	2191335298,
22702	3376449993,
22703	2106063485,
22704	4195741690,
22705	1508618841,
22706	1204391495,
22707	4027317232,
22708	2917941677,
22709	3563566036,
22710	2734514082,
22711	2951366063,
22712	2629772188,
22713	2767672228,
22714	1922491506,
22715	3227229120,
22716	3082974647,
22717	4246528509,
22718	2477669779,
22719	644500518,
22720	911895606,
22721	1061256767,
22722	4144166391,
22723	3427763148,
22724	878471220,
22725	2784252325,
22726	3845444069,
22727	4043897329,
22728	1905517169,
22729	3631459288,
22730	827548209,
22731	356461077,
22732	67897348,
22733	3344078279,
22734	593839651,
22735	3277757891,
22736	405286936,
22737	2527147926,
22738	84871685,
22739	2595565466,
22740	118033927,
22741	305538066,
22742	2157648768,
22743	3795705826,
22744	3945188843,
22745	661212711,
22746	2999812018,
22747	1973414517,
22748	152769033,
22749	2208177539,
22750	745822252,
22751	439235610,
22752	455947803,
22753	1857215598,
22754	1525593178,
22755	2700827552,
22756	1391895634,
22757	994932283,
22758	3596728278,
22759	3016654259,
22760	695947817,
22761	3812548067,
22762	795958831,
22763	2224493444,
22764	1408607827,
22765	3513301457,
22766	0,
22767	3979133421,
22768	543178784,
22769	4229948412,
22770	2982705585,
22771	1542305371,
22772	1790891114,
22773	3410398667,
22774	3201918910,
22775	961245753,
22776	1256100938,
22777	1289001036,
22778	1491644504,
22779	3477767631,
22780	3496721360,
22781	4012557807,
22782	2867154858,
22783	4212583931,
22784	1137018435,
22785	1305975373,
22786	861234739,
22787	2241073541,
22788	1171229253,
22789	4178635257,
22790	33948674,
22791	2139225727,
22792	1357946960,
22793	1011120188,
22794	2679776671,
22795	2833468328,
22796	1374921297,
22797	2751356323,
22798	1086357568,
22799	2408187279,
22800	2460827538,
22801	2646352285,
22802	944271416,
22803	4110742005,
22804	3168756668,
22805	3066132406,
22806	3665145818,
22807	560153121,
22808	271589392,
22809	4279952895,
22810	4077846003,
22811	3530407890,
22812	3444343245,
22813	202643468,
22814	322250259,
22815	3962553324,
22816	1608629855,
22817	2543990167,
22818	1154254916,
22819	389623319,
22820	3294073796,
22821	2817676711,
22822	2122513534,
22823	1028094525,
22824	1689045092,
22825	1575467613,
22826	422261273,
22827	1939203699,
22828	1621147744,
22829	2174228865,
22830	1339137615,
22831	3699352540,
22832	577127458,
22833	712922154,
22834	2427141008,
22835	2290289544,
22836	1187679302,
22837	3995715566,
22838	3100863416,
22839	339486740,
22840	3732514782,
22841	1591917662,
22842	186455563,
22843	3681988059,
22844	3762019296,
22845	844522546,
22846	978220090,
22847	169743370,
22848	1239126601,
22849	101321734,
22850	611076132,
22851	1558493276,
22852	3260915650,
22853	3547250131,
22854	2901361580,
22855	1655096418,
22856	2443721105,
22857	2510565781,
22858	3828863972,
22859	2039214713,
22860	3878868455,
22861	3359869896,
22862	928607799,
22863	1840765549,
22864	2374762893,
22865	3580146133,
22866	1322425422,
22867	2850048425,
22868	1823791212,
22869	1459268694,
22870	4094161908,
22871	3928346602,
22872	1706019429,
22873	2056189050,
22874	2934523822,
22875	135794696,
22876	3134549946,
22877	2022240376,
22878	628050469,
22879	779246638,
22880	472135708,
22881	2800834470,
22882	3032970164,
22883	3327236038,
22884	3894660072,
22885	3715932637,
22886	1956440180,
22887	522272287,
22888	1272813131,
22889	3185336765,
22890	2340818315,
22891	2323976074,
22892	1888542832,
22893	1044544574,
22894	3049550261,
22895	1722469478,
22896	1222152264,
22897	50660867,
22898	4127324150,
22899	236067854,
22900	1638122081,
22901	895445557,
22902	1475980887,
22903	3117443513,
22904	2257655686,
22905	3243809217,
22906	489110045,
22907	2662934430,
22908	3778599393,
22909	4162055160,
22910	2561878936,
22911	288563729,
22912	1773916777,
22913	3648039385,
22914	2391345038,
22915	2493985684,
22916	2612407707,
22917	505560094,
22918	2274497927,
22919	3911240169,
22920	3460925390,
22921	1442818645,
22922	678973480,
22923	3749357023,
22924	2358182796,
22925	2717407649,
22926	2306869641,
22927	219617805,
22928	3218761151,
22929	3862026214,
22930	1120306242,
22931	1756942440,
22932	1103331905,
22933	2578459033,
22934	762796589,
22935	252780047,
22936	2966125488,
22937	1425844308,
22938	3151392187,
22939	372911126
22940];
22941var T4 = [
22942	1667474886,
22943	2088535288,
22944	2004326894,
22945	2071694838,
22946	4075949567,
22947	1802223062,
22948	1869591006,
22949	3318043793,
22950	808472672,
22951	16843522,
22952	1734846926,
22953	724270422,
22954	4278065639,
22955	3621216949,
22956	2880169549,
22957	1987484396,
22958	3402253711,
22959	2189597983,
22960	3385409673,
22961	2105378810,
22962	4210693615,
22963	1499065266,
22964	1195886990,
22965	4042263547,

22966	2913856577,
22967	3570689971,
22968	2728590687,
22969	2947541573,
22970	2627518243,
22971	2762274643,
22972	1920112356,
22973	3233831835,
22974	3082273397,
22975	4261223649,
22976	2475929149,
22977	640051788,
22978	909531756,
22979	1061110142,
22980	4160160501,
22981	3435941763,
22982	875846760,
22983	2779116625,
22984	3857003729,
22985	4059105529,
22986	1903268834,
22987	3638064043,
22988	825316194,
22989	353713962,
22990	67374088,
22991	3351728789,
22992	589522246,
22993	3284360861,
22994	404236336,
22995	2526454071,
22996	84217610,
22997	2593830191,
22998	117901582,
22999	303183396,
23000	2155911963,
23001	3806477791,
23002	3958056653,
23003	656894286,
23004	2998062463,
23005	1970642922,
23006	151591698,
23007	2206440989,
23008	741110872,
23009	437923380,
23010	454765878,
23011	1852748508,
23012	1515908788,
23013	2694904667,
23014	1381168804,
23015	993742198,
23016	3604373943,
23017	3014905469,
23018	690584402,
23019	3823320797,
23020	791638366,
23021	2223281939,
23022	1398011302,
23023	3520161977,
23024	0,
23025	3991743681,
23026	538992704,
23027	4244381667,
23028	2981218425,
23029	1532751286,
23030	1785380564,
23031	3419096717,
23032	3200178535,
23033	960056178,
23034	1246420628,
23035	1280103576,
23036	1482221744,
23037	3486468741,
23038	3503319995,
23039	4025428677,
23040	2863326543,
23041	4227536621,
23042	1128514950,
23043	1296947098,
23044	859002214,
23045	2240123921,
23046	1162203018,
23047	4193849577,
23048	33687044,
23049	2139062782,
23050	1347481760,
23051	1010582648,
23052	2678045221,
23053	2829640523,
23054	1364325282,
23055	2745433693,
23056	1077985408,
23057	2408548869,
23058	2459086143,
23059	2644360225,
23060	943212656,
23061	4126475505,
23062	3166494563,
23063	3065430391,
23064	3671750063,
23065	555836226,
23066	269496352,
23067	4294908645,
23068	4092792573,
23069	3537006015,
23070	3452783745,
23071	202118168,
23072	320025894,
23073	3974901699,
23074	1600119230,
23075	2543297077,
23076	1145359496,
23077	387397934,
23078	3301201811,
23079	2812801621,
23080	2122220284,
23081	1027426170,
23082	1684319432,
23083	1566435258,
23084	421079858,
23085	1936954854,
23086	1616945344,
23087	2172753945,
23088	1330631070,
23089	3705438115,
23090	572679748,
23091	707427924,
23092	2425400123,
23093	2290647819,
23094	1179044492,
23095	4008585671,
23096	3099120491,
23097	336870440,
23098	3739122087,
23099	1583276732,
23100	185277718,
23101	3688593069,
23102	3772791771,
23103	842159716,
23104	976899700,
23105	168435220,
23106	1229577106,
23107	101059084,
23108	606366792,
23109	1549591736,
23110	3267517855,
23111	3553849021,
23112	2897014595,
23113	1650632388,
23114	2442242105,
23115	2509612081,
23116	3840161747,
23117	2038008818,
23118	3890688725,
23119	3368567691,
23120	926374254,
23121	1835907034,
23122	2374863873,
23123	3587531953,
23124	1313788572,
23125	2846482505,
23126	1819063512,
23127	1448540844,
23128	4109633523,
23129	3941213647,
23130	1701162954,
23131	2054852340,
23132	2930698567,
23133	134748176,
23134	3132806511,
23135	2021165296,
23136	623210314,
23137	774795868,
23138	471606328,
23139	2795958615,
23140	3031746419,
23141	3334885783,
23142	3907527627,
23143	3722280097,
23144	1953799400,
23145	522133822,
23146	1263263126,
23147	3183336545,
23148	2341176845,
23149	2324333839,
23150	1886425312,
23151	1044267644,
23152	3048588401,
23153	1718004428,
23154	1212733584,
23155	50529542,
23156	4143317495,
23157	235803164,
23158	1633788866,
23159	892690282,
23160	1465383342,
23161	3115962473,
23162	2256965911,
23163	3250673817,
23164	488449850,
23165	2661202215,
23166	3789633753,
23167	4177007595,
23168	2560144171,
23169	286339874,
23170	1768537042,
23171	3654906025,
23172	2391705863,
23173	2492770099,
23174	2610673197,
23175	505291324,
23176	2273808917,
23177	3924369609,
23178	3469625735,
23179	1431699370,
23180	673740880,
23181	3755965093,
23182	2358021891,
23183	2711746649,
23184	2307489801,
23185	218961690,
23186	3217021541,
23187	3873845719,
23188	1111672452,
23189	1751693520,
23190	1094828930,
23191	2576986153,
23192	757954394,
23193	252645662,
23194	2964376443,
23195	1414855848,
23196	3149649517,
23197	370555436
23198];
23199var T5 = [
23200	1374988112,
23201	2118214995,
23202	437757123,
23203	975658646,
23204	1001089995,
23205	530400753,
23206	2902087851,
23207	1273168787,
23208	540080725,
23209	2910219766,
23210	2295101073,
23211	4110568485,
23212	1340463100,
23213	3307916247,
23214	641025152,
23215	3043140495,
23216	3736164937,
23217	632953703,
23218	1172967064,
23219	1576976609,
23220	3274667266,
23221	2169303058,
23222	2370213795,
23223	1809054150,
23224	59727847,
23225	361929877,
23226	3211623147,
23227	2505202138,
23228	3569255213,
23229	1484005843,
23230	1239443753,
23231	2395588676,
23232	1975683434,
23233	4102977912,
23234	2572697195,
23235	666464733,
23236	3202437046,
23237	4035489047,
23238	3374361702,
23239	2110667444,
23240	1675577880,
23241	3843699074,
23242	2538681184,
23243	1649639237,
23244	2976151520,
23245	3144396420,
23246	4269907996,
23247	4178062228,
23248	1883793496,
23249	2403728665,
23250	2497604743,
23251	1383856311,
23252	2876494627,
23253	1917518562,
23254	3810496343,
23255	1716890410,
23256	3001755655,
23257	800440835,
23258	2261089178,
23259	3543599269,
23260	807962610,
23261	599762354,
23262	33778362,
23263	3977675356,
23264	2328828971,
23265	2809771154,
23266	4077384432,
23267	1315562145,
23268	1708848333,
23269	101039829,
23270	3509871135,
23271	3299278474,
23272	875451293,
23273	2733856160,
23274	92987698,
23275	2767645557,
23276	193195065,
23277	1080094634,
23278	1584504582,
23279	3178106961,
23280	1042385657,
23281	2531067453,
23282	3711829422,
23283	1306967366,
23284	2438237621,
23285	1908694277,
23286	67556463,
23287	1615861247,
23288	429456164,
23289	3602770327,
23290	2302690252,
23291	1742315127,
23292	2968011453,
23293	126454664,
23294	3877198648,
23295	2043211483,
23296	2709260871,
23297	2084704233,
23298	4169408201,
23299	0,
23300	159417987,
23301	841739592,
23302	504459436,
23303	1817866830,
23304	4245618683,
23305	260388950,
23306	1034867998,
23307	908933415,
23308	168810852,
23309	1750902305,
23310	2606453969,
23311	607530554,
23312	202008497,
23313	2472011535,
23314	3035535058,
23315	463180190,
23316	2160117071,
23317	1641816226,
23318	1517767529,
23319	470948374,
23320	3801332234,
23321	3231722213,
23322	1008918595,
23323	303765277,
23324	235474187,
23325	4069246893,
23326	766945465,
23327	337553864,
23328	1475418501,
23329	2943682380,
23330	4003061179,
23331	2743034109,
23332	4144047775,
23333	1551037884,
23334	1147550661,
23335	1543208500,
23336	2336434550,
23337	3408119516,
23338	3069049960,
23339	3102011747,
23340	3610369226,
23341	1113818384,
23342	328671808,
23343	2227573024,
23344	2236228733,
23345	3535486456,
23346	2935566865,
23347	3341394285,

23348	496906059,
23349	3702665459,
23350	226906860,
23351	2009195472,
23352	733156972,
23353	2842737049,
23354	294930682,
23355	1206477858,
23356	2835123396,
23357	2700099354,
23358	1451044056,
23359	573804783,
23360	2269728455,
23361	3644379585,
23362	2362090238,
23363	2564033334,
23364	2801107407,
23365	2776292904,
23366	3669462566,
23367	1068351396,
23368	742039012,
23369	1350078989,
23370	1784663195,
23371	1417561698,
23372	4136440770,
23373	2430122216,
23374	775550814,
23375	2193862645,
23376	2673705150,
23377	1775276924,
23378	1876241833,
23379	3475313331,
23380	3366754619,
23381	270040487,
23382	3902563182,
23383	3678124923,
23384	3441850377,
23385	1851332852,
23386	3969562369,
23387	2203032232,
23388	3868552805,
23389	2868897406,
23390	566021896,
23391	4011190502,
23392	3135740889,
23393	1248802510,
23394	3936291284,
23395	699432150,
23396	832877231,
23397	708780849,
23398	3332740144,
23399	899835584,
23400	1951317047,
23401	4236429990,
23402	3767586992,
23403	866637845,
23404	4043610186,
23405	1106041591,
23406	2144161806,
23407	395441711,
23408	1984812685,
23409	1139781709,
23410	3433712980,
23411	3835036895,
23412	2664543715,
23413	1282050075,
23414	3240894392,
23415	1181045119,
23416	2640243204,
23417	25965917,
23418	4203181171,
23419	4211818798,
23420	3009879386,
23421	2463879762,
23422	3910161971,
23423	1842759443,
23424	2597806476,
23425	933301370,
23426	1509430414,
23427	3943906441,
23428	3467192302,
23429	3076639029,
23430	3776767469,
23431	2051518780,
23432	2631065433,
23433	1441952575,
23434	404016761,
23435	1942435775,
23436	1408749034,
23437	1610459739,
23438	3745345300,
23439	2017778566,
23440	3400528769,
23441	3110650942,
23442	941896748,
23443	3265478751,
23444	371049330,
23445	3168937228,
23446	675039627,
23447	4279080257,
23448	967311729,
23449	135050206,
23450	3635733660,
23451	1683407248,
23452	2076935265,
23453	3576870512,
23454	1215061108,
23455	3501741890
23456];
23457var T6 = [
23458	1347548327,
23459	1400783205,
23460	3273267108,
23461	2520393566,
23462	3409685355,
23463	4045380933,
23464	2880240216,
23465	2471224067,
23466	1428173050,
23467	4138563181,
23468	2441661558,
23469	636813900,
23470	4233094615,
23471	3620022987,
23472	2149987652,
23473	2411029155,
23474	1239331162,
23475	1730525723,
23476	2554718734,
23477	3781033664,
23478	46346101,
23479	310463728,
23480	2743944855,
23481	3328955385,
23482	3875770207,
23483	2501218972,
23484	3955191162,
23485	3667219033,
23486	768917123,
23487	3545789473,
23488	692707433,
23489	1150208456,
23490	1786102409,
23491	2029293177,
23492	1805211710,
23493	3710368113,
23494	3065962831,
23495	401639597,
23496	1724457132,
23497	3028143674,
23498	409198410,
23499	2196052529,
23500	1620529459,
23501	1164071807,
23502	3769721975,
23503	2226875310,
23504	486441376,
23505	2499348523,
23506	1483753576,
23507	428819965,
23508	2274680428,
23509	3075636216,
23510	598438867,
23511	3799141122,
23512	1474502543,
23513	711349675,
23514	129166120,
23515	53458370,
23516	2592523643,
23517	2782082824,
23518	4063242375,
23519	2988687269,
23520	3120694122,
23521	1559041666,
23522	730517276,
23523	2460449204,
23524	4042459122,
23525	2706270690,
23526	3446004468,
23527	3573941694,
23528	533804130,
23529	2328143614,
23530	2637442643,
23531	2695033685,
23532	839224033,
23533	1973745387,
23534	957055980,
23535	2856345839,
23536	106852767,
23537	1371368976,
23538	4181598602,
23539	1033297158,
23540	2933734917,
23541	1179510461,
23542	3046200461,
23543	91341917,
23544	1862534868,
23545	4284502037,
23546	605657339,
23547	2547432937,
23548	3431546947,
23549	2003294622,
23550	3182487618,
23551	2282195339,
23552	954669403,
23553	3682191598,
23554	1201765386,
23555	3917234703,
23556	3388507166,
23557	0,
23558	2198438022,
23559	1211247597,
23560	2887651696,
23561	1315723890,
23562	4227665663,
23563	1443857720,
23564	507358933,
23565	657861945,
23566	1678381017,
23567	560487590,
23568	3516619604,
23569	975451694,
23570	2970356327,
23571	261314535,
23572	3535072918,
23573	2652609425,
23574	1333838021,
23575	2724322336,
23576	1767536459,
23577	370938394,
23578	182621114,
23579	3854606378,
23580	1128014560,
23581	487725847,
23582	185469197,
23583	2918353863,
23584	3106780840,
23585	3356761769,
23586	2237133081,
23587	1286567175,
23588	3152976349,
23589	4255350624,
23590	2683765030,
23591	3160175349,
23592	3309594171,
23593	878443390,
23594	1988838185,
23595	3704300486,
23596	1756818940,
23597	1673061617,
23598	3403100636,
23599	272786309,
23600	1075025698,
23601	545572369,
23602	2105887268,
23603	4174560061,
23604	296679730,
23605	1841768865,
23606	1260232239,
23607	4091327024,
23608	3960309330,
23609	3497509347,
23610	1814803222,
23611	2578018489,
23612	4195456072,
23613	575138148,
23614	3299409036,
23615	446754879,
23616	3629546796,
23617	4011996048,
23618	3347532110,
23619	3252238545,
23620	4270639778,
23621	915985419,
23622	3483825537,
23623	681933534,
23624	651868046,
23625	2755636671,
23626	3828103837,
23627	223377554,
23628	2607439820,
23629	1649704518,
23630	3270937875,
23631	3901806776,
23632	1580087799,
23633	4118987695,
23634	3198115200,
23635	2087309459,
23636	2842678573,
23637	3016697106,
23638	1003007129,
23639	2802849917,
23640	1860738147,
23641	2077965243,
23642	164439672,
23643	4100872472,
23644	32283319,
23645	2827177882,
23646	1709610350,
23647	2125135846,
23648	136428751,
23649	3874428392,
23650	3652904859,
23651	3460984630,
23652	3572145929,
23653	3593056380,
23654	2939266226,
23655	824852259,
23656	818324884,
23657	3224740454,
23658	930369212,

23659	2801566410,
23660	2967507152,
23661	355706840,
23662	1257309336,
23663	4148292826,
23664	243256656,
23665	790073846,
23666	2373340630,
23667	1296297904,
23668	1422699085,
23669	3756299780,
23670	3818836405,
23671	457992840,
23672	3099667487,
23673	2135319889,
23674	77422314,
23675	1560382517,
23676	1945798516,
23677	788204353,
23678	1521706781,
23679	1385356242,
23680	870912086,
23681	325965383,
23682	2358957921,
23683	2050466060,
23684	2388260884,
23685	2313884476,
23686	4006521127,
23687	901210569,
23688	3990953189,
23689	1014646705,
23690	1503449823,
23691	1062597235,
23692	2031621326,
23693	3212035895,
23694	3931371469,
23695	1533017514,
23696	350174575,
23697	2256028891,
23698	2177544179,
23699	1052338372,
23700	741876788,
23701	1606591296,
23702	1914052035,
23703	213705253,
23704	2334669897,
23705	1107234197,
23706	1899603969,
23707	3725069491,
23708	2631447780,
23709	2422494913,
23710	1635502980,
23711	1893020342,
23712	1950903388,
23713	1120974935
23714];
23715var T7 = [
23716	2807058932,
23717	1699970625,
23718	2764249623,
23719	1586903591,
23720	1808481195,
23721	1173430173,
23722	1487645946,
23723	59984867,
23724	4199882800,
23725	1844882806,
23726	1989249228,
23727	1277555970,
23728	3623636965,
23729	3419915562,
23730	1149249077,
23731	2744104290,
23732	1514790577,
23733	459744698,
23734	244860394,
23735	3235995134,
23736	1963115311,
23737	4027744588,
23738	2544078150,
23739	4190530515,
23740	1608975247,
23741	2627016082,
23742	2062270317,
23743	1507497298,
23744	2200818878,
23745	567498868,
23746	1764313568,
23747	3359936201,
23748	2305455554,
23749	2037970062,
23750	1047239e3,
23751	1910319033,
23752	1337376481,
23753	2904027272,
23754	2892417312,
23755	984907214,
23756	1243112415,
23757	830661914,
23758	861968209,
23759	2135253587,
23760	2011214180,
23761	2927934315,
23762	2686254721,
23763	731183368,
23764	1750626376,
23765	4246310725,
23766	1820824798,
23767	4172763771,
23768	3542330227,
23769	48394827,
23770	2404901663,
23771	2871682645,
23772	671593195,
23773	3254988725,
23774	2073724613,
23775	145085239,
23776	2280796200,
23777	2779915199,
23778	1790575107,
23779	2187128086,
23780	472615631,
23781	3029510009,
23782	4075877127,
23783	3802222185,
23784	4107101658,
23785	3201631749,
23786	1646252340,
23787	4270507174,
23788	1402811438,
23789	1436590835,
23790	3778151818,
23791	3950355702,
23792	3963161475,
23793	4020912224,
23794	2667994737,
23795	273792366,
23796	2331590177,
23797	104699613,
23798	95345982,
23799	3175501286,
23800	2377486676,
23801	1560637892,
23802	3564045318,
23803	369057872,
23804	4213447064,
23805	3919042237,
23806	1137477952,
23807	2658625497,
23808	1119727848,
23809	2340947849,
23810	1530455833,
23811	4007360968,
23812	172466556,
23813	266959938,
23814	516552836,
23815	0,
23816	2256734592,
23817	3980931627,
23818	1890328081,
23819	1917742170,
23820	4294704398,
23821	945164165,
23822	3575528878,
23823	958871085,
23824	3647212047,
23825	2787207260,
23826	1423022939,
23827	775562294,
23828	1739656202,
23829	3876557655,
23830	2530391278,
23831	2443058075,
23832	3310321856,
23833	547512796,
23834	1265195639,
23835	437656594,
23836	3121275539,
23837	719700128,
23838	3762502690,
23839	387781147,
23840	218828297,
23841	3350065803,
23842	2830708150,
23843	2848461854,
23844	428169201,
23845	122466165,
23846	3720081049,
23847	1627235199,
23848	648017665,
23849	4122762354,
23850	1002783846,
23851	2117360635,
23852	695634755,
23853	3336358691,
23854	4234721005,
23855	4049844452,
23856	3704280881,
23857	2232435299,
23858	574624663,
23859	287343814,
23860	612205898,
23861	1039717051,
23862	840019705,
23863	2708326185,
23864	793451934,
23865	821288114,
23866	1391201670,
23867	3822090177,
23868	376187827,
23869	3113855344,
23870	1224348052,
23871	1679968233,
23872	2361698556,
23873	1058709744,
23874	752375421,
23875	2431590963,
23876	1321699145,
23877	3519142200,
23878	2734591178,
23879	188127444,
23880	2177869557,
23881	3727205754,
23882	2384911031,
23883	3215212461,
23884	2648976442,
23885	2450346104,
23886	3432737375,
23887	1180849278,
23888	331544205,
23889	3102249176,
23890	4150144569,
23891	2952102595,
23892	2159976285,
23893	2474404304,
23894	766078933,
23895	313773861,
23896	2570832044,
23897	2108100632,
23898	1668212892,
23899	3145456443,
23900	2013908262,
23901	418672217,
23902	3070356634,
23903	2594734927,
23904	1852171925,
23905	3867060991,
23906	3473416636,
23907	3907448597,
23908	2614737639,
23909	919489135,
23910	164948639,
23911	2094410160,
23912	2997825956,
23913	590424639,
23914	2486224549,
23915	1723872674,
23916	3157750862,
23917	3399941250,
23918	3501252752,
23919	3625268135,
23920	2555048196,
23921	3673637356,

23922	1343127501,
23923	4130281361,
23924	3599595085,
23925	2957853679,
23926	1297403050,
23927	81781910,
23928	3051593425,
23929	2283490410,
23930	532201772,
23931	1367295589,
23932	3926170974,
23933	895287692,
23934	1953757831,
23935	1093597963,
23936	492483431,
23937	3528626907,
23938	1446242576,
23939	1192455638,
23940	1636604631,
23941	209336225,
23942	344873464,
23943	1015671571,
23944	669961897,
23945	3375740769,
23946	3857572124,
23947	2973530695,
23948	3747192018,
23949	1933530610,
23950	3464042516,
23951	935293895,
23952	3454686199,
23953	2858115069,
23954	1863638845,
23955	3683022916,
23956	4085369519,
23957	3292445032,
23958	875313188,
23959	1080017571,
23960	3279033885,
23961	621591778,
23962	1233856572,
23963	2504130317,
23964	24197544,
23965	3017672716,
23966	3835484340,
23967	3247465558,
23968	2220981195,
23969	3060847922,
23970	1551124588,
23971	1463996600
23972];
23973var T8 = [
23974	4104605777,
23975	1097159550,
23976	396673818,
23977	660510266,
23978	2875968315,
23979	2638606623,
23980	4200115116,
23981	3808662347,
23982	821712160,
23983	1986918061,
23984	3430322568,
23985	38544885,
23986	3856137295,
23987	718002117,
23988	893681702,
23989	1654886325,
23990	2975484382,
23991	3122358053,
23992	3926825029,
23993	4274053469,
23994	796197571,
23995	1290801793,
23996	1184342925,
23997	3556361835,
23998	2405426947,
23999	2459735317,
24000	1836772287,
24001	1381620373,
24002	3196267988,
24003	1948373848,
24004	3764988233,
24005	3385345166,
24006	3263785589,
24007	2390325492,
24008	1480485785,
24009	3111247143,
24010	3780097726,
24011	2293045232,
24012	548169417,
24013	3459953789,
24014	3746175075,
24015	439452389,
24016	1362321559,
24017	1400849762,
24018	1685577905,
24019	1806599355,
24020	2174754046,
24021	137073913,
24022	1214797936,
24023	1174215055,
24024	3731654548,
24025	2079897426,
24026	1943217067,
24027	1258480242,
24028	529487843,
24029	1437280870,
24030	3945269170,
24031	3049390895,
24032	3313212038,
24033	923313619,
24034	679998e3,
24035	3215307299,
24036	57326082,
24037	377642221,
24038	3474729866,
24039	2041877159,
24040	133361907,
24041	1776460110,
24042	3673476453,
24043	96392454,
24044	878845905,
24045	2801699524,
24046	777231668,
24047	4082475170,
24048	2330014213,
24049	4142626212,
24050	2213296395,
24051	1626319424,
24052	1906247262,
24053	1846563261,
24054	562755902,
24055	3708173718,
24056	1040559837,
24057	3871163981,
24058	1418573201,
24059	3294430577,
24060	114585348,
24061	1343618912,
24062	2566595609,
24063	3186202582,
24064	1078185097,
24065	3651041127,
24066	3896688048,
24067	2307622919,
24068	425408743,
24069	3371096953,
24070	2081048481,
24071	1108339068,
24072	2216610296,
24073	0,
24074	2156299017,
24075	736970802,
24076	292596766,
24077	1517440620,
24078	251657213,
24079	2235061775,
24080	2933202493,
24081	758720310,
24082	265905162,
24083	1554391400,
24084	1532285339,
24085	908999204,
24086	174567692,
24087	1474760595,
24088	4002861748,
24089	2610011675,
24090	3234156416,
24091	3693126241,
24092	2001430874,
24093	303699484,
24094	2478443234,
24095	2687165888,
24096	585122620,
24097	454499602,
24098	151849742,
24099	2345119218,
24100	3064510765,
24101	514443284,
24102	4044981591,
24103	1963412655,
24104	2581445614,
24105	2137062819,
24106	19308535,
24107	1928707164,
24108	1715193156,
24109	4219352155,
24110	1126790795,
24111	600235211,
24112	3992742070,
24113	3841024952,
24114	836553431,
24115	1669664834,
24116	2535604243,
24117	3323011204,
24118	1243905413,
24119	3141400786,
24120	4180808110,
24121	698445255,
24122	2653899549,
24123	2989552604,
24124	2253581325,
24125	3252932727,
24126	3004591147,
24127	1891211689,
24128	2487810577,
24129	3915653703,
24130	4237083816,
24131	4030667424,
24132	2100090966,
24133	865136418,
24134	1229899655,
24135	953270745,
24136	3399679628,
24137	3557504664,
24138	4118925222,
24139	2061379749,
24140	3079546586,
24141	2915017791,
24142	983426092,
24143	2022837584,
24144	1607244650,
24145	2118541908,
24146	2366882550,
24147	3635996816,
24148	972512814,
24149	3283088770,
24150	1568718495,
24151	3499326569,
24152	3576539503,
24153	621982671,
24154	2895723464,
24155	410887952,
24156	2623762152,
24157	1002142683,
24158	645401037,
24159	1494807662,
24160	2595684844,
24161	1335535747,
24162	2507040230,
24163	4293295786,
24164	3167684641,
24165	367585007,
24166	3885750714,
24167	1865862730,
24168	2668221674,
24169	2960971305,
24170	2763173681,
24171	1059270954,
24172	2777952454,
24173	2724642869,
24174	1320957812,
24175	2194319100,
24176	2429595872,
24177	2815956275,
24178	77089521,
24179	3973773121,
24180	3444575871,
24181	2448830231,
24182	1305906550,
24183	4021308739,
24184	2857194700,
24185	2516901860,
24186	3518358430,
24187	1787304780,
24188	740276417,
24189	1699839814,
24190	1592394909,
24191	2352307457,
24192	2272556026,
24193	188821243,
24194	1729977011,
24195	3687994002,
24196	274084841,
24197	3594982253,
24198	3613494426,
24199	2701949495,
24200	4162096729,
24201	322734571,
24202	2837966542,
24203	1640576439,
24204	484830689,
24205	1202797690,
24206	3537852828,
24207	4067639125,
24208	349075736,
24209	3342319475,
24210	4157467219,
24211	4255800159,
24212	1030690015,
24213	1155237496,
24214	2951971274,
24215	1757691577,
24216	607398968,
24217	2738905026,
24218	499347990,
24219	3794078908,
24220	1011452712,
24221	227885567,
24222	2818666809,
24223	213114376,
24224	3034881240,
24225	1455525988,
24226	3414450555,
24227	850817237,
24228	1817998408,
24229	3092726480
24230];
24231var U1 = [
24232	0,
24233	235474187,
24234	470948374,
24235	303765277,
24236	941896748,
24237	908933415,
24238	607530554,
24239	708780849,
24240	1883793496,
24241	2118214995,
24242	1817866830,
24243	1649639237,
24244	1215061108,
24245	1181045119,
24246	1417561698,
24247	1517767529,
24248	3767586992,
24249	4003061179,
24250	4236429990,
24251	4069246893,
24252	3635733660,
24253	3602770327,
24254	3299278474,
24255	3400528769,
24256	2430122216,
24257	2664543715,
24258	2362090238,
24259	2193862645,
24260	2835123396,
24261	2801107407,
24262	3035535058,
24263	3135740889,
24264	3678124923,
24265	3576870512,
24266	3341394285,
24267	3374361702,
24268	3810496343,
24269	3977675356,
24270	4279080257,
24271	4043610186,
24272	2876494627,
24273	2776292904,
24274	3076639029,
24275	3110650942,
24276	2472011535,
24277	2640243204,
24278	2403728665,
24279	2169303058,
24280	1001089995,
24281	899835584,
24282	666464733,
24283	699432150,
24284	59727847,
24285	226906860,
24286	530400753,
24287	294930682,
24288	1273168787,
24289	1172967064,
24290	1475418501,
24291	1509430414,
24292	1942435775,
24293	2110667444,
24294	1876241833,
24295	1641816226,
24296	2910219766,
24297	2743034109,
24298	2976151520,
24299	3211623147,
24300	2505202138,
24301	2606453969,
24302	2302690252,
24303	2269728455,
24304	3711829422,
24305	3543599269,
24306	3240894392,
24307	3475313331,
24308	3843699074,
24309	3943906441,
24310	4178062228,
24311	4144047775,
24312	1306967366,
24313	1139781709,
24314	1374988112,
24315	1610459739,
24316	1975683434,
24317	2076935265,
24318	1775276924,
24319	1742315127,
24320	1034867998,
24321	866637845,
24322	566021896,
24323	800440835,
24324	92987698,
24325	193195065,
24326	429456164,
24327	395441711,
24328	1984812685,
24329	2017778566,
24330	1784663195,
24331	1683407248,
24332	1315562145,
24333	1080094634,
24334	1383856311,
24335	1551037884,
24336	101039829,
24337	135050206,
24338	437757123,
24339	337553864,
24340	1042385657,
24341	807962610,
24342	573804783,
24343	742039012,
24344	2531067453,
24345	2564033334,
24346	2328828971,
24347	2227573024,
24348	2935566865,
24349	2700099354,
24350	3001755655,
24351	3168937228,
24352	3868552805,
24353	3902563182,
24354	4203181171,
24355	4102977912,
24356	3736164937,
24357	3501741890,
24358	3265478751,
24359	3433712980,
24360	1106041591,
24361	1340463100,
24362	1576976609,
24363	1408749034,
24364	2043211483,
24365	2009195472,
24366	1708848333,
24367	1809054150,
24368	832877231,
24369	1068351396,
24370	766945465,
24371	599762354,
24372	159417987,
24373	126454664,
24374	361929877,
24375	463180190,
24376	2709260871,
24377	2943682380,
24378	3178106961,
24379	3009879386,
24380	2572697195,
24381	2538681184,
24382	2236228733,
24383	2336434550,
24384	3509871135,
24385	3745345300,
24386	3441850377,
24387	3274667266,
24388	3910161971,
24389	3877198648,

24390	4110568485,
24391	4211818798,
24392	2597806476,
24393	2497604743,
24394	2261089178,
24395	2295101073,
24396	2733856160,
24397	2902087851,
24398	3202437046,
24399	2968011453,
24400	3936291284,
24401	3835036895,
24402	4136440770,
24403	4169408201,
24404	3535486456,
24405	3702665459,
24406	3467192302,
24407	3231722213,
24408	2051518780,
24409	1951317047,
24410	1716890410,
24411	1750902305,
24412	1113818384,
24413	1282050075,
24414	1584504582,
24415	1350078989,
24416	168810852,
24417	67556463,
24418	371049330,
24419	404016761,
24420	841739592,
24421	1008918595,
24422	775550814,
24423	540080725,
24424	3969562369,
24425	3801332234,
24426	4035489047,
24427	4269907996,
24428	3569255213,
24429	3669462566,
24430	3366754619,
24431	3332740144,
24432	2631065433,
24433	2463879762,
24434	2160117071,
24435	2395588676,
24436	2767645557,
24437	2868897406,
24438	3102011747,
24439	3069049960,
24440	202008497,
24441	33778362,
24442	270040487,
24443	504459436,
24444	875451293,
24445	975658646,
24446	675039627,
24447	641025152,
24448	2084704233,
24449	1917518562,
24450	1615861247,
24451	1851332852,
24452	1147550661,
24453	1248802510,
24454	1484005843,
24455	1451044056,
24456	933301370,
24457	967311729,
24458	733156972,
24459	632953703,
24460	260388950,
24461	25965917,
24462	328671808,
24463	496906059,
24464	1206477858,
24465	1239443753,
24466	1543208500,
24467	1441952575,
24468	2144161806,
24469	1908694277,
24470	1675577880,
24471	1842759443,
24472	3610369226,
24473	3644379585,
24474	3408119516,
24475	3307916247,
24476	4011190502,
24477	3776767469,
24478	4077384432,
24479	4245618683,
24480	2809771154,
24481	2842737049,
24482	3144396420,
24483	3043140495,
24484	2673705150,
24485	2438237621,
24486	2203032232,
24487	2370213795
24488];
24489var U2 = [
24490	0,
24491	185469197,
24492	370938394,
24493	487725847,
24494	741876788,
24495	657861945,
24496	975451694,
24497	824852259,
24498	1483753576,
24499	1400783205,
24500	1315723890,
24501	1164071807,
24502	1950903388,
24503	2135319889,
24504	1649704518,
24505	1767536459,
24506	2967507152,
24507	3152976349,
24508	2801566410,
24509	2918353863,
24510	2631447780,
24511	2547432937,
24512	2328143614,
24513	2177544179,
24514	3901806776,
24515	3818836405,
24516	4270639778,
24517	4118987695,
24518	3299409036,
24519	3483825537,
24520	3535072918,
24521	3652904859,
24522	2077965243,
24523	1893020342,
24524	1841768865,
24525	1724457132,
24526	1474502543,
24527	1559041666,
24528	1107234197,
24529	1257309336,
24530	598438867,
24531	681933534,
24532	901210569,
24533	1052338372,
24534	261314535,
24535	77422314,
24536	428819965,
24537	310463728,
24538	3409685355,
24539	3224740454,
24540	3710368113,
24541	3593056380,
24542	3875770207,
24543	3960309330,
24544	4045380933,
24545	4195456072,
24546	2471224067,
24547	2554718734,
24548	2237133081,
24549	2388260884,
24550	3212035895,
24551	3028143674,
24552	2842678573,
24553	2724322336,
24554	4138563181,
24555	4255350624,
24556	3769721975,
24557	3955191162,
24558	3667219033,
24559	3516619604,
24560	3431546947,
24561	3347532110,
24562	2933734917,
24563	2782082824,
24564	3099667487,
24565	3016697106,
24566	2196052529,
24567	2313884476,
24568	2499348523,
24569	2683765030,
24570	1179510461,
24571	1296297904,
24572	1347548327,
24573	1533017514,
24574	1786102409,
24575	1635502980,
24576	2087309459,
24577	2003294622,
24578	507358933,
24579	355706840,
24580	136428751,
24581	53458370,
24582	839224033,
24583	957055980,
24584	605657339,
24585	790073846,
24586	2373340630,
24587	2256028891,
24588	2607439820,
24589	2422494913,
24590	2706270690,
24591	2856345839,
24592	3075636216,
24593	3160175349,
24594	3573941694,
24595	3725069491,
24596	3273267108,
24597	3356761769,
24598	4181598602,
24599	4063242375,
24600	4011996048,
24601	3828103837,
24602	1033297158,
24603	915985419,
24604	730517276,
24605	545572369,
24606	296679730,
24607	446754879,
24608	129166120,
24609	213705253,
24610	1709610350,
24611	1860738147,
24612	1945798516,
24613	2029293177,
24614	1239331162,
24615	1120974935,
24616	1606591296,
24617	1422699085,
24618	4148292826,
24619	4233094615,
24620	3781033664,
24621	3931371469,
24622	3682191598,
24623	3497509347,
24624	3446004468,
24625	3328955385,
24626	2939266226,
24627	2755636671,
24628	3106780840,
24629	2988687269,
24630	2198438022,
24631	2282195339,
24632	2501218972,
24633	2652609425,
24634	1201765386,
24635	1286567175,
24636	1371368976,
24637	1521706781,
24638	1805211710,
24639	1620529459,
24640	2105887268,
24641	1988838185,
24642	533804130,
24643	350174575,
24644	164439672,
24645	46346101,
24646	870912086,
24647	954669403,
24648	636813900,
24649	788204353,
24650	2358957921,
24651	2274680428,
24652	2592523643,
24653	2441661558,
24654	2695033685,
24655	2880240216,
24656	3065962831,
24657	3182487618,
24658	3572145929,
24659	3756299780,
24660	3270937875,
24661	3388507166,
24662	4174560061,
24663	4091327024,
24664	4006521127,
24665	3854606378,
24666	1014646705,
24667	930369212,
24668	711349675,
24669	560487590,
24670	272786309,
24671	457992840,
24672	106852767,
24673	223377554,
24674	1678381017,
24675	1862534868,
24676	1914052035,
24677	2031621326,
24678	1211247597,
24679	1128014560,
24680	1580087799,
24681	1428173050,
24682	32283319,
24683	182621114,
24684	401639597,
24685	486441376,
24686	768917123,
24687	651868046,
24688	1003007129,
24689	818324884,
24690	1503449823,
24691	1385356242,
24692	1333838021,
24693	1150208456,
24694	1973745387,
24695	2125135846,
24696	1673061617,
24697	1756818940,
24698	2970356327,
24699	3120694122,
24700	2802849917,
24701	2887651696,
24702	2637442643,
24703	2520393566,
24704	2334669897,
24705	2149987652,
24706	3917234703,
24707	3799141122,
24708	4284502037,
24709	4100872472,
24710	3309594171,
24711	3460984630,
24712	3545789473,
24713	3629546796,
24714	2050466060,
24715	1899603969,
24716	1814803222,
24717	1730525723,
24718	1443857720,
24719	1560382517,
24720	1075025698,
24721	1260232239,
24722	575138148,
24723	692707433,
24724	878443390,
24725	1062597235,
24726	243256656,
24727	91341917,
24728	409198410,
24729	325965383,
24730	3403100636,
24731	3252238545,
24732	3704300486,
24733	3620022987,
24734	3874428392,
24735	3990953189,
24736	4042459122,
24737	4227665663,
24738	2460449204,
24739	2578018489,
24740	2226875310,
24741	2411029155,

24742	3198115200,
24743	3046200461,
24744	2827177882,
24745	2743944855
24746];
24747var U3 = [
24748	0,
24749	218828297,
24750	437656594,
24751	387781147,
24752	875313188,
24753	958871085,
24754	775562294,
24755	590424639,
24756	1750626376,
24757	1699970625,
24758	1917742170,
24759	2135253587,
24760	1551124588,
24761	1367295589,
24762	1180849278,
24763	1265195639,
24764	3501252752,
24765	3720081049,
24766	3399941250,
24767	3350065803,
24768	3835484340,
24769	3919042237,
24770	4270507174,
24771	4085369519,
24772	3102249176,
24773	3051593425,
24774	2734591178,
24775	2952102595,
24776	2361698556,
24777	2177869557,
24778	2530391278,
24779	2614737639,
24780	3145456443,
24781	3060847922,
24782	2708326185,
24783	2892417312,
24784	2404901663,
24785	2187128086,
24786	2504130317,
24787	2555048196,
24788	3542330227,
24789	3727205754,
24790	3375740769,
24791	3292445032,
24792	3876557655,
24793	3926170974,
24794	4246310725,
24795	4027744588,
24796	1808481195,
24797	1723872674,
24798	1910319033,
24799	2094410160,
24800	1608975247,
24801	1391201670,
24802	1173430173,
24803	1224348052,
24804	59984867,
24805	244860394,
24806	428169201,
24807	344873464,
24808	935293895,
24809	984907214,
24810	766078933,
24811	547512796,
24812	1844882806,
24813	1627235199,
24814	2011214180,
24815	2062270317,
24816	1507497298,
24817	1423022939,
24818	1137477952,
24819	1321699145,
24820	95345982,
24821	145085239,
24822	532201772,
24823	313773861,
24824	830661914,
24825	1015671571,
24826	731183368,
24827	648017665,
24828	3175501286,
24829	2957853679,
24830	2807058932,
24831	2858115069,
24832	2305455554,
24833	2220981195,
24834	2474404304,
24835	2658625497,
24836	3575528878,
24837	3625268135,
24838	3473416636,
24839	3254988725,
24840	3778151818,
24841	3963161475,
24842	4213447064,
24843	4130281361,
24844	3599595085,
24845	3683022916,
24846	3432737375,
24847	3247465558,
24848	3802222185,
24849	4020912224,
24850	4172763771,
24851	4122762354,
24852	3201631749,
24853	3017672716,
24854	2764249623,
24855	2848461854,
24856	2331590177,
24857	2280796200,
24858	2431590963,
24859	2648976442,
24860	104699613,
24861	188127444,
24862	472615631,
24863	287343814,
24864	840019705,
24865	1058709744,
24866	671593195,
24867	621591778,
24868	1852171925,
24869	1668212892,
24870	1953757831,
24871	2037970062,
24872	1514790577,
24873	1463996600,
24874	1080017571,
24875	1297403050,
24876	3673637356,
24877	3623636965,
24878	3235995134,
24879	3454686199,
24880	4007360968,
24881	3822090177,
24882	4107101658,
24883	4190530515,
24884	2997825956,
24885	3215212461,
24886	2830708150,
24887	2779915199,
24888	2256734592,
24889	2340947849,
24890	2627016082,
24891	2443058075,
24892	172466556,
24893	122466165,
24894	273792366,
24895	492483431,
24896	1047239e3,
24897	861968209,
24898	612205898,
24899	695634755,
24900	1646252340,
24901	1863638845,
24902	2013908262,
24903	1963115311,
24904	1446242576,
24905	1530455833,
24906	1277555970,
24907	1093597963,
24908	1636604631,
24909	1820824798,
24910	2073724613,
24911	1989249228,
24912	1436590835,
24913	1487645946,
24914	1337376481,
24915	1119727848,
24916	164948639,
24917	81781910,
24918	331544205,
24919	516552836,
24920	1039717051,
24921	821288114,
24922	669961897,
24923	719700128,
24924	2973530695,
24925	3157750862,
24926	2871682645,
24927	2787207260,
24928	2232435299,
24929	2283490410,
24930	2667994737,
24931	2450346104,
24932	3647212047,
24933	3564045318,
24934	3279033885,
24935	3464042516,
24936	3980931627,
24937	3762502690,
24938	4150144569,
24939	4199882800,
24940	3070356634,
24941	3121275539,
24942	2904027272,
24943	2686254721,
24944	2200818878,
24945	2384911031,
24946	2570832044,
24947	2486224549,
24948	3747192018,
24949	3528626907,
24950	3310321856,
24951	3359936201,
24952	3950355702,
24953	3867060991,
24954	4049844452,
24955	4234721005,
24956	1739656202,
24957	1790575107,
24958	2108100632,
24959	1890328081,
24960	1402811438,
24961	1586903591,
24962	1233856572,
24963	1149249077,
24964	266959938,
24965	48394827,
24966	369057872,
24967	418672217,
24968	1002783846,
24969	919489135,
24970	567498868,
24971	752375421,
24972	209336225,
24973	24197544,
24974	376187827,
24975	459744698,
24976	945164165,
24977	895287692,
24978	574624663,
24979	793451934,
24980	1679968233,
24981	1764313568,
24982	2117360635,
24983	1933530610,
24984	1343127501,
24985	1560637892,
24986	1243112415,
24987	1192455638,
24988	3704280881,
24989	3519142200,
24990	3336358691,
24991	3419915562,
24992	3907448597,
24993	3857572124,
24994	4075877127,
24995	4294704398,
24996	3029510009,
24997	3113855344,
24998	2927934315,
24999	2744104290,
25000	2159976285,
25001	2377486676,
25002	2594734927,
25003	2544078150
25004];
25005var U4 = [
25006	0,
25007	151849742,
25008	303699484,
25009	454499602,
25010	607398968,
25011	758720310,
25012	908999204,
25013	1059270954,
25014	1214797936,
25015	1097159550,
25016	1517440620,
25017	1400849762,
25018	1817998408,
25019	1699839814,
25020	2118541908,
25021	2001430874,
25022	2429595872,
25023	2581445614,
25024	2194319100,
25025	2345119218,
25026	3034881240,
25027	3186202582,
25028	2801699524,
25029	2951971274,
25030	3635996816,
25031	3518358430,
25032	3399679628,
25033	3283088770,
25034	4237083816,
25035	4118925222,
25036	4002861748,
25037	3885750714,
25038	1002142683,
25039	850817237,
25040	698445255,
25041	548169417,
25042	529487843,
25043	377642221,
25044	227885567,
25045	77089521,
25046	1943217067,
25047	2061379749,
25048	1640576439,
25049	1757691577,
25050	1474760595,
25051	1592394909,
25052	1174215055,
25053	1290801793,
25054	2875968315,
25055	2724642869,
25056	3111247143,
25057	2960971305,
25058	2405426947,
25059	2253581325,
25060	2638606623,
25061	2487810577,
25062	3808662347,
25063	3926825029,
25064	4044981591,
25065	4162096729,
25066	3342319475,
25067	3459953789,

25068	3576539503,
25069	3693126241,
25070	1986918061,
25071	2137062819,
25072	1685577905,
25073	1836772287,
25074	1381620373,
25075	1532285339,
25076	1078185097,
25077	1229899655,
25078	1040559837,
25079	923313619,
25080	740276417,
25081	621982671,
25082	439452389,
25083	322734571,
25084	137073913,
25085	19308535,
25086	3871163981,
25087	4021308739,
25088	4104605777,
25089	4255800159,
25090	3263785589,
25091	3414450555,
25092	3499326569,
25093	3651041127,
25094	2933202493,
25095	2815956275,
25096	3167684641,
25097	3049390895,
25098	2330014213,
25099	2213296395,
25100	2566595609,
25101	2448830231,
25102	1305906550,
25103	1155237496,
25104	1607244650,
25105	1455525988,
25106	1776460110,
25107	1626319424,
25108	2079897426,
25109	1928707164,
25110	96392454,
25111	213114376,
25112	396673818,
25113	514443284,
25114	562755902,
25115	679998e3,
25116	865136418,
25117	983426092,
25118	3708173718,
25119	3557504664,
25120	3474729866,
25121	3323011204,
25122	4180808110,
25123	4030667424,
25124	3945269170,
25125	3794078908,
25126	2507040230,
25127	2623762152,
25128	2272556026,
25129	2390325492,
25130	2975484382,
25131	3092726480,
25132	2738905026,
25133	2857194700,
25134	3973773121,
25135	3856137295,
25136	4274053469,
25137	4157467219,
25138	3371096953,
25139	3252932727,
25140	3673476453,
25141	3556361835,
25142	2763173681,
25143	2915017791,
25144	3064510765,
25145	3215307299,
25146	2156299017,
25147	2307622919,
25148	2459735317,
25149	2610011675,
25150	2081048481,
25151	1963412655,
25152	1846563261,
25153	1729977011,
25154	1480485785,
25155	1362321559,
25156	1243905413,
25157	1126790795,
25158	878845905,
25159	1030690015,
25160	645401037,
25161	796197571,
25162	274084841,
25163	425408743,
25164	38544885,
25165	188821243,
25166	3613494426,
25167	3731654548,
25168	3313212038,
25169	3430322568,
25170	4082475170,
25171	4200115116,
25172	3780097726,
25173	3896688048,
25174	2668221674,
25175	2516901860,
25176	2366882550,
25177	2216610296,
25178	3141400786,
25179	2989552604,
25180	2837966542,
25181	2687165888,
25182	1202797690,
25183	1320957812,
25184	1437280870,
25185	1554391400,
25186	1669664834,
25187	1787304780,
25188	1906247262,
25189	2022837584,
25190	265905162,
25191	114585348,
25192	499347990,
25193	349075736,
25194	736970802,
25195	585122620,
25196	972512814,
25197	821712160,
25198	2595684844,
25199	2478443234,
25200	2293045232,
25201	2174754046,
25202	3196267988,
25203	3079546586,
25204	2895723464,
25205	2777952454,
25206	3537852828,
25207	3687994002,
25208	3234156416,
25209	3385345166,
25210	4142626212,
25211	4293295786,
25212	3841024952,
25213	3992742070,
25214	174567692,
25215	57326082,
25216	410887952,
25217	292596766,
25218	777231668,
25219	660510266,
25220	1011452712,
25221	893681702,
25222	1108339068,
25223	1258480242,
25224	1343618912,
25225	1494807662,
25226	1715193156,
25227	1865862730,
25228	1948373848,
25229	2100090966,
25230	2701949495,
25231	2818666809,
25232	3004591147,
25233	3122358053,
25234	2235061775,
25235	2352307457,
25236	2535604243,
25237	2653899549,
25238	3915653703,
25239	3764988233,
25240	4219352155,
25241	4067639125,
25242	3444575871,
25243	3294430577,
25244	3746175075,
25245	3594982253,
25246	836553431,
25247	953270745,
25248	600235211,
25249	718002117,
25250	367585007,
25251	484830689,
25252	133361907,
25253	251657213,
25254	2041877159,
25255	1891211689,
25256	1806599355,
25257	1654886325,
25258	1568718495,
25259	1418573201,
25260	1335535747,
25261	1184342925
25262];
25263function convertToInt32(bytes) {
25264	const result = [];
25265	for (let i = 0; i < bytes.length; i += 4) result.push(bytes[i] << 24 | bytes[i + 1] << 16 | bytes[i + 2] << 8 | bytes[i + 3]);
25266	return result;
25267}
25268var AES = class AES {
25269	get key() {
25270		return __classPrivateFieldGet$2(this, _AES_key, "f").slice();
25271	}
25272	constructor(key) {
25273		_AES_key.set(this, void 0);
25274		_AES_Kd.set(this, void 0);
25275		_AES_Ke.set(this, void 0);
25276		if (!(this instanceof AES)) throw Error("AES must be instanitated with `new`");
25277		__classPrivateFieldSet$2(this, _AES_key, new Uint8Array(key), "f");
25278		const rounds = numberOfRounds[this.key.length];
25279		if (rounds == null) throw new TypeError("invalid key size (must be 16, 24 or 32 bytes)");
25280		__classPrivateFieldSet$2(this, _AES_Ke, [], "f");
25281		__classPrivateFieldSet$2(this, _AES_Kd, [], "f");
25282		for (let i = 0; i <= rounds; i++) {
25283			__classPrivateFieldGet$2(this, _AES_Ke, "f").push([
25284				0,
25285				0,
25286				0,
25287				0
25288			]);
25289			__classPrivateFieldGet$2(this, _AES_Kd, "f").push([
25290				0,
25291				0,
25292				0,
25293				0
25294			]);
25295		}
25296		const roundKeyCount = (rounds + 1) * 4;
25297		const KC = this.key.length / 4;
25298		const tk = convertToInt32(this.key);
25299		let index;
25300		for (let i = 0; i < KC; i++) {
25301			index = i >> 2;
25302			__classPrivateFieldGet$2(this, _AES_Ke, "f")[index][i % 4] = tk[i];
25303			__classPrivateFieldGet$2(this, _AES_Kd, "f")[rounds - index][i % 4] = tk[i];
25304		}
25305		let rconpointer = 0;
25306		let t = KC, tt;
25307		while (t < roundKeyCount) {
25308			tt = tk[KC - 1];
25309			tk[0] ^= S[tt >> 16 & 255] << 24 ^ S[tt >> 8 & 255] << 16 ^ S[tt & 255] << 8 ^ S[tt >> 24 & 255] ^ rcon[rconpointer] << 24;
25310			rconpointer += 1;
25311			if (KC != 8) for (let i = 1; i < KC; i++) tk[i] ^= tk[i - 1];
25312			else {
25313				for (let i = 1; i < KC / 2; i++) tk[i] ^= tk[i - 1];
25314				tt = tk[KC / 2 - 1];
25315				tk[KC / 2] ^= S[tt & 255] ^ S[tt >> 8 & 255] << 8 ^ S[tt >> 16 & 255] << 16 ^ S[tt >> 24 & 255] << 24;
25316				for (let i = KC / 2 + 1; i < KC; i++) tk[i] ^= tk[i - 1];
25317			}
25318			let i = 0, r, c;
25319			while (i < KC && t < roundKeyCount) {
25320				r = t >> 2;
25321				c = t % 4;
25322				__classPrivateFieldGet$2(this, _AES_Ke, "f")[r][c] = tk[i];
25323				__classPrivateFieldGet$2(this, _AES_Kd, "f")[rounds - r][c] = tk[i++];
25324				t++;
25325			}
25326		}
25327		for (let r = 1; r < rounds; r++) for (let c = 0; c < 4; c++) {
25328			tt = __classPrivateFieldGet$2(this, _AES_Kd, "f")[r][c];
25329			__classPrivateFieldGet$2(this, _AES_Kd, "f")[r][c] = U1[tt >> 24 & 255] ^ U2[tt >> 16 & 255] ^ U3[tt >> 8 & 255] ^ U4[tt & 255];
25330		}
25331	}
25332	encrypt(plaintext) {
25333		if (plaintext.length != 16) throw new TypeError("invalid plaintext size (must be 16 bytes)");
25334		const rounds = __classPrivateFieldGet$2(this, _AES_Ke, "f").length - 1;
25335		const a = [
25336			0,
25337			0,
25338			0,
25339			0
25340		];
25341		let t = convertToInt32(plaintext);
25342		for (let i = 0; i < 4; i++) t[i] ^= __classPrivateFieldGet$2(this, _AES_Ke, "f")[0][i];
25343		for (let r = 1; r < rounds; r++) {
25344			for (let i = 0; i < 4; i++) a[i] = T1[t[i] >> 24 & 255] ^ T2[t[(i + 1) % 4] >> 16 & 255] ^ T3[t[(i + 2) % 4] >> 8 & 255] ^ T4[t[(i + 3) % 4] & 255] ^ __classPrivateFieldGet$2(this, _AES_Ke, "f")[r][i];
25345			t = a.slice();
25346		}
25347		const result = /* @__PURE__ */ new Uint8Array(16);
25348		let tt = 0;
25349		for (let i = 0; i < 4; i++) {
25350			tt = __classPrivateFieldGet$2(this, _AES_Ke, "f")[rounds][i];

25351			result[4 * i] = (S[t[i] >> 24 & 255] ^ tt >> 24) & 255;
25352			result[4 * i + 1] = (S[t[(i + 1) % 4] >> 16 & 255] ^ tt >> 16) & 255;
25353			result[4 * i + 2] = (S[t[(i + 2) % 4] >> 8 & 255] ^ tt >> 8) & 255;
25354			result[4 * i + 3] = (S[t[(i + 3) % 4] & 255] ^ tt) & 255;
25355		}
25356		return result;
25357	}
25358	decrypt(ciphertext) {
25359		if (ciphertext.length != 16) throw new TypeError("invalid ciphertext size (must be 16 bytes)");
25360		const rounds = __classPrivateFieldGet$2(this, _AES_Kd, "f").length - 1;
25361		const a = [
25362			0,
25363			0,
25364			0,
25365			0
25366		];
25367		let t = convertToInt32(ciphertext);
25368		for (let i = 0; i < 4; i++) t[i] ^= __classPrivateFieldGet$2(this, _AES_Kd, "f")[0][i];
25369		for (let r = 1; r < rounds; r++) {
25370			for (let i = 0; i < 4; i++) a[i] = T5[t[i] >> 24 & 255] ^ T6[t[(i + 3) % 4] >> 16 & 255] ^ T7[t[(i + 2) % 4] >> 8 & 255] ^ T8[t[(i + 1) % 4] & 255] ^ __classPrivateFieldGet$2(this, _AES_Kd, "f")[r][i];
25371			t = a.slice();
25372		}
25373		const result = /* @__PURE__ */ new Uint8Array(16);
25374		let tt = 0;
25375		for (let i = 0; i < 4; i++) {
25376			tt = __classPrivateFieldGet$2(this, _AES_Kd, "f")[rounds][i];
25377			result[4 * i] = (Si[t[i] >> 24 & 255] ^ tt >> 24) & 255;
25378			result[4 * i + 1] = (Si[t[(i + 3) % 4] >> 16 & 255] ^ tt >> 16) & 255;
25379			result[4 * i + 2] = (Si[t[(i + 2) % 4] >> 8 & 255] ^ tt >> 8) & 255;
25380			result[4 * i + 3] = (Si[t[(i + 1) % 4] & 255] ^ tt) & 255;
25381		}
25382		return result;
25383	}
25384};
25385_AES_key = /* @__PURE__ */ new WeakMap(), _AES_Kd = /* @__PURE__ */ new WeakMap(), _AES_Ke = /* @__PURE__ */ new WeakMap();
25386//#endregion
25387//#region node_modules/aes-js/lib.esm/mode.js
25388var ModeOfOperation = class {
25389	constructor(name, key, cls) {
25390		if (cls && !(this instanceof cls)) throw new Error(`${name} must be instantiated with "new"`);
25391		Object.defineProperties(this, {
25392			aes: {
25393				enumerable: true,
25394				value: new AES(key)
25395			},
25396			name: {
25397				enumerable: true,
25398				value: name
25399			}
25400		});
25401	}
25402};
25403//#endregion
25404//#region node_modules/aes-js/lib.esm/mode-cbc.js
25405var __classPrivateFieldSet$1 = function(receiver, state, value, kind, f) {
25406	if (kind === "m") throw new TypeError("Private method is not writable");
25407	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
25408	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
25409	return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
25410};
25411var __classPrivateFieldGet$1 = function(receiver, state, kind, f) {
25412	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
25413	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
25414	return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
25415};
25416var _CBC_iv;
25417var _CBC_lastBlock;
25418var CBC = class CBC extends ModeOfOperation {
25419	constructor(key, iv) {
25420		super("ECC", key, CBC);
25421		_CBC_iv.set(this, void 0);
25422		_CBC_lastBlock.set(this, void 0);
25423		if (iv) {
25424			if (iv.length % 16) throw new TypeError("invalid iv size (must be 16 bytes)");
25425			__classPrivateFieldSet$1(this, _CBC_iv, new Uint8Array(iv), "f");
25426		} else __classPrivateFieldSet$1(this, _CBC_iv, /* @__PURE__ */ new Uint8Array(16), "f");
25427		__classPrivateFieldSet$1(this, _CBC_lastBlock, this.iv, "f");
25428	}
25429	get iv() {
25430		return new Uint8Array(__classPrivateFieldGet$1(this, _CBC_iv, "f"));
25431	}
25432	encrypt(plaintext) {
25433		if (plaintext.length % 16) throw new TypeError("invalid plaintext size (must be multiple of 16 bytes)");
25434		const ciphertext = new Uint8Array(plaintext.length);
25435		for (let i = 0; i < plaintext.length; i += 16) {
25436			for (let j = 0; j < 16; j++) __classPrivateFieldGet$1(this, _CBC_lastBlock, "f")[j] ^= plaintext[i + j];
25437			__classPrivateFieldSet$1(this, _CBC_lastBlock, this.aes.encrypt(__classPrivateFieldGet$1(this, _CBC_lastBlock, "f")), "f");
25438			ciphertext.set(__classPrivateFieldGet$1(this, _CBC_lastBlock, "f"), i);
25439		}
25440		return ciphertext;
25441	}
25442	decrypt(ciphertext) {
25443		if (ciphertext.length % 16) throw new TypeError("invalid ciphertext size (must be multiple of 16 bytes)");
25444		const plaintext = new Uint8Array(ciphertext.length);
25445		for (let i = 0; i < ciphertext.length; i += 16) {
25446			const block = this.aes.decrypt(ciphertext.subarray(i, i + 16));
25447			for (let j = 0; j < 16; j++) {
25448				plaintext[i + j] = block[j] ^ __classPrivateFieldGet$1(this, _CBC_lastBlock, "f")[j];
25449				__classPrivateFieldGet$1(this, _CBC_lastBlock, "f")[j] = ciphertext[i + j];
25450			}
25451		}
25452		return plaintext;
25453	}
25454};
25455_CBC_iv = /* @__PURE__ */ new WeakMap(), _CBC_lastBlock = /* @__PURE__ */ new WeakMap();
25456//#endregion
25457//#region node_modules/aes-js/lib.esm/mode-ctr.js
25458var __classPrivateFieldSet = function(receiver, state, value, kind, f) {
25459	if (kind === "m") throw new TypeError("Private method is not writable");
25460	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
25461	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
25462	return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
25463};
25464var __classPrivateFieldGet = function(receiver, state, kind, f) {
25465	if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
25466	if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
25467	return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
25468};
25469var _CTR_remaining;
25470var _CTR_remainingIndex;
25471var _CTR_counter;
25472var CTR = class CTR extends ModeOfOperation {
25473	constructor(key, initialValue) {
25474		super("CTR", key, CTR);
25475		_CTR_remaining.set(this, void 0);
25476		_CTR_remainingIndex.set(this, void 0);
25477		_CTR_counter.set(this, void 0);

25478		__classPrivateFieldSet(this, _CTR_counter, /* @__PURE__ */ new Uint8Array(16), "f");
25479		__classPrivateFieldGet(this, _CTR_counter, "f").fill(0);
25480		__classPrivateFieldSet(this, _CTR_remaining, __classPrivateFieldGet(this, _CTR_counter, "f"), "f");
25481		__classPrivateFieldSet(this, _CTR_remainingIndex, 16, "f");
25482		if (initialValue == null) initialValue = 1;
25483		if (typeof initialValue === "number") this.setCounterValue(initialValue);
25484		else this.setCounterBytes(initialValue);
25485	}
25486	get counter() {
25487		return new Uint8Array(__classPrivateFieldGet(this, _CTR_counter, "f"));
25488	}
25489	setCounterValue(value) {
25490		if (!Number.isInteger(value) || value < 0 || value > Number.MAX_SAFE_INTEGER) throw new TypeError("invalid counter initial integer value");
25491		for (let index = 15; index >= 0; --index) {
25492			__classPrivateFieldGet(this, _CTR_counter, "f")[index] = value % 256;
25493			value = Math.floor(value / 256);
25494		}
25495	}
25496	setCounterBytes(value) {
25497		if (value.length !== 16) throw new TypeError("invalid counter initial Uint8Array value length");
25498		__classPrivateFieldGet(this, _CTR_counter, "f").set(value);
25499	}
25500	increment() {
25501		for (let i = 15; i >= 0; i--) if (__classPrivateFieldGet(this, _CTR_counter, "f")[i] === 255) __classPrivateFieldGet(this, _CTR_counter, "f")[i] = 0;
25502		else {
25503			__classPrivateFieldGet(this, _CTR_counter, "f")[i]++;
25504			break;
25505		}
25506	}
25507	encrypt(plaintext) {
25508		var _a, _b;
25509		const crypttext = new Uint8Array(plaintext);
25510		for (let i = 0; i < crypttext.length; i++) {
25511			if (__classPrivateFieldGet(this, _CTR_remainingIndex, "f") === 16) {
25512				__classPrivateFieldSet(this, _CTR_remaining, this.aes.encrypt(__classPrivateFieldGet(this, _CTR_counter, "f")), "f");
25513				__classPrivateFieldSet(this, _CTR_remainingIndex, 0, "f");
25514				this.increment();
25515			}
25516			crypttext[i] ^= __classPrivateFieldGet(this, _CTR_remaining, "f")[__classPrivateFieldSet(this, _CTR_remainingIndex, (_b = __classPrivateFieldGet(this, _CTR_remainingIndex, "f"), _a = _b++, _b), "f"), _a];
25517		}
25518		return crypttext;
25519	}
25520	decrypt(ciphertext) {
25521		return this.encrypt(ciphertext);
25522	}
25523};
25524_CTR_remaining = /* @__PURE__ */ new WeakMap(), _CTR_remainingIndex = /* @__PURE__ */ new WeakMap(), _CTR_counter = /* @__PURE__ */ new WeakMap();
25525//#endregion
25526//#region node_modules/aes-js/lib.esm/padding.js
25527function pkcs7Strip(data) {
25528	if (data.length < 16) throw new TypeError("PKCS#7 invalid length");
25529	const padder = data[data.length - 1];
25530	if (padder > 16) throw new TypeError("PKCS#7 padding byte out of range");
25531	const length = data.length - padder;
25532	for (let i = 0; i < padder; i++) if (data[length + i] !== padder) throw new TypeError("PKCS#7 invalid padding byte");
25533	return new Uint8Array(data.subarray(0, length));
25534}
25535//#endregion
25536//#region node_modules/ethers/lib.esm/wallet/utils.js
25537/**
25538*  @_ignore
25539*/
25540function looseArrayify(hexString) {
25541	if (typeof hexString === "string" && !hexString.startsWith("0x")) hexString = "0x" + hexString;
25542	return getBytesCopy(hexString);
25543}
25544function zpad$1(value, length) {
25545	value = String(value);
25546	while (value.length < length) value = "0" + value;
25547	return value;
25548}
25549function getPassword(password) {
25550	if (typeof password === "string") return toUtf8Bytes(password, "NFKC");
25551	return getBytesCopy(password);
25552}
25553function spelunk(object, _path) {
25554	const match = _path.match(/^([a-z0-9$_.-]*)(:([a-z]+))?(!)?$/i);
25555	assertArgument(match != null, "invalid path", "path", _path);
25556	const path = match[1];
25557	const type = match[3];
25558	const reqd = match[4] === "!";
25559	let cur = object;
25560	for (const comp of path.toLowerCase().split(".")) {
25561		if (Array.isArray(cur)) {
25562			if (!comp.match(/^[0-9]+$/)) break;
25563			cur = cur[parseInt(comp)];
25564		} else if (typeof cur === "object") {
25565			let found = null;
25566			for (const key in cur) if (key.toLowerCase() === comp) {
25567				found = cur[key];
25568				break;
25569			}
25570			cur = found;
25571		} else cur = null;
25572		if (cur == null) break;
25573	}
25574	assertArgument(!reqd || cur != null, "missing required value", "path", path);
25575	if (type && cur != null) {
25576		if (type === "int") {
25577			if (typeof cur === "string" && cur.match(/^-?[0-9]+$/)) return parseInt(cur);
25578			else if (Number.isSafeInteger(cur)) return cur;
25579		}
25580		if (type === "number") {
25581			if (typeof cur === "string" && cur.match(/^-?[0-9.]*$/)) return parseFloat(cur);
25582		}
25583		if (type === "data") {
25584			if (typeof cur === "string") return looseArrayify(cur);
25585		}
25586		if (type === "array" && Array.isArray(cur)) return cur;
25587		if (type === typeof cur) return cur;
25588		assertArgument(false, `wrong type found for ${type} `, "path", path);
25589	}
25590	return cur;
25591}
25592//#endregion
25593//#region node_modules/ethers/lib.esm/wallet/json-keystore.js
25594/**
25595*  The JSON Wallet formats allow a simple way to store the private
25596*  keys needed in Ethereum along with related information and allows
25597*  for extensible forms of encryption.
25598*
25599*  These utilities facilitate decrypting and encrypting the most common
25600*  JSON Wallet formats.
25601*
25602*  @_subsection: api/wallet:JSON Wallets  [json-wallets]
25603*/
25604var defaultPath$1 = "m/44'/60'/0'/0/0";
25605/**
25606*  Returns true if %%json%% is a valid JSON Keystore Wallet.
25607*/
25608function isKeystoreJson(json) {
25609	try {
25610		const data = JSON.parse(json);
25611		if ((data.version != null ? parseInt(data.version) : 0) === 3) return true;
25612	} catch (error) {}
25613	return false;

25614}
25615function decrypt(data, key, ciphertext) {
25616	if (spelunk(data, "crypto.cipher:string") === "aes-128-ctr") return hexlify(new CTR(key, spelunk(data, "crypto.cipherparams.iv:data!")).decrypt(ciphertext));
25617	assert(false, "unsupported cipher", "UNSUPPORTED_OPERATION", { operation: "decrypt" });
25618}
25619function getAccount(data, _key) {
25620	const key = getBytes(_key);
25621	const ciphertext = spelunk(data, "crypto.ciphertext:data!");
25622	assertArgument(hexlify(keccak256(concat([key.slice(16, 32), ciphertext]))).substring(2) === spelunk(data, "crypto.mac:string!").toLowerCase(), "incorrect password", "password", "[ REDACTED ]");
25623	const privateKey = decrypt(data, key.slice(0, 16), ciphertext);
25624	const address = computeAddress(privateKey);
25625	if (data.address) {
25626		let check = data.address.toLowerCase();
25627		if (!check.startsWith("0x")) check = "0x" + check;
25628		assertArgument(getAddress(check) === address, "keystore address/privateKey mismatch", "address", data.address);
25629	}
25630	const account = {
25631		address,
25632		privateKey
25633	};
25634	if (spelunk(data, "x-ethers.version:string") === "0.1") {
25635		const mnemonicKey = key.slice(32, 64);
25636		const mnemonicCiphertext = spelunk(data, "x-ethers.mnemonicCiphertext:data!");
25637		const mnemonicAesCtr = new CTR(mnemonicKey, spelunk(data, "x-ethers.mnemonicCounter:data!"));
25638		account.mnemonic = {
25639			path: spelunk(data, "x-ethers.path:string") || defaultPath$1,
25640			locale: spelunk(data, "x-ethers.locale:string") || "en",
25641			entropy: hexlify(getBytes(mnemonicAesCtr.decrypt(mnemonicCiphertext)))
25642		};
25643	}
25644	return account;
25645}
25646function getDecryptKdfParams(data) {
25647	const kdf = spelunk(data, "crypto.kdf:string");
25648	if (kdf && typeof kdf === "string") {
25649		if (kdf.toLowerCase() === "scrypt") {
25650			const salt = spelunk(data, "crypto.kdfparams.salt:data!");
25651			const N = spelunk(data, "crypto.kdfparams.n:int!");
25652			const r = spelunk(data, "crypto.kdfparams.r:int!");
25653			const p = spelunk(data, "crypto.kdfparams.p:int!");
25654			assertArgument(N > 0 && (N & N - 1) === 0, "invalid kdf.N", "kdf.N", N);
25655			assertArgument(r > 0 && p > 0, "invalid kdf", "kdf", kdf);
25656			const dkLen = spelunk(data, "crypto.kdfparams.dklen:int!");
25657			assertArgument(dkLen === 32, "invalid kdf.dklen", "kdf.dflen", dkLen);
25658			return {
25659				name: "scrypt",
25660				salt,
25661				N,
25662				r,
25663				p,
25664				dkLen: 64
25665			};
25666		} else if (kdf.toLowerCase() === "pbkdf2") {
25667			const salt = spelunk(data, "crypto.kdfparams.salt:data!");
25668			const prf = spelunk(data, "crypto.kdfparams.prf:string!");
25669			const algorithm = prf.split("-").pop();
25670			assertArgument(algorithm === "sha256" || algorithm === "sha512", "invalid kdf.pdf", "kdf.pdf", prf);
25671			const count = spelunk(data, "crypto.kdfparams.c:int!");
25672			const dkLen = spelunk(data, "crypto.kdfparams.dklen:int!");
25673			assertArgument(dkLen === 32, "invalid kdf.dklen", "kdf.dklen", dkLen);
25674			return {
25675				name: "pbkdf2",
25676				salt,
25677				count,
25678				dkLen,
25679				algorithm
25680			};
25681		}
25682	}
25683	assertArgument(false, "unsupported key-derivation function", "kdf", kdf);
25684}
25685/**
25686*  Returns the account details for the JSON Keystore Wallet %%json%%
25687*  using %%password%%.
25688*
25689*  It is preferred to use the [async version](decryptKeystoreJson)
25690*  instead, which allows a [[ProgressCallback]] to keep the user informed
25691*  as to the decryption status.
25692*
25693*  This method will block the event loop (freezing all UI) until decryption
25694*  is complete, which can take quite some time, depending on the wallet
25695*  paramters and platform.
25696*/
25697function decryptKeystoreJsonSync(json, _password) {
25698	const data = JSON.parse(json);
25699	const password = getPassword(_password);
25700	const params = getDecryptKdfParams(data);
25701	if (params.name === "pbkdf2") {
25702		const { salt, count, dkLen, algorithm } = params;
25703		return getAccount(data, pbkdf2(password, salt, count, dkLen, algorithm));
25704	}
25705	assert(params.name === "scrypt", "cannot be reached", "UNKNOWN_ERROR", { params });
25706	const { salt, N, r, p, dkLen } = params;
25707	return getAccount(data, scryptSync(password, salt, N, r, p, dkLen));
25708}
25709function stall$1(duration) {
25710	return new Promise((resolve) => {
25711		setTimeout(() => {
25712			resolve();
25713		}, duration);
25714	});
25715}
25716/**
25717*  Resolves to the decrypted JSON Keystore Wallet %%json%% using the
25718*  %%password%%.
25719*

25720*  If provided, %%progress%% will be called periodically during the
25721*  decrpytion to provide feedback, and if the function returns
25722*  ``false`` will halt decryption.
25723*
25724*  The %%progressCallback%% will **always** receive ``0`` before
25725*  decryption begins and ``1`` when complete.
25726*/
25727async function decryptKeystoreJson(json, _password, progress) {
25728	const data = JSON.parse(json);
25729	const password = getPassword(_password);
25730	const params = getDecryptKdfParams(data);
25731	if (params.name === "pbkdf2") {
25732		if (progress) {
25733			progress(0);
25734			await stall$1(0);
25735		}
25736		const { salt, count, dkLen, algorithm } = params;
25737		const key = pbkdf2(password, salt, count, dkLen, algorithm);
25738		if (progress) {
25739			progress(1);
25740			await stall$1(0);
25741		}
25742		return getAccount(data, key);
25743	}
25744	assert(params.name === "scrypt", "cannot be reached", "UNKNOWN_ERROR", { params });
25745	const { salt, N, r, p, dkLen } = params;
25746	return getAccount(data, await scrypt(password, salt, N, r, p, dkLen, progress));
25747}
25748function getEncryptKdfParams(options) {
25749	const salt = options.salt != null ? getBytes(options.salt, "options.salt") : randomBytes(32);
25750	let N = 1 << 17, r = 8, p = 1;
25751	if (options.scrypt) {
25752		if (options.scrypt.N) N = options.scrypt.N;
25753		if (options.scrypt.r) r = options.scrypt.r;
25754		if (options.scrypt.p) p = options.scrypt.p;
25755	}
25756	assertArgument(typeof N === "number" && N > 0 && Number.isSafeInteger(N) && (BigInt(N) & BigInt(N - 1)) === BigInt(0), "invalid scrypt N parameter", "options.N", N);
25757	assertArgument(typeof r === "number" && r > 0 && Number.isSafeInteger(r), "invalid scrypt r parameter", "options.r", r);
25758	assertArgument(typeof p === "number" && p > 0 && Number.isSafeInteger(p), "invalid scrypt p parameter", "options.p", p);
25759	return {
25760		name: "scrypt",
25761		dkLen: 32,
25762		salt,
25763		N,
25764		r,
25765		p
25766	};
25767}
25768function _encryptKeystore(key, kdf, account, options) {
25769	const privateKey = getBytes(account.privateKey, "privateKey");
25770	const iv = options.iv != null ? getBytes(options.iv, "options.iv") : randomBytes(16);
25771	assertArgument(iv.length === 16, "invalid options.iv length", "options.iv", options.iv);
25772	const uuidRandom = options.uuid != null ? getBytes(options.uuid, "options.uuid") : randomBytes(16);
25773	assertArgument(uuidRandom.length === 16, "invalid options.uuid length", "options.uuid", options.iv);
25774	const derivedKey = key.slice(0, 16);
25775	const macPrefix = key.slice(16, 32);
25776	const ciphertext = getBytes(new CTR(derivedKey, iv).encrypt(privateKey));
25777	const mac = keccak256(concat([macPrefix, ciphertext]));
25778	const data = {
25779		address: account.address.substring(2).toLowerCase(),
25780		id: uuidV4(uuidRandom),
25781		version: 3,
25782		Crypto: {
25783			cipher: "aes-128-ctr",
25784			cipherparams: { iv: hexlify(iv).substring(2) },
25785			ciphertext: hexlify(ciphertext).substring(2),
25786			kdf: "scrypt",
25787			kdfparams: {
25788				salt: hexlify(kdf.salt).substring(2),
25789				n: kdf.N,
25790				dklen: 32,
25791				p: kdf.p,
25792				r: kdf.r
25793			},
25794			mac: mac.substring(2)
25795		}
25796	};
25797	if (account.mnemonic) {
25798		const client = options.client != null ? options.client : `ethers/${version}`;
25799		const path = account.mnemonic.path || defaultPath$1;
25800		const locale = account.mnemonic.locale || "en";
25801		const mnemonicKey = key.slice(32, 64);
25802		const entropy = getBytes(account.mnemonic.entropy, "account.mnemonic.entropy");
25803		const mnemonicIv = randomBytes(16);
25804		const mnemonicCiphertext = getBytes(new CTR(mnemonicKey, mnemonicIv).encrypt(entropy));
25805		const now = /* @__PURE__ */ new Date();
25806		data["x-ethers"] = {
25807			client,
25808			gethFilename: "UTC--" + (now.getUTCFullYear() + "-" + zpad$1(now.getUTCMonth() + 1, 2) + "-" + zpad$1(now.getUTCDate(), 2) + "T" + zpad$1(now.getUTCHours(), 2) + "-" + zpad$1(now.getUTCMinutes(), 2) + "-" + zpad$1(now.getUTCSeconds(), 2) + ".0Z") + "--" + data.address,
25809			path,
25810			locale,
25811			mnemonicCounter: hexlify(mnemonicIv).substring(2),
25812			mnemonicCiphertext: hexlify(mnemonicCiphertext).substring(2),
25813			version: "0.1"
25814		};
25815	}
25816	return JSON.stringify(data);
25817}
25818/**
25819*  Return the JSON Keystore Wallet for %%account%% encrypted with
25820*  %%password%%.
25821*
25822*  The %%options%% can be used to tune the password-based key
25823*  derivation function parameters, explicitly set the random values
25824*  used. Any provided [[ProgressCallback]] is ignord.
25825*/

25826function encryptKeystoreJsonSync(account, password, options) {
25827	if (options == null) options = {};
25828	const passwordBytes = getPassword(password);
25829	const kdf = getEncryptKdfParams(options);
25830	return _encryptKeystore(getBytes(scryptSync(passwordBytes, kdf.salt, kdf.N, kdf.r, kdf.p, 64)), kdf, account, options);
25831}
25832/**
25833*  Resolved to the JSON Keystore Wallet for %%account%% encrypted
25834*  with %%password%%.
25835*
25836*  The %%options%% can be used to tune the password-based key
25837*  derivation function parameters, explicitly set the random values
25838*  used and provide a [[ProgressCallback]] to receive periodic updates
25839*  on the completion status..
25840*/
25841async function encryptKeystoreJson(account, password, options) {
25842	if (options == null) options = {};
25843	const passwordBytes = getPassword(password);
25844	const kdf = getEncryptKdfParams(options);
25845	return _encryptKeystore(getBytes(await scrypt(passwordBytes, kdf.salt, kdf.N, kdf.r, kdf.p, 64, options.progressCallback)), kdf, account, options);
25846}
25847//#endregion
25848//#region node_modules/ethers/lib.esm/wallet/hdwallet.js
25849/**
25850*  Explain HD Wallets..
25851*
25852*  @_subsection: api/wallet:HD Wallets  [hd-wallets]
25853*/
25854/**
25855*  The default derivation path for Ethereum HD Nodes. (i.e. ``"m/44'/60'/0'/0/0"``)
25856*/
25857var defaultPath = "m/44'/60'/0'/0/0";
25858var MasterSecret = new Uint8Array([
25859	66,
25860	105,
25861	116,
25862	99,
25863	111,
25864	105,
25865	110,
25866	32,
25867	115,
25868	101,
25869	101,
25870	100
25871]);
25872var HardenedBit = 2147483648;
25873var N$1 = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
25874var Nibbles = "0123456789abcdef";
25875function zpad(value, length) {
25876	let result = "";
25877	while (value) {
25878		result = Nibbles[value % 16] + result;
25879		value = Math.trunc(value / 16);
25880	}
25881	while (result.length < length * 2) result = "0" + result;
25882	return "0x" + result;
25883}
25884function encodeBase58Check(_value) {
25885	const value = getBytes(_value);
25886	return encodeBase58(concat([value, dataSlice(sha256(sha256(value)), 0, 4)]));
25887}
25888var _guard = {};
25889function ser_I(index, chainCode, publicKey, privateKey) {
25890	const data = /* @__PURE__ */ new Uint8Array(37);
25891	if (index & HardenedBit) {
25892		assert(privateKey != null, "cannot derive child of neutered node", "UNSUPPORTED_OPERATION", { operation: "deriveChild" });
25893		data.set(getBytes(privateKey), 1);
25894	} else data.set(getBytes(publicKey));
25895	for (let i = 24; i >= 0; i -= 8) data[33 + (i >> 3)] = index >> 24 - i & 255;
25896	const I = getBytes(computeHmac("sha512", chainCode, data));
25897	return {
25898		IL: I.slice(0, 32),
25899		IR: I.slice(32)
25900	};
25901}
25902function derivePath(node, path) {
25903	const components = path.split("/");
25904	assertArgument(components.length > 0, "invalid path", "path", path);
25905	if (components[0] === "m") {
25906		assertArgument(node.depth === 0, `cannot derive root path (i.e. path starting with "m/") for a node at non-zero depth ${node.depth}`, "path", path);
25907		components.shift();
25908	}
25909	let result = node;
25910	for (let i = 0; i < components.length; i++) {
25911		const component = components[i];
25912		if (component.match(/^[0-9]+'$/)) {
25913			const index = parseInt(component.substring(0, component.length - 1));
25914			assertArgument(index < HardenedBit, "invalid path index", `path[${i}]`, component);
25915			result = result.deriveChild(HardenedBit + index);
25916		} else if (component.match(/^[0-9]+$/)) {
25917			const index = parseInt(component);
25918			assertArgument(index < HardenedBit, "invalid path index", `path[${i}]`, component);
25919			result = result.deriveChild(index);
25920		} else assertArgument(false, "invalid path component", `path[${i}]`, component);
25921	}
25922	return result;
25923}
25924/**
25925*  An **HDNodeWallet** is a [[Signer]] backed by the private key derived
25926*  from an HD Node using the [[link-bip-32]] stantard.
25927*
25928*  An HD Node forms a hierarchal structure with each HD Node having a
25929*  private key and the ability to derive child HD Nodes, defined by
25930*  a path indicating the index of each child.
25931*/
25932var HDNodeWallet = class HDNodeWallet extends BaseWallet {
25933	/**
25934	*  The compressed public key.
25935	*/
25936	publicKey;
25937	/**
25938	*  The fingerprint.
25939	*
25940	*  A fingerprint allows quick qay to detect parent and child nodes,
25941	*  but developers should be prepared to deal with collisions as it
25942	*  is only 4 bytes.
25943	*/
25944	fingerprint;
25945	/**
25946	*  The parent fingerprint.
25947	*/
25948	parentFingerprint;
25949	/**
25950	*  The mnemonic used to create this HD Node, if available.
25951	*

vendor: 7,892 bytes, lines 25952-26193

25952	*  Sources such as extended keys do not encode the mnemonic, in
25953	*  which case this will be ``null``.
25954	*/
25955	mnemonic;
25956	/**
25957	*  The chaincode, which is effectively a public key used
25958	*  to derive children.
25959	*/
25960	chainCode;
25961	/**
25962	*  The derivation path of this wallet.
25963	*
25964	*  Since extended keys do not provide full path details, this
25965	*  may be ``null``, if instantiated from a source that does not
25966	*  encode it.
25967	*/
25968	path;
25969	/**
25970	*  The child index of this wallet. Values over ``2 *\* 31`` indicate
25971	*  the node is hardened.
25972	*/
25973	index;
25974	/**
25975	*  The depth of this wallet, which is the number of components
25976	*  in its path.
25977	*/
25978	depth;
25979	/**
25980	*  @private
25981	*/
25982	constructor(guard, signingKey, parentFingerprint, chainCode, path, index, depth, mnemonic, provider) {
25983		super(signingKey, provider);
25984		assertPrivate(guard, _guard, "HDNodeWallet");
25985		defineProperties(this, { publicKey: signingKey.compressedPublicKey });
25986		const fingerprint = dataSlice(ripemd160(sha256(this.publicKey)), 0, 4);
25987		defineProperties(this, {
25988			parentFingerprint,
25989			fingerprint,
25990			chainCode,
25991			path,
25992			index,
25993			depth
25994		});
25995		defineProperties(this, { mnemonic });
25996	}
25997	connect(provider) {
25998		return new HDNodeWallet(_guard, this.signingKey, this.parentFingerprint, this.chainCode, this.path, this.index, this.depth, this.mnemonic, provider);
25999	}
26000	#account() {
26001		const account = {
26002			address: this.address,
26003			privateKey: this.privateKey
26004		};
26005		const m = this.mnemonic;
26006		if (this.path && m && m.wordlist.locale === "en" && m.password === "") account.mnemonic = {
26007			path: this.path,
26008			locale: "en",
26009			entropy: m.entropy
26010		};
26011		return account;
26012	}
26013	/**
26014	*  Resolves to a [JSON Keystore Wallet](json-wallets) encrypted with
26015	*  %%password%%.
26016	*
26017	*  If %%progressCallback%% is specified, it will receive periodic
26018	*  updates as the encryption process progreses.
26019	*/
26020	async encrypt(password, progressCallback) {
26021		return await encryptKeystoreJson(this.#account(), password, { progressCallback });
26022	}
26023	/**
26024	*  Returns a [JSON Keystore Wallet](json-wallets) encryped with
26025	*  %%password%%.
26026	*
26027	*  It is preferred to use the [async version](encrypt) instead,
26028	*  which allows a [[ProgressCallback]] to keep the user informed.
26029	*
26030	*  This method will block the event loop (freezing all UI) until
26031	*  it is complete, which may be a non-trivial duration.
26032	*/
26033	encryptSync(password) {
26034		return encryptKeystoreJsonSync(this.#account(), password);
26035	}
26036	/**
26037	*  The extended key.
26038	*
26039	*  This key will begin with the prefix ``xpriv`` and can be used to
26040	*  reconstruct this HD Node to derive its children.
26041	*/
26042	get extendedKey() {
26043		assert(this.depth < 256, "Depth too deep", "UNSUPPORTED_OPERATION", { operation: "extendedKey" });
26044		return encodeBase58Check(concat([
26045			"0x0488ADE4",
26046			zpad(this.depth, 1),
26047			this.parentFingerprint,
26048			zpad(this.index, 4),
26049			this.chainCode,
26050			concat(["0x00", this.privateKey])
26051		]));
26052	}
26053	/**
26054	*  Returns true if this wallet has a path, providing a Type Guard
26055	*  that the path is non-null.
26056	*/
26057	hasPath() {
26058		return this.path != null;
26059	}
26060	/**
26061	*  Returns a neutered HD Node, which removes the private details
26062	*  of an HD Node.
26063	*
26064	*  A neutered node has no private key, but can be used to derive
26065	*  child addresses and other public data about the HD Node.
26066	*/
26067	neuter() {
26068		return new HDNodeVoidWallet(_guard, this.address, this.publicKey, this.parentFingerprint, this.chainCode, this.path, this.index, this.depth, this.provider);
26069	}
26070	/**
26071	*  Return the child for %%index%%.
26072	*/
26073	deriveChild(_index) {
26074		const index = getNumber(_index, "index");
26075		assertArgument(index <= 4294967295, "invalid index", "index", index);
26076		let path = this.path;
26077		if (path) {
26078			path += "/" + (index & 2147483647);
26079			if (index & HardenedBit) path += "'";
26080		}
26081		const { IR, IL } = ser_I(index, this.chainCode, this.publicKey, this.privateKey);
26082		const ki = new SigningKey(toBeHex((toBigInt(IL) + BigInt(this.privateKey)) % N$1, 32));
26083		return new HDNodeWallet(_guard, ki, this.fingerprint, hexlify(IR), path, index, this.depth + 1, this.mnemonic, this.provider);
26084	}
26085	/**
26086	*  Return the HDNode for %%path%% from this node.
26087	*/
26088	derivePath(path) {
26089		return derivePath(this, path);
26090	}
26091	static #fromSeed(_seed, mnemonic) {
26092		assertArgument(isBytesLike(_seed), "invalid seed", "seed", "[REDACTED]");
26093		const seed = getBytes(_seed, "seed");
26094		assertArgument(seed.length >= 16 && seed.length <= 64, "invalid seed", "seed", "[REDACTED]");
26095		const I = getBytes(computeHmac("sha512", MasterSecret, seed));
26096		const signingKey = new SigningKey(hexlify(I.slice(0, 32)));
26097		return new HDNodeWallet(_guard, signingKey, "0x00000000", hexlify(I.slice(32)), "m", 0, 0, mnemonic, null);
26098	}
26099	/**
26100	*  Creates a new HD Node from %%extendedKey%%.
26101	*
26102	*  If the %%extendedKey%% will either have a prefix or ``xpub`` or
26103	*  ``xpriv``, returning a neutered HD Node ([[HDNodeVoidWallet]])
26104	*  or full HD Node ([[HDNodeWallet) respectively.
26105	*/
26106	static fromExtendedKey(extendedKey) {
26107		const bytes = toBeArray(decodeBase58(extendedKey));
26108		assertArgument(bytes.length === 82 || encodeBase58Check(bytes.slice(0, 78)) === extendedKey, "invalid extended key", "extendedKey", "[ REDACTED ]");
26109		const depth = bytes[4];
26110		const parentFingerprint = hexlify(bytes.slice(5, 9));
26111		const index = parseInt(hexlify(bytes.slice(9, 13)).substring(2), 16);
26112		const chainCode = hexlify(bytes.slice(13, 45));
26113		const key = bytes.slice(45, 78);
26114		switch (hexlify(bytes.slice(0, 4))) {
26115			case "0x0488b21e":
26116			case "0x043587cf": {
26117				const publicKey = hexlify(key);
26118				return new HDNodeVoidWallet(_guard, computeAddress(publicKey), publicKey, parentFingerprint, chainCode, null, index, depth, null);
26119			}
26120			case "0x0488ade4":
26121			case "0x04358394 ":
26122				if (key[0] !== 0) break;
26123				return new HDNodeWallet(_guard, new SigningKey(key.slice(1)), parentFingerprint, chainCode, null, index, depth, null, null);
26124		}
26125		assertArgument(false, "invalid extended key prefix", "extendedKey", "[ REDACTED ]");
26126	}
26127	/**
26128	*  Creates a new random HDNode.
26129	*/
26130	static createRandom(password, path, wordlist) {
26131		if (password == null) password = "";
26132		if (path == null) path = defaultPath;
26133		if (wordlist == null) wordlist = LangEn.wordlist();
26134		const mnemonic = Mnemonic.fromEntropy(randomBytes(16), password, wordlist);
26135		return HDNodeWallet.#fromSeed(mnemonic.computeSeed(), mnemonic).derivePath(path);
26136	}
26137	/**
26138	*  Create an HD Node from %%mnemonic%%.
26139	*/
26140	static fromMnemonic(mnemonic, path) {
26141		if (!path) path = defaultPath;
26142		return HDNodeWallet.#fromSeed(mnemonic.computeSeed(), mnemonic).derivePath(path);
26143	}
26144	/**
26145	*  Creates an HD Node from a mnemonic %%phrase%%.
26146	*/
26147	static fromPhrase(phrase, password, path, wordlist) {
26148		if (password == null) password = "";
26149		if (path == null) path = defaultPath;
26150		if (wordlist == null) wordlist = LangEn.wordlist();
26151		const mnemonic = Mnemonic.fromPhrase(phrase, password, wordlist);
26152		return HDNodeWallet.#fromSeed(mnemonic.computeSeed(), mnemonic).derivePath(path);
26153	}
26154	/**
26155	*  Creates an HD Node from a %%seed%%.
26156	*/
26157	static fromSeed(seed) {
26158		return HDNodeWallet.#fromSeed(seed, null);
26159	}
26160};
26161/**
26162*  A **HDNodeVoidWallet** cannot sign, but provides access to
26163*  the children nodes of a [[link-bip-32]] HD wallet addresses.
26164*
26165*  The can be created by using an extended ``xpub`` key to
26166*  [[HDNodeWallet_fromExtendedKey]] or by
26167*  [nuetering](HDNodeWallet-neuter) a [[HDNodeWallet]].
26168*/
26169var HDNodeVoidWallet = class HDNodeVoidWallet extends VoidSigner {
26170	/**
26171	*  The compressed public key.
26172	*/
26173	publicKey;
26174	/**
26175	*  The fingerprint.
26176	*
26177	*  A fingerprint allows quick qay to detect parent and child nodes,
26178	*  but developers should be prepared to deal with collisions as it
26179	*  is only 4 bytes.
26180	*/
26181	fingerprint;
26182	/**
26183	*  The parent node fingerprint.
26184	*/
26185	parentFingerprint;
26186	/**
26187	*  The chaincode, which is effectively a public key used
26188	*  to derive children.
26189	*/
26190	chainCode;
26191	/**
26192	*  The derivation path of this wallet.
26193	*

26194	*  Since extended keys do not provider full path details, this
26195	*  may be ``null``, if instantiated from a source that does not
26196	*  enocde it.
26197	*/
26198	path;
26199	/**
26200	*  The child index of this wallet. Values over ``2 *\* 31`` indicate
26201	*  the node is hardened.
26202	*/
26203	index;
26204	/**
26205	*  The depth of this wallet, which is the number of components
26206	*  in its path.
26207	*/
26208	depth;
26209	/**
26210	*  @private
26211	*/
26212	constructor(guard, address, publicKey, parentFingerprint, chainCode, path, index, depth, provider) {
26213		super(address, provider);
26214		assertPrivate(guard, _guard, "HDNodeVoidWallet");
26215		defineProperties(this, { publicKey });
26216		const fingerprint = dataSlice(ripemd160(sha256(publicKey)), 0, 4);
26217		defineProperties(this, {
26218			publicKey,
26219			fingerprint,
26220			parentFingerprint,
26221			chainCode,
26222			path,
26223			index,
26224			depth
26225		});
26226	}
26227	connect(provider) {
26228		return new HDNodeVoidWallet(_guard, this.address, this.publicKey, this.parentFingerprint, this.chainCode, this.path, this.index, this.depth, provider);
26229	}
26230	/**
26231	*  The extended key.
26232	*
26233	*  This key will begin with the prefix ``xpub`` and can be used to
26234	*  reconstruct this neutered key to derive its children addresses.
26235	*/
26236	get extendedKey() {
26237		assert(this.depth < 256, "Depth too deep", "UNSUPPORTED_OPERATION", { operation: "extendedKey" });
26238		return encodeBase58Check(concat([
26239			"0x0488B21E",
26240			zpad(this.depth, 1),
26241			this.parentFingerprint,
26242			zpad(this.index, 4),
26243			this.chainCode,
26244			this.publicKey
26245		]));
26246	}
26247	/**
26248	*  Returns true if this wallet has a path, providing a Type Guard
26249	*  that the path is non-null.
26250	*/
26251	hasPath() {
26252		return this.path != null;
26253	}
26254	/**
26255	*  Return the child for %%index%%.
26256	*/
26257	deriveChild(_index) {
26258		const index = getNumber(_index, "index");
26259		assertArgument(index <= 4294967295, "invalid index", "index", index);
26260		let path = this.path;
26261		if (path) {
26262			path += "/" + (index & 2147483647);
26263			if (index & HardenedBit) path += "'";
26264		}
26265		const { IR, IL } = ser_I(index, this.chainCode, this.publicKey, null);
26266		const Ki = SigningKey.addPoints(IL, this.publicKey, true);
26267		const address = computeAddress(Ki);
26268		return new HDNodeVoidWallet(_guard, address, Ki, this.fingerprint, hexlify(IR), path, index, this.depth + 1, this.provider);
26269	}
26270	/**
26271	*  Return the signer for %%path%% from this node.
26272	*/
26273	derivePath(path) {
26274		return derivePath(this, path);
26275	}
26276};
26277/**
26278*  Returns the [[link-bip-32]] path for the account at %%index%%.
26279*
26280*  This is the pattern used by wallets like Ledger.
26281*
26282*  There is also an [alternate pattern](getIndexedAccountPath) used by
26283*  some software.
26284*/
26285function getAccountPath(_index) {
26286	const index = getNumber(_index, "index");
26287	assertArgument(index >= 0 && index < HardenedBit, "invalid account index", "index", index);
26288	return `m/44'/60'/${index}'/0/0`;
26289}
26290/**
26291*  Returns the path using an alternative pattern for deriving accounts,
26292*  at %%index%%.
26293*
26294*  This derivation path uses the //index// component rather than the
26295*  //account// component to derive sequential accounts.
26296*
26297*  This is the pattern used by wallets like MetaMask.
26298*/
26299function getIndexedAccountPath(_index) {
26300	const index = getNumber(_index, "index");
26301	assertArgument(index >= 0 && index < HardenedBit, "invalid account index", "index", index);
26302	return `m/44'/60'/0'/0/${index}`;
26303}
26304//#endregion
26305//#region node_modules/ethers/lib.esm/wallet/json-crowdsale.js
26306/**
26307*  @_subsection: api/wallet:JSON Wallets  [json-wallets]
26308*/
26309/**
26310*  Returns true if %%json%% is a valid JSON Crowdsale wallet.
26311*/
26312function isCrowdsaleJson(json) {
26313	try {
26314		if (JSON.parse(json).encseed) return true;
26315	} catch (error) {}
26316	return false;
26317}
26318/**
26319*  Before Ethereum launched, it was necessary to create a wallet
26320*  format for backers to use, which would be used to receive ether
26321*  as a reward for contributing to the project.
26322*
26323*  The [[link-crowdsale]] format is now obsolete, but it is still
26324*  useful to support and the additional code is fairly trivial as
26325*  all the primitives required are used through core portions of
26326*  the library.
26327*/
26328function decryptCrowdsaleJson(json, _password) {
26329	const data = JSON.parse(json);
26330	const password = getPassword(_password);
26331	const address = getAddress(spelunk(data, "ethaddr:string!"));
26332	const encseed = looseArrayify(spelunk(data, "encseed:string!"));
26333	assertArgument(encseed && encseed.length % 16 === 0, "invalid encseed", "json", json);
26334	const key = getBytes(pbkdf2(password, password, 2e3, 32, "sha256")).slice(0, 16);
26335	const iv = encseed.slice(0, 16);
26336	const encryptedSeed = encseed.slice(16);
26337	const seed = pkcs7Strip(getBytes(new CBC(key, iv).decrypt(encryptedSeed)));
26338	let seedHex = "";
26339	for (let i = 0; i < seed.length; i++) seedHex += String.fromCharCode(seed[i]);
26340	return {
26341		address,
26342		privateKey: id(seedHex)
26343	};
26344}
26345//#endregion
26346//#region node_modules/ethers/lib.esm/wallet/wallet.js
26347function stall(duration) {
26348	return new Promise((resolve) => {
26349		setTimeout(() => {
26350			resolve();
26351		}, duration);
26352	});
26353}
26354/**
26355*  A **Wallet** manages a single private key which is used to sign
26356*  transactions, messages and other common payloads.
26357*
26358*  This class is generally the main entry point for developers
26359*  that wish to use a private key directly, as it can create
26360*  instances from a large variety of common sources, including
26361*  raw private key, [[link-bip-39]] mnemonics and encrypte JSON
26362*  wallets.
26363*/
26364var Wallet = class Wallet extends BaseWallet {
26365	/**
26366	*  Create a new wallet for the private %%key%%, optionally connected
26367	*  to %%provider%%.
26368	*/
26369	constructor(key, provider) {
26370		if (typeof key === "string" && !key.startsWith("0x")) key = "0x" + key;
26371		let signingKey = typeof key === "string" ? new SigningKey(key) : key;
26372		super(signingKey, provider);
26373	}
26374	connect(provider) {
26375		return new Wallet(this.signingKey, provider);
26376	}
26377	/**
26378	*  Resolves to a [JSON Keystore Wallet](json-wallets) encrypted with
26379	*  %%password%%.
26380	*
26381	*  If %%progressCallback%% is specified, it will receive periodic
26382	*  updates as the encryption process progreses.
26383	*/
26384	async encrypt(password, progressCallback) {

26385		return await encryptKeystoreJson({
26386			address: this.address,
26387			privateKey: this.privateKey
26388		}, password, { progressCallback });
26389	}
26390	/**
26391	*  Returns a [JSON Keystore Wallet](json-wallets) encryped with
26392	*  %%password%%.
26393	*
26394	*  It is preferred to use the [async version](encrypt) instead,
26395	*  which allows a [[ProgressCallback]] to keep the user informed.
26396	*
26397	*  This method will block the event loop (freezing all UI) until
26398	*  it is complete, which may be a non-trivial duration.
26399	*/
26400	encryptSync(password) {
26401		return encryptKeystoreJsonSync({
26402			address: this.address,
26403			privateKey: this.privateKey
26404		}, password);
26405	}
26406	static #fromAccount(account) {
26407		assertArgument(account, "invalid JSON wallet", "json", "[ REDACTED ]");
26408		if ("mnemonic" in account && account.mnemonic && account.mnemonic.locale === "en") {
26409			const mnemonic = Mnemonic.fromEntropy(account.mnemonic.entropy);
26410			const wallet = HDNodeWallet.fromMnemonic(mnemonic, account.mnemonic.path);
26411			if (wallet.address === account.address && wallet.privateKey === account.privateKey) return wallet;
26412			console.log("WARNING: JSON mismatch address/privateKey != mnemonic; fallback onto private key");
26413		}
26414		const wallet = new Wallet(account.privateKey);
26415		assertArgument(wallet.address === account.address, "address/privateKey mismatch", "json", "[ REDACTED ]");
26416		return wallet;
26417	}

26418	/**
26419	*  Creates (asynchronously) a **Wallet** by decrypting the %%json%%
26420	*  with %%password%%.
26421	*
26422	*  If %%progress%% is provided, it is called periodically during
26423	*  decryption so that any UI can be updated.
26424	*/
26425	static async fromEncryptedJson(json, password, progress) {
26426		let account = null;
26427		if (isKeystoreJson(json)) account = await decryptKeystoreJson(json, password, progress);
26428		else if (isCrowdsaleJson(json)) {
26429			if (progress) {
26430				progress(0);
26431				await stall(0);
26432			}
26433			account = decryptCrowdsaleJson(json, password);
26434			if (progress) {
26435				progress(1);
26436				await stall(0);
26437			}
26438		}
26439		return Wallet.#fromAccount(account);
26440	}
26441	/**
26442	*  Creates a **Wallet** by decrypting the %%json%% with %%password%%.
26443	*
26444	*  The [[fromEncryptedJson]] method is preferred, as this method
26445	*  will lock up and freeze the UI during decryption, which may take
26446	*  some time.
26447	*/
26448	static fromEncryptedJsonSync(json, password) {
26449		let account = null;
26450		if (isKeystoreJson(json)) account = decryptKeystoreJsonSync(json, password);
26451		else if (isCrowdsaleJson(json)) account = decryptCrowdsaleJson(json, password);
26452		else assertArgument(false, "invalid JSON wallet", "json", "[ REDACTED ]");
26453		return Wallet.#fromAccount(account);
26454	}
26455	/**
26456	*  Creates a new random [[HDNodeWallet]] using the available
26457	*  [cryptographic random source](randomBytes).
26458	*
26459	*  If there is no crytographic random source, this will throw.
26460	*/
26461	static createRandom(provider) {
26462		const wallet = HDNodeWallet.createRandom();
26463		if (provider) return wallet.connect(provider);
26464		return wallet;
26465	}

26466	/**
26467	*  Creates a [[HDNodeWallet]] for %%phrase%%.
26468	*/
26469	static fromPhrase(phrase, provider) {
26470		const wallet = HDNodeWallet.fromPhrase(phrase);
26471		if (provider) return wallet.connect(provider);
26472		return wallet;
26473	}
26474};
26475//#endregion
26476//#region node_modules/ethers/lib.esm/wordlists/bit-reader.js
26477var Base64 = ")!@#$%^&*(ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_";
26478/**
26479*  @_ignore
26480*/
26481function decodeBits(width, data) {
26482	const maxValue = (1 << width) - 1;
26483	const result = [];
26484	let accum = 0, bits = 0, flood = 0;
26485	for (let i = 0; i < data.length; i++) {
26486		accum = accum << 6 | Base64.indexOf(data[i]);
26487		bits += 6;
26488		while (bits >= width) {
26489			const value = accum >> bits - width;
26490			accum &= (1 << bits - width) - 1;
26491			bits -= width;
26492			if (value === 0) flood += maxValue;
26493			else {
26494				result.push(value + flood);
26495				flood = 0;
26496			}
26497		}
26498	}
26499	return result;
26500}
26501//#endregion
26502//#region node_modules/ethers/lib.esm/wordlists/decode-owla.js
26503/**
26504*  @_ignore
26505*/
26506function decodeOwlA(data, accents) {
26507	let words = decodeOwl(data).join(",");
26508	accents.split(/,/g).forEach((accent) => {
26509		const match = accent.match(/^([a-z]*)([0-9]+)([0-9])(.*)$/);
26510		assertArgument(match !== null, "internal error parsing accents", "accents", accents);
26511		let posOffset = 0;
26512		const positions = decodeBits(parseInt(match[3]), match[4]);
26513		const charCode = parseInt(match[2]);
26514		const regex = new RegExp(`([${match[1]}])`, "g");
26515		words = words.replace(regex, (all, letter) => {
26516			if (--positions[posOffset] === 0) {
26517				letter = String.fromCharCode(letter.charCodeAt(0), charCode);
26518				posOffset++;
26519			}
26520			return letter;
26521		});
26522	});
26523	return words.split(",");
26524}
26525//#endregion
26526//#region node_modules/ethers/lib.esm/wordlists/wordlist-owla.js
26527/**
26528*  An OWL-A format Wordlist extends the OWL format to add an
26529*  overlay onto an OWL format Wordlist to support diacritic
26530*  marks.
26531*
26532*  This class is generally not useful to most developers as
26533*  it is used mainly internally to keep Wordlists for languages
26534*  based on latin-1 small.
26535*
26536*  If necessary, there are tools within the ``generation/`` folder
26537*  to create the necessary data.
26538*/
26539var WordlistOwlA = class extends WordlistOwl {
26540	#accent;
26541	/**
26542	*  Creates a new Wordlist for %%locale%% using the OWLA %%data%%
26543	*  and %%accent%% data and validated against the %%checksum%%.
26544	*/
26545	constructor(locale, data, accent, checksum) {
26546		super(locale, data, checksum);
26547		this.#accent = accent;
26548	}
26549	/**
26550	*  The OWLA-encoded accent data.
26551	*/
26552	get _accent() {
26553		return this.#accent;
26554	}
26555	/**
26556	*  Decode all the words for the wordlist.
26557	*/
26558	_decodeWords() {
26559		return decodeOwlA(this._data, this._accent);
26560	}
26561};
26562//#endregion
26563//#region node_modules/ethers/lib.esm/wordlists/wordlists-browser.js
26564var wordlists = { en: LangEn.wordlist() };
26565//#endregion
26566//#region node_modules/ethers/lib.esm/ethers.js
26567var ethers_exports = /* @__PURE__ */ __exportAll({
26568	AbiCoder: () => AbiCoder,
26569	AbstractProvider: () => AbstractProvider,
26570	AbstractSigner: () => AbstractSigner,
26571	AlchemyProvider: () => AlchemyProvider,
26572	AnkrProvider: () => AnkrProvider,
26573	BaseContract: () => BaseContract,
26574	BaseWallet: () => BaseWallet,
26575	Block: () => Block,
26576	BlockscoutProvider: () => BlockscoutProvider,
26577	BrowserProvider: () => BrowserProvider,
26578	ChainstackProvider: () => ChainstackProvider,
26579	CloudflareProvider: () => CloudflareProvider,
26580	ConstructorFragment: () => ConstructorFragment,
26581	Contract: () => Contract,
26582	ContractEventPayload: () => ContractEventPayload,
26583	ContractFactory: () => ContractFactory,
26584	ContractTransactionReceipt: () => ContractTransactionReceipt,
26585	ContractTransactionResponse: () => ContractTransactionResponse,
26586	ContractUnknownEventPayload: () => ContractUnknownEventPayload,
26587	EnsPlugin: () => EnsPlugin,
26588	EnsResolver: () => EnsResolver,
26589	ErrorDescription: () => ErrorDescription,
26590	ErrorFragment: () => ErrorFragment,
26591	EtherSymbol: () => "Ξ",
26592	EtherscanPlugin: () => EtherscanPlugin,
26593	EtherscanProvider: () => EtherscanProvider,
26594	EventFragment: () => EventFragment,
26595	EventLog: () => EventLog,
26596	EventPayload: () => EventPayload,
26597	FallbackFragment: () => FallbackFragment,
26598	FallbackProvider: () => FallbackProvider,
26599	FeeData: () => FeeData,
26600	FeeDataNetworkPlugin: () => FeeDataNetworkPlugin,
26601	FetchCancelSignal: () => FetchCancelSignal,
26602	FetchRequest: () => FetchRequest,
26603	FetchResponse: () => FetchResponse,
26604	FetchUrlFeeDataNetworkPlugin: () => FetchUrlFeeDataNetworkPlugin,
26605	FixedNumber: () => FixedNumber,
26606	Fragment: () => Fragment,
26607	FunctionFragment: () => FunctionFragment,
26608	GasCostPlugin: () => GasCostPlugin,
26609	HDNodeVoidWallet: () => HDNodeVoidWallet,
26610	HDNodeWallet: () => HDNodeWallet,
26611	Indexed: () => Indexed,
26612	InfuraProvider: () => InfuraProvider,
26613	InfuraWebSocketProvider: () => InfuraWebSocketProvider,
26614	Interface: () => Interface,
26615	IpcSocketProvider: () => void 0,
26616	JsonRpcApiProvider: () => JsonRpcApiProvider,
26617	JsonRpcProvider: () => JsonRpcProvider,
26618	JsonRpcSigner: () => JsonRpcSigner,
26619	LangEn: () => LangEn,
26620	Log: () => Log,
26621	LogDescription: () => LogDescription,
26622	MaxInt256: () => MaxInt256,
26623	MaxUint256: () => MaxUint256,
26624	MessagePrefix: () =>

26624 MessagePrefix,
26625	MinInt256: () => MinInt256,
26626	Mnemonic: () => Mnemonic,
26627	MulticoinProviderPlugin: () => MulticoinProviderPlugin,
26628	N: () => N,
26629	NamedFragment: () => NamedFragment,
26630	Network: () => Network,
26631	NetworkPlugin: () => NetworkPlugin,
26632	NonceManager: () => NonceManager,
26633	ParamType: () => ParamType,
26634	PocketProvider: () => PocketProvider,
26635	QuickNodeProvider: () => QuickNodeProvider,
26636	Result: () => Result,
26637	Signature: () => Signature,
26638	SigningKey: () => SigningKey,
26639	SocketBlockSubscriber: () => SocketBlockSubscriber,
26640	SocketEventSubscriber: () => SocketEventSubscriber,
26641	SocketPendingSubscriber: () => SocketPendingSubscriber,
26642	SocketProvider: () => SocketProvider,
26643	SocketSubscriber: () => SocketSubscriber,
26644	StructFragment: () => StructFragment,
26645	Transaction: () => Transaction,
26646	TransactionDescription: () => TransactionDescription,
26647	TransactionReceipt: () => TransactionReceipt,
26648	TransactionResponse: () => TransactionResponse,
26649	Typed: () => Typed,
26650	TypedDataEncoder: () => TypedDataEncoder,
26651	UndecodedEventLog: () => UndecodedEventLog,
26652	UnmanagedSubscriber: () => UnmanagedSubscriber,
26653	Utf8ErrorFuncs: () => Utf8ErrorFuncs,
26654	VoidSigner: () => VoidSigner,
26655	Wallet: () => Wallet,
26656	WebSocketProvider: () => WebSocketProvider,
26657	WeiPerEther: () => WeiPerEther,
26658	Wordlist: () => Wordlist,
26659	WordlistOwl: () => WordlistOwl,
26660	WordlistOwlA: () => WordlistOwlA,
26661	ZeroAddress: () => ZeroAddress,
26662	ZeroHash: () => ZeroHash,
26663	accessListify: () => accessListify,
26664	assert: () => assert,
26665	assertArgument: () => assertArgument,
26666	assertArgumentCount: () => assertArgumentCount,
26667	assertNormalize: () => assertNormalize,
26668	assertPrivate: () => assertPrivate,
26669	authorizationify: () => authorizationify,
26670	checkResultErrors: () => checkResultErrors,
26671	computeAddress: () => computeAddress,
26672	computeHmac: () => computeHmac,
26673	concat: () => concat,
26674	copyRequest: () => copyRequest,
26675	dataLength: () => dataLength,
26676	dataSlice: () => dataSlice,
26677	decodeBase58: () => decodeBase58,
26678	decodeBase64: () => decodeBase64,
26679	decodeBytes32String: () => decodeBytes32String,
26680	decodeRlp: () => decodeRlp,
26681	decryptCrowdsaleJson: () => decryptCrowdsaleJson,
26682	decryptKeystoreJson: () => decryptKeystoreJson,
26683	decryptKeystoreJsonSync: () => decryptKeystoreJsonSync,
26684	defaultPath: () => defaultPath,
26685	defineProperties: () => defineProperties,
26686	dnsEncode: () => dnsEncode,
26687	encodeBase58: () => encodeBase58,
26688	encodeBase64: () => encodeBase64,
26689	encodeBytes32String: () => encodeBytes32String,
26690	encodeRlp: () => encodeRlp,
26691	encryptKeystoreJson: () =>

26691 encryptKeystoreJson,
26692	encryptKeystoreJsonSync: () => encryptKeystoreJsonSync,
26693	ensNormalize: () => ensNormalize,
26694	formatEther: () => formatEther,
26695	formatUnits: () => formatUnits,
26696	fromTwos: () => fromTwos,
26697	getAccountPath: () => getAccountPath,
26698	getAddress: () => getAddress,
26699	getBigInt: () => getBigInt,
26700	getBytes: () => getBytes,
26701	getBytesCopy: () => getBytesCopy,
26702	getCreate2Address: () => getCreate2Address,
26703	getCreateAddress: () => getCreateAddress,
26704	getDefaultProvider: () => getDefaultProvider,
26705	getIcapAddress: () => getIcapAddress,
26706	getIndexedAccountPath: () => getIndexedAccountPath,
26707	getNumber: () => getNumber,
26708	getUint: () => getUint,
26709	hashAuthorization: () => hashAuthorization,
26710	hashMessage: () => hashMessage,
26711	hexlify: () => hexlify,
26712	id: () => id,
26713	isAddress: () => isAddress,
26714	isAddressable: () => isAddressable,
26715	isBytesLike: () => isBytesLike,
26716	isCallException: () => isCallException,
26717	isCrowdsaleJson: () => isCrowdsaleJson,
26718	isError: () => isError,
26719	isHexString: () => isHexString,
26720	isKeystoreJson: () => isKeystoreJson,
26721	isValidName: () => isValidName,
26722	keccak256: () => keccak256,
26723	lock: () => lock,
26724	makeError: () => makeError,
26725	mask: () => mask,
26726	namehash: () => namehash,
26727	parseEther: () => parseEther,
26728	parseUnits: () => parseUnits,
26729	pbkdf2: () => pbkdf2,
26730	randomBytes: () => randomBytes,
26731	recoverAddress: () => recoverAddress,
26732	resolveAddress: () => resolveAddress,
26733	resolveProperties: () => resolveProperties,
26734	ripemd160: () => ripemd160,
26735	scrypt: () => scrypt,
26736	scryptSync: () => scryptSync,
26737	sha256: () => sha256,
26738	sha512: () => sha512,
26739	showThrottleMessage: () => showThrottleMessage,
26740	solidityPacked: () => solidityPacked,
26741	solidityPackedKeccak256: () => solidityPackedKeccak256,
26742	solidityPackedSha256: () => solidityPackedSha256,
26743	stripZerosLeft: () => stripZerosLeft,
26744	toBeArray: () => toBeArray,
26745	toBeHex: () => toBeHex,
26746	toBigInt: () => toBigInt,
26747	toNumber: () => toNumber,
26748	toQuantity: () => toQuantity,
26749	toTwos: () => toTwos,
26750	toUtf8Bytes: () => toUtf8Bytes,
26751	toUtf8CodePoints: () => toUtf8CodePoints,
26752	toUtf8String: () => toUtf8String,
26753	uuidV4: () => uuidV4,
26754	verifyAuthorization: () => verifyAuthorization,
26755	verifyMessage: () => verifyMessage,
26756	verifyTypedData: () => verifyTypedData,
26757	version: () => version,
26758	wordlists: () => wordlists,
26759	zeroPadBytes: () => zeroPadBytes,
26760	zeroPadValue: () => zeroPadValue
26761});
26762//#endregion
26763//#region node_modules/ethers/lib.esm/index.js
26764/**
26765*  The Application Programming Interface (API) is the collection of
26766*  functions, classes and types offered by the Ethers library.
26767*
26768*  @_section: api:Application Programming Interface  [about-api]
26769*  @_navTitle: API
26770*/
26771//#endregion
26772export { AbiCoder, AbstractProvider, AbstractSigner, AlchemyProvider, AnkrProvider, BaseContract, BaseWallet, Block, BlockscoutProvider, BrowserProvider, ChainstackProvider, CloudflareProvider, ConstructorFragment, Contract, ContractEventPayload, ContractFactory, ContractTransactionReceipt, ContractTransactionResponse, ContractUnknownEventPayload, EnsPlugin, EnsResolver, ErrorDescription, ErrorFragment, EtherSymbol, EtherscanPlugin, EtherscanProvider, EventFragment, EventLog, EventPayload, FallbackFragment, FallbackProvider, FeeData, FeeDataNetworkPlugin, FetchCancelSignal, FetchRequest, FetchResponse, FetchUrlFeeDataNetworkPlugin, FixedNumber, Fragment, FunctionFragment, GasCostPlugin, HDNodeVoidWallet, HDNodeWallet, Indexed, InfuraProvider, InfuraWebSocketProvider, Interface, IpcSocketProvider, JsonRpcApiProvider, JsonRpcProvider, JsonRpcSigner, LangEn, Log, LogDescription, MaxInt256, MaxUint256, MessagePrefix, MinInt256, Mnemonic, MulticoinProviderPlugin, N, NamedFragment, Network, NetworkPlugin, NonceManager, ParamType, PocketProvider, QuickNodeProvider, Result, Signature, SigningKey, SocketBlockSubscriber, SocketEventSubscriber, SocketPendingSubscriber, SocketProvider, SocketSubscriber, StructFragment, Transaction, TransactionDescription, TransactionReceipt, TransactionResponse, Typed, TypedDataEncoder, UndecodedEventLog, UnmanagedSubscriber, Utf8ErrorFuncs, VoidSigner, Wallet, WebSocketProvider, WeiPerEther, Wordlist, WordlistOwl, WordlistOwlA, ZeroAddress, ZeroHash, accessListify, assert, assertArgument, assertArgumentCount, assertNormalize, assertPrivate, authorizationify, checkResultErrors, computeAddress, computeHmac, concat, copyRequest, dataLength, dataSlice, decodeBase58, decodeBase64, decodeBytes32String, decodeRlp, decryptCrowdsaleJson, decryptKeystoreJson, decryptKeystoreJsonSync, defaultPath, defineProperties, dnsEncode, encodeBase58, encodeBase64, encodeBytes32String, encodeRlp, encryptKe

26772ystoreJson, encryptKeystoreJsonSync, ensNormalize, ethers_exports as ethers, formatEther, formatUnits, fromTwos, getAccountPath, getAddress, getBigInt, getBytes, getBytesCopy, getCreate2Address, getCreateAddress, getDefaultProvider, getIcapAddress, getIndexedAccountPath, getNumber, getUint, hashAuthorization, hashMessage, hexlify, id, isAddress, isAddressable, isBytesLike, isCallException, isCrowdsaleJson, isError, isHexString, isKeystoreJson, isValidName, keccak256, lock, makeError, mask, namehash, parseEther, parseUnits, pbkdf2, randomBytes, recoverAddress, resolveAddress, resolveProperties, ripemd160, scrypt, scryptSync, sha256, sha512, showThrottleMessage, solidityPacked, solidityPackedKeccak256, solidityPackedSha256, stripZerosLeft, toBeArray, toBeHex, toBigInt, toNumber, toQuantity, toTwos, toUtf8Bytes, toUtf8CodePoints, toUtf8String, uuidV4, verifyAuthorization, verifyMessage, verifyTypedData, version, wordlists, zeroPadBytes, zeroPadValue };
26773
26774//# sourceMappingURL=data:application/json;base64,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

26774cGVydGllcyB0byBlbnN1cmUgdGhleSBhcmUgYm90aFxuICogIGh1bWFuLXJlYWRhYmxlIChpLmUuIGBgLm1lc3NhZ2VgYCkgYW5kIG1hY2hpbmUtcmVhZGFibGUgKGkuZS4gYGAuY29kZWBgKS5cbiAqXG4gKiAgVGhlIFtbaXNFcnJvcl1dIGZ1bmN0aW9uIGNhbiBiZSB1c2VkIHRvIGNoZWNrIHRoZSBlcnJvciBgYGNvZGVgYCBhbmRcbiAqICBwcm92aWRlIGEgdHlwZSBndWFyZCBmb3IgdGhlIHByb3BlcnRpZXMgcHJlc2VudCBvbiB0aGF0IGVycm9yIGludGVyZmFjZS5cbiAqXG4gKiAgQF9zZWN0aW9uOiBhcGkvdXRpbHMvZXJyb3JzOkVycm9ycyAgW2Fib3V0LWVycm9yc11cbiAqL1xuaW1wb3J0IHsgdmVyc2lvbiB9IGZyb20gXCIuLi9fdmVyc2lvbi5qc1wiO1xuaW1wb3J0IHsgZGVmaW5lUHJvcGVydGllcyB9IGZyb20gXCIuL3Byb3BlcnRpZXMuanNcIjtcbmZ1bmN0aW9uIHN0cmluZ2lmeSh2YWx1ZSwgc2Vlbikge1xuICAgIGlmICh2YWx1ZSA9PSBudWxsKSB7XG4gICAgICAgIHJldHVybiBcIm51bGxcIjtcbiAgICB9XG4gICAgaWYgKHNlZW4gPT0gbnVsbCkge1xuICAgICAgICBzZWVuID0gbmV3IFNldCgpO1xuICAgIH1cbiAgICBpZiAodHlwZW9mICh2YWx1ZSkgPT09IFwib2JqZWN0XCIpIHtcbiAgICAgICAgaWYgKHNlZW4uaGFzKHZhbHVlKSkge1xuICAgICAgICAgICAgcmV0dXJuIFwiW0NpcmN1bGFyXVwiO1xuICAgICAgICB9XG4gICAgICAgIHNlZW4uYWRkKHZhbHVlKTtcbiAgICB9XG4gICAgaWYgKEFycmF5LmlzQXJyYXkodmFsdWUpKSB7XG4gICAgICAgIHJldHVybiBcIlsgXCIgKyAodmFsdWUubWFwKCh2KSA9PiBzdHJpbmdpZnkodiwgc2VlbikpKS5qb2luKFwiLCBcIikgKyBcIiBdXCI7XG4gICAgfVxuICAgIGlmICh2YWx1ZSBpbnN0YW5jZW9mIFVpbnQ4QXJyYXkpIHtcbiAgICAgICAgY29uc3QgSEVYID0gXCIwMTIzNDU2Nzg5YWJjZGVmXCI7XG4gICAgICAgIGxldCByZXN1bHQgPSBcIjB4XCI7XG4gICAgICAgIGZvciAobGV0IGkgPSAwOyBpIDwgdmFsdWUubGVuZ3RoOyBpKyspIHtcbiAgICAgICAgICAgIHJlc3VsdCArPSBIRVhbdmFsdWVbaV0gPj4gNF07XG4gICAgICAgICAgICByZXN1bHQgKz0gSEVYW3ZhbHVlW2ldICYgMHhmXTtcbiAgICAgICAgfVxuICAgICAgICByZXR1cm4gcmVzdWx0O1xuICAgIH1cbiAgICBpZiAodHlwZW9mICh2YWx1ZSkgPT09IFwib2JqZWN0XCIgJiYgdHlwZW9mICh2YWx1ZS50b0pTT04pID09PSBcImZ1bmN0aW9uXCIpIHtcbiAgICAgICAgcmV0dXJuIHN0cmluZ2lmeSh2YWx1ZS50b0pTT04oKSwgc2Vlbik7XG4gICAgfVxuICAgIHN3aXRjaCAodHlwZW9mICh2YWx1ZSkpIHtcbiAgICAgICAgY2FzZSBcImJvb2xlYW5cIjpcbiAgICAgICAgY2FzZSBcIm51bWJlclwiOlxuICAgICAgICBjYXNlIFwic3ltYm9sXCI6XG4gICAgICAgICAgICByZXR1cm4gdmFsdWUudG9TdHJpbmcoKTtcbiAgICAgICAgY2FzZSBcImJpZ2ludFwiOlxuICAgICAgICAgICAgcmV0dXJuIEJpZ0ludCh2YWx1ZSkudG9TdHJpbmcoKTtcbiAgICAgICAgY2FzZSBcInN0cmluZ1wiOlxuICAgICAgICAgICAgcmV0dXJuIEpTT04uc3RyaW5naWZ5KHZhbHVlKTtcbiAgICAgICAgY2FzZSBcIm9iamVjdFwiOiB7XG4gICAgICAgICAgICBjb25zdCBrZXlzID0gT2JqZWN0LmtleXModmFsdWUpO1xuICAgICAgICAgICAga2V5cy5zb3J0KCk7XG4gICAgICAgICAgICByZXR1cm4gXCJ7IFwiICsga2V5cy5tYXAoKGspID0+IGAke3N0cmluZ2lmeShrLCBzZWVuKX06ICR7c3RyaW5naWZ5KHZhbHVlW2tdLCBzZWVuKX1gKS5qb2luKFwiLCBcIikgKyBcIiB9XCI7XG4gICAgICAgIH1cbiAgICB9XG4gICAgcmV0dXJuIGBbIENPVUxEIE5PVCBTRVJJQUxJWkUgXWA7XG59XG4vKipcbiAqICBSZXR1cm5zIHRydWUgaWYgdGhlICUlZXJyb3IlJSBtYXRjaGVzIGFuIGVycm9yIHRocm93biBieSBldGhlcnNcbiAqICB0aGF0IG1hdGNoZXMgdGhlIGVycm9yICUlY29kZSUlLlxuICpcbiAqICBJbiBUeXBlU2NyaXB0IGVudmlyb25tZW50cywgdGhpcyBjYW4gYmUgdXNlZCB0byBjaGVjayB0aGF0ICUlZXJyb3IlJVxuICogIG1hdGNoZXMgYW4gRXRoZXJzRXJyb3IgdHlwZSwgd2hpY2ggbWVhbnMgdGhlIGV4cGVjdGVkIHByb3BlcnRpZXMgd2lsbFxuICogIGJlIHNldC5cbiAqXG4gKiAgQFNlZSBbRXJyb3JDb2Rlc10oYXBpOkVycm9yQ29kZSlcbiAqICBAZXhhbXBsZVxuICogICAgdHJ5IHtcbiAqICAgICAgLy8gY29

26774kZS4uLi5cbiAqICAgIH0gY2F0Y2ggKGUpIHtcbiAqICAgICAgaWYgKGlzRXJyb3IoZSwgXCJDQUxMX0VYQ0VQVElPTlwiKSkge1xuICogICAgICAgICAgLy8gVGhlIFR5cGUgR3VhcmQgaGFzIHZhbGlkYXRlZCB0aGlzIG9iamVjdFxuICogICAgICAgICAgY29uc29sZS5sb2coZS5kYXRhKTtcbiAqICAgICAgfVxuICogICAgfVxuICovXG5leHBvcnQgZnVuY3Rpb24gaXNFcnJvcihlcnJvciwgY29kZSkge1xuICAgIHJldHVybiAoZXJyb3IgJiYgZXJyb3IuY29kZSA9PT0gY29kZSk7XG59XG4vKipcbiAqICBSZXR1cm5zIHRydWUgaWYgJSVlcnJvciUlIGlzIGEgW1tDYWxsRXhjZXB0aW9uRXJyb3JdLlxuICovXG5leHBvcnQgZnVuY3Rpb24gaXNDYWxsRXhjZXB0aW9uKGVycm9yKSB7XG4gICAgcmV0dXJuIGlzRXJyb3IoZXJyb3IsIFwiQ0FMTF9FWENFUFRJT05cIik7XG59XG4vKipcbiAqICBSZXR1cm5zIGEgbmV3IEVycm9yIGNvbmZpZ3VyZWQgdG8gdGhlIGZvcm1hdCBldGhlcnMgZW1pdHMgZXJyb3JzLCB3aXRoXG4gKiAgdGhlICUlbWVzc2FnZSUlLCBbW2FwaTpFcnJvckNvZGVdXSAlJWNvZGUlJSBhbmQgYWRkaXRpb25hbCBwcm9wZXJ0aWVzXG4gKiAgZm9yIHRoZSBjb3JyZXNwb25kaW5nIEV0aGVyc0Vycm9yLlxuICpcbiAqICBFYWNoIGVycm9yIGluIGV0aGVycyBpbmNsdWRlcyB0aGUgdmVyc2lvbiBvZiBldGhlcnMsIGFcbiAqICBtYWNoaW5lLXJlYWRhYmxlIFtbRXJyb3JDb2RlXV0sIGFuZCBkZXBlbmRpbmcgb24gJSVjb2RlJSUsIGFkZGl0aW9uYWxcbiAqICByZXF1aXJlZCBwcm9wZXJ0aWVzLiBUaGUgZXJyb3IgbWVzc2FnZSB3aWxsIGFsc28gaW5jbHVkZSB0aGUgJSVtZXNzYWdlJSUsXG4gKiAgZXRoZXJzIHZlcnNpb24sICUlY29kZSUlIGFuZCBhbGwgYWRkaXRpb25hbCBwcm9wZXJ0aWVzLCBzZXJpYWxpemVkLlxuICovXG5leHBvcnQgZnVuY3Rpb24gbWFrZUVycm9yKG1lc3NhZ2UsIGNvZGUsIGluZm8pIHtcbiAgICBsZXQgc2hvcnRNZXNzYWdlID0gbWVzc2FnZTtcbiAgICB7XG4gICAgICAgIGNvbnN0IGRldGFpbHMgPSBbXTtcbiAgICAgICAgaWYgKGluZm8pIHtcbiAgICAgICAgICAgIGlmIChcIm1lc3NhZ2VcIiBpbiBpbmZvIHx8IFwiY29kZVwiIGluIGluZm8gfHwgXCJuYW1lXCIgaW4gaW5mbykge1xuICAgICAgICAgICAgICAgIHRocm93IG5ldyBFcnJvcihgdmFsdWUgd2lsbCBvdmVyd3JpdGUgcG9wdWxhdGVkIHZhbHVlczogJHtzdHJpbmdpZnkoaW5mbyl9YCk7XG4gICAgICAgICAgICB9XG4gICAgICAgICAgICBmb3IgKGNvbnN0IGtleSBpbiBpbmZvKSB7XG4gICAgICAgICAgICAgICAgaWYgKGtleSA9PT0gXCJzaG9ydE1lc3NhZ2VcIikge1xuICAgICAgICAgICAgICAgICAgICBjb250aW51ZTtcbiAgICAgICAgICAgICAgICB9XG4gICAgICAgICAgICAgICAgY29uc3QgdmFsdWUgPSAoaW5mb1trZXldKTtcbiAgICAgICAgICAgICAgICAvLyAgICAgICAgICAgICAgICB0cnkge1xuICAgICAgICAgICAgICAgIGRldGFpbHMucHVzaChrZXkgKyBcIj1cIiArIHN0cmluZ2lmeSh2YWx1ZSkpO1xuICAgICAgICAgICAgICAgIC8vICAgICAgICAgICAgICAgIH0gY2F0Y2ggKGVycm9yOiBhbnkpIHtcbiAgICAgICAgICAgICAgICAvLyAgICAgICAgICAgICAgICBjb25zb2xlLmxvZyhcIk1NTVwiLCBlcnJvci5tZXNzYWdlKTtcbiAgICAgICAgICAgICAgICAvLyAgICAgICAgICAgICAgICAgICAgZGV0YWlscy5wdXNoKGtleSArIFwiPVtjb3VsZCBub3Qgc2VyaWFsaXplIG9iamVjdF1cIik7XG4gICAgICAgICAgICAgICAgLy8gICAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgfVxuICAgICAgICB9XG4gICAgICAgIGRldGFpbHMucHVzaChgY29kZT0ke2NvZGV9YCk7XG4gICAgICAgIGRldGFpbHMucHVzaChgdmVyc2lvbj0ke3ZlcnNpb259YCk7XG4gICAgICAgIGlmIChkZXRhaWxzLmxlbmd0aCkge1xuICAgICAgICAgICAgbWVzc2FnZSArPSBcIiAoXCIgKyBkZXRhaWxzLmpvaW4oXCIsIFwiKSArIFwiKVwiO1xuICAgICAgICB9XG4gICAgfVxuICAgIGxldCBlcnJvcjtcbiAgICBzd2l0Y2ggKGNvZGUpIHtcbiAgICAgICAgY2FzZSBcIklOVkFMSURfQVJHVU1FTlRcIjpcbiAgICAgICAgICAgIGVycm9yID0gbmV3IFR5cGVFcnJvcihtZXNzYWdlKTtcbiAgICAgICAgICAgIGJyZWFrO1xuICAgICAgICBjYXNlIFwiTlVNRVJJQ19GQVVMVFwiOlxuICAgICAgICBjYXNlIFwiQlVGRkVSX09WRVJSVU5cIjpcbiAgICAgICAgICAgIGVycm9yID0gbmV3IFJhbmdlRXJyb3IobWVzc2FnZSk7XG4gICAgICAgICAgICBicmVhaztcbiAgICAgICAgZGVmYXVsdDpcbiAgICAgICAgICAgIGVycm9yID0gbmV3IEVycm9yKG1lc3NhZ2UpO1xuICAgIH1cbiAgICBkZWZpbmVQcm9wZXJ0aWVzKGVycm9yLCB7IGNvZGUgfSk7XG4gICAgaWYgKGluZm8pIHtcbiAgICAgICAgT2JqZWN0LmFzc2lnbihlcnJvciwgaW5mbyk7XG4gICAgfVxuICAgIGlmIChlcnJvci5zaG9ydE1lc3NhZ2UgPT0gbnVsbCkge1xuICAgICAgICBkZWZpbmVQcm9wZXJ0aWVzKGVycm9yLCB7IHNob3J0TWVzc2FnZSB9KTtcbiAgICB9XG4gICAgcmV0dXJuIGVycm9yO1xufVxuLyoqXG4gKiAgVGhyb3dzIGFuIEV0aGVyc0Vycm9yIHdpdGggJSVtZXNzYWdlJSUsICUlY29kZSUlIGFuZCBhZGRpdGlvbmFsIGVycm9yXG4gKiAgJSVpbmZvJSUgd2hlbiAlJWNoZWNrJSUgaXMgZmFsc2lzaC4uXG4gKlxuICogIEBzZWUgW1thcGk6bWFrZUVycm9yXV1cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGFzc2VydChjaGVjaywgbWVzc2FnZSwgY29kZSwgaW5mbykge1xuICAgIGlmICghY2hlY2spIHtcbiAgICAgICAgdGhyb3cgbWFrZUVycm9yKG1lc3NhZ2UsIGNvZGUsIGluZm8pO1xuICAgIH1cbn1cbi8qKlxuICogIEEgc2ltcGxlIGhlbHBlciB0byBzaW1wbHkgZW5zdXJpbmcgcHJvdmlkZWQgYXJndW1lbnRzIG1hdGNoIGV4cGVjdGVkXG4gKiAgY29uc3RyYWludHMsIHRocm93aW5nIGlmIG5vdC5cbiAqXG4gKiAgSW4gVHlwZVNjcmlwdCBlbnZpcm9ubWVudHMsIHRoZSAlJWNoZWNrJSUgaGFzIGJlZW4gYXNzZXJ0ZWQgdHJ1ZSwgc29cbiAqICBhbnkgZnVydGhlciBjb2RlIGRvZXMgbm90IG5lZWQgYWRkaXRpb25hbCBjb21waWxlLXRpbWUgY2hlY2tz

26774LlxuICovXG5leHBvcnQgZnVuY3Rpb24gYXNzZXJ0QXJndW1lbnQoY2hlY2ssIG1lc3NhZ2UsIG5hbWUsIHZhbHVlKSB7XG4gICAgYXNzZXJ0KGNoZWNrLCBtZXNzYWdlLCBcIklOVkFMSURfQVJHVU1FTlRcIiwgeyBhcmd1bWVudDogbmFtZSwgdmFsdWU6IHZhbHVlIH0pO1xufVxuZXhwb3J0IGZ1bmN0aW9uIGFzc2VydEFyZ3VtZW50Q291bnQoY291bnQsIGV4cGVjdGVkQ291bnQsIG1lc3NhZ2UpIHtcbiAgICBpZiAobWVzc2FnZSA9PSBudWxsKSB7XG4gICAgICAgIG1lc3NhZ2UgPSBcIlwiO1xuICAgIH1cbiAgICBpZiAobWVzc2FnZSkge1xuICAgICAgICBtZXNzYWdlID0gXCI6IFwiICsgbWVzc2FnZTtcbiAgICB9XG4gICAgYXNzZXJ0KGNvdW50ID49IGV4cGVjdGVkQ291bnQsIFwibWlzc2luZyBhcmd1bWVudFwiICsgbWVzc2FnZSwgXCJNSVNTSU5HX0FSR1VNRU5UXCIsIHtcbiAgICAgICAgY291bnQ6IGNvdW50LFxuICAgICAgICBleHBlY3RlZENvdW50OiBleHBlY3RlZENvdW50XG4gICAgfSk7XG4gICAgYXNzZXJ0KGNvdW50IDw9IGV4cGVjdGVkQ291bnQsIFwidG9vIG1hbnkgYXJndW1lbnRzXCIgKyBtZXNzYWdlLCBcIlVORVhQRUNURURfQVJHVU1FTlRcIiwge1xuICAgICAgICBjb3VudDogY291bnQsXG4gICAgICAgIGV4cGVjdGVkQ291bnQ6IGV4cGVjdGVkQ291bnRcbiAgICB9KTtcbn1cbmNvbnN0IF9ub3JtYWxpemVGb3JtcyA9IFtcIk5GRFwiLCBcIk5GQ1wiLCBcIk5GS0RcIiwgXCJORktDXCJdLnJlZHVjZSgoYWNjdW0sIGZvcm0pID0+IHtcbiAgICB0cnkge1xuICAgICAgICAvLyBHZW5lcmFsIHRlc3QgZm9yIG5vcm1hbGl6ZVxuICAgICAgICAvKiBjOCBpZ25vcmUgc3RhcnQgKi9cbiAgICAgICAgaWYgKFwidGVzdFwiLm5vcm1hbGl6ZShmb3JtKSAhPT0gXCJ0ZXN0XCIpIHtcbiAgICAgICAgICAgIHRocm93IG5ldyBFcnJvcihcImJhZFwiKTtcbiAgICAgICAgfVxuICAgICAgICA7XG4gICAgICAgIC8qIGM4IGlnbm9yZSBzdG9wICovXG4gICAgICAgIGlmIChmb3JtID09PSBcIk5GRFwiKSB7XG4gICAgICAgICAgICBjb25zdCBjaGVjayA9IFN0cmluZy5mcm9tQ2hhckNvZGUoMHhlOSkubm9ybWFsaXplKFwiTkZEXCIpO1xuICAgICAgICAgICAgY29uc3QgZXhwZWN0ZWQgPSBTdHJpbmcuZnJvbUNoYXJDb2RlKDB4NjUsIDB4MDMwMSk7XG4gICAgICAgICAgICAvKiBjOCBpZ25vcmUgc3RhcnQgKi9cbiAgICAgICAgICAgIGlmIChjaGVjayAhPT0gZXhwZWN0ZWQpIHtcbiAgICAgICAgICAgICAgICB0aHJvdyBuZXcgRXJyb3IoXCJicm9rZW5cIik7XG4gICAgICAgICAgICB9XG4gICAgICAgICAgICAvKiBjOCBpZ25vcmUgc3RvcCAqL1xuICAgICAgICB9XG4gICAgICAgIGFjY3VtLnB1c2goZm9ybSk7XG4gICAgfVxuICAgIGNhdGNoIChlcnJvcikgeyB9XG4gICAgcmV0dXJuIGFjY3VtO1xufSwgW10pO1xuLyoqXG4gKiAgVGhyb3dzIGlmIHRoZSBub3JtYWxpemF0aW9uICUlZm9ybSUlIGlzIG5vdCBzdXBwb3J0ZWQuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBhc3NlcnROb3JtYWxpemUoZm9ybSkge1xuICAgIGFzc2VydChfbm9ybWFsaXplRm9ybXMuaW5kZXhPZihmb3JtKSA+PSAwLCBcInBsYXRmb3JtIG1pc3NpbmcgU3RyaW5nLnByb3RvdHlwZS5ub3JtYWxpemVcIiwgXCJVTlNVUFBPUlRFRF9PUEVSQVRJT05cIiwge1xuICAgICAgICBvcGVyYXRpb246IFwiU3RyaW5nLnByb3RvdHlwZS5ub3JtYWxpemVcIiwgaW5mbzogeyBmb3JtIH1cbiAgICB9KTtcbn1cbi8qKlxuICogIE1hbnkgY2xhc3NlcyB1c2UgZmlsZS1zY29wZWQgdmFsdWVzIHRvIGd1YXJkIHRoZSBjb25zdHJ1Y3RvcixcbiAqICBtYWtpbmcgaXQgZWZmZWN0aXZlbHkgcHJpdmF0ZS4gVGhpcyBmYWNpbGl0YXRlcyB0aGF0IHBhdHRlcm5cbiAqICBieSBlbnN1cmluZyB0aGUgJSVnaXZlbkdhdXJkJSUgbWF0Y2hlcyB0aGUgZmlsZS1zY29wZWQgJSVndWFyZCUlLFxuICogIHRocm93aW5nIGlmIG5vdCwgaW5kaWNhdGluZyB0aGUgJSVjbGFzc05hbWUlJSBpZiBwcm92aWRlZC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGFzc2VydFByaXZhdGUoZ2l2ZW5HdWFyZCwgZ3VhcmQsIGNsYXNzTmFtZSkge1xuICAgIGlmIChjbGFzc05hbWUgPT0gbnVsbCkge1xuICAgICAgICBjbGFzc05hbWUgPSBcIlwiO1xuICAgIH1cbiAgICBpZiAoZ2l2ZW5HdWFyZCAhPT0gZ3VhcmQpIHtcbiAgICAgICAgbGV0IG1ldGhvZCA9IGNsYXNzTmFtZSwgb3BlcmF0aW9uID0gXCJuZXdcIjtcbiAgICAgICAgaWYgKGNsYXNzTmFtZSkge1xuICAgICAgICAgICAgbWV0aG9kICs9IFwiLlwiO1xuICAgICAgICAgICAgb3BlcmF0aW9uICs9IFwiIFwiICsgY2xhc3NOYW1lO1xuICAgICAgICB9XG4gICAgICAgIGFzc2VydChmYWxzZSwgYHByaXZhdGUgY29uc3RydWN0b3I7IHVzZSAke21ldGhvZH1mcm9tKiBtZXRob2RzYCwgXCJVTlNVUFBPUlRFRF9PUEVSQVRJT05cIiwge1xuICAgICAgICAgICAgb3BlcmF0aW9uXG4gICAgICAgIH0pO1xuICAgIH1cbn1cbi8vIyBzb3VyY2VNYXBwaW5nVVJMPWVycm9ycy5qcy5tYXAiLCIvKipcbiAqICBTb21lIGRhdGEgaGVscGVycy5cbiAqXG4gKlxuICogIEBfc3Vic2VjdGlvbiBhcGkvdXRpbHM6RGF0YSBIZWxwZXJzICBbYWJvdXQtZGF0YV1cbiAqL1xuaW1wb3J0IHsgYXNzZXJ0LCBhc3NlcnRBcmd1bWVudCB9IGZyb20gXCIuL2Vycm9ycy5qc1wiO1xuZnVuY3Rpb24gX2dldEJ5dGVzKHZhbHVlLCBuYW1lLCBjb3B5KSB7XG4gICAgaWYgKHZhbHVlIGluc3RhbmNlb2YgVWludDhBcnJheSkge1xuICAgICAgICBpZiAoY29weSkge1xuICAgICAgICAgICAgcmV0dXJuIG5ldyBVaW50OEFycmF5KHZhbHVlKTtcbiAgICAgICAgfVxuICAgICAgICByZXR1cm4gdmFsdWU7XG4gICAgfVxuICAgIGlmICh0eXBlb2YgKHZhbHVlKSA9PT0gXCJzdHJpbmdcIiAmJiAodmFsdWUubGVuZ3RoICUgMikgPT09IDAgJiZcbiAgICAgICAgdmFsdWUubWF0Y2goL14weFswLTlhLWZdKiQvaSkpIHtcbiAgICAgICAgY29uc3QgcmVzdWx0ID0gbmV3IFVpbnQ4QXJyYXkoKHZhbHVlLmxlbmd0aCAtIDIpIC8gMik7XG4gICAgICAgIGxldCBvZmZzZXQgPSAyO1xuICAgICAgICBmb3IgKGxldCBpID0gMDsgaSA8IHJlc3VsdC5sZW5ndGg7IGkrKykge1xuICAgICAgICAgICAgcmVzdWx0W2ldID0gcGFyc2VJbnQodmFsdWUuc3Vic3RyaW5nKG9mZnNldCwgb2Zmc2V0ICsgMiksIDE2KTtcbiAgICAgICAgICAgIG9mZnNldCArPSAyO1xuICAgICAgICB9XG4gICAgICAgI

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

26774LyBkb2VzIG5vdCBoYXZlIGFuZCBsZWFkaW5nIDAgdmFsdWVzIHVubGVzcyB0aGUgdmFsdWUgaXNcbiAqICB0aGUgbGl0ZXJhbCB2YWx1ZSBgMHgwYC4gVGhpcyBpcyBtb3N0IGNvbW1vbmx5IHVzZWQgZm9yIEpTU09OLVJQQ1xuICogIG51bWVyaWMgdmFsdWVzLlxuICovXG5leHBvcnQgZnVuY3Rpb24gdG9RdWFudGl0eSh2YWx1ZSkge1xuICAgIGxldCByZXN1bHQgPSBoZXhsaWZ5KGlzQnl0ZXNMaWtlKHZhbHVlKSA/IHZhbHVlIDogdG9CZUFycmF5KHZhbHVlKSkuc3Vic3RyaW5nKDIpO1xuICAgIHdoaWxlIChyZXN1bHQuc3RhcnRzV2l0aChcIjBcIikpIHtcbiAgICAgICAgcmVzdWx0ID0gcmVzdWx0LnN1YnN0cmluZygxKTtcbiAgICB9XG4gICAgaWYgKHJlc3VsdCA9PT0gXCJcIikge1xuICAgICAgICByZXN1bHQgPSBcIjBcIjtcbiAgICB9XG4gICAgcmV0dXJuIFwiMHhcIiArIHJlc3VsdDtcbn1cbi8vIyBzb3VyY2VNYXBwaW5nVVJMPW1hdGhzLmpzLm1hcCIsIi8qKlxuICogIFRoZSBbQmFzZTU4IEVuY29kaW5nXShsaW5rLWJhc2U1OCkgc2NoZW1lIGFsbG93cyBhICoqbnVtZXJpYyoqIHZhbHVlXG4gKiAgdG8gYmUgZW5jb2RlZCBhcyBhIGNvbXBhY3Qgc3RyaW5nIHVzaW5nIGEgcmFkaXggb2YgNTggdXNpbmcgb25seVxuICogIGFscGhhLW51bWVyaWMgY2hhcmFjdGVycy4gQ29uZnVzaW5nbHkgc2ltaWxhciBjaGFyYWN0ZXJzIGFyZSBvbWl0dGVkXG4gKiAgKGkuZS4gYGBcImwwT1wiYGApLlxuICpcbiAqICBOb3RlIHRoYXQgQmFzZTU4IGVuY29kZXMgYSAqKm51bWVyaWMqKiB2YWx1ZSwgbm90IGFyYml0cmFyeSBieXRlcyxcbiAqICBzaW5jZSBhbnkgemVyby1ieXRlcyBvbiB0aGUgbGVmdCB3b3VsZCBnZXQgcmVtb3ZlZC4gVG8gbWl0aWdhdGUgdGhpc1xuICogIGlzc3VlIG1vc3Qgc2NoZW1lcyB0aGF0IHVzZSBCYXNlNTggY2hvb3NlIHNwZWNpZmljIGhpZ2gtb3JkZXIgdmFsdWVzXG4gKiAgdG8gZW5zdXJlIG5vbi16ZXJvIHByZWZpeGVzLlxuICpcbiAqICBAX3N1YnNlY3Rpb246IGFwaS91dGlsczpCYXNlNTggRW5jb2RpbmcgW2Fib3V0LWJhc2U1OF1cbiAqL1xuaW1wb3J0IHsgZ2V0Qnl0ZXMgfSBmcm9tIFwiLi9kYXRhLmpzXCI7XG5pbXBvcnQgeyBhc3NlcnRBcmd1bWVudCB9IGZyb20gXCIuL2Vycm9ycy5qc1wiO1xuaW1wb3J0IHsgdG9CaWdJbnQgfSBmcm9tIFwiLi9tYXRocy5qc1wiO1xuY29uc3QgQWxwaGFiZXQgPSBcIjEyMzQ1Njc4OUFCQ0RFRkdISktMTU5QUVJTVFVWV1hZWmFiY2RlZmdoaWprbW5vcHFyc3R1dnd4eXpcIjtcbmxldCBMb29rdXAgPSBudWxsO1xuZnVuY3Rpb24gZ2V0QWxwaGEobGV0dGVyKSB7XG4gICAgaWYgKExvb2t1cCA9PSBudWxsKSB7XG4gICAgICAgIExvb2t1cCA9IHt9O1xuICAgICAgICBmb3IgKGxldCBpID0gMDsgaSA8IEFscGhhYmV0Lmxlbmd0aDsgaSsrKSB7XG4gICAgICAgICAgICBMb29rdXBbQWxwaGFiZXRbaV1dID0gQmlnSW50KGkpO1xuICAgICAgICB9XG4gICAgfVxuICAgIGNvbnN0IHJlc3VsdCA9IExvb2t1cFtsZXR0ZXJdO1xuICAgIGFzc2VydEFyZ3VtZW50KHJlc3VsdCAhPSBudWxsLCBgaW52YWxpZCBiYXNlNTggdmFsdWVgLCBcImxldHRlclwiLCBsZXR0ZXIpO1xuICAgIHJldHVybiByZXN1bHQ7XG59XG5jb25zdCBCTl8wID0gQmlnSW50KDApO1xuY29uc3QgQk5fNTggPSBCaWdJbnQoNTgpO1xuLyoqXG4gKiAgRW5jb2RlICUldmFsdWUlJSBhcyBhIEJhc2U1OC1lbmNvZGVkIHN0cmluZy5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGVuY29kZUJhc2U1OChfdmFsdWUpIHtcbiAgICBjb25zdCBieXRlcyA9IGdldEJ5dGVzKF92YWx1ZSk7XG4gICAgbGV0IHZhbHVlID0gdG9CaWdJbnQoYnl0ZXMpO1xuICAgIGxldCByZXN1bHQgPSBcIlwiO1xuICAgIHdoaWxlICh2YWx1ZSkge1xuICAgICAgICByZXN1bHQgPSBBbHBoYWJldFtOdW1iZXIodmFsdWUgJSBCTl81OCldICsgcmVzdWx0O1xuICAgICAgICB2YWx1ZSAvPSBCTl81ODtcbiAgICB9XG4gICAgLy8gQWNjb3VudCBmb3IgbGVhZGluZyBwYWRkaW5nIHplcm9zXG4gICAgZm9yIChsZXQgaSA9IDA7IGkgPCBieXRlcy5sZW5ndGg7IGkrKykge1xuICAgICAgICBpZiAoYnl0ZXNbaV0pIHtcbiAgICAgICAgICAgIGJyZWFrO1xuICAgICAgICB9XG4gICAgICAgIHJlc3VsdCA9IEFscGhhYmV0WzBdICsgcmVzdWx0O1xuICAgIH1cbiAgICByZXR1cm4gcmVzdWx0O1xufVxuLyoqXG4gKiAgRGVjb2RlIHRoZSBCYXNlNTgtZW5jb2RlZCAlJXZhbHVlJSUuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBkZWNvZGVCYXNlNTgodmFsdWUpIHtcbiAgICBsZXQgcmVzdWx0ID0gQk5fMDtcbiAgICBmb3IgKGxldCBpID0gMDsgaSA8IHZhbHVlLmxlbmd0aDsgaSsrKSB7XG4gICAgICAgIHJlc3VsdCAqPSBCTl81ODtcbiAgICAgICAgcmVzdWx0ICs9IGdldEFscGhhKHZhbHVlW2ldKTtcbiAgICB9XG4gICAgcmV0dXJuIHJlc3VsdDtcbn1cbi8vIyBzb3VyY2VNYXBwaW5nVVJMPWJhc2U1OC5qcy5tYXAiLCIvLyB1dGlscy9iYXNlNjQtYnJvd3NlclxuaW1wb3J0IHsgZ2V0Qnl0ZXMgfSBmcm9tIFwiLi9kYXRhLmpzXCI7XG5leHBvcnQgZnVuY3Rpb24gZGVjb2RlQmFzZTY0KHRleHREYXRhKSB7XG4gICAgdGV4dERhdGEgPSBhdG9iKHRleHREYXRhKTtcbiAgICBjb25zdCBkYXRhID0gbmV3IFVpbnQ4QXJyYXkodGV4dERhdGEubGVuZ3RoKTtcbiAgICBmb3IgKGxldCBpID0gMDsgaSA8IHRleHREYXRhLmxlbmd0aDsgaSsrKSB7XG4gICAgICAgIGRhdGFbaV0gPSB0ZXh0RGF0YS5jaGFyQ29kZUF0KGkpO1xuICAgIH1cbiAgICByZXR1cm4gZ2V0Qnl0ZXMoZGF0YSk7XG59XG5leHBvcnQgZnVuY3Rpb24gZW5jb2RlQmFzZTY0KF9kYXRhKSB7XG4gICAgY29uc3QgZGF0YSA9IGdldEJ5dGVzKF9kYXRhKTtcbiAgICBsZXQgdGV4dERhdGEgPSBcIlwiO1xuICAgIGZvciAobGV0IGkgPSAwOyBpIDwgZGF0YS5sZW5ndGg7IGkrKykge1xuICAgICAgICB0ZXh0RGF0YSArPSBTdHJpbmcuZnJvbUNoYXJDb2RlKGRhdGFbaV0pO1xuICAgIH1cbiAgICByZXR1cm4gYnRvYSh0ZXh0RGF0YSk7XG59XG4vLyMgc291cmNlTWFwcGluZ1VSTD1iYXNlNjQtYnJvd3Nlci5qcy5tYXAiLCIvKipcbiAqICBFdmVudHMgYWxsb3cgZm9yIGFwcGxpY2F0aW9ucyB0byB1c2UgdGhlIG9ic2VydmVyIHBhdHRlcm4sIHdoaWNoXG4gKiAgYWxsb3dzIHN1YnNjcmliaW5nIGFuZCBwdWJsaXNoaW5nIGV2ZW50cywgb3V0c2lkZSB0aGUgbm9ybWFsXG4gKiAgZXhlY3V0aW9uIHBhdGhzLlxuICpcbiAqICBAX3NlY3Rpb24gYXBpL3V0aWxzL2V2ZW50czpFdmVudHMgIFthYm91dC1ldmVud

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

26774R0cDovL3N0YWNrb3ZlcmZsb3cuY29tL3F1ZXN0aW9ucy8xMzM1NjQ5My9kZWNvZGUtdXRmLTgtd2l0aC1qYXZhc2NyaXB0IzEzNjkxNDk5XG5mdW5jdGlvbiBnZXRVdGY4Q29kZVBvaW50cyhfYnl0ZXMsIG9uRXJyb3IpIHtcbiAgICBpZiAob25FcnJvciA9PSBudWxsKSB7XG4gICAgICAgIG9uRXJyb3IgPSBVdGY4RXJyb3JGdW5jcy5lcnJvcjtcbiAgICB9XG4gICAgY29uc3QgYnl0ZXMgPSBnZXRCeXRlcyhfYnl0ZXMsIFwiYnl0ZXNcIik7XG4gICAgY29uc3QgcmVzdWx0ID0gW107XG4gICAgbGV0IGkgPSAwO1xuICAgIC8vIEludmFsaWQgYnl0ZXMgYXJlIGlnbm9yZWRcbiAgICB3aGlsZSAoaSA8IGJ5dGVzLmxlbmd0aCkge1xuICAgICAgICBjb25zdCBjID0gYnl0ZXNbaSsrXTtcbiAgICAgICAgLy8gMHh4eCB4eHh4XG4gICAgICAgIGlmIChjID4+IDcgPT09IDApIHtcbiAgICAgICAgICAgIHJlc3VsdC5wdXNoKGMpO1xuICAgICAgICAgICAgY29udGludWU7XG4gICAgICAgIH1cbiAgICAgICAgLy8gTXVsdGlieXRlOyBob3cgbWFueSBieXRlcyBsZWZ0IGZvciB0aGlzIGNoYXJhY3Rlcj9cbiAgICAgICAgbGV0IGV4dHJhTGVuZ3RoID0gbnVsbDtcbiAgICAgICAgbGV0IG92ZXJsb25nTWFzayA9IG51bGw7XG4gICAgICAgIC8vIDExMHggeHh4eCAxMHh4IHh4eHhcbiAgICAgICAgaWYgKChjICYgMHhlMCkgPT09IDB4YzApIHtcbiAgICAgICAgICAgIGV4dHJhTGVuZ3RoID0gMTtcbiAgICAgICAgICAgIG92ZXJsb25nTWFzayA9IDB4N2Y7XG4gICAgICAgICAgICAvLyAxMTEwIHh4eHggMTB4eCB4eHh4IDEweHggeHh4eFxuICAgICAgICB9XG4gICAgICAgIGVsc2UgaWYgKChjICYgMHhmMCkgPT09IDB4ZTApIHtcbiAgICAgICAgICAgIGV4dHJhTGVuZ3RoID0gMjtcbiAgICAgICAgICAgIG92ZXJsb25nTWFzayA9IDB4N2ZmO1xuICAgICAgICAgICAgLy8gMTExMSAweHh4IDEweHggeHh4eCAxMHh4IHh4eHggMTB4eCB4eHh4XG4gICAgICAgIH1cbiAgICAgICAgZWxzZSBpZiAoKGMgJiAweGY4KSA9PT0gMHhmMCkge1xuICAgICAgICAgICAgZXh0cmFMZW5ndGggPSAzO1xuICAgICAgICAgICAgb3ZlcmxvbmdNYXNrID0gMHhmZmZmO1xuICAgICAgICB9XG4gICAgICAgIGVsc2Uge1xuICAgICAgICAgICAgaWYgKChjICYgMHhjMCkgPT09IDB4ODApIHtcbiAgICAgICAgICAgICAgICBpICs9IG9uRXJyb3IoXCJVTkVYUEVDVEVEX0NPTlRJTlVFXCIsIGkgLSAxLCBieXRlcywgcmVzdWx0KTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgICAgIGVsc2Uge1xuICAgICAgICAgICAgICAgIGkgKz0gb25FcnJvcihcIkJBRF9QUkVGSVhcIiwgaSAtIDEsIGJ5dGVzLCByZXN1bHQpO1xuICAgICAgICAgICAgfVxuICAgICAgICAgICAgY29udGludWU7XG4gICAgICAgIH1cbiAgICAgICAgLy8gRG8gd2UgaGF2ZSBlbm91Z2ggYnl0ZXMgaW4gb3VyIGRhdGE/XG4gICAgICAgIGlmIChpIC0gMSArIGV4dHJhTGVuZ3RoID49IGJ5dGVzLmxlbmd0aCkge1xuICAgICAgICAgICAgaSArPSBvbkVycm9yKFwiT1ZFUlJVTlwiLCBpIC0gMSwgYnl0ZXMsIHJlc3VsdCk7XG4gICAgICAgICAgICBjb250aW51ZTtcbiAgICAgICAgfVxuICAgICAgICAvLyBSZW1vdmUgdGhlIGxlbmd0aCBwcmVmaXggZnJvbSB0aGUgY2hhclxuICAgICAgICBsZXQgcmVzID0gYyAmICgoMSA8PCAoOCAtIGV4dHJhTGVuZ3RoIC0gMSkpIC0gMSk7XG4gICAgICAgIGZvciAobGV0IGogPSAwOyBqIDwgZXh0cmFMZW5ndGg7IGorKykge1xuICAgICAgICAgICAgbGV0IG5leHRDaGFyID0gYnl0ZXNbaV07XG4gICAgICAgICAgICAvLyBJbnZhbGlkIGNvbnRpbnVhdGlvbiBieXRlXG4gICAgICAgICAgICBpZiAoKG5leHRDaGFyICYgMHhjMCkgIT0gMHg4MCkge1xuICAgICAgICAgICAgICAgIGkgKz0gb25FcnJvcihcIk1JU1NJTkdfQ09OVElOVUVcIiwgaSwgYnl0ZXMsIHJlc3VsdCk7XG4gICAgICAgICAgICAgICAgcmVzID0gbnVsbDtcbiAgICAgICAgICAgICAgICBicmVhaztcbiAgICAgICAgICAgIH1cbiAgICAgICAgICAgIDtcbiAgICAgICAgICAgIHJlcyA9IChyZXMgPDwgNikgfCAobmV4dENoYXIgJiAweDNmKTtcbiAgICAgICAgICAgIGkrKztcbiAgICAgICAgfVxuICAgICAgICAvLyBTZWUgYWJvdmUgbG9vcCBmb3IgaW52YWxpZCBjb250aW51YXRpb24gYnl0ZVxuICAgICAgICBpZiAocmVzID09PSBudWxsKSB7XG4gICAgICAgICAgICBjb250aW51ZTtcbiAgICAgICAgfVxuICAgICAgICAvLyBNYXhpbXVtIGNvZGUgcG9pbnRcbiAgICAgICAgaWYgKHJlcyA+IDB4MTBmZmZmKSB7XG4gICAgICAgICAgICBpICs9IG9uRXJyb3IoXCJPVVRfT0ZfUkFOR0VcIiwgaSAtIDEgLSBleHRyYUxlbmd0aCwgYnl0ZXMsIHJlc3VsdCwgcmVzKTtcbiAgICAgICAgICAgIGNvbnRpbnVlO1xuICAgICAgICB9XG4gICAgICAgIC8vIFJlc2VydmVkIGZvciBVVEYtMTYgc3Vycm9nYXRlIGhhbHZlc1xuICAgICAgICBpZiAocmVzID49IDB4ZDgwMCAmJiByZXMgPD0gMHhkZmZmKSB7XG4gICAgICAgICAgICBpICs9IG9uRXJyb3IoXCJVVEYxNl9TVVJST0dBVEVcIiwgaSAtIDEgLSBleHRyYUxlbmd0aCwgYnl0ZXMsIHJlc3VsdCwgcmVzKTtcbiAgICAgICAgICAgIGNvbnRpbnVlO1xuICAgICAgICB9XG4gICAgICAgIC8vIENoZWNrIGZvciBvdmVybG9uZyBzZXF1ZW5jZXMgKG1vcmUgYnl0ZXMgdGhhbiBuZWVkZWQpXG4gICAgICAgIGlmIChyZXMgPD0gb3ZlcmxvbmdNYXNrKSB7XG4gICAgICAgICAgICBpICs9IG9uRXJyb3IoXCJPVkVSTE9OR1wiLCBpIC0gMSAtIGV4dHJhTGVuZ3RoLCBieXRlcywgcmVzdWx0LCByZXMpO1xuICAgICAgICAgICAgY29udGludWU7XG4gICAgICAgIH1cbiAgICAgICAgcmVzdWx0LnB1c2gocmVzKTtcbiAgICB9XG4gICAgcmV0dXJuIHJlc3VsdDtcbn1cbi8vIGh0dHA6Ly9zdGFja292ZXJmbG93LmNvbS9xdWVzdGlvbnMvMTg3Mjk0MDUvaG93LXRvLWNvbnZlcnQtdXRmOC1zdHJpbmctdG8tYnl0ZS1hcnJheVxuLyoqXG4gKiAgUmV0dXJucyB0aGUgVVRGLTggYnl0ZSByZXByZXNlbnRhdGlvbiBvZiAlJXN0ciUlLlxuICpcbiAqICBJZiAlJWZvcm0lJSBpcyBzcGVjaWZpZWQsIHRoZSBzdHJpbmcgaXMgbm9ybWFsaXplZC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHRvVXRmOEJ5dGVzKHN0ciwgZm9ybSkge1xuICAgIGFzc2VydEFyZ3VtZW50KHR5cGVvZiAoc3RyKSA9PT0gXCJzdHJpbmdcIiwgXCJpbnZhbGlkIHN0cmluZyB2YWx1ZVwiLCBcInN0clwiLCBzdHIpO1xuICAgIGlmIChmb3JtICE9IG51bGwpIHtcbiAgICAgICAgYXNzZXJ0Tm9ybWFsaXplKGZvcm0pO1xuICAgICAgICBzdHIgPSBzdHIubm9ybWFsaXplKGZvcm0pO1xuICAgIH1cbiAgICBsZXQgcmVzdWx0ID0gW107XG4gICAgZm9yIChsZXQgaSA9IDA7IGkgPCBzdHIubGVuZ3RoOyBpKyspIHtcbiAgICAgICAgY29uc3QgYyA9IHN0ci5jaGFyQ29kZUF0KGkpO1xuICAgICAgICBpZiAoYyA8IDB4ODApIHtcbiAgICAgICAgICAgI

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

26774HJldHVybiBuZXcgRml4ZWROdW1iZXIoX2d1YXJkLCB2YWx1ZSwgZm9ybWF0KTtcbiAgICB9XG4gICAgLyoqXG4gICAgICogIENyZWF0ZXMgYSBuZXcgW1tGaXhlZE51bWJlcl1dIGZvciAlJXZhbHVlJSUgd2l0aCAlJWZvcm1hdCUlLlxuICAgICAqXG4gICAgICogIFRoaXMgd2lsbCB0aHJvdyBhIFtbTnVtZXJpY0ZhdWx0RXJyb3JdXSBpZiAlJXZhbHVlJSUgY2Fubm90IGZpdFxuICAgICAqICBpbiAlJWZvcm1hdCUlLCBlaXRoZXIgZHVlIHRvIG92ZXJmbG93IG9yIHVuZGVyZmxvdyAocHJlY2lzaW9uIGxvc3MpLlxuICAgICAqL1xuICAgIHN0YXRpYyBmcm9tU3RyaW5nKF92YWx1ZSwgX2Zvcm1hdCkge1xuICAgICAgICBjb25zdCBtYXRjaCA9IF92YWx1ZS5tYXRjaCgvXigtPykoWzAtOV0qKVxcLj8oWzAtOV0qKSQvKTtcbiAgICAgICAgYXNzZXJ0QXJndW1lbnQobWF0Y2ggJiYgKG1hdGNoWzJdLmxlbmd0aCArIG1hdGNoWzNdLmxlbmd0aCkgPiAwLCBcImludmFsaWQgRml4ZWROdW1iZXIgc3RyaW5nIHZhbHVlXCIsIFwidmFsdWVcIiwgX3ZhbHVlKTtcbiAgICAgICAgY29uc3QgZm9ybWF0ID0gZ2V0Rm9ybWF0KF9mb3JtYXQpO1xuICAgICAgICBsZXQgd2hvbGUgPSAobWF0Y2hbMl0gfHwgXCIwXCIpLCBkZWNpbWFsID0gKG1hdGNoWzNdIHx8IFwiXCIpO1xuICAgICAgICAvLyBQYWQgb3V0IHRoZSBkZWNpbWFsc1xuICAgICAgICB3aGlsZSAoZGVjaW1hbC5sZW5ndGggPCBmb3JtYXQuZGVjaW1hbHMpIHtcbiAgICAgICAgICAgIGRlY2ltYWwgKz0gWmVyb3M7XG4gICAgICAgIH1cbiAgICAgICAgLy8gQ2hlY2sgcHJlY2lzaW9uIGlzIHNhZmVcbiAgICAgICAgYXNzZXJ0KGRlY2ltYWwuc3Vic3RyaW5nKGZvcm1hdC5kZWNpbWFscykubWF0Y2goL14wKiQvKSwgXCJ0b28gbWFueSBkZWNpbWFscyBmb3IgZm9ybWF0XCIsIFwiTlVNRVJJQ19GQVVMVFwiLCB7XG4gICAgICAgICAgICBvcGVyYXRpb246IFwiZnJvbVN0cmluZ1wiLCBmYXVsdDogXCJ1bmRlcmZsb3dcIiwgdmFsdWU6IF92YWx1ZVxuICAgICAgICB9KTtcbiAgICAgICAgLy8gUmVtb3ZlIGV4dHJhIHBhZGRpbmdcbiAgICAgICAgZGVjaW1hbCA9IGRlY2ltYWwuc3Vic3RyaW5nKDAsIGZvcm1hdC5kZWNpbWFscyk7XG4gICAgICAgIGNvbnN0IHZhbHVlID0gQmlnSW50KG1hdGNoWzFdICsgd2hvbGUgKyBkZWNpbWFsKTtcbiAgICAgICAgY2hlY2tWYWx1ZSh2YWx1ZSwgZm9ybWF0LCBcImZyb21TdHJpbmdcIik7XG4gICAgICAgIHJldHVybiBuZXcgRml4ZWROdW1iZXIoX2d1YXJkLCB2YWx1ZSwgZm9ybWF0KTtcbiAgICB9XG4gICAgLyoqXG4gICAgICogIENyZWF0ZXMgYSBuZXcgW1tGaXhlZE51bWJlcl1dIHdpdGggdGhlIGJpZy1lbmRpYW4gcmVwcmVzZW50YXRpb25cbiAgICAgKiAgJSV2YWx1ZSUlIHdpdGggJSVmb3JtYXQlJS5cbiAgICAgKlxuICAgICAqICBUaGlzIHdpbGwgdGhyb3cgYSBbW051bWVyaWNGYXVsdEVycm9yXV0gaWYgJSV2YWx1ZSUlIGNhbm5vdCBmaXRcbiAgICAgKiAgaW4gJSVmb3JtYXQlJSBkdWUgdG8gb3ZlcmZsb3cuXG4gICAgICovXG4gICAgc3RhdGljIGZyb21CeXRlcyhfdmFsdWUsIF9mb3JtYXQpIHtcbiAgICAgICAgbGV0IHZhbHVlID0gdG9CaWdJbnQoZ2V0Qnl0ZXMoX3ZhbHVlLCBcInZhbHVlXCIpKTtcbiAgICAgICAgY29uc3QgZm9ybWF0ID0gZ2V0Rm9ybWF0KF9mb3JtYXQpO1xuICAgICAgICBpZiAoZm9ybWF0LnNpZ25lZCkge1xuICAgICAgICAgICAgdmFsdWUgPSBmcm9tVHdvcyh2YWx1ZSwgZm9ybWF0LndpZHRoKTtcbiAgICAgICAgfVxuICAgICAgICBjaGVja1ZhbHVlKHZhbHVlLCBmb3JtYXQsIFwiZnJvbUJ5dGVzXCIpO1xuICAgICAgICByZXR1cm4gbmV3IEZpeGVkTnVtYmVyKF9ndWFyZCwgdmFsdWUsIGZvcm1hdCk7XG4gICAgfVxufVxuLy9jb25zdCBmMSA9IEZpeGVkTnVtYmVyLmZyb21TdHJpbmcoXCIxMi41NlwiLCBcImZpeGVkMTZ4MlwiKTtcbi8vY29uc3QgZjIgPSBGaXhlZE51bWJlci5mcm9tU3RyaW5nKFwiMC4zXCIsIFwiZml4ZWQxNngyXCIpO1xuLy9jb25zb2xlLmxvZyhmMS5kaXZTaWduYWwoZjIpKTtcbi8vY29uc3QgQlVNUCA9IEZpeGVkTnVtYmVyLmZyb20oXCIwLjVcIik7XG4vLyMgc291cmNlTWFwcGluZ1VSTD1maXhlZG51bWJlci5qcy5tYXAiLCIvL1NlZTogaHR0cHM6Ly9naXRodWIuY29tL2V0aGVyZXVtL3dpa2kvd2lraS9STFBcbmltcG9ydCB7IGhleGxpZnkgfSBmcm9tIFwiLi9kYXRhLmpzXCI7XG5pbXBvcnQgeyBhc3NlcnQsIGFzc2VydEFyZ3VtZW50IH0gZnJvbSBcIi4vZXJyb3JzLmpzXCI7XG5pbXBvcnQgeyBnZXRCeXRlcyB9IGZyb20gXCIuL2RhdGEuanNcIjtcbmZ1bmN0aW9uIGhleGxpZnlCeXRlKHZhbHVlKSB7XG4gICAgbGV0IHJlc3VsdCA9IHZhbHVlLnRvU3RyaW5nKDE2KTtcbiAgICB3aGlsZSAocmVzdWx0Lmxlbmd0aCA8IDIpIHtcbiAgICAgICAgcmVzdWx0ID0gXCIwXCIgKyByZXN1bHQ7XG4gICAgfVxuICAgIHJldHVybiBcIjB4XCIgKyByZXN1bHQ7XG59XG5mdW5jdGlvbiB1bmFycmF5aWZ5SW50ZWdlcihkYXRhLCBvZmZzZXQsIGxlbmd0aCkge1xuICAgIGxldCByZXN1bHQgPSAwO1xuICAgIGZvciAobGV0IGkgPSAwOyBpIDwgbGVuZ3RoOyBpKyspIHtcbiAgICAgICAgcmVzdWx0ID0gKHJlc3VsdCAqIDI1NikgKyBkYXRhW29mZnNldCArIGldO1xuICAgIH1cbiAgICByZXR1cm4gcmVzdWx0O1xufVxuZnVuY3Rpb24gX2RlY29kZUNoaWxkcmVuKGRhdGEsIG9mZnNldCwgY2hpbGRPZmZzZXQsIGxlbmd0aCkge1xuICAgIGNvbnN0IHJlc3VsdCA9IFtdO1xuICAgIHdoaWxlIChjaGlsZE9mZnNldCA8IG9mZnNldCArIDEgKyBsZW5ndGgpIHtcbiAgICAgICAgY29uc3QgZGVjb2RlZCA9IF9kZWNvZGUoZGF0YSwgY2hpbGRPZmZzZXQpO1xuICAgICAgICByZXN1bHQucHVzaChkZWNvZGVkLnJlc3VsdCk7XG4gICAgICAgIGNoaWxkT2Zmc2V0ICs9IGRlY29kZWQuY29uc3VtZWQ7XG4gICAgICAgIGFzc2VydChjaGlsZE9mZnNldCA8PSBvZmZzZXQgKyAxICsgbGVuZ3RoLCBcImNoaWxkIGRhdGEgdG9vIHNob3J0XCIsIFwiQlVGRkVSX09WRVJSVU5cIiwge1xuICAgICAgICAgICAgYnVmZmVyOiBkYXRhLCBsZW5ndGgsIG9mZnNldFxuICAgICAgICB9KTtcbiAgICB9XG4gICAgcmV0dXJuIHsgY29uc3VtZWQ6ICgxICsgbGVuZ3RoKSwgcmVzdWx0OiByZXN1bHQgfTtcbn1cbi8vIHJldHVybnMgeyBjb25zdW1lZDogbnVtYmVyLCByZXN1bHQ6IE9iamVjdCB9XG5mdW5jdGlvbiBfZGVjb2RlKGRhdGEsIG9mZnNldCkge1xuICAgIGFzc2VydChkYXRhLmxlbmd0aCAhPT0gMCwgXCJkYXRhIHRvbyBzaG9ydFwiLCBcIkJVRkZFUl9PVkVSUlVOXCIsIHtcbiAgICAgICAgYnVmZmVyOiBkYXRhLCBsZW5ndGg6IDAsIG9mZnNldDogMVxuICAgIH0pO1xuICAgIGNvbnN0IGNoZWNrT2Zmc2V0ID0gKG9mZnNldCkgPT4ge1xuICAgICAgICBhc3NlcnQob2Zmc2V0IDw9IGRhdGEubGVuZ3RoLCBcImRhdGEgc2hvcnQgc2VnbWVudCB0b28gc2hvcnRcIiwgXCJCVUZGRVJfT1ZFUlJVTlwiLCB7XG4gICAgICAgICAgICBidWZmZXI6IGRhdGEsIGxlbmd0aDogZGF0YS5sZW5ndGgsIG9mZnNldFxuICAgICAgICB9KTtcbiAgICB9O1xuICAgIC8vIEFycmF5IHdpdGggZXh0cmEgbGVuZ3RoIHByZWZpeFxuICAgIGlmIChkYXRhW29mZnNldF0gPj0gMHhmOCkge1xuICAgICAgICBjb25zdCBsZW5ndGhMZW5ndGggPSBkYXRhW29mZnNldF0gLSAweGY3O1xuICAgICAgICBjaGVja09mZnNldChvZmZzZXQgKyAxICsgbGVuZ3RoTGVuZ3RoKTtcbiAgICAgICAgY29uc3QgbGVuZ3RoID0gdW5hcnJheWlmeUludGVnZXIoZGF0YSwgb2Zmc2V0ICsgMSwgbGVuZ3RoTGVuZ3RoKTtcbiAgICAgICAgY2hlY2tPZmZzZXQob2Zmc2V0ICsgMSArIGxlbmd0aExlbmd0aCArIGxlbmd0aCk7XG4gICAgICAgI

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

26774H1cbiAgICAgICAgICAgICAgICAgICAgLy8gUGFzcyBpbXBvcnRhbnQgY2hlY2tzIChsaWtlIGB0aGVuYCBmb3IgUHJvbWlzZSkgdGhyb3VnaFxuICAgICAgICAgICAgICAgICAgICBpZiAocGFzc1Byb3BlcnRpZXMuaW5kZXhPZihwcm9wKSA+PSAwKSB7XG4gICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gUmVmbGVjdC5nZXQodGFyZ2V0LCBwcm9wLCByZWNlaXZlcik7XG4gICAgICAgICAgICAgICAgICAgIH1cbiAgICAgICAgICAgICAgICAgICAgY29uc3QgdmFsdWUgPSB0YXJnZXRbcHJvcF07XG4gICAgICAgICAgICAgICAgICAgIGlmICh2YWx1ZSBpbnN0YW5jZW9mIEZ1bmN0aW9uKSB7XG4gICAgICAgICAgICAgICAgICAgICAgICAvLyBNYWtlIHN1cmUgZnVuY3Rpb25zIHdvcmsgd2l0aCBwcml2YXRlIHZhcmlhYmxlc1xuICAgICAgICAgICAgICAgICAgICAgICAgLy8gU2VlOiBodHRwczovL2RldmVsb3Blci5tb3ppbGxhLm9yZy9lbi1VUy9kb2NzL1dlYi9KYXZhU2NyaXB0L1JlZmVyZW5jZS9HbG9iYWxfT2JqZWN0cy9Qcm94eSNub19wcml2YXRlX3Byb3BlcnR5X2ZvcndhcmRpbmdcbiAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiBmdW5jdGlvbiAoLi4uYXJncykge1xuICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJldHVybiB2YWx1ZS5hcHBseSgodGhpcyA9PT0gcmVjZWl2ZXIpID8gdGFyZ2V0IDogdGhpcywgYXJncyk7XG4gICAgICAgICAgICAgICAgICAgICAgICB9O1xuICAgICAgICAgICAgICAgICAgICB9XG4gICAgICAgICAgICAgICAgICAgIGVsc2UgaWYgKCEocHJvcCBpbiB0YXJnZXQpKSB7XG4gICAgICAgICAgICAgICAgICAgICAgICAvLyBQb3NzaWJsZSBuYW1lIGFjY2Vzc29yXG4gICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4gdGFyZ2V0LmdldFZhbHVlLmFwcGx5KCh0aGlzID09PSByZWNlaXZlcikgPyB0YXJnZXQgOiB0aGlzLCBbcHJvcF0pO1xuICAgICAgICAgICAgICAgICAgICB9XG4gICAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgICAgIHJldHVybiBSZWZsZWN0LmdldCh0YXJnZXQsIHByb3AsIHJlY2VpdmVyKTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgfSk7XG4gICAgICAgIHNldE5hbWVzKHByb3h5LCBnZXROYW1lcyh0aGlzKSk7XG4gICAgICAgIHJldHVybiBwcm94eTtcbiAgICB9XG4gICAgLyoqXG4gICAgICogIFJldHVybnMgdGhlIFJlc3VsdCBhcyBhIG5vcm1hbCBBcnJheS4gSWYgJSVkZWVwJSUsIGFueSBjaGlsZHJlblxuICAgICAqICB3aGljaCBhcmUgUmVzdWx0IG9iamVjdHMgYXJlIGFsc28gY29udmVydGVkIHRvIGEgbm9ybWFsIEFycmF

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

26774H1cbiAgICAgICAgICAgIGVsc2Uge1xuICAgICAgICAgICAgICAgIGFzc2VydChmYWxzZSwgXCJkYXRhIG91dC1vZi1ib3VuZHNcIiwgXCJCVUZGRVJfT1ZFUlJVTlwiLCB7XG4gICAgICAgICAgICAgICAgICAgIGJ1ZmZlcjogZ2V0Qnl0ZXNDb3B5KHRoaXMuI2RhdGEpLFxuICAgICAgICAgICAgICAgICAgICBsZW5ndGg6IHRoaXMuI2RhdGEubGVuZ3RoLFxuICAgICAgICAgICAgICAgICAgICBvZmZzZXQ6IHRoaXMuI29mZnNldCArIGFsaWduZWRMZW5ndGhcbiAgICAgICAgICAgICAgICB9KTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgfVxuICAgICAgICByZXR1cm4gdGhpcy4jZGF0YS5zbGljZSh0aGlzLiNvZmZzZXQsIHRoaXMuI29mZnNldCArIGFsaWduZWRMZW5ndGgpO1xuICAgIH1cbiAgICAvLyBDcmVhdGUgYSBzdWItcmVhZGVyIHdpdGggdGhlIHNhbWUgdW5kZXJseWluZyBkYXRhLCBidXQgb2Zmc2V0XG4gICAgc3ViUmVhZGVyKG9mZnNldCkge1xuICAgICAgICBjb25zdCByZWFkZXIgPSBuZXcgUmVhZGVyKHRoaXMuI2RhdGEuc2xpY2UodGhpcy4jb2Zmc2V0ICsgb2Zmc2V0KSwgdGhpcy5hbGxvd0xvb3NlLCB0aGlzLiNtYXhJbmZsYXRpb24pO1xuICAgICAgICByZWFkZXIuI3BhcmVudCA9IHRoaXM7XG4gICAgICAgIHJldHVybiByZWFkZXI7XG4gICAgfVxuICAgIC8vIFJlYWQgYnl0ZXNcbiAgICByZWFkQnl0ZXMobGVuZ3RoLCBsb29zZSkge1xuICAgICAgICBsZXQgYnl0ZXMgPSB0aGlzLiNwZWVrQnl0ZXMoMCwgbGVuZ3RoLCAhIWxvb3NlKTtcbiAgICAgICAgdGhpcy4jaW5jcmVtZW50Qnl0ZXNSZWFkKGxlbmd0aCk7XG4gICAgICAgIHRoaXMuI29mZnNldCArPSBieXRlcy5sZW5ndGg7XG4gICAgICAgIC8vIEBUT0RPOiBNYWtlIHN1cmUgdGhlIGxlbmd0aC4uZW5kIGJ5dGVzIGFyZSBhbGwgMD9cbiAgICAgICAgcmV0dXJuIGJ5dGVzLnNsaWNlKDAsIGxlbmd0aCk7XG4gICAgfVxuICAgIC8vIFJlYWQgYSBudW1lcmljIHZhbHVlc1xuICAgIHJlYWRWYWx1ZSgpIHtcbiAgICAgICAgcmV0dXJuIHRvQmlnSW50KHRoaXMucmVhZEJ5dGVzKFdvcmRTaXplKSk7XG4gICAgfVxuICAgIHJlYWRJbmRleCgpIHtcbiAgICAgICAgcmV0dXJuIHRvTnVtYmVyKHRoaXMucmVhZEJ5dGVzKFdvcmRTaXplKSk7XG4gICAgfVxufVxuLy8jIHNvdXJjZU1hcHBpbmdVUkw9YWJzd

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

26774HJldHVybiB7IHg6IGF4LCB5OiBheSB9O1xuICAgICAgICB9XG4gICAgICAgIGlzVG9yc2lvbkZyZWUoKSB7XG4gICAgICAgICAgICBjb25zdCB7IGg6IGNvZmFjdG9yLCBpc1RvcnNpb25GcmVlIH0gPSBDVVJWRTtcbiAgICAgICAgICAgIGlmIChjb2ZhY3RvciA9PT0gXzFuKVxuICAgICAgICAgICAgICAgIHJldHVybiB0cnVlOyAvLyBObyBzdWJncm91cHMsIGFsd2F5cyB0b3JzaW9uLWZyZWVcbiAgICAgICAgICAgIGlmIChpc1RvcnNpb25GcmVlKVxuICAgICAgICAgICAgICAgIHJldHVybiBpc1RvcnNpb25GcmVlKFBvaW50LCB0aGlzKTtcbiAgICAgICAgICAgIHRocm93IG5ldyBFcnJvcignaXNUb3JzaW9uRnJlZSgpIGhhcyBub3QgYmVlbiBkZWNsYXJlZCBmb3IgdGhlIGVsbGlwdGljIGN1cnZlJyk7XG4gICAgICAgIH1cbiAgICAgICAgY2xlYXJDb2ZhY3RvcigpIHtcbiAgICAgICAgICAgIGNvbnN0IHsgaDogY29mYWN0b3IsIGNsZWFyQ29mYWN0b3IgfSA9IENVUlZFO1xuICAgICAgICAgICAgaWYgKGNvZmFjdG9yID09PSBfMW4pXG4gICAgICAgICAgICAgICAgcmV0dXJuIHRoaXM7IC8vIEZhc3QtcGF0aFxuICAgICAgICAgICAgaWYgKGNsZWFyQ29mYWN0b3IpXG4gICAgICAgICAgICAgICAgcmV0dXJuIGNsZWFyQ29mYWN0b3IoUG9pbnQsIHRoaXMpO1xuICAgICAgICAgICAgcmV0dXJuIHRoaXMubXVsdGlwbHlVbnNhZmUoQ1VSVkUuaCk7XG4gICAgICAgIH1cbiAgICAgICAgdG9SYXdCeXRlcyhpc0NvbXByZXNzZWQgPSB0cnVlKSB7XG4gICAgICAgICAgICB0aGlzLmFzc2VydFZhbGlkaXR5KCk7XG4gICAgICAgICAgICByZXR1cm4gdG9CeXRlcyhQb2ludCwgdGhpcywgaXNDb21wcmVzc2VkKTtcbiAgICAgICAgfVxuICAgICAgICB0b0hleChpc0NvbXByZXNzZWQgPSB0cnVlKSB7XG4gICAgICAgICAgICByZXR1cm4gdXQuYnl0ZXNUb0hleCh0aGlzLnRvUmF3Qnl0ZXMoaXNDb21wcmVzc2VkKSk7XG4gICAgICAgIH1cbiAgICB9XG4gICAgUG9pbnQuQkFTRSA9IG5ldyBQb2ludChDVVJWRS5HeCwgQ1VSVkUuR3ksIEZwLk9ORSk7XG4gICAgUG9pbnQuWkVSTyA9IG5ldyBQb2ludChGcC5aRVJPLCBGcC5PTkUsIEZwLlpFUk8pO1xuICAgIGNvbnN0IF9iaXRzID0gQ1VSVkUubkJpdExlbmd0aDtcbiAgICBjb25zdCB3bmFmID0gd05BRihQb2ludCwgQ1VSVkUuZW5kbyA/IE1hdGguY2VpbChfYml0cyAvIDIpIDogX2JpdHMpO1xuICAgIC8vIFZhbGlkYXRlIGlmIGdlbmVyYXRvciBwb2ludCBpcyBvbiBjdXJ2ZVxuICAgIHJldHVybiB7XG4gICAgICAgIENVUlZFLFxuICAgICAgICBQcm9qZWN0aXZlUG9pbnQ6IFBvaW50LFxuICAgICAgICBub3JtUHJpdmF0ZUtleVRvU2NhbGFyLFxuICAgICAgICB3ZWllcnN0cmFzc0VxdWF0aW9uLFxuICAgICAgICBpc1dpdGhpbkN1cnZlT3JkZXIsXG4gICAgfTtcbn1cbmZ1bmN0aW9uIHZhbGlkYXRlT3B0cyhjdXJ2ZSkge1xuICAgIGNvbnN0IG9wdHMgPSB2YWxpZGF0ZUJhc2ljKGN1cnZlKTtcbiAgICB1dC52YWxpZGF0ZU9iamVjdChvcHRzLCB7XG4gICAgICAgIGhhc2g6ICdoYXNoJyxcbiAgICAgICAgaG1hYzogJ2Z1bmN0aW9uJyxcbiAgICAgICAgcmFuZG9tQnl0ZXM6ICdmdW5jdGlvbicsXG4gICAgfSwge1xuICAgICAgICBiaXRzMmludDogJ2Z1bmN0aW9uJyxcbiAgICAgICAgYml0czJpbnRfbW9kTjogJ2Z1bmN0aW9uJyxcbiAgICAgICAgbG93UzogJ2Jvb2xlYW4nLFxuICAgIH0pO1xuICAgIHJldHVybiBPYmplY3QuZnJlZXplKHsgbG93UzogdHJ1ZSwgLi4ub3B0cyB9KTtcbn1cbmV4cG9ydCBmdW5jdGlvbiB3ZWllcnN0cmFzcyhjdXJ2ZURlZikge1xuICAgIGNvbnN0IENVUlZFID0gdmFsaWRhdGVPcHRzKGN1cnZlRGVmKTtcbiAgICBjb25zdCB7IEZwLCBuOiBDVVJWRV9PUkRFUiB9ID0gQ1VSVkU7XG4gICAgY29uc3QgY29tcHJlc3NlZExlbiA9IEZwLkJZVEVTICsgMTsgLy8gZS5nLiAzMyBmb3IgMzJcbiAgICBjb25zdCB1bmNvbXByZXNzZWRMZW4gPSAyICogRnAuQllURVMgKyAxOyAvLyBlLmcuIDY1IGZvciAzMlxuICAgIGZ1bmN0aW9uIGlzVmFsaWRGaWVsZEVsZW1lbnQobnVtKSB7XG4gICAgICAgIHJldHVybiBfMG4gPCBudW0gJiYgbnVtIDwgRnAuT1JERVI7IC8vIDAgaXMgYmFubmVkIHNpbmNlIGl0J3Mgbm90IGludmVydGlibGUgRkVcbiAgICB9XG4gICAgZnVuY3Rpb24gbW9kTihhKSB7XG4gICAgICAgIHJldHVybiBtb2QubW9kKGEsIENVUlZFX09SREVSKTtcbiAgICB9XG4gICAgZnVuY3Rpb24gaW52TihhKSB7XG4gICAgICAgIHJldHVybiBtb2QuaW52ZXJ0KGEsIENVUlZFX09SREVSKTtcbiAgICB9XG4gICAgY29uc3QgeyBQcm9qZWN0aXZlUG9pbnQ6IFBvaW50LCBub3JtUHJpdmF0ZUtleVRvU2NhbGFyLCB3ZWllcnN0cmFzc0VxdWF0aW9uLCBpc1dpdGhpbkN1cnZlT3JkZXIsIH0gPSB3ZWllcnN0cmFzc1BvaW50cyh7XG4gICAgICAgIC4uLkNVUlZFLFxuICAgICAgICB0b0J5dGVzKF9jLCBwb2ludCwgaXNDb21wcmVzc2VkKSB7XG4gICAgICAgICAgICBjb25zdCBhID0gcG9pbnQudG9BZmZpbmUoKTtcbiAgICAgICAgICAgIGNvbnN0IHggPSBGcC50b0J5dGVzKGEueCk7XG4gICAgICAgICAgICBjb25zdCBjYXQgPSB1dC5jb25jYXRCeXRlcztcbiAgICAgICAgICAgIGlmIChpc0NvbXByZXNzZWQpIHtcbiAgICAgICAgICAgICAgICByZXR1cm4gY2F0KFVpbnQ4QXJyYXkuZnJvbShbcG9pbnQuaGFzRXZlblkoKSA/IDB4MDIgOiAweDAzXSksIHgpO1xuICAgICAgICAgICAgfVxuICAgICAgICAgICAgZWxzZSB7XG4gICAgICAgICAgICAgICAgcmV0dXJuIGNhdChVaW50OEFycmF5LmZyb20oWzB4MDRdKSwgeCwgRnAudG9CeXRlcyhhLnkpKTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgfSxcbiAgICAgICAgZnJvbUJ5dGVzKGJ5dGVzKSB7XG4gICAgICAgICAgICBjb25zdCBsZW4gPSBieXRlcy5sZW5ndGg7XG4gICAgICAgICAgICBjb25zdCBoZWFkID0gYnl0ZXNbMF07XG4gICAgICAgICAgICBjb25zdCB0YWlsID0gYnl0ZXMuc3ViYXJyYXkoMSk7XG4gICAgICAgICAgICAvLyB0aGlzLmFzc2VydFZhbGlkaXR5KCkgaXMgZG9uZSBpbnNpZGUgb2YgZnJvbUhleFxuICAgICAgICAgICAgaWYgKGxlbiA9PT0gY29tcHJlc3NlZExlbiAmJiAoaGVhZCA9PT0gMHgwMiB8fCBoZWFkID09PSAweDAzKSkge1xuICAgICAgICAgICAgICAgIGNvbnN0IHggPSB1dC5ieXRlc1RvTnVtYmVyQkUodGFpbCk7XG4gICAgICAgICAgICAgICAgaWYgKCFpc1ZhbGlkRmllbGRFbGVtZW50KHgpKVxuICAgICAgICAgICAgICAgICAgICB0aHJvdyBuZXcgRXJyb3IoJ1BvaW50IGlzIG5vdCBvbiBjdXJ2ZScpO1xuICAgICAgICAgICAgICAgIGNvbnN0IHkyID0gd2VpZXJzdHJhc3NFcXVhdGlvbih4KTsgLy8gecKyID0geMKzICsgYXggKyBiXG4gICAgICAgICAgICAgICAgbGV0IHkgPSBGcC5zcXJ0KHkyKTsgLy8geSA9IHnCsiBeIChwKzEpLzRcbiAgICAgICAgICAgICAgICBjb25zdCBpc1lPZGQgPSAoeSAmIF8xbikgPT09IF8xbjtcbiAgICAgICAgICAgICAgICAvLyBFQ0RTQVxuICAgICAgICAgICAgICAgIGNvbnN0IGlzSGVhZE9kZCA9ICh

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

26774VpciB0YWdnZWQgaGFzaCBwcmVmaXggb2YgW1NIQTI1Nih0YWcpIHwgU0hBMjU2KHRhZyldICovXG5jb25zdCBUQUdHRURfSEFTSF9QUkVGSVhFUyA9IHt9O1xuZnVuY3Rpb24gdGFnZ2VkSGFzaCh0YWcsIC4uLm1lc3NhZ2VzKSB7XG4gICAgbGV0IHRhZ1AgPSBUQUdHRURfSEFTSF9QUkVGSVhFU1t0YWddO1xuICAgIGlmICh0YWdQID09PSB1bmRlZmluZWQpIHtcbiAgICAgICAgY29uc3QgdGFnSCA9IHNoYTI1NihVaW50OEFycmF5LmZyb20odGFnLCAoYykgPT4gYy5jaGFyQ29kZUF0KDApKSk7XG4gICAgICAgIHRhZ1AgPSBjb25jYXRCeXRlcyh0YWdILCB0YWdIKTtcbiAgICAgICAgVEFHR0VEX0hBU0hfUFJFRklYRVNbdGFnXSA9IHRhZ1A7XG4gICAgfVxuICAgIHJldHVybiBzaGEyNTYoY29uY2F0Qnl0ZXModGFnUCwgLi4ubWVzc2FnZXMpKTtcbn1cbi8vIEVDRFNBIGNvbXBhY3QgcG9pbnRzIGFyZSAzMy1ieXRlLiBTY2hub3JyIGlzIDMyOiB3ZSBzdHJpcCBmaXJzdCBieXRlIDB4MDIgb3IgMHgwM1xuY29uc3QgcG9pbnRUb0J5dGVzID0gKHBvaW50KSA9PiBwb2ludC50b1Jhd0J5dGVzKHRydWUpLnNsaWNlKDEpO1xuY29uc3QgbnVtVG8zMmIgPSAobikgPT4gbnVtYmVyVG9CeXRlc0JFKG4sIDMyKTtcbmNvbnN0IG1vZFAgPSAoeCkgPT4gbW9kKHgsIHNlY3AyNTZrMVApO1xuY29uc3QgbW9kTiA9ICh4KSA9PiBtb2QoeCwgc2VjcDI1NmsxTik7XG5jb25zdCBQb2ludCA9IHNlY3AyNTZrMS5Qcm9qZWN0aXZlUG9pbnQ7XG5jb25zdCBHbXVsQWRkID0gKFEsIGEsIGIpID0+IFBvaW50LkJBU0UubXVsdGlwbHlBbmRBZGRVbnNhZmUoUSwgYSwgYik7XG4vLyBDYWxjdWxhdGUgcG9pbnQsIHNjYWxhciBhbmQgYnl0ZXNcbmZ1bmN0aW9uIHNjaG5vcnJHZXRFeHRQdWJLZXkocHJpdikge1xuICAgIGxldCBkXyA9IHNlY3AyNTZrMS51dGlscy5ub3JtUHJpdmF0ZUtleVRvU2NhbGFyKHByaXYpOyAvLyBzYW1lIG1ldGhvZCBleGVjdXRlZCBpbiBmcm9tUHJpdmF0ZUtleVxuICAgIGxldCBwID0gUG9pbnQuZnJvbVByaXZhdGVLZXkoZF8pOyAvLyBQID0gZCfii4VHOyAwIDwgZCcgPCBuIGNoZWNrIGlzIGRvbmUgaW5zaWRlXG4gICAgY29uc3Qgc2NhbGFyID0gcC5oYXNFdmVuWSgpID8gZF8gOiBtb2ROKC1kXyk7XG4gICAgcmV0dXJuIHsgc2NhbGFyOiBzY2FsYXIsIGJ5dGVzOiBwb2ludFRvQnl0ZXMocCkgfTtcbn1cbi8qKlxuICogbGlmdF94IGZyb20gQklQMzQwLiBDb252ZXJ0IDMyLWJ5dGUgeCBjb29yZGluYXRlIHRvIGVsbGlwdGljIGN1cnZlIHBvaW50LlxuICogQHJldHVybnMgdmFsaWQgcG9pbnQgY2hlY2tlZCBmb3IgYmVpbmcgb24tY3VydmVcbiAqL1xuZnVuY3Rpb24gbGlmdF94KHgpIHtcbiAgICBpZiAoIWZlKHgpKVxuICAgICAgICB0aHJvdyBuZXcgRXJyb3IoJ2JhZCB4OiBuZWVkIDAgPCB4IDwgcCcpOyAvLyBGYWlsIGlmIHgg4omlIHAuXG4gICAgY29uc3QgeHggPSBtb2RQKHggKiB4KTtcbiAgICBjb25zdCBjID0gbW9kUCh4eCAqIHggKyBCaWdJbnQoNykpOyAvLyBMZXQgYyA9IHjCsyArIDcgbW9kIHAuXG4gICAgbGV0IHkgPSBzcXJ0TW9kKGMpOyAvLyBMZXQgeSA9IGNeKHArMSkvNCBtb2QgcC5cbiAgICBpZiAoeSAlIF8ybiAhPT0gXzBuKVxuICAgICAgICB5ID0gbW9kUCgteSk7IC8vIFJldHVybiB0aGUgdW5pcXVlIHBvaW50IFAgc3VjaCB0aGF0IHgoUCkgPSB4IGFuZFxuICAgIGNvbnN0IHAgPSBuZXcgUG9pbnQoeCwgeSwgXzFuKTsgLy8geShQKSA9IHkgaWYgeSBtb2QgMiA9IDAgb3IgeShQKSA9IHAteSBvdGhlcndpc2UuXG4gICAgcC5hc3NlcnRWYWxpZGl0eSgpO1xuICAgIHJldHVybiBwO1xufVxuLyoqXG4gKiBDcmVhdGUgdGFnZ2VkIGhhc2gsIGNvbnZlcnQgaXQgdG8gYmlnaW50LCByZWR1Y2UgbW9kdWxvLW4uXG4gKi9cbmZ1bmN0aW9uIGNoYWxsZW5nZSguLi5hcmdzKSB7XG4gICAgcmV0dXJuIG1vZE4oYnl0ZXNUb051bWJlckJFKHRhZ2dlZEhhc2goJ0JJUDAzNDAvY2hhbGxlbmdlJywgLi4uYXJncykpKTtcbn1cbi8qKlxuICogU2Nobm9yciBwdWJsaWMga2V5IGlzIGp1c3QgYHhgIGNvb3JkaW5hdGUgb2YgUG9pbnQgYXMgcGVyIEJJUDM0MC5cbiAqL1xuZnVuY3Rpb24gc2Nobm9yckdldFB1YmxpY0tleShwcml2YXRlS2V5KSB7XG4gICAgcmV0dXJuIHNjaG5vcnJHZXRFeHRQdWJLZXkocHJpdmF0ZUtleSkuYnl0ZXM7IC8vIGQnPWludChzaykuIEZhaWwgaWYgZCc9MCBvciBkJ+KJpW4uIFJldCBieXRlcyhkJ+KLhUcpXG59XG4vKipcbiAqIENyZWF0ZXMgU2Nobm9yciBzaWduYXR1cmUgYXMgcGVyIEJJUDM0MC4gVmVyaWZpZXMgaXRzZWxmIGJlZm9yZSByZXR1cm5pbmcgYW55dGhpbmcuXG4gKiBhdXhSYW5kIGlzIG9wdGlvbmFsIGFuZCBpcyBub3QgdGhlIHNvbGUgc291cmNlIG9mIGsgZ2VuZXJhdGlvbjogYmFkIENTUFJORyB3b24ndCBiZSBkYW5nZXJvdXMuXG4gKi9cbmZ1bmN0aW9uIHNjaG5vcnJTaWduKG1lc3NhZ2UsIHByaXZhdGVLZXksIGF1eFJhbmQgPSByYW5kb21CeXRlcygzMikpIHtcbiAgICBjb25zdCBtID0gZW5zdXJlQnl0ZXMoJ21lc3NhZ2UnLCBtZXNzYWdlKTtcbiAgICBjb25zdCB7IGJ5dGVzOiBweCwgc2NhbGFyOiBkIH0gPSBzY2hub3JyR2V0RXh0UHViS2V5KHByaXZhdGVLZXkpOyAvLyBjaGVja3MgZm9yIGlzV2l0aGluQ3VydmVPcmRlclxuICAgIGNvbnN0IGEgPSBlbnN1cmVCeXRlcygnYXV4UmFuZCcsIGF1eFJhbmQsIDMyKTsgLy8gQXV4aWxpYXJ5IHJhbmRvbSBkYXRhIGE6IGEgMzItYnl0ZSBhcnJheVxuICAgIGNvbnN0IHQgPSBudW1UbzMyYihkIF4gYnl0ZXNUb051bWJlckJFKHRhZ2dlZEhhc2goJ0JJUDAzNDAvYXV4JywgYSkpKTsgLy8gTGV0IHQgYmUgdGhlIGJ5dGUtd2lzZSB4b3Igb2YgYnl0ZXMoZCkgYW5kIGhhc2gvYXV4KGEpXG4gICAgY29uc3QgcmFuZCA9IHRhZ2dlZEhhc2goJ0JJUDAzNDAvbm9uY2UnLCB0LCBweCwgbSk7IC8vIExldCByYW5kID0gaGFzaC9ub25jZSh0IHx8IGJ5dGVzKFApIHx8IG0pXG4gICAgY29uc3Qga18gPSBtb2ROKGJ5dGVzVG9OdW1iZXJCRShyYW5kKSk7IC8vIExldCBrJyA9IGludChyYW5kKSBtb2QgblxuICAgIGlmIChrXyA9PT0gXzBuKVxuICAgICAgICB0aHJvdyBuZXcgRXJyb3IoJ3NpZ24gZmFpbGVkOiBrIGlzIHplcm8nKTsgLy8gRmFpbCBpZiBrJyA9IDAuXG4gICAgY29uc3QgeyBieXRlczogcngsIHNjYWxhcjogayB9ID0gc2Nobm9yckdldEV4d

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

26774I1NiA9IEJpZ0ludChcIjB4ZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZlwiKTtcbi8qKlxuICogIEEgY29uc3RhbnQgZm9yIHRoZSBtaW5pbXVtIHZhbHVlIGZvciBhbiBgYGludDI1NmBgLlxuICpcbiAqICAoKippLmUuKiogYGAtODAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMG5gYClcbiAqL1xuZXhwb3J0IGNvbnN0IE1pbkludDI1NiA9IEJpZ0ludChcIjB4ODAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMFwiKSAqIEJpZ0ludCgtMSk7XG4vKipcbiAqICBBIGNvbnN0YW50IGZvciB0aGUgbWF4aW11bSB2YWx1ZSBmb3IgYW4gYGBpbnQyNTZgYC5cbiAqXG4gKiAgKCoqaS5lLioqIGBgMHg3ZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmbmBgKVxuICovXG5leHBvcnQgY29uc3QgTWF4SW50MjU2ID0gQmlnSW50KFwiMHg3ZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmXCIpO1xuLy8jIHNvdXJjZU1hcHBpbmdVUkw9bnVtYmVycy5qcy5tYXAiLCIvLyBORktDIChjb21wb3NlZCkgICAgICAgICAgICAgLy8gKGRlY29tcG9zZWQpXG4vKipcbiAqICBBIGNvbnN0YW50IGZvciB0aGUgZXRoZXIgc3ltYm9sIChub3JtYWxpemVkIHVzaW5nIE5GS0MpLlxuICpcbiAqICAoKippLmUuKiogYGBcIlxcXFx1MDM5ZVwiYGApXG4gKi9cbmV4cG9ydCBjb25zdCBFdGhlclN5bWJvbCA9IFwiXFx1MDM5ZVwiOyAvLyBcIlxcdUQ4MzVcXHVERjYzXCI7XG4vKipcbiAqICBBIGNvbnN0YW50IGZvciB0aGUgW1tsaW5rLWVpcC0xOTFdXSBwZXJzb25hbCBtZXNzYWdlIHByZWZpeC5cbiAqXG4gKiAgKCoqaS5lLioqIGBgXCJcXFxceDE5RXRoZXJldW0gU2lnbmVkIE1lc3NhZ2U6XFxcXG5cImBgKVxuICovXG5leHBvcnQgY29uc3QgTWVzc2FnZVByZWZpeCA9IFwiXFx4MTlFdGhlcmV1bSBTaWduZWQgTWVzc2FnZTpcXG5cIjtcbi8vIyBzb3VyY2VNYXBwaW5nVVJMPXN0cmluZ3MuanMubWFwIiwiaW1wb3J0IHsgWmVyb0hhc2ggfSBmcm9tIFwiLi4vY29uc3RhbnRzL2luZGV4LmpzXCI7XG5pbXBvcnQgeyBjb25jYXQsIGRhdGFMZW5ndGgsIGdldEJpZ0ludCwgZ2V0Qnl0ZXMsIGdldE51bWJlciwgaGV4bGlmeSwgdG9CZUFycmF5LCBpc0hleFN0cmluZywgemVyb1BhZFZhbHVlLCBhc3NlcnRBcmd1bWVudCwgYXNzZXJ0UHJpdmF0ZSB9IGZyb20gXCIuLi91dGlscy9pbmRleC5qc1wiO1xuLy8gQ29uc3RhbnRzXG5jb25zdCBCTl8wID0gQmlnSW50KDApO1xuY29uc3QgQk5fMSA9IEJpZ0ludCgxKTtcbmNvbnN0IEJOXzIgPSBCaWdJbnQoMik7XG5jb25zdCBCTl8yNyA9IEJpZ0ludCgyNyk7XG5jb25zdCBCTl8yOCA9IEJpZ0ludCgyOCk7XG5jb25zdCBCTl8zNSA9IEJpZ0ludCgzNSk7XG5jb25zdCBCTl9OID0gQmlnSW50KFwiMHhmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZWJhYWVkY2U2YWY0OGEwM2JiZmQyNWU4Y2QwMzY0MTQxXCIpO1xuY29uc3QgQk5fTl8yID0gQk5fTiAvIEJOXzI7IC8vIE11c3QgYmUgaW50ZWdlciAoZmxvb3IpIGRpdmlzaW9uOyBkbyBOT1Qgc2hpZnRzXG5jb25zdCBpbnNwZWN0ID0gU3ltYm9sLmZvcihcIm5vZGVqcy51dGlsLmluc3BlY3QuY3VzdG9tXCIpO1xuY29uc3QgX2d1YXJkID0ge307XG5mdW5jdGlvbiB0b1VpbnQyNTYodmFsdWUpIHtcbiAgICByZXR1cm4gemVyb1BhZFZhbHVlKHRvQmVBcnJheSh2YWx1ZSksIDMyKTtcbn1cbi8qKlxuICogIEEgU2lnbmF0dXJlICBAVE9ET1xuICpcbiAqXG4gKiAgQF9kb2Nsb2M6IGFwaS9jcnlwdG86U2lnbmluZ1xuICovXG5leHBvcnQgY2xhc3MgU2lnbmF0dXJlIHtcbiAgICAjcjtcbiAgICAjcztcbiAgICAjdjtcbiAgICAjbmV0d29ya1Y7XG4gICAgLyoqXG4gICAgICogIFRoZSBgYHJgYCB2YWx1ZSBmb3IgYSBzaWduYXR1cmUuXG4gICAgICpcbiAgICAgKiAgVGhpcyByZXByZXNlbnRzIHRoZSBgYHhgYCBjb29yZGluYXRlIG9mIGEgXCJyZWZlcmVuY2VcIiBvclxuICAgICAqICBjaGFsbGVuZ2UgcG9pbnQsIGZyb20gd2hpY2ggdGhlIGBgeWBgIGNhbiBiZSBjb21wdXRlZC5cbiAgICAgKi9cbiAgICBnZXQgcigpIHsgcmV0dXJuIHRoaXMuI3I7IH1cbiAgICBzZXQgcih2YWx1ZSkge1xuICAgICAgICBhc3NlcnRBcmd1bWVudChkYXRhTGVuZ3RoKHZhbHVlKSA9PT0gMzIsIFwiaW52YWxpZCByXCIsIFwidmFsdWVcIiwgdmFsdWUpO1xuICAgICAgICB0aGlzLiNyID0gaGV4bGlmeSh2YWx1ZSk7XG4gICAgfVxuICAgIC8qKlxuICAgICAqICBUaGUgYGBzYGAgdmFsdWUgZm9yIGEgc2lnbmF0dXJlLlxuICAgICAqL1xuICAgIGdldCBzKCkge1xuICAgICAgICBhc3NlcnRBcmd1bWVudChwYXJzZUludCh0aGlzLiNzLnN1YnN0cmluZygwLCAzKSkgPCA4LCBcIm5vbi1jYW5vbmljYWwgczsgdXNlIC5fc1wiLCBcInNcIiwgdGhpcy4jcyk7XG4gICAgICAgIHJldHVybiB0aGlzLiNzO1xuICAgIH1cbiAgICBzZXQgcyhfdmFsdWUpIHtcbiAgICAgICAgYXNzZXJ0QXJndW1lbnQoZGF0YUxlbmd0aChfdmFsdWUpID09PSAzMiwgXCJpbnZhbGlkIHNcIiwgXCJ2YWx1ZVwiLCBfdmFsdWUpO1xuICAgICAgICB0aGlzLiNzID0gaGV4bGlmeShfdmFsdWUpO1xuICAgIH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJuIHRoZSBzIHZhbHVlLCB1bmNoZWNrZWQgZm9yIEVJUC0yIGNvbXBsaWFuY2UuXG4gICAgICpcbiAgICAgKiAgVGhpcyBzaG91bGQgZ2VuZXJhbGx5IG5vdCBiZSB1c2VkIGFuZCBpcyBmb3Igc2l0dWF0aW9ucyB3aGVyZVxuICAgICAqICBhIG5vbi1jYW5vbmljYWwgUyB2YWx1ZSBtaWdodCBiZSByZWxldmFudCwgc3VjaCBhcyBGcm9udGllciBibG9ja3NcbiAgICAgKiAgdGhhdCB3ZXJlIG1pbmVkIHByaW9yIHRvIEVJUC0yIG9yIGludmFsaWQgQXV0aG9yaXphdGlvbiBMaXN0XG4gICAgICogIHNpZ25hdHVyZXMuXG4gICAgICovXG4gICAgZ2V0IF9zKCkgeyByZXR1cm4gdGhpcy4jczsgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm5zIHRydWUgaWYgdGhlIFNpZ25hdHVyZSBpcyB2YWxpZCBmb3IgW1tsaW5rLWVpcC0yXV0gc2lnbmF0dXJlcy5cbiAgICAgKi9cbiAgICBpc1ZhbGlkKCkge1xuICAgICAgICBjb25zdCBzID0gQmlnSW50KHRoaXMuI3MpO1xuICAgICAgICByZXR1cm4gKHMgPD0gQk5fTl8yKTtcbiAgICB9XG4gICAgLyoqXG4gICAgICogIFRoZSBgYHZgYCB2YWx1ZSBmb3IgYSBzaWduYXR1cmUuXG4gICAgICpcbiAgICAgKiAgU2luY2UgYSBnaXZlbiBgYHhgYCB2YWx1ZSBmb3IgYGByYGAgaGFzIHR3byBwb3NzaWJsZSB2YWx1ZXMgZm9yXG4gICAgICogIGl0cyBjb3JyZXNwb25kaW4gYGB5YGAsIHRoZSBgYHZgYCBpbmRpY2F0ZXMgd2hpY2ggb2YgdGhlIHR3byBgYHlgYFxuICAgICAqICB2YWx1ZXMgdG8gdXNlLlxuICAgICAqXG4gICAgICogIEl0IGlzIG5vcm1hbGl6ZWQgdG8gdGhlIHZhbHVlcyBgYDI3YGAgb3IgYGAyOGBgIGZvciBsZWdhY3lcbiAgICAgKiAgcHVycG9zZXMuXG4gICAgICovXG4gICAgZ2V0IHYoKSB7IHJldHVybi

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

26774oKSA6IG51bGwpLFxuICAgICAgICAgICAgcjogdGhpcy5yLCBzOiB0aGlzLl9zLCB2OiB0aGlzLnYsXG4gICAgICAgIH07XG4gICAgfVxuICAgIFtpbnNwZWN0XSgpIHtcbiAgICAgICAgcmV0dXJuIHRoaXMudG9TdHJpbmcoKTtcbiAgICB9XG4gICAgdG9TdHJpbmcoKSB7XG4gICAgICAgIGlmICh0aGlzLmlzVmFsaWQoKSkge1xuICAgICAgICAgICAgcmV0dXJuIGBTaWduYXR1cmUgeyByOiAke3RoaXMucn0sIHM6ICR7dGhpcy5fc30sIHY6ICR7dGhpcy52fSB9YDtcbiAgICAgICAgfVxuICAgICAgICByZXR1cm4gYFNpZ25hdHVyZSB7IHI6ICR7dGhpcy5yfSwgczogJHt0aGlzLl9zfSwgdjogJHt0aGlzLnZ9LCB2YWxpZDogZmFsc2UgfWA7XG4gICAgfVxuICAgIC8qKlxuICAgICAqICBDb21wdXRlIHRoZSBjaGFpbiBJRCBmcm9tIHRoZSBgYHZgYCBpbiBhIGxlZ2FjeSBFSVAtMTU1IHRyYW5zYWN0aW9ucy5cbiAgICAgKlxuICAgICAqICBAZXhhbXBsZTpcbiAgICAgKiAgICBTaWduYXR1cmUuZ2V0Q2hhaW5JZCg0NSlcbiAgICAgKiAgICAvL19yZXN1bHQ6XG4gICAgICpcbiAgICAgKiAgICBTaWduYXR1cmUuZ2V0Q2hhaW5JZCg0NilcbiAgICAgKiAgICAvL19yZXN1bHQ6XG4gICAgICovXG4gICAgc3RhdGljIGdldENoYWluSWQodikge1xuICAgICAgICBjb25zdCBidiA9IGdldEJpZ0ludCh2LCBcInZcIik7XG4gICAgICAgIC8vIFRoZSB2IGlzIG5vdCBhbiBFSVAtMTU1IHYsIHNvIGl0IGlzIHRoZSB1bnNwZWNpZmllZCBjaGFpbiBJRFxuICAgICAgICBpZiAoKGJ2ID09IEJOXzI3KSB8fCAoYnYgPT0gQk5fMjgpKSB7XG4gICAgICAgICAgICByZXR1cm4gQk5fMDtcbiAgICAgICAgfVxuICAgICAgICAvLyBCYWQgdmFsdWUgZm9yIGFuIEVJUC0xNTUgdlxuICAgICAgICBhc3NlcnRBcmd1bWVudChidiA+PSBCTl8zNSwgXCJpbnZhbGlkIEVJUC0xNTUgdlwiLCBcInZcIiwgdik7XG4gICAgICAgIHJldHVybiAoYnYgLSBCTl8zNSkgLyBCTl8yO1xuICAgIH1cbiAgICAvKipcbiAgICAgKiAgQ29tcHV0ZSB0aGUgYGB2YGAgZm9yIGEgY2hhaW4gSUQgZm9yIGEgbGVnYWN5IEVJUC0xNTUgdHJhbnNhY3Rpb25zLlxuICAgICAqXG4gICAgICogIExlZ2FjeSB0cmFuc2FjdGlvbnMgd2hpY2ggdXNlIFtbbGluay1laXAtMTU1XV0gaGlqYWNrIHRoZSBgYHZgYFxuICAgICAqICBwcm9wZXJ0eSB0byBpbmNsdWRlIHRoZSBjaGFpbiBJRC5cbiAgICAgKlxuICAgICAqICBAZXhhbXBsZTpcbiAgICAgKiAgICBTaWduYXR1cmUuZ2V0Q2hhaW5JZFYoNSwgMjcpXG4gICAgICogICAgLy9fcmVzdWx0OlxuICAgICAqXG4gICAgICogICAgU2lnbmF0dXJlLmdldENoYWluSWRWKDUsIDI4KVxuICAgICAqICAgIC8vX3Jlc3VsdDpcbiAgICAgKlxuICAgICAqL1xuICAgIHN0YXRpYyBnZXRDaGFpbklkVihjaGFpbklkLCB2KSB7XG4gICAgICAgIHJldHVybiAoZ2V0QmlnSW50KGNoYWluSWQpICogQk5fMikgKyBCaWdJbnQoMzUgKyB2IC0gMjcpO1xuICAgIH1cbiAgICAvKipcbiAgICAgKiAgQ29tcHV0ZSB0aGUgbm9ybWFsaXplZCBsZWdhY3kgdHJhbnNhY3Rpb24gYGB2YGAgZnJvbSBhIGBgeVBhcmlydHlgYCxcbiAgICAgKiAgYSBsZWdhY3kgdHJhbnNhY3Rpb24gYGB2YGAgb3IgYSBsZWdhY3kgW1tsaW5rLWVpcC0xNTVdXSB0cmFuc2FjdGlvbi5cbiAgICAgKlxuICAgICAqICBAZXhhbXBsZTpcbiAgICAgKiAgICAvLyBUaGUgdmFsdWVzIDAgYW5kIDEgaW1wbHkgdiBpcyBhY3R1YWxseSB5UGFyaXR5XG4gICAgICogICAgU2lnbmF0dXJlLmdldE5vcm1hbGl6ZWRWKDApXG4gICAgICogICAgLy9fcmVzdWx0OlxuICAgICAqXG4gICAgICogICAgLy8gTGVnYWN5IG5vbi1FSVAtMTU1OSB0cmFuc2FjdGlvbiAoaS5lLiAyNyBvciAyOClcbiAgICAgKiAgICBTaWduYXR1cmUuZ2V0Tm9ybWFsaXplZFYoMjcpXG4gICAgICogICAgLy9fcmVzdWx0OlxuICAgICAqXG4gICAgICogICAgLy8gTGVnYWN5IEVJUC0xNTUgdHJhbnNhY3Rpb24gKGkuZS4gPj0gMzUpXG4gICAgICogICAgU2lnbmF0dXJlLmdldE5vcm1hbGl6ZWRWKDQ2KVxuICAgICAqICAgIC8vX3Jlc3VsdDpcbiAgICAgKlxuICAgICAqICAgIC8vIEludmFsaWQgdmFsdWVzIHRocm93XG4gICAgICogICAgU2lnbmF0dXJlLmdldE5vcm1hbGl6ZWRWKDUpXG4gICAgICogICAgLy9fZXJyb3I6XG4gICAgICovXG4gICAgc3RhdGljIGdldE5vcm1hbGl6ZWRWKHYpIHtcbiAgICAgICAgY29uc3QgYnYgPSBnZXRCaWdJbnQodik7XG4gICAgICAgIGlmIChidiA9PT0gQk5fMCB8fCBidiA9PT0gQk5fMjcpIHtcbiAgICAgICAgICAgIHJldHVybiAyNztcbiAgICAgICAgfVxuICAgICAgICBpZiAoYnYgPT09IEJOXzEgfHwgYnYgPT09IEJOXzI4KSB7XG4gICAgICAgICAgICByZXR1cm4gMjg7XG4gICAgICAgIH1cbiAgICAgICAgYXNzZXJ0QXJndW1lbnQoYnYgPj0gQk5fMzUsIFwiaW52YWxpZCB2XCIsIFwidlwiLCB2KTtcbiAgICAgICAgLy8gT3RoZXJ3aXNlLCBFSVAtMTU1IHYgbWVhbnMgb2RkIGlzIDI3IGFuZCBldmVuIGlzIDI4XG4gICAgICAgIHJldHVybiAoYnYgJiBCTl8xKSA/IDI3IDogMjg7XG4gICAgfVxuICAgIC8qKlxuICAgICAqICBDcmVhdGVzIGEgbmV3IFtbU2lnbmF0dXJlXV0uXG4gICAgICpcbiAgICAgKiAgSWYgbm8gJSVzaWclJSBpcyBwcm92aWRlZCwgYSBuZXcgW1tTaWduYXR1cmVdXSBpcyBjcmVhdGVkXG4gICAgICogIHdpdGggZGVmYXVsdCB2YWx1ZXMuXG4gICAgICpcbiAgICAgKiAgSWYgJSVzaWclJSBpcyBhIHN0cmluZywgaXQgaXMgcGFyc2VkLlxuICAgICAqL1xuICAgIHN0YXRpYyBmcm9tKHNpZykge1xuICAgICAgICBmdW5jdGlvbiBhc3NlcnRFcnJvcihjaGVjaywgbWVzc2FnZSkge1xuICAgICAgICAgICAgYXNzZXJ0QXJndW1lbnQoY2hlY2ssIG1lc3NhZ2UsIFwic2lnbmF0dXJlXCIsIHNpZyk7XG4gICAgICAgIH1cbiAgICAgICAgO1xuICAgICAgICBpZiAoc2lnID09IG51bGwpIHtcbiAgICAgICAgICAgIHJldHVybiBuZXcgU2lnbmF0dXJlKF9ndWFyZCwgWmVyb0hhc2gsIFplcm9IYXNoLCAyNyk7XG4gICAgICAgIH1cbiAgICAgICAgaWYgKHR5cGVvZiAoc2lnKSA9PT0gXCJzdHJpbmdcIikge1xuICAgICAgICAgICAgY29uc3QgYnl0ZXMgPSBnZXRCeXRlcyhzaWcsIFwic2lnbmF0dXJlXCIpO1xuICAgICAgICAgICAgaWYgKGJ5dGVzLmxlbmd0aCA9PT0gNjQpIHtcbiAgICAgICAgICAgICAgICBjb25zdCByID0gaGV4bGlmeShieXRlcy5zbGljZSgwLCAzMikpO1xuICAgICAgICAgICAgICAgIGNvbnN0IHMgPSBieXRlcy5zbGljZSgzMiwgNjQpO1xuICAgICAgICAgICAgICAgIGNvbnN0IHYgPSAoc1swXSAmIDB4ODApID8gMjggOiAyNztcbiAgICAgICAgICAgICAgICBzWzBdICY9IDB4N2Y7XG4gICAgICAgICAgICAgICAgcmV0dXJuIG5ldyBTaWduYXR1cmUoX2d1YXJkLCByLCBoZXhsaWZ5KHMpLCB2KTtcbiAgICAgICAgICAgI

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

26774B0aGlzLiNwcml2YXRlS2V5OyB9XG4gICAgLyoqXG4gICAgICogIFRoZSB1bmNvbXByZXNzZWQgcHVibGljIGtleS5cbiAgICAgKlxuICAgICAqIFRoaXMgd2lsbCBhbHdheXMgYmVnaW4gd2l0aCB0aGUgcHJlZml4IGBgMHgwNGBgIGFuZCBiZSAxMzJcbiAgICAgKiBjaGFyYWN0ZXJzIGxvbmcgKHRoZSBgYDB4YGAgcHJlZml4IGFuZCAxMzAgaGV4YWRlY2ltYWwgbmliYmxlcykuXG4gICAgICovXG4gICAgZ2V0IHB1YmxpY0tleSgpIHsgcmV0dXJuIFNpZ25pbmdLZXkuY29tcHV0ZVB1YmxpY0tleSh0aGlzLiNwcml2YXRlS2V5KTsgfVxuICAgIC8qKlxuICAgICAqICBUaGUgY29tcHJlc3NlZCBwdWJsaWMga2V5LlxuICAgICAqXG4gICAgICogIFRoaXMgd2lsbCBhbHdheXMgYmVnaW4gd2l0aCBlaXRoZXIgdGhlIHByZWZpeCBgYDB4MDJgYCBvciBgYDB4MDNgYFxuICAgICAqICBhbmQgYmUgNjggY2hhcmFjdGVycyBsb25nICh0aGUgYGAweGBgIHByZWZpeCBhbmQgMzMgaGV4YWRlY2ltYWxcbiAgICAgKiAgbmliYmxlcylcbiAgICAgKi9cbiAgICBnZXQgY29tcHJlc3NlZFB1YmxpY0tleSgpIHsgcmV0dXJuIFNpZ25pbmdLZXkuY29tcHV0ZVB1YmxpY0tleSh0aGlzLiNwcml2YXRlS2V5LCB0cnVlKTsgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm4gdGhlIHNpZ25hdHVyZSBvZiB0aGUgc2lnbmVkICUlZGlnZXN0JSUuXG4gICAgICovXG4gICAgc2lnbihkaWdlc3QpIHtcbiAgICAgICAgYXNzZXJ0QXJndW1lbnQoZGF0YUxlbmd0aChkaWdlc3QpID09PSAzMiwgXCJpbnZhbGlkIGRpZ2VzdCBsZW5ndGhcIiwgXCJkaWdlc3RcIiwgZGlnZXN0KTtcbiAgICAgICAgY29uc3Qgc2lnID0gc2VjcDI1NmsxLnNpZ24oZ2V0Qnl0ZXNDb3B5KGRpZ2VzdCksIGdldEJ5dGVzQ29weSh0aGlzLiNwcml2YXRlS2V5KSwge1xuICAgICAgICAgICAgbG93UzogdHJ1ZVxuICAgICAgICB9KTtcbiAgICAgICAgcmV0dXJuIFNpZ25hdHVyZS5mcm9tKHtcbiAgICAgICAgICAgIHI6IHRvQmVIZXgoc2lnLnIsIDMyKSxcbiAgICAgICAgICAgIHM6IHRvQmVIZXgoc2lnLnMsIDMyKSxcbiAgICAgICAgICAgIHY6IChzaWcucmVjb3ZlcnkgPyAweDFjIDogMHgxYilcbiAgICAgICAgfSk7XG4gICAgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm5zIHRoZSBbW2xpbmstd2lraS1lY2RoXV0gc2hhcmVkIHNlY3JldCBiZXR3ZWVuIHRoaXNcbiAgICAgKiAgcHJpdmF0ZSBrZXkgYW5kIHRoZSAlJW90aGVyJSUga2V5LlxuICAgICAqXG4gICAgICogIFRoZSAlJW90aGVyJSUga2V5IG1heSBiZSBhbnkgdHlwZSBvZiBrZXksIGEgcmF3IHB1YmxpYyBrZXksXG4gICAgICogIGEgY29tcHJlc3NlZC91bmNvbXByZXNzZWQgcHViaWMga2V5IG9yIGFwcml2YXRlIGtleS5cbiAgICAgKlxuICAgICAqICBCZXN0IHByYWN0aWNlIGlzIHVzdWFsbHkgdG8gdXNlIGEgY3J5cHRvZ3JhcGh

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

26774c3MoZGF0YVNsaWNlKGtlY2NhazI1NihlbmNvZGVSbHAoW2Zyb20sIG5vbmNlSGV4XSkpLCAxMikpO1xufVxuLyoqXG4gKiAgUmV0dXJucyB0aGUgYWRkcmVzcyB0aGF0IHdvdWxkIHJlc3VsdCBmcm9tIGEgYGBDUkVBVEUyYGAgb3BlcmF0aW9uXG4gKiAgd2l0aCB0aGUgZ2l2ZW4gJSVmcm9tJSUsICUlc2FsdCUlIGFuZCAlJWluaXRDb2RlSGFzaCUlLlxuICpcbiAqICBUbyBjb21wdXRlIHRoZSAlJWluaXRDb2RlSGFzaCUlIGZyb20gYSBjb250cmFjdCdzIGluaXQgY29kZSwgdXNlXG4gKiAgdGhlIFtba2VjY2FrMjU2XV0gZnVuY3Rpb24uXG4gKlxuICogIEZvciBhIHF1aWNrIG92ZXJ2aWV3IGFuZCBleGFtcGxlIG9mIGBgQ1JFQVRFMmBgLCBzZWUgW1tsaW5rLXJpY21vby13aXNwc11dLlxuICpcbiAqICBAZXhhbXBsZVxuICogICAgLy8gVGhlIGFkZHJlc3Mgb2YgdGhlIGNvbnRyYWN0XG4gKiAgICBmcm9tID0gXCIweDhiYTFmMTA5NTUxYkQ0MzI4MDMwMTI2NDVBYzEzNmRkZDY0REJBNzJcIlxuICpcbiAqICAgIC8vIFRoZSBzYWx0XG4gKiAgICBzYWx0ID0gaWQoXCJIZWxsb1dvcmxkXCIpXG4gKlxuICogICAgLy8gVGhlIGhhc2ggb2YgdGhlIGluaXRDb2RlXG4gKiAgICBpbml0Q29kZSA9IFwiMHg2Mzk0MTk4ZGYxNjAwMDUyNjEwM2ZmNjAyMDYwMDQ2MDFjMzM1YWZhNjA0MDUxNjA2MGYzXCI7XG4gKiAgICBpbml0Q29kZUhhc2ggPSBrZWNjYWsyNTYoaW5pdENvZGUpXG4gKlxuICogICAgZ2V0Q3JlYXRlMkFkZHJlc3MoZnJvbSwgc2FsdCwgaW5pdENvZGVIYXNoKVxuICogICAgLy9fcmVzdWx0OlxuICovXG5leHBvcnQgZnVuY3Rpb24gZ2V0Q3JlYXRlMkFkZHJlc3MoX2Zyb20sIF9zYWx0LCBfaW5pdENvZGVIYXNoKSB7XG4gICAgY29uc3QgZnJvbSA9IGdldEFkZHJl

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

26774BhIG5ldyBgYGludDQ4YGAgdHlwZSBmb3IgJSV2JSUuXG4gICAgICovXG4gICAgc3RhdGljIGludDQ4KHYpIHsgcmV0dXJuIG4odiwgLTQ4KTsgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm4gYSBuZXcgYGBpbnQ1NmBgIHR5cGUgZm9yICUldiUlLlxuICAgICAqL1xuICAgIHN0YXRpYyBpbnQ1Nih2KSB7IHJldHVybiBuKHYsIC01Nik7IH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJuIGEgbmV3IGBgaW50NjRgYCB0eXBlIGZvciAlJXYlJS5cbiAgICAgKi9cbiAgICBzdGF0aWMgaW50NjQodikgeyByZXR1cm4gbih2LCAtNjQpOyB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiBhIG5ldyBgYGludDcyYGAgdHlwZSBmb3IgJSV2JSUuXG4gICAgICovXG4gICAgc3RhdGljIGludDcyKHYpIHsgcmV0dXJuIG4odiwgLTcyKTsgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm4gYSBuZXcgYGBpbnQ4MGBgIHR5cGUgZm9yICUldiUlLlxuICAgICAqL1xuICAgIHN0YXRpYyBpbnQ4MCh2KSB7IHJldHVybiBuKHYsIC04MCk7IH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJuIGEgbmV3IGBgaW50ODhgYCB0eXBlIGZvciAlJXYlJS5cbiAgICAgKi9cbiAgICBzdGF0aWMgaW50ODgodikgeyByZXR1cm4gbih2LCAtODgpOyB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiBhIG5ldyBgYGludDk2YGAgdHlwZSBmb3IgJSV2JSUuXG4gICAgICovXG4gICAgc3RhdGljIGludDk2KHYpIHsgcmV0dXJuIG4odiwgLTk2KTsgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm4gYSBuZXcgYGBpbnQxMDRgYCB0eXBlIGZvciAlJXYlJS5cbiAgICAgKi9cbiAgICBzdGF0aWMgaW50MTA0KHYpIHsgcmV0dXJuIG4odiwgLTEwNCk7IH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJuIGEgbmV3IGBgaW50MTEyYGAgdHlwZSBmb3IgJSV2JSUuXG4gICAgICovXG4gICAgc3RhdGljIGludDExMih2KSB7IHJldHVybiBuKHYsIC0xMTIpOyB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiBhIG5ldyBgYGludDEyMGBgIHR5cGUgZm9yICUldiUlLlxuICAgICAqL1xuICAgIHN0YXRpYyBpbnQxMjAodikgeyByZXR1cm4gbih2LCAtMTIwKTsgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm4gYSBuZXcgYGBpbnQxMjhgYCB0eXBlIGZvciAlJXYlJS5cbiAgICAgKi9cbiAgICBzdGF0aWMgaW50MTI4KHYpIHsgcmV0dXJuIG4odiwgLTEyOCk7IH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJuIGEgbmV3IGBgaW50MTM2YGAgdHlwZSBmb3IgJSV2JSUuXG4gICAgICovXG4gICAgc3RhdGljIGludDEzNih2KSB7IHJldHVybiBuKHYsIC0xMzYpOyB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiBhIG5ldyBgYGludDE0NGBgIHR5cGUgZm9yICUldiUlLlxuICAgICAqL1xuICAgIHN0YXRpYyBpbnQxNDQodikgeyByZXR1cm4gbih2LCAtMTQ0KTsgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm4gYSBuZXcgYGBpbnQ1MmBgIHR5cGUgZm9yICUldiUlLlxuICAgICAqL1xuICAgIHN0YXRpYyBpbnQxNTIodikgeyByZXR1cm4gbih2LCAtMTUyKTsgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm4gYSBuZXcgYGBpbnQxNjBgYCB0eXBlIGZvciAlJXYlJS5cbiAgICAgKi9cbiAgICBzdGF0aWMgaW50MTYwKHYpIHsgcmV0dXJuIG4odiwgLTE2MCk7IH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJuIGEgbmV3IGBgaW50MTY4YGAgdHlwZSBmb3IgJSV2JSUuXG4gICAgICovXG4gICAgc3RhdGljIGludDE2OCh2KSB7IHJldHVybiBuKHYsIC0xNjgpOyB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiBhIG5ldyBgYGludDE3NmBgIHR5cGUgZm9yICUldiUlLlxuICAgICAqL1xuICAgIHN0YXRpYyBpbnQxNzYodikgeyByZXR1cm4gbih2LCAtMTc2KTsgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm4gYSBuZXcgYGBpbnQxODRgYCB0eXBlIGZvciAlJXYlJS5cbiAgICAgKi9cbiAgICBzdGF0aWMgaW50MTg0KHYpIHsgcmV0dXJuIG4odiwgLTE4NCk7IH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJuIGEgbmV3IGBgaW50OTJgYCB0eXBlIGZvciAlJXYlJS5cbiAgICAgKi9cbiAgICBzdGF0aWMgaW50MTkyKHYpIHsgcmV0dXJuIG4odiwgLTE5Mik7IH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJuIGEgbmV3IGBgaW50MjAwYGAgdHlwZSBmb3IgJSV2JSUuXG4gICAgICovXG4gICAgc3RhdGljIGludDIwMCh2KSB7IHJldHVybiBuKHYsIC0yMDApOyB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiBhIG5ldyBgYGludDIwOGBgIHR5cGUgZm9yICUldiUlLlxuICAgICAqL1xuICAgIHN0YXRpYyBpbnQyMDgodikgeyByZXR1cm4gbih2LCAtMjA4KTsgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm4gYSBuZXcgYGBpbnQyMTZgYCB0eXBlIGZvciAlJXYlJS5cbiAgICAgKi9cbiAgICBzdGF0aWMgaW50MjE2KHYpIHsgcmV0dXJuIG4odiwgLTIxNik7IH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJuIGEgbmV3IGBgaW50MjI0YGAgdHlwZSBmb3IgJSV2JSUuXG4gICAgICovXG4gICAgc3RhdGljIGludDIyNCh2KSB7IHJldHVybiBuKHYsIC0yMjQpOyB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiBhIG5ldyBgYGludDIzMmBgIHR5cGUgZm9yICUldiUlLlxuICAgICAqL1xuICAgIHN0YXRpYyBpbnQyMzIodikgeyByZXR1cm4gbih2LCAtMjMyKTsgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm4gYSBuZXcgYGBpbnQyNDBgYCB0eXBlIGZvciAlJXYlJS5cbiAgICAgKi9cbiAgICBzdGF0aWMgaW50MjQwKHYpIHsgcmV0dXJuIG4odiwgLTI0MCk7IH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJuIGEgbmV3IGBgaW50MjQ4YGAgdHlwZSBmb3IgJSV2JSUuXG4gICAgICovXG4gICAgc3RhdGljIGludDI0OCh2KSB7IHJldHVybiBuKHYsIC0yNDgpOyB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiBhIG5ldyBgYGludDI1NmBgIHR5cGUgZm9yICUldiUlLlxuICAgICAqL1xuICAgIHN0YXRpYyBpbnQyNTYodikgeyByZXR1cm4gbih2LCAtMjU2KTsgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm4gYSBuZXcgYGBpbnQyNTZgYCB0eXBlIGZvciAlJXYlJS5cbiAgICAgKi9cbiAgICBzdGF0aWMgaW50KHYpIHsgcmV0dXJuIG4odiwgLTI1Nik7IH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJuIGEgbmV3IGBgYnl0ZXMxYGAgdHlwZSBmb3IgJSV2JSUuXG4gICAgICovXG4gICAgc3RhdGljIGJ5dGVzMSh2KSB7IHJldHVybi

26774BiKHYsIDEpOyB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiBhIG5ldyBgYGJ5dGVzMmBgIHR5cGUgZm9yICUldiUlLlxuICAgICAqL1xuICAgIHN0YXRpYyBieXRlczIodikgeyByZXR1cm4gYih2LCAyKTsgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm4gYSBuZXcgYGBieXRlczNgYCB0eXBlIGZvciAlJXYlJS5cbiAgICAgKi9cbiAgICBzdGF0aWMgYnl0ZXMzKHYpIHsgcmV0dXJuIGIodiwgMyk7IH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJuIGEgbmV3IGBgYnl0ZXM0YGAgdHlwZSBmb3IgJSV2JSUuXG4gICAgICovXG4gICAgc3RhdGljIGJ5dGVzNCh2KSB7IHJldHVybiBiKHYsIDQpOyB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiBhIG5ldyBgYGJ5dGVzNWBgIHR5cGUgZm9yICUldiUlLlxuICAgICAqL1xuICAgIHN0YXRpYyBieXRlczUodikgeyByZXR1cm4gYih2LCA1KTsgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm4gYSBuZXcgYGBieXRlczZgYCB0eXBlIGZvciAlJXYlJS5cbiAgICAgKi9cbiAgICBzdGF0aWMgYnl0ZXM2KHYpIHsgcmV0dXJuIGIodiwgNik7IH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJuIGEgbmV3IGBgYnl0ZXM3YGAgdHlwZSBmb3IgJSV2JSUuXG4gICAgICovXG4gICAgc3RhdGljIGJ5dGVzNyh2KSB7IHJldHVybiBiKHYsIDcpOyB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiBhIG5ldyBgYGJ5dGVzOGBgIHR5cGUgZm9yICUldiUlLlxuICAgICAqL1xuICAgIHN0YXRpYyBieXRlczgodikgeyByZXR1cm4gYih2LCA4KTsgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm4gYSBuZXcgYGBieXRlczlgYCB0eXBlIGZvciAlJXYlJS5cbiAgICAgKi9cbiAgICBzdGF0aWMgYnl0ZXM5KHYpIHsgcmV0dXJuIGIodiwgOSk7IH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJuIGEgbmV3IGBgYnl0ZXMxMGBgIHR5cGUgZm9yICUldiUlLlxuICAgICAqL1xuICAgIHN0YXRpYyBieXRlczEwKHYpIHsgcmV0dXJuIGIodiwgMTApOyB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiBhIG5ldyBgYGJ5dGVzMTFgYCB0eXBlIGZvciAlJXYlJS5cbiAgICAgKi9cbiAgICBzdGF0aWMgYnl0ZXMxMSh2KSB7IHJldHVybiBiKHYsIDExKTsgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm4gYSBuZXcgYGBieXRlczEyYGAgdHlwZSBmb3IgJSV2JSUuXG4gICAgICovXG4gICAgc3RhdGljIGJ5dGVzMTIodikgeyByZXR1cm4gYih2LCAxMik7IH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJuIGEgbmV3IGBgYnl0ZXMxM2BgIHR5cGUgZm9yICUldiUlLlxuICAgICAqL1xuICAgIHN0YXRpYyBieXRlczEzKHYpIHsgcmV0dXJuIGIodiwgMTMpOyB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiBhIG5ldyBgYGJ5dGVzMTRgYCB0eXBlIGZvciAlJXYlJS5cbiAgICAgKi9cbiAgICBzdGF0aWMgYnl0ZXMxNCh2KSB7IHJldHVybiBiKHYsIDE0KTsgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm4gYSBuZXcgYGBieXRlczE1YGAgdHlwZSBmb3IgJSV2JSUuXG4gICAgICovXG4gICAgc3RhdGljIGJ5dGVzMTUodikgeyByZXR1cm4gYih2LCAxNSk7IH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJuIGEgbmV3IGBgYnl0ZXMxNmBgIHR5cGUgZm9yICUldiUlLlxuICAgICAqL1xuICAgIHN0YXRpYyBieXRlczE2KHYpIHsgcmV0dXJuIGIodiwgMTYpOyB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiBhIG5ldyBgYGJ5dGVzMTdgYCB0eXBlIGZvciAlJXYlJS5cbiAgICAgKi9cbiAgICBzdGF0aWMgYnl0ZXMxNyh2KSB7IHJldHVybiBiKHYsIDE3KTsgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm4gYSBuZXcgYGBieXRlczE4YGAgdHlwZSBmb3IgJSV2JSUuXG4gICAgICovXG4gICAgc3RhdGljIGJ5dGVzMTgodikgeyByZXR1cm4gYih2LCAxOCk7IH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJuIGEgbmV3IGBgYnl0ZXMxOWBgIHR5cGUgZm9yICUldiUlLlxuICAgICAqL1xuICAgIHN0YXRpYyBieXRlczE5KHYpIHsgcmV0dXJuIGIodiwgMTkpOyB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiBhIG5ldyBgYGJ5dGVzMjBgYCB0eXBlIGZvciAlJXYlJS5cbiAgICAgKi9cbiAgICBzdGF0aWMgYnl0ZXMyMCh2KSB7IHJldHVybiBiKHYsIDIwKTsgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm4gYSBuZXcgYGBieXRlczIxYGAgdHlwZSBmb3IgJSV2JSUuXG4gICAgICovXG4gICAgc3RhdGljIGJ5dGVzMjEodikgeyByZXR1cm4gYih2LCAyMSk7IH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJuIGEgbmV3IGBgYnl0ZXMyMmBgIHR5cGUgZm9yICUldiUlLlxuICAgICAqL1xuICAgIHN0YXRpYyBieXRlczIyKHYpIHsgcmV0dXJuIGIodiwgMjIpOyB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiBhIG5ldyBgYGJ5dGVzMjNgYCB0eXBlIGZvciAlJXYlJS5cbiAgICAgKi9cbiAgICBzdGF0aWMgYnl0ZXMyMyh2KSB7IHJldHVybiBiKHYsIDIzKTsgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm4gYSBuZXcgYGBieXRlczI0YGAgdHlwZSBmb3IgJSV2JSUuXG4gICAgICovXG4gICAgc3RhdGljIGJ5dGVzMjQodikgeyByZXR1cm4gYih2LCAyNCk7IH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJuIGEgbmV3IGBgYnl0ZXMyNWBgIHR5cGUgZm9yICUldiUlLlxuICAgICAqL1xuICAgIHN0YXRpYyBieXRlczI1KHYpIHsgcmV0dXJuIGIodiwgMjUpOyB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiBhIG5ldyBgYGJ5dGVzMjZgYCB0eXBlIGZvciAlJXYlJS5cbiAgICAgKi9cbiAgICBzdGF0aWMgYnl0ZXMyNih2KSB7IHJldHVybiBiKHYsIDI2KTsgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm4gYSBuZXcgYGBieXRlczI3YGAgdHlwZSBmb3IgJSV2JSUuXG4gICAgICovXG4gICAgc3RhdGljIGJ5dGVzMjcodikgeyByZXR1cm4gYih2LCAyNyk7IH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJuIGEgbmV3IGBgYnl0ZXMyOGBgIHR5cGUgZm9yICUldiUlLlxuICAgICAqL1xuICAgIHN0YXRpYyBieXRlczI4KHYpIHsgcmV0dXJuIGIodiwgMjgpOyB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiBhIG5ldyBgYGJ5dGVzMjlgYCB0eXBlIGZvciAlJXYlJS5cbiAgICAgKi9cbiAgICBzdGF0aWMgYnl0ZXMyOSh2KSB7IHJldHVybi

26774BiKHYsIDI5KTsgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm4gYSBuZXcgYGBieXRlczMwYGAgdHlwZSBmb3IgJSV2JSUuXG4gICAgICovXG4gICAgc3RhdGljIGJ5dGVzMzAodikgeyByZXR1cm4gYih2LCAzMCk7IH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJuIGEgbmV3IGBgYnl0ZXMzMWBgIHR5cGUgZm9yICUldiUlLlxuICAgICAqL1xuICAgIHN0YXRpYyBieXRlczMxKHYpIHsgcmV0dXJuIGIodiwgMzEpOyB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiBhIG5ldyBgYGJ5dGVzMzJgYCB0eXBlIGZvciAlJXYlJS5cbiAgICAgKi9cbiAgICBzdGF0aWMgYnl0ZXMzMih2KSB7IHJldHVybiBiKHYsIDMyKTsgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm4gYSBuZXcgYGBhZGRyZXNzYGAgdHlwZSBmb3IgJSV2JSUuXG4gICAgICovXG4gICAgc3RhdGljIGFkZHJlc3ModikgeyByZXR1cm4gbmV3IFR5cGVkKF9nYXVyZCwgXCJhZGRyZXNzXCIsIHYpOyB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiBhIG5ldyBgYGJvb2xgYCB0eXBlIGZvciAlJXYlJS5cbiAgICAgKi9cbiAgICBzdGF0aWMgYm9vbCh2KSB7IHJldHVybiBuZXcgVHlwZWQoX2dhdXJkLCBcImJvb2xcIiwgISF2KTsgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm4gYSBuZXcgYGBieXRlc2BgIHR5cGUgZm9yICUldiUlLlxuICAgICAqL1xuICAgIHN0YXRpYyBieXRlcyh2KSB7IHJldHVybiBuZXcgVHlwZWQoX2dhdXJkLCBcImJ5dGVzXCIsIHYpOyB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiBhIG5ldyBgYHN0cmluZ2BgIHR5cGUgZm9yICUldiUlLlxuICAgICAqL1xuICAgIHN0YXRpYyBzdHJpbmc

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

2677450eXBlID0gY29kZXIudHlwZTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgfVxuICAgICAgICBlbHNlIHtcbiAgICAgICAgICAgIHRyeSB7XG4gICAgICAgICAgICAgICAgdmFsdWUgPSBjb2Rlci5kZWNvZGUocmVhZGVyKTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgICAgIGNhdGNoIChlcnJvcikge1xuICAgICAgICAgICAgICAgIC8vIENhbm5vdCByZWNvdmVyIGZyb20gdGhpc1xuICAgICAgICAgICAgICAgIGlmIChpc0Vycm9yKGVycm9yLCBcIkJVRkZFUl9PVkVSUlVOXCIpKSB7XG4gICAgICAgICAgICAgICAgICAgIHRocm93IGVycm9yO1xuICAgICAgICAgICAgICAgIH1cbiAgICAgICAgICAgICAgICB2YWx1ZSA9IGVycm9yO1xuICAgICAgICAgICAgICAgIHZhbHVlLmJhc2VUeXBlID0gY29kZXIubmFtZTtcbiAgICAgICAgICAgICAgICB2YWx1ZS5uYW1lID0gY29kZXIubG9jYWxOYW1lO1xuICAgICAgICAgICAgICAgIHZhbHVlLnR5cGUgPSBjb2Rlci50eXBlO1xuICAgICAgICAgICAgfVxuICAgICAgICB9XG4gICAgICAgIGlmICh2YWx1ZSA9PSB1bmRlZmluZWQpIHtcbiAgICAgICAgICAgIHRocm93IG5ldyBFcnJvcihcImludmVzdGlnYXRlXCIpO1xuICAgICAgICB9XG4gICAgICAgIHZhbHVlcy5wdXNoKHZhbHVlKTtcbiAgICAgICAga2V5cy5wdXNoKGNvZGVyLmxvY2FsTmFtZSB8fCBudWxsKTtcbiAgICB9KTtcbiAgICByZXR1cm4gUmVzdWx0LmZyb21JdGVtcyh2YWx1ZXMsIGtleXMpO1xufVxuLyoqXG4gKiAgQF9pZ25vcmVcbiAqL1xuZXhwb3J0IGNsYXNzIEFycmF5Q29kZXIgZXh0ZW5kcyBDb2RlciB7XG4gICAgY29kZXI7XG4gICAgbGVuZ3RoO1xuICAgIGNvbnN0cnVjdG9yKGNvZGVyLCBsZW5ndGgsIGxvY2FsTmFtZSkge1xuICAgICAgICBjb25zdCB0eXBlID0gKGNvZGVyLnR5cGUgKyBcIltcIiArIChsZW5ndGggPj0gMCA/IGxlbmd0aCA6IFwiXCIpICsgXCJdXCIpO1xuICAgICAgICBjb25zdCBkeW5hbWljID0gKGxlbmd0aCA9PT0gLTEgfHwgY29kZXIuZHluYW1pYyk7XG4gICAgICAgIHN1cGVyKFwiYXJyYXlcIiwgdHlwZSwgbG9jYWxOYW1lLCBkeW5hbWljKTtcbiAgICAgICAgZGVmaW5lUHJvcGVydGllcyh0aGlzLCB7IGNvZGVyLCBsZW5ndGggfSk7XG4gICAgfVxuICAgIGRlZmF1bHRWYWx1ZSgpIHtcbiAgICAgICAgLy8gVmVyaWZpZXMgdGhlIGNoaWxkIGNvZGVyIGlzIHZhbGlkIChldmVuIGlmIHRoZSBhcnJheSBpcyBkeW5hbWljIG9yIDAtbGVuZ3RoKVxuICAgICAgICBjb25zdCBkZWZhdWx0Q2hpbGQgPSB0aGlzLmNvZGVyLmRlZmF1bHRWYWx1ZSgpO1xuICAgICAgICBjb25zdCByZXN1bHQgPSBbXTtcbiAgICAgICAgZm9yIChsZXQgaSA9IDA7IGkgPCB0aGlzLmxlbmd0aDsgaSsrKSB7XG4gICAgICAgICAgICByZXN1bHQucHVzaChkZWZhdWx0Q2hpbGQpO1xuICAgICAgICB9XG4gICAgICAgIHJldHVybiByZXN1bHQ7XG4gICAgfVxuICAgIGVuY29kZSh3cml0ZXIsIF92YWx1ZSkge1xuICAgICAgICBjb25zdCB2YWx1ZSA9IFR5cGVkLmRlcmVmZXJlbmNlKF92YWx1ZSwgXCJhcnJheVwiKTtcbiAgICAgICAgaWYgKCFBcnJheS5pc0FycmF5KHZhbHVlKSkge1xuICAgICAgICAgICAgdGhpcy5fdGhyb3dFcnJvcihcImV4cGVjdGVkIGFycmF5IHZhbHVlXCIsIHZhbHVlKTtcbiAgICAgICAgfVxuICAgICAgICBsZXQgY291bnQgPSB0aGlzLmxlbmd0aDtcbiAgICAgICAgaWYgKGNvdW50ID09PSAtMSkge1xuICAgICAgICAgICAgY291bnQgPSB2YWx1ZS5sZW5ndGg7XG4gICAgICAgICAgICB3cml0ZXIud3JpdGVWYWx1ZSh2YWx1ZS5sZW5ndGgpO1xuICAgICAgICB9XG4gICAgICAgIGFzc2VydEFyZ3VtZW50Q291bnQodmFsdWUubGVuZ3RoLCBjb3VudCwgXCJjb2RlciBhcnJheVwiICsgKHRoaXMubG9jYWxOYW1lID8gKFwiIFwiICsgdGhpcy5sb2NhbE5hbWUpIDogXCJcIikpO1xuICAgICAgICBsZXQgY29kZXJzID0gW107XG4gICAgICAgIGZvciAobGV0IGkgPSAwOyBpIDwgdmFsdWUubGVuZ3RoOyBpKyspIHtcbiAgICAgICAgICAgIGNvZGVycy5wdXNoKHRoaXMuY29kZXIpO1xuICAgICAgICB9XG4gICAgICAgIHJldHVybiBwYWNrKHdyaXRlciwgY29kZXJzLCB2YWx1ZSk7XG4gICAgfVxuICAgIGRlY29kZShyZWFkZXIpIHtcbiAgICAgICAgbGV0IGNvdW50ID0gdGhpcy5sZW5ndGg7XG4gICAgICAgIGlmIChjb3VudCA9PT0gLTEpIHtcbiAgICAgICAgICAgIGNvdW50ID0gcmVhZGVyLnJlYWRJbmRleCgpO1xuICAgICAgICAgICAgLy8gQ2hlY2sgdGhhdCB0aGVyZSBpcyAqcm91Z2hseSogZW5vdWdoIGRhdGEgdG8gZW5zdXJlXG4gICAgICAgICAgICAvLyBzdHJheSByYW5kb20gZGF0YSBpcyBub3QgYmVpbmcgcmVhZCBhcyBhIGxlbmd0aC4gRWFjaFxuICAgICAgICAgICAgLy8gc2xvdCByZXF1aXJlcyBhdCBsZWFzdCAzMiBieXRlcyBmb3IgdGhlaXIgdmFsdWUgKG9yIDMyXG4gICAgICAgICAgICAvLyBieXRlcyBhcyBhIGxpbmsgdG8gdGhlIGRhdGEpLiBUaGlzIGNvdWxkIHVzZSBhIG11Y2hcbiAgICAgICAgICAgIC8vIHRpZ2h0ZXIgYm91bmQsIGJ1dCB3ZSBhcmUgZXJyb3Jpbmcgb24gdGhlIHNpZGUgb2Ygc2FmZXR5LlxuICAgICAgICAgICAgYXNzZXJ0KGNvdW50ICogV29yZFNpemUgPD0gcmVhZGVyLmRhdGFMZW5ndGgsIFwiaW5zdWZmaWNpZW50IGRhdGEgbGVuZ3RoXCIsIFwiQlVGRkVSX09WRVJSVU5cIiwgeyBidWZmZXI6IHJlYWRlci5ieXRlcywgb2Zmc2V0OiBjb3VudCAqIFdvcmRTaXplLCBsZW5ndGg6IHJlYWRlci5kYXRhTGVuZ3RoIH0pO1xuICAgICAgICB9XG4gICAgICAgIGxldCBjb2RlcnMgPSBbXTtcbiAgICAgICAgZm9yIChsZXQgaSA9IDA7IGkgPCBjb3VudDsgaSsrKSB7XG4gICAgICAgICAgICBjb2RlcnMucHVzaChuZXcgQW5vbnltb3VzQ29kZXIodGhpcy5jb2RlcikpO1xuICAgICAgICB9XG4gICAgICAgIHJldHVybiB1bnBhY2socmVhZGVyLCBjb2RlcnMpO1xuICAgIH1cbn1cbi8vIyBzb3VyY2VNYXBwaW5nVVJMPWFycmF5LmpzLm1hcCIsImltcG9ydCB7IFR5cGVkIH0gZnJvbSBcIi4uL3R5cGVkLmpzXCI7XG5pbXBvcnQgeyBDb2RlciB9IGZyb20gXCIuL2Fic3RyYWN0LWNvZGVyLmpzXCI7XG4vKipcbiAqICBAX2lnbm9yZVxuICovXG5leHBvcnQgY2xhc3MgQm9vbGVhbkNvZGVyIGV4dGVuZHMgQ29kZXIge1xuICAgIGNvbnN0cnVjdG9yKGxvY2FsTmFtZSkge1xuICAgICAgICBzdXBlcihcImJvb2xcIiwgXCJib29sXCIsIGxvY2FsTmFtZSwgZmFsc2UpO1xuICAgIH1cbiAgICBkZWZhdWx0VmFsdWUoKSB7XG4gICAgICAgI

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

26774h1d1B2R3U4bjVrRlRCZnNEbnc4NlNUUHFCTGtMWlFpSENUc0FSUTZmRXdmVEdHWUtiWXpNQVMySEFiT1ZBMU9OZndKcml3WXpCd2NBWXdlREJYWGhBQmtDb3dpZkFBRUF5d05UQURVQ3FRZVpBQlVBZ1QwQk9RTWpLd0VkNFFLTEE0OElMY2NCa1NzQjd5VUVGNzhNRVFEek0yNUdBc090QW9CbVpwNEYyVlFDaWdKRk1RRkpJUVFCU2tOTkE2dHQzUURYQUVjR0Q5dERBUkduUnNjVzN6OEIyMnNuQU1NQTl3QUJNUWNCUFFISkFlOXBBTE1CV3dzdENaNnZzUUZKNVNVQWZ3QVJad0hUQW9VQTJRQXhBSHZ0QVU4QVNRVlY5UVhQQWt0RkFRMHRGQ2RUWFFHM0F4c0JMd0VKQUhVR3g0bWh4UU1iQkdrSHp3SVFGeFhkQXU4cUI3RURJdHNUeVVMQkFyM2FVUUF5RWdvMENyVUt0QjlmODF3dkFpMXVQVXdBQ2gra1BzTS9TZ1ZOTzA4N1ZEdFBPMVE3VHp0VU8wODdWRHRQTzFRRGs3dmV1OTRLYUY5QlllY01vZzNRUk1RNlJSUFhZRTFnTGhQRUxiTVV2UlhLSlZJWk9ScTRKd0VsNEZVRkR3QXR6MllzQ0NnMGNSZTRBRHNwWklNOVk0SWVMQXBISE9OVGpWVDBMUmNBclV1ZU02c05xQnNSUkR3RlEzWHBZaVlXQ2dvZUFtUjlBbUkrVjBtclZ6Y2NBcUh6QW1pVUFtWUZBcCtBT0JjSEFtWTNBbVlpQkdvRWV3Ti9Ed04ramprQ09YTVRPWDQ2SHg4Q2JCa0NNakk0QmdKdHd3SnRxdXVHTDJOQkp3RmpBTm9BM1FCR0FRZVVESWtBK2dlK0FBbXhBbmNyQW5hZU93SjVSejhDZUxZWldOZEZxa2JUQW53N0FuckVBbjBGQW56c0JWVUZIRWY4U0hsZklBQW5FVWxVU2xjUkUwcklBdEQ5QXRESVN5TURpRXNEaCtKRXdaRXVBdktkWFA4REE2cEx5a3dwSWN0TlNFMnJBb3M3QW9yVXZSY0RHVDlqQWJNQ2pqTUNqbGc4azMwQ2p0VUNqbGgwVWJCVE1RWlMwRlNCQXBQM0FwTUlBT1VBR0

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

26774oaFM2N09yQTJIZXQ0TTlKTTNqbS95Ulg2Yll4bmZtellsNXFRZEh4TjA4RnNOdVdEcldkNHZNVVkyUUQzaHI4dlM3M1NDVGtGb1haUjN4TnpPUXQ4ZC82SGZqQm1YcXZyRTZFR2tMeks2WUsyVTIva3NVL2lVSCtMdlZJc0pJK3JpMkFML2tsbytTaGREeWZzNUE4M2kycHJrTXM1MUlLUjdaY3FqWkppNVgzK2JkOEdseVd2dGRkeEtFb0VxU2dFTzdBOGpJZ2YybkgwaDhGak03b0I2eXRlM1g1bXBMMGkvRTRSeDBDb3RLbklMSmovdkpxbzRWa1BROTNqUnRSVmZhaXRRUHFsZGw1eFJZUHE4Mzg3WjBEY25adk9lSU9OMEh0MStQMjdrRkxHUUljTEJYNEZHM3NmZmNjTkhoNWNQZnpwOUlOb1J0cVZ0ZFZpSmZnOFJqblhpSXovTU5xRU42enZ6WDNoTXp5V0M3b1NvWElUMTR1YmMwYWJQWDhScDlHVmE1TkkvOGl2KzZlbGExb1RuY2JkaW1SS25yYlJmZkRSL1g0bkgrYmdxQXVIV2w3aE9hZVhQV1Z6SWVSbDdnYStKekQ0U3gzbWxqL3E2UmEvRTJIaERmMjFlRXpUTE5HZkNac1krL3l4WnpReklBdWlqRzY1aWk0Ty93YUFKQ3JFSmFXZC9EUkFLTVE1Njc4RHc1QVQ3UkNLemRhZEl3ZDhMc0QrRGdQQkFTbVdzVWxmOFIwazF3LzJrNGxPMldwYjR6TUk2RUpWSnMweGsvd244L2ZSVVBxckRLaGJqSFI0MVNxZ0ZNeDVSR01QdWR1RndsdTVsSzg5dFcxMXNUcWlYLzVFZkdzNW5PK3k5Rkt2Z1hLUE9FbWdFMDVFS05MNlNqYjN4UzQwSDNCVlBobTBFU09aZ0FqWm95bWM4YmUwaW5EVm80SmRKVmYrTktkM3ROL0NhQjdHU2hoSDI3cWY5NU5vRlpWWC82WmtSMmxYK0NnV3JRMklOZ2toK2JiTXo2OCt1SjNDbHNoOEhTTVBFUXRBdCtCQkU2ZlhEYWI3S0lsc0t4VTFsSVhXL0tXVnN0cGRQYW5KMHBkWHBRaW5EeVVRanRZN1pWY2ZpZWNSeFJETUFVaEhGVTJjRWFjaVEraHRpUE1QeDFrZHZ0V0c5VDQ0dzNyMDM3bGpIQkZKZFlSMHI1NXF2TVJpeHRBRUZKQXFBNFQxRVM4N0ZBeDdVb3pYYXN5dGc4TWZ0Wll0MHJqWWdMZTZFSjVhV3Z5MnFzY0JTQlE3eWVob0pJQTN3SUlaOXVrZmt5QmI2cW51ZTVrbzhXNTBycFY0a1hxV2pJNW5iR1JYck5XMHRCWkhYbFk0OG5TZ2NVWEJIV1Q0R2NnTFpKb0xsS0puVjk2a0NZcHE5ZVdIaDd4SnprQ0F5clF1UTVBSjBxcS91WjN0b0pnbE50ZXJlditRbTBLWHhQZy8rWWJGUkpkZmhicDF3T25WT0VZZFZIVHlhNkN0TzBhZmhFYUJoeDNvSHdDYjVLcTZSd0hEekZNbDJ2ZmpMOEd3emNDb1RqN3daZStVRm5ZRFYyeUtwUFU5ZGJhMjlnWUJkTnFKZy9LWG96TytDSlRsS21sS2hucVRmNWRvZVMzNURaRlYrY1lKUVZqZCtvVlkvR3RjLzZYUHpVeGIxZ01xZjZjRWpOTm9SQzhBT2JycCtmeDBjVnRHdTRmZkMyVGdYUkM4elBsOG1vVUhDQjVIWjI1ZDg3bWxzaWlLMGFOd0J0Y0VRalJOQlQvUXJYYncvOGFWWGRLTUhuOUVxWUVLRXl4U0dUcFlRT2FlczFHMVFxOHBEZ3FrWnRsTzJIUnlDWHBtZU03VFNyUlBrQWgwMDRCZmlzVnBGNnpQNDRuMkp2eHovZ09Wb2NOQ3l5OVY2bGtvZDI4UU00cGJhTXZWSmlnRC93M0Jyc2pTSnJYbHFjNHVsQllPQ2NlaUJONGIvZ0hhall5dXBiaEV0NjNhNjE5QXk0d3NMNmE2dzZCK0E3VG5veUU3QmxpV0hKZnpWeHhJS00vVzNNL0o4Qng5OU9wODYzUThlTnVJTUdSeCsrVmJZZmptK1ZHWUJBM0FwL0tFdS93eEJOQnBKSm5jd0hQRzQ1VjhHaDk4WklyR0NjMjBNd2lqR293WmJjUzdkMW5FZ2NPVzVjZGRacEhMMlhQQUlSYkNvbGloZVp6WFR2QnhaT1kzaU1TRFNLRHJJQ3lKL2lRczF2ZHBsVmRIL0pyTEpzUTJqdFRuZkNySVRJZ2hxM0tGWDNxQWdMV0FJcDhJZmZOU2RUWXB0bmJHZmM4cytxY3Izenl6eUhwMWFKZytqeFRGNGtEMXJ5NVdhdXY1VjN4bk9Hd1RGZWNOelhTTEhCVzIwL3BDUWprNHVvckQwcGxJaE1TVGM3OSsvcjRSS1BDbFJZVEJZZXgxT2I1Y3J0ZnZSUUJCdjZyZS82Rmh0Q3F0ZHVhZzY3Z2xxUkE3Ny8zdWxibGg5WVJ0TWREeGtDeUpEZU5uQXVDTFBRRm1kUlJXSnRIMjBaOERzdGZKZis1b2o1U1NCNjRkMGlGNS9ZYTRLZlRXeGZpdmo5QXAyL3piWWFUby8xZ08zdE02UllzQ1poYXJNQkZyN0ZtNjFtTFNyUW5FSTRPRjFnYlZTNGsvSkU5VW90T3JuTEpadXN3b1dvZENTVjh6Ynlia0pTVklQN244VWFFOXhDUjM5ckpabWYyN0hPQVBWT0djOXBka1FVY1JySTBxeVZGOVozajFSSERieElmd2JXem1QVmp3SWRQSnZ0bUJZd0VRSVVzSVcxUzkzOWhjVmlrSzAwb3pQUkkwMmNxaHpWVU56cE94VmRyd1JQdmxoMWFJT2YweEZFcUQzWWtHbkNuRmFoL2NGTjNKMmdCN04rYlpTR2F3d2tLRnUxdHBRTXJwMVcrMjdZTmt5VDBUcGNGcFRxZ09xcUxhYnJnY0NVUHhoOTdtUkVPR3k0eEl0elE5eFNsNnJxKzhCWnNIY3JRRlJlUytRZU14SjNQNkNuTDlFUC9lT0xEanVtTGh2cmNRcnBQaWtuc29mYnpCdjlnVFAwbFUrVElWd0U2RTdDY0tmVDM2cStaaUVPSEo5YXlmMGR5VUpMZXpBYjJNOGFOSHdkMCtPSm1zVmdUelJXQSc7XG5cbi8vIGh0dHBzOi8vdW5pY29kZS5vcmcvcmVwb3J0cy90cjE1L1xyXG4vLyBmb3IgcmVmZXJlbmNlIGltcGxlbWVudGF0aW9uXHJcbi8vIHNlZTogL2Rlcml2ZS9uZi5qc1xyXG5cclxuXHJcbi8vIGFsZ29yaXRobWljIGhhbmd1bFxyXG4vLyBodHRwczovL3d3dy51bmljb2RlLm9yZy92ZXJzaW9ucy9Vbmljb2RlMTUuMC4wL2NoMDMucGRmIChwYWdlIDE0NClcclxuY29uc3QgUzAgPSAweEFDMDA7XHJcbmNvbnN0IEwwID0gMHgxMTAwO1xyXG5jb25zdCBWMCA9IDB4MTE2MTtcclxuY29uc3QgVDAgPSAweDExQTc7XHJcbmNvbnN0IExfQ09VTlQgPSAxOTtcclxuY29uc3QgVl9DT1VOVCA9IDIxO1xyXG5jb25zdCBUX0NPVU5UID0gMjg7XHJcbmNvbnN0IE5fQ09VTlQgPSBWX0NPVU5UICogVF9DT1VOVDtcclxuY29uc3QgU19DT1VOVCA9IExfQ09VTlQgKiBOX0NPVU5UO1xyXG5jb25zdCBTMSA9IFMwICsgU19DT1VOVDtcclxuY29uc3QgTDEgPSBMMCArIExfQ09VTlQ7XHJcbmNvbnN0IFYxID0gVjAgKyBWX0NPVU5UO1xyXG5jb25zdCBUMSA9IFQwICsgVF9DT1VOVDtcclxuXHJcbmZ1bmN0aW9uIHVucGFja19jYyhwYWNrZWQpIHtcclxuXHRyZXR1cm4gKHBhY2tlZCA+PiAyNCkgJiAweEZGO1xyXG59XHJcbmZ1bmN0aW9uIHVucGFja19jcChwYWNrZWQpIHtcclxuXHRyZXR1cm4gcGFja2VkICYgMHhGRkZGRkY7XHJcbn1cclxuXHJcbmxldCBTSElGVEVEX1JBTkssIEVYQ0xVU0lPTlMsIERFQ09NUCwgUkVDT01QO1xyXG5cclxuLy8gZXhwb3J0IGZ1bmN0aW9uIG5mX2RlaW5pdCgpIHtcclxuLy8gXHRpZiAoIVNISUZURURfUkFOSykgcmV0dXJuO1xyXG4vLyBcdFNISUZURURfUkFOSyA9IEVYQ0xVU0lPTlMgPSBERUNPTVAgPSBSRUNPTVAgPSB1bmRlZmluZWQ7XHJcbi8vIH1cclxuXHJcbmZ1bmN0aW9uIGluaXQkMSgpIHtcclxuXHQvL2NvbnNvbGUudGltZSgnbmYnKTtcclxuXHRsZXQgciA9IHJlYWRfY29tcHJlc3NlZF9wYXlsb2FkKENPTVBSRVNTRUQpO1xyXG5cdFNISUZURURfUkFOSyA9IG5ldyBNYXAocmVhZF9zb3J0ZWRfYXJyYXlzKHIpLmZsYXRNYXAoKHYsIGkpID0+IHYubWFwKHggPT4gW3gsIChpKzEpIDw8IDI0XSkpKTsgLy8gcHJlLXNoaWZ0ZWRcclxuXHRFWENMVVNJT05TID0gbmV3IFNldChyZWFkX3NvcnRlZChyKSk7XHJcblx0REVDT01QID0gbmV3IE1hcCgpO1xyXG5cdFJFQ09NUCA9IG5ldyBNYXAoKTtcclxuXHRmb3IgKGxldCBbY3AsIGNwc10gb2YgcmVhZF9tYXBwZWQocikpIHtcclxuXHRcdGlmICghRVhDTFVTSU9OUy5oYXMoY3ApICYmIGNwcy5sZW5ndGggPT0gMikge1xyXG5cdFx0XHRsZXQgW2EsIGJdID0gY3BzO1xyXG5cdFx0XHRsZXQgYnVja2V0ID0gUkVDT01QLmdldChhKTtcclxuXHRcdFx0aWYgKCFidWNrZXQpIHtcclxuXHRcdFx0XHRidWNrZXQgPSBuZXcgTWFwKCk7XHJcblx0XHRcdFx0UkVDT01QLnNldChhLCBidWNrZXQpO1xyXG5cdFx0XHR9XHJcblx0XHRcdGJ1Y2tldC5zZXQoYiwgY3ApO1xyXG5cdFx0fVxyXG5cdFx0REVDT01QLnNldChjcCwgY3BzLnJldmVyc2UoKSk7IC8vIHN0b3JlZCByZXZlcnNlZFxyXG5cdH1cclxuXHQvL2NvbnNvbGUudGltZUVuZCgnbmYnKTtcclxuXHQvLyAyMDIzMDkwNTogMTFtc1xyXG59XHJcblxyXG5mdW5jdGlvbiBpc19oYW5ndWwoY3ApIHtcclxuXHRyZXR1cm4gY3AgPj0gUzAgJiYgY3AgPCBTMTtcclxufVxyXG5cclxuZnVuY3Rpb24gY29tcG9zZV9wYWlyKGEsIGIpIHtcclxuXHRpZiAoYSA+PSBMMCAmJiBhIDwgTDEgJiYgYiA+PSBWMCAmJiBiIDwgVjEpIHtcclxuXHRcdHJldHVybi

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

26774Bjb21wb3NlZF9mcm9tX2RlY29tcG9zZWQoZGVjb21wb3NlZChjcHMpKTtcclxufVxuXG5jb25zdCBIWVBIRU4gPSAweDJEO1xyXG5jb25zdCBTVE9QID0gMHgyRTtcclxuY29uc3QgU1RPUF9DSCA9ICcuJztcclxuY29uc3QgRkUwRiA9IDB4RkUwRjtcclxuY29uc3QgVU5JUVVFX1BIID0gMTtcclxuXHJcbi8vIDIwMjMwOTEzOiByZXBsYWNlIFsuLi52XSB3aXRoIEFycmF5X2Zyb20odikgdG8gYXZvaWQgbGFyZ2Ugc3ByZWFkc1xyXG5jb25zdCBBcnJheV9mcm9tID0geCA9PiBBcnJheS5mcm9tKHgpOyAvLyBBcnJheS5mcm9tLmJpbmQoQXJyYXkpO1xyXG5cclxuZnVuY3Rpb24gZ3JvdXBfaGFzX2NwKGcsIGNwKSB7XHJcblx0Ly8gMjAyMzA5MTM6IGtlZXAgcHJpbWFyeSBhbmQgc2Vjb25kYXJ5IGRpc3RpbmN0IGluc3RlYWQgb2YgY3JlYXRpbmcgdmFsaWQgdW5pb25cclxuXHRyZXR1cm4gZy5QLmhhcyhjcCkgfHwgZy5RLmhhcyhjcCk7XHJcbn1cclxuXHJcbmNsYXNzIEVtb2ppIGV4dGVuZHMgQXJyYXkge1xyXG5cdGdldCBpc19lbW9qaSgpIHsgcmV0dXJuIHRydWU7IH0gLy8gZnJlZSB0YWdnaW5nIHN5c3RlbVxyXG59XHJcblxyXG5sZXQgTUFQUEVELCBJR05PUkVELCBDTSwgTlNNLCBFU0NBUEUsIE5GQ19DSEVDSywgR1JPVVBTLCBXSE9MRV9WQUxJRCwgV0hPTEVfTUFQLCBWQUxJRCwgRU1PSklfTElTVCwgRU1PSklfUk9PVDtcclxuXHJcbi8vIGV4cG9ydCBmdW5jdGlvbiBlbnNfZGVpbml0KCkge1xyXG4vLyBcdG5mX2RlaW5pdCgpO1xyXG4vLyBcdGlmICghTUFQUEVEKSByZXR1cm47XHJcbi8vIFx0TUFQUEVEID0gSUdOT1JFRCA9IENNID0gTlNNID0gRVNDQVBFID0gTkZDX0NIRUNLID0gR1JPVVBTID0gV0hPTEVfVkFMSUQgPSBXSE9MRV9NQVAgPSBWQUxJRCA9IEVNT0pJX0xJU1QgPSBFTU9KSV9ST09UID0gdW5kZWZpbmVkO1xyXG4vLyB9XHJcblxyXG5mdW5jdGlvbiBpbml0KCkge1xyXG5cdGlmIChNQVBQRUQpIHJldHVybjtcclxuXHRcclxuXHRsZXQgciA9IHJlYWRfY29tcHJlc3NlZF9wYXlsb2FkKENPTVBSRVNTRUQkMSk7XHJcblx0Y29uc3QgcmVhZF9zb3J0ZWRfYXJyYXkgPSAoKSA9PiByZWFkX3NvcnRlZChyKTtcclxuXHRjb25zdCByZWFkX3NvcnRlZF9zZXQgPSAoKSA9PiBuZXcgU2V0KHJlYWRfc29ydGVkX2FycmF5KCkpO1xyXG5cdGNvbnN0IHNldF9hZGRfbWFueSA9IChzZXQsIHYpID0+IHYuZm9yRWFjaCh4ID0+IHNldC5hZGQoeCkpO1xyXG5cclxuXHRNQVBQRUQgPSBuZXcgTWFwKHJlYWRfbWFwcGVkKHIpKTsgXHJcblx0SUdOT1JFRCA9IHJlYWRfc29ydGVkX3NldCgpOyAvLyBpZ25vcmVkIGNoYXJhY3RlcnMgYXJlIG5vdCB2YWxpZCwgc28ganVzdCByZWFkIHJhdyBjb2RlcG9pbnRzXHJcblxyXG5cdC8qXHJcblx0Ly8gZGlyZWN0IGluY2x1ZGUgZnJvbSBwYXlsb2FkIGlzIHNtYWxsZXIgdGhhbiB0aGUgZGVjb21wcmVzc2lvbiBjb2RlXHJcblx0Y29uc3QgRkVOQ0VEID0gbmV3IE1hcChyZWFkX2FycmF5X3doaWxlKCgpID0+IHtcclxuXHRcdGxldCBjcCA9IHIoKTtcclxuXHRcdGlmIChjcCkgcmV0dXJuIFtjcCwgcmVhZF9zdHIocigpKV07XHJcblx0fSkpO1xyXG5cdCovXHJcblx0Ly8gMjAyMzAyMTc6IHdlIHN0aWxsIG5lZWQgYWxsIENNIGZvciBwcm9wZXIgZXJyb3IgZm9ybWF0dGluZ1xyXG5cdC8vIGJ1dCBub3JtIG9ubHkgbmVlZHMgTlNNIHN1YnNldCB0aGF0IGFyZSBwb3RlbnRpYWxseS12YWxpZFxyXG5cdENNID0gcmVhZF9zb3J0ZWRfYXJyYXkoKTtcclxuXHROU00gPSBuZXcgU2V0KHJlYWRfc29ydGVkX2FycmF5KCkubWFwKGkgPT4gQ01baV0pKTtcclxuXHRDTSA9IG5ldyBTZXQoQ00pO1xyXG5cdFxyXG5cdEVTQ0FQRSA9IHJlYWRfc29ydGVkX3NldCgpOyAvLyBjaGFyYWN0ZXJzIHRoYXQgc2hvdWxkIG5vdCBiZSBwcmludGVkXHJcblx0TkZDX0NIRUNLID0gcmVhZF9zb3J0ZWRfc2V0KCk7IC8vIG9ubHkgbmVlZGVkIHRvIGlsbHVzdHJhdGUgZW5zX3Rva2VuaXplKCkgdHJhbnNmb3JtYXRpb25zXHJcblxyXG5cdGxldCBjaHVua3MgPSByZWFkX3NvcnRlZF9hcnJheXMocik7XHJcblx0bGV0IHVucmVzdHJpY3RlZCA9IHIoKTtcclxuXHQvL2NvbnN0IHJlYWRfY2h1bmtlZCA9ICgpID0+IG5ldyBTZXQocmVhZF9zb3J0ZWRfYXJyYXkoKS5mbGF0TWFwKGkgPT4gY2h1bmtzW2ldKS5jb25jYXQocmVhZF9zb3J0ZWRfYXJyYXkoKSkpO1xyXG5cdGNvbnN0IHJlYWRfY2h1bmtlZCA9ICgpID0+IHtcclxuXHRcdC8vIDIwMjMwOTIxOiBidWlsZCBzZXQgaW4gcGFydHMsIDJ4IGZhc3RlclxyXG5cdFx0bGV0IHNldCA9IG5ldyBTZXQoKTtcclxuXHRcdHJlYWRfc29ydGVkX2FycmF5KCkuZm9yRWFjaChpID0+IHNldF9hZGRfbWFueShzZXQsIGNodW5rc1tpXSkpO1xyXG5cdFx0c2V0X2FkZF9tYW55KHNldCwgcmVhZF9zb3J0ZWRfYXJyYXkoKSk7XHJcblx0XHRyZXR1cm4gc2V0OyBcclxuXHR9O1xyXG5cdEdST1VQUyA9IHJlYWRfYXJyYXlfd2hpbGUoaSA9PiB7XHJcblx0XHQvLyBtaW5pZmllciBwcm9wZXJ0eSBtYW5nbGluZyBzZWVtcyB1bnNhZmVcclxuXHRcdC8vIHNvIHRoZXNlIGFyZSBtYW51YWxseSByZW5hbWVkIHRvIHNpbmdsZSBjaGFyc1xyXG5cdFx0bGV0IE4gPSByZWFkX2FycmF5X3doaWxlKHIpLm1hcCh4ID0+IHgrMHg2MCk7XHJcblx0XHRpZiAoTi5sZW5ndGgpIHtcclxuXHRcdFx0bGV0IFIgPSBpID49IHVucmVzdHJpY3RlZDsgLy8gdW5yZXN0cmljdGVkIHRoZW4gcmVzdHJpY3RlZFxyXG5cdFx0XHROWzBdIC09IDMyOyAvLyBjYXBpdGFsaXplXHJcblx0XHRcdE4gPSBzdHJfZnJvbV9jcHMoTik7XHJcblx0XHRcdGlmIChSKSBOPWBSZXN0cmljdGVkWyR7Tn1dYDtcclxuXHRcdFx0bGV0IFAgPSByZWFkX2NodW5rZWQoKTsgLy8gcHJpbWFyeVxyXG5cdFx0XHRsZXQgUSA9IHJlYWRfY2h1bmtlZCgpOyAvLyBzZWNvbmRhcnlcclxuXHRcdFx0bGV0IE0gPSAhcigpOyAvLyBub3Qtd2hpdGVsaXN0ZWQsIGNoZWNrIGZvciBOU01cclxuXHRcdFx0Ly8gKioqIHRoaXMgY29kZSBjdXJyZW50bHkgaXNuJ3QgbmVlZGVkICoqKlxyXG5cdFx0XHQvKlxyXG5cdFx0XHRsZXQgViA9IFsuLi5QLCAuLi5RXS5zb3J0KChhLCBiKSA9PiBhLWIpOyAvLyBkZXJpdmU6IHNvcnRlZCB2YWxpZFxyXG5cdFx0XHRsZXQgTSA9IHIoKS0xOyAvLyBudW1iZXIgb2YgY29tYmluaW5nIG1hcmtcclxuXHRcdFx0aWYgKE0gPCAwKSB7IC8vIHdoaXRlbGlzdGVkXHJcblx0XHRcdFx0TSA9IG5ldyBNYXAocmVhZF9hcnJheV93aGlsZSgoKSA9PiB7XHJcblx0XHRcdFx0XHRsZXQgaSA9IHIoKTtcclxuXHRcdFx0XHRcdGlmIChpKSByZXR1cm4gW1ZbaS0xXSwgcmVhZF9hcnJheV93aGlsZSgoKSA9PiB7XHJcblx0XHRcdFx0XHRcdGxldCB2ID0gcmVhZF9hcnJheV93aGlsZShyKTtcclxuXHRcdFx0XHRcdFx0aWYgKHYubGVuZ3RoKSByZXR1cm4gdi5tYXAoeCA9PiB4LTEpO1xyXG5cdFx0XHRcdFx0fSldO1xyXG5cdFx0XHRcdH0pKTtcclxuXHRcdFx0fSovXHJcblx0XHRcdHJldHVybi

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

26774Bjb2xsYXBzZV92YWxpZF90b2tlbnModG9rZW5zKTtcclxufVxyXG5cclxuZnVuY3Rpb24gaXNfdmFsaWRfb3JfbWFwcGVkKHR5cGUpIHtcclxuXHRyZXR1cm4gdHlwZSA9PSBUWV9WQUxJRCB8fCB0eXBlID09IFRZX01BUFBFRDtcclxufVxyXG5cclxuZnVuY3Rpb24gcmVxdWlyZXNfY2hlY2soY3BzKSB7XHJcblx0cmV0dXJuIGNwcy5zb21lKGNwID0+IE5GQ19DSEVDSy5oYXMoY3ApKTtcclxufVxyXG5cclxuZnVuY3Rpb24gY29sbGFwc2VfdmFsaWRfdG9rZW5zKHRva2Vucykge1xyXG5cdGZvciAobGV0IGkgPSAwOyBpIDwgdG9rZW5zLmxlbmd0aDsgaSsrKSB7XHJcblx0XHRpZiAodG9rZW5zW2ldLnR5cGUgPT0gVFlfVkFMSUQpIHtcclxuXHRcdFx0bGV0IGogPSBpICsgMTtcclxuXHRcdFx0d2hpbGUgKGogPCB0b2tlbnMubGVuZ3RoICYmIHRva2Vuc1tqXS50eXBlID09IFRZX1ZBTElEKSBqKys7XHJcblx0XHRcdHRva2Vucy5zcGxpY2UoaSwgaiAtIGksIHt0eXBlOiBUWV9WQUxJRCwgY3BzOiB0b2tlbnMuc2xpY2UoaSwgaikuZmxhdE1hcCh4ID0+IHguY3BzKX0pO1xyXG5cdFx0fVxyXG5cdH1cclxuXHRyZXR1cm4gdG9rZW5zO1xyXG59XG5cbmV4cG9ydCB7IGVuc19iZWF1dGlmeSwgZW5zX2Vtb2ppLCBlbnNfbm9ybWFsaXplLCBlbnNfbm9ybWFsaXplX2ZyYWdtZW50LCBlbnNfc3BsaXQsIGVuc190b2tlbml6ZSwgaXNfY29tYmluaW5nX21hcmssIG5mYywgbmZkLCBzYWZlX3N0cl9mcm9tX2Nwcywgc2hvdWxkX2VzY2FwZSB9O1xuIiwiaW1wb3J0IHsga2VjY2FrMjU2IH0gZnJvbSBcIi4uL2NyeXB0by9pbmRleC5qc1wiO1xuaW1wb3J0IHsgY29uY2F0LCBoZXhsaWZ5LCBhc3NlcnRBcmd1bWVudCwgdG9VdGY4Qnl0ZXMgfSBmcm9tIFwiLi4vdXRpbHMvaW5kZXguanNcIjtcbmltcG9ydCB7IGVuc19ub3JtYWxpemUgfSBmcm9tIFwiQGFkcmFmZnkvZW5zLW5vcm1hbGl6ZVwiO1xuY29uc3QgWmVyb3MgPSBuZXcgVWludDhBcnJheSgzMik7XG5aZXJvcy5maWxsKDApO1xuZnVuY3Rpb24gY2hlY2tDb21wb25lbnQoY29tcCkge1xuICAgIGFzc2VydEFyZ3VtZW50KGNvbXAubGVuZ3RoICE9PSAwLCBcImludmFsaWQgRU5TIG5hbWU7IGVtcHR5IGNvbXBvbmVudFwiLCBcImNvbXBcIiwgY29tcCk7XG4gICAgcmV0dXJuIGNvbXA7XG59XG5mdW5jdGlvbiBlbnNOYW1lU3BsaXQobmFtZSkge1xuICAgIGNvbnN0IGJ5dGVzID0gdG9VdGY4Qnl0ZXMoZW5zTm9ybWFsaXplKG5hbWUpKTtcbiAgICBjb25zdCBjb21wcyA9IFtdO1xuICAgIGlmIChuYW1lLmxlbmd0aCA9PT0gMCkge1xuICAgICAgICByZXR1cm4gY29tcHM7XG4gICAgfVxuICAgIGxldCBsYXN0ID0gMDtcbiAgICBmb3IgKGxldCBpID0gMDsgaSA8IGJ5dGVzLmxlbmd0aDsgaSsrKSB7XG4gICAgICAgIGNvbnN0IGQgPSBieXRlc1tpXTtcbiAgICAgICAgLy8gQSBzZXBhcmF0b3IgKGkuZS4gXCIuXCIpOyBjb3B5IHRoaXMgY29tcG9uZW50XG4gICAgICAgIGlmIChkID09PSAweDJlKSB7XG4gICAgICAgICAgICBjb21wcy5wdXNoKGNoZWNrQ29tcG9uZW50KGJ5dGVzLnNsaWNlKGxhc3QsIGkpKSk7XG4gICAgICAgICAgICBsYXN0ID0gaSArIDE7XG4gICAgICAgIH1cbiAgICB9XG4gICAgLy8gVGhlcmUgd2FzIGEgc3RyYXkgc2VwYXJhdG9yIGF0IHRoZSBlbmQgb2YgdGhlIG5hbWVcbiAgICBhc3NlcnRBcmd1bWVudChsYXN0IDwgYnl0ZXMubGVuZ3RoLCBcImludmFsaWQgRU5TIG5hbWU7IGVtcHR5IGNvbXBvbmVudFwiLCBcIm5hbWVcIiwgbmFtZSk7XG4gICAgY29tcHMucHVzaChjaGVja0NvbXBvbmVudChieXRlcy5zbGljZShsYXN0KSkpO1xuICAgIHJldHVybiBjb21wcztcbn1cbi8qKlxuICogIFJldHVybnMgdGhlIEVOUyAlJW5hbWUlJSBub3JtYWxpemVkLlxuICovXG5leHBvcnQgZnVuY3Rpb24gZW5zTm9ybWFsaXplKG5hbWUpIHtcbiAgICB0cnkge1xuICAgICAgICBpZiAobmFtZS5sZW5ndGggPT09IDApIHtcbiAgICAgICAgICAgIHRocm93IG5ldyBFcnJvcihcImVtcHR5IGxhYmVsXCIpO1xuICAgICAgICB9XG4gICAgICAgIHJldHVybiBlbnNfbm9ybWFsaXplKG5hbWUpO1xuICAgIH1cbiAgICBjYXRjaCAoZXJyb3IpIHtcbiAgICAgICAgYXNzZXJ0QXJndW1lbnQoZmFsc2UsIGBpbnZhbGlkIEVOUyBuYW1lICgke2Vycm9yLm1lc3NhZ2V9KWAsIFwibmFtZVwiLCBuYW1lKTtcbiAgICB9XG59XG4vKipcbiAqICBSZXR1cm5zIGBgdHJ1ZWBgIGlmICUlbmFtZSUlIGlzIGEgdmFsaWQgRU5TIG5hbWUuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBpc1ZhbGlkTmFtZShuYW1lKSB7XG4gICAgdHJ5IHtcbiAgICAgICAgcmV0dXJuIChlbnNOYW1lU3BsaXQobmFtZSkubGVuZ3RoICE9PSAwKTtcbiAgICB9XG4gICAgY2F0Y2ggKGVycm9yKSB7IH1cbiAgICByZXR1cm4gZmFsc2U7XG59XG4vKipcbiAqICBSZXR1cm5zIHRoZSBbW2xpbmstbmFtZWhhc2hdXSBmb3IgJSVuYW1lJSUuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBuYW1laGFzaChuYW1lKSB7XG4gICAgYXNzZXJ0QXJndW1lbnQodHlwZW9mIChuYW1lKSA9PT0gXCJzdHJpbmdcIiwgXCJpbnZhbGlkIEVOUyBuYW1lOyBub3QgYSBzdHJpbmdcIiwgXCJuYW1lXCIsIG5hbWUpO1xuICAgIGFzc2VydEFyZ3VtZW50KG5hbWUubGVuZ3RoLCBgaW52YWxpZCBFTlMgbmFtZSAoZW1wdHkgbGFiZWwpYCwgXCJuYW1lXCIsIG5hbWUpO1xuICAgIGxldCByZXN1bHQgPSBaZXJvcztcbiAgICBjb25zdCBjb21wcyA9IGVuc05hbWVTcGxpdChuYW1lKTtcbiAgICB3aGlsZSAoY29tcHMubGVuZ3RoKSB7XG4gICAgICAgIHJlc3VsdCA9IGtlY2NhazI1Nihjb25jYXQoW3Jlc3VsdCwga2VjY2FrMjU2KChjb21wcy5wb3AoKSkpXSkpO1xuICAgIH1cbiAgICByZXR1cm4gaGV4bGlmeShyZXN1bHQpO1xufVxuLyoqXG4gKiAgUmV0dXJucyB0aGUgRE5TIGVuY29kZWQgJSVuYW1lJSUuXG4gKlxuICogIFRoaXMgaXMgdXNlZCBmb3IgdmFyaW91cyBwYXJ0cyBvZiBFTlMgbmFtZSByZXNvbHV0aW9uLCBzdWNoXG4gKiAgYXMgdGhlIHdpbGRjYXJkIHJlc29sdXRpb24uXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBkbnNFbmNvZGUobmFtZSwgX21heExlbmd0aCkge1xuICAgIGNvbnN0IGxlbmd0aCA9IChfbWF4TGVuZ3RoICE9IG51bGwpID8gX21heExlbmd0aCA6IDYzO1xuICAgIGFzc2VydEFyZ3VtZW50KGxlbmd0aCA8PSAyNTUsIFwiRE5TIGVuY29kZWQgbGFiZWwgY2Fubm90IGV4Y2VlZCAyNTVcIiwgXCJsZW5ndGhcIiwgbGVuZ3RoKTtcbiAgICByZXR1cm4gaGV4bGlmeShjb25jYXQoZW5zTmFtZVNwbGl0KG5hbWUpLm1hcCgoY29tcCkgPT4ge1xuICAgICAgICBhc3NlcnRBcmd1bWVudChjb21wLmxlbmd0aCA8PSBsZW5ndGgsIGBsYWJlbCAke0pTT04uc3RyaW5naWZ5KG5hbWUpfSBleGNlZWRzICR7bGVuZ3RofSBieXRlc2AsIFwibmFtZVwiLCBuYW1lKTtcbiAgICAgICAgY29uc3QgYnl0ZXMgPSBuZXcgVWludDhBcnJheShjb21wLmxlbmd0aCArIDEpO1xuICAgICAgICBieXRlcy5zZXQoY29tcCwgMSk7XG4gICAgICAgIGJ5dGVzWzBdID0gYnl0ZXMubGVuZ3RoIC0gMTtcbiAgICAgICAgcmV0dXJuIGJ5dGVzO1xuICAgIH0pKSkgKyBcIjAwXCI7XG59XG4vLyMgc291cmNlTWFwcGluZ1VSTD1uYW1laGFzaC5qcy5tYXAiLCJpbXBvcnQgeyBrZWNjYWsyNTYgfSBmcm9tIFwiLi4vY3J5cHRvL2luZGV4LmpzXCI7XG5pbXBvcnQgeyBNZXNzYWdlUHJlZml4IH0gZnJvbSBcIi4uL2NvbnN0YW50cy9pbmRleC5qc1wiO1xuaW1wb3J0IHsgcmVjb3ZlckFkZHJl

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

26774VzLmxlbmd0aCA9PT0gd2lkdGgsIGBpbnZhbGlkIGxlbmd0aCBmb3IgJHt0eXBlfWAsIFwidmFsdWVcIiwgdmFsdWUpO1xuICAgICAgICAgICAgICAgIHJldHVybiBoZXhQYWRSaWdodCh2YWx1ZSk7XG4gICAgICAgICAgICB9O1xuICAgICAgICB9XG4gICAgfVxuICAgIHN3aXRjaCAodHlwZSkge1xuICAgICAgICBjYXNlIFwiYWRkcmVzc1wiOiByZXR1cm4gZnVuY3Rpb24gKHZhbHVlKSB7XG4gICAgICAgICAgICByZXR1cm4gemVyb1BhZFZhbHVlKGdldEFkZHJlc3ModmFsdWUpLCAzMik7XG4gICAgICAgIH07XG4gICAgICAgIGNhc2UgXCJib29sXCI6IHJldHVybiBmdW5jdGlvbiAodmFsdWUpIHtcbiAgICAgICAgICAgIHJldHVybiAoKCF2YWx1ZSkgPyBoZXhGYWxzZSA6IGhleFRydWUpO1xuICAgICAgICB9O1xuICAgICAgICBjYXNlIFwiYnl0ZXNcIjogcmV0dXJuIGZ1bmN0aW9uICh2YWx1ZSkge1xuICAgICAgICAgICAgcmV0dXJuIGtlY2NhazI1Nih2YWx1ZSk7XG4gICAgICAgIH07XG4gICAgICAgIGNhc2UgXCJzdHJpbmdcIjogcmV0dXJuIGZ1bmN0aW9uICh2YWx1ZSkge1xuICAgICAgICAgICAgcmV0dXJuIGlkKHZhbHVlKTtcbiAgICAgICAgfTtcbiAgICB9XG4gICAgcmV0dXJuIG51bGw7XG59XG5mdW5jdGlvbiBlbmNvZGVUeXBlKG5hbWUsIGZpZWxkcykge1xuICAgIHJldHVybiBgJHtuYW1lfSgke2ZpZWxkcy5tYXAoKHsgbmFtZSwgdHlwZSB9KSA9PiAodHlwZSArIFwiIFwiICsgbmFtZSkpLmpvaW4oXCIsXCIpfSlgO1xufVxuLy8gZm9vW11bM10gPT4geyBiYXNlOiBcImZvb1wiLCBpbmRleDogXCJbXVszXVwiLCBhcnJheToge1xuLy8gICAgIGJhc2U6IFwiZm9vXCIsIHByZWZpeDogXCJmb29bXVwiLCBjb3VudDogMyB9IH1cbmZ1bmN0aW9uIHNwbGl0QXJyYXkodHlwZSkge1xuICAgIGNvbnN0IG1hdGNoID0gdHlwZS5tYXRjaCgvXihbXlxceDViXSopKChcXHg1YlxcZCpcXHg1ZCkqKShcXHg1YihcXGQqKVxceDVkKSQvKTtcbiAgICBpZiAobWF0Y2gpIHtcbiAgICAgICAgcmV0dXJuIHtcbiAgICAgICAgICAgIGJhc2U6IG1hdGNoWzFdLFxuICAgICAgICAgICAgaW5kZXg6IChtYXRjaFsyXSArIG1hdGNoWzRdKSxcbiAgICAgICAgICAgIGFycmF5OiB7XG4gICAgICAgICAgICAgICAgYmFzZTogbWF0Y2hbMV0sXG4gICAgICAgICAgICAgICAgcHJlZml4OiAobWF0Y2hbMV0gKyBtYXRjaFsyXSksXG4gICAgICAgICAgICAgICAgY291bnQ6IChtYXRjaFs1XSA/IHBhcnNlSW50KG1hdGNoWzVdKSA6IC0xKSxcbiAgICAgICAgICAgIH1cbiAgICAgICAgfTtcbiAgICB9XG4gICAgcmV0dXJuIHsgYmFzZTogdHlwZSB9O1xufVxuLyoqXG4gKiAgQSAqKlR5cGVkRGF0YUVuY29kZSoqIHByZXBhcmVzIGFuZCBlbmNvZGVzIFtbbGluay1laXAtNzEyXV0gcGF5bG9hZHNcbiAqICBmb3Igc2lnbmVkIHR5cGVkIGRhdGEuXG4gKlxuICogIFRoaXMgaXMgdXNlZnVsIGZvciB0aG9zZSB0aGF0IHdpc2ggdG8gY29tcHV0ZSB2YXJpb3VzIGNvbXBvbmVudHMgb2YgYVxuICogIHR5cGVkIGRhdGEgaGFzaCwgcHJpbWFyeSB0eXBlcywgb3Igc3ViLWNvbXBvbmVudHMsIGJ1dCBnZW5lcmFsbHkgdGhlXG4gKiAgaGlnaGVyIGxldmVsIFtbU2lnbmVyLXNpZ25UeXBlZERhdGFdXSBpcyBtb3JlIHVzZWZ1bC5cbiAqL1xuZXhwb3J0IGNsYXNzIFR5cGVkRGF0YUVuY29kZXIge1xuICAgIC8qKlxuICAgICAqICBUaGUgcHJpbWFyeSB0eXBlIGZvciB0aGUgc3RydWN0dXJlZCBbW3R5cGVzXV0uXG4gICAgICpcbiAgICAgKiAgVGhpcyBpcyBkZXJpdmVkIGF1dG9tYXRpY2FsbHkgZnJvbSB0aGUgW1t0eXBlc11dLCBzaW5jZSBub1xuICAgICAqICByZWN1cnNpb24gaXMgcG9zc2libGUsIG9uY2UgdGhlIERBRyBmb3IgdGhlIHR5cGVzIGlzIGNvbnN0dXJjdGVkXG4gICAgICogIGludGVybmFsbHksIHRoZSBwcmltYXJ5IHR5cGUgbXVzdCBiZSB0aGUgb25seSByZW1haW5pbmcgdHlwZSB3aXRoXG4gICAgICogIG5vIHBhcmVudCBub2Rlcy5cbiAgICAgKi9cbiAgICBwcmltYXJ5VHlwZTtcbiAgICAjdHlwZXM7XG4gICAgLyoqXG4gICAgICogIFRoZSB0eXBlcy5cbiAgICAgKi9cbiAgICBnZXQgdHlwZXMoKSB7XG4gICAgICAgIHJldHVybiBKU09OLnBhcnNlKHRoaXMuI3R5cGVzKTtcbiAgICB9XG4gICAgI2Z1bGxUeXBlcztcbiAgICAjZW5jb2RlckNhY2hlO1xuICAgIC8qKlxuICAgICAqICBDcmVhdGUgYSBuZXcgKipUeXBlZERhdGFFbmNvZGVyKiogZm9yICUldHlwZXMlJS5cbiAgICAgKlxuICAgICAqICBUaGlzIHBlcmZvcm1zIGFsbCBuZWNlc3NhcnkgY2hlY2tpbmcgdGhhdCB0eXBlcyBhcmUgdmFsaWQgYW5kXG4gICAgICogIGRvIG5vdCB2aW9sYXRlIHRoZSBbW2xpbmstZWlwLTcxMl1dIHN0cnVjdHVyYWwgY29uc3RyYWludHMgYXNcbiAgICAgKiAgd2VsbCBhcyBjb21wdXRlcyB0aGUgW1twcmltYXJ5VHlwZV1dLlxuICAgICAqL1xuICAgIGNvbnN0cnVjdG9yKF90eXBlcykge1xuICAgICAgICB0aGlzLiNmdWxsVHlwZXMgPSBuZXcgTWFwKCk7XG4gICAgICAgIHRoaXMuI2VuY29kZXJDYWNoZSA9IG5ldyBNYXAoKTtcbiAgICAgICAgLy8gTGluayBzdHJ1Y3QgdHlwZXMgdG8gdGhlaXIgZGlyZWN0IGNoaWxkIHN0cnVjdHNcbiAgICAgICAgY29uc3QgbGlua3MgPSBuZXcgTWFwKCk7XG4gICAgICAgIC8vIExpbmsgc3RydWN0cyB0byBzdHJ1Y3RzIHdoaWNoIGNvbnRhaW4gdGhlbSBhcyBhIGNoaWxkXG4gICAgICAgIGNvbnN0IHBhcmVudHMgPSBuZXcgTWFwKCk7XG4gICAgICAgIC8vIExpbmsgYWxsIHN1YnR5cGVzIHdpdGhpbiBhIGdpdmVuIHN0cnVjdFxuICAgICAgICBjb25zdCBzdWJ0eXBlcyA9IG5ldyBNYXAoKTtcbiAgICAgICAgY29uc3QgdHlwZXMgPSB7fTtcbiAgICAgICAgT2JqZWN0LmtleXMoX3R5cGVzKS5mb3JFYWNoKCh0eXBlKSA9PiB7XG4gICAgICAgICAgICB0eXBlc1t0eXBlXSA9IF90eXBlc1t0eXBlXS5tYXAoKHsgbmFtZSwgdHlwZSB9KSA9PiB7XG4gICAgICAgICAgICAgICAgLy8gTm9ybWFsaXplIHRoZSBiYXNlIHR5cGUgKHVubGVzcyBuYW1lIGNvbmZsaWN0KVxuICAgICAgICAgICAgICAgIGxldCB7IGJhc2UsIGluZGV4IH0gPSBzcGxpdEFycmF5KHR5cGUpO1xuICAgICAgICAgICAgICAgIGlmIChiYXNlID09PSBcImludFwiICYmICFfdHlwZXNbXCJpbnRcIl0pIHtcbiAgICAgICAgICAgICAgICAgICAgYmFzZSA9IFwiaW50MjU2XCI7XG4gICAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgICAgIGlmIChiYXNlID09PSBcInVpbnRcIiAmJiAhX3R5cGVzW1widWludFwiXSkge1xuICAgICAgICAgICAgICAgICAgICBiYXNlID0gXCJ1aW50MjU2XCI7XG4gICAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgICAgI

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

26774HRoaXMuI2VuY29kZXJDYWNoZS5zZXQodHlwZSwgZW5jb2Rlcik7XG4gICAgICAgIH1cbiAgICAgICAgcmV0dXJuIGVuY29kZXI7XG4gICAgfVxuICAgICNnZXRFbmNvZGVyKHR5cGUpIHtcbiAgICAgICAgLy8gQmFzaWMgZW5jb2RlciB0eXBlIChhZGRyZXNzLCBib29sLCB1aW50MjU2LCBldGMpXG4gICAgICAgIHtcbiAgICAgICAgICAgIGNvbnN0IGVuY29kZXIgPSBnZXRCYXNlRW5jb2Rlcih0eXBlKTtcbiAgICAgICAgICAgIGlmIChlbmNvZGVyKSB7XG4gICAgICAgICAgICAgICAgcmV0dXJuIGVuY29kZXI7XG4gICAgICAgICAgICB9XG4gICAgICAgIH1cbiAgICAgICAgLy8gQXJyYXlcbiAgICAgICAgY29uc3QgYXJyYXkgPSBzcGxpdEFycmF5KHR5cGUpLmFycmF5O1xuICAgICAgICBpZiAoYXJyYXkpIHtcbiAgICAgICAgICAgIGNvbnN0IHN1YnR5cGUgPSBhcnJheS5wcmVmaXg7XG4gICAgICAgICAgICBjb25zdCBzdWJFbmNvZGVyID0gdGhpcy5nZXRFbmNvZGVyKHN1YnR5cGUpO1xuICAgICAgICAgICAgcmV0dXJuICh2YWx1ZSkgPT4ge1xuICAgICAgICAgICAgICAgIGFzc2VydEFyZ3VtZW50KGFycmF5LmNvdW50ID09PSAtMSB8fCBhcnJheS5jb3VudCA9PT0gdmFsdWUubGVuZ3RoLCBgYXJyYXkgbGVuZ3RoIG1pc21hdGNoOyBleHBlY3RlZCBsZW5ndGggJHthcnJheS5jb3VudH1gLCBcInZhbHVlXCIsIHZhbHVlKTtcbiAgICAgICAgICAgICAgICBsZXQgcmVzdWx0ID0gdmFsdWUubWFwKHN1YkVuY29kZXIpO1xuICAgICAgICAgICAgICAgIGlmICh0aGlzLiNmdWxsVHlwZXMuaGFzKHN1YnR5cGUpKSB7XG4gICAgICAgICAgICAgICAgICAgIHJlc3VsdCA9IHJlc3VsdC5tYXAoa2VjY2FrMjU2KTtcbiAgICAgICAgICAgICAgICB9XG4gICAgICAgICAgICAgICAgcmV0dXJuIGtlY2NhazI1Nihjb25jYXQocmVzdWx0KSk7XG4gICAgICAgICAgICB9O1xuICAgICAgICB9XG4gICAgICAgIC8vIFN0cnVjdFxuICAgICAgICBjb25zdCBmaWVsZHMgPSB0aGlzLnR5cGVzW3R5cGVdO1xuICAgICAgICBpZiAoZmllbGRzKSB7XG4gICAgICAgICAgICBjb25zdCBlbmNvZGVkVHlwZSA9IGlkKHRoaXMuI2Z1bGxUeXBlcy5nZXQodHlwZSkpO1xuICAgICAgICAgICAgcmV0dXJuICh2YWx1ZSkgPT4ge1xuICAgICAgICAgICAgICAgIGNvbnN0IHZhbHVlcyA9IGZpZWxkcy5tYXAoKHsgbmFtZSwgdHlwZSB9KSA9PiB7XG4gICAgICAgICAgICAgICAgICAgIGNvbnN0IHJlc3VsdCA9IHRoaXMuZ2V0RW5jb2Rlcih0eXBlKSh2YWx1ZVtuYW1lXSk7XG4gICAgICAgICAgICAgICAgICAgIGlmICh0aGlzLiNmdWxsVHlwZXMuaGFzKHR5cGUpKSB7XG4gICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4ga2VjY2FrMjU2KHJlc3VsdCk7XG4gICAgICAgICAgICAgICAgICAgIH1cbiAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHJlc3VsdDtcbiAgICAgICAgICAgICAgICB9KTtcbiAgICAgICAgICAgICAgICB2YWx1ZXMudW5zaGlmdChlbmNvZGVkVHlwZSk7XG4gICAgICAgICAgICAgICAgcmV0dXJuIGNvbmNhdCh2YWx1ZXMpO1xuICAgICAgICAgICAgfTtcbiAgICAgICAgfVxuICAgICAgICBhc3NlcnRBcmd1bWVudChmYWxzZSwgYHVua25vd24gdHlwZTogJHt0eXBlfWAsIFwidHlwZVwiLCB0eXBlKTtcbiAgICB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiB0aGUgZnVsbCB0eXBlIGZvciAlJW5hbWUlJS5cbiAgICAgKi9cbiAgICBlbmNvZGVUeXBlKG5hbWUpIHtcbiAgICAgICAgY29uc3QgcmVzdWx0ID0gdGhpcy4jZnVsbFR5cGVzLmdldChuYW1lKTtcbiAgICAgICAgYXNzZXJ0QXJndW1lbnQocmVzdWx0LCBgdW5rbm93biB0eXBlOiAke0pTT04uc3RyaW5naWZ5KG5hbWUpfWAsIFwibmFtZVwiLCBuYW1lKTtcbiAgICAgICAgcmV0dXJuIHJlc3VsdDtcbiAgICB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiB0aGUgZW5jb2RlZCAlJXZhbHVlJSUgZm9yIHRoZSAlJXR5cGUlJS5cbiAgICAgKi9cbiAgICBlbmNvZGVEYXRhKHR5cGUsIHZhbHVlKSB7XG4gICAgICAgIHJldHVybiB0aGlzLmdldEVuY29kZXIodHlwZSkodmFsdWUpO1xuICAgIH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJucyB0aGUgaGFzaCBvZiAlJXZhbHVlJSUgZm9yIHRoZSB0eXBlIG9mICUlbmFtZSUlLlxuICAgICAqL1xuICAgIGhhc2hTdHJ1Y3QobmFtZSwgdmFsdWUpIHtcbiAgICAgICAgcmV0dXJuIGtlY2NhazI1Nih0aGlzLmVuY29kZURhdGEobmFtZSwgdmFsdWUpKTtcbiAgICB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiB0aGUgZnVsbGVkIGVuY29kZWQgJSV2YWx1ZSUlIGZvciB0aGUgW1t0eXBlc11dLlxuICAgICAqL1xuICAgIGVuY29kZSh2YWx1ZSkge1xuICAgICAgICByZXR1cm4gdGhpcy5lbmNvZGVEYXRhKHRoaXMucHJpbWFyeVR5cGUsIHZhbHVlKTtcbiAgICB9XG4gICAgLyoqXG4gICAgICogIFJldHVybiB0aGUgaGFzaCBvZiB0aGUgZnVsbHkgZW5jb2RlZCAlJXZhbHVlJSUgZm9yIHRoZSBbW3R5cGVzXV0uXG4gICAgICovXG4gICAgaGFzaCh2YWx1ZSkge1xuICAgICAgICByZXR1cm4gdGhpcy5oYXNoU3RydWN0KHRoaXMucHJpbWFyeVR5cGUsIHZhbHVlKTtcbiAgICB9XG4gICAgLyoqXG4gICAgICogIEBfaWdub3JlOlxuICAgICAqL1xuICAgIF92aXNpdCh0eXBlLCB2YWx1ZSwgY2FsbGJhY2spIHtcbiAgICAgICAgLy8gQmFzaWMgZW5jb2RlciB0eXBlIChhZGRyZXNzLCBib29sLCB1aW50MjU2LCBldGMpXG4gICAgICAgIHtcbiAgICAgICAgICAgIGNvbnN0IGVuY29kZXIgPSBnZXRCYXNlRW5jb2Rlcih0eXBlKTtcbiAgICAgICAgICAgIGlmIChlbmNvZGVyKSB7XG4gICAgICAgICAgICAgICAgcmV0dXJuIGNhbGxiYWNrKHR5cGUsIHZhbHVlKTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgfVxuICAgICAgICAvLyBBcnJheVxuICAgICAgICBjb25zdCBhcnJheSA9IHNwbGl0QXJyYXkodHlwZSkuYXJyYXk7XG4gICAgICAgIGlmIChhcnJheSkge1xuICAgICAgICAgICAgYXNzZXJ0QXJndW1lbnQoYXJyYXkuY291bnQgPT09IC0xIHx8IGFycmF5LmNvdW50ID09PSB2YWx1ZS5sZW5ndGgsIGBhcnJheSBsZW5ndGggbWlzbWF0Y2g7IGV4cGVjdGVkIGxlbmd0aCAke2FycmF5LmNvdW50fWAsIFwidmFsdWVcIiwgdmFsdWUpO1xuICAgICAgICAgICAgcmV0dXJuIHZhbHVlLm1hcCgodikgPT4gdGhpcy5fdmlzaXQoYXJyYXkucHJlZml4LCB2LCBjYWxsYmFjaykpO1xuICAgICAgICB9XG4gICAgICAgIC8vIFN0cnVjdFxuICAgICAgICBjb25zdCBmaWVsZHMgPSB0aGlzLnR5cGVzW3R5cGVdO1xuICAgICAgICBpZiAoZmllbGRzKSB7XG4gICAgICAgICAgICByZXR1cm4gZmllbGRzLnJlZHVjZSgoYWNjdW0sIHsgbmFtZSwgdHlwZSB9KSA9PiB7XG4gICAgICAgICAgICAgICAgYWNjdW1bbmFtZV0gPSB0aGlzLl92aXNpdCh0eXBlLCB2YWx1ZVtuYW1lXSwgY2FsbGJhY2spO1xuICAgICAgICAgICAgICAgI

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

26774IjogXCJPUEVOX0JSQUNLRVRcIiwgXCJdXCI6IFwiQ0xPU0VfQlJBQ0tFVFwiLFxuICAgIFwiLFwiOiBcIkNPTU1BXCIsIFwiQFwiOiBcIkFUXCJcbn07XG4vLyBQYXJzZXIgcmVnZXhlcyB0byBjb25zdW1lIHRoZSBuZXh0IHRva2VuXG5jb25zdCByZWdleFdoaXRlc3BhY2VQcmVmaXggPSBuZXcgUmVnRXhwKFwiXihcXFxccyopXCIpO1xuY29uc3QgcmVnZXhOdW1iZXJQcmVmaXggPSBuZXcgUmVnRXhwKFwiXihbMC05XSspXCIpO1xuY29uc3QgcmVnZXhJZFByZWZpeCA9IG5ldyBSZWdFeHAoXCJeKFthLXpBLVokX11bYS16QS1aMC05JF9dKilcIik7XG4vLyBQYXJzZXIgcmVnZXhzIHRvIGNoZWNrIHZhbGlkaXR5XG5jb25zdCByZWdleElkID0gbmV3IFJlZ0V4cChcIl4oW2EtekEtWiRfXVthLXpBLVowLTkkX10qKSRcIik7XG5jb25zdCByZWdleFR5cGUgPSBuZXcgUmVnRXhwKFwiXihhZGRyZXNzfGJvb2x8Ynl0ZXMoWzAtOV0qKXxzdHJpbmd8dT9pbnQoWzAtOV0qKSkkXCIpO1xuY2xhc3MgVG9rZW5TdHJpbmcge1xuICAgICNvZmZzZXQ7XG4gICAgI3Rva2VucztcbiAgICBnZXQgb2Zmc2V0KCkgeyByZXR1cm4gdGhpcy4jb2Zmc2V0OyB9XG4gICAgZ2V0IGxlbmd0aCgpIHsgcmV0dXJuIHRoaXMuI3Rva2Vucy5sZW5ndGggLSB0aGlzLiNvZmZzZXQ7IH1cbiAgICBjb25zdHJ1Y3Rvcih0b2tlbnMpIHtcbiAgICAgICAgdGhpcy4jb2Zmc2V0ID0gMDtcbiAgICAgICAgdGhpcy4jdG9rZW5zID0gdG9rZW5zLnNsaWNlKCk7XG4gICAgfVxuICAgIGNsb25lKCkgeyByZXR1cm4gbmV3IFRva2VuU3RyaW5nKHRoaXMuI3Rva2Vucyk7IH1cbiAgICByZXNldCgpIHsgdGhpcy4jb2Zmc2V0ID0gMDsgfVxuICAgICNzdWJUb2tlblN0cmluZyhmcm9tID0gMCwgdG8gPSAwKSB7XG4gICAgICAgIHJldHVybiBuZXcgVG9rZW5TdHJpbmcodGhpcy4jdG9rZW5zLnNsaWNlKGZyb20sIHRvKS5tYXAoKHQpID0+IHtcbiAgICAgICAgICAgIHJldHVybiBPYmplY3QuZnJlZXplKE9iamVjdC5hc3NpZ24oe30sIHQsIHtcbiAgICAgICAgICAgICAgICBtYXRjaDogKHQubWF0Y2ggLSBmcm9tKSxcbiAgICAgICAgICAgICAgICBsaW5rQmFjazogKHQubGlua0JhY2sgLSBmcm9tKSxcbiAgICAgICAgICAgICAgICBsaW5rTmV4dDogKHQubGlua05leHQgLSBmcm9tKSxcbiAgICAgICAgICAgIH0pKTtcbiAgICAgICAgfSkpO1xuICAgIH1cbiAgICAvLyBQb3BzIGFuZCByZXR1cm5zIHRoZSB2YWx1ZSBvZiB0aGUgbmV4dCB0b2tlbiwgaWYgaXQgaXMgYSBrZXl3b3JkIGluIGFsbG93ZWQ7IHRocm93cyBpZiBvdXQgb2YgdG9rZW5zXG4gICAgcG9wS2V5d29yZChhbGxvd2VkKSB7XG4gICAgICAgIGNvbnN0IHRvcCA9IHRoaXMucGVlaygpO1xuICAgICAgICBpZiAodG9wLnR5cGUgIT09IFwiS0VZV09SRFwiIHx8ICFhbGxvd2VkLmhhcyh0b3AudGV4dCkpIHtcbiAgICAgICAgICAgIHRocm93IG5ldyBFcnJvcihgZXhwZWN0ZWQga2V5d29yZCAke3RvcC50ZXh0fWApO1xuICAgICAgICB9XG4gICAgICAgIHJldHVybiB0aGlzLnBvcCgpLnRleHQ7XG4gICAgfVxuICAgIC8vIFBvcHMgYW5kIHJldHVybnMgdGhlIHZhbHVlIG9mIHRoZSBuZXh0IHRva2VuIGlmIGl0IGlzIGB0eXBlYDsgdGhyb3dzIGlmIG91dCBvZiB0b2tlbnNcbiAgICBwb3BUeXBlKHR5cGUpIHtcbiAgICAgICAgaWYgKHRoaXMucGVlaygpLnR5cGUgIT09IHR5cGUpIHtcbiAgICAgICAgICAgIGNvbnN0IHRvcCA9IHRoaXMucGVlaygpO1xuICAgICAgICAgICAgdGhyb3cgbmV3IEVycm9yKGBleHBlY3RlZCAke3R5cGV9OyBnb3QgJHt0b3AudHlwZX0gJHtKU09OLnN0cmluZ2lmeSh0b3AudGV4dCl9YCk7XG4gICAgICAgIH1cbiAgICAgICAgcmV0dXJuIHRoaXMucG9wKCkudGV4dDtcbiAgICB9XG4gICAgLy8gUG9wcyBhbmQgcmV0dXJucyBhIFwiKFwiIFRPS0VOUyBcIilcIlxuICAgIHBvcFBhcmVuKCkge1xuICAgICAgICBjb25zdCB0b3AgPSB0aGlzLnBlZWsoKTtcbiAgICAgICAgaWYgKHRvcC50eXBlICE9PSBcIk9QRU5fUEFSRU5cIikge1xuICAgICAgICAgICAgdGhyb3cgbmV3IEVycm9yKFwiYmFkIHN0YXJ0XCIpO1xuICAgICAgICB9XG4gICAgICAgIGNvbnN0IHJlc3VsdCA9IHRoaXMuI3N1YlRva2VuU3RyaW5nKHRoaXMuI29mZnNldCArIDEsIHRvcC5tYXRjaCArIDEpO1xuICAgICAgICB0aGlzLiNvZmZzZXQgPSB0b3AubWF0Y2ggKyAxO1xuICAgICAgICByZXR1cm4gcmVzdWx0O1xuICAgIH1cbiAgICAvLyBQb3BzIGFuZCByZXR1cm5zIHRoZSBpdGVtcyB3aXRoaW4gXCIoXCIgSVRFTTEgXCIsXCIgSVRFTTIgXCIsXCIgLi4uIFwiKVwiXG4gICAgcG9wUGFyYW1zKCkge1xuICAgICAgICBjb25zdCB0b3AgPSB0aGlzLnBlZWsoKTtcbiAgICAgICAgaWYgKHRvcC50eXBlICE9PSBcIk9QRU5fUEFSRU5cIikge1xuICAgICAgICAgICAgdGhyb3cgbmV3IEVycm9yKFwiYmFkIHN0YXJ0XCIpO1xuICAgICAgICB9XG4gICAgICAgIGNvbnN0IHJlc3VsdCA9IFtdO1xuICAgICAgICB3aGlsZSAodGhpcy4jb2Zmc2V0IDwgdG9wLm1hdGNoIC0gMSkge1xuICAgICAgICAgICAgY29uc3QgbGluayA9IHRoaXMucGVlaygpLmxpbmtOZXh0O1xuICAgICAgICAgICAgcmVzdWx0LnB1c2godGhpcy4jc3ViVG9rZW5TdHJpbmcodGhpcy4jb2Zmc2V0ICsgMSwgbGluaykpO1xuICAgICAgICAgICAgdGhpcy4jb2Zmc2V0ID0gbGluaztcbiAgICAgICAgfVxuICAgICAgICB0aGlzLiNvZmZzZXQgPSB0b3AubWF0Y2ggKyAxO1xuICAgICAgICByZXR1cm4gcmVzdWx0O1xuICAgIH1cbiAgICAvLyBSZXR1cm5zIHRoZSB0b3AgVG9rZW4sIHRocm93aW5nIGlmIG91dCBvZiB0b2tlbnNcbiAgICBwZWVrKCkge1xuICAgICAgICBpZiAodGhpcy4jb2Zmc2V0ID49IHRoaXMuI3Rva2Vucy5sZW5ndGgpIHtcbiAgICAgICAgICAgIHRocm93IG5ldyBFcnJvcihcIm91dC1vZi1ib3VuZHNcIik7XG4gICAgICAgIH1cbiAgICAgICAgcmV0dXJuIHRoaXMuI3Rva2Vuc1t0aGlzLiNvZmZzZXRdO1xuICAgIH1cbiAgICAvLyBSZXR1cm5zIHRoZSBuZXh0IHZhbHVlLCBpZiBpdCBpcyBhIGtleXdvcmQgaW4gYGFsbG93ZWRgXG4gICAgcGVla0tleXdvcmQoYWxsb3dlZCkge1xuICAgICAgICBjb25zdCB0b3AgPSB0aGlzLnBlZWtUeXBlKFwiS0VZV09SRFwiKTtcbiAgICAgICAgcmV0dXJuICh0b3AgIT0gbnVsbCAmJiBhbGxvd2VkLmhhcyh0b3ApKSA/IHRvcCA6IG51bGw7XG4gICAgfVxuICAgIC8vIFJldHVybnMgdGhlIHZhbHVlIG9mIHRoZSBuZXh0IHRva2VuIGlmIGl0IGlzIGB0eXBlYFxuICAgIHBlZWtUeXBlKHR5cGUpIHtcbiAgICAgICAgaWYgKHRoaXMubGVuZ3RoID09PSAwKSB7XG4gICAgICAgICAgICByZXR1cm4gbnVsbDtcbiAgICAgICAgfVxuICAgICAgICBjb25zdCB0b3AgPSB0aGlzLnBlZWsoKTtcbiAgICAgICAgcmV0dXJuICh0b3AudHlwZSA9PT0gdHlwZSkgPyB0b3AudGV4dCA6IG51bGw7XG4gICAgfVxuICAgIC8vIFJldHVybnMgdGhlIG5leHQgdG9rZW47IHRocm93cyBpZiBvdXQgb2YgdG9rZW5zXG4gICAgcG9wKCkge1xuICAgICAgICBjb25zdCByZXN1bHQgPSB0aGlzLnBlZWsoKTtcbiAgICAgICAgdGhpcy4jb2Zmc2V0Kys7XG4gICAgICAgI

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

26774ZWN0IHRoZSBmcmFnbWVudC5cbiAgICAgKi9cbiAgICBkZWNvZGVGdW5jdGlvbkRhdGEoZnJhZ21lbnQsIGRhdGEpIHtcbiAgICAgICAgaWYgKHR5cGVvZiAoZnJhZ21lbnQpID09PSBcInN0cmluZ1wiKSB7XG4gICAgICAgICAgICBjb25zdCBmID0gdGhpcy5nZXRGdW5jdGlvbihmcmFnbWVudCk7XG4gICAgICAgICAgICBhc3NlcnRBcmd1bWVudChmLCBcInVua25vd24gZnVuY3Rpb25cIiwgXCJmcmFnbWVudFwiLCBmcmFnbWVudCk7XG4gICAgICAgICAgICBmcmFnbWVudCA9IGY7XG4gICAgICAgIH1cbiAgICAgICAgYXNzZXJ0QXJndW1lbnQoZGF0YVNsaWNlKGRhdGEsIDAsIDQpID09PSBmcmFnbWVudC5zZWxlY3RvciwgYGRhdGEgc2lnbmF0dXJlIGRvZXMgbm90IG1hdGNoIGZ1bmN0aW9uICR7ZnJhZ21lbnQubmFtZX0uYCwgXCJkYXRhXCIsIGRhdGEpO1xuICAgICAgICByZXR1cm4gdGhpcy5fZGVjb2RlUGFyYW1zKGZyYWdtZW50LmlucHV0cywgZGF0YVNsaWNlKGRhdGEsIDQpKTtcbiAgICB9XG4gICAgLyoqXG4gICAgICogIEVuY29kZXMgdGhlIGBgdHguZGF0YWBgIGZvciBhIHRyYW5zYWN0aW9uIHRoYXQgY2FsbHMgdGhlIGZ1bmN0aW9uXG4gICAgICogIHNwZWNpZmllZCAoc2VlIFtbZ2V0RnVuY3Rpb25dXSBmb3IgdmFsaWQgdmFsdWVzIGZvciAlJWZyYWdtZW50JSUpIHdpdGhcbiAgICAgKiAgdGhlICUldmFsdWVzJSUuXG4gICAgICovXG4gICAgZW5jb2RlRnVuY3Rpb25EYXRhKGZyYWdtZW50LCB2YWx1ZXMpIHtcbiAgICAgICAgaWYgKHR5cGVvZiAoZnJhZ21lbnQpID09PSBcInN0cmluZ1wiKSB7XG4gICAgICAgICAgICBjb25zdCBmID0gdGhpcy5nZXRGdW5jdGlvbihmcmFnbWVudCk7XG4gICAgICAgICAgICBhc3NlcnRBcmd1bWVudChmLCBcInVua25vd24gZnVuY3Rpb25cIiwgXCJmcmFnbWVudFwiLCBmcmFnbWVudCk7XG4gICAgICAgICAgICBmcmFnbWVudCA9IGY7XG4gICAgICAgIH1cbiAgICAgICAgcmV0dXJuIGNvbmNhdChbXG4gICAgICAgICAgICBmcmFnbWVudC5zZWxlY3RvcixcbiAgICAgICAgICAgIHRoaXMuX2VuY29kZVBhcmFtcyhmcmFnbWVudC5pbnB1dHMsIHZhbHVlcyB8fCBbXSlcbiAgICAgICAgXSk7XG4gICAgfVxuICAgIC8qKlxuICAgICAqICBEZWNvZGVzIHRoZSByZXN1bHQgJSVkYXRhJSUgKGUuZy4gZnJvbSBhbiBgYGV0aF9jYWxsYGApIGZvciB0aGVcbiAgICAgKiAgc3BlY2lmaWVkIGZ1bmN0aW9uIChzZWUgW1tnZXRGdW5jdGlvbl1dIGZvciB2YWxpZCB2YWx1ZXMgZm9yXG4gICAgICogICUla2V5JSUpLlxuICAgICAqXG4gICAgICogIE1vc3QgZGV2ZWxvcGVycyBzaG91bGQgcHJlZmVyIHRoZSBbW3BhcnNlQ2FsbFJlc3VsdF1dIG1ldGhvZCBpbnN0ZWFkLFxuICAgICAqICB3aGljaCB3aWxsIGF1dG9tYXRpY2FsbHkgZGV0ZWN0IGEgYGBDQUxMX0VYQ0VQVElPTmBgIGFuZCB0aHJvdyB0aGVcbiAgICAgKiAgY29ycmVzcG9uZGluZyBlcnJvci5cbiAgICAgKi9cbiAgICBkZWNvZGVGdW5jdGlvblJlc3VsdChmcmFnbWVudCwgZGF0YSkge1xuICAgICAgICBpZiAodHlwZW9mIChmcmFnbWVudCkgPT09IFwic3RyaW5nXCIpIHtcbiAgICAgICAgICAgIGNvbnN0IGYgPSB0aGlzLmdldEZ1bmN0aW9uKGZyYWdtZW50KTtcbiAgICAgICAgICAgIGFzc2VydEFyZ3VtZW50KGYsIFwidW5rbm93biBmdW5jdGlvblwiLCBcImZyYWdtZW50XCIsIGZyYWdtZW50KTtcbiAgICAgICAgICAgIGZyYWdtZW50ID0gZjtcbiAgICAgICAgfVxuICAgICAgICBsZXQgbWVzc2FnZSA9IFwiaW52YWxpZCBsZW5ndGggZm9yIHJlc3VsdCBkYXRhXCI7XG4gICAgICAgIGNvbnN0IGJ5dGVzID0gZ2V0Qnl0ZXNDb3B5KGRhdGEpO1xuICAgICAgICBpZiAoKGJ5dGVzLmxlbmd0aCAlIDMyKSA9PT0gMCkge1xuICAgICAgICAgICAgdHJ5IHtcbiAgICAgICAgICAgICAgICByZXR1cm4gdGhpcy4jYWJpQ29kZXIuZGVjb2RlKGZyYWdtZW50Lm91dHB1dHMsIGJ5dGVzKTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgICAgIGNhdGNoIChlcnJvcikge1xuICAgICAgICAgICAgICAgIG1lc3NhZ2UgPSBcImNvdWxkIG5vdCBkZWNvZGUgcmVzdWx0IGRhdGFcIjtcbiAgICAgICAgICAgIH1cbiAgICAgICAgfVxuICAgICAgICAvLyBDYWxsIHJldHVybmVkIGRhdGEgd2l0aCBubyBlcnJvciwgYnV0IHRoZSBkYXRhIGlzIGp1bmtcbiAgICAgICAgYXNzZXJ0KGZhbHNlLCBtZXNzYWdlLCBcIkJBRF9EQVRBXCIsIHtcbiAgICAgICAgICAgIHZhbHVlOiBoZXhsaWZ5KGJ5dGVzKSxcbiAgICAgICAgICAgIGluZm86IHsgbWV0aG9kOiBmcmFnbWVudC5uYW1lLCBzaWduYXR1cmU6IGZyYWdtZW50LmZvcm1hdCgpIH1cbiAgICAgICAgfSk7XG4gICAgfVxuICAgIG1ha2VFcnJvcihfZGF0YSwgdHgpIHtcbiAgICAgICAgY29uc3QgZGF0YSA9IGdldEJ5dGVzKF9kYXRhLCBcImRhdGFcIik7XG4gICAgICAgIGNvbnN0IGVycm9yID0gQWJpQ29kZXIuZ2V0QnVpbHRpbkNhbGxFeGNlcHRpb24oXCJjYWxsXCIsIHR4LCBkYXRhKTtcbiAgICAgICAgLy8gTm90IGEgYnVpbHQtaW4gZXJyb3I7IHRyeSBmaW5kaW5nIGEgY3VzdG9tIGVycm9yXG4gICAgICAgIGNvbnN0IGN1c3RvbVByZWZpeCA9IFwiZXhlY3V0aW9uIHJldmVydGVkICh1bmtub3duIGN1c3RvbSBlcnJvcilcIjtcbiAgICAgICAgaWYgKGVycm9yLm1lc3NhZ2Uuc3RhcnRzV2l0aChjdXN0b21QcmVmaXgpKSB7XG4gICAgICAgICAgICBjb25zdCBzZWxlY3RvciA9IGhleGxpZnkoZGF0YS5zbGljZSgwLCA0KSk7XG4gICAgICAgICAgICBjb25zdCBlZiA9IHRoaXMuZ2V0RXJyb3Ioc2VsZWN0b3IpO1xuICAgICAgICAgICAgaWYgKGVmKSB7XG4gICAgICAgICAgICAgICAgdHJ5IHtcbiAgICAgICAgICAgICAgICAgICAgY29uc3QgYXJncyA9IHRoaXMuI2FiaUNvZGVyLmRlY29kZShlZi5pbnB1dHMsIGRhdGEuc2xpY2UoNCkpO1xuICAgICAgICAgICAgICAgICAgICBlcnJvci5yZXZlcnQgPSB7XG4gICAgICAgICAgICAgICAgICAgICAgICBuYW1lOiBlZi5uYW1lLCBzaWduYXR1cmU6IGVmLmZvcm1hdCgpLCBhcmdzXG4gICAgICAgICAgICAgICAgICAgIH07XG4gICAgICAgICAgICAgICAgICAgIGVycm9yLnJlY

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

26774hdCBhbGwgdHJhbnNhY3Rpb25zIGluIHRoaXMgYmxvY2sgd2VyZVxuICAgICAqICBjaGFyZ2VkLlxuICAgICAqXG4gICAgICogIFRoaXMgYWRqdXN0cyBhZnRlciBlYWNoIGJsb2NrLCBkZXBlbmRpbmcgb24gaG93IGNvbmdlc3RlZCB0aGUgbmV0d29ya1xuICAgICAqICBpcy5cbiAgICAgKi9cbiAgICBiYXNlRmVlUGVyR2FzO1xuICAgICN0cmFuc2FjdGlvbnM7XG4gICAgLyoqXG4gICAgICogIENyZWF0ZSBhIG5ldyAqKkJsb2NrKiogb2JqZWN0LlxuICAgICAqXG4gICAgICogIFRoaXMgc2hvdWxkIGdlbmVyYWxseSBub3QgYmUgbmVjZXNzYXJ5IGFzIHRoZSB1bmxlc3MgaW1wbGVtZW50aW5nIGFcbiAgICAgKiAgbG93LWxldmVsIGxpYnJhcnkuXG4gICAgICovXG4gICAgY29uc3RydWN0b3IoYmxvY2ssIHByb3ZpZGVyKSB7XG4gICAgICAgIHRoaXMuI3RyYW5zYWN0aW9ucyA9IGJsb2NrLnRyYW5zYWN0aW9ucy5tYXAoKHR4KSA9PiB7XG4gICAgICAgICAgICBpZiAodHlwZW9mICh0eCkgIT09IFwic3RyaW5nXCIpIHtcbiAgICAgICAgICAgICAgICByZXR1cm4gbmV3IFRyYW5zYWN0aW9uUmVzcG9uc2UodHgsIHByb3ZpZGVyKTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgICAgIHJldHVybiB0eDtcbiAgICAgICAgfSk7XG4gICAgICAgIGRlZmluZVByb3BlcnRpZXModGhpcywge1xuICAgICAgICAgICAgcHJvdmlkZXIsXG4gICAgICAgICAgICBoYXNoOiBnZXRWYWx1ZShibG9jay5oYXNoKSxcbiAgICAgICAgICAgIG51bWJlcjogYmxvY2subnVtYmVyLFxuICAgICAgICAgICAgdGltZXN0YW1wOiBibG9jay50aW1lc3RhbXAsXG4gICAgICAgICAgICBwYXJlbnRIYXNoOiBibG9jay5wYXJlbnRIYXNoLFxuICAgICAgICAgICAgcGFyZW50QmVhY29uQmxvY2tSb290OiBibG9jay5wYXJlbnRCZWFjb25CbG9ja1Jvb3QsXG4gICAgICAgICAgICBub25jZTogYmxvY2subm9uY2UsXG4gICAgICAgICAgICBkaWZmaWN1bHR5OiBibG9jay5kaWZmaWN1bHR5LFxuICAgICAgICAgICAgZ2FzTGltaXQ6IGJsb2NrLmdhc0xpbWl0LFxuICAgICAgICAgICAgZ2FzVXNlZDogYmxvY2suZ2FzVXNlZCxcbiAgICAgICAgICAgIGJsb2JHYXNVc2VkOiBibG9jay5ibG9iR2FzVXNlZCxcbiAgICAgICAgICAgIGV4Y2Vzc0Jsb2JHYXM6IGJsb2NrLmV4Y2Vzc0Jsb2JHYXMsXG4gICAgICAgICAgICBtaW5lcjogYmxvY2subWluZXIsXG4gICAgICAgICAgICBwcmV2UmFuZGFvOiBnZXRWYWx1ZShibG9jay5wcmV2UmFuZGFvKSxcbiAgICAgICAgICAgIGV4dHJhRGF0YTogYmxvY2suZXh0cmFEYXRhLFxuICAgICAgICAgICAgYmFzZUZlZVBlckdhczogZ2V0VmFsdWUoYmxvY2suYmFzZUZlZVBlckdhcyksXG4gICAgICAgICAgICBzdGF0ZVJvb3Q6IGJsb2NrLnN0YXRlUm9vdCxcbiAgICAgICAgICAgIHJlY2VpcHRzUm9vdDogYmxvY2sucmVjZWlwdHNSb290LFxuICAgICAgICAgICAgdHJhbnNhY3Rpb25zUm9vdDogYmxvY2sudHJhbnNhY3Rpb25zUm9vdCxcbiAgICAgICAgfSk7XG4gICAgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm5zIHRoZSBsaXN0IG9mIHRyYW5zYWN0aW9uIGhhc2hlcywgaW4gdGhlIG9yZGVyXG4gICAgICogIHRoZXkgd2VyZSBleGVjdXRlZCB3aXRoaW4gdGhlIGJsb2NrLlxuICAgICAqL1xuICAgIGdldCB0cmFuc2FjdGlvbnMoKSB7XG4gICAgICAgIHJldHVybiB0aGlzLiN0cmFuc2FjdGlvbnMubWFwKCh0eCkgPT4ge1xuICAgICAgICAgICAgaWYgKHR5cGVvZiAodHgpID09PSBcInN0cmluZ1wiKSB7XG4gICAgICAgICAgICAgICAgcmV0dXJuIHR4O1xuICAgICAgICAgICAgfVxuICAgICAgICAgICAgcmV0dXJuIHR4Lmhhc2g7XG4gICAgICAgIH0pO1xuICAgIH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJucyB0aGUgY29tcGxldGUgdHJhbnNhY3Rpb25zLCBpbiB0aGUgb3JkZXIgdGhleVxuICAgICAqICB3ZXJlIGV4ZWN1dGVkIHdpdGhpbiB0aGUgYmxvY2suXG4gICAgICpcbiAgICAgKiAgVGhpcyBpcyBvbmx5IGF2YWlsYWJsZSBmb3IgYmxvY2tzIHdoaWNoIHByZWZldGNoZWRcbiAgICAgKiAgdHJhbnNhY3Rpb25zLCBieSBwYXNzaW5nIGBgdHJ1ZWBgIHRvICUlcHJlZmV0Y2hUeHMlJVxuICAgICAqICBpbnRvIFtbUHJvdmlkZXItZ2V0QmxvY2tdXS5cbiAgICAgKi9cbiAgICBnZXQgcHJlZmV0Y2hlZFRyYW5zYWN0aW9ucygpIHtcbiAgICAgICAgY29uc3QgdHhzID0gdGhpcy4jdHJhbnNhY3Rpb25zLnNsaWNlKCk7XG4gICAgICAgIC8vIERvZXNuJ3QgbWF0dGVyLi4uXG4gICAgICAgIGlmICh0eHMubGVuZ3RoID09PSAwKSB7XG4gICAgICAgICAgICByZXR1cm4gW107XG4gICAgICAgIH1cbiAgICAgICAgLy8gTWFrZSBzdXJlIHdlIHByZWZldGNoZWQgdGhlIHRyYW5zYWN0aW9uc1xuICAgICAgICBhc3NlcnQodHlwZW9mICh0eHNbMF0pID09PSBcIm9iamVjdFwiLCBcInRyYW5zYWN0aW9ucyB3ZXJlIG5vdCBwcmVmZXRjaGVkIHdpdGggYmxvY2sgcmVxdWVzdFwiLCBcIlVOU1VQUE9SVEVEX09QRVJBVElPTlwiLCB7XG4gICAgICAgICAgICBvcGVyYXRpb246IFwidHJhbnNhY3Rpb25SZXNwb25zZXMoKVwiXG4gICAgICAgIH0pO1xuICAgICAgICByZXR1cm4gdHhzO1xuICAgIH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJucyBhIEpTT04tZnJpZW5kbHkgdmFsdWUuXG4gICAgICovXG4gICAgdG9KU09OKCkge1xuICAgICAgICBjb25zdCB7IGJhc2VGZWVQZXJHYXMsIGRpZmZpY3VsdHksIGV4dHJhRGF0YSwgZ2FzTGltaXQsIGdhc1VzZWQsIGhhc2gsIG1pbmVyLCBwcmV2UmFuZGFvLCBub25jZSwgbnVtYmVyLCBwYXJlbnRIYXNoLCBwYXJlbnRCZWFjb25CbG9ja1Jvb3QsIHN0YXRlUm9vdCwgcmVjZWlwdHNSb290LCB0cmFuc2FjdGlvbnNSb290LCB0aW1lc3RhbXAsIHRyYW5zYWN0aW9ucyB9ID0gdGhpcztcbiAgICAgICAgcmV0dXJuIHtcbiAgICAgICAgICAgIF90eXBlOiBcIkJsb2NrXCIsXG4gICAgICAgICAgICBiYXNlRmVlUGVyR2FzOiB0b0pzb24oYmFzZUZlZVBlckdhcyksXG4gICAgICAgICAgICBkaWZmaWN1bHR5OiB0b0pzb24oZGlmZmljdWx0eSksXG4gICAgICAgICAgICBleHRyYURhdGEsXG4gICAgICAgICAgICBnYXNMaW1pdDogdG9Kc29uKGdhc0xpbWl0KSxcbiAgICAgICAgICAgIGdhc1VzZWQ6IHRvSnNvbihnYXNVc2VkKSxcbiAgICAgICAgICAgIGJsb2JHYXNVc2VkOiB0b0pzb24odGhpcy5ibG9iR2FzVXNlZCksXG4gICAgICAgICAgICBleGNlc3NCbG9iR2FzOiB0b0pzb24odGhpcy5leGNlc3NCbG9iR2FzKSxcbiAgICAgICAgICAgIGhhc2gsIG1pbmVyLCBwcmV2UmFuZGFvLCBub25jZSwgbnVtYmVyLCBwYXJlbnRIYXNoLCB0aW1lc3RhbXAsXG4gICAgICAgICAgICBwYXJlbnRCZWFjb25CbG9ja1Jvb3QsIHN0YXRlUm9vdCwgcmVjZWlwdHNSb290LCB0cmFuc2FjdGlvbnNSb290LFxuICAgICAgICAgICAgdHJhbnNhY3Rpb25zLFxuICAgICAgICB9O1xuICAgIH1cbiAgICBbU3ltYm9sLml0ZXJhdG9yXSgpIHtcbiAgICAgICAgbGV0IGluZGV4ID0gMDtcbiAgICAgICAgY29uc3QgdHhzID0gdGhpcy50cmFuc2FjdGlvbnM7XG4gICAgICAgI

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

26774ID09PSBcIjB4XCIpO1xuICAgICAgICBpZiAoaWZhY2UuZmFsbGJhY2sgJiYgIWlmYWNlLmZhbGxiYWNrLnBheWFibGUgJiYgaWZhY2UucmVjZWl2ZSAmJiAhbm9EYXRhICYmICFub1ZhbHVlKSB7XG4gICAgICAgICAgICBhc3NlcnRBcmd1bWVudChmYWxzZSwgXCJjYW5ub3Qgc2VuZCBkYXRhIHRvIHJlY2VpdmUgb3Igc2VuZCB2YWx1ZSB0byBub24tcGF5YWJsZSBmYWxsYmFja1wiLCBcIm92ZXJyaWRlc1wiLCBvdmVycmlkZXMpO1xuICAgICAgICB9XG4gICAgICAgIGFzc2VydEFyZ3VtZW50KGlmYWNlLmZhbGxiYWNrIHx8IG5vRGF0YSwgXCJjYW5ub3Qgc2VuZCBkYXRhIHRvIHJlY2VpdmUtb25seSBjb250cmFjdFwiLCBcIm92ZXJyaWRlcy5kYXRhXCIsIHR4LmRhdGEpO1xuICAgICAgICAvLyBPbmx5IGFsbG93IHBheWFibGUgY29udHJhY3RzIHRvIHNldCBub24temVybyB2YWx1ZVxuICAgICAgICBjb25zdCBwYXlhYmxlID0gaWZhY2UucmVjZWl2ZSB8fCAoaWZhY2UuZmFsbGJhY2sgJiYgaWZhY2UuZmFsbGJhY2sucGF5YWJsZSk7XG4gICAgICAgIGFzc2VydEFyZ3VtZW50KHBheWFibGUgfHwgbm9WYWx1ZSwgXCJjYW5ub3Qgc2VuZCB2YWx1ZSB0byBub24tcGF5YWJsZSBmYWxsYmFja1wiLCBcIm92ZXJyaWRlcy52YWx1ZVwiLCB0eC52YWx1ZSk7XG4gICAgICAgIC8vIE9ubHkgYWxsb3cgZmFsbGJhY2sgY29udHJhY3RzIHRvIHNldCBub24tZW1wdHkgZGF0YVxuICAgICAgICBhc3NlcnRBcmd1bWVudChpZmFjZS5mYWxsYmFjayB8fCBub0RhdGEsIFwiY2Fubm90IHNlbmQgZGF0YSB0byByZWNlaXZlLW9ubHkgY29udHJhY3RcIiwgXCJvdmVycmlkZXMuZGF0YVwiLCB0eC5kYXRhKTtcbiAgICAgICAgcmV0dXJuIHR4O1xuICAgIH07XG4gICAgY29uc3Qgc3RhdGljQ2FsbCA9IGFzeW5jIGZ1bmN0aW9uIChvdmVycmlkZXMpIHtcbiAgICAgICAgY29uc3QgcnVubmVyID0gZ2V0UnVubmVyKGNvbnRyYWN0LnJ1bm5lciwgXCJjYWxsXCIpO1xuICAgICAgICBhc3NlcnQoY2FuQ2FsbChydW5uZXIpLCBcImNvbnRyYWN0IHJ1bm5lciBkb2VzIG5vdCBzdXBwb3J0IGNhbGxpbmdcIiwgXCJVTlNVUFBPUlRFRF9PUEVSQVRJT05cIiwgeyBvcGVyYXRpb246IFwiY2FsbFwiIH0pO1xuICAgICAgICBjb25zdCB0eCA9IGF3YWl0IHBvcHVsYXRlVHJhbnNhY3Rpb24ob3ZlcnJpZGVzKTtcbiAgICAgICAgdHJ5IHtcbiAgICAgICAgICAgIHJldHVybiBhd2FpdCBydW5uZXIuY2FsbCh0eCk7XG4gICAgICAgIH1cbiAgICAgICAgY2F0Y2ggKGVycm9yKSB7XG4gICAgICAgICAgICBpZiAoaXNDYWxsRXhjZXB0aW9uKGVycm9yKSAmJiBlcnJvci5kYXRhKSB7XG4gICAgICAgICAgICAgICAgdGhyb3cgY29udHJhY3QuaW50ZXJmYWNlLm1ha2VFcnJvcihlcnJvci5kYXRhLCB0eCk7XG4gICAgICAgICAgICB9XG4gICAgICAgICAgICB0aHJvdyBlcnJvcjtcbiAgICAgICAgfVxuICAgIH07XG4gICAgY29uc3Qgc2VuZCA9IGFzeW5jIGZ1bmN0aW9uIChvdmVycmlkZXMpIHtcbiAgICAgICAgY29uc3QgcnVubmVyID0gY29udHJhY3QucnVubmVyO1xuICAgICAgICBhc3NlcnQoY2FuU2VuZChydW5uZXIpLCBcImNvbnRyYWN0IHJ1bm5lciBkb2VzIG5vdCBzdXBwb3J0IHNlbmRpbmcgdHJhbnNhY3Rpb25zXCIsIFwiVU5TVVBQT1JURURfT1BFUkFUSU9OXCIsIHsgb3BlcmF0aW9uOiBcInNlbmRUcmFuc2FjdGlvblwiIH0pO1xuICAgICAgICBjb25zdCB0eCA9IGF3YWl0IHJ1bm5lci5zZW5kVHJhbnNhY3Rpb24oYXdhaXQgcG9wdWxhdGVUcmFuc2FjdGlvbihvdmVycmlkZXMpKTtcbiAgICAgICAgY29uc3QgcHJvdmlkZXIgPSBnZXRQcm92aWRlcihjb250cmFjdC5ydW5uZXIpO1xuICAgICAgICAvLyBAVE9ETzogdGhlIHByb3ZpZGVyIGNhbiBiZSBudWxsOyBtYWtlIGEgY3VzdG9tIGR1bW15IHByb3ZpZGVyIHRoYXQgd2lsbCB0aHJvdyBhXG4gICAgICAgIC8vIG1lYW5pbmdmdWwgZXJyb3JcbiAgICAgICAgcmV0dXJuIG5ldyBDb250cmFjdFRyYW5zYWN0aW9uUmVzcG9uc2UoY29udHJhY3QuaW50ZXJmYWNlLCBwcm92aWRlciwgdHgpO1xuICAgIH07XG4gICAgY29uc3QgZXN0aW1hdGVHYXMgPSBhc3luYyBmdW5jdGlvbiAob3ZlcnJpZGVzKSB7XG4gICAgICAgIGNvbnN0IHJ1bm5lciA9IGdldFJ1bm5lcihjb250cmFjdC5ydW5uZXIsIFwiZXN0aW1hdGVHYXNcIik7XG4gICAgICAgIGFzc2VydChjYW5Fc3RpbWF0ZShydW5uZXIpLCBcImNvbnRyYWN0IHJ1bm5lciBkb2VzIG5vdCBzdXBwb3J0IGdhcyBlc3RpbWF0aW9uXCIsIFwiVU5TVVBQT1JURURfT1BFUkFUSU9OXCIsIHsgb3BlcmF0aW9uOiBcImVzdGltYXRlR2FzXCIgfSk7XG4gICAgICAgIHJldHVybiBhd2FpdCBydW5uZXIuZXN0aW1hdGVHYXMoYXdhaXQgcG9wdWxhdGVUcmFuc2FjdGlvbihvdmVycmlkZXMpKTtcbiAgICB9O1xuICAgIGNvbnN0IG1ldGhvZCA9IGFzeW5jIChvdmVycmlkZXMpID0+IHtcbiAgICAgICAgcmV0dXJuIGF3YWl0IHNlbmQob3ZlcnJpZGVzKTtcbiAgICB9O1xuICAgIGRlZmluZVByb3BlcnRpZXMobWV0aG9kLCB7XG4gICAgICAgIF9jb250cmFjdDogY29udHJhY3QsXG4gICAgICAgIGVzdGltYXRlR2FzLFxuICAgICAgICBwb3B1bGF0ZVRyYW5zYWN0aW9uLFxuICAgICAgICBzZW5kLCBzdGF0aWNDYWxsXG4gICAgfSk7XG4gICAgcmV0dXJuIG1ldGhvZDtcbn1cbmZ1bmN0aW9uIGJ1aWxkV3JhcHBlZE1ldGhvZChjb250cmFjdCwga2V5KSB7XG4gICAgY29uc3QgZ2V0RnJhZ21lbnQgPSBmdW5jdGlvbiAoLi4uYXJncykge1xuICAgICAgICBjb25zdCBmcmFnbWVudCA9IGNvbnRyYWN0LmludGVyZmFjZS5nZXRGdW5jdGlvbihrZXksIGFyZ3MpO1xuICAgICAgICBhc3NlcnQoZnJhZ21lbnQsIFwibm8gbWF0Y2hpbmcgZnJhZ21lbnRcIiwgXCJVTlNVUFBPUlRFRF9PUEVSQVRJT05cIiwge1xuICAgICAgICAgICAgb3BlcmF0aW9uOiBcImZyYWdtZW50XCIsXG4gICAgICAgICAgICBpbmZvOiB7IGtleSwgYXJncyB9XG4gICAgICAgIH0pO1xuICAgICAgICByZXR1cm4gZnJhZ21lbnQ7XG4gICAgfTtcbiAgICBjb25zdCBwb3B1bGF0ZVRyYW5zYWN0aW9uID0gYXN5bmMgZnVuY3Rpb24gKC4uLmFyZ3MpIHtcbiAgICAgICAgY29uc3QgZnJhZ21lbnQgPSBnZXRGcmFnbWVudCguLi5hcmdzKTtcbiAgICAgICAgLy8gSWYgYW4gb3ZlcnJpZGVzIHdhcyBwYXNzZWQgaW4sIGNvcHkgaXQgYW5kIG5vcm1hbGl6ZSB0aGUgdmFsdWVzXG4gICAgICAgIGxldCBvdmVycmlkZXMgPSB7fTtcbiAgICAgICAgaWYgKGZyYWdtZW50LmlucHV0cy5sZW5ndGggKyAxID09PSBhcmdzLmxlbmd0aCkge1xuICAgICAgICAgICAgb3ZlcnJpZGVzID0gYXdhaXQgY29weU92ZXJyaWRlcyhhcmdzLnBvcCgpKTtcbiAgICAgICAgICAgIGlmIChvdmVycmlkZXMuZnJvbSkge1xuICAgICAgICAgICAgICAgIG92ZXJyaWRlcy5mcm9tID0gYXdhaXQgcmVzb2x2ZUFkZHJl

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

26774HN1Yi5saXN0ZW5lcnMuc3BsaWNlKGluZGV4LCAxKTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgfVxuICAgICAgICBpZiAobGlzdGVuZXIgPT0gbnVsbCB8fCBzdWIubGlzdGVuZXJzLmxlbmd0aCA9PT0gMCkge1xuICAgICAgICAgICAgc3ViLnN0b3AoKTtcbiAgICAgICAgICAgIGdldEludGVybmFsKHRoaXMpLnN1YnMuZGVsZXRlKHN1Yi50YWcpO1xuICAgICAgICB9XG4gICAgICAgIHJldHVybiB0aGlzO1xuICAgIH1cbiAgICAvKipcbiAgICAgKiAgUmVtb3ZlIGFsbCB0aGUgbGlzdGVuZXJzIGZvciAlJWV2ZW50JSUgb3IgcmVtb3ZlIGFsbCBsaXN0ZW5lcnMgaWZcbiAgICAgKiAgdW5zcGVjaWZpZWQuXG4gICAgICovXG4gICAgYXN5bmMgcmVtb3ZlQWxsTGlzdGVuZXJzKGV2ZW50KSB7XG4gICAgICAgIGlmIChldmVudCkge1xuICAgICAgICAgICAgY29uc3Qgc3ViID0gYXdhaXQgaGFzU3ViKHRoaXMsIGV2ZW50KTtcbiAgICAgICAgICAgIGlmICghc3ViKSB7XG4gICAgICAgICAgICAgICAgcmV0dXJuIHRoaXM7XG4gICAgICAgICAgICB9XG4gICAgICAgICAgICBzdWIuc3RvcCgpO1xuICAgICAgICAgICAgZ2V0SW50ZXJuYWwodGhpcykuc3Vicy5kZWxldGUoc3ViLnRhZyk7XG4gICAgICAgIH1cbiAgICAgICAgZWxzZSB7XG4gICAgICAgICAgICBjb25zdCB7IHN1YnMgfSA9IGdldEludGVybmFsKHRoaXMpO1xuICAgICAgICAgICAgZm9yIChjb25zdCB7IHRhZywgc3RvcCB9IG9mIHN1YnMudmFsdWVzKCkpIHtcbiAgICAgICAgICAgICAgICBzdG9wKCk7XG4gICAgICAgICAgICAgICAgc3Vicy5kZWxldGUodGFnKTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgfVxuICAgICAgICByZXR1cm4gdGhpcztcbiAgICB9XG4gICAgLyoqXG4gICAgICogIEFsaWFzIGZvciBbb25dLlxuICAgICAqL1xuICAgIGFzeW5jIGFkZExpc3RlbmVyKGV2ZW50LCBsaXN0ZW5lcikge1xuICAgICAgICByZXR1cm4gYXdhaXQgdGhpcy5vbihldmVudCwgbGlzdGVuZXIpO1xuICAgIH1cbiAgICAvKipcbiAgICAgKiAgQWxpYXMgZm9yIFtvZmZdLlxuICAgICAqL1xuICAgIGFzeW5jIHJlbW92ZUxpc3RlbmVyKGV2ZW50LCBsaXN0ZW5lcikge1xuICAgICAgICByZXR1cm4gYXdhaXQgdGhpcy5vZmYoZXZlbnQsIGxpc3RlbmVyKTtcbiAgICB9XG4gICAgLyoqXG4gICAgICogIENyZWF0ZSBhIG5ldyBDbGFzcyBmb3IgdGhlICUlYWJpJSUuXG4gICAgICovXG4gICAgc3RhdGljIGJ1aWxkQ2xhc3MoYWJpKSB7XG4gICAgICAgIGNsYXNzIEN1c3RvbUNvbnRyYWN0IGV4dGVuZHMgQmFzZUNvbnRyYWN0IHtcbiAgICAgICAgICAgIGNvbnN0cnVjdG9yKGFkZHJlc3MsIHJ1bm5lciA9IG51bGwpIHtcbiAgICAgICAgICAgICAgICBzdXBlcihhZGRyZXNzLCBhYmksIHJ1bm5lcik7XG4gICAgICAgICAgICB9XG4gICAgICAgIH1cbiAgICAgICAgcmV0dXJuIEN1c3RvbUNvbnRyYWN0O1xuICAgIH1cbiAgICA7XG4gICAgLyoqXG4gICAgICogIENyZWF0ZSBhIG5ldyBCYXNlQ29udHJhY3Qgd2l0aCBhIHNwZWNpZmllZCBJbnRlcmZhY2UuXG4gICAgICovXG4gICAgc3RhdGljIGZyb20odGFyZ2V0LCBhYmksIHJ1bm5lcikge1xuICAgICAgICBpZiAocnVubmVyID09IG51bGwpIHtcbiAgICAgICAgICAgIHJ1bm5lciA9IG51bGw7XG4gICAgICAgIH1cbiAgICAgICAgY29uc3QgY29udHJhY3QgPSBuZXcgdGhpcyh0YXJnZXQsIGFiaSwgcnVubmVyKTtcbiAgICAgICAgcmV0dXJuIGNvbnRyYWN0O1xuICAgIH1cbn1cbmZ1bmN0aW9uIF9Db250cmFjdEJhc2UoKSB7XG4gICAgcmV0dXJuIEJhc2VDb250cmFjdDtcbn1cbi8qKlxuICogIEEgW1tCYXNlQ29udHJhY3RdXSB3aXRoIG5vI

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

26774H1cbiAgICAgICAgcmV0dXJuIG51bGw7XG4gICAgfVxuICAgIC8qKlxuICAgICAqICBSZXNvbHZlcyB0byB0aGUgYWRkcmVzcyBmb3IgJSVjb2luVHlwZSUlIG9yIG51bGwgaWYgdGhlXG4gICAgICogIHByb3ZpZGVkICUlY29pblR5cGUlJSBoYXMgbm90IGJlZW4gY29uZmlndXJlZC5cbiAgICAgKi9cbiAgICBhc3luYyBnZXRBZGRyZXNzKF9jb2luVHlwZSkge1xuICAgICAgICBjb25zdCBjb2luVHlwZSA9IChfY29pblR5cGUgPT0gbnVsbCkgPyBCTl82MCA6IGdldEJpZ0ludChfY29pblR5cGUpO1xuICAgICAgICBpZiAoY29pblR5cGUgPT09IEJOXzYwKSB7XG4gICAgICAgICAgICB0cnkge1xuICAgICAgICAgICAgICAgIGNvbnN0IHJlc3VsdCA9IGF3YWl0IHRoaXMuI2ZldGNoKFwiYWRkcihieXRlczMyKVwiKTtcbiAgICAgICAgICAgICAgICAvLyBObyBhZGRyZXNzXG4gICAgICAgICAgICAgICAgaWYgKHJlc3VsdCA9PSBudWxsIHx8IHJlc3VsdCA9PT0gWmVyb0FkZHJlc3MpIHtcbiAgICAgICAgICAgICAgICAgICAgcmV0dXJuIG51bGw7XG4gICAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgICAgIHJldHVybiByZXN1bHQ7XG4gICAgICAgICAgICB9XG4gICAgICAgICAgICBjYXRjaCAoZXJyb3IpIHtcbiAgICAgICAgICAgICAgICBpZiAoaXNFcnJvcihlcnJvciwgXCJDQUxMX0VYQ0VQVElPTlwiKSkge1xuICAgICAgICAgICAgICAgICAgICByZXR1cm4gbnVsbDtcbiAgICAgICAgICAgICAgICB9XG4gICAgICAgICAgICAgICAgdGhyb3cgZXJyb3I7XG4gICAgICAgICAgICB9XG4gICAgICAgIH1cbiAgICAgICAgaWYgKGlzRXZtQ29pblR5cGUoY29pblR5cGUpKSB7XG4gICAgICAgICAgICBjb25zdCBkYXRhID0gYXdhaXQgdGhpcy4jZmV0Y2goXCJhZGRyKGJ5dGVzMzIsdWludClcIiwgW2NvaW5UeXBlXSk7XG4gICAgICAgICAgICBpZiAoaXNIZXhTdHJpbmcoZGF0YSwgMjApKSB7XG4gICAgICAgICAgICAgICAgcmV0dXJuIGdldEFkZHJl

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

26774H1cbiAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IHRva2VuSWQgPSBjb21wc1sxXTtcbiAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IGNvbnRyYWN0ID0gbmV3IENvbnRyYWN0KGNvbXBzWzBdLCBbXG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgLy8gRVJDLTcyMVxuICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwiZnVuY3Rpb24gdG9rZW5VUkkodWludCkgdmlldyByZXR1cm5zIChzdHJpbmcpXCIsXG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgXCJmdW5jdGlvbiBvd25lck9mKHVpbnQpIHZpZXcgcmV0dXJucyAoYWRkcmVzcylcIixcbiAgICAgICAgICAgICAgICAgICAgICAgICAgICAvLyBFUkMtMTE1NVxuICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwiZnVuY3Rpb24gdXJpKHVpbnQpIHZpZXcgcmV0dXJucyAoc3RyaW5nKVwiLFxuICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwiZnVuY3Rpb24gYmFsYW5jZU9mKGFkZHJlc3MsIHVpbnQyNTYpIHZpZXcgcmV0dXJucyAodWludClcIlxuICAgICAgICAgICAgICAgICAgICAgICAgXSwgdGhpcy5wcm92aWRlcik7XG4gICAgICAgICAgICAgICAgICAgICAgICAvLyBDaGVjayB0aGF0IHRoaXMgYWNjb3VudCBvd25zIHRoZSB0b2tlblxuICAgICAgICAgICAgICAgICAgICAgICAgaWYgKHNjaGVtZSA9PT0gXCJlcmM3MjFcIikge1xuICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IHRva2VuT3duZXIgPSBhd2FpdCBjb250cmFjdC5vd25lck9mKHRva2VuSWQpO1xuICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlmIChvd25lciAhPT0gdG9rZW5Pd25lcikge1xuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBsaW5rYWdlLnB1c2goeyB0eXBlOiBcIiFvd25lclwiLCB2YWx1ZTogdG9rZW5Pd25lciB9KTtcbiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHsgdXJsOiBudWxsLCBsaW5rYWdlIH07XG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgICAgICAgICAgICAgICAgIGxpbmthZ2UucHVzaCh7IHR5cGU6IFwib3duZXJcIiwgdmFsdWU6IHRva2VuT3duZXIgfSk7XG4gICAgICAgICAgICAgICAgICAgICAgICB9XG4gICAgICAgICAgICAgICAgICAgICAgICBlbHNlIGlmIChzY2hlbWUgPT09IFwiZXJjMTE1NVwiKSB7XG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgYmFsYW5jZSA9IGF3YWl0IGNvbnRyYWN0LmJhbGFuY2VPZihvd25lciwgdG9rZW5JZCk7XG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgaWYgKCFiYWxhbmNlKSB7XG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGxpbmthZ2UucHVzaCh7IHR5cGU6IFwiIWJhbGFuY2VcIiwgdmFsdWU6IFwiMFwiIH0pO1xuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4geyB1cmw6IG51bGwsIGxpbmthZ2UgfTtcbiAgICAgICAgICAgICAgICAgICAgICAgICAgICB9XG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgbGlua2FnZS5wdXNoKHsgdHlwZTogXCJiYWxhbmNlXCIsIHZhbHVlOiBiYWxhbmNlLnRvU3RyaW5nKCkgfSk7XG4gICAgICAgICAgICAgICAgICAgICAgICB9XG4gICAgICAgICAgICAgICAgICAgICAgICAvLyBDYWxsIHRoZSB0b2tlbiBjb250cmFjdCBmb3IgdGhlIG1ldGFkYXRhIFVSTFxuICAgICAgICAgICAgICAgICAgICAgICAgbGV0IG1ldGFkYXRhVXJsID0gYXdhaXQgY29udHJhY3Rbc2VsZWN0b3JdKHRva2VuSWQpO1xuICAgICAgICAgICAgICAgICAgICAgICAgaWYgKG1ldGFkYXRhVXJsID09IG51bGwgfHwgbWV0YWRhdGFVcmwgPT09IFwiMHhcIikge1xuICAgICAgICAgICAgICAgICAgICAgICAgICAgIGxpbmthZ2UucHVzaCh7IHR5cGU6IFwiIW1ldGFkYXRhLXVybFwiLCB2YWx1ZTogXCJcIiB9KTtcbiAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXR1cm4geyB1cmw6IG51bGwsIGxpbmthZ2UgfTtcbiAgICAgICAgICAgICAgICAgICAgICAgIH1cbiAgICAgICAgICAgICAgICAgICAgICAgIGxpbmthZ2UucHVzaCh7IHR5cGU6IFwibWV0YWRhdGEtdXJsLWJhc2VcIiwgdmFsdWU6IG1ldGFkYXRhVXJsIH0pO1xuICAgICAgICAgICAgICAgICAgICAgICAgLy8gRVJDLTExNTUgYWxsb3dzIGEgZ2VuZXJpYyB7aWR9IGluIHRoZSBVUkxcbiAgICAgICAgICAgICAgICAgICAgICAgIGlmIChzY2hlbWUgPT09IFwiZXJjMTE1NVwiKSB7XG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgbWV0YWRhdGFVcmwgPSBtZXRhZGF0YVVybC5yZXBsYWNlKFwie2lkfVwiLCB0b0JlSGV4KHRva2VuSWQsIDMyKS5zdWJzdHJpbmcoMikpO1xuICAgICAgICAgICAgICAgICAgICAgICAgICAgIGxpbmthZ2UucHVzaCh7IHR5cGU6IFwibWV0YWRhdGEtdXJsLWV4cGFuZGVkXCIsIHZhbHVlOiBtZXRhZGF0YVVybCB9KTtcbiAgICAgICAgICAgICAgICAgICAgICAgIH1cbiAgICAgICAgICAgICAgICAgICAgICAgIC8vIFRyYW5zZm9ybSBJUEZTIG1ldGFkYXRhIGxpbmtzXG4gICAgICAgICAgICAgICAgICAgICAgICBpZiAobWV0YWRhdGFVcmwubWF0Y2goL15pcGZzOi9pKSkge1xuICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1ldGFkYXRhVXJsID0gZ2V0SXBmc0xpbmsobWV0YWRhdGFVcmwpO1xuICAgICAgICAgICAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgICAgICAgICAgICAgbGlua2FnZS5wdXNoKHsgdHlwZTogXCJtZXRhZGF0YS11cmxcIiwgdmFsdWU6IG1ldGFkYXRhVXJsIH0pO1xuICAgICAgICAgICAgICAgICAgICAgICAgLy8gR2V0IHRoZSB0b2tlbiBtZXRhZGF0YVxuICAgICAgICAgICAgICAgICAgICAgICAgbGV0IG1ldGFkYXRhID0ge307XG4gICAgICAgICAgICAgICAgICAgICAgICBjb25zdCByZXNwb25zZSA9IGF3YWl0IChuZXcgRmV0Y2hSZXF1ZXN0KG1ldGFkYXRhVXJsKSkuc2VuZCgpO1xuICAgICAgICAgICAgICAgICAgICAgICAgcmVzcG9uc2UuYXNzZXJ0T2soKTtcbiAgICAgICAgICAgICAgICAgICAgICAgIHRyeSB7XG4gICAgICAgICAgICAgICAgICAgICAgICAgICAgbWV0YWRhdGEgPSByZXNwb25zZS5ib2R5SnNvbjtcbiAgICAgICAgICAgICAgICAgICAgICAgI

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

26774H1cbiAgICAgICAgICAgIHRocm93IGVycm9yO1xuICAgICAgICB9XG4gICAgfVxuICAgIC8qKlxuICAgICAqICBSZXNvbHZlIHRvIHRoZSBFTlMgcmVzb2x2ZXIgZm9yICUlbmFtZSUlIHVzaW5nICUlcHJvdmlkZXIlJSBvclxuICAgICAqICBgYG51bGxgYCBpZiB1bmNvbmZpZ3VyZWQuXG4gICAgICovXG4gICAgc3RhdGljIGFzeW5jIGZyb21OYW1lKHByb3ZpZGVyLCBuYW1lKSB7XG4gICAgICAgIC8vIFdlIGhhdmUgYSBVbml2ZXJzYWwgUmVzb2x2ZXIsIHVzZSBpdFxuICAgICAgICBjb25zdCB1bml2ZXJzYWwgPSBhd2FpdCBjcmVhdGVVbml2ZXJzYWwocHJvdmlkZXIpO1xuICAgICAgICBpZiAodW5pdmVyc2FsKSB7XG4gICAgICAgICAgICBsZXQgZG5zTmFtZTtcbiAgICAgICAgICAgIHRyeSB7XG4gICAgICAgICAgICAgICAgZG5zTmFtZSA9IGRuc0VuY29kZShlbnNOb3JtYWxpemUobmFtZSksIDI1NSk7XG4gICAgICAgICAgICB9XG4gICAgICAgICAgICBjYXRjaCAoZXJyb3IpIHtcbiAgICAgICAgICAgICAgICAvLyBTaG91bGQgdGhpcyBlbWl0IGFuIGVycm9yIGluIHRoZSBwcm92aWRlciBkZWJ1ZyBldmVudD9cbiAgICAgICAgICAgICAgICByZXR1cm4gbnVsbDtcbiAgICAgICAgICAgIH1cbiAgICAgICAgICAgIGNvbnN0IHJlc3VsdCA9IGF3YWl0IHVuaXZlcnNhbC5yZXF1aXJlUmVzb2x2ZXIoZG5zTmFtZSk7XG4gICAgICAgICAgICByZXR1cm4gbmV3IEVuc1Jlc29sdmVyKHByb3ZpZGVyLCByZXN1bHQucmVzb2x2ZXIsIG5hbWUsIHJlc3VsdC5leHRlbmRlZCk7XG4gICAgICAgIH1cbiAgICAgICAgbGV0IGN1cnJlbnROYW1lID0gbmFtZTtcbiAgICAgICAgd2hpbGUgKHRydWUpIHtcbiAgICAgICAgICAgIGlmIChjdXJyZW50TmFtZSA9PT0gXCJcIiB8fCBjdXJyZW50TmFtZSA9PT0gXCIuXCIpIHtcbiAgICAgICAgICAgICAgICByZXR1cm4gbnVsbDtcbiAgICAgICAgICAgIH1cbiAgICAgICAgICAgIC8vIE9wdGltaXphdGlvbiBzaW5jZSB0aGUgZXRoIG5vZGUgY2Fubm90IGNoYW5nZSBhbmQgZG9lc1xuICAgICAgICAgICAgLy8gbm90IGhhdmUgYSB3aWxkY2FyZCByZXNvbHZlclxuICAgICAgICAgICAgaWYgKG5hbWUgIT09IFwiZXRoXCIgJiYgY3VycmVudE5hbWUgPT09IFwiZXRoXCIpIHtcbiAgICAgICAgICAgICAgICByZXR1cm4gbnVsbDtcbiAgICAgICAgICAgIH1cbiAgICAgICAgICAgIC8vIENoZWNrIHRoZSBjdXJyZW50IG5vZGUgZm9yIGEgcmVzb2x2ZXJcbiAgICAgICAgICAgIGNvbnN0IGFkZHIgPSBhd2FpdCBFbnNSZXNvbHZlci4jZ2V0UmVzb2x2ZXIocHJvdmlkZXIsIGN1cnJlbnROYW1lKTtcbiAgICAgICAgICAgIC8vIEZvdW5kIGEgcmVzb2x2ZXIhXG4gICAgICAgICAgICBpZiAoYWRkciAhPSBudWxsKSB7XG4gICAgICAgICAgICAgICAgY29uc3QgcmVzb2x2ZXIgPSBuZXcgRW5zUmVzb2x2ZXIocHJvdmlkZXIsIGFkZHIsIG5hbWUpO1xuICAgICAgICAgICAgICAgIC8vIExlZ2FjeSByZXNvbHZlciBmb3VuZCwgdXNpbmcgRUlQLTI1NDQgc28gaXQgaXNuJ3Qgc2FmZSB0byB1c2VcbiAgICAgICAgICAgICAgICBpZiAoY3VycmVudE5hbWUgIT09IG5hbWUgJiYgIShhd2FpdCByZXNvbHZlci5zdXBwb3J0c1dpbGRjYXJkKCkpKSB7XG4gICAgICAgICAgICAgICAgICAgIHJldHVybiBudWxsO1xuICAgICAgICAgICAgICAgIH1cbiAgICAgICAgICAgICAgICByZXR1cm4gcmVzb2x2ZXI7XG4gICAgICAgICAgICB9XG4gICAgICAgICAgICAvLyBHZXQgdGhlIHBhcmVudCBub2RlXG4gICAgICAgICAgICBjdXJyZW50TmFtZSA9IGN1cnJlbnROYW1lLnNwbGl0KFwiLlwiKS5zbGljZSgxKS5qb2luKFwiLlwiKTtcbiAgICAgICAgfVxuICAgIH1cbn1cbmFzeW5jIGZ1bmN0aW9uIGNyZWF0ZVVuaXZlcnNhbChwcm92aWRlcikge1xuICAgIGNvbnN0IGFkZHJlc3MgPSBhd2FpdCBFbnNSZXNvbHZlci5nZXRVbml2ZXJzYWxSZXNvbHZlckFkZHJl

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

26774HRocm93IG5ldyBFcnJvcihcImludmFsaWQgdWludDI1NlwiKTtcbiAgICB9XG4gICAgcmV0dXJuIHplcm9QYWRWYWx1ZSh2YWx1ZSwgMzIpO1xufVxuY29uc3QgX2Zvcm1hdExvZyA9IG9iamVjdCh7XG4gICAgYWRkcmVzczogZ2V0QWRkcmVzcyxcbiAgICBibG9ja0hhc2g6IGZvcm1hdEhhc2gsXG4gICAgYmxvY2tOdW1iZXI6IGdldE51bWJlcixcbiAgICBkYXRhOiBmb3JtYXREYXRhLFxuICAgIGluZGV4OiBnZXROdW1iZXIsXG4gICAgcmVtb3ZlZDogYWxsb3dOdWxsKGZvcm1hdEJvb2xlYW4sIGZhbHNlKSxcbiAgICB0b3BpY3M6IGFycmF5T2YoZm9ybWF0SGFzaCksXG4gICAgdHJhbnNhY3Rpb25IYXNoOiBmb3JtYXRIYXNoLFxuICAgIHRyYW5zYWN0aW9uSW5kZXg6IGdldE51bWJlcixcbn0sIHtcbiAgICBpbmRleDogW1wibG9nSW5kZXhcIl1cbn0pO1xuZXhwb3J0IGZ1bmN0aW9uIGZvcm1hdExvZyh2YWx1ZSkge1xuICAgIHJldHVybiBfZm9ybWF0TG9nKHZhbHVlKTtcbn1cbmNvbnN0IF9mb3JtYXRCbG9jayA9IG9iamVjdCh7XG4gICAgaGFzaDogYWxsb3dOdWxsKGZvcm1hdEhhc2gpLFxuICAgIHBhcmVudEhhc2g6IGZvcm1hdEhhc2gsXG4gICAgcGFyZW50QmVhY29uQmxvY2tSb290OiBhbGxvd051bGwoZm9ybWF0SGFzaCwgbnVsbCksXG4gICAgbnVtYmVyOiBnZXROdW1iZXIsXG4gICAgdGltZXN0YW1wOiBnZXROdW1iZXIsXG4gICAgbm9uY2U6IGFsbG93TnVsbChmb3JtYXREYXRhKSxcbiAgICBkaWZmaWN1bHR5OiBnZXRCaWdJbnQsXG4gICAgZ2FzTGltaXQ6IGdldEJpZ0ludCxcbiAgICBnYXNVc2VkOiBnZXRCaWdJbnQsXG4gICAgc3RhdGVSb290OiBhbGxvd051bGwoZm9ybWF0SGFzaCwgbnVsbCksXG4gICAgcmVjZWlwdHNSb290OiBhbGxvd051bGwoZm9ybWF0SGFzaCwgbnVsbCksXG4gICAgdHJhbnNhY3Rpb25zUm9vdDogYWxsb3dOdWxsKGZvcm1hdEhhc2gsIG51bGwpLFxuICAgIGJsb2JHYXNVc2VkOiBhbGxvd051bGwoZ2V0QmlnSW50LCBudWxsKSxcbiAgICBleGNlc3NCbG9iR2FzOiBhbGxvd051bGwoZ2V0QmlnSW50LCBudWxsKSxcbiAgICBtaW5lcjogYWxsb3dOdWxsKGdldEFkZHJl

26774c3MpLFxuICAgIHByZXZSYW5kYW86IGFsbG93TnVsbChmb3JtYXRIYXNoLCBudWxsKSxcbiAgICBleHRyYURhdGE6IGZvcm1hdERhdGEsXG4gICAgYmFzZUZlZVBlckdhczogYWxsb3dOdWxsKGdldEJpZ0ludClcbn0sIHtcbiAgICBwcmV2UmFuZGFvOiBbXCJtaXhIYXNoXCJdXG59KTtcbmV4cG9ydCBmdW5jdGlvbiBmb3JtYXRCbG9jayh2YWx1ZSkge1xuICAgIGNvbnN0IHJlc3VsdCA9IF9mb3JtYXRCbG9jayh2YWx1ZSk7XG4gICAgcmVzdWx0LnRyYW5zYWN0aW9ucyA9IHZhbHVlLnRyYW5zYWN0aW9ucy5tYXAoKHR4KSA9PiB7XG4gICAgICAgIGlmICh0eXBlb2YgKHR4KSA9PT0gXCJzdHJpbmdcIikge1xuICAgICAgICAgICAgcmV0dXJuIHR4O1xuICAgICAgICB9XG4gICAgICAgIHJldHVybiBmb3JtYXRUcmFuc2FjdGlvblJlc3BvbnNlKHR4KTtcbiAgICB9KTtcbiAgICByZXR1cm4gcmVzdWx0O1xufVxuY29uc3QgX2Zvcm1hdFJlY2VpcHRMb2cgPSBvYmplY3Qoe1xuICAgIHRyYW5zYWN0aW9uSW5kZXg6IGdldE51bWJlcixcbiAgICBibG9ja051bWJlcjogZ2V0TnVtYmVyLFxuICAgIHRyYW5zYWN0aW9uSGFzaDogZm9ybWF0SGFzaCxcbiAgICBhZGRyZXNzOiBnZXRBZGRyZXNzLFxuICAgIHRvcGljczogYXJyYXlPZihmb3JtYXRIYXNoKSxcbiAgICBkYXRhOiBmb3JtYXREYXRhLFxuICAgIGluZGV4OiBnZXROdW1iZXIsXG4gICAgYmxvY2tIYXNoOiBmb3JtYXRIYXNoLFxufSwge1xuICAgIGluZGV4OiBbXCJsb2dJbmRleFwiXVxufSk7XG5leHBvcnQgZnVuY3Rpb24gZm9ybWF0UmVjZWlwdExvZyh2YWx1ZSkge1xuICAgIHJldHVybiBfZm9ybWF0UmVjZWlwdExvZyh2YWx1ZSk7XG59XG5jb25zdCBfZm9ybWF0VHJhbnNhY3Rpb25SZWNlaXB0ID0gb2JqZWN0KHtcbiAgICB0bzogYWxsb3dOdWxsKGdldEFkZHJl

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

26774H1cbiAgICAgICAgc3VwZXIoYG9yZy5ldGhlcnMubmV0d29yay5wbHVnaW5zLkdhc0Nvc3QjJHsoZWZmZWN0aXZlQmxvY2sgfHwgMCl9YCk7XG4gICAgICAgIGNvbnN0IHByb3BzID0geyBlZmZlY3RpdmVCbG9jayB9O1xuICAgICAgICBmdW5jdGlvbiBzZXQobmFtZSwgbnVsbGlzaCkge1xuICAgICAgICAgICAgbGV0IHZhbHVlID0gKGNvc3RzIHx8IHt9KVtuYW1lXTtcbiAgICAgICAgICAgIGlmICh2YWx1ZSA9PSBudWxsKSB7XG4gICAgICAgICAgICAgICAgdmFsdWUgPSBudWxsaXNoO1xuICAgICAgICAgICAgfVxuICAgICAgICAgICAgYXNzZXJ0QXJndW1lbnQodHlwZW9mICh2YWx1ZSkgPT09IFwibnVtYmVyXCIsIGBpbnZhbHVkIHZhbHVlIGZvciAke25hbWV9YCwgXCJjb3N0c1wiLCBjb3N0cyk7XG4gICAgICAgICAgICBwcm9wc1tuYW1lXSA9IHZhbHVlO1xuICAgICAgICB9XG4gICAgICAgIHNldChcInR4QmFzZVwiLCAyMTAwMCk7XG4gICAgICAgIHNldChcInR4Q3JlYXRlXCIsIDMyMDAwKTtcbiAgICAgICAgc2V0KFwidHhEYXRhWmVyb1wiLCA0KTtcbiAgICAgICAgc2V0KFwidHhEYXRhTm9uemVyb1wiLCAxNik7XG4gICAgICAgIHNldChcInR4QWNjZXNzTGlzdFN0b3JhZ2VLZXlcIiwgMTkwMCk7XG4gICAgICAgIHNldChcInR4QWNjZXNzTGlzdEFkZHJlc3NcIiwgMjQwMCk7XG4gICAgICAgIGRlZmluZVByb3BlcnRpZXModGhpcywgcHJvcHMpO1xuICAgIH1cbiAgICB0b1N0cmluZygpIHtcbiAgICAgICAgcmV0dXJuIGAke3RoaXMubmFtZX0geyB0eEJhc2U6ICR7dGhpcy50eEJhc2V9LCB0eENyZWF0ZTogJHt0aGlzLnR4Q3JlYXRlfSwgdHhEYXRhWmVybzogJHt0aGlzLnR4RGF0YVplcm99LCB0eEFjY2Vzc0xpc3RTdG9yYWdlS2V5OiAke3RoaXMudHhBY2Nlc3NMaXN0U3RvcmFnZUtleX0sIHR4QWNjZXNzTGlzdEFkZHJlc3M6ICR7dGhpcy50eEFjY2Vzc0xpc3RBZGRyZXNzfSB9YDtcbiAgICB9XG4gICAgY2xvbmUoKSB7XG4gICAgICAgIHJldHVybiBuZXcgR2FzQ29zdFBsdWdpbih0aGlzLmVmZmVjdGl2ZUJsb2NrLCB0aGlzKTtcbiAgICB9XG59XG4vKipcbiAqICBBbiAqKkVuc1BsdWdpbioqIGFsbG93cyBhIFtbTmV0d29ya11dIHRvIHNwZWNpZnkgdGhlIEVOUyBSZWdpc3RyeVxuICogIENvbnRyYWN0IGFkZHJlc3MgYW5kIHR

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

26774c3MgfSBmcm9tIFwiLi4vYWRkcmVzcy9pbmRleC5qc1wiO1xuaW1wb3J0IHsgVHJhbnNhY3Rpb24gfSBmcm9tIFwiLi4vdHJhbnNhY3Rpb24vaW5kZXguanNcIjtcbmltcG9ydCB7IGNvbmNhdCwgZGF0YUxlbmd0aCwgZGF0YVNsaWNlLCBoZXhsaWZ5LCBpc0hleFN0cmluZywgZ2V0QmlnSW50LCBnZXRCeXRlcywgZ2V0TnVtYmVyLCBpc0NhbGxFeGNlcHRpb24sIG1ha2VFcnJvciwgYXNzZXJ0LCBhc3NlcnRBcmd1bWVudCwgRmV0Y2hSZXF1ZXN0LCB0b0JlQXJyYXksIHRvUXVhbnRpdHksIGRlZmluZVByb3BlcnRpZXMsIEV2ZW50UGF5bG9hZCwgcmVzb2x2ZVByb3BlcnRpZXMsIHRvVXRmOFN0cmluZyB9IGZyb20gXCIuLi91dGlscy9pbmRleC5qc1wiO1xuaW1wb3J0IHsgRW5zUmVzb2x2ZXIgfSBmcm9tIFwiLi9lbnMtcmVzb2x2ZXIuanNcIjtcbmltcG9ydCB7IGZvcm1hdEJsb2NrLCBmb3JtYXRMb2csIGZvcm1hdFRyYW5zYWN0aW9uUmVjZWlwdCwgZm9ybWF0VHJhbnNhY3Rpb25SZXNwb25zZSB9IGZyb20gXCIuL2Zvcm1hdC5qc1wiO1xuaW1wb3J0IHsgTmV0d29yayB9IGZyb20gXCIuL25ldHdvcmsuanNcIjtcbmltcG9ydCB7IGNvcHlSZXF1ZXN0LCBCbG9jaywgRmVlRGF0YSwgTG9nLCBUcmFuc2FjdGlvblJlY2VpcHQsIFRyYW5zYWN0aW9uUmVzcG9uc2UgfSBmcm9tIFwiLi9wcm92aWRlci5qc1wiO1xuaW1wb3J0IHsgUG9sbGluZ0Jsb2NrU3Vic2NyaWJlciwgUG9sbGluZ0Jsb2NrVGFnU3Vic2NyaWJlciwgUG9sbGluZ0V2ZW50U3Vic2NyaWJlciwgUG9sbGluZ09ycGhhblN1YnNjcmliZXIsIFBvbGxpbmdUcmFuc2FjdGlvblN1YnNjcmliZXIgfSBmcm9tIFwiLi9zdWJzY3JpYmVyLXBvbGxpbmcuanNcIjtcbi8vIENvbnN0YW50c1xuY29uc3QgQk5fMiA9IEJpZ0ludCgyKTtcbmNvbnN0IE1BWF9DQ0lQX1JFRElSRUNUUyA9IDEwO1xuZnVuY3Rpb24gc3RhbGwoZHVyYXRpb24pIHtcbiAgICByZXR1cm4gbmV3IFByb21pc2UoKHJlc29sdmUpID0+IHsgc2V0VGltZW91dChyZXNvbHZlLCBkdXJhdGlvbik7IH0pO1xufVxuZnVuY3Rpb24gaXNQcm9taXNlKHZhbHVlKSB7XG4gICAgcmV0dXJuICh2YWx1ZSAmJiB0eXBlb2YgKHZhbHVlLnRoZW4pID09PSBcImZ1bmN0aW9uXCIpO1xufVxuZnVuY3Rpb24gZ2V0VGFnKHByZWZpeCwgdmFsdWUpIHtcbiAgICByZXR1cm4gcHJlZml4ICsgXCI6XCIgKyBKU09OLnN0cmluZ2lmeSh2YWx1ZSwgKGssIHYpID0+IHtcbiAgICAgICAgaWYgKHYgPT0gbnVsbCkge1xuICAgICAgICAgICAgcmV0dXJuIFwibnVsbFwiO1xuICAgICAgICB9XG4gICAgICAgIGlmICh0eXBlb2YgKHYpID09PSBcImJpZ2ludFwiKSB7XG4gICAgICAgICAgICByZXR1cm4gYGJpZ2ludDoke3YudG9TdHJpbmcoKX1gO1xuICAgICAgICB9XG4gICAgICAgIGlmICh0eXBlb2YgKHYpID09PSBcInN0cmluZ1wiKSB7XG4gICAgICAgICAgICByZXR1cm4gdi50b0xvd2VyQ2FzZSgpO1xuICAgICAgICB9XG4gICAgICAgIC8vIFNvcnQgb2JqZWN0IGtleXNcbiAgICAgICAgaWYgKHR5cGVvZiAodikgPT09IFwib2JqZWN0XCIgJiYgIUFycmF5LmlzQXJyYXkodikpIHtcbiAgICAgICAgICAgIGNvbnN0IGtleXMgPSBPYmplY3Qua2V5cyh2KTtcbiAgICAgICAgICAgIGtleXMuc29ydCgpO1xuICAgICAgICAgICAgcmV0dXJuIGtleXMucmVkdWNlKChhY2N1bSwga2V5KSA9PiB7XG4gICAgICAgICAgICAgICAgYWNjdW1ba2V5XSA9IHZba2V5XTtcbiAgICAgICAgICAgICAgICByZXR1cm4gYWNjdW07XG4gICAgICAgICAgICB9LCB7fSk7XG4gICAgICAgIH1cbiAgICAgICAgcmV0dXJuIHY7XG4gICAgfSk7XG59XG4vKipcbiAqICBBbiAqKlVubWFuYWdlZFN1YnNjcmliZXIqKiBpcyB1c2VmdWwgZm9yIGV2ZW50cyB3aGljaCBkbyBub3QgcmVxdWlyZVxuICogIGFueSBhZGRpdGlvbmFsIG1hbmFnZW1lbnQsIHN1Y2ggYXMgYGBcImRlYnVnXCJgYCB3aGljaCBvbmx5IHJlcXVpcmVzXG4gKiAgZW1pdCBpbiBzeW5jaHJvbm91cyBldmVudCBsb29wIHRyaWdnZXJlZCBjYWxscy5cbiAqL1xuZXhwb3J0IGNsYXNzIFVubWFuYWdlZFN1YnNjcmliZXIge1xuICAgIC8qKlxuICAgICAqICBUaGUgbmFtZSBmb2YgdGhlIGV2ZW50LlxuICAgICAqL1xuICAgIG5hbWU7XG4gICAgLyoqXG4gICAgICogIENyZWF0ZSBhIG5ldyBVbm1hbmFnZWRTdWJzY3JpYmVyIHdpdGggJSVuYW1lJSUuXG4gICAgICovXG4gICAgY29uc3RydWN0b3IobmFtZSkgeyBkZWZpbmVQcm9wZXJ0aWVzKHRoaXMsIHsgbmFtZSB9KTsgfVxuICAgIHN0YXJ0KCkgeyB9XG4gICAgc3RvcCgpIHsgfVxuICAgIHBhdXNlKGRyb3BXaGlsZVBhdXNlZCkgeyB9XG4gICAgcmVzdW1lKCkgeyB9XG59XG5mdW5jdGlvbiBjb3B5KHZhbHVlKSB7XG4gICAgcmV0dXJuIEpTT04ucGFyc2UoSlNPTi5zdHJpbmdpZnkodmFsdWUpKTtcbn1cbmZ1bmN0aW9uIGNvbmNpc2lmeShpdGVtcykge1xuICAgIGl0ZW1zID0gQXJyYXkuZnJvbSgobmV3IFNldChpdGVtcykpLnZhbHVlcygpKTtcbiAgICBpdGVtcy5zb3J0KCk7XG4gICAgcmV0dXJuIGl0ZW1zO1xufVxuYXN5bmMgZnVuY3Rpb24gZ2V0U3Vic2NyaXB0aW9uKF9ldmVudCwgcHJvdmlkZXIpIHtcbiAgICBpZiAoX2V2ZW50ID09IG51bGwpIHtcbiAgICAgICAgdGhyb3cgbmV3IEVycm9yKFwiaW52YWxpZCBldmVudFwiKTtcbiAgICB9XG4gICAgLy8gTm9ybWFsaXplIHRvcGljIGFycmF5IGluZm8gYW4gRXZlbnRGaWx0ZXJcbiAgICBpZiAoQXJyYXkuaXNBcnJheShfZXZlbnQpKSB7XG4gICAgICAgIF9ldmVudCA9IHsgdG9waWNzOiBfZXZlbnQgfTtcbiAgICB9XG4gICAgaWYgKHR5cGVvZiAoX2V2ZW50KSA9PT0gXCJzdHJpbmdcIikge1xuICAgICAgICBzd2l0Y2ggKF9ldmVudCkge1xuICAgICAgICAgICAgY2FzZSBcImJsb2NrXCI6XG4gICAgICAgICAgICBjYXNlIFwiZGVidWdcIjpcbiAgICAgICAgICAgIGNhc2UgXCJlcnJvclwiOlxuICAgICAgICAgICAgY2FzZSBcImZpbmFsaXplZFwiOlxuICAgICAgICAgICAgY2FzZSBcIm5ldHdvcmtcIjpcbiAgICAgICAgICAgIGNhc2UgXCJwZW5kaW5nXCI6XG4gICAgICAgICAgICBjYXNlIFwic2FmZVwiOiB7XG4gICAgICAgICAgICAgICAgcmV0dXJuIHsgdHlwZTogX2V2ZW50LCB0YWc6IF9ldmVudCB9O1xuICAgICAgICAgICAgfVxuICAgICAgICB9XG4gICAgfVxuICAgIGlmIChpc0hleFN0cmluZyhfZXZlbnQsIDMyKSkge1xuICAgICAgICBjb25zdCBoYXNoID0gX2V2ZW50LnRvTG93ZXJDYXNlKCk7XG4gICAgICAgI

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

26774V0d29ya1wiKTtcbiAgICAgICAgaWYgKHR5cGVvZiAoc3RhdGljTmV0d29yaykgPT09IFwiYm9vbGVhblwiKSB7XG4gICAgICAgICAgICBhc3NlcnRBcmd1bWVudCghc3RhdGljTmV0d29yayB8fCBuZXR3b3JrICE9PSBcImFueVwiLCBcInN0YXRpY05ldHdvcmsgY2Fubm90IGJlIHVzZWQgb24gc3BlY2lhbCBuZXR3b3JrICdhbnknXCIsIFwib3B0aW9uc1wiLCBvcHRpb25zKTtcbiAgICAgICAgICAgIGlmIChzdGF0aWNOZXR3b3JrICYmIG5ldHdvcmsgIT0gbnVsbCkge1xuICAgICAgICAgICAgICAgIHRoaXMuI25ldHdvcmsgPSBOZXR3b3JrLmZyb20obmV0d29yayk7XG4gICAgICAgICAgICB9XG4gICAgICAgIH1cbiAgICAgICAgZWxzZSBpZiAoc3RhdGljTmV0d29yaykge1xuICAgICAgICAgICAgLy8gTWFrZSBzdXJlIGFueSBzdGF0aWMgbmV0d29yayBpcyBjb21wYXRiaWxlIHdpdGggdGhlIHByb3ZpZGVkIG5ldHdyb2tcbiAgICAgICAgICAgIGFzc2VydEFyZ3VtZW50KG5ldHdvcmsgPT0gbnVsbCB8fCBzdGF0aWNOZXR3b3JrLm1hdGNoZXMobmV0d29yayksIFwic3RhdGljTmV0d29yayBNVVNUIG1hdGNoIG5ldHdvcmsgb2JqZWN0XCIsIFwib3B0aW9uc1wiLCBvcHRpb25zKTtcbiAgICAgICAgICAgIHRoaXMuI25ldHdvcmsgPSBzdGF0aWNOZXR3b3JrO1xuICAgICAgICB9XG4gICAgfVxuICAgIC8qKlxuICAgICAqICBSZXR1cm5zIHRoZSB2YWx1ZSBhc3NvY2lhdGVkIHdpdGggdGhlIG9wdGlvbiAlJWtleSUlLlxuICAgICAqXG4gICAgICogIFN1Yi1jbGFzc2VzIGNhbiB1c2UgdGhpcyB0byBpbnF1aXJlIGFib3V0IGNvbmZpZ3VyYXRpb24gb3B0aW9ucy5cbiAgICAgKi9cbiAgICBfZ2V0T3B0aW9uKGtleSkge1xuICAgICAgICByZXR1cm4gdGhpcy4jb3B0aW9uc1trZXldO1xuICAgIH1cbiAgICAvKipcbiAgICAgKiAgR2V0cyB0aGUgW1tOZXR3b3JrXV0gdGhpcyBwcm92aWRlciBoYXMgY29tbWl0dGVkIHRvLiBPbiBlYWNoIGNhbGwsIHRoZSBuZXR3b3JrXG4gICAgICogIGlzIGRldGVjdGVkLCBhbmQgaWYgaXQgaGFzIGNoYW5nZWQsIHRoZSBjYWxsIHdpbGwgcmVqZWN0LlxuICAgICAqL1xuICAgIGdldCBfbmV0d29yaygpIHtcbiAgICAgICAgYXNzZXJ0KHRoaXMuI25ldHdvcmssIFwibmV0d29yayBpcyBub3QgYXZhaWxhYmxlIHlldFwiLCBcIk5FVFdPUktfRVJST1JcIik7XG4gICAgICAgIHJldHVybiB0aGlzLiNuZXR3b3JrO1xuICAgIH1cbiAgICAvKipcbiAgICAgKiAgUmVzb2x2ZXMgdG8gdGhlIG5vbi1ub3JtYWxpem

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

26774HRva2VuID0gZGVmYXVsdFRva2VuO1xuICAgICAgICB9XG4gICAgICAgIGNvbnN0IHJlcXVlc3QgPSBRdWlja05vZGVQcm92aWRlci5nZXRSZXF1ZXN0KG5ldHdvcmssIHRva2VuKTtcbiAgICAgICAgc3VwZXIocmVxdWVzdCwgbmV0d29yaywgeyBzdGF0aWNOZXR3b3JrOiBuZXR3b3JrIH0pO1xuICAgICAgICBkZWZpbmVQcm9wZXJ0aWVzKHRoaXMsIHsgdG9rZW4gfSk7XG4gICAgfVxuICAgIF9nZXRQcm92aWRlcihjaGFpbklkKSB7XG4gICAgICAgIHRyeSB7XG4gICAgICAgICAgICByZXR1cm4gbmV3IFF1aWNrTm9kZVByb3ZpZGVyKGNoYWluSWQsIHRoaXMudG9rZW4pO1xuICAgICAgICB9XG4gICAgICAgIGNhdGNoIChlcnJvcikgeyB9XG4gICAgICAgIHJldHVybiBzdXBlci5fZ2V0UHJvdmlkZXIoY2hhaW5JZCk7XG4gICAgfVxuICAgIGlzQ29tbXVuaXR5UmVzb3VyY2UoKSB7XG4gICAgICAgIHJldHVybiAodGhpcy50b2tlbiA9PT0gZGVmYXVsdFRva2VuKTtcbiAgICB9XG4gICAgLyoqXG4gICAgICogIFJldHVybnMgYSBuZXcgcmVxdWVzdCBwcmVwYXJlZCBmb3IgJSVuZXR3b3JrJSUgYW5kIHRoZVxuICAgICAqICAlJXRva2VuJSUuXG4gICAgICovXG4gICAgc3RhdGljIGdldFJlcXVlc3QobmV0d29yaywgdG9rZW4pIHtcbiAgICAgICAgaWYgKHRva2VuID09IG51bGwpIHtcbiAgICAgICAgICAgIHRva2VuID0gZGVmYXVsdFRva2VuO1xuICAgICAgICB9XG4gICAgICAgIGNvbnN0IHJlcXVlc3QgPSBuZXcgRmV0Y2hSZXF1ZXN0KGBodHRwczovXFwvJHtnZXRIb3N0KG5ldHdvcmsubmFtZSl9LyR7dG9rZW59YCk7XG4gICAgICAgIHJlcXVlc3QuYWxsb3dHemlwID0gdHJ1ZTtcbiAgICAgICAgLy9pZiAocHJvamVjdFNlY3JldCkgeyByZXF1ZXN0LnNldENyZWRlbnRpYWxzKFwiXCIsIHByb2plY3RTZWNyZXQpOyB9XG4gICAgICAgIGlmICh0b2tlbiA9PT0gZGVmYXVsdFRva2VuKSB7XG4gICAgICAgICAgICByZXF1ZXN0LnJldHJ5RnVuYyA9IGFzeW5jIChyZXF1ZXN0LCByZXNwb25zZSwgYXR0ZW1wdCkgPT4ge1xuICAgICAgICAgICAgICAgIHNob3dUaHJvdHRsZU1lc3NhZ2UoXCJRdWlja05vZGVQcm92aWRlclwiKTtcbiAgICAgICAgICAgICAgICByZXR1cm4gdHJ1ZTtcbiAgICAgICAgICAgIH07XG4gICAgICAgIH1cbiAgICAgICAgcmV0dXJuIHJlcXVlc3Q7XG4gICAgfVxufVxuLy8jIHNvdXJjZU1hcHBpbmdVUkw9cHJvdmlkZXItcXVpY2tub2RlLmpzLm1hcCIsIi8qKlxuICogIEEgKipGYWxsYmFja1Byb3ZpZGVyKiogcHJvdmlkZXMgcmVzaWxpZW5jZSwgc2VjdXJpdHkgYW5kIHBlcmZvcm1hbmNlXG4gKiAgaW4gYSB3YXkgdGhhdCBpcyBjdXN0b21pemFibGUgYW5kIGNvbmZpZ3VyYWJsZS5cbiAqXG4gKiAgQF9zZWN0aW9uOiBhcGkvcHJvdmlkZXJzL2ZhbGxiYWNrLXByb3ZpZGVyOkZhbGxiYWNrIFByb3ZpZGVyIFthYm91dC1mYWxsYmFjay1wcm92aWRlcl1cbiAqL1xuaW1wb3J0IHsgYXNzZXJ0LCBhc3NlcnRBcmd1bWVudCwgZ2V0QmlnSW50LCBnZXROdW1iZXIsIGlzRXJyb3IgfSBmcm9tIFwiLi4vdXRpbHMvaW5kZXguanNcIjtcbmltcG9ydCB7IEFic3RyYWN0UHJvdmlkZXIgfSBmcm9tIFwiLi9hYnN0cmFjdC1wcm92aWRlci5qc1wiO1xuaW1wb3J0IHsgTmV0d29yayB9IGZyb20gXCIuL25ldHdvcmsuanNcIjtcbmNvbnN0IEJOXzEgPSBCaWdJbnQoXCIxXCIpO1xuY29uc3QgQk5fMiA9IEJpZ0ludChcIjJcIik7XG5mdW5jdGlvbiBzaHVmZmxlKGFycmF5KSB7XG4gICAgZm9yIChsZXQgaSA9IGFycmF5Lmxlbmd0aCAtIDE7IGkgPiAwOyBpLS0pIHtcbiAgICAgICAgY29uc3QgaiA9IE1hdGguZmxvb3IoTWF0aC5yYW5kb20oKSAqIChpICsgMSkpO1xuICAgICAgICBjb25zdCB0bXAgPSBhcnJheVtpXTtcbiAgICAgICAgYXJyYXlbaV0gPSBhcnJheVtqXTtcbiAgICAgICAgYXJyYXlbal0gPSB0bXA7XG4gICAgfVxufVxuZnVuY3Rpb24gc3RhbGwoZHVyYXRpb24pIHtcbiAgICByZXR1cm4gbmV3IFByb21pc2UoKHJlc29sdmUpID0+IHsgc2V0VGltZW91dChyZXNvbHZlLCBkdXJhdGlvbik7IH0pO1xufVxuZnVuY3Rpb24gZ2V0VGltZSgpIHsgcmV0dXJuIChuZXcgRGF0ZSgpKS5nZXRUaW1lKCk7IH1cbmZ1bmN0aW9uIHN0cmluZ2lmeSh2YWx1ZSkge1xuICAgIHJldHVybiBKU09OLnN0cmluZ2lmeSh2YWx1ZSwgKGtleSwgdmFsdWUpID0+IHtcbiAgICAgICAgaWYgKHR5cGVvZiAodmFsdWUpID09PSBcImJpZ2ludFwiKSB7XG4gICAgICAgICAgICByZXR1cm4geyB0eXBlOiBcImJpZ2ludFwiLCB2YWx1ZTogdmFsdWUudG9TdHJpbmcoKSB9O1xuICAgICAgICB9XG4gICAgICAgIHJldHVybiB2YWx1ZTtcbiAgICB9KTtcbn1cbjtcbmNvbnN0IGRlZmF1bHRDb25maWcgPSB7IHN0YWxsVGltZW91dDogNDAwLCBwcmlvcml0eTogMSwgd2VpZ2h0OiAxIH07XG5jb25zdCBkZWZhdWx0U3RhdGUgPSB7XG4gICAgYmxvY2tOdW1iZXI6IC0yLCByZXF1ZXN0czogMCwgbGF0ZVJlc3BvbnNlczogMCwgZXJyb3JSZXNwb25zZXM6IDAsXG4gICAgb3V0T2ZTeW5jOiAtMSwgdW5zdXBwb3J0ZWRFdmVudHM6IDAsIHJvbGxpbmdEdXJhdGlvbjogMCwgc2NvcmU6IDAsXG4gICAgX25ldHdvcms6IG51bGwsIF91cGRhdGVOdW1iZXI6IG51bGwsIF90b3RhbFRpbWU6IDAsXG4gICAgX2xhc3RGYXRhbEVycm9yOiBudWxsLCBfbGFzdEZhdGFsRXJyb3JUaW1lc3RhbXA6IDBcbn07XG5hc3luYyBmdW5jdGlvbiB3YWl0Rm9yU3luYyhjb25maWcsIGJsb2NrTnVtYmVyKSB7XG4gICAgd2hpbGUgKGNvbmZpZy5ibG9ja051bWJlciA8IDAgfHwgY29uZmlnLmJsb2NrTnVtYmVyIDwgYmxvY2tOdW1iZXIpIHtcbiAgICAgICAgaWYgKCFjb25maWcuX3VwZGF0ZU51bWJlcikge1xuICAgICAgICAgICAgY29uZmlnLl91cGRhdGVOdW1iZXIgPSAoYXN5bmMgKCkgPT4ge1xuICAgICAgICAgICAgICAgIHRyeSB7XG4gICAgICAgICAgICAgICAgICAgIGNvbnN0IGJsb2NrTnVtYmVyID0gYXdhaXQgY29uZmlnLnByb3ZpZGVyLmdldEJsb2NrTnVtYmVyKCk7XG4gICAgICAgICAgICAgICAgICAgIGlmIChibG9ja051bWJlciA+IGNvbmZpZy5ibG9ja051bWJlcikge1xuICAgICAgICAgICAgICAgICAgICAgICAgY29uZmlnLmJsb2NrTnVtYmVyID0gYmxvY2tOdW1iZXI7XG4gICAgICAgICAgICAgICAgICAgI

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

26774HNodWZmbGUoYWxsQ29uZmlncyk7XG4gICAgICAgIGFsbENvbmZpZ3Muc29ydCgoYSwgYikgPT4gKGEucHJpb3JpdHkgLSBiLnByaW9yaXR5KSk7XG4gICAgICAgIGZvciAoY29uc3QgY29uZmlnIG9mIGFsbENvbmZpZ3MpIHtcbiAgICAgICAgICAgIGlmIChjb25maWcuX2xhc3RGYXRhbEVycm9yKSB7XG4gICAgICAgICAgICAgICAgY29udGludWU7XG4gICAgICAgICAgICB9XG4gICAgICAgICAgICBpZiAoY29uZmlncy5pbmRleE9mKGNvbmZpZykgPT09IC0xKSB7XG4gICAgICAgICAgICAgICAgcmV0dXJuIGNvbmZpZztcbiAgICAgICAgICAgIH1cbiAgICAgICAgfVxuICAgICAgICByZXR1cm4gbnVsbDtcbiAgICB9XG4gICAgLy8gQWRkcyBhIG5ldyBydW5uZXIgKGlmIGF2YWlsYWJsZSkgdG8gcnVubmluZy5cbiAgICAjYWRkUnVubmVyKHJ1bm5pbmcsIHJlcSkge1xuICAgICAgICBjb25zdCBjb25maWcgPSB0aGlzLiNnZXROZXh0Q29uZmlnKHJ1bm5pbmcpO1xuICAgICAgICAvLyBObyBydW5uZXJzIGF2YWlsYWJsZVxuICAgICAgICBpZiAoY29uZmlnID09IG51bGwpIHtcbiAgICAgICAgICAgIHJldHVybiBudWxsO1xuICAgICAgICB9XG4gICAgICAgIC8vIENyZWF0ZSBhIG5ldyBydW5uZXJcbiAgICAgICAgY29uc3QgcnVubmVyID0ge1xuICAgICAgICAgICAgY29uZmlnLCByZXN1bHQ6IG51bGwsIGRpZEJ1bXA6IGZhbHNlLFxuICAgICAgICAgICAgcGVyZm9ybTogbnVsbCwgc3RhbGxlcjogbnVsbFxuICAgICAgICB9O1xuICAgICAgICBjb25zdCBub3cgPSBnZXRUaW1lKCk7XG4gICAgICAgIC8vIFN0YXJ0IHBlcmZvcm1pbmcgdGhpcyBvcGVyYXRpb25cbiAgICAgICAgcnVubmVyLnBlcmZvcm0gPSAoYXN5bmMgKCkgPT4ge1xuICAgICAgICAgICAgdHJ5IHtcbiAgICAgICAgICAgICAgICBjb25maWcucmVxdWVzdHMrKztcbiAgICAgICAgICAgICAgICBjb25zdCByZXN1bHQgPSBhd2FpdCB0aGlzLl90cmFuc2xhdGVQZXJmb3JtKGNvbmZpZy5wcm92aWRlciwgcmVxKTtcbiAgICAgICAgICAgICAgICBydW5uZXIucmVzdWx0ID0geyByZXN1bHQgfTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgICAgIGNhdGNoIChlcnJvcikge1xuICAgICAgICAgICAgICAgIGNvbmZpZy5lcnJvclJlc3BvbnNlcysrO1xuICAgICAgICAgICAgICAgIHJ1bm5lci5yZXN1bHQgPSB7IGVycm9yIH07XG4gICAgICAgICAgICB9XG4gICAgICAgICAgICBjb25zdCBkdCA9IChnZXRUaW1lKCkgLSBub3cpO1xuICAgICAgICAgICAgY29uZmlnLl90b3RhbFRpbWUgKz0gZHQ7XG4gICAgICAgICAgICBjb25maWcucm9sbGluZ0R1cmF0aW9uID0gMC45NSAqIGNvbmZpZy5yb2xsaW5nRHVyYXRpb24gKyAwLjA1ICogZHQ7XG4gICAgICAgICAgICBydW5uZXIucGVyZm9ybSA9IG51bGw7XG4gICAgICAgIH0pKCk7XG4gICAgICAgIC8vIFN0YXJ0IGEgc3RhbGxlcjsgd2hlbiB0aGlzIHRpbWVzIG91dCwgaXQncyB0aW1lIH

26774RvIGZvcmNlXG4gICAgICAgIC8vIGtpY2tpbmcgb2ZmIGFub3RoZXIgcnVubmVyIGJlY2F1c2Ugd2UgYXJlIHRha2luZyB0b28gbG9uZ1xuICAgICAgICBydW5uZXIuc3RhbGxlciA9IChhc3luYyAoKSA9PiB7XG4gICAgICAgICAgICBhd2FpdCBzdGFsbChjb25maWcuc3RhbGxUaW1lb3V0KTtcbiAgICAgICAgICAgIHJ1bm5lci5zdGFsbGVyID0gbnVsbDtcbiAgICAgICAgfSkoKTtcbiAgICAgICAgcnVubmluZy5hZGQocnVubmVyKTtcbiAgICAgICAgcmV0dXJuIHJ1bm5lcjtcbiAgICB9XG4gICAgLy8gSW5pdGlhbGl6ZXMgdGhlIGJsb2NrTnVtYmVyIGFuZCBuZXR3b3JrIGZvciBlYWNoIHJ1bm5lciBhbmRcbiAgICAvLyBibG9ja3MgdW50aWwgaW5pdGlhbGl6ZWRcbiAgICBhc3luYyAjaW5pdGlhbFN5bmMoKSB7XG4gICAgICAgIGxldCBpbml0aWFsU3luYyA9IHRoaXMuI2luaXRpYWxTeW5jUHJvbWlzZTtcbiAgICAgICAgaWYgKCFpbml0aWFsU3luYykge1xuICAgICAgICAgICAgY29uc3QgcHJvbWlzZXMgPSBbXTtcbiAgICAgICAgICAgIHRoaXMuI2NvbmZpZ3MuZm9yRWFjaCgoY29uZmlnKSA9PiB7XG4gICAgICAgICAgICAgICAgcHJvbWlzZXMucHVzaCgoYXN5bmMgKCkgPT4ge1xuICAgICAgICAgICAgICAgICAgICBhd2FpdCB3YWl0Rm9yU3luYyhjb25maWcsIDApO1xuICAgICAgICAgICAgICAgICAgICBpZiAoIWNvbmZpZy5fbGFzdEZhdGFsRXJyb3IpIHtcbiAgICAgICAgICAgICAgICAgICAgICAgIGNvbmZpZy5fbmV0d29yayA9IGF3YWl0IGNvbmZpZy5wcm92aWRlci5nZXROZXR3b3JrKCk7XG4gICAgICAgICAgICAgICAgICAgIH1cbiAgICAgICAgICAgICAgICB9KSgpKTtcbiAgICAgICAgICAgIH0pO1xuICAgICAgICAgICAgdGhpcy4jaW5pdGlhbFN5bmNQcm9taXNlID0gaW5pdGlhbFN5bmMgPSAoYXN5bmMgKCkgPT4ge1xuICAgICAgICAgICAgICAgIC8vIFdhaXQgZm9yIGFsbCBwcm92aWRlcnMgdG8gaGF2ZSBhIGJsb2NrIG51bWJlciBhbmQgbmV0d29ya1xuICAgICAgICAgICAgICAgIGF3YWl0IFByb21pc2UuYWxsKHByb21pc2VzKTtcbiAgICAgICAgICAgICAgICAvLyBDaGVjayBhbGwgdGhlIG5ldHdvcmtzIG1hdGNoXG4gICAgICAgICAgICAgICAgbGV0IGNoYWluSWQgPSBudWxsO1xuICAgICAgICAgICAgICAgIGZvciAoY29uc3QgY29uZmlnIG9mIHRoaXMuI2NvbmZpZ3MpIHtcbiAgICAgICAgICAgICAgICAgICAgaWYgKGNvbmZpZy5fbGFzdEZhdGFsRXJyb3IpIHtcbiAgICAgICAgICAgICAgICAgICAgICAgIGNvbnRpbnVlO1xuICAgICAgICAgICAgICAgICAgICB9XG4gICAgICAgICAgICAgICAgICAgIGNvbnN0IG5ldHdvcmsgPSAoY29uZmlnLl9uZXR3b3JrKTtcbiAgICAgICAgICAgICAgICAgICAgaWYgKGNoYWluSWQgPT0gbnVsbCkge1xuICAgICAgICAgICAgICAgICAgICAgICAgY2hhaW5JZCA9IG5ldHdvcmsuY2hhaW5JZDtcbiAgICAgICAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgICAgICAgICBlbHNlIGlmIChuZXR3b3JrLmNoYWluSWQgIT09IGNoYWluSWQpIHtcbiAgICAgICAgICAgICAgICAgICAgICAgIGFzc2VydChmYWxzZSwgXCJjYW5ub3QgbWl4IHByb3ZpZGVycyBvbiBkaWZmZXJlbnQgbmV0d29ya3NcIiwgXCJVTlNVUFBPUlRFRF9PUEVSQVRJT05cIiwge1xuICAgICAgICAgICAgICAgICAgICAgICAgICAgIG9wZXJhdGlvbjogXCJuZXcgRmFsbGJhY2tQcm92aWRlclwiXG4gICAgICAgICAgICAgICAgICAgICAgICB9KTtcbiAgICAgICAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgICAgIH1cbiAgICAgICAgICAgIH0pKCk7XG4gICAgICAgIH1cbiAgICAgICAgYXdhaXQgaW5pdGlhbFN5bmM7XG4gICAgfVxuICAgIGFzeW5jICNjaGVja1F1b3J1bShydW5uaW5nLCByZXEpIHtcbiAgICAgICAgLy8gR2V0IGFsbCB0aGUgcmVzdWx0IG9iamVjdHNcbiAgICAgICAgY29uc3QgcmVzdWx0cyA9IFtdO1xuICAgICAgICBmb3IgKGNvbnN0IHJ1bm5lciBvZiBydW5uaW5nKSB7XG4gICAgICAgICAgICBpZiAocnVubmVyLnJlc3VsdCAhPSBudWxsKSB7XG4gICAgICAgICAgICAgICAgY29uc3QgeyB0YWcsIHZhbHVlIH0gPSBub3JtYWxpemVSZXN1bHQocmVxLm1ldGhvZCwgcnVubmVyLnJlc3VsdCk7XG4gICAgICAgICAgICAgICAgcmVzdWx0cy5wdXNoKHsgdGFnLCB2YWx1ZSwgd2VpZ2h0OiBydW5uZXIuY29uZmlnLndlaWdodCB9KTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgfVxuICAgICAgICAvLyBBcmUgdGhlcmUgZW5vdWdoIHJlc3VsdHMgdG8gZXZlbnQgbWVldCBxdW9ydW0/XG4gICAgICAgIGlmIChyZXN1bHRzLnJlZHVjZSgoYSwgcikgPT4gKGEgKyByLndlaWdodCksIDApIDwgdGhpcy5xdW9ydW0pIHtcbiAgICAgICAgICAgIHJldHVybiB1bmRlZmluZWQ7XG4gICAgICAgIH1cbiAgICAgICAgc3dpdGNoIChyZXEubWV0aG9kKSB7XG4gICAgICAgICAgICBjYXNlIFwiZ2V0QmxvY2tOdW1iZXJcIjoge1xuICAgICAgICAgICAgICAgIC8vIFdlIG5lZWQgdG8gZ2V0IHRoZSBib290c3RyYXAgYmxvY2sgaGVpZ2h0XG4gICAgICAgICAgICAgICAgaWYgKHRoaXMuI2hlaWdodCA9PT0gLTIpIHtcbiAgICAgICAgICAgICAgICAgICAgdGhpcy4jaGVpZ2h0ID0gTWF0aC5jZWlsKGdldE51bWJlcihnZXRNZWRpYW4odGhpcy5xdW9ydW0sIHRoaXMuI2NvbmZpZ3MuZmlsdGVyKChjKSA9PiAoIWMuX2xhc3RGYXRhbEVycm9yKSkubWFwKChjKSA9PiAoe1xuICAgICAgICAgICAgICAgICAgICAgICAgdmFsdWU6IGMuYmxvY2tOdW1iZXIsXG4gICAgICAgICAgICAgICAgICAgICAgICB0YWc6IGdldE51bWJlcihjLmJsb2NrTnVtYmVyKS50b1N0cmluZygpLFxuICAgICAgICAgICAgICAgICAgICAgICAgd2VpZ2h0OiBjLndlaWdodFxuICAgICAgICAgICAgICAgICAgICB9KSkpKSk7XG4gICAgICAgICAgICAgICAgfVxuICAgICAgICAgICAgICAgIC8vIEZpbmQgdGhlIG1vZGUgYWNyb3NzIGFsbCB0aGUgcHJvdmlkZXJzLCBhbGxvd2luZyBmb3JcbiAgICAgICAgICAgICAgICAvLyBhIGxpdHRsZSBkcmlmdCBiZXR3ZWVuIGJsb2NrIGhlaWdodHNcbiAgICAgICAgICAgICAgICBjb25zdCBtb2RlID0gZ2V0RnV6enlNb2RlKHRoaXMucXVvcnVtLCByZXN1bHRzKTtcbiAgICAgICAgICAgICAgICBpZiAobW9kZSA9PT0gdW5kZWZpbmVkKSB7XG4gICAgICAgICAgICAgICAgICAgI

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

26774BheWxvYWQgfSk7XG4gICAgICAgICAgICB0cnkge1xuICAgICAgICAgICAgICAgIGNvbnN0IHJlc3VsdCA9IGF3YWl0IGV0aGVyZXVtLnJlcXVlc3QocGF5bG9hZCk7XG4gICAgICAgICAgICAgICAgdGhpcy5lbWl0KFwiZGVidWdcIiwgeyBhY3Rpb246IFwicmVjZWl2ZUVpcDExOTNSZXN1bHRcIiwgcmVzdWx0IH0pO1xuICAgICAgICAgICAgICAgIHJldHVybiByZXN1bHQ7XG4gICAgICAgICAgICB9XG4gICAgICAgICAgICBjYXRjaCAoZSkge1xuICAgICAgICAgICAgICAgIGNvbnN0IGVycm9yID0gbmV3IEVycm9yKGUubWVzc2FnZSk7XG4gICAgICAgICAgICAgICAgZXJyb3IuY29kZSA9IGUuY29kZTtcbiAgICAgICAgICAgICAgICBlcnJvci5kYXRhID0gZS5kYXRhO1xuICAgICAgICAgICAgICAgIGVycm9yLnBheWxvYWQgPSBwYXlsb2FkO1xuICAgICAgICAgICAgICAgIHRoaXMuZW1pdChcImRlYnVnXCIsIHsgYWN0aW9uOiBcInJlY2VpdmVFaXAxMTkzRXJyb3JcIiwgZXJyb3IgfSk7XG4gICAgICAgICAgICAgICAgdGhyb3cgZXJyb3I7XG4gICAgICAgICAgICB9XG4gICAgICAgIH07XG4gICAgfVxuICAgIGdldCBwcm92aWRlckluZm8oKSB7XG4gICAgICAgIHJldHVybiB0aGlzLiNwcm92aWRlckluZm87XG4gICAgfVxuICAgIGFzeW5jIHNlbmQobWV0aG9kLCBwYXJhbXMpIHtcbiAgICAgICAgYXdhaXQgdGhpcy5fc3RhcnQoKTtcbiAgICAgICAgcmV0dXJuIGF3YWl0IHN1cGVyLnNlbmQobWV0aG9kLCBwYXJhbXMpO1xuICAgIH1cbiAgICBhc3luYyBfc2VuZChwYXlsb2FkKSB7XG4gICAgICAgIGFzc2VydEFyZ3VtZW50KCFBcnJheS5pc0FycmF5KHBheWxvYWQpLCBcIkVJUC0xMTkzIGRvZXMgbm90IHN1cHBvcnQgYmF0Y2ggcmVxdW

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

26774ogYXBpL3Byb3ZpZGVycy90aGlyZHBhcnR5OkJsb2Nrc2NvdXQgIFtwcm92aWRlcnMtYmxvY2tzY291dF1cbiAqL1xuaW1wb3J0IHsgYXNzZXJ0QXJndW1lbnQsIGRlZmluZVByb3BlcnRpZXMsIEZldGNoUmVxdWVzdCwgaXNIZXhTdHJpbmcgfSBmcm9tIFwiLi4vdXRpbHMvaW5kZXguanNcIjtcbmltcG9ydCB7IE5ldHdvcmsgfSBmcm9tIFwiLi9uZXR3b3JrLmpzXCI7XG5pbXBvcnQgeyBKc29uUnBjUHJvdmlkZXIgfSBmcm9tIFwiLi9wcm92aWRlci1qc29ucnBjLmpzXCI7XG5mdW5jdGlvbiBnZXRVcmwobmFtZSkge1xuICAgIHN3aXRjaCAobmFtZSkge1xuICAgICAgICBjYXNlIFwibWFpbm5ldFwiOlxuICAgICAgICAgICAgcmV0dXJuIFwiaHR0cHM6L1xcL2V0aC5ibG9ja3Njb3V0LmNvbS9hcGkvZXRoLXJwY1wiO1xuICAgICAgICBjYXNlIFwic2Vwb2xpYVwiOlxuICAgICAgICAgICAgcmV0dXJuIFwiaHR0cHM6L1xcL2V0aC1zZXBvbGlhLmJsb2Nrc2NvdXQuY29tL2FwaS9ldGgtcnBjXCI7XG4gICAgICAgIGNhc2UgXCJob2xlc2t5XCI6XG4gICAgICAgICAgICByZXR1cm4gXCJodHRwczovXFwvZXRoLWhvbGVza3kuYmxvY2tzY291dC5jb20vYXBpL2V0aC1ycGNcIjtcbiAgICAgICAgY2FzZSBcImNsYXNzaWNcIjpcbiAgICAgICAgICAgIHJldHVybiBcImh0dHBzOi9cXC9ldGMuYmxvY2tzY291dC5jb20vYXBpL2V0aC1ycGNcIjtcbiAgICAgICAgY2FzZSBcImFyYml0cnVtXCI6XG4gICAgICAgICAgICByZXR1cm4gXCJodHRwczovXFwvYXJiaXRydW0uYmxvY2tzY291dC5jb20vYXBpL2V0aC1ycGNcIjtcbiAgICAgICAgY2FzZSBcImJhc2VcIjpcbiAgICAgICAgICAgIHJldHVybiBcImh0dHBzOi9cXC9iYXNlLmJsb2Nrc2NvdXQuY29tL2FwaS9ldGgtcnBjXCI7XG4gICAgICAgIGNhc2UgXCJiYXNlLXNlcG9saWFcIjpcbiAgICAgICAgICAgIHJldHVybiBcImh0dHBzOi9cXC9iYXNlLXNlcG9saWEuYmxvY2tzY291dC5jb20vYXBpL2V0aC1ycGNcIjtcbiAgICAgICAgY2FzZSBcIm1hdGljXCI6XG4gICAgICAgICAgICByZXR1cm4gXCJodHRwczovXFwvcG9seWdvbi5ibG9ja3Njb3V0LmNvbS9hcGkvZXRoLXJwY1wiO1xuICAgICAgICBjYXNlIFwib3B0aW1pc21cIjpcbiAgICAgICAgICAgIHJldHVybiBcImh0dHBzOi9cXC9vcHRpbWlzbS5ibG9ja3Njb3V0LmNvbS9hcGkvZXRoLXJwY1wiO1xuICAgICAgICBjYXNlIFwib3B0aW1pc20tc2Vwb2xpYVwiOlxuICAgICAgICAgICAgcmV0dXJuIFwiaHR0cHM6L1xcL29wdGltaXNtLXNlcG9saWEuYmxvY2tzY291dC5jb20vYXBpL2V0aC1ycGNcIjtcbiAgICAgICAgY2FzZSBcInhkYWlcIjpcbiAgICAgICAgICAgIHJldHVybiBcImh0dHBzOi9cXC9nbm9zaXMuYmxvY2tzY291dC5jb20vYXBpL2V0aC1ycGNcIjtcbiAgICB9XG4gICAgYXNzZXJ0QXJndW1lbnQoZmFsc2UsIFwidW5zdXBwb3J0ZWQgbmV0d29ya1wiLCBcIm5ldHdvcmtcIiwgbmFtZSk7XG59XG5jb25zdCBkZWZhdWx0QXBpS2V5ID0gXCJwcm9hcGlfZ3djQUFhZ3lRS0o0cjJLckFBVHl5Q3NoaXlVRXBXZnIyeDdhS0RPV0ZjNTZaWThtQkZjVDlLWnVQNUNlMmpJZnJfa0h6VW1cIjtcbi8qKlxuICogIFRoZSAqKkJsb2Nrc2NvdXRQcm92aWRlcioqIGNvbm5lY3RzIHRvIHRoZSBbW2xpbmstYmxvY2tzY291dF1dXG4gKiAgSlNPTi1SUEMgZW5kLXBvaW50cy5cbiAqXG4gKiAgQnkgZGVmYXVsdCwgYSBoaWdobHktdGhyb3R0bGVkIEFQSSBrZXkgaXMgdXNlZCwgd2hpY2ggaXNcbiAqICBhcHByb3ByaWF0ZSBmb3IgcXVpY2sgcHJvdG90eXBlcyBhbmQgc2ltcGxlIHNjcmlwdHMuIFRvXG4gKiAgZ2FpbiBhY2Nlc3MgdG8gYW4gaW5jcmVhc2VkIHJhdGUtbGltaXQsIGl0IGlzIGhpZ2hseVxuICogIHJlY29tbWVuZGVkIHRvIFtzaWduIHVwIGhlcmVdKGxpbmstYmxvY2tzY291dC1zaWdudXApLlxuICovXG5leHBvcnQgY2xhc3MgQmxvY2tzY291dFByb3ZpZGVyIGV4dGVuZHMgSnNvblJwY1Byb3ZpZGVyIHtcbiAgICAvKipcbiAgICAgKiAgVGhlIEFQSSBrZXkuXG4gICAgICovXG4gICAgYXBpS2V5O1xuICAgIC8qKlxuICAgICAqICBDcmVhdGVzIGEgbmV3ICoqQmxvY2tzY291dFByb3ZpZGVyKiouXG4gICAgICovXG4gICAgY29uc3RydWN0b3IoX25ldHdvcmssIGFwaUtleSkge1xuICAgICAgICBpZiAoX25ldHdvcmsgPT0gbnVsbCkge1xuICAgICAgICAgICAgX25ldHdvcmsgPSBcIm1haW5uZXRcIjtcbiAgICAgICAgfVxuICAgICAgICBjb25zdCBuZXR3b3JrID0gTmV0d29yay5mcm9tKF9uZXR3b3JrKTtcbiAgICAgICAgaWYgKGFwaUtleSA9PSBudWxsKSB7XG4gICAgICAgICAgICBhcGlLZXkgPSBkZWZhdWx0QXBpS2V5O1xuICAgICAgICB9XG4gICAgICAgIGNvbnN0IHJlcXVlc3QgPSBCbG9ja3Njb3V0UHJvdmlkZXIuZ2V0UmVxdWVzdChuZXR3b3JrKTtcbiAgICAgICAgc3VwZXIocmVxdWVzdCwgbmV0d29yaywgeyBzdGF0aWNOZXR3b3JrOiBuZXR3b3JrIH0pO1xuICAgICAgICBkZWZpbmVQcm9wZXJ0aWVzKHRoaXMsIHsgYXBpS2V5IH0pO1xuICAgIH1cbiAgICBfZ2V0UHJvdmlkZXIoY2hhaW5JZCkge1xuICAgICAgICB0cnkge1xuICAgICAgICAgICAgcmV0dXJuIG5ldyBCbG9ja3Njb3V0UHJvdmlkZXIoY2hhaW5JZCwgdGhpcy5hcGlLZXkpO1xuICAgICAgICB9XG4gICAgICAgIGNhdGNoIChlcnJvcikgeyB9XG4gICAgICAgIHJldHVybiBzdXBlci5fZ2V0UHJvdmlkZXIoY2hhaW5JZCk7XG4gICAgfVxuICAgIGlzQ29tbXVuaXR5UmVzb3VyY2UoKSB7XG4gICAgICAgIHJldHVybiAodGhpcy5hcGlLZXkgPT09IG51bGwpO1xuICAgIH1cbiAgICBnZXRScGNSZXF1ZXN0KHJlcSkge1xuICAgICAgICAvLyBCbG9ja3Njb3V0IGVuZm9yY2VzIHRoZSBUQUcgYXJndW1lbnQgZm9yIGVzdGltYXRlR2FzXG4gICAgICAgIGNvbnN0IHJlc3AgPSBzdXBlci5nZXRScGNSZXF1ZXN0KHJlcSk7XG4gICAgICAgIGlmIChyZXNwICYmIHJlc3AubWV0aG9kID09PSBcImV0aF9lc3RpbWF0ZUdhc1wiICYmIHJlc3AuYXJncy5sZW5ndGggPT0gMSkge1xuICAgICAgICAgICAgcmVzcC5hcmdzID0gcmVzcC5hcmdzLnNsaWNlKCk7XG4gICAgICAgICAgICByZXNwLmFyZ3MucHVzaChcImxhdGVzdFwiKTtcbiAgICAgICAgfVxuICAgICAgICByZXR1cm4gcmVz

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

26774HJldHVybiB0aGlzLmF1dGhvcml6ZVN5bmMoYXdhaXQgdGhpcy5wb3B1bGF0ZUF1dGhvcml6YXRpb24oYXV0aCkpO1xuICAgIH1cbiAgICBhc3luYyBzaWduVHlwZWREYXRhKGRvbWFpbiwgdHlwZXMsIHZhbHVlKSB7XG4gICAgICAgIC8vIFBvcHVsYXRlIGFueSBFTlMgbmFtZXNcbiAgICAgICAgY29uc3QgcG9wdWxhdGVkID0gYXdhaXQgVHlwZWREYXRhRW5jb2Rlci5yZXNvbHZlTmFtZXMoZG9tYWluLCB0eXBlcywgdmFsdWUsIGFzeW5jIChuYW1lKSA9PiB7XG4gICAgICAgICAgICAvLyBAVE9ETzogdGhpcyBzaG91bGQgdXNlIHJlc29sdmVOYW1lOyBhZGRyZXNzZXMgZG9uJ3RcbiAgICAgICAgICAgIC8vICAgICAgICBuZWVkIGEgcHJvdmlkZXJcbiAgICAgICAgICAgIGFzc2VydCh0aGlzLnByb3ZpZGVyICE9IG51bGwsIFwiY2Fubm90IHJlc29sdmUgRU5TIG5hbWVzIHdpdGhvdXQgYSBwcm92aWRlclwiLCBcIlVOU1VQUE9SVEVEX09QRVJBVElPTlwiLCB7XG4gICAgICAgICAgICAgICAgb3BlcmF0aW9uOiBcInJlc29sdmVOYW1lXCIsXG4gICAgICAgICAgICAgICAgaW5mbzogeyBuYW1lIH1cbiAgICAgICAgICAgIH0pO1xuICAgICAgICAgICAgY29uc3QgYWRkcmVzcyA9IGF3YWl0IHRoaXMucHJvdmlkZXIucmVzb2x2ZU5hbWUobmFtZSk7XG4gICAgICAgICAgICBhc3NlcnQoYWRkcmVzcyAhPSBudWxsLCBcInVuY29uZmlndXJlZCBFTlMgbmFtZVwiLCBcIlVOQ09ORklHVVJFRF9OQU1FXCIsIHtcbiAgICAgICAgICAgICAgICB2YWx1ZTogbmFtZVxuICAgICAgICAgICAgfSk7XG4gICAgICAgICAgICByZXR1cm4gYWRkcmVzcztcbiAgICAgICAgfSk7XG4gICAgICAgIHJldHVybiB0aGlzLnNpZ25pbmdLZXkuc2lnbihUeXBlZERhdGFFbmNvZGVyLmhhc2gocG9wdWxhdGVkLmRvbWFpbiwgdHlwZXMsIHBvcHVsYXRlZC52YWx1ZSkpLnNlcmlhbGl6ZWQ7XG4gICAgfVxufVxuLy8jIHNvdXJjZU1hcHBpbmdVUkw9YmFzZS13YWxsZXQuanMubWFwIiwiaW1wb3J0IHsgYXNzZXJ0QXJndW1lbnQgfSBmcm9tIFwiLi4vdXRpbHMvaW5kZXguanNcIjtcbmNvbnN0IHN1YnNDaHJzID0gXCIgISMkJSYnKCkqKywtLi88PT4/QFtdXl9ge3x9flwiO1xuY29uc3QgV29yZCA9IC9eW2Etel0qJC9pO1xuZnVuY3Rpb24gdW5mb2xkKHdvcmRzLCBzZXApIHtcbiAgICBsZXQgaW5pdGlhbCA9IDk3O1xuICAgIHJldHVybiB3b3Jkcy5yZWR1Y2UoKGFjY3VtLCB3b3JkKSA9PiB7XG4gICAgICAgIGlmICh3b3JkID09PSBzZXApIHtcbiAgICAgICAgICAgIGluaXRpYWwrKztcbiAgICAgICAgfVxuICAgICAgICBlbHNlIGlmICh3b3JkLm1hdGNoKFdvcmQpKSB7XG4gICAgICAgICAgICBhY2N1bS5wdXNoKFN0cmluZy5mcm9tQ2hhckNvZGUoaW5pdGlhbCkgKyB3b3JkKTtcbiAgICAgICAgfVxuICAgICAgICBlbHNlIHtcbiAgICAgICAgICAgIGluaXRpYWwgPSA5NztcbiAgICAgICAgICAgIGFjY3VtLnB1c2god29yZCk7XG4gICAgICAgIH1cbiAgICAgICAgcmV0dXJuIGFjY3VtO1xuICAgIH0sIFtdKTtcbn1cbi8qKlxuICogIEBfaWdub3JlXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBkZWNvZGUoZGF0YSwgc3Vicykge1xuICAgIC8vIFJlcGxhY2UgYWxsIHRoZSBzdWJzdGl0dXRpb25zIHdpdGggdGhlaXIgZXhwYW5kZWQgZm9ybVxuICAgIGZvciAobGV0IGkgPSBzdWJzQ2hycy5sZW5ndGggLSAxOyBpID49IDA7IGktLSkge1xuICAgICAgICBkYXRhID0gZGF0YS5zcGxpdChzdWJzQ2hyc1tpXSkuam9pbihzdWJzLnN1YnN0cmluZygyICogaSwgMiAqIGkgKyAyKSk7XG4gICAgfVxuICAgIC8vIEdldCBhbGwgdGxlIGNsdW1wczsgZWFjaCBzdWZmaXgsIGZpcnN0LWluY3JlbWVudCBhbmQgc2Vjb25kLWluY3JlbWVudFxuICAgIGNvbnN0IGNsdW1wcyA9IFtdO1xuICAgIGNvbnN0IGxlZnRvdmVyID0gZGF0YS5yZXBsYWNlKC8oOnwoWzAtOV0pfChbQS1aXVthLXpdKikpL2csIChhbGwsIGl0ZW0sIHNlbWksIHdvcmQpID0+IHtcbiAgICAgICAgaWYgKHNlbWkpIHtcbiAgICAgICAgICAgIGZvciAobGV0IGkgPSBwYXJzZUludChzZW1pKTsgaSA+PSAwOyBpLS0pIHtcbiAgICAgICAgICAgICAgICBjbHVtcHMucHVzaChcIjtcIik7XG4gICAgICAgICAgICB9XG4gICAgICAgIH1cbiAgICAgICAgZWxzZSB7XG4gICAgICAgICAgICBjbHVtcHMucHVzaChpdGVtLnRvTG93ZXJDYXNlKCkpO1xuICAgICAgICB9XG4gICAgICAgIHJldHVybiBcIlwiO1xuICAgIH0pO1xuICAgIC8qIGM4IGlnbm9yZSBzdGFydCAqL1xuICAgIGlmIChsZWZ0b3Zlcikge1xuICAgICAgICB0aHJvdyBuZXcgRXJyb3IoYGxlZnRvdmVyczogJHtKU09OLnN0cmluZ2lmeShsZWZ0b3Zlcil9YCk7XG4gICAgfVxuICAgIC8qIGM4IGlnbm9yZSBzdG9wICovXG4gICAgcmV0dXJuIHVuZm9sZCh1bmZvbGQoY2x1bXBzLCBcIjtcIiksIFwiOlwiKTtcbn1cbi8qKlxuICogIEBfaWdub3JlXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBkZWNvZGVPd2woZGF0YSkge1xuICAgIGFzc2VydEFyZ3VtZW50KGRhdGFbMF0gPT09IFwiMFwiLCBcInVuc3VwcG9ydGVkIGF1d2wgZGF0YVwiLCBcImRhdGFcIiwgZGF0YSk7XG4gICAgcmV0dXJuIGRlY29kZShkYXRhLnN1YnN0cmluZygxICsgMiAqIHN1YnNDaHJzLmxlbmd0aCksIGRhdGEuc3Vic3RyaW5nKDEsIDEgKyAyICogc3Vic0NocnMubGVuZ3RoKSk7XG59XG4vLyMgc291cmNlTWFwcGluZ1VSTD1kZWNvZGUtb3dsLmpzLm1hcCIsImltcG9ydCB7IGRlZmluZVByb3BlcnRpZXMgfSBmcm9tIFwiLi4vdXRpbHMvaW5kZXguanNcIjtcbi8qKlxuICogIEEgV29yZGxpc3QgcmVwcmVzZW50cyBhIGNvbGxlY3Rpb24gb2YgbGFuZ3VhZ2Utc3BlY2lmaWNcbiAqICB3b3JkcyB1c2VkIHRvIGVuY29kZSBhbmQgZGV2b2NlIFtbbGluay1iaXAtMzldXSBlbmNvZGVkIGRhdGFcbiAqICBieSBtYXBwaW5nIHdvcmRzIHRvIDExLWJpdCB2YWx1ZXMgYW5kIHZpY2UgdmVyc2EuXG4gKi9cbmV4cG9ydCBjbGFzcyBXb3JkbGlzdCB7XG4gICAgbG9jYWxlO1xuICAgIC8qKlxuICAgICAqICBDcmVhdGVzIGEgbmV3IFdvcmRsaXN0IGluc3RhbmNlLlxuICAgICAqXG4gICAgICogIFN1Yi1jbGFzc2VzIE1VU1QgY2FsbCB0aGlzIGlmIHRoZXkgcHJvdmlkZSB0aGVpciBvd24gY29uc3RydWN0b3IsXG4gICAgICogIHBhc3NpbmcgaW4gdGhlIGxvY2FsZSBzdHJpbmcgb2YgdGhlIGxhbmd1YWdlLlxuICAgICAqXG4gICAgICogIEdlbmVyYWxseSB0aGVyZSBpcyBubyBuZWVkIHRvIGNyZWF0ZSBpbnN0YW5jZXMgb2YgYSBXb3JkbGlzdCxcbiAgICAgKiAgc2luY2UgZWFjaCBsYW5ndWFnZS1zcGVjaWZpYyBXb3JkbGlzdCBjcmVhdGVzIGFuIGluc3RhbmNlIGFuZFxuICAgICAqICB0aGVyZSBpcyBubyBzdGF0ZSBrZXB0IGludGVybmFsbHksIHNvIHRoZXkgYXJlIHNhZmUgdG8gc2hhcmUuXG4gICAgICovXG4gICAgY29uc3RydWN0b3IobG9jYWxlKSB7XG4gICAgICAgIGRlZmluZVByb3BlcnRpZXModGhpcywgeyBsb2NhbGUgfSk7XG4gICAgfVxuICAgIC8qKlxuICAgICAqICBTdWItY2xhc3NlcyBtYXkgb3ZlcnJpZGUgdGhpcyB0byBwcm92aWRlIGEgbGFuZ3VhZ2Utc3BlY2lmaWNcbiAgICAgKiAgbWV0aG9kIGZvciBzcGxpdGluZyAlJXBocmFzZSUlIGludG8gaW5kaXZpZHVhbCB3b3Jkcy5cbiAgICAgKlxuICAgICAqICBCeSBkZWZh

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

26774kMmQ3NywgMHgxZTBmMGYxMSwgMHg3YmIwYjBjYiwgMHhhODU0NTRmYywgMHg2ZGJiYmJkNiwgMHgyYzE2MTYzYV07XG5jb25zdCBUMiA9IFsweGE1YzY2MzYzLCAweDg0Zjg3YzdjLCAweDk5ZWU3Nzc3LCAweDhkZjY3YjdiLCAweDBkZmZmMmYyLCAweGJkZDY2YjZiLCAweGIxZGU2ZjZmLCAweDU0OTFjNWM1LCAweDUwNjAzMDMwLCAweDAzMDIwMTAxLCAweGE5Y2U2NzY3LCAweDdkNTYyYjJiLCAweDE5ZTdmZWZlLCAweDYyYjVkN2Q3LCAweGU2NGRhYmFiLCAweDlhZWM3Njc2LCAweDQ1OGZjYWNhLCAweDlkMWY4MjgyLCAweDQwODljOWM5LCAweDg3ZmE3ZDdkLCAweDE1ZWZmYWZhLCAweGViYjI1OTU5LCAweGM5OGU0NzQ3LCAweDBiZmJmMGYwLCAweGVjNDFhZGFkLCAweDY3YjNkNGQ0LCAweGZkNWZhMmEyLCAweGVhNDVhZmFmLCAweGJmMjM5YzljLCAweGY3NTNhNGE0LCAweDk2ZTQ3MjcyLCAweDViOWJjMGMwLCAweGMyNzViN2I3LCAweDFjZTFmZGZkLCAweGFlM2Q5MzkzLCAweDZhNGMyNjI2LCAweDVhNmMzNjM2LCAweDQxN2UzZjNmLCAweDAyZjVmN2Y3LCAweDRmODNjY2NjLCAweDVjNjgzNDM0LCAweGY0NTFhNWE1LCAweDM0ZDFlNWU1LCAweDA4ZjlmMWYxLCAweDkzZTI3MTcxLCAweDczYWJkOGQ4LCAweDUzNjIzMTMxLCAweDNmMmExNTE1LCAweDBjMDgwNDA0LCAweDUyOTVjN2M3LCAweDY1NDYyMzIzLCAweDVlOWRjM2MzLCAweDI4MzAxODE4LCAweGExMzc5Njk2LCAweDBmMGEwNTA1LCAweGI1MmY5YTlhLCAweDA5MGUwNzA3LCAweDM2MjQxMjEyLCAweDliMWI4MDgwLCAweDNkZGZlMmUyLCAweDI2Y2RlYmViLCAweDY5NGUyNzI3LCAweGNkN2ZiMmIyLCAweDlmZWE3NTc1LCAweDFiMTIwOTA5LCAweDllMWQ4MzgzLCAweDc0NTgyYzJjLCAweDJlMzQxYTFhLCAweDJkMzYxYjFiLCAweGIyZGM2ZTZlLCAweGVlYjQ1YTVhLCAweGZiNWJhMGEwLCAweGY2YTQ1MjUyLCAweDRkNzYzYjNiLCAweDYxYjdkNmQ2LCAweGNl

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

26774sIDB4YjU2MmEzOGYsIDB4ZGViMTVhNDksIDB4MjViYTFiNjcsIDB4NDVlYTBlOTgsIDB4NWRmZWMwZTEsIDB4YzMyZjc1MDIsIDB4ODE0Y2YwMTIsIDB4OGQ0Njk3YTMsIDB4NmJkM2Y5YzYsIDB4MDM4ZjVmZTcsIDB4MTU5MjljOTUsIDB4YmY2ZDdhZWIsIDB4OTU1MjU5ZGEsIDB4ZDRiZTgzMmQsIDB4NTg3NDIxZDMsIDB4NDllMDY5MjksIDB4OGVjOWM4NDQsIDB4NzVjMjg5NmEsIDB4ZjQ4ZTc5NzgsIDB4OTk1ODNlNmIsIDB4MjdiOTcxZGQsIDB4YmVlMTRmYjYsIDB4ZjA4OGFkMTcsIDB4YzkyMGFjNjYsIDB4N2RjZTNhYjQsIDB4NjNkZjRhMTgsIDB4ZTUxYTMxODIsIDB4OTc1MTMzNjAsIDB4NjI1MzdmNDUsIDB4YjE2NDc3ZTAsIDB4YmI2YmFlODQsIDB4ZmU4MWEwMWMsIDB4ZjkwODJiOTQsIDB4NzA0ODY4NTgsIDB4OGY0NWZkMTksIDB4OTRkZTZjODcsIDB4NTI3YmY4YjcsIDB4YWI3M2QzMjMsIDB4NzI0YjAyZTIsIDB4ZTMxZjhmNTcsIDB4NjY1NWFiMmEsIDB4YjJlYjI4MDcsIDB4MmZiNWMyMDMsIDB4ODZjNTdiOWEsIDB4ZDMzNzA4YTUsIDB4MzAyODg3ZjIsIDB4MjNiZmE1YjIsIDB4MDIwMzZhYmEsIDB4ZWQxNjgyNWMsIDB4OGFjZjFjMmIsIDB4YTc3OWI0OTIsIDB4ZjMwN2YyZjAsIDB4NGU2OWUyYTEsIDB4NjVkYWY0Y2QsIDB4MDYwNWJlZDUsIDB4ZDEzNDYyMWYsIDB4YzRhNmZlOGEsIDB4MzQyZTUzOWQsIDB4YTJmMzU1YTAsIDB4MDU4YWUxMzIsIDB4YTRmNmViNzUsIDB4MGI4M2VjMzksIDB4NDA2MGVmYWEsIDB4NWU3MTlmMDYsIDB4YmQ2ZTEwNTEsIDB4M2UyMThhZjksIDB4OTZkZDA2M2QsIDB4ZGQzZTA1YWUsIDB4NGRlNmJkNDYsIDB4OTE1NDhkYjUsIDB4NzFjNDVkMDUsIDB4MDQwNmQ0NmYsIDB4NjA1MDE1ZmYsIDB4MTk5OGZiMjQsIDB4ZDZiZGU5OTcsIDB4ODk0MDQzY2MsIDB4NjdkOTllNzcsIDB4YjBlODQyYmQsIDB4MDc4OThiODgsIDB4ZTcxOTViMzgsIDB4NzljOGVlZGIsIDB4YTE3YzBhNDcsIDB4N2M0MjBmZTksIDB4Zjg4NDFlYzksIDB4MDAwMDAwMDAsIDB4MDk4MDg2ODMsIDB4MzIyYmVkNDgsIDB4MWUxMTcwYWMsIDB4NmM1YTcyNGUsIDB4ZmQwZWZmZmIsIDB4MGY4NTM4NTYsIDB4M2RhZWQ1MWUsIDB4MzYyZDM5MjcsIDB4MGEwZmQ5NjQsIDB4Njg1Y2E2MjEsIDB4OWI1YjU0ZDEsIDB4MjQzNjJlM2EsIDB4MGMwYTY3YjEsIDB4OTM1N2U3MGYsIDB4YjRlZTk2ZDIsIDB4MWI5YjkxOWUsIDB4ODBjMGM1NGYsIDB4NjFkYzIwYTIsIDB4NWE3NzRiNjksIDB4MWMxMjFhMTYsIDB4ZTI5M2JhMGEsIDB4YzBhMDJhZTUsIDB4M2MyMmUwNDMsIDB4MTIxYjE3MWQsIDB4MGUwOTBkMGIsIDB4ZjI4YmM3YWQsIDB4MmRiNmE4YjksIDB4MTQxZWE5YzgsIDB4NTdmMTE5ODUsIDB4YWY3NTA3NGMsIDB4ZWU5OWRkYmIsIDB4YTM3ZjYwZmQsIDB4ZjcwMTI2OWYsIDB4NWM3MmY1YmMsIDB4NDQ2NjNiYzUsIDB4NWJmYjdlMzQsIDB4OGI0MzI5NzYsIDB4Y2IyM2M2ZGMsIDB4YjZlZGZjNjgsIDB4YjhlNGYxNjMsIDB4ZDczMWRjY2EsIDB4NDI2Mzg1MTAsIDB4MTM5NzIyNDAsIDB4ODRjNjExMjAsIDB4ODU0YTI0N2QsIDB4ZDJiYjNkZjgsIDB4YWVmOTMyMTEsIDB4YzcyOWExNmQsIDB4MWQ5ZTJmNGIsIDB4ZGNiMjMwZjMsIDB4MGQ4NjUyZWMsIDB4NzdjMWUzZDAsIDB4MmJiMzE2NmMsIDB4YTk3MGI5OTksIDB4MTE5NDQ4ZmEsIDB4NDdlOTY0MjIsIDB4YThmYzhjYzQsIDB4YTBmMDNmMWEsIDB4NTY3ZDJjZDgsIDB4MjIzMzkwZWYsIDB4ODc0OTRlYzcsIDB4ZDkzOGQxYzEsIDB4OGNjYWEyZmUsIDB4OThkNDBiMzYsIDB4YTZmNTgxY2YsIDB4YTU3YWRlMjgsIDB4ZGFiNzhlMjYsIDB4M2ZhZGJmYTQsIDB4MmMzYTlkZTQsIDB4NTA3ODkyMGQsIDB4NmE1ZmNjOWIsIDB4NTQ3ZTQ2NjIsIDB4ZjY4ZDEzYzIsIDB4OTBkOGI4ZTgsIDB4MmUzOWY3NWUsIDB4ODJjM2FmZjUsIDB4OWY1ZDgwYmUsIDB4NjlkMDkzN2MsIDB4NmZkNTJkYTksIDB4Y2YyNTEyYjMsIDB4YzhhYzk5M2IsIDB4MTAxODdkYTcsIDB4ZTg5YzYzNmUsIDB4ZGIzYmJiN2IsIDB4Y2QyNjc4MDksIDB4NmU1OTE4ZjQsIDB4ZWM5YWI3MDEsIDB4ODM0ZjlhYTgsIDB4ZTY5NTZlNjUsIDB4YWFmZmU2N2UsIDB4MjFiY2NmMDgsIDB4ZWYxNWU4ZTYsIDB4YmFlNzliZDksIDB4NGE2ZjM2Y2UsIDB4ZWE5ZjA5ZDQsIDB4MjliMDdjZDYsIDB4MzFhNGIyYWYsIDB4MmEzZjIzMzEsIDB4YzZhNTk0MzAsIDB4MzVhMjY2YzAsIDB4NzQ0ZWJjMzcsIDB4ZmM4MmNhYTYsIDB4ZTA5MGQwYjAsIDB4MzNhN2Q4MTUsIDB4ZjEwNDk4NGEsIDB4NDFlY2RhZjcsIDB4N2ZjZDUwMGUsIDB4MTc5MWY2MmYsIDB4NzY0ZGQ2OGQsIDB4NDNlZmIwNGQsIDB4Y2NhYTRkNTQsIDB4ZTQ5NjA0ZGYsIDB4OWVkMWI1ZTMsIDB4NGM2YTg4MWIsIDB4YzEyYzFmYjgsIDB4NDY2NTUxN2YsIDB4OWQ1ZWVhMDQsIDB4MDE4YzM1NWQsIDB4ZmE4Nzc0NzMsIDB4ZmIwYjQxMmUsIDB4YjM2NzFkNWEsIDB4OTJkYmQyNTIsIDB4ZTkxMDU2MzMsIDB4NmRkNjQ3MTMsIDB4OWFkNzYxOGMsIDB4MzdhMTBjN2EsIDB4NTlmODE0OGUsIDB4ZWIxMzNjODksIDB4Y2VhOTI3ZWUsIDB4Yjc2MWM5MzUsIDB4ZTExY2U1ZWQsIDB4N2E0N2IxM2MsIDB4OWNkMmRmNTksIDB4NTVmMjczM2YsIDB4MTgxNGNlNzksIDB4NzNjNzM3YmYsIDB4NTNmN2NkZWEsIDB4NWZmZGFhNWIsIDB4ZGYzZDZmMTQsIDB4Nzg0NGRiODYsIDB4Y2FhZmYzODEsIDB4Yjk2OGM0M2UsIDB4MzgyNDM0MmMsIDB4YzJhMzQwNWYsIDB4MTYxZGMzNzIsIDB4YmNlMjI1MGMsIDB4MjgzYzQ5OGIsIDB4ZmYwZDk1NDEsIDB4MzlhODAxNzEsIDB4MDgwY2IzZGUsIDB4ZDhiNGU0OWMsIDB4NjQ1NmMxOTAsIDB4N2JjYjg0NjEsIDB4ZDUzMmI2NzAsIDB4NDg2YzVjNzQsIDB4ZDBiODU3NDJdO1xuY29uc3QgVDYgPSBbMHg1MDUxZjRhNywgMHg1MzdlNDE2NSwgMHhjMzFhMTdhNCwgMHg5NjNhMjc1ZSwgMHhjYjNiYWI2YiwgMHhmMTFmOWQ0NSwgMHhhYmFjZmE1OCwgMHg5MzRiZTMwMywgMHg1NTIwMzBmYSwgMHhmNmFkNzY2ZCwgMHg5MTg4Y2M3NiwgMHgyNWY1MDI0YywgMHhmYzRmZTVkNywgMHhkN2M1MmFjYiwgMHg4MDI2MzU0NCwgMHg4ZmI1NjJhMywgMHg0OWRlYjE1YSwgMHg2NzI1YmExYiwgMHg5ODQ1ZWEwZSwgMHhlMTVkZmVjMCwgMHgwMmMzMmY3NSwgMHgxMjgxNGNmMCwgMHhhMzhkNDY5NywgMHhjNjZiZDNmOSwgMHhlNzAzOGY1ZiwgMHg5NTE1OTI5YywgMHhlYmJmNmQ3YSwgMHhkYTk1NTI1OSwgMHgyZGQ0YmU4MywgMHhkMzU4NzQyMSwgMHgyOTQ5ZTA2OSwgMHg0NDhlYzljOCwgMHg2YTc1YzI4OSwgMHg3OGY0OGU3OSwgMHg2Yjk5NTgzZSwgMHhkZDI3Yjk3MSwgMHhiNmJlZTE0ZiwgMHgxN2YwODhhZCwgMHg2NmM5MjBhYywgMHhiNDdkY2UzYSwgMHgxODYzZGY0YSwgMHg4MmU1MWEzMSwgMHg2MDk3NTEzMywgMHg0NTYyNTM3ZiwgMHhlMGIxNjQ3NywgMHg4NGJiNmJhZSwgMHgxY2ZlODFhMCwgMHg5NGY5MDgyYiwgMHg1ODcwNDg2OCwgMHgxOThmNDVmZCwgMHg4Nzk0

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

26774DB4M2M0OThiMjgsIDB4MGQ5NTQxZmYsIDB4YTgwMTcxMzksIDB4MGNiM2RlMDgsIDB4YjRlNDljZDgsIDB4NTZjMTkwNjQsIDB4Y2I4NDYxN2IsIDB4MzJiNjcwZDUsIDB4NmM1Yzc0NDgsIDB4Yjg1NzQyZDBdO1xuLy8gVHJhbnNmb3JtYXRpb25zIGZvciBkZWNyeXB0aW9uIGtleSBleHBhbnNpb25cbmNvbnN0IFUxID0gWzB4MDAwMDAwMDAsIDB4MGUwOTBkMGIsIDB4MWMxMjFhMTYsIDB4MTIxYjE3MWQsIDB4MzgyNDM0MmMsIDB4MzYyZDM5MjcsIDB4MjQzNjJlM2EsIDB4MmEzZjIzMzEsIDB4NzA0ODY4NTgsIDB4N2U0MTY1NTMsIDB4NmM1YTcyNGUsIDB4NjI1MzdmNDUsIDB4NDg2YzVjNzQsIDB4NDY2NTUxN2YsIDB4NTQ3ZTQ2NjIsIDB4NWE3NzRiNjksIDB4ZTA5MGQwYjAsIDB4ZWU5OWRkYmIsIDB4ZmM4MmNhYTYsIDB4ZjI4YmM3YWQsIDB4ZDhiNGU0OWMsIDB4ZDZiZGU5OTcsIDB4YzRhNmZlOGEsIDB4Y2FhZmYzODEsIDB4OTBkOGI4ZTgsIDB4OWVkMWI1ZTMsIDB4OGNjYWEyZmUsIDB4ODJjM2FmZjUsIDB4YThmYzhjYzQsIDB4YTZmNTgxY2YsIDB4YjRlZTk2ZDIsIDB4YmFlNzliZDksIDB4ZGIzYmJiN2IsIDB4ZDUzMmI2NzAsIDB4YzcyOWExNmQsIDB4YzkyMGFjNjYsIDB4ZTMxZjhmNTcsIDB4ZWQxNjgyNWMsIDB4ZmYwZDk1NDEsIDB4ZjEwNDk4NGEsIDB4YWI3M2QzMjMsIDB4YTU3YWRlMjgsIDB4Yjc2MWM5MzUsIDB4Yjk2OGM0M2UsIDB4OTM1N2U3MGYsIDB4OWQ1ZWVhMDQsIDB4OGY0NWZkMTksIDB4ODE0Y2YwMTIsIDB4M2JhYjZiY2IsIDB4MzVhMjY2YzAsIDB4MjdiOTcxZGQsIDB4MjliMDdjZDYsIDB4MDM4ZjVmZTcsIDB4MGQ4NjUyZWMsIDB4MWY5ZDQ1ZjEsIDB4MTE5NDQ4ZmEsIDB4NGJlMzAzOTMsIDB4NDVlYTBlOTgsIDB4NTdmMTE5ODUsIDB4NTlmODE0OGUsIDB4NzNjNzM3YmYsIDB4N2RjZTNhYjQsIDB4NmZkNTJkYTksIDB4NjFkYzIwYTIsIDB4YWQ3NjZkZjYsIDB4YTM3ZjYwZmQsIDB4YjE2NDc3ZTAsIDB4YmY2ZDdhZWIsIDB4OTU1MjU5ZGEsIDB4OWI1YjU0ZDEsIDB4ODk0MDQzY2MsIDB4ODc0OTRlYzcsIDB4ZGQzZTA1YWUsIDB4ZDMzNzA4YTUsIDB4YzEyYzFmYjgsIDB4Y2YyNTEyYjMsIDB4ZTUxYTMxODIsIDB4ZWIxMzNjODksIDB4ZjkwODJiOTQsIDB4ZjcwMTI2OWYsIDB4NGRlNmJkNDYsIDB4NDNlZmIwNGQsIDB4NTFmNGE3NTAsIDB4NWZmZGFhNWIsIDB4NzVjMjg5NmEsIDB4N2JjYjg0NjEsIDB4NjlkMDkzN2MsIDB4NjdkOTllNzcsIDB4M2RhZWQ1MWUsIDB4MzNhN2Q4MTUsIDB4MjFiY2NmMDgsIDB4MmZiNWMyMDMsIDB4MDU4YWUxMzIsIDB4MGI4M2VjMzksIDB4MTk5OGZiMjQsIDB4MTc5MWY2MmYsIDB4NzY0ZGQ2OGQsIDB4Nzg0NGRiODYsIDB4NmE1ZmNjOWIsIDB4NjQ1NmMxOTAsIDB4NGU2OWUyYTEsIDB4NDA2MGVmYWEsIDB4NTI3YmY4YjcsIDB4NWM3MmY1YmMsIDB4MDYwNWJlZDUsIDB4MDgwY2IzZGUsIDB4MWExN2E0YzMsIDB4MTQxZWE5YzgsIDB4M2UyMThhZjksIDB4MzAyODg3ZjIsIDB4MjIzMzkwZWYsIDB4MmMzYTlkZTQsIDB4OTZkZDA2M2QsIDB4OThkNDBiMzYsIDB4OGFjZjFjMmIsIDB4ODRjNjExMjAsIDB4YWVmOTMyMTEsIDB4YTBmMDNmMWEsIDB4YjJlYjI4MDcsIDB4YmNlMjI1MGMsIDB4ZTY5NTZlNjUsIDB4ZTg5YzYzNmUsIDB4ZmE4Nzc0NzMsIDB4ZjQ4ZTc5NzgsIDB4ZGViMTVhNDksIDB4ZDBiODU3NDIsIDB4YzJhMzQwNWYsIDB4Y2NhYTRkNTQsIDB4NDFlY2RhZjcsIDB4NGZlNWQ3ZmMsIDB4NWRmZWMwZTEsIDB4NTNmN2NkZWEsIDB4NzljOGVlZGIsIDB4NzdjMWUzZDAsIDB4NjVkYWY0Y2QsIDB4NmJkM2Y5YzYsIDB4MzFhNGIyYWYsIDB4M2ZhZGJmYTQsIDB4MmRiNmE4YjksIDB4MjNiZmE1YjIsIDB4MDk4MDg2ODMsIDB4MDc4OThiODgsIDB4MTU5MjljOTUsIDB4MWI5YjkxOWUsIDB4YTE3YzBhNDcsIDB4YWY3NTA3NGMsIDB4YmQ2ZTEwNTEsIDB4YjM2NzFkNWEsIDB4OTk1ODNlNmIsIDB4OTc1MTMzNjAsIDB4ODU0YTI0N2QsIDB4OGI0MzI5NzYsIDB4ZDEzNDYyMWYsIDB4ZGYzZDZmMTQsIDB4Y2QyNjc4MDksIDB4YzMyZjc1MDIsIDB4ZTkxMDU2MzMsIDB4ZTcxOTViMzgsIDB4ZjUwMjRjMjUsIDB4ZmIwYjQxMmUsIDB4OWFkNzYxOGMsIDB4OTRkZTZjODcsIDB4ODZjNTdiOWEsIDB4ODhjYzc2OTEsIDB4YTJmMzU1YTAsIDB4YWNmYTU4YWIsIDB4YmVlMTRmYjYsIDB4YjBlODQyYmQsIDB4ZWE5ZjA5ZDQsIDB4ZTQ5NjA0ZGYsIDB4ZjY4ZDEzYzIsIDB4Zjg4NDFlYzksIDB4ZDJiYjNkZjgsIDB4ZGNiMjMwZjMsIDB4Y2VhOTI3ZWUsIDB4YzBhMDJhZTUsIDB4N2E0N2IxM2MsIDB4NzQ0ZWJjMzcsIDB4NjY1NWFiMmEsIDB4Njg1Y2E2MjEsIDB4NDI2Mzg1MTAsIDB4NGM2YTg4MWIsIDB4NWU3MTlmMDYsIDB4NTA3ODkyMGQsIDB4MGEwZmQ5NjQsIDB4MDQwNmQ0NmYsIDB4MTYxZGMzNzIsIDB4MTgxNGNlNzksIDB4MzIyYmVkNDgsIDB4M2MyMmUwNDMsIDB4MmUzOWY3NWUsIDB4MjAzMGZhNTUsIDB4ZWM5YWI3MDEsIDB4ZTI5M2JhMGEsIDB4ZjA4OGFkMTcsIDB4ZmU4MWEwMWMsIDB4ZDRiZTgzMmQsIDB4ZGFiNzhlMjYsIDB4YzhhYzk5M2IsIDB4YzZhNTk0MzAsIDB4OWNkMmRmNTksIDB4OTJkYmQyNTIsIDB4ODBjMGM1NGYsIDB4OGVjOWM4NDQsIDB4YTRmNmViNzUsIDB4YWFmZmU2N2UsIDB4YjhlNGYxNjMsIDB4YjZlZGZjNjgsIDB4MGMwYTY3YjEsIDB4MDIwMzZhYmEsIDB4MTAxODdkYTcsIDB4MWUxMTcwYWMsIDB4MzQyZTUzOWQsIDB4M2EyNzVlOTYsIDB4MjgzYzQ5OGIsIDB4MjYzNTQ0ODAsIDB4N2M0MjBmZTksIDB4NzI0YjAyZTIsIDB4NjA1MDE1ZmYsIDB4NmU1OTE4ZjQsIDB4NDQ2NjNiYzUsIDB4NGE2ZjM2Y2UsIDB4NTg3NDIxZDMsIDB4NTY3ZDJjZDgsIDB4MzdhMTBjN2EsIDB4MzlhODAxNzEsIDB4MmJiMzE2NmMsIDB4MjViYTFiNjcsIDB4MGY4NTM4NTYsIDB4MDE4YzM1NWQsIDB4MTM5NzIyNDAsIDB4MWQ5ZTJmNGIsIDB4NDdlOTY0MjIsIDB4NDllMDY5MjksIDB4NWJmYjdlMzQsIDB4NTVmMjczM2YsIDB4N2ZjZDUwMGUsIDB4NzFjNDVkMDUsIDB4NjNkZjRhMTgsIDB4NmRkNjQ3MTMsIDB4ZDczMWRjY2EsIDB4ZDkzOGQxYzEsIDB4Y2IyM2M2ZGMsIDB4YzUyYWNiZDcsIDB4ZWYxNWU4ZTYsIDB4ZTExY2U1ZWQsIDB4ZjMwN2YyZjAsIDB4ZmQwZWZmZmIsIDB4YTc3OWI0OTIsIDB4YTk3MGI5OTksIDB4YmI2YmFlODQsIDB4YjU2MmEzOGYsIDB4OWY1ZDgwYmUsIDB4OTE1NDhkYjUsIDB4ODM0ZjlhYTgsIDB4OGQ0Njk3YTNdO1xuY29uc3QgVTIgPSBbMHgwMDAwMDAwMCwgMHgwYjBlMDkwZCwgMHgxNjFjMTIxYSwgMHgxZDEyMWIxNywgMHgyYzM4MjQzNCwgMHgyNzM2MmQzOSwgMHgzYTI0MzYyZSwgMHgzMTJhM2YyMywgMHg1ODcwNDg2OCwgMHg1MzdlNDE2NSwgMHg0ZTZjNWE3MiwgMHg0NTYyNTM3ZiwgMHg3NDQ4NmM1YywgMHg3ZjQ2NjU1MSwgMHg2MjU0N2U0NiwgMHg2OTVhNzc0YiwgMHhiMGUwOTBkMCwgMHhiYmVlOTlkZCwgMHhhNmZjODJjYSwgMHhhZGYyOGJjNywgMHg5Y2Q4YjRlNCwgMHg5N2Q2YmRlOSwgMHg4YWM0YTZmZSwgMHg4MWNhYWZmMywgMHhlODkwZDhiOCwgMHhlMzllZDFiNSwgMHhmZThjY2FhMiwgMHhmNTgyYzNhZiwgMHhjNGE4ZmM4YywgMHhjZmE2ZjU4MSwgMHhkMmI0ZWU5NiwgMHhkOWJhZTc5YiwgMHg3YmRiM2JiYiwgMHg3MGQ1MzJiNiwgMHg2ZGM3MjlhMSwgMHg2NmM5MjBhYywgMHg1N2UzMWY4ZiwgMHg1Y2VkMTY4MiwgMHg0MWZmMGQ5NSwgMHg0YWYxMDQ5OCwgMHgyM2FiNzNkMywgMHgyOGE1N2FkZSwgMHgzNWI3NjFjOSwgMHgzZWI5NjhjNCwgMHgwZjkzNTdlNywgMHgwNDlkNWVlYSwgMHgxOThmNDVmZCwgMHgxMjgxNGNmMCwgMHhjYjNiYWI2YiwgMHhjMDM1YTI2NiwgMHhkZDI3Yjk3MSwgMHhkNjI5Y

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

26774B7IElMOiBJLnNsaWNlKDAsIDMyKSwgSVI6IEkuc2xpY2UoMzIpIH07XG59XG5mdW5jdGlvbiBkZXJpdmVQYXRoKG5vZGUsIHBhdGgpIHtcbiAgICBjb25zdCBjb21wb25lbnRzID0gcGF0aC5zcGxpdChcIi9cIik7XG4gICAgYXNzZXJ0QXJndW1lbnQoY29tcG9uZW50cy5sZW5ndGggPiAwLCBcImludmFsaWQgcGF0aFwiLCBcInBhdGhcIiwgcGF0aCk7XG4gICAgaWYgKGNvbXBvbmVudHNbMF0gPT09IFwibVwiKSB7XG4gICAgICAgIGFzc2VydEFyZ3VtZW50KG5vZGUuZGVwdGggPT09IDAsIGBjYW5ub3QgZGVyaXZlIHJvb3QgcGF0aCAoaS5lLiBwYXRoIHN0YXJ0aW5nIHdpdGggXCJtL1wiKSBmb3IgYSBub2RlIGF0IG5vbi16ZXJvIGRlcHRoICR7bm9kZS5kZXB0aH1gLCBcInBhdGhcIiwgcGF0aCk7XG4gICAgICAgIGNvbXBvbmVudHMuc2hpZnQoKTtcbiAgICB9XG4gICAgbGV0IHJlc3VsdCA9IG5vZGU7XG4gICAgZm9yIChsZXQgaSA9IDA7IGkgPCBjb21wb25lbnRzLmxlbmd0aDsgaSsrKSB7XG4gICAgICAgIGNvbnN0IGNvbXBvbmVudCA9IGNvbXBvbmVudHNbaV07XG4gICAgICAgIGlmIChjb21wb25lbnQubWF0Y2goL15bMC05XSsnJC8pKSB7XG4gICAgICAgICAgICBjb25zdCBpbmRleCA9IHBhcnNlSW50KGNvbXBvbmVudC5zdWJzdHJpbmcoMCwgY29tcG9uZW50Lmxlbmd0aCAtIDEpKTtcbiAgICAgICAgICAgIGFzc2VydEFyZ3VtZW50KGluZGV4IDwgSGFyZGVuZWRCaXQsIFwiaW52YWxpZCBwYXRoIGluZGV4XCIsIGBwYXRoWyR7aX1dYCwgY29tcG9uZW50KTtcbiAgICAgICAgICAgIHJlc3VsdCA9IHJlc3VsdC5kZXJpdmVDaGlsZChIYXJkZW5lZEJpdCArIGluZGV4KTtcbiAgICAgICAgfVxuICAgICAgICBlbHNlIGlmIChjb21wb25lbnQubWF0Y2goL15bMC05XSskLykpIHtcbiAgICAgICAgICAgIGNvbnN0IGluZGV4ID0gcGFyc2VJbnQoY29tcG9uZW50KTtcbiAgICAgICAgICAgIGFzc2VydEFyZ3VtZW50KGluZGV4IDwgSGFyZGVuZWRCaXQsIFwiaW52YWxpZCBwYXRoIGluZGV4XCIsIGBwYXRoWyR7aX1dYCwgY29tcG9uZW50KTtcbiAgICAgICAgICAgIHJlc3VsdCA9IHJlc3VsdC5kZXJpdmVDaGlsZChpbmRleCk7XG4gICAgICAgIH1cbiAgICAgICAgZWxzZSB7XG4gICAgICAgICAgICBhc3NlcnRBcmd1bWVudChmYWxzZSwgXCJpbnZhbGlkIHBhdGggY29tcG9uZW50XCIsIGBwYXRoWyR7aX1dYCwgY29tcG9uZW50KTtcbiAgICAgICAgfVxuICAgIH1cbiAgICByZXR1cm4gcmVzdWx0O1xufVxuLyoqXG4gKiAgQW4gKipIRE5vZGVXYWxsZXQqKiBpcyBhIFtbU2lnbmVyXV0gYmFja2VkIGJ5IHRoZSBwcml2YXRlIGtleSBkZXJpdmVkXG4gKiAgZnJvbSBhbiBIRCBOb2RlIHVzaW5nIHRoZSBbW2xpbmstYmlwLTMyXV0gc3RhbnRhcmQuXG4gKlxuICogIEFuIEhEIE5vZGUgZm9ybXMgYSBoaWVyYXJjaGFsIHN0cnVjdHVyZSB3aXRoIGVhY2ggSEQgTm9kZSBoYXZpbmcgYVxuICogIHByaXZhdGUga2V5IGFuZCB0aGUgYWJpbGl0eSB0byBkZXJpdmUgY2hpbGQgSEQgTm9kZXMsIGRlZmluZWQgYnlcbiAqICBhIHBhdGggaW5kaWNhdGluZyB0aGUgaW5kZXggb2YgZWFjaCBjaGlsZC5cbiAqL1xuZXhwb3J0IGNsYXNzIEhETm9kZVdhbGxldCBleHRlbmRzIEJhc2VXYWxsZXQge1xuICAgIC8qKlxuICAgICAqICBUaGUgY29tcHJlc3NlZCBwdWJsaWMga2V5LlxuICAgICAqL1xuICAgIHB1YmxpY0tleTtcbiAgICAvKipcbiAgICAgKiAgVGhlIGZpbmdlcnByaW50LlxuICAgICAqXG4gICAgICogIEEgZmluZ2VycHJpbnQgYWxsb3dzIHF1aWNrIHFheSB0byBkZXRlY3QgcGFyZW50IGFuZCBjaGlsZCBub2RlcyxcbiAgICAgKiAgYnV0IGRldmVsb3BlcnMgc2hvdWxkIGJlIHByZXBhcmVkIHRvIGRlYWwgd2l0aCBjb2xsaXNpb25zIGFzIGl0XG4gICAgICogIGlzIG9ubHkgNCBieXRlcy5cbiAgICAgKi9cbiAgICBmaW5nZXJwcmludDtcbiAgICAvKipcbiAgICAgKiAgVGhlIHBhcmVudCBmaW5nZXJwcmludC5cbiAgICAgKi9cbiAgICBwYXJlbnRGaW5nZXJwcmludDtcbiAgICAvKipcbiAgICAgKiAgVGhlIG1uZW1vbmljIHVzZWQgdG8gY3JlYXRlIHRoaXMgSEQgTm9kZSwgaWYgYXZhaWxhYmxlLlxuICAgICAqXG4gICAgICogIFNvdXJjZXMgc3VjaCBhcyBleHRlbmRlZCBrZXlzIGRvIG5vdCBlbmNvZGUgdGhlIG1uZW1vbmljLCBpblxuICAgICAqICB3aGljaCBjYXNlIHRoaXMgd2lsbCBiZSBgYG51bGxgYC5cbiAgICAgKi9cbiAgICBtbmVtb25pYztcbiAgICAvKipcbiAgICAgKiAgVGhlIGNoYWluY29kZSwgd2hpY2ggaXMgZWZmZWN0aXZlbHkgYSBwdWJsaWMga2V5IHVzZWRcbiAgICAgKiAgdG8gZGVyaXZlIGNoaWxkcmVuLlxuICAgICAqL1xuICAgIGNoYWluQ29kZTtcbiAgICAvKipcbiAgICAgKiAgVGhlIGRlcml2YXRpb24gcGF0aCBvZiB0aGlzIHdhbGxldC5cbiAgICAgKlxuICAgICAqICBTaW5jZSBleHRlbmRlZCBrZXlzIGRvIG5vdCBwcm92aWRlIGZ1bGwgcGF0aCBkZXRhaWxzLCB0aGlzXG4gICAgICogIG1heSBiZSBgYG51bGxgYCwgaWYgaW5zdGFudGlhdGVkIGZyb20gYSBzb3VyY2UgdGhhdCBkb2VzIG5vdFxuICAgICAqICBlbmNvZGUgaXQuXG4gICAgICovXG4gICAgcGF0aDtcbiAgICAvKipcbiAgICAgKiAgVGhlIGNoaWxkIGluZGV4IG9mIHRoaXMgd2FsbGV0LiBWYWx1ZXMgb3ZlciBgYDIgKlxcKiAzMWBgIGluZGljYXRlXG4gICAgICogIHRoZSBub2RlIGlzIGhhcmRlbmVkLlxuICAgICAqL1xuICAgIGluZGV4O1xuICAgIC8qKlxuICAgICAqICBUaGUgZGVwdGggb2YgdGhpcyB3YWxsZXQsIHdoaWNoIGlzIHRoZSBudW1iZXIgb2YgY29tcG9uZW50c1xuICAgICAqICBpbiBpdHMgcGF0aC5cbiAgICAgKi9cbiAgICBkZXB0aDtcbiAgICAvKipcbiAgICAgKiAgQHByaXZhdGVcbiAgICAgKi9cbiAgICBjb25zdHJ1Y3RvcihndWFyZCwgc2lnbmluZ0tleSwgcGFyZW50RmluZ2VycHJpbnQsIGNoYWluQ29kZSwgcGF0aCwgaW5kZXgsIGRlcHRoLCBtbmVtb25pYywgcHJvdmlkZXIpIHtcbiAgICAgICAgc3VwZXIoc2lnbmluZ0tleSwgcHJvdmlkZXIpO1xuICAgICAgICBhc3NlcnRQcml2YXRlKGd1YXJkLCBfZ3VhcmQsIFwiSEROb2RlV2FsbGV0XCIpO1xuICAgICAgICBkZWZpbmVQcm9wZXJ0aWVzKHRoaXMsIHsgcHVibGljS2V5OiBzaWduaW5nS2V5LmNvbXByZXNzZWRQdWJsaWNLZXkgfSk7XG4gICAgICAgIGNvbnN0IGZpbmdlcnByaW50ID0gZGF0YVNsaWNlKHJpcGVtZDE2MChzaGEyNTYodGhpcy5wdWJsaWNLZXkpKSwgMCwgNCk7XG4gICAgICAgIGRlZmluZVByb3BlcnRpZXModGhpcywge1xuICAgICAgICAgICAgcGFyZW50RmluZ2VycHJpbnQsIGZpbmdlcnByaW50LFxuICAgICAgICAgICAgY2hhaW5Db2RlLCBwYXRoLCBpbmRleCwgZGVwdGhcbiAgICAgICAgfSk7XG4gICAgICAgIGRlZmluZVByb3BlcnRpZXModGhpcywgeyBtbmVtb25pYyB9KTtcbiAgICB9XG4gICAgY29ubmVjdChwcm92aWRlcikge1xuICAgICAgICByZXR1cm4gbmV3IEhETm9kZVdhbGxldChfZ3VhcmQsIHRoaXMuc2lnbmluZ0tleSwgdGhpcy5wYXJlbnRGaW5nZXJwcmludCwgdGhpcy5jaGFpbkNvZGUsIHRoaXMucGF0aCwgdGhpcy5pbmRleCwgdGhpcy5kZXB0aCwgdGhpcy5tbmVtb25pYywgcHJvdmlkZXIpO1xuICAgIH1cbiAgICAjYWNjb3VudCgpIHtcbiAgICAgICAgY29uc3QgYWNjb3VudCA9IHsgYWRkcmVzczogdGhpcy5hZGRyZXNzLCBwcml2YXRlS2V5OiB0aGlzLnByaXZhdGVLZXkgfTtcbiAgICAgICAgY29uc3QgbSA9IHRoaXMubW5lbW9uaWM7XG4gICAgICAgIGlmICh0aGlzLnBhdGggJiYgbSAmJiBtLndvcmRsaXN0LmxvY2FsZSA9PT0gXCJlblwiICYmIG0ucGFzc3dvcmQgPT09IFwiXCIpIHtcbiAgICAgICAgICAgIGFjY291bnQubW5lbW9uaWMgPSB7XG4gICAgICAgICAgICAgICAgcGF0aDogdGhpcy5wYXRoLFxuICAgICAgICAgICAgICAgIGxvY2FsZTogXCJlblwiLFxuICAgICAgICAgICAgICAgIGVudHJvcHk6IG0uZW50cm9weVxuICAgICAgICAgICAgfTtcbiAgICAgICAgfVxuICAgICAgICByZXR1cm4gYWNjb3VudDtcbiAgICB9XG4gICAgLyoqXG4gICAgICogIFJlc29sdmVzIHRvIGEgW0pTT04g

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

26774HJldHVybiBuZXcgV2FsbGV0KHRoaXMuc2lnbmluZ0tleSwgcHJvdmlkZXIpO1xuICAgIH1cbiAgICAvKipcbiAgICAgKiAgUmVzb2x2ZXMgdG8gYSBbSlNPTiBLZXlzdG9yZSBXYWxsZXRdKGpzb24td2FsbGV0cykgZW5jcnlwdGVkIHdpdGhcbiAgICAgKiAgJSVwYXNzd29yZCUlLlxuICAgICAqXG4gICAgICogIElmICUlcHJvZ3Jlc3NDYWxsYmFjayUlIGlzIHNwZWNpZmllZCwgaXQgd2lsbCByZWNlaXZlIHBlcmlvZGljXG4gICAgICogIHVwZGF0ZXMgYXMgdGhlIGVuY3J5cHRpb24gcHJvY2VzcyBwcm9ncmVzZXMuXG4gICAgICovXG4gICAgYXN5bmMgZW5jcnlwdChwYXNzd29yZCwgcHJvZ3Jlc3NDYWxsYmFjaykge1xuICAgICAgICBjb25zdCBhY2NvdW50ID0geyBhZGRyZXNzOiB0aGlzLmFkZHJlc3MsIHByaXZhdGVLZXk6IHRoaXMucHJpdmF0ZUtleSB9O1xuICAgICAgICByZXR1cm4gYXdhaXQgZW5jcnlwdEtleXN0b3JlSnNvbihhY2NvdW50LCBwYXNzd29yZCwgeyBwcm9ncmVzc0NhbGxiYWNrIH0pO1xuICAgIH1cbiAgICAvKipcbiAgICAgKiAgUmV0dXJucyBhIFtKU09OIEtleXN0b3JlIFdhbGxldF0oanNvbi13YWxsZXRzKSBlbmNyeXBlZCB3aXRoXG4gICAgICogICUlcGFzc3dvcmQlJS5cbiAgICAgKlxuICAgICAqICBJdCBpcyBwcmVmZXJyZWQgdG8gdXNlIHRoZSBbYXN5bmMgdmVyc2lvbl0oZW5jcnlwdCkgaW5zdGVhZCxcbiAgICAgKiAgd2hpY2ggYWxsb3dzIGEgW1tQcm9ncmVzc0NhbGxiYWNrXV0gdG8ga2VlcCB0aGUgdXNlciBpbmZvcm1lZC5cbiAgICAgKlxuICAgICAqICBUaGlzIG1ldGhvZCB3aWxsIGJsb2NrIHRoZSBldmVudCBsb29wIChmcmVlemluZyBhbGwgVUkpIHVudGlsXG4gICAgICogIGl0IGlzIGNvbXBsZXRlLCB3aGljaCBtYXkgYmUgYSBub24tdHJpdmlhbCBkdXJhdGlvbi5cbiAgICAgKi9cbiAgICBlbmNyeXB0U3luYyhwYXNzd29yZCkge1xuICAgICAgICBjb25zdCBhY2NvdW50ID0geyBhZGRyZXNzOiB0aGlzLmFkZHJlc3MsIHByaXZhdGVLZXk6IHRoaXMucHJpdmF0ZUtleSB9O1xuICAgICAgICByZXR1cm4gZW5jcnlwdEtleXN0b3JlSnNvblN5bmMoYWNjb3VudCwgcGFzc3dvcmQpO1xuICAgIH1cbiAgICBzdGF0aWMgI2Zyb21BY2NvdW50KGFjY291bnQpIHtcbiAgICAgICAgYXNzZXJ0QXJndW1lbnQoYWNjb3VudCwgXCJpbnZhbGlkIEpTT04gd2FsbGV0XCIsIFwianNvblwiLCBcIlsgUkVEQUNURUQgXVwiKTtcbiAgICAgICAgaWYgKFwibW5lbW9uaWNcIiBpbiBhY2NvdW50ICYmIGFjY291bnQubW5lbW9uaWMgJiYgYWNjb3VudC5tbmVtb25pYy5sb2NhbGUgPT09IFwiZW5cIikge1xuICAgICAgICAgICAgY29uc3QgbW5lbW9uaWMgPSBNbmVtb25pYy5mcm9tRW50cm9weShhY2NvdW50Lm1uZW1vbmljLmVudHJvcHkpO1xuICAgICAgICAgICAgY29uc3Qgd2FsbGV0ID0gSEROb2RlV2FsbGV0LmZyb21NbmVtb25pYyhtbm

26774Vtb25pYywgYWNjb3VudC5tbmVtb25pYy5wYXRoKTtcbiAgICAgICAgICAgIGlmICh3YWxsZXQuYWRkcmVzcyA9PT0gYWNjb3VudC5hZGRyZXNzICYmIHdhbGxldC5wcml2YXRlS2V5ID09PSBhY2NvdW50LnByaXZhdGVLZXkpIHtcbiAgICAgICAgICAgICAgICByZXR1cm4gd2FsbGV0O1xuICAgICAgICAgICAgfVxuICAgICAgICAgICAgY29uc29sZS5sb2coXCJXQVJOSU5HOiBKU09OIG1pc21hdGNoIGFkZHJlc3MvcHJpdmF0ZUtleSAhPSBtbmVtb25pYzsgZmFsbGJhY2sgb250byBwcml2YXRlIGtleVwiKTtcbiAgICAgICAgfVxuICAgICAgICBjb25zdCB3YWxsZXQgPSBuZXcgV2FsbGV0KGFjY291bnQucHJpdmF0ZUtleSk7XG4gICAgICAgIGFzc2VydEFyZ3VtZW50KHdhbGxldC5hZGRyZXNzID09PSBhY2NvdW50LmFkZHJlc3MsIFwiYWRkcmVzcy9wcml2YXRlS2V5IG1pc21hdGNoXCIsIFwianNvblwiLCBcIlsgUkVEQUNURUQgXVwiKTtcbiAgICAgICAgcmV0dXJuIHdhbGxldDtcbiAgICB9XG4gICAgLyoqXG4gICAgICogIENyZWF0ZXMgKGFzeW5jaHJvbm91c2x5KSBhICoqV2FsbGV0KiogYnkgZGVjcnlwdGluZyB0aGUgJSVqc29uJSVcbiAgICAgKiAgd2l0aCAlJXBhc3N3b3JkJSUuXG4gICAgICpcbiAgICAgKiAgSWYgJSVwcm9ncmVzcyUlIGlzIHByb3ZpZGVkLCBpdCBpcyBjYWxsZWQgcGVyaW9kaWNhbGx5IGR1cmluZ1xuICAgICAqICBkZWNyeXB0aW9uIHNvIHRoYXQgYW55IFVJIGNhbiBiZSB1cGRhdGVkLlxuICAgICAqL1xuICAgIHN0YXRpYyBhc3luYyBmcm9tRW5jcnlwdGVkSnNvbihqc29uLCBwYXNzd29yZCwgcHJvZ3Jlc3MpIHtcbiAgICAgICAgbGV0IGFjY291bnQgPSBudWxsO1xuICAgICAgICBpZiAoaXNLZXlzdG9yZUpzb24oanNvbikpIHtcbiAgICAgICAgICAgIGFjY291bnQgPSBhd2FpdCBkZWNyeXB0S2V5c3RvcmVKc29uKGpzb24sIHBhc3N3b3JkLCBwcm9ncmVzcyk7XG4gICAgICAgIH1cbiAgICAgICAgZWxzZSBpZiAoaXNDcm93ZHNhbGVKc29uKGpzb24pKSB7XG4gICAgICAgICAgICBpZiAocHJvZ3Jlc3MpIHtcbiAgICAgICAgICAgICAgICBwcm9ncmVzcygwKTtcbiAgICAgICAgICAgICAgICBhd2FpdCBzdGFsbCgwKTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgICAgIGFjY291bnQgPSBkZWNyeXB0Q3Jvd2RzYWxlSnNvbihqc29uLCBwYXNzd29yZCk7XG4gICAgICAgICAgICBpZiAocHJvZ3Jlc3MpIHtcbiAgICAgICAgICAgICAgICBwcm9ncmVzcygxKTtcbiAgICAgICAgICAgICAgICBhd2FpdCBzdGFsbCgwKTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgfVxuICAgICAgICByZXR1cm4gV2FsbGV0LiNmcm9tQWNjb3VudChhY2NvdW50KTtcbiAgICB9XG4gICAgLyoqXG4gICAgICogIENyZWF0ZXMgYSAqKldhbGxldCoqIGJ5IGRlY3J5cHRpbmcgdGhlICUlanNvbiUlIHdpdGggJSVwYXNzd29yZCUlLlxuICAgICAqXG4gICAgICogIFRoZSBbW2Zyb21FbmNyeXB0ZWRKc29uXV0gbWV0aG9kIGlzIHByZWZlcnJlZCwgYXMgdGhpcyBtZXRob2RcbiAgICAgKiAgd2lsbCBsb2NrIHVwIGFuZCBmcmVlemUgdGhlIFVJIGR1cmluZyBkZWNyeXB0aW9uLCB3aGljaCBtYXkgdGFrZVxuICAgICAqICBzb21lIHRpbWUuXG4gICAgICovXG4gICAgc3RhdGljIGZyb21FbmNyeXB0ZWRKc29uU3luYyhqc29uLCBwYXNzd29yZCkge1xuICAgICAgICBsZXQgYWNjb3VudCA9IG51bGw7XG4gICAgICAgIGlmIChpc0tleXN0b3JlSnNvbihqc29uKSkge1xuICAgICAgICAgICAgYWNjb3VudCA9IGRlY3J5cHRLZXlzdG9yZUpzb25TeW5jKGpzb24sIHBhc3N3b3JkKTtcbiAgICAgICAgfVxuICAgICAgICBlbHNlIGlmIChpc0Nyb3dkc2FsZUpzb24oanNvbikpIHtcbiAgICAgICAgICAgIGFjY291bnQgPSBkZWNyeXB0Q3Jvd2RzYWxlSnNvbihqc29uLCBwYXNzd29yZCk7XG4gICAgICAgIH1cbiAgICAgICAgZWxzZSB7XG4gICAgICAgICAgICBhc3NlcnRBcmd1bWVudChmYWxzZSwgXCJpbnZhbGlkIEpTT04gd2FsbGV0XCIsIFwianNvblwiLCBcIlsgUkVEQUNURUQgXVwiKTtcbiAgICAgICAgfVxuICAgICAgICByZXR1cm4gV2FsbGV0LiNmcm9tQWNjb3VudChhY2NvdW50KTtcbiAgICB9XG4gICAgLyoqXG4gICAgICogIENyZWF0ZXMgYSBuZXcgcmFuZG9tIFtbSEROb2RlV2FsbGV0XV0gdXNpbmcgdGhlIGF2YWlsYWJsZVxuICAgICAqICBbY3J5cHRvZ3JhcGh

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

26774FHLE9BQU8sV0FBVyxRQUFRLGVBTDlCLFVBQVU7RUFDbkIsT0FBTztFQUNQLFdBQVc7RUFDWCxRQUFRLFFBQVEsSUFBSTtDQUN4QixHQUFHLEtBQzBEO0NBQzdELE9BQWEsQ0FBQztDQUNkLE9BQWEsQ0FBQztDQUNkLE9BQWEsQ0FBQztDQUNkLE9BQWEsS0FBSztDQUNsQixPQUFhLFNBQVM7Q0FDdEIsT0FBYSxNQUFNO0NBQ25CLElBQUksZUFBZSxLQUFBLEtBQWEsT0FBTyxlQUFlLFlBQ2xELE1BQU0sSUFBSSxNQUFNLCtCQUErQjtDQUNuRCxNQUFNLFlBQVksTUFBTTtDQUN4QixNQUFNLGNBQWMsWUFBWTtDQUNoQyxJQUFJLEtBQUssTUFBTSxJQUFLLElBQUksT0FBUSxLQUFLLEtBQUssTUFBTSxZQUFZLE1BQU0sSUFBSSxLQUFLLElBR3ZFLE1BQU0sSUFBSSxNQUFNLDZGQUE2RjtDQUVqSCxJQUFJLElBQUksS0FBSyxLQUFNLEtBQUssS0FBSyxLQUFLLEtBQU0sV0FDcEMsTUFBTSxJQUFJLE1BQU0sMEZBQTBGO0NBRTlHLElBQUksUUFBUSxLQUFLLFNBQVMsS0FBSyxLQUFLLEtBQUssSUFDckMsTUFBTSxJQUFJLE1BQU0sZ0ZBQWdGO0NBRXBHLE1BQU0sVUFBVSxhQUFhLElBQUk7Q0FDakMsSUFBSSxVQUFVLFFBQ1YsTUFBTSxJQUFJLE1BQU0saUNBQWlDLFFBQVEseUJBQXlCLE9BQU8sVUFBVTtDQUl2RyxNQUFNLElBQUlDLFNBQU9DLFVBQVEsVUFBVSxNQUFNO0VBQUUsR0FBRztFQUFHLE9BQU8sWUFBWTtDQUFFLENBQUM7Q0FDdkUsTUFBTSxNQUFNLElBQUksQ0FBQztDQUVqQixNQUFNLElBQUksSUFBSSxJQUFJLFdBQVcsWUFBWSxDQUFDLENBQUM7Q0FDM0MsTUFBTSxNQUFNLElBQUksSUFBSSxXQUFXLFNBQVMsQ0FBQztDQUN6QyxJQUFJLG1CQUFtQixDQUFFO0NBQ3pCLElBQUksWUFBWTtFQUNaLE1BQU0sZ0JBQWdCLElBQUksSUFBSTtFQUc5QixNQUFNLGNBQWMsS0FBSyxJQUFJLEtBQUssTUFBTSxnQkFBZ0IsR0FBSyxHQUFHLENBQUM7RUFDakUsSUFBSSxjQUFjO0VBQ2xCLG1CQUFtQjtHQUNmO0dBQ0EsSUFBSSxlQUFlLEVBQUUsY0FBYyxnQkFBZ0IsZ0JBQWdCLGdCQUMvRCxXQUFXLGNBQWMsYUFBYTtFQUM5QztDQUNKO0NBQ0EsT0FBTztFQUFFO0VBQUc7RUFBRztFQUFHO0VBQU87RUFBYTtFQUFHO0VBQUs7RUFBRztFQUFLO0VBQVk7Q0FBVTtBQUNoRjtBQUNBLFNBQVMsYUFBYSxVQUFVLE9BQU8sR0FBRyxHQU

26774FHLEtBQUs7Q0FDOUMsTUFBTSxNQUFNRCxTQUFPQyxVQUFRLFVBQVUsR0FBRztFQUFFLEdBQUc7RUFBRztDQUFNLENBQUM7Q0FDdkQsRUFBRSxLQUFLLENBQUM7Q0FDUixFQUFFLEtBQUssQ0FBQztDQUNSLElBQUksS0FBSyxDQUFDO0NBQ1YsT0FBTztBQUNYOzs7Ozs7Ozs7Ozs7Ozs7QUFlQSxTQUFnQkMsU0FBTyxVQUFVLE1BQU0sTUFBTTtDQUN6QyxNQUFNLEVBQUUsR0FBRyxHQUFHLEdBQUcsT0FBTyxhQUFhLEdBQUcsS0FBSyxHQUFHLEtBQUssZUFBZSxXQUFXLFVBQVUsTUFBTSxJQUFJO0NBQ25HLEtBQUssSUFBSSxLQUFLLEdBQUcsS0FBSyxHQUFHLE1BQU07RUFDM0IsTUFBTSxLQUFLLGNBQWM7RUFDekIsS0FBSyxJQUFJLElBQUksR0FBRyxJQUFJLGFBQWEsS0FDN0IsRUFBRSxLQUFLLElBQUksS0FBSztFQUNwQixLQUFLLElBQUksSUFBSSxHQUFHLE1BQU0sR0FBRyxJQUFJLElBQUksR0FBRyxLQUFLO0dBQ3JDLFNBQVMsR0FBRyxLQUFLLEdBQUksT0FBTyxhQUFjLENBQUM7R0FDM0MsV0FBVztFQUNmO0VBQ0EsU0FBUyxJQUFJLElBQUksS0FBSyxhQUFhLEtBQUssSUFBSSxDQUFDO0VBQzdDLFdBQVc7RUFDWCxLQUFLLElBQUksSUFBSSxHQUFHLElBQUksR0FBRyxLQUFLO0dBRXhCLE1BQU0sSUFBSSxJQUFJLEtBQUssY0FBYyxNQUFNO0dBQ3ZDLEtBQUssSUFBSSxJQUFJLEdBQUcsSUFBSSxhQUFhLEtBQzdCLElBQUksS0FBSyxJQUFJLEtBQUssS0FBSyxFQUFFLElBQUksY0FBYztHQUMvQyxTQUFTLEtBQUssR0FBRyxLQUFLLElBQUksQ0FBQztHQUMzQixXQUFXO0VBQ2Y7Q0FDSjtDQUNBLE9BQU8sYUFBYSxVQUFVLE9BQU8sR0FBRyxHQU

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

26774BQUc7Q0FDUCxHQUFHO0VBQ0MsMEJBQTBCO0VBQzFCLGdCQUFnQjtFQUNoQixlQUFlO0VBQ2YsZUFBZTtFQUNmLG9CQUFvQjtFQUNwQixXQUFXO0VBQ1gsU0FBUztDQUNiLENBQUM7Q0FDRCxNQUFNLEVBQUUsTUFBTSxJQUFJLE1BQU07Q0FDeEIsSUFBSSxNQUFNO0VBQ04sSUFBSSxDQUFDLEdBQUcsSUFBSSxHQUFHLEdBQUcsSUFBSSxHQUNsQixNQUFNLElBQUksTUFBTSxtRUFBbUU7RUFFdkYsSUFBSSxPQUFPLFNBQVMsWUFDaEIsT0FBTyxLQUFLLFNBQVMsWUFDckIsT0FBTyxLQUFLLGdCQUFnQixZQUM1QixNQUFNLElBQUksTUFBTSxtRUFBbUU7Q0FFM0Y7Q0FDQSxPQUFPLE9BQU8sT0FBTyxFQUFFLEdBQUcsS0FBSyxDQUFDO0FBQ3BDO0FBRUEsSUFBTSxFQUFFLGlCQUFpQixLQUFLLFlBQVksUUFBUUM7QUFDbEQsSUFBYSxNQUFNO0NBRWYsS0FBSyxNQUFNLGVBQWUsTUFBTTtFQUM1QixZQUFZLElBQUksSUFBSTtHQUNoQixNQUFNLENBQUM7RUFDWDtDQUNKO0NBQ0EsVUFBVSxNQUFNO0VBQ1osTUFBTSxFQUFFLEtBQUssTUFBTTtFQUNuQixJQUFJLEtBQUssU0FBUyxLQUFLLEtBQUssT0FBTyxHQUMvQixNQUFNLElBQUksRUFBRSwrQkFBK0I7RUFDL0MsTUFBTSxNQUFNLEtBQUs7RUFDakIsTUFBTSxNQUFNLEtBQUssU0FBUyxHQUFHLE1BQU0sQ0FBQztFQUNwQyxJQUFJLENBQUMsT0FBTyxJQUFJLFdBQVcsS0FDdkIsTUFBTSxJQUFJLEVBQUUseUNBQXlDO0VBS3pELElBQUksSUFBSSxLQUFLLEtBQ1QsTUFBTSxJQUFJLEVBQUUscUNBQXFDO0VBQ3JELElBQUksSUFBSSxPQUFPLEtBQVEsRUFBRSxJQUFJLEtBQUssTUFDOUIsTUFBTSxJQUFJLEVBQUUscURBQXFEO0VBQ3JFLE9BQU87R0FBRSxHQUFHLElBQUksR0FBRztHQUFHLEdBQUcsS0FBSyxTQUFTLE1BQU0sQ0FBQztFQUFFO0NBQ3BEO0NBQ0EsTUFBTSxLQUFLO0VBRVAsTUFBTSxFQUFFLEtBQUssTUFBTTtFQUNuQixNQUFNLE9BQU8sT0FBTyxRQUFRLFdBQVcsSUFBSSxHQUFHLElBQUk7RUFDbEQsSUFBSSxFQUFFLGdCQUFnQixhQUNsQixNQUFNLElBQUksTUFBTSxlQUFlO0VBQ25DLElBQUksSUFBSSxLQUFLO0VBQ2IsSUFBSSxJQUFJLEtBQUssS0FBSyxNQUFNLElBQ3BCLE1BQU0sSUFBSSxFQUFFLHVCQUF1QjtFQUN2QyxJQUFJLEtBQUssT0FBTyxJQUFJLEdBQ2hCLE1BQU0sSUFBSSxFQUFFLHFDQUFxQztFQUNyRCxNQUFNLEVBQUUsR0FBRyxHQUFHLEdBQUcsV0FBVyxJQUFJLFVBQVUsS0FBSyxTQUFTLENBQUMsQ0FBQztFQUMxRCxNQUFNLEVBQUUsR0FBRyxHQUFHLEdBQUcsZUFBZSxJQUFJLFVBQVUsTUFBTTtFQUNwRCxJQUFJLFdBQVcsUUFDWCxNQUFNLElBQUksRUFBRSw2Q0FBNkM7RUFDN0QsT0FBTztHQUFFO0dBQUc7RUFBRTtDQUNsQjtDQUNBLFdBQVcsS0FBSztFQUVaLE1BQU0sU0FBUyxNQUFPLE9BQU8sU0FBUyxFQUFFLElBQUksRUFBRSxJQUFJLElBQVMsT0FBTyxJQUFJO0VBQ3RFLE1BQU0sS0FBSyxRQUFRO0dBQ2YsTUFBTSxNQUFNLElBQUksU0FBUyxFQUFFO0dBQzNCLE9BQU8sSUFBSSxTQUFTLElBQUksSUFBSSxRQUFRO0VBQ3hDO0VBQ0EsTUFBTSxJQUFJLE1BQU0sRUFBRSxJQUFJLENBQUMsQ0FBQztFQUN4QixNQUFNLElBQUksTUFBTSxFQUFFLElBQUksQ0FBQyxDQUFDO0VBQ3hCLE1BQU0sTUFBTSxFQUFFLFNBQVM7RUFDdkIsTUFBTSxNQUFNLEVBQUUsU0FBUztFQUN2QixNQUFNLEtBQUssRUFBRSxHQUFHO0VBQ2hCLE1BQU0sS0FBSyxFQUFFLEdBQUc7RUFDaEIsT0FBTyxLQUFLLEVBQUUsTUFBTSxNQUFNLENBQUMsRUFBRSxJQUFJLEtBQUssRUFBRSxJQUFJLEtBQUs7Q0FDckQ7QUFDSjtBQUdBLElBQU0sTUFBTSxPQUFPLENBQUM7QUFBR0MsSUFBQUEsUUFBTSxPQUFPLENBQUM7QUFBb0IsSUFBQSxNQUFNLE9BQU8sQ0FBQztBQUN2RSxTQUFnQixrQkFBa0IsTUFBTTtDQUNwQyxNQUFNLFFBQVEsa0JBQWtCLElBQUk7Q0FDcEMsTUFBTSxFQUFFLE9BQU87Q0FDZixNQUFNLFVBQVUsTUFBTSxhQUNoQixJQUFJLE9BQU8sa0JBQWtCO0VBQzNCLE1BQU0sSUFBSSxNQUFNLFNBQVM7RUFDekIsT0FBT0MsWUFBZSxXQUFXLEtBQUssQ0FBQyxDQUFJLENBQUMsR0FBRyxHQUFHLFFBQVEsRUFBRSxDQUFDLEdBQUcsR0FBRyxRQUFRLEVBQUUsQ0FBQyxDQUFDO0NBQ25GO0NBQ0osTUFBTSxZQUFZLE1BQU0sZUFDbEIsVUFBVTtFQUVSLE1BQU0sT0FBTyxNQUFNLFNBQVMsQ0FBQztFQUk3QixPQUFPO0dBQUUsR0FGQyxHQUFHLFVBQVUsS0FBSyxTQUFTLEdBQUcsR0FBRyxLQUFLLENBRXZDO0dBQUcsR0FERixHQUFHLFVBQVUsS0FBSyxTQUFTLEdBQUcsT0FBTyxJQUFJLEdBQUcsS0FBSyxDQUMvQztFQUFFO0NBQ2xCOzs7OztDQUtKLFNBQVMsb0JBQW9CLEdBQUc7RUFDNUIsTUFBTSxFQUFFLEdBQUcsTUFBTTtFQUNqQixNQUFNLEtBQUssR0FBRyxJQUFJLENBQUM7RUFDbkIsTUFBTSxLQUFLLEdBQUcsSUFBSSxJQUFJLENBQUM7RUFDdkIsT0FBTyxHQUFHLElBQUksR0FBRyxJQUFJLElBQUksR0FBRyxJQUFJLEdBQUcsQ0FBQyxDQUFDLEdBQUcsQ0FBQztDQUM3QztDQUtBLElBQUksQ0FBQyxHQUFHLElBQUksR0FBRyxJQUFJLE1BQU0sRUFBRSxHQUFHLG9CQUFvQixNQUFNLEVBQUUsQ0FBQyxHQUN2RCxNQUFNLElBQUksTUFBTSw2Q0FBNkM7Q0FFakUsU0FBUyxtQkFBbUIsS0FBSztFQUM3QixPQUFPLE9BQU8sUUFBUSxZQUFZLE1BQU0sT0FBTyxNQUFNLE1BQU07Q0FDL0Q7Q0FDQSxTQUFTLFNBQVMsS0FBSztFQUNuQixJQUFJLENBQUMsbUJBQW1CLEdBQUcsR0FDdkIsTUFBTSxJQUFJLE1BQU0sNkNBQTZDO0NBQ3JFO0NBR0EsU0FBUyx1QkFBdUIsS0FBSztFQUNqQyxNQUFNLEVBQUUsMEJBQTBCLFNBQVMsYUFBYSxnQkFBZ0IsTUFBTTtFQUM5RSxJQUFJLFdBQVcsT0FBTyxRQUFRLFVBQVU7R0FDcEMsSUFBSSxlQUFlLFlBQ2YsTUFBTUMsV0FBYyxHQUFHO0dBRTNCLElBQUksT0FBTyxRQUFRLFlBQVksQ0FBQyxRQUFRLFNBQVMsSUFBSSxNQUFNLEdBQ3ZELE1BQU0sSUFBSSxNQUFNLGFBQWE7R0FDakMsTUFBTSxJQUFJLFNBQVMsY0FBYyxHQUFHLEdBQUc7RUFDM0M7RUFDQSxJQUFJO0VBQ0osSUFBSTtHQUNBLE1BQ0ksT0FBTyxRQUFRLFdBQ1QsTUFDQUMsZ0JBQW1CLFlBQVksZUFBZSxLQUFLLFdBQVcsQ0FBQztFQUM3RSxTQUNPLE9BQU87R0FDVixNQUFNLElBQUksTUFBTSx1QkFBdUIsWUFBWSw2QkFBNkIsT0FBTyxLQUFLO0VBQ2hHO0VBQ0EsSUFBSSxnQkFDQSxNQUFNQyxJQUFRLEtBQUssQ0FBQztFQUN4QixTQUFTLEdBQUc7RUFDWixPQUFPO0NBQ1g7Q0FDQSxNQUFNLG1DQUFtQixJQUFJLElBQUk7Q0FDakMsU0FBUyxlQUFlLE9BQU87RUFDM0IsSUFBSSxFQUFFLGlCQUFpQixRQUNuQixNQUFNLElBQUksTUFBTSwwQkFBMEI7Q0FDbEQ7Ozs7OztDQU1BLE1BQU0sTUFBTTtFQUNSLFlBQVksSUFBSSxJQUFJLElBQUk7R0FDcEIsS0FBSyxLQUFLO0dBQ1YsS0FBSyxLQUFLO0dBQ1YsS0FBSyxLQUFLO0dBQ1YsSUFBSSxNQUFNLFFBQVEsQ0FBQyxHQUFHLFFBQVEsRUFBRSxHQUM1QixNQUFNLElBQUksTUFBTSxZQUFZO0dBQ2hDLElBQUksTUFBTSxRQUFRLENBQUMsR0FBRyxRQUFRLEVBQUUsR0FDNUIsTUFBTSxJQUFJLE1BQU0sWUFBWTtHQUNoQyxJQUFJLE1BQU0sUUFBUSxDQUFDLEdBQUcsUUFBUSxFQUFFLEdBQzVCLE1BQU0sSUFBSSxNQUFNLFlBQVk7RUFDcEM7RUFHQSxPQUFPLFdBQVcsR0FBRztHQUNqQixNQUFNLEVBQUUsR0FBRyxNQUFNLEtBQUssQ0FBQztHQUN2QixJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsUUFBUSxDQUFDLEtBQUssQ0FBQyxHQUFHLFFBQVEsQ0FBQyxHQUNyQyxN

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

26774FHLEdBQUc7Q0FBRzs7OztDQUlwQyxPQUFPLE1BQU0sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEdBQUc7Q0FBRzs7OztDQUlwQyxPQUFPLE1BQU0sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEdBQUc7Q0FBRzs7OztDQUlwQyxPQUFPLE1BQU0sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEdBQUc7Q0FBRzs7OztDQUlwQyxPQUFPLE1BQU0sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEdBQUc7Q0FBRzs7OztDQUlwQyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUk7Q0FBRzs7OztDQUl0QyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUk7Q0FBRzs7OztDQUl0QyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUk7Q0FBRzs7OztDQUl0QyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUk7Q0FBRzs7OztDQUl0QyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUk7Q0FBRzs7OztDQUl0QyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUk7Q0FBRzs7OztDQUl0QyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUk7Q0FBRzs7OztDQUl0QyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUk7Q0FBRzs7OztDQUl0QyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUk7Q0FBRzs7OztDQUl0QyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUk7Q0FBRzs7OztDQUl0QyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUk7Q0FBRzs7OztDQUl0QyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUk7Q0FBRzs7OztDQUl0QyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUk7Q0FBRzs7OztDQUl0QyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUk7Q0FBRzs7OztDQUl0QyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUk7Q0FBRzs7OztDQUl0QyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUk7Q0FBRzs7OztDQUl0QyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUk7Q0FBRzs7OztDQUl0QyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUk7Q0FBRzs7OztDQUl0QyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUk7Q0FBRzs7OztDQUl0QyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUk7Q0FBRzs7OztDQUl0QyxPQUFPLElBQUksR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLElBQUk7Q0FBRzs7OztDQUluQyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLENBQUM7Q0FBRzs7OztDQUluQyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLENBQUM7Q0FBRzs7OztDQUluQyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLENBQUM7Q0FBRzs7OztDQUluQyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLENBQUM7Q0FBRzs7OztDQUluQyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLENBQUM7Q0FBRzs7OztDQUluQyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLENBQUM7Q0FBRzs7OztDQUluQyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLENBQUM7Q0FBRzs7OztDQUluQyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLENBQUM7Q0FBRzs7OztDQUluQyxPQUFPLE9BQU8sR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLENBQUM7Q0FBRzs7OztDQUluQyxPQUFPLFFBQVEsR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUU7Q0FBRzs7OztDQUlyQyxPQUFPLFFBQVEsR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUU7Q0FBRzs7OztDQUlyQyxPQUFPLFFBQVEsR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUU7Q0FBRzs7OztDQUlyQyxPQUFPLFFBQVEsR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUU7Q0FBRzs7OztDQUlyQyxPQUFPLFFBQVEsR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUU7Q0FBRzs7OztDQUlyQyxPQUFPLFFBQVEsR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUU7Q0FBRzs7OztDQUlyQyxPQUFPLFFBQVEsR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUU7Q0FBRzs7OztDQUlyQyxPQUFPLFFBQVEsR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUU7Q0FBRzs7OztDQUlyQyxPQUFPLFFBQVEsR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUU7Q0FBRzs7OztDQUlyQyxPQUFPLFFBQVEsR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUU7Q0FBRzs7OztDQUlyQyxPQUFPLFFBQVEsR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUU7Q0FBRzs7OztDQUlyQyxPQUFPLFFBQVEsR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUU7Q0FBRzs7OztDQUlyQyxPQUFPLFFBQVEsR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUU7Q0FBRzs7OztDQUlyQyxPQUFPLFFBQVEsR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUU7Q0FBRzs7OztDQUlyQyxPQUFPLFFBQVEsR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUU7Q0FBRzs7OztDQUlyQyxPQUFPLFFBQVEsR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUU7Q0FBRzs7OztDQUlyQyxPQUFPLFFBQVEsR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUU7Q0FBRzs7OztDQUlyQyxPQUFPLFFBQVEsR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUU7Q0FBRzs7OztDQUlyQyxPQUFPLFFBQVEsR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUU7Q0FBRzs7OztDQUlyQyxPQUFPLFFBQVEsR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUU7Q0FBRzs7OztDQUlyQyxPQUFPLFFBQVEsR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUU7Q0FBRzs7OztDQUlyQyxPQUFPLFFBQVEsR0FBRztFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUU7Q0FBRzs7OztDQUlyQyxPQUFPLFFBQVEsR0FBRztFQUFFLE9BQU8sRUFBRSxHQU

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

26774BQUc7RUFDdkcsSUFBSSxTQUFTLENBQUM7RUFDZCxLQUFLLElBQUksSUFBSSxHQUFHLElBQUksTUFBTSxRQUFRLEtBQzlCLE9BQU8sS0FBSyxLQUFLLEtBQUs7RUFFMUIsT0FBTyxLQUFLLFFBQVEsUUFBUSxLQUFLO0NBQ3JDO0NBQ0EsT0FBTyxRQUFRO0VBQ1gsSUFBSSxRQUFRLEtBQUs7RUFDakIsSUFBSSxVQUFVLElBQUk7R0FDZCxRQUFRLE9BQU8sVUFBVTtHQU16QixPQUFPLFFBQUEsTUFBb0IsT0FBTyxZQUFZLDRCQUE0QixrQkFBa0I7SUFBRSxRQUFRLE9BQU87SUFBTyxRQUFRLFFBQUE7SUFBa0IsUUFBUSxPQUFPO0dBQVcsQ0FBQztFQUM3SztFQUNBLElBQUksU0FBUyxDQUFDO0VBQ2QsS0FBSyxJQUFJLElBQUksR0FBRyxJQUFJLE9BQU8sS0FDdkIsT0FBTyxLQUFLLElBQUksZUFBZSxLQUFLLEtBQUssQ0FBQztFQUU5QyxPQUFPLE9BQU8sUUFBUSxNQUFNO0NBQ2hDO0FBQ0o7Ozs7OztBQ3hKQSxJQUFhLGVBQWIsY0FBa0MsTUFBTTtDQUNwQyxZQUFZLFdBQVc7RUFDbkIsTUFBTSxRQUFRLFFBQVEsV0FBVyxLQUFLO0NBQzFDO0NBQ0EsZUFBZTtFQUNYLE9BQU87Q0FDWDtDQUNBLE9BQU8sUUFBUSxRQUFRO0VBQ25CLE1BQU0sUUFBUSxNQUFNLFlBQVksUUFBUSxNQUFNO0VBQzlDLE9BQU8sT0FBTyxXQUFXLFFBQVEsSUFBSSxDQUFDO0NBQzFDO0NBQ0EsT0FBTyxRQUFRO0VBQ1gsT0FBTyxDQUFDLENBQUMsT0FBTyxVQUFVO0NBQzlCO0FBQ0o7Ozs7OztBQ2RBLElBQWEsb0JBQWIsY0FBdUMsTUFBTTtDQUN6QyxZQUFZLE1BQU0sV0FBVztFQUN6QixNQUFNLE1BQU0sTUFBTSxXQUFXLElBQUk7Q0FDckM7Q0FDQSxlQUFlO0VBQ1gsT0FBTztDQUNYO0NBQ0EsT0FBTyxRQUFRLE9BQU87RUFDbEIsUUFBUSxhQUFhLEtBQUs7RUFDMUIsSUFBSSxTQUFTLE9BQU8sV0FBVyxNQUFNLE1BQU07RUFDM0MsVUFBVSxPQUFPLFdBQVcsS0FBSztFQUNqQyxPQUFPO0NBQ1g7Q0FDQSxPQUFPLFFBQVE7RUFDWCxPQUFPLE9BQU8sVUFBVSxPQUFPLFVBQVUsR0FBRyxJQUFJO0NBQ3BEO0FBQ0o7Ozs7QUFJQSxJQUFhLGFBQWIsY0FBZ0Msa0JBQWtCO0NBQzlDLFlBQVksV0FBVztFQUNuQixNQUFNLFNBQVMsU0FBUztDQUM1QjtDQUNBLE9BQU8sUUFBUTtFQUNYLE9BQU8sUUFBUSxNQUFNLE9BQU8sTUFBTSxDQUFDO0NBQ3ZDO0FBQ0o7Ozs7OztBQzFCQSxJQUFhLGtCQUFiLGNBQXFDLE1BQU07Q0FDdkM7Q0FDQSxZQUFZLE1BQU0sV0FBVztFQUN6QixJQUFJLE9BQU8sVUFBVSxPQUFPLElBQUk7RUFDaEMsTUFBTSxNQUFNLE1BQU0sV0FBVyxLQUFLO0VBQ2xDLGlCQUFpQixNQUFNLEVBQUUsS0FBSyxHQUFHLEVBQUUsTUFBTSxTQUFTLENBQUM7Q0FDdkQ7Q0FDQSxlQUFlO0VBQ1gsT0FBUSxxRUFBc0UsVUFBVSxHQUFHLElBQUksS0FBSyxPQUFPLENBQUM7Q0FDaEg7Q0FDQSxPQUFPLFFBQVEsUUFBUTtFQUNuQixJQUFJLE9BQU8sYUFBYSxNQUFNLFlBQVksUUFBUSxLQUFLLElBQUksQ0FBQztFQUM1RCxJQUFJLEtBQUssV0FBVyxLQUFLLE1BQ3JCLEtBQUssWUFBWSx5QkFBeUIsTUFBTTtFQUVwRCxPQUFPLE9BQU8sV0FBVyxJQUFJO0NBQ2pDO0NBQ0EsT0FBTyxRQUFRO0VBQ1gsT0FBTyxRQUFRLE9BQU8sVUFBVSxLQUFLLElBQUksQ0FBQztDQUM5QztBQUNKOzs7QUN6QkEsSUFBTSxRQUFRLElBQUksV0FBVyxDQUFDLENBQUM7Ozs7QUFJL0IsSUFBYSxZQUFiLGNBQStCLE1BQU07Q0FDakMsWUFBWSxXQUFXO0VBQ25CLE1BQU0sUUFBUSxJQUFJLFdBQVcsS0FBSztDQUN0QztDQUNBLGVBQWU7RUFDWCxPQUFPO0NBQ1g7Q0FDQSxPQUFPLFFBQVEsT0FBTztFQUNsQixJQUFJLFNBQVMsTUFDVCxLQUFLLFlBQVksWUFBWSxLQUFLO0VBRXRDLE9BQU8sT0FBTyxXQUFXLEtBQUs7Q0FDbEM7Q0FDQSxPQUFPLFFBQVE7RUFDWCxPQUFPLFVBQVUsQ0FBQztFQUNsQixPQUFPO0NBQ1g7QUFDSjs7O0FDbkJBLElBQU1DLFNBQU8sT0FBTyxDQUFDO0FBQ3JCLElBQU1DLFNBQU8sT0FBTyxDQUFDO0FBQ3JCLElBQU1DLG1CQUFpQixPQUFPLG9FQUFvRTs7OztBQUlsRyxJQUFhLGNBQWIsY0FBaUMsTUFBTTtDQUNuQztDQUNBO0NBQ0EsWUFBWSxNQUFNLFFBQVEsV0FBVztFQUNqQyxNQUFNLFFBQVMsU0FBUyxRQUFRLFVBQVcsT0FBTztFQUNsRCxNQUFNLE1BQU0sTUFBTSxXQUFXLEtBQUs7RUFDbEMsaUJBQWlCLE1BQU07R0FBRTtHQUFNO0VBQU8

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

26774FZLEtBQUssTUFBTSxPQUFPLEdBQUcsc0JBQXNCLFFBQVEsSUFBSTtFQUNwRyxTQUFTLE9BQU8sT0FBTyxPQUFPLE1BQU0sQ0FBQztFQUNyQyxpQkFBaUIsTUFBTSxFQUFFLEtBQUssQ0FBQztDQUNuQztBQUNKO0FBQ0EsU0FBUyxXQUFXLFFBQVEsUUFBUTtDQUNoQyxPQUFPLE1BQU0sT0FBTyxLQUFLLE1BQU0sRUFBRSxPQUFPLE1BQU0sQ0FBQyxDQUFDLENBQUMsS0FBTSxXQUFXLFNBQVUsT0FBTyxHQUFHLElBQUk7QUFDOUY7Ozs7QUFJQSxJQUFhLGdCQUFiLE1BQWEsc0JBQXNCLGNBQWM7Ozs7Q0FJN0MsWUFBWSxPQUFPLE1BQU0sUUFBUTtFQUM3QixNQUFNLE9BQU8sU0FBUyxNQUFNLE1BQU07RUFDbEMsT0FBTyxlQUFlLE1BQU1DLFlBQVUsRUFBRSxPQUFPLHNCQUFzQixDQUFDO0NBQzFFOzs7O0NBSUEsSUFBSSxXQUFXO0VBQ1gsT0FBTyxHQUFHLEtBQUssT0FBTyxTQUFTLENBQUMsQ0FBQyxDQUFDLFVBQVUsR0FBRyxFQUFFO0NBQ3JEOzs7O0NBSUEsT0FBTyxRQUFRO0VBQ1gsSUFBSSxVQUFVLE1BQ1YsU0FBUztFQUViLElBQUksV0FBVyxRQUNYLE9BQU8sS0FBSyxVQUFVO0dBQ2xCLE1BQU07R0FDTixNQUFNLEtBQUs7R0FDWCxRQUFRLEtBQUssT0FBTyxLQUFLLFVBQVUsS0FBSyxNQUFNLE1BQU0sT0FBTyxNQUFNLENBQUMsQ0FBQztFQUN2RSxDQUFDO0VBRUwsTUFBTSxTQUFTLENBQUM7RUFDaEIsSUFBSSxXQUFXLFdBQ1gsT0FBTyxLQUFLLE9BQU87RUFFdkIsT0FBTyxLQUFLLEtBQUssT0FBTyxXQUFXLFFBQVEsS0FBSyxNQUFNLENBQUM7RUFDdkQsT0FBTyxPQUFPLEtBQUssR0FBRztDQUMxQjs7OztDQUlBLE9BQU8sS0FBSyxLQUFLO0VBQ2IsSUFBSSxjQUFjLFdBQVcsR0FBRyxHQUM1QixPQUFPO0VBRVgsSUFBSSxPQUFRLFFBQVMsVUFDakIsT0FBTyxjQUFjLEtBQUssSUFBSSxHQUFHLENBQUM7T0FFakMsSUFBSSxlQUFlLGFBQWE7R0FDakMsTUFBTSxPQUFPLFlBQVksU0FBUyxHQUFHO0dBQ3JDLE1BQU0sU0FBUyxjQUFjLEdBQUc7R0FDaEMsV0FBVyxHQUFHO0dBQ2QsT0FBTyxJQUFJLGNBQWNELFVBQVEsTUFBTSxNQUFNO0VBQ2pEO0VBQ0EsT0FBTyxJQUFJLGNBQWNBLFVBQVEsSUFBSSxNQUFNLElBQUksU0FBUyxJQUFJLE9BQU8sSUFBSSxVQUFVLElBQUksSUFBSSxDQUFDLENBQUM7Q0FDL0Y7Ozs7O0NBS0EsT0FBTyxXQUFXLE9BQU87RUFDckIsT0FBUSxTQUFTLE1BQU1DLGdCQUFjO0NBQ3pDO0FBQ0o7Ozs7QUFJQSxJQUFhLGdCQUFiLE1BQWEsc0JBQXNCLGNBQWM7Ozs7Q0FJN0M7Ozs7Q0FJQSxZQUFZLE9BQU8sTUFBTSxRQUFRLFdBQVc7RUFDeEMsTUFBTSxPQUFPLFNBQVMsTUFBTSxNQUFNO0VBQ2xDLE9BQU8sZUFBZSxNQUFNQSxZQUFVLEVBQUUsT0FBTyxzQkFBc0IsQ0FBQztFQUN0RSxpQkFBaUIsTUFBTSxFQUFFLFVBQVUsQ0FBQztDQUN4Qzs7OztDQUlBLElBQUksWUFBWTtFQUNaLE9BQU8sR0FBRyxLQUFLLE9BQU8sU0FBUyxDQUFDO0NBQ3BDOzs7O0NBSUEsT0FBTyxRQUFRO0VBQ1gsSUFBSSxVQUFVLE1BQ1YsU0FBUztFQUViLElBQUksV0FBVyxRQUNYLE9BQU8sS0FBSyxVQUFVO0dBQ2xCLE1BQU07R0FDTixXQUFXLEtBQUs7R0FDaEIsTUFBTSxLQUFLO0dBQ1gsUUFBUSxLQUFLLE9BQU8sS0FBSyxNQUFNLEtBQUssTUFBTSxFQUFFLE9BQU8sTUFBTSxDQUFDLENBQUM7RUFDL0QsQ0FBQztFQUVMLE1BQU0sU0FBUyxDQUFDO0VBQ2hCLElBQUksV0FBVyxXQUNYLE9BQU8sS0FBSyxPQUFPO0VBRXZCLE9BQU8sS0FBSyxLQUFLLE9BQU8sV0FBVyxRQUFRLEtBQUssTUFBTSxDQUFDO0VBQ3ZELElBQUksV0FBVyxhQUFhLEtBQUssV0FDN0IsT0FBTyxLQUFLLFdBQVc7RUFFM0IsT0FBTyxPQUFPLEtBQUssR0FBRztDQUMxQjs7OztDQUlBLE9BQU8sYUFBYSxNQUFNLFFBQVE7RUFDOUIsVUFBVSxVQUFVLENBQUMsRUFBQSxDQUFHLEtBQUssTUFBTSxVQUFVLEtBQUssQ0FBQyxDQUFDO0VBRXBELE9BQU8sSUFEYyxjQUFjRCxVQUFRLE1BQU0sUUFBUSxLQUMzQyxDQUFDLENBQUM7Q0FDcEI7Ozs7Q0FJQSxPQUFPLEtBQUssS0FBSztFQUNiLElBQUksY0FBYyxXQUFXLEdBQUcsR0FDNUIsT0FBTztFQUVYLElBQUksT0FBUSxRQUFTLFVBQ2pCLElBQUk7R0FDQSxPQUFPLGNBQWMsS0FBSyxJQUFJLEdBQUcsQ0FBQztFQUN0QyxTQUNPLE9BQU87R0FDVixlQUFlLE9BQU8sMEJBQTBCLE9BQU8sR0FBRztFQUM5RDtPQUVDLElBQUksZUFBZSxhQUFhO0dBQ2pDLE1BQU0sT0FBTyxZQUFZLFNBQVMsR0FBRztHQUNyQyxNQUFNLFNBQVMsY0FBYyxLQUFLLElBQUk7R0FDdEMsTUFBTSxZQUFZLENBQUMsQ0FBQyxnQkFBZ0IsS0FBSyxPQUFPLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQyxDQUFDLElBQUksV0FBVztHQUMvRSxXQUFXLEdBQUc7R0FDZCxPQUFPLElBQUksY0FBY0EsVUFBUSxNQUFNLFFBQVEsU0FBUztFQUM1RDtFQUNBLE9BQU8sSUFBSSxjQUFjQSxVQUFRLElBQUksTUFBTSxJQUFJLFNBQVMsSUFBSSxPQUFPLEtBQUssTUFBTSxVQUFVLEtBQUssR0FBRyxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksU0FBUztDQUNoSTs7Ozs7Q0FLQSxPQUFPLFdBQVcsT0FBTztFQUNyQixPQUFRLFNBQVMsTUFBTUMsZ0JBQWM7Q0FDekM7QUFDSjs7OztBQUlBLElBQWEsc0JBQWIsTUFBYSw0QkFBNEIsU0FBUzs7OztDQUk5Qzs7OztDQUlBOzs7O0NBSUEsWUFBWSxPQUFPLE1BQU0sUUFBUSxTQUFTLEtBQUs7RUFDM0MsTUFBTSxPQUFPLE1BQU0sTUFBTTtFQUN6QixPQUFPLGVBQWUsTUFBTUEsWUFBVSxFQUFFLE9BQU8sNEJBQTRCLENBQUM7RUFDNUUsaUJBQWlCLE1BQU07R0FBRTtHQUFTO0VBQUksQ0FBQztDQUMzQzs7OztDQUlBLE9BQU8sUUFBUTtFQUNYLE9BQU8sVUFBVSxRQUFRLFdBQVcsV0FBVywyQ0FBMkMseUJBQXlCLEVBQUUsV0FBVyxrQkFBa0IsQ0FBQztFQUNuSixJQUFJLFdBQVcsUUFDWCxPQUFPLEtBQUssVUFBVTtHQUNsQixNQUFNO0dBQ04saUJBQWtCLEtBQUssVUFBVSxZQUFZO0dBQzdDLFNBQVMsS0FBSztHQUNkLEtBQU8sS0FBSyxPQUFPLE9BQVEsS0FBSyxNQUFNLEtBQUE7R0FDdEMsUUFBUSxLQUFLLE9BQU8sS0FBSyxNQUFNLEtBQUssTUFBTSxFQUFFLE9BQU8sTUFBTSxDQUFDLENBQUM7RUFDL0QsQ0FBQztFQUVMLE1BQU0sU0FBUyxDQUFDLGNBQWMsV0FBVyxRQUFRLEtBQUssTUFBTSxHQUFHO0VBQy9ELElBQUksS0FBSyxTQUNMLE9BQU8sS0FBSyxTQUFTO0VBRXpCLElBQUksS0FBSyxPQUFPLE1BQ1osT0FBTyxLQUFLLElBQUksS0FBSyxJQUFJLFNBQVMsR0FBRztFQUV6QyxPQUFPLE9BQU8sS0FBSyxHQUFHO0NBQzFCOzs7O0NBSUEsT0FBTyxLQUFLLEtBQUs7RUFDYixJQUFJLG9CQUFvQixXQUFXLEdBQUcsR0FDbEMsT0FBTztFQUVYLElBQUksT0FBUSxRQUFTLFVBQ2pCLElBQUk7R0FDQSxPQUFPLG9CQUFvQixLQUFLLElBQUksR0FBRyxDQUFDO0VBQzVDLFNBQ08sT0FBTztHQUNWLGVBQWUsT0FBTywrQkFBK0IsT0FBTyxHQUFHO0VBQ25FO09BRUMsSUFBSSxlQUFlLGFBQWE7R0FDakMsZ0JBQWdCLEtBQUssT0FBTyxDQUFDLGFBQWEsQ0FBQyxDQUFDO0dBQzVDLE1BQU0sU0FBUyxjQUFjLEdBQUc7R0FDaEMsTUFBTSxVQUFVLENBQUMsQ0FBQyxnQkFBZ0IsS0FBSyxhQUFhLENBQUMsQ0FBQyxJQUFJLFNBQVM7R0FDbkUsTUFBTSxNQUFNLFdBQVcsR0FBRztHQUMxQixXQUFXLEdBQUc7R0FDZCxPQUFPLElBQUksb0JBQW9CRCxVQUFRLGVBQWUsUUFBUSxTQUFTLEdBQUc7RUFDOUU7RUFDQSxPQUFPLElBQUksb0JBQW9CQSxVQUFRLGVBQWUsSUFBSSxTQUFTLElBQUksT0FBTyxJQUFJLFVBQVUsSUFBSSxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBSSxTQUFVLElBQUksT0FBTyxPQUFRLElBQUksTUFBTSxJQUFJO0NBQzdKOzs7OztDQUtBLE9BQU8sV0FBVyxPQUFPO0VBQ3JCLE9BQVEsU0FBUyxNQUFNQyxnQkFBYztDQUN6QztBQUNKOzs7O0FBSUEsSUFBYSxtQkFBYixNQUFhLHlCQUF5QixTQUFTOzs7O0NBSTNDO0NBQ0EsWUFBWSxPQUFPLFFBQVEsU0FBUztFQUNoQyxNQUFNLE9BQU8sWUFBWSxNQUFNO0VBQy9CLE9BQU8sZUFBZSxNQUFNQSxZQUFVLEVBQUUsT0FBTyx5QkFBeUIsQ0FBQztFQUN6RSxpQkFBaUIsTUFBTSxFQUFFLFFBQVEsQ0FBQztDQUN0Qzs7OztDQUlBLE9BQU8sUUFBUTtFQUNYLE1BQU0sT0FBUyxLQUFLLE9BQU8sV0FBVyxJQUFLLFlBQVk7RUFDdkQsSUFBSSxXQUFXLFFBQVE7R0FDbkIsTUFBTSxrQkFBbUIsS0FBSyxVQUFVLFlBQVk7R0FDcEQsT0FBTyxLQUFLLFVBQVU7SUFBRTtJQUFNO0dBQWdCLENBQUM7RUFDbkQ7RUFDQSxPQUFPLEdBQUcsS0FBSyxJQUFJLEtBQUssVUFBVSxhQU

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

26774FZO0VBQ3ZFLEVBQUEsQ0FBRztDQUNQO0NBQ0EsaUJBQWlCO0VBQ2IsT0FBTyxLQUFLO0NBQ2hCO0FBQ0o7QUFPQSxTQUFTLFVBQVUsT0FBTyxTQUFTO0NBQy9CLElBQUksU0FBUyxNQUNULE9BQU87Q0FFWCxJQUFJLE9BQVEsTUFBTSxhQUFjLFlBQzVCLE9BQU87Q0FFWCxJQUFJLE1BQU0sWUFBWSxPQUFRLE1BQU0sU0FBUyxhQUFjLFlBQ3ZELE9BQU8sTUFBTTtDQUVqQixPQUFPO0FBQ1g7QUFDQSxTQUFTLFlBQVksT0FBTztDQUN4QixJQUFJLFNBQVMsTUFDVCxPQUFPO0NBRVgsT0FBTyxNQUFNLFlBQVk7QUFDN0I7Ozs7QUFJQSxlQUFzQixjQUFjLEtBQUssU0FBUztDQUU5QyxNQUFNLGFBQWEsTUFBTSxZQUFZLEtBQUssV0FBVztDQUNyRCxlQUFlLE9BQVEsZUFBZ0IsVUFBVSwrQkFBK0IsYUFBYSxHQUFHO0NBRWhHLE1BQU0sWUFBWSxZQUFZLFVBQVU7Q0FDeEMsZUFBZSxVQUFVLE1BQU0sU0FBUyxXQUFXLENBQUMsRUFBQSxDQUFHLFFBQVEsSUFBSSxLQUFLLEdBQUcsc0JBQXNCLGdCQUFnQixVQUFVLEVBQUU7Q0FDN0gsZUFBZSxVQUFVLFFBQVEsU0FBUyxXQUFXLENBQUMsRUFBQSxDQUFHLFFBQVEsTUFBTSxLQUFLLEdBQUcsd0JBQXdCLGtCQUFrQixVQUFVLElBQUk7Q0FFdkksSUFBSSxVQUFVLE1BQ1YsVUFBVSxPQUFPLFVBQVU7Q0FFL0IsT0FBTztBQUNYOzs7O0FBSUEsZUFBc0IsWUFBWSxTQUFTLFFBQVEsTUFBTTtDQUVyRCxNQUFNLFNBQVMsVUFBVSxTQUFTLGFBQWE7Q0FDL0MsTUFBTSxXQUFXLFdBQVcsTUFBTSxJQUFJLFNBQVM7Q0FDL0MsT0FBTyxNQUFNLFFBQVEsSUFBSSxPQUFPLEtBQUssT0FBTyxVQUFVO0VBQ2xELE9BQU8sTUFBTSxVQUFVLEtBQUssU0FBUyxNQUFNLFVBQVU7R0FDakQsUUFBUSxNQUFNLFlBQVksT0FBTyxJQUFJO0dBQ3JDLElBQUksU0FBUyxXQUNULE9BQU8sZUFBZSxPQUFPLFFBQVE7R0FFekMsT0FBTztFQUNYLENBQUM7Q0FDTCxDQUFDLENBQUM7QUFDTjtBQUNBLFNBQVMscUJBQXFCLFVBQVU7Q0FDcEMsTUFBTSxzQkFBc0IsZUFBZ0IsV0FBVztFQUVuRCxNQUFNLEtBQU0sTUFBTSxjQUFjLFdBQVcsQ0FBQyxNQUFNLENBQUM7RUFDbkQsR0FBRyxLQUFLLE1BQU0sU0FBUyxXQUFXO0VBQ2xDLElBQUksR0FBRyxNQUNILEd

26774BQUcsT0FBTyxNQUFNLGVBQWUsR0FBRyxNQUFNLFlBQVksU0FBUyxNQUFNLENBQUM7RUFFeEUsTUFBTSxRQUFRLFNBQVM7RUFDdkIsTUFBTSxVQUFXLFVBQVcsR0FBRyxTQUFTQSxRQUFPLGlCQUFpQixNQUFNQTtFQUN0RSxNQUFNLFVBQVcsR0FBRyxRQUFRLFVBQVU7RUFDdEMsSUFBSSxNQUFNLFlBQVksQ0FBQyxNQUFNLFNBQVMsV0FBVyxNQUFNLFdBQVcsQ0FBQyxVQUFVLENBQUMsU0FDMUUsZUFBZSxPQUFPLHFFQUFxRSxhQUFhLFNBQVM7RUFFckgsZUFBZSxNQUFNLFlBQVksUUFBUSw2Q0FBNkMsa0JBQWtCLEdBQUcsSUFBSTtFQUcvRyxlQURnQixNQUFNLFdBQVksTUFBTSxZQUFZLE1BQU0sU0FBUyxXQUN6QyxTQUFTLDZDQUE2QyxtQkFBbUIsR0FBRyxLQUFLO0VBRTNHLGVBQWUsTUFBTSxZQUFZLFFBQVEsNkNBQTZDLGtCQUFrQixHQUFHLElBQUk7RUFDL0csT0FBTztDQUNYO0NBQ0EsTUFBTSxhQUFhLGVBQWdCLFdBQVc7RUFDMUMsTUFBTSxTQUFTLFVBQVUsU0FBUyxRQUFRLE1BQU07RUFDaEQsT0FBTyxRQUFRLE1BQU0sR0FBRyw0Q0FBNEMseUJBQXlCLEVBQUUsV0FBVyxPQUFPLENBQUM7RUFDbEgsTUFBTSxLQUFLLE1BQU0sb0JBQW9CLFNBQVM7RUFDOUMsSUFBSTtHQUNBLE9BQU8sTUFBTSxPQUFPLEtBQUssRUFBRTtFQUMvQixTQUNPLE9BQU87R0FDVixJQUFJLGdCQUFnQixLQUFLLEtBQUssTUFBTSxNQUNoQyxNQUFNLFNBQVMsVUFBVSxVQUFVLE1BQU0sTUFBTSxFQUFFO0dBRXJELE1BQU07RUFDVjtDQUNKO0NBQ0EsTUFBTSxPQUFPLGVBQWdCLFdBQVc7RUFDcEMsTUFBTSxTQUFTLFNBQVM7RUFDeEIsT0FBTyxRQUFRLE1BQU0sR0FBRyx5REFBeUQseUJBQXlCLEVBQUUsV0FBVyxrQkFBa0IsQ0FBQztFQUMxSSxNQUFNLEtBQUssTUFBTSxPQUFPLGdCQUFnQixNQUFNLG9CQUFvQixTQUFTLENBQUM7RUFDNUUsTUFBTSxXQUFXLFlBQVksU0FBUyxNQUFNO0VBRzVDLE9BQU8sSUFBSSw0QkFBNEIsU0FBUyxXQUFXLFVBQVUsRUFBRTtDQUMzRTtDQUNBLE1BQU0sY0FBYyxlQUFnQixXQUFXO0VBQzNDLE1BQU0sU0FBUyxVQUFVLFNBQVMsUUFBUSxhQUFhO0VBQ3ZELE9BQU8sWUFBWSxNQUFNLEdBQUcsbURBQW1ELHlCQUF5QixFQUFFLFdBQVcsY0FBYyxDQUFDO0VBQ3BJLE9BQU8sTUFBTSxPQUFPLFlBQVksTUFBTSxvQkFBb0IsU0FBUyxDQUFDO0NBQ3hFO0NBQ0EsTUFBTSxTQUFTLE9BQU8sY0FBYztFQUNoQyxPQUFPLE1BQU0sS0FBSyxTQUFTO0NBQy9CO0NBQ0EsaUJBQWlCLFFBQVE7RUFDckIsV0FBVztFQUNYO0VBQ0E7RUFDQTtFQUFNO0NBQ1YsQ0FBQztDQUNELE9BQU87QUFDWDtBQUNBLFNBQVMsbUJBQW1CLFVBQVUsS0FBSztDQUN2QyxNQUFNLGNBQWMsU0FBVSxHQUFHLE1BQU07RUFDbkMsTUFBTSxXQUFXLFNBQVMsVUFBVSxZQU

26774FZLEtBQUssSUFBSTtFQUN6RCxPQUFPLFVBQVUsd0JBQXdCLHlCQUF5QjtHQUM5RCxXQUFXO0dBQ1gsTUFBTTtJQUFFO0lBQUs7R0FBSztFQUN0QixDQUFDO0VBQ0QsT0FBTztDQUNYO0NBQ0EsTUFBTSxzQkFBc0IsZUFBZ0IsR0FBRyxNQUFNO0VBQ2pELE1BQU0sV0FBVyxZQUFZLEdBQUcsSUFBSTtFQUVwQyxJQUFJLFlBQVksQ0FBQztFQUNqQixJQUFJLFNBQVMsT0FBTyxTQUFTLE1BQU0sS0FBSyxRQUFRO0dBQzVDLFlBQVksTUFBTSxjQUFjLEtBQUssSUFBSSxDQUFDO0dBQzFDLElBQUksVUFBVSxNQUNWLFVBQVUsT0FBTyxNQUFNLGVBQWUsVUFBVSxNQUFNLFlBQVksU0FBUyxNQUFNLENBQUM7RUFFMUY7RUFDQSxJQUFJLFNBQVMsT0FBTyxXQUFXLEtBQUssUUFDaEMsTUFBTSxJQUFJLE1BQU0sNEVBQTRFO0VBRWhHLE1BQU0sZUFBZSxNQUFNLFlBQVksU0FBUyxRQUFRLFNBQVMsUUFBUSxJQUFJO0VBQzdFLE9BQU8sT0FBTyxPQUFPLENBQUMsR0FBRyxXQUFXLE1BQU0sa0JBQWtCO0dBQ3hELElBQUksU0FBUyxXQUFXO0dBQ3hCLE1BQU0sU0FBUyxVQUFVLG1CQUFtQixVQUFVLFlBQVk7RUFDdEUsQ0FBQyxDQUFDO0NBQ047Q0FDQSxNQUFNLGFBQWEsZUFBZ0IsR0FBRyxNQUFNO0VBQ3hDLE1BQU0sU0FBUyxNQUFNLGlCQUFpQixHQUFHLElBQUk7RUFDN0MsSUFBSSxPQUFPLFdBQVcsR0FDbEIsT0FBTyxPQUFPO0VBRWxCLE9BQU87Q0FDWDtDQUNBLE1BQU0sT0FBTyxlQUFnQixHQUFHLE1BQU07RUFDbEMsTUFBTSxTQUFTLFNBQVM7RUFDeEIsT0FBTyxRQUFRLE1BQU0sR0FBRyx5REFBeUQseUJBQXlCLEVBQUUsV0FBVyxrQkFBa0IsQ0FBQztFQUMxSSxNQUFNLEtBQUssTUFBTSxPQUFPLGdCQUFnQixNQUFNLG9CQUFvQixHQUFHLElBQUksQ0FBQztFQUMxRSxNQUFNLFdBQVcsWUFBWSxTQUFTLE1BQU07RUFHNUMsT0FBTyxJQUFJLDRCQUE0QixTQUFTLFdBQVcsVUFBVSxFQUFFO0NBQzNFO0NBQ0EsTUFBTSxjQUFjLGVBQWdCLEdBQUcsTUFBTTtFQUN6QyxNQUFNLFNBQVMsVUFBVSxTQUFTLFFBQVEsYUFBYTtFQUN2RCxPQUFPLFlBQVksTUFBTSxHQUFHLG1EQUFtRCx5QkFBeUIsRUFBRSxXQUFXLGNBQWMsQ0FBQztFQUNwSSxPQUFPLE1BQU0sT0FBTyxZQUFZLE1BQU0sb0JBQW9CLEdBQUcsSUFBSSxDQUFDO0NBQ3RFO0NBQ0EsTUFBTSxtQkFBbUIsZUFBZ0IsR0FBRyxNQUFNO0VBQzlDLE1BQU0sU0FBUyxVQUFVLFNBQVMsUUFBUSxNQUFNO0VBQ2hELE9BQU8sUUFBUSxNQUFNLEdBQUcsNENBQTRDLHlCQUF5QixFQUFFLFdBQVcsT0FBTyxDQUFDO0VBQ2xILE1BQU0sS0FBSyxNQUFNLG9CQUFvQixHQUFHLElBQUk7RUFDNUMsSUFBSSxTQUFTO0VBQ2IsSUFBSTtHQUNBLFNBQVMsTUFBTSxPQUFPLEtBQUssRUFBRTtFQUNqQyxTQUNPLE9BQU87R0FDVixJQUFJLGdCQUFnQixLQUFLLEtBQUssTUFBTSxNQUNoQyxNQUFNLFNBQVMsVUFBVSxVQUFVLE1BQU0sTUFBTSxFQUFFO0dBRXJELE1BQU07RUFDVjtFQUNBLE1BQU0sV0FBVyxZQUFZLEdBQUcsSUFBSTtFQUNwQyxPQUFPLFNBQVMsVUFBVSxxQkFBcUIsVUFBVSxNQUFNO0NBQ25FO0NBQ0EsTUFBTSxTQUFTLE9BQU8sR0FBRyxTQUFTO0VBRTlCLElBRGlCLFlBQVksR0FBRyxJQUNyQixDQUFDLENBQUMsVUFDVCxPQUFPLE1BQU0sV0FBVyxHQUFHLElBQUk7RUFFbkMsT0FBTyxNQUFNLEtBQUssR0FBRyxJQUFJO0NBQzdCO0NBQ0EsaUJBQWlCLFFBQVE7RUFDckIsTUFBTSxTQUFTLFVBQVUsZ0JBQWdCLEdBQUc7RUFDNUMsV0FBVztFQUFVLE1BQU07RUFDM0I7RUFDQTtFQUNBO0VBQ0E7RUFBTTtFQUFZO0NBQ3RCLENBQUM7Q0FFRCxPQUFPLGVBQWUsUUFBUSxZQUFZO0VBQ3RDLGNBQWM7RUFDZCxZQUFZO0VBQ1osV0FBVztHQUNQLE1BQU0sV0FBVyxTQUFTLFVBQVUsWUFBWSxHQUFHO0dBQ25ELE9BQU8sVUFBVSx3QkFBd0IseUJBQXlCO0lBQzlELFdBQVc7SUFDWCxNQUFNLEVBQUUsSUFBSTtHQUNoQixDQUFDO0dBQ0QsT0FBTztFQUNYO0NBQ0osQ0FBQztDQUNELE9BQU87QUFDWDtBQUNBLFNBQVMsa0JBQWtCLFVBQVUsS0FBSztDQUN0QyxNQUFNLGNBQWMsU0FBVSxHQUFHLE1BQU07RUFDbkMsTUFBTSxXQUFXLFNBQVMsVUFBVSxTQUFTLEtBQUssSUFBSTtFQUN0RCxPQUFPLFVBQVUsd0JBQXdCLHlCQUF5QjtHQUM5RCxXQUFXO0dBQ1gsTUFBTTtJQUFFO0lBQUs7R0FBSztFQUN0QixDQUFDO0VBQ0QsT0FBTztDQUNYO0NBQ0EsTUFBTSxTQUFTLFNBQVUsR0FBRyxNQUFNO0VBQzlCLE9BQU8sSUFBSSxvQkFBb0IsVUFBVSxZQU

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

26774QUFNO0dBQUU7R0FBUTtHQUFRLFdBQVc7RUFBTSxDQUFDO0VBQzNELE9BQU8sZUFBZSxNQUFNLFVBQVUsRUFBRSxPQUFPLENBQUMsRUFBRSxDQUFDO0VBQ25ELElBQUk7RUFDSixJQUFJLE9BQU87RUFDWCxJQUFJLFdBQVc7RUFDZixJQUFJLFdBQVc7R0FDWCxNQUFNLFdBQVcsWUFBWSxNQUFNO0dBR25DLFdBQVcsSUFBSSw0QkFBNEIsS0FBSyxXQUFXLFVBQVUsU0FBUztFQUNsRjtFQUNBLElBQUksdUJBQU8sSUFBSSxJQUFJO0VBRW5CLElBQUksT0FBUSxXQUFZLFVBQVU7R0FDOUIsSUFBSSxZQUFZLE1BQU0sR0FBRztJQUNyQixPQUFPO0lBQ1AsY0FBYyxRQUFRLFFBQVEsTUFBTTtHQUN4QyxPQUNLO0lBQ0QsTUFBTSxXQUFXLFVBQVUsUUFBUSxhQUFhO0lBQ2hELElBQUksQ0FBQyxXQUFXLFFBQVEsR0FDcEIsTUFBTSxVQUFVLG9EQUFvRCx5QkFBeUIsRUFDekYsV0FBVyxjQUNmLENBQUM7SUFFTCxjQUFjLFNBQVMsWUFBWSxNQUFNLENBQUMsQ0FBQyxNQUFNLFNBQVM7S0FDdEQsSUFBSSxRQUFRLE1BQ1IsTUFBTSxVQUFVLHVFQUF1RSxxQkFBcUIsRUFDeEcsT0FBTyxPQUNYLENBQUM7S0FFTCxZQUFZLElBQUksQ0FBQyxDQUFDLE9BQU87S0FDekIsT0FBTztJQUNYLENBQUM7R0FDTDtFQUNKLE9BRUksY0FBYyxPQUFPLFdBQVcsQ0FBQyxDQUFDLE1BQU0sU0FBUztHQUM3QyxJQUFJLFFBQVEsTUFDUixNQUFNLElBQUksTUFBTSxNQUFNO0dBRTFCLFlBQVksSUFBSSxDQUFDLENBQUMsT0FBTztHQUN6QixPQUFPO0VBQ1gsQ0FBQztFQUdMLFlBQVksTUFBTTtHQUFFO0dBQWE7R0FBTTtHQUFVO0VBQUssQ0FBQztFQUV2RCxNQUFNLFVBQVUsSUFBSSxNQUFNLENBQUMsR0FBRztHQUMxQixNQUFNLFFBQVEsTUFBTSxhQUFhO0lBRTdCLElBQUksT0FBUSxTQUFVLFlBQVksZUFBZSxRQUFRLElBQUksS0FBSyxHQUM5RCxPQUFPLFFBQVEsSUFBSSxRQUFRLE1BQU0sUUFBUTtJQUU3QyxJQUFJO0tBQ0EsT0FBTyxLQUFLLFNBQVMsSUFBSTtJQUM3QixTQUNPLE9BQU87S0FDVixJQUFJLENBQUMsUUFBUSxPQUFPLGtCQUFrQixLQUFLLE1BQU0sYUFBYSxPQUMxRCxNQUFNO0lBRWQ7R0FFSjtHQUNBLE1BQU0sUUFBUSxTQUFTO0lBRW5CLElBQUksZUFBZSxRQUFRLElBQUksS0FBSyxHQUNoQyxPQUFPLFFBQVEsSUFBSSxRQUFRLElBQUk7SUFFbkMsT0FBTyxRQUFRLElBQUksUUFBUSxJQUFJLEtBQUssS0FBSyxVQUFVLFNBQVMsT0FBTyxJQUFJLENBQUM7R0FDNUU7RUFDSixDQUFDO0VBQ0QsaUJBQWlCLE1BQU0sRUFBRSxRQUFRLENBQUM7RUFDbEMsaUJBQWlCLE1BQU0sRUFDbkIsVUFBWSxNQUFNLFdBQVcsTUFBTSxXQUFhLHFCQUFxQixJQUFJLElBQUssS0FDbEYsQ0FBQztFQUVELE9BQU8sSUFBSSxNQUFNLE1BQU07R0FDbkIsTUFBTSxRQUFRLE1BQU0sYUFBYTtJQUM3QixJQUFJLE9BQVEsU0FBVSxZQUFZLFFBQVEsVUFBVSxlQUFlLFFBQVEsSUFBSSxLQUFLLEdBQ2hGLE9BQU8sUUFBUSxJQUFJLFFBQVEsTUFBTSxRQUFRO0lBRzdDLElBQUk7S0FDQSxPQUFPLE9BQU8sWUFBWSxJQUFJO0lBQ2xDLFNBQ08sT0FBTztLQUNWLElBQUksQ0FBQyxRQUFRLE9BQU8sa0JBQWtCLEtBQUssTUFBTSxhQUFhLE9BQzFELE1BQU07SUFFZDtHQUVKO0dBQ0EsTUFBTSxRQUFRLFNBQVM7SUFDbkIsSUFBSSxPQUFRLFNBQVUsWUFBWSxRQUFRLFVBQVUsZUFBZSxRQUFRLElBQUksS0FBSyxHQUNoRixPQUFPLFFBQVEsSUFBSSxRQUFRLElBQUk7SUFFbkMsT0FBTyxPQUFPLFVBQVUsWUFBWSxJQUFJO0dBQzVDO0VBQ0osQ0FBQztDQUNMOzs7OztDQUtBLFFBQVEsUUFBUTtFQUNaLE9BQU8sSUFBSSxhQUFhLEtBQUssUUFBUSxLQUFLLFdBQVcsTUFBTTtDQUMvRDs7Ozs7Q0FLQSxPQUFPLFFBQVE7RUFDWCxPQUFPLElBQUksYUFBYSxRQUFRLEtBQUssV0FBVyxLQUFLLE1BQU07Q0FDL0Q7Ozs7Q0FJQSxNQUFNLGFBQWE7RUFBRSxPQUFPLE1BQU0sWUFBWSxJQUFJLENBQUMsQ0FBQztDQUFhOzs7O0NBSWpFLE1BQU0sa0JBQWtCO0VBQ3BCLE1BQU0sV0FBVyxZQUFZLEtBQUssTUFBTTtFQUN4QyxPQUFPLFVBQVUscUNBQXFDLHlCQUF5QixFQUFFLFdBQVcsa0JBQWtCLENBQUM7RUFDL0csTUFBTSxPQUFPLE1BQU0sU0FBUyxRQUFRLE1BQU0sS0FBSyxXQUFXLENBQUM7RUFDM0QsSUFBSSxTQUFTLE1BQ1QsT0FBTztFQUVYLE9BQU87Q0FDWDs7Ozs7Q0FLQSxNQUFNLG9CQUFvQjtFQUV0QixNQUFNLFdBQVcsS0FBSyxzQkFBc0I7RUFDNUMsSUFBSSxVQUFVO0dBQ1YsTUFBTSxTQUFTLEtBQUs7R0FDcEIsT0FBTztFQUNYO0VBR0EsSUFBSSxNQURlLEtBQUssZ0JBQWdCLEtBQzVCLE1BQ1IsT0FBTztFQUdYLE1BQU0sV0FBVyxZQUFZLEtBQUssTUFBTTtFQUN4QyxPQUFPLFlBQVksTUFBTSw4Q0FBOEMseUJBQXlCLEVBQUUsV0FBVyxvQkFBb0IsQ0FBQztFQUNsSSxPQUFPLElBQUksU0FBUyxTQUFTLFdBQVc7R0FDcEMsTUFBTSxZQUFZLFlBQVk7SUFDMUIsSUFBSTtLQUVBLElBQUksTUFEZSxLQUFLLGdCQUFnQixLQUM1QixNQUNSLE9BQU8sUUFBUSxJQUFJO0tBRXZCLFNBQVMsS0FBSyxTQUFTLFNBQVM7SUFDcEMsU0FDTyxPQUFPO0tBQ1YsT0FBTyxLQUFLO0lBQ2hCO0dBQ0o7R0FDQSxVQUFVO0VBQ2QsQ0FBQztDQUNMOzs7Ozs7O0NBT0Esd0JBQXdCO0VBQ3BCLE9BQU8sWUFBWSxJQUFJLENBQUMsQ0FBQztDQUM3Qjs7Ozs7O0NBTUEsWUFBWSxLQUFLO0VBQ2IsSUFBSSxPQUFRLFFBQVMsVUFDakIsTUFBTSxJQUFJLE9BQU87RUFHckIsT0FEYSxtQkFBbUIsTUFBTSxHQUM1QjtDQUNkOzs7Ozs7Q0FNQSxTQUFTLEtBQUs7RUFDVixJQUFJLE9BQVEsUUFBUyxVQUNqQixNQUFNLElBQUksT0FBTztFQUVyQixPQUFPLGtCQUFrQixNQUFNLEdBQUc7Q0FDdEM7Ozs7Q0FJQSxNQUFNLGlCQUFpQixNQUFNO0VBQ3pCLE1BQU0sSUFBSSxNQUFNLE9BQU87Q0FDM0I7Ozs7OztDQXFCQSxNQUFNLFlBQVksT0FBTyxXQUFXLFNBQVM7RUFDekMsSUFBSSxhQUFhLE1BQ2IsWUFBWTtFQUVoQixJQUFJLFdBQVcsTUFDWCxVQUFVO0VBRWQsTUFBTSxFQUFFLE1BQU0sZ0JBQWdCLFlBQVksSUFBSTtFQUM5QyxNQUFNLFVBQVcsT0FBTyxPQUFRLE1BQU07RUFDdEMsTUFBTSxFQUFFLFVBQVUsV0FBVyxNQUFNLFdBQVcsTUFBTSxLQUFLO0VBQ3pELE1BQU0sU0FBUztHQUFFO0dBQVM7R0FBUTtHQUFXO0VBQVE7RUFDckQsTUFBTSxXQUFXLFlBQVksS0FBSyxNQUFNO0VBQ3hDLE9BQU8sVUFBVSw0Q0FBNEMseUJBQXlCLEVBQUUsV0FBVyxjQUFjLENBQUM7RUFDbEgsUUFBUSxNQUFNLFNBQVMsUUFBUSxNQUFNLEVBQUEsQ0FBRyxLQUFLLFFBQVE7R0FDakQsSUFBSSxnQkFBZ0I7R0FDcEIsSUFBSSxpQkFBaUIsTUFDakIsSUFBSTtJQUNBLGdCQUFnQixLQUFLLFVBQVUsU0FBUyxJQUFJLE9BQU8sRUFBRTtHQUN6RCxTQUNPLE9BQU8sQ0FBRTtHQUVwQixJQUFJLGVBQ0EsSUFBSTtJQUNBLE9BQU8sSUFBSSxTQUFTLEtBQUssS0FBSyxXQUFXLGFBQWE7R0FDMUQsU0FDTyxPQUFPO0lBQ1YsT0FBTyxJQUFJLGtCQUFrQixLQUFLLEtBQUs7R0FDM0M7R0FFSixPQUFPLElBQUksSUFBSSxLQUFLLFFBQVE7RUFDaEMsQ0FBQztDQUNMOzs7O0NBSUEsTUFBTSxHQUFHLE9BQU8sVUFBVTtFQUN0QixNQUFNLE1BQU0sTUFBTSxPQUFPLE1BQU0sTUFBTSxLQUFLO0VBQzFDLElBQUksVUFBVSxLQUFLO0dBQUU7R0FBVSxNQUFNO0VBQU0sQ0FBQztFQUM1QyxJQUFJLE1BQU07RUFDVixPQUFPO0NBQ1g7Ozs7O0NBS0EsTUFBTSxLQUFLLE9BQU8sVUFBVTtFQUN4QixNQUFNLE1BQU0sTUFBTSxPQUFPLE1BQU0sUUFBUSxLQUFLO0VBQzVDLElBQUksVUFBVSxLQUFLO0dBQUU7R0FBVSxNQUFNO0VBQUssQ0FBQztFQUMzQyxJQUFJLE1BQU07RUFDVixPQUFPO0NBQ1g7Ozs7OztDQU1BLE1BQU0sS0FBSyxPQUFPLEdBQUcsTUFBTTtFQUN2QixPQUFPLE1BQU0sS0FBSyxNQUFNLE9BQU8sTUFBTSxJQUFJO0NBQzdDOzs7OztDQUtBLE1BQU0sY0FBYyxPQUFPO0VBQ3ZCLElBQUksT0FBTztHQUNQLE1BQU0sTUFBTSxNQUFNLE9BQU8sTUFBTSxLQUFLO0dBQ3BDLElBQUksQ0FBQyxLQUNELE9BQU87R0FFWCxPQUFPLElBQUksVUFBVTtFQUN6QjtFQUNBLE1BQU0sRUFBRSxTQUFTLFlBQVksSUFBSTtFQUNqQyxJQUFJLFFBQVE7RUFDWixLQUFLLE1BQU0sRUFBRSxlQUFlLEtBQUssT0FBTyxHQUNwQyxTQUFTLFVBQVU7RUFFdkIsT0FBTztDQUNYOzs7OztDQUtBLE1BQU0sVUFBVSxPQUFPO0VBQ25CLElBQUksT0FBTztHQUNQLE1BQU0sTUFBTSxNQUFNLE9BQU8sTUFBTSxLQUFLO0dBQ3BDLElBQUksQ0FBQyxLQUNELE9BQU8sQ0FBQztHQUVaLE9BQU8sSUFBSSxVQUFVLEtBQUssRUFBRSxlQUFlLFFBQVE7RUFDdkQ7RUFDQSxNQUFNLEVBQUUsU0FBUyxZQUFZLElBQUk7RUFDakMsSUFBSSxTQUFTLENBQUM7RUFDZCxLQUFLLE1BQU0sRUFBRSxlQUFlLEtBQUssT0FBTyxHQUNwQyxTQUFTLE9BQU8sT0FBTyxVQUFVLEtBQUssRUFBRSxlQUFlLFFBQVEsQ0FBQztFQUVwRSxPQUFPO0NBQ1g7Ozs7O0NBS0EsTUFBTSxJQUFJLE9BQU8sVUFBVTtFQUN2QixNQUFNLE1BQU0sTUFBTSxPQUFPLE1BQU0sS0FBSztFQUNwQyxJQUFJLENBQUMsS0FDRCxPQUFPO0VBRVgsSUFBSSxVQUFVO0dBQ1YsTUFBTSxRQUFRLElBQUksVUFBVSxLQUFLLEVBQUUsZUFBZSxRQUFRLENBQUMsQ0FBQyxRQUFRLFFBQVE7R0FDNUUsSUFBSSxTQUFTLEdBQ1QsSUFBSSxVQUFVLE9BQU8sT0FBTyxDQUFDO0VBRXJDO0VBQ0EsSUFBSSxZQUFZLFFBQVEsSUFBSSxVQUFVLFdBQVcsR0FBRztHQUNoRCxJQUFJLEtBQUs7R0FDVCxZQUFZLElBQUksQ0FBQyxDQUFDLEtBQUssT0FBTyxJQUFJLEdBQUc7RUFDek

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

26774CQUFpQjtHQUNoQztHQUNKLEtBQUs7SUFDRCxJQUFJLGNBQWMsS0FDZCxPQUFPO0tBQ0gsUUFBUTtLQUNSLE1BQU0sQ0FBQyxJQUFJLFVBQVUsQ0FBQyxDQUFDLElBQUksbUJBQW1CO0lBQ2xEO1NBRUMsSUFBSSxlQUFlLEtBQ3BCLE9BQU87S0FDSCxRQUFRO0tBQ1IsTUFBTSxDQUFDLElBQUksV0FBVyxDQUFDLENBQUMsSUFBSSxtQkFBbUI7SUFDbkQ7SUFFSjtHQUNKLEtBQUssa0JBQ0QsT0FBTztJQUNILFFBQVE7SUFDUixNQUFNLENBQUMsSUFBSSxJQUFJO0dBQ25CO0dBQ0osS0FBSyx5QkFDRCxPQUFPO0lBQ0gsUUFBUTtJQUNSLE1BQU0sQ0FBQyxJQUFJLElBQUk7R0FDbkI7R0FDSixLQUFLLFFBQ0QsT0FBTztJQUNILFFBQVE7SUFDUixNQUFNLENBQUMsS0FBSyxrQkFBa0IsSUFBSSxXQUFXLEdBQUcsSUFBSSxRQUFRO0dBQ2hFO0dBQ0osS0FBSyxlQUNELE9BQU87SUFDSCxRQUFRO0lBQ1IsTUFBTSxDQUFDLEtBQUssa0JBQWtCLElBQUksV0FBVyxDQUFDO0dBQ2xEO0dBRUosS0FBSztJQUNELElBQUksSUFBSSxVQUFVLElBQUksT0FBTyxXQUFXLE1BQU07S0FDMUMsSUFBSSxNQUFNLFFBQVEsSUFBSSxPQUFPLE9BQU8sR0FDaEMsSUFBSSxPQUFPLFVBQVUsSUFBSSxPQUFPLFFBQVEsSUFBSSxZQUFZO1VBR3hELElBQUksT0FBTyxVQUFVLGFBQWEsSUFBSSxPQUFPLE9BQU87SUFFNUQ7SUFDQSxPQUFPO0tBQUUsUUFBUTtLQUFlLE1BQU0sQ0FBQyxJQUFJLE1BQU07SUFBRTtFQUMzRDtFQUNBLE9BQU87Q0FDWDs7Ozs7OztDQU9BLFlBQVksU0FBUyxRQUFRO0VBQ3pCLE1BQU0sRUFBRSxXQUFXO0VBQ25CLE1BQU0sRUFBRSxVQUFVO0VBQ2xCLElBQUksV0FBVyxxQkFBcUIsTUFBTSxTQUFTO0dBQy9DLE1BQU0sTUFBTSxNQUFNO0dBQ2xCLElBQUksQ0FBQyxJQUFJLE1BQU0sU0FBUyxLQUFLLElBQUksTUFBTSxxQkFBcUIsR0FDeEQsT0FBTyxVQUFVLHNCQUFzQixzQkFBc0I7SUFDekQsYUFBYyxRQUFRLE9BQU87SUFDN0IsTUFBTTtLQUFFO0tBQVM7SUFBTTtHQUMzQixDQUFDO1FBRUEsSUFBSSxJQUFJLE1BQU0sUUFBUSxLQUFLLElBQUksTUFBTSxVQUFVLEdBQ2hELE9BQU8sVUFBVSwrQkFBK0IsaUJBQWlCO0lBQzdELGFBQWMsUUFBUSxPQUFPO0lBQzdCLE1BQU07S0FBRTtLQUFTO0lBQU07R0FDM0IsQ0FBQztFQUVUO0VBQ0EsSUFBSSxXQUFXLGNBQWMsV0FBVyxtQkFBbUI7R0FDdkQsTUFBTSxTQUFTLFlBQVksS0FBSztHQUNoQyxNQUFNLElBQUksU0FBUyx3QkFBeUIsV0FBVyxhQUFjLFNBQVMsZUFBZ0IsUUFBUSxPQUFPLElBQU0sU0FBUyxPQUFPLE9BQU8sSUFBSztHQUMv

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

26774FHLFFBQVE7RUFDOUUsUUFBUSxZQUFZO0VBQ3BCLElBQUksV0FBVyxVQUFVLFFBQVEsSUFBSSxHQUNqQyxRQUFRLFlBQVksT0FBTyxTQUFTLFVBQVUsWUFBWTtHQUN0RCxvQkFBb0Isb0JBQW9CO0dBQ3hDLE9BQU87RUFDWDtFQUVKLE9BQU87Q0FDWDtBQUNKOzs7Ozs7Ozs7OztBQ3JGQSxJQUFhLHFCQUFiLGNBQXdDLGdCQUFnQjtDQUNwRCxZQUFZLFVBQVU7RUFDbEIsSUFBSSxZQUFZLE1BQ1osV0FBVztFQUVmLE1BQU0sVUFBVSxRQUFRLEtBQUssUUFBUTtFQUNyQyxlQUFlLFFBQVEsU0FBUyxXQUFXLHVCQUF1QixXQUFXLFFBQVE7RUFDckYsTUFBTSwrQkFBZ0MsU0FBUyxFQUFFLGVBQWUsUUFBUSxDQUFDO0NBQzdFO0FBQ0o7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUNnQkEsSUFBTSxZQUFhLDJXQUtxRCxNQUFNLElBQUk7QUFDbEYsSUFBTSxXQUFXO0FBQ2pCLFNBQVMsVUFBVSxPQUFPO0NBQ3RCLE9BQVEsU0FBUyxPQUFRLE1BQU0sU0FBVTtBQUM3QztBQUNBLElBQU0sb0JBQW9COzs7Ozs7O0FBTzFCLElBQWEsa0JBQWIsTUFBYSx3QkFBd0IsY0FBYzs7OztDQUkvQzs7Ozs7Q0FLQSxZQUFZLFNBQVM7RUFDakIsTUFBTSxpQkFBaUI7RUFDdkIsaUJBQWlCLE1BQU0sRUFBRSxRQUFRLENBQUM7Q0FDdEM7Q0FDQSxRQUFRO0VBQ0osT0FBTyxJQUFJLGdCQUFnQixLQUFLLE9BQU87Q0FDM0M7QUFDSjtBQUNBLElBQU0sV0FBVyxDQUFDLGdCQUFnQjtBQUNsQyxJQUFJLFNBQVM7Ozs7Ozs7Ozs7O0FBV2IsSUFBYSxvQkFBYixjQUF1QyxpQkFBaUI7Ozs7Q0FJcEQ7Ozs7Q0FJQTtDQUNBOzs7O0NBSUEsWUFBWSxVQUFVLFNBQVM7RUFDM0IsTUFBTSxTQUFVLFdBQVcsT0FBUSxVQUFVO0VBQzdDLE1BQU07RUFDTixNQUFNLFVBQVUsUUFBUSxLQUFLLFFBQVE7RUFDckMsZUFBZSxVQUFVLFFBQVEsR0FBRyxRQUFRLFNBQVMsS0FBSyxHQUFHLHVCQUF1QixXQUFXLE9BQU87RUFDdEcsS0FBSyxVQUFVLFFBQVEsVUFBVSxpQkFBaUI7RUFDbEQsaUJBQWlCLE1BQU07R0FBRTtHQUFRO0VBQVEsQ0FBQztDQUM5Qzs7Ozs7Ozs7Ozs7OztDQWFBLGFBQWE7RUFDVCxJQUFJLEtBQUssU0FDTCxPQUFPLEtBQUssUUFBUTtFQUV4QixRQUFRLEtBQUssUUFBUSxNQUFyQjtHQUNJLEtBQUssV0FDRCxPQUFPO0dBQ1gsS0FBSyxVQUNELE9BQU87R0FDWCxLQUFLLFdBQ0QsT0FBTztHQUNYLEtBQUssV0FDRCxPQUFPO0dBQ1gsS0FBSyxZQUNELE9BQU87R0FDWCxLQUFLLG1CQUNELE9BQU87R0FDWCxLQUFLLFFBQ0QsT0FBTztHQUNYLEtBQUssZ0JBQ0QsT0FBTztHQUNYLEtBQUssT0FDRCxPQUFPO0dBQ1gsS0FBSyxRQUNELE9BQU87R0FDWCxLQUFLLFNBQ0QsT0FBTztHQUNYLEtBQUssY0FDRCxPQUFPO0dBQ1gsS0FBSyxnQkFDRCxPQUFPO0dBQ1gsS0FBSyxZQUNELE9BQU87R0FDWCxLQUFLLG1CQUNELE9BQU87RUFFZjtFQUNBLGVBQWUsT0FBTyx1QkFBdUIsV0FBVyxLQUFLLE9BQU87Q0FDeEU7Ozs7Q0FJQSxPQUFPLFFBQVEsUUFBUTtFQUNuQixJQUFJLFFBQVEsT0FBTyxLQUFLLE1BQU0sQ0FBQyxDQUFDLFFBQVEsT0FBTyxRQUFRO0dBQ25ELE1BQU0sUUFBUSxPQUFPO0dBQ3JCLElBQUksU0FBUyxNQUNULFNBQVMsSUFBSSxJQUFJLEdBQUc7R0FFeEIsT0FBTztFQUNYLEdBQUcsRUFBRTtFQUNMLElBQUksS0FBSyxRQUNMLFNBQVMsV0FBVyxLQUFLO0VBRTdCLE9BQU8sNENBQTRDLEtBQUssUUFBUSxRQUFRLFVBQVUsU0FBUztDQUMvRjs7OztDQUlBLGFBQWE7RUFDVCxPQUFPLDRDQUE0QyxLQUFLLFFBQVE7Q0FDcEU7Ozs7Q0FJQSxZQUFZLFFBQVEsUUFBUTtFQUN4QixPQUFPLFNBQVM7RUFDaEIsT0FBTyxTQUFTLEtBQUs7RUFDckIsT0FBTyxVQUFVLEtBQUssUUFBUTtFQUM5QixPQUFPO0NBQ1g7Q0FDQSxNQUFNLGdCQUFnQjtFQUNsQixPQUFPLEtBQUs7Q0FDaEI7Ozs7OztDQU1BLE1BQU0sTUFBTSxRQUFRLFFBQVEsTUFBTTtFQUM5QixNQUFNLEtBQUs7RUFDWCxNQUFNLE1BQU8sT0FBTyxLQUFLLFdBQVcsSUFBSSxLQUFLLE9BQU8sUUFBUSxNQUFNO0VBQ2xFLE1BQU0sVUFBVyxPQUFPLEtBQUssWUFBWSxRQUFRLE1BQU0sSUFBSTtFQUMzRCxLQUFLLEtBQUssU0FBUztHQUFFLFFBQVE7R0FBZTtHQUFJO0dBQWM7RUFBUSxDQUFDO0VBQ3ZFLE1BQU0sVUFBVSxJQUFJLGFBQWEsR0FBRztFQUNwQyxRQUFRLGtCQUFrQixFQUFFLGNBQWMsSUFBSyxDQUFDO0VBQ2hELFFBQVEsYUFBYSxLQUFLLE1BQU0sWUFBWTtHQUN4QyxJQUFJLEtBQUssb0JBQW9CLEdBQ3pCLG9CQUFvQixXQUFXO0dBRW5DLE9BQU8sUUFBUSxRQUFRLElBQUk7RUFDL0I7RUFDQSxRQUFRLGNBQWMsT0FBTyxTQUFTLGFBQWE7R0FDL0MsTUFBTSxTQUFTLFNBQVMsUUFBUSxJQUFJLEtBQUssTUFBTSxhQUFhLFNBQVMsSUFBSSxDQUFDLElBQUksQ0FBQztHQUMvRSxNQUFNLFlBQWEsT0FBUSxPQUFPLFdBQVksV0FBWSxPQUFPLFNBQVMsR0FBQSxDQUFJLFlBQVksQ0FBQyxDQUFDLFFBQVEsWUFBWSxLQUFLO0dBQ3JILElBQUksV0FBVyxTQUVQO1FBQUEsVUFBVSxPQUFPLFVBQVUsS0FBSyxPQUFPLFdBQVcsV0FBVyxVQUFVO0tBQ3ZFLEtBQUssS0FBSyxTQUFTO01BQUUsUUFBUTtNQUFnQjtNQUFJLFFBQVE7TUFBZSxPQUFPO0tBQU8sQ0FBQztLQUN2RixTQUFTLG1CQUFtQixPQUFPLFFBQVEsUUFBUTtJQUN2RDtVQUdBLElBQUksVUFBVTtJQUNWLEtBQUssS0FBSyxTQUFTO0tBQUUsUUFBUTtLQUFnQjtLQUFJLFFBQVE7S0FBZSxPQUFPLE9BQU87SUFBTyxDQUFDO0lBQzlGLFNBQVMsbUJBQW1CLE9BQU8sUUFBUSxRQUFRO0dBQ3ZEO0dBRUosT0FBTztFQUNYO0VBQ0EsSUFBSSxTQUFTO0dBQ1QsUUFBUSxVQUFVLGdCQUFnQixrREFBa0Q7R0FDcEYsUUFBUSxPQUFPLE9BQU8sS0FBSyxPQUFPLENBQUMsQ0FBQyxLQUFLLE1BQU0sR0FBRyxFQUFFLEdBQUcsUUFBUSxJQUFJLENBQUMsQ0FBQyxLQUFLLEdBQUc7RUFDakY7RUFDQSxNQUFNLFdBQVcsTUFBTSxRQUFRLEtBQUs7RUFDcEMsSUFBSTtHQUNBLFNBQVMsU0FBUztFQUN0QixTQUNPLE9BQU87R0FDVixLQUFLLEtBQUssU0FBUztJQUFFLFFBQVE7SUFBZ0I7SUFBSTtJQUFPLFFBQVE7R0FBVyxDQUFDO0dBQzVFLE9BQU8sT0FBTyxrQkFBa0IsZ0JBQWdCO0lBQUU7SUFBUztHQUFTLENBQUM7RUFDekU7RUFDQSxJQUFJLENBQUMsU0FBUyxRQUFRLEdBQUc7R0FDckIsS0FBSyxLQUFLLFNBQVM7SUFBRSxRQUFRO0lBQWdCO0lBQUksT0FBTztJQUFnQixRQUFRO0dBQVksQ0FBQztHQUM3RixPQUFPLE9BQU8sb0JBQW9CLGdCQUFnQjtJQUFFO0lBQVM7R0FBUyxDQUFDO0VBQzNFO0VBQ0EsTUFBTSxTQUFTLEtBQUssTUFBTSxhQUFhLFNBQVMsSUFBSSxDQUFDO0VBQ3JELElBQUksV0

26774FBVyxTQUFTO0dBQ3BCLElBQUksT0FBTyxXQUFXLE9BQU87SUFDekIsS0FBSyxLQUFLLFNBQVM7S0FBRSxRQUFRO0tBQWdCO0tBQUk7S0FBUSxRQUFRO0lBQW1CLENBQUM7SUFDckYsT0FBTyxPQUFPLHFEQUFxRCxnQkFBZ0I7S0FBRTtLQUFTO0tBQVUsTUFBTSxFQUFFLE9BQU87SUFBRSxDQUFDO0dBQzlIO0dBQ0EsSUFBSSxPQUFPLE9BQU87SUFDZCxLQUFLLEtBQUssU0FBUztLQUFFLFFBQVE7S0FBZ0I7S0FBSTtLQUFRLFFBQVE7SUFBaUIsQ0FBQztJQUNuRixPQUFPLE9BQU8sa0JBQWtCLGdCQUFnQjtLQUFFO0tBQVM7S0FBVSxNQUFNLEVBQUUsT0FBTztJQUFFLENBQUM7R0FDM0Y7R0FDQSxLQUFLLEtBQUssU0FBUztJQUFFLFFBQVE7SUFBa0I7SUFBSTtHQUFPLENBQUM7R0FDM0QsT0FBTyxPQUFPO0VBQ2xCLE9BQ0s7R0FFRCxJQUFJLE9BQU8sVUFBVSxNQUFNLE9BQU8sWUFBWSxzQkFBc0IsT0FBTyxZQUFZLDBCQUEwQjtJQUM3RyxLQUFLLEtBQUssU0FBUztLQUFFLFFBQVE7S0FBa0I7S0FBSTtJQUFPLENBQUM7SUFDM0QsT0FBTyxPQUFPO0dBQ2xCO0dBQ0EsSUFBSSxPQUFPLFVBQVUsS0FBTSxPQUFRLE9BQU8sWUFBYSxZQUFZLENBQUMsT0FBTyxRQUFRLE1BQU0sS0FBSyxHQUFJO0lBQzlGLEtBQUssS0FBSyxTQUFTO0tBQUUsUUFBUTtLQUFnQjtLQUFJO0lBQU8sQ0FBQztJQUN6RCxPQUFPLE9BQU8sa0JBQWtCLGdCQUFnQjtLQUFFO0tBQVM7S0FBVSxNQUFNLEVBQUUsT0FBTztJQUFFLENBQUM7R0FDM0Y7R0FDQSxLQUFLLEtBQUssU0FBUztJQUFFLFFBQVE7SUFBa0I7SUFBSTtHQUFPLENBQUM7R0FDM0QsT0FBTyxPQUFPO0VBQ2xCO0NBQ0o7Ozs7Q0FJQSx3QkFBd0IsYUFBYTtFQUNqQyxNQUFNLFNBQVMsQ0FBQztFQUNoQixLQUFLLElBQUksT0FBTyxhQUFhO0dBQ3pCLElBQUksU0FBUyxRQUFRLEdBQUcsS0FBSyxHQUN6QjtHQUVKLElBQUksWUFBWSxRQUFRLE1BQ3BCO0dBRUosSUFBSSxRQUFRLFlBQVk7R0FDeEIsSUFBSSxRQUFRLFVBQVUsVUFBVSxHQUM1QjtHQUVKLElBQUksUUFBUSxjQUFjLFVBQVUsVUFDaEM7R0FHSixJQUFJO0lBQUUsTUFBTTtJQUFNLFVBQVU7SUFBTSxVQUFVO0lBQU0sY0FBYztJQUFNLHNCQUFzQjtJQUFNLE9BQU87SUFBTSxPQUFPO0dBQUssRUFBRSxNQUN6SCxRQUFRLFdBQVcsS0FBSztRQUV2QixJQUFJLFFBQVEsY0FDYixRQUFRLE1BQU0sY0FBYyxLQUFLLENBQUMsQ0FBQyxLQUFLLFFBQVE7SUFDNUMsT0FBTyxhQUFhLElBQUksUUFBUSxrQkFBa0IsSUFBSSxZQUFZLEtBQUssT0FBSyxFQUFFO0dBQ2xGLENBQUMsQ0FBQyxDQUFDLEtBQUssR0FBRyxJQUFJO1FBRWQsSUFBSSxRQUFRLHVCQUF1QjtJQUNwQyxJQUFJLE1BQU0sV0FBVyxHQUNqQjtJQUdKLE9BQU8sT0FBTyxzREFBc0QseUJBQXlCO0tBQ3pGLFdBQVc7S0FDWCxNQUFNLEVBQUUsWUFBWTtJQUN4QixDQUFDO0dBQ0wsT0FFSSxRQUFRLFFBQVEsS0FBSztHQUV6QixPQUFPLE9BQU87RUFDbEI7RUFDQSxPQUFPO0NBQ1g7Ozs7Q0FJQSxZQUFZLEtBQUssT0FBTyxhQUFhO0VBRWpDLElBQUksVUFBVTtFQUNkLElBQUksUUFBUSxPQUFPLGNBQWMsR0FBRztHQUVoQyxJQUFJO0lBQ0EsVUFBVSxNQUFNLEtBQUssT0FBTyxNQUFNO0dBQ3RDLFNBQ08sR0FBRyxDQUFFO0dBQ1osSUFBSSxDQUFDLFNBQ0QsSUFBSTtJQUNBLFVBQVUsTUFBTSxLQUFLO0dBQ3pCLFNBQ08sR0FBRyxDQUFFO0VBRXBCO0VBQ0EsSUFBSSxJQUFJLFdBQVcsZUFDWDtPQUFBLENBQUMsUUFBUSxNQUFNLFNBQVMsS0FBSyxRQUFRLE1BQU0scUJBQXFCLEdBQ2hFLE9BQU8sT0FBTyxzQkFBc0Isc0JBQXNCLEVBQ3RELGFBQWEsSUFBSSxZQUNyQixDQUFDO0VBQUE7RUFHVCxJQUFJLElBQUksV0FBVyxVQUFVLElBQUksV0FBVyxlQUNwQztPQUFBLFFBQVEsTUFBTSxxQkFBcUIsR0FBRztJQUN0QyxJQUFJLE9BQU87SUFDWCxJQUFJO0tBQ0EsT0FBTyxNQUFNLEtBQUssT0FBTyxNQUFNO0lBQ25DLFNBQ08sT0FBTyxDQUFFO0lBQ2hCLE1BQU0sSUFBSSxTQUFTLHdCQUF3QixJQUFJLFFBQVEsSUFBSSxhQUFhLElBQUk7SUFDNUUsRUFBRSxPQUFPO0tBQUUsU0FBUztLQUFLO0lBQU07SUFDL0IsTUFBTTtHQUNWOztFQUVKLElBQUksU0FDSTtPQUFBLElBQUksV0FBVyx3QkFBd0I7SUFDdkMsTUFBTSxjQUFjLFlBQVksS0FBSyxJQUFJLGlCQUFpQjtJQUMxRCxJQUFJLFFBQVEsTUFBTSxjQUFjLEtBQUssUUFBUSxNQUFNLGNBQWMsR0FDN0QsT0FBTyxPQUFPLDJCQUEyQiwyQkFBMkIsRUFDaEUsWUFDSixDQUFDO0lBRUwsSUFBSSxRQUFRLE1BQU0sb0JBQW9CLEdBQ2xDLE9BQU8sT0FBTyxxREFBcUQsc0JBQXNCLEVBQ3JGLFlBQ0osQ0FBQztJQUVMLElBQUksUUFBUSxNQUFNLDJFQUEyRSxHQUN6RixPQUFPLE9BQU8sK0JBQStCLGlCQUFpQixFQUMxRCxZQUNKLENBQUM7R0FFVDs7RUFHSixNQUFNO0NBQ1Y7Q0FDQSxNQUFNLGlCQUFpQjtFQUNuQixPQUFPLEtBQUs7Q0FDaEI7Q0FDQSxNQUFNLFNBQVMsS0FBSztFQUNoQixRQUFRLElBQUksUUFBWjtHQUNJLEtBQUssV0FDRCxPQUFPLEtBQUssUUFBUTtHQUN4QixLQUFLLGtCQUNELE9BQU8sS0FBSyxNQUFNLFNBQVMsRUFBRSxRQUFRLGtCQUFrQixDQUFDO0dBQzVELEtBQUssZUFDRCxPQUFPLEtBQUssTUFBTSxTQUFTLEVBQUUsUUFBUSxlQUFlLENBQUM7R0FDekQsS0FBSyxrQkFFRCxJQUFJLEtBQUssUUFBUSxTQUFTLFdBQ3RCLE9BQU87UUFFTixJQUFJLEtBQUssUUFBUSxTQUFTLFlBQzNCLE9BQU87UUFHUCxNQUFNLElBQUksTUFBTSw0Q0FBNEM7R0E2QnBFLEtBQUssY0FFRCxPQUFPLEtBQUssTUFBTSxXQUFXO0lBQ3pCLFFBQVE7SUFDUixTQUFTLElBQUk7SUFDYixLQUFLLElBQUk7R0FDYixDQUFDO0dBQ0wsS0FBSyx1QkFDRCxPQUFPLEtBQUssTUFBTSxTQUFTO0lBQ3ZCLFFBQVE7SUFDUixTQUFTLElBQUk7SUFDYixLQUFLLElBQUk7R0FDYixDQUFDO0dBQ0wsS0FBSyxXQUNELE9BQU8sS0FBSyxNQUFNLFNBQVM7SUFDdkIsUUFBUTtJQUNSLFNBQVMsSUFBSTtJQUNiLEtBQUssSUFBSTtHQUNiLENBQUM7R0FDTCxLQUFLLGNBQ0QsT0FBTyxLQUFLLE1BQU0sU0FBUztJQUN2QixRQUFRO0lBQ1IsU0FBUyxJQUFJO0lBQ2IsVUFBVSxJQUFJO0lBQ2QsS0FBSyxJQUFJO0dBQ2IsQ0FBQztHQUNMLEtB

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

26774QUFNO0dBQ25CLFdBQVcsU0FBUztHQUNwQixlQUFlLFNBQVM7RUFDNUIsQ0FBQztDQUNMO0NBQ0Esc0JBQXNCO0VBQ2xCLE9BQVEsS0FBSyxjQUFjO0NBQy9CO0FBQ0o7Ozs7Ozs7Ozs7QUFVQSxJQUFhLGlCQUFiLE1BQWEsdUJBQXVCLGdCQUFnQjs7OztDQUloRDs7Ozs7OztDQU9BOzs7O0NBSUEsWUFBWSxVQUFVLFdBQVcsZUFBZTtFQUM1QyxJQUFJLFlBQVksTUFDWixXQUFXO0VBRWYsTUFBTSxVQUFVLFFBQVEsS0FBSyxRQUFRO0VBQ3JDLElBQUksYUFBYSxNQUNiLFlBQVk7RUFFaEIsSUFBSSxpQkFBaUIsTUFDakIsZ0JBQWdCO0VBRXBCLE1BQU0sVUFBVSxlQUFlLFdBQVcsU0FBUyxXQUFXLGFBQWE7RUFDM0UsTUFBTSxTQUFTLFNBQVMsRUFBRSxlQUFlLFFBQVEsQ0FBQztFQUNsRCxpQkFBaUIsTUFBTTtHQUFFO0dBQVc7RUFBYyxDQUFDO0NBQ3ZEO0NBQ0EsYUFBYSxTQUFTO0VBQ2xCLElBQUk7R0FDQSxPQUFPLElBQUksZUFBZSxTQUFTLEtBQUssV0FBVyxLQUFLLGFBQWE7RUFDekUsU0FDTyxPQUFPLENBQUU7RUFDaEIsT0FBTyxNQUFNLGFBQWEsT0FBTztDQUNyQztDQUNBLHNCQUFzQjtFQUNsQixPQUFRLEtBQUssY0FBYztDQUMvQjs7OztDQUlBLE9BQU8scUJBQXFCLFNBQVMsV0FBVztFQUM1QyxPQUFPLElBQUksd0JBQXdCLFNBQVMsU0FBUztDQUN6RDs7Ozs7Q0FLQSxPQUFPLFdBQVcsU0FBUyxXQUFXLGVBQWU7RUFDakQsSUFBSSxhQUFhLE1BQ2IsWUFBWTtFQUVoQixJQUFJLGlCQUFpQixNQUNqQixnQkFBZ0I7RUFFcEIsTUFBTSxVQUFVLElBQUksYUFBYSxZQUFZQSxVQUFRLFFBQVEsSUFBSSxFQUFFLE1BQU0sV0FBVztFQUNwRixRQUFRLFlBQVk7RUFDcEIsSUFBSSxlQUNBLFFBQVEsZUFBZSxJQUFJLGFBQWE7RUFFNUMsSUFBSSxjQUFjLGtCQUNkLFFBQVEsWUFBWSxPQUFPLFNBQVMsVUFBVSxZQU

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

26774BQ3pCLElBQUk7RUFDQSxVQUFVLEtBQUssSUFBSSxtQkFBbUIsU0FBUyxRQUFRLFVBQVUsQ0FBQztDQUN0RSxTQUNPLE9BQU8sQ0FBRTtDQUVwQixJQUFJLGFBQWEsWUFBWSxHQUN6QixJQUFJO0VBQ0EsVUFBVSxLQUFLLElBQUksbUJBQW1CLE9BQU8sQ0FBQztDQUNsRCxTQUNPLE9BQU8sQ0FBRTtDQUVwQixJQUFJLGFBQWEsV0FBVyxHQUN4QixJQUFJO0VBQ0EsVUFBVSxLQUFLLElBQUksa0JBQWtCLFNBQVMsUUFBUSxTQUFTLENBQUM7Q0FDcEUsU0FDTyxPQUFPLENBQUU7Q0FFcEIsSUFBSSxhQUFhLFFBQVEsR0FDckIsSUFBSTtFQUNBLElBQUksWUFBWSxRQUFRO0VBQ3hCLElBQUksZ0JBQWdCLEtBQUE7RUFDcEIsSUFBSSxPQUFRLGNBQWUsVUFBVTtHQUNqQyxnQkFBZ0IsVUFBVTtHQUMxQixZQUFZLFVBQVU7RUFDMUI7RUFDQSxVQUFVLEtBQUssSUFBSSxlQUFlLFNBQVMsV0FBVyxhQUFhLENBQUM7Q0FDeEUsU0FDTyxPQUFPLENBQUU7Q0FpQnBCLElBQUksYUFBYSxXQUFXLEdBQ3hCLElBQUk7RUFDQSxJQUFJLFFBQVEsUUFBUTtFQUNwQixVQUFVLEtBQUssSUFBSSxrQkFBa0IsU0FBUyxLQUFLLENBQUM7Q0FDeEQsU0FDTyxPQUFPLENBQUU7Q0FFcEIsT0FBTyxVQUFVLFFBQVEsK0JBQStCLHlCQUF5QixFQUM3RSxXQUFXLHFCQUNmLENBQUM7Q0FFRCxJQUFJLFVBQVUsV0FBVyxHQUNyQixPQUFPLFVBQVU7Q0FJckIsSUFBSSxTQUFTLEtBQUssTUFBTSxVQUFVLFNBQVMsQ0FBQztDQUM1QyxJQUFJLFNBQVMsR0FDVCxTQUFTO0NBSWIsSUFBSSxpQkFBaUIsU0FBUyxRQUFRLGNBQWMsSUFBSSxNQUFNLElBQzFELFNBQVM7Q0FHYixJQUFJLFdBQVcsUUFBUSxRQUNuQixTQUFTLFFBQVE7Q0FFckIsT0FBTyxJQUFJLGlCQUFpQixXQUFXLEtBQUEsR0FBVyxFQUFFLE9BQU8sQ0FBQztBQUNoRTs7Ozs7Ozs7QUMzTEEsSUFBYSxlQUFiLE1BQWEscUJBQXFCLGVBQWU7Ozs7Q0FJN0M7Q0FDQTtDQUNBOzs7O0NBSUEsWUFBWSxRQUFRO0VBQ2hCLE1BQU0sT0FBTyxRQUFRO0VBQ3JCLGlCQUFpQixNQUFNLEVBQUUsT0FBTyxDQUFDO0VBQ2pDLEtB

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

267740FBQ0o7Ozs7Ozs7Ozs7Ozs7OztBQ3RCQSxJQUFhLGNBQWIsY0FBaUMsU0FBUztDQUN0QztDQUNBOzs7OztDQUtBLFlBQVksUUFBUSxNQUFNLFVBQVU7RUFDaEMsTUFBTSxNQUFNO0VBQ1osS0FBSyxRQUFRO0VBQ2IsS0FBSyxZQUFZO0VBQ2pCLEtBQUssU0FBUztDQUNsQjs7OztDQUlBLElBQUksUUFBUTtFQUFFLE9BQU8sS0FBSztDQUFPOzs7O0NBSWpDLGVBQWU7RUFDWCxPQUFPLFVBQVUsS0FBSyxLQUFLO0NBQy9CO0NBQ0E7Q0FDQSxhQUFhO0VBQ1QsSUFBSSxLQUFLLFVBQVUsTUFBTTtHQUNyQixNQUFNLFFBQVEsS0FBSyxhQUFhOztHQUloQyxJQUZpQixHQUFHLE1BQU0sS0FBSyxJQUFJLElBQUksSUFFNUIsTUFBTSxLQUFLLFdBQ2xCLE1BQU0sSUFBSSxNQUFNLHNCQUFzQixLQUFLLE9BQU8sUUFBUTs7R0FHOUQsS0FBSyxTQUFTO0VBQ2xCO0VBQ0EsT0FBTyxLQUFLO0NBQ2hCO0NBQ0EsUUFBUSxPQUFPO0VBQ1gsTUFBTSxRQUFRLEtBQUssV0FBVztFQUM5QixlQUFlLFNBQVMsS0FBSyxRQUFRLE1BQU0sUUFBUSx1QkFBdUIsU0FBUyxTQUFTLEtBQUs7RUFDakcsT0FBTyxNQUFNO0NBQ2pCO0NBQ0EsYUFBYSxNQUFNO0VBQ2YsT0FBTyxLQUFLLFdBQVcsQ0FBQyxDQUFDLFFBQVEsSUFBSTtDQUN6QztBQUNKOzs7QUMvREEsSUFBTSxRQUFRO0FBQ2QsSUFBTSxXQUFXO0FBQ2pCLElBQUksV0FBVzs7Ozs7O0FBTWYsSUFBYSxTQUFiLE1BQWEsZUFBZSxZQUFZOzs7Ozs7Ozs7Q0FTcEMsY0FBYztFQUFFLE1BQU0sTUFBTSxPQUFPLFFBQVE7Q0FBRzs7Ozs7Q0FLOUMsT0FBTyxXQUFXO0VBQ2QsSUFBSSxZQUFZLE1BQ1osV0FBVyxJQUFJLE9BQU87RUFFMUIsT0FBTztDQUNYO0FBQ0o7OztBQ3pCQSxTQUFTLGFBQWEsTUFBTTtDQUN4QixRQUFTLEtBQUssUUFBUSxLQUFPLElBQUksT0FBUTtBQUM3QztBQUVBLFNBQVMsYUFBYSxNQUFNO0NBQ3hCLFFBQVMsS0FBSyxRQUFRLElBQUs7QUFDL0I7QUFDQSxTQUFTLGtCQUFrQixVQUFVLFVBQVU7Q0FDM0MsZ0JBQWdCLE1BQU07Q0FDdEIsSUFBSSxZQUFZLE1BQ1osV0FBVyxPQUFPLFNBQVM7Q0FFL0IsTUFBTSxRQUFRLFNBQVMsTUFBTSxRQUFRO0NBQ3JDLGVBQWdCLE1BQU0sU0FBUyxNQUFPLEtBQUssTUFBTSxVQUFVLE1BQU0sTUFBTSxVQUFVLElBQUksMkJBQTJCLFlBQVksY0FBYztDQUMxSSxNQUFNLFVBQVUsSUFBSSxXQUFXLEtBQUssS0FBSyxLQUFLLE1BQU0sU0FBUyxDQUFDLENBQUM7Q0FDL0QsSUFBSSxTQUFTO0NBQ2IsS0FBSyxJQUFJLElBQUksR0FBRyxJQUFJLE1BQU0sUUFBUSxLQUFLO0VBQ25DLElBQUksUUFBUSxTQUFTLGFBQWEsTUFBTSxFQUFFLENBQUMsVUFBVSxNQUFNLENBQUM7RUFDNUQsZUFBZSxTQUFTLEdBQUcsa0NBQWtDLEtBQUssWUFBWSxjQUFjO0VBQzVGLEtBQUssSUFBSSxNQUFNLEdBQUcsTUFBTSxJQUFJLE9BQU87R0FDL0IsSUFBSSxRQUFTLEtBQU0sS0FBSyxLQUNwQixRQUFRLFVBQVUsTUFBTyxLQUFNLElBQUssU0FBUztHQUVqRDtFQUNKO0NBQ0o7Q0FDQSxNQUFNLGNBQWMsS0FBSyxNQUFNLFNBQVM7Q0FFeEMsTUFBTSxlQUFlLGFBREEsTUFBTSxTQUFTLENBQ1U7Q0FFOUMsZ0JBRGlCLFNBQVMsT0FBTyxRQUFRLE1BQU0sR0FBRyxjQUFjLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxLQUFLLG1CQUM3QyxRQUFRLFFBQVEsU0FBUyxLQUFLLGVBQWUsNkJBQTZCLFlBQVksY0FBYztDQUNqSSxPQUFPLFFBQVEsUUFBUSxNQUFNLEdBQUcsY0FBYyxDQUFDLENBQUM7QUFDcEQ7QUFDQSxTQUFTLGtCQUFrQixTQUFTLFVBQVU7Q0FDMUMsZUFBZ0IsUUFBUSxTQUFTLE1BQU8sS0FBSyxRQUFRLFVBQVUsTUFBTSxRQUFRLFVBQVUsSUFBSSx3QkFBd0IsV0FBVyxjQUFjO0NBQzVJLElBQUksWUFBWSxNQUNaLFdBQVcsT0FBTyxTQUFTO0NBRS9CLE1BQU0sVUFBVSxDQUFDLENBQUM7Q0FDbEIsSUFBSSxnQkFBZ0I7Q0FDcEIsS0FBSyxJQUFJLElBQUksR0FBRyxJQUFJLFFBQVEsUUFBUSxLQUVoQyxJQUFJLGdCQUFnQixHQUFHO0VBQ25CLFFBQVEsUUFBUSxTQUFTLE9BQU87RUFDaEMsUUFBUSxRQUFRLFNBQVMsTUFBTSxRQUFRO0VBQ3ZDLGlCQUFpQjtDQUVyQixPQUNLO0VBQ0QsUUFBUSxRQUFRLFNBQVMsT0FBTztFQUNoQyxRQUFRLFFBQVEsU0FBUyxNQUFNLFFBQVEsTUFBTyxJQUFJO0VBRWxELFFBQVEsS0FBSyxRQUFRLEtBQUssYUFBYSxJQUFJLGFBQWEsQ0FBQztFQUN6RCxpQkFBaUI7Q0FDckI7Q0FHSixNQUFNLGVBQWUsUUFBUSxTQUFTO0NBQ3RDLE1BQU0sV0FBVyxTQUFTLE9BQU8sT0FBTyxDQUFDLENBQUMsVUFBVSxHQUFHLENBQUMsR0FBRyxFQUFFLElBQUksYUFBYSxZQUFZO0NBRTFGLFFBQVEsUUFBUSxTQUFTLE9BQU87Q0FDaEMsUUFBUSxRQUFRLFNBQVMsTUFBTyxZQUFhLElBQUk7Q0FDakQsT0FBTyxTQUFTLEtBQUssUUFBUSxLQUFLLFVBQVUsU0FBUyxRQUFRLEtBQUssQ0FBQyxDQUFDO0FBQ3hFO0FBQ0EsSUFBTUMsV0FBUyxDQUFDOzs7OztBQUtoQixJQUFhLFdBQWIsTUFBYSxTQUFTOzs7Ozs7Q0FNbEI7Ozs7O0NBS0E7Ozs7Q0FJQTs7OztDQUlBOzs7O0NBSUEsWUFBWSxPQUFPLFNBQVMsUUFBUSxVQUFVLFVBQVU7RUFDcEQsSUFBSSxZQUFZLE1BQ1osV0FBVztFQUVmLElBQUksWUFBWSxNQUNaLFdBQVcsT0FBTyxTQUFTO0VBRS9CLGNBQWMsT0FBT0EsVUFBUSxVQUFVO0VBQ3ZDLGlCQUFpQixNQUFNO0dBQUU7R0FBUTtHQUFVO0dBQVU7RUFBUSxDQUFDO0NBQ2xFOzs7O0NBSUEsY0FBYztFQUNWLE1BQU0sT0FBTyxZQUFZLGFBQWEsS0FBSyxVQUFVLE1BQU07RUFDM0QsT0FBTyxPQUFPLFlBQVksS0FBSyxRQUFRLE1BQU0sR0FBRyxNQUFNLE1BQU0sSUFBSSxRQUFRO0NBQzVFOzs7Ozs7O0NBT0EsT0FBTyxXQUFXLFFBQVEsVUFBVSxVQUFVO0VBRTFDLE1BQU0sVUFBVSxrQkFBa0IsUUFBUSxRQUFRO0VBQ2xELFNBQVMsa0JBQWtCLFNBQVMsT0FBTyxHQUFHLFFBQVE7RUFDdEQsT0FBTyxJQUFJLFNBQVNBLFVBQVEsU0FBUyxRQUFRLFVBQVUsUUFBUTtDQUNuRTs7Ozs7OztDQU9BLE9BQU8sWUFBWSxVQUFVLFVBQVUsVUFBVTtFQUM3QyxNQUFNLFVBQVUsU0FBUyxVQUFVLFNBQVM7RUFDNUMsTUFBTSxTQUFTLGtCQUFrQixTQUFTLFFBQVE7RUFDbEQsT0FBTyxJQUFJLFNBQVNBLFVBQVEsUUFBUSxPQUFPLEdBQUcsUUFBUSxVQUFVLFFBQVE7Q0FDNUU7Ozs7Q0FJQSxPQUFPLGdCQUFnQixVQUFVLFVBQVU7

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

26774BQ25ELE9BQU8sU0FBUyxHQUFHO1FBRWxCLElBQUksT0FBTyxjQUFjLEdBQUcsR0FDN0IsT0FBTztFQUVmO0VBQ0EsSUFBSSxTQUFTLFVBQ0w7T0FBQSxPQUFRLFFBQVMsWUFBWSxJQUFJLE1BQU0sYUFBYSxHQUNwRCxPQUFPLFdBQVcsR0FBRztFQUFBO0VBRzdCLElBQUksU0FBUyxRQUNMO09BQUEsT0FBUSxRQUFTLFVBQ2pCLE9BQU8sY0FBYyxHQUFHO0VBQUE7RUFHaEMsSUFBSSxTQUFTLFdBQVcsTUFBTSxRQUFRLEdBQUcsR0FDckMsT0FBTztFQUVYLElBQUksU0FBUyxPQUFRLEtBQ2pCLE9BQU87RUFFWCxlQUFlLE9BQU8sd0JBQXdCLEtBQUssSUFBSSxRQUFRLElBQUk7Q0FDdkU7Q0FDQSxPQUFPO0FBQ1g7Ozs7Ozs7Ozs7Ozs7QUNuRUEsSUFBTUMsZ0JBQWM7Ozs7QUFJcEIsU0FBZ0IsZUFBZSxNQUFNO0NBQ2pDLElBQUk7RUFDQSxNQUFNLE9BQU8sS0FBSyxNQUFNLElBQUk7RUFFNUIsS0FEa0IsS0FBSyxXQUFXLE9BQVEsU0FBUyxLQUFLLE9BQU8sSUFBSSxPQUNuRCxHQUNaLE9BQU87Q0FFZixTQUNPLE9BQU8sQ0FBRTtDQUNoQixPQUFPO0FBQ1g7QUFDQSxTQUFTLFFBQVEsTUFBTSxLQUFLLFlBQVk7Q0FFcEMsSUFEZSxRQUFRLE1BQU0sc0JBQ3BCLE1BQU0sZUFHWCxPQUFPLFFBQVEsSUFESSxJQUFJLEtBRFosUUFBUSxNQUFNLDhCQUNHLENBQ2IsQ0FBQSxDQUFPLFFBQVEsVUFBVSxDQUFDO0NBRTdDLE9BQU8sT0FBTyxzQkFBc0IseUJBQXlCLEVBQ3pELFdBQVcsVUFDZixDQUFDO0FBQ0w7QUFDQSxTQUFTLFdBQVcsTUFBTSxNQUFNO0NBQzVCLE1BQU0sTUFBTSxTQUFTLElBQUk7Q0FDekIsTUFBTSxhQUFhLFFBQVEsTUFBTSx5QkFBeUI7Q0FFMUQsZUFEb0IsUUFBUSxVQUFVLE9BQU8sQ0FBQyxJQUFJLE1BQU0sSUFBSSxFQUFFLEdBQUcsVUFBVSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsVUFBVSxDQUMzRSxNQUFnQixRQUFRLE1BQU0sb0JBQW9CLENBQUMsQ0FBQyxZQUFZLEdBQUcsc0JBQXNCLFlBQVksY0FBYztDQUNsSSxNQUFNLGFBQWEsUUFBUSxNQUFNLElBQUksTUFBTSxHQUFHLEVBQUUsR0FBRyxVQUFVO0NBQzdELE1BQU0sVUFBVSxlQUFlLFVBQVU7Q0FDekMsSUFBSSxLQUFLLFNBQVM7RUFDZCxJQUFJLFFBQVEsS0FBSyxRQUFRLFlBQVk7RUFDckMsSUFBSSxDQUFDLE1BQU0sV0FBVyxJQUFJLEdBQ3RCLFFBQVEsT0FBTztFQUVuQixlQUFlLFdBQVcsS0FBSyxNQUFNLFNBQVMsd0NBQXdDLFdBQVcsS0FBSyxPQUFPO0NBQ2pIO0NBQ0EsTUFBTSxVQUFVO0VBQUU7RUFBUztDQUFXO0NBR3RDLElBRGdCLFFBQVEsTUFBTSx5QkFDcEIsTUFBTSxPQUFPO0VBQ25CLE1BQU0sY0FBYyxJQUFJLE1BQU0sSUFBSSxFQUFFO0VBQ3BDLE1BQU0scUJBQXFCLFF

26774BQVEsTUFBTSxtQ0FBbUM7RUFFNUUsTUFBTSxpQkFBaUIsSUFBSSxJQUFJLGFBRFosUUFBUSxNQUFNLGdDQUNXLENBQVU7RUFDdEQsUUFBUSxXQUFXO0dBQ2YsTUFBTyxRQUFRLE1BQU0sc0JBQXNCLEtBQUtBO0dBQ2hELFFBQVMsUUFBUSxNQUFNLHdCQUF3QixLQUFLO0dBQ3BELFNBQVMsUUFBUSxTQUFTLGVBQWUsUUFBUSxrQkFBa0IsQ0FBQyxDQUFDO0VBQ3pFO0NBQ0o7Q0FDQSxPQUFPO0FBQ1g7QUFDQSxTQUFTLG9CQUFvQixNQUFNO0NBQy9CLE1BQU0sTUFBTSxRQUFRLE1BQU0sbUJBQW1CO0NBQzdDLElBQUksT0FBTyxPQUFRLFFBQVMsVUFBVTtFQUNsQyxJQUFJLElBQUksWUFBWSxNQUFNLFVBQVU7R0FDaEMsTUFBTSxPQUFPLFFBQVEsTUFBTSw2QkFBNkI7R0FDeEQsTUFBTSxJQUFJLFFBQVEsTUFBTSx5QkFBeUI7R0FDakQsTUFBTSxJQUFJLFFBQVEsTUFBTSx5QkFBeUI7R0FDakQsTUFBTSxJQUFJLFFBQVEsTUFBTSx5QkFBeUI7R0FFakQsZUFBZSxJQUFJLE1BQU0sSUFBSyxJQUFJLE9BQVEsR0FBRyxpQkFBaUIsU0FBUyxDQUFDO0dBQ3hFLGVBQWUsSUFBSSxLQUFLLElBQUksR0FBRyxlQUFlLE9BQU8sR0FBRztHQUN4RCxNQUFNLFFBQVEsUUFBUSxNQUFNLDZCQUE2QjtHQUN6RCxlQUFlLFVBQVUsSUFBSSxxQkFBcUIsYUFBYSxLQUFLO0dBQ3BFLE9BQU87SUFBRSxNQUFNO0lBQVU7SUFBTTtJQUFHO0lBQUc7SUFBRyxPQUFPO0dBQUc7RUFDdEQsT0FDSyxJQUFJLElBQUksWUFBWSxNQUFNLFVBQVU7R0FDckMsTUFBTSxPQUFPLFFBQVEsTUFBTSw2QkFBNkI7R0FDeEQsTUFBTSxNQUFNLFFBQVEsTUFBTSw4QkFBOEI7R0FDeEQsTUFBTSxZQUFZLElBQUksTUFBTSxHQUFHLENBQUMsQ0FBQyxJQUFJO0dBQ3JDLGVBQWUsY0FBYyxZQUFZLGNBQWMsVUFBVSxtQkFBbUIsV0FBVyxHQUFHO0dBQ2xHLE1BQU0sUUFBUSxRQUFRLE1BQU0seUJBQXlCO0dBQ3JELE1BQU0sUUFBUSxRQUFRLE1BQU0sNkJBQTZCO0dBQ3pELGVBQWUsVUFBVSxJQUFJLHFCQUFxQixhQUFhLEtBQUs7R0FDcEUsT0FBTztJQUFFLE1BQU07SUFBVTtJQUFNO0lBQU87SUFBTztHQUFVO0VBQzNEO0NBQ0o7Q0FDQSxlQUFlLE9BQU8sdUNBQXVDLE9BQU8sR0FBRztBQUMzRTs7Ozs7Ozs7Ozs7OztBQWFBLFNBQWdCLHdCQUF3QixNQUFNLFdBQVc7Q0FDckQsTUFBTSxPQUFPLEtBQUssTUFBTSxJQUFJO0NBQzVCLE1BQU0sV0FBVyxZQUFZLFNBQVM7Q0FDdEMsTUFBTSxTQUFTLG9CQUFvQixJQUFJO0NBQ3ZDLElBQUksT0FBTyxTQUFTLFVBQVU7RUFDMUIsTUFBTSxFQUFFLE1BQU0sT0FBTyxPQUFPLGNBQWM7RUFFMUMsT0FBTyxXQUFXLE1BRE4sT0FBTyxVQUFVLE1BQU0sT0FBTyxPQUFPLFNBQ3ZCLENBQUM7Q0FDL0I7Q0FDQSxPQUFPLE9BQU8sU0FBUyxVQUFVLHFCQUFxQixpQkFBaUIsRUFBRSxPQUFPLENBQUM7Q0FDakYsTUFBTSxFQUFFLE1BQU0sR0FBRyxHQUFHLEdBQUcsVUFBVTtDQUVqQyxPQUFPLFdBQVcsTUFETixXQUFXLFVBQVUsTUFBTSxHQUFHLEdBQUcsR0FBRyxLQUN0QixDQUFDO0FBQy9CO0FBQ0EsU0FBU0MsUUFBTSxVQUFVO0NBQ3JCLE9BQU8sSUFBSSxTQUFTLFlBQVk7RUFBRSxpQkFBaUI7R0FBRSxRQUFRO0VBQUcsR0FBRyxRQUFRO0NBQUcsQ0FBQztBQUNuRjs7Ozs7Ozs7Ozs7O0FBWUEsZUFBc0Isb0JBQW9CLE1BQU0sV0FBVyxVQUFVO0NBQ2pFLE1BQU0sT0FBTyxLQUFLLE1BQU0sSUFBSTtDQUM1QixNQUFNLFdBQVcsWUFBWSxTQUFTO0NBQ3RDLE1BQU0sU0FBUyxvQkFBb0IsSUFBSTtDQUN2QyxJQUFJLE9BQU8sU0FBUyxVQUFVO0VBQzFCLElBQUksVUFBVTtHQUNWLFNBQVMsQ0FBQztHQUNWLE1BQU1BLFFBQU0sQ0FBQztFQUNqQjtFQUNBLE1BQU0sRUFBRSxNQUFNLE9BQU8sT0FBTyxjQUFjO0VBQzFDLE1BQU0sTUFBTSxPQUFPLFVBQVUsTUFBTSxPQUFPLE9BQU8sU0FBUztFQUMxRCxJQUFJLFVBQVU7R0FDVixTQUFTLENBQUM7R0FDVixNQUFNQSxRQUFNLENBQUM7RUFDakI7RUFDQSxPQUFPLFdBQVcsTUFBTSxHQUFHO0NBQy9CO0NBQ0EsT0FBTyxPQUFPLFNBQVMsVUFBVSxxQkFBcUIsaUJBQWlCLEVBQUUsT0FBTyxDQUFDO0NBQ2pGLE1BQU0sRUFBRSxNQUFNLEdBQUcsR0FBRyxHQUFHLFVBQVU7Q0FFakMsT0FBTyxXQUFXLE1BQU0sTUFETixPQUFPLFVBQVUsTUFBTSxHQUFHLEdBQUcsR0FBRyxPQUFPLFFBQVEsQ0FDdEM7QUFDL0I7QUFDQSxTQUFTLG9CQUFvQixTQUFTO0NBRWxDLE1BQU0sT0FBUSxRQUFRLFFBQVEsT0FBUSxTQUFTLFFBQVEsTUFBTSxjQUFjLElBQUksWUFBWSxFQUFFO0NBRTdGLElBQUksSUFBSyxLQUFLLElBQUssSUFBSSxHQUFHLElBQUk7Q0FDOUIsSUFBSSxRQUFRLFFBQVE7RUFDaEIsSUFBSSxRQUFRLE9BQU8sR0FDZixJQUFJLFFBQVEsT0FBTztFQUV2QixJQUFJLFFBQVEsT0FBTyxHQUNmLElBQUksUUFBUSxPQUFPO0VBRXZCLElBQUksUUFBUSxPQUFPLEdBQ2YsSUFBSSxRQUFRLE9BQU87Q0FFM0I7Q0FDQSxlQUFlLE9BQVEsTUFBTyxZQUFZLElBQUksS0FBSyxPQUFPLGNBQWMsQ0FBQyxNQUFNLE9BQU8sQ0FBQyxJQUFJLE9BQU8sSUFBSSxDQUFDLE9BQU8sT0FBTyxDQUFDLEdBQUcsOEJBQThCLGFBQWEsQ0FBQztDQUNySyxlQUFlLE9BQVEsTUFBTyxZQUFZLElBQUksS0FBSyxPQUFPLGNBQWMsQ0FBQyxHQUFHLDhCQUE4QixhQUFhLENBQUM7Q0FDeEgsZUFBZSxPQUFRLE1BQU8sWUFBWSxJQUFJLEtBQUssT0FBTyxjQUFjLENBQUMsR0FBRyw4QkFBOEIsYUFBYSxDQUFDO0NBQ3hILE9BQU87RUFBRSxNQUFNO0VBQVUsT0FBTztFQUFJO0VBQU07RUFBRztFQUFHO0NBQUU7QUFDdEQ7QUFDQSxTQUFTLGlCQUFpQixLQUFLLEtBQUssU0FBUyxTQUFTO0NBQ2xELE1BQU0sYUFBYSxTQUFTLFFBQVEsWUFBWSxZQUFZO0NBRTVELE1BQU0sS0FBTSxRQUFRLE1BQU0sT0FBUSxTQUFTLFFBQVEsSUFBSSxZQUFZLElBQUksWUFBWSxFQUFFO0NBQ3JGLGVBQWUsR0FBRyxXQUFXLElBQUksNkJBQTZCLGNBQWMsUUFBUSxFQUFFO0NBRXRGLE1BQU0sYUFBYyxRQUFRLFFBQVEsT0FBUSxTQUFTLFFBQVEsTUFBTSxjQUFjLElBQUksWUFBWSxFQUFFO0NBQ25HLGVBQWUsV0FBVyxXQUFXLElBQUksK0JBQStCLGdCQUFnQixRQUFRLEVBQUU7Q0FJbEcsTUFBTSxhQUFhLElBQUksTUFBTSxHQUFHLEVBQUU7Q0FDbEMsTUFBTSxZQUFZLElBQUksTUFBTSxJQUFJLEVBQUU7Q0FHbEMsTUFBTSxhQUFhLFNBQVMsSUFEVCxJQUFJLFlBQVksRUFDUCxDQUFBLENBQU8sUUFBUSxVQUFVLENBQUM7Q0FFdEQsTUFBTSxNQUFNLFVBQVUsT0FBTyxDQUFDLFdBQVcsVUFBVSxDQUFDLENBQUM7Q0FFckQsTUFBTSxPQUFPO0VBQ1QsU0FBUyxRQUFRLFFBQVEsVUFBVSxDQUFDLENBQUMsQ0FBQyxZQUFZO0VBQ2xELElBQUksT0FBTyxVQUFVO0VBQ3JCLFNBQVM7RUFDVCxRQUFRO0dBQ0osUUFBUTtHQUNSLGNBQWMsRUFDVixJQUFJLFFBQVEsRUFBRSxDQUFDLENBQUMsVUFBVSxDQUFDLEVBQy9CO0dBQ0EsWUFBWSxRQUFRLFVBQVUsQ0FBQyxDQUFDLFVBQVUsQ0FBQztHQUMzQyxLQUFLO0dBQ0wsV0FBVztJQUNQLE1BQU0sUUFBUSxJQUFJLElBQUksQ0FBQyxDQUFDLFVBQVUsQ0FBQztJQUNuQyxHQUFHLElBQUk7SUFDUCxPQUFPO0lBQ1AsR0FBRyxJQUFJO0lBQ1AsR0FBRyxJQUFJO0dBQ1g7R0FDQSxLQUFLLElBQUksVUFBVSxDQUFDO0VBQ3hCO

267740NBQ0o7Q0FFQSxJQUFJLFFBQVEsVUFBVTtFQUNsQixNQUFNLFNBQVUsUUFBUSxVQUFVLE9BQVEsUUFBUSxTQUFTLFVBQVU7RUFDckUsTUFBTSxPQUFPLFFBQVEsU0FBUyxRQUFRRDtFQUN0QyxNQUFNLFNBQVMsUUFBUSxTQUFTLFVBQVU7RUFDMUMsTUFBTSxjQUFjLElBQUksTUFBTSxJQUFJLEVBQUU7RUFDcEMsTUFBTSxVQUFVLFNBQVMsUUFBUSxTQUFTLFNBQVMsMEJBQTBCO0VBQzdFLE1BQU0sYUFBYSxZQUFZLEVBQUU7RUFFakMsTUFBTSxxQkFBcUIsU0FBUyxJQURULElBQUksYUFBYSxVQUNSLENBQUEsQ0FBZSxRQUFRLE9BQU8sQ0FBQztFQUNuRSxNQUFNLHNCQUFNLElBQUksS0FBSztFQVFyQixLQUFLLGNBQWM7R0FDZjtHQUFRLGNBRlUsV0FOSCxJQUFJLGVBQWUsSUFBSSxNQUN0Q0UsT0FBSyxJQUFJLFlBQVksSUFBSSxHQUFHLENBQUMsSUFBSSxNQUNqQ0EsT0FBSyxJQUFJLFdBQVcsR0FBRyxDQUFDLElBQUksTUFDNUJBLE9BQUssSUFBSSxZQUFZLEdBQUcsQ0FBQyxJQUFJLE1BQzdCQSxPQUFLLElBQUksY0FBYyxHQUFHLENBQUMsSUFBSSxNQUMvQkEsT0FBSyxJQUFJLGNBQWMsR0FBRyxDQUFDLElBQUksU0FDUyxPQUFPLEtBQUs7R0FFOUI7R0FBTTtHQUM1QixpQkFBaUIsUUFBUSxVQUFVLENBQUMsQ0FBQyxVQUFVLENBQUM7R0FDaEQsb0JBQW9CLFFBQVEsa0JBQWtCLENBQUMsQ0FBQyxVQUFVLENBQUM7R0FDM0QsU0FBUztFQUNiO0NBQ0o7Q0FDQSxPQUFPLEtBQUssVUFBVSxJQUFJO0FBQzlCOzs7Ozs7Ozs7QUFTQSxTQUFnQix3QkFBd0IsU0FBUyxVQUFVLFNBQVM7Q0FDaEUsSUFBSSxXQUFXLE1BQ1gsVUFBVSxDQUFDO0NBRWYsTUFBTSxnQkFBZ0IsWUFBWSxRQUFRO0NBQzFDLE1BQU0sTUFBTSxvQkFBb0IsT0FBTztDQUV2QyxPQUFPLGlCQUFpQixTQURaLFdBQVcsZUFBZSxJQUFJLE1BQU0sSUFBSSxHQUFHLElBQUksR0FBRyxJQUFJLEdBQUcsRUFDcEMsQ0FBRyxHQU

26774FHLEtBQUssU0FBUyxPQUFPO0FBQ2hFOzs7Ozs7Ozs7O0FBVUEsZUFBc0Isb0JBQW9CLFNBQVMsVUFBVSxTQUFTO0NBQ2xFLElBQUksV0FBVyxNQUNYLFVBQVUsQ0FBQztDQUVmLE1BQU0sZ0JBQWdCLFlBQVksUUFBUTtDQUMxQyxNQUFNLE1BQU0sb0JBQW9CLE9BQU87Q0FFdkMsT0FBTyxpQkFBaUIsU0FBUyxNQURmLE9BQU8sZUFBZSxJQUFJLE1BQU0sSUFBSSxHQUFHLElBQUksR0FBRyxJQUFJLEdBQUcsSUFBSSxRQUFRLGdCQUFnQixDQUMvRCxHQUFHLEtBQUssU0FBUyxPQUFPO0FBQ2hFOzs7Ozs7Ozs7OztBQzdRQSxJQUFhLGNBQWM7QUFFM0IsSUFBTSxlQUFlLElBQUksV0FBVztDQUFDO0NBQUk7Q0FBSztDQUFLO0NBQUk7Q0FBSztDQUFLO0NBQUs7Q0FBSTtDQUFLO0NBQUs7Q0FBSztBQUFHLENBQUM7QUFDN0YsSUFBTSxjQUFjO0FBQ3BCLElBQU1DLE1BQUksT0FBTyxvRUFBb0U7QUFDckYsSUFBTSxVQUFVO0FBQ2hCLFNBQVMsS0FBSyxPQUFPLFFBQVE7Q0FDekIsSUFBSSxTQUFTO0NBQ2IsT0FBTyxPQUFPO0VBQ1YsU0FBUyxRQUFRLFFBQVEsTUFBTTtFQUMvQixRQUFRLEtBQUssTUFBTSxRQUFRLEVBQUU7Q0FDakM7Q0FDQSxPQUFPLE9BQU8sU0FBUyxTQUFTLEdBQzVCLFNBQVMsTUFBTTtDQUVuQixPQUFPLE9BQU87QUFDbEI7QUFDQSxTQUFTLGtCQUFrQixRQUFRO0NBQy9CLE1BQU0sUUFBUSxTQUFTLE1BQU07Q0FHN0IsT0FBTyxhQURPLE9BQU8sQ0FBQyxPQURSLFVBQVUsT0FBTyxPQUFPLEtBQUssQ0FBQyxHQUFHLEdBQUcsQ0FDckIsQ0FBSyxDQUNkLENBQUs7QUFDN0I7QUFDQSxJQUFNLFNBQVMsQ0FBQztBQUNoQixTQUFTLE1BQU0sT0FBTyxXQUFXLFdBQVcsWUFBWTtDQUNwRCxNQUFNLHVCQUFPLElBQUksV0FBVyxFQUFFO0NBQzlCLElBQUksUUFBUSxhQUFhO0VBQ3JCLE9BQU8sY0FBYyxNQUFNLHdDQUF3Qyx5QkFBeUIsRUFDeEYsV0FBVyxjQUNmLENBQUM7RUFFRCxLQUFLLElBQUksU0FBUyxVQUFVLEdBQUcsQ0FBQztDQUNwQyxPQUdJLEtBQUssSUFBSSxTQUFTLFNBQVMsQ0FBQztDQUdoQyxLQUFLLElBQUksSUFBSSxJQUFJLEtBQUssR0FBRyxLQUFLLEdBQzFCLEtBQUssTUFBTSxLQUFLLE1BQVEsU0FBVSxLQUFLLElBQU07Q0FFakQsTUFBTSxJQUFJLFNBQVMsWUFBWSxVQUFVLFdBQVcsSUFBSSxDQUFDO0NBQ3pELE9BQU87RUFBRSxJQUFJLEVBQUUsTUFBTSxHQUFHLEVBQUU7RUFBRyxJQUFJLEVBQUUsTUFBTSxFQUFFO0NBQUU7QUFDakQ7QUFDQSxTQUFTLFdBQVcsTUFBTSxNQUFNO0NBQzVCLE1BQU0sYUFBYSxLQUFLLE1BQU0sR0FBRztDQUNqQyxlQUFlLFdBQVcsU0FBUyxHQUFHLGdCQUFnQixRQUFRLElBQUk7Q0FDbEUsSUFBSSxXQUFXLE9BQU8sS0FBSztFQUN2QixlQUFlLEtBQUssVUFBVSxHQUFHLHVGQUF1RixLQUFLLFNBQVMsUUFBUSxJQUFJO0VBQ2xKLFdBQVcsTUFBTTtDQUNyQjtDQUNBLElBQUksU0FBUztDQUNiLEtBQUssSUFBSSxJQUFJLEdBQUcsSUFBSSxXQUFXLFFBQVEsS0FBSztFQUN4QyxNQUFNLFlBQVksV0FBVztFQUM3QixJQUFJLFVBQVUsTUFBTSxXQUFXLEdBQUc7R0FDOUIsTUFBTSxRQUFRLFNBQVMsVUFBVSxVQUFVLEdBQUcsVUFBVSxTQUFTLENBQUMsQ0FBQztHQUNuRSxlQUFlLFFBQVEsYUFBYSxzQkFBc0IsUUFBUSxFQUFFLElBQUksU0FBUztHQUNqRixTQUFTLE9BQU8sWUFBWSxjQUFjLEtBQUs7RUFDbkQsT0FDSyxJQUFJLFVBQVUsTUFBTSxVQUFVLEdBQUc7R0FDbEMsTUFBTSxRQUFRLFNBQVMsU0FBUztHQUNoQyxlQUFlLFFBQVEsYUFBYSxzQkFBc0IsUUFBUSxFQUFFLElBQUksU0FBUztHQUNqRixTQUFTLE9BQU8sWUFBWSxLQUFLO0VBQ3JDLE9BRUksZUFBZSxPQUFPLDBCQUEwQixRQUFRLEVBQUUsSUFBSSxTQUFTO0NBRS9FO0NBQ0EsT0FBTztBQUNYOzs7Ozs7Ozs7QUFTQSxJQUFhLGVBQWIsTUFBYSxxQkFBcUIsV0FBVzs7OztDQUl6Qzs7Ozs7Ozs7Q0FRQTs7OztDQUlBOzs7Ozs7O0NBT0E7Ozs7O0NBS0E7Ozs7Ozs7O0NBUUE7Ozs7O0NBS0E7Ozs7O0NBS0E7Ozs7Q0FJQSxZQUFZLE9BQU8sWUFBWSxtQkFBbUIsV0FBVyxNQUFNLE9BQU8sT0FBTyxVQUFVLFVBQVU7RUFDakcsTUFBTSxZQUFZLFFBQVE7RUFDMUIsY0FBYyxPQUFPLFFBQVEsY0FBYztFQUMzQyxpQkFBaUIsTUFBTSxFQUFFLFdBQVcsV0FBVyxvQkFBb0IsQ0FBQztFQUNwRSxNQUFNLGNBQWMsVUFBVSxVQUFVLE9BQU8sS0FBSyxTQUFTLENBQUMsR0FBRyxHQUFHLENBQUM7RUFDckUsaUJBQWlCLE1BQU07R0FDbkI7R0FBbUI7R0FDbkI7R0FBVztHQUFNO0dBQU87RUFDNUIsQ0FBQztFQUNELGlCQUFpQixNQUFNLEVBQUUsU0FBUyxDQUFDO0NBQ3ZDO0NBQ0EsUUFBUSxVQUFVO0VBQ2QsT0FBTyxJQUFJLGFBQWEsUUFBUSxLQUFLLFlBQVksS0FBSyxtQkFBbUIsS0FBSyxXQUFXLEtBQUssTUFBTSxLQUFLLE9BQU8sS0FBSyxPQUFPLEtBQUssVUFBVSxRQUFRO0NBQ3ZKO0NBQ0EsV0FBVztFQUNQLE1BQU0sVUFBVTtHQUFFLFNBQVMsS0FBSztHQUFTLFlBQVksS0FBSztFQUFXO0VBQ3JFLE1BQU0sSUFBSSxLQUFLO0VBQ2YsSUFBSSxLQUFLLFFBQVEsS0FBSyxFQUFFLFNBQVMsV0FBVyxRQUFRLEVBQUUsYUFBYSxJQUMvRCxRQUFRLFdBQVc7R0FDZixNQUFNLEtBQUs7R0FDWCxRQUFRO0dBQ1IsU0FBUyxFQUFFO0VBQ2Y7RUFFSixPQUFPO0NBQ1g7Ozs7Ozs7O0NBUUEsTUFBTSxRQUFRLFVBQVUsa0JBQWtCO0VBQ3RDLE9BQU8sTUFBTSxvQkFBb0IsS0FBSyxTQUFTLEdBQUcsVUFBVSxFQUFFLGlCQUFpQixDQUFDO0NBQ3BGOzs7Ozs7Ozs7OztDQVdBLFlBQVksVUFBVTtFQUNsQixPQUFPLHdCQUF3QixLQUFLLFNBQVMsR0FBRyxRQUFRO0NBQzVEOzs7Ozs7O0NBT0EsSUFBSSxjQUFjO0VBTWQsT0FBTyxLQUFLLFFBQVEsS0FBSyxrQkFBa0IseUJBQXlCLEVBQUUsV0FBVyxjQUFjLENBQUM7RUFDaEcsT0FBTyxrQkFBa0IsT0FBTztHQUM1QjtHQUFjLEtBQUssS0FBSyxPQUFPLENBQUM7R0FBRyxLQUFLO0dBQ3hDLEtBQUssS0FBSyxPQUFPLENBQUM7R0FBRyxLQUFLO0dBQzFCLE9BQU8sQ0FBQyxRQUFRLEtBQUssVUFBVSxDQUFDO0VBQ3BDLENBQUMsQ0FBQztDQUNOOzs7OztDQUtBLFVBQVU7RUFBRSxPQUFRLEtBQUssUUFBUTtDQUFPOzs7Ozs7OztDQVF4QyxTQUFTO0VBQ0wsT0FBTyxJQUFJLGl

26774CQUFpQixRQUFRLEtBQUssU0FBUyxLQUFLLFdBQVcsS0FBSyxtQkFBbUIsS0FBSyxXQUFXLEtBQUssTUFBTSxLQUFLLE9BQU8sS0FBSyxPQUFPLEtBQUssUUFBUTtDQUM5Sjs7OztDQUlBLFlBQVksUUFBUTtFQUNoQixNQUFNLFFBQVEsVUFBVSxRQUFRLE9BQU87RUFDdkMsZUFBZSxTQUFTLFlBQVksaUJBQWlCLFNBQVMsS0FBSztFQUVuRSxJQUFJLE9BQU8sS0FBSztFQUNoQixJQUFJLE1BQU07R0FDTixRQUFRLE9BQU8sUUFBUTtHQUN2QixJQUFJLFFBQVEsYUFDUixRQUFRO0VBRWhCO0VBQ0EsTUFBTSxFQUFFLElBQUksT0FBTyxNQUFNLE9BQU8sS0FBSyxXQUFXLEtBQUssV0FBVyxLQUFLLFVBQVU7RUFDL0UsTUFBTSxLQUFLLElBQUksV0FBVyxTQUFTLFNBQVMsRUFBRSxJQUFJLE9BQU8sS0FBSyxVQUFVLEtBQUtBLEtBQUcsRUFBRSxDQUFDO0VBQ25GLE9BQU8sSUFBSSxhQUFhLFFBQVEsSUFBSSxLQUFLLGFBQWEsUUFBUSxFQUFFLEdBQUcsTUFBTSxPQUFPLEtBQUssUUFBUSxHQUFHLEtBQUssVUFBVSxLQUFLLFFBQVE7Q0FDaEk7Ozs7Q0FJQSxXQUFXLE1BQU07RUFDYixPQUFPLFdBQVcsTUFBTSxJQUFJO0NBQ2hDO0NBQ0EsT0FBTyxVQUFVLE9BQU8sVUFBVTtFQUM5QixlQUFlLFlBQVksS0FBSyxHQUFHLGdCQUFnQixRQUFRLFlBQVk7RUFDdkUsTUFBTSxPQUFPLFNBQVMsT0FBTyxNQUFNO0VBQ25DLGVBQWUsS0FBSyxVQUFVLE1BQU0sS0FBSyxVQUFVLElBQUksZ0JBQWdCLFFBQVEsWUFBWTtFQUMzRixNQUFNLElBQUksU0FBUyxZQUFZLFVBQVUsY0FBYyxJQUFJLENBQUM7RUFDNUQsTUFBTSxhQUFhLElBQUksV0FBVyxRQUFRLEVBQUUsTUFBTSxHQUFHLEVBQUUsQ0FBQyxDQUFDO0VBQ3pELE9BQU8sSUFBSSxhQUFhLFFBQVEsWUFBWSxjQUFjLFFBQVEsRUFBRSxNQUFNLEVBQUUsQ0FBQyxHQUFHLEtBQUssR0FBRyxHQUFHLFVBQVUsSUFBSTtDQUM3Rzs7Ozs7Ozs7Q0FRQSxPQUFPLGdCQUFnQixhQUFhO0VBQ2hDLE1BQU0sUUFBUSxVQUFVLGFBQWEsV0FBVyxDQUFDO0VBQ2pELGVBQWUsTUFBTSxXQUFXLE1BQU0sa0JBQWtCLE1BQU0sTUFBTSxHQUFHLEVBQUUsQ0FBQyxNQUFNLGFBQWEsd0JBQXdCLGVBQWUsY0FBYztFQUNsSixNQUFNLFFBQVEsTUFBTTtFQUNwQixNQUFNLG9CQUFvQixRQUFRLE1BQU0sTUFBTSxHQUFHLENBQUMsQ0FBQztFQUNuRCxNQUFNLFFBQVEsU0FBUyxRQUFRLE1BQU0sTUFBTSxHQUFHLEVBQUUsQ0FBQyxDQUFDLENBQUMsVUFBVSxDQUFDLEdBQUcsRUFBRTtFQUNuRSxNQUFNLFlBQVksUUFBUSxNQUFNLE1BQU0sSUFBSSxFQUFFLENBQUM7RUFDN0MsTUFBTSxNQUFNLE1BQU0sTUFBTSxJQUFJLEVBQUU7RUFDOUIsUUFBUSxRQUFRLE1BQU0sTUFBTSxHQUFHLENBQUMsQ0FBQyxHQUFqQztHQUVJLEtBQUs7R0FDTCxLQUFLLGNBQWM7SUFDZixNQUFNLFlBQVksUUFBUSxHQUFHO0lBQzdCLE9BQU8sSUFBSSxpQkFBaUIsUUFBUSxlQUFlLFNBQVMsR0FBRyxXQUFXLG1CQUFtQixXQUFXLE1BQU0sT0FBTyxPQUFPLElBQUk7R0FDcEk7R0FFQSxLQUFLO0dBQ0wsS0FBSztJQUNELElBQUksSUFBSSxPQUFPLEdBQ1g7SUFFSixPQUFPLElBQUksYUFBYSxRQUFRLElBQUksV0FBVyxJQUFJLE1BQU0sQ0FBQyxDQUFDLEdBQUcsbUJBQW1CLFdBQVcsTUFBTSxPQUFPLE9BQU8sTUFBTSxJQUFJO0VBQ2xJO0VBQ0EsZUFBZSxPQUFPLCtCQUErQixlQUFlLGNBQWM7Q0FDdEY7Ozs7Q0FJQSxPQUFPLGFBQWEsVUFBVSxNQUFNLFVBQVU7RUFDMUMsSUFBSSxZQUFZLE1BQ1osV0FBVztFQUVmLElBQUksUUFBUSxNQUNSLE9BQU87RUFFWCxJQUFJLFlBQVksTUFDWixXQUFXLE9BQU8sU0FBUztFQUUvQixNQUFNLFdBQVcsU0FBUyxZQUFZLFlBQVksRUFBRSxHQUFHLFVBQVUsUUFBUTtFQUN6RSxPQUFPLGFBQWEsVUFBVSxTQUFTLFlBQVksR0FBRyxRQUFRLENBQUMsQ0FBQyxXQUFXLElBQUk7Q0FDbkY7Ozs7Q0FJQSxPQUFPLGFBQWEsVUFBVSxNQUFNO0VBQ2hDLElBQUksQ0FBQyxNQUNELE9BQU87RUFFWCxPQUFPLGFBQWEsVUFBVSxTQUFTLFlBQVksR0FBRyxRQUFRLENBQUMsQ0FBQyxXQUFXLElBQUk7Q0FDbkY7Ozs7Q0FJQSxPQUFPLFdBQVcsUUFBUSxVQUFVLE1BQU0sVUFBVTtFQUNoRCxJQUFJLFlBQVksTUFDWixXQUFXO0VBRWYsSUFBSSxRQUFRLE1BQ1IsT0FBTztFQUVYLElBQUksWUFBWSxNQUNaLFdBQVcsT0FBTyxTQUFTO0VBRS9CLE1BQU0sV0FBVyxTQUFTLFdBQVcsUUFBUSxVQUFVLFFBQVE7RUFDL0QsT0FBTyxhQUFhLFVBQVUsU0FBUyxZQUFZLEdBQUcsUUFBUSxDQUFDLENBQUMsV0FBVyxJQUFJO0NBQ25GOzs7O0NBSUEsT0FBTyxTQUFTLE1BQU07RUFDbEIsT0FBTyxhQUFhLFVBQVUsTUFBTSxJQUFJO0NBQzVDO0FBQ0o7Ozs7Ozs7OztBQVNBLElBQWEsbUJBQWIsTUFBYSx5QkFBeUIsV0FBVzs7OztDQUk3Qzs7Ozs7Ozs7Q0FRQTs7OztDQUlBOzs7OztDQUtBOzs7Ozs7OztDQVFBOzs7OztDQUtBOzs7OztDQUtBOzs7O0NBSUEsWUFBWSxPQUFPLFNBQVMsV0FBVyxtQkFBbUIsV0FBVyxNQUFNLE9BQU8sT0FBTyxVQUFVO0VBQy9GLE1BQU0sU0FBUyxRQUFRO0VBQ3ZCLGNBQWMsT0FBTyxRQUFRLGtCQUFrQjtFQUMvQyxpQkFBaUIsTUFBTSxFQUFFLFVBQVUsQ0FBQztFQUNwQyxNQUFNLGNBQWMsVUFBVSxVQUFVLE9BQU8sU0FBUyxDQUFDLEdBQUcsR0FBRyxDQUFDO0VBQ2hFLGlCQUFpQixNQUFNO0dBQ25CO0dBQVc7R0FBYTtHQUFtQjtHQUFXO0dBQU07R0FBTztFQUN2RSxDQUFDO0NBQ0w7Q0FDQSxRQUFRLFVBQVU7RUFDZCxPQUFPLElBQUksaUJBQWlCLFFBQVEsS0FBSyxTQUFTLEtBQUssV0FBVyxLQUFLLG1CQUFtQixLQUFLLFdBQVcsS0FBSyxNQUFNLEtBQUssT0FBTyxLQUFLLE9BQU8sUUFBUTtDQUN6Sjs7Ozs7OztDQU9BLElBQUksY0FBYztFQU1kLE9BQU8sS0FBSyxRQUFRLEtBQUssa0JBQWtCLHlCQUF5QixFQUFFLFdBQVcsY0FBYyxDQUFDO0VBQ2hHLE9BQU8sa0JBQWtCLE9BQU87R0FDNUI7R0FDQSxLQUFLLEtBQUssT0FBTyxDQUFDO0dBQ2xCLEtBQUs7R0FDTCxLQUFLLEtBQUssT0FBTyxDQUFDO0dBQ2xCLEtBQUs7R0FDTCxLQUFLO0VBQ1QsQ0FBQyxDQUFDO0NBQ047Ozs7O0NBS0EsVUFBVTtFQUFFLE9BQVEsS0FBSyxRQUFRO0NBQU87Ozs7Q0FJeEMsWUFBWSxRQUFRO0VBQ2hCLE1BQU0sUUFBUSxVQUFVLFFBQVEsT0FBTztFQUN2QyxlQUFlLFNBQVMsWUFBWSxpQkFBaUIsU0FBUyxLQUFLO0VBRW5FLElBQUksT0FBTyxLQUFLO0VBQ2hCLElBQUksTUFBTTtHQUNOLFFBQVEsT0FBTyxRQUFRO0dBQ3ZCLElBQUksUUFBUSxhQUNSLFF

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