@zip.js/zip.js 2.8.30 → 2.8.31

package/lib/core/streams/zlib-wasm/zlib-streams-loader.js

@@ -72,12 +72,10 @@ function arrayBufferFromDataURI(dataURI) {
 }
 
 export {
-	setWasmExports,
 	CompressionStreamZlib,
 	DecompressionStreamZlib
 } from "./zlib-streams.js";
 export {
 	initModule,
-	resetWasmModule,
-	initializedModule
+	resetWasmModule
 };

package/lib/core/util/base64.js

@@ -0,0 +1,68 @@
+/*
+ Copyright (c) 2025 Gildas Lormeau. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright 
+ notice, this list of conditions and the following disclaimer in 
+ the documentation and/or other materials provided with the distribution.
+
+ 3. The names of the authors may not be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+ INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+ INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+const BASE64_TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+export function base64Decode(b64) {
+	b64 = String(b64).replace(/[^A-Za-z0-9+/=]/g, "");
+	const len = b64.length;
+	const out = [];
+	for (let i = 0; i < len; i += 4) {
+		const a = BASE64_TABLE.indexOf(b64[i]);
+		const b = BASE64_TABLE.indexOf(b64[i + 1]);
+		const c = BASE64_TABLE.indexOf(b64[i + 2]);
+		const d = BASE64_TABLE.indexOf(b64[i + 3]);
+		const n = (a << 18) | (b << 12) | ((c & 63) << 6) | (d & 63);
+		out.push((n >> 16) & 0xff);
+		if (b64[i + 2] !== "=") {
+			out.push((n >> 8) & 0xff);
+		}
+		if (b64[i + 3] !== "=") {
+			out.push(n & 0xff);
+		}
+	}
+	return new Uint8Array(out);
+}
+
+export function base64Encode(bytes) {
+	let out = "";
+	const len = bytes.length;
+	let i = 0;
+	for (; i + 2 < len; i += 3) {
+		const n = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
+		out += BASE64_TABLE[(n >> 18) & 63] + BASE64_TABLE[(n >> 12) & 63] + BASE64_TABLE[(n >> 6) & 63] + BASE64_TABLE[n & 63];
+	}
+	const rem = len - i;
+	if (rem === 1) {
+		const n = bytes[i] << 16;
+		out += BASE64_TABLE[(n >> 18) & 63] + BASE64_TABLE[(n >> 12) & 63] + "==";
+	} else if (rem === 2) {
+		const n = (bytes[i] << 16) | (bytes[i + 1] << 8);
+		out += BASE64_TABLE[(n >> 18) & 63] + BASE64_TABLE[(n >> 12) & 63] + BASE64_TABLE[(n >> 6) & 63] + "=";
+	}
+	return out;
+}

package/lib/core/util/decode-text.js

@@ -38,7 +38,6 @@ function decodeText(value, encoding) {
 	if (encoding && encoding.trim().toLowerCase() == "cp437") {
 		return decodeCP437(value);
 	} else {
-		// ignoreBOM keeps a leading U+FEFF in filenames/comments instead of dropping it
 		return new TextDecoder(encoding, { ignoreBOM: true }).decode(value);
 	}
 }

package/lib/core/util/default-mime-type.js

@@ -26,10 +26,7 @@
  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-const mimeTypes = {};
-
 export {
-	mimeTypes,
 	getMimeType
 };
 

package/lib/core/util/inflate.js

@@ -0,0 +1,194 @@
+/*
+ Copyright (c) 2025 Gildas Lormeau. All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+ this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright 
+ notice, this list of conditions and the following disclaimer in 
+ the documentation and/or other materials provided with the distribution.
+
+ 3. The names of the authors may not be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED ''AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
+ INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT,
+ INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+ EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+const MAX_CODE_LENGTH = 15;
+const END_OF_BLOCK = 256;
+const LENGTH_BASES = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258];
+const LENGTH_EXTRA_BITS = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0];
+const DISTANCE_BASES = [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577];
+const DISTANCE_EXTRA_BITS = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13];
+const CODE_LENGTH_CODE_ORDER = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+const FIXED_LITERAL_LENGTHS = new Uint8Array(288);
+FIXED_LITERAL_LENGTHS.fill(8, 0, 144);
+FIXED_LITERAL_LENGTHS.fill(9, 144, 256);
+FIXED_LITERAL_LENGTHS.fill(7, 256, 280);
+FIXED_LITERAL_LENGTHS.fill(8, 280, 288);
+const FIXED_DISTANCE_LENGTHS = new Uint8Array(30).fill(5);
+
+export function inflateRaw(input) {
+	let inputIndex = 0;
+	let bitBuffer = 0;
+	let bitCount = 0;
+	let output = new Uint8Array(1024);
+	let outputLength = 0;
+	let lastBlock = 0;
+	while (!lastBlock) {
+		lastBlock = readBits(1);
+		const blockType = readBits(2);
+		if (blockType == 0) {
+			copyStoredBlock();
+		} else if (blockType == 1) {
+			inflateBlock(buildHuffmanTable(FIXED_LITERAL_LENGTHS), buildHuffmanTable(FIXED_DISTANCE_LENGTHS));
+		} else if (blockType == 2) {
+			inflateBlock(...readDynamicTables());
+		} else {
+			throw new Error("invalid deflate block type");
+		}
+	}
+	return output.subarray(0, outputLength);
+
+	function readByte() {
+		if (inputIndex >= input.length) {
+			throw new Error("unexpected end of deflate data");
+		}
+		return input[inputIndex++];
+	}
+
+	function readBits(count) {
+		while (bitCount < count) {
+			bitBuffer |= readByte() << bitCount;
+			bitCount += 8;
+		}
+		const value = bitBuffer & ((1 << count) - 1);
+		bitBuffer >>>= count;
+		bitCount -= count;
+		return value;
+	}
+
+	function copyStoredBlock() {
+		bitBuffer = 0;
+		bitCount = 0;
+		const length = readByte() | (readByte() << 8);
+		inputIndex += 2;
+		ensureOutput(outputLength + length);
+		for (let indexByte = 0; indexByte < length; indexByte++) {
+			output[outputLength++] = readByte();
+		}
+	}
+
+	function inflateBlock(literalTable, distanceTable) {
+		let symbol = decodeSymbol(literalTable);
+		while (symbol != END_OF_BLOCK) {
+			if (symbol < END_OF_BLOCK) {
+				ensureOutput(outputLength + 1);
+				output[outputLength++] = symbol;
+			} else {
+				const lengthIndex = symbol - 257;
+				const length = LENGTH_BASES[lengthIndex] + readBits(LENGTH_EXTRA_BITS[lengthIndex]);
+				const distanceIndex = decodeSymbol(distanceTable);
+				const distance = DISTANCE_BASES[distanceIndex] + readBits(DISTANCE_EXTRA_BITS[distanceIndex]);
+				ensureOutput(outputLength + length);
+				const copyStart = outputLength - distance;
+				for (let indexByte = 0; indexByte < length; indexByte++) {
+					output[outputLength++] = output[copyStart + indexByte];
+				}
+			}
+			symbol = decodeSymbol(literalTable);
+		}
+	}
+
+	function readDynamicTables() {
+		const literalLengthCount = readBits(5) + 257;
+		const distanceLengthCount = readBits(5) + 1;
+		const codeLengthCount = readBits(4) + 4;
+		const codeLengthLengths = new Uint8Array(19);
+		for (let indexCode = 0; indexCode < codeLengthCount; indexCode++) {
+			codeLengthLengths[CODE_LENGTH_CODE_ORDER[indexCode]] = readBits(3);
+		}
+		const codeLengthTable = buildHuffmanTable(codeLengthLengths);
+		const lengths = new Uint8Array(literalLengthCount + distanceLengthCount);
+		let indexLength = 0;
+		while (indexLength < lengths.length) {
+			const symbol = decodeSymbol(codeLengthTable);
+			if (symbol < 16) {
+				lengths[indexLength++] = symbol;
+			} else if (symbol == 16) {
+				const previousLength = lengths[indexLength - 1];
+				let repeatCount = readBits(2) + 3;
+				while (repeatCount--) {
+					lengths[indexLength++] = previousLength;
+				}
+			} else {
+				const repeatCount = symbol == 17 ? readBits(3) + 3 : readBits(7) + 11;
+				indexLength += repeatCount;
+			}
+		}
+		return [
+			buildHuffmanTable(lengths.subarray(0, literalLengthCount)),
+			buildHuffmanTable(lengths.subarray(literalLengthCount))
+		];
+	}
+
+	function decodeSymbol(table) {
+		const { lengthCounts, symbols } = table;
+		let code = 0;
+		let first = 0;
+		let index = 0;
+		for (let length = 1; length <= MAX_CODE_LENGTH; length++) {
+			code |= readBits(1);
+			const count = lengthCounts[length];
+			if (code - first < count) {
+				return symbols[index + (code - first)];
+			}
+			index += count;
+			first = (first + count) << 1;
+			code <<= 1;
+		}
+		throw new Error("invalid huffman code");
+	}
+
+	function ensureOutput(length) {
+		if (output.length < length) {
+			let newLength = output.length * 2;
+			while (newLength < length) {
+				newLength *= 2;
+			}
+			const newOutput = new Uint8Array(newLength);
+			newOutput.set(output.subarray(0, outputLength));
+			output = newOutput;
+		}
+	}
+}
+
+function buildHuffmanTable(codeLengths) {
+	const lengthCounts = new Uint16Array(MAX_CODE_LENGTH + 1);
+	for (const length of codeLengths) {
+		lengthCounts[length]++;
+	}
+	lengthCounts[0] = 0;
+	const offsets = new Uint16Array(MAX_CODE_LENGTH + 2);
+	for (let length = 1; length <= MAX_CODE_LENGTH; length++) {
+		offsets[length + 1] = offsets[length] + lengthCounts[length];
+	}
+	const symbols = new Uint16Array(codeLengths.length);
+	for (let symbol = 0; symbol < codeLengths.length; symbol++) {
+		if (codeLengths[symbol]) {
+			symbols[offsets[codeLengths[symbol]]++] = symbol;
+		}
+	}
+	return { lengthCounts, symbols };
+}

package/lib/core/util/mime-type.js

@@ -222,7 +222,6 @@ const table = {
 		"x-doom": "wad",
 		"x-dvi": "dvi",
 		"x-httpd-eruby": "rhtml",
-		"x-font": "pcf.Z",
 		"x-freemind": "mm",
 		"x-gnumeric": "gnumeric",
 		"x-go-sgf": "sgf",
@@ -909,7 +908,7 @@ const table = {
 		"x-msbinder": "obd",
 		"x-mscardfile": "crd",
 		"x-msclip": "clp",
-		"application/x-ms-installer": "msi",
+		"x-ms-installer": "msi",
 		"x-msmediaview": [
 			"mvb",
 			"m13",
@@ -1272,7 +1271,10 @@ const table = {
 		],
 		"x-tga": "tga",
 		"cis-cod": "cod",
-		"avif": "avifs",
+		"avif": [
+			"avif",
+			"avifs"
+		],
 		"heic": [
 			"heif",
 			"heic"
@@ -1491,7 +1493,6 @@ const table = {
 		"vnd.wap.sl": "sl"
 	},
 	"video": {
-		"avif": "avif",
 		"3gpp": "3gp",
 		"annodex": "axv",
 		"dl": "dl",
@@ -1610,28 +1611,31 @@ const table = {
 	}
 };
 
-const mimeTypes = (() => {
-	const mimeTypes = {};
-	for (const type of Object.keys(table)) {
-		for (const subtype of Object.keys(table[type])) {
-			const value = table[type][subtype];
-			if (typeof value == "string") {
-				mimeTypes[value] = type + "/" + subtype;
-			} else {
-				for (let indexMimeType = 0; indexMimeType < value.length; indexMimeType++) {
-					mimeTypes[value[indexMimeType]] = type + "/" + subtype;
-				}
-			}
-		}
-	}
-	return mimeTypes;
-})();
+let mimeTypes;
 
 export {
-	mimeTypes,
 	getMimeType
 };
 
 function getMimeType(filename) {
-	return filename && mimeTypes[filename.split(".").pop().toLowerCase()] || getDefaultMimeType();
+	return filename && getMimeTypes()[filename.split(".").pop().toLowerCase()] || getDefaultMimeType();
+}
+
+function getMimeTypes() {
+	if (!mimeTypes) {
+		mimeTypes = {};
+		for (const type of Object.keys(table)) {
+			for (const subtype of Object.keys(table[type])) {
+				const value = table[type][subtype];
+				if (typeof value == "string") {
+					mimeTypes[value] = type + "/" + subtype;
+				} else {
+					for (let indexMimeType = 0; indexMimeType < value.length; indexMimeType++) {
+						mimeTypes[value[indexMimeType]] = type + "/" + subtype;
+					}
+				}
+			}
+		}
+	}
+	return mimeTypes;
 }

package/lib/core/util/opfs-temp-stream.js

@@ -35,36 +35,12 @@ export {
 const DEFAULT_THRESHOLD = 1024 * 1024;
 const DEFAULT_DIRECTORY_NAME = ".zip.js-temp";
 
-// Builds a `createTempStream` factory (see `ZipWriter`'s option of the same name) that spills the
-// data of a buffered entry to the Origin Private File System (OPFS) instead of keeping it in memory.
-//
-// It is meant for the buffered-write path (keep-order concurrent `add()`, non-seekable output, ...),
-// where the compressed data of an entry has to be held until the writer is free. In memory that data
-// grows with the entry size; here it is written to an OPFS file and streamed back, so peak memory
-// stays bounded.
-//
-// It is hybrid on purpose: an entry stays fully in memory until it exceeds `thresholdBytes`, and only
-// then spills to a file. Small entries never touch the disk, so a workload made of many tiny entries
-// keeps the speed of the in-memory default; only genuinely large entries pay for (and benefit from)
-// the file round-trip.
-//
-// OPFS is a browser/worker feature; there is no fallback here. Feature-detect
-// `navigator.storage.getDirectory` (or inject `getDirectory`) before using it, and let the writer use
-// its in-memory default elsewhere.
-//
-// Options:
-//   thresholdBytes  spill to a file once a buffered entry exceeds this size (default 1 MiB).
-//   directoryName   name of the OPFS sub-directory holding the temp files (default ".zip.js-temp").
-//   getDirectory    returns (or resolves to) the root `FileSystemDirectoryHandle`. Defaults to
-//                   `navigator.storage.getDirectory()`. Inject it to run inside a worker with a
-//                   pre-obtained handle, or to test against a mock.
 function createOPFSTempStream(options = {}) {
 	const {
 		thresholdBytes = DEFAULT_THRESHOLD,
 		directoryName = DEFAULT_DIRECTORY_NAME,
 		getDirectory = () => navigator.storage.getDirectory()
 	} = options;
-	// The temp directory is resolved once and shared by every entry of this factory.
 	let directoryHandlePromise;
 	function getTempDirectory() {
 		if (!directoryHandlePromise) {
@@ -73,15 +49,12 @@ function createOPFSTempStream(options = {}) {
 		}
 		return directoryHandlePromise;
 	}
-	return async function () {
+	return function () {
 		const memoryChunks = [];
 		let bufferedSize = 0;
 		let spilled = false;
 		let fileName, fileHandle, fileWriter, fileReader;
 
-		// Move whatever is buffered in memory to a fresh OPFS file, then keep writing to that file.
-		// `FileSystemWritableFileStream` is a `WritableStream`, so it is driven through the standard
-		// writer API rather than its non-standard `write()`/`seek()` convenience methods.
 		async function spillToFile() {
 			const directoryHandle = await getTempDirectory();
 			fileName = crypto.randomUUID();
@@ -91,7 +64,6 @@ function createOPFSTempStream(options = {}) {
 			for (const chunk of memoryChunks) {
 				await fileWriter.write(chunk);
 			}
-			// Release the in-memory copy; from now on data lives in the file.
 			memoryChunks.length = 0;
 		}
 
@@ -115,9 +87,6 @@ function createOPFSTempStream(options = {}) {
 			}
 		});
 
-		// The writer always closes `writable` before reading `readable`, so `spilled` is final by the
-		// time `pull` runs. It is read lazily here (not in `start`, which runs at construction time,
-		// before anything is written and before `spilled` is known).
 		let memoryIndex = 0;
 		const readable = new ReadableStream({
 			async pull(controller) {
@@ -144,11 +113,6 @@ function createOPFSTempStream(options = {}) {
 				}
 			}
 		}, { highWaterMark: 0 });
-		// highWaterMark 0: do not pull (and possibly close on an empty buffer) until the consumer
-		// actually reads, which the writer only does once the data has been fully written.
-
-		// Called by the writer on every exit path (success, error, abort). Best-effort: it must never
-		// throw. Closes any still-open file writer, then deletes the temp file.
 		async function dispose() {
 			if (fileWriter) {
 				try {

package/lib/core/web-worker-inline-native.js

@@ -1 +1 @@
-const A="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";function g(g){g({workerURI:g=>{const B="text/javascript",I=(g=>{g=(g=>{const B=(g=(g+"").replace(/[^A-Za-z0-9+/=]/g,"")).length,I=[];for(let E=0;B>E;E+=4){const B=A.indexOf(g[E])<<18|A.indexOf(g[E+1])<<12|(63&A.indexOf(g[E+2]))<<6|63&A.indexOf(g[E+3]);I.push(B>>16&255),"="!==g[E+2]&&I.push(B>>8&255),"="!==g[E+3]&&I.push(255&B)}return new Uint8Array(I)})(g);let B=new Uint8Array(1024),I=0;for(let A=0;A<g.length;){const C=g[A++];if(128&C){const Y=3+(127&C),Q=g[A++]<<8|g[A++],F=I-Q;E(I+Y);for(let A=0;Y>A;A++)B[I++]=B[F+A]}else{const Y=C;E(I+Y);for(let E=0;Y>E&&A<g.length;E++)B[I++]=g[A++]}}return(g=>{let B="";const I=g.length;let E=0;for(;I>E+2;E+=3){const I=g[E]<<16|g[E+1]<<8|g[E+2];B+=A[I>>18&63]+A[I>>12&63]+A[I>>6&63]+A[63&I]}const C=I-E;if(1===C){const I=g[E]<<16;B+=A[I>>18&63]+A[I>>12&63]+"=="}else if(2===C){const I=g[E]<<16|g[E+1]<<8;B+=A[I>>18&63]+A[I>>12&63]+A[I>>6&63]+"="}return B})(new Uint8Array(B.buffer.slice(0,I)));function E(A){if(B.length<A){let g=2*B.length;for(;A>g;)g*=2;const E=new Uint8Array(g);E.set(B.subarray(0,I)),B=E}}})("IChlPT57ImZ1bmN0aW9uIj09dHlwZW9mIGRlZmluZSYmgwAIBS5hbWQ/gwALCihlKTplKCl9KSiFADVEKCl7InVzZSBzdHJpY3QiO2NvbnN0e0FycmF5OmUsT2JqZWN0OnQsTnVtYmVyOnIsTWF0aDpuLEVycm9yOmksVWludDiDAC4Bb4IADQIxNoMADgFmggAOAjMygwAOA3MsSYcADQFsgABFInA6YSxEYXRhVmlldzpjLFByb21pc2U6dSxUZXh0RW5jb2SAAG4zdyxjcnlwdG86aCxwb3N0TWVzc2FnZTpkLFRyYW5zZm9ybVN0cmVhbTpwLFJlYWRhYmxlhAARBnksV3JpdIgAEQdrLENvbXBygABCgAD0hAAUBW0sRGVjjgAWFmJ9PXNlbGYsdj12b2lkIDAsZz0idW6DAT8FZCIsQz2HAXAHLFM9W1tdLJEAAwJdO4AAnxQobGV0IGU9MDsyNTY+ZTtlKyspe4EAEwN0PWWKAB8BOIQAHRd0PTEmdD90Pj4+MV4zOTg4MjkyMzg0OoIAEQs7U1swXVtlXT10fZMAWoUAFoAARYAAUQN0O3SBAG6CAc4IIHI9U1t0LTGBAD+AAEcBdIIARwFygABVAjheggBVBzI1NSZyXX2CACwbW3osQSxfLHgsSSxVLEIsSF09UztjbGFzcyBGgwBNBHJ1Y3SAAGoIZSl7dGhpcy6AAMsLfHwtMX1hcHBlbmSBABeDAIQCMHyDAB+DAlCAAIILMHxlLmxlbmd0aDuBACIBboAAvBFpZihyPj04JiZlLmJ1ZmZlcoUAsAhpPW5ldyBjKIUAGAEsgAAJEnl0ZU9mZnNldCxyKSxvPXItOIIBQwo7bz49bjtuKz04hQA9CWU9dF5pLmdldIICcgkobiwhMCkscj2JABMCKzSBABUEO3Q9SIIA/AZlXV5CW2WBARABJoAADwNdXlWCAA0CMTaDAA4BSYIADgIyNIMADgF4hAEuA15fW4IBQoMAFgFBggANhQAyAXqCAA6EADIBfYIBrwM7cj6BAKaBAeOBAc4BOIAAJIEASAoodF5lW25dKV07hAFNAnR9gACmgAOTB3JldHVybn6DABYCfX2DAYICUCCAAxyAAWYDcyBwigGMgwF0AWWEAWsBdIIBPQpGO3N1cGVyKHt0hQMrAihlgAE6A3t0LoYBqgksci5lbnF1ZXWBBBYHfSxmbHVzaIAATIUBsYEARgVvKDQpO4MBjAFyhQGkAS6AAYSDA9sEKDAsdIEBVgMoKSmAAaIJdmFsdWU9cn19gAANAT2BALmAALeCAEsCWD2BAFQDY2F0gACCA3Qpe4AB9gQwPT09hQIOAnx8gQAOAXSEAA4BKYMA+QMgZS6EADMCdCmGAkICZVuFADSAAssKLG49WC5pKHIpO4QAMgIzMoAARwJuP4gAOQs6WC5vKHQsbiwwfIECQgVzbGljZYAAs4cARQEpgAD2AWyBArOFATmGAqKEAKQBdIUAjwEwiACFgQNJhwB1AioogAAQAikrgwCMA30sdYYA5IAAG4UATwE8hgBIhQGkAnI9gAW6hwCTDm4uY2VpbCh0LzMyKSkphQCFhAA0EnQmPTMxLHI+MCYmdCYmKGVbcoAAgYAA/QFogADcgwANDSYyMTQ3NDgzNjQ4Pj6AAI8BLIAA2gYsZX0saDqBAI6AAfYCPT6CAR4HZT90OihyP4ADmxw6dDw8MzItZSkrMTA5OTUxMTYyNzc3NiplLGk6gAZTBG4ucm+ABPMDKGUvigAfByl8fDMyLG+DAFUELG4pe4EC2oMFJYEBfIAAnQRuPVtdgANYBz49MzI7dC2AAAYEKW4ucIECV4ADtIAEA44BWIAA+YQCGgEphgURAWmBACgBPIcBi4ADNYUARQV8ZVtpXYADPwF0gQBOgQAMggDGhQRkAWmGAcABP4oCKwI6MIAEMIEBoQFphgIthABRggFFAytvJoABYIAAB4ABJQM/cjqAABsEb3AoKYIBRAdufX0sVD17gQR8BHM6e3CJAisCWC6BAjoCLziAAImDAymAAqmCBNiKAMgDdD5pggDBBTMmaXx8gAEegAC0Ay80XYAAvoAAvAI9boIEJQYsbjw8PTiFAJkEcn0sa4kAZwJbXYIAVoABboAAToEAWoEBRgFyhwEeAXKBAR4BPYAAQwE4gAEcB3JdLDMmfnKAAGoBdIMA4AFugADDAT2ABOmFAq4CJnKAAkSHAPsDOCoogAATgAAkgADrgARlBH0sRD2CBGmNBemFAI2BA9UQO3QuYmxvY2tTaXplPTUxMoAEAhltPVsxNzMyNTg0MTkzLDQwMjMyMzM0MTcsgAacgAbABzMxMDIsMjeAACMQMzg3OCwzMjg1Mzc3NTIwXYAAPAF2gAA8CjUxODUwMDI0OSyAAAkBOYAAGwEzgABHBTI0MDA5gAAOATCAADINMzk1NDY5NzgyXSxlP4AA3AFDgAHpAUOFAz2AALsCLlOAABEBU4kAEQFBgAARBUEpOnQugAfbgQSgAX2EAAiHBiOBAMuGBGyBAFEBbYcAQIAATYABeYAABwJBPYAELwZ9dXBkYXSBBSSLAQkBIoEJMgJuZ4cJdYAJcIAD1gRULl8ugQHDhwS4gQCgAViGBJcDLlMsgAV7AW6AABYBQYACl4EAqwFugAQ+gQJNgQMeC28+OTAwNzE5OTI1gAPTgAN9CDEpdGhyb3cggQJlJ2koIkNhbm5vdCBoYXNoIG1vcmUgdGhhbiAyXjUzIC0gMSBiaXRzIoUAegFmggKaAXOBBSSBAkQBbIQCQoMIOogBxwMrbi2AAJeIAA+AAiSGAA6ABN2BB2OBCGOJADQLKXQuSShmLnN1YmGBCdMGKDE2KmwsgAAFAyhsK4ADOQQpLGwrgAiGhQLUAy5zcIQE6YEAJ4ECbAFVjQGLhAkWAS6ACG2FBWkCLkOAB6GHATgCLFuBArOBBNyABGKJAMiDAwoEKzI7MYAHyoMJR4MC44AC+YEAKIUDDAQuZmxvgQLQDS5BLzQyOTQ5NjcyOTaBAvqEAC6ACKABQYAEvIUDWgIpZYAA4gF0iQC7gAHThgIyhAJQBCxyfUKHBQ+FAB4HPjE5P2U+M4EABQE1gQAFAzc5P4MFJhE6dF5yXm46dCZyfHQmbnxyJoAADIYAEgF+gAATAn1IgwZAhQX7BDw8ZXyBCDCBBawBfYAAj4cHnoEBNgYsaT1yLkOAAkYDZSg4hADthQoXATGFChYBb4IKM4EJ+YEAGwNmPWmACfECLHOAAAeAB0MBbIAAB4ADVAFhgAAHBDNdLGOAAAcBNIsKtwI3OYMB+oAKSYEAUYAEWYIATwNyLkiAAYmAAAsELTNdXoEABwE4gwAHAjE0hAAIAjZdhgL/AXSCAC4HNSxmKStyLoEBLAlzLGwsYSkrYyuBAEuAABQCdluGAZoGLzIwKV18gAdsAj1hgACVAWyAAKCBADwFMzAscymAALMDZixmgAkfgQDAggDFBStmfDAsgQDHggDMAitzggAOATKBAA4EMl0rbIIADgEzgQAOBDNdK2GCAA4BNIEADgY0XStjfDCABOsLVz17aW1wb3J0S2WADOiABvOAAysFVy5GKFSCCmoBc4MDwwIsUIcB3YEKrQE9gAVcBzFlNCwwPm6ACLcCPnKLA5wCaW6ACQOAAecQcGFyYW1zIHRvIHBia2RmMoYDkQVvPTErKIAF9gU1KTw8MoMBkIMBDwIsdYQAIgF3ggOzgg0mAUKCCW4FKG8pLGiECw4Bd4MDyAFkgAGZgwAuA3A9WIMC4oAEdYUAtoAHGwF1gAN7AihvgACqBSk+ZDt1gQG9gQAlA2Y9c4ADVAJlboINUgIocIgDWAF1gAGugAFsgAOwBD5sO2yEDEqJAC2AAX8BYYAAdQNhPHOFAx0BYYEAJgZbYV1ePXOAAAaDAjSAACKFAHYFJiZsPGaGC+6AACwBaIEKNYMLfQVkLGZbbIAHAwRkKz00gAWXggLoAXeHCQoCLziACUYCRjqeBoiAB3gFdC5YPUSABUqDDYOAC0MELlQ9W4EBK4ABsIEABgFdhggYgAAagAIyhwS+gAloATuFB0MCPmmCBbcBKIIAMwIpLoYF7QEugASkhwNUgAzRAjtphA1VAW6BDTQEdF09OYAGoQUyMjQ4NoALxAF0gAqRgAKHgQAXCjE1NDk1NTY4MjiCABiBAJeBAH2EAFmBAD2BBHQBVIAALocAFAExggAUAUSCAemBBLKBADKUBrUBZYQAJwNlLliABMyCACmABqoEVz0hMYgGqYIMOIAAFIALoYEACgFEhwDXBn1kaWdlc40AVgEsgQV8AUSBAPOECNCFAF6AAJmFADwBdIIBE5EFA4UCKIAAeYADJoMAfIsDG4QAIgYgb24gYWyAD2YDZHkggwBWDmQgaG1hYyBjYWxsZWQhgAMqhQT6gQBFhgC1gwDGhAC6gADEgAPAAU2FB3YEaCE9Z4AI1oQADYEMjwdSYW5kb21WgQyPCXM9PUMsUj0iSYYDmwVzc3dvcoAPxwFqhwAVBXNpZ25hgAB2DmUiLFY9InppcGpzLWFigAQbBy1jaGVjay2GADUBO4UP+QIgRYQA7AFNhQrJjgB5gQfQiwe6ghDKBSBBUEkggQfCgA2egQR+gBBSASmEDScYcT0xNixLPXtuYW1lOiJQQktERjIifSxMgAK+gACBgACkAih7gQf3ATqEACEFSE1BQyKAAQkESyksTogAIwVpdGVyYYEApAZzOjFlMyyJADIFU0hBLTGEADMETz1bIoARYgRpdmVCgQgzB10sWj1bOCyACc+ABbwCLFGACZUBNoAJgoAJrAxdLFk9MTAsJD1bMCyCAAIDXSxHiQF6BixKPUcmJoAD3wh1YnRsZSxlZYEAD4QAIAFKgQAgAXSBCRKCBJ0DLHJlogpfAU2AA9GMEUwBLI0AEYEKOwFNgQOHggADBXx8dC5SgAKbhwlxggAcATSBDiWBAAyABuuABySJEH6EBXiABPSAAcUINCE9PW8mJjaDAAcBOIEAB5MF2QdhZXMga2V5gAIxAnplgAKrgwhdgArCgQUshgo9AWyACjsBXYAGqwxvOzQqbysyOD5mO2aFEfgBZYAFLwFmgQ4/BChmJW+ADQgEMHx8OIAAB4AAdoMAEAI0KYIEjAFyhBBygAzfAzI0XoIADoQQWwQ8PDE2gwARgxB5gAv4gAAPgxDEASyEAFSCAEMBZYEAGoMARgJeYYEAR4AA7YAACAsxXjI4MyooYT4+N4EJpoAAjgFdggCTBG9dXmWKElcBZoEH9gQsZi0thwGfCnNbMyZlP2Y6Zi2ACCYBbIEICAg0Pj1mfHw0PoEOWIIFFQJyW4EIrYAAuQJdXoIFDoIAEIQAu4EAEwEyhAATgwC9gQASATOBABKBAMACdF2AESqIBEmJBAgBaoAHhgEwgAS6AWWWAB4DMSl9gAIBigTTggIEgATYhAAMgAIEgQ4zgwIUgQAHAWmBC+MBb4UNYYQCEZQTtQRvWyhpgQDxgAFWhAFCgAFbgAFCAV6BABSGADQDYz1mgAA2BCFyW2OABnqABxqABwyBAgiAAWSBBxaCAgEFbz1mXmaBAEWAAAUBMoEABQEzgQAFBTQ7bz1vgRIVgQEJBG9eOTmADiAEY109b4AGUwRvXT1jggmhgQmsgQm3AWOAAv2CALKAB+YENjg0M4ANJgUqYV42NYANVAIqbIAAQQQ3KnNehAAZBjgqYyx3PYEAEwFpgABIhwAWAW+GALKBDk0DND5ygg5GgQ4/gQB2A3c9d4ICdwF3gRKnAix0gQAWgACFA3U9dYIAFgF1gQAWhgIqgQBAATWIAECAAWECcl2IDYiBABOBAAWGABMBfYEBrYMRIIEDdoUDlJcDb4IHs4UDcYkK/IAKOIEHdIAKIoMAQwMvNC2AEJuIBKeACi2DAfqAACeACj2BAg0BbIAAB4ACCAFhgAAHgATZgAGvgQr3AXWAAAeBAtGAAM8HdyxoLGQscIAAxgIwXYADV4AAMgF5gRHwBD8zOjGBABCAADsBa4AAEAEygQAMgABAAW2CABwCMTqACwQBcoEASQNiPTSKAj8BboQCPQF3gAM6AXCDAxcEXmxbeYcUJwNhW2uGFEEBY4IDBQFtgQBLAmJdgAnyAXOBACmEADOAACaHADMBbYwAMwFwggAzASuAAJwBZIAANYAAK4QANYAAKIcANYAAf4oANQF5gwA1ggDFAXOBACuEADWAACiHADWAAIGKADUBa4MANYEA6oAJu4ABJwF3gAEfAWiAARMBZIoA94AED4QDNIABOQQmLWU6gAMkAXWFAQGDAkSIAQWCBNEBdYcBCYEEtwF1iAEMAysrXYACxAFwgABuAXmAAG4Ba4AAbgFtgAC0AXeFCCcBb4AGzgFukgZXgQJmggIBAlY9gAAMgQAJA3E9dIMACQFLgAxHhQlbhQARggAhiAlBiQRhAUyDCNMCViyEAEkESyl9ToQIAIEAqQF+gQQNBDI0KSmADyIBMYEA4QU7ZWxzZYUX6IUA6oEEfoQA5YACtoIFsoAEYQE1gRMNgBDTgBBogwANAnI/gRHihAANAm4/gBG+BTorK24pgAAFAXKBAAWAE/KBEJOAD4uBATmBAAkBcoABMoEACAFuhQtMA2V9T4EAnYETZ4AULIANLYIAtIAAsYEKKoIGYIENNIYAFYAJ4QMpfUyEFCiCALUBboEHFAEhgBKthhWUhAjlgAUrhQtRgRCxgBLxiRLrAW6CEuuABsODAVQBT4EQd4MAL4AS94YMS4AAFQF0gBL8Al49gQYwgAQhAWmAArqBAA2AAsCBAA2AA1yAAA2AApiBAA2AA1mAAA0CM12FANoDWC51gAyvAWmACf8ELGllPYANrYIDtQFvgghzAWWAEX2FCHcBLoYN2YEJ/gFmjwAghwj5gAAhhBjegBsCkxddAXuFCf+AGw4EcmF3UIUADoAWU4MA1IQaOoEBKoAbGIIKM4UAJQNPbmyAGwkDfSl7hBeMBHN0YXKCAnaFCa+CC3yAAm2ACxEBOoEE/oAWPwI9PoIBQAJaPYAK94YAe4EXo4EY+ANZOm6AFd+BF8CAEnqCADICb32ADTAGYXN5bmMgiRfqjRAqhwDGAW6AAEUDcyxagBuFgwB3DmF9PXI7bj8oYXdhaXQoggBKhg71gBxdhQ66ggAfASCABcWDABwBaIAMtoAFaAFagAVegAhIAmY9ggAQggAOghLGgAHdASGCBXQDfHxvgAHcgQAMgAJpiQXmAVKBHIQBcoAHdgFugQBMgAfggAA+A3NdK4AXAIAC44IAEoQAEAYsZj90LmWBHG6CDaMHaShWKSk6bIANnAE6gwCTAWGEAmYBY4QViIYV+QJZLYgADAMpJXGBEdyFGPACYWWAAHwDZSxjgAB3AVmBGguGAUSDGQWFCpUCeySAHPoBR4AB64YBcoQBNQJmfYMKroEQFYACWQIpe4MAjAFmhACMAXODARCBF9mGAIGABn6CABWIABOCAsABYYMAuIEAS4UPX4cIyQFwgA13gBEzgA0Xhw0NhgNWAXSIABQDYT1kggArAW6FDE4BY4EAboMAFAFyhQ06gAFcgADwgwB3AnU9hQCJAjxZgAbFiRQbAzA7WYQFxAR1fD1jgAj4gAYagBJAgAChAXWKAcMCaimADo2GAVKBDZaAAASDA04BbMMDToADOoIEX4UazP8DQIMDQAFpgANAAWaEAgsBc4EDQIMVYIMByYADTAFsgwMviQNOhwNMA249RYICygJvKIMDPoUGzAF3gQIejANngBeaggMnAWmAAAoCLGaHAvUBc4QCBYQCPQIobIUVBoYC8oUACYEC+AFhgRF+AihsgAtEgA03jAMDAmEshQA8gAAfxgMHgQEQAXOHAtmFAmuIC6KFAryDAuKAAOiJAuOACbGDAruAD+wCaS6GD6CEABWIAtCGEjiAA2CHAoyAAUqAFRyHADiAANiBHJaAEgiCHJaGD8aAAQOEAWeAAWEBZocA7QFzgADtAWyGAO2ABSEBZYABQ4MAwoAHQAJ0PYAAYAFhgAIihQOKAWOGByoCLWmDA1yEGaoBKIICSYAB+YERFoABIAE+hgrwhgJdAmU7gAKyhRpBgh1bgAGWgAsohgfNgQH+Bm4rKGMtY4AByoET3IAT/QUtcT49dYAT2gI9cY0EKoAD9AZ0LHUsdSuAACwCO2aAE4eOBDcCaT2IEVgBO4ANv4YAIwFpgR4RgQCBgwFmgAAPAXWACHqGAIoBLoQBEIEEWIAAZIER+IQCLIUBT4ABiYYBSwJyLoUDMQU9bnVsbIYFGJAGZoAAaoMBIwMhb2WFEU8BV4cHxIEIaAN0cnmFCZKDAmKIB+QCKCKABEgBIoIASwIhMYEIHoAU1gJjaIUAL4AIHoAAFosAT4ACDIACMgNpLEyABQ4BT4EFmJIDrYEAkQFmiACRAVCBHW8ELnNhbIAjDAEuhxFmgAAtkQCfhwhjhABSiwCXgAiVggCXlwBVgQClhxHWgQAigANuAixOgAMbASyAG7cDMipRgCA3ggcuhgQDASmADNKGAgYBYYAA3IEAI4ICM4gAFoEAFAEsgwA+gAAbAXeBAc0BYYUAEIYTfIUAdwNyLHuAEO+AHPqAAAaAI6QBSoAjnoUB1gFWgADgAmZpgADUgACvBTp3fSwkggVNgCRgghTCA2UoY4EDkAFmgCPVAigkgABoAUeCAB4CaWWABkGAA4gBd4cDgoIFmIgY8IAKtQJ2P4Ik1YEDM4MJsAR3PT1nhxCGgwDtgAAjBnVuZXNjYYAA24AGOYAkLQNVUkmBI+EEb25lboEQIoYfRocKpYMdOoYZ4IEOtIIOoYAgMgRoYXJDgABEAUGCCqCFAIyEAvqCANICdymBCsKAACOBFH4BKYElRYAjhoUAxYAED4IAxYMAZQFlhxUihAWUhQBzgAQ8hR4tjgAchQN8gRDphAALgQIahQuBgANthgBvggkdgguuhgBphhuHggJqhgAqgQCviAFegAPDgQL+hgAfgQE8igAfgRg+hAfBAXmvB8GSAhuRCxGAB3OcCxGsAGSAAlQBdoAC44EAO4EH5gJ9LJgHyoIGrIYEnQR8fHIuiABihwJnAW2CBx6HAVmAHACAA22LAD2AEHyIADyCBOgELDAhPYEDtwJ0KIAdOAFehwAriQCwASmMCwgBO4IiCoYdSQQyKX1vkAryhwe5gwCbgQbUhglvAWvFAa76AZqCDn0BLIAORpoBopoBgIYcdYUJY4IBtgN0WzGADvOTAY6AD42WA5MBboIDiAFigQFwgBtXgAOZBWk9MTJ9gQ/egAnFiwA2gQAcgA8EhwAxgAjFgAdChwG2gAdKgQGwhgN9gAHGigEChAgEjgS2gSH4AW6HBLaBJkMBcoAFrQI9Q4EEiwJedIEFzwFnggrdiQXCiAQugACNygBogQAKkQBogAHngACFgR0phQhoBFszMDWAIhILODk2LDU5MTc1MTCAIeKAIgIGMDgyMTkyggxQhgJdAWWEBmoBaYAYQoIGLAFGgBVxghsphwAPATKAGxKBIqyJG5MCdDyFCluCG5qCAKIBboIOhoIBposAK4UUK4cAKwFyiQX7gAmAhwDPgwDsggXUAlssggYlgQCggQzwgCtOgydBggBnhQDtAX6CABqCJwwEO3I9eoAB8IAIcwN1bCiAAAoDcitTgQldgCRSAjM0gCLdAzgxM4AldoEHHwF0hwBLgygwhgBQAW+BAFCAAB+DAFCDAHwDPVtpgAFgAm9dhwCkggGbhgSyATKAIMCBACiAASiFAZ+AAHiEAIcGdCwxXnQpgRW8iADkgAAfhxLqghKShwAcgAC4hwAchiEvgQAjgwRyAUGVBHKAAcoEY2h1boIdZ4AMNgJyZYAEHI8reogEaQF9hAD1gABGgwAmAmVkgQIHgw4OgAAMAm8sgCyejwBCAmYsgBupgxtUgAuwgQJFgAAsgCAzBGV2ZWyALFuAK68BbIAK1QQ2NDp1gAu/gAjphgRighXjgBRMggB/gBzFgyw3hAF5BWs9bCYmgB4RAiF1gAetASGAHs4Bc4ATMgEhgAoJBHx8IW6AIwmAAA2AF9cFIWx8fGuAIQ2DH5kBUIAATQVCZSh5LIEHqIEeTQRrPyhwggAaAl9lgAAbAUiBABuCCR0DKCJngAC0ASKAACaEADEBcIAF2AN5PVWBAAsCZiyAAmuDALuIAT+AFN2DDgUBLIAAegMocz+EADiBAE4Ba4EBoQMpOiiABPiAAA4BbIINNoQAHwFkgRnbAUmADQcELHksKIEKy4MqHoIAvYIaHQFkiA0bgQBahQDUgAAbA2s/cIcAHYIDewNjKGiDKduGKgCAApaFKgCBCkSIDaCADK+FBpMBX5UCIYQbCoAZmoAcWIUEkIAivpAqrwFpgx5QiAS9Ay5taYAGiocJGYIERQItPYAL+4MpUIUHRgFyhwoAgwLEhBEWAWaGGDCGDyqBAEMBOIAayY0KYwFmiAsQgg2XgQXOgwmjhQBEgAbdgCPXgAnVgQk3hAzhA2YtOIAMUoMAQ4IhOIMAtIAL04YAtAFsgwBQiQhdAWGCBl8Dcz5hgQ2zggBliQAegB6PgABKgAJdhgZOAWyHDnyDAGsBOIEL6IUAYwMtYTuAAsABY40AZ4MAZYMAF4gAYIIAXoEN0AI9Y40sBYMBDIcr/IAAxYktiIIADQFMhADWgABShgIIgiwWhiwkgS2AAmUugBeniQAXgi2CiiwsggI3AXikBFgBaYEEWJEvvpEEWocEKgFviARZgBvzgwQ2gwQ/gwLyAmwsiASHgCOYkQR7AXWIBF4Bd4EQHYYEV40EVYAPggQobz9wgQOXAXCCA7YBeYoDtgFzggO2hAAfggO2gAIAgAQ8gAQSAXCAD8aKAPGJAHOEBBaAADqCDSuFAayCBjCBMQiAAP2HKuqBAHYCKHuDD6sBcIAJI4UvowFygw63hBXZgSkqAmFkgCkpgg6nhBjegBc0gCkYgzF1hAq1iy5lgButhSFFhwE3ASCAEE4BYYAbroMAMQR0LmNhgAFGgRmFgwMkAXuCBE2ADBkBZIANrIAMDIATPgFvgS22AmxvgAEPgDKdiQkyBSxjYW5jgAUVgRPVgABIgQAMgg2BgA2DgAU8ASyAAV+BBaSBBL+GBYyEAU6BBYyABQOCCnoBcIMFBoAA0YIFyQFvgAXTAXOHETmSBOSBBBUCbCGDAVKHAsiAKNqLFQCLCdOAAHCECQMBcoEAhYMkhgNwKHuCA1SBApmBBEKDMkiAMu+AAikCdHmAADEBIoUCLgMiLHuAAG4BOoEArAFygABYhgBXgAIOhxKmAW+FALmAHN8CJiaAGiEBOoAsWQFvgBMwgBMVhQIiAT+AIdqEAAsBLYERHAE6hQAQggAOgxSsggH9gwSogBZ4hhCghAH5AiF0hgHvgAAOAmkpgwApAWmCACmDGt6CEa+GACWGBPGCELmEAnqABvkDZSxsiADJgAEUjA6PBGlwZVSAAEMCdWeALYeIACmCADqJDB4CLneEM82BAZCBM9mBAuKAC7qRAvKEEciBAfKBAOSCMX0BO4UUmoMDnAF5hALFAWWEAv2ALu+CAv2BAO0CZS6BApiHADCEApgCO2KAACMCa32FABaBAJCAAKWDAjWBBvSFAT2MEkuFAIaDADiACfCBJFeCD2aCEg6BEeWCDCucADeEAvuKADgBboEVHYAACIECVYUCQ4QGhgRGZT0iggOFAixQgAAKggDCgDXYggVgAViXBWCAEFGMBTmBGGSCDfaBEPoCY1SAEY+BA7CDBPAEZjtvLoIOJAZzV2l0aCiFAmMGIik/Zj1BgAAoigAdAmluhAAdgATfA2Y9eIEtAAcub3V0cHV0gi5HATCEFjCFKNiFApiCF7MBYYwFVYAS5oQDWIwOTIIEroYRagJzK4YgXogNhoEPN4YG5IYMfgVuLHtpboQAjYAX0IIGl4AZII0AZoIRdIQVy4gR04YAXYAOJIkA14EtMIQAgQFliAAXgCD3AXaAA7qIABKAFheHAA2LBGOGBV+AAxuHBWGDIQ+MB60Be4cGxQNlfT2AA+GIAN6IABsBLI0A6oAAKYwElAFukgSUAWGKA68CYymKAA8BbIsAD4ET54UH0gFUlgJyhDYrAzsxPoMvOoEixQE2gAkGjAoJgDKzgxyLiQoMhhc1hQnPhwlfgAiJgRM+gQh0gxdPiBNkgQaHghApAX2FHreDNZ2GF8CAGvmAMm6FAdKACT2CGGAEaSxpK4EsD4Ae4AFlgC6VAmk/hgAZAik6gDGyhhkuigIahwbKghZzAX2CAHMDRGU9gDMagAPbhBTdBm5hdmlnYYABD4IoxoYADgEugA6XBGR3YXKACH4EbmN1coAbEAJjeYABJIAAPpoAI4YEIIMBJQVXZT17b4An+QMuL2OAMCsFL3dlYi2AEP8Na2VyLXdhc20uanMiLIEACYAVO4YAJIABnoAI4wVzL3psaYAALYAAHYMACoQAFwEugQASASKIDKKCAbOAH2MCOkSAHKYDZTo1gChyAWyDAAcDYWU6gCp+kglAgAAYjwAVhAEQAW2CAQiTOZmEACMBYoIAIwJifYcC4gF7gC3PhhjhAU2DAhsBYYA6EoMACYIEXQRqZSxWgQRpjBizAUWCDueCAoeAEnmBAZiDA0wBb4IciQFzgAowgAAQA2ZpZ4Ea6oIHDAMhby6RANQBKYcFroE6PAkuaW5pdE1vZHWBDZiBLWqAAEOFAZyTAEGAK6sDfWYujwAXggBOjgAXAyxmLpABIYMALZAAGYYZfgZ7aGlnaFeABYoHck1hcms6MYA2/4AFJoUD7QJ8fJIKLYkJ8YIdYAFNgwNZAVaBG58EKTtxZYADrIEGGwEigQAxAiIshAowBElkOlaADg+BAXaAACqAEPETJXIuTUFYX1NBRkVfSU5URUdFUoQLn4oKEQJpfYUKkogeXYAK7IAPWYYKJYAiAYAfE4E174UIGIMAuwFrhQC7hAefhQRhhQbNhx4igB4dAjtShgDHgAQshgDGA0ZlLIMAkAFlqQDKhB24gTYwgA31gwEsBFhlKG+AGwsCLGqDAogBQYEH+4ADrAN0cm+ALOwBcoQA/IIFmoAP9gN9PWqAHGWCAEUBbIwJGIoAD4EASgJUZYEZAIA3pQNtYXiBAl+FA44CLDaAJIWADriADvyCADMBb4AEuIYAYQEsgAITAXaAGRwBQ4EBQ4EDg4QAEIIAl4AAEIAA4YMAf4I7KIUJZIYI/40GYwFjiAZIAncshwa/AjpogB4ThwIUAVCAB8MDZXN1gBq9owA8gAUnigyBiQgmgD0ZiAAPgDfVgRGoAmkugSghAmVkiAOBkgDBhQUZAUuCGcKHCmuAAKqDAieEAoYBdIQD6AJ0KYIUn4Uon4EFsYYdp4Y67IA1EIMPF4A5KgEsgDhyggAWgBSmgwBsgTtjgxYtgQAKgxSRggAUhgB9gQCNhQ1IBlVua25vd4ALFoEX+IASJIQEiYQChIAOAYAJUAJja4AO9YEJjIADLYIt0wFviQE+ggSjA2Qoe4IAQgE6qwA6gAF4BGFkZEWBAhEDTGlzgAeugAE8ASKEAEIEIiwoe4EKToAIV4YgxYMB3gF0iAMjAXKEAzeHA8eAByqAATeAAUeANymACguBNygCJiaCBXGAAyECPUaGBFoCZT2ABFGBFOqADFyAAAoCZGWAAY6AB3uAAWcBKIUEG4IBeYAEBYQAW4AgFYAAVoAA1YEAVIcAR4AD0YQAR4AACokARwIpfYAAcQFQgAhlAWqFC4KIAmeEAhIGKTt2YXJ7iEDOAkxlikDPAk5liUDCAk9ljkCDAlplg0EbAlFlhEEcA1llLIMALQEkgAmQB2dsb2JhbFSBC04CR2WCL1+AOSACMTiAHaYGOCw3LDksgAAQCDAsNSwxMSw0gS+GATOAFi0BLIAvjYAADQYsMTVdLEqDAigBTIM4n4MCiwFOgytkgjokiSO9hSy1AXSENtmAHFOBO/sCODqAPcuFABSAGs+CAPECIHKOAD8BMYUpwQFyiwBAAzQ6MoMAMwFuhgB/gCttATGAAKaAOfSAAMCEMD6DMDcDLDQ4gASOASyAF/sCMTKAABkBOYA6AQM1NiyAQMwBLIE6MwI3NoAAFIA58YAA24AIPgIyMIAALQMzMDeAADUBMIAAMQY2MTQ0LDiBADMEMTIyOIAAKQE2gQA3BDI0NTeANlYCLGmRAH0BNYAAfwE3gQCBgRumggE1gQBWgQCKgAB9gQCNATCBAJCAAIGAAJMCODCCAJaBACiBAJoBNoAAM4EAnoAALIAYb4cx4QFvgj6thCCfhD6zAWmEFEyDKHcEPWUgaYACeIENmoAIlQNMZT+DAqiAAaOTQLaDAA2EEy6AJzIBcowAP4gTqYADpAErgApahABPkhN9ASuBAJiBDYOAAvEBZoAGwYcEVQFmhAC6gCoDAiE9gCOWASi5AKgEKS5maYAIBoA0R4A9IYkeW4I0QoMBDwd7Y2U6SmUsgAOoAzAsd4EABQFogQAFgARrgAAVgAQlAzAseYEABQFrgQAFgTKGAyIsYoEACwF2gQAFgASfgAoMAmU6gzkeiAWXAWyEQCyDH1OAK1YBdIQP3gJ7U4EHmoAEtIUBHQIpLIAObgNyLF+BBI4BeIEATwFJgQAFAVWBAAUBQoAABYkj7oIwOoMaD4gC9I49UQI9MoQrCIIuzoAb2IAAB4AqpooDJYEMKIg6aocjJ4QCnYABkYEDKwJjdJosmwFIghMXgQAKgA+yhCydgA+ygTifAXWUADqFApKCACwBWIYAQAFUhgBAgAwjgAzygjWDgAQ0gwAKgAsTA2l9fYcC3QF3iTFEBFJ0Wy2COdwGZT4yPzk6gDppgCm1AiIiiCBwhAGMgQXOgRQPAT2AAD+FEIqAAYCDABQBIoEMJ4MGvQ8gIit0KyIgKCIrcisiKSKFARqIITEBZIoB3oEypoApKoo8noE/OoMBYoI+3QQxfDEmgAMAgAAphzxWAW6IIMmEAFADZS5SgT/5AWqAADiCRSeFACABeYQAIIIAKIIybYAVPIIAFIVDwogC2gFrhgNAgwIFgkPvgAIGgQzrgAA6gjRKgAoHA2UuRYgh6oAAeIAxJYEAK4Aau4IADoACMgI9aYUAX4UAFIA6n4ARt4AAOgMrPTOAAFMEaS0xJoIAV4AAFARLZVtPgR1cAytIdIAAOwIucYEzfwdlLkxlW3Z0gA5mhgARAkVlgTE2AU6IG6oBbYoBTYIA3oITGpEApIAd0IFDAIEACoEAoIYADIAAmIEEBoMAmIIAjIAxtJYAcgFiiQI/gD01A2UtVYgBbYAAsIkcVoACWwI/WoE8gAE6gAAGgAAPASuDMzuIHMcBZ4gDmARfdCs3gA+mgQPxgADFASiBAAgBKYApsQNpPVGAJE6CPCWAQbABeIFDcgIveIABxYA7UYAu/wIrX4YEHgMuLi6CBDsEMTUpLIIEKgdPZTo0MixagQQPAVGFBGgLLFllOjMyNzY3LCSBBDYBR4EEQAFKgQi6gBDqAWmAB1GCBFyAA8WBACSAGViACx+EABGBQSsBdIAJOwFShgR/hAAjAml0gUJkAXSCAFYBOIAL8YAADgFmgQATAXOBAAWACv0CMCyASUSADw6BAAUDd3Q6gDKqAWiBAAsBZIEABQF5gQAFAWuBAAUBYoEABQF2gQAFAWeBAAUBQ4EABQFTgQAFAXqBAAUBQYEABQFfgQAFAXiBAAUBSYEABQFVgwCbAk9lgCYRAUaAAjgDKSxCgwASgACbhQASAUiGAL8BRIIAEAFFgQCeAU6BAAUCRnSBBaMBVoEACwFQgQBOAViBAAUGVHQ6OCxEhQDLAVeBABMBTYEABQFSgQAFAUuDAPkEJGUoVIAMmIMGGwEpgAyHAnAogRIiAyh7cYEATAFqgQAqAVaBAAUBRYAABYEW9gFMhgA3AzIqUIEAhacAOwFxgwC+ggA7AVirADsES3Q6eoE6oAFMhAAIAU6DAAiIBhIBQ7sGEoACfwFTgR+gA28uaoAIlgQsby5FgBIbhUBPAW+GBhOIAxyBAC+FBzaRALaIH4CHACqCBlQDY3QogDavgg7BAnQogiRqgAG7gjTqiSC2gCDGhAzOggvsAXSAEY2CLUkCcn2DGiqDAOuAA0yBDjqAAyyBSASCCVCAAWCJAV2HPPcBIIFC2AIpdIFGfYA3ugNdKyuESb2EADWGHYmFADqAAR2QAFCAASqJBd4BMYFGIoQ0JgM9byuAONCAORSABeaAP6WANC2HNp+DIbeGAYmCStGEBjSBPVmECOCBIfCANxkBcoAAnYUBdIMA/wFuhQD/AWWBFyiCQ3WEAwqHR5uDI7iFAHGBAKcBb4cAcQFvhzm4AXKABeCAP/OBNlaDAAoCO26AMqKABmcCZT+ABs4BZoARCoABxIUAE4wIDYAIHoEIDQRfdD04gAO8gAViAUmAIa4CNTiAA74CPUmBBM4CKzGAA7eAAAuAA6uAABgBNoADmAE9gQYFAysyOYADmAE9gED/AViAHywBOYADmgE9gwPUgAOfgD5lgAOcggAuA010PYAFIgFSgALCAyJuZYEbfoBNxoACDAVhcnkiLIFEo4AMnAEggBV+gAANgAADgAGQgBWPgg5jhwAdhAAPgQ3khgANgAozgAocA2ljaYAOEoAkrIBEa4EAT4MKMIYAJYA8N4AC+oFARYAFjAFWggAKAXKAAAqAAweEAPoFMTkpO0WAJX4BNoAHHIAAF4BGJwFdgAD/gQAJBDhdPTeCDE4DcXQ9gAK2ggPKhAFrhQPwAjg4kAKQggyhAjM+gBBkgQIOgQIHgEc8iEz6AjQ0gTVWigAgATmIACCAATECOzKBQtaIACABN4kAIAE4gDn3Ajg3jABgiC2NggRYgQCyhACmATOABIqCAKUBNYEE6AJ0PYAEUwFxgAEDAU6CAAoBS4AACgJPdIcuB4UEXYsldIYCb4EldIMw8IACZQNuXT+BBv6AAAgBOoBDa4AC8YAIG4AIMIBFjIEC9AFygDyjAX2AAkSEAA2AAAqESH6FDieABKCLNZ+ATWmDSIuWBOaEAH2ARpSAA0yDAH0BcoEAfQFmggT2ghwJgCEngDyrBCtvLTGAAE4CKXuAAvCACDmEGxuGAvWAASYCaXSAAhkDKSxagAD8hwR3hACagA4BgheJhRdzATGKAQ+BCDGETSmBCK4Dbj5ygEnMgACHgQEAiAApgQHIgADSgwAqhAFYgENZATeAJ+uCCGQCcj6AAgYBP4AABAM6cimBOpYBboAIcIYEf4A7EgE7gACGhAphgA3ZgQifgS/ZhEUrgASNiCwGASmAAp3TAcD/AbGGAbECbnSAA8CBMDOFBkoBUYoJ5AElgAqmAjIxgQuohwZsAVmGCyiAAGmGTAUDdHx8hgAMAXKFLz0BMYQCnIRPVoIK84IdbAEmgwtWAiwxhwAtASiBGziBJ/sBPoEAHAIyMYEOwQEtgwALgAXBgBmAAixuhwAaAW6GABoBKIEMJgM2fGWBJuSCTGeARrCAAJuLAVGDAVCBAEWBAGQBaYYnKAFlkgBsAT2AAQSAEnSKAFqFT8wCPTWAACWAHlYCci2DAAqDAGSGCqWAJ+kEKTtkb4YAf4EBu4EAkYNLr4QAgIABo4A+nolJQwQpfXdogAWhAygtLYAP3AFlgQCAgga1ggCIgRLzhADRgQCAAjE2gwB+gAAIrgBlnAEVjQB5hS8HiQEHgQW6ASSABnPPUv2HUvcBXoJS94RS/QEkgQIUrlL+gwEXgAA8hVL9gQALiFL+gwBWhFL/gADUBVtHdCxKgBEDgA9CgA5vgA9rgA35gCl0gCoAAiR0hwMcAWaAD4qADTyFAvyAIS2EAkgCMDuHAvyCA+WHK2eEBC8CfH6AHYGDTwiAAB+BCYmAJhyIHKKAAvaAUsiHBwgBY4FLmYMRpYAACZhTA4I7fIQAO4AFawFeghULg0dxAWmEUwGJABOEUwEDbj1vhUF+Al5pg0G9hD3zAW6DAA6FPg4BcoVB2oMADwF0gwA2gFMGAmVyiVMHAUqAAnGIADYBR4MAD41TCYQCcoJPAAE4gQAlglMKAW6ALGUBaYFTCoQCcIcqdQJeboQDfIYSfYIePQIxNoEOmQFCgE4Sgg/gA2UuVYACtYEABoIO2AFCgAAHgSROAUKAA92AVGIBKIIP8IcAJIAQSoA9N4AAHgEtgAE2iBJ4ggBaggA2Ajg/hwBXgwBIgAsEigBGgAmdgEnQggBFAzEmN4wAfIgSeIQRuYQAWAMxNi2APeWCACyDEFOCAAwBfIFL64AAH4ApxYwAzYJDQoA3zwJCZYYQLAFCgT34gEtmgCZJlwBIhAAniADdAWOCAN2NC10BS4oLYIIP/QF0gQ/9iAbohQArAUyMACuAEJ6VACsBcYYuSoMAKwFxgQN5gwArggBjAVeDAA4BMYEfpYJTeIE/A4IQbYAa0YAADIg0I4YBP4UudYAAIwFVgApDgU+hggAIgwAQBmUuTXQtLYBBPIMAMIAFwogungF3hhM9hwbVgwCRATyEEOyAEwCEAKKDQsUBcYAYL4EMWgE8gD6DgAQdhxMOhgCPhAbUgQB8gg4VgD+KgwjMgFK+gAAXAU2BU62BUsiBAAmAAICBFVqAACuBPvGEAAqBAAgCQnSAIxSAAw8CLCGCACOBEh6IABsBKYFOhoIAYIMAaIAAGIBWyQIsaYBSMgExgAFIgwAaiBMJAWSEFF6CBPiDJjCABIQCSGWBDLeAFGSAFDGAJiqCAAoBV4Alm4AMOIIAsIEAo4MSDIBMSYAA24ABpAFzhAZHgA1jAW+DAQ6CArMDdFsrgBJVAU2ACxWATZuCAKOBAIGAA2iCACWAC/iEIVCACVyAACYCOymBHaOIADUHMj5sPysrbIERLIAAy4UCAIAARYAIloEAgAFzgAHBgSfVgQ5XgCvWAWaBACUBRYRAZwF0gRUagD60hwdlgQBUAS+AGJSBBw4CO3KARqqCAZsBb4Emo4A45YEHfwJyPYICPYEAE4ITE4gCNgEtgANSAVKAAJOBAMaIAA+AD8aEAJqEAPeATqYBboEACIYAqIED8IEA9oEDZoIJ5oQACIEEI4EAGIAv3IAARIAAPIANEIIAPIAACIEUFIMCqoEB6oQAp4BGs4MH7oEAyAE+gBBjgwHRhQCKhQCuiwp9gwHUgC4ugEaugwHaAWGAAAeAHWaBOoSDAeEBdYMACgFUgi71gQAKgCGbAWiDAAoCTWWARCWDAaOBDuoBRIAAdwFvgg7lA2UuSIEO14UDyIADTIIDUYAAiIMB1oIGPgFSgA57AztUdIUIYYYC+gVvPWxbbIMA6oEALoEBAAE+gSUZAW+ARB0BZIAAKgEsggAdgABHA28sYYALs4IB34IAb4FIYYAAXIAJ0AF3giYYBXVbbi13gBnkAXOAAFGFAXUJc3QrPXMqKG8rgB9JAWOEAhqCABIBY4MAVYAAGIM1l4ACqoA0HYQJdIAAe4AC3IEat4MAagU7KW8tLYABYIIADYACZIMACoADioAR24MADQFogQAXBGQtPTKEAZUCZD6EDnaAAEuBEGmAASiAAmKBABGBAPmDAFWAABcBboYC5AItLYABC4AA4IEwAQFsgwK5gAA2ggCygQDEAyhvLYQAFgIpKoIACYAA3oQAEYAMCwIsboAAXYIQpYEgjIIB84M6hYIEZIIDx4AJWIFIXoMAggExggG8gwz+A2Y9ZoARQoA+14IRQoECcwE9gEpygAAng1aAhAxFhQl6gwBzgQC7g1hMgAAPgA/DgBDDgEWvgQGRgTMFgACIAW+ACG+AAlaBAOqJODGLBPyCAJiAEHyBERSATuEBRYAeaoABzwNsPTeAApWDRwuAAYKBA8+AUFwCMziAABUBM4JIE4EW34AA9oMGzYENQ4YNyQFpg1HkghadgQBPBigrK3M+PYAwmQFpgEJBgSg8A2E+c4ADcIAGTIIBQYACCAE6gADJA2k/KIAAIIABa4gAGoEWuYAADYAQeYIADgYpOnM+MTCDADuAEHuCABSAA7GBAA4BN4QAMIEAuwFvgAOqgQCzgT/BhQCyAjpphAARATaDAA+AAAqCAOCJE3cBeY0BGIEBFoENl4MBFoEC5QFzgAA2AWyAARaAAF+CMcuCAGABbIAAUYYHOoFRYoABCgFhglFcgT80gAMwgQBEAWGEAQ0EKytmPoFKVAFugADsggp4BGw+ZimAAvCCCF+CAMyAAxEBaoEGZoMAC4ACaoQCzIABJAItLYAwz4IggoECtQI/KIAARYECqZgAPIJL/AEshwAhgQFLhQAigQAMgQAjggAeAmYtgB6qgC7UAWaBAWKIAFKBAWiGADGAAAyIADGAHuaASz0BOokALYABh4YALYAADIoAXgEzgQ6ZgAFEgBRbgQGfAm8/iAE/AjpuhAARATaDAA+AAAqCAWmJFecBa4gbOoAGrYMBMgEwgB1CgAKQggnxgwl0gAYlggAIAX6BWqyCW2yBHgWAGSGAAJeAJj+AJiGBACOCGl+AXOaHGYCPAxWBBaCDC+WAAW6BCNWBAaiER/UDLkZ0gETYgQ7Kgkg9gwAQgAHjgFQTATiBFlqDABCARwKAKsEBM4EA7wJuP4MKQYMDq4MACIABHwE6gASagBoxgAgShAAfAW+EGjqCACSFAA2CAckCPWqBBK+BOpuBA40EaS09aYIAEIIAOIE/rYIEf4ACbIAZuoAO8IIAF4EU74EASoIACIMARQFWiQBFgA95AW6HAEUBboEARYUCbgFzgAcagADyATuEAJeBCemCAJOBAAmBApSBDjsKYnI9W3tPdDpNcoASJIEZm4EABQFZgQAFASSBFwcBLIEAHAFSggAcATSBABwBNIEAHAE4gQAcATSJABwBNYEAHAE1gQAcgB/wgAAdATiJAB0BNoEAHYAAGIAAHoAgAoAAHgIzMoMAHwFqjABYgwA8AjE2iQAegAAUgAAfATiHAB+LAD2DAB+JAF2AIEyJACGAABWAACGAAAaBAEGAIGeAACKADqqKAEOAABaBAESAAAeAACSBFciBAEaAIRSJACWBFiWAACWBAAeCACWDAQOAISUBfYAPYYYbcIIL1oUbcAIqZYBG9gI+NIAdyYAzXocbY4wLRIAbRoEMJwFlgFh9ASmAAoMBSoUQ3YYZGYQKSIBZhAJ0PYIAPYEACoAABQF6gAslAisoghuBgBMkhBeMAi50gAvdgABHAVmBTw4CLnKBCDoBQ4AXn4YcIYUAEoAeo4gDOAFThA1rggAeAUeBE3WAA+OBIL2AABKAGNiAAAiBABUBKYAXqoAiiRFCWVRFU19QRVJfRUxFTUVOVIgA3QF6hyxLgQPkgVv6gxBhgQxYAUeAJIaAEhEBKYEKWoEAq4AAboBOEIQACIIUXwQwOnItg121gA84iwAtgQDYgQAtggAIhwAtiBlwiAxXgxFSgCiThh1zAmk+gQjtgAS2gDV4gCI+gAA9gADVAXeADnKABCOBP9+BCnwBY4EBWwF1gkNugBMFgAEnA2UuWoAhowQudmU9gRNhgAAIghn1gBQhkhAJASuAEKGBPGkBOoBf34QAPYIIc4AAP4EQpqUAP4EE1wF1gATXgQqpAWiCAAiAQ0iGAOYBX5EBYYAE0oJZEoAKYAF0gAqzAXmBAAUBZIABuYIQ+4IJegFkgAVCggAJA3l0P4AVngI6LYET5oAaR4IJgAFkgQjAASuCHkqBCiuBAOuAKMGBDAWAAAeAIwABLYIFawFXgAwGgQ0TAWSEAAgBaIQACAF1gUVLgQBggAA3gCEqgQAMAiksggIIASyAG66DAXCAXEyBAW4BKYIU7YIn0wE9gQGvgAAWgwBlgQA1gAyYAXmCEU2BAAiAEv+DAAiCAGABPYAeYIUJNYEAgIEAFYQNLoADFIMDCoECHJEDIYEWQIEAMIIAoJEAIYEDQYJXt5IDOoMCn4UDM4APQIIA8oIBN4kAngQ7KTt9hgxDBHl0PFWBAXCBBnCDAPiDMs0BeIAO4YABooYBv4IAzYIA94AAooAAHYAQi4JX+wJ0LYACGgI+QoEAswJ0PYAOeoMDioABJ4I++4EAKwM9ciuABnaDADUBK4QAKYEACYABGgF4gSFKhAIJAXiBAoGEAFOBAA6HAEqDACiDAE2AAWyJB6IBeIICYoEI9YAc2oABu4QTUQEhgzIZgQBOAUOFA1YBIYAWYoBfRIAxR4APswI0MoAKyAIuT4AAcwI1N4UACgI2OYUACgI3M4UACgI5MYUACgIxMIYAFQIxMYYACwI2NoBV/YEAC4g1zYQFA4UiKIAf5ogiP4g1nokDHYMAqYIY9IISpIEz34Eo7gFygghBgAEjAXmFAR4BeYABGYQLhYIC/QFkgQEgAXCBOluACHADci5mgAH4gQEqAXCBASqCABCDAp4Ba4IAEIEAPwEtggAYAWqCAAiBA3WAAAuCMo0BZoEAbgFpij7MAUKJEBaEAUwCLlGAAC+BAAYCLkeDAqePBDKBAIuHJnsCaXSAUH2CAHGBY32DAAiJNbOLEHqDAGaAAdGCAdqAAbICPjWBXTGGFSqCJFQBLYAO9IEVQIEA/oAAHoECuwF3gACWgAAQAWOAABCAAZSACP2CAZ+AVCuSADqDBF6GR6SDABsBNYNDpoAAOwF3gBFQgAAFgQEhgAr1gACzggJjggGxgwQhhwA7ggAoAU2AACmDK7GFAFyBAI+AB2AEdCk8PYAAB4AHLJAAi4MAcIgAroQAyZEAJgE0gAWnhAAlgQAJggWtgQAQAT2AAowCKSyFAB6HAk8BOIBeLwIuX4BfYIBWJIEKIYMExwNuLnqBEDEDfHwygC4EAlN0gAZYgBs0gQAJAjE6ggCFgAAKBjI6MyxyfIFSJgE2gwD9ggUtgAASgGWSgQUjBTMxLXIlgGT2gALmgDpMggKLhAAkggASgQIHgRR3gDlEgQAPgxRggQAVg2fpgRG4hQC3ASyEAVCEAWKOAVCAALICNTeEANiCBJKDAmmAFpKAA0+AC4OAE6iCAAkDMTM5hAAKgANqAW6AApkBKYIADYABAIACpAFKgQDcAjApgQEOggKygADgggAOggQuggAUAWWBB5wBNIsAFAF0gQAUATiLABQBcoEAFIFhy4MAbIEDzoIAGAFugAEFggAShAAOhiYZjQAWgxbcjgAXgxbkhAAXATmGAYaNAasBNIAAuIwAegFpgRKdgAChgQFBggDJgxatiAAiAXOKAJwBc4cAnIMBKZEDwoEERoIBkIEAI4AgP4FQioABsAI2OYMOBYABiYIAUYUAjZ0ACKQA0YEAbaICFoIDMoIAVYEC7oJOIYEEkIoBB4YYzIEFPIBNTIMChYUBEQEtgQDXgxRtgQAhASuAa18CLm+AFHKECYeBAA2AACOAMVSBUo6AAJ+FARGDATKABNKBAECBCP2BABWCAC8BLIQFJ4IAGoEJA5wAw4ITF4AJzAF9lwBfgQHagw4vigBdgBbeggEoAjczgQMeAjczjwEIgwK+hgAJhk42hQQYggDagwmCggDAggDBggBBggBogAB4nAC9gBXkgC8UhABfgGOBgADygFdpggHIiRA3gAhlhQBRiQC5AjkxgQC5ATmACdCRALkBcoUAuQFy2wC5gBqUoAC5gwCygAf3gQCzgAAHkwC0AUeDAIWCAa6BAtoBb4EDU4sAi48AjIYDpoIFGoMAhYMFOoUEPIcE7oEAfqgFM4QGRIIHFgFugAmtggAJgACUggiphwYkgAEOhAOaAU2BBaiACaCCBkMBeoBYU4sgtAEhhBiagAMhhgc4gQDjggvbhAcNgAfQhAAdiBzRgyArggW5AWuDFgmCKnCCCsiBCkuCCsaAC/2DC9SACquGA7gBVIEBgIA/M4JSAIID2YYAV4BqbIIAUoALu4AvmogAcIMANAUwKT8/M4MKv4AQSaEAT4UgaII9F4ABBoIB5o4BBoMXPYkBCYILOIAleoIADYMBDIUAE4IHo4gBCYcBN4MMUogBFIEAFYELkoEUgoAM2IFfgYEOCYAMNYAHJ4MMK4ARp4ASqQIrK4ATdYsACIABdIEsUYABOwJJdIEDGYQCw5MALacACAJvPoEgQoEAnwNJdC2AFnyABOmBAA6BCoKDBi2AABqCAMyFAMcCPHiAAS6dAd2CHHCADeWEAAUBa4ED0oItL4EZxwNrdC2BK5OCADGAAFyAAB2CADWFAAuBASqACHv/Ah4DKTpigQQ5AVOAEo8BT4MEN4IfjoADOYBn3YACOYEJ5oMDq4ADbYIDHIAAGIEAHoYCDIMKO4IAJoIDs4AAJYIicoMf9oAAB4ABS4EMA4ITAoAyooQTVAFMhhMNhAAKgRNYhQwngFvjATWDDA+AFK6AB+qCTkyBB4CAAJKBABaAES6DDteBBA6CAHsBZIMH1gFogwAHgQEtgURBiwrejwRchAARgQrHgAkJgQqDAT6AFbaCBDaAEHiHCHmWBNOJABOKCQyEABSKCQmDAEoBaIcASgFojwBKggATjABKggAUhABKgAJ1iAqUhiRAkQqbgwD9gwDVggEkA1plPYAIBgFahwVtgQn9ASmAOviGDLgBRoUOeoIMqYQBMAEtgyPRgw54gmhpAU+GEdUBdIADHQE9gCt8AXSAD7wBPYAhioBBfYQACIA8cIIAGIApv4IACIAp34QtnYJXeIAp44IAF4Ap5YIAL4YfeIEiS4cfW4IADoYfPoIADgJRZYV2igF0gA2HggATgA3mgQAHgTzTgDTMgQK2Az8tM4AVOoYA2AFQiw2QghZaAXiDML2AA7yAJiICLmKBGa8DZS5fgCwlggAVAT6CEY2AEnuABLiCAAuAFY4BYYITBYAcXYEQo4AcWoIEGoAV9gF3hAAKgR7MAWiFAAyBZNmAHGCFAA6AJEmAAGSAK+gCLkGCHwqAIXKADHwBc4UEg4EAfIAEgIYSSIQRHAFygAA5gBvKgB+OhAAOgABVAiE9gHQlgwAQgAAMAXWGAByBABoCdymAMyEEdGludYNCloIlhIEjVIArToIAYIAA3QEyhB+VAT6AS9uEAJ0CbF2BAyGCAEUBbIAcHYBqooIEOYAeYAFugBlVgwYagCtfgQEpgAOMgBl3hBJGlgDshRGJgA2eAWGAEdIBY4Amv4AAboIZeYdydQFmggD8gAFigC/zAWaHAasBWIQBq4Qb94QYpoQGtYUYTIAR1oAGWoIDqoIR4QFigxPoggAKiCllgAKtgBYgBjM2MjQ0NIMq2IEflAEzgCf+giUSgTNDAj0xgQ2IgDNQhA6qhSHwiwbrhAAaATmDIRuFAA8BMYAa0YoAEAEziQA6gwhkgCyyBDI7SHSEJYOIAEyKAGaGM8eAL6uBA3kBLIIgu4AAKIABs4QACwFMgQUfiADcggBeghyDgQBPggAsgBykgAQ0hAAvgwA0ggAThABCAU6AAEKAcEOAB4iCdJOEFI+AGmMBR4EAjoIdCYAG3Yhq04EdqgMxNCuAZeCCMSuBKf2BTSKAADWAABoDMys3gG+JggM8gB6EhAAOgHGxgmcEggJQgSHMgBmXgBkNATqAAAaAEx4BNYAfC4AABwE0gBpOAT+JGoaAGy6CGreDBiKDGoqCGkgBTIBYCIAJiIQbGwE0gwAahgIZhQIVAWmCAQuDGWEBLYAqzgEsgAUOgxm3gAhyhQAMBW4tNCw0hFKXhCVzhxtwgAEBAWmCAQGAAGABO4Icv4IBVIEX2AEshAAPgAFQgABPglbuhQFsgB/bhAFjgAAKgBq1hAC1hAGPAUyBAceCJGQBLIAW+IIbWYQAPYQVboAUEAFogAT6gQXggggpgAa7ggSOgQW3gALKiBJOggfPh0gqgwMighADhhXaAXmAaHWBEAcBOoJDzoEaVQJEcoMeVIcZGwFXiwBHgAj/gDj9iDGPgAs1jiMvgQA0gQ49gSVoAUGBFL6CHb2EFVWGBK4BRIE2EoIlYgI0MoECB4QAkwE8gXXmgQAZggAOAS2AXbaFFj2AAPmADqOAFXmCAEiCKB2GAA6ACReCboWAI9uAAm2CLCCDF0eBB6aCeR+AAAaARCGHADEBKYQEkAJmPYEJIIATyYAHwIUAHYEBJwEsggJthAhFgCE6hjcZgGm7giLzhQAPgHEigAQTgScKhQASgDYLAX6JACKAGZcBfoIAI4UBpoEB3YBwxYIxeoAJFYEYy4IAeoIUwoAACIAUxYQB8oAA9IAItIQAFYAXl4UBJoMXxIAAC4EUzoMX14EACIAPTYAAL4EAWIcXqIsAWIIXqYQAToEApIQAToQAC4EAToAN8IQOBIAftoIJ2QFzgQqNggEZgEGagQG9gRyggAHZhBahAWSAC+2CURWCGGSBABqDANGHGI2CABSDGGKBJNcBY4IL5wFjhReWjxiIhAEShAL0gwCbghnmgAAIA3VlLYBObYEAxoELGoBXFIAANgErgQJzgQALgDdIgQAQhEthgicHhwiIgwA9ghl6iQCggwBcgQBmgQKsgQBXgwDEhgCPAX2GA2eHXcmCGBSEALaAF9iDANyAIOSCKNKAPTGAB/qCCouBAn+EBTSEAraCAGGAAA8BaIEDjYIC6YQBRYMAiwJ3ZYECyIEAH4IH94MGo4EZtIYBRK0BY4FHcYUA0JEBa4A7iIYDUoQDeIEDUIEDTo4Z7YER7oMBeYEa54QBeYEAC4UBeYMYm5ABHIoD6wFphgQjA2ksRIIriIYAR4MmZoUD8IADJQE9gE6eASiAdCuCDMaCB3CMAVGAL6EBboEGNQFygQBFgQYZgARwgwPTiQAmgQPfhwPXhBmXgDR0hgVIgQMPhQOggk8XhAHMgQHXgRUrhwTzAVKLBPOMEBmEGkiNDw+CGlqeDw6BaLiHDwuAAA+CHkaEAamDNayCAR0Dcjw9hRv4gg4XggqrgFOxgAArgg6IgCZbmw6HhhTEhAJ6AVeEDo0BboMOjYQBgoQAFo8OlYIPBwFJgAVTggDcgAAfjg6ogAAHhRvkggCAgwAQjBvGggA2ghvqgwOvgABrAS2BBiCFEQiIAP+JI4iBACmBD5uBACWCEhWrDxKCBLKBHD+CC6kBOoEACssPJIYCKgFq9AIqgQw2hQGNAXaBAAqEAcmAACyAAOyFAkgBYoEsZYERppkCUwEsgDYJgQAQgBvsgwmghQAggiDBgwBrgAFNgQIKggIVAWKCRfaALyiEFA6MAoiCHbSABv6CCI+CVNSCAeqEApyHCJmGAP2DGk2BAFCCKumIAC6KbCOFHZKAAquCAhmCAPmCAJ2KAtMBMYACPIQAGIoC1YAAD4EAXoAAB4AGMIACgYErboEG144BW4sCh4AA7YMCIoAAnoEBj4UBYoQAqKQCmIMCmQFnghCTkQEvgwBfgiBg4AK9gQoHAVaAGzcBNYA4boAJYYB+m4A8JYAMQYFJtgIscYAJYIgzCgIwLIACBIcAIYALaAFLgHnggwAzAXKACIkBTIYADgFugFn6AUuAXj6BO9eAREKADsYBTIQADgExgD5chEUWAU6ADsOAAF6EZo+AHKGGAEkBT5IAGoEAVQFOhQBHgESRAiw3gEX0gES2gUWagAAzhQBggUYBgEUagAAFgEStgwBqAVqDO7OBRQOAO8MCcXKAEWaBRkiBXS4BUY0AG4AmQoIAGQFZgFXoA3QoToADEwEkggAKAU+AAAoBR4oALQFFgGZ3ggArAUqNABeBPgoEOSw0OYBFrYEB0QFugQBAAUuBHteCAAoBTIAtb4YENIE1v4kLcQIlMoALcYABfQE2hwRXAW6UACOAJUGHRX2EACSJHk2CB4WAIymBDY2ACguBDYaACPqBC5qACiGAUjGBBxWBWW2BMduAQk+AUiWBMW2BAAuCauoBcoAQtANuLmGAbLmCQFaAgniAGkQBMYAPw4MADgF1ggAOgFu2gAfGggA1AXmAAAsBeIMACwFrgAALAUmDAAsBbYEeVgFygHHqAW+AfzKBIvaABPgBdoA8woEFD4ALOwE1gDIFAWeALeSDI+eADYkBQ4ADWgFTgAAEAXqAAASAgEwBO4CIu4MsoYB+rAI+Y4MFSoE3pIUZKIIFIoBVUAJhK4Eu/YAY2gU8PGMsY4Az2YIzO4AuzwVbYSZoXYQFgwF6gB/pAmhygCx0gA/UBHosYy2AAAWBABMBZIAByQM9PXqAU82AEJqAPI6AAkuFN/KBD/gCNiaAABuAAAkBQ4IAGQMseiaBPEuAABOCAJYBepEAlQF7gBRzgEGTATaAApyDAEiAOwmPAKEEQys9YYAU/QM8PHqBAUqIAJWDM/aTAPCjAFuDAPwBd4AA/AFknwD8hgDhAVPMAOEBU5YA4YMEogFDgAJpA28tYoEEoQNTPnWFGaADUy11g4jngFG/AW2FRSyFdOEBZIBLa4FHmIB+KwNvIGaBKRiBStSAFMGEAI8BOYYAj4MHRgFrggC7A0E9cIAjrYAsK4ADIok3DIFFMoAF/AEphAH4A2xbQYAAB4FNuYITH4AARYkALQFykgAtgl1LAUGAAMcBU4YhCAJyPoAAdoAAcwMray2DbOeAJAkBLYIlUIA1WbUAgoESlQFlgBIigHLRjAAtgABYgQbVgQMugCMxgAB7iQBgAWuVALUBa4QAtYIAtoMBJIAAr94BJIICUwJ0PoA6CYQAIwFzggAjgHlXlwAOgYcWATuCFQGLABcBPoE6fooAFIAHsYIAz4EAZoIAcNoAa4YEIgI2NIEDQZQCqYFBWJICoYEDoIEDcAIrKIcDJYBF5YwAVoAACQIzMoEACYQAQgMxOTGGAEKLAHIBbIJrDQJsL4MDo5kAeAF1kQB4hAjrAWeBDpADdj5vgyqrA189Y4ANwQE7gC0BAV+BA7kBX4B5foBdcYIGAgFjgQPUgQZggg4cAXCAM/+AAAcDd2U9gABBCT9nLWkrNTo1LYAtOgFnggl2gBePBT5vP3YtgEfQAjU3gCuXATeBG2IBdoEYeYA3jIEEGYEZkYA4BIAAbokrVQFmiQbWgTHQgFleAT+AB+ICNjqAAAUBNI1GwoAJNIJGwQJ5coAirwExgEy2A2tyOoBsM4JGygFtggALAmJygUYvgQAFAWeBAAUBQ4EABYBLGYAYZQFTggALgQAFgI9EgDGSgY+3AWGBAAUBY4EADwF1gQAFAUGBAAUBX4EABQFJgQAFAVWBAAUBQoEAIwFIgIkChUb/gACEAUaGAA+BQZCAj6eFRY8BboRA+IEJjYdFjQFzgJBPAyksWIEATgF3gAClgEZPgQALAUSBAAUCV3KAE3uIOcSAAQ6BA+SCHlSAL5WEAP8CZHKAAPQBaIAAK4AV14BEt4g5moEAMIB7RocAKIAJi4AAKYBMZIAAXolL54AAKYYs6IIagYGDbgE0gGLdhRp6gjzJgQAPhBp2gok9hRpwg0u4A249e4AAsIABZQdNcjpacixSgE/OCXIsanI6R3IsVoAAdIGQ/wE6gE5iAXGAAAaAFX8BS4EA4ARMcjo1gE5KAU6CADcBT4EA/YBLxoQASIBHRANyOlGCAEgBJIIASAFKggBIAXSCAEiAQ9uCAEiAf/0BcoArJYMASQE0ggBJgG6ggQBPiUu7ggJFhV4NgRgdgwJRgYRFAWOAYDSEesOAY/oOayxtLGIsdixnLEMsUyyEj9aGQ5mBJduJAA0IVT1zP3VuOmOEir+BPkuADT2DhA8BeICDsIQ0e4MypYMypAJ4W4AynQFdgUYTgQAaAXeAj2GAASqAfJYDNTt1gBhlgg4IAXiAhFwCO3WBF2OAA/oCdz6BZVUCdz2AYmuAABsBdYULvwNVLk+AKoUCQz2AAeGBP3aAAEWBeLUBQ4MACoAUfgFDgGL3gArzgA37ASmAAR6CAGwBY4A1AQJ1PoA2D4IAY4F9boAAj4MAGgE+gTZLAnc9gG5/AXCAADOBhNWHAMiAAIQBcIE5OgMscC2AADcBbIAwzQI+cIUb8oKACQFwghw3gQ3JgH2xgBpqhhwQgwB3AUmBAI+BNOGCAFWDAFQCSVuAiPECXT2AAAcCXSuBAFSOASaBEfSAASeBGBkCW0mFATIDXT1hgGTxAndphFKDAmNhgTOZAzp6PYAF5wQsXz1VgAt2gwThATuCABoBMYAAGgJVLoAxLAFBgAAHgDDegQAiAXGFACKAW7wBYYFVYIEAI4AwNoEAIwFWgwAjAktygQV5AWuAALKAAJCAALYBY4AKiwFmgQGkAWiAe7qAOAiACrqAAm4BeYFLQwF3gAq3AXmBjjiAAPuBIvkHLk5yP3k+PYACowR5PlZygCnAgRp3iAAZAlUugAKlAnk+gQAHhh5khxAfBEM9aG6ANkKAdFqAAouAT62CAnsDVS5XgAw0AW2BAG4DbC1kgAtDgAAJAWiAC6cBYoEOswRiLT1thAhdASiAfAsEZCkrYoAl14ACAAJTK4AtGoEFFAFDhQXTgAFQAWKDAeyEAEwHMTtrJm07KYB8xYOBzoAAIQdtPyhrJj1tgADRBmsrPW0pOoIBBIAO1IAB2gItLYEBpoM1QIEChYMBRYA5TAJbb4EBm4EBMgFsggJEB2smZykhPXaDCD+AADmAhtSAY7YBd4AFloJ75gFogAFGgQDIgAJmgAANgAKOAmgrgQAiggJagAALgCSTgThBAilogAB2ggJ0gQCaAXmEADq7AWYCdj2AAJuDAx6BAc4CK3aAASGABQ6AAJGBlTCABQ0CUy2BABiDD5uAAQ0Ba4I4toIDYIAAsQEpgTf7AWuAAaWCANeAHWqHAOuCAOGBAikBd4kCKQFDgAtoAT2AclyEAY+DAZ+FAZSFAdCKAYSTAYGFD6WCALSAfc2CA9UBd4Agkoc9Wo4E24BiPoIE3QFhgmOPgEYJgD2PAXOARguAOKoEMTxzKYBgGgFugA9SgDGSgJEIhmv0hgArAT6DACuBHb6BABSCEgWARQSEMaiAABqBDbGAeTmAAEWBPGqCAEiBO/6ECXeDACiDAEuCAEkCLXOWAC2AN72BWZOBHbaAVywCcjqAVGKHBpuAWZSAAC6GHGYBYYIGYgFkgAYaAVGCBeIBWYYHUwI1NIAbsAMkcjqACBsBR4EABgN9LHChACaHBh0BeYIG+4MdLYQvLoFlxIIucYAPQoBqyIkvPQF0gAOSgSKwgQmGgGVfAXmAIueBAAaABxaACWGAAo4BIYcAIQE4gC27igAhATGBjeWJUTWHAHqBE7IGcj9wbjpkgBnTAz17WoEBA4Nt7AFRiTckhDrKgUnPATSAR/KBPIOAI5eBBRuEQtWDSAqIABiDSciASZ+Ai36JABiDHuiAABgBOJEASIULzYABN4ZTtAFZgExygAr7gAisgIN5gQAPgCFLgBEYAW+AEGQBOYSNJ4EAuAFvgFvNggAJAWmBXSiEAMqCBuyABquACgkBSIARe4BWoYECqYA3twFygATvgQD7gRgSggM+gXdqgAAHgD2VgANBgQAKgQDuATOAKF6JAKWARwiAAASDOgCCACUBY4UAewF1hAB7gC+sgAMqAmEsgAB1gjysgRGRggfrggB0gQBggQB0AnQugBHPgFYPghJmgGnQgQFugYoTgB6sgSLAgAh2gBEwA3I9OYAABwFhgQARgAjJgArvAnI9gRzngACggQBkggKYAm1ug1R4hmG0AllljGu+g2GfAiJOgUxsgpCCglvNgGKPiAKJAWKLEcGHA9CTCKaFSQSAWKGBBSeBAkyAAn+BEdqCAAcBY44vVYAjoYE7sIMG2IER7YFUQIAK+YAe7YABfoAACYEdtoMw64AQEYAC4IExIQF5gkWUhQx5gBPGAXqAUBUBdYAbhgF3gCH4AW2BDh2HZi+EB5yBAC6EB5+CAwYBOoMPiIABLoEKY4YAS4cRXwFJgglNATKAMVqBL9wEMzU2MYCByAFhgoGOAXKAL8mCAIEBX4AKyIASHARyLmdyhC8KggALAUOAABsBZ4ALqAMpLF+Bi1WEAF0BOIQNIYIXN4IqsIIABwEugBOmgR+sASGBIcmBAI6AGmgCKFWAbAaACsyALvGADIUDOCkpgC/hhw3JgGHeAXKAm8qAdj6BZy4BIIJ1lgEihQBnhg1SgQBngIkBAVWAAYuFADuAXl2CXJmIYFaAThEDdGhvgE5TkQA/AUKAADyAEzSBAEMBK4AUmIsA+QFrgAAbAj4xgDIMAms+gQAQjQ5oAndpgItBgGsYgWTgjwBdgJAsglQbAWuBWQqDGESAK1+CAT2ANyyCAUiAADKAS9oDJmE/gQE7ATmBDToCOTGBAVCKCU+BAVaBAcqDAa2CAEwCYSyAAPaCDC6BAA+2APwFNTczNDSDAEOMAEKEAXeAZwcBZ4GCbAF0kgDfiAHfgCRIgQyvgAHjgQDQgQBSgB2QhAJXggIphwIwjAIxATKHAOYDMjpJgA3GgQAchwBaAW6AAO2XAFUBU5QAVQEzhwBVATOAAFWDATiHAFWAFhWBATwBYYIAFYAw0oIAva8AuwE0hwBmATSCOw2CAD4BP4YBqQFTgQGpiQB4AXOaAM2LAGeAZaqJALIBcoAEJ4gAewE1hwB7ATWBAhyGAH6AADEBaIACZAFTgAkOAT6BICmAh5uAkZKEAEeENUOBMbSCAAkBdIEhHAFrgAAvggCcAS2BADcBKYB0d4QAGoAe9oQAL4AE94EFFYBSfpUAvIAEGYIAvYB2UoUYsYFmhYAAMoFs2oAg1QFogR8cAWiCARWAAA2DAR6GCiYBdoFrDoEBL4AFBoUA4gE2hwDiATaBAOKBXXeEAquDBNYBc4kAPoAoeoELmYAW/IAVBoAKxoAI8ocA8AFygADNgQBfgwDbgQAOgwDZgDBLgQAXgQbYAWuFGm4Ba4BtbQE+g3GpvQDsAWuIAKGDCXeJAdIBdIIB0o4A9wE3hwD3ATeBAPeBPT+0APcBbooA94EADoMAeoAwifcA9wFyhQD3hADwATiHAPABOIEA8IUAfoIA74MDSYUAhwFhgATzgytAgQCIhgT1hQYiA3JjIIChkwFtgVvnkASugANSigSyAUeBOHgBYoAkKgI5JoCcrYQGo4J254UFpIUG7IsT+ocArwE5hASuhwAygBHLjAcPATmAbCOEADABOYIHjgQhci5thi2aAUGAACqBk9mQBhaDAHKGADyCBgCAB5uACxCANzOGHEuBAgOGACQBMoEAJANyLmuAATsBSIcAgwMyMDaEAQKECCSAALWBAB0Ba4AJbwIhVYEQwwFCgQAFAlUogEMUhQ/ZhgCCATOLD9eBD5+ATf+IAKOAYgmIAI8BQoAARQEsgQCUiAA2ATKHAE6EAImDABgBM4A7m4kHS4ONOYFjp4kBvYCYroAcsIsBeQI5M4EAiYEA44MBgIQCFAFhgA4UgQhJgAvvgo5fgC2KjAeuAXOAChGACgWDAGqDFamAalKRBxiCA5WEAFeLAdCAYjqVAYABNIcA6ocFngE5ggWehQWSggLViQWYgSt2gAALgA6wgAPahqBNgQBXgAV9gQqEhAV3hwNeAWyBAAoBZogFS4YHjpQCqAE5ggU+gANKgAjngAjEAXKACOoCNSmBFgqAAfmCCdcBSYQAE4BX1oMAEQFBgQARgAkOATSAABGEADUEPjI4NoAK3AFygg1igQAzAT6AVkmDAV+BABQCPyKBGhIEbWFueYQBWIBxxIwAEgEggF9phheXBnN5bWJvbJEBfQNyLlWJBQ8BOYcFDwM5NzqDT5CAACKABNIEQXI7KYQCy4AMnIAqIIEAGIAE0wFdgAC8gAAWAUKAAAWDDWgCMTmACbsBVYAALo4AKYAS9QIuQoEMTAFQgTwxgAx4AXKBDGyBABSBe2kBcoANqYEMEIMM2IEAFgF9gAv6gwAMAWOAAAwBRogOLICN4oIP2oEM7oAVHwF1gBTJAXKBDO4BRoAAB4EM7oIAaAF1gQ0vggBZAWKBAAqOG16BGDSFApeWCXOLAR6HBT0COTiKAR4CX3KAbmEBSYAA9YMMIQFwgXdrA3JbVYAC2YAeSIAR7YARJYEcWgF4g3JEgFOGAXCAGJQCKUKAmWcBaIIAr4ABKoQBJwE9gQAahnNEgVDEggArgwWegQAvgYrzhQA5ggs+AVWGCk2GA9yBaiaDAgYFcmVwZWGRANuBCIaEAHaBLqwEaD0zK4EElIAAW4CAYYIGRgExgDuXgQB8gQlgggB5ggHngwB5gRMygwAzhAH8gTGGgwAmgB7kiwAmAjExgAAnggAWgEfVg3+9gADqAWiBC+GDATaxAL+CAWcBaIAjKYMCZ4UBPYBWtoIBNoAAKYMN04dB34IBLIAAK4AQOIAT4JACCwItLYEG0AFzgIbDgVsQBC1vZi2CBLqSAheHAseBDzWCArgBUIgCuICk0oYCuICiIIMCuIICtYEG/IACtYEA/AQsUCxYgwK3AVSJArcBUIYCtwFYgAAKggBbAUSAlyOAAAuCATuCAzcBQoVwYIAZPIAVNY0Az4sbHZcC3YAP4AE2ggBhAVeCARuIex+BAJ+HAaCAmU2HANwBUoQADAF1gAAMAWqCAAwBRIcDlAMyLFeCBOIELE0sUoMA3AFqiQDcAU2DANyAAHgBUoMACoQEAIQAzpEAzIUExJUAxoIBFZIHHooGLQE5hQYtgR/FhAAWgAALhAgjgQVmgExKATaALpeAMoaAWy0Be4EIK4IiZ4AV0oEQCI0QJgFUgg9giAKNggATgDn0mwP6AXCAIIOBfjGAor4BJoEADIAHNIEAPQN5PXCFADoBeYIcrQNVKHmBA0wBeYEAIwI+PoEADIAATIIAE4kAUQFCggAmgQFcAVSBFTSAAAyDD2GFBFaBABaBAAyDDRuBA8yBBDKCAHiFEJ4DMjA1hwFJgB18hQAdggDgjgmNhB2qgwAloB2RkAJ0gA1ZggEFgAEhgAbIAzMxOoMQ7IQAKIYJg4AAC4ABsoI+7QFJgXVDggDQgAtEgAZugwAOAUKGABaBAOaFAAyAL+SCB/qGAFGGDu6AAAuDBbKBAWiAV8qBAEiAI9aOAaKWAZyAADTSAZyUAVCMH1OQAUoBeoQB04IBVICi3IEARocAKIYPkoAAC48BSgF6ngFKhABHhg9zgAALhBLeAWyJA2GCCW0Cdy2AU3mAAFSADNGCCXGAAEUDenItgBhygAXkgUXwgXkQpCLcjgDogQBEAUmAOHoBaIAhV4AACYAamYAIjAVlLWgpOoEACgFJgAAKggBnAVOHD4mJCeeKFeMBaIQhsIGZcoNnt4Eoi4AZjIBPO4AABAFkgxfYAWSAf6OBAMCABrqED9efAE0Bb4kARogKZYIKPYQKOIMHrYIAqIcEi4wLbIADjpEBZYAAZIMlqoAAjwFsgUp8jCSQhwA/ggp8gxR/gggxgQuwAnctgBTAgzD/AXeAADsBQ4AB5QF3hg3kAXeFF5aAFhyFBf4DZi13gDIViA0oAWeDDokBdIAFDYECxYEVEIgOq4ARggJhOoINi4Eg0IAMFoIOLo4UWYJiP5UUV4MOLoQAFYYKhIAAC4UA0IECRYYOpYEA1okOpYiEgIEA4IgMiYUAfYUElqEAf4YJ5YAACwE6hAGGgBrIgg1phgAagAZQhQAagFCCiQAbATGADdCDFoUBNIYdfYUWloh8CYAAyYpteQJtbokB8oR9OYhpNoAXWoAAM4EGl4EDAAN8fHeBFvGBPGaCAI6AAwKEBpmABVWCALqCABKAFOGAAhSCAAuAFgKCRpyEAe8Bd4IonoI82oMbVoZUToIXFoMFCoEpNYIXW4EACYQnDoEwsYE644QXk4IpHoAVqYAQpoF6nIcch4MCx4EpMIEr+4AAB4EVmoEAK4AAKgFJgSHagSlAgj3zgAAWgDEbhVzVgQPdgQAigCYAgm6dhDRDginAgQAYgW5qhWIbgn0bgBs9gEoRAT+DQ8aCMjSKACKCQpuAAHGBEUiAAHGCAGwBOoAAKgFJgAMPhACMhwCmgQCZgQAwgDHmhgAUgUqNgXwXggsUkgBlgQArgAA1gjHgiADcgQASijjGgS07iINYgSRIAS2BLbABcIFy8oYBO4UCiIBwrQEthqUBAXWBLcmANKOAA8yBAbiAADWBTYeBGeSUA9eCLsqMA8CQAH8Bd4QAfwF3gy7ugQAwgDLJghDWAT+AgkuBR0WICPoBP4ArhoYAFIQLYYAhCoEPjIQAIYALXYE3hYEB+4AhzYAABoAAiYAABgFtgzLjgwAMgS+GgAM2gAf3AW2IUIKCAoaHW36CBFeBRq+CABYBOoRiTYBgbodQhIosKAFigSIVg2zdAWKCmsCGbVuCAEUBYoAth4slbgFTpAA/AWKBqDSHXuuAABCANxSHXuyFAF8BNIwAX4AKNINBuYMsi4AskoE9RoABuoEDYIAsmYQsroEsoIAB1wFhgQ3HgVmlgQF/iFA/gABFgQBDgiZugCZ1gTPTgCZegQXOAWOBb72GJpGAJoqBhkGBJl+BC2mAJluIT56AAEWBGwmAGwWITVGDBE+CFN+HflAEbW47c4AGX4Aq3IIY64FkDoAaMYB3j4AgpoIq0YAARoIrcYZNBYVeMYADroMI+IhM+YhSd4MnfAFlgCdFiEx2gQAgggBWgAD5gALXiEwsgQCygQAZAjcmgCtcAS2BAAeIJcABdoglwIMe0gI/LYA0xIIcngJnboN+JQIsQ4Qcp4txH4ADV4AmUQFngAJmgnD3AWaBsI6DcQIBc4ABl4xr4IQ+KYA7ZoAVPoEeF4MAM4Rx0YRRNYAEGIImeYEAVIcqvYUAK4ZmwoAyyoAcP4GjLYMAYIQAIYFqpYMN1YIAKYABCoYwtIQAQoSsXoRer4QAHYVzn4FjewJsZYAGd4EBEYsAdAE8hADWgDxZiQC3gXbJhx2GAVOIH5WBAFQCQ26AB1oBLIAAy4FHiYGPLYcvlYIAYoF45YB8DYUAc4aCbIgAlwFagHeUhZAaiY/NgoSZgg1shyAGgAgzgzcRAWOAibOFW6SAALKBAAaIApUCWWWBgiCBmDYBYYAXOQJkOoByP4EhLQE9gXPqgCgxgx+PgAkbgQNNhF5fAnM8gHn3g2BehQFyhAHOhQAYgDlnhG+bgKM4iIjrgDy2gTCwgABFAWaBA2MBbIB9SYADY4A7JIEDY4WZCQE7gQAOgVQIhQHOAS6AAgSBOAaANQOCHiSBA7OAN4GBA7OBADuAA7OGjluFB2MBdYAiKIKJ04YAG4AjloMHkQFzgAlFhAcOgCgqgCHiAndugAvBiYnvgAGhgwGGgoF5AXuBrXiAACyBQfGFAZ6ACQSAAeqAAJKAHvCJhzGGAWWAJr+NAWUDcHJvgA9ngB/agnieggFnAX2AgfiAqXqAeaaAWliBtMABfYBYdoAkO4SA0oN2+oAB1IMCAoR2+IEBjIYl7IoBIgFmhQEiAW+DASIBb4MBIgFvlQEiAW+BPqGIASKBACnLASKAAJKAWjiMASKBSriIEjiPASqCARYCaXqCkiCSAS+AP/KDAS+DAp6AB66AAM2FAuOAOX+BAAaMAFSAEnOIAuIBZoKCEocGToG7hqADZ4IG04MDqIaE0gIud4AER4SlX4cAooF/1oMBCYF/LoWEKYEAdYEFSAFBkwU/hoXFhyynhQCjkwAeg47RgXoegA/piohmgQAUAy0xNYAP/oEs5wQmJiJugrxAh7MtgQlegI7wgH3Ug474gAVGhAEBgAS3A3thboIB2YluF4F4coizsoAFlIJopoJtlQMsY26BiiSECuuAPMSAXyMBNYADsYBE3YBg6YUARAFmgyeHASGIIkaBC6aCDEsBIoA2DoNHaoBemoAVeQE+g6/ygSJIgADHgAAOhgAzAW6ARlOElASAIMqAADEBZoBgRIBbEIAbWoIV/AE+gANMA2k+OYCp2oANKoAABoGwK4EAKoJTAIFTCoAAGwIwPoA8GQNvPjSCqf+DA64BZocAYoMAFIAlHYBvPoEAuAFzgwDrhQD9AXOBPaqAAQCABM2AA4qAB16Ao20CZT2ANoqAJG+BCEQBc4hGMQFzgSF1AW6AAAeDC6CBAA+AAA0BWYAAPYELiIBBxQIuJIAIYoB1dAFzgFkqgwAiASSBACKAfHCBABKCACKAfG+AoJoCJGWGdXiAABSHDCECMiqBAEuAA8eBRxCELFGFABKARxqGABIBR4IAEoEME4AAB4B8Q4AAbANpKzaAAAyEg6eBI/+AAEsBboFD9YA9XQE9gwANggBrgBO8gABdgQAGAXKCAAYBUoAQL4B5M4CqkoFUoocF3YQAPYBHFQFzgVSvhABAA05lPYBD0IEADYEjMYABM4FF2IAAV4FikIB5OYAct4BabIZupYhEb4QBb4JIGYEIg4E+zIE+EgFrg2flgwI2ggtVgLcFgyRsAXSBTtSER6CBR6yAAkgBdIMPR4EABwI9LYEABoElnIABsIAp7IEADgE/gDBCgAG7ggvMhQATgh0pgQsTgkg4gEm6gHYwhZsUgUNsgTr1hkg+AT6AZbOKlROAY6KEcL2DRXWDdKSEPKUBS4B+fIdrnY4AL4MIRoEAMYRMGQFMggBthkidgBU9g3XBiQBCgwAThgBGgmgVigB1AUyOAHWOADOOAHkBcYI724ZJCIEAeYJ1/4sARoEAE4YARoJoY4oAeYByXI4AeYwAM4kAeYFE5oNrdoFAn4BE1IR1b4BFlYBLtYFfUYBzm4BzfYINTIBx7IYAK4BFK4QAKwFOgW9IgA4+AVCGACiAcgqGACgBcYAM4oh1woBFfoFz3IFhDIAAKYhqPIAAB4A/voALjYRFRIKYfYJGjIYOcIMErIECFYFBhIABHoJBJ4JdVIAAPoB0YYBM5YFINANdLlqCQh6IABEBUYEAEYB0jYYAEQFZgQARgHSZhgARASSDTbyCAImCTGCBPGuCAAeCTZSETj6APaeEPDGEPEKAPySCDwiAAwqFRzyBYZGETUuDAzOAfDwBLYAH9YJLd4APAIAAIYAPBYEPPIBV+IAozYAmMYAnlAJuOoAZQwRobjpGgY8Iggb1g78fhYXugAgyhQALgwvfhYbCgAAZhQALioU2gQdggQcIAV+cBviFCr2BK82HABWGBB2hBu+RBsaHBF+JBsWAusiABa+BlM8BIYAGk4IBMYyPuYFbCoQG24cHiIgpWI0GzoQElYRLCoAAVoFeEgFXgGewhAhagQBugl5rgUMggXY3gAbqggZLgVZbggZLgjViAW6DEmWBISaDNHuIosqGKdKGKaqKB02EO6yCAEKDAGKBmzSAbKmAAAYBNYEFDoIHVoCLZ4UZxoAAN4EdgoAAK4BEq4Ii3AQ9NSsogA+AgAIlASGBAEeAIzaAb8+BALCBOcmHAT2AABKAABiBB1ABaYMFnogSxIExx4ESi4NPUYISz4El7YJOEIESKIAHFIBDn44F6oYObYUtMYC7nYMFz4IGt4C68oEAB6AAOIcGKYAB5IMoqYMGLoQGDYNZQ4CMK4MGDoABc4Eta4oBcwF0giJRgL6XgCLfgwAIgCimgANtgLJwhAAugg8JhHung4TtgAJSgIR9gE55gwCuggRKgAVBgQAwgBzLgIsuhgAKgBurhAAKAXeAAF6BACaDGhCEBGaIAAaBVrQBcoMDhIEDmAFigKmuA246doB0M4MEj4sDl4eRqIwDl4eQopEDlwE7jIszAT2DBNeAlkgBQYERBICr7AFfgIlZAyk7Cg==");if(g){const A=atob(I),g=new Blob([A],{type:B});return URL.createObjectURL(g)}return"data:"+B+";base64,"+I}})}export{g as configureWebWorker};
+const r=[3,4,5,6,7,8,9,10,11,13,15,17,19,23,27,31,35,43,51,59,67,83,99,115,131,163,195,227,258],t=[0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0],o=[1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193,257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577],e=[0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13],a=[16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15],h=new Uint8Array(288);h.fill(8,0,144),h.fill(9,144,256),h.fill(7,256,280),h.fill(8,280,288);const l=new Uint8Array(30).fill(5);function n(r){const t=new Uint16Array(16);for(const o of r)t[o]++;t[0]=0;const o=new Uint16Array(17);for(let r=1;15>=r;r++)o[r+1]=o[r]+t[r];const e=new Uint16Array(r.length);for(let t=0;t<r.length;t++)r[t]&&(e[o[r[t]]++]=t);return{t:t,symbols:e}}const s="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";function f(f){f({workerURI:f=>{const q="text/javascript",P=(s=>{let f=0,q=0,P=0,V=new Uint8Array(1024),d=0,u=0;for(;!u;){u=H(1);const r=H(2);if(0==r)K();else if(1==r)X(n(h),n(l));else{if(2!=r)throw Error("invalid deflate block type");X(...i())}}return V.subarray(0,d);function G(){if(f>=s.length)throw Error("unexpected end of deflate data");return s[f++]}function H(r){for(;r>P;)q|=G()<<P,P+=8;const t=q&(1<<r)-1;return q>>>=r,P-=r,t}function K(){q=0,P=0;const r=G()|G()<<8;f+=2,y(d+r);for(let t=0;r>t;t++)V[d++]=G()}function X(a,h){let l=b(a);for(;256!=l;){if(256>l)y(d+1),V[d++]=l;else{const a=l-257,n=r[a]+H(t[a]),s=b(h),f=o[s]+H(e[s]);y(d+n);const q=d-f;for(let r=0;n>r;r++)V[d++]=V[q+r]}l=b(a)}}function i(){const r=H(5)+257,t=H(5)+1,o=H(4)+4,e=new Uint8Array(19);for(let r=0;o>r;r++)e[a[r]]=H(3);const h=n(e),l=new Uint8Array(r+t);let s=0;for(;s<l.length;){const r=b(h);if(16>r)l[s++]=r;else if(16==r){const r=l[s-1];let t=H(2)+3;for(;t--;)l[s++]=r}else s+=17==r?H(3)+3:H(7)+11}return[n(l.subarray(0,r)),n(l.subarray(r))]}function b(r){const{t:t,symbols:o}=r;let e=0,a=0,h=0;for(let r=1;15>=r;r++){e|=H(1);const l=t[r];if(l>e-a)return o[h+(e-a)];h+=l,a=a+l<<1,e<<=1}throw Error("invalid huffman code")}function y(r){if(V.length<r){let t=2*V.length;for(;r>t;)t*=2;const o=new Uint8Array(t);o.set(V.subarray(0,d)),V=o}}})((r=>{const t=(r=(r+"").replace(/[^A-Za-z0-9+/=]/g,"")).length,o=[];for(let e=0;t>e;e+=4){const t=s.indexOf(r[e])<<18|s.indexOf(r[e+1])<<12|(63&s.indexOf(r[e+2]))<<6|63&s.indexOf(r[e+3]);o.push(t>>16&255),"="!==r[e+2]&&o.push(t>>8&255),"="!==r[e+3]&&o.push(255&t)}return new Uint8Array(o)})("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"));if(f){const r=new Blob([P],{type:q});return URL.createObjectURL(r)}return"data:"+q+";base64,"+(r=>{let t="";const o=r.length;let e=0;for(;o>e+2;e+=3){const o=r[e]<<16|r[e+1]<<8|r[e+2];t+=s[o>>18&63]+s[o>>12&63]+s[o>>6&63]+s[63&o]}const a=o-e;if(1===a){const o=r[e]<<16;t+=s[o>>18&63]+s[o>>12&63]+"=="}else if(2===a){const o=r[e]<<16|r[e+1]<<8;t+=s[o>>18&63]+s[o>>12&63]+s[o>>6&63]+"="}return t})(P)}})}export{f as configureWebWorker};