From 3b5e2b92e8875102b00f3e4f291a2fcd145ed494 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Wed, 16 Jul 2025 16:18:40 +0200 Subject: [PATCH 01/43] createXorbs also outputs file hash, sha256 and representation --- packages/hub/src/utils/createXorbs.ts | 60 +++++++++++++++++-- .../hub/src/vendor/xet-chunk/chunker_wasm.ts | 2 +- .../src/vendor/xet-chunk/chunker_wasm_bg.d.ts | 3 +- 3 files changed, 58 insertions(+), 7 deletions(-) diff --git a/packages/hub/src/utils/createXorbs.ts b/packages/hub/src/utils/createXorbs.ts index e239dc0f0a..66b8b8b6a6 100644 --- a/packages/hub/src/utils/createXorbs.ts +++ b/packages/hub/src/utils/createXorbs.ts @@ -13,10 +13,22 @@ const MAX_CHUNK_SIZE = 2 * TARGET_CHUNK_SIZE; const XORB_SIZE = 64 * 1024 * 1024; const MAX_XORB_CHUNKS = 8 * 1024; -export async function* createXorbs( - fileSource: Blob -): AsyncGenerator<{ xorb: Uint8Array; hash: string }, void, undefined> { +export async function* createXorbs(fileSource: Blob): AsyncGenerator< + | { type: "xorb"; xorb: Uint8Array; hash: string; id: number } + | { + type: "file"; + hash: string; + chunkHashes: string[]; + sha256: string; + representation: Array<{ xorbId: number; offset: number; length: number }>; + }, + void, + undefined +> { const chunkModule = await import("../vendor/xet-chunk/chunker_wasm"); + const sha256Module = await import("../vendor/hash-wasm/sha256-wrapper"); + let xorbId = 0; + await chunkModule.init(); const chunker = new chunkModule.Chunker(TARGET_CHUNK_SIZE); @@ -27,9 +39,15 @@ export async function* createXorbs( const reader = fileSource.stream().getReader(); let xorbOffset = 0; let xorbChunks = Array<{ hash: string; length: number }>(); + const fileChunks: Array<{ hash: string; length: number }> = []; + const fileRepresentation: Array<{ xorbId: number; offset: number; length: number }> = []; + + const sha256 = await sha256Module.createSHA256(); + sha256.init(); const addChunks = function* (chunks: Array<{ hash: string; length: number }>) { for (const chunk of chunks) { + fileChunks.push({ hash: chunk.hash, length: chunk.length }); let chunkToCopy: Uint8Array; if (chunk.length === sourceChunks[0].length) { chunkToCopy = sourceChunks[0]; @@ -51,7 +69,13 @@ export async function* createXorbs( xorbOffset = writeChunk(xorb, xorbOffset, chunkToCopy); if (xorbOffset === 0) { // Failure to write chunk, maybe because it went over xorb size limit - yield { xorb: xorb.subarray(0, xorbOffset), hash: "" }; + yield { + type: "xorb" as const, + xorb: xorb.subarray(0, xorbOffset), + hash: chunkModule.compute_xorb_hash(xorbChunks), + id: xorbId, + }; + xorbId++; xorb = new Uint8Array(XORB_SIZE); xorbOffset = writeChunk(xorb, 0, chunkToCopy); @@ -59,9 +83,26 @@ export async function* createXorbs( throw new Error("Failed to write chunk into xorb"); } } + const lastRep = fileRepresentation.at(-1); + + if (!lastRep) { + fileRepresentation.push({ xorbId, offset: 0, length: xorbOffset }); + } else { + if (lastRep.xorbId === xorbId) { + lastRep.length = xorbOffset - lastRep.offset; + } else { + fileRepresentation.push({ xorbId, offset: 0, length: xorbOffset }); + } + } xorbChunks.push(chunk); if (xorbChunks.length >= MAX_XORB_CHUNKS) { - yield { xorb: xorb.subarray(0, xorbOffset), hash: chunkModule.compute_xorb_hash(xorbChunks) }; + yield { + type: "xorb" as const, + xorb: xorb.subarray(0, xorbOffset), + hash: chunkModule.compute_xorb_hash(xorbChunks), + id: xorbId, + }; + xorbId++; xorbOffset = 0; xorbChunks = []; xorb = new Uint8Array(XORB_SIZE); @@ -76,8 +117,17 @@ export async function* createXorbs( break; } sourceChunks.push(value); + sha256.update(value); yield* addChunks(chunker.add_data(value)); } + + yield { + type: "file" as const, + hash: chunkModule.compute_file_hash(fileChunks), + chunkHashes: fileChunks.map((x) => x.hash), + sha256: sha256.digest("hex"), + representation: fileRepresentation, + }; } finally { chunker.free(); // ^ is this really needed ? diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts b/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts index 2446dd4574..708985b4d7 100644 --- a/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts @@ -55,7 +55,7 @@ init(); export { init }; -export { compute_xorb_hash, Chunker } from "./chunker_wasm_bg.js"; +export { compute_xorb_hash, compute_file_hash, Chunker } from "./chunker_wasm_bg.js"; // const exports = WebAssembly.Module.exports(wasmModule).map((item) => item.name); diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts index 3ec1cf3934..366fcf1779 100644 --- a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts @@ -1,6 +1,7 @@ /* tslint:disable */ /* eslint-disable */ -export function compute_xorb_hash(chunks_array: any): string; +export function compute_xorb_hash(chunks_array: Array<{ hash: string; length: number }>): string; +export function compute_file_hash(chunks_array: Array<{ hash: string; length: number }>): string; export class Chunker { free(): void; constructor(target_chunk_size: number); From 3127a01e0dae8da5df1ff06e7f1e4cfdbcf0539b Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Wed, 16 Jul 2025 16:22:47 +0200 Subject: [PATCH 02/43] createXorbs handles a stream of blobs --- packages/hub/src/utils/createXorbs.ts | 170 +++++++++++++------------- 1 file changed, 87 insertions(+), 83 deletions(-) diff --git a/packages/hub/src/utils/createXorbs.ts b/packages/hub/src/utils/createXorbs.ts index 66b8b8b6a6..55a86bd052 100644 --- a/packages/hub/src/utils/createXorbs.ts +++ b/packages/hub/src/utils/createXorbs.ts @@ -13,7 +13,7 @@ const MAX_CHUNK_SIZE = 2 * TARGET_CHUNK_SIZE; const XORB_SIZE = 64 * 1024 * 1024; const MAX_XORB_CHUNKS = 8 * 1024; -export async function* createXorbs(fileSource: Blob): AsyncGenerator< +export async function* createXorbs(fileSources: AsyncGenerator): AsyncGenerator< | { type: "xorb"; xorb: Uint8Array; hash: string; id: number } | { type: "file"; @@ -33,101 +33,105 @@ export async function* createXorbs(fileSource: Blob): AsyncGenerator< const chunker = new chunkModule.Chunker(TARGET_CHUNK_SIZE); let xorb = new Uint8Array(XORB_SIZE); - const sourceChunks: Array = []; + let xorbOffset = 0; + let xorbChunks = Array<{ hash: string; length: number }>(); try { - const reader = fileSource.stream().getReader(); - let xorbOffset = 0; - let xorbChunks = Array<{ hash: string; length: number }>(); - const fileChunks: Array<{ hash: string; length: number }> = []; - const fileRepresentation: Array<{ xorbId: number; offset: number; length: number }> = []; - - const sha256 = await sha256Module.createSHA256(); - sha256.init(); - - const addChunks = function* (chunks: Array<{ hash: string; length: number }>) { - for (const chunk of chunks) { - fileChunks.push({ hash: chunk.hash, length: chunk.length }); - let chunkToCopy: Uint8Array; - if (chunk.length === sourceChunks[0].length) { - chunkToCopy = sourceChunks[0]; - sourceChunks.shift(); - } else if (chunk.length < sourceChunks[0].length) { - chunkToCopy = sourceChunks[0].subarray(0, chunk.length); - sourceChunks[0] = sourceChunks[0].subarray(chunk.length); - } else { - chunkToCopy = new Uint8Array(chunk.length); - let copyOffset = 0; - let index = 0; - while (copyOffset < chunk.length) { - chunkToCopy.set(sourceChunks[index].subarray(0, chunk.length - copyOffset), copyOffset); - copyOffset += sourceChunks[index].length; - index++; + for await (const fileSource of fileSources) { + const initialXorbOffset = xorbOffset; + const sourceChunks: Array = []; + + const reader = fileSource.stream().getReader(); + const fileChunks: Array<{ hash: string; length: number }> = []; + const fileRepresentation: Array<{ xorbId: number; offset: number; length: number }> = []; + + const sha256 = await sha256Module.createSHA256(); + sha256.init(); + + const addChunks = function* (chunks: Array<{ hash: string; length: number }>) { + for (const chunk of chunks) { + fileChunks.push({ hash: chunk.hash, length: chunk.length }); + let chunkToCopy: Uint8Array; + if (chunk.length === sourceChunks[0].length) { + chunkToCopy = sourceChunks[0]; + sourceChunks.shift(); + } else if (chunk.length < sourceChunks[0].length) { + chunkToCopy = sourceChunks[0].subarray(0, chunk.length); + sourceChunks[0] = sourceChunks[0].subarray(chunk.length); + } else { + chunkToCopy = new Uint8Array(chunk.length); + let copyOffset = 0; + let index = 0; + while (copyOffset < chunk.length) { + chunkToCopy.set(sourceChunks[index].subarray(0, chunk.length - copyOffset), copyOffset); + copyOffset += sourceChunks[index].length; + index++; + } + sourceChunks.splice(0, index); } - sourceChunks.splice(0, index); - } - xorbOffset = writeChunk(xorb, xorbOffset, chunkToCopy); - if (xorbOffset === 0) { - // Failure to write chunk, maybe because it went over xorb size limit - yield { - type: "xorb" as const, - xorb: xorb.subarray(0, xorbOffset), - hash: chunkModule.compute_xorb_hash(xorbChunks), - id: xorbId, - }; - xorbId++; - xorb = new Uint8Array(XORB_SIZE); - xorbOffset = writeChunk(xorb, 0, chunkToCopy); - + xorbOffset = writeChunk(xorb, xorbOffset, chunkToCopy); if (xorbOffset === 0) { - throw new Error("Failed to write chunk into xorb"); + // Failure to write chunk, maybe because it went over xorb size limit + yield { + type: "xorb" as const, + xorb: xorb.subarray(0, xorbOffset), + hash: chunkModule.compute_xorb_hash(xorbChunks), + id: xorbId, + }; + xorbId++; + xorb = new Uint8Array(XORB_SIZE); + xorbOffset = writeChunk(xorb, 0, chunkToCopy); + + if (xorbOffset === 0) { + throw new Error("Failed to write chunk into xorb"); + } } - } - const lastRep = fileRepresentation.at(-1); + const lastRep = fileRepresentation.at(-1); - if (!lastRep) { - fileRepresentation.push({ xorbId, offset: 0, length: xorbOffset }); - } else { - if (lastRep.xorbId === xorbId) { - lastRep.length = xorbOffset - lastRep.offset; + if (!lastRep) { + fileRepresentation.push({ xorbId, offset: initialXorbOffset, length: xorbOffset - initialXorbOffset }); } else { - fileRepresentation.push({ xorbId, offset: 0, length: xorbOffset }); + if (lastRep.xorbId === xorbId) { + lastRep.length = xorbOffset - lastRep.offset; + } else { + fileRepresentation.push({ xorbId, offset: 0, length: xorbOffset }); + } + } + xorbChunks.push(chunk); + if (xorbChunks.length >= MAX_XORB_CHUNKS) { + yield { + type: "xorb" as const, + xorb: xorb.subarray(0, xorbOffset), + hash: chunkModule.compute_xorb_hash(xorbChunks), + id: xorbId, + }; + xorbId++; + xorbOffset = 0; + xorbChunks = []; + xorb = new Uint8Array(XORB_SIZE); } } - xorbChunks.push(chunk); - if (xorbChunks.length >= MAX_XORB_CHUNKS) { - yield { - type: "xorb" as const, - xorb: xorb.subarray(0, xorbOffset), - hash: chunkModule.compute_xorb_hash(xorbChunks), - id: xorbId, - }; - xorbId++; - xorbOffset = 0; - xorbChunks = []; - xorb = new Uint8Array(XORB_SIZE); + }; + + while (true) { + const { done, value } = await reader.read(); + if (done) { + yield* addChunks(chunker.finish()); + break; } + sourceChunks.push(value); + sha256.update(value); + yield* addChunks(chunker.add_data(value)); } - }; - while (true) { - const { done, value } = await reader.read(); - if (done) { - yield* addChunks(chunker.finish()); - break; - } - sourceChunks.push(value); - sha256.update(value); - yield* addChunks(chunker.add_data(value)); + yield { + type: "file" as const, + hash: chunkModule.compute_file_hash(fileChunks), + chunkHashes: fileChunks.map((x) => x.hash), + sha256: sha256.digest("hex"), + representation: fileRepresentation, + }; } - - yield { - type: "file" as const, - hash: chunkModule.compute_file_hash(fileChunks), - chunkHashes: fileChunks.map((x) => x.hash), - sha256: sha256.digest("hex"), - representation: fileRepresentation, - }; } finally { chunker.free(); // ^ is this really needed ? From 099cc406941971b9b25089daf68653f229243e6c Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Wed, 16 Jul 2025 18:22:44 +0200 Subject: [PATCH 03/43] basic shard creation --- packages/hub/scripts/build-xet-wasm.sh | 1 + packages/hub/src/utils/createXorbs.ts | 42 ++- packages/hub/src/utils/uploadShards.ts | 271 ++++++++++++++++++ .../hub/src/vendor/xet-chunk/chunker_wasm.ts | 2 +- .../src/vendor/xet-chunk/chunker_wasm_bg.d.ts | 1 + 5 files changed, 306 insertions(+), 11 deletions(-) create mode 100644 packages/hub/src/utils/uploadShards.ts diff --git a/packages/hub/scripts/build-xet-wasm.sh b/packages/hub/scripts/build-xet-wasm.sh index 73faa23212..6ef145714a 100755 --- a/packages/hub/scripts/build-xet-wasm.sh +++ b/packages/hub/scripts/build-xet-wasm.sh @@ -224,6 +224,7 @@ fi # copy the generated hf_xet_thin_wasm_bg.js to the hub package and hf_xet_thin_wasm_bg.wasm to the hub package cp "$CLONE_DIR/$PACKAGE/pkg/hf_xet_thin_wasm_bg.js" "./src/vendor/xet-chunk/chunker_wasm_bg.js" +cp "$CLONE_DIR/$PACKAGE/pkg/hf_xet_thin_wasm_bg.wasm.d.ts" "./src/vendor/xet-chunk/chunker_wasm_bg.wasm.d.ts" echo "// Generated by build-xet-wasm.sh" > "./src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts" echo "export const wasmBase64 = atob(\`" >> "./src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts" base64 "$CLONE_DIR/$PACKAGE/pkg/hf_xet_thin_wasm_bg.wasm" | fold -w 100 >> "./src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts" diff --git a/packages/hub/src/utils/createXorbs.ts b/packages/hub/src/utils/createXorbs.ts index 55a86bd052..e994a83c94 100644 --- a/packages/hub/src/utils/createXorbs.ts +++ b/packages/hub/src/utils/createXorbs.ts @@ -14,13 +14,25 @@ const XORB_SIZE = 64 * 1024 * 1024; const MAX_XORB_CHUNKS = 8 * 1024; export async function* createXorbs(fileSources: AsyncGenerator): AsyncGenerator< - | { type: "xorb"; xorb: Uint8Array; hash: string; id: number } + | { + type: "xorb"; + xorb: Uint8Array; + hash: string; + id: number; + chunks: Array<{ hash: string; length: number; offset: number }>; + } | { type: "file"; hash: string; - chunkHashes: string[]; + verificationHash: string; sha256: string; - representation: Array<{ xorbId: number; offset: number; length: number }>; + representation: Array<{ + xorbId: number; + offset: number; + endOffset: number; + /** Unpacked length */ + length: number; + }>; }, void, undefined @@ -34,7 +46,7 @@ export async function* createXorbs(fileSources: AsyncGenerator): AsyncGene let xorb = new Uint8Array(XORB_SIZE); let xorbOffset = 0; - let xorbChunks = Array<{ hash: string; length: number }>(); + let xorbChunks = Array<{ hash: string; length: number; offset: number }>(); try { for await (const fileSource of fileSources) { @@ -43,13 +55,14 @@ export async function* createXorbs(fileSources: AsyncGenerator): AsyncGene const reader = fileSource.stream().getReader(); const fileChunks: Array<{ hash: string; length: number }> = []; - const fileRepresentation: Array<{ xorbId: number; offset: number; length: number }> = []; + const fileRepresentation: Array<{ xorbId: number; offset: number; endOffset: number; length: number }> = []; const sha256 = await sha256Module.createSHA256(); sha256.init(); const addChunks = function* (chunks: Array<{ hash: string; length: number }>) { for (const chunk of chunks) { + let chunkOffset = xorbOffset; fileChunks.push({ hash: chunk.hash, length: chunk.length }); let chunkToCopy: Uint8Array; if (chunk.length === sourceChunks[0].length) { @@ -76,10 +89,12 @@ export async function* createXorbs(fileSources: AsyncGenerator): AsyncGene type: "xorb" as const, xorb: xorb.subarray(0, xorbOffset), hash: chunkModule.compute_xorb_hash(xorbChunks), + chunks: [...xorbChunks], id: xorbId, }; xorbId++; xorb = new Uint8Array(XORB_SIZE); + chunkOffset = 0; xorbOffset = writeChunk(xorb, 0, chunkToCopy); if (xorbOffset === 0) { @@ -89,20 +104,27 @@ export async function* createXorbs(fileSources: AsyncGenerator): AsyncGene const lastRep = fileRepresentation.at(-1); if (!lastRep) { - fileRepresentation.push({ xorbId, offset: initialXorbOffset, length: xorbOffset - initialXorbOffset }); + fileRepresentation.push({ + xorbId, + offset: initialXorbOffset, + endOffset: xorbOffset - initialXorbOffset, + length: chunk.length, + }); } else { if (lastRep.xorbId === xorbId) { - lastRep.length = xorbOffset - lastRep.offset; + lastRep.endOffset = xorbOffset - lastRep.offset; + lastRep.length += chunk.length; } else { - fileRepresentation.push({ xorbId, offset: 0, length: xorbOffset }); + fileRepresentation.push({ xorbId, offset: 0, endOffset: xorbOffset, length: chunk.length }); } } - xorbChunks.push(chunk); + xorbChunks.push({ hash: chunk.hash, length: chunk.length, offset: chunkOffset }); if (xorbChunks.length >= MAX_XORB_CHUNKS) { yield { type: "xorb" as const, xorb: xorb.subarray(0, xorbOffset), hash: chunkModule.compute_xorb_hash(xorbChunks), + chunks: [...xorbChunks], id: xorbId, }; xorbId++; @@ -127,7 +149,7 @@ export async function* createXorbs(fileSources: AsyncGenerator): AsyncGene yield { type: "file" as const, hash: chunkModule.compute_file_hash(fileChunks), - chunkHashes: fileChunks.map((x) => x.hash), + verificationHash: chunkModule.compute_range_verification_hash(fileChunks.map((x) => x.hash)), sha256: sha256.digest("hex"), representation: fileRepresentation, }; diff --git a/packages/hub/src/utils/uploadShards.ts b/packages/hub/src/utils/uploadShards.ts new file mode 100644 index 0000000000..1bee77a7a9 --- /dev/null +++ b/packages/hub/src/utils/uploadShards.ts @@ -0,0 +1,271 @@ +import { createXorbs } from "./createXorbs"; +import { sum } from "./sum"; + +const SHARD_MAX_SIZE = 64 * 1024 * 1024; +const SHARD_HEADER_SIZE = 48; +const SHARD_FOOTER_SIZE = 192; +const HASH_LENGTH = 32; +const XORB_FOOTER_LENGTH = 48; +const FILE_FOOTER_LENGTH = 48; +const SHARD_HEADER_VERSION = 2n; +const SHARD_FOOTER_VERSION = 1n; + +const MDB_FILE_FLAG_WITH_VERIFICATION = 0x80000000; // Cannot define as 1 << 31 because it becomes a negative number +const MDB_FILE_FLAG_WITH_METADATA_EXT = 0x40000000; + +const SHARD_MAGIC_TAG = new Uint8Array(32); + +writeHashToArray("0".repeat(64), SHARD_MAGIC_TAG, 0); + +/** + * Outputs the file sha256 after their xorbs/shards have been uploaded. + */ +export async function uploadShards(source: AsyncGenerator): Promise { + const xorbHashes: Array = []; + + const fileInfoSection = new Uint8Array(Math.floor(SHARD_MAX_SIZE - SHARD_HEADER_SIZE - SHARD_FOOTER_SIZE) / 2); + const xorbInfoSection = new Uint8Array(Math.floor(SHARD_MAX_SIZE - SHARD_HEADER_SIZE - SHARD_FOOTER_SIZE) / 2); + + const xorbView = new DataView(xorbInfoSection.buffer); + let xorbViewOffset = 0; + const fileInfoView = new DataView(fileInfoSection.buffer); + let fileViewOffset = 0; + let xorbTotalSize = 0n; + let fileTotalSize = 0n; + let xorbTotalUnpackedSize = 0n; + const fileShas: Array = []; + + for await (const output of createXorbs(source)) { + switch (output.type) { + case "xorb": { + xorbHashes.push(output.hash); + + // todo: handle when going out of bounds + writeHashToArray(output.hash, xorbInfoSection, xorbViewOffset); + xorbViewOffset += HASH_LENGTH; + xorbView.setUint32(xorbViewOffset, 0, true); // flags + xorbViewOffset += 4; + xorbView.setUint32(xorbViewOffset, output.chunks.length, true); + xorbViewOffset += 4; + const xorbUnpackedSize = sum(output.chunks.map((x) => x.length)); + xorbView.setUint32(xorbViewOffset, xorbUnpackedSize, true); + xorbTotalUnpackedSize += BigInt(xorbUnpackedSize); + xorbTotalSize += BigInt(output.xorb.byteLength); + xorbViewOffset += 4; + xorbView.setUint32(xorbViewOffset, output.xorb.byteLength, true); + xorbViewOffset += 4; + + for (const chunk of output.chunks) { + writeHashToArray(chunk.hash, xorbInfoSection, xorbViewOffset); + xorbViewOffset += HASH_LENGTH; + xorbView.setUint32(xorbViewOffset, chunk.length, true); + xorbViewOffset += 4; + xorbView.setUint32(xorbViewOffset, chunk.offset, true); + xorbViewOffset += 4; + xorbView.setBigUint64(xorbViewOffset, 0n, true); // reserved + xorbViewOffset += 8; + } + + await uploadXorb(output); + //^ Todo: queue it and do not await it + break; + } + case "file": { + fileShas.push(output.sha256); // note: if yielding instead, maybe wait until shard is uploaded. + + // todo: handle out of bounds + + writeHashToArray(output.hash, fileInfoSection, fileViewOffset); + fileViewOffset += HASH_LENGTH; + // Cannot use | binary operator since it works with int32 not uint32 and one of the flags is 1 << 31 + fileInfoView.setUint32(fileViewOffset, MDB_FILE_FLAG_WITH_METADATA_EXT + MDB_FILE_FLAG_WITH_VERIFICATION, true); + fileViewOffset += 4; + fileInfoView.setUint32(fileViewOffset, output.representation.length, true); + fileViewOffset += 4; + fileInfoView.setBigUint64(fileViewOffset, 0n, true); // reserved + fileViewOffset += 8; + + for (const chunk of output.representation) { + writeHashToArray(xorbHashes[chunk.xorbId], fileInfoSection, fileViewOffset); + fileViewOffset += HASH_LENGTH; + fileInfoView.setUint32(fileViewOffset, 0, true); // Xorb flags + fileViewOffset += 4; + fileInfoView.setUint32(fileViewOffset, chunk.length, true); + fileViewOffset += 4; + fileInfoView.setUint32(fileViewOffset, chunk.offset, true); + fileViewOffset += 4; + fileInfoView.setUint32(fileViewOffset, chunk.endOffset, true); + fileViewOffset += 4; + } + + // File verification data + writeHashToArray(output.verificationHash, fileInfoSection, fileViewOffset); + fileViewOffset += HASH_LENGTH; + + // reserved in file verification data + for (let i = 0; i < 16; i++) { + fileInfoSection[i] = 0; + } + fileViewOffset += 16; + + // File metadata ext + writeHashToArray(output.sha256, fileInfoSection, fileViewOffset); + fileViewOffset += HASH_LENGTH; + + // reserved in file metadata ext + for (let i = 0; i < 16; i++) { + fileInfoSection[i] = 0; + } + fileViewOffset += 16; + + break; + } + } + } + + function createShard(): Uint8Array { + const shard = new Uint8Array( + SHARD_HEADER_SIZE + SHARD_FOOTER_SIZE + xorbViewOffset + XORB_FOOTER_LENGTH + fileViewOffset + FILE_FOOTER_LENGTH + ); + + const shardView = new DataView(shard.buffer); + let shardOffset = 0; + + // Header + shard.set(SHARD_MAGIC_TAG, shardOffset); + shardOffset += SHARD_MAGIC_TAG.length; + + shardView.setBigUint64(shardOffset, SHARD_HEADER_VERSION, true); + shardOffset += 8; + + shardView.setBigUint64(shardOffset, BigInt(SHARD_FOOTER_SIZE), true); + shardOffset += 8; + + // File Info Section + shard.set(fileInfoSection, shardOffset); + shardOffset += fileInfoSection.length; + + // File info bookend + for (let i = 0; i < 32; i++) { + shard[shardOffset + i] = 0xff; + } + shardOffset += 32; + for (let i = 0; i < 16; i++) { + shard[shardOffset + i] = 0; + } + shardOffset += 16; + + // XORB Info Section + shard.set(xorbInfoSection, shardOffset); + shardOffset += xorbInfoSection.length; + + // Xorb info bookend + for (let i = 0; i < 32; i++) { + shard[shardOffset + i] = 0xff; + } + shardOffset += 32; + for (let i = 0; i < 16; i++) { + shard[shardOffset + i] = 0; + } + shardOffset += 16; + + // Footer + shardView.setBigUint64(shardOffset, SHARD_FOOTER_VERSION, true); + shardOffset += 8; + shardView.setBigUint64(shardOffset, BigInt(SHARD_HEADER_SIZE), true); // begging of fileinfo section + shardOffset += 8; + shardView.setBigUint64(shardOffset, BigInt(SHARD_FOOTER_SIZE + fileInfoSection.byteLength), true); // beginning of xorbinfo section + shardOffset += 8; + shardView.setBigUint64( + shardOffset, + BigInt(SHARD_FOOTER_SIZE + fileInfoSection.byteLength + xorbInfoSection.byteLength), + true + ); // beginning of file lookup table + shardOffset += 8; + shardView.setBigUint64(shardOffset, BigInt(0), true); // num entries in file lookup table + shardOffset += 8; + + shardView.setBigUint64( + shardOffset, + BigInt(SHARD_FOOTER_SIZE + fileInfoSection.byteLength + xorbInfoSection.byteLength + 8), + true + ); // beginning of cas lookup table + shardOffset += 8; + shardView.setBigUint64(shardOffset, BigInt(0), true); // num entries in cas lookup table + shardOffset += 8; + + // Footer + const footerOffset = shardOffset; + shardView.setBigUint64( + shardOffset, + BigInt(SHARD_FOOTER_SIZE + fileInfoSection.byteLength + xorbInfoSection.byteLength + 16), + true + ); // beginning of chunk lookup table + shardOffset += 8; + shardView.setBigUint64(shardOffset, BigInt(0), true); // num entries in chunk lookup table + shardOffset += 8; + + // Chunk HMAC + for (let i = 0; i < 32; i++) { + shardView.setUint8(shardOffset + i, 0); + } + shardOffset += 32; + + shardView.setBigUint64(shardOffset, BigInt(Math.floor(Date.now() / 1000)), true); + shardOffset += 8; + + // Shard key expiration + shardView.setBigUint64(shardOffset, BigInt(Math.floor(Date.now() / 1000)), true); + shardOffset += 8; + + // Reserved space (48 bytes) + for (let i = 0; i < 48; i++) { + shardView.setUint8(shardOffset + i, 0); + } + shardOffset += 48; + + shardView.setBigUint64(shardOffset, xorbTotalSize, true); + shardOffset += 8; + + shardView.setBigUint64(shardOffset, fileTotalSize, true); + shardOffset += 8; + + shardView.setBigUint64(shardOffset, xorbTotalUnpackedSize, true); + shardOffset += 8; + + shardView.setBigUint64(footerOffset, BigInt(footerOffset), true); + + xorbViewOffset = 0; + fileViewOffset = 0; + xorbTotalSize = 0n; + xorbTotalUnpackedSize = 0n; + fileTotalSize = 0n; + + return shard; + } + + // If un-uploaded data remains, upload it + if (xorbViewOffset || fileViewOffset) { + await uploadShard(createShard()); + } + + return fileShas; +} + +// Todo: switch from hex to non-hex when WASM switches. For now consider hash is hex +function writeHashToArray(hash: string, array: Uint8Array, offset: number) { + for (let i = 0; i < hash.length; i += 2) { + const byte = parseInt(hash.substring(i, i + 2), 16); + array[offset + i / 2] = byte; + } +} + +async function uploadXorb(xorb: { hash: string; xorb: Uint8Array }) { + void xorb; + // todo +} + +async function uploadShard(shard: Uint8Array) { + void shard; + // todo +} diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts b/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts index 708985b4d7..45894de5eb 100644 --- a/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts @@ -55,7 +55,7 @@ init(); export { init }; -export { compute_xorb_hash, compute_file_hash, Chunker } from "./chunker_wasm_bg.js"; +export { compute_xorb_hash, compute_file_hash, Chunker, compute_range_verification_hash } from "./chunker_wasm_bg.js"; // const exports = WebAssembly.Module.exports(wasmModule).map((item) => item.name); diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts index 366fcf1779..365536f1cc 100644 --- a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts @@ -1,6 +1,7 @@ /* tslint:disable */ /* eslint-disable */ export function compute_xorb_hash(chunks_array: Array<{ hash: string; length: number }>): string; +export function compute_range_verification_hash(chunkHashes: string[]): string; export function compute_file_hash(chunks_array: Array<{ hash: string; length: number }>): string; export class Chunker { free(): void; From 8b358695f5f61e09de5e7664effbc052f39759c3 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Wed, 16 Jul 2025 18:31:44 +0200 Subject: [PATCH 04/43] shard magic tag --- packages/hub/src/utils/uploadShards.ts | 35 +++++++++++++++++++++++++- 1 file changed, 34 insertions(+), 1 deletion(-) diff --git a/packages/hub/src/utils/uploadShards.ts b/packages/hub/src/utils/uploadShards.ts index 1bee77a7a9..3c388b97ff 100644 --- a/packages/hub/src/utils/uploadShards.ts +++ b/packages/hub/src/utils/uploadShards.ts @@ -13,7 +13,40 @@ const SHARD_FOOTER_VERSION = 1n; const MDB_FILE_FLAG_WITH_VERIFICATION = 0x80000000; // Cannot define as 1 << 31 because it becomes a negative number const MDB_FILE_FLAG_WITH_METADATA_EXT = 0x40000000; -const SHARD_MAGIC_TAG = new Uint8Array(32); +const SHARD_MAGIC_TAG = new Uint8Array([ + "H".charCodeAt(0), + "F".charCodeAt(0), + "R".charCodeAt(0), + "e".charCodeAt(0), + "p".charCodeAt(0), + "o".charCodeAt(0), + "M".charCodeAt(0), + "e".charCodeAt(0), + "t".charCodeAt(0), + "a".charCodeAt(0), + "D".charCodeAt(0), + "a".charCodeAt(0), + "t".charCodeAt(0), + "a".charCodeAt(0), + 0, + 85, + 105, + 103, + 69, + 106, + 123, + 129, + 87, + 131, + 165, + 189, + 217, + 92, + 205, + 209, + 74, + 169, +]); writeHashToArray("0".repeat(64), SHARD_MAGIC_TAG, 0); From 6676431d84876de7aea19cdb2c423e4af445e57a Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Wed, 16 Jul 2025 21:38:51 +0200 Subject: [PATCH 05/43] remove shard key expiry --- packages/hub/src/utils/uploadShards.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/hub/src/utils/uploadShards.ts b/packages/hub/src/utils/uploadShards.ts index 3c388b97ff..9dfb8eea59 100644 --- a/packages/hub/src/utils/uploadShards.ts +++ b/packages/hub/src/utils/uploadShards.ts @@ -248,7 +248,7 @@ export async function uploadShards(source: AsyncGenerator): Promise Date: Fri, 18 Jul 2025 22:29:43 +0200 Subject: [PATCH 06/43] actually make API calls to xet backend to upload shards/xorbs --- packages/hub/src/utils/XetBlob.ts | 2 - packages/hub/src/utils/uploadShards.ts | 138 ++++++++++++++++-- .../hub/src/vendor/xet-chunk/chunker_wasm.ts | 8 +- .../src/vendor/xet-chunk/chunker_wasm_bg.d.ts | 1 + 4 files changed, 137 insertions(+), 12 deletions(-) diff --git a/packages/hub/src/utils/XetBlob.ts b/packages/hub/src/utils/XetBlob.ts index 0846d1a535..b6721a3284 100644 --- a/packages/hub/src/utils/XetBlob.ts +++ b/packages/hub/src/utils/XetBlob.ts @@ -662,8 +662,6 @@ async function getAccessToken( const jwt = { accessToken: json.accessToken, expiresAt: new Date(json.exp * 1000), - initialAccessToken, - refreshUrl, casUrl: json.casUrl, }; diff --git a/packages/hub/src/utils/uploadShards.ts b/packages/hub/src/utils/uploadShards.ts index 9dfb8eea59..06ad86af32 100644 --- a/packages/hub/src/utils/uploadShards.ts +++ b/packages/hub/src/utils/uploadShards.ts @@ -1,3 +1,5 @@ +import { createApiError } from "../error"; +import type { RepoId } from "../types/public"; import { createXorbs } from "./createXorbs"; import { sum } from "./sum"; @@ -50,10 +52,18 @@ const SHARD_MAGIC_TAG = new Uint8Array([ writeHashToArray("0".repeat(64), SHARD_MAGIC_TAG, 0); +interface UploadShardsParams { + accessToken: string | undefined; + hubUrl: string; + customFetch: typeof fetch; + repo: RepoId; + rev: string; +} + /** * Outputs the file sha256 after their xorbs/shards have been uploaded. */ -export async function uploadShards(source: AsyncGenerator): Promise { +export async function uploadShards(source: AsyncGenerator, params: UploadShardsParams): Promise { const xorbHashes: Array = []; const fileInfoSection = new Uint8Array(Math.floor(SHARD_MAX_SIZE - SHARD_HEADER_SIZE - SHARD_FOOTER_SIZE) / 2); @@ -99,7 +109,7 @@ export async function uploadShards(source: AsyncGenerator): Promise): Promise): string { + return JSON.stringify([params.hubUrl, params.repo, params.rev, params.accessToken]); +} + +const jwtPromises: Map> = new Map(); +/** + * Cache to store JWTs, to avoid making many auth requests when downloading multiple files from the same repo + */ +const jwts: Map< + string, + { + accessToken: string; + expiresAt: Date; + casUrl: string; + } +> = new Map(); + +async function getAccessToken(params: UploadShardsParams): Promise<{ accessToken: string; casUrl: string }> { + const key = cacheKey(params); + + const jwt = jwts.get(key); + + if (jwt && jwt.expiresAt > new Date(Date.now() + JWT_SAFETY_PERIOD)) { + return { accessToken: jwt.accessToken, casUrl: jwt.casUrl }; + } + + // If we already have a promise for this repo, return it + const existingPromise = jwtPromises.get(key); + if (existingPromise) { + return existingPromise; + } + + const promise = (async () => { + const resp = await params.customFetch( + `${params.hubUrl}/api/${params.repo.type}s/${params.repo.name}/xet-write-token/${params.rev}`, + { + method: "POST", + headers: params.accessToken + ? { + Authorization: `Bearer ${params.accessToken}`, + } + : {}, + } + ); + + if (!resp.ok) { + throw await createApiError(resp); + } + + const json: { accessToken: string; casUrl: string; exp: number } = await resp.json(); + const jwt = { + accessToken: json.accessToken, + expiresAt: new Date(json.exp * 1000), + casUrl: json.casUrl, + }; + + jwtPromises.delete(key); + + for (const [key, value] of jwts.entries()) { + if (value.expiresAt < new Date(Date.now() + JWT_SAFETY_PERIOD)) { + jwts.delete(key); + } else { + break; + } + } + if (jwts.size >= JWT_CACHE_SIZE) { + const keyToDelete = jwts.keys().next().value; + if (keyToDelete) { + jwts.delete(keyToDelete); + } + } + jwts.set(key, jwt); + + return { + accessToken: json.accessToken, + casUrl: json.casUrl, + }; + })(); + + jwtPromises.set(key, promise); + + return promise; } diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts b/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts index 45894de5eb..bc28f3c463 100644 --- a/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts @@ -55,7 +55,13 @@ init(); export { init }; -export { compute_xorb_hash, compute_file_hash, Chunker, compute_range_verification_hash } from "./chunker_wasm_bg.js"; +export { + compute_xorb_hash, + compute_file_hash, + Chunker, + compute_range_verification_hash, + compute_shard_hash, +} from "./chunker_wasm_bg.js"; // const exports = WebAssembly.Module.exports(wasmModule).map((item) => item.name); diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts index 365536f1cc..76b98e554c 100644 --- a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts @@ -1,6 +1,7 @@ /* tslint:disable */ /* eslint-disable */ export function compute_xorb_hash(chunks_array: Array<{ hash: string; length: number }>): string; +export function compute_shard_hash(shard: Uint8Array): string; export function compute_range_verification_hash(chunkHashes: string[]): string; export function compute_file_hash(chunks_array: Array<{ hash: string; length: number }>): string; export class Chunker { From 7a38fc78e1b214a91abb266d81bf06f8a138226c Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Fri, 18 Jul 2025 23:47:50 +0200 Subject: [PATCH 07/43] fix prefix for shard upload --- packages/hub/src/utils/uploadShards.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/hub/src/utils/uploadShards.ts b/packages/hub/src/utils/uploadShards.ts index 06ad86af32..bc4092a344 100644 --- a/packages/hub/src/utils/uploadShards.ts +++ b/packages/hub/src/utils/uploadShards.ts @@ -323,7 +323,7 @@ async function uploadShard(shard: Uint8Array, params: UploadShardsParams) { const token = await getAccessToken(params); const shardHash = "0".repeat(64); - const resp = await params.customFetch(`${token.casUrl}/shard/default/${shardHash}`, { + const resp = await params.customFetch(`${token.casUrl}/shard/default-merkledb/${shardHash}`, { method: "PUT", body: shard, headers: { From 947a92696a8ecfb8ab60b311da54932b9e977cc9 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Mon, 21 Jul 2025 15:26:19 +0200 Subject: [PATCH 08/43] fix verificaiton data --- packages/hub/src/utils/createXorbs.ts | 33 ++++++++++++++++++++++---- packages/hub/src/utils/uploadShards.ts | 25 +++++++++---------- 2 files changed, 42 insertions(+), 16 deletions(-) diff --git a/packages/hub/src/utils/createXorbs.ts b/packages/hub/src/utils/createXorbs.ts index e994a83c94..897c9ba084 100644 --- a/packages/hub/src/utils/createXorbs.ts +++ b/packages/hub/src/utils/createXorbs.ts @@ -24,7 +24,6 @@ export async function* createXorbs(fileSources: AsyncGenerator): AsyncGene | { type: "file"; hash: string; - verificationHash: string; sha256: string; representation: Array<{ xorbId: number; @@ -32,6 +31,7 @@ export async function* createXorbs(fileSources: AsyncGenerator): AsyncGene endOffset: number; /** Unpacked length */ length: number; + rangeHash: string; }>; }, void, @@ -55,7 +55,14 @@ export async function* createXorbs(fileSources: AsyncGenerator): AsyncGene const reader = fileSource.stream().getReader(); const fileChunks: Array<{ hash: string; length: number }> = []; - const fileRepresentation: Array<{ xorbId: number; offset: number; endOffset: number; length: number }> = []; + let currentChunkRangeBeginning = 0; + const fileRepresentation: Array<{ + xorbId: number; + offset: number; + endOffset: number; + length: number; + rangeHash: string; + }> = []; const sha256 = await sha256Module.createSHA256(); sha256.init(); @@ -109,13 +116,25 @@ export async function* createXorbs(fileSources: AsyncGenerator): AsyncGene offset: initialXorbOffset, endOffset: xorbOffset - initialXorbOffset, length: chunk.length, + rangeHash: "", }); + currentChunkRangeBeginning = fileChunks.length - 1; } else { if (lastRep.xorbId === xorbId) { lastRep.endOffset = xorbOffset - lastRep.offset; lastRep.length += chunk.length; } else { - fileRepresentation.push({ xorbId, offset: 0, endOffset: xorbOffset, length: chunk.length }); + lastRep.rangeHash = chunkModule.compute_range_verification_hash( + fileChunks.slice(currentChunkRangeBeginning, -1).map((x) => x.hash, -1) + ); + fileRepresentation.push({ + xorbId, + offset: 0, + endOffset: xorbOffset, + length: chunk.length, + rangeHash: "", + }); + currentChunkRangeBeginning = fileChunks.length - 1; } } xorbChunks.push({ hash: chunk.hash, length: chunk.length, offset: chunkOffset }); @@ -146,10 +165,16 @@ export async function* createXorbs(fileSources: AsyncGenerator): AsyncGene yield* addChunks(chunker.add_data(value)); } + const lastRep = fileRepresentation.at(-1); + if (lastRep) { + lastRep.rangeHash = chunkModule.compute_range_verification_hash( + fileChunks.slice(currentChunkRangeBeginning).map((x) => x.hash) + ); + } + yield { type: "file" as const, hash: chunkModule.compute_file_hash(fileChunks), - verificationHash: chunkModule.compute_range_verification_hash(fileChunks.map((x) => x.hash)), sha256: sha256.digest("hex"), representation: fileRepresentation, }; diff --git a/packages/hub/src/utils/uploadShards.ts b/packages/hub/src/utils/uploadShards.ts index bc4092a344..c76c98547c 100644 --- a/packages/hub/src/utils/uploadShards.ts +++ b/packages/hub/src/utils/uploadShards.ts @@ -128,28 +128,29 @@ export async function uploadShards(source: AsyncGenerator, params: UploadS fileInfoView.setBigUint64(fileViewOffset, 0n, true); // reserved fileViewOffset += 8; - for (const chunk of output.representation) { - writeHashToArray(xorbHashes[chunk.xorbId], fileInfoSection, fileViewOffset); + for (const repItem of output.representation) { + writeHashToArray(xorbHashes[repItem.xorbId], fileInfoSection, fileViewOffset); fileViewOffset += HASH_LENGTH; fileInfoView.setUint32(fileViewOffset, 0, true); // Xorb flags fileViewOffset += 4; - fileInfoView.setUint32(fileViewOffset, chunk.length, true); + fileInfoView.setUint32(fileViewOffset, repItem.length, true); fileViewOffset += 4; - fileInfoView.setUint32(fileViewOffset, chunk.offset, true); + fileInfoView.setUint32(fileViewOffset, repItem.offset, true); fileViewOffset += 4; - fileInfoView.setUint32(fileViewOffset, chunk.endOffset, true); + fileInfoView.setUint32(fileViewOffset, repItem.endOffset, true); fileViewOffset += 4; } // File verification data - writeHashToArray(output.verificationHash, fileInfoSection, fileViewOffset); - fileViewOffset += HASH_LENGTH; - - // reserved in file verification data - for (let i = 0; i < 16; i++) { - fileInfoSection[i] = 0; + for (const repItem of output.representation) { + writeHashToArray(repItem.rangeHash, fileInfoSection, fileViewOffset); + fileViewOffset += HASH_LENGTH; + // reserved in file verification data + for (let i = 0; i < 16; i++) { + fileInfoSection[i] = 0; + } + fileViewOffset += 16; } - fileViewOffset += 16; // File metadata ext writeHashToArray(output.sha256, fileInfoSection, fileViewOffset); From 9cd2e665bed45f5539b4482a5bb01b795d5e09a4 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Mon, 21 Jul 2025 15:30:53 +0200 Subject: [PATCH 09/43] update wasm bindings --- packages/hub/package.json | 2 +- .../hub/src/vendor/xet-chunk/chunker_wasm.ts | 2 +- .../src/vendor/xet-chunk/chunker_wasm_bg.d.ts | 2 +- .../src/vendor/xet-chunk/chunker_wasm_bg.js | 62 + .../xet-chunk/chunker_wasm_bg.wasm.base64.ts | 3417 +++++++++-------- .../xet-chunk/chunker_wasm_bg.wasm.d.ts | 2 + 6 files changed, 1805 insertions(+), 1682 deletions(-) diff --git a/packages/hub/package.json b/packages/hub/package.json index 005023f025..1f5de298d2 100644 --- a/packages/hub/package.json +++ b/packages/hub/package.json @@ -42,7 +42,7 @@ "test": "vitest run", "test:browser": "vitest run --browser.name=chrome --browser.headless --config vitest-browser.config.mts", "check": "tsc", - "build:xet-wasm": "./scripts/build-xet-wasm.sh -t bundler -c -b hoytak/250714-eliminate-mdb-v1" + "build:xet-wasm": "./scripts/build-xet-wasm.sh -t bundler --clean" }, "files": [ "src", diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts b/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts index bc28f3c463..44caf9640e 100644 --- a/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts @@ -59,7 +59,7 @@ export { compute_xorb_hash, compute_file_hash, Chunker, - compute_range_verification_hash, + compute_verification_hash, compute_shard_hash, } from "./chunker_wasm_bg.js"; diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts index 76b98e554c..c9e8495c26 100644 --- a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts @@ -2,7 +2,7 @@ /* eslint-disable */ export function compute_xorb_hash(chunks_array: Array<{ hash: string; length: number }>): string; export function compute_shard_hash(shard: Uint8Array): string; -export function compute_range_verification_hash(chunkHashes: string[]): string; +export function compute_verification_hash(chunkHashes: string[]): string; export function compute_file_hash(chunks_array: Array<{ hash: string; length: number }>): string; export class Chunker { free(): void; diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.js b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.js index d41d63de51..62f45fd1d9 100644 --- a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.js +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.js @@ -188,6 +188,8 @@ function takeFromExternrefTable0(idx) { return value; } /** + * takes an Array of Objects of the form { "hash": string, "length": number } + * and returns a string of a hash * @param {any} chunks_array * @returns {string} */ @@ -210,6 +212,66 @@ export function compute_xorb_hash(chunks_array) { } } +/** + * takes an Array of Objects of the form { "hash": string, "length": number } + * and returns a string of a hash + * @param {any} chunks_array + * @returns {string} + */ +export function compute_file_hash(chunks_array) { + let deferred2_0; + let deferred2_1; + try { + const ret = wasm.compute_file_hash(chunks_array); + var ptr1 = ret[0]; + var len1 = ret[1]; + if (ret[3]) { + ptr1 = 0; len1 = 0; + throw takeFromExternrefTable0(ret[2]); + } + deferred2_0 = ptr1; + deferred2_1 = len1; + return getStringFromWasm0(ptr1, len1); + } finally { + wasm.__wbindgen_free(deferred2_0, deferred2_1, 1); + } +} + +function passArrayJsValueToWasm0(array, malloc) { + const ptr = malloc(array.length * 4, 4) >>> 0; + for (let i = 0; i < array.length; i++) { + const add = addToExternrefTable0(array[i]); + getDataViewMemory0().setUint32(ptr + 4 * i, add, true); + } + WASM_VECTOR_LEN = array.length; + return ptr; +} +/** + * takes an Array of hashes as strings and returns the verification hash for that range of chunk hashes + * @param {string[]} chunk_hashes + * @returns {string} + */ +export function compute_verification_hash(chunk_hashes) { + let deferred3_0; + let deferred3_1; + try { + const ptr0 = passArrayJsValueToWasm0(chunk_hashes, wasm.__wbindgen_malloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.compute_verification_hash(ptr0, len0); + var ptr2 = ret[0]; + var len2 = ret[1]; + if (ret[3]) { + ptr2 = 0; len2 = 0; + throw takeFromExternrefTable0(ret[2]); + } + deferred3_0 = ptr2; + deferred3_1 = len2; + return getStringFromWasm0(ptr2, len2); + } finally { + wasm.__wbindgen_free(deferred3_0, deferred3_1, 1); + } +} + const ChunkerFinalization = (typeof FinalizationRegistry === 'undefined') ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry(ptr => wasm.__wbg_chunker_free(ptr >>> 0, 1)); diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts index 86d5cfc1d1..4cd7b3368e 100644 --- a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts @@ -1,1688 +1,1747 @@ // Generated by build-xet-wasm.sh export const wasmBase64 = atob(` -AGFzbQEAAAABpgIrYAJ/fwF/YAN/f38Bf2ACf38AYAN/f38AYAR/f39/AGABfwF/YAFvAX9gAX8A -YAV/f39/fwBgAW8Bb2ACf28AYAABb2AAAGAGf39/f39/AGAEf39/fwF/YAADf39/YAJvbwFvYAZ/ -f39/f38Bf2AFf39/f38Bf2ACb28Bf2ACf38Bb2AAAX9gAAR/f39/YAFvAXxgAXwBb2ADb29vAGAC -b38Bb2ADb39vAGADb29/AGAFf39/fn8AYAd/f39+f39/AX9gCX9/f39/f35+fgBgA35/fwF/YAd/ -f39/f39/AX9gA39/fwN/f39gAW8Ef39/f2ABfwN/f39gBX9/fX9/AGAEf31/fwBgBX9/fH9/AGAE -f3x/fwBgBX9/fn9/AGAEf35/fwAC9RAoGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxRfX3diaW5k -Z2VuX2lzX29iamVjdAAGGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxdfX3diaW5kZ2VuX2lzX3Vu -ZGVmaW5lZAAGGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcw1fX3diaW5kZ2VuX2luABMYLi9oZl94 -ZXRfdGhpbl93YXNtX2JnLmpzFV9fd2JpbmRnZW5fc3RyaW5nX2dldAAKGC4vaGZfeGV0X3RoaW5f -d2FzbV9iZy5qcxRfX3diaW5kZ2VuX2Vycm9yX25ldwAUGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5q +AGFzbQEAAAABrwIsYAJ/fwF/YAN/f38Bf2ACf38AYAN/f38AYAR/f39/AGABbwF/YAF/AX9gAX8A +YAV/f39/fwBgAAR/f39/YAFvAW9gAn9vAGAAAW9gAABgBn9/f39/fwBgBH9/f38Bf2AAA39/f2AC +b28Bb2AGf39/f39/AX9gBX9/f39/AX9gAn9/AW9gAm9vAX9gAAF/YAFvBH9/f39gAW8BfGABfAFv +YANvb28AYAJvfwFvYANvf28AYANvb38AYAV/f39+fwBgB39/f35/f38Bf2AJf39/f39/fn5+AGAD +fn9/AX9gB39/f39/f38Bf2ACf38Ef39/f2ADf39/A39/f2ABfwN/f39gBX9/fX9/AGAEf31/fwBg +BX9/fH9/AGAEf3x/fwBgBX9/fn9/AGAEf35/fwAC9RAoGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5q cxpfX3diZ19sb2dfYzVkMWE4ZGMwOTgyMTJhZgACGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxVf -X3diaW5kZ2VuX3N0cmluZ19uZXcAFBguL2hmX3hldF90aGluX3dhc21fYmcuanMZX193YmluZGdl -bl9qc3ZhbF9sb29zZV9lcQATGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxZfX3diaW5kZ2VuX2Jv -b2xlYW5fZ2V0AAYYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzFV9fd2JpbmRnZW5fbnVtYmVyX2dl -dAAKGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxRfX3diaW5kZ2VuX2FzX251bWJlcgAXGC4vaGZf -eGV0X3RoaW5fd2FzbV9iZy5qcx1fX3diZ19TdHJpbmdfOGYwZWIzOWE0YTRjMmY2NgAKGC4vaGZf -eGV0X3RoaW5fd2FzbV9iZy5qcxVfX3diaW5kZ2VuX251bWJlcl9uZXcAGBguL2hmX3hldF90aGlu -X3dhc21fYmcuanMkX193YmdfZ2V0d2l0aHJlZmtleV8xZGMzNjFiZDEwMDUzYmZlABAYLi9oZl94 -ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX3NldF8zZjFkMGI5ODRlZDI3MmVkABkYLi9oZl94ZXRf -dGhpbl93YXNtX2JnLmpzGl9fd2JnX2dldF9iOWI5MzA0N2ZlM2NmNDViABoYLi9oZl94ZXRfdGhp -bl93YXNtX2JnLmpzHV9fd2JnX2xlbmd0aF9lMmQyYTQ5MTMyYzFiMjU2AAYYLi9oZl94ZXRfdGhp -bl93YXNtX2JnLmpzGl9fd2JnX25ld183OGZlYjEwOGI2NDcyNzEzAAsYLi9oZl94ZXRfdGhpbl93 -YXNtX2JnLmpzFl9fd2JpbmRnZW5faXNfZnVuY3Rpb24ABhguL2hmX3hldF90aGluX3dhc21fYmcu -anMbX193YmdfbmV4dF8yNWZlYWRmYzA5MTNmZWE5AAkYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpz -G19fd2JnX25leHRfNjU3NGUxYThhNjJkMTA1NQAJGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxtf -X3diZ19kb25lXzc2OWU1ZWRlNGIzMWM2N2IABhguL2hmX3hldF90aGluX3dhc21fYmcuanMcX193 -YmdfdmFsdWVfY2QxZmZhN2IxYWI3OTRmMQAJGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcx9fX3di -Z19pdGVyYXRvcl85YTI0Yzg4ZGY4NjBkYzY1AAsYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzGl9f -d2JnX2dldF82N2IyYmE2MmZjMzBkZTEyABAYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzG19fd2Jn -X2NhbGxfNjcyYTRkMjE2MzRkNGEyNAAQGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxpfX3diZ19u -ZXdfNDA1ZTIyZjM5MDU3NmNlMgALGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxpfX3diZ19zZXRf -Mzc4MzcwMjNmM2Q3NDBlOAAbGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcx5fX3diZ19pc0FycmF5 -X2ExZWFiN2UwZDA2NzM5MWIABhguL2hmX3hldF90aGluX3dhc21fYmcuanMtX193YmdfaW5zdGFu -Y2VvZl9BcnJheUJ1ZmZlcl9lMTQ1ODU0MzJlMzczN2ZjAAYYLi9oZl94ZXRfdGhpbl93YXNtX2Jn -LmpzJF9fd2JnX2lzU2FmZUludGVnZXJfMzQzZTJiZWVlZWNlMWJiMAAGGC4vaGZfeGV0X3RoaW5f -d2FzbV9iZy5qcx1fX3diZ19idWZmZXJfNjA5Y2MzZWVlNTFlZDE1OAAJGC4vaGZfeGV0X3RoaW5f -d2FzbV9iZy5qcxpfX3diZ19uZXdfYTEyMDAyYTdmOTFjNzViZQAJGC4vaGZfeGV0X3RoaW5fd2Fz -bV9iZy5qcxpfX3diZ19zZXRfNjU1OTViZGQ4NjhiMzAwOQAcGC4vaGZfeGV0X3RoaW5fd2FzbV9i -Zy5qcx1fX3diZ19sZW5ndGhfYTQ0NjE5M2RjMjJjMTJmOAAGGC4vaGZfeGV0X3RoaW5fd2FzbV9i -Zy5qcyxfX3diZ19pbnN0YW5jZW9mX1VpbnQ4QXJyYXlfMTcxNTZiY2YxMTgwODZhOQAGGC4vaGZf -eGV0X3RoaW5fd2FzbV9iZy5qcxdfX3diaW5kZ2VuX2RlYnVnX3N0cmluZwAKGC4vaGZfeGV0X3Ro -aW5fd2FzbV9iZy5qcxBfX3diaW5kZ2VuX3Rocm93AAIYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpz -EV9fd2JpbmRnZW5fbWVtb3J5AAsYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzH19fd2JpbmRnZW5f -aW5pdF9leHRlcm5yZWZfdGFibGUADAPJAccBHQUeAgACAAgDBAMRAAcBAAEAAQABEQEEAwIfAQIA -IAACAAAADQ0hAAAABQIVCAMAAgQABAQDDgMBBQIACAMCAgIDBw0DFQ0CAAQCAgADAAQCAAgDAQME -AgAAAAQEAAQBAQcEDAEABwIAAwQAEgAHACIjAiQOEQUACBIlJykHBAABBAAHBQIDAAcAAAUOAwAB -AAgAAAQEAAAHAgICAAAAAgMDBQMDAwAHAAAAAAAAAAAAAAAADAwCAAIAAAIAAQIAAAIFBQUFAwQJ -AnABcXFvAIABBQMBABEGCQF/AUGAgMAACwedAg4GbWVtb3J5AgASX193YmdfY2h1bmtlcl9mcmVl -AGcLY2h1bmtlcl9uZXcAUhBjaHVua2VyX2FkZF9kYXRhAJgBDmNodW5rZXJfZmluaXNoAJsBEWNv -bXB1dGVfeG9yYl9oYXNoAJkBEV9fd2JpbmRnZW5fbWFsbG9jAJUBEl9fd2JpbmRnZW5fcmVhbGxv -YwCcARRfX3diaW5kZ2VuX2V4bl9zdG9yZQDAARdfX2V4dGVybnJlZl90YWJsZV9hbGxvYwBtE19f -d2JpbmRnZW5fZXhwb3J0XzQBARlfX2V4dGVybnJlZl90YWJsZV9kZWFsbG9jAGoPX193YmluZGdl -bl9mcmVlALUBEF9fd2JpbmRnZW5fc3RhcnQAJwnKAQEAQQELcOgB2AHnAdEBqwGHAUnVAdMB1AG4 -ATS6AdYBqwGHAU+CAawBqwGHAUrXAdIBqwGHAUvZAbgBcJMBoQFuoAGhAZ0BqAGmAaABoAGiAaMB -pAGpAX537QHuAYMBhgFbngFphAGKAVxs2gGSAbwBvQHKAXt2vgG6AYUBpwHQAZ8BY1e/AZABYKoB -2wG+AbABlwHOAX+rAYgBUd8BwgHBAcQBjwHDAeABpQF5WGjpAasBjAFQ4QHiAbYBuAHFAcYBN3Ra -Oo0B5AEMAQ4KhdMExwGJGwEgfyAAIAAoAhgiHSABKAAQIiQgACgCCGpqIhsgASgAFCIVaiAdIBsg -AkH/AXFzQRB3IgJB8ua74wNqIh1zQRR3IhtqIiIgAnNBGHciCSAdaiIcIBtzQRl3Ig8gACgCFCIb -IAEoAAgiAiAAKAIEamoiGSABKAAMIh1qIBkgA0IgiKdzQRB3Ih5B+6LhpARrIiAgG3NBFHciBmoi -CiABKAAoIhtqaiIjIAEoACwiGWogDyAjIAAoAhAiISABKAAAIg8gACgCAGpqIgggASgABCIfaiAh -IAggA6dzQRB3IiFB58yn0AZqIghzQRR3IgdqIg4gIXNBGHciDXNBEHciCyAAKAIcIgUgASgAGCIj -IAAoAgxqaiIMIAEoABwiIWogBSAMIARB/wFxc0EQdyIEQcaVwNUFayIFc0EUdyIMaiIRIARzQRh3 -IhAgBWoiBWoiEnNBFHciFGoiEyAdaiAGICAgCiAec0EYdyIgaiIGc0EZdyIKIA4gASgAICIEamoi -DiABKAAkIh5qIAogHCAOIBBzQRB3IhxqIgpzQRR3Ig5qIhAgHHNBGHciFiAKaiIKIA5zQRl3Ihxq -Ig4gG2ogHCAOIAUgDHNBGXciBSAiIAEoADAiHGpqIgwgASgANCIiaiAMICBzQRB3IiAgCCANaiII -aiINIAVzQRR3IgVqIgwgIHNBGHciF3NBEHciDiAHIAhzQRl3IgggESABKAA4IiBqaiIHIAEoADwi -AWogByAJc0EQdyIJIAZqIgYgCHNBFHciCGoiByAJc0EYdyIJIAZqIgZqIhFzQRR3IhhqIhogHGog -CyATc0EYdyILIBJqIhIgFHNBGXciFCAMICFqaiIMIA9qIAkgDHNBEHciCSAKaiIKIBRzQRR3Igxq -IhQgCXNBGHciCSAKaiIKIAxzQRl3IgxqIhMgFWogDCATIAYgCHNBGXciBiACIBBqaiIIICNqIAYg -CCALc0EQdyIGIA0gF2oiCGoiDXNBFHciC2oiDCAGc0EYdyIGc0EQdyIQIAUgCHNBGXciCCAHICRq -aiIHICJqIAggByAWc0EQdyIIIBJqIgdzQRR3IgVqIhIgCHNBGHciCCAHaiIHaiITc0EUdyIWaiIX -IBtqIA4gGnNBGHciDiARaiIRIBhzQRl3IhggDCAfamoiDCAZaiAKIAggDHNBEHciCmoiCCAYc0EU -dyIMaiIYIApzQRh3IgogCGoiCCAMc0EZdyIMaiIaIBxqIAwgGiAFIAdzQRl3IgcgFCAeamoiBSAg -aiAHIAUgDnNBEHciByAGIA1qIgZqIg5zQRR3Ig1qIgUgB3NBGHciB3NBEHciDCAGIAtzQRl3IgYg -ASASamoiCyAEaiAGIAkgC3NBEHciCSARaiIGc0EUdyILaiIRIAlzQRh3IgkgBmoiBmoiEnNBFHci -FGoiGiAeaiAQIBdzQRh3IhAgE2oiEyAWc0EZdyIWIAUgImpqIgUgAmogBSAJc0EQdyIJIAhqIggg -FnNBFHciBWoiFiAJc0EYdyIJIAhqIgggBXNBGXciBWoiFyAPaiAFIBcgBiALc0EZdyIGIBggHWpq -IgsgJGogBiALIBBzQRB3IgYgByAOaiIHaiIOc0EUdyILaiIFIAZzQRh3IgZzQRB3IhAgByANc0EZ -dyIHIBEgIWpqIg0gIGogByAKIA1zQRB3IgogE2oiB3NBFHciDWoiESAKc0EYdyIKIAdqIgdqIhNz -QRR3IhdqIhggHGogDCAac0EYdyIMIBJqIhIgFHNBGXciFCAFICNqaiIFIBVqIAUgCnNBEHciCiAI -aiIIIBRzQRR3IgVqIhQgCnNBGHciCiAIaiIIIAVzQRl3IgVqIhogHmogBSAaIAcgDXNBGXciByAW -IBlqaiINIAFqIAcgDCANc0EQdyIHIAYgDmoiBmoiDnNBFHciDWoiBSAHc0EYdyIHc0EQdyIMIAYg -C3NBGXciBiAEIBFqaiILIB9qIAYgCSALc0EQdyIJIBJqIgZzQRR3IgtqIhEgCXNBGHciCSAGaiIG -aiISc0EUdyIWaiIaIBlqIBAgGHNBGHciECATaiITIBdzQRl3IhcgBSAgamoiBSAdaiAFIAlzQRB3 -IgkgCGoiCCAXc0EUdyIFaiIXIAlzQRh3IgkgCGoiCCAFc0EZdyIFaiIYIAJqIAUgGCAGIAtzQRl3 -IgYgFCAbamoiCyAhaiAGIAsgEHNBEHciBiAHIA5qIgdqIg5zQRR3IgtqIgUgBnNBGHciBnNBEHci -ECAHIA1zQRl3IgcgESAiamoiDSABaiAHIAogDXNBEHciCiATaiIHc0EUdyINaiIRIApzQRh3Igog -B2oiB2oiFHNBFHciE2oiGCAeaiAMIBpzQRh3IgwgEmoiEiAWc0EZdyIWIAUgJGpqIgUgD2ogBSAK -c0EQdyIKIAhqIgggFnNBFHciBWoiFiAKc0EYdyIKIAhqIgggBXNBGXciBWoiGiAZaiAFIBogByAN -c0EZdyIHIBUgF2pqIg0gBGogByAMIA1zQRB3IgcgBiAOaiIGaiIOc0EUdyINaiIFIAdzQRh3Igdz -QRB3IgwgBiALc0EZdyIGIBEgH2pqIgsgI2ogBiAJIAtzQRB3IgkgEmoiBnNBFHciC2oiESAJc0EY -dyIJIAZqIgZqIhJzQRR3IhdqIhogFWogECAYc0EYdyIQIBRqIhQgE3NBGXciEyABIAVqaiIFIBtq -IAUgCXNBEHciCSAIaiIIIBNzQRR3IgVqIhMgCXNBGHciCSAIaiIIIAVzQRl3IgVqIhggHWogBSAY -IAYgC3NBGXciBiAWIBxqaiILICJqIAYgCyAQc0EQdyIGIAcgDmoiB2oiDnNBFHciC2oiBSAGc0EY -dyIGc0EQdyIQIAcgDXNBGXciByARICBqaiINIARqIAcgCiANc0EQdyIKIBRqIgdzQRR3Ig1qIhEg -CnNBGHciCiAHaiIHaiIUc0EUdyIWaiIYIBlqIAwgGnNBGHciDCASaiISIBdzQRl3IhcgBSAhamoi -BSACaiAFIApzQRB3IgogCGoiCCAXc0EUdyIFaiIXIApzQRh3IgogCGoiCCAFc0EZdyIFaiIaIBVq -IAUgGiAHIA1zQRl3IgcgDyATamoiDSAfaiAHIAwgDXNBEHciByAGIA5qIgZqIg5zQRR3Ig1qIgUg -B3NBGHciB3NBEHciDCAGIAtzQRl3IgYgESAjamoiCyAkaiAGIAkgC3NBEHciCSASaiIGc0EUdyIL -aiIRIAlzQRh3IgkgBmoiBmoiEnNBFHciE2oiGiAPaiAQIBhzQRh3IhAgFGoiFCAWc0EZdyIWIAQg -BWpqIgUgHGogBSAJc0EQdyIJIAhqIgggFnNBFHciBWoiFiAJc0EYdyIJIAhqIgggBXNBGXciBWoi -GCAbaiAFIBggBiALc0EZdyIGIBcgHmpqIgsgIGogBiALIBBzQRB3IgYgByAOaiIHaiIOc0EUdyIL -aiIFIAZzQRh3IgZzQRB3IhAgByANc0EZdyIHIAEgEWpqIg0gH2ogByAKIA1zQRB3IgogFGoiB3NB -FHciDWoiESAKc0EYdyIKIAdqIgdqIhRzQRR3IhdqIhggFWogDCAac0EYdyIVIBJqIgwgE3NBGXci -EiAFICJqaiIFIB1qIAUgCnNBEHciCiAIaiIIIBJzQRR3IgVqIhIgCnNBGHciCiAIaiIIIAVzQRl3 -IgVqIhMgD2ogBSATIAcgDXNBGXciDyACIBZqaiIHICNqIA8gByAVc0EQdyIVIAYgDmoiD2oiBnNB -FHciB2oiDiAVc0EYdyIVc0EQdyINIAsgD3NBGXciDyARICRqaiILICFqIA8gCSALc0EQdyIPIAxq -IglzQRR3IgtqIgUgD3NBGHciDyAJaiIJaiIMc0EUdyIRaiITIAJqIB4gECAYc0EYdyICIBRqIh4g -F3NBGXciECAOIB9qaiIfaiAPIB9zQRB3Ig8gCGoiHyAQc0EUdyIIaiIOIA9zQRh3Ig8gH2oiHyAI -c0EZdyIIaiIQIBxqIBAgASAJIAtzQRl3IgEgEiAZamoiGWogASACIBlzQRB3IgEgBiAVaiICaiIV -c0EUdyIZaiIcIAFzQRh3IgFzQRB3IgkgAiAHc0EZdyICIAQgBWpqIgQgI2ogAiAEIApzQRB3IgIg -HmoiBHNBFHciI2oiHiACc0EYdyICIARqIgRqIgYgCHNBFHciCmoiCCAJc0EYdyIJIAZqIgYgASAV -aiIBIBlzQRl3IhUgHiAhamoiGSAiaiAVIA8gGXNBEHciFSANIBNzQRh3IhkgDGoiD2oiIXNBFHci -HmoiInM2AgwgACAbIA8gEXNBGXciDyAcICBqaiIcaiACIBxzQRB3IgIgH2oiGyAPc0EUdyIPaiIf -IAJzQRh3IgIgG2oiGyAkIAQgI3NBGXciBCAOIB1qaiIdaiAEIAEgGSAdc0EQdyIBaiIEc0EUdyIk -aiIdczYCCCAAIBUgInNBGHciFSAhaiIZIAhzNgIEIAAgASAdc0EYdyIBIARqIgQgH3M2AgAgACAE -ICRzQRl3IAJzNgIcIAAgBiAKc0EZdyAVczYCGCAAIA8gG3NBGXcgAXM2AhQgACAZIB5zQRl3IAlz -NgIQC5skAgl/AX4jAEEQayIIJAACfwJAAkACQAJAAkACQCAAQfUBTwRAQQAgAEHM/3tLDQcaIABB -C2oiAUF4cSEFQcCDwQAoAgAiCUUNBEEfIQdBACAFayEEIABB9P//B00EQCAFQQYgAUEIdmciAGt2 -QQFxIABBAXRrQT5qIQcLIAdBAnRBpIDBAGooAgAiAUUEQEEAIQAMAgtBACEAIAVBGSAHQQF2a0EA -IAdBH0cbdCEDA0ACQCABKAIEQXhxIgYgBUkNACAGIAVrIgYgBE8NACABIQIgBiIEDQBBACEEIAEh -AAwECyABKAIUIgYgACAGIAEgA0EddkEEcWooAhAiAUcbIAAgBhshACADQQF0IQMgAQ0ACwwBC0G8 -g8EAKAIAIgJBECAAQQtqQfgDcSAAQQtJGyIFQQN2IgB2IgFBA3EEQAJAIAFBf3NBAXEgAGoiBkED -dCIAQbSBwQBqIgMgAEG8gcEAaigCACIBKAIIIgRHBEAgBCADNgIMIAMgBDYCCAwBC0G8g8EAIAJB -fiAGd3E2AgALIAEgAEEDcjYCBCAAIAFqIgAgACgCBEEBcjYCBCABQQhqDAcLIAVBxIPBACgCAE0N -AwJAAkAgAUUEQEHAg8EAKAIAIgBFDQYgAGhBAnRBpIDBAGooAgAiAigCBEF4cSAFayEEIAIhAQNA -AkAgAigCECIADQAgAigCFCIADQAgASgCGCEHAkACQCABIAEoAgwiAEYEQCABQRRBECABKAIUIgAb -aigCACICDQFBACEADAILIAEoAggiAiAANgIMIAAgAjYCCAwBCyABQRRqIAFBEGogABshAwNAIAMh -BiACIgBBFGogAEEQaiAAKAIUIgIbIQMgAEEUQRAgAhtqKAIAIgINAAsgBkEANgIACyAHRQ0EAkAg -ASgCHEECdEGkgMEAaiICKAIAIAFHBEAgASAHKAIQRwRAIAcgADYCFCAADQIMBwsgByAANgIQIAAN -AQwGCyACIAA2AgAgAEUNBAsgACAHNgIYIAEoAhAiAgRAIAAgAjYCECACIAA2AhgLIAEoAhQiAkUN -BCAAIAI2AhQgAiAANgIYDAQLIAAoAgRBeHEgBWsiAiAEIAIgBEkiAhshBCAAIAEgAhshASAAIQIM -AAsACwJAQQIgAHQiA0EAIANrciABIAB0cWgiBkEDdCIBQbSBwQBqIgMgAUG8gcEAaigCACIAKAII -IgRHBEAgBCADNgIMIAMgBDYCCAwBC0G8g8EAIAJBfiAGd3E2AgALIAAgBUEDcjYCBCAAIAVqIgYg -ASAFayIDQQFyNgIEIAAgAWogAzYCAEHEg8EAKAIAIgQEQCAEQXhxQbSBwQBqIQFBzIPBACgCACEC -An9BvIPBACgCACIFQQEgBEEDdnQiBHFFBEBBvIPBACAEIAVyNgIAIAEMAQsgASgCCAshBCABIAI2 -AgggBCACNgIMIAIgATYCDCACIAQ2AggLQcyDwQAgBjYCAEHEg8EAIAM2AgAgAEEIagwIC0HAg8EA -QcCDwQAoAgBBfiABKAIcd3E2AgALAkACQCAEQRBPBEAgASAFQQNyNgIEIAEgBWoiAyAEQQFyNgIE -IAMgBGogBDYCAEHEg8EAKAIAIgZFDQEgBkF4cUG0gcEAaiEAQcyDwQAoAgAhAgJ/QbyDwQAoAgAi -BUEBIAZBA3Z0IgZxRQRAQbyDwQAgBSAGcjYCACAADAELIAAoAggLIQYgACACNgIIIAYgAjYCDCAC -IAA2AgwgAiAGNgIIDAELIAEgBCAFaiIAQQNyNgIEIAAgAWoiACAAKAIEQQFyNgIEDAELQcyDwQAg -AzYCAEHEg8EAIAQ2AgALIAFBCGoMBgsgACACckUEQEEAIQJBAiAHdCIAQQAgAGtyIAlxIgBFDQMg -AGhBAnRBpIDBAGooAgAhAAsgAEUNAQsDQCAAIAIgACgCBEF4cSIDIAVrIgYgBEkiBxshCSAAKAIQ -IgFFBEAgACgCFCEBCyACIAkgAyAFSSIAGyECIAQgBiAEIAcbIAAbIQQgASIADQALCyACRQ0AIAVB -xIPBACgCACIATSAEIAAgBWtPcQ0AIAIoAhghBwJAAkAgAiACKAIMIgBGBEAgAkEUQRAgAigCFCIA -G2ooAgAiAQ0BQQAhAAwCCyACKAIIIgEgADYCDCAAIAE2AggMAQsgAkEUaiACQRBqIAAbIQMDQCAD -IQYgASIAQRRqIABBEGogACgCFCIBGyEDIABBFEEQIAEbaigCACIBDQALIAZBADYCAAsgB0UNAgJA -IAIoAhxBAnRBpIDBAGoiASgCACACRwRAIAIgBygCEEcEQCAHIAA2AhQgAA0CDAULIAcgADYCECAA -DQEMBAsgASAANgIAIABFDQILIAAgBzYCGCACKAIQIgEEQCAAIAE2AhAgASAANgIYCyACKAIUIgFF -DQIgACABNgIUIAEgADYCGAwCCwJAAkACQAJAAkAgBUHEg8EAKAIAIgFLBEAgBUHIg8EAKAIAIgBP -BEAgBUGvgARqQYCAfHEiAkEQdkAAIQAgCEEEaiIBQQA2AgggAUEAIAJBgIB8cSAAQX9GIgIbNgIE -IAFBACAAQRB0IAIbNgIAQQAgCCgCBCIBRQ0JGiAIKAIMIQZB1IPBACAIKAIIIgRB1IPBACgCAGoi -ADYCAEHYg8EAIABB2IPBACgCACICIAAgAksbNgIAAkACQEHQg8EAKAIAIgIEQEGkgcEAIQADQCAB -IAAoAgAiAyAAKAIEIgdqRg0CIAAoAggiAA0ACwwCC0Hgg8EAKAIAIgBBACAAIAFNG0UEQEHgg8EA -IAE2AgALQeSDwQBB/x82AgBBsIHBACAGNgIAQaiBwQAgBDYCAEGkgcEAIAE2AgBBwIHBAEG0gcEA -NgIAQciBwQBBvIHBADYCAEG8gcEAQbSBwQA2AgBB0IHBAEHEgcEANgIAQcSBwQBBvIHBADYCAEHY -gcEAQcyBwQA2AgBBzIHBAEHEgcEANgIAQeCBwQBB1IHBADYCAEHUgcEAQcyBwQA2AgBB6IHBAEHc -gcEANgIAQdyBwQBB1IHBADYCAEHwgcEAQeSBwQA2AgBB5IHBAEHcgcEANgIAQfiBwQBB7IHBADYC -AEHsgcEAQeSBwQA2AgBBgILBAEH0gcEANgIAQfSBwQBB7IHBADYCAEH8gcEAQfSBwQA2AgBBiILB -AEH8gcEANgIAQYSCwQBB/IHBADYCAEGQgsEAQYSCwQA2AgBBjILBAEGEgsEANgIAQZiCwQBBjILB -ADYCAEGUgsEAQYyCwQA2AgBBoILBAEGUgsEANgIAQZyCwQBBlILBADYCAEGogsEAQZyCwQA2AgBB -pILBAEGcgsEANgIAQbCCwQBBpILBADYCAEGsgsEAQaSCwQA2AgBBuILBAEGsgsEANgIAQbSCwQBB -rILBADYCAEHAgsEAQbSCwQA2AgBByILBAEG8gsEANgIAQbyCwQBBtILBADYCAEHQgsEAQcSCwQA2 -AgBBxILBAEG8gsEANgIAQdiCwQBBzILBADYCAEHMgsEAQcSCwQA2AgBB4ILBAEHUgsEANgIAQdSC -wQBBzILBADYCAEHogsEAQdyCwQA2AgBB3ILBAEHUgsEANgIAQfCCwQBB5ILBADYCAEHkgsEAQdyC -wQA2AgBB+ILBAEHsgsEANgIAQeyCwQBB5ILBADYCAEGAg8EAQfSCwQA2AgBB9ILBAEHsgsEANgIA -QYiDwQBB/ILBADYCAEH8gsEAQfSCwQA2AgBBkIPBAEGEg8EANgIAQYSDwQBB/ILBADYCAEGYg8EA -QYyDwQA2AgBBjIPBAEGEg8EANgIAQaCDwQBBlIPBADYCAEGUg8EAQYyDwQA2AgBBqIPBAEGcg8EA -NgIAQZyDwQBBlIPBADYCAEGwg8EAQaSDwQA2AgBBpIPBAEGcg8EANgIAQbiDwQBBrIPBADYCAEGs -g8EAQaSDwQA2AgBB0IPBACABQQ9qQXhxIgBBCGsiAjYCAEG0g8EAQayDwQA2AgBByIPBACAEQShr -IgMgASAAa2pBCGoiADYCACACIABBAXI2AgQgASADakEoNgIEQdyDwQBBgICAATYCAAwICyACIANJ -IAEgAk1yDQAgACgCDCIDQQFxDQAgA0EBdiAGRg0DC0Hgg8EAQeCDwQAoAgAiACABIAAgAUkbNgIA -IAEgBGohA0GkgcEAIQACQAJAA0AgAyAAKAIAIgdHBEAgACgCCCIADQEMAgsLIAAoAgwiA0EBcQ0A -IANBAXYgBkYNAQtBpIHBACEAA0ACQCACIAAoAgAiA08EQCACIAMgACgCBGoiB0kNAQsgACgCCCEA -DAELC0HQg8EAIAFBD2pBeHEiAEEIayIDNgIAQciDwQAgBEEoayIJIAEgAGtqQQhqIgA2AgAgAyAA -QQFyNgIEIAEgCWpBKDYCBEHcg8EAQYCAgAE2AgAgAiAHQSBrQXhxQQhrIgAgACACQRBqSRsiA0Eb -NgIEQaSBwQApAgAhCiADQRBqQayBwQApAgA3AgAgAyAKNwIIQbCBwQAgBjYCAEGogcEAIAQ2AgBB -pIHBACABNgIAQayBwQAgA0EIajYCACADQRxqIQADQCAAQQc2AgAgAEEEaiIAIAdJDQALIAIgA0YN -ByADIAMoAgRBfnE2AgQgAiADIAJrIgBBAXI2AgQgAyAANgIAIABBgAJPBEAgAiAAEFMMCAsgAEH4 -AXFBtIHBAGohAQJ/QbyDwQAoAgAiA0EBIABBA3Z0IgBxRQRAQbyDwQAgACADcjYCACABDAELIAEo -AggLIQAgASACNgIIIAAgAjYCDCACIAE2AgwgAiAANgIIDAcLIAAgATYCACAAIAAoAgQgBGo2AgQg -AUEPakF4cUEIayICIAVBA3I2AgQgB0EPakF4cUEIayIEIAIgBWoiAGshBSAEQdCDwQAoAgBGDQMg -BEHMg8EAKAIARg0EIAQoAgQiAUEDcUEBRgRAIAQgAUF4cSIBEEggASAFaiEFIAEgBGoiBCgCBCEB -CyAEIAFBfnE2AgQgACAFQQFyNgIEIAAgBWogBTYCACAFQYACTwRAIAAgBRBTDAYLIAVB+AFxQbSB -wQBqIQECf0G8g8EAKAIAIgNBASAFQQN2dCIEcUUEQEG8g8EAIAMgBHI2AgAgAQwBCyABKAIICyED -IAEgADYCCCADIAA2AgwgACABNgIMIAAgAzYCCAwFC0HIg8EAIAAgBWsiATYCAEHQg8EAQdCDwQAo -AgAiACAFaiICNgIAIAIgAUEBcjYCBCAAIAVBA3I2AgQgAEEIagwIC0HMg8EAKAIAIQACQCABIAVr -IgJBD00EQEHMg8EAQQA2AgBBxIPBAEEANgIAIAAgAUEDcjYCBCAAIAFqIgEgASgCBEEBcjYCBAwB -C0HEg8EAIAI2AgBBzIPBACAAIAVqIgM2AgAgAyACQQFyNgIEIAAgAWogAjYCACAAIAVBA3I2AgQL -IABBCGoMBwsgACAEIAdqNgIEQdCDwQBB0IPBACgCACIAQQ9qQXhxIgFBCGsiAjYCAEHIg8EAQciD -wQAoAgAgBGoiAyAAIAFrakEIaiIBNgIAIAIgAUEBcjYCBCAAIANqQSg2AgRB3IPBAEGAgIABNgIA -DAMLQdCDwQAgADYCAEHIg8EAQciDwQAoAgAgBWoiATYCACAAIAFBAXI2AgQMAQtBzIPBACAANgIA -QcSDwQBBxIPBACgCACAFaiIBNgIAIAAgAUEBcjYCBCAAIAFqIAE2AgALIAJBCGoMAwtBAEHIg8EA -KAIAIgAgBU0NAhpByIPBACAAIAVrIgE2AgBB0IPBAEHQg8EAKAIAIgAgBWoiAjYCACACIAFBAXI2 -AgQgACAFQQNyNgIEIABBCGoMAgtBwIPBAEHAg8EAKAIAQX4gAigCHHdxNgIACwJAIARBEE8EQCAC -IAVBA3I2AgQgAiAFaiIAIARBAXI2AgQgACAEaiAENgIAIARBgAJPBEAgACAEEFMMAgsgBEH4AXFB -tIHBAGohAQJ/QbyDwQAoAgAiA0EBIARBA3Z0IgRxRQRAQbyDwQAgAyAEcjYCACABDAELIAEoAggL -IQMgASAANgIIIAMgADYCDCAAIAE2AgwgACADNgIIDAELIAIgBCAFaiIAQQNyNgIEIAAgAmoiACAA -KAIEQQFyNgIECyACQQhqCyAIQRBqJAAL1QwCDX8BfiMAQaACayIHJAACQAJAAkACQAJAIAFBgAhN -BEAgB0EANgKIASABIAFBACABQYAIRxsiDGsiDkGACE8EQCAHQQE2AogBIAcgADYCjAFBASEKCyAH -QYwBaiELIAMhFCAFIQEjAEEgayIIJAAgBkEFdiIJIAogCSAKSRsiDQRAIARBAnIhDyAEQQFyIRAD -QCALKAIAIQkgCEEYaiIRIAJBGGopAgA3AwAgCEEQaiISIAJBEGopAgA3AwAgCEEIaiITIAJBCGop -AgA3AwAgCCACKQIANwMAIAggCUHAACAUIBAQKCAIIAlBQGtBwAAgFCAEECggCCAJQYABakHAACAU -IAQQKCAIIAlBwAFqQcAAIBQgBBAoIAggCUGAAmpBwAAgFCAEECggCCAJQcACakHAACAUIAQQKCAI -IAlBgANqQcAAIBQgBBAoIAggCUHAA2pBwAAgFCAEECggCCAJQYAEakHAACAUIAQQKCAIIAlBwARq -QcAAIBQgBBAoIAggCUGABWpBwAAgFCAEECggCCAJQcAFakHAACAUIAQQKCAIIAlBgAZqQcAAIBQg -BBAoIAggCUHABmpBwAAgFCAEECggCCAJQYAHakHAACAUIAQQKCAIIAlBwAdqQcAAIBQgDxAoIAFB -GGogESkDADcAACABQRBqIBIpAwA3AAAgAUEIaiATKQMANwAAIAEgCCkDADcAACALQQRqIQsgAUEg -aiEBIBRCAXwhFCANQQFrIg0NAAsLIAhBIGokACAMRQ0BIAdByAFqQgA3AwAgB0HAAWpCADcDACAH -QbgBakIANwMAIAdBsAFqQgA3AwAgB0GoAWpCADcDACAHQaABakIANwMAIAdBmAFqQgA3AwAgB0HY -AWoiASACQQhqKQIANwMAIAdB4AFqIgggAkEQaikCADcDACAHQegBaiIJIAJBGGopAgA3AwAgB0IA -NwOQASAHIAQ6APoBIAdBADsB+AEgByACKQIANwPQASAHIAMgCq18NwPwASAHQZABaiAAIA5qIAwQ -QyEAIAdB0ABqIAEpAwA3AwAgB0HYAGogCCkDADcDACAHQeAAaiAJKQMANwMAIAdBEGogAEEIaikD -ADcDACAHQRhqIABBEGopAwA3AwAgB0EgaiAAQRhqKQMANwMAIAdBKGogAEEgaikDADcDACAHQTBq -IABBKGopAwA3AwAgB0E4aiAAQTBqKQMANwMAIAdBQGsgAEE4aikDADcDACAHIAcpA9ABNwNIIAcg -ACkDADcDCCAHLQD6ASEAIActAPkBIQIgByAHLQD4ASIEOgBwIAcgBykD8AEiAzcDaCAHIAAgAkVy -QQJyIgA6AHEgB0GYAmoiAiAJKQMANwMAIAdBkAJqIgkgCCkDADcDACAHQYgCaiIIIAEpAwA3AwAg -ByAHKQPQATcDgAIgB0GAAmogB0EIaiAEIAMgABAoIApBBXQiAEEgaiIBIAZLDQIgAigCACEBIAko -AgAhAiAIKAIAIQQgBygClAIhBiAHKAKMAiEIIAcoAoQCIQkgBygCgAIhCyAAIAVqIgAgBygCnAI2 -ABwgACABNgAYIAAgBjYAFCAAIAI2ABAgACAINgAMIAAgBDYACCAAIAk2AAQgACALNgAAIApBAWoh -CgwBCyABQn8gAa1CAXxCAYhCAX15iKciCE0NAiAHQQhqIglBAEGAAfwLACAAIAhBAWoiCCACIAMg -BCAJQSBBwAAgCEGACEYbIgoQKiELIAAgCGogASAIayACIAMgCEEKdq18IAQgCSAKakGAASAKaxAq -IAtBAUYEQCAGQT9NDQQgBSAHKQAINwAAIAVBOGogB0FAaykAADcAACAFQTBqIAdBOGopAAA3AAAg -BUEoaiAHQTBqKQAANwAAIAVBIGogB0EoaikAADcAACAFQRhqIAdBIGopAAA3AAAgBUEQaiAHQRhq -KQAANwAAIAVBCGogB0EQaikAADcAAEECIQoMAQsgC2pBBXQiAEGBAU8NBCAHQQhqIAAgAiAEIAUg -BhA9IQoLIAdBoAJqJAAgCg8LIAEgBkGAusAAEMwBAAsgB0EANgIYIAdBATYCDCAHQYi5wAA2Aggg -B0IENwIQIAdBCGpB0LrAABCaAQALQcAAIAZB4LrAABDMAQALIABBgAFB8LrAABDMAQAL8ggCBX8D -fgJAAkACQCABQQhPBEAgAUEHcSICRQ0BIAAoAqABIgNBKU8NAiADRQRAIABBADYCoAEMAgsgA0EB -a0H/////A3EiBUEBaiIEQQNxIQYgAkECdEGg48AAaigCACACdq0hCQJAIAVBA0kEQCAAIQIMAQsg -BEH8////B3EhBSAAIQIDQCACIAI1AgAgCX4gCHwiBz4CACACQQRqIgQgBDUCACAJfiAHQiCIfCIH -PgIAIAJBCGoiBCAENQIAIAl+IAdCIIh8Igc+AgAgAkEMaiIEIAQ1AgAgCX4gB0IgiHwiBz4CACAH -QiCIIQggAkEQaiECIAVBBGsiBQ0ACwsgBgRAA0AgAiACNQIAIAl+IAh8Igc+AgAgAkEEaiECIAdC -IIghCCAGQQFrIgYNAAsLIAAgB0KAgICAEFoEfyADQShGDQQgACADQQJ0aiAIPgIAIANBAWoFIAML -NgKgAQwBCyAAKAKgASIDQSlPDQEgA0UEQCAAQQA2AqABDwsgAUECdEGg48AAajUCACEJIANBAWtB -/////wNxIgFBAWoiAkEDcSEGAkAgAUEDSQRAIAAhAgwBCyACQfz///8HcSEFIAAhAgNAIAIgAjUC -ACAJfiAIfCIHPgIAIAJBBGoiASABNQIAIAl+IAdCIIh8Igc+AgAgAkEIaiIBIAE1AgAgCX4gB0Ig -iHwiBz4CACACQQxqIgEgATUCACAJfiAHQiCIfCIHPgIAIAdCIIghCCACQRBqIQIgBUEEayIFDQAL -CyAGBEADQCACIAI1AgAgCX4gCHwiBz4CACACQQRqIQIgB0IgiCEIIAZBAWsiBg0ACwsgACAHQoCA -gIAQWgR/IANBKEYNAyAAIANBAnRqIAg+AgAgA0EBagUgAws2AqABDwsCQCABQQhxBEAgACgCoAEi -A0EpTw0CAkAgA0UEQEEAIQMMAQsgA0EBa0H/////A3EiAkEBaiIFQQNxIQYCQCACQQNJBEBCACEH -IAAhAgwBCyAFQfz///8HcSEFQgAhByAAIQIDQCACIAI1AgBC4esXfiAHfCIHPgIAIAJBBGoiBCAE -NQIAQuHrF34gB0IgiHwiBz4CACACQQhqIgQgBDUCAELh6xd+IAdCIIh8Igc+AgAgAkEMaiIEIAQ1 -AgBC4esXfiAHQiCIfCIIPgIAIAhCIIghByACQRBqIQIgBUEEayIFDQALCyAGBEADQCACIAI1AgBC -4esXfiAHfCIIPgIAIAJBBGohAiAIQiCIIQcgBkEBayIGDQALCyAIQoCAgIAQVA0AIANBKEYNAiAA -IANBAnRqIAc+AgAgA0EBaiEDCyAAIAM2AqABCyABQRBxBEAgAEGQ0MAAQQIQMAsgAUEgcQRAIABB -mNDAAEEDEDALIAFBwABxBEAgAEGk0MAAQQUQMAsgAUGAAXEEQCAAQbjQwABBChAwCyABQYACcQRA -IABB4NDAAEETEDALIAAgARAsGg8LDAELIANBKEHA+sAAEMwBAAtBKEEoQcD6wAAQfQALywgBCH8C -QCABQYAKSQRAIAFBBXYhBwJAAkAgACgCoAEiBQRAIAVBAWshAyAFQQJ0IABqQQRrIQIgBSAHakEC -dCAAakEEayEGIAVBKUkhBQNAIAVFDQIgAyAHaiIEQShPDQMgBiACKAIANgIAIAZBBGshBiACQQRr -IQIgA0EBayIDQX9HDQALCyABQSBJDQMgAEEANgIAIAdBAWoiAkECRg0DIABBADYCBCACQQNGDQMg -AEEANgIIIAJBBEYNAyAAQQA2AgwgAkEFRg0DIABBADYCECACQQZGDQMgAEEANgIUIAJBB0YNAyAA -QQA2AhggAkEIRg0DIABBADYCHCACQQlGDQMgAEEANgIgIAJBCkYNAyAAQQA2AiQgAkELRg0DIABB -ADYCKCACQQxGDQMgAEEANgIsIAJBDUYNAyAAQQA2AjAgAkEORg0DIABBADYCNCACQQ9GDQMgAEEA -NgI4IAJBEEYNAyAAQQA2AjwgAkERRg0DIABBADYCQCACQRJGDQMgAEEANgJEIAJBE0YNAyAAQQA2 -AkggAkEURg0DIABBADYCTCACQRVGDQMgAEEANgJQIAJBFkYNAyAAQQA2AlQgAkEXRg0DIABBADYC -WCACQRhGDQMgAEEANgJcIAJBGUYNAyAAQQA2AmAgAkEaRg0DIABBADYCZCACQRtGDQMgAEEANgJo -IAJBHEYNAyAAQQA2AmwgAkEdRg0DIABBADYCcCACQR5GDQMgAEEANgJ0IAJBH0YNAyAAQQA2Angg -AkEgRg0DIABBADYCfCACQSFGDQMgAEEANgKAASACQSJGDQMgAEEANgKEASACQSNGDQMgAEEANgKI -ASACQSRGDQMgAEEANgKMASACQSVGDQMgAEEANgKQASACQSZGDQMgAEEANgKUASACQSdGDQMgAEEA -NgKYASACQShGDQMgAEEANgKcASACQSlGDQNBKEEoQcD6wAAQfQALIANBKEHA+sAAEH0ACyAEQShB -wPrAABB9AAtB6vrAAEEdQcD6wAAQkQEACyAAKAKgASIDIAdqIQIgAUEfcSIGRQRAIAAgAjYCoAEg -AA8LAkAgAkEBayIEQSdNBEAgAiEFIAAgBEECdGooAgBBACABayIBdiIERQ0BIAJBJ00EQCAAIAJB -AnRqIAQ2AgAgAkEBaiEFDAILIAJBKEHA+sAAEH0ACyAEQShBwPrAABB9AAsCQCAHQQFqIgggAk8N -ACABQR9xIQEgA0EBcUUEQCAAIAJBAWsiAkECdGoiBCAEKAIAIAZ0IARBBGsoAgAgAXZyNgIACyAD -QQJGDQAgAkECdCAAakEMayEDA0AgA0EIaiIEIAQoAgAgBnQgA0EEaiIEKAIAIgkgAXZyNgIAIAQg -CSAGdCADKAIAIAF2cjYCACADQQhrIQMgCCACQQJrIgJJDQALCyAAIAdBAnRqIgEgASgCACAGdDYC -ACAAIAU2AqABIAALiAoDDH8BfgFvQcyRwAAhAyMAQdAAayICJAAgAiABNgIMAkACQAJAAkAgARDq -AUEBRgRAIAIgATYCICACQQA2AhAgAkHMkcAANgIYIAJB3JHAADYCHCACQSBqIQpBgICAgHghAQNA -IAIgA0EIajYCGCACIAMoAgAgAygCBBA5NgI4IAooAgAlASACQThqKAIAJQEQDSEPEG0iBSAPJgEC -QAJAAkACQAJAAkAgBSUBEAFBAUYEQCACKAI4JQEgAigCICUBEAJBAUcNAQsCQCACKAIQRQ0AIAIo -AhQiB0GEAUkNACAHEGoLIAIgBTYCFCACQQE2AhAgAygCACEFAn8CQAJAAkAgAygCBEEEaw4DAQIA -AgtBACEHQQYhCEHDkcAAIQMCQANAIAUtAAAiCyADLQAAIgxGBEAgBUEBaiEFIANBAWohAyAIQQFr -IggNAQwCCwsgCyAMayEHCyAHDQFBAQwCC0EAIAUoAABBv5HAACgAAEYNARoLQQILIAIoAjgiBUGD -AUsEQCAFEGoLQQFrDgIDAQILIAVBhAFPBEAgBRBqCyACKAI4IgNBhAFPBEAgAxBqCyACKAIYIgMg -AigCHEcNBQwHCyACKAIQIAJBADYCEEEBRgRAIAIoAhQiA0GEAUkNBCADEGoMBAsMCQsgAUGAgICA -eEcEQEHBhMAAQQQQgQEhBAwCCyACKAIQIAJBADYCEEEBRw0IIAIgAigCFCIBNgI4IAIgARDmAQJA -IAIoAgAiBgRAIAIoAgQiASENDAELIAJBOGogAkHPAGpByIPAABA+IQZBgICAgHghAQsgAigCOCID -QYQBTwRAIAMQagsgAUGAgICAeEcNAiAAQYCAgIB4NgIAIAAgBjYCBAwGCyAJRQRAIAIoAhAgAkEA -NgIQQQFHDQggAiACKAIUNgIkIAJBKGoiBCACQSRqIgMoAgAlARAeBH4gBCADKAIAJQEQCvwGNwMI -QgEFQgALNwMAAn8CQCACKAIoQQFGBEAgAikDMCIOQgBZDQELIAJBJGogAkHPAGpBmILAABA+IQRB -AQwBCyAOQoCAgIAQWgRAIAJBAToAOCACIA43A0AjAEEwayIDJAAgA0GYgsAANgIEIAMgAkHPAGo2 -AgAgA0ECNgIMIANB9InAADYCCCADQgI3AhQgAyADrUKAgICAsAGENwMoIAMgAkE4aq1CgICAgMAB -hDcDICADIANBIGo2AhAgA0EIahBhIQQgA0EwaiQAQQEMAQsgDqchBEEACyACKAIkIgVBhAFPBEAg -BRBqC0EBIQlFDQIMAQtBxYTAAEEGEIEBIQQLIABBgICAgHg2AgAgACAENgIEIAFBgICAgHhyQYCA -gIB4Rg0EIAYgARDHAQwECyACKAIYIgMgAigCHEcNAAsMAQsgAkEMaiACQc8AakG4g8AAED4hBCAA -QYCAgIB4NgIAIAAgBDYCBCABQYQBSQ0CIAEQagwCCyABQYCAgIB4RwRAIAkEQCAAIAQ2AgwgACAN -NgIIIAAgBjYCBCAAIAE2AgAMAgtBxYTAAEEGEIABIQQgAEGAgICAeDYCACAAIAQ2AgQgAUUNASAG -IAEQxwEMAQtBwYTAAEEEEIABIQEgAEGAgICAeDYCACAAIAE2AgQLIAIoAiAiAEGEAU8EQCAAEGoL -IAIoAhBFDQAgAigCFCIAQYMBTQ0AIAAQagsgAkHQAGokAA8LQZCEwABBMRDeAQALzwYBCH8CQAJA -IAEgAEEDakF8cSIDIABrIghJDQAgASAIayIGQQRJDQAgBkEDcSEHQQAhAQJAIAAgA0YiCQ0AAkAg -ACADayIFQXxLBEBBACEDDAELQQAhAwNAIAEgACADaiICLAAAQb9/SmogAkEBaiwAAEG/f0pqIAJB -AmosAABBv39KaiACQQNqLAAAQb9/SmohASADQQRqIgMNAAsLIAkNACAAIANqIQIDQCABIAIsAABB -v39KaiEBIAJBAWohAiAFQQFqIgUNAAsLIAAgCGohAAJAIAdFDQAgACAGQXxxaiIDLAAAQb9/SiEE -IAdBAUYNACAEIAMsAAFBv39KaiEEIAdBAkYNACAEIAMsAAJBv39KaiEECyAGQQJ2IQUgASAEaiEE -A0AgACEDIAVFDQJBwAEgBSAFQcABTxsiBkEDcSEHIAZBAnQhCEEAIQIgBUEETwRAIAAgCEHwB3Fq -IQkgACEBA0AgASgCACIAQX9zQQd2IABBBnZyQYGChAhxIAJqIAFBBGooAgAiAEF/c0EHdiAAQQZ2 -ckGBgoQIcWogAUEIaigCACIAQX9zQQd2IABBBnZyQYGChAhxaiABQQxqKAIAIgBBf3NBB3YgAEEG -dnJBgYKECHFqIQIgAUEQaiIBIAlHDQALCyAFIAZrIQUgAyAIaiEAIAJBCHZB/4H8B3EgAkH/gfwH -cWpBgYAEbEEQdiAEaiEEIAdFDQALAn8gAyAGQfwBcUECdGoiACgCACIBQX9zQQd2IAFBBnZyQYGC -hAhxIgEgB0EBRg0AGiABIAAoAgQiAUF/c0EHdiABQQZ2ckGBgoQIcWoiASAHQQJGDQAaIAAoAggi -AEF/c0EHdiAAQQZ2ckGBgoQIcSABagsiAUEIdkH/gRxxIAFB/4H8B3FqQYGABGxBEHYgBGoPCyAB -RQRAQQAPCyABQQNxIQMCQCABQQRJBEAMAQsgAUF8cSEFA0AgBCAAIAJqIgEsAABBv39KaiABQQFq -LAAAQb9/SmogAUECaiwAAEG/f0pqIAFBA2osAABBv39KaiEEIAUgAkEEaiICRw0ACwsgA0UNACAA -IAJqIQEDQCAEIAEsAABBv39KaiEEIAFBAWohASADQQFrIgMNAAsLIAQLyQcCCn8CfiMAQTBrIgYk -AAJAAkACQAJAAkACQAJAIANFDQACfyABKAIYIgcgASgCKCIFQUBrTQRAIAEoAhwgBWsiByADIAMg -B0sbIQhBACEHIAFBHGoMAQsgASgCHCAFayIJIAMgAyAJSxshCCAJIAMgByAFa0HBAGsiByADIAdJ -GyIHSQ0CIAUgB2ohBSABQRxqCyEJIAZBCGohCiACIAdqIQ0gCCAHayELIAEpAxAhEEEAIQggASkD -ACEPIAEoAgghDgNAAkAgCCALRgRAQQAhDAwBCyABIA4gCCANai0AAEEDdGopAwAgD0IBhnwiDzcD -AEEBIQwgCEEBaiEIIA8gEINCAFINAQsLIAogCDYCBCAKIAw2AgACQAJAIAYoAghBAXEEQCAJKAIA -IgggBigCDCIEIAVqTQ0BDAILIAkoAgAiCCAFIAtqSw0CCyAIIAVrIQQLIAFCADcDACAEIAdqIQUg -ASgCKCIHRQRAIAMgBUkNAyAGQSBqIAIgBRB1DAYLIAMgBUkNAyABQSBqIQMgASgCICAHayAFSQRA -IAMgByAFEFYgASgCKCEHCyAFBEAgASgCJCAHaiACIAX8CgAACyABIAUgB2o2AiggBkEYaiADQQhq -KAIANgIAIAFBADYCKCADKQIAIQ8gAUKAgICAEDcDICAGIA83AxAgBkEgaiAGQRBqEHIMBQsgBEUE -QCABKAIgIAEoAigiBWsgA0kEQCABQSBqIAUgAxBWIAEoAighBQsgAwRAIAEoAiQgBWogAiAD/AoA -AAsgACADNgIwIABBADYCACABIAMgBWo2AigMBgsgASgCKCIFRQ0DIAFBIGohBCABKAIgIAVrIANJ -BEAgBCAFIAMQViABKAIoIQULIAMEQCABKAIkIAVqIAIgA/wKAAALIAEgAyAFajYCKCAGQRhqIARB -CGooAgA2AgAgAUEANgIoIAQpAgAhDyABQoCAgIAQNwMgIAYgDzcDECAGQSBqIAZBEGoQciADIQUM -BAsgByAIQaibwAAQzQEACyAFIANBuJvAABDMAQALIAUgA0HIm8AAEMwBAAsgBkEgaiACIAMQdSAD -IQULIAZBGGogBkEoaikCACIPNwMAIAYgBikCIDcDECAPpyIBRQRAIABBADYCMCAAQQA2AgAgBkEc -aiAGKAIUQQAgBigCECgCEBEDAAwBCyAGKAIQIQIgBigCHCEDIABBEGpBtLjAACAGKAIUIgQgARAx -IAAgBTYCMCAAIAM2AgwgACABNgIIIAAgBDYCBCAAIAI2AgALIAZBMGokAAvYBQIMfwN+IwBBoAFr -IgkkACAJQQBBoAH8CwACQAJAAkAgAiAAKAKgASIFTQRAIAVBKU8NASABIAJBAnRqIQwCQAJAIAUE -QCAFQQFqIQ0gBUECdCEKA0AgCSAGQQJ0aiEDA0AgBiECIAMhBCABIAxGDQggA0EEaiEDIAJBAWoh -BiABKAIAIQcgAUEEaiILIQEgB0UNAAsgB60hEUIAIQ8gCiEHIAIhASAAIQMDQCABQShPDQQgBCAP -IAQ1AgB8IAM1AgAgEX58IhA+AgAgEEIgiCEPIARBBGohBCABQQFqIQEgA0EEaiEDIAdBBGsiBw0A -CyAIIBBCgICAgBBaBH8gAiAFaiIBQShPDQMgCSABQQJ0aiAPPgIAIA0FIAULIAJqIgEgASAISRsh -CCALIQEMAAsACwNAIAEgDEYNBiAEQQFqIQQgASgCACABQQRqIQFFDQAgCCAEQQFrIgIgAiAISRsh -CAwACwALIAFBKEHA+sAAEH0ACyABQShBwPrAABB9AAsgBUEpTw0BIAJBAnQhDCACQQFqIQ0gACAF -QQJ0aiEOIAAhAwJAA0AgCSAHQQJ0aiEGA0AgByELIAYhBCADIA5GDQUgBEEEaiEGIAdBAWohByAD -KAIAIQogA0EEaiIFIQMgCkUNAAsgCq0hEUIAIQ8gDCEKIAshAyABIQYDQCADQShPDQIgBCAPIAQ1 -AgB8IAY1AgAgEX58IhA+AgAgEEIgiCEPIARBBGohBCADQQFqIQMgBkEEaiEGIApBBGsiCg0ACwJA -IAggEEKAgICAEFoEfyACIAtqIgNBKE8NASAJIANBAnRqIA8+AgAgDQUgAgsgC2oiAyADIAhJGyEI -IAUhAwwBCwsgA0EoQcD6wAAQfQALIANBKEHA+sAAEH0ACyAFQShBwPrAABDMAQALIAVBKEHA+sAA -EMwBAAsgACAJQaAB/AoAACAAIAg2AqABIAlBoAFqJAAL5AgCCn8BfiMAQYACayIEJAAgBCABKQAY -NwIYIAQgASkAEDcCECAEIAEpAAg3AgggBCABKQAANwIAAn8gA0GBCE8EQCAEQSBqIQUjAEHgAGsi -ASQAIAFBOGoiBkIANwMAIAFBMGoiB0IANwMAIAFBKGoiCEIANwMAIAFBIGoiCUIANwMAIAFBGGoi -CkIANwMAIAFBEGoiC0IANwMAIAFBCGoiDEIANwMAIAFCADcDACACIAMgBEIAQRAgAUHAABAqIQMg -AUHYAGpCADcDACABQdAAakIANwMAIAFByABqQgA3AwAgAUIANwNAAkACQAJAAkAgA0EDTwRAA0Ag -A0EFdCICQcEATw0CIAEgAiAEQRAgAUFAayINQSAQPSIDQQV0IgJBwQBPDQMgAkEhTw0EIAIEQCAB -IA0gAvwKAAALIANBAksNAAsLIAUgASkDADcAACAFQThqIAYpAwA3AAAgBUEwaiAHKQMANwAAIAVB -KGogCCkDADcAACAFQSBqIAkpAwA3AAAgBUEYaiAKKQMANwAAIAVBEGogCykDADcAACAFQQhqIAwp -AwA3AAAgAUHgAGokAAwDCyACQcAAQYC7wAAQzAEACyACQcAAQZC7wAAQzAEACyACQSBBoLvAABDM -AQALIARB+ABqIARBGGopAgA3AwAgBEHwAGogBEEQaikCADcDACAEQegAaiAEQQhqKQIANwMAIAQg -BCkCADcDYEHAACEDQRQMAQsgBEHIAWpCADcDACAEQcABakIANwMAIARBuAFqQgA3AwAgBEGwAWpC -ADcDACAEQagBakIANwMAIARBmAFqQgA3AwAgBEEQOgD6ASAEQaABakIANwMAIARB2AFqIgUgBEEI -aikCADcDACAEQegBaiIGIARBGGopAgA3AwAgBEHgAWoiByAEQRBqKQIANwMAIARCADcDkAEgBCAE -KQIANwPQASAEQQA7AfgBIARCADcD8AEgBEGQAWogAiADEEMhASAEQegAaiAFKQMANwMAIARB8ABq -IAcpAwA3AwAgBEH4AGogBikDADcDACAEQShqIAFBCGopAwA3AwAgBEEwaiABQRBqKQMANwMAIARB -OGogAUEYaikDADcDACAEQUBrIAFBIGopAwA3AwAgBEHIAGogAUEoaikDADcDACAEQdAAaiABQTBq -KQMANwMAIARB2ABqIAFBOGopAwA3AwAgBCAEKQPQATcDYCAEIAEpAwA3AyAgBCkD8AEhDiAELQD4 -ASEDIAQtAPoBIAQtAPkBRXJBAnILIQEgBCAONwOAASAEIAM6AIgBIAQgAToAiQEgBEGoAWoiAiAE -QfgAaikDADcDACAEQaABaiIFIARB8ABqKQMANwMAIARBmAFqIgYgBEHoAGopAwA3AwAgBCAEKQNg -NwOQASAEQZABaiAEQSBqIANCACABQQhyECggACACKQMANwAYIAAgBSkDADcAECAAIAYpAwA3AAgg -ACAEKQOQATcAACAEQYACaiQAC74LAQV/IwBBIGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJA -IAEOKAYBAQEBAQEBAQIEAQEDAQEBAQEBAQEBAQEBAQEBAQEBAQEIAQEBAQcACyABQdwARg0ECyAC -QQFxRSABQf8FTXINBwJ/AkBBEUEAIAFBr7AETxsiAiACQQhyIgMgAUELdCICIANBAnRBjP7AAGoo -AgBBC3RJGyIDIANBBHIiAyADQQJ0QYz+wABqKAIAQQt0IAJLGyIDIANBAnIiAyADQQJ0QYz+wABq -KAIAQQt0IAJLGyIDIANBAWoiAyADQQJ0QYz+wABqKAIAQQt0IAJLGyIDIANBAWoiAyADQQJ0QYz+ -wABqKAIAQQt0IAJLGyIDQQJ0QYz+wABqKAIAQQt0IgUgAkYgAiAFS2ogA2oiA0EhTQRAIANBAnRB -jP7AAGoiBigCAEEVdiECQe8FIQUCfwJAIANBIUYNACAGKAIEQRV2IQUgAw0AQQAMAQsgBkEEaygC -AEH///8AcQshAwJAIAUgAkF/c2pFDQAgASADayEHQe8FIAIgAkHvBU0bIQYgBUEBayEDQQAhBQNA -IAIgBkYNAyAFIAJBwMnAAGotAABqIgUgB0sNASADIAJBAWoiAkcNAAsgAyECCyACQQFxDAILIANB -IkGA+sAAEH0ACyAGQe8FQZD6wAAQfQALRQ0HIARBADoACiAEQQA7AQggBCABQRR2QYfmwABqLQAA -OgALIAQgAUEEdkEPcUGH5sAAai0AADoADyAEIAFBCHZBD3FBh+bAAGotAAA6AA4gBCABQQx2QQ9x -QYfmwABqLQAAOgANIAQgAUEQdkEPcUGH5sAAai0AADoADCABQQFyZ0ECdiICIARBCGoiA2oiBUH7 -ADoAACAFQQFrQfUAOgAAIAMgAkECayICakHcADoAACAEQRBqIgMgAUEPcUGH5sAAai0AADoAACAA -QQo6AAsgACACOgAKIAAgBCkCCDcCACAEQf0AOgARIABBCGogAy8BADsBAAwJCyAAQYAEOwEKIABC -ADcBAiAAQdzoATsBAAwICyAAQYAEOwEKIABCADcBAiAAQdzkATsBAAwHCyAAQYAEOwEKIABCADcB -AiAAQdzcATsBAAwGCyAAQYAEOwEKIABCADcBAiAAQdy4ATsBAAwFCyAAQYAEOwEKIABCADcBAiAA -QdzgADsBAAwECyACQYACcUUNASAAQYAEOwEKIABCADcBAiAAQdzOADsBAAwDCyACQf///wdxQYCA -BE8NAQsCf0EAIAFBIEkNABpBASABQf8ASQ0AGiABQYCABE8EQCABQeD//wBxQeDNCkcgAUH+//8A -cUGe8ApHcSABQcDuCmtBeklxIAFBsJ0La0FySXEgAUHw1wtrQXFJcSABQYDwC2tB3mxJcSABQYCA -DGtBnnRJcSABQdCmDGtBe0lxIAFBgII4a0GwxVRJcSABQfCDOElxIAFBgIAITw0BGiABQazuwABB -LEGE78AAQdABQdTwwABB5gMQTgwBCyABQbr0wABBKEGK9cAAQaICQaz3wABBqQIQTgtFBEAgBEEA -OgAWIARBADsBFCAEIAFBFHZBh+bAAGotAAA6ABcgBCABQQR2QQ9xQYfmwABqLQAAOgAbIAQgAUEI -dkEPcUGH5sAAai0AADoAGiAEIAFBDHZBD3FBh+bAAGotAAA6ABkgBCABQRB2QQ9xQYfmwABqLQAA -OgAYIAFBAXJnQQJ2IgIgBEEUaiIDaiIFQfsAOgAAIAVBAWtB9QA6AAAgAyACQQJrIgJqQdwAOgAA -IARBHGoiAyABQQ9xQYfmwABqLQAAOgAAIABBCjoACyAAIAI6AAogACAEKQIUNwIAIARB/QA6AB0g -AEEIaiADLwEAOwEADAILIAAgATYCBCAAQYABOgAADAELIABBgAQ7AQogAEIANwECIABB3MQAOwEA -CyAEQSBqJAAL0wUCB38BfgJ/IAFFBEAgACgCCCEHQS0hCyAFQQFqDAELQStBgIDEACAAKAIIIgdB -gICAAXEiARshCyABQRV2IAVqCyEIAkAgB0GAgIAEcUUEQEEAIQIMAQsgA0EQTwRAIAIgAxAuIAhq -IQgMAQsgA0UNACADQQNxIQoCQCADQQRJBEBBACEBDAELIANBDHEhDEEAIQEDQCABIAIgCWoiBiwA -AEG/f0pqIAZBAWosAABBv39KaiAGQQJqLAAAQb9/SmogBkEDaiwAAEG/f0pqIQEgDCAJQQRqIglH -DQALCyAKBEAgAiAJaiEGA0AgASAGLAAAQb9/SmohASAGQQFqIQYgCkEBayIKDQALCyABIAhqIQgL -AkAgAC8BDCIJIAhLBEACQAJAIAdBgICACHFFBEAgCSAIayEJQQAhAUEAIQgCQAJAAkAgB0EddkED -cUEBaw4DAAEAAgsgCSEIDAELIAlB/v8DcUEBdiEICyAHQf///wBxIQogACgCBCEHIAAoAgAhAANA -IAFB//8DcSAIQf//A3FPDQJBASEGIAFBAWohASAAIAogBygCEBEAAEUNAAsMBAsgACAAKQIIIg2n -QYCAgP95cUGwgICAAnI2AghBASEGIAAoAgAiByAAKAIEIgogCyACIAMQlAENA0EAIQEgCSAIa0H/ -/wNxIQIDQCABQf//A3EgAk8NAiABQQFqIQEgB0EwIAooAhARAABFDQALDAMLQQEhBiAAIAcgCyAC -IAMQlAENAiAAIAQgBSAHKAIMEQEADQJBACEBIAkgCGtB//8DcSECA0AgAUH//wNxIgMgAkkhBiAC -IANNDQMgAUEBaiEBIAAgCiAHKAIQEQAARQ0ACwwCCyAHIAQgBSAKKAIMEQEADQEgACANNwIIQQAP -C0EBIQYgACgCACIBIAAoAgQiACALIAIgAxCUAQ0AIAEgBCAFIAAoAgwRAQAhBgsgBguEBgIBfwF8 -IwBBMGsiAiQAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgAC0AAEEBaw4R -AQIDBAUGBwgJCgsMDQ4PEBEACyACIAAtAAE6AAggAkECNgIUIAJB2LzAADYCECACQgE3AhwgAiAC -QQhqrUKAgICAwAiENwMoIAIgAkEoajYCGCABKAIAIAEoAgQgAkEQahA4DBELIAIgACkDCDcDCCAC -QQI2AhQgAkH0vMAANgIQIAJCATcCHCACIAJBCGqtQoCAgIDQCIQ3AyggAiACQShqNgIYIAEoAgAg -ASgCBCACQRBqEDgMEAsgAiAAKQMINwMIIAJBAjYCFCACQfS8wAA2AhAgAkIBNwIcIAIgAkEIaq1C -gICAgOAIhDcDKCACIAJBKGo2AhggASgCACABKAIEIAJBEGoQOAwPCyAAKwMIIQMgAkECNgIUIAJB -lL3AADYCECACQgE3AhwgAiACQShqrUKAgICA8AiENwMIIAIgAzkDKCACIAJBCGo2AhggASgCACAB -KAIEIAJBEGoQOAwOCyACIAAoAgQ2AgggAkECNgIUIAJBsL3AADYCECACQgE3AhwgAiACQQhqrUKA -gICAgAmENwMoIAIgAkEoajYCGCABKAIAIAEoAgQgAkEQahA4DA0LIAIgACkCBDcCCCACQQE2AhQg -AkHIvcAANgIQIAJCATcCHCACIAJBCGqtQoCAgICQCYQ3AyggAiACQShqNgIYIAEoAgAgASgCBCAC -QRBqEDgMDAsgAUHEvMAAQQoQtwEMCwsgAUHQvcAAQQoQtwEMCgsgAUHavcAAQQwQtwEMCQsgAUHm -vcAAQQ4QtwEMCAsgAUH0vcAAQQgQtwEMBwsgAUH8vcAAQQMQtwEMBgsgAUH/vcAAQQQQtwEMBQsg -AUGDvsAAQQwQtwEMBAsgAUGPvsAAQQ8QtwEMAwsgAUGevsAAQQ0QtwEMAgsgAUGrvsAAQQ4QtwEM -AQsgASAAKAIEIAAoAggQtwELIAJBMGokAAv+BQEFfyAAQQhrIgEgAEEEaygCACIDQXhxIgBqIQIC -QAJAIANBAXENACADQQJxRQ0BIAEoAgAiAyAAaiEAIAEgA2siAUHMg8EAKAIARgRAIAIoAgRBA3FB -A0cNAUHEg8EAIAA2AgAgAiACKAIEQX5xNgIEIAEgAEEBcjYCBCACIAA2AgAPCyABIAMQSAsCQAJA -AkACQAJAIAIoAgQiA0ECcUUEQCACQdCDwQAoAgBGDQIgAkHMg8EAKAIARg0DIAIgA0F4cSICEEgg -ASAAIAJqIgBBAXI2AgQgACABaiAANgIAIAFBzIPBACgCAEcNAUHEg8EAIAA2AgAPCyACIANBfnE2 -AgQgASAAQQFyNgIEIAAgAWogADYCAAsgAEGAAkkNAiABIAAQU0EAIQFB5IPBAEHkg8EAKAIAQQFr -IgA2AgAgAA0EQayBwQAoAgAiAARAA0AgAUEBaiEBIAAoAggiAA0ACwtB5IPBAEH/HyABIAFB/x9N -GzYCAA8LQdCDwQAgATYCAEHIg8EAQciDwQAoAgAgAGoiADYCACABIABBAXI2AgRBzIPBACgCACAB -RgRAQcSDwQBBADYCAEHMg8EAQQA2AgALIABB3IPBACgCACIDTQ0DQdCDwQAoAgAiAkUNA0EAIQBB -yIPBACgCACIEQSlJDQJBpIHBACEBA0AgAiABKAIAIgVPBEAgAiAFIAEoAgRqSQ0ECyABKAIIIQEM -AAsAC0HMg8EAIAE2AgBBxIPBAEHEg8EAKAIAIABqIgA2AgAgASAAQQFyNgIEIAAgAWogADYCAA8L -IABB+AFxQbSBwQBqIQICf0G8g8EAKAIAIgNBASAAQQN2dCIAcUUEQEG8g8EAIAAgA3I2AgAgAgwB -CyACKAIICyEAIAIgATYCCCAAIAE2AgwgASACNgIMIAEgADYCCA8LQayBwQAoAgAiAQRAA0AgAEEB -aiEAIAEoAggiAQ0ACwtB5IPBAEH/HyAAIABB/x9NGzYCACADIARPDQBB3IPBAEF/NgIACwvhBAEG -fwJAAkAgACgCCCIHQYCAgMABcUUNAAJAAkAgB0GAgICAAXFFBEAgAkEQSQ0BIAEgAhAuIQMMAgsC -QAJAIAAvAQ4iA0UEQEEAIQIMAQsgASACaiEIQQAhAiADIQUgASEEA0AgBCIGIAhGDQICfyAGQQFq -IAYsAAAiBEEATg0AGiAGQQJqIARBYEkNABogBkEDaiAEQXBJDQAaIAZBBGoLIgQgBmsgAmohAiAF -QQFrIgUNAAsLQQAhBQsgAyAFayEDDAELIAJFBEBBACECDAELIAJBA3EhBgJAIAJBBEkEQAwBCyAC -QQxxIQgDQCADIAEgBWoiBCwAAEG/f0pqIARBAWosAABBv39KaiAEQQJqLAAAQb9/SmogBEEDaiwA -AEG/f0pqIQMgCCAFQQRqIgVHDQALCyAGRQ0AIAEgBWohBANAIAMgBCwAAEG/f0pqIQMgBEEBaiEE -IAZBAWsiBg0ACwsgAyAALwEMIgRPDQAgBCADayEGQQAhA0EAIQUCQAJAAkAgB0EddkEDcUEBaw4C -AAECCyAGIQUMAQsgBkH+/wNxQQF2IQULIAdB////AHEhCCAAKAIEIQcgACgCACEAA0AgA0H//wNx -IAVB//8DcUkEQEEBIQQgA0EBaiEDIAAgCCAHKAIQEQAARQ0BDAMLC0EBIQQgACABIAIgBygCDBEB -AA0BQQAhAyAGIAVrQf//A3EhAQNAIANB//8DcSICIAFJIQQgASACTQ0CIANBAWohAyAAIAggBygC -EBEAAEUNAAsMAQsgACgCACABIAIgACgCBCgCDBEBACEECyAEC54EAQR/IwBBgAFrIgQkAAJAAkAC -QCABKAIIIgJBgICAEHFFBEAgAkGAgIAgcQ0BQQEhAiAAKAIAIAEQR0UNAgwDCyAAKAIAIQIDQCAD -IARqQf8AaiACQQ9xIgVBMHIgBUHXAGogBUEKSRs6AAAgA0EBayEDIAJBEEkgAkEEdiECRQ0AC0EB -IQIgAUEBQYnpwABBAiADIARqQYABakEAIANrEDNFDQEMAgsgACgCACECA0AgAyAEakH/AGogAkEP -cSIFQTByIAVBN2ogBUEKSRs6AAAgA0EBayEDIAJBD0sgAkEEdiECDQALQQEhAiABQQFBienAAEEC -IAMgBGpBgAFqQQAgA2sQMw0BCyABKAIAQYXmwABBAiABKAIEKAIMEQEADQACQCABKAIIIgJBgICA -EHFFBEAgAkGAgIAgcQ0BIAAoAgQgARBHIQIMAgsgACgCBCECQQAhAwNAIAMgBGpB/wBqIAJBD3Ei -AEEwciAAQdcAaiAAQQpJGzoAACADQQFrIQMgAkEPSyACQQR2IQINAAsgAUEBQYnpwABBAiADIARq -QYABakEAIANrEDMhAgwBCyAAKAIEIQJBACEDA0AgAyAEakH/AGogAkEPcSIAQTByIABBN2ogAEEK -SRs6AAAgA0EBayEDIAJBD0sgAkEEdiECDQALIAFBAUGJ6cAAQQIgAyAEakGAAWpBACADaxAzIQIL -IARBgAFqJAAgAgu9BAEIfyMAQRBrIgMkACADIAE2AgQgAyAANgIAIANCoICAgA43AggCfwJAAkAC -QCACKAIQIgkEQCACKAIUIgANAQwCCyACKAIMIgBFDQEgAigCCCIBIABBA3RqIQQgAEEBa0H///// -AXFBAWohBiACKAIAIQADQAJAIABBBGooAgAiBUUNACADKAIAIAAoAgAgBSADKAIEKAIMEQEARQ0A -QQEMBQtBASABKAIAIAMgAUEEaigCABEAAA0EGiAAQQhqIQAgBCABQQhqIgFHDQALDAILIABBGGwh -CiAAQQFrQf////8BcUEBaiEGIAIoAgghBCACKAIAIQADQAJAIABBBGooAgAiAUUNACADKAIAIAAo -AgAgASADKAIEKAIMEQEARQ0AQQEMBAtBACEHQQAhCAJAAkACQCAFIAlqIgFBCGovAQBBAWsOAgEC -AAsgAUEKai8BACEIDAELIAQgAUEMaigCAEEDdGovAQQhCAsCQAJAAkAgAS8BAEEBaw4CAQIACyAB -QQJqLwEAIQcMAQsgBCABQQRqKAIAQQN0ai8BBCEHCyADIAc7AQ4gAyAIOwEMIAMgAUEUaigCADYC -CEEBIAQgAUEQaigCAEEDdGoiASgCACADIAFBBGooAgARAAANAxogAEEIaiEAIAVBGGoiBSAKRw0A -CwwBCwsCQCAGIAIoAgRPDQAgAygCACACKAIAIAZBA3RqIgAoAgAgACgCBCADKAIEKAIMEQEARQ0A -QQEMAQtBAAsgA0EQaiQAC68VAhZ/A34jAEEQayIVJABBzP/AACgCAEUEQEHM/8AAKAIAIQRBzP/A -AEIBNwIAQdj/wAAoAgAhCkHU/8AAKAIAIQJB1P/AAEGImcAAKQIANwIAQeD/wAAoAgAhBUHc/8AA -QZCZwAApAgA3AgACQCAERSAKRXINACAFBEAgAkEIaiEIIAIpAwBCf4VCgIGChIiQoMCAf4MhGCAC -IQQDQCAYUARAA0AgBEHgAGshBCAIKQMAIAhBCGohCEKAgYKEiJCgwIB/gyIYQoCBgoSIkKDAgH9R -DQALIBhCgIGChIiQoMCAf4UhGAsgBCAYeqdBA3ZBdGxqQQRrKAIAIgNBhAFPBEAgAxBqCyAYQgF9 -IBiDIRggBUEBayIFDQALCyAKIApBDGxBE2pBeHEiA2pBCWoiBEUNACACIANrIAQQxwELCwJAAkBB -0P/AACgCAEUEQEHQ/8AAQX82AgBB2P/AACgCACIDIABxIQUgAEEZdiIWrUKBgoSIkKDAgAF+IRlB -1P/AACgCACECA0AgAiAFaikAACIaIBmFIhhCf4UgGEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIY -UEUEQANAIAAgAiAYeqdBA3YgBWogA3FBdGxqIgRBDGsoAgBGBEAgBEEIaygCACABRg0GCyAYQgF9 -IBiDIhhQRQ0ACwsgGiAaQgGGg0KAgYKEiJCgwIB/g1BFDQIgBSAHQQhqIgdqIANxIQUMAAsAC0Hw -mMAAEIkBAAtB3P/AACgCAEUEQCAVQQhqIRcjAEEgayIPJAACQAJAQeD/wAAoAgAiCEEBaiIEIAhP -BEACQEHY/8AAKAIAIgsgC0EBaiINQQN2IgJBB2wgC0EISRsiEkEBdiAESQRAIBJBAWoiAiAEIAIg -BEsbIgJBCEkNASACQf////8BTQRAQX8gAkEDdEEHbkEBa2d2QQFqIQQMBAsQiwEgDygCHCEEIA8o -AhghAgwEC0EAIQRB1P/AACgCACEJAkAgAiANQQdxQQBHaiIDRQ0AIANBAUcEQCADQf7///8DcSEC -A0AgBCAJaiIHIAcpAwAiGEJ/hUIHiEKBgoSIkKDAgAGDIBhC//79+/fv37//AIR8NwMAIAdBCGoi -ByAHKQMAIhhCf4VCB4hCgYKEiJCgwIABgyAYQv/+/fv379+//wCEfDcDACAEQRBqIQQgAkECayIC -DQALCyADQQFxRQ0AIAQgCWoiBCAEKQMAIhhCf4VCB4hCgYKEiJCgwIABgyAYQv/+/fv379+//wCE -fDcDAAsCQAJAIA1BCE8EQCAJIA1qIAkpAAA3AAAMAQsgDQRAIAlBCGogCSAN/AoAAAsgDUUNAQsg -CUEIaiEQIAlBDGshE0EBIQJBACEEA0AgBCEHIAIhBAJAIAcgCWoiFC0AAEGAAUcNACATIAdBdGxq -IQYCQANAIAYoAgAiAiAGKAIEIAIbIgogC3EiBSECIAUgCWopAABCgIGChIiQoMCAf4MiGVAEQEEI -IQMDQCACIANqIQIgA0EIaiEDIAkgAiALcSICaikAAEKAgYKEiJCgwIB/gyIZUA0ACwsgCSAZeqdB -A3YgAmogC3EiAmosAABBAE4EQCAJKQMAQoCBgoSIkKDAgH+DeqdBA3YhAgsgAiAFayAHIAVrcyAL -cUEISQ0BIAIgCWoiAy0AACADIApBGXYiAzoAACAQIAJBCGsgC3FqIAM6AAAgEyACQXRsaiEDQf8B -RwRAIAYtAAAhAiAGIAMtAAA6AAAgAyACOgAAIAYtAAEhAiAGIAMtAAE6AAEgAyACOgABIAYtAAIh -AiAGIAMtAAI6AAIgAyACOgACIAYtAAMhAiAGIAMtAAM6AAMgAyACOgADIAYtAAQhAiAGIAMtAAQ6 -AAQgAyACOgAEIAYtAAUhAiAGIAMtAAU6AAUgAyACOgAFIAYtAAYhAiAGIAMtAAY6AAYgAyACOgAG -IAYtAAchAiAGIAMtAAc6AAcgAyACOgAHIAYtAAghAiAGIAMtAAg6AAggAyACOgAIIAYtAAkhAiAG -IAMtAAk6AAkgAyACOgAJIAYtAAohAiAGIAMtAAo6AAogAyACOgAKIAYtAAshAiAGIAMtAAs6AAsg -AyACOgALDAELCyAUQf8BOgAAIBAgB0EIayALcWpB/wE6AAAgA0EIaiAGQQhqKAAANgAAIAMgBikA -ADcAAAwBCyAUIApBGXYiAjoAACAQIAdBCGsgC3FqIAI6AAALIAQgBCANSSIHaiECIAcNAAsLQdz/ -wAAgEiAIazYCAEGBgICAeCECDAMLQQRBCCACQQRJGyEEDAELEIsBIA8oAgQhBCAPKAIAIQIMAQsC -QAJAIAStQgx+IhhCIIinDQAgGKciAkF4Sw0AIAJBB2pBeHEiAyAEQQhqIgdqIgUgA0kgBUH4//// -B0tyDQBByf/AAC0AABogBUEIELsBIgINAUEIIAUQ4wEACxCLASAPKAIMIQQgDygCCCECDAELIAIg -A2ohDCAHBEAgDEH/ASAH/AsACyAEQQFrIhEgBEEDdkEHbCAEQQlJGyEQQdT/wAAoAgAhAyAIBEAg -DEEMayESIAxBCGohEyADQQxrIQkgAykDAEJ/hUKAgYKEiJCgwIB/gyEZIAMhAkEAIQQgCCEHA0Ag -GVAEQANAIARBCGohBCACQQhqIgIpAwBCgIGChIiQoMCAf4MiGEKAgYKEiJCgwIB/UQ0ACyAYQoCB -goSIkKDAgH+FIRkLIAwgCSAZeqdBA3YgBGoiFEF0bGoiCigCACIFIAooAgQgBRsiCiARcSIOaikA -AEKAgYKEiJCgwIB/gyIYUARAQQghBgNAIAYgDmohBSAGQQhqIQYgDCAFIBFxIg5qKQAAQoCBgoSI -kKDAgH+DIhhQDQALCyAZQgF9IBmDIRkgDCAYeqdBA3YgDmogEXEiDmosAABBAE4EQCAMKQMAQoCB -goSIkKDAgH+DeqdBA3YhDgsgDCAOaiAKQRl2IgU6AAAgEyAOQQhrIBFxaiAFOgAAIBIgDkF0bGoi -CkEIaiAJIBRBdGxqIgVBCGooAAA2AAAgCiAFKQAANwAAIAdBAWsiBw0ACwtB2P/AACARNgIAQdT/ -wAAgDDYCAEHc/8AAIBAgCGs2AgBBgYCAgHghAiALRQ0AIAsgDUEMbEEHakF4cSIEakEJaiIHRQ0A -IAMgBGsgBxDHAQsgFyACNgIAIBcgBDYCBCAPQSBqJAALIAAgARCyASEHQdT/wAAoAgAiCEHY/8AA -KAIAIgQgAHEiBWopAABCgIGChIiQoMCAf4MiGFAEQEEIIQMDQCADIAVqIQIgA0EIaiEDIAggAiAE -cSIFaikAAEKAgYKEiJCgwIB/gyIYUA0ACwsgCCAYeqdBA3YgBWogBHEiBWosAAAiA0EATgRAIAgg -CCkDAEKAgYKEiJCgwIB/g3qnQQN2IgVqLQAAIQMLIAUgCGogFjoAACAIIAVBCGsgBHFqQQhqIBY6 -AABB3P/AAEHc/8AAKAIAIANBAXFrNgIAQeD/wABB4P/AACgCAEEBajYCACAIIAVBdGxqIgRBBGsg -BzYCACAEQQhrIAE2AgAgBEEMayAANgIACyAEQQRrKAIAIQEQbSIAIAElASYBQdD/wABB0P/AACgC -AEEBajYCACAVQRBqJAAgAAuVBAEMfyABQQFrIQ4gACgCBCEKIAAoAgAhCyAAKAIIIQwCQANAIAUN -AQJ/AkAgAiADSQ0AA0AgASADaiEFAkACQAJAIAIgA2siB0EHTQRAIAIgA0cNASACIQMMBQsCQCAF -QQNqQXxxIgYgBWsiBARAQQAhAANAIAAgBWotAABBCkYNBSAEIABBAWoiAEcNAAsgBCAHQQhrIgBN -DQEMAwsgB0EIayEACwNAQYCChAggBigCACIJQYqUqNAAc2sgCXJBgIKECCAGQQRqKAIAIglBipSo -0ABzayAJcnFBgIGChHhxQYCBgoR4Rw0CIAZBCGohBiAEQQhqIgQgAE0NAAsMAQtBACEAA0AgACAF -ai0AAEEKRg0CIAcgAEEBaiIARw0ACyACIQMMAwsgBCAHRgRAIAIhAwwDCwNAIAQgBWotAABBCkYE -QCAEIQAMAgsgByAEQQFqIgRHDQALIAIhAwwCCyAAIANqIgZBAWohAwJAIAIgBk0NACAAIAVqLQAA -QQpHDQBBACEFIAMhBiADDAMLIAIgA08NAAsLIAIgCEYNAkEBIQUgCCEGIAILIQACQCAMLQAABEAg -C0H86MAAQQQgCigCDBEBAA0BC0EAIQQgACAIRwRAIAAgDmotAABBCkYhBAsgACAIayEAIAEgCGoh -ByAMIAQ6AAAgBiEIIAsgByAAIAooAgwRAQBFDQELC0EBIQ0LIA0LygQCB38BfiMAQRBrIgYkAAJA -IAAvAQwiBUUEQCAAKAIAIAAoAgQgARA8IQIMAQsgBiABKAIMIgQ2AgwgBiABKAIIIgI2AgggBiAB -KAIEIgM2AgQgBiABKAIAIgE2AgACQCAAKQIIIgmnIgdBgICACHEEQCAAKAIAIAEgAyAAKAIEKAIM -EQEADQEgACAHQYCAgP95cUGwgICAAnIiBzYCCCAGQgE3AgAgBSADQf//A3FrIgFBACABIAVNGyEF -QQAhAwsgBARAIARBDGwhCANAAn8CQAJAAkAgAi8BAEEBaw4CAgEACyACQQRqKAIADAILIAJBCGoo -AgAMAQsgAkECai8BACIEQegHTwRAQQRBBSAEQZDOAEkbDAELQQEgBEEKSQ0AGkECQQMgBEHkAEkb -CyACQQxqIQIgA2ohAyAIQQxrIggNAAsLAkACQCAFQf//A3EgA0sEQCAFIANrIQNBACECQQAhAQJA -AkACQCAHQR12QQNxQQFrDgMAAQACCyADIQEMAQsgA0H+/wNxQQF2IQELIAdB////AHEhCCAAKAIE -IQcgACgCACEEA0AgAkH//wNxIAFB//8DcU8NAiACQQFqIQIgBCAIIAcoAhARAABFDQALDAMLIAAo -AgAgACgCBCAGEDwhAgwBCyAEIAcgBhA8DQFBACEFIAMgAWtB//8DcSEBA0AgBUH//wNxIgMgAUkh -AiABIANNDQEgBUEBaiEFIAQgCCAHKAIQEQAARQ0ACwsgACAJNwIIDAELQQEhAgsgBkEQaiQAIAIL -/gMBCX8jAEEQayIEJAACfwJAIAIoAgQiA0UNACAAIAIoAgAgAyABKAIMEQEARQ0AQQEMAQsgAigC -DCIGBEAgAigCCCIDIAZBDGxqIQggBEEMaiEJA0ACQAJAAkACQCADLwEAQQFrDgICAQALAkAgAygC -BCICQcEATwRAIAFBDGooAgAhBgNAQQEgAEHT6sAAQcAAIAYRAQANCBogAkFAaiICQcAASw0ACwwB -CyACRQ0DCyAAQdPqwAAgAiABQQxqKAIAEQEARQ0CQQEMBQsgACADKAIEIAMoAgggAUEMaigCABEB -AEUNAUEBDAQLIAMvAQIhAiAJQQA6AAAgBEEANgIIAn9BBEEFIAJBkM4ASRsgAkHoB08NABpBASAC -QQpJDQAaQQJBAyACQeQASRsLIgYgBEEIaiIKaiIHQQFrIgUgAiACQQpuIgtBCmxrQTByOgAAAkAg -BSAKRg0AIAdBAmsiBSALQQpwQTByOgAAIARBCGogBUYNACAHQQNrIgUgAkHkAG5BCnBBMHI6AAAg -BEEIaiAFRg0AIAdBBGsiBSACQegHbkEKcEEwcjoAACAEQQhqIAVGDQAgB0EFayACQZDOAG5BMHI6 -AAALIAAgBEEIaiAGIAFBDGooAgARAQBFDQBBAQwDCyADQQxqIgMgCEcNAAsLQQALIARBEGokAAvM -BAEKfyMAQTBrIgYkAAJAAkACQAJ/QQAgAUFAcSIKRQ0AGiAGQQhqIAA2AgBBASAKQcAARg0AGiAG -IABBQGs2AgwgCkGAAUcNAUECCyEHIAFBP3EhASAFQQV2IgkgByAHIAlLGyIIBEAgBkEIaiEJIANB -BHIhCyAIQQV0IQxBACEDA0AgCSgCACEIIAZBKGoiDSACQRhqKQIANwMAIAZBIGoiDiACQRBqKQIA -NwMAIAZBGGoiDyACQQhqKQIANwMAIAYgAikCADcDECAGQRBqIAhBwABCACALECggAyAEaiIIQRhq -IA0pAwA3AAAgCEEQaiAOKQMANwAAIAhBCGogDykDADcAACAIIAYpAxA3AAAgCUEEaiEJIAwgA0Eg -aiIDRw0ACwsCQCABBEAgBSAHQQV0IgJJDQEgBSACayIDQR9NDQMgAUEgRw0EIAIgBGoiASAAIApq -IgApAAA3AAAgAUEYaiAAQRhqKQAANwAAIAFBEGogAEEQaikAADcAACABQQhqIABBCGopAAA3AAAg -B0EBaiEHCyAGQTBqJAAgBw8LIAIgBUGwusAAEMsBAAsgBiAAQYABajYCEEHou8AAQSsgBkEQakGU -vMAAQcC6wAAQegALQSAgA0GQusAAEMwBAAsjAEEwayIAJAAgAEEgNgIEIAAgATYCACAAQQM2Agwg -AEH0/cAANgIIIABCAjcCFCAAIABBBGqtQoCAgICQCoQ3AyggACAArUKAgICAkAqENwMgIAAgAEEg -ajYCECAAQQhqQaC6wAAQmgEAC4QEAgd/AXwjAEHQAGsiAyQAAkACQAJAAkACQCAAKAIAIgQlAUGB -ASUBEAdFBEAgBCUBEAgOAgIBAwsgA0EHOgAwIANBMGogASACEHwhAAwEC0EBIQYLQQEhB0EAIQAM -AQsgA0EQaiAEJQEQCSADKAIQBEAgAysDGCEKQQMhAEEBIQcMAQsgA0EIaiAEEOYBAn8gAygCCCIE -BEAgAygCDCIFIQZBBQwBCwJAAkAgACgCACUBECMEQCADQTBqIAAQcyADKAI4IQYgAygCNCEEIAMo -AjAhCAwBCyAAKAIAJQEQHUUNASADIAAoAgAQswEiBTYCSCADQTBqIANByABqEHMgAygCOCEGIAMo -AjQhBCADKAIwIQggBUGEAUkNACAFEGoLIAhBgICAgHhGDQBBASEHQQYMAQsgA0EBNgI0IANB/JfA -ADYCMCADQgE3AjwgAyAArUKAgICA4AOENwNIIAMgA0HIAGo2AjggA0EkaiADQTBqEERBgICAgHgh -CCADKAIsIQYgAygCKCEEIAMoAiQhBUERCyEAIAatvyEKIAchCQsgAyAKOQM4IAMgBDYCNCADIAY6 -ADEgAyAAOgAwIANBMGogASACEHwhAAJAIAlFBEAgByAFRXJFDQEMAgsgCARAIAQgCBDHAQsgBUUg -B3INAQsgBCAFEMcBCyADQdAAaiQAIAAL5AMBBX8jAEEQayIIJAACQAJAAkACQAJAIAEoAghBAUYE -QCABKAIAIQUgASgCBCEEIAFBDBDHAUEdQYEBIARBCnZnQQJ0ayAEQf//B0sbIQYgAiAFayIHIANq -IQMgAiAFRgRAIAYhAQwGCyAGQQV2IgIgB2oiAUGAgIDAAE8EQEHJ/8AALQAAGkEUQQQQuwEiAUUN -AiABQQE2AhAgASACIANqNgIIIAEgBSACazYCBCABIAIgBGo2AgAgASAGQQJ2QQdxNgIMDAULIAZB -HXEgAUEFdHIhAQwECyADQQBIDQECQCADRQRAQQEhBQwBC0HJ/8AALQAAGkEBIQQgA0EBELsBIgVF -DQILIAMEQCAFIAIgA/wKAAALIAEgASgCCCICQQFrNgIIIAJBAUYEQCABKAIAIAFBBGooAgAiBEEB -EK8BRQ0DIAQQxwEgAUEMEMcBC0EdQYEBIANBCnZnQQJ0ayADQf//B0sbIQEgAyEEDAQLQQRBFBDj -AQALIAQgA0Gws8AAEK4BAAtB7LTAAEErIAhBD2pB3LTAAEGotcAAEHoACyADIAdrIgJBACACIANN -GyEDIAQgB2shBCAFIAdqIQULIAAgATYCDCAAIAQ2AgggACADNgIEIAAgBTYCACAIQRBqJAAL3wgC -C38GfiMAQfAAayIEJAACQAJAIAEoAgQiAyABKAIMRwRAIAEgA0EQajYCBCADKAIMIQggAygCACEH -IAIoAgQhCSAEQShqIQYgAygCBCECQgEhEgJAAkACQAJAAkAgAygCCEHAAEcNAEEAIQEDQCABQcAA -RwRAIAEgAmoiAy0AACIFQTBrQf8BcUEKTwRAIAVBX3FBwQBrQf8BcUEFSw0DCyABQQJqIQEgA0EB -ai0AACIDQTBrQf8BcUEKSSADQV9xQcEAa0H/AXFBBklyDQEMAgsLIAIsABAiCkFASA0BIAJBEGoh -C0EPQRAgAi0AAEErRiIBGyEDIAEgAmohAQNAIAEtAAAiBUHBAGtBX3FBCmogBUEwayAFQTlLGyIF -QQ9LDQEgAUEBaiEBIAWtIA5CBIaEIQ4gA0EBayIDDQALIAIsACAiDEFASA0CIAJBIGohDSACQRFq -IAsgCkErRiIDGyEBQQ9BECADGyEDA0AgAS0AACIFQcEAa0FfcUEKaiAFQTBrIAVBOUsbIgVBD0sN -ASABQQFqIQEgBa0gD0IEhoQhDyADQQFrIgMNAAsgAiwAMCIKQUBIDQMgAkEwaiELIAJBIWogDSAM -QStGIgMbIQFBD0EQIAMbIQMDQCABLQAAIgVBwQBrQV9xQQpqIAVBMGsgBUE5SxsiBUEPSw0BIAFB -AWohASAFrSAQQgSGhCEQIANBAWsiAw0ACyACQTFqIAsgCkErRiIDGyEBQQ9BECADGyEDA0AgAS0A -ACIFQcEAa0FfcUEKaiAFQTBrIAVBOUsbIgVBD0sNASABQQFqIQEgBa0gEUIEhoQhESADQQFrIgMN -AAsgBiARNwMgIAYgEDcDGCAGIA83AxAgBiAONwMIQgAhEgsgBiASNwMADAMLIAJBwABBAEEQQYS4 -wAAQuQEACyACQcAAQRBBIEGUuMAAELkBAAsgAkHAAEEgQTBBpLjAABC5AQALAkAgBCgCKEEBRgRA -IARBADYCWCAEQoCAgIAQNwJQIARB0JTAADYCYCAEQqCAgIAONwJkIAQgBEHQAGo2AlwgBEHcAGoi -ASgCAEHEt8AAQR4gASgCBCgCDBEBAA0EIAQoAlAhASAEKAJUIgMgBCgCWBCyASEIIAEEQCADIAEQ -xwELIAcEQCACIAcQxwELIAlBBGohAQJAIAkoAgBFDQAgASgCACICQYQBSQ0AIAIQagsgCUEBNgIA -IAEgCDYCAAwBCyAEQSBqIARByABqKQMANwMAIARBGGogBEFAaykDADcDACAEQRBqIARBOGopAwA3 -AwAgBCAEKQMwNwMIQgEhEyAHRQ0AIAIgBxDHAQsgACATNwMAIAAgBCkDCDcDCCAAIAg2AiggAEEQ -aiAEQRBqKQMANwMAIABBGGogBEEYaikDADcDACAAQSBqIARBIGopAwA3AwAMAQsgAEICNwMACyAE -QfAAaiQADwtB+JTAAEE3IARB7wBqQeiUwABBpJbAABB6AAv5AwECfyAAIAFqIQICQAJAIAAoAgQi -A0EBcQ0AIANBAnFFDQEgACgCACIDIAFqIQEgACADayIAQcyDwQAoAgBGBEAgAigCBEEDcUEDRw0B -QcSDwQAgATYCACACIAIoAgRBfnE2AgQgACABQQFyNgIEIAIgATYCAAwCCyAAIAMQSAsCQAJAAkAg -AigCBCIDQQJxRQRAIAJB0IPBACgCAEYNAiACQcyDwQAoAgBGDQMgAiADQXhxIgIQSCAAIAEgAmoi -AUEBcjYCBCAAIAFqIAE2AgAgAEHMg8EAKAIARw0BQcSDwQAgATYCAA8LIAIgA0F+cTYCBCAAIAFB -AXI2AgQgACABaiABNgIACyABQYACTwRAIAAgARBTDwsgAUH4AXFBtIHBAGohAgJ/QbyDwQAoAgAi -A0EBIAFBA3Z0IgFxRQRAQbyDwQAgASADcjYCACACDAELIAIoAggLIQEgAiAANgIIIAEgADYCDCAA -IAI2AgwgACABNgIIDwtB0IPBACAANgIAQciDwQBByIPBACgCACABaiIBNgIAIAAgAUEBcjYCBCAA -QcyDwQAoAgBHDQFBxIPBAEEANgIAQcyDwQBBADYCAA8LQcyDwQAgADYCAEHEg8EAQcSDwQAoAgAg -AWoiATYCACAAIAFBAXI2AgQgACABaiABNgIACwuOAwEEfwJAAkACQAJAAkAgByAIVgRAIAcgCH0g -CFgNAQJAIAYgByAGfVQgByAGQgGGfSAIQgGGWnFFBEAgBiAIVg0BDAcLIAIgA0kNAwwFCyAHIAYg -CH0iBn0gBlYNBSACIANJDQMgASADaiEMIAEhCgJAAkADQCADIAlGDQEgCUEBaiEJIApBAWsiCiAD -aiILLQAAQTlGDQALIAsgCy0AAEEBajoAACADIAlrQQFqIANPDQEgCUEBayIFRQ0BIAtBAWpBMCAF -/AsADAELAkAgA0UEQEExIQkMAQsgAUExOgAAIANBAUYEQEEwIQkMAQtBMCEJIANBAWsiCkUNACAB -QQFqQTAgCvwLAAsgBEEBasEiBCAFwUwgAiADTXINACAMIAk6AAAgA0EBaiEDCyACIANPDQQgAyAC -QYjkwAAQzAEACyAAQQA2AgAPCyAAQQA2AgAPCyADIAJBmOTAABDMAQALIAMgAkH448AAEMwBAAsg -ACAEOwEIIAAgAzYCBCAAIAE2AgAPCyAAQQA2AgALpwMBAn8CQAJAAkACQCAALQBoIgMEQCADQcEA -Tw0DIAJBwAAgA2siBCACIARJGyIEBEAgACADaiABIAT8CgAACyAAIAAtAGggBGoiAzoAaCABIARq -IQEgAiAEayICRQRAQQAhAgwCCyAAQUBrIABBwAAgACkDYCAALQBqIAAtAGlFchAoIABCADcDACAA -QQA6AGggAEEIakIANwMAIABBEGpCADcDACAAQRhqQgA3AwAgAEEgakIANwMAIABBKGpCADcDACAA -QTBqQgA3AwAgAEE4akIANwMAIAAgAC0AaUEBajoAaQtBACEDIAJBwQBJDQEgAEFAayEEIAAtAGkh -AwNAIAQgAUHAACAAKQNgIAAtAGogA0H/AXFFchAoIAAgAC0AaUEBaiIDOgBpIAFBQGshASACQUBq -IgJBwABLDQALIAAtAGghAwsgA0H/AXEiA0HBAE8NAgsgAkHAACADayIEIAIgBEkbIgIEQCAAIANq -IAEgAvwKAAALIAAgAC0AaCACajoAaCAADwsgA0HAAEHwucAAEMsBAAsgA0HAAEHwucAAEMsBAAuP -AwEHfyMAQRBrIgQkAAJAAkACQAJAIAEoAgQiAgRAIAEoAgAhByACQQNxIQUCQCACQQRJBEBBACEC -DAELIAdBHGohAyACQXxxIQhBACECA0AgAygCACADQQhrKAIAIANBEGsoAgAgA0EYaygCACACampq -aiECIANBIGohAyAIIAZBBGoiBkcNAAsLIAUEQCAGQQN0IAdqQQRqIQMDQCADKAIAIAJqIQIgA0EI -aiEDIAVBAWsiBQ0ACwsgASgCDEUNAiACQQ9LDQEgBygCBA0BDAMLQQAhAiABKAIMRQ0CCyACQQAg -AkEAShtBAXQhAgtBACEFIAJBAE4EQCACRQ0BQcn/wAAtAAAaQQEhBSACQQEQuwEiAw0CCyAFIAJB -kMjAABCuAQALQQEhA0EAIQILIARBADYCCCAEIAM2AgQgBCACNgIAIARBkMfAACABEDhFBEAgACAE -KQIANwIAIABBCGogBEEIaigCADYCACAEQRBqJAAPC0GwyMAAQdYAIARBD2pBoMjAAEGgycAAEHoA -C+cCAQV/AkAgAUHN/3tBECAAIABBEE0bIgBrTw0AIABBECABQQtqQXhxIAFBC0kbIgRqQQxqECki -AkUNACACQQhrIQECQCAAQQFrIgMgAnFFBEAgASEADAELIAJBBGsiBSgCACIGQXhxIAIgA2pBACAA -a3FBCGsiAiAAQQAgAiABa0EQTRtqIgAgAWsiAmshAyAGQQNxBEAgACADIAAoAgRBAXFyQQJyNgIE -IAAgA2oiAyADKAIEQQFyNgIEIAUgAiAFKAIAQQFxckECcjYCACABIAJqIgMgAygCBEEBcjYCBCAB -IAIQQQwBCyABKAIAIQEgACADNgIEIAAgASACajYCAAsCQCAAKAIEIgFBA3FFDQAgAUF4cSICIARB -EGpNDQAgACAEIAFBAXFyQQJyNgIEIAAgBGoiASACIARrIgRBA3I2AgQgACACaiICIAIoAgRBAXI2 -AgQgASAEEEELIABBCGohAwsgAwvqAgIGfwJ+IwBBIGsiBSQAQRQhAyAAIglC6AdaBEAgCSEKA0Ag -BUEMaiADaiIEQQNrIAogCkKQzgCAIglCkM4Afn2nIgZB//8DcUHkAG4iB0EBdCIIQYzpwABqLQAA -OgAAIARBBGsgCEGL6cAAai0AADoAACAEQQFrIAYgB0HkAGxrQf//A3FBAXQiBkGM6cAAai0AADoA -ACAEQQJrIAZBi+nAAGotAAA6AAAgA0EEayEDIApC/6ziBFYgCSEKDQALCyAJQglWBEAgAyAFakEL -aiAJpyIEIARB//8DcUHkAG4iBEHkAGxrQf//A3FBAXQiBkGM6cAAai0AADoAACADQQJrIgMgBUEM -amogBkGL6cAAai0AADoAACAErSEJCyAAUEUgCVBxRQRAIANBAWsiAyAFQQxqaiAJp0EBdEEecUGM -6cAAai0AADoAAAsgAiABQQFBACAFQQxqIANqQRQgA2sQMyAFQSBqJAAL5gIBCH8jAEEQayIFJABB -CiECIAAiA0HoB08EQCADIQQDQCAFQQZqIAJqIgZBA2sgBCAEQZDOAG4iA0GQzgBsayIHQf//A3FB -5ABuIghBAXQiCUGM6cAAai0AADoAACAGQQRrIAlBi+nAAGotAAA6AAAgBkEBayAHIAhB5ABsa0H/ -/wNxQQF0IgdBjOnAAGotAAA6AAAgBkECayAHQYvpwABqLQAAOgAAIAJBBGshAiAEQf+s4gRLIAMh -BA0ACwsCQCADQQlNBEAgAyEEDAELIAIgBWpBBWogAyADQf//A3FB5ABuIgRB5ABsa0H//wNxQQF0 -IgNBjOnAAGotAAA6AAAgAkECayICIAVBBmpqIANBi+nAAGotAAA6AAALQQAgACAEG0UEQCACQQFr -IgIgBUEGamogBEEBdEEecUGM6cAAai0AADoAAAsgAUEBQQFBACAFQQZqIAJqQQogAmsQMyAFQRBq -JAALggMBBH8gACgCDCECAkACQAJAIAFBgAJPBEAgACgCGCEDAkACQCAAIAJGBEAgAEEUQRAgACgC -FCICG2ooAgAiAQ0BQQAhAgwCCyAAKAIIIgEgAjYCDCACIAE2AggMAQsgAEEUaiAAQRBqIAIbIQQD -QCAEIQUgASICQRRqIAJBEGogAigCFCIBGyEEIAJBFEEQIAEbaigCACIBDQALIAVBADYCAAsgA0UN -AgJAIAAoAhxBAnRBpIDBAGoiASgCACAARwRAIAMoAhAgAEYNASADIAI2AhQgAg0DDAQLIAEgAjYC -ACACRQ0EDAILIAMgAjYCECACDQEMAgsgACgCCCIAIAJHBEAgACACNgIMIAIgADYCCA8LQbyDwQBB -vIPBACgCAEF+IAFBA3Z3cTYCAA8LIAIgAzYCGCAAKAIQIgEEQCACIAE2AhAgASACNgIYCyAAKAIU -IgBFDQAgAiAANgIUIAAgAjYCGA8LDwtBwIPBAEHAg8EAKAIAQX4gACgCHHdxNgIAC+ACAQR/IwBB -EGsiAiQAAkAgAUGAAU8EQCACQQxqIgRBAnIhAyACQQA2AgwCQCABQYAQTwRAIARBA3IhBSABQYCA -BE8EQCACQRBqIQMgAiABQRJ2QfABcjoADCACIAFBBnZBP3FBgAFyOgAOIAIgAUEMdkE/cUGAAXI6 -AA0gBSEEDAILIAIgAUEMdkHgAXI6AAwgAiABQQZ2QT9xQYABcjoADSADIQQgBSEDDAELIAJBDGpB -AXIhBCACIAFBBnZBwAFyOgAMCyAEIAFBP3FBgAFyOgAAIAMgAkEMamsiASAAKAIAIAAoAggiA2tL -BEAgACADIAFBAUEBEFUgACgCCCEDCyABBEAgACgCBCADaiACQQxqIAH8CgAACyAAIAEgA2o2AggM -AQsgACgCCCIDIAAoAgBGBEAgAEHog8AAEG8LIAAoAgQgA2ogAToAACAAIANBAWo2AggLIAJBEGok -AEEAC+ACAQR/IwBBEGsiAiQAAkAgAUGAAU8EQCACQQxqIgRBAnIhAyACQQA2AgwCQCABQYAQTwRA -IARBA3IhBSABQYCABE8EQCACQRBqIQMgAiABQRJ2QfABcjoADCACIAFBBnZBP3FBgAFyOgAOIAIg -AUEMdkE/cUGAAXI6AA0gBSEEDAILIAIgAUEMdkHgAXI6AAwgAiABQQZ2QT9xQYABcjoADSADIQQg -BSEDDAELIAJBDGpBAXIhBCACIAFBBnZBwAFyOgAMCyAEIAFBP3FBgAFyOgAAIAMgAkEMamsiASAA -KAIAIAAoAggiA2tLBEAgACADIAFBAUEBEFUgACgCCCEDCyABBEAgACgCBCADaiACQQxqIAH8CgAA -CyAAIAEgA2o2AggMAQsgACgCCCIDIAAoAgBGBEAgAEGIkMAAEG8LIAAoAgQgA2ogAToAACAAIANB -AWo2AggLIAJBEGokAEEAC+ACAQR/IwBBEGsiAiQAAkAgAUGAAU8EQCACQQxqIgRBAnIhAyACQQA2 -AgwCQCABQYAQTwRAIARBA3IhBSABQYCABE8EQCACQRBqIQMgAiABQRJ2QfABcjoADCACIAFBBnZB -P3FBgAFyOgAOIAIgAUEMdkE/cUGAAXI6AA0gBSEEDAILIAIgAUEMdkHgAXI6AAwgAiABQQZ2QT9x -QYABcjoADSADIQQgBSEDDAELIAJBDGpBAXIhBCACIAFBBnZBwAFyOgAMCyAEIAFBP3FBgAFyOgAA -IAMgAkEMamsiASAAKAIAIAAoAggiA2tLBEAgACADIAFBAUEBEFUgACgCCCEDCyABBEAgACgCBCAD -aiACQQxqIAH8CgAACyAAIAEgA2o2AggMAQsgACgCCCIDIAAoAgBGBEAgAEG8lsAAEG8LIAAoAgQg -A2ogAToAACAAIANBAWo2AggLIAJBEGokAEEAC7MCAQF/IwBB8ABrIgYkACAGIAE2AgwgBiAANgII -IAYgAzYCFCAGIAI2AhAgBkGg/8AAKAIANgIcIAZBlP/AACgCADYCGAJAIAQoAgAEQCAGQTBqIARB -EGopAgA3AwAgBkEoaiAEQQhqKQIANwMAIAYgBCkCADcDICAGQQQ2AlwgBkGw6MAANgJYIAZCBDcC -ZCAGIAZBEGqtQoCAgICADYQ3A1AgBiAGQQhqrUKAgICAgA2ENwNIIAYgBkEgaq1CgICAgKANhDcD -QAwBCyAGQQM2AlwgBkH858AANgJYIAZCAzcCZCAGIAZBEGqtQoCAgICADYQ3A0ggBiAGQQhqrUKA -gICAgA2ENwNACyAGIAZBGGqtQoCAgICQDYQ3AzggBiAGQThqNgJgIAZB2ABqIAUQmgEAC/ICAQF/ -AkAgAgRAIAEtAABBME0NASAFQQI7AQACQAJAAkACQAJAIAPBIgZBAEoEQCAFIAE2AgQgAiADQf// -A3EiA0sNASAFQQA7AQwgBSACNgIIIAUgAyACazYCECAEDQJBAiEBDAULIAUgAjYCICAFIAE2Ahwg -BUECOwEYIAVBADsBDCAFQQI2AgggBUHB5cAANgIEIAVBACAGayIDNgIQQQMhASACIARPDQQgBCAC -ayICIANNDQQgAiAGaiEEDAMLIAVBAjsBGCAFQQE2AhQgBUHA5cAANgIQIAVBAjsBDCAFIAM2Aggg -BSACIANrIgI2AiAgBSABIANqNgIcIAIgBEkNAUEDIQEMAwsgBUEBNgIgIAVBwOXAADYCHCAFQQI7 -ARgMAQsgBCACayEECyAFIAQ2AiggBUEAOwEkQQQhAQsgACABNgIEIAAgBTYCAA8LQajiwABBIUHM -5MAAEJEBAAtB3OTAAEEfQfzkwAAQkQEAC8oCAQZ/IAEgAkEBdGohCSAAQYD+A3FBCHYhCiAAQf8B -cSEMAkACQAJAAkADQCABQQJqIQsgByABLQABIgJqIQggCiABLQAAIgFHBEAgASAKSw0EIAghByAL -IgEgCUcNAQwECyAHIAhLDQEgBCAISQ0CIAMgB2ohAQNAIAJFBEAgCCEHIAsiASAJRw0CDAULIAJB -AWshAiABLQAAIAFBAWohASAMRw0ACwtBACECDAMLIAcgCEGc7sAAEM0BAAsgCCAEQZzuwAAQzAEA -CyAAQf//A3EhByAFIAZqIQNBASECA0AgBUEBaiEAAkAgBSwAACIBQQBOBEAgACEFDAELIAAgA0cE -QCAFLQABIAFB/wBxQQh0ciEBIAVBAmohBQwBC0GM7sAAEM8BAAsgByABayIHQQBIDQEgAkEBcyEC -IAMgBUcNAAsLIAJBAXELzgIBA38jAEEQayICJAACQCABQYABTwRAIAJBADYCDAJ/IAFBgBBPBEAg -AUGAgARPBEAgAkEMakEDciEEIAIgAUESdkHwAXI6AAwgAiABQQZ2QT9xQYABcjoADiACIAFBDHZB -P3FBgAFyOgANQQQMAgsgAkEMakECciEEIAIgAUEMdkHgAXI6AAwgAiABQQZ2QT9xQYABcjoADUED -DAELIAJBDGpBAXIhBCACIAFBBnZBwAFyOgAMQQILIQMgBCABQT9xQYABcjoAACAAKAIAIAAoAggi -AWsgA0kEQCAAIAEgA0EBQQEQVSAAKAIIIQELIAMEQCAAKAIEIAFqIAJBDGogA/wKAAALIAAgASAD -ajYCCAwBCyAAKAIIIgMgACgCAEYEQCAAQciJwAAQbwsgACgCBCADaiABOgAAIAAgA0EBajYCCAsg -AkEQaiQAQQALygIBA38jAEEQayICJAACQCABQYABTwRAIAJBADYCDAJ/IAFBgBBPBEAgAUGAgARP -BEAgAkEMakEDciEEIAIgAUESdkHwAXI6AAwgAiABQQZ2QT9xQYABcjoADiACIAFBDHZBP3FBgAFy -OgANQQQMAgsgAkEMakECciEEIAIgAUEMdkHgAXI6AAwgAiABQQZ2QT9xQYABcjoADUEDDAELIAJB -DGpBAXIhBCACIAFBBnZBwAFyOgAMQQILIQMgBCABQT9xQYABcjoAACAAKAIAIAAoAggiAWsgA0kE -QCAAIAEgAxBlIAAoAgghAQsgAwRAIAAoAgQgAWogAkEMaiAD/AoAAAsgACABIANqNgIIDAELIAAo -AggiAyAAKAIARgRAIABBsMnAABBvCyAAIANBAWo2AgggACgCBCADaiABOgAACyACQRBqJABBAAvG -AgECfyMAQRBrIgIkAAJAIAFBgAFPBEAgAkEANgIMAn8gAUGAEE8EQCABQYCABE8EQCACIAFBP3FB -gAFyOgAPIAIgAUESdkHwAXI6AAwgAiABQQZ2QT9xQYABcjoADiACIAFBDHZBP3FBgAFyOgANQQQM -AgsgAiABQT9xQYABcjoADiACIAFBDHZB4AFyOgAMIAIgAUEGdkE/cUGAAXI6AA1BAwwBCyACIAFB -P3FBgAFyOgANIAIgAUEGdkHAAXI6AAxBAgsiASAAKAIAIAAoAggiA2tLBEAgACADIAEQXSAAKAII -IQMLIAEEQCAAKAIEIANqIAJBDGogAfwKAAALIAAgASADajYCCAwBCyAAKAIIIgMgACgCAEYEQCAA -QejBwAAQbwsgACgCBCADaiABOgAAIAAgA0EBajYCCAsgAkEQaiQAQQALrwgBCH8jAEHwAGsiAiQA -IAJBCGohBCMAQSBrIgMkACADIABpIgE2AhwCQAJAAkACQAJAAkAgAUEBRgRAIABBwABNDQEgA0Hs -/8AANgIYQfD/wAAtAABBA0cEfyADIANBGGo2AhwgAyADQRxqNgIAIwBBIGsiASQAAkACQAJAAkAC -QAJAQfD/wAAtAABBAWsOAwIEAQALQfD/wABBAjoAACADKAIAIgYoAgAhBSAGQQA2AgAgBUUNAiAF -KAIAQQg2AgBB8P/AAEEDOgAACyABQSBqJAAMAwsgAUEANgIYIAFBATYCDCABQayewAA2AggMCQtB -8J/AABDPAQALIAFBADYCGCABQQE2AgwgAUHsnsAANgIIDAcLIAMoAhgFQez/wAALKAIAIgFFDQIg -A0Hk/8AANgIYIAAgAW4iBkHo/8AALQAAQQNHBH8gAyADQRhqNgIcIAMgA0EcajYCACMAQSBrIgEk -AAJAAkACQAJAAkACQEHo/8AALQAAQQFrDgMCBAEAC0Ho/8AAQQI6AAAgAygCACIIKAIAIQUgCEEA -NgIAIAVFDQIgBSgCAEECNgIAQej/wABBAzoAAAsgAUEgaiQADAMLIAFBADYCGCABQQE2AgwgAUGs -nsAANgIIDAkLQfCfwAAQzwEACyABQQA2AhggAUEBNgIMIAFB7J7AADYCCAwHCyADKAIYBUHk/8AA -CygCACAAbCIBTw0DIAFBAEgNBEHJ/8AALQAAGkEBIQcgAUEBELsBIgVFDQQgBCABNgIcIAQgBjYC -GCAEQYCgwAA2AgggBEIANwMAIARBADYCKCAEIAU2AiQgBCABNgIgIAQgAEEBayIArSAAZ0Egc62G -NwMQIANBIGokAAwGCyADQQA2AgAjAEEQayIAJAAgAEGYmcAANgIMIAAgA0EcajYCCCAAQQhqQYCw -wAAgAEEMakGAsMAAIANBgJrAABBMAAtBkJrAAEEoQbiawAAQkQEAC0HImsAAEJYBAAtB2JrAAEEv -QYibwAAQkQEACyAHIAFBmJvAABCuAQALIAFCBDcCECABQQhqQeScwAAQmgEACyACQegAaiACQTBq -KQMANwIAIAJB4ABqIAJBKGopAwA3AgAgAkHYAGogAkEgaikDADcCACACQdAAaiACQRhqKQMANwIA -IAJByABqIAJBEGopAwA3AgBByf/AAC0AABogAiACKQMINwJAQcAAQQgQuwEiAEUEQEEIQcAAEOMB -AAsgAEEANgIIIABCgYCAgBA3AwAgACACKQI8NwIMIABBFGogAkHEAGopAgA3AgAgAEEcaiACQcwA -aikCADcCACAAQSRqIAJB1ABqKQIANwIAIABBLGogAkHcAGopAgA3AgAgAEE0aiACQeQAaikCADcC -ACAAQTxqIAJB7ABqKAIANgIAIAJB8ABqJAAgAEEIagvEAgEEfyAAQgA3AhAgAAJ/QQAgAUGAAkkN -ABpBHyABQf///wdLDQAaIAFBBiABQQh2ZyIDa3ZBAXEgA0EBdGtBPmoLIgI2AhwgAkECdEGkgMEA -aiEEQQEgAnQiA0HAg8EAKAIAcUUEQCAEIAA2AgAgACAENgIYIAAgADYCDCAAIAA2AghBwIPBAEHA -g8EAKAIAIANyNgIADwsCQAJAIAEgBCgCACIDKAIEQXhxRgRAIAMhAgwBCyABQRkgAkEBdmtBACAC -QR9HG3QhBQNAIAMgBUEddkEEcWoiBCgCECICRQ0CIAVBAXQhBSACIQMgAigCBEF4cSABRw0ACwsg -AigCCCIBIAA2AgwgAiAANgIIIABBADYCGCAAIAI2AgwgACABNgIIDwsgBEEQaiAANgIAIAAgAzYC -GCAAIAA2AgwgACAANgIIC/cCAQR/IwBBMGsiACQAAkACQEGs/8AAKAIARQRAQcT/wAAoAgAhAUHE -/8AAQQA2AgAgAUUNASAAQRhqIAERBwAgAEEQaiICIABBJGopAgA3AwAgACAAKQIcNwMIIAAoAhgh -AUGs/8AAKAIAIgMNAgJAIANFDQBBsP/AACgCACICRQ0AQbT/wAAoAgAgAkECdBDHAQtBsP/AACAB -NgIAQaz/wABBATYCAEG0/8AAIAApAwg3AgBBvP/AACAAQRBqKQMANwIACyAAQTBqJABBsP/AAA8L -IABBADYCKCAAQQE2AhwgAEH0vsAANgIYIABCBDcCICAAQRhqQeC/wAAQmgEACyAAQShqIAIpAwA3 -AgAgACAAKQMINwIgIAAgATYCHCAAQQE2AhgCQCAAQRhqIgEoAgBFDQAgASgCBCICRQ0AIAEoAggg -AkECdBDHAQsgAEEANgIoIABBATYCHCAAQYDAwAA2AhggAEIENwIgIAFBiMDAABCaAQAL/AECBH8B -fiMAQSBrIgUkAAJAAkAgBEUNACABIAEgAmoiAksNACADIARqQQFrQQAgA2txrSACIAAoAgAiAUEB -dCIGIAIgBksbIgJBCEEEQQEgBEGBCEkbIARBAUYbIgYgAiAGSxsiBq1+IglCIIhQRQ0AIAmnIghB -gICAgHggA2tLDQBBACECIAUgAQR/IAUgASAEbDYCHCAFIAAoAgQ2AhQgAwUgAgs2AhggBUEIaiAD -IAggBUEUahBxIAUoAghBAUcNASAFKAIQIQIgBSgCDCEHCyAHIAJBwJTAABCuAQALIAUoAgwhASAA -IAY2AgAgACABNgIEIAVBIGokAAvKAQIEfwF+IwBBIGsiAyQAAkACQCABIAEgAmoiAksNAEEIIAIg -ACgCACIBQQF0IgQgAiAESxsiAiACQQhNGyIErSIHQiCIUEUNACAHpyIFQf////8HSw0AIAMgAQR/ -IAMgATYCHCADIAAoAgQ2AhRBAQVBAAs2AhggA0EIakEBIAUgA0EUahBxIAMoAghBAUcNASADKAIQ -IQIgAygCDCEGCyAGIAJB8J3AABCuAQALIAMoAgwhASAAIAQ2AgAgACABNgIEIANBIGokAAuJAgEB -fyMAQRBrIgIkACAAKAIAIQACfyABLQALQRhxRQRAIAEoAgAgACABKAIEKAIQEQAADAELIAJBADYC -DCABIAJBDGoCfyAAQYABTwRAIABBgBBPBEAgAEGAgARPBEAgAiAAQT9xQYABcjoADyACIABBEnZB -8AFyOgAMIAIgAEEGdkE/cUGAAXI6AA4gAiAAQQx2QT9xQYABcjoADUEEDAMLIAIgAEE/cUGAAXI6 -AA4gAiAAQQx2QeABcjoADCACIABBBnZBP3FBgAFyOgANQQMMAgsgAiAAQT9xQYABcjoADSACIABB -BnZBwAFyOgAMQQIMAQsgAiAAOgAMQQELEDYLIAJBEGokAAuqAgIDfwF+IwBBQGoiAiQAIAEoAgBB -gICAgHhGBEAgASgCDCEDIAJBJGoiBEEANgIAIAJCgICAgBA3AhwgAkEwaiADKAIAIgNBCGopAgA3 -AwAgAkE4aiADQRBqKQIANwMAIAIgAykCADcDKCACQRxqQdjCwAAgAkEoahA4GiACQRhqIAQoAgAi -AzYCACACIAIpAhwiBTcDECABQQhqIAM2AgAgASAFNwIACyABKQIAIQUgAUKAgICAEDcCACACQQhq -IgMgAUEIaiIBKAIANgIAIAFBADYCAEHJ/8AALQAAGiACIAU3AwBBDEEEELsBIgFFBEBBBEEMEOMB -AAsgASACKQMANwIAIAFBCGogAygCADYCACAAQdDFwAA2AgQgACABNgIAIAJBQGskAAuaAgEDfyMA -QRBrIgYkACABIAEoAggiBUEAIAVBAUcbNgIIAkACQAJAIAVBAUYEQCABKAIEIQQgASgCACEFIAFB -DBDHASADRQ0BIAUgAiAD/AoAAAwBCyADQQBIDQECQCADRQRAQQEhBQwBC0HJ/8AALQAAGkEBIQQg -A0EBELsBIgVFDQILIAMEQCAFIAIgA/wKAAALIAEgASgCCCICQQFrNgIIIAMhBCACQQFHDQAgASgC -ACABQQRqKAIAIgRBARCvAUUNAiAEEMcBIAFBDBDHASADIQQLIAAgAzYCCCAAIAU2AgQgACAENgIA -IAZBEGokAA8LIAQgA0Gws8AAEK4BAAtB7LTAAEErIAZBD2pB3LTAAEGotcAAEHoAC4ICAgF+An8j -AEGAAWsiBCQAIAAoAgApAwAhAgJ/AkAgASgCCCIAQYCAgBBxRQRAIABBgICAIHENASACQQEgARBG -DAILQQAhAANAIAAgBGpB/wBqIAKnQQ9xIgNBMHIgA0HXAGogA0EKSRs6AAAgAEEBayEAIAJCD1Yg -AkIEiCECDQALIAFBAUGJ6cAAQQIgACAEakGAAWpBACAAaxAzDAELQQAhAANAIAAgBGpB/wBqIAKn -QQ9xIgNBMHIgA0E3aiADQQpJGzoAACAAQQFrIQAgAkIPViACQgSIIQINAAsgAUEBQYnpwABBAiAA -IARqQYABakEAIABrEDMLIARBgAFqJAALiAIBBX8CQAJAAkACQCABKAIAIgFBAXEEQEEdQYEBIAIg -AUF+cSIFayIGIANqIgFBCnZnQQJ0ayABQf//B0sbIQQgAiAFRgRAIAQhAiABIQMMBQsgBEEFdiIH -IAZqIgJBgICAwABJDQJByf/AAC0AABpBFEEEELsBIgJFDQEgAkEBNgIQIAIgASAHaiIINgIIIAIg -BSAHazYCBCACIAg2AgAgAiAEQQJ2QQdxNgIMDAMLIAAgASACIAMQPw8LQQRBFBDjAQALIARBHXEg -AkEFdHIhAgsgASAGayIEQQAgASAETxshASAFIAZqIQULIAAgAjYCDCAAIAM2AgggACABNgIEIAAg -BTYCAAuDAgEFfwJAAkACQAJAIAEoAgAiAUEBcQRAQR1BgQEgAiABayIGIANqIgRBCnZnQQJ0ayAE -Qf//B0sbIQUgASACRgRAIAUhAiAEIQMMBQsgBUEFdiIHIAZqIgJBgICAwABJDQJByf/AAC0AABpB -FEEEELsBIgJFDQEgAkEBNgIQIAIgBCAHaiIINgIIIAIgASAHazYCBCACIAg2AgAgAiAFQQJ2QQdx -NgIMDAMLIAAgASACIAMQPw8LQQRBFBDjAQALIAVBHXEgAkEFdHIhAgsgBCAGayIFQQAgBCAFTxsh -BCABIAZqIQELIAAgAjYCDCAAIAM2AgggACAENgIEIAAgATYCAAvVAQIEfwF+IwBBIGsiAyQAAkAC -QCABIAEgAmoiAksEQEEAIQEMAQtBACEBQQggAiAAKAIAIgVBAXQiBCACIARLGyICIAJBCE0bIgSt -IgdCIIhQRQ0AIAenIgZB/////wdLDQAgAyAFBH8gAyAFNgIcIAMgACgCBDYCFEEBBUEACzYCGCAD -QQhqQQEgBiADQRRqEHEgAygCCEEBRw0BIAMoAhAhAiADKAIMIQELIAEgAkHIwsAAEK4BAAsgAygC -DCEBIAAgBDYCACAAIAE2AgQgA0EgaiQAC6gCAQR/IwBBIGsiBCQAQQEhBgJAIAAoAgAiBSABIAIg -ACgCBCIHKAIMIgERAQANAAJAIAAtAApBgAFxRQRAIAVBhenAAEEBIAERAQANAiADIABBpJDAACgC -ABEAAEUNAQwCCyAFQYbpwABBAiABEQEADQEgBEEBOgAPIAQgBzYCBCAEIAU2AgAgBEHk6MAANgIU -IAQgACkCCDcCGCAEIARBD2o2AgggBCAENgIQIAMgBEEQakGkkMAAKAIAEQAADQEgBCgCEEGA6cAA -QQIgBCgCFCgCDBEBAA0BCwJAIAINACAALQAKQYABcQ0AIAAoAgBBiOnAAEEBIAAoAgQoAgwRAQAN -AQsgACgCAEGE5sAAQQEgACgCBCgCDBEBACEGCyAEQSBqJAAgBgusAgIEfwFvIwBBIGsiAyQAEBoh -BxBtIgUgByYBIANBGGoiBCAFNgIEIAQgAjYCACADKAIcIQICQCADKAIYIgRFBEBBASEFDAELIAMg -AjYCHCADIAQ2AhggA0EQaiIEIAEoAgQgASgCCBCyATYCBCAEQQA2AgBBASEFIAMoAhQhBAJAAkAg -AygCEEEBcQRAIAIhASAEIQIMAQsgA0EcaiIGQb+RwABBBBA5IAQQyAEgASgCDLgQDCEHEG0iASAH -JgEgA0EIaiICIAE2AgQgAkEANgIAIAMoAgwhAiADKAIIQQFxRQ0BIAMoAhwhAQsgAUGEAUkNASAB -EGoMAQsgBkHDkcAAQQYQOSACEMgBQQAhBSADKAIcIQILIAAgAjYCBCAAIAU2AgAgA0EgaiQAC9kD -AQd/IwBBEGsiBiQAAkACQCACQQdNBEAgAg0BDAILIAZBCGohBwJAAkACQAJAIAFBA2pBfHEiAyAB -Rg0AIAIgAyABayIDIAIgA0kbIgRFDQBBACEDQQEhBQNAIAEgA2otAABBLkYNBCAEIANBAWoiA0cN -AAsgBCACQQhrIghLDQIMAQsgAkEIayEIQQAhBAtBrty48QIhAwNAQYCChAggASAEaiIJKAIAQa7c -uPECcyIFayAFckGAgoQIIAlBBGooAgBBrty48QJzIgVrIAVycUGAgYKEeHFBgIGChHhHDQEgBEEI -aiIEIAhNDQALCyACIARHBEBBLiEDQQEhBQNAIAEgBGotAABBLkYEQCAEIQMMAwsgAiAEQQFqIgRH -DQALC0EAIQULIAcgAzYCBCAHIAU2AgAgBigCCEEBRiEDDAELIAEtAABBLkYiAyACQQFGcg0AIAEt -AAFBLkYiAyACQQJGcg0AIAEtAAJBLkYiAyACQQNGcg0AIAEtAANBLkYiAyACQQRGcg0AIAEtAARB -LkYiAyACQQVGcg0AIAEtAAVBLkYiAyACQQZGcg0AIAEtAAZBLkYhAwsgACADIAAtAARyOgAEIAAo -AgAgASACELcBIAZBEGokAAvkAQEEfyMAQRBrIgMkACAAKAIMIQECQAJ/AkACQAJAAkACQCAAKAIE -DgIAAQILIAENAUEBIQFBACEAQQEhAgwDCyABRQ0BCyADQQRqIAAQRCADKAIEIQAgAygCCCECIAMo -AgwMAgsgACgCACIBKAIEIgBBAEgNAiABKAIAIQEgAEUEQEEBIQJBACEADAELQcn/wAAtAAAaQQEh -BCAAQQEQuwEiAkUNAgsgAARAIAIgASAA/AoAAAsgAAshASACIAEQsQEgAARAIAIgABDHAQsgA0EQ -aiQADwsgBCAAQdSLwAAQrgEAC5QCAgF/AX4jAEGgAWsiAiQAIAJCgICAgIAIIgMgAUEYaq2ENwM4 -IAIgAyABQRBqrYQ3AzAgAiADIAFBCGqthDcDKCACIAMgAa2ENwMgIAJB5LfAADYCCCACQQQ2Agwg -AkEENgIcIAJCg4CAgICEgIBpNwKYASACQYCAwAA2ApABIAJBAjsBiAEgAkKCgICAgISAgGk3AoAB -IAJBgIDAADYCeCACQQI7AXAgAkKBgICAgISAgGk3AmggAkGAgMAANgJgIAJBAjsBWCACQoCAgICA -hICAaTcCUCACQoCAwAA3AkggAkECOwFAIAIgAkFAazYCGCACQQQ2AhQgAiACQSBqNgIQIAAgAkEI -ahBEIAJBoAFqJAAL8gEBAn8jAEEwayICJAACQCAAKQMAQv///////////wCDQoCAgICAgID4/wBa -BEAgAkEBNgIUIAJBvL7AADYCECACQgE3AhwgAiAArUKAgICAoAmENwMoIAIgAkEoajYCGCABKAIA -IAEoAgQgAkEQahA4IQMMAQsgAkEAOgAMIAIgATYCCEEBIQMgAkEBNgIUIAJBvL7AADYCECACQgE3 -AhwgAiAArUKAgICAoAmENwMoIAIgAkEoajYCGCACQQhqQaS8wAAgAkEQahA4DQAgAi0ADEUEQCAB -QcS+wABBAhC3AQ0BC0EAIQMLIAJBMGokACADC5UCAQJ/IwBBIGsiBSQAQaCAwQBBoIDBACgCACIG -QQFqNgIAAn9BACAGQQBIDQAaQQFB7IPBAC0AAA0AGkHsg8EAQQE6AABB6IPBAEHog8EAKAIAQQFq -NgIAQQILQf8BcSIGQQJHBEAgBkEBcQRAIAVBCGogACABKAIYEQIACwALAkBBlIDBACgCACIGQQBO -BEBBlIDBACAGQQFqNgIAQZiAwQAoAgAEQCAFIAAgASgCFBECACAFIAQ6AB0gBSADOgAcIAUgAjYC -GCAFIAUpAwA3AhBBmIDBACgCACAFQRBqQZyAwQAoAgAoAhQRAgALQZSAwQBBlIDBACgCAEEBazYC -AEHsg8EAQQA6AAAgA0UNAQALAAsAC7sBAQJ/IwBBIGsiAyQAAkACf0EAIAEgASACaiICSw0AGkEA -QQggAiAAKAIAIgFBAXQiBCACIARLGyICIAJBCE0bIgRBAEgNABpBACECIAMgAQR/IAMgATYCHCAD -IAAoAgQ2AhRBAQUgAgs2AhggA0EIakEBIAQgA0EUahBxIAMoAghBAUcNASADKAIQIQAgAygCDAsg -AEHkx8AAEK4BAAsgAygCDCEBIAAgBDYCACAAIAE2AgQgA0EgaiQAC7oBAQV/IwBBIGsiAiQAIAAo -AgAiBEH///8/SwRAQQBBACABEK4BAAsCQEEEIARBAXQiBSAFQQRNGyIFQQR0IgZB/P///wdNBH8g -AiAEBH8gAiAEQQR0NgIcIAIgACgCBDYCFEEEBSADCzYCGCACQQhqQQQgBiACQRRqEHEgAigCCEEB -Rw0BIAIoAhAhAyACKAIMBSADCyADIAEQrgEACyACKAIMIQEgACAFNgIAIAAgATYCBCACQSBqJAAL -vQEBA38jAEEQayICJAACQAJAAkAgAUUEQCAARQ0BIABBCGsiASgCAEEBRw0CIAAoAiwgACgCKCED -IAFBADYCAAJAIAFBf0YNACAAQQRrIgAgACgCAEEBayIANgIAIAANACABQcAAEMcBCyADRQ0DIAMQ -xwEMAwsgAEUNACACIABBCGsiADYCDCAAIAAoAgBBAWsiADYCACAADQIgAkEMahCOAQwCCxDcAQAL -QeqRwABBPxDeAQALIAJBEGokAAvBAQIDfwF+IwBBMGsiAiQAIAEoAgBBgICAgHhGBEAgASgCDCED -IAJBFGoiBEEANgIAIAJCgICAgBA3AgwgAkEgaiADKAIAIgNBCGopAgA3AwAgAkEoaiADQRBqKQIA -NwMAIAIgAykCADcDGCACQQxqQdjCwAAgAkEYahA4GiACQQhqIAQoAgAiAzYCACACIAIpAgwiBTcD -ACABQQhqIAM2AgAgASAFNwIACyAAQdDFwAA2AgQgACABNgIAIAJBMGokAAu2AQEBfyMAQRBrIgMk -AAJAAkACQCAAKAIAIgBBAXEEQCABIABBfnEiAGsgAmoiAUEBEK8BRQ0CIAAgARDHAQwBCyAAIAAo -AggiAUEBazYCCCABQQFHDQAgACgCACAAQQRqKAIAIgJBARCvAUUNAiACEMcBIABBDBDHAQsgA0EQ -aiQADwtB7LTAAEErIANBD2pB3LTAAEGYtcAAEHoAC0HstMAAQSsgA0EPakHctMAAQai1wAAQegAL -sAEBBn8CQAJAIABBhAFJDQAgANBvJgEQVCIBKAIMIQUgASgCECECIAFCADcCDCABKAIIIQMgASgC -BCEEIAFCBDcCBCABKAIAIQYgAUEANgIAIAAgAkkNASAAIAJrIgAgA08NASAEIABBAnRqIAU2AgAg -ASACNgIQIAEgADYCDCABIAM2AgggASgCBCABIAQ2AgQgASgCACEAIAEgBjYCACAARQ0AIABBAnQQ -xwELDwsAC7kBAQF/Qcn/wAAtAAAaAkBBDEEEELsBIgYEQCAGQQI2AgggBiADNgIAIAYgBCADayAF -ajYCBCABIAYgASgCACIBIAEgAkYiAhs2AgAgAkUEQCABIAEoAggiAkEBajYCCCACQQBIDQIgACAB -NgIMIAAgBTYCCCAAIAQ2AgQgAEG4tcAANgIAIAZBDBDHAQ8LIAAgBjYCDCAAIAU2AgggACAENgIE -IABBuLXAADYCAA8LQQRBDBDjAQALAAuxAQEBfyMAQRBrIgMkAAJAAkACQCAAKAIAIgBBAXEEQCAB -IABrIAJqIgFBARCvAUUNAiAAIAEQxwEMAQsgACAAKAIIIgFBAWs2AgggAUEBRw0AIAAoAgAgAEEE -aigCACICQQEQrwFFDQIgAhDHASAAQQwQxwELIANBEGokAA8LQey0wABBKyADQQ9qQdy0wABBmLXA -ABB6AAtB7LTAAEErIANBD2pB3LTAAEGotcAAEHoAC88DAgx/AX4jAEEgayIEJAAgBEEYaiIJEFQi -BUEQaiIHKAIANgIAIARBEGoiCiAFQQhqIggpAgA3AwAgB0EANgIAIAhCADcCACAFKQIAIQwgBUKA -gICAwAA3AgAgBCAMNwMIAn8jAEEgayIDJAACQAJAIARBCGoiACgCDCIBIAAoAggiAkYEQAJAIAAo -AgAiAiABRgRA0G9BgAEgASABQYABTRsiBvwPASICQX9GDQQCQCAAKAIQIgtFBEAgACACNgIQDAEL -IAEgC2ogAkcNBQsgASAGaiICQf////8BSw0EIAMgAQR/IAMgAUECdDYCHCADIAAoAgQ2AhRBBAVB -AAs2AhggA0EIakEEIAJBAnQgA0EUahBxIAMoAghBAUYNBCADKAIMIQYgACACNgIAIAAgBjYCBAwB -CyABIAJPDQMLIAAgAUEBaiICNgIIIAAoAgQgAUECdGogAjYCAAwBCyABIAJPDQELIAAgACgCBCAB -QQJ0aigCADYCDCAAKAIQIANBIGokACABagwBCwALIAggCikDADcCACAHIAkoAgA2AgAgBSgCBCED -IAUoAgAhASAFIAQpAwg3AgAgAQRAIAMgAUECdBDHAQsgBEEgaiQAC6wBAQF/IwBBEGsiBiQAAkAg -AQRAIAZBBGogASADIAQgBSACKAIQEQgAAkAgBigCBCICIAYoAgwiAU0EQCAGKAIIIQUMAQsgAkEC -dCECIAYoAgghAyABRQRAQQQhBSADIAIQxwEMAQsgAyACQQQgAUECdCICELQBIgVFDQILIAAgATYC -BCAAIAU2AgAgBkEQaiQADwtBgLLAAEEyEN4BAAtBBCACQfCxwAAQrgEAC5oBAQR/IwBBIGsiAiQA -QQggACgCACIEQQF0IgMgA0EITRsiA0EASARAQQBBACABEK4BAAsgAiAEBH8gAiAENgIcIAIgACgC -BDYCFEEBBSAFCzYCGCACQQhqQQEgAyACQRRqEHEgAigCCEEBRgRAIAIoAgwgAigCECABEK4BAAsg -AigCDCEBIAAgAzYCACAAIAE2AgQgAkEgaiQAC6QBAQF/IwBBQGoiAiQAIAAoAgAhACACQgA3Azgg -AkE4aiAAJQEQJCACIAIoAjwiADYCNCACIAIoAjg2AjAgAiAANgIsIAIgAkEsaq1CgICAgOAJhDcD -ICACQQI2AgwgAkGMwcAANgIIIAJCATcCFCACIAJBIGo2AhAgASgCACABKAIEIAJBCGoQOCACKAIs -IgEEQCACKAIwIAEQxwELIAJBQGskAAuPAQEBfyACQQBOBEACfyADKAIEBEACQCADKAIIIgRFBEAM -AQsgAygCACAEIAEgAhC0AQwCCwsgASACRQ0AGkHJ/8AALQAAGiACIAEQuwELIgNFBEAgACACNgII -IAAgATYCBCAAQQE2AgAPCyAAIAI2AgggACADNgIEIABBADYCAA8LIABBADYCBCAAQQE2AgALrQEB -A38gASgCBCECAn8CQCABKAIIIgQgASgCACIDRwRAQcn/wAAtAAAaQQxBBBC7ASIBDQFBBEEMEOMB -AAsgBEUEQEEAIQFBASECQcCzwAAMAgsgAkEBcQRAIAIhAUHItMAADAILIAJBAXIhAUG0tMAADAEL -IAFBATYCCCABIAM2AgQgASACNgIAQbi1wAALIQMgACABNgIMIAAgBDYCCCAAIAI2AgQgACADNgIA -C8ABAgV/AW8CQCABKAIAIgUQ7AEiA0EASA0AAkAgA0UEQEEBIQQMAQtByf/AAC0AABpBASECIANB -ARC7ASIERQ0BCxAmIQcQbSIBIAcmASABIgYlARAfIQcQbSIBIAcmASABELMBIQIgAUGEAU8EQCAB -EGoLIAIlASAFJQEgBBAhIAJBhAFPBEAgAhBqCyAGQYQBTwRAIAYQagsgACAFEOwBNgIIIAAgBDYC -BCAAIAM2AgAPCyACIANB8LDAABCuAQALlAEBA38jAEEQayICJAACf0EBIAEoAgAiA0EnIAEoAgQi -BCgCECIBEQAADQAaIAJBBGogACgCAEGBAhAyAkAgAi0ABEGAAUYEQCADIAIoAgggAREAAEUNAUEB -DAILIAMgAi0ADiIAIAJBBGpqIAItAA8gAGsgBCgCDBEBAEUNAEEBDAELIANBJyABEQAACyACQRBq -JAALlQEBAn8CQCACQQBIDQAgAAJ/IAJFBEBBwLPAACEDQQEhBEEADAELQcn/wAAtAAAaQQEhAyAC -QQEQuwEiBEUNASACBEAgBCABIAL8CgAACyAEQQFxBEBByLTAACEDIAQMAQtBtLTAACEDIARBAXIL -NgIMIAAgAjYCCCAAIAQ2AgQgACADNgIADwsgAyACQbCzwAAQrgEAC3kCAX4CfyMAQYABayIEJAAg -ACkDACECQQAhAANAIAAgBGpB/wBqIAKnQQ9xIgNBMHIgA0HXAGogA0EKSRs6AAAgAEEBayEAIAJC -D1YgAkIEiCECDQALIAFBAUGJ6cAAQQIgACAEakGAAWpBACAAaxAzIARBgAFqJAALhAEBAX8CQCAD -QQBIDQACQCADRQRAQQEhAQwBC0HJ/8AALQAAGkEBIQQgA0EBELsBIgFFDQELIAMEQCABIAIgA/wK -AAALIAAgAzYCCCAAIAM2AgQgACABNgIAIABBHUGBASADQQp2Z0ECdGsgA0H//wdLGzYCDA8LIAQg -A0HAtsAAEK4BAAujAQIEfwFvAkAgAS0ABARAQQIhAwwBCyABKAIAJQEQFCEGEG0iAiAGJgFBjIDB -ACgCACEEQYiAwQAoAgBBiIDBAEIANwIAQQEhA0EBRgRAIAFBAToABAwBCwJ/IAIlARAVRQRAIAIl -ARAWIQYQbSIBIAYmASABIQRBAAwBCyABQQE6AARBAgshAyACQYQBSQ0AIAIQagsgACAENgIEIAAg -AzYCAAt6AQF/IwBBIGsiAiQAAn8gACgCAEGAgICAeEcEQCABIAAoAgQgACgCCBC3AQwBCyACQRBq -IAAoAgwoAgAiAEEIaikCADcDACACQRhqIABBEGopAgA3AwAgAiAAKQIANwMIIAEoAgAgASgCBCAC -QQhqEDgLIAJBIGokAAt8AQF/IwBBQGoiBSQAIAUgATYCDCAFIAA2AgggBSADNgIUIAUgAjYCECAF -QQI2AhwgBUHU6MAANgIYIAVCAjcCJCAFIAVBEGqtQoCAgICADYQ3AzggBSAFQQhqrUKAgICAkA2E -NwMwIAUgBUEwajYCICAFQRhqIAQQmgEAC3ABAX8jAEEQayIBJAAgACgCACIAIAAoAggiAkEBazYC -CAJAIAJBAUYEQCAAKAIAIABBBGooAgAiA0EBEK8BRQ0BIAMQxwEgAEEMEMcBCyABQRBqJAAPC0Hs -tMAAQSsgAUEPakHctMAAQai1wAAQegALzQIBA38jAEEwayIDJAAgAyACNgIEIAMgATYCACADQQI2 -AgwgA0HolsAANgIIIANCAjcCFCADIAOtQoCAgIDQA4Q3AyggAyAArUKAgICAwAGENwMgIAMgA0Eg -ajYCEAJ/IwBBEGsiAiQAIANBCGoiACgCDCEBAkACfwJAAkACQAJAAkAgACgCBA4CAAECCyABDQFB -ASEFQQAhAEEBIQEMAwsgAUUNAQsgAkEEaiAAEEQgAigCDCEAIAIoAgghASACKAIEDAILIAAoAgAi -ASgCBCIAQQBIDQIgASgCACEFIABFBEBBASEBQQAhAAwBC0HJ/8AALQAAGkEBIQQgAEEBELsBIgFF -DQILIAAEQCABIAUgAPwKAAALIAALIQQgASAAELEBIAQEQCABIAQQxwELIAJBEGokAAwBCyAEIABB -7JfAABCuAQALIANBMGokAAtqAgF/AX4jAEEwayIDJAAgAyABNgIEIAMgADYCACADQQI2AgwgA0Gg -58AANgIIIANCAjcCFCADQoCAgICQCiIEIAOthDcDKCADIAQgA0EEaq2ENwMgIAMgA0EgajYCECAD -QQhqIAIQmgEAC2gBAX8CQCADQQBIDQACQCADRQRAQQEhAQwBC0HJ/8AALQAAGkEBIQQgA0EBELsB -IgFFDQELIAMEQCABIAIgA/wKAAALIAAgAzYCCCAAIAE2AgQgACADNgIADwsgBCADQbCzwAAQrgEA -C2kAIwBBMGsiACQAQcj/wAAtAABFBEAgAEEwaiQADwsgAEECNgIMIABBmMXAADYCCCAAQgE3AhQg -ACABNgIsIAAgAEEsaq1CgICAgJAKhDcDICAAIABBIGo2AhAgAEEIakHAxcAAEJoBAAteAQF/IwBB -MGsiAiQAIAIgATYCDCACIAA2AgggAkECNgIUIAJBlIrAADYCECACQgE3AhwgAiACQQhqrUKAgICA -0AGENwMoIAIgAkEoajYCGCACQRBqEGEgAkEwaiQAC14BAX8jAEEwayICJAAgAiABNgIMIAIgADYC -CCACQQI2AhQgAkG4isAANgIQIAJCATcCHCACIAJBCGqtQoCAgIDQAYQ3AyggAiACQShqNgIYIAJB -EGoQYSACQTBqJAALWQECfyMAQRBrIgIkACAAQQRqIQMCfyAAKAIAQQFGBEAgAiADNgIMIAFBqpDA -AEEDIAJBDGoQXgwBCyACIAM2AgggAUGokMAAQQIgAkEIahBeCyACQRBqJAALWwEBfyABKAIAIgRB -AXEEQCAAIAEgBCAEQX5xIAIgAxBrDwsgBCAEKAIIIgFBAWo2AgggAUEATgRAIAAgBDYCDCAAIAM2 -AgggACACNgIEIABBuLXAADYCAA8LAAtYAQF/IAEoAgAiBEEBcQRAIAAgASAEIAQgAiADEGsPCyAE -IAQoAggiAUEBajYCCCABQQBOBEAgACAENgIMIAAgAzYCCCAAIAI2AgQgAEG4tcAANgIADwsAC04A -IwBBIGsiACQAIABBATYCBCAAQeC7wAA2AgAgAEIBNwIMIABCyLvAgKAINwMYIAAgAEEYajYCCCAB -KAIAIAEoAgQgABA4IABBIGokAAtLACABKAIAIgFBAXEEQCABQX5xIQEgAwRAIAEgAiAD/AoAAAsg -ACADNgIIIAAgATYCBCAAIAIgA2ogAWs2AgAPCyAAIAEgAiADEFkLSwEBfyAAKAIAIAAoAggiA2sg -AkkEQCAAIAMgAkEBQQEQVSAAKAIIIQMLIAIEQCAAKAIEIANqIAEgAvwKAAALIAAgAiADajYCCEEA -C0cBAX8gACgCACAAKAIIIgNrIAJJBEAgACADIAIQXSAAKAIIIQMLIAIEQCAAKAIEIANqIAEgAvwK -AAALIAAgAiADajYCCEEAC00BAX8jAEEwayIBJAAgAUEBNgIMIAFBuObAADYCCCABQgE3AhQgASAB -QS9qrUKAgICA8AyENwMgIAEgAUEgajYCECABQQhqIAAQmgEAC0QAIAEoAgAiAUEBcQRAIAMEQCAB -IAIgA/wKAAALIAAgAzYCCCAAIAE2AgQgACACIANqIAFrNgIADwsgACABIAIgAxBZCzoBAX8jAEEg -ayIAJAAgAEEANgIYIABBATYCDCAAQcTGwAA2AgggAEIENwIQIABBCGpB+MbAABCaAQALRwEBfyAA -KAIAIAAoAggiA2sgAkkEQCAAIAMgAhBlIAAoAgghAwsgAgRAIAAoAgQgA2ogASAC/AoAAAsgACAC -IANqNgIIQQALTwECfyAAKAIEIQIgACgCACEDAkAgACgCCCIALQAARQ0AIANB/OjAAEEEIAIoAgwR -AQBFDQBBAQ8LIAAgAUEKRjoAACADIAEgAigCEBEAAAtCAQF/IAAoAgAiACgCMCIBBEAgACgCNCAB -EMcBCwJAIABBf0YNACAAIAAoAgRBAWsiATYCBCABDQAgAEHAABDHAQsLTwECf0HJ/8AALQAAGiAB -KAIEIQIgASgCACEDQQhBBBC7ASIBRQRAQQRBCBDjAQALIAEgAjYCBCABIAM2AgAgAEHgxcAANgIE -IAAgATYCAAuSdAMjfxp+AXwgASgCCCIDQYCAgAFxIQIgACsDACE/IANBgICAgAFxRQRAIAEgAkEA -RyEBQQAhACMAQYABayIHJAAgP70hJQJ/QQMgP5lEAAAAAAAA8H9hDQAaQQIgJUKAgICAgICA+P8A -gyImQoCAgICAgID4/wBRDQAaICVC/////////weDIilCgICAgICAgAiEICVCAYZC/v///////w+D -ICVCNIinQf8PcSIAGyInQgGDISggJlAEQEEEIClQDQEaIABBswhrIQBCASEmIChQDAELQoCAgICA -gIAgICdCAYYgJ0KAgICAgICACFEiAhshJ0ICQgEgAhshJkHLd0HMdyACGyAAaiEAIChQCyECIAcg -ADsBeCAHICY3A3AgB0IBNwNoIAcgJzcDYCAHIAI6AHoCfwJAAkACQCACQQJrIgIEQEEBIQBBw+XA -AEHE5cAAICVCAFMiAxtBw+XAAEEBIAMbIAEbIRcgJUI/iKcgAXIhG0EDIAIgAkEDTxtBAmsOAgMC -AQsgB0EDNgIoIAdBxeXAADYCJCAHQQI7ASBBASEXQQEhACAHQSBqDAMLIAdBAzYCKCAHQcjlwAA2 -AiQgB0ECOwEgIAdBIGoMAgsgB0EgaiEGIAdBD2ohDCMAQTBrIgMkAAJAAkACfwJAAkACQAJAAkAC -QAJAAkAgB0HgAGoiACkDACIlUEUEQCAAKQMIIidQDQEgACkDECImUA0CICUgJnwiJiAlVA0DICUg -J1QNBCAmQoCAgICAgICAIFoNBSADIAAvARgiADsBCCADICUgJ30iJzcDACAAIABBIGsgACAmQoCA -gIAQVCIBGyICQRBrIAIgJkIghiAmIAEbIiZCgICAgICAwABUIgEbIgJBCGsgAiAmQhCGICYgARsi -JkKAgICAgICAgAFUIgEbIgJBBGsgAiAmQgiGICYgARsiJkKAgICAgICAgBBUIgEbIgJBAmsgAiAm -QgSGICYgARsiJkKAgICAgICAgMAAVCIBGyAmQgKGICYgARsiKEIAWSICayIBa8EiCkEASA0GIANC -fyAKrSIpiCImICeDNwMQICYgJ1QNCiADIAA7AQggAyAlNwMAIAMgJSAmgzcDECAlICZWDQpBoH8g -AWvBQdAAbEGwpwVqQc4QbSIAQdEATw0HIABBBHQiAEGI1sAAaikDACIqQv////8PgyImICUgKUI/ -gyIlhiIrQiCIIjV+IixCIIgiMSAqQiCIIikgNX4iMnwgKSArQv////8PgyIqfiIrQiCIIjZ8ITMg -LEL/////D4MgJiAqfkIgiHwgK0L/////D4N8IjdCgICAgAh8QiCIIStCAUEAIAEgAEGQ1sAAai8B -AGprQT9xrSIshiIqQgF9IS4gJiAnICWGIiVCIIgiJ34iLUL/////D4MgJiAlQv////8PgyIlfkIg -iHwgJSApfiIlQv////8Pg3wiPkKAgICACHxCIIghNCAnICl+ITggJUIgiCE5IC1CIIghOiAAQZLW -wABqLwEAIQEgKSAoIAKthiIlQiCIIjt+IjwgJiA7fiInQiCIIi98ICkgJUL/////D4MiJX4iKEIg -iCIwfCAnQv////8PgyAlICZ+QiCIfCAoQv////8Pg3wiPUKAgICACHxCIIh8QgF8Ii0gLIinIgBB -kM4ATwRAIABBwIQ9SQ0JIABBgMLXL08EQEEIQQkgAEGAlOvcA0kiAhshCkGAwtcvQYCU69wDIAIb -DAsLQQZBByAAQYCt4gRJIgIbIQpBwIQ9QYCt4gQgAhsMCgsgAEHkAE8EQEECQQMgAEHoB0kiAhsh -CkHkAEHoByACGwwKC0EKQQEgAEEJSyIKGwwJC0Hb0cAAQRxB2ODAABCRAQALQYjSwABBHUHo4MAA -EJEBAAtBuNLAAEEcQfjgwAAQkQEAC0Gc1MAAQTZBmOLAABCRAQALQdTTwABBN0GI4sAAEJEBAAtB -mOHAAEEtQcjhwAAQkQEAC0Gvz8AAQR1B8M/AABCRAQALIABB0QBByODAABB9AAtBBEEFIABBoI0G -SSICGyEKQZDOAEGgjQYgAhsLIQIgKyAzfCEzIC0gLoMhJiAKIAFrQQFqIQUgLSA4IDp8IDl8IDR8 -fSI0QgF8IiggLoMhJ0EAIQECQAJAAkACQAJAAkACQAJAA0AgACACbiELIAFBEUYNAiABIAxqIg4g -C0EwaiINOgAAAkAgACACIAtsayIArSAshiIrICZ8IiUgKFoEQCABIApHDQEgAUEBaiEBQgEhJQNA -ICUhKCAnISkgAUERTw0GIAEgDGogJkIKfiImICyIp0EwaiICOgAAIAFBAWohASAlQgp+ISUgJ0IK -fiInICYgLoMiJlgNAAsgJSAtIDN9fiIsICV8ISsgJyAmfSAqVCIADQcgLCAlfSIsICZWDQMMBwsg -KCAlfSInIAKtICyGIihUIQIgLSAzfSIsQgF8ISogJyAoVCAlICxCAX0iLFpyDQUgPUKAgICACHxC -IIgiLSAvIDB8fCA8fCEnQgIgOSA6fCA+QoCAgIAIfEIgiHwgOHwgJiAofCIlICt8fH0hLkIAIDEg -NnwgN0KAgICACHxCIIh8IjEgMnwgJiArfHx9ITIgJSAxfCApIDUgO31+fCAvfSAwfSAtfSEpA0Ag -JSArfCIvICxUICcgMnwgKSArfFpyRQRAICYgK3whJUEAIQIMBwsgDiANQQFrIg06AAAgJiAofCEm -ICcgLnwhLSAsIC9WBEAgKCApfCEpICUgKHwhJSAnICh9IScgKCAtWA0BCwsgKCAtViECICYgK3wh -JQwFCyABQQFqIQEgAkEKSSACQQpuIQJFDQALQdjhwAAQlgEACyABIAxqQQFrIQogKiAxIDZ8IDdC -gICAgAh8QiCIfCAyfEIKfiAvIDB8ID1CgICAgAh8QiCIfCA8fEIKfn0gKH58IS0gKUIKfiAmICp8 -fSEuICwgJn0hL0IAISkDQCAmICp8IiUgLFQgKSAvfCAmIC18WnJFBEBBACEADAULIAogAkEBayIC -OgAAICkgLnwiMCAqVCEAICUgLFoNBSApICp9ISkgJSEmICogMFgNAAsMBAtBEUERQejhwAAQfQAL -IAFBEUH44cAAEH0ACwJAICUgKlogAnINACAqICUgKHwiJlggKiAlfSAmICp9VHENACAGQQA2AgAM -BAsgJSA0QgN9WCAlQgJacUUEQCAGQQA2AgAMBAsgBiAFOwEIIAYgAUEBajYCBAwCCyAmISULAkAg -JSArWiAAcg0AICsgJSAqfCImWCArICV9ICYgK31UcQ0AIAZBADYCAAwCCyAlIChCWH4gJ3xYICUg -KEIUflpxRQRAIAZBADYCAAwCCyAGIAU7AQggBiABNgIECyAGIAw2AgALIANBMGokAAwBCyADQQA2 -AhgjAEEQayIAJAAgACADNgIMIAAgA0EQajYCCCAAQQhqQbDnwAAgAEEMakGw58AAIANBGGpBgNDA -ABBMAAsCQCAHKAIgBEAgB0HYAGogB0EoaigCADYCACAHIAcpAiA3A1AMAQsgB0HQAGohDyAHQQ9q -IQ0jAEGgCmsiASQAAkACQAJAAkACQAJAAkACQCAHQeAAaiIAKQMAIiVQRQRAIAApAwgiJlBFBEAg -ACkDECInUEUEQCAlICUgJ3wiKFgEQCAlICZaBEAgACwAGiEYIAAuARghACABICU+AgAgAUEBQQIg -JUKAgICAEFQiAhs2AqABIAFBACAlQiCIpyACGzYCBCABQQhqQQBBmAH8CwAgASAmPgKkASABQQFB -AiAmQoCAgIAQVCICGzYCxAIgAUEAICZCIIinIAIbNgKoASABQawBakEAQZgB/AsAIAEgJz4CyAIg -AUEBQQIgJ0KAgICAEFQiAhs2AugDIAFBACAnQiCIpyACGzYCzAIgAUHQAmpBAEGYAfwLACABQfAD -akEAQZwB/AsAIAFBATYC7AMgAUEBNgKMBSAArCAoQgF9eX1CwprB6AR+QoChzaC0AnxCIIinIgLB -IQ4CQCAAQQBOBEAgASAAECwaIAFBpAFqIAAQLBogAUHIAmogABAsGgwBCyABQewDakEAIABrwRAs -GgsCQCAOQQBIBEAgAUEAIA5rQf//A3EiABArIAFBpAFqIAAQKyABQcgCaiAAECsMAQsgAUHsA2og -AkH//wFxECsLIAEoAqABIQMgAUH8CGogAUGgAfwKAAAgASADNgKcCgJAAkACQAJAIAEoAugDIgYg -AyADIAZJGyICQShNBEAgAkUEQEEAIQIMBAsgAkEBcSELIAJBAUcNAQwCCwwMCyACQT5xIREgAUH8 -CGohACABQcgCaiEFA0AgACAIIAAoAgAiEiAFKAIAaiIKaiIINgIAIABBBGoiDCAMKAIAIhMgBUEE -aigCAGoiDCAKIBJJIAggCklyaiIKNgIAIAwgE0kgCiAMSXIhCCAFQQhqIQUgAEEIaiEAIBEgCUEC -aiIJRw0ACwsgCwR/IAlBAnQiACABQfwIamoiCiAKKAIAIgogAUHIAmogAGooAgBqIgAgCGoiCTYC -ACAAIApJIAAgCUtyBSAIC0UNACACQShGDQEgAUH8CGogAkECdGpBATYCACACQQFqIQILIAEgAjYC -nAogAiABKAKMBSIJIAIgCUsbIgBBKUkEQCAAQQJ0IQACQAJAAn8CQANAIABFDQEgAEEEayIAIAFB -7ANqaigCACICIAAgAUH8CGpqKAIAIgpGDQALIAIgCksgAiAKSWsMAQtBf0EAIAAbCyAYTgRAAkAg -A0UEQEEAIQMMAQsgA0EBa0H/////A3EiAEEBaiICQQNxIQUCQCAAQQNJBEAgASEAQgAhJQwBCyAC -Qfz///8HcSEKIAEhAEIAISUDQCAAIAA1AgBCCn4gJXwiJT4CACAAQQRqIgIgAjUCAEIKfiAlQiCI -fCIlPgIAIABBCGoiAiACNQIAQgp+ICVCIIh8IiU+AgAgAEEMaiICIAI1AgBCCn4gJUIgiHwiJj4C -ACAmQiCIISUgAEEQaiEAIApBBGsiCg0ACwsgBQRAA0AgACAANQIAQgp+ICV8IiY+AgAgAEEEaiEA -ICZCIIghJSAFQQFrIgUNAAsLICZCgICAgBBUDQAgA0EoRg0DIAEgA0ECdGogJT4CACADQQFqIQML -IAEgAzYCoAEgASgCxAIiAkEpTw0NIAECf0EAIAJFDQAaIAJBAWtB/////wNxIgBBAWoiA0EDcSEF -AkAgAEEDSQRAIAFBpAFqIQBCACElDAELIANB/P///wdxIQogAUGkAWohAEIAISUDQCAAIAA1AgBC -Cn4gJXwiJT4CACAAQQRqIgMgAzUCAEIKfiAlQiCIfCIlPgIAIABBCGoiAyADNQIAQgp+ICVCIIh8 -IiU+AgAgAEEMaiIDIAM1AgBCCn4gJUIgiHwiJj4CACAmQiCIISUgAEEQaiEAIApBBGsiCg0ACwsg -BQRAA0AgACAANQIAQgp+ICV8IiY+AgAgAEEEaiEAICZCIIghJSAFQQFrIgUNAAsLIAIgJkKAgICA -EFQNABogAkEoRg0RIAFBpAFqIAJBAnRqICU+AgAgAkEBags2AsQCIAEgBgR/IAZBAWtB/////wNx -IgBBAWoiAkEDcSEFAkAgAEEDSQRAIAFByAJqIQBCACElDAELIAJB/P///wdxIQogAUHIAmohAEIA -ISUDQCAAIAA1AgBCCn4gJXwiJT4CACAAQQRqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIABBCGoiAiAC -NQIAQgp+ICVCIIh8IiU+AgAgAEEMaiICIAI1AgBCCn4gJUIgiHwiJj4CACAmQiCIISUgAEEQaiEA -IApBBGsiCg0ACwsgBQRAA0AgACAANQIAQgp+ICV8IiY+AgAgAEEEaiEAICZCIIghJSAFQQFrIgUN -AAsLICZCgICAgBBUBEAgASAGNgLoAwwDCyAGQShGDREgAUHIAmogBkECdGogJT4CACAGQQFqBUEA -CzYC6AMMAQsgDkEBaiEOCyABQZAFaiICIAFB7ANqIgBBoAH8CgAAIAEgCTYCsAYgAkEBECwhHSAB -KAKMBSECIAFBtAZqIgMgAEGgAfwKAAAgASACNgLUByADQQIQLCEeIAEoAowFIQIgAUHYB2oiAyAA -QaAB/AoAACABIAI2AvgIIANBAxAsIR8CQAJAAkACQAJAAkAgASgC+AgiEiABKAKgASIJIAkgEkkb -IgJBKE0EQCABQYwFaiEgIAFBsAZqISEgAUHUB2ohIiABKAKMBSERIAEoArAGIRMgASgC1AchGUEA -IQYDQCAGIQogAkECdCEAAn8CQAJAAkADQCAARQ0BIAAgImohAyAAQQRrIgAgAWooAgAiBiADKAIA -IgNGDQALIAMgBksNAQwCCyAARQ0BCyAJIQJBAAwBCyACBEBBASEIQQAhCSACQQFHBEAgAkE+cSEM -IAEiAEHYB2ohBQNAIAAgCCAAKAIAIgsgBSgCAEF/c2oiA2oiCDYCACAAQQRqIgYgBigCACIQIAVB -BGooAgBBf3NqIgYgAyALSSADIAhLcmoiAzYCACAGIBBJIAMgBklyIQggBUEIaiEFIABBCGohACAM -IAlBAmoiCUcNAAsLIAJBAXEEfyABIAlBAnQiAGoiAyADKAIAIgMgACAfaigCAEF/c2oiACAIaiIG -NgIAIAAgA0kgACAGS3IFIAgLRQ0WCyABIAI2AqABQQgLIQsgGSACIAIgGUkbIgZBKU8NAyAGQQJ0 -IQACQAJAAkADQCAARQ0BIAAgIWohAyAAQQRrIgAgAWooAgAiCSADKAIAIgNGDQALIAMgCU0NASAC -IQYMAgsgAEUNACACIQYMAQsgBgRAQQEhCEEAIQkgBkEBRwRAIAZBPnEhDCABIgBBtAZqIQUDQCAA -IAggACgCACIQIAUoAgBBf3NqIgJqIgg2AgAgAEEEaiIDIAMoAgAiFCAFQQRqKAIAQX9zaiIDIAIg -EEkgAiAIS3JqIgI2AgAgAyAUSSACIANJciEIIAVBCGohBSAAQQhqIQAgDCAJQQJqIglHDQALCyAG -QQFxBH8gASAJQQJ0IgBqIgIgAigCACICIAAgHmooAgBBf3NqIgAgCGoiAzYCACAAIAJJIAAgA0ty -BSAIC0UNFgsgASAGNgKgASALQQRyIQsLIBMgBiAGIBNJGyIDQSlPDQQgA0ECdCEAAkACQAJAA0Ag -AEUNASAAICBqIQIgAEEEayIAIAFqKAIAIgkgAigCACICRg0ACyACIAlNDQEgBiEDDAILIABFDQAg -BiEDDAELIAMEQEEBIQhBACEJIANBAUcEQCADQT5xIQwgASIAQZAFaiEFA0AgACAIIAAoAgAiECAF -KAIAQX9zaiICaiIINgIAIABBBGoiBiAGKAIAIhQgBUEEaigCAEF/c2oiBiACIBBJIAIgCEtyaiIC -NgIAIAYgFEkgAiAGSXIhCCAFQQhqIQUgAEEIaiEAIAwgCUECaiIJRw0ACwsgA0EBcQR/IAEgCUEC -dCIAaiICIAIoAgAiAiAAIB1qKAIAQX9zaiIAIAhqIgY2AgAgACACSSAAIAZLcgUgCAtFDRYLIAEg -AzYCoAEgC0ECaiELCyARIAMgAyARSRsiAkEpTw0TIAJBAnQhAAJAAkACQANAIABFDQEgAEEEayIA -IAFqKAIAIgYgACABQewDamooAgAiCUYNAAsgBiAJTw0BIAMhAgwCCyAARQ0AIAMhAgwBCyACBEBB -ASEIQQAhCSACQQFHBEAgAkE+cSEMIAEiAEHsA2ohBQNAIAAgCCAAKAIAIhAgBSgCAEF/c2oiA2oi -CDYCACAAQQRqIgYgBigCACIUIAVBBGooAgBBf3NqIgYgAyAQSSADIAhLcmoiAzYCACAGIBRJIAMg -BklyIQggBUEIaiEFIABBCGohACAMIAlBAmoiCUcNAAsLIAJBAXEEfyABIAlBAnQiAGoiAyADKAIA -IgMgAUHsA2ogAGooAgBBf3NqIgAgCGoiBjYCACAAIANJIAAgBktyBSAIC0UNFgsgASACNgKgASAL -QQFqIQsLIApBEUYNBiAKIA1qIAtBMGo6AAAgASgCxAIiDCACIAIgDEkbIgBBKU8NFSAKQQFqIQYg -AEECdCEAAn8CQANAIABFDQEgAEEEayIAIAFqKAIAIgMgACABQaQBamooAgAiCUYNAAsgAyAJSyAD -IAlJawwBC0F/QQAgABsLIRQgAUH8CGogAUGgAfwKAAAgASACNgKcCiABKALoAyILIAIgAiALSRsi -A0EoSw0FAkAgA0UEQEEAIQMMAQtBACEIQQAhCSADQQFHBEAgA0E+cSEjIAFB/AhqIQAgAUHIAmoh -BQNAIAAgCCAAKAIAIiQgBSgCAGoiEGoiFTYCACAAQQRqIgggCCgCACIWIAVBBGooAgBqIgggECAk -SSAQIBVLcmoiEDYCACAIIBZJIAggEEtyIQggBUEIaiEFIABBCGohACAjIAlBAmoiCUcNAAsLIANB -AXEEfyAJQQJ0IgAgAUH8CGpqIgkgCSgCACIJIAFByAJqIABqKAIAaiIAIAhqIgU2AgAgACAJSSAA -IAVLcgUgCAtFDQAgA0EoRg0XIAFB/AhqIANBAnRqQQE2AgAgA0EBaiEDCyABIAM2ApwKIAMgESAD -IBFLGyIAQSlPDRUgAEECdCEAAn8CQANAIABFDQEgAEEEayIAIAFB7ANqaigCACIDIAAgAUH8CGpq -KAIAIglGDQALIAMgCUsgAyAJSWsMAQtBf0EAIAAbCyAYTiIAIBQgGEgiA0VxRQRAIAANEyADDQMM -EgtBACEDIAECf0EAIAJFDQAaIAJBAWtB/////wNxIgBBAWoiCkEDcSEFAkAgAEEDSQRAIAEhAEIA -ISUMAQsgCkH8////B3EhCiABIQBCACElA0AgACAANQIAQgp+ICV8IiU+AgAgAEEEaiIJIAk1AgBC -Cn4gJUIgiHwiJT4CACAAQQhqIgkgCTUCAEIKfiAlQiCIfCIlPgIAIABBDGoiCSAJNQIAQgp+ICVC +X3diaW5kZ2VuX3N0cmluZ19uZXcAFBguL2hmX3hldF90aGluX3dhc21fYmcuanMVX193YmluZGdl +bl9zdHJpbmdfZ2V0AAsYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzFF9fd2JpbmRnZW5faXNfb2Jq +ZWN0AAUYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzF19fd2JpbmRnZW5faXNfdW5kZWZpbmVkAAUY +Li9oZl94ZXRfdGhpbl93YXNtX2JnLmpzDV9fd2JpbmRnZW5faW4AFRguL2hmX3hldF90aGluX3dh +c21fYmcuanMUX193YmluZGdlbl9lcnJvcl9uZXcAFBguL2hmX3hldF90aGluX3dhc21fYmcuanMZ +X193YmluZGdlbl9qc3ZhbF9sb29zZV9lcQAVGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxZfX3di +aW5kZ2VuX2Jvb2xlYW5fZ2V0AAUYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzFV9fd2JpbmRnZW5f +bnVtYmVyX2dldAALGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxRfX3diaW5kZ2VuX2FzX251bWJl +cgAYGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcx1fX3diZ19TdHJpbmdfOGYwZWIzOWE0YTRjMmY2 +NgALGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxVfX3diaW5kZ2VuX251bWJlcl9uZXcAGRguL2hm +X3hldF90aGluX3dhc21fYmcuanMkX193YmdfZ2V0d2l0aHJlZmtleV8xZGMzNjFiZDEwMDUzYmZl +ABEYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX3NldF8zZjFkMGI5ODRlZDI3MmVkABoY +Li9oZl94ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX2dldF9iOWI5MzA0N2ZlM2NmNDViABsYLi9o +Zl94ZXRfdGhpbl93YXNtX2JnLmpzHV9fd2JnX2xlbmd0aF9lMmQyYTQ5MTMyYzFiMjU2AAUYLi9o +Zl94ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX25ld183OGZlYjEwOGI2NDcyNzEzAAwYLi9oZl94 +ZXRfdGhpbl93YXNtX2JnLmpzFl9fd2JpbmRnZW5faXNfZnVuY3Rpb24ABRguL2hmX3hldF90aGlu +X3dhc21fYmcuanMbX193YmdfbmV4dF8yNWZlYWRmYzA5MTNmZWE5AAoYLi9oZl94ZXRfdGhpbl93 +YXNtX2JnLmpzG19fd2JnX25leHRfNjU3NGUxYThhNjJkMTA1NQAKGC4vaGZfeGV0X3RoaW5fd2Fz +bV9iZy5qcxtfX3diZ19kb25lXzc2OWU1ZWRlNGIzMWM2N2IABRguL2hmX3hldF90aGluX3dhc21f +YmcuanMcX193YmdfdmFsdWVfY2QxZmZhN2IxYWI3OTRmMQAKGC4vaGZfeGV0X3RoaW5fd2FzbV9i +Zy5qcx9fX3diZ19pdGVyYXRvcl85YTI0Yzg4ZGY4NjBkYzY1AAwYLi9oZl94ZXRfdGhpbl93YXNt +X2JnLmpzGl9fd2JnX2dldF82N2IyYmE2MmZjMzBkZTEyABEYLi9oZl94ZXRfdGhpbl93YXNtX2Jn +LmpzG19fd2JnX2NhbGxfNjcyYTRkMjE2MzRkNGEyNAARGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5q +cxpfX3diZ19uZXdfNDA1ZTIyZjM5MDU3NmNlMgAMGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxpf +X3diZ19zZXRfMzc4MzcwMjNmM2Q3NDBlOAAcGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcx5fX3di +Z19pc0FycmF5X2ExZWFiN2UwZDA2NzM5MWIABRguL2hmX3hldF90aGluX3dhc21fYmcuanMtX193 +YmdfaW5zdGFuY2VvZl9BcnJheUJ1ZmZlcl9lMTQ1ODU0MzJlMzczN2ZjAAUYLi9oZl94ZXRfdGhp +bl93YXNtX2JnLmpzJF9fd2JnX2lzU2FmZUludGVnZXJfMzQzZTJiZWVlZWNlMWJiMAAFGC4vaGZf +eGV0X3RoaW5fd2FzbV9iZy5qcx1fX3diZ19idWZmZXJfNjA5Y2MzZWVlNTFlZDE1OAAKGC4vaGZf +eGV0X3RoaW5fd2FzbV9iZy5qcxpfX3diZ19uZXdfYTEyMDAyYTdmOTFjNzViZQAKGC4vaGZfeGV0 +X3RoaW5fd2FzbV9iZy5qcxpfX3diZ19zZXRfNjU1OTViZGQ4NjhiMzAwOQAdGC4vaGZfeGV0X3Ro +aW5fd2FzbV9iZy5qcx1fX3diZ19sZW5ndGhfYTQ0NjE5M2RjMjJjMTJmOAAFGC4vaGZfeGV0X3Ro +aW5fd2FzbV9iZy5qcyxfX3diZ19pbnN0YW5jZW9mX1VpbnQ4QXJyYXlfMTcxNTZiY2YxMTgwODZh +OQAFGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxdfX3diaW5kZ2VuX2RlYnVnX3N0cmluZwALGC4v +aGZfeGV0X3RoaW5fd2FzbV9iZy5qcxBfX3diaW5kZ2VuX3Rocm93AAIYLi9oZl94ZXRfdGhpbl93 +YXNtX2JnLmpzEV9fd2JpbmRnZW5fbWVtb3J5AAwYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzH19f +d2JpbmRnZW5faW5pdF9leHRlcm5yZWZfdGFibGUADQPNAcsBHgYfAgIAAgIAAwgDBAMSAwAHAQAB +AAEAARIBBAIgAQIAIQMAAgAADg4iAAAGAhYIAwACBAAEBAMPAwEGAgAIAwICAgMHDgMWDgIABAIC +AAMABAIACAMBAwQCAAAABAQABAEBBwQNAQAABwIAAwQCABMAByMkFxcCJQ8SBgAIEyYoKgcEAAEE +AAcCAwAHAAAGDwYDAAEACAAABAQAAAcCAgIAAAACAwMGAwMDAAcAAAAAAAAAAAAAAA0NAgACAAAC +AAECAAACBgYGBgMECQJwAWhobwCAAQUDAQARBgkBfwFBgIDAAAsHzwIQBm1lbW9yeQIAEl9fd2Jn +X2NodW5rZXJfZnJlZQBpC2NodW5rZXJfbmV3AFQQY2h1bmtlcl9hZGRfZGF0YQCcAQ5jaHVua2Vy +X2ZpbmlzaACgARFjb21wdXRlX3hvcmJfaGFzaACdARFjb21wdXRlX2ZpbGVfaGFzaACeARljb21w +dXRlX3ZlcmlmaWNhdGlvbl9oYXNoAJsBEV9fd2JpbmRnZW5fbWFsbG9jAJkBEl9fd2JpbmRnZW5f +cmVhbGxvYwChARRfX3diaW5kZ2VuX2V4bl9zdG9yZQDFARdfX2V4dGVybnJlZl90YWJsZV9hbGxv +YwBvE19fd2JpbmRnZW5fZXhwb3J0XzQBARlfX2V4dGVybnJlZl90YWJsZV9kZWFsbG9jAGwPX193 +YmluZGdlbl9mcmVlALoBEF9fd2JpbmRnZW5fc3RhcnQAJwm8AQEAQQELZ9oB2wGCAbABiQFN3AHW +AdkB7AHrAdgB1wG9ATi/Ad0BsAGJAU69AXKXAaYBcKUBpgGiAa0BqwGlAaUBpwGoAakBrgGAAXnx +AfIBhQGIAV2jAWuGAYwBXm7eAZUBwQHCAc8BfXjDAb8BhwGsAdUBpAFlWcQBkwFirwHfAcMBtAHT +AYEBsAGKAVPjAccBxgHJAZIByAHkAaoBe1pq7QGwAY4BUuUB5gG7Ab0BygHLATt2XD6QAegBDAEO +CpvsBMsBiRsBIH8gACAAKAIYIh0gASgAECIkIAAoAghqaiIbIAEoABQiFWogHSAbIAJB/wFxc0EQ +dyICQfLmu+MDaiIdc0EUdyIbaiIiIAJzQRh3IgkgHWoiHCAbc0EZdyIPIAAoAhQiGyABKAAIIgIg +ACgCBGpqIhkgASgADCIdaiAZIANCIIinc0EQdyIeQfui4aQEayIgIBtzQRR3IgZqIgogASgAKCIb +amoiIyABKAAsIhlqIA8gIyAAKAIQIiEgASgAACIPIAAoAgBqaiIIIAEoAAQiH2ogISAIIAOnc0EQ +dyIhQefMp9AGaiIIc0EUdyIHaiIOICFzQRh3Ig1zQRB3IgsgACgCHCIFIAEoABgiIyAAKAIMamoi +DCABKAAcIiFqIAUgDCAEQf8BcXNBEHciBEHGlcDVBWsiBXNBFHciDGoiESAEc0EYdyIQIAVqIgVq +IhJzQRR3IhRqIhMgHWogBiAgIAogHnNBGHciIGoiBnNBGXciCiAOIAEoACAiBGpqIg4gASgAJCIe +aiAKIBwgDiAQc0EQdyIcaiIKc0EUdyIOaiIQIBxzQRh3IhYgCmoiCiAOc0EZdyIcaiIOIBtqIBwg +DiAFIAxzQRl3IgUgIiABKAAwIhxqaiIMIAEoADQiImogDCAgc0EQdyIgIAggDWoiCGoiDSAFc0EU +dyIFaiIMICBzQRh3IhdzQRB3Ig4gByAIc0EZdyIIIBEgASgAOCIgamoiByABKAA8IgFqIAcgCXNB +EHciCSAGaiIGIAhzQRR3IghqIgcgCXNBGHciCSAGaiIGaiIRc0EUdyIYaiIaIBxqIAsgE3NBGHci +CyASaiISIBRzQRl3IhQgDCAhamoiDCAPaiAJIAxzQRB3IgkgCmoiCiAUc0EUdyIMaiIUIAlzQRh3 +IgkgCmoiCiAMc0EZdyIMaiITIBVqIAwgEyAGIAhzQRl3IgYgAiAQamoiCCAjaiAGIAggC3NBEHci +BiANIBdqIghqIg1zQRR3IgtqIgwgBnNBGHciBnNBEHciECAFIAhzQRl3IgggByAkamoiByAiaiAI +IAcgFnNBEHciCCASaiIHc0EUdyIFaiISIAhzQRh3IgggB2oiB2oiE3NBFHciFmoiFyAbaiAOIBpz +QRh3Ig4gEWoiESAYc0EZdyIYIAwgH2pqIgwgGWogCiAIIAxzQRB3IgpqIgggGHNBFHciDGoiGCAK +c0EYdyIKIAhqIgggDHNBGXciDGoiGiAcaiAMIBogBSAHc0EZdyIHIBQgHmpqIgUgIGogByAFIA5z +QRB3IgcgBiANaiIGaiIOc0EUdyINaiIFIAdzQRh3IgdzQRB3IgwgBiALc0EZdyIGIAEgEmpqIgsg +BGogBiAJIAtzQRB3IgkgEWoiBnNBFHciC2oiESAJc0EYdyIJIAZqIgZqIhJzQRR3IhRqIhogHmog +ECAXc0EYdyIQIBNqIhMgFnNBGXciFiAFICJqaiIFIAJqIAUgCXNBEHciCSAIaiIIIBZzQRR3IgVq +IhYgCXNBGHciCSAIaiIIIAVzQRl3IgVqIhcgD2ogBSAXIAYgC3NBGXciBiAYIB1qaiILICRqIAYg +CyAQc0EQdyIGIAcgDmoiB2oiDnNBFHciC2oiBSAGc0EYdyIGc0EQdyIQIAcgDXNBGXciByARICFq +aiINICBqIAcgCiANc0EQdyIKIBNqIgdzQRR3Ig1qIhEgCnNBGHciCiAHaiIHaiITc0EUdyIXaiIY +IBxqIAwgGnNBGHciDCASaiISIBRzQRl3IhQgBSAjamoiBSAVaiAFIApzQRB3IgogCGoiCCAUc0EU +dyIFaiIUIApzQRh3IgogCGoiCCAFc0EZdyIFaiIaIB5qIAUgGiAHIA1zQRl3IgcgFiAZamoiDSAB +aiAHIAwgDXNBEHciByAGIA5qIgZqIg5zQRR3Ig1qIgUgB3NBGHciB3NBEHciDCAGIAtzQRl3IgYg +BCARamoiCyAfaiAGIAkgC3NBEHciCSASaiIGc0EUdyILaiIRIAlzQRh3IgkgBmoiBmoiEnNBFHci +FmoiGiAZaiAQIBhzQRh3IhAgE2oiEyAXc0EZdyIXIAUgIGpqIgUgHWogBSAJc0EQdyIJIAhqIggg +F3NBFHciBWoiFyAJc0EYdyIJIAhqIgggBXNBGXciBWoiGCACaiAFIBggBiALc0EZdyIGIBQgG2pq +IgsgIWogBiALIBBzQRB3IgYgByAOaiIHaiIOc0EUdyILaiIFIAZzQRh3IgZzQRB3IhAgByANc0EZ +dyIHIBEgImpqIg0gAWogByAKIA1zQRB3IgogE2oiB3NBFHciDWoiESAKc0EYdyIKIAdqIgdqIhRz +QRR3IhNqIhggHmogDCAac0EYdyIMIBJqIhIgFnNBGXciFiAFICRqaiIFIA9qIAUgCnNBEHciCiAI +aiIIIBZzQRR3IgVqIhYgCnNBGHciCiAIaiIIIAVzQRl3IgVqIhogGWogBSAaIAcgDXNBGXciByAV +IBdqaiINIARqIAcgDCANc0EQdyIHIAYgDmoiBmoiDnNBFHciDWoiBSAHc0EYdyIHc0EQdyIMIAYg +C3NBGXciBiARIB9qaiILICNqIAYgCSALc0EQdyIJIBJqIgZzQRR3IgtqIhEgCXNBGHciCSAGaiIG +aiISc0EUdyIXaiIaIBVqIBAgGHNBGHciECAUaiIUIBNzQRl3IhMgASAFamoiBSAbaiAFIAlzQRB3 +IgkgCGoiCCATc0EUdyIFaiITIAlzQRh3IgkgCGoiCCAFc0EZdyIFaiIYIB1qIAUgGCAGIAtzQRl3 +IgYgFiAcamoiCyAiaiAGIAsgEHNBEHciBiAHIA5qIgdqIg5zQRR3IgtqIgUgBnNBGHciBnNBEHci +ECAHIA1zQRl3IgcgESAgamoiDSAEaiAHIAogDXNBEHciCiAUaiIHc0EUdyINaiIRIApzQRh3Igog +B2oiB2oiFHNBFHciFmoiGCAZaiAMIBpzQRh3IgwgEmoiEiAXc0EZdyIXIAUgIWpqIgUgAmogBSAK +c0EQdyIKIAhqIgggF3NBFHciBWoiFyAKc0EYdyIKIAhqIgggBXNBGXciBWoiGiAVaiAFIBogByAN +c0EZdyIHIA8gE2pqIg0gH2ogByAMIA1zQRB3IgcgBiAOaiIGaiIOc0EUdyINaiIFIAdzQRh3Igdz +QRB3IgwgBiALc0EZdyIGIBEgI2pqIgsgJGogBiAJIAtzQRB3IgkgEmoiBnNBFHciC2oiESAJc0EY +dyIJIAZqIgZqIhJzQRR3IhNqIhogD2ogECAYc0EYdyIQIBRqIhQgFnNBGXciFiAEIAVqaiIFIBxq +IAUgCXNBEHciCSAIaiIIIBZzQRR3IgVqIhYgCXNBGHciCSAIaiIIIAVzQRl3IgVqIhggG2ogBSAY +IAYgC3NBGXciBiAXIB5qaiILICBqIAYgCyAQc0EQdyIGIAcgDmoiB2oiDnNBFHciC2oiBSAGc0EY +dyIGc0EQdyIQIAcgDXNBGXciByABIBFqaiINIB9qIAcgCiANc0EQdyIKIBRqIgdzQRR3Ig1qIhEg +CnNBGHciCiAHaiIHaiIUc0EUdyIXaiIYIBVqIAwgGnNBGHciFSASaiIMIBNzQRl3IhIgBSAiamoi +BSAdaiAFIApzQRB3IgogCGoiCCASc0EUdyIFaiISIApzQRh3IgogCGoiCCAFc0EZdyIFaiITIA9q +IAUgEyAHIA1zQRl3Ig8gAiAWamoiByAjaiAPIAcgFXNBEHciFSAGIA5qIg9qIgZzQRR3IgdqIg4g +FXNBGHciFXNBEHciDSALIA9zQRl3Ig8gESAkamoiCyAhaiAPIAkgC3NBEHciDyAMaiIJc0EUdyIL +aiIFIA9zQRh3Ig8gCWoiCWoiDHNBFHciEWoiEyACaiAeIBAgGHNBGHciAiAUaiIeIBdzQRl3IhAg +DiAfamoiH2ogDyAfc0EQdyIPIAhqIh8gEHNBFHciCGoiDiAPc0EYdyIPIB9qIh8gCHNBGXciCGoi +ECAcaiAQIAEgCSALc0EZdyIBIBIgGWpqIhlqIAEgAiAZc0EQdyIBIAYgFWoiAmoiFXNBFHciGWoi +HCABc0EYdyIBc0EQdyIJIAIgB3NBGXciAiAEIAVqaiIEICNqIAIgBCAKc0EQdyICIB5qIgRzQRR3 +IiNqIh4gAnNBGHciAiAEaiIEaiIGIAhzQRR3IgpqIgggCXNBGHciCSAGaiIGIAEgFWoiASAZc0EZ +dyIVIB4gIWpqIhkgImogFSAPIBlzQRB3IhUgDSATc0EYdyIZIAxqIg9qIiFzQRR3Ih5qIiJzNgIM +IAAgGyAPIBFzQRl3Ig8gHCAgamoiHGogAiAcc0EQdyICIB9qIhsgD3NBFHciD2oiHyACc0EYdyIC +IBtqIhsgJCAEICNzQRl3IgQgDiAdamoiHWogBCABIBkgHXNBEHciAWoiBHNBFHciJGoiHXM2Aggg +ACAVICJzQRh3IhUgIWoiGSAIczYCBCAAIAEgHXNBGHciASAEaiIEIB9zNgIAIAAgBCAkc0EZdyAC +czYCHCAAIAYgCnNBGXcgFXM2AhggACAPIBtzQRl3IAFzNgIUIAAgGSAec0EZdyAJczYCEAubJAIJ +fwF+IwBBEGsiCCQAAn8CQAJAAkACQAJAAkAgAEH1AU8EQEEAIABBzP97Sw0HGiAAQQtqIgFBeHEh +BUHchMEAKAIAIglFDQRBHyEHQQAgBWshBCAAQfT//wdNBEAgBUEGIAFBCHZnIgBrdkEBcSAAQQF0 +a0E+aiEHCyAHQQJ0QcCBwQBqKAIAIgFFBEBBACEADAILQQAhACAFQRkgB0EBdmtBACAHQR9HG3Qh +AwNAAkAgASgCBEF4cSIGIAVJDQAgBiAFayIGIARPDQAgASECIAYiBA0AQQAhBCABIQAMBAsgASgC +FCIGIAAgBiABIANBHXZBBHFqKAIQIgFHGyAAIAYbIQAgA0EBdCEDIAENAAsMAQtB2ITBACgCACIC +QRAgAEELakH4A3EgAEELSRsiBUEDdiIAdiIBQQNxBEACQCABQX9zQQFxIABqIgZBA3QiAEHQgsEA +aiIDIABB2ILBAGooAgAiASgCCCIERwRAIAQgAzYCDCADIAQ2AggMAQtB2ITBACACQX4gBndxNgIA +CyABIABBA3I2AgQgACABaiIAIAAoAgRBAXI2AgQgAUEIagwHCyAFQeCEwQAoAgBNDQMCQAJAIAFF +BEBB3ITBACgCACIARQ0GIABoQQJ0QcCBwQBqKAIAIgIoAgRBeHEgBWshBCACIQEDQAJAIAIoAhAi +AA0AIAIoAhQiAA0AIAEoAhghBwJAAkAgASABKAIMIgBGBEAgAUEUQRAgASgCFCIAG2ooAgAiAg0B +QQAhAAwCCyABKAIIIgIgADYCDCAAIAI2AggMAQsgAUEUaiABQRBqIAAbIQMDQCADIQYgAiIAQRRq +IABBEGogACgCFCICGyEDIABBFEEQIAIbaigCACICDQALIAZBADYCAAsgB0UNBAJAIAEoAhxBAnRB +wIHBAGoiAigCACABRwRAIAEgBygCEEcEQCAHIAA2AhQgAA0CDAcLIAcgADYCECAADQEMBgsgAiAA +NgIAIABFDQQLIAAgBzYCGCABKAIQIgIEQCAAIAI2AhAgAiAANgIYCyABKAIUIgJFDQQgACACNgIU +IAIgADYCGAwECyAAKAIEQXhxIAVrIgIgBCACIARJIgIbIQQgACABIAIbIQEgACECDAALAAsCQEEC +IAB0IgNBACADa3IgASAAdHFoIgZBA3QiAUHQgsEAaiIDIAFB2ILBAGooAgAiACgCCCIERwRAIAQg +AzYCDCADIAQ2AggMAQtB2ITBACACQX4gBndxNgIACyAAIAVBA3I2AgQgACAFaiIGIAEgBWsiA0EB +cjYCBCAAIAFqIAM2AgBB4ITBACgCACIEBEAgBEF4cUHQgsEAaiEBQeiEwQAoAgAhAgJ/QdiEwQAo +AgAiBUEBIARBA3Z0IgRxRQRAQdiEwQAgBCAFcjYCACABDAELIAEoAggLIQQgASACNgIIIAQgAjYC +DCACIAE2AgwgAiAENgIIC0HohMEAIAY2AgBB4ITBACADNgIAIABBCGoMCAtB3ITBAEHchMEAKAIA +QX4gASgCHHdxNgIACwJAAkAgBEEQTwRAIAEgBUEDcjYCBCABIAVqIgMgBEEBcjYCBCADIARqIAQ2 +AgBB4ITBACgCACIGRQ0BIAZBeHFB0ILBAGohAEHohMEAKAIAIQICf0HYhMEAKAIAIgVBASAGQQN2 +dCIGcUUEQEHYhMEAIAUgBnI2AgAgAAwBCyAAKAIICyEGIAAgAjYCCCAGIAI2AgwgAiAANgIMIAIg +BjYCCAwBCyABIAQgBWoiAEEDcjYCBCAAIAFqIgAgACgCBEEBcjYCBAwBC0HohMEAIAM2AgBB4ITB +ACAENgIACyABQQhqDAYLIAAgAnJFBEBBACECQQIgB3QiAEEAIABrciAJcSIARQ0DIABoQQJ0QcCB +wQBqKAIAIQALIABFDQELA0AgACACIAAoAgRBeHEiAyAFayIGIARJIgcbIQkgACgCECIBRQRAIAAo +AhQhAQsgAiAJIAMgBUkiABshAiAEIAYgBCAHGyAAGyEEIAEiAA0ACwsgAkUNACAFQeCEwQAoAgAi +AE0gBCAAIAVrT3ENACACKAIYIQcCQAJAIAIgAigCDCIARgRAIAJBFEEQIAIoAhQiABtqKAIAIgEN +AUEAIQAMAgsgAigCCCIBIAA2AgwgACABNgIIDAELIAJBFGogAkEQaiAAGyEDA0AgAyEGIAEiAEEU +aiAAQRBqIAAoAhQiARshAyAAQRRBECABG2ooAgAiAQ0ACyAGQQA2AgALIAdFDQICQCACKAIcQQJ0 +QcCBwQBqIgEoAgAgAkcEQCACIAcoAhBHBEAgByAANgIUIAANAgwFCyAHIAA2AhAgAA0BDAQLIAEg +ADYCACAARQ0CCyAAIAc2AhggAigCECIBBEAgACABNgIQIAEgADYCGAsgAigCFCIBRQ0CIAAgATYC +FCABIAA2AhgMAgsCQAJAAkACQAJAIAVB4ITBACgCACIBSwRAIAVB5ITBACgCACIATwRAIAVBr4AE +akGAgHxxIgJBEHZAACEAIAhBBGoiAUEANgIIIAFBACACQYCAfHEgAEF/RiICGzYCBCABQQAgAEEQ +dCACGzYCAEEAIAgoAgQiAUUNCRogCCgCDCEGQfCEwQAgCCgCCCIEQfCEwQAoAgBqIgA2AgBB9ITB +ACAAQfSEwQAoAgAiAiAAIAJLGzYCAAJAAkBB7ITBACgCACICBEBBwILBACEAA0AgASAAKAIAIgMg +ACgCBCIHakYNAiAAKAIIIgANAAsMAgtB/ITBACgCACIAQQAgACABTRtFBEBB/ITBACABNgIAC0GA +hcEAQf8fNgIAQcyCwQAgBjYCAEHEgsEAIAQ2AgBBwILBACABNgIAQdyCwQBB0ILBADYCAEHkgsEA +QdiCwQA2AgBB2ILBAEHQgsEANgIAQeyCwQBB4ILBADYCAEHggsEAQdiCwQA2AgBB9ILBAEHogsEA +NgIAQeiCwQBB4ILBADYCAEH8gsEAQfCCwQA2AgBB8ILBAEHogsEANgIAQYSDwQBB+ILBADYCAEH4 +gsEAQfCCwQA2AgBBjIPBAEGAg8EANgIAQYCDwQBB+ILBADYCAEGUg8EAQYiDwQA2AgBBiIPBAEGA +g8EANgIAQZyDwQBBkIPBADYCAEGQg8EAQYiDwQA2AgBBmIPBAEGQg8EANgIAQaSDwQBBmIPBADYC +AEGgg8EAQZiDwQA2AgBBrIPBAEGgg8EANgIAQaiDwQBBoIPBADYCAEG0g8EAQaiDwQA2AgBBsIPB +AEGog8EANgIAQbyDwQBBsIPBADYCAEG4g8EAQbCDwQA2AgBBxIPBAEG4g8EANgIAQcCDwQBBuIPB +ADYCAEHMg8EAQcCDwQA2AgBByIPBAEHAg8EANgIAQdSDwQBByIPBADYCAEHQg8EAQciDwQA2AgBB +3IPBAEHQg8EANgIAQeSDwQBB2IPBADYCAEHYg8EAQdCDwQA2AgBB7IPBAEHgg8EANgIAQeCDwQBB +2IPBADYCAEH0g8EAQeiDwQA2AgBB6IPBAEHgg8EANgIAQfyDwQBB8IPBADYCAEHwg8EAQeiDwQA2 +AgBBhITBAEH4g8EANgIAQfiDwQBB8IPBADYCAEGMhMEAQYCEwQA2AgBBgITBAEH4g8EANgIAQZSE +wQBBiITBADYCAEGIhMEAQYCEwQA2AgBBnITBAEGQhMEANgIAQZCEwQBBiITBADYCAEGkhMEAQZiE +wQA2AgBBmITBAEGQhMEANgIAQayEwQBBoITBADYCAEGghMEAQZiEwQA2AgBBtITBAEGohMEANgIA +QaiEwQBBoITBADYCAEG8hMEAQbCEwQA2AgBBsITBAEGohMEANgIAQcSEwQBBuITBADYCAEG4hMEA +QbCEwQA2AgBBzITBAEHAhMEANgIAQcCEwQBBuITBADYCAEHUhMEAQciEwQA2AgBByITBAEHAhMEA +NgIAQeyEwQAgAUEPakF4cSIAQQhrIgI2AgBB0ITBAEHIhMEANgIAQeSEwQAgBEEoayIDIAEgAGtq +QQhqIgA2AgAgAiAAQQFyNgIEIAEgA2pBKDYCBEH4hMEAQYCAgAE2AgAMCAsgAiADSSABIAJNcg0A +IAAoAgwiA0EBcQ0AIANBAXYgBkYNAwtB/ITBAEH8hMEAKAIAIgAgASAAIAFJGzYCACABIARqIQNB +wILBACEAAkACQANAIAMgACgCACIHRwRAIAAoAggiAA0BDAILCyAAKAIMIgNBAXENACADQQF2IAZG +DQELQcCCwQAhAANAAkAgAiAAKAIAIgNPBEAgAiADIAAoAgRqIgdJDQELIAAoAgghAAwBCwtB7ITB +ACABQQ9qQXhxIgBBCGsiAzYCAEHkhMEAIARBKGsiCSABIABrakEIaiIANgIAIAMgAEEBcjYCBCAB +IAlqQSg2AgRB+ITBAEGAgIABNgIAIAIgB0Ega0F4cUEIayIAIAAgAkEQakkbIgNBGzYCBEHAgsEA +KQIAIQogA0EQakHIgsEAKQIANwIAIAMgCjcCCEHMgsEAIAY2AgBBxILBACAENgIAQcCCwQAgATYC +AEHIgsEAIANBCGo2AgAgA0EcaiEAA0AgAEEHNgIAIABBBGoiACAHSQ0ACyACIANGDQcgAyADKAIE +QX5xNgIEIAIgAyACayIAQQFyNgIEIAMgADYCACAAQYACTwRAIAIgABBVDAgLIABB+AFxQdCCwQBq +IQECf0HYhMEAKAIAIgNBASAAQQN2dCIAcUUEQEHYhMEAIAAgA3I2AgAgAQwBCyABKAIICyEAIAEg +AjYCCCAAIAI2AgwgAiABNgIMIAIgADYCCAwHCyAAIAE2AgAgACAAKAIEIARqNgIEIAFBD2pBeHFB +CGsiAiAFQQNyNgIEIAdBD2pBeHFBCGsiBCACIAVqIgBrIQUgBEHshMEAKAIARg0DIARB6ITBACgC +AEYNBCAEKAIEIgFBA3FBAUYEQCAEIAFBeHEiARBMIAEgBWohBSABIARqIgQoAgQhAQsgBCABQX5x +NgIEIAAgBUEBcjYCBCAAIAVqIAU2AgAgBUGAAk8EQCAAIAUQVQwGCyAFQfgBcUHQgsEAaiEBAn9B +2ITBACgCACIDQQEgBUEDdnQiBHFFBEBB2ITBACADIARyNgIAIAEMAQsgASgCCAshAyABIAA2Aggg +AyAANgIMIAAgATYCDCAAIAM2AggMBQtB5ITBACAAIAVrIgE2AgBB7ITBAEHshMEAKAIAIgAgBWoi +AjYCACACIAFBAXI2AgQgACAFQQNyNgIEIABBCGoMCAtB6ITBACgCACEAAkAgASAFayICQQ9NBEBB +6ITBAEEANgIAQeCEwQBBADYCACAAIAFBA3I2AgQgACABaiIBIAEoAgRBAXI2AgQMAQtB4ITBACAC +NgIAQeiEwQAgACAFaiIDNgIAIAMgAkEBcjYCBCAAIAFqIAI2AgAgACAFQQNyNgIECyAAQQhqDAcL +IAAgBCAHajYCBEHshMEAQeyEwQAoAgAiAEEPakF4cSIBQQhrIgI2AgBB5ITBAEHkhMEAKAIAIARq +IgMgACABa2pBCGoiATYCACACIAFBAXI2AgQgACADakEoNgIEQfiEwQBBgICAATYCAAwDC0HshMEA +IAA2AgBB5ITBAEHkhMEAKAIAIAVqIgE2AgAgACABQQFyNgIEDAELQeiEwQAgADYCAEHghMEAQeCE +wQAoAgAgBWoiATYCACAAIAFBAXI2AgQgACABaiABNgIACyACQQhqDAMLQQBB5ITBACgCACIAIAVN +DQIaQeSEwQAgACAFayIBNgIAQeyEwQBB7ITBACgCACIAIAVqIgI2AgAgAiABQQFyNgIEIAAgBUED +cjYCBCAAQQhqDAILQdyEwQBB3ITBACgCAEF+IAIoAhx3cTYCAAsCQCAEQRBPBEAgAiAFQQNyNgIE +IAIgBWoiACAEQQFyNgIEIAAgBGogBDYCACAEQYACTwRAIAAgBBBVDAILIARB+AFxQdCCwQBqIQEC +f0HYhMEAKAIAIgNBASAEQQN2dCIEcUUEQEHYhMEAIAMgBHI2AgAgAQwBCyABKAIICyEDIAEgADYC +CCADIAA2AgwgACABNgIMIAAgAzYCCAwBCyACIAQgBWoiAEEDcjYCBCAAIAJqIgAgACgCBEEBcjYC +BAsgAkEIagsgCEEQaiQAC9UMAg1/AX4jAEGgAmsiByQAAkACQAJAAkACQCABQYAITQRAIAdBADYC +iAEgASABQQAgAUGACEcbIgxrIg5BgAhPBEAgB0EBNgKIASAHIAA2AowBQQEhCgsgB0GMAWohCyAD +IRQgBSEBIwBBIGsiCCQAIAZBBXYiCSAKIAkgCkkbIg0EQCAEQQJyIQ8gBEEBciEQA0AgCygCACEJ +IAhBGGoiESACQRhqKQIANwMAIAhBEGoiEiACQRBqKQIANwMAIAhBCGoiEyACQQhqKQIANwMAIAgg +AikCADcDACAIIAlBwAAgFCAQECggCCAJQUBrQcAAIBQgBBAoIAggCUGAAWpBwAAgFCAEECggCCAJ +QcABakHAACAUIAQQKCAIIAlBgAJqQcAAIBQgBBAoIAggCUHAAmpBwAAgFCAEECggCCAJQYADakHA +ACAUIAQQKCAIIAlBwANqQcAAIBQgBBAoIAggCUGABGpBwAAgFCAEECggCCAJQcAEakHAACAUIAQQ +KCAIIAlBgAVqQcAAIBQgBBAoIAggCUHABWpBwAAgFCAEECggCCAJQYAGakHAACAUIAQQKCAIIAlB +wAZqQcAAIBQgBBAoIAggCUGAB2pBwAAgFCAEECggCCAJQcAHakHAACAUIA8QKCABQRhqIBEpAwA3 +AAAgAUEQaiASKQMANwAAIAFBCGogEykDADcAACABIAgpAwA3AAAgC0EEaiELIAFBIGohASAUQgF8 +IRQgDUEBayINDQALCyAIQSBqJAAgDEUNASAHQcgBakIANwMAIAdBwAFqQgA3AwAgB0G4AWpCADcD +ACAHQbABakIANwMAIAdBqAFqQgA3AwAgB0GgAWpCADcDACAHQZgBakIANwMAIAdB2AFqIgEgAkEI +aikCADcDACAHQeABaiIIIAJBEGopAgA3AwAgB0HoAWoiCSACQRhqKQIANwMAIAdCADcDkAEgByAE +OgD6ASAHQQA7AfgBIAcgAikCADcD0AEgByADIAqtfDcD8AEgB0GQAWogACAOaiAMEEYhACAHQdAA +aiABKQMANwMAIAdB2ABqIAgpAwA3AwAgB0HgAGogCSkDADcDACAHQRBqIABBCGopAwA3AwAgB0EY +aiAAQRBqKQMANwMAIAdBIGogAEEYaikDADcDACAHQShqIABBIGopAwA3AwAgB0EwaiAAQShqKQMA +NwMAIAdBOGogAEEwaikDADcDACAHQUBrIABBOGopAwA3AwAgByAHKQPQATcDSCAHIAApAwA3Awgg +By0A+gEhACAHLQD5ASECIAcgBy0A+AEiBDoAcCAHIAcpA/ABIgM3A2ggByAAIAJFckECciIAOgBx +IAdBmAJqIgIgCSkDADcDACAHQZACaiIJIAgpAwA3AwAgB0GIAmoiCCABKQMANwMAIAcgBykD0AE3 +A4ACIAdBgAJqIAdBCGogBCADIAAQKCAKQQV0IgBBIGoiASAGSw0CIAIoAgAhASAJKAIAIQIgCCgC +ACEEIAcoApQCIQYgBygCjAIhCCAHKAKEAiEJIAcoAoACIQsgACAFaiIAIAcoApwCNgAcIAAgATYA +GCAAIAY2ABQgACACNgAQIAAgCDYADCAAIAQ2AAggACAJNgAEIAAgCzYAACAKQQFqIQoMAQsgAUJ/ +IAGtQgF8QgGIQgF9eYinIghNDQIgB0EIaiIJQQBBgAH8CwAgACAIQQFqIgggAiADIAQgCUEgQcAA +IAhBgAhGGyIKECohCyAAIAhqIAEgCGsgAiADIAhBCnatfCAEIAkgCmpBgAEgCmsQKiALQQFGBEAg +BkE/TQ0EIAUgBykACDcAACAFQThqIAdBQGspAAA3AAAgBUEwaiAHQThqKQAANwAAIAVBKGogB0Ew +aikAADcAACAFQSBqIAdBKGopAAA3AAAgBUEYaiAHQSBqKQAANwAAIAVBEGogB0EYaikAADcAACAF +QQhqIAdBEGopAAA3AABBAiEKDAELIAtqQQV0IgBBgQFPDQQgB0EIaiAAIAIgBCAFIAYQQSEKCyAH +QaACaiQAIAoPCyABIAZBtLrAABDRAQALIAdBADYCGCAHQQE2AgwgB0G8ucAANgIIIAdCBDcCECAH +QQhqQYS7wAAQnwEAC0HAACAGQZS7wAAQ0QEACyAAQYABQaS7wAAQ0QEAC/IIAgV/A34CQAJAAkAg +AUEITwRAIAFBB3EiAkUNASAAKAKgASIDQSlPDQIgA0UEQCAAQQA2AqABDAILIANBAWtB/////wNx +IgVBAWoiBEEDcSEGIAJBAnRBwOTAAGooAgAgAnatIQkCQCAFQQNJBEAgACECDAELIARB/P///wdx +IQUgACECA0AgAiACNQIAIAl+IAh8Igc+AgAgAkEEaiIEIAQ1AgAgCX4gB0IgiHwiBz4CACACQQhq +IgQgBDUCACAJfiAHQiCIfCIHPgIAIAJBDGoiBCAENQIAIAl+IAdCIIh8Igc+AgAgB0IgiCEIIAJB +EGohAiAFQQRrIgUNAAsLIAYEQANAIAIgAjUCACAJfiAIfCIHPgIAIAJBBGohAiAHQiCIIQggBkEB +ayIGDQALCyAAIAdCgICAgBBaBH8gA0EoRg0EIAAgA0ECdGogCD4CACADQQFqBSADCzYCoAEMAQsg +ACgCoAEiA0EpTw0BIANFBEAgAEEANgKgAQ8LIAFBAnRBwOTAAGo1AgAhCSADQQFrQf////8DcSIB +QQFqIgJBA3EhBgJAIAFBA0kEQCAAIQIMAQsgAkH8////B3EhBSAAIQIDQCACIAI1AgAgCX4gCHwi +Bz4CACACQQRqIgEgATUCACAJfiAHQiCIfCIHPgIAIAJBCGoiASABNQIAIAl+IAdCIIh8Igc+AgAg +AkEMaiIBIAE1AgAgCX4gB0IgiHwiBz4CACAHQiCIIQggAkEQaiECIAVBBGsiBQ0ACwsgBgRAA0Ag +AiACNQIAIAl+IAh8Igc+AgAgAkEEaiECIAdCIIghCCAGQQFrIgYNAAsLIAAgB0KAgICAEFoEfyAD +QShGDQMgACADQQJ0aiAIPgIAIANBAWoFIAMLNgKgAQ8LAkAgAUEIcQRAIAAoAqABIgNBKU8NAgJA +IANFBEBBACEDDAELIANBAWtB/////wNxIgJBAWoiBUEDcSEGAkAgAkEDSQRAQgAhByAAIQIMAQsg +BUH8////B3EhBUIAIQcgACECA0AgAiACNQIAQuHrF34gB3wiBz4CACACQQRqIgQgBDUCAELh6xd+ +IAdCIIh8Igc+AgAgAkEIaiIEIAQ1AgBC4esXfiAHQiCIfCIHPgIAIAJBDGoiBCAENQIAQuHrF34g +B0IgiHwiCD4CACAIQiCIIQcgAkEQaiECIAVBBGsiBQ0ACwsgBgRAA0AgAiACNQIAQuHrF34gB3wi +CD4CACACQQRqIQIgCEIgiCEHIAZBAWsiBg0ACwsgCEKAgICAEFQNACADQShGDQIgACADQQJ0aiAH +PgIAIANBAWohAwsgACADNgKgAQsgAUEQcQRAIABBsNHAAEECEDMLIAFBIHEEQCAAQbjRwABBAxAz +CyABQcAAcQRAIABBxNHAAEEFEDMLIAFBgAFxBEAgAEHY0cAAQQoQMwsgAUGAAnEEQCAAQYDSwABB +ExAzCyAAIAEQLRoPCwwBCyADQShB3PvAABDRAQALQShBKEHc+8AAEH8AC7cIAgx/AX4jAEHAAWsi +AiQAIAEoAhAhAyACIAFBEGoiBDYCICACIAM2AhwgAiACQb8BaiIGNgIYIAJBgAFqIgUgASACQRhq +IgcQSgJAAkACQCACKQOAASIOQgJRDQAgAkH4AGoiAyACQagBaikDADcDACACQfAAaiIIIAJBoAFq +KQMANwMAIAJB6ABqIgkgAkGYAWopAwA3AwAgAkHgAGoiCiACQZABaikDADcDACACIAIpA4gBNwNY +IA6nQQFxRQ0AIAJB0ABqIgsgAykDADcDACACQcgAaiIMIAgpAwA3AwAgAkFAayINIAkpAwA3AwAg +AkE4aiIIIAopAwA3AwAgAiACKQNYNwMwQeWAwQAtAAAaQaABQQgQwAEiA0UNAiADIAIpAzA3AwAg +A0EgaiALKQMANwMAIANBGGogDCkDADcDACADQRBqIA0pAwA3AwAgA0EIaiAIKQMANwMAIAJBATYC +FCACIAM2AhAgAkEENgIMIAJBKGoiCSAEKAIAIgQ2AgAgAkEgaiABQQhqKQIANwMAIAIgASkCADcD +GCACIAk2ArgBIAIgBDYCtAEgAiAGNgKwASAFIAcgAkGwAWoQSgJAIAIpA4ABIg5CAlENACACQYgB +aiEEQSghAUEBIQYDQCACQfgAaiIFIARBIGopAwA3AwAgAkHwAGoiByAEQRhqKQMANwMAIAJB6ABq +IgogBEEQaikDADcDACACQeAAaiINIARBCGopAwA3AwAgAiAEKQMANwNYIA6nQQFxRQ0BIAsgBSkD +ADcDACAMIAcpAwA3AwAgAkFAayIHIAopAwA3AwAgCCANKQMANwMAIAIgAikDWDcDMCACKAIMIAZG +BEAgAkEMaiAGQQFBCEEoEFcgAigCECEDCyABIANqIgUgAikDMDcDACAFQSBqIAspAwA3AwAgBUEY +aiAMKQMANwMAIAVBEGogBykDADcDACAFQQhqIAgpAwA3AwAgAiAGQQFqIgY2AhQgAigCKCEFIAIg +CTYCuAEgAiAFNgK0ASABQShqIQEgAiACQb8BajYCsAEgAkGAAWogAkEYaiACQbABahBKIAIpA4AB +Ig5CAlINAAsLIAIoAiQiASACKAIcIgNHBEAgASADa0EEdiEEA0AgAygCACIBBEAgA0EEaigCACAB +EMwBCyADQRBqIQMgBEEBayIEDQALCyACKAIgIgEEQCACKAIYIAFBBHQQzAELIAAgAikCDDcCACAA +QQhqIAJBFGooAgA2AgAMAQsgAEEANgIIIABCgICAgIABNwIAIAEoAgwiACABKAIEIgNHBEAgACAD +a0EEdiEEA0AgAygCACIABEAgA0EEaigCACAAEMwBCyADQRBqIQMgBEEBayIEDQALCyABKAIIIgBF +DQAgASgCACAAQQR0EMwBCyACQcABaiQADwtBCEGgAUGok8AAELIBAAvLCAEIfwJAIAFBgApJBEAg +AUEFdiEHAkACQCAAKAKgASIFBEAgBUEBayEDIAVBAnQgAGpBBGshAiAFIAdqQQJ0IABqQQRrIQYg +BUEpSSEFA0AgBUUNAiADIAdqIgRBKE8NAyAGIAIoAgA2AgAgBkEEayEGIAJBBGshAiADQQFrIgNB +f0cNAAsLIAFBIEkNAyAAQQA2AgAgB0EBaiICQQJGDQMgAEEANgIEIAJBA0YNAyAAQQA2AgggAkEE +Rg0DIABBADYCDCACQQVGDQMgAEEANgIQIAJBBkYNAyAAQQA2AhQgAkEHRg0DIABBADYCGCACQQhG +DQMgAEEANgIcIAJBCUYNAyAAQQA2AiAgAkEKRg0DIABBADYCJCACQQtGDQMgAEEANgIoIAJBDEYN +AyAAQQA2AiwgAkENRg0DIABBADYCMCACQQ5GDQMgAEEANgI0IAJBD0YNAyAAQQA2AjggAkEQRg0D +IABBADYCPCACQRFGDQMgAEEANgJAIAJBEkYNAyAAQQA2AkQgAkETRg0DIABBADYCSCACQRRGDQMg +AEEANgJMIAJBFUYNAyAAQQA2AlAgAkEWRg0DIABBADYCVCACQRdGDQMgAEEANgJYIAJBGEYNAyAA +QQA2AlwgAkEZRg0DIABBADYCYCACQRpGDQMgAEEANgJkIAJBG0YNAyAAQQA2AmggAkEcRg0DIABB +ADYCbCACQR1GDQMgAEEANgJwIAJBHkYNAyAAQQA2AnQgAkEfRg0DIABBADYCeCACQSBGDQMgAEEA +NgJ8IAJBIUYNAyAAQQA2AoABIAJBIkYNAyAAQQA2AoQBIAJBI0YNAyAAQQA2AogBIAJBJEYNAyAA +QQA2AowBIAJBJUYNAyAAQQA2ApABIAJBJkYNAyAAQQA2ApQBIAJBJ0YNAyAAQQA2ApgBIAJBKEYN +AyAAQQA2ApwBIAJBKUYNA0EoQShB3PvAABB/AAsgA0EoQdz7wAAQfwALIARBKEHc+8AAEH8AC0GG +/MAAQR1B3PvAABCUAQALIAAoAqABIgMgB2ohAiABQR9xIgZFBEAgACACNgKgASAADwsCQCACQQFr +IgRBJ00EQCACIQUgACAEQQJ0aigCAEEAIAFrIgF2IgRFDQEgAkEnTQRAIAAgAkECdGogBDYCACAC +QQFqIQUMAgsgAkEoQdz7wAAQfwALIARBKEHc+8AAEH8ACwJAIAdBAWoiCCACTw0AIAFBH3EhASAD +QQFxRQRAIAAgAkEBayICQQJ0aiIEIAQoAgAgBnQgBEEEaygCACABdnI2AgALIANBAkYNACACQQJ0 +IABqQQxrIQMDQCADQQhqIgQgBCgCACAGdCADQQRqIgQoAgAiCSABdnI2AgAgBCAJIAZ0IAMoAgAg +AXZyNgIAIANBCGshAyAIIAJBAmsiAkkNAAsLIAAgB0ECdGoiASABKAIAIAZ0NgIAIAAgBTYCoAEg +AAv/CQMMfwF+AW9B5IXAACEDIwBB0ABrIgIkACACIAE2AgwCQAJAAkACQCABEO4BQQFGBEAgAiAB +NgIgIAJBADYCECACQeSFwAA2AhggAkH0hcAANgIcIAJBIGohCkGAgICAeCEBA0AgAiADQQhqNgIY +IAIgAygCACADKAIEED02AjggCigCACUBIAJBOGooAgAlARANIQ8QbyIFIA8mAQJAAkACQAJAAkAC +QCAFJQEQBEEBRgRAIAIoAjglASACKAIgJQEQBUEBRw0BCwJAIAIoAhBFDQAgAigCFCIHQYQBSQ0A +IAcQbAsgAiAFNgIUIAJBATYCECADKAIAIQUCfwJAAkACQCADKAIEQQRrDgMBAgACC0EAIQdBBiEI +QduFwAAhAwJAA0AgBS0AACILIAMtAAAiDEYEQCAFQQFqIQUgA0EBaiEDIAhBAWsiCA0BDAILCyAL +IAxrIQcLIAcNAUEBDAILQQAgBSgAAEHXhcAAKAAARg0BGgtBAgsgAigCOCIFQYMBSwRAIAUQbAtB +AWsOAgMBAgsgBUGEAU8EQCAFEGwLIAIoAjgiA0GEAU8EQCADEGwLIAIoAhgiAyACKAIcRw0FDAcL +IAIoAhAgAkEANgIQQQFGBEAgAigCFCIDQYQBSQ0EIAMQbAwECwwJCyABQYCAgIB4RwRAQYGLwABB +BBCEASEEDAILIAIoAhAgAkEANgIQRQ0IIAIgAigCFCIDNgI4IAIgAxDqAQJ/IAIoAgAiBgRAIAIo +AgQiDQwBCyACQThqIAJBzwBqQaCKwAAQQiEGQYCAgIB4CyEBIANBhAFPBEAgAxBsCyABQYCAgIB4 +Rw0CIABBgICAgHg2AgAgACAGNgIEDAYLIAlFBEAgAigCECACQQA2AhBBAUcNCCACIAIoAhQ2AiQg +AkEoaiIEIAJBJGoiAygCACUBEB4EfiAEIAMoAgAlARAK/AY3AwhCAQVCAAs3AwACfwJAIAIoAihB +AUYEQCACKQMwIg5CAFkNAQsgAkEkaiACQc8AakGAicAAEEIhBEEBDAELIA5CgICAgBBaBEAgAkEB +OgA4IAIgDjcDQCMAQTBrIgMkACADQYCJwAA2AgQgAyACQc8AajYCACADQQI2AgwgA0GwkMAANgII +IANCAjcCFCADIAOtQoCAgIDgAYQ3AyggAyACQThqrUKAgICA8AGENwMgIAMgA0EgajYCECADQQhq +EGMhBCADQTBqJABBAQwBCyAOpyEEQQALIAIoAiQiBUGEAU8EQCAFEGwLQQEhCUUNAgwBC0GFi8AA +QQYQhAEhBAsgAEGAgICAeDYCACAAIAQ2AgQgAUGAgICAeHJBgICAgHhGDQQgBiABEMwBDAQLIAIo +AhgiAyACKAIcRw0ACwwBCyACQQxqIAJBzwBqQcCKwAAQQiEEIABBgICAgHg2AgAgACAENgIEIAFB +hAFJDQIgARBsDAILIAFBgICAgHhHBEAgCQRAIAAgBDYCDCAAIA02AgggACAGNgIEIAAgATYCAAwC +C0GFi8AAQQYQgwEhBCAAQYCAgIB4NgIAIAAgBDYCBCABRQ0BIAYgARDMAQwBC0GBi8AAQQQQgwEh +ASAAQYCAgIB4NgIAIAAgATYCBAsgAigCICIAQYQBTwRAIAAQbAsgAigCEEUNACACKAIUIgBBgwFN +DQAgABBsCyACQdAAaiQADwtB0IrAAEExEOIBAAu9CwMGfwF+AW8jAEHQAGsiAiQAIAIgATYCIAJA +AkACQAJAAkAgAkEgaiIBKAIAJQEQHARAIAJBJGoiAyABKAIAJQEQEDYCCCADQQA2AgQgAyABNgIA +QQAhASACQQA2AjAgAigCJARAIAIoAiwiAyACKAIoIgRNBEBBBCEDDAMLQeWAwQAtAAAaQYCABCAD +IARrIgFBACABIANNGyIBIAFBgIAETxsiAUEEdCIEQQQQwAEiAw0CQQQgBEGAisAAELIBAAsgAkEA +NgI8IAJCgICAgMAANwI0DAILIAJBQGshARAXIQkQbyIDIAkmASADIQUgAkEgaigCACIEJQEgAyUB +EBghCRBvIgMgCSYBQaiBwQAoAgAhBkGkgcEAKAIAIQdBpIHBAEIANwIAAkACQAJAIAdBAUYEQCAB +QQM6AAQgASAGNgIADAELAkAgAxDvAUEBRgRAIAMlASAEJQEQGSEJEG8iBCAJJgFBqIHBACgCACEG +QaSBwQAoAgAhB0GkgcEAQgA3AgACQCAHQQFGBEAgAUEDOgAEIAEgBjYCAAwBCwJAIAQQ7gFBAUcN +ACAEJQEQEyEJEG8iBiAJJgEgBhDvASAGQYQBTwRAIAYQbAtBAUcNACABQQA6AAQgASAENgIAIANB +hAFPBEAgAxBsCyAFQYQBSQ0GDAULIAFBAjoABCAEQYQBSQ0AIAQQbAsgA0GEAU8NAQwCCyABQQI6 +AAQgA0GEAUkNAQsgAxBsCyAFQYMBTQ0BCyAFEGwLIAIoAkAhAQJAAkACQCACLQBEIgNBAmsOAgIA +AQsgAEGAgICAeDYCACAAIAE2AgQgAigCICIBQYMBSw0FDAYLIAIgAzoAOCACIAE2AjQgAkEANgIs +IAJCgICAgMAANwIkIAJBGGogAkE0ahB6AkAgAigCGCIDQQJHBEAgAigCHCEBA0ACQCADQQFxRQRA +IAJBQGsgARAuIAIoAkQhASACKAJAIgVBgICAgHhHDQELIABBgICAgHg2AgAgACABNgIEIAIoAiwi +AwRAIAIoAighAQNAIAEoAgAiAARAIAFBBGooAgAgABDMAQsgAUEQaiEBIANBAWsiAw0ACwsgAigC +JCIABEAgAigCKCAAQQR0EMwBCyACKAI0IgFBgwFLDQMMBwsgAikCSCEIIAIoAiwiAyACKAIkRgRA +IAJBJGpBkIrAABBoCyACKAIoIANBBHRqIgQgCDcCCCAEIAE2AgQgBCAFNgIAIAIgA0EBajYCLCAC +QRBqIAJBNGoQeiACKAIUIQEgAigCECIDQQJHDQALCyAAIAIpAiQ3AgAgAEEIaiACQSxqKAIANgIA +IAIoAjQiAUGDAU0NBAsgARBsDAMLIAJBIGogAkFAa0GwisAAEEIhASAAQYCAgIB4NgIAIAAgATYC +BAwCCyACQQA2AjwgAiADNgI4IAIgATYCNANAIAJBCGohAyACQSRqIgEoAgQiBCABKAIITwR/QQAF +IAEgBEEBajYCBCABKAIAKAIAJQEgBBAPIQkQbyIBIAkmAUEBCyEEIAMgATYCBCADIAQ2AgAgAigC +CEEBcUUNASACKAIMIQEgAiACKAIwQQFqNgIwIAJBQGsgARAuIAIoAkQhASACKAJAIgVBgICAgHhG +BEAgAEGAgICAeDYCACAAIAE2AgQgAigCPCIDBEAgAigCOCEBA0AgASgCACIABEAgAUEEaigCACAA +EMwBCyABQRBqIQEgA0EBayIDDQALCyACKAI0IgBFDQMgAigCOCAAQQR0EMwBDAMLIAIpAkghCCAC +KAI8IgMgAigCNEYEQCACQTRqQZCKwAAQaAsgAigCOCADQQR0aiIEIAg3AgggBCABNgIEIAQgBTYC +ACACIANBAWo2AjwgAigCJA0ACwsgACACKQI0NwIAIABBCGogAkE8aigCADYCAAsgAigCICIBQYMB +TQ0BCyABEGwLIAJB0ABqJAALzwYBCH8CQAJAIAEgAEEDakF8cSIDIABrIghJDQAgASAIayIGQQRJ +DQAgBkEDcSEHQQAhAQJAIAAgA0YiCQ0AAkAgACADayIFQXxLBEBBACEDDAELQQAhAwNAIAEgACAD +aiICLAAAQb9/SmogAkEBaiwAAEG/f0pqIAJBAmosAABBv39KaiACQQNqLAAAQb9/SmohASADQQRq +IgMNAAsLIAkNACAAIANqIQIDQCABIAIsAABBv39KaiEBIAJBAWohAiAFQQFqIgUNAAsLIAAgCGoh +AAJAIAdFDQAgACAGQXxxaiIDLAAAQb9/SiEEIAdBAUYNACAEIAMsAAFBv39KaiEEIAdBAkYNACAE +IAMsAAJBv39KaiEECyAGQQJ2IQUgASAEaiEEA0AgACEDIAVFDQJBwAEgBSAFQcABTxsiBkEDcSEH +IAZBAnQhCEEAIQIgBUEETwRAIAAgCEHwB3FqIQkgACEBA0AgASgCACIAQX9zQQd2IABBBnZyQYGC +hAhxIAJqIAFBBGooAgAiAEF/c0EHdiAAQQZ2ckGBgoQIcWogAUEIaigCACIAQX9zQQd2IABBBnZy +QYGChAhxaiABQQxqKAIAIgBBf3NBB3YgAEEGdnJBgYKECHFqIQIgAUEQaiIBIAlHDQALCyAFIAZr +IQUgAyAIaiEAIAJBCHZB/4H8B3EgAkH/gfwHcWpBgYAEbEEQdiAEaiEEIAdFDQALAn8gAyAGQfwB +cUECdGoiACgCACIBQX9zQQd2IAFBBnZyQYGChAhxIgEgB0EBRg0AGiABIAAoAgQiAUF/c0EHdiAB +QQZ2ckGBgoQIcWoiASAHQQJGDQAaIAAoAggiAEF/c0EHdiAAQQZ2ckGBgoQIcSABagsiAUEIdkH/ +gRxxIAFB/4H8B3FqQYGABGxBEHYgBGoPCyABRQRAQQAPCyABQQNxIQMCQCABQQRJBEAMAQsgAUF8 +cSEFA0AgBCAAIAJqIgEsAABBv39KaiABQQFqLAAAQb9/SmogAUECaiwAAEG/f0pqIAFBA2osAABB +v39KaiEEIAUgAkEEaiICRw0ACwsgA0UNACAAIAJqIQEDQCAEIAEsAABBv39KaiEEIAFBAWohASAD +QQFrIgMNAAsLIAQLlQgCC38DfiMAQeAAayIEJAAgAq1CKH4iDqchAwJAIA5CIIinIANB+P///wdL +cg0AAn8gA0UEQEEIIQZBAAwBC0HlgMEALQAAGkEIIQcgA0EIEMABIgZFDQEgAgshCyADBEAgBiAB +IAP8CgAACyACQQJPBEAgBkHQAGohDCAEQdwAaq1CgICAgBCEIQ4gBEHYAGqtQoCAgIAghCEPA0BB +ACEDQQAhBQJAAkACQAJAAkACQANAIAMhCiACIAVJDQUgBUEobCEJAkAgAiAFayIBQQNJDQBBCSAB +IAFBCU8bIQggCSAMaiEDQQIhAQNAIAEgCEYEQCAIIQEMAgsgAUEBaiEBIAMpAxhCA4MgA0EoaiED +QgBSDQALCyABIAVqIgggAUkNASACIAhJDQJBlIHBACEFQZCBwQAoAgBFBEACf0HlgMEALQAAGkGA +CEEBEMABIgMEQEGggcEAQQA2AgBBlIHBAEEANgIAQZyBwQAoAgAhBUGcgcEAIAM2AgBBmIHBACgC +ACEDQZiBwQBBgAg2AgBBkIHBACgCAEGQgcEAQQE2AgBFIANFckUEQCAFIAMQzAELQZSBwQAMAQtB +AUGACEHwiMAAELIBAAshBQsgBSgCAA0DQQAhAyAFQQA2AgwgBUF/NgIAQQAhByABBEAgBUEEaiEN +IAYgCWoiAyABQShsaiEJA0AgBCADNgJYIAQgA0EgaiIBNgJcIARBAzYCNCAEQZiMwAA2AjAgBEIC +NwI8IAQgDjcDECAEIA83AwggBCAEQQhqNgI4IA1BhJHAACAEQTBqEDwNBiABKAIAIAdqIQcgAUEI +aiIDIAlHDQALIAUoAgwhAwsgBEEwakGIucAAIAUoAgggAxA0IARB0ABqIgEgBzYCACAFIAUoAgBB +AWo2AgAgBEEQaiIDIARBOGopAwA3AwAgBEEYaiIFIARBQGspAwA3AwAgBEEgaiIHIARByABqKQMA +NwMAIARBKGoiCSABKQMANwMAIAQgBCkDMDcDCCACIApLBEAgBiAKQShsaiIBIAQpAwg3AwAgAUEg +aiAJKQMANwMAIAFBGGogBykDADcDACABQRBqIAUpAwA3AwAgAUEIaiADKQMANwMAIApBAWohAyAI +IgUgAkYNBwwBCwsgCiACQfyAwAAQfwALIAUgCEHsgMAAENIBAAsgCCACQeyAwAAQ0QEAC0HkjcAA +EIsBAAtBwIzAAEErIARBMGpBsIzAAEHUjcAAEHwACyAFIAJBjIHAABDQAQALIAMhAiAKDQALCyAA +IAYpAwA3AwAgAEEYaiAGQRhqKQMANwMAIABBEGogBkEQaikDADcDACAAQQhqIAZBCGopAwA3AwAg +BiALQShsEMwBIARB4ABqJAAPCyAHIANBuIXAABCyAQALyQcCCn8CfiMAQTBrIgYkAAJAAkACQAJA +AkACQAJAIANFDQACfyABKAIYIgcgASgCKCIFQUBrTQRAIAEoAhwgBWsiByADIAMgB0sbIQhBACEH +IAFBHGoMAQsgASgCHCAFayIJIAMgAyAJSxshCCAJIAMgByAFa0HBAGsiByADIAdJGyIHSQ0CIAUg +B2ohBSABQRxqCyEJIAZBCGohCiACIAdqIQ0gCCAHayELIAEpAxAhEEEAIQggASkDACEPIAEoAggh +DgNAAkAgCCALRgRAQQAhDAwBCyABIA4gCCANai0AAEEDdGopAwAgD0IBhnwiDzcDAEEBIQwgCEEB +aiEIIA8gEINCAFINAQsLIAogCDYCBCAKIAw2AgACQAJAIAYoAghBAXEEQCAJKAIAIgggBigCDCIE +IAVqTQ0BDAILIAkoAgAiCCAFIAtqSw0CCyAIIAVrIQQLIAFCADcDACAEIAdqIQUgASgCKCIHRQRA +IAMgBUkNAyAGQSBqIAIgBRB3DAYLIAMgBUkNAyABQSBqIQMgASgCICAHayAFSQRAIAMgByAFEFgg +ASgCKCEHCyAFBEAgASgCJCAHaiACIAX8CgAACyABIAUgB2o2AiggBkEYaiADQQhqKAIANgIAIAFB +ADYCKCADKQIAIQ8gAUKAgICAEDcDICAGIA83AxAgBkEgaiAGQRBqEHQMBQsgBEUEQCABKAIgIAEo +AigiBWsgA0kEQCABQSBqIAUgAxBYIAEoAighBQsgAwRAIAEoAiQgBWogAiAD/AoAAAsgACADNgIw +IABBADYCACABIAMgBWo2AigMBgsgASgCKCIFRQ0DIAFBIGohBCABKAIgIAVrIANJBEAgBCAFIAMQ +WCABKAIoIQULIAMEQCABKAIkIAVqIAIgA/wKAAALIAEgAyAFajYCKCAGQRhqIARBCGooAgA2AgAg +AUEANgIoIAQpAgAhDyABQoCAgIAQNwMgIAYgDzcDECAGQSBqIAZBEGoQdCADIQUMBAsgByAIQZiY +wAAQ0gEACyAFIANBqJjAABDRAQALIAUgA0G4mMAAENEBAAsgBkEgaiACIAMQdyADIQULIAZBGGog +BkEoaikCACIPNwMAIAYgBikCIDcDECAPpyIBRQRAIABBADYCMCAAQQA2AgAgBkEcaiAGKAIUQQAg +BigCECgCEBEDAAwBCyAGKAIQIQIgBigCHCEDIABBEGpB6LjAACAGKAIUIgQgARA0IAAgBTYCMCAA +IAM2AgwgACABNgIIIAAgBDYCBCAAIAI2AgALIAZBMGokAAvYBQIMfwN+IwBBoAFrIgkkACAJQQBB +oAH8CwACQAJAAkAgAiAAKAKgASIFTQRAIAVBKU8NASABIAJBAnRqIQwCQAJAIAUEQCAFQQFqIQ0g +BUECdCEKA0AgCSAGQQJ0aiEDA0AgBiECIAMhBCABIAxGDQggA0EEaiEDIAJBAWohBiABKAIAIQcg +AUEEaiILIQEgB0UNAAsgB60hEUIAIQ8gCiEHIAIhASAAIQMDQCABQShPDQQgBCAPIAQ1AgB8IAM1 +AgAgEX58IhA+AgAgEEIgiCEPIARBBGohBCABQQFqIQEgA0EEaiEDIAdBBGsiBw0ACyAIIBBCgICA +gBBaBH8gAiAFaiIBQShPDQMgCSABQQJ0aiAPPgIAIA0FIAULIAJqIgEgASAISRshCCALIQEMAAsA +CwNAIAEgDEYNBiAEQQFqIQQgASgCACABQQRqIQFFDQAgCCAEQQFrIgIgAiAISRshCAwACwALIAFB +KEHc+8AAEH8ACyABQShB3PvAABB/AAsgBUEpTw0BIAJBAnQhDCACQQFqIQ0gACAFQQJ0aiEOIAAh +AwJAA0AgCSAHQQJ0aiEGA0AgByELIAYhBCADIA5GDQUgBEEEaiEGIAdBAWohByADKAIAIQogA0EE +aiIFIQMgCkUNAAsgCq0hEUIAIQ8gDCEKIAshAyABIQYDQCADQShPDQIgBCAPIAQ1AgB8IAY1AgAg +EX58IhA+AgAgEEIgiCEPIARBBGohBCADQQFqIQMgBkEEaiEGIApBBGsiCg0ACwJAIAggEEKAgICA +EFoEfyACIAtqIgNBKE8NASAJIANBAnRqIA8+AgAgDQUgAgsgC2oiAyADIAhJGyEIIAUhAwwBCwsg +A0EoQdz7wAAQfwALIANBKEHc+8AAEH8ACyAFQShB3PvAABDRAQALIAVBKEHc+8AAENEBAAsgACAJ +QaAB/AoAACAAIAg2AqABIAlBoAFqJAAL5AgCCn8BfiMAQYACayIEJAAgBCABKQAYNwIYIAQgASkA +EDcCECAEIAEpAAg3AgggBCABKQAANwIAAn8gA0GBCE8EQCAEQSBqIQUjAEHgAGsiASQAIAFBOGoi +BkIANwMAIAFBMGoiB0IANwMAIAFBKGoiCEIANwMAIAFBIGoiCUIANwMAIAFBGGoiCkIANwMAIAFB +EGoiC0IANwMAIAFBCGoiDEIANwMAIAFCADcDACACIAMgBEIAQRAgAUHAABAqIQMgAUHYAGpCADcD +ACABQdAAakIANwMAIAFByABqQgA3AwAgAUIANwNAAkACQAJAAkAgA0EDTwRAA0AgA0EFdCICQcEA +Tw0CIAEgAiAEQRAgAUFAayINQSAQQSIDQQV0IgJBwQBPDQMgAkEhTw0EIAIEQCABIA0gAvwKAAAL +IANBAksNAAsLIAUgASkDADcAACAFQThqIAYpAwA3AAAgBUEwaiAHKQMANwAAIAVBKGogCCkDADcA +ACAFQSBqIAkpAwA3AAAgBUEYaiAKKQMANwAAIAVBEGogCykDADcAACAFQQhqIAwpAwA3AAAgAUHg +AGokAAwDCyACQcAAQbS7wAAQ0QEACyACQcAAQcS7wAAQ0QEACyACQSBB1LvAABDRAQALIARB+ABq +IARBGGopAgA3AwAgBEHwAGogBEEQaikCADcDACAEQegAaiAEQQhqKQIANwMAIAQgBCkCADcDYEHA +ACEDQRQMAQsgBEHIAWpCADcDACAEQcABakIANwMAIARBuAFqQgA3AwAgBEGwAWpCADcDACAEQagB +akIANwMAIARBmAFqQgA3AwAgBEEQOgD6ASAEQaABakIANwMAIARB2AFqIgUgBEEIaikCADcDACAE +QegBaiIGIARBGGopAgA3AwAgBEHgAWoiByAEQRBqKQIANwMAIARCADcDkAEgBCAEKQIANwPQASAE +QQA7AfgBIARCADcD8AEgBEGQAWogAiADEEYhASAEQegAaiAFKQMANwMAIARB8ABqIAcpAwA3AwAg +BEH4AGogBikDADcDACAEQShqIAFBCGopAwA3AwAgBEEwaiABQRBqKQMANwMAIARBOGogAUEYaikD +ADcDACAEQUBrIAFBIGopAwA3AwAgBEHIAGogAUEoaikDADcDACAEQdAAaiABQTBqKQMANwMAIARB +2ABqIAFBOGopAwA3AwAgBCAEKQPQATcDYCAEIAEpAwA3AyAgBCkD8AEhDiAELQD4ASEDIAQtAPoB +IAQtAPkBRXJBAnILIQEgBCAONwOAASAEIAM6AIgBIAQgAToAiQEgBEGoAWoiAiAEQfgAaikDADcD +ACAEQaABaiIFIARB8ABqKQMANwMAIARBmAFqIgYgBEHoAGopAwA3AwAgBCAEKQNgNwOQASAEQZAB +aiAEQSBqIANCACABQQhyECggACACKQMANwAYIAAgBSkDADcAECAAIAYpAwA3AAggACAEKQOQATcA +ACAEQYACaiQAC74LAQV/IwBBIGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEOKAYBAQEB +AQEBAQIEAQEDAQEBAQEBAQEBAQEBAQEBAQEBAQEIAQEBAQcACyABQdwARg0ECyACQQFxRSABQf8F +TXINBwJ/AkBBEUEAIAFBr7AETxsiAiACQQhyIgMgAUELdCICIANBAnRBqP/AAGooAgBBC3RJGyID +IANBBHIiAyADQQJ0Qaj/wABqKAIAQQt0IAJLGyIDIANBAnIiAyADQQJ0Qaj/wABqKAIAQQt0IAJL +GyIDIANBAWoiAyADQQJ0Qaj/wABqKAIAQQt0IAJLGyIDIANBAWoiAyADQQJ0Qaj/wABqKAIAQQt0 +IAJLGyIDQQJ0Qaj/wABqKAIAQQt0IgUgAkYgAiAFS2ogA2oiA0EhTQRAIANBAnRBqP/AAGoiBigC +AEEVdiECQe8FIQUCfwJAIANBIUYNACAGKAIEQRV2IQUgAw0AQQAMAQsgBkEEaygCAEH///8AcQsh +AwJAIAUgAkF/c2pFDQAgASADayEHQe8FIAIgAkHvBU0bIQYgBUEBayEDQQAhBQNAIAIgBkYNAyAF +IAJB4MrAAGotAABqIgUgB0sNASADIAJBAWoiAkcNAAsgAyECCyACQQFxDAILIANBIkGc+8AAEH8A +CyAGQe8FQaz7wAAQfwALRQ0HIARBADoACiAEQQA7AQggBCABQRR2QafnwABqLQAAOgALIAQgAUEE +dkEPcUGn58AAai0AADoADyAEIAFBCHZBD3FBp+fAAGotAAA6AA4gBCABQQx2QQ9xQafnwABqLQAA +OgANIAQgAUEQdkEPcUGn58AAai0AADoADCABQQFyZ0ECdiICIARBCGoiA2oiBUH7ADoAACAFQQFr +QfUAOgAAIAMgAkECayICakHcADoAACAEQRBqIgMgAUEPcUGn58AAai0AADoAACAAQQo6AAsgACAC +OgAKIAAgBCkCCDcCACAEQf0AOgARIABBCGogAy8BADsBAAwJCyAAQYAEOwEKIABCADcBAiAAQdzo +ATsBAAwICyAAQYAEOwEKIABCADcBAiAAQdzkATsBAAwHCyAAQYAEOwEKIABCADcBAiAAQdzcATsB +AAwGCyAAQYAEOwEKIABCADcBAiAAQdy4ATsBAAwFCyAAQYAEOwEKIABCADcBAiAAQdzgADsBAAwE +CyACQYACcUUNASAAQYAEOwEKIABCADcBAiAAQdzOADsBAAwDCyACQf///wdxQYCABE8NAQsCf0EA +IAFBIEkNABpBASABQf8ASQ0AGiABQYCABE8EQCABQeD//wBxQeDNCkcgAUH+//8AcUGe8ApHcSAB +QcDuCmtBeklxIAFBsJ0La0FySXEgAUHw1wtrQXFJcSABQYDwC2tB3mxJcSABQYCADGtBnnRJcSAB +QdCmDGtBe0lxIAFBgII4a0GwxVRJcSABQfCDOElxIAFBgIAITw0BGiABQcjvwABBLEGg8MAAQdAB +QfDxwABB5gMQUQwBCyABQdb1wABBKEGm9sAAQaICQcj4wABBqQIQUQtFBEAgBEEAOgAWIARBADsB +FCAEIAFBFHZBp+fAAGotAAA6ABcgBCABQQR2QQ9xQafnwABqLQAAOgAbIAQgAUEIdkEPcUGn58AA +ai0AADoAGiAEIAFBDHZBD3FBp+fAAGotAAA6ABkgBCABQRB2QQ9xQafnwABqLQAAOgAYIAFBAXJn +QQJ2IgIgBEEUaiIDaiIFQfsAOgAAIAVBAWtB9QA6AAAgAyACQQJrIgJqQdwAOgAAIARBHGoiAyAB +QQ9xQafnwABqLQAAOgAAIABBCjoACyAAIAI6AAogACAEKQIUNwIAIARB/QA6AB0gAEEIaiADLwEA +OwEADAILIAAgATYCBCAAQYABOgAADAELIABBgAQ7AQogAEIANwECIABB3MQAOwEACyAEQSBqJAAL +0wUCB38BfgJ/IAFFBEAgACgCCCEHQS0hCyAFQQFqDAELQStBgIDEACAAKAIIIgdBgICAAXEiARsh +CyABQRV2IAVqCyEIAkAgB0GAgIAEcUUEQEEAIQIMAQsgA0EQTwRAIAIgAxAwIAhqIQgMAQsgA0UN +ACADQQNxIQoCQCADQQRJBEBBACEBDAELIANBDHEhDEEAIQEDQCABIAIgCWoiBiwAAEG/f0pqIAZB +AWosAABBv39KaiAGQQJqLAAAQb9/SmogBkEDaiwAAEG/f0pqIQEgDCAJQQRqIglHDQALCyAKBEAg +AiAJaiEGA0AgASAGLAAAQb9/SmohASAGQQFqIQYgCkEBayIKDQALCyABIAhqIQgLAkAgAC8BDCIJ +IAhLBEACQAJAIAdBgICACHFFBEAgCSAIayEJQQAhAUEAIQgCQAJAAkAgB0EddkEDcUEBaw4DAAEA +AgsgCSEIDAELIAlB/v8DcUEBdiEICyAHQf///wBxIQogACgCBCEHIAAoAgAhAANAIAFB//8DcSAI +Qf//A3FPDQJBASEGIAFBAWohASAAIAogBygCEBEAAEUNAAsMBAsgACAAKQIIIg2nQYCAgP95cUGw +gICAAnI2AghBASEGIAAoAgAiByAAKAIEIgogCyACIAMQmAENA0EAIQEgCSAIa0H//wNxIQIDQCAB +Qf//A3EgAk8NAiABQQFqIQEgB0EwIAooAhARAABFDQALDAMLQQEhBiAAIAcgCyACIAMQmAENAiAA +IAQgBSAHKAIMEQEADQJBACEBIAkgCGtB//8DcSECA0AgAUH//wNxIgMgAkkhBiACIANNDQMgAUEB +aiEBIAAgCiAHKAIQEQAARQ0ACwwCCyAHIAQgBSAKKAIMEQEADQEgACANNwIIQQAPC0EBIQYgACgC +ACIBIAAoAgQiACALIAIgAxCYAQ0AIAEgBCAFIAAoAgwRAQAhBgsgBguKBQIGfwV+QgEhDQJAAkAC +QAJAIAJBwABHDQBBACECA0AgAkHAAEcEQCABIAJqIgMtAAAiBEEwa0H/AXFBCk8EQCAEQV9xQcEA +a0H/AXFBBUsNAwsgAkECaiECIANBAWotAAAiA0Ewa0H/AXFBCkkgA0FfcUHBAGtB/wFxQQZJcg0B +DAILCyABLAAQIgVBQEgNASABQRBqIQZBD0EQIAEtAABBK0YiAhshAyABIAJqIQIDQCACLQAAIgRB +wQBrQV9xQQpqIARBMGsgBEE5SxsiBEEPSw0BIAJBAWohAiAErSAJQgSGhCEJIANBAWsiAw0ACyAB +LAAgIgdBQEgNAiABQSBqIQggAUERaiAGIAVBK0YiAxshAkEPQRAgAxshAwNAIAItAAAiBEHBAGtB +X3FBCmogBEEwayAEQTlLGyIEQQ9LDQEgAkEBaiECIAStIApCBIaEIQogA0EBayIDDQALIAEsADAi +BUFASA0DIAFBMGohBiABQSFqIAggB0ErRiIDGyECQQ9BECADGyEDA0AgAi0AACIEQcEAa0FfcUEK +aiAEQTBrIARBOUsbIgRBD0sNASACQQFqIQIgBK0gC0IEhoQhCyADQQFrIgMNAAsgAUExaiAGIAVB +K0YiARshAkEPQRAgARshAwNAIAItAAAiAUHBAGtBX3FBCmogAUEwayABQTlLGyIBQQ9LDQEgAkEB +aiECIAGtIAxCBIaEIQwgA0EBayIDDQALIAAgDDcDICAAIAs3AxggACAKNwMQIAAgCTcDCEIAIQ0L +IAAgDTcDAA8LIAFBwABBAEEQQbi4wAAQvgEACyABQcAAQRBBIEHIuMAAEL4BAAsgAUHAAEEgQTBB +2LjAABC+AQALhAYCAX8BfCMAQTBrIgIkAAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJA +AkACQAJAIAAtAABBAWsOEQECAwQFBgcICQoLDA0ODxARAAsgAiAALQABOgAIIAJBAjYCFCACQYy9 +wAA2AhAgAkIBNwIcIAIgAkEIaq1CgICAgMAHhDcDKCACIAJBKGo2AhggASgCACABKAIEIAJBEGoQ +PAwRCyACIAApAwg3AwggAkECNgIUIAJBqL3AADYCECACQgE3AhwgAiACQQhqrUKAgICA0AeENwMo +IAIgAkEoajYCGCABKAIAIAEoAgQgAkEQahA8DBALIAIgACkDCDcDCCACQQI2AhQgAkGovcAANgIQ +IAJCATcCHCACIAJBCGqtQoCAgIDgB4Q3AyggAiACQShqNgIYIAEoAgAgASgCBCACQRBqEDwMDwsg +ACsDCCEDIAJBAjYCFCACQci9wAA2AhAgAkIBNwIcIAIgAkEoaq1CgICAgPAHhDcDCCACIAM5Aygg +AiACQQhqNgIYIAEoAgAgASgCBCACQRBqEDwMDgsgAiAAKAIENgIIIAJBAjYCFCACQeS9wAA2AhAg +AkIBNwIcIAIgAkEIaq1CgICAgIAIhDcDKCACIAJBKGo2AhggASgCACABKAIEIAJBEGoQPAwNCyAC +IAApAgQ3AgggAkEBNgIUIAJB/L3AADYCECACQgE3AhwgAiACQQhqrUKAgICAkAiENwMoIAIgAkEo +ajYCGCABKAIAIAEoAgQgAkEQahA8DAwLIAFB+LzAAEEKELwBDAsLIAFBhL7AAEEKELwBDAoLIAFB +jr7AAEEMELwBDAkLIAFBmr7AAEEOELwBDAgLIAFBqL7AAEEIELwBDAcLIAFBsL7AAEEDELwBDAYL +IAFBs77AAEEEELwBDAULIAFBt77AAEEMELwBDAQLIAFBw77AAEEPELwBDAMLIAFB0r7AAEENELwB +DAILIAFB377AAEEOELwBDAELIAEgACgCBCAAKAIIELwBCyACQTBqJAAL/gUBBX8gAEEIayIBIABB +BGsoAgAiA0F4cSIAaiECAkACQCADQQFxDQAgA0ECcUUNASABKAIAIgMgAGohACABIANrIgFB6ITB +ACgCAEYEQCACKAIEQQNxQQNHDQFB4ITBACAANgIAIAIgAigCBEF+cTYCBCABIABBAXI2AgQgAiAA +NgIADwsgASADEEwLAkACQAJAAkACQCACKAIEIgNBAnFFBEAgAkHshMEAKAIARg0CIAJB6ITBACgC +AEYNAyACIANBeHEiAhBMIAEgACACaiIAQQFyNgIEIAAgAWogADYCACABQeiEwQAoAgBHDQFB4ITB +ACAANgIADwsgAiADQX5xNgIEIAEgAEEBcjYCBCAAIAFqIAA2AgALIABBgAJJDQIgASAAEFVBACEB +QYCFwQBBgIXBACgCAEEBayIANgIAIAANBEHIgsEAKAIAIgAEQANAIAFBAWohASAAKAIIIgANAAsL +QYCFwQBB/x8gASABQf8fTRs2AgAPC0HshMEAIAE2AgBB5ITBAEHkhMEAKAIAIABqIgA2AgAgASAA +QQFyNgIEQeiEwQAoAgAgAUYEQEHghMEAQQA2AgBB6ITBAEEANgIACyAAQfiEwQAoAgAiA00NA0Hs +hMEAKAIAIgJFDQNBACEAQeSEwQAoAgAiBEEpSQ0CQcCCwQAhAQNAIAIgASgCACIFTwRAIAIgBSAB +KAIEakkNBAsgASgCCCEBDAALAAtB6ITBACABNgIAQeCEwQBB4ITBACgCACAAaiIANgIAIAEgAEEB +cjYCBCAAIAFqIAA2AgAPCyAAQfgBcUHQgsEAaiECAn9B2ITBACgCACIDQQEgAEEDdnQiAHFFBEBB +2ITBACAAIANyNgIAIAIMAQsgAigCCAshACACIAE2AgggACABNgIMIAEgAjYCDCABIAA2AggPC0HI +gsEAKAIAIgEEQANAIABBAWohACABKAIIIgENAAsLQYCFwQBB/x8gACAAQf8fTRs2AgAgAyAETw0A +QfiEwQBBfzYCAAsL4QQBBn8CQAJAIAAoAggiB0GAgIDAAXFFDQACQAJAIAdBgICAgAFxRQRAIAJB +EEkNASABIAIQMCEDDAILAkACQCAALwEOIgNFBEBBACECDAELIAEgAmohCEEAIQIgAyEFIAEhBANA +IAQiBiAIRg0CAn8gBkEBaiAGLAAAIgRBAE4NABogBkECaiAEQWBJDQAaIAZBA2ogBEFwSQ0AGiAG +QQRqCyIEIAZrIAJqIQIgBUEBayIFDQALC0EAIQULIAMgBWshAwwBCyACRQRAQQAhAgwBCyACQQNx +IQYCQCACQQRJBEAMAQsgAkEMcSEIA0AgAyABIAVqIgQsAABBv39KaiAEQQFqLAAAQb9/SmogBEEC +aiwAAEG/f0pqIARBA2osAABBv39KaiEDIAggBUEEaiIFRw0ACwsgBkUNACABIAVqIQQDQCADIAQs +AABBv39KaiEDIARBAWohBCAGQQFrIgYNAAsLIAMgAC8BDCIETw0AIAQgA2shBkEAIQNBACEFAkAC +QAJAIAdBHXZBA3FBAWsOAgABAgsgBiEFDAELIAZB/v8DcUEBdiEFCyAHQf///wBxIQggACgCBCEH +IAAoAgAhAANAIANB//8DcSAFQf//A3FJBEBBASEEIANBAWohAyAAIAggBygCEBEAAEUNAQwDCwtB +ASEEIAAgASACIAcoAgwRAQANAUEAIQMgBiAFa0H//wNxIQEDQCADQf//A3EiAiABSSEEIAEgAk0N +AiADQQFqIQMgACAIIAcoAhARAABFDQALDAELIAAoAgAgASACIAAoAgQoAgwRAQAhBAsgBAueBAEE +fyMAQYABayIEJAACQAJAAkAgASgCCCICQYCAgBBxRQRAIAJBgICAIHENAUEBIQIgACgCACABEEtF +DQIMAwsgACgCACECA0AgAyAEakH/AGogAkEPcSIFQTByIAVB1wBqIAVBCkkbOgAAIANBAWshAyAC +QRBJIAJBBHYhAkUNAAtBASECIAFBAUGm6sAAQQIgAyAEakGAAWpBACADaxA2RQ0BDAILIAAoAgAh +AgNAIAMgBGpB/wBqIAJBD3EiBUEwciAFQTdqIAVBCkkbOgAAIANBAWshAyACQQ9LIAJBBHYhAg0A +C0EBIQIgAUEBQabqwABBAiADIARqQYABakEAIANrEDYNAQsgASgCAEGl58AAQQIgASgCBCgCDBEB +AA0AAkAgASgCCCICQYCAgBBxRQRAIAJBgICAIHENASAAKAIEIAEQSyECDAILIAAoAgQhAkEAIQMD +QCADIARqQf8AaiACQQ9xIgBBMHIgAEHXAGogAEEKSRs6AAAgA0EBayEDIAJBD0sgAkEEdiECDQAL +IAFBAUGm6sAAQQIgAyAEakGAAWpBACADaxA2IQIMAQsgACgCBCECQQAhAwNAIAMgBGpB/wBqIAJB +D3EiAEEwciAAQTdqIABBCkkbOgAAIANBAWshAyACQQ9LIAJBBHYhAg0ACyABQQFBpurAAEECIAMg +BGpBgAFqQQAgA2sQNiECCyAEQYABaiQAIAILvQQBCH8jAEEQayIDJAAgAyABNgIEIAMgADYCACAD +QqCAgIAONwIIAn8CQAJAAkAgAigCECIJBEAgAigCFCIADQEMAgsgAigCDCIARQ0BIAIoAggiASAA +QQN0aiEEIABBAWtB/////wFxQQFqIQYgAigCACEAA0ACQCAAQQRqKAIAIgVFDQAgAygCACAAKAIA +IAUgAygCBCgCDBEBAEUNAEEBDAULQQEgASgCACADIAFBBGooAgARAAANBBogAEEIaiEAIAQgAUEI +aiIBRw0ACwwCCyAAQRhsIQogAEEBa0H/////AXFBAWohBiACKAIIIQQgAigCACEAA0ACQCAAQQRq +KAIAIgFFDQAgAygCACAAKAIAIAEgAygCBCgCDBEBAEUNAEEBDAQLQQAhB0EAIQgCQAJAAkAgBSAJ +aiIBQQhqLwEAQQFrDgIBAgALIAFBCmovAQAhCAwBCyAEIAFBDGooAgBBA3RqLwEEIQgLAkACQAJA +IAEvAQBBAWsOAgECAAsgAUECai8BACEHDAELIAQgAUEEaigCAEEDdGovAQQhBwsgAyAHOwEOIAMg +CDsBDCADIAFBFGooAgA2AghBASAEIAFBEGooAgBBA3RqIgEoAgAgAyABQQRqKAIAEQAADQMaIABB +CGohACAFQRhqIgUgCkcNAAsMAQsLAkAgBiACKAIETw0AIAMoAgAgAigCACAGQQN0aiIAKAIAIAAo +AgQgAygCBCgCDBEBAEUNAEEBDAELQQALIANBEGokAAuvFQIWfwN+IwBBEGsiFSQAQeiAwQAoAgBF +BEBB6IDBACgCACEEQeiAwQBCATcCAEH0gMEAKAIAIQpB8IDBACgCACECQfCAwQBB+JXAACkCADcC +AEH8gMEAKAIAIQVB+IDBAEGAlsAAKQIANwIAAkAgBEUgCkVyDQAgBQRAIAJBCGohCCACKQMAQn+F +QoCBgoSIkKDAgH+DIRggAiEEA0AgGFAEQANAIARB4ABrIQQgCCkDACAIQQhqIQhCgIGChIiQoMCA +f4MiGEKAgYKEiJCgwIB/UQ0ACyAYQoCBgoSIkKDAgH+FIRgLIAQgGHqnQQN2QXRsakEEaygCACID +QYQBTwRAIAMQbAsgGEIBfSAYgyEYIAVBAWsiBQ0ACwsgCiAKQQxsQRNqQXhxIgNqQQlqIgRFDQAg +AiADayAEEMwBCwsCQAJAQeyAwQAoAgBFBEBB7IDBAEF/NgIAQfSAwQAoAgAiAyAAcSEFIABBGXYi +Fq1CgYKEiJCgwIABfiEZQfCAwQAoAgAhAgNAIAIgBWopAAAiGiAZhSIYQn+FIBhCgYKEiJCgwIAB +fYNCgIGChIiQoMCAf4MiGFBFBEADQCAAIAIgGHqnQQN2IAVqIANxQXRsaiIEQQxrKAIARgRAIARB +CGsoAgAgAUYNBgsgGEIBfSAYgyIYUEUNAAsLIBogGkIBhoNCgIGChIiQoMCAf4NQRQ0CIAUgB0EI +aiIHaiADcSEFDAALAAtB3JXAABCLAQALQfiAwQAoAgBFBEAgFUEIaiEXIwBBIGsiDyQAAkACQEH8 +gMEAKAIAIghBAWoiBCAITwRAAkBB9IDBACgCACILIAtBAWoiDUEDdiICQQdsIAtBCEkbIhJBAXYg +BEkEQCASQQFqIgIgBCACIARLGyICQQhJDQEgAkH/////AU0EQEF/IAJBA3RBB25BAWtndkEBaiEE +DAQLEI0BIA8oAhwhBCAPKAIYIQIMBAtBACEEQfCAwQAoAgAhCQJAIAIgDUEHcUEAR2oiA0UNACAD +QQFHBEAgA0H+////A3EhAgNAIAQgCWoiByAHKQMAIhhCf4VCB4hCgYKEiJCgwIABgyAYQv/+/fv3 +79+//wCEfDcDACAHQQhqIgcgBykDACIYQn+FQgeIQoGChIiQoMCAAYMgGEL//v379+/fv/8AhHw3 +AwAgBEEQaiEEIAJBAmsiAg0ACwsgA0EBcUUNACAEIAlqIgQgBCkDACIYQn+FQgeIQoGChIiQoMCA +AYMgGEL//v379+/fv/8AhHw3AwALAkACQCANQQhPBEAgCSANaiAJKQAANwAADAELIA0EQCAJQQhq +IAkgDfwKAAALIA1FDQELIAlBCGohECAJQQxrIRNBASECQQAhBANAIAQhByACIQQCQCAHIAlqIhQt +AABBgAFHDQAgEyAHQXRsaiEGAkADQCAGKAIAIgIgBigCBCACGyIKIAtxIgUhAiAFIAlqKQAAQoCB +goSIkKDAgH+DIhlQBEBBCCEDA0AgAiADaiECIANBCGohAyAJIAIgC3EiAmopAABCgIGChIiQoMCA +f4MiGVANAAsLIAkgGXqnQQN2IAJqIAtxIgJqLAAAQQBOBEAgCSkDAEKAgYKEiJCgwIB/g3qnQQN2 +IQILIAIgBWsgByAFa3MgC3FBCEkNASACIAlqIgMtAAAgAyAKQRl2IgM6AAAgECACQQhrIAtxaiAD +OgAAIBMgAkF0bGohA0H/AUcEQCAGLQAAIQIgBiADLQAAOgAAIAMgAjoAACAGLQABIQIgBiADLQAB +OgABIAMgAjoAASAGLQACIQIgBiADLQACOgACIAMgAjoAAiAGLQADIQIgBiADLQADOgADIAMgAjoA +AyAGLQAEIQIgBiADLQAEOgAEIAMgAjoABCAGLQAFIQIgBiADLQAFOgAFIAMgAjoABSAGLQAGIQIg +BiADLQAGOgAGIAMgAjoABiAGLQAHIQIgBiADLQAHOgAHIAMgAjoAByAGLQAIIQIgBiADLQAIOgAI +IAMgAjoACCAGLQAJIQIgBiADLQAJOgAJIAMgAjoACSAGLQAKIQIgBiADLQAKOgAKIAMgAjoACiAG +LQALIQIgBiADLQALOgALIAMgAjoACwwBCwsgFEH/AToAACAQIAdBCGsgC3FqQf8BOgAAIANBCGog +BkEIaigAADYAACADIAYpAAA3AAAMAQsgFCAKQRl2IgI6AAAgECAHQQhrIAtxaiACOgAACyAEIAQg +DUkiB2ohAiAHDQALC0H4gMEAIBIgCGs2AgBBgYCAgHghAgwDC0EEQQggAkEESRshBAwBCxCNASAP +KAIEIQQgDygCACECDAELAkACQCAErUIMfiIYQiCIpw0AIBinIgJBeEsNACACQQdqQXhxIgMgBEEI +aiIHaiIFIANJIAVB+P///wdLcg0AQeWAwQAtAAAaIAVBCBDAASICDQFBCCAFEOcBAAsQjQEgDygC +DCEEIA8oAgghAgwBCyACIANqIQwgBwRAIAxB/wEgB/wLAAsgBEEBayIRIARBA3ZBB2wgBEEJSRsh +EEHwgMEAKAIAIQMgCARAIAxBDGshEiAMQQhqIRMgA0EMayEJIAMpAwBCf4VCgIGChIiQoMCAf4Mh +GSADIQJBACEEIAghBwNAIBlQBEADQCAEQQhqIQQgAkEIaiICKQMAQoCBgoSIkKDAgH+DIhhCgIGC +hIiQoMCAf1ENAAsgGEKAgYKEiJCgwIB/hSEZCyAMIAkgGXqnQQN2IARqIhRBdGxqIgooAgAiBSAK +KAIEIAUbIgogEXEiDmopAABCgIGChIiQoMCAf4MiGFAEQEEIIQYDQCAGIA5qIQUgBkEIaiEGIAwg +BSARcSIOaikAAEKAgYKEiJCgwIB/gyIYUA0ACwsgGUIBfSAZgyEZIAwgGHqnQQN2IA5qIBFxIg5q +LAAAQQBOBEAgDCkDAEKAgYKEiJCgwIB/g3qnQQN2IQ4LIAwgDmogCkEZdiIFOgAAIBMgDkEIayAR +cWogBToAACASIA5BdGxqIgpBCGogCSAUQXRsaiIFQQhqKAAANgAAIAogBSkAADcAACAHQQFrIgcN +AAsLQfSAwQAgETYCAEHwgMEAIAw2AgBB+IDBACAQIAhrNgIAQYGAgIB4IQIgC0UNACALIA1BDGxB +B2pBeHEiBGpBCWoiB0UNACADIARrIAcQzAELIBcgAjYCACAXIAQ2AgQgD0EgaiQACyAAIAEQtQEh +B0HwgMEAKAIAIghB9IDBACgCACIEIABxIgVqKQAAQoCBgoSIkKDAgH+DIhhQBEBBCCEDA0AgAyAF +aiECIANBCGohAyAIIAIgBHEiBWopAABCgIGChIiQoMCAf4MiGFANAAsLIAggGHqnQQN2IAVqIARx +IgVqLAAAIgNBAE4EQCAIIAgpAwBCgIGChIiQoMCAf4N6p0EDdiIFai0AACEDCyAFIAhqIBY6AAAg +CCAFQQhrIARxakEIaiAWOgAAQfiAwQBB+IDBACgCACADQQFxazYCAEH8gMEAQfyAwQAoAgBBAWo2 +AgAgCCAFQXRsaiIEQQRrIAc2AgAgBEEIayABNgIAIARBDGsgADYCAAsgBEEEaygCACEBEG8iACAB +JQEmAUHsgMEAQeyAwQAoAgBBAWo2AgAgFUEQaiQAIAALlQQBDH8gAUEBayEOIAAoAgQhCiAAKAIA +IQsgACgCCCEMAkADQCAFDQECfwJAIAIgA0kNAANAIAEgA2ohBQJAAkACQCACIANrIgdBB00EQCAC +IANHDQEgAiEDDAULAkAgBUEDakF8cSIGIAVrIgQEQEEAIQADQCAAIAVqLQAAQQpGDQUgBCAAQQFq +IgBHDQALIAQgB0EIayIATQ0BDAMLIAdBCGshAAsDQEGAgoQIIAYoAgAiCUGKlKjQAHNrIAlyQYCC +hAggBkEEaigCACIJQYqUqNAAc2sgCXJxQYCBgoR4cUGAgYKEeEcNAiAGQQhqIQYgBEEIaiIEIABN +DQALDAELQQAhAANAIAAgBWotAABBCkYNAiAHIABBAWoiAEcNAAsgAiEDDAMLIAQgB0YEQCACIQMM +AwsDQCAEIAVqLQAAQQpGBEAgBCEADAILIAcgBEEBaiIERw0ACyACIQMMAgsgACADaiIGQQFqIQMC +QCACIAZNDQAgACAFai0AAEEKRw0AQQAhBSADIQYgAwwDCyACIANPDQALCyACIAhGDQJBASEFIAgh +BiACCyEAAkAgDC0AAARAIAtBnOrAAEEEIAooAgwRAQANAQtBACEEIAAgCEcEQCAAIA5qLQAAQQpG +IQQLIAAgCGshACABIAhqIQcgDCAEOgAAIAYhCCALIAcgACAKKAIMEQEARQ0BCwtBASENCyANC8oE +Agd/AX4jAEEQayIGJAACQCAALwEMIgVFBEAgACgCACAAKAIEIAEQQCECDAELIAYgASgCDCIENgIM +IAYgASgCCCICNgIIIAYgASgCBCIDNgIEIAYgASgCACIBNgIAAkAgACkCCCIJpyIHQYCAgAhxBEAg +ACgCACABIAMgACgCBCgCDBEBAA0BIAAgB0GAgID/eXFBsICAgAJyIgc2AgggBkIBNwIAIAUgA0H/ +/wNxayIBQQAgASAFTRshBUEAIQMLIAQEQCAEQQxsIQgDQAJ/AkACQAJAIAIvAQBBAWsOAgIBAAsg +AkEEaigCAAwCCyACQQhqKAIADAELIAJBAmovAQAiBEHoB08EQEEEQQUgBEGQzgBJGwwBC0EBIARB +CkkNABpBAkEDIARB5ABJGwsgAkEMaiECIANqIQMgCEEMayIIDQALCwJAAkAgBUH//wNxIANLBEAg +BSADayEDQQAhAkEAIQECQAJAAkAgB0EddkEDcUEBaw4DAAEAAgsgAyEBDAELIANB/v8DcUEBdiEB +CyAHQf///wBxIQggACgCBCEHIAAoAgAhBANAIAJB//8DcSABQf//A3FPDQIgAkEBaiECIAQgCCAH +KAIQEQAARQ0ACwwDCyAAKAIAIAAoAgQgBhBAIQIMAQsgBCAHIAYQQA0BQQAhBSADIAFrQf//A3Eh +AQNAIAVB//8DcSIDIAFJIQIgASADTQ0BIAVBAWohBSAEIAggBygCEBEAAEUNAAsLIAAgCTcCCAwB +C0EBIQILIAZBEGokACACC/4DAQl/IwBBEGsiBCQAAn8CQCACKAIEIgNFDQAgACACKAIAIAMgASgC +DBEBAEUNAEEBDAELIAIoAgwiBgRAIAIoAggiAyAGQQxsaiEIIARBDGohCQNAAkACQAJAAkAgAy8B +AEEBaw4CAgEACwJAIAMoAgQiAkHBAE8EQCABQQxqKAIAIQYDQEEBIABB8OvAAEHAACAGEQEADQga +IAJBQGoiAkHAAEsNAAsMAQsgAkUNAwsgAEHw68AAIAIgAUEMaigCABEBAEUNAkEBDAULIAAgAygC +BCADKAIIIAFBDGooAgARAQBFDQFBAQwECyADLwECIQIgCUEAOgAAIARBADYCCAJ/QQRBBSACQZDO +AEkbIAJB6AdPDQAaQQEgAkEKSQ0AGkECQQMgAkHkAEkbCyIGIARBCGoiCmoiB0EBayIFIAIgAkEK +biILQQpsa0EwcjoAAAJAIAUgCkYNACAHQQJrIgUgC0EKcEEwcjoAACAEQQhqIAVGDQAgB0EDayIF +IAJB5ABuQQpwQTByOgAAIARBCGogBUYNACAHQQRrIgUgAkHoB25BCnBBMHI6AAAgBEEIaiAFRg0A +IAdBBWsgAkGQzgBuQTByOgAACyAAIARBCGogBiABQQxqKAIAEQEARQ0AQQEMAwsgA0EMaiIDIAhH +DQALC0EACyAEQRBqJAALzAQBCn8jAEEwayIGJAACQAJAAkACf0EAIAFBQHEiCkUNABogBkEIaiAA +NgIAQQEgCkHAAEYNABogBiAAQUBrNgIMIApBgAFHDQFBAgshByABQT9xIQEgBUEFdiIJIAcgByAJ +SxsiCARAIAZBCGohCSADQQRyIQsgCEEFdCEMQQAhAwNAIAkoAgAhCCAGQShqIg0gAkEYaikCADcD +ACAGQSBqIg4gAkEQaikCADcDACAGQRhqIg8gAkEIaikCADcDACAGIAIpAgA3AxAgBkEQaiAIQcAA +QgAgCxAoIAMgBGoiCEEYaiANKQMANwAAIAhBEGogDikDADcAACAIQQhqIA8pAwA3AAAgCCAGKQMQ +NwAAIAlBBGohCSAMIANBIGoiA0cNAAsLAkAgAQRAIAUgB0EFdCICSQ0BIAUgAmsiA0EfTQ0DIAFB +IEcNBCACIARqIgEgACAKaiIAKQAANwAAIAFBGGogAEEYaikAADcAACABQRBqIABBEGopAAA3AAAg +AUEIaiAAQQhqKQAANwAAIAdBAWohBwsgBkEwaiQAIAcPCyACIAVB5LrAABDQAQALIAYgAEGAAWo2 +AhBBnLzAAEErIAZBEGpByLzAAEH0usAAEHwAC0EgIANBxLrAABDRAQALIwBBMGsiACQAIABBIDYC +BCAAIAE2AgAgAEEDNgIMIABBkP/AADYCCCAAQgI3AhQgACAAQQRqrUKAgICAgAmENwMoIAAgAK1C +gICAgIAJhDcDICAAIABBIGo2AhAgAEEIakHUusAAEJ8BAAuEBAIHfwF8IwBB0ABrIgMkAAJAAkAC +QAJAAkAgACgCACIEJQFBgQElARAHRQRAIAQlARAIDgICAQMLIANBBzoAMCADQTBqIAEgAhB+IQAM +BAtBASEGC0EBIQdBACEADAELIANBEGogBCUBEAkgAygCEARAIAMrAxghCkEDIQBBASEHDAELIANB +CGogBBDqAQJ/IAMoAggiBARAIAMoAgwiBSEGQQUMAQsCQAJAIAAoAgAlARAjBEAgA0EwaiAAEHUg +AygCOCEGIAMoAjQhBCADKAIwIQgMAQsgACgCACUBEB1FDQEgAyAAKAIAELcBIgU2AkggA0EwaiAD +QcgAahB1IAMoAjghBiADKAI0IQQgAygCMCEIIAVBhAFJDQAgBRBsCyAIQYCAgIB4Rg0AQQEhB0EG +DAELIANBATYCNCADQeiUwAA2AjAgA0IBNwI8IAMgAK1CgICAgOAChDcDSCADIANByABqNgI4IANB +JGogA0EwahBHQYCAgIB4IQggAygCLCEGIAMoAighBCADKAIkIQVBEQshACAGrb8hCiAHIQkLIAMg +CjkDOCADIAQ2AjQgAyAGOgAxIAMgADoAMCADQTBqIAEgAhB+IQACQCAJRQRAIAcgBUVyRQ0BDAIL +IAgEQCAEIAgQzAELIAVFIAdyDQELIAQgBRDMAQsgA0HQAGokACAAC+QDAQV/IwBBEGsiCCQAAkAC +QAJAAkACQCABKAIIQQFGBEAgASgCACEFIAEoAgQhBCABQQwQzAFBHUGBASAEQQp2Z0ECdGsgBEH/ +/wdLGyEGIAIgBWsiByADaiEDIAIgBUYEQCAGIQEMBgsgBkEFdiICIAdqIgFBgICAwABPBEBB5YDB +AC0AABpBFEEEEMABIgFFDQIgAUEBNgIQIAEgAiADajYCCCABIAUgAms2AgQgASACIARqNgIAIAEg +BkECdkEHcTYCDAwFCyAGQR1xIAFBBXRyIQEMBAsgA0EASA0BAkAgA0UEQEEBIQUMAQtB5YDBAC0A +ABpBASEEIANBARDAASIFRQ0CCyADBEAgBSACIAP8CgAACyABIAEoAggiAkEBazYCCCACQQFGBEAg +ASgCACABQQRqKAIAIgRBARCzAUUNAyAEEMwBIAFBDBDMAQtBHUGBASADQQp2Z0ECdGsgA0H//wdL +GyEBIAMhBAwEC0EEQRQQ5wEACyAEIANB5LPAABCyAQALQaC1wABBKyAIQQ9qQZC1wABB3LXAABB8 +AAsgAyAHayICQQAgAiADTRshAyAEIAdrIQQgBSAHaiEFCyAAIAE2AgwgACAENgIIIAAgAzYCBCAA +IAU2AgAgCEEQaiQAC/kDAQJ/IAAgAWohAgJAAkAgACgCBCIDQQFxDQAgA0ECcUUNASAAKAIAIgMg +AWohASAAIANrIgBB6ITBACgCAEYEQCACKAIEQQNxQQNHDQFB4ITBACABNgIAIAIgAigCBEF+cTYC +BCAAIAFBAXI2AgQgAiABNgIADAILIAAgAxBMCwJAAkACQCACKAIEIgNBAnFFBEAgAkHshMEAKAIA +Rg0CIAJB6ITBACgCAEYNAyACIANBeHEiAhBMIAAgASACaiIBQQFyNgIEIAAgAWogATYCACAAQeiE +wQAoAgBHDQFB4ITBACABNgIADwsgAiADQX5xNgIEIAAgAUEBcjYCBCAAIAFqIAE2AgALIAFBgAJP +BEAgACABEFUPCyABQfgBcUHQgsEAaiECAn9B2ITBACgCACIDQQEgAUEDdnQiAXFFBEBB2ITBACAB +IANyNgIAIAIMAQsgAigCCAshASACIAA2AgggASAANgIMIAAgAjYCDCAAIAE2AggPC0HshMEAIAA2 +AgBB5ITBAEHkhMEAKAIAIAFqIgE2AgAgACABQQFyNgIEIABB6ITBACgCAEcNAUHghMEAQQA2AgBB +6ITBAEEANgIADwtB6ITBACAANgIAQeCEwQBB4ITBACgCACABaiIBNgIAIAAgAUEBcjYCBCAAIAFq +IAE2AgALC44DAQR/AkACQAJAAkACQCAHIAhWBEAgByAIfSAIWA0BAkAgBiAHIAZ9VCAHIAZCAYZ9 +IAhCAYZacUUEQCAGIAhWDQEMBwsgAiADSQ0DDAULIAcgBiAIfSIGfSAGVg0FIAIgA0kNAyABIANq +IQwgASEKAkACQANAIAMgCUYNASAJQQFqIQkgCkEBayIKIANqIgstAABBOUYNAAsgCyALLQAAQQFq +OgAAIAMgCWtBAWogA08NASAJQQFrIgVFDQEgC0EBakEwIAX8CwAMAQsCQCADRQRAQTEhCQwBCyAB +QTE6AAAgA0EBRgRAQTAhCQwBC0EwIQkgA0EBayIKRQ0AIAFBAWpBMCAK/AsACyAEQQFqwSIEIAXB +TCACIANNcg0AIAwgCToAACADQQFqIQMLIAIgA08NBCADIAJBqOXAABDRAQALIABBADYCAA8LIABB +ADYCAA8LIAMgAkG45cAAENEBAAsgAyACQZjlwAAQ0QEACyAAIAQ7AQggACADNgIEIAAgATYCAA8L +IABBADYCAAunAwECfwJAAkACQAJAIAAtAGgiAwRAIANBwQBPDQMgAkHAACADayIEIAIgBEkbIgQE +QCAAIANqIAEgBPwKAAALIAAgAC0AaCAEaiIDOgBoIAEgBGohASACIARrIgJFBEBBACECDAILIABB +QGsgAEHAACAAKQNgIAAtAGogAC0AaUVyECggAEIANwMAIABBADoAaCAAQQhqQgA3AwAgAEEQakIA +NwMAIABBGGpCADcDACAAQSBqQgA3AwAgAEEoakIANwMAIABBMGpCADcDACAAQThqQgA3AwAgACAA +LQBpQQFqOgBpC0EAIQMgAkHBAEkNASAAQUBrIQQgAC0AaSEDA0AgBCABQcAAIAApA2AgAC0AaiAD +Qf8BcUVyECggACAALQBpQQFqIgM6AGkgAUFAayEBIAJBQGoiAkHAAEsNAAsgAC0AaCEDCyADQf8B +cSIDQcEATw0CCyACQcAAIANrIgQgAiAESRsiAgRAIAAgA2ogASAC/AoAAAsgACAALQBoIAJqOgBo +IAAPCyADQcAAQaS6wAAQ0AEACyADQcAAQaS6wAAQ0AEAC48DAQd/IwBBEGsiBCQAAkACQAJAAkAg +ASgCBCICBEAgASgCACEHIAJBA3EhBQJAIAJBBEkEQEEAIQIMAQsgB0EcaiEDIAJBfHEhCEEAIQID +QCADKAIAIANBCGsoAgAgA0EQaygCACADQRhrKAIAIAJqampqIQIgA0EgaiEDIAggBkEEaiIGRw0A +CwsgBQRAIAZBA3QgB2pBBGohAwNAIAMoAgAgAmohAiADQQhqIQMgBUEBayIFDQALCyABKAIMRQ0C +IAJBD0sNASAHKAIEDQEMAwtBACECIAEoAgxFDQILIAJBACACQQBKG0EBdCECC0EAIQUgAkEATgRA +IAJFDQFB5YDBAC0AABpBASEFIAJBARDAASIDDQILIAUgAkGwycAAELIBAAtBASEDQQAhAgsgBEEA +NgIIIAQgAzYCBCAEIAI2AgAgBEGwyMAAIAEQPEUEQCAAIAQpAgA3AgAgAEEIaiAEQQhqKAIANgIA +IARBEGokAA8LQdDJwABB1gAgBEEPakHAycAAQcDKwAAQfAAL5wIBBX8CQCABQc3/e0EQIAAgAEEQ +TRsiAGtPDQAgAEEQIAFBC2pBeHEgAUELSRsiBGpBDGoQKSICRQ0AIAJBCGshAQJAIABBAWsiAyAC +cUUEQCABIQAMAQsgAkEEayIFKAIAIgZBeHEgAiADakEAIABrcUEIayICIABBACACIAFrQRBNG2oi +ACABayICayEDIAZBA3EEQCAAIAMgACgCBEEBcXJBAnI2AgQgACADaiIDIAMoAgRBAXI2AgQgBSAC +IAUoAgBBAXFyQQJyNgIAIAEgAmoiAyADKAIEQQFyNgIEIAEgAhBEDAELIAEoAgAhASAAIAM2AgQg +ACABIAJqNgIACwJAIAAoAgQiAUEDcUUNACABQXhxIgIgBEEQak0NACAAIAQgAUEBcXJBAnI2AgQg +ACAEaiIBIAIgBGsiBEEDcjYCBCAAIAJqIgIgAigCBEEBcjYCBCABIAQQRAsgAEEIaiEDCyADC+oC +AgZ/An4jAEEgayIFJABBFCEDIAAiCULoB1oEQCAJIQoDQCAFQQxqIANqIgRBA2sgCiAKQpDOAIAi +CUKQzgB+faciBkH//wNxQeQAbiIHQQF0IghBqerAAGotAAA6AAAgBEEEayAIQajqwABqLQAAOgAA +IARBAWsgBiAHQeQAbGtB//8DcUEBdCIGQanqwABqLQAAOgAAIARBAmsgBkGo6sAAai0AADoAACAD +QQRrIQMgCkL/rOIEViAJIQoNAAsLIAlCCVYEQCADIAVqQQtqIAmnIgQgBEH//wNxQeQAbiIEQeQA +bGtB//8DcUEBdCIGQanqwABqLQAAOgAAIANBAmsiAyAFQQxqaiAGQajqwABqLQAAOgAAIAStIQkL +IABQRSAJUHFFBEAgA0EBayIDIAVBDGpqIAmnQQF0QR5xQanqwABqLQAAOgAACyACIAFBAUEAIAVB +DGogA2pBFCADaxA2IAVBIGokAAvQAgEEfyMAQfAAayIDJAACQCAAAn4CQCABKAIEIgQgASgCDEcE +QCABIARBEGo2AgQgBCgCDCEFIAQoAgAhASACKAIEIANByABqIAQoAgQiBiAEKAIIEDcgAygCSCIE +RQRAIANBQGsgA0HoAGopAwA3AwAgA0E4aiADQeAAaikDADcDACADQTBqIANB2ABqKQMANwMAIAMg +AykDUDcDKAsgAQRAIAYgARDMAQsgBEEBcUUNAUEBOgAAQgAMAgsgAEICNwMADAILIANBIGogA0FA +aykDADcDACADQRhqIANBOGopAwA3AwAgA0EQaiADQTBqKQMANwMAIAMgAykDKDcDCEIBCzcDACAA +IAMpAwg3AwggACAFNgIoIABBEGogA0EQaikDADcDACAAQRhqIANBGGopAwA3AwAgAEEgaiADQSBq +KQMANwMACyADQfAAaiQAC+YCAQh/IwBBEGsiBSQAQQohAiAAIgNB6AdPBEAgAyEEA0AgBUEGaiAC +aiIGQQNrIAQgBEGQzgBuIgNBkM4AbGsiB0H//wNxQeQAbiIIQQF0IglBqerAAGotAAA6AAAgBkEE +ayAJQajqwABqLQAAOgAAIAZBAWsgByAIQeQAbGtB//8DcUEBdCIHQanqwABqLQAAOgAAIAZBAmsg +B0Go6sAAai0AADoAACACQQRrIQIgBEH/rOIESyADIQQNAAsLAkAgA0EJTQRAIAMhBAwBCyACIAVq +QQVqIAMgA0H//wNxQeQAbiIEQeQAbGtB//8DcUEBdCIDQanqwABqLQAAOgAAIAJBAmsiAiAFQQZq +aiADQajqwABqLQAAOgAAC0EAIAAgBBtFBEAgAkEBayICIAVBBmpqIARBAXRBHnFBqerAAGotAAA6 +AAALIAFBAUEBQQAgBUEGaiACakEKIAJrEDYgBUEQaiQAC4IDAQR/IAAoAgwhAgJAAkACQCABQYAC +TwRAIAAoAhghAwJAAkAgACACRgRAIABBFEEQIAAoAhQiAhtqKAIAIgENAUEAIQIMAgsgACgCCCIB +IAI2AgwgAiABNgIIDAELIABBFGogAEEQaiACGyEEA0AgBCEFIAEiAkEUaiACQRBqIAIoAhQiARsh +BCACQRRBECABG2ooAgAiAQ0ACyAFQQA2AgALIANFDQICQCAAKAIcQQJ0QcCBwQBqIgEoAgAgAEcE +QCADKAIQIABGDQEgAyACNgIUIAINAwwECyABIAI2AgAgAkUNBAwCCyADIAI2AhAgAg0BDAILIAAo +AggiACACRwRAIAAgAjYCDCACIAA2AggPC0HYhMEAQdiEwQAoAgBBfiABQQN2d3E2AgAPCyACIAM2 +AhggACgCECIBBEAgAiABNgIQIAEgAjYCGAsgACgCFCIARQ0AIAIgADYCFCAAIAI2AhgPCw8LQdyE +wQBB3ITBACgCAEF+IAAoAhx3cTYCAAvgAgEEfyMAQRBrIgIkAAJAIAFBgAFPBEAgAkEMaiIEQQJy +IQMgAkEANgIMAkAgAUGAEE8EQCAEQQNyIQUgAUGAgARPBEAgAkEQaiEDIAIgAUESdkHwAXI6AAwg +AiABQQZ2QT9xQYABcjoADiACIAFBDHZBP3FBgAFyOgANIAUhBAwCCyACIAFBDHZB4AFyOgAMIAIg +AUEGdkE/cUGAAXI6AA0gAyEEIAUhAwwBCyACQQxqQQFyIQQgAiABQQZ2QcABcjoADAsgBCABQT9x +QYABcjoAACADIAJBDGprIgEgACgCACAAKAIIIgNrSwRAIAAgAyABQQFBARBXIAAoAgghAwsgAQRA +IAAoAgQgA2ogAkEMaiAB/AoAAAsgACABIANqNgIIDAELIAAoAggiAyAAKAIARgRAIABBoITAABBx +CyAAKAIEIANqIAE6AAAgACADQQFqNgIICyACQRBqJABBAAvgAgEEfyMAQRBrIgIkAAJAIAFBgAFP +BEAgAkEMaiIEQQJyIQMgAkEANgIMAkAgAUGAEE8EQCAEQQNyIQUgAUGAgARPBEAgAkEQaiEDIAIg +AUESdkHwAXI6AAwgAiABQQZ2QT9xQYABcjoADiACIAFBDHZBP3FBgAFyOgANIAUhBAwCCyACIAFB +DHZB4AFyOgAMIAIgAUEGdkE/cUGAAXI6AA0gAyEEIAUhAwwBCyACQQxqQQFyIQQgAiABQQZ2QcAB +cjoADAsgBCABQT9xQYABcjoAACADIAJBDGprIgEgACgCACAAKAIIIgNrSwRAIAAgAyABQQFBARBX +IAAoAgghAwsgAQRAIAAoAgQgA2ogAkEMaiAB/AoAAAsgACABIANqNgIIDAELIAAoAggiAyAAKAIA +RgRAIABBhJDAABBxCyAAKAIEIANqIAE6AAAgACADQQFqNgIICyACQRBqJABBAAuzAgEBfyMAQfAA +ayIGJAAgBiABNgIMIAYgADYCCCAGIAM2AhQgBiACNgIQIAZBvIDBACgCADYCHCAGQbCAwQAoAgA2 +AhgCQCAEKAIABEAgBkEwaiAEQRBqKQIANwMAIAZBKGogBEEIaikCADcDACAGIAQpAgA3AyAgBkEE +NgJcIAZB0OnAADYCWCAGQgQ3AmQgBiAGQRBqrUKAgICA8AuENwNQIAYgBkEIaq1CgICAgPALhDcD +SCAGIAZBIGqtQoCAgICQDIQ3A0AMAQsgBkEDNgJcIAZBnOnAADYCWCAGQgM3AmQgBiAGQRBqrUKA +gICA8AuENwNIIAYgBkEIaq1CgICAgPALhDcDQAsgBiAGQRhqrUKAgICAgAyENwM4IAYgBkE4ajYC +YCAGQdgAaiAFEJ8BAAvyAgEBfwJAIAIEQCABLQAAQTBNDQEgBUECOwEAAkACQAJAAkACQCADwSIG +QQBKBEAgBSABNgIEIAIgA0H//wNxIgNLDQEgBUEAOwEMIAUgAjYCCCAFIAMgAms2AhAgBA0CQQIh +AQwFCyAFIAI2AiAgBSABNgIcIAVBAjsBGCAFQQA7AQwgBUECNgIIIAVB4ebAADYCBCAFQQAgBmsi +AzYCEEEDIQEgAiAETw0EIAQgAmsiAiADTQ0EIAIgBmohBAwDCyAFQQI7ARggBUEBNgIUIAVB4ObA +ADYCECAFQQI7AQwgBSADNgIIIAUgAiADayICNgIgIAUgASADajYCHCACIARJDQFBAyEBDAMLIAVB +ATYCICAFQeDmwAA2AhwgBUECOwEYDAELIAQgAmshBAsgBSAENgIoIAVBADsBJEEEIQELIAAgATYC +BCAAIAU2AgAPC0HI48AAQSFB7OXAABCUAQALQfzlwABBH0Gc5sAAEJQBAAvKAgEGfyABIAJBAXRq +IQkgAEGA/gNxQQh2IQogAEH/AXEhDAJAAkACQAJAA0AgAUECaiELIAcgAS0AASICaiEIIAogAS0A +ACIBRwRAIAEgCksNBCAIIQcgCyIBIAlHDQEMBAsgByAISw0BIAQgCEkNAiADIAdqIQEDQCACRQRA +IAghByALIgEgCUcNAgwFCyACQQFrIQIgAS0AACABQQFqIQEgDEcNAAsLQQAhAgwDCyAHIAhBuO/A +ABDSAQALIAggBEG478AAENEBAAsgAEH//wNxIQcgBSAGaiEDQQEhAgNAIAVBAWohAAJAIAUsAAAi +AUEATgRAIAAhBQwBCyAAIANHBEAgBS0AASABQf8AcUEIdHIhASAFQQJqIQUMAQtBqO/AABDUAQAL +IAcgAWsiB0EASA0BIAJBAXMhAiADIAVHDQALCyACQQFxC8oCAQN/IwBBEGsiAiQAAkAgAUGAAU8E +QCACQQA2AgwCfyABQYAQTwRAIAFBgIAETwRAIAJBDGpBA3IhBCACIAFBEnZB8AFyOgAMIAIgAUEG +dkE/cUGAAXI6AA4gAiABQQx2QT9xQYABcjoADUEEDAILIAJBDGpBAnIhBCACIAFBDHZB4AFyOgAM +IAIgAUEGdkE/cUGAAXI6AA1BAwwBCyACQQxqQQFyIQQgAiABQQZ2QcABcjoADEECCyEDIAQgAUE/ +cUGAAXI6AAAgACgCACAAKAIIIgFrIANJBEAgACABIAMQZyAAKAIIIQELIAMEQCAAKAIEIAFqIAJB +DGogA/wKAAALIAAgASADajYCCAwBCyAAKAIIIgMgACgCAEYEQCAAQdDKwAAQcQsgACADQQFqNgII +IAAoAgQgA2ogAToAAAsgAkEQaiQAQQALxgIBAn8jAEEQayICJAACQCABQYABTwRAIAJBADYCDAJ/ +IAFBgBBPBEAgAUGAgARPBEAgAiABQT9xQYABcjoADyACIAFBEnZB8AFyOgAMIAIgAUEGdkE/cUGA +AXI6AA4gAiABQQx2QT9xQYABcjoADUEEDAILIAIgAUE/cUGAAXI6AA4gAiABQQx2QeABcjoADCAC +IAFBBnZBP3FBgAFyOgANQQMMAQsgAiABQT9xQYABcjoADSACIAFBBnZBwAFyOgAMQQILIgEgACgC +ACAAKAIIIgNrSwRAIAAgAyABEF8gACgCCCEDCyABBEAgACgCBCADaiACQQxqIAH8CgAACyAAIAEg +A2o2AggMAQsgACgCCCIDIAAoAgBGBEAgAEHkw8AAEHELIAAoAgQgA2ogAToAACAAIANBAWo2AggL +IAJBEGokAEEAC68IAQh/IwBB8ABrIgIkACACQQhqIQQjAEEgayIDJAAgAyAAaSIBNgIcAkACQAJA +AkACQAJAIAFBAUYEQCAAQcAATQ0BIANBiIHBADYCGEGMgcEALQAAQQNHBH8gAyADQRhqNgIcIAMg +A0EcajYCACMAQSBrIgEkAAJAAkACQAJAAkACQEGMgcEALQAAQQFrDgMCBAEAC0GMgcEAQQI6AAAg +AygCACIGKAIAIQUgBkEANgIAIAVFDQIgBSgCAEEINgIAQYyBwQBBAzoAAAsgAUEgaiQADAMLIAFB +ADYCGCABQQE2AgwgAUGcm8AANgIIDAkLQeCcwAAQ1AEACyABQQA2AhggAUEBNgIMIAFB3JvAADYC +CAwHCyADKAIYBUGIgcEACygCACIBRQ0CIANBgIHBADYCGCAAIAFuIgZBhIHBAC0AAEEDRwR/IAMg +A0EYajYCHCADIANBHGo2AgAjAEEgayIBJAACQAJAAkACQAJAAkBBhIHBAC0AAEEBaw4DAgQBAAtB +hIHBAEECOgAAIAMoAgAiCCgCACEFIAhBADYCACAFRQ0CIAUoAgBBAjYCAEGEgcEAQQM6AAALIAFB +IGokAAwDCyABQQA2AhggAUEBNgIMIAFBnJvAADYCCAwJC0HgnMAAENQBAAsgAUEANgIYIAFBATYC +DCABQdybwAA2AggMBwsgAygCGAVBgIHBAAsoAgAgAGwiAU8NAyABQQBIDQRB5YDBAC0AABpBASEH +IAFBARDAASIFRQ0EIAQgATYCHCAEIAY2AhggBEHwnMAANgIIIARCADcDACAEQQA2AiggBCAFNgIk +IAQgATYCICAEIABBAWsiAK0gAGdBIHOthjcDECADQSBqJAAMBgsgA0EANgIAIwBBEGsiACQAIABB +iJbAADYCDCAAIANBHGo2AgggAEEIakG0sMAAIABBDGpBtLDAACADQfCWwAAQTwALQYCXwABBKEGo +l8AAEJQBAAtBuJfAABCaAQALQciXwABBL0H4l8AAEJQBAAsgByABQYiYwAAQsgEACyABQgQ3AhAg +AUEIakHUmcAAEJ8BAAsgAkHoAGogAkEwaikDADcCACACQeAAaiACQShqKQMANwIAIAJB2ABqIAJB +IGopAwA3AgAgAkHQAGogAkEYaikDADcCACACQcgAaiACQRBqKQMANwIAQeWAwQAtAAAaIAIgAikD +CDcCQEHAAEEIEMABIgBFBEBBCEHAABDnAQALIABBADYCCCAAQoGAgIAQNwMAIAAgAikCPDcCDCAA +QRRqIAJBxABqKQIANwIAIABBHGogAkHMAGopAgA3AgAgAEEkaiACQdQAaikCADcCACAAQSxqIAJB +3ABqKQIANwIAIABBNGogAkHkAGopAgA3AgAgAEE8aiACQewAaigCADYCACACQfAAaiQAIABBCGoL +xAIBBH8gAEIANwIQIAACf0EAIAFBgAJJDQAaQR8gAUH///8HSw0AGiABQQYgAUEIdmciA2t2QQFx +IANBAXRrQT5qCyICNgIcIAJBAnRBwIHBAGohBEEBIAJ0IgNB3ITBACgCAHFFBEAgBCAANgIAIAAg +BDYCGCAAIAA2AgwgACAANgIIQdyEwQBB3ITBACgCACADcjYCAA8LAkACQCABIAQoAgAiAygCBEF4 +cUYEQCADIQIMAQsgAUEZIAJBAXZrQQAgAkEfRxt0IQUDQCADIAVBHXZBBHFqIgQoAhAiAkUNAiAF +QQF0IQUgAiEDIAIoAgRBeHEgAUcNAAsLIAIoAggiASAANgIMIAIgADYCCCAAQQA2AhggACACNgIM +IAAgATYCCA8LIARBEGogADYCACAAIAM2AhggACAANgIMIAAgADYCCAv3AgEEfyMAQTBrIgAkAAJA +AkBByIDBACgCAEUEQEHggMEAKAIAIQFB4IDBAEEANgIAIAFFDQEgAEEYaiABEQcAIABBEGoiAiAA +QSRqKQIANwMAIAAgACkCHDcDCCAAKAIYIQFByIDBACgCACIDDQICQCADRQ0AQcyAwQAoAgAiAkUN +AEHQgMEAKAIAIAJBAnQQzAELQcyAwQAgATYCAEHIgMEAQQE2AgBB0IDBACAAKQMINwIAQdiAwQAg +AEEQaikDADcCAAsgAEEwaiQAQcyAwQAPCyAAQQA2AiggAEEBNgIcIABBqL/AADYCGCAAQgQ3AiAg +AEEYakGUwMAAEJ8BAAsgAEEoaiACKQMANwIAIAAgACkDCDcCICAAIAE2AhwgAEEBNgIYAkAgAEEY +aiIBKAIARQ0AIAEoAgQiAkUNACABKAIIIAJBAnQQzAELIABBADYCKCAAQQE2AhwgAEG0wMAANgIY +IABCBDcCICABQbzAwAAQnwEAC/wBAgR/AX4jAEEgayIFJAACQAJAIARFDQAgASABIAJqIgJLDQAg +AyAEakEBa0EAIANrca0gAiAAKAIAIgFBAXQiBiACIAZLGyICQQhBBEEBIARBgQhJGyAEQQFGGyIG +IAIgBksbIgatfiIJQiCIUEUNACAJpyIIQYCAgIB4IANrSw0AQQAhAiAFIAEEfyAFIAEgBGw2Ahwg +BSAAKAIENgIUIAMFIAILNgIYIAVBCGogAyAIIAVBFGoQcyAFKAIIQQFHDQEgBSgCECECIAUoAgwh +BwsgByACQYSMwAAQsgEACyAFKAIMIQEgACAGNgIAIAAgATYCBCAFQSBqJAALygECBH8BfiMAQSBr +IgMkAAJAAkAgASABIAJqIgJLDQBBCCACIAAoAgAiAUEBdCIEIAIgBEsbIgIgAkEITRsiBK0iB0Ig +iFBFDQAgB6ciBUH/////B0sNACADIAEEfyADIAE2AhwgAyAAKAIENgIUQQEFQQALNgIYIANBCGpB +ASAFIANBFGoQcyADKAIIQQFHDQEgAygCECECIAMoAgwhBgsgBiACQeCawAAQsgEACyADKAIMIQEg +ACAENgIAIAAgATYCBCADQSBqJAALiQIBAX8jAEEQayICJAAgACgCACEAAn8gAS0AC0EYcUUEQCAB +KAIAIAAgASgCBCgCEBEAAAwBCyACQQA2AgwgASACQQxqAn8gAEGAAU8EQCAAQYAQTwRAIABBgIAE +TwRAIAIgAEE/cUGAAXI6AA8gAiAAQRJ2QfABcjoADCACIABBBnZBP3FBgAFyOgAOIAIgAEEMdkE/ +cUGAAXI6AA1BBAwDCyACIABBP3FBgAFyOgAOIAIgAEEMdkHgAXI6AAwgAiAAQQZ2QT9xQYABcjoA +DUEDDAILIAIgAEE/cUGAAXI6AA0gAiAAQQZ2QcABcjoADEECDAELIAIgADoADEEBCxA6CyACQRBq +JAALqgICA38BfiMAQUBqIgIkACABKAIAQYCAgIB4RgRAIAEoAgwhAyACQSRqIgRBADYCACACQoCA +gIAQNwIcIAJBMGogAygCACIDQQhqKQIANwMAIAJBOGogA0EQaikCADcDACACIAMpAgA3AyggAkEc +akHUxMAAIAJBKGoQPBogAkEYaiAEKAIAIgM2AgAgAiACKQIcIgU3AxAgAUEIaiADNgIAIAEgBTcC +AAsgASkCACEFIAFCgICAgBA3AgAgAkEIaiIDIAFBCGoiASgCADYCACABQQA2AgBB5YDBAC0AABog +AiAFNwMAQQxBBBDAASIBRQRAQQRBDBDnAQALIAEgAikDADcCACABQQhqIAMoAgA2AgAgAEHwxsAA +NgIEIAAgATYCACACQUBrJAALmgIBA38jAEEQayIGJAAgASABKAIIIgVBACAFQQFHGzYCCAJAAkAC +QCAFQQFGBEAgASgCBCEEIAEoAgAhBSABQQwQzAEgA0UNASAFIAIgA/wKAAAMAQsgA0EASA0BAkAg +A0UEQEEBIQUMAQtB5YDBAC0AABpBASEEIANBARDAASIFRQ0CCyADBEAgBSACIAP8CgAACyABIAEo +AggiAkEBazYCCCADIQQgAkEBRw0AIAEoAgAgAUEEaigCACIEQQEQswFFDQIgBBDMASABQQwQzAEg +AyEECyAAIAM2AgggACAFNgIEIAAgBDYCACAGQRBqJAAPCyAEIANB5LPAABCyAQALQaC1wABBKyAG +QQ9qQZC1wABB3LXAABB8AAuCAgIBfgJ/IwBBgAFrIgQkACAAKAIAKQMAIQICfwJAIAEoAggiAEGA +gIAQcUUEQCAAQYCAgCBxDQEgAkEBIAEQSQwCC0EAIQADQCAAIARqQf8AaiACp0EPcSIDQTByIANB +1wBqIANBCkkbOgAAIABBAWshACACQg9WIAJCBIghAg0ACyABQQFBpurAAEECIAAgBGpBgAFqQQAg +AGsQNgwBC0EAIQADQCAAIARqQf8AaiACp0EPcSIDQTByIANBN2ogA0EKSRs6AAAgAEEBayEAIAJC +D1YgAkIEiCECDQALIAFBAUGm6sAAQQIgACAEakGAAWpBACAAaxA2CyAEQYABaiQAC4gCAQV/AkAC +QAJAAkAgASgCACIBQQFxBEBBHUGBASACIAFBfnEiBWsiBiADaiIBQQp2Z0ECdGsgAUH//wdLGyEE +IAIgBUYEQCAEIQIgASEDDAULIARBBXYiByAGaiICQYCAgMAASQ0CQeWAwQAtAAAaQRRBBBDAASIC +RQ0BIAJBATYCECACIAEgB2oiCDYCCCACIAUgB2s2AgQgAiAINgIAIAIgBEECdkEHcTYCDAwDCyAA +IAEgAiADEEMPC0EEQRQQ5wEACyAEQR1xIAJBBXRyIQILIAEgBmsiBEEAIAEgBE8bIQEgBSAGaiEF +CyAAIAI2AgwgACADNgIIIAAgATYCBCAAIAU2AgALgwIBBX8CQAJAAkACQCABKAIAIgFBAXEEQEEd +QYEBIAIgAWsiBiADaiIEQQp2Z0ECdGsgBEH//wdLGyEFIAEgAkYEQCAFIQIgBCEDDAULIAVBBXYi +ByAGaiICQYCAgMAASQ0CQeWAwQAtAAAaQRRBBBDAASICRQ0BIAJBATYCECACIAQgB2oiCDYCCCAC +IAEgB2s2AgQgAiAINgIAIAIgBUECdkEHcTYCDAwDCyAAIAEgAiADEEMPC0EEQRQQ5wEACyAFQR1x +IAJBBXRyIQILIAQgBmsiBUEAIAQgBU8bIQQgASAGaiEBCyAAIAI2AgwgACADNgIIIAAgBDYCBCAA +IAE2AgAL1QECBH8BfiMAQSBrIgMkAAJAAkAgASABIAJqIgJLBEBBACEBDAELQQAhAUEIIAIgACgC +ACIFQQF0IgQgAiAESxsiAiACQQhNGyIErSIHQiCIUEUNACAHpyIGQf////8HSw0AIAMgBQR/IAMg +BTYCHCADIAAoAgQ2AhRBAQVBAAs2AhggA0EIakEBIAYgA0EUahBzIAMoAghBAUcNASADKAIQIQIg +AygCDCEBCyABIAJBxMTAABCyAQALIAMoAgwhASAAIAQ2AgAgACABNgIEIANBIGokAAuoAgEEfyMA +QSBrIgQkAEEBIQYCQCAAKAIAIgUgASACIAAoAgQiBygCDCIBEQEADQACQCAALQAKQYABcUUEQCAF +QaLqwABBASABEQEADQIgAyAAQbyEwAAoAgARAABFDQEMAgsgBUGj6sAAQQIgAREBAA0BIARBAToA +DyAEIAc2AgQgBCAFNgIAIARBhOrAADYCFCAEIAApAgg3AhggBCAEQQ9qNgIIIAQgBDYCECADIARB +EGpBvITAACgCABEAAA0BIAQoAhBBoOrAAEECIAQoAhQoAgwRAQANAQsCQCACDQAgAC0ACkGAAXEN +ACAAKAIAQaXqwABBASAAKAIEKAIMEQEADQELIAAoAgBBpOfAAEEBIAAoAgQoAgwRAQAhBgsgBEEg +aiQAIAYLrAICBH8BbyMAQSBrIgMkABAaIQcQbyIFIAcmASADQRhqIgQgBTYCBCAEIAI2AgAgAygC +HCECAkAgAygCGCIERQRAQQEhBQwBCyADIAI2AhwgAyAENgIYIANBEGoiBCABKAIEIAEoAggQtQE2 +AgQgBEEANgIAQQEhBSADKAIUIQQCQAJAIAMoAhBBAXEEQCACIQEgBCECDAELIANBHGoiBkHXhcAA +QQQQPSAEEM0BIAEoAgy4EAwhBxBvIgEgByYBIANBCGoiAiABNgIEIAJBADYCACADKAIMIQIgAygC +CEEBcUUNASADKAIcIQELIAFBhAFJDQEgARBsDAELIAZB24XAAEEGED0gAhDNAUEAIQUgAygCHCEC +CyAAIAI2AgQgACAFNgIAIANBIGokAAvZAwEHfyMAQRBrIgYkAAJAAkAgAkEHTQRAIAINAQwCCyAG +QQhqIQcCQAJAAkACQCABQQNqQXxxIgMgAUYNACACIAMgAWsiAyACIANJGyIERQ0AQQAhA0EBIQUD +QCABIANqLQAAQS5GDQQgBCADQQFqIgNHDQALIAQgAkEIayIISw0CDAELIAJBCGshCEEAIQQLQa7c +uPECIQMDQEGAgoQIIAEgBGoiCSgCAEGu3LjxAnMiBWsgBXJBgIKECCAJQQRqKAIAQa7cuPECcyIF +ayAFcnFBgIGChHhxQYCBgoR4Rw0BIARBCGoiBCAITQ0ACwsgAiAERwRAQS4hA0EBIQUDQCABIARq +LQAAQS5GBEAgBCEDDAMLIAIgBEEBaiIERw0ACwtBACEFCyAHIAM2AgQgByAFNgIAIAYoAghBAUYh +AwwBCyABLQAAQS5GIgMgAkEBRnINACABLQABQS5GIgMgAkECRnINACABLQACQS5GIgMgAkEDRnIN +ACABLQADQS5GIgMgAkEERnINACABLQAEQS5GIgMgAkEFRnINACABLQAFQS5GIgMgAkEGRnINACAB +LQAGQS5GIQMLIAAgAyAALQAEcjoABCAAKAIAIAEgAhC8ASAGQRBqJAAL5AEBBH8jAEEQayIDJAAg +ACgCDCEBAkACfwJAAkACQAJAAkAgACgCBA4CAAECCyABDQFBASEBQQAhAEEBIQIMAwsgAUUNAQsg +A0EEaiAAEEcgAygCBCEAIAMoAgghAiADKAIMDAILIAAoAgAiASgCBCIAQQBIDQIgASgCACEBIABF +BEBBASECQQAhAAwBC0HlgMEALQAAGkEBIQQgAEEBEMABIgJFDQILIAAEQCACIAEgAPwKAAALIAAL +IQEgAiABELYBIAAEQCACIAAQzAELIANBEGokAA8LIAQgAEGQksAAELIBAAuUAgIBfwF+IwBBoAFr +IgIkACACQoCAgICAByIDIAFBGGqthDcDOCACIAMgAUEQaq2ENwMwIAIgAyABQQhqrYQ3AyggAiAD +IAGthDcDICACQZi4wAA2AgggAkEENgIMIAJBBDYCHCACQoOAgICAhICAaTcCmAEgAkGAgMAANgKQ +ASACQQI7AYgBIAJCgoCAgICEgIBpNwKAASACQYCAwAA2AnggAkECOwFwIAJCgYCAgICEgIBpNwJo +IAJBgIDAADYCYCACQQI7AVggAkKAgICAgISAgGk3AlAgAkKAgMAANwJIIAJBAjsBQCACIAJBQGs2 +AhggAkEENgIUIAIgAkEgajYCECAAIAJBCGoQRyACQaABaiQAC/IBAQJ/IwBBMGsiAiQAAkAgACkD +AEL///////////8Ag0KAgICAgICA+P8AWgRAIAJBATYCFCACQfC+wAA2AhAgAkIBNwIcIAIgAK1C +gICAgKAIhDcDKCACIAJBKGo2AhggASgCACABKAIEIAJBEGoQPCEDDAELIAJBADoADCACIAE2AghB +ASEDIAJBATYCFCACQfC+wAA2AhAgAkIBNwIcIAIgAK1CgICAgKAIhDcDKCACIAJBKGo2AhggAkEI +akHYvMAAIAJBEGoQPA0AIAItAAxFBEAgAUH4vsAAQQIQvAENAQtBACEDCyACQTBqJAAgAwuVAgEC +fyMAQSBrIgUkAEG8gcEAQbyBwQAoAgAiBkEBajYCAAJ/QQAgBkEASA0AGkEBQYiFwQAtAAANABpB +iIXBAEEBOgAAQYSFwQBBhIXBACgCAEEBajYCAEECC0H/AXEiBkECRwRAIAZBAXEEQCAFQQhqIAAg +ASgCGBECAAsACwJAQbCBwQAoAgAiBkEATgRAQbCBwQAgBkEBajYCAEG0gcEAKAIABEAgBSAAIAEo +AhQRAgAgBSAEOgAdIAUgAzoAHCAFIAI2AhggBSAFKQMANwIQQbSBwQAoAgAgBUEQakG4gcEAKAIA +KAIUEQIAC0GwgcEAQbCBwQAoAgBBAWs2AgBBiIXBAEEAOgAAIANFDQEACwALAAu7AQECfyMAQSBr +IgMkAAJAAn9BACABIAEgAmoiAksNABpBAEEIIAIgACgCACIBQQF0IgQgAiAESxsiAiACQQhNGyIE +QQBIDQAaQQAhAiADIAEEfyADIAE2AhwgAyAAKAIENgIUQQEFIAILNgIYIANBCGpBASAEIANBFGoQ +cyADKAIIQQFHDQEgAygCECEAIAMoAgwLIABBhMnAABCyAQALIAMoAgwhASAAIAQ2AgAgACABNgIE +IANBIGokAAu6AQEFfyMAQSBrIgIkACAAKAIAIgRB////P0sEQEEAQQAgARCyAQALAkBBBCAEQQF0 +IgUgBUEETRsiBUEEdCIGQfz///8HTQR/IAIgBAR/IAIgBEEEdDYCHCACIAAoAgQ2AhRBBAUgAws2 +AhggAkEIakEEIAYgAkEUahBzIAIoAghBAUcNASACKAIQIQMgAigCDAUgAwsgAyABELIBAAsgAigC +DCEBIAAgBTYCACAAIAE2AgQgAkEgaiQAC70BAQN/IwBBEGsiAiQAAkACQAJAIAFFBEAgAEUNASAA +QQhrIgEoAgBBAUcNAiAAKAIsIAAoAighAyABQQA2AgACQCABQX9GDQAgAEEEayIAIAAoAgBBAWsi +ADYCACAADQAgAUHAABDMAQsgA0UNAyADEMwBDAMLIABFDQAgAiAAQQhrIgA2AgwgACAAKAIAQQFr +IgA2AgAgAA0CIAJBDGoQkQEMAgsQ4AEAC0GChsAAQT8Q4gEACyACQRBqJAALwQECA38BfiMAQTBr +IgIkACABKAIAQYCAgIB4RgRAIAEoAgwhAyACQRRqIgRBADYCACACQoCAgIAQNwIMIAJBIGogAygC +ACIDQQhqKQIANwMAIAJBKGogA0EQaikCADcDACACIAMpAgA3AxggAkEMakHUxMAAIAJBGGoQPBog +AkEIaiAEKAIAIgM2AgAgAiACKQIMIgU3AwAgAUEIaiADNgIAIAEgBTcCAAsgAEHwxsAANgIEIAAg +ATYCACACQTBqJAALtgEBAX8jAEEQayIDJAACQAJAAkAgACgCACIAQQFxBEAgASAAQX5xIgBrIAJq +IgFBARCzAUUNAiAAIAEQzAEMAQsgACAAKAIIIgFBAWs2AgggAUEBRw0AIAAoAgAgAEEEaigCACIC +QQEQswFFDQIgAhDMASAAQQwQzAELIANBEGokAA8LQaC1wABBKyADQQ9qQZC1wABBzLXAABB8AAtB +oLXAAEErIANBD2pBkLXAAEHctcAAEHwAC7ABAQZ/AkACQCAAQYQBSQ0AIADQbyYBEFYiASgCDCEF +IAEoAhAhAiABQgA3AgwgASgCCCEDIAEoAgQhBCABQgQ3AgQgASgCACEGIAFBADYCACAAIAJJDQEg +ACACayIAIANPDQEgBCAAQQJ0aiAFNgIAIAEgAjYCECABIAA2AgwgASADNgIIIAEoAgQgASAENgIE +IAEoAgAhACABIAY2AgAgAEUNACAAQQJ0EMwBCw8LAAu5AQEBf0HlgMEALQAAGgJAQQxBBBDAASIG +BEAgBkECNgIIIAYgAzYCACAGIAQgA2sgBWo2AgQgASAGIAEoAgAiASABIAJGIgIbNgIAIAJFBEAg +ASABKAIIIgJBAWo2AgggAkEASA0CIAAgATYCDCAAIAU2AgggACAENgIEIABB7LXAADYCACAGQQwQ +zAEPCyAAIAY2AgwgACAFNgIIIAAgBDYCBCAAQey1wAA2AgAPC0EEQQwQ5wEACwALsQEBAX8jAEEQ +ayIDJAACQAJAAkAgACgCACIAQQFxBEAgASAAayACaiIBQQEQswFFDQIgACABEMwBDAELIAAgACgC +CCIBQQFrNgIIIAFBAUcNACAAKAIAIABBBGooAgAiAkEBELMBRQ0CIAIQzAEgAEEMEMwBCyADQRBq +JAAPC0GgtcAAQSsgA0EPakGQtcAAQcy1wAAQfAALQaC1wABBKyADQQ9qQZC1wABB3LXAABB8AAvP +AwIMfwF+IwBBIGsiBCQAIARBGGoiCRBWIgVBEGoiBygCADYCACAEQRBqIgogBUEIaiIIKQIANwMA +IAdBADYCACAIQgA3AgAgBSkCACEMIAVCgICAgMAANwIAIAQgDDcDCAJ/IwBBIGsiAyQAAkACQCAE +QQhqIgAoAgwiASAAKAIIIgJGBEACQCAAKAIAIgIgAUYEQNBvQYABIAEgAUGAAU0bIgb8DwEiAkF/ +Rg0EAkAgACgCECILRQRAIAAgAjYCEAwBCyABIAtqIAJHDQULIAEgBmoiAkH/////AUsNBCADIAEE +fyADIAFBAnQ2AhwgAyAAKAIENgIUQQQFQQALNgIYIANBCGpBBCACQQJ0IANBFGoQcyADKAIIQQFG +DQQgAygCDCEGIAAgAjYCACAAIAY2AgQMAQsgASACTw0DCyAAIAFBAWoiAjYCCCAAKAIEIAFBAnRq +IAI2AgAMAQsgASACTw0BCyAAIAAoAgQgAUECdGooAgA2AgwgACgCECADQSBqJAAgAWoMAQsACyAI +IAopAwA3AgAgByAJKAIANgIAIAUoAgQhAyAFKAIAIQEgBSAEKQMINwIAIAEEQCADIAFBAnQQzAEL +IARBIGokAAusAQEBfyMAQRBrIgYkAAJAIAEEQCAGQQRqIAEgAyAEIAUgAigCEBEIAAJAIAYoAgQi +AiAGKAIMIgFNBEAgBigCCCEFDAELIAJBAnQhAiAGKAIIIQMgAUUEQEEEIQUgAyACEMwBDAELIAMg +AkEEIAFBAnQiAhC4ASIFRQ0CCyAAIAE2AgQgACAFNgIAIAZBEGokAA8LQbSywABBMhDiAQALQQQg +AkGkssAAELIBAAuaAQEEfyMAQSBrIgIkAEEIIAAoAgAiBEEBdCIDIANBCE0bIgNBAEgEQEEAQQAg +ARCyAQALIAIgBAR/IAIgBDYCHCACIAAoAgQ2AhRBAQUgBQs2AhggAkEIakEBIAMgAkEUahBzIAIo +AghBAUYEQCACKAIMIAIoAhAgARCyAQALIAIoAgwhASAAIAM2AgAgACABNgIEIAJBIGokAAukAQEB +fyMAQUBqIgIkACAAKAIAIQAgAkIANwM4IAJBOGogACUBECQgAiACKAI8IgA2AjQgAiACKAI4NgIw +IAIgADYCLCACIAJBLGqtQoCAgIDgCIQ3AyAgAkECNgIMIAJBiMPAADYCCCACQgE3AhQgAiACQSBq +NgIQIAEoAgAgASgCBCACQQhqEDwgAigCLCIBBEAgAigCMCABEMwBCyACQUBrJAALjwEBAX8gAkEA +TgRAAn8gAygCBARAAkAgAygCCCIERQRADAELIAMoAgAgBCABIAIQuAEMAgsLIAEgAkUNABpB5YDB +AC0AABogAiABEMABCyIDRQRAIAAgAjYCCCAAIAE2AgQgAEEBNgIADwsgACACNgIIIAAgAzYCBCAA +QQA2AgAPCyAAQQA2AgQgAEEBNgIAC60BAQN/IAEoAgQhAgJ/AkAgASgCCCIEIAEoAgAiA0cEQEHl +gMEALQAAGkEMQQQQwAEiAQ0BQQRBDBDnAQALIARFBEBBACEBQQEhAkH0s8AADAILIAJBAXEEQCAC +IQFB/LTAAAwCCyACQQFyIQFB6LTAAAwBCyABQQE2AgggASADNgIEIAEgAjYCAEHstcAACyEDIAAg +ATYCDCAAIAQ2AgggACACNgIEIAAgAzYCAAvAAQIFfwFvAkAgASgCACIFEPABIgNBAEgNAAJAIANF +BEBBASEEDAELQeWAwQAtAAAaQQEhAiADQQEQwAEiBEUNAQsQJiEHEG8iASAHJgEgASIGJQEQHyEH +EG8iASAHJgEgARC3ASECIAFBhAFPBEAgARBsCyACJQEgBSUBIAQQISACQYQBTwRAIAIQbAsgBkGE +AU8EQCAGEGwLIAAgBRDwATYCCCAAIAQ2AgQgACADNgIADwsgAiADQaSxwAAQsgEAC5QBAQN/IwBB +EGsiAiQAAn9BASABKAIAIgNBJyABKAIEIgQoAhAiAREAAA0AGiACQQRqIAAoAgBBgQIQNQJAIAIt +AARBgAFGBEAgAyACKAIIIAERAABFDQFBAQwCCyADIAItAA4iACACQQRqaiACLQAPIABrIAQoAgwR +AQBFDQBBAQwBCyADQScgAREAAAsgAkEQaiQAC5UBAQJ/AkAgAkEASA0AIAACfyACRQRAQfSzwAAh +A0EBIQRBAAwBC0HlgMEALQAAGkEBIQMgAkEBEMABIgRFDQEgAgRAIAQgASAC/AoAAAsgBEEBcQRA +Qfy0wAAhAyAEDAELQei0wAAhAyAEQQFyCzYCDCAAIAI2AgggACAENgIEIAAgAzYCAA8LIAMgAkHk +s8AAELIBAAt5AgF+An8jAEGAAWsiBCQAIAApAwAhAkEAIQADQCAAIARqQf8AaiACp0EPcSIDQTBy +IANB1wBqIANBCkkbOgAAIABBAWshACACQg9WIAJCBIghAg0ACyABQQFBpurAAEECIAAgBGpBgAFq +QQAgAGsQNiAEQYABaiQAC4QBAQF/AkAgA0EASA0AAkAgA0UEQEEBIQEMAQtB5YDBAC0AABpBASEE +IANBARDAASIBRQ0BCyADBEAgASACIAP8CgAACyAAIAM2AgggACADNgIEIAAgATYCACAAQR1BgQEg +A0EKdmdBAnRrIANB//8HSxs2AgwPCyAEIANB9LbAABCyAQALowECBH8BbwJAIAEtAAQEQEECIQMM +AQsgASgCACUBEBQhBhBvIgIgBiYBQaiBwQAoAgAhBEGkgcEAKAIAQaSBwQBCADcCAEEBIQNBAUYE +QCABQQE6AAQMAQsCfyACJQEQFUUEQCACJQEQFiEGEG8iASAGJgEgASEEQQAMAQsgAUEBOgAEQQIL +IQMgAkGEAUkNACACEGwLIAAgBDYCBCAAIAM2AgALegEBfyMAQSBrIgIkAAJ/IAAoAgBBgICAgHhH +BEAgASAAKAIEIAAoAggQvAEMAQsgAkEQaiAAKAIMKAIAIgBBCGopAgA3AwAgAkEYaiAAQRBqKQIA +NwMAIAIgACkCADcDCCABKAIAIAEoAgQgAkEIahA8CyACQSBqJAALfAEBfyMAQUBqIgUkACAFIAE2 +AgwgBSAANgIIIAUgAzYCFCAFIAI2AhAgBUECNgIcIAVB9OnAADYCGCAFQgI3AiQgBSAFQRBqrUKA +gICA8AuENwM4IAUgBUEIaq1CgICAgIAMhDcDMCAFIAVBMGo2AiAgBUEYaiAEEJ8BAAtwAQF/IwBB +EGsiASQAIAAoAgAiACAAKAIIIgJBAWs2AggCQCACQQFGBEAgACgCACAAQQRqKAIAIgNBARCzAUUN +ASADEMwBIABBDBDMAQsgAUEQaiQADwtBoLXAAEErIAFBD2pBkLXAAEHctcAAEHwAC80CAQN/IwBB +MGsiAyQAIAMgAjYCBCADIAE2AgAgA0ECNgIMIANB1JPAADYCCCADQgI3AhQgAyADrUKAgICA0AKE +NwMoIAMgAK1CgICAgPABhDcDICADIANBIGo2AhACfyMAQRBrIgIkACADQQhqIgAoAgwhAQJAAn8C +QAJAAkACQAJAIAAoAgQOAgABAgsgAQ0BQQEhBUEAIQBBASEBDAMLIAFFDQELIAJBBGogABBHIAIo +AgwhACACKAIIIQEgAigCBAwCCyAAKAIAIgEoAgQiAEEASA0CIAEoAgAhBSAARQRAQQEhAUEAIQAM +AQtB5YDBAC0AABpBASEEIABBARDAASIBRQ0CCyAABEAgASAFIAD8CgAACyAACyEEIAEgABC2ASAE +BEAgASAEEMwBCyACQRBqJAAMAQsgBCAAQdiUwAAQsgEACyADQTBqJAALagIBfwF+IwBBMGsiAyQA +IAMgATYCBCADIAA2AgAgA0ECNgIMIANBwOjAADYCCCADQgI3AhQgA0KAgICAgAkiBCADrYQ3Aygg +AyAEIANBBGqthDcDICADIANBIGo2AhAgA0EIaiACEJ8BAAtoAQF/AkAgA0EASA0AAkAgA0UEQEEB +IQEMAQtB5YDBAC0AABpBASEEIANBARDAASIBRQ0BCyADBEAgASACIAP8CgAACyAAIAM2AgggACAB +NgIEIAAgAzYCAA8LIAQgA0Hks8AAELIBAAtpACMAQTBrIgAkAEHkgMEALQAARQRAIABBMGokAA8L +IABBAjYCDCAAQbjGwAA2AgggAEIBNwIUIAAgATYCLCAAIABBLGqtQoCAgICACYQ3AyAgACAAQSBq +NgIQIABBCGpB4MbAABCfAQALWQECfyMAQRBrIgIkACAAQQRqIQMCfyAAKAIAQQFGBEAgAiADNgIM +IAFBwoTAAEEDIAJBDGoQYAwBCyACIAM2AgggAUHAhMAAQQIgAkEIahBgCyACQRBqJAALXgEBfyMA +QTBrIgIkACACIAE2AgwgAiAANgIIIAJBAjYCFCACQdCQwAA2AhAgAkIBNwIcIAIgAkEIaq1CgICA +gIAChDcDKCACIAJBKGo2AhggAkEQahBjIAJBMGokAAteAQF/IwBBMGsiAiQAIAIgATYCDCACIAA2 +AgggAkECNgIUIAJB9JDAADYCECACQgE3AhwgAiACQQhqrUKAgICAgAKENwMoIAIgAkEoajYCGCAC +QRBqEGMgAkEwaiQAC1sBAX8gASgCACIEQQFxBEAgACABIAQgBEF+cSACIAMQbQ8LIAQgBCgCCCIB +QQFqNgIIIAFBAE4EQCAAIAQ2AgwgACADNgIIIAAgAjYCBCAAQey1wAA2AgAPCwALWAEBfyABKAIA +IgRBAXEEQCAAIAEgBCAEIAIgAxBtDwsgBCAEKAIIIgFBAWo2AgggAUEATgRAIAAgBDYCDCAAIAM2 +AgggACACNgIEIABB7LXAADYCAA8LAAtOACMAQSBrIgAkACAAQQE2AgQgAEGUvMAANgIAIABCATcC +DCAAQvy7wICgBzcDGCAAIABBGGo2AgggASgCACABKAIEIAAQPCAAQSBqJAALSwAgASgCACIBQQFx +BEAgAUF+cSEBIAMEQCABIAIgA/wKAAALIAAgAzYCCCAAIAE2AgQgACACIANqIAFrNgIADwsgACAB +IAIgAxBbC0sBAX8gACgCACAAKAIIIgNrIAJJBEAgACADIAJBAUEBEFcgACgCCCEDCyACBEAgACgC +BCADaiABIAL8CgAACyAAIAIgA2o2AghBAAtHAQF/IAAoAgAgACgCCCIDayACSQRAIAAgAyACEF8g +ACgCCCEDCyACBEAgACgCBCADaiABIAL8CgAACyAAIAIgA2o2AghBAAtNAQF/IwBBMGsiASQAIAFB +ATYCDCABQdjnwAA2AgggAUIBNwIUIAEgAUEvaq1CgICAgOALhDcDICABIAFBIGo2AhAgAUEIaiAA +EJ8BAAtEACABKAIAIgFBAXEEQCADBEAgASACIAP8CgAACyAAIAM2AgggACABNgIEIAAgAiADaiAB +azYCAA8LIAAgASACIAMQWws6AQF/IwBBIGsiACQAIABBADYCGCAAQQE2AgwgAEHkx8AANgIIIABC +BDcCECAAQQhqQZjIwAAQnwEAC0cBAX8gACgCACAAKAIIIgNrIAJJBEAgACADIAIQZyAAKAIIIQML +IAIEQCAAKAIEIANqIAEgAvwKAAALIAAgAiADajYCCEEAC0EBAn8jAEEQayICJAAgAkEIaiAAKAIA +JQEQCyACKAIIIgMgAigCDCIAIAEQ6QEgAARAIAMgABDMAQsgAkEQaiQAC08BAn8gACgCBCECIAAo +AgAhAwJAIAAoAggiAC0AAEUNACADQZzqwABBBCACKAIMEQEARQ0AQQEPCyAAIAFBCkY6AAAgAyAB +IAIoAhARAAALQgEBfyAAKAIAIgAoAjAiAQRAIAAoAjQgARDMAQsCQCAAQX9GDQAgACAAKAIEQQFr +IgE2AgQgAQ0AIABBwAAQzAELC08BAn9B5YDBAC0AABogASgCBCECIAEoAgAhA0EIQQQQwAEiAUUE +QEEEQQgQ5wEACyABIAI2AgQgASADNgIAIABBgMfAADYCBCAAIAE2AgALknQDI38afgF8IAEoAggi +A0GAgIABcSECIAArAwAhPyADQYCAgIABcUUEQCABIAJBAEchAUEAIQAjAEGAAWsiByQAID+9ISUC +f0EDID+ZRAAAAAAAAPB/YQ0AGkECICVCgICAgICAgPj/AIMiJkKAgICAgICA+P8AUQ0AGiAlQv// +//////8HgyIpQoCAgICAgIAIhCAlQgGGQv7///////8PgyAlQjSIp0H/D3EiABsiJ0IBgyEoICZQ +BEBBBCApUA0BGiAAQbMIayEAQgEhJiAoUAwBC0KAgICAgICAICAnQgGGICdCgICAgICAgAhRIgIb +ISdCAkIBIAIbISZBy3dBzHcgAhsgAGohACAoUAshAiAHIAA7AXggByAmNwNwIAdCATcDaCAHICc3 +A2AgByACOgB6An8CQAJAAkAgAkECayICBEBBASEAQePmwABB5ObAACAlQgBTIgMbQePmwABBASAD +GyABGyEXICVCP4inIAFyIRtBAyACIAJBA08bQQJrDgIDAgELIAdBAzYCKCAHQeXmwAA2AiQgB0EC +OwEgQQEhF0EBIQAgB0EgagwDCyAHQQM2AiggB0Ho5sAANgIkIAdBAjsBICAHQSBqDAILIAdBIGoh +BiAHQQ9qIQwjAEEwayIDJAACQAJAAn8CQAJAAkACQAJAAkACQAJAIAdB4ABqIgApAwAiJVBFBEAg +ACkDCCInUA0BIAApAxAiJlANAiAlICZ8IiYgJVQNAyAlICdUDQQgJkKAgICAgICAgCBaDQUgAyAA +LwEYIgA7AQggAyAlICd9Iic3AwAgACAAQSBrIAAgJkKAgICAEFQiARsiAkEQayACICZCIIYgJiAB +GyImQoCAgICAgMAAVCIBGyICQQhrIAIgJkIQhiAmIAEbIiZCgICAgICAgIABVCIBGyICQQRrIAIg +JkIIhiAmIAEbIiZCgICAgICAgIAQVCIBGyICQQJrIAIgJkIEhiAmIAEbIiZCgICAgICAgIDAAFQi +ARsgJkIChiAmIAEbIihCAFkiAmsiAWvBIgpBAEgNBiADQn8gCq0iKYgiJiAngzcDECAmICdUDQog +AyAAOwEIIAMgJTcDACADICUgJoM3AxAgJSAmVg0KQaB/IAFrwUHQAGxBsKcFakHOEG0iAEHRAE8N +ByAAQQR0IgBBqNfAAGopAwAiKkL/////D4MiJiAlIClCP4MiJYYiK0IgiCI1fiIsQiCIIjEgKkIg +iCIpIDV+IjJ8ICkgK0L/////D4MiKn4iK0IgiCI2fCEzICxC/////w+DICYgKn5CIIh8ICtC//// +/w+DfCI3QoCAgIAIfEIgiCErQgFBACABIABBsNfAAGovAQBqa0E/ca0iLIYiKkIBfSEuICYgJyAl +hiIlQiCIIid+Ii1C/////w+DICYgJUL/////D4MiJX5CIIh8ICUgKX4iJUL/////D4N8Ij5CgICA +gAh8QiCIITQgJyApfiE4ICVCIIghOSAtQiCIITogAEGy18AAai8BACEBICkgKCACrYYiJUIgiCI7 +fiI8ICYgO34iJ0IgiCIvfCApICVC/////w+DIiV+IihCIIgiMHwgJ0L/////D4MgJSAmfkIgiHwg +KEL/////D4N8Ij1CgICAgAh8QiCIfEIBfCItICyIpyIAQZDOAE8EQCAAQcCEPUkNCSAAQYDC1y9P +BEBBCEEJIABBgJTr3ANJIgIbIQpBgMLXL0GAlOvcAyACGwwLC0EGQQcgAEGAreIESSICGyEKQcCE +PUGAreIEIAIbDAoLIABB5ABPBEBBAkEDIABB6AdJIgIbIQpB5ABB6AcgAhsMCgtBCkEBIABBCUsi +ChsMCQtB+9LAAEEcQfjhwAAQlAEAC0Go08AAQR1BiOLAABCUAQALQdjTwABBHEGY4sAAEJQBAAtB +vNXAAEE2QbjjwAAQlAEAC0H01MAAQTdBqOPAABCUAQALQbjiwABBLUHo4sAAEJQBAAtBz9DAAEEd +QZDRwAAQlAEACyAAQdEAQejhwAAQfwALQQRBBSAAQaCNBkkiAhshCkGQzgBBoI0GIAIbCyECICsg +M3whMyAtIC6DISYgCiABa0EBaiEFIC0gOCA6fCA5fCA0fH0iNEIBfCIoIC6DISdBACEBAkACQAJA +AkACQAJAAkACQANAIAAgAm4hCyABQRFGDQIgASAMaiIOIAtBMGoiDToAAAJAIAAgAiALbGsiAK0g +LIYiKyAmfCIlIChaBEAgASAKRw0BIAFBAWohAUIBISUDQCAlISggJyEpIAFBEU8NBiABIAxqICZC +Cn4iJiAsiKdBMGoiAjoAACABQQFqIQEgJUIKfiElICdCCn4iJyAmIC6DIiZYDQALICUgLSAzfX4i +LCAlfCErICcgJn0gKlQiAA0HICwgJX0iLCAmVg0DDAcLICggJX0iJyACrSAshiIoVCECIC0gM30i +LEIBfCEqICcgKFQgJSAsQgF9Iixacg0FID1CgICAgAh8QiCIIi0gLyAwfHwgPHwhJ0ICIDkgOnwg +PkKAgICACHxCIIh8IDh8ICYgKHwiJSArfHx9IS5CACAxIDZ8IDdCgICAgAh8QiCIfCIxIDJ8ICYg +K3x8fSEyICUgMXwgKSA1IDt9fnwgL30gMH0gLX0hKQNAICUgK3wiLyAsVCAnIDJ8ICkgK3xackUE +QCAmICt8ISVBACECDAcLIA4gDUEBayINOgAAICYgKHwhJiAnIC58IS0gLCAvVgRAICggKXwhKSAl +ICh8ISUgJyAofSEnICggLVgNAQsLICggLVYhAiAmICt8ISUMBQsgAUEBaiEBIAJBCkkgAkEKbiEC +RQ0AC0H44sAAEJoBAAsgASAMakEBayEKICogMSA2fCA3QoCAgIAIfEIgiHwgMnxCCn4gLyAwfCA9 +QoCAgIAIfEIgiHwgPHxCCn59ICh+fCEtIClCCn4gJiAqfH0hLiAsICZ9IS9CACEpA0AgJiAqfCIl +ICxUICkgL3wgJiAtfFpyRQRAQQAhAAwFCyAKIAJBAWsiAjoAACApIC58IjAgKlQhACAlICxaDQUg +KSAqfSEpICUhJiAqIDBYDQALDAQLQRFBEUGI48AAEH8ACyABQRFBmOPAABB/AAsCQCAlICpaIAJy +DQAgKiAlICh8IiZYICogJX0gJiAqfVRxDQAgBkEANgIADAQLICUgNEIDfVggJUICWnFFBEAgBkEA +NgIADAQLIAYgBTsBCCAGIAFBAWo2AgQMAgsgJiElCwJAICUgK1ogAHINACArICUgKnwiJlggKyAl +fSAmICt9VHENACAGQQA2AgAMAgsgJSAoQlh+ICd8WCAlIChCFH5acUUEQCAGQQA2AgAMAgsgBiAF +OwEIIAYgATYCBAsgBiAMNgIACyADQTBqJAAMAQsgA0EANgIYIwBBEGsiACQAIAAgAzYCDCAAIANB +EGo2AgggAEEIakHQ6MAAIABBDGpB0OjAACADQRhqQaDRwAAQTwALAkAgBygCIARAIAdB2ABqIAdB +KGooAgA2AgAgByAHKQIgNwNQDAELIAdB0ABqIQ8gB0EPaiENIwBBoAprIgEkAAJAAkACQAJAAkAC +QAJAAkAgB0HgAGoiACkDACIlUEUEQCAAKQMIIiZQRQRAIAApAxAiJ1BFBEAgJSAlICd8IihYBEAg +JSAmWgRAIAAsABohGCAALgEYIQAgASAlPgIAIAFBAUECICVCgICAgBBUIgIbNgKgASABQQAgJUIg +iKcgAhs2AgQgAUEIakEAQZgB/AsAIAEgJj4CpAEgAUEBQQIgJkKAgICAEFQiAhs2AsQCIAFBACAm +QiCIpyACGzYCqAEgAUGsAWpBAEGYAfwLACABICc+AsgCIAFBAUECICdCgICAgBBUIgIbNgLoAyAB +QQAgJ0IgiKcgAhs2AswCIAFB0AJqQQBBmAH8CwAgAUHwA2pBAEGcAfwLACABQQE2AuwDIAFBATYC +jAUgAKwgKEIBfXl9QsKawegEfkKAoc2gtAJ8QiCIpyICwSEOAkAgAEEATgRAIAEgABAtGiABQaQB +aiAAEC0aIAFByAJqIAAQLRoMAQsgAUHsA2pBACAAa8EQLRoLAkAgDkEASARAIAFBACAOa0H//wNx +IgAQKyABQaQBaiAAECsgAUHIAmogABArDAELIAFB7ANqIAJB//8BcRArCyABKAKgASEDIAFB/Ahq +IAFBoAH8CgAAIAEgAzYCnAoCQAJAAkACQCABKALoAyIGIAMgAyAGSRsiAkEoTQRAIAJFBEBBACEC +DAQLIAJBAXEhCyACQQFHDQEMAgsMDAsgAkE+cSERIAFB/AhqIQAgAUHIAmohBQNAIAAgCCAAKAIA +IhIgBSgCAGoiCmoiCDYCACAAQQRqIgwgDCgCACITIAVBBGooAgBqIgwgCiASSSAIIApJcmoiCjYC +ACAMIBNJIAogDElyIQggBUEIaiEFIABBCGohACARIAlBAmoiCUcNAAsLIAsEfyAJQQJ0IgAgAUH8 +CGpqIgogCigCACIKIAFByAJqIABqKAIAaiIAIAhqIgk2AgAgACAKSSAAIAlLcgUgCAtFDQAgAkEo +Rg0BIAFB/AhqIAJBAnRqQQE2AgAgAkEBaiECCyABIAI2ApwKIAIgASgCjAUiCSACIAlLGyIAQSlJ +BEAgAEECdCEAAkACQAJ/AkADQCAARQ0BIABBBGsiACABQewDamooAgAiAiAAIAFB/AhqaigCACIK +Rg0ACyACIApLIAIgCklrDAELQX9BACAAGwsgGE4EQAJAIANFBEBBACEDDAELIANBAWtB/////wNx +IgBBAWoiAkEDcSEFAkAgAEEDSQRAIAEhAEIAISUMAQsgAkH8////B3EhCiABIQBCACElA0AgACAA +NQIAQgp+ICV8IiU+AgAgAEEEaiICIAI1AgBCCn4gJUIgiHwiJT4CACAAQQhqIgIgAjUCAEIKfiAl +QiCIfCIlPgIAIABBDGoiAiACNQIAQgp+ICVCIIh8IiY+AgAgJkIgiCElIABBEGohACAKQQRrIgoN +AAsLIAUEQANAIAAgADUCAEIKfiAlfCImPgIAIABBBGohACAmQiCIISUgBUEBayIFDQALCyAmQoCA +gIAQVA0AIANBKEYNAyABIANBAnRqICU+AgAgA0EBaiEDCyABIAM2AqABIAEoAsQCIgJBKU8NDSAB +An9BACACRQ0AGiACQQFrQf////8DcSIAQQFqIgNBA3EhBQJAIABBA0kEQCABQaQBaiEAQgAhJQwB +CyADQfz///8HcSEKIAFBpAFqIQBCACElA0AgACAANQIAQgp+ICV8IiU+AgAgAEEEaiIDIAM1AgBC +Cn4gJUIgiHwiJT4CACAAQQhqIgMgAzUCAEIKfiAlQiCIfCIlPgIAIABBDGoiAyADNQIAQgp+ICVC IIh8IiY+AgAgJkIgiCElIABBEGohACAKQQRrIgoNAAsLIAUEQANAIAAgADUCAEIKfiAlfCImPgIA -IABBBGohACAmQiCIISUgBUEBayIFDQALCyACICZCgICAgBBUDQAaIAJBKEYNFyABIAJBAnRqICU+ -AgAgAkEBagsiCTYCoAECQCAMRQ0AIAxBAWtB/////wNxIgBBAWoiAkEDcSEFAkAgAEEDSQRAIAFB -pAFqIQBCACElDAELIAJB/P///wdxIQogAUGkAWohAEIAISUDQCAAIAA1AgBCCn4gJXwiJT4CACAA -QQRqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIABBCGoiAiACNQIAQgp+ICVCIIh8IiU+AgAgAEEMaiIC -IAI1AgBCCn4gJUIgiHwiJj4CACAmQiCIISUgAEEQaiEAIApBBGsiCg0ACwsgBQRAA0AgACAANQIA -Qgp+ICV8IiY+AgAgAEEEaiEAICZCIIghJSAFQQFrIgUNAAsLICZCgICAgBBUBEAgDCEDDAELIAxB -KEYNFyABQaQBaiAMQQJ0aiAlPgIAIAxBAWohAwsgASADNgLEAgJAIAtFBEBBACELDAELIAtBAWtB -/////wNxIgBBAWoiAkEDcSEFAkAgAEEDSQRAIAFByAJqIQBCACElDAELIAJB/P///wdxIQogAUHI -AmohAEIAISUDQCAAIAA1AgBCCn4gJXwiJT4CACAAQQRqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIABB -CGoiAiACNQIAQgp+ICVCIIh8IiU+AgAgAEEMaiICIAI1AgBCCn4gJUIgiHwiJj4CACAmQiCIISUg -AEEQaiEAIApBBGsiCg0ACwsgBQRAA0AgACAANQIAQgp+ICV8IiY+AgAgAEEEaiEAICZCIIghJSAF -QQFrIgUNAAsLICZCgICAgBBUDQAgC0EoRg0XIAFByAJqIAtBAnRqICU+AgAgC0EBaiELCyABIAs2 -AugDIBIgCSAJIBJJGyICQShNDQALCwwRCyABQQEQLBogASgCjAUiACABKAKgASICIAAgAksbIgBB -KU8NBCAAQQJ0IQAgAUEEayECIAFB6ANqIQMDQCAARQ0OIAAgA2ohCSAAIAJqIABBBGshACgCACIM -IAkoAgAiCUYNAAsgCSAMTQ0ODA8LIAZBKEHA+sAAEMwBAAsgA0EoQcD6wAAQzAEACyADQShBwPrA -ABDMAQALQRFBEUGk08AAEH0ACwwNCwwNCwwLCwwLC0HU08AAQTdBjNTAABCRAQALQZzUwABBNkHU -1MAAEJEBAAtBuNLAAEEcQdTSwAAQkQEAC0GI0sAAQR1BqNLAABCRAQALQdvRwABBHEH40cAAEJEB -AAsgAA0BCyAGIA1qIQIgCiEAQX8hBQJAA0AgAEF/Rg0BIAVBAWohBSAAIA1qIABBAWshAC0AAEE5 -Rg0ACyAAIA1qIgJBAWoiAyADLQAAQQFqOgAAIAVFIABBAmogCktyDQEgAkECakEwIAX8CwAMAQsg -DUExOgAAIAoEQCANQQFqQTAgCvwLAAsgBkERSQRAIAJBMDoAACAOQQFqIQ4gCkECaiEGDAELIAZB -EUG008AAEH0ACyAGQRFNBEAgDyAOOwEIIA8gBjYCBCAPIA02AgAgAUGgCmokAAwFCyAGQRFBxNPA -ABDMAQALIAJBKEHA+sAAEMwBAAtB0PrAAEEaQcD6wAAQkQEACyAAQShBwPrAABDMAQALQShBKEHA -+sAAEH0ACwsgByAHKAJQIAcoAlQgBy8BWEEAIAdBIGoQTSAHKAIEIQAgBygCAAwBCyAHQQI7ASAg -B0EBNgIoIAdBy+XAADYCJCAHQSBqCyEBIAcgADYCXCAHIAE2AlggByAbNgJUIAcgFzYCUCAHQdAA -ahA7IAdBgAFqJAAPCwJ/IAEhDCACQQBHIQIgAS8BDiERQQAhASMAQfAIayIHJAAgP70hJwJ/QQMg -P5lEAAAAAAAA8H9hDQAaQQIgJ0KAgICAgICA+P8AgyImQoCAgICAgID4/wBRDQAaICdC//////// -/weDIilCgICAgICAgAiEICdCAYZC/v///////w+DICdCNIinQf8PcSIAGyIlQgGDISggJlAEQEEE -IClQDQEaIABBswhrIQFCASEmIChQDAELQoCAgICAgIAgICVCAYYgJUKAgICAgICACFEiARshJUIC -QgEgARshJkHLd0HMdyABGyAAaiEBIChQCyEAIAcgATsB6AggByAmNwPgCCAHQgE3A9gIIAcgJTcD -0AggByAAOgDqCAJAAn8CQAJAAkACQCAAQQJrIgMEQEEBIQBBw+XAAEHE5cAAICdCAFMiBhtBw+XA -AEEBIAYbIAIbIRsgJ0I/iKcgAnIhHUEDIAMgA0EDTxtBAmsOAgIDAQsgB0EDNgKYCCAHQcXlwAA2 -ApQIIAdBAjsBkAhBASEbQQEhACAHQZAIagwECyAHQQM2ApgIIAdByOXAADYClAggB0ECOwGQCCAH -QZAIagwDC0ECIQAgB0ECOwGQCCARRQ0BIAcgETYCoAggB0EAOwGcCCAHQQI2ApgIIAdBweXAADYC -lAggB0GQCGoMAgtBdEEFIAHBIgBBAEgbIABsIgBBwP0ASQRAIAdBkAhqIQQgB0EQaiEFIABBBHZB -FWoiCiEBQYCAfkEAIBFrIBHBQQBIGyEJAkACQAJ/AkACQAJAAkAgB0HQCGoiACkDACIlUEUEQCAl -QoCAgICAgICAIFoNASABRQ0CQaB/IAAvARgiAEEgayAAICVCgICAgBBUIgAbIgJBEGsgAiAlQiCG -ICUgABsiJUKAgICAgIDAAFQiABsiAkEIayACICVCEIYgJSAAGyIlQoCAgICAgICAAVQiABsiAkEE -ayACICVCCIYgJSAAGyIlQoCAgICAgICAEFQiABsiAkECayACICVCBIYgJSAAGyIlQoCAgICAgICA -wABUIgAbICVCAoYgJSAAGyIlQgBZayIDa8FB0ABsQbCnBWpBzhBtIgBB0QBPDQMgAEEEdCICQYjW -wABqKQMAIiZC/////w+DIicgJSAlQn+FQj+IhiIlQiCIIih+IilCIIggJkIgiCImICh+fCAmICVC -/////w+DIiV+IiZCIIh8IClC/////w+DICUgJ35CIIh8ICZC/////w+DfEKAgICACHxCIIh8IiVB -QCADIAJBkNbAAGovAQBqayILQT9xrSIniKchACACQZLWwABqLwEAIQIgJUIBICeGIihCAX0iKYMi -JlAEQCABQQpLDQcgAUECdEGc48AAaigCACAASw0HCyAAQZDOAE8EQCAAQcCEPUkNBSAAQYDC1y9P -BEBBCEEJIABBgJTr3ANJIgMbIQZBgMLXL0GAlOvcAyADGwwHC0EGQQcgAEGAreIESSIDGyEGQcCE -PUGAreIEIAMbDAYLIABB5ABPBEBBAkEDIABB6AdJIgMbIQZB5ABB6AcgAxsMBgtBCkEBIABBCUsi -BhsMBQtB29HAAEEcQcziwAAQkQEAC0Hc4sAAQSRBgOPAABCRAQALQajiwABBIUGQ48AAEJEBAAsg -AEHRAEHI4MAAEH0AC0EEQQUgAEGgjQZJIgMbIQZBkM4AQaCNBiADGwshAwJAAkACQAJAIAYgAmtB -AWrBIgggCcEiAkoEQCALQf//A3EhDiAIIAlrwSABIAggAmsgAUkbIgtBAWshD0EAIQIDQCAAIANu -IQ0gASACRg0DIAAgAyANbGshACACIAVqIA1BMGo6AAAgAiAPRg0EIAIgBkYNAiACQQFqIQIgA0EK -SSADQQpuIQNFDQALQcjjwAAQlgEACyAEIAUgAUEAIAggCSAlQgqAIAOtICeGICgQQgwFCyACQQFq -IQIgDkEBa0E/ca0hKkIBISUDQCAlICqIUEUEQCAEQQA2AgAMBgsgASACTQ0DIAIgBWogJkIKfiIm -ICeIp0EwajoAACAlQgp+ISUgJiApgyEmIAsgAkEBaiICRw0ACyAEIAUgASALIAggCSAmICggJRBC -DAQLIAEgAUHY48AAEH0ACyAEIAUgASALIAggCSAArSAnhiAmfCADrSAnhiAoEEIMAgsgAiABQejj -wAAQfQALIARBADYCAAsgCcEhGAJAIAcoApAIBEAgB0HICGogB0GYCGooAgA2AgAgByAHKQKQCDcD -wAgMAQsgB0HACGohEiAHQRBqIQkjAEHABmsiBSQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAdB -0AhqIgApAwAiJVBFBEAgACkDCCImUA0BIAApAxAiJ1ANAiAlICd8ICVUDQMgJSAmVA0EIAAuARgh -ACAFICU+AgwgBUEBQQIgJUKAgICAEFQiARs2AqwBIAVBACAlQiCIpyABGzYCECAFQRRqQQBBmAH8 -CwAgBUG0AWpBAEGcAfwLACAFQQE2ArABIAVBATYC0AIgAKwgJUIBfXl9QsKawegEfkKAoc2gtAJ8 -QiCIpyIBwSENAkAgAEEATgRAIAVBDGogABAsGgwBCyAFQbABakEAIABrwRAsGgsCQCANQQBIBEAg -BUEMakEAIA1rQf//A3EQKwwBCyAFQbABaiABQf//AXEQKwsgBSgC0AIhCyAFQZwFaiAFQbABakGg -AfwKAAAgBSALNgK8BiAKIgZBCk8EQCAFQZQFaiECA0AgBSgCvAYiBEEpTw0KAkAgBEUNACAEQf// -//8DaiEAIARBAnQhAQJ/IARBAUYEQEIAISUgBUGcBWogAWoMAQsgASACaiEEIABB/////wNxQQFq -Qf7///8HcSEDQgAhJQNAIARBBGoiASABNQIAICVCIIaEIiVCgJTr3AOAIiY+AgAgBCAENQIAICUg -JkKAlOvcA359QiCGhCIlQoCU69wDgCImPgIAICUgJkKAlOvcA359ISUgBEEIayEEIANBAmsiAw0A -CyAlQiCGISUgBEEIagsgAEEBcQ0AQQRrIgAgJSAANQIAhEKAlOvcA4A+AgALIAZBCWsiBkEJSw0A -CwsgBkECdEGg48AAaigCAEEBdCICRQ0FIAUoArwGIgRBKU8NCCAEBH8gBEH/////A2ohACAEQQJ0 -IQEgAq0hJQJ/IARBAUYEQEIAISYgBUGcBWogAWoMAQsgASAFakGUBWohBCAAQf////8DcUEBakH+ -////B3EhA0IAISYDQCAEQQRqIgEgATUCACAmQiCGhCImICWAIic+AgAgBCAENQIAICYgJSAnfn1C -IIaEIiYgJYAiJz4CACAmICUgJ359ISYgBEEIayEEIANBAmsiAw0ACyAmQiCGISYgBEEIagshASAA -QQFxRQRAIAFBBGsiACAmIAA1AgCEICWAPgIACyAFKAK8BgVBAAshAQJAAkACQCAFKAKsASIAIAEg -ACABSxsiAUEoTQRAIAFFBEBBACEBDAQLIAFBAXEhDiABQQFHDQFBACEGQQAhCAwCCwwUCyABQT5x -IQ9BACEGIAVBnAVqIQQgBUEMaiEDQQAhCANAIAQgBCgCACIXIAMoAgBqIgIgBkEBcWoiEzYCACAE -QQRqIgYgBigCACIZIANBBGooAgBqIgYgAiAXSSACIBNLcmoiAjYCACAGIBlJIAIgBklyIQYgA0EI -aiEDIARBCGohBCAPIAhBAmoiCEcNAAsLIA4EfyAIQQJ0IgIgBUGcBWpqIgMgAygCACIDIAVBDGog -AmooAgBqIgIgBmoiBjYCACACIANJIAIgBktyBSAGC0EBcUUNACABQShGDQogBUGcBWogAUECdGpB -ATYCACABQQFqIQELIAUgATYCvAYgCyABIAEgC0kbIgRBKU8NCCAEQQJ0IQQCQAJAA0AgBEUNASAE -QQRrIgQgBUGcBWpqKAIAIgEgBCAFQbABamooAgAiAkYNAAsgASACTw0BDAgLIAQNBwsgDUEBaiEN -DAcLQdvRwABBHEHk1MAAEJEBAAtBiNLAAEEdQfTUwAAQkQEAC0G40sAAQRxBhNXAABCRAQALQZzU -wABBNkH01cAAEJEBAAtB1NPAAEE3QeTVwAAQkQEAC0GH+8AAQRtBwPrAABCRAQALIABFBEBBACEA -IAVBADYCrAEMAQsgAEEBa0H/////A3EiAUEBaiICQQNxIQMCQCABQQNJBEAgBUEMaiEEQgAhJQwB -CyACQfz///8HcSEBIAVBDGohBEIAISUDQCAEIAQ1AgBCCn4gJXwiJT4CACAEQQRqIgIgAjUCAEIK -fiAlQiCIfCIlPgIAIARBCGoiAiACNQIAQgp+ICVCIIh8IiU+AgAgBEEMaiICIAI1AgBCCn4gJUIg -iHwiJj4CACAmQiCIISUgBEEQaiEEIAFBBGsiAQ0ACwsgAwRAA0AgBCAENQIAQgp+ICV8IiY+AgAg -BEEEaiEEICZCIIghJSADQQFrIgMNAAsLICZCgICAgBBaBEAgAEEoRg0DIAVBDGogAEECdGogJT4C -ACAAQQFqIQALIAUgADYCrAELQQAhBgJAAkACQAJAIA3BIgEgGMEiAkgiHkUEQCANIBhrwSAKIAEg -AmsgCkkbIggNAQtBACEIDAELIAVB1AJqIgEgBUGwAWoiAEGgAfwKAAAgBSALNgL0A0EBIRcgAUEB -ECwhHyAFKALQAiEBIAVB+ANqIgIgAEGgAfwKAAAgBSABNgKYBSACQQIQLCEgIAUoAtACIQEgBUGc -BWoiAiAAQaAB/AoAACAFIAE2ArwGIAVBrAFqISEgBUHQAmohIiAFQfQDaiEUIAVBmAVqISNBACEO -IAJBAxAsISQgBSgCrAEhACAFKALQAiELIAUoAvQDIRMgBSgCmAUhGSAFKAK8BiEQAkACQAJAAkAD -QCAAQSlPDQogAEECdCEBQQAhBAJ/AkACQANAIAEgBEYNASAFQQxqIARqIARBBGohBCgCAEUNAAsg -ECAAIAAgEEkbIgFBKU8NFCABQQJ0IQQCQANAIARFDQEgBCAjaiECIARBBGsiBCAFQQxqaigCACID -IAIoAgAiAkYNAAsgAiADTQ0CQQAMAwsgBEUNAUEADAILIAggCksNBCAIIA5GDQggCCAOayIARQ0I -IAkgDmpBMCAA/AsADAgLQQEhBkEAIQAgAUEBRwRAIAFBPnEhDyAFQQxqIQQgBUGcBWohAwNAIAQg -BCgCACIVIAMoAgBBf3NqIgIgBkEBcWoiFjYCACAEQQRqIgYgBigCACIaIANBBGooAgBBf3NqIgYg -AiAVSSACIBZLcmoiAjYCACAGIBpJIAIgBklyIQYgA0EIaiEDIARBCGohBCAPIABBAmoiAEcNAAsL -IAFBAXEEfyAAQQJ0IgAgBUEMamoiAiACKAIAIgIgACAkaigCAEF/c2oiACAGaiIDNgIAIAAgAkkg -ACADS3IFIAYLQQFxRQ0MIAUgATYCrAEgASEAQQgLIQ8gGSAAIAAgGUkbIgJBKU8NAyACQQJ0IQQC -QAJAAkADQCAERQ0BIAQgFGohASAEQQRrIgQgBUEMamooAgAiAyABKAIAIgFGDQALIAEgA00NASAA -IQIMAgsgBEUNACAAIQIMAQsgAgRAQQEhBkEAIQAgAkEBRwRAIAJBPnEhFSAFQQxqIQQgBUH4A2oh -AwNAIAQgBCgCACIWIAMoAgBBf3NqIgEgBkEBcWoiGjYCACAEQQRqIgYgBigCACIcIANBBGooAgBB -f3NqIgYgASAWSSABIBpLcmoiATYCACAGIBxJIAEgBklyIQYgA0EIaiEDIARBCGohBCAVIABBAmoi -AEcNAAsLIAJBAXEEfyAAQQJ0IgAgBUEMamoiASABKAIAIgEgACAgaigCAEF/c2oiACAGaiIDNgIA -IAAgAUkgACADS3IFIAYLQQFxRQ0NCyAFIAI2AqwBIA9BBHIhDwsgEyACIAIgE0kbIgFBKU8NBCAB -QQJ0IQQCQAJAAkADQCAERQ0BIAQgImohACAEQQRrIgQgBUEMamooAgAiAyAAKAIAIgBGDQALIAAg -A00NASACIQEMAgsgBEUNACACIQEMAQsgAQRAQQEhBkEAIQAgAUEBRwRAIAFBPnEhFSAFQQxqIQQg -BUHUAmohAwNAIAQgBCgCACIWIAMoAgBBf3NqIgIgBkEBcWoiGjYCACAEQQRqIgYgBigCACIcIANB -BGooAgBBf3NqIgYgAiAWSSACIBpLcmoiAjYCACAGIBxJIAIgBklyIQYgA0EIaiEDIARBCGohBCAV -IABBAmoiAEcNAAsLIAFBAXEEfyAAQQJ0IgAgBUEMamoiAiACKAIAIgIgACAfaigCAEF/c2oiACAG -aiIDNgIAIAAgAkkgACADS3IFIAYLQQFxRQ0NCyAFIAE2AqwBIA9BAmohDwsgCyABIAEgC0kbIgBB -KU8NCiAAQQJ0IQQCQAJAAkADQCAERQ0BIAQgIWohAiAEQQRrIgQgBUEMamooAgAiAyACKAIAIgJG -DQALIAIgA00NASABIQAMAgsgBEUNACABIQAMAQsgAARAQQEhBkEAIQEgAEEBRwRAIABBPnEhFSAF -QQxqIQQgBUGwAWohAwNAIAQgBCgCACIWIAMoAgBBf3NqIgIgBkEBcWoiGjYCACAEQQRqIgYgBigC -ACIcIANBBGooAgBBf3NqIgYgAiAWSSACIBpLcmoiAjYCACAGIBxJIAIgBklyIQYgA0EIaiEDIARB -CGohBCAVIAFBAmoiAUcNAAsLIABBAXEEfyABQQJ0IgEgBUEMamoiAiACKAIAIgIgBUGwAWogAWoo -AgBBf3NqIgEgBmoiAzYCACABIAJJIAEgA0tyBSAGC0EBcUUNDQsgBSAANgKsASAPQQFqIQ8LIAog -Dk0NASAJIA5qIA9BMGo6AAAgAEEpTw0KAkAgAEUEQEEAIQAMAQsgAEEBa0H/////A3EiAUEBaiIC -QQNxIQMCQCABQQNJBEAgBUEMaiEEQgAhJgwBCyACQfz///8HcSEBIAVBDGohBEIAISYDQCAEIAQ1 -AgBCCn4gJnwiJT4CACAEQQRqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIARBCGoiAiACNQIAQgp+ICVC -IIh8IiU+AgAgBEEMaiICIAI1AgBCCn4gJUIgiHwiJT4CACAlQiCIISYgBEEQaiEEIAFBBGsiAQ0A -CwsgAwRAA0AgBCAENQIAQgp+ICZ8IiU+AgAgBEEEaiEEICVCIIghJiADQQFrIgMNAAsLICVCgICA -gBBUDQAgAEEoRg0KIAVBDGogAEECdGogJj4CACAAQQFqIQALIAUgADYCrAEgDkEBaiEOIBcgCCAX -SyIBaiEXIAENAAtBASEGDAQLIA4gCkHE1cAAEH0ACyAIIApB1NXAABDMAQALIAJBKEHA+sAAEMwB -AAsMDAsCQAJAAkAgC0EpSQRAAkAgC0UEQEEAIQsMAQsgC0EBa0H/////A3EiAUEBaiICQQNxIQMC -QCABQQNJBEAgBUGwAWohBEIAISUMAQsgAkH8////B3EhASAFQbABaiEEQgAhJQNAIAQgBDUCAEIF -fiAlfCIlPgIAIARBBGoiAiACNQIAQgV+ICVCIIh8IiU+AgAgBEEIaiICIAI1AgBCBX4gJUIgiHwi -JT4CACAEQQxqIgIgAjUCAEIFfiAlQiCIfCImPgIAICZCIIghJSAEQRBqIQQgAUEEayIBDQALCyAD -BEADQCAEIAQ1AgBCBX4gJXwiJj4CACAEQQRqIQQgJkIgiCElIANBAWsiAw0ACwsgJkKAgICAEFQN -ACALQShGDQggBUGwAWogC0ECdGogJT4CACALQQFqIQsLIAUgCzYC0AIgCyAAIAAgC0kbIgRBKU8N -BiAEQQJ0IQQgBUEIaiEAIAVBrAFqIQECQAJAA0AgBEUNASABIARqIQIgACAEaiAEQQRrIQQoAgAi -AyACKAIAIgJGDQALIAIgA08NBQwBCyAGIARFcUUNBCAIQQFrIgAgCk8NAiAAIAlqLQAAQQFxRQ0E -CyAIIApLDQIgCCAJakEAIQQgCSEDAkADQCAEIAhGDQEgBEEBaiEEIANBAWsiAyAIaiIALQAAQTlG -DQALIAAgAC0AAEEBajoAACAIIARrQQFqIAhPDQQgBEEBayIBRQ0EIABBAWpBMCAB/AsADAQLAkAg -CEUEQEExIQQMAQsgCUExOgAAIAhBAUYEQEEwIQQMAQtBMCEEIAhBAWsiAEUNACAJQQFqQTAgAPwL -AAsgDUEBaiENIB4gCCAKT3INAyAEOgAAIAhBAWohCAwDCyALQShBwPrAABDMAQALIAAgCkGU1cAA -EH0ACyAIIApBpNXAABDMAQALIAggCksNAQsgEiANOwEIIBIgCDYCBCASIAk2AgAgBUHABmokAAwF -CyAIIApBtNXAABDMAQALIARBKEHA+sAAEMwBAAtBKEEoQcD6wAAQfQALIABBKEHA+sAAEMwBAAtB -0PrAAEEaQcD6wAAQkQEACwsgGCAHLgHICCIASARAIAdBCGogBygCwAggBygCxAggACARIAdBkAhq -EE0gBygCDCEAIAcoAggMAwtBAiEAIAdBAjsBkAggEUUEQEEBIQAgB0EBNgKYCCAHQcvlwAA2ApQI -IAdBkAhqDAMLIAcgETYCoAggB0EAOwGcCCAHQQI2ApgIIAdBweXAADYClAggB0GQCGoMAgtBzOXA -AEElQfTlwAAQkQEAC0EBIQAgB0EBNgKYCCAHQcvlwAA2ApQIIAdBkAhqCyEBIAcgADYCzAggByAB -NgLICCAHIB02AsQIIAcgGzYCwAggDCAHQcAIahA7IAdB8AhqJAAMAQsgAUEoQcD6wAAQzAEACwtC -AQF/IwBBIGsiAyQAIANBADYCECADQQE2AgQgA0IENwIIIAMgATYCHCADIAA2AhggAyADQRhqNgIA -IAMgAhCaAQALQAEBfyABKAIAIgEgASgCCCIEQQFqNgIIIARBAEgEQAALIAAgATYCDCAAIAM2Aggg -ACACNgIEIABBuLXAADYCAAuUAgEDfyAAKAIAIQIgASgCCCIAQYCAgBBxRQRAIABBgICAIHFFBEAg -AiABEM4BDwtBACEAIwBBgAFrIgQkACACKAIAIQIDQCAAIARqQf8AaiACQQ9xIgNBMHIgA0E3aiAD -QQpJGzoAACAAQQFrIQAgAkEPSyACQQR2IQINAAsgAUEBQYnpwABBAiAAIARqQYABakEAIABrEDMg -BEGAAWokAA8LQQAhACMAQYABayIEJAAgAigCACECA0AgACAEakH/AGogAkEPcSIDQTByIANB1wBq -IANBCkkbOgAAIABBAWshACACQQ9LIAJBBHYhAg0ACyABQQFBienAAEECIAAgBGpBgAFqQQAgAGsQ -MyAEQYABaiQACzgAAkAgAkGAgMQARg0AIAAgAiABKAIQEQAARQ0AQQEPCyADRQRAQQAPCyAAIAMg -BCABKAIMEQEACy0AAkAgACABEK8BRQ0AIAAEQEHJ/8AALQAAGiAAIAEQuwEiAUUNAQsgAQ8LAAs3 -AQF/IwBBIGsiASQAIAFBADYCGCABQQE2AgwgAUG8+8AANgIIIAFCBDcCECABQQhqIAAQmgEAC7MB -AQJ/IwBBEGsiACQAIAEoAgBBmMTAAEELIAEoAgQoAgwRAQAhAyAAQQhqIgJBADoABSACIAM6AAQg -AiABNgIAIAIiAS0ABCECIAEtAAUEQCABAn9BASACQQFxDQAaIAEoAgAiAS0ACkGAAXFFBEAgASgC -AEGD6cAAQQIgASgCBCgCDBEBAAwBCyABKAIAQYLpwABBASABKAIEKAIMEQEACyICOgAECyACQQFx -IABBEGokAAunDAIXfwF+IwBBEGsiCiQAIAEhECMAQdAAayIDJAACQAJAAkACQCAAIgsEQCAAQQhr -IgwgDCgCAEEBaiIANgIAIABFDQEgCygCAA0CIAtBfzYCACADIAw2AhQgAyALNgIQIAMgC0EIaiIP -NgIMIANBGGohCSMAQYABayIAJAAgAEEANgIUIABCgICAgIABNwIMAkACQCACBEAgAEHIAGpBBHIh -BgNAIAIgBEkNAiAAQcgAaiAPIAQgEGogAiAEa0EAEC8gAEEgaiIRIAZBCGopAgA3AwAgAEEoaiIS -IAZBEGopAgA3AwAgAEEwaiITIAZBGGopAgA3AwAgAEE4aiIUIAZBIGopAgA3AwAgAEFAayIVIAZB -KGooAgA2AgAgACAGKQIANwMYIAAoAnghFiAAKAJIIhcEQCAAKAIUIg0gACgCDEYEQCMAQSBrIgEk -AEEEIABBDGoiBygCACIOQQF0IgUgBUEETRsiGK1CMH4iGkIgiFBFBEBBAEEAQdibwAAQrgEACwJA -IBqnIhlB+P///wdNBEAgASAOBH8gASAOQTBsNgIcIAEgBygCBDYCFEEIBUEACzYCGCABQQhqQQgg -GSABQRRqEHEgASgCCEEBRw0BIAEoAgwhCCABKAIQIQULIAggBUHYm8AAEK4BAAsgASgCDCEFIAcg -GDYCACAHIAU2AgQgAUEgaiQACyAAKAIQIA1BMGxqIgEgACkDGDcCBCABIBc2AgAgAUEMaiARKQMA -NwIAIAFBFGogEikDADcCACABQRxqIBMpAwA3AgAgAUEkaiAUKQMANwIAIAFBLGogFSgCADYCACAA -IA1BAWo2AhQLIAQgFmoiBCACRw0ACwsgCSAAKQIMNwIAIAlBCGogAEEUaigCADYCACAAQYABaiQA -DAELIAQgAkHom8AAEMsBAAtBBCEEIAMoAhwhACADKAIYIQUgAygCICIBBEBByf/AAC0AABogAUEE -dCIGQQQQuwEiBEUNBAsgA0EANgIsIAMgBDYCKCADIAE2AiQgAyAAIAFBMGxqNgI8IAMgBTYCOCAD -IAA2AjQgAyAANgIwIAMgBDYCSCADQQA2AkQgAyADQSxqNgJAIANBQGshBSMAQUBqIgQkAAJAIANB -MGoiCCgCBCIAIAgoAgwiDUYEQCAFKAIEIQYMAQsgBSgCCCAFKAIEIgZBBHRqIQcgBEEcaiEOIARB -IGohCQNAIAggAEEwaiIBNgIEIARBOGogAEEoaikDADcDACAEQTBqIABBIGopAwA3AwAgBEEoaiAA -QRhqKQMANwMAIAkgAEEQaikDADcDACAEQRhqIg8gAEEIaikDADcDACAEIAApAwA3AxAgBCAJEGIg -BCAPKAIAIgA2AgwgDiAEKAIUIAAgBCgCECgCEBEDACAHQQhqIARBCGopAgA3AgAgByAEKQIANwIA -IAUgBkEBaiIGNgIEIAdBEGohByABIgAgDUcNAAsLIAUoAgAgBjYCACAIKAIIIgAEQCAIKAIAIABB -MGwQxwELIARBQGskACADKAIkIQkgAygCKCEBIAMoAiwhBCADQQA2AiRBASEHIAggA0EkahCtAQJA -IAMoAjBFBEAgAygCNCEFDAELIANByABqIANBOGooAgA2AgAgAyADKQIwNwNAAkAgBARAIARBBHQh -ByADQUBrQQRyIQggAygCSCEGIAEhAANAIAMgACADKAJAEF8gAygCBCEFIAMoAgBBAXENAiAIIAYg -BRDJASADIAZBAWoiBjYCSCAAQRBqIQAgB0EQayIHDQALC0EAIQcgAygCRCEFDAELQQEhByADKAJE -IgBBhAFJDQAgABBqCyAEBEAgASEAA0AgACgCACIGBEAgAEEEaigCACAGEMcBCyAAQRBqIQAgBEEB -ayIEDQALCyAJBEAgASAJQQR0EMcBCyACBEAgECACEMcBCyALQQA2AgAgDCAMKAIAQQFrIgA2AgAg -AEUEQCADQRRqEI4BCyAKIAc2AgggCiAFQQAgBxs2AgQgCkEAIAUgBxs2AgAgA0HQAGokAAwECxDc -AQsACxDdAQALQQQgBkGMjsAAEK4BAAsgCigCACAKKAIEIAooAgggCkEQaiQAC6shAhZ/An4jAEEQ -ayIMJAAQbSIBIAAmASMAQRBrIhEkACARQQRqIRIjAEHQAGsiBCQAIARBCGohBSMAQdAAayICJAAg -AiABNgIgAkACQAJAAkACQCACQSBqIgEoAgAlARAcBEAgAkEkaiIDIAEoAgAlARAQNgIIIANBADYC -BCADIAE2AgBBACEBIAJBADYCMCACKAIkBEAgAigCLCIDIAIoAigiBk0EQEEEIQMMAwtByf/AAC0A -ABpBgIAEIAMgBmsiAUEAIAEgA00bIgEgAUGAgARPGyIBQQR0IgZBBBC7ASIDDQJBBCAGQZiDwAAQ -rgEACyACQQA2AjwgAkKAgICAwAA3AjQMAgsgAkFAayEBEBchABBtIgcgACYBIAJBIGooAgAiBiUB -IAclARAYIQAQbSIDIAAmAUGMgMEAKAIAIQhBiIDBACgCACEKQYiAwQBCADcCAAJAAkACQCAKQQFG -BEAgAUEDOgAEIAEgCDYCAAwBCwJAIAMQ6wFBAUYEQCADJQEgBiUBEBkhABBtIgYgACYBQYyAwQAo -AgAhCEGIgMEAKAIAIQpBiIDBAEIANwIAAkAgCkEBRgRAIAFBAzoABCABIAg2AgAMAQsCQCAGEOoB -QQFHDQAgBiUBEBMhABBtIgggACYBIAgQ6wEgCEGEAU8EQCAIEGoLQQFHDQAgAUEAOgAEIAEgBjYC -ACADQYQBTwRAIAMQagsgB0GEAUkNBgwFCyABQQI6AAQgBkGEAUkNACAGEGoLIANBhAFPDQEMAgsg -AUECOgAEIANBhAFJDQELIAMQagsgB0GDAU0NAQsgBxBqCyACKAJAIQECQAJAAkAgAi0ARCIDQQJr -DgICAAELIAVBgICAgHg2AgAgBSABNgIEIAIoAiAiAUGDAUsNBQwGCyACIAM6ADggAiABNgI0IAJB -ADYCLCACQoCAgIDAADcCJCACQRhqIAJBNGoQeAJAIAIoAhgiA0ECRwRAIAIoAhwhAQNAAkAgA0EB -cUUEQCACQUBrIAEQLSACKAJEIQEgAigCQCIHQYCAgIB4Rw0BCyAFQYCAgIB4NgIAIAUgATYCBCAC -KAIsIgMEQCACKAIoIQEDQCABKAIAIgUEQCABQQRqKAIAIAUQxwELIAFBEGohASADQQFrIgMNAAsL -IAIoAiQiAQRAIAIoAiggAUEEdBDHAQsgAigCNCIBQYMBSw0DDAcLIAIpAkghFyACKAIsIgMgAigC -JEYEQCACQSRqQaiDwAAQZgsgAigCKCADQQR0aiIGIBc3AgggBiABNgIEIAYgBzYCACACIANBAWo2 -AiwgAkEQaiACQTRqEHggAigCFCEBIAIoAhAiA0ECRw0ACwsgBSACKQIkNwIAIAVBCGogAkEsaigC -ADYCACACKAI0IgFBgwFNDQQLIAEQagwDCyACQSBqIAJBQGtB2IPAABA+IQEgBUGAgICAeDYCACAF -IAE2AgQMAgsgAkEANgI8IAIgAzYCOCACIAE2AjQDQCACQQhqIQMgAkEkaiIBKAIEIgYgASgCCE8E -f0EABSABIAZBAWo2AgQgASgCACgCACUBIAYQDyEAEG0iASAAJgFBAQshBiADIAE2AgQgAyAGNgIA -IAIoAghBAXFFDQEgAigCDCEBIAIgAigCMEEBajYCMCACQUBrIAEQLSACKAJEIQEgAigCQCIHQYCA -gIB4RgRAIAVBgICAgHg2AgAgBSABNgIEIAIoAjwiAwRAIAIoAjghAQNAIAEoAgAiBQRAIAFBBGoo -AgAgBRDHAQsgAUEQaiEBIANBAWsiAw0ACwsgAigCNCIBRQ0DIAIoAjggAUEEdBDHAQwDCyACKQJI -IRcgAigCPCIDIAIoAjRGBEAgAkE0akGog8AAEGYLIAIoAjggA0EEdGoiBiAXNwIIIAYgATYCBCAG -IAc2AgAgAiADQQFqNgI8IAIoAiQNAAsLIAUgAikCNDcCACAFQQhqIAJBPGooAgA2AgALIAIoAiAi -AUGDAU0NAQsgARBqCyACQdAAaiQAIAQoAgwhAQJAAkACQAJAAkACQAJAAkAgBCgCCCICQYCAgIB4 -RgRAIAQgATYCFCAEQQA2AkggBEKAgICAEDcCQCAEQZyOwAA2AhwgBEKggICADjcCICAEIARBQGs2 -AhgjAEEQayIBJAAgAUEIaiAEQRRqKAIAJQEQCyABKAIIIgMgASgCDCICIARBGGoQ5QEgAgRAIAMg -AhDHAQsgAUEQaiQADQIgBCgCQCEBIAQoAkQiAiAEKAJIELIBIQMgAQRAIAIgARDHAQsgBCgCFCIB -QYQBTwRAIAEQagsgEkGAgICAeDYCACASIAM2AgQMAQsgBCgCECEDIARBADYCCCAEIAEgA0EEdGo2 -AiQgBCACNgIgIAQgATYCHCAEIAE2AhggBCAEQQhqNgIoIARBQGshBiMAQcABayIBJAAgBEEYaiIF -KAIQIQIgASAFQRBqIgM2AiAgASACNgIcIAEgAUG/AWoiBzYCGCABQYABaiIIIAUgAUEYaiIOEEAC -QAJAAkACQCABKQOAASIXQgJRDQAgAUH4AGoiAiABQagBaikDADcDACABQfAAaiILIAFBoAFqKQMA -NwMAIAFB6ABqIhAgAUGYAWopAwA3AwAgAUHgAGoiDSABQZABaikDADcDACABIAEpA4gBNwNYIBen -QQFxRQ0AIAFB0ABqIgogAikDADcDACABQcgAaiIPIAspAwA3AwAgAUFAayITIBApAwA3AwAgAUE4 -aiILIA0pAwA3AwAgASABKQNYNwMwQcn/wAAtAAAaQaABQQgQuwEiAkUNAiACIAEpAzA3AwAgAkEg -aiAKKQMANwMAIAJBGGogDykDADcDACACQRBqIBMpAwA3AwAgAkEIaiALKQMANwMAIAFBATYCFCAB -IAI2AhAgAUEENgIMIAFBKGoiECADKAIAIgM2AgAgAUEgaiAFQQhqKQIANwMAIAEgBSkCADcDGCAB -IBA2ArgBIAEgAzYCtAEgASAHNgKwASAIIA4gAUGwAWoQQAJAIAEpA4ABIhdCAlENACABQYgBaiEF -QSghCEEBIQMDQCABQfgAaiIHIAVBIGopAwA3AwAgAUHwAGoiDiAFQRhqKQMANwMAIAFB6ABqIg0g -BUEQaikDADcDACABQeAAaiITIAVBCGopAwA3AwAgASAFKQMANwNYIBenQQFxRQ0BIAogBykDADcD -ACAPIA4pAwA3AwAgAUFAayIOIA0pAwA3AwAgCyATKQMANwMAIAEgASkDWDcDMCABKAIMIANGBEAg -AUEMaiADQQFBCEEoEFUgASgCECECCyACIAhqIgcgASkDMDcDACAHQSBqIAopAwA3AwAgB0EYaiAP -KQMANwMAIAdBEGogDikDADcDACAHQQhqIAspAwA3AwAgASADQQFqIgM2AhQgASgCKCEHIAEgEDYC -uAEgASAHNgK0ASAIQShqIQggASABQb8BajYCsAEgAUGAAWogAUEYaiABQbABahBAIAEpA4ABIhdC -AlINAAsLIAEoAiQiAyABKAIcIgJHBEAgAyACa0EEdiEDA0AgAigCACIFBEAgAkEEaigCACAFEMcB -CyACQRBqIQIgA0EBayIDDQALCyABKAIgIgIEQCABKAIYIAJBBHQQxwELIAYgASkCDDcCACAGQQhq -IAFBFGooAgA2AgAMAQsgBkEANgIIIAZCgICAgIABNwIAIAUoAgwiAyAFKAIEIgJHBEAgAyACa0EE -diEDA0AgAigCACIGBEAgAkEEaigCACAGEMcBCyACQRBqIQIgA0EBayIDDQALCyAFKAIIIgJFDQAg -BSgCACACQQR0EMcBCyABQcABaiQADAELQQhBoAFBtIfAABCuAQALAkACQCAEKAIIQQFGBEAgBCgC -DCEPIAQoAkAiAUUNASAEKAJEIAFBKGwQxwEMAQsgBCgCRCEPIAQoAkAiEEGAgICAeEcNAQsgEkGA -gICAeDYCACASIA82AgQMAQsCQCAEKAJIIgJFBEAgBEEwakIANwMAIARBKGpCADcDACAEQSBqQgA3 -AwAgBEIANwMYDAELIAKtQih+IhenIQEgF0IgiKcgAUH4////B0tyDQMCfyABRQRAQQghB0EADAEL -Qcn/wAAtAAAaQQghCSABQQgQuwEiB0UNBCACCyEOIAEEQCAHIA8gAfwKAAALIAJBAUcEQCAHQdAA -aiETA0BBACEBQQAhAwNAIAEhBSACIANJDQkgA0EobCEIAkAgAiADayIBQQNJDQBBCSABIAFBCU8b -IQYgCCATaiEJQQIhAQNAIAEgBkYEQCAGIQEMAgsgAUEBaiEBIAkpAxhCA4MgCUEoaiEJQgBSDQAL -CyABIANqIgYgAUkNByACIAZJDQggBEEYaiEKIAcgCGohC0EAIQ1BACEIIwBB4ABrIgMkAAJAQQBB -4IzAACgCABEFACIJBEACQCAJKAIARQRAIAlBADYCDCAJQX82AgAgAQRAIAlBBGohDSALIAFBKGxq -IRYgA0E0aq1CgICAgJABhCEXIANBMGqtQoCAgICgAYQhGANAIAMgCzYCMCADIAtBIGoiATYCNCAD -QQM2AjwgA0HQhMAANgI4IANCAjcCRCADIBc3A1ggAyAYNwNQIAMgA0HQAGo2AkAgDUHIisAAIANB -OGoQOA0DIAEoAgAgCGohCCABQQhqIgsgFkcNAAsgCSgCDCENCyADQQhqQdS4wAAgCSgCCCANEDEg -A0EoaiIBIAg2AgAgCSAJKAIAQQFqNgIAIApBIGogASkDADcDACAKQRhqIANBIGopAwA3AwAgCkEQ -aiADQRhqKQMANwMAIApBCGogA0EQaikDADcDACAKIAMpAwg3AwAgA0HgAGokAAwDC0GchsAAEIkB -AAtB+ITAAEErIANBOGpB6ITAAEGMhsAAEHoACyMAQTBrIgEkACABQQE2AgwgAUHsxMAANgIIIAFC -ATcCFCABIAFBL2qtQoCAgICACoQ3AyAgASABQSBqNgIQIAFBCGpBvIjAABCaAQALIAIgBUYNCiAH -IAVBKGxqIgEgBCkDGDcDACABQSBqIARBOGopAwA3AwAgAUEYaiAEQTBqKQMANwMAIAFBEGogBEEo -aikDADcDACABQQhqIARBIGopAwA3AwAgBUEBaiEBIAYiAyACRw0ACyABIQIgBQ0ACwsgBEEwaiAH -QRhqKQMANwMAIARBKGogB0EQaikDADcDACAEQSBqIAdBCGopAwA3AwAgBCAHKQMANwMYIA5FDQAg -ByAOQShsEMcBCyASIARBGGoQYiAQRQ0AIA8gEEEobBDHAQsgBEHQAGokAAwGC0HEjsAAQTcgBEHP -AGpBtI7AAEHwj8AAEHoACyAJIAFBoJHAABCuAQALIAMgBkHQjMAAEM0BAAsgBiACQdCMwAAQzAEA -CyADIAJB9IzAABDLAQALIAIgAkHkjMAAEH0ACwJAAkAgDAJ/IBEoAgQiAkGAgICAeEYEQCARKAII -IQFBAQwBCyARKAIIIQECQCARKAIMIhQgAk8EQCABIRUMAQsgFEUEQEEBIRUgASACEMcBDAELIAEg -AkEBIBQQtAEiFUUNAgtBACEBQQALNgIMIAwgATYCCCAMIBQ2AgQgDCAVNgIAIBFBEGokAAwBC0EB -IBRBtJPAABCuAQALIAwoAgAgDCgCBCAMKAIIIAwoAgwgDEEQaiQAC/oBAgJ/AX4jAEEQayICJAAg -AkEBOwEMIAIgATYCCCACIAA2AgQjAEEQayIBJAAgAkEEaiIAKQIAIQQgASAANgIMIAEgBDcCBCMA -QRBrIgAkACABQQRqIgEoAgAiAigCDCEDAkACQAJAAkAgAigCBA4CAAECCyADDQFBASECQQAhAwwC -CyADDQAgAigCACICKAIEIQMgAigCACECDAELIABBgICAgHg2AgAgACABNgIMIABBjMbAACABKAIE -IAEoAggiAC0ACCAALQAJEGQACyAAIAM2AgQgACACNgIAIABB8MXAACABKAIEIAEoAggiAC0ACCAA -LQAJEGQAC64IAQp/IwBBEGsiBiQAIwBBIGsiBCQAAkACQAJAIAAEQCAAQQhrIgggCCgCAEEBaiIB -NgIAIAFFDQEgACgCAA0CIABBfzYCACAEIAg2AhwgBCAANgIYIAQgAEEIaiIDNgIUIARBCGohCiMA -QbABayIBJAAgAUEANgIcIAFCgICAgMAANwIUIwBBQGoiAiQAIAJBCGogA0EBQQBBARAvIAFBIGoi -A0EoaiACQTBqKQMANwMAIANBIGogAkEoaikDADcDACADQRhqIAJBIGopAwA3AwAgA0EQaiACQRhq -KQMANwMAIANBCGogAkEQaikDADcDACADIAIpAwg3AwAgAkFAayQAAn8gASgCICIFRQRAQQQhAkEA -DAELIAFB+ABqIAFByABqKQMANwMAIAFB8ABqIAFBQGspAwA3AwAgAUHoAGogAUE4aikDADcDACAB -QeAAaiICIAFBMGopAwA3AwAgAUHYAGoiAyABQShqKQMANwMAIAEgASkDIDcDUCABQYABaiACEGIg -ASADKAIAIgI2AowBIAFB3ABqIAEoAlQgAiABKAJQKAIQEQMAIAFBFGpBpJPAABBmIAEoAhgiAiAB -KQKAATcCACACQQhqIAFBiAFqKQIANwIAIAFBATYCHEEBCyEHIAFBADYCmAFBASEDIAFBIGogAUGY -AWoQrQECQCABKAIgRQRAIAEoAiQhBQwBCyABQagBaiABQShqKAIANgIAIAEgASkCIDcDoAECQCAF -BEAgB0EEdCEHIAFBoAFqQQRyIQkgASgCqAEhAwNAIAFBCGogAiABKAKgARBfIAEoAgwhBSABKAII -QQFxDQIgCSADIAUQyQEgASADQQFqIgM2AqgBIAJBEGohAiAHQRBrIgcNAAsLQQAhAyABKAKkASEF -DAELQQEhAyABKAKkASICQYQBSQ0AIAIQagsgASAFNgKUASABIAM2ApABIAFBATYCJCABQbCRwAA2 -AiAgAUIBNwIsIAEgAUGQAWqtQoCAgICgAoQ3A5gBIAEgAUGYAWo2AiggAUGgAWogAUEgahBEIAEo -AqQBIgIgASgCqAEQBSABKAKgASIDBEAgAiADEMcBCyABKAKQASEFIAEoApQBIQcgASgCHCIDBEAg -ASgCGCECA0AgAigCACIJBEAgAkEEaigCACAJEMcBCyACQRBqIQIgA0EBayIDDQALCyABKAIUIgIE -QCABKAIYIAJBBHQQxwELIAogBzYCBCAKIAU2AgAgAUGwAWokACAEKAIMIQEgBCgCCCECIABBADYC -ACAIIAgoAgBBAWsiADYCACAARQRAIARBHGoQjgELIAYgAkEBcSIANgIIIAYgAUEAIAAbNgIEIAZB -ACABIAAbNgIAIARBIGokAAwDCxDcAQsACxDdAQALIAYoAgAgBigCBCAGKAIIIAZBEGokAAshAAJA -IAEgAxCvAQRAIAAgASADIAIQtAEiAA0BCwALIAALJQAgAEUEQEGAssAAQTIQ3gEACyAAIAIgAyAE -IAUgASgCEBESAAsgAQF/QQEhASAAKAIAIgBBAXEEfyABBSAAKAIIQQFGCwsfAQJ+IAApAwAiAiAC -Qj+HIgOFIAN9IAJCAFkgARBGCyMAIABFBEBBgLLAAEEyEN4BAAsgACACIAMgBCABKAIQEQQACyMA -IABFBEBBgLLAAEEyEN4BAAsgACACIAMgBCABKAIQEQ4ACyMAIABFBEBBgLLAAEEyEN4BAAsgACAC -IAMgBCABKAIQESYACyMAIABFBEBBgLLAAEEyEN4BAAsgACACIAMgBCABKAIQESgACyMAIABFBEBB -gLLAAEEyEN4BAAsgACACIAMgBCABKAIQESoACyYBAX8gACgCACIBQYCAgIB4ckGAgICAeEcEQCAA -KAIEIAEQxwELCyEAIABFBEBBgLLAAEEyEN4BAAsgACACIAMgASgCEBEDAAsiACAALQAARQRAIAFB -ruvAAEEFEDYPCyABQbPrwABBBBA2Cx8AIABFBEBBgLLAAEEyEN4BAAsgACACIAEoAhARAAALIQAg -AEEANgIMIAAgAzYCCCAAIAI2AgQgAEHAs8AANgIACykAIAAgAC0ABCABQS5GcjoABCAAKAIAIgAo -AgAgASAAKAIEKAIQEQAACxgBAX8gACgCACIBBEAgACgCBCABEMcBCwvsAQEDf0H0/8AAKAIABH9B -+P/AAAUCfwJAAkACQCAARQ0AIAAoAgAgAEEANgIAQQFxRQ0AIAAoAhAhASAAKAIMIQIgACgCCCED -IAAoAgQhAAwBC0EAIQFByf/AAC0AABpBgAghA0EAIQBBgAhBARC7ASICRQ0BC0GEgMEAIAE2AgBB -+P/AACAANgIAQYCAwQAoAgAhAUGAgMEAIAI2AgBB/P/AACgCACEAQfz/wAAgAzYCAEH0/8AAKAIA -QfT/wABBATYCAEUgAEVyRQRAIAEgABDHAQtB+P/AAAwBC0EBQYAIQfSAwAAQrgEACwsLJwIBbwF/ -EBEhAhBtIgMgAiYBIABBADYCCCAAIAM2AgQgACABNgIAC0IAIAAEQCAAIAEQ4wEACyMAQSBrIgAk -ACAAQQA2AhggAEEBNgIMIABBvMfAADYCCCAAQgQ3AhAgAEEIaiACEJoBAAsVACABaUEBRiAAQYCA -gIB4IAFrTXELHAAgAEEANgIQIABCADcCCCAAQoCAgIDAADcCAAsWAQFvIAAgARAEIQIQbSIAIAIm -ASAACxYBAW8gACABEAYhAhBtIgAgAiYBIAALFgEBbyAAJQEQICEBEG0iACABJgEgAAvtBgEGfwJ/ -AkACQAJAAkACQCAAQQRrIgUoAgAiBkF4cSIEQQRBCCAGQQNxIgcbIAFqTwRAIAdBACABQSdqIgkg -BEkbDQECQAJAIAJBCU8EQCACIAMQRSIIDQFBAAwJCyADQcz/e0sNAUEQIANBC2pBeHEgA0ELSRsh -AQJAIAdFBEAgAUGAAkkgBCABQQRySXIgBCABa0GBgAhPcg0BDAkLIABBCGsiAiAEaiEHAkACQAJA -AkAgASAESwRAIAdB0IPBACgCAEYNBCAHQcyDwQAoAgBGDQIgBygCBCIGQQJxDQUgBkF4cSIGIARq -IgQgAUkNBSAHIAYQSCAEIAFrIgNBEEkNASAFIAEgBSgCAEEBcXJBAnI2AgAgASACaiIBIANBA3I2 -AgQgAiAEaiICIAIoAgRBAXI2AgQgASADEEEMDQsgBCABayIDQQ9LDQIMDAsgBSAEIAUoAgBBAXFy -QQJyNgIAIAIgBGoiASABKAIEQQFyNgIEDAsLQcSDwQAoAgAgBGoiBCABSQ0CAkAgBCABayIDQQ9N -BEAgBSAGQQFxIARyQQJyNgIAIAIgBGoiASABKAIEQQFyNgIEQQAhA0EAIQEMAQsgBSABIAZBAXFy -QQJyNgIAIAEgAmoiASADQQFyNgIEIAIgBGoiAiADNgIAIAIgAigCBEF+cTYCBAtBzIPBACABNgIA -QcSDwQAgAzYCAAwKCyAFIAEgBkEBcXJBAnI2AgAgASACaiIBIANBA3I2AgQgByAHKAIEQQFyNgIE -IAEgAxBBDAkLQciDwQAoAgAgBGoiBCABSw0HCyADECkiAUUNASADQXxBeCAFKAIAIgJBA3EbIAJB -eHFqIgIgAiADSxsiAgRAIAEgACAC/AoAAAsgABA1IAEMCAsgAyABIAEgA0sbIgIEQCAIIAAgAvwK -AAALIAUoAgAiAkF4cSIDIAFBBEEIIAJBA3EiAhtqSQ0DIAJBACADIAlLGw0EIAAQNQsgCAwGC0GZ -w8AAQS5ByMPAABCRAQALQdjDwABBLkGIxMAAEJEBAAtBmcPAAEEuQcjDwAAQkQEAC0HYw8AAQS5B -iMTAABCRAQALIAUgASAGQQFxckECcjYCACABIAJqIgIgBCABayIBQQFyNgIEQciDwQAgATYCAEHQ -g8EAIAI2AgAgAAwBCyAACwsOACABBEAgACABEMcBCwsZACABKAIAQZfmwABBDiABKAIEKAIMEQEA -CxYAIAAoAgAgASACIAAoAgQoAgwRAQALFAAgACgCACABIAAoAgQoAgwRAAALgwgBBH8jAEHwAGsi -BSQAIAUgAzYCDCAFIAI2AggCfyABQYECTwRAAn9BgAIgACwAgAJBv39KDQAaQf8BIAAsAP8BQb9/ -Sg0AGkH+AUH9ASAALAD+AUG/f0obCyIGIABqLAAAQb9/SgRAQfPrwAAhB0EFDAILIAAgAUEAIAYg -BBC5AQALQQEhByABIQZBAAshCCAFIAY2AhQgBSAANgIQIAUgCDYCHCAFIAc2AhgCQAJAAkACQCAB -IAJJIgYgASADSXJFBEAgAiADSw0BIAJFIAEgAk1yRQRAIAVBDGogBUEIaiAAIAJqLAAAQb9/Shso -AgAhAwsgBSADNgIgIAMgASICSQRAIANBAWoiAiADQQNrIgZBACADIAZPGyIGSQ0DAn8gAiAGayIH -QQFrIAAgA2osAABBv39KDQAaIAdBAmsgACACaiICQQJrLAAAQb9/Sg0AGiAHQQNrIAJBA2ssAABB -v39KDQAaIAdBfEF7IAJBBGssAABBv39KG2oLIAZqIQILAkAgAkUNACABIAJNBEAgASACRg0BDAUL -IAAgAmosAABBv39MDQQLAn8CQAJAIAEgAkYNAAJAAkAgACACaiIBLAAAIgBBAEgEQCABLQABQT9x -IQYgAEEfcSEDIABBX0sNASADQQZ0IAZyIQAMAgsgBSAAQf8BcTYCJEEBDAQLIAEtAAJBP3EgBkEG -dHIhBiAAQXBJBEAgBiADQQx0ciEADAELIANBEnRBgIDwAHEgAS0AA0E/cSAGQQZ0cnIiAEGAgMQA -Rg0BCyAFIAA2AiQgAEGAAU8NAUEBDAILIAQQzwEAC0ECIABBgBBJDQAaQQNBBCAAQYCABEkbCyEA -IAUgAjYCKCAFIAAgAmo2AiwgBUEFNgI0IAVB/OzAADYCMCAFQgU3AjwgBSAFQRhqrUKAgICAkA2E -NwNoIAUgBUEQaq1CgICAgJANhDcDYCAFIAVBKGqtQoCAgICwDYQ3A1ggBSAFQSRqrUKAgICAwA2E -NwNQIAUgBUEgaq1CgICAgJAKhDcDSAwECyAFIAIgAyAGGzYCKCAFQQM2AjQgBUG87cAANgIwIAVC -AzcCPCAFIAVBGGqtQoCAgICQDYQ3A1ggBSAFQRBqrUKAgICAkA2ENwNQIAUgBUEoaq1CgICAgJAK -hDcDSAwDCyAFQQQ2AjQgBUGc7MAANgIwIAVCBDcCPCAFIAVBGGqtQoCAgICQDYQ3A2AgBSAFQRBq -rUKAgICAkA2ENwNYIAUgBUEMaq1CgICAgJAKhDcDUCAFIAVBCGqtQoCAgICQCoQ3A0gMAgsgBiAC -QdTtwAAQzQEACyAAIAEgAiABIAQQuQEACyAFIAVByABqNgI4IAVBMGogBBCaAQALEQAgACgCACAA -KAIEIAEQ5QELGQACfyABQQlPBEAgASAAEEUMAQsgABApCwsPACAAIAEoAgAgAiADEFkLDwAgACAB -KAIAIAIgAxA/CxEAIAAoAgQgACgCCCABEOUBC+AGAQ9/IAAoAgAhByAAKAIEIQVBACEAIwBBEGsi -BiQAQQEhDAJAIAEoAgAiCkEiIAEoAgQiDSgCECIOEQAADQACQCAFRQRADAELQQAgBWshDyAHIQEg -BSEAAkACfwJAA0AgACABaiEQQQAhAwJAA0AgASADaiIELQAAIglB/wBrQf8BcUGhAUkgCUEiRnIg -CUHcAEZyDQEgACADQQFqIgNHDQALIAAgCGoMAwsgBEEBaiEBAkAgBCwAACIAQQBOBEAgAEH/AXEh -AAwBCyABLQAAQT9xIQsgAEEfcSEJIARBAmohASAAQV9NBEAgCUEGdCALciEADAELIAEtAABBP3Eg -C0EGdHIhCyAEQQNqIQEgAEFwSQRAIAsgCUEMdHIhAAwBCyAJQRJ0QYCA8ABxIAEtAABBP3EgC0EG -dHJyIQAgBEEEaiEBCyAGQQRqIABBgYAEEDICQAJAIAYtAARBgAFGDQAgBi0ADyAGLQAOa0H/AXFB -AUYNAAJAAkAgAiADIAhqIgRLDQACQCACRQ0AIAIgBU8EQCACIAVHDQIMAQsgAiAHaiwAAEG/f0wN -AQsCQCAERQ0AIAQgBU8EQCAEIA9qRQ0BDAILIAcgCGogA2osAABBQEgNAQsgCiACIAdqIAggAmsg -A2ogDSgCDCICEQEARQ0BDAMLIAcgBSACIARBuOvAABC5AQALAkAgBi0ABEGAAUYEQCAKIAYoAggg -DhEAAA0DDAELIAogBi0ADiIEIAZBBGpqIAYtAA8gBGsgAhEBAA0CCwJ/QQEgAEGAAUkNABpBAiAA -QYAQSQ0AGkEDQQQgAEGAgARJGwsgCGogA2ohAgsCf0EBIABBgAFJDQAaQQIgAEGAEEkNABpBA0EE -IABBgIAESRsLIAhqIgQgA2ohCCAQIAFrIgBFDQIMAQsLDAQLIAMgBGoLIgMgAkkNAEEAIQACQCAC -RQ0AIAIgBU8EQCACIgAgBUcNAgwBCyACIgAgB2osAABBv39MDQELIANFBEBBACEDDAILIAMgBU8E -QCADIAVGDQIgACECDAELIAMgB2osAABBv39KDQEgACECCyAHIAUgAiADQcjrwAAQuQEACyAKIAAg -B2ogAyAAayANKAIMEQEADQAgCkEiIA4RAAAhDAsgBkEQaiQAIAwLFgBBjIDBACAANgIAQYiAwQBB -ATYCAAsiACAAQu26rbbNhdT14wA3AwggAEL4gpm9le7Gxbl/NwMACyEAIABCgLzfhaul+JsnNwMI -IABCn/WWlNbu7cOhfzcDAAsTACAAQeDFwAA2AgQgACABNgIACxEAIAEgACgCACAAKAIEELcBCxAA -IAEgACgCACAAKAIEEDYLEAAgASgCACABKAIEIAAQOAthAQJ/AkACQCAAQQRrKAIAIgJBeHEiA0EE -QQggAkEDcSICGyABak8EQCACQQAgAyABQSdqSxsNASAAEDUMAgtBmcPAAEEuQcjDwAAQkQEAC0HY -w8AAQS5BiMTAABCRAQALCx0BAW8gACgCACUBIAElASABEGogAiUBIAIQahAOCxcBAW8gACgCACUB -IAEgAiUBIAIQahAbCw0AIAAoAgAoAghBAUYLawEBfyMAQTBrIgMkACADIAE2AgQgAyAANgIAIANB -AjYCDCADQbz8wAA2AgggA0ICNwIUIAMgA0EEaq1CgICAgJAKhDcDKCADIAOtQoCAgICQCoQ3AyAg -AyADQSBqNgIQIANBCGogAhCaAQALawEBfyMAQTBrIgMkACADIAE2AgQgAyAANgIAIANBAjYCDCAD -Qdz8wAA2AgggA0ICNwIUIAMgA0EEaq1CgICAgJAKhDcDKCADIAOtQoCAgICQCoQ3AyAgAyADQSBq -NgIQIANBCGogAhCaAQALawEBfyMAQTBrIgMkACADIAE2AgQgAyAANgIAIANBAjYCDCADQZD9wAA2 -AgggA0ICNwIUIAMgA0EEaq1CgICAgJAKhDcDKCADIAOtQoCAgICQCoQ3AyAgAyADQSBqNgIQIANB -CGogAhCaAQALCwAgACgCACABEEcLDwBBwObAAEErIAAQkQEACw0AIAApAwBBASABEEYLDgAgAUGo -gsAAQQoQtwELCwAgACgCACABEHALDAAgACgCACABEM4BC4oDAQF/IAAoAgAhAiMAQdABayIAJAAg -ACACQRhqrUKAgICAgAiENwNoIAAgAkEQaq1CgICAgIAIhDcDYCAAIAJBCGqtQoCAgICACIQ3A1gg -ACACrUKAgICAgAiENwNQIABB5LfAADYCOCAAQQQ2AjwgAEEENgJMIABCg4CAgICEgIBpNwLIASAA -QYCAwAA2AsABIABBAjsBuAEgAEKCgICAgISAgGk3ArABIABBgIDAADYCqAEgAEECOwGgASAAQoGA -gICAhICAaTcCmAEgAEGAgMAANgKQASAAQQI7AYgBIABCgICAgICEgIBpNwKAASAAQoCAwAA3Angg -AEECOwFwIAAgAEHwAGo2AkggAEEENgJEIAAgAEHQAGo2AkAgAEEsaiICIABBOGoQRCAAIAKtQoCA -gICQCIQ3AyAgAEEBNgIMIABB9LjAADYCCCAAQgE3AhQgACAAQSBqNgIQIAEoAgAgASgCBCAAQQhq -EDggACgCLCICBEAgACgCMCACEMcBCyAAQdABaiQACw0AIABB+IPAACABEDgLDgAgAUHMiMAAQQUQ -twELDgAgAUGAkMAAQQUQtwELDgAgAUHckcAAQQ4QtwELDgAgAUG0lsAAQQUQtwELDgAgAUGyssAA -QQsQtwELDQAgAEGkvMAAIAEQOAsNAEGYwMAAQRsQ3gEACw4AQbPAwABBzwAQ3gEACwkAIAAgARAl -AAsNACAAQdjCwAAgARA4CwwAIAAgASkCADcDAAsNACAAQZDHwAAgARA4Cw4AIAFBiMfAAEEFELcB -CxoAIAAgAUGQgMEAKAIAIgBB0gAgABsRAgAACw0AIABB5OjAACABEDgLCgAgAiAAIAEQNgsKACAA -IAElARADCw4AIAFBvLzAAEEIELcBCw4AIAFBxr7AAEEDELcBCwkAIABBADYCAAsIACAAJQEQAAsI -ACAAJQEQEgsIACAAJQEQIgsEAEEACwIACwuifw4AQYCAwAALlQIvaG9tZS9jb3lvdHRlNTA4Ly5y -dXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0 -bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3N0cmluZy5ycwAAEAB0AAAA6AEAABcAAAAv -aG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24t -bGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvY29yZS9zcmMvaXRlci90cmFp -dHMvaXRlcmF0b3IucnMAAACEABAAgQAAAMEHAAAJAEGggsAAC5UBAQAAAAEAAABhIHNlcXVlbmNl -L2hvbWUvY295b3R0ZTUwOC8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5 -Y2Y4YzZiNWI1NTdmL3NlcmRlLTEuMC4yMTkvc3JjL2RlL2ltcGxzLnJzAAAAMgEQAGMAAACVBAAA -IgAAADIBEABjAAAAmAQAABwAQcCDwAALBQEAAAACAEHQg8AACwUBAAAAAwBB4IPAAAuFAQEAAAAE -AAAAAAAQAHQAAAB9BQAAGwAAAAUAAAAMAAAABAAAAAYAAAAHAAAACAAAAGNhbGxlZCBgT3B0aW9u -Ojp1bndyYXBfdGhyb3coKWAgb24gYSBgTm9uZWAgdmFsdWVoYXNobGVuZ3RoIDogCgABAAAAAAAA -AEsCEAADAAAATgIQAAEAQfCEwAALwQkBAAAADgAAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAg -b24gYW4gYEVycmAgdmFsdWUvaG9tZS9jb3lvdHRlNTA4L2NvZGUvaHVnZ2luZ2ZhY2UuanMvcGFj -a2FnZXMvaHViL3hldC1jb3JlLXdhc20tYnVpbGQvbWVya2xlaGFzaC9zcmMvYWdncmVnYXRlZF9o -YXNoZXMucnOjAhAAaQAAAD0AAAAqAAAAowIQAGkAAAA4AAAAHgAAAC9ob21lL2NveW90dGU1MDgv -LnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS14ODZfNjQtdW5rbm93bi1saW51eC1nbnUvbGliL3J1 -c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvdmVjL3NwZWNfZnJvbV9pdGVyX25lc3Rl -ZC5ycwAsAxAAhwAAABMAAAAFAAAAL2hvbWUvY295b3R0ZTUwOC8ucnVzdHVwL3Rvb2xjaGFpbnMv -c3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJy -YXJ5L3N0ZC9zcmMvdGhyZWFkL2xvY2FsLnJzxAMQAHgAAAAVAQAAGQAAAEVycm9yL2hvbWUvY295 -b3R0ZTUwOC8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdu -dS9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2FsbG9jL3NyYy9zdHJpbmcucnMAAABRBBAA -dAAAAH0FAAAbAAAAaW52YWxpZCB2YWx1ZTogLCBleHBlY3RlZCAAANgEEAAPAAAA5wQQAAsAAABt -aXNzaW5nIGZpZWxkIGBgBAUQAA8AAAATBRAAAQAAAGR1cGxpY2F0ZSBmaWVsZCBgAAAAJAUQABEA -AAATBRAAAQAAAA8AAAAMAAAABAAAABAAAAARAAAACAAAAC9ob21lL2NveW90dGU1MDgvLnJ1c3R1 +IABBBGohACAmQiCIISUgBUEBayIFDQALCyACICZCgICAgBBUDQAaIAJBKEYNESABQaQBaiACQQJ0 +aiAlPgIAIAJBAWoLNgLEAiABIAYEfyAGQQFrQf////8DcSIAQQFqIgJBA3EhBQJAIABBA0kEQCAB +QcgCaiEAQgAhJQwBCyACQfz///8HcSEKIAFByAJqIQBCACElA0AgACAANQIAQgp+ICV8IiU+AgAg +AEEEaiICIAI1AgBCCn4gJUIgiHwiJT4CACAAQQhqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIABBDGoi +AiACNQIAQgp+ICVCIIh8IiY+AgAgJkIgiCElIABBEGohACAKQQRrIgoNAAsLIAUEQANAIAAgADUC +AEIKfiAlfCImPgIAIABBBGohACAmQiCIISUgBUEBayIFDQALCyAmQoCAgIAQVARAIAEgBjYC6AMM +AwsgBkEoRg0RIAFByAJqIAZBAnRqICU+AgAgBkEBagVBAAs2AugDDAELIA5BAWohDgsgAUGQBWoi +AiABQewDaiIAQaAB/AoAACABIAk2ArAGIAJBARAtIR0gASgCjAUhAiABQbQGaiIDIABBoAH8CgAA +IAEgAjYC1AcgA0ECEC0hHiABKAKMBSECIAFB2AdqIgMgAEGgAfwKAAAgASACNgL4CCADQQMQLSEf +AkACQAJAAkACQAJAIAEoAvgIIhIgASgCoAEiCSAJIBJJGyICQShNBEAgAUGMBWohICABQbAGaiEh +IAFB1AdqISIgASgCjAUhESABKAKwBiETIAEoAtQHIRlBACEGA0AgBiEKIAJBAnQhAAJ/AkACQAJA +A0AgAEUNASAAICJqIQMgAEEEayIAIAFqKAIAIgYgAygCACIDRg0ACyADIAZLDQEMAgsgAEUNAQsg +CSECQQAMAQsgAgRAQQEhCEEAIQkgAkEBRwRAIAJBPnEhDCABIgBB2AdqIQUDQCAAIAggACgCACIL +IAUoAgBBf3NqIgNqIgg2AgAgAEEEaiIGIAYoAgAiECAFQQRqKAIAQX9zaiIGIAMgC0kgAyAIS3Jq +IgM2AgAgBiAQSSADIAZJciEIIAVBCGohBSAAQQhqIQAgDCAJQQJqIglHDQALCyACQQFxBH8gASAJ +QQJ0IgBqIgMgAygCACIDIAAgH2ooAgBBf3NqIgAgCGoiBjYCACAAIANJIAAgBktyBSAIC0UNFgsg +ASACNgKgAUEICyELIBkgAiACIBlJGyIGQSlPDQMgBkECdCEAAkACQAJAA0AgAEUNASAAICFqIQMg +AEEEayIAIAFqKAIAIgkgAygCACIDRg0ACyADIAlNDQEgAiEGDAILIABFDQAgAiEGDAELIAYEQEEB +IQhBACEJIAZBAUcEQCAGQT5xIQwgASIAQbQGaiEFA0AgACAIIAAoAgAiECAFKAIAQX9zaiICaiII +NgIAIABBBGoiAyADKAIAIhQgBUEEaigCAEF/c2oiAyACIBBJIAIgCEtyaiICNgIAIAMgFEkgAiAD +SXIhCCAFQQhqIQUgAEEIaiEAIAwgCUECaiIJRw0ACwsgBkEBcQR/IAEgCUECdCIAaiICIAIoAgAi +AiAAIB5qKAIAQX9zaiIAIAhqIgM2AgAgACACSSAAIANLcgUgCAtFDRYLIAEgBjYCoAEgC0EEciEL +CyATIAYgBiATSRsiA0EpTw0EIANBAnQhAAJAAkACQANAIABFDQEgACAgaiECIABBBGsiACABaigC +ACIJIAIoAgAiAkYNAAsgAiAJTQ0BIAYhAwwCCyAARQ0AIAYhAwwBCyADBEBBASEIQQAhCSADQQFH +BEAgA0E+cSEMIAEiAEGQBWohBQNAIAAgCCAAKAIAIhAgBSgCAEF/c2oiAmoiCDYCACAAQQRqIgYg +BigCACIUIAVBBGooAgBBf3NqIgYgAiAQSSACIAhLcmoiAjYCACAGIBRJIAIgBklyIQggBUEIaiEF +IABBCGohACAMIAlBAmoiCUcNAAsLIANBAXEEfyABIAlBAnQiAGoiAiACKAIAIgIgACAdaigCAEF/ +c2oiACAIaiIGNgIAIAAgAkkgACAGS3IFIAgLRQ0WCyABIAM2AqABIAtBAmohCwsgESADIAMgEUkb +IgJBKU8NEyACQQJ0IQACQAJAAkADQCAARQ0BIABBBGsiACABaigCACIGIAAgAUHsA2pqKAIAIglG +DQALIAYgCU8NASADIQIMAgsgAEUNACADIQIMAQsgAgRAQQEhCEEAIQkgAkEBRwRAIAJBPnEhDCAB +IgBB7ANqIQUDQCAAIAggACgCACIQIAUoAgBBf3NqIgNqIgg2AgAgAEEEaiIGIAYoAgAiFCAFQQRq +KAIAQX9zaiIGIAMgEEkgAyAIS3JqIgM2AgAgBiAUSSADIAZJciEIIAVBCGohBSAAQQhqIQAgDCAJ +QQJqIglHDQALCyACQQFxBH8gASAJQQJ0IgBqIgMgAygCACIDIAFB7ANqIABqKAIAQX9zaiIAIAhq +IgY2AgAgACADSSAAIAZLcgUgCAtFDRYLIAEgAjYCoAEgC0EBaiELCyAKQRFGDQYgCiANaiALQTBq +OgAAIAEoAsQCIgwgAiACIAxJGyIAQSlPDRUgCkEBaiEGIABBAnQhAAJ/AkADQCAARQ0BIABBBGsi +ACABaigCACIDIAAgAUGkAWpqKAIAIglGDQALIAMgCUsgAyAJSWsMAQtBf0EAIAAbCyEUIAFB/Ahq +IAFBoAH8CgAAIAEgAjYCnAogASgC6AMiCyACIAIgC0kbIgNBKEsNBQJAIANFBEBBACEDDAELQQAh +CEEAIQkgA0EBRwRAIANBPnEhIyABQfwIaiEAIAFByAJqIQUDQCAAIAggACgCACIkIAUoAgBqIhBq +IhU2AgAgAEEEaiIIIAgoAgAiFiAFQQRqKAIAaiIIIBAgJEkgECAVS3JqIhA2AgAgCCAWSSAIIBBL +ciEIIAVBCGohBSAAQQhqIQAgIyAJQQJqIglHDQALCyADQQFxBH8gCUECdCIAIAFB/AhqaiIJIAko +AgAiCSABQcgCaiAAaigCAGoiACAIaiIFNgIAIAAgCUkgACAFS3IFIAgLRQ0AIANBKEYNFyABQfwI +aiADQQJ0akEBNgIAIANBAWohAwsgASADNgKcCiADIBEgAyARSxsiAEEpTw0VIABBAnQhAAJ/AkAD +QCAARQ0BIABBBGsiACABQewDamooAgAiAyAAIAFB/AhqaigCACIJRg0ACyADIAlLIAMgCUlrDAEL +QX9BACAAGwsgGE4iACAUIBhIIgNFcUUEQCAADRMgAw0DDBILQQAhAyABAn9BACACRQ0AGiACQQFr +Qf////8DcSIAQQFqIgpBA3EhBQJAIABBA0kEQCABIQBCACElDAELIApB/P///wdxIQogASEAQgAh +JQNAIAAgADUCAEIKfiAlfCIlPgIAIABBBGoiCSAJNQIAQgp+ICVCIIh8IiU+AgAgAEEIaiIJIAk1 +AgBCCn4gJUIgiHwiJT4CACAAQQxqIgkgCTUCAEIKfiAlQiCIfCImPgIAICZCIIghJSAAQRBqIQAg +CkEEayIKDQALCyAFBEADQCAAIAA1AgBCCn4gJXwiJj4CACAAQQRqIQAgJkIgiCElIAVBAWsiBQ0A +CwsgAiAmQoCAgIAQVA0AGiACQShGDRcgASACQQJ0aiAlPgIAIAJBAWoLIgk2AqABAkAgDEUNACAM +QQFrQf////8DcSIAQQFqIgJBA3EhBQJAIABBA0kEQCABQaQBaiEAQgAhJQwBCyACQfz///8HcSEK +IAFBpAFqIQBCACElA0AgACAANQIAQgp+ICV8IiU+AgAgAEEEaiICIAI1AgBCCn4gJUIgiHwiJT4C +ACAAQQhqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIABBDGoiAiACNQIAQgp+ICVCIIh8IiY+AgAgJkIg +iCElIABBEGohACAKQQRrIgoNAAsLIAUEQANAIAAgADUCAEIKfiAlfCImPgIAIABBBGohACAmQiCI +ISUgBUEBayIFDQALCyAmQoCAgIAQVARAIAwhAwwBCyAMQShGDRcgAUGkAWogDEECdGogJT4CACAM +QQFqIQMLIAEgAzYCxAICQCALRQRAQQAhCwwBCyALQQFrQf////8DcSIAQQFqIgJBA3EhBQJAIABB +A0kEQCABQcgCaiEAQgAhJQwBCyACQfz///8HcSEKIAFByAJqIQBCACElA0AgACAANQIAQgp+ICV8 +IiU+AgAgAEEEaiICIAI1AgBCCn4gJUIgiHwiJT4CACAAQQhqIgIgAjUCAEIKfiAlQiCIfCIlPgIA +IABBDGoiAiACNQIAQgp+ICVCIIh8IiY+AgAgJkIgiCElIABBEGohACAKQQRrIgoNAAsLIAUEQANA +IAAgADUCAEIKfiAlfCImPgIAIABBBGohACAmQiCIISUgBUEBayIFDQALCyAmQoCAgIAQVA0AIAtB +KEYNFyABQcgCaiALQQJ0aiAlPgIAIAtBAWohCwsgASALNgLoAyASIAkgCSASSRsiAkEoTQ0ACwsM +EQsgAUEBEC0aIAEoAowFIgAgASgCoAEiAiAAIAJLGyIAQSlPDQQgAEECdCEAIAFBBGshAiABQegD +aiEDA0AgAEUNDiAAIANqIQkgACACaiAAQQRrIQAoAgAiDCAJKAIAIglGDQALIAkgDE0NDgwPCyAG +QShB3PvAABDRAQALIANBKEHc+8AAENEBAAsgA0EoQdz7wAAQ0QEAC0ERQRFBxNTAABB/AAsMDQsM +DQsMCwsMCwtB9NTAAEE3QazVwAAQlAEAC0G81cAAQTZB9NXAABCUAQALQdjTwABBHEH008AAEJQB +AAtBqNPAAEEdQcjTwAAQlAEAC0H70sAAQRxBmNPAABCUAQALIAANAQsgBiANaiECIAohAEF/IQUC +QANAIABBf0YNASAFQQFqIQUgACANaiAAQQFrIQAtAABBOUYNAAsgACANaiICQQFqIgMgAy0AAEEB +ajoAACAFRSAAQQJqIApLcg0BIAJBAmpBMCAF/AsADAELIA1BMToAACAKBEAgDUEBakEwIAr8CwAL +IAZBEUkEQCACQTA6AAAgDkEBaiEOIApBAmohBgwBCyAGQRFB1NTAABB/AAsgBkERTQRAIA8gDjsB +CCAPIAY2AgQgDyANNgIAIAFBoApqJAAMBQsgBkERQeTUwAAQ0QEACyACQShB3PvAABDRAQALQez7 +wABBGkHc+8AAEJQBAAsgAEEoQdz7wAAQ0QEAC0EoQShB3PvAABB/AAsLIAcgBygCUCAHKAJUIAcv +AVhBACAHQSBqEFAgBygCBCEAIAcoAgAMAQsgB0ECOwEgIAdBATYCKCAHQevmwAA2AiQgB0Egagsh +ASAHIAA2AlwgByABNgJYIAcgGzYCVCAHIBc2AlAgB0HQAGoQPyAHQYABaiQADwsCfyABIQwgAkEA +RyECIAEvAQ4hEUEAIQEjAEHwCGsiByQAID+9IScCf0EDID+ZRAAAAAAAAPB/YQ0AGkECICdCgICA +gICAgPj/AIMiJkKAgICAgICA+P8AUQ0AGiAnQv////////8HgyIpQoCAgICAgIAIhCAnQgGGQv7/ +//////8PgyAnQjSIp0H/D3EiABsiJUIBgyEoICZQBEBBBCApUA0BGiAAQbMIayEBQgEhJiAoUAwB +C0KAgICAgICAICAlQgGGICVCgICAgICAgAhRIgEbISVCAkIBIAEbISZBy3dBzHcgARsgAGohASAo +UAshACAHIAE7AegIIAcgJjcD4AggB0IBNwPYCCAHICU3A9AIIAcgADoA6ggCQAJ/AkACQAJAAkAg +AEECayIDBEBBASEAQePmwABB5ObAACAnQgBTIgYbQePmwABBASAGGyACGyEbICdCP4inIAJyIR1B +AyADIANBA08bQQJrDgICAwELIAdBAzYCmAggB0Hl5sAANgKUCCAHQQI7AZAIQQEhG0EBIQAgB0GQ +CGoMBAsgB0EDNgKYCCAHQejmwAA2ApQIIAdBAjsBkAggB0GQCGoMAwtBAiEAIAdBAjsBkAggEUUN +ASAHIBE2AqAIIAdBADsBnAggB0ECNgKYCCAHQeHmwAA2ApQIIAdBkAhqDAILQXRBBSABwSIAQQBI +GyAAbCIAQcD9AEkEQCAHQZAIaiEEIAdBEGohBSAAQQR2QRVqIgohAUGAgH5BACARayARwUEASBsh +CQJAAkACfwJAAkACQAJAIAdB0AhqIgApAwAiJVBFBEAgJUKAgICAgICAgCBaDQEgAUUNAkGgfyAA +LwEYIgBBIGsgACAlQoCAgIAQVCIAGyICQRBrIAIgJUIghiAlIAAbIiVCgICAgICAwABUIgAbIgJB +CGsgAiAlQhCGICUgABsiJUKAgICAgICAgAFUIgAbIgJBBGsgAiAlQgiGICUgABsiJUKAgICAgICA +gBBUIgAbIgJBAmsgAiAlQgSGICUgABsiJUKAgICAgICAgMAAVCIAGyAlQgKGICUgABsiJUIAWWsi +A2vBQdAAbEGwpwVqQc4QbSIAQdEATw0DIABBBHQiAkGo18AAaikDACImQv////8PgyInICUgJUJ/ +hUI/iIYiJUIgiCIofiIpQiCIICZCIIgiJiAofnwgJiAlQv////8PgyIlfiImQiCIfCApQv////8P +gyAlICd+QiCIfCAmQv////8Pg3xCgICAgAh8QiCIfCIlQUAgAyACQbDXwABqLwEAamsiC0E/ca0i +J4inIQAgAkGy18AAai8BACECICVCASAnhiIoQgF9IimDIiZQBEAgAUEKSw0HIAFBAnRBvOTAAGoo +AgAgAEsNBwsgAEGQzgBPBEAgAEHAhD1JDQUgAEGAwtcvTwRAQQhBCSAAQYCU69wDSSIDGyEGQYDC +1y9BgJTr3AMgAxsMBwtBBkEHIABBgK3iBEkiAxshBkHAhD1BgK3iBCADGwwGCyAAQeQATwRAQQJB +AyAAQegHSSIDGyEGQeQAQegHIAMbDAYLQQpBASAAQQlLIgYbDAULQfvSwABBHEHs48AAEJQBAAtB +/OPAAEEkQaDkwAAQlAEAC0HI48AAQSFBsOTAABCUAQALIABB0QBB6OHAABB/AAtBBEEFIABBoI0G +SSIDGyEGQZDOAEGgjQYgAxsLIQMCQAJAAkACQCAGIAJrQQFqwSIIIAnBIgJKBEAgC0H//wNxIQ4g +CCAJa8EgASAIIAJrIAFJGyILQQFrIQ9BACECA0AgACADbiENIAEgAkYNAyAAIAMgDWxrIQAgAiAF +aiANQTBqOgAAIAIgD0YNBCACIAZGDQIgAkEBaiECIANBCkkgA0EKbiEDRQ0AC0Ho5MAAEJoBAAsg +BCAFIAFBACAIIAkgJUIKgCADrSAnhiAoEEUMBQsgAkEBaiECIA5BAWtBP3GtISpCASElA0AgJSAq +iFBFBEAgBEEANgIADAYLIAEgAk0NAyACIAVqICZCCn4iJiAniKdBMGo6AAAgJUIKfiElICYgKYMh +JiALIAJBAWoiAkcNAAsgBCAFIAEgCyAIIAkgJiAoICUQRQwECyABIAFB+OTAABB/AAsgBCAFIAEg +CyAIIAkgAK0gJ4YgJnwgA60gJ4YgKBBFDAILIAIgAUGI5cAAEH8ACyAEQQA2AgALIAnBIRgCQCAH +KAKQCARAIAdByAhqIAdBmAhqKAIANgIAIAcgBykCkAg3A8AIDAELIAdBwAhqIRIgB0EQaiEJIwBB +wAZrIgUkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAHQdAIaiIAKQMAIiVQRQRAIAApAwgiJlAN +ASAAKQMQIidQDQIgJSAnfCAlVA0DICUgJlQNBCAALgEYIQAgBSAlPgIMIAVBAUECICVCgICAgBBU +IgEbNgKsASAFQQAgJUIgiKcgARs2AhAgBUEUakEAQZgB/AsAIAVBtAFqQQBBnAH8CwAgBUEBNgKw +ASAFQQE2AtACIACsICVCAX15fULCmsHoBH5CgKHNoLQCfEIgiKciAcEhDQJAIABBAE4EQCAFQQxq +IAAQLRoMAQsgBUGwAWpBACAAa8EQLRoLAkAgDUEASARAIAVBDGpBACANa0H//wNxECsMAQsgBUGw +AWogAUH//wFxECsLIAUoAtACIQsgBUGcBWogBUGwAWpBoAH8CgAAIAUgCzYCvAYgCiIGQQpPBEAg +BUGUBWohAgNAIAUoArwGIgRBKU8NCgJAIARFDQAgBEH/////A2ohACAEQQJ0IQECfyAEQQFGBEBC +ACElIAVBnAVqIAFqDAELIAEgAmohBCAAQf////8DcUEBakH+////B3EhA0IAISUDQCAEQQRqIgEg +ATUCACAlQiCGhCIlQoCU69wDgCImPgIAIAQgBDUCACAlICZCgJTr3AN+fUIghoQiJUKAlOvcA4Ai +Jj4CACAlICZCgJTr3AN+fSElIARBCGshBCADQQJrIgMNAAsgJUIghiElIARBCGoLIABBAXENAEEE +ayIAICUgADUCAIRCgJTr3AOAPgIACyAGQQlrIgZBCUsNAAsLIAZBAnRBwOTAAGooAgBBAXQiAkUN +BSAFKAK8BiIEQSlPDQggBAR/IARB/////wNqIQAgBEECdCEBIAKtISUCfyAEQQFGBEBCACEmIAVB +nAVqIAFqDAELIAEgBWpBlAVqIQQgAEH/////A3FBAWpB/v///wdxIQNCACEmA0AgBEEEaiIBIAE1 +AgAgJkIghoQiJiAlgCInPgIAIAQgBDUCACAmICUgJ359QiCGhCImICWAIic+AgAgJiAlICd+fSEm +IARBCGshBCADQQJrIgMNAAsgJkIghiEmIARBCGoLIQEgAEEBcUUEQCABQQRrIgAgJiAANQIAhCAl +gD4CAAsgBSgCvAYFQQALIQECQAJAAkAgBSgCrAEiACABIAAgAUsbIgFBKE0EQCABRQRAQQAhAQwE +CyABQQFxIQ4gAUEBRw0BQQAhBkEAIQgMAgsMFAsgAUE+cSEPQQAhBiAFQZwFaiEEIAVBDGohA0EA +IQgDQCAEIAQoAgAiFyADKAIAaiICIAZBAXFqIhM2AgAgBEEEaiIGIAYoAgAiGSADQQRqKAIAaiIG +IAIgF0kgAiATS3JqIgI2AgAgBiAZSSACIAZJciEGIANBCGohAyAEQQhqIQQgDyAIQQJqIghHDQAL +CyAOBH8gCEECdCICIAVBnAVqaiIDIAMoAgAiAyAFQQxqIAJqKAIAaiICIAZqIgY2AgAgAiADSSAC +IAZLcgUgBgtBAXFFDQAgAUEoRg0KIAVBnAVqIAFBAnRqQQE2AgAgAUEBaiEBCyAFIAE2ArwGIAsg +ASABIAtJGyIEQSlPDQggBEECdCEEAkACQANAIARFDQEgBEEEayIEIAVBnAVqaigCACIBIAQgBUGw +AWpqKAIAIgJGDQALIAEgAk8NAQwICyAEDQcLIA1BAWohDQwHC0H70sAAQRxBhNbAABCUAQALQajT +wABBHUGU1sAAEJQBAAtB2NPAAEEcQaTWwAAQlAEAC0G81cAAQTZBlNfAABCUAQALQfTUwABBN0GE +18AAEJQBAAtBo/zAAEEbQdz7wAAQlAEACyAARQRAQQAhACAFQQA2AqwBDAELIABBAWtB/////wNx +IgFBAWoiAkEDcSEDAkAgAUEDSQRAIAVBDGohBEIAISUMAQsgAkH8////B3EhASAFQQxqIQRCACEl +A0AgBCAENQIAQgp+ICV8IiU+AgAgBEEEaiICIAI1AgBCCn4gJUIgiHwiJT4CACAEQQhqIgIgAjUC +AEIKfiAlQiCIfCIlPgIAIARBDGoiAiACNQIAQgp+ICVCIIh8IiY+AgAgJkIgiCElIARBEGohBCAB +QQRrIgENAAsLIAMEQANAIAQgBDUCAEIKfiAlfCImPgIAIARBBGohBCAmQiCIISUgA0EBayIDDQAL +CyAmQoCAgIAQWgRAIABBKEYNAyAFQQxqIABBAnRqICU+AgAgAEEBaiEACyAFIAA2AqwBC0EAIQYC +QAJAAkACQCANwSIBIBjBIgJIIh5FBEAgDSAYa8EgCiABIAJrIApJGyIIDQELQQAhCAwBCyAFQdQC +aiIBIAVBsAFqIgBBoAH8CgAAIAUgCzYC9ANBASEXIAFBARAtIR8gBSgC0AIhASAFQfgDaiICIABB +oAH8CgAAIAUgATYCmAUgAkECEC0hICAFKALQAiEBIAVBnAVqIgIgAEGgAfwKAAAgBSABNgK8BiAF +QawBaiEhIAVB0AJqISIgBUH0A2ohFCAFQZgFaiEjQQAhDiACQQMQLSEkIAUoAqwBIQAgBSgC0AIh +CyAFKAL0AyETIAUoApgFIRkgBSgCvAYhEAJAAkACQAJAA0AgAEEpTw0KIABBAnQhAUEAIQQCfwJA +AkADQCABIARGDQEgBUEMaiAEaiAEQQRqIQQoAgBFDQALIBAgACAAIBBJGyIBQSlPDRQgAUECdCEE +AkADQCAERQ0BIAQgI2ohAiAEQQRrIgQgBUEMamooAgAiAyACKAIAIgJGDQALIAIgA00NAkEADAML +IARFDQFBAAwCCyAIIApLDQQgCCAORg0IIAggDmsiAEUNCCAJIA5qQTAgAPwLAAwIC0EBIQZBACEA +IAFBAUcEQCABQT5xIQ8gBUEMaiEEIAVBnAVqIQMDQCAEIAQoAgAiFSADKAIAQX9zaiICIAZBAXFq +IhY2AgAgBEEEaiIGIAYoAgAiGiADQQRqKAIAQX9zaiIGIAIgFUkgAiAWS3JqIgI2AgAgBiAaSSAC +IAZJciEGIANBCGohAyAEQQhqIQQgDyAAQQJqIgBHDQALCyABQQFxBH8gAEECdCIAIAVBDGpqIgIg +AigCACICIAAgJGooAgBBf3NqIgAgBmoiAzYCACAAIAJJIAAgA0tyBSAGC0EBcUUNDCAFIAE2AqwB +IAEhAEEICyEPIBkgACAAIBlJGyICQSlPDQMgAkECdCEEAkACQAJAA0AgBEUNASAEIBRqIQEgBEEE +ayIEIAVBDGpqKAIAIgMgASgCACIBRg0ACyABIANNDQEgACECDAILIARFDQAgACECDAELIAIEQEEB +IQZBACEAIAJBAUcEQCACQT5xIRUgBUEMaiEEIAVB+ANqIQMDQCAEIAQoAgAiFiADKAIAQX9zaiIB +IAZBAXFqIho2AgAgBEEEaiIGIAYoAgAiHCADQQRqKAIAQX9zaiIGIAEgFkkgASAaS3JqIgE2AgAg +BiAcSSABIAZJciEGIANBCGohAyAEQQhqIQQgFSAAQQJqIgBHDQALCyACQQFxBH8gAEECdCIAIAVB +DGpqIgEgASgCACIBIAAgIGooAgBBf3NqIgAgBmoiAzYCACAAIAFJIAAgA0tyBSAGC0EBcUUNDQsg +BSACNgKsASAPQQRyIQ8LIBMgAiACIBNJGyIBQSlPDQQgAUECdCEEAkACQAJAA0AgBEUNASAEICJq +IQAgBEEEayIEIAVBDGpqKAIAIgMgACgCACIARg0ACyAAIANNDQEgAiEBDAILIARFDQAgAiEBDAEL +IAEEQEEBIQZBACEAIAFBAUcEQCABQT5xIRUgBUEMaiEEIAVB1AJqIQMDQCAEIAQoAgAiFiADKAIA +QX9zaiICIAZBAXFqIho2AgAgBEEEaiIGIAYoAgAiHCADQQRqKAIAQX9zaiIGIAIgFkkgAiAaS3Jq +IgI2AgAgBiAcSSACIAZJciEGIANBCGohAyAEQQhqIQQgFSAAQQJqIgBHDQALCyABQQFxBH8gAEEC +dCIAIAVBDGpqIgIgAigCACICIAAgH2ooAgBBf3NqIgAgBmoiAzYCACAAIAJJIAAgA0tyBSAGC0EB +cUUNDQsgBSABNgKsASAPQQJqIQ8LIAsgASABIAtJGyIAQSlPDQogAEECdCEEAkACQAJAA0AgBEUN +ASAEICFqIQIgBEEEayIEIAVBDGpqKAIAIgMgAigCACICRg0ACyACIANNDQEgASEADAILIARFDQAg +ASEADAELIAAEQEEBIQZBACEBIABBAUcEQCAAQT5xIRUgBUEMaiEEIAVBsAFqIQMDQCAEIAQoAgAi +FiADKAIAQX9zaiICIAZBAXFqIho2AgAgBEEEaiIGIAYoAgAiHCADQQRqKAIAQX9zaiIGIAIgFkkg +AiAaS3JqIgI2AgAgBiAcSSACIAZJciEGIANBCGohAyAEQQhqIQQgFSABQQJqIgFHDQALCyAAQQFx +BH8gAUECdCIBIAVBDGpqIgIgAigCACICIAVBsAFqIAFqKAIAQX9zaiIBIAZqIgM2AgAgASACSSAB +IANLcgUgBgtBAXFFDQ0LIAUgADYCrAEgD0EBaiEPCyAKIA5NDQEgCSAOaiAPQTBqOgAAIABBKU8N +CgJAIABFBEBBACEADAELIABBAWtB/////wNxIgFBAWoiAkEDcSEDAkAgAUEDSQRAIAVBDGohBEIA +ISYMAQsgAkH8////B3EhASAFQQxqIQRCACEmA0AgBCAENQIAQgp+ICZ8IiU+AgAgBEEEaiICIAI1 +AgBCCn4gJUIgiHwiJT4CACAEQQhqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIARBDGoiAiACNQIAQgp+ +ICVCIIh8IiU+AgAgJUIgiCEmIARBEGohBCABQQRrIgENAAsLIAMEQANAIAQgBDUCAEIKfiAmfCIl +PgIAIARBBGohBCAlQiCIISYgA0EBayIDDQALCyAlQoCAgIAQVA0AIABBKEYNCiAFQQxqIABBAnRq +ICY+AgAgAEEBaiEACyAFIAA2AqwBIA5BAWohDiAXIAggF0siAWohFyABDQALQQEhBgwECyAOIApB +5NbAABB/AAsgCCAKQfTWwAAQ0QEACyACQShB3PvAABDRAQALDAwLAkACQAJAIAtBKUkEQAJAIAtF +BEBBACELDAELIAtBAWtB/////wNxIgFBAWoiAkEDcSEDAkAgAUEDSQRAIAVBsAFqIQRCACElDAEL +IAJB/P///wdxIQEgBUGwAWohBEIAISUDQCAEIAQ1AgBCBX4gJXwiJT4CACAEQQRqIgIgAjUCAEIF +fiAlQiCIfCIlPgIAIARBCGoiAiACNQIAQgV+ICVCIIh8IiU+AgAgBEEMaiICIAI1AgBCBX4gJUIg +iHwiJj4CACAmQiCIISUgBEEQaiEEIAFBBGsiAQ0ACwsgAwRAA0AgBCAENQIAQgV+ICV8IiY+AgAg +BEEEaiEEICZCIIghJSADQQFrIgMNAAsLICZCgICAgBBUDQAgC0EoRg0IIAVBsAFqIAtBAnRqICU+ +AgAgC0EBaiELCyAFIAs2AtACIAsgACAAIAtJGyIEQSlPDQYgBEECdCEEIAVBCGohACAFQawBaiEB +AkACQANAIARFDQEgASAEaiECIAAgBGogBEEEayEEKAIAIgMgAigCACICRg0ACyACIANPDQUMAQsg +BiAERXFFDQQgCEEBayIAIApPDQIgACAJai0AAEEBcUUNBAsgCCAKSw0CIAggCWpBACEEIAkhAwJA +A0AgBCAIRg0BIARBAWohBCADQQFrIgMgCGoiAC0AAEE5Rg0ACyAAIAAtAABBAWo6AAAgCCAEa0EB +aiAITw0EIARBAWsiAUUNBCAAQQFqQTAgAfwLAAwECwJAIAhFBEBBMSEEDAELIAlBMToAACAIQQFG +BEBBMCEEDAELQTAhBCAIQQFrIgBFDQAgCUEBakEwIAD8CwALIA1BAWohDSAeIAggCk9yDQMgBDoA +ACAIQQFqIQgMAwsgC0EoQdz7wAAQ0QEACyAAIApBtNbAABB/AAsgCCAKQcTWwAAQ0QEACyAIIApL +DQELIBIgDTsBCCASIAg2AgQgEiAJNgIAIAVBwAZqJAAMBQsgCCAKQdTWwAAQ0QEACyAEQShB3PvA +ABDRAQALQShBKEHc+8AAEH8ACyAAQShB3PvAABDRAQALQez7wABBGkHc+8AAEJQBAAsLIBggBy4B +yAgiAEgEQCAHQQhqIAcoAsAIIAcoAsQIIAAgESAHQZAIahBQIAcoAgwhACAHKAIIDAMLQQIhACAH +QQI7AZAIIBFFBEBBASEAIAdBATYCmAggB0Hr5sAANgKUCCAHQZAIagwDCyAHIBE2AqAIIAdBADsB +nAggB0ECNgKYCCAHQeHmwAA2ApQIIAdBkAhqDAILQezmwABBJUGU58AAEJQBAAtBASEAIAdBATYC +mAggB0Hr5sAANgKUCCAHQZAIagshASAHIAA2AswIIAcgATYCyAggByAdNgLECCAHIBs2AsAIIAwg +B0HACGoQPyAHQfAIaiQADAELIAFBKEHc+8AAENEBAAsLQgEBfyMAQSBrIgMkACADQQA2AhAgA0EB +NgIEIANCBDcCCCADIAE2AhwgAyAANgIYIAMgA0EYajYCACADIAIQnwEAC0ABAX8gASgCACIBIAEo +AggiBEEBajYCCCAEQQBIBEAACyAAIAE2AgwgACADNgIIIAAgAjYCBCAAQey1wAA2AgALPAAgACAB +KQAANwAAIABBGGogAUEYaikAADcAACAAQRBqIAFBEGopAAA3AAAgAEEIaiABQQhqKQAANwAAC5QC +AQN/IAAoAgAhAiABKAIIIgBBgICAEHFFBEAgAEGAgIAgcUUEQCACIAEQ0wEPC0EAIQAjAEGAAWsi +BCQAIAIoAgAhAgNAIAAgBGpB/wBqIAJBD3EiA0EwciADQTdqIANBCkkbOgAAIABBAWshACACQQ9L +IAJBBHYhAg0ACyABQQFBpurAAEECIAAgBGpBgAFqQQAgAGsQNiAEQYABaiQADwtBACEAIwBBgAFr +IgQkACACKAIAIQIDQCAAIARqQf8AaiACQQ9xIgNBMHIgA0HXAGogA0EKSRs6AAAgAEEBayEAIAJB +D0sgAkEEdiECDQALIAFBAUGm6sAAQQIgACAEakGAAWpBACAAaxA2IARBgAFqJAALOAACQCACQYCA +xABGDQAgACACIAEoAhARAABFDQBBAQ8LIANFBEBBAA8LIAAgAyAEIAEoAgwRAQALLQACQCAAIAEQ +swFFDQAgAARAQeWAwQAtAAAaIAAgARDAASIBRQ0BCyABDwsACzcBAX8jAEEgayIBJAAgAUEANgIY +IAFBATYCDCABQdj8wAA2AgggAUIENwIQIAFBCGogABCfAQAL5RkCG38BfiMAQRBrIg0kACMAQSBr +IgkkACMAQSBrIgQkACABrUIMfiIdpyEDAkACQAJAAkAgHUIgiKcgA0H8////B0tyDQACfyADRQRA +QQQhBUEADAELQeWAwQAtAAAaQQQhAiADQQQQwAEiBUUNASABCyECIARBADYCHCAEIAU2AhggBCAC +NgIUIAEEQCABQQJ0IQpBCCECA0AgBEEIaiAAIAhqKAIAIgMQ6gEgBCgCCCIQRQ0DIAQoAgwhCyAD +QYQBTwRAIAMQbAsgBCgCFCAGRgRAIwBBIGsiAyQAQQQgBEEUaiIFKAIAIgxBAXQiByAHQQRNGyIP +rUIMfiIdQiCIUEUEQEEAQQBB3MHAABCyAQALAkAgHaciDkH8////B00EfyADIAwEfyADIAxBDGw2 +AhwgAyAFKAIENgIUQQQFQQALNgIYIANBCGpBBCAOIANBFGoQcyADKAIIQQFHDQEgAygCECEHIAMo +AgwFQQALIAdB3MHAABCyAQALIAMoAgwhByAFIA82AgAgBSAHNgIEIANBIGokACAEKAIYIQULIAIg +BWoiAyALNgIAIANBBGsgEDYCACADQQhrIAs2AgAgBCAGQQFqIgY2AhwgAkEMaiECIAogCEEEaiII +Rw0ACyAAIAFBAnQQzAELIAQoAhghAAJAIAYgBCgCFCIBTwRAIAAhAgwBCyABQQxsIQEgBkUEQEEE +IQIgACABEMwBDAELIAAgAUEEIAZBDGwiABC4ASICRQ0DCyAJIAY2AgQgCSACNgIAIARBIGokAAwD +CyACIANBvMHAABCyAQALQezBwABBKBDiAQALQQQgAEHMwcAAELIBAAsgCSAJKAIEIgA2AhAgCSAJ +KAIANgIMIAkgADYCCCAJQRRqIRAjAEEwayIEJAAgCUEIaiIBKAIAIQIgASgCBCEAIAEoAgghASAE +QQA6AC8gBCAAIAFBDGxqNgIMIAQgAjYCCCAEIAA2AgQgBCAANgIAIAQgBEEvajYCECAEQSBqIQUj +AEHgAGsiAiQAAkACQAJAAkACQCAEKAIEIgEgBCgCDCIGRgRAIAEhAAwBCyAEKAIQIQwgBCABQQxq +IgA2AgQgASgCACEDIAJBOGogASgCBCIHIAEoAggQNyADBEAgByADEMwBCyACKAI4QQFxRQ0BIAxB +AToAAAsgBUEANgIIIAVCgICAgIABNwIAIAYgAGtBDG4hASAAIAZHBEADQCAAKAIAIgMEQCAAQQRq +KAIAIAMQzAELIABBDGohACABQQFrIgENAAsLIAQoAggiAEUNASAEKAIAIABBDGwQzAEMAQsgAkEw +aiIDIAJB2ABqKQMANwMAIAJBKGoiByACQdAAaikDADcDACACQSBqIgggAkHIAGopAwA3AwAgAiAC +KQNANwMYQeWAwQAtAAAaQYABQQgQwAEiAUUNASABIAIpAxg3AwAgAUEYaiADKQMANwMAIAFBEGog +BykDADcDACABQQhqIAgpAwA3AwAgAkEBNgIUIAIgATYCECACQQQ2AgwgBCgCCCEKIAQoAgAhDwJA +IAAgBkYNACACQUBrIQhBICEHQQEhAwNAIAAoAgAhCyACQThqIABBBGooAgAiDiAAQQhqKAIAEDcg +CwRAIA4gCxDMAQsgAigCOEEBcQRAIAxBAToAACAAQQxqIQAMAgsgAkEwaiIOIAhBGGopAwA3AwAg +AkEoaiIRIAhBEGopAwA3AwAgAkEgaiITIAhBCGopAwA3AwAgAiAIKQMANwMYIAIoAgwgA0YEQCAC +QQxqIANBAUEIQSAQVyACKAIQIQELIAEgB2oiCyACKQMYNwMAIAtBGGogDikDADcDACALQRBqIBEp +AwA3AwAgC0EIaiATKQMANwMAIAIgA0EBaiIDNgIUIAdBIGohByAAQQxqIgAgBkcNAAsLIAYgAGtB +DG4hASAAIAZHBEADQCAAKAIAIgMEQCAAQQRqKAIAIAMQzAELIABBDGohACABQQFrIgENAAsLIAoE +QCAPIApBDGwQzAELIAUgAikCDDcCACAFQQhqIAJBFGooAgA2AgALIAJB4ABqJAAMAQtBCEGAAUGo +k8AAELIBAAsCQAJAAkACQAJAIAQtAC9BAUYEQCAEKAIgIgBFDQEgBCgCJCAAQQV0EMwBDAELIAQo +AiAiE0GAgICAeEcNAQsgBEEANgIoIARCgICAgBA3AiAgBEG0gsAANgIEIARCoICAgA43AgggBCAE +QSBqNgIAIAQQuQENAiAEKAIgIQAgBCgCJCIBIAQoAigQtQEhAiAABEAgASAAEMwBCyAQQYCAgIB4 +NgIAIBAgAjYCBAwBCyAEKAIkIhkhACAEKAIoIQEjAEHgAGsiCCQAIAhBADYCKCAIQQA2AhggCCAA +NgI4IAggACABQQV0ajYCPCAIQQxqIQtBACEBIwBBEGsiBiQAAkACQAJ/AkACQCAIQRhqIgUiACgC +ACIDBEAgACgCBCICIAAoAgxHDQEgACgCCCICBEAgAyACEMwBCyAAQQA2AgALIAAoAiAiA0UNASAD +IAAoAiRGDQEgACADQSBqNgIgQeWAwQAtAAAaQSBBARDAASICRQ0DIABBIDYCCCAAIAI2AgAgAiAD +KQAANwAAIAAgAkEgajYCDCACQRhqIANBGGopAAA3AAAgAkEQaiADQRBqKQAANwAAIAJBCGogA0EI +aikAADcAAAsgACACQQFqNgIEIAItAAAhAEEBDAELIAAoAhAiAwRAIAAoAhQiAiAAKAIcRwRAIAAg +AkEBajYCFCACLQAAIQBBAQwCCyAAKAIYIgIEQCADIAIQzAELIABBADYCEAtBAAshAiAGIAA6AAEg +BiACOgAADAELQQFBIEHkrcAAELIBAAsCQCAGLQAABEACQEEIQX8gBSgCDCIPIAUoAgQiDGsiAiAF +KAIcIhcgBSgCFCIAa0EAIAUoAhAiDhsiA2oiByACIAdLGyADIAUoAgAiAxtBAWoiAkF/IAIbIgIg +AkEITRsiAkEASA0AIAYtAAEhB0HlgMEALQAAGkEBIQEgAkEBEMABIgpFDQAgCiAHOgAAIAZBATYC +DCAGIAo2AgggBiACNgIEIAUoAiQhGiAFKAIgIQcgBSgCGCEYIAUoAgghEUEBIQUDQAJAAkACQAJ/ +AkAgA0UNACAMIAwgD0cNARogEUUNACADIBEQzAELIAdFIAcgGkZyDQFB5YDBAC0AABpBIEEBEMAB +IgNFDQIgAyAHKQAANwAAIANBGGogB0EYaikAADcAACADQRBqIAdBEGopAAA3AAAgA0EIaiAHQQhq +KQAANwAAQSAhESADQSBqIQ8gB0EgaiEHIAMLIgJBAWohDCAAIQEMAgsCQCAORQ0AIAAgF0cEQCAA +QQFqIQFBACEDIAAhAgwDCyAYRQ0AIA4gGBDMAQsgCyAGKQIENwIAIAtBCGogBkEMaigCADYCAAwF +C0EBQSBB5K3AABCyAQALIAItAAAhGyAGKAIEIAVGBEAgBkEEaiEKIwBBIGsiACQAAkACQCAFQX8g +DyAMayICIBcgAWtBACAOGyIUaiISIAIgEksbIBQgAxtBAWoiAkF/IAIbIAVqIgJLDQBBCCACIAoo +AgAiFEEBdCISIAIgEksbIgIgAkEITRsiEq0iHUIgiFBFDQAgHaciHEH/////B0sNACAAIBQEfyAA +IBQ2AhwgACAKKAIENgIUQQEFQQALNgIYIABBCGpBASAcIABBFGoQcyAAKAIIQQFHDQEgACgCECEC +IAAoAgwhFgsgFiACQaSwwAAQsgEACyAAKAIMIQIgCiASNgIAIAogAjYCBCAAQSBqJAAgBigCCCEK +CyAFIApqIBs6AAAgBiAFQQFqIgU2AgwgASEADAALAAsgASACQfiuwAAQsgEACyALQQA2AgggC0KA +gICAEDcCAAJAIAUoAgAiAEUNACAFKAIIIgFFDQAgACABEMwBCyAFKAIQIgBFDQAgBSgCGCIBRQ0A +IAAgARDMAQsgBkEQaiQAIAhBQGsiAEGIr8AAIAgoAhAiASAIKAIUEDQgBCAAEJYBIAgoAgwiAARA +IAEgABDMAQsgCEHgAGokACAQIAQQZCATRQ0AIBkgE0EFdBDMAQsgBEEwaiQADAELQdyCwABBNyAE +QS9qQcyCwABBiITAABB8AAsCQAJAIA0CfyAJKAIUIgJBgICAgHhGBEBBACEAIAkoAhghAUEBDAEL +IAkoAhghAQJAIAkoAhwiFSACTwRAIAEhAAwBCyAVRQRAQQEhACABIAIQzAEMAQsgASACQQEgFRC4 +ASIARQ0CC0EAIQFBAAs2AgwgDSABNgIIIA0gFTYCBCANIAA2AgAgCUEgaiQADAELQQEgFUHMh8AA +ELIBAAsgDSgCACANKAIEIA0oAgggDSgCDCANQRBqJAALpwwCF38BfiMAQRBrIgokACABIRAjAEHQ +AGsiAyQAAkACQAJAAkAgACILBEAgAEEIayIMIAwoAgBBAWoiADYCACAARQ0BIAsoAgANAiALQX82 +AgAgAyAMNgIUIAMgCzYCECADIAtBCGoiDzYCDCADQRhqIQkjAEGAAWsiACQAIABBADYCFCAAQoCA +gICAATcCDAJAAkAgAgRAIABByABqQQRyIQYDQCACIARJDQIgAEHIAGogDyAEIBBqIAIgBGtBABAy +IABBIGoiESAGQQhqKQIANwMAIABBKGoiEiAGQRBqKQIANwMAIABBMGoiEyAGQRhqKQIANwMAIABB +OGoiFCAGQSBqKQIANwMAIABBQGsiFSAGQShqKAIANgIAIAAgBikCADcDGCAAKAJ4IRYgACgCSCIX +BEAgACgCFCINIAAoAgxGBEAjAEEgayIBJABBBCAAQQxqIgcoAgAiDkEBdCIFIAVBBE0bIhitQjB+ +IhpCIIhQRQRAQQBBAEHImMAAELIBAAsCQCAapyIZQfj///8HTQRAIAEgDgR/IAEgDkEwbDYCHCAB +IAcoAgQ2AhRBCAVBAAs2AhggAUEIakEIIBkgAUEUahBzIAEoAghBAUcNASABKAIMIQggASgCECEF +CyAIIAVByJjAABCyAQALIAEoAgwhBSAHIBg2AgAgByAFNgIEIAFBIGokAAsgACgCECANQTBsaiIB +IAApAxg3AgQgASAXNgIAIAFBDGogESkDADcCACABQRRqIBIpAwA3AgAgAUEcaiATKQMANwIAIAFB +JGogFCkDADcCACABQSxqIBUoAgA2AgAgACANQQFqNgIUCyAEIBZqIgQgAkcNAAsLIAkgACkCDDcC +ACAJQQhqIABBFGooAgA2AgAgAEGAAWokAAwBCyAEIAJB2JjAABDQAQALQQQhBCADKAIcIQAgAygC +GCEFIAMoAiAiAQRAQeWAwQAtAAAaIAFBBHQiBkEEEMABIgRFDQQLIANBADYCLCADIAQ2AiggAyAB +NgIkIAMgACABQTBsajYCPCADIAU2AjggAyAANgI0IAMgADYCMCADIAQ2AkggA0EANgJEIAMgA0Es +ajYCQCADQUBrIQUjAEFAaiIEJAACQCADQTBqIggoAgQiACAIKAIMIg1GBEAgBSgCBCEGDAELIAUo +AgggBSgCBCIGQQR0aiEHIARBHGohDiAEQSBqIQkDQCAIIABBMGoiATYCBCAEQThqIABBKGopAwA3 +AwAgBEEwaiAAQSBqKQMANwMAIARBKGogAEEYaikDADcDACAJIABBEGopAwA3AwAgBEEYaiIPIABB +CGopAwA3AwAgBCAAKQMANwMQIAQgCRBkIAQgDygCACIANgIMIA4gBCgCFCAAIAQoAhAoAhARAwAg +B0EIaiAEQQhqKQIANwIAIAcgBCkCADcCACAFIAZBAWoiBjYCBCAHQRBqIQcgASIAIA1HDQALCyAF +KAIAIAY2AgAgCCgCCCIABEAgCCgCACAAQTBsEMwBCyAEQUBrJAAgAygCJCEJIAMoAighASADKAIs +IQQgA0EANgIkQQEhByAIIANBJGoQsQECQCADKAIwRQRAIAMoAjQhBQwBCyADQcgAaiADQThqKAIA +NgIAIAMgAykCMDcDQAJAIAQEQCAEQQR0IQcgA0FAa0EEciEIIAMoAkghBiABIQADQCADIAAgAygC +QBBhIAMoAgQhBSADKAIAQQFxDQIgCCAGIAUQzgEgAyAGQQFqIgY2AkggAEEQaiEAIAdBEGsiBw0A +CwtBACEHIAMoAkQhBQwBC0EBIQcgAygCRCIAQYQBSQ0AIAAQbAsgBARAIAEhAANAIAAoAgAiBgRA +IABBBGooAgAgBhDMAQsgAEEQaiEAIARBAWsiBA0ACwsgCQRAIAEgCUEEdBDMAQsgAgRAIBAgAhDM +AQsgC0EANgIAIAwgDCgCAEEBayIANgIAIABFBEAgA0EUahCRAQsgCiAHNgIIIAogBUEAIAcbNgIE +IApBACAFIAcbNgIAIANB0ABqJAAMBAsQ4AELAAsQ4QEAC0EEIAZBpILAABCyAQALIAooAgAgCigC +BCAKKAIIIApBEGokAAuaBgEIfyMAQRBrIgQkABBvIgIgACYBIwBBEGsiCCQAIAhBBGohAyMAQdAA +ayIBJAAgAUEMaiACEC8gASgCECECAkACQAJAIAEoAgwiBUGAgICAeEYEQCABIAI2AjwgAUEANgJI +IAFCgICAgBA3AkAgAUG0gsAANgIcIAFCoICAgA43AiAgASABQUBrNgIYIAFBPGogAUEYahCPAQ0C +IAEoAkAhAiABKAJEIgUgASgCSBC1ASEGIAIEQCAFIAIQzAELIAEoAjwiAkGEAU8EQCACEGwLIANB +gICAgHg2AgAgAyAGNgIEDAELIAEoAhQhBiABQQA6AAwgASACIAZBBHRqNgIkIAEgBTYCICABIAI2 +AhwgASACNgIYIAEgAUEMajYCKCABQUBrIAFBGGoQLAJAAkAgAS0ADEEBRgRAIAEoAkAiAkUNASAB +KAJEIAJBKGwQzAEMAQsgASgCQCICQYCAgIB4Rw0BCyABQQA2AkggAUKAgICAEDcCQCABQbSCwAA2 +AhwgAUKggICADjcCICABIAFBQGs2AhggAUEYahC5AQ0CIAEoAkAhAiABKAJEIgUgASgCSBC1ASEG +IAIEQCAFIAIQzAELIANBgICAgHg2AgAgAyAGNgIEDAELIAEoAkQhBQJAIAEoAkgiBkUEQCABQTBq +QgA3AwAgAUEoakIANwMAIAFBIGpCADcDACABQgA3AxgMAQsgAUEYaiAFIAYQMQsgAyABQRhqEGQg +AkUNACAFIAJBKGwQzAELIAFB0ABqJAAMAQtB3ILAAEE3IAFBzwBqQcyCwABBiITAABB8AAsCQAJA +IAQCfyAIKAIEIgJBgICAgHhGBEAgCCgCCCEBQQAhA0EBDAELIAgoAgghAQJAIAgoAgwiAyACTwRA +IAEhBwwBCyADRQRAQQEhByABIAIQzAEMAQsgASACQQEgAxC4ASIHRQ0CC0EAIQFBAAs2AgwgBCAB +NgIIIAQgAzYCBCAEIAc2AgAgCEEQaiQADAELQQEgA0HMh8AAELIBAAsgBCgCACAEKAIEIAQoAggg +BCgCDCAEQRBqJAALhwcBCn8jAEEQayIEJAAQbyICIAAmASMAQRBrIggkACAIQQRqIQUjAEHwAGsi +ASQAIAFBCGogAhAvIAEoAgwhAgJAAkACQCABKAIIIgNBgICAgHhGBEAgASACNgJoIAFBADYCMCAB +QoCAgIAQNwIoIAFBtILAADYCTCABQqCAgIAONwJQIAEgAUEoajYCSCABQegAaiABQcgAahCPAQ0C +IAEoAighAiABKAIsIgMgASgCMBC1ASEGIAIEQCADIAIQzAELIAEoAmgiAkGEAU8EQCACEGwLIAVB +gICAgHg2AgAgBSAGNgIEDAELIAEoAhAhBiABQQA6AAggASACIAZBBHRqNgJUIAEgAzYCUCABIAI2 +AkwgASACNgJIIAEgAUEIajYCWCABQShqIAFByABqECwCQAJAIAEtAAhBAUYEQCABKAIoIgJFDQEg +ASgCLCACQShsEMwBDAELIAEoAigiBkGAgICAeEcNAQsgAUEANgIwIAFCgICAgBA3AiggAUG0gsAA +NgJMIAFCoICAgA43AlAgASABQShqNgJIIAFByABqELkBDQIgASgCKCECIAEoAiwiAyABKAIwELUB +IQYgAgRAIAMgAhDMAQsgBUGAgICAeDYCACAFIAY2AgQMAQsgASgCLCEJAkAgASgCMCICRQRAIAFB +IGpCADcDACABQRhqQgA3AwAgAUEQakIANwMAIAFCADcDCAwBCyABQShqIgogCSACEDEgAUHIAGoi +A0Hch8AAEJYBIwBBIGsiAiQAIAJBGGogA0EYaikAADcDACACQRBqIANBEGopAAA3AwAgAkEIaiAD +QQhqKQAANwMAIAIgAykAADcDACABQQhqIAIgCkEgEDQgAkEgaiQACyAFIAFBCGoQZCAGRQ0AIAkg +BkEobBDMAQsgAUHwAGokAAwBC0HcgsAAQTcgAUHvAGpBzILAAEGIhMAAEHwACwJAAkAgBAJ/IAgo +AgQiBUGAgICAeEYEQCAIKAIIIQFBACECQQEMAQsgCCgCCCEBAkAgCCgCDCICIAVPBEAgASEHDAEL +IAJFBEBBASEHIAEgBRDMAQwBCyABIAVBASACELgBIgdFDQILQQAhAUEACzYCDCAEIAE2AgggBCAC +NgIEIAQgBzYCACAIQRBqJAAMAQtBASACQcyHwAAQsgEACyAEKAIAIAQoAgQgBCgCCCAEKAIMIARB +EGokAAv6AQICfwF+IwBBEGsiAiQAIAJBATsBDCACIAE2AgggAiAANgIEIwBBEGsiASQAIAJBBGoi +ACkCACEEIAEgADYCDCABIAQ3AgQjAEEQayIAJAAgAUEEaiIBKAIAIgIoAgwhAwJAAkACQAJAIAIo +AgQOAgABAgsgAw0BQQEhAkEAIQMMAgsgAw0AIAIoAgAiAigCBCEDIAIoAgAhAgwBCyAAQYCAgIB4 +NgIAIAAgATYCDCAAQazHwAAgASgCBCABKAIIIgAtAAggAC0ACRBmAAsgACADNgIEIAAgAjYCACAA +QZDHwAAgASgCBCABKAIIIgAtAAggAC0ACRBmAAutCAEKfyMAQRBrIgYkACMAQSBrIgQkAAJAAkAC +QCAABEAgAEEIayIIIAgoAgBBAWoiATYCACABRQ0BIAAoAgANAiAAQX82AgAgBCAINgIcIAQgADYC +GCAEIABBCGoiAzYCFCAEQQhqIQojAEGwAWsiASQAIAFBADYCHCABQoCAgIDAADcCFCMAQUBqIgIk +ACACQQhqIANBAUEAQQEQMiABQSBqIgNBKGogAkEwaikDADcDACADQSBqIAJBKGopAwA3AwAgA0EY +aiACQSBqKQMANwMAIANBEGogAkEYaikDADcDACADQQhqIAJBEGopAwA3AwAgAyACKQMINwMAIAJB +QGskAAJ/IAEoAiAiBUUEQEEEIQJBAAwBCyABQfgAaiABQcgAaikDADcDACABQfAAaiABQUBrKQMA +NwMAIAFB6ABqIAFBOGopAwA3AwAgAUHgAGoiAiABQTBqKQMANwMAIAFB2ABqIgMgAUEoaikDADcD +ACABIAEpAyA3A1AgAUGAAWogAhBkIAEgAygCACICNgKMASABQdwAaiABKAJUIAIgASgCUCgCEBED +ACABQRRqQbyHwAAQaCABKAIYIgIgASkCgAE3AgAgAkEIaiABQYgBaikCADcCACABQQE2AhxBAQsh +ByABQQA2ApgBQQEhAyABQSBqIAFBmAFqELEBAkAgASgCIEUEQCABKAIkIQUMAQsgAUGoAWogAUEo +aigCADYCACABIAEpAiA3A6ABAkAgBQRAIAdBBHQhByABQaABakEEciEJIAEoAqgBIQMDQCABQQhq +IAIgASgCoAEQYSABKAIMIQUgASgCCEEBcQ0CIAkgAyAFEM4BIAEgA0EBaiIDNgKoASACQRBqIQIg +B0EQayIHDQALC0EAIQMgASgCpAEhBQwBC0EBIQMgASgCpAEiAkGEAUkNACACEGwLIAEgBTYClAEg +ASADNgKQASABQQE2AiQgAUHIhcAANgIgIAFCATcCLCABIAFBkAFqrUKAgICAMIQ3A5gBIAEgAUGY +AWo2AiggAUGgAWogAUEgahBHIAEoAqQBIgIgASgCqAEQACABKAKgASIDBEAgAiADEMwBCyABKAKQ +ASEFIAEoApQBIQcgASgCHCIDBEAgASgCGCECA0AgAigCACIJBEAgAkEEaigCACAJEMwBCyACQRBq +IQIgA0EBayIDDQALCyABKAIUIgIEQCABKAIYIAJBBHQQzAELIAogBzYCBCAKIAU2AgAgAUGwAWok +ACAEKAIMIQEgBCgCCCECIABBADYCACAIIAgoAgBBAWsiADYCACAARQRAIARBHGoQkQELIAYgAkEB +cSIANgIIIAYgAUEAIAAbNgIEIAZBACABIAAbNgIAIARBIGokAAwDCxDgAQsACxDhAQALIAYoAgAg +BigCBCAGKAIIIAZBEGokAAshAAJAIAEgAxCzAQRAIAAgASADIAIQuAEiAA0BCwALIAALJQAgAEUE +QEG0ssAAQTIQ4gEACyAAIAIgAyAEIAUgASgCEBETAAsgAQF/QQEhASAAKAIAIgBBAXEEfyABBSAA +KAIIQQFGCwsfAQJ+IAApAwAiAiACQj+HIgOFIAN9IAJCAFkgARBJCyMAIABFBEBBtLLAAEEyEOIB +AAsgACACIAMgBCABKAIQEQQACyMAIABFBEBBtLLAAEEyEOIBAAsgACACIAMgBCABKAIQEQ8ACyMA +IABFBEBBtLLAAEEyEOIBAAsgACACIAMgBCABKAIQEScACyMAIABFBEBBtLLAAEEyEOIBAAsgACAC +IAMgBCABKAIQESkACyMAIABFBEBBtLLAAEEyEOIBAAsgACACIAMgBCABKAIQESsACyYBAX8gACgC +ACIBQYCAgIB4ckGAgICAeEcEQCAAKAIEIAEQzAELCyEAIABFBEBBtLLAAEEyEOIBAAsgACACIAMg +ASgCEBEDAAsiACAALQAARQRAIAFBy+zAAEEFEDoPCyABQdDswABBBBA6Cx8AIABFBEBBtLLAAEEy +EOIBAAsgACACIAEoAhARAAALIQAgAEEANgIMIAAgAzYCCCAAIAI2AgQgAEH0s8AANgIACykAIAAg +AC0ABCABQS5GcjoABCAAKAIAIgAoAgAgASAAKAIEKAIQEQAACxgBAX8gACgCACIBBEAgACgCBCAB +EMwBCwsnAgFvAX8QESECEG8iAyACJgEgAEEANgIIIAAgAzYCBCAAIAE2AgALQgAgAARAIAAgARDn +AQALIwBBIGsiACQAIABBADYCGCAAQQE2AgwgAEHcyMAANgIIIABCBDcCECAAQQhqIAIQnwEACxUA +IAFpQQFGIABBgICAgHggAWtNcQscACAAQQA2AhAgAEIANwIIIABCgICAgMAANwIACxYBAW8gACAB +EAEhAhBvIgAgAiYBIAALFgEBbyAAIAEQBiECEG8iACACJgEgAAsWAQFvIAAlARAgIQEQbyIAIAEm +ASAAC+0GAQZ/An8CQAJAAkACQAJAIABBBGsiBSgCACIGQXhxIgRBBEEIIAZBA3EiBxsgAWpPBEAg +B0EAIAFBJ2oiCSAESRsNAQJAAkAgAkEJTwRAIAIgAxBIIggNAUEADAkLIANBzP97Sw0BQRAgA0EL +akF4cSADQQtJGyEBAkAgB0UEQCABQYACSSAEIAFBBHJJciAEIAFrQYGACE9yDQEMCQsgAEEIayIC +IARqIQcCQAJAAkACQCABIARLBEAgB0HshMEAKAIARg0EIAdB6ITBACgCAEYNAiAHKAIEIgZBAnEN +BSAGQXhxIgYgBGoiBCABSQ0FIAcgBhBMIAQgAWsiA0EQSQ0BIAUgASAFKAIAQQFxckECcjYCACAB +IAJqIgEgA0EDcjYCBCACIARqIgIgAigCBEEBcjYCBCABIAMQRAwNCyAEIAFrIgNBD0sNAgwMCyAF +IAQgBSgCAEEBcXJBAnI2AgAgAiAEaiIBIAEoAgRBAXI2AgQMCwtB4ITBACgCACAEaiIEIAFJDQIC +QCAEIAFrIgNBD00EQCAFIAZBAXEgBHJBAnI2AgAgAiAEaiIBIAEoAgRBAXI2AgRBACEDQQAhAQwB +CyAFIAEgBkEBcXJBAnI2AgAgASACaiIBIANBAXI2AgQgAiAEaiICIAM2AgAgAiACKAIEQX5xNgIE +C0HohMEAIAE2AgBB4ITBACADNgIADAoLIAUgASAGQQFxckECcjYCACABIAJqIgEgA0EDcjYCBCAH +IAcoAgRBAXI2AgQgASADEEQMCQtB5ITBACgCACAEaiIEIAFLDQcLIAMQKSIBRQ0BIANBfEF4IAUo +AgAiAkEDcRsgAkF4cWoiAiACIANLGyICBEAgASAAIAL8CgAACyAAEDkgAQwICyADIAEgASADSxsi +AgRAIAggACAC/AoAAAsgBSgCACICQXhxIgMgAUEEQQggAkEDcSICG2pJDQMgAkEAIAMgCUsbDQQg +ABA5CyAIDAYLQZXFwABBLkHExcAAEJQBAAtB1MXAAEEuQYTGwAAQlAEAC0GVxcAAQS5BxMXAABCU +AQALQdTFwABBLkGExsAAEJQBAAsgBSABIAZBAXFyQQJyNgIAIAEgAmoiAiAEIAFrIgFBAXI2AgRB +5ITBACABNgIAQeyEwQAgAjYCACAADAELIAALCxkAIAAoAgBB+LfAAEEeIAAoAgQoAgwRAQALDgAg +AQRAIAAgARDMAQsLGQAgASgCAEG358AAQQ4gASgCBCgCDBEBAAsWACAAKAIAIAEgAiAAKAIEKAIM +EQEACxQAIAAoAgAgASAAKAIEKAIMEQAAC4MIAQR/IwBB8ABrIgUkACAFIAM2AgwgBSACNgIIAn8g +AUGBAk8EQAJ/QYACIAAsAIACQb9/Sg0AGkH/ASAALAD/AUG/f0oNABpB/gFB/QEgACwA/gFBv39K +GwsiBiAAaiwAAEG/f0oEQEGP7cAAIQdBBQwCCyAAIAFBACAGIAQQvgEAC0EBIQcgASEGQQALIQgg +BSAGNgIUIAUgADYCECAFIAg2AhwgBSAHNgIYAkACQAJAAkAgASACSSIGIAEgA0lyRQRAIAIgA0sN +ASACRSABIAJNckUEQCAFQQxqIAVBCGogACACaiwAAEG/f0obKAIAIQMLIAUgAzYCICADIAEiAkkE +QCADQQFqIgIgA0EDayIGQQAgAyAGTxsiBkkNAwJ/IAIgBmsiB0EBayAAIANqLAAAQb9/Sg0AGiAH +QQJrIAAgAmoiAkECaywAAEG/f0oNABogB0EDayACQQNrLAAAQb9/Sg0AGiAHQXxBeyACQQRrLAAA +Qb9/ShtqCyAGaiECCwJAIAJFDQAgASACTQRAIAEgAkYNAQwFCyAAIAJqLAAAQb9/TA0ECwJ/AkAC +QCABIAJGDQACQAJAIAAgAmoiASwAACIAQQBIBEAgAS0AAUE/cSEGIABBH3EhAyAAQV9LDQEgA0EG +dCAGciEADAILIAUgAEH/AXE2AiRBAQwECyABLQACQT9xIAZBBnRyIQYgAEFwSQRAIAYgA0EMdHIh +AAwBCyADQRJ0QYCA8ABxIAEtAANBP3EgBkEGdHJyIgBBgIDEAEYNAQsgBSAANgIkIABBgAFPDQFB +AQwCCyAEENQBAAtBAiAAQYAQSQ0AGkEDQQQgAEGAgARJGwshACAFIAI2AiggBSAAIAJqNgIsIAVB +BTYCNCAFQZjuwAA2AjAgBUIFNwI8IAUgBUEYaq1CgICAgIAMhDcDaCAFIAVBEGqtQoCAgICADIQ3 +A2AgBSAFQShqrUKAgICAoAyENwNYIAUgBUEkaq1CgICAgLAMhDcDUCAFIAVBIGqtQoCAgICACYQ3 +A0gMBAsgBSACIAMgBhs2AiggBUEDNgI0IAVB2O7AADYCMCAFQgM3AjwgBSAFQRhqrUKAgICAgAyE +NwNYIAUgBUEQaq1CgICAgIAMhDcDUCAFIAVBKGqtQoCAgICACYQ3A0gMAwsgBUEENgI0IAVBuO3A +ADYCMCAFQgQ3AjwgBSAFQRhqrUKAgICAgAyENwNgIAUgBUEQaq1CgICAgIAMhDcDWCAFIAVBDGqt +QoCAgICACYQ3A1AgBSAFQQhqrUKAgICAgAmENwNIDAILIAYgAkHw7sAAENIBAAsgACABIAIgASAE +EL4BAAsgBSAFQcgAajYCOCAFQTBqIAQQnwEACxEAIAAoAgAgACgCBCABEOkBCxkAAn8gAUEJTwRA +IAEgABBIDAELIAAQKQsLDwAgACABKAIAIAIgAxBbCw8AIAAgASgCACACIAMQQwsRACAAKAIEIAAo +AgggARDpAQvgBgEPfyAAKAIAIQcgACgCBCEFQQAhACMAQRBrIgYkAEEBIQwCQCABKAIAIgpBIiAB +KAIEIg0oAhAiDhEAAA0AAkAgBUUEQAwBC0EAIAVrIQ8gByEBIAUhAAJAAn8CQANAIAAgAWohEEEA +IQMCQANAIAEgA2oiBC0AACIJQf8Aa0H/AXFBoQFJIAlBIkZyIAlB3ABGcg0BIAAgA0EBaiIDRw0A +CyAAIAhqDAMLIARBAWohAQJAIAQsAAAiAEEATgRAIABB/wFxIQAMAQsgAS0AAEE/cSELIABBH3Eh +CSAEQQJqIQEgAEFfTQRAIAlBBnQgC3IhAAwBCyABLQAAQT9xIAtBBnRyIQsgBEEDaiEBIABBcEkE +QCALIAlBDHRyIQAMAQsgCUESdEGAgPAAcSABLQAAQT9xIAtBBnRyciEAIARBBGohAQsgBkEEaiAA +QYGABBA1AkACQCAGLQAEQYABRg0AIAYtAA8gBi0ADmtB/wFxQQFGDQACQAJAIAIgAyAIaiIESw0A +AkAgAkUNACACIAVPBEAgAiAFRw0CDAELIAIgB2osAABBv39MDQELAkAgBEUNACAEIAVPBEAgBCAP +akUNAQwCCyAHIAhqIANqLAAAQUBIDQELIAogAiAHaiAIIAJrIANqIA0oAgwiAhEBAEUNAQwDCyAH +IAUgAiAEQdTswAAQvgEACwJAIAYtAARBgAFGBEAgCiAGKAIIIA4RAAANAwwBCyAKIAYtAA4iBCAG +QQRqaiAGLQAPIARrIAIRAQANAgsCf0EBIABBgAFJDQAaQQIgAEGAEEkNABpBA0EEIABBgIAESRsL +IAhqIANqIQILAn9BASAAQYABSQ0AGkECIABBgBBJDQAaQQNBBCAAQYCABEkbCyAIaiIEIANqIQgg +ECABayIARQ0CDAELCwwECyADIARqCyIDIAJJDQBBACEAAkAgAkUNACACIAVPBEAgAiIAIAVHDQIM +AQsgAiIAIAdqLAAAQb9/TA0BCyADRQRAQQAhAwwCCyADIAVPBEAgAyAFRg0CIAAhAgwBCyADIAdq +LAAAQb9/Sg0BIAAhAgsgByAFIAIgA0Hk7MAAEL4BAAsgCiAAIAdqIAMgAGsgDSgCDBEBAA0AIApB +IiAOEQAAIQwLIAZBEGokACAMCxYAQaiBwQAgADYCAEGkgcEAQQE2AgALIgAgAELtuq22zYXU9eMA +NwMIIABC+IKZvZXuxsW5fzcDAAshACAAQoC834WrpfibJzcDCCAAQp/1lpTW7u3DoX83AwALEwAg +AEGAx8AANgIEIAAgATYCAAsRACABIAAoAgAgACgCBBC8AQsQACABIAAoAgAgACgCBBA6CxAAIAEo +AgAgASgCBCAAEDwLYQECfwJAAkAgAEEEaygCACICQXhxIgNBBEEIIAJBA3EiAhsgAWpPBEAgAkEA +IAMgAUEnaksbDQEgABA5DAILQZXFwABBLkHExcAAEJQBAAtB1MXAAEEuQYTGwAAQlAEACwsdAQFv +IAAoAgAlASABJQEgARBsIAIlASACEGwQDgsXAQFvIAAoAgAlASABIAIlASACEGwQGwsNACAAKAIA +KAIIQQFGC2sBAX8jAEEwayIDJAAgAyABNgIEIAMgADYCACADQQI2AgwgA0HY/cAANgIIIANCAjcC +FCADIANBBGqtQoCAgICACYQ3AyggAyADrUKAgICAgAmENwMgIAMgA0EgajYCECADQQhqIAIQnwEA +C2sBAX8jAEEwayIDJAAgAyABNgIEIAMgADYCACADQQI2AgwgA0H4/cAANgIIIANCAjcCFCADIANB +BGqtQoCAgICACYQ3AyggAyADrUKAgICAgAmENwMgIAMgA0EgajYCECADQQhqIAIQnwEAC2sBAX8j +AEEwayIDJAAgAyABNgIEIAMgADYCACADQQI2AgwgA0Gs/sAANgIIIANCAjcCFCADIANBBGqtQoCA +gICACYQ3AyggAyADrUKAgICAgAmENwMgIAMgA0EgajYCECADQQhqIAIQnwEACwsAIAAoAgAgARBL +Cw8AQeDnwABBKyAAEJQBAAsNACAAKQMAQQEgARBJCw4AIAFBmITAAEEFELwBCw4AIAFB9IXAAEEO +ELwBCw4AIAFBkInAAEEKELwBCwsAIAAoAgAgARByCwwAIAAoAgAgARDTAQuKAwEBfyAAKAIAIQIj +AEHQAWsiACQAIAAgAkEYaq1CgICAgIAHhDcDaCAAIAJBEGqtQoCAgICAB4Q3A2AgACACQQhqrUKA +gICAgAeENwNYIAAgAq1CgICAgIAHhDcDUCAAQZi4wAA2AjggAEEENgI8IABBBDYCTCAAQoOAgICA +hICAaTcCyAEgAEGAgMAANgLAASAAQQI7AbgBIABCgoCAgICEgIBpNwKwASAAQYCAwAA2AqgBIABB +AjsBoAEgAEKBgICAgISAgGk3ApgBIABBgIDAADYCkAEgAEECOwGIASAAQoCAgICAhICAaTcCgAEg +AEKAgMAANwJ4IABBAjsBcCAAIABB8ABqNgJIIABBBDYCRCAAIABB0ABqNgJAIABBLGoiAiAAQThq +EEcgACACrUKAgICAkAeENwMgIABBATYCDCAAQai5wAA2AgggAEIBNwIUIAAgAEEgajYCECABKAIA +IAEoAgQgAEEIahA8IAAoAiwiAgRAIAAoAjAgAhDMAQsgAEHQAWokAAsNACAAQYSRwAAgARA8Cw4A +IAFBiI/AAEEFELwBCw4AIAFB5rLAAEELELwBCw0AIABB2LzAACABEDwLDQBBlMLAAEEbEOIBAAsO +AEGvwsAAQc8AEOIBAAsJACAAIAEQJQALDQAgAEHUxMAAIAEQPAsMACAAIAEpAgA3AwALDQAgAEGw +yMAAIAEQPAsOACABQajIwABBBRC8AQsaACAAIAFBrIHBACgCACIAQckAIAAbEQIAAAsNACAAQYTq +wAAgARA8CwoAIAIgACABEDoLCgAgACABJQEQAgsOACABQfC8wABBCBC8AQsOACABQfq+wABBAxC8 +AQsJACAAQQA2AgALCAAgACUBEAMLCAAgACUBEBILCAAgACUBECILBABBAAsCAAsLpoABDgBBgIDA +AAvJAi9ob21lL2NveW90dGU1MDgvY29kZS9odWdnaW5nZmFjZS5qcy9wYWNrYWdlcy9odWIveGV0 +LWNvcmUtd2FzbS1idWlsZC9tZXJrbGVoYXNoL3NyYy9hZ2dyZWdhdGVkX2hhc2hlcy5ycwAAAAAA +EABpAAAAWQAAADgAAAAAABAAaQAAAFkAAAAPAAAAAAAQAGkAAABWAAAAOQAAAC9ob21lL2NveW90 +dGU1MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS14ODZfNjQtdW5rbm93bi1saW51eC1nbnUv +bGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvdmVjL3NwZWNfZnJvbV9pdGVy +X25lc3RlZC5ycwCcABAAhwAAADQAAAAFAAAABAAAAAwAAAAEAAAABQAAAAYAAAAHAEHUgsAAC4UF +AQAAAAgAAABhIERpc3BsYXkgaW1wbGVtZW50YXRpb24gcmV0dXJuZWQgYW4gZXJyb3IgdW5leHBl +Y3RlZGx5L2hvbWUvY295b3R0ZTUwOC8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLXg4Nl82NC11 +bmtub3duLWxpbnV4LWdudS9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2FsbG9jL3NyYy9z +dHJpbmcucnMAkwEQAHQAAADRCgAADgAAAEVycm9yAAAAkwEQAHQAAAB9BQAAGwAAAAAAAAAEAAAA +BAAAAAkAAABPa0Vyci9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS14 +ODZfNjQtdW5rbm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxv +Yy9zcmMvc2xpY2UucnNFAhAAcwAAAL4BAAAdAAAAAQAAAAAAAABKc0NodW5raGFzaGxlbmd0aAAA +ANcCEAAEAAAA2wIQAAYAAABzdHJ1Y3QgSnNDaHVua2F0dGVtcHRlZCB0byB0YWtlIG93bmVyc2hp +cCBvZiBSdXN0IHZhbHVlIHdoaWxlIGl0IHdhcyBib3Jyb3dlZC9ob21lL2NveW90dGU1MDgvLmNh +cmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi93YXNtLWJp +bmRnZW4tMC4yLjEwMC9zcmMvY29udmVydC9zbGljZXMucnNzcmMvbGliLnJzALEDEAAKAAAANwAA +ABQAAABBAxAAcAAAACQBAAAOAEH8h8AAC4EBL2hvbWUvY295b3R0ZTUwOC8ucnVzdHVwL3Rvb2xj +aGFpbnMvc3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9saWIvcnVzdGxpYi9zcmMvcnVz +dC9saWJyYXJ5L2FsbG9jL3NyYy9zdHJpbmcucnP8AxAAdAAAAOgBAAAXAEGIicAAC5UBAQAAAAoA +AABhIHNlcXVlbmNlL2hvbWUvY295b3R0ZTUwOC8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNy +YXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3NlcmRlLTEuMC4yMTkvc3JjL2RlL2ltcGxzLnJzAAAA +mgQQAGMAAACVBAAAIgAAAJoEEABjAAAAmAQAABwAQaiKwAALBQEAAAALAEG4isAACwUBAAAADABB +yIrAAAvlAQEAAAANAAAAY2FsbGVkIGBPcHRpb246OnVud3JhcF90aHJvdygpYCBvbiBhIGBOb25l +YCB2YWx1ZWhhc2hsZW5ndGgvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFi +bGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkv +YWxsb2Mvc3JjL3Jhd192ZWMvbW9kLnJziwUQAHkAAAAuAgAAEQAAACA6IAoBAAAAAAAAABQGEAAD +AAAAFwYQAAEAQbiMwAALwwkBAAAAEQAAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4g +YEVycmAgdmFsdWUvaG9tZS9jb3lvdHRlNTA4L2NvZGUvaHVnZ2luZ2ZhY2UuanMvcGFja2FnZXMv +aHViL3hldC1jb3JlLXdhc20tYnVpbGQvbWVya2xlaGFzaC9zcmMvYWdncmVnYXRlZF9oYXNoZXMu +cnNrBhAAaQAAAD0AAAAqAAAAawYQAGkAAAA4AAAAHgAAAC9ob21lL2NveW90dGU1MDgvLnJ1c3R1 cC90b29sY2hhaW5zL3N0YWJsZS14ODZfNjQtdW5rbm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIv -c3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvc2xpY2UucnMAYAUQAHMAAAC+AQAAHQAAAC9ob21l -L2NveW90dGU1MDgvY29kZS9odWdnaW5nZmFjZS5qcy9wYWNrYWdlcy9odWIveGV0LWNvcmUtd2Fz -bS1idWlsZC9tZXJrbGVoYXNoL3NyYy9hZ2dyZWdhdGVkX2hhc2hlcy5ycwAAAOQFEABpAAAAWQAA -ADgAAAATAAAA5AUQAGkAAABZAAAADwAAAOQFEABpAAAAVgAAADkAAAAvaG9tZS9jb3lvdHRlNTA4 -Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9y -dXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3ZlYy9zcGVjX2Zyb21faXRlcl9uZXN0 -ZWQucnMAhAYQAIcAAAA0AAAABQAAABQAAAAMAAAABAAAABUAAAAWAAAACABBvI7AAAupBgEAAAAX -AAAAYSBEaXNwbGF5IGltcGxlbWVudGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHVuZXhwZWN0ZWRs -eS9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS14ODZfNjQtdW5rbm93 -bi1saW51eC1nbnUvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvc3RyaW5n -LnJzAHsHEAB0AAAA0QoAAA4AAABFcnJvcgAAAHsHEAB0AAAAfQUAABsAAAAAAAAABAAAAAQAAAAY -AAAAT2tFcnIvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0 -LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3Jj -L3NsaWNlLnJzLQgQAHMAAAC+AQAAHQAAAAEAAAAAAAAASnNDaHVua2hhc2hsZW5ndGgAAAC/CBAA -BAAAAMMIEAAGAAAAc3RydWN0IEpzQ2h1bmthdHRlbXB0ZWQgdG8gdGFrZSBvd25lcnNoaXAgb2Yg -UnVzdCB2YWx1ZSB3aGlsZSBpdCB3YXMgYm9ycm93ZWQvaG9tZS9jb3lvdHRlNTA4Ly5jYXJnby9y -ZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvd2FzbS1iaW5kZ2Vu -LTAuMi4xMDAvc3JjL2NvbnZlcnQvc2xpY2VzLnJzc3JjL2xpYi5ycwCZCRAACgAAADcAAAAUAAAA -KQkQAHAAAAAkAQAADgAAAC9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJs +c3JjL3J1c3QvbGlicmFyeS9jb3JlL3NyYy9pdGVyL3RyYWl0cy9pdGVyYXRvci5ycwAAAPQGEACB +AAAAwQcAAAkAAABFcnJvci9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJs ZS14ODZfNjQtdW5rbm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9h -bGxvYy9zcmMvcmF3X3ZlYy9tb2QucnMAAADECRAAeQAAAC4CAAARAAAAGQAAAAwAAAAEAAAAGgAA -ABsAAAAIAEHwlMAAC5sEAQAAABwAAABhIERpc3BsYXkgaW1wbGVtZW50YXRpb24gcmV0dXJuZWQg -YW4gZXJyb3IgdW5leHBlY3RlZGx5L2hvbWUvY295b3R0ZTUwOC8ucnVzdHVwL3Rvb2xjaGFpbnMv -c3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJy -YXJ5L2FsbG9jL3NyYy9zdHJpbmcucnMArwoQAHQAAADRCgAADgAAAEVycm9yAAAArwoQAHQAAAB9 -BQAAGwAAAGludmFsaWQgdHlwZTogLCBleHBlY3RlZCAAAABMCxAADgAAAFoLEAALAAAAL2hvbWUv -Y295b3R0ZTUwOC8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4 -LWdudS9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2FsbG9jL3NyYy9zbGljZS5ycwB4CxAA -cwAAAL4BAAAdAAAAAQAAAAAAAAAvaG9tZS9jb3lvdHRlNTA4Ly5jYXJnby9yZWdpc3RyeS9zcmMv -aW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvc2VyZGUtd2FzbS1iaW5kZ2VuLTAuNi41 -L3NyYy9saWIucnMAAAAEDBAAaQAAADUAAAAOAAAA//////////+ADBAAQZiZwAALwRsBAAAAL2hv -bWUvY295b3R0ZTUwOC9jb2RlL2h1Z2dpbmdmYWNlLmpzL3BhY2thZ2VzL2h1Yi94ZXQtY29yZS13 -YXNtLWJ1aWxkL2RlZHVwbGljYXRpb24vc3JjL2NodW5raW5nLnJzAJwMEABjAAAAHgAAAAkAAABh -c3NlcnRpb24gZmFpbGVkOiB0YXJnZXRfY2h1bmtfc2l6ZSA+IDY0nAwQAGMAAAAiAAAACQAAAJwM -EABjAAAALgAAAB0AAABhc3NlcnRpb24gZmFpbGVkOiBtYXhpbXVtX2NodW5rID4gbWluaW11bV9j -aHVuawCcDBAAYwAAADEAAAAJAAAAnAwQAGMAAAA7AAAAFwAAAJwMEABjAAAAZQAAADsAAACcDBAA -YwAAAIcAAAAyAAAAnAwQAGMAAACJAAAAOgAAAJwMEABjAAAAsQAAABUAAACcDBAAYwAAAK4AAABA -AAAAL2hvbWUvY295b3R0ZTUwOC8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0x -OTQ5Y2Y4YzZiNWI1NTdmL2xhenlfc3RhdGljLTEuNS4wL3NyYy9pbmxpbmVfbGF6eS5ycwAA+A0Q -AGoAAAAeAAAAEAAAAC9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS14 -ODZfNjQtdW5rbm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxv -Yy9zcmMvcmF3X3ZlYy9tb2QucnMAAAB0DhAAeQAAAC4CAAARAAAAT25jZSBpbnN0YW5jZSBoYXMg -cHJldmlvdXNseSBiZWVuIHBvaXNvbmVkAAAADxAAKgAAAG9uZS10aW1lIGluaXRpYWxpemF0aW9u -IG1heSBub3QgYmUgcGVyZm9ybWVkIHJlY3Vyc2l2ZWx5NA8QADgAAAAvaG9tZS9jb3lvdHRlNTA4 -Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9y -dXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvc3RkL3NyYy9zeW5jL3BvaXNvbi9vbmNlLnJzdA8QAHwA -AACbAAAAMgAAAFn1QOip04iw1iDtOffHUlarcomJaYmyRXfHjrbViQprtzF6iz5XjzZL2Tbp3DbG -HbbVVFVOTHogy5ojKEazdKQSuaMcPqgGO/e6Ai9sjeeQipoNFfctyeGt04YQOgWVjiIHOrjx9C5a -rn+An5SsD6WB1tiA6wNzDg+tcBXcfrCZdjD9VbUvnWhopJ4RglAAACjMj6gGg7DE/Uo39opnsD42 -dK2Gq4ef8TbHa76/nxLy7aSYXFdJEUjFe0eVBgEAAMzqnBqAN7ofbZukY9Zv8DtLh+OCl35omePY -UKpzBqF5IPQRYp7PrORxkFeHH+cgJZuKGnj909Urc8gR3c1N3gAvOYdaHDGp6v9AvBe2jnTbb78g -9o2aV6+xwgkb2uWmhi6hIsMKwy/MZ0L3wf4qXjV7pCHA9MiZLcPPBJRKS966aX1wHXIYtfcgLPN7 -WLaGMgwnr4aItgAAeZCK2+TWFaGZ4bKXnH5PSAHjE1e3e8rMYPGwK6aEJb/IvF1iE+jnrVqVhw2U -cAAAb2KeEwiR5oqiON4v12p3vc/A/MIfAGv7J8R75rh0pMdYXesQFvH2utFw521bH8sJR0x9l+YZ -srBKraduOLzMAAE/l98KnYTMcPdqAX3vo3P+vb2G09IHyDAXeWyWySp/2gTFxmuoN9CdYKoeZnzx -84fmqk2wJqasB1tKTzeZWnXerixb5n6DkIUHVv2Trehu2O1TEOHZAADX2xzSsjsGnrLSASrxd6sH -RBtk5lUCVezGFJxEqJT7ePX1wMYbDlHH48rkNgsyAAAtGossJjN8gkRB6kgLX2cU6+yNSabTeyZe -A/WC+W+R8Yj7NPR/GyKG2ElvOOfOvp1Kjw/IyvhY6thk/JKGGY0ANpq/uk9wOG1MvufRB8sy4JAI -Ra32IY0ipYklwL+xXGNxzqKcc6EgRlj75arj3+en6w08K5PKEAx77a+E6P4nJx+r4vltHN+iI/V0 -B6zRzU1O4jOt/3AAABZ4l8V76KyiSWAotFonkphZifHdgRGGwhk+SEKgcpm7eDBRZjfNcO9kmPyr -EwUAAINAyVgYtljA3uAll4VQ6AmUfT74O/uXkc5LthJtYh5+0Vd7f1BUDFIWJOJ0cXnhvodV6SIy -rNlvPr/fmnyVIwAVvksjfn0coLuMo7hYx6KrMCs+7M6gHw2RuWB+i6W2CzVmop9b3TNDo8EBQH07 -/cInEXNUJIBB+8sYDaWFYaVlT7WEh70CevZjUOZn3RFvaasUqPwiIAAAUti5LZG+1oxXiq7ptolR -aSgM2gq1U5TuXoR4Gqle/Nhnp0oaGb+Gq+UVZMi1xgAALqIIjhcQcyYlyosHGxAt7fuoJrKE7UE7 -BtwoDxIi5hMmbXD76/UVo866ATNOwxaIrv1xu5xbOelIFnIuIOksABzJsysd24NCpaax0hpGfddr -hutu5Bfs4nzE+zlAvuC4BJ0p1cRgod40NozSyIbsfpmjmJ8SrRkh74OiYWv0zKYXxlj23s5SLIPd -rGkRh7Qt6cue89bwAACJlC+NydjVPYT1ASuichiK8jx7DsSkgvKWoRvLLOwggBPjWZ7gtpNm64N8 -zBnOAAA7nEf2NVfLIFta11k3vy52dTlpPYL+eyDV2ZwzEsF91wN9YoRCg6eb6VFf6RPFfSEWeF78 -KRp7si1muzGYzdUATHN1bYCb43EjGvsG8CpXfoUf6WovT3Oi8t0sArXGgr/eoGEHxuo7XJhpQUe7 -k8jNAX4YXGGFEG1dfCesMK74d5EsKhKBa3yRZ2nRrZm2dVubBprnas8AAAQR3mD6CsTzw2eRpXoS -YyBNidFpIuYdYiZHK+YdrIjRPGdLFeI2cBAdOlUoX7gAAD1vIxhMTu/yAva5EWbe1tkckUf7VXn8 -ob2NKS8D/YXr4fq+sy9QJ74eZs3EUUID4zYYB1TTZBNEPpjydWyzggDwZvoWA5FFsffKR5icBhwC -IVJLWsffECm1qFccPjVbc2zZjuksMUTOZfq9BkUulLwblFcSp4ZQ8K3OUdMVssP+AkIU4FUQrgBU -5EJvhEBL9ci8vMjZfwAA/pveF/Oevb8SToXyLzAEqNTY5aVXSc45hLo3VqTiuf+LgaCeHa25VYoX -GfPLigAAOPv70Mi/4kjotUjoQZjji4uglgYWEicOKiRES+iWENU64ZJnF7oBEZ1oMUUPdy7CbMW7 -cvLviRbsUFZ/GSqpAE54ob2QWXa8rrj8kuNBFMag5DHtLDrhB02dTiOE6cuSxYp9u3L1T4/QO5YL -wHCWCwHrAxpYWpViVAIA6uWDX2SZ8ojNFuX8Qc+YetpIl9q7+kVI/rKqAABVZfWbBht2GVattkOD -Xo+L2SFIFP0cXT6PzbCiLB5c7H+1+6f+4Pf6G5YSutMAAACOsQGEF5A/2utfOuNtkP9w53BpwKfV -JwXpE3xgc+fYIqw7PGTfcKvJ4xK+itzGpO2K5zMAQR/v7MtyrHSywiQAtACpT5UNdAYEYz0ymyl6 -HdXqy5iyfMOzm3N4YcfjhsmK9UZLNuqrn1bMha/FFKJthI+jt9g+pBfr25odUezMbvtaMxMJs8r5 -0u4V9MVgXkq0cjZQZ2kAAIe7VBQSHaWdFsi7uRMeMoSN3S+rtm89+40KFo7tXjBg6GyU6RRLv8vD -EBs4Y08AABBOzG+Bt9UHVYFqanI2peXdf6BHNLKvV5TTyav3RvMYPdMa1lXGbWP28/c5SauLzHsY -3cEGqcdjAAAAAAQAAAAEAAAAHwAAAC9ob21lL2NveW90dGU1MDgvLmNhcmdvL3JlZ2lzdHJ5L3Ny -Yy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9qcy1zeXMtMC4zLjc3L3NyYy9saWIu -cnMAABAYEABeAAAA+xgAAAEAAAAvaG9tZS9jb3lvdHRlNTA4Ly5jYXJnby9yZWdpc3RyeS9zcmMv -aW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvd2FzbS1iaW5kZ2VuLTAuMi4xMDAvc3Jj -L2NvbnZlcnQvc2xpY2VzLnJzgBgQAHAAAAAkAQAADgAAAGNsb3N1cmUgaW52b2tlZCByZWN1cnNp -dmVseSBvciBhZnRlciBiZWluZyBkcm9wcGVkTGF5b3V0RXJyb3IvaG9tZS9jb3lvdHRlNTA4Ly5y -dXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0 -bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3NsaWNlLnJzPRkQAHMAAAC+AQAAHQAAACwA -AAAtAAAALgAAAC8AAAAwAAAAL2hvbWUvY295b3R0ZTUwOC8uY2FyZ28vcmVnaXN0cnkvc3JjL2lu -ZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2J5dGVzLTEuMTAuMS9zcmMvYnl0ZXMucnMA -MQAAADIAAAAzAAAANAAAADUAAAA2AAAANwAAADgAAAA0AAAAOQBB5LTAAAu5EwEAAAA6AAAAY2Fs -bGVkIGBSZXN1bHQ6OnVud3JhcCgpYCBvbiBhbiBgRXJyYCB2YWx1ZQDUGRAAXwAAAEgFAAAyAAAA -1BkQAF8AAABWBQAASQAAADsAAAA8AAAAPQAAAD4AAAA/AAAAL2hvbWUvY295b3R0ZTUwOC8ucnVz -dHVwL3Rvb2xjaGFpbnMvc3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9saWIvcnVzdGxp -Yi9zcmMvcnVzdC9saWJyYXJ5L2FsbG9jL3NyYy9zbGljZS5ycwDMGhAAcwAAAL4BAAAdAAAAL2hv -bWUvY295b3R0ZTUwOC9jb2RlL2h1Z2dpbmdmYWNlLmpzL3BhY2thZ2VzL2h1Yi94ZXQtY29yZS13 -YXNtLWJ1aWxkL21lcmtsZWhhc2gvc3JjL2RhdGFfaGFzaC5ycwAAAFAbEABhAAAAegAAAAkAAABJ -bnZhbGlkIGhleCBpbnB1dCBmb3IgRGF0YUhhc2gAAAEAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAEA -AAAAAAAAUBsQAGEAAACyAAAAKgAAAFAbEABhAAAAswAAACoAAABQGxAAYQAAALQAAAAqAAAAZpf1 -d1uVUN4xNcuspZcYHJ3kIRCb6ytYtNCwS5Ot8ikBfsXHpUcplv2UZma0igLmXd1TbzfHbdL4Y1Lm -SlNxPwEAAAAAAAAAbWlkID4gbGVuAAAAfBwQAAkAAAAvaG9tZS9jb3lvdHRlNTA4Ly5jYXJnby9y -ZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYmxha2UzLTEuOC4y -L3NyYy9saWIucnMAAACQHBAAXQAAAAsCAAARAAAAkBwQAF0AAAC+AgAACgAAAJAcEABdAAAA7AIA -ACgAAACQHBAAXQAAAOwCAAA0AAAAkBwQAF0AAADsAgAADAAAAJAcEABdAAAA3AIAABcAAACQHBAA -XQAAABgDAAAfAAAAkBwQAF0AAAA1AwAADAAAAJAcEABdAAAAPAMAABIAAACQHBAAXQAAAGADAAAh -AAAAkBwQAF0AAABiAwAAEQAAAJAcEABdAAAAYgMAAEEAAABpbnN1ZmZpY2llbnQgY2FwYWNpdHkA -AACwHRAAFQAAAENhcGFjaXR5RXJyb3I6IADQHRAADwAAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAo -KWAgb24gYW4gYEVycmAgdmFsdWUAAAAAAAQAAAAEAAAAQwAAAAAAAAAIAAAABAAAAEsAAABMAAAA -TQAAAGEgc3RyaW5nYnl0ZSBhcnJheWJvb2xlYW4gYGBOHhAACQAAAFceEAABAAAAaW50ZWdlciBg -AAAAaB4QAAkAAABXHhAAAQAAAGZsb2F0aW5nIHBvaW50IGCEHhAAEAAAAFceEAABAAAAY2hhcmFj -dGVyIGAApB4QAAsAAABXHhAAAQAAAHN0cmluZyAAwB4QAAcAAAB1bml0IHZhbHVlT3B0aW9uIHZh -bHVlbmV3dHlwZSBzdHJ1Y3RzZXF1ZW5jZW1hcGVudW11bml0IHZhcmlhbnRuZXd0eXBlIHZhcmlh -bnR0dXBsZSB2YXJpYW50c3RydWN0IHZhcmlhbnQAAAABAAAAAAAAAC4wdTMyTGF6eSBpbnN0YW5j -ZSBoYXMgcHJldmlvdXNseSBiZWVuIHBvaXNvbmVkAEkfEAAqAAAAL2hvbWUvY295b3R0ZTUwOC8u -Y2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL29uY2Vf -Y2VsbC0xLjIxLjMvc3JjL2xpYi5ycwAAAHwfEABhAAAACAMAABkAAAByZWVudHJhbnQgaW5pdAAA -8B8QAA4AAAB8HxAAYQAAAHoCAAANAAAAbnVsbCBwb2ludGVyIHBhc3NlZCB0byBydXN0cmVjdXJz -aXZlIHVzZSBvZiBhbiBvYmplY3QgZGV0ZWN0ZWQgd2hpY2ggd291bGQgbGVhZCB0byB1bnNhZmUg -YWxpYXNpbmcgaW4gcnVzdEpzVmFsdWUoKQCCIBAACAAAAIogEAABAAAAL3J1c3RjLzE3MDY3ZTlh -YzZkN2VjYjcwZTUwZjkyYzE5NDRlNTQ1MTg4ZDIzNTkvbGlicmFyeS9hbGxvYy9zcmMvc3RyaW5n -LnJzAJwgEABLAAAAfQUAABsAAAAvcnVzdGMvMTcwNjdlOWFjNmQ3ZWNiNzBlNTBmOTJjMTk0NGU1 -NDUxODhkMjM1OS9saWJyYXJ5L2FsbG9jL3NyYy9yYXdfdmVjL21vZC5yc/ggEABQAAAALgIAABEA -AABTAAAADAAAAAQAAABUAAAAVQAAAFYAAAAvcnVzdC9kZXBzL2RsbWFsbG9jLTAuMi43L3NyYy9k -bG1hbGxvYy5yc2Fzc2VydGlvbiBmYWlsZWQ6IHBzaXplID49IHNpemUgKyBtaW5fb3ZlcmhlYWQA -cCEQACkAAACoBAAACQAAAGFzc2VydGlvbiBmYWlsZWQ6IHBzaXplIDw9IHNpemUgKyBtYXhfb3Zl -cmhlYWQAAHAhEAApAAAArgQAAA0AAABBY2Nlc3NFcnJvcmNhbm5vdCBhY2Nlc3MgYSBUaHJlYWQg -TG9jYWwgU3RvcmFnZSB2YWx1ZSBkdXJpbmcgb3IgYWZ0ZXIgZGVzdHJ1Y3Rpb246IAAjIhAASAAA -AG1lbW9yeSBhbGxvY2F0aW9uIG9mICBieXRlcyBmYWlsZWQAAHQiEAAVAAAAiSIQAA0AAABsaWJy -YXJ5L3N0ZC9zcmMvYWxsb2MucnOoIhAAGAAAAGQBAAAJAAAAUwAAAAwAAAAEAAAAVwAAAAAAAAAI -AAAABAAAAFgAAAAAAAAACAAAAAQAAABZAAAAWgAAAFsAAABcAAAAXQAAABAAAAAEAAAAXgAAAF8A -AABgAAAAYQAAAEhhc2ggdGFibGUgY2FwYWNpdHkgb3ZlcmZsb3coIxAAHAAAAC9ydXN0L2RlcHMv -aGFzaGJyb3duLTAuMTUuMi9zcmMvcmF3L21vZC5ycwAATCMQACoAAAAjAAAAKAAAAEVycm9yAAAA -YgAAAAwAAAAEAAAAYwAAAGQAAABlAAAAY2FwYWNpdHkgb3ZlcmZsb3cAAACoIxAAEQAAAGxpYnJh -cnkvYWxsb2Mvc3JjL3Jhd192ZWMvbW9kLnJzxCMQACAAAAAuAgAAEQAAAGxpYnJhcnkvYWxsb2Mv -c3JjL3N0cmluZy5ycwD0IxAAGwAAAOgBAAAXAEGoyMAAC8wSAQAAAGYAAABhIGZvcm1hdHRpbmcg -dHJhaXQgaW1wbGVtZW50YXRpb24gcmV0dXJuZWQgYW4gZXJyb3Igd2hlbiB0aGUgdW5kZXJseWlu -ZyBzdHJlYW0gZGlkIG5vdGxpYnJhcnkvYWxsb2Mvc3JjL2ZtdC5ycwAAhiQQABgAAACKAgAADgAA -APQjEAAbAAAAfQUAABsAAAAAcAAHAC0BAQECAQIBAUgLMBUQAWUHAgYCAgEEIwEeG1sLOgkJARgE -AQkBAwEFKwM7CSoYASA3AQEBBAgEAQMHCgIdAToBAQECBAgBCQEKAhoBAgI5AQQCBAICAwMBHgID -AQsCOQEEBQECBAEUAhYGAQE6AQECAQQIAQcDCgIeATsBAQEMAQkBKAEDATcBAQMFAwEEBwILAh0B -OgECAgEBAwMBBAcCCwIcAjkCAQECBAgBCQEKAh0BSAEEAQIDAQEIAVEBAgcMCGIBAgkLB0kCGwEB -AQEBNw4BBQECBQsBJAkBZgQBBgECAgIZAgQDEAQNAQICBgEPAQADAAQcAx0CHgJAAgEHCAECCwkB -LQMBAXUCIgF2AwQCCQEGA9sCAgE6AQEHAQEBAQIIBgoCATAfMQQwCgQDJgkMAiAEAgY4AQECAwEB -BTgIAgKYAwENAQcEAQYBAwLGQAABwyEAA40BYCAABmkCAAQBCiACUAIAAQMBBAEZAgUBlwIaEg0B -JggZCwEBLAMwAQIEAgICASQBQwYCAgICDAEIAS8BMwEBAwICBQIBASoCCAHuAQIBBAEAAQAQEBAA -AgAB4gGVBQADAQIFBCgDBAGlAgAEQQUAAk8ERgsxBHsBNg8pAQICCgMxBAICBwE9AyQFAQg+AQwC -NAkBAQgEAgFfAwIEBgECAZ0BAwgVAjkCAQEBAQwBCQEOBwMFQwECBgEBAgEBAwQDAQEOAlUIAgMB -ARcBUQECBgEBAgEBAgEC6wECBAYCAQIbAlUIAgEBAmoBAQECCGUBAQECBAEFAAkBAvUBCgQEAZAE -AgIEASAKKAYCBAgBCQYCAy4NAQIABwEGAQFSFgIHAQIBAnoGAwEBAgEHAQFIAgMBAQEAAgsCNAUF -AxcBAAEGDwAMAwMABTsHAAE/BFEBCwIAAgAuAhcABQMGCAgCBx4ElAMANwQyCAEOARYFAQ8ABwER -AgcBAgEFZAGgBwABPQQABP4CAAdtBwBggPAAYXNzZXJ0aW9uIGZhaWxlZDogZWRlbHRhID49IDBs -aWJyYXJ5L2NvcmUvc3JjL251bS9kaXlfZmxvYXQucnMAAADMJxAAIQAAAEwAAAAJAAAAzCcQACEA -AABOAAAACQAAAMFv8oYjAAAAge+shVtBbS3uBAAAAR9qv2TtOG7tl6fa9Pk/6QNPGAABPpUuCZnf -A/04FQ8v5HQj7PXP0wjcBMTasM28GX8zpgMmH+lOAgAAAXwumFuH075yn9nYhy8VEsZQ3mtwbkrP -D9iV1W5xsiawZsatJDYVHVrTQjwOVP9jwHNVzBfv+WXyKLxV98fcgNztbvTO79xf91MFAGxpYnJh -cnkvY29yZS9zcmMvbnVtL2ZsdDJkZWMvc3RyYXRlZ3kvZHJhZ29uLnJzYXNzZXJ0aW9uIGZhaWxl -ZDogZC5tYW50ID4gMACsKBAALwAAAHYAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogZC5taW51cyA+ -IDAAAACsKBAALwAAAHcAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogZC5wbHVzID4gMKwoEAAvAAAA -eAAAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBidWYubGVuKCkgPj0gTUFYX1NJR19ESUdJVFMAAACs -KBAALwAAAHsAAAAFAAAArCgQAC8AAADCAAAACQAAAKwoEAAvAAAA+wAAAA0AAACsKBAALwAAAAIB -AAASAAAAYXNzZXJ0aW9uIGZhaWxlZDogZC5tYW50LmNoZWNrZWRfc3ViKGQubWludXMpLmlzX3Nv -bWUoKQCsKBAALwAAAHoAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogZC5tYW50LmNoZWNrZWRfYWRk -KGQucGx1cykuaXNfc29tZSgpAACsKBAALwAAAHkAAAAFAAAArCgQAC8AAAALAQAABQAAAKwoEAAv -AAAADAEAAAUAAACsKBAALwAAAA0BAAAFAAAArCgQAC8AAAByAQAAJAAAAKwoEAAvAAAAdwEAAC8A -AACsKBAALwAAAIQBAAASAAAArCgQAC8AAABmAQAADQAAAKwoEAAvAAAATAEAACIAAACsKBAALwAA -AA8BAAAFAAAArCgQAC8AAAAOAQAABQAAAAAAAADfRRo9A88a5sH7zP4AAAAAysaaxxf+cKvc+9T+ -AAAAAE/cvL78sXf/9vvc/gAAAAAM1mtB75FWvhH85P4AAAAAPPx/kK0f0I0s/Oz+AAAAAIOaVTEo -XFHTRvz0/gAAAAC1yaatj6xxnWH8/P4AAAAAy4vuI3cinOp7/AT/AAAAAG1TeECRScyulvwM/wAA -AABXzrZdeRI8grH8FP8AAAAAN1b7TTaUEMLL/Bz/AAAAAE+YSDhv6paQ5vwk/wAAAADHOoIly4V0 -1wD9LP8AAAAA9Je/l83PhqAb/TT/AAAAAOWsKheYCjTvNf08/wAAAACOsjUq+2c4slD9RP8AAAAA -Oz/G0t/UyIRr/Uz/AAAAALrN0xonRN3Fhf1U/wAAAACWySW7zp9rk6D9XP8AAAAAhKVifSRsrNu6 -/WT/AAAAAPbaXw1YZquj1f1s/wAAAAAm8cPek/ji8+/9dP8AAAAAuID/qqittbUK/nz/AAAAAItK -fGwFX2KHJf6E/wAAAABTMME0YP+8yT/+jP8AAAAAVSa6kYyFTpZa/pT/AAAAAL1+KXAkd/nfdP6c -/wAAAACPuOW4n73fpo/+pP8AAAAAlH10iM9fqfip/qz/AAAAAM+bqI+TcES5xP60/wAAAABrFQ+/ -+PAIit/+vP8AAAAAtjExZVUlsM35/sT/AAAAAKx/e9DG4j+ZFP/M/wAAAAAGOysqxBBc5C7/1P8A -AAAA05JzaZkkJKpJ/9z/AAAAAA7KAIPytYf9Y//k/wAAAADrGhGSZAjlvH7/7P8AAAAAzIhQbwnM -vIyZ//T/AAAAACxlGeJYF7fRs//8/wBB/trAAAsFQJzO/wQAQYzbwAALnSQQpdTo6P8MAAAAAAAA -AGKsxet4rQMAFAAAAAAAhAmU+Hg5P4EeABwAAAAAALMVB8l7zpfAOAAkAAAAAABwXOp7zjJ+j1MA -LAAAAAAAaIDpq6Q40tVtADQAAAAAAEUimhcmJ0+fiAA8AAAAAAAn+8TUMaJj7aIARAAAAAAAqK3I -jDhl3rC9AEwAAAAAANtlqxqOCMeD2ABUAAAAAACaHXFC+R1dxPIAXAAAAAAAWOcbpixpTZINAWQA -AAAAAOqNcBpk7gHaJwFsAAAAAABKd++amaNtokIBdAAAAAAAhWt9tHt4CfJcAXwAAAAAAHcY3Xmh -5FS0dwGEAAAAAADCxZtbkoZbhpIBjAAAAAAAPV2WyMVTNcisAZQAAAAAALOgl/pctCqVxwGcAAAA -AADjX6CZvZ9G3uEBpAAAAAAAJYw52zTCm6X8AawAAAAAAFyfmKNymsb2FgK0AAAAAADOvulUU7/c -tzECvAAAAAAA4kEi8hfz/IhMAsQAAAAAAKV4XNObziDMZgLMAAAAAADfUyF781oWmIEC1AAAAAAA -OjAfl9y1oOKbAtwAAAAAAJaz41xT0dmotgLkAAAAAAA8RKek2Xyb+9AC7AAAAAAAEESkp0xMdrvr -AvQAAAAAABqcQLbvjquLBgP8AAAAAAAshFemEO8f0CADBAEAAAAAKTGR6eWkEJs7AwwBAAAAAJ0M -nKH7mxDnVQMUAQAAAAAp9Dti2SAorHADHAEAAAAAhc+nel5LRICLAyQBAAAAAC3drANA5CG/pQMs -AQAAAACP/0ReL5xnjsADNAEAAAAAQbiMnJ0XM9TaAzwBAAAAAKkb47SS2xme9QNEAQAAAADZd9+6 -br+W6w8ETAEAAAAAbGlicmFyeS9jb3JlL3NyYy9udW0vZmx0MmRlYy9zdHJhdGVneS9ncmlzdS5y -cwAAGDAQAC4AAAB9AAAAFQAAABgwEAAuAAAAqQAAAAUAAAAYMBAALgAAAKoAAAAFAAAAGDAQAC4A -AACrAAAABQAAABgwEAAuAAAArgAAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBkLm1hbnQgKyBkLnBs -dXMgPCAoMSA8PCA2MSkAAAAYMBAALgAAAK8AAAAFAAAAGDAQAC4AAAAKAQAAEQAAABgwEAAuAAAA -DQEAAAkAAAAYMBAALgAAAEABAAAJAAAAGDAQAC4AAACtAAAABQAAABgwEAAuAAAArAAAAAUAAABh -c3NlcnRpb24gZmFpbGVkOiAhYnVmLmlzX2VtcHR5KCkAAAAYMBAALgAAANwBAAAFAAAAYXNzZXJ0 -aW9uIGZhaWxlZDogZC5tYW50IDwgKDEgPDwgNjEpGDAQAC4AAADdAQAABQAAABgwEAAuAAAA3gEA -AAUAAAABAAAACgAAAGQAAADoAwAAECcAAKCGAQBAQg8AgJaYAADh9QUAypo7GDAQAC4AAAAzAgAA -EQAAABgwEAAuAAAANgIAAAkAAAAYMBAALgAAAGwCAAAJAAAAGDAQAC4AAADjAgAAJgAAABgwEAAu -AAAA7wIAACYAAAAYMBAALgAAAMwCAAAmAAAAbGlicmFyeS9jb3JlL3NyYy9udW0vZmx0MmRlYy9t -b2QucnMAKDIQACMAAAC7AAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGJ1ZlswXSA+IGInMCcAKDIQ -ACMAAAC8AAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IHBhcnRzLmxlbigpID49IDQAACgyEAAjAAAA -vQAAAAUAAAAuMC4tK05hTmluZjBhc3NlcnRpb24gZmFpbGVkOiBidWYubGVuKCkgPj0gbWF4bGVu -AAAAKDIQACMAAAB+AgAADQAAACkuLjAxMjM0NTY3ODlhYmNkZWZCb3Jyb3dNdXRFcnJvcmFscmVh -ZHkgYm9ycm93ZWQ6IAAlMxAAEgAAAGNhbGxlZCBgT3B0aW9uOjp1bndyYXAoKWAgb24gYSBgTm9u -ZWAgdmFsdWVpbmRleCBvdXQgb2YgYm91bmRzOiB0aGUgbGVuIGlzICBidXQgdGhlIGluZGV4IGlz -IAAAAGszEAAgAAAAizMQABIAAAAAAAAABAAAAAQAAABtAAAAPT0hPW1hdGNoZXNhc3NlcnRpb24g -YGxlZnQgIHJpZ2h0YCBmYWlsZWQKICBsZWZ0OiAKIHJpZ2h0OiAAyzMQABAAAADbMxAAFwAAAPIz -EAAJAAAAIHJpZ2h0YCBmYWlsZWQ6IAogIGxlZnQ6IAAAAMszEAAQAAAAFDQQABAAAAAkNBAACQAA -APIzEAAJAAAAOiAAAAEAAAAAAAAAUDQQAAIAAAAAAAAADAAAAAQAAABuAAAAbwAAAHAAAAAgICAg -LAp9IH0oKAosMHgwMDAxMDIwMzA0MDUwNjA3MDgwOTEwMTExMjEzMTQxNTE2MTcxODE5MjAyMTIy -MjMyNDI1MjYyNzI4MjkzMDMxMzIzMzM0MzUzNjM3MzgzOTQwNDE0MjQzNDQ0NTQ2NDc0ODQ5NTA1 -MTUyNTM1NDU1NTY1NzU4NTk2MDYxNjI2MzY0NjU2NjY3Njg2OTcwNzE3MjczNzQ3NTc2Nzc3ODc5 -ODA4MTgyODM4NDg1ODY4Nzg4ODk5MDkxOTI5Mzk0OTU5Njk3OTg5OTAwMDAwMDAwMDAwMDAwMDAw -MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDBsaWJyYXJ5L2Nv -cmUvc3JjL2ZtdC9tb2QucnNmYWxzZXRydWUAkzUQABsAAADYCgAAJgAAAJM1EAAbAAAA4QoAABoA -AABsaWJyYXJ5L2NvcmUvc3JjL3N0ci9tb2QucnNbLi4uXWJlZ2luIDw9IGVuZCAoIDw9ICkgd2hl -biBzbGljaW5nIGBgAPg1EAAOAAAABjYQAAQAAAAKNhAAEAAAABo2EAABAAAAYnl0ZSBpbmRleCAg -aXMgbm90IGEgY2hhciBib3VuZGFyeTsgaXQgaXMgaW5zaWRlICAoYnl0ZXMgKSBvZiBgADw2EAAL -AAAARzYQACYAAABtNhAACAAAAHU2EAAGAAAAGjYQAAEAAAAgaXMgb3V0IG9mIGJvdW5kcyBvZiBg -AAA8NhAACwAAAKQ2EAAWAAAAGjYQAAEAAADYNRAAGwAAAJwBAAAsAAAAbGlicmFyeS9jb3JlL3Ny -Yy91bmljb2RlL3ByaW50YWJsZS5ycwAAAOQ2EAAlAAAAGgAAADYAAADkNhAAJQAAAAoAAAArAAAA -AAYBAQMBBAIFBwcCCAgJAgoFCwIOBBABEQISBRMcFAEVAhcCGQ0cBR0IHwEkAWoEawKvA7ECvALP -AtEC1AzVCdYC1wLaAeAF4QLnBOgC7iDwBPgC+gT7AQwnOz5OT4+enp97i5OWorK6hrEGBwk2PT5W -89DRBBQYNjdWV3+qrq+9NeASh4mOngQNDhESKTE0OkVGSUpOT2RlioyNj7bBw8TGy9ZctrcbHAcI -CgsUFzY5Oqip2NkJN5CRqAcKOz5maY+SEW9fv+7vWmL0/P9TVJqbLi8nKFWdoKGjpKeorbq8xAYL -DBUdOj9FUaanzM2gBxkaIiU+P+fs7//FxgQgIyUmKDM4OkhKTFBTVVZYWlxeYGNlZmtzeH1/iqSq -r7DA0K6vbm/d3pNeInsFAwQtA2YDAS8ugIIdAzEPHAQkCR4FKwVEBA4qgKoGJAQkBCgINAtOAzQM -gTcJFgoIGDtFOQNjCAkwFgUhAxsFAUA4BEsFLwQKBwkHQCAnBAwJNgM6BRoHBAwHUEk3Mw0zBy4I -CgYmAx0IAoDQUhADNywIKhYaJhwUFwlOBCQJRA0ZBwoGSAgnCXULQj4qBjsFCgZRBgEFEAMFC1kI -Ah1iHkgICoCmXiJFCwoGDRM6BgoGFBwsBBeAuTxkUwxICQpGRRtICFMNSQcKgLYiDgoGRgodA0dJ -NwMOCAoGOQcKgTYZBzsDHVUBDzINg5tmdQuAxIpMYw2EMBAWCo+bBYJHmrk6hsaCOQcqBFwGJgpG -CigFE4GwOoDGW2VLBDkHEUAFCwIOl/gIhNYpCqLngTMPAR0GDgQIgYyJBGsFDQMJBxCPYID6BoG0 -TEcJdDyA9gpzCHAVRnoUDBQMVwkZgIeBRwOFQg8VhFAfBgaA1SsFPiEBcC0DGgQCgUAfEToFAYHQ -KoDWKwQBgeCA9ylMBAoEAoMRREw9gMI8BgEEVQUbNAKBDiwEZAxWCoCuOB0NLAQJBwIOBoCag9gE -EQMNA3cEXwYMBAEPDAQ4CAoGKAgsBAI+gVQMHQMKBTgHHAYJB4D6hAYAAQMFBQYGAgcGCAcJEQoc -CxkMGg0QDgwPBBADEhITCRYBFwQYARkDGgcbARwCHxYgAysDLQsuATAEMQIyAacEqQKqBKsI+gL7 -Bf0C/gP/Ca14eYuNojBXWIuMkBzdDg9LTPv8Li8/XF1f4oSNjpGSqbG6u8XGycre5OX/AAQREikx -NDc6Oz1JSl2EjpKpsbS6u8bKzs/k5QAEDQ4REikxNDo7RUZJSl5kZYSRm53Jzs8NESk6O0VJV1tc -Xl9kZY2RqbS6u8XJ3+Tl8A0RRUlkZYCEsry+v9XX8PGDhYukpr6/xcfP2ttImL3Nxs7PSU5PV1le -X4mOj7G2t7/BxsfXERYXW1z29/7/gG1x3t8OH25vHB1ffX6ur027vBYXHh9GR05PWFpcXn5/tcXU -1dzw8fVyc490dZYmLi+nr7e/x8/X35oAQJeYMI8fzs/S1M7/Tk9aWwcIDxAnL+7vbm83PT9CRZCR -U2d1yMnQ0djZ5/7/ACBfIoLfBIJECBsEBhGBrA6AqwUfCIEcAxkIAQQvBDQEBwMBBwYHEQpQDxIH -VQcDBBwKCQMIAwcDAgMDAwwEBQMLBgEOFQVOBxsHVwcCBhcMUARDAy0DAQQRBg8MOgQdJV8gbQRq -JYDIBYKwAxoGgv0DWQcWCRgJFAwUDGoGCgYaBlkHKwVGCiwEDAQBAzELLAQaBgsDgKwGCgYvMYD0 -CDwDDwM+BTgIKwWC/xEYCC8RLQMhDyEPgIwEgpoWCxWIlAUvBTsHAg4YCYC+InQMgNYagRAFgOEJ -8p4DNwmBXBSAuAiA3RU7AwoGOAhGCAwGdAseA1oEWQmAgxgcChYJTASAigarpAwXBDGhBIHaJgcM -BQWAphCB9QcBICoGTASAjQSAvgMbAw8NbGlicmFyeS9jb3JlL3NyYy91bmljb2RlL3VuaWNvZGVf -ZGF0YS5ycwAAANU8EAAoAAAATQAAACgAAADVPBAAKAAAAFkAAAAWAAAAbGlicmFyeS9jb3JlL3Ny -Yy9udW0vYmlnbnVtLnJzAAAgPRAAHgAAAKsBAAABAAAAYXNzZXJ0aW9uIGZhaWxlZDogbm9ib3Jy -b3dhc3NlcnRpb24gZmFpbGVkOiBkaWdpdHMgPCA0MGFzc2VydGlvbiBmYWlsZWQ6IG90aGVyID4g -MGF0dGVtcHQgdG8gZGl2aWRlIGJ5IHplcm8Aoj0QABkAAABhdHRlbXB0IHRvIGNhbGN1bGF0ZSB0 -aGUgcmVtYWluZGVyIHdpdGggYSBkaXZpc29yIG9mIHplcm8AAADEPRAAOQAAAHJhbmdlIHN0YXJ0 -IGluZGV4ICBvdXQgb2YgcmFuZ2UgZm9yIHNsaWNlIG9mIGxlbmd0aCAIPhAAEgAAABo+EAAiAAAA -cmFuZ2UgZW5kIGluZGV4IEw+EAAQAAAAGj4QACIAAABzbGljZSBpbmRleCBzdGFydHMgYXQgIGJ1 -dCBlbmRzIGF0IABsPhAAFgAAAII+EAANAAAAY29weV9mcm9tX3NsaWNlOiBzb3VyY2Ugc2xpY2Ug -bGVuZ3RoICgpIGRvZXMgbm90IG1hdGNoIGRlc3RpbmF0aW9uIHNsaWNlIGxlbmd0aCAoAAAAoD4Q -ACYAAADGPhAAKwAAAAQzEAABAAAAAAMAAIMEIACRBWAAXROgABIXIB8MIGAf7ywgKyowoCtvpmAs -AqjgLB774C0A/iA2nv9gNv0B4TYBCiE3JA3hN6sOYTkvGOE5MBzhSvMe4U5ANKFSHmHhU/BqYVRP -b+FUnbxhVQDPYVZl0aFWANohVwDgoViu4iFa7OThW9DoYVwgAO5c8AF/XcAzEADCMxAAxDMQAAIA -AAACAAAABwBBxP/AAAsBTwBwCXByb2R1Y2VycwIIbGFuZ3VhZ2UBBFJ1c3QADHByb2Nlc3NlZC1i -eQMFcnVzdGMdMS44Ny4wICgxNzA2N2U5YWMgMjAyNS0wNS0wOSkGd2FscnVzBjAuMjMuMwx3YXNt -LWJpbmRnZW4HMC4yLjEwMABrD3RhcmdldF9mZWF0dXJlcwYrD211dGFibGUtZ2xvYmFscysTbm9u -dHJhcHBpbmctZnB0b2ludCsLYnVsay1tZW1vcnkrCHNpZ24tZXh0Kw9yZWZlcmVuY2UtdHlwZXMr -Cm11bHRpdmFsdWU= +bGxvYy9zcmMvc3RyaW5nLnJzAAAAjQcQAHQAAAB9BQAAGwAAAGludmFsaWQgdmFsdWU6ICwgZXhw +ZWN0ZWQgAAAUCBAADwAAACMIEAALAAAAbWlzc2luZyBmaWVsZCBgYEAIEAAPAAAATwgQAAEAAABk +dXBsaWNhdGUgZmllbGQgYAAAAGAIEAARAAAATwgQAAEAAAASAAAADAAAAAQAAAATAAAAFAAAAAcA +AAAvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25v +d24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3NsaWNl +LnJzAJwIEABzAAAAvgEAAB0AAAAvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9z +dGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJh +cnkvYWxsb2Mvc3JjL3ZlYy9zcGVjX2Zyb21faXRlcl9uZXN0ZWQucnMAIAkQAIcAAAATAAAABQAA +AGludmFsaWQgdHlwZTogLCBleHBlY3RlZCAAAAC4CRAADgAAAMYJEAALAAAAL2hvbWUvY295b3R0 +ZTUwOC8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9s +aWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2FsbG9jL3NyYy9zbGljZS5ycwDkCRAAcwAAAL4B +AAAdAAAAAQAAAAAAAAAvaG9tZS9jb3lvdHRlNTA4Ly5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXgu +Y3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvc2VyZGUtd2FzbS1iaW5kZ2VuLTAuNi41L3NyYy9s +aWIucnMAAABwChAAaQAAADUAAAAOAAAAAAAAAP//////////8AoQAEGIlsAAC4UfAQAAAC9ob21l +L2NveW90dGU1MDgvY29kZS9odWdnaW5nZmFjZS5qcy9wYWNrYWdlcy9odWIveGV0LWNvcmUtd2Fz +bS1idWlsZC9kZWR1cGxpY2F0aW9uL3NyYy9jaHVua2luZy5ycwAMCxAAYwAAAB4AAAAJAAAAYXNz +ZXJ0aW9uIGZhaWxlZDogdGFyZ2V0X2NodW5rX3NpemUgPiA2NAwLEABjAAAAIgAAAAkAAAAMCxAA +YwAAAC4AAAAdAAAAYXNzZXJ0aW9uIGZhaWxlZDogbWF4aW11bV9jaHVuayA+IG1pbmltdW1fY2h1 +bmsADAsQAGMAAAAxAAAACQAAAAwLEABjAAAAOwAAABcAAAAMCxAAYwAAAGUAAAA7AAAADAsQAGMA +AACHAAAAMgAAAAwLEABjAAAAiQAAADoAAAAMCxAAYwAAALEAAAAVAAAADAsQAGMAAACuAAAAQAAA +AC9ob21lL2NveW90dGU1MDgvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0 +OWNmOGM2YjViNTU3Zi9sYXp5X3N0YXRpYy0xLjUuMC9zcmMvaW5saW5lX2xhenkucnMAAGgMEABq +AAAAHgAAABAAAAAvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2 +XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mv +c3JjL3Jhd192ZWMvbW9kLnJzAAAA5AwQAHkAAAAuAgAAEQAAAE9uY2UgaW5zdGFuY2UgaGFzIHBy +ZXZpb3VzbHkgYmVlbiBwb2lzb25lZAAAcA0QACoAAABvbmUtdGltZSBpbml0aWFsaXphdGlvbiBt +YXkgbm90IGJlIHBlcmZvcm1lZCByZWN1cnNpdmVseaQNEAA4AAAAL2hvbWUvY295b3R0ZTUwOC8u +cnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9saWIvcnVz +dGxpYi9zcmMvcnVzdC9saWJyYXJ5L3N0ZC9zcmMvc3luYy9wb2lzb24vb25jZS5yc+QNEAB8AAAA +mwAAADIAAABZ9UDoqdOIsNYg7Tn3x1JWq3KJiWmJskV3x4621YkKa7cxeos+V482S9k26dw2xh22 +1VRVTkx6IMuaIyhGs3SkErmjHD6oBjv3ugIvbI3nkIqaDRX3LcnhrdOGEDoFlY4iBzq48fQuWq5/ +gJ+UrA+lgdbYgOsDcw4PrXAV3H6wmXYw/VW1L51oaKSeEYJQAAAozI+oBoOwxP1KN/aKZ7A+NnSt +hquHn/E2x2u+v58S8u2kmFxXSRFIxXtHlQYBAADM6pwagDe6H22bpGPWb/A7S4fjgpd+aJnj2FCq +cwaheSD0EWKez6zkcZBXhx/nICWbihp4/dPVK3PIEd3NTd4ALzmHWhwxqer/QLwXto5022+/IPaN +mlevscIJG9rlpoYuoSLDCsMvzGdC98H+Kl41e6QhwPTImS3DzwSUSkveuml9cB1yGLX3ICzze1i2 +hjIMJ6+GiLYAAHmQitvk1hWhmeGyl5x+T0gB4xNXt3vKzGDxsCumhCW/yLxdYhPo561alYcNlHAA +AG9inhMIkeaKojjeL9dqd73PwPzCHwBr+yfEe+a4dKTHWF3rEBbx9rrRcOdtWx/LCUdMfZfmGbKw +Sq2nbji8zAABP5ffCp2EzHD3agF976Nz/r29htPSB8gwF3lslskqf9oExcZrqDfQnWCqHmZ88fOH +5qpNsCamrAdbSk83mVp13q4sW+Z+g5CFB1b9k63obtjtUxDh2QAA19sc0rI7Bp6y0gEq8XerB0Qb +ZOZVAlXsxhScRKiU+3j19cDGGw5Rx+PK5DYLMgAALRqLLCYzfIJEQepIC19nFOvsjUmm03smXgP1 +gvlvkfGI+zT0fxsihthJbzjnzr6dSo8PyMr4WOrYZPyShhmNADaav7pPcDhtTL7n0QfLMuCQCEWt +9iGNIqWJJcC/sVxjcc6inHOhIEZY++Wq49/np+sNPCuTyhAMe+2vhOj+Jycfq+L5bRzfoiP1dAes +0c1NTuIzrf9wAAAWeJfFe+isoklgKLRaJ5KYWYnx3YERhsIZPkhCoHKZu3gwUWY3zXDvZJj8qxMF +AACDQMlYGLZYwN7gJZeFUOgJlH0++Dv7l5HOS7YSbWIeftFXe39QVAxSFiTidHF54b6HVekiMqzZ +bz6/35p8lSMAFb5LI359HKC7jKO4WMeiqzArPuzOoB8Nkblgfoultgs1ZqKfW90zQ6PBAUB9O/3C +JxFzVCSAQfvLGA2lhWGlZU+1hIe9Anr2Y1DmZ90Rb2mrFKj8IiAAAFLYuS2RvtaMV4qu6baJUWko +DNoKtVOU7l6EeBqpXvzYZ6dKGhm/hqvlFWTItcYAAC6iCI4XEHMmJcqLBxsQLe37qCayhO1BOwbc +KA8SIuYTJm1w++v1FaPOugEzTsMWiK79cbucWznpSBZyLiDpLAAcybMrHduDQqWmsdIaRn3Xa4br +buQX7OJ8xPs5QL7guASdKdXEYKHeNDaM0siG7H6Zo5ifEq0ZIe+DomFr9MymF8ZY9t7OUiyD3axp +EYe0LenLnvPW8AAAiZQvjcnY1T2E9QEronIYivI8ew7EpILylqEbyyzsIIAT41me4LaTZuuDfMwZ +zgAAO5xH9jVXyyBbWtdZN78udnU5aT2C/nsg1dmcMxLBfdcDfWKEQoOnm+lRX+kTxX0hFnhe/Cka +e7ItZrsxmM3VAExzdW2Am+NxIxr7BvAqV36FH+lqL09zovLdLAK1xoK/3qBhB8bqO1yYaUFHu5PI +zQF+GFxhhRBtXXwnrDCu+HeRLCoSgWt8kWdp0a2ZtnVbmwaa52rPAAAEEd5g+grE88NnkaV6EmMg +TYnRaSLmHWImRyvmHayI0TxnSxXiNnAQHTpVKF+4AAA9byMYTE7v8gL2uRFm3tbZHJFH+1V5/KG9 +jSkvA/2F6+H6vrMvUCe+HmbNxFFCA+M2GAdU02QTRD6Y8nVss4IA8Gb6FgORRbH3ykeYnAYcAiFS +S1rH3xAptahXHD41W3Ns2Y7pLDFEzmX6vQZFLpS8G5RXEqeGUPCtzlHTFbLD/gJCFOBVEK4AVORC +b4RAS/XIvLzI2X8AAP6b3hfznr2/Ek6F8i8wBKjU2OWlV0nOOYS6N1ak4rn/i4Ggnh2tuVWKFxnz +y4oAADj7+9DIv+JI6LVI6EGY44uLoJYGFhInDiokREvolhDVOuGSZxe6ARGdaDFFD3cuwmzFu3Ly +74kW7FBWfxkqqQBOeKG9kFl2vK64/JLjQRTGoOQx7Sw64QdNnU4jhOnLksWKfbty9U+P0DuWC8Bw +lgsB6wMaWFqVYlQCAOrlg19kmfKIzRbl/EHPmHraSJfau/pFSP6yqgAAVWX1mwYbdhlWrbZDg16P +i9khSBT9HF0+j82woiweXOx/tfun/uD3+huWErrTAAAAjrEBhBeQP9rrXzrjbZD/cOdwacCn1ScF +6RN8YHPn2CKsOzxk33CryeMSvorcxqTtiuczAEEf7+zLcqx0ssIkALQAqU+VDXQGBGM9Mpspeh3V +6suYsnzDs5tzeGHH44bJivVGSzbqq59WzIWvxRSibYSPo7fYPqQX69uaHVHszG77WjMTCbPK+dLu +FfTFYF5KtHI2UGdpAACHu1QUEh2lnRbIu7kTHjKEjd0vq7ZvPfuNChaO7V4wYOhslOkUS7/LwxAb +OGNPAAAQTsxvgbfVB1WBampyNqXl3X+gRzSyr1eU08mr90bzGD3TGtZVxm1j9vP3OUmri8x7GN3B +BqnHYy9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS14ODZfNjQtdW5r +bm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvc2xp +Y2UucnMAcBYQAHMAAAC+AQAAHQAAAC9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29sY2hhaW5z +L3N0YWJsZS14ODZfNjQtdW5rbm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGli +cmFyeS9jb3JlL3NyYy9pdGVyL3RyYWl0cy9pdGVyYXRvci5ycwAAAPQWEACBAAAAwQcAAAkAAAB/ +GFfWzlbtZhJ/+RPnpcPzpM0m1bXbSeZBJJh/KPuUwy9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90 +b29sY2hhaW5zL3N0YWJsZS14ODZfNjQtdW5rbm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIvc3Jj +L3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvcmF3X3ZlYy9tb2QucnMAAACoFxAAeQAAAC4CAAARAAAA +AAAAAAQAAAAEAAAAFwAAAC9ob21lL2NveW90dGU1MDgvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRl +eC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9qcy1zeXMtMC4zLjc3L3NyYy9saWIucnMAAEQY +EABeAAAA+xgAAAEAAAAvaG9tZS9jb3lvdHRlNTA4Ly5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXgu +Y3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvd2FzbS1iaW5kZ2VuLTAuMi4xMDAvc3JjL2NvbnZl +cnQvc2xpY2VzLnJztBgQAHAAAAAkAQAADgAAAGNsb3N1cmUgaW52b2tlZCByZWN1cnNpdmVseSBv +ciBhZnRlciBiZWluZyBkcm9wcGVkTGF5b3V0RXJyb3IvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAv +dG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3Ny +Yy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3NsaWNlLnJzcRkQAHMAAAC+AQAAHQAAACQAAAAlAAAA +JgAAACcAAAAoAAAAL2hvbWUvY295b3R0ZTUwOC8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNy +YXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2J5dGVzLTEuMTAuMS9zcmMvYnl0ZXMucnMAKQAAACoA +AAArAAAALAAAAC0AAAAuAAAALwAAADAAAAAsAAAAMQBBmLXAAAulFAEAAAAyAAAAY2FsbGVkIGBS +ZXN1bHQ6OnVud3JhcCgpYCBvbiBhbiBgRXJyYCB2YWx1ZQAIGhAAXwAAAEgFAAAyAAAACBoQAF8A +AABWBQAASQAAADMAAAA0AAAANQAAADYAAAA3AAAAL2hvbWUvY295b3R0ZTUwOC8ucnVzdHVwL3Rv +b2xjaGFpbnMvc3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9saWIvcnVzdGxpYi9zcmMv +cnVzdC9saWJyYXJ5L2FsbG9jL3NyYy9zbGljZS5ycwAAGxAAcwAAAL4BAAAdAAAAL2hvbWUvY295 +b3R0ZTUwOC9jb2RlL2h1Z2dpbmdmYWNlLmpzL3BhY2thZ2VzL2h1Yi94ZXQtY29yZS13YXNtLWJ1 +aWxkL21lcmtsZWhhc2gvc3JjL2RhdGFfaGFzaC5ycwAAAIQbEABhAAAAegAAAAkAAABJbnZhbGlk +IGhleCBpbnB1dCBmb3IgRGF0YUhhc2gAAAEAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAEAAAAAAAAA +hBsQAGEAAACyAAAAKgAAAIQbEABhAAAAswAAACoAAACEGxAAYQAAALQAAAAqAAAAZpf1d1uVUN4x +NcuspZcYHJ3kIRCb6ytYtNCwS5Ot8ikBfsXHpUcplv2UZma0igLmXd1TbzfHbdL4Y1LmSlNxPwEA +AAAAAAAAbWlkID4gbGVuAAAAsBwQAAkAAAAvaG9tZS9jb3lvdHRlNTA4Ly5jYXJnby9yZWdpc3Ry +eS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYmxha2UzLTEuOC4yL3NyYy9s +aWIucnMAAADEHBAAXQAAAAsCAAARAAAAxBwQAF0AAAC+AgAACgAAAMQcEABdAAAA7AIAACgAAADE +HBAAXQAAAOwCAAA0AAAAxBwQAF0AAADsAgAADAAAAMQcEABdAAAA3AIAABcAAADEHBAAXQAAABgD +AAAfAAAAxBwQAF0AAAA1AwAADAAAAMQcEABdAAAAPAMAABIAAADEHBAAXQAAAGADAAAhAAAAxBwQ +AF0AAABiAwAAEQAAAMQcEABdAAAAYgMAAEEAAABpbnN1ZmZpY2llbnQgY2FwYWNpdHkAAADkHRAA +FQAAAENhcGFjaXR5RXJyb3I6IAAEHhAADwAAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24g +YW4gYEVycmAgdmFsdWUAAAAAAAQAAAAEAAAAOwAAAAAAAAAIAAAABAAAAEMAAABEAAAARQAAAGEg +c3RyaW5nYnl0ZSBhcnJheWJvb2xlYW4gYGCCHhAACQAAAIseEAABAAAAaW50ZWdlciBgAAAAnB4Q +AAkAAACLHhAAAQAAAGZsb2F0aW5nIHBvaW50IGC4HhAAEAAAAIseEAABAAAAY2hhcmFjdGVyIGAA +2B4QAAsAAACLHhAAAQAAAHN0cmluZyAA9B4QAAcAAAB1bml0IHZhbHVlT3B0aW9uIHZhbHVlbmV3 +dHlwZSBzdHJ1Y3RzZXF1ZW5jZW1hcGVudW11bml0IHZhcmlhbnRuZXd0eXBlIHZhcmlhbnR0dXBs +ZSB2YXJpYW50c3RydWN0IHZhcmlhbnQAAAABAAAAAAAAAC4wdTMyTGF6eSBpbnN0YW5jZSBoYXMg +cHJldmlvdXNseSBiZWVuIHBvaXNvbmVkAH0fEAAqAAAAL2hvbWUvY295b3R0ZTUwOC8uY2FyZ28v +cmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL29uY2VfY2VsbC0x +LjIxLjMvc3JjL2xpYi5ycwAAALAfEABhAAAACAMAABkAAAByZWVudHJhbnQgaW5pdAAAJCAQAA4A +AACwHxAAYQAAAHoCAAANAAAAL2hvbWUvY295b3R0ZTUwOC8uY2FyZ28vcmVnaXN0cnkvc3JjL2lu +ZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3dhc20tYmluZGdlbi0wLjIuMTAwL3NyYy9j +b252ZXJ0L2ltcGxzLnJzAEwgEABvAAAAYQIAABYAAABMIBAAbwAAAHECAAAMAAAATCAQAG8AAABt +AgAAEAAAAGFycmF5IGNvbnRhaW5zIGEgdmFsdWUgb2YgdGhlIHdyb25nIHR5cGVudWxsIHBvaW50 +ZXIgcGFzc2VkIHRvIHJ1c3RyZWN1cnNpdmUgdXNlIG9mIGFuIG9iamVjdCBkZXRlY3RlZCB3aGlj +aCB3b3VsZCBsZWFkIHRvIHVuc2FmZSBhbGlhc2luZyBpbiBydXN0SnNWYWx1ZSgpAH4hEAAIAAAA +hiEQAAEAAAAvcnVzdGMvMTcwNjdlOWFjNmQ3ZWNiNzBlNTBmOTJjMTk0NGU1NDUxODhkMjM1OS9s +aWJyYXJ5L2FsbG9jL3NyYy9zdHJpbmcucnMAmCEQAEsAAAB9BQAAGwAAAC9ydXN0Yy8xNzA2N2U5 +YWM2ZDdlY2I3MGU1MGY5MmMxOTQ0ZTU0NTE4OGQyMzU5L2xpYnJhcnkvYWxsb2Mvc3JjL3Jhd192 +ZWMvbW9kLnJz9CEQAFAAAAAuAgAAEQAAAEoAAAAMAAAABAAAAEsAAABMAAAATQAAAC9ydXN0L2Rl +cHMvZGxtYWxsb2MtMC4yLjcvc3JjL2RsbWFsbG9jLnJzYXNzZXJ0aW9uIGZhaWxlZDogcHNpemUg +Pj0gc2l6ZSArIG1pbl9vdmVyaGVhZABsIhAAKQAAAKgEAAAJAAAAYXNzZXJ0aW9uIGZhaWxlZDog +cHNpemUgPD0gc2l6ZSArIG1heF9vdmVyaGVhZAAAbCIQACkAAACuBAAADQAAAG1lbW9yeSBhbGxv +Y2F0aW9uIG9mICBieXRlcyBmYWlsZWQAABQjEAAVAAAAKSMQAA0AAABsaWJyYXJ5L3N0ZC9zcmMv +YWxsb2MucnNIIxAAGAAAAGQBAAAJAAAASgAAAAwAAAAEAAAATgAAAAAAAAAIAAAABAAAAE8AAAAA +AAAACAAAAAQAAABQAAAAUQAAAFIAAABTAAAAVAAAABAAAAAEAAAAVQAAAFYAAABXAAAAWAAAAEhh +c2ggdGFibGUgY2FwYWNpdHkgb3ZlcmZsb3fIIxAAHAAAAC9ydXN0L2RlcHMvaGFzaGJyb3duLTAu +MTUuMi9zcmMvcmF3L21vZC5ycwAA7CMQACoAAAAjAAAAKAAAAEVycm9yAAAAWQAAAAwAAAAEAAAA +WgAAAFsAAABcAAAAY2FwYWNpdHkgb3ZlcmZsb3cAAABIJBAAEQAAAGxpYnJhcnkvYWxsb2Mvc3Jj +L3Jhd192ZWMvbW9kLnJzZCQQACAAAAAuAgAAEQAAAGxpYnJhcnkvYWxsb2Mvc3JjL3N0cmluZy5y +cwCUJBAAGwAAAOgBAAAXAEHIycAAC8wSAQAAAF0AAABhIGZvcm1hdHRpbmcgdHJhaXQgaW1wbGVt +ZW50YXRpb24gcmV0dXJuZWQgYW4gZXJyb3Igd2hlbiB0aGUgdW5kZXJseWluZyBzdHJlYW0gZGlk +IG5vdGxpYnJhcnkvYWxsb2Mvc3JjL2ZtdC5ycwAAJiUQABgAAACKAgAADgAAAJQkEAAbAAAAfQUA +ABsAAAAAcAAHAC0BAQECAQIBAUgLMBUQAWUHAgYCAgEEIwEeG1sLOgkJARgEAQkBAwEFKwM7CSoY +ASA3AQEBBAgEAQMHCgIdAToBAQECBAgBCQEKAhoBAgI5AQQCBAICAwMBHgIDAQsCOQEEBQECBAEU +AhYGAQE6AQECAQQIAQcDCgIeATsBAQEMAQkBKAEDATcBAQMFAwEEBwILAh0BOgECAgEBAwMBBAcC +CwIcAjkCAQECBAgBCQEKAh0BSAEEAQIDAQEIAVEBAgcMCGIBAgkLB0kCGwEBAQEBNw4BBQECBQsB +JAkBZgQBBgECAgIZAgQDEAQNAQICBgEPAQADAAQcAx0CHgJAAgEHCAECCwkBLQMBAXUCIgF2AwQC +CQEGA9sCAgE6AQEHAQEBAQIIBgoCATAfMQQwCgQDJgkMAiAEAgY4AQECAwEBBTgIAgKYAwENAQcE +AQYBAwLGQAABwyEAA40BYCAABmkCAAQBCiACUAIAAQMBBAEZAgUBlwIaEg0BJggZCwEBLAMwAQIE +AgICASQBQwYCAgICDAEIAS8BMwEBAwICBQIBASoCCAHuAQIBBAEAAQAQEBAAAgAB4gGVBQADAQIF +BCgDBAGlAgAEQQUAAk8ERgsxBHsBNg8pAQICCgMxBAICBwE9AyQFAQg+AQwCNAkBAQgEAgFfAwIE +BgECAZ0BAwgVAjkCAQEBAQwBCQEOBwMFQwECBgEBAgEBAwQDAQEOAlUIAgMBARcBUQECBgEBAgEB +AgEC6wECBAYCAQIbAlUIAgEBAmoBAQECCGUBAQECBAEFAAkBAvUBCgQEAZAEAgIEASAKKAYCBAgB +CQYCAy4NAQIABwEGAQFSFgIHAQIBAnoGAwEBAgEHAQFIAgMBAQEAAgsCNAUFAxcBAAEGDwAMAwMA +BTsHAAE/BFEBCwIAAgAuAhcABQMGCAgCBx4ElAMANwQyCAEOARYFAQ8ABwERAgcBAgEFZAGgBwAB +PQQABP4CAAdtBwBggPAAYXNzZXJ0aW9uIGZhaWxlZDogZWRlbHRhID49IDBsaWJyYXJ5L2NvcmUv +c3JjL251bS9kaXlfZmxvYXQucnMAAABsKBAAIQAAAEwAAAAJAAAAbCgQACEAAABOAAAACQAAAMFv +8oYjAAAAge+shVtBbS3uBAAAAR9qv2TtOG7tl6fa9Pk/6QNPGAABPpUuCZnfA/04FQ8v5HQj7PXP +0wjcBMTasM28GX8zpgMmH+lOAgAAAXwumFuH075yn9nYhy8VEsZQ3mtwbkrPD9iV1W5xsiawZsat +JDYVHVrTQjwOVP9jwHNVzBfv+WXyKLxV98fcgNztbvTO79xf91MFAGxpYnJhcnkvY29yZS9zcmMv +bnVtL2ZsdDJkZWMvc3RyYXRlZ3kvZHJhZ29uLnJzYXNzZXJ0aW9uIGZhaWxlZDogZC5tYW50ID4g +MABMKRAALwAAAHYAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogZC5taW51cyA+IDAAAABMKRAALwAA +AHcAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogZC5wbHVzID4gMEwpEAAvAAAAeAAAAAUAAABhc3Nl +cnRpb24gZmFpbGVkOiBidWYubGVuKCkgPj0gTUFYX1NJR19ESUdJVFMAAABMKRAALwAAAHsAAAAF +AAAATCkQAC8AAADCAAAACQAAAEwpEAAvAAAA+wAAAA0AAABMKRAALwAAAAIBAAASAAAAYXNzZXJ0 +aW9uIGZhaWxlZDogZC5tYW50LmNoZWNrZWRfc3ViKGQubWludXMpLmlzX3NvbWUoKQBMKRAALwAA +AHoAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogZC5tYW50LmNoZWNrZWRfYWRkKGQucGx1cykuaXNf +c29tZSgpAABMKRAALwAAAHkAAAAFAAAATCkQAC8AAAALAQAABQAAAEwpEAAvAAAADAEAAAUAAABM +KRAALwAAAA0BAAAFAAAATCkQAC8AAAByAQAAJAAAAEwpEAAvAAAAdwEAAC8AAABMKRAALwAAAIQB +AAASAAAATCkQAC8AAABmAQAADQAAAEwpEAAvAAAATAEAACIAAABMKRAALwAAAA8BAAAFAAAATCkQ +AC8AAAAOAQAABQAAAAAAAADfRRo9A88a5sH7zP4AAAAAysaaxxf+cKvc+9T+AAAAAE/cvL78sXf/ +9vvc/gAAAAAM1mtB75FWvhH85P4AAAAAPPx/kK0f0I0s/Oz+AAAAAIOaVTEoXFHTRvz0/gAAAAC1 +yaatj6xxnWH8/P4AAAAAy4vuI3cinOp7/AT/AAAAAG1TeECRScyulvwM/wAAAABXzrZdeRI8grH8 +FP8AAAAAN1b7TTaUEMLL/Bz/AAAAAE+YSDhv6paQ5vwk/wAAAADHOoIly4V01wD9LP8AAAAA9Je/ +l83PhqAb/TT/AAAAAOWsKheYCjTvNf08/wAAAACOsjUq+2c4slD9RP8AAAAAOz/G0t/UyIRr/Uz/ +AAAAALrN0xonRN3Fhf1U/wAAAACWySW7zp9rk6D9XP8AAAAAhKVifSRsrNu6/WT/AAAAAPbaXw1Y +Zquj1f1s/wAAAAAm8cPek/ji8+/9dP8AAAAAuID/qqittbUK/nz/AAAAAItKfGwFX2KHJf6E/wAA +AABTMME0YP+8yT/+jP8AAAAAVSa6kYyFTpZa/pT/AAAAAL1+KXAkd/nfdP6c/wAAAACPuOW4n73f +po/+pP8AAAAAlH10iM9fqfip/qz/AAAAAM+bqI+TcES5xP60/wAAAABrFQ+/+PAIit/+vP8AAAAA +tjExZVUlsM35/sT/AAAAAKx/e9DG4j+ZFP/M/wAAAAAGOysqxBBc5C7/1P8AAAAA05JzaZkkJKpJ +/9z/AAAAAA7KAIPytYf9Y//k/wAAAADrGhGSZAjlvH7/7P8AAAAAzIhQbwnMvIyZ//T/AAAAACxl +GeJYF7fRs//8/wBBntzAAAsFQJzO/wQAQazcwAALmSQQpdTo6P8MAAAAAAAAAGKsxet4rQMAFAAA +AAAAhAmU+Hg5P4EeABwAAAAAALMVB8l7zpfAOAAkAAAAAABwXOp7zjJ+j1MALAAAAAAAaIDpq6Q4 +0tVtADQAAAAAAEUimhcmJ0+fiAA8AAAAAAAn+8TUMaJj7aIARAAAAAAAqK3IjDhl3rC9AEwAAAAA +ANtlqxqOCMeD2ABUAAAAAACaHXFC+R1dxPIAXAAAAAAAWOcbpixpTZINAWQAAAAAAOqNcBpk7gHa +JwFsAAAAAABKd++amaNtokIBdAAAAAAAhWt9tHt4CfJcAXwAAAAAAHcY3Xmh5FS0dwGEAAAAAADC +xZtbkoZbhpIBjAAAAAAAPV2WyMVTNcisAZQAAAAAALOgl/pctCqVxwGcAAAAAADjX6CZvZ9G3uEB +pAAAAAAAJYw52zTCm6X8AawAAAAAAFyfmKNymsb2FgK0AAAAAADOvulUU7/ctzECvAAAAAAA4kEi +8hfz/IhMAsQAAAAAAKV4XNObziDMZgLMAAAAAADfUyF781oWmIEC1AAAAAAAOjAfl9y1oOKbAtwA +AAAAAJaz41xT0dmotgLkAAAAAAA8RKek2Xyb+9AC7AAAAAAAEESkp0xMdrvrAvQAAAAAABqcQLbv +jquLBgP8AAAAAAAshFemEO8f0CADBAEAAAAAKTGR6eWkEJs7AwwBAAAAAJ0MnKH7mxDnVQMUAQAA +AAAp9Dti2SAorHADHAEAAAAAhc+nel5LRICLAyQBAAAAAC3drANA5CG/pQMsAQAAAACP/0ReL5xn +jsADNAEAAAAAQbiMnJ0XM9TaAzwBAAAAAKkb47SS2xme9QNEAQAAAADZd9+6br+W6w8ETAEAAAAA +bGlicmFyeS9jb3JlL3NyYy9udW0vZmx0MmRlYy9zdHJhdGVneS9ncmlzdS5ycwAAuDAQAC4AAAB9 +AAAAFQAAALgwEAAuAAAAqQAAAAUAAAC4MBAALgAAAKoAAAAFAAAAuDAQAC4AAACrAAAABQAAALgw +EAAuAAAArgAAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBkLm1hbnQgKyBkLnBsdXMgPCAoMSA8PCA2 +MSkAAAC4MBAALgAAAK8AAAAFAAAAuDAQAC4AAAAKAQAAEQAAALgwEAAuAAAADQEAAAkAAAC4MBAA +LgAAAEABAAAJAAAAuDAQAC4AAACtAAAABQAAALgwEAAuAAAArAAAAAUAAABhc3NlcnRpb24gZmFp +bGVkOiAhYnVmLmlzX2VtcHR5KCkAAAC4MBAALgAAANwBAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDog +ZC5tYW50IDwgKDEgPDwgNjEpuDAQAC4AAADdAQAABQAAALgwEAAuAAAA3gEAAAUAAAABAAAACgAA +AGQAAADoAwAAECcAAKCGAQBAQg8AgJaYAADh9QUAypo7uDAQAC4AAAAzAgAAEQAAALgwEAAuAAAA +NgIAAAkAAAC4MBAALgAAAGwCAAAJAAAAuDAQAC4AAADjAgAAJgAAALgwEAAuAAAA7wIAACYAAAC4 +MBAALgAAAMwCAAAmAAAAbGlicmFyeS9jb3JlL3NyYy9udW0vZmx0MmRlYy9tb2QucnMAyDIQACMA +AAC7AAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGJ1ZlswXSA+IGInMCcAyDIQACMAAAC8AAAABQAA +AGFzc2VydGlvbiBmYWlsZWQ6IHBhcnRzLmxlbigpID49IDQAAMgyEAAjAAAAvQAAAAUAAAAuMC4t +K05hTmluZjBhc3NlcnRpb24gZmFpbGVkOiBidWYubGVuKCkgPj0gbWF4bGVuAAAAyDIQACMAAAB+ +AgAADQAAACkuLjAxMjM0NTY3ODlhYmNkZWZCb3Jyb3dNdXRFcnJvcmFscmVhZHkgYm9ycm93ZWQ6 +IADFMxAAEgAAAGNhbGxlZCBgT3B0aW9uOjp1bndyYXAoKWAgb24gYSBgTm9uZWAgdmFsdWVpbmRl +eCBvdXQgb2YgYm91bmRzOiB0aGUgbGVuIGlzICBidXQgdGhlIGluZGV4IGlzIAAAAAs0EAAgAAAA +KzQQABIAAAAAAAAABAAAAAQAAABkAAAAPT0hPW1hdGNoZXNhc3NlcnRpb24gYGxlZnQgIHJpZ2h0 +YCBmYWlsZWQKICBsZWZ0OiAKIHJpZ2h0OiAAazQQABAAAAB7NBAAFwAAAJI0EAAJAAAAIHJpZ2h0 +YCBmYWlsZWQ6IAogIGxlZnQ6IAAAAGs0EAAQAAAAtDQQABAAAADENBAACQAAAJI0EAAJAAAAOiAA +AAEAAAAAAAAA8DQQAAIAAAAAAAAADAAAAAQAAABlAAAAZgAAAGcAAAAgICAgLAooKAosMHgwMDAx +MDIwMzA0MDUwNjA3MDgwOTEwMTExMjEzMTQxNTE2MTcxODE5MjAyMTIyMjMyNDI1MjYyNzI4Mjkz +MDMxMzIzMzM0MzUzNjM3MzgzOTQwNDE0MjQzNDQ0NTQ2NDc0ODQ5NTA1MTUyNTM1NDU1NTY1NzU4 +NTk2MDYxNjI2MzY0NjU2NjY3Njg2OTcwNzE3MjczNzQ3NTc2Nzc3ODc5ODA4MTgyODM4NDg1ODY4 +Nzg4ODk5MDkxOTI5Mzk0OTU5Njk3OTg5OTAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw +MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDBsaWJyYXJ5L2NvcmUvc3JjL2ZtdC9tb2Qu +cnNmYWxzZXRydWUwNhAAGwAAANgKAAAmAAAAMDYQABsAAADhCgAAGgAAAGxpYnJhcnkvY29yZS9z +cmMvc3RyL21vZC5yc1suLi5dYmVnaW4gPD0gZW5kICggPD0gKSB3aGVuIHNsaWNpbmcgYGAAlDYQ +AA4AAACiNhAABAAAAKY2EAAQAAAAtjYQAAEAAABieXRlIGluZGV4ICBpcyBub3QgYSBjaGFyIGJv +dW5kYXJ5OyBpdCBpcyBpbnNpZGUgIChieXRlcyApIG9mIGAA2DYQAAsAAADjNhAAJgAAAAk3EAAI +AAAAETcQAAYAAAC2NhAAAQAAACBpcyBvdXQgb2YgYm91bmRzIG9mIGAAANg2EAALAAAAQDcQABYA +AAC2NhAAAQAAAHQ2EAAbAAAAnAEAACwAAABsaWJyYXJ5L2NvcmUvc3JjL3VuaWNvZGUvcHJpbnRh +YmxlLnJzAAAAgDcQACUAAAAaAAAANgAAAIA3EAAlAAAACgAAACsAAAAABgEBAwEEAgUHBwIICAkC +CgULAg4EEAERAhIFExwUARUCFwIZDRwFHQgfASQBagRrAq8DsQK8As8C0QLUDNUJ1gLXAtoB4AXh +AucE6ALuIPAE+AL6BPsBDCc7Pk5Pj56en3uLk5aisrqGsQYHCTY9Plbz0NEEFBg2N1ZXf6qur701 +4BKHiY6eBA0OERIpMTQ6RUZJSk5PZGWKjI2PtsHDxMbL1ly2txscBwgKCxQXNjk6qKnY2Qk3kJGo +Bwo7PmZpj5IRb1+/7u9aYvT8/1NUmpsuLycoVZ2goaOkp6iturzEBgsMFR06P0VRpqfMzaAHGRoi +JT4/5+zv/8XGBCAjJSYoMzg6SEpMUFNVVlhaXF5gY2Vma3N4fX+KpKqvsMDQrq9ub93ek14iewUD +BC0DZgMBLy6Agh0DMQ8cBCQJHgUrBUQEDiqAqgYkBCQEKAg0C04DNAyBNwkWCggYO0U5A2MICTAW +BSEDGwUBQDgESwUvBAoHCQdAICcEDAk2AzoFGgcEDAdQSTczDTMHLggKBiYDHQgCgNBSEAM3LAgq +FhomHBQXCU4EJAlEDRkHCgZICCcJdQtCPioGOwUKBlEGAQUQAwULWQgCHWIeSAgKgKZeIkULCgYN +EzoGCgYUHCwEF4C5PGRTDEgJCkZFG0gIUw1JBwqAtiIOCgZGCh0DR0k3Aw4ICgY5BwqBNhkHOwMd +VQEPMg2Dm2Z1C4DEikxjDYQwEBYKj5sFgkeauTqGxoI5ByoEXAYmCkYKKAUTgbA6gMZbZUsEOQcR +QAULAg6X+AiE1ikKoueBMw8BHQYOBAiBjIkEawUNAwkHEI9ggPoGgbRMRwl0PID2CnMIcBVGehQM +FAxXCRmAh4FHA4VCDxWEUB8GBoDVKwU+IQFwLQMaBAKBQB8ROgUBgdAqgNYrBAGB4ID3KUwECgQC +gxFETD2AwjwGAQRVBRs0AoEOLARkDFYKgK44HQ0sBAkHAg4GgJqD2AQRAw0DdwRfBgwEAQ8MBDgI +CgYoCCwEAj6BVAwdAwoFOAccBgkHgPqEBgABAwUFBgYCBwYIBwkRChwLGQwaDRAODA8EEAMSEhMJ +FgEXBBgBGQMaBxsBHAIfFiADKwMtCy4BMAQxAjIBpwSpAqoEqwj6AvsF/QL+A/8JrXh5i42iMFdY +i4yQHN0OD0tM+/wuLz9cXV/ihI2OkZKpsbq7xcbJyt7k5f8ABBESKTE0Nzo7PUlKXYSOkqmxtLq7 +xsrOz+TlAAQNDhESKTE0OjtFRklKXmRlhJGbncnOzw0RKTo7RUlXW1xeX2RljZGptLq7xcnf5OXw +DRFFSWRlgISyvL6/1dfw8YOFi6Smvr/Fx8/a20iYvc3Gzs9JTk9XWV5fiY6Psba3v8HGx9cRFhdb +XPb3/v+AbXHe3w4fbm8cHV99fq6vTbu8FhceH0ZHTk9YWlxefn+1xdTV3PDx9XJzj3R1liYuL6ev +t7/Hz9ffmgBAl5gwjx/Oz9LUzv9OT1pbBwgPECcv7u9ubzc9P0JFkJFTZ3XIydDR2Nnn/v8AIF8i +gt8EgkQIGwQGEYGsDoCrBR8IgRwDGQgBBC8ENAQHAwEHBgcRClAPEgdVBwMEHAoJAwgDBwMCAwMD +DAQFAwsGAQ4VBU4HGwdXBwIGFwxQBEMDLQMBBBEGDww6BB0lXyBtBGolgMgFgrADGgaC/QNZBxYJ +GAkUDBQMagYKBhoGWQcrBUYKLAQMBAEDMQssBBoGCwOArAYKBi8xgPQIPAMPAz4FOAgrBYL/ERgI +LxEtAyEPIQ+AjASCmhYLFYiUBS8FOwcCDhgJgL4idAyA1hqBEAWA4QnyngM3CYFcFIC4CIDdFTsD +CgY4CEYIDAZ0Cx4DWgRZCYCDGBwKFglMBICKBqukDBcEMaEEgdomBwwFBYCmEIH1BwEgKgZMBICN +BIC+AxsDDw1saWJyYXJ5L2NvcmUvc3JjL3VuaWNvZGUvdW5pY29kZV9kYXRhLnJzAAAAcT0QACgA +AABNAAAAKAAAAHE9EAAoAAAAWQAAABYAAABsaWJyYXJ5L2NvcmUvc3JjL251bS9iaWdudW0ucnMA +ALw9EAAeAAAAqwEAAAEAAABhc3NlcnRpb24gZmFpbGVkOiBub2JvcnJvd2Fzc2VydGlvbiBmYWls +ZWQ6IGRpZ2l0cyA8IDQwYXNzZXJ0aW9uIGZhaWxlZDogb3RoZXIgPiAwYXR0ZW1wdCB0byBkaXZp +ZGUgYnkgemVybwA+PhAAGQAAAGF0dGVtcHQgdG8gY2FsY3VsYXRlIHRoZSByZW1haW5kZXIgd2l0 +aCBhIGRpdmlzb3Igb2YgemVybwAAAGA+EAA5AAAAcmFuZ2Ugc3RhcnQgaW5kZXggIG91dCBvZiBy +YW5nZSBmb3Igc2xpY2Ugb2YgbGVuZ3RoIKQ+EAASAAAAtj4QACIAAAByYW5nZSBlbmQgaW5kZXgg +6D4QABAAAAC2PhAAIgAAAHNsaWNlIGluZGV4IHN0YXJ0cyBhdCAgYnV0IGVuZHMgYXQgAAg/EAAW +AAAAHj8QAA0AAABjb3B5X2Zyb21fc2xpY2U6IHNvdXJjZSBzbGljZSBsZW5ndGggKCkgZG9lcyBu +b3QgbWF0Y2ggZGVzdGluYXRpb24gc2xpY2UgbGVuZ3RoICgAAAA8PxAAJgAAAGI/EAArAAAApDMQ +AAEAAAAAAwAAgwQgAJEFYABdE6AAEhcgHwwgYB/vLCArKjCgK2+mYCwCqOAsHvvgLQD+IDae/2A2 +/QHhNgEKITckDeE3qw5hOS8Y4TkwHOFK8x7hTkA0oVIeYeFT8GphVE9v4VSdvGFVAM9hVmXRoVYA +2iFXAOChWK7iIVrs5OFb0OhhXCAA7lzwAX9dYDQQAGI0EABkNBAAAgAAAAIAAAAHAEHggMEACwFH +AHAJcHJvZHVjZXJzAghsYW5ndWFnZQEEUnVzdAAMcHJvY2Vzc2VkLWJ5AwVydXN0Yx0xLjg3LjAg +KDE3MDY3ZTlhYyAyMDI1LTA1LTA5KQZ3YWxydXMGMC4yMy4zDHdhc20tYmluZGdlbgcwLjIuMTAw +AGsPdGFyZ2V0X2ZlYXR1cmVzBisPbXV0YWJsZS1nbG9iYWxzKxNub250cmFwcGluZy1mcHRvaW50 +KwtidWxrLW1lbW9yeSsIc2lnbi1leHQrD3JlZmVyZW5jZS10eXBlcysKbXVsdGl2YWx1ZQ== `) .trim() .replaceAll("\n", ""); diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.d.ts b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.d.ts index 1535d5a6fb..f065297e0d 100644 --- a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.d.ts +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.d.ts @@ -6,6 +6,8 @@ export const chunker_new: (a: number) => number; export const chunker_add_data: (a: number, b: number, c: number) => [number, number, number]; export const chunker_finish: (a: number) => [number, number, number]; export const compute_xorb_hash: (a: any) => [number, number, number, number]; +export const compute_file_hash: (a: any) => [number, number, number, number]; +export const compute_verification_hash: (a: number, b: number) => [number, number, number, number]; export const __wbindgen_malloc: (a: number, b: number) => number; export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number; export const __wbindgen_exn_store: (a: number) => void; From bf8ae1ce07614dcca5bddc17700a0ca1f225a9c5 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Mon, 21 Jul 2025 15:36:15 +0200 Subject: [PATCH 10/43] fixup! update wasm bindings --- packages/hub/src/utils/createXorbs.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/packages/hub/src/utils/createXorbs.ts b/packages/hub/src/utils/createXorbs.ts index 897c9ba084..4c6c38988d 100644 --- a/packages/hub/src/utils/createXorbs.ts +++ b/packages/hub/src/utils/createXorbs.ts @@ -124,7 +124,7 @@ export async function* createXorbs(fileSources: AsyncGenerator): AsyncGene lastRep.endOffset = xorbOffset - lastRep.offset; lastRep.length += chunk.length; } else { - lastRep.rangeHash = chunkModule.compute_range_verification_hash( + lastRep.rangeHash = chunkModule.compute_verification_hash( fileChunks.slice(currentChunkRangeBeginning, -1).map((x) => x.hash, -1) ); fileRepresentation.push({ @@ -167,7 +167,7 @@ export async function* createXorbs(fileSources: AsyncGenerator): AsyncGene const lastRep = fileRepresentation.at(-1); if (lastRep) { - lastRep.rangeHash = chunkModule.compute_range_verification_hash( + lastRep.rangeHash = chunkModule.compute_verification_hash( fileChunks.slice(currentChunkRangeBeginning).map((x) => x.hash) ); } From 70f0a0ecf229244c2075ffa3161b2482e30bbe83 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Mon, 21 Jul 2025 15:38:28 +0200 Subject: [PATCH 11/43] no need to compute shard hash client-side --- packages/hub/src/vendor/xet-chunk/chunker_wasm.ts | 8 +------- packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts | 1 - 2 files changed, 1 insertion(+), 8 deletions(-) diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts b/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts index 44caf9640e..4f5419f599 100644 --- a/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts @@ -55,13 +55,7 @@ init(); export { init }; -export { - compute_xorb_hash, - compute_file_hash, - Chunker, - compute_verification_hash, - compute_shard_hash, -} from "./chunker_wasm_bg.js"; +export { compute_xorb_hash, compute_file_hash, Chunker, compute_verification_hash } from "./chunker_wasm_bg.js"; // const exports = WebAssembly.Module.exports(wasmModule).map((item) => item.name); diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts index c9e8495c26..b8c52930f8 100644 --- a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts @@ -1,7 +1,6 @@ /* tslint:disable */ /* eslint-disable */ export function compute_xorb_hash(chunks_array: Array<{ hash: string; length: number }>): string; -export function compute_shard_hash(shard: Uint8Array): string; export function compute_verification_hash(chunkHashes: string[]): string; export function compute_file_hash(chunks_array: Array<{ hash: string; length: number }>): string; export class Chunker { From 431949b1d6371d529df1aac94b0ff0c5d9397700 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Wed, 23 Jul 2025 21:27:01 +0200 Subject: [PATCH 12/43] no need for shard hash --- packages/hub/src/utils/uploadShards.ts | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/packages/hub/src/utils/uploadShards.ts b/packages/hub/src/utils/uploadShards.ts index c76c98547c..e8a3b79b78 100644 --- a/packages/hub/src/utils/uploadShards.ts +++ b/packages/hub/src/utils/uploadShards.ts @@ -322,9 +322,8 @@ async function uploadXorb(xorb: { hash: string; xorb: Uint8Array }, params: Uplo async function uploadShard(shard: Uint8Array, params: UploadShardsParams) { const token = await getAccessToken(params); - const shardHash = "0".repeat(64); - const resp = await params.customFetch(`${token.casUrl}/shard/default-merkledb/${shardHash}`, { + const resp = await params.customFetch(`${token.casUrl}/v1/shard/default-merkledb`, { method: "PUT", body: shard, headers: { From adbe363966fc870df0625de90f2f01c242d53040 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Thu, 24 Jul 2025 09:59:17 +0200 Subject: [PATCH 13/43] add va prefix to xorb too --- packages/hub/src/utils/uploadShards.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/hub/src/utils/uploadShards.ts b/packages/hub/src/utils/uploadShards.ts index e8a3b79b78..327cb468ad 100644 --- a/packages/hub/src/utils/uploadShards.ts +++ b/packages/hub/src/utils/uploadShards.ts @@ -307,7 +307,7 @@ function writeHashToArray(hash: string, array: Uint8Array, offset: number) { async function uploadXorb(xorb: { hash: string; xorb: Uint8Array }, params: UploadShardsParams) { const token = await getAccessToken(params); - const resp = await params.customFetch(`${token.casUrl}/xorb/default/${xorb.hash}`, { + const resp = await params.customFetch(`${token.casUrl}/v1/xorb/default/${xorb.hash}`, { method: "PUT", body: xorb.xorb, headers: { From 2f9d4a076ce453a7ad21d06592822d4308088737 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Thu, 24 Jul 2025 10:24:50 +0200 Subject: [PATCH 14/43] progress events for uploading xorbs --- packages/hub/src/utils/createXorbs.ts | 27 ++++++++++++++++++-------- packages/hub/src/utils/uploadShards.ts | 16 ++++++++++----- 2 files changed, 30 insertions(+), 13 deletions(-) diff --git a/packages/hub/src/utils/createXorbs.ts b/packages/hub/src/utils/createXorbs.ts index 4c6c38988d..766a494900 100644 --- a/packages/hub/src/utils/createXorbs.ts +++ b/packages/hub/src/utils/createXorbs.ts @@ -13,16 +13,23 @@ const MAX_CHUNK_SIZE = 2 * TARGET_CHUNK_SIZE; const XORB_SIZE = 64 * 1024 * 1024; const MAX_XORB_CHUNKS = 8 * 1024; -export async function* createXorbs(fileSources: AsyncGenerator): AsyncGenerator< +export async function* createXorbs( + fileSources: AsyncGenerator<{ content: Blob; path: string; sha256: string }> +): AsyncGenerator< | { type: "xorb"; xorb: Uint8Array; hash: string; id: number; chunks: Array<{ hash: string; length: number; offset: number }>; + files: Array<{ + path: string; + progress: number; + }>; } | { type: "file"; + path: string; hash: string; sha256: string; representation: Array<{ @@ -38,7 +45,6 @@ export async function* createXorbs(fileSources: AsyncGenerator): AsyncGene undefined > { const chunkModule = await import("../vendor/xet-chunk/chunker_wasm"); - const sha256Module = await import("../vendor/hash-wasm/sha256-wrapper"); let xorbId = 0; await chunkModule.init(); @@ -47,13 +53,15 @@ export async function* createXorbs(fileSources: AsyncGenerator): AsyncGene let xorb = new Uint8Array(XORB_SIZE); let xorbOffset = 0; let xorbChunks = Array<{ hash: string; length: number; offset: number }>(); + let xorbFiles: Record = {}; try { for await (const fileSource of fileSources) { const initialXorbOffset = xorbOffset; const sourceChunks: Array = []; - const reader = fileSource.stream().getReader(); + const reader = fileSource.content.stream().getReader(); + let processedBytes = 0; const fileChunks: Array<{ hash: string; length: number }> = []; let currentChunkRangeBeginning = 0; const fileRepresentation: Array<{ @@ -64,9 +72,6 @@ export async function* createXorbs(fileSources: AsyncGenerator): AsyncGene rangeHash: string; }> = []; - const sha256 = await sha256Module.createSHA256(); - sha256.init(); - const addChunks = function* (chunks: Array<{ hash: string; length: number }>) { for (const chunk of chunks) { let chunkOffset = xorbOffset; @@ -98,11 +103,13 @@ export async function* createXorbs(fileSources: AsyncGenerator): AsyncGene hash: chunkModule.compute_xorb_hash(xorbChunks), chunks: [...xorbChunks], id: xorbId, + files: Object.entries(xorbFiles).map(([path, progress]) => ({ path, progress })), }; xorbId++; xorb = new Uint8Array(XORB_SIZE); chunkOffset = 0; xorbOffset = writeChunk(xorb, 0, chunkToCopy); + xorbFiles = {}; if (xorbOffset === 0) { throw new Error("Failed to write chunk into xorb"); @@ -138,6 +145,7 @@ export async function* createXorbs(fileSources: AsyncGenerator): AsyncGene } } xorbChunks.push({ hash: chunk.hash, length: chunk.length, offset: chunkOffset }); + xorbFiles[fileSource.path] = processedBytes / fileSource.content.size; if (xorbChunks.length >= MAX_XORB_CHUNKS) { yield { type: "xorb" as const, @@ -145,10 +153,12 @@ export async function* createXorbs(fileSources: AsyncGenerator): AsyncGene hash: chunkModule.compute_xorb_hash(xorbChunks), chunks: [...xorbChunks], id: xorbId, + files: Object.entries(xorbFiles).map(([path, progress]) => ({ path, progress })), }; xorbId++; xorbOffset = 0; xorbChunks = []; + xorbFiles = {}; xorb = new Uint8Array(XORB_SIZE); } } @@ -160,8 +170,8 @@ export async function* createXorbs(fileSources: AsyncGenerator): AsyncGene yield* addChunks(chunker.finish()); break; } + processedBytes += value.length; sourceChunks.push(value); - sha256.update(value); yield* addChunks(chunker.add_data(value)); } @@ -174,9 +184,10 @@ export async function* createXorbs(fileSources: AsyncGenerator): AsyncGene yield { type: "file" as const, + path: fileSource.path, hash: chunkModule.compute_file_hash(fileChunks), - sha256: sha256.digest("hex"), representation: fileRepresentation, + sha256: fileSource.sha256, }; } } finally { diff --git a/packages/hub/src/utils/uploadShards.ts b/packages/hub/src/utils/uploadShards.ts index 327cb468ad..dbd151eb42 100644 --- a/packages/hub/src/utils/uploadShards.ts +++ b/packages/hub/src/utils/uploadShards.ts @@ -63,7 +63,12 @@ interface UploadShardsParams { /** * Outputs the file sha256 after their xorbs/shards have been uploaded. */ -export async function uploadShards(source: AsyncGenerator, params: UploadShardsParams): Promise { +export async function* uploadShards( + source: AsyncGenerator<{ content: Blob; path: string; sha256: string }>, + params: UploadShardsParams +): AsyncGenerator< + { type: "file"; path: string; sha256: string } | { type: "fileProgress"; path: string; progress: number } +> { const xorbHashes: Array = []; const fileInfoSection = new Uint8Array(Math.floor(SHARD_MAX_SIZE - SHARD_HEADER_SIZE - SHARD_FOOTER_SIZE) / 2); @@ -76,7 +81,6 @@ export async function uploadShards(source: AsyncGenerator, params: UploadS let xorbTotalSize = 0n; let fileTotalSize = 0n; let xorbTotalUnpackedSize = 0n; - const fileShas: Array = []; for await (const output of createXorbs(source)) { switch (output.type) { @@ -111,10 +115,14 @@ export async function uploadShards(source: AsyncGenerator, params: UploadS await uploadXorb(output, params); //^ Todo: queue it and do not await it + + for (const file of output.files) { + yield { type: "fileProgress", path: file.path, progress: file.progress }; + } break; } case "file": { - fileShas.push(output.sha256); // note: if yielding instead, maybe wait until shard is uploaded. + yield { type: "file", path: output.path, sha256: output.sha256 }; // Maybe wait until shard is uploaded before yielding. // todo: handle out of bounds @@ -292,8 +300,6 @@ export async function uploadShards(source: AsyncGenerator, params: UploadS if (xorbViewOffset || fileViewOffset) { await uploadShard(createShard(), params); } - - return fileShas; } // Todo: switch from hex to non-hex when WASM switches. For now consider hash is hex From a13da79a7e80f47d0a49145df512680a1b71fc02 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Thu, 24 Jul 2025 10:34:38 +0200 Subject: [PATCH 15/43] commit leftover xorb after all chunks have been processed --- packages/hub/src/utils/createXorbs.ts | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/packages/hub/src/utils/createXorbs.ts b/packages/hub/src/utils/createXorbs.ts index 766a494900..716ec723d9 100644 --- a/packages/hub/src/utils/createXorbs.ts +++ b/packages/hub/src/utils/createXorbs.ts @@ -190,6 +190,17 @@ export async function* createXorbs( sha256: fileSource.sha256, }; } + + if (xorbOffset > 0) { + yield { + type: "xorb" as const, + xorb: xorb.subarray(0, xorbOffset), + hash: chunkModule.compute_xorb_hash(xorbChunks), + chunks: [...xorbChunks], + id: xorbId, + files: Object.entries(xorbFiles).map(([path, progress]) => ({ path, progress })), + }; + } } finally { chunker.free(); // ^ is this really needed ? From 3cbde5ebb4c62fe89fb8ff65b3451b6e68811867 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Thu, 24 Jul 2025 10:43:09 +0200 Subject: [PATCH 16/43] integrate xet upload in commit function --- packages/hub/src/lib/commit.ts | 370 +++++++++++++++---------- packages/hub/src/utils/createXorbs.ts | 12 +- packages/hub/src/utils/uploadShards.ts | 8 +- 3 files changed, 230 insertions(+), 160 deletions(-) diff --git a/packages/hub/src/lib/commit.ts b/packages/hub/src/lib/commit.ts index a7acb3bcbe..bfcf73e92c 100644 --- a/packages/hub/src/lib/commit.ts +++ b/packages/hub/src/lib/commit.ts @@ -22,6 +22,7 @@ import { eventToGenerator } from "../utils/eventToGenerator"; import { base64FromBytes } from "../utils/base64FromBytes"; import { isFrontend } from "../utils/isFrontend"; import { createBlobs } from "../utils/createBlobs"; +import { uploadShards } from "../utils/uploadShards"; const CONCURRENT_SHAS = 5; const CONCURRENT_LFS_UPLOADS = 5; @@ -88,6 +89,10 @@ export type CommitParams = { fetch?: typeof fetch; abortSignal?: AbortSignal; // Credentials are optional due to custom fetch functions or cookie auth + /** + * @deprecated Not yet ready for production use + */ + xet?: boolean; } & Partial; export interface CommitOutput { @@ -293,178 +298,243 @@ export async function* commitIter(params: CommitParams): AsyncGenerator [shas[i], op])); - yield* eventToGenerator((yieldCallback, returnCallback, rejectCallback) => { - return promisesQueueStreaming( - json.objects.map((obj) => async () => { - const op = shaToOperation.get(obj.oid); - - if (!op) { - throw new InvalidApiResponseFormatError("Unrequested object ID in response"); - } + if (params.xet) { + // First get all the files that are already uploaded out of the way + for (const obj of json.objects) { + const op = shaToOperation.get(obj.oid); + if (!op) { + throw new InvalidApiResponseFormatError("Unrequested object ID in response"); + } - abortSignal?.throwIfAborted(); + if (obj.error) { + const errorMessage = `Error while doing LFS batch call for ${operations[shas.indexOf(obj.oid)].path}: ${ + obj.error.message + }${batchRequestId ? ` - Request ID: ${batchRequestId}` : ""}`; + throw new HubApiError(res.url, obj.error.code, batchRequestId, errorMessage); + } - if (obj.error) { - const errorMessage = `Error while doing LFS batch call for ${operations[shas.indexOf(obj.oid)].path}: ${ - obj.error.message - }${batchRequestId ? ` - Request ID: ${batchRequestId}` : ""}`; - throw new HubApiError(res.url, obj.error.code, batchRequestId, errorMessage); - } - if (!obj.actions?.upload) { - // Already uploaded - yieldCallback({ - event: "fileProgress", - path: op.path, - progress: 1, - state: "uploading", - }); - return; - } - yieldCallback({ + if (!obj.actions?.upload) { + // Already uploaded + yield { event: "fileProgress", path: op.path, - progress: 0, + progress: 1, state: "uploading", - }); - const content = op.content; - const header = obj.actions.upload.header; - if (header?.chunk_size) { - const chunkSize = parseInt(header.chunk_size); - - // multipart upload - // parts are in upload.header['00001'] to upload.header['99999'] - - const completionUrl = obj.actions.upload.href; - const parts = Object.keys(header).filter((key) => /^[0-9]+$/.test(key)); + }; + } + } + for await (const event of uploadShards( + (async function* () { + for (const obj of json.objects) { + const op = shaToOperation.get(obj.oid); + if (!op || !obj.actions?.upload) { + continue; + } + abortSignal?.throwIfAborted(); - if (parts.length !== Math.ceil(content.size / chunkSize)) { - throw new Error("Invalid server response to upload large LFS file, wrong number of parts"); + yield { content: op.content, path: op.path, sha256: obj.oid }; + } + })(), + { + customFetch: params.fetch ?? fetch, + accessToken, + hubUrl: params.hubUrl ?? HUB_URL, + repo: repoId, + // todo: maybe leave empty if PR? + rev: params.branch ?? "main", + } + )) { + if (event.event === "file") { + yield { + event: "fileProgress", + path: event.path, + progress: 1, + state: "uploading", + }; + } else if (event.event === "fileProgress") { + yield { + event: "fileProgress", + path: event.path, + progress: event.progress, + state: "uploading", + }; + } + } + } else { + yield* eventToGenerator((yieldCallback, returnCallback, rejectCallback) => { + return promisesQueueStreaming( + json.objects.map((obj) => async () => { + const op = shaToOperation.get(obj.oid); + + if (!op) { + throw new InvalidApiResponseFormatError("Unrequested object ID in response"); } - const completeReq: ApiLfsCompleteMultipartRequest = { - oid: obj.oid, - parts: parts.map((part) => ({ - partNumber: +part, - etag: "", - })), - }; - - // Defined here so that it's not redefined at each iteration (and the caller can tell it's for the same file) - const progressCallback = (progress: number) => - yieldCallback({ event: "fileProgress", path: op.path, progress, state: "uploading" }); - - await promisesQueueStreaming( - parts.map((part) => async () => { - abortSignal?.throwIfAborted(); - - const index = parseInt(part) - 1; - const slice = content.slice(index * chunkSize, (index + 1) * chunkSize); - - const res = await (params.fetch ?? fetch)(header[part], { - method: "PUT", - /** Unfortunately, browsers don't support our inherited version of Blob in fetch calls */ - body: slice instanceof WebBlob && isFrontend ? await slice.arrayBuffer() : slice, - signal: abortSignal, - ...({ - progressHint: { - path: op.path, - part: index, - numParts: parts.length, - progressCallback, - }, - // eslint-disable-next-line @typescript-eslint/no-explicit-any - } as any), - }); + abortSignal?.throwIfAborted(); - if (!res.ok) { - throw await createApiError(res, { - requestId: batchRequestId, - message: `Error while uploading part ${part} of ${ - operations[shas.indexOf(obj.oid)].path - } to LFS storage`, + if (obj.error) { + const errorMessage = `Error while doing LFS batch call for ${operations[shas.indexOf(obj.oid)].path}: ${ + obj.error.message + }${batchRequestId ? ` - Request ID: ${batchRequestId}` : ""}`; + throw new HubApiError(res.url, obj.error.code, batchRequestId, errorMessage); + } + if (!obj.actions?.upload) { + // Already uploaded + yieldCallback({ + event: "fileProgress", + path: op.path, + progress: 1, + state: "uploading", + }); + return; + } + yieldCallback({ + event: "fileProgress", + path: op.path, + progress: 0, + state: "uploading", + }); + const content = op.content; + + const header = obj.actions.upload.header; + if (header?.chunk_size) { + const chunkSize = parseInt(header.chunk_size); + + // multipart upload + // parts are in upload.header['00001'] to upload.header['99999'] + + const completionUrl = obj.actions.upload.href; + const parts = Object.keys(header).filter((key) => /^[0-9]+$/.test(key)); + + if (parts.length !== Math.ceil(content.size / chunkSize)) { + throw new Error("Invalid server response to upload large LFS file, wrong number of parts"); + } + + const completeReq: ApiLfsCompleteMultipartRequest = { + oid: obj.oid, + parts: parts.map((part) => ({ + partNumber: +part, + etag: "", + })), + }; + + // Defined here so that it's not redefined at each iteration (and the caller can tell it's for the same file) + const progressCallback = (progress: number) => + yieldCallback({ event: "fileProgress", path: op.path, progress, state: "uploading" }); + + await promisesQueueStreaming( + parts.map((part) => async () => { + abortSignal?.throwIfAborted(); + + const index = parseInt(part) - 1; + const slice = content.slice(index * chunkSize, (index + 1) * chunkSize); + + const res = await (params.fetch ?? fetch)(header[part], { + method: "PUT", + /** Unfortunately, browsers don't support our inherited version of Blob in fetch calls */ + body: slice instanceof WebBlob && isFrontend ? await slice.arrayBuffer() : slice, + signal: abortSignal, + ...({ + progressHint: { + path: op.path, + part: index, + numParts: parts.length, + progressCallback, + }, + // eslint-disable-next-line @typescript-eslint/no-explicit-any + } as any), }); - } - const eTag = res.headers.get("ETag"); + if (!res.ok) { + throw await createApiError(res, { + requestId: batchRequestId, + message: `Error while uploading part ${part} of ${ + operations[shas.indexOf(obj.oid)].path + } to LFS storage`, + }); + } - if (!eTag) { - throw new Error("Cannot get ETag of part during multipart upload"); - } + const eTag = res.headers.get("ETag"); - completeReq.parts[Number(part) - 1].etag = eTag; - }), - MULTIPART_PARALLEL_UPLOAD - ); + if (!eTag) { + throw new Error("Cannot get ETag of part during multipart upload"); + } - abortSignal?.throwIfAborted(); + completeReq.parts[Number(part) - 1].etag = eTag; + }), + MULTIPART_PARALLEL_UPLOAD + ); - const res = await (params.fetch ?? fetch)(completionUrl, { - method: "POST", - body: JSON.stringify(completeReq), - headers: { - Accept: "application/vnd.git-lfs+json", - "Content-Type": "application/vnd.git-lfs+json", - }, - signal: abortSignal, - }); + abortSignal?.throwIfAborted(); - if (!res.ok) { - throw await createApiError(res, { - requestId: batchRequestId, - message: `Error completing multipart upload of ${ - operations[shas.indexOf(obj.oid)].path - } to LFS storage`, + const res = await (params.fetch ?? fetch)(completionUrl, { + method: "POST", + body: JSON.stringify(completeReq), + headers: { + Accept: "application/vnd.git-lfs+json", + "Content-Type": "application/vnd.git-lfs+json", + }, + signal: abortSignal, }); - } - yieldCallback({ - event: "fileProgress", - path: op.path, - progress: 1, - state: "uploading", - }); - } else { - const res = await (params.fetch ?? fetch)(obj.actions.upload.href, { - method: "PUT", - headers: { - ...(batchRequestId ? { "X-Request-Id": batchRequestId } : undefined), - }, - /** Unfortunately, browsers don't support our inherited version of Blob in fetch calls */ - body: content instanceof WebBlob && isFrontend ? await content.arrayBuffer() : content, - signal: abortSignal, - ...({ - progressHint: { - path: op.path, - progressCallback: (progress: number) => - yieldCallback({ - event: "fileProgress", - path: op.path, - progress, - state: "uploading", - }), + if (!res.ok) { + throw await createApiError(res, { + requestId: batchRequestId, + message: `Error completing multipart upload of ${ + operations[shas.indexOf(obj.oid)].path + } to LFS storage`, + }); + } + + yieldCallback({ + event: "fileProgress", + path: op.path, + progress: 1, + state: "uploading", + }); + } else { + const res = await (params.fetch ?? fetch)(obj.actions.upload.href, { + method: "PUT", + headers: { + ...(batchRequestId ? { "X-Request-Id": batchRequestId } : undefined), }, - // eslint-disable-next-line @typescript-eslint/no-explicit-any - } as any), - }); + /** Unfortunately, browsers don't support our inherited version of Blob in fetch calls */ + body: content instanceof WebBlob && isFrontend ? await content.arrayBuffer() : content, + signal: abortSignal, + ...({ + progressHint: { + path: op.path, + progressCallback: (progress: number) => + yieldCallback({ + event: "fileProgress", + path: op.path, + progress, + state: "uploading", + }), + }, + // eslint-disable-next-line @typescript-eslint/no-explicit-any + } as any), + }); - if (!res.ok) { - throw await createApiError(res, { - requestId: batchRequestId, - message: `Error while uploading ${operations[shas.indexOf(obj.oid)].path} to LFS storage`, + if (!res.ok) { + throw await createApiError(res, { + requestId: batchRequestId, + message: `Error while uploading ${operations[shas.indexOf(obj.oid)].path} to LFS storage`, + }); + } + + yieldCallback({ + event: "fileProgress", + path: op.path, + progress: 1, + state: "uploading", }); } - - yieldCallback({ - event: "fileProgress", - path: op.path, - progress: 1, - state: "uploading", - }); - } - }), - CONCURRENT_LFS_UPLOADS - ).then(returnCallback, rejectCallback); - }); + }), + CONCURRENT_LFS_UPLOADS + ).then(returnCallback, rejectCallback); + }); + } } abortSignal?.throwIfAborted(); diff --git a/packages/hub/src/utils/createXorbs.ts b/packages/hub/src/utils/createXorbs.ts index 716ec723d9..174991f23a 100644 --- a/packages/hub/src/utils/createXorbs.ts +++ b/packages/hub/src/utils/createXorbs.ts @@ -17,7 +17,7 @@ export async function* createXorbs( fileSources: AsyncGenerator<{ content: Blob; path: string; sha256: string }> ): AsyncGenerator< | { - type: "xorb"; + event: "xorb"; xorb: Uint8Array; hash: string; id: number; @@ -28,7 +28,7 @@ export async function* createXorbs( }>; } | { - type: "file"; + event: "file"; path: string; hash: string; sha256: string; @@ -98,7 +98,7 @@ export async function* createXorbs( if (xorbOffset === 0) { // Failure to write chunk, maybe because it went over xorb size limit yield { - type: "xorb" as const, + event: "xorb" as const, xorb: xorb.subarray(0, xorbOffset), hash: chunkModule.compute_xorb_hash(xorbChunks), chunks: [...xorbChunks], @@ -148,7 +148,7 @@ export async function* createXorbs( xorbFiles[fileSource.path] = processedBytes / fileSource.content.size; if (xorbChunks.length >= MAX_XORB_CHUNKS) { yield { - type: "xorb" as const, + event: "xorb" as const, xorb: xorb.subarray(0, xorbOffset), hash: chunkModule.compute_xorb_hash(xorbChunks), chunks: [...xorbChunks], @@ -183,7 +183,7 @@ export async function* createXorbs( } yield { - type: "file" as const, + event: "file" as const, path: fileSource.path, hash: chunkModule.compute_file_hash(fileChunks), representation: fileRepresentation, @@ -193,7 +193,7 @@ export async function* createXorbs( if (xorbOffset > 0) { yield { - type: "xorb" as const, + event: "xorb" as const, xorb: xorb.subarray(0, xorbOffset), hash: chunkModule.compute_xorb_hash(xorbChunks), chunks: [...xorbChunks], diff --git a/packages/hub/src/utils/uploadShards.ts b/packages/hub/src/utils/uploadShards.ts index dbd151eb42..d5c5ef5270 100644 --- a/packages/hub/src/utils/uploadShards.ts +++ b/packages/hub/src/utils/uploadShards.ts @@ -67,7 +67,7 @@ export async function* uploadShards( source: AsyncGenerator<{ content: Blob; path: string; sha256: string }>, params: UploadShardsParams ): AsyncGenerator< - { type: "file"; path: string; sha256: string } | { type: "fileProgress"; path: string; progress: number } + { event: "file"; path: string; sha256: string } | { event: "fileProgress"; path: string; progress: number } > { const xorbHashes: Array = []; @@ -83,7 +83,7 @@ export async function* uploadShards( let xorbTotalUnpackedSize = 0n; for await (const output of createXorbs(source)) { - switch (output.type) { + switch (output.event) { case "xorb": { xorbHashes.push(output.hash); @@ -117,12 +117,12 @@ export async function* uploadShards( //^ Todo: queue it and do not await it for (const file of output.files) { - yield { type: "fileProgress", path: file.path, progress: file.progress }; + yield { event: "fileProgress", path: file.path, progress: file.progress }; } break; } case "file": { - yield { type: "file", path: output.path, sha256: output.sha256 }; // Maybe wait until shard is uploaded before yielding. + yield { event: "file", path: output.path, sha256: output.sha256 }; // Maybe wait until shard is uploaded before yielding. // todo: handle out of bounds From 651f6c0e2d35f9103d018199304719465c5664e7 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Thu, 24 Jul 2025 16:27:12 +0200 Subject: [PATCH 17/43] add local dedup for xet uploads --- packages/hub/src/utils/createXorbs.ts | 117 ++++++++++++++++++++------ 1 file changed, 92 insertions(+), 25 deletions(-) diff --git a/packages/hub/src/utils/createXorbs.ts b/packages/hub/src/utils/createXorbs.ts index 174991f23a..a5fe3379c5 100644 --- a/packages/hub/src/utils/createXorbs.ts +++ b/packages/hub/src/utils/createXorbs.ts @@ -13,6 +13,15 @@ const MAX_CHUNK_SIZE = 2 * TARGET_CHUNK_SIZE; const XORB_SIZE = 64 * 1024 * 1024; const MAX_XORB_CHUNKS = 8 * 1024; +interface ChunkCache { + xorbIndex: number; // uint16 + chunkPosition: number; // uint32 +} + +const CHUNK_CACHE_INITIAL_SIZE = 10_000; +const CHUNK_CACHE_GROW_FACTOR = 1.5; +const CHUNK_CACHE_MAX_SIZE = 1_000_000; + export async function* createXorbs( fileSources: AsyncGenerator<{ content: Blob; path: string; sha256: string }> ): AsyncGenerator< @@ -50,6 +59,45 @@ export async function* createXorbs( await chunkModule.init(); const chunker = new chunkModule.Chunker(TARGET_CHUNK_SIZE); + let chunkCacheIndex = 0; + let chunkCacheXorbIndices = new Uint16Array(CHUNK_CACHE_INITIAL_SIZE); + let chunkCacheChunkOffsets = new Uint32Array(CHUNK_CACHE_INITIAL_SIZE); + let chunkCacheChunkEndOffsets = new Uint32Array(CHUNK_CACHE_INITIAL_SIZE); + const chunkCacheMap = new Map(); // hash -> chunkCacheIndex. Less overhead that way, empty object is 60+B and empty array is 40+B + + function addChunkToCache(hash: string, xorbIndex: number, chunkPosition: number, chunkLength: number) { + chunkCacheMap.set(hash, chunkCacheIndex); + + if (chunkCacheIndex >= chunkCacheXorbIndices.length) { + // todo: switch to resize() with modern browsers + const oldXorbIndices = chunkCacheXorbIndices; + const oldChunkPositions = chunkCacheChunkOffsets; + const oldChunkLengths = chunkCacheChunkEndOffsets; + chunkCacheXorbIndices = new Uint16Array( + Math.min(chunkCacheXorbIndices.length * CHUNK_CACHE_GROW_FACTOR, CHUNK_CACHE_MAX_SIZE) + ); + chunkCacheChunkOffsets = new Uint32Array( + Math.min(chunkCacheChunkOffsets.length * CHUNK_CACHE_GROW_FACTOR, CHUNK_CACHE_MAX_SIZE) + ); + chunkCacheChunkEndOffsets = new Uint32Array( + Math.min(chunkCacheChunkEndOffsets.length * CHUNK_CACHE_GROW_FACTOR, CHUNK_CACHE_MAX_SIZE) + ); + chunkCacheXorbIndices.set(oldXorbIndices); + chunkCacheChunkOffsets.set(oldChunkPositions); + chunkCacheChunkEndOffsets.set(oldChunkLengths); + } + + chunkCacheXorbIndices[chunkCacheIndex] = xorbIndex; + chunkCacheChunkOffsets[chunkCacheIndex] = chunkPosition; + chunkCacheChunkEndOffsets[chunkCacheIndex] = chunkLength; + chunkCacheIndex = (chunkCacheIndex + 1) % CHUNK_CACHE_MAX_SIZE; + + while (chunkCacheMap.size > CHUNK_CACHE_MAX_SIZE) { + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + chunkCacheMap.delete(chunkCacheMap.keys().next().value!); + } + } + let xorb = new Uint8Array(XORB_SIZE); let xorbOffset = 0; let xorbChunks = Array<{ hash: string; length: number; offset: number }>(); @@ -75,7 +123,11 @@ export async function* createXorbs( const addChunks = function* (chunks: Array<{ hash: string; length: number }>) { for (const chunk of chunks) { let chunkOffset = xorbOffset; + let chunkEndOffset; + let chunkXorbId = xorbId; fileChunks.push({ hash: chunk.hash, length: chunk.length }); + + // Remove chunks from source data let chunkToCopy: Uint8Array; if (chunk.length === sourceChunks[0].length) { chunkToCopy = sourceChunks[0]; @@ -94,50 +146,65 @@ export async function* createXorbs( } sourceChunks.splice(0, index); } - xorbOffset = writeChunk(xorb, xorbOffset, chunkToCopy); - if (xorbOffset === 0) { - // Failure to write chunk, maybe because it went over xorb size limit - yield { - event: "xorb" as const, - xorb: xorb.subarray(0, xorbOffset), - hash: chunkModule.compute_xorb_hash(xorbChunks), - chunks: [...xorbChunks], - id: xorbId, - files: Object.entries(xorbFiles).map(([path, progress]) => ({ path, progress })), - }; - xorbId++; - xorb = new Uint8Array(XORB_SIZE); - chunkOffset = 0; - xorbOffset = writeChunk(xorb, 0, chunkToCopy); - xorbFiles = {}; + + const cacheIndex = chunkCacheMap.get(chunk.hash); + if (cacheIndex === undefined) { + xorbOffset = writeChunk(xorb, xorbOffset, chunkToCopy); if (xorbOffset === 0) { - throw new Error("Failed to write chunk into xorb"); + // Failure to write chunk, maybe because it went over xorb size limit + yield { + event: "xorb" as const, + xorb: xorb.subarray(0, xorbOffset), + hash: chunkModule.compute_xorb_hash(xorbChunks), + chunks: [...xorbChunks], + id: xorbId, + files: Object.entries(xorbFiles).map(([path, progress]) => ({ path, progress })), + }; + xorbId++; + xorb = new Uint8Array(XORB_SIZE); + chunkOffset = 0; + chunkXorbId = xorbId; + xorbOffset = writeChunk(xorb, 0, chunkToCopy); + xorbFiles = {}; + + if (xorbOffset === 0) { + throw new Error("Failed to write chunk into xorb"); + } } + + chunkEndOffset = xorbOffset; + + addChunkToCache(chunk.hash, xorbId, chunkOffset, chunkEndOffset); + } else { + chunkXorbId = chunkCacheXorbIndices[cacheIndex]; + chunkOffset = chunkCacheChunkOffsets[cacheIndex]; + chunkEndOffset = chunkCacheChunkEndOffsets[cacheIndex]; } + const lastRep = fileRepresentation.at(-1); if (!lastRep) { fileRepresentation.push({ - xorbId, - offset: initialXorbOffset, - endOffset: xorbOffset - initialXorbOffset, + xorbId: chunkXorbId, + offset: chunkOffset, + endOffset: chunkEndOffset, length: chunk.length, rangeHash: "", }); currentChunkRangeBeginning = fileChunks.length - 1; } else { - if (lastRep.xorbId === xorbId) { - lastRep.endOffset = xorbOffset - lastRep.offset; + if (lastRep.xorbId === chunkXorbId && lastRep.endOffset === chunkOffset) { + lastRep.endOffset = chunkEndOffset; lastRep.length += chunk.length; } else { lastRep.rangeHash = chunkModule.compute_verification_hash( fileChunks.slice(currentChunkRangeBeginning, -1).map((x) => x.hash, -1) ); fileRepresentation.push({ - xorbId, - offset: 0, - endOffset: xorbOffset, + xorbId: chunkXorbId, + offset: chunkOffset, + endOffset: chunkEndOffset, length: chunk.length, rangeHash: "", }); From f3e190fdea6bdedf457aa00403e6dd79be339e79 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Thu, 24 Jul 2025 17:03:29 +0200 Subject: [PATCH 18/43] move chunk caching to its own class/file --- packages/hub/src/utils/ChunkCache.ts | 63 ++++++++++++++++++++++++ packages/hub/src/utils/createXorbs.ts | 66 ++++---------------------- packages/hub/src/utils/uploadShards.ts | 6 ++- 3 files changed, 77 insertions(+), 58 deletions(-) create mode 100644 packages/hub/src/utils/ChunkCache.ts diff --git a/packages/hub/src/utils/ChunkCache.ts b/packages/hub/src/utils/ChunkCache.ts new file mode 100644 index 0000000000..0596f9c27c --- /dev/null +++ b/packages/hub/src/utils/ChunkCache.ts @@ -0,0 +1,63 @@ +const CHUNK_CACHE_INITIAL_SIZE = 10_000; +const CHUNK_CACHE_GROW_FACTOR = 1.5; +const CHUNK_CACHE_MAX_SIZE = 1_000_000; + +export class ChunkCache { + index = 0; + // Index >= 0 means local xorb, < 0 means remote xorb + xorbIndices = new Int32Array(CHUNK_CACHE_INITIAL_SIZE); + chunkOffsets = new Uint32Array(CHUNK_CACHE_INITIAL_SIZE); + chunkEndOffsets = new Uint32Array(CHUNK_CACHE_INITIAL_SIZE); + map = new Map(); // hash -> chunkCacheIndex. Less overhead that way, empty object is 60+B and empty array is 40+B + + addChunkToCache(hash: string, xorbIndex: number, chunkOffset: number, chunkEndOffset: number): void { + this.map.set(hash, this.index); + + if (this.index >= this.xorbIndices.length) { + // todo: switch to resize() with modern browsers + const oldXorbIndices = this.xorbIndices; + const oldChunkOffsets = this.chunkOffsets; + const oldChunkLengths = this.chunkEndOffsets; + this.xorbIndices = new Int32Array( + Math.min(this.xorbIndices.length * CHUNK_CACHE_GROW_FACTOR, CHUNK_CACHE_MAX_SIZE) + ); + this.chunkOffsets = new Uint32Array( + Math.min(this.chunkOffsets.length * CHUNK_CACHE_GROW_FACTOR, CHUNK_CACHE_MAX_SIZE) + ); + this.chunkEndOffsets = new Uint32Array( + Math.min(this.chunkEndOffsets.length * CHUNK_CACHE_GROW_FACTOR, CHUNK_CACHE_MAX_SIZE) + ); + this.xorbIndices.set(oldXorbIndices); + this.chunkOffsets.set(oldChunkOffsets); + this.chunkEndOffsets.set(oldChunkLengths); + } + + this.xorbIndices[this.index] = xorbIndex; + this.chunkOffsets[this.index] = chunkOffset; + this.chunkEndOffsets[this.index] = chunkEndOffset; + this.index = (this.index + 1) % CHUNK_CACHE_MAX_SIZE; + + while (this.map.size > CHUNK_CACHE_MAX_SIZE) { + // eslint-disable-next-line @typescript-eslint/no-non-null-assertion + this.map.delete(this.map.keys().next().value!); + } + } + + getChunk(hash: string): + | { + xorbIndex: number; + offset: number; + endOffset: number; + } + | undefined { + const index = this.map.get(hash); + if (index === undefined) { + return undefined; + } + return { + xorbIndex: this.xorbIndices[index], + offset: this.chunkOffsets[index], + endOffset: this.chunkEndOffsets[index], + }; + } +} diff --git a/packages/hub/src/utils/createXorbs.ts b/packages/hub/src/utils/createXorbs.ts index a5fe3379c5..496a46df28 100644 --- a/packages/hub/src/utils/createXorbs.ts +++ b/packages/hub/src/utils/createXorbs.ts @@ -6,6 +6,7 @@ import { bg4_split_bytes, XET_CHUNK_HEADER_BYTES, XetChunkCompressionScheme } from "./XetBlob"; import { compress as lz4_compress } from "../vendor/lz4js"; +import { ChunkCache } from "./ChunkCache"; const TARGET_CHUNK_SIZE = 64 * 1024; /* eslint-disable @typescript-eslint/no-unused-vars */ @@ -13,15 +14,6 @@ const MAX_CHUNK_SIZE = 2 * TARGET_CHUNK_SIZE; const XORB_SIZE = 64 * 1024 * 1024; const MAX_XORB_CHUNKS = 8 * 1024; -interface ChunkCache { - xorbIndex: number; // uint16 - chunkPosition: number; // uint32 -} - -const CHUNK_CACHE_INITIAL_SIZE = 10_000; -const CHUNK_CACHE_GROW_FACTOR = 1.5; -const CHUNK_CACHE_MAX_SIZE = 1_000_000; - export async function* createXorbs( fileSources: AsyncGenerator<{ content: Blob; path: string; sha256: string }> ): AsyncGenerator< @@ -42,7 +34,7 @@ export async function* createXorbs( hash: string; sha256: string; representation: Array<{ - xorbId: number; + xorbId: number | string; // either xorb id (for local xorbs) or xorb hash (for remote xorbs) offset: number; endOffset: number; /** Unpacked length */ @@ -58,46 +50,7 @@ export async function* createXorbs( await chunkModule.init(); const chunker = new chunkModule.Chunker(TARGET_CHUNK_SIZE); - - let chunkCacheIndex = 0; - let chunkCacheXorbIndices = new Uint16Array(CHUNK_CACHE_INITIAL_SIZE); - let chunkCacheChunkOffsets = new Uint32Array(CHUNK_CACHE_INITIAL_SIZE); - let chunkCacheChunkEndOffsets = new Uint32Array(CHUNK_CACHE_INITIAL_SIZE); - const chunkCacheMap = new Map(); // hash -> chunkCacheIndex. Less overhead that way, empty object is 60+B and empty array is 40+B - - function addChunkToCache(hash: string, xorbIndex: number, chunkPosition: number, chunkLength: number) { - chunkCacheMap.set(hash, chunkCacheIndex); - - if (chunkCacheIndex >= chunkCacheXorbIndices.length) { - // todo: switch to resize() with modern browsers - const oldXorbIndices = chunkCacheXorbIndices; - const oldChunkPositions = chunkCacheChunkOffsets; - const oldChunkLengths = chunkCacheChunkEndOffsets; - chunkCacheXorbIndices = new Uint16Array( - Math.min(chunkCacheXorbIndices.length * CHUNK_CACHE_GROW_FACTOR, CHUNK_CACHE_MAX_SIZE) - ); - chunkCacheChunkOffsets = new Uint32Array( - Math.min(chunkCacheChunkOffsets.length * CHUNK_CACHE_GROW_FACTOR, CHUNK_CACHE_MAX_SIZE) - ); - chunkCacheChunkEndOffsets = new Uint32Array( - Math.min(chunkCacheChunkEndOffsets.length * CHUNK_CACHE_GROW_FACTOR, CHUNK_CACHE_MAX_SIZE) - ); - chunkCacheXorbIndices.set(oldXorbIndices); - chunkCacheChunkOffsets.set(oldChunkPositions); - chunkCacheChunkEndOffsets.set(oldChunkLengths); - } - - chunkCacheXorbIndices[chunkCacheIndex] = xorbIndex; - chunkCacheChunkOffsets[chunkCacheIndex] = chunkPosition; - chunkCacheChunkEndOffsets[chunkCacheIndex] = chunkLength; - chunkCacheIndex = (chunkCacheIndex + 1) % CHUNK_CACHE_MAX_SIZE; - - while (chunkCacheMap.size > CHUNK_CACHE_MAX_SIZE) { - // eslint-disable-next-line @typescript-eslint/no-non-null-assertion - chunkCacheMap.delete(chunkCacheMap.keys().next().value!); - } - } - + const chunkCache = new ChunkCache(); let xorb = new Uint8Array(XORB_SIZE); let xorbOffset = 0; let xorbChunks = Array<{ hash: string; length: number; offset: number }>(); @@ -105,7 +58,6 @@ export async function* createXorbs( try { for await (const fileSource of fileSources) { - const initialXorbOffset = xorbOffset; const sourceChunks: Array = []; const reader = fileSource.content.stream().getReader(); @@ -147,8 +99,8 @@ export async function* createXorbs( sourceChunks.splice(0, index); } - const cacheIndex = chunkCacheMap.get(chunk.hash); - if (cacheIndex === undefined) { + const cacheData = chunkCache.getChunk(chunk.hash); + if (cacheData === undefined) { xorbOffset = writeChunk(xorb, xorbOffset, chunkToCopy); if (xorbOffset === 0) { @@ -175,11 +127,11 @@ export async function* createXorbs( chunkEndOffset = xorbOffset; - addChunkToCache(chunk.hash, xorbId, chunkOffset, chunkEndOffset); + chunkCache.addChunkToCache(chunk.hash, xorbId, chunkOffset, chunkEndOffset); } else { - chunkXorbId = chunkCacheXorbIndices[cacheIndex]; - chunkOffset = chunkCacheChunkOffsets[cacheIndex]; - chunkEndOffset = chunkCacheChunkEndOffsets[cacheIndex]; + chunkXorbId = cacheData.xorbIndex; + chunkOffset = cacheData.offset; + chunkEndOffset = cacheData.endOffset; } const lastRep = fileRepresentation.at(-1); diff --git a/packages/hub/src/utils/uploadShards.ts b/packages/hub/src/utils/uploadShards.ts index d5c5ef5270..ac1e3dfe37 100644 --- a/packages/hub/src/utils/uploadShards.ts +++ b/packages/hub/src/utils/uploadShards.ts @@ -137,7 +137,11 @@ export async function* uploadShards( fileViewOffset += 8; for (const repItem of output.representation) { - writeHashToArray(xorbHashes[repItem.xorbId], fileInfoSection, fileViewOffset); + writeHashToArray( + typeof repItem.xorbId === "number" ? xorbHashes[repItem.xorbId] : repItem.xorbId, + fileInfoSection, + fileViewOffset + ); fileViewOffset += HASH_LENGTH; fileInfoView.setUint32(fileViewOffset, 0, true); // Xorb flags fileViewOffset += 4; From 06dcd6d3287e6d28a742756d407ed4a33f0c19dc Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Fri, 25 Jul 2025 17:28:18 +0200 Subject: [PATCH 19/43] Make sure to not OOB when writing shards --- packages/hub/src/utils/uploadShards.ts | 32 +++++++++++++++++++++++--- 1 file changed, 29 insertions(+), 3 deletions(-) diff --git a/packages/hub/src/utils/uploadShards.ts b/packages/hub/src/utils/uploadShards.ts index ac1e3dfe37..9a56b66ed4 100644 --- a/packages/hub/src/utils/uploadShards.ts +++ b/packages/hub/src/utils/uploadShards.ts @@ -71,8 +71,8 @@ export async function* uploadShards( > { const xorbHashes: Array = []; - const fileInfoSection = new Uint8Array(Math.floor(SHARD_MAX_SIZE - SHARD_HEADER_SIZE - SHARD_FOOTER_SIZE) / 2); - const xorbInfoSection = new Uint8Array(Math.floor(SHARD_MAX_SIZE - SHARD_HEADER_SIZE - SHARD_FOOTER_SIZE) / 2); + const fileInfoSection = new Uint8Array(Math.floor(SHARD_MAX_SIZE - SHARD_HEADER_SIZE - SHARD_FOOTER_SIZE) * 0.25); + const xorbInfoSection = new Uint8Array(Math.floor(SHARD_MAX_SIZE - SHARD_HEADER_SIZE - SHARD_FOOTER_SIZE) * 0.75); const xorbView = new DataView(xorbInfoSection.buffer); let xorbViewOffset = 0; @@ -87,6 +87,19 @@ export async function* uploadShards( case "xorb": { xorbHashes.push(output.hash); + // Calculate space needed for this xorb entry + const xorbEntrySize = HASH_LENGTH + 4 + 4 + 4 + 4; // hash + flags + count + unpacked + packed + const chunksSize = output.chunks.length * (HASH_LENGTH + 4 + 4 + 8); // per chunk: hash + length + offset + reserved + const totalXorbSize = xorbEntrySize + chunksSize; + + // Check if adding this xorb would exceed buffer capacity + if (xorbViewOffset + totalXorbSize > xorbInfoSection.length) { + // Upload current shard and reset buffers + if (xorbViewOffset > 0 || fileViewOffset > 0) { + await uploadShard(createShard(), params); + } + } + // todo: handle when going out of bounds writeHashToArray(output.hash, xorbInfoSection, xorbViewOffset); xorbViewOffset += HASH_LENGTH; @@ -124,7 +137,20 @@ export async function* uploadShards( case "file": { yield { event: "file", path: output.path, sha256: output.sha256 }; // Maybe wait until shard is uploaded before yielding. - // todo: handle out of bounds + // Calculate space needed for this file entry + const fileHeaderSize = HASH_LENGTH + 4 + 4 + 8; // hash + flags + rep length + reserved + const representationSize = output.representation.length * (HASH_LENGTH + 4 + 4 + 4 + 4); // per rep: xorb hash + flags + length + offset + endOffset + const verificationSize = output.representation.length * (HASH_LENGTH + 16); // per rep: range hash + reserved + const metadataSize = HASH_LENGTH + 16; // sha256 + reserved + const totalFileSize = fileHeaderSize + representationSize + verificationSize + metadataSize; + + // Check if adding this file would exceed buffer capacity + if (fileViewOffset + totalFileSize > fileInfoSection.length) { + // Upload current shard and reset buffers + if (xorbViewOffset > 0 || fileViewOffset > 0) { + await uploadShard(createShard(), params); + } + } writeHashToArray(output.hash, fileInfoSection, fileViewOffset); fileViewOffset += HASH_LENGTH; From c093c645819be0c1ce69c77be6d5f53b6185c384 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Tue, 29 Jul 2025 13:10:58 +0200 Subject: [PATCH 20/43] dedup boolean when loading chunks from wasm --- .../src/vendor/xet-chunk/chunker_wasm_bg.d.ts | 4 +- .../xet-chunk/chunker_wasm_bg.wasm.base64.ts | 3487 +++++++++-------- 2 files changed, 1756 insertions(+), 1735 deletions(-) diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts index b8c52930f8..bf8e8bded7 100644 --- a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts @@ -6,6 +6,6 @@ export function compute_file_hash(chunks_array: Array<{ hash: string; length: nu export class Chunker { free(): void; constructor(target_chunk_size: number); - add_data(data: Uint8Array): Array<{ hash: string; length: number }>; - finish(): Array<{ hash: string; length: number }>; + add_data(data: Uint8Array): Array<{ hash: string; length: number; dedup: boolean }>; + finish(): Array<{ hash: string; length: number; dedup: boolean }>; } diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts index 4cd7b3368e..8dfc87e9f3 100644 --- a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts @@ -1,1747 +1,1768 @@ // Generated by build-xet-wasm.sh export const wasmBase64 = atob(` -AGFzbQEAAAABrwIsYAJ/fwF/YAN/f38Bf2ACf38AYAN/f38AYAR/f39/AGABbwF/YAF/AX9gAX8A +AGFzbQEAAAABtQItYAJ/fwF/YAN/f38Bf2ACf38AYAN/f38AYAR/f39/AGABfwF/YAF/AGABbwF/ YAV/f39/fwBgAAR/f39/YAFvAW9gAn9vAGAAAW9gAABgBn9/f39/fwBgBH9/f38Bf2AAA39/f2AC b28Bb2AGf39/f39/AX9gBX9/f39/AX9gAn9/AW9gAm9vAX9gAAF/YAFvBH9/f39gAW8BfGABfAFv YANvb28AYAJvfwFvYANvf28AYANvb38AYAV/f39+fwBgB39/f35/f38Bf2AJf39/f39/fn5+AGAD fn9/AX9gB39/f39/f38Bf2ACf38Ef39/f2ADf39/A39/f2ABfwN/f39gBX9/fX9/AGAEf31/fwBg -BX9/fH9/AGAEf3x/fwBgBX9/fn9/AGAEf35/fwAC9RAoGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5q -cxpfX3diZ19sb2dfYzVkMWE4ZGMwOTgyMTJhZgACGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxVf -X3diaW5kZ2VuX3N0cmluZ19uZXcAFBguL2hmX3hldF90aGluX3dhc21fYmcuanMVX193YmluZGdl -bl9zdHJpbmdfZ2V0AAsYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzFF9fd2JpbmRnZW5faXNfb2Jq -ZWN0AAUYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzF19fd2JpbmRnZW5faXNfdW5kZWZpbmVkAAUY -Li9oZl94ZXRfdGhpbl93YXNtX2JnLmpzDV9fd2JpbmRnZW5faW4AFRguL2hmX3hldF90aGluX3dh -c21fYmcuanMUX193YmluZGdlbl9lcnJvcl9uZXcAFBguL2hmX3hldF90aGluX3dhc21fYmcuanMZ -X193YmluZGdlbl9qc3ZhbF9sb29zZV9lcQAVGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxZfX3di -aW5kZ2VuX2Jvb2xlYW5fZ2V0AAUYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzFV9fd2JpbmRnZW5f -bnVtYmVyX2dldAALGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxRfX3diaW5kZ2VuX2FzX251bWJl -cgAYGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcx1fX3diZ19TdHJpbmdfOGYwZWIzOWE0YTRjMmY2 -NgALGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxVfX3diaW5kZ2VuX251bWJlcl9uZXcAGRguL2hm -X3hldF90aGluX3dhc21fYmcuanMkX193YmdfZ2V0d2l0aHJlZmtleV8xZGMzNjFiZDEwMDUzYmZl -ABEYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX3NldF8zZjFkMGI5ODRlZDI3MmVkABoY -Li9oZl94ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX2dldF9iOWI5MzA0N2ZlM2NmNDViABsYLi9o -Zl94ZXRfdGhpbl93YXNtX2JnLmpzHV9fd2JnX2xlbmd0aF9lMmQyYTQ5MTMyYzFiMjU2AAUYLi9o -Zl94ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX25ld183OGZlYjEwOGI2NDcyNzEzAAwYLi9oZl94 -ZXRfdGhpbl93YXNtX2JnLmpzFl9fd2JpbmRnZW5faXNfZnVuY3Rpb24ABRguL2hmX3hldF90aGlu -X3dhc21fYmcuanMbX193YmdfbmV4dF8yNWZlYWRmYzA5MTNmZWE5AAoYLi9oZl94ZXRfdGhpbl93 -YXNtX2JnLmpzG19fd2JnX25leHRfNjU3NGUxYThhNjJkMTA1NQAKGC4vaGZfeGV0X3RoaW5fd2Fz -bV9iZy5qcxtfX3diZ19kb25lXzc2OWU1ZWRlNGIzMWM2N2IABRguL2hmX3hldF90aGluX3dhc21f -YmcuanMcX193YmdfdmFsdWVfY2QxZmZhN2IxYWI3OTRmMQAKGC4vaGZfeGV0X3RoaW5fd2FzbV9i -Zy5qcx9fX3diZ19pdGVyYXRvcl85YTI0Yzg4ZGY4NjBkYzY1AAwYLi9oZl94ZXRfdGhpbl93YXNt -X2JnLmpzGl9fd2JnX2dldF82N2IyYmE2MmZjMzBkZTEyABEYLi9oZl94ZXRfdGhpbl93YXNtX2Jn -LmpzG19fd2JnX2NhbGxfNjcyYTRkMjE2MzRkNGEyNAARGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5q -cxpfX3diZ19uZXdfNDA1ZTIyZjM5MDU3NmNlMgAMGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxpf -X3diZ19zZXRfMzc4MzcwMjNmM2Q3NDBlOAAcGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcx5fX3di -Z19pc0FycmF5X2ExZWFiN2UwZDA2NzM5MWIABRguL2hmX3hldF90aGluX3dhc21fYmcuanMtX193 -YmdfaW5zdGFuY2VvZl9BcnJheUJ1ZmZlcl9lMTQ1ODU0MzJlMzczN2ZjAAUYLi9oZl94ZXRfdGhp -bl93YXNtX2JnLmpzJF9fd2JnX2lzU2FmZUludGVnZXJfMzQzZTJiZWVlZWNlMWJiMAAFGC4vaGZf -eGV0X3RoaW5fd2FzbV9iZy5qcx1fX3diZ19idWZmZXJfNjA5Y2MzZWVlNTFlZDE1OAAKGC4vaGZf -eGV0X3RoaW5fd2FzbV9iZy5qcxpfX3diZ19uZXdfYTEyMDAyYTdmOTFjNzViZQAKGC4vaGZfeGV0 -X3RoaW5fd2FzbV9iZy5qcxpfX3diZ19zZXRfNjU1OTViZGQ4NjhiMzAwOQAdGC4vaGZfeGV0X3Ro -aW5fd2FzbV9iZy5qcx1fX3diZ19sZW5ndGhfYTQ0NjE5M2RjMjJjMTJmOAAFGC4vaGZfeGV0X3Ro -aW5fd2FzbV9iZy5qcyxfX3diZ19pbnN0YW5jZW9mX1VpbnQ4QXJyYXlfMTcxNTZiY2YxMTgwODZh -OQAFGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxdfX3diaW5kZ2VuX2RlYnVnX3N0cmluZwALGC4v -aGZfeGV0X3RoaW5fd2FzbV9iZy5qcxBfX3diaW5kZ2VuX3Rocm93AAIYLi9oZl94ZXRfdGhpbl93 -YXNtX2JnLmpzEV9fd2JpbmRnZW5fbWVtb3J5AAwYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzH19f -d2JpbmRnZW5faW5pdF9leHRlcm5yZWZfdGFibGUADQPNAcsBHgYfAgIAAgIAAwgDBAMSAwAHAQAB -AAEAARIBBAIgAQIAIQMAAgAADg4iAAAGAhYIAwACBAAEBAMPAwEGAgAIAwICAgMHDgMWDgIABAIC -AAMABAIACAMBAwQCAAAABAQABAEBBwQNAQAABwIAAwQCABMAByMkFxcCJQ8SBgAIEyYoKgcEAAEE -AAcCAwAHAAAGDwYDAAEACAAABAQAAAcCAgIAAAACAwMGAwMDAAcAAAAAAAAAAAAAAA0NAgACAAAC -AAECAAACBgYGBgMECQJwAWhobwCAAQUDAQARBgkBfwFBgIDAAAsHzwIQBm1lbW9yeQIAEl9fd2Jn -X2NodW5rZXJfZnJlZQBpC2NodW5rZXJfbmV3AFQQY2h1bmtlcl9hZGRfZGF0YQCcAQ5jaHVua2Vy -X2ZpbmlzaACgARFjb21wdXRlX3hvcmJfaGFzaACdARFjb21wdXRlX2ZpbGVfaGFzaACeARljb21w -dXRlX3ZlcmlmaWNhdGlvbl9oYXNoAJsBEV9fd2JpbmRnZW5fbWFsbG9jAJkBEl9fd2JpbmRnZW5f -cmVhbGxvYwChARRfX3diaW5kZ2VuX2V4bl9zdG9yZQDFARdfX2V4dGVybnJlZl90YWJsZV9hbGxv -YwBvE19fd2JpbmRnZW5fZXhwb3J0XzQBARlfX2V4dGVybnJlZl90YWJsZV9kZWFsbG9jAGwPX193 -YmluZGdlbl9mcmVlALoBEF9fd2JpbmRnZW5fc3RhcnQAJwm8AQEAQQELZ9oB2wGCAbABiQFN3AHW -AdkB7AHrAdgB1wG9ATi/Ad0BsAGJAU69AXKXAaYBcKUBpgGiAa0BqwGlAaUBpwGoAakBrgGAAXnx -AfIBhQGIAV2jAWuGAYwBXm7eAZUBwQHCAc8BfXjDAb8BhwGsAdUBpAFlWcQBkwFirwHfAcMBtAHT -AYEBsAGKAVPjAccBxgHJAZIByAHkAaoBe1pq7QGwAY4BUuUB5gG7Ab0BygHLATt2XD6QAegBDAEO -CpvsBMsBiRsBIH8gACAAKAIYIh0gASgAECIkIAAoAghqaiIbIAEoABQiFWogHSAbIAJB/wFxc0EQ -dyICQfLmu+MDaiIdc0EUdyIbaiIiIAJzQRh3IgkgHWoiHCAbc0EZdyIPIAAoAhQiGyABKAAIIgIg -ACgCBGpqIhkgASgADCIdaiAZIANCIIinc0EQdyIeQfui4aQEayIgIBtzQRR3IgZqIgogASgAKCIb -amoiIyABKAAsIhlqIA8gIyAAKAIQIiEgASgAACIPIAAoAgBqaiIIIAEoAAQiH2ogISAIIAOnc0EQ -dyIhQefMp9AGaiIIc0EUdyIHaiIOICFzQRh3Ig1zQRB3IgsgACgCHCIFIAEoABgiIyAAKAIMamoi -DCABKAAcIiFqIAUgDCAEQf8BcXNBEHciBEHGlcDVBWsiBXNBFHciDGoiESAEc0EYdyIQIAVqIgVq -IhJzQRR3IhRqIhMgHWogBiAgIAogHnNBGHciIGoiBnNBGXciCiAOIAEoACAiBGpqIg4gASgAJCIe -aiAKIBwgDiAQc0EQdyIcaiIKc0EUdyIOaiIQIBxzQRh3IhYgCmoiCiAOc0EZdyIcaiIOIBtqIBwg -DiAFIAxzQRl3IgUgIiABKAAwIhxqaiIMIAEoADQiImogDCAgc0EQdyIgIAggDWoiCGoiDSAFc0EU -dyIFaiIMICBzQRh3IhdzQRB3Ig4gByAIc0EZdyIIIBEgASgAOCIgamoiByABKAA8IgFqIAcgCXNB -EHciCSAGaiIGIAhzQRR3IghqIgcgCXNBGHciCSAGaiIGaiIRc0EUdyIYaiIaIBxqIAsgE3NBGHci -CyASaiISIBRzQRl3IhQgDCAhamoiDCAPaiAJIAxzQRB3IgkgCmoiCiAUc0EUdyIMaiIUIAlzQRh3 -IgkgCmoiCiAMc0EZdyIMaiITIBVqIAwgEyAGIAhzQRl3IgYgAiAQamoiCCAjaiAGIAggC3NBEHci -BiANIBdqIghqIg1zQRR3IgtqIgwgBnNBGHciBnNBEHciECAFIAhzQRl3IgggByAkamoiByAiaiAI -IAcgFnNBEHciCCASaiIHc0EUdyIFaiISIAhzQRh3IgggB2oiB2oiE3NBFHciFmoiFyAbaiAOIBpz -QRh3Ig4gEWoiESAYc0EZdyIYIAwgH2pqIgwgGWogCiAIIAxzQRB3IgpqIgggGHNBFHciDGoiGCAK -c0EYdyIKIAhqIgggDHNBGXciDGoiGiAcaiAMIBogBSAHc0EZdyIHIBQgHmpqIgUgIGogByAFIA5z -QRB3IgcgBiANaiIGaiIOc0EUdyINaiIFIAdzQRh3IgdzQRB3IgwgBiALc0EZdyIGIAEgEmpqIgsg -BGogBiAJIAtzQRB3IgkgEWoiBnNBFHciC2oiESAJc0EYdyIJIAZqIgZqIhJzQRR3IhRqIhogHmog -ECAXc0EYdyIQIBNqIhMgFnNBGXciFiAFICJqaiIFIAJqIAUgCXNBEHciCSAIaiIIIBZzQRR3IgVq -IhYgCXNBGHciCSAIaiIIIAVzQRl3IgVqIhcgD2ogBSAXIAYgC3NBGXciBiAYIB1qaiILICRqIAYg -CyAQc0EQdyIGIAcgDmoiB2oiDnNBFHciC2oiBSAGc0EYdyIGc0EQdyIQIAcgDXNBGXciByARICFq -aiINICBqIAcgCiANc0EQdyIKIBNqIgdzQRR3Ig1qIhEgCnNBGHciCiAHaiIHaiITc0EUdyIXaiIY -IBxqIAwgGnNBGHciDCASaiISIBRzQRl3IhQgBSAjamoiBSAVaiAFIApzQRB3IgogCGoiCCAUc0EU -dyIFaiIUIApzQRh3IgogCGoiCCAFc0EZdyIFaiIaIB5qIAUgGiAHIA1zQRl3IgcgFiAZamoiDSAB -aiAHIAwgDXNBEHciByAGIA5qIgZqIg5zQRR3Ig1qIgUgB3NBGHciB3NBEHciDCAGIAtzQRl3IgYg -BCARamoiCyAfaiAGIAkgC3NBEHciCSASaiIGc0EUdyILaiIRIAlzQRh3IgkgBmoiBmoiEnNBFHci -FmoiGiAZaiAQIBhzQRh3IhAgE2oiEyAXc0EZdyIXIAUgIGpqIgUgHWogBSAJc0EQdyIJIAhqIggg -F3NBFHciBWoiFyAJc0EYdyIJIAhqIgggBXNBGXciBWoiGCACaiAFIBggBiALc0EZdyIGIBQgG2pq -IgsgIWogBiALIBBzQRB3IgYgByAOaiIHaiIOc0EUdyILaiIFIAZzQRh3IgZzQRB3IhAgByANc0EZ -dyIHIBEgImpqIg0gAWogByAKIA1zQRB3IgogE2oiB3NBFHciDWoiESAKc0EYdyIKIAdqIgdqIhRz -QRR3IhNqIhggHmogDCAac0EYdyIMIBJqIhIgFnNBGXciFiAFICRqaiIFIA9qIAUgCnNBEHciCiAI -aiIIIBZzQRR3IgVqIhYgCnNBGHciCiAIaiIIIAVzQRl3IgVqIhogGWogBSAaIAcgDXNBGXciByAV -IBdqaiINIARqIAcgDCANc0EQdyIHIAYgDmoiBmoiDnNBFHciDWoiBSAHc0EYdyIHc0EQdyIMIAYg -C3NBGXciBiARIB9qaiILICNqIAYgCSALc0EQdyIJIBJqIgZzQRR3IgtqIhEgCXNBGHciCSAGaiIG -aiISc0EUdyIXaiIaIBVqIBAgGHNBGHciECAUaiIUIBNzQRl3IhMgASAFamoiBSAbaiAFIAlzQRB3 -IgkgCGoiCCATc0EUdyIFaiITIAlzQRh3IgkgCGoiCCAFc0EZdyIFaiIYIB1qIAUgGCAGIAtzQRl3 -IgYgFiAcamoiCyAiaiAGIAsgEHNBEHciBiAHIA5qIgdqIg5zQRR3IgtqIgUgBnNBGHciBnNBEHci -ECAHIA1zQRl3IgcgESAgamoiDSAEaiAHIAogDXNBEHciCiAUaiIHc0EUdyINaiIRIApzQRh3Igog -B2oiB2oiFHNBFHciFmoiGCAZaiAMIBpzQRh3IgwgEmoiEiAXc0EZdyIXIAUgIWpqIgUgAmogBSAK -c0EQdyIKIAhqIgggF3NBFHciBWoiFyAKc0EYdyIKIAhqIgggBXNBGXciBWoiGiAVaiAFIBogByAN -c0EZdyIHIA8gE2pqIg0gH2ogByAMIA1zQRB3IgcgBiAOaiIGaiIOc0EUdyINaiIFIAdzQRh3Igdz -QRB3IgwgBiALc0EZdyIGIBEgI2pqIgsgJGogBiAJIAtzQRB3IgkgEmoiBnNBFHciC2oiESAJc0EY -dyIJIAZqIgZqIhJzQRR3IhNqIhogD2ogECAYc0EYdyIQIBRqIhQgFnNBGXciFiAEIAVqaiIFIBxq -IAUgCXNBEHciCSAIaiIIIBZzQRR3IgVqIhYgCXNBGHciCSAIaiIIIAVzQRl3IgVqIhggG2ogBSAY -IAYgC3NBGXciBiAXIB5qaiILICBqIAYgCyAQc0EQdyIGIAcgDmoiB2oiDnNBFHciC2oiBSAGc0EY -dyIGc0EQdyIQIAcgDXNBGXciByABIBFqaiINIB9qIAcgCiANc0EQdyIKIBRqIgdzQRR3Ig1qIhEg -CnNBGHciCiAHaiIHaiIUc0EUdyIXaiIYIBVqIAwgGnNBGHciFSASaiIMIBNzQRl3IhIgBSAiamoi -BSAdaiAFIApzQRB3IgogCGoiCCASc0EUdyIFaiISIApzQRh3IgogCGoiCCAFc0EZdyIFaiITIA9q -IAUgEyAHIA1zQRl3Ig8gAiAWamoiByAjaiAPIAcgFXNBEHciFSAGIA5qIg9qIgZzQRR3IgdqIg4g -FXNBGHciFXNBEHciDSALIA9zQRl3Ig8gESAkamoiCyAhaiAPIAkgC3NBEHciDyAMaiIJc0EUdyIL -aiIFIA9zQRh3Ig8gCWoiCWoiDHNBFHciEWoiEyACaiAeIBAgGHNBGHciAiAUaiIeIBdzQRl3IhAg -DiAfamoiH2ogDyAfc0EQdyIPIAhqIh8gEHNBFHciCGoiDiAPc0EYdyIPIB9qIh8gCHNBGXciCGoi -ECAcaiAQIAEgCSALc0EZdyIBIBIgGWpqIhlqIAEgAiAZc0EQdyIBIAYgFWoiAmoiFXNBFHciGWoi -HCABc0EYdyIBc0EQdyIJIAIgB3NBGXciAiAEIAVqaiIEICNqIAIgBCAKc0EQdyICIB5qIgRzQRR3 -IiNqIh4gAnNBGHciAiAEaiIEaiIGIAhzQRR3IgpqIgggCXNBGHciCSAGaiIGIAEgFWoiASAZc0EZ -dyIVIB4gIWpqIhkgImogFSAPIBlzQRB3IhUgDSATc0EYdyIZIAxqIg9qIiFzQRR3Ih5qIiJzNgIM -IAAgGyAPIBFzQRl3Ig8gHCAgamoiHGogAiAcc0EQdyICIB9qIhsgD3NBFHciD2oiHyACc0EYdyIC -IBtqIhsgJCAEICNzQRl3IgQgDiAdamoiHWogBCABIBkgHXNBEHciAWoiBHNBFHciJGoiHXM2Aggg -ACAVICJzQRh3IhUgIWoiGSAIczYCBCAAIAEgHXNBGHciASAEaiIEIB9zNgIAIAAgBCAkc0EZdyAC -czYCHCAAIAYgCnNBGXcgFXM2AhggACAPIBtzQRl3IAFzNgIUIAAgGSAec0EZdyAJczYCEAubJAIJ -fwF+IwBBEGsiCCQAAn8CQAJAAkACQAJAAkAgAEH1AU8EQEEAIABBzP97Sw0HGiAAQQtqIgFBeHEh -BUHchMEAKAIAIglFDQRBHyEHQQAgBWshBCAAQfT//wdNBEAgBUEGIAFBCHZnIgBrdkEBcSAAQQF0 -a0E+aiEHCyAHQQJ0QcCBwQBqKAIAIgFFBEBBACEADAILQQAhACAFQRkgB0EBdmtBACAHQR9HG3Qh -AwNAAkAgASgCBEF4cSIGIAVJDQAgBiAFayIGIARPDQAgASECIAYiBA0AQQAhBCABIQAMBAsgASgC -FCIGIAAgBiABIANBHXZBBHFqKAIQIgFHGyAAIAYbIQAgA0EBdCEDIAENAAsMAQtB2ITBACgCACIC -QRAgAEELakH4A3EgAEELSRsiBUEDdiIAdiIBQQNxBEACQCABQX9zQQFxIABqIgZBA3QiAEHQgsEA -aiIDIABB2ILBAGooAgAiASgCCCIERwRAIAQgAzYCDCADIAQ2AggMAQtB2ITBACACQX4gBndxNgIA -CyABIABBA3I2AgQgACABaiIAIAAoAgRBAXI2AgQgAUEIagwHCyAFQeCEwQAoAgBNDQMCQAJAIAFF -BEBB3ITBACgCACIARQ0GIABoQQJ0QcCBwQBqKAIAIgIoAgRBeHEgBWshBCACIQEDQAJAIAIoAhAi -AA0AIAIoAhQiAA0AIAEoAhghBwJAAkAgASABKAIMIgBGBEAgAUEUQRAgASgCFCIAG2ooAgAiAg0B -QQAhAAwCCyABKAIIIgIgADYCDCAAIAI2AggMAQsgAUEUaiABQRBqIAAbIQMDQCADIQYgAiIAQRRq -IABBEGogACgCFCICGyEDIABBFEEQIAIbaigCACICDQALIAZBADYCAAsgB0UNBAJAIAEoAhxBAnRB -wIHBAGoiAigCACABRwRAIAEgBygCEEcEQCAHIAA2AhQgAA0CDAcLIAcgADYCECAADQEMBgsgAiAA -NgIAIABFDQQLIAAgBzYCGCABKAIQIgIEQCAAIAI2AhAgAiAANgIYCyABKAIUIgJFDQQgACACNgIU -IAIgADYCGAwECyAAKAIEQXhxIAVrIgIgBCACIARJIgIbIQQgACABIAIbIQEgACECDAALAAsCQEEC -IAB0IgNBACADa3IgASAAdHFoIgZBA3QiAUHQgsEAaiIDIAFB2ILBAGooAgAiACgCCCIERwRAIAQg -AzYCDCADIAQ2AggMAQtB2ITBACACQX4gBndxNgIACyAAIAVBA3I2AgQgACAFaiIGIAEgBWsiA0EB -cjYCBCAAIAFqIAM2AgBB4ITBACgCACIEBEAgBEF4cUHQgsEAaiEBQeiEwQAoAgAhAgJ/QdiEwQAo -AgAiBUEBIARBA3Z0IgRxRQRAQdiEwQAgBCAFcjYCACABDAELIAEoAggLIQQgASACNgIIIAQgAjYC -DCACIAE2AgwgAiAENgIIC0HohMEAIAY2AgBB4ITBACADNgIAIABBCGoMCAtB3ITBAEHchMEAKAIA -QX4gASgCHHdxNgIACwJAAkAgBEEQTwRAIAEgBUEDcjYCBCABIAVqIgMgBEEBcjYCBCADIARqIAQ2 -AgBB4ITBACgCACIGRQ0BIAZBeHFB0ILBAGohAEHohMEAKAIAIQICf0HYhMEAKAIAIgVBASAGQQN2 -dCIGcUUEQEHYhMEAIAUgBnI2AgAgAAwBCyAAKAIICyEGIAAgAjYCCCAGIAI2AgwgAiAANgIMIAIg -BjYCCAwBCyABIAQgBWoiAEEDcjYCBCAAIAFqIgAgACgCBEEBcjYCBAwBC0HohMEAIAM2AgBB4ITB -ACAENgIACyABQQhqDAYLIAAgAnJFBEBBACECQQIgB3QiAEEAIABrciAJcSIARQ0DIABoQQJ0QcCB -wQBqKAIAIQALIABFDQELA0AgACACIAAoAgRBeHEiAyAFayIGIARJIgcbIQkgACgCECIBRQRAIAAo -AhQhAQsgAiAJIAMgBUkiABshAiAEIAYgBCAHGyAAGyEEIAEiAA0ACwsgAkUNACAFQeCEwQAoAgAi -AE0gBCAAIAVrT3ENACACKAIYIQcCQAJAIAIgAigCDCIARgRAIAJBFEEQIAIoAhQiABtqKAIAIgEN -AUEAIQAMAgsgAigCCCIBIAA2AgwgACABNgIIDAELIAJBFGogAkEQaiAAGyEDA0AgAyEGIAEiAEEU -aiAAQRBqIAAoAhQiARshAyAAQRRBECABG2ooAgAiAQ0ACyAGQQA2AgALIAdFDQICQCACKAIcQQJ0 -QcCBwQBqIgEoAgAgAkcEQCACIAcoAhBHBEAgByAANgIUIAANAgwFCyAHIAA2AhAgAA0BDAQLIAEg -ADYCACAARQ0CCyAAIAc2AhggAigCECIBBEAgACABNgIQIAEgADYCGAsgAigCFCIBRQ0CIAAgATYC -FCABIAA2AhgMAgsCQAJAAkACQAJAIAVB4ITBACgCACIBSwRAIAVB5ITBACgCACIATwRAIAVBr4AE -akGAgHxxIgJBEHZAACEAIAhBBGoiAUEANgIIIAFBACACQYCAfHEgAEF/RiICGzYCBCABQQAgAEEQ -dCACGzYCAEEAIAgoAgQiAUUNCRogCCgCDCEGQfCEwQAgCCgCCCIEQfCEwQAoAgBqIgA2AgBB9ITB -ACAAQfSEwQAoAgAiAiAAIAJLGzYCAAJAAkBB7ITBACgCACICBEBBwILBACEAA0AgASAAKAIAIgMg -ACgCBCIHakYNAiAAKAIIIgANAAsMAgtB/ITBACgCACIAQQAgACABTRtFBEBB/ITBACABNgIAC0GA -hcEAQf8fNgIAQcyCwQAgBjYCAEHEgsEAIAQ2AgBBwILBACABNgIAQdyCwQBB0ILBADYCAEHkgsEA -QdiCwQA2AgBB2ILBAEHQgsEANgIAQeyCwQBB4ILBADYCAEHggsEAQdiCwQA2AgBB9ILBAEHogsEA -NgIAQeiCwQBB4ILBADYCAEH8gsEAQfCCwQA2AgBB8ILBAEHogsEANgIAQYSDwQBB+ILBADYCAEH4 -gsEAQfCCwQA2AgBBjIPBAEGAg8EANgIAQYCDwQBB+ILBADYCAEGUg8EAQYiDwQA2AgBBiIPBAEGA -g8EANgIAQZyDwQBBkIPBADYCAEGQg8EAQYiDwQA2AgBBmIPBAEGQg8EANgIAQaSDwQBBmIPBADYC -AEGgg8EAQZiDwQA2AgBBrIPBAEGgg8EANgIAQaiDwQBBoIPBADYCAEG0g8EAQaiDwQA2AgBBsIPB -AEGog8EANgIAQbyDwQBBsIPBADYCAEG4g8EAQbCDwQA2AgBBxIPBAEG4g8EANgIAQcCDwQBBuIPB -ADYCAEHMg8EAQcCDwQA2AgBByIPBAEHAg8EANgIAQdSDwQBByIPBADYCAEHQg8EAQciDwQA2AgBB -3IPBAEHQg8EANgIAQeSDwQBB2IPBADYCAEHYg8EAQdCDwQA2AgBB7IPBAEHgg8EANgIAQeCDwQBB -2IPBADYCAEH0g8EAQeiDwQA2AgBB6IPBAEHgg8EANgIAQfyDwQBB8IPBADYCAEHwg8EAQeiDwQA2 -AgBBhITBAEH4g8EANgIAQfiDwQBB8IPBADYCAEGMhMEAQYCEwQA2AgBBgITBAEH4g8EANgIAQZSE -wQBBiITBADYCAEGIhMEAQYCEwQA2AgBBnITBAEGQhMEANgIAQZCEwQBBiITBADYCAEGkhMEAQZiE -wQA2AgBBmITBAEGQhMEANgIAQayEwQBBoITBADYCAEGghMEAQZiEwQA2AgBBtITBAEGohMEANgIA -QaiEwQBBoITBADYCAEG8hMEAQbCEwQA2AgBBsITBAEGohMEANgIAQcSEwQBBuITBADYCAEG4hMEA -QbCEwQA2AgBBzITBAEHAhMEANgIAQcCEwQBBuITBADYCAEHUhMEAQciEwQA2AgBByITBAEHAhMEA -NgIAQeyEwQAgAUEPakF4cSIAQQhrIgI2AgBB0ITBAEHIhMEANgIAQeSEwQAgBEEoayIDIAEgAGtq -QQhqIgA2AgAgAiAAQQFyNgIEIAEgA2pBKDYCBEH4hMEAQYCAgAE2AgAMCAsgAiADSSABIAJNcg0A -IAAoAgwiA0EBcQ0AIANBAXYgBkYNAwtB/ITBAEH8hMEAKAIAIgAgASAAIAFJGzYCACABIARqIQNB -wILBACEAAkACQANAIAMgACgCACIHRwRAIAAoAggiAA0BDAILCyAAKAIMIgNBAXENACADQQF2IAZG -DQELQcCCwQAhAANAAkAgAiAAKAIAIgNPBEAgAiADIAAoAgRqIgdJDQELIAAoAgghAAwBCwtB7ITB -ACABQQ9qQXhxIgBBCGsiAzYCAEHkhMEAIARBKGsiCSABIABrakEIaiIANgIAIAMgAEEBcjYCBCAB -IAlqQSg2AgRB+ITBAEGAgIABNgIAIAIgB0Ega0F4cUEIayIAIAAgAkEQakkbIgNBGzYCBEHAgsEA -KQIAIQogA0EQakHIgsEAKQIANwIAIAMgCjcCCEHMgsEAIAY2AgBBxILBACAENgIAQcCCwQAgATYC -AEHIgsEAIANBCGo2AgAgA0EcaiEAA0AgAEEHNgIAIABBBGoiACAHSQ0ACyACIANGDQcgAyADKAIE -QX5xNgIEIAIgAyACayIAQQFyNgIEIAMgADYCACAAQYACTwRAIAIgABBVDAgLIABB+AFxQdCCwQBq -IQECf0HYhMEAKAIAIgNBASAAQQN2dCIAcUUEQEHYhMEAIAAgA3I2AgAgAQwBCyABKAIICyEAIAEg -AjYCCCAAIAI2AgwgAiABNgIMIAIgADYCCAwHCyAAIAE2AgAgACAAKAIEIARqNgIEIAFBD2pBeHFB -CGsiAiAFQQNyNgIEIAdBD2pBeHFBCGsiBCACIAVqIgBrIQUgBEHshMEAKAIARg0DIARB6ITBACgC -AEYNBCAEKAIEIgFBA3FBAUYEQCAEIAFBeHEiARBMIAEgBWohBSABIARqIgQoAgQhAQsgBCABQX5x -NgIEIAAgBUEBcjYCBCAAIAVqIAU2AgAgBUGAAk8EQCAAIAUQVQwGCyAFQfgBcUHQgsEAaiEBAn9B -2ITBACgCACIDQQEgBUEDdnQiBHFFBEBB2ITBACADIARyNgIAIAEMAQsgASgCCAshAyABIAA2Aggg -AyAANgIMIAAgATYCDCAAIAM2AggMBQtB5ITBACAAIAVrIgE2AgBB7ITBAEHshMEAKAIAIgAgBWoi -AjYCACACIAFBAXI2AgQgACAFQQNyNgIEIABBCGoMCAtB6ITBACgCACEAAkAgASAFayICQQ9NBEBB -6ITBAEEANgIAQeCEwQBBADYCACAAIAFBA3I2AgQgACABaiIBIAEoAgRBAXI2AgQMAQtB4ITBACAC -NgIAQeiEwQAgACAFaiIDNgIAIAMgAkEBcjYCBCAAIAFqIAI2AgAgACAFQQNyNgIECyAAQQhqDAcL -IAAgBCAHajYCBEHshMEAQeyEwQAoAgAiAEEPakF4cSIBQQhrIgI2AgBB5ITBAEHkhMEAKAIAIARq -IgMgACABa2pBCGoiATYCACACIAFBAXI2AgQgACADakEoNgIEQfiEwQBBgICAATYCAAwDC0HshMEA -IAA2AgBB5ITBAEHkhMEAKAIAIAVqIgE2AgAgACABQQFyNgIEDAELQeiEwQAgADYCAEHghMEAQeCE -wQAoAgAgBWoiATYCACAAIAFBAXI2AgQgACABaiABNgIACyACQQhqDAMLQQBB5ITBACgCACIAIAVN -DQIaQeSEwQAgACAFayIBNgIAQeyEwQBB7ITBACgCACIAIAVqIgI2AgAgAiABQQFyNgIEIAAgBUED -cjYCBCAAQQhqDAILQdyEwQBB3ITBACgCAEF+IAIoAhx3cTYCAAsCQCAEQRBPBEAgAiAFQQNyNgIE -IAIgBWoiACAEQQFyNgIEIAAgBGogBDYCACAEQYACTwRAIAAgBBBVDAILIARB+AFxQdCCwQBqIQEC -f0HYhMEAKAIAIgNBASAEQQN2dCIEcUUEQEHYhMEAIAMgBHI2AgAgAQwBCyABKAIICyEDIAEgADYC -CCADIAA2AgwgACABNgIMIAAgAzYCCAwBCyACIAQgBWoiAEEDcjYCBCAAIAJqIgAgACgCBEEBcjYC -BAsgAkEIagsgCEEQaiQAC9UMAg1/AX4jAEGgAmsiByQAAkACQAJAAkACQCABQYAITQRAIAdBADYC -iAEgASABQQAgAUGACEcbIgxrIg5BgAhPBEAgB0EBNgKIASAHIAA2AowBQQEhCgsgB0GMAWohCyAD -IRQgBSEBIwBBIGsiCCQAIAZBBXYiCSAKIAkgCkkbIg0EQCAEQQJyIQ8gBEEBciEQA0AgCygCACEJ -IAhBGGoiESACQRhqKQIANwMAIAhBEGoiEiACQRBqKQIANwMAIAhBCGoiEyACQQhqKQIANwMAIAgg -AikCADcDACAIIAlBwAAgFCAQECggCCAJQUBrQcAAIBQgBBAoIAggCUGAAWpBwAAgFCAEECggCCAJ -QcABakHAACAUIAQQKCAIIAlBgAJqQcAAIBQgBBAoIAggCUHAAmpBwAAgFCAEECggCCAJQYADakHA -ACAUIAQQKCAIIAlBwANqQcAAIBQgBBAoIAggCUGABGpBwAAgFCAEECggCCAJQcAEakHAACAUIAQQ -KCAIIAlBgAVqQcAAIBQgBBAoIAggCUHABWpBwAAgFCAEECggCCAJQYAGakHAACAUIAQQKCAIIAlB -wAZqQcAAIBQgBBAoIAggCUGAB2pBwAAgFCAEECggCCAJQcAHakHAACAUIA8QKCABQRhqIBEpAwA3 -AAAgAUEQaiASKQMANwAAIAFBCGogEykDADcAACABIAgpAwA3AAAgC0EEaiELIAFBIGohASAUQgF8 -IRQgDUEBayINDQALCyAIQSBqJAAgDEUNASAHQcgBakIANwMAIAdBwAFqQgA3AwAgB0G4AWpCADcD -ACAHQbABakIANwMAIAdBqAFqQgA3AwAgB0GgAWpCADcDACAHQZgBakIANwMAIAdB2AFqIgEgAkEI -aikCADcDACAHQeABaiIIIAJBEGopAgA3AwAgB0HoAWoiCSACQRhqKQIANwMAIAdCADcDkAEgByAE -OgD6ASAHQQA7AfgBIAcgAikCADcD0AEgByADIAqtfDcD8AEgB0GQAWogACAOaiAMEEYhACAHQdAA -aiABKQMANwMAIAdB2ABqIAgpAwA3AwAgB0HgAGogCSkDADcDACAHQRBqIABBCGopAwA3AwAgB0EY -aiAAQRBqKQMANwMAIAdBIGogAEEYaikDADcDACAHQShqIABBIGopAwA3AwAgB0EwaiAAQShqKQMA -NwMAIAdBOGogAEEwaikDADcDACAHQUBrIABBOGopAwA3AwAgByAHKQPQATcDSCAHIAApAwA3Awgg -By0A+gEhACAHLQD5ASECIAcgBy0A+AEiBDoAcCAHIAcpA/ABIgM3A2ggByAAIAJFckECciIAOgBx -IAdBmAJqIgIgCSkDADcDACAHQZACaiIJIAgpAwA3AwAgB0GIAmoiCCABKQMANwMAIAcgBykD0AE3 -A4ACIAdBgAJqIAdBCGogBCADIAAQKCAKQQV0IgBBIGoiASAGSw0CIAIoAgAhASAJKAIAIQIgCCgC -ACEEIAcoApQCIQYgBygCjAIhCCAHKAKEAiEJIAcoAoACIQsgACAFaiIAIAcoApwCNgAcIAAgATYA -GCAAIAY2ABQgACACNgAQIAAgCDYADCAAIAQ2AAggACAJNgAEIAAgCzYAACAKQQFqIQoMAQsgAUJ/ -IAGtQgF8QgGIQgF9eYinIghNDQIgB0EIaiIJQQBBgAH8CwAgACAIQQFqIgggAiADIAQgCUEgQcAA -IAhBgAhGGyIKECohCyAAIAhqIAEgCGsgAiADIAhBCnatfCAEIAkgCmpBgAEgCmsQKiALQQFGBEAg -BkE/TQ0EIAUgBykACDcAACAFQThqIAdBQGspAAA3AAAgBUEwaiAHQThqKQAANwAAIAVBKGogB0Ew -aikAADcAACAFQSBqIAdBKGopAAA3AAAgBUEYaiAHQSBqKQAANwAAIAVBEGogB0EYaikAADcAACAF -QQhqIAdBEGopAAA3AABBAiEKDAELIAtqQQV0IgBBgQFPDQQgB0EIaiAAIAIgBCAFIAYQQSEKCyAH -QaACaiQAIAoPCyABIAZBtLrAABDRAQALIAdBADYCGCAHQQE2AgwgB0G8ucAANgIIIAdCBDcCECAH -QQhqQYS7wAAQnwEAC0HAACAGQZS7wAAQ0QEACyAAQYABQaS7wAAQ0QEAC/IIAgV/A34CQAJAAkAg -AUEITwRAIAFBB3EiAkUNASAAKAKgASIDQSlPDQIgA0UEQCAAQQA2AqABDAILIANBAWtB/////wNx -IgVBAWoiBEEDcSEGIAJBAnRBwOTAAGooAgAgAnatIQkCQCAFQQNJBEAgACECDAELIARB/P///wdx -IQUgACECA0AgAiACNQIAIAl+IAh8Igc+AgAgAkEEaiIEIAQ1AgAgCX4gB0IgiHwiBz4CACACQQhq -IgQgBDUCACAJfiAHQiCIfCIHPgIAIAJBDGoiBCAENQIAIAl+IAdCIIh8Igc+AgAgB0IgiCEIIAJB -EGohAiAFQQRrIgUNAAsLIAYEQANAIAIgAjUCACAJfiAIfCIHPgIAIAJBBGohAiAHQiCIIQggBkEB -ayIGDQALCyAAIAdCgICAgBBaBH8gA0EoRg0EIAAgA0ECdGogCD4CACADQQFqBSADCzYCoAEMAQsg -ACgCoAEiA0EpTw0BIANFBEAgAEEANgKgAQ8LIAFBAnRBwOTAAGo1AgAhCSADQQFrQf////8DcSIB -QQFqIgJBA3EhBgJAIAFBA0kEQCAAIQIMAQsgAkH8////B3EhBSAAIQIDQCACIAI1AgAgCX4gCHwi -Bz4CACACQQRqIgEgATUCACAJfiAHQiCIfCIHPgIAIAJBCGoiASABNQIAIAl+IAdCIIh8Igc+AgAg -AkEMaiIBIAE1AgAgCX4gB0IgiHwiBz4CACAHQiCIIQggAkEQaiECIAVBBGsiBQ0ACwsgBgRAA0Ag -AiACNQIAIAl+IAh8Igc+AgAgAkEEaiECIAdCIIghCCAGQQFrIgYNAAsLIAAgB0KAgICAEFoEfyAD -QShGDQMgACADQQJ0aiAIPgIAIANBAWoFIAMLNgKgAQ8LAkAgAUEIcQRAIAAoAqABIgNBKU8NAgJA -IANFBEBBACEDDAELIANBAWtB/////wNxIgJBAWoiBUEDcSEGAkAgAkEDSQRAQgAhByAAIQIMAQsg -BUH8////B3EhBUIAIQcgACECA0AgAiACNQIAQuHrF34gB3wiBz4CACACQQRqIgQgBDUCAELh6xd+ -IAdCIIh8Igc+AgAgAkEIaiIEIAQ1AgBC4esXfiAHQiCIfCIHPgIAIAJBDGoiBCAENQIAQuHrF34g -B0IgiHwiCD4CACAIQiCIIQcgAkEQaiECIAVBBGsiBQ0ACwsgBgRAA0AgAiACNQIAQuHrF34gB3wi -CD4CACACQQRqIQIgCEIgiCEHIAZBAWsiBg0ACwsgCEKAgICAEFQNACADQShGDQIgACADQQJ0aiAH -PgIAIANBAWohAwsgACADNgKgAQsgAUEQcQRAIABBsNHAAEECEDMLIAFBIHEEQCAAQbjRwABBAxAz -CyABQcAAcQRAIABBxNHAAEEFEDMLIAFBgAFxBEAgAEHY0cAAQQoQMwsgAUGAAnEEQCAAQYDSwABB -ExAzCyAAIAEQLRoPCwwBCyADQShB3PvAABDRAQALQShBKEHc+8AAEH8AC7cIAgx/AX4jAEHAAWsi -AiQAIAEoAhAhAyACIAFBEGoiBDYCICACIAM2AhwgAiACQb8BaiIGNgIYIAJBgAFqIgUgASACQRhq -IgcQSgJAAkACQCACKQOAASIOQgJRDQAgAkH4AGoiAyACQagBaikDADcDACACQfAAaiIIIAJBoAFq -KQMANwMAIAJB6ABqIgkgAkGYAWopAwA3AwAgAkHgAGoiCiACQZABaikDADcDACACIAIpA4gBNwNY -IA6nQQFxRQ0AIAJB0ABqIgsgAykDADcDACACQcgAaiIMIAgpAwA3AwAgAkFAayINIAkpAwA3AwAg -AkE4aiIIIAopAwA3AwAgAiACKQNYNwMwQeWAwQAtAAAaQaABQQgQwAEiA0UNAiADIAIpAzA3AwAg -A0EgaiALKQMANwMAIANBGGogDCkDADcDACADQRBqIA0pAwA3AwAgA0EIaiAIKQMANwMAIAJBATYC -FCACIAM2AhAgAkEENgIMIAJBKGoiCSAEKAIAIgQ2AgAgAkEgaiABQQhqKQIANwMAIAIgASkCADcD -GCACIAk2ArgBIAIgBDYCtAEgAiAGNgKwASAFIAcgAkGwAWoQSgJAIAIpA4ABIg5CAlENACACQYgB -aiEEQSghAUEBIQYDQCACQfgAaiIFIARBIGopAwA3AwAgAkHwAGoiByAEQRhqKQMANwMAIAJB6ABq -IgogBEEQaikDADcDACACQeAAaiINIARBCGopAwA3AwAgAiAEKQMANwNYIA6nQQFxRQ0BIAsgBSkD -ADcDACAMIAcpAwA3AwAgAkFAayIHIAopAwA3AwAgCCANKQMANwMAIAIgAikDWDcDMCACKAIMIAZG -BEAgAkEMaiAGQQFBCEEoEFcgAigCECEDCyABIANqIgUgAikDMDcDACAFQSBqIAspAwA3AwAgBUEY -aiAMKQMANwMAIAVBEGogBykDADcDACAFQQhqIAgpAwA3AwAgAiAGQQFqIgY2AhQgAigCKCEFIAIg -CTYCuAEgAiAFNgK0ASABQShqIQEgAiACQb8BajYCsAEgAkGAAWogAkEYaiACQbABahBKIAIpA4AB -Ig5CAlINAAsLIAIoAiQiASACKAIcIgNHBEAgASADa0EEdiEEA0AgAygCACIBBEAgA0EEaigCACAB -EMwBCyADQRBqIQMgBEEBayIEDQALCyACKAIgIgEEQCACKAIYIAFBBHQQzAELIAAgAikCDDcCACAA -QQhqIAJBFGooAgA2AgAMAQsgAEEANgIIIABCgICAgIABNwIAIAEoAgwiACABKAIEIgNHBEAgACAD -a0EEdiEEA0AgAygCACIABEAgA0EEaigCACAAEMwBCyADQRBqIQMgBEEBayIEDQALCyABKAIIIgBF -DQAgASgCACAAQQR0EMwBCyACQcABaiQADwtBCEGgAUGok8AAELIBAAvLCAEIfwJAIAFBgApJBEAg -AUEFdiEHAkACQCAAKAKgASIFBEAgBUEBayEDIAVBAnQgAGpBBGshAiAFIAdqQQJ0IABqQQRrIQYg -BUEpSSEFA0AgBUUNAiADIAdqIgRBKE8NAyAGIAIoAgA2AgAgBkEEayEGIAJBBGshAiADQQFrIgNB -f0cNAAsLIAFBIEkNAyAAQQA2AgAgB0EBaiICQQJGDQMgAEEANgIEIAJBA0YNAyAAQQA2AgggAkEE -Rg0DIABBADYCDCACQQVGDQMgAEEANgIQIAJBBkYNAyAAQQA2AhQgAkEHRg0DIABBADYCGCACQQhG -DQMgAEEANgIcIAJBCUYNAyAAQQA2AiAgAkEKRg0DIABBADYCJCACQQtGDQMgAEEANgIoIAJBDEYN -AyAAQQA2AiwgAkENRg0DIABBADYCMCACQQ5GDQMgAEEANgI0IAJBD0YNAyAAQQA2AjggAkEQRg0D -IABBADYCPCACQRFGDQMgAEEANgJAIAJBEkYNAyAAQQA2AkQgAkETRg0DIABBADYCSCACQRRGDQMg -AEEANgJMIAJBFUYNAyAAQQA2AlAgAkEWRg0DIABBADYCVCACQRdGDQMgAEEANgJYIAJBGEYNAyAA -QQA2AlwgAkEZRg0DIABBADYCYCACQRpGDQMgAEEANgJkIAJBG0YNAyAAQQA2AmggAkEcRg0DIABB -ADYCbCACQR1GDQMgAEEANgJwIAJBHkYNAyAAQQA2AnQgAkEfRg0DIABBADYCeCACQSBGDQMgAEEA -NgJ8IAJBIUYNAyAAQQA2AoABIAJBIkYNAyAAQQA2AoQBIAJBI0YNAyAAQQA2AogBIAJBJEYNAyAA -QQA2AowBIAJBJUYNAyAAQQA2ApABIAJBJkYNAyAAQQA2ApQBIAJBJ0YNAyAAQQA2ApgBIAJBKEYN -AyAAQQA2ApwBIAJBKUYNA0EoQShB3PvAABB/AAsgA0EoQdz7wAAQfwALIARBKEHc+8AAEH8AC0GG -/MAAQR1B3PvAABCUAQALIAAoAqABIgMgB2ohAiABQR9xIgZFBEAgACACNgKgASAADwsCQCACQQFr -IgRBJ00EQCACIQUgACAEQQJ0aigCAEEAIAFrIgF2IgRFDQEgAkEnTQRAIAAgAkECdGogBDYCACAC -QQFqIQUMAgsgAkEoQdz7wAAQfwALIARBKEHc+8AAEH8ACwJAIAdBAWoiCCACTw0AIAFBH3EhASAD -QQFxRQRAIAAgAkEBayICQQJ0aiIEIAQoAgAgBnQgBEEEaygCACABdnI2AgALIANBAkYNACACQQJ0 -IABqQQxrIQMDQCADQQhqIgQgBCgCACAGdCADQQRqIgQoAgAiCSABdnI2AgAgBCAJIAZ0IAMoAgAg -AXZyNgIAIANBCGshAyAIIAJBAmsiAkkNAAsLIAAgB0ECdGoiASABKAIAIAZ0NgIAIAAgBTYCoAEg -AAv/CQMMfwF+AW9B5IXAACEDIwBB0ABrIgIkACACIAE2AgwCQAJAAkACQCABEO4BQQFGBEAgAiAB -NgIgIAJBADYCECACQeSFwAA2AhggAkH0hcAANgIcIAJBIGohCkGAgICAeCEBA0AgAiADQQhqNgIY -IAIgAygCACADKAIEED02AjggCigCACUBIAJBOGooAgAlARANIQ8QbyIFIA8mAQJAAkACQAJAAkAC -QCAFJQEQBEEBRgRAIAIoAjglASACKAIgJQEQBUEBRw0BCwJAIAIoAhBFDQAgAigCFCIHQYQBSQ0A -IAcQbAsgAiAFNgIUIAJBATYCECADKAIAIQUCfwJAAkACQCADKAIEQQRrDgMBAgACC0EAIQdBBiEI -QduFwAAhAwJAA0AgBS0AACILIAMtAAAiDEYEQCAFQQFqIQUgA0EBaiEDIAhBAWsiCA0BDAILCyAL -IAxrIQcLIAcNAUEBDAILQQAgBSgAAEHXhcAAKAAARg0BGgtBAgsgAigCOCIFQYMBSwRAIAUQbAtB -AWsOAgMBAgsgBUGEAU8EQCAFEGwLIAIoAjgiA0GEAU8EQCADEGwLIAIoAhgiAyACKAIcRw0FDAcL -IAIoAhAgAkEANgIQQQFGBEAgAigCFCIDQYQBSQ0EIAMQbAwECwwJCyABQYCAgIB4RwRAQYGLwABB -BBCEASEEDAILIAIoAhAgAkEANgIQRQ0IIAIgAigCFCIDNgI4IAIgAxDqAQJ/IAIoAgAiBgRAIAIo -AgQiDQwBCyACQThqIAJBzwBqQaCKwAAQQiEGQYCAgIB4CyEBIANBhAFPBEAgAxBsCyABQYCAgIB4 -Rw0CIABBgICAgHg2AgAgACAGNgIEDAYLIAlFBEAgAigCECACQQA2AhBBAUcNCCACIAIoAhQ2AiQg -AkEoaiIEIAJBJGoiAygCACUBEB4EfiAEIAMoAgAlARAK/AY3AwhCAQVCAAs3AwACfwJAIAIoAihB -AUYEQCACKQMwIg5CAFkNAQsgAkEkaiACQc8AakGAicAAEEIhBEEBDAELIA5CgICAgBBaBEAgAkEB -OgA4IAIgDjcDQCMAQTBrIgMkACADQYCJwAA2AgQgAyACQc8AajYCACADQQI2AgwgA0GwkMAANgII -IANCAjcCFCADIAOtQoCAgIDgAYQ3AyggAyACQThqrUKAgICA8AGENwMgIAMgA0EgajYCECADQQhq -EGMhBCADQTBqJABBAQwBCyAOpyEEQQALIAIoAiQiBUGEAU8EQCAFEGwLQQEhCUUNAgwBC0GFi8AA -QQYQhAEhBAsgAEGAgICAeDYCACAAIAQ2AgQgAUGAgICAeHJBgICAgHhGDQQgBiABEMwBDAQLIAIo -AhgiAyACKAIcRw0ACwwBCyACQQxqIAJBzwBqQcCKwAAQQiEEIABBgICAgHg2AgAgACAENgIEIAFB -hAFJDQIgARBsDAILIAFBgICAgHhHBEAgCQRAIAAgBDYCDCAAIA02AgggACAGNgIEIAAgATYCAAwC -C0GFi8AAQQYQgwEhBCAAQYCAgIB4NgIAIAAgBDYCBCABRQ0BIAYgARDMAQwBC0GBi8AAQQQQgwEh -ASAAQYCAgIB4NgIAIAAgATYCBAsgAigCICIAQYQBTwRAIAAQbAsgAigCEEUNACACKAIUIgBBgwFN -DQAgABBsCyACQdAAaiQADwtB0IrAAEExEOIBAAu9CwMGfwF+AW8jAEHQAGsiAiQAIAIgATYCIAJA -AkACQAJAAkAgAkEgaiIBKAIAJQEQHARAIAJBJGoiAyABKAIAJQEQEDYCCCADQQA2AgQgAyABNgIA -QQAhASACQQA2AjAgAigCJARAIAIoAiwiAyACKAIoIgRNBEBBBCEDDAMLQeWAwQAtAAAaQYCABCAD -IARrIgFBACABIANNGyIBIAFBgIAETxsiAUEEdCIEQQQQwAEiAw0CQQQgBEGAisAAELIBAAsgAkEA -NgI8IAJCgICAgMAANwI0DAILIAJBQGshARAXIQkQbyIDIAkmASADIQUgAkEgaigCACIEJQEgAyUB -EBghCRBvIgMgCSYBQaiBwQAoAgAhBkGkgcEAKAIAIQdBpIHBAEIANwIAAkACQAJAIAdBAUYEQCAB -QQM6AAQgASAGNgIADAELAkAgAxDvAUEBRgRAIAMlASAEJQEQGSEJEG8iBCAJJgFBqIHBACgCACEG -QaSBwQAoAgAhB0GkgcEAQgA3AgACQCAHQQFGBEAgAUEDOgAEIAEgBjYCAAwBCwJAIAQQ7gFBAUcN -ACAEJQEQEyEJEG8iBiAJJgEgBhDvASAGQYQBTwRAIAYQbAtBAUcNACABQQA6AAQgASAENgIAIANB -hAFPBEAgAxBsCyAFQYQBSQ0GDAULIAFBAjoABCAEQYQBSQ0AIAQQbAsgA0GEAU8NAQwCCyABQQI6 -AAQgA0GEAUkNAQsgAxBsCyAFQYMBTQ0BCyAFEGwLIAIoAkAhAQJAAkACQCACLQBEIgNBAmsOAgIA -AQsgAEGAgICAeDYCACAAIAE2AgQgAigCICIBQYMBSw0FDAYLIAIgAzoAOCACIAE2AjQgAkEANgIs -IAJCgICAgMAANwIkIAJBGGogAkE0ahB6AkAgAigCGCIDQQJHBEAgAigCHCEBA0ACQCADQQFxRQRA -IAJBQGsgARAuIAIoAkQhASACKAJAIgVBgICAgHhHDQELIABBgICAgHg2AgAgACABNgIEIAIoAiwi -AwRAIAIoAighAQNAIAEoAgAiAARAIAFBBGooAgAgABDMAQsgAUEQaiEBIANBAWsiAw0ACwsgAigC -JCIABEAgAigCKCAAQQR0EMwBCyACKAI0IgFBgwFLDQMMBwsgAikCSCEIIAIoAiwiAyACKAIkRgRA -IAJBJGpBkIrAABBoCyACKAIoIANBBHRqIgQgCDcCCCAEIAE2AgQgBCAFNgIAIAIgA0EBajYCLCAC -QRBqIAJBNGoQeiACKAIUIQEgAigCECIDQQJHDQALCyAAIAIpAiQ3AgAgAEEIaiACQSxqKAIANgIA -IAIoAjQiAUGDAU0NBAsgARBsDAMLIAJBIGogAkFAa0GwisAAEEIhASAAQYCAgIB4NgIAIAAgATYC -BAwCCyACQQA2AjwgAiADNgI4IAIgATYCNANAIAJBCGohAyACQSRqIgEoAgQiBCABKAIITwR/QQAF -IAEgBEEBajYCBCABKAIAKAIAJQEgBBAPIQkQbyIBIAkmAUEBCyEEIAMgATYCBCADIAQ2AgAgAigC -CEEBcUUNASACKAIMIQEgAiACKAIwQQFqNgIwIAJBQGsgARAuIAIoAkQhASACKAJAIgVBgICAgHhG -BEAgAEGAgICAeDYCACAAIAE2AgQgAigCPCIDBEAgAigCOCEBA0AgASgCACIABEAgAUEEaigCACAA -EMwBCyABQRBqIQEgA0EBayIDDQALCyACKAI0IgBFDQMgAigCOCAAQQR0EMwBDAMLIAIpAkghCCAC -KAI8IgMgAigCNEYEQCACQTRqQZCKwAAQaAsgAigCOCADQQR0aiIEIAg3AgggBCABNgIEIAQgBTYC -ACACIANBAWo2AjwgAigCJA0ACwsgACACKQI0NwIAIABBCGogAkE8aigCADYCAAsgAigCICIBQYMB -TQ0BCyABEGwLIAJB0ABqJAALzwYBCH8CQAJAIAEgAEEDakF8cSIDIABrIghJDQAgASAIayIGQQRJ -DQAgBkEDcSEHQQAhAQJAIAAgA0YiCQ0AAkAgACADayIFQXxLBEBBACEDDAELQQAhAwNAIAEgACAD -aiICLAAAQb9/SmogAkEBaiwAAEG/f0pqIAJBAmosAABBv39KaiACQQNqLAAAQb9/SmohASADQQRq -IgMNAAsLIAkNACAAIANqIQIDQCABIAIsAABBv39KaiEBIAJBAWohAiAFQQFqIgUNAAsLIAAgCGoh -AAJAIAdFDQAgACAGQXxxaiIDLAAAQb9/SiEEIAdBAUYNACAEIAMsAAFBv39KaiEEIAdBAkYNACAE -IAMsAAJBv39KaiEECyAGQQJ2IQUgASAEaiEEA0AgACEDIAVFDQJBwAEgBSAFQcABTxsiBkEDcSEH -IAZBAnQhCEEAIQIgBUEETwRAIAAgCEHwB3FqIQkgACEBA0AgASgCACIAQX9zQQd2IABBBnZyQYGC -hAhxIAJqIAFBBGooAgAiAEF/c0EHdiAAQQZ2ckGBgoQIcWogAUEIaigCACIAQX9zQQd2IABBBnZy -QYGChAhxaiABQQxqKAIAIgBBf3NBB3YgAEEGdnJBgYKECHFqIQIgAUEQaiIBIAlHDQALCyAFIAZr -IQUgAyAIaiEAIAJBCHZB/4H8B3EgAkH/gfwHcWpBgYAEbEEQdiAEaiEEIAdFDQALAn8gAyAGQfwB -cUECdGoiACgCACIBQX9zQQd2IAFBBnZyQYGChAhxIgEgB0EBRg0AGiABIAAoAgQiAUF/c0EHdiAB -QQZ2ckGBgoQIcWoiASAHQQJGDQAaIAAoAggiAEF/c0EHdiAAQQZ2ckGBgoQIcSABagsiAUEIdkH/ -gRxxIAFB/4H8B3FqQYGABGxBEHYgBGoPCyABRQRAQQAPCyABQQNxIQMCQCABQQRJBEAMAQsgAUF8 -cSEFA0AgBCAAIAJqIgEsAABBv39KaiABQQFqLAAAQb9/SmogAUECaiwAAEG/f0pqIAFBA2osAABB -v39KaiEEIAUgAkEEaiICRw0ACwsgA0UNACAAIAJqIQEDQCAEIAEsAABBv39KaiEEIAFBAWohASAD -QQFrIgMNAAsLIAQLlQgCC38DfiMAQeAAayIEJAAgAq1CKH4iDqchAwJAIA5CIIinIANB+P///wdL -cg0AAn8gA0UEQEEIIQZBAAwBC0HlgMEALQAAGkEIIQcgA0EIEMABIgZFDQEgAgshCyADBEAgBiAB -IAP8CgAACyACQQJPBEAgBkHQAGohDCAEQdwAaq1CgICAgBCEIQ4gBEHYAGqtQoCAgIAghCEPA0BB -ACEDQQAhBQJAAkACQAJAAkACQANAIAMhCiACIAVJDQUgBUEobCEJAkAgAiAFayIBQQNJDQBBCSAB -IAFBCU8bIQggCSAMaiEDQQIhAQNAIAEgCEYEQCAIIQEMAgsgAUEBaiEBIAMpAxhCA4MgA0EoaiED -QgBSDQALCyABIAVqIgggAUkNASACIAhJDQJBlIHBACEFQZCBwQAoAgBFBEACf0HlgMEALQAAGkGA -CEEBEMABIgMEQEGggcEAQQA2AgBBlIHBAEEANgIAQZyBwQAoAgAhBUGcgcEAIAM2AgBBmIHBACgC -ACEDQZiBwQBBgAg2AgBBkIHBACgCAEGQgcEAQQE2AgBFIANFckUEQCAFIAMQzAELQZSBwQAMAQtB -AUGACEHwiMAAELIBAAshBQsgBSgCAA0DQQAhAyAFQQA2AgwgBUF/NgIAQQAhByABBEAgBUEEaiEN -IAYgCWoiAyABQShsaiEJA0AgBCADNgJYIAQgA0EgaiIBNgJcIARBAzYCNCAEQZiMwAA2AjAgBEIC -NwI8IAQgDjcDECAEIA83AwggBCAEQQhqNgI4IA1BhJHAACAEQTBqEDwNBiABKAIAIAdqIQcgAUEI -aiIDIAlHDQALIAUoAgwhAwsgBEEwakGIucAAIAUoAgggAxA0IARB0ABqIgEgBzYCACAFIAUoAgBB -AWo2AgAgBEEQaiIDIARBOGopAwA3AwAgBEEYaiIFIARBQGspAwA3AwAgBEEgaiIHIARByABqKQMA -NwMAIARBKGoiCSABKQMANwMAIAQgBCkDMDcDCCACIApLBEAgBiAKQShsaiIBIAQpAwg3AwAgAUEg -aiAJKQMANwMAIAFBGGogBykDADcDACABQRBqIAUpAwA3AwAgAUEIaiADKQMANwMAIApBAWohAyAI -IgUgAkYNBwwBCwsgCiACQfyAwAAQfwALIAUgCEHsgMAAENIBAAsgCCACQeyAwAAQ0QEAC0HkjcAA -EIsBAAtBwIzAAEErIARBMGpBsIzAAEHUjcAAEHwACyAFIAJBjIHAABDQAQALIAMhAiAKDQALCyAA -IAYpAwA3AwAgAEEYaiAGQRhqKQMANwMAIABBEGogBkEQaikDADcDACAAQQhqIAZBCGopAwA3AwAg -BiALQShsEMwBIARB4ABqJAAPCyAHIANBuIXAABCyAQALyQcCCn8CfiMAQTBrIgYkAAJAAkACQAJA -AkACQAJAIANFDQACfyABKAIYIgcgASgCKCIFQUBrTQRAIAEoAhwgBWsiByADIAMgB0sbIQhBACEH -IAFBHGoMAQsgASgCHCAFayIJIAMgAyAJSxshCCAJIAMgByAFa0HBAGsiByADIAdJGyIHSQ0CIAUg -B2ohBSABQRxqCyEJIAZBCGohCiACIAdqIQ0gCCAHayELIAEpAxAhEEEAIQggASkDACEPIAEoAggh -DgNAAkAgCCALRgRAQQAhDAwBCyABIA4gCCANai0AAEEDdGopAwAgD0IBhnwiDzcDAEEBIQwgCEEB -aiEIIA8gEINCAFINAQsLIAogCDYCBCAKIAw2AgACQAJAIAYoAghBAXEEQCAJKAIAIgggBigCDCIE -IAVqTQ0BDAILIAkoAgAiCCAFIAtqSw0CCyAIIAVrIQQLIAFCADcDACAEIAdqIQUgASgCKCIHRQRA -IAMgBUkNAyAGQSBqIAIgBRB3DAYLIAMgBUkNAyABQSBqIQMgASgCICAHayAFSQRAIAMgByAFEFgg -ASgCKCEHCyAFBEAgASgCJCAHaiACIAX8CgAACyABIAUgB2o2AiggBkEYaiADQQhqKAIANgIAIAFB -ADYCKCADKQIAIQ8gAUKAgICAEDcDICAGIA83AxAgBkEgaiAGQRBqEHQMBQsgBEUEQCABKAIgIAEo -AigiBWsgA0kEQCABQSBqIAUgAxBYIAEoAighBQsgAwRAIAEoAiQgBWogAiAD/AoAAAsgACADNgIw -IABBADYCACABIAMgBWo2AigMBgsgASgCKCIFRQ0DIAFBIGohBCABKAIgIAVrIANJBEAgBCAFIAMQ -WCABKAIoIQULIAMEQCABKAIkIAVqIAIgA/wKAAALIAEgAyAFajYCKCAGQRhqIARBCGooAgA2AgAg -AUEANgIoIAQpAgAhDyABQoCAgIAQNwMgIAYgDzcDECAGQSBqIAZBEGoQdCADIQUMBAsgByAIQZiY -wAAQ0gEACyAFIANBqJjAABDRAQALIAUgA0G4mMAAENEBAAsgBkEgaiACIAMQdyADIQULIAZBGGog -BkEoaikCACIPNwMAIAYgBikCIDcDECAPpyIBRQRAIABBADYCMCAAQQA2AgAgBkEcaiAGKAIUQQAg -BigCECgCEBEDAAwBCyAGKAIQIQIgBigCHCEDIABBEGpB6LjAACAGKAIUIgQgARA0IAAgBTYCMCAA -IAM2AgwgACABNgIIIAAgBDYCBCAAIAI2AgALIAZBMGokAAvYBQIMfwN+IwBBoAFrIgkkACAJQQBB -oAH8CwACQAJAAkAgAiAAKAKgASIFTQRAIAVBKU8NASABIAJBAnRqIQwCQAJAIAUEQCAFQQFqIQ0g -BUECdCEKA0AgCSAGQQJ0aiEDA0AgBiECIAMhBCABIAxGDQggA0EEaiEDIAJBAWohBiABKAIAIQcg -AUEEaiILIQEgB0UNAAsgB60hEUIAIQ8gCiEHIAIhASAAIQMDQCABQShPDQQgBCAPIAQ1AgB8IAM1 -AgAgEX58IhA+AgAgEEIgiCEPIARBBGohBCABQQFqIQEgA0EEaiEDIAdBBGsiBw0ACyAIIBBCgICA -gBBaBH8gAiAFaiIBQShPDQMgCSABQQJ0aiAPPgIAIA0FIAULIAJqIgEgASAISRshCCALIQEMAAsA -CwNAIAEgDEYNBiAEQQFqIQQgASgCACABQQRqIQFFDQAgCCAEQQFrIgIgAiAISRshCAwACwALIAFB -KEHc+8AAEH8ACyABQShB3PvAABB/AAsgBUEpTw0BIAJBAnQhDCACQQFqIQ0gACAFQQJ0aiEOIAAh -AwJAA0AgCSAHQQJ0aiEGA0AgByELIAYhBCADIA5GDQUgBEEEaiEGIAdBAWohByADKAIAIQogA0EE -aiIFIQMgCkUNAAsgCq0hEUIAIQ8gDCEKIAshAyABIQYDQCADQShPDQIgBCAPIAQ1AgB8IAY1AgAg -EX58IhA+AgAgEEIgiCEPIARBBGohBCADQQFqIQMgBkEEaiEGIApBBGsiCg0ACwJAIAggEEKAgICA -EFoEfyACIAtqIgNBKE8NASAJIANBAnRqIA8+AgAgDQUgAgsgC2oiAyADIAhJGyEIIAUhAwwBCwsg -A0EoQdz7wAAQfwALIANBKEHc+8AAEH8ACyAFQShB3PvAABDRAQALIAVBKEHc+8AAENEBAAsgACAJ -QaAB/AoAACAAIAg2AqABIAlBoAFqJAAL5AgCCn8BfiMAQYACayIEJAAgBCABKQAYNwIYIAQgASkA -EDcCECAEIAEpAAg3AgggBCABKQAANwIAAn8gA0GBCE8EQCAEQSBqIQUjAEHgAGsiASQAIAFBOGoi -BkIANwMAIAFBMGoiB0IANwMAIAFBKGoiCEIANwMAIAFBIGoiCUIANwMAIAFBGGoiCkIANwMAIAFB -EGoiC0IANwMAIAFBCGoiDEIANwMAIAFCADcDACACIAMgBEIAQRAgAUHAABAqIQMgAUHYAGpCADcD -ACABQdAAakIANwMAIAFByABqQgA3AwAgAUIANwNAAkACQAJAAkAgA0EDTwRAA0AgA0EFdCICQcEA -Tw0CIAEgAiAEQRAgAUFAayINQSAQQSIDQQV0IgJBwQBPDQMgAkEhTw0EIAIEQCABIA0gAvwKAAAL -IANBAksNAAsLIAUgASkDADcAACAFQThqIAYpAwA3AAAgBUEwaiAHKQMANwAAIAVBKGogCCkDADcA -ACAFQSBqIAkpAwA3AAAgBUEYaiAKKQMANwAAIAVBEGogCykDADcAACAFQQhqIAwpAwA3AAAgAUHg -AGokAAwDCyACQcAAQbS7wAAQ0QEACyACQcAAQcS7wAAQ0QEACyACQSBB1LvAABDRAQALIARB+ABq -IARBGGopAgA3AwAgBEHwAGogBEEQaikCADcDACAEQegAaiAEQQhqKQIANwMAIAQgBCkCADcDYEHA -ACEDQRQMAQsgBEHIAWpCADcDACAEQcABakIANwMAIARBuAFqQgA3AwAgBEGwAWpCADcDACAEQagB -akIANwMAIARBmAFqQgA3AwAgBEEQOgD6ASAEQaABakIANwMAIARB2AFqIgUgBEEIaikCADcDACAE -QegBaiIGIARBGGopAgA3AwAgBEHgAWoiByAEQRBqKQIANwMAIARCADcDkAEgBCAEKQIANwPQASAE -QQA7AfgBIARCADcD8AEgBEGQAWogAiADEEYhASAEQegAaiAFKQMANwMAIARB8ABqIAcpAwA3AwAg -BEH4AGogBikDADcDACAEQShqIAFBCGopAwA3AwAgBEEwaiABQRBqKQMANwMAIARBOGogAUEYaikD -ADcDACAEQUBrIAFBIGopAwA3AwAgBEHIAGogAUEoaikDADcDACAEQdAAaiABQTBqKQMANwMAIARB -2ABqIAFBOGopAwA3AwAgBCAEKQPQATcDYCAEIAEpAwA3AyAgBCkD8AEhDiAELQD4ASEDIAQtAPoB -IAQtAPkBRXJBAnILIQEgBCAONwOAASAEIAM6AIgBIAQgAToAiQEgBEGoAWoiAiAEQfgAaikDADcD -ACAEQaABaiIFIARB8ABqKQMANwMAIARBmAFqIgYgBEHoAGopAwA3AwAgBCAEKQNgNwOQASAEQZAB -aiAEQSBqIANCACABQQhyECggACACKQMANwAYIAAgBSkDADcAECAAIAYpAwA3AAggACAEKQOQATcA -ACAEQYACaiQAC74LAQV/IwBBIGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEOKAYBAQEB -AQEBAQIEAQEDAQEBAQEBAQEBAQEBAQEBAQEBAQEIAQEBAQcACyABQdwARg0ECyACQQFxRSABQf8F -TXINBwJ/AkBBEUEAIAFBr7AETxsiAiACQQhyIgMgAUELdCICIANBAnRBqP/AAGooAgBBC3RJGyID -IANBBHIiAyADQQJ0Qaj/wABqKAIAQQt0IAJLGyIDIANBAnIiAyADQQJ0Qaj/wABqKAIAQQt0IAJL -GyIDIANBAWoiAyADQQJ0Qaj/wABqKAIAQQt0IAJLGyIDIANBAWoiAyADQQJ0Qaj/wABqKAIAQQt0 -IAJLGyIDQQJ0Qaj/wABqKAIAQQt0IgUgAkYgAiAFS2ogA2oiA0EhTQRAIANBAnRBqP/AAGoiBigC -AEEVdiECQe8FIQUCfwJAIANBIUYNACAGKAIEQRV2IQUgAw0AQQAMAQsgBkEEaygCAEH///8AcQsh -AwJAIAUgAkF/c2pFDQAgASADayEHQe8FIAIgAkHvBU0bIQYgBUEBayEDQQAhBQNAIAIgBkYNAyAF -IAJB4MrAAGotAABqIgUgB0sNASADIAJBAWoiAkcNAAsgAyECCyACQQFxDAILIANBIkGc+8AAEH8A -CyAGQe8FQaz7wAAQfwALRQ0HIARBADoACiAEQQA7AQggBCABQRR2QafnwABqLQAAOgALIAQgAUEE -dkEPcUGn58AAai0AADoADyAEIAFBCHZBD3FBp+fAAGotAAA6AA4gBCABQQx2QQ9xQafnwABqLQAA -OgANIAQgAUEQdkEPcUGn58AAai0AADoADCABQQFyZ0ECdiICIARBCGoiA2oiBUH7ADoAACAFQQFr -QfUAOgAAIAMgAkECayICakHcADoAACAEQRBqIgMgAUEPcUGn58AAai0AADoAACAAQQo6AAsgACAC -OgAKIAAgBCkCCDcCACAEQf0AOgARIABBCGogAy8BADsBAAwJCyAAQYAEOwEKIABCADcBAiAAQdzo -ATsBAAwICyAAQYAEOwEKIABCADcBAiAAQdzkATsBAAwHCyAAQYAEOwEKIABCADcBAiAAQdzcATsB -AAwGCyAAQYAEOwEKIABCADcBAiAAQdy4ATsBAAwFCyAAQYAEOwEKIABCADcBAiAAQdzgADsBAAwE -CyACQYACcUUNASAAQYAEOwEKIABCADcBAiAAQdzOADsBAAwDCyACQf///wdxQYCABE8NAQsCf0EA -IAFBIEkNABpBASABQf8ASQ0AGiABQYCABE8EQCABQeD//wBxQeDNCkcgAUH+//8AcUGe8ApHcSAB -QcDuCmtBeklxIAFBsJ0La0FySXEgAUHw1wtrQXFJcSABQYDwC2tB3mxJcSABQYCADGtBnnRJcSAB -QdCmDGtBe0lxIAFBgII4a0GwxVRJcSABQfCDOElxIAFBgIAITw0BGiABQcjvwABBLEGg8MAAQdAB -QfDxwABB5gMQUQwBCyABQdb1wABBKEGm9sAAQaICQcj4wABBqQIQUQtFBEAgBEEAOgAWIARBADsB -FCAEIAFBFHZBp+fAAGotAAA6ABcgBCABQQR2QQ9xQafnwABqLQAAOgAbIAQgAUEIdkEPcUGn58AA -ai0AADoAGiAEIAFBDHZBD3FBp+fAAGotAAA6ABkgBCABQRB2QQ9xQafnwABqLQAAOgAYIAFBAXJn -QQJ2IgIgBEEUaiIDaiIFQfsAOgAAIAVBAWtB9QA6AAAgAyACQQJrIgJqQdwAOgAAIARBHGoiAyAB -QQ9xQafnwABqLQAAOgAAIABBCjoACyAAIAI6AAogACAEKQIUNwIAIARB/QA6AB0gAEEIaiADLwEA -OwEADAILIAAgATYCBCAAQYABOgAADAELIABBgAQ7AQogAEIANwECIABB3MQAOwEACyAEQSBqJAAL -0wUCB38BfgJ/IAFFBEAgACgCCCEHQS0hCyAFQQFqDAELQStBgIDEACAAKAIIIgdBgICAAXEiARsh -CyABQRV2IAVqCyEIAkAgB0GAgIAEcUUEQEEAIQIMAQsgA0EQTwRAIAIgAxAwIAhqIQgMAQsgA0UN -ACADQQNxIQoCQCADQQRJBEBBACEBDAELIANBDHEhDEEAIQEDQCABIAIgCWoiBiwAAEG/f0pqIAZB -AWosAABBv39KaiAGQQJqLAAAQb9/SmogBkEDaiwAAEG/f0pqIQEgDCAJQQRqIglHDQALCyAKBEAg -AiAJaiEGA0AgASAGLAAAQb9/SmohASAGQQFqIQYgCkEBayIKDQALCyABIAhqIQgLAkAgAC8BDCIJ -IAhLBEACQAJAIAdBgICACHFFBEAgCSAIayEJQQAhAUEAIQgCQAJAAkAgB0EddkEDcUEBaw4DAAEA -AgsgCSEIDAELIAlB/v8DcUEBdiEICyAHQf///wBxIQogACgCBCEHIAAoAgAhAANAIAFB//8DcSAI -Qf//A3FPDQJBASEGIAFBAWohASAAIAogBygCEBEAAEUNAAsMBAsgACAAKQIIIg2nQYCAgP95cUGw -gICAAnI2AghBASEGIAAoAgAiByAAKAIEIgogCyACIAMQmAENA0EAIQEgCSAIa0H//wNxIQIDQCAB -Qf//A3EgAk8NAiABQQFqIQEgB0EwIAooAhARAABFDQALDAMLQQEhBiAAIAcgCyACIAMQmAENAiAA -IAQgBSAHKAIMEQEADQJBACEBIAkgCGtB//8DcSECA0AgAUH//wNxIgMgAkkhBiACIANNDQMgAUEB -aiEBIAAgCiAHKAIQEQAARQ0ACwwCCyAHIAQgBSAKKAIMEQEADQEgACANNwIIQQAPC0EBIQYgACgC -ACIBIAAoAgQiACALIAIgAxCYAQ0AIAEgBCAFIAAoAgwRAQAhBgsgBguKBQIGfwV+QgEhDQJAAkAC -QAJAIAJBwABHDQBBACECA0AgAkHAAEcEQCABIAJqIgMtAAAiBEEwa0H/AXFBCk8EQCAEQV9xQcEA -a0H/AXFBBUsNAwsgAkECaiECIANBAWotAAAiA0Ewa0H/AXFBCkkgA0FfcUHBAGtB/wFxQQZJcg0B -DAILCyABLAAQIgVBQEgNASABQRBqIQZBD0EQIAEtAABBK0YiAhshAyABIAJqIQIDQCACLQAAIgRB -wQBrQV9xQQpqIARBMGsgBEE5SxsiBEEPSw0BIAJBAWohAiAErSAJQgSGhCEJIANBAWsiAw0ACyAB -LAAgIgdBQEgNAiABQSBqIQggAUERaiAGIAVBK0YiAxshAkEPQRAgAxshAwNAIAItAAAiBEHBAGtB -X3FBCmogBEEwayAEQTlLGyIEQQ9LDQEgAkEBaiECIAStIApCBIaEIQogA0EBayIDDQALIAEsADAi -BUFASA0DIAFBMGohBiABQSFqIAggB0ErRiIDGyECQQ9BECADGyEDA0AgAi0AACIEQcEAa0FfcUEK -aiAEQTBrIARBOUsbIgRBD0sNASACQQFqIQIgBK0gC0IEhoQhCyADQQFrIgMNAAsgAUExaiAGIAVB -K0YiARshAkEPQRAgARshAwNAIAItAAAiAUHBAGtBX3FBCmogAUEwayABQTlLGyIBQQ9LDQEgAkEB -aiECIAGtIAxCBIaEIQwgA0EBayIDDQALIAAgDDcDICAAIAs3AxggACAKNwMQIAAgCTcDCEIAIQ0L -IAAgDTcDAA8LIAFBwABBAEEQQbi4wAAQvgEACyABQcAAQRBBIEHIuMAAEL4BAAsgAUHAAEEgQTBB -2LjAABC+AQALhAYCAX8BfCMAQTBrIgIkAAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJA -AkACQAJAIAAtAABBAWsOEQECAwQFBgcICQoLDA0ODxARAAsgAiAALQABOgAIIAJBAjYCFCACQYy9 -wAA2AhAgAkIBNwIcIAIgAkEIaq1CgICAgMAHhDcDKCACIAJBKGo2AhggASgCACABKAIEIAJBEGoQ -PAwRCyACIAApAwg3AwggAkECNgIUIAJBqL3AADYCECACQgE3AhwgAiACQQhqrUKAgICA0AeENwMo -IAIgAkEoajYCGCABKAIAIAEoAgQgAkEQahA8DBALIAIgACkDCDcDCCACQQI2AhQgAkGovcAANgIQ -IAJCATcCHCACIAJBCGqtQoCAgIDgB4Q3AyggAiACQShqNgIYIAEoAgAgASgCBCACQRBqEDwMDwsg -ACsDCCEDIAJBAjYCFCACQci9wAA2AhAgAkIBNwIcIAIgAkEoaq1CgICAgPAHhDcDCCACIAM5Aygg -AiACQQhqNgIYIAEoAgAgASgCBCACQRBqEDwMDgsgAiAAKAIENgIIIAJBAjYCFCACQeS9wAA2AhAg -AkIBNwIcIAIgAkEIaq1CgICAgIAIhDcDKCACIAJBKGo2AhggASgCACABKAIEIAJBEGoQPAwNCyAC -IAApAgQ3AgggAkEBNgIUIAJB/L3AADYCECACQgE3AhwgAiACQQhqrUKAgICAkAiENwMoIAIgAkEo -ajYCGCABKAIAIAEoAgQgAkEQahA8DAwLIAFB+LzAAEEKELwBDAsLIAFBhL7AAEEKELwBDAoLIAFB -jr7AAEEMELwBDAkLIAFBmr7AAEEOELwBDAgLIAFBqL7AAEEIELwBDAcLIAFBsL7AAEEDELwBDAYL -IAFBs77AAEEEELwBDAULIAFBt77AAEEMELwBDAQLIAFBw77AAEEPELwBDAMLIAFB0r7AAEENELwB -DAILIAFB377AAEEOELwBDAELIAEgACgCBCAAKAIIELwBCyACQTBqJAAL/gUBBX8gAEEIayIBIABB -BGsoAgAiA0F4cSIAaiECAkACQCADQQFxDQAgA0ECcUUNASABKAIAIgMgAGohACABIANrIgFB6ITB -ACgCAEYEQCACKAIEQQNxQQNHDQFB4ITBACAANgIAIAIgAigCBEF+cTYCBCABIABBAXI2AgQgAiAA -NgIADwsgASADEEwLAkACQAJAAkACQCACKAIEIgNBAnFFBEAgAkHshMEAKAIARg0CIAJB6ITBACgC -AEYNAyACIANBeHEiAhBMIAEgACACaiIAQQFyNgIEIAAgAWogADYCACABQeiEwQAoAgBHDQFB4ITB -ACAANgIADwsgAiADQX5xNgIEIAEgAEEBcjYCBCAAIAFqIAA2AgALIABBgAJJDQIgASAAEFVBACEB -QYCFwQBBgIXBACgCAEEBayIANgIAIAANBEHIgsEAKAIAIgAEQANAIAFBAWohASAAKAIIIgANAAsL -QYCFwQBB/x8gASABQf8fTRs2AgAPC0HshMEAIAE2AgBB5ITBAEHkhMEAKAIAIABqIgA2AgAgASAA -QQFyNgIEQeiEwQAoAgAgAUYEQEHghMEAQQA2AgBB6ITBAEEANgIACyAAQfiEwQAoAgAiA00NA0Hs -hMEAKAIAIgJFDQNBACEAQeSEwQAoAgAiBEEpSQ0CQcCCwQAhAQNAIAIgASgCACIFTwRAIAIgBSAB -KAIEakkNBAsgASgCCCEBDAALAAtB6ITBACABNgIAQeCEwQBB4ITBACgCACAAaiIANgIAIAEgAEEB -cjYCBCAAIAFqIAA2AgAPCyAAQfgBcUHQgsEAaiECAn9B2ITBACgCACIDQQEgAEEDdnQiAHFFBEBB -2ITBACAAIANyNgIAIAIMAQsgAigCCAshACACIAE2AgggACABNgIMIAEgAjYCDCABIAA2AggPC0HI -gsEAKAIAIgEEQANAIABBAWohACABKAIIIgENAAsLQYCFwQBB/x8gACAAQf8fTRs2AgAgAyAETw0A -QfiEwQBBfzYCAAsL4QQBBn8CQAJAIAAoAggiB0GAgIDAAXFFDQACQAJAIAdBgICAgAFxRQRAIAJB -EEkNASABIAIQMCEDDAILAkACQCAALwEOIgNFBEBBACECDAELIAEgAmohCEEAIQIgAyEFIAEhBANA -IAQiBiAIRg0CAn8gBkEBaiAGLAAAIgRBAE4NABogBkECaiAEQWBJDQAaIAZBA2ogBEFwSQ0AGiAG -QQRqCyIEIAZrIAJqIQIgBUEBayIFDQALC0EAIQULIAMgBWshAwwBCyACRQRAQQAhAgwBCyACQQNx -IQYCQCACQQRJBEAMAQsgAkEMcSEIA0AgAyABIAVqIgQsAABBv39KaiAEQQFqLAAAQb9/SmogBEEC -aiwAAEG/f0pqIARBA2osAABBv39KaiEDIAggBUEEaiIFRw0ACwsgBkUNACABIAVqIQQDQCADIAQs -AABBv39KaiEDIARBAWohBCAGQQFrIgYNAAsLIAMgAC8BDCIETw0AIAQgA2shBkEAIQNBACEFAkAC -QAJAIAdBHXZBA3FBAWsOAgABAgsgBiEFDAELIAZB/v8DcUEBdiEFCyAHQf///wBxIQggACgCBCEH -IAAoAgAhAANAIANB//8DcSAFQf//A3FJBEBBASEEIANBAWohAyAAIAggBygCEBEAAEUNAQwDCwtB -ASEEIAAgASACIAcoAgwRAQANAUEAIQMgBiAFa0H//wNxIQEDQCADQf//A3EiAiABSSEEIAEgAk0N -AiADQQFqIQMgACAIIAcoAhARAABFDQALDAELIAAoAgAgASACIAAoAgQoAgwRAQAhBAsgBAueBAEE -fyMAQYABayIEJAACQAJAAkAgASgCCCICQYCAgBBxRQRAIAJBgICAIHENAUEBIQIgACgCACABEEtF -DQIMAwsgACgCACECA0AgAyAEakH/AGogAkEPcSIFQTByIAVB1wBqIAVBCkkbOgAAIANBAWshAyAC -QRBJIAJBBHYhAkUNAAtBASECIAFBAUGm6sAAQQIgAyAEakGAAWpBACADaxA2RQ0BDAILIAAoAgAh -AgNAIAMgBGpB/wBqIAJBD3EiBUEwciAFQTdqIAVBCkkbOgAAIANBAWshAyACQQ9LIAJBBHYhAg0A -C0EBIQIgAUEBQabqwABBAiADIARqQYABakEAIANrEDYNAQsgASgCAEGl58AAQQIgASgCBCgCDBEB -AA0AAkAgASgCCCICQYCAgBBxRQRAIAJBgICAIHENASAAKAIEIAEQSyECDAILIAAoAgQhAkEAIQMD -QCADIARqQf8AaiACQQ9xIgBBMHIgAEHXAGogAEEKSRs6AAAgA0EBayEDIAJBD0sgAkEEdiECDQAL -IAFBAUGm6sAAQQIgAyAEakGAAWpBACADaxA2IQIMAQsgACgCBCECQQAhAwNAIAMgBGpB/wBqIAJB -D3EiAEEwciAAQTdqIABBCkkbOgAAIANBAWshAyACQQ9LIAJBBHYhAg0ACyABQQFBpurAAEECIAMg -BGpBgAFqQQAgA2sQNiECCyAEQYABaiQAIAILvQQBCH8jAEEQayIDJAAgAyABNgIEIAMgADYCACAD -QqCAgIAONwIIAn8CQAJAAkAgAigCECIJBEAgAigCFCIADQEMAgsgAigCDCIARQ0BIAIoAggiASAA -QQN0aiEEIABBAWtB/////wFxQQFqIQYgAigCACEAA0ACQCAAQQRqKAIAIgVFDQAgAygCACAAKAIA -IAUgAygCBCgCDBEBAEUNAEEBDAULQQEgASgCACADIAFBBGooAgARAAANBBogAEEIaiEAIAQgAUEI -aiIBRw0ACwwCCyAAQRhsIQogAEEBa0H/////AXFBAWohBiACKAIIIQQgAigCACEAA0ACQCAAQQRq -KAIAIgFFDQAgAygCACAAKAIAIAEgAygCBCgCDBEBAEUNAEEBDAQLQQAhB0EAIQgCQAJAAkAgBSAJ -aiIBQQhqLwEAQQFrDgIBAgALIAFBCmovAQAhCAwBCyAEIAFBDGooAgBBA3RqLwEEIQgLAkACQAJA -IAEvAQBBAWsOAgECAAsgAUECai8BACEHDAELIAQgAUEEaigCAEEDdGovAQQhBwsgAyAHOwEOIAMg -CDsBDCADIAFBFGooAgA2AghBASAEIAFBEGooAgBBA3RqIgEoAgAgAyABQQRqKAIAEQAADQMaIABB -CGohACAFQRhqIgUgCkcNAAsMAQsLAkAgBiACKAIETw0AIAMoAgAgAigCACAGQQN0aiIAKAIAIAAo -AgQgAygCBCgCDBEBAEUNAEEBDAELQQALIANBEGokAAuvFQIWfwN+IwBBEGsiFSQAQeiAwQAoAgBF -BEBB6IDBACgCACEEQeiAwQBCATcCAEH0gMEAKAIAIQpB8IDBACgCACECQfCAwQBB+JXAACkCADcC -AEH8gMEAKAIAIQVB+IDBAEGAlsAAKQIANwIAAkAgBEUgCkVyDQAgBQRAIAJBCGohCCACKQMAQn+F -QoCBgoSIkKDAgH+DIRggAiEEA0AgGFAEQANAIARB4ABrIQQgCCkDACAIQQhqIQhCgIGChIiQoMCA -f4MiGEKAgYKEiJCgwIB/UQ0ACyAYQoCBgoSIkKDAgH+FIRgLIAQgGHqnQQN2QXRsakEEaygCACID -QYQBTwRAIAMQbAsgGEIBfSAYgyEYIAVBAWsiBQ0ACwsgCiAKQQxsQRNqQXhxIgNqQQlqIgRFDQAg -AiADayAEEMwBCwsCQAJAQeyAwQAoAgBFBEBB7IDBAEF/NgIAQfSAwQAoAgAiAyAAcSEFIABBGXYi -Fq1CgYKEiJCgwIABfiEZQfCAwQAoAgAhAgNAIAIgBWopAAAiGiAZhSIYQn+FIBhCgYKEiJCgwIAB -fYNCgIGChIiQoMCAf4MiGFBFBEADQCAAIAIgGHqnQQN2IAVqIANxQXRsaiIEQQxrKAIARgRAIARB -CGsoAgAgAUYNBgsgGEIBfSAYgyIYUEUNAAsLIBogGkIBhoNCgIGChIiQoMCAf4NQRQ0CIAUgB0EI -aiIHaiADcSEFDAALAAtB3JXAABCLAQALQfiAwQAoAgBFBEAgFUEIaiEXIwBBIGsiDyQAAkACQEH8 -gMEAKAIAIghBAWoiBCAITwRAAkBB9IDBACgCACILIAtBAWoiDUEDdiICQQdsIAtBCEkbIhJBAXYg -BEkEQCASQQFqIgIgBCACIARLGyICQQhJDQEgAkH/////AU0EQEF/IAJBA3RBB25BAWtndkEBaiEE -DAQLEI0BIA8oAhwhBCAPKAIYIQIMBAtBACEEQfCAwQAoAgAhCQJAIAIgDUEHcUEAR2oiA0UNACAD -QQFHBEAgA0H+////A3EhAgNAIAQgCWoiByAHKQMAIhhCf4VCB4hCgYKEiJCgwIABgyAYQv/+/fv3 -79+//wCEfDcDACAHQQhqIgcgBykDACIYQn+FQgeIQoGChIiQoMCAAYMgGEL//v379+/fv/8AhHw3 -AwAgBEEQaiEEIAJBAmsiAg0ACwsgA0EBcUUNACAEIAlqIgQgBCkDACIYQn+FQgeIQoGChIiQoMCA -AYMgGEL//v379+/fv/8AhHw3AwALAkACQCANQQhPBEAgCSANaiAJKQAANwAADAELIA0EQCAJQQhq -IAkgDfwKAAALIA1FDQELIAlBCGohECAJQQxrIRNBASECQQAhBANAIAQhByACIQQCQCAHIAlqIhQt -AABBgAFHDQAgEyAHQXRsaiEGAkADQCAGKAIAIgIgBigCBCACGyIKIAtxIgUhAiAFIAlqKQAAQoCB -goSIkKDAgH+DIhlQBEBBCCEDA0AgAiADaiECIANBCGohAyAJIAIgC3EiAmopAABCgIGChIiQoMCA -f4MiGVANAAsLIAkgGXqnQQN2IAJqIAtxIgJqLAAAQQBOBEAgCSkDAEKAgYKEiJCgwIB/g3qnQQN2 -IQILIAIgBWsgByAFa3MgC3FBCEkNASACIAlqIgMtAAAgAyAKQRl2IgM6AAAgECACQQhrIAtxaiAD -OgAAIBMgAkF0bGohA0H/AUcEQCAGLQAAIQIgBiADLQAAOgAAIAMgAjoAACAGLQABIQIgBiADLQAB -OgABIAMgAjoAASAGLQACIQIgBiADLQACOgACIAMgAjoAAiAGLQADIQIgBiADLQADOgADIAMgAjoA -AyAGLQAEIQIgBiADLQAEOgAEIAMgAjoABCAGLQAFIQIgBiADLQAFOgAFIAMgAjoABSAGLQAGIQIg -BiADLQAGOgAGIAMgAjoABiAGLQAHIQIgBiADLQAHOgAHIAMgAjoAByAGLQAIIQIgBiADLQAIOgAI -IAMgAjoACCAGLQAJIQIgBiADLQAJOgAJIAMgAjoACSAGLQAKIQIgBiADLQAKOgAKIAMgAjoACiAG -LQALIQIgBiADLQALOgALIAMgAjoACwwBCwsgFEH/AToAACAQIAdBCGsgC3FqQf8BOgAAIANBCGog -BkEIaigAADYAACADIAYpAAA3AAAMAQsgFCAKQRl2IgI6AAAgECAHQQhrIAtxaiACOgAACyAEIAQg -DUkiB2ohAiAHDQALC0H4gMEAIBIgCGs2AgBBgYCAgHghAgwDC0EEQQggAkEESRshBAwBCxCNASAP -KAIEIQQgDygCACECDAELAkACQCAErUIMfiIYQiCIpw0AIBinIgJBeEsNACACQQdqQXhxIgMgBEEI -aiIHaiIFIANJIAVB+P///wdLcg0AQeWAwQAtAAAaIAVBCBDAASICDQFBCCAFEOcBAAsQjQEgDygC -DCEEIA8oAgghAgwBCyACIANqIQwgBwRAIAxB/wEgB/wLAAsgBEEBayIRIARBA3ZBB2wgBEEJSRsh -EEHwgMEAKAIAIQMgCARAIAxBDGshEiAMQQhqIRMgA0EMayEJIAMpAwBCf4VCgIGChIiQoMCAf4Mh -GSADIQJBACEEIAghBwNAIBlQBEADQCAEQQhqIQQgAkEIaiICKQMAQoCBgoSIkKDAgH+DIhhCgIGC -hIiQoMCAf1ENAAsgGEKAgYKEiJCgwIB/hSEZCyAMIAkgGXqnQQN2IARqIhRBdGxqIgooAgAiBSAK -KAIEIAUbIgogEXEiDmopAABCgIGChIiQoMCAf4MiGFAEQEEIIQYDQCAGIA5qIQUgBkEIaiEGIAwg -BSARcSIOaikAAEKAgYKEiJCgwIB/gyIYUA0ACwsgGUIBfSAZgyEZIAwgGHqnQQN2IA5qIBFxIg5q -LAAAQQBOBEAgDCkDAEKAgYKEiJCgwIB/g3qnQQN2IQ4LIAwgDmogCkEZdiIFOgAAIBMgDkEIayAR -cWogBToAACASIA5BdGxqIgpBCGogCSAUQXRsaiIFQQhqKAAANgAAIAogBSkAADcAACAHQQFrIgcN -AAsLQfSAwQAgETYCAEHwgMEAIAw2AgBB+IDBACAQIAhrNgIAQYGAgIB4IQIgC0UNACALIA1BDGxB -B2pBeHEiBGpBCWoiB0UNACADIARrIAcQzAELIBcgAjYCACAXIAQ2AgQgD0EgaiQACyAAIAEQtQEh -B0HwgMEAKAIAIghB9IDBACgCACIEIABxIgVqKQAAQoCBgoSIkKDAgH+DIhhQBEBBCCEDA0AgAyAF -aiECIANBCGohAyAIIAIgBHEiBWopAABCgIGChIiQoMCAf4MiGFANAAsLIAggGHqnQQN2IAVqIARx -IgVqLAAAIgNBAE4EQCAIIAgpAwBCgIGChIiQoMCAf4N6p0EDdiIFai0AACEDCyAFIAhqIBY6AAAg -CCAFQQhrIARxakEIaiAWOgAAQfiAwQBB+IDBACgCACADQQFxazYCAEH8gMEAQfyAwQAoAgBBAWo2 -AgAgCCAFQXRsaiIEQQRrIAc2AgAgBEEIayABNgIAIARBDGsgADYCAAsgBEEEaygCACEBEG8iACAB -JQEmAUHsgMEAQeyAwQAoAgBBAWo2AgAgFUEQaiQAIAALlQQBDH8gAUEBayEOIAAoAgQhCiAAKAIA -IQsgACgCCCEMAkADQCAFDQECfwJAIAIgA0kNAANAIAEgA2ohBQJAAkACQCACIANrIgdBB00EQCAC -IANHDQEgAiEDDAULAkAgBUEDakF8cSIGIAVrIgQEQEEAIQADQCAAIAVqLQAAQQpGDQUgBCAAQQFq -IgBHDQALIAQgB0EIayIATQ0BDAMLIAdBCGshAAsDQEGAgoQIIAYoAgAiCUGKlKjQAHNrIAlyQYCC -hAggBkEEaigCACIJQYqUqNAAc2sgCXJxQYCBgoR4cUGAgYKEeEcNAiAGQQhqIQYgBEEIaiIEIABN -DQALDAELQQAhAANAIAAgBWotAABBCkYNAiAHIABBAWoiAEcNAAsgAiEDDAMLIAQgB0YEQCACIQMM -AwsDQCAEIAVqLQAAQQpGBEAgBCEADAILIAcgBEEBaiIERw0ACyACIQMMAgsgACADaiIGQQFqIQMC -QCACIAZNDQAgACAFai0AAEEKRw0AQQAhBSADIQYgAwwDCyACIANPDQALCyACIAhGDQJBASEFIAgh -BiACCyEAAkAgDC0AAARAIAtBnOrAAEEEIAooAgwRAQANAQtBACEEIAAgCEcEQCAAIA5qLQAAQQpG -IQQLIAAgCGshACABIAhqIQcgDCAEOgAAIAYhCCALIAcgACAKKAIMEQEARQ0BCwtBASENCyANC8oE -Agd/AX4jAEEQayIGJAACQCAALwEMIgVFBEAgACgCACAAKAIEIAEQQCECDAELIAYgASgCDCIENgIM -IAYgASgCCCICNgIIIAYgASgCBCIDNgIEIAYgASgCACIBNgIAAkAgACkCCCIJpyIHQYCAgAhxBEAg -ACgCACABIAMgACgCBCgCDBEBAA0BIAAgB0GAgID/eXFBsICAgAJyIgc2AgggBkIBNwIAIAUgA0H/ -/wNxayIBQQAgASAFTRshBUEAIQMLIAQEQCAEQQxsIQgDQAJ/AkACQAJAIAIvAQBBAWsOAgIBAAsg -AkEEaigCAAwCCyACQQhqKAIADAELIAJBAmovAQAiBEHoB08EQEEEQQUgBEGQzgBJGwwBC0EBIARB -CkkNABpBAkEDIARB5ABJGwsgAkEMaiECIANqIQMgCEEMayIIDQALCwJAAkAgBUH//wNxIANLBEAg -BSADayEDQQAhAkEAIQECQAJAAkAgB0EddkEDcUEBaw4DAAEAAgsgAyEBDAELIANB/v8DcUEBdiEB -CyAHQf///wBxIQggACgCBCEHIAAoAgAhBANAIAJB//8DcSABQf//A3FPDQIgAkEBaiECIAQgCCAH -KAIQEQAARQ0ACwwDCyAAKAIAIAAoAgQgBhBAIQIMAQsgBCAHIAYQQA0BQQAhBSADIAFrQf//A3Eh -AQNAIAVB//8DcSIDIAFJIQIgASADTQ0BIAVBAWohBSAEIAggBygCEBEAAEUNAAsLIAAgCTcCCAwB -C0EBIQILIAZBEGokACACC/4DAQl/IwBBEGsiBCQAAn8CQCACKAIEIgNFDQAgACACKAIAIAMgASgC -DBEBAEUNAEEBDAELIAIoAgwiBgRAIAIoAggiAyAGQQxsaiEIIARBDGohCQNAAkACQAJAAkAgAy8B -AEEBaw4CAgEACwJAIAMoAgQiAkHBAE8EQCABQQxqKAIAIQYDQEEBIABB8OvAAEHAACAGEQEADQga -IAJBQGoiAkHAAEsNAAsMAQsgAkUNAwsgAEHw68AAIAIgAUEMaigCABEBAEUNAkEBDAULIAAgAygC -BCADKAIIIAFBDGooAgARAQBFDQFBAQwECyADLwECIQIgCUEAOgAAIARBADYCCAJ/QQRBBSACQZDO -AEkbIAJB6AdPDQAaQQEgAkEKSQ0AGkECQQMgAkHkAEkbCyIGIARBCGoiCmoiB0EBayIFIAIgAkEK -biILQQpsa0EwcjoAAAJAIAUgCkYNACAHQQJrIgUgC0EKcEEwcjoAACAEQQhqIAVGDQAgB0EDayIF -IAJB5ABuQQpwQTByOgAAIARBCGogBUYNACAHQQRrIgUgAkHoB25BCnBBMHI6AAAgBEEIaiAFRg0A -IAdBBWsgAkGQzgBuQTByOgAACyAAIARBCGogBiABQQxqKAIAEQEARQ0AQQEMAwsgA0EMaiIDIAhH -DQALC0EACyAEQRBqJAALzAQBCn8jAEEwayIGJAACQAJAAkACf0EAIAFBQHEiCkUNABogBkEIaiAA -NgIAQQEgCkHAAEYNABogBiAAQUBrNgIMIApBgAFHDQFBAgshByABQT9xIQEgBUEFdiIJIAcgByAJ -SxsiCARAIAZBCGohCSADQQRyIQsgCEEFdCEMQQAhAwNAIAkoAgAhCCAGQShqIg0gAkEYaikCADcD -ACAGQSBqIg4gAkEQaikCADcDACAGQRhqIg8gAkEIaikCADcDACAGIAIpAgA3AxAgBkEQaiAIQcAA -QgAgCxAoIAMgBGoiCEEYaiANKQMANwAAIAhBEGogDikDADcAACAIQQhqIA8pAwA3AAAgCCAGKQMQ -NwAAIAlBBGohCSAMIANBIGoiA0cNAAsLAkAgAQRAIAUgB0EFdCICSQ0BIAUgAmsiA0EfTQ0DIAFB -IEcNBCACIARqIgEgACAKaiIAKQAANwAAIAFBGGogAEEYaikAADcAACABQRBqIABBEGopAAA3AAAg -AUEIaiAAQQhqKQAANwAAIAdBAWohBwsgBkEwaiQAIAcPCyACIAVB5LrAABDQAQALIAYgAEGAAWo2 -AhBBnLzAAEErIAZBEGpByLzAAEH0usAAEHwAC0EgIANBxLrAABDRAQALIwBBMGsiACQAIABBIDYC -BCAAIAE2AgAgAEEDNgIMIABBkP/AADYCCCAAQgI3AhQgACAAQQRqrUKAgICAgAmENwMoIAAgAK1C -gICAgIAJhDcDICAAIABBIGo2AhAgAEEIakHUusAAEJ8BAAuEBAIHfwF8IwBB0ABrIgMkAAJAAkAC -QAJAAkAgACgCACIEJQFBgQElARAHRQRAIAQlARAIDgICAQMLIANBBzoAMCADQTBqIAEgAhB+IQAM -BAtBASEGC0EBIQdBACEADAELIANBEGogBCUBEAkgAygCEARAIAMrAxghCkEDIQBBASEHDAELIANB -CGogBBDqAQJ/IAMoAggiBARAIAMoAgwiBSEGQQUMAQsCQAJAIAAoAgAlARAjBEAgA0EwaiAAEHUg -AygCOCEGIAMoAjQhBCADKAIwIQgMAQsgACgCACUBEB1FDQEgAyAAKAIAELcBIgU2AkggA0EwaiAD -QcgAahB1IAMoAjghBiADKAI0IQQgAygCMCEIIAVBhAFJDQAgBRBsCyAIQYCAgIB4Rg0AQQEhB0EG -DAELIANBATYCNCADQeiUwAA2AjAgA0IBNwI8IAMgAK1CgICAgOAChDcDSCADIANByABqNgI4IANB -JGogA0EwahBHQYCAgIB4IQggAygCLCEGIAMoAighBCADKAIkIQVBEQshACAGrb8hCiAHIQkLIAMg -CjkDOCADIAQ2AjQgAyAGOgAxIAMgADoAMCADQTBqIAEgAhB+IQACQCAJRQRAIAcgBUVyRQ0BDAIL -IAgEQCAEIAgQzAELIAVFIAdyDQELIAQgBRDMAQsgA0HQAGokACAAC+QDAQV/IwBBEGsiCCQAAkAC -QAJAAkACQCABKAIIQQFGBEAgASgCACEFIAEoAgQhBCABQQwQzAFBHUGBASAEQQp2Z0ECdGsgBEH/ -/wdLGyEGIAIgBWsiByADaiEDIAIgBUYEQCAGIQEMBgsgBkEFdiICIAdqIgFBgICAwABPBEBB5YDB -AC0AABpBFEEEEMABIgFFDQIgAUEBNgIQIAEgAiADajYCCCABIAUgAms2AgQgASACIARqNgIAIAEg -BkECdkEHcTYCDAwFCyAGQR1xIAFBBXRyIQEMBAsgA0EASA0BAkAgA0UEQEEBIQUMAQtB5YDBAC0A -ABpBASEEIANBARDAASIFRQ0CCyADBEAgBSACIAP8CgAACyABIAEoAggiAkEBazYCCCACQQFGBEAg -ASgCACABQQRqKAIAIgRBARCzAUUNAyAEEMwBIAFBDBDMAQtBHUGBASADQQp2Z0ECdGsgA0H//wdL -GyEBIAMhBAwEC0EEQRQQ5wEACyAEIANB5LPAABCyAQALQaC1wABBKyAIQQ9qQZC1wABB3LXAABB8 -AAsgAyAHayICQQAgAiADTRshAyAEIAdrIQQgBSAHaiEFCyAAIAE2AgwgACAENgIIIAAgAzYCBCAA -IAU2AgAgCEEQaiQAC/kDAQJ/IAAgAWohAgJAAkAgACgCBCIDQQFxDQAgA0ECcUUNASAAKAIAIgMg -AWohASAAIANrIgBB6ITBACgCAEYEQCACKAIEQQNxQQNHDQFB4ITBACABNgIAIAIgAigCBEF+cTYC -BCAAIAFBAXI2AgQgAiABNgIADAILIAAgAxBMCwJAAkACQCACKAIEIgNBAnFFBEAgAkHshMEAKAIA -Rg0CIAJB6ITBACgCAEYNAyACIANBeHEiAhBMIAAgASACaiIBQQFyNgIEIAAgAWogATYCACAAQeiE -wQAoAgBHDQFB4ITBACABNgIADwsgAiADQX5xNgIEIAAgAUEBcjYCBCAAIAFqIAE2AgALIAFBgAJP -BEAgACABEFUPCyABQfgBcUHQgsEAaiECAn9B2ITBACgCACIDQQEgAUEDdnQiAXFFBEBB2ITBACAB -IANyNgIAIAIMAQsgAigCCAshASACIAA2AgggASAANgIMIAAgAjYCDCAAIAE2AggPC0HshMEAIAA2 -AgBB5ITBAEHkhMEAKAIAIAFqIgE2AgAgACABQQFyNgIEIABB6ITBACgCAEcNAUHghMEAQQA2AgBB -6ITBAEEANgIADwtB6ITBACAANgIAQeCEwQBB4ITBACgCACABaiIBNgIAIAAgAUEBcjYCBCAAIAFq -IAE2AgALC44DAQR/AkACQAJAAkACQCAHIAhWBEAgByAIfSAIWA0BAkAgBiAHIAZ9VCAHIAZCAYZ9 -IAhCAYZacUUEQCAGIAhWDQEMBwsgAiADSQ0DDAULIAcgBiAIfSIGfSAGVg0FIAIgA0kNAyABIANq -IQwgASEKAkACQANAIAMgCUYNASAJQQFqIQkgCkEBayIKIANqIgstAABBOUYNAAsgCyALLQAAQQFq -OgAAIAMgCWtBAWogA08NASAJQQFrIgVFDQEgC0EBakEwIAX8CwAMAQsCQCADRQRAQTEhCQwBCyAB -QTE6AAAgA0EBRgRAQTAhCQwBC0EwIQkgA0EBayIKRQ0AIAFBAWpBMCAK/AsACyAEQQFqwSIEIAXB -TCACIANNcg0AIAwgCToAACADQQFqIQMLIAIgA08NBCADIAJBqOXAABDRAQALIABBADYCAA8LIABB -ADYCAA8LIAMgAkG45cAAENEBAAsgAyACQZjlwAAQ0QEACyAAIAQ7AQggACADNgIEIAAgATYCAA8L -IABBADYCAAunAwECfwJAAkACQAJAIAAtAGgiAwRAIANBwQBPDQMgAkHAACADayIEIAIgBEkbIgQE -QCAAIANqIAEgBPwKAAALIAAgAC0AaCAEaiIDOgBoIAEgBGohASACIARrIgJFBEBBACECDAILIABB -QGsgAEHAACAAKQNgIAAtAGogAC0AaUVyECggAEIANwMAIABBADoAaCAAQQhqQgA3AwAgAEEQakIA -NwMAIABBGGpCADcDACAAQSBqQgA3AwAgAEEoakIANwMAIABBMGpCADcDACAAQThqQgA3AwAgACAA -LQBpQQFqOgBpC0EAIQMgAkHBAEkNASAAQUBrIQQgAC0AaSEDA0AgBCABQcAAIAApA2AgAC0AaiAD -Qf8BcUVyECggACAALQBpQQFqIgM6AGkgAUFAayEBIAJBQGoiAkHAAEsNAAsgAC0AaCEDCyADQf8B -cSIDQcEATw0CCyACQcAAIANrIgQgAiAESRsiAgRAIAAgA2ogASAC/AoAAAsgACAALQBoIAJqOgBo -IAAPCyADQcAAQaS6wAAQ0AEACyADQcAAQaS6wAAQ0AEAC48DAQd/IwBBEGsiBCQAAkACQAJAAkAg -ASgCBCICBEAgASgCACEHIAJBA3EhBQJAIAJBBEkEQEEAIQIMAQsgB0EcaiEDIAJBfHEhCEEAIQID -QCADKAIAIANBCGsoAgAgA0EQaygCACADQRhrKAIAIAJqampqIQIgA0EgaiEDIAggBkEEaiIGRw0A -CwsgBQRAIAZBA3QgB2pBBGohAwNAIAMoAgAgAmohAiADQQhqIQMgBUEBayIFDQALCyABKAIMRQ0C -IAJBD0sNASAHKAIEDQEMAwtBACECIAEoAgxFDQILIAJBACACQQBKG0EBdCECC0EAIQUgAkEATgRA -IAJFDQFB5YDBAC0AABpBASEFIAJBARDAASIDDQILIAUgAkGwycAAELIBAAtBASEDQQAhAgsgBEEA -NgIIIAQgAzYCBCAEIAI2AgAgBEGwyMAAIAEQPEUEQCAAIAQpAgA3AgAgAEEIaiAEQQhqKAIANgIA -IARBEGokAA8LQdDJwABB1gAgBEEPakHAycAAQcDKwAAQfAAL5wIBBX8CQCABQc3/e0EQIAAgAEEQ -TRsiAGtPDQAgAEEQIAFBC2pBeHEgAUELSRsiBGpBDGoQKSICRQ0AIAJBCGshAQJAIABBAWsiAyAC -cUUEQCABIQAMAQsgAkEEayIFKAIAIgZBeHEgAiADakEAIABrcUEIayICIABBACACIAFrQRBNG2oi -ACABayICayEDIAZBA3EEQCAAIAMgACgCBEEBcXJBAnI2AgQgACADaiIDIAMoAgRBAXI2AgQgBSAC -IAUoAgBBAXFyQQJyNgIAIAEgAmoiAyADKAIEQQFyNgIEIAEgAhBEDAELIAEoAgAhASAAIAM2AgQg -ACABIAJqNgIACwJAIAAoAgQiAUEDcUUNACABQXhxIgIgBEEQak0NACAAIAQgAUEBcXJBAnI2AgQg -ACAEaiIBIAIgBGsiBEEDcjYCBCAAIAJqIgIgAigCBEEBcjYCBCABIAQQRAsgAEEIaiEDCyADC+oC -AgZ/An4jAEEgayIFJABBFCEDIAAiCULoB1oEQCAJIQoDQCAFQQxqIANqIgRBA2sgCiAKQpDOAIAi -CUKQzgB+faciBkH//wNxQeQAbiIHQQF0IghBqerAAGotAAA6AAAgBEEEayAIQajqwABqLQAAOgAA -IARBAWsgBiAHQeQAbGtB//8DcUEBdCIGQanqwABqLQAAOgAAIARBAmsgBkGo6sAAai0AADoAACAD -QQRrIQMgCkL/rOIEViAJIQoNAAsLIAlCCVYEQCADIAVqQQtqIAmnIgQgBEH//wNxQeQAbiIEQeQA -bGtB//8DcUEBdCIGQanqwABqLQAAOgAAIANBAmsiAyAFQQxqaiAGQajqwABqLQAAOgAAIAStIQkL -IABQRSAJUHFFBEAgA0EBayIDIAVBDGpqIAmnQQF0QR5xQanqwABqLQAAOgAACyACIAFBAUEAIAVB -DGogA2pBFCADaxA2IAVBIGokAAvQAgEEfyMAQfAAayIDJAACQCAAAn4CQCABKAIEIgQgASgCDEcE -QCABIARBEGo2AgQgBCgCDCEFIAQoAgAhASACKAIEIANByABqIAQoAgQiBiAEKAIIEDcgAygCSCIE -RQRAIANBQGsgA0HoAGopAwA3AwAgA0E4aiADQeAAaikDADcDACADQTBqIANB2ABqKQMANwMAIAMg -AykDUDcDKAsgAQRAIAYgARDMAQsgBEEBcUUNAUEBOgAAQgAMAgsgAEICNwMADAILIANBIGogA0FA -aykDADcDACADQRhqIANBOGopAwA3AwAgA0EQaiADQTBqKQMANwMAIAMgAykDKDcDCEIBCzcDACAA -IAMpAwg3AwggACAFNgIoIABBEGogA0EQaikDADcDACAAQRhqIANBGGopAwA3AwAgAEEgaiADQSBq -KQMANwMACyADQfAAaiQAC+YCAQh/IwBBEGsiBSQAQQohAiAAIgNB6AdPBEAgAyEEA0AgBUEGaiAC -aiIGQQNrIAQgBEGQzgBuIgNBkM4AbGsiB0H//wNxQeQAbiIIQQF0IglBqerAAGotAAA6AAAgBkEE -ayAJQajqwABqLQAAOgAAIAZBAWsgByAIQeQAbGtB//8DcUEBdCIHQanqwABqLQAAOgAAIAZBAmsg -B0Go6sAAai0AADoAACACQQRrIQIgBEH/rOIESyADIQQNAAsLAkAgA0EJTQRAIAMhBAwBCyACIAVq -QQVqIAMgA0H//wNxQeQAbiIEQeQAbGtB//8DcUEBdCIDQanqwABqLQAAOgAAIAJBAmsiAiAFQQZq -aiADQajqwABqLQAAOgAAC0EAIAAgBBtFBEAgAkEBayICIAVBBmpqIARBAXRBHnFBqerAAGotAAA6 -AAALIAFBAUEBQQAgBUEGaiACakEKIAJrEDYgBUEQaiQAC4IDAQR/IAAoAgwhAgJAAkACQCABQYAC -TwRAIAAoAhghAwJAAkAgACACRgRAIABBFEEQIAAoAhQiAhtqKAIAIgENAUEAIQIMAgsgACgCCCIB -IAI2AgwgAiABNgIIDAELIABBFGogAEEQaiACGyEEA0AgBCEFIAEiAkEUaiACQRBqIAIoAhQiARsh -BCACQRRBECABG2ooAgAiAQ0ACyAFQQA2AgALIANFDQICQCAAKAIcQQJ0QcCBwQBqIgEoAgAgAEcE -QCADKAIQIABGDQEgAyACNgIUIAINAwwECyABIAI2AgAgAkUNBAwCCyADIAI2AhAgAg0BDAILIAAo -AggiACACRwRAIAAgAjYCDCACIAA2AggPC0HYhMEAQdiEwQAoAgBBfiABQQN2d3E2AgAPCyACIAM2 -AhggACgCECIBBEAgAiABNgIQIAEgAjYCGAsgACgCFCIARQ0AIAIgADYCFCAAIAI2AhgPCw8LQdyE -wQBB3ITBACgCAEF+IAAoAhx3cTYCAAvgAgEEfyMAQRBrIgIkAAJAIAFBgAFPBEAgAkEMaiIEQQJy -IQMgAkEANgIMAkAgAUGAEE8EQCAEQQNyIQUgAUGAgARPBEAgAkEQaiEDIAIgAUESdkHwAXI6AAwg -AiABQQZ2QT9xQYABcjoADiACIAFBDHZBP3FBgAFyOgANIAUhBAwCCyACIAFBDHZB4AFyOgAMIAIg -AUEGdkE/cUGAAXI6AA0gAyEEIAUhAwwBCyACQQxqQQFyIQQgAiABQQZ2QcABcjoADAsgBCABQT9x -QYABcjoAACADIAJBDGprIgEgACgCACAAKAIIIgNrSwRAIAAgAyABQQFBARBXIAAoAgghAwsgAQRA -IAAoAgQgA2ogAkEMaiAB/AoAAAsgACABIANqNgIIDAELIAAoAggiAyAAKAIARgRAIABBoITAABBx -CyAAKAIEIANqIAE6AAAgACADQQFqNgIICyACQRBqJABBAAvgAgEEfyMAQRBrIgIkAAJAIAFBgAFP -BEAgAkEMaiIEQQJyIQMgAkEANgIMAkAgAUGAEE8EQCAEQQNyIQUgAUGAgARPBEAgAkEQaiEDIAIg -AUESdkHwAXI6AAwgAiABQQZ2QT9xQYABcjoADiACIAFBDHZBP3FBgAFyOgANIAUhBAwCCyACIAFB -DHZB4AFyOgAMIAIgAUEGdkE/cUGAAXI6AA0gAyEEIAUhAwwBCyACQQxqQQFyIQQgAiABQQZ2QcAB -cjoADAsgBCABQT9xQYABcjoAACADIAJBDGprIgEgACgCACAAKAIIIgNrSwRAIAAgAyABQQFBARBX -IAAoAgghAwsgAQRAIAAoAgQgA2ogAkEMaiAB/AoAAAsgACABIANqNgIIDAELIAAoAggiAyAAKAIA -RgRAIABBhJDAABBxCyAAKAIEIANqIAE6AAAgACADQQFqNgIICyACQRBqJABBAAuzAgEBfyMAQfAA -ayIGJAAgBiABNgIMIAYgADYCCCAGIAM2AhQgBiACNgIQIAZBvIDBACgCADYCHCAGQbCAwQAoAgA2 -AhgCQCAEKAIABEAgBkEwaiAEQRBqKQIANwMAIAZBKGogBEEIaikCADcDACAGIAQpAgA3AyAgBkEE -NgJcIAZB0OnAADYCWCAGQgQ3AmQgBiAGQRBqrUKAgICA8AuENwNQIAYgBkEIaq1CgICAgPALhDcD -SCAGIAZBIGqtQoCAgICQDIQ3A0AMAQsgBkEDNgJcIAZBnOnAADYCWCAGQgM3AmQgBiAGQRBqrUKA -gICA8AuENwNIIAYgBkEIaq1CgICAgPALhDcDQAsgBiAGQRhqrUKAgICAgAyENwM4IAYgBkE4ajYC -YCAGQdgAaiAFEJ8BAAvyAgEBfwJAIAIEQCABLQAAQTBNDQEgBUECOwEAAkACQAJAAkACQCADwSIG -QQBKBEAgBSABNgIEIAIgA0H//wNxIgNLDQEgBUEAOwEMIAUgAjYCCCAFIAMgAms2AhAgBA0CQQIh -AQwFCyAFIAI2AiAgBSABNgIcIAVBAjsBGCAFQQA7AQwgBUECNgIIIAVB4ebAADYCBCAFQQAgBmsi -AzYCEEEDIQEgAiAETw0EIAQgAmsiAiADTQ0EIAIgBmohBAwDCyAFQQI7ARggBUEBNgIUIAVB4ObA -ADYCECAFQQI7AQwgBSADNgIIIAUgAiADayICNgIgIAUgASADajYCHCACIARJDQFBAyEBDAMLIAVB -ATYCICAFQeDmwAA2AhwgBUECOwEYDAELIAQgAmshBAsgBSAENgIoIAVBADsBJEEEIQELIAAgATYC -BCAAIAU2AgAPC0HI48AAQSFB7OXAABCUAQALQfzlwABBH0Gc5sAAEJQBAAvKAgEGfyABIAJBAXRq -IQkgAEGA/gNxQQh2IQogAEH/AXEhDAJAAkACQAJAA0AgAUECaiELIAcgAS0AASICaiEIIAogAS0A -ACIBRwRAIAEgCksNBCAIIQcgCyIBIAlHDQEMBAsgByAISw0BIAQgCEkNAiADIAdqIQEDQCACRQRA -IAghByALIgEgCUcNAgwFCyACQQFrIQIgAS0AACABQQFqIQEgDEcNAAsLQQAhAgwDCyAHIAhBuO/A -ABDSAQALIAggBEG478AAENEBAAsgAEH//wNxIQcgBSAGaiEDQQEhAgNAIAVBAWohAAJAIAUsAAAi -AUEATgRAIAAhBQwBCyAAIANHBEAgBS0AASABQf8AcUEIdHIhASAFQQJqIQUMAQtBqO/AABDUAQAL -IAcgAWsiB0EASA0BIAJBAXMhAiADIAVHDQALCyACQQFxC8oCAQN/IwBBEGsiAiQAAkAgAUGAAU8E -QCACQQA2AgwCfyABQYAQTwRAIAFBgIAETwRAIAJBDGpBA3IhBCACIAFBEnZB8AFyOgAMIAIgAUEG -dkE/cUGAAXI6AA4gAiABQQx2QT9xQYABcjoADUEEDAILIAJBDGpBAnIhBCACIAFBDHZB4AFyOgAM -IAIgAUEGdkE/cUGAAXI6AA1BAwwBCyACQQxqQQFyIQQgAiABQQZ2QcABcjoADEECCyEDIAQgAUE/ -cUGAAXI6AAAgACgCACAAKAIIIgFrIANJBEAgACABIAMQZyAAKAIIIQELIAMEQCAAKAIEIAFqIAJB -DGogA/wKAAALIAAgASADajYCCAwBCyAAKAIIIgMgACgCAEYEQCAAQdDKwAAQcQsgACADQQFqNgII -IAAoAgQgA2ogAToAAAsgAkEQaiQAQQALxgIBAn8jAEEQayICJAACQCABQYABTwRAIAJBADYCDAJ/ -IAFBgBBPBEAgAUGAgARPBEAgAiABQT9xQYABcjoADyACIAFBEnZB8AFyOgAMIAIgAUEGdkE/cUGA -AXI6AA4gAiABQQx2QT9xQYABcjoADUEEDAILIAIgAUE/cUGAAXI6AA4gAiABQQx2QeABcjoADCAC -IAFBBnZBP3FBgAFyOgANQQMMAQsgAiABQT9xQYABcjoADSACIAFBBnZBwAFyOgAMQQILIgEgACgC -ACAAKAIIIgNrSwRAIAAgAyABEF8gACgCCCEDCyABBEAgACgCBCADaiACQQxqIAH8CgAACyAAIAEg -A2o2AggMAQsgACgCCCIDIAAoAgBGBEAgAEHkw8AAEHELIAAoAgQgA2ogAToAACAAIANBAWo2AggL -IAJBEGokAEEAC68IAQh/IwBB8ABrIgIkACACQQhqIQQjAEEgayIDJAAgAyAAaSIBNgIcAkACQAJA -AkACQAJAIAFBAUYEQCAAQcAATQ0BIANBiIHBADYCGEGMgcEALQAAQQNHBH8gAyADQRhqNgIcIAMg -A0EcajYCACMAQSBrIgEkAAJAAkACQAJAAkACQEGMgcEALQAAQQFrDgMCBAEAC0GMgcEAQQI6AAAg -AygCACIGKAIAIQUgBkEANgIAIAVFDQIgBSgCAEEINgIAQYyBwQBBAzoAAAsgAUEgaiQADAMLIAFB -ADYCGCABQQE2AgwgAUGcm8AANgIIDAkLQeCcwAAQ1AEACyABQQA2AhggAUEBNgIMIAFB3JvAADYC -CAwHCyADKAIYBUGIgcEACygCACIBRQ0CIANBgIHBADYCGCAAIAFuIgZBhIHBAC0AAEEDRwR/IAMg -A0EYajYCHCADIANBHGo2AgAjAEEgayIBJAACQAJAAkACQAJAAkBBhIHBAC0AAEEBaw4DAgQBAAtB -hIHBAEECOgAAIAMoAgAiCCgCACEFIAhBADYCACAFRQ0CIAUoAgBBAjYCAEGEgcEAQQM6AAALIAFB -IGokAAwDCyABQQA2AhggAUEBNgIMIAFBnJvAADYCCAwJC0HgnMAAENQBAAsgAUEANgIYIAFBATYC -DCABQdybwAA2AggMBwsgAygCGAVBgIHBAAsoAgAgAGwiAU8NAyABQQBIDQRB5YDBAC0AABpBASEH -IAFBARDAASIFRQ0EIAQgATYCHCAEIAY2AhggBEHwnMAANgIIIARCADcDACAEQQA2AiggBCAFNgIk -IAQgATYCICAEIABBAWsiAK0gAGdBIHOthjcDECADQSBqJAAMBgsgA0EANgIAIwBBEGsiACQAIABB -iJbAADYCDCAAIANBHGo2AgggAEEIakG0sMAAIABBDGpBtLDAACADQfCWwAAQTwALQYCXwABBKEGo -l8AAEJQBAAtBuJfAABCaAQALQciXwABBL0H4l8AAEJQBAAsgByABQYiYwAAQsgEACyABQgQ3AhAg -AUEIakHUmcAAEJ8BAAsgAkHoAGogAkEwaikDADcCACACQeAAaiACQShqKQMANwIAIAJB2ABqIAJB -IGopAwA3AgAgAkHQAGogAkEYaikDADcCACACQcgAaiACQRBqKQMANwIAQeWAwQAtAAAaIAIgAikD -CDcCQEHAAEEIEMABIgBFBEBBCEHAABDnAQALIABBADYCCCAAQoGAgIAQNwMAIAAgAikCPDcCDCAA -QRRqIAJBxABqKQIANwIAIABBHGogAkHMAGopAgA3AgAgAEEkaiACQdQAaikCADcCACAAQSxqIAJB -3ABqKQIANwIAIABBNGogAkHkAGopAgA3AgAgAEE8aiACQewAaigCADYCACACQfAAaiQAIABBCGoL -xAIBBH8gAEIANwIQIAACf0EAIAFBgAJJDQAaQR8gAUH///8HSw0AGiABQQYgAUEIdmciA2t2QQFx -IANBAXRrQT5qCyICNgIcIAJBAnRBwIHBAGohBEEBIAJ0IgNB3ITBACgCAHFFBEAgBCAANgIAIAAg -BDYCGCAAIAA2AgwgACAANgIIQdyEwQBB3ITBACgCACADcjYCAA8LAkACQCABIAQoAgAiAygCBEF4 -cUYEQCADIQIMAQsgAUEZIAJBAXZrQQAgAkEfRxt0IQUDQCADIAVBHXZBBHFqIgQoAhAiAkUNAiAF -QQF0IQUgAiEDIAIoAgRBeHEgAUcNAAsLIAIoAggiASAANgIMIAIgADYCCCAAQQA2AhggACACNgIM -IAAgATYCCA8LIARBEGogADYCACAAIAM2AhggACAANgIMIAAgADYCCAv3AgEEfyMAQTBrIgAkAAJA -AkBByIDBACgCAEUEQEHggMEAKAIAIQFB4IDBAEEANgIAIAFFDQEgAEEYaiABEQcAIABBEGoiAiAA -QSRqKQIANwMAIAAgACkCHDcDCCAAKAIYIQFByIDBACgCACIDDQICQCADRQ0AQcyAwQAoAgAiAkUN -AEHQgMEAKAIAIAJBAnQQzAELQcyAwQAgATYCAEHIgMEAQQE2AgBB0IDBACAAKQMINwIAQdiAwQAg -AEEQaikDADcCAAsgAEEwaiQAQcyAwQAPCyAAQQA2AiggAEEBNgIcIABBqL/AADYCGCAAQgQ3AiAg -AEEYakGUwMAAEJ8BAAsgAEEoaiACKQMANwIAIAAgACkDCDcCICAAIAE2AhwgAEEBNgIYAkAgAEEY -aiIBKAIARQ0AIAEoAgQiAkUNACABKAIIIAJBAnQQzAELIABBADYCKCAAQQE2AhwgAEG0wMAANgIY -IABCBDcCICABQbzAwAAQnwEAC/wBAgR/AX4jAEEgayIFJAACQAJAIARFDQAgASABIAJqIgJLDQAg -AyAEakEBa0EAIANrca0gAiAAKAIAIgFBAXQiBiACIAZLGyICQQhBBEEBIARBgQhJGyAEQQFGGyIG -IAIgBksbIgatfiIJQiCIUEUNACAJpyIIQYCAgIB4IANrSw0AQQAhAiAFIAEEfyAFIAEgBGw2Ahwg -BSAAKAIENgIUIAMFIAILNgIYIAVBCGogAyAIIAVBFGoQcyAFKAIIQQFHDQEgBSgCECECIAUoAgwh -BwsgByACQYSMwAAQsgEACyAFKAIMIQEgACAGNgIAIAAgATYCBCAFQSBqJAALygECBH8BfiMAQSBr -IgMkAAJAAkAgASABIAJqIgJLDQBBCCACIAAoAgAiAUEBdCIEIAIgBEsbIgIgAkEITRsiBK0iB0Ig -iFBFDQAgB6ciBUH/////B0sNACADIAEEfyADIAE2AhwgAyAAKAIENgIUQQEFQQALNgIYIANBCGpB -ASAFIANBFGoQcyADKAIIQQFHDQEgAygCECECIAMoAgwhBgsgBiACQeCawAAQsgEACyADKAIMIQEg -ACAENgIAIAAgATYCBCADQSBqJAALiQIBAX8jAEEQayICJAAgACgCACEAAn8gAS0AC0EYcUUEQCAB -KAIAIAAgASgCBCgCEBEAAAwBCyACQQA2AgwgASACQQxqAn8gAEGAAU8EQCAAQYAQTwRAIABBgIAE -TwRAIAIgAEE/cUGAAXI6AA8gAiAAQRJ2QfABcjoADCACIABBBnZBP3FBgAFyOgAOIAIgAEEMdkE/ -cUGAAXI6AA1BBAwDCyACIABBP3FBgAFyOgAOIAIgAEEMdkHgAXI6AAwgAiAAQQZ2QT9xQYABcjoA -DUEDDAILIAIgAEE/cUGAAXI6AA0gAiAAQQZ2QcABcjoADEECDAELIAIgADoADEEBCxA6CyACQRBq -JAALqgICA38BfiMAQUBqIgIkACABKAIAQYCAgIB4RgRAIAEoAgwhAyACQSRqIgRBADYCACACQoCA -gIAQNwIcIAJBMGogAygCACIDQQhqKQIANwMAIAJBOGogA0EQaikCADcDACACIAMpAgA3AyggAkEc -akHUxMAAIAJBKGoQPBogAkEYaiAEKAIAIgM2AgAgAiACKQIcIgU3AxAgAUEIaiADNgIAIAEgBTcC -AAsgASkCACEFIAFCgICAgBA3AgAgAkEIaiIDIAFBCGoiASgCADYCACABQQA2AgBB5YDBAC0AABog -AiAFNwMAQQxBBBDAASIBRQRAQQRBDBDnAQALIAEgAikDADcCACABQQhqIAMoAgA2AgAgAEHwxsAA -NgIEIAAgATYCACACQUBrJAALmgIBA38jAEEQayIGJAAgASABKAIIIgVBACAFQQFHGzYCCAJAAkAC -QCAFQQFGBEAgASgCBCEEIAEoAgAhBSABQQwQzAEgA0UNASAFIAIgA/wKAAAMAQsgA0EASA0BAkAg -A0UEQEEBIQUMAQtB5YDBAC0AABpBASEEIANBARDAASIFRQ0CCyADBEAgBSACIAP8CgAACyABIAEo -AggiAkEBazYCCCADIQQgAkEBRw0AIAEoAgAgAUEEaigCACIEQQEQswFFDQIgBBDMASABQQwQzAEg -AyEECyAAIAM2AgggACAFNgIEIAAgBDYCACAGQRBqJAAPCyAEIANB5LPAABCyAQALQaC1wABBKyAG -QQ9qQZC1wABB3LXAABB8AAuCAgIBfgJ/IwBBgAFrIgQkACAAKAIAKQMAIQICfwJAIAEoAggiAEGA -gIAQcUUEQCAAQYCAgCBxDQEgAkEBIAEQSQwCC0EAIQADQCAAIARqQf8AaiACp0EPcSIDQTByIANB -1wBqIANBCkkbOgAAIABBAWshACACQg9WIAJCBIghAg0ACyABQQFBpurAAEECIAAgBGpBgAFqQQAg -AGsQNgwBC0EAIQADQCAAIARqQf8AaiACp0EPcSIDQTByIANBN2ogA0EKSRs6AAAgAEEBayEAIAJC -D1YgAkIEiCECDQALIAFBAUGm6sAAQQIgACAEakGAAWpBACAAaxA2CyAEQYABaiQAC4gCAQV/AkAC -QAJAAkAgASgCACIBQQFxBEBBHUGBASACIAFBfnEiBWsiBiADaiIBQQp2Z0ECdGsgAUH//wdLGyEE -IAIgBUYEQCAEIQIgASEDDAULIARBBXYiByAGaiICQYCAgMAASQ0CQeWAwQAtAAAaQRRBBBDAASIC -RQ0BIAJBATYCECACIAEgB2oiCDYCCCACIAUgB2s2AgQgAiAINgIAIAIgBEECdkEHcTYCDAwDCyAA -IAEgAiADEEMPC0EEQRQQ5wEACyAEQR1xIAJBBXRyIQILIAEgBmsiBEEAIAEgBE8bIQEgBSAGaiEF -CyAAIAI2AgwgACADNgIIIAAgATYCBCAAIAU2AgALgwIBBX8CQAJAAkACQCABKAIAIgFBAXEEQEEd -QYEBIAIgAWsiBiADaiIEQQp2Z0ECdGsgBEH//wdLGyEFIAEgAkYEQCAFIQIgBCEDDAULIAVBBXYi -ByAGaiICQYCAgMAASQ0CQeWAwQAtAAAaQRRBBBDAASICRQ0BIAJBATYCECACIAQgB2oiCDYCCCAC -IAEgB2s2AgQgAiAINgIAIAIgBUECdkEHcTYCDAwDCyAAIAEgAiADEEMPC0EEQRQQ5wEACyAFQR1x -IAJBBXRyIQILIAQgBmsiBUEAIAQgBU8bIQQgASAGaiEBCyAAIAI2AgwgACADNgIIIAAgBDYCBCAA -IAE2AgAL1QECBH8BfiMAQSBrIgMkAAJAAkAgASABIAJqIgJLBEBBACEBDAELQQAhAUEIIAIgACgC -ACIFQQF0IgQgAiAESxsiAiACQQhNGyIErSIHQiCIUEUNACAHpyIGQf////8HSw0AIAMgBQR/IAMg -BTYCHCADIAAoAgQ2AhRBAQVBAAs2AhggA0EIakEBIAYgA0EUahBzIAMoAghBAUcNASADKAIQIQIg -AygCDCEBCyABIAJBxMTAABCyAQALIAMoAgwhASAAIAQ2AgAgACABNgIEIANBIGokAAuoAgEEfyMA -QSBrIgQkAEEBIQYCQCAAKAIAIgUgASACIAAoAgQiBygCDCIBEQEADQACQCAALQAKQYABcUUEQCAF -QaLqwABBASABEQEADQIgAyAAQbyEwAAoAgARAABFDQEMAgsgBUGj6sAAQQIgAREBAA0BIARBAToA -DyAEIAc2AgQgBCAFNgIAIARBhOrAADYCFCAEIAApAgg3AhggBCAEQQ9qNgIIIAQgBDYCECADIARB -EGpBvITAACgCABEAAA0BIAQoAhBBoOrAAEECIAQoAhQoAgwRAQANAQsCQCACDQAgAC0ACkGAAXEN -ACAAKAIAQaXqwABBASAAKAIEKAIMEQEADQELIAAoAgBBpOfAAEEBIAAoAgQoAgwRAQAhBgsgBEEg -aiQAIAYLrAICBH8BbyMAQSBrIgMkABAaIQcQbyIFIAcmASADQRhqIgQgBTYCBCAEIAI2AgAgAygC -HCECAkAgAygCGCIERQRAQQEhBQwBCyADIAI2AhwgAyAENgIYIANBEGoiBCABKAIEIAEoAggQtQE2 -AgQgBEEANgIAQQEhBSADKAIUIQQCQAJAIAMoAhBBAXEEQCACIQEgBCECDAELIANBHGoiBkHXhcAA -QQQQPSAEEM0BIAEoAgy4EAwhBxBvIgEgByYBIANBCGoiAiABNgIEIAJBADYCACADKAIMIQIgAygC -CEEBcUUNASADKAIcIQELIAFBhAFJDQEgARBsDAELIAZB24XAAEEGED0gAhDNAUEAIQUgAygCHCEC -CyAAIAI2AgQgACAFNgIAIANBIGokAAvZAwEHfyMAQRBrIgYkAAJAAkAgAkEHTQRAIAINAQwCCyAG -QQhqIQcCQAJAAkACQCABQQNqQXxxIgMgAUYNACACIAMgAWsiAyACIANJGyIERQ0AQQAhA0EBIQUD -QCABIANqLQAAQS5GDQQgBCADQQFqIgNHDQALIAQgAkEIayIISw0CDAELIAJBCGshCEEAIQQLQa7c -uPECIQMDQEGAgoQIIAEgBGoiCSgCAEGu3LjxAnMiBWsgBXJBgIKECCAJQQRqKAIAQa7cuPECcyIF -ayAFcnFBgIGChHhxQYCBgoR4Rw0BIARBCGoiBCAITQ0ACwsgAiAERwRAQS4hA0EBIQUDQCABIARq -LQAAQS5GBEAgBCEDDAMLIAIgBEEBaiIERw0ACwtBACEFCyAHIAM2AgQgByAFNgIAIAYoAghBAUYh -AwwBCyABLQAAQS5GIgMgAkEBRnINACABLQABQS5GIgMgAkECRnINACABLQACQS5GIgMgAkEDRnIN -ACABLQADQS5GIgMgAkEERnINACABLQAEQS5GIgMgAkEFRnINACABLQAFQS5GIgMgAkEGRnINACAB -LQAGQS5GIQMLIAAgAyAALQAEcjoABCAAKAIAIAEgAhC8ASAGQRBqJAAL5AEBBH8jAEEQayIDJAAg -ACgCDCEBAkACfwJAAkACQAJAAkAgACgCBA4CAAECCyABDQFBASEBQQAhAEEBIQIMAwsgAUUNAQsg -A0EEaiAAEEcgAygCBCEAIAMoAgghAiADKAIMDAILIAAoAgAiASgCBCIAQQBIDQIgASgCACEBIABF -BEBBASECQQAhAAwBC0HlgMEALQAAGkEBIQQgAEEBEMABIgJFDQILIAAEQCACIAEgAPwKAAALIAAL -IQEgAiABELYBIAAEQCACIAAQzAELIANBEGokAA8LIAQgAEGQksAAELIBAAuUAgIBfwF+IwBBoAFr -IgIkACACQoCAgICAByIDIAFBGGqthDcDOCACIAMgAUEQaq2ENwMwIAIgAyABQQhqrYQ3AyggAiAD -IAGthDcDICACQZi4wAA2AgggAkEENgIMIAJBBDYCHCACQoOAgICAhICAaTcCmAEgAkGAgMAANgKQ -ASACQQI7AYgBIAJCgoCAgICEgIBpNwKAASACQYCAwAA2AnggAkECOwFwIAJCgYCAgICEgIBpNwJo -IAJBgIDAADYCYCACQQI7AVggAkKAgICAgISAgGk3AlAgAkKAgMAANwJIIAJBAjsBQCACIAJBQGs2 -AhggAkEENgIUIAIgAkEgajYCECAAIAJBCGoQRyACQaABaiQAC/IBAQJ/IwBBMGsiAiQAAkAgACkD -AEL///////////8Ag0KAgICAgICA+P8AWgRAIAJBATYCFCACQfC+wAA2AhAgAkIBNwIcIAIgAK1C -gICAgKAIhDcDKCACIAJBKGo2AhggASgCACABKAIEIAJBEGoQPCEDDAELIAJBADoADCACIAE2AghB -ASEDIAJBATYCFCACQfC+wAA2AhAgAkIBNwIcIAIgAK1CgICAgKAIhDcDKCACIAJBKGo2AhggAkEI -akHYvMAAIAJBEGoQPA0AIAItAAxFBEAgAUH4vsAAQQIQvAENAQtBACEDCyACQTBqJAAgAwuVAgEC -fyMAQSBrIgUkAEG8gcEAQbyBwQAoAgAiBkEBajYCAAJ/QQAgBkEASA0AGkEBQYiFwQAtAAANABpB -iIXBAEEBOgAAQYSFwQBBhIXBACgCAEEBajYCAEECC0H/AXEiBkECRwRAIAZBAXEEQCAFQQhqIAAg -ASgCGBECAAsACwJAQbCBwQAoAgAiBkEATgRAQbCBwQAgBkEBajYCAEG0gcEAKAIABEAgBSAAIAEo -AhQRAgAgBSAEOgAdIAUgAzoAHCAFIAI2AhggBSAFKQMANwIQQbSBwQAoAgAgBUEQakG4gcEAKAIA -KAIUEQIAC0GwgcEAQbCBwQAoAgBBAWs2AgBBiIXBAEEAOgAAIANFDQEACwALAAu7AQECfyMAQSBr -IgMkAAJAAn9BACABIAEgAmoiAksNABpBAEEIIAIgACgCACIBQQF0IgQgAiAESxsiAiACQQhNGyIE -QQBIDQAaQQAhAiADIAEEfyADIAE2AhwgAyAAKAIENgIUQQEFIAILNgIYIANBCGpBASAEIANBFGoQ -cyADKAIIQQFHDQEgAygCECEAIAMoAgwLIABBhMnAABCyAQALIAMoAgwhASAAIAQ2AgAgACABNgIE -IANBIGokAAu6AQEFfyMAQSBrIgIkACAAKAIAIgRB////P0sEQEEAQQAgARCyAQALAkBBBCAEQQF0 -IgUgBUEETRsiBUEEdCIGQfz///8HTQR/IAIgBAR/IAIgBEEEdDYCHCACIAAoAgQ2AhRBBAUgAws2 -AhggAkEIakEEIAYgAkEUahBzIAIoAghBAUcNASACKAIQIQMgAigCDAUgAwsgAyABELIBAAsgAigC -DCEBIAAgBTYCACAAIAE2AgQgAkEgaiQAC70BAQN/IwBBEGsiAiQAAkACQAJAIAFFBEAgAEUNASAA -QQhrIgEoAgBBAUcNAiAAKAIsIAAoAighAyABQQA2AgACQCABQX9GDQAgAEEEayIAIAAoAgBBAWsi -ADYCACAADQAgAUHAABDMAQsgA0UNAyADEMwBDAMLIABFDQAgAiAAQQhrIgA2AgwgACAAKAIAQQFr -IgA2AgAgAA0CIAJBDGoQkQEMAgsQ4AEAC0GChsAAQT8Q4gEACyACQRBqJAALwQECA38BfiMAQTBr -IgIkACABKAIAQYCAgIB4RgRAIAEoAgwhAyACQRRqIgRBADYCACACQoCAgIAQNwIMIAJBIGogAygC -ACIDQQhqKQIANwMAIAJBKGogA0EQaikCADcDACACIAMpAgA3AxggAkEMakHUxMAAIAJBGGoQPBog -AkEIaiAEKAIAIgM2AgAgAiACKQIMIgU3AwAgAUEIaiADNgIAIAEgBTcCAAsgAEHwxsAANgIEIAAg -ATYCACACQTBqJAALtgEBAX8jAEEQayIDJAACQAJAAkAgACgCACIAQQFxBEAgASAAQX5xIgBrIAJq -IgFBARCzAUUNAiAAIAEQzAEMAQsgACAAKAIIIgFBAWs2AgggAUEBRw0AIAAoAgAgAEEEaigCACIC -QQEQswFFDQIgAhDMASAAQQwQzAELIANBEGokAA8LQaC1wABBKyADQQ9qQZC1wABBzLXAABB8AAtB -oLXAAEErIANBD2pBkLXAAEHctcAAEHwAC7ABAQZ/AkACQCAAQYQBSQ0AIADQbyYBEFYiASgCDCEF -IAEoAhAhAiABQgA3AgwgASgCCCEDIAEoAgQhBCABQgQ3AgQgASgCACEGIAFBADYCACAAIAJJDQEg -ACACayIAIANPDQEgBCAAQQJ0aiAFNgIAIAEgAjYCECABIAA2AgwgASADNgIIIAEoAgQgASAENgIE -IAEoAgAhACABIAY2AgAgAEUNACAAQQJ0EMwBCw8LAAu5AQEBf0HlgMEALQAAGgJAQQxBBBDAASIG -BEAgBkECNgIIIAYgAzYCACAGIAQgA2sgBWo2AgQgASAGIAEoAgAiASABIAJGIgIbNgIAIAJFBEAg -ASABKAIIIgJBAWo2AgggAkEASA0CIAAgATYCDCAAIAU2AgggACAENgIEIABB7LXAADYCACAGQQwQ -zAEPCyAAIAY2AgwgACAFNgIIIAAgBDYCBCAAQey1wAA2AgAPC0EEQQwQ5wEACwALsQEBAX8jAEEQ -ayIDJAACQAJAAkAgACgCACIAQQFxBEAgASAAayACaiIBQQEQswFFDQIgACABEMwBDAELIAAgACgC -CCIBQQFrNgIIIAFBAUcNACAAKAIAIABBBGooAgAiAkEBELMBRQ0CIAIQzAEgAEEMEMwBCyADQRBq -JAAPC0GgtcAAQSsgA0EPakGQtcAAQcy1wAAQfAALQaC1wABBKyADQQ9qQZC1wABB3LXAABB8AAvP -AwIMfwF+IwBBIGsiBCQAIARBGGoiCRBWIgVBEGoiBygCADYCACAEQRBqIgogBUEIaiIIKQIANwMA -IAdBADYCACAIQgA3AgAgBSkCACEMIAVCgICAgMAANwIAIAQgDDcDCAJ/IwBBIGsiAyQAAkACQCAE -QQhqIgAoAgwiASAAKAIIIgJGBEACQCAAKAIAIgIgAUYEQNBvQYABIAEgAUGAAU0bIgb8DwEiAkF/ -Rg0EAkAgACgCECILRQRAIAAgAjYCEAwBCyABIAtqIAJHDQULIAEgBmoiAkH/////AUsNBCADIAEE -fyADIAFBAnQ2AhwgAyAAKAIENgIUQQQFQQALNgIYIANBCGpBBCACQQJ0IANBFGoQcyADKAIIQQFG -DQQgAygCDCEGIAAgAjYCACAAIAY2AgQMAQsgASACTw0DCyAAIAFBAWoiAjYCCCAAKAIEIAFBAnRq -IAI2AgAMAQsgASACTw0BCyAAIAAoAgQgAUECdGooAgA2AgwgACgCECADQSBqJAAgAWoMAQsACyAI -IAopAwA3AgAgByAJKAIANgIAIAUoAgQhAyAFKAIAIQEgBSAEKQMINwIAIAEEQCADIAFBAnQQzAEL -IARBIGokAAusAQEBfyMAQRBrIgYkAAJAIAEEQCAGQQRqIAEgAyAEIAUgAigCEBEIAAJAIAYoAgQi -AiAGKAIMIgFNBEAgBigCCCEFDAELIAJBAnQhAiAGKAIIIQMgAUUEQEEEIQUgAyACEMwBDAELIAMg -AkEEIAFBAnQiAhC4ASIFRQ0CCyAAIAE2AgQgACAFNgIAIAZBEGokAA8LQbSywABBMhDiAQALQQQg -AkGkssAAELIBAAuaAQEEfyMAQSBrIgIkAEEIIAAoAgAiBEEBdCIDIANBCE0bIgNBAEgEQEEAQQAg -ARCyAQALIAIgBAR/IAIgBDYCHCACIAAoAgQ2AhRBAQUgBQs2AhggAkEIakEBIAMgAkEUahBzIAIo -AghBAUYEQCACKAIMIAIoAhAgARCyAQALIAIoAgwhASAAIAM2AgAgACABNgIEIAJBIGokAAukAQEB -fyMAQUBqIgIkACAAKAIAIQAgAkIANwM4IAJBOGogACUBECQgAiACKAI8IgA2AjQgAiACKAI4NgIw -IAIgADYCLCACIAJBLGqtQoCAgIDgCIQ3AyAgAkECNgIMIAJBiMPAADYCCCACQgE3AhQgAiACQSBq -NgIQIAEoAgAgASgCBCACQQhqEDwgAigCLCIBBEAgAigCMCABEMwBCyACQUBrJAALjwEBAX8gAkEA -TgRAAn8gAygCBARAAkAgAygCCCIERQRADAELIAMoAgAgBCABIAIQuAEMAgsLIAEgAkUNABpB5YDB -AC0AABogAiABEMABCyIDRQRAIAAgAjYCCCAAIAE2AgQgAEEBNgIADwsgACACNgIIIAAgAzYCBCAA -QQA2AgAPCyAAQQA2AgQgAEEBNgIAC60BAQN/IAEoAgQhAgJ/AkAgASgCCCIEIAEoAgAiA0cEQEHl -gMEALQAAGkEMQQQQwAEiAQ0BQQRBDBDnAQALIARFBEBBACEBQQEhAkH0s8AADAILIAJBAXEEQCAC -IQFB/LTAAAwCCyACQQFyIQFB6LTAAAwBCyABQQE2AgggASADNgIEIAEgAjYCAEHstcAACyEDIAAg -ATYCDCAAIAQ2AgggACACNgIEIAAgAzYCAAvAAQIFfwFvAkAgASgCACIFEPABIgNBAEgNAAJAIANF -BEBBASEEDAELQeWAwQAtAAAaQQEhAiADQQEQwAEiBEUNAQsQJiEHEG8iASAHJgEgASIGJQEQHyEH -EG8iASAHJgEgARC3ASECIAFBhAFPBEAgARBsCyACJQEgBSUBIAQQISACQYQBTwRAIAIQbAsgBkGE -AU8EQCAGEGwLIAAgBRDwATYCCCAAIAQ2AgQgACADNgIADwsgAiADQaSxwAAQsgEAC5QBAQN/IwBB -EGsiAiQAAn9BASABKAIAIgNBJyABKAIEIgQoAhAiAREAAA0AGiACQQRqIAAoAgBBgQIQNQJAIAIt -AARBgAFGBEAgAyACKAIIIAERAABFDQFBAQwCCyADIAItAA4iACACQQRqaiACLQAPIABrIAQoAgwR -AQBFDQBBAQwBCyADQScgAREAAAsgAkEQaiQAC5UBAQJ/AkAgAkEASA0AIAACfyACRQRAQfSzwAAh -A0EBIQRBAAwBC0HlgMEALQAAGkEBIQMgAkEBEMABIgRFDQEgAgRAIAQgASAC/AoAAAsgBEEBcQRA -Qfy0wAAhAyAEDAELQei0wAAhAyAEQQFyCzYCDCAAIAI2AgggACAENgIEIAAgAzYCAA8LIAMgAkHk -s8AAELIBAAt5AgF+An8jAEGAAWsiBCQAIAApAwAhAkEAIQADQCAAIARqQf8AaiACp0EPcSIDQTBy -IANB1wBqIANBCkkbOgAAIABBAWshACACQg9WIAJCBIghAg0ACyABQQFBpurAAEECIAAgBGpBgAFq -QQAgAGsQNiAEQYABaiQAC4QBAQF/AkAgA0EASA0AAkAgA0UEQEEBIQEMAQtB5YDBAC0AABpBASEE -IANBARDAASIBRQ0BCyADBEAgASACIAP8CgAACyAAIAM2AgggACADNgIEIAAgATYCACAAQR1BgQEg -A0EKdmdBAnRrIANB//8HSxs2AgwPCyAEIANB9LbAABCyAQALowECBH8BbwJAIAEtAAQEQEECIQMM -AQsgASgCACUBEBQhBhBvIgIgBiYBQaiBwQAoAgAhBEGkgcEAKAIAQaSBwQBCADcCAEEBIQNBAUYE -QCABQQE6AAQMAQsCfyACJQEQFUUEQCACJQEQFiEGEG8iASAGJgEgASEEQQAMAQsgAUEBOgAEQQIL -IQMgAkGEAUkNACACEGwLIAAgBDYCBCAAIAM2AgALegEBfyMAQSBrIgIkAAJ/IAAoAgBBgICAgHhH -BEAgASAAKAIEIAAoAggQvAEMAQsgAkEQaiAAKAIMKAIAIgBBCGopAgA3AwAgAkEYaiAAQRBqKQIA -NwMAIAIgACkCADcDCCABKAIAIAEoAgQgAkEIahA8CyACQSBqJAALfAEBfyMAQUBqIgUkACAFIAE2 -AgwgBSAANgIIIAUgAzYCFCAFIAI2AhAgBUECNgIcIAVB9OnAADYCGCAFQgI3AiQgBSAFQRBqrUKA -gICA8AuENwM4IAUgBUEIaq1CgICAgIAMhDcDMCAFIAVBMGo2AiAgBUEYaiAEEJ8BAAtwAQF/IwBB -EGsiASQAIAAoAgAiACAAKAIIIgJBAWs2AggCQCACQQFGBEAgACgCACAAQQRqKAIAIgNBARCzAUUN -ASADEMwBIABBDBDMAQsgAUEQaiQADwtBoLXAAEErIAFBD2pBkLXAAEHctcAAEHwAC80CAQN/IwBB -MGsiAyQAIAMgAjYCBCADIAE2AgAgA0ECNgIMIANB1JPAADYCCCADQgI3AhQgAyADrUKAgICA0AKE -NwMoIAMgAK1CgICAgPABhDcDICADIANBIGo2AhACfyMAQRBrIgIkACADQQhqIgAoAgwhAQJAAn8C -QAJAAkACQAJAIAAoAgQOAgABAgsgAQ0BQQEhBUEAIQBBASEBDAMLIAFFDQELIAJBBGogABBHIAIo -AgwhACACKAIIIQEgAigCBAwCCyAAKAIAIgEoAgQiAEEASA0CIAEoAgAhBSAARQRAQQEhAUEAIQAM -AQtB5YDBAC0AABpBASEEIABBARDAASIBRQ0CCyAABEAgASAFIAD8CgAACyAACyEEIAEgABC2ASAE -BEAgASAEEMwBCyACQRBqJAAMAQsgBCAAQdiUwAAQsgEACyADQTBqJAALagIBfwF+IwBBMGsiAyQA -IAMgATYCBCADIAA2AgAgA0ECNgIMIANBwOjAADYCCCADQgI3AhQgA0KAgICAgAkiBCADrYQ3Aygg -AyAEIANBBGqthDcDICADIANBIGo2AhAgA0EIaiACEJ8BAAtoAQF/AkAgA0EASA0AAkAgA0UEQEEB -IQEMAQtB5YDBAC0AABpBASEEIANBARDAASIBRQ0BCyADBEAgASACIAP8CgAACyAAIAM2AgggACAB -NgIEIAAgAzYCAA8LIAQgA0Hks8AAELIBAAtpACMAQTBrIgAkAEHkgMEALQAARQRAIABBMGokAA8L -IABBAjYCDCAAQbjGwAA2AgggAEIBNwIUIAAgATYCLCAAIABBLGqtQoCAgICACYQ3AyAgACAAQSBq -NgIQIABBCGpB4MbAABCfAQALWQECfyMAQRBrIgIkACAAQQRqIQMCfyAAKAIAQQFGBEAgAiADNgIM -IAFBwoTAAEEDIAJBDGoQYAwBCyACIAM2AgggAUHAhMAAQQIgAkEIahBgCyACQRBqJAALXgEBfyMA -QTBrIgIkACACIAE2AgwgAiAANgIIIAJBAjYCFCACQdCQwAA2AhAgAkIBNwIcIAIgAkEIaq1CgICA -gIAChDcDKCACIAJBKGo2AhggAkEQahBjIAJBMGokAAteAQF/IwBBMGsiAiQAIAIgATYCDCACIAA2 -AgggAkECNgIUIAJB9JDAADYCECACQgE3AhwgAiACQQhqrUKAgICAgAKENwMoIAIgAkEoajYCGCAC -QRBqEGMgAkEwaiQAC1sBAX8gASgCACIEQQFxBEAgACABIAQgBEF+cSACIAMQbQ8LIAQgBCgCCCIB -QQFqNgIIIAFBAE4EQCAAIAQ2AgwgACADNgIIIAAgAjYCBCAAQey1wAA2AgAPCwALWAEBfyABKAIA -IgRBAXEEQCAAIAEgBCAEIAIgAxBtDwsgBCAEKAIIIgFBAWo2AgggAUEATgRAIAAgBDYCDCAAIAM2 -AgggACACNgIEIABB7LXAADYCAA8LAAtOACMAQSBrIgAkACAAQQE2AgQgAEGUvMAANgIAIABCATcC -DCAAQvy7wICgBzcDGCAAIABBGGo2AgggASgCACABKAIEIAAQPCAAQSBqJAALSwAgASgCACIBQQFx -BEAgAUF+cSEBIAMEQCABIAIgA/wKAAALIAAgAzYCCCAAIAE2AgQgACACIANqIAFrNgIADwsgACAB -IAIgAxBbC0sBAX8gACgCACAAKAIIIgNrIAJJBEAgACADIAJBAUEBEFcgACgCCCEDCyACBEAgACgC -BCADaiABIAL8CgAACyAAIAIgA2o2AghBAAtHAQF/IAAoAgAgACgCCCIDayACSQRAIAAgAyACEF8g -ACgCCCEDCyACBEAgACgCBCADaiABIAL8CgAACyAAIAIgA2o2AghBAAtNAQF/IwBBMGsiASQAIAFB -ATYCDCABQdjnwAA2AgggAUIBNwIUIAEgAUEvaq1CgICAgOALhDcDICABIAFBIGo2AhAgAUEIaiAA -EJ8BAAtEACABKAIAIgFBAXEEQCADBEAgASACIAP8CgAACyAAIAM2AgggACABNgIEIAAgAiADaiAB -azYCAA8LIAAgASACIAMQWws6AQF/IwBBIGsiACQAIABBADYCGCAAQQE2AgwgAEHkx8AANgIIIABC -BDcCECAAQQhqQZjIwAAQnwEAC0cBAX8gACgCACAAKAIIIgNrIAJJBEAgACADIAIQZyAAKAIIIQML -IAIEQCAAKAIEIANqIAEgAvwKAAALIAAgAiADajYCCEEAC0EBAn8jAEEQayICJAAgAkEIaiAAKAIA -JQEQCyACKAIIIgMgAigCDCIAIAEQ6QEgAARAIAMgABDMAQsgAkEQaiQAC08BAn8gACgCBCECIAAo -AgAhAwJAIAAoAggiAC0AAEUNACADQZzqwABBBCACKAIMEQEARQ0AQQEPCyAAIAFBCkY6AAAgAyAB -IAIoAhARAAALQgEBfyAAKAIAIgAoAjAiAQRAIAAoAjQgARDMAQsCQCAAQX9GDQAgACAAKAIEQQFr -IgE2AgQgAQ0AIABBwAAQzAELC08BAn9B5YDBAC0AABogASgCBCECIAEoAgAhA0EIQQQQwAEiAUUE -QEEEQQgQ5wEACyABIAI2AgQgASADNgIAIABBgMfAADYCBCAAIAE2AgALknQDI38afgF8IAEoAggi -A0GAgIABcSECIAArAwAhPyADQYCAgIABcUUEQCABIAJBAEchAUEAIQAjAEGAAWsiByQAID+9ISUC -f0EDID+ZRAAAAAAAAPB/YQ0AGkECICVCgICAgICAgPj/AIMiJkKAgICAgICA+P8AUQ0AGiAlQv// -//////8HgyIpQoCAgICAgIAIhCAlQgGGQv7///////8PgyAlQjSIp0H/D3EiABsiJ0IBgyEoICZQ -BEBBBCApUA0BGiAAQbMIayEAQgEhJiAoUAwBC0KAgICAgICAICAnQgGGICdCgICAgICAgAhRIgIb -ISdCAkIBIAIbISZBy3dBzHcgAhsgAGohACAoUAshAiAHIAA7AXggByAmNwNwIAdCATcDaCAHICc3 -A2AgByACOgB6An8CQAJAAkAgAkECayICBEBBASEAQePmwABB5ObAACAlQgBTIgMbQePmwABBASAD -GyABGyEXICVCP4inIAFyIRtBAyACIAJBA08bQQJrDgIDAgELIAdBAzYCKCAHQeXmwAA2AiQgB0EC -OwEgQQEhF0EBIQAgB0EgagwDCyAHQQM2AiggB0Ho5sAANgIkIAdBAjsBICAHQSBqDAILIAdBIGoh -BiAHQQ9qIQwjAEEwayIDJAACQAJAAn8CQAJAAkACQAJAAkACQAJAIAdB4ABqIgApAwAiJVBFBEAg -ACkDCCInUA0BIAApAxAiJlANAiAlICZ8IiYgJVQNAyAlICdUDQQgJkKAgICAgICAgCBaDQUgAyAA -LwEYIgA7AQggAyAlICd9Iic3AwAgACAAQSBrIAAgJkKAgICAEFQiARsiAkEQayACICZCIIYgJiAB -GyImQoCAgICAgMAAVCIBGyICQQhrIAIgJkIQhiAmIAEbIiZCgICAgICAgIABVCIBGyICQQRrIAIg -JkIIhiAmIAEbIiZCgICAgICAgIAQVCIBGyICQQJrIAIgJkIEhiAmIAEbIiZCgICAgICAgIDAAFQi -ARsgJkIChiAmIAEbIihCAFkiAmsiAWvBIgpBAEgNBiADQn8gCq0iKYgiJiAngzcDECAmICdUDQog -AyAAOwEIIAMgJTcDACADICUgJoM3AxAgJSAmVg0KQaB/IAFrwUHQAGxBsKcFakHOEG0iAEHRAE8N -ByAAQQR0IgBBqNfAAGopAwAiKkL/////D4MiJiAlIClCP4MiJYYiK0IgiCI1fiIsQiCIIjEgKkIg -iCIpIDV+IjJ8ICkgK0L/////D4MiKn4iK0IgiCI2fCEzICxC/////w+DICYgKn5CIIh8ICtC//// -/w+DfCI3QoCAgIAIfEIgiCErQgFBACABIABBsNfAAGovAQBqa0E/ca0iLIYiKkIBfSEuICYgJyAl -hiIlQiCIIid+Ii1C/////w+DICYgJUL/////D4MiJX5CIIh8ICUgKX4iJUL/////D4N8Ij5CgICA -gAh8QiCIITQgJyApfiE4ICVCIIghOSAtQiCIITogAEGy18AAai8BACEBICkgKCACrYYiJUIgiCI7 -fiI8ICYgO34iJ0IgiCIvfCApICVC/////w+DIiV+IihCIIgiMHwgJ0L/////D4MgJSAmfkIgiHwg -KEL/////D4N8Ij1CgICAgAh8QiCIfEIBfCItICyIpyIAQZDOAE8EQCAAQcCEPUkNCSAAQYDC1y9P -BEBBCEEJIABBgJTr3ANJIgIbIQpBgMLXL0GAlOvcAyACGwwLC0EGQQcgAEGAreIESSICGyEKQcCE -PUGAreIEIAIbDAoLIABB5ABPBEBBAkEDIABB6AdJIgIbIQpB5ABB6AcgAhsMCgtBCkEBIABBCUsi -ChsMCQtB+9LAAEEcQfjhwAAQlAEAC0Go08AAQR1BiOLAABCUAQALQdjTwABBHEGY4sAAEJQBAAtB -vNXAAEE2QbjjwAAQlAEAC0H01MAAQTdBqOPAABCUAQALQbjiwABBLUHo4sAAEJQBAAtBz9DAAEEd -QZDRwAAQlAEACyAAQdEAQejhwAAQfwALQQRBBSAAQaCNBkkiAhshCkGQzgBBoI0GIAIbCyECICsg -M3whMyAtIC6DISYgCiABa0EBaiEFIC0gOCA6fCA5fCA0fH0iNEIBfCIoIC6DISdBACEBAkACQAJA -AkACQAJAAkACQANAIAAgAm4hCyABQRFGDQIgASAMaiIOIAtBMGoiDToAAAJAIAAgAiALbGsiAK0g -LIYiKyAmfCIlIChaBEAgASAKRw0BIAFBAWohAUIBISUDQCAlISggJyEpIAFBEU8NBiABIAxqICZC -Cn4iJiAsiKdBMGoiAjoAACABQQFqIQEgJUIKfiElICdCCn4iJyAmIC6DIiZYDQALICUgLSAzfX4i -LCAlfCErICcgJn0gKlQiAA0HICwgJX0iLCAmVg0DDAcLICggJX0iJyACrSAshiIoVCECIC0gM30i -LEIBfCEqICcgKFQgJSAsQgF9Iixacg0FID1CgICAgAh8QiCIIi0gLyAwfHwgPHwhJ0ICIDkgOnwg -PkKAgICACHxCIIh8IDh8ICYgKHwiJSArfHx9IS5CACAxIDZ8IDdCgICAgAh8QiCIfCIxIDJ8ICYg -K3x8fSEyICUgMXwgKSA1IDt9fnwgL30gMH0gLX0hKQNAICUgK3wiLyAsVCAnIDJ8ICkgK3xackUE -QCAmICt8ISVBACECDAcLIA4gDUEBayINOgAAICYgKHwhJiAnIC58IS0gLCAvVgRAICggKXwhKSAl -ICh8ISUgJyAofSEnICggLVgNAQsLICggLVYhAiAmICt8ISUMBQsgAUEBaiEBIAJBCkkgAkEKbiEC -RQ0AC0H44sAAEJoBAAsgASAMakEBayEKICogMSA2fCA3QoCAgIAIfEIgiHwgMnxCCn4gLyAwfCA9 -QoCAgIAIfEIgiHwgPHxCCn59ICh+fCEtIClCCn4gJiAqfH0hLiAsICZ9IS9CACEpA0AgJiAqfCIl -ICxUICkgL3wgJiAtfFpyRQRAQQAhAAwFCyAKIAJBAWsiAjoAACApIC58IjAgKlQhACAlICxaDQUg -KSAqfSEpICUhJiAqIDBYDQALDAQLQRFBEUGI48AAEH8ACyABQRFBmOPAABB/AAsCQCAlICpaIAJy -DQAgKiAlICh8IiZYICogJX0gJiAqfVRxDQAgBkEANgIADAQLICUgNEIDfVggJUICWnFFBEAgBkEA -NgIADAQLIAYgBTsBCCAGIAFBAWo2AgQMAgsgJiElCwJAICUgK1ogAHINACArICUgKnwiJlggKyAl -fSAmICt9VHENACAGQQA2AgAMAgsgJSAoQlh+ICd8WCAlIChCFH5acUUEQCAGQQA2AgAMAgsgBiAF -OwEIIAYgATYCBAsgBiAMNgIACyADQTBqJAAMAQsgA0EANgIYIwBBEGsiACQAIAAgAzYCDCAAIANB -EGo2AgggAEEIakHQ6MAAIABBDGpB0OjAACADQRhqQaDRwAAQTwALAkAgBygCIARAIAdB2ABqIAdB -KGooAgA2AgAgByAHKQIgNwNQDAELIAdB0ABqIQ8gB0EPaiENIwBBoAprIgEkAAJAAkACQAJAAkAC -QAJAAkAgB0HgAGoiACkDACIlUEUEQCAAKQMIIiZQRQRAIAApAxAiJ1BFBEAgJSAlICd8IihYBEAg -JSAmWgRAIAAsABohGCAALgEYIQAgASAlPgIAIAFBAUECICVCgICAgBBUIgIbNgKgASABQQAgJUIg -iKcgAhs2AgQgAUEIakEAQZgB/AsAIAEgJj4CpAEgAUEBQQIgJkKAgICAEFQiAhs2AsQCIAFBACAm -QiCIpyACGzYCqAEgAUGsAWpBAEGYAfwLACABICc+AsgCIAFBAUECICdCgICAgBBUIgIbNgLoAyAB -QQAgJ0IgiKcgAhs2AswCIAFB0AJqQQBBmAH8CwAgAUHwA2pBAEGcAfwLACABQQE2AuwDIAFBATYC -jAUgAKwgKEIBfXl9QsKawegEfkKAoc2gtAJ8QiCIpyICwSEOAkAgAEEATgRAIAEgABAtGiABQaQB -aiAAEC0aIAFByAJqIAAQLRoMAQsgAUHsA2pBACAAa8EQLRoLAkAgDkEASARAIAFBACAOa0H//wNx -IgAQKyABQaQBaiAAECsgAUHIAmogABArDAELIAFB7ANqIAJB//8BcRArCyABKAKgASEDIAFB/Ahq -IAFBoAH8CgAAIAEgAzYCnAoCQAJAAkACQCABKALoAyIGIAMgAyAGSRsiAkEoTQRAIAJFBEBBACEC -DAQLIAJBAXEhCyACQQFHDQEMAgsMDAsgAkE+cSERIAFB/AhqIQAgAUHIAmohBQNAIAAgCCAAKAIA -IhIgBSgCAGoiCmoiCDYCACAAQQRqIgwgDCgCACITIAVBBGooAgBqIgwgCiASSSAIIApJcmoiCjYC -ACAMIBNJIAogDElyIQggBUEIaiEFIABBCGohACARIAlBAmoiCUcNAAsLIAsEfyAJQQJ0IgAgAUH8 -CGpqIgogCigCACIKIAFByAJqIABqKAIAaiIAIAhqIgk2AgAgACAKSSAAIAlLcgUgCAtFDQAgAkEo -Rg0BIAFB/AhqIAJBAnRqQQE2AgAgAkEBaiECCyABIAI2ApwKIAIgASgCjAUiCSACIAlLGyIAQSlJ -BEAgAEECdCEAAkACQAJ/AkADQCAARQ0BIABBBGsiACABQewDamooAgAiAiAAIAFB/AhqaigCACIK -Rg0ACyACIApLIAIgCklrDAELQX9BACAAGwsgGE4EQAJAIANFBEBBACEDDAELIANBAWtB/////wNx -IgBBAWoiAkEDcSEFAkAgAEEDSQRAIAEhAEIAISUMAQsgAkH8////B3EhCiABIQBCACElA0AgACAA +BX9/fH9/AGAEf3x/fwBgBX9/fn9/AGAEf35/fwBgAn9+AX4C9RAoGC4vaGZfeGV0X3RoaW5fd2Fz +bV9iZy5qcxpfX3diZ19sb2dfYzVkMWE4ZGMwOTgyMTJhZgACGC4vaGZfeGV0X3RoaW5fd2FzbV9i +Zy5qcxVfX3diaW5kZ2VuX3N0cmluZ19uZXcAFBguL2hmX3hldF90aGluX3dhc21fYmcuanMVX193 +YmluZGdlbl9zdHJpbmdfZ2V0AAsYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzFF9fd2JpbmRnZW5f +aXNfb2JqZWN0AAcYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzF19fd2JpbmRnZW5faXNfdW5kZWZp +bmVkAAcYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzDV9fd2JpbmRnZW5faW4AFRguL2hmX3hldF90 +aGluX3dhc21fYmcuanMUX193YmluZGdlbl9lcnJvcl9uZXcAFBguL2hmX3hldF90aGluX3dhc21f +YmcuanMZX193YmluZGdlbl9qc3ZhbF9sb29zZV9lcQAVGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5q +cxZfX3diaW5kZ2VuX2Jvb2xlYW5fZ2V0AAcYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzFV9fd2Jp +bmRnZW5fbnVtYmVyX2dldAALGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxRfX3diaW5kZ2VuX2Fz +X251bWJlcgAYGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcx1fX3diZ19TdHJpbmdfOGYwZWIzOWE0 +YTRjMmY2NgALGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxVfX3diaW5kZ2VuX251bWJlcl9uZXcA +GRguL2hmX3hldF90aGluX3dhc21fYmcuanMkX193YmdfZ2V0d2l0aHJlZmtleV8xZGMzNjFiZDEw +MDUzYmZlABEYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX3NldF8zZjFkMGI5ODRlZDI3 +MmVkABoYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX2dldF9iOWI5MzA0N2ZlM2NmNDVi +ABsYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzHV9fd2JnX2xlbmd0aF9lMmQyYTQ5MTMyYzFiMjU2 +AAcYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX25ld183OGZlYjEwOGI2NDcyNzEzAAwY +Li9oZl94ZXRfdGhpbl93YXNtX2JnLmpzFl9fd2JpbmRnZW5faXNfZnVuY3Rpb24ABxguL2hmX3hl +dF90aGluX3dhc21fYmcuanMbX193YmdfbmV4dF8yNWZlYWRmYzA5MTNmZWE5AAoYLi9oZl94ZXRf +dGhpbl93YXNtX2JnLmpzG19fd2JnX25leHRfNjU3NGUxYThhNjJkMTA1NQAKGC4vaGZfeGV0X3Ro +aW5fd2FzbV9iZy5qcxtfX3diZ19kb25lXzc2OWU1ZWRlNGIzMWM2N2IABxguL2hmX3hldF90aGlu +X3dhc21fYmcuanMcX193YmdfdmFsdWVfY2QxZmZhN2IxYWI3OTRmMQAKGC4vaGZfeGV0X3RoaW5f +d2FzbV9iZy5qcx9fX3diZ19pdGVyYXRvcl85YTI0Yzg4ZGY4NjBkYzY1AAwYLi9oZl94ZXRfdGhp +bl93YXNtX2JnLmpzGl9fd2JnX2dldF82N2IyYmE2MmZjMzBkZTEyABEYLi9oZl94ZXRfdGhpbl93 +YXNtX2JnLmpzG19fd2JnX2NhbGxfNjcyYTRkMjE2MzRkNGEyNAARGC4vaGZfeGV0X3RoaW5fd2Fz +bV9iZy5qcxpfX3diZ19uZXdfNDA1ZTIyZjM5MDU3NmNlMgAMGC4vaGZfeGV0X3RoaW5fd2FzbV9i +Zy5qcxpfX3diZ19zZXRfMzc4MzcwMjNmM2Q3NDBlOAAcGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5q +cx5fX3diZ19pc0FycmF5X2ExZWFiN2UwZDA2NzM5MWIABxguL2hmX3hldF90aGluX3dhc21fYmcu +anMtX193YmdfaW5zdGFuY2VvZl9BcnJheUJ1ZmZlcl9lMTQ1ODU0MzJlMzczN2ZjAAcYLi9oZl94 +ZXRfdGhpbl93YXNtX2JnLmpzJF9fd2JnX2lzU2FmZUludGVnZXJfMzQzZTJiZWVlZWNlMWJiMAAH +GC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcx1fX3diZ19idWZmZXJfNjA5Y2MzZWVlNTFlZDE1OAAK +GC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxpfX3diZ19uZXdfYTEyMDAyYTdmOTFjNzViZQAKGC4v +aGZfeGV0X3RoaW5fd2FzbV9iZy5qcxpfX3diZ19zZXRfNjU1OTViZGQ4NjhiMzAwOQAdGC4vaGZf +eGV0X3RoaW5fd2FzbV9iZy5qcx1fX3diZ19sZW5ndGhfYTQ0NjE5M2RjMjJjMTJmOAAHGC4vaGZf +eGV0X3RoaW5fd2FzbV9iZy5qcyxfX3diZ19pbnN0YW5jZW9mX1VpbnQ4QXJyYXlfMTcxNTZiY2Yx +MTgwODZhOQAHGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxdfX3diaW5kZ2VuX2RlYnVnX3N0cmlu +ZwALGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxBfX3diaW5kZ2VuX3Rocm93AAIYLi9oZl94ZXRf +dGhpbl93YXNtX2JnLmpzEV9fd2JpbmRnZW5fbWVtb3J5AAwYLi9oZl94ZXRfdGhpbl93YXNtX2Jn +LmpzH19fd2JpbmRnZW5faW5pdF9leHRlcm5yZWZfdGFibGUADQPQAc4BHgUfAgIAAgIAAwgDBAMS +AwAGAQABAAEAARIBBAIgAQIAIQMFAAIAAA4OIgAAAhYIAwACBAAEBAMDDwEFAgAIAgMGAgIDBg4D +Fg4CAAQCAgADAAQCAAgDAQMEAgUAAAAEBAAEAQEGBA0BAAAGAgADBAIAEwAGIyQXFwIlDxIFAAgT +JigqBgQAAQQsAAYDAwAGAAAFDwUDAAEACAAABAQAAAYCAgIAAAACAwMFAwMDAAYAAAAAAAAAAAAA +AA0NAgACAAACAAECAAACBQUFBQMECQJwAWhobwCAAQUDAQARBgkBfwFBgIDAAAsHzwIQBm1lbW9y +eQIAEl9fd2JnX2NodW5rZXJfZnJlZQBqC2NodW5rZXJfbmV3AEsQY2h1bmtlcl9hZGRfZGF0YQCe +AQ5jaHVua2VyX2ZpbmlzaACiARFjb21wdXRlX3hvcmJfaGFzaACfARFjb21wdXRlX2ZpbGVfaGFz +aACgARljb21wdXRlX3ZlcmlmaWNhdGlvbl9oYXNoAJ0BEV9fd2JpbmRnZW5fbWFsbG9jAJsBEl9f +d2JpbmRnZW5fcmVhbGxvYwCjARRfX3diaW5kZ2VuX2V4bl9zdG9yZQDIARdfX2V4dGVybnJlZl90 +YWJsZV9hbGxvYwBwE19fd2JpbmRnZW5fZXhwb3J0XzQBARlfX2V4dGVybnJlZl90YWJsZV9kZWFs +bG9jAG0PX193YmluZGdlbl9mcmVlAL0BEF9fd2JpbmRnZW5fc3RhcnQAJwm8AQEAQQELZ9wB3QGE +AbMBiwFO3wHZAd4B7wHuAdsB2gHAATjCAeABswGLAU/AAXOZAagBcacBqAGkAa8BrQGnAacBqQGq +AasBsAGBAXr0AfUBhwGKAV2lAWyIAY4BXm/hAZcBxAHFAdIBfnnGAcIBiQGuAdgBpgFlWccBlQFi +sgHiAcYBtwHWAYIBswGMAVTmAcoByQHMAZQBywHnAawBfFpr8AGzAZABU+gB6QG+AcABzQHOATt3 +XD6SAesBDAEOCv/zBM4BiRsBIH8gACAAKAIYIh0gASgAECIkIAAoAghqaiIbIAEoABQiFWogHSAb +IAJB/wFxc0EQdyICQfLmu+MDaiIdc0EUdyIbaiIiIAJzQRh3IgkgHWoiHCAbc0EZdyIPIAAoAhQi +GyABKAAIIgIgACgCBGpqIhkgASgADCIdaiAZIANCIIinc0EQdyIeQfui4aQEayIgIBtzQRR3IgZq +IgogASgAKCIbamoiIyABKAAsIhlqIA8gIyAAKAIQIiEgASgAACIPIAAoAgBqaiIIIAEoAAQiH2og +ISAIIAOnc0EQdyIhQefMp9AGaiIIc0EUdyIHaiIOICFzQRh3Ig1zQRB3IgsgACgCHCIFIAEoABgi +IyAAKAIMamoiDCABKAAcIiFqIAUgDCAEQf8BcXNBEHciBEHGlcDVBWsiBXNBFHciDGoiESAEc0EY +dyIQIAVqIgVqIhJzQRR3IhRqIhMgHWogBiAgIAogHnNBGHciIGoiBnNBGXciCiAOIAEoACAiBGpq +Ig4gASgAJCIeaiAKIBwgDiAQc0EQdyIcaiIKc0EUdyIOaiIQIBxzQRh3IhYgCmoiCiAOc0EZdyIc +aiIOIBtqIBwgDiAFIAxzQRl3IgUgIiABKAAwIhxqaiIMIAEoADQiImogDCAgc0EQdyIgIAggDWoi +CGoiDSAFc0EUdyIFaiIMICBzQRh3IhdzQRB3Ig4gByAIc0EZdyIIIBEgASgAOCIgamoiByABKAA8 +IgFqIAcgCXNBEHciCSAGaiIGIAhzQRR3IghqIgcgCXNBGHciCSAGaiIGaiIRc0EUdyIYaiIaIBxq +IAsgE3NBGHciCyASaiISIBRzQRl3IhQgDCAhamoiDCAPaiAJIAxzQRB3IgkgCmoiCiAUc0EUdyIM +aiIUIAlzQRh3IgkgCmoiCiAMc0EZdyIMaiITIBVqIAwgEyAGIAhzQRl3IgYgAiAQamoiCCAjaiAG +IAggC3NBEHciBiANIBdqIghqIg1zQRR3IgtqIgwgBnNBGHciBnNBEHciECAFIAhzQRl3IgggByAk +amoiByAiaiAIIAcgFnNBEHciCCASaiIHc0EUdyIFaiISIAhzQRh3IgggB2oiB2oiE3NBFHciFmoi +FyAbaiAOIBpzQRh3Ig4gEWoiESAYc0EZdyIYIAwgH2pqIgwgGWogCiAIIAxzQRB3IgpqIgggGHNB +FHciDGoiGCAKc0EYdyIKIAhqIgggDHNBGXciDGoiGiAcaiAMIBogBSAHc0EZdyIHIBQgHmpqIgUg +IGogByAFIA5zQRB3IgcgBiANaiIGaiIOc0EUdyINaiIFIAdzQRh3IgdzQRB3IgwgBiALc0EZdyIG +IAEgEmpqIgsgBGogBiAJIAtzQRB3IgkgEWoiBnNBFHciC2oiESAJc0EYdyIJIAZqIgZqIhJzQRR3 +IhRqIhogHmogECAXc0EYdyIQIBNqIhMgFnNBGXciFiAFICJqaiIFIAJqIAUgCXNBEHciCSAIaiII +IBZzQRR3IgVqIhYgCXNBGHciCSAIaiIIIAVzQRl3IgVqIhcgD2ogBSAXIAYgC3NBGXciBiAYIB1q +aiILICRqIAYgCyAQc0EQdyIGIAcgDmoiB2oiDnNBFHciC2oiBSAGc0EYdyIGc0EQdyIQIAcgDXNB +GXciByARICFqaiINICBqIAcgCiANc0EQdyIKIBNqIgdzQRR3Ig1qIhEgCnNBGHciCiAHaiIHaiIT +c0EUdyIXaiIYIBxqIAwgGnNBGHciDCASaiISIBRzQRl3IhQgBSAjamoiBSAVaiAFIApzQRB3Igog +CGoiCCAUc0EUdyIFaiIUIApzQRh3IgogCGoiCCAFc0EZdyIFaiIaIB5qIAUgGiAHIA1zQRl3Igcg +FiAZamoiDSABaiAHIAwgDXNBEHciByAGIA5qIgZqIg5zQRR3Ig1qIgUgB3NBGHciB3NBEHciDCAG +IAtzQRl3IgYgBCARamoiCyAfaiAGIAkgC3NBEHciCSASaiIGc0EUdyILaiIRIAlzQRh3IgkgBmoi +BmoiEnNBFHciFmoiGiAZaiAQIBhzQRh3IhAgE2oiEyAXc0EZdyIXIAUgIGpqIgUgHWogBSAJc0EQ +dyIJIAhqIgggF3NBFHciBWoiFyAJc0EYdyIJIAhqIgggBXNBGXciBWoiGCACaiAFIBggBiALc0EZ +dyIGIBQgG2pqIgsgIWogBiALIBBzQRB3IgYgByAOaiIHaiIOc0EUdyILaiIFIAZzQRh3IgZzQRB3 +IhAgByANc0EZdyIHIBEgImpqIg0gAWogByAKIA1zQRB3IgogE2oiB3NBFHciDWoiESAKc0EYdyIK +IAdqIgdqIhRzQRR3IhNqIhggHmogDCAac0EYdyIMIBJqIhIgFnNBGXciFiAFICRqaiIFIA9qIAUg +CnNBEHciCiAIaiIIIBZzQRR3IgVqIhYgCnNBGHciCiAIaiIIIAVzQRl3IgVqIhogGWogBSAaIAcg +DXNBGXciByAVIBdqaiINIARqIAcgDCANc0EQdyIHIAYgDmoiBmoiDnNBFHciDWoiBSAHc0EYdyIH +c0EQdyIMIAYgC3NBGXciBiARIB9qaiILICNqIAYgCSALc0EQdyIJIBJqIgZzQRR3IgtqIhEgCXNB +GHciCSAGaiIGaiISc0EUdyIXaiIaIBVqIBAgGHNBGHciECAUaiIUIBNzQRl3IhMgASAFamoiBSAb +aiAFIAlzQRB3IgkgCGoiCCATc0EUdyIFaiITIAlzQRh3IgkgCGoiCCAFc0EZdyIFaiIYIB1qIAUg +GCAGIAtzQRl3IgYgFiAcamoiCyAiaiAGIAsgEHNBEHciBiAHIA5qIgdqIg5zQRR3IgtqIgUgBnNB +GHciBnNBEHciECAHIA1zQRl3IgcgESAgamoiDSAEaiAHIAogDXNBEHciCiAUaiIHc0EUdyINaiIR +IApzQRh3IgogB2oiB2oiFHNBFHciFmoiGCAZaiAMIBpzQRh3IgwgEmoiEiAXc0EZdyIXIAUgIWpq +IgUgAmogBSAKc0EQdyIKIAhqIgggF3NBFHciBWoiFyAKc0EYdyIKIAhqIgggBXNBGXciBWoiGiAV +aiAFIBogByANc0EZdyIHIA8gE2pqIg0gH2ogByAMIA1zQRB3IgcgBiAOaiIGaiIOc0EUdyINaiIF +IAdzQRh3IgdzQRB3IgwgBiALc0EZdyIGIBEgI2pqIgsgJGogBiAJIAtzQRB3IgkgEmoiBnNBFHci +C2oiESAJc0EYdyIJIAZqIgZqIhJzQRR3IhNqIhogD2ogECAYc0EYdyIQIBRqIhQgFnNBGXciFiAE +IAVqaiIFIBxqIAUgCXNBEHciCSAIaiIIIBZzQRR3IgVqIhYgCXNBGHciCSAIaiIIIAVzQRl3IgVq +IhggG2ogBSAYIAYgC3NBGXciBiAXIB5qaiILICBqIAYgCyAQc0EQdyIGIAcgDmoiB2oiDnNBFHci +C2oiBSAGc0EYdyIGc0EQdyIQIAcgDXNBGXciByABIBFqaiINIB9qIAcgCiANc0EQdyIKIBRqIgdz +QRR3Ig1qIhEgCnNBGHciCiAHaiIHaiIUc0EUdyIXaiIYIBVqIAwgGnNBGHciFSASaiIMIBNzQRl3 +IhIgBSAiamoiBSAdaiAFIApzQRB3IgogCGoiCCASc0EUdyIFaiISIApzQRh3IgogCGoiCCAFc0EZ +dyIFaiITIA9qIAUgEyAHIA1zQRl3Ig8gAiAWamoiByAjaiAPIAcgFXNBEHciFSAGIA5qIg9qIgZz +QRR3IgdqIg4gFXNBGHciFXNBEHciDSALIA9zQRl3Ig8gESAkamoiCyAhaiAPIAkgC3NBEHciDyAM +aiIJc0EUdyILaiIFIA9zQRh3Ig8gCWoiCWoiDHNBFHciEWoiEyACaiAeIBAgGHNBGHciAiAUaiIe +IBdzQRl3IhAgDiAfamoiH2ogDyAfc0EQdyIPIAhqIh8gEHNBFHciCGoiDiAPc0EYdyIPIB9qIh8g +CHNBGXciCGoiECAcaiAQIAEgCSALc0EZdyIBIBIgGWpqIhlqIAEgAiAZc0EQdyIBIAYgFWoiAmoi +FXNBFHciGWoiHCABc0EYdyIBc0EQdyIJIAIgB3NBGXciAiAEIAVqaiIEICNqIAIgBCAKc0EQdyIC +IB5qIgRzQRR3IiNqIh4gAnNBGHciAiAEaiIEaiIGIAhzQRR3IgpqIgggCXNBGHciCSAGaiIGIAEg +FWoiASAZc0EZdyIVIB4gIWpqIhkgImogFSAPIBlzQRB3IhUgDSATc0EYdyIZIAxqIg9qIiFzQRR3 +Ih5qIiJzNgIMIAAgGyAPIBFzQRl3Ig8gHCAgamoiHGogAiAcc0EQdyICIB9qIhsgD3NBFHciD2oi +HyACc0EYdyICIBtqIhsgJCAEICNzQRl3IgQgDiAdamoiHWogBCABIBkgHXNBEHciAWoiBHNBFHci +JGoiHXM2AgggACAVICJzQRh3IhUgIWoiGSAIczYCBCAAIAEgHXNBGHciASAEaiIEIB9zNgIAIAAg +BCAkc0EZdyACczYCHCAAIAYgCnNBGXcgFXM2AhggACAPIBtzQRl3IAFzNgIUIAAgGSAec0EZdyAJ +czYCEAubJAIJfwF+IwBBEGsiCCQAAn8CQAJAAkACQAJAAkAgAEH1AU8EQEEAIABBzP97Sw0HGiAA +QQtqIgFBeHEhBUGEhsEAKAIAIglFDQRBHyEHQQAgBWshBCAAQfT//wdNBEAgBUEGIAFBCHZnIgBr +dkEBcSAAQQF0a0E+aiEHCyAHQQJ0QeiCwQBqKAIAIgFFBEBBACEADAILQQAhACAFQRkgB0EBdmtB +ACAHQR9HG3QhAwNAAkAgASgCBEF4cSIGIAVJDQAgBiAFayIGIARPDQAgASECIAYiBA0AQQAhBCAB +IQAMBAsgASgCFCIGIAAgBiABIANBHXZBBHFqKAIQIgFHGyAAIAYbIQAgA0EBdCEDIAENAAsMAQtB +gIbBACgCACICQRAgAEELakH4A3EgAEELSRsiBUEDdiIAdiIBQQNxBEACQCABQX9zQQFxIABqIgZB +A3QiAEH4g8EAaiIDIABBgITBAGooAgAiASgCCCIERwRAIAQgAzYCDCADIAQ2AggMAQtBgIbBACAC +QX4gBndxNgIACyABIABBA3I2AgQgACABaiIAIAAoAgRBAXI2AgQgAUEIagwHCyAFQYiGwQAoAgBN +DQMCQAJAIAFFBEBBhIbBACgCACIARQ0GIABoQQJ0QeiCwQBqKAIAIgIoAgRBeHEgBWshBCACIQED +QAJAIAIoAhAiAA0AIAIoAhQiAA0AIAEoAhghBwJAAkAgASABKAIMIgBGBEAgAUEUQRAgASgCFCIA +G2ooAgAiAg0BQQAhAAwCCyABKAIIIgIgADYCDCAAIAI2AggMAQsgAUEUaiABQRBqIAAbIQMDQCAD +IQYgAiIAQRRqIABBEGogACgCFCICGyEDIABBFEEQIAIbaigCACICDQALIAZBADYCAAsgB0UNBAJA +IAEoAhxBAnRB6ILBAGoiAigCACABRwRAIAEgBygCEEcEQCAHIAA2AhQgAA0CDAcLIAcgADYCECAA +DQEMBgsgAiAANgIAIABFDQQLIAAgBzYCGCABKAIQIgIEQCAAIAI2AhAgAiAANgIYCyABKAIUIgJF +DQQgACACNgIUIAIgADYCGAwECyAAKAIEQXhxIAVrIgIgBCACIARJIgIbIQQgACABIAIbIQEgACEC +DAALAAsCQEECIAB0IgNBACADa3IgASAAdHFoIgZBA3QiAUH4g8EAaiIDIAFBgITBAGooAgAiACgC +CCIERwRAIAQgAzYCDCADIAQ2AggMAQtBgIbBACACQX4gBndxNgIACyAAIAVBA3I2AgQgACAFaiIG +IAEgBWsiA0EBcjYCBCAAIAFqIAM2AgBBiIbBACgCACIEBEAgBEF4cUH4g8EAaiEBQZCGwQAoAgAh +AgJ/QYCGwQAoAgAiBUEBIARBA3Z0IgRxRQRAQYCGwQAgBCAFcjYCACABDAELIAEoAggLIQQgASAC +NgIIIAQgAjYCDCACIAE2AgwgAiAENgIIC0GQhsEAIAY2AgBBiIbBACADNgIAIABBCGoMCAtBhIbB +AEGEhsEAKAIAQX4gASgCHHdxNgIACwJAAkAgBEEQTwRAIAEgBUEDcjYCBCABIAVqIgMgBEEBcjYC +BCADIARqIAQ2AgBBiIbBACgCACIGRQ0BIAZBeHFB+IPBAGohAEGQhsEAKAIAIQICf0GAhsEAKAIA +IgVBASAGQQN2dCIGcUUEQEGAhsEAIAUgBnI2AgAgAAwBCyAAKAIICyEGIAAgAjYCCCAGIAI2Agwg +AiAANgIMIAIgBjYCCAwBCyABIAQgBWoiAEEDcjYCBCAAIAFqIgAgACgCBEEBcjYCBAwBC0GQhsEA +IAM2AgBBiIbBACAENgIACyABQQhqDAYLIAAgAnJFBEBBACECQQIgB3QiAEEAIABrciAJcSIARQ0D +IABoQQJ0QeiCwQBqKAIAIQALIABFDQELA0AgACACIAAoAgRBeHEiAyAFayIGIARJIgcbIQkgACgC +ECIBRQRAIAAoAhQhAQsgAiAJIAMgBUkiABshAiAEIAYgBCAHGyAAGyEEIAEiAA0ACwsgAkUNACAF +QYiGwQAoAgAiAE0gBCAAIAVrT3ENACACKAIYIQcCQAJAIAIgAigCDCIARgRAIAJBFEEQIAIoAhQi +ABtqKAIAIgENAUEAIQAMAgsgAigCCCIBIAA2AgwgACABNgIIDAELIAJBFGogAkEQaiAAGyEDA0Ag +AyEGIAEiAEEUaiAAQRBqIAAoAhQiARshAyAAQRRBECABG2ooAgAiAQ0ACyAGQQA2AgALIAdFDQIC +QCACKAIcQQJ0QeiCwQBqIgEoAgAgAkcEQCACIAcoAhBHBEAgByAANgIUIAANAgwFCyAHIAA2AhAg +AA0BDAQLIAEgADYCACAARQ0CCyAAIAc2AhggAigCECIBBEAgACABNgIQIAEgADYCGAsgAigCFCIB +RQ0CIAAgATYCFCABIAA2AhgMAgsCQAJAAkACQAJAIAVBiIbBACgCACIBSwRAIAVBjIbBACgCACIA +TwRAIAVBr4AEakGAgHxxIgJBEHZAACEAIAhBBGoiAUEANgIIIAFBACACQYCAfHEgAEF/RiICGzYC +BCABQQAgAEEQdCACGzYCAEEAIAgoAgQiAUUNCRogCCgCDCEGQZiGwQAgCCgCCCIEQZiGwQAoAgBq +IgA2AgBBnIbBACAAQZyGwQAoAgAiAiAAIAJLGzYCAAJAAkBBlIbBACgCACICBEBB6IPBACEAA0Ag +ASAAKAIAIgMgACgCBCIHakYNAiAAKAIIIgANAAsMAgtBpIbBACgCACIAQQAgACABTRtFBEBBpIbB +ACABNgIAC0GohsEAQf8fNgIAQfSDwQAgBjYCAEHsg8EAIAQ2AgBB6IPBACABNgIAQYSEwQBB+IPB +ADYCAEGMhMEAQYCEwQA2AgBBgITBAEH4g8EANgIAQZSEwQBBiITBADYCAEGIhMEAQYCEwQA2AgBB +nITBAEGQhMEANgIAQZCEwQBBiITBADYCAEGkhMEAQZiEwQA2AgBBmITBAEGQhMEANgIAQayEwQBB +oITBADYCAEGghMEAQZiEwQA2AgBBtITBAEGohMEANgIAQaiEwQBBoITBADYCAEG8hMEAQbCEwQA2 +AgBBsITBAEGohMEANgIAQcSEwQBBuITBADYCAEG4hMEAQbCEwQA2AgBBwITBAEG4hMEANgIAQcyE +wQBBwITBADYCAEHIhMEAQcCEwQA2AgBB1ITBAEHIhMEANgIAQdCEwQBByITBADYCAEHchMEAQdCE +wQA2AgBB2ITBAEHQhMEANgIAQeSEwQBB2ITBADYCAEHghMEAQdiEwQA2AgBB7ITBAEHghMEANgIA +QeiEwQBB4ITBADYCAEH0hMEAQeiEwQA2AgBB8ITBAEHohMEANgIAQfyEwQBB8ITBADYCAEH4hMEA +QfCEwQA2AgBBhIXBAEH4hMEANgIAQYyFwQBBgIXBADYCAEGAhcEAQfiEwQA2AgBBlIXBAEGIhcEA +NgIAQYiFwQBBgIXBADYCAEGchcEAQZCFwQA2AgBBkIXBAEGIhcEANgIAQaSFwQBBmIXBADYCAEGY +hcEAQZCFwQA2AgBBrIXBAEGghcEANgIAQaCFwQBBmIXBADYCAEG0hcEAQaiFwQA2AgBBqIXBAEGg +hcEANgIAQbyFwQBBsIXBADYCAEGwhcEAQaiFwQA2AgBBxIXBAEG4hcEANgIAQbiFwQBBsIXBADYC +AEHMhcEAQcCFwQA2AgBBwIXBAEG4hcEANgIAQdSFwQBByIXBADYCAEHIhcEAQcCFwQA2AgBB3IXB +AEHQhcEANgIAQdCFwQBByIXBADYCAEHkhcEAQdiFwQA2AgBB2IXBAEHQhcEANgIAQeyFwQBB4IXB +ADYCAEHghcEAQdiFwQA2AgBB9IXBAEHohcEANgIAQeiFwQBB4IXBADYCAEH8hcEAQfCFwQA2AgBB +8IXBAEHohcEANgIAQZSGwQAgAUEPakF4cSIAQQhrIgI2AgBB+IXBAEHwhcEANgIAQYyGwQAgBEEo +ayIDIAEgAGtqQQhqIgA2AgAgAiAAQQFyNgIEIAEgA2pBKDYCBEGghsEAQYCAgAE2AgAMCAsgAiAD +SSABIAJNcg0AIAAoAgwiA0EBcQ0AIANBAXYgBkYNAwtBpIbBAEGkhsEAKAIAIgAgASAAIAFJGzYC +ACABIARqIQNB6IPBACEAAkACQANAIAMgACgCACIHRwRAIAAoAggiAA0BDAILCyAAKAIMIgNBAXEN +ACADQQF2IAZGDQELQeiDwQAhAANAAkAgAiAAKAIAIgNPBEAgAiADIAAoAgRqIgdJDQELIAAoAggh +AAwBCwtBlIbBACABQQ9qQXhxIgBBCGsiAzYCAEGMhsEAIARBKGsiCSABIABrakEIaiIANgIAIAMg +AEEBcjYCBCABIAlqQSg2AgRBoIbBAEGAgIABNgIAIAIgB0Ega0F4cUEIayIAIAAgAkEQakkbIgNB +GzYCBEHog8EAKQIAIQogA0EQakHwg8EAKQIANwIAIAMgCjcCCEH0g8EAIAY2AgBB7IPBACAENgIA +QeiDwQAgATYCAEHwg8EAIANBCGo2AgAgA0EcaiEAA0AgAEEHNgIAIABBBGoiACAHSQ0ACyACIANG +DQcgAyADKAIEQX5xNgIEIAIgAyACayIAQQFyNgIEIAMgADYCACAAQYACTwRAIAIgABBVDAgLIABB ++AFxQfiDwQBqIQECf0GAhsEAKAIAIgNBASAAQQN2dCIAcUUEQEGAhsEAIAAgA3I2AgAgAQwBCyAB +KAIICyEAIAEgAjYCCCAAIAI2AgwgAiABNgIMIAIgADYCCAwHCyAAIAE2AgAgACAAKAIEIARqNgIE +IAFBD2pBeHFBCGsiAiAFQQNyNgIEIAdBD2pBeHFBCGsiBCACIAVqIgBrIQUgBEGUhsEAKAIARg0D +IARBkIbBACgCAEYNBCAEKAIEIgFBA3FBAUYEQCAEIAFBeHEiARBNIAEgBWohBSABIARqIgQoAgQh +AQsgBCABQX5xNgIEIAAgBUEBcjYCBCAAIAVqIAU2AgAgBUGAAk8EQCAAIAUQVQwGCyAFQfgBcUH4 +g8EAaiEBAn9BgIbBACgCACIDQQEgBUEDdnQiBHFFBEBBgIbBACADIARyNgIAIAEMAQsgASgCCAsh +AyABIAA2AgggAyAANgIMIAAgATYCDCAAIAM2AggMBQtBjIbBACAAIAVrIgE2AgBBlIbBAEGUhsEA +KAIAIgAgBWoiAjYCACACIAFBAXI2AgQgACAFQQNyNgIEIABBCGoMCAtBkIbBACgCACEAAkAgASAF +ayICQQ9NBEBBkIbBAEEANgIAQYiGwQBBADYCACAAIAFBA3I2AgQgACABaiIBIAEoAgRBAXI2AgQM +AQtBiIbBACACNgIAQZCGwQAgACAFaiIDNgIAIAMgAkEBcjYCBCAAIAFqIAI2AgAgACAFQQNyNgIE +CyAAQQhqDAcLIAAgBCAHajYCBEGUhsEAQZSGwQAoAgAiAEEPakF4cSIBQQhrIgI2AgBBjIbBAEGM +hsEAKAIAIARqIgMgACABa2pBCGoiATYCACACIAFBAXI2AgQgACADakEoNgIEQaCGwQBBgICAATYC +AAwDC0GUhsEAIAA2AgBBjIbBAEGMhsEAKAIAIAVqIgE2AgAgACABQQFyNgIEDAELQZCGwQAgADYC +AEGIhsEAQYiGwQAoAgAgBWoiATYCACAAIAFBAXI2AgQgACABaiABNgIACyACQQhqDAMLQQBBjIbB +ACgCACIAIAVNDQIaQYyGwQAgACAFayIBNgIAQZSGwQBBlIbBACgCACIAIAVqIgI2AgAgAiABQQFy +NgIEIAAgBUEDcjYCBCAAQQhqDAILQYSGwQBBhIbBACgCAEF+IAIoAhx3cTYCAAsCQCAEQRBPBEAg +AiAFQQNyNgIEIAIgBWoiACAEQQFyNgIEIAAgBGogBDYCACAEQYACTwRAIAAgBBBVDAILIARB+AFx +QfiDwQBqIQECf0GAhsEAKAIAIgNBASAEQQN2dCIEcUUEQEGAhsEAIAMgBHI2AgAgAQwBCyABKAII +CyEDIAEgADYCCCADIAA2AgwgACABNgIMIAAgAzYCCAwBCyACIAQgBWoiAEEDcjYCBCAAIAJqIgAg +ACgCBEEBcjYCBAsgAkEIagsgCEEQaiQAC9UMAg1/AX4jAEGgAmsiByQAAkACQAJAAkACQCABQYAI +TQRAIAdBADYCiAEgASABQQAgAUGACEcbIgxrIg5BgAhPBEAgB0EBNgKIASAHIAA2AowBQQEhCgsg +B0GMAWohCyADIRQgBSEBIwBBIGsiCCQAIAZBBXYiCSAKIAkgCkkbIg0EQCAEQQJyIQ8gBEEBciEQ +A0AgCygCACEJIAhBGGoiESACQRhqKQIANwMAIAhBEGoiEiACQRBqKQIANwMAIAhBCGoiEyACQQhq +KQIANwMAIAggAikCADcDACAIIAlBwAAgFCAQECggCCAJQUBrQcAAIBQgBBAoIAggCUGAAWpBwAAg +FCAEECggCCAJQcABakHAACAUIAQQKCAIIAlBgAJqQcAAIBQgBBAoIAggCUHAAmpBwAAgFCAEECgg +CCAJQYADakHAACAUIAQQKCAIIAlBwANqQcAAIBQgBBAoIAggCUGABGpBwAAgFCAEECggCCAJQcAE +akHAACAUIAQQKCAIIAlBgAVqQcAAIBQgBBAoIAggCUHABWpBwAAgFCAEECggCCAJQYAGakHAACAU +IAQQKCAIIAlBwAZqQcAAIBQgBBAoIAggCUGAB2pBwAAgFCAEECggCCAJQcAHakHAACAUIA8QKCAB +QRhqIBEpAwA3AAAgAUEQaiASKQMANwAAIAFBCGogEykDADcAACABIAgpAwA3AAAgC0EEaiELIAFB +IGohASAUQgF8IRQgDUEBayINDQALCyAIQSBqJAAgDEUNASAHQcgBakIANwMAIAdBwAFqQgA3AwAg +B0G4AWpCADcDACAHQbABakIANwMAIAdBqAFqQgA3AwAgB0GgAWpCADcDACAHQZgBakIANwMAIAdB +2AFqIgEgAkEIaikCADcDACAHQeABaiIIIAJBEGopAgA3AwAgB0HoAWoiCSACQRhqKQIANwMAIAdC +ADcDkAEgByAEOgD6ASAHQQA7AfgBIAcgAikCADcD0AEgByADIAqtfDcD8AEgB0GQAWogACAOaiAM +EEYhACAHQdAAaiABKQMANwMAIAdB2ABqIAgpAwA3AwAgB0HgAGogCSkDADcDACAHQRBqIABBCGop +AwA3AwAgB0EYaiAAQRBqKQMANwMAIAdBIGogAEEYaikDADcDACAHQShqIABBIGopAwA3AwAgB0Ew +aiAAQShqKQMANwMAIAdBOGogAEEwaikDADcDACAHQUBrIABBOGopAwA3AwAgByAHKQPQATcDSCAH +IAApAwA3AwggBy0A+gEhACAHLQD5ASECIAcgBy0A+AEiBDoAcCAHIAcpA/ABIgM3A2ggByAAIAJF +ckECciIAOgBxIAdBmAJqIgIgCSkDADcDACAHQZACaiIJIAgpAwA3AwAgB0GIAmoiCCABKQMANwMA +IAcgBykD0AE3A4ACIAdBgAJqIAdBCGogBCADIAAQKCAKQQV0IgBBIGoiASAGSw0CIAIoAgAhASAJ +KAIAIQIgCCgCACEEIAcoApQCIQYgBygCjAIhCCAHKAKEAiEJIAcoAoACIQsgACAFaiIAIAcoApwC +NgAcIAAgATYAGCAAIAY2ABQgACACNgAQIAAgCDYADCAAIAQ2AAggACAJNgAEIAAgCzYAACAKQQFq +IQoMAQsgAUJ/IAGtQgF8QgGIQgF9eYinIghNDQIgB0EIaiIJQQBBgAH8CwAgACAIQQFqIgggAiAD +IAQgCUEgQcAAIAhBgAhGGyIKECohCyAAIAhqIAEgCGsgAiADIAhBCnatfCAEIAkgCmpBgAEgCmsQ +KiALQQFGBEAgBkE/TQ0EIAUgBykACDcAACAFQThqIAdBQGspAAA3AAAgBUEwaiAHQThqKQAANwAA +IAVBKGogB0EwaikAADcAACAFQSBqIAdBKGopAAA3AAAgBUEYaiAHQSBqKQAANwAAIAVBEGogB0EY +aikAADcAACAFQQhqIAdBEGopAAA3AABBAiEKDAELIAtqQQV0IgBBgQFPDQQgB0EIaiAAIAIgBCAF +IAYQQSEKCyAHQaACaiQAIAoPCyABIAZByLvAABDUAQALIAdBADYCGCAHQQE2AgwgB0HQusAANgII +IAdCBDcCECAHQQhqQZi8wAAQoQEAC0HAACAGQai8wAAQ1AEACyAAQYABQbi8wAAQ1AEAC/MIAgV/ +A34CQAJAAkAgAUEITwRAIAFBB3EiAkUNASAAKAKgASIDQSlPDQIgA0UEQCAAQQA2AqABDAILIANB +AWtB/////wNxIgVBAWoiBEEDcSEGIAJBAnRB0OXAAGooAgAgAnatIQkCQCAFQQNJBEAgACECDAEL +IARB/P///wdxIQUgACECA0AgAiACNQIAIAl+IAh8Igc+AgAgAkEEaiIEIAQ1AgAgCX4gB0IgiHwi +Bz4CACACQQhqIgQgBDUCACAJfiAHQiCIfCIHPgIAIAJBDGoiBCAENQIAIAl+IAdCIIh8Igc+AgAg +B0IgiCEIIAJBEGohAiAFQQRrIgUNAAsLIAYEQANAIAIgAjUCACAJfiAIfCIHPgIAIAJBBGohAiAH +QiCIIQggBkEBayIGDQALCyAAIAdCgICAgBBaBH8gA0EoRg0EIAAgA0ECdGogCD4CACADQQFqBSAD +CzYCoAEMAQsgACgCoAEiA0EpTw0BIANFBEAgAEEANgKgAQ8LIAFBAnRB0OXAAGo1AgAhCSADQQFr +Qf////8DcSIBQQFqIgJBA3EhBgJAIAFBA0kEQCAAIQIMAQsgAkH8////B3EhBSAAIQIDQCACIAI1 +AgAgCX4gCHwiBz4CACACQQRqIgEgATUCACAJfiAHQiCIfCIHPgIAIAJBCGoiASABNQIAIAl+IAdC +IIh8Igc+AgAgAkEMaiIBIAE1AgAgCX4gB0IgiHwiBz4CACAHQiCIIQggAkEQaiECIAVBBGsiBQ0A +CwsgBgRAA0AgAiACNQIAIAl+IAh8Igc+AgAgAkEEaiECIAdCIIghCCAGQQFrIgYNAAsLIAAgB0KA +gICAEFoEfyADQShGDQMgACADQQJ0aiAIPgIAIANBAWoFIAMLNgKgAQ8LAkAgAUEIcQRAIAAoAqAB +IgNBKU8NAgJAIANFBEBBACEDDAELIANBAWtB/////wNxIgJBAWoiBUEDcSEGAkAgAkEDSQRAQgAh +ByAAIQIMAQsgBUH8////B3EhBUIAIQcgACECA0AgAiACNQIAQuHrF34gB3wiBz4CACACQQRqIgQg +BDUCAELh6xd+IAdCIIh8Igc+AgAgAkEIaiIEIAQ1AgBC4esXfiAHQiCIfCIHPgIAIAJBDGoiBCAE +NQIAQuHrF34gB0IgiHwiCD4CACAIQiCIIQcgAkEQaiECIAVBBGsiBQ0ACwsgBgRAA0AgAiACNQIA +QuHrF34gB3wiCD4CACACQQRqIQIgCEIgiCEHIAZBAWsiBg0ACwsgCEKAgICAEFQNACADQShGDQIg +ACADQQJ0aiAHPgIAIANBAWohAwsgACADNgKgAQsgAUEQcQRAIABBxNLAAEECEDMLIAFBIHEEQCAA +QczSwABBAxAzCyABQcAAcQRAIABB2NLAAEEFEDMLIAFBgAFxBEAgAEHs0sAAQQoQMwsgAUGAAnEE +QCAAQZTTwABBExAzCyAAIAEQLRoPCwwBCyADQShB7PzAABDUAQALQShBKEHs/MAAEIABAAu3CAIM +fwF+IwBBwAFrIgIkACABKAIQIQMgAiABQRBqIgQ2AiAgAiADNgIcIAIgAkG/AWoiBjYCGCACQYAB +aiIFIAEgAkEYaiIHEEoCQAJAAkAgAikDgAEiDkICUQ0AIAJB+ABqIgMgAkGoAWopAwA3AwAgAkHw +AGoiCCACQaABaikDADcDACACQegAaiIJIAJBmAFqKQMANwMAIAJB4ABqIgogAkGQAWopAwA3AwAg +AiACKQOIATcDWCAOp0EBcUUNACACQdAAaiILIAMpAwA3AwAgAkHIAGoiDCAIKQMANwMAIAJBQGsi +DSAJKQMANwMAIAJBOGoiCCAKKQMANwMAIAIgAikDWDcDMEH5gcEALQAAGkGgAUEIEMMBIgNFDQIg +AyACKQMwNwMAIANBIGogCykDADcDACADQRhqIAwpAwA3AwAgA0EQaiANKQMANwMAIANBCGogCCkD +ADcDACACQQE2AhQgAiADNgIQIAJBBDYCDCACQShqIgkgBCgCACIENgIAIAJBIGogAUEIaikCADcD +ACACIAEpAgA3AxggAiAJNgK4ASACIAQ2ArQBIAIgBjYCsAEgBSAHIAJBsAFqEEoCQCACKQOAASIO +QgJRDQAgAkGIAWohBEEoIQFBASEGA0AgAkH4AGoiBSAEQSBqKQMANwMAIAJB8ABqIgcgBEEYaikD +ADcDACACQegAaiIKIARBEGopAwA3AwAgAkHgAGoiDSAEQQhqKQMANwMAIAIgBCkDADcDWCAOp0EB +cUUNASALIAUpAwA3AwAgDCAHKQMANwMAIAJBQGsiByAKKQMANwMAIAggDSkDADcDACACIAIpA1g3 +AzAgAigCDCAGRgRAIAJBDGogBkEBQQhBKBBXIAIoAhAhAwsgASADaiIFIAIpAzA3AwAgBUEgaiAL +KQMANwMAIAVBGGogDCkDADcDACAFQRBqIAcpAwA3AwAgBUEIaiAIKQMANwMAIAIgBkEBaiIGNgIU +IAIoAighBSACIAk2ArgBIAIgBTYCtAEgAUEoaiEBIAIgAkG/AWo2ArABIAJBgAFqIAJBGGogAkGw +AWoQSiACKQOAASIOQgJSDQALCyACKAIkIgEgAigCHCIDRwRAIAEgA2tBBHYhBANAIAMoAgAiAQRA +IANBBGooAgAgARDPAQsgA0EQaiEDIARBAWsiBA0ACwsgAigCICIBBEAgAigCGCABQQR0EM8BCyAA +IAIpAgw3AgAgAEEIaiACQRRqKAIANgIADAELIABBADYCCCAAQoCAgICAATcCACABKAIMIgAgASgC +BCIDRwRAIAAgA2tBBHYhBANAIAMoAgAiAARAIANBBGooAgAgABDPAQsgA0EQaiEDIARBAWsiBA0A +CwsgASgCCCIARQ0AIAEoAgAgAEEEdBDPAQsgAkHAAWokAA8LQQhBoAFBxJHAABC1AQAL0AgBCH8C +QCABQYAKSQRAIAFBBXYhBwJAAkAgACgCoAEiBQRAIAVBAWshAyAFQQJ0IABqQQRrIQIgBSAHakEC +dCAAakEEayEGIAVBKUkhBQNAIAVFDQIgAyAHaiIEQShPDQMgBiACKAIANgIAIAZBBGshBiACQQRr +IQIgA0EBayIDQX9HDQALCyABQSBJDQMgAEEANgIAIAdBAWoiAkECRg0DIABBADYCBCACQQNGDQMg +AEEANgIIIAJBBEYNAyAAQQA2AgwgAkEFRg0DIABBADYCECACQQZGDQMgAEEANgIUIAJBB0YNAyAA +QQA2AhggAkEIRg0DIABBADYCHCACQQlGDQMgAEEANgIgIAJBCkYNAyAAQQA2AiQgAkELRg0DIABB +ADYCKCACQQxGDQMgAEEANgIsIAJBDUYNAyAAQQA2AjAgAkEORg0DIABBADYCNCACQQ9GDQMgAEEA +NgI4IAJBEEYNAyAAQQA2AjwgAkERRg0DIABBADYCQCACQRJGDQMgAEEANgJEIAJBE0YNAyAAQQA2 +AkggAkEURg0DIABBADYCTCACQRVGDQMgAEEANgJQIAJBFkYNAyAAQQA2AlQgAkEXRg0DIABBADYC +WCACQRhGDQMgAEEANgJcIAJBGUYNAyAAQQA2AmAgAkEaRg0DIABBADYCZCACQRtGDQMgAEEANgJo +IAJBHEYNAyAAQQA2AmwgAkEdRg0DIABBADYCcCACQR5GDQMgAEEANgJ0IAJBH0YNAyAAQQA2Angg +AkEgRg0DIABBADYCfCACQSFGDQMgAEEANgKAASACQSJGDQMgAEEANgKEASACQSNGDQMgAEEANgKI +ASACQSRGDQMgAEEANgKMASACQSVGDQMgAEEANgKQASACQSZGDQMgAEEANgKUASACQSdGDQMgAEEA +NgKYASACQShGDQMgAEEANgKcASACQSlGDQNBKEEoQez8wAAQgAEACyADQShB7PzAABCAAQALIARB +KEHs/MAAEIABAAtBlv3AAEEdQez8wAAQlgEACyAAKAKgASIDIAdqIQIgAUEfcSIGRQRAIAAgAjYC +oAEgAA8LAkAgAkEBayIEQSdNBEAgAiEFIAAgBEECdGooAgBBACABayIBdiIERQ0BIAJBJ00EQCAA +IAJBAnRqIAQ2AgAgAkEBaiEFDAILIAJBKEHs/MAAEIABAAsgBEEoQez8wAAQgAEACwJAIAdBAWoi +CCACTw0AIAFBH3EhASADQQFxRQRAIAAgAkEBayICQQJ0aiIEIAQoAgAgBnQgBEEEaygCACABdnI2 +AgALIANBAkYNACACQQJ0IABqQQxrIQMDQCADQQhqIgQgBCgCACAGdCADQQRqIgQoAgAiCSABdnI2 +AgAgBCAJIAZ0IAMoAgAgAXZyNgIAIANBCGshAyAIIAJBAmsiAkkNAAsLIAAgB0ECdGoiASABKAIA +IAZ0NgIAIAAgBTYCoAEgAAv/CQMMfwF+AW9BxITAACEDIwBB0ABrIgIkACACIAE2AgwCQAJAAkAC +QCABEPEBQQFGBEAgAiABNgIgIAJBADYCECACQcSEwAA2AhggAkHUhMAANgIcIAJBIGohCkGAgICA +eCEBA0AgAiADQQhqNgIYIAIgAygCACADKAIEED02AjggCigCACUBIAJBOGooAgAlARANIQ8QcCIF +IA8mAQJAAkACQAJAAkACQCAFJQEQBEEBRgRAIAIoAjglASACKAIgJQEQBUEBRw0BCwJAIAIoAhBF +DQAgAigCFCIHQYQBSQ0AIAcQbQsgAiAFNgIUIAJBATYCECADKAIAIQUCfwJAAkACQCADKAIEQQRr +DgMBAgACC0EAIQdBBiEIQbyEwAAhAwJAA0AgBS0AACILIAMtAAAiDEYEQCAFQQFqIQUgA0EBaiED +IAhBAWsiCA0BDAILCyALIAxrIQcLIAcNAUEBDAILQQAgBSgAAEG4hMAAKAAARg0BGgtBAgsgAigC +OCIFQYMBSwRAIAUQbQtBAWsOAgMBAgsgBUGEAU8EQCAFEG0LIAIoAjgiA0GEAU8EQCADEG0LIAIo +AhgiAyACKAIcRw0FDAcLIAIoAhAgAkEANgIQQQFGBEAgAigCFCIDQYQBSQ0EIAMQbQwECwwJCyAB +QYCAgIB4RwRAQaGKwABBBBCGASEEDAILIAIoAhAgAkEANgIQRQ0IIAIgAigCFCIDNgI4IAIgAxDt +AQJ/IAIoAgAiBgRAIAIoAgQiDQwBCyACQThqIAJBzwBqQcCJwAAQQiEGQYCAgIB4CyEBIANBhAFP +BEAgAxBtCyABQYCAgIB4Rw0CIABBgICAgHg2AgAgACAGNgIEDAYLIAlFBEAgAigCECACQQA2AhBB +AUcNCCACIAIoAhQ2AiQgAkEoaiIEIAJBJGoiAygCACUBEB4EfiAEIAMoAgAlARAK/AY3AwhCAQVC +AAs3AwACfwJAIAIoAihBAUYEQCACKQMwIg5CAFkNAQsgAkEkaiACQc8AakGgiMAAEEIhBEEBDAEL +IA5CgICAgBBaBEAgAkEBOgA4IAIgDjcDQCMAQTBrIgMkACADQaCIwAA2AgQgAyACQc8AajYCACAD +QQI2AgwgA0HMjsAANgIIIANCAjcCFCADIAOtQoCAgIDgAYQ3AyggAyACQThqrUKAgICA8AGENwMg +IAMgA0EgajYCECADQQhqEGMhBCADQTBqJABBAQwBCyAOpyEEQQALIAIoAiQiBUGEAU8EQCAFEG0L +QQEhCUUNAgwBC0GlisAAQQYQhgEhBAsgAEGAgICAeDYCACAAIAQ2AgQgAUGAgICAeHJBgICAgHhG +DQQgBiABEM8BDAQLIAIoAhgiAyACKAIcRw0ACwwBCyACQQxqIAJBzwBqQeCJwAAQQiEEIABBgICA +gHg2AgAgACAENgIEIAFBhAFJDQIgARBtDAILIAFBgICAgHhHBEAgCQRAIAAgBDYCDCAAIA02Aggg +ACAGNgIEIAAgATYCAAwCC0GlisAAQQYQhQEhBCAAQYCAgIB4NgIAIAAgBDYCBCABRQ0BIAYgARDP +AQwBC0GhisAAQQQQhQEhASAAQYCAgIB4NgIAIAAgATYCBAsgAigCICIAQYQBTwRAIAAQbQsgAigC +EEUNACACKAIUIgBBgwFNDQAgABBtCyACQdAAaiQADwtB8InAAEExEOUBAAuzCwMGfwF+AW8jAEHQ +AGsiAiQAIAIgATYCIAJAAkACQAJAAkAgAkEgaiIBKAIAJQEQHARAIAJBJGoiAyABKAIAJQEQEDYC +CCADQQA2AgQgAyABNgIAQQAhASACQQA2AjAgAigCJARAIAIoAiwiAyACKAIoIgRNBEBBBCEDDAML +QfmBwQAtAAAaQYCABCADIARrIgFBACABIANNGyIBIAFBgIAETxsiAUEEdCIEQQQQwwEiAw0CQQQg +BEGgicAAELUBAAsgAkEANgI8IAJCgICAgMAANwI0DAILIAJBQGshARAXIQkQcCIDIAkmASADIQUg +AkEgaigCACIEJQEgAyUBEBghCRBwIgMgCSYBQdCCwQAoAgAhBkHMgsEAKAIAIQdBzILBAEIANwIA +AkACQAJAIAdBAUYEQCABQQM6AAQgASAGNgIADAELAkAgAxDyAUEBRgRAIAMlASAEJQEQGSEJEHAi +BCAJJgFB0ILBACgCACEGQcyCwQAoAgAhB0HMgsEAQgA3AgACQCAHQQFGBEAgAUEDOgAEIAEgBjYC +AAwBCwJAIAQQ8QFBAUcNACAEJQEQEyEJEHAiBiAJJgEgBhDyASAGQYQBTwRAIAYQbQtBAUcNACAB +QQA6AAQgASAENgIAIANBhAFPBEAgAxBtCyAFQYQBSQ0GDAULIAFBAjoABCAEQYQBSQ0AIAQQbQsg +A0GEAU8NAQwCCyABQQI6AAQgA0GEAUkNAQsgAxBtCyAFQYMBTQ0BCyAFEG0LIAIoAkAhAQJAAkAC +QCACLQBEIgNBAmsOAgIAAQsgAEGAgICAeDYCACAAIAE2AgQgAigCICIBQYMBSw0FDAYLIAIgAzoA +OCACIAE2AjQgAkEANgIsIAJCgICAgMAANwIkIAJBGGogAkE0ahB7AkAgAigCGCIDQQJHBEAgAigC +HCEBA0ACQCADQQFxRQRAIAJBQGsgARAuIAIoAkQhASACKAJAIgVBgICAgHhHDQELIABBgICAgHg2 +AgAgACABNgIEIAIoAiwiAwRAIAIoAighAQNAIAEoAgAiAARAIAFBBGooAgAgABDPAQsgAUEQaiEB +IANBAWsiAw0ACwsgAigCJCIABEAgAigCKCAAQQR0EM8BCyACKAI0IgFBgwFLDQMMBwsgAikCSCEI +IAIoAiwiAyACKAIkRgRAIAJBJGoQaQsgAigCKCADQQR0aiIEIAg3AgggBCABNgIEIAQgBTYCACAC +IANBAWo2AiwgAkEQaiACQTRqEHsgAigCFCEBIAIoAhAiA0ECRw0ACwsgACACKQIkNwIAIABBCGog +AkEsaigCADYCACACKAI0IgFBgwFNDQQLIAEQbQwDCyACQSBqIAJBQGtB0InAABBCIQEgAEGAgICA +eDYCACAAIAE2AgQMAgsgAkEANgI8IAIgAzYCOCACIAE2AjQDQCACQQhqIQMgAkEkaiIBKAIEIgQg +ASgCCE8Ef0EABSABIARBAWo2AgQgASgCACgCACUBIAQQDyEJEHAiASAJJgFBAQshBCADIAE2AgQg +AyAENgIAIAIoAghBAXFFDQEgAigCDCEBIAIgAigCMEEBajYCMCACQUBrIAEQLiACKAJEIQEgAigC +QCIFQYCAgIB4RgRAIABBgICAgHg2AgAgACABNgIEIAIoAjwiAwRAIAIoAjghAQNAIAEoAgAiAARA +IAFBBGooAgAgABDPAQsgAUEQaiEBIANBAWsiAw0ACwsgAigCNCIARQ0DIAIoAjggAEEEdBDPAQwD +CyACKQJIIQggAigCPCIDIAIoAjRGBEAgAkE0ahBpCyACKAI4IANBBHRqIgQgCDcCCCAEIAE2AgQg +BCAFNgIAIAIgA0EBajYCPCACKAIkDQALCyAAIAIpAjQ3AgAgAEEIaiACQTxqKAIANgIACyACKAIg +IgFBgwFNDQELIAEQbQsgAkHQAGokAAvPBgEIfwJAAkAgASAAQQNqQXxxIgMgAGsiCEkNACABIAhr +IgZBBEkNACAGQQNxIQdBACEBAkAgACADRiIJDQACQCAAIANrIgVBfEsEQEEAIQMMAQtBACEDA0Ag +ASAAIANqIgIsAABBv39KaiACQQFqLAAAQb9/SmogAkECaiwAAEG/f0pqIAJBA2osAABBv39KaiEB +IANBBGoiAw0ACwsgCQ0AIAAgA2ohAgNAIAEgAiwAAEG/f0pqIQEgAkEBaiECIAVBAWoiBQ0ACwsg +ACAIaiEAAkAgB0UNACAAIAZBfHFqIgMsAABBv39KIQQgB0EBRg0AIAQgAywAAUG/f0pqIQQgB0EC +Rg0AIAQgAywAAkG/f0pqIQQLIAZBAnYhBSABIARqIQQDQCAAIQMgBUUNAkHAASAFIAVBwAFPGyIG +QQNxIQcgBkECdCEIQQAhAiAFQQRPBEAgACAIQfAHcWohCSAAIQEDQCABKAIAIgBBf3NBB3YgAEEG +dnJBgYKECHEgAmogAUEEaigCACIAQX9zQQd2IABBBnZyQYGChAhxaiABQQhqKAIAIgBBf3NBB3Yg +AEEGdnJBgYKECHFqIAFBDGooAgAiAEF/c0EHdiAAQQZ2ckGBgoQIcWohAiABQRBqIgEgCUcNAAsL +IAUgBmshBSADIAhqIQAgAkEIdkH/gfwHcSACQf+B/AdxakGBgARsQRB2IARqIQQgB0UNAAsCfyAD +IAZB/AFxQQJ0aiIAKAIAIgFBf3NBB3YgAUEGdnJBgYKECHEiASAHQQFGDQAaIAEgACgCBCIBQX9z +QQd2IAFBBnZyQYGChAhxaiIBIAdBAkYNABogACgCCCIAQX9zQQd2IABBBnZyQYGChAhxIAFqCyIB +QQh2Qf+BHHEgAUH/gfwHcWpBgYAEbEEQdiAEag8LIAFFBEBBAA8LIAFBA3EhAwJAIAFBBEkEQAwB +CyABQXxxIQUDQCAEIAAgAmoiASwAAEG/f0pqIAFBAWosAABBv39KaiABQQJqLAAAQb9/SmogAUED +aiwAAEG/f0pqIQQgBSACQQRqIgJHDQALCyADRQ0AIAAgAmohAQNAIAQgASwAAEG/f0pqIQQgAUEB +aiEBIANBAWsiAw0ACwsgBAuVCAILfwN+IwBB4ABrIgQkACACrUIofiIOpyEDAkAgDkIgiKcgA0H4 +////B0tyDQACfyADRQRAQQghBkEADAELQfmBwQAtAAAaQQghByADQQgQwwEiBkUNASACCyELIAME +QCAGIAEgA/wKAAALIAJBAk8EQCAGQdAAaiEMIARB3ABqrUKAgICAEIQhDiAEQdgAaq1CgICAgCCE +IQ8DQEEAIQNBACEFAkACQAJAAkACQAJAA0AgAyEKIAIgBUkNBSAFQShsIQkCQCACIAVrIgFBA0kN +AEEJIAEgAUEJTxshCCAJIAxqIQNBAiEBA0AgASAIRgRAIAghAQwCCyABQQFqIQEgA0IEELEBIANB +KGohA0IAUg0ACwsgASAFaiIIIAFJDQEgAiAISQ0CQbyCwQAhBUG4gsEAKAIARQRAAn9B+YHBAC0A +ABpBgAhBARDDASIDBEBByILBAEEANgIAQbyCwQBBADYCAEHEgsEAKAIAIQVBxILBACADNgIAQcCC +wQAoAgAhA0HAgsEAQYAINgIAQbiCwQAoAgBBuILBAEEBNgIARSADRXJFBEAgBSADEM8BC0G8gsEA +DAELQQFBgAhBiI7AABC1AQALIQULIAUoAgANA0EAIQMgBUEANgIMIAVBfzYCAEEAIQcgAQRAIAVB +BGohDSAGIAlqIgMgAUEobGohCQNAIAQgAzYCWCAEIANBIGoiATYCXCAEQQM2AjQgBEG4i8AANgIw +IARCAjcCPCAEIA43AxAgBCAPNwMIIAQgBEEIajYCOCANQaCPwAAgBEEwahA8DQYgASgCACAHaiEH +IAFBCGoiAyAJRw0ACyAFKAIMIQMLIARBMGpBnLrAACAFKAIIIAMQNCAEQdAAaiIBIAc2AgAgBSAF +KAIAQQFqNgIAIARBEGoiAyAEQThqKQMANwMAIARBGGoiBSAEQUBrKQMANwMAIARBIGoiByAEQcgA +aikDADcDACAEQShqIgkgASkDADcDACAEIAQpAzA3AwggAiAKSwRAIAYgCkEobGoiASAEKQMINwMA +IAFBIGogCSkDADcDACABQRhqIAcpAwA3AwAgAUEQaiAFKQMANwMAIAFBCGogAykDADcDACAKQQFq +IQMgCCIFIAJGDQcMAQsLIAogAkH8gMAAEIABAAsgBSAIQeyAwAAQ1QEACyAIIAJB7IDAABDUAQAL +QYSNwAAQjQEAC0Hgi8AAQSsgBEEwakHQi8AAQfSMwAAQfQALIAUgAkGMgcAAENMBAAsgAyECIAoN +AAsLIAAgBikDADcDACAAQRhqIAZBGGopAwA3AwAgAEEQaiAGQRBqKQMANwMAIABBCGogBkEIaikD +ADcDACAGIAtBKGwQzwEgBEHgAGokAA8LIAcgA0GghMAAELUBAAvJBwIKfwJ+IwBBMGsiBiQAAkAC +QAJAAkACQAJAAkAgA0UNAAJ/IAEoAhgiByABKAIoIgVBQGtNBEAgASgCHCAFayIHIAMgAyAHSxsh +CEEAIQcgAUEcagwBCyABKAIcIAVrIgkgAyADIAlLGyEIIAkgAyAHIAVrQcEAayIHIAMgB0kbIgdJ +DQIgBSAHaiEFIAFBHGoLIQkgBkEIaiEKIAIgB2ohDSAIIAdrIQsgASkDECEQQQAhCCABKQMAIQ8g +ASgCCCEOA0ACQCAIIAtGBEBBACEMDAELIAEgDiAIIA1qLQAAQQN0aikDACAPQgGGfCIPNwMAQQEh +DCAIQQFqIQggDyAQg0IAUg0BCwsgCiAINgIEIAogDDYCAAJAAkAgBigCCEEBcQRAIAkoAgAiCCAG +KAIMIgQgBWpNDQEMAgsgCSgCACIIIAUgC2pLDQILIAggBWshBAsgAUIANwMAIAQgB2ohBSABKAIo +IgdFBEAgAyAFSQ0DIAZBIGogAiAFEHgMBgsgAyAFSQ0DIAFBIGohAyABKAIgIAdrIAVJBEAgAyAH +IAUQWCABKAIoIQcLIAUEQCABKAIkIAdqIAIgBfwKAAALIAEgBSAHajYCKCAGQRhqIANBCGooAgA2 +AgAgAUEANgIoIAMpAgAhDyABQoCAgIAQNwMgIAYgDzcDECAGQSBqIAZBEGoQdQwFCyAERQRAIAEo +AiAgASgCKCIFayADSQRAIAFBIGogBSADEFggASgCKCEFCyADBEAgASgCJCAFaiACIAP8CgAACyAA +IAM2AjAgAEEANgIAIAEgAyAFajYCKAwGCyABKAIoIgVFDQMgAUEgaiEEIAEoAiAgBWsgA0kEQCAE +IAUgAxBYIAEoAighBQsgAwRAIAEoAiQgBWogAiAD/AoAAAsgASADIAVqNgIoIAZBGGogBEEIaigC +ADYCACABQQA2AiggBCkCACEPIAFCgICAgBA3AyAgBiAPNwMQIAZBIGogBkEQahB1IAMhBQwECyAH +IAhBsJbAABDVAQALIAUgA0HAlsAAENQBAAsgBSADQdCWwAAQ1AEACyAGQSBqIAIgAxB4IAMhBQsg +BkEYaiAGQShqKQIAIg83AwAgBiAGKQIgNwMQIA+nIgFFBEAgAEEANgIwIABBADYCACAGQRxqIAYo +AhRBACAGKAIQKAIQEQMADAELIAYoAhAhAiAGKAIcIQMgAEEQakH8ucAAIAYoAhQiBCABEDQgACAF +NgIwIAAgAzYCDCAAIAE2AgggACAENgIEIAAgAjYCAAsgBkEwaiQAC9wFAgx/A34jAEGgAWsiCSQA +IAlBAEGgAfwLAAJAAkACQCACIAAoAqABIgVNBEAgBUEpTw0BIAEgAkECdGohDAJAAkAgBQRAIAVB +AWohDSAFQQJ0IQoDQCAJIAZBAnRqIQMDQCAGIQIgAyEEIAEgDEYNCCADQQRqIQMgAkEBaiEGIAEo +AgAhByABQQRqIgshASAHRQ0ACyAHrSERQgAhDyAKIQcgAiEBIAAhAwNAIAFBKE8NBCAEIA8gBDUC +AHwgAzUCACARfnwiED4CACAQQiCIIQ8gBEEEaiEEIAFBAWohASADQQRqIQMgB0EEayIHDQALIAgg +EEKAgICAEFoEfyACIAVqIgFBKE8NAyAJIAFBAnRqIA8+AgAgDQUgBQsgAmoiASABIAhJGyEIIAsh +AQwACwALA0AgASAMRg0GIARBAWohBCABKAIAIAFBBGohAUUNACAIIARBAWsiAiACIAhJGyEIDAAL +AAsgAUEoQez8wAAQgAEACyABQShB7PzAABCAAQALIAVBKU8NASACQQJ0IQwgAkEBaiENIAAgBUEC +dGohDiAAIQMCQANAIAkgB0ECdGohBgNAIAchCyAGIQQgAyAORg0FIARBBGohBiAHQQFqIQcgAygC +ACEKIANBBGoiBSEDIApFDQALIAqtIRFCACEPIAwhCiALIQMgASEGA0AgA0EoTw0CIAQgDyAENQIA +fCAGNQIAIBF+fCIQPgIAIBBCIIghDyAEQQRqIQQgA0EBaiEDIAZBBGohBiAKQQRrIgoNAAsCQCAI +IBBCgICAgBBaBH8gAiALaiIDQShPDQEgCSADQQJ0aiAPPgIAIA0FIAILIAtqIgMgAyAISRshCCAF +IQMMAQsLIANBKEHs/MAAEIABAAsgA0EoQez8wAAQgAEACyAFQShB7PzAABDUAQALIAVBKEHs/MAA +ENQBAAsgACAJQaAB/AoAACAAIAg2AqABIAlBoAFqJAAL5AgCCn8BfiMAQYACayIEJAAgBCABKQAY +NwIYIAQgASkAEDcCECAEIAEpAAg3AgggBCABKQAANwIAAn8gA0GBCE8EQCAEQSBqIQUjAEHgAGsi +ASQAIAFBOGoiBkIANwMAIAFBMGoiB0IANwMAIAFBKGoiCEIANwMAIAFBIGoiCUIANwMAIAFBGGoi +CkIANwMAIAFBEGoiC0IANwMAIAFBCGoiDEIANwMAIAFCADcDACACIAMgBEIAQRAgAUHAABAqIQMg +AUHYAGpCADcDACABQdAAakIANwMAIAFByABqQgA3AwAgAUIANwNAAkACQAJAAkAgA0EDTwRAA0Ag +A0EFdCICQcEATw0CIAEgAiAEQRAgAUFAayINQSAQQSIDQQV0IgJBwQBPDQMgAkEhTw0EIAIEQCAB +IA0gAvwKAAALIANBAksNAAsLIAUgASkDADcAACAFQThqIAYpAwA3AAAgBUEwaiAHKQMANwAAIAVB +KGogCCkDADcAACAFQSBqIAkpAwA3AAAgBUEYaiAKKQMANwAAIAVBEGogCykDADcAACAFQQhqIAwp +AwA3AAAgAUHgAGokAAwDCyACQcAAQci8wAAQ1AEACyACQcAAQdi8wAAQ1AEACyACQSBB6LzAABDU +AQALIARB+ABqIARBGGopAgA3AwAgBEHwAGogBEEQaikCADcDACAEQegAaiAEQQhqKQIANwMAIAQg +BCkCADcDYEHAACEDQRQMAQsgBEHIAWpCADcDACAEQcABakIANwMAIARBuAFqQgA3AwAgBEGwAWpC +ADcDACAEQagBakIANwMAIARBmAFqQgA3AwAgBEEQOgD6ASAEQaABakIANwMAIARB2AFqIgUgBEEI +aikCADcDACAEQegBaiIGIARBGGopAgA3AwAgBEHgAWoiByAEQRBqKQIANwMAIARCADcDkAEgBCAE +KQIANwPQASAEQQA7AfgBIARCADcD8AEgBEGQAWogAiADEEYhASAEQegAaiAFKQMANwMAIARB8ABq +IAcpAwA3AwAgBEH4AGogBikDADcDACAEQShqIAFBCGopAwA3AwAgBEEwaiABQRBqKQMANwMAIARB +OGogAUEYaikDADcDACAEQUBrIAFBIGopAwA3AwAgBEHIAGogAUEoaikDADcDACAEQdAAaiABQTBq +KQMANwMAIARB2ABqIAFBOGopAwA3AwAgBCAEKQPQATcDYCAEIAEpAwA3AyAgBCkD8AEhDiAELQD4 +ASEDIAQtAPoBIAQtAPkBRXJBAnILIQEgBCAONwOAASAEIAM6AIgBIAQgAToAiQEgBEGoAWoiAiAE +QfgAaikDADcDACAEQaABaiIFIARB8ABqKQMANwMAIARBmAFqIgYgBEHoAGopAwA3AwAgBCAEKQNg +NwOQASAEQZABaiAEQSBqIANCACABQQhyECggACACKQMANwAYIAAgBSkDADcAECAAIAYpAwA3AAgg +ACAEKQOQATcAACAEQYACaiQAC8ALAQV/IwBBIGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJA +IAEOKAYBAQEBAQEBAQIEAQEDAQEBAQEBAQEBAQEBAQEBAQEBAQEIAQEBAQcACyABQdwARg0ECyAC +QQFxRSABQf8FTXINBwJ/AkBBEUEAIAFBr7AETxsiAiACQQhyIgMgAUELdCICIANBAnRBuIDBAGoo +AgBBC3RJGyIDIANBBHIiAyADQQJ0QbiAwQBqKAIAQQt0IAJLGyIDIANBAnIiAyADQQJ0QbiAwQBq +KAIAQQt0IAJLGyIDIANBAWoiAyADQQJ0QbiAwQBqKAIAQQt0IAJLGyIDIANBAWoiAyADQQJ0QbiA +wQBqKAIAQQt0IAJLGyIDQQJ0QbiAwQBqKAIAQQt0IgUgAkYgAiAFS2ogA2oiA0EhTQRAIANBAnRB +uIDBAGoiBigCAEEVdiECQe8FIQUCfwJAIANBIUYNACAGKAIEQRV2IQUgAw0AQQAMAQsgBkEEaygC +AEH///8AcQshAwJAIAUgAkF/c2pFDQAgASADayEHQe8FIAIgAkHvBU0bIQYgBUEBayEDQQAhBQNA +IAIgBkYNAyAFIAJB9MvAAGotAABqIgUgB0sNASADIAJBAWoiAkcNAAsgAyECCyACQQFxDAILIANB +IkGs/MAAEIABAAsgBkHvBUG8/MAAEIABAAtFDQcgBEEAOgAKIARBADsBCCAEIAFBFHZBt+jAAGot +AAA6AAsgBCABQQR2QQ9xQbfowABqLQAAOgAPIAQgAUEIdkEPcUG36MAAai0AADoADiAEIAFBDHZB +D3FBt+jAAGotAAA6AA0gBCABQRB2QQ9xQbfowABqLQAAOgAMIAFBAXJnQQJ2IgIgBEEIaiIDaiIF +QfsAOgAAIAVBAWtB9QA6AAAgAyACQQJrIgJqQdwAOgAAIARBEGoiAyABQQ9xQbfowABqLQAAOgAA +IABBCjoACyAAIAI6AAogACAEKQIINwIAIARB/QA6ABEgAEEIaiADLwEAOwEADAkLIABBgAQ7AQog +AEIANwECIABB3OgBOwEADAgLIABBgAQ7AQogAEIANwECIABB3OQBOwEADAcLIABBgAQ7AQogAEIA +NwECIABB3NwBOwEADAYLIABBgAQ7AQogAEIANwECIABB3LgBOwEADAULIABBgAQ7AQogAEIANwEC +IABB3OAAOwEADAQLIAJBgAJxRQ0BIABBgAQ7AQogAEIANwECIABB3M4AOwEADAMLIAJB////B3FB +gIAETw0BCwJ/QQAgAUEgSQ0AGkEBIAFB/wBJDQAaIAFBgIAETwRAIAFB4P//AHFB4M0KRyABQf7/ +/wBxQZ7wCkdxIAFBwO4Ka0F6SXEgAUGwnQtrQXJJcSABQfDXC2tBcUlxIAFBgPALa0HebElxIAFB +gIAMa0GedElxIAFB0KYMa0F7SXEgAUGAgjhrQbDFVElxIAFB8IM4SXEgAUGAgAhPDQEaIAFB2PDA +AEEsQbDxwABB0AFBgPPAAEHmAxBSDAELIAFB5vbAAEEoQbb3wABBogJB2PnAAEGpAhBSC0UEQCAE +QQA6ABYgBEEAOwEUIAQgAUEUdkG36MAAai0AADoAFyAEIAFBBHZBD3FBt+jAAGotAAA6ABsgBCAB +QQh2QQ9xQbfowABqLQAAOgAaIAQgAUEMdkEPcUG36MAAai0AADoAGSAEIAFBEHZBD3FBt+jAAGot +AAA6ABggAUEBcmdBAnYiAiAEQRRqIgNqIgVB+wA6AAAgBUEBa0H1ADoAACADIAJBAmsiAmpB3AA6 +AAAgBEEcaiIDIAFBD3FBt+jAAGotAAA6AAAgAEEKOgALIAAgAjoACiAAIAQpAhQ3AgAgBEH9ADoA +HSAAQQhqIAMvAQA7AQAMAgsgACABNgIEIABBgAE6AAAMAQsgAEGABDsBCiAAQgA3AQIgAEHcxAA7 +AQALIARBIGokAAvTBQIHfwF+An8gAUUEQCAAKAIIIQdBLSELIAVBAWoMAQtBK0GAgMQAIAAoAggi +B0GAgIABcSIBGyELIAFBFXYgBWoLIQgCQCAHQYCAgARxRQRAQQAhAgwBCyADQRBPBEAgAiADEDAg +CGohCAwBCyADRQ0AIANBA3EhCgJAIANBBEkEQEEAIQEMAQsgA0EMcSEMQQAhAQNAIAEgAiAJaiIG +LAAAQb9/SmogBkEBaiwAAEG/f0pqIAZBAmosAABBv39KaiAGQQNqLAAAQb9/SmohASAMIAlBBGoi +CUcNAAsLIAoEQCACIAlqIQYDQCABIAYsAABBv39KaiEBIAZBAWohBiAKQQFrIgoNAAsLIAEgCGoh +CAsCQCAALwEMIgkgCEsEQAJAAkAgB0GAgIAIcUUEQCAJIAhrIQlBACEBQQAhCAJAAkACQCAHQR12 +QQNxQQFrDgMAAQACCyAJIQgMAQsgCUH+/wNxQQF2IQgLIAdB////AHEhCiAAKAIEIQcgACgCACEA +A0AgAUH//wNxIAhB//8DcU8NAkEBIQYgAUEBaiEBIAAgCiAHKAIQEQAARQ0ACwwECyAAIAApAggi +DadBgICA/3lxQbCAgIACcjYCCEEBIQYgACgCACIHIAAoAgQiCiALIAIgAxCaAQ0DQQAhASAJIAhr +Qf//A3EhAgNAIAFB//8DcSACTw0CIAFBAWohASAHQTAgCigCEBEAAEUNAAsMAwtBASEGIAAgByAL +IAIgAxCaAQ0CIAAgBCAFIAcoAgwRAQANAkEAIQEgCSAIa0H//wNxIQIDQCABQf//A3EiAyACSSEG +IAIgA00NAyABQQFqIQEgACAKIAcoAhARAABFDQALDAILIAcgBCAFIAooAgwRAQANASAAIA03AghB +AA8LQQEhBiAAKAIAIgEgACgCBCIAIAsgAiADEJoBDQAgASAEIAUgACgCDBEBACEGCyAGC4oFAgZ/ +BX5CASENAkACQAJAAkAgAkHAAEcNAEEAIQIDQCACQcAARwRAIAEgAmoiAy0AACIEQTBrQf8BcUEK +TwRAIARBX3FBwQBrQf8BcUEFSw0DCyACQQJqIQIgA0EBai0AACIDQTBrQf8BcUEKSSADQV9xQcEA +a0H/AXFBBklyDQEMAgsLIAEsABAiBUFASA0BIAFBEGohBkEPQRAgAS0AAEErRiICGyEDIAEgAmoh +AgNAIAItAAAiBEHBAGtBX3FBCmogBEEwayAEQTlLGyIEQQ9LDQEgAkEBaiECIAStIAlCBIaEIQkg +A0EBayIDDQALIAEsACAiB0FASA0CIAFBIGohCCABQRFqIAYgBUErRiIDGyECQQ9BECADGyEDA0Ag +Ai0AACIEQcEAa0FfcUEKaiAEQTBrIARBOUsbIgRBD0sNASACQQFqIQIgBK0gCkIEhoQhCiADQQFr +IgMNAAsgASwAMCIFQUBIDQMgAUEwaiEGIAFBIWogCCAHQStGIgMbIQJBD0EQIAMbIQMDQCACLQAA +IgRBwQBrQV9xQQpqIARBMGsgBEE5SxsiBEEPSw0BIAJBAWohAiAErSALQgSGhCELIANBAWsiAw0A +CyABQTFqIAYgBUErRiIBGyECQQ9BECABGyEDA0AgAi0AACIBQcEAa0FfcUEKaiABQTBrIAFBOUsb +IgFBD0sNASACQQFqIQIgAa0gDEIEhoQhDCADQQFrIgMNAAsgACAMNwMgIAAgCzcDGCAAIAo3AxAg +ACAJNwMIQgAhDQsgACANNwMADwsgAUHAAEEAQRBBzLnAABDBAQALIAFBwABBEEEgQdy5wAAQwQEA +CyABQcAAQSBBMEHsucAAEMEBAAuEBgIBfwF8IwBBMGsiAiQAAn8CQAJAAkACQAJAAkACQAJAAkAC +QAJAAkACQAJAAkACQAJAAkAgAC0AAEEBaw4RAQIDBAUGBwgJCgsMDQ4PEBEACyACIAAtAAE6AAgg +AkECNgIUIAJBoL7AADYCECACQgE3AhwgAiACQQhqrUKAgICAwAeENwMoIAIgAkEoajYCGCABKAIA +IAEoAgQgAkEQahA8DBELIAIgACkDCDcDCCACQQI2AhQgAkG8vsAANgIQIAJCATcCHCACIAJBCGqt +QoCAgIDQB4Q3AyggAiACQShqNgIYIAEoAgAgASgCBCACQRBqEDwMEAsgAiAAKQMINwMIIAJBAjYC +FCACQby+wAA2AhAgAkIBNwIcIAIgAkEIaq1CgICAgOAHhDcDKCACIAJBKGo2AhggASgCACABKAIE +IAJBEGoQPAwPCyAAKwMIIQMgAkECNgIUIAJB3L7AADYCECACQgE3AhwgAiACQShqrUKAgICA8AeE +NwMIIAIgAzkDKCACIAJBCGo2AhggASgCACABKAIEIAJBEGoQPAwOCyACIAAoAgQ2AgggAkECNgIU +IAJB+L7AADYCECACQgE3AhwgAiACQQhqrUKAgICAgAiENwMoIAIgAkEoajYCGCABKAIAIAEoAgQg +AkEQahA8DA0LIAIgACkCBDcCCCACQQE2AhQgAkGQv8AANgIQIAJCATcCHCACIAJBCGqtQoCAgICQ +CIQ3AyggAiACQShqNgIYIAEoAgAgASgCBCACQRBqEDwMDAsgAUGMvsAAQQoQvwEMCwsgAUGYv8AA +QQoQvwEMCgsgAUGiv8AAQQwQvwEMCQsgAUGuv8AAQQ4QvwEMCAsgAUG8v8AAQQgQvwEMBwsgAUHE +v8AAQQMQvwEMBgsgAUHHv8AAQQQQvwEMBQsgAUHLv8AAQQwQvwEMBAsgAUHXv8AAQQ8QvwEMAwsg +AUHmv8AAQQ0QvwEMAgsgAUHzv8AAQQ4QvwEMAQsgASAAKAIEIAAoAggQvwELIAJBMGokAAv+BQEF +fyAAQQhrIgEgAEEEaygCACIDQXhxIgBqIQICQAJAIANBAXENACADQQJxRQ0BIAEoAgAiAyAAaiEA +IAEgA2siAUGQhsEAKAIARgRAIAIoAgRBA3FBA0cNAUGIhsEAIAA2AgAgAiACKAIEQX5xNgIEIAEg +AEEBcjYCBCACIAA2AgAPCyABIAMQTQsCQAJAAkACQAJAIAIoAgQiA0ECcUUEQCACQZSGwQAoAgBG +DQIgAkGQhsEAKAIARg0DIAIgA0F4cSICEE0gASAAIAJqIgBBAXI2AgQgACABaiAANgIAIAFBkIbB +ACgCAEcNAUGIhsEAIAA2AgAPCyACIANBfnE2AgQgASAAQQFyNgIEIAAgAWogADYCAAsgAEGAAkkN +AiABIAAQVUEAIQFBqIbBAEGohsEAKAIAQQFrIgA2AgAgAA0EQfCDwQAoAgAiAARAA0AgAUEBaiEB +IAAoAggiAA0ACwtBqIbBAEH/HyABIAFB/x9NGzYCAA8LQZSGwQAgATYCAEGMhsEAQYyGwQAoAgAg +AGoiADYCACABIABBAXI2AgRBkIbBACgCACABRgRAQYiGwQBBADYCAEGQhsEAQQA2AgALIABBoIbB +ACgCACIDTQ0DQZSGwQAoAgAiAkUNA0EAIQBBjIbBACgCACIEQSlJDQJB6IPBACEBA0AgAiABKAIA +IgVPBEAgAiAFIAEoAgRqSQ0ECyABKAIIIQEMAAsAC0GQhsEAIAE2AgBBiIbBAEGIhsEAKAIAIABq +IgA2AgAgASAAQQFyNgIEIAAgAWogADYCAA8LIABB+AFxQfiDwQBqIQICf0GAhsEAKAIAIgNBASAA +QQN2dCIAcUUEQEGAhsEAIAAgA3I2AgAgAgwBCyACKAIICyEAIAIgATYCCCAAIAE2AgwgASACNgIM +IAEgADYCCA8LQfCDwQAoAgAiAQRAA0AgAEEBaiEAIAEoAggiAQ0ACwtBqIbBAEH/HyAAIABB/x9N +GzYCACADIARPDQBBoIbBAEF/NgIACwvhBAEGfwJAAkAgACgCCCIHQYCAgMABcUUNAAJAAkAgB0GA +gICAAXFFBEAgAkEQSQ0BIAEgAhAwIQMMAgsCQAJAIAAvAQ4iA0UEQEEAIQIMAQsgASACaiEIQQAh +AiADIQUgASEEA0AgBCIGIAhGDQICfyAGQQFqIAYsAAAiBEEATg0AGiAGQQJqIARBYEkNABogBkED +aiAEQXBJDQAaIAZBBGoLIgQgBmsgAmohAiAFQQFrIgUNAAsLQQAhBQsgAyAFayEDDAELIAJFBEBB +ACECDAELIAJBA3EhBgJAIAJBBEkEQAwBCyACQQxxIQgDQCADIAEgBWoiBCwAAEG/f0pqIARBAWos +AABBv39KaiAEQQJqLAAAQb9/SmogBEEDaiwAAEG/f0pqIQMgCCAFQQRqIgVHDQALCyAGRQ0AIAEg +BWohBANAIAMgBCwAAEG/f0pqIQMgBEEBaiEEIAZBAWsiBg0ACwsgAyAALwEMIgRPDQAgBCADayEG +QQAhA0EAIQUCQAJAAkAgB0EddkEDcUEBaw4CAAECCyAGIQUMAQsgBkH+/wNxQQF2IQULIAdB//// +AHEhCCAAKAIEIQcgACgCACEAA0AgA0H//wNxIAVB//8DcUkEQEEBIQQgA0EBaiEDIAAgCCAHKAIQ +EQAARQ0BDAMLC0EBIQQgACABIAIgBygCDBEBAA0BQQAhAyAGIAVrQf//A3EhAQNAIANB//8DcSIC +IAFJIQQgASACTQ0CIANBAWohAyAAIAggBygCEBEAAEUNAAsMAQsgACgCACABIAIgACgCBCgCDBEB +ACEECyAEC54EAQR/IwBBgAFrIgQkAAJAAkACQCABKAIIIgJBgICAEHFFBEAgAkGAgIAgcQ0BQQEh +AiAAKAIAIAEQTEUNAgwDCyAAKAIAIQIDQCADIARqQf8AaiACQQ9xIgVBMHIgBUHXAGogBUEKSRs6 +AAAgA0EBayEDIAJBEEkgAkEEdiECRQ0AC0EBIQIgAUEBQbbrwABBAiADIARqQYABakEAIANrEDZF +DQEMAgsgACgCACECA0AgAyAEakH/AGogAkEPcSIFQTByIAVBN2ogBUEKSRs6AAAgA0EBayEDIAJB +D0sgAkEEdiECDQALQQEhAiABQQFBtuvAAEECIAMgBGpBgAFqQQAgA2sQNg0BCyABKAIAQbXowABB +AiABKAIEKAIMEQEADQACQCABKAIIIgJBgICAEHFFBEAgAkGAgIAgcQ0BIAAoAgQgARBMIQIMAgsg +ACgCBCECQQAhAwNAIAMgBGpB/wBqIAJBD3EiAEEwciAAQdcAaiAAQQpJGzoAACADQQFrIQMgAkEP +SyACQQR2IQINAAsgAUEBQbbrwABBAiADIARqQYABakEAIANrEDYhAgwBCyAAKAIEIQJBACEDA0Ag +AyAEakH/AGogAkEPcSIAQTByIABBN2ogAEEKSRs6AAAgA0EBayEDIAJBD0sgAkEEdiECDQALIAFB +AUG268AAQQIgAyAEakGAAWpBACADaxA2IQILIARBgAFqJAAgAgu9BAEIfyMAQRBrIgMkACADIAE2 +AgQgAyAANgIAIANCoICAgA43AggCfwJAAkACQCACKAIQIgkEQCACKAIUIgANAQwCCyACKAIMIgBF +DQEgAigCCCIBIABBA3RqIQQgAEEBa0H/////AXFBAWohBiACKAIAIQADQAJAIABBBGooAgAiBUUN +ACADKAIAIAAoAgAgBSADKAIEKAIMEQEARQ0AQQEMBQtBASABKAIAIAMgAUEEaigCABEAAA0EGiAA +QQhqIQAgBCABQQhqIgFHDQALDAILIABBGGwhCiAAQQFrQf////8BcUEBaiEGIAIoAgghBCACKAIA +IQADQAJAIABBBGooAgAiAUUNACADKAIAIAAoAgAgASADKAIEKAIMEQEARQ0AQQEMBAtBACEHQQAh +CAJAAkACQCAFIAlqIgFBCGovAQBBAWsOAgECAAsgAUEKai8BACEIDAELIAQgAUEMaigCAEEDdGov +AQQhCAsCQAJAAkAgAS8BAEEBaw4CAQIACyABQQJqLwEAIQcMAQsgBCABQQRqKAIAQQN0ai8BBCEH +CyADIAc7AQ4gAyAIOwEMIAMgAUEUaigCADYCCEEBIAQgAUEQaigCAEEDdGoiASgCACADIAFBBGoo +AgARAAANAxogAEEIaiEAIAVBGGoiBSAKRw0ACwwBCwsCQCAGIAIoAgRPDQAgAygCACACKAIAIAZB +A3RqIgAoAgAgACgCBCADKAIEKAIMEQEARQ0AQQEMAQtBAAsgA0EQaiQAC68VAhZ/A34jAEEQayIV +JABB/IHBACgCAEUEQEH8gcEAKAIAIQRB/IHBAEIBNwIAQYiCwQAoAgAhCkGEgsEAKAIAIQJBhILB +AEGQlMAAKQIANwIAQZCCwQAoAgAhBUGMgsEAQZiUwAApAgA3AgACQCAERSAKRXINACAFBEAgAkEI +aiEIIAIpAwBCf4VCgIGChIiQoMCAf4MhGCACIQQDQCAYUARAA0AgBEHgAGshBCAIKQMAIAhBCGoh +CEKAgYKEiJCgwIB/gyIYQoCBgoSIkKDAgH9RDQALIBhCgIGChIiQoMCAf4UhGAsgBCAYeqdBA3ZB +dGxqQQRrKAIAIgNBhAFPBEAgAxBtCyAYQgF9IBiDIRggBUEBayIFDQALCyAKIApBDGxBE2pBeHEi +A2pBCWoiBEUNACACIANrIAQQzwELCwJAAkBBgILBACgCAEUEQEGAgsEAQX82AgBBiILBACgCACID +IABxIQUgAEEZdiIWrUKBgoSIkKDAgAF+IRlBhILBACgCACECA0AgAiAFaikAACIaIBmFIhhCf4Ug +GEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIYUEUEQANAIAAgAiAYeqdBA3YgBWogA3FBdGxqIgRB +DGsoAgBGBEAgBEEIaygCACABRg0GCyAYQgF9IBiDIhhQRQ0ACwsgGiAaQgGGg0KAgYKEiJCgwIB/ +g1BFDQIgBSAHQQhqIgdqIANxIQUMAAsAC0H4k8AAEI0BAAtBjILBACgCAEUEQCAVQQhqIRcjAEEg +ayIPJAACQAJAQZCCwQAoAgAiCEEBaiIEIAhPBEACQEGIgsEAKAIAIgsgC0EBaiINQQN2IgJBB2wg +C0EISRsiEkEBdiAESQRAIBJBAWoiAiAEIAIgBEsbIgJBCEkNASACQf////8BTQRAQX8gAkEDdEEH +bkEBa2d2QQFqIQQMBAsQjwEgDygCHCEEIA8oAhghAgwEC0EAIQRBhILBACgCACEJAkAgAiANQQdx +QQBHaiIDRQ0AIANBAUcEQCADQf7///8DcSECA0AgBCAJaiIHIAcpAwAiGEJ/hUIHiEKBgoSIkKDA +gAGDIBhC//79+/fv37//AIR8NwMAIAdBCGoiByAHKQMAIhhCf4VCB4hCgYKEiJCgwIABgyAYQv/+ +/fv379+//wCEfDcDACAEQRBqIQQgAkECayICDQALCyADQQFxRQ0AIAQgCWoiBCAEKQMAIhhCf4VC +B4hCgYKEiJCgwIABgyAYQv/+/fv379+//wCEfDcDAAsCQAJAIA1BCE8EQCAJIA1qIAkpAAA3AAAM +AQsgDQRAIAlBCGogCSAN/AoAAAsgDUUNAQsgCUEIaiEQIAlBDGshE0EBIQJBACEEA0AgBCEHIAIh +BAJAIAcgCWoiFC0AAEGAAUcNACATIAdBdGxqIQYCQANAIAYoAgAiAiAGKAIEIAIbIgogC3EiBSEC +IAUgCWopAABCgIGChIiQoMCAf4MiGVAEQEEIIQMDQCACIANqIQIgA0EIaiEDIAkgAiALcSICaikA +AEKAgYKEiJCgwIB/gyIZUA0ACwsgCSAZeqdBA3YgAmogC3EiAmosAABBAE4EQCAJKQMAQoCBgoSI +kKDAgH+DeqdBA3YhAgsgAiAFayAHIAVrcyALcUEISQ0BIAIgCWoiAy0AACADIApBGXYiAzoAACAQ +IAJBCGsgC3FqIAM6AAAgEyACQXRsaiEDQf8BRwRAIAYtAAAhAiAGIAMtAAA6AAAgAyACOgAAIAYt +AAEhAiAGIAMtAAE6AAEgAyACOgABIAYtAAIhAiAGIAMtAAI6AAIgAyACOgACIAYtAAMhAiAGIAMt +AAM6AAMgAyACOgADIAYtAAQhAiAGIAMtAAQ6AAQgAyACOgAEIAYtAAUhAiAGIAMtAAU6AAUgAyAC +OgAFIAYtAAYhAiAGIAMtAAY6AAYgAyACOgAGIAYtAAchAiAGIAMtAAc6AAcgAyACOgAHIAYtAAgh +AiAGIAMtAAg6AAggAyACOgAIIAYtAAkhAiAGIAMtAAk6AAkgAyACOgAJIAYtAAohAiAGIAMtAAo6 +AAogAyACOgAKIAYtAAshAiAGIAMtAAs6AAsgAyACOgALDAELCyAUQf8BOgAAIBAgB0EIayALcWpB +/wE6AAAgA0EIaiAGQQhqKAAANgAAIAMgBikAADcAAAwBCyAUIApBGXYiAjoAACAQIAdBCGsgC3Fq +IAI6AAALIAQgBCANSSIHaiECIAcNAAsLQYyCwQAgEiAIazYCAEGBgICAeCECDAMLQQRBCCACQQRJ +GyEEDAELEI8BIA8oAgQhBCAPKAIAIQIMAQsCQAJAIAStQgx+IhhCIIinDQAgGKciAkF4Sw0AIAJB +B2pBeHEiAyAEQQhqIgdqIgUgA0kgBUH4////B0tyDQBB+YHBAC0AABogBUEIEMMBIgINAUEIIAUQ +6gEACxCPASAPKAIMIQQgDygCCCECDAELIAIgA2ohDCAHBEAgDEH/ASAH/AsACyAEQQFrIhEgBEED +dkEHbCAEQQlJGyEQQYSCwQAoAgAhAyAIBEAgDEEMayESIAxBCGohEyADQQxrIQkgAykDAEJ/hUKA +gYKEiJCgwIB/gyEZIAMhAkEAIQQgCCEHA0AgGVAEQANAIARBCGohBCACQQhqIgIpAwBCgIGChIiQ +oMCAf4MiGEKAgYKEiJCgwIB/UQ0ACyAYQoCBgoSIkKDAgH+FIRkLIAwgCSAZeqdBA3YgBGoiFEF0 +bGoiCigCACIFIAooAgQgBRsiCiARcSIOaikAAEKAgYKEiJCgwIB/gyIYUARAQQghBgNAIAYgDmoh +BSAGQQhqIQYgDCAFIBFxIg5qKQAAQoCBgoSIkKDAgH+DIhhQDQALCyAZQgF9IBmDIRkgDCAYeqdB +A3YgDmogEXEiDmosAABBAE4EQCAMKQMAQoCBgoSIkKDAgH+DeqdBA3YhDgsgDCAOaiAKQRl2IgU6 +AAAgEyAOQQhrIBFxaiAFOgAAIBIgDkF0bGoiCkEIaiAJIBRBdGxqIgVBCGooAAA2AAAgCiAFKQAA +NwAAIAdBAWsiBw0ACwtBiILBACARNgIAQYSCwQAgDDYCAEGMgsEAIBAgCGs2AgBBgYCAgHghAiAL +RQ0AIAsgDUEMbEEHakF4cSIEakEJaiIHRQ0AIAMgBGsgBxDPAQsgFyACNgIAIBcgBDYCBCAPQSBq +JAALIAAgARC4ASEHQYSCwQAoAgAiCEGIgsEAKAIAIgQgAHEiBWopAABCgIGChIiQoMCAf4MiGFAE +QEEIIQMDQCADIAVqIQIgA0EIaiEDIAggAiAEcSIFaikAAEKAgYKEiJCgwIB/gyIYUA0ACwsgCCAY +eqdBA3YgBWogBHEiBWosAAAiA0EATgRAIAggCCkDAEKAgYKEiJCgwIB/g3qnQQN2IgVqLQAAIQML +IAUgCGogFjoAACAIIAVBCGsgBHFqQQhqIBY6AABBjILBAEGMgsEAKAIAIANBAXFrNgIAQZCCwQBB +kILBACgCAEEBajYCACAIIAVBdGxqIgRBBGsgBzYCACAEQQhrIAE2AgAgBEEMayAANgIACyAEQQRr +KAIAIQEQcCIAIAElASYBQYCCwQBBgILBACgCAEEBajYCACAVQRBqJAAgAAuVBAEMfyABQQFrIQ4g +ACgCBCEKIAAoAgAhCyAAKAIIIQwCQANAIAUNAQJ/AkAgAiADSQ0AA0AgASADaiEFAkACQAJAIAIg +A2siB0EHTQRAIAIgA0cNASACIQMMBQsCQCAFQQNqQXxxIgYgBWsiBARAQQAhAANAIAAgBWotAABB +CkYNBSAEIABBAWoiAEcNAAsgBCAHQQhrIgBNDQEMAwsgB0EIayEACwNAQYCChAggBigCACIJQYqU +qNAAc2sgCXJBgIKECCAGQQRqKAIAIglBipSo0ABzayAJcnFBgIGChHhxQYCBgoR4Rw0CIAZBCGoh +BiAEQQhqIgQgAE0NAAsMAQtBACEAA0AgACAFai0AAEEKRg0CIAcgAEEBaiIARw0ACyACIQMMAwsg +BCAHRgRAIAIhAwwDCwNAIAQgBWotAABBCkYEQCAEIQAMAgsgByAEQQFqIgRHDQALIAIhAwwCCyAA +IANqIgZBAWohAwJAIAIgBk0NACAAIAVqLQAAQQpHDQBBACEFIAMhBiADDAMLIAIgA08NAAsLIAIg +CEYNAkEBIQUgCCEGIAILIQACQCAMLQAABEAgC0Gs68AAQQQgCigCDBEBAA0BC0EAIQQgACAIRwRA +IAAgDmotAABBCkYhBAsgACAIayEAIAEgCGohByAMIAQ6AAAgBiEIIAsgByAAIAooAgwRAQBFDQEL +C0EBIQ0LIA0LygQCB38BfiMAQRBrIgYkAAJAIAAvAQwiBUUEQCAAKAIAIAAoAgQgARBAIQIMAQsg +BiABKAIMIgQ2AgwgBiABKAIIIgI2AgggBiABKAIEIgM2AgQgBiABKAIAIgE2AgACQCAAKQIIIgmn +IgdBgICACHEEQCAAKAIAIAEgAyAAKAIEKAIMEQEADQEgACAHQYCAgP95cUGwgICAAnIiBzYCCCAG +QgE3AgAgBSADQf//A3FrIgFBACABIAVNGyEFQQAhAwsgBARAIARBDGwhCANAAn8CQAJAAkAgAi8B +AEEBaw4CAgEACyACQQRqKAIADAILIAJBCGooAgAMAQsgAkECai8BACIEQegHTwRAQQRBBSAEQZDO +AEkbDAELQQEgBEEKSQ0AGkECQQMgBEHkAEkbCyACQQxqIQIgA2ohAyAIQQxrIggNAAsLAkACQCAF +Qf//A3EgA0sEQCAFIANrIQNBACECQQAhAQJAAkACQCAHQR12QQNxQQFrDgMAAQACCyADIQEMAQsg +A0H+/wNxQQF2IQELIAdB////AHEhCCAAKAIEIQcgACgCACEEA0AgAkH//wNxIAFB//8DcU8NAiAC +QQFqIQIgBCAIIAcoAhARAABFDQALDAMLIAAoAgAgACgCBCAGEEAhAgwBCyAEIAcgBhBADQFBACEF +IAMgAWtB//8DcSEBA0AgBUH//wNxIgMgAUkhAiABIANNDQEgBUEBaiEFIAQgCCAHKAIQEQAARQ0A +CwsgACAJNwIIDAELQQEhAgsgBkEQaiQAIAIL/gMBCX8jAEEQayIEJAACfwJAIAIoAgQiA0UNACAA +IAIoAgAgAyABKAIMEQEARQ0AQQEMAQsgAigCDCIGBEAgAigCCCIDIAZBDGxqIQggBEEMaiEJA0AC +QAJAAkACQCADLwEAQQFrDgICAQALAkAgAygCBCICQcEATwRAIAFBDGooAgAhBgNAQQEgAEGA7cAA +QcAAIAYRAQANCBogAkFAaiICQcAASw0ACwwBCyACRQ0DCyAAQYDtwAAgAiABQQxqKAIAEQEARQ0C +QQEMBQsgACADKAIEIAMoAgggAUEMaigCABEBAEUNAUEBDAQLIAMvAQIhAiAJQQA6AAAgBEEANgII +An9BBEEFIAJBkM4ASRsgAkHoB08NABpBASACQQpJDQAaQQJBAyACQeQASRsLIgYgBEEIaiIKaiIH +QQFrIgUgAiACQQpuIgtBCmxrQTByOgAAAkAgBSAKRg0AIAdBAmsiBSALQQpwQTByOgAAIARBCGog +BUYNACAHQQNrIgUgAkHkAG5BCnBBMHI6AAAgBEEIaiAFRg0AIAdBBGsiBSACQegHbkEKcEEwcjoA +ACAEQQhqIAVGDQAgB0EFayACQZDOAG5BMHI6AAALIAAgBEEIaiAGIAFBDGooAgARAQBFDQBBAQwD +CyADQQxqIgMgCEcNAAsLQQALIARBEGokAAvMBAEKfyMAQTBrIgYkAAJAAkACQAJ/QQAgAUFAcSIK +RQ0AGiAGQQhqIAA2AgBBASAKQcAARg0AGiAGIABBQGs2AgwgCkGAAUcNAUECCyEHIAFBP3EhASAF +QQV2IgkgByAHIAlLGyIIBEAgBkEIaiEJIANBBHIhCyAIQQV0IQxBACEDA0AgCSgCACEIIAZBKGoi +DSACQRhqKQIANwMAIAZBIGoiDiACQRBqKQIANwMAIAZBGGoiDyACQQhqKQIANwMAIAYgAikCADcD +ECAGQRBqIAhBwABCACALECggAyAEaiIIQRhqIA0pAwA3AAAgCEEQaiAOKQMANwAAIAhBCGogDykD +ADcAACAIIAYpAxA3AAAgCUEEaiEJIAwgA0EgaiIDRw0ACwsCQCABBEAgBSAHQQV0IgJJDQEgBSAC +ayIDQR9NDQMgAUEgRw0EIAIgBGoiASAAIApqIgApAAA3AAAgAUEYaiAAQRhqKQAANwAAIAFBEGog +AEEQaikAADcAACABQQhqIABBCGopAAA3AAAgB0EBaiEHCyAGQTBqJAAgBw8LIAIgBUH4u8AAENMB +AAsgBiAAQYABajYCEEGwvcAAQSsgBkEQakHcvcAAQYi8wAAQfQALQSAgA0HYu8AAENQBAAsjAEEw +ayIAJAAgAEEgNgIEIAAgATYCACAAQQM2AgwgAEGggMEANgIIIABCAjcCFCAAIABBBGqtQoCAgICA +CYQ3AyggACAArUKAgICAgAmENwMgIAAgAEEgajYCECAAQQhqQei7wAAQoQEAC4QEAgd/AXwjAEHQ +AGsiAyQAAkACQAJAAkACQCAAKAIAIgQlAUGBASUBEAdFBEAgBCUBEAgOAgIBAwsgA0EHOgAwIANB +MGogASACEH8hAAwEC0EBIQYLQQEhB0EAIQAMAQsgA0EQaiAEJQEQCSADKAIQBEAgAysDGCEKQQMh +AEEBIQcMAQsgA0EIaiAEEO0BAn8gAygCCCIEBEAgAygCDCIFIQZBBQwBCwJAAkAgACgCACUBECME +QCADQTBqIAAQdiADKAI4IQYgAygCNCEEIAMoAjAhCAwBCyAAKAIAJQEQHUUNASADIAAoAgAQugEi +BTYCSCADQTBqIANByABqEHYgAygCOCEGIAMoAjQhBCADKAIwIQggBUGEAUkNACAFEG0LIAhBgICA +gHhGDQBBASEHQQYMAQsgA0EBNgI0IANBhJPAADYCMCADQgE3AjwgAyAArUKAgICA4AKENwNIIAMg +A0HIAGo2AjggA0EkaiADQTBqEEdBgICAgHghCCADKAIsIQYgAygCKCEEIAMoAiQhBUERCyEAIAat +vyEKIAchCQsgAyAKOQM4IAMgBDYCNCADIAY6ADEgAyAAOgAwIANBMGogASACEH8hAAJAIAlFBEAg +ByAFRXJFDQEMAgsgCARAIAQgCBDPAQsgBUUgB3INAQsgBCAFEM8BCyADQdAAaiQAIAAL5AMBBX8j +AEEQayIIJAACQAJAAkACQAJAIAEoAghBAUYEQCABKAIAIQUgASgCBCEEIAFBDBDPAUEdQYEBIARB +CnZnQQJ0ayAEQf//B0sbIQYgAiAFayIHIANqIQMgAiAFRgRAIAYhAQwGCyAGQQV2IgIgB2oiAUGA +gIDAAE8EQEH5gcEALQAAGkEUQQQQwwEiAUUNAiABQQE2AhAgASACIANqNgIIIAEgBSACazYCBCAB +IAIgBGo2AgAgASAGQQJ2QQdxNgIMDAULIAZBHXEgAUEFdHIhAQwECyADQQBIDQECQCADRQRAQQEh +BQwBC0H5gcEALQAAGkEBIQQgA0EBEMMBIgVFDQILIAMEQCAFIAIgA/wKAAALIAEgASgCCCICQQFr +NgIIIAJBAUYEQCABKAIAIAFBBGooAgAiBEEBELYBRQ0DIAQQzwEgAUEMEM8BC0EdQYEBIANBCnZn +QQJ0ayADQf//B0sbIQEgAyEEDAQLQQRBFBDqAQALIAQgA0H4tMAAELUBAAtBtLbAAEErIAhBD2pB +pLbAAEHwtsAAEH0ACyADIAdrIgJBACACIANNGyEDIAQgB2shBCAFIAdqIQULIAAgATYCDCAAIAQ2 +AgggACADNgIEIAAgBTYCACAIQRBqJAAL+QMBAn8gACABaiECAkACQCAAKAIEIgNBAXENACADQQJx +RQ0BIAAoAgAiAyABaiEBIAAgA2siAEGQhsEAKAIARgRAIAIoAgRBA3FBA0cNAUGIhsEAIAE2AgAg +AiACKAIEQX5xNgIEIAAgAUEBcjYCBCACIAE2AgAMAgsgACADEE0LAkACQAJAIAIoAgQiA0ECcUUE +QCACQZSGwQAoAgBGDQIgAkGQhsEAKAIARg0DIAIgA0F4cSICEE0gACABIAJqIgFBAXI2AgQgACAB +aiABNgIAIABBkIbBACgCAEcNAUGIhsEAIAE2AgAPCyACIANBfnE2AgQgACABQQFyNgIEIAAgAWog +ATYCAAsgAUGAAk8EQCAAIAEQVQ8LIAFB+AFxQfiDwQBqIQICf0GAhsEAKAIAIgNBASABQQN2dCIB +cUUEQEGAhsEAIAEgA3I2AgAgAgwBCyACKAIICyEBIAIgADYCCCABIAA2AgwgACACNgIMIAAgATYC +CA8LQZSGwQAgADYCAEGMhsEAQYyGwQAoAgAgAWoiATYCACAAIAFBAXI2AgQgAEGQhsEAKAIARw0B +QYiGwQBBADYCAEGQhsEAQQA2AgAPC0GQhsEAIAA2AgBBiIbBAEGIhsEAKAIAIAFqIgE2AgAgACAB +QQFyNgIEIAAgAWogATYCAAsLjgMBBH8CQAJAAkACQAJAIAcgCFYEQCAHIAh9IAhYDQECQCAGIAcg +Bn1UIAcgBkIBhn0gCEIBhlpxRQRAIAYgCFYNAQwHCyACIANJDQMMBQsgByAGIAh9IgZ9IAZWDQUg +AiADSQ0DIAEgA2ohDCABIQoCQAJAA0AgAyAJRg0BIAlBAWohCSAKQQFrIgogA2oiCy0AAEE5Rg0A +CyALIAstAABBAWo6AAAgAyAJa0EBaiADTw0BIAlBAWsiBUUNASALQQFqQTAgBfwLAAwBCwJAIANF +BEBBMSEJDAELIAFBMToAACADQQFGBEBBMCEJDAELQTAhCSADQQFrIgpFDQAgAUEBakEwIAr8CwAL +IARBAWrBIgQgBcFMIAIgA01yDQAgDCAJOgAAIANBAWohAwsgAiADTw0EIAMgAkG45sAAENQBAAsg +AEEANgIADwsgAEEANgIADwsgAyACQcjmwAAQ1AEACyADIAJBqObAABDUAQALIAAgBDsBCCAAIAM2 +AgQgACABNgIADwsgAEEANgIAC6cDAQJ/AkACQAJAAkAgAC0AaCIDBEAgA0HBAE8NAyACQcAAIANr +IgQgAiAESRsiBARAIAAgA2ogASAE/AoAAAsgACAALQBoIARqIgM6AGggASAEaiEBIAIgBGsiAkUE +QEEAIQIMAgsgAEFAayAAQcAAIAApA2AgAC0AaiAALQBpRXIQKCAAQgA3AwAgAEEAOgBoIABBCGpC +ADcDACAAQRBqQgA3AwAgAEEYakIANwMAIABBIGpCADcDACAAQShqQgA3AwAgAEEwakIANwMAIABB +OGpCADcDACAAIAAtAGlBAWo6AGkLQQAhAyACQcEASQ0BIABBQGshBCAALQBpIQMDQCAEIAFBwAAg +ACkDYCAALQBqIANB/wFxRXIQKCAAIAAtAGlBAWoiAzoAaSABQUBrIQEgAkFAaiICQcAASw0ACyAA +LQBoIQMLIANB/wFxIgNBwQBPDQILIAJBwAAgA2siBCACIARJGyICBEAgACADaiABIAL8CgAACyAA +IAAtAGggAmo6AGggAA8LIANBwABBuLvAABDTAQALIANBwABBuLvAABDTAQALjwMBB38jAEEQayIE +JAACQAJAAkACQCABKAIEIgIEQCABKAIAIQcgAkEDcSEFAkAgAkEESQRAQQAhAgwBCyAHQRxqIQMg +AkF8cSEIQQAhAgNAIAMoAgAgA0EIaygCACADQRBrKAIAIANBGGsoAgAgAmpqamohAiADQSBqIQMg +CCAGQQRqIgZHDQALCyAFBEAgBkEDdCAHakEEaiEDA0AgAygCACACaiECIANBCGohAyAFQQFrIgUN +AAsLIAEoAgxFDQIgAkEPSw0BIAcoAgQNAQwDC0EAIQIgASgCDEUNAgsgAkEAIAJBAEobQQF0IQIL +QQAhBSACQQBOBEAgAkUNAUH5gcEALQAAGkEBIQUgAkEBEMMBIgMNAgsgBSACQcTKwAAQtQEAC0EB +IQNBACECCyAEQQA2AgggBCADNgIEIAQgAjYCACAEQcTJwAAgARA8RQRAIAAgBCkCADcCACAAQQhq +IARBCGooAgA2AgAgBEEQaiQADwtB5MrAAEHWACAEQQ9qQdTKwABB1MvAABB9AAvnAgEFfwJAIAFB +zf97QRAgACAAQRBNGyIAa08NACAAQRAgAUELakF4cSABQQtJGyIEakEMahApIgJFDQAgAkEIayEB +AkAgAEEBayIDIAJxRQRAIAEhAAwBCyACQQRrIgUoAgAiBkF4cSACIANqQQAgAGtxQQhrIgIgAEEA +IAIgAWtBEE0baiIAIAFrIgJrIQMgBkEDcQRAIAAgAyAAKAIEQQFxckECcjYCBCAAIANqIgMgAygC +BEEBcjYCBCAFIAIgBSgCAEEBcXJBAnI2AgAgASACaiIDIAMoAgRBAXI2AgQgASACEEQMAQsgASgC +ACEBIAAgAzYCBCAAIAEgAmo2AgALAkAgACgCBCIBQQNxRQ0AIAFBeHEiAiAEQRBqTQ0AIAAgBCAB +QQFxckECcjYCBCAAIARqIgEgAiAEayIEQQNyNgIEIAAgAmoiAiACKAIEQQFyNgIEIAEgBBBECyAA +QQhqIQMLIAML6gICBn8CfiMAQSBrIgUkAEEUIQMgACIJQugHWgRAIAkhCgNAIAVBDGogA2oiBEED +ayAKIApCkM4AgCIJQpDOAH59pyIGQf//A3FB5ABuIgdBAXQiCEG568AAai0AADoAACAEQQRrIAhB +uOvAAGotAAA6AAAgBEEBayAGIAdB5ABsa0H//wNxQQF0IgZBuevAAGotAAA6AAAgBEECayAGQbjr +wABqLQAAOgAAIANBBGshAyAKQv+s4gRWIAkhCg0ACwsgCUIJVgRAIAMgBWpBC2ogCaciBCAEQf// +A3FB5ABuIgRB5ABsa0H//wNxQQF0IgZBuevAAGotAAA6AAAgA0ECayIDIAVBDGpqIAZBuOvAAGot +AAA6AAAgBK0hCQsgAFBFIAlQcUUEQCADQQFrIgMgBUEMamogCadBAXRBHnFBuevAAGotAAA6AAAL +IAIgAUEBQQAgBUEMaiADakEUIANrEDYgBUEgaiQAC9ACAQR/IwBB8ABrIgMkAAJAIAACfgJAIAEo +AgQiBCABKAIMRwRAIAEgBEEQajYCBCAEKAIMIQUgBCgCACEBIAIoAgQgA0HIAGogBCgCBCIGIAQo +AggQNyADKAJIIgRFBEAgA0FAayADQegAaikDADcDACADQThqIANB4ABqKQMANwMAIANBMGogA0HY +AGopAwA3AwAgAyADKQNQNwMoCyABBEAgBiABEM8BCyAEQQFxRQ0BQQE6AABCAAwCCyAAQgI3AwAM +AgsgA0EgaiADQUBrKQMANwMAIANBGGogA0E4aikDADcDACADQRBqIANBMGopAwA3AwAgAyADKQMo +NwMIQgELNwMAIAAgAykDCDcDCCAAIAU2AiggAEEQaiADQRBqKQMANwMAIABBGGogA0EYaikDADcD +ACAAQSBqIANBIGopAwA3AwALIANB8ABqJAAL3AgBCH8jAEGAAWsiAiQAIAJBCGohBCMAQSBrIgMk +ACADIABpIgE2AhwCQAJAAkACQAJAAkAgAUEBRgRAIABBwABNDQEgA0GcgsEANgIYQaCCwQAtAABB +A0cEfyADIANBGGo2AhwgAyADQRxqNgIAIwBBIGsiASQAAkACQAJAAkACQAJAQaCCwQAtAABBAWsO +AwIEAQALQaCCwQBBAjoAACADKAIAIgYoAgAhBSAGQQA2AgAgBUUNAiAFKAIAQQg2AgBBoILBAEED +OgAACyABQSBqJAAMAwsgAUEANgIYIAFBATYCDCABQbSZwAA2AggMCgtB+JrAABDXAQALIAFBADYC +GCABQQE2AgwgAUH0mcAANgIIDAgLIAMoAhgFQZyCwQALKAIAIgFFDQIgA0GUgsEANgIYIAAgAW4i +BkGYgsEALQAAQQNHBH8gAyADQRhqNgIcIAMgA0EcajYCACMAQSBrIgEkAAJAAkACQAJAAkACQEGY +gsEALQAAQQFrDgMCBAEAC0GYgsEAQQI6AAAgAygCACIHKAIAIQUgB0EANgIAIAVFDQIgBSgCAEEC +NgIAQZiCwQBBAzoAAAsgAUEgaiQADAMLIAFBADYCGCABQQE2AgwgAUG0mcAANgIIDAoLQfiawAAQ +1wEACyABQQA2AhggAUEBNgIMIAFB9JnAADYCCAwICyADKAIYBUGUgsEACygCACAAbCIBTw0DIAFB +AEgNBEH5gcEALQAAGkEBIQggAUEBEMMBIgVFDQQgBCABNgIcIAQgBjYCGCAEQYibwAA2AgggBEIA +NwMAIARBADYCKCAEIAU2AiQgBCABNgIgIAQgAEEBayIArSAAZ0Egc62GNwMQIANBIGokAAwFCyAD +QQA2AgAjAEEQayIAJAAgAEGglMAANgIMIAAgA0EcajYCCCAAQQhqQcixwAAgAEEMakHIscAAIANB +iJXAABBQAAtBmJXAAEEoQcCVwAAQlgEAC0HQlcAAEJwBAAtB4JXAAEEvQZCWwAAQlgEACyAIIAFB +oJbAABC1AQALIAJBOGoiAEEAOgAAIAJB+ABqIAApAwA3AgAgAkHwAGogAkEwaikDADcCACACQegA +aiACQShqKQMANwIAIAJB4ABqIAJBIGopAwA3AgAgAkHYAGogAkEYaikDADcCACACQdAAaiACQRBq +KQMANwIAQfmBwQAtAAAaIAIgAikDCDcCSEHIAEEIEMMBIgBFBEBBCEHIABDqAQALIABBADYCCCAA +QoGAgIAQNwMAIAAgAikCRDcCDCAAQRRqIAJBzABqKQIANwIAIABBHGogAkHUAGopAgA3AgAgAEEk +aiACQdwAaikCADcCACAAQSxqIAJB5ABqKQIANwIAIABBNGogAkHsAGopAgA3AgAgAEE8aiACQfQA +aikCADcCACAAQcQAaiACQfwAaigCADYCACACQYABaiQAIABBCGoPCyABQgQ3AhAgAUEIakHsl8AA +EKEBAAvmAgEIfyMAQRBrIgUkAEEKIQIgACIDQegHTwRAIAMhBANAIAVBBmogAmoiBkEDayAEIARB +kM4AbiIDQZDOAGxrIgdB//8DcUHkAG4iCEEBdCIJQbnrwABqLQAAOgAAIAZBBGsgCUG468AAai0A +ADoAACAGQQFrIAcgCEHkAGxrQf//A3FBAXQiB0G568AAai0AADoAACAGQQJrIAdBuOvAAGotAAA6 +AAAgAkEEayECIARB/6ziBEsgAyEEDQALCwJAIANBCU0EQCADIQQMAQsgAiAFakEFaiADIANB//8D +cUHkAG4iBEHkAGxrQf//A3FBAXQiA0G568AAai0AADoAACACQQJrIgIgBUEGamogA0G468AAai0A +ADoAAAtBACAAIAQbRQRAIAJBAWsiAiAFQQZqaiAEQQF0QR5xQbnrwABqLQAAOgAACyABQQFBAUEA +IAVBBmogAmpBCiACaxA2IAVBEGokAAuCAwEEfyAAKAIMIQICQAJAAkAgAUGAAk8EQCAAKAIYIQMC +QAJAIAAgAkYEQCAAQRRBECAAKAIUIgIbaigCACIBDQFBACECDAILIAAoAggiASACNgIMIAIgATYC +CAwBCyAAQRRqIABBEGogAhshBANAIAQhBSABIgJBFGogAkEQaiACKAIUIgEbIQQgAkEUQRAgARtq +KAIAIgENAAsgBUEANgIACyADRQ0CAkAgACgCHEECdEHogsEAaiIBKAIAIABHBEAgAygCECAARg0B +IAMgAjYCFCACDQMMBAsgASACNgIAIAJFDQQMAgsgAyACNgIQIAINAQwCCyAAKAIIIgAgAkcEQCAA +IAI2AgwgAiAANgIIDwtBgIbBAEGAhsEAKAIAQX4gAUEDdndxNgIADwsgAiADNgIYIAAoAhAiAQRA +IAIgATYCECABIAI2AhgLIAAoAhQiAEUNACACIAA2AhQgACACNgIYDwsPC0GEhsEAQYSGwQAoAgBB +fiAAKAIcd3E2AgAL4AIBBH8jAEEQayICJAACQCABQYABTwRAIAJBDGoiBEECciEDIAJBADYCDAJA +IAFBgBBPBEAgBEEDciEFIAFBgIAETwRAIAJBEGohAyACIAFBEnZB8AFyOgAMIAIgAUEGdkE/cUGA +AXI6AA4gAiABQQx2QT9xQYABcjoADSAFIQQMAgsgAiABQQx2QeABcjoADCACIAFBBnZBP3FBgAFy +OgANIAMhBCAFIQMMAQsgAkEMakEBciEEIAIgAUEGdkHAAXI6AAwLIAQgAUE/cUGAAXI6AAAgAyAC +QQxqayIBIAAoAgAgACgCCCIDa0sEQCAAIAMgAUEBQQEQVyAAKAIIIQMLIAEEQCAAKAIEIANqIAJB +DGogAfwKAAALIAAgASADajYCCAwBCyAAKAIIIgMgACgCAEYEQCAAQYiDwAAQcgsgACgCBCADaiAB +OgAAIAAgA0EBajYCCAsgAkEQaiQAQQAL4AIBBH8jAEEQayICJAACQCABQYABTwRAIAJBDGoiBEEC +ciEDIAJBADYCDAJAIAFBgBBPBEAgBEEDciEFIAFBgIAETwRAIAJBEGohAyACIAFBEnZB8AFyOgAM +IAIgAUEGdkE/cUGAAXI6AA4gAiABQQx2QT9xQYABcjoADSAFIQQMAgsgAiABQQx2QeABcjoADCAC +IAFBBnZBP3FBgAFyOgANIAMhBCAFIQMMAQsgAkEMakEBciEEIAIgAUEGdkHAAXI6AAwLIAQgAUE/ +cUGAAXI6AAAgAyACQQxqayIBIAAoAgAgACgCCCIDa0sEQCAAIAMgAUEBQQEQVyAAKAIIIQMLIAEE +QCAAKAIEIANqIAJBDGogAfwKAAALIAAgASADajYCCAwBCyAAKAIIIgMgACgCAEYEQCAAQaCOwAAQ +cgsgACgCBCADaiABOgAAIAAgA0EBajYCCAsgAkEQaiQAQQALswIBAX8jAEHwAGsiBiQAIAYgATYC +DCAGIAA2AgggBiADNgIUIAYgAjYCECAGQcyBwQAoAgA2AhwgBkHAgcEAKAIANgIYAkAgBCgCAARA +IAZBMGogBEEQaikCADcDACAGQShqIARBCGopAgA3AwAgBiAEKQIANwMgIAZBBDYCXCAGQeDqwAA2 +AlggBkIENwJkIAYgBkEQaq1CgICAgPALhDcDUCAGIAZBCGqtQoCAgIDwC4Q3A0ggBiAGQSBqrUKA +gICAkAyENwNADAELIAZBAzYCXCAGQazqwAA2AlggBkIDNwJkIAYgBkEQaq1CgICAgPALhDcDSCAG +IAZBCGqtQoCAgIDwC4Q3A0ALIAYgBkEYaq1CgICAgIAMhDcDOCAGIAZBOGo2AmAgBkHYAGogBRCh +AQAL8gIBAX8CQCACBEAgAS0AAEEwTQ0BIAVBAjsBAAJAAkACQAJAAkAgA8EiBkEASgRAIAUgATYC +BCACIANB//8DcSIDSw0BIAVBADsBDCAFIAI2AgggBSADIAJrNgIQIAQNAkECIQEMBQsgBSACNgIg +IAUgATYCHCAFQQI7ARggBUEAOwEMIAVBAjYCCCAFQfHnwAA2AgQgBUEAIAZrIgM2AhBBAyEBIAIg +BE8NBCAEIAJrIgIgA00NBCACIAZqIQQMAwsgBUECOwEYIAVBATYCFCAFQfDnwAA2AhAgBUECOwEM +IAUgAzYCCCAFIAIgA2siAjYCICAFIAEgA2o2AhwgAiAESQ0BQQMhAQwDCyAFQQE2AiAgBUHw58AA +NgIcIAVBAjsBGAwBCyAEIAJrIQQLIAUgBDYCKCAFQQA7ASRBBCEBCyAAIAE2AgQgACAFNgIADwtB +2OTAAEEhQfzmwAAQlgEAC0GM58AAQR9BrOfAABCWAQALygIBBn8gASACQQF0aiEJIABBgP4DcUEI +diEKIABB/wFxIQwCQAJAAkACQANAIAFBAmohCyAHIAEtAAEiAmohCCAKIAEtAAAiAUcEQCABIApL +DQQgCCEHIAsiASAJRw0BDAQLIAcgCEsNASAEIAhJDQIgAyAHaiEBA0AgAkUEQCAIIQcgCyIBIAlH +DQIMBQsgAkEBayECIAEtAAAgAUEBaiEBIAxHDQALC0EAIQIMAwsgByAIQcjwwAAQ1QEACyAIIARB +yPDAABDUAQALIABB//8DcSEHIAUgBmohA0EBIQIDQCAFQQFqIQACQCAFLAAAIgFBAE4EQCAAIQUM +AQsgACADRwRAIAUtAAEgAUH/AHFBCHRyIQEgBUECaiEFDAELQbjwwAAQ1wEACyAHIAFrIgdBAEgN +ASACQQFzIQIgAyAFRw0ACwsgAkEBcQvKAgEDfyMAQRBrIgIkAAJAIAFBgAFPBEAgAkEANgIMAn8g +AUGAEE8EQCABQYCABE8EQCACQQxqQQNyIQQgAiABQRJ2QfABcjoADCACIAFBBnZBP3FBgAFyOgAO +IAIgAUEMdkE/cUGAAXI6AA1BBAwCCyACQQxqQQJyIQQgAiABQQx2QeABcjoADCACIAFBBnZBP3FB +gAFyOgANQQMMAQsgAkEMakEBciEEIAIgAUEGdkHAAXI6AAxBAgshAyAEIAFBP3FBgAFyOgAAIAAo +AgAgACgCCCIBayADSQRAIAAgASADEGggACgCCCEBCyADBEAgACgCBCABaiACQQxqIAP8CgAACyAA +IAEgA2o2AggMAQsgACgCCCIDIAAoAgBGBEAgAEHky8AAEHILIAAgA0EBajYCCCAAKAIEIANqIAE6 +AAALIAJBEGokAEEAC8YCAQJ/IwBBEGsiAiQAAkAgAUGAAU8EQCACQQA2AgwCfyABQYAQTwRAIAFB +gIAETwRAIAIgAUE/cUGAAXI6AA8gAiABQRJ2QfABcjoADCACIAFBBnZBP3FBgAFyOgAOIAIgAUEM +dkE/cUGAAXI6AA1BBAwCCyACIAFBP3FBgAFyOgAOIAIgAUEMdkHgAXI6AAwgAiABQQZ2QT9xQYAB +cjoADUEDDAELIAIgAUE/cUGAAXI6AA0gAiABQQZ2QcABcjoADEECCyIBIAAoAgAgACgCCCIDa0sE +QCAAIAMgARBfIAAoAgghAwsgAQRAIAAoAgQgA2ogAkEMaiAB/AoAAAsgACABIANqNgIIDAELIAAo +AggiAyAAKAIARgRAIABB+MTAABByCyAAKAIEIANqIAE6AAAgACADQQFqNgIICyACQRBqJABBAAvE +AgEEfyAAQgA3AhAgAAJ/QQAgAUGAAkkNABpBHyABQf///wdLDQAaIAFBBiABQQh2ZyIDa3ZBAXEg +A0EBdGtBPmoLIgI2AhwgAkECdEHogsEAaiEEQQEgAnQiA0GEhsEAKAIAcUUEQCAEIAA2AgAgACAE +NgIYIAAgADYCDCAAIAA2AghBhIbBAEGEhsEAKAIAIANyNgIADwsCQAJAIAEgBCgCACIDKAIEQXhx +RgRAIAMhAgwBCyABQRkgAkEBdmtBACACQR9HG3QhBQNAIAMgBUEddkEEcWoiBCgCECICRQ0CIAVB +AXQhBSACIQMgAigCBEF4cSABRw0ACwsgAigCCCIBIAA2AgwgAiAANgIIIABBADYCGCAAIAI2Agwg +ACABNgIIDwsgBEEQaiAANgIAIAAgAzYCGCAAIAA2AgwgACAANgIIC/cCAQR/IwBBMGsiACQAAkAC +QEHYgcEAKAIARQRAQfCBwQAoAgAhAUHwgcEAQQA2AgAgAUUNASAAQRhqIAERBgAgAEEQaiICIABB +JGopAgA3AwAgACAAKQIcNwMIIAAoAhghAUHYgcEAKAIAIgMNAgJAIANFDQBB3IHBACgCACICRQ0A +QeCBwQAoAgAgAkECdBDPAQtB3IHBACABNgIAQdiBwQBBATYCAEHggcEAIAApAwg3AgBB6IHBACAA +QRBqKQMANwIACyAAQTBqJABB3IHBAA8LIABBADYCKCAAQQE2AhwgAEG8wMAANgIYIABCBDcCICAA +QRhqQajBwAAQoQEACyAAQShqIAIpAwA3AgAgACAAKQMINwIgIAAgATYCHCAAQQE2AhgCQCAAQRhq +IgEoAgBFDQAgASgCBCICRQ0AIAEoAgggAkECdBDPAQsgAEEANgIoIABBATYCHCAAQcjBwAA2Ahgg +AEIENwIgIAFB0MHAABChAQAL/AECBH8BfiMAQSBrIgUkAAJAAkAgBEUNACABIAEgAmoiAksNACAD +IARqQQFrQQAgA2txrSACIAAoAgAiAUEBdCIGIAIgBksbIgJBCEEEQQEgBEGBCEkbIARBAUYbIgYg +AiAGSxsiBq1+IglCIIhQRQ0AIAmnIghBgICAgHggA2tLDQBBACECIAUgAQR/IAUgASAEbDYCHCAF +IAAoAgQ2AhQgAwUgAgs2AhggBUEIaiADIAggBUEUahB0IAUoAghBAUcNASAFKAIQIQIgBSgCDCEH +CyAHIAJBpIvAABC1AQALIAUoAgwhASAAIAY2AgAgACABNgIEIAVBIGokAAvKAQIEfwF+IwBBIGsi +AyQAAkACQCABIAEgAmoiAksNAEEIIAIgACgCACIBQQF0IgQgAiAESxsiAiACQQhNGyIErSIHQiCI +UEUNACAHpyIFQf////8HSw0AIAMgAQR/IAMgATYCHCADIAAoAgQ2AhRBAQVBAAs2AhggA0EIakEB +IAUgA0EUahB0IAMoAghBAUcNASADKAIQIQIgAygCDCEGCyAGIAJB+JjAABC1AQALIAMoAgwhASAA +IAQ2AgAgACABNgIEIANBIGokAAuJAgEBfyMAQRBrIgIkACAAKAIAIQACfyABLQALQRhxRQRAIAEo +AgAgACABKAIEKAIQEQAADAELIAJBADYCDCABIAJBDGoCfyAAQYABTwRAIABBgBBPBEAgAEGAgARP +BEAgAiAAQT9xQYABcjoADyACIABBEnZB8AFyOgAMIAIgAEEGdkE/cUGAAXI6AA4gAiAAQQx2QT9x +QYABcjoADUEEDAMLIAIgAEE/cUGAAXI6AA4gAiAAQQx2QeABcjoADCACIABBBnZBP3FBgAFyOgAN +QQMMAgsgAiAAQT9xQYABcjoADSACIABBBnZBwAFyOgAMQQIMAQsgAiAAOgAMQQELEDoLIAJBEGok +AAuqAgIDfwF+IwBBQGoiAiQAIAEoAgBBgICAgHhGBEAgASgCDCEDIAJBJGoiBEEANgIAIAJCgICA +gBA3AhwgAkEwaiADKAIAIgNBCGopAgA3AwAgAkE4aiADQRBqKQIANwMAIAIgAykCADcDKCACQRxq +QejFwAAgAkEoahA8GiACQRhqIAQoAgAiAzYCACACIAIpAhwiBTcDECABQQhqIAM2AgAgASAFNwIA +CyABKQIAIQUgAUKAgICAEDcCACACQQhqIgMgAUEIaiIBKAIANgIAIAFBADYCAEH5gcEALQAAGiAC +IAU3AwBBDEEEEMMBIgFFBEBBBEEMEOoBAAsgASACKQMANwIAIAFBCGogAygCADYCACAAQYTIwAA2 +AgQgACABNgIAIAJBQGskAAuaAgEDfyMAQRBrIgYkACABIAEoAggiBUEAIAVBAUcbNgIIAkACQAJA +IAVBAUYEQCABKAIEIQQgASgCACEFIAFBDBDPASADRQ0BIAUgAiAD/AoAAAwBCyADQQBIDQECQCAD +RQRAQQEhBQwBC0H5gcEALQAAGkEBIQQgA0EBEMMBIgVFDQILIAMEQCAFIAIgA/wKAAALIAEgASgC +CCICQQFrNgIIIAMhBCACQQFHDQAgASgCACABQQRqKAIAIgRBARC2AUUNAiAEEM8BIAFBDBDPASAD +IQQLIAAgAzYCCCAAIAU2AgQgACAENgIAIAZBEGokAA8LIAQgA0H4tMAAELUBAAtBtLbAAEErIAZB +D2pBpLbAAEHwtsAAEH0AC4ICAgF+An8jAEGAAWsiBCQAIAAoAgApAwAhAgJ/AkAgASgCCCIAQYCA +gBBxRQRAIABBgICAIHENASACQQEgARBJDAILQQAhAANAIAAgBGpB/wBqIAKnQQ9xIgNBMHIgA0HX +AGogA0EKSRs6AAAgAEEBayEAIAJCD1YgAkIEiCECDQALIAFBAUG268AAQQIgACAEakGAAWpBACAA +axA2DAELQQAhAANAIAAgBGpB/wBqIAKnQQ9xIgNBMHIgA0E3aiADQQpJGzoAACAAQQFrIQAgAkIP +ViACQgSIIQINAAsgAUEBQbbrwABBAiAAIARqQYABakEAIABrEDYLIARBgAFqJAALiAIBBX8CQAJA +AkACQCABKAIAIgFBAXEEQEEdQYEBIAIgAUF+cSIFayIGIANqIgFBCnZnQQJ0ayABQf//B0sbIQQg +AiAFRgRAIAQhAiABIQMMBQsgBEEFdiIHIAZqIgJBgICAwABJDQJB+YHBAC0AABpBFEEEEMMBIgJF +DQEgAkEBNgIQIAIgASAHaiIINgIIIAIgBSAHazYCBCACIAg2AgAgAiAEQQJ2QQdxNgIMDAMLIAAg +ASACIAMQQw8LQQRBFBDqAQALIARBHXEgAkEFdHIhAgsgASAGayIEQQAgASAETxshASAFIAZqIQUL +IAAgAjYCDCAAIAM2AgggACABNgIEIAAgBTYCAAuDAgEFfwJAAkACQAJAIAEoAgAiAUEBcQRAQR1B +gQEgAiABayIGIANqIgRBCnZnQQJ0ayAEQf//B0sbIQUgASACRgRAIAUhAiAEIQMMBQsgBUEFdiIH +IAZqIgJBgICAwABJDQJB+YHBAC0AABpBFEEEEMMBIgJFDQEgAkEBNgIQIAIgBCAHaiIINgIIIAIg +ASAHazYCBCACIAg2AgAgAiAFQQJ2QQdxNgIMDAMLIAAgASACIAMQQw8LQQRBFBDqAQALIAVBHXEg +AkEFdHIhAgsgBCAGayIFQQAgBCAFTxshBCABIAZqIQELIAAgAjYCDCAAIAM2AgggACAENgIEIAAg +ATYCAAvVAQIEfwF+IwBBIGsiAyQAAkACQCABIAEgAmoiAksEQEEAIQEMAQtBACEBQQggAiAAKAIA +IgVBAXQiBCACIARLGyICIAJBCE0bIgStIgdCIIhQRQ0AIAenIgZB/////wdLDQAgAyAFBH8gAyAF +NgIcIAMgACgCBDYCFEEBBUEACzYCGCADQQhqQQEgBiADQRRqEHQgAygCCEEBRw0BIAMoAhAhAiAD +KAIMIQELIAEgAkHYxcAAELUBAAsgAygCDCEBIAAgBDYCACAAIAE2AgQgA0EgaiQAC8oCAgR/AW8j +AEEgayIDJAAQGiEHEHAiBSAHJgEgA0EYaiIEIAU2AgQgBCACNgIAIAMoAhwhAgJAIAMoAhgiBEUE +QEEBIQUMAQsgAyACNgIcIAMgBDYCGCADQRBqIgQgASgCBCABKAIIELgBNgIEIARBADYCAEEBIQUg +AygCFCEEAkACQCADKAIQQQFxBEAgAiEBIAQhAgwBCyADQRxqIgZBuITAAEEEED0gBBDQASABKAIM +uBAMIQcQcCIEIAcmASADQQhqIgIgBDYCBCACQQA2AgAgAygCDCECIAMoAghBAXFFDQEgAygCHCEB +CyABQYQBSQ0BIAEQbQwBCyAGQbyEwABBBhA9IAIQ0AEgAS0AECEBIAZB7oTAAEEFED1BggFBgwEg +ARsQ0AFBACEFIAMoAhwhAgsgACACNgIEIAAgBTYCACADQSBqJAALqAIBBH8jAEEgayIEJABBASEG +AkAgACgCACIFIAEgAiAAKAIEIgcoAgwiAREBAA0AAkAgAC0ACkGAAXFFBEAgBUGy68AAQQEgAREB +AA0CIAMgAEGkg8AAKAIAEQAARQ0BDAILIAVBs+vAAEECIAERAQANASAEQQE6AA8gBCAHNgIEIAQg +BTYCACAEQZTrwAA2AhQgBCAAKQIINwIYIAQgBEEPajYCCCAEIAQ2AhAgAyAEQRBqQaSDwAAoAgAR +AAANASAEKAIQQbDrwABBAiAEKAIUKAIMEQEADQELAkAgAg0AIAAtAApBgAFxDQAgACgCAEG168AA +QQEgACgCBCgCDBEBAA0BCyAAKAIAQbTowABBASAAKAIEKAIMEQEAIQYLIARBIGokACAGC9kDAQd/ +IwBBEGsiBiQAAkACQCACQQdNBEAgAg0BDAILIAZBCGohBwJAAkACQAJAIAFBA2pBfHEiAyABRg0A +IAIgAyABayIDIAIgA0kbIgRFDQBBACEDQQEhBQNAIAEgA2otAABBLkYNBCAEIANBAWoiA0cNAAsg +BCACQQhrIghLDQIMAQsgAkEIayEIQQAhBAtBrty48QIhAwNAQYCChAggASAEaiIJKAIAQa7cuPEC +cyIFayAFckGAgoQIIAlBBGooAgBBrty48QJzIgVrIAVycUGAgYKEeHFBgIGChHhHDQEgBEEIaiIE +IAhNDQALCyACIARHBEBBLiEDQQEhBQNAIAEgBGotAABBLkYEQCAEIQMMAwsgAiAEQQFqIgRHDQAL +C0EAIQULIAcgAzYCBCAHIAU2AgAgBigCCEEBRiEDDAELIAEtAABBLkYiAyACQQFGcg0AIAEtAAFB +LkYiAyACQQJGcg0AIAEtAAJBLkYiAyACQQNGcg0AIAEtAANBLkYiAyACQQRGcg0AIAEtAARBLkYi +AyACQQVGcg0AIAEtAAVBLkYiAyACQQZGcg0AIAEtAAZBLkYhAwsgACADIAAtAARyOgAEIAAoAgAg +ASACEL8BIAZBEGokAAvkAQEEfyMAQRBrIgMkACAAKAIMIQECQAJ/AkACQAJAAkACQCAAKAIEDgIA +AQILIAENAUEBIQFBACEAQQEhAgwDCyABRQ0BCyADQQRqIAAQRyADKAIEIQAgAygCCCECIAMoAgwM +AgsgACgCACIBKAIEIgBBAEgNAiABKAIAIQEgAEUEQEEBIQJBACEADAELQfmBwQAtAAAaQQEhBCAA +QQEQwwEiAkUNAgsgAARAIAIgASAA/AoAAAsgAAshASACIAEQuQEgAARAIAIgABDPAQsgA0EQaiQA +DwsgBCAAQayQwAAQtQEAC5QCAgF/AX4jAEGgAWsiAiQAIAJCgICAgIAHIgMgAUEYaq2ENwM4IAIg +AyABQRBqrYQ3AzAgAiADIAFBCGqthDcDKCACIAMgAa2ENwMgIAJBrLnAADYCCCACQQQ2AgwgAkEE +NgIcIAJCg4CAgICEgIBpNwKYASACQYCAwAA2ApABIAJBAjsBiAEgAkKCgICAgISAgGk3AoABIAJB +gIDAADYCeCACQQI7AXAgAkKBgICAgISAgGk3AmggAkGAgMAANgJgIAJBAjsBWCACQoCAgICAhICA +aTcCUCACQoCAwAA3AkggAkECOwFAIAIgAkFAazYCGCACQQQ2AhQgAiACQSBqNgIQIAAgAkEIahBH +IAJBoAFqJAAL8gEBAn8jAEEwayICJAACQCAAKQMAQv///////////wCDQoCAgICAgID4/wBaBEAg +AkEBNgIUIAJBhMDAADYCECACQgE3AhwgAiAArUKAgICAoAiENwMoIAIgAkEoajYCGCABKAIAIAEo +AgQgAkEQahA8IQMMAQsgAkEAOgAMIAIgATYCCEEBIQMgAkEBNgIUIAJBhMDAADYCECACQgE3Ahwg +AiAArUKAgICAoAiENwMoIAIgAkEoajYCGCACQQhqQey9wAAgAkEQahA8DQAgAi0ADEUEQCABQYzA +wABBAhC/AQ0BC0EAIQMLIAJBMGokACADC5UCAQJ/IwBBIGsiBSQAQeSCwQBB5ILBACgCACIGQQFq +NgIAAn9BACAGQQBIDQAaQQFBsIbBAC0AAA0AGkGwhsEAQQE6AABBrIbBAEGshsEAKAIAQQFqNgIA +QQILQf8BcSIGQQJHBEAgBkEBcQRAIAVBCGogACABKAIYEQIACwALAkBB2ILBACgCACIGQQBOBEBB +2ILBACAGQQFqNgIAQdyCwQAoAgAEQCAFIAAgASgCFBECACAFIAQ6AB0gBSADOgAcIAUgAjYCGCAF +IAUpAwA3AhBB3ILBACgCACAFQRBqQeCCwQAoAgAoAhQRAgALQdiCwQBB2ILBACgCAEEBazYCAEGw +hsEAQQA6AAAgA0UNAQALAAsAC8QBAgZ/AX4jAEEgayICJABBBCAAKAIAIgVBAXQiAyADQQRNGyIG +rUIUfiIIQiCIUEUEQEEAQQAgARC1AQALAkAgCKciB0H8////B00EQEEAIQMgAiAFBH8gAiAFQRRs +NgIcIAIgACgCBDYCFEEEBSADCzYCGCACQQhqQQQgByACQRRqEHQgAigCCEEBRw0BIAIoAgwhBCAC +KAIQIQMLIAQgAyABELUBAAsgAigCDCEBIAAgBjYCACAAIAE2AgQgAkEgaiQAC7sBAQJ/IwBBIGsi +AyQAAkACf0EAIAEgASACaiICSw0AGkEAQQggAiAAKAIAIgFBAXQiBCACIARLGyICIAJBCE0bIgRB +AEgNABpBACECIAMgAQR/IAMgATYCHCADIAAoAgQ2AhRBAQUgAgs2AhggA0EIakEBIAQgA0EUahB0 +IAMoAghBAUcNASADKAIQIQAgAygCDAsgAEGYysAAELUBAAsgAygCDCEBIAAgBDYCACAAIAE2AgQg +A0EgaiQAC8ABAQV/IwBBIGsiASQAIAAoAgAiAkH///8/SwRAQQBBAEGwicAAELUBAAsCQEEEIAJB +AXQiAyADQQRNGyIDQQR0IgRB/P///wdNBH8gASACBH8gASACQQR0NgIcIAEgACgCBDYCFEEEBUEA +CzYCGCABQQhqQQQgBCABQRRqEHQgASgCCEEBRw0BIAEoAhAhBSABKAIMBUEACyAFQbCJwAAQtQEA +CyABKAIMIQIgACADNgIAIAAgAjYCBCABQSBqJAALvQEBA38jAEEQayICJAACQAJAAkAgAUUEQCAA +RQ0BIABBCGsiASgCAEEBRw0CIAAoAiwgACgCKCEDIAFBADYCAAJAIAFBf0YNACAAQQRrIgAgACgC +AEEBayIANgIAIAANACABQcgAEM8BCyADRQ0DIAMQzwEMAwsgAEUNACACIABBCGsiADYCDCAAIAAo +AgBBAWsiADYCACAADQIgAkEMahCTAQwCCxDjAQALQfOEwABBPxDlAQALIAJBEGokAAvBAQIDfwF+ +IwBBMGsiAiQAIAEoAgBBgICAgHhGBEAgASgCDCEDIAJBFGoiBEEANgIAIAJCgICAgBA3AgwgAkEg +aiADKAIAIgNBCGopAgA3AwAgAkEoaiADQRBqKQIANwMAIAIgAykCADcDGCACQQxqQejFwAAgAkEY +ahA8GiACQQhqIAQoAgAiAzYCACACIAIpAgwiBTcDACABQQhqIAM2AgAgASAFNwIACyAAQYTIwAA2 +AgQgACABNgIAIAJBMGokAAu2AQEBfyMAQRBrIgMkAAJAAkACQCAAKAIAIgBBAXEEQCABIABBfnEi +AGsgAmoiAUEBELYBRQ0CIAAgARDPAQwBCyAAIAAoAggiAUEBazYCCCABQQFHDQAgACgCACAAQQRq +KAIAIgJBARC2AUUNAiACEM8BIABBDBDPAQsgA0EQaiQADwtBtLbAAEErIANBD2pBpLbAAEHgtsAA +EH0AC0G0tsAAQSsgA0EPakGktsAAQfC2wAAQfQALsAEBBn8CQAJAIABBhAFJDQAgANBvJgEQViIB +KAIMIQUgASgCECECIAFCADcCDCABKAIIIQMgASgCBCEEIAFCBDcCBCABKAIAIQYgAUEANgIAIAAg +AkkNASAAIAJrIgAgA08NASAEIABBAnRqIAU2AgAgASACNgIQIAEgADYCDCABIAM2AgggASgCBCAB +IAQ2AgQgASgCACEAIAEgBjYCACAARQ0AIABBAnQQzwELDwsAC7kBAQF/QfmBwQAtAAAaAkBBDEEE +EMMBIgYEQCAGQQI2AgggBiADNgIAIAYgBCADayAFajYCBCABIAYgASgCACIBIAEgAkYiAhs2AgAg +AkUEQCABIAEoAggiAkEBajYCCCACQQBIDQIgACABNgIMIAAgBTYCCCAAIAQ2AgQgAEGAt8AANgIA +IAZBDBDPAQ8LIAAgBjYCDCAAIAU2AgggACAENgIEIABBgLfAADYCAA8LQQRBDBDqAQALAAuxAQEB +fyMAQRBrIgMkAAJAAkACQCAAKAIAIgBBAXEEQCABIABrIAJqIgFBARC2AUUNAiAAIAEQzwEMAQsg +ACAAKAIIIgFBAWs2AgggAUEBRw0AIAAoAgAgAEEEaigCACICQQEQtgFFDQIgAhDPASAAQQwQzwEL +IANBEGokAA8LQbS2wABBKyADQQ9qQaS2wABB4LbAABB9AAtBtLbAAEErIANBD2pBpLbAAEHwtsAA +EH0AC88DAgx/AX4jAEEgayIEJAAgBEEYaiIJEFYiBUEQaiIHKAIANgIAIARBEGoiCiAFQQhqIggp +AgA3AwAgB0EANgIAIAhCADcCACAFKQIAIQwgBUKAgICAwAA3AgAgBCAMNwMIAn8jAEEgayIDJAAC +QAJAIARBCGoiACgCDCIBIAAoAggiAkYEQAJAIAAoAgAiAiABRgRA0G9BgAEgASABQYABTRsiBvwP +ASICQX9GDQQCQCAAKAIQIgtFBEAgACACNgIQDAELIAEgC2ogAkcNBQsgASAGaiICQf////8BSw0E +IAMgAQR/IAMgAUECdDYCHCADIAAoAgQ2AhRBBAVBAAs2AhggA0EIakEEIAJBAnQgA0EUahB0IAMo +AghBAUYNBCADKAIMIQYgACACNgIAIAAgBjYCBAwBCyABIAJPDQMLIAAgAUEBaiICNgIIIAAoAgQg +AUECdGogAjYCAAwBCyABIAJPDQELIAAgACgCBCABQQJ0aigCADYCDCAAKAIQIANBIGokACABagwB +CwALIAggCikDADcCACAHIAkoAgA2AgAgBSgCBCEDIAUoAgAhASAFIAQpAwg3AgAgAQRAIAMgAUEC +dBDPAQsgBEEgaiQAC6wBAQF/IwBBEGsiBiQAAkAgAQRAIAZBBGogASADIAQgBSACKAIQEQgAAkAg +BigCBCICIAYoAgwiAU0EQCAGKAIIIQUMAQsgAkECdCECIAYoAgghAyABRQRAQQQhBSADIAIQzwEM +AQsgAyACQQQgAUECdCICELsBIgVFDQILIAAgATYCBCAAIAU2AgAgBkEQaiQADwtByLPAAEEyEOUB +AAtBBCACQbizwAAQtQEAC5oBAQR/IwBBIGsiAiQAQQggACgCACIEQQF0IgMgA0EITRsiA0EASARA +QQBBACABELUBAAsgAiAEBH8gAiAENgIcIAIgACgCBDYCFEEBBSAFCzYCGCACQQhqQQEgAyACQRRq +EHQgAigCCEEBRgRAIAIoAgwgAigCECABELUBAAsgAigCDCEBIAAgAzYCACAAIAE2AgQgAkEgaiQA +C6QBAQF/IwBBQGoiAiQAIAAoAgAhACACQgA3AzggAkE4aiAAJQEQJCACIAIoAjwiADYCNCACIAIo +Ajg2AjAgAiAANgIsIAIgAkEsaq1CgICAgOAIhDcDICACQQI2AgwgAkGcxMAANgIIIAJCATcCFCAC +IAJBIGo2AhAgASgCACABKAIEIAJBCGoQPCACKAIsIgEEQCACKAIwIAEQzwELIAJBQGskAAuPAQEB +fyACQQBOBEACfyADKAIEBEACQCADKAIIIgRFBEAMAQsgAygCACAEIAEgAhC7AQwCCwsgASACRQ0A +GkH5gcEALQAAGiACIAEQwwELIgNFBEAgACACNgIIIAAgATYCBCAAQQE2AgAPCyAAIAI2AgggACAD +NgIEIABBADYCAA8LIABBADYCBCAAQQE2AgALrQEBA38gASgCBCECAn8CQCABKAIIIgQgASgCACID +RwRAQfmBwQAtAAAaQQxBBBDDASIBDQFBBEEMEOoBAAsgBEUEQEEAIQFBASECQYi1wAAMAgsgAkEB +cQRAIAIhAUGQtsAADAILIAJBAXIhAUH8tcAADAELIAFBATYCCCABIAM2AgQgASACNgIAQYC3wAAL +IQMgACABNgIMIAAgBDYCCCAAIAI2AgQgACADNgIAC8ABAgV/AW8CQCABKAIAIgUQ8wEiA0EASA0A +AkAgA0UEQEEBIQQMAQtB+YHBAC0AABpBASECIANBARDDASIERQ0BCxAmIQcQcCIBIAcmASABIgYl +ARAfIQcQcCIBIAcmASABELoBIQIgAUGEAU8EQCABEG0LIAIlASAFJQEgBBAhIAJBhAFPBEAgAhBt +CyAGQYQBTwRAIAYQbQsgACAFEPMBNgIIIAAgBDYCBCAAIAM2AgAPCyACIANBuLLAABC1AQALlAEB +A38jAEEQayICJAACf0EBIAEoAgAiA0EnIAEoAgQiBCgCECIBEQAADQAaIAJBBGogACgCAEGBAhA1 +AkAgAi0ABEGAAUYEQCADIAIoAgggAREAAEUNAUEBDAILIAMgAi0ADiIAIAJBBGpqIAItAA8gAGsg +BCgCDBEBAEUNAEEBDAELIANBJyABEQAACyACQRBqJAALlQEBAn8CQCACQQBIDQAgAAJ/IAJFBEBB +iLXAACEDQQEhBEEADAELQfmBwQAtAAAaQQEhAyACQQEQwwEiBEUNASACBEAgBCABIAL8CgAACyAE +QQFxBEBBkLbAACEDIAQMAQtB/LXAACEDIARBAXILNgIMIAAgAjYCCCAAIAQ2AgQgACADNgIADwsg +AyACQfi0wAAQtQEAC3kCAX4CfyMAQYABayIEJAAgACkDACECQQAhAANAIAAgBGpB/wBqIAKnQQ9x +IgNBMHIgA0HXAGogA0EKSRs6AAAgAEEBayEAIAJCD1YgAkIEiCECDQALIAFBAUG268AAQQIgACAE +akGAAWpBACAAaxA2IARBgAFqJAALhAEBAX8CQCADQQBIDQACQCADRQRAQQEhAQwBC0H5gcEALQAA +GkEBIQQgA0EBEMMBIgFFDQELIAMEQCABIAIgA/wKAAALIAAgAzYCCCAAIAM2AgQgACABNgIAIABB +HUGBASADQQp2Z0ECdGsgA0H//wdLGzYCDA8LIAQgA0GIuMAAELUBAAujAQIEfwFvAkAgAS0ABARA +QQIhAwwBCyABKAIAJQEQFCEGEHAiAiAGJgFB0ILBACgCACEEQcyCwQAoAgBBzILBAEIANwIAQQEh +A0EBRgRAIAFBAToABAwBCwJ/IAIlARAVRQRAIAIlARAWIQYQcCIBIAYmASABIQRBAAwBCyABQQE6 +AARBAgshAyACQYQBSQ0AIAIQbQsgACAENgIEIAAgAzYCAAt6AQF/IwBBIGsiAiQAAn8gACgCAEGA +gICAeEcEQCABIAAoAgQgACgCCBC/AQwBCyACQRBqIAAoAgwoAgAiAEEIaikCADcDACACQRhqIABB +EGopAgA3AwAgAiAAKQIANwMIIAEoAgAgASgCBCACQQhqEDwLIAJBIGokAAt8AQF/IwBBQGoiBSQA +IAUgATYCDCAFIAA2AgggBSADNgIUIAUgAjYCECAFQQI2AhwgBUGE68AANgIYIAVCAjcCJCAFIAVB +EGqtQoCAgIDwC4Q3AzggBSAFQQhqrUKAgICAgAyENwMwIAUgBUEwajYCICAFQRhqIAQQoQEAC3AB +AX8jAEEQayIBJAAgACgCACIAIAAoAggiAkEBazYCCAJAIAJBAUYEQCAAKAIAIABBBGooAgAiA0EB +ELYBRQ0BIAMQzwEgAEEMEM8BCyABQRBqJAAPC0G0tsAAQSsgAUEPakGktsAAQfC2wAAQfQALzQIB +A38jAEEwayIDJAAgAyACNgIEIAMgATYCACADQQI2AgwgA0HwkcAANgIIIANCAjcCFCADIAOtQoCA +gIDQAoQ3AyggAyAArUKAgICA8AGENwMgIAMgA0EgajYCEAJ/IwBBEGsiAiQAIANBCGoiACgCDCEB +AkACfwJAAkACQAJAAkAgACgCBA4CAAECCyABDQFBASEFQQAhAEEBIQEMAwsgAUUNAQsgAkEEaiAA +EEcgAigCDCEAIAIoAgghASACKAIEDAILIAAoAgAiASgCBCIAQQBIDQIgASgCACEFIABFBEBBASEB +QQAhAAwBC0H5gcEALQAAGkEBIQQgAEEBEMMBIgFFDQILIAAEQCABIAUgAPwKAAALIAALIQQgASAA +ELkBIAQEQCABIAQQzwELIAJBEGokAAwBCyAEIABB9JLAABC1AQALIANBMGokAAtqAgF/AX4jAEEw +ayIDJAAgAyABNgIEIAMgADYCACADQQI2AgwgA0HQ6cAANgIIIANCAjcCFCADQoCAgICACSIEIAOt +hDcDKCADIAQgA0EEaq2ENwMgIAMgA0EgajYCECADQQhqIAIQoQEAC2gBAX8CQCADQQBIDQACQCAD +RQRAQQEhAQwBC0H5gcEALQAAGkEBIQQgA0EBEMMBIgFFDQELIAMEQCABIAIgA/wKAAALIAAgAzYC +CCAAIAE2AgQgACADNgIADwsgBCADQfi0wAAQtQEAC2kAIwBBMGsiACQAQfiBwQAtAABFBEAgAEEw +aiQADwsgAEECNgIMIABBzMfAADYCCCAAQgE3AhQgACABNgIsIAAgAEEsaq1CgICAgIAJhDcDICAA +IABBIGo2AhAgAEEIakH0x8AAEKEBAAucAgIDfwF+IwBBEGsiASQAIAFBqILBADYCBCAAQbCCwQAt +AABBA0cEfyABIAFBBGo2AgggASABQQhqNgIMIAFBDGohAiMAQSBrIgAkAAJAAkACQAJAAkACQAJA +QbCCwQAtAABBAWsOAwIEAQALQbCCwQBBAjoAACACKAIAIgMoAgAhAiADQQA2AgAgAkUNAiACKAIA +QoAINwMAQbCCwQBBAzoAAAsgAEEgaiQADAQLIABBADYCGCAAQQE2AgwgAEG4rMAANgIIDAILQfyt +wAAQ1wEACyAAQQA2AhggAEEBNgIMIABB+KzAADYCCAsgAEIENwIQIABBCGpB+K7AABChAQALIAEo +AgQFQaiCwQALKQMAELEBIAFBEGokAFALWQECfyMAQRBrIgIkACAAQQRqIQMCfyAAKAIAQQFGBEAg +AiADNgIMIAFBqoPAAEEDIAJBDGoQYQwBCyACIAM2AgggAUGog8AAQQIgAkEIahBhCyACQRBqJAAL +XgEBfyMAQTBrIgIkACACIAE2AgwgAiAANgIIIAJBAjYCFCACQeyOwAA2AhAgAkIBNwIcIAIgAkEI +aq1CgICAgIAChDcDKCACIAJBKGo2AhggAkEQahBjIAJBMGokAAteAQF/IwBBMGsiAiQAIAIgATYC +DCACIAA2AgggAkECNgIUIAJBkI/AADYCECACQgE3AhwgAiACQQhqrUKAgICAgAKENwMoIAIgAkEo +ajYCGCACQRBqEGMgAkEwaiQAC1sBAX8gASgCACIEQQFxBEAgACABIAQgBEF+cSACIAMQbg8LIAQg +BCgCCCIBQQFqNgIIIAFBAE4EQCAAIAQ2AgwgACADNgIIIAAgAjYCBCAAQYC3wAA2AgAPCwALWAEB +fyABKAIAIgRBAXEEQCAAIAEgBCAEIAIgAxBuDwsgBCAEKAIIIgFBAWo2AgggAUEATgRAIAAgBDYC +DCAAIAM2AgggACACNgIEIABBgLfAADYCAA8LAAtOACMAQSBrIgAkACAAQQE2AgQgAEGovcAANgIA +IABCATcCDCAAQpC9wICgBzcDGCAAIABBGGo2AgggASgCACABKAIEIAAQPCAAQSBqJAALSwAgASgC +ACIBQQFxBEAgAUF+cSEBIAMEQCABIAIgA/wKAAALIAAgAzYCCCAAIAE2AgQgACACIANqIAFrNgIA +DwsgACABIAIgAxBbC0sBAX8gACgCACAAKAIIIgNrIAJJBEAgACADIAJBAUEBEFcgACgCCCEDCyAC +BEAgACgCBCADaiABIAL8CgAACyAAIAIgA2o2AghBAAtHAQF/IAAoAgAgACgCCCIDayACSQRAIAAg +AyACEF8gACgCCCEDCyACBEAgACgCBCADaiABIAL8CgAACyAAIAIgA2o2AghBAAtNAQF/IwBBMGsi +ASQAIAFBATYCDCABQejowAA2AgggAUIBNwIUIAEgAUEvaq1CgICAgOALhDcDICABIAFBIGo2AhAg +AUEIaiAAEKEBAAtEACABKAIAIgFBAXEEQCADBEAgASACIAP8CgAACyAAIAM2AgggACABNgIEIAAg +AiADaiABazYCAA8LIAAgASACIAMQWws6AQF/IwBBIGsiACQAIABBADYCGCAAQQE2AgwgAEH4yMAA +NgIIIABCBDcCECAAQQhqQazJwAAQoQEAC0cBAX8gACgCACAAKAIIIgNrIAJJBEAgACADIAIQaCAA +KAIIIQMLIAIEQCAAKAIEIANqIAEgAvwKAAALIAAgAiADajYCCEEAC0EBAn8jAEEQayICJAAgAkEI +aiAAKAIAJQEQCyACKAIIIgMgAigCDCIAIAEQ7AEgAARAIAMgABDPAQsgAkEQaiQAC08BAn8gACgC +BCECIAAoAgAhAwJAIAAoAggiAC0AAEUNACADQazrwABBBCACKAIMEQEARQ0AQQEPCyAAIAFBCkY6 +AAAgAyABIAIoAhARAAALQgEBfyAAKAIAIgAoAjAiAQRAIAAoAjQgARDPAQsCQCAAQX9GDQAgACAA +KAIEQQFrIgE2AgQgAQ0AIABByAAQzwELC08BAn9B+YHBAC0AABogASgCBCECIAEoAgAhA0EIQQQQ +wwEiAUUEQEEEQQgQ6gEACyABIAI2AgQgASADNgIAIABBlMjAADYCBCAAIAE2AgALnnQDI38afgF8 +IAEoAggiA0GAgIABcSECIAArAwAhPyADQYCAgIABcUUEQCABIAJBAEchAUEAIQAjAEGAAWsiByQA +ID+9ISUCf0EDID+ZRAAAAAAAAPB/YQ0AGkECICVCgICAgICAgPj/AIMiJkKAgICAgICA+P8AUQ0A +GiAlQv////////8HgyIpQoCAgICAgIAIhCAlQgGGQv7///////8PgyAlQjSIp0H/D3EiABsiJ0IB +gyEoICZQBEBBBCApUA0BGiAAQbMIayEAQgEhJiAoUAwBC0KAgICAgICAICAnQgGGICdCgICAgICA +gAhRIgIbISdCAkIBIAIbISZBy3dBzHcgAhsgAGohACAoUAshAiAHIAA7AXggByAmNwNwIAdCATcD +aCAHICc3A2AgByACOgB6An8CQAJAAkAgAkECayICBEBBASEAQfPnwABB9OfAACAlQgBTIgMbQfPn +wABBASADGyABGyEXICVCP4inIAFyIRtBAyACIAJBA08bQQJrDgIDAgELIAdBAzYCKCAHQfXnwAA2 +AiQgB0ECOwEgQQEhF0EBIQAgB0EgagwDCyAHQQM2AiggB0H458AANgIkIAdBAjsBICAHQSBqDAIL +IAdBIGohBiAHQQ9qIQwjAEEwayIDJAACQAJAAn8CQAJAAkACQAJAAkACQAJAIAdB4ABqIgApAwAi +JVBFBEAgACkDCCInUA0BIAApAxAiJlANAiAlICZ8IiYgJVQNAyAlICdUDQQgJkKAgICAgICAgCBa +DQUgAyAALwEYIgA7AQggAyAlICd9Iic3AwAgACAAQSBrIAAgJkKAgICAEFQiARsiAkEQayACICZC +IIYgJiABGyImQoCAgICAgMAAVCIBGyICQQhrIAIgJkIQhiAmIAEbIiZCgICAgICAgIABVCIBGyIC +QQRrIAIgJkIIhiAmIAEbIiZCgICAgICAgIAQVCIBGyICQQJrIAIgJkIEhiAmIAEbIiZCgICAgICA +gIDAAFQiARsgJkIChiAmIAEbIihCAFkiAmsiAWvBIgpBAEgNBiADQn8gCq0iKYgiJiAngzcDECAm +ICdUDQogAyAAOwEIIAMgJTcDACADICUgJoM3AxAgJSAmVg0KQaB/IAFrwUHQAGxBsKcFakHOEG0i +AEHRAE8NByAAQQR0IgBBuNjAAGopAwAiKkL/////D4MiJiAlIClCP4MiJYYiK0IgiCI1fiIsQiCI +IjEgKkIgiCIpIDV+IjJ8ICkgK0L/////D4MiKn4iK0IgiCI2fCEzICxC/////w+DICYgKn5CIIh8 +ICtC/////w+DfCI3QoCAgIAIfEIgiCErQgFBACABIABBwNjAAGovAQBqa0E/ca0iLIYiKkIBfSEu +ICYgJyAlhiIlQiCIIid+Ii1C/////w+DICYgJUL/////D4MiJX5CIIh8ICUgKX4iJUL/////D4N8 +Ij5CgICAgAh8QiCIITQgJyApfiE4ICVCIIghOSAtQiCIITogAEHC2MAAai8BACEBICkgKCACrYYi +JUIgiCI7fiI8ICYgO34iJ0IgiCIvfCApICVC/////w+DIiV+IihCIIgiMHwgJ0L/////D4MgJSAm +fkIgiHwgKEL/////D4N8Ij1CgICAgAh8QiCIfEIBfCItICyIpyIAQZDOAE8EQCAAQcCEPUkNCSAA +QYDC1y9PBEBBCEEJIABBgJTr3ANJIgIbIQpBgMLXL0GAlOvcAyACGwwLC0EGQQcgAEGAreIESSIC +GyEKQcCEPUGAreIEIAIbDAoLIABB5ABPBEBBAkEDIABB6AdJIgIbIQpB5ABB6AcgAhsMCgtBCkEB +IABBCUsiChsMCQtBj9TAAEEcQYjjwAAQlgEAC0G81MAAQR1BmOPAABCWAQALQezUwABBHEGo48AA +EJYBAAtB0NbAAEE2QcjkwAAQlgEAC0GI1sAAQTdBuOTAABCWAQALQcjjwABBLUH448AAEJYBAAtB +49HAAEEdQaTSwAAQlgEACyAAQdEAQfjiwAAQgAEAC0EEQQUgAEGgjQZJIgIbIQpBkM4AQaCNBiAC +GwshAiArIDN8ITMgLSAugyEmIAogAWtBAWohBSAtIDggOnwgOXwgNHx9IjRCAXwiKCAugyEnQQAh +AQJAAkACQAJAAkACQAJAAkADQCAAIAJuIQsgAUERRg0CIAEgDGoiDiALQTBqIg06AAACQCAAIAIg +C2xrIgCtICyGIisgJnwiJSAoWgRAIAEgCkcNASABQQFqIQFCASElA0AgJSEoICchKSABQRFPDQYg +ASAMaiAmQgp+IiYgLIinQTBqIgI6AAAgAUEBaiEBICVCCn4hJSAnQgp+IicgJiAugyImWA0ACyAl +IC0gM31+IiwgJXwhKyAnICZ9ICpUIgANByAsICV9IiwgJlYNAwwHCyAoICV9IicgAq0gLIYiKFQh +AiAtIDN9IixCAXwhKiAnIChUICUgLEIBfSIsWnINBSA9QoCAgIAIfEIgiCItIC8gMHx8IDx8ISdC +AiA5IDp8ID5CgICAgAh8QiCIfCA4fCAmICh8IiUgK3x8fSEuQgAgMSA2fCA3QoCAgIAIfEIgiHwi +MSAyfCAmICt8fH0hMiAlIDF8ICkgNSA7fX58IC99IDB9IC19ISkDQCAlICt8Ii8gLFQgJyAyfCAp +ICt8WnJFBEAgJiArfCElQQAhAgwHCyAOIA1BAWsiDToAACAmICh8ISYgJyAufCEtICwgL1YEQCAo +ICl8ISkgJSAofCElICcgKH0hJyAoIC1YDQELCyAoIC1WIQIgJiArfCElDAULIAFBAWohASACQQpJ +IAJBCm4hAkUNAAtBiOTAABCcAQALIAEgDGpBAWshCiAqIDEgNnwgN0KAgICACHxCIIh8IDJ8Qgp+ +IC8gMHwgPUKAgICACHxCIIh8IDx8Qgp+fSAofnwhLSApQgp+ICYgKnx9IS4gLCAmfSEvQgAhKQNA +ICYgKnwiJSAsVCApIC98ICYgLXxackUEQEEAIQAMBQsgCiACQQFrIgI6AAAgKSAufCIwICpUIQAg +JSAsWg0FICkgKn0hKSAlISYgKiAwWA0ACwwEC0ERQRFBmOTAABCAAQALIAFBEUGo5MAAEIABAAsC +QCAlICpaIAJyDQAgKiAlICh8IiZYICogJX0gJiAqfVRxDQAgBkEANgIADAQLICUgNEIDfVggJUIC +WnFFBEAgBkEANgIADAQLIAYgBTsBCCAGIAFBAWo2AgQMAgsgJiElCwJAICUgK1ogAHINACArICUg +KnwiJlggKyAlfSAmICt9VHENACAGQQA2AgAMAgsgJSAoQlh+ICd8WCAlIChCFH5acUUEQCAGQQA2 +AgAMAgsgBiAFOwEIIAYgATYCBAsgBiAMNgIACyADQTBqJAAMAQsgA0EANgIYIwBBEGsiACQAIAAg +AzYCDCAAIANBEGo2AgggAEEIakHg6cAAIABBDGpB4OnAACADQRhqQbTSwAAQUAALAkAgBygCIARA +IAdB2ABqIAdBKGooAgA2AgAgByAHKQIgNwNQDAELIAdB0ABqIQ8gB0EPaiENIwBBoAprIgEkAAJA +AkACQAJAAkACQAJAAkAgB0HgAGoiACkDACIlUEUEQCAAKQMIIiZQRQRAIAApAxAiJ1BFBEAgJSAl +ICd8IihYBEAgJSAmWgRAIAAsABohGCAALgEYIQAgASAlPgIAIAFBAUECICVCgICAgBBUIgIbNgKg +ASABQQAgJUIgiKcgAhs2AgQgAUEIakEAQZgB/AsAIAEgJj4CpAEgAUEBQQIgJkKAgICAEFQiAhs2 +AsQCIAFBACAmQiCIpyACGzYCqAEgAUGsAWpBAEGYAfwLACABICc+AsgCIAFBAUECICdCgICAgBBU +IgIbNgLoAyABQQAgJ0IgiKcgAhs2AswCIAFB0AJqQQBBmAH8CwAgAUHwA2pBAEGcAfwLACABQQE2 +AuwDIAFBATYCjAUgAKwgKEIBfXl9QsKawegEfkKAoc2gtAJ8QiCIpyICwSEOAkAgAEEATgRAIAEg +ABAtGiABQaQBaiAAEC0aIAFByAJqIAAQLRoMAQsgAUHsA2pBACAAa8EQLRoLAkAgDkEASARAIAFB +ACAOa0H//wNxIgAQKyABQaQBaiAAECsgAUHIAmogABArDAELIAFB7ANqIAJB//8BcRArCyABKAKg +ASEDIAFB/AhqIAFBoAH8CgAAIAEgAzYCnAoCQAJAAkACQCABKALoAyIGIAMgAyAGSRsiAkEoTQRA +IAJFBEBBACECDAQLIAJBAXEhCyACQQFHDQEMAgsMDAsgAkE+cSERIAFB/AhqIQAgAUHIAmohBQNA +IAAgCCAAKAIAIhIgBSgCAGoiCmoiCDYCACAAQQRqIgwgDCgCACITIAVBBGooAgBqIgwgCiASSSAI +IApJcmoiCjYCACAMIBNJIAogDElyIQggBUEIaiEFIABBCGohACARIAlBAmoiCUcNAAsLIAsEfyAJ +QQJ0IgAgAUH8CGpqIgogCigCACIKIAFByAJqIABqKAIAaiIAIAhqIgk2AgAgACAKSSAAIAlLcgUg +CAtFDQAgAkEoRg0BIAFB/AhqIAJBAnRqQQE2AgAgAkEBaiECCyABIAI2ApwKIAIgASgCjAUiCSAC +IAlLGyIAQSlJBEAgAEECdCEAAkACQAJ/AkADQCAARQ0BIABBBGsiACABQewDamooAgAiAiAAIAFB +/AhqaigCACIKRg0ACyACIApLIAIgCklrDAELQX9BACAAGwsgGE4EQAJAIANFBEBBACEDDAELIANB +AWtB/////wNxIgBBAWoiAkEDcSEFAkAgAEEDSQRAIAEhAEIAISUMAQsgAkH8////B3EhCiABIQBC +ACElA0AgACAANQIAQgp+ICV8IiU+AgAgAEEEaiICIAI1AgBCCn4gJUIgiHwiJT4CACAAQQhqIgIg +AjUCAEIKfiAlQiCIfCIlPgIAIABBDGoiAiACNQIAQgp+ICVCIIh8IiY+AgAgJkIgiCElIABBEGoh +ACAKQQRrIgoNAAsLIAUEQANAIAAgADUCAEIKfiAlfCImPgIAIABBBGohACAmQiCIISUgBUEBayIF +DQALCyAmQoCAgIAQVA0AIANBKEYNAyABIANBAnRqICU+AgAgA0EBaiEDCyABIAM2AqABIAEoAsQC +IgJBKU8NDSABAn9BACACRQ0AGiACQQFrQf////8DcSIAQQFqIgNBA3EhBQJAIABBA0kEQCABQaQB +aiEAQgAhJQwBCyADQfz///8HcSEKIAFBpAFqIQBCACElA0AgACAANQIAQgp+ICV8IiU+AgAgAEEE +aiIDIAM1AgBCCn4gJUIgiHwiJT4CACAAQQhqIgMgAzUCAEIKfiAlQiCIfCIlPgIAIABBDGoiAyAD +NQIAQgp+ICVCIIh8IiY+AgAgJkIgiCElIABBEGohACAKQQRrIgoNAAsLIAUEQANAIAAgADUCAEIK +fiAlfCImPgIAIABBBGohACAmQiCIISUgBUEBayIFDQALCyACICZCgICAgBBUDQAaIAJBKEYNESAB +QaQBaiACQQJ0aiAlPgIAIAJBAWoLNgLEAiABIAYEfyAGQQFrQf////8DcSIAQQFqIgJBA3EhBQJA +IABBA0kEQCABQcgCaiEAQgAhJQwBCyACQfz///8HcSEKIAFByAJqIQBCACElA0AgACAANQIAQgp+ +ICV8IiU+AgAgAEEEaiICIAI1AgBCCn4gJUIgiHwiJT4CACAAQQhqIgIgAjUCAEIKfiAlQiCIfCIl +PgIAIABBDGoiAiACNQIAQgp+ICVCIIh8IiY+AgAgJkIgiCElIABBEGohACAKQQRrIgoNAAsLIAUE +QANAIAAgADUCAEIKfiAlfCImPgIAIABBBGohACAmQiCIISUgBUEBayIFDQALCyAmQoCAgIAQVARA +IAEgBjYC6AMMAwsgBkEoRg0RIAFByAJqIAZBAnRqICU+AgAgBkEBagVBAAs2AugDDAELIA5BAWoh +DgsgAUGQBWoiAiABQewDaiIAQaAB/AoAACABIAk2ArAGIAJBARAtIR0gASgCjAUhAiABQbQGaiID +IABBoAH8CgAAIAEgAjYC1AcgA0ECEC0hHiABKAKMBSECIAFB2AdqIgMgAEGgAfwKAAAgASACNgL4 +CCADQQMQLSEfAkACQAJAAkACQAJAIAEoAvgIIhIgASgCoAEiCSAJIBJJGyICQShNBEAgAUGMBWoh +ICABQbAGaiEhIAFB1AdqISIgASgCjAUhESABKAKwBiETIAEoAtQHIRlBACEGA0AgBiEKIAJBAnQh +AAJ/AkACQAJAA0AgAEUNASAAICJqIQMgAEEEayIAIAFqKAIAIgYgAygCACIDRg0ACyADIAZLDQEM +AgsgAEUNAQsgCSECQQAMAQsgAgRAQQEhCEEAIQkgAkEBRwRAIAJBPnEhDCABIgBB2AdqIQUDQCAA +IAggACgCACILIAUoAgBBf3NqIgNqIgg2AgAgAEEEaiIGIAYoAgAiECAFQQRqKAIAQX9zaiIGIAMg +C0kgAyAIS3JqIgM2AgAgBiAQSSADIAZJciEIIAVBCGohBSAAQQhqIQAgDCAJQQJqIglHDQALCyAC +QQFxBH8gASAJQQJ0IgBqIgMgAygCACIDIAAgH2ooAgBBf3NqIgAgCGoiBjYCACAAIANJIAAgBkty +BSAIC0UNFgsgASACNgKgAUEICyELIBkgAiACIBlJGyIGQSlPDQMgBkECdCEAAkACQAJAA0AgAEUN +ASAAICFqIQMgAEEEayIAIAFqKAIAIgkgAygCACIDRg0ACyADIAlNDQEgAiEGDAILIABFDQAgAiEG +DAELIAYEQEEBIQhBACEJIAZBAUcEQCAGQT5xIQwgASIAQbQGaiEFA0AgACAIIAAoAgAiECAFKAIA +QX9zaiICaiIINgIAIABBBGoiAyADKAIAIhQgBUEEaigCAEF/c2oiAyACIBBJIAIgCEtyaiICNgIA +IAMgFEkgAiADSXIhCCAFQQhqIQUgAEEIaiEAIAwgCUECaiIJRw0ACwsgBkEBcQR/IAEgCUECdCIA +aiICIAIoAgAiAiAAIB5qKAIAQX9zaiIAIAhqIgM2AgAgACACSSAAIANLcgUgCAtFDRYLIAEgBjYC +oAEgC0EEciELCyATIAYgBiATSRsiA0EpTw0EIANBAnQhAAJAAkACQANAIABFDQEgACAgaiECIABB +BGsiACABaigCACIJIAIoAgAiAkYNAAsgAiAJTQ0BIAYhAwwCCyAARQ0AIAYhAwwBCyADBEBBASEI +QQAhCSADQQFHBEAgA0E+cSEMIAEiAEGQBWohBQNAIAAgCCAAKAIAIhAgBSgCAEF/c2oiAmoiCDYC +ACAAQQRqIgYgBigCACIUIAVBBGooAgBBf3NqIgYgAiAQSSACIAhLcmoiAjYCACAGIBRJIAIgBkly +IQggBUEIaiEFIABBCGohACAMIAlBAmoiCUcNAAsLIANBAXEEfyABIAlBAnQiAGoiAiACKAIAIgIg +ACAdaigCAEF/c2oiACAIaiIGNgIAIAAgAkkgACAGS3IFIAgLRQ0WCyABIAM2AqABIAtBAmohCwsg +ESADIAMgEUkbIgJBKU8NEyACQQJ0IQACQAJAAkADQCAARQ0BIABBBGsiACABaigCACIGIAAgAUHs +A2pqKAIAIglGDQALIAYgCU8NASADIQIMAgsgAEUNACADIQIMAQsgAgRAQQEhCEEAIQkgAkEBRwRA +IAJBPnEhDCABIgBB7ANqIQUDQCAAIAggACgCACIQIAUoAgBBf3NqIgNqIgg2AgAgAEEEaiIGIAYo +AgAiFCAFQQRqKAIAQX9zaiIGIAMgEEkgAyAIS3JqIgM2AgAgBiAUSSADIAZJciEIIAVBCGohBSAA +QQhqIQAgDCAJQQJqIglHDQALCyACQQFxBH8gASAJQQJ0IgBqIgMgAygCACIDIAFB7ANqIABqKAIA +QX9zaiIAIAhqIgY2AgAgACADSSAAIAZLcgUgCAtFDRYLIAEgAjYCoAEgC0EBaiELCyAKQRFGDQYg +CiANaiALQTBqOgAAIAEoAsQCIgwgAiACIAxJGyIAQSlPDRUgCkEBaiEGIABBAnQhAAJ/AkADQCAA +RQ0BIABBBGsiACABaigCACIDIAAgAUGkAWpqKAIAIglGDQALIAMgCUsgAyAJSWsMAQtBf0EAIAAb +CyEUIAFB/AhqIAFBoAH8CgAAIAEgAjYCnAogASgC6AMiCyACIAIgC0kbIgNBKEsNBQJAIANFBEBB +ACEDDAELQQAhCEEAIQkgA0EBRwRAIANBPnEhIyABQfwIaiEAIAFByAJqIQUDQCAAIAggACgCACIk +IAUoAgBqIhBqIhU2AgAgAEEEaiIIIAgoAgAiFiAFQQRqKAIAaiIIIBAgJEkgECAVS3JqIhA2AgAg +CCAWSSAIIBBLciEIIAVBCGohBSAAQQhqIQAgIyAJQQJqIglHDQALCyADQQFxBH8gCUECdCIAIAFB +/AhqaiIJIAkoAgAiCSABQcgCaiAAaigCAGoiACAIaiIFNgIAIAAgCUkgACAFS3IFIAgLRQ0AIANB +KEYNFyABQfwIaiADQQJ0akEBNgIAIANBAWohAwsgASADNgKcCiADIBEgAyARSxsiAEEpTw0VIABB +AnQhAAJ/AkADQCAARQ0BIABBBGsiACABQewDamooAgAiAyAAIAFB/AhqaigCACIJRg0ACyADIAlL +IAMgCUlrDAELQX9BACAAGwsgGE4iACAUIBhIIgNFcUUEQCAADRMgAw0DDBILQQAhAyABAn9BACAC +RQ0AGiACQQFrQf////8DcSIAQQFqIgpBA3EhBQJAIABBA0kEQCABIQBCACElDAELIApB/P///wdx +IQogASEAQgAhJQNAIAAgADUCAEIKfiAlfCIlPgIAIABBBGoiCSAJNQIAQgp+ICVCIIh8IiU+AgAg +AEEIaiIJIAk1AgBCCn4gJUIgiHwiJT4CACAAQQxqIgkgCTUCAEIKfiAlQiCIfCImPgIAICZCIIgh +JSAAQRBqIQAgCkEEayIKDQALCyAFBEADQCAAIAA1AgBCCn4gJXwiJj4CACAAQQRqIQAgJkIgiCEl +IAVBAWsiBQ0ACwsgAiAmQoCAgIAQVA0AGiACQShGDRcgASACQQJ0aiAlPgIAIAJBAWoLIgk2AqAB +AkAgDEUNACAMQQFrQf////8DcSIAQQFqIgJBA3EhBQJAIABBA0kEQCABQaQBaiEAQgAhJQwBCyAC +Qfz///8HcSEKIAFBpAFqIQBCACElA0AgACAANQIAQgp+ICV8IiU+AgAgAEEEaiICIAI1AgBCCn4g +JUIgiHwiJT4CACAAQQhqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIABBDGoiAiACNQIAQgp+ICVCIIh8 +IiY+AgAgJkIgiCElIABBEGohACAKQQRrIgoNAAsLIAUEQANAIAAgADUCAEIKfiAlfCImPgIAIABB +BGohACAmQiCIISUgBUEBayIFDQALCyAmQoCAgIAQVARAIAwhAwwBCyAMQShGDRcgAUGkAWogDEEC +dGogJT4CACAMQQFqIQMLIAEgAzYCxAICQCALRQRAQQAhCwwBCyALQQFrQf////8DcSIAQQFqIgJB +A3EhBQJAIABBA0kEQCABQcgCaiEAQgAhJQwBCyACQfz///8HcSEKIAFByAJqIQBCACElA0AgACAA NQIAQgp+ICV8IiU+AgAgAEEEaiICIAI1AgBCCn4gJUIgiHwiJT4CACAAQQhqIgIgAjUCAEIKfiAl QiCIfCIlPgIAIABBDGoiAiACNQIAQgp+ICVCIIh8IiY+AgAgJkIgiCElIABBEGohACAKQQRrIgoN AAsLIAUEQANAIAAgADUCAEIKfiAlfCImPgIAIABBBGohACAmQiCIISUgBUEBayIFDQALCyAmQoCA -gIAQVA0AIANBKEYNAyABIANBAnRqICU+AgAgA0EBaiEDCyABIAM2AqABIAEoAsQCIgJBKU8NDSAB -An9BACACRQ0AGiACQQFrQf////8DcSIAQQFqIgNBA3EhBQJAIABBA0kEQCABQaQBaiEAQgAhJQwB -CyADQfz///8HcSEKIAFBpAFqIQBCACElA0AgACAANQIAQgp+ICV8IiU+AgAgAEEEaiIDIAM1AgBC -Cn4gJUIgiHwiJT4CACAAQQhqIgMgAzUCAEIKfiAlQiCIfCIlPgIAIABBDGoiAyADNQIAQgp+ICVC -IIh8IiY+AgAgJkIgiCElIABBEGohACAKQQRrIgoNAAsLIAUEQANAIAAgADUCAEIKfiAlfCImPgIA -IABBBGohACAmQiCIISUgBUEBayIFDQALCyACICZCgICAgBBUDQAaIAJBKEYNESABQaQBaiACQQJ0 -aiAlPgIAIAJBAWoLNgLEAiABIAYEfyAGQQFrQf////8DcSIAQQFqIgJBA3EhBQJAIABBA0kEQCAB -QcgCaiEAQgAhJQwBCyACQfz///8HcSEKIAFByAJqIQBCACElA0AgACAANQIAQgp+ICV8IiU+AgAg -AEEEaiICIAI1AgBCCn4gJUIgiHwiJT4CACAAQQhqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIABBDGoi -AiACNQIAQgp+ICVCIIh8IiY+AgAgJkIgiCElIABBEGohACAKQQRrIgoNAAsLIAUEQANAIAAgADUC -AEIKfiAlfCImPgIAIABBBGohACAmQiCIISUgBUEBayIFDQALCyAmQoCAgIAQVARAIAEgBjYC6AMM -AwsgBkEoRg0RIAFByAJqIAZBAnRqICU+AgAgBkEBagVBAAs2AugDDAELIA5BAWohDgsgAUGQBWoi -AiABQewDaiIAQaAB/AoAACABIAk2ArAGIAJBARAtIR0gASgCjAUhAiABQbQGaiIDIABBoAH8CgAA -IAEgAjYC1AcgA0ECEC0hHiABKAKMBSECIAFB2AdqIgMgAEGgAfwKAAAgASACNgL4CCADQQMQLSEf -AkACQAJAAkACQAJAIAEoAvgIIhIgASgCoAEiCSAJIBJJGyICQShNBEAgAUGMBWohICABQbAGaiEh -IAFB1AdqISIgASgCjAUhESABKAKwBiETIAEoAtQHIRlBACEGA0AgBiEKIAJBAnQhAAJ/AkACQAJA -A0AgAEUNASAAICJqIQMgAEEEayIAIAFqKAIAIgYgAygCACIDRg0ACyADIAZLDQEMAgsgAEUNAQsg -CSECQQAMAQsgAgRAQQEhCEEAIQkgAkEBRwRAIAJBPnEhDCABIgBB2AdqIQUDQCAAIAggACgCACIL -IAUoAgBBf3NqIgNqIgg2AgAgAEEEaiIGIAYoAgAiECAFQQRqKAIAQX9zaiIGIAMgC0kgAyAIS3Jq -IgM2AgAgBiAQSSADIAZJciEIIAVBCGohBSAAQQhqIQAgDCAJQQJqIglHDQALCyACQQFxBH8gASAJ -QQJ0IgBqIgMgAygCACIDIAAgH2ooAgBBf3NqIgAgCGoiBjYCACAAIANJIAAgBktyBSAIC0UNFgsg -ASACNgKgAUEICyELIBkgAiACIBlJGyIGQSlPDQMgBkECdCEAAkACQAJAA0AgAEUNASAAICFqIQMg -AEEEayIAIAFqKAIAIgkgAygCACIDRg0ACyADIAlNDQEgAiEGDAILIABFDQAgAiEGDAELIAYEQEEB -IQhBACEJIAZBAUcEQCAGQT5xIQwgASIAQbQGaiEFA0AgACAIIAAoAgAiECAFKAIAQX9zaiICaiII -NgIAIABBBGoiAyADKAIAIhQgBUEEaigCAEF/c2oiAyACIBBJIAIgCEtyaiICNgIAIAMgFEkgAiAD -SXIhCCAFQQhqIQUgAEEIaiEAIAwgCUECaiIJRw0ACwsgBkEBcQR/IAEgCUECdCIAaiICIAIoAgAi -AiAAIB5qKAIAQX9zaiIAIAhqIgM2AgAgACACSSAAIANLcgUgCAtFDRYLIAEgBjYCoAEgC0EEciEL -CyATIAYgBiATSRsiA0EpTw0EIANBAnQhAAJAAkACQANAIABFDQEgACAgaiECIABBBGsiACABaigC -ACIJIAIoAgAiAkYNAAsgAiAJTQ0BIAYhAwwCCyAARQ0AIAYhAwwBCyADBEBBASEIQQAhCSADQQFH -BEAgA0E+cSEMIAEiAEGQBWohBQNAIAAgCCAAKAIAIhAgBSgCAEF/c2oiAmoiCDYCACAAQQRqIgYg -BigCACIUIAVBBGooAgBBf3NqIgYgAiAQSSACIAhLcmoiAjYCACAGIBRJIAIgBklyIQggBUEIaiEF -IABBCGohACAMIAlBAmoiCUcNAAsLIANBAXEEfyABIAlBAnQiAGoiAiACKAIAIgIgACAdaigCAEF/ -c2oiACAIaiIGNgIAIAAgAkkgACAGS3IFIAgLRQ0WCyABIAM2AqABIAtBAmohCwsgESADIAMgEUkb -IgJBKU8NEyACQQJ0IQACQAJAAkADQCAARQ0BIABBBGsiACABaigCACIGIAAgAUHsA2pqKAIAIglG -DQALIAYgCU8NASADIQIMAgsgAEUNACADIQIMAQsgAgRAQQEhCEEAIQkgAkEBRwRAIAJBPnEhDCAB -IgBB7ANqIQUDQCAAIAggACgCACIQIAUoAgBBf3NqIgNqIgg2AgAgAEEEaiIGIAYoAgAiFCAFQQRq -KAIAQX9zaiIGIAMgEEkgAyAIS3JqIgM2AgAgBiAUSSADIAZJciEIIAVBCGohBSAAQQhqIQAgDCAJ -QQJqIglHDQALCyACQQFxBH8gASAJQQJ0IgBqIgMgAygCACIDIAFB7ANqIABqKAIAQX9zaiIAIAhq -IgY2AgAgACADSSAAIAZLcgUgCAtFDRYLIAEgAjYCoAEgC0EBaiELCyAKQRFGDQYgCiANaiALQTBq -OgAAIAEoAsQCIgwgAiACIAxJGyIAQSlPDRUgCkEBaiEGIABBAnQhAAJ/AkADQCAARQ0BIABBBGsi -ACABaigCACIDIAAgAUGkAWpqKAIAIglGDQALIAMgCUsgAyAJSWsMAQtBf0EAIAAbCyEUIAFB/Ahq -IAFBoAH8CgAAIAEgAjYCnAogASgC6AMiCyACIAIgC0kbIgNBKEsNBQJAIANFBEBBACEDDAELQQAh -CEEAIQkgA0EBRwRAIANBPnEhIyABQfwIaiEAIAFByAJqIQUDQCAAIAggACgCACIkIAUoAgBqIhBq -IhU2AgAgAEEEaiIIIAgoAgAiFiAFQQRqKAIAaiIIIBAgJEkgECAVS3JqIhA2AgAgCCAWSSAIIBBL -ciEIIAVBCGohBSAAQQhqIQAgIyAJQQJqIglHDQALCyADQQFxBH8gCUECdCIAIAFB/AhqaiIJIAko -AgAiCSABQcgCaiAAaigCAGoiACAIaiIFNgIAIAAgCUkgACAFS3IFIAgLRQ0AIANBKEYNFyABQfwI -aiADQQJ0akEBNgIAIANBAWohAwsgASADNgKcCiADIBEgAyARSxsiAEEpTw0VIABBAnQhAAJ/AkAD -QCAARQ0BIABBBGsiACABQewDamooAgAiAyAAIAFB/AhqaigCACIJRg0ACyADIAlLIAMgCUlrDAEL -QX9BACAAGwsgGE4iACAUIBhIIgNFcUUEQCAADRMgAw0DDBILQQAhAyABAn9BACACRQ0AGiACQQFr -Qf////8DcSIAQQFqIgpBA3EhBQJAIABBA0kEQCABIQBCACElDAELIApB/P///wdxIQogASEAQgAh -JQNAIAAgADUCAEIKfiAlfCIlPgIAIABBBGoiCSAJNQIAQgp+ICVCIIh8IiU+AgAgAEEIaiIJIAk1 -AgBCCn4gJUIgiHwiJT4CACAAQQxqIgkgCTUCAEIKfiAlQiCIfCImPgIAICZCIIghJSAAQRBqIQAg -CkEEayIKDQALCyAFBEADQCAAIAA1AgBCCn4gJXwiJj4CACAAQQRqIQAgJkIgiCElIAVBAWsiBQ0A -CwsgAiAmQoCAgIAQVA0AGiACQShGDRcgASACQQJ0aiAlPgIAIAJBAWoLIgk2AqABAkAgDEUNACAM -QQFrQf////8DcSIAQQFqIgJBA3EhBQJAIABBA0kEQCABQaQBaiEAQgAhJQwBCyACQfz///8HcSEK -IAFBpAFqIQBCACElA0AgACAANQIAQgp+ICV8IiU+AgAgAEEEaiICIAI1AgBCCn4gJUIgiHwiJT4C -ACAAQQhqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIABBDGoiAiACNQIAQgp+ICVCIIh8IiY+AgAgJkIg -iCElIABBEGohACAKQQRrIgoNAAsLIAUEQANAIAAgADUCAEIKfiAlfCImPgIAIABBBGohACAmQiCI -ISUgBUEBayIFDQALCyAmQoCAgIAQVARAIAwhAwwBCyAMQShGDRcgAUGkAWogDEECdGogJT4CACAM -QQFqIQMLIAEgAzYCxAICQCALRQRAQQAhCwwBCyALQQFrQf////8DcSIAQQFqIgJBA3EhBQJAIABB -A0kEQCABQcgCaiEAQgAhJQwBCyACQfz///8HcSEKIAFByAJqIQBCACElA0AgACAANQIAQgp+ICV8 -IiU+AgAgAEEEaiICIAI1AgBCCn4gJUIgiHwiJT4CACAAQQhqIgIgAjUCAEIKfiAlQiCIfCIlPgIA -IABBDGoiAiACNQIAQgp+ICVCIIh8IiY+AgAgJkIgiCElIABBEGohACAKQQRrIgoNAAsLIAUEQANA -IAAgADUCAEIKfiAlfCImPgIAIABBBGohACAmQiCIISUgBUEBayIFDQALCyAmQoCAgIAQVA0AIAtB -KEYNFyABQcgCaiALQQJ0aiAlPgIAIAtBAWohCwsgASALNgLoAyASIAkgCSASSRsiAkEoTQ0ACwsM -EQsgAUEBEC0aIAEoAowFIgAgASgCoAEiAiAAIAJLGyIAQSlPDQQgAEECdCEAIAFBBGshAiABQegD -aiEDA0AgAEUNDiAAIANqIQkgACACaiAAQQRrIQAoAgAiDCAJKAIAIglGDQALIAkgDE0NDgwPCyAG -QShB3PvAABDRAQALIANBKEHc+8AAENEBAAsgA0EoQdz7wAAQ0QEAC0ERQRFBxNTAABB/AAsMDQsM -DQsMCwsMCwtB9NTAAEE3QazVwAAQlAEAC0G81cAAQTZB9NXAABCUAQALQdjTwABBHEH008AAEJQB -AAtBqNPAAEEdQcjTwAAQlAEAC0H70sAAQRxBmNPAABCUAQALIAANAQsgBiANaiECIAohAEF/IQUC -QANAIABBf0YNASAFQQFqIQUgACANaiAAQQFrIQAtAABBOUYNAAsgACANaiICQQFqIgMgAy0AAEEB -ajoAACAFRSAAQQJqIApLcg0BIAJBAmpBMCAF/AsADAELIA1BMToAACAKBEAgDUEBakEwIAr8CwAL -IAZBEUkEQCACQTA6AAAgDkEBaiEOIApBAmohBgwBCyAGQRFB1NTAABB/AAsgBkERTQRAIA8gDjsB -CCAPIAY2AgQgDyANNgIAIAFBoApqJAAMBQsgBkERQeTUwAAQ0QEACyACQShB3PvAABDRAQALQez7 -wABBGkHc+8AAEJQBAAsgAEEoQdz7wAAQ0QEAC0EoQShB3PvAABB/AAsLIAcgBygCUCAHKAJUIAcv -AVhBACAHQSBqEFAgBygCBCEAIAcoAgAMAQsgB0ECOwEgIAdBATYCKCAHQevmwAA2AiQgB0Egagsh -ASAHIAA2AlwgByABNgJYIAcgGzYCVCAHIBc2AlAgB0HQAGoQPyAHQYABaiQADwsCfyABIQwgAkEA -RyECIAEvAQ4hEUEAIQEjAEHwCGsiByQAID+9IScCf0EDID+ZRAAAAAAAAPB/YQ0AGkECICdCgICA -gICAgPj/AIMiJkKAgICAgICA+P8AUQ0AGiAnQv////////8HgyIpQoCAgICAgIAIhCAnQgGGQv7/ -//////8PgyAnQjSIp0H/D3EiABsiJUIBgyEoICZQBEBBBCApUA0BGiAAQbMIayEBQgEhJiAoUAwB -C0KAgICAgICAICAlQgGGICVCgICAgICAgAhRIgEbISVCAkIBIAEbISZBy3dBzHcgARsgAGohASAo -UAshACAHIAE7AegIIAcgJjcD4AggB0IBNwPYCCAHICU3A9AIIAcgADoA6ggCQAJ/AkACQAJAAkAg -AEECayIDBEBBASEAQePmwABB5ObAACAnQgBTIgYbQePmwABBASAGGyACGyEbICdCP4inIAJyIR1B -AyADIANBA08bQQJrDgICAwELIAdBAzYCmAggB0Hl5sAANgKUCCAHQQI7AZAIQQEhG0EBIQAgB0GQ -CGoMBAsgB0EDNgKYCCAHQejmwAA2ApQIIAdBAjsBkAggB0GQCGoMAwtBAiEAIAdBAjsBkAggEUUN -ASAHIBE2AqAIIAdBADsBnAggB0ECNgKYCCAHQeHmwAA2ApQIIAdBkAhqDAILQXRBBSABwSIAQQBI -GyAAbCIAQcD9AEkEQCAHQZAIaiEEIAdBEGohBSAAQQR2QRVqIgohAUGAgH5BACARayARwUEASBsh -CQJAAkACfwJAAkACQAJAIAdB0AhqIgApAwAiJVBFBEAgJUKAgICAgICAgCBaDQEgAUUNAkGgfyAA -LwEYIgBBIGsgACAlQoCAgIAQVCIAGyICQRBrIAIgJUIghiAlIAAbIiVCgICAgICAwABUIgAbIgJB -CGsgAiAlQhCGICUgABsiJUKAgICAgICAgAFUIgAbIgJBBGsgAiAlQgiGICUgABsiJUKAgICAgICA -gBBUIgAbIgJBAmsgAiAlQgSGICUgABsiJUKAgICAgICAgMAAVCIAGyAlQgKGICUgABsiJUIAWWsi -A2vBQdAAbEGwpwVqQc4QbSIAQdEATw0DIABBBHQiAkGo18AAaikDACImQv////8PgyInICUgJUJ/ -hUI/iIYiJUIgiCIofiIpQiCIICZCIIgiJiAofnwgJiAlQv////8PgyIlfiImQiCIfCApQv////8P -gyAlICd+QiCIfCAmQv////8Pg3xCgICAgAh8QiCIfCIlQUAgAyACQbDXwABqLwEAamsiC0E/ca0i -J4inIQAgAkGy18AAai8BACECICVCASAnhiIoQgF9IimDIiZQBEAgAUEKSw0HIAFBAnRBvOTAAGoo -AgAgAEsNBwsgAEGQzgBPBEAgAEHAhD1JDQUgAEGAwtcvTwRAQQhBCSAAQYCU69wDSSIDGyEGQYDC -1y9BgJTr3AMgAxsMBwtBBkEHIABBgK3iBEkiAxshBkHAhD1BgK3iBCADGwwGCyAAQeQATwRAQQJB -AyAAQegHSSIDGyEGQeQAQegHIAMbDAYLQQpBASAAQQlLIgYbDAULQfvSwABBHEHs48AAEJQBAAtB -/OPAAEEkQaDkwAAQlAEAC0HI48AAQSFBsOTAABCUAQALIABB0QBB6OHAABB/AAtBBEEFIABBoI0G -SSIDGyEGQZDOAEGgjQYgAxsLIQMCQAJAAkACQCAGIAJrQQFqwSIIIAnBIgJKBEAgC0H//wNxIQ4g -CCAJa8EgASAIIAJrIAFJGyILQQFrIQ9BACECA0AgACADbiENIAEgAkYNAyAAIAMgDWxrIQAgAiAF -aiANQTBqOgAAIAIgD0YNBCACIAZGDQIgAkEBaiECIANBCkkgA0EKbiEDRQ0AC0Ho5MAAEJoBAAsg -BCAFIAFBACAIIAkgJUIKgCADrSAnhiAoEEUMBQsgAkEBaiECIA5BAWtBP3GtISpCASElA0AgJSAq -iFBFBEAgBEEANgIADAYLIAEgAk0NAyACIAVqICZCCn4iJiAniKdBMGo6AAAgJUIKfiElICYgKYMh -JiALIAJBAWoiAkcNAAsgBCAFIAEgCyAIIAkgJiAoICUQRQwECyABIAFB+OTAABB/AAsgBCAFIAEg -CyAIIAkgAK0gJ4YgJnwgA60gJ4YgKBBFDAILIAIgAUGI5cAAEH8ACyAEQQA2AgALIAnBIRgCQCAH -KAKQCARAIAdByAhqIAdBmAhqKAIANgIAIAcgBykCkAg3A8AIDAELIAdBwAhqIRIgB0EQaiEJIwBB -wAZrIgUkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAHQdAIaiIAKQMAIiVQRQRAIAApAwgiJlAN -ASAAKQMQIidQDQIgJSAnfCAlVA0DICUgJlQNBCAALgEYIQAgBSAlPgIMIAVBAUECICVCgICAgBBU -IgEbNgKsASAFQQAgJUIgiKcgARs2AhAgBUEUakEAQZgB/AsAIAVBtAFqQQBBnAH8CwAgBUEBNgKw -ASAFQQE2AtACIACsICVCAX15fULCmsHoBH5CgKHNoLQCfEIgiKciAcEhDQJAIABBAE4EQCAFQQxq -IAAQLRoMAQsgBUGwAWpBACAAa8EQLRoLAkAgDUEASARAIAVBDGpBACANa0H//wNxECsMAQsgBUGw -AWogAUH//wFxECsLIAUoAtACIQsgBUGcBWogBUGwAWpBoAH8CgAAIAUgCzYCvAYgCiIGQQpPBEAg -BUGUBWohAgNAIAUoArwGIgRBKU8NCgJAIARFDQAgBEH/////A2ohACAEQQJ0IQECfyAEQQFGBEBC -ACElIAVBnAVqIAFqDAELIAEgAmohBCAAQf////8DcUEBakH+////B3EhA0IAISUDQCAEQQRqIgEg -ATUCACAlQiCGhCIlQoCU69wDgCImPgIAIAQgBDUCACAlICZCgJTr3AN+fUIghoQiJUKAlOvcA4Ai -Jj4CACAlICZCgJTr3AN+fSElIARBCGshBCADQQJrIgMNAAsgJUIghiElIARBCGoLIABBAXENAEEE -ayIAICUgADUCAIRCgJTr3AOAPgIACyAGQQlrIgZBCUsNAAsLIAZBAnRBwOTAAGooAgBBAXQiAkUN -BSAFKAK8BiIEQSlPDQggBAR/IARB/////wNqIQAgBEECdCEBIAKtISUCfyAEQQFGBEBCACEmIAVB -nAVqIAFqDAELIAEgBWpBlAVqIQQgAEH/////A3FBAWpB/v///wdxIQNCACEmA0AgBEEEaiIBIAE1 -AgAgJkIghoQiJiAlgCInPgIAIAQgBDUCACAmICUgJ359QiCGhCImICWAIic+AgAgJiAlICd+fSEm -IARBCGshBCADQQJrIgMNAAsgJkIghiEmIARBCGoLIQEgAEEBcUUEQCABQQRrIgAgJiAANQIAhCAl -gD4CAAsgBSgCvAYFQQALIQECQAJAAkAgBSgCrAEiACABIAAgAUsbIgFBKE0EQCABRQRAQQAhAQwE -CyABQQFxIQ4gAUEBRw0BQQAhBkEAIQgMAgsMFAsgAUE+cSEPQQAhBiAFQZwFaiEEIAVBDGohA0EA -IQgDQCAEIAQoAgAiFyADKAIAaiICIAZBAXFqIhM2AgAgBEEEaiIGIAYoAgAiGSADQQRqKAIAaiIG -IAIgF0kgAiATS3JqIgI2AgAgBiAZSSACIAZJciEGIANBCGohAyAEQQhqIQQgDyAIQQJqIghHDQAL -CyAOBH8gCEECdCICIAVBnAVqaiIDIAMoAgAiAyAFQQxqIAJqKAIAaiICIAZqIgY2AgAgAiADSSAC -IAZLcgUgBgtBAXFFDQAgAUEoRg0KIAVBnAVqIAFBAnRqQQE2AgAgAUEBaiEBCyAFIAE2ArwGIAsg -ASABIAtJGyIEQSlPDQggBEECdCEEAkACQANAIARFDQEgBEEEayIEIAVBnAVqaigCACIBIAQgBUGw -AWpqKAIAIgJGDQALIAEgAk8NAQwICyAEDQcLIA1BAWohDQwHC0H70sAAQRxBhNbAABCUAQALQajT -wABBHUGU1sAAEJQBAAtB2NPAAEEcQaTWwAAQlAEAC0G81cAAQTZBlNfAABCUAQALQfTUwABBN0GE -18AAEJQBAAtBo/zAAEEbQdz7wAAQlAEACyAARQRAQQAhACAFQQA2AqwBDAELIABBAWtB/////wNx -IgFBAWoiAkEDcSEDAkAgAUEDSQRAIAVBDGohBEIAISUMAQsgAkH8////B3EhASAFQQxqIQRCACEl -A0AgBCAENQIAQgp+ICV8IiU+AgAgBEEEaiICIAI1AgBCCn4gJUIgiHwiJT4CACAEQQhqIgIgAjUC -AEIKfiAlQiCIfCIlPgIAIARBDGoiAiACNQIAQgp+ICVCIIh8IiY+AgAgJkIgiCElIARBEGohBCAB -QQRrIgENAAsLIAMEQANAIAQgBDUCAEIKfiAlfCImPgIAIARBBGohBCAmQiCIISUgA0EBayIDDQAL -CyAmQoCAgIAQWgRAIABBKEYNAyAFQQxqIABBAnRqICU+AgAgAEEBaiEACyAFIAA2AqwBC0EAIQYC -QAJAAkACQCANwSIBIBjBIgJIIh5FBEAgDSAYa8EgCiABIAJrIApJGyIIDQELQQAhCAwBCyAFQdQC -aiIBIAVBsAFqIgBBoAH8CgAAIAUgCzYC9ANBASEXIAFBARAtIR8gBSgC0AIhASAFQfgDaiICIABB -oAH8CgAAIAUgATYCmAUgAkECEC0hICAFKALQAiEBIAVBnAVqIgIgAEGgAfwKAAAgBSABNgK8BiAF -QawBaiEhIAVB0AJqISIgBUH0A2ohFCAFQZgFaiEjQQAhDiACQQMQLSEkIAUoAqwBIQAgBSgC0AIh -CyAFKAL0AyETIAUoApgFIRkgBSgCvAYhEAJAAkACQAJAA0AgAEEpTw0KIABBAnQhAUEAIQQCfwJA -AkADQCABIARGDQEgBUEMaiAEaiAEQQRqIQQoAgBFDQALIBAgACAAIBBJGyIBQSlPDRQgAUECdCEE -AkADQCAERQ0BIAQgI2ohAiAEQQRrIgQgBUEMamooAgAiAyACKAIAIgJGDQALIAIgA00NAkEADAML -IARFDQFBAAwCCyAIIApLDQQgCCAORg0IIAggDmsiAEUNCCAJIA5qQTAgAPwLAAwIC0EBIQZBACEA -IAFBAUcEQCABQT5xIQ8gBUEMaiEEIAVBnAVqIQMDQCAEIAQoAgAiFSADKAIAQX9zaiICIAZBAXFq -IhY2AgAgBEEEaiIGIAYoAgAiGiADQQRqKAIAQX9zaiIGIAIgFUkgAiAWS3JqIgI2AgAgBiAaSSAC -IAZJciEGIANBCGohAyAEQQhqIQQgDyAAQQJqIgBHDQALCyABQQFxBH8gAEECdCIAIAVBDGpqIgIg -AigCACICIAAgJGooAgBBf3NqIgAgBmoiAzYCACAAIAJJIAAgA0tyBSAGC0EBcUUNDCAFIAE2AqwB -IAEhAEEICyEPIBkgACAAIBlJGyICQSlPDQMgAkECdCEEAkACQAJAA0AgBEUNASAEIBRqIQEgBEEE -ayIEIAVBDGpqKAIAIgMgASgCACIBRg0ACyABIANNDQEgACECDAILIARFDQAgACECDAELIAIEQEEB -IQZBACEAIAJBAUcEQCACQT5xIRUgBUEMaiEEIAVB+ANqIQMDQCAEIAQoAgAiFiADKAIAQX9zaiIB -IAZBAXFqIho2AgAgBEEEaiIGIAYoAgAiHCADQQRqKAIAQX9zaiIGIAEgFkkgASAaS3JqIgE2AgAg -BiAcSSABIAZJciEGIANBCGohAyAEQQhqIQQgFSAAQQJqIgBHDQALCyACQQFxBH8gAEECdCIAIAVB -DGpqIgEgASgCACIBIAAgIGooAgBBf3NqIgAgBmoiAzYCACAAIAFJIAAgA0tyBSAGC0EBcUUNDQsg -BSACNgKsASAPQQRyIQ8LIBMgAiACIBNJGyIBQSlPDQQgAUECdCEEAkACQAJAA0AgBEUNASAEICJq -IQAgBEEEayIEIAVBDGpqKAIAIgMgACgCACIARg0ACyAAIANNDQEgAiEBDAILIARFDQAgAiEBDAEL -IAEEQEEBIQZBACEAIAFBAUcEQCABQT5xIRUgBUEMaiEEIAVB1AJqIQMDQCAEIAQoAgAiFiADKAIA -QX9zaiICIAZBAXFqIho2AgAgBEEEaiIGIAYoAgAiHCADQQRqKAIAQX9zaiIGIAIgFkkgAiAaS3Jq -IgI2AgAgBiAcSSACIAZJciEGIANBCGohAyAEQQhqIQQgFSAAQQJqIgBHDQALCyABQQFxBH8gAEEC -dCIAIAVBDGpqIgIgAigCACICIAAgH2ooAgBBf3NqIgAgBmoiAzYCACAAIAJJIAAgA0tyBSAGC0EB -cUUNDQsgBSABNgKsASAPQQJqIQ8LIAsgASABIAtJGyIAQSlPDQogAEECdCEEAkACQAJAA0AgBEUN -ASAEICFqIQIgBEEEayIEIAVBDGpqKAIAIgMgAigCACICRg0ACyACIANNDQEgASEADAILIARFDQAg -ASEADAELIAAEQEEBIQZBACEBIABBAUcEQCAAQT5xIRUgBUEMaiEEIAVBsAFqIQMDQCAEIAQoAgAi -FiADKAIAQX9zaiICIAZBAXFqIho2AgAgBEEEaiIGIAYoAgAiHCADQQRqKAIAQX9zaiIGIAIgFkkg -AiAaS3JqIgI2AgAgBiAcSSACIAZJciEGIANBCGohAyAEQQhqIQQgFSABQQJqIgFHDQALCyAAQQFx -BH8gAUECdCIBIAVBDGpqIgIgAigCACICIAVBsAFqIAFqKAIAQX9zaiIBIAZqIgM2AgAgASACSSAB -IANLcgUgBgtBAXFFDQ0LIAUgADYCrAEgD0EBaiEPCyAKIA5NDQEgCSAOaiAPQTBqOgAAIABBKU8N -CgJAIABFBEBBACEADAELIABBAWtB/////wNxIgFBAWoiAkEDcSEDAkAgAUEDSQRAIAVBDGohBEIA -ISYMAQsgAkH8////B3EhASAFQQxqIQRCACEmA0AgBCAENQIAQgp+ICZ8IiU+AgAgBEEEaiICIAI1 -AgBCCn4gJUIgiHwiJT4CACAEQQhqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIARBDGoiAiACNQIAQgp+ -ICVCIIh8IiU+AgAgJUIgiCEmIARBEGohBCABQQRrIgENAAsLIAMEQANAIAQgBDUCAEIKfiAmfCIl -PgIAIARBBGohBCAlQiCIISYgA0EBayIDDQALCyAlQoCAgIAQVA0AIABBKEYNCiAFQQxqIABBAnRq -ICY+AgAgAEEBaiEACyAFIAA2AqwBIA5BAWohDiAXIAggF0siAWohFyABDQALQQEhBgwECyAOIApB -5NbAABB/AAsgCCAKQfTWwAAQ0QEACyACQShB3PvAABDRAQALDAwLAkACQAJAIAtBKUkEQAJAIAtF -BEBBACELDAELIAtBAWtB/////wNxIgFBAWoiAkEDcSEDAkAgAUEDSQRAIAVBsAFqIQRCACElDAEL -IAJB/P///wdxIQEgBUGwAWohBEIAISUDQCAEIAQ1AgBCBX4gJXwiJT4CACAEQQRqIgIgAjUCAEIF -fiAlQiCIfCIlPgIAIARBCGoiAiACNQIAQgV+ICVCIIh8IiU+AgAgBEEMaiICIAI1AgBCBX4gJUIg -iHwiJj4CACAmQiCIISUgBEEQaiEEIAFBBGsiAQ0ACwsgAwRAA0AgBCAENQIAQgV+ICV8IiY+AgAg -BEEEaiEEICZCIIghJSADQQFrIgMNAAsLICZCgICAgBBUDQAgC0EoRg0IIAVBsAFqIAtBAnRqICU+ -AgAgC0EBaiELCyAFIAs2AtACIAsgACAAIAtJGyIEQSlPDQYgBEECdCEEIAVBCGohACAFQawBaiEB -AkACQANAIARFDQEgASAEaiECIAAgBGogBEEEayEEKAIAIgMgAigCACICRg0ACyACIANPDQUMAQsg -BiAERXFFDQQgCEEBayIAIApPDQIgACAJai0AAEEBcUUNBAsgCCAKSw0CIAggCWpBACEEIAkhAwJA -A0AgBCAIRg0BIARBAWohBCADQQFrIgMgCGoiAC0AAEE5Rg0ACyAAIAAtAABBAWo6AAAgCCAEa0EB -aiAITw0EIARBAWsiAUUNBCAAQQFqQTAgAfwLAAwECwJAIAhFBEBBMSEEDAELIAlBMToAACAIQQFG -BEBBMCEEDAELQTAhBCAIQQFrIgBFDQAgCUEBakEwIAD8CwALIA1BAWohDSAeIAggCk9yDQMgBDoA -ACAIQQFqIQgMAwsgC0EoQdz7wAAQ0QEACyAAIApBtNbAABB/AAsgCCAKQcTWwAAQ0QEACyAIIApL -DQELIBIgDTsBCCASIAg2AgQgEiAJNgIAIAVBwAZqJAAMBQsgCCAKQdTWwAAQ0QEACyAEQShB3PvA -ABDRAQALQShBKEHc+8AAEH8ACyAAQShB3PvAABDRAQALQez7wABBGkHc+8AAEJQBAAsLIBggBy4B -yAgiAEgEQCAHQQhqIAcoAsAIIAcoAsQIIAAgESAHQZAIahBQIAcoAgwhACAHKAIIDAMLQQIhACAH -QQI7AZAIIBFFBEBBASEAIAdBATYCmAggB0Hr5sAANgKUCCAHQZAIagwDCyAHIBE2AqAIIAdBADsB -nAggB0ECNgKYCCAHQeHmwAA2ApQIIAdBkAhqDAILQezmwABBJUGU58AAEJQBAAtBASEAIAdBATYC -mAggB0Hr5sAANgKUCCAHQZAIagshASAHIAA2AswIIAcgATYCyAggByAdNgLECCAHIBs2AsAIIAwg -B0HACGoQPyAHQfAIaiQADAELIAFBKEHc+8AAENEBAAsLQgEBfyMAQSBrIgMkACADQQA2AhAgA0EB -NgIEIANCBDcCCCADIAE2AhwgAyAANgIYIAMgA0EYajYCACADIAIQnwEAC0ABAX8gASgCACIBIAEo -AggiBEEBajYCCCAEQQBIBEAACyAAIAE2AgwgACADNgIIIAAgAjYCBCAAQey1wAA2AgALPAAgACAB -KQAANwAAIABBGGogAUEYaikAADcAACAAQRBqIAFBEGopAAA3AAAgAEEIaiABQQhqKQAANwAAC5QC -AQN/IAAoAgAhAiABKAIIIgBBgICAEHFFBEAgAEGAgIAgcUUEQCACIAEQ0wEPC0EAIQAjAEGAAWsi -BCQAIAIoAgAhAgNAIAAgBGpB/wBqIAJBD3EiA0EwciADQTdqIANBCkkbOgAAIABBAWshACACQQ9L -IAJBBHYhAg0ACyABQQFBpurAAEECIAAgBGpBgAFqQQAgAGsQNiAEQYABaiQADwtBACEAIwBBgAFr -IgQkACACKAIAIQIDQCAAIARqQf8AaiACQQ9xIgNBMHIgA0HXAGogA0EKSRs6AAAgAEEBayEAIAJB -D0sgAkEEdiECDQALIAFBAUGm6sAAQQIgACAEakGAAWpBACAAaxA2IARBgAFqJAALOAACQCACQYCA -xABGDQAgACACIAEoAhARAABFDQBBAQ8LIANFBEBBAA8LIAAgAyAEIAEoAgwRAQALLQACQCAAIAEQ -swFFDQAgAARAQeWAwQAtAAAaIAAgARDAASIBRQ0BCyABDwsACzcBAX8jAEEgayIBJAAgAUEANgIY -IAFBATYCDCABQdj8wAA2AgggAUIENwIQIAFBCGogABCfAQAL5RkCG38BfiMAQRBrIg0kACMAQSBr -IgkkACMAQSBrIgQkACABrUIMfiIdpyEDAkACQAJAAkAgHUIgiKcgA0H8////B0tyDQACfyADRQRA -QQQhBUEADAELQeWAwQAtAAAaQQQhAiADQQQQwAEiBUUNASABCyECIARBADYCHCAEIAU2AhggBCAC -NgIUIAEEQCABQQJ0IQpBCCECA0AgBEEIaiAAIAhqKAIAIgMQ6gEgBCgCCCIQRQ0DIAQoAgwhCyAD -QYQBTwRAIAMQbAsgBCgCFCAGRgRAIwBBIGsiAyQAQQQgBEEUaiIFKAIAIgxBAXQiByAHQQRNGyIP -rUIMfiIdQiCIUEUEQEEAQQBB3MHAABCyAQALAkAgHaciDkH8////B00EfyADIAwEfyADIAxBDGw2 -AhwgAyAFKAIENgIUQQQFQQALNgIYIANBCGpBBCAOIANBFGoQcyADKAIIQQFHDQEgAygCECEHIAMo -AgwFQQALIAdB3MHAABCyAQALIAMoAgwhByAFIA82AgAgBSAHNgIEIANBIGokACAEKAIYIQULIAIg -BWoiAyALNgIAIANBBGsgEDYCACADQQhrIAs2AgAgBCAGQQFqIgY2AhwgAkEMaiECIAogCEEEaiII -Rw0ACyAAIAFBAnQQzAELIAQoAhghAAJAIAYgBCgCFCIBTwRAIAAhAgwBCyABQQxsIQEgBkUEQEEE -IQIgACABEMwBDAELIAAgAUEEIAZBDGwiABC4ASICRQ0DCyAJIAY2AgQgCSACNgIAIARBIGokAAwD -CyACIANBvMHAABCyAQALQezBwABBKBDiAQALQQQgAEHMwcAAELIBAAsgCSAJKAIEIgA2AhAgCSAJ -KAIANgIMIAkgADYCCCAJQRRqIRAjAEEwayIEJAAgCUEIaiIBKAIAIQIgASgCBCEAIAEoAgghASAE -QQA6AC8gBCAAIAFBDGxqNgIMIAQgAjYCCCAEIAA2AgQgBCAANgIAIAQgBEEvajYCECAEQSBqIQUj -AEHgAGsiAiQAAkACQAJAAkACQCAEKAIEIgEgBCgCDCIGRgRAIAEhAAwBCyAEKAIQIQwgBCABQQxq -IgA2AgQgASgCACEDIAJBOGogASgCBCIHIAEoAggQNyADBEAgByADEMwBCyACKAI4QQFxRQ0BIAxB -AToAAAsgBUEANgIIIAVCgICAgIABNwIAIAYgAGtBDG4hASAAIAZHBEADQCAAKAIAIgMEQCAAQQRq -KAIAIAMQzAELIABBDGohACABQQFrIgENAAsLIAQoAggiAEUNASAEKAIAIABBDGwQzAEMAQsgAkEw -aiIDIAJB2ABqKQMANwMAIAJBKGoiByACQdAAaikDADcDACACQSBqIgggAkHIAGopAwA3AwAgAiAC -KQNANwMYQeWAwQAtAAAaQYABQQgQwAEiAUUNASABIAIpAxg3AwAgAUEYaiADKQMANwMAIAFBEGog -BykDADcDACABQQhqIAgpAwA3AwAgAkEBNgIUIAIgATYCECACQQQ2AgwgBCgCCCEKIAQoAgAhDwJA -IAAgBkYNACACQUBrIQhBICEHQQEhAwNAIAAoAgAhCyACQThqIABBBGooAgAiDiAAQQhqKAIAEDcg -CwRAIA4gCxDMAQsgAigCOEEBcQRAIAxBAToAACAAQQxqIQAMAgsgAkEwaiIOIAhBGGopAwA3AwAg -AkEoaiIRIAhBEGopAwA3AwAgAkEgaiITIAhBCGopAwA3AwAgAiAIKQMANwMYIAIoAgwgA0YEQCAC -QQxqIANBAUEIQSAQVyACKAIQIQELIAEgB2oiCyACKQMYNwMAIAtBGGogDikDADcDACALQRBqIBEp -AwA3AwAgC0EIaiATKQMANwMAIAIgA0EBaiIDNgIUIAdBIGohByAAQQxqIgAgBkcNAAsLIAYgAGtB -DG4hASAAIAZHBEADQCAAKAIAIgMEQCAAQQRqKAIAIAMQzAELIABBDGohACABQQFrIgENAAsLIAoE -QCAPIApBDGwQzAELIAUgAikCDDcCACAFQQhqIAJBFGooAgA2AgALIAJB4ABqJAAMAQtBCEGAAUGo -k8AAELIBAAsCQAJAAkACQAJAIAQtAC9BAUYEQCAEKAIgIgBFDQEgBCgCJCAAQQV0EMwBDAELIAQo -AiAiE0GAgICAeEcNAQsgBEEANgIoIARCgICAgBA3AiAgBEG0gsAANgIEIARCoICAgA43AgggBCAE -QSBqNgIAIAQQuQENAiAEKAIgIQAgBCgCJCIBIAQoAigQtQEhAiAABEAgASAAEMwBCyAQQYCAgIB4 -NgIAIBAgAjYCBAwBCyAEKAIkIhkhACAEKAIoIQEjAEHgAGsiCCQAIAhBADYCKCAIQQA2AhggCCAA -NgI4IAggACABQQV0ajYCPCAIQQxqIQtBACEBIwBBEGsiBiQAAkACQAJ/AkACQCAIQRhqIgUiACgC -ACIDBEAgACgCBCICIAAoAgxHDQEgACgCCCICBEAgAyACEMwBCyAAQQA2AgALIAAoAiAiA0UNASAD -IAAoAiRGDQEgACADQSBqNgIgQeWAwQAtAAAaQSBBARDAASICRQ0DIABBIDYCCCAAIAI2AgAgAiAD -KQAANwAAIAAgAkEgajYCDCACQRhqIANBGGopAAA3AAAgAkEQaiADQRBqKQAANwAAIAJBCGogA0EI -aikAADcAAAsgACACQQFqNgIEIAItAAAhAEEBDAELIAAoAhAiAwRAIAAoAhQiAiAAKAIcRwRAIAAg -AkEBajYCFCACLQAAIQBBAQwCCyAAKAIYIgIEQCADIAIQzAELIABBADYCEAtBAAshAiAGIAA6AAEg -BiACOgAADAELQQFBIEHkrcAAELIBAAsCQCAGLQAABEACQEEIQX8gBSgCDCIPIAUoAgQiDGsiAiAF -KAIcIhcgBSgCFCIAa0EAIAUoAhAiDhsiA2oiByACIAdLGyADIAUoAgAiAxtBAWoiAkF/IAIbIgIg -AkEITRsiAkEASA0AIAYtAAEhB0HlgMEALQAAGkEBIQEgAkEBEMABIgpFDQAgCiAHOgAAIAZBATYC -DCAGIAo2AgggBiACNgIEIAUoAiQhGiAFKAIgIQcgBSgCGCEYIAUoAgghEUEBIQUDQAJAAkACQAJ/ -AkAgA0UNACAMIAwgD0cNARogEUUNACADIBEQzAELIAdFIAcgGkZyDQFB5YDBAC0AABpBIEEBEMAB -IgNFDQIgAyAHKQAANwAAIANBGGogB0EYaikAADcAACADQRBqIAdBEGopAAA3AAAgA0EIaiAHQQhq -KQAANwAAQSAhESADQSBqIQ8gB0EgaiEHIAMLIgJBAWohDCAAIQEMAgsCQCAORQ0AIAAgF0cEQCAA -QQFqIQFBACEDIAAhAgwDCyAYRQ0AIA4gGBDMAQsgCyAGKQIENwIAIAtBCGogBkEMaigCADYCAAwF -C0EBQSBB5K3AABCyAQALIAItAAAhGyAGKAIEIAVGBEAgBkEEaiEKIwBBIGsiACQAAkACQCAFQX8g -DyAMayICIBcgAWtBACAOGyIUaiISIAIgEksbIBQgAxtBAWoiAkF/IAIbIAVqIgJLDQBBCCACIAoo -AgAiFEEBdCISIAIgEksbIgIgAkEITRsiEq0iHUIgiFBFDQAgHaciHEH/////B0sNACAAIBQEfyAA -IBQ2AhwgACAKKAIENgIUQQEFQQALNgIYIABBCGpBASAcIABBFGoQcyAAKAIIQQFHDQEgACgCECEC -IAAoAgwhFgsgFiACQaSwwAAQsgEACyAAKAIMIQIgCiASNgIAIAogAjYCBCAAQSBqJAAgBigCCCEK -CyAFIApqIBs6AAAgBiAFQQFqIgU2AgwgASEADAALAAsgASACQfiuwAAQsgEACyALQQA2AgggC0KA -gICAEDcCAAJAIAUoAgAiAEUNACAFKAIIIgFFDQAgACABEMwBCyAFKAIQIgBFDQAgBSgCGCIBRQ0A -IAAgARDMAQsgBkEQaiQAIAhBQGsiAEGIr8AAIAgoAhAiASAIKAIUEDQgBCAAEJYBIAgoAgwiAARA -IAEgABDMAQsgCEHgAGokACAQIAQQZCATRQ0AIBkgE0EFdBDMAQsgBEEwaiQADAELQdyCwABBNyAE -QS9qQcyCwABBiITAABB8AAsCQAJAIA0CfyAJKAIUIgJBgICAgHhGBEBBACEAIAkoAhghAUEBDAEL -IAkoAhghAQJAIAkoAhwiFSACTwRAIAEhAAwBCyAVRQRAQQEhACABIAIQzAEMAQsgASACQQEgFRC4 -ASIARQ0CC0EAIQFBAAs2AgwgDSABNgIIIA0gFTYCBCANIAA2AgAgCUEgaiQADAELQQEgFUHMh8AA -ELIBAAsgDSgCACANKAIEIA0oAgggDSgCDCANQRBqJAALpwwCF38BfiMAQRBrIgokACABIRAjAEHQ -AGsiAyQAAkACQAJAAkAgACILBEAgAEEIayIMIAwoAgBBAWoiADYCACAARQ0BIAsoAgANAiALQX82 -AgAgAyAMNgIUIAMgCzYCECADIAtBCGoiDzYCDCADQRhqIQkjAEGAAWsiACQAIABBADYCFCAAQoCA -gICAATcCDAJAAkAgAgRAIABByABqQQRyIQYDQCACIARJDQIgAEHIAGogDyAEIBBqIAIgBGtBABAy -IABBIGoiESAGQQhqKQIANwMAIABBKGoiEiAGQRBqKQIANwMAIABBMGoiEyAGQRhqKQIANwMAIABB -OGoiFCAGQSBqKQIANwMAIABBQGsiFSAGQShqKAIANgIAIAAgBikCADcDGCAAKAJ4IRYgACgCSCIX -BEAgACgCFCINIAAoAgxGBEAjAEEgayIBJABBBCAAQQxqIgcoAgAiDkEBdCIFIAVBBE0bIhitQjB+ -IhpCIIhQRQRAQQBBAEHImMAAELIBAAsCQCAapyIZQfj///8HTQRAIAEgDgR/IAEgDkEwbDYCHCAB -IAcoAgQ2AhRBCAVBAAs2AhggAUEIakEIIBkgAUEUahBzIAEoAghBAUcNASABKAIMIQggASgCECEF -CyAIIAVByJjAABCyAQALIAEoAgwhBSAHIBg2AgAgByAFNgIEIAFBIGokAAsgACgCECANQTBsaiIB -IAApAxg3AgQgASAXNgIAIAFBDGogESkDADcCACABQRRqIBIpAwA3AgAgAUEcaiATKQMANwIAIAFB -JGogFCkDADcCACABQSxqIBUoAgA2AgAgACANQQFqNgIUCyAEIBZqIgQgAkcNAAsLIAkgACkCDDcC -ACAJQQhqIABBFGooAgA2AgAgAEGAAWokAAwBCyAEIAJB2JjAABDQAQALQQQhBCADKAIcIQAgAygC -GCEFIAMoAiAiAQRAQeWAwQAtAAAaIAFBBHQiBkEEEMABIgRFDQQLIANBADYCLCADIAQ2AiggAyAB -NgIkIAMgACABQTBsajYCPCADIAU2AjggAyAANgI0IAMgADYCMCADIAQ2AkggA0EANgJEIAMgA0Es -ajYCQCADQUBrIQUjAEFAaiIEJAACQCADQTBqIggoAgQiACAIKAIMIg1GBEAgBSgCBCEGDAELIAUo -AgggBSgCBCIGQQR0aiEHIARBHGohDiAEQSBqIQkDQCAIIABBMGoiATYCBCAEQThqIABBKGopAwA3 -AwAgBEEwaiAAQSBqKQMANwMAIARBKGogAEEYaikDADcDACAJIABBEGopAwA3AwAgBEEYaiIPIABB -CGopAwA3AwAgBCAAKQMANwMQIAQgCRBkIAQgDygCACIANgIMIA4gBCgCFCAAIAQoAhAoAhARAwAg -B0EIaiAEQQhqKQIANwIAIAcgBCkCADcCACAFIAZBAWoiBjYCBCAHQRBqIQcgASIAIA1HDQALCyAF -KAIAIAY2AgAgCCgCCCIABEAgCCgCACAAQTBsEMwBCyAEQUBrJAAgAygCJCEJIAMoAighASADKAIs -IQQgA0EANgIkQQEhByAIIANBJGoQsQECQCADKAIwRQRAIAMoAjQhBQwBCyADQcgAaiADQThqKAIA -NgIAIAMgAykCMDcDQAJAIAQEQCAEQQR0IQcgA0FAa0EEciEIIAMoAkghBiABIQADQCADIAAgAygC -QBBhIAMoAgQhBSADKAIAQQFxDQIgCCAGIAUQzgEgAyAGQQFqIgY2AkggAEEQaiEAIAdBEGsiBw0A -CwtBACEHIAMoAkQhBQwBC0EBIQcgAygCRCIAQYQBSQ0AIAAQbAsgBARAIAEhAANAIAAoAgAiBgRA -IABBBGooAgAgBhDMAQsgAEEQaiEAIARBAWsiBA0ACwsgCQRAIAEgCUEEdBDMAQsgAgRAIBAgAhDM -AQsgC0EANgIAIAwgDCgCAEEBayIANgIAIABFBEAgA0EUahCRAQsgCiAHNgIIIAogBUEAIAcbNgIE -IApBACAFIAcbNgIAIANB0ABqJAAMBAsQ4AELAAsQ4QEAC0EEIAZBpILAABCyAQALIAooAgAgCigC -BCAKKAIIIApBEGokAAuaBgEIfyMAQRBrIgQkABBvIgIgACYBIwBBEGsiCCQAIAhBBGohAyMAQdAA -ayIBJAAgAUEMaiACEC8gASgCECECAkACQAJAIAEoAgwiBUGAgICAeEYEQCABIAI2AjwgAUEANgJI -IAFCgICAgBA3AkAgAUG0gsAANgIcIAFCoICAgA43AiAgASABQUBrNgIYIAFBPGogAUEYahCPAQ0C -IAEoAkAhAiABKAJEIgUgASgCSBC1ASEGIAIEQCAFIAIQzAELIAEoAjwiAkGEAU8EQCACEGwLIANB -gICAgHg2AgAgAyAGNgIEDAELIAEoAhQhBiABQQA6AAwgASACIAZBBHRqNgIkIAEgBTYCICABIAI2 -AhwgASACNgIYIAEgAUEMajYCKCABQUBrIAFBGGoQLAJAAkAgAS0ADEEBRgRAIAEoAkAiAkUNASAB -KAJEIAJBKGwQzAEMAQsgASgCQCICQYCAgIB4Rw0BCyABQQA2AkggAUKAgICAEDcCQCABQbSCwAA2 -AhwgAUKggICADjcCICABIAFBQGs2AhggAUEYahC5AQ0CIAEoAkAhAiABKAJEIgUgASgCSBC1ASEG -IAIEQCAFIAIQzAELIANBgICAgHg2AgAgAyAGNgIEDAELIAEoAkQhBQJAIAEoAkgiBkUEQCABQTBq -QgA3AwAgAUEoakIANwMAIAFBIGpCADcDACABQgA3AxgMAQsgAUEYaiAFIAYQMQsgAyABQRhqEGQg -AkUNACAFIAJBKGwQzAELIAFB0ABqJAAMAQtB3ILAAEE3IAFBzwBqQcyCwABBiITAABB8AAsCQAJA -IAQCfyAIKAIEIgJBgICAgHhGBEAgCCgCCCEBQQAhA0EBDAELIAgoAgghAQJAIAgoAgwiAyACTwRA -IAEhBwwBCyADRQRAQQEhByABIAIQzAEMAQsgASACQQEgAxC4ASIHRQ0CC0EAIQFBAAs2AgwgBCAB -NgIIIAQgAzYCBCAEIAc2AgAgCEEQaiQADAELQQEgA0HMh8AAELIBAAsgBCgCACAEKAIEIAQoAggg -BCgCDCAEQRBqJAALhwcBCn8jAEEQayIEJAAQbyICIAAmASMAQRBrIggkACAIQQRqIQUjAEHwAGsi -ASQAIAFBCGogAhAvIAEoAgwhAgJAAkACQCABKAIIIgNBgICAgHhGBEAgASACNgJoIAFBADYCMCAB -QoCAgIAQNwIoIAFBtILAADYCTCABQqCAgIAONwJQIAEgAUEoajYCSCABQegAaiABQcgAahCPAQ0C -IAEoAighAiABKAIsIgMgASgCMBC1ASEGIAIEQCADIAIQzAELIAEoAmgiAkGEAU8EQCACEGwLIAVB -gICAgHg2AgAgBSAGNgIEDAELIAEoAhAhBiABQQA6AAggASACIAZBBHRqNgJUIAEgAzYCUCABIAI2 -AkwgASACNgJIIAEgAUEIajYCWCABQShqIAFByABqECwCQAJAIAEtAAhBAUYEQCABKAIoIgJFDQEg -ASgCLCACQShsEMwBDAELIAEoAigiBkGAgICAeEcNAQsgAUEANgIwIAFCgICAgBA3AiggAUG0gsAA -NgJMIAFCoICAgA43AlAgASABQShqNgJIIAFByABqELkBDQIgASgCKCECIAEoAiwiAyABKAIwELUB -IQYgAgRAIAMgAhDMAQsgBUGAgICAeDYCACAFIAY2AgQMAQsgASgCLCEJAkAgASgCMCICRQRAIAFB -IGpCADcDACABQRhqQgA3AwAgAUEQakIANwMAIAFCADcDCAwBCyABQShqIgogCSACEDEgAUHIAGoi -A0Hch8AAEJYBIwBBIGsiAiQAIAJBGGogA0EYaikAADcDACACQRBqIANBEGopAAA3AwAgAkEIaiAD -QQhqKQAANwMAIAIgAykAADcDACABQQhqIAIgCkEgEDQgAkEgaiQACyAFIAFBCGoQZCAGRQ0AIAkg -BkEobBDMAQsgAUHwAGokAAwBC0HcgsAAQTcgAUHvAGpBzILAAEGIhMAAEHwACwJAAkAgBAJ/IAgo -AgQiBUGAgICAeEYEQCAIKAIIIQFBACECQQEMAQsgCCgCCCEBAkAgCCgCDCICIAVPBEAgASEHDAEL -IAJFBEBBASEHIAEgBRDMAQwBCyABIAVBASACELgBIgdFDQILQQAhAUEACzYCDCAEIAE2AgggBCAC -NgIEIAQgBzYCACAIQRBqJAAMAQtBASACQcyHwAAQsgEACyAEKAIAIAQoAgQgBCgCCCAEKAIMIARB -EGokAAv6AQICfwF+IwBBEGsiAiQAIAJBATsBDCACIAE2AgggAiAANgIEIwBBEGsiASQAIAJBBGoi -ACkCACEEIAEgADYCDCABIAQ3AgQjAEEQayIAJAAgAUEEaiIBKAIAIgIoAgwhAwJAAkACQAJAIAIo -AgQOAgABAgsgAw0BQQEhAkEAIQMMAgsgAw0AIAIoAgAiAigCBCEDIAIoAgAhAgwBCyAAQYCAgIB4 -NgIAIAAgATYCDCAAQazHwAAgASgCBCABKAIIIgAtAAggAC0ACRBmAAsgACADNgIEIAAgAjYCACAA -QZDHwAAgASgCBCABKAIIIgAtAAggAC0ACRBmAAutCAEKfyMAQRBrIgYkACMAQSBrIgQkAAJAAkAC -QCAABEAgAEEIayIIIAgoAgBBAWoiATYCACABRQ0BIAAoAgANAiAAQX82AgAgBCAINgIcIAQgADYC -GCAEIABBCGoiAzYCFCAEQQhqIQojAEGwAWsiASQAIAFBADYCHCABQoCAgIDAADcCFCMAQUBqIgIk -ACACQQhqIANBAUEAQQEQMiABQSBqIgNBKGogAkEwaikDADcDACADQSBqIAJBKGopAwA3AwAgA0EY -aiACQSBqKQMANwMAIANBEGogAkEYaikDADcDACADQQhqIAJBEGopAwA3AwAgAyACKQMINwMAIAJB -QGskAAJ/IAEoAiAiBUUEQEEEIQJBAAwBCyABQfgAaiABQcgAaikDADcDACABQfAAaiABQUBrKQMA -NwMAIAFB6ABqIAFBOGopAwA3AwAgAUHgAGoiAiABQTBqKQMANwMAIAFB2ABqIgMgAUEoaikDADcD -ACABIAEpAyA3A1AgAUGAAWogAhBkIAEgAygCACICNgKMASABQdwAaiABKAJUIAIgASgCUCgCEBED -ACABQRRqQbyHwAAQaCABKAIYIgIgASkCgAE3AgAgAkEIaiABQYgBaikCADcCACABQQE2AhxBAQsh -ByABQQA2ApgBQQEhAyABQSBqIAFBmAFqELEBAkAgASgCIEUEQCABKAIkIQUMAQsgAUGoAWogAUEo -aigCADYCACABIAEpAiA3A6ABAkAgBQRAIAdBBHQhByABQaABakEEciEJIAEoAqgBIQMDQCABQQhq -IAIgASgCoAEQYSABKAIMIQUgASgCCEEBcQ0CIAkgAyAFEM4BIAEgA0EBaiIDNgKoASACQRBqIQIg -B0EQayIHDQALC0EAIQMgASgCpAEhBQwBC0EBIQMgASgCpAEiAkGEAUkNACACEGwLIAEgBTYClAEg -ASADNgKQASABQQE2AiQgAUHIhcAANgIgIAFCATcCLCABIAFBkAFqrUKAgICAMIQ3A5gBIAEgAUGY -AWo2AiggAUGgAWogAUEgahBHIAEoAqQBIgIgASgCqAEQACABKAKgASIDBEAgAiADEMwBCyABKAKQ -ASEFIAEoApQBIQcgASgCHCIDBEAgASgCGCECA0AgAigCACIJBEAgAkEEaigCACAJEMwBCyACQRBq -IQIgA0EBayIDDQALCyABKAIUIgIEQCABKAIYIAJBBHQQzAELIAogBzYCBCAKIAU2AgAgAUGwAWok -ACAEKAIMIQEgBCgCCCECIABBADYCACAIIAgoAgBBAWsiADYCACAARQRAIARBHGoQkQELIAYgAkEB -cSIANgIIIAYgAUEAIAAbNgIEIAZBACABIAAbNgIAIARBIGokAAwDCxDgAQsACxDhAQALIAYoAgAg -BigCBCAGKAIIIAZBEGokAAshAAJAIAEgAxCzAQRAIAAgASADIAIQuAEiAA0BCwALIAALJQAgAEUE -QEG0ssAAQTIQ4gEACyAAIAIgAyAEIAUgASgCEBETAAsgAQF/QQEhASAAKAIAIgBBAXEEfyABBSAA -KAIIQQFGCwsfAQJ+IAApAwAiAiACQj+HIgOFIAN9IAJCAFkgARBJCyMAIABFBEBBtLLAAEEyEOIB -AAsgACACIAMgBCABKAIQEQQACyMAIABFBEBBtLLAAEEyEOIBAAsgACACIAMgBCABKAIQEQ8ACyMA -IABFBEBBtLLAAEEyEOIBAAsgACACIAMgBCABKAIQEScACyMAIABFBEBBtLLAAEEyEOIBAAsgACAC -IAMgBCABKAIQESkACyMAIABFBEBBtLLAAEEyEOIBAAsgACACIAMgBCABKAIQESsACyYBAX8gACgC -ACIBQYCAgIB4ckGAgICAeEcEQCAAKAIEIAEQzAELCyEAIABFBEBBtLLAAEEyEOIBAAsgACACIAMg -ASgCEBEDAAsiACAALQAARQRAIAFBy+zAAEEFEDoPCyABQdDswABBBBA6Cx8AIABFBEBBtLLAAEEy -EOIBAAsgACACIAEoAhARAAALIQAgAEEANgIMIAAgAzYCCCAAIAI2AgQgAEH0s8AANgIACykAIAAg -AC0ABCABQS5GcjoABCAAKAIAIgAoAgAgASAAKAIEKAIQEQAACxgBAX8gACgCACIBBEAgACgCBCAB -EMwBCwsnAgFvAX8QESECEG8iAyACJgEgAEEANgIIIAAgAzYCBCAAIAE2AgALQgAgAARAIAAgARDn -AQALIwBBIGsiACQAIABBADYCGCAAQQE2AgwgAEHcyMAANgIIIABCBDcCECAAQQhqIAIQnwEACxUA -IAFpQQFGIABBgICAgHggAWtNcQscACAAQQA2AhAgAEIANwIIIABCgICAgMAANwIACxYBAW8gACAB -EAEhAhBvIgAgAiYBIAALFgEBbyAAIAEQBiECEG8iACACJgEgAAsWAQFvIAAlARAgIQEQbyIAIAEm -ASAAC+0GAQZ/An8CQAJAAkACQAJAIABBBGsiBSgCACIGQXhxIgRBBEEIIAZBA3EiBxsgAWpPBEAg -B0EAIAFBJ2oiCSAESRsNAQJAAkAgAkEJTwRAIAIgAxBIIggNAUEADAkLIANBzP97Sw0BQRAgA0EL -akF4cSADQQtJGyEBAkAgB0UEQCABQYACSSAEIAFBBHJJciAEIAFrQYGACE9yDQEMCQsgAEEIayIC -IARqIQcCQAJAAkACQCABIARLBEAgB0HshMEAKAIARg0EIAdB6ITBACgCAEYNAiAHKAIEIgZBAnEN -BSAGQXhxIgYgBGoiBCABSQ0FIAcgBhBMIAQgAWsiA0EQSQ0BIAUgASAFKAIAQQFxckECcjYCACAB -IAJqIgEgA0EDcjYCBCACIARqIgIgAigCBEEBcjYCBCABIAMQRAwNCyAEIAFrIgNBD0sNAgwMCyAF -IAQgBSgCAEEBcXJBAnI2AgAgAiAEaiIBIAEoAgRBAXI2AgQMCwtB4ITBACgCACAEaiIEIAFJDQIC -QCAEIAFrIgNBD00EQCAFIAZBAXEgBHJBAnI2AgAgAiAEaiIBIAEoAgRBAXI2AgRBACEDQQAhAQwB -CyAFIAEgBkEBcXJBAnI2AgAgASACaiIBIANBAXI2AgQgAiAEaiICIAM2AgAgAiACKAIEQX5xNgIE -C0HohMEAIAE2AgBB4ITBACADNgIADAoLIAUgASAGQQFxckECcjYCACABIAJqIgEgA0EDcjYCBCAH -IAcoAgRBAXI2AgQgASADEEQMCQtB5ITBACgCACAEaiIEIAFLDQcLIAMQKSIBRQ0BIANBfEF4IAUo -AgAiAkEDcRsgAkF4cWoiAiACIANLGyICBEAgASAAIAL8CgAACyAAEDkgAQwICyADIAEgASADSxsi -AgRAIAggACAC/AoAAAsgBSgCACICQXhxIgMgAUEEQQggAkEDcSICG2pJDQMgAkEAIAMgCUsbDQQg -ABA5CyAIDAYLQZXFwABBLkHExcAAEJQBAAtB1MXAAEEuQYTGwAAQlAEAC0GVxcAAQS5BxMXAABCU -AQALQdTFwABBLkGExsAAEJQBAAsgBSABIAZBAXFyQQJyNgIAIAEgAmoiAiAEIAFrIgFBAXI2AgRB -5ITBACABNgIAQeyEwQAgAjYCACAADAELIAALCxkAIAAoAgBB+LfAAEEeIAAoAgQoAgwRAQALDgAg -AQRAIAAgARDMAQsLGQAgASgCAEG358AAQQ4gASgCBCgCDBEBAAsWACAAKAIAIAEgAiAAKAIEKAIM -EQEACxQAIAAoAgAgASAAKAIEKAIMEQAAC4MIAQR/IwBB8ABrIgUkACAFIAM2AgwgBSACNgIIAn8g -AUGBAk8EQAJ/QYACIAAsAIACQb9/Sg0AGkH/ASAALAD/AUG/f0oNABpB/gFB/QEgACwA/gFBv39K -GwsiBiAAaiwAAEG/f0oEQEGP7cAAIQdBBQwCCyAAIAFBACAGIAQQvgEAC0EBIQcgASEGQQALIQgg -BSAGNgIUIAUgADYCECAFIAg2AhwgBSAHNgIYAkACQAJAAkAgASACSSIGIAEgA0lyRQRAIAIgA0sN -ASACRSABIAJNckUEQCAFQQxqIAVBCGogACACaiwAAEG/f0obKAIAIQMLIAUgAzYCICADIAEiAkkE -QCADQQFqIgIgA0EDayIGQQAgAyAGTxsiBkkNAwJ/IAIgBmsiB0EBayAAIANqLAAAQb9/Sg0AGiAH -QQJrIAAgAmoiAkECaywAAEG/f0oNABogB0EDayACQQNrLAAAQb9/Sg0AGiAHQXxBeyACQQRrLAAA -Qb9/ShtqCyAGaiECCwJAIAJFDQAgASACTQRAIAEgAkYNAQwFCyAAIAJqLAAAQb9/TA0ECwJ/AkAC -QCABIAJGDQACQAJAIAAgAmoiASwAACIAQQBIBEAgAS0AAUE/cSEGIABBH3EhAyAAQV9LDQEgA0EG -dCAGciEADAILIAUgAEH/AXE2AiRBAQwECyABLQACQT9xIAZBBnRyIQYgAEFwSQRAIAYgA0EMdHIh -AAwBCyADQRJ0QYCA8ABxIAEtAANBP3EgBkEGdHJyIgBBgIDEAEYNAQsgBSAANgIkIABBgAFPDQFB -AQwCCyAEENQBAAtBAiAAQYAQSQ0AGkEDQQQgAEGAgARJGwshACAFIAI2AiggBSAAIAJqNgIsIAVB -BTYCNCAFQZjuwAA2AjAgBUIFNwI8IAUgBUEYaq1CgICAgIAMhDcDaCAFIAVBEGqtQoCAgICADIQ3 -A2AgBSAFQShqrUKAgICAoAyENwNYIAUgBUEkaq1CgICAgLAMhDcDUCAFIAVBIGqtQoCAgICACYQ3 -A0gMBAsgBSACIAMgBhs2AiggBUEDNgI0IAVB2O7AADYCMCAFQgM3AjwgBSAFQRhqrUKAgICAgAyE -NwNYIAUgBUEQaq1CgICAgIAMhDcDUCAFIAVBKGqtQoCAgICACYQ3A0gMAwsgBUEENgI0IAVBuO3A -ADYCMCAFQgQ3AjwgBSAFQRhqrUKAgICAgAyENwNgIAUgBUEQaq1CgICAgIAMhDcDWCAFIAVBDGqt -QoCAgICACYQ3A1AgBSAFQQhqrUKAgICAgAmENwNIDAILIAYgAkHw7sAAENIBAAsgACABIAIgASAE -EL4BAAsgBSAFQcgAajYCOCAFQTBqIAQQnwEACxEAIAAoAgAgACgCBCABEOkBCxkAAn8gAUEJTwRA -IAEgABBIDAELIAAQKQsLDwAgACABKAIAIAIgAxBbCw8AIAAgASgCACACIAMQQwsRACAAKAIEIAAo -AgggARDpAQvgBgEPfyAAKAIAIQcgACgCBCEFQQAhACMAQRBrIgYkAEEBIQwCQCABKAIAIgpBIiAB -KAIEIg0oAhAiDhEAAA0AAkAgBUUEQAwBC0EAIAVrIQ8gByEBIAUhAAJAAn8CQANAIAAgAWohEEEA -IQMCQANAIAEgA2oiBC0AACIJQf8Aa0H/AXFBoQFJIAlBIkZyIAlB3ABGcg0BIAAgA0EBaiIDRw0A -CyAAIAhqDAMLIARBAWohAQJAIAQsAAAiAEEATgRAIABB/wFxIQAMAQsgAS0AAEE/cSELIABBH3Eh -CSAEQQJqIQEgAEFfTQRAIAlBBnQgC3IhAAwBCyABLQAAQT9xIAtBBnRyIQsgBEEDaiEBIABBcEkE -QCALIAlBDHRyIQAMAQsgCUESdEGAgPAAcSABLQAAQT9xIAtBBnRyciEAIARBBGohAQsgBkEEaiAA -QYGABBA1AkACQCAGLQAEQYABRg0AIAYtAA8gBi0ADmtB/wFxQQFGDQACQAJAIAIgAyAIaiIESw0A -AkAgAkUNACACIAVPBEAgAiAFRw0CDAELIAIgB2osAABBv39MDQELAkAgBEUNACAEIAVPBEAgBCAP -akUNAQwCCyAHIAhqIANqLAAAQUBIDQELIAogAiAHaiAIIAJrIANqIA0oAgwiAhEBAEUNAQwDCyAH -IAUgAiAEQdTswAAQvgEACwJAIAYtAARBgAFGBEAgCiAGKAIIIA4RAAANAwwBCyAKIAYtAA4iBCAG -QQRqaiAGLQAPIARrIAIRAQANAgsCf0EBIABBgAFJDQAaQQIgAEGAEEkNABpBA0EEIABBgIAESRsL -IAhqIANqIQILAn9BASAAQYABSQ0AGkECIABBgBBJDQAaQQNBBCAAQYCABEkbCyAIaiIEIANqIQgg -ECABayIARQ0CDAELCwwECyADIARqCyIDIAJJDQBBACEAAkAgAkUNACACIAVPBEAgAiIAIAVHDQIM -AQsgAiIAIAdqLAAAQb9/TA0BCyADRQRAQQAhAwwCCyADIAVPBEAgAyAFRg0CIAAhAgwBCyADIAdq -LAAAQb9/Sg0BIAAhAgsgByAFIAIgA0Hk7MAAEL4BAAsgCiAAIAdqIAMgAGsgDSgCDBEBAA0AIApB -IiAOEQAAIQwLIAZBEGokACAMCxYAQaiBwQAgADYCAEGkgcEAQQE2AgALIgAgAELtuq22zYXU9eMA -NwMIIABC+IKZvZXuxsW5fzcDAAshACAAQoC834WrpfibJzcDCCAAQp/1lpTW7u3DoX83AwALEwAg -AEGAx8AANgIEIAAgATYCAAsRACABIAAoAgAgACgCBBC8AQsQACABIAAoAgAgACgCBBA6CxAAIAEo -AgAgASgCBCAAEDwLYQECfwJAAkAgAEEEaygCACICQXhxIgNBBEEIIAJBA3EiAhsgAWpPBEAgAkEA -IAMgAUEnaksbDQEgABA5DAILQZXFwABBLkHExcAAEJQBAAtB1MXAAEEuQYTGwAAQlAEACwsdAQFv -IAAoAgAlASABJQEgARBsIAIlASACEGwQDgsXAQFvIAAoAgAlASABIAIlASACEGwQGwsNACAAKAIA -KAIIQQFGC2sBAX8jAEEwayIDJAAgAyABNgIEIAMgADYCACADQQI2AgwgA0HY/cAANgIIIANCAjcC -FCADIANBBGqtQoCAgICACYQ3AyggAyADrUKAgICAgAmENwMgIAMgA0EgajYCECADQQhqIAIQnwEA -C2sBAX8jAEEwayIDJAAgAyABNgIEIAMgADYCACADQQI2AgwgA0H4/cAANgIIIANCAjcCFCADIANB -BGqtQoCAgICACYQ3AyggAyADrUKAgICAgAmENwMgIAMgA0EgajYCECADQQhqIAIQnwEAC2sBAX8j -AEEwayIDJAAgAyABNgIEIAMgADYCACADQQI2AgwgA0Gs/sAANgIIIANCAjcCFCADIANBBGqtQoCA -gICACYQ3AyggAyADrUKAgICAgAmENwMgIAMgA0EgajYCECADQQhqIAIQnwEACwsAIAAoAgAgARBL -Cw8AQeDnwABBKyAAEJQBAAsNACAAKQMAQQEgARBJCw4AIAFBmITAAEEFELwBCw4AIAFB9IXAAEEO -ELwBCw4AIAFBkInAAEEKELwBCwsAIAAoAgAgARByCwwAIAAoAgAgARDTAQuKAwEBfyAAKAIAIQIj -AEHQAWsiACQAIAAgAkEYaq1CgICAgIAHhDcDaCAAIAJBEGqtQoCAgICAB4Q3A2AgACACQQhqrUKA -gICAgAeENwNYIAAgAq1CgICAgIAHhDcDUCAAQZi4wAA2AjggAEEENgI8IABBBDYCTCAAQoOAgICA -hICAaTcCyAEgAEGAgMAANgLAASAAQQI7AbgBIABCgoCAgICEgIBpNwKwASAAQYCAwAA2AqgBIABB -AjsBoAEgAEKBgICAgISAgGk3ApgBIABBgIDAADYCkAEgAEECOwGIASAAQoCAgICAhICAaTcCgAEg -AEKAgMAANwJ4IABBAjsBcCAAIABB8ABqNgJIIABBBDYCRCAAIABB0ABqNgJAIABBLGoiAiAAQThq -EEcgACACrUKAgICAkAeENwMgIABBATYCDCAAQai5wAA2AgggAEIBNwIUIAAgAEEgajYCECABKAIA -IAEoAgQgAEEIahA8IAAoAiwiAgRAIAAoAjAgAhDMAQsgAEHQAWokAAsNACAAQYSRwAAgARA8Cw4A -IAFBiI/AAEEFELwBCw4AIAFB5rLAAEELELwBCw0AIABB2LzAACABEDwLDQBBlMLAAEEbEOIBAAsO -AEGvwsAAQc8AEOIBAAsJACAAIAEQJQALDQAgAEHUxMAAIAEQPAsMACAAIAEpAgA3AwALDQAgAEGw -yMAAIAEQPAsOACABQajIwABBBRC8AQsaACAAIAFBrIHBACgCACIAQckAIAAbEQIAAAsNACAAQYTq -wAAgARA8CwoAIAIgACABEDoLCgAgACABJQEQAgsOACABQfC8wABBCBC8AQsOACABQfq+wABBAxC8 -AQsJACAAQQA2AgALCAAgACUBEAMLCAAgACUBEBILCAAgACUBECILBABBAAsCAAsLpoABDgBBgIDA -AAvJAi9ob21lL2NveW90dGU1MDgvY29kZS9odWdnaW5nZmFjZS5qcy9wYWNrYWdlcy9odWIveGV0 -LWNvcmUtd2FzbS1idWlsZC9tZXJrbGVoYXNoL3NyYy9hZ2dyZWdhdGVkX2hhc2hlcy5ycwAAAAAA -EABpAAAAWQAAADgAAAAAABAAaQAAAFkAAAAPAAAAAAAQAGkAAABWAAAAOQAAAC9ob21lL2NveW90 -dGU1MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS14ODZfNjQtdW5rbm93bi1saW51eC1nbnUv -bGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvdmVjL3NwZWNfZnJvbV9pdGVy -X25lc3RlZC5ycwCcABAAhwAAADQAAAAFAAAABAAAAAwAAAAEAAAABQAAAAYAAAAHAEHUgsAAC4UF -AQAAAAgAAABhIERpc3BsYXkgaW1wbGVtZW50YXRpb24gcmV0dXJuZWQgYW4gZXJyb3IgdW5leHBl -Y3RlZGx5L2hvbWUvY295b3R0ZTUwOC8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLXg4Nl82NC11 -bmtub3duLWxpbnV4LWdudS9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2FsbG9jL3NyYy9z -dHJpbmcucnMAkwEQAHQAAADRCgAADgAAAEVycm9yAAAAkwEQAHQAAAB9BQAAGwAAAAAAAAAEAAAA -BAAAAAkAAABPa0Vyci9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS14 -ODZfNjQtdW5rbm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxv -Yy9zcmMvc2xpY2UucnNFAhAAcwAAAL4BAAAdAAAAAQAAAAAAAABKc0NodW5raGFzaGxlbmd0aAAA -ANcCEAAEAAAA2wIQAAYAAABzdHJ1Y3QgSnNDaHVua2F0dGVtcHRlZCB0byB0YWtlIG93bmVyc2hp -cCBvZiBSdXN0IHZhbHVlIHdoaWxlIGl0IHdhcyBib3Jyb3dlZC9ob21lL2NveW90dGU1MDgvLmNh -cmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi93YXNtLWJp -bmRnZW4tMC4yLjEwMC9zcmMvY29udmVydC9zbGljZXMucnNzcmMvbGliLnJzALEDEAAKAAAANwAA -ABQAAABBAxAAcAAAACQBAAAOAEH8h8AAC4EBL2hvbWUvY295b3R0ZTUwOC8ucnVzdHVwL3Rvb2xj -aGFpbnMvc3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9saWIvcnVzdGxpYi9zcmMvcnVz -dC9saWJyYXJ5L2FsbG9jL3NyYy9zdHJpbmcucnP8AxAAdAAAAOgBAAAXAEGIicAAC5UBAQAAAAoA -AABhIHNlcXVlbmNlL2hvbWUvY295b3R0ZTUwOC8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNy -YXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3NlcmRlLTEuMC4yMTkvc3JjL2RlL2ltcGxzLnJzAAAA -mgQQAGMAAACVBAAAIgAAAJoEEABjAAAAmAQAABwAQaiKwAALBQEAAAALAEG4isAACwUBAAAADABB -yIrAAAvlAQEAAAANAAAAY2FsbGVkIGBPcHRpb246OnVud3JhcF90aHJvdygpYCBvbiBhIGBOb25l -YCB2YWx1ZWhhc2hsZW5ndGgvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFi -bGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkv -YWxsb2Mvc3JjL3Jhd192ZWMvbW9kLnJziwUQAHkAAAAuAgAAEQAAACA6IAoBAAAAAAAAABQGEAAD -AAAAFwYQAAEAQbiMwAALwwkBAAAAEQAAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4g -YEVycmAgdmFsdWUvaG9tZS9jb3lvdHRlNTA4L2NvZGUvaHVnZ2luZ2ZhY2UuanMvcGFja2FnZXMv -aHViL3hldC1jb3JlLXdhc20tYnVpbGQvbWVya2xlaGFzaC9zcmMvYWdncmVnYXRlZF9oYXNoZXMu -cnNrBhAAaQAAAD0AAAAqAAAAawYQAGkAAAA4AAAAHgAAAC9ob21lL2NveW90dGU1MDgvLnJ1c3R1 -cC90b29sY2hhaW5zL3N0YWJsZS14ODZfNjQtdW5rbm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIv -c3JjL3J1c3QvbGlicmFyeS9jb3JlL3NyYy9pdGVyL3RyYWl0cy9pdGVyYXRvci5ycwAAAPQGEACB -AAAAwQcAAAkAAABFcnJvci9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJs -ZS14ODZfNjQtdW5rbm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9h -bGxvYy9zcmMvc3RyaW5nLnJzAAAAjQcQAHQAAAB9BQAAGwAAAGludmFsaWQgdmFsdWU6ICwgZXhw -ZWN0ZWQgAAAUCBAADwAAACMIEAALAAAAbWlzc2luZyBmaWVsZCBgYEAIEAAPAAAATwgQAAEAAABk -dXBsaWNhdGUgZmllbGQgYAAAAGAIEAARAAAATwgQAAEAAAASAAAADAAAAAQAAAATAAAAFAAAAAcA -AAAvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25v -d24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3NsaWNl -LnJzAJwIEABzAAAAvgEAAB0AAAAvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9z -dGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJh -cnkvYWxsb2Mvc3JjL3ZlYy9zcGVjX2Zyb21faXRlcl9uZXN0ZWQucnMAIAkQAIcAAAATAAAABQAA -AGludmFsaWQgdHlwZTogLCBleHBlY3RlZCAAAAC4CRAADgAAAMYJEAALAAAAL2hvbWUvY295b3R0 -ZTUwOC8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9s -aWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2FsbG9jL3NyYy9zbGljZS5ycwDkCRAAcwAAAL4B -AAAdAAAAAQAAAAAAAAAvaG9tZS9jb3lvdHRlNTA4Ly5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXgu -Y3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvc2VyZGUtd2FzbS1iaW5kZ2VuLTAuNi41L3NyYy9s -aWIucnMAAABwChAAaQAAADUAAAAOAAAAAAAAAP//////////8AoQAEGIlsAAC4UfAQAAAC9ob21l -L2NveW90dGU1MDgvY29kZS9odWdnaW5nZmFjZS5qcy9wYWNrYWdlcy9odWIveGV0LWNvcmUtd2Fz -bS1idWlsZC9kZWR1cGxpY2F0aW9uL3NyYy9jaHVua2luZy5ycwAMCxAAYwAAAB4AAAAJAAAAYXNz -ZXJ0aW9uIGZhaWxlZDogdGFyZ2V0X2NodW5rX3NpemUgPiA2NAwLEABjAAAAIgAAAAkAAAAMCxAA -YwAAAC4AAAAdAAAAYXNzZXJ0aW9uIGZhaWxlZDogbWF4aW11bV9jaHVuayA+IG1pbmltdW1fY2h1 -bmsADAsQAGMAAAAxAAAACQAAAAwLEABjAAAAOwAAABcAAAAMCxAAYwAAAGUAAAA7AAAADAsQAGMA -AACHAAAAMgAAAAwLEABjAAAAiQAAADoAAAAMCxAAYwAAALEAAAAVAAAADAsQAGMAAACuAAAAQAAA -AC9ob21lL2NveW90dGU1MDgvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0 -OWNmOGM2YjViNTU3Zi9sYXp5X3N0YXRpYy0xLjUuMC9zcmMvaW5saW5lX2xhenkucnMAAGgMEABq -AAAAHgAAABAAAAAvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2 +gIAQVA0AIAtBKEYNFyABQcgCaiALQQJ0aiAlPgIAIAtBAWohCwsgASALNgLoAyASIAkgCSASSRsi +AkEoTQ0ACwsMEQsgAUEBEC0aIAEoAowFIgAgASgCoAEiAiAAIAJLGyIAQSlPDQQgAEECdCEAIAFB +BGshAiABQegDaiEDA0AgAEUNDiAAIANqIQkgACACaiAAQQRrIQAoAgAiDCAJKAIAIglGDQALIAkg +DE0NDgwPCyAGQShB7PzAABDUAQALIANBKEHs/MAAENQBAAsgA0EoQez8wAAQ1AEAC0ERQRFB2NXA +ABCAAQALDA0LDA0LDAsLDAsLQYjWwABBN0HA1sAAEJYBAAtB0NbAAEE2QYjXwAAQlgEAC0Hs1MAA +QRxBiNXAABCWAQALQbzUwABBHUHc1MAAEJYBAAtBj9TAAEEcQazUwAAQlgEACyAADQELIAYgDWoh +AiAKIQBBfyEFAkADQCAAQX9GDQEgBUEBaiEFIAAgDWogAEEBayEALQAAQTlGDQALIAAgDWoiAkEB +aiIDIAMtAABBAWo6AAAgBUUgAEECaiAKS3INASACQQJqQTAgBfwLAAwBCyANQTE6AAAgCgRAIA1B +AWpBMCAK/AsACyAGQRFJBEAgAkEwOgAAIA5BAWohDiAKQQJqIQYMAQsgBkERQejVwAAQgAEACyAG +QRFNBEAgDyAOOwEIIA8gBjYCBCAPIA02AgAgAUGgCmokAAwFCyAGQRFB+NXAABDUAQALIAJBKEHs +/MAAENQBAAtB/PzAAEEaQez8wAAQlgEACyAAQShB7PzAABDUAQALQShBKEHs/MAAEIABAAsLIAcg +BygCUCAHKAJUIAcvAVhBACAHQSBqEFEgBygCBCEAIAcoAgAMAQsgB0ECOwEgIAdBATYCKCAHQfvn +wAA2AiQgB0EgagshASAHIAA2AlwgByABNgJYIAcgGzYCVCAHIBc2AlAgB0HQAGoQPyAHQYABaiQA +DwsCfyABIQwgAkEARyECIAEvAQ4hEUEAIQEjAEHwCGsiByQAID+9IScCf0EDID+ZRAAAAAAAAPB/ +YQ0AGkECICdCgICAgICAgPj/AIMiJkKAgICAgICA+P8AUQ0AGiAnQv////////8HgyIpQoCAgICA +gIAIhCAnQgGGQv7///////8PgyAnQjSIp0H/D3EiABsiJUIBgyEoICZQBEBBBCApUA0BGiAAQbMI +ayEBQgEhJiAoUAwBC0KAgICAgICAICAlQgGGICVCgICAgICAgAhRIgEbISVCAkIBIAEbISZBy3dB +zHcgARsgAGohASAoUAshACAHIAE7AegIIAcgJjcD4AggB0IBNwPYCCAHICU3A9AIIAcgADoA6ggC +QAJ/AkACQAJAAkAgAEECayIDBEBBASEAQfPnwABB9OfAACAnQgBTIgYbQfPnwABBASAGGyACGyEb +ICdCP4inIAJyIR1BAyADIANBA08bQQJrDgICAwELIAdBAzYCmAggB0H158AANgKUCCAHQQI7AZAI +QQEhG0EBIQAgB0GQCGoMBAsgB0EDNgKYCCAHQfjnwAA2ApQIIAdBAjsBkAggB0GQCGoMAwtBAiEA +IAdBAjsBkAggEUUNASAHIBE2AqAIIAdBADsBnAggB0ECNgKYCCAHQfHnwAA2ApQIIAdBkAhqDAIL +QXRBBSABwSIAQQBIGyAAbCIAQcD9AEkEQCAHQZAIaiEEIAdBEGohBSAAQQR2QRVqIgohAUGAgH5B +ACARayARwUEASBshCQJAAkACfwJAAkACQAJAIAdB0AhqIgApAwAiJVBFBEAgJUKAgICAgICAgCBa +DQEgAUUNAkGgfyAALwEYIgBBIGsgACAlQoCAgIAQVCIAGyICQRBrIAIgJUIghiAlIAAbIiVCgICA +gICAwABUIgAbIgJBCGsgAiAlQhCGICUgABsiJUKAgICAgICAgAFUIgAbIgJBBGsgAiAlQgiGICUg +ABsiJUKAgICAgICAgBBUIgAbIgJBAmsgAiAlQgSGICUgABsiJUKAgICAgICAgMAAVCIAGyAlQgKG +ICUgABsiJUIAWWsiA2vBQdAAbEGwpwVqQc4QbSIAQdEATw0DIABBBHQiAkG42MAAaikDACImQv// +//8PgyInICUgJUJ/hUI/iIYiJUIgiCIofiIpQiCIICZCIIgiJiAofnwgJiAlQv////8PgyIlfiIm +QiCIfCApQv////8PgyAlICd+QiCIfCAmQv////8Pg3xCgICAgAh8QiCIfCIlQUAgAyACQcDYwABq +LwEAamsiC0E/ca0iJ4inIQAgAkHC2MAAai8BACECICVCASAnhiIoQgF9IimDIiZQBEAgAUEKSw0H +IAFBAnRBzOXAAGooAgAgAEsNBwsgAEGQzgBPBEAgAEHAhD1JDQUgAEGAwtcvTwRAQQhBCSAAQYCU +69wDSSIDGyEGQYDC1y9BgJTr3AMgAxsMBwtBBkEHIABBgK3iBEkiAxshBkHAhD1BgK3iBCADGwwG +CyAAQeQATwRAQQJBAyAAQegHSSIDGyEGQeQAQegHIAMbDAYLQQpBASAAQQlLIgYbDAULQY/UwABB +HEH85MAAEJYBAAtBjOXAAEEkQbDlwAAQlgEAC0HY5MAAQSFBwOXAABCWAQALIABB0QBB+OLAABCA +AQALQQRBBSAAQaCNBkkiAxshBkGQzgBBoI0GIAMbCyEDAkACQAJAAkAgBiACa0EBasEiCCAJwSIC +SgRAIAtB//8DcSEOIAggCWvBIAEgCCACayABSRsiC0EBayEPQQAhAgNAIAAgA24hDSABIAJGDQMg +ACADIA1sayEAIAIgBWogDUEwajoAACACIA9GDQQgAiAGRg0CIAJBAWohAiADQQpJIANBCm4hA0UN +AAtB+OXAABCcAQALIAQgBSABQQAgCCAJICVCCoAgA60gJ4YgKBBFDAULIAJBAWohAiAOQQFrQT9x +rSEqQgEhJQNAICUgKohQRQRAIARBADYCAAwGCyABIAJNDQMgAiAFaiAmQgp+IiYgJ4inQTBqOgAA +ICVCCn4hJSAmICmDISYgCyACQQFqIgJHDQALIAQgBSABIAsgCCAJICYgKCAlEEUMBAsgASABQYjm +wAAQgAEACyAEIAUgASALIAggCSAArSAnhiAmfCADrSAnhiAoEEUMAgsgAiABQZjmwAAQgAEACyAE +QQA2AgALIAnBIRgCQCAHKAKQCARAIAdByAhqIAdBmAhqKAIANgIAIAcgBykCkAg3A8AIDAELIAdB +wAhqIRIgB0EQaiEJIwBBwAZrIgUkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAHQdAIaiIAKQMA +IiVQRQRAIAApAwgiJlANASAAKQMQIidQDQIgJSAnfCAlVA0DICUgJlQNBCAALgEYIQAgBSAlPgIM +IAVBAUECICVCgICAgBBUIgEbNgKsASAFQQAgJUIgiKcgARs2AhAgBUEUakEAQZgB/AsAIAVBtAFq +QQBBnAH8CwAgBUEBNgKwASAFQQE2AtACIACsICVCAX15fULCmsHoBH5CgKHNoLQCfEIgiKciAcEh +DQJAIABBAE4EQCAFQQxqIAAQLRoMAQsgBUGwAWpBACAAa8EQLRoLAkAgDUEASARAIAVBDGpBACAN +a0H//wNxECsMAQsgBUGwAWogAUH//wFxECsLIAUoAtACIQsgBUGcBWogBUGwAWpBoAH8CgAAIAUg +CzYCvAYgCiIGQQpPBEAgBUGUBWohAgNAIAUoArwGIgRBKU8NCgJAIARFDQAgBEH/////A2ohACAE +QQJ0IQECfyAEQQFGBEBCACElIAVBnAVqIAFqDAELIAEgAmohBCAAQf////8DcUEBakH+////B3Eh +A0IAISUDQCAEQQRqIgEgATUCACAlQiCGhCIlQoCU69wDgCImPgIAIAQgBDUCACAlICZCgJTr3AN+ +fUIghoQiJUKAlOvcA4AiJj4CACAlICZCgJTr3AN+fSElIARBCGshBCADQQJrIgMNAAsgJUIghiEl +IARBCGoLIABBAXENAEEEayIAICUgADUCAIRCgJTr3AOAPgIACyAGQQlrIgZBCUsNAAsLIAZBAnRB +0OXAAGooAgBBAXQiAkUNBSAFKAK8BiIEQSlPDQggBAR/IARB/////wNqIQAgBEECdCEBIAKtISUC +fyAEQQFGBEBCACEmIAVBnAVqIAFqDAELIAEgBWpBlAVqIQQgAEH/////A3FBAWpB/v///wdxIQNC +ACEmA0AgBEEEaiIBIAE1AgAgJkIghoQiJiAlgCInPgIAIAQgBDUCACAmICUgJ359QiCGhCImICWA +Iic+AgAgJiAlICd+fSEmIARBCGshBCADQQJrIgMNAAsgJkIghiEmIARBCGoLIQEgAEEBcUUEQCAB +QQRrIgAgJiAANQIAhCAlgD4CAAsgBSgCvAYFQQALIQECQAJAAkAgBSgCrAEiACABIAAgAUsbIgFB +KE0EQCABRQRAQQAhAQwECyABQQFxIQ4gAUEBRw0BQQAhBkEAIQgMAgsMFAsgAUE+cSEPQQAhBiAF +QZwFaiEEIAVBDGohA0EAIQgDQCAEIAQoAgAiFyADKAIAaiICIAZBAXFqIhM2AgAgBEEEaiIGIAYo +AgAiGSADQQRqKAIAaiIGIAIgF0kgAiATS3JqIgI2AgAgBiAZSSACIAZJciEGIANBCGohAyAEQQhq +IQQgDyAIQQJqIghHDQALCyAOBH8gCEECdCICIAVBnAVqaiIDIAMoAgAiAyAFQQxqIAJqKAIAaiIC +IAZqIgY2AgAgAiADSSACIAZLcgUgBgtBAXFFDQAgAUEoRg0KIAVBnAVqIAFBAnRqQQE2AgAgAUEB +aiEBCyAFIAE2ArwGIAsgASABIAtJGyIEQSlPDQggBEECdCEEAkACQANAIARFDQEgBEEEayIEIAVB +nAVqaigCACIBIAQgBUGwAWpqKAIAIgJGDQALIAEgAk8NAQwICyAEDQcLIA1BAWohDQwHC0GP1MAA +QRxBmNfAABCWAQALQbzUwABBHUGo18AAEJYBAAtB7NTAAEEcQbjXwAAQlgEAC0HQ1sAAQTZBqNjA +ABCWAQALQYjWwABBN0GY2MAAEJYBAAtBs/3AAEEbQez8wAAQlgEACyAARQRAQQAhACAFQQA2AqwB +DAELIABBAWtB/////wNxIgFBAWoiAkEDcSEDAkAgAUEDSQRAIAVBDGohBEIAISUMAQsgAkH8//// +B3EhASAFQQxqIQRCACElA0AgBCAENQIAQgp+ICV8IiU+AgAgBEEEaiICIAI1AgBCCn4gJUIgiHwi +JT4CACAEQQhqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIARBDGoiAiACNQIAQgp+ICVCIIh8IiY+AgAg +JkIgiCElIARBEGohBCABQQRrIgENAAsLIAMEQANAIAQgBDUCAEIKfiAlfCImPgIAIARBBGohBCAm +QiCIISUgA0EBayIDDQALCyAmQoCAgIAQWgRAIABBKEYNAyAFQQxqIABBAnRqICU+AgAgAEEBaiEA +CyAFIAA2AqwBC0EAIQYCQAJAAkACQCANwSIBIBjBIgJIIh5FBEAgDSAYa8EgCiABIAJrIApJGyII +DQELQQAhCAwBCyAFQdQCaiIBIAVBsAFqIgBBoAH8CgAAIAUgCzYC9ANBASEXIAFBARAtIR8gBSgC +0AIhASAFQfgDaiICIABBoAH8CgAAIAUgATYCmAUgAkECEC0hICAFKALQAiEBIAVBnAVqIgIgAEGg +AfwKAAAgBSABNgK8BiAFQawBaiEhIAVB0AJqISIgBUH0A2ohFCAFQZgFaiEjQQAhDiACQQMQLSEk +IAUoAqwBIQAgBSgC0AIhCyAFKAL0AyETIAUoApgFIRkgBSgCvAYhEAJAAkACQAJAA0AgAEEpTw0K +IABBAnQhAUEAIQQCfwJAAkADQCABIARGDQEgBUEMaiAEaiAEQQRqIQQoAgBFDQALIBAgACAAIBBJ +GyIBQSlPDRQgAUECdCEEAkADQCAERQ0BIAQgI2ohAiAEQQRrIgQgBUEMamooAgAiAyACKAIAIgJG +DQALIAIgA00NAkEADAMLIARFDQFBAAwCCyAIIApLDQQgCCAORg0IIAggDmsiAEUNCCAJIA5qQTAg +APwLAAwIC0EBIQZBACEAIAFBAUcEQCABQT5xIQ8gBUEMaiEEIAVBnAVqIQMDQCAEIAQoAgAiFSAD +KAIAQX9zaiICIAZBAXFqIhY2AgAgBEEEaiIGIAYoAgAiGiADQQRqKAIAQX9zaiIGIAIgFUkgAiAW +S3JqIgI2AgAgBiAaSSACIAZJciEGIANBCGohAyAEQQhqIQQgDyAAQQJqIgBHDQALCyABQQFxBH8g +AEECdCIAIAVBDGpqIgIgAigCACICIAAgJGooAgBBf3NqIgAgBmoiAzYCACAAIAJJIAAgA0tyBSAG +C0EBcUUNDCAFIAE2AqwBIAEhAEEICyEPIBkgACAAIBlJGyICQSlPDQMgAkECdCEEAkACQAJAA0Ag +BEUNASAEIBRqIQEgBEEEayIEIAVBDGpqKAIAIgMgASgCACIBRg0ACyABIANNDQEgACECDAILIARF +DQAgACECDAELIAIEQEEBIQZBACEAIAJBAUcEQCACQT5xIRUgBUEMaiEEIAVB+ANqIQMDQCAEIAQo +AgAiFiADKAIAQX9zaiIBIAZBAXFqIho2AgAgBEEEaiIGIAYoAgAiHCADQQRqKAIAQX9zaiIGIAEg +FkkgASAaS3JqIgE2AgAgBiAcSSABIAZJciEGIANBCGohAyAEQQhqIQQgFSAAQQJqIgBHDQALCyAC +QQFxBH8gAEECdCIAIAVBDGpqIgEgASgCACIBIAAgIGooAgBBf3NqIgAgBmoiAzYCACAAIAFJIAAg +A0tyBSAGC0EBcUUNDQsgBSACNgKsASAPQQRyIQ8LIBMgAiACIBNJGyIBQSlPDQQgAUECdCEEAkAC +QAJAA0AgBEUNASAEICJqIQAgBEEEayIEIAVBDGpqKAIAIgMgACgCACIARg0ACyAAIANNDQEgAiEB +DAILIARFDQAgAiEBDAELIAEEQEEBIQZBACEAIAFBAUcEQCABQT5xIRUgBUEMaiEEIAVB1AJqIQMD +QCAEIAQoAgAiFiADKAIAQX9zaiICIAZBAXFqIho2AgAgBEEEaiIGIAYoAgAiHCADQQRqKAIAQX9z +aiIGIAIgFkkgAiAaS3JqIgI2AgAgBiAcSSACIAZJciEGIANBCGohAyAEQQhqIQQgFSAAQQJqIgBH +DQALCyABQQFxBH8gAEECdCIAIAVBDGpqIgIgAigCACICIAAgH2ooAgBBf3NqIgAgBmoiAzYCACAA +IAJJIAAgA0tyBSAGC0EBcUUNDQsgBSABNgKsASAPQQJqIQ8LIAsgASABIAtJGyIAQSlPDQogAEEC +dCEEAkACQAJAA0AgBEUNASAEICFqIQIgBEEEayIEIAVBDGpqKAIAIgMgAigCACICRg0ACyACIANN +DQEgASEADAILIARFDQAgASEADAELIAAEQEEBIQZBACEBIABBAUcEQCAAQT5xIRUgBUEMaiEEIAVB +sAFqIQMDQCAEIAQoAgAiFiADKAIAQX9zaiICIAZBAXFqIho2AgAgBEEEaiIGIAYoAgAiHCADQQRq +KAIAQX9zaiIGIAIgFkkgAiAaS3JqIgI2AgAgBiAcSSACIAZJciEGIANBCGohAyAEQQhqIQQgFSAB +QQJqIgFHDQALCyAAQQFxBH8gAUECdCIBIAVBDGpqIgIgAigCACICIAVBsAFqIAFqKAIAQX9zaiIB +IAZqIgM2AgAgASACSSABIANLcgUgBgtBAXFFDQ0LIAUgADYCrAEgD0EBaiEPCyAKIA5NDQEgCSAO +aiAPQTBqOgAAIABBKU8NCgJAIABFBEBBACEADAELIABBAWtB/////wNxIgFBAWoiAkEDcSEDAkAg +AUEDSQRAIAVBDGohBEIAISYMAQsgAkH8////B3EhASAFQQxqIQRCACEmA0AgBCAENQIAQgp+ICZ8 +IiU+AgAgBEEEaiICIAI1AgBCCn4gJUIgiHwiJT4CACAEQQhqIgIgAjUCAEIKfiAlQiCIfCIlPgIA +IARBDGoiAiACNQIAQgp+ICVCIIh8IiU+AgAgJUIgiCEmIARBEGohBCABQQRrIgENAAsLIAMEQANA +IAQgBDUCAEIKfiAmfCIlPgIAIARBBGohBCAlQiCIISYgA0EBayIDDQALCyAlQoCAgIAQVA0AIABB +KEYNCiAFQQxqIABBAnRqICY+AgAgAEEBaiEACyAFIAA2AqwBIA5BAWohDiAXIAggF0siAWohFyAB +DQALQQEhBgwECyAOIApB+NfAABCAAQALIAggCkGI2MAAENQBAAsgAkEoQez8wAAQ1AEACwwMCwJA +AkACQCALQSlJBEACQCALRQRAQQAhCwwBCyALQQFrQf////8DcSIBQQFqIgJBA3EhAwJAIAFBA0kE +QCAFQbABaiEEQgAhJQwBCyACQfz///8HcSEBIAVBsAFqIQRCACElA0AgBCAENQIAQgV+ICV8IiU+ +AgAgBEEEaiICIAI1AgBCBX4gJUIgiHwiJT4CACAEQQhqIgIgAjUCAEIFfiAlQiCIfCIlPgIAIARB +DGoiAiACNQIAQgV+ICVCIIh8IiY+AgAgJkIgiCElIARBEGohBCABQQRrIgENAAsLIAMEQANAIAQg +BDUCAEIFfiAlfCImPgIAIARBBGohBCAmQiCIISUgA0EBayIDDQALCyAmQoCAgIAQVA0AIAtBKEYN +CCAFQbABaiALQQJ0aiAlPgIAIAtBAWohCwsgBSALNgLQAiALIAAgACALSRsiBEEpTw0GIARBAnQh +BCAFQQhqIQAgBUGsAWohAQJAAkADQCAERQ0BIAEgBGohAiAAIARqIARBBGshBCgCACIDIAIoAgAi +AkYNAAsgAiADTw0FDAELIAYgBEVxRQ0EIAhBAWsiACAKTw0CIAAgCWotAABBAXFFDQQLIAggCksN +AiAIIAlqQQAhBCAJIQMCQANAIAQgCEYNASAEQQFqIQQgA0EBayIDIAhqIgAtAABBOUYNAAsgACAA +LQAAQQFqOgAAIAggBGtBAWogCE8NBCAEQQFrIgFFDQQgAEEBakEwIAH8CwAMBAsCQCAIRQRAQTEh +BAwBCyAJQTE6AAAgCEEBRgRAQTAhBAwBC0EwIQQgCEEBayIARQ0AIAlBAWpBMCAA/AsACyANQQFq +IQ0gHiAIIApPcg0DIAQ6AAAgCEEBaiEIDAMLIAtBKEHs/MAAENQBAAsgACAKQcjXwAAQgAEACyAI +IApB2NfAABDUAQALIAggCksNAQsgEiANOwEIIBIgCDYCBCASIAk2AgAgBUHABmokAAwFCyAIIApB +6NfAABDUAQALIARBKEHs/MAAENQBAAtBKEEoQez8wAAQgAEACyAAQShB7PzAABDUAQALQfz8wABB +GkHs/MAAEJYBAAsLIBggBy4ByAgiAEgEQCAHQQhqIAcoAsAIIAcoAsQIIAAgESAHQZAIahBRIAco +AgwhACAHKAIIDAMLQQIhACAHQQI7AZAIIBFFBEBBASEAIAdBATYCmAggB0H758AANgKUCCAHQZAI +agwDCyAHIBE2AqAIIAdBADsBnAggB0ECNgKYCCAHQfHnwAA2ApQIIAdBkAhqDAILQfznwABBJUGk +6MAAEJYBAAtBASEAIAdBATYCmAggB0H758AANgKUCCAHQZAIagshASAHIAA2AswIIAcgATYCyAgg +ByAdNgLECCAHIBs2AsAIIAwgB0HACGoQPyAHQfAIaiQADAELIAFBKEHs/MAAENQBAAsLQgEBfyMA +QSBrIgMkACADQQA2AhAgA0EBNgIEIANCBDcCCCADIAE2AhwgAyAANgIYIAMgA0EYajYCACADIAIQ +oQEAC0ABAX8gASgCACIBIAEoAggiBEEBajYCCCAEQQBIBEAACyAAIAE2AgwgACADNgIIIAAgAjYC +BCAAQYC3wAA2AgALPAAgACABKQAANwAAIABBGGogAUEYaikAADcAACAAQRBqIAFBEGopAAA3AAAg +AEEIaiABQQhqKQAANwAAC5QCAQN/IAAoAgAhAiABKAIIIgBBgICAEHFFBEAgAEGAgIAgcUUEQCAC +IAEQ1gEPC0EAIQAjAEGAAWsiBCQAIAIoAgAhAgNAIAAgBGpB/wBqIAJBD3EiA0EwciADQTdqIANB +CkkbOgAAIABBAWshACACQQ9LIAJBBHYhAg0ACyABQQFBtuvAAEECIAAgBGpBgAFqQQAgAGsQNiAE +QYABaiQADwtBACEAIwBBgAFrIgQkACACKAIAIQIDQCAAIARqQf8AaiACQQ9xIgNBMHIgA0HXAGog +A0EKSRs6AAAgAEEBayEAIAJBD0sgAkEEdiECDQALIAFBAUG268AAQQIgACAEakGAAWpBACAAaxA2 +IARBgAFqJAALOAACQCACQYCAxABGDQAgACACIAEoAhARAABFDQBBAQ8LIANFBEBBAA8LIAAgAyAE +IAEoAgwRAQALLQACQCAAIAEQtgFFDQAgAARAQfmBwQAtAAAaIAAgARDDASIBRQ0BCyABDwsACzcB +AX8jAEEgayIBJAAgAUEANgIYIAFBATYCDCABQej9wAA2AgggAUIENwIQIAFBCGogABChAQAL5RkC +G38BfiMAQRBrIg0kACMAQSBrIgkkACMAQSBrIgQkACABrUIMfiIdpyEDAkACQAJAAkAgHUIgiKcg +A0H8////B0tyDQACfyADRQRAQQQhBUEADAELQfmBwQAtAAAaQQQhAiADQQQQwwEiBUUNASABCyEC +IARBADYCHCAEIAU2AhggBCACNgIUIAEEQCABQQJ0IQpBCCECA0AgBEEIaiAAIAhqKAIAIgMQ7QEg +BCgCCCIQRQ0DIAQoAgwhCyADQYQBTwRAIAMQbQsgBCgCFCAGRgRAIwBBIGsiAyQAQQQgBEEUaiIF +KAIAIgxBAXQiByAHQQRNGyIPrUIMfiIdQiCIUEUEQEEAQQBB8MLAABC1AQALAkAgHaciDkH8//// +B00EfyADIAwEfyADIAxBDGw2AhwgAyAFKAIENgIUQQQFQQALNgIYIANBCGpBBCAOIANBFGoQdCAD +KAIIQQFHDQEgAygCECEHIAMoAgwFQQALIAdB8MLAABC1AQALIAMoAgwhByAFIA82AgAgBSAHNgIE +IANBIGokACAEKAIYIQULIAIgBWoiAyALNgIAIANBBGsgEDYCACADQQhrIAs2AgAgBCAGQQFqIgY2 +AhwgAkEMaiECIAogCEEEaiIIRw0ACyAAIAFBAnQQzwELIAQoAhghAAJAIAYgBCgCFCIBTwRAIAAh +AgwBCyABQQxsIQEgBkUEQEEEIQIgACABEM8BDAELIAAgAUEEIAZBDGwiABC7ASICRQ0DCyAJIAY2 +AgQgCSACNgIAIARBIGokAAwDCyACIANB0MLAABC1AQALQYDDwABBKBDlAQALQQQgAEHgwsAAELUB +AAsgCSAJKAIEIgA2AhAgCSAJKAIANgIMIAkgADYCCCAJQRRqIRAjAEEwayIEJAAgCUEIaiIBKAIA +IQIgASgCBCEAIAEoAgghASAEQQA6AC8gBCAAIAFBDGxqNgIMIAQgAjYCCCAEIAA2AgQgBCAANgIA +IAQgBEEvajYCECAEQSBqIQUjAEHgAGsiAiQAAkACQAJAAkACQCAEKAIEIgEgBCgCDCIGRgRAIAEh +AAwBCyAEKAIQIQwgBCABQQxqIgA2AgQgASgCACEDIAJBOGogASgCBCIHIAEoAggQNyADBEAgByAD +EM8BCyACKAI4QQFxRQ0BIAxBAToAAAsgBUEANgIIIAVCgICAgIABNwIAIAYgAGtBDG4hASAAIAZH +BEADQCAAKAIAIgMEQCAAQQRqKAIAIAMQzwELIABBDGohACABQQFrIgENAAsLIAQoAggiAEUNASAE +KAIAIABBDGwQzwEMAQsgAkEwaiIDIAJB2ABqKQMANwMAIAJBKGoiByACQdAAaikDADcDACACQSBq +IgggAkHIAGopAwA3AwAgAiACKQNANwMYQfmBwQAtAAAaQYABQQgQwwEiAUUNASABIAIpAxg3AwAg +AUEYaiADKQMANwMAIAFBEGogBykDADcDACABQQhqIAgpAwA3AwAgAkEBNgIUIAIgATYCECACQQQ2 +AgwgBCgCCCEKIAQoAgAhDwJAIAAgBkYNACACQUBrIQhBICEHQQEhAwNAIAAoAgAhCyACQThqIABB +BGooAgAiDiAAQQhqKAIAEDcgCwRAIA4gCxDPAQsgAigCOEEBcQRAIAxBAToAACAAQQxqIQAMAgsg +AkEwaiIOIAhBGGopAwA3AwAgAkEoaiIRIAhBEGopAwA3AwAgAkEgaiITIAhBCGopAwA3AwAgAiAI +KQMANwMYIAIoAgwgA0YEQCACQQxqIANBAUEIQSAQVyACKAIQIQELIAEgB2oiCyACKQMYNwMAIAtB +GGogDikDADcDACALQRBqIBEpAwA3AwAgC0EIaiATKQMANwMAIAIgA0EBaiIDNgIUIAdBIGohByAA +QQxqIgAgBkcNAAsLIAYgAGtBDG4hASAAIAZHBEADQCAAKAIAIgMEQCAAQQRqKAIAIAMQzwELIABB +DGohACABQQFrIgENAAsLIAoEQCAPIApBDGwQzwELIAUgAikCDDcCACAFQQhqIAJBFGooAgA2AgAL +IAJB4ABqJAAMAQtBCEGAAUHEkcAAELUBAAsCQAJAAkACQAJAIAQtAC9BAUYEQCAEKAIgIgBFDQEg +BCgCJCAAQQV0EM8BDAELIAQoAiAiE0GAgICAeEcNAQsgBEEANgIoIARCgICAgBA3AiAgBEGcgcAA +NgIEIARCoICAgA43AgggBCAEQSBqNgIAIAQQvAENAiAEKAIgIQAgBCgCJCIBIAQoAigQuAEhAiAA +BEAgASAAEM8BCyAQQYCAgIB4NgIAIBAgAjYCBAwBCyAEKAIkIhkhACAEKAIoIQEjAEHgAGsiCCQA +IAhBADYCKCAIQQA2AhggCCAANgI4IAggACABQQV0ajYCPCAIQQxqIQtBACEBIwBBEGsiBiQAAkAC +QAJ/AkACQCAIQRhqIgUiACgCACIDBEAgACgCBCICIAAoAgxHDQEgACgCCCICBEAgAyACEM8BCyAA +QQA2AgALIAAoAiAiA0UNASADIAAoAiRGDQEgACADQSBqNgIgQfmBwQAtAAAaQSBBARDDASICRQ0D +IABBIDYCCCAAIAI2AgAgAiADKQAANwAAIAAgAkEgajYCDCACQRhqIANBGGopAAA3AAAgAkEQaiAD +QRBqKQAANwAAIAJBCGogA0EIaikAADcAAAsgACACQQFqNgIEIAItAAAhAEEBDAELIAAoAhAiAwRA +IAAoAhQiAiAAKAIcRwRAIAAgAkEBajYCFCACLQAAIQBBAQwCCyAAKAIYIgIEQCADIAIQzwELIABB +ADYCEAtBAAshAiAGIAA6AAEgBiACOgAADAELQQFBIEH8q8AAELUBAAsCQCAGLQAABEACQEEIQX8g +BSgCDCIPIAUoAgQiDGsiAiAFKAIcIhcgBSgCFCIAa0EAIAUoAhAiDhsiA2oiByACIAdLGyADIAUo +AgAiAxtBAWoiAkF/IAIbIgIgAkEITRsiAkEASA0AIAYtAAEhB0H5gcEALQAAGkEBIQEgAkEBEMMB +IgpFDQAgCiAHOgAAIAZBATYCDCAGIAo2AgggBiACNgIEIAUoAiQhGiAFKAIgIQcgBSgCGCEYIAUo +AgghEUEBIQUDQAJAAkACQAJ/AkAgA0UNACAMIAwgD0cNARogEUUNACADIBEQzwELIAdFIAcgGkZy +DQFB+YHBAC0AABpBIEEBEMMBIgNFDQIgAyAHKQAANwAAIANBGGogB0EYaikAADcAACADQRBqIAdB +EGopAAA3AAAgA0EIaiAHQQhqKQAANwAAQSAhESADQSBqIQ8gB0EgaiEHIAMLIgJBAWohDCAAIQEM +AgsCQCAORQ0AIAAgF0cEQCAAQQFqIQFBACEDIAAhAgwDCyAYRQ0AIA4gGBDPAQsgCyAGKQIENwIA +IAtBCGogBkEMaigCADYCAAwFC0EBQSBB/KvAABC1AQALIAItAAAhGyAGKAIEIAVGBEAgBkEEaiEK +IwBBIGsiACQAAkACQCAFQX8gDyAMayICIBcgAWtBACAOGyIUaiISIAIgEksbIBQgAxtBAWoiAkF/ +IAIbIAVqIgJLDQBBCCACIAooAgAiFEEBdCISIAIgEksbIgIgAkEITRsiEq0iHUIgiFBFDQAgHaci +HEH/////B0sNACAAIBQEfyAAIBQ2AhwgACAKKAIENgIUQQEFQQALNgIYIABBCGpBASAcIABBFGoQ +dCAAKAIIQQFHDQEgACgCECECIAAoAgwhFgsgFiACQbixwAAQtQEACyAAKAIMIQIgCiASNgIAIAog +AjYCBCAAQSBqJAAgBigCCCEKCyAFIApqIBs6AAAgBiAFQQFqIgU2AgwgASEADAALAAsgASACQYyw +wAAQtQEACyALQQA2AgggC0KAgICAEDcCAAJAIAUoAgAiAEUNACAFKAIIIgFFDQAgACABEM8BCyAF +KAIQIgBFDQAgBSgCGCIBRQ0AIAAgARDPAQsgBkEQaiQAIAhBQGsiAEGcsMAAIAgoAhAiASAIKAIU +EDQgBCAAEJgBIAgoAgwiAARAIAEgABDPAQsgCEHgAGokACAQIAQQZCATRQ0AIBkgE0EFdBDPAQsg +BEEwaiQADAELQcSBwABBNyAEQS9qQbSBwABB8ILAABB9AAsCQAJAIA0CfyAJKAIUIgJBgICAgHhG +BEBBACEAIAkoAhghAUEBDAELIAkoAhghAQJAIAkoAhwiFSACTwRAIAEhAAwBCyAVRQRAQQEhACAB +IAIQzwEMAQsgASACQQEgFRC7ASIARQ0CC0EAIQFBAAs2AgwgDSABNgIIIA0gFTYCBCANIAA2AgAg +CUEgaiQADAELQQEgFUHchsAAELUBAAsgDSgCACANKAIEIA0oAgggDSgCDCANQRBqJAALzw4CGX8B +fiMAQRBrIgokACMAQSBrIgckAAJAAkACQCAABEAgAEEIayINIA0oAgBBAWoiBjYCACAGRQ0BIAAo +AgANAiAAQX82AgAgByANNgIQIAcgADYCDCAHIAI2AhwgByABNgIYIAcgAjYCFCAHIABBCGoiBjYC +CEEAIQIjAEGAAWsiAyQAIANBCGohDiAHQRRqIhMoAgQhFCATKAIIIQgjAEGAAWsiASQAIAFBADYC +FCABQoCAgICAATcCDAJAAkAgCARAIAFByABqQQRyIQQDQCACIAhLDQIgAUHIAGogBiACIBRqIAgg +AmtBABAyIAFBIGoiESAEQQhqKQIANwMAIAFBKGoiEiAEQRBqKQIANwMAIAFBMGoiFSAEQRhqKQIA +NwMAIAFBOGoiFiAEQSBqKQIANwMAIAFBQGsiFyAEQShqKAIANgIAIAEgBCkCADcDGCABKAJ4IRgg +ASgCSCIZBEAgASgCFCIPIAEoAgxGBEAjAEEgayIFJABBBCABQQxqIgwoAgAiEEEBdCIJIAlBBE0b +IhqtQjB+IhxCIIhQRQRAQQBBAEHglsAAELUBAAsCQCAcpyIbQfj///8HTQRAIAUgEAR/IAUgEEEw +bDYCHCAFIAwoAgQ2AhRBCAVBAAs2AhggBUEIakEIIBsgBUEUahB0IAUoAghBAUcNASAFKAIMIQsg +BSgCECEJCyALIAlB4JbAABC1AQALIAUoAgwhCSAMIBo2AgAgDCAJNgIEIAVBIGokAAsgASgCECAP +QTBsaiIFIAEpAxg3AgQgBSAZNgIAIAVBDGogESkDADcCACAFQRRqIBIpAwA3AgAgBUEcaiAVKQMA +NwIAIAVBJGogFikDADcCACAFQSxqIBcoAgA2AgAgASAPQQFqNgIUCyACIBhqIgIgCEcNAAsLIA4g +ASkCDDcCACAOQQhqIAFBFGooAgA2AgAgAUGAAWokAAwBCyACIAhB8JbAABDTAQALAkACQAJAIAMo +AhAiAkUEQEEEIQQMAQtB+YHBAC0AABogAkEUbCIBQQQQwwEiBEUNAQsgA0EANgIcIAMgBDYCGCAD +IAI2AhQgAygCDCIFIAJBMGxqIQggAygCCCEMIAUhAQJAIAIEQCADQSxqIQ4gA0EwaiEJIANBIGpB +BHIiBEEIaiEPIARBGGohECAEQSBqIREgBEEoaiESIAEhAgNAIAIoAgAiAQRAIAMgATYCICAEIAJB +BGopAgA3AgAgDyACQQxqKQIANwIAIARBEGogAkEUaikCADcCACAQIAJBHGopAgA3AgAgESACQSRq +KQIANwIAIBIgAkEsaigCADYCACAGLQAwIQEgCRCDASELIANB0ABqIAkQZCADIAsgAUEBc3I6AGAg +AyADKAIoIgE2AlwgDiADKAIkIAEgAygCICgCEBEDACADKAIcIgEgAygCFEYEQCADQRRqQcyFwAAQ +ZwsgAygCGCABQRRsaiILIAMpAlA3AgAgC0EIaiADQdgAaikCADcCACALQRBqIANB4ABqKAIANgIA +IAZBAToAMCADIAFBAWo2AhwgAkEwaiICIAhHDQEMAwsLIAJBMGohAQsgASAIRg0AIAggAWsiAkEw +biIGQQFxQQAhBCACQTBrQTBPBEAgBkH+//8/cSEGIAEhAgNAIAJBDGogAkEEaigCACACQQhqKAIA +IAIoAgAoAhARAwAgAkE8aiACQTRqKAIAIAJBOGooAgAgAkEwaigCACgCEBEDACACQeAAaiECIAYg +BEECaiIERw0ACwtFDQAgASAEQTBsaiIBQQxqIAEoAgQgASgCCCABKAIAKAIQEQMACyAMBEAgBSAM +QTBsEM8BCyADQQA2AmQgAygCGCECQQEhBiADQfQAaiADQeQAaiADKAIcIgEQtAECQCADKAJ0RQRA +IAMoAnghAQwBCyADQfAAaiADQfwAaigCADYCACADIAMpAnQ3A2gCQCABBEAgAUEUbCEGIANB6ABq +QQRyIQUgAygCcCEEA0AgAyACIAMoAmgQYCADKAIEIQEgAygCAEEBcQ0CIAUgBCABENEBIAMgBEEB +aiIENgJwIAJBFGohAiAGQRRrIgYNAAsLQQAhBiADKAJsIQEMAQtBASEGIAMoAmwiAkGEAUkNACAC +EG0LIAMoAhwiBARAIAMoAhghAgNAIAIoAgAiBQRAIAJBBGooAgAgBRDPAQsgAkEUaiECIARBAWsi +BA0ACwsgAygCFCICBEAgAygCGCACQRRsEM8BCyATKAIAIgIEQCAUIAIQzwELIAcgATYCBCAHIAY2 +AgAgA0GAAWokAAwBC0EEIAFBvIXAABC1AQALIAcoAgQhASAHKAIAIQIgAEEANgIAIA0gDSgCAEEB +ayIANgIAIABFBEAgB0EQahCTAQsgCiACQQFxIgA2AgggCiABQQAgABs2AgQgCkEAIAEgABs2AgAg +B0EgaiQADAMLEOMBCwALEOQBAAsgCigCACAKKAIEIAooAgggCkEQaiQAC5oGAQh/IwBBEGsiBCQA +EHAiAiAAJgEjAEEQayIIJAAgCEEEaiEDIwBB0ABrIgEkACABQQxqIAIQLyABKAIQIQICQAJAAkAg +ASgCDCIFQYCAgIB4RgRAIAEgAjYCPCABQQA2AkggAUKAgICAEDcCQCABQZyBwAA2AhwgAUKggICA +DjcCICABIAFBQGs2AhggAUE8aiABQRhqEJEBDQIgASgCQCECIAEoAkQiBSABKAJIELgBIQYgAgRA +IAUgAhDPAQsgASgCPCICQYQBTwRAIAIQbQsgA0GAgICAeDYCACADIAY2AgQMAQsgASgCFCEGIAFB +ADoADCABIAIgBkEEdGo2AiQgASAFNgIgIAEgAjYCHCABIAI2AhggASABQQxqNgIoIAFBQGsgAUEY +ahAsAkACQCABLQAMQQFGBEAgASgCQCICRQ0BIAEoAkQgAkEobBDPAQwBCyABKAJAIgJBgICAgHhH +DQELIAFBADYCSCABQoCAgIAQNwJAIAFBnIHAADYCHCABQqCAgIAONwIgIAEgAUFAazYCGCABQRhq +ELwBDQIgASgCQCECIAEoAkQiBSABKAJIELgBIQYgAgRAIAUgAhDPAQsgA0GAgICAeDYCACADIAY2 +AgQMAQsgASgCRCEFAkAgASgCSCIGRQRAIAFBMGpCADcDACABQShqQgA3AwAgAUEgakIANwMAIAFC +ADcDGAwBCyABQRhqIAUgBhAxCyADIAFBGGoQZCACRQ0AIAUgAkEobBDPAQsgAUHQAGokAAwBC0HE +gcAAQTcgAUHPAGpBtIHAAEHwgsAAEH0ACwJAAkAgBAJ/IAgoAgQiAkGAgICAeEYEQCAIKAIIIQFB +ACEDQQEMAQsgCCgCCCEBAkAgCCgCDCIDIAJPBEAgASEHDAELIANFBEBBASEHIAEgAhDPAQwBCyAB +IAJBASADELsBIgdFDQILQQAhAUEACzYCDCAEIAE2AgggBCADNgIEIAQgBzYCACAIQRBqJAAMAQtB +ASADQdyGwAAQtQEACyAEKAIAIAQoAgQgBCgCCCAEKAIMIARBEGokAAuHBwEKfyMAQRBrIgQkABBw +IgIgACYBIwBBEGsiCCQAIAhBBGohBSMAQfAAayIBJAAgAUEIaiACEC8gASgCDCECAkACQAJAIAEo +AggiA0GAgICAeEYEQCABIAI2AmggAUEANgIwIAFCgICAgBA3AiggAUGcgcAANgJMIAFCoICAgA43 +AlAgASABQShqNgJIIAFB6ABqIAFByABqEJEBDQIgASgCKCECIAEoAiwiAyABKAIwELgBIQYgAgRA +IAMgAhDPAQsgASgCaCICQYQBTwRAIAIQbQsgBUGAgICAeDYCACAFIAY2AgQMAQsgASgCECEGIAFB +ADoACCABIAIgBkEEdGo2AlQgASADNgJQIAEgAjYCTCABIAI2AkggASABQQhqNgJYIAFBKGogAUHI +AGoQLAJAAkAgAS0ACEEBRgRAIAEoAigiAkUNASABKAIsIAJBKGwQzwEMAQsgASgCKCIGQYCAgIB4 +Rw0BCyABQQA2AjAgAUKAgICAEDcCKCABQZyBwAA2AkwgAUKggICADjcCUCABIAFBKGo2AkggAUHI +AGoQvAENAiABKAIoIQIgASgCLCIDIAEoAjAQuAEhBiACBEAgAyACEM8BCyAFQYCAgIB4NgIAIAUg +BjYCBAwBCyABKAIsIQkCQCABKAIwIgJFBEAgAUEgakIANwMAIAFBGGpCADcDACABQRBqQgA3AwAg +AUIANwMIDAELIAFBKGoiCiAJIAIQMSABQcgAaiIDQeyGwAAQmAEjAEEgayICJAAgAkEYaiADQRhq +KQAANwMAIAJBEGogA0EQaikAADcDACACQQhqIANBCGopAAA3AwAgAiADKQAANwMAIAFBCGogAiAK +QSAQNCACQSBqJAALIAUgAUEIahBkIAZFDQAgCSAGQShsEM8BCyABQfAAaiQADAELQcSBwABBNyAB +Qe8AakG0gcAAQfCCwAAQfQALAkACQCAEAn8gCCgCBCIFQYCAgIB4RgRAIAgoAgghAUEAIQJBAQwB +CyAIKAIIIQECQCAIKAIMIgIgBU8EQCABIQcMAQsgAkUEQEEBIQcgASAFEM8BDAELIAEgBUEBIAIQ +uwEiB0UNAgtBACEBQQALNgIMIAQgATYCCCAEIAI2AgQgBCAHNgIAIAhBEGokAAwBC0EBIAJB3IbA +ABC1AQALIAQoAgAgBCgCBCAEKAIIIAQoAgwgBEEQaiQAC/oBAgJ/AX4jAEEQayICJAAgAkEBOwEM +IAIgATYCCCACIAA2AgQjAEEQayIBJAAgAkEEaiIAKQIAIQQgASAANgIMIAEgBDcCBCMAQRBrIgAk +ACABQQRqIgEoAgAiAigCDCEDAkACQAJAAkAgAigCBA4CAAECCyADDQFBASECQQAhAwwCCyADDQAg +AigCACICKAIEIQMgAigCACECDAELIABBgICAgHg2AgAgACABNgIMIABBwMjAACABKAIEIAEoAggi +AC0ACCAALQAJEGYACyAAIAM2AgQgACACNgIAIABBpMjAACABKAIEIAEoAggiAC0ACCAALQAJEGYA +C98IAQt/IwBBEGsiCCQAIwBBIGsiByQAAkACQAJAIAAEQCAAQQhrIgkgCSgCAEEBaiICNgIAIAJF +DQEgACgCAA0CIABBfzYCACAHIAk2AhwgByAANgIYIAcgAEEIaiICNgIUIAdBCGohCiMAQbABayIB +JAAgAUEANgIUIAFCgICAgMAANwIMIwBBQGoiAyQAIANBCGogAkEBQQBBARAyIAFBGGoiBEEoaiAD +QTBqKQMANwMAIARBIGogA0EoaikDADcDACAEQRhqIANBIGopAwA3AwAgBEEQaiADQRhqKQMANwMA +IARBCGogA0EQaikDADcDACAEIAMpAwg3AwAgA0FAayQAAn8gASgCGCILRQRAQQQhBUEADAELIAFB +8ABqIAFBQGspAwA3AwAgAUHoAGogAUE4aikDADcDACABQeAAaiABQTBqKQMANwMAIAFB2ABqIgMg +AUEoaikDADcDACABQdAAaiIFIAFBIGopAwA3AwAgASABKQMYNwNIIAItADAhBiADEIMBIQQgAUH8 +AGogAxBkIAFBjAFqIgMgBCAGQQFzcjoAACABIAUoAgAiBDYCiAEgAUHUAGogASgCTCAEIAEoAkgo +AhARAwAgAUEMakHMhsAAEGcgASgCECIFIAEpAnw3AgAgBUEIaiABQYQBaikCADcCACAFQRBqIAMo +AgA2AgAgAkEBOgAwIAFBATYCFEEBCyECIAFBADYCmAFBASEGIAFBGGogAUGYAWogAhC0AQJAIAEo +AhhFBEAgASgCHCEDDAELIAFBqAFqIAFBIGooAgA2AgAgASABKQIYNwOgAQJAIAsEQCACQRRsIQQg +AUGgAWpBBHIhAiABKAKoASEGA0AgASAFIAEoAqABEGAgASgCBCEDIAEoAgBBAXENAiACIAYgAxDR +ASABIAZBAWoiBjYCqAEgBUEUaiEFIARBFGsiBA0ACwtBACEGIAEoAqQBIQMMAQtBASEGIAEoAqQB +IgJBhAFJDQAgAhBtCyABIAM2ApQBIAEgBjYCkAEgAUEBNgIcIAFBsITAADYCGCABQgE3AiQgASAB +QZABaq1CgICAgDCENwOYASABIAFBmAFqNgIgIAFBoAFqIAFBGGoQRyABKAKkASIEIAEoAqgBEAAg +ASgCoAEiAgRAIAQgAhDPAQsgASgCkAEhAyABKAKUASEEIAEoAhQiBgRAIAEoAhAhBQNAIAUoAgAi +AgRAIAVBBGooAgAgAhDPAQsgBUEUaiEFIAZBAWsiBg0ACwsgASgCDCICBEAgASgCECACQRRsEM8B +CyAKIAQ2AgQgCiADNgIAIAFBsAFqJAAgBygCDCEEIAcoAgghAiAAQQA2AgAgCSAJKAIAQQFrIgA2 +AgAgAEUEQCAHQRxqEJMBCyAIIAJBAXEiADYCCCAIIARBACAAGzYCBCAIQQAgBCAAGzYCACAHQSBq +JAAMAwsQ4wELAAsQ5AEACyAIKAIAIAgoAgQgCCgCCCAIQRBqJAALIQACQCABIAMQtgEEQCAAIAEg +AyACELsBIgANAQsACyAACyUAIABFBEBByLPAAEEyEOUBAAsgACACIAMgBCAFIAEoAhAREwALIAEB +f0EBIQEgACgCACIAQQFxBH8gAQUgACgCCEEBRgsLHwECfiAAKQMAIgIgAkI/hyIDhSADfSACQgBZ +IAEQSQsjACAARQRAQcizwABBMhDlAQALIAAgAiADIAQgASgCEBEEAAsjACAARQRAQcizwABBMhDl +AQALIAAgAiADIAQgASgCEBEPAAsjACAARQRAQcizwABBMhDlAQALIAAgAiADIAQgASgCEBEnAAsj +ACAARQRAQcizwABBMhDlAQALIAAgAiADIAQgASgCEBEpAAsjACAARQRAQcizwABBMhDlAQALIAAg +AiADIAQgASgCEBErAAsmAQF/IAAoAgAiAUGAgICAeHJBgICAgHhHBEAgACgCBCABEM8BCwshACAA +RQRAQcizwABBMhDlAQALIAAgAiADIAEoAhARAwALIgAgAC0AAEUEQCABQdvtwABBBRA6DwsgAUHg +7cAAQQQQOgsfACAARQRAQcizwABBMhDlAQALIAAgAiABKAIQEQAACyEAIABBADYCDCAAIAM2Aggg +ACACNgIEIABBiLXAADYCAAtIACABUEUEQCAAKQMYIAGCDwsjAEEgayIAJAAgAEEANgIYIABBATYC +DCAAQaz+wAA2AgggAEIENwIQIABBCGpB/LjAABChAQALKQAgACAALQAEIAFBLkZyOgAEIAAoAgAi +ACgCACABIAAoAgQoAhARAAALGAEBfyAAKAIAIgEEQCAAKAIEIAEQzwELCyUBAW8QESEDEHAiAiAD +JgEgAEEANgIIIAAgAjYCBCAAIAE2AgALQgAgAARAIAAgARDqAQALIwBBIGsiACQAIABBADYCGCAA +QQE2AgwgAEHwycAANgIIIABCBDcCECAAQQhqIAIQoQEACxUAIAFpQQFGIABBgICAgHggAWtNcQsc +ACAAQQA2AhAgAEIANwIIIABCgICAgMAANwIACxYBAW8gACABEAEhAhBwIgAgAiYBIAALFgEBbyAA +IAEQBiECEHAiACACJgEgAAsWAQFvIAAlARAgIQEQcCIAIAEmASAAC+0GAQZ/An8CQAJAAkACQAJA +IABBBGsiBSgCACIGQXhxIgRBBEEIIAZBA3EiBxsgAWpPBEAgB0EAIAFBJ2oiCSAESRsNAQJAAkAg +AkEJTwRAIAIgAxBIIggNAUEADAkLIANBzP97Sw0BQRAgA0ELakF4cSADQQtJGyEBAkAgB0UEQCAB +QYACSSAEIAFBBHJJciAEIAFrQYGACE9yDQEMCQsgAEEIayICIARqIQcCQAJAAkACQCABIARLBEAg +B0GUhsEAKAIARg0EIAdBkIbBACgCAEYNAiAHKAIEIgZBAnENBSAGQXhxIgYgBGoiBCABSQ0FIAcg +BhBNIAQgAWsiA0EQSQ0BIAUgASAFKAIAQQFxckECcjYCACABIAJqIgEgA0EDcjYCBCACIARqIgIg +AigCBEEBcjYCBCABIAMQRAwNCyAEIAFrIgNBD0sNAgwMCyAFIAQgBSgCAEEBcXJBAnI2AgAgAiAE +aiIBIAEoAgRBAXI2AgQMCwtBiIbBACgCACAEaiIEIAFJDQICQCAEIAFrIgNBD00EQCAFIAZBAXEg +BHJBAnI2AgAgAiAEaiIBIAEoAgRBAXI2AgRBACEDQQAhAQwBCyAFIAEgBkEBcXJBAnI2AgAgASAC +aiIBIANBAXI2AgQgAiAEaiICIAM2AgAgAiACKAIEQX5xNgIEC0GQhsEAIAE2AgBBiIbBACADNgIA +DAoLIAUgASAGQQFxckECcjYCACABIAJqIgEgA0EDcjYCBCAHIAcoAgRBAXI2AgQgASADEEQMCQtB +jIbBACgCACAEaiIEIAFLDQcLIAMQKSIBRQ0BIANBfEF4IAUoAgAiAkEDcRsgAkF4cWoiAiACIANL +GyICBEAgASAAIAL8CgAACyAAEDkgAQwICyADIAEgASADSxsiAgRAIAggACAC/AoAAAsgBSgCACIC +QXhxIgMgAUEEQQggAkEDcSICG2pJDQMgAkEAIAMgCUsbDQQgABA5CyAIDAYLQanGwABBLkHYxsAA +EJYBAAtB6MbAAEEuQZjHwAAQlgEAC0GpxsAAQS5B2MbAABCWAQALQejGwABBLkGYx8AAEJYBAAsg +BSABIAZBAXFyQQJyNgIAIAEgAmoiAiAEIAFrIgFBAXI2AgRBjIbBACABNgIAQZSGwQAgAjYCACAA +DAELIAALCxkAIAAoAgBBjLnAAEEeIAAoAgQoAgwRAQALDgAgAQRAIAAgARDPAQsLGQAgASgCAEHH +6MAAQQ4gASgCBCgCDBEBAAsWACAAKAIAIAEgAiAAKAIEKAIMEQEACxQAIAAoAgAgASAAKAIEKAIM +EQAAC4MIAQR/IwBB8ABrIgUkACAFIAM2AgwgBSACNgIIAn8gAUGBAk8EQAJ/QYACIAAsAIACQb9/ +Sg0AGkH/ASAALAD/AUG/f0oNABpB/gFB/QEgACwA/gFBv39KGwsiBiAAaiwAAEG/f0oEQEGf7sAA +IQdBBQwCCyAAIAFBACAGIAQQwQEAC0EBIQcgASEGQQALIQggBSAGNgIUIAUgADYCECAFIAg2Ahwg +BSAHNgIYAkACQAJAAkAgASACSSIGIAEgA0lyRQRAIAIgA0sNASACRSABIAJNckUEQCAFQQxqIAVB +CGogACACaiwAAEG/f0obKAIAIQMLIAUgAzYCICADIAEiAkkEQCADQQFqIgIgA0EDayIGQQAgAyAG +TxsiBkkNAwJ/IAIgBmsiB0EBayAAIANqLAAAQb9/Sg0AGiAHQQJrIAAgAmoiAkECaywAAEG/f0oN +ABogB0EDayACQQNrLAAAQb9/Sg0AGiAHQXxBeyACQQRrLAAAQb9/ShtqCyAGaiECCwJAIAJFDQAg +ASACTQRAIAEgAkYNAQwFCyAAIAJqLAAAQb9/TA0ECwJ/AkACQCABIAJGDQACQAJAIAAgAmoiASwA +ACIAQQBIBEAgAS0AAUE/cSEGIABBH3EhAyAAQV9LDQEgA0EGdCAGciEADAILIAUgAEH/AXE2AiRB +AQwECyABLQACQT9xIAZBBnRyIQYgAEFwSQRAIAYgA0EMdHIhAAwBCyADQRJ0QYCA8ABxIAEtAANB +P3EgBkEGdHJyIgBBgIDEAEYNAQsgBSAANgIkIABBgAFPDQFBAQwCCyAEENcBAAtBAiAAQYAQSQ0A +GkEDQQQgAEGAgARJGwshACAFIAI2AiggBSAAIAJqNgIsIAVBBTYCNCAFQajvwAA2AjAgBUIFNwI8 +IAUgBUEYaq1CgICAgIAMhDcDaCAFIAVBEGqtQoCAgICADIQ3A2AgBSAFQShqrUKAgICAoAyENwNY +IAUgBUEkaq1CgICAgLAMhDcDUCAFIAVBIGqtQoCAgICACYQ3A0gMBAsgBSACIAMgBhs2AiggBUED +NgI0IAVB6O/AADYCMCAFQgM3AjwgBSAFQRhqrUKAgICAgAyENwNYIAUgBUEQaq1CgICAgIAMhDcD +UCAFIAVBKGqtQoCAgICACYQ3A0gMAwsgBUEENgI0IAVByO7AADYCMCAFQgQ3AjwgBSAFQRhqrUKA +gICAgAyENwNgIAUgBUEQaq1CgICAgIAMhDcDWCAFIAVBDGqtQoCAgICACYQ3A1AgBSAFQQhqrUKA +gICAgAmENwNIDAILIAYgAkGA8MAAENUBAAsgACABIAIgASAEEMEBAAsgBSAFQcgAajYCOCAFQTBq +IAQQoQEACxEAIAAoAgAgACgCBCABEOwBCxkAAn8gAUEJTwRAIAEgABBIDAELIAAQKQsLDwAgACAB +KAIAIAIgAxBbCw8AIAAgASgCACACIAMQQwsRACAAKAIEIAAoAgggARDsAQvgBgEPfyAAKAIAIQcg +ACgCBCEFQQAhACMAQRBrIgYkAEEBIQwCQCABKAIAIgpBIiABKAIEIg0oAhAiDhEAAA0AAkAgBUUE +QAwBC0EAIAVrIQ8gByEBIAUhAAJAAn8CQANAIAAgAWohEEEAIQMCQANAIAEgA2oiBC0AACIJQf8A +a0H/AXFBoQFJIAlBIkZyIAlB3ABGcg0BIAAgA0EBaiIDRw0ACyAAIAhqDAMLIARBAWohAQJAIAQs +AAAiAEEATgRAIABB/wFxIQAMAQsgAS0AAEE/cSELIABBH3EhCSAEQQJqIQEgAEFfTQRAIAlBBnQg +C3IhAAwBCyABLQAAQT9xIAtBBnRyIQsgBEEDaiEBIABBcEkEQCALIAlBDHRyIQAMAQsgCUESdEGA +gPAAcSABLQAAQT9xIAtBBnRyciEAIARBBGohAQsgBkEEaiAAQYGABBA1AkACQCAGLQAEQYABRg0A +IAYtAA8gBi0ADmtB/wFxQQFGDQACQAJAIAIgAyAIaiIESw0AAkAgAkUNACACIAVPBEAgAiAFRw0C +DAELIAIgB2osAABBv39MDQELAkAgBEUNACAEIAVPBEAgBCAPakUNAQwCCyAHIAhqIANqLAAAQUBI +DQELIAogAiAHaiAIIAJrIANqIA0oAgwiAhEBAEUNAQwDCyAHIAUgAiAEQeTtwAAQwQEACwJAIAYt +AARBgAFGBEAgCiAGKAIIIA4RAAANAwwBCyAKIAYtAA4iBCAGQQRqaiAGLQAPIARrIAIRAQANAgsC +f0EBIABBgAFJDQAaQQIgAEGAEEkNABpBA0EEIABBgIAESRsLIAhqIANqIQILAn9BASAAQYABSQ0A +GkECIABBgBBJDQAaQQNBBCAAQYCABEkbCyAIaiIEIANqIQggECABayIARQ0CDAELCwwECyADIARq +CyIDIAJJDQBBACEAAkAgAkUNACACIAVPBEAgAiIAIAVHDQIMAQsgAiIAIAdqLAAAQb9/TA0BCyAD +RQRAQQAhAwwCCyADIAVPBEAgAyAFRg0CIAAhAgwBCyADIAdqLAAAQb9/Sg0BIAAhAgsgByAFIAIg +A0H07cAAEMEBAAsgCiAAIAdqIAMgAGsgDSgCDBEBAA0AIApBIiAOEQAAIQwLIAZBEGokACAMCxYA +QdCCwQAgADYCAEHMgsEAQQE2AgALIgAgAELtuq22zYXU9eMANwMIIABC+IKZvZXuxsW5fzcDAAsh +ACAAQoC834WrpfibJzcDCCAAQp/1lpTW7u3DoX83AwALEwAgAEGUyMAANgIEIAAgATYCAAsRACAB +IAAoAgAgACgCBBC/AQsQACABIAAoAgAgACgCBBA6CxAAIAEoAgAgASgCBCAAEDwLYQECfwJAAkAg +AEEEaygCACICQXhxIgNBBEEIIAJBA3EiAhsgAWpPBEAgAkEAIAMgAUEnaksbDQEgABA5DAILQanG +wABBLkHYxsAAEJYBAAtB6MbAAEEuQZjHwAAQlgEACwsdAQFvIAAoAgAlASABJQEgARBtIAIlASAC +EG0QDgsXAQFvIAAoAgAlASABIAIlASACEG0QGwsNACAAKAIAKAIIQQFGC2sBAX8jAEEwayIDJAAg +AyABNgIEIAMgADYCACADQQI2AgwgA0Ho/sAANgIIIANCAjcCFCADIANBBGqtQoCAgICACYQ3Aygg +AyADrUKAgICAgAmENwMgIAMgA0EgajYCECADQQhqIAIQoQEAC2sBAX8jAEEwayIDJAAgAyABNgIE +IAMgADYCACADQQI2AgwgA0GI/8AANgIIIANCAjcCFCADIANBBGqtQoCAgICACYQ3AyggAyADrUKA +gICAgAmENwMgIAMgA0EgajYCECADQQhqIAIQoQEAC2sBAX8jAEEwayIDJAAgAyABNgIEIAMgADYC +ACADQQI2AgwgA0G8/8AANgIIIANCAjcCFCADIANBBGqtQoCAgICACYQ3AyggAyADrUKAgICAgAmE +NwMgIAMgA0EgajYCECADQQhqIAIQoQEACwsAIAAoAgAgARBMCw8AQfDowABBKyAAEJYBAAsNACAA +KQMAQQEgARBJCw4AIAFBgIPAAEEFEL8BCw4AIAFB1ITAAEEQEL8BCw4AIAFBsIjAAEEKEL8BCwwA +IAAoAgAgARDWAQuKAwEBfyAAKAIAIQIjAEHQAWsiACQAIAAgAkEYaq1CgICAgIAHhDcDaCAAIAJB +EGqtQoCAgICAB4Q3A2AgACACQQhqrUKAgICAgAeENwNYIAAgAq1CgICAgIAHhDcDUCAAQay5wAA2 +AjggAEEENgI8IABBBDYCTCAAQoOAgICAhICAaTcCyAEgAEGAgMAANgLAASAAQQI7AbgBIABCgoCA +gICEgIBpNwKwASAAQYCAwAA2AqgBIABBAjsBoAEgAEKBgICAgISAgGk3ApgBIABBgIDAADYCkAEg +AEECOwGIASAAQoCAgICAhICAaTcCgAEgAEKAgMAANwJ4IABBAjsBcCAAIABB8ABqNgJIIABBBDYC +RCAAIABB0ABqNgJAIABBLGoiAiAAQThqEEcgACACrUKAgICAkAeENwMgIABBATYCDCAAQby6wAA2 +AgggAEIBNwIUIAAgAEEgajYCECABKAIAIAEoAgQgAEEIahA8IAAoAiwiAgRAIAAoAjAgAhDPAQsg +AEHQAWokAAsLACAAKAIAIAEQcwsNACAAQaCPwAAgARA8Cw4AIAFBmI7AAEEFEL8BCw4AIAFB+rPA +AEELEL8BCw0AIABB7L3AACABEDwLDQBBqMPAAEEbEOUBAAsOAEHDw8AAQc8AEOUBAAsJACAAIAEQ +JQALDQAgAEHoxcAAIAEQPAsMACAAIAEpAgA3AwALDQAgAEHEycAAIAEQPAsOACABQbzJwABBBRC/ +AQsaACAAIAFB1ILBACgCACIAQckAIAAbEQIAAAsNACAAQZTrwAAgARA8CwoAIAIgACABEDoLCgAg +ACABJQEQAgsOACABQYS+wABBCBC/AQsOACABQY7AwABBAxC/AQsJACAAQQA2AgALCAAgACUBEAML +CAAgACUBEBILCAAgACUBECILBABBAAsCAAsLtoEBDgBBgIDAAAuxAS9ob21lL2NveW90dGU1MDgv +Y29kZS9odWdnaW5nZmFjZS5qcy9wYWNrYWdlcy9odWIveGV0LWNvcmUtd2FzbS1idWlsZC9tZXJr +bGVoYXNoL3NyYy9hZ2dyZWdhdGVkX2hhc2hlcy5ycwAAAAAAEABpAAAAWQAAADgAAAAAABAAaQAA +AFkAAAAPAAAAAAAQAGkAAABWAAAAOQAAAAQAAAAMAAAABAAAAAUAAAAGAAAABwBBvIHAAAutBQEA +AAAIAAAAYSBEaXNwbGF5IGltcGxlbWVudGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHVuZXhwZWN0 +ZWRseS9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS14ODZfNjQtdW5r +bm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvc3Ry +aW5nLnJzAPsAEAB0AAAA0QoAAA4AAABFcnJvcgAAAPsAEAB0AAAAfQUAABsAAAAAAAAABAAAAAQA +AAAJAAAAT2tFcnIvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2 XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mv -c3JjL3Jhd192ZWMvbW9kLnJzAAAA5AwQAHkAAAAuAgAAEQAAAE9uY2UgaW5zdGFuY2UgaGFzIHBy -ZXZpb3VzbHkgYmVlbiBwb2lzb25lZAAAcA0QACoAAABvbmUtdGltZSBpbml0aWFsaXphdGlvbiBt -YXkgbm90IGJlIHBlcmZvcm1lZCByZWN1cnNpdmVseaQNEAA4AAAAL2hvbWUvY295b3R0ZTUwOC8u -cnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9saWIvcnVz -dGxpYi9zcmMvcnVzdC9saWJyYXJ5L3N0ZC9zcmMvc3luYy9wb2lzb24vb25jZS5yc+QNEAB8AAAA -mwAAADIAAABZ9UDoqdOIsNYg7Tn3x1JWq3KJiWmJskV3x4621YkKa7cxeos+V482S9k26dw2xh22 -1VRVTkx6IMuaIyhGs3SkErmjHD6oBjv3ugIvbI3nkIqaDRX3LcnhrdOGEDoFlY4iBzq48fQuWq5/ -gJ+UrA+lgdbYgOsDcw4PrXAV3H6wmXYw/VW1L51oaKSeEYJQAAAozI+oBoOwxP1KN/aKZ7A+NnSt -hquHn/E2x2u+v58S8u2kmFxXSRFIxXtHlQYBAADM6pwagDe6H22bpGPWb/A7S4fjgpd+aJnj2FCq -cwaheSD0EWKez6zkcZBXhx/nICWbihp4/dPVK3PIEd3NTd4ALzmHWhwxqer/QLwXto5022+/IPaN -mlevscIJG9rlpoYuoSLDCsMvzGdC98H+Kl41e6QhwPTImS3DzwSUSkveuml9cB1yGLX3ICzze1i2 -hjIMJ6+GiLYAAHmQitvk1hWhmeGyl5x+T0gB4xNXt3vKzGDxsCumhCW/yLxdYhPo561alYcNlHAA -AG9inhMIkeaKojjeL9dqd73PwPzCHwBr+yfEe+a4dKTHWF3rEBbx9rrRcOdtWx/LCUdMfZfmGbKw -Sq2nbji8zAABP5ffCp2EzHD3agF976Nz/r29htPSB8gwF3lslskqf9oExcZrqDfQnWCqHmZ88fOH -5qpNsCamrAdbSk83mVp13q4sW+Z+g5CFB1b9k63obtjtUxDh2QAA19sc0rI7Bp6y0gEq8XerB0Qb -ZOZVAlXsxhScRKiU+3j19cDGGw5Rx+PK5DYLMgAALRqLLCYzfIJEQepIC19nFOvsjUmm03smXgP1 -gvlvkfGI+zT0fxsihthJbzjnzr6dSo8PyMr4WOrYZPyShhmNADaav7pPcDhtTL7n0QfLMuCQCEWt -9iGNIqWJJcC/sVxjcc6inHOhIEZY++Wq49/np+sNPCuTyhAMe+2vhOj+Jycfq+L5bRzfoiP1dAes -0c1NTuIzrf9wAAAWeJfFe+isoklgKLRaJ5KYWYnx3YERhsIZPkhCoHKZu3gwUWY3zXDvZJj8qxMF -AACDQMlYGLZYwN7gJZeFUOgJlH0++Dv7l5HOS7YSbWIeftFXe39QVAxSFiTidHF54b6HVekiMqzZ -bz6/35p8lSMAFb5LI359HKC7jKO4WMeiqzArPuzOoB8Nkblgfoultgs1ZqKfW90zQ6PBAUB9O/3C -JxFzVCSAQfvLGA2lhWGlZU+1hIe9Anr2Y1DmZ90Rb2mrFKj8IiAAAFLYuS2RvtaMV4qu6baJUWko -DNoKtVOU7l6EeBqpXvzYZ6dKGhm/hqvlFWTItcYAAC6iCI4XEHMmJcqLBxsQLe37qCayhO1BOwbc -KA8SIuYTJm1w++v1FaPOugEzTsMWiK79cbucWznpSBZyLiDpLAAcybMrHduDQqWmsdIaRn3Xa4br -buQX7OJ8xPs5QL7guASdKdXEYKHeNDaM0siG7H6Zo5ifEq0ZIe+DomFr9MymF8ZY9t7OUiyD3axp -EYe0LenLnvPW8AAAiZQvjcnY1T2E9QEronIYivI8ew7EpILylqEbyyzsIIAT41me4LaTZuuDfMwZ -zgAAO5xH9jVXyyBbWtdZN78udnU5aT2C/nsg1dmcMxLBfdcDfWKEQoOnm+lRX+kTxX0hFnhe/Cka -e7ItZrsxmM3VAExzdW2Am+NxIxr7BvAqV36FH+lqL09zovLdLAK1xoK/3qBhB8bqO1yYaUFHu5PI -zQF+GFxhhRBtXXwnrDCu+HeRLCoSgWt8kWdp0a2ZtnVbmwaa52rPAAAEEd5g+grE88NnkaV6EmMg -TYnRaSLmHWImRyvmHayI0TxnSxXiNnAQHTpVKF+4AAA9byMYTE7v8gL2uRFm3tbZHJFH+1V5/KG9 -jSkvA/2F6+H6vrMvUCe+HmbNxFFCA+M2GAdU02QTRD6Y8nVss4IA8Gb6FgORRbH3ykeYnAYcAiFS -S1rH3xAptahXHD41W3Ns2Y7pLDFEzmX6vQZFLpS8G5RXEqeGUPCtzlHTFbLD/gJCFOBVEK4AVORC -b4RAS/XIvLzI2X8AAP6b3hfznr2/Ek6F8i8wBKjU2OWlV0nOOYS6N1ak4rn/i4Ggnh2tuVWKFxnz -y4oAADj7+9DIv+JI6LVI6EGY44uLoJYGFhInDiokREvolhDVOuGSZxe6ARGdaDFFD3cuwmzFu3Ly -74kW7FBWfxkqqQBOeKG9kFl2vK64/JLjQRTGoOQx7Sw64QdNnU4jhOnLksWKfbty9U+P0DuWC8Bw -lgsB6wMaWFqVYlQCAOrlg19kmfKIzRbl/EHPmHraSJfau/pFSP6yqgAAVWX1mwYbdhlWrbZDg16P -i9khSBT9HF0+j82woiweXOx/tfun/uD3+huWErrTAAAAjrEBhBeQP9rrXzrjbZD/cOdwacCn1ScF -6RN8YHPn2CKsOzxk33CryeMSvorcxqTtiuczAEEf7+zLcqx0ssIkALQAqU+VDXQGBGM9Mpspeh3V -6suYsnzDs5tzeGHH44bJivVGSzbqq59WzIWvxRSibYSPo7fYPqQX69uaHVHszG77WjMTCbPK+dLu -FfTFYF5KtHI2UGdpAACHu1QUEh2lnRbIu7kTHjKEjd0vq7ZvPfuNChaO7V4wYOhslOkUS7/LwxAb -OGNPAAAQTsxvgbfVB1WBampyNqXl3X+gRzSyr1eU08mr90bzGD3TGtZVxm1j9vP3OUmri8x7GN3B -BqnHYy9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS14ODZfNjQtdW5r -bm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvc2xp -Y2UucnMAcBYQAHMAAAC+AQAAHQAAAC9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29sY2hhaW5z -L3N0YWJsZS14ODZfNjQtdW5rbm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGli -cmFyeS9jb3JlL3NyYy9pdGVyL3RyYWl0cy9pdGVyYXRvci5ycwAAAPQWEACBAAAAwQcAAAkAAAB/ -GFfWzlbtZhJ/+RPnpcPzpM0m1bXbSeZBJJh/KPuUwy9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90 +c3JjL3NsaWNlLnJzrQEQAHMAAAC+AQAAHQAAAAEAAAAAAAAAaGFzaGxlbmd0aAAAOAIQAAQAAAA8 +AhAABgAAAHN0cnVjdCBKc0NodW5rSW5Kc0NodW5rT3V0ZGVkdXBhdHRlbXB0ZWQgdG8gdGFrZSBv +d25lcnNoaXAgb2YgUnVzdCB2YWx1ZSB3aGlsZSBpdCB3YXMgYm9ycm93ZWRzcmMvbGliLnJzsgIQ +AAoAAAA9AAAAOAAAALICEAAKAAAAQQAAACEAAAAvaG9tZS9jb3lvdHRlNTA4Ly5jYXJnby9yZWdp +c3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvd2FzbS1iaW5kZ2VuLTAu +Mi4xMDAvc3JjL2NvbnZlcnQvc2xpY2VzLnJzsgIQAAoAAABMAAAAFAAAANwCEABwAAAAJAEAAA4A +QYyHwAALkQEvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0 +LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvY29yZS9zcmMv +aXRlci90cmFpdHMvaXRlcmF0b3IucnMAAACMAxAAgQAAAMEHAAAJAEGoiMAAC5UBAQAAAAoAAABh +IHNlcXVlbmNlL2hvbWUvY295b3R0ZTUwOC8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRl +cy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3NlcmRlLTEuMC4yMTkvc3JjL2RlL2ltcGxzLnJzAAAAOgQQ +AGMAAACVBAAAIgAAADoEEABjAAAAmAQAABwAQciJwAALBQEAAAALAEHYicAACwUBAAAADABB6InA +AAvlAQEAAAANAAAAY2FsbGVkIGBPcHRpb246OnVud3JhcF90aHJvdygpYCBvbiBhIGBOb25lYCB2 +YWx1ZWhhc2hsZW5ndGgvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUt +eDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxs +b2Mvc3JjL3Jhd192ZWMvbW9kLnJzKwUQAHkAAAAuAgAAEQAAACA6IAoBAAAAAAAAALQFEAADAAAA +twUQAAEAQdiLwAALuwgBAAAAEQAAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVy +cmAgdmFsdWUvaG9tZS9jb3lvdHRlNTA4L2NvZGUvaHVnZ2luZ2ZhY2UuanMvcGFja2FnZXMvaHVi +L3hldC1jb3JlLXdhc20tYnVpbGQvbWVya2xlaGFzaC9zcmMvYWdncmVnYXRlZF9oYXNoZXMucnML +BhAAaQAAAD0AAAAqAAAACwYQAGkAAAA4AAAAHgAAAC9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90 b29sY2hhaW5zL3N0YWJsZS14ODZfNjQtdW5rbm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIvc3Jj -L3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvcmF3X3ZlYy9tb2QucnMAAACoFxAAeQAAAC4CAAARAAAA -AAAAAAQAAAAEAAAAFwAAAC9ob21lL2NveW90dGU1MDgvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRl -eC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9qcy1zeXMtMC4zLjc3L3NyYy9saWIucnMAAEQY -EABeAAAA+xgAAAEAAAAvaG9tZS9jb3lvdHRlNTA4Ly5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXgu -Y3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvd2FzbS1iaW5kZ2VuLTAuMi4xMDAvc3JjL2NvbnZl -cnQvc2xpY2VzLnJztBgQAHAAAAAkAQAADgAAAGNsb3N1cmUgaW52b2tlZCByZWN1cnNpdmVseSBv -ciBhZnRlciBiZWluZyBkcm9wcGVkTGF5b3V0RXJyb3IvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAv -dG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3Ny -Yy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3NsaWNlLnJzcRkQAHMAAAC+AQAAHQAAACQAAAAlAAAA -JgAAACcAAAAoAAAAL2hvbWUvY295b3R0ZTUwOC8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNy -YXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2J5dGVzLTEuMTAuMS9zcmMvYnl0ZXMucnMAKQAAACoA -AAArAAAALAAAAC0AAAAuAAAALwAAADAAAAAsAAAAMQBBmLXAAAulFAEAAAAyAAAAY2FsbGVkIGBS -ZXN1bHQ6OnVud3JhcCgpYCBvbiBhbiBgRXJyYCB2YWx1ZQAIGhAAXwAAAEgFAAAyAAAACBoQAF8A -AABWBQAASQAAADMAAAA0AAAANQAAADYAAAA3AAAAL2hvbWUvY295b3R0ZTUwOC8ucnVzdHVwL3Rv -b2xjaGFpbnMvc3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9saWIvcnVzdGxpYi9zcmMv -cnVzdC9saWJyYXJ5L2FsbG9jL3NyYy9zbGljZS5ycwAAGxAAcwAAAL4BAAAdAAAAL2hvbWUvY295 -b3R0ZTUwOC9jb2RlL2h1Z2dpbmdmYWNlLmpzL3BhY2thZ2VzL2h1Yi94ZXQtY29yZS13YXNtLWJ1 -aWxkL21lcmtsZWhhc2gvc3JjL2RhdGFfaGFzaC5ycwAAAIQbEABhAAAAegAAAAkAAABJbnZhbGlk -IGhleCBpbnB1dCBmb3IgRGF0YUhhc2gAAAEAAAAAAAAAAQAAAAAAAAABAAAAAAAAAAEAAAAAAAAA -hBsQAGEAAACyAAAAKgAAAIQbEABhAAAAswAAACoAAACEGxAAYQAAALQAAAAqAAAAZpf1d1uVUN4x -NcuspZcYHJ3kIRCb6ytYtNCwS5Ot8ikBfsXHpUcplv2UZma0igLmXd1TbzfHbdL4Y1LmSlNxPwEA -AAAAAAAAbWlkID4gbGVuAAAAsBwQAAkAAAAvaG9tZS9jb3lvdHRlNTA4Ly5jYXJnby9yZWdpc3Ry -eS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvYmxha2UzLTEuOC4yL3NyYy9s -aWIucnMAAADEHBAAXQAAAAsCAAARAAAAxBwQAF0AAAC+AgAACgAAAMQcEABdAAAA7AIAACgAAADE -HBAAXQAAAOwCAAA0AAAAxBwQAF0AAADsAgAADAAAAMQcEABdAAAA3AIAABcAAADEHBAAXQAAABgD -AAAfAAAAxBwQAF0AAAA1AwAADAAAAMQcEABdAAAAPAMAABIAAADEHBAAXQAAAGADAAAhAAAAxBwQ -AF0AAABiAwAAEQAAAMQcEABdAAAAYgMAAEEAAABpbnN1ZmZpY2llbnQgY2FwYWNpdHkAAADkHRAA -FQAAAENhcGFjaXR5RXJyb3I6IAAEHhAADwAAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24g -YW4gYEVycmAgdmFsdWUAAAAAAAQAAAAEAAAAOwAAAAAAAAAIAAAABAAAAEMAAABEAAAARQAAAGEg -c3RyaW5nYnl0ZSBhcnJheWJvb2xlYW4gYGCCHhAACQAAAIseEAABAAAAaW50ZWdlciBgAAAAnB4Q -AAkAAACLHhAAAQAAAGZsb2F0aW5nIHBvaW50IGC4HhAAEAAAAIseEAABAAAAY2hhcmFjdGVyIGAA -2B4QAAsAAACLHhAAAQAAAHN0cmluZyAA9B4QAAcAAAB1bml0IHZhbHVlT3B0aW9uIHZhbHVlbmV3 -dHlwZSBzdHJ1Y3RzZXF1ZW5jZW1hcGVudW11bml0IHZhcmlhbnRuZXd0eXBlIHZhcmlhbnR0dXBs -ZSB2YXJpYW50c3RydWN0IHZhcmlhbnQAAAABAAAAAAAAAC4wdTMyTGF6eSBpbnN0YW5jZSBoYXMg -cHJldmlvdXNseSBiZWVuIHBvaXNvbmVkAH0fEAAqAAAAL2hvbWUvY295b3R0ZTUwOC8uY2FyZ28v -cmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL29uY2VfY2VsbC0x -LjIxLjMvc3JjL2xpYi5ycwAAALAfEABhAAAACAMAABkAAAByZWVudHJhbnQgaW5pdAAAJCAQAA4A -AACwHxAAYQAAAHoCAAANAAAAL2hvbWUvY295b3R0ZTUwOC8uY2FyZ28vcmVnaXN0cnkvc3JjL2lu -ZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3dhc20tYmluZGdlbi0wLjIuMTAwL3NyYy9j -b252ZXJ0L2ltcGxzLnJzAEwgEABvAAAAYQIAABYAAABMIBAAbwAAAHECAAAMAAAATCAQAG8AAABt -AgAAEAAAAGFycmF5IGNvbnRhaW5zIGEgdmFsdWUgb2YgdGhlIHdyb25nIHR5cGVudWxsIHBvaW50 -ZXIgcGFzc2VkIHRvIHJ1c3RyZWN1cnNpdmUgdXNlIG9mIGFuIG9iamVjdCBkZXRlY3RlZCB3aGlj -aCB3b3VsZCBsZWFkIHRvIHVuc2FmZSBhbGlhc2luZyBpbiBydXN0SnNWYWx1ZSgpAH4hEAAIAAAA -hiEQAAEAAAAvcnVzdGMvMTcwNjdlOWFjNmQ3ZWNiNzBlNTBmOTJjMTk0NGU1NDUxODhkMjM1OS9s -aWJyYXJ5L2FsbG9jL3NyYy9zdHJpbmcucnMAmCEQAEsAAAB9BQAAGwAAAC9ydXN0Yy8xNzA2N2U5 -YWM2ZDdlY2I3MGU1MGY5MmMxOTQ0ZTU0NTE4OGQyMzU5L2xpYnJhcnkvYWxsb2Mvc3JjL3Jhd192 -ZWMvbW9kLnJz9CEQAFAAAAAuAgAAEQAAAEoAAAAMAAAABAAAAEsAAABMAAAATQAAAC9ydXN0L2Rl -cHMvZGxtYWxsb2MtMC4yLjcvc3JjL2RsbWFsbG9jLnJzYXNzZXJ0aW9uIGZhaWxlZDogcHNpemUg -Pj0gc2l6ZSArIG1pbl9vdmVyaGVhZABsIhAAKQAAAKgEAAAJAAAAYXNzZXJ0aW9uIGZhaWxlZDog -cHNpemUgPD0gc2l6ZSArIG1heF9vdmVyaGVhZAAAbCIQACkAAACuBAAADQAAAG1lbW9yeSBhbGxv -Y2F0aW9uIG9mICBieXRlcyBmYWlsZWQAABQjEAAVAAAAKSMQAA0AAABsaWJyYXJ5L3N0ZC9zcmMv -YWxsb2MucnNIIxAAGAAAAGQBAAAJAAAASgAAAAwAAAAEAAAATgAAAAAAAAAIAAAABAAAAE8AAAAA -AAAACAAAAAQAAABQAAAAUQAAAFIAAABTAAAAVAAAABAAAAAEAAAAVQAAAFYAAABXAAAAWAAAAEhh -c2ggdGFibGUgY2FwYWNpdHkgb3ZlcmZsb3fIIxAAHAAAAC9ydXN0L2RlcHMvaGFzaGJyb3duLTAu -MTUuMi9zcmMvcmF3L21vZC5ycwAA7CMQACoAAAAjAAAAKAAAAEVycm9yAAAAWQAAAAwAAAAEAAAA -WgAAAFsAAABcAAAAY2FwYWNpdHkgb3ZlcmZsb3cAAABIJBAAEQAAAGxpYnJhcnkvYWxsb2Mvc3Jj -L3Jhd192ZWMvbW9kLnJzZCQQACAAAAAuAgAAEQAAAGxpYnJhcnkvYWxsb2Mvc3JjL3N0cmluZy5y -cwCUJBAAGwAAAOgBAAAXAEHIycAAC8wSAQAAAF0AAABhIGZvcm1hdHRpbmcgdHJhaXQgaW1wbGVt -ZW50YXRpb24gcmV0dXJuZWQgYW4gZXJyb3Igd2hlbiB0aGUgdW5kZXJseWluZyBzdHJlYW0gZGlk -IG5vdGxpYnJhcnkvYWxsb2Mvc3JjL2ZtdC5ycwAAJiUQABgAAACKAgAADgAAAJQkEAAbAAAAfQUA -ABsAAAAAcAAHAC0BAQECAQIBAUgLMBUQAWUHAgYCAgEEIwEeG1sLOgkJARgEAQkBAwEFKwM7CSoY -ASA3AQEBBAgEAQMHCgIdAToBAQECBAgBCQEKAhoBAgI5AQQCBAICAwMBHgIDAQsCOQEEBQECBAEU -AhYGAQE6AQECAQQIAQcDCgIeATsBAQEMAQkBKAEDATcBAQMFAwEEBwILAh0BOgECAgEBAwMBBAcC -CwIcAjkCAQECBAgBCQEKAh0BSAEEAQIDAQEIAVEBAgcMCGIBAgkLB0kCGwEBAQEBNw4BBQECBQsB -JAkBZgQBBgECAgIZAgQDEAQNAQICBgEPAQADAAQcAx0CHgJAAgEHCAECCwkBLQMBAXUCIgF2AwQC -CQEGA9sCAgE6AQEHAQEBAQIIBgoCATAfMQQwCgQDJgkMAiAEAgY4AQECAwEBBTgIAgKYAwENAQcE -AQYBAwLGQAABwyEAA40BYCAABmkCAAQBCiACUAIAAQMBBAEZAgUBlwIaEg0BJggZCwEBLAMwAQIE -AgICASQBQwYCAgICDAEIAS8BMwEBAwICBQIBASoCCAHuAQIBBAEAAQAQEBAAAgAB4gGVBQADAQIF -BCgDBAGlAgAEQQUAAk8ERgsxBHsBNg8pAQICCgMxBAICBwE9AyQFAQg+AQwCNAkBAQgEAgFfAwIE -BgECAZ0BAwgVAjkCAQEBAQwBCQEOBwMFQwECBgEBAgEBAwQDAQEOAlUIAgMBARcBUQECBgEBAgEB -AgEC6wECBAYCAQIbAlUIAgEBAmoBAQECCGUBAQECBAEFAAkBAvUBCgQEAZAEAgIEASAKKAYCBAgB -CQYCAy4NAQIABwEGAQFSFgIHAQIBAnoGAwEBAgEHAQFIAgMBAQEAAgsCNAUFAxcBAAEGDwAMAwMA -BTsHAAE/BFEBCwIAAgAuAhcABQMGCAgCBx4ElAMANwQyCAEOARYFAQ8ABwERAgcBAgEFZAGgBwAB -PQQABP4CAAdtBwBggPAAYXNzZXJ0aW9uIGZhaWxlZDogZWRlbHRhID49IDBsaWJyYXJ5L2NvcmUv -c3JjL251bS9kaXlfZmxvYXQucnMAAABsKBAAIQAAAEwAAAAJAAAAbCgQACEAAABOAAAACQAAAMFv -8oYjAAAAge+shVtBbS3uBAAAAR9qv2TtOG7tl6fa9Pk/6QNPGAABPpUuCZnfA/04FQ8v5HQj7PXP -0wjcBMTasM28GX8zpgMmH+lOAgAAAXwumFuH075yn9nYhy8VEsZQ3mtwbkrPD9iV1W5xsiawZsat -JDYVHVrTQjwOVP9jwHNVzBfv+WXyKLxV98fcgNztbvTO79xf91MFAGxpYnJhcnkvY29yZS9zcmMv -bnVtL2ZsdDJkZWMvc3RyYXRlZ3kvZHJhZ29uLnJzYXNzZXJ0aW9uIGZhaWxlZDogZC5tYW50ID4g -MABMKRAALwAAAHYAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogZC5taW51cyA+IDAAAABMKRAALwAA -AHcAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogZC5wbHVzID4gMEwpEAAvAAAAeAAAAAUAAABhc3Nl -cnRpb24gZmFpbGVkOiBidWYubGVuKCkgPj0gTUFYX1NJR19ESUdJVFMAAABMKRAALwAAAHsAAAAF -AAAATCkQAC8AAADCAAAACQAAAEwpEAAvAAAA+wAAAA0AAABMKRAALwAAAAIBAAASAAAAYXNzZXJ0 -aW9uIGZhaWxlZDogZC5tYW50LmNoZWNrZWRfc3ViKGQubWludXMpLmlzX3NvbWUoKQBMKRAALwAA -AHoAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogZC5tYW50LmNoZWNrZWRfYWRkKGQucGx1cykuaXNf -c29tZSgpAABMKRAALwAAAHkAAAAFAAAATCkQAC8AAAALAQAABQAAAEwpEAAvAAAADAEAAAUAAABM -KRAALwAAAA0BAAAFAAAATCkQAC8AAAByAQAAJAAAAEwpEAAvAAAAdwEAAC8AAABMKRAALwAAAIQB -AAASAAAATCkQAC8AAABmAQAADQAAAEwpEAAvAAAATAEAACIAAABMKRAALwAAAA8BAAAFAAAATCkQ -AC8AAAAOAQAABQAAAAAAAADfRRo9A88a5sH7zP4AAAAAysaaxxf+cKvc+9T+AAAAAE/cvL78sXf/ -9vvc/gAAAAAM1mtB75FWvhH85P4AAAAAPPx/kK0f0I0s/Oz+AAAAAIOaVTEoXFHTRvz0/gAAAAC1 -yaatj6xxnWH8/P4AAAAAy4vuI3cinOp7/AT/AAAAAG1TeECRScyulvwM/wAAAABXzrZdeRI8grH8 -FP8AAAAAN1b7TTaUEMLL/Bz/AAAAAE+YSDhv6paQ5vwk/wAAAADHOoIly4V01wD9LP8AAAAA9Je/ -l83PhqAb/TT/AAAAAOWsKheYCjTvNf08/wAAAACOsjUq+2c4slD9RP8AAAAAOz/G0t/UyIRr/Uz/ -AAAAALrN0xonRN3Fhf1U/wAAAACWySW7zp9rk6D9XP8AAAAAhKVifSRsrNu6/WT/AAAAAPbaXw1Y -Zquj1f1s/wAAAAAm8cPek/ji8+/9dP8AAAAAuID/qqittbUK/nz/AAAAAItKfGwFX2KHJf6E/wAA -AABTMME0YP+8yT/+jP8AAAAAVSa6kYyFTpZa/pT/AAAAAL1+KXAkd/nfdP6c/wAAAACPuOW4n73f -po/+pP8AAAAAlH10iM9fqfip/qz/AAAAAM+bqI+TcES5xP60/wAAAABrFQ+/+PAIit/+vP8AAAAA -tjExZVUlsM35/sT/AAAAAKx/e9DG4j+ZFP/M/wAAAAAGOysqxBBc5C7/1P8AAAAA05JzaZkkJKpJ -/9z/AAAAAA7KAIPytYf9Y//k/wAAAADrGhGSZAjlvH7/7P8AAAAAzIhQbwnMvIyZ//T/AAAAACxl -GeJYF7fRs//8/wBBntzAAAsFQJzO/wQAQazcwAALmSQQpdTo6P8MAAAAAAAAAGKsxet4rQMAFAAA -AAAAhAmU+Hg5P4EeABwAAAAAALMVB8l7zpfAOAAkAAAAAABwXOp7zjJ+j1MALAAAAAAAaIDpq6Q4 -0tVtADQAAAAAAEUimhcmJ0+fiAA8AAAAAAAn+8TUMaJj7aIARAAAAAAAqK3IjDhl3rC9AEwAAAAA -ANtlqxqOCMeD2ABUAAAAAACaHXFC+R1dxPIAXAAAAAAAWOcbpixpTZINAWQAAAAAAOqNcBpk7gHa -JwFsAAAAAABKd++amaNtokIBdAAAAAAAhWt9tHt4CfJcAXwAAAAAAHcY3Xmh5FS0dwGEAAAAAADC -xZtbkoZbhpIBjAAAAAAAPV2WyMVTNcisAZQAAAAAALOgl/pctCqVxwGcAAAAAADjX6CZvZ9G3uEB -pAAAAAAAJYw52zTCm6X8AawAAAAAAFyfmKNymsb2FgK0AAAAAADOvulUU7/ctzECvAAAAAAA4kEi -8hfz/IhMAsQAAAAAAKV4XNObziDMZgLMAAAAAADfUyF781oWmIEC1AAAAAAAOjAfl9y1oOKbAtwA -AAAAAJaz41xT0dmotgLkAAAAAAA8RKek2Xyb+9AC7AAAAAAAEESkp0xMdrvrAvQAAAAAABqcQLbv -jquLBgP8AAAAAAAshFemEO8f0CADBAEAAAAAKTGR6eWkEJs7AwwBAAAAAJ0MnKH7mxDnVQMUAQAA -AAAp9Dti2SAorHADHAEAAAAAhc+nel5LRICLAyQBAAAAAC3drANA5CG/pQMsAQAAAACP/0ReL5xn -jsADNAEAAAAAQbiMnJ0XM9TaAzwBAAAAAKkb47SS2xme9QNEAQAAAADZd9+6br+W6w8ETAEAAAAA -bGlicmFyeS9jb3JlL3NyYy9udW0vZmx0MmRlYy9zdHJhdGVneS9ncmlzdS5ycwAAuDAQAC4AAAB9 -AAAAFQAAALgwEAAuAAAAqQAAAAUAAAC4MBAALgAAAKoAAAAFAAAAuDAQAC4AAACrAAAABQAAALgw -EAAuAAAArgAAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBkLm1hbnQgKyBkLnBsdXMgPCAoMSA8PCA2 -MSkAAAC4MBAALgAAAK8AAAAFAAAAuDAQAC4AAAAKAQAAEQAAALgwEAAuAAAADQEAAAkAAAC4MBAA -LgAAAEABAAAJAAAAuDAQAC4AAACtAAAABQAAALgwEAAuAAAArAAAAAUAAABhc3NlcnRpb24gZmFp -bGVkOiAhYnVmLmlzX2VtcHR5KCkAAAC4MBAALgAAANwBAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDog -ZC5tYW50IDwgKDEgPDwgNjEpuDAQAC4AAADdAQAABQAAALgwEAAuAAAA3gEAAAUAAAABAAAACgAA -AGQAAADoAwAAECcAAKCGAQBAQg8AgJaYAADh9QUAypo7uDAQAC4AAAAzAgAAEQAAALgwEAAuAAAA -NgIAAAkAAAC4MBAALgAAAGwCAAAJAAAAuDAQAC4AAADjAgAAJgAAALgwEAAuAAAA7wIAACYAAAC4 -MBAALgAAAMwCAAAmAAAAbGlicmFyeS9jb3JlL3NyYy9udW0vZmx0MmRlYy9tb2QucnMAyDIQACMA -AAC7AAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGJ1ZlswXSA+IGInMCcAyDIQACMAAAC8AAAABQAA -AGFzc2VydGlvbiBmYWlsZWQ6IHBhcnRzLmxlbigpID49IDQAAMgyEAAjAAAAvQAAAAUAAAAuMC4t -K05hTmluZjBhc3NlcnRpb24gZmFpbGVkOiBidWYubGVuKCkgPj0gbWF4bGVuAAAAyDIQACMAAAB+ -AgAADQAAACkuLjAxMjM0NTY3ODlhYmNkZWZCb3Jyb3dNdXRFcnJvcmFscmVhZHkgYm9ycm93ZWQ6 -IADFMxAAEgAAAGNhbGxlZCBgT3B0aW9uOjp1bndyYXAoKWAgb24gYSBgTm9uZWAgdmFsdWVpbmRl -eCBvdXQgb2YgYm91bmRzOiB0aGUgbGVuIGlzICBidXQgdGhlIGluZGV4IGlzIAAAAAs0EAAgAAAA -KzQQABIAAAAAAAAABAAAAAQAAABkAAAAPT0hPW1hdGNoZXNhc3NlcnRpb24gYGxlZnQgIHJpZ2h0 -YCBmYWlsZWQKICBsZWZ0OiAKIHJpZ2h0OiAAazQQABAAAAB7NBAAFwAAAJI0EAAJAAAAIHJpZ2h0 -YCBmYWlsZWQ6IAogIGxlZnQ6IAAAAGs0EAAQAAAAtDQQABAAAADENBAACQAAAJI0EAAJAAAAOiAA -AAEAAAAAAAAA8DQQAAIAAAAAAAAADAAAAAQAAABlAAAAZgAAAGcAAAAgICAgLAooKAosMHgwMDAx -MDIwMzA0MDUwNjA3MDgwOTEwMTExMjEzMTQxNTE2MTcxODE5MjAyMTIyMjMyNDI1MjYyNzI4Mjkz -MDMxMzIzMzM0MzUzNjM3MzgzOTQwNDE0MjQzNDQ0NTQ2NDc0ODQ5NTA1MTUyNTM1NDU1NTY1NzU4 -NTk2MDYxNjI2MzY0NjU2NjY3Njg2OTcwNzE3MjczNzQ3NTc2Nzc3ODc5ODA4MTgyODM4NDg1ODY4 -Nzg4ODk5MDkxOTI5Mzk0OTU5Njk3OTg5OTAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw -MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDBsaWJyYXJ5L2NvcmUvc3JjL2ZtdC9tb2Qu -cnNmYWxzZXRydWUwNhAAGwAAANgKAAAmAAAAMDYQABsAAADhCgAAGgAAAGxpYnJhcnkvY29yZS9z -cmMvc3RyL21vZC5yc1suLi5dYmVnaW4gPD0gZW5kICggPD0gKSB3aGVuIHNsaWNpbmcgYGAAlDYQ -AA4AAACiNhAABAAAAKY2EAAQAAAAtjYQAAEAAABieXRlIGluZGV4ICBpcyBub3QgYSBjaGFyIGJv -dW5kYXJ5OyBpdCBpcyBpbnNpZGUgIChieXRlcyApIG9mIGAA2DYQAAsAAADjNhAAJgAAAAk3EAAI -AAAAETcQAAYAAAC2NhAAAQAAACBpcyBvdXQgb2YgYm91bmRzIG9mIGAAANg2EAALAAAAQDcQABYA -AAC2NhAAAQAAAHQ2EAAbAAAAnAEAACwAAABsaWJyYXJ5L2NvcmUvc3JjL3VuaWNvZGUvcHJpbnRh -YmxlLnJzAAAAgDcQACUAAAAaAAAANgAAAIA3EAAlAAAACgAAACsAAAAABgEBAwEEAgUHBwIICAkC -CgULAg4EEAERAhIFExwUARUCFwIZDRwFHQgfASQBagRrAq8DsQK8As8C0QLUDNUJ1gLXAtoB4AXh -AucE6ALuIPAE+AL6BPsBDCc7Pk5Pj56en3uLk5aisrqGsQYHCTY9Plbz0NEEFBg2N1ZXf6qur701 -4BKHiY6eBA0OERIpMTQ6RUZJSk5PZGWKjI2PtsHDxMbL1ly2txscBwgKCxQXNjk6qKnY2Qk3kJGo -Bwo7PmZpj5IRb1+/7u9aYvT8/1NUmpsuLycoVZ2goaOkp6iturzEBgsMFR06P0VRpqfMzaAHGRoi -JT4/5+zv/8XGBCAjJSYoMzg6SEpMUFNVVlhaXF5gY2Vma3N4fX+KpKqvsMDQrq9ub93ek14iewUD -BC0DZgMBLy6Agh0DMQ8cBCQJHgUrBUQEDiqAqgYkBCQEKAg0C04DNAyBNwkWCggYO0U5A2MICTAW -BSEDGwUBQDgESwUvBAoHCQdAICcEDAk2AzoFGgcEDAdQSTczDTMHLggKBiYDHQgCgNBSEAM3LAgq -FhomHBQXCU4EJAlEDRkHCgZICCcJdQtCPioGOwUKBlEGAQUQAwULWQgCHWIeSAgKgKZeIkULCgYN -EzoGCgYUHCwEF4C5PGRTDEgJCkZFG0gIUw1JBwqAtiIOCgZGCh0DR0k3Aw4ICgY5BwqBNhkHOwMd -VQEPMg2Dm2Z1C4DEikxjDYQwEBYKj5sFgkeauTqGxoI5ByoEXAYmCkYKKAUTgbA6gMZbZUsEOQcR -QAULAg6X+AiE1ikKoueBMw8BHQYOBAiBjIkEawUNAwkHEI9ggPoGgbRMRwl0PID2CnMIcBVGehQM -FAxXCRmAh4FHA4VCDxWEUB8GBoDVKwU+IQFwLQMaBAKBQB8ROgUBgdAqgNYrBAGB4ID3KUwECgQC -gxFETD2AwjwGAQRVBRs0AoEOLARkDFYKgK44HQ0sBAkHAg4GgJqD2AQRAw0DdwRfBgwEAQ8MBDgI -CgYoCCwEAj6BVAwdAwoFOAccBgkHgPqEBgABAwUFBgYCBwYIBwkRChwLGQwaDRAODA8EEAMSEhMJ -FgEXBBgBGQMaBxsBHAIfFiADKwMtCy4BMAQxAjIBpwSpAqoEqwj6AvsF/QL+A/8JrXh5i42iMFdY -i4yQHN0OD0tM+/wuLz9cXV/ihI2OkZKpsbq7xcbJyt7k5f8ABBESKTE0Nzo7PUlKXYSOkqmxtLq7 -xsrOz+TlAAQNDhESKTE0OjtFRklKXmRlhJGbncnOzw0RKTo7RUlXW1xeX2RljZGptLq7xcnf5OXw -DRFFSWRlgISyvL6/1dfw8YOFi6Smvr/Fx8/a20iYvc3Gzs9JTk9XWV5fiY6Psba3v8HGx9cRFhdb -XPb3/v+AbXHe3w4fbm8cHV99fq6vTbu8FhceH0ZHTk9YWlxefn+1xdTV3PDx9XJzj3R1liYuL6ev -t7/Hz9ffmgBAl5gwjx/Oz9LUzv9OT1pbBwgPECcv7u9ubzc9P0JFkJFTZ3XIydDR2Nnn/v8AIF8i -gt8EgkQIGwQGEYGsDoCrBR8IgRwDGQgBBC8ENAQHAwEHBgcRClAPEgdVBwMEHAoJAwgDBwMCAwMD -DAQFAwsGAQ4VBU4HGwdXBwIGFwxQBEMDLQMBBBEGDww6BB0lXyBtBGolgMgFgrADGgaC/QNZBxYJ -GAkUDBQMagYKBhoGWQcrBUYKLAQMBAEDMQssBBoGCwOArAYKBi8xgPQIPAMPAz4FOAgrBYL/ERgI -LxEtAyEPIQ+AjASCmhYLFYiUBS8FOwcCDhgJgL4idAyA1hqBEAWA4QnyngM3CYFcFIC4CIDdFTsD -CgY4CEYIDAZ0Cx4DWgRZCYCDGBwKFglMBICKBqukDBcEMaEEgdomBwwFBYCmEIH1BwEgKgZMBICN -BIC+AxsDDw1saWJyYXJ5L2NvcmUvc3JjL3VuaWNvZGUvdW5pY29kZV9kYXRhLnJzAAAAcT0QACgA -AABNAAAAKAAAAHE9EAAoAAAAWQAAABYAAABsaWJyYXJ5L2NvcmUvc3JjL251bS9iaWdudW0ucnMA -ALw9EAAeAAAAqwEAAAEAAABhc3NlcnRpb24gZmFpbGVkOiBub2JvcnJvd2Fzc2VydGlvbiBmYWls -ZWQ6IGRpZ2l0cyA8IDQwYXNzZXJ0aW9uIGZhaWxlZDogb3RoZXIgPiAwYXR0ZW1wdCB0byBkaXZp -ZGUgYnkgemVybwA+PhAAGQAAAGF0dGVtcHQgdG8gY2FsY3VsYXRlIHRoZSByZW1haW5kZXIgd2l0 -aCBhIGRpdmlzb3Igb2YgemVybwAAAGA+EAA5AAAAcmFuZ2Ugc3RhcnQgaW5kZXggIG91dCBvZiBy -YW5nZSBmb3Igc2xpY2Ugb2YgbGVuZ3RoIKQ+EAASAAAAtj4QACIAAAByYW5nZSBlbmQgaW5kZXgg -6D4QABAAAAC2PhAAIgAAAHNsaWNlIGluZGV4IHN0YXJ0cyBhdCAgYnV0IGVuZHMgYXQgAAg/EAAW -AAAAHj8QAA0AAABjb3B5X2Zyb21fc2xpY2U6IHNvdXJjZSBzbGljZSBsZW5ndGggKCkgZG9lcyBu -b3QgbWF0Y2ggZGVzdGluYXRpb24gc2xpY2UgbGVuZ3RoICgAAAA8PxAAJgAAAGI/EAArAAAApDMQ -AAEAAAAAAwAAgwQgAJEFYABdE6AAEhcgHwwgYB/vLCArKjCgK2+mYCwCqOAsHvvgLQD+IDae/2A2 -/QHhNgEKITckDeE3qw5hOS8Y4TkwHOFK8x7hTkA0oVIeYeFT8GphVE9v4VSdvGFVAM9hVmXRoVYA -2iFXAOChWK7iIVrs5OFb0OhhXCAA7lzwAX9dYDQQAGI0EABkNBAAAgAAAAIAAAAHAEHggMEACwFH -AHAJcHJvZHVjZXJzAghsYW5ndWFnZQEEUnVzdAAMcHJvY2Vzc2VkLWJ5AwVydXN0Yx0xLjg3LjAg -KDE3MDY3ZTlhYyAyMDI1LTA1LTA5KQZ3YWxydXMGMC4yMy4zDHdhc20tYmluZGdlbgcwLjIuMTAw -AGsPdGFyZ2V0X2ZlYXR1cmVzBisPbXV0YWJsZS1nbG9iYWxzKxNub250cmFwcGluZy1mcHRvaW50 -KwtidWxrLW1lbW9yeSsIc2lnbi1leHQrD3JlZmVyZW5jZS10eXBlcysKbXVsdGl2YWx1ZQ== +L3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvc3RyaW5nLnJzlAYQAHQAAADoAQAAFwAAAEVycm9yAAAA +lAYQAHQAAAB9BQAAGwAAAGludmFsaWQgdmFsdWU6ICwgZXhwZWN0ZWQgAAAwBxAADwAAAD8HEAAL +AAAAbWlzc2luZyBmaWVsZCBgYFwHEAAPAAAAawcQAAEAAABkdXBsaWNhdGUgZmllbGQgYAAAAHwH +EAARAAAAawcQAAEAAAASAAAADAAAAAQAAAATAAAAFAAAAAcAAAAvaG9tZS9jb3lvdHRlNTA4Ly5y +dXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0 +bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3NsaWNlLnJzALgHEABzAAAAvgEAAB0AAAAv +aG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24t +bGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3ZlYy9zcGVj +X2Zyb21faXRlcl9uZXN0ZWQucnMAPAgQAIcAAAATAAAABQAAAGludmFsaWQgdHlwZTogLCBleHBl +Y3RlZCAAAADUCBAADgAAAOIIEAALAAAAL2hvbWUvY295b3R0ZTUwOC8ucnVzdHVwL3Rvb2xjaGFp +bnMvc3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9saWIvcnVzdGxpYi9zcmMvcnVzdC9s +aWJyYXJ5L2FsbG9jL3NyYy9zbGljZS5ycwAACRAAcwAAAL4BAAAdAAAAAQAAAAAAAAAvaG9tZS9j +b3lvdHRlNTA4Ly5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1 +YjU1N2Yvc2VyZGUtd2FzbS1iaW5kZ2VuLTAuNi41L3NyYy9saWIucnMAAACMCRAAaQAAADUAAAAO +AAAA//////////8IChAAQaCUwAALgSIBAAAAL2hvbWUvY295b3R0ZTUwOC9jb2RlL2h1Z2dpbmdm +YWNlLmpzL3BhY2thZ2VzL2h1Yi94ZXQtY29yZS13YXNtLWJ1aWxkL2RlZHVwbGljYXRpb24vc3Jj +L2NodW5raW5nLnJzACQKEABjAAAAHgAAAAkAAABhc3NlcnRpb24gZmFpbGVkOiB0YXJnZXRfY2h1 +bmtfc2l6ZSA+IDY0JAoQAGMAAAAiAAAACQAAACQKEABjAAAALgAAAB0AAABhc3NlcnRpb24gZmFp +bGVkOiBtYXhpbXVtX2NodW5rID4gbWluaW11bV9jaHVuawAkChAAYwAAADEAAAAJAAAAJAoQAGMA +AAA7AAAAFwAAACQKEABjAAAAZQAAADsAAAAkChAAYwAAAIcAAAAyAAAAJAoQAGMAAACJAAAAOgAA +ACQKEABjAAAAsQAAABUAAAAkChAAYwAAAK4AAABAAAAAL2hvbWUvY295b3R0ZTUwOC8uY2FyZ28v +cmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2xhenlfc3RhdGlj +LTEuNS4wL3NyYy9pbmxpbmVfbGF6eS5ycwAAgAsQAGoAAAAeAAAAEAAAAC9ob21lL2NveW90dGU1 +MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS14ODZfNjQtdW5rbm93bi1saW51eC1nbnUvbGli +L3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvcmF3X3ZlYy9tb2QucnMAAAD8CxAA +eQAAAC4CAAARAAAAT25jZSBpbnN0YW5jZSBoYXMgcHJldmlvdXNseSBiZWVuIHBvaXNvbmVkAACI +DBAAKgAAAG9uZS10aW1lIGluaXRpYWxpemF0aW9uIG1heSBub3QgYmUgcGVyZm9ybWVkIHJlY3Vy +c2l2ZWx5vAwQADgAAAAvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUt +eDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvc3Rk +L3NyYy9zeW5jL3BvaXNvbi9vbmNlLnJz/AwQAHwAAACbAAAAMgAAAFn1QOip04iw1iDtOffHUlar +comJaYmyRXfHjrbViQprtzF6iz5XjzZL2Tbp3DbGHbbVVFVOTHogy5ojKEazdKQSuaMcPqgGO/e6 +Ai9sjeeQipoNFfctyeGt04YQOgWVjiIHOrjx9C5arn+An5SsD6WB1tiA6wNzDg+tcBXcfrCZdjD9 +VbUvnWhopJ4RglAAACjMj6gGg7DE/Uo39opnsD42dK2Gq4ef8TbHa76/nxLy7aSYXFdJEUjFe0eV +BgEAAMzqnBqAN7ofbZukY9Zv8DtLh+OCl35omePYUKpzBqF5IPQRYp7PrORxkFeHH+cgJZuKGnj9 +09Urc8gR3c1N3gAvOYdaHDGp6v9AvBe2jnTbb78g9o2aV6+xwgkb2uWmhi6hIsMKwy/MZ0L3wf4q +XjV7pCHA9MiZLcPPBJRKS966aX1wHXIYtfcgLPN7WLaGMgwnr4aItgAAeZCK2+TWFaGZ4bKXnH5P +SAHjE1e3e8rMYPGwK6aEJb/IvF1iE+jnrVqVhw2UcAAAb2KeEwiR5oqiON4v12p3vc/A/MIfAGv7 +J8R75rh0pMdYXesQFvH2utFw521bH8sJR0x9l+YZsrBKraduOLzMAAE/l98KnYTMcPdqAX3vo3P+ +vb2G09IHyDAXeWyWySp/2gTFxmuoN9CdYKoeZnzx84fmqk2wJqasB1tKTzeZWnXerixb5n6DkIUH +Vv2Trehu2O1TEOHZAADX2xzSsjsGnrLSASrxd6sHRBtk5lUCVezGFJxEqJT7ePX1wMYbDlHH48rk +NgsyAAAtGossJjN8gkRB6kgLX2cU6+yNSabTeyZeA/WC+W+R8Yj7NPR/GyKG2ElvOOfOvp1Kjw/I +yvhY6thk/JKGGY0ANpq/uk9wOG1MvufRB8sy4JAIRa32IY0ipYklwL+xXGNxzqKcc6EgRlj75arj +3+en6w08K5PKEAx77a+E6P4nJx+r4vltHN+iI/V0B6zRzU1O4jOt/3AAABZ4l8V76KyiSWAotFon +kphZifHdgRGGwhk+SEKgcpm7eDBRZjfNcO9kmPyrEwUAAINAyVgYtljA3uAll4VQ6AmUfT74O/uX +kc5LthJtYh5+0Vd7f1BUDFIWJOJ0cXnhvodV6SIyrNlvPr/fmnyVIwAVvksjfn0coLuMo7hYx6Kr +MCs+7M6gHw2RuWB+i6W2CzVmop9b3TNDo8EBQH07/cInEXNUJIBB+8sYDaWFYaVlT7WEh70CevZj +UOZn3RFvaasUqPwiIAAAUti5LZG+1oxXiq7ptolRaSgM2gq1U5TuXoR4Gqle/Nhnp0oaGb+Gq+UV +ZMi1xgAALqIIjhcQcyYlyosHGxAt7fuoJrKE7UE7BtwoDxIi5hMmbXD76/UVo866ATNOwxaIrv1x +u5xbOelIFnIuIOksABzJsysd24NCpaax0hpGfddrhutu5Bfs4nzE+zlAvuC4BJ0p1cRgod40NozS +yIbsfpmjmJ8SrRkh74OiYWv0zKYXxlj23s5SLIPdrGkRh7Qt6cue89bwAACJlC+NydjVPYT1ASui +chiK8jx7DsSkgvKWoRvLLOwggBPjWZ7gtpNm64N8zBnOAAA7nEf2NVfLIFta11k3vy52dTlpPYL+ +eyDV2ZwzEsF91wN9YoRCg6eb6VFf6RPFfSEWeF78KRp7si1muzGYzdUATHN1bYCb43EjGvsG8CpX +foUf6WovT3Oi8t0sArXGgr/eoGEHxuo7XJhpQUe7k8jNAX4YXGGFEG1dfCesMK74d5EsKhKBa3yR +Z2nRrZm2dVubBprnas8AAAQR3mD6CsTzw2eRpXoSYyBNidFpIuYdYiZHK+YdrIjRPGdLFeI2cBAd +OlUoX7gAAD1vIxhMTu/yAva5EWbe1tkckUf7VXn8ob2NKS8D/YXr4fq+sy9QJ74eZs3EUUID4zYY +B1TTZBNEPpjydWyzggDwZvoWA5FFsffKR5icBhwCIVJLWsffECm1qFccPjVbc2zZjuksMUTOZfq9 +BkUulLwblFcSp4ZQ8K3OUdMVssP+AkIU4FUQrgBU5EJvhEBL9ci8vMjZfwAA/pveF/Oevb8SToXy +LzAEqNTY5aVXSc45hLo3VqTiuf+LgaCeHa25VYoXGfPLigAAOPv70Mi/4kjotUjoQZjji4uglgYW +EicOKiRES+iWENU64ZJnF7oBEZ1oMUUPdy7CbMW7cvLviRbsUFZ/GSqpAE54ob2QWXa8rrj8kuNB +FMag5DHtLDrhB02dTiOE6cuSxYp9u3L1T4/QO5YLwHCWCwHrAxpYWpViVAIA6uWDX2SZ8ojNFuX8 +Qc+YetpIl9q7+kVI/rKqAABVZfWbBht2GVattkODXo+L2SFIFP0cXT6PzbCiLB5c7H+1+6f+4Pf6 +G5YSutMAAACOsQGEF5A/2utfOuNtkP9w53BpwKfVJwXpE3xgc+fYIqw7PGTfcKvJ4xK+itzGpO2K +5zMAQR/v7MtyrHSywiQAtACpT5UNdAYEYz0ymyl6HdXqy5iyfMOzm3N4YcfjhsmK9UZLNuqrn1bM +ha/FFKJthI+jt9g+pBfr25odUezMbvtaMxMJs8r50u4V9MVgXkq0cjZQZ2kAAIe7VBQSHaWdFsi7 +uRMeMoSN3S+rtm89+40KFo7tXjBg6GyU6RRLv8vDEBs4Y08AABBOzG+Bt9UHVYFqanI2peXdf6BH +NLKvV5TTyav3RvMYPdMa1lXGbWP28/c5SauLzHsY3cEGqcdjL2hvbWUvY295b3R0ZTUwOC8ucnVz +dHVwL3Rvb2xjaGFpbnMvc3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9saWIvcnVzdGxp +Yi9zcmMvcnVzdC9saWJyYXJ5L2FsbG9jL3NyYy9zbGljZS5ycwCIFRAAcwAAAL4BAAAdAAAAT25j +ZSBpbnN0YW5jZSBoYXMgcHJldmlvdXNseSBiZWVuIHBvaXNvbmVkAAAMFhAAKgAAAG9uZS10aW1l +IGluaXRpYWxpemF0aW9uIG1heSBub3QgYmUgcGVyZm9ybWVkIHJlY3Vyc2l2ZWx5QBYQADgAAAAv +aG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24t +bGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvc3RkL3NyYy9zeW5jL3BvaXNv +bi9vbmNlLnJzgBYQAHwAAACbAAAAMgAAAC9ob21lL2NveW90dGU1MDgvLmNhcmdvL3JlZ2lzdHJ5 +L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9sYXp5X3N0YXRpYy0xLjUuMC9z +cmMvaW5saW5lX2xhenkucnMAAAwXEABqAAAAHgAAABAAAAAvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0 +dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGli +L3NyYy9ydXN0L2xpYnJhcnkvY29yZS9zcmMvaXRlci90cmFpdHMvaXRlcmF0b3IucnMAAACIFxAA +gQAAAMEHAAAJAAAAfxhX1s5W7WYSf/kT56XD86TNJtW120nmQSSYfyj7lMMvaG9tZS9jb3lvdHRl +NTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xp +Yi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3Jhd192ZWMvbW9kLnJzAAAAPBgQ +AHkAAAAuAgAAEQAAAAAAAAAEAAAABAAAABcAAAAvaG9tZS9jb3lvdHRlNTA4Ly5jYXJnby9yZWdp +c3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvanMtc3lzLTAuMy43Ny9z +cmMvbGliLnJzAADYGBAAXgAAAPsYAAABAAAAL2hvbWUvY295b3R0ZTUwOC8uY2FyZ28vcmVnaXN0 +cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3dhc20tYmluZGdlbi0wLjIu +MTAwL3NyYy9jb252ZXJ0L3NsaWNlcy5yc0gZEABwAAAAJAEAAA4AAABjbG9zdXJlIGludm9rZWQg +cmVjdXJzaXZlbHkgb3IgYWZ0ZXIgYmVpbmcgZHJvcHBlZExheW91dEVycm9yL2hvbWUvY295b3R0 +ZTUwOC8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9s +aWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2FsbG9jL3NyYy9zbGljZS5ycwUaEABzAAAAvgEA +AB0AAAAkAAAAJQAAACYAAAAnAAAAKAAAAC9ob21lL2NveW90dGU1MDgvLmNhcmdvL3JlZ2lzdHJ5 +L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9ieXRlcy0xLjEwLjEvc3JjL2J5 +dGVzLnJzACkAAAAqAAAAKwAAACwAAAAtAAAALgAAAC8AAAAwAAAALAAAADEAQay2wAALpRQBAAAA +MgAAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAnBoQAF8AAABI +BQAAMgAAAJwaEABfAAAAVgUAAEkAAAAzAAAANAAAADUAAAA2AAAANwAAAC9ob21lL2NveW90dGU1 +MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS14ODZfNjQtdW5rbm93bi1saW51eC1nbnUvbGli +L3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvc2xpY2UucnMAlBsQAHMAAAC+AQAA +HQAAAC9ob21lL2NveW90dGU1MDgvY29kZS9odWdnaW5nZmFjZS5qcy9wYWNrYWdlcy9odWIveGV0 +LWNvcmUtd2FzbS1idWlsZC9tZXJrbGVoYXNoL3NyYy9kYXRhX2hhc2gucnMAAAAYHBAAYQAAAHoA +AAAJAAAASW52YWxpZCBoZXggaW5wdXQgZm9yIERhdGFIYXNoAAABAAAAAAAAAAEAAAAAAAAAAQAA +AAAAAAABAAAAAAAAABgcEABhAAAAsgAAACoAAAAYHBAAYQAAALMAAAAqAAAAGBwQAGEAAAC0AAAA +KgAAAGaX9XdblVDeMTXLrKWXGByd5CEQm+srWLTQsEuTrfIpAX7Fx6VHKZb9lGZmtIoC5l3dU283 +x23S+GNS5kpTcT8BAAAAAAAAAG1pZCA+IGxlbgAAAEQdEAAJAAAAL2hvbWUvY295b3R0ZTUwOC8u +Y2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2JsYWtl +My0xLjguMi9zcmMvbGliLnJzAAAAWB0QAF0AAAALAgAAEQAAAFgdEABdAAAAvgIAAAoAAABYHRAA +XQAAAOwCAAAoAAAAWB0QAF0AAADsAgAANAAAAFgdEABdAAAA7AIAAAwAAABYHRAAXQAAANwCAAAX +AAAAWB0QAF0AAAAYAwAAHwAAAFgdEABdAAAANQMAAAwAAABYHRAAXQAAADwDAAASAAAAWB0QAF0A +AABgAwAAIQAAAFgdEABdAAAAYgMAABEAAABYHRAAXQAAAGIDAABBAAAAaW5zdWZmaWNpZW50IGNh +cGFjaXR5AAAAeB4QABUAAABDYXBhY2l0eUVycm9yOiAAmB4QAA8AAABjYWxsZWQgYFJlc3VsdDo6 +dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlAAAAAAAEAAAABAAAADsAAAAAAAAACAAAAAQAAABD +AAAARAAAAEUAAABhIHN0cmluZ2J5dGUgYXJyYXlib29sZWFuIGBgFh8QAAkAAAAfHxAAAQAAAGlu +dGVnZXIgYAAAADAfEAAJAAAAHx8QAAEAAABmbG9hdGluZyBwb2ludCBgTB8QABAAAAAfHxAAAQAA +AGNoYXJhY3RlciBgAGwfEAALAAAAHx8QAAEAAABzdHJpbmcgAIgfEAAHAAAAdW5pdCB2YWx1ZU9w +dGlvbiB2YWx1ZW5ld3R5cGUgc3RydWN0c2VxdWVuY2VtYXBlbnVtdW5pdCB2YXJpYW50bmV3dHlw +ZSB2YXJpYW50dHVwbGUgdmFyaWFudHN0cnVjdCB2YXJpYW50AAAAAQAAAAAAAAAuMHUzMkxhenkg +aW5zdGFuY2UgaGFzIHByZXZpb3VzbHkgYmVlbiBwb2lzb25lZAARIBAAKgAAAC9ob21lL2NveW90 +dGU1MDgvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3 +Zi9vbmNlX2NlbGwtMS4yMS4zL3NyYy9saWIucnMAAABEIBAAYQAAAAgDAAAZAAAAcmVlbnRyYW50 +IGluaXQAALggEAAOAAAARCAQAGEAAAB6AgAADQAAAC9ob21lL2NveW90dGU1MDgvLmNhcmdvL3Jl +Z2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi93YXNtLWJpbmRnZW4t +MC4yLjEwMC9zcmMvY29udmVydC9pbXBscy5ycwDgIBAAbwAAAGECAAAWAAAA4CAQAG8AAABxAgAA +DAAAAOAgEABvAAAAbQIAABAAAABhcnJheSBjb250YWlucyBhIHZhbHVlIG9mIHRoZSB3cm9uZyB0 +eXBlbnVsbCBwb2ludGVyIHBhc3NlZCB0byBydXN0cmVjdXJzaXZlIHVzZSBvZiBhbiBvYmplY3Qg +ZGV0ZWN0ZWQgd2hpY2ggd291bGQgbGVhZCB0byB1bnNhZmUgYWxpYXNpbmcgaW4gcnVzdEpzVmFs +dWUoKQASIhAACAAAABoiEAABAAAAL3J1c3RjLzE3MDY3ZTlhYzZkN2VjYjcwZTUwZjkyYzE5NDRl +NTQ1MTg4ZDIzNTkvbGlicmFyeS9hbGxvYy9zcmMvc3RyaW5nLnJzACwiEABLAAAAfQUAABsAAAAv +cnVzdGMvMTcwNjdlOWFjNmQ3ZWNiNzBlNTBmOTJjMTk0NGU1NDUxODhkMjM1OS9saWJyYXJ5L2Fs +bG9jL3NyYy9yYXdfdmVjL21vZC5yc4giEABQAAAALgIAABEAAABKAAAADAAAAAQAAABLAAAATAAA +AE0AAAAvcnVzdC9kZXBzL2RsbWFsbG9jLTAuMi43L3NyYy9kbG1hbGxvYy5yc2Fzc2VydGlvbiBm +YWlsZWQ6IHBzaXplID49IHNpemUgKyBtaW5fb3ZlcmhlYWQAACMQACkAAACoBAAACQAAAGFzc2Vy +dGlvbiBmYWlsZWQ6IHBzaXplIDw9IHNpemUgKyBtYXhfb3ZlcmhlYWQAAAAjEAApAAAArgQAAA0A +AABtZW1vcnkgYWxsb2NhdGlvbiBvZiAgYnl0ZXMgZmFpbGVkAACoIxAAFQAAAL0jEAANAAAAbGli +cmFyeS9zdGQvc3JjL2FsbG9jLnJz3CMQABgAAABkAQAACQAAAEoAAAAMAAAABAAAAE4AAAAAAAAA +CAAAAAQAAABPAAAAAAAAAAgAAAAEAAAAUAAAAFEAAABSAAAAUwAAAFQAAAAQAAAABAAAAFUAAABW +AAAAVwAAAFgAAABIYXNoIHRhYmxlIGNhcGFjaXR5IG92ZXJmbG93XCQQABwAAAAvcnVzdC9kZXBz +L2hhc2hicm93bi0wLjE1LjIvc3JjL3Jhdy9tb2QucnMAAIAkEAAqAAAAIwAAACgAAABFcnJvcgAA +AFkAAAAMAAAABAAAAFoAAABbAAAAXAAAAGNhcGFjaXR5IG92ZXJmbG93AAAA3CQQABEAAABsaWJy +YXJ5L2FsbG9jL3NyYy9yYXdfdmVjL21vZC5yc/gkEAAgAAAALgIAABEAAABsaWJyYXJ5L2FsbG9j +L3NyYy9zdHJpbmcucnMAKCUQABsAAADoAQAAFwBB3MrAAAvIEgEAAABdAAAAYSBmb3JtYXR0aW5n +IHRyYWl0IGltcGxlbWVudGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHdoZW4gdGhlIHVuZGVybHlp +bmcgc3RyZWFtIGRpZCBub3RsaWJyYXJ5L2FsbG9jL3NyYy9mbXQucnMAALolEAAYAAAAigIAAA4A +AAAoJRAAGwAAAH0FAAAbAAAAAHAABwAtAQEBAgECAQFICzAVEAFlBwIGAgIBBCMBHhtbCzoJCQEY +BAEJAQMBBSsDOwkqGAEgNwEBAQQIBAEDBwoCHQE6AQEBAgQIAQkBCgIaAQICOQEEAgQCAgMDAR4C +AwELAjkBBAUBAgQBFAIWBgEBOgEBAgEECAEHAwoCHgE7AQEBDAEJASgBAwE3AQEDBQMBBAcCCwId +AToBAgIBAQMDAQQHAgsCHAI5AgEBAgQIAQkBCgIdAUgBBAECAwEBCAFRAQIHDAhiAQIJCwdJAhsB +AQEBATcOAQUBAgULASQJAWYEAQYBAgICGQIEAxAEDQECAgYBDwEAAwAEHAMdAh4CQAIBBwgBAgsJ +AS0DAQF1AiIBdgMEAgkBBgPbAgIBOgEBBwEBAQECCAYKAgEwHzEEMAoEAyYJDAIgBAIGOAEBAgMB +AQU4CAICmAMBDQEHBAEGAQMCxkAAAcMhAAONAWAgAAZpAgAEAQogAlACAAEDAQQBGQIFAZcCGhIN +ASYIGQsBASwDMAECBAICAgEkAUMGAgICAgwBCAEvATMBAQMCAgUCAQEqAggB7gECAQQBAAEAEBAQ +AAIAAeIBlQUAAwECBQQoAwQBpQIABEEFAAJPBEYLMQR7ATYPKQECAgoDMQQCAgcBPQMkBQEIPgEM +AjQJAQEIBAIBXwMCBAYBAgGdAQMIFQI5AgEBAQEMAQkBDgcDBUMBAgYBAQIBAQMEAwEBDgJVCAID +AQEXAVEBAgYBAQIBAQIBAusBAgQGAgECGwJVCAIBAQJqAQEBAghlAQEBAgQBBQAJAQL1AQoEBAGQ +BAICBAEgCigGAgQIAQkGAgMuDQECAAcBBgEBUhYCBwECAQJ6BgMBAQIBBwEBSAIDAQEBAAILAjQF +BQMXAQABBg8ADAMDAAU7BwABPwRRAQsCAAIALgIXAAUDBggIAgceBJQDADcEMggBDgEWBQEPAAcB +EQIHAQIBBWQBoAcAAT0EAAT+AgAHbQcAYIDwAGFzc2VydGlvbiBmYWlsZWQ6IGVkZWx0YSA+PSAw +bGlicmFyeS9jb3JlL3NyYy9udW0vZGl5X2Zsb2F0LnJzAAAAACkQACEAAABMAAAACQAAAAApEAAh +AAAATgAAAAkAAADBb/KGIwAAAIHvrIVbQW0t7gQAAAEfar9k7Thu7Zen2vT5P+kDTxgAAT6VLgmZ +3wP9OBUPL+R0I+z1z9MI3ATE2rDNvBl/M6YDJh/pTgIAAAF8Lphbh9O+cp/Z2IcvFRLGUN5rcG5K +zw/YldVucbImsGbGrSQ2FR1a00I8DlT/Y8BzVcwX7/ll8ii8VffH3IDc7W70zu/cX/dTBQBsaWJy +YXJ5L2NvcmUvc3JjL251bS9mbHQyZGVjL3N0cmF0ZWd5L2RyYWdvbi5yc2Fzc2VydGlvbiBmYWls +ZWQ6IGQubWFudCA+IDAA4CkQAC8AAAB2AAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGQubWludXMg +PiAwAAAA4CkQAC8AAAB3AAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGQucGx1cyA+IDDgKRAALwAA +AHgAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogYnVmLmxlbigpID49IE1BWF9TSUdfRElHSVRTAAAA +4CkQAC8AAAB7AAAABQAAAOApEAAvAAAAwgAAAAkAAADgKRAALwAAAPsAAAANAAAA4CkQAC8AAAAC +AQAAEgAAAGFzc2VydGlvbiBmYWlsZWQ6IGQubWFudC5jaGVja2VkX3N1YihkLm1pbnVzKS5pc19z +b21lKCkA4CkQAC8AAAB6AAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGQubWFudC5jaGVja2VkX2Fk +ZChkLnBsdXMpLmlzX3NvbWUoKQAA4CkQAC8AAAB5AAAABQAAAOApEAAvAAAACwEAAAUAAADgKRAA +LwAAAAwBAAAFAAAA4CkQAC8AAAANAQAABQAAAOApEAAvAAAAcgEAACQAAADgKRAALwAAAHcBAAAv +AAAA4CkQAC8AAACEAQAAEgAAAOApEAAvAAAAZgEAAA0AAADgKRAALwAAAEwBAAAiAAAA4CkQAC8A +AAAPAQAABQAAAOApEAAvAAAADgEAAAUAAADfRRo9A88a5sH7zP4AAAAAysaaxxf+cKvc+9T+AAAA +AE/cvL78sXf/9vvc/gAAAAAM1mtB75FWvhH85P4AAAAAPPx/kK0f0I0s/Oz+AAAAAIOaVTEoXFHT +Rvz0/gAAAAC1yaatj6xxnWH8/P4AAAAAy4vuI3cinOp7/AT/AAAAAG1TeECRScyulvwM/wAAAABX +zrZdeRI8grH8FP8AAAAAN1b7TTaUEMLL/Bz/AAAAAE+YSDhv6paQ5vwk/wAAAADHOoIly4V01wD9 +LP8AAAAA9Je/l83PhqAb/TT/AAAAAOWsKheYCjTvNf08/wAAAACOsjUq+2c4slD9RP8AAAAAOz/G +0t/UyIRr/Uz/AAAAALrN0xonRN3Fhf1U/wAAAACWySW7zp9rk6D9XP8AAAAAhKVifSRsrNu6/WT/ +AAAAAPbaXw1YZquj1f1s/wAAAAAm8cPek/ji8+/9dP8AAAAAuID/qqittbUK/nz/AAAAAItKfGwF +X2KHJf6E/wAAAABTMME0YP+8yT/+jP8AAAAAVSa6kYyFTpZa/pT/AAAAAL1+KXAkd/nfdP6c/wAA +AACPuOW4n73fpo/+pP8AAAAAlH10iM9fqfip/qz/AAAAAM+bqI+TcES5xP60/wAAAABrFQ+/+PAI +it/+vP8AAAAAtjExZVUlsM35/sT/AAAAAKx/e9DG4j+ZFP/M/wAAAAAGOysqxBBc5C7/1P8AAAAA +05JzaZkkJKpJ/9z/AAAAAA7KAIPytYf9Y//k/wAAAADrGhGSZAjlvH7/7P8AAAAAzIhQbwnMvIyZ +//T/AAAAACxlGeJYF7fRs//8/wBBrt3AAAsFQJzO/wQAQbzdwAALmSQQpdTo6P8MAAAAAAAAAGKs +xet4rQMAFAAAAAAAhAmU+Hg5P4EeABwAAAAAALMVB8l7zpfAOAAkAAAAAABwXOp7zjJ+j1MALAAA +AAAAaIDpq6Q40tVtADQAAAAAAEUimhcmJ0+fiAA8AAAAAAAn+8TUMaJj7aIARAAAAAAAqK3IjDhl +3rC9AEwAAAAAANtlqxqOCMeD2ABUAAAAAACaHXFC+R1dxPIAXAAAAAAAWOcbpixpTZINAWQAAAAA +AOqNcBpk7gHaJwFsAAAAAABKd++amaNtokIBdAAAAAAAhWt9tHt4CfJcAXwAAAAAAHcY3Xmh5FS0 +dwGEAAAAAADCxZtbkoZbhpIBjAAAAAAAPV2WyMVTNcisAZQAAAAAALOgl/pctCqVxwGcAAAAAADj +X6CZvZ9G3uEBpAAAAAAAJYw52zTCm6X8AawAAAAAAFyfmKNymsb2FgK0AAAAAADOvulUU7/ctzEC +vAAAAAAA4kEi8hfz/IhMAsQAAAAAAKV4XNObziDMZgLMAAAAAADfUyF781oWmIEC1AAAAAAAOjAf +l9y1oOKbAtwAAAAAAJaz41xT0dmotgLkAAAAAAA8RKek2Xyb+9AC7AAAAAAAEESkp0xMdrvrAvQA +AAAAABqcQLbvjquLBgP8AAAAAAAshFemEO8f0CADBAEAAAAAKTGR6eWkEJs7AwwBAAAAAJ0MnKH7 +mxDnVQMUAQAAAAAp9Dti2SAorHADHAEAAAAAhc+nel5LRICLAyQBAAAAAC3drANA5CG/pQMsAQAA +AACP/0ReL5xnjsADNAEAAAAAQbiMnJ0XM9TaAzwBAAAAAKkb47SS2xme9QNEAQAAAADZd9+6br+W +6w8ETAEAAAAAbGlicmFyeS9jb3JlL3NyYy9udW0vZmx0MmRlYy9zdHJhdGVneS9ncmlzdS5ycwAA +SDEQAC4AAAB9AAAAFQAAAEgxEAAuAAAAqQAAAAUAAABIMRAALgAAAKoAAAAFAAAASDEQAC4AAACr +AAAABQAAAEgxEAAuAAAArgAAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBkLm1hbnQgKyBkLnBsdXMg +PCAoMSA8PCA2MSkAAABIMRAALgAAAK8AAAAFAAAASDEQAC4AAAAKAQAAEQAAAEgxEAAuAAAADQEA +AAkAAABIMRAALgAAAEABAAAJAAAASDEQAC4AAACtAAAABQAAAEgxEAAuAAAArAAAAAUAAABhc3Nl +cnRpb24gZmFpbGVkOiAhYnVmLmlzX2VtcHR5KCkAAABIMRAALgAAANwBAAAFAAAAYXNzZXJ0aW9u +IGZhaWxlZDogZC5tYW50IDwgKDEgPDwgNjEpSDEQAC4AAADdAQAABQAAAEgxEAAuAAAA3gEAAAUA +AAABAAAACgAAAGQAAADoAwAAECcAAKCGAQBAQg8AgJaYAADh9QUAypo7SDEQAC4AAAAzAgAAEQAA +AEgxEAAuAAAANgIAAAkAAABIMRAALgAAAGwCAAAJAAAASDEQAC4AAADjAgAAJgAAAEgxEAAuAAAA +7wIAACYAAABIMRAALgAAAMwCAAAmAAAAbGlicmFyeS9jb3JlL3NyYy9udW0vZmx0MmRlYy9tb2Qu +cnMAWDMQACMAAAC7AAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGJ1ZlswXSA+IGInMCcAWDMQACMA +AAC8AAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IHBhcnRzLmxlbigpID49IDQAAFgzEAAjAAAAvQAA +AAUAAAAuMC4tK05hTmluZjBhc3NlcnRpb24gZmFpbGVkOiBidWYubGVuKCkgPj0gbWF4bGVuAAAA +WDMQACMAAAB+AgAADQAAACkuLjAxMjM0NTY3ODlhYmNkZWZCb3Jyb3dNdXRFcnJvcmFscmVhZHkg +Ym9ycm93ZWQ6IABVNBAAEgAAAGNhbGxlZCBgT3B0aW9uOjp1bndyYXAoKWAgb24gYSBgTm9uZWAg +dmFsdWVpbmRleCBvdXQgb2YgYm91bmRzOiB0aGUgbGVuIGlzICBidXQgdGhlIGluZGV4IGlzIAAA +AJs0EAAgAAAAuzQQABIAAAAAAAAABAAAAAQAAABkAAAAPT0hPW1hdGNoZXNhc3NlcnRpb24gYGxl +ZnQgIHJpZ2h0YCBmYWlsZWQKICBsZWZ0OiAKIHJpZ2h0OiAA+zQQABAAAAALNRAAFwAAACI1EAAJ +AAAAIHJpZ2h0YCBmYWlsZWQ6IAogIGxlZnQ6IAAAAPs0EAAQAAAARDUQABAAAABUNRAACQAAACI1 +EAAJAAAAOiAAAAEAAAAAAAAAgDUQAAIAAAAAAAAADAAAAAQAAABlAAAAZgAAAGcAAAAgICAgLAoo +KAosMHgwMDAxMDIwMzA0MDUwNjA3MDgwOTEwMTExMjEzMTQxNTE2MTcxODE5MjAyMTIyMjMyNDI1 +MjYyNzI4MjkzMDMxMzIzMzM0MzUzNjM3MzgzOTQwNDE0MjQzNDQ0NTQ2NDc0ODQ5NTA1MTUyNTM1 +NDU1NTY1NzU4NTk2MDYxNjI2MzY0NjU2NjY3Njg2OTcwNzE3MjczNzQ3NTc2Nzc3ODc5ODA4MTgy +ODM4NDg1ODY4Nzg4ODk5MDkxOTI5Mzk0OTU5Njk3OTg5OTAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw +MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDBsaWJyYXJ5L2NvcmUvc3Jj +L2ZtdC9tb2QucnNmYWxzZXRydWXANhAAGwAAANgKAAAmAAAAwDYQABsAAADhCgAAGgAAAGxpYnJh +cnkvY29yZS9zcmMvc3RyL21vZC5yc1suLi5dYmVnaW4gPD0gZW5kICggPD0gKSB3aGVuIHNsaWNp +bmcgYGAAJDcQAA4AAAAyNxAABAAAADY3EAAQAAAARjcQAAEAAABieXRlIGluZGV4ICBpcyBub3Qg +YSBjaGFyIGJvdW5kYXJ5OyBpdCBpcyBpbnNpZGUgIChieXRlcyApIG9mIGAAaDcQAAsAAABzNxAA +JgAAAJk3EAAIAAAAoTcQAAYAAABGNxAAAQAAACBpcyBvdXQgb2YgYm91bmRzIG9mIGAAAGg3EAAL +AAAA0DcQABYAAABGNxAAAQAAAAQ3EAAbAAAAnAEAACwAAABsaWJyYXJ5L2NvcmUvc3JjL3VuaWNv +ZGUvcHJpbnRhYmxlLnJzAAAAEDgQACUAAAAaAAAANgAAABA4EAAlAAAACgAAACsAAAAABgEBAwEE +AgUHBwIICAkCCgULAg4EEAERAhIFExwUARUCFwIZDRwFHQgfASQBagRrAq8DsQK8As8C0QLUDNUJ +1gLXAtoB4AXhAucE6ALuIPAE+AL6BPsBDCc7Pk5Pj56en3uLk5aisrqGsQYHCTY9Plbz0NEEFBg2 +N1ZXf6qur7014BKHiY6eBA0OERIpMTQ6RUZJSk5PZGWKjI2PtsHDxMbL1ly2txscBwgKCxQXNjk6 +qKnY2Qk3kJGoBwo7PmZpj5IRb1+/7u9aYvT8/1NUmpsuLycoVZ2goaOkp6iturzEBgsMFR06P0VR +pqfMzaAHGRoiJT4/5+zv/8XGBCAjJSYoMzg6SEpMUFNVVlhaXF5gY2Vma3N4fX+KpKqvsMDQrq9u +b93ek14iewUDBC0DZgMBLy6Agh0DMQ8cBCQJHgUrBUQEDiqAqgYkBCQEKAg0C04DNAyBNwkWCggY +O0U5A2MICTAWBSEDGwUBQDgESwUvBAoHCQdAICcEDAk2AzoFGgcEDAdQSTczDTMHLggKBiYDHQgC +gNBSEAM3LAgqFhomHBQXCU4EJAlEDRkHCgZICCcJdQtCPioGOwUKBlEGAQUQAwULWQgCHWIeSAgK +gKZeIkULCgYNEzoGCgYUHCwEF4C5PGRTDEgJCkZFG0gIUw1JBwqAtiIOCgZGCh0DR0k3Aw4ICgY5 +BwqBNhkHOwMdVQEPMg2Dm2Z1C4DEikxjDYQwEBYKj5sFgkeauTqGxoI5ByoEXAYmCkYKKAUTgbA6 +gMZbZUsEOQcRQAULAg6X+AiE1ikKoueBMw8BHQYOBAiBjIkEawUNAwkHEI9ggPoGgbRMRwl0PID2 +CnMIcBVGehQMFAxXCRmAh4FHA4VCDxWEUB8GBoDVKwU+IQFwLQMaBAKBQB8ROgUBgdAqgNYrBAGB +4ID3KUwECgQCgxFETD2AwjwGAQRVBRs0AoEOLARkDFYKgK44HQ0sBAkHAg4GgJqD2AQRAw0DdwRf +BgwEAQ8MBDgICgYoCCwEAj6BVAwdAwoFOAccBgkHgPqEBgABAwUFBgYCBwYIBwkRChwLGQwaDRAO +DA8EEAMSEhMJFgEXBBgBGQMaBxsBHAIfFiADKwMtCy4BMAQxAjIBpwSpAqoEqwj6AvsF/QL+A/8J +rXh5i42iMFdYi4yQHN0OD0tM+/wuLz9cXV/ihI2OkZKpsbq7xcbJyt7k5f8ABBESKTE0Nzo7PUlK +XYSOkqmxtLq7xsrOz+TlAAQNDhESKTE0OjtFRklKXmRlhJGbncnOzw0RKTo7RUlXW1xeX2RljZGp +tLq7xcnf5OXwDRFFSWRlgISyvL6/1dfw8YOFi6Smvr/Fx8/a20iYvc3Gzs9JTk9XWV5fiY6Psba3 +v8HGx9cRFhdbXPb3/v+AbXHe3w4fbm8cHV99fq6vTbu8FhceH0ZHTk9YWlxefn+1xdTV3PDx9XJz +j3R1liYuL6evt7/Hz9ffmgBAl5gwjx/Oz9LUzv9OT1pbBwgPECcv7u9ubzc9P0JFkJFTZ3XIydDR +2Nnn/v8AIF8igt8EgkQIGwQGEYGsDoCrBR8IgRwDGQgBBC8ENAQHAwEHBgcRClAPEgdVBwMEHAoJ +AwgDBwMCAwMDDAQFAwsGAQ4VBU4HGwdXBwIGFwxQBEMDLQMBBBEGDww6BB0lXyBtBGolgMgFgrAD +GgaC/QNZBxYJGAkUDBQMagYKBhoGWQcrBUYKLAQMBAEDMQssBBoGCwOArAYKBi8xgPQIPAMPAz4F +OAgrBYL/ERgILxEtAyEPIQ+AjASCmhYLFYiUBS8FOwcCDhgJgL4idAyA1hqBEAWA4QnyngM3CYFc +FIC4CIDdFTsDCgY4CEYIDAZ0Cx4DWgRZCYCDGBwKFglMBICKBqukDBcEMaEEgdomBwwFBYCmEIH1 +BwEgKgZMBICNBIC+AxsDDw1saWJyYXJ5L2NvcmUvc3JjL3VuaWNvZGUvdW5pY29kZV9kYXRhLnJz +AAAAAT4QACgAAABNAAAAKAAAAAE+EAAoAAAAWQAAABYAAABsaWJyYXJ5L2NvcmUvc3JjL251bS9i +aWdudW0ucnMAAEw+EAAeAAAAqwEAAAEAAABhc3NlcnRpb24gZmFpbGVkOiBub2JvcnJvd2Fzc2Vy +dGlvbiBmYWlsZWQ6IGRpZ2l0cyA8IDQwYXNzZXJ0aW9uIGZhaWxlZDogb3RoZXIgPiAwYXR0ZW1w +dCB0byBkaXZpZGUgYnkgemVybwDOPhAAGQAAAGF0dGVtcHQgdG8gY2FsY3VsYXRlIHRoZSByZW1h +aW5kZXIgd2l0aCBhIGRpdmlzb3Igb2YgemVybwAAAPA+EAA5AAAAcmFuZ2Ugc3RhcnQgaW5kZXgg +IG91dCBvZiByYW5nZSBmb3Igc2xpY2Ugb2YgbGVuZ3RoIDQ/EAASAAAARj8QACIAAAByYW5nZSBl +bmQgaW5kZXggeD8QABAAAABGPxAAIgAAAHNsaWNlIGluZGV4IHN0YXJ0cyBhdCAgYnV0IGVuZHMg +YXQgAJg/EAAWAAAArj8QAA0AAABjb3B5X2Zyb21fc2xpY2U6IHNvdXJjZSBzbGljZSBsZW5ndGgg +KCkgZG9lcyBub3QgbWF0Y2ggZGVzdGluYXRpb24gc2xpY2UgbGVuZ3RoICgAAADMPxAAJgAAAPI/ +EAArAAAANDQQAAEAAAAAAwAAgwQgAJEFYABdE6AAEhcgHwwgYB/vLCArKjCgK2+mYCwCqOAsHvvg +LQD+IDae/2A2/QHhNgEKITckDeE3qw5hOS8Y4TkwHOFK8x7hTkA0oVIeYeFT8GphVE9v4VSdvGFV +AM9hVmXRoVYA2iFXAOChWK7iIVrs5OFb0OhhXCAA7lzwAX9d8DQQAPI0EAD0NBAAAgAAAAIAAAAH +AEHwgcEACwFHAHAJcHJvZHVjZXJzAghsYW5ndWFnZQEEUnVzdAAMcHJvY2Vzc2VkLWJ5AwVydXN0 +Yx0xLjg3LjAgKDE3MDY3ZTlhYyAyMDI1LTA1LTA5KQZ3YWxydXMGMC4yMy4zDHdhc20tYmluZGdl +bgcwLjIuMTAwAGsPdGFyZ2V0X2ZlYXR1cmVzBisPbXV0YWJsZS1nbG9iYWxzKxNub250cmFwcGlu +Zy1mcHRvaW50KwtidWxrLW1lbW9yeSsIc2lnbi1leHQrD3JlZmVyZW5jZS10eXBlcysKbXVsdGl2 +YWx1ZQ== `) .trim() .replaceAll("\n", ""); From 2e276998b44f2113edaa0b54b789672cdba5084e Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Tue, 29 Jul 2025 13:47:59 +0200 Subject: [PATCH 21/43] global dedup! (just need hmac algorithm) --- packages/hub/src/utils/ChunkCache.ts | 27 ++++++- packages/hub/src/utils/createXorbs.ts | 64 ++++++++++++---- packages/hub/src/utils/shardParser.ts | 99 +++++++++++++++++++++++++ packages/hub/src/utils/uploadShards.ts | 94 +---------------------- packages/hub/src/utils/xetWriteToken.ts | 97 ++++++++++++++++++++++++ 5 files changed, 276 insertions(+), 105 deletions(-) create mode 100644 packages/hub/src/utils/shardParser.ts create mode 100644 packages/hub/src/utils/xetWriteToken.ts diff --git a/packages/hub/src/utils/ChunkCache.ts b/packages/hub/src/utils/ChunkCache.ts index 0596f9c27c..2418eb7388 100644 --- a/packages/hub/src/utils/ChunkCache.ts +++ b/packages/hub/src/utils/ChunkCache.ts @@ -9,9 +9,19 @@ export class ChunkCache { chunkOffsets = new Uint32Array(CHUNK_CACHE_INITIAL_SIZE); chunkEndOffsets = new Uint32Array(CHUNK_CACHE_INITIAL_SIZE); map = new Map(); // hash -> chunkCacheIndex. Less overhead that way, empty object is 60+B and empty array is 40+B + hmacs = new Set(); // todo : remove old hmacs - addChunkToCache(hash: string, xorbIndex: number, chunkOffset: number, chunkEndOffset: number): void { + addChunkToCache( + hash: string, + xorbIndex: number, + chunkOffset: number, + chunkEndOffset: number, + hmac: string | null + ): void { this.map.set(hash, this.index); + if (hmac !== null) { + this.hmacs.add(hmac); + } if (this.index >= this.xorbIndices.length) { // todo: switch to resize() with modern browsers @@ -50,7 +60,15 @@ export class ChunkCache { endOffset: number; } | undefined { - const index = this.map.get(hash); + let index = this.map.get(hash); + if (index === undefined) { + for (const hmac of this.hmacs) { + index = this.map.get(hashHash(hash, hmac)); + if (index !== undefined) { + break; + } + } + } if (index === undefined) { return undefined; } @@ -61,3 +79,8 @@ export class ChunkCache { }; } } + +// Todo: use wasm to hash +function hashHash(hash: string, hmac: string): string { + return hash + hmac; +} diff --git a/packages/hub/src/utils/createXorbs.ts b/packages/hub/src/utils/createXorbs.ts index 496a46df28..9f559b5fc3 100644 --- a/packages/hub/src/utils/createXorbs.ts +++ b/packages/hub/src/utils/createXorbs.ts @@ -7,15 +7,19 @@ import { bg4_split_bytes, XET_CHUNK_HEADER_BYTES, XetChunkCompressionScheme } from "./XetBlob"; import { compress as lz4_compress } from "../vendor/lz4js"; import { ChunkCache } from "./ChunkCache"; +import { xetWriteToken, type XetWriteTokenParams } from "./xetWriteToken"; +import { parseShardData } from "./shardParser"; const TARGET_CHUNK_SIZE = 64 * 1024; /* eslint-disable @typescript-eslint/no-unused-vars */ const MAX_CHUNK_SIZE = 2 * TARGET_CHUNK_SIZE; const XORB_SIZE = 64 * 1024 * 1024; const MAX_XORB_CHUNKS = 8 * 1024; +const INTERVAL_BETWEEN_REMOTE_DEDUP = 4_000_000; // 4MB export async function* createXorbs( - fileSources: AsyncGenerator<{ content: Blob; path: string; sha256: string }> + fileSources: AsyncGenerator<{ content: Blob; path: string; sha256: string }>, + params: XetWriteTokenParams ): AsyncGenerator< | { event: "xorb"; @@ -54,7 +58,13 @@ export async function* createXorbs( let xorb = new Uint8Array(XORB_SIZE); let xorbOffset = 0; let xorbChunks = Array<{ hash: string; length: number; offset: number }>(); - let xorbFiles: Record = {}; + /** + * path => 0..1 mapping + */ + let fileProgress: Record = {}; + + const remoteXorbHashes: string[] = [""]; // starts at index 1 (to simplify implem a bit) + let bytesSinceRemoteDedup = Infinity; try { for await (const fileSource of fileSources) { @@ -65,14 +75,14 @@ export async function* createXorbs( const fileChunks: Array<{ hash: string; length: number }> = []; let currentChunkRangeBeginning = 0; const fileRepresentation: Array<{ - xorbId: number; + xorbId: number | string; offset: number; endOffset: number; length: number; rangeHash: string; }> = []; - const addChunks = function* (chunks: Array<{ hash: string; length: number }>) { + const addChunks = async function* (chunks: Array<{ hash: string; length: number; dedup: boolean }>) { for (const chunk of chunks) { let chunkOffset = xorbOffset; let chunkEndOffset; @@ -99,7 +109,34 @@ export async function* createXorbs( sourceChunks.splice(0, index); } - const cacheData = chunkCache.getChunk(chunk.hash); + let cacheData = chunkCache.getChunk(chunk.hash); + if (cacheData === undefined && chunk.dedup && bytesSinceRemoteDedup >= INTERVAL_BETWEEN_REMOTE_DEDUP) { + const token = await xetWriteToken(params); + bytesSinceRemoteDedup = 0; + + const shardResp = await fetch(token.casUrl + "/v1/chunk/" + chunk.hash); + + // todo: handle non-404 non-429 errors, eg throw error + if (shardResp.ok) { + const shard = await shardResp.blob(); + const shardData = await parseShardData(shard); + + for (const xorb of shardData.xorbs) { + const remoteXorbId = -remoteXorbHashes.length; + remoteXorbHashes.push(xorb.hash); + for (const chunk of xorb.chunks) { + chunkCache.addChunkToCache( + chunk.hash, + remoteXorbId, + chunk.startOffset, + chunk.endOffset, + shardData.hmacKey + ); + } + } + } + cacheData = chunkCache.getChunk(chunk.hash); + } if (cacheData === undefined) { xorbOffset = writeChunk(xorb, xorbOffset, chunkToCopy); @@ -111,14 +148,14 @@ export async function* createXorbs( hash: chunkModule.compute_xorb_hash(xorbChunks), chunks: [...xorbChunks], id: xorbId, - files: Object.entries(xorbFiles).map(([path, progress]) => ({ path, progress })), + files: Object.entries(fileProgress).map(([path, progress]) => ({ path, progress })), }; xorbId++; xorb = new Uint8Array(XORB_SIZE); chunkOffset = 0; chunkXorbId = xorbId; xorbOffset = writeChunk(xorb, 0, chunkToCopy); - xorbFiles = {}; + fileProgress = {}; if (xorbOffset === 0) { throw new Error("Failed to write chunk into xorb"); @@ -127,18 +164,19 @@ export async function* createXorbs( chunkEndOffset = xorbOffset; - chunkCache.addChunkToCache(chunk.hash, xorbId, chunkOffset, chunkEndOffset); + chunkCache.addChunkToCache(chunk.hash, xorbId, chunkOffset, chunkEndOffset, null); } else { chunkXorbId = cacheData.xorbIndex; chunkOffset = cacheData.offset; chunkEndOffset = cacheData.endOffset; } + bytesSinceRemoteDedup += chunk.length; const lastRep = fileRepresentation.at(-1); if (!lastRep) { fileRepresentation.push({ - xorbId: chunkXorbId, + xorbId: chunkXorbId >= 0 ? chunkXorbId : remoteXorbHashes[-chunkXorbId], offset: chunkOffset, endOffset: chunkEndOffset, length: chunk.length, @@ -164,7 +202,7 @@ export async function* createXorbs( } } xorbChunks.push({ hash: chunk.hash, length: chunk.length, offset: chunkOffset }); - xorbFiles[fileSource.path] = processedBytes / fileSource.content.size; + fileProgress[fileSource.path] = processedBytes / fileSource.content.size; if (xorbChunks.length >= MAX_XORB_CHUNKS) { yield { event: "xorb" as const, @@ -172,12 +210,12 @@ export async function* createXorbs( hash: chunkModule.compute_xorb_hash(xorbChunks), chunks: [...xorbChunks], id: xorbId, - files: Object.entries(xorbFiles).map(([path, progress]) => ({ path, progress })), + files: Object.entries(fileProgress).map(([path, progress]) => ({ path, progress })), }; xorbId++; xorbOffset = 0; xorbChunks = []; - xorbFiles = {}; + fileProgress = {}; xorb = new Uint8Array(XORB_SIZE); } } @@ -217,7 +255,7 @@ export async function* createXorbs( hash: chunkModule.compute_xorb_hash(xorbChunks), chunks: [...xorbChunks], id: xorbId, - files: Object.entries(xorbFiles).map(([path, progress]) => ({ path, progress })), + files: Object.entries(fileProgress).map(([path, progress]) => ({ path, progress })), }; } } finally { diff --git a/packages/hub/src/utils/shardParser.ts b/packages/hub/src/utils/shardParser.ts new file mode 100644 index 0000000000..99fa584f33 --- /dev/null +++ b/packages/hub/src/utils/shardParser.ts @@ -0,0 +1,99 @@ +const SHARD_FOOTER_SIZE = 192; +const HASH_LENGTH = 32; +const XORB_FOOTER_LENGTH = 48; + +function readHashFromArray(array: Uint8Array, offset: number): string { + let hash = ""; + for (let i = 0; i < HASH_LENGTH; i++) { + hash += array[offset + i].toString(16).padStart(2, "0"); + } + return hash; +} + +export interface ShardData { + hmacKey: string; + xorbs: Array<{ + hash: string; + chunks: Array<{ + hash: string; + startOffset: number; + endOffset: number; + length: number; + }>; + }>; +} + +export async function parseShardData(shardBlob: Blob): Promise { + const shard = new Uint8Array(await shardBlob.arrayBuffer()); + const shardView = new DataView(shard.buffer); + + // Read footer to get section offsets + const footerStart = shard.length - SHARD_FOOTER_SIZE; + const xorbInfoStart = Number(shardView.getBigUint64(footerStart + 16, true)); + const fileLookupStart = Number(shardView.getBigUint64(footerStart + 24, true)); + + // Extract HMAC from footer (32 bytes starting at offset 112 from footer start) + const hmacKey = readHashFromArray(shard, footerStart + 112); + + // Parse XORB Info Section + const xorbs: ShardData["xorbs"] = []; + let offset = xorbInfoStart; + + while (offset < fileLookupStart - XORB_FOOTER_LENGTH) { + // Check if we've hit the xorb info bookend (32 bytes of 0xff) + if (shard[offset] === 0xff) { + break; + } + + // Read xorb entry + const xorbHash = readHashFromArray(shard, offset); + offset += HASH_LENGTH; + + // Skip flags (4 bytes) + offset += 4; + + const chunkCount = shardView.getUint32(offset, true); + offset += 4; + + // Skip unpackedSize (4 bytes) + offset += 4; + + // Skip packedSize (4 bytes) + offset += 4; + + // Read chunks for this xorb + const chunks: ShardData["xorbs"][0]["chunks"] = []; + for (let i = 0; i < chunkCount; i++) { + const chunkHash = readHashFromArray(shard, offset); + offset += HASH_LENGTH; + + const length = shardView.getUint32(offset, true); + offset += 4; + + const startOffset = shardView.getUint32(offset, true); + offset += 4; + + const endOffset = startOffset + length; + + // Skip reserved 8 bytes + offset += 8; + + chunks.push({ + hash: chunkHash, + startOffset, + endOffset, + length, + }); + } + + xorbs.push({ + hash: xorbHash, + chunks, + }); + } + + return { + hmacKey, + xorbs, + }; +} diff --git a/packages/hub/src/utils/uploadShards.ts b/packages/hub/src/utils/uploadShards.ts index 9a56b66ed4..f0c4a72458 100644 --- a/packages/hub/src/utils/uploadShards.ts +++ b/packages/hub/src/utils/uploadShards.ts @@ -2,6 +2,7 @@ import { createApiError } from "../error"; import type { RepoId } from "../types/public"; import { createXorbs } from "./createXorbs"; import { sum } from "./sum"; +import { xetWriteToken } from "./xetWriteToken"; const SHARD_MAX_SIZE = 64 * 1024 * 1024; const SHARD_HEADER_SIZE = 48; @@ -82,7 +83,7 @@ export async function* uploadShards( let fileTotalSize = 0n; let xorbTotalUnpackedSize = 0n; - for await (const output of createXorbs(source)) { + for await (const output of createXorbs(source, params)) { switch (output.event) { case "xorb": { xorbHashes.push(output.hash); @@ -341,7 +342,7 @@ function writeHashToArray(hash: string, array: Uint8Array, offset: number) { } async function uploadXorb(xorb: { hash: string; xorb: Uint8Array }, params: UploadShardsParams) { - const token = await getAccessToken(params); + const token = await xetWriteToken(params); const resp = await params.customFetch(`${token.casUrl}/v1/xorb/default/${xorb.hash}`, { method: "PUT", @@ -357,7 +358,7 @@ async function uploadXorb(xorb: { hash: string; xorb: Uint8Array }, params: Uplo } async function uploadShard(shard: Uint8Array, params: UploadShardsParams) { - const token = await getAccessToken(params); + const token = await xetWriteToken(params); const resp = await params.customFetch(`${token.casUrl}/v1/shard/default-merkledb`, { method: "PUT", @@ -371,90 +372,3 @@ async function uploadShard(shard: Uint8Array, params: UploadShardsParams) { throw await createApiError(resp); } } - -const JWT_SAFETY_PERIOD = 60_000; -const JWT_CACHE_SIZE = 1_000; - -function cacheKey(params: Omit): string { - return JSON.stringify([params.hubUrl, params.repo, params.rev, params.accessToken]); -} - -const jwtPromises: Map> = new Map(); -/** - * Cache to store JWTs, to avoid making many auth requests when downloading multiple files from the same repo - */ -const jwts: Map< - string, - { - accessToken: string; - expiresAt: Date; - casUrl: string; - } -> = new Map(); - -async function getAccessToken(params: UploadShardsParams): Promise<{ accessToken: string; casUrl: string }> { - const key = cacheKey(params); - - const jwt = jwts.get(key); - - if (jwt && jwt.expiresAt > new Date(Date.now() + JWT_SAFETY_PERIOD)) { - return { accessToken: jwt.accessToken, casUrl: jwt.casUrl }; - } - - // If we already have a promise for this repo, return it - const existingPromise = jwtPromises.get(key); - if (existingPromise) { - return existingPromise; - } - - const promise = (async () => { - const resp = await params.customFetch( - `${params.hubUrl}/api/${params.repo.type}s/${params.repo.name}/xet-write-token/${params.rev}`, - { - method: "POST", - headers: params.accessToken - ? { - Authorization: `Bearer ${params.accessToken}`, - } - : {}, - } - ); - - if (!resp.ok) { - throw await createApiError(resp); - } - - const json: { accessToken: string; casUrl: string; exp: number } = await resp.json(); - const jwt = { - accessToken: json.accessToken, - expiresAt: new Date(json.exp * 1000), - casUrl: json.casUrl, - }; - - jwtPromises.delete(key); - - for (const [key, value] of jwts.entries()) { - if (value.expiresAt < new Date(Date.now() + JWT_SAFETY_PERIOD)) { - jwts.delete(key); - } else { - break; - } - } - if (jwts.size >= JWT_CACHE_SIZE) { - const keyToDelete = jwts.keys().next().value; - if (keyToDelete) { - jwts.delete(keyToDelete); - } - } - jwts.set(key, jwt); - - return { - accessToken: json.accessToken, - casUrl: json.casUrl, - }; - })(); - - jwtPromises.set(key, promise); - - return promise; -} diff --git a/packages/hub/src/utils/xetWriteToken.ts b/packages/hub/src/utils/xetWriteToken.ts new file mode 100644 index 0000000000..db8077c5f4 --- /dev/null +++ b/packages/hub/src/utils/xetWriteToken.ts @@ -0,0 +1,97 @@ +import { createApiError } from "../error"; +import type { RepoId } from "../types/public"; + +export interface XetWriteTokenParams { + accessToken: string | undefined; + hubUrl: string; + customFetch: typeof fetch; + repo: RepoId; + rev: string; +} + +const JWT_SAFETY_PERIOD = 60_000; +const JWT_CACHE_SIZE = 1_000; + +function cacheKey(params: Omit): string { + return JSON.stringify([params.hubUrl, params.repo, params.rev, params.accessToken]); +} + +const jwtPromises: Map> = new Map(); +/** + * Cache to store JWTs, to avoid making many auth requests when downloading multiple files from the same repo + */ +const jwts: Map< + string, + { + accessToken: string; + expiresAt: Date; + casUrl: string; + } +> = new Map(); + +export async function xetWriteToken(params: XetWriteTokenParams): Promise<{ accessToken: string; casUrl: string }> { + const key = cacheKey(params); + + const jwt = jwts.get(key); + + if (jwt && jwt.expiresAt > new Date(Date.now() + JWT_SAFETY_PERIOD)) { + return { accessToken: jwt.accessToken, casUrl: jwt.casUrl }; + } + + // If we already have a promise for this repo, return it + const existingPromise = jwtPromises.get(key); + if (existingPromise) { + return existingPromise; + } + + const promise = (async () => { + const resp = await params.customFetch( + `${params.hubUrl}/api/${params.repo.type}s/${params.repo.name}/xet-write-token/${params.rev}`, + { + method: "POST", + headers: params.accessToken + ? { + Authorization: `Bearer ${params.accessToken}`, + } + : {}, + } + ); + + if (!resp.ok) { + throw await createApiError(resp); + } + + const json: { accessToken: string; casUrl: string; exp: number } = await resp.json(); + const jwt = { + accessToken: json.accessToken, + expiresAt: new Date(json.exp * 1000), + casUrl: json.casUrl, + }; + + jwtPromises.delete(key); + + for (const [key, value] of jwts.entries()) { + if (value.expiresAt < new Date(Date.now() + JWT_SAFETY_PERIOD)) { + jwts.delete(key); + } else { + break; + } + } + if (jwts.size >= JWT_CACHE_SIZE) { + const keyToDelete = jwts.keys().next().value; + if (keyToDelete) { + jwts.delete(keyToDelete); + } + } + jwts.set(key, jwt); + + return { + accessToken: json.accessToken, + casUrl: json.casUrl, + }; + })(); + + jwtPromises.set(key, promise); + + return promise; +} From 7c397dd96049179cb65e7ea4d91fbe889231e7dd Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Tue, 29 Jul 2025 14:10:10 +0200 Subject: [PATCH 22/43] delay file events until matching xorb is emitted --- packages/hub/src/utils/createXorbs.ts | 60 +++++++++++++++++++++------ 1 file changed, 47 insertions(+), 13 deletions(-) diff --git a/packages/hub/src/utils/createXorbs.ts b/packages/hub/src/utils/createXorbs.ts index 9f559b5fc3..3d38d03230 100644 --- a/packages/hub/src/utils/createXorbs.ts +++ b/packages/hub/src/utils/createXorbs.ts @@ -18,7 +18,7 @@ const MAX_XORB_CHUNKS = 8 * 1024; const INTERVAL_BETWEEN_REMOTE_DEDUP = 4_000_000; // 4MB export async function* createXorbs( - fileSources: AsyncGenerator<{ content: Blob; path: string; sha256: string }>, + fileSources: AsyncGenerator<{ content: Blob; path: string }>, params: XetWriteTokenParams ): AsyncGenerator< | { @@ -36,7 +36,6 @@ export async function* createXorbs( event: "file"; path: string; hash: string; - sha256: string; representation: Array<{ xorbId: number | string; // either xorb id (for local xorbs) or xorb hash (for remote xorbs) offset: number; @@ -59,9 +58,30 @@ export async function* createXorbs( let xorbOffset = 0; let xorbChunks = Array<{ hash: string; length: number; offset: number }>(); /** - * path => 0..1 mapping + * path => 0..1 mapping of the current xorb + * + * eg + * + * A => 1 + * B => 1 + * C => 0.345 + * + * If the xorb contains the end of file A, B, and up to 34.5% of file C */ - let fileProgress: Record = {}; + let xorbFileProgress: Record = {}; + + const pendingFileEvents: Array<{ + event: "file"; + path: string; + hash: string; + representation: Array<{ + xorbId: number | string; + offset: number; + endOffset: number; + length: number; + rangeHash: string; + }>; + }> = []; const remoteXorbHashes: string[] = [""]; // starts at index 1 (to simplify implem a bit) let bytesSinceRemoteDedup = Infinity; @@ -148,14 +168,20 @@ export async function* createXorbs( hash: chunkModule.compute_xorb_hash(xorbChunks), chunks: [...xorbChunks], id: xorbId, - files: Object.entries(fileProgress).map(([path, progress]) => ({ path, progress })), + files: Object.entries(xorbFileProgress).map(([path, progress]) => ({ path, progress })), }; xorbId++; xorb = new Uint8Array(XORB_SIZE); chunkOffset = 0; chunkXorbId = xorbId; + xorbFileProgress = {}; + + for (const event of pendingFileEvents) { + yield event; + } + pendingFileEvents.length = 0; + xorbOffset = writeChunk(xorb, 0, chunkToCopy); - fileProgress = {}; if (xorbOffset === 0) { throw new Error("Failed to write chunk into xorb"); @@ -202,7 +228,7 @@ export async function* createXorbs( } } xorbChunks.push({ hash: chunk.hash, length: chunk.length, offset: chunkOffset }); - fileProgress[fileSource.path] = processedBytes / fileSource.content.size; + xorbFileProgress[fileSource.path] = processedBytes / fileSource.content.size; if (xorbChunks.length >= MAX_XORB_CHUNKS) { yield { event: "xorb" as const, @@ -210,13 +236,18 @@ export async function* createXorbs( hash: chunkModule.compute_xorb_hash(xorbChunks), chunks: [...xorbChunks], id: xorbId, - files: Object.entries(fileProgress).map(([path, progress]) => ({ path, progress })), + files: Object.entries(xorbFileProgress).map(([path, progress]) => ({ path, progress })), }; xorbId++; xorbOffset = 0; xorbChunks = []; - fileProgress = {}; + xorbFileProgress = {}; xorb = new Uint8Array(XORB_SIZE); + + for (const event of pendingFileEvents) { + yield event; + } + pendingFileEvents.length = 0; } } }; @@ -239,13 +270,12 @@ export async function* createXorbs( ); } - yield { + pendingFileEvents.push({ event: "file" as const, path: fileSource.path, hash: chunkModule.compute_file_hash(fileChunks), representation: fileRepresentation, - sha256: fileSource.sha256, - }; + }); } if (xorbOffset > 0) { @@ -255,9 +285,13 @@ export async function* createXorbs( hash: chunkModule.compute_xorb_hash(xorbChunks), chunks: [...xorbChunks], id: xorbId, - files: Object.entries(fileProgress).map(([path, progress]) => ({ path, progress })), + files: Object.entries(xorbFileProgress).map(([path, progress]) => ({ path, progress })), }; } + + for (const event of pendingFileEvents) { + yield event; + } } finally { chunker.free(); // ^ is this really needed ? From 5f3a61b767d400f6ea234035c4faaea89019c63c Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Tue, 29 Jul 2025 17:07:28 +0200 Subject: [PATCH 23/43] add dedup ratio to information --- packages/hub/src/utils/createXorbs.ts | 10 +++++++++- 1 file changed, 9 insertions(+), 1 deletion(-) diff --git a/packages/hub/src/utils/createXorbs.ts b/packages/hub/src/utils/createXorbs.ts index 3d38d03230..c7f11a4b75 100644 --- a/packages/hub/src/utils/createXorbs.ts +++ b/packages/hub/src/utils/createXorbs.ts @@ -36,6 +36,8 @@ export async function* createXorbs( event: "file"; path: string; hash: string; + /** Percentage of file bytes that were deduplicated (0-1) */ + dedupRatio: number; representation: Array<{ xorbId: number | string; // either xorb id (for local xorbs) or xorb hash (for remote xorbs) offset: number; @@ -74,6 +76,7 @@ export async function* createXorbs( event: "file"; path: string; hash: string; + dedupRatio: number; representation: Array<{ xorbId: number | string; offset: number; @@ -84,14 +87,15 @@ export async function* createXorbs( }> = []; const remoteXorbHashes: string[] = [""]; // starts at index 1 (to simplify implem a bit) - let bytesSinceRemoteDedup = Infinity; try { for await (const fileSource of fileSources) { + let bytesSinceRemoteDedup = Infinity; const sourceChunks: Array = []; const reader = fileSource.content.stream().getReader(); let processedBytes = 0; + let dedupedBytes = 0; // Track bytes that were deduplicated const fileChunks: Array<{ hash: string; length: number }> = []; let currentChunkRangeBeginning = 0; const fileRepresentation: Array<{ @@ -195,6 +199,7 @@ export async function* createXorbs( chunkXorbId = cacheData.xorbIndex; chunkOffset = cacheData.offset; chunkEndOffset = cacheData.endOffset; + dedupedBytes += chunk.length; // Track deduplicated bytes } bytesSinceRemoteDedup += chunk.length; @@ -270,10 +275,13 @@ export async function* createXorbs( ); } + const dedupRatio = fileSource.content.size > 0 ? dedupedBytes / fileSource.content.size : 0; + pendingFileEvents.push({ event: "file" as const, path: fileSource.path, hash: chunkModule.compute_file_hash(fileChunks), + dedupRatio, representation: fileRepresentation, }); } From 66299a36ba16dfaf1fd34f0cd1c114a603deea6b Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Tue, 29 Jul 2025 17:09:52 +0200 Subject: [PATCH 24/43] fixup! add dedup ratio to information --- packages/hub/src/utils/createXorbs.ts | 5 ++++- packages/hub/src/utils/uploadShards.ts | 5 +++-- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/packages/hub/src/utils/createXorbs.ts b/packages/hub/src/utils/createXorbs.ts index c7f11a4b75..0875cfeb47 100644 --- a/packages/hub/src/utils/createXorbs.ts +++ b/packages/hub/src/utils/createXorbs.ts @@ -18,7 +18,7 @@ const MAX_XORB_CHUNKS = 8 * 1024; const INTERVAL_BETWEEN_REMOTE_DEDUP = 4_000_000; // 4MB export async function* createXorbs( - fileSources: AsyncGenerator<{ content: Blob; path: string }>, + fileSources: AsyncGenerator<{ content: Blob; path: string; sha256: string }>, params: XetWriteTokenParams ): AsyncGenerator< | { @@ -36,6 +36,7 @@ export async function* createXorbs( event: "file"; path: string; hash: string; + sha256: string; /** Percentage of file bytes that were deduplicated (0-1) */ dedupRatio: number; representation: Array<{ @@ -77,6 +78,7 @@ export async function* createXorbs( path: string; hash: string; dedupRatio: number; + sha256: string; representation: Array<{ xorbId: number | string; offset: number; @@ -281,6 +283,7 @@ export async function* createXorbs( event: "file" as const, path: fileSource.path, hash: chunkModule.compute_file_hash(fileChunks), + sha256: fileSource.sha256, dedupRatio, representation: fileRepresentation, }); diff --git a/packages/hub/src/utils/uploadShards.ts b/packages/hub/src/utils/uploadShards.ts index f0c4a72458..d15f865e45 100644 --- a/packages/hub/src/utils/uploadShards.ts +++ b/packages/hub/src/utils/uploadShards.ts @@ -68,7 +68,8 @@ export async function* uploadShards( source: AsyncGenerator<{ content: Blob; path: string; sha256: string }>, params: UploadShardsParams ): AsyncGenerator< - { event: "file"; path: string; sha256: string } | { event: "fileProgress"; path: string; progress: number } + | { event: "file"; path: string; sha256: string; dedupRatio: number } + | { event: "fileProgress"; path: string; progress: number } > { const xorbHashes: Array = []; @@ -136,7 +137,7 @@ export async function* uploadShards( break; } case "file": { - yield { event: "file", path: output.path, sha256: output.sha256 }; // Maybe wait until shard is uploaded before yielding. + yield { event: "file", path: output.path, sha256: output.sha256, dedupRatio: output.dedupRatio }; // Maybe wait until shard is uploaded before yielding. // Calculate space needed for this file entry const fileHeaderSize = HASH_LENGTH + 4 + 4 + 8; // hash + flags + rep length + reserved From 988d85b8d8db55f07ebcbe37c2a61d4f1b5845a5 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Tue, 29 Jul 2025 21:02:43 +0200 Subject: [PATCH 25/43] use hmac function from wasm --- packages/hub/package.json | 2 +- packages/hub/src/utils/ChunkCache.ts | 12 +- packages/hub/src/utils/createXorbs.ts | 4 +- .../hub/src/vendor/xet-chunk/chunker_wasm.ts | 8 +- .../src/vendor/xet-chunk/chunker_wasm_bg.d.ts | 1 + .../src/vendor/xet-chunk/chunker_wasm_bg.js | 29 + .../xet-chunk/chunker_wasm_bg.wasm.base64.ts | 3526 +++++++++-------- .../xet-chunk/chunker_wasm_bg.wasm.d.ts | 1 + 8 files changed, 1816 insertions(+), 1767 deletions(-) diff --git a/packages/hub/package.json b/packages/hub/package.json index 1f5de298d2..4520cbc402 100644 --- a/packages/hub/package.json +++ b/packages/hub/package.json @@ -42,7 +42,7 @@ "test": "vitest run", "test:browser": "vitest run --browser.name=chrome --browser.headless --config vitest-browser.config.mts", "check": "tsc", - "build:xet-wasm": "./scripts/build-xet-wasm.sh -t bundler --clean" + "build:xet-wasm": "./scripts/build-xet-wasm.sh -t bundler --clean -b hmac-wasm" }, "files": [ "src", diff --git a/packages/hub/src/utils/ChunkCache.ts b/packages/hub/src/utils/ChunkCache.ts index 2418eb7388..0fe6d492a5 100644 --- a/packages/hub/src/utils/ChunkCache.ts +++ b/packages/hub/src/utils/ChunkCache.ts @@ -53,7 +53,10 @@ export class ChunkCache { } } - getChunk(hash: string): + getChunk( + hash: string, + hmacFunction: (hash: string, key: string) => string + ): | { xorbIndex: number; offset: number; @@ -63,7 +66,7 @@ export class ChunkCache { let index = this.map.get(hash); if (index === undefined) { for (const hmac of this.hmacs) { - index = this.map.get(hashHash(hash, hmac)); + index = this.map.get(hmacFunction(hash, hmac)); if (index !== undefined) { break; } @@ -79,8 +82,3 @@ export class ChunkCache { }; } } - -// Todo: use wasm to hash -function hashHash(hash: string, hmac: string): string { - return hash + hmac; -} diff --git a/packages/hub/src/utils/createXorbs.ts b/packages/hub/src/utils/createXorbs.ts index 0875cfeb47..6a70cc540f 100644 --- a/packages/hub/src/utils/createXorbs.ts +++ b/packages/hub/src/utils/createXorbs.ts @@ -135,7 +135,7 @@ export async function* createXorbs( sourceChunks.splice(0, index); } - let cacheData = chunkCache.getChunk(chunk.hash); + let cacheData = chunkCache.getChunk(chunk.hash, chunkModule.compute_hmac); if (cacheData === undefined && chunk.dedup && bytesSinceRemoteDedup >= INTERVAL_BETWEEN_REMOTE_DEDUP) { const token = await xetWriteToken(params); bytesSinceRemoteDedup = 0; @@ -160,8 +160,8 @@ export async function* createXorbs( ); } } + cacheData = chunkCache.getChunk(chunk.hash, chunkModule.compute_hmac); } - cacheData = chunkCache.getChunk(chunk.hash); } if (cacheData === undefined) { xorbOffset = writeChunk(xorb, xorbOffset, chunkToCopy); diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts b/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts index 4f5419f599..39d4ed87cf 100644 --- a/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts @@ -55,7 +55,13 @@ init(); export { init }; -export { compute_xorb_hash, compute_file_hash, Chunker, compute_verification_hash } from "./chunker_wasm_bg.js"; +export { + compute_xorb_hash, + compute_file_hash, + Chunker, + compute_verification_hash, + compute_hmac, +} from "./chunker_wasm_bg.js"; // const exports = WebAssembly.Module.exports(wasmModule).map((item) => item.name); diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts index bf8e8bded7..52c6d5edaf 100644 --- a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts @@ -3,6 +3,7 @@ export function compute_xorb_hash(chunks_array: Array<{ hash: string; length: number }>): string; export function compute_verification_hash(chunkHashes: string[]): string; export function compute_file_hash(chunks_array: Array<{ hash: string; length: number }>): string; +export function compute_hmac(hash: string, key: string): string; export class Chunker { free(): void; constructor(target_chunk_size: number); diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.js b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.js index 62f45fd1d9..0f20569017 100644 --- a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.js +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.js @@ -272,6 +272,35 @@ export function compute_verification_hash(chunk_hashes) { } } +/** + * takes a hash and HMAC key (both as hex strings) and returns the HMAC result as a hex string + * @param {string} hash_hex + * @param {string} hmac_key_hex + * @returns {string} + */ +export function compute_hmac(hash_hex, hmac_key_hex) { + let deferred4_0; + let deferred4_1; + try { + const ptr0 = passStringToWasm0(hash_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len0 = WASM_VECTOR_LEN; + const ptr1 = passStringToWasm0(hmac_key_hex, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + const ret = wasm.compute_hmac(ptr0, len0, ptr1, len1); + var ptr3 = ret[0]; + var len3 = ret[1]; + if (ret[3]) { + ptr3 = 0; len3 = 0; + throw takeFromExternrefTable0(ret[2]); + } + deferred4_0 = ptr3; + deferred4_1 = len3; + return getStringFromWasm0(ptr3, len3); + } finally { + wasm.__wbindgen_free(deferred4_0, deferred4_1, 1); + } +} + const ChunkerFinalization = (typeof FinalizationRegistry === 'undefined') ? { register: () => {}, unregister: () => {} } : new FinalizationRegistry(ptr => wasm.__wbg_chunker_free(ptr >>> 0, 1)); diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts index 8dfc87e9f3..98a1f0d130 100644 --- a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts @@ -1,1768 +1,1782 @@ // Generated by build-xet-wasm.sh export const wasmBase64 = atob(` -AGFzbQEAAAABtQItYAJ/fwF/YAN/f38Bf2ACf38AYAN/f38AYAR/f39/AGABfwF/YAF/AGABbwF/ -YAV/f39/fwBgAAR/f39/YAFvAW9gAn9vAGAAAW9gAABgBn9/f39/fwBgBH9/f38Bf2AAA39/f2AC +AGFzbQEAAAABwAIuYAJ/fwF/YAN/f38Bf2ACf38AYAN/f38AYAR/f39/AGABfwBgAW8Bf2ABfwF/ +YAAEf39/f2AFf39/f38AYAFvAW9gAn9vAGAAAW9gAABgBn9/f39/fwBgBH9/f38Bf2AAA39/f2AC b28Bb2AGf39/f39/AX9gBX9/f39/AX9gAn9/AW9gAm9vAX9gAAF/YAFvBH9/f39gAW8BfGABfAFv YANvb28AYAJvfwFvYANvf28AYANvb38AYAV/f39+fwBgB39/f35/f38Bf2AJf39/f39/fn5+AGAD -fn9/AX9gB39/f39/f38Bf2ACf38Ef39/f2ADf39/A39/f2ABfwN/f39gBX9/fX9/AGAEf31/fwBg -BX9/fH9/AGAEf3x/fwBgBX9/fn9/AGAEf35/fwBgAn9+AX4C9RAoGC4vaGZfeGV0X3RoaW5fd2Fz -bV9iZy5qcxpfX3diZ19sb2dfYzVkMWE4ZGMwOTgyMTJhZgACGC4vaGZfeGV0X3RoaW5fd2FzbV9i -Zy5qcxVfX3diaW5kZ2VuX3N0cmluZ19uZXcAFBguL2hmX3hldF90aGluX3dhc21fYmcuanMVX193 -YmluZGdlbl9zdHJpbmdfZ2V0AAsYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzFF9fd2JpbmRnZW5f -aXNfb2JqZWN0AAcYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzF19fd2JpbmRnZW5faXNfdW5kZWZp -bmVkAAcYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzDV9fd2JpbmRnZW5faW4AFRguL2hmX3hldF90 -aGluX3dhc21fYmcuanMUX193YmluZGdlbl9lcnJvcl9uZXcAFBguL2hmX3hldF90aGluX3dhc21f -YmcuanMZX193YmluZGdlbl9qc3ZhbF9sb29zZV9lcQAVGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5q -cxZfX3diaW5kZ2VuX2Jvb2xlYW5fZ2V0AAcYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzFV9fd2Jp -bmRnZW5fbnVtYmVyX2dldAALGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxRfX3diaW5kZ2VuX2Fz -X251bWJlcgAYGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcx1fX3diZ19TdHJpbmdfOGYwZWIzOWE0 -YTRjMmY2NgALGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxVfX3diaW5kZ2VuX251bWJlcl9uZXcA -GRguL2hmX3hldF90aGluX3dhc21fYmcuanMkX193YmdfZ2V0d2l0aHJlZmtleV8xZGMzNjFiZDEw -MDUzYmZlABEYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX3NldF8zZjFkMGI5ODRlZDI3 -MmVkABoYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX2dldF9iOWI5MzA0N2ZlM2NmNDVi -ABsYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzHV9fd2JnX2xlbmd0aF9lMmQyYTQ5MTMyYzFiMjU2 -AAcYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX25ld183OGZlYjEwOGI2NDcyNzEzAAwY -Li9oZl94ZXRfdGhpbl93YXNtX2JnLmpzFl9fd2JpbmRnZW5faXNfZnVuY3Rpb24ABxguL2hmX3hl -dF90aGluX3dhc21fYmcuanMbX193YmdfbmV4dF8yNWZlYWRmYzA5MTNmZWE5AAoYLi9oZl94ZXRf -dGhpbl93YXNtX2JnLmpzG19fd2JnX25leHRfNjU3NGUxYThhNjJkMTA1NQAKGC4vaGZfeGV0X3Ro -aW5fd2FzbV9iZy5qcxtfX3diZ19kb25lXzc2OWU1ZWRlNGIzMWM2N2IABxguL2hmX3hldF90aGlu -X3dhc21fYmcuanMcX193YmdfdmFsdWVfY2QxZmZhN2IxYWI3OTRmMQAKGC4vaGZfeGV0X3RoaW5f -d2FzbV9iZy5qcx9fX3diZ19pdGVyYXRvcl85YTI0Yzg4ZGY4NjBkYzY1AAwYLi9oZl94ZXRfdGhp -bl93YXNtX2JnLmpzGl9fd2JnX2dldF82N2IyYmE2MmZjMzBkZTEyABEYLi9oZl94ZXRfdGhpbl93 -YXNtX2JnLmpzG19fd2JnX2NhbGxfNjcyYTRkMjE2MzRkNGEyNAARGC4vaGZfeGV0X3RoaW5fd2Fz -bV9iZy5qcxpfX3diZ19uZXdfNDA1ZTIyZjM5MDU3NmNlMgAMGC4vaGZfeGV0X3RoaW5fd2FzbV9i -Zy5qcxpfX3diZ19zZXRfMzc4MzcwMjNmM2Q3NDBlOAAcGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5q -cx5fX3diZ19pc0FycmF5X2ExZWFiN2UwZDA2NzM5MWIABxguL2hmX3hldF90aGluX3dhc21fYmcu -anMtX193YmdfaW5zdGFuY2VvZl9BcnJheUJ1ZmZlcl9lMTQ1ODU0MzJlMzczN2ZjAAcYLi9oZl94 -ZXRfdGhpbl93YXNtX2JnLmpzJF9fd2JnX2lzU2FmZUludGVnZXJfMzQzZTJiZWVlZWNlMWJiMAAH -GC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcx1fX3diZ19idWZmZXJfNjA5Y2MzZWVlNTFlZDE1OAAK -GC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxpfX3diZ19uZXdfYTEyMDAyYTdmOTFjNzViZQAKGC4v -aGZfeGV0X3RoaW5fd2FzbV9iZy5qcxpfX3diZ19zZXRfNjU1OTViZGQ4NjhiMzAwOQAdGC4vaGZf -eGV0X3RoaW5fd2FzbV9iZy5qcx1fX3diZ19sZW5ndGhfYTQ0NjE5M2RjMjJjMTJmOAAHGC4vaGZf -eGV0X3RoaW5fd2FzbV9iZy5qcyxfX3diZ19pbnN0YW5jZW9mX1VpbnQ4QXJyYXlfMTcxNTZiY2Yx -MTgwODZhOQAHGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxdfX3diaW5kZ2VuX2RlYnVnX3N0cmlu -ZwALGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxBfX3diaW5kZ2VuX3Rocm93AAIYLi9oZl94ZXRf -dGhpbl93YXNtX2JnLmpzEV9fd2JpbmRnZW5fbWVtb3J5AAwYLi9oZl94ZXRfdGhpbl93YXNtX2Jn -LmpzH19fd2JpbmRnZW5faW5pdF9leHRlcm5yZWZfdGFibGUADQPQAc4BHgUfAgIAAgIAAwgDBAMS -AwAGAQABAAEAARIBBAIgAQIAIQMFAAIAAA4OIgAAAhYIAwACBAAEBAMDDwEFAgAIAgMGAgIDBg4D -Fg4CAAQCAgADAAQCAAgDAQMEAgUAAAAEBAAEAQEGBA0BAAAGAgADBAIAEwAGIyQXFwIlDxIFAAgT -JigqBgQAAQQsAAYDAwAGAAAFDwUDAAEACAAABAQAAAYCAgIAAAACAwMFAwMDAAYAAAAAAAAAAAAA -AA0NAgACAAACAAECAAACBQUFBQMECQJwAWhobwCAAQUDAQARBgkBfwFBgIDAAAsHzwIQBm1lbW9y -eQIAEl9fd2JnX2NodW5rZXJfZnJlZQBqC2NodW5rZXJfbmV3AEsQY2h1bmtlcl9hZGRfZGF0YQCe -AQ5jaHVua2VyX2ZpbmlzaACiARFjb21wdXRlX3hvcmJfaGFzaACfARFjb21wdXRlX2ZpbGVfaGFz -aACgARljb21wdXRlX3ZlcmlmaWNhdGlvbl9oYXNoAJ0BEV9fd2JpbmRnZW5fbWFsbG9jAJsBEl9f -d2JpbmRnZW5fcmVhbGxvYwCjARRfX3diaW5kZ2VuX2V4bl9zdG9yZQDIARdfX2V4dGVybnJlZl90 -YWJsZV9hbGxvYwBwE19fd2JpbmRnZW5fZXhwb3J0XzQBARlfX2V4dGVybnJlZl90YWJsZV9kZWFs -bG9jAG0PX193YmluZGdlbl9mcmVlAL0BEF9fd2JpbmRnZW5fc3RhcnQAJwm8AQEAQQELZ9wB3QGE -AbMBiwFO3wHZAd4B7wHuAdsB2gHAATjCAeABswGLAU/AAXOZAagBcacBqAGkAa8BrQGnAacBqQGq -AasBsAGBAXr0AfUBhwGKAV2lAWyIAY4BXm/hAZcBxAHFAdIBfnnGAcIBiQGuAdgBpgFlWccBlQFi -sgHiAcYBtwHWAYIBswGMAVTmAcoByQHMAZQBywHnAawBfFpr8AGzAZABU+gB6QG+AcABzQHOATt3 -XD6SAesBDAEOCv/zBM4BiRsBIH8gACAAKAIYIh0gASgAECIkIAAoAghqaiIbIAEoABQiFWogHSAb -IAJB/wFxc0EQdyICQfLmu+MDaiIdc0EUdyIbaiIiIAJzQRh3IgkgHWoiHCAbc0EZdyIPIAAoAhQi -GyABKAAIIgIgACgCBGpqIhkgASgADCIdaiAZIANCIIinc0EQdyIeQfui4aQEayIgIBtzQRR3IgZq -IgogASgAKCIbamoiIyABKAAsIhlqIA8gIyAAKAIQIiEgASgAACIPIAAoAgBqaiIIIAEoAAQiH2og -ISAIIAOnc0EQdyIhQefMp9AGaiIIc0EUdyIHaiIOICFzQRh3Ig1zQRB3IgsgACgCHCIFIAEoABgi -IyAAKAIMamoiDCABKAAcIiFqIAUgDCAEQf8BcXNBEHciBEHGlcDVBWsiBXNBFHciDGoiESAEc0EY -dyIQIAVqIgVqIhJzQRR3IhRqIhMgHWogBiAgIAogHnNBGHciIGoiBnNBGXciCiAOIAEoACAiBGpq -Ig4gASgAJCIeaiAKIBwgDiAQc0EQdyIcaiIKc0EUdyIOaiIQIBxzQRh3IhYgCmoiCiAOc0EZdyIc -aiIOIBtqIBwgDiAFIAxzQRl3IgUgIiABKAAwIhxqaiIMIAEoADQiImogDCAgc0EQdyIgIAggDWoi -CGoiDSAFc0EUdyIFaiIMICBzQRh3IhdzQRB3Ig4gByAIc0EZdyIIIBEgASgAOCIgamoiByABKAA8 -IgFqIAcgCXNBEHciCSAGaiIGIAhzQRR3IghqIgcgCXNBGHciCSAGaiIGaiIRc0EUdyIYaiIaIBxq -IAsgE3NBGHciCyASaiISIBRzQRl3IhQgDCAhamoiDCAPaiAJIAxzQRB3IgkgCmoiCiAUc0EUdyIM -aiIUIAlzQRh3IgkgCmoiCiAMc0EZdyIMaiITIBVqIAwgEyAGIAhzQRl3IgYgAiAQamoiCCAjaiAG -IAggC3NBEHciBiANIBdqIghqIg1zQRR3IgtqIgwgBnNBGHciBnNBEHciECAFIAhzQRl3IgggByAk -amoiByAiaiAIIAcgFnNBEHciCCASaiIHc0EUdyIFaiISIAhzQRh3IgggB2oiB2oiE3NBFHciFmoi -FyAbaiAOIBpzQRh3Ig4gEWoiESAYc0EZdyIYIAwgH2pqIgwgGWogCiAIIAxzQRB3IgpqIgggGHNB -FHciDGoiGCAKc0EYdyIKIAhqIgggDHNBGXciDGoiGiAcaiAMIBogBSAHc0EZdyIHIBQgHmpqIgUg -IGogByAFIA5zQRB3IgcgBiANaiIGaiIOc0EUdyINaiIFIAdzQRh3IgdzQRB3IgwgBiALc0EZdyIG -IAEgEmpqIgsgBGogBiAJIAtzQRB3IgkgEWoiBnNBFHciC2oiESAJc0EYdyIJIAZqIgZqIhJzQRR3 -IhRqIhogHmogECAXc0EYdyIQIBNqIhMgFnNBGXciFiAFICJqaiIFIAJqIAUgCXNBEHciCSAIaiII -IBZzQRR3IgVqIhYgCXNBGHciCSAIaiIIIAVzQRl3IgVqIhcgD2ogBSAXIAYgC3NBGXciBiAYIB1q -aiILICRqIAYgCyAQc0EQdyIGIAcgDmoiB2oiDnNBFHciC2oiBSAGc0EYdyIGc0EQdyIQIAcgDXNB -GXciByARICFqaiINICBqIAcgCiANc0EQdyIKIBNqIgdzQRR3Ig1qIhEgCnNBGHciCiAHaiIHaiIT -c0EUdyIXaiIYIBxqIAwgGnNBGHciDCASaiISIBRzQRl3IhQgBSAjamoiBSAVaiAFIApzQRB3Igog -CGoiCCAUc0EUdyIFaiIUIApzQRh3IgogCGoiCCAFc0EZdyIFaiIaIB5qIAUgGiAHIA1zQRl3Igcg -FiAZamoiDSABaiAHIAwgDXNBEHciByAGIA5qIgZqIg5zQRR3Ig1qIgUgB3NBGHciB3NBEHciDCAG -IAtzQRl3IgYgBCARamoiCyAfaiAGIAkgC3NBEHciCSASaiIGc0EUdyILaiIRIAlzQRh3IgkgBmoi -BmoiEnNBFHciFmoiGiAZaiAQIBhzQRh3IhAgE2oiEyAXc0EZdyIXIAUgIGpqIgUgHWogBSAJc0EQ -dyIJIAhqIgggF3NBFHciBWoiFyAJc0EYdyIJIAhqIgggBXNBGXciBWoiGCACaiAFIBggBiALc0EZ -dyIGIBQgG2pqIgsgIWogBiALIBBzQRB3IgYgByAOaiIHaiIOc0EUdyILaiIFIAZzQRh3IgZzQRB3 -IhAgByANc0EZdyIHIBEgImpqIg0gAWogByAKIA1zQRB3IgogE2oiB3NBFHciDWoiESAKc0EYdyIK -IAdqIgdqIhRzQRR3IhNqIhggHmogDCAac0EYdyIMIBJqIhIgFnNBGXciFiAFICRqaiIFIA9qIAUg -CnNBEHciCiAIaiIIIBZzQRR3IgVqIhYgCnNBGHciCiAIaiIIIAVzQRl3IgVqIhogGWogBSAaIAcg -DXNBGXciByAVIBdqaiINIARqIAcgDCANc0EQdyIHIAYgDmoiBmoiDnNBFHciDWoiBSAHc0EYdyIH -c0EQdyIMIAYgC3NBGXciBiARIB9qaiILICNqIAYgCSALc0EQdyIJIBJqIgZzQRR3IgtqIhEgCXNB -GHciCSAGaiIGaiISc0EUdyIXaiIaIBVqIBAgGHNBGHciECAUaiIUIBNzQRl3IhMgASAFamoiBSAb -aiAFIAlzQRB3IgkgCGoiCCATc0EUdyIFaiITIAlzQRh3IgkgCGoiCCAFc0EZdyIFaiIYIB1qIAUg -GCAGIAtzQRl3IgYgFiAcamoiCyAiaiAGIAsgEHNBEHciBiAHIA5qIgdqIg5zQRR3IgtqIgUgBnNB -GHciBnNBEHciECAHIA1zQRl3IgcgESAgamoiDSAEaiAHIAogDXNBEHciCiAUaiIHc0EUdyINaiIR -IApzQRh3IgogB2oiB2oiFHNBFHciFmoiGCAZaiAMIBpzQRh3IgwgEmoiEiAXc0EZdyIXIAUgIWpq -IgUgAmogBSAKc0EQdyIKIAhqIgggF3NBFHciBWoiFyAKc0EYdyIKIAhqIgggBXNBGXciBWoiGiAV -aiAFIBogByANc0EZdyIHIA8gE2pqIg0gH2ogByAMIA1zQRB3IgcgBiAOaiIGaiIOc0EUdyINaiIF -IAdzQRh3IgdzQRB3IgwgBiALc0EZdyIGIBEgI2pqIgsgJGogBiAJIAtzQRB3IgkgEmoiBnNBFHci -C2oiESAJc0EYdyIJIAZqIgZqIhJzQRR3IhNqIhogD2ogECAYc0EYdyIQIBRqIhQgFnNBGXciFiAE -IAVqaiIFIBxqIAUgCXNBEHciCSAIaiIIIBZzQRR3IgVqIhYgCXNBGHciCSAIaiIIIAVzQRl3IgVq -IhggG2ogBSAYIAYgC3NBGXciBiAXIB5qaiILICBqIAYgCyAQc0EQdyIGIAcgDmoiB2oiDnNBFHci -C2oiBSAGc0EYdyIGc0EQdyIQIAcgDXNBGXciByABIBFqaiINIB9qIAcgCiANc0EQdyIKIBRqIgdz -QRR3Ig1qIhEgCnNBGHciCiAHaiIHaiIUc0EUdyIXaiIYIBVqIAwgGnNBGHciFSASaiIMIBNzQRl3 -IhIgBSAiamoiBSAdaiAFIApzQRB3IgogCGoiCCASc0EUdyIFaiISIApzQRh3IgogCGoiCCAFc0EZ -dyIFaiITIA9qIAUgEyAHIA1zQRl3Ig8gAiAWamoiByAjaiAPIAcgFXNBEHciFSAGIA5qIg9qIgZz -QRR3IgdqIg4gFXNBGHciFXNBEHciDSALIA9zQRl3Ig8gESAkamoiCyAhaiAPIAkgC3NBEHciDyAM -aiIJc0EUdyILaiIFIA9zQRh3Ig8gCWoiCWoiDHNBFHciEWoiEyACaiAeIBAgGHNBGHciAiAUaiIe -IBdzQRl3IhAgDiAfamoiH2ogDyAfc0EQdyIPIAhqIh8gEHNBFHciCGoiDiAPc0EYdyIPIB9qIh8g -CHNBGXciCGoiECAcaiAQIAEgCSALc0EZdyIBIBIgGWpqIhlqIAEgAiAZc0EQdyIBIAYgFWoiAmoi -FXNBFHciGWoiHCABc0EYdyIBc0EQdyIJIAIgB3NBGXciAiAEIAVqaiIEICNqIAIgBCAKc0EQdyIC -IB5qIgRzQRR3IiNqIh4gAnNBGHciAiAEaiIEaiIGIAhzQRR3IgpqIgggCXNBGHciCSAGaiIGIAEg -FWoiASAZc0EZdyIVIB4gIWpqIhkgImogFSAPIBlzQRB3IhUgDSATc0EYdyIZIAxqIg9qIiFzQRR3 -Ih5qIiJzNgIMIAAgGyAPIBFzQRl3Ig8gHCAgamoiHGogAiAcc0EQdyICIB9qIhsgD3NBFHciD2oi -HyACc0EYdyICIBtqIhsgJCAEICNzQRl3IgQgDiAdamoiHWogBCABIBkgHXNBEHciAWoiBHNBFHci -JGoiHXM2AgggACAVICJzQRh3IhUgIWoiGSAIczYCBCAAIAEgHXNBGHciASAEaiIEIB9zNgIAIAAg -BCAkc0EZdyACczYCHCAAIAYgCnNBGXcgFXM2AhggACAPIBtzQRl3IAFzNgIUIAAgGSAec0EZdyAJ -czYCEAubJAIJfwF+IwBBEGsiCCQAAn8CQAJAAkACQAJAAkAgAEH1AU8EQEEAIABBzP97Sw0HGiAA -QQtqIgFBeHEhBUGEhsEAKAIAIglFDQRBHyEHQQAgBWshBCAAQfT//wdNBEAgBUEGIAFBCHZnIgBr -dkEBcSAAQQF0a0E+aiEHCyAHQQJ0QeiCwQBqKAIAIgFFBEBBACEADAILQQAhACAFQRkgB0EBdmtB -ACAHQR9HG3QhAwNAAkAgASgCBEF4cSIGIAVJDQAgBiAFayIGIARPDQAgASECIAYiBA0AQQAhBCAB -IQAMBAsgASgCFCIGIAAgBiABIANBHXZBBHFqKAIQIgFHGyAAIAYbIQAgA0EBdCEDIAENAAsMAQtB -gIbBACgCACICQRAgAEELakH4A3EgAEELSRsiBUEDdiIAdiIBQQNxBEACQCABQX9zQQFxIABqIgZB -A3QiAEH4g8EAaiIDIABBgITBAGooAgAiASgCCCIERwRAIAQgAzYCDCADIAQ2AggMAQtBgIbBACAC -QX4gBndxNgIACyABIABBA3I2AgQgACABaiIAIAAoAgRBAXI2AgQgAUEIagwHCyAFQYiGwQAoAgBN -DQMCQAJAIAFFBEBBhIbBACgCACIARQ0GIABoQQJ0QeiCwQBqKAIAIgIoAgRBeHEgBWshBCACIQED -QAJAIAIoAhAiAA0AIAIoAhQiAA0AIAEoAhghBwJAAkAgASABKAIMIgBGBEAgAUEUQRAgASgCFCIA -G2ooAgAiAg0BQQAhAAwCCyABKAIIIgIgADYCDCAAIAI2AggMAQsgAUEUaiABQRBqIAAbIQMDQCAD -IQYgAiIAQRRqIABBEGogACgCFCICGyEDIABBFEEQIAIbaigCACICDQALIAZBADYCAAsgB0UNBAJA -IAEoAhxBAnRB6ILBAGoiAigCACABRwRAIAEgBygCEEcEQCAHIAA2AhQgAA0CDAcLIAcgADYCECAA -DQEMBgsgAiAANgIAIABFDQQLIAAgBzYCGCABKAIQIgIEQCAAIAI2AhAgAiAANgIYCyABKAIUIgJF -DQQgACACNgIUIAIgADYCGAwECyAAKAIEQXhxIAVrIgIgBCACIARJIgIbIQQgACABIAIbIQEgACEC -DAALAAsCQEECIAB0IgNBACADa3IgASAAdHFoIgZBA3QiAUH4g8EAaiIDIAFBgITBAGooAgAiACgC -CCIERwRAIAQgAzYCDCADIAQ2AggMAQtBgIbBACACQX4gBndxNgIACyAAIAVBA3I2AgQgACAFaiIG -IAEgBWsiA0EBcjYCBCAAIAFqIAM2AgBBiIbBACgCACIEBEAgBEF4cUH4g8EAaiEBQZCGwQAoAgAh -AgJ/QYCGwQAoAgAiBUEBIARBA3Z0IgRxRQRAQYCGwQAgBCAFcjYCACABDAELIAEoAggLIQQgASAC -NgIIIAQgAjYCDCACIAE2AgwgAiAENgIIC0GQhsEAIAY2AgBBiIbBACADNgIAIABBCGoMCAtBhIbB -AEGEhsEAKAIAQX4gASgCHHdxNgIACwJAAkAgBEEQTwRAIAEgBUEDcjYCBCABIAVqIgMgBEEBcjYC -BCADIARqIAQ2AgBBiIbBACgCACIGRQ0BIAZBeHFB+IPBAGohAEGQhsEAKAIAIQICf0GAhsEAKAIA -IgVBASAGQQN2dCIGcUUEQEGAhsEAIAUgBnI2AgAgAAwBCyAAKAIICyEGIAAgAjYCCCAGIAI2Agwg -AiAANgIMIAIgBjYCCAwBCyABIAQgBWoiAEEDcjYCBCAAIAFqIgAgACgCBEEBcjYCBAwBC0GQhsEA -IAM2AgBBiIbBACAENgIACyABQQhqDAYLIAAgAnJFBEBBACECQQIgB3QiAEEAIABrciAJcSIARQ0D -IABoQQJ0QeiCwQBqKAIAIQALIABFDQELA0AgACACIAAoAgRBeHEiAyAFayIGIARJIgcbIQkgACgC -ECIBRQRAIAAoAhQhAQsgAiAJIAMgBUkiABshAiAEIAYgBCAHGyAAGyEEIAEiAA0ACwsgAkUNACAF -QYiGwQAoAgAiAE0gBCAAIAVrT3ENACACKAIYIQcCQAJAIAIgAigCDCIARgRAIAJBFEEQIAIoAhQi -ABtqKAIAIgENAUEAIQAMAgsgAigCCCIBIAA2AgwgACABNgIIDAELIAJBFGogAkEQaiAAGyEDA0Ag -AyEGIAEiAEEUaiAAQRBqIAAoAhQiARshAyAAQRRBECABG2ooAgAiAQ0ACyAGQQA2AgALIAdFDQIC -QCACKAIcQQJ0QeiCwQBqIgEoAgAgAkcEQCACIAcoAhBHBEAgByAANgIUIAANAgwFCyAHIAA2AhAg -AA0BDAQLIAEgADYCACAARQ0CCyAAIAc2AhggAigCECIBBEAgACABNgIQIAEgADYCGAsgAigCFCIB -RQ0CIAAgATYCFCABIAA2AhgMAgsCQAJAAkACQAJAIAVBiIbBACgCACIBSwRAIAVBjIbBACgCACIA -TwRAIAVBr4AEakGAgHxxIgJBEHZAACEAIAhBBGoiAUEANgIIIAFBACACQYCAfHEgAEF/RiICGzYC -BCABQQAgAEEQdCACGzYCAEEAIAgoAgQiAUUNCRogCCgCDCEGQZiGwQAgCCgCCCIEQZiGwQAoAgBq -IgA2AgBBnIbBACAAQZyGwQAoAgAiAiAAIAJLGzYCAAJAAkBBlIbBACgCACICBEBB6IPBACEAA0Ag -ASAAKAIAIgMgACgCBCIHakYNAiAAKAIIIgANAAsMAgtBpIbBACgCACIAQQAgACABTRtFBEBBpIbB -ACABNgIAC0GohsEAQf8fNgIAQfSDwQAgBjYCAEHsg8EAIAQ2AgBB6IPBACABNgIAQYSEwQBB+IPB -ADYCAEGMhMEAQYCEwQA2AgBBgITBAEH4g8EANgIAQZSEwQBBiITBADYCAEGIhMEAQYCEwQA2AgBB -nITBAEGQhMEANgIAQZCEwQBBiITBADYCAEGkhMEAQZiEwQA2AgBBmITBAEGQhMEANgIAQayEwQBB -oITBADYCAEGghMEAQZiEwQA2AgBBtITBAEGohMEANgIAQaiEwQBBoITBADYCAEG8hMEAQbCEwQA2 -AgBBsITBAEGohMEANgIAQcSEwQBBuITBADYCAEG4hMEAQbCEwQA2AgBBwITBAEG4hMEANgIAQcyE -wQBBwITBADYCAEHIhMEAQcCEwQA2AgBB1ITBAEHIhMEANgIAQdCEwQBByITBADYCAEHchMEAQdCE -wQA2AgBB2ITBAEHQhMEANgIAQeSEwQBB2ITBADYCAEHghMEAQdiEwQA2AgBB7ITBAEHghMEANgIA -QeiEwQBB4ITBADYCAEH0hMEAQeiEwQA2AgBB8ITBAEHohMEANgIAQfyEwQBB8ITBADYCAEH4hMEA -QfCEwQA2AgBBhIXBAEH4hMEANgIAQYyFwQBBgIXBADYCAEGAhcEAQfiEwQA2AgBBlIXBAEGIhcEA -NgIAQYiFwQBBgIXBADYCAEGchcEAQZCFwQA2AgBBkIXBAEGIhcEANgIAQaSFwQBBmIXBADYCAEGY -hcEAQZCFwQA2AgBBrIXBAEGghcEANgIAQaCFwQBBmIXBADYCAEG0hcEAQaiFwQA2AgBBqIXBAEGg -hcEANgIAQbyFwQBBsIXBADYCAEGwhcEAQaiFwQA2AgBBxIXBAEG4hcEANgIAQbiFwQBBsIXBADYC -AEHMhcEAQcCFwQA2AgBBwIXBAEG4hcEANgIAQdSFwQBByIXBADYCAEHIhcEAQcCFwQA2AgBB3IXB -AEHQhcEANgIAQdCFwQBByIXBADYCAEHkhcEAQdiFwQA2AgBB2IXBAEHQhcEANgIAQeyFwQBB4IXB -ADYCAEHghcEAQdiFwQA2AgBB9IXBAEHohcEANgIAQeiFwQBB4IXBADYCAEH8hcEAQfCFwQA2AgBB -8IXBAEHohcEANgIAQZSGwQAgAUEPakF4cSIAQQhrIgI2AgBB+IXBAEHwhcEANgIAQYyGwQAgBEEo -ayIDIAEgAGtqQQhqIgA2AgAgAiAAQQFyNgIEIAEgA2pBKDYCBEGghsEAQYCAgAE2AgAMCAsgAiAD -SSABIAJNcg0AIAAoAgwiA0EBcQ0AIANBAXYgBkYNAwtBpIbBAEGkhsEAKAIAIgAgASAAIAFJGzYC -ACABIARqIQNB6IPBACEAAkACQANAIAMgACgCACIHRwRAIAAoAggiAA0BDAILCyAAKAIMIgNBAXEN -ACADQQF2IAZGDQELQeiDwQAhAANAAkAgAiAAKAIAIgNPBEAgAiADIAAoAgRqIgdJDQELIAAoAggh -AAwBCwtBlIbBACABQQ9qQXhxIgBBCGsiAzYCAEGMhsEAIARBKGsiCSABIABrakEIaiIANgIAIAMg -AEEBcjYCBCABIAlqQSg2AgRBoIbBAEGAgIABNgIAIAIgB0Ega0F4cUEIayIAIAAgAkEQakkbIgNB -GzYCBEHog8EAKQIAIQogA0EQakHwg8EAKQIANwIAIAMgCjcCCEH0g8EAIAY2AgBB7IPBACAENgIA -QeiDwQAgATYCAEHwg8EAIANBCGo2AgAgA0EcaiEAA0AgAEEHNgIAIABBBGoiACAHSQ0ACyACIANG -DQcgAyADKAIEQX5xNgIEIAIgAyACayIAQQFyNgIEIAMgADYCACAAQYACTwRAIAIgABBVDAgLIABB -+AFxQfiDwQBqIQECf0GAhsEAKAIAIgNBASAAQQN2dCIAcUUEQEGAhsEAIAAgA3I2AgAgAQwBCyAB -KAIICyEAIAEgAjYCCCAAIAI2AgwgAiABNgIMIAIgADYCCAwHCyAAIAE2AgAgACAAKAIEIARqNgIE -IAFBD2pBeHFBCGsiAiAFQQNyNgIEIAdBD2pBeHFBCGsiBCACIAVqIgBrIQUgBEGUhsEAKAIARg0D -IARBkIbBACgCAEYNBCAEKAIEIgFBA3FBAUYEQCAEIAFBeHEiARBNIAEgBWohBSABIARqIgQoAgQh -AQsgBCABQX5xNgIEIAAgBUEBcjYCBCAAIAVqIAU2AgAgBUGAAk8EQCAAIAUQVQwGCyAFQfgBcUH4 -g8EAaiEBAn9BgIbBACgCACIDQQEgBUEDdnQiBHFFBEBBgIbBACADIARyNgIAIAEMAQsgASgCCAsh -AyABIAA2AgggAyAANgIMIAAgATYCDCAAIAM2AggMBQtBjIbBACAAIAVrIgE2AgBBlIbBAEGUhsEA -KAIAIgAgBWoiAjYCACACIAFBAXI2AgQgACAFQQNyNgIEIABBCGoMCAtBkIbBACgCACEAAkAgASAF -ayICQQ9NBEBBkIbBAEEANgIAQYiGwQBBADYCACAAIAFBA3I2AgQgACABaiIBIAEoAgRBAXI2AgQM -AQtBiIbBACACNgIAQZCGwQAgACAFaiIDNgIAIAMgAkEBcjYCBCAAIAFqIAI2AgAgACAFQQNyNgIE -CyAAQQhqDAcLIAAgBCAHajYCBEGUhsEAQZSGwQAoAgAiAEEPakF4cSIBQQhrIgI2AgBBjIbBAEGM -hsEAKAIAIARqIgMgACABa2pBCGoiATYCACACIAFBAXI2AgQgACADakEoNgIEQaCGwQBBgICAATYC -AAwDC0GUhsEAIAA2AgBBjIbBAEGMhsEAKAIAIAVqIgE2AgAgACABQQFyNgIEDAELQZCGwQAgADYC -AEGIhsEAQYiGwQAoAgAgBWoiATYCACAAIAFBAXI2AgQgACABaiABNgIACyACQQhqDAMLQQBBjIbB -ACgCACIAIAVNDQIaQYyGwQAgACAFayIBNgIAQZSGwQBBlIbBACgCACIAIAVqIgI2AgAgAiABQQFy -NgIEIAAgBUEDcjYCBCAAQQhqDAILQYSGwQBBhIbBACgCAEF+IAIoAhx3cTYCAAsCQCAEQRBPBEAg -AiAFQQNyNgIEIAIgBWoiACAEQQFyNgIEIAAgBGogBDYCACAEQYACTwRAIAAgBBBVDAILIARB+AFx -QfiDwQBqIQECf0GAhsEAKAIAIgNBASAEQQN2dCIEcUUEQEGAhsEAIAMgBHI2AgAgAQwBCyABKAII -CyEDIAEgADYCCCADIAA2AgwgACABNgIMIAAgAzYCCAwBCyACIAQgBWoiAEEDcjYCBCAAIAJqIgAg -ACgCBEEBcjYCBAsgAkEIagsgCEEQaiQAC9UMAg1/AX4jAEGgAmsiByQAAkACQAJAAkACQCABQYAI -TQRAIAdBADYCiAEgASABQQAgAUGACEcbIgxrIg5BgAhPBEAgB0EBNgKIASAHIAA2AowBQQEhCgsg -B0GMAWohCyADIRQgBSEBIwBBIGsiCCQAIAZBBXYiCSAKIAkgCkkbIg0EQCAEQQJyIQ8gBEEBciEQ -A0AgCygCACEJIAhBGGoiESACQRhqKQIANwMAIAhBEGoiEiACQRBqKQIANwMAIAhBCGoiEyACQQhq -KQIANwMAIAggAikCADcDACAIIAlBwAAgFCAQECggCCAJQUBrQcAAIBQgBBAoIAggCUGAAWpBwAAg -FCAEECggCCAJQcABakHAACAUIAQQKCAIIAlBgAJqQcAAIBQgBBAoIAggCUHAAmpBwAAgFCAEECgg -CCAJQYADakHAACAUIAQQKCAIIAlBwANqQcAAIBQgBBAoIAggCUGABGpBwAAgFCAEECggCCAJQcAE -akHAACAUIAQQKCAIIAlBgAVqQcAAIBQgBBAoIAggCUHABWpBwAAgFCAEECggCCAJQYAGakHAACAU -IAQQKCAIIAlBwAZqQcAAIBQgBBAoIAggCUGAB2pBwAAgFCAEECggCCAJQcAHakHAACAUIA8QKCAB -QRhqIBEpAwA3AAAgAUEQaiASKQMANwAAIAFBCGogEykDADcAACABIAgpAwA3AAAgC0EEaiELIAFB -IGohASAUQgF8IRQgDUEBayINDQALCyAIQSBqJAAgDEUNASAHQcgBakIANwMAIAdBwAFqQgA3AwAg -B0G4AWpCADcDACAHQbABakIANwMAIAdBqAFqQgA3AwAgB0GgAWpCADcDACAHQZgBakIANwMAIAdB -2AFqIgEgAkEIaikCADcDACAHQeABaiIIIAJBEGopAgA3AwAgB0HoAWoiCSACQRhqKQIANwMAIAdC -ADcDkAEgByAEOgD6ASAHQQA7AfgBIAcgAikCADcD0AEgByADIAqtfDcD8AEgB0GQAWogACAOaiAM -EEYhACAHQdAAaiABKQMANwMAIAdB2ABqIAgpAwA3AwAgB0HgAGogCSkDADcDACAHQRBqIABBCGop -AwA3AwAgB0EYaiAAQRBqKQMANwMAIAdBIGogAEEYaikDADcDACAHQShqIABBIGopAwA3AwAgB0Ew -aiAAQShqKQMANwMAIAdBOGogAEEwaikDADcDACAHQUBrIABBOGopAwA3AwAgByAHKQPQATcDSCAH -IAApAwA3AwggBy0A+gEhACAHLQD5ASECIAcgBy0A+AEiBDoAcCAHIAcpA/ABIgM3A2ggByAAIAJF -ckECciIAOgBxIAdBmAJqIgIgCSkDADcDACAHQZACaiIJIAgpAwA3AwAgB0GIAmoiCCABKQMANwMA -IAcgBykD0AE3A4ACIAdBgAJqIAdBCGogBCADIAAQKCAKQQV0IgBBIGoiASAGSw0CIAIoAgAhASAJ -KAIAIQIgCCgCACEEIAcoApQCIQYgBygCjAIhCCAHKAKEAiEJIAcoAoACIQsgACAFaiIAIAcoApwC -NgAcIAAgATYAGCAAIAY2ABQgACACNgAQIAAgCDYADCAAIAQ2AAggACAJNgAEIAAgCzYAACAKQQFq -IQoMAQsgAUJ/IAGtQgF8QgGIQgF9eYinIghNDQIgB0EIaiIJQQBBgAH8CwAgACAIQQFqIgggAiAD -IAQgCUEgQcAAIAhBgAhGGyIKECohCyAAIAhqIAEgCGsgAiADIAhBCnatfCAEIAkgCmpBgAEgCmsQ -KiALQQFGBEAgBkE/TQ0EIAUgBykACDcAACAFQThqIAdBQGspAAA3AAAgBUEwaiAHQThqKQAANwAA -IAVBKGogB0EwaikAADcAACAFQSBqIAdBKGopAAA3AAAgBUEYaiAHQSBqKQAANwAAIAVBEGogB0EY -aikAADcAACAFQQhqIAdBEGopAAA3AABBAiEKDAELIAtqQQV0IgBBgQFPDQQgB0EIaiAAIAIgBCAF -IAYQQSEKCyAHQaACaiQAIAoPCyABIAZByLvAABDUAQALIAdBADYCGCAHQQE2AgwgB0HQusAANgII -IAdCBDcCECAHQQhqQZi8wAAQoQEAC0HAACAGQai8wAAQ1AEACyAAQYABQbi8wAAQ1AEAC/MIAgV/ -A34CQAJAAkAgAUEITwRAIAFBB3EiAkUNASAAKAKgASIDQSlPDQIgA0UEQCAAQQA2AqABDAILIANB -AWtB/////wNxIgVBAWoiBEEDcSEGIAJBAnRB0OXAAGooAgAgAnatIQkCQCAFQQNJBEAgACECDAEL -IARB/P///wdxIQUgACECA0AgAiACNQIAIAl+IAh8Igc+AgAgAkEEaiIEIAQ1AgAgCX4gB0IgiHwi -Bz4CACACQQhqIgQgBDUCACAJfiAHQiCIfCIHPgIAIAJBDGoiBCAENQIAIAl+IAdCIIh8Igc+AgAg -B0IgiCEIIAJBEGohAiAFQQRrIgUNAAsLIAYEQANAIAIgAjUCACAJfiAIfCIHPgIAIAJBBGohAiAH -QiCIIQggBkEBayIGDQALCyAAIAdCgICAgBBaBH8gA0EoRg0EIAAgA0ECdGogCD4CACADQQFqBSAD -CzYCoAEMAQsgACgCoAEiA0EpTw0BIANFBEAgAEEANgKgAQ8LIAFBAnRB0OXAAGo1AgAhCSADQQFr -Qf////8DcSIBQQFqIgJBA3EhBgJAIAFBA0kEQCAAIQIMAQsgAkH8////B3EhBSAAIQIDQCACIAI1 -AgAgCX4gCHwiBz4CACACQQRqIgEgATUCACAJfiAHQiCIfCIHPgIAIAJBCGoiASABNQIAIAl+IAdC -IIh8Igc+AgAgAkEMaiIBIAE1AgAgCX4gB0IgiHwiBz4CACAHQiCIIQggAkEQaiECIAVBBGsiBQ0A -CwsgBgRAA0AgAiACNQIAIAl+IAh8Igc+AgAgAkEEaiECIAdCIIghCCAGQQFrIgYNAAsLIAAgB0KA -gICAEFoEfyADQShGDQMgACADQQJ0aiAIPgIAIANBAWoFIAMLNgKgAQ8LAkAgAUEIcQRAIAAoAqAB -IgNBKU8NAgJAIANFBEBBACEDDAELIANBAWtB/////wNxIgJBAWoiBUEDcSEGAkAgAkEDSQRAQgAh -ByAAIQIMAQsgBUH8////B3EhBUIAIQcgACECA0AgAiACNQIAQuHrF34gB3wiBz4CACACQQRqIgQg -BDUCAELh6xd+IAdCIIh8Igc+AgAgAkEIaiIEIAQ1AgBC4esXfiAHQiCIfCIHPgIAIAJBDGoiBCAE -NQIAQuHrF34gB0IgiHwiCD4CACAIQiCIIQcgAkEQaiECIAVBBGsiBQ0ACwsgBgRAA0AgAiACNQIA -QuHrF34gB3wiCD4CACACQQRqIQIgCEIgiCEHIAZBAWsiBg0ACwsgCEKAgICAEFQNACADQShGDQIg -ACADQQJ0aiAHPgIAIANBAWohAwsgACADNgKgAQsgAUEQcQRAIABBxNLAAEECEDMLIAFBIHEEQCAA -QczSwABBAxAzCyABQcAAcQRAIABB2NLAAEEFEDMLIAFBgAFxBEAgAEHs0sAAQQoQMwsgAUGAAnEE -QCAAQZTTwABBExAzCyAAIAEQLRoPCwwBCyADQShB7PzAABDUAQALQShBKEHs/MAAEIABAAu3CAIM -fwF+IwBBwAFrIgIkACABKAIQIQMgAiABQRBqIgQ2AiAgAiADNgIcIAIgAkG/AWoiBjYCGCACQYAB -aiIFIAEgAkEYaiIHEEoCQAJAAkAgAikDgAEiDkICUQ0AIAJB+ABqIgMgAkGoAWopAwA3AwAgAkHw -AGoiCCACQaABaikDADcDACACQegAaiIJIAJBmAFqKQMANwMAIAJB4ABqIgogAkGQAWopAwA3AwAg -AiACKQOIATcDWCAOp0EBcUUNACACQdAAaiILIAMpAwA3AwAgAkHIAGoiDCAIKQMANwMAIAJBQGsi -DSAJKQMANwMAIAJBOGoiCCAKKQMANwMAIAIgAikDWDcDMEH5gcEALQAAGkGgAUEIEMMBIgNFDQIg -AyACKQMwNwMAIANBIGogCykDADcDACADQRhqIAwpAwA3AwAgA0EQaiANKQMANwMAIANBCGogCCkD -ADcDACACQQE2AhQgAiADNgIQIAJBBDYCDCACQShqIgkgBCgCACIENgIAIAJBIGogAUEIaikCADcD -ACACIAEpAgA3AxggAiAJNgK4ASACIAQ2ArQBIAIgBjYCsAEgBSAHIAJBsAFqEEoCQCACKQOAASIO -QgJRDQAgAkGIAWohBEEoIQFBASEGA0AgAkH4AGoiBSAEQSBqKQMANwMAIAJB8ABqIgcgBEEYaikD -ADcDACACQegAaiIKIARBEGopAwA3AwAgAkHgAGoiDSAEQQhqKQMANwMAIAIgBCkDADcDWCAOp0EB -cUUNASALIAUpAwA3AwAgDCAHKQMANwMAIAJBQGsiByAKKQMANwMAIAggDSkDADcDACACIAIpA1g3 -AzAgAigCDCAGRgRAIAJBDGogBkEBQQhBKBBXIAIoAhAhAwsgASADaiIFIAIpAzA3AwAgBUEgaiAL -KQMANwMAIAVBGGogDCkDADcDACAFQRBqIAcpAwA3AwAgBUEIaiAIKQMANwMAIAIgBkEBaiIGNgIU -IAIoAighBSACIAk2ArgBIAIgBTYCtAEgAUEoaiEBIAIgAkG/AWo2ArABIAJBgAFqIAJBGGogAkGw -AWoQSiACKQOAASIOQgJSDQALCyACKAIkIgEgAigCHCIDRwRAIAEgA2tBBHYhBANAIAMoAgAiAQRA -IANBBGooAgAgARDPAQsgA0EQaiEDIARBAWsiBA0ACwsgAigCICIBBEAgAigCGCABQQR0EM8BCyAA -IAIpAgw3AgAgAEEIaiACQRRqKAIANgIADAELIABBADYCCCAAQoCAgICAATcCACABKAIMIgAgASgC -BCIDRwRAIAAgA2tBBHYhBANAIAMoAgAiAARAIANBBGooAgAgABDPAQsgA0EQaiEDIARBAWsiBA0A -CwsgASgCCCIARQ0AIAEoAgAgAEEEdBDPAQsgAkHAAWokAA8LQQhBoAFBxJHAABC1AQAL0AgBCH8C -QCABQYAKSQRAIAFBBXYhBwJAAkAgACgCoAEiBQRAIAVBAWshAyAFQQJ0IABqQQRrIQIgBSAHakEC -dCAAakEEayEGIAVBKUkhBQNAIAVFDQIgAyAHaiIEQShPDQMgBiACKAIANgIAIAZBBGshBiACQQRr -IQIgA0EBayIDQX9HDQALCyABQSBJDQMgAEEANgIAIAdBAWoiAkECRg0DIABBADYCBCACQQNGDQMg -AEEANgIIIAJBBEYNAyAAQQA2AgwgAkEFRg0DIABBADYCECACQQZGDQMgAEEANgIUIAJBB0YNAyAA -QQA2AhggAkEIRg0DIABBADYCHCACQQlGDQMgAEEANgIgIAJBCkYNAyAAQQA2AiQgAkELRg0DIABB -ADYCKCACQQxGDQMgAEEANgIsIAJBDUYNAyAAQQA2AjAgAkEORg0DIABBADYCNCACQQ9GDQMgAEEA -NgI4IAJBEEYNAyAAQQA2AjwgAkERRg0DIABBADYCQCACQRJGDQMgAEEANgJEIAJBE0YNAyAAQQA2 -AkggAkEURg0DIABBADYCTCACQRVGDQMgAEEANgJQIAJBFkYNAyAAQQA2AlQgAkEXRg0DIABBADYC -WCACQRhGDQMgAEEANgJcIAJBGUYNAyAAQQA2AmAgAkEaRg0DIABBADYCZCACQRtGDQMgAEEANgJo -IAJBHEYNAyAAQQA2AmwgAkEdRg0DIABBADYCcCACQR5GDQMgAEEANgJ0IAJBH0YNAyAAQQA2Angg -AkEgRg0DIABBADYCfCACQSFGDQMgAEEANgKAASACQSJGDQMgAEEANgKEASACQSNGDQMgAEEANgKI -ASACQSRGDQMgAEEANgKMASACQSVGDQMgAEEANgKQASACQSZGDQMgAEEANgKUASACQSdGDQMgAEEA -NgKYASACQShGDQMgAEEANgKcASACQSlGDQNBKEEoQez8wAAQgAEACyADQShB7PzAABCAAQALIARB -KEHs/MAAEIABAAtBlv3AAEEdQez8wAAQlgEACyAAKAKgASIDIAdqIQIgAUEfcSIGRQRAIAAgAjYC -oAEgAA8LAkAgAkEBayIEQSdNBEAgAiEFIAAgBEECdGooAgBBACABayIBdiIERQ0BIAJBJ00EQCAA -IAJBAnRqIAQ2AgAgAkEBaiEFDAILIAJBKEHs/MAAEIABAAsgBEEoQez8wAAQgAEACwJAIAdBAWoi -CCACTw0AIAFBH3EhASADQQFxRQRAIAAgAkEBayICQQJ0aiIEIAQoAgAgBnQgBEEEaygCACABdnI2 -AgALIANBAkYNACACQQJ0IABqQQxrIQMDQCADQQhqIgQgBCgCACAGdCADQQRqIgQoAgAiCSABdnI2 -AgAgBCAJIAZ0IAMoAgAgAXZyNgIAIANBCGshAyAIIAJBAmsiAkkNAAsLIAAgB0ECdGoiASABKAIA -IAZ0NgIAIAAgBTYCoAEgAAv/CQMMfwF+AW9BxITAACEDIwBB0ABrIgIkACACIAE2AgwCQAJAAkAC -QCABEPEBQQFGBEAgAiABNgIgIAJBADYCECACQcSEwAA2AhggAkHUhMAANgIcIAJBIGohCkGAgICA -eCEBA0AgAiADQQhqNgIYIAIgAygCACADKAIEED02AjggCigCACUBIAJBOGooAgAlARANIQ8QcCIF -IA8mAQJAAkACQAJAAkACQCAFJQEQBEEBRgRAIAIoAjglASACKAIgJQEQBUEBRw0BCwJAIAIoAhBF -DQAgAigCFCIHQYQBSQ0AIAcQbQsgAiAFNgIUIAJBATYCECADKAIAIQUCfwJAAkACQCADKAIEQQRr -DgMBAgACC0EAIQdBBiEIQbyEwAAhAwJAA0AgBS0AACILIAMtAAAiDEYEQCAFQQFqIQUgA0EBaiED -IAhBAWsiCA0BDAILCyALIAxrIQcLIAcNAUEBDAILQQAgBSgAAEG4hMAAKAAARg0BGgtBAgsgAigC -OCIFQYMBSwRAIAUQbQtBAWsOAgMBAgsgBUGEAU8EQCAFEG0LIAIoAjgiA0GEAU8EQCADEG0LIAIo -AhgiAyACKAIcRw0FDAcLIAIoAhAgAkEANgIQQQFGBEAgAigCFCIDQYQBSQ0EIAMQbQwECwwJCyAB -QYCAgIB4RwRAQaGKwABBBBCGASEEDAILIAIoAhAgAkEANgIQRQ0IIAIgAigCFCIDNgI4IAIgAxDt -AQJ/IAIoAgAiBgRAIAIoAgQiDQwBCyACQThqIAJBzwBqQcCJwAAQQiEGQYCAgIB4CyEBIANBhAFP -BEAgAxBtCyABQYCAgIB4Rw0CIABBgICAgHg2AgAgACAGNgIEDAYLIAlFBEAgAigCECACQQA2AhBB -AUcNCCACIAIoAhQ2AiQgAkEoaiIEIAJBJGoiAygCACUBEB4EfiAEIAMoAgAlARAK/AY3AwhCAQVC -AAs3AwACfwJAIAIoAihBAUYEQCACKQMwIg5CAFkNAQsgAkEkaiACQc8AakGgiMAAEEIhBEEBDAEL -IA5CgICAgBBaBEAgAkEBOgA4IAIgDjcDQCMAQTBrIgMkACADQaCIwAA2AgQgAyACQc8AajYCACAD -QQI2AgwgA0HMjsAANgIIIANCAjcCFCADIAOtQoCAgIDgAYQ3AyggAyACQThqrUKAgICA8AGENwMg -IAMgA0EgajYCECADQQhqEGMhBCADQTBqJABBAQwBCyAOpyEEQQALIAIoAiQiBUGEAU8EQCAFEG0L -QQEhCUUNAgwBC0GlisAAQQYQhgEhBAsgAEGAgICAeDYCACAAIAQ2AgQgAUGAgICAeHJBgICAgHhG -DQQgBiABEM8BDAQLIAIoAhgiAyACKAIcRw0ACwwBCyACQQxqIAJBzwBqQeCJwAAQQiEEIABBgICA -gHg2AgAgACAENgIEIAFBhAFJDQIgARBtDAILIAFBgICAgHhHBEAgCQRAIAAgBDYCDCAAIA02Aggg -ACAGNgIEIAAgATYCAAwCC0GlisAAQQYQhQEhBCAAQYCAgIB4NgIAIAAgBDYCBCABRQ0BIAYgARDP -AQwBC0GhisAAQQQQhQEhASAAQYCAgIB4NgIAIAAgATYCBAsgAigCICIAQYQBTwRAIAAQbQsgAigC -EEUNACACKAIUIgBBgwFNDQAgABBtCyACQdAAaiQADwtB8InAAEExEOUBAAuzCwMGfwF+AW8jAEHQ -AGsiAiQAIAIgATYCIAJAAkACQAJAAkAgAkEgaiIBKAIAJQEQHARAIAJBJGoiAyABKAIAJQEQEDYC -CCADQQA2AgQgAyABNgIAQQAhASACQQA2AjAgAigCJARAIAIoAiwiAyACKAIoIgRNBEBBBCEDDAML -QfmBwQAtAAAaQYCABCADIARrIgFBACABIANNGyIBIAFBgIAETxsiAUEEdCIEQQQQwwEiAw0CQQQg -BEGgicAAELUBAAsgAkEANgI8IAJCgICAgMAANwI0DAILIAJBQGshARAXIQkQcCIDIAkmASADIQUg -AkEgaigCACIEJQEgAyUBEBghCRBwIgMgCSYBQdCCwQAoAgAhBkHMgsEAKAIAIQdBzILBAEIANwIA -AkACQAJAIAdBAUYEQCABQQM6AAQgASAGNgIADAELAkAgAxDyAUEBRgRAIAMlASAEJQEQGSEJEHAi -BCAJJgFB0ILBACgCACEGQcyCwQAoAgAhB0HMgsEAQgA3AgACQCAHQQFGBEAgAUEDOgAEIAEgBjYC -AAwBCwJAIAQQ8QFBAUcNACAEJQEQEyEJEHAiBiAJJgEgBhDyASAGQYQBTwRAIAYQbQtBAUcNACAB -QQA6AAQgASAENgIAIANBhAFPBEAgAxBtCyAFQYQBSQ0GDAULIAFBAjoABCAEQYQBSQ0AIAQQbQsg -A0GEAU8NAQwCCyABQQI6AAQgA0GEAUkNAQsgAxBtCyAFQYMBTQ0BCyAFEG0LIAIoAkAhAQJAAkAC -QCACLQBEIgNBAmsOAgIAAQsgAEGAgICAeDYCACAAIAE2AgQgAigCICIBQYMBSw0FDAYLIAIgAzoA -OCACIAE2AjQgAkEANgIsIAJCgICAgMAANwIkIAJBGGogAkE0ahB7AkAgAigCGCIDQQJHBEAgAigC -HCEBA0ACQCADQQFxRQRAIAJBQGsgARAuIAIoAkQhASACKAJAIgVBgICAgHhHDQELIABBgICAgHg2 -AgAgACABNgIEIAIoAiwiAwRAIAIoAighAQNAIAEoAgAiAARAIAFBBGooAgAgABDPAQsgAUEQaiEB -IANBAWsiAw0ACwsgAigCJCIABEAgAigCKCAAQQR0EM8BCyACKAI0IgFBgwFLDQMMBwsgAikCSCEI -IAIoAiwiAyACKAIkRgRAIAJBJGoQaQsgAigCKCADQQR0aiIEIAg3AgggBCABNgIEIAQgBTYCACAC -IANBAWo2AiwgAkEQaiACQTRqEHsgAigCFCEBIAIoAhAiA0ECRw0ACwsgACACKQIkNwIAIABBCGog -AkEsaigCADYCACACKAI0IgFBgwFNDQQLIAEQbQwDCyACQSBqIAJBQGtB0InAABBCIQEgAEGAgICA -eDYCACAAIAE2AgQMAgsgAkEANgI8IAIgAzYCOCACIAE2AjQDQCACQQhqIQMgAkEkaiIBKAIEIgQg -ASgCCE8Ef0EABSABIARBAWo2AgQgASgCACgCACUBIAQQDyEJEHAiASAJJgFBAQshBCADIAE2AgQg -AyAENgIAIAIoAghBAXFFDQEgAigCDCEBIAIgAigCMEEBajYCMCACQUBrIAEQLiACKAJEIQEgAigC -QCIFQYCAgIB4RgRAIABBgICAgHg2AgAgACABNgIEIAIoAjwiAwRAIAIoAjghAQNAIAEoAgAiAARA -IAFBBGooAgAgABDPAQsgAUEQaiEBIANBAWsiAw0ACwsgAigCNCIARQ0DIAIoAjggAEEEdBDPAQwD -CyACKQJIIQggAigCPCIDIAIoAjRGBEAgAkE0ahBpCyACKAI4IANBBHRqIgQgCDcCCCAEIAE2AgQg -BCAFNgIAIAIgA0EBajYCPCACKAIkDQALCyAAIAIpAjQ3AgAgAEEIaiACQTxqKAIANgIACyACKAIg -IgFBgwFNDQELIAEQbQsgAkHQAGokAAvPBgEIfwJAAkAgASAAQQNqQXxxIgMgAGsiCEkNACABIAhr -IgZBBEkNACAGQQNxIQdBACEBAkAgACADRiIJDQACQCAAIANrIgVBfEsEQEEAIQMMAQtBACEDA0Ag -ASAAIANqIgIsAABBv39KaiACQQFqLAAAQb9/SmogAkECaiwAAEG/f0pqIAJBA2osAABBv39KaiEB -IANBBGoiAw0ACwsgCQ0AIAAgA2ohAgNAIAEgAiwAAEG/f0pqIQEgAkEBaiECIAVBAWoiBQ0ACwsg -ACAIaiEAAkAgB0UNACAAIAZBfHFqIgMsAABBv39KIQQgB0EBRg0AIAQgAywAAUG/f0pqIQQgB0EC -Rg0AIAQgAywAAkG/f0pqIQQLIAZBAnYhBSABIARqIQQDQCAAIQMgBUUNAkHAASAFIAVBwAFPGyIG -QQNxIQcgBkECdCEIQQAhAiAFQQRPBEAgACAIQfAHcWohCSAAIQEDQCABKAIAIgBBf3NBB3YgAEEG -dnJBgYKECHEgAmogAUEEaigCACIAQX9zQQd2IABBBnZyQYGChAhxaiABQQhqKAIAIgBBf3NBB3Yg -AEEGdnJBgYKECHFqIAFBDGooAgAiAEF/c0EHdiAAQQZ2ckGBgoQIcWohAiABQRBqIgEgCUcNAAsL -IAUgBmshBSADIAhqIQAgAkEIdkH/gfwHcSACQf+B/AdxakGBgARsQRB2IARqIQQgB0UNAAsCfyAD -IAZB/AFxQQJ0aiIAKAIAIgFBf3NBB3YgAUEGdnJBgYKECHEiASAHQQFGDQAaIAEgACgCBCIBQX9z -QQd2IAFBBnZyQYGChAhxaiIBIAdBAkYNABogACgCCCIAQX9zQQd2IABBBnZyQYGChAhxIAFqCyIB -QQh2Qf+BHHEgAUH/gfwHcWpBgYAEbEEQdiAEag8LIAFFBEBBAA8LIAFBA3EhAwJAIAFBBEkEQAwB -CyABQXxxIQUDQCAEIAAgAmoiASwAAEG/f0pqIAFBAWosAABBv39KaiABQQJqLAAAQb9/SmogAUED -aiwAAEG/f0pqIQQgBSACQQRqIgJHDQALCyADRQ0AIAAgAmohAQNAIAQgASwAAEG/f0pqIQQgAUEB -aiEBIANBAWsiAw0ACwsgBAuVCAILfwN+IwBB4ABrIgQkACACrUIofiIOpyEDAkAgDkIgiKcgA0H4 -////B0tyDQACfyADRQRAQQghBkEADAELQfmBwQAtAAAaQQghByADQQgQwwEiBkUNASACCyELIAME -QCAGIAEgA/wKAAALIAJBAk8EQCAGQdAAaiEMIARB3ABqrUKAgICAEIQhDiAEQdgAaq1CgICAgCCE -IQ8DQEEAIQNBACEFAkACQAJAAkACQAJAA0AgAyEKIAIgBUkNBSAFQShsIQkCQCACIAVrIgFBA0kN -AEEJIAEgAUEJTxshCCAJIAxqIQNBAiEBA0AgASAIRgRAIAghAQwCCyABQQFqIQEgA0IEELEBIANB -KGohA0IAUg0ACwsgASAFaiIIIAFJDQEgAiAISQ0CQbyCwQAhBUG4gsEAKAIARQRAAn9B+YHBAC0A -ABpBgAhBARDDASIDBEBByILBAEEANgIAQbyCwQBBADYCAEHEgsEAKAIAIQVBxILBACADNgIAQcCC -wQAoAgAhA0HAgsEAQYAINgIAQbiCwQAoAgBBuILBAEEBNgIARSADRXJFBEAgBSADEM8BC0G8gsEA -DAELQQFBgAhBiI7AABC1AQALIQULIAUoAgANA0EAIQMgBUEANgIMIAVBfzYCAEEAIQcgAQRAIAVB -BGohDSAGIAlqIgMgAUEobGohCQNAIAQgAzYCWCAEIANBIGoiATYCXCAEQQM2AjQgBEG4i8AANgIw -IARCAjcCPCAEIA43AxAgBCAPNwMIIAQgBEEIajYCOCANQaCPwAAgBEEwahA8DQYgASgCACAHaiEH -IAFBCGoiAyAJRw0ACyAFKAIMIQMLIARBMGpBnLrAACAFKAIIIAMQNCAEQdAAaiIBIAc2AgAgBSAF -KAIAQQFqNgIAIARBEGoiAyAEQThqKQMANwMAIARBGGoiBSAEQUBrKQMANwMAIARBIGoiByAEQcgA -aikDADcDACAEQShqIgkgASkDADcDACAEIAQpAzA3AwggAiAKSwRAIAYgCkEobGoiASAEKQMINwMA -IAFBIGogCSkDADcDACABQRhqIAcpAwA3AwAgAUEQaiAFKQMANwMAIAFBCGogAykDADcDACAKQQFq -IQMgCCIFIAJGDQcMAQsLIAogAkH8gMAAEIABAAsgBSAIQeyAwAAQ1QEACyAIIAJB7IDAABDUAQAL -QYSNwAAQjQEAC0Hgi8AAQSsgBEEwakHQi8AAQfSMwAAQfQALIAUgAkGMgcAAENMBAAsgAyECIAoN -AAsLIAAgBikDADcDACAAQRhqIAZBGGopAwA3AwAgAEEQaiAGQRBqKQMANwMAIABBCGogBkEIaikD -ADcDACAGIAtBKGwQzwEgBEHgAGokAA8LIAcgA0GghMAAELUBAAvJBwIKfwJ+IwBBMGsiBiQAAkAC -QAJAAkACQAJAAkAgA0UNAAJ/IAEoAhgiByABKAIoIgVBQGtNBEAgASgCHCAFayIHIAMgAyAHSxsh -CEEAIQcgAUEcagwBCyABKAIcIAVrIgkgAyADIAlLGyEIIAkgAyAHIAVrQcEAayIHIAMgB0kbIgdJ -DQIgBSAHaiEFIAFBHGoLIQkgBkEIaiEKIAIgB2ohDSAIIAdrIQsgASkDECEQQQAhCCABKQMAIQ8g -ASgCCCEOA0ACQCAIIAtGBEBBACEMDAELIAEgDiAIIA1qLQAAQQN0aikDACAPQgGGfCIPNwMAQQEh -DCAIQQFqIQggDyAQg0IAUg0BCwsgCiAINgIEIAogDDYCAAJAAkAgBigCCEEBcQRAIAkoAgAiCCAG -KAIMIgQgBWpNDQEMAgsgCSgCACIIIAUgC2pLDQILIAggBWshBAsgAUIANwMAIAQgB2ohBSABKAIo -IgdFBEAgAyAFSQ0DIAZBIGogAiAFEHgMBgsgAyAFSQ0DIAFBIGohAyABKAIgIAdrIAVJBEAgAyAH -IAUQWCABKAIoIQcLIAUEQCABKAIkIAdqIAIgBfwKAAALIAEgBSAHajYCKCAGQRhqIANBCGooAgA2 -AgAgAUEANgIoIAMpAgAhDyABQoCAgIAQNwMgIAYgDzcDECAGQSBqIAZBEGoQdQwFCyAERQRAIAEo -AiAgASgCKCIFayADSQRAIAFBIGogBSADEFggASgCKCEFCyADBEAgASgCJCAFaiACIAP8CgAACyAA -IAM2AjAgAEEANgIAIAEgAyAFajYCKAwGCyABKAIoIgVFDQMgAUEgaiEEIAEoAiAgBWsgA0kEQCAE -IAUgAxBYIAEoAighBQsgAwRAIAEoAiQgBWogAiAD/AoAAAsgASADIAVqNgIoIAZBGGogBEEIaigC -ADYCACABQQA2AiggBCkCACEPIAFCgICAgBA3AyAgBiAPNwMQIAZBIGogBkEQahB1IAMhBQwECyAH -IAhBsJbAABDVAQALIAUgA0HAlsAAENQBAAsgBSADQdCWwAAQ1AEACyAGQSBqIAIgAxB4IAMhBQsg -BkEYaiAGQShqKQIAIg83AwAgBiAGKQIgNwMQIA+nIgFFBEAgAEEANgIwIABBADYCACAGQRxqIAYo -AhRBACAGKAIQKAIQEQMADAELIAYoAhAhAiAGKAIcIQMgAEEQakH8ucAAIAYoAhQiBCABEDQgACAF -NgIwIAAgAzYCDCAAIAE2AgggACAENgIEIAAgAjYCAAsgBkEwaiQAC9wFAgx/A34jAEGgAWsiCSQA -IAlBAEGgAfwLAAJAAkACQCACIAAoAqABIgVNBEAgBUEpTw0BIAEgAkECdGohDAJAAkAgBQRAIAVB -AWohDSAFQQJ0IQoDQCAJIAZBAnRqIQMDQCAGIQIgAyEEIAEgDEYNCCADQQRqIQMgAkEBaiEGIAEo -AgAhByABQQRqIgshASAHRQ0ACyAHrSERQgAhDyAKIQcgAiEBIAAhAwNAIAFBKE8NBCAEIA8gBDUC -AHwgAzUCACARfnwiED4CACAQQiCIIQ8gBEEEaiEEIAFBAWohASADQQRqIQMgB0EEayIHDQALIAgg -EEKAgICAEFoEfyACIAVqIgFBKE8NAyAJIAFBAnRqIA8+AgAgDQUgBQsgAmoiASABIAhJGyEIIAsh -AQwACwALA0AgASAMRg0GIARBAWohBCABKAIAIAFBBGohAUUNACAIIARBAWsiAiACIAhJGyEIDAAL -AAsgAUEoQez8wAAQgAEACyABQShB7PzAABCAAQALIAVBKU8NASACQQJ0IQwgAkEBaiENIAAgBUEC -dGohDiAAIQMCQANAIAkgB0ECdGohBgNAIAchCyAGIQQgAyAORg0FIARBBGohBiAHQQFqIQcgAygC -ACEKIANBBGoiBSEDIApFDQALIAqtIRFCACEPIAwhCiALIQMgASEGA0AgA0EoTw0CIAQgDyAENQIA -fCAGNQIAIBF+fCIQPgIAIBBCIIghDyAEQQRqIQQgA0EBaiEDIAZBBGohBiAKQQRrIgoNAAsCQCAI -IBBCgICAgBBaBH8gAiALaiIDQShPDQEgCSADQQJ0aiAPPgIAIA0FIAILIAtqIgMgAyAISRshCCAF -IQMMAQsLIANBKEHs/MAAEIABAAsgA0EoQez8wAAQgAEACyAFQShB7PzAABDUAQALIAVBKEHs/MAA -ENQBAAsgACAJQaAB/AoAACAAIAg2AqABIAlBoAFqJAAL5AgCCn8BfiMAQYACayIEJAAgBCABKQAY -NwIYIAQgASkAEDcCECAEIAEpAAg3AgggBCABKQAANwIAAn8gA0GBCE8EQCAEQSBqIQUjAEHgAGsi -ASQAIAFBOGoiBkIANwMAIAFBMGoiB0IANwMAIAFBKGoiCEIANwMAIAFBIGoiCUIANwMAIAFBGGoi -CkIANwMAIAFBEGoiC0IANwMAIAFBCGoiDEIANwMAIAFCADcDACACIAMgBEIAQRAgAUHAABAqIQMg -AUHYAGpCADcDACABQdAAakIANwMAIAFByABqQgA3AwAgAUIANwNAAkACQAJAAkAgA0EDTwRAA0Ag -A0EFdCICQcEATw0CIAEgAiAEQRAgAUFAayINQSAQQSIDQQV0IgJBwQBPDQMgAkEhTw0EIAIEQCAB -IA0gAvwKAAALIANBAksNAAsLIAUgASkDADcAACAFQThqIAYpAwA3AAAgBUEwaiAHKQMANwAAIAVB -KGogCCkDADcAACAFQSBqIAkpAwA3AAAgBUEYaiAKKQMANwAAIAVBEGogCykDADcAACAFQQhqIAwp -AwA3AAAgAUHgAGokAAwDCyACQcAAQci8wAAQ1AEACyACQcAAQdi8wAAQ1AEACyACQSBB6LzAABDU -AQALIARB+ABqIARBGGopAgA3AwAgBEHwAGogBEEQaikCADcDACAEQegAaiAEQQhqKQIANwMAIAQg -BCkCADcDYEHAACEDQRQMAQsgBEHIAWpCADcDACAEQcABakIANwMAIARBuAFqQgA3AwAgBEGwAWpC -ADcDACAEQagBakIANwMAIARBmAFqQgA3AwAgBEEQOgD6ASAEQaABakIANwMAIARB2AFqIgUgBEEI -aikCADcDACAEQegBaiIGIARBGGopAgA3AwAgBEHgAWoiByAEQRBqKQIANwMAIARCADcDkAEgBCAE -KQIANwPQASAEQQA7AfgBIARCADcD8AEgBEGQAWogAiADEEYhASAEQegAaiAFKQMANwMAIARB8ABq -IAcpAwA3AwAgBEH4AGogBikDADcDACAEQShqIAFBCGopAwA3AwAgBEEwaiABQRBqKQMANwMAIARB -OGogAUEYaikDADcDACAEQUBrIAFBIGopAwA3AwAgBEHIAGogAUEoaikDADcDACAEQdAAaiABQTBq -KQMANwMAIARB2ABqIAFBOGopAwA3AwAgBCAEKQPQATcDYCAEIAEpAwA3AyAgBCkD8AEhDiAELQD4 -ASEDIAQtAPoBIAQtAPkBRXJBAnILIQEgBCAONwOAASAEIAM6AIgBIAQgAToAiQEgBEGoAWoiAiAE -QfgAaikDADcDACAEQaABaiIFIARB8ABqKQMANwMAIARBmAFqIgYgBEHoAGopAwA3AwAgBCAEKQNg -NwOQASAEQZABaiAEQSBqIANCACABQQhyECggACACKQMANwAYIAAgBSkDADcAECAAIAYpAwA3AAgg -ACAEKQOQATcAACAEQYACaiQAC8ALAQV/IwBBIGsiBCQAAkACQAJAAkACQAJAAkACQAJAAkACQAJA -IAEOKAYBAQEBAQEBAQIEAQEDAQEBAQEBAQEBAQEBAQEBAQEBAQEIAQEBAQcACyABQdwARg0ECyAC -QQFxRSABQf8FTXINBwJ/AkBBEUEAIAFBr7AETxsiAiACQQhyIgMgAUELdCICIANBAnRBuIDBAGoo -AgBBC3RJGyIDIANBBHIiAyADQQJ0QbiAwQBqKAIAQQt0IAJLGyIDIANBAnIiAyADQQJ0QbiAwQBq -KAIAQQt0IAJLGyIDIANBAWoiAyADQQJ0QbiAwQBqKAIAQQt0IAJLGyIDIANBAWoiAyADQQJ0QbiA -wQBqKAIAQQt0IAJLGyIDQQJ0QbiAwQBqKAIAQQt0IgUgAkYgAiAFS2ogA2oiA0EhTQRAIANBAnRB -uIDBAGoiBigCAEEVdiECQe8FIQUCfwJAIANBIUYNACAGKAIEQRV2IQUgAw0AQQAMAQsgBkEEaygC -AEH///8AcQshAwJAIAUgAkF/c2pFDQAgASADayEHQe8FIAIgAkHvBU0bIQYgBUEBayEDQQAhBQNA -IAIgBkYNAyAFIAJB9MvAAGotAABqIgUgB0sNASADIAJBAWoiAkcNAAsgAyECCyACQQFxDAILIANB -IkGs/MAAEIABAAsgBkHvBUG8/MAAEIABAAtFDQcgBEEAOgAKIARBADsBCCAEIAFBFHZBt+jAAGot -AAA6AAsgBCABQQR2QQ9xQbfowABqLQAAOgAPIAQgAUEIdkEPcUG36MAAai0AADoADiAEIAFBDHZB -D3FBt+jAAGotAAA6AA0gBCABQRB2QQ9xQbfowABqLQAAOgAMIAFBAXJnQQJ2IgIgBEEIaiIDaiIF -QfsAOgAAIAVBAWtB9QA6AAAgAyACQQJrIgJqQdwAOgAAIARBEGoiAyABQQ9xQbfowABqLQAAOgAA -IABBCjoACyAAIAI6AAogACAEKQIINwIAIARB/QA6ABEgAEEIaiADLwEAOwEADAkLIABBgAQ7AQog -AEIANwECIABB3OgBOwEADAgLIABBgAQ7AQogAEIANwECIABB3OQBOwEADAcLIABBgAQ7AQogAEIA -NwECIABB3NwBOwEADAYLIABBgAQ7AQogAEIANwECIABB3LgBOwEADAULIABBgAQ7AQogAEIANwEC -IABB3OAAOwEADAQLIAJBgAJxRQ0BIABBgAQ7AQogAEIANwECIABB3M4AOwEADAMLIAJB////B3FB -gIAETw0BCwJ/QQAgAUEgSQ0AGkEBIAFB/wBJDQAaIAFBgIAETwRAIAFB4P//AHFB4M0KRyABQf7/ -/wBxQZ7wCkdxIAFBwO4Ka0F6SXEgAUGwnQtrQXJJcSABQfDXC2tBcUlxIAFBgPALa0HebElxIAFB -gIAMa0GedElxIAFB0KYMa0F7SXEgAUGAgjhrQbDFVElxIAFB8IM4SXEgAUGAgAhPDQEaIAFB2PDA -AEEsQbDxwABB0AFBgPPAAEHmAxBSDAELIAFB5vbAAEEoQbb3wABBogJB2PnAAEGpAhBSC0UEQCAE -QQA6ABYgBEEAOwEUIAQgAUEUdkG36MAAai0AADoAFyAEIAFBBHZBD3FBt+jAAGotAAA6ABsgBCAB -QQh2QQ9xQbfowABqLQAAOgAaIAQgAUEMdkEPcUG36MAAai0AADoAGSAEIAFBEHZBD3FBt+jAAGot -AAA6ABggAUEBcmdBAnYiAiAEQRRqIgNqIgVB+wA6AAAgBUEBa0H1ADoAACADIAJBAmsiAmpB3AA6 -AAAgBEEcaiIDIAFBD3FBt+jAAGotAAA6AAAgAEEKOgALIAAgAjoACiAAIAQpAhQ3AgAgBEH9ADoA -HSAAQQhqIAMvAQA7AQAMAgsgACABNgIEIABBgAE6AAAMAQsgAEGABDsBCiAAQgA3AQIgAEHcxAA7 -AQALIARBIGokAAvTBQIHfwF+An8gAUUEQCAAKAIIIQdBLSELIAVBAWoMAQtBK0GAgMQAIAAoAggi -B0GAgIABcSIBGyELIAFBFXYgBWoLIQgCQCAHQYCAgARxRQRAQQAhAgwBCyADQRBPBEAgAiADEDAg -CGohCAwBCyADRQ0AIANBA3EhCgJAIANBBEkEQEEAIQEMAQsgA0EMcSEMQQAhAQNAIAEgAiAJaiIG -LAAAQb9/SmogBkEBaiwAAEG/f0pqIAZBAmosAABBv39KaiAGQQNqLAAAQb9/SmohASAMIAlBBGoi -CUcNAAsLIAoEQCACIAlqIQYDQCABIAYsAABBv39KaiEBIAZBAWohBiAKQQFrIgoNAAsLIAEgCGoh -CAsCQCAALwEMIgkgCEsEQAJAAkAgB0GAgIAIcUUEQCAJIAhrIQlBACEBQQAhCAJAAkACQCAHQR12 -QQNxQQFrDgMAAQACCyAJIQgMAQsgCUH+/wNxQQF2IQgLIAdB////AHEhCiAAKAIEIQcgACgCACEA -A0AgAUH//wNxIAhB//8DcU8NAkEBIQYgAUEBaiEBIAAgCiAHKAIQEQAARQ0ACwwECyAAIAApAggi -DadBgICA/3lxQbCAgIACcjYCCEEBIQYgACgCACIHIAAoAgQiCiALIAIgAxCaAQ0DQQAhASAJIAhr -Qf//A3EhAgNAIAFB//8DcSACTw0CIAFBAWohASAHQTAgCigCEBEAAEUNAAsMAwtBASEGIAAgByAL -IAIgAxCaAQ0CIAAgBCAFIAcoAgwRAQANAkEAIQEgCSAIa0H//wNxIQIDQCABQf//A3EiAyACSSEG -IAIgA00NAyABQQFqIQEgACAKIAcoAhARAABFDQALDAILIAcgBCAFIAooAgwRAQANASAAIA03AghB -AA8LQQEhBiAAKAIAIgEgACgCBCIAIAsgAiADEJoBDQAgASAEIAUgACgCDBEBACEGCyAGC4oFAgZ/ -BX5CASENAkACQAJAAkAgAkHAAEcNAEEAIQIDQCACQcAARwRAIAEgAmoiAy0AACIEQTBrQf8BcUEK -TwRAIARBX3FBwQBrQf8BcUEFSw0DCyACQQJqIQIgA0EBai0AACIDQTBrQf8BcUEKSSADQV9xQcEA -a0H/AXFBBklyDQEMAgsLIAEsABAiBUFASA0BIAFBEGohBkEPQRAgAS0AAEErRiICGyEDIAEgAmoh -AgNAIAItAAAiBEHBAGtBX3FBCmogBEEwayAEQTlLGyIEQQ9LDQEgAkEBaiECIAStIAlCBIaEIQkg -A0EBayIDDQALIAEsACAiB0FASA0CIAFBIGohCCABQRFqIAYgBUErRiIDGyECQQ9BECADGyEDA0Ag -Ai0AACIEQcEAa0FfcUEKaiAEQTBrIARBOUsbIgRBD0sNASACQQFqIQIgBK0gCkIEhoQhCiADQQFr -IgMNAAsgASwAMCIFQUBIDQMgAUEwaiEGIAFBIWogCCAHQStGIgMbIQJBD0EQIAMbIQMDQCACLQAA -IgRBwQBrQV9xQQpqIARBMGsgBEE5SxsiBEEPSw0BIAJBAWohAiAErSALQgSGhCELIANBAWsiAw0A -CyABQTFqIAYgBUErRiIBGyECQQ9BECABGyEDA0AgAi0AACIBQcEAa0FfcUEKaiABQTBrIAFBOUsb -IgFBD0sNASACQQFqIQIgAa0gDEIEhoQhDCADQQFrIgMNAAsgACAMNwMgIAAgCzcDGCAAIAo3AxAg -ACAJNwMIQgAhDQsgACANNwMADwsgAUHAAEEAQRBBzLnAABDBAQALIAFBwABBEEEgQdy5wAAQwQEA -CyABQcAAQSBBMEHsucAAEMEBAAuEBgIBfwF8IwBBMGsiAiQAAn8CQAJAAkACQAJAAkACQAJAAkAC -QAJAAkACQAJAAkACQAJAAkAgAC0AAEEBaw4RAQIDBAUGBwgJCgsMDQ4PEBEACyACIAAtAAE6AAgg -AkECNgIUIAJBoL7AADYCECACQgE3AhwgAiACQQhqrUKAgICAwAeENwMoIAIgAkEoajYCGCABKAIA -IAEoAgQgAkEQahA8DBELIAIgACkDCDcDCCACQQI2AhQgAkG8vsAANgIQIAJCATcCHCACIAJBCGqt -QoCAgIDQB4Q3AyggAiACQShqNgIYIAEoAgAgASgCBCACQRBqEDwMEAsgAiAAKQMINwMIIAJBAjYC -FCACQby+wAA2AhAgAkIBNwIcIAIgAkEIaq1CgICAgOAHhDcDKCACIAJBKGo2AhggASgCACABKAIE -IAJBEGoQPAwPCyAAKwMIIQMgAkECNgIUIAJB3L7AADYCECACQgE3AhwgAiACQShqrUKAgICA8AeE -NwMIIAIgAzkDKCACIAJBCGo2AhggASgCACABKAIEIAJBEGoQPAwOCyACIAAoAgQ2AgggAkECNgIU -IAJB+L7AADYCECACQgE3AhwgAiACQQhqrUKAgICAgAiENwMoIAIgAkEoajYCGCABKAIAIAEoAgQg -AkEQahA8DA0LIAIgACkCBDcCCCACQQE2AhQgAkGQv8AANgIQIAJCATcCHCACIAJBCGqtQoCAgICQ -CIQ3AyggAiACQShqNgIYIAEoAgAgASgCBCACQRBqEDwMDAsgAUGMvsAAQQoQvwEMCwsgAUGYv8AA -QQoQvwEMCgsgAUGiv8AAQQwQvwEMCQsgAUGuv8AAQQ4QvwEMCAsgAUG8v8AAQQgQvwEMBwsgAUHE -v8AAQQMQvwEMBgsgAUHHv8AAQQQQvwEMBQsgAUHLv8AAQQwQvwEMBAsgAUHXv8AAQQ8QvwEMAwsg -AUHmv8AAQQ0QvwEMAgsgAUHzv8AAQQ4QvwEMAQsgASAAKAIEIAAoAggQvwELIAJBMGokAAv+BQEF -fyAAQQhrIgEgAEEEaygCACIDQXhxIgBqIQICQAJAIANBAXENACADQQJxRQ0BIAEoAgAiAyAAaiEA -IAEgA2siAUGQhsEAKAIARgRAIAIoAgRBA3FBA0cNAUGIhsEAIAA2AgAgAiACKAIEQX5xNgIEIAEg -AEEBcjYCBCACIAA2AgAPCyABIAMQTQsCQAJAAkACQAJAIAIoAgQiA0ECcUUEQCACQZSGwQAoAgBG -DQIgAkGQhsEAKAIARg0DIAIgA0F4cSICEE0gASAAIAJqIgBBAXI2AgQgACABaiAANgIAIAFBkIbB -ACgCAEcNAUGIhsEAIAA2AgAPCyACIANBfnE2AgQgASAAQQFyNgIEIAAgAWogADYCAAsgAEGAAkkN -AiABIAAQVUEAIQFBqIbBAEGohsEAKAIAQQFrIgA2AgAgAA0EQfCDwQAoAgAiAARAA0AgAUEBaiEB -IAAoAggiAA0ACwtBqIbBAEH/HyABIAFB/x9NGzYCAA8LQZSGwQAgATYCAEGMhsEAQYyGwQAoAgAg -AGoiADYCACABIABBAXI2AgRBkIbBACgCACABRgRAQYiGwQBBADYCAEGQhsEAQQA2AgALIABBoIbB -ACgCACIDTQ0DQZSGwQAoAgAiAkUNA0EAIQBBjIbBACgCACIEQSlJDQJB6IPBACEBA0AgAiABKAIA -IgVPBEAgAiAFIAEoAgRqSQ0ECyABKAIIIQEMAAsAC0GQhsEAIAE2AgBBiIbBAEGIhsEAKAIAIABq -IgA2AgAgASAAQQFyNgIEIAAgAWogADYCAA8LIABB+AFxQfiDwQBqIQICf0GAhsEAKAIAIgNBASAA -QQN2dCIAcUUEQEGAhsEAIAAgA3I2AgAgAgwBCyACKAIICyEAIAIgATYCCCAAIAE2AgwgASACNgIM -IAEgADYCCA8LQfCDwQAoAgAiAQRAA0AgAEEBaiEAIAEoAggiAQ0ACwtBqIbBAEH/HyAAIABB/x9N -GzYCACADIARPDQBBoIbBAEF/NgIACwvhBAEGfwJAAkAgACgCCCIHQYCAgMABcUUNAAJAAkAgB0GA -gICAAXFFBEAgAkEQSQ0BIAEgAhAwIQMMAgsCQAJAIAAvAQ4iA0UEQEEAIQIMAQsgASACaiEIQQAh -AiADIQUgASEEA0AgBCIGIAhGDQICfyAGQQFqIAYsAAAiBEEATg0AGiAGQQJqIARBYEkNABogBkED -aiAEQXBJDQAaIAZBBGoLIgQgBmsgAmohAiAFQQFrIgUNAAsLQQAhBQsgAyAFayEDDAELIAJFBEBB -ACECDAELIAJBA3EhBgJAIAJBBEkEQAwBCyACQQxxIQgDQCADIAEgBWoiBCwAAEG/f0pqIARBAWos -AABBv39KaiAEQQJqLAAAQb9/SmogBEEDaiwAAEG/f0pqIQMgCCAFQQRqIgVHDQALCyAGRQ0AIAEg -BWohBANAIAMgBCwAAEG/f0pqIQMgBEEBaiEEIAZBAWsiBg0ACwsgAyAALwEMIgRPDQAgBCADayEG -QQAhA0EAIQUCQAJAAkAgB0EddkEDcUEBaw4CAAECCyAGIQUMAQsgBkH+/wNxQQF2IQULIAdB//// -AHEhCCAAKAIEIQcgACgCACEAA0AgA0H//wNxIAVB//8DcUkEQEEBIQQgA0EBaiEDIAAgCCAHKAIQ -EQAARQ0BDAMLC0EBIQQgACABIAIgBygCDBEBAA0BQQAhAyAGIAVrQf//A3EhAQNAIANB//8DcSIC -IAFJIQQgASACTQ0CIANBAWohAyAAIAggBygCEBEAAEUNAAsMAQsgACgCACABIAIgACgCBCgCDBEB -ACEECyAEC54EAQR/IwBBgAFrIgQkAAJAAkACQCABKAIIIgJBgICAEHFFBEAgAkGAgIAgcQ0BQQEh -AiAAKAIAIAEQTEUNAgwDCyAAKAIAIQIDQCADIARqQf8AaiACQQ9xIgVBMHIgBUHXAGogBUEKSRs6 -AAAgA0EBayEDIAJBEEkgAkEEdiECRQ0AC0EBIQIgAUEBQbbrwABBAiADIARqQYABakEAIANrEDZF -DQEMAgsgACgCACECA0AgAyAEakH/AGogAkEPcSIFQTByIAVBN2ogBUEKSRs6AAAgA0EBayEDIAJB -D0sgAkEEdiECDQALQQEhAiABQQFBtuvAAEECIAMgBGpBgAFqQQAgA2sQNg0BCyABKAIAQbXowABB -AiABKAIEKAIMEQEADQACQCABKAIIIgJBgICAEHFFBEAgAkGAgIAgcQ0BIAAoAgQgARBMIQIMAgsg -ACgCBCECQQAhAwNAIAMgBGpB/wBqIAJBD3EiAEEwciAAQdcAaiAAQQpJGzoAACADQQFrIQMgAkEP -SyACQQR2IQINAAsgAUEBQbbrwABBAiADIARqQYABakEAIANrEDYhAgwBCyAAKAIEIQJBACEDA0Ag -AyAEakH/AGogAkEPcSIAQTByIABBN2ogAEEKSRs6AAAgA0EBayEDIAJBD0sgAkEEdiECDQALIAFB -AUG268AAQQIgAyAEakGAAWpBACADaxA2IQILIARBgAFqJAAgAgu9BAEIfyMAQRBrIgMkACADIAE2 -AgQgAyAANgIAIANCoICAgA43AggCfwJAAkACQCACKAIQIgkEQCACKAIUIgANAQwCCyACKAIMIgBF -DQEgAigCCCIBIABBA3RqIQQgAEEBa0H/////AXFBAWohBiACKAIAIQADQAJAIABBBGooAgAiBUUN -ACADKAIAIAAoAgAgBSADKAIEKAIMEQEARQ0AQQEMBQtBASABKAIAIAMgAUEEaigCABEAAA0EGiAA -QQhqIQAgBCABQQhqIgFHDQALDAILIABBGGwhCiAAQQFrQf////8BcUEBaiEGIAIoAgghBCACKAIA -IQADQAJAIABBBGooAgAiAUUNACADKAIAIAAoAgAgASADKAIEKAIMEQEARQ0AQQEMBAtBACEHQQAh -CAJAAkACQCAFIAlqIgFBCGovAQBBAWsOAgECAAsgAUEKai8BACEIDAELIAQgAUEMaigCAEEDdGov -AQQhCAsCQAJAAkAgAS8BAEEBaw4CAQIACyABQQJqLwEAIQcMAQsgBCABQQRqKAIAQQN0ai8BBCEH -CyADIAc7AQ4gAyAIOwEMIAMgAUEUaigCADYCCEEBIAQgAUEQaigCAEEDdGoiASgCACADIAFBBGoo -AgARAAANAxogAEEIaiEAIAVBGGoiBSAKRw0ACwwBCwsCQCAGIAIoAgRPDQAgAygCACACKAIAIAZB -A3RqIgAoAgAgACgCBCADKAIEKAIMEQEARQ0AQQEMAQtBAAsgA0EQaiQAC68VAhZ/A34jAEEQayIV -JABB/IHBACgCAEUEQEH8gcEAKAIAIQRB/IHBAEIBNwIAQYiCwQAoAgAhCkGEgsEAKAIAIQJBhILB -AEGQlMAAKQIANwIAQZCCwQAoAgAhBUGMgsEAQZiUwAApAgA3AgACQCAERSAKRXINACAFBEAgAkEI -aiEIIAIpAwBCf4VCgIGChIiQoMCAf4MhGCACIQQDQCAYUARAA0AgBEHgAGshBCAIKQMAIAhBCGoh -CEKAgYKEiJCgwIB/gyIYQoCBgoSIkKDAgH9RDQALIBhCgIGChIiQoMCAf4UhGAsgBCAYeqdBA3ZB -dGxqQQRrKAIAIgNBhAFPBEAgAxBtCyAYQgF9IBiDIRggBUEBayIFDQALCyAKIApBDGxBE2pBeHEi -A2pBCWoiBEUNACACIANrIAQQzwELCwJAAkBBgILBACgCAEUEQEGAgsEAQX82AgBBiILBACgCACID -IABxIQUgAEEZdiIWrUKBgoSIkKDAgAF+IRlBhILBACgCACECA0AgAiAFaikAACIaIBmFIhhCf4Ug -GEKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyIYUEUEQANAIAAgAiAYeqdBA3YgBWogA3FBdGxqIgRB -DGsoAgBGBEAgBEEIaygCACABRg0GCyAYQgF9IBiDIhhQRQ0ACwsgGiAaQgGGg0KAgYKEiJCgwIB/ -g1BFDQIgBSAHQQhqIgdqIANxIQUMAAsAC0H4k8AAEI0BAAtBjILBACgCAEUEQCAVQQhqIRcjAEEg -ayIPJAACQAJAQZCCwQAoAgAiCEEBaiIEIAhPBEACQEGIgsEAKAIAIgsgC0EBaiINQQN2IgJBB2wg -C0EISRsiEkEBdiAESQRAIBJBAWoiAiAEIAIgBEsbIgJBCEkNASACQf////8BTQRAQX8gAkEDdEEH -bkEBa2d2QQFqIQQMBAsQjwEgDygCHCEEIA8oAhghAgwEC0EAIQRBhILBACgCACEJAkAgAiANQQdx -QQBHaiIDRQ0AIANBAUcEQCADQf7///8DcSECA0AgBCAJaiIHIAcpAwAiGEJ/hUIHiEKBgoSIkKDA -gAGDIBhC//79+/fv37//AIR8NwMAIAdBCGoiByAHKQMAIhhCf4VCB4hCgYKEiJCgwIABgyAYQv/+ -/fv379+//wCEfDcDACAEQRBqIQQgAkECayICDQALCyADQQFxRQ0AIAQgCWoiBCAEKQMAIhhCf4VC -B4hCgYKEiJCgwIABgyAYQv/+/fv379+//wCEfDcDAAsCQAJAIA1BCE8EQCAJIA1qIAkpAAA3AAAM -AQsgDQRAIAlBCGogCSAN/AoAAAsgDUUNAQsgCUEIaiEQIAlBDGshE0EBIQJBACEEA0AgBCEHIAIh -BAJAIAcgCWoiFC0AAEGAAUcNACATIAdBdGxqIQYCQANAIAYoAgAiAiAGKAIEIAIbIgogC3EiBSEC -IAUgCWopAABCgIGChIiQoMCAf4MiGVAEQEEIIQMDQCACIANqIQIgA0EIaiEDIAkgAiALcSICaikA -AEKAgYKEiJCgwIB/gyIZUA0ACwsgCSAZeqdBA3YgAmogC3EiAmosAABBAE4EQCAJKQMAQoCBgoSI -kKDAgH+DeqdBA3YhAgsgAiAFayAHIAVrcyALcUEISQ0BIAIgCWoiAy0AACADIApBGXYiAzoAACAQ -IAJBCGsgC3FqIAM6AAAgEyACQXRsaiEDQf8BRwRAIAYtAAAhAiAGIAMtAAA6AAAgAyACOgAAIAYt -AAEhAiAGIAMtAAE6AAEgAyACOgABIAYtAAIhAiAGIAMtAAI6AAIgAyACOgACIAYtAAMhAiAGIAMt -AAM6AAMgAyACOgADIAYtAAQhAiAGIAMtAAQ6AAQgAyACOgAEIAYtAAUhAiAGIAMtAAU6AAUgAyAC -OgAFIAYtAAYhAiAGIAMtAAY6AAYgAyACOgAGIAYtAAchAiAGIAMtAAc6AAcgAyACOgAHIAYtAAgh -AiAGIAMtAAg6AAggAyACOgAIIAYtAAkhAiAGIAMtAAk6AAkgAyACOgAJIAYtAAohAiAGIAMtAAo6 -AAogAyACOgAKIAYtAAshAiAGIAMtAAs6AAsgAyACOgALDAELCyAUQf8BOgAAIBAgB0EIayALcWpB -/wE6AAAgA0EIaiAGQQhqKAAANgAAIAMgBikAADcAAAwBCyAUIApBGXYiAjoAACAQIAdBCGsgC3Fq -IAI6AAALIAQgBCANSSIHaiECIAcNAAsLQYyCwQAgEiAIazYCAEGBgICAeCECDAMLQQRBCCACQQRJ -GyEEDAELEI8BIA8oAgQhBCAPKAIAIQIMAQsCQAJAIAStQgx+IhhCIIinDQAgGKciAkF4Sw0AIAJB -B2pBeHEiAyAEQQhqIgdqIgUgA0kgBUH4////B0tyDQBB+YHBAC0AABogBUEIEMMBIgINAUEIIAUQ -6gEACxCPASAPKAIMIQQgDygCCCECDAELIAIgA2ohDCAHBEAgDEH/ASAH/AsACyAEQQFrIhEgBEED -dkEHbCAEQQlJGyEQQYSCwQAoAgAhAyAIBEAgDEEMayESIAxBCGohEyADQQxrIQkgAykDAEJ/hUKA -gYKEiJCgwIB/gyEZIAMhAkEAIQQgCCEHA0AgGVAEQANAIARBCGohBCACQQhqIgIpAwBCgIGChIiQ -oMCAf4MiGEKAgYKEiJCgwIB/UQ0ACyAYQoCBgoSIkKDAgH+FIRkLIAwgCSAZeqdBA3YgBGoiFEF0 -bGoiCigCACIFIAooAgQgBRsiCiARcSIOaikAAEKAgYKEiJCgwIB/gyIYUARAQQghBgNAIAYgDmoh -BSAGQQhqIQYgDCAFIBFxIg5qKQAAQoCBgoSIkKDAgH+DIhhQDQALCyAZQgF9IBmDIRkgDCAYeqdB -A3YgDmogEXEiDmosAABBAE4EQCAMKQMAQoCBgoSIkKDAgH+DeqdBA3YhDgsgDCAOaiAKQRl2IgU6 -AAAgEyAOQQhrIBFxaiAFOgAAIBIgDkF0bGoiCkEIaiAJIBRBdGxqIgVBCGooAAA2AAAgCiAFKQAA -NwAAIAdBAWsiBw0ACwtBiILBACARNgIAQYSCwQAgDDYCAEGMgsEAIBAgCGs2AgBBgYCAgHghAiAL -RQ0AIAsgDUEMbEEHakF4cSIEakEJaiIHRQ0AIAMgBGsgBxDPAQsgFyACNgIAIBcgBDYCBCAPQSBq -JAALIAAgARC4ASEHQYSCwQAoAgAiCEGIgsEAKAIAIgQgAHEiBWopAABCgIGChIiQoMCAf4MiGFAE -QEEIIQMDQCADIAVqIQIgA0EIaiEDIAggAiAEcSIFaikAAEKAgYKEiJCgwIB/gyIYUA0ACwsgCCAY -eqdBA3YgBWogBHEiBWosAAAiA0EATgRAIAggCCkDAEKAgYKEiJCgwIB/g3qnQQN2IgVqLQAAIQML -IAUgCGogFjoAACAIIAVBCGsgBHFqQQhqIBY6AABBjILBAEGMgsEAKAIAIANBAXFrNgIAQZCCwQBB -kILBACgCAEEBajYCACAIIAVBdGxqIgRBBGsgBzYCACAEQQhrIAE2AgAgBEEMayAANgIACyAEQQRr -KAIAIQEQcCIAIAElASYBQYCCwQBBgILBACgCAEEBajYCACAVQRBqJAAgAAuVBAEMfyABQQFrIQ4g -ACgCBCEKIAAoAgAhCyAAKAIIIQwCQANAIAUNAQJ/AkAgAiADSQ0AA0AgASADaiEFAkACQAJAIAIg -A2siB0EHTQRAIAIgA0cNASACIQMMBQsCQCAFQQNqQXxxIgYgBWsiBARAQQAhAANAIAAgBWotAABB -CkYNBSAEIABBAWoiAEcNAAsgBCAHQQhrIgBNDQEMAwsgB0EIayEACwNAQYCChAggBigCACIJQYqU -qNAAc2sgCXJBgIKECCAGQQRqKAIAIglBipSo0ABzayAJcnFBgIGChHhxQYCBgoR4Rw0CIAZBCGoh -BiAEQQhqIgQgAE0NAAsMAQtBACEAA0AgACAFai0AAEEKRg0CIAcgAEEBaiIARw0ACyACIQMMAwsg -BCAHRgRAIAIhAwwDCwNAIAQgBWotAABBCkYEQCAEIQAMAgsgByAEQQFqIgRHDQALIAIhAwwCCyAA -IANqIgZBAWohAwJAIAIgBk0NACAAIAVqLQAAQQpHDQBBACEFIAMhBiADDAMLIAIgA08NAAsLIAIg -CEYNAkEBIQUgCCEGIAILIQACQCAMLQAABEAgC0Gs68AAQQQgCigCDBEBAA0BC0EAIQQgACAIRwRA -IAAgDmotAABBCkYhBAsgACAIayEAIAEgCGohByAMIAQ6AAAgBiEIIAsgByAAIAooAgwRAQBFDQEL -C0EBIQ0LIA0LygQCB38BfiMAQRBrIgYkAAJAIAAvAQwiBUUEQCAAKAIAIAAoAgQgARBAIQIMAQsg -BiABKAIMIgQ2AgwgBiABKAIIIgI2AgggBiABKAIEIgM2AgQgBiABKAIAIgE2AgACQCAAKQIIIgmn -IgdBgICACHEEQCAAKAIAIAEgAyAAKAIEKAIMEQEADQEgACAHQYCAgP95cUGwgICAAnIiBzYCCCAG -QgE3AgAgBSADQf//A3FrIgFBACABIAVNGyEFQQAhAwsgBARAIARBDGwhCANAAn8CQAJAAkAgAi8B -AEEBaw4CAgEACyACQQRqKAIADAILIAJBCGooAgAMAQsgAkECai8BACIEQegHTwRAQQRBBSAEQZDO -AEkbDAELQQEgBEEKSQ0AGkECQQMgBEHkAEkbCyACQQxqIQIgA2ohAyAIQQxrIggNAAsLAkACQCAF -Qf//A3EgA0sEQCAFIANrIQNBACECQQAhAQJAAkACQCAHQR12QQNxQQFrDgMAAQACCyADIQEMAQsg -A0H+/wNxQQF2IQELIAdB////AHEhCCAAKAIEIQcgACgCACEEA0AgAkH//wNxIAFB//8DcU8NAiAC -QQFqIQIgBCAIIAcoAhARAABFDQALDAMLIAAoAgAgACgCBCAGEEAhAgwBCyAEIAcgBhBADQFBACEF -IAMgAWtB//8DcSEBA0AgBUH//wNxIgMgAUkhAiABIANNDQEgBUEBaiEFIAQgCCAHKAIQEQAARQ0A -CwsgACAJNwIIDAELQQEhAgsgBkEQaiQAIAIL/gMBCX8jAEEQayIEJAACfwJAIAIoAgQiA0UNACAA -IAIoAgAgAyABKAIMEQEARQ0AQQEMAQsgAigCDCIGBEAgAigCCCIDIAZBDGxqIQggBEEMaiEJA0AC -QAJAAkACQCADLwEAQQFrDgICAQALAkAgAygCBCICQcEATwRAIAFBDGooAgAhBgNAQQEgAEGA7cAA -QcAAIAYRAQANCBogAkFAaiICQcAASw0ACwwBCyACRQ0DCyAAQYDtwAAgAiABQQxqKAIAEQEARQ0C -QQEMBQsgACADKAIEIAMoAgggAUEMaigCABEBAEUNAUEBDAQLIAMvAQIhAiAJQQA6AAAgBEEANgII -An9BBEEFIAJBkM4ASRsgAkHoB08NABpBASACQQpJDQAaQQJBAyACQeQASRsLIgYgBEEIaiIKaiIH -QQFrIgUgAiACQQpuIgtBCmxrQTByOgAAAkAgBSAKRg0AIAdBAmsiBSALQQpwQTByOgAAIARBCGog -BUYNACAHQQNrIgUgAkHkAG5BCnBBMHI6AAAgBEEIaiAFRg0AIAdBBGsiBSACQegHbkEKcEEwcjoA -ACAEQQhqIAVGDQAgB0EFayACQZDOAG5BMHI6AAALIAAgBEEIaiAGIAFBDGooAgARAQBFDQBBAQwD -CyADQQxqIgMgCEcNAAsLQQALIARBEGokAAvMBAEKfyMAQTBrIgYkAAJAAkACQAJ/QQAgAUFAcSIK -RQ0AGiAGQQhqIAA2AgBBASAKQcAARg0AGiAGIABBQGs2AgwgCkGAAUcNAUECCyEHIAFBP3EhASAF -QQV2IgkgByAHIAlLGyIIBEAgBkEIaiEJIANBBHIhCyAIQQV0IQxBACEDA0AgCSgCACEIIAZBKGoi -DSACQRhqKQIANwMAIAZBIGoiDiACQRBqKQIANwMAIAZBGGoiDyACQQhqKQIANwMAIAYgAikCADcD -ECAGQRBqIAhBwABCACALECggAyAEaiIIQRhqIA0pAwA3AAAgCEEQaiAOKQMANwAAIAhBCGogDykD -ADcAACAIIAYpAxA3AAAgCUEEaiEJIAwgA0EgaiIDRw0ACwsCQCABBEAgBSAHQQV0IgJJDQEgBSAC -ayIDQR9NDQMgAUEgRw0EIAIgBGoiASAAIApqIgApAAA3AAAgAUEYaiAAQRhqKQAANwAAIAFBEGog -AEEQaikAADcAACABQQhqIABBCGopAAA3AAAgB0EBaiEHCyAGQTBqJAAgBw8LIAIgBUH4u8AAENMB -AAsgBiAAQYABajYCEEGwvcAAQSsgBkEQakHcvcAAQYi8wAAQfQALQSAgA0HYu8AAENQBAAsjAEEw -ayIAJAAgAEEgNgIEIAAgATYCACAAQQM2AgwgAEGggMEANgIIIABCAjcCFCAAIABBBGqtQoCAgICA -CYQ3AyggACAArUKAgICAgAmENwMgIAAgAEEgajYCECAAQQhqQei7wAAQoQEAC4QEAgd/AXwjAEHQ -AGsiAyQAAkACQAJAAkACQCAAKAIAIgQlAUGBASUBEAdFBEAgBCUBEAgOAgIBAwsgA0EHOgAwIANB -MGogASACEH8hAAwEC0EBIQYLQQEhB0EAIQAMAQsgA0EQaiAEJQEQCSADKAIQBEAgAysDGCEKQQMh -AEEBIQcMAQsgA0EIaiAEEO0BAn8gAygCCCIEBEAgAygCDCIFIQZBBQwBCwJAAkAgACgCACUBECME -QCADQTBqIAAQdiADKAI4IQYgAygCNCEEIAMoAjAhCAwBCyAAKAIAJQEQHUUNASADIAAoAgAQugEi -BTYCSCADQTBqIANByABqEHYgAygCOCEGIAMoAjQhBCADKAIwIQggBUGEAUkNACAFEG0LIAhBgICA -gHhGDQBBASEHQQYMAQsgA0EBNgI0IANBhJPAADYCMCADQgE3AjwgAyAArUKAgICA4AKENwNIIAMg -A0HIAGo2AjggA0EkaiADQTBqEEdBgICAgHghCCADKAIsIQYgAygCKCEEIAMoAiQhBUERCyEAIAat -vyEKIAchCQsgAyAKOQM4IAMgBDYCNCADIAY6ADEgAyAAOgAwIANBMGogASACEH8hAAJAIAlFBEAg -ByAFRXJFDQEMAgsgCARAIAQgCBDPAQsgBUUgB3INAQsgBCAFEM8BCyADQdAAaiQAIAAL5AMBBX8j -AEEQayIIJAACQAJAAkACQAJAIAEoAghBAUYEQCABKAIAIQUgASgCBCEEIAFBDBDPAUEdQYEBIARB -CnZnQQJ0ayAEQf//B0sbIQYgAiAFayIHIANqIQMgAiAFRgRAIAYhAQwGCyAGQQV2IgIgB2oiAUGA -gIDAAE8EQEH5gcEALQAAGkEUQQQQwwEiAUUNAiABQQE2AhAgASACIANqNgIIIAEgBSACazYCBCAB -IAIgBGo2AgAgASAGQQJ2QQdxNgIMDAULIAZBHXEgAUEFdHIhAQwECyADQQBIDQECQCADRQRAQQEh -BQwBC0H5gcEALQAAGkEBIQQgA0EBEMMBIgVFDQILIAMEQCAFIAIgA/wKAAALIAEgASgCCCICQQFr -NgIIIAJBAUYEQCABKAIAIAFBBGooAgAiBEEBELYBRQ0DIAQQzwEgAUEMEM8BC0EdQYEBIANBCnZn -QQJ0ayADQf//B0sbIQEgAyEEDAQLQQRBFBDqAQALIAQgA0H4tMAAELUBAAtBtLbAAEErIAhBD2pB -pLbAAEHwtsAAEH0ACyADIAdrIgJBACACIANNGyEDIAQgB2shBCAFIAdqIQULIAAgATYCDCAAIAQ2 -AgggACADNgIEIAAgBTYCACAIQRBqJAAL+QMBAn8gACABaiECAkACQCAAKAIEIgNBAXENACADQQJx -RQ0BIAAoAgAiAyABaiEBIAAgA2siAEGQhsEAKAIARgRAIAIoAgRBA3FBA0cNAUGIhsEAIAE2AgAg -AiACKAIEQX5xNgIEIAAgAUEBcjYCBCACIAE2AgAMAgsgACADEE0LAkACQAJAIAIoAgQiA0ECcUUE -QCACQZSGwQAoAgBGDQIgAkGQhsEAKAIARg0DIAIgA0F4cSICEE0gACABIAJqIgFBAXI2AgQgACAB -aiABNgIAIABBkIbBACgCAEcNAUGIhsEAIAE2AgAPCyACIANBfnE2AgQgACABQQFyNgIEIAAgAWog -ATYCAAsgAUGAAk8EQCAAIAEQVQ8LIAFB+AFxQfiDwQBqIQICf0GAhsEAKAIAIgNBASABQQN2dCIB -cUUEQEGAhsEAIAEgA3I2AgAgAgwBCyACKAIICyEBIAIgADYCCCABIAA2AgwgACACNgIMIAAgATYC -CA8LQZSGwQAgADYCAEGMhsEAQYyGwQAoAgAgAWoiATYCACAAIAFBAXI2AgQgAEGQhsEAKAIARw0B -QYiGwQBBADYCAEGQhsEAQQA2AgAPC0GQhsEAIAA2AgBBiIbBAEGIhsEAKAIAIAFqIgE2AgAgACAB -QQFyNgIEIAAgAWogATYCAAsLjgMBBH8CQAJAAkACQAJAIAcgCFYEQCAHIAh9IAhYDQECQCAGIAcg -Bn1UIAcgBkIBhn0gCEIBhlpxRQRAIAYgCFYNAQwHCyACIANJDQMMBQsgByAGIAh9IgZ9IAZWDQUg -AiADSQ0DIAEgA2ohDCABIQoCQAJAA0AgAyAJRg0BIAlBAWohCSAKQQFrIgogA2oiCy0AAEE5Rg0A -CyALIAstAABBAWo6AAAgAyAJa0EBaiADTw0BIAlBAWsiBUUNASALQQFqQTAgBfwLAAwBCwJAIANF -BEBBMSEJDAELIAFBMToAACADQQFGBEBBMCEJDAELQTAhCSADQQFrIgpFDQAgAUEBakEwIAr8CwAL -IARBAWrBIgQgBcFMIAIgA01yDQAgDCAJOgAAIANBAWohAwsgAiADTw0EIAMgAkG45sAAENQBAAsg -AEEANgIADwsgAEEANgIADwsgAyACQcjmwAAQ1AEACyADIAJBqObAABDUAQALIAAgBDsBCCAAIAM2 -AgQgACABNgIADwsgAEEANgIAC6cDAQJ/AkACQAJAAkAgAC0AaCIDBEAgA0HBAE8NAyACQcAAIANr -IgQgAiAESRsiBARAIAAgA2ogASAE/AoAAAsgACAALQBoIARqIgM6AGggASAEaiEBIAIgBGsiAkUE -QEEAIQIMAgsgAEFAayAAQcAAIAApA2AgAC0AaiAALQBpRXIQKCAAQgA3AwAgAEEAOgBoIABBCGpC -ADcDACAAQRBqQgA3AwAgAEEYakIANwMAIABBIGpCADcDACAAQShqQgA3AwAgAEEwakIANwMAIABB -OGpCADcDACAAIAAtAGlBAWo6AGkLQQAhAyACQcEASQ0BIABBQGshBCAALQBpIQMDQCAEIAFBwAAg -ACkDYCAALQBqIANB/wFxRXIQKCAAIAAtAGlBAWoiAzoAaSABQUBrIQEgAkFAaiICQcAASw0ACyAA -LQBoIQMLIANB/wFxIgNBwQBPDQILIAJBwAAgA2siBCACIARJGyICBEAgACADaiABIAL8CgAACyAA -IAAtAGggAmo6AGggAA8LIANBwABBuLvAABDTAQALIANBwABBuLvAABDTAQALjwMBB38jAEEQayIE -JAACQAJAAkACQCABKAIEIgIEQCABKAIAIQcgAkEDcSEFAkAgAkEESQRAQQAhAgwBCyAHQRxqIQMg -AkF8cSEIQQAhAgNAIAMoAgAgA0EIaygCACADQRBrKAIAIANBGGsoAgAgAmpqamohAiADQSBqIQMg -CCAGQQRqIgZHDQALCyAFBEAgBkEDdCAHakEEaiEDA0AgAygCACACaiECIANBCGohAyAFQQFrIgUN -AAsLIAEoAgxFDQIgAkEPSw0BIAcoAgQNAQwDC0EAIQIgASgCDEUNAgsgAkEAIAJBAEobQQF0IQIL -QQAhBSACQQBOBEAgAkUNAUH5gcEALQAAGkEBIQUgAkEBEMMBIgMNAgsgBSACQcTKwAAQtQEAC0EB -IQNBACECCyAEQQA2AgggBCADNgIEIAQgAjYCACAEQcTJwAAgARA8RQRAIAAgBCkCADcCACAAQQhq -IARBCGooAgA2AgAgBEEQaiQADwtB5MrAAEHWACAEQQ9qQdTKwABB1MvAABB9AAvnAgEFfwJAIAFB -zf97QRAgACAAQRBNGyIAa08NACAAQRAgAUELakF4cSABQQtJGyIEakEMahApIgJFDQAgAkEIayEB -AkAgAEEBayIDIAJxRQRAIAEhAAwBCyACQQRrIgUoAgAiBkF4cSACIANqQQAgAGtxQQhrIgIgAEEA -IAIgAWtBEE0baiIAIAFrIgJrIQMgBkEDcQRAIAAgAyAAKAIEQQFxckECcjYCBCAAIANqIgMgAygC -BEEBcjYCBCAFIAIgBSgCAEEBcXJBAnI2AgAgASACaiIDIAMoAgRBAXI2AgQgASACEEQMAQsgASgC -ACEBIAAgAzYCBCAAIAEgAmo2AgALAkAgACgCBCIBQQNxRQ0AIAFBeHEiAiAEQRBqTQ0AIAAgBCAB -QQFxckECcjYCBCAAIARqIgEgAiAEayIEQQNyNgIEIAAgAmoiAiACKAIEQQFyNgIEIAEgBBBECyAA -QQhqIQMLIAML6gICBn8CfiMAQSBrIgUkAEEUIQMgACIJQugHWgRAIAkhCgNAIAVBDGogA2oiBEED -ayAKIApCkM4AgCIJQpDOAH59pyIGQf//A3FB5ABuIgdBAXQiCEG568AAai0AADoAACAEQQRrIAhB -uOvAAGotAAA6AAAgBEEBayAGIAdB5ABsa0H//wNxQQF0IgZBuevAAGotAAA6AAAgBEECayAGQbjr -wABqLQAAOgAAIANBBGshAyAKQv+s4gRWIAkhCg0ACwsgCUIJVgRAIAMgBWpBC2ogCaciBCAEQf// -A3FB5ABuIgRB5ABsa0H//wNxQQF0IgZBuevAAGotAAA6AAAgA0ECayIDIAVBDGpqIAZBuOvAAGot -AAA6AAAgBK0hCQsgAFBFIAlQcUUEQCADQQFrIgMgBUEMamogCadBAXRBHnFBuevAAGotAAA6AAAL -IAIgAUEBQQAgBUEMaiADakEUIANrEDYgBUEgaiQAC9ACAQR/IwBB8ABrIgMkAAJAIAACfgJAIAEo -AgQiBCABKAIMRwRAIAEgBEEQajYCBCAEKAIMIQUgBCgCACEBIAIoAgQgA0HIAGogBCgCBCIGIAQo -AggQNyADKAJIIgRFBEAgA0FAayADQegAaikDADcDACADQThqIANB4ABqKQMANwMAIANBMGogA0HY -AGopAwA3AwAgAyADKQNQNwMoCyABBEAgBiABEM8BCyAEQQFxRQ0BQQE6AABCAAwCCyAAQgI3AwAM -AgsgA0EgaiADQUBrKQMANwMAIANBGGogA0E4aikDADcDACADQRBqIANBMGopAwA3AwAgAyADKQMo -NwMIQgELNwMAIAAgAykDCDcDCCAAIAU2AiggAEEQaiADQRBqKQMANwMAIABBGGogA0EYaikDADcD -ACAAQSBqIANBIGopAwA3AwALIANB8ABqJAAL3AgBCH8jAEGAAWsiAiQAIAJBCGohBCMAQSBrIgMk -ACADIABpIgE2AhwCQAJAAkACQAJAAkAgAUEBRgRAIABBwABNDQEgA0GcgsEANgIYQaCCwQAtAABB -A0cEfyADIANBGGo2AhwgAyADQRxqNgIAIwBBIGsiASQAAkACQAJAAkACQAJAQaCCwQAtAABBAWsO -AwIEAQALQaCCwQBBAjoAACADKAIAIgYoAgAhBSAGQQA2AgAgBUUNAiAFKAIAQQg2AgBBoILBAEED -OgAACyABQSBqJAAMAwsgAUEANgIYIAFBATYCDCABQbSZwAA2AggMCgtB+JrAABDXAQALIAFBADYC -GCABQQE2AgwgAUH0mcAANgIIDAgLIAMoAhgFQZyCwQALKAIAIgFFDQIgA0GUgsEANgIYIAAgAW4i -BkGYgsEALQAAQQNHBH8gAyADQRhqNgIcIAMgA0EcajYCACMAQSBrIgEkAAJAAkACQAJAAkACQEGY -gsEALQAAQQFrDgMCBAEAC0GYgsEAQQI6AAAgAygCACIHKAIAIQUgB0EANgIAIAVFDQIgBSgCAEEC -NgIAQZiCwQBBAzoAAAsgAUEgaiQADAMLIAFBADYCGCABQQE2AgwgAUG0mcAANgIIDAoLQfiawAAQ -1wEACyABQQA2AhggAUEBNgIMIAFB9JnAADYCCAwICyADKAIYBUGUgsEACygCACAAbCIBTw0DIAFB -AEgNBEH5gcEALQAAGkEBIQggAUEBEMMBIgVFDQQgBCABNgIcIAQgBjYCGCAEQYibwAA2AgggBEIA -NwMAIARBADYCKCAEIAU2AiQgBCABNgIgIAQgAEEBayIArSAAZ0Egc62GNwMQIANBIGokAAwFCyAD -QQA2AgAjAEEQayIAJAAgAEGglMAANgIMIAAgA0EcajYCCCAAQQhqQcixwAAgAEEMakHIscAAIANB -iJXAABBQAAtBmJXAAEEoQcCVwAAQlgEAC0HQlcAAEJwBAAtB4JXAAEEvQZCWwAAQlgEACyAIIAFB -oJbAABC1AQALIAJBOGoiAEEAOgAAIAJB+ABqIAApAwA3AgAgAkHwAGogAkEwaikDADcCACACQegA -aiACQShqKQMANwIAIAJB4ABqIAJBIGopAwA3AgAgAkHYAGogAkEYaikDADcCACACQdAAaiACQRBq -KQMANwIAQfmBwQAtAAAaIAIgAikDCDcCSEHIAEEIEMMBIgBFBEBBCEHIABDqAQALIABBADYCCCAA -QoGAgIAQNwMAIAAgAikCRDcCDCAAQRRqIAJBzABqKQIANwIAIABBHGogAkHUAGopAgA3AgAgAEEk -aiACQdwAaikCADcCACAAQSxqIAJB5ABqKQIANwIAIABBNGogAkHsAGopAgA3AgAgAEE8aiACQfQA -aikCADcCACAAQcQAaiACQfwAaigCADYCACACQYABaiQAIABBCGoPCyABQgQ3AhAgAUEIakHsl8AA -EKEBAAvmAgEIfyMAQRBrIgUkAEEKIQIgACIDQegHTwRAIAMhBANAIAVBBmogAmoiBkEDayAEIARB -kM4AbiIDQZDOAGxrIgdB//8DcUHkAG4iCEEBdCIJQbnrwABqLQAAOgAAIAZBBGsgCUG468AAai0A -ADoAACAGQQFrIAcgCEHkAGxrQf//A3FBAXQiB0G568AAai0AADoAACAGQQJrIAdBuOvAAGotAAA6 -AAAgAkEEayECIARB/6ziBEsgAyEEDQALCwJAIANBCU0EQCADIQQMAQsgAiAFakEFaiADIANB//8D -cUHkAG4iBEHkAGxrQf//A3FBAXQiA0G568AAai0AADoAACACQQJrIgIgBUEGamogA0G468AAai0A -ADoAAAtBACAAIAQbRQRAIAJBAWsiAiAFQQZqaiAEQQF0QR5xQbnrwABqLQAAOgAACyABQQFBAUEA -IAVBBmogAmpBCiACaxA2IAVBEGokAAuCAwEEfyAAKAIMIQICQAJAAkAgAUGAAk8EQCAAKAIYIQMC -QAJAIAAgAkYEQCAAQRRBECAAKAIUIgIbaigCACIBDQFBACECDAILIAAoAggiASACNgIMIAIgATYC -CAwBCyAAQRRqIABBEGogAhshBANAIAQhBSABIgJBFGogAkEQaiACKAIUIgEbIQQgAkEUQRAgARtq -KAIAIgENAAsgBUEANgIACyADRQ0CAkAgACgCHEECdEHogsEAaiIBKAIAIABHBEAgAygCECAARg0B -IAMgAjYCFCACDQMMBAsgASACNgIAIAJFDQQMAgsgAyACNgIQIAINAQwCCyAAKAIIIgAgAkcEQCAA -IAI2AgwgAiAANgIIDwtBgIbBAEGAhsEAKAIAQX4gAUEDdndxNgIADwsgAiADNgIYIAAoAhAiAQRA -IAIgATYCECABIAI2AhgLIAAoAhQiAEUNACACIAA2AhQgACACNgIYDwsPC0GEhsEAQYSGwQAoAgBB -fiAAKAIcd3E2AgAL4AIBBH8jAEEQayICJAACQCABQYABTwRAIAJBDGoiBEECciEDIAJBADYCDAJA -IAFBgBBPBEAgBEEDciEFIAFBgIAETwRAIAJBEGohAyACIAFBEnZB8AFyOgAMIAIgAUEGdkE/cUGA -AXI6AA4gAiABQQx2QT9xQYABcjoADSAFIQQMAgsgAiABQQx2QeABcjoADCACIAFBBnZBP3FBgAFy -OgANIAMhBCAFIQMMAQsgAkEMakEBciEEIAIgAUEGdkHAAXI6AAwLIAQgAUE/cUGAAXI6AAAgAyAC -QQxqayIBIAAoAgAgACgCCCIDa0sEQCAAIAMgAUEBQQEQVyAAKAIIIQMLIAEEQCAAKAIEIANqIAJB -DGogAfwKAAALIAAgASADajYCCAwBCyAAKAIIIgMgACgCAEYEQCAAQYiDwAAQcgsgACgCBCADaiAB -OgAAIAAgA0EBajYCCAsgAkEQaiQAQQAL4AIBBH8jAEEQayICJAACQCABQYABTwRAIAJBDGoiBEEC -ciEDIAJBADYCDAJAIAFBgBBPBEAgBEEDciEFIAFBgIAETwRAIAJBEGohAyACIAFBEnZB8AFyOgAM -IAIgAUEGdkE/cUGAAXI6AA4gAiABQQx2QT9xQYABcjoADSAFIQQMAgsgAiABQQx2QeABcjoADCAC -IAFBBnZBP3FBgAFyOgANIAMhBCAFIQMMAQsgAkEMakEBciEEIAIgAUEGdkHAAXI6AAwLIAQgAUE/ -cUGAAXI6AAAgAyACQQxqayIBIAAoAgAgACgCCCIDa0sEQCAAIAMgAUEBQQEQVyAAKAIIIQMLIAEE -QCAAKAIEIANqIAJBDGogAfwKAAALIAAgASADajYCCAwBCyAAKAIIIgMgACgCAEYEQCAAQaCOwAAQ -cgsgACgCBCADaiABOgAAIAAgA0EBajYCCAsgAkEQaiQAQQALswIBAX8jAEHwAGsiBiQAIAYgATYC -DCAGIAA2AgggBiADNgIUIAYgAjYCECAGQcyBwQAoAgA2AhwgBkHAgcEAKAIANgIYAkAgBCgCAARA -IAZBMGogBEEQaikCADcDACAGQShqIARBCGopAgA3AwAgBiAEKQIANwMgIAZBBDYCXCAGQeDqwAA2 -AlggBkIENwJkIAYgBkEQaq1CgICAgPALhDcDUCAGIAZBCGqtQoCAgIDwC4Q3A0ggBiAGQSBqrUKA -gICAkAyENwNADAELIAZBAzYCXCAGQazqwAA2AlggBkIDNwJkIAYgBkEQaq1CgICAgPALhDcDSCAG -IAZBCGqtQoCAgIDwC4Q3A0ALIAYgBkEYaq1CgICAgIAMhDcDOCAGIAZBOGo2AmAgBkHYAGogBRCh -AQAL8gIBAX8CQCACBEAgAS0AAEEwTQ0BIAVBAjsBAAJAAkACQAJAAkAgA8EiBkEASgRAIAUgATYC -BCACIANB//8DcSIDSw0BIAVBADsBDCAFIAI2AgggBSADIAJrNgIQIAQNAkECIQEMBQsgBSACNgIg -IAUgATYCHCAFQQI7ARggBUEAOwEMIAVBAjYCCCAFQfHnwAA2AgQgBUEAIAZrIgM2AhBBAyEBIAIg -BE8NBCAEIAJrIgIgA00NBCACIAZqIQQMAwsgBUECOwEYIAVBATYCFCAFQfDnwAA2AhAgBUECOwEM -IAUgAzYCCCAFIAIgA2siAjYCICAFIAEgA2o2AhwgAiAESQ0BQQMhAQwDCyAFQQE2AiAgBUHw58AA -NgIcIAVBAjsBGAwBCyAEIAJrIQQLIAUgBDYCKCAFQQA7ASRBBCEBCyAAIAE2AgQgACAFNgIADwtB -2OTAAEEhQfzmwAAQlgEAC0GM58AAQR9BrOfAABCWAQALygIBBn8gASACQQF0aiEJIABBgP4DcUEI -diEKIABB/wFxIQwCQAJAAkACQANAIAFBAmohCyAHIAEtAAEiAmohCCAKIAEtAAAiAUcEQCABIApL -DQQgCCEHIAsiASAJRw0BDAQLIAcgCEsNASAEIAhJDQIgAyAHaiEBA0AgAkUEQCAIIQcgCyIBIAlH -DQIMBQsgAkEBayECIAEtAAAgAUEBaiEBIAxHDQALC0EAIQIMAwsgByAIQcjwwAAQ1QEACyAIIARB -yPDAABDUAQALIABB//8DcSEHIAUgBmohA0EBIQIDQCAFQQFqIQACQCAFLAAAIgFBAE4EQCAAIQUM -AQsgACADRwRAIAUtAAEgAUH/AHFBCHRyIQEgBUECaiEFDAELQbjwwAAQ1wEACyAHIAFrIgdBAEgN -ASACQQFzIQIgAyAFRw0ACwsgAkEBcQvKAgEDfyMAQRBrIgIkAAJAIAFBgAFPBEAgAkEANgIMAn8g -AUGAEE8EQCABQYCABE8EQCACQQxqQQNyIQQgAiABQRJ2QfABcjoADCACIAFBBnZBP3FBgAFyOgAO -IAIgAUEMdkE/cUGAAXI6AA1BBAwCCyACQQxqQQJyIQQgAiABQQx2QeABcjoADCACIAFBBnZBP3FB -gAFyOgANQQMMAQsgAkEMakEBciEEIAIgAUEGdkHAAXI6AAxBAgshAyAEIAFBP3FBgAFyOgAAIAAo -AgAgACgCCCIBayADSQRAIAAgASADEGggACgCCCEBCyADBEAgACgCBCABaiACQQxqIAP8CgAACyAA -IAEgA2o2AggMAQsgACgCCCIDIAAoAgBGBEAgAEHky8AAEHILIAAgA0EBajYCCCAAKAIEIANqIAE6 -AAALIAJBEGokAEEAC8YCAQJ/IwBBEGsiAiQAAkAgAUGAAU8EQCACQQA2AgwCfyABQYAQTwRAIAFB -gIAETwRAIAIgAUE/cUGAAXI6AA8gAiABQRJ2QfABcjoADCACIAFBBnZBP3FBgAFyOgAOIAIgAUEM -dkE/cUGAAXI6AA1BBAwCCyACIAFBP3FBgAFyOgAOIAIgAUEMdkHgAXI6AAwgAiABQQZ2QT9xQYAB -cjoADUEDDAELIAIgAUE/cUGAAXI6AA0gAiABQQZ2QcABcjoADEECCyIBIAAoAgAgACgCCCIDa0sE -QCAAIAMgARBfIAAoAgghAwsgAQRAIAAoAgQgA2ogAkEMaiAB/AoAAAsgACABIANqNgIIDAELIAAo -AggiAyAAKAIARgRAIABB+MTAABByCyAAKAIEIANqIAE6AAAgACADQQFqNgIICyACQRBqJABBAAvE -AgEEfyAAQgA3AhAgAAJ/QQAgAUGAAkkNABpBHyABQf///wdLDQAaIAFBBiABQQh2ZyIDa3ZBAXEg -A0EBdGtBPmoLIgI2AhwgAkECdEHogsEAaiEEQQEgAnQiA0GEhsEAKAIAcUUEQCAEIAA2AgAgACAE -NgIYIAAgADYCDCAAIAA2AghBhIbBAEGEhsEAKAIAIANyNgIADwsCQAJAIAEgBCgCACIDKAIEQXhx -RgRAIAMhAgwBCyABQRkgAkEBdmtBACACQR9HG3QhBQNAIAMgBUEddkEEcWoiBCgCECICRQ0CIAVB -AXQhBSACIQMgAigCBEF4cSABRw0ACwsgAigCCCIBIAA2AgwgAiAANgIIIABBADYCGCAAIAI2Agwg -ACABNgIIDwsgBEEQaiAANgIAIAAgAzYCGCAAIAA2AgwgACAANgIIC/cCAQR/IwBBMGsiACQAAkAC -QEHYgcEAKAIARQRAQfCBwQAoAgAhAUHwgcEAQQA2AgAgAUUNASAAQRhqIAERBgAgAEEQaiICIABB -JGopAgA3AwAgACAAKQIcNwMIIAAoAhghAUHYgcEAKAIAIgMNAgJAIANFDQBB3IHBACgCACICRQ0A -QeCBwQAoAgAgAkECdBDPAQtB3IHBACABNgIAQdiBwQBBATYCAEHggcEAIAApAwg3AgBB6IHBACAA -QRBqKQMANwIACyAAQTBqJABB3IHBAA8LIABBADYCKCAAQQE2AhwgAEG8wMAANgIYIABCBDcCICAA -QRhqQajBwAAQoQEACyAAQShqIAIpAwA3AgAgACAAKQMINwIgIAAgATYCHCAAQQE2AhgCQCAAQRhq -IgEoAgBFDQAgASgCBCICRQ0AIAEoAgggAkECdBDPAQsgAEEANgIoIABBATYCHCAAQcjBwAA2Ahgg -AEIENwIgIAFB0MHAABChAQAL/AECBH8BfiMAQSBrIgUkAAJAAkAgBEUNACABIAEgAmoiAksNACAD -IARqQQFrQQAgA2txrSACIAAoAgAiAUEBdCIGIAIgBksbIgJBCEEEQQEgBEGBCEkbIARBAUYbIgYg -AiAGSxsiBq1+IglCIIhQRQ0AIAmnIghBgICAgHggA2tLDQBBACECIAUgAQR/IAUgASAEbDYCHCAF -IAAoAgQ2AhQgAwUgAgs2AhggBUEIaiADIAggBUEUahB0IAUoAghBAUcNASAFKAIQIQIgBSgCDCEH -CyAHIAJBpIvAABC1AQALIAUoAgwhASAAIAY2AgAgACABNgIEIAVBIGokAAvKAQIEfwF+IwBBIGsi -AyQAAkACQCABIAEgAmoiAksNAEEIIAIgACgCACIBQQF0IgQgAiAESxsiAiACQQhNGyIErSIHQiCI -UEUNACAHpyIFQf////8HSw0AIAMgAQR/IAMgATYCHCADIAAoAgQ2AhRBAQVBAAs2AhggA0EIakEB -IAUgA0EUahB0IAMoAghBAUcNASADKAIQIQIgAygCDCEGCyAGIAJB+JjAABC1AQALIAMoAgwhASAA -IAQ2AgAgACABNgIEIANBIGokAAuJAgEBfyMAQRBrIgIkACAAKAIAIQACfyABLQALQRhxRQRAIAEo -AgAgACABKAIEKAIQEQAADAELIAJBADYCDCABIAJBDGoCfyAAQYABTwRAIABBgBBPBEAgAEGAgARP -BEAgAiAAQT9xQYABcjoADyACIABBEnZB8AFyOgAMIAIgAEEGdkE/cUGAAXI6AA4gAiAAQQx2QT9x -QYABcjoADUEEDAMLIAIgAEE/cUGAAXI6AA4gAiAAQQx2QeABcjoADCACIABBBnZBP3FBgAFyOgAN -QQMMAgsgAiAAQT9xQYABcjoADSACIABBBnZBwAFyOgAMQQIMAQsgAiAAOgAMQQELEDoLIAJBEGok -AAuqAgIDfwF+IwBBQGoiAiQAIAEoAgBBgICAgHhGBEAgASgCDCEDIAJBJGoiBEEANgIAIAJCgICA -gBA3AhwgAkEwaiADKAIAIgNBCGopAgA3AwAgAkE4aiADQRBqKQIANwMAIAIgAykCADcDKCACQRxq -QejFwAAgAkEoahA8GiACQRhqIAQoAgAiAzYCACACIAIpAhwiBTcDECABQQhqIAM2AgAgASAFNwIA -CyABKQIAIQUgAUKAgICAEDcCACACQQhqIgMgAUEIaiIBKAIANgIAIAFBADYCAEH5gcEALQAAGiAC -IAU3AwBBDEEEEMMBIgFFBEBBBEEMEOoBAAsgASACKQMANwIAIAFBCGogAygCADYCACAAQYTIwAA2 -AgQgACABNgIAIAJBQGskAAuaAgEDfyMAQRBrIgYkACABIAEoAggiBUEAIAVBAUcbNgIIAkACQAJA -IAVBAUYEQCABKAIEIQQgASgCACEFIAFBDBDPASADRQ0BIAUgAiAD/AoAAAwBCyADQQBIDQECQCAD -RQRAQQEhBQwBC0H5gcEALQAAGkEBIQQgA0EBEMMBIgVFDQILIAMEQCAFIAIgA/wKAAALIAEgASgC -CCICQQFrNgIIIAMhBCACQQFHDQAgASgCACABQQRqKAIAIgRBARC2AUUNAiAEEM8BIAFBDBDPASAD -IQQLIAAgAzYCCCAAIAU2AgQgACAENgIAIAZBEGokAA8LIAQgA0H4tMAAELUBAAtBtLbAAEErIAZB -D2pBpLbAAEHwtsAAEH0AC4ICAgF+An8jAEGAAWsiBCQAIAAoAgApAwAhAgJ/AkAgASgCCCIAQYCA -gBBxRQRAIABBgICAIHENASACQQEgARBJDAILQQAhAANAIAAgBGpB/wBqIAKnQQ9xIgNBMHIgA0HX -AGogA0EKSRs6AAAgAEEBayEAIAJCD1YgAkIEiCECDQALIAFBAUG268AAQQIgACAEakGAAWpBACAA -axA2DAELQQAhAANAIAAgBGpB/wBqIAKnQQ9xIgNBMHIgA0E3aiADQQpJGzoAACAAQQFrIQAgAkIP -ViACQgSIIQINAAsgAUEBQbbrwABBAiAAIARqQYABakEAIABrEDYLIARBgAFqJAALiAIBBX8CQAJA -AkACQCABKAIAIgFBAXEEQEEdQYEBIAIgAUF+cSIFayIGIANqIgFBCnZnQQJ0ayABQf//B0sbIQQg -AiAFRgRAIAQhAiABIQMMBQsgBEEFdiIHIAZqIgJBgICAwABJDQJB+YHBAC0AABpBFEEEEMMBIgJF -DQEgAkEBNgIQIAIgASAHaiIINgIIIAIgBSAHazYCBCACIAg2AgAgAiAEQQJ2QQdxNgIMDAMLIAAg -ASACIAMQQw8LQQRBFBDqAQALIARBHXEgAkEFdHIhAgsgASAGayIEQQAgASAETxshASAFIAZqIQUL -IAAgAjYCDCAAIAM2AgggACABNgIEIAAgBTYCAAuDAgEFfwJAAkACQAJAIAEoAgAiAUEBcQRAQR1B -gQEgAiABayIGIANqIgRBCnZnQQJ0ayAEQf//B0sbIQUgASACRgRAIAUhAiAEIQMMBQsgBUEFdiIH -IAZqIgJBgICAwABJDQJB+YHBAC0AABpBFEEEEMMBIgJFDQEgAkEBNgIQIAIgBCAHaiIINgIIIAIg -ASAHazYCBCACIAg2AgAgAiAFQQJ2QQdxNgIMDAMLIAAgASACIAMQQw8LQQRBFBDqAQALIAVBHXEg -AkEFdHIhAgsgBCAGayIFQQAgBCAFTxshBCABIAZqIQELIAAgAjYCDCAAIAM2AgggACAENgIEIAAg -ATYCAAvVAQIEfwF+IwBBIGsiAyQAAkACQCABIAEgAmoiAksEQEEAIQEMAQtBACEBQQggAiAAKAIA -IgVBAXQiBCACIARLGyICIAJBCE0bIgStIgdCIIhQRQ0AIAenIgZB/////wdLDQAgAyAFBH8gAyAF -NgIcIAMgACgCBDYCFEEBBUEACzYCGCADQQhqQQEgBiADQRRqEHQgAygCCEEBRw0BIAMoAhAhAiAD -KAIMIQELIAEgAkHYxcAAELUBAAsgAygCDCEBIAAgBDYCACAAIAE2AgQgA0EgaiQAC8oCAgR/AW8j -AEEgayIDJAAQGiEHEHAiBSAHJgEgA0EYaiIEIAU2AgQgBCACNgIAIAMoAhwhAgJAIAMoAhgiBEUE -QEEBIQUMAQsgAyACNgIcIAMgBDYCGCADQRBqIgQgASgCBCABKAIIELgBNgIEIARBADYCAEEBIQUg -AygCFCEEAkACQCADKAIQQQFxBEAgAiEBIAQhAgwBCyADQRxqIgZBuITAAEEEED0gBBDQASABKAIM -uBAMIQcQcCIEIAcmASADQQhqIgIgBDYCBCACQQA2AgAgAygCDCECIAMoAghBAXFFDQEgAygCHCEB -CyABQYQBSQ0BIAEQbQwBCyAGQbyEwABBBhA9IAIQ0AEgAS0AECEBIAZB7oTAAEEFED1BggFBgwEg -ARsQ0AFBACEFIAMoAhwhAgsgACACNgIEIAAgBTYCACADQSBqJAALqAIBBH8jAEEgayIEJABBASEG -AkAgACgCACIFIAEgAiAAKAIEIgcoAgwiAREBAA0AAkAgAC0ACkGAAXFFBEAgBUGy68AAQQEgAREB -AA0CIAMgAEGkg8AAKAIAEQAARQ0BDAILIAVBs+vAAEECIAERAQANASAEQQE6AA8gBCAHNgIEIAQg -BTYCACAEQZTrwAA2AhQgBCAAKQIINwIYIAQgBEEPajYCCCAEIAQ2AhAgAyAEQRBqQaSDwAAoAgAR -AAANASAEKAIQQbDrwABBAiAEKAIUKAIMEQEADQELAkAgAg0AIAAtAApBgAFxDQAgACgCAEG168AA -QQEgACgCBCgCDBEBAA0BCyAAKAIAQbTowABBASAAKAIEKAIMEQEAIQYLIARBIGokACAGC9kDAQd/ -IwBBEGsiBiQAAkACQCACQQdNBEAgAg0BDAILIAZBCGohBwJAAkACQAJAIAFBA2pBfHEiAyABRg0A -IAIgAyABayIDIAIgA0kbIgRFDQBBACEDQQEhBQNAIAEgA2otAABBLkYNBCAEIANBAWoiA0cNAAsg -BCACQQhrIghLDQIMAQsgAkEIayEIQQAhBAtBrty48QIhAwNAQYCChAggASAEaiIJKAIAQa7cuPEC -cyIFayAFckGAgoQIIAlBBGooAgBBrty48QJzIgVrIAVycUGAgYKEeHFBgIGChHhHDQEgBEEIaiIE -IAhNDQALCyACIARHBEBBLiEDQQEhBQNAIAEgBGotAABBLkYEQCAEIQMMAwsgAiAEQQFqIgRHDQAL -C0EAIQULIAcgAzYCBCAHIAU2AgAgBigCCEEBRiEDDAELIAEtAABBLkYiAyACQQFGcg0AIAEtAAFB -LkYiAyACQQJGcg0AIAEtAAJBLkYiAyACQQNGcg0AIAEtAANBLkYiAyACQQRGcg0AIAEtAARBLkYi -AyACQQVGcg0AIAEtAAVBLkYiAyACQQZGcg0AIAEtAAZBLkYhAwsgACADIAAtAARyOgAEIAAoAgAg -ASACEL8BIAZBEGokAAvkAQEEfyMAQRBrIgMkACAAKAIMIQECQAJ/AkACQAJAAkACQCAAKAIEDgIA -AQILIAENAUEBIQFBACEAQQEhAgwDCyABRQ0BCyADQQRqIAAQRyADKAIEIQAgAygCCCECIAMoAgwM -AgsgACgCACIBKAIEIgBBAEgNAiABKAIAIQEgAEUEQEEBIQJBACEADAELQfmBwQAtAAAaQQEhBCAA -QQEQwwEiAkUNAgsgAARAIAIgASAA/AoAAAsgAAshASACIAEQuQEgAARAIAIgABDPAQsgA0EQaiQA -DwsgBCAAQayQwAAQtQEAC5QCAgF/AX4jAEGgAWsiAiQAIAJCgICAgIAHIgMgAUEYaq2ENwM4IAIg -AyABQRBqrYQ3AzAgAiADIAFBCGqthDcDKCACIAMgAa2ENwMgIAJBrLnAADYCCCACQQQ2AgwgAkEE -NgIcIAJCg4CAgICEgIBpNwKYASACQYCAwAA2ApABIAJBAjsBiAEgAkKCgICAgISAgGk3AoABIAJB -gIDAADYCeCACQQI7AXAgAkKBgICAgISAgGk3AmggAkGAgMAANgJgIAJBAjsBWCACQoCAgICAhICA -aTcCUCACQoCAwAA3AkggAkECOwFAIAIgAkFAazYCGCACQQQ2AhQgAiACQSBqNgIQIAAgAkEIahBH -IAJBoAFqJAAL8gEBAn8jAEEwayICJAACQCAAKQMAQv///////////wCDQoCAgICAgID4/wBaBEAg -AkEBNgIUIAJBhMDAADYCECACQgE3AhwgAiAArUKAgICAoAiENwMoIAIgAkEoajYCGCABKAIAIAEo -AgQgAkEQahA8IQMMAQsgAkEAOgAMIAIgATYCCEEBIQMgAkEBNgIUIAJBhMDAADYCECACQgE3Ahwg -AiAArUKAgICAoAiENwMoIAIgAkEoajYCGCACQQhqQey9wAAgAkEQahA8DQAgAi0ADEUEQCABQYzA -wABBAhC/AQ0BC0EAIQMLIAJBMGokACADC5UCAQJ/IwBBIGsiBSQAQeSCwQBB5ILBACgCACIGQQFq -NgIAAn9BACAGQQBIDQAaQQFBsIbBAC0AAA0AGkGwhsEAQQE6AABBrIbBAEGshsEAKAIAQQFqNgIA -QQILQf8BcSIGQQJHBEAgBkEBcQRAIAVBCGogACABKAIYEQIACwALAkBB2ILBACgCACIGQQBOBEBB -2ILBACAGQQFqNgIAQdyCwQAoAgAEQCAFIAAgASgCFBECACAFIAQ6AB0gBSADOgAcIAUgAjYCGCAF -IAUpAwA3AhBB3ILBACgCACAFQRBqQeCCwQAoAgAoAhQRAgALQdiCwQBB2ILBACgCAEEBazYCAEGw -hsEAQQA6AAAgA0UNAQALAAsAC8QBAgZ/AX4jAEEgayICJABBBCAAKAIAIgVBAXQiAyADQQRNGyIG -rUIUfiIIQiCIUEUEQEEAQQAgARC1AQALAkAgCKciB0H8////B00EQEEAIQMgAiAFBH8gAiAFQRRs -NgIcIAIgACgCBDYCFEEEBSADCzYCGCACQQhqQQQgByACQRRqEHQgAigCCEEBRw0BIAIoAgwhBCAC -KAIQIQMLIAQgAyABELUBAAsgAigCDCEBIAAgBjYCACAAIAE2AgQgAkEgaiQAC7sBAQJ/IwBBIGsi -AyQAAkACf0EAIAEgASACaiICSw0AGkEAQQggAiAAKAIAIgFBAXQiBCACIARLGyICIAJBCE0bIgRB -AEgNABpBACECIAMgAQR/IAMgATYCHCADIAAoAgQ2AhRBAQUgAgs2AhggA0EIakEBIAQgA0EUahB0 -IAMoAghBAUcNASADKAIQIQAgAygCDAsgAEGYysAAELUBAAsgAygCDCEBIAAgBDYCACAAIAE2AgQg -A0EgaiQAC8ABAQV/IwBBIGsiASQAIAAoAgAiAkH///8/SwRAQQBBAEGwicAAELUBAAsCQEEEIAJB -AXQiAyADQQRNGyIDQQR0IgRB/P///wdNBH8gASACBH8gASACQQR0NgIcIAEgACgCBDYCFEEEBUEA -CzYCGCABQQhqQQQgBCABQRRqEHQgASgCCEEBRw0BIAEoAhAhBSABKAIMBUEACyAFQbCJwAAQtQEA -CyABKAIMIQIgACADNgIAIAAgAjYCBCABQSBqJAALvQEBA38jAEEQayICJAACQAJAAkAgAUUEQCAA -RQ0BIABBCGsiASgCAEEBRw0CIAAoAiwgACgCKCEDIAFBADYCAAJAIAFBf0YNACAAQQRrIgAgACgC -AEEBayIANgIAIAANACABQcgAEM8BCyADRQ0DIAMQzwEMAwsgAEUNACACIABBCGsiADYCDCAAIAAo -AgBBAWsiADYCACAADQIgAkEMahCTAQwCCxDjAQALQfOEwABBPxDlAQALIAJBEGokAAvBAQIDfwF+ -IwBBMGsiAiQAIAEoAgBBgICAgHhGBEAgASgCDCEDIAJBFGoiBEEANgIAIAJCgICAgBA3AgwgAkEg -aiADKAIAIgNBCGopAgA3AwAgAkEoaiADQRBqKQIANwMAIAIgAykCADcDGCACQQxqQejFwAAgAkEY -ahA8GiACQQhqIAQoAgAiAzYCACACIAIpAgwiBTcDACABQQhqIAM2AgAgASAFNwIACyAAQYTIwAA2 -AgQgACABNgIAIAJBMGokAAu2AQEBfyMAQRBrIgMkAAJAAkACQCAAKAIAIgBBAXEEQCABIABBfnEi -AGsgAmoiAUEBELYBRQ0CIAAgARDPAQwBCyAAIAAoAggiAUEBazYCCCABQQFHDQAgACgCACAAQQRq -KAIAIgJBARC2AUUNAiACEM8BIABBDBDPAQsgA0EQaiQADwtBtLbAAEErIANBD2pBpLbAAEHgtsAA -EH0AC0G0tsAAQSsgA0EPakGktsAAQfC2wAAQfQALsAEBBn8CQAJAIABBhAFJDQAgANBvJgEQViIB -KAIMIQUgASgCECECIAFCADcCDCABKAIIIQMgASgCBCEEIAFCBDcCBCABKAIAIQYgAUEANgIAIAAg -AkkNASAAIAJrIgAgA08NASAEIABBAnRqIAU2AgAgASACNgIQIAEgADYCDCABIAM2AgggASgCBCAB -IAQ2AgQgASgCACEAIAEgBjYCACAARQ0AIABBAnQQzwELDwsAC7kBAQF/QfmBwQAtAAAaAkBBDEEE -EMMBIgYEQCAGQQI2AgggBiADNgIAIAYgBCADayAFajYCBCABIAYgASgCACIBIAEgAkYiAhs2AgAg -AkUEQCABIAEoAggiAkEBajYCCCACQQBIDQIgACABNgIMIAAgBTYCCCAAIAQ2AgQgAEGAt8AANgIA -IAZBDBDPAQ8LIAAgBjYCDCAAIAU2AgggACAENgIEIABBgLfAADYCAA8LQQRBDBDqAQALAAuxAQEB -fyMAQRBrIgMkAAJAAkACQCAAKAIAIgBBAXEEQCABIABrIAJqIgFBARC2AUUNAiAAIAEQzwEMAQsg -ACAAKAIIIgFBAWs2AgggAUEBRw0AIAAoAgAgAEEEaigCACICQQEQtgFFDQIgAhDPASAAQQwQzwEL -IANBEGokAA8LQbS2wABBKyADQQ9qQaS2wABB4LbAABB9AAtBtLbAAEErIANBD2pBpLbAAEHwtsAA -EH0AC88DAgx/AX4jAEEgayIEJAAgBEEYaiIJEFYiBUEQaiIHKAIANgIAIARBEGoiCiAFQQhqIggp -AgA3AwAgB0EANgIAIAhCADcCACAFKQIAIQwgBUKAgICAwAA3AgAgBCAMNwMIAn8jAEEgayIDJAAC -QAJAIARBCGoiACgCDCIBIAAoAggiAkYEQAJAIAAoAgAiAiABRgRA0G9BgAEgASABQYABTRsiBvwP -ASICQX9GDQQCQCAAKAIQIgtFBEAgACACNgIQDAELIAEgC2ogAkcNBQsgASAGaiICQf////8BSw0E -IAMgAQR/IAMgAUECdDYCHCADIAAoAgQ2AhRBBAVBAAs2AhggA0EIakEEIAJBAnQgA0EUahB0IAMo -AghBAUYNBCADKAIMIQYgACACNgIAIAAgBjYCBAwBCyABIAJPDQMLIAAgAUEBaiICNgIIIAAoAgQg -AUECdGogAjYCAAwBCyABIAJPDQELIAAgACgCBCABQQJ0aigCADYCDCAAKAIQIANBIGokACABagwB -CwALIAggCikDADcCACAHIAkoAgA2AgAgBSgCBCEDIAUoAgAhASAFIAQpAwg3AgAgAQRAIAMgAUEC -dBDPAQsgBEEgaiQAC6wBAQF/IwBBEGsiBiQAAkAgAQRAIAZBBGogASADIAQgBSACKAIQEQgAAkAg -BigCBCICIAYoAgwiAU0EQCAGKAIIIQUMAQsgAkECdCECIAYoAgghAyABRQRAQQQhBSADIAIQzwEM -AQsgAyACQQQgAUECdCICELsBIgVFDQILIAAgATYCBCAAIAU2AgAgBkEQaiQADwtByLPAAEEyEOUB -AAtBBCACQbizwAAQtQEAC5oBAQR/IwBBIGsiAiQAQQggACgCACIEQQF0IgMgA0EITRsiA0EASARA -QQBBACABELUBAAsgAiAEBH8gAiAENgIcIAIgACgCBDYCFEEBBSAFCzYCGCACQQhqQQEgAyACQRRq -EHQgAigCCEEBRgRAIAIoAgwgAigCECABELUBAAsgAigCDCEBIAAgAzYCACAAIAE2AgQgAkEgaiQA -C6QBAQF/IwBBQGoiAiQAIAAoAgAhACACQgA3AzggAkE4aiAAJQEQJCACIAIoAjwiADYCNCACIAIo -Ajg2AjAgAiAANgIsIAIgAkEsaq1CgICAgOAIhDcDICACQQI2AgwgAkGcxMAANgIIIAJCATcCFCAC -IAJBIGo2AhAgASgCACABKAIEIAJBCGoQPCACKAIsIgEEQCACKAIwIAEQzwELIAJBQGskAAuPAQEB -fyACQQBOBEACfyADKAIEBEACQCADKAIIIgRFBEAMAQsgAygCACAEIAEgAhC7AQwCCwsgASACRQ0A -GkH5gcEALQAAGiACIAEQwwELIgNFBEAgACACNgIIIAAgATYCBCAAQQE2AgAPCyAAIAI2AgggACAD -NgIEIABBADYCAA8LIABBADYCBCAAQQE2AgALrQEBA38gASgCBCECAn8CQCABKAIIIgQgASgCACID -RwRAQfmBwQAtAAAaQQxBBBDDASIBDQFBBEEMEOoBAAsgBEUEQEEAIQFBASECQYi1wAAMAgsgAkEB -cQRAIAIhAUGQtsAADAILIAJBAXIhAUH8tcAADAELIAFBATYCCCABIAM2AgQgASACNgIAQYC3wAAL -IQMgACABNgIMIAAgBDYCCCAAIAI2AgQgACADNgIAC8ABAgV/AW8CQCABKAIAIgUQ8wEiA0EASA0A -AkAgA0UEQEEBIQQMAQtB+YHBAC0AABpBASECIANBARDDASIERQ0BCxAmIQcQcCIBIAcmASABIgYl -ARAfIQcQcCIBIAcmASABELoBIQIgAUGEAU8EQCABEG0LIAIlASAFJQEgBBAhIAJBhAFPBEAgAhBt -CyAGQYQBTwRAIAYQbQsgACAFEPMBNgIIIAAgBDYCBCAAIAM2AgAPCyACIANBuLLAABC1AQALlAEB -A38jAEEQayICJAACf0EBIAEoAgAiA0EnIAEoAgQiBCgCECIBEQAADQAaIAJBBGogACgCAEGBAhA1 -AkAgAi0ABEGAAUYEQCADIAIoAgggAREAAEUNAUEBDAILIAMgAi0ADiIAIAJBBGpqIAItAA8gAGsg -BCgCDBEBAEUNAEEBDAELIANBJyABEQAACyACQRBqJAALlQEBAn8CQCACQQBIDQAgAAJ/IAJFBEBB -iLXAACEDQQEhBEEADAELQfmBwQAtAAAaQQEhAyACQQEQwwEiBEUNASACBEAgBCABIAL8CgAACyAE -QQFxBEBBkLbAACEDIAQMAQtB/LXAACEDIARBAXILNgIMIAAgAjYCCCAAIAQ2AgQgACADNgIADwsg -AyACQfi0wAAQtQEAC3kCAX4CfyMAQYABayIEJAAgACkDACECQQAhAANAIAAgBGpB/wBqIAKnQQ9x -IgNBMHIgA0HXAGogA0EKSRs6AAAgAEEBayEAIAJCD1YgAkIEiCECDQALIAFBAUG268AAQQIgACAE -akGAAWpBACAAaxA2IARBgAFqJAALhAEBAX8CQCADQQBIDQACQCADRQRAQQEhAQwBC0H5gcEALQAA -GkEBIQQgA0EBEMMBIgFFDQELIAMEQCABIAIgA/wKAAALIAAgAzYCCCAAIAM2AgQgACABNgIAIABB -HUGBASADQQp2Z0ECdGsgA0H//wdLGzYCDA8LIAQgA0GIuMAAELUBAAujAQIEfwFvAkAgAS0ABARA -QQIhAwwBCyABKAIAJQEQFCEGEHAiAiAGJgFB0ILBACgCACEEQcyCwQAoAgBBzILBAEIANwIAQQEh -A0EBRgRAIAFBAToABAwBCwJ/IAIlARAVRQRAIAIlARAWIQYQcCIBIAYmASABIQRBAAwBCyABQQE6 -AARBAgshAyACQYQBSQ0AIAIQbQsgACAENgIEIAAgAzYCAAt6AQF/IwBBIGsiAiQAAn8gACgCAEGA -gICAeEcEQCABIAAoAgQgACgCCBC/AQwBCyACQRBqIAAoAgwoAgAiAEEIaikCADcDACACQRhqIABB -EGopAgA3AwAgAiAAKQIANwMIIAEoAgAgASgCBCACQQhqEDwLIAJBIGokAAt8AQF/IwBBQGoiBSQA -IAUgATYCDCAFIAA2AgggBSADNgIUIAUgAjYCECAFQQI2AhwgBUGE68AANgIYIAVCAjcCJCAFIAVB -EGqtQoCAgIDwC4Q3AzggBSAFQQhqrUKAgICAgAyENwMwIAUgBUEwajYCICAFQRhqIAQQoQEAC3AB -AX8jAEEQayIBJAAgACgCACIAIAAoAggiAkEBazYCCAJAIAJBAUYEQCAAKAIAIABBBGooAgAiA0EB -ELYBRQ0BIAMQzwEgAEEMEM8BCyABQRBqJAAPC0G0tsAAQSsgAUEPakGktsAAQfC2wAAQfQALzQIB -A38jAEEwayIDJAAgAyACNgIEIAMgATYCACADQQI2AgwgA0HwkcAANgIIIANCAjcCFCADIAOtQoCA -gIDQAoQ3AyggAyAArUKAgICA8AGENwMgIAMgA0EgajYCEAJ/IwBBEGsiAiQAIANBCGoiACgCDCEB -AkACfwJAAkACQAJAAkAgACgCBA4CAAECCyABDQFBASEFQQAhAEEBIQEMAwsgAUUNAQsgAkEEaiAA -EEcgAigCDCEAIAIoAgghASACKAIEDAILIAAoAgAiASgCBCIAQQBIDQIgASgCACEFIABFBEBBASEB -QQAhAAwBC0H5gcEALQAAGkEBIQQgAEEBEMMBIgFFDQILIAAEQCABIAUgAPwKAAALIAALIQQgASAA -ELkBIAQEQCABIAQQzwELIAJBEGokAAwBCyAEIABB9JLAABC1AQALIANBMGokAAtqAgF/AX4jAEEw -ayIDJAAgAyABNgIEIAMgADYCACADQQI2AgwgA0HQ6cAANgIIIANCAjcCFCADQoCAgICACSIEIAOt -hDcDKCADIAQgA0EEaq2ENwMgIAMgA0EgajYCECADQQhqIAIQoQEAC2gBAX8CQCADQQBIDQACQCAD -RQRAQQEhAQwBC0H5gcEALQAAGkEBIQQgA0EBEMMBIgFFDQELIAMEQCABIAIgA/wKAAALIAAgAzYC -CCAAIAE2AgQgACADNgIADwsgBCADQfi0wAAQtQEAC2kAIwBBMGsiACQAQfiBwQAtAABFBEAgAEEw -aiQADwsgAEECNgIMIABBzMfAADYCCCAAQgE3AhQgACABNgIsIAAgAEEsaq1CgICAgIAJhDcDICAA -IABBIGo2AhAgAEEIakH0x8AAEKEBAAucAgIDfwF+IwBBEGsiASQAIAFBqILBADYCBCAAQbCCwQAt -AABBA0cEfyABIAFBBGo2AgggASABQQhqNgIMIAFBDGohAiMAQSBrIgAkAAJAAkACQAJAAkACQAJA -QbCCwQAtAABBAWsOAwIEAQALQbCCwQBBAjoAACACKAIAIgMoAgAhAiADQQA2AgAgAkUNAiACKAIA -QoAINwMAQbCCwQBBAzoAAAsgAEEgaiQADAQLIABBADYCGCAAQQE2AgwgAEG4rMAANgIIDAILQfyt -wAAQ1wEACyAAQQA2AhggAEEBNgIMIABB+KzAADYCCAsgAEIENwIQIABBCGpB+K7AABChAQALIAEo -AgQFQaiCwQALKQMAELEBIAFBEGokAFALWQECfyMAQRBrIgIkACAAQQRqIQMCfyAAKAIAQQFGBEAg -AiADNgIMIAFBqoPAAEEDIAJBDGoQYQwBCyACIAM2AgggAUGog8AAQQIgAkEIahBhCyACQRBqJAAL -XgEBfyMAQTBrIgIkACACIAE2AgwgAiAANgIIIAJBAjYCFCACQeyOwAA2AhAgAkIBNwIcIAIgAkEI -aq1CgICAgIAChDcDKCACIAJBKGo2AhggAkEQahBjIAJBMGokAAteAQF/IwBBMGsiAiQAIAIgATYC -DCACIAA2AgggAkECNgIUIAJBkI/AADYCECACQgE3AhwgAiACQQhqrUKAgICAgAKENwMoIAIgAkEo -ajYCGCACQRBqEGMgAkEwaiQAC1sBAX8gASgCACIEQQFxBEAgACABIAQgBEF+cSACIAMQbg8LIAQg -BCgCCCIBQQFqNgIIIAFBAE4EQCAAIAQ2AgwgACADNgIIIAAgAjYCBCAAQYC3wAA2AgAPCwALWAEB -fyABKAIAIgRBAXEEQCAAIAEgBCAEIAIgAxBuDwsgBCAEKAIIIgFBAWo2AgggAUEATgRAIAAgBDYC -DCAAIAM2AgggACACNgIEIABBgLfAADYCAA8LAAtOACMAQSBrIgAkACAAQQE2AgQgAEGovcAANgIA -IABCATcCDCAAQpC9wICgBzcDGCAAIABBGGo2AgggASgCACABKAIEIAAQPCAAQSBqJAALSwAgASgC -ACIBQQFxBEAgAUF+cSEBIAMEQCABIAIgA/wKAAALIAAgAzYCCCAAIAE2AgQgACACIANqIAFrNgIA -DwsgACABIAIgAxBbC0sBAX8gACgCACAAKAIIIgNrIAJJBEAgACADIAJBAUEBEFcgACgCCCEDCyAC -BEAgACgCBCADaiABIAL8CgAACyAAIAIgA2o2AghBAAtHAQF/IAAoAgAgACgCCCIDayACSQRAIAAg -AyACEF8gACgCCCEDCyACBEAgACgCBCADaiABIAL8CgAACyAAIAIgA2o2AghBAAtNAQF/IwBBMGsi -ASQAIAFBATYCDCABQejowAA2AgggAUIBNwIUIAEgAUEvaq1CgICAgOALhDcDICABIAFBIGo2AhAg -AUEIaiAAEKEBAAtEACABKAIAIgFBAXEEQCADBEAgASACIAP8CgAACyAAIAM2AgggACABNgIEIAAg -AiADaiABazYCAA8LIAAgASACIAMQWws6AQF/IwBBIGsiACQAIABBADYCGCAAQQE2AgwgAEH4yMAA -NgIIIABCBDcCECAAQQhqQazJwAAQoQEAC0cBAX8gACgCACAAKAIIIgNrIAJJBEAgACADIAIQaCAA -KAIIIQMLIAIEQCAAKAIEIANqIAEgAvwKAAALIAAgAiADajYCCEEAC0EBAn8jAEEQayICJAAgAkEI -aiAAKAIAJQEQCyACKAIIIgMgAigCDCIAIAEQ7AEgAARAIAMgABDPAQsgAkEQaiQAC08BAn8gACgC -BCECIAAoAgAhAwJAIAAoAggiAC0AAEUNACADQazrwABBBCACKAIMEQEARQ0AQQEPCyAAIAFBCkY6 -AAAgAyABIAIoAhARAAALQgEBfyAAKAIAIgAoAjAiAQRAIAAoAjQgARDPAQsCQCAAQX9GDQAgACAA -KAIEQQFrIgE2AgQgAQ0AIABByAAQzwELC08BAn9B+YHBAC0AABogASgCBCECIAEoAgAhA0EIQQQQ -wwEiAUUEQEEEQQgQ6gEACyABIAI2AgQgASADNgIAIABBlMjAADYCBCAAIAE2AgALnnQDI38afgF8 -IAEoAggiA0GAgIABcSECIAArAwAhPyADQYCAgIABcUUEQCABIAJBAEchAUEAIQAjAEGAAWsiByQA -ID+9ISUCf0EDID+ZRAAAAAAAAPB/YQ0AGkECICVCgICAgICAgPj/AIMiJkKAgICAgICA+P8AUQ0A -GiAlQv////////8HgyIpQoCAgICAgIAIhCAlQgGGQv7///////8PgyAlQjSIp0H/D3EiABsiJ0IB -gyEoICZQBEBBBCApUA0BGiAAQbMIayEAQgEhJiAoUAwBC0KAgICAgICAICAnQgGGICdCgICAgICA -gAhRIgIbISdCAkIBIAIbISZBy3dBzHcgAhsgAGohACAoUAshAiAHIAA7AXggByAmNwNwIAdCATcD -aCAHICc3A2AgByACOgB6An8CQAJAAkAgAkECayICBEBBASEAQfPnwABB9OfAACAlQgBTIgMbQfPn -wABBASADGyABGyEXICVCP4inIAFyIRtBAyACIAJBA08bQQJrDgIDAgELIAdBAzYCKCAHQfXnwAA2 -AiQgB0ECOwEgQQEhF0EBIQAgB0EgagwDCyAHQQM2AiggB0H458AANgIkIAdBAjsBICAHQSBqDAIL -IAdBIGohBiAHQQ9qIQwjAEEwayIDJAACQAJAAn8CQAJAAkACQAJAAkACQAJAIAdB4ABqIgApAwAi -JVBFBEAgACkDCCInUA0BIAApAxAiJlANAiAlICZ8IiYgJVQNAyAlICdUDQQgJkKAgICAgICAgCBa -DQUgAyAALwEYIgA7AQggAyAlICd9Iic3AwAgACAAQSBrIAAgJkKAgICAEFQiARsiAkEQayACICZC -IIYgJiABGyImQoCAgICAgMAAVCIBGyICQQhrIAIgJkIQhiAmIAEbIiZCgICAgICAgIABVCIBGyIC -QQRrIAIgJkIIhiAmIAEbIiZCgICAgICAgIAQVCIBGyICQQJrIAIgJkIEhiAmIAEbIiZCgICAgICA -gIDAAFQiARsgJkIChiAmIAEbIihCAFkiAmsiAWvBIgpBAEgNBiADQn8gCq0iKYgiJiAngzcDECAm -ICdUDQogAyAAOwEIIAMgJTcDACADICUgJoM3AxAgJSAmVg0KQaB/IAFrwUHQAGxBsKcFakHOEG0i -AEHRAE8NByAAQQR0IgBBuNjAAGopAwAiKkL/////D4MiJiAlIClCP4MiJYYiK0IgiCI1fiIsQiCI -IjEgKkIgiCIpIDV+IjJ8ICkgK0L/////D4MiKn4iK0IgiCI2fCEzICxC/////w+DICYgKn5CIIh8 -ICtC/////w+DfCI3QoCAgIAIfEIgiCErQgFBACABIABBwNjAAGovAQBqa0E/ca0iLIYiKkIBfSEu -ICYgJyAlhiIlQiCIIid+Ii1C/////w+DICYgJUL/////D4MiJX5CIIh8ICUgKX4iJUL/////D4N8 -Ij5CgICAgAh8QiCIITQgJyApfiE4ICVCIIghOSAtQiCIITogAEHC2MAAai8BACEBICkgKCACrYYi -JUIgiCI7fiI8ICYgO34iJ0IgiCIvfCApICVC/////w+DIiV+IihCIIgiMHwgJ0L/////D4MgJSAm -fkIgiHwgKEL/////D4N8Ij1CgICAgAh8QiCIfEIBfCItICyIpyIAQZDOAE8EQCAAQcCEPUkNCSAA -QYDC1y9PBEBBCEEJIABBgJTr3ANJIgIbIQpBgMLXL0GAlOvcAyACGwwLC0EGQQcgAEGAreIESSIC -GyEKQcCEPUGAreIEIAIbDAoLIABB5ABPBEBBAkEDIABB6AdJIgIbIQpB5ABB6AcgAhsMCgtBCkEB -IABBCUsiChsMCQtBj9TAAEEcQYjjwAAQlgEAC0G81MAAQR1BmOPAABCWAQALQezUwABBHEGo48AA -EJYBAAtB0NbAAEE2QcjkwAAQlgEAC0GI1sAAQTdBuOTAABCWAQALQcjjwABBLUH448AAEJYBAAtB -49HAAEEdQaTSwAAQlgEACyAAQdEAQfjiwAAQgAEAC0EEQQUgAEGgjQZJIgIbIQpBkM4AQaCNBiAC -GwshAiArIDN8ITMgLSAugyEmIAogAWtBAWohBSAtIDggOnwgOXwgNHx9IjRCAXwiKCAugyEnQQAh -AQJAAkACQAJAAkACQAJAAkADQCAAIAJuIQsgAUERRg0CIAEgDGoiDiALQTBqIg06AAACQCAAIAIg -C2xrIgCtICyGIisgJnwiJSAoWgRAIAEgCkcNASABQQFqIQFCASElA0AgJSEoICchKSABQRFPDQYg -ASAMaiAmQgp+IiYgLIinQTBqIgI6AAAgAUEBaiEBICVCCn4hJSAnQgp+IicgJiAugyImWA0ACyAl -IC0gM31+IiwgJXwhKyAnICZ9ICpUIgANByAsICV9IiwgJlYNAwwHCyAoICV9IicgAq0gLIYiKFQh -AiAtIDN9IixCAXwhKiAnIChUICUgLEIBfSIsWnINBSA9QoCAgIAIfEIgiCItIC8gMHx8IDx8ISdC -AiA5IDp8ID5CgICAgAh8QiCIfCA4fCAmICh8IiUgK3x8fSEuQgAgMSA2fCA3QoCAgIAIfEIgiHwi -MSAyfCAmICt8fH0hMiAlIDF8ICkgNSA7fX58IC99IDB9IC19ISkDQCAlICt8Ii8gLFQgJyAyfCAp -ICt8WnJFBEAgJiArfCElQQAhAgwHCyAOIA1BAWsiDToAACAmICh8ISYgJyAufCEtICwgL1YEQCAo -ICl8ISkgJSAofCElICcgKH0hJyAoIC1YDQELCyAoIC1WIQIgJiArfCElDAULIAFBAWohASACQQpJ -IAJBCm4hAkUNAAtBiOTAABCcAQALIAEgDGpBAWshCiAqIDEgNnwgN0KAgICACHxCIIh8IDJ8Qgp+ -IC8gMHwgPUKAgICACHxCIIh8IDx8Qgp+fSAofnwhLSApQgp+ICYgKnx9IS4gLCAmfSEvQgAhKQNA -ICYgKnwiJSAsVCApIC98ICYgLXxackUEQEEAIQAMBQsgCiACQQFrIgI6AAAgKSAufCIwICpUIQAg -JSAsWg0FICkgKn0hKSAlISYgKiAwWA0ACwwEC0ERQRFBmOTAABCAAQALIAFBEUGo5MAAEIABAAsC -QCAlICpaIAJyDQAgKiAlICh8IiZYICogJX0gJiAqfVRxDQAgBkEANgIADAQLICUgNEIDfVggJUIC -WnFFBEAgBkEANgIADAQLIAYgBTsBCCAGIAFBAWo2AgQMAgsgJiElCwJAICUgK1ogAHINACArICUg -KnwiJlggKyAlfSAmICt9VHENACAGQQA2AgAMAgsgJSAoQlh+ICd8WCAlIChCFH5acUUEQCAGQQA2 -AgAMAgsgBiAFOwEIIAYgATYCBAsgBiAMNgIACyADQTBqJAAMAQsgA0EANgIYIwBBEGsiACQAIAAg -AzYCDCAAIANBEGo2AgggAEEIakHg6cAAIABBDGpB4OnAACADQRhqQbTSwAAQUAALAkAgBygCIARA -IAdB2ABqIAdBKGooAgA2AgAgByAHKQIgNwNQDAELIAdB0ABqIQ8gB0EPaiENIwBBoAprIgEkAAJA -AkACQAJAAkACQAJAAkAgB0HgAGoiACkDACIlUEUEQCAAKQMIIiZQRQRAIAApAxAiJ1BFBEAgJSAl -ICd8IihYBEAgJSAmWgRAIAAsABohGCAALgEYIQAgASAlPgIAIAFBAUECICVCgICAgBBUIgIbNgKg -ASABQQAgJUIgiKcgAhs2AgQgAUEIakEAQZgB/AsAIAEgJj4CpAEgAUEBQQIgJkKAgICAEFQiAhs2 -AsQCIAFBACAmQiCIpyACGzYCqAEgAUGsAWpBAEGYAfwLACABICc+AsgCIAFBAUECICdCgICAgBBU -IgIbNgLoAyABQQAgJ0IgiKcgAhs2AswCIAFB0AJqQQBBmAH8CwAgAUHwA2pBAEGcAfwLACABQQE2 -AuwDIAFBATYCjAUgAKwgKEIBfXl9QsKawegEfkKAoc2gtAJ8QiCIpyICwSEOAkAgAEEATgRAIAEg -ABAtGiABQaQBaiAAEC0aIAFByAJqIAAQLRoMAQsgAUHsA2pBACAAa8EQLRoLAkAgDkEASARAIAFB -ACAOa0H//wNxIgAQKyABQaQBaiAAECsgAUHIAmogABArDAELIAFB7ANqIAJB//8BcRArCyABKAKg -ASEDIAFB/AhqIAFBoAH8CgAAIAEgAzYCnAoCQAJAAkACQCABKALoAyIGIAMgAyAGSRsiAkEoTQRA -IAJFBEBBACECDAQLIAJBAXEhCyACQQFHDQEMAgsMDAsgAkE+cSERIAFB/AhqIQAgAUHIAmohBQNA -IAAgCCAAKAIAIhIgBSgCAGoiCmoiCDYCACAAQQRqIgwgDCgCACITIAVBBGooAgBqIgwgCiASSSAI -IApJcmoiCjYCACAMIBNJIAogDElyIQggBUEIaiEFIABBCGohACARIAlBAmoiCUcNAAsLIAsEfyAJ -QQJ0IgAgAUH8CGpqIgogCigCACIKIAFByAJqIABqKAIAaiIAIAhqIgk2AgAgACAKSSAAIAlLcgUg -CAtFDQAgAkEoRg0BIAFB/AhqIAJBAnRqQQE2AgAgAkEBaiECCyABIAI2ApwKIAIgASgCjAUiCSAC -IAlLGyIAQSlJBEAgAEECdCEAAkACQAJ/AkADQCAARQ0BIABBBGsiACABQewDamooAgAiAiAAIAFB -/AhqaigCACIKRg0ACyACIApLIAIgCklrDAELQX9BACAAGwsgGE4EQAJAIANFBEBBACEDDAELIANB -AWtB/////wNxIgBBAWoiAkEDcSEFAkAgAEEDSQRAIAEhAEIAISUMAQsgAkH8////B3EhCiABIQBC -ACElA0AgACAANQIAQgp+ICV8IiU+AgAgAEEEaiICIAI1AgBCCn4gJUIgiHwiJT4CACAAQQhqIgIg -AjUCAEIKfiAlQiCIfCIlPgIAIABBDGoiAiACNQIAQgp+ICVCIIh8IiY+AgAgJkIgiCElIABBEGoh -ACAKQQRrIgoNAAsLIAUEQANAIAAgADUCAEIKfiAlfCImPgIAIABBBGohACAmQiCIISUgBUEBayIF -DQALCyAmQoCAgIAQVA0AIANBKEYNAyABIANBAnRqICU+AgAgA0EBaiEDCyABIAM2AqABIAEoAsQC -IgJBKU8NDSABAn9BACACRQ0AGiACQQFrQf////8DcSIAQQFqIgNBA3EhBQJAIABBA0kEQCABQaQB -aiEAQgAhJQwBCyADQfz///8HcSEKIAFBpAFqIQBCACElA0AgACAANQIAQgp+ICV8IiU+AgAgAEEE -aiIDIAM1AgBCCn4gJUIgiHwiJT4CACAAQQhqIgMgAzUCAEIKfiAlQiCIfCIlPgIAIABBDGoiAyAD -NQIAQgp+ICVCIIh8IiY+AgAgJkIgiCElIABBEGohACAKQQRrIgoNAAsLIAUEQANAIAAgADUCAEIK -fiAlfCImPgIAIABBBGohACAmQiCIISUgBUEBayIFDQALCyACICZCgICAgBBUDQAaIAJBKEYNESAB -QaQBaiACQQJ0aiAlPgIAIAJBAWoLNgLEAiABIAYEfyAGQQFrQf////8DcSIAQQFqIgJBA3EhBQJA -IABBA0kEQCABQcgCaiEAQgAhJQwBCyACQfz///8HcSEKIAFByAJqIQBCACElA0AgACAANQIAQgp+ -ICV8IiU+AgAgAEEEaiICIAI1AgBCCn4gJUIgiHwiJT4CACAAQQhqIgIgAjUCAEIKfiAlQiCIfCIl -PgIAIABBDGoiAiACNQIAQgp+ICVCIIh8IiY+AgAgJkIgiCElIABBEGohACAKQQRrIgoNAAsLIAUE -QANAIAAgADUCAEIKfiAlfCImPgIAIABBBGohACAmQiCIISUgBUEBayIFDQALCyAmQoCAgIAQVARA -IAEgBjYC6AMMAwsgBkEoRg0RIAFByAJqIAZBAnRqICU+AgAgBkEBagVBAAs2AugDDAELIA5BAWoh -DgsgAUGQBWoiAiABQewDaiIAQaAB/AoAACABIAk2ArAGIAJBARAtIR0gASgCjAUhAiABQbQGaiID -IABBoAH8CgAAIAEgAjYC1AcgA0ECEC0hHiABKAKMBSECIAFB2AdqIgMgAEGgAfwKAAAgASACNgL4 -CCADQQMQLSEfAkACQAJAAkACQAJAIAEoAvgIIhIgASgCoAEiCSAJIBJJGyICQShNBEAgAUGMBWoh -ICABQbAGaiEhIAFB1AdqISIgASgCjAUhESABKAKwBiETIAEoAtQHIRlBACEGA0AgBiEKIAJBAnQh -AAJ/AkACQAJAA0AgAEUNASAAICJqIQMgAEEEayIAIAFqKAIAIgYgAygCACIDRg0ACyADIAZLDQEM -AgsgAEUNAQsgCSECQQAMAQsgAgRAQQEhCEEAIQkgAkEBRwRAIAJBPnEhDCABIgBB2AdqIQUDQCAA -IAggACgCACILIAUoAgBBf3NqIgNqIgg2AgAgAEEEaiIGIAYoAgAiECAFQQRqKAIAQX9zaiIGIAMg -C0kgAyAIS3JqIgM2AgAgBiAQSSADIAZJciEIIAVBCGohBSAAQQhqIQAgDCAJQQJqIglHDQALCyAC -QQFxBH8gASAJQQJ0IgBqIgMgAygCACIDIAAgH2ooAgBBf3NqIgAgCGoiBjYCACAAIANJIAAgBkty -BSAIC0UNFgsgASACNgKgAUEICyELIBkgAiACIBlJGyIGQSlPDQMgBkECdCEAAkACQAJAA0AgAEUN -ASAAICFqIQMgAEEEayIAIAFqKAIAIgkgAygCACIDRg0ACyADIAlNDQEgAiEGDAILIABFDQAgAiEG -DAELIAYEQEEBIQhBACEJIAZBAUcEQCAGQT5xIQwgASIAQbQGaiEFA0AgACAIIAAoAgAiECAFKAIA -QX9zaiICaiIINgIAIABBBGoiAyADKAIAIhQgBUEEaigCAEF/c2oiAyACIBBJIAIgCEtyaiICNgIA -IAMgFEkgAiADSXIhCCAFQQhqIQUgAEEIaiEAIAwgCUECaiIJRw0ACwsgBkEBcQR/IAEgCUECdCIA -aiICIAIoAgAiAiAAIB5qKAIAQX9zaiIAIAhqIgM2AgAgACACSSAAIANLcgUgCAtFDRYLIAEgBjYC -oAEgC0EEciELCyATIAYgBiATSRsiA0EpTw0EIANBAnQhAAJAAkACQANAIABFDQEgACAgaiECIABB -BGsiACABaigCACIJIAIoAgAiAkYNAAsgAiAJTQ0BIAYhAwwCCyAARQ0AIAYhAwwBCyADBEBBASEI -QQAhCSADQQFHBEAgA0E+cSEMIAEiAEGQBWohBQNAIAAgCCAAKAIAIhAgBSgCAEF/c2oiAmoiCDYC -ACAAQQRqIgYgBigCACIUIAVBBGooAgBBf3NqIgYgAiAQSSACIAhLcmoiAjYCACAGIBRJIAIgBkly -IQggBUEIaiEFIABBCGohACAMIAlBAmoiCUcNAAsLIANBAXEEfyABIAlBAnQiAGoiAiACKAIAIgIg -ACAdaigCAEF/c2oiACAIaiIGNgIAIAAgAkkgACAGS3IFIAgLRQ0WCyABIAM2AqABIAtBAmohCwsg -ESADIAMgEUkbIgJBKU8NEyACQQJ0IQACQAJAAkADQCAARQ0BIABBBGsiACABaigCACIGIAAgAUHs -A2pqKAIAIglGDQALIAYgCU8NASADIQIMAgsgAEUNACADIQIMAQsgAgRAQQEhCEEAIQkgAkEBRwRA -IAJBPnEhDCABIgBB7ANqIQUDQCAAIAggACgCACIQIAUoAgBBf3NqIgNqIgg2AgAgAEEEaiIGIAYo -AgAiFCAFQQRqKAIAQX9zaiIGIAMgEEkgAyAIS3JqIgM2AgAgBiAUSSADIAZJciEIIAVBCGohBSAA -QQhqIQAgDCAJQQJqIglHDQALCyACQQFxBH8gASAJQQJ0IgBqIgMgAygCACIDIAFB7ANqIABqKAIA -QX9zaiIAIAhqIgY2AgAgACADSSAAIAZLcgUgCAtFDRYLIAEgAjYCoAEgC0EBaiELCyAKQRFGDQYg -CiANaiALQTBqOgAAIAEoAsQCIgwgAiACIAxJGyIAQSlPDRUgCkEBaiEGIABBAnQhAAJ/AkADQCAA -RQ0BIABBBGsiACABaigCACIDIAAgAUGkAWpqKAIAIglGDQALIAMgCUsgAyAJSWsMAQtBf0EAIAAb -CyEUIAFB/AhqIAFBoAH8CgAAIAEgAjYCnAogASgC6AMiCyACIAIgC0kbIgNBKEsNBQJAIANFBEBB -ACEDDAELQQAhCEEAIQkgA0EBRwRAIANBPnEhIyABQfwIaiEAIAFByAJqIQUDQCAAIAggACgCACIk -IAUoAgBqIhBqIhU2AgAgAEEEaiIIIAgoAgAiFiAFQQRqKAIAaiIIIBAgJEkgECAVS3JqIhA2AgAg -CCAWSSAIIBBLciEIIAVBCGohBSAAQQhqIQAgIyAJQQJqIglHDQALCyADQQFxBH8gCUECdCIAIAFB -/AhqaiIJIAkoAgAiCSABQcgCaiAAaigCAGoiACAIaiIFNgIAIAAgCUkgACAFS3IFIAgLRQ0AIANB -KEYNFyABQfwIaiADQQJ0akEBNgIAIANBAWohAwsgASADNgKcCiADIBEgAyARSxsiAEEpTw0VIABB -AnQhAAJ/AkADQCAARQ0BIABBBGsiACABQewDamooAgAiAyAAIAFB/AhqaigCACIJRg0ACyADIAlL -IAMgCUlrDAELQX9BACAAGwsgGE4iACAUIBhIIgNFcUUEQCAADRMgAw0DDBILQQAhAyABAn9BACAC -RQ0AGiACQQFrQf////8DcSIAQQFqIgpBA3EhBQJAIABBA0kEQCABIQBCACElDAELIApB/P///wdx -IQogASEAQgAhJQNAIAAgADUCAEIKfiAlfCIlPgIAIABBBGoiCSAJNQIAQgp+ICVCIIh8IiU+AgAg -AEEIaiIJIAk1AgBCCn4gJUIgiHwiJT4CACAAQQxqIgkgCTUCAEIKfiAlQiCIfCImPgIAICZCIIgh -JSAAQRBqIQAgCkEEayIKDQALCyAFBEADQCAAIAA1AgBCCn4gJXwiJj4CACAAQQRqIQAgJkIgiCEl -IAVBAWsiBQ0ACwsgAiAmQoCAgIAQVA0AGiACQShGDRcgASACQQJ0aiAlPgIAIAJBAWoLIgk2AqAB -AkAgDEUNACAMQQFrQf////8DcSIAQQFqIgJBA3EhBQJAIABBA0kEQCABQaQBaiEAQgAhJQwBCyAC -Qfz///8HcSEKIAFBpAFqIQBCACElA0AgACAANQIAQgp+ICV8IiU+AgAgAEEEaiICIAI1AgBCCn4g -JUIgiHwiJT4CACAAQQhqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIABBDGoiAiACNQIAQgp+ICVCIIh8 -IiY+AgAgJkIgiCElIABBEGohACAKQQRrIgoNAAsLIAUEQANAIAAgADUCAEIKfiAlfCImPgIAIABB -BGohACAmQiCIISUgBUEBayIFDQALCyAmQoCAgIAQVARAIAwhAwwBCyAMQShGDRcgAUGkAWogDEEC -dGogJT4CACAMQQFqIQMLIAEgAzYCxAICQCALRQRAQQAhCwwBCyALQQFrQf////8DcSIAQQFqIgJB +fn9/AX9gB39/f39/f38Bf2AEf39/fwR/f39/YAJ/fwR/f39/YAN/f38Df39/YAF/A39/f2AFf399 +f38AYAR/fX9/AGAFf398f38AYAR/fH9/AGAFf39+f38AYAR/fn9/AGACf34BfgL1ECgYLi9oZl94 +ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX2xvZ19jNWQxYThkYzA5ODIxMmFmAAIYLi9oZl94ZXRf +dGhpbl93YXNtX2JnLmpzFV9fd2JpbmRnZW5fc3RyaW5nX25ldwAUGC4vaGZfeGV0X3RoaW5fd2Fz +bV9iZy5qcxVfX3diaW5kZ2VuX3N0cmluZ19nZXQACxguL2hmX3hldF90aGluX3dhc21fYmcuanMU +X193YmluZGdlbl9pc19vYmplY3QABhguL2hmX3hldF90aGluX3dhc21fYmcuanMXX193YmluZGdl +bl9pc191bmRlZmluZWQABhguL2hmX3hldF90aGluX3dhc21fYmcuanMNX193YmluZGdlbl9pbgAV +GC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxRfX3diaW5kZ2VuX2Vycm9yX25ldwAUGC4vaGZfeGV0 +X3RoaW5fd2FzbV9iZy5qcxlfX3diaW5kZ2VuX2pzdmFsX2xvb3NlX2VxABUYLi9oZl94ZXRfdGhp +bl93YXNtX2JnLmpzFl9fd2JpbmRnZW5fYm9vbGVhbl9nZXQABhguL2hmX3hldF90aGluX3dhc21f +YmcuanMVX193YmluZGdlbl9udW1iZXJfZ2V0AAsYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzFF9f +d2JpbmRnZW5fYXNfbnVtYmVyABgYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzHV9fd2JnX1N0cmlu +Z184ZjBlYjM5YTRhNGMyZjY2AAsYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzFV9fd2JpbmRnZW5f +bnVtYmVyX25ldwAZGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcyRfX3diZ19nZXR3aXRocmVma2V5 +XzFkYzM2MWJkMTAwNTNiZmUAERguL2hmX3hldF90aGluX3dhc21fYmcuanMaX193Ymdfc2V0XzNm +MWQwYjk4NGVkMjcyZWQAGhguL2hmX3hldF90aGluX3dhc21fYmcuanMaX193YmdfZ2V0X2I5Yjkz +MDQ3ZmUzY2Y0NWIAGxguL2hmX3hldF90aGluX3dhc21fYmcuanMdX193YmdfbGVuZ3RoX2UyZDJh +NDkxMzJjMWIyNTYABhguL2hmX3hldF90aGluX3dhc21fYmcuanMaX193YmdfbmV3Xzc4ZmViMTA4 +YjY0NzI3MTMADBguL2hmX3hldF90aGluX3dhc21fYmcuanMWX193YmluZGdlbl9pc19mdW5jdGlv +bgAGGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxtfX3diZ19uZXh0XzI1ZmVhZGZjMDkxM2ZlYTkA +ChguL2hmX3hldF90aGluX3dhc21fYmcuanMbX193YmdfbmV4dF82NTc0ZTFhOGE2MmQxMDU1AAoY +Li9oZl94ZXRfdGhpbl93YXNtX2JnLmpzG19fd2JnX2RvbmVfNzY5ZTVlZGU0YjMxYzY3YgAGGC4v +aGZfeGV0X3RoaW5fd2FzbV9iZy5qcxxfX3diZ192YWx1ZV9jZDFmZmE3YjFhYjc5NGYxAAoYLi9o +Zl94ZXRfdGhpbl93YXNtX2JnLmpzH19fd2JnX2l0ZXJhdG9yXzlhMjRjODhkZjg2MGRjNjUADBgu +L2hmX3hldF90aGluX3dhc21fYmcuanMaX193YmdfZ2V0XzY3YjJiYTYyZmMzMGRlMTIAERguL2hm +X3hldF90aGluX3dhc21fYmcuanMbX193YmdfY2FsbF82NzJhNGQyMTYzNGQ0YTI0ABEYLi9oZl94 +ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX25ld180MDVlMjJmMzkwNTc2Y2UyAAwYLi9oZl94ZXRf +dGhpbl93YXNtX2JnLmpzGl9fd2JnX3NldF8zNzgzNzAyM2YzZDc0MGU4ABwYLi9oZl94ZXRfdGhp +bl93YXNtX2JnLmpzHl9fd2JnX2lzQXJyYXlfYTFlYWI3ZTBkMDY3MzkxYgAGGC4vaGZfeGV0X3Ro +aW5fd2FzbV9iZy5qcy1fX3diZ19pbnN0YW5jZW9mX0FycmF5QnVmZmVyX2UxNDU4NTQzMmUzNzM3 +ZmMABhguL2hmX3hldF90aGluX3dhc21fYmcuanMkX193YmdfaXNTYWZlSW50ZWdlcl8zNDNlMmJl +ZWVlY2UxYmIwAAYYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzHV9fd2JnX2J1ZmZlcl82MDljYzNl +ZWU1MWVkMTU4AAoYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX25ld19hMTIwMDJhN2Y5 +MWM3NWJlAAoYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX3NldF82NTU5NWJkZDg2OGIz +MDA5AB0YLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzHV9fd2JnX2xlbmd0aF9hNDQ2MTkzZGMyMmMx +MmY4AAYYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzLF9fd2JnX2luc3RhbmNlb2ZfVWludDhBcnJh +eV8xNzE1NmJjZjExODA4NmE5AAYYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzF19fd2JpbmRnZW5f +ZGVidWdfc3RyaW5nAAsYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzEF9fd2JpbmRnZW5fdGhyb3cA +AhguL2hmX3hldF90aGluX3dhc21fYmcuanMRX193YmluZGdlbl9tZW1vcnkADBguL2hmX3hldF90 +aGluX3dhc21fYmcuanMfX193YmluZGdlbl9pbml0X2V4dGVybnJlZl90YWJsZQANA9IB0AEeBx8C +AgACAgADCQMEAxIDAAUBAAEAAQABEgEEAiABAgAhAwcAAgAADg4iAAACFgkDAAIEAAQEAwMPAQcC +AAkCAwUCAgMFDgMWDgIABAICAAMABAIACQMBAwQCBwAAAAQEAwAEAQEFBA0BAAAFAgADBAIAEwAF +IyQlFxcCJg8SBwAJEycpKwUEAAEELQAFAwMABQAABw8AAwABAAkAAAQEAAAFAgICAAAAAgMDBwMD +AwAFAAAAAAAAAAAAAAANDQIAAgAAAgABAgAAAgcHBwcDBAkCcAFpaW8AgAEFAwEAEQYJAX8BQYCA +wAALB98CEQZtZW1vcnkCABJfX3diZ19jaHVua2VyX2ZyZWUAagtjaHVua2VyX25ldwBLEGNodW5r +ZXJfYWRkX2RhdGEAoAEOY2h1bmtlcl9maW5pc2gApAERY29tcHV0ZV94b3JiX2hhc2gAoQERY29t +cHV0ZV9maWxlX2hhc2gAogEZY29tcHV0ZV92ZXJpZmljYXRpb25faGFzaACfAQxjb21wdXRlX2ht +YWMAngERX193YmluZGdlbl9tYWxsb2MAnAESX193YmluZGdlbl9yZWFsbG9jAKUBFF9fd2JpbmRn +ZW5fZXhuX3N0b3JlAMoBF19fZXh0ZXJucmVmX3RhYmxlX2FsbG9jAHATX193YmluZGdlbl9leHBv +cnRfNAEBGV9fZXh0ZXJucmVmX3RhYmxlX2RlYWxsb2MAbQ9fX3diaW5kZ2VuX2ZyZWUAvwEQX193 +YmluZGdlbl9zdGFydAAnCb4BAQBBAQto3gHfAYQBvgG1AYwBTuEB2wHgAfEB8AHdAdwBwgE4xAHi +AbUBjAFPwgFzmgGqAXGpAaoBpgGxAa8BqQGpAasBrAGtAbIBgQF69gH3AYcBiwFdpwFsiAGPAV5v +4wGYAcYBxwHUAX55yAHEAYoBsAHaAagBZVnJAZYBYrQB5AHIAbkB2AGCAbUBjQFU6AHMAcsBzgGV +Ac0B6QGuAXxaa/IBtQGRAVPqAesBwAHCAc8B0AE7d1w+kwHtAQwBDgra+QTQAYkbASB/IAAgACgC +GCIdIAEoABAiJCAAKAIIamoiGyABKAAUIhVqIB0gGyACQf8BcXNBEHciAkHy5rvjA2oiHXNBFHci +G2oiIiACc0EYdyIJIB1qIhwgG3NBGXciDyAAKAIUIhsgASgACCICIAAoAgRqaiIZIAEoAAwiHWog +GSADQiCIp3NBEHciHkH7ouGkBGsiICAbc0EUdyIGaiIKIAEoACgiG2pqIiMgASgALCIZaiAPICMg +ACgCECIhIAEoAAAiDyAAKAIAamoiCCABKAAEIh9qICEgCCADp3NBEHciIUHnzKfQBmoiCHNBFHci +B2oiDiAhc0EYdyINc0EQdyILIAAoAhwiBSABKAAYIiMgACgCDGpqIgwgASgAHCIhaiAFIAwgBEH/ +AXFzQRB3IgRBxpXA1QVrIgVzQRR3IgxqIhEgBHNBGHciECAFaiIFaiISc0EUdyIUaiITIB1qIAYg +ICAKIB5zQRh3IiBqIgZzQRl3IgogDiABKAAgIgRqaiIOIAEoACQiHmogCiAcIA4gEHNBEHciHGoi +CnNBFHciDmoiECAcc0EYdyIWIApqIgogDnNBGXciHGoiDiAbaiAcIA4gBSAMc0EZdyIFICIgASgA +MCIcamoiDCABKAA0IiJqIAwgIHNBEHciICAIIA1qIghqIg0gBXNBFHciBWoiDCAgc0EYdyIXc0EQ +dyIOIAcgCHNBGXciCCARIAEoADgiIGpqIgcgASgAPCIBaiAHIAlzQRB3IgkgBmoiBiAIc0EUdyII +aiIHIAlzQRh3IgkgBmoiBmoiEXNBFHciGGoiGiAcaiALIBNzQRh3IgsgEmoiEiAUc0EZdyIUIAwg +IWpqIgwgD2ogCSAMc0EQdyIJIApqIgogFHNBFHciDGoiFCAJc0EYdyIJIApqIgogDHNBGXciDGoi +EyAVaiAMIBMgBiAIc0EZdyIGIAIgEGpqIgggI2ogBiAIIAtzQRB3IgYgDSAXaiIIaiINc0EUdyIL +aiIMIAZzQRh3IgZzQRB3IhAgBSAIc0EZdyIIIAcgJGpqIgcgImogCCAHIBZzQRB3IgggEmoiB3NB +FHciBWoiEiAIc0EYdyIIIAdqIgdqIhNzQRR3IhZqIhcgG2ogDiAac0EYdyIOIBFqIhEgGHNBGXci +GCAMIB9qaiIMIBlqIAogCCAMc0EQdyIKaiIIIBhzQRR3IgxqIhggCnNBGHciCiAIaiIIIAxzQRl3 +IgxqIhogHGogDCAaIAUgB3NBGXciByAUIB5qaiIFICBqIAcgBSAOc0EQdyIHIAYgDWoiBmoiDnNB +FHciDWoiBSAHc0EYdyIHc0EQdyIMIAYgC3NBGXciBiABIBJqaiILIARqIAYgCSALc0EQdyIJIBFq +IgZzQRR3IgtqIhEgCXNBGHciCSAGaiIGaiISc0EUdyIUaiIaIB5qIBAgF3NBGHciECATaiITIBZz +QRl3IhYgBSAiamoiBSACaiAFIAlzQRB3IgkgCGoiCCAWc0EUdyIFaiIWIAlzQRh3IgkgCGoiCCAF +c0EZdyIFaiIXIA9qIAUgFyAGIAtzQRl3IgYgGCAdamoiCyAkaiAGIAsgEHNBEHciBiAHIA5qIgdq +Ig5zQRR3IgtqIgUgBnNBGHciBnNBEHciECAHIA1zQRl3IgcgESAhamoiDSAgaiAHIAogDXNBEHci +CiATaiIHc0EUdyINaiIRIApzQRh3IgogB2oiB2oiE3NBFHciF2oiGCAcaiAMIBpzQRh3IgwgEmoi +EiAUc0EZdyIUIAUgI2pqIgUgFWogBSAKc0EQdyIKIAhqIgggFHNBFHciBWoiFCAKc0EYdyIKIAhq +IgggBXNBGXciBWoiGiAeaiAFIBogByANc0EZdyIHIBYgGWpqIg0gAWogByAMIA1zQRB3IgcgBiAO +aiIGaiIOc0EUdyINaiIFIAdzQRh3IgdzQRB3IgwgBiALc0EZdyIGIAQgEWpqIgsgH2ogBiAJIAtz +QRB3IgkgEmoiBnNBFHciC2oiESAJc0EYdyIJIAZqIgZqIhJzQRR3IhZqIhogGWogECAYc0EYdyIQ +IBNqIhMgF3NBGXciFyAFICBqaiIFIB1qIAUgCXNBEHciCSAIaiIIIBdzQRR3IgVqIhcgCXNBGHci +CSAIaiIIIAVzQRl3IgVqIhggAmogBSAYIAYgC3NBGXciBiAUIBtqaiILICFqIAYgCyAQc0EQdyIG +IAcgDmoiB2oiDnNBFHciC2oiBSAGc0EYdyIGc0EQdyIQIAcgDXNBGXciByARICJqaiINIAFqIAcg +CiANc0EQdyIKIBNqIgdzQRR3Ig1qIhEgCnNBGHciCiAHaiIHaiIUc0EUdyITaiIYIB5qIAwgGnNB +GHciDCASaiISIBZzQRl3IhYgBSAkamoiBSAPaiAFIApzQRB3IgogCGoiCCAWc0EUdyIFaiIWIApz +QRh3IgogCGoiCCAFc0EZdyIFaiIaIBlqIAUgGiAHIA1zQRl3IgcgFSAXamoiDSAEaiAHIAwgDXNB +EHciByAGIA5qIgZqIg5zQRR3Ig1qIgUgB3NBGHciB3NBEHciDCAGIAtzQRl3IgYgESAfamoiCyAj +aiAGIAkgC3NBEHciCSASaiIGc0EUdyILaiIRIAlzQRh3IgkgBmoiBmoiEnNBFHciF2oiGiAVaiAQ +IBhzQRh3IhAgFGoiFCATc0EZdyITIAEgBWpqIgUgG2ogBSAJc0EQdyIJIAhqIgggE3NBFHciBWoi +EyAJc0EYdyIJIAhqIgggBXNBGXciBWoiGCAdaiAFIBggBiALc0EZdyIGIBYgHGpqIgsgImogBiAL +IBBzQRB3IgYgByAOaiIHaiIOc0EUdyILaiIFIAZzQRh3IgZzQRB3IhAgByANc0EZdyIHIBEgIGpq +Ig0gBGogByAKIA1zQRB3IgogFGoiB3NBFHciDWoiESAKc0EYdyIKIAdqIgdqIhRzQRR3IhZqIhgg +GWogDCAac0EYdyIMIBJqIhIgF3NBGXciFyAFICFqaiIFIAJqIAUgCnNBEHciCiAIaiIIIBdzQRR3 +IgVqIhcgCnNBGHciCiAIaiIIIAVzQRl3IgVqIhogFWogBSAaIAcgDXNBGXciByAPIBNqaiINIB9q +IAcgDCANc0EQdyIHIAYgDmoiBmoiDnNBFHciDWoiBSAHc0EYdyIHc0EQdyIMIAYgC3NBGXciBiAR +ICNqaiILICRqIAYgCSALc0EQdyIJIBJqIgZzQRR3IgtqIhEgCXNBGHciCSAGaiIGaiISc0EUdyIT +aiIaIA9qIBAgGHNBGHciECAUaiIUIBZzQRl3IhYgBCAFamoiBSAcaiAFIAlzQRB3IgkgCGoiCCAW +c0EUdyIFaiIWIAlzQRh3IgkgCGoiCCAFc0EZdyIFaiIYIBtqIAUgGCAGIAtzQRl3IgYgFyAeamoi +CyAgaiAGIAsgEHNBEHciBiAHIA5qIgdqIg5zQRR3IgtqIgUgBnNBGHciBnNBEHciECAHIA1zQRl3 +IgcgASARamoiDSAfaiAHIAogDXNBEHciCiAUaiIHc0EUdyINaiIRIApzQRh3IgogB2oiB2oiFHNB +FHciF2oiGCAVaiAMIBpzQRh3IhUgEmoiDCATc0EZdyISIAUgImpqIgUgHWogBSAKc0EQdyIKIAhq +IgggEnNBFHciBWoiEiAKc0EYdyIKIAhqIgggBXNBGXciBWoiEyAPaiAFIBMgByANc0EZdyIPIAIg +FmpqIgcgI2ogDyAHIBVzQRB3IhUgBiAOaiIPaiIGc0EUdyIHaiIOIBVzQRh3IhVzQRB3Ig0gCyAP +c0EZdyIPIBEgJGpqIgsgIWogDyAJIAtzQRB3Ig8gDGoiCXNBFHciC2oiBSAPc0EYdyIPIAlqIglq +IgxzQRR3IhFqIhMgAmogHiAQIBhzQRh3IgIgFGoiHiAXc0EZdyIQIA4gH2pqIh9qIA8gH3NBEHci +DyAIaiIfIBBzQRR3IghqIg4gD3NBGHciDyAfaiIfIAhzQRl3IghqIhAgHGogECABIAkgC3NBGXci +ASASIBlqaiIZaiABIAIgGXNBEHciASAGIBVqIgJqIhVzQRR3IhlqIhwgAXNBGHciAXNBEHciCSAC +IAdzQRl3IgIgBCAFamoiBCAjaiACIAQgCnNBEHciAiAeaiIEc0EUdyIjaiIeIAJzQRh3IgIgBGoi +BGoiBiAIc0EUdyIKaiIIIAlzQRh3IgkgBmoiBiABIBVqIgEgGXNBGXciFSAeICFqaiIZICJqIBUg +DyAZc0EQdyIVIA0gE3NBGHciGSAMaiIPaiIhc0EUdyIeaiIiczYCDCAAIBsgDyARc0EZdyIPIBwg +IGpqIhxqIAIgHHNBEHciAiAfaiIbIA9zQRR3Ig9qIh8gAnNBGHciAiAbaiIbICQgBCAjc0EZdyIE +IA4gHWpqIh1qIAQgASAZIB1zQRB3IgFqIgRzQRR3IiRqIh1zNgIIIAAgFSAic0EYdyIVICFqIhkg +CHM2AgQgACABIB1zQRh3IgEgBGoiBCAfczYCACAAIAQgJHNBGXcgAnM2AhwgACAGIApzQRl3IBVz +NgIYIAAgDyAbc0EZdyABczYCFCAAIBkgHnNBGXcgCXM2AhALmyQCCX8BfiMAQRBrIggkAAJ/AkAC +QAJAAkACQAJAIABB9QFPBEBBACAAQcz/e0sNBxogAEELaiIBQXhxIQVBxIbBACgCACIJRQ0EQR8h +B0EAIAVrIQQgAEH0//8HTQRAIAVBBiABQQh2ZyIAa3ZBAXEgAEEBdGtBPmohBwsgB0ECdEGog8EA +aigCACIBRQRAQQAhAAwCC0EAIQAgBUEZIAdBAXZrQQAgB0EfRxt0IQMDQAJAIAEoAgRBeHEiBiAF +SQ0AIAYgBWsiBiAETw0AIAEhAiAGIgQNAEEAIQQgASEADAQLIAEoAhQiBiAAIAYgASADQR12QQRx +aigCECIBRxsgACAGGyEAIANBAXQhAyABDQALDAELQcCGwQAoAgAiAkEQIABBC2pB+ANxIABBC0kb +IgVBA3YiAHYiAUEDcQRAAkAgAUF/c0EBcSAAaiIGQQN0IgBBuITBAGoiAyAAQcCEwQBqKAIAIgEo +AggiBEcEQCAEIAM2AgwgAyAENgIIDAELQcCGwQAgAkF+IAZ3cTYCAAsgASAAQQNyNgIEIAAgAWoi +ACAAKAIEQQFyNgIEIAFBCGoMBwsgBUHIhsEAKAIATQ0DAkACQCABRQRAQcSGwQAoAgAiAEUNBiAA +aEECdEGog8EAaigCACICKAIEQXhxIAVrIQQgAiEBA0ACQCACKAIQIgANACACKAIUIgANACABKAIY +IQcCQAJAIAEgASgCDCIARgRAIAFBFEEQIAEoAhQiABtqKAIAIgINAUEAIQAMAgsgASgCCCICIAA2 +AgwgACACNgIIDAELIAFBFGogAUEQaiAAGyEDA0AgAyEGIAIiAEEUaiAAQRBqIAAoAhQiAhshAyAA +QRRBECACG2ooAgAiAg0ACyAGQQA2AgALIAdFDQQCQCABKAIcQQJ0QaiDwQBqIgIoAgAgAUcEQCAB +IAcoAhBHBEAgByAANgIUIAANAgwHCyAHIAA2AhAgAA0BDAYLIAIgADYCACAARQ0ECyAAIAc2Ahgg +ASgCECICBEAgACACNgIQIAIgADYCGAsgASgCFCICRQ0EIAAgAjYCFCACIAA2AhgMBAsgACgCBEF4 +cSAFayICIAQgAiAESSICGyEEIAAgASACGyEBIAAhAgwACwALAkBBAiAAdCIDQQAgA2tyIAEgAHRx +aCIGQQN0IgFBuITBAGoiAyABQcCEwQBqKAIAIgAoAggiBEcEQCAEIAM2AgwgAyAENgIIDAELQcCG +wQAgAkF+IAZ3cTYCAAsgACAFQQNyNgIEIAAgBWoiBiABIAVrIgNBAXI2AgQgACABaiADNgIAQciG +wQAoAgAiBARAIARBeHFBuITBAGohAUHQhsEAKAIAIQICf0HAhsEAKAIAIgVBASAEQQN2dCIEcUUE +QEHAhsEAIAQgBXI2AgAgAQwBCyABKAIICyEEIAEgAjYCCCAEIAI2AgwgAiABNgIMIAIgBDYCCAtB +0IbBACAGNgIAQciGwQAgAzYCACAAQQhqDAgLQcSGwQBBxIbBACgCAEF+IAEoAhx3cTYCAAsCQAJA +IARBEE8EQCABIAVBA3I2AgQgASAFaiIDIARBAXI2AgQgAyAEaiAENgIAQciGwQAoAgAiBkUNASAG +QXhxQbiEwQBqIQBB0IbBACgCACECAn9BwIbBACgCACIFQQEgBkEDdnQiBnFFBEBBwIbBACAFIAZy +NgIAIAAMAQsgACgCCAshBiAAIAI2AgggBiACNgIMIAIgADYCDCACIAY2AggMAQsgASAEIAVqIgBB +A3I2AgQgACABaiIAIAAoAgRBAXI2AgQMAQtB0IbBACADNgIAQciGwQAgBDYCAAsgAUEIagwGCyAA +IAJyRQRAQQAhAkECIAd0IgBBACAAa3IgCXEiAEUNAyAAaEECdEGog8EAaigCACEACyAARQ0BCwNA +IAAgAiAAKAIEQXhxIgMgBWsiBiAESSIHGyEJIAAoAhAiAUUEQCAAKAIUIQELIAIgCSADIAVJIgAb +IQIgBCAGIAQgBxsgABshBCABIgANAAsLIAJFDQAgBUHIhsEAKAIAIgBNIAQgACAFa09xDQAgAigC +GCEHAkACQCACIAIoAgwiAEYEQCACQRRBECACKAIUIgAbaigCACIBDQFBACEADAILIAIoAggiASAA +NgIMIAAgATYCCAwBCyACQRRqIAJBEGogABshAwNAIAMhBiABIgBBFGogAEEQaiAAKAIUIgEbIQMg +AEEUQRAgARtqKAIAIgENAAsgBkEANgIACyAHRQ0CAkAgAigCHEECdEGog8EAaiIBKAIAIAJHBEAg +AiAHKAIQRwRAIAcgADYCFCAADQIMBQsgByAANgIQIAANAQwECyABIAA2AgAgAEUNAgsgACAHNgIY +IAIoAhAiAQRAIAAgATYCECABIAA2AhgLIAIoAhQiAUUNAiAAIAE2AhQgASAANgIYDAILAkACQAJA +AkACQCAFQciGwQAoAgAiAUsEQCAFQcyGwQAoAgAiAE8EQCAFQa+ABGpBgIB8cSICQRB2QAAhACAI +QQRqIgFBADYCCCABQQAgAkGAgHxxIABBf0YiAhs2AgQgAUEAIABBEHQgAhs2AgBBACAIKAIEIgFF +DQkaIAgoAgwhBkHYhsEAIAgoAggiBEHYhsEAKAIAaiIANgIAQdyGwQAgAEHchsEAKAIAIgIgACAC +Sxs2AgACQAJAQdSGwQAoAgAiAgRAQaiEwQAhAANAIAEgACgCACIDIAAoAgQiB2pGDQIgACgCCCIA +DQALDAILQeSGwQAoAgAiAEEAIAAgAU0bRQRAQeSGwQAgATYCAAtB6IbBAEH/HzYCAEG0hMEAIAY2 +AgBBrITBACAENgIAQaiEwQAgATYCAEHEhMEAQbiEwQA2AgBBzITBAEHAhMEANgIAQcCEwQBBuITB +ADYCAEHUhMEAQciEwQA2AgBByITBAEHAhMEANgIAQdyEwQBB0ITBADYCAEHQhMEAQciEwQA2AgBB +5ITBAEHYhMEANgIAQdiEwQBB0ITBADYCAEHshMEAQeCEwQA2AgBB4ITBAEHYhMEANgIAQfSEwQBB +6ITBADYCAEHohMEAQeCEwQA2AgBB/ITBAEHwhMEANgIAQfCEwQBB6ITBADYCAEGEhcEAQfiEwQA2 +AgBB+ITBAEHwhMEANgIAQYCFwQBB+ITBADYCAEGMhcEAQYCFwQA2AgBBiIXBAEGAhcEANgIAQZSF +wQBBiIXBADYCAEGQhcEAQYiFwQA2AgBBnIXBAEGQhcEANgIAQZiFwQBBkIXBADYCAEGkhcEAQZiF +wQA2AgBBoIXBAEGYhcEANgIAQayFwQBBoIXBADYCAEGohcEAQaCFwQA2AgBBtIXBAEGohcEANgIA +QbCFwQBBqIXBADYCAEG8hcEAQbCFwQA2AgBBuIXBAEGwhcEANgIAQcSFwQBBuIXBADYCAEHMhcEA +QcCFwQA2AgBBwIXBAEG4hcEANgIAQdSFwQBByIXBADYCAEHIhcEAQcCFwQA2AgBB3IXBAEHQhcEA +NgIAQdCFwQBByIXBADYCAEHkhcEAQdiFwQA2AgBB2IXBAEHQhcEANgIAQeyFwQBB4IXBADYCAEHg +hcEAQdiFwQA2AgBB9IXBAEHohcEANgIAQeiFwQBB4IXBADYCAEH8hcEAQfCFwQA2AgBB8IXBAEHo +hcEANgIAQYSGwQBB+IXBADYCAEH4hcEAQfCFwQA2AgBBjIbBAEGAhsEANgIAQYCGwQBB+IXBADYC +AEGUhsEAQYiGwQA2AgBBiIbBAEGAhsEANgIAQZyGwQBBkIbBADYCAEGQhsEAQYiGwQA2AgBBpIbB +AEGYhsEANgIAQZiGwQBBkIbBADYCAEGshsEAQaCGwQA2AgBBoIbBAEGYhsEANgIAQbSGwQBBqIbB +ADYCAEGohsEAQaCGwQA2AgBBvIbBAEGwhsEANgIAQbCGwQBBqIbBADYCAEHUhsEAIAFBD2pBeHEi +AEEIayICNgIAQbiGwQBBsIbBADYCAEHMhsEAIARBKGsiAyABIABrakEIaiIANgIAIAIgAEEBcjYC +BCABIANqQSg2AgRB4IbBAEGAgIABNgIADAgLIAIgA0kgASACTXINACAAKAIMIgNBAXENACADQQF2 +IAZGDQMLQeSGwQBB5IbBACgCACIAIAEgACABSRs2AgAgASAEaiEDQaiEwQAhAAJAAkADQCADIAAo +AgAiB0cEQCAAKAIIIgANAQwCCwsgACgCDCIDQQFxDQAgA0EBdiAGRg0BC0GohMEAIQADQAJAIAIg +ACgCACIDTwRAIAIgAyAAKAIEaiIHSQ0BCyAAKAIIIQAMAQsLQdSGwQAgAUEPakF4cSIAQQhrIgM2 +AgBBzIbBACAEQShrIgkgASAAa2pBCGoiADYCACADIABBAXI2AgQgASAJakEoNgIEQeCGwQBBgICA +ATYCACACIAdBIGtBeHFBCGsiACAAIAJBEGpJGyIDQRs2AgRBqITBACkCACEKIANBEGpBsITBACkC +ADcCACADIAo3AghBtITBACAGNgIAQayEwQAgBDYCAEGohMEAIAE2AgBBsITBACADQQhqNgIAIANB +HGohAANAIABBBzYCACAAQQRqIgAgB0kNAAsgAiADRg0HIAMgAygCBEF+cTYCBCACIAMgAmsiAEEB +cjYCBCADIAA2AgAgAEGAAk8EQCACIAAQVQwICyAAQfgBcUG4hMEAaiEBAn9BwIbBACgCACIDQQEg +AEEDdnQiAHFFBEBBwIbBACAAIANyNgIAIAEMAQsgASgCCAshACABIAI2AgggACACNgIMIAIgATYC +DCACIAA2AggMBwsgACABNgIAIAAgACgCBCAEajYCBCABQQ9qQXhxQQhrIgIgBUEDcjYCBCAHQQ9q +QXhxQQhrIgQgAiAFaiIAayEFIARB1IbBACgCAEYNAyAEQdCGwQAoAgBGDQQgBCgCBCIBQQNxQQFG +BEAgBCABQXhxIgEQTSABIAVqIQUgASAEaiIEKAIEIQELIAQgAUF+cTYCBCAAIAVBAXI2AgQgACAF +aiAFNgIAIAVBgAJPBEAgACAFEFUMBgsgBUH4AXFBuITBAGohAQJ/QcCGwQAoAgAiA0EBIAVBA3Z0 +IgRxRQRAQcCGwQAgAyAEcjYCACABDAELIAEoAggLIQMgASAANgIIIAMgADYCDCAAIAE2AgwgACAD +NgIIDAULQcyGwQAgACAFayIBNgIAQdSGwQBB1IbBACgCACIAIAVqIgI2AgAgAiABQQFyNgIEIAAg +BUEDcjYCBCAAQQhqDAgLQdCGwQAoAgAhAAJAIAEgBWsiAkEPTQRAQdCGwQBBADYCAEHIhsEAQQA2 +AgAgACABQQNyNgIEIAAgAWoiASABKAIEQQFyNgIEDAELQciGwQAgAjYCAEHQhsEAIAAgBWoiAzYC +ACADIAJBAXI2AgQgACABaiACNgIAIAAgBUEDcjYCBAsgAEEIagwHCyAAIAQgB2o2AgRB1IbBAEHU +hsEAKAIAIgBBD2pBeHEiAUEIayICNgIAQcyGwQBBzIbBACgCACAEaiIDIAAgAWtqQQhqIgE2AgAg +AiABQQFyNgIEIAAgA2pBKDYCBEHghsEAQYCAgAE2AgAMAwtB1IbBACAANgIAQcyGwQBBzIbBACgC +ACAFaiIBNgIAIAAgAUEBcjYCBAwBC0HQhsEAIAA2AgBByIbBAEHIhsEAKAIAIAVqIgE2AgAgACAB +QQFyNgIEIAAgAWogATYCAAsgAkEIagwDC0EAQcyGwQAoAgAiACAFTQ0CGkHMhsEAIAAgBWsiATYC +AEHUhsEAQdSGwQAoAgAiACAFaiICNgIAIAIgAUEBcjYCBCAAIAVBA3I2AgQgAEEIagwCC0HEhsEA +QcSGwQAoAgBBfiACKAIcd3E2AgALAkAgBEEQTwRAIAIgBUEDcjYCBCACIAVqIgAgBEEBcjYCBCAA +IARqIAQ2AgAgBEGAAk8EQCAAIAQQVQwCCyAEQfgBcUG4hMEAaiEBAn9BwIbBACgCACIDQQEgBEED +dnQiBHFFBEBBwIbBACADIARyNgIAIAEMAQsgASgCCAshAyABIAA2AgggAyAANgIMIAAgATYCDCAA +IAM2AggMAQsgAiAEIAVqIgBBA3I2AgQgACACaiIAIAAoAgRBAXI2AgQLIAJBCGoLIAhBEGokAAvV +DAINfwF+IwBBoAJrIgckAAJAAkACQAJAAkAgAUGACE0EQCAHQQA2AogBIAEgAUEAIAFBgAhHGyIM +ayIOQYAITwRAIAdBATYCiAEgByAANgKMAUEBIQoLIAdBjAFqIQsgAyEUIAUhASMAQSBrIggkACAG +QQV2IgkgCiAJIApJGyINBEAgBEECciEPIARBAXIhEANAIAsoAgAhCSAIQRhqIhEgAkEYaikCADcD +ACAIQRBqIhIgAkEQaikCADcDACAIQQhqIhMgAkEIaikCADcDACAIIAIpAgA3AwAgCCAJQcAAIBQg +EBAoIAggCUFAa0HAACAUIAQQKCAIIAlBgAFqQcAAIBQgBBAoIAggCUHAAWpBwAAgFCAEECggCCAJ +QYACakHAACAUIAQQKCAIIAlBwAJqQcAAIBQgBBAoIAggCUGAA2pBwAAgFCAEECggCCAJQcADakHA +ACAUIAQQKCAIIAlBgARqQcAAIBQgBBAoIAggCUHABGpBwAAgFCAEECggCCAJQYAFakHAACAUIAQQ +KCAIIAlBwAVqQcAAIBQgBBAoIAggCUGABmpBwAAgFCAEECggCCAJQcAGakHAACAUIAQQKCAIIAlB +gAdqQcAAIBQgBBAoIAggCUHAB2pBwAAgFCAPECggAUEYaiARKQMANwAAIAFBEGogEikDADcAACAB +QQhqIBMpAwA3AAAgASAIKQMANwAAIAtBBGohCyABQSBqIQEgFEIBfCEUIA1BAWsiDQ0ACwsgCEEg +aiQAIAxFDQEgB0HIAWpCADcDACAHQcABakIANwMAIAdBuAFqQgA3AwAgB0GwAWpCADcDACAHQagB +akIANwMAIAdBoAFqQgA3AwAgB0GYAWpCADcDACAHQdgBaiIBIAJBCGopAgA3AwAgB0HgAWoiCCAC +QRBqKQIANwMAIAdB6AFqIgkgAkEYaikCADcDACAHQgA3A5ABIAcgBDoA+gEgB0EAOwH4ASAHIAIp +AgA3A9ABIAcgAyAKrXw3A/ABIAdBkAFqIAAgDmogDBBGIQAgB0HQAGogASkDADcDACAHQdgAaiAI +KQMANwMAIAdB4ABqIAkpAwA3AwAgB0EQaiAAQQhqKQMANwMAIAdBGGogAEEQaikDADcDACAHQSBq +IABBGGopAwA3AwAgB0EoaiAAQSBqKQMANwMAIAdBMGogAEEoaikDADcDACAHQThqIABBMGopAwA3 +AwAgB0FAayAAQThqKQMANwMAIAcgBykD0AE3A0ggByAAKQMANwMIIActAPoBIQAgBy0A+QEhAiAH +IActAPgBIgQ6AHAgByAHKQPwASIDNwNoIAcgACACRXJBAnIiADoAcSAHQZgCaiICIAkpAwA3AwAg +B0GQAmoiCSAIKQMANwMAIAdBiAJqIgggASkDADcDACAHIAcpA9ABNwOAAiAHQYACaiAHQQhqIAQg +AyAAECggCkEFdCIAQSBqIgEgBksNAiACKAIAIQEgCSgCACECIAgoAgAhBCAHKAKUAiEGIAcoAowC +IQggBygChAIhCSAHKAKAAiELIAAgBWoiACAHKAKcAjYAHCAAIAE2ABggACAGNgAUIAAgAjYAECAA +IAg2AAwgACAENgAIIAAgCTYABCAAIAs2AAAgCkEBaiEKDAELIAFCfyABrUIBfEIBiEIBfXmIpyII +TQ0CIAdBCGoiCUEAQYAB/AsAIAAgCEEBaiIIIAIgAyAEIAlBIEHAACAIQYAIRhsiChAqIQsgACAI +aiABIAhrIAIgAyAIQQp2rXwgBCAJIApqQYABIAprECogC0EBRgRAIAZBP00NBCAFIAcpAAg3AAAg +BUE4aiAHQUBrKQAANwAAIAVBMGogB0E4aikAADcAACAFQShqIAdBMGopAAA3AAAgBUEgaiAHQShq +KQAANwAAIAVBGGogB0EgaikAADcAACAFQRBqIAdBGGopAAA3AAAgBUEIaiAHQRBqKQAANwAAQQIh +CgwBCyALakEFdCIAQYEBTw0EIAdBCGogACACIAQgBSAGEEEhCgsgB0GgAmokACAKDwsgASAGQYi8 +wAAQ1gEACyAHQQA2AhggB0EBNgIMIAdBkLvAADYCCCAHQgQ3AhAgB0EIakHYvMAAEKMBAAtBwAAg +BkHovMAAENYBAAsgAEGAAUH4vMAAENYBAAvzCAIFfwN+AkACQAJAIAFBCE8EQCABQQdxIgJFDQEg +ACgCoAEiA0EpTw0CIANFBEAgAEEANgKgAQwCCyADQQFrQf////8DcSIFQQFqIgRBA3EhBiACQQJ0 +QZDmwABqKAIAIAJ2rSEJAkAgBUEDSQRAIAAhAgwBCyAEQfz///8HcSEFIAAhAgNAIAIgAjUCACAJ +fiAIfCIHPgIAIAJBBGoiBCAENQIAIAl+IAdCIIh8Igc+AgAgAkEIaiIEIAQ1AgAgCX4gB0IgiHwi +Bz4CACACQQxqIgQgBDUCACAJfiAHQiCIfCIHPgIAIAdCIIghCCACQRBqIQIgBUEEayIFDQALCyAG +BEADQCACIAI1AgAgCX4gCHwiBz4CACACQQRqIQIgB0IgiCEIIAZBAWsiBg0ACwsgACAHQoCAgIAQ +WgR/IANBKEYNBCAAIANBAnRqIAg+AgAgA0EBagUgAws2AqABDAELIAAoAqABIgNBKU8NASADRQRA +IABBADYCoAEPCyABQQJ0QZDmwABqNQIAIQkgA0EBa0H/////A3EiAUEBaiICQQNxIQYCQCABQQNJ +BEAgACECDAELIAJB/P///wdxIQUgACECA0AgAiACNQIAIAl+IAh8Igc+AgAgAkEEaiIBIAE1AgAg +CX4gB0IgiHwiBz4CACACQQhqIgEgATUCACAJfiAHQiCIfCIHPgIAIAJBDGoiASABNQIAIAl+IAdC +IIh8Igc+AgAgB0IgiCEIIAJBEGohAiAFQQRrIgUNAAsLIAYEQANAIAIgAjUCACAJfiAIfCIHPgIA +IAJBBGohAiAHQiCIIQggBkEBayIGDQALCyAAIAdCgICAgBBaBH8gA0EoRg0DIAAgA0ECdGogCD4C +ACADQQFqBSADCzYCoAEPCwJAIAFBCHEEQCAAKAKgASIDQSlPDQICQCADRQRAQQAhAwwBCyADQQFr +Qf////8DcSICQQFqIgVBA3EhBgJAIAJBA0kEQEIAIQcgACECDAELIAVB/P///wdxIQVCACEHIAAh +AgNAIAIgAjUCAELh6xd+IAd8Igc+AgAgAkEEaiIEIAQ1AgBC4esXfiAHQiCIfCIHPgIAIAJBCGoi +BCAENQIAQuHrF34gB0IgiHwiBz4CACACQQxqIgQgBDUCAELh6xd+IAdCIIh8Igg+AgAgCEIgiCEH +IAJBEGohAiAFQQRrIgUNAAsLIAYEQANAIAIgAjUCAELh6xd+IAd8Igg+AgAgAkEEaiECIAhCIIgh +ByAGQQFrIgYNAAsLIAhCgICAgBBUDQAgA0EoRg0CIAAgA0ECdGogBz4CACADQQFqIQMLIAAgAzYC +oAELIAFBEHEEQCAAQYTTwABBAhAzCyABQSBxBEAgAEGM08AAQQMQMwsgAUHAAHEEQCAAQZjTwABB +BRAzCyABQYABcQRAIABBrNPAAEEKEDMLIAFBgAJxBEAgAEHU08AAQRMQMwsgACABEC0aDwsMAQsg +A0EoQaz9wAAQ1gEAC0EoQShBrP3AABCAAQALtwgCDH8BfiMAQcABayICJAAgASgCECEDIAIgAUEQ +aiIENgIgIAIgAzYCHCACIAJBvwFqIgY2AhggAkGAAWoiBSABIAJBGGoiBxBKAkACQAJAIAIpA4AB +Ig5CAlENACACQfgAaiIDIAJBqAFqKQMANwMAIAJB8ABqIgggAkGgAWopAwA3AwAgAkHoAGoiCSAC +QZgBaikDADcDACACQeAAaiIKIAJBkAFqKQMANwMAIAIgAikDiAE3A1ggDqdBAXFFDQAgAkHQAGoi +CyADKQMANwMAIAJByABqIgwgCCkDADcDACACQUBrIg0gCSkDADcDACACQThqIgggCikDADcDACAC +IAIpA1g3AzBBuYLBAC0AABpBoAFBCBDFASIDRQ0CIAMgAikDMDcDACADQSBqIAspAwA3AwAgA0EY +aiAMKQMANwMAIANBEGogDSkDADcDACADQQhqIAgpAwA3AwAgAkEBNgIUIAIgAzYCECACQQQ2Agwg +AkEoaiIJIAQoAgAiBDYCACACQSBqIAFBCGopAgA3AwAgAiABKQIANwMYIAIgCTYCuAEgAiAENgK0 +ASACIAY2ArABIAUgByACQbABahBKAkAgAikDgAEiDkICUQ0AIAJBiAFqIQRBKCEBQQEhBgNAIAJB ++ABqIgUgBEEgaikDADcDACACQfAAaiIHIARBGGopAwA3AwAgAkHoAGoiCiAEQRBqKQMANwMAIAJB +4ABqIg0gBEEIaikDADcDACACIAQpAwA3A1ggDqdBAXFFDQEgCyAFKQMANwMAIAwgBykDADcDACAC +QUBrIgcgCikDADcDACAIIA0pAwA3AwAgAiACKQNYNwMwIAIoAgwgBkYEQCACQQxqIAZBAUEIQSgQ +VyACKAIQIQMLIAEgA2oiBSACKQMwNwMAIAVBIGogCykDADcDACAFQRhqIAwpAwA3AwAgBUEQaiAH +KQMANwMAIAVBCGogCCkDADcDACACIAZBAWoiBjYCFCACKAIoIQUgAiAJNgK4ASACIAU2ArQBIAFB +KGohASACIAJBvwFqNgKwASACQYABaiACQRhqIAJBsAFqEEogAikDgAEiDkICUg0ACwsgAigCJCIB +IAIoAhwiA0cEQCABIANrQQR2IQQDQCADKAIAIgEEQCADQQRqKAIAIAEQ0QELIANBEGohAyAEQQFr +IgQNAAsLIAIoAiAiAQRAIAIoAhggAUEEdBDRAQsgACACKQIMNwIAIABBCGogAkEUaigCADYCAAwB +CyAAQQA2AgggAEKAgICAgAE3AgAgASgCDCIAIAEoAgQiA0cEQCAAIANrQQR2IQQDQCADKAIAIgAE +QCADQQRqKAIAIAAQ0QELIANBEGohAyAEQQFrIgQNAAsLIAEoAggiAEUNACABKAIAIABBBHQQ0QEL +IAJBwAFqJAAPC0EIQaABQYCSwAAQtwEAC9AIAQh/AkAgAUGACkkEQCABQQV2IQcCQAJAIAAoAqAB +IgUEQCAFQQFrIQMgBUECdCAAakEEayECIAUgB2pBAnQgAGpBBGshBiAFQSlJIQUDQCAFRQ0CIAMg +B2oiBEEoTw0DIAYgAigCADYCACAGQQRrIQYgAkEEayECIANBAWsiA0F/Rw0ACwsgAUEgSQ0DIABB +ADYCACAHQQFqIgJBAkYNAyAAQQA2AgQgAkEDRg0DIABBADYCCCACQQRGDQMgAEEANgIMIAJBBUYN +AyAAQQA2AhAgAkEGRg0DIABBADYCFCACQQdGDQMgAEEANgIYIAJBCEYNAyAAQQA2AhwgAkEJRg0D +IABBADYCICACQQpGDQMgAEEANgIkIAJBC0YNAyAAQQA2AiggAkEMRg0DIABBADYCLCACQQ1GDQMg +AEEANgIwIAJBDkYNAyAAQQA2AjQgAkEPRg0DIABBADYCOCACQRBGDQMgAEEANgI8IAJBEUYNAyAA +QQA2AkAgAkESRg0DIABBADYCRCACQRNGDQMgAEEANgJIIAJBFEYNAyAAQQA2AkwgAkEVRg0DIABB +ADYCUCACQRZGDQMgAEEANgJUIAJBF0YNAyAAQQA2AlggAkEYRg0DIABBADYCXCACQRlGDQMgAEEA +NgJgIAJBGkYNAyAAQQA2AmQgAkEbRg0DIABBADYCaCACQRxGDQMgAEEANgJsIAJBHUYNAyAAQQA2 +AnAgAkEeRg0DIABBADYCdCACQR9GDQMgAEEANgJ4IAJBIEYNAyAAQQA2AnwgAkEhRg0DIABBADYC +gAEgAkEiRg0DIABBADYChAEgAkEjRg0DIABBADYCiAEgAkEkRg0DIABBADYCjAEgAkElRg0DIABB +ADYCkAEgAkEmRg0DIABBADYClAEgAkEnRg0DIABBADYCmAEgAkEoRg0DIABBADYCnAEgAkEpRg0D +QShBKEGs/cAAEIABAAsgA0EoQaz9wAAQgAEACyAEQShBrP3AABCAAQALQdb9wABBHUGs/cAAEJcB +AAsgACgCoAEiAyAHaiECIAFBH3EiBkUEQCAAIAI2AqABIAAPCwJAIAJBAWsiBEEnTQRAIAIhBSAA +IARBAnRqKAIAQQAgAWsiAXYiBEUNASACQSdNBEAgACACQQJ0aiAENgIAIAJBAWohBQwCCyACQShB +rP3AABCAAQALIARBKEGs/cAAEIABAAsCQCAHQQFqIgggAk8NACABQR9xIQEgA0EBcUUEQCAAIAJB +AWsiAkECdGoiBCAEKAIAIAZ0IARBBGsoAgAgAXZyNgIACyADQQJGDQAgAkECdCAAakEMayEDA0Ag +A0EIaiIEIAQoAgAgBnQgA0EEaiIEKAIAIgkgAXZyNgIAIAQgCSAGdCADKAIAIAF2cjYCACADQQhr +IQMgCCACQQJrIgJJDQALCyAAIAdBAnRqIgEgASgCACAGdDYCACAAIAU2AqABIAAL/wkDDH8BfgFv +QcSEwAAhAyMAQdAAayICJAAgAiABNgIMAkACQAJAAkAgARDzAUEBRgRAIAIgATYCICACQQA2AhAg +AkHEhMAANgIYIAJB1ITAADYCHCACQSBqIQpBgICAgHghAQNAIAIgA0EIajYCGCACIAMoAgAgAygC +BBA9NgI4IAooAgAlASACQThqKAIAJQEQDSEPEHAiBSAPJgECQAJAAkACQAJAAkAgBSUBEARBAUYE +QCACKAI4JQEgAigCICUBEAVBAUcNAQsCQCACKAIQRQ0AIAIoAhQiB0GEAUkNACAHEG0LIAIgBTYC +FCACQQE2AhAgAygCACEFAn8CQAJAAkAgAygCBEEEaw4DAQIAAgtBACEHQQYhCEG8hMAAIQMCQANA +IAUtAAAiCyADLQAAIgxGBEAgBUEBaiEFIANBAWohAyAIQQFrIggNAQwCCwsgCyAMayEHCyAHDQFB +AQwCC0EAIAUoAABBuITAACgAAEYNARoLQQILIAIoAjgiBUGDAUsEQCAFEG0LQQFrDgIDAQILIAVB +hAFPBEAgBRBtCyACKAI4IgNBhAFPBEAgAxBtCyACKAIYIgMgAigCHEcNBQwHCyACKAIQIAJBADYC +EEEBRgRAIAIoAhQiA0GEAUkNBCADEG0MBAsMCQsgAUGAgICAeEcEQEHdisAAQQQQhgEhBAwCCyAC +KAIQIAJBADYCEEUNCCACIAIoAhQiAzYCOCACIAMQ7wECfyACKAIAIgYEQCACKAIEIg0MAQsgAkE4 +aiACQc8AakH8icAAEEIhBkGAgICAeAshASADQYQBTwRAIAMQbQsgAUGAgICAeEcNAiAAQYCAgIB4 +NgIAIAAgBjYCBAwGCyAJRQRAIAIoAhAgAkEANgIQQQFHDQggAiACKAIUNgIkIAJBKGoiBCACQSRq +IgMoAgAlARAeBH4gBCADKAIAJQEQCvwGNwMIQgEFQgALNwMAAn8CQCACKAIoQQFGBEAgAikDMCIO +QgBZDQELIAJBJGogAkHPAGpB3IjAABBCIQRBAQwBCyAOQoCAgIAQWgRAIAJBAToAOCACIA43A0Aj +AEEwayIDJAAgA0HciMAANgIEIAMgAkHPAGo2AgAgA0ECNgIMIANBiI/AADYCCCADQgI3AhQgAyAD +rUKAgICA8AGENwMoIAMgAkE4aq1CgICAgIAChDcDICADIANBIGo2AhAgA0EIahBjIQQgA0EwaiQA +QQEMAQsgDqchBEEACyACKAIkIgVBhAFPBEAgBRBtC0EBIQlFDQIMAQtB4YrAAEEGEIYBIQQLIABB +gICAgHg2AgAgACAENgIEIAFBgICAgHhyQYCAgIB4Rg0EIAYgARDRAQwECyACKAIYIgMgAigCHEcN +AAsMAQsgAkEMaiACQc8AakGcisAAEEIhBCAAQYCAgIB4NgIAIAAgBDYCBCABQYQBSQ0CIAEQbQwC +CyABQYCAgIB4RwRAIAkEQCAAIAQ2AgwgACANNgIIIAAgBjYCBCAAIAE2AgAMAgtB4YrAAEEGEIUB +IQQgAEGAgICAeDYCACAAIAQ2AgQgAUUNASAGIAEQ0QEMAQtB3YrAAEEEEIUBIQEgAEGAgICAeDYC +ACAAIAE2AgQLIAIoAiAiAEGEAU8EQCAAEG0LIAIoAhBFDQAgAigCFCIAQYMBTQ0AIAAQbQsgAkHQ +AGokAA8LQayKwABBMRDnAQALswsDBn8BfgFvIwBB0ABrIgIkACACIAE2AiACQAJAAkACQAJAIAJB +IGoiASgCACUBEBwEQCACQSRqIgMgASgCACUBEBA2AgggA0EANgIEIAMgATYCAEEAIQEgAkEANgIw +IAIoAiQEQCACKAIsIgMgAigCKCIETQRAQQQhAwwDC0G5gsEALQAAGkGAgAQgAyAEayIBQQAgASAD +TRsiASABQYCABE8bIgFBBHQiBEEEEMUBIgMNAkEEIARB3InAABC3AQALIAJBADYCPCACQoCAgIDA +ADcCNAwCCyACQUBrIQEQFyEJEHAiAyAJJgEgAyEFIAJBIGooAgAiBCUBIAMlARAYIQkQcCIDIAkm +AUGQg8EAKAIAIQZBjIPBACgCACEHQYyDwQBCADcCAAJAAkACQCAHQQFGBEAgAUEDOgAEIAEgBjYC +AAwBCwJAIAMQ9AFBAUYEQCADJQEgBCUBEBkhCRBwIgQgCSYBQZCDwQAoAgAhBkGMg8EAKAIAIQdB +jIPBAEIANwIAAkAgB0EBRgRAIAFBAzoABCABIAY2AgAMAQsCQCAEEPMBQQFHDQAgBCUBEBMhCRBw +IgYgCSYBIAYQ9AEgBkGEAU8EQCAGEG0LQQFHDQAgAUEAOgAEIAEgBDYCACADQYQBTwRAIAMQbQsg +BUGEAUkNBgwFCyABQQI6AAQgBEGEAUkNACAEEG0LIANBhAFPDQEMAgsgAUECOgAEIANBhAFJDQEL +IAMQbQsgBUGDAU0NAQsgBRBtCyACKAJAIQECQAJAAkAgAi0ARCIDQQJrDgICAAELIABBgICAgHg2 +AgAgACABNgIEIAIoAiAiAUGDAUsNBQwGCyACIAM6ADggAiABNgI0IAJBADYCLCACQoCAgIDAADcC +JCACQRhqIAJBNGoQewJAIAIoAhgiA0ECRwRAIAIoAhwhAQNAAkAgA0EBcUUEQCACQUBrIAEQLiAC +KAJEIQEgAigCQCIFQYCAgIB4Rw0BCyAAQYCAgIB4NgIAIAAgATYCBCACKAIsIgMEQCACKAIoIQED +QCABKAIAIgAEQCABQQRqKAIAIAAQ0QELIAFBEGohASADQQFrIgMNAAsLIAIoAiQiAARAIAIoAigg +AEEEdBDRAQsgAigCNCIBQYMBSw0DDAcLIAIpAkghCCACKAIsIgMgAigCJEYEQCACQSRqEGkLIAIo +AiggA0EEdGoiBCAINwIIIAQgATYCBCAEIAU2AgAgAiADQQFqNgIsIAJBEGogAkE0ahB7IAIoAhQh +ASACKAIQIgNBAkcNAAsLIAAgAikCJDcCACAAQQhqIAJBLGooAgA2AgAgAigCNCIBQYMBTQ0ECyAB +EG0MAwsgAkEgaiACQUBrQYyKwAAQQiEBIABBgICAgHg2AgAgACABNgIEDAILIAJBADYCPCACIAM2 +AjggAiABNgI0A0AgAkEIaiEDIAJBJGoiASgCBCIEIAEoAghPBH9BAAUgASAEQQFqNgIEIAEoAgAo +AgAlASAEEA8hCRBwIgEgCSYBQQELIQQgAyABNgIEIAMgBDYCACACKAIIQQFxRQ0BIAIoAgwhASAC +IAIoAjBBAWo2AjAgAkFAayABEC4gAigCRCEBIAIoAkAiBUGAgICAeEYEQCAAQYCAgIB4NgIAIAAg +ATYCBCACKAI8IgMEQCACKAI4IQEDQCABKAIAIgAEQCABQQRqKAIAIAAQ0QELIAFBEGohASADQQFr +IgMNAAsLIAIoAjQiAEUNAyACKAI4IABBBHQQ0QEMAwsgAikCSCEIIAIoAjwiAyACKAI0RgRAIAJB +NGoQaQsgAigCOCADQQR0aiIEIAg3AgggBCABNgIEIAQgBTYCACACIANBAWo2AjwgAigCJA0ACwsg +ACACKQI0NwIAIABBCGogAkE8aigCADYCAAsgAigCICIBQYMBTQ0BCyABEG0LIAJB0ABqJAALzwYB +CH8CQAJAIAEgAEEDakF8cSIDIABrIghJDQAgASAIayIGQQRJDQAgBkEDcSEHQQAhAQJAIAAgA0Yi +CQ0AAkAgACADayIFQXxLBEBBACEDDAELQQAhAwNAIAEgACADaiICLAAAQb9/SmogAkEBaiwAAEG/ +f0pqIAJBAmosAABBv39KaiACQQNqLAAAQb9/SmohASADQQRqIgMNAAsLIAkNACAAIANqIQIDQCAB +IAIsAABBv39KaiEBIAJBAWohAiAFQQFqIgUNAAsLIAAgCGohAAJAIAdFDQAgACAGQXxxaiIDLAAA +Qb9/SiEEIAdBAUYNACAEIAMsAAFBv39KaiEEIAdBAkYNACAEIAMsAAJBv39KaiEECyAGQQJ2IQUg +ASAEaiEEA0AgACEDIAVFDQJBwAEgBSAFQcABTxsiBkEDcSEHIAZBAnQhCEEAIQIgBUEETwRAIAAg +CEHwB3FqIQkgACEBA0AgASgCACIAQX9zQQd2IABBBnZyQYGChAhxIAJqIAFBBGooAgAiAEF/c0EH +diAAQQZ2ckGBgoQIcWogAUEIaigCACIAQX9zQQd2IABBBnZyQYGChAhxaiABQQxqKAIAIgBBf3NB +B3YgAEEGdnJBgYKECHFqIQIgAUEQaiIBIAlHDQALCyAFIAZrIQUgAyAIaiEAIAJBCHZB/4H8B3Eg +AkH/gfwHcWpBgYAEbEEQdiAEaiEEIAdFDQALAn8gAyAGQfwBcUECdGoiACgCACIBQX9zQQd2IAFB +BnZyQYGChAhxIgEgB0EBRg0AGiABIAAoAgQiAUF/c0EHdiABQQZ2ckGBgoQIcWoiASAHQQJGDQAa +IAAoAggiAEF/c0EHdiAAQQZ2ckGBgoQIcSABagsiAUEIdkH/gRxxIAFB/4H8B3FqQYGABGxBEHYg +BGoPCyABRQRAQQAPCyABQQNxIQMCQCABQQRJBEAMAQsgAUF8cSEFA0AgBCAAIAJqIgEsAABBv39K +aiABQQFqLAAAQb9/SmogAUECaiwAAEG/f0pqIAFBA2osAABBv39KaiEEIAUgAkEEaiICRw0ACwsg +A0UNACAAIAJqIQEDQCAEIAEsAABBv39KaiEEIAFBAWohASADQQFrIgMNAAsLIAQLlQgCC38DfiMA +QeAAayIEJAAgAq1CKH4iDqchAwJAIA5CIIinIANB+P///wdLcg0AAn8gA0UEQEEIIQZBAAwBC0G5 +gsEALQAAGkEIIQcgA0EIEMUBIgZFDQEgAgshCyADBEAgBiABIAP8CgAACyACQQJPBEAgBkHQAGoh +DCAEQdwAaq1CgICAgBCEIQ4gBEHYAGqtQoCAgIAghCEPA0BBACEDQQAhBQJAAkACQAJAAkACQANA +IAMhCiACIAVJDQUgBUEobCEJAkAgAiAFayIBQQNJDQBBCSABIAFBCU8bIQggCSAMaiEDQQIhAQNA +IAEgCEYEQCAIIQEMAgsgAUEBaiEBIANCBBCzASADQShqIQNCAFINAAsLIAEgBWoiCCABSQ0BIAIg +CEkNAkH8gsEAIQVB+ILBACgCAEUEQAJ/QbmCwQAtAAAaQYAIQQEQxQEiAwRAQYiDwQBBADYCAEH8 +gsEAQQA2AgBBhIPBACgCACEFQYSDwQAgAzYCAEGAg8EAKAIAIQNBgIPBAEGACDYCAEH4gsEAKAIA +QfiCwQBBATYCAEUgA0VyRQRAIAUgAxDRAQtB/ILBAAwBC0EBQYAIQcSOwAAQtwEACyEFCyAFKAIA +DQNBACEDIAVBADYCDCAFQX82AgBBACEHIAEEQCAFQQRqIQ0gBiAJaiIDIAFBKGxqIQkDQCAEIAM2 +AlggBCADQSBqIgE2AlwgBEEDNgI0IARB9IvAADYCMCAEQgI3AjwgBCAONwMQIAQgDzcDCCAEIARB +CGo2AjggDUHcj8AAIARBMGoQPA0GIAEoAgAgB2ohByABQQhqIgMgCUcNAAsgBSgCDCEDCyAEQTBq +Qdy6wAAgBSgCCCADEDQgBEHQAGoiASAHNgIAIAUgBSgCAEEBajYCACAEQRBqIgMgBEE4aikDADcD +ACAEQRhqIgUgBEFAaykDADcDACAEQSBqIgcgBEHIAGopAwA3AwAgBEEoaiIJIAEpAwA3AwAgBCAE +KQMwNwMIIAIgCksEQCAGIApBKGxqIgEgBCkDCDcDACABQSBqIAkpAwA3AwAgAUEYaiAHKQMANwMA +IAFBEGogBSkDADcDACABQQhqIAMpAwA3AwAgCkEBaiEDIAgiBSACRg0HDAELCyAKIAJB/IDAABCA +AQALIAUgCEHsgMAAENcBAAsgCCACQeyAwAAQ1gEAC0HAjcAAEI4BAAtBnIzAAEErIARBMGpBjIzA +AEGwjcAAEH0ACyAFIAJBjIHAABDVAQALIAMhAiAKDQALCyAAIAYpAwA3AwAgAEEYaiAGQRhqKQMA +NwMAIABBEGogBkEQaikDADcDACAAQQhqIAZBCGopAwA3AwAgBiALQShsENEBIARB4ABqJAAPCyAH +IANBoITAABC3AQALyQcCCn8CfiMAQTBrIgYkAAJAAkACQAJAAkACQAJAIANFDQACfyABKAIYIgcg +ASgCKCIFQUBrTQRAIAEoAhwgBWsiByADIAMgB0sbIQhBACEHIAFBHGoMAQsgASgCHCAFayIJIAMg +AyAJSxshCCAJIAMgByAFa0HBAGsiByADIAdJGyIHSQ0CIAUgB2ohBSABQRxqCyEJIAZBCGohCiAC +IAdqIQ0gCCAHayELIAEpAxAhEEEAIQggASkDACEPIAEoAgghDgNAAkAgCCALRgRAQQAhDAwBCyAB +IA4gCCANai0AAEEDdGopAwAgD0IBhnwiDzcDAEEBIQwgCEEBaiEIIA8gEINCAFINAQsLIAogCDYC +BCAKIAw2AgACQAJAIAYoAghBAXEEQCAJKAIAIgggBigCDCIEIAVqTQ0BDAILIAkoAgAiCCAFIAtq +Sw0CCyAIIAVrIQQLIAFCADcDACAEIAdqIQUgASgCKCIHRQRAIAMgBUkNAyAGQSBqIAIgBRB4DAYL +IAMgBUkNAyABQSBqIQMgASgCICAHayAFSQRAIAMgByAFEFggASgCKCEHCyAFBEAgASgCJCAHaiAC +IAX8CgAACyABIAUgB2o2AiggBkEYaiADQQhqKAIANgIAIAFBADYCKCADKQIAIQ8gAUKAgICAEDcD +ICAGIA83AxAgBkEgaiAGQRBqEHUMBQsgBEUEQCABKAIgIAEoAigiBWsgA0kEQCABQSBqIAUgAxBY +IAEoAighBQsgAwRAIAEoAiQgBWogAiAD/AoAAAsgACADNgIwIABBADYCACABIAMgBWo2AigMBgsg +ASgCKCIFRQ0DIAFBIGohBCABKAIgIAVrIANJBEAgBCAFIAMQWCABKAIoIQULIAMEQCABKAIkIAVq +IAIgA/wKAAALIAEgAyAFajYCKCAGQRhqIARBCGooAgA2AgAgAUEANgIoIAQpAgAhDyABQoCAgIAQ +NwMgIAYgDzcDECAGQSBqIAZBEGoQdSADIQUMBAsgByAIQfCWwAAQ1wEACyAFIANBgJfAABDWAQAL +IAUgA0GQl8AAENYBAAsgBkEgaiACIAMQeCADIQULIAZBGGogBkEoaikCACIPNwMAIAYgBikCIDcD +ECAPpyIBRQRAIABBADYCMCAAQQA2AgAgBkEcaiAGKAIUQQAgBigCECgCEBEDAAwBCyAGKAIQIQIg +BigCHCEDIABBEGpBvLrAACAGKAIUIgQgARA0IAAgBTYCMCAAIAM2AgwgACABNgIIIAAgBDYCBCAA +IAI2AgALIAZBMGokAAvcBQIMfwN+IwBBoAFrIgkkACAJQQBBoAH8CwACQAJAAkAgAiAAKAKgASIF +TQRAIAVBKU8NASABIAJBAnRqIQwCQAJAIAUEQCAFQQFqIQ0gBUECdCEKA0AgCSAGQQJ0aiEDA0Ag +BiECIAMhBCABIAxGDQggA0EEaiEDIAJBAWohBiABKAIAIQcgAUEEaiILIQEgB0UNAAsgB60hEUIA +IQ8gCiEHIAIhASAAIQMDQCABQShPDQQgBCAPIAQ1AgB8IAM1AgAgEX58IhA+AgAgEEIgiCEPIARB +BGohBCABQQFqIQEgA0EEaiEDIAdBBGsiBw0ACyAIIBBCgICAgBBaBH8gAiAFaiIBQShPDQMgCSAB +QQJ0aiAPPgIAIA0FIAULIAJqIgEgASAISRshCCALIQEMAAsACwNAIAEgDEYNBiAEQQFqIQQgASgC +ACABQQRqIQFFDQAgCCAEQQFrIgIgAiAISRshCAwACwALIAFBKEGs/cAAEIABAAsgAUEoQaz9wAAQ +gAEACyAFQSlPDQEgAkECdCEMIAJBAWohDSAAIAVBAnRqIQ4gACEDAkADQCAJIAdBAnRqIQYDQCAH +IQsgBiEEIAMgDkYNBSAEQQRqIQYgB0EBaiEHIAMoAgAhCiADQQRqIgUhAyAKRQ0ACyAKrSERQgAh +DyAMIQogCyEDIAEhBgNAIANBKE8NAiAEIA8gBDUCAHwgBjUCACARfnwiED4CACAQQiCIIQ8gBEEE +aiEEIANBAWohAyAGQQRqIQYgCkEEayIKDQALAkAgCCAQQoCAgIAQWgR/IAIgC2oiA0EoTw0BIAkg +A0ECdGogDz4CACANBSACCyALaiIDIAMgCEkbIQggBSEDDAELCyADQShBrP3AABCAAQALIANBKEGs +/cAAEIABAAsgBUEoQaz9wAAQ1gEACyAFQShBrP3AABDWAQALIAAgCUGgAfwKAAAgACAINgKgASAJ +QaABaiQAC+QIAgp/AX4jAEGAAmsiBCQAIAQgASkAGDcCGCAEIAEpABA3AhAgBCABKQAINwIIIAQg +ASkAADcCAAJ/IANBgQhPBEAgBEEgaiEFIwBB4ABrIgEkACABQThqIgZCADcDACABQTBqIgdCADcD +ACABQShqIghCADcDACABQSBqIglCADcDACABQRhqIgpCADcDACABQRBqIgtCADcDACABQQhqIgxC +ADcDACABQgA3AwAgAiADIARCAEEQIAFBwAAQKiEDIAFB2ABqQgA3AwAgAUHQAGpCADcDACABQcgA +akIANwMAIAFCADcDQAJAAkACQAJAIANBA08EQANAIANBBXQiAkHBAE8NAiABIAIgBEEQIAFBQGsi +DUEgEEEiA0EFdCICQcEATw0DIAJBIU8NBCACBEAgASANIAL8CgAACyADQQJLDQALCyAFIAEpAwA3 +AAAgBUE4aiAGKQMANwAAIAVBMGogBykDADcAACAFQShqIAgpAwA3AAAgBUEgaiAJKQMANwAAIAVB +GGogCikDADcAACAFQRBqIAspAwA3AAAgBUEIaiAMKQMANwAAIAFB4ABqJAAMAwsgAkHAAEGIvcAA +ENYBAAsgAkHAAEGYvcAAENYBAAsgAkEgQai9wAAQ1gEACyAEQfgAaiAEQRhqKQIANwMAIARB8ABq +IARBEGopAgA3AwAgBEHoAGogBEEIaikCADcDACAEIAQpAgA3A2BBwAAhA0EUDAELIARByAFqQgA3 +AwAgBEHAAWpCADcDACAEQbgBakIANwMAIARBsAFqQgA3AwAgBEGoAWpCADcDACAEQZgBakIANwMA +IARBEDoA+gEgBEGgAWpCADcDACAEQdgBaiIFIARBCGopAgA3AwAgBEHoAWoiBiAEQRhqKQIANwMA +IARB4AFqIgcgBEEQaikCADcDACAEQgA3A5ABIAQgBCkCADcD0AEgBEEAOwH4ASAEQgA3A/ABIARB +kAFqIAIgAxBGIQEgBEHoAGogBSkDADcDACAEQfAAaiAHKQMANwMAIARB+ABqIAYpAwA3AwAgBEEo +aiABQQhqKQMANwMAIARBMGogAUEQaikDADcDACAEQThqIAFBGGopAwA3AwAgBEFAayABQSBqKQMA +NwMAIARByABqIAFBKGopAwA3AwAgBEHQAGogAUEwaikDADcDACAEQdgAaiABQThqKQMANwMAIAQg +BCkD0AE3A2AgBCABKQMANwMgIAQpA/ABIQ4gBC0A+AEhAyAELQD6ASAELQD5AUVyQQJyCyEBIAQg +DjcDgAEgBCADOgCIASAEIAE6AIkBIARBqAFqIgIgBEH4AGopAwA3AwAgBEGgAWoiBSAEQfAAaikD +ADcDACAEQZgBaiIGIARB6ABqKQMANwMAIAQgBCkDYDcDkAEgBEGQAWogBEEgaiADQgAgAUEIchAo +IAAgAikDADcAGCAAIAUpAwA3ABAgACAGKQMANwAIIAAgBCkDkAE3AAAgBEGAAmokAAvACwEFfyMA +QSBrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABDigGAQEBAQEBAQECBAEBAwEBAQEBAQEB +AQEBAQEBAQEBAQEBCAEBAQEHAAsgAUHcAEYNBAsgAkEBcUUgAUH/BU1yDQcCfwJAQRFBACABQa+w +BE8bIgIgAkEIciIDIAFBC3QiAiADQQJ0QfiAwQBqKAIAQQt0SRsiAyADQQRyIgMgA0ECdEH4gMEA +aigCAEELdCACSxsiAyADQQJyIgMgA0ECdEH4gMEAaigCAEELdCACSxsiAyADQQFqIgMgA0ECdEH4 +gMEAaigCAEELdCACSxsiAyADQQFqIgMgA0ECdEH4gMEAaigCAEELdCACSxsiA0ECdEH4gMEAaigC +AEELdCIFIAJGIAIgBUtqIANqIgNBIU0EQCADQQJ0QfiAwQBqIgYoAgBBFXYhAkHvBSEFAn8CQCAD +QSFGDQAgBigCBEEVdiEFIAMNAEEADAELIAZBBGsoAgBB////AHELIQMCQCAFIAJBf3NqRQ0AIAEg +A2shB0HvBSACIAJB7wVNGyEGIAVBAWshA0EAIQUDQCACIAZGDQMgBSACQbTMwABqLQAAaiIFIAdL +DQEgAyACQQFqIgJHDQALIAMhAgsgAkEBcQwCCyADQSJB7PzAABCAAQALIAZB7wVB/PzAABCAAQAL +RQ0HIARBADoACiAEQQA7AQggBCABQRR2QffowABqLQAAOgALIAQgAUEEdkEPcUH36MAAai0AADoA +DyAEIAFBCHZBD3FB9+jAAGotAAA6AA4gBCABQQx2QQ9xQffowABqLQAAOgANIAQgAUEQdkEPcUH3 +6MAAai0AADoADCABQQFyZ0ECdiICIARBCGoiA2oiBUH7ADoAACAFQQFrQfUAOgAAIAMgAkECayIC +akHcADoAACAEQRBqIgMgAUEPcUH36MAAai0AADoAACAAQQo6AAsgACACOgAKIAAgBCkCCDcCACAE +Qf0AOgARIABBCGogAy8BADsBAAwJCyAAQYAEOwEKIABCADcBAiAAQdzoATsBAAwICyAAQYAEOwEK +IABCADcBAiAAQdzkATsBAAwHCyAAQYAEOwEKIABCADcBAiAAQdzcATsBAAwGCyAAQYAEOwEKIABC +ADcBAiAAQdy4ATsBAAwFCyAAQYAEOwEKIABCADcBAiAAQdzgADsBAAwECyACQYACcUUNASAAQYAE +OwEKIABCADcBAiAAQdzOADsBAAwDCyACQf///wdxQYCABE8NAQsCf0EAIAFBIEkNABpBASABQf8A +SQ0AGiABQYCABE8EQCABQeD//wBxQeDNCkcgAUH+//8AcUGe8ApHcSABQcDuCmtBeklxIAFBsJ0L +a0FySXEgAUHw1wtrQXFJcSABQYDwC2tB3mxJcSABQYCADGtBnnRJcSABQdCmDGtBe0lxIAFBgII4 +a0GwxVRJcSABQfCDOElxIAFBgIAITw0BGiABQZjxwABBLEHw8cAAQdABQcDzwABB5gMQUgwBCyAB +Qab3wABBKEH298AAQaICQZj6wABBqQIQUgtFBEAgBEEAOgAWIARBADsBFCAEIAFBFHZB9+jAAGot +AAA6ABcgBCABQQR2QQ9xQffowABqLQAAOgAbIAQgAUEIdkEPcUH36MAAai0AADoAGiAEIAFBDHZB +D3FB9+jAAGotAAA6ABkgBCABQRB2QQ9xQffowABqLQAAOgAYIAFBAXJnQQJ2IgIgBEEUaiIDaiIF +QfsAOgAAIAVBAWtB9QA6AAAgAyACQQJrIgJqQdwAOgAAIARBHGoiAyABQQ9xQffowABqLQAAOgAA +IABBCjoACyAAIAI6AAogACAEKQIUNwIAIARB/QA6AB0gAEEIaiADLwEAOwEADAILIAAgATYCBCAA +QYABOgAADAELIABBgAQ7AQogAEIANwECIABB3MQAOwEACyAEQSBqJAAL0wUCB38BfgJ/IAFFBEAg +ACgCCCEHQS0hCyAFQQFqDAELQStBgIDEACAAKAIIIgdBgICAAXEiARshCyABQRV2IAVqCyEIAkAg +B0GAgIAEcUUEQEEAIQIMAQsgA0EQTwRAIAIgAxAwIAhqIQgMAQsgA0UNACADQQNxIQoCQCADQQRJ +BEBBACEBDAELIANBDHEhDEEAIQEDQCABIAIgCWoiBiwAAEG/f0pqIAZBAWosAABBv39KaiAGQQJq +LAAAQb9/SmogBkEDaiwAAEG/f0pqIQEgDCAJQQRqIglHDQALCyAKBEAgAiAJaiEGA0AgASAGLAAA +Qb9/SmohASAGQQFqIQYgCkEBayIKDQALCyABIAhqIQgLAkAgAC8BDCIJIAhLBEACQAJAIAdBgICA +CHFFBEAgCSAIayEJQQAhAUEAIQgCQAJAAkAgB0EddkEDcUEBaw4DAAEAAgsgCSEIDAELIAlB/v8D +cUEBdiEICyAHQf///wBxIQogACgCBCEHIAAoAgAhAANAIAFB//8DcSAIQf//A3FPDQJBASEGIAFB +AWohASAAIAogBygCEBEAAEUNAAsMBAsgACAAKQIIIg2nQYCAgP95cUGwgICAAnI2AghBASEGIAAo +AgAiByAAKAIEIgogCyACIAMQmwENA0EAIQEgCSAIa0H//wNxIQIDQCABQf//A3EgAk8NAiABQQFq +IQEgB0EwIAooAhARAABFDQALDAMLQQEhBiAAIAcgCyACIAMQmwENAiAAIAQgBSAHKAIMEQEADQJB +ACEBIAkgCGtB//8DcSECA0AgAUH//wNxIgMgAkkhBiACIANNDQMgAUEBaiEBIAAgCiAHKAIQEQAA +RQ0ACwwCCyAHIAQgBSAKKAIMEQEADQEgACANNwIIQQAPC0EBIQYgACgCACIBIAAoAgQiACALIAIg +AxCbAQ0AIAEgBCAFIAAoAgwRAQAhBgsgBguKBQIGfwV+QgEhDQJAAkACQAJAIAJBwABHDQBBACEC +A0AgAkHAAEcEQCABIAJqIgMtAAAiBEEwa0H/AXFBCk8EQCAEQV9xQcEAa0H/AXFBBUsNAwsgAkEC +aiECIANBAWotAAAiA0Ewa0H/AXFBCkkgA0FfcUHBAGtB/wFxQQZJcg0BDAILCyABLAAQIgVBQEgN +ASABQRBqIQZBD0EQIAEtAABBK0YiAhshAyABIAJqIQIDQCACLQAAIgRBwQBrQV9xQQpqIARBMGsg +BEE5SxsiBEEPSw0BIAJBAWohAiAErSAJQgSGhCEJIANBAWsiAw0ACyABLAAgIgdBQEgNAiABQSBq +IQggAUERaiAGIAVBK0YiAxshAkEPQRAgAxshAwNAIAItAAAiBEHBAGtBX3FBCmogBEEwayAEQTlL +GyIEQQ9LDQEgAkEBaiECIAStIApCBIaEIQogA0EBayIDDQALIAEsADAiBUFASA0DIAFBMGohBiAB +QSFqIAggB0ErRiIDGyECQQ9BECADGyEDA0AgAi0AACIEQcEAa0FfcUEKaiAEQTBrIARBOUsbIgRB +D0sNASACQQFqIQIgBK0gC0IEhoQhCyADQQFrIgMNAAsgAUExaiAGIAVBK0YiARshAkEPQRAgARsh +AwNAIAItAAAiAUHBAGtBX3FBCmogAUEwayABQTlLGyIBQQ9LDQEgAkEBaiECIAGtIAxCBIaEIQwg +A0EBayIDDQALIAAgDDcDICAAIAs3AxggACAKNwMQIAAgCTcDCEIAIQ0LIAAgDTcDAA8LIAFBwABB +AEEQQYy6wAAQwwEACyABQcAAQRBBIEGcusAAEMMBAAsgAUHAAEEgQTBBrLrAABDDAQALhAYCAX8B +fCMAQTBrIgIkAAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAtAABBAWsO +EQECAwQFBgcICQoLDA0ODxARAAsgAiAALQABOgAIIAJBAjYCFCACQeC+wAA2AhAgAkIBNwIcIAIg +AkEIaq1CgICAgNAHhDcDKCACIAJBKGo2AhggASgCACABKAIEIAJBEGoQPAwRCyACIAApAwg3Awgg +AkECNgIUIAJB/L7AADYCECACQgE3AhwgAiACQQhqrUKAgICA4AeENwMoIAIgAkEoajYCGCABKAIA +IAEoAgQgAkEQahA8DBALIAIgACkDCDcDCCACQQI2AhQgAkH8vsAANgIQIAJCATcCHCACIAJBCGqt +QoCAgIDwB4Q3AyggAiACQShqNgIYIAEoAgAgASgCBCACQRBqEDwMDwsgACsDCCEDIAJBAjYCFCAC +QZy/wAA2AhAgAkIBNwIcIAIgAkEoaq1CgICAgIAIhDcDCCACIAM5AyggAiACQQhqNgIYIAEoAgAg +ASgCBCACQRBqEDwMDgsgAiAAKAIENgIIIAJBAjYCFCACQbi/wAA2AhAgAkIBNwIcIAIgAkEIaq1C +gICAgJAIhDcDKCACIAJBKGo2AhggASgCACABKAIEIAJBEGoQPAwNCyACIAApAgQ3AgggAkEBNgIU +IAJB0L/AADYCECACQgE3AhwgAiACQQhqrUKAgICAoAiENwMoIAIgAkEoajYCGCABKAIAIAEoAgQg +AkEQahA8DAwLIAFBzL7AAEEKEMEBDAsLIAFB2L/AAEEKEMEBDAoLIAFB4r/AAEEMEMEBDAkLIAFB +7r/AAEEOEMEBDAgLIAFB/L/AAEEIEMEBDAcLIAFBhMDAAEEDEMEBDAYLIAFBh8DAAEEEEMEBDAUL +IAFBi8DAAEEMEMEBDAQLIAFBl8DAAEEPEMEBDAMLIAFBpsDAAEENEMEBDAILIAFBs8DAAEEOEMEB +DAELIAEgACgCBCAAKAIIEMEBCyACQTBqJAAL/gUBBX8gAEEIayIBIABBBGsoAgAiA0F4cSIAaiEC +AkACQCADQQFxDQAgA0ECcUUNASABKAIAIgMgAGohACABIANrIgFB0IbBACgCAEYEQCACKAIEQQNx +QQNHDQFByIbBACAANgIAIAIgAigCBEF+cTYCBCABIABBAXI2AgQgAiAANgIADwsgASADEE0LAkAC +QAJAAkACQCACKAIEIgNBAnFFBEAgAkHUhsEAKAIARg0CIAJB0IbBACgCAEYNAyACIANBeHEiAhBN +IAEgACACaiIAQQFyNgIEIAAgAWogADYCACABQdCGwQAoAgBHDQFByIbBACAANgIADwsgAiADQX5x +NgIEIAEgAEEBcjYCBCAAIAFqIAA2AgALIABBgAJJDQIgASAAEFVBACEBQeiGwQBB6IbBACgCAEEB +ayIANgIAIAANBEGwhMEAKAIAIgAEQANAIAFBAWohASAAKAIIIgANAAsLQeiGwQBB/x8gASABQf8f +TRs2AgAPC0HUhsEAIAE2AgBBzIbBAEHMhsEAKAIAIABqIgA2AgAgASAAQQFyNgIEQdCGwQAoAgAg +AUYEQEHIhsEAQQA2AgBB0IbBAEEANgIACyAAQeCGwQAoAgAiA00NA0HUhsEAKAIAIgJFDQNBACEA +QcyGwQAoAgAiBEEpSQ0CQaiEwQAhAQNAIAIgASgCACIFTwRAIAIgBSABKAIEakkNBAsgASgCCCEB +DAALAAtB0IbBACABNgIAQciGwQBByIbBACgCACAAaiIANgIAIAEgAEEBcjYCBCAAIAFqIAA2AgAP +CyAAQfgBcUG4hMEAaiECAn9BwIbBACgCACIDQQEgAEEDdnQiAHFFBEBBwIbBACAAIANyNgIAIAIM +AQsgAigCCAshACACIAE2AgggACABNgIMIAEgAjYCDCABIAA2AggPC0GwhMEAKAIAIgEEQANAIABB +AWohACABKAIIIgENAAsLQeiGwQBB/x8gACAAQf8fTRs2AgAgAyAETw0AQeCGwQBBfzYCAAsL4QQB +Bn8CQAJAIAAoAggiB0GAgIDAAXFFDQACQAJAIAdBgICAgAFxRQRAIAJBEEkNASABIAIQMCEDDAIL +AkACQCAALwEOIgNFBEBBACECDAELIAEgAmohCEEAIQIgAyEFIAEhBANAIAQiBiAIRg0CAn8gBkEB +aiAGLAAAIgRBAE4NABogBkECaiAEQWBJDQAaIAZBA2ogBEFwSQ0AGiAGQQRqCyIEIAZrIAJqIQIg +BUEBayIFDQALC0EAIQULIAMgBWshAwwBCyACRQRAQQAhAgwBCyACQQNxIQYCQCACQQRJBEAMAQsg +AkEMcSEIA0AgAyABIAVqIgQsAABBv39KaiAEQQFqLAAAQb9/SmogBEECaiwAAEG/f0pqIARBA2os +AABBv39KaiEDIAggBUEEaiIFRw0ACwsgBkUNACABIAVqIQQDQCADIAQsAABBv39KaiEDIARBAWoh +BCAGQQFrIgYNAAsLIAMgAC8BDCIETw0AIAQgA2shBkEAIQNBACEFAkACQAJAIAdBHXZBA3FBAWsO +AgABAgsgBiEFDAELIAZB/v8DcUEBdiEFCyAHQf///wBxIQggACgCBCEHIAAoAgAhAANAIANB//8D +cSAFQf//A3FJBEBBASEEIANBAWohAyAAIAggBygCEBEAAEUNAQwDCwtBASEEIAAgASACIAcoAgwR +AQANAUEAIQMgBiAFa0H//wNxIQEDQCADQf//A3EiAiABSSEEIAEgAk0NAiADQQFqIQMgACAIIAco +AhARAABFDQALDAELIAAoAgAgASACIAAoAgQoAgwRAQAhBAsgBAueBAEEfyMAQYABayIEJAACQAJA +AkAgASgCCCICQYCAgBBxRQRAIAJBgICAIHENAUEBIQIgACgCACABEExFDQIMAwsgACgCACECA0Ag +AyAEakH/AGogAkEPcSIFQTByIAVB1wBqIAVBCkkbOgAAIANBAWshAyACQRBJIAJBBHYhAkUNAAtB +ASECIAFBAUH268AAQQIgAyAEakGAAWpBACADaxA2RQ0BDAILIAAoAgAhAgNAIAMgBGpB/wBqIAJB +D3EiBUEwciAFQTdqIAVBCkkbOgAAIANBAWshAyACQQ9LIAJBBHYhAg0AC0EBIQIgAUEBQfbrwABB +AiADIARqQYABakEAIANrEDYNAQsgASgCAEH16MAAQQIgASgCBCgCDBEBAA0AAkAgASgCCCICQYCA +gBBxRQRAIAJBgICAIHENASAAKAIEIAEQTCECDAILIAAoAgQhAkEAIQMDQCADIARqQf8AaiACQQ9x +IgBBMHIgAEHXAGogAEEKSRs6AAAgA0EBayEDIAJBD0sgAkEEdiECDQALIAFBAUH268AAQQIgAyAE +akGAAWpBACADaxA2IQIMAQsgACgCBCECQQAhAwNAIAMgBGpB/wBqIAJBD3EiAEEwciAAQTdqIABB +CkkbOgAAIANBAWshAyACQQ9LIAJBBHYhAg0ACyABQQFB9uvAAEECIAMgBGpBgAFqQQAgA2sQNiEC +CyAEQYABaiQAIAILvQQBCH8jAEEQayIDJAAgAyABNgIEIAMgADYCACADQqCAgIAONwIIAn8CQAJA +AkAgAigCECIJBEAgAigCFCIADQEMAgsgAigCDCIARQ0BIAIoAggiASAAQQN0aiEEIABBAWtB//// +/wFxQQFqIQYgAigCACEAA0ACQCAAQQRqKAIAIgVFDQAgAygCACAAKAIAIAUgAygCBCgCDBEBAEUN +AEEBDAULQQEgASgCACADIAFBBGooAgARAAANBBogAEEIaiEAIAQgAUEIaiIBRw0ACwwCCyAAQRhs +IQogAEEBa0H/////AXFBAWohBiACKAIIIQQgAigCACEAA0ACQCAAQQRqKAIAIgFFDQAgAygCACAA +KAIAIAEgAygCBCgCDBEBAEUNAEEBDAQLQQAhB0EAIQgCQAJAAkAgBSAJaiIBQQhqLwEAQQFrDgIB +AgALIAFBCmovAQAhCAwBCyAEIAFBDGooAgBBA3RqLwEEIQgLAkACQAJAIAEvAQBBAWsOAgECAAsg +AUECai8BACEHDAELIAQgAUEEaigCAEEDdGovAQQhBwsgAyAHOwEOIAMgCDsBDCADIAFBFGooAgA2 +AghBASAEIAFBEGooAgBBA3RqIgEoAgAgAyABQQRqKAIAEQAADQMaIABBCGohACAFQRhqIgUgCkcN +AAsMAQsLAkAgBiACKAIETw0AIAMoAgAgAigCACAGQQN0aiIAKAIAIAAoAgQgAygCBCgCDBEBAEUN +AEEBDAELQQALIANBEGokAAuvFQIWfwN+IwBBEGsiFSQAQbyCwQAoAgBFBEBBvILBACgCACEEQbyC +wQBCATcCAEHIgsEAKAIAIQpBxILBACgCACECQcSCwQBB0JTAACkCADcCAEHQgsEAKAIAIQVBzILB +AEHYlMAAKQIANwIAAkAgBEUgCkVyDQAgBQRAIAJBCGohCCACKQMAQn+FQoCBgoSIkKDAgH+DIRgg +AiEEA0AgGFAEQANAIARB4ABrIQQgCCkDACAIQQhqIQhCgIGChIiQoMCAf4MiGEKAgYKEiJCgwIB/ +UQ0ACyAYQoCBgoSIkKDAgH+FIRgLIAQgGHqnQQN2QXRsakEEaygCACIDQYQBTwRAIAMQbQsgGEIB +fSAYgyEYIAVBAWsiBQ0ACwsgCiAKQQxsQRNqQXhxIgNqQQlqIgRFDQAgAiADayAEENEBCwsCQAJA +QcCCwQAoAgBFBEBBwILBAEF/NgIAQciCwQAoAgAiAyAAcSEFIABBGXYiFq1CgYKEiJCgwIABfiEZ +QcSCwQAoAgAhAgNAIAIgBWopAAAiGiAZhSIYQn+FIBhCgYKEiJCgwIABfYNCgIGChIiQoMCAf4Mi +GFBFBEADQCAAIAIgGHqnQQN2IAVqIANxQXRsaiIEQQxrKAIARgRAIARBCGsoAgAgAUYNBgsgGEIB +fSAYgyIYUEUNAAsLIBogGkIBhoNCgIGChIiQoMCAf4NQRQ0CIAUgB0EIaiIHaiADcSEFDAALAAtB +tJTAABCOAQALQcyCwQAoAgBFBEAgFUEIaiEXIwBBIGsiDyQAAkACQEHQgsEAKAIAIghBAWoiBCAI +TwRAAkBByILBACgCACILIAtBAWoiDUEDdiICQQdsIAtBCEkbIhJBAXYgBEkEQCASQQFqIgIgBCAC +IARLGyICQQhJDQEgAkH/////AU0EQEF/IAJBA3RBB25BAWtndkEBaiEEDAQLEJABIA8oAhwhBCAP +KAIYIQIMBAtBACEEQcSCwQAoAgAhCQJAIAIgDUEHcUEAR2oiA0UNACADQQFHBEAgA0H+////A3Eh +AgNAIAQgCWoiByAHKQMAIhhCf4VCB4hCgYKEiJCgwIABgyAYQv/+/fv379+//wCEfDcDACAHQQhq +IgcgBykDACIYQn+FQgeIQoGChIiQoMCAAYMgGEL//v379+/fv/8AhHw3AwAgBEEQaiEEIAJBAmsi +Ag0ACwsgA0EBcUUNACAEIAlqIgQgBCkDACIYQn+FQgeIQoGChIiQoMCAAYMgGEL//v379+/fv/8A +hHw3AwALAkACQCANQQhPBEAgCSANaiAJKQAANwAADAELIA0EQCAJQQhqIAkgDfwKAAALIA1FDQEL +IAlBCGohECAJQQxrIRNBASECQQAhBANAIAQhByACIQQCQCAHIAlqIhQtAABBgAFHDQAgEyAHQXRs +aiEGAkADQCAGKAIAIgIgBigCBCACGyIKIAtxIgUhAiAFIAlqKQAAQoCBgoSIkKDAgH+DIhlQBEBB +CCEDA0AgAiADaiECIANBCGohAyAJIAIgC3EiAmopAABCgIGChIiQoMCAf4MiGVANAAsLIAkgGXqn +QQN2IAJqIAtxIgJqLAAAQQBOBEAgCSkDAEKAgYKEiJCgwIB/g3qnQQN2IQILIAIgBWsgByAFa3Mg +C3FBCEkNASACIAlqIgMtAAAgAyAKQRl2IgM6AAAgECACQQhrIAtxaiADOgAAIBMgAkF0bGohA0H/ +AUcEQCAGLQAAIQIgBiADLQAAOgAAIAMgAjoAACAGLQABIQIgBiADLQABOgABIAMgAjoAASAGLQAC +IQIgBiADLQACOgACIAMgAjoAAiAGLQADIQIgBiADLQADOgADIAMgAjoAAyAGLQAEIQIgBiADLQAE +OgAEIAMgAjoABCAGLQAFIQIgBiADLQAFOgAFIAMgAjoABSAGLQAGIQIgBiADLQAGOgAGIAMgAjoA +BiAGLQAHIQIgBiADLQAHOgAHIAMgAjoAByAGLQAIIQIgBiADLQAIOgAIIAMgAjoACCAGLQAJIQIg +BiADLQAJOgAJIAMgAjoACSAGLQAKIQIgBiADLQAKOgAKIAMgAjoACiAGLQALIQIgBiADLQALOgAL +IAMgAjoACwwBCwsgFEH/AToAACAQIAdBCGsgC3FqQf8BOgAAIANBCGogBkEIaigAADYAACADIAYp +AAA3AAAMAQsgFCAKQRl2IgI6AAAgECAHQQhrIAtxaiACOgAACyAEIAQgDUkiB2ohAiAHDQALC0HM +gsEAIBIgCGs2AgBBgYCAgHghAgwDC0EEQQggAkEESRshBAwBCxCQASAPKAIEIQQgDygCACECDAEL +AkACQCAErUIMfiIYQiCIpw0AIBinIgJBeEsNACACQQdqQXhxIgMgBEEIaiIHaiIFIANJIAVB+P// +/wdLcg0AQbmCwQAtAAAaIAVBCBDFASICDQFBCCAFEOwBAAsQkAEgDygCDCEEIA8oAgghAgwBCyAC +IANqIQwgBwRAIAxB/wEgB/wLAAsgBEEBayIRIARBA3ZBB2wgBEEJSRshEEHEgsEAKAIAIQMgCARA +IAxBDGshEiAMQQhqIRMgA0EMayEJIAMpAwBCf4VCgIGChIiQoMCAf4MhGSADIQJBACEEIAghBwNA +IBlQBEADQCAEQQhqIQQgAkEIaiICKQMAQoCBgoSIkKDAgH+DIhhCgIGChIiQoMCAf1ENAAsgGEKA +gYKEiJCgwIB/hSEZCyAMIAkgGXqnQQN2IARqIhRBdGxqIgooAgAiBSAKKAIEIAUbIgogEXEiDmop +AABCgIGChIiQoMCAf4MiGFAEQEEIIQYDQCAGIA5qIQUgBkEIaiEGIAwgBSARcSIOaikAAEKAgYKE +iJCgwIB/gyIYUA0ACwsgGUIBfSAZgyEZIAwgGHqnQQN2IA5qIBFxIg5qLAAAQQBOBEAgDCkDAEKA +gYKEiJCgwIB/g3qnQQN2IQ4LIAwgDmogCkEZdiIFOgAAIBMgDkEIayARcWogBToAACASIA5BdGxq +IgpBCGogCSAUQXRsaiIFQQhqKAAANgAAIAogBSkAADcAACAHQQFrIgcNAAsLQciCwQAgETYCAEHE +gsEAIAw2AgBBzILBACAQIAhrNgIAQYGAgIB4IQIgC0UNACALIA1BDGxBB2pBeHEiBGpBCWoiB0UN +ACADIARrIAcQ0QELIBcgAjYCACAXIAQ2AgQgD0EgaiQACyAAIAEQugEhB0HEgsEAKAIAIghByILB +ACgCACIEIABxIgVqKQAAQoCBgoSIkKDAgH+DIhhQBEBBCCEDA0AgAyAFaiECIANBCGohAyAIIAIg +BHEiBWopAABCgIGChIiQoMCAf4MiGFANAAsLIAggGHqnQQN2IAVqIARxIgVqLAAAIgNBAE4EQCAI +IAgpAwBCgIGChIiQoMCAf4N6p0EDdiIFai0AACEDCyAFIAhqIBY6AAAgCCAFQQhrIARxakEIaiAW +OgAAQcyCwQBBzILBACgCACADQQFxazYCAEHQgsEAQdCCwQAoAgBBAWo2AgAgCCAFQXRsaiIEQQRr +IAc2AgAgBEEIayABNgIAIARBDGsgADYCAAsgBEEEaygCACEBEHAiACABJQEmAUHAgsEAQcCCwQAo +AgBBAWo2AgAgFUEQaiQAIAALlQQBDH8gAUEBayEOIAAoAgQhCiAAKAIAIQsgACgCCCEMAkADQCAF +DQECfwJAIAIgA0kNAANAIAEgA2ohBQJAAkACQCACIANrIgdBB00EQCACIANHDQEgAiEDDAULAkAg +BUEDakF8cSIGIAVrIgQEQEEAIQADQCAAIAVqLQAAQQpGDQUgBCAAQQFqIgBHDQALIAQgB0EIayIA +TQ0BDAMLIAdBCGshAAsDQEGAgoQIIAYoAgAiCUGKlKjQAHNrIAlyQYCChAggBkEEaigCACIJQYqU +qNAAc2sgCXJxQYCBgoR4cUGAgYKEeEcNAiAGQQhqIQYgBEEIaiIEIABNDQALDAELQQAhAANAIAAg +BWotAABBCkYNAiAHIABBAWoiAEcNAAsgAiEDDAMLIAQgB0YEQCACIQMMAwsDQCAEIAVqLQAAQQpG +BEAgBCEADAILIAcgBEEBaiIERw0ACyACIQMMAgsgACADaiIGQQFqIQMCQCACIAZNDQAgACAFai0A +AEEKRw0AQQAhBSADIQYgAwwDCyACIANPDQALCyACIAhGDQJBASEFIAghBiACCyEAAkAgDC0AAARA +IAtB7OvAAEEEIAooAgwRAQANAQtBACEEIAAgCEcEQCAAIA5qLQAAQQpGIQQLIAAgCGshACABIAhq +IQcgDCAEOgAAIAYhCCALIAcgACAKKAIMEQEARQ0BCwtBASENCyANC8oEAgd/AX4jAEEQayIGJAAC +QCAALwEMIgVFBEAgACgCACAAKAIEIAEQQCECDAELIAYgASgCDCIENgIMIAYgASgCCCICNgIIIAYg +ASgCBCIDNgIEIAYgASgCACIBNgIAAkAgACkCCCIJpyIHQYCAgAhxBEAgACgCACABIAMgACgCBCgC +DBEBAA0BIAAgB0GAgID/eXFBsICAgAJyIgc2AgggBkIBNwIAIAUgA0H//wNxayIBQQAgASAFTRsh +BUEAIQMLIAQEQCAEQQxsIQgDQAJ/AkACQAJAIAIvAQBBAWsOAgIBAAsgAkEEaigCAAwCCyACQQhq +KAIADAELIAJBAmovAQAiBEHoB08EQEEEQQUgBEGQzgBJGwwBC0EBIARBCkkNABpBAkEDIARB5ABJ +GwsgAkEMaiECIANqIQMgCEEMayIIDQALCwJAAkAgBUH//wNxIANLBEAgBSADayEDQQAhAkEAIQEC +QAJAAkAgB0EddkEDcUEBaw4DAAEAAgsgAyEBDAELIANB/v8DcUEBdiEBCyAHQf///wBxIQggACgC +BCEHIAAoAgAhBANAIAJB//8DcSABQf//A3FPDQIgAkEBaiECIAQgCCAHKAIQEQAARQ0ACwwDCyAA +KAIAIAAoAgQgBhBAIQIMAQsgBCAHIAYQQA0BQQAhBSADIAFrQf//A3EhAQNAIAVB//8DcSIDIAFJ +IQIgASADTQ0BIAVBAWohBSAEIAggBygCEBEAAEUNAAsLIAAgCTcCCAwBC0EBIQILIAZBEGokACAC +C/4DAQl/IwBBEGsiBCQAAn8CQCACKAIEIgNFDQAgACACKAIAIAMgASgCDBEBAEUNAEEBDAELIAIo +AgwiBgRAIAIoAggiAyAGQQxsaiEIIARBDGohCQNAAkACQAJAAkAgAy8BAEEBaw4CAgEACwJAIAMo +AgQiAkHBAE8EQCABQQxqKAIAIQYDQEEBIABBwO3AAEHAACAGEQEADQgaIAJBQGoiAkHAAEsNAAsM +AQsgAkUNAwsgAEHA7cAAIAIgAUEMaigCABEBAEUNAkEBDAULIAAgAygCBCADKAIIIAFBDGooAgAR +AQBFDQFBAQwECyADLwECIQIgCUEAOgAAIARBADYCCAJ/QQRBBSACQZDOAEkbIAJB6AdPDQAaQQEg +AkEKSQ0AGkECQQMgAkHkAEkbCyIGIARBCGoiCmoiB0EBayIFIAIgAkEKbiILQQpsa0EwcjoAAAJA +IAUgCkYNACAHQQJrIgUgC0EKcEEwcjoAACAEQQhqIAVGDQAgB0EDayIFIAJB5ABuQQpwQTByOgAA +IARBCGogBUYNACAHQQRrIgUgAkHoB25BCnBBMHI6AAAgBEEIaiAFRg0AIAdBBWsgAkGQzgBuQTBy +OgAACyAAIARBCGogBiABQQxqKAIAEQEARQ0AQQEMAwsgA0EMaiIDIAhHDQALC0EACyAEQRBqJAAL +zAQBCn8jAEEwayIGJAACQAJAAkACf0EAIAFBQHEiCkUNABogBkEIaiAANgIAQQEgCkHAAEYNABog +BiAAQUBrNgIMIApBgAFHDQFBAgshByABQT9xIQEgBUEFdiIJIAcgByAJSxsiCARAIAZBCGohCSAD +QQRyIQsgCEEFdCEMQQAhAwNAIAkoAgAhCCAGQShqIg0gAkEYaikCADcDACAGQSBqIg4gAkEQaikC +ADcDACAGQRhqIg8gAkEIaikCADcDACAGIAIpAgA3AxAgBkEQaiAIQcAAQgAgCxAoIAMgBGoiCEEY +aiANKQMANwAAIAhBEGogDikDADcAACAIQQhqIA8pAwA3AAAgCCAGKQMQNwAAIAlBBGohCSAMIANB +IGoiA0cNAAsLAkAgAQRAIAUgB0EFdCICSQ0BIAUgAmsiA0EfTQ0DIAFBIEcNBCACIARqIgEgACAK +aiIAKQAANwAAIAFBGGogAEEYaikAADcAACABQRBqIABBEGopAAA3AAAgAUEIaiAAQQhqKQAANwAA +IAdBAWohBwsgBkEwaiQAIAcPCyACIAVBuLzAABDVAQALIAYgAEGAAWo2AhBB8L3AAEErIAZBEGpB +nL7AAEHIvMAAEH0AC0EgIANBmLzAABDWAQALIwBBMGsiACQAIABBIDYCBCAAIAE2AgAgAEEDNgIM +IABB4IDBADYCCCAAQgI3AhQgACAAQQRqrUKAgICAkAmENwMoIAAgAK1CgICAgJAJhDcDICAAIABB +IGo2AhAgAEEIakGovMAAEKMBAAuEBAIHfwF8IwBB0ABrIgMkAAJAAkACQAJAAkAgACgCACIEJQFB +gQElARAHRQRAIAQlARAIDgICAQMLIANBBzoAMCADQTBqIAEgAhB/IQAMBAtBASEGC0EBIQdBACEA +DAELIANBEGogBCUBEAkgAygCEARAIAMrAxghCkEDIQBBASEHDAELIANBCGogBBDvAQJ/IAMoAggi +BARAIAMoAgwiBSEGQQUMAQsCQAJAIAAoAgAlARAjBEAgA0EwaiAAEHYgAygCOCEGIAMoAjQhBCAD +KAIwIQgMAQsgACgCACUBEB1FDQEgAyAAKAIAELwBIgU2AkggA0EwaiADQcgAahB2IAMoAjghBiAD +KAI0IQQgAygCMCEIIAVBhAFJDQAgBRBtCyAIQYCAgIB4Rg0AQQEhB0EGDAELIANBATYCNCADQcCT +wAA2AjAgA0IBNwI8IAMgAK1CgICAgPAChDcDSCADIANByABqNgI4IANBJGogA0EwahBHQYCAgIB4 +IQggAygCLCEGIAMoAighBCADKAIkIQVBEQshACAGrb8hCiAHIQkLIAMgCjkDOCADIAQ2AjQgAyAG +OgAxIAMgADoAMCADQTBqIAEgAhB/IQACQCAJRQRAIAcgBUVyRQ0BDAILIAgEQCAEIAgQ0QELIAVF +IAdyDQELIAQgBRDRAQsgA0HQAGokACAAC+QDAQV/IwBBEGsiCCQAAkACQAJAAkACQCABKAIIQQFG +BEAgASgCACEFIAEoAgQhBCABQQwQ0QFBHUGBASAEQQp2Z0ECdGsgBEH//wdLGyEGIAIgBWsiByAD +aiEDIAIgBUYEQCAGIQEMBgsgBkEFdiICIAdqIgFBgICAwABPBEBBuYLBAC0AABpBFEEEEMUBIgFF +DQIgAUEBNgIQIAEgAiADajYCCCABIAUgAms2AgQgASACIARqNgIAIAEgBkECdkEHcTYCDAwFCyAG +QR1xIAFBBXRyIQEMBAsgA0EASA0BAkAgA0UEQEEBIQUMAQtBuYLBAC0AABpBASEEIANBARDFASIF +RQ0CCyADBEAgBSACIAP8CgAACyABIAEoAggiAkEBazYCCCACQQFGBEAgASgCACABQQRqKAIAIgRB +ARC4AUUNAyAEENEBIAFBDBDRAQtBHUGBASADQQp2Z0ECdGsgA0H//wdLGyEBIAMhBAwEC0EEQRQQ +7AEACyAEIANBuLXAABC3AQALQfS2wABBKyAIQQ9qQeS2wABBsLfAABB9AAsgAyAHayICQQAgAiAD +TRshAyAEIAdrIQQgBSAHaiEFCyAAIAE2AgwgACAENgIIIAAgAzYCBCAAIAU2AgAgCEEQaiQAC/kD +AQJ/IAAgAWohAgJAAkAgACgCBCIDQQFxDQAgA0ECcUUNASAAKAIAIgMgAWohASAAIANrIgBB0IbB +ACgCAEYEQCACKAIEQQNxQQNHDQFByIbBACABNgIAIAIgAigCBEF+cTYCBCAAIAFBAXI2AgQgAiAB +NgIADAILIAAgAxBNCwJAAkACQCACKAIEIgNBAnFFBEAgAkHUhsEAKAIARg0CIAJB0IbBACgCAEYN +AyACIANBeHEiAhBNIAAgASACaiIBQQFyNgIEIAAgAWogATYCACAAQdCGwQAoAgBHDQFByIbBACAB +NgIADwsgAiADQX5xNgIEIAAgAUEBcjYCBCAAIAFqIAE2AgALIAFBgAJPBEAgACABEFUPCyABQfgB +cUG4hMEAaiECAn9BwIbBACgCACIDQQEgAUEDdnQiAXFFBEBBwIbBACABIANyNgIAIAIMAQsgAigC +CAshASACIAA2AgggASAANgIMIAAgAjYCDCAAIAE2AggPC0HUhsEAIAA2AgBBzIbBAEHMhsEAKAIA +IAFqIgE2AgAgACABQQFyNgIEIABB0IbBACgCAEcNAUHIhsEAQQA2AgBB0IbBAEEANgIADwtB0IbB +ACAANgIAQciGwQBByIbBACgCACABaiIBNgIAIAAgAUEBcjYCBCAAIAFqIAE2AgALC44DAQR/AkAC +QAJAAkACQCAHIAhWBEAgByAIfSAIWA0BAkAgBiAHIAZ9VCAHIAZCAYZ9IAhCAYZacUUEQCAGIAhW +DQEMBwsgAiADSQ0DDAULIAcgBiAIfSIGfSAGVg0FIAIgA0kNAyABIANqIQwgASEKAkACQANAIAMg +CUYNASAJQQFqIQkgCkEBayIKIANqIgstAABBOUYNAAsgCyALLQAAQQFqOgAAIAMgCWtBAWogA08N +ASAJQQFrIgVFDQEgC0EBakEwIAX8CwAMAQsCQCADRQRAQTEhCQwBCyABQTE6AAAgA0EBRgRAQTAh +CQwBC0EwIQkgA0EBayIKRQ0AIAFBAWpBMCAK/AsACyAEQQFqwSIEIAXBTCACIANNcg0AIAwgCToA +ACADQQFqIQMLIAIgA08NBCADIAJB+ObAABDWAQALIABBADYCAA8LIABBADYCAA8LIAMgAkGI58AA +ENYBAAsgAyACQejmwAAQ1gEACyAAIAQ7AQggACADNgIEIAAgATYCAA8LIABBADYCAAunAwECfwJA +AkACQAJAIAAtAGgiAwRAIANBwQBPDQMgAkHAACADayIEIAIgBEkbIgQEQCAAIANqIAEgBPwKAAAL +IAAgAC0AaCAEaiIDOgBoIAEgBGohASACIARrIgJFBEBBACECDAILIABBQGsgAEHAACAAKQNgIAAt +AGogAC0AaUVyECggAEIANwMAIABBADoAaCAAQQhqQgA3AwAgAEEQakIANwMAIABBGGpCADcDACAA +QSBqQgA3AwAgAEEoakIANwMAIABBMGpCADcDACAAQThqQgA3AwAgACAALQBpQQFqOgBpC0EAIQMg +AkHBAEkNASAAQUBrIQQgAC0AaSEDA0AgBCABQcAAIAApA2AgAC0AaiADQf8BcUVyECggACAALQBp +QQFqIgM6AGkgAUFAayEBIAJBQGoiAkHAAEsNAAsgAC0AaCEDCyADQf8BcSIDQcEATw0CCyACQcAA +IANrIgQgAiAESRsiAgRAIAAgA2ogASAC/AoAAAsgACAALQBoIAJqOgBoIAAPCyADQcAAQfi7wAAQ +1QEACyADQcAAQfi7wAAQ1QEAC48DAQd/IwBBEGsiBCQAAkACQAJAAkAgASgCBCICBEAgASgCACEH +IAJBA3EhBQJAIAJBBEkEQEEAIQIMAQsgB0EcaiEDIAJBfHEhCEEAIQIDQCADKAIAIANBCGsoAgAg +A0EQaygCACADQRhrKAIAIAJqampqIQIgA0EgaiEDIAggBkEEaiIGRw0ACwsgBQRAIAZBA3QgB2pB +BGohAwNAIAMoAgAgAmohAiADQQhqIQMgBUEBayIFDQALCyABKAIMRQ0CIAJBD0sNASAHKAIEDQEM +AwtBACECIAEoAgxFDQILIAJBACACQQBKG0EBdCECC0EAIQUgAkEATgRAIAJFDQFBuYLBAC0AABpB +ASEFIAJBARDFASIDDQILIAUgAkGEy8AAELcBAAtBASEDQQAhAgsgBEEANgIIIAQgAzYCBCAEIAI2 +AgAgBEGEysAAIAEQPEUEQCAAIAQpAgA3AgAgAEEIaiAEQQhqKAIANgIAIARBEGokAA8LQaTLwABB +1gAgBEEPakGUy8AAQZTMwAAQfQAL5wIBBX8CQCABQc3/e0EQIAAgAEEQTRsiAGtPDQAgAEEQIAFB +C2pBeHEgAUELSRsiBGpBDGoQKSICRQ0AIAJBCGshAQJAIABBAWsiAyACcUUEQCABIQAMAQsgAkEE +ayIFKAIAIgZBeHEgAiADakEAIABrcUEIayICIABBACACIAFrQRBNG2oiACABayICayEDIAZBA3EE +QCAAIAMgACgCBEEBcXJBAnI2AgQgACADaiIDIAMoAgRBAXI2AgQgBSACIAUoAgBBAXFyQQJyNgIA +IAEgAmoiAyADKAIEQQFyNgIEIAEgAhBEDAELIAEoAgAhASAAIAM2AgQgACABIAJqNgIACwJAIAAo +AgQiAUEDcUUNACABQXhxIgIgBEEQak0NACAAIAQgAUEBcXJBAnI2AgQgACAEaiIBIAIgBGsiBEED +cjYCBCAAIAJqIgIgAigCBEEBcjYCBCABIAQQRAsgAEEIaiEDCyADC+oCAgZ/An4jAEEgayIFJABB +FCEDIAAiCULoB1oEQCAJIQoDQCAFQQxqIANqIgRBA2sgCiAKQpDOAIAiCUKQzgB+faciBkH//wNx +QeQAbiIHQQF0IghB+evAAGotAAA6AAAgBEEEayAIQfjrwABqLQAAOgAAIARBAWsgBiAHQeQAbGtB +//8DcUEBdCIGQfnrwABqLQAAOgAAIARBAmsgBkH468AAai0AADoAACADQQRrIQMgCkL/rOIEViAJ +IQoNAAsLIAlCCVYEQCADIAVqQQtqIAmnIgQgBEH//wNxQeQAbiIEQeQAbGtB//8DcUEBdCIGQfnr +wABqLQAAOgAAIANBAmsiAyAFQQxqaiAGQfjrwABqLQAAOgAAIAStIQkLIABQRSAJUHFFBEAgA0EB +ayIDIAVBDGpqIAmnQQF0QR5xQfnrwABqLQAAOgAACyACIAFBAUEAIAVBDGogA2pBFCADaxA2IAVB +IGokAAvQAgEEfyMAQfAAayIDJAACQCAAAn4CQCABKAIEIgQgASgCDEcEQCABIARBEGo2AgQgBCgC +DCEFIAQoAgAhASACKAIEIANByABqIAQoAgQiBiAEKAIIEDcgAygCSCIERQRAIANBQGsgA0HoAGop +AwA3AwAgA0E4aiADQeAAaikDADcDACADQTBqIANB2ABqKQMANwMAIAMgAykDUDcDKAsgAQRAIAYg +ARDRAQsgBEEBcUUNAUEBOgAAQgAMAgsgAEICNwMADAILIANBIGogA0FAaykDADcDACADQRhqIANB +OGopAwA3AwAgA0EQaiADQTBqKQMANwMAIAMgAykDKDcDCEIBCzcDACAAIAMpAwg3AwggACAFNgIo +IABBEGogA0EQaikDADcDACAAQRhqIANBGGopAwA3AwAgAEEgaiADQSBqKQMANwMACyADQfAAaiQA +C9wIAQh/IwBBgAFrIgIkACACQQhqIQQjAEEgayIDJAAgAyAAaSIBNgIcAkACQAJAAkACQAJAIAFB +AUYEQCAAQcAATQ0BIANB3ILBADYCGEHggsEALQAAQQNHBH8gAyADQRhqNgIcIAMgA0EcajYCACMA +QSBrIgEkAAJAAkACQAJAAkACQEHggsEALQAAQQFrDgMCBAEAC0HggsEAQQI6AAAgAygCACIGKAIA +IQUgBkEANgIAIAVFDQIgBSgCAEEINgIAQeCCwQBBAzoAAAsgAUEgaiQADAMLIAFBADYCGCABQQE2 +AgwgAUH0mcAANgIIDAoLQbibwAAQ2QEACyABQQA2AhggAUEBNgIMIAFBtJrAADYCCAwICyADKAIY +BUHcgsEACygCACIBRQ0CIANB1ILBADYCGCAAIAFuIgZB2ILBAC0AAEEDRwR/IAMgA0EYajYCHCAD +IANBHGo2AgAjAEEgayIBJAACQAJAAkACQAJAAkBB2ILBAC0AAEEBaw4DAgQBAAtB2ILBAEECOgAA +IAMoAgAiBygCACEFIAdBADYCACAFRQ0CIAUoAgBBAjYCAEHYgsEAQQM6AAALIAFBIGokAAwDCyAB +QQA2AhggAUEBNgIMIAFB9JnAADYCCAwKC0G4m8AAENkBAAsgAUEANgIYIAFBATYCDCABQbSawAA2 +AggMCAsgAygCGAVB1ILBAAsoAgAgAGwiAU8NAyABQQBIDQRBuYLBAC0AABpBASEIIAFBARDFASIF +RQ0EIAQgATYCHCAEIAY2AhggBEHIm8AANgIIIARCADcDACAEQQA2AiggBCAFNgIkIAQgATYCICAE +IABBAWsiAK0gAGdBIHOthjcDECADQSBqJAAMBQsgA0EANgIAIwBBEGsiACQAIABB4JTAADYCDCAA +IANBHGo2AgggAEEIakGIssAAIABBDGpBiLLAACADQciVwAAQUAALQdiVwABBKEGAlsAAEJcBAAtB +kJbAABCdAQALQaCWwABBL0HQlsAAEJcBAAsgCCABQeCWwAAQtwEACyACQThqIgBBADoAACACQfgA +aiAAKQMANwIAIAJB8ABqIAJBMGopAwA3AgAgAkHoAGogAkEoaikDADcCACACQeAAaiACQSBqKQMA +NwIAIAJB2ABqIAJBGGopAwA3AgAgAkHQAGogAkEQaikDADcCAEG5gsEALQAAGiACIAIpAwg3AkhB +yABBCBDFASIARQRAQQhByAAQ7AEACyAAQQA2AgggAEKBgICAEDcDACAAIAIpAkQ3AgwgAEEUaiAC +QcwAaikCADcCACAAQRxqIAJB1ABqKQIANwIAIABBJGogAkHcAGopAgA3AgAgAEEsaiACQeQAaikC +ADcCACAAQTRqIAJB7ABqKQIANwIAIABBPGogAkH0AGopAgA3AgAgAEHEAGogAkH8AGooAgA2AgAg +AkGAAWokACAAQQhqDwsgAUIENwIQIAFBCGpBrJjAABCjAQAL5gIBCH8jAEEQayIFJABBCiECIAAi +A0HoB08EQCADIQQDQCAFQQZqIAJqIgZBA2sgBCAEQZDOAG4iA0GQzgBsayIHQf//A3FB5ABuIghB +AXQiCUH568AAai0AADoAACAGQQRrIAlB+OvAAGotAAA6AAAgBkEBayAHIAhB5ABsa0H//wNxQQF0 +IgdB+evAAGotAAA6AAAgBkECayAHQfjrwABqLQAAOgAAIAJBBGshAiAEQf+s4gRLIAMhBA0ACwsC +QCADQQlNBEAgAyEEDAELIAIgBWpBBWogAyADQf//A3FB5ABuIgRB5ABsa0H//wNxQQF0IgNB+evA +AGotAAA6AAAgAkECayICIAVBBmpqIANB+OvAAGotAAA6AAALQQAgACAEG0UEQCACQQFrIgIgBUEG +amogBEEBdEEecUH568AAai0AADoAAAsgAUEBQQFBACAFQQZqIAJqQQogAmsQNiAFQRBqJAALggMB +BH8gACgCDCECAkACQAJAIAFBgAJPBEAgACgCGCEDAkACQCAAIAJGBEAgAEEUQRAgACgCFCICG2oo +AgAiAQ0BQQAhAgwCCyAAKAIIIgEgAjYCDCACIAE2AggMAQsgAEEUaiAAQRBqIAIbIQQDQCAEIQUg +ASICQRRqIAJBEGogAigCFCIBGyEEIAJBFEEQIAEbaigCACIBDQALIAVBADYCAAsgA0UNAgJAIAAo +AhxBAnRBqIPBAGoiASgCACAARwRAIAMoAhAgAEYNASADIAI2AhQgAg0DDAQLIAEgAjYCACACRQ0E +DAILIAMgAjYCECACDQEMAgsgACgCCCIAIAJHBEAgACACNgIMIAIgADYCCA8LQcCGwQBBwIbBACgC +AEF+IAFBA3Z3cTYCAA8LIAIgAzYCGCAAKAIQIgEEQCACIAE2AhAgASACNgIYCyAAKAIUIgBFDQAg +AiAANgIUIAAgAjYCGA8LDwtBxIbBAEHEhsEAKAIAQX4gACgCHHdxNgIAC+ACAQR/IwBBEGsiAiQA +AkAgAUGAAU8EQCACQQxqIgRBAnIhAyACQQA2AgwCQCABQYAQTwRAIARBA3IhBSABQYCABE8EQCAC +QRBqIQMgAiABQRJ2QfABcjoADCACIAFBBnZBP3FBgAFyOgAOIAIgAUEMdkE/cUGAAXI6AA0gBSEE +DAILIAIgAUEMdkHgAXI6AAwgAiABQQZ2QT9xQYABcjoADSADIQQgBSEDDAELIAJBDGpBAXIhBCAC +IAFBBnZBwAFyOgAMCyAEIAFBP3FBgAFyOgAAIAMgAkEMamsiASAAKAIAIAAoAggiA2tLBEAgACAD +IAFBAUEBEFcgACgCCCEDCyABBEAgACgCBCADaiACQQxqIAH8CgAACyAAIAEgA2o2AggMAQsgACgC +CCIDIAAoAgBGBEAgAEGIg8AAEHILIAAoAgQgA2ogAToAACAAIANBAWo2AggLIAJBEGokAEEAC+AC +AQR/IwBBEGsiAiQAAkAgAUGAAU8EQCACQQxqIgRBAnIhAyACQQA2AgwCQCABQYAQTwRAIARBA3Ih +BSABQYCABE8EQCACQRBqIQMgAiABQRJ2QfABcjoADCACIAFBBnZBP3FBgAFyOgAOIAIgAUEMdkE/ +cUGAAXI6AA0gBSEEDAILIAIgAUEMdkHgAXI6AAwgAiABQQZ2QT9xQYABcjoADSADIQQgBSEDDAEL +IAJBDGpBAXIhBCACIAFBBnZBwAFyOgAMCyAEIAFBP3FBgAFyOgAAIAMgAkEMamsiASAAKAIAIAAo +AggiA2tLBEAgACADIAFBAUEBEFcgACgCCCEDCyABBEAgACgCBCADaiACQQxqIAH8CgAACyAAIAEg +A2o2AggMAQsgACgCCCIDIAAoAgBGBEAgAEHcjsAAEHILIAAoAgQgA2ogAToAACAAIANBAWo2AggL +IAJBEGokAEEAC7MCAQF/IwBB8ABrIgYkACAGIAE2AgwgBiAANgIIIAYgAzYCFCAGIAI2AhAgBkGM +gsEAKAIANgIcIAZBgILBACgCADYCGAJAIAQoAgAEQCAGQTBqIARBEGopAgA3AwAgBkEoaiAEQQhq +KQIANwMAIAYgBCkCADcDICAGQQQ2AlwgBkGg68AANgJYIAZCBDcCZCAGIAZBEGqtQoCAgICADIQ3 +A1AgBiAGQQhqrUKAgICAgAyENwNIIAYgBkEgaq1CgICAgKAMhDcDQAwBCyAGQQM2AlwgBkHs6sAA +NgJYIAZCAzcCZCAGIAZBEGqtQoCAgICADIQ3A0ggBiAGQQhqrUKAgICAgAyENwNACyAGIAZBGGqt +QoCAgICQDIQ3AzggBiAGQThqNgJgIAZB2ABqIAUQowEAC/ICAQF/AkAgAgRAIAEtAABBME0NASAF +QQI7AQACQAJAAkACQAJAIAPBIgZBAEoEQCAFIAE2AgQgAiADQf//A3EiA0sNASAFQQA7AQwgBSAC +NgIIIAUgAyACazYCECAEDQJBAiEBDAULIAUgAjYCICAFIAE2AhwgBUECOwEYIAVBADsBDCAFQQI2 +AgggBUGx6MAANgIEIAVBACAGayIDNgIQQQMhASACIARPDQQgBCACayICIANNDQQgAiAGaiEEDAML +IAVBAjsBGCAFQQE2AhQgBUGw6MAANgIQIAVBAjsBDCAFIAM2AgggBSACIANrIgI2AiAgBSABIANq +NgIcIAIgBEkNAUEDIQEMAwsgBUEBNgIgIAVBsOjAADYCHCAFQQI7ARgMAQsgBCACayEECyAFIAQ2 +AiggBUEAOwEkQQQhAQsgACABNgIEIAAgBTYCAA8LQZjlwABBIUG858AAEJcBAAtBzOfAAEEfQezn +wAAQlwEAC8oCAQZ/IAEgAkEBdGohCSAAQYD+A3FBCHYhCiAAQf8BcSEMAkACQAJAAkADQCABQQJq +IQsgByABLQABIgJqIQggCiABLQAAIgFHBEAgASAKSw0EIAghByALIgEgCUcNAQwECyAHIAhLDQEg +BCAISQ0CIAMgB2ohAQNAIAJFBEAgCCEHIAsiASAJRw0CDAULIAJBAWshAiABLQAAIAFBAWohASAM +Rw0ACwtBACECDAMLIAcgCEGI8cAAENcBAAsgCCAEQYjxwAAQ1gEACyAAQf//A3EhByAFIAZqIQNB +ASECA0AgBUEBaiEAAkAgBSwAACIBQQBOBEAgACEFDAELIAAgA0cEQCAFLQABIAFB/wBxQQh0ciEB +IAVBAmohBQwBC0H48MAAENkBAAsgByABayIHQQBIDQEgAkEBcyECIAMgBUcNAAsLIAJBAXELygIB +A38jAEEQayICJAACQCABQYABTwRAIAJBADYCDAJ/IAFBgBBPBEAgAUGAgARPBEAgAkEMakEDciEE +IAIgAUESdkHwAXI6AAwgAiABQQZ2QT9xQYABcjoADiACIAFBDHZBP3FBgAFyOgANQQQMAgsgAkEM +akECciEEIAIgAUEMdkHgAXI6AAwgAiABQQZ2QT9xQYABcjoADUEDDAELIAJBDGpBAXIhBCACIAFB +BnZBwAFyOgAMQQILIQMgBCABQT9xQYABcjoAACAAKAIAIAAoAggiAWsgA0kEQCAAIAEgAxBoIAAo +AgghAQsgAwRAIAAoAgQgAWogAkEMaiAD/AoAAAsgACABIANqNgIIDAELIAAoAggiAyAAKAIARgRA +IABBpMzAABByCyAAIANBAWo2AgggACgCBCADaiABOgAACyACQRBqJABBAAvGAgECfyMAQRBrIgIk +AAJAIAFBgAFPBEAgAkEANgIMAn8gAUGAEE8EQCABQYCABE8EQCACIAFBP3FBgAFyOgAPIAIgAUES +dkHwAXI6AAwgAiABQQZ2QT9xQYABcjoADiACIAFBDHZBP3FBgAFyOgANQQQMAgsgAiABQT9xQYAB +cjoADiACIAFBDHZB4AFyOgAMIAIgAUEGdkE/cUGAAXI6AA1BAwwBCyACIAFBP3FBgAFyOgANIAIg +AUEGdkHAAXI6AAxBAgsiASAAKAIAIAAoAggiA2tLBEAgACADIAEQXyAAKAIIIQMLIAEEQCAAKAIE +IANqIAJBDGogAfwKAAALIAAgASADajYCCAwBCyAAKAIIIgMgACgCAEYEQCAAQbjFwAAQcgsgACgC +BCADaiABOgAAIAAgA0EBajYCCAsgAkEQaiQAQQALxAIBBH8gAEIANwIQIAACf0EAIAFBgAJJDQAa +QR8gAUH///8HSw0AGiABQQYgAUEIdmciA2t2QQFxIANBAXRrQT5qCyICNgIcIAJBAnRBqIPBAGoh +BEEBIAJ0IgNBxIbBACgCAHFFBEAgBCAANgIAIAAgBDYCGCAAIAA2AgwgACAANgIIQcSGwQBBxIbB +ACgCACADcjYCAA8LAkACQCABIAQoAgAiAygCBEF4cUYEQCADIQIMAQsgAUEZIAJBAXZrQQAgAkEf +Rxt0IQUDQCADIAVBHXZBBHFqIgQoAhAiAkUNAiAFQQF0IQUgAiEDIAIoAgRBeHEgAUcNAAsLIAIo +AggiASAANgIMIAIgADYCCCAAQQA2AhggACACNgIMIAAgATYCCA8LIARBEGogADYCACAAIAM2Ahgg +ACAANgIMIAAgADYCCAv3AgEEfyMAQTBrIgAkAAJAAkBBmILBACgCAEUEQEGwgsEAKAIAIQFBsILB +AEEANgIAIAFFDQEgAEEYaiABEQUAIABBEGoiAiAAQSRqKQIANwMAIAAgACkCHDcDCCAAKAIYIQFB +mILBACgCACIDDQICQCADRQ0AQZyCwQAoAgAiAkUNAEGggsEAKAIAIAJBAnQQ0QELQZyCwQAgATYC +AEGYgsEAQQE2AgBBoILBACAAKQMINwIAQaiCwQAgAEEQaikDADcCAAsgAEEwaiQAQZyCwQAPCyAA +QQA2AiggAEEBNgIcIABB/MDAADYCGCAAQgQ3AiAgAEEYakHowcAAEKMBAAsgAEEoaiACKQMANwIA +IAAgACkDCDcCICAAIAE2AhwgAEEBNgIYAkAgAEEYaiIBKAIARQ0AIAEoAgQiAkUNACABKAIIIAJB +AnQQ0QELIABBADYCKCAAQQE2AhwgAEGIwsAANgIYIABCBDcCICABQZDCwAAQowEAC/wBAgR/AX4j +AEEgayIFJAACQAJAIARFDQAgASABIAJqIgJLDQAgAyAEakEBa0EAIANrca0gAiAAKAIAIgFBAXQi +BiACIAZLGyICQQhBBEEBIARBgQhJGyAEQQFGGyIGIAIgBksbIgatfiIJQiCIUEUNACAJpyIIQYCA +gIB4IANrSw0AQQAhAiAFIAEEfyAFIAEgBGw2AhwgBSAAKAIENgIUIAMFIAILNgIYIAVBCGogAyAI +IAVBFGoQdCAFKAIIQQFHDQEgBSgCECECIAUoAgwhBwsgByACQeCLwAAQtwEACyAFKAIMIQEgACAG +NgIAIAAgATYCBCAFQSBqJAALygECBH8BfiMAQSBrIgMkAAJAAkAgASABIAJqIgJLDQBBCCACIAAo +AgAiAUEBdCIEIAIgBEsbIgIgAkEITRsiBK0iB0IgiFBFDQAgB6ciBUH/////B0sNACADIAEEfyAD +IAE2AhwgAyAAKAIENgIUQQEFQQALNgIYIANBCGpBASAFIANBFGoQdCADKAIIQQFHDQEgAygCECEC +IAMoAgwhBgsgBiACQbiZwAAQtwEACyADKAIMIQEgACAENgIAIAAgATYCBCADQSBqJAALiQIBAX8j +AEEQayICJAAgACgCACEAAn8gAS0AC0EYcUUEQCABKAIAIAAgASgCBCgCEBEAAAwBCyACQQA2Agwg +ASACQQxqAn8gAEGAAU8EQCAAQYAQTwRAIABBgIAETwRAIAIgAEE/cUGAAXI6AA8gAiAAQRJ2QfAB +cjoADCACIABBBnZBP3FBgAFyOgAOIAIgAEEMdkE/cUGAAXI6AA1BBAwDCyACIABBP3FBgAFyOgAO +IAIgAEEMdkHgAXI6AAwgAiAAQQZ2QT9xQYABcjoADUEDDAILIAIgAEE/cUGAAXI6AA0gAiAAQQZ2 +QcABcjoADEECDAELIAIgADoADEEBCxA6CyACQRBqJAALqgICA38BfiMAQUBqIgIkACABKAIAQYCA +gIB4RgRAIAEoAgwhAyACQSRqIgRBADYCACACQoCAgIAQNwIcIAJBMGogAygCACIDQQhqKQIANwMA +IAJBOGogA0EQaikCADcDACACIAMpAgA3AyggAkEcakGoxsAAIAJBKGoQPBogAkEYaiAEKAIAIgM2 +AgAgAiACKQIcIgU3AxAgAUEIaiADNgIAIAEgBTcCAAsgASkCACEFIAFCgICAgBA3AgAgAkEIaiID +IAFBCGoiASgCADYCACABQQA2AgBBuYLBAC0AABogAiAFNwMAQQxBBBDFASIBRQRAQQRBDBDsAQAL +IAEgAikDADcCACABQQhqIAMoAgA2AgAgAEHEyMAANgIEIAAgATYCACACQUBrJAALmgIBA38jAEEQ +ayIGJAAgASABKAIIIgVBACAFQQFHGzYCCAJAAkACQCAFQQFGBEAgASgCBCEEIAEoAgAhBSABQQwQ +0QEgA0UNASAFIAIgA/wKAAAMAQsgA0EASA0BAkAgA0UEQEEBIQUMAQtBuYLBAC0AABpBASEEIANB +ARDFASIFRQ0CCyADBEAgBSACIAP8CgAACyABIAEoAggiAkEBazYCCCADIQQgAkEBRw0AIAEoAgAg +AUEEaigCACIEQQEQuAFFDQIgBBDRASABQQwQ0QEgAyEECyAAIAM2AgggACAFNgIEIAAgBDYCACAG +QRBqJAAPCyAEIANBuLXAABC3AQALQfS2wABBKyAGQQ9qQeS2wABBsLfAABB9AAuCAgIBfgJ/IwBB +gAFrIgQkACAAKAIAKQMAIQICfwJAIAEoAggiAEGAgIAQcUUEQCAAQYCAgCBxDQEgAkEBIAEQSQwC +C0EAIQADQCAAIARqQf8AaiACp0EPcSIDQTByIANB1wBqIANBCkkbOgAAIABBAWshACACQg9WIAJC +BIghAg0ACyABQQFB9uvAAEECIAAgBGpBgAFqQQAgAGsQNgwBC0EAIQADQCAAIARqQf8AaiACp0EP +cSIDQTByIANBN2ogA0EKSRs6AAAgAEEBayEAIAJCD1YgAkIEiCECDQALIAFBAUH268AAQQIgACAE +akGAAWpBACAAaxA2CyAEQYABaiQAC4gCAQV/AkACQAJAAkAgASgCACIBQQFxBEBBHUGBASACIAFB +fnEiBWsiBiADaiIBQQp2Z0ECdGsgAUH//wdLGyEEIAIgBUYEQCAEIQIgASEDDAULIARBBXYiByAG +aiICQYCAgMAASQ0CQbmCwQAtAAAaQRRBBBDFASICRQ0BIAJBATYCECACIAEgB2oiCDYCCCACIAUg +B2s2AgQgAiAINgIAIAIgBEECdkEHcTYCDAwDCyAAIAEgAiADEEMPC0EEQRQQ7AEACyAEQR1xIAJB +BXRyIQILIAEgBmsiBEEAIAEgBE8bIQEgBSAGaiEFCyAAIAI2AgwgACADNgIIIAAgATYCBCAAIAU2 +AgALgwIBBX8CQAJAAkACQCABKAIAIgFBAXEEQEEdQYEBIAIgAWsiBiADaiIEQQp2Z0ECdGsgBEH/ +/wdLGyEFIAEgAkYEQCAFIQIgBCEDDAULIAVBBXYiByAGaiICQYCAgMAASQ0CQbmCwQAtAAAaQRRB +BBDFASICRQ0BIAJBATYCECACIAQgB2oiCDYCCCACIAEgB2s2AgQgAiAINgIAIAIgBUECdkEHcTYC +DAwDCyAAIAEgAiADEEMPC0EEQRQQ7AEACyAFQR1xIAJBBXRyIQILIAQgBmsiBUEAIAQgBU8bIQQg +ASAGaiEBCyAAIAI2AgwgACADNgIIIAAgBDYCBCAAIAE2AgAL1QECBH8BfiMAQSBrIgMkAAJAAkAg +ASABIAJqIgJLBEBBACEBDAELQQAhAUEIIAIgACgCACIFQQF0IgQgAiAESxsiAiACQQhNGyIErSIH +QiCIUEUNACAHpyIGQf////8HSw0AIAMgBQR/IAMgBTYCHCADIAAoAgQ2AhRBAQVBAAs2AhggA0EI +akEBIAYgA0EUahB0IAMoAghBAUcNASADKAIQIQIgAygCDCEBCyABIAJBmMbAABC3AQALIAMoAgwh +ASAAIAQ2AgAgACABNgIEIANBIGokAAvKAgIEfwFvIwBBIGsiAyQAEBohBxBwIgUgByYBIANBGGoi +BCAFNgIEIAQgAjYCACADKAIcIQICQCADKAIYIgRFBEBBASEFDAELIAMgAjYCHCADIAQ2AhggA0EQ +aiIEIAEoAgQgASgCCBC6ATYCBCAEQQA2AgBBASEFIAMoAhQhBAJAAkAgAygCEEEBcQRAIAIhASAE +IQIMAQsgA0EcaiIGQbiEwABBBBA9IAQQ0gEgASgCDLgQDCEHEHAiBCAHJgEgA0EIaiICIAQ2AgQg +AkEANgIAIAMoAgwhAiADKAIIQQFxRQ0BIAMoAhwhAQsgAUGEAUkNASABEG0MAQsgBkG8hMAAQQYQ +PSACENIBIAEtABAhASAGQe6EwABBBRA9QYIBQYMBIAEbENIBQQAhBSADKAIcIQILIAAgAjYCBCAA +IAU2AgAgA0EgaiQAC6gCAQR/IwBBIGsiBCQAQQEhBgJAIAAoAgAiBSABIAIgACgCBCIHKAIMIgER +AQANAAJAIAAtAApBgAFxRQRAIAVB8uvAAEEBIAERAQANAiADIABBpIPAACgCABEAAEUNAQwCCyAF +QfPrwABBAiABEQEADQEgBEEBOgAPIAQgBzYCBCAEIAU2AgAgBEHU68AANgIUIAQgACkCCDcCGCAE +IARBD2o2AgggBCAENgIQIAMgBEEQakGkg8AAKAIAEQAADQEgBCgCEEHw68AAQQIgBCgCFCgCDBEB +AA0BCwJAIAINACAALQAKQYABcQ0AIAAoAgBB9evAAEEBIAAoAgQoAgwRAQANAQsgACgCAEH06MAA +QQEgACgCBCgCDBEBACEGCyAEQSBqJAAgBgvZAwEHfyMAQRBrIgYkAAJAAkAgAkEHTQRAIAINAQwC +CyAGQQhqIQcCQAJAAkACQCABQQNqQXxxIgMgAUYNACACIAMgAWsiAyACIANJGyIERQ0AQQAhA0EB +IQUDQCABIANqLQAAQS5GDQQgBCADQQFqIgNHDQALIAQgAkEIayIISw0CDAELIAJBCGshCEEAIQQL +Qa7cuPECIQMDQEGAgoQIIAEgBGoiCSgCAEGu3LjxAnMiBWsgBXJBgIKECCAJQQRqKAIAQa7cuPEC +cyIFayAFcnFBgIGChHhxQYCBgoR4Rw0BIARBCGoiBCAITQ0ACwsgAiAERwRAQS4hA0EBIQUDQCAB +IARqLQAAQS5GBEAgBCEDDAMLIAIgBEEBaiIERw0ACwtBACEFCyAHIAM2AgQgByAFNgIAIAYoAghB +AUYhAwwBCyABLQAAQS5GIgMgAkEBRnINACABLQABQS5GIgMgAkECRnINACABLQACQS5GIgMgAkED +RnINACABLQADQS5GIgMgAkEERnINACABLQAEQS5GIgMgAkEFRnINACABLQAFQS5GIgMgAkEGRnIN +ACABLQAGQS5GIQMLIAAgAyAALQAEcjoABCAAKAIAIAEgAhDBASAGQRBqJAAL5AEBBH8jAEEQayID +JAAgACgCDCEBAkACfwJAAkACQAJAAkAgACgCBA4CAAECCyABDQFBASEBQQAhAEEBIQIMAwsgAUUN +AQsgA0EEaiAAEEcgAygCBCEAIAMoAgghAiADKAIMDAILIAAoAgAiASgCBCIAQQBIDQIgASgCACEB +IABFBEBBASECQQAhAAwBC0G5gsEALQAAGkEBIQQgAEEBEMUBIgJFDQILIAAEQCACIAEgAPwKAAAL +IAALIQEgAiABELsBIAAEQCACIAAQ0QELIANBEGokAA8LIAQgAEHokMAAELcBAAuUAgIBfwF+IwBB +oAFrIgIkACACQoCAgICQByIDIAFBGGqthDcDOCACIAMgAUEQaq2ENwMwIAIgAyABQQhqrYQ3Aygg +AiADIAGthDcDICACQey5wAA2AgggAkEENgIMIAJBBDYCHCACQoOAgICAhICAaTcCmAEgAkGAgMAA +NgKQASACQQI7AYgBIAJCgoCAgICEgIBpNwKAASACQYCAwAA2AnggAkECOwFwIAJCgYCAgICEgIBp +NwJoIAJBgIDAADYCYCACQQI7AVggAkKAgICAgISAgGk3AlAgAkKAgMAANwJIIAJBAjsBQCACIAJB +QGs2AhggAkEENgIUIAIgAkEgajYCECAAIAJBCGoQRyACQaABaiQAC/IBAQJ/IwBBMGsiAiQAAkAg +ACkDAEL///////////8Ag0KAgICAgICA+P8AWgRAIAJBATYCFCACQcTAwAA2AhAgAkIBNwIcIAIg +AK1CgICAgLAIhDcDKCACIAJBKGo2AhggASgCACABKAIEIAJBEGoQPCEDDAELIAJBADoADCACIAE2 +AghBASEDIAJBATYCFCACQcTAwAA2AhAgAkIBNwIcIAIgAK1CgICAgLAIhDcDKCACIAJBKGo2Ahgg +AkEIakGsvsAAIAJBEGoQPA0AIAItAAxFBEAgAUHMwMAAQQIQwQENAQtBACEDCyACQTBqJAAgAwuV +AgECfyMAQSBrIgUkAEGkg8EAQaSDwQAoAgAiBkEBajYCAAJ/QQAgBkEASA0AGkEBQfCGwQAtAAAN +ABpB8IbBAEEBOgAAQeyGwQBB7IbBACgCAEEBajYCAEECC0H/AXEiBkECRwRAIAZBAXEEQCAFQQhq +IAAgASgCGBECAAsACwJAQZiDwQAoAgAiBkEATgRAQZiDwQAgBkEBajYCAEGcg8EAKAIABEAgBSAA +IAEoAhQRAgAgBSAEOgAdIAUgAzoAHCAFIAI2AhggBSAFKQMANwIQQZyDwQAoAgAgBUEQakGgg8EA +KAIAKAIUEQIAC0GYg8EAQZiDwQAoAgBBAWs2AgBB8IbBAEEAOgAAIANFDQEACwALAAvEAQIGfwF+ +IwBBIGsiAiQAQQQgACgCACIFQQF0IgMgA0EETRsiBq1CFH4iCEIgiFBFBEBBAEEAIAEQtwEACwJA +IAinIgdB/P///wdNBEBBACEDIAIgBQR/IAIgBUEUbDYCHCACIAAoAgQ2AhRBBAUgAws2AhggAkEI +akEEIAcgAkEUahB0IAIoAghBAUcNASACKAIMIQQgAigCECEDCyAEIAMgARC3AQALIAIoAgwhASAA +IAY2AgAgACABNgIEIAJBIGokAAu7AQECfyMAQSBrIgMkAAJAAn9BACABIAEgAmoiAksNABpBAEEI +IAIgACgCACIBQQF0IgQgAiAESxsiAiACQQhNGyIEQQBIDQAaQQAhAiADIAEEfyADIAE2AhwgAyAA +KAIENgIUQQEFIAILNgIYIANBCGpBASAEIANBFGoQdCADKAIIQQFHDQEgAygCECEAIAMoAgwLIABB +2MrAABC3AQALIAMoAgwhASAAIAQ2AgAgACABNgIEIANBIGokAAvAAQEFfyMAQSBrIgEkACAAKAIA +IgJB////P0sEQEEAQQBB7InAABC3AQALAkBBBCACQQF0IgMgA0EETRsiA0EEdCIEQfz///8HTQR/ +IAEgAgR/IAEgAkEEdDYCHCABIAAoAgQ2AhRBBAVBAAs2AhggAUEIakEEIAQgAUEUahB0IAEoAghB +AUcNASABKAIQIQUgASgCDAVBAAsgBUHsicAAELcBAAsgASgCDCECIAAgAzYCACAAIAI2AgQgAUEg +aiQAC70BAQN/IwBBEGsiAiQAAkACQAJAIAFFBEAgAEUNASAAQQhrIgEoAgBBAUcNAiAAKAIsIAAo +AighAyABQQA2AgACQCABQX9GDQAgAEEEayIAIAAoAgBBAWsiADYCACAADQAgAUHIABDRAQsgA0UN +AyADENEBDAMLIABFDQAgAiAAQQhrIgA2AgwgACAAKAIAQQFrIgA2AgAgAA0CIAJBDGoQlAEMAgsQ +5QEAC0HzhMAAQT8Q5wEACyACQRBqJAALwQECA38BfiMAQTBrIgIkACABKAIAQYCAgIB4RgRAIAEo +AgwhAyACQRRqIgRBADYCACACQoCAgIAQNwIMIAJBIGogAygCACIDQQhqKQIANwMAIAJBKGogA0EQ +aikCADcDACACIAMpAgA3AxggAkEMakGoxsAAIAJBGGoQPBogAkEIaiAEKAIAIgM2AgAgAiACKQIM +IgU3AwAgAUEIaiADNgIAIAEgBTcCAAsgAEHEyMAANgIEIAAgATYCACACQTBqJAALtgEBAX8jAEEQ +ayIDJAACQAJAAkAgACgCACIAQQFxBEAgASAAQX5xIgBrIAJqIgFBARC4AUUNAiAAIAEQ0QEMAQsg +ACAAKAIIIgFBAWs2AgggAUEBRw0AIAAoAgAgAEEEaigCACICQQEQuAFFDQIgAhDRASAAQQwQ0QEL +IANBEGokAA8LQfS2wABBKyADQQ9qQeS2wABBoLfAABB9AAtB9LbAAEErIANBD2pB5LbAAEGwt8AA +EH0AC7ABAQZ/AkACQCAAQYQBSQ0AIADQbyYBEFYiASgCDCEFIAEoAhAhAiABQgA3AgwgASgCCCED +IAEoAgQhBCABQgQ3AgQgASgCACEGIAFBADYCACAAIAJJDQEgACACayIAIANPDQEgBCAAQQJ0aiAF +NgIAIAEgAjYCECABIAA2AgwgASADNgIIIAEoAgQgASAENgIEIAEoAgAhACABIAY2AgAgAEUNACAA +QQJ0ENEBCw8LAAu5AQEBf0G5gsEALQAAGgJAQQxBBBDFASIGBEAgBkECNgIIIAYgAzYCACAGIAQg +A2sgBWo2AgQgASAGIAEoAgAiASABIAJGIgIbNgIAIAJFBEAgASABKAIIIgJBAWo2AgggAkEASA0C +IAAgATYCDCAAIAU2AgggACAENgIEIABBwLfAADYCACAGQQwQ0QEPCyAAIAY2AgwgACAFNgIIIAAg +BDYCBCAAQcC3wAA2AgAPC0EEQQwQ7AEACwALsQEBAX8jAEEQayIDJAACQAJAAkAgACgCACIAQQFx +BEAgASAAayACaiIBQQEQuAFFDQIgACABENEBDAELIAAgACgCCCIBQQFrNgIIIAFBAUcNACAAKAIA +IABBBGooAgAiAkEBELgBRQ0CIAIQ0QEgAEEMENEBCyADQRBqJAAPC0H0tsAAQSsgA0EPakHktsAA +QaC3wAAQfQALQfS2wABBKyADQQ9qQeS2wABBsLfAABB9AAvPAwIMfwF+IwBBIGsiBCQAIARBGGoi +CRBWIgVBEGoiBygCADYCACAEQRBqIgogBUEIaiIIKQIANwMAIAdBADYCACAIQgA3AgAgBSkCACEM +IAVCgICAgMAANwIAIAQgDDcDCAJ/IwBBIGsiAyQAAkACQCAEQQhqIgAoAgwiASAAKAIIIgJGBEAC +QCAAKAIAIgIgAUYEQNBvQYABIAEgAUGAAU0bIgb8DwEiAkF/Rg0EAkAgACgCECILRQRAIAAgAjYC +EAwBCyABIAtqIAJHDQULIAEgBmoiAkH/////AUsNBCADIAEEfyADIAFBAnQ2AhwgAyAAKAIENgIU +QQQFQQALNgIYIANBCGpBBCACQQJ0IANBFGoQdCADKAIIQQFGDQQgAygCDCEGIAAgAjYCACAAIAY2 +AgQMAQsgASACTw0DCyAAIAFBAWoiAjYCCCAAKAIEIAFBAnRqIAI2AgAMAQsgASACTw0BCyAAIAAo +AgQgAUECdGooAgA2AgwgACgCECADQSBqJAAgAWoMAQsACyAIIAopAwA3AgAgByAJKAIANgIAIAUo +AgQhAyAFKAIAIQEgBSAEKQMINwIAIAEEQCADIAFBAnQQ0QELIARBIGokAAusAQEBfyMAQRBrIgYk +AAJAIAEEQCAGQQRqIAEgAyAEIAUgAigCEBEJAAJAIAYoAgQiAiAGKAIMIgFNBEAgBigCCCEFDAEL +IAJBAnQhAiAGKAIIIQMgAUUEQEEEIQUgAyACENEBDAELIAMgAkEEIAFBAnQiAhC9ASIFRQ0CCyAA +IAE2AgQgACAFNgIAIAZBEGokAA8LQYi0wABBMhDnAQALQQQgAkH4s8AAELcBAAuaAQEEfyMAQSBr +IgIkAEEIIAAoAgAiBEEBdCIDIANBCE0bIgNBAEgEQEEAQQAgARC3AQALIAIgBAR/IAIgBDYCHCAC +IAAoAgQ2AhRBAQUgBQs2AhggAkEIakEBIAMgAkEUahB0IAIoAghBAUYEQCACKAIMIAIoAhAgARC3 +AQALIAIoAgwhASAAIAM2AgAgACABNgIEIAJBIGokAAukAQEBfyMAQUBqIgIkACAAKAIAIQAgAkIA +NwM4IAJBOGogACUBECQgAiACKAI8IgA2AjQgAiACKAI4NgIwIAIgADYCLCACIAJBLGqtQoCAgIDw +CIQ3AyAgAkECNgIMIAJB3MTAADYCCCACQgE3AhQgAiACQSBqNgIQIAEoAgAgASgCBCACQQhqEDwg +AigCLCIBBEAgAigCMCABENEBCyACQUBrJAALjwEBAX8gAkEATgRAAn8gAygCBARAAkAgAygCCCIE +RQRADAELIAMoAgAgBCABIAIQvQEMAgsLIAEgAkUNABpBuYLBAC0AABogAiABEMUBCyIDRQRAIAAg +AjYCCCAAIAE2AgQgAEEBNgIADwsgACACNgIIIAAgAzYCBCAAQQA2AgAPCyAAQQA2AgQgAEEBNgIA +C60BAQN/IAEoAgQhAgJ/AkAgASgCCCIEIAEoAgAiA0cEQEG5gsEALQAAGkEMQQQQxQEiAQ0BQQRB +DBDsAQALIARFBEBBACEBQQEhAkHItcAADAILIAJBAXEEQCACIQFB0LbAAAwCCyACQQFyIQFBvLbA +AAwBCyABQQE2AgggASADNgIEIAEgAjYCAEHAt8AACyEDIAAgATYCDCAAIAQ2AgggACACNgIEIAAg +AzYCAAvAAQIFfwFvAkAgASgCACIFEPUBIgNBAEgNAAJAIANFBEBBASEEDAELQbmCwQAtAAAaQQEh +AiADQQEQxQEiBEUNAQsQJiEHEHAiASAHJgEgASIGJQEQHyEHEHAiASAHJgEgARC8ASECIAFBhAFP +BEAgARBtCyACJQEgBSUBIAQQISACQYQBTwRAIAIQbQsgBkGEAU8EQCAGEG0LIAAgBRD1ATYCCCAA +IAQ2AgQgACADNgIADwsgAiADQfiywAAQtwEAC5QBAQN/IwBBEGsiAiQAAn9BASABKAIAIgNBJyAB +KAIEIgQoAhAiAREAAA0AGiACQQRqIAAoAgBBgQIQNQJAIAItAARBgAFGBEAgAyACKAIIIAERAABF +DQFBAQwCCyADIAItAA4iACACQQRqaiACLQAPIABrIAQoAgwRAQBFDQBBAQwBCyADQScgAREAAAsg +AkEQaiQAC5UBAQJ/AkAgAkEASA0AIAACfyACRQRAQci1wAAhA0EBIQRBAAwBC0G5gsEALQAAGkEB +IQMgAkEBEMUBIgRFDQEgAgRAIAQgASAC/AoAAAsgBEEBcQRAQdC2wAAhAyAEDAELQby2wAAhAyAE +QQFyCzYCDCAAIAI2AgggACAENgIEIAAgAzYCAA8LIAMgAkG4tcAAELcBAAt5AgF+An8jAEGAAWsi +BCQAIAApAwAhAkEAIQADQCAAIARqQf8AaiACp0EPcSIDQTByIANB1wBqIANBCkkbOgAAIABBAWsh +ACACQg9WIAJCBIghAg0ACyABQQFB9uvAAEECIAAgBGpBgAFqQQAgAGsQNiAEQYABaiQAC4QBAQF/ +AkAgA0EASA0AAkAgA0UEQEEBIQEMAQtBuYLBAC0AABpBASEEIANBARDFASIBRQ0BCyADBEAgASAC +IAP8CgAACyAAIAM2AgggACADNgIEIAAgATYCACAAQR1BgQEgA0EKdmdBAnRrIANB//8HSxs2AgwP +CyAEIANByLjAABC3AQALowECBH8BbwJAIAEtAAQEQEECIQMMAQsgASgCACUBEBQhBhBwIgIgBiYB +QZCDwQAoAgAhBEGMg8EAKAIAQYyDwQBCADcCAEEBIQNBAUYEQCABQQE6AAQMAQsCfyACJQEQFUUE +QCACJQEQFiEGEHAiASAGJgEgASEEQQAMAQsgAUEBOgAEQQILIQMgAkGEAUkNACACEG0LIAAgBDYC +BCAAIAM2AgALegEBfyMAQSBrIgIkAAJ/IAAoAgBBgICAgHhHBEAgASAAKAIEIAAoAggQwQEMAQsg +AkEQaiAAKAIMKAIAIgBBCGopAgA3AwAgAkEYaiAAQRBqKQIANwMAIAIgACkCADcDCCABKAIAIAEo +AgQgAkEIahA8CyACQSBqJAALfAEBfyMAQUBqIgUkACAFIAE2AgwgBSAANgIIIAUgAzYCFCAFIAI2 +AhAgBUECNgIcIAVBxOvAADYCGCAFQgI3AiQgBSAFQRBqrUKAgICAgAyENwM4IAUgBUEIaq1CgICA +gJAMhDcDMCAFIAVBMGo2AiAgBUEYaiAEEKMBAAtwAQF/IwBBEGsiASQAIAAoAgAiACAAKAIIIgJB +AWs2AggCQCACQQFGBEAgACgCACAAQQRqKAIAIgNBARC4AUUNASADENEBIABBDBDRAQsgAUEQaiQA +DwtB9LbAAEErIAFBD2pB5LbAAEGwt8AAEH0AC80CAQN/IwBBMGsiAyQAIAMgAjYCBCADIAE2AgAg +A0ECNgIMIANBrJLAADYCCCADQgI3AhQgAyADrUKAgICA4AKENwMoIAMgAK1CgICAgIAChDcDICAD +IANBIGo2AhACfyMAQRBrIgIkACADQQhqIgAoAgwhAQJAAn8CQAJAAkACQAJAIAAoAgQOAgABAgsg +AQ0BQQEhBUEAIQBBASEBDAMLIAFFDQELIAJBBGogABBHIAIoAgwhACACKAIIIQEgAigCBAwCCyAA +KAIAIgEoAgQiAEEASA0CIAEoAgAhBSAARQRAQQEhAUEAIQAMAQtBuYLBAC0AABpBASEEIABBARDF +ASIBRQ0CCyAABEAgASAFIAD8CgAACyAACyEEIAEgABC7ASAEBEAgASAEENEBCyACQRBqJAAMAQsg +BCAAQbCTwAAQtwEACyADQTBqJAALagIBfwF+IwBBMGsiAyQAIAMgATYCBCADIAA2AgAgA0ECNgIM +IANBkOrAADYCCCADQgI3AhQgA0KAgICAkAkiBCADrYQ3AyggAyAEIANBBGqthDcDICADIANBIGo2 +AhAgA0EIaiACEKMBAAtoAQF/AkAgA0EASA0AAkAgA0UEQEEBIQEMAQtBuYLBAC0AABpBASEEIANB +ARDFASIBRQ0BCyADBEAgASACIAP8CgAACyAAIAM2AgggACABNgIEIAAgAzYCAA8LIAQgA0G4tcAA +ELcBAAtpACMAQTBrIgAkAEG4gsEALQAARQRAIABBMGokAA8LIABBAjYCDCAAQYzIwAA2AgggAEIB +NwIUIAAgATYCLCAAIABBLGqtQoCAgICQCYQ3AyAgACAAQSBqNgIQIABBCGpBtMjAABCjAQALnAIC +A38BfiMAQRBrIgEkACABQeiCwQA2AgQgAEHwgsEALQAAQQNHBH8gASABQQRqNgIIIAEgAUEIajYC +DCABQQxqIQIjAEEgayIAJAACQAJAAkACQAJAAkACQEHwgsEALQAAQQFrDgMCBAEAC0HwgsEAQQI6 +AAAgAigCACIDKAIAIQIgA0EANgIAIAJFDQIgAigCAEKACDcDAEHwgsEAQQM6AAALIABBIGokAAwE +CyAAQQA2AhggAEEBNgIMIABB+KzAADYCCAwCC0G8rsAAENkBAAsgAEEANgIYIABBATYCDCAAQbit +wAA2AggLIABCBDcCECAAQQhqQbivwAAQowEACyABKAIEBUHogsEACykDABCzASABQRBqJABQC1kB +An8jAEEQayICJAAgAEEEaiEDAn8gACgCAEEBRgRAIAIgAzYCDCABQaqDwABBAyACQQxqEGEMAQsg +AiADNgIIIAFBqIPAAEECIAJBCGoQYQsgAkEQaiQAC14BAX8jAEEwayICJAAgAiABNgIMIAIgADYC +CCACQQI2AhQgAkGoj8AANgIQIAJCATcCHCACIAJBCGqtQoCAgICQAoQ3AyggAiACQShqNgIYIAJB +EGoQYyACQTBqJAALXgEBfyMAQTBrIgIkACACIAE2AgwgAiAANgIIIAJBAjYCFCACQcyPwAA2AhAg +AkIBNwIcIAIgAkEIaq1CgICAgJAChDcDKCACIAJBKGo2AhggAkEQahBjIAJBMGokAAtbAQF/IAEo +AgAiBEEBcQRAIAAgASAEIARBfnEgAiADEG4PCyAEIAQoAggiAUEBajYCCCABQQBOBEAgACAENgIM +IAAgAzYCCCAAIAI2AgQgAEHAt8AANgIADwsAC1gBAX8gASgCACIEQQFxBEAgACABIAQgBCACIAMQ +bg8LIAQgBCgCCCIBQQFqNgIIIAFBAE4EQCAAIAQ2AgwgACADNgIIIAAgAjYCBCAAQcC3wAA2AgAP +CwALWAEBfyMAQSBrIgMkACADQRhqIAJBGGopAAA3AwAgA0EQaiACQRBqKQAANwMAIANBCGogAkEI +aikAADcDACADIAIpAAA3AwAgACADIAFBIBA0IANBIGokAAtOACMAQSBrIgAkACAAQQE2AgQgAEHo +vcAANgIAIABCATcCDCAAQtC9wICwBzcDGCAAIABBGGo2AgggASgCACABKAIEIAAQPCAAQSBqJAAL +SwAgASgCACIBQQFxBEAgAUF+cSEBIAMEQCABIAIgA/wKAAALIAAgAzYCCCAAIAE2AgQgACACIANq +IAFrNgIADwsgACABIAIgAxBbC0sBAX8gACgCACAAKAIIIgNrIAJJBEAgACADIAJBAUEBEFcgACgC +CCEDCyACBEAgACgCBCADaiABIAL8CgAACyAAIAIgA2o2AghBAAtHAQF/IAAoAgAgACgCCCIDayAC +SQRAIAAgAyACEF8gACgCCCEDCyACBEAgACgCBCADaiABIAL8CgAACyAAIAIgA2o2AghBAAtNAQF/ +IwBBMGsiASQAIAFBATYCDCABQajpwAA2AgggAUIBNwIUIAEgAUEvaq1CgICAgPALhDcDICABIAFB +IGo2AhAgAUEIaiAAEKMBAAtEACABKAIAIgFBAXEEQCADBEAgASACIAP8CgAACyAAIAM2AgggACAB +NgIEIAAgAiADaiABazYCAA8LIAAgASACIAMQWws6AQF/IwBBIGsiACQAIABBADYCGCAAQQE2Agwg +AEG4ycAANgIIIABCBDcCECAAQQhqQezJwAAQowEAC0cBAX8gACgCACAAKAIIIgNrIAJJBEAgACAD +IAIQaCAAKAIIIQMLIAIEQCAAKAIEIANqIAEgAvwKAAALIAAgAiADajYCCEEAC0EBAn8jAEEQayIC +JAAgAkEIaiAAKAIAJQEQCyACKAIIIgMgAigCDCIAIAEQ7gEgAARAIAMgABDRAQsgAkEQaiQAC08B +An8gACgCBCECIAAoAgAhAwJAIAAoAggiAC0AAEUNACADQezrwABBBCACKAIMEQEARQ0AQQEPCyAA +IAFBCkY6AAAgAyABIAIoAhARAAALQgEBfyAAKAIAIgAoAjAiAQRAIAAoAjQgARDRAQsCQCAAQX9G +DQAgACAAKAIEQQFrIgE2AgQgAQ0AIABByAAQ0QELC08BAn9BuYLBAC0AABogASgCBCECIAEoAgAh +A0EIQQQQxQEiAUUEQEEEQQgQ7AEACyABIAI2AgQgASADNgIAIABB1MjAADYCBCAAIAE2AgALnnQD +I38afgF8IAEoAggiA0GAgIABcSECIAArAwAhPyADQYCAgIABcUUEQCABIAJBAEchAUEAIQAjAEGA +AWsiByQAID+9ISUCf0EDID+ZRAAAAAAAAPB/YQ0AGkECICVCgICAgICAgPj/AIMiJkKAgICAgICA ++P8AUQ0AGiAlQv////////8HgyIpQoCAgICAgIAIhCAlQgGGQv7///////8PgyAlQjSIp0H/D3Ei +ABsiJ0IBgyEoICZQBEBBBCApUA0BGiAAQbMIayEAQgEhJiAoUAwBC0KAgICAgICAICAnQgGGICdC +gICAgICAgAhRIgIbISdCAkIBIAIbISZBy3dBzHcgAhsgAGohACAoUAshAiAHIAA7AXggByAmNwNw +IAdCATcDaCAHICc3A2AgByACOgB6An8CQAJAAkAgAkECayICBEBBASEAQbPowABBtOjAACAlQgBT +IgMbQbPowABBASADGyABGyEXICVCP4inIAFyIRtBAyACIAJBA08bQQJrDgIDAgELIAdBAzYCKCAH +QbXowAA2AiQgB0ECOwEgQQEhF0EBIQAgB0EgagwDCyAHQQM2AiggB0G46MAANgIkIAdBAjsBICAH +QSBqDAILIAdBIGohBiAHQQ9qIQwjAEEwayIDJAACQAJAAn8CQAJAAkACQAJAAkACQAJAIAdB4ABq +IgApAwAiJVBFBEAgACkDCCInUA0BIAApAxAiJlANAiAlICZ8IiYgJVQNAyAlICdUDQQgJkKAgICA +gICAgCBaDQUgAyAALwEYIgA7AQggAyAlICd9Iic3AwAgACAAQSBrIAAgJkKAgICAEFQiARsiAkEQ +ayACICZCIIYgJiABGyImQoCAgICAgMAAVCIBGyICQQhrIAIgJkIQhiAmIAEbIiZCgICAgICAgIAB +VCIBGyICQQRrIAIgJkIIhiAmIAEbIiZCgICAgICAgIAQVCIBGyICQQJrIAIgJkIEhiAmIAEbIiZC +gICAgICAgIDAAFQiARsgJkIChiAmIAEbIihCAFkiAmsiAWvBIgpBAEgNBiADQn8gCq0iKYgiJiAn +gzcDECAmICdUDQogAyAAOwEIIAMgJTcDACADICUgJoM3AxAgJSAmVg0KQaB/IAFrwUHQAGxBsKcF +akHOEG0iAEHRAE8NByAAQQR0IgBB+NjAAGopAwAiKkL/////D4MiJiAlIClCP4MiJYYiK0IgiCI1 +fiIsQiCIIjEgKkIgiCIpIDV+IjJ8ICkgK0L/////D4MiKn4iK0IgiCI2fCEzICxC/////w+DICYg +Kn5CIIh8ICtC/////w+DfCI3QoCAgIAIfEIgiCErQgFBACABIABBgNnAAGovAQBqa0E/ca0iLIYi +KkIBfSEuICYgJyAlhiIlQiCIIid+Ii1C/////w+DICYgJUL/////D4MiJX5CIIh8ICUgKX4iJUL/ +////D4N8Ij5CgICAgAh8QiCIITQgJyApfiE4ICVCIIghOSAtQiCIITogAEGC2cAAai8BACEBICkg +KCACrYYiJUIgiCI7fiI8ICYgO34iJ0IgiCIvfCApICVC/////w+DIiV+IihCIIgiMHwgJ0L///// +D4MgJSAmfkIgiHwgKEL/////D4N8Ij1CgICAgAh8QiCIfEIBfCItICyIpyIAQZDOAE8EQCAAQcCE +PUkNCSAAQYDC1y9PBEBBCEEJIABBgJTr3ANJIgIbIQpBgMLXL0GAlOvcAyACGwwLC0EGQQcgAEGA +reIESSICGyEKQcCEPUGAreIEIAIbDAoLIABB5ABPBEBBAkEDIABB6AdJIgIbIQpB5ABB6AcgAhsM +CgtBCkEBIABBCUsiChsMCQtBz9TAAEEcQcjjwAAQlwEAC0H81MAAQR1B2OPAABCXAQALQazVwABB +HEHo48AAEJcBAAtBkNfAAEE2QYjlwAAQlwEAC0HI1sAAQTdB+OTAABCXAQALQYjkwABBLUG45MAA +EJcBAAtBo9LAAEEdQeTSwAAQlwEACyAAQdEAQbjjwAAQgAEAC0EEQQUgAEGgjQZJIgIbIQpBkM4A +QaCNBiACGwshAiArIDN8ITMgLSAugyEmIAogAWtBAWohBSAtIDggOnwgOXwgNHx9IjRCAXwiKCAu +gyEnQQAhAQJAAkACQAJAAkACQAJAAkADQCAAIAJuIQsgAUERRg0CIAEgDGoiDiALQTBqIg06AAAC +QCAAIAIgC2xrIgCtICyGIisgJnwiJSAoWgRAIAEgCkcNASABQQFqIQFCASElA0AgJSEoICchKSAB +QRFPDQYgASAMaiAmQgp+IiYgLIinQTBqIgI6AAAgAUEBaiEBICVCCn4hJSAnQgp+IicgJiAugyIm +WA0ACyAlIC0gM31+IiwgJXwhKyAnICZ9ICpUIgANByAsICV9IiwgJlYNAwwHCyAoICV9IicgAq0g +LIYiKFQhAiAtIDN9IixCAXwhKiAnIChUICUgLEIBfSIsWnINBSA9QoCAgIAIfEIgiCItIC8gMHx8 +IDx8ISdCAiA5IDp8ID5CgICAgAh8QiCIfCA4fCAmICh8IiUgK3x8fSEuQgAgMSA2fCA3QoCAgIAI +fEIgiHwiMSAyfCAmICt8fH0hMiAlIDF8ICkgNSA7fX58IC99IDB9IC19ISkDQCAlICt8Ii8gLFQg +JyAyfCApICt8WnJFBEAgJiArfCElQQAhAgwHCyAOIA1BAWsiDToAACAmICh8ISYgJyAufCEtICwg +L1YEQCAoICl8ISkgJSAofCElICcgKH0hJyAoIC1YDQELCyAoIC1WIQIgJiArfCElDAULIAFBAWoh +ASACQQpJIAJBCm4hAkUNAAtByOTAABCdAQALIAEgDGpBAWshCiAqIDEgNnwgN0KAgICACHxCIIh8 +IDJ8Qgp+IC8gMHwgPUKAgICACHxCIIh8IDx8Qgp+fSAofnwhLSApQgp+ICYgKnx9IS4gLCAmfSEv +QgAhKQNAICYgKnwiJSAsVCApIC98ICYgLXxackUEQEEAIQAMBQsgCiACQQFrIgI6AAAgKSAufCIw +ICpUIQAgJSAsWg0FICkgKn0hKSAlISYgKiAwWA0ACwwEC0ERQRFB2OTAABCAAQALIAFBEUHo5MAA +EIABAAsCQCAlICpaIAJyDQAgKiAlICh8IiZYICogJX0gJiAqfVRxDQAgBkEANgIADAQLICUgNEID +fVggJUICWnFFBEAgBkEANgIADAQLIAYgBTsBCCAGIAFBAWo2AgQMAgsgJiElCwJAICUgK1ogAHIN +ACArICUgKnwiJlggKyAlfSAmICt9VHENACAGQQA2AgAMAgsgJSAoQlh+ICd8WCAlIChCFH5acUUE +QCAGQQA2AgAMAgsgBiAFOwEIIAYgATYCBAsgBiAMNgIACyADQTBqJAAMAQsgA0EANgIYIwBBEGsi +ACQAIAAgAzYCDCAAIANBEGo2AgggAEEIakGg6sAAIABBDGpBoOrAACADQRhqQfTSwAAQUAALAkAg +BygCIARAIAdB2ABqIAdBKGooAgA2AgAgByAHKQIgNwNQDAELIAdB0ABqIQ8gB0EPaiENIwBBoApr +IgEkAAJAAkACQAJAAkACQAJAAkAgB0HgAGoiACkDACIlUEUEQCAAKQMIIiZQRQRAIAApAxAiJ1BF +BEAgJSAlICd8IihYBEAgJSAmWgRAIAAsABohGCAALgEYIQAgASAlPgIAIAFBAUECICVCgICAgBBU +IgIbNgKgASABQQAgJUIgiKcgAhs2AgQgAUEIakEAQZgB/AsAIAEgJj4CpAEgAUEBQQIgJkKAgICA +EFQiAhs2AsQCIAFBACAmQiCIpyACGzYCqAEgAUGsAWpBAEGYAfwLACABICc+AsgCIAFBAUECICdC +gICAgBBUIgIbNgLoAyABQQAgJ0IgiKcgAhs2AswCIAFB0AJqQQBBmAH8CwAgAUHwA2pBAEGcAfwL +ACABQQE2AuwDIAFBATYCjAUgAKwgKEIBfXl9QsKawegEfkKAoc2gtAJ8QiCIpyICwSEOAkAgAEEA +TgRAIAEgABAtGiABQaQBaiAAEC0aIAFByAJqIAAQLRoMAQsgAUHsA2pBACAAa8EQLRoLAkAgDkEA +SARAIAFBACAOa0H//wNxIgAQKyABQaQBaiAAECsgAUHIAmogABArDAELIAFB7ANqIAJB//8BcRAr +CyABKAKgASEDIAFB/AhqIAFBoAH8CgAAIAEgAzYCnAoCQAJAAkACQCABKALoAyIGIAMgAyAGSRsi +AkEoTQRAIAJFBEBBACECDAQLIAJBAXEhCyACQQFHDQEMAgsMDAsgAkE+cSERIAFB/AhqIQAgAUHI +AmohBQNAIAAgCCAAKAIAIhIgBSgCAGoiCmoiCDYCACAAQQRqIgwgDCgCACITIAVBBGooAgBqIgwg +CiASSSAIIApJcmoiCjYCACAMIBNJIAogDElyIQggBUEIaiEFIABBCGohACARIAlBAmoiCUcNAAsL +IAsEfyAJQQJ0IgAgAUH8CGpqIgogCigCACIKIAFByAJqIABqKAIAaiIAIAhqIgk2AgAgACAKSSAA +IAlLcgUgCAtFDQAgAkEoRg0BIAFB/AhqIAJBAnRqQQE2AgAgAkEBaiECCyABIAI2ApwKIAIgASgC +jAUiCSACIAlLGyIAQSlJBEAgAEECdCEAAkACQAJ/AkADQCAARQ0BIABBBGsiACABQewDamooAgAi +AiAAIAFB/AhqaigCACIKRg0ACyACIApLIAIgCklrDAELQX9BACAAGwsgGE4EQAJAIANFBEBBACED +DAELIANBAWtB/////wNxIgBBAWoiAkEDcSEFAkAgAEEDSQRAIAEhAEIAISUMAQsgAkH8////B3Eh +CiABIQBCACElA0AgACAANQIAQgp+ICV8IiU+AgAgAEEEaiICIAI1AgBCCn4gJUIgiHwiJT4CACAA +QQhqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIABBDGoiAiACNQIAQgp+ICVCIIh8IiY+AgAgJkIgiCEl +IABBEGohACAKQQRrIgoNAAsLIAUEQANAIAAgADUCAEIKfiAlfCImPgIAIABBBGohACAmQiCIISUg +BUEBayIFDQALCyAmQoCAgIAQVA0AIANBKEYNAyABIANBAnRqICU+AgAgA0EBaiEDCyABIAM2AqAB +IAEoAsQCIgJBKU8NDSABAn9BACACRQ0AGiACQQFrQf////8DcSIAQQFqIgNBA3EhBQJAIABBA0kE +QCABQaQBaiEAQgAhJQwBCyADQfz///8HcSEKIAFBpAFqIQBCACElA0AgACAANQIAQgp+ICV8IiU+ +AgAgAEEEaiIDIAM1AgBCCn4gJUIgiHwiJT4CACAAQQhqIgMgAzUCAEIKfiAlQiCIfCIlPgIAIABB +DGoiAyADNQIAQgp+ICVCIIh8IiY+AgAgJkIgiCElIABBEGohACAKQQRrIgoNAAsLIAUEQANAIAAg +ADUCAEIKfiAlfCImPgIAIABBBGohACAmQiCIISUgBUEBayIFDQALCyACICZCgICAgBBUDQAaIAJB +KEYNESABQaQBaiACQQJ0aiAlPgIAIAJBAWoLNgLEAiABIAYEfyAGQQFrQf////8DcSIAQQFqIgJB A3EhBQJAIABBA0kEQCABQcgCaiEAQgAhJQwBCyACQfz///8HcSEKIAFByAJqIQBCACElA0AgACAA NQIAQgp+ICV8IiU+AgAgAEEEaiICIAI1AgBCCn4gJUIgiHwiJT4CACAAQQhqIgIgAjUCAEIKfiAl QiCIfCIlPgIAIABBDGoiAiACNQIAQgp+ICVCIIh8IiY+AgAgJkIgiCElIABBEGohACAKQQRrIgoN AAsLIAUEQANAIAAgADUCAEIKfiAlfCImPgIAIABBBGohACAmQiCIISUgBUEBayIFDQALCyAmQoCA -gIAQVA0AIAtBKEYNFyABQcgCaiALQQJ0aiAlPgIAIAtBAWohCwsgASALNgLoAyASIAkgCSASSRsi -AkEoTQ0ACwsMEQsgAUEBEC0aIAEoAowFIgAgASgCoAEiAiAAIAJLGyIAQSlPDQQgAEECdCEAIAFB -BGshAiABQegDaiEDA0AgAEUNDiAAIANqIQkgACACaiAAQQRrIQAoAgAiDCAJKAIAIglGDQALIAkg -DE0NDgwPCyAGQShB7PzAABDUAQALIANBKEHs/MAAENQBAAsgA0EoQez8wAAQ1AEAC0ERQRFB2NXA -ABCAAQALDA0LDA0LDAsLDAsLQYjWwABBN0HA1sAAEJYBAAtB0NbAAEE2QYjXwAAQlgEAC0Hs1MAA -QRxBiNXAABCWAQALQbzUwABBHUHc1MAAEJYBAAtBj9TAAEEcQazUwAAQlgEACyAADQELIAYgDWoh -AiAKIQBBfyEFAkADQCAAQX9GDQEgBUEBaiEFIAAgDWogAEEBayEALQAAQTlGDQALIAAgDWoiAkEB -aiIDIAMtAABBAWo6AAAgBUUgAEECaiAKS3INASACQQJqQTAgBfwLAAwBCyANQTE6AAAgCgRAIA1B -AWpBMCAK/AsACyAGQRFJBEAgAkEwOgAAIA5BAWohDiAKQQJqIQYMAQsgBkERQejVwAAQgAEACyAG -QRFNBEAgDyAOOwEIIA8gBjYCBCAPIA02AgAgAUGgCmokAAwFCyAGQRFB+NXAABDUAQALIAJBKEHs -/MAAENQBAAtB/PzAAEEaQez8wAAQlgEACyAAQShB7PzAABDUAQALQShBKEHs/MAAEIABAAsLIAcg -BygCUCAHKAJUIAcvAVhBACAHQSBqEFEgBygCBCEAIAcoAgAMAQsgB0ECOwEgIAdBATYCKCAHQfvn -wAA2AiQgB0EgagshASAHIAA2AlwgByABNgJYIAcgGzYCVCAHIBc2AlAgB0HQAGoQPyAHQYABaiQA -DwsCfyABIQwgAkEARyECIAEvAQ4hEUEAIQEjAEHwCGsiByQAID+9IScCf0EDID+ZRAAAAAAAAPB/ -YQ0AGkECICdCgICAgICAgPj/AIMiJkKAgICAgICA+P8AUQ0AGiAnQv////////8HgyIpQoCAgICA -gIAIhCAnQgGGQv7///////8PgyAnQjSIp0H/D3EiABsiJUIBgyEoICZQBEBBBCApUA0BGiAAQbMI -ayEBQgEhJiAoUAwBC0KAgICAgICAICAlQgGGICVCgICAgICAgAhRIgEbISVCAkIBIAEbISZBy3dB -zHcgARsgAGohASAoUAshACAHIAE7AegIIAcgJjcD4AggB0IBNwPYCCAHICU3A9AIIAcgADoA6ggC -QAJ/AkACQAJAAkAgAEECayIDBEBBASEAQfPnwABB9OfAACAnQgBTIgYbQfPnwABBASAGGyACGyEb -ICdCP4inIAJyIR1BAyADIANBA08bQQJrDgICAwELIAdBAzYCmAggB0H158AANgKUCCAHQQI7AZAI -QQEhG0EBIQAgB0GQCGoMBAsgB0EDNgKYCCAHQfjnwAA2ApQIIAdBAjsBkAggB0GQCGoMAwtBAiEA -IAdBAjsBkAggEUUNASAHIBE2AqAIIAdBADsBnAggB0ECNgKYCCAHQfHnwAA2ApQIIAdBkAhqDAIL -QXRBBSABwSIAQQBIGyAAbCIAQcD9AEkEQCAHQZAIaiEEIAdBEGohBSAAQQR2QRVqIgohAUGAgH5B -ACARayARwUEASBshCQJAAkACfwJAAkACQAJAIAdB0AhqIgApAwAiJVBFBEAgJUKAgICAgICAgCBa -DQEgAUUNAkGgfyAALwEYIgBBIGsgACAlQoCAgIAQVCIAGyICQRBrIAIgJUIghiAlIAAbIiVCgICA -gICAwABUIgAbIgJBCGsgAiAlQhCGICUgABsiJUKAgICAgICAgAFUIgAbIgJBBGsgAiAlQgiGICUg -ABsiJUKAgICAgICAgBBUIgAbIgJBAmsgAiAlQgSGICUgABsiJUKAgICAgICAgMAAVCIAGyAlQgKG -ICUgABsiJUIAWWsiA2vBQdAAbEGwpwVqQc4QbSIAQdEATw0DIABBBHQiAkG42MAAaikDACImQv// -//8PgyInICUgJUJ/hUI/iIYiJUIgiCIofiIpQiCIICZCIIgiJiAofnwgJiAlQv////8PgyIlfiIm -QiCIfCApQv////8PgyAlICd+QiCIfCAmQv////8Pg3xCgICAgAh8QiCIfCIlQUAgAyACQcDYwABq -LwEAamsiC0E/ca0iJ4inIQAgAkHC2MAAai8BACECICVCASAnhiIoQgF9IimDIiZQBEAgAUEKSw0H -IAFBAnRBzOXAAGooAgAgAEsNBwsgAEGQzgBPBEAgAEHAhD1JDQUgAEGAwtcvTwRAQQhBCSAAQYCU -69wDSSIDGyEGQYDC1y9BgJTr3AMgAxsMBwtBBkEHIABBgK3iBEkiAxshBkHAhD1BgK3iBCADGwwG -CyAAQeQATwRAQQJBAyAAQegHSSIDGyEGQeQAQegHIAMbDAYLQQpBASAAQQlLIgYbDAULQY/UwABB -HEH85MAAEJYBAAtBjOXAAEEkQbDlwAAQlgEAC0HY5MAAQSFBwOXAABCWAQALIABB0QBB+OLAABCA -AQALQQRBBSAAQaCNBkkiAxshBkGQzgBBoI0GIAMbCyEDAkACQAJAAkAgBiACa0EBasEiCCAJwSIC -SgRAIAtB//8DcSEOIAggCWvBIAEgCCACayABSRsiC0EBayEPQQAhAgNAIAAgA24hDSABIAJGDQMg -ACADIA1sayEAIAIgBWogDUEwajoAACACIA9GDQQgAiAGRg0CIAJBAWohAiADQQpJIANBCm4hA0UN -AAtB+OXAABCcAQALIAQgBSABQQAgCCAJICVCCoAgA60gJ4YgKBBFDAULIAJBAWohAiAOQQFrQT9x -rSEqQgEhJQNAICUgKohQRQRAIARBADYCAAwGCyABIAJNDQMgAiAFaiAmQgp+IiYgJ4inQTBqOgAA -ICVCCn4hJSAmICmDISYgCyACQQFqIgJHDQALIAQgBSABIAsgCCAJICYgKCAlEEUMBAsgASABQYjm -wAAQgAEACyAEIAUgASALIAggCSAArSAnhiAmfCADrSAnhiAoEEUMAgsgAiABQZjmwAAQgAEACyAE -QQA2AgALIAnBIRgCQCAHKAKQCARAIAdByAhqIAdBmAhqKAIANgIAIAcgBykCkAg3A8AIDAELIAdB -wAhqIRIgB0EQaiEJIwBBwAZrIgUkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAHQdAIaiIAKQMA -IiVQRQRAIAApAwgiJlANASAAKQMQIidQDQIgJSAnfCAlVA0DICUgJlQNBCAALgEYIQAgBSAlPgIM -IAVBAUECICVCgICAgBBUIgEbNgKsASAFQQAgJUIgiKcgARs2AhAgBUEUakEAQZgB/AsAIAVBtAFq -QQBBnAH8CwAgBUEBNgKwASAFQQE2AtACIACsICVCAX15fULCmsHoBH5CgKHNoLQCfEIgiKciAcEh -DQJAIABBAE4EQCAFQQxqIAAQLRoMAQsgBUGwAWpBACAAa8EQLRoLAkAgDUEASARAIAVBDGpBACAN -a0H//wNxECsMAQsgBUGwAWogAUH//wFxECsLIAUoAtACIQsgBUGcBWogBUGwAWpBoAH8CgAAIAUg -CzYCvAYgCiIGQQpPBEAgBUGUBWohAgNAIAUoArwGIgRBKU8NCgJAIARFDQAgBEH/////A2ohACAE -QQJ0IQECfyAEQQFGBEBCACElIAVBnAVqIAFqDAELIAEgAmohBCAAQf////8DcUEBakH+////B3Eh -A0IAISUDQCAEQQRqIgEgATUCACAlQiCGhCIlQoCU69wDgCImPgIAIAQgBDUCACAlICZCgJTr3AN+ -fUIghoQiJUKAlOvcA4AiJj4CACAlICZCgJTr3AN+fSElIARBCGshBCADQQJrIgMNAAsgJUIghiEl -IARBCGoLIABBAXENAEEEayIAICUgADUCAIRCgJTr3AOAPgIACyAGQQlrIgZBCUsNAAsLIAZBAnRB -0OXAAGooAgBBAXQiAkUNBSAFKAK8BiIEQSlPDQggBAR/IARB/////wNqIQAgBEECdCEBIAKtISUC -fyAEQQFGBEBCACEmIAVBnAVqIAFqDAELIAEgBWpBlAVqIQQgAEH/////A3FBAWpB/v///wdxIQNC -ACEmA0AgBEEEaiIBIAE1AgAgJkIghoQiJiAlgCInPgIAIAQgBDUCACAmICUgJ359QiCGhCImICWA -Iic+AgAgJiAlICd+fSEmIARBCGshBCADQQJrIgMNAAsgJkIghiEmIARBCGoLIQEgAEEBcUUEQCAB -QQRrIgAgJiAANQIAhCAlgD4CAAsgBSgCvAYFQQALIQECQAJAAkAgBSgCrAEiACABIAAgAUsbIgFB -KE0EQCABRQRAQQAhAQwECyABQQFxIQ4gAUEBRw0BQQAhBkEAIQgMAgsMFAsgAUE+cSEPQQAhBiAF -QZwFaiEEIAVBDGohA0EAIQgDQCAEIAQoAgAiFyADKAIAaiICIAZBAXFqIhM2AgAgBEEEaiIGIAYo -AgAiGSADQQRqKAIAaiIGIAIgF0kgAiATS3JqIgI2AgAgBiAZSSACIAZJciEGIANBCGohAyAEQQhq -IQQgDyAIQQJqIghHDQALCyAOBH8gCEECdCICIAVBnAVqaiIDIAMoAgAiAyAFQQxqIAJqKAIAaiIC -IAZqIgY2AgAgAiADSSACIAZLcgUgBgtBAXFFDQAgAUEoRg0KIAVBnAVqIAFBAnRqQQE2AgAgAUEB -aiEBCyAFIAE2ArwGIAsgASABIAtJGyIEQSlPDQggBEECdCEEAkACQANAIARFDQEgBEEEayIEIAVB -nAVqaigCACIBIAQgBUGwAWpqKAIAIgJGDQALIAEgAk8NAQwICyAEDQcLIA1BAWohDQwHC0GP1MAA -QRxBmNfAABCWAQALQbzUwABBHUGo18AAEJYBAAtB7NTAAEEcQbjXwAAQlgEAC0HQ1sAAQTZBqNjA -ABCWAQALQYjWwABBN0GY2MAAEJYBAAtBs/3AAEEbQez8wAAQlgEACyAARQRAQQAhACAFQQA2AqwB -DAELIABBAWtB/////wNxIgFBAWoiAkEDcSEDAkAgAUEDSQRAIAVBDGohBEIAISUMAQsgAkH8//// -B3EhASAFQQxqIQRCACElA0AgBCAENQIAQgp+ICV8IiU+AgAgBEEEaiICIAI1AgBCCn4gJUIgiHwi -JT4CACAEQQhqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIARBDGoiAiACNQIAQgp+ICVCIIh8IiY+AgAg -JkIgiCElIARBEGohBCABQQRrIgENAAsLIAMEQANAIAQgBDUCAEIKfiAlfCImPgIAIARBBGohBCAm -QiCIISUgA0EBayIDDQALCyAmQoCAgIAQWgRAIABBKEYNAyAFQQxqIABBAnRqICU+AgAgAEEBaiEA -CyAFIAA2AqwBC0EAIQYCQAJAAkACQCANwSIBIBjBIgJIIh5FBEAgDSAYa8EgCiABIAJrIApJGyII -DQELQQAhCAwBCyAFQdQCaiIBIAVBsAFqIgBBoAH8CgAAIAUgCzYC9ANBASEXIAFBARAtIR8gBSgC -0AIhASAFQfgDaiICIABBoAH8CgAAIAUgATYCmAUgAkECEC0hICAFKALQAiEBIAVBnAVqIgIgAEGg -AfwKAAAgBSABNgK8BiAFQawBaiEhIAVB0AJqISIgBUH0A2ohFCAFQZgFaiEjQQAhDiACQQMQLSEk -IAUoAqwBIQAgBSgC0AIhCyAFKAL0AyETIAUoApgFIRkgBSgCvAYhEAJAAkACQAJAA0AgAEEpTw0K -IABBAnQhAUEAIQQCfwJAAkADQCABIARGDQEgBUEMaiAEaiAEQQRqIQQoAgBFDQALIBAgACAAIBBJ -GyIBQSlPDRQgAUECdCEEAkADQCAERQ0BIAQgI2ohAiAEQQRrIgQgBUEMamooAgAiAyACKAIAIgJG -DQALIAIgA00NAkEADAMLIARFDQFBAAwCCyAIIApLDQQgCCAORg0IIAggDmsiAEUNCCAJIA5qQTAg -APwLAAwIC0EBIQZBACEAIAFBAUcEQCABQT5xIQ8gBUEMaiEEIAVBnAVqIQMDQCAEIAQoAgAiFSAD -KAIAQX9zaiICIAZBAXFqIhY2AgAgBEEEaiIGIAYoAgAiGiADQQRqKAIAQX9zaiIGIAIgFUkgAiAW -S3JqIgI2AgAgBiAaSSACIAZJciEGIANBCGohAyAEQQhqIQQgDyAAQQJqIgBHDQALCyABQQFxBH8g -AEECdCIAIAVBDGpqIgIgAigCACICIAAgJGooAgBBf3NqIgAgBmoiAzYCACAAIAJJIAAgA0tyBSAG -C0EBcUUNDCAFIAE2AqwBIAEhAEEICyEPIBkgACAAIBlJGyICQSlPDQMgAkECdCEEAkACQAJAA0Ag -BEUNASAEIBRqIQEgBEEEayIEIAVBDGpqKAIAIgMgASgCACIBRg0ACyABIANNDQEgACECDAILIARF -DQAgACECDAELIAIEQEEBIQZBACEAIAJBAUcEQCACQT5xIRUgBUEMaiEEIAVB+ANqIQMDQCAEIAQo -AgAiFiADKAIAQX9zaiIBIAZBAXFqIho2AgAgBEEEaiIGIAYoAgAiHCADQQRqKAIAQX9zaiIGIAEg -FkkgASAaS3JqIgE2AgAgBiAcSSABIAZJciEGIANBCGohAyAEQQhqIQQgFSAAQQJqIgBHDQALCyAC -QQFxBH8gAEECdCIAIAVBDGpqIgEgASgCACIBIAAgIGooAgBBf3NqIgAgBmoiAzYCACAAIAFJIAAg -A0tyBSAGC0EBcUUNDQsgBSACNgKsASAPQQRyIQ8LIBMgAiACIBNJGyIBQSlPDQQgAUECdCEEAkAC -QAJAA0AgBEUNASAEICJqIQAgBEEEayIEIAVBDGpqKAIAIgMgACgCACIARg0ACyAAIANNDQEgAiEB -DAILIARFDQAgAiEBDAELIAEEQEEBIQZBACEAIAFBAUcEQCABQT5xIRUgBUEMaiEEIAVB1AJqIQMD -QCAEIAQoAgAiFiADKAIAQX9zaiICIAZBAXFqIho2AgAgBEEEaiIGIAYoAgAiHCADQQRqKAIAQX9z -aiIGIAIgFkkgAiAaS3JqIgI2AgAgBiAcSSACIAZJciEGIANBCGohAyAEQQhqIQQgFSAAQQJqIgBH -DQALCyABQQFxBH8gAEECdCIAIAVBDGpqIgIgAigCACICIAAgH2ooAgBBf3NqIgAgBmoiAzYCACAA -IAJJIAAgA0tyBSAGC0EBcUUNDQsgBSABNgKsASAPQQJqIQ8LIAsgASABIAtJGyIAQSlPDQogAEEC -dCEEAkACQAJAA0AgBEUNASAEICFqIQIgBEEEayIEIAVBDGpqKAIAIgMgAigCACICRg0ACyACIANN -DQEgASEADAILIARFDQAgASEADAELIAAEQEEBIQZBACEBIABBAUcEQCAAQT5xIRUgBUEMaiEEIAVB -sAFqIQMDQCAEIAQoAgAiFiADKAIAQX9zaiICIAZBAXFqIho2AgAgBEEEaiIGIAYoAgAiHCADQQRq -KAIAQX9zaiIGIAIgFkkgAiAaS3JqIgI2AgAgBiAcSSACIAZJciEGIANBCGohAyAEQQhqIQQgFSAB -QQJqIgFHDQALCyAAQQFxBH8gAUECdCIBIAVBDGpqIgIgAigCACICIAVBsAFqIAFqKAIAQX9zaiIB -IAZqIgM2AgAgASACSSABIANLcgUgBgtBAXFFDQ0LIAUgADYCrAEgD0EBaiEPCyAKIA5NDQEgCSAO -aiAPQTBqOgAAIABBKU8NCgJAIABFBEBBACEADAELIABBAWtB/////wNxIgFBAWoiAkEDcSEDAkAg -AUEDSQRAIAVBDGohBEIAISYMAQsgAkH8////B3EhASAFQQxqIQRCACEmA0AgBCAENQIAQgp+ICZ8 -IiU+AgAgBEEEaiICIAI1AgBCCn4gJUIgiHwiJT4CACAEQQhqIgIgAjUCAEIKfiAlQiCIfCIlPgIA -IARBDGoiAiACNQIAQgp+ICVCIIh8IiU+AgAgJUIgiCEmIARBEGohBCABQQRrIgENAAsLIAMEQANA -IAQgBDUCAEIKfiAmfCIlPgIAIARBBGohBCAlQiCIISYgA0EBayIDDQALCyAlQoCAgIAQVA0AIABB -KEYNCiAFQQxqIABBAnRqICY+AgAgAEEBaiEACyAFIAA2AqwBIA5BAWohDiAXIAggF0siAWohFyAB -DQALQQEhBgwECyAOIApB+NfAABCAAQALIAggCkGI2MAAENQBAAsgAkEoQez8wAAQ1AEACwwMCwJA -AkACQCALQSlJBEACQCALRQRAQQAhCwwBCyALQQFrQf////8DcSIBQQFqIgJBA3EhAwJAIAFBA0kE -QCAFQbABaiEEQgAhJQwBCyACQfz///8HcSEBIAVBsAFqIQRCACElA0AgBCAENQIAQgV+ICV8IiU+ -AgAgBEEEaiICIAI1AgBCBX4gJUIgiHwiJT4CACAEQQhqIgIgAjUCAEIFfiAlQiCIfCIlPgIAIARB -DGoiAiACNQIAQgV+ICVCIIh8IiY+AgAgJkIgiCElIARBEGohBCABQQRrIgENAAsLIAMEQANAIAQg -BDUCAEIFfiAlfCImPgIAIARBBGohBCAmQiCIISUgA0EBayIDDQALCyAmQoCAgIAQVA0AIAtBKEYN -CCAFQbABaiALQQJ0aiAlPgIAIAtBAWohCwsgBSALNgLQAiALIAAgACALSRsiBEEpTw0GIARBAnQh -BCAFQQhqIQAgBUGsAWohAQJAAkADQCAERQ0BIAEgBGohAiAAIARqIARBBGshBCgCACIDIAIoAgAi -AkYNAAsgAiADTw0FDAELIAYgBEVxRQ0EIAhBAWsiACAKTw0CIAAgCWotAABBAXFFDQQLIAggCksN -AiAIIAlqQQAhBCAJIQMCQANAIAQgCEYNASAEQQFqIQQgA0EBayIDIAhqIgAtAABBOUYNAAsgACAA -LQAAQQFqOgAAIAggBGtBAWogCE8NBCAEQQFrIgFFDQQgAEEBakEwIAH8CwAMBAsCQCAIRQRAQTEh -BAwBCyAJQTE6AAAgCEEBRgRAQTAhBAwBC0EwIQQgCEEBayIARQ0AIAlBAWpBMCAA/AsACyANQQFq -IQ0gHiAIIApPcg0DIAQ6AAAgCEEBaiEIDAMLIAtBKEHs/MAAENQBAAsgACAKQcjXwAAQgAEACyAI -IApB2NfAABDUAQALIAggCksNAQsgEiANOwEIIBIgCDYCBCASIAk2AgAgBUHABmokAAwFCyAIIApB -6NfAABDUAQALIARBKEHs/MAAENQBAAtBKEEoQez8wAAQgAEACyAAQShB7PzAABDUAQALQfz8wABB -GkHs/MAAEJYBAAsLIBggBy4ByAgiAEgEQCAHQQhqIAcoAsAIIAcoAsQIIAAgESAHQZAIahBRIAco -AgwhACAHKAIIDAMLQQIhACAHQQI7AZAIIBFFBEBBASEAIAdBATYCmAggB0H758AANgKUCCAHQZAI -agwDCyAHIBE2AqAIIAdBADsBnAggB0ECNgKYCCAHQfHnwAA2ApQIIAdBkAhqDAILQfznwABBJUGk -6MAAEJYBAAtBASEAIAdBATYCmAggB0H758AANgKUCCAHQZAIagshASAHIAA2AswIIAcgATYCyAgg -ByAdNgLECCAHIBs2AsAIIAwgB0HACGoQPyAHQfAIaiQADAELIAFBKEHs/MAAENQBAAsLQgEBfyMA -QSBrIgMkACADQQA2AhAgA0EBNgIEIANCBDcCCCADIAE2AhwgAyAANgIYIAMgA0EYajYCACADIAIQ -oQEAC0ABAX8gASgCACIBIAEoAggiBEEBajYCCCAEQQBIBEAACyAAIAE2AgwgACADNgIIIAAgAjYC -BCAAQYC3wAA2AgALPAAgACABKQAANwAAIABBGGogAUEYaikAADcAACAAQRBqIAFBEGopAAA3AAAg -AEEIaiABQQhqKQAANwAAC5QCAQN/IAAoAgAhAiABKAIIIgBBgICAEHFFBEAgAEGAgIAgcUUEQCAC -IAEQ1gEPC0EAIQAjAEGAAWsiBCQAIAIoAgAhAgNAIAAgBGpB/wBqIAJBD3EiA0EwciADQTdqIANB -CkkbOgAAIABBAWshACACQQ9LIAJBBHYhAg0ACyABQQFBtuvAAEECIAAgBGpBgAFqQQAgAGsQNiAE -QYABaiQADwtBACEAIwBBgAFrIgQkACACKAIAIQIDQCAAIARqQf8AaiACQQ9xIgNBMHIgA0HXAGog -A0EKSRs6AAAgAEEBayEAIAJBD0sgAkEEdiECDQALIAFBAUG268AAQQIgACAEakGAAWpBACAAaxA2 -IARBgAFqJAALOAACQCACQYCAxABGDQAgACACIAEoAhARAABFDQBBAQ8LIANFBEBBAA8LIAAgAyAE -IAEoAgwRAQALLQACQCAAIAEQtgFFDQAgAARAQfmBwQAtAAAaIAAgARDDASIBRQ0BCyABDwsACzcB -AX8jAEEgayIBJAAgAUEANgIYIAFBATYCDCABQej9wAA2AgggAUIENwIQIAFBCGogABChAQAL5RkC -G38BfiMAQRBrIg0kACMAQSBrIgkkACMAQSBrIgQkACABrUIMfiIdpyEDAkACQAJAAkAgHUIgiKcg -A0H8////B0tyDQACfyADRQRAQQQhBUEADAELQfmBwQAtAAAaQQQhAiADQQQQwwEiBUUNASABCyEC -IARBADYCHCAEIAU2AhggBCACNgIUIAEEQCABQQJ0IQpBCCECA0AgBEEIaiAAIAhqKAIAIgMQ7QEg -BCgCCCIQRQ0DIAQoAgwhCyADQYQBTwRAIAMQbQsgBCgCFCAGRgRAIwBBIGsiAyQAQQQgBEEUaiIF -KAIAIgxBAXQiByAHQQRNGyIPrUIMfiIdQiCIUEUEQEEAQQBB8MLAABC1AQALAkAgHaciDkH8//// -B00EfyADIAwEfyADIAxBDGw2AhwgAyAFKAIENgIUQQQFQQALNgIYIANBCGpBBCAOIANBFGoQdCAD -KAIIQQFHDQEgAygCECEHIAMoAgwFQQALIAdB8MLAABC1AQALIAMoAgwhByAFIA82AgAgBSAHNgIE -IANBIGokACAEKAIYIQULIAIgBWoiAyALNgIAIANBBGsgEDYCACADQQhrIAs2AgAgBCAGQQFqIgY2 -AhwgAkEMaiECIAogCEEEaiIIRw0ACyAAIAFBAnQQzwELIAQoAhghAAJAIAYgBCgCFCIBTwRAIAAh -AgwBCyABQQxsIQEgBkUEQEEEIQIgACABEM8BDAELIAAgAUEEIAZBDGwiABC7ASICRQ0DCyAJIAY2 -AgQgCSACNgIAIARBIGokAAwDCyACIANB0MLAABC1AQALQYDDwABBKBDlAQALQQQgAEHgwsAAELUB -AAsgCSAJKAIEIgA2AhAgCSAJKAIANgIMIAkgADYCCCAJQRRqIRAjAEEwayIEJAAgCUEIaiIBKAIA -IQIgASgCBCEAIAEoAgghASAEQQA6AC8gBCAAIAFBDGxqNgIMIAQgAjYCCCAEIAA2AgQgBCAANgIA -IAQgBEEvajYCECAEQSBqIQUjAEHgAGsiAiQAAkACQAJAAkACQCAEKAIEIgEgBCgCDCIGRgRAIAEh -AAwBCyAEKAIQIQwgBCABQQxqIgA2AgQgASgCACEDIAJBOGogASgCBCIHIAEoAggQNyADBEAgByAD -EM8BCyACKAI4QQFxRQ0BIAxBAToAAAsgBUEANgIIIAVCgICAgIABNwIAIAYgAGtBDG4hASAAIAZH -BEADQCAAKAIAIgMEQCAAQQRqKAIAIAMQzwELIABBDGohACABQQFrIgENAAsLIAQoAggiAEUNASAE -KAIAIABBDGwQzwEMAQsgAkEwaiIDIAJB2ABqKQMANwMAIAJBKGoiByACQdAAaikDADcDACACQSBq -IgggAkHIAGopAwA3AwAgAiACKQNANwMYQfmBwQAtAAAaQYABQQgQwwEiAUUNASABIAIpAxg3AwAg -AUEYaiADKQMANwMAIAFBEGogBykDADcDACABQQhqIAgpAwA3AwAgAkEBNgIUIAIgATYCECACQQQ2 -AgwgBCgCCCEKIAQoAgAhDwJAIAAgBkYNACACQUBrIQhBICEHQQEhAwNAIAAoAgAhCyACQThqIABB -BGooAgAiDiAAQQhqKAIAEDcgCwRAIA4gCxDPAQsgAigCOEEBcQRAIAxBAToAACAAQQxqIQAMAgsg -AkEwaiIOIAhBGGopAwA3AwAgAkEoaiIRIAhBEGopAwA3AwAgAkEgaiITIAhBCGopAwA3AwAgAiAI -KQMANwMYIAIoAgwgA0YEQCACQQxqIANBAUEIQSAQVyACKAIQIQELIAEgB2oiCyACKQMYNwMAIAtB -GGogDikDADcDACALQRBqIBEpAwA3AwAgC0EIaiATKQMANwMAIAIgA0EBaiIDNgIUIAdBIGohByAA -QQxqIgAgBkcNAAsLIAYgAGtBDG4hASAAIAZHBEADQCAAKAIAIgMEQCAAQQRqKAIAIAMQzwELIABB -DGohACABQQFrIgENAAsLIAoEQCAPIApBDGwQzwELIAUgAikCDDcCACAFQQhqIAJBFGooAgA2AgAL -IAJB4ABqJAAMAQtBCEGAAUHEkcAAELUBAAsCQAJAAkACQAJAIAQtAC9BAUYEQCAEKAIgIgBFDQEg -BCgCJCAAQQV0EM8BDAELIAQoAiAiE0GAgICAeEcNAQsgBEEANgIoIARCgICAgBA3AiAgBEGcgcAA -NgIEIARCoICAgA43AgggBCAEQSBqNgIAIAQQvAENAiAEKAIgIQAgBCgCJCIBIAQoAigQuAEhAiAA -BEAgASAAEM8BCyAQQYCAgIB4NgIAIBAgAjYCBAwBCyAEKAIkIhkhACAEKAIoIQEjAEHgAGsiCCQA -IAhBADYCKCAIQQA2AhggCCAANgI4IAggACABQQV0ajYCPCAIQQxqIQtBACEBIwBBEGsiBiQAAkAC -QAJ/AkACQCAIQRhqIgUiACgCACIDBEAgACgCBCICIAAoAgxHDQEgACgCCCICBEAgAyACEM8BCyAA -QQA2AgALIAAoAiAiA0UNASADIAAoAiRGDQEgACADQSBqNgIgQfmBwQAtAAAaQSBBARDDASICRQ0D -IABBIDYCCCAAIAI2AgAgAiADKQAANwAAIAAgAkEgajYCDCACQRhqIANBGGopAAA3AAAgAkEQaiAD -QRBqKQAANwAAIAJBCGogA0EIaikAADcAAAsgACACQQFqNgIEIAItAAAhAEEBDAELIAAoAhAiAwRA -IAAoAhQiAiAAKAIcRwRAIAAgAkEBajYCFCACLQAAIQBBAQwCCyAAKAIYIgIEQCADIAIQzwELIABB -ADYCEAtBAAshAiAGIAA6AAEgBiACOgAADAELQQFBIEH8q8AAELUBAAsCQCAGLQAABEACQEEIQX8g -BSgCDCIPIAUoAgQiDGsiAiAFKAIcIhcgBSgCFCIAa0EAIAUoAhAiDhsiA2oiByACIAdLGyADIAUo -AgAiAxtBAWoiAkF/IAIbIgIgAkEITRsiAkEASA0AIAYtAAEhB0H5gcEALQAAGkEBIQEgAkEBEMMB -IgpFDQAgCiAHOgAAIAZBATYCDCAGIAo2AgggBiACNgIEIAUoAiQhGiAFKAIgIQcgBSgCGCEYIAUo -AgghEUEBIQUDQAJAAkACQAJ/AkAgA0UNACAMIAwgD0cNARogEUUNACADIBEQzwELIAdFIAcgGkZy -DQFB+YHBAC0AABpBIEEBEMMBIgNFDQIgAyAHKQAANwAAIANBGGogB0EYaikAADcAACADQRBqIAdB -EGopAAA3AAAgA0EIaiAHQQhqKQAANwAAQSAhESADQSBqIQ8gB0EgaiEHIAMLIgJBAWohDCAAIQEM -AgsCQCAORQ0AIAAgF0cEQCAAQQFqIQFBACEDIAAhAgwDCyAYRQ0AIA4gGBDPAQsgCyAGKQIENwIA -IAtBCGogBkEMaigCADYCAAwFC0EBQSBB/KvAABC1AQALIAItAAAhGyAGKAIEIAVGBEAgBkEEaiEK -IwBBIGsiACQAAkACQCAFQX8gDyAMayICIBcgAWtBACAOGyIUaiISIAIgEksbIBQgAxtBAWoiAkF/ -IAIbIAVqIgJLDQBBCCACIAooAgAiFEEBdCISIAIgEksbIgIgAkEITRsiEq0iHUIgiFBFDQAgHaci -HEH/////B0sNACAAIBQEfyAAIBQ2AhwgACAKKAIENgIUQQEFQQALNgIYIABBCGpBASAcIABBFGoQ -dCAAKAIIQQFHDQEgACgCECECIAAoAgwhFgsgFiACQbixwAAQtQEACyAAKAIMIQIgCiASNgIAIAog -AjYCBCAAQSBqJAAgBigCCCEKCyAFIApqIBs6AAAgBiAFQQFqIgU2AgwgASEADAALAAsgASACQYyw -wAAQtQEACyALQQA2AgggC0KAgICAEDcCAAJAIAUoAgAiAEUNACAFKAIIIgFFDQAgACABEM8BCyAF -KAIQIgBFDQAgBSgCGCIBRQ0AIAAgARDPAQsgBkEQaiQAIAhBQGsiAEGcsMAAIAgoAhAiASAIKAIU -EDQgBCAAEJgBIAgoAgwiAARAIAEgABDPAQsgCEHgAGokACAQIAQQZCATRQ0AIBkgE0EFdBDPAQsg -BEEwaiQADAELQcSBwABBNyAEQS9qQbSBwABB8ILAABB9AAsCQAJAIA0CfyAJKAIUIgJBgICAgHhG -BEBBACEAIAkoAhghAUEBDAELIAkoAhghAQJAIAkoAhwiFSACTwRAIAEhAAwBCyAVRQRAQQEhACAB -IAIQzwEMAQsgASACQQEgFRC7ASIARQ0CC0EAIQFBAAs2AgwgDSABNgIIIA0gFTYCBCANIAA2AgAg -CUEgaiQADAELQQEgFUHchsAAELUBAAsgDSgCACANKAIEIA0oAgggDSgCDCANQRBqJAALzw4CGX8B -fiMAQRBrIgokACMAQSBrIgckAAJAAkACQCAABEAgAEEIayINIA0oAgBBAWoiBjYCACAGRQ0BIAAo -AgANAiAAQX82AgAgByANNgIQIAcgADYCDCAHIAI2AhwgByABNgIYIAcgAjYCFCAHIABBCGoiBjYC -CEEAIQIjAEGAAWsiAyQAIANBCGohDiAHQRRqIhMoAgQhFCATKAIIIQgjAEGAAWsiASQAIAFBADYC -FCABQoCAgICAATcCDAJAAkAgCARAIAFByABqQQRyIQQDQCACIAhLDQIgAUHIAGogBiACIBRqIAgg -AmtBABAyIAFBIGoiESAEQQhqKQIANwMAIAFBKGoiEiAEQRBqKQIANwMAIAFBMGoiFSAEQRhqKQIA -NwMAIAFBOGoiFiAEQSBqKQIANwMAIAFBQGsiFyAEQShqKAIANgIAIAEgBCkCADcDGCABKAJ4IRgg -ASgCSCIZBEAgASgCFCIPIAEoAgxGBEAjAEEgayIFJABBBCABQQxqIgwoAgAiEEEBdCIJIAlBBE0b -IhqtQjB+IhxCIIhQRQRAQQBBAEHglsAAELUBAAsCQCAcpyIbQfj///8HTQRAIAUgEAR/IAUgEEEw -bDYCHCAFIAwoAgQ2AhRBCAVBAAs2AhggBUEIakEIIBsgBUEUahB0IAUoAghBAUcNASAFKAIMIQsg -BSgCECEJCyALIAlB4JbAABC1AQALIAUoAgwhCSAMIBo2AgAgDCAJNgIEIAVBIGokAAsgASgCECAP -QTBsaiIFIAEpAxg3AgQgBSAZNgIAIAVBDGogESkDADcCACAFQRRqIBIpAwA3AgAgBUEcaiAVKQMA -NwIAIAVBJGogFikDADcCACAFQSxqIBcoAgA2AgAgASAPQQFqNgIUCyACIBhqIgIgCEcNAAsLIA4g -ASkCDDcCACAOQQhqIAFBFGooAgA2AgAgAUGAAWokAAwBCyACIAhB8JbAABDTAQALAkACQAJAIAMo -AhAiAkUEQEEEIQQMAQtB+YHBAC0AABogAkEUbCIBQQQQwwEiBEUNAQsgA0EANgIcIAMgBDYCGCAD -IAI2AhQgAygCDCIFIAJBMGxqIQggAygCCCEMIAUhAQJAIAIEQCADQSxqIQ4gA0EwaiEJIANBIGpB -BHIiBEEIaiEPIARBGGohECAEQSBqIREgBEEoaiESIAEhAgNAIAIoAgAiAQRAIAMgATYCICAEIAJB -BGopAgA3AgAgDyACQQxqKQIANwIAIARBEGogAkEUaikCADcCACAQIAJBHGopAgA3AgAgESACQSRq -KQIANwIAIBIgAkEsaigCADYCACAGLQAwIQEgCRCDASELIANB0ABqIAkQZCADIAsgAUEBc3I6AGAg -AyADKAIoIgE2AlwgDiADKAIkIAEgAygCICgCEBEDACADKAIcIgEgAygCFEYEQCADQRRqQcyFwAAQ -ZwsgAygCGCABQRRsaiILIAMpAlA3AgAgC0EIaiADQdgAaikCADcCACALQRBqIANB4ABqKAIANgIA -IAZBAToAMCADIAFBAWo2AhwgAkEwaiICIAhHDQEMAwsLIAJBMGohAQsgASAIRg0AIAggAWsiAkEw -biIGQQFxQQAhBCACQTBrQTBPBEAgBkH+//8/cSEGIAEhAgNAIAJBDGogAkEEaigCACACQQhqKAIA -IAIoAgAoAhARAwAgAkE8aiACQTRqKAIAIAJBOGooAgAgAkEwaigCACgCEBEDACACQeAAaiECIAYg -BEECaiIERw0ACwtFDQAgASAEQTBsaiIBQQxqIAEoAgQgASgCCCABKAIAKAIQEQMACyAMBEAgBSAM -QTBsEM8BCyADQQA2AmQgAygCGCECQQEhBiADQfQAaiADQeQAaiADKAIcIgEQtAECQCADKAJ0RQRA -IAMoAnghAQwBCyADQfAAaiADQfwAaigCADYCACADIAMpAnQ3A2gCQCABBEAgAUEUbCEGIANB6ABq -QQRyIQUgAygCcCEEA0AgAyACIAMoAmgQYCADKAIEIQEgAygCAEEBcQ0CIAUgBCABENEBIAMgBEEB -aiIENgJwIAJBFGohAiAGQRRrIgYNAAsLQQAhBiADKAJsIQEMAQtBASEGIAMoAmwiAkGEAUkNACAC -EG0LIAMoAhwiBARAIAMoAhghAgNAIAIoAgAiBQRAIAJBBGooAgAgBRDPAQsgAkEUaiECIARBAWsi -BA0ACwsgAygCFCICBEAgAygCGCACQRRsEM8BCyATKAIAIgIEQCAUIAIQzwELIAcgATYCBCAHIAY2 -AgAgA0GAAWokAAwBC0EEIAFBvIXAABC1AQALIAcoAgQhASAHKAIAIQIgAEEANgIAIA0gDSgCAEEB -ayIANgIAIABFBEAgB0EQahCTAQsgCiACQQFxIgA2AgggCiABQQAgABs2AgQgCkEAIAEgABs2AgAg -B0EgaiQADAMLEOMBCwALEOQBAAsgCigCACAKKAIEIAooAgggCkEQaiQAC5oGAQh/IwBBEGsiBCQA -EHAiAiAAJgEjAEEQayIIJAAgCEEEaiEDIwBB0ABrIgEkACABQQxqIAIQLyABKAIQIQICQAJAAkAg -ASgCDCIFQYCAgIB4RgRAIAEgAjYCPCABQQA2AkggAUKAgICAEDcCQCABQZyBwAA2AhwgAUKggICA -DjcCICABIAFBQGs2AhggAUE8aiABQRhqEJEBDQIgASgCQCECIAEoAkQiBSABKAJIELgBIQYgAgRA -IAUgAhDPAQsgASgCPCICQYQBTwRAIAIQbQsgA0GAgICAeDYCACADIAY2AgQMAQsgASgCFCEGIAFB -ADoADCABIAIgBkEEdGo2AiQgASAFNgIgIAEgAjYCHCABIAI2AhggASABQQxqNgIoIAFBQGsgAUEY -ahAsAkACQCABLQAMQQFGBEAgASgCQCICRQ0BIAEoAkQgAkEobBDPAQwBCyABKAJAIgJBgICAgHhH -DQELIAFBADYCSCABQoCAgIAQNwJAIAFBnIHAADYCHCABQqCAgIAONwIgIAEgAUFAazYCGCABQRhq -ELwBDQIgASgCQCECIAEoAkQiBSABKAJIELgBIQYgAgRAIAUgAhDPAQsgA0GAgICAeDYCACADIAY2 -AgQMAQsgASgCRCEFAkAgASgCSCIGRQRAIAFBMGpCADcDACABQShqQgA3AwAgAUEgakIANwMAIAFC -ADcDGAwBCyABQRhqIAUgBhAxCyADIAFBGGoQZCACRQ0AIAUgAkEobBDPAQsgAUHQAGokAAwBC0HE -gcAAQTcgAUHPAGpBtIHAAEHwgsAAEH0ACwJAAkAgBAJ/IAgoAgQiAkGAgICAeEYEQCAIKAIIIQFB -ACEDQQEMAQsgCCgCCCEBAkAgCCgCDCIDIAJPBEAgASEHDAELIANFBEBBASEHIAEgAhDPAQwBCyAB -IAJBASADELsBIgdFDQILQQAhAUEACzYCDCAEIAE2AgggBCADNgIEIAQgBzYCACAIQRBqJAAMAQtB -ASADQdyGwAAQtQEACyAEKAIAIAQoAgQgBCgCCCAEKAIMIARBEGokAAuHBwEKfyMAQRBrIgQkABBw -IgIgACYBIwBBEGsiCCQAIAhBBGohBSMAQfAAayIBJAAgAUEIaiACEC8gASgCDCECAkACQAJAIAEo -AggiA0GAgICAeEYEQCABIAI2AmggAUEANgIwIAFCgICAgBA3AiggAUGcgcAANgJMIAFCoICAgA43 -AlAgASABQShqNgJIIAFB6ABqIAFByABqEJEBDQIgASgCKCECIAEoAiwiAyABKAIwELgBIQYgAgRA -IAMgAhDPAQsgASgCaCICQYQBTwRAIAIQbQsgBUGAgICAeDYCACAFIAY2AgQMAQsgASgCECEGIAFB -ADoACCABIAIgBkEEdGo2AlQgASADNgJQIAEgAjYCTCABIAI2AkggASABQQhqNgJYIAFBKGogAUHI -AGoQLAJAAkAgAS0ACEEBRgRAIAEoAigiAkUNASABKAIsIAJBKGwQzwEMAQsgASgCKCIGQYCAgIB4 -Rw0BCyABQQA2AjAgAUKAgICAEDcCKCABQZyBwAA2AkwgAUKggICADjcCUCABIAFBKGo2AkggAUHI -AGoQvAENAiABKAIoIQIgASgCLCIDIAEoAjAQuAEhBiACBEAgAyACEM8BCyAFQYCAgIB4NgIAIAUg -BjYCBAwBCyABKAIsIQkCQCABKAIwIgJFBEAgAUEgakIANwMAIAFBGGpCADcDACABQRBqQgA3AwAg -AUIANwMIDAELIAFBKGoiCiAJIAIQMSABQcgAaiIDQeyGwAAQmAEjAEEgayICJAAgAkEYaiADQRhq -KQAANwMAIAJBEGogA0EQaikAADcDACACQQhqIANBCGopAAA3AwAgAiADKQAANwMAIAFBCGogAiAK -QSAQNCACQSBqJAALIAUgAUEIahBkIAZFDQAgCSAGQShsEM8BCyABQfAAaiQADAELQcSBwABBNyAB -Qe8AakG0gcAAQfCCwAAQfQALAkACQCAEAn8gCCgCBCIFQYCAgIB4RgRAIAgoAgghAUEAIQJBAQwB -CyAIKAIIIQECQCAIKAIMIgIgBU8EQCABIQcMAQsgAkUEQEEBIQcgASAFEM8BDAELIAEgBUEBIAIQ -uwEiB0UNAgtBACEBQQALNgIMIAQgATYCCCAEIAI2AgQgBCAHNgIAIAhBEGokAAwBC0EBIAJB3IbA -ABC1AQALIAQoAgAgBCgCBCAEKAIIIAQoAgwgBEEQaiQAC/oBAgJ/AX4jAEEQayICJAAgAkEBOwEM -IAIgATYCCCACIAA2AgQjAEEQayIBJAAgAkEEaiIAKQIAIQQgASAANgIMIAEgBDcCBCMAQRBrIgAk -ACABQQRqIgEoAgAiAigCDCEDAkACQAJAAkAgAigCBA4CAAECCyADDQFBASECQQAhAwwCCyADDQAg -AigCACICKAIEIQMgAigCACECDAELIABBgICAgHg2AgAgACABNgIMIABBwMjAACABKAIEIAEoAggi -AC0ACCAALQAJEGYACyAAIAM2AgQgACACNgIAIABBpMjAACABKAIEIAEoAggiAC0ACCAALQAJEGYA -C98IAQt/IwBBEGsiCCQAIwBBIGsiByQAAkACQAJAIAAEQCAAQQhrIgkgCSgCAEEBaiICNgIAIAJF -DQEgACgCAA0CIABBfzYCACAHIAk2AhwgByAANgIYIAcgAEEIaiICNgIUIAdBCGohCiMAQbABayIB -JAAgAUEANgIUIAFCgICAgMAANwIMIwBBQGoiAyQAIANBCGogAkEBQQBBARAyIAFBGGoiBEEoaiAD -QTBqKQMANwMAIARBIGogA0EoaikDADcDACAEQRhqIANBIGopAwA3AwAgBEEQaiADQRhqKQMANwMA -IARBCGogA0EQaikDADcDACAEIAMpAwg3AwAgA0FAayQAAn8gASgCGCILRQRAQQQhBUEADAELIAFB -8ABqIAFBQGspAwA3AwAgAUHoAGogAUE4aikDADcDACABQeAAaiABQTBqKQMANwMAIAFB2ABqIgMg -AUEoaikDADcDACABQdAAaiIFIAFBIGopAwA3AwAgASABKQMYNwNIIAItADAhBiADEIMBIQQgAUH8 -AGogAxBkIAFBjAFqIgMgBCAGQQFzcjoAACABIAUoAgAiBDYCiAEgAUHUAGogASgCTCAEIAEoAkgo -AhARAwAgAUEMakHMhsAAEGcgASgCECIFIAEpAnw3AgAgBUEIaiABQYQBaikCADcCACAFQRBqIAMo -AgA2AgAgAkEBOgAwIAFBATYCFEEBCyECIAFBADYCmAFBASEGIAFBGGogAUGYAWogAhC0AQJAIAEo -AhhFBEAgASgCHCEDDAELIAFBqAFqIAFBIGooAgA2AgAgASABKQIYNwOgAQJAIAsEQCACQRRsIQQg -AUGgAWpBBHIhAiABKAKoASEGA0AgASAFIAEoAqABEGAgASgCBCEDIAEoAgBBAXENAiACIAYgAxDR -ASABIAZBAWoiBjYCqAEgBUEUaiEFIARBFGsiBA0ACwtBACEGIAEoAqQBIQMMAQtBASEGIAEoAqQB -IgJBhAFJDQAgAhBtCyABIAM2ApQBIAEgBjYCkAEgAUEBNgIcIAFBsITAADYCGCABQgE3AiQgASAB -QZABaq1CgICAgDCENwOYASABIAFBmAFqNgIgIAFBoAFqIAFBGGoQRyABKAKkASIEIAEoAqgBEAAg -ASgCoAEiAgRAIAQgAhDPAQsgASgCkAEhAyABKAKUASEEIAEoAhQiBgRAIAEoAhAhBQNAIAUoAgAi -AgRAIAVBBGooAgAgAhDPAQsgBUEUaiEFIAZBAWsiBg0ACwsgASgCDCICBEAgASgCECACQRRsEM8B -CyAKIAQ2AgQgCiADNgIAIAFBsAFqJAAgBygCDCEEIAcoAgghAiAAQQA2AgAgCSAJKAIAQQFrIgA2 -AgAgAEUEQCAHQRxqEJMBCyAIIAJBAXEiADYCCCAIIARBACAAGzYCBCAIQQAgBCAAGzYCACAHQSBq -JAAMAwsQ4wELAAsQ5AEACyAIKAIAIAgoAgQgCCgCCCAIQRBqJAALIQACQCABIAMQtgEEQCAAIAEg -AyACELsBIgANAQsACyAACyUAIABFBEBByLPAAEEyEOUBAAsgACACIAMgBCAFIAEoAhAREwALIAEB -f0EBIQEgACgCACIAQQFxBH8gAQUgACgCCEEBRgsLHwECfiAAKQMAIgIgAkI/hyIDhSADfSACQgBZ -IAEQSQsjACAARQRAQcizwABBMhDlAQALIAAgAiADIAQgASgCEBEEAAsjACAARQRAQcizwABBMhDl -AQALIAAgAiADIAQgASgCEBEPAAsjACAARQRAQcizwABBMhDlAQALIAAgAiADIAQgASgCEBEnAAsj -ACAARQRAQcizwABBMhDlAQALIAAgAiADIAQgASgCEBEpAAsjACAARQRAQcizwABBMhDlAQALIAAg -AiADIAQgASgCEBErAAsmAQF/IAAoAgAiAUGAgICAeHJBgICAgHhHBEAgACgCBCABEM8BCwshACAA -RQRAQcizwABBMhDlAQALIAAgAiADIAEoAhARAwALIgAgAC0AAEUEQCABQdvtwABBBRA6DwsgAUHg -7cAAQQQQOgsfACAARQRAQcizwABBMhDlAQALIAAgAiABKAIQEQAACyEAIABBADYCDCAAIAM2Aggg -ACACNgIEIABBiLXAADYCAAtIACABUEUEQCAAKQMYIAGCDwsjAEEgayIAJAAgAEEANgIYIABBATYC -DCAAQaz+wAA2AgggAEIENwIQIABBCGpB/LjAABChAQALKQAgACAALQAEIAFBLkZyOgAEIAAoAgAi -ACgCACABIAAoAgQoAhARAAALGAEBfyAAKAIAIgEEQCAAKAIEIAEQzwELCyUBAW8QESEDEHAiAiAD -JgEgAEEANgIIIAAgAjYCBCAAIAE2AgALQgAgAARAIAAgARDqAQALIwBBIGsiACQAIABBADYCGCAA -QQE2AgwgAEHwycAANgIIIABCBDcCECAAQQhqIAIQoQEACxUAIAFpQQFGIABBgICAgHggAWtNcQsc -ACAAQQA2AhAgAEIANwIIIABCgICAgMAANwIACxYBAW8gACABEAEhAhBwIgAgAiYBIAALFgEBbyAA -IAEQBiECEHAiACACJgEgAAsWAQFvIAAlARAgIQEQcCIAIAEmASAAC+0GAQZ/An8CQAJAAkACQAJA -IABBBGsiBSgCACIGQXhxIgRBBEEIIAZBA3EiBxsgAWpPBEAgB0EAIAFBJ2oiCSAESRsNAQJAAkAg -AkEJTwRAIAIgAxBIIggNAUEADAkLIANBzP97Sw0BQRAgA0ELakF4cSADQQtJGyEBAkAgB0UEQCAB -QYACSSAEIAFBBHJJciAEIAFrQYGACE9yDQEMCQsgAEEIayICIARqIQcCQAJAAkACQCABIARLBEAg -B0GUhsEAKAIARg0EIAdBkIbBACgCAEYNAiAHKAIEIgZBAnENBSAGQXhxIgYgBGoiBCABSQ0FIAcg -BhBNIAQgAWsiA0EQSQ0BIAUgASAFKAIAQQFxckECcjYCACABIAJqIgEgA0EDcjYCBCACIARqIgIg -AigCBEEBcjYCBCABIAMQRAwNCyAEIAFrIgNBD0sNAgwMCyAFIAQgBSgCAEEBcXJBAnI2AgAgAiAE -aiIBIAEoAgRBAXI2AgQMCwtBiIbBACgCACAEaiIEIAFJDQICQCAEIAFrIgNBD00EQCAFIAZBAXEg -BHJBAnI2AgAgAiAEaiIBIAEoAgRBAXI2AgRBACEDQQAhAQwBCyAFIAEgBkEBcXJBAnI2AgAgASAC -aiIBIANBAXI2AgQgAiAEaiICIAM2AgAgAiACKAIEQX5xNgIEC0GQhsEAIAE2AgBBiIbBACADNgIA -DAoLIAUgASAGQQFxckECcjYCACABIAJqIgEgA0EDcjYCBCAHIAcoAgRBAXI2AgQgASADEEQMCQtB -jIbBACgCACAEaiIEIAFLDQcLIAMQKSIBRQ0BIANBfEF4IAUoAgAiAkEDcRsgAkF4cWoiAiACIANL -GyICBEAgASAAIAL8CgAACyAAEDkgAQwICyADIAEgASADSxsiAgRAIAggACAC/AoAAAsgBSgCACIC -QXhxIgMgAUEEQQggAkEDcSICG2pJDQMgAkEAIAMgCUsbDQQgABA5CyAIDAYLQanGwABBLkHYxsAA -EJYBAAtB6MbAAEEuQZjHwAAQlgEAC0GpxsAAQS5B2MbAABCWAQALQejGwABBLkGYx8AAEJYBAAsg -BSABIAZBAXFyQQJyNgIAIAEgAmoiAiAEIAFrIgFBAXI2AgRBjIbBACABNgIAQZSGwQAgAjYCACAA -DAELIAALCxkAIAAoAgBBjLnAAEEeIAAoAgQoAgwRAQALDgAgAQRAIAAgARDPAQsLGQAgASgCAEHH -6MAAQQ4gASgCBCgCDBEBAAsWACAAKAIAIAEgAiAAKAIEKAIMEQEACxQAIAAoAgAgASAAKAIEKAIM -EQAAC4MIAQR/IwBB8ABrIgUkACAFIAM2AgwgBSACNgIIAn8gAUGBAk8EQAJ/QYACIAAsAIACQb9/ -Sg0AGkH/ASAALAD/AUG/f0oNABpB/gFB/QEgACwA/gFBv39KGwsiBiAAaiwAAEG/f0oEQEGf7sAA -IQdBBQwCCyAAIAFBACAGIAQQwQEAC0EBIQcgASEGQQALIQggBSAGNgIUIAUgADYCECAFIAg2Ahwg -BSAHNgIYAkACQAJAAkAgASACSSIGIAEgA0lyRQRAIAIgA0sNASACRSABIAJNckUEQCAFQQxqIAVB -CGogACACaiwAAEG/f0obKAIAIQMLIAUgAzYCICADIAEiAkkEQCADQQFqIgIgA0EDayIGQQAgAyAG -TxsiBkkNAwJ/IAIgBmsiB0EBayAAIANqLAAAQb9/Sg0AGiAHQQJrIAAgAmoiAkECaywAAEG/f0oN -ABogB0EDayACQQNrLAAAQb9/Sg0AGiAHQXxBeyACQQRrLAAAQb9/ShtqCyAGaiECCwJAIAJFDQAg -ASACTQRAIAEgAkYNAQwFCyAAIAJqLAAAQb9/TA0ECwJ/AkACQCABIAJGDQACQAJAIAAgAmoiASwA -ACIAQQBIBEAgAS0AAUE/cSEGIABBH3EhAyAAQV9LDQEgA0EGdCAGciEADAILIAUgAEH/AXE2AiRB -AQwECyABLQACQT9xIAZBBnRyIQYgAEFwSQRAIAYgA0EMdHIhAAwBCyADQRJ0QYCA8ABxIAEtAANB -P3EgBkEGdHJyIgBBgIDEAEYNAQsgBSAANgIkIABBgAFPDQFBAQwCCyAEENcBAAtBAiAAQYAQSQ0A -GkEDQQQgAEGAgARJGwshACAFIAI2AiggBSAAIAJqNgIsIAVBBTYCNCAFQajvwAA2AjAgBUIFNwI8 -IAUgBUEYaq1CgICAgIAMhDcDaCAFIAVBEGqtQoCAgICADIQ3A2AgBSAFQShqrUKAgICAoAyENwNY -IAUgBUEkaq1CgICAgLAMhDcDUCAFIAVBIGqtQoCAgICACYQ3A0gMBAsgBSACIAMgBhs2AiggBUED -NgI0IAVB6O/AADYCMCAFQgM3AjwgBSAFQRhqrUKAgICAgAyENwNYIAUgBUEQaq1CgICAgIAMhDcD -UCAFIAVBKGqtQoCAgICACYQ3A0gMAwsgBUEENgI0IAVByO7AADYCMCAFQgQ3AjwgBSAFQRhqrUKA -gICAgAyENwNgIAUgBUEQaq1CgICAgIAMhDcDWCAFIAVBDGqtQoCAgICACYQ3A1AgBSAFQQhqrUKA -gICAgAmENwNIDAILIAYgAkGA8MAAENUBAAsgACABIAIgASAEEMEBAAsgBSAFQcgAajYCOCAFQTBq -IAQQoQEACxEAIAAoAgAgACgCBCABEOwBCxkAAn8gAUEJTwRAIAEgABBIDAELIAAQKQsLDwAgACAB -KAIAIAIgAxBbCw8AIAAgASgCACACIAMQQwsRACAAKAIEIAAoAgggARDsAQvgBgEPfyAAKAIAIQcg -ACgCBCEFQQAhACMAQRBrIgYkAEEBIQwCQCABKAIAIgpBIiABKAIEIg0oAhAiDhEAAA0AAkAgBUUE -QAwBC0EAIAVrIQ8gByEBIAUhAAJAAn8CQANAIAAgAWohEEEAIQMCQANAIAEgA2oiBC0AACIJQf8A -a0H/AXFBoQFJIAlBIkZyIAlB3ABGcg0BIAAgA0EBaiIDRw0ACyAAIAhqDAMLIARBAWohAQJAIAQs -AAAiAEEATgRAIABB/wFxIQAMAQsgAS0AAEE/cSELIABBH3EhCSAEQQJqIQEgAEFfTQRAIAlBBnQg -C3IhAAwBCyABLQAAQT9xIAtBBnRyIQsgBEEDaiEBIABBcEkEQCALIAlBDHRyIQAMAQsgCUESdEGA -gPAAcSABLQAAQT9xIAtBBnRyciEAIARBBGohAQsgBkEEaiAAQYGABBA1AkACQCAGLQAEQYABRg0A -IAYtAA8gBi0ADmtB/wFxQQFGDQACQAJAIAIgAyAIaiIESw0AAkAgAkUNACACIAVPBEAgAiAFRw0C -DAELIAIgB2osAABBv39MDQELAkAgBEUNACAEIAVPBEAgBCAPakUNAQwCCyAHIAhqIANqLAAAQUBI -DQELIAogAiAHaiAIIAJrIANqIA0oAgwiAhEBAEUNAQwDCyAHIAUgAiAEQeTtwAAQwQEACwJAIAYt -AARBgAFGBEAgCiAGKAIIIA4RAAANAwwBCyAKIAYtAA4iBCAGQQRqaiAGLQAPIARrIAIRAQANAgsC -f0EBIABBgAFJDQAaQQIgAEGAEEkNABpBA0EEIABBgIAESRsLIAhqIANqIQILAn9BASAAQYABSQ0A -GkECIABBgBBJDQAaQQNBBCAAQYCABEkbCyAIaiIEIANqIQggECABayIARQ0CDAELCwwECyADIARq -CyIDIAJJDQBBACEAAkAgAkUNACACIAVPBEAgAiIAIAVHDQIMAQsgAiIAIAdqLAAAQb9/TA0BCyAD -RQRAQQAhAwwCCyADIAVPBEAgAyAFRg0CIAAhAgwBCyADIAdqLAAAQb9/Sg0BIAAhAgsgByAFIAIg -A0H07cAAEMEBAAsgCiAAIAdqIAMgAGsgDSgCDBEBAA0AIApBIiAOEQAAIQwLIAZBEGokACAMCxYA -QdCCwQAgADYCAEHMgsEAQQE2AgALIgAgAELtuq22zYXU9eMANwMIIABC+IKZvZXuxsW5fzcDAAsh -ACAAQoC834WrpfibJzcDCCAAQp/1lpTW7u3DoX83AwALEwAgAEGUyMAANgIEIAAgATYCAAsRACAB -IAAoAgAgACgCBBC/AQsQACABIAAoAgAgACgCBBA6CxAAIAEoAgAgASgCBCAAEDwLYQECfwJAAkAg -AEEEaygCACICQXhxIgNBBEEIIAJBA3EiAhsgAWpPBEAgAkEAIAMgAUEnaksbDQEgABA5DAILQanG -wABBLkHYxsAAEJYBAAtB6MbAAEEuQZjHwAAQlgEACwsdAQFvIAAoAgAlASABJQEgARBtIAIlASAC -EG0QDgsXAQFvIAAoAgAlASABIAIlASACEG0QGwsNACAAKAIAKAIIQQFGC2sBAX8jAEEwayIDJAAg -AyABNgIEIAMgADYCACADQQI2AgwgA0Ho/sAANgIIIANCAjcCFCADIANBBGqtQoCAgICACYQ3Aygg -AyADrUKAgICAgAmENwMgIAMgA0EgajYCECADQQhqIAIQoQEAC2sBAX8jAEEwayIDJAAgAyABNgIE -IAMgADYCACADQQI2AgwgA0GI/8AANgIIIANCAjcCFCADIANBBGqtQoCAgICACYQ3AyggAyADrUKA -gICAgAmENwMgIAMgA0EgajYCECADQQhqIAIQoQEAC2sBAX8jAEEwayIDJAAgAyABNgIEIAMgADYC -ACADQQI2AgwgA0G8/8AANgIIIANCAjcCFCADIANBBGqtQoCAgICACYQ3AyggAyADrUKAgICAgAmE -NwMgIAMgA0EgajYCECADQQhqIAIQoQEACwsAIAAoAgAgARBMCw8AQfDowABBKyAAEJYBAAsNACAA -KQMAQQEgARBJCw4AIAFBgIPAAEEFEL8BCw4AIAFB1ITAAEEQEL8BCw4AIAFBsIjAAEEKEL8BCwwA -IAAoAgAgARDWAQuKAwEBfyAAKAIAIQIjAEHQAWsiACQAIAAgAkEYaq1CgICAgIAHhDcDaCAAIAJB -EGqtQoCAgICAB4Q3A2AgACACQQhqrUKAgICAgAeENwNYIAAgAq1CgICAgIAHhDcDUCAAQay5wAA2 -AjggAEEENgI8IABBBDYCTCAAQoOAgICAhICAaTcCyAEgAEGAgMAANgLAASAAQQI7AbgBIABCgoCA -gICEgIBpNwKwASAAQYCAwAA2AqgBIABBAjsBoAEgAEKBgICAgISAgGk3ApgBIABBgIDAADYCkAEg -AEECOwGIASAAQoCAgICAhICAaTcCgAEgAEKAgMAANwJ4IABBAjsBcCAAIABB8ABqNgJIIABBBDYC -RCAAIABB0ABqNgJAIABBLGoiAiAAQThqEEcgACACrUKAgICAkAeENwMgIABBATYCDCAAQby6wAA2 -AgggAEIBNwIUIAAgAEEgajYCECABKAIAIAEoAgQgAEEIahA8IAAoAiwiAgRAIAAoAjAgAhDPAQsg -AEHQAWokAAsLACAAKAIAIAEQcwsNACAAQaCPwAAgARA8Cw4AIAFBmI7AAEEFEL8BCw4AIAFB+rPA -AEELEL8BCw0AIABB7L3AACABEDwLDQBBqMPAAEEbEOUBAAsOAEHDw8AAQc8AEOUBAAsJACAAIAEQ -JQALDQAgAEHoxcAAIAEQPAsMACAAIAEpAgA3AwALDQAgAEHEycAAIAEQPAsOACABQbzJwABBBRC/ -AQsaACAAIAFB1ILBACgCACIAQckAIAAbEQIAAAsNACAAQZTrwAAgARA8CwoAIAIgACABEDoLCgAg -ACABJQEQAgsOACABQYS+wABBCBC/AQsOACABQY7AwABBAxC/AQsJACAAQQA2AgALCAAgACUBEAML -CAAgACUBEBILCAAgACUBECILBABBAAsCAAsLtoEBDgBBgIDAAAuxAS9ob21lL2NveW90dGU1MDgv -Y29kZS9odWdnaW5nZmFjZS5qcy9wYWNrYWdlcy9odWIveGV0LWNvcmUtd2FzbS1idWlsZC9tZXJr -bGVoYXNoL3NyYy9hZ2dyZWdhdGVkX2hhc2hlcy5ycwAAAAAAEABpAAAAWQAAADgAAAAAABAAaQAA -AFkAAAAPAAAAAAAQAGkAAABWAAAAOQAAAAQAAAAMAAAABAAAAAUAAAAGAAAABwBBvIHAAAutBQEA -AAAIAAAAYSBEaXNwbGF5IGltcGxlbWVudGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHVuZXhwZWN0 -ZWRseS9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS14ODZfNjQtdW5r -bm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvc3Ry -aW5nLnJzAPsAEAB0AAAA0QoAAA4AAABFcnJvcgAAAPsAEAB0AAAAfQUAABsAAAAAAAAABAAAAAQA -AAAJAAAAT2tFcnIvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2 -XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mv -c3JjL3NsaWNlLnJzrQEQAHMAAAC+AQAAHQAAAAEAAAAAAAAAaGFzaGxlbmd0aAAAOAIQAAQAAAA8 -AhAABgAAAHN0cnVjdCBKc0NodW5rSW5Kc0NodW5rT3V0ZGVkdXBhdHRlbXB0ZWQgdG8gdGFrZSBv -d25lcnNoaXAgb2YgUnVzdCB2YWx1ZSB3aGlsZSBpdCB3YXMgYm9ycm93ZWRzcmMvbGliLnJzsgIQ -AAoAAAA9AAAAOAAAALICEAAKAAAAQQAAACEAAAAvaG9tZS9jb3lvdHRlNTA4Ly5jYXJnby9yZWdp -c3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvd2FzbS1iaW5kZ2VuLTAu -Mi4xMDAvc3JjL2NvbnZlcnQvc2xpY2VzLnJzsgIQAAoAAABMAAAAFAAAANwCEABwAAAAJAEAAA4A -QYyHwAALkQEvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0 -LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvY29yZS9zcmMv -aXRlci90cmFpdHMvaXRlcmF0b3IucnMAAACMAxAAgQAAAMEHAAAJAEGoiMAAC5UBAQAAAAoAAABh -IHNlcXVlbmNlL2hvbWUvY295b3R0ZTUwOC8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRl -cy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3NlcmRlLTEuMC4yMTkvc3JjL2RlL2ltcGxzLnJzAAAAOgQQ -AGMAAACVBAAAIgAAADoEEABjAAAAmAQAABwAQciJwAALBQEAAAALAEHYicAACwUBAAAADABB6InA -AAvlAQEAAAANAAAAY2FsbGVkIGBPcHRpb246OnVud3JhcF90aHJvdygpYCBvbiBhIGBOb25lYCB2 -YWx1ZWhhc2hsZW5ndGgvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUt -eDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxs -b2Mvc3JjL3Jhd192ZWMvbW9kLnJzKwUQAHkAAAAuAgAAEQAAACA6IAoBAAAAAAAAALQFEAADAAAA -twUQAAEAQdiLwAALuwgBAAAAEQAAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVy -cmAgdmFsdWUvaG9tZS9jb3lvdHRlNTA4L2NvZGUvaHVnZ2luZ2ZhY2UuanMvcGFja2FnZXMvaHVi -L3hldC1jb3JlLXdhc20tYnVpbGQvbWVya2xlaGFzaC9zcmMvYWdncmVnYXRlZF9oYXNoZXMucnML -BhAAaQAAAD0AAAAqAAAACwYQAGkAAAA4AAAAHgAAAC9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90 -b29sY2hhaW5zL3N0YWJsZS14ODZfNjQtdW5rbm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIvc3Jj -L3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvc3RyaW5nLnJzlAYQAHQAAADoAQAAFwAAAEVycm9yAAAA -lAYQAHQAAAB9BQAAGwAAAGludmFsaWQgdmFsdWU6ICwgZXhwZWN0ZWQgAAAwBxAADwAAAD8HEAAL -AAAAbWlzc2luZyBmaWVsZCBgYFwHEAAPAAAAawcQAAEAAABkdXBsaWNhdGUgZmllbGQgYAAAAHwH -EAARAAAAawcQAAEAAAASAAAADAAAAAQAAAATAAAAFAAAAAcAAAAvaG9tZS9jb3lvdHRlNTA4Ly5y -dXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0 -bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3NsaWNlLnJzALgHEABzAAAAvgEAAB0AAAAv -aG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24t -bGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3ZlYy9zcGVj -X2Zyb21faXRlcl9uZXN0ZWQucnMAPAgQAIcAAAATAAAABQAAAGludmFsaWQgdHlwZTogLCBleHBl -Y3RlZCAAAADUCBAADgAAAOIIEAALAAAAL2hvbWUvY295b3R0ZTUwOC8ucnVzdHVwL3Rvb2xjaGFp -bnMvc3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9saWIvcnVzdGxpYi9zcmMvcnVzdC9s -aWJyYXJ5L2FsbG9jL3NyYy9zbGljZS5ycwAACRAAcwAAAL4BAAAdAAAAAQAAAAAAAAAvaG9tZS9j +gIAQVARAIAEgBjYC6AMMAwsgBkEoRg0RIAFByAJqIAZBAnRqICU+AgAgBkEBagVBAAs2AugDDAEL +IA5BAWohDgsgAUGQBWoiAiABQewDaiIAQaAB/AoAACABIAk2ArAGIAJBARAtIR0gASgCjAUhAiAB +QbQGaiIDIABBoAH8CgAAIAEgAjYC1AcgA0ECEC0hHiABKAKMBSECIAFB2AdqIgMgAEGgAfwKAAAg +ASACNgL4CCADQQMQLSEfAkACQAJAAkACQAJAIAEoAvgIIhIgASgCoAEiCSAJIBJJGyICQShNBEAg +AUGMBWohICABQbAGaiEhIAFB1AdqISIgASgCjAUhESABKAKwBiETIAEoAtQHIRlBACEGA0AgBiEK +IAJBAnQhAAJ/AkACQAJAA0AgAEUNASAAICJqIQMgAEEEayIAIAFqKAIAIgYgAygCACIDRg0ACyAD +IAZLDQEMAgsgAEUNAQsgCSECQQAMAQsgAgRAQQEhCEEAIQkgAkEBRwRAIAJBPnEhDCABIgBB2Adq +IQUDQCAAIAggACgCACILIAUoAgBBf3NqIgNqIgg2AgAgAEEEaiIGIAYoAgAiECAFQQRqKAIAQX9z +aiIGIAMgC0kgAyAIS3JqIgM2AgAgBiAQSSADIAZJciEIIAVBCGohBSAAQQhqIQAgDCAJQQJqIglH +DQALCyACQQFxBH8gASAJQQJ0IgBqIgMgAygCACIDIAAgH2ooAgBBf3NqIgAgCGoiBjYCACAAIANJ +IAAgBktyBSAIC0UNFgsgASACNgKgAUEICyELIBkgAiACIBlJGyIGQSlPDQMgBkECdCEAAkACQAJA +A0AgAEUNASAAICFqIQMgAEEEayIAIAFqKAIAIgkgAygCACIDRg0ACyADIAlNDQEgAiEGDAILIABF +DQAgAiEGDAELIAYEQEEBIQhBACEJIAZBAUcEQCAGQT5xIQwgASIAQbQGaiEFA0AgACAIIAAoAgAi +ECAFKAIAQX9zaiICaiIINgIAIABBBGoiAyADKAIAIhQgBUEEaigCAEF/c2oiAyACIBBJIAIgCEty +aiICNgIAIAMgFEkgAiADSXIhCCAFQQhqIQUgAEEIaiEAIAwgCUECaiIJRw0ACwsgBkEBcQR/IAEg +CUECdCIAaiICIAIoAgAiAiAAIB5qKAIAQX9zaiIAIAhqIgM2AgAgACACSSAAIANLcgUgCAtFDRYL +IAEgBjYCoAEgC0EEciELCyATIAYgBiATSRsiA0EpTw0EIANBAnQhAAJAAkACQANAIABFDQEgACAg +aiECIABBBGsiACABaigCACIJIAIoAgAiAkYNAAsgAiAJTQ0BIAYhAwwCCyAARQ0AIAYhAwwBCyAD +BEBBASEIQQAhCSADQQFHBEAgA0E+cSEMIAEiAEGQBWohBQNAIAAgCCAAKAIAIhAgBSgCAEF/c2oi +AmoiCDYCACAAQQRqIgYgBigCACIUIAVBBGooAgBBf3NqIgYgAiAQSSACIAhLcmoiAjYCACAGIBRJ +IAIgBklyIQggBUEIaiEFIABBCGohACAMIAlBAmoiCUcNAAsLIANBAXEEfyABIAlBAnQiAGoiAiAC +KAIAIgIgACAdaigCAEF/c2oiACAIaiIGNgIAIAAgAkkgACAGS3IFIAgLRQ0WCyABIAM2AqABIAtB +AmohCwsgESADIAMgEUkbIgJBKU8NEyACQQJ0IQACQAJAAkADQCAARQ0BIABBBGsiACABaigCACIG +IAAgAUHsA2pqKAIAIglGDQALIAYgCU8NASADIQIMAgsgAEUNACADIQIMAQsgAgRAQQEhCEEAIQkg +AkEBRwRAIAJBPnEhDCABIgBB7ANqIQUDQCAAIAggACgCACIQIAUoAgBBf3NqIgNqIgg2AgAgAEEE +aiIGIAYoAgAiFCAFQQRqKAIAQX9zaiIGIAMgEEkgAyAIS3JqIgM2AgAgBiAUSSADIAZJciEIIAVB +CGohBSAAQQhqIQAgDCAJQQJqIglHDQALCyACQQFxBH8gASAJQQJ0IgBqIgMgAygCACIDIAFB7ANq +IABqKAIAQX9zaiIAIAhqIgY2AgAgACADSSAAIAZLcgUgCAtFDRYLIAEgAjYCoAEgC0EBaiELCyAK +QRFGDQYgCiANaiALQTBqOgAAIAEoAsQCIgwgAiACIAxJGyIAQSlPDRUgCkEBaiEGIABBAnQhAAJ/ +AkADQCAARQ0BIABBBGsiACABaigCACIDIAAgAUGkAWpqKAIAIglGDQALIAMgCUsgAyAJSWsMAQtB +f0EAIAAbCyEUIAFB/AhqIAFBoAH8CgAAIAEgAjYCnAogASgC6AMiCyACIAIgC0kbIgNBKEsNBQJA +IANFBEBBACEDDAELQQAhCEEAIQkgA0EBRwRAIANBPnEhIyABQfwIaiEAIAFByAJqIQUDQCAAIAgg +ACgCACIkIAUoAgBqIhBqIhU2AgAgAEEEaiIIIAgoAgAiFiAFQQRqKAIAaiIIIBAgJEkgECAVS3Jq +IhA2AgAgCCAWSSAIIBBLciEIIAVBCGohBSAAQQhqIQAgIyAJQQJqIglHDQALCyADQQFxBH8gCUEC +dCIAIAFB/AhqaiIJIAkoAgAiCSABQcgCaiAAaigCAGoiACAIaiIFNgIAIAAgCUkgACAFS3IFIAgL +RQ0AIANBKEYNFyABQfwIaiADQQJ0akEBNgIAIANBAWohAwsgASADNgKcCiADIBEgAyARSxsiAEEp +Tw0VIABBAnQhAAJ/AkADQCAARQ0BIABBBGsiACABQewDamooAgAiAyAAIAFB/AhqaigCACIJRg0A +CyADIAlLIAMgCUlrDAELQX9BACAAGwsgGE4iACAUIBhIIgNFcUUEQCAADRMgAw0DDBILQQAhAyAB +An9BACACRQ0AGiACQQFrQf////8DcSIAQQFqIgpBA3EhBQJAIABBA0kEQCABIQBCACElDAELIApB +/P///wdxIQogASEAQgAhJQNAIAAgADUCAEIKfiAlfCIlPgIAIABBBGoiCSAJNQIAQgp+ICVCIIh8 +IiU+AgAgAEEIaiIJIAk1AgBCCn4gJUIgiHwiJT4CACAAQQxqIgkgCTUCAEIKfiAlQiCIfCImPgIA +ICZCIIghJSAAQRBqIQAgCkEEayIKDQALCyAFBEADQCAAIAA1AgBCCn4gJXwiJj4CACAAQQRqIQAg +JkIgiCElIAVBAWsiBQ0ACwsgAiAmQoCAgIAQVA0AGiACQShGDRcgASACQQJ0aiAlPgIAIAJBAWoL +Igk2AqABAkAgDEUNACAMQQFrQf////8DcSIAQQFqIgJBA3EhBQJAIABBA0kEQCABQaQBaiEAQgAh +JQwBCyACQfz///8HcSEKIAFBpAFqIQBCACElA0AgACAANQIAQgp+ICV8IiU+AgAgAEEEaiICIAI1 +AgBCCn4gJUIgiHwiJT4CACAAQQhqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIABBDGoiAiACNQIAQgp+ +ICVCIIh8IiY+AgAgJkIgiCElIABBEGohACAKQQRrIgoNAAsLIAUEQANAIAAgADUCAEIKfiAlfCIm +PgIAIABBBGohACAmQiCIISUgBUEBayIFDQALCyAmQoCAgIAQVARAIAwhAwwBCyAMQShGDRcgAUGk +AWogDEECdGogJT4CACAMQQFqIQMLIAEgAzYCxAICQCALRQRAQQAhCwwBCyALQQFrQf////8DcSIA +QQFqIgJBA3EhBQJAIABBA0kEQCABQcgCaiEAQgAhJQwBCyACQfz///8HcSEKIAFByAJqIQBCACEl +A0AgACAANQIAQgp+ICV8IiU+AgAgAEEEaiICIAI1AgBCCn4gJUIgiHwiJT4CACAAQQhqIgIgAjUC +AEIKfiAlQiCIfCIlPgIAIABBDGoiAiACNQIAQgp+ICVCIIh8IiY+AgAgJkIgiCElIABBEGohACAK +QQRrIgoNAAsLIAUEQANAIAAgADUCAEIKfiAlfCImPgIAIABBBGohACAmQiCIISUgBUEBayIFDQAL +CyAmQoCAgIAQVA0AIAtBKEYNFyABQcgCaiALQQJ0aiAlPgIAIAtBAWohCwsgASALNgLoAyASIAkg +CSASSRsiAkEoTQ0ACwsMEQsgAUEBEC0aIAEoAowFIgAgASgCoAEiAiAAIAJLGyIAQSlPDQQgAEEC +dCEAIAFBBGshAiABQegDaiEDA0AgAEUNDiAAIANqIQkgACACaiAAQQRrIQAoAgAiDCAJKAIAIglG +DQALIAkgDE0NDgwPCyAGQShBrP3AABDWAQALIANBKEGs/cAAENYBAAsgA0EoQaz9wAAQ1gEAC0ER +QRFBmNbAABCAAQALDA0LDA0LDAsLDAsLQcjWwABBN0GA18AAEJcBAAtBkNfAAEE2QcjXwAAQlwEA +C0Gs1cAAQRxByNXAABCXAQALQfzUwABBHUGc1cAAEJcBAAtBz9TAAEEcQezUwAAQlwEACyAADQEL +IAYgDWohAiAKIQBBfyEFAkADQCAAQX9GDQEgBUEBaiEFIAAgDWogAEEBayEALQAAQTlGDQALIAAg +DWoiAkEBaiIDIAMtAABBAWo6AAAgBUUgAEECaiAKS3INASACQQJqQTAgBfwLAAwBCyANQTE6AAAg +CgRAIA1BAWpBMCAK/AsACyAGQRFJBEAgAkEwOgAAIA5BAWohDiAKQQJqIQYMAQsgBkERQajWwAAQ +gAEACyAGQRFNBEAgDyAOOwEIIA8gBjYCBCAPIA02AgAgAUGgCmokAAwFCyAGQRFBuNbAABDWAQAL +IAJBKEGs/cAAENYBAAtBvP3AAEEaQaz9wAAQlwEACyAAQShBrP3AABDWAQALQShBKEGs/cAAEIAB +AAsLIAcgBygCUCAHKAJUIAcvAVhBACAHQSBqEFEgBygCBCEAIAcoAgAMAQsgB0ECOwEgIAdBATYC +KCAHQbvowAA2AiQgB0EgagshASAHIAA2AlwgByABNgJYIAcgGzYCVCAHIBc2AlAgB0HQAGoQPyAH +QYABaiQADwsCfyABIQwgAkEARyECIAEvAQ4hEUEAIQEjAEHwCGsiByQAID+9IScCf0EDID+ZRAAA +AAAAAPB/YQ0AGkECICdCgICAgICAgPj/AIMiJkKAgICAgICA+P8AUQ0AGiAnQv////////8HgyIp +QoCAgICAgIAIhCAnQgGGQv7///////8PgyAnQjSIp0H/D3EiABsiJUIBgyEoICZQBEBBBCApUA0B +GiAAQbMIayEBQgEhJiAoUAwBC0KAgICAgICAICAlQgGGICVCgICAgICAgAhRIgEbISVCAkIBIAEb +ISZBy3dBzHcgARsgAGohASAoUAshACAHIAE7AegIIAcgJjcD4AggB0IBNwPYCCAHICU3A9AIIAcg +ADoA6ggCQAJ/AkACQAJAAkAgAEECayIDBEBBASEAQbPowABBtOjAACAnQgBTIgYbQbPowABBASAG +GyACGyEbICdCP4inIAJyIR1BAyADIANBA08bQQJrDgICAwELIAdBAzYCmAggB0G16MAANgKUCCAH +QQI7AZAIQQEhG0EBIQAgB0GQCGoMBAsgB0EDNgKYCCAHQbjowAA2ApQIIAdBAjsBkAggB0GQCGoM +AwtBAiEAIAdBAjsBkAggEUUNASAHIBE2AqAIIAdBADsBnAggB0ECNgKYCCAHQbHowAA2ApQIIAdB +kAhqDAILQXRBBSABwSIAQQBIGyAAbCIAQcD9AEkEQCAHQZAIaiEEIAdBEGohBSAAQQR2QRVqIgoh +AUGAgH5BACARayARwUEASBshCQJAAkACfwJAAkACQAJAIAdB0AhqIgApAwAiJVBFBEAgJUKAgICA +gICAgCBaDQEgAUUNAkGgfyAALwEYIgBBIGsgACAlQoCAgIAQVCIAGyICQRBrIAIgJUIghiAlIAAb +IiVCgICAgICAwABUIgAbIgJBCGsgAiAlQhCGICUgABsiJUKAgICAgICAgAFUIgAbIgJBBGsgAiAl +QgiGICUgABsiJUKAgICAgICAgBBUIgAbIgJBAmsgAiAlQgSGICUgABsiJUKAgICAgICAgMAAVCIA +GyAlQgKGICUgABsiJUIAWWsiA2vBQdAAbEGwpwVqQc4QbSIAQdEATw0DIABBBHQiAkH42MAAaikD +ACImQv////8PgyInICUgJUJ/hUI/iIYiJUIgiCIofiIpQiCIICZCIIgiJiAofnwgJiAlQv////8P +gyIlfiImQiCIfCApQv////8PgyAlICd+QiCIfCAmQv////8Pg3xCgICAgAh8QiCIfCIlQUAgAyAC +QYDZwABqLwEAamsiC0E/ca0iJ4inIQAgAkGC2cAAai8BACECICVCASAnhiIoQgF9IimDIiZQBEAg +AUEKSw0HIAFBAnRBjObAAGooAgAgAEsNBwsgAEGQzgBPBEAgAEHAhD1JDQUgAEGAwtcvTwRAQQhB +CSAAQYCU69wDSSIDGyEGQYDC1y9BgJTr3AMgAxsMBwtBBkEHIABBgK3iBEkiAxshBkHAhD1BgK3i +BCADGwwGCyAAQeQATwRAQQJBAyAAQegHSSIDGyEGQeQAQegHIAMbDAYLQQpBASAAQQlLIgYbDAUL +Qc/UwABBHEG85cAAEJcBAAtBzOXAAEEkQfDlwAAQlwEAC0GY5cAAQSFBgObAABCXAQALIABB0QBB +uOPAABCAAQALQQRBBSAAQaCNBkkiAxshBkGQzgBBoI0GIAMbCyEDAkACQAJAAkAgBiACa0EBasEi +CCAJwSICSgRAIAtB//8DcSEOIAggCWvBIAEgCCACayABSRsiC0EBayEPQQAhAgNAIAAgA24hDSAB +IAJGDQMgACADIA1sayEAIAIgBWogDUEwajoAACACIA9GDQQgAiAGRg0CIAJBAWohAiADQQpJIANB +Cm4hA0UNAAtBuObAABCdAQALIAQgBSABQQAgCCAJICVCCoAgA60gJ4YgKBBFDAULIAJBAWohAiAO +QQFrQT9xrSEqQgEhJQNAICUgKohQRQRAIARBADYCAAwGCyABIAJNDQMgAiAFaiAmQgp+IiYgJ4in +QTBqOgAAICVCCn4hJSAmICmDISYgCyACQQFqIgJHDQALIAQgBSABIAsgCCAJICYgKCAlEEUMBAsg +ASABQcjmwAAQgAEACyAEIAUgASALIAggCSAArSAnhiAmfCADrSAnhiAoEEUMAgsgAiABQdjmwAAQ +gAEACyAEQQA2AgALIAnBIRgCQCAHKAKQCARAIAdByAhqIAdBmAhqKAIANgIAIAcgBykCkAg3A8AI +DAELIAdBwAhqIRIgB0EQaiEJIwBBwAZrIgUkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAHQdAI +aiIAKQMAIiVQRQRAIAApAwgiJlANASAAKQMQIidQDQIgJSAnfCAlVA0DICUgJlQNBCAALgEYIQAg +BSAlPgIMIAVBAUECICVCgICAgBBUIgEbNgKsASAFQQAgJUIgiKcgARs2AhAgBUEUakEAQZgB/AsA +IAVBtAFqQQBBnAH8CwAgBUEBNgKwASAFQQE2AtACIACsICVCAX15fULCmsHoBH5CgKHNoLQCfEIg +iKciAcEhDQJAIABBAE4EQCAFQQxqIAAQLRoMAQsgBUGwAWpBACAAa8EQLRoLAkAgDUEASARAIAVB +DGpBACANa0H//wNxECsMAQsgBUGwAWogAUH//wFxECsLIAUoAtACIQsgBUGcBWogBUGwAWpBoAH8 +CgAAIAUgCzYCvAYgCiIGQQpPBEAgBUGUBWohAgNAIAUoArwGIgRBKU8NCgJAIARFDQAgBEH///// +A2ohACAEQQJ0IQECfyAEQQFGBEBCACElIAVBnAVqIAFqDAELIAEgAmohBCAAQf////8DcUEBakH+ +////B3EhA0IAISUDQCAEQQRqIgEgATUCACAlQiCGhCIlQoCU69wDgCImPgIAIAQgBDUCACAlICZC +gJTr3AN+fUIghoQiJUKAlOvcA4AiJj4CACAlICZCgJTr3AN+fSElIARBCGshBCADQQJrIgMNAAsg +JUIghiElIARBCGoLIABBAXENAEEEayIAICUgADUCAIRCgJTr3AOAPgIACyAGQQlrIgZBCUsNAAsL +IAZBAnRBkObAAGooAgBBAXQiAkUNBSAFKAK8BiIEQSlPDQggBAR/IARB/////wNqIQAgBEECdCEB +IAKtISUCfyAEQQFGBEBCACEmIAVBnAVqIAFqDAELIAEgBWpBlAVqIQQgAEH/////A3FBAWpB/v// +/wdxIQNCACEmA0AgBEEEaiIBIAE1AgAgJkIghoQiJiAlgCInPgIAIAQgBDUCACAmICUgJ359QiCG +hCImICWAIic+AgAgJiAlICd+fSEmIARBCGshBCADQQJrIgMNAAsgJkIghiEmIARBCGoLIQEgAEEB +cUUEQCABQQRrIgAgJiAANQIAhCAlgD4CAAsgBSgCvAYFQQALIQECQAJAAkAgBSgCrAEiACABIAAg +AUsbIgFBKE0EQCABRQRAQQAhAQwECyABQQFxIQ4gAUEBRw0BQQAhBkEAIQgMAgsMFAsgAUE+cSEP +QQAhBiAFQZwFaiEEIAVBDGohA0EAIQgDQCAEIAQoAgAiFyADKAIAaiICIAZBAXFqIhM2AgAgBEEE +aiIGIAYoAgAiGSADQQRqKAIAaiIGIAIgF0kgAiATS3JqIgI2AgAgBiAZSSACIAZJciEGIANBCGoh +AyAEQQhqIQQgDyAIQQJqIghHDQALCyAOBH8gCEECdCICIAVBnAVqaiIDIAMoAgAiAyAFQQxqIAJq +KAIAaiICIAZqIgY2AgAgAiADSSACIAZLcgUgBgtBAXFFDQAgAUEoRg0KIAVBnAVqIAFBAnRqQQE2 +AgAgAUEBaiEBCyAFIAE2ArwGIAsgASABIAtJGyIEQSlPDQggBEECdCEEAkACQANAIARFDQEgBEEE +ayIEIAVBnAVqaigCACIBIAQgBUGwAWpqKAIAIgJGDQALIAEgAk8NAQwICyAEDQcLIA1BAWohDQwH +C0HP1MAAQRxB2NfAABCXAQALQfzUwABBHUHo18AAEJcBAAtBrNXAAEEcQfjXwAAQlwEAC0GQ18AA +QTZB6NjAABCXAQALQcjWwABBN0HY2MAAEJcBAAtB8/3AAEEbQaz9wAAQlwEACyAARQRAQQAhACAF +QQA2AqwBDAELIABBAWtB/////wNxIgFBAWoiAkEDcSEDAkAgAUEDSQRAIAVBDGohBEIAISUMAQsg +AkH8////B3EhASAFQQxqIQRCACElA0AgBCAENQIAQgp+ICV8IiU+AgAgBEEEaiICIAI1AgBCCn4g +JUIgiHwiJT4CACAEQQhqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIARBDGoiAiACNQIAQgp+ICVCIIh8 +IiY+AgAgJkIgiCElIARBEGohBCABQQRrIgENAAsLIAMEQANAIAQgBDUCAEIKfiAlfCImPgIAIARB +BGohBCAmQiCIISUgA0EBayIDDQALCyAmQoCAgIAQWgRAIABBKEYNAyAFQQxqIABBAnRqICU+AgAg +AEEBaiEACyAFIAA2AqwBC0EAIQYCQAJAAkACQCANwSIBIBjBIgJIIh5FBEAgDSAYa8EgCiABIAJr +IApJGyIIDQELQQAhCAwBCyAFQdQCaiIBIAVBsAFqIgBBoAH8CgAAIAUgCzYC9ANBASEXIAFBARAt +IR8gBSgC0AIhASAFQfgDaiICIABBoAH8CgAAIAUgATYCmAUgAkECEC0hICAFKALQAiEBIAVBnAVq +IgIgAEGgAfwKAAAgBSABNgK8BiAFQawBaiEhIAVB0AJqISIgBUH0A2ohFCAFQZgFaiEjQQAhDiAC +QQMQLSEkIAUoAqwBIQAgBSgC0AIhCyAFKAL0AyETIAUoApgFIRkgBSgCvAYhEAJAAkACQAJAA0Ag +AEEpTw0KIABBAnQhAUEAIQQCfwJAAkADQCABIARGDQEgBUEMaiAEaiAEQQRqIQQoAgBFDQALIBAg +ACAAIBBJGyIBQSlPDRQgAUECdCEEAkADQCAERQ0BIAQgI2ohAiAEQQRrIgQgBUEMamooAgAiAyAC +KAIAIgJGDQALIAIgA00NAkEADAMLIARFDQFBAAwCCyAIIApLDQQgCCAORg0IIAggDmsiAEUNCCAJ +IA5qQTAgAPwLAAwIC0EBIQZBACEAIAFBAUcEQCABQT5xIQ8gBUEMaiEEIAVBnAVqIQMDQCAEIAQo +AgAiFSADKAIAQX9zaiICIAZBAXFqIhY2AgAgBEEEaiIGIAYoAgAiGiADQQRqKAIAQX9zaiIGIAIg +FUkgAiAWS3JqIgI2AgAgBiAaSSACIAZJciEGIANBCGohAyAEQQhqIQQgDyAAQQJqIgBHDQALCyAB +QQFxBH8gAEECdCIAIAVBDGpqIgIgAigCACICIAAgJGooAgBBf3NqIgAgBmoiAzYCACAAIAJJIAAg +A0tyBSAGC0EBcUUNDCAFIAE2AqwBIAEhAEEICyEPIBkgACAAIBlJGyICQSlPDQMgAkECdCEEAkAC +QAJAA0AgBEUNASAEIBRqIQEgBEEEayIEIAVBDGpqKAIAIgMgASgCACIBRg0ACyABIANNDQEgACEC +DAILIARFDQAgACECDAELIAIEQEEBIQZBACEAIAJBAUcEQCACQT5xIRUgBUEMaiEEIAVB+ANqIQMD +QCAEIAQoAgAiFiADKAIAQX9zaiIBIAZBAXFqIho2AgAgBEEEaiIGIAYoAgAiHCADQQRqKAIAQX9z +aiIGIAEgFkkgASAaS3JqIgE2AgAgBiAcSSABIAZJciEGIANBCGohAyAEQQhqIQQgFSAAQQJqIgBH +DQALCyACQQFxBH8gAEECdCIAIAVBDGpqIgEgASgCACIBIAAgIGooAgBBf3NqIgAgBmoiAzYCACAA +IAFJIAAgA0tyBSAGC0EBcUUNDQsgBSACNgKsASAPQQRyIQ8LIBMgAiACIBNJGyIBQSlPDQQgAUEC +dCEEAkACQAJAA0AgBEUNASAEICJqIQAgBEEEayIEIAVBDGpqKAIAIgMgACgCACIARg0ACyAAIANN +DQEgAiEBDAILIARFDQAgAiEBDAELIAEEQEEBIQZBACEAIAFBAUcEQCABQT5xIRUgBUEMaiEEIAVB +1AJqIQMDQCAEIAQoAgAiFiADKAIAQX9zaiICIAZBAXFqIho2AgAgBEEEaiIGIAYoAgAiHCADQQRq +KAIAQX9zaiIGIAIgFkkgAiAaS3JqIgI2AgAgBiAcSSACIAZJciEGIANBCGohAyAEQQhqIQQgFSAA +QQJqIgBHDQALCyABQQFxBH8gAEECdCIAIAVBDGpqIgIgAigCACICIAAgH2ooAgBBf3NqIgAgBmoi +AzYCACAAIAJJIAAgA0tyBSAGC0EBcUUNDQsgBSABNgKsASAPQQJqIQ8LIAsgASABIAtJGyIAQSlP +DQogAEECdCEEAkACQAJAA0AgBEUNASAEICFqIQIgBEEEayIEIAVBDGpqKAIAIgMgAigCACICRg0A +CyACIANNDQEgASEADAILIARFDQAgASEADAELIAAEQEEBIQZBACEBIABBAUcEQCAAQT5xIRUgBUEM +aiEEIAVBsAFqIQMDQCAEIAQoAgAiFiADKAIAQX9zaiICIAZBAXFqIho2AgAgBEEEaiIGIAYoAgAi +HCADQQRqKAIAQX9zaiIGIAIgFkkgAiAaS3JqIgI2AgAgBiAcSSACIAZJciEGIANBCGohAyAEQQhq +IQQgFSABQQJqIgFHDQALCyAAQQFxBH8gAUECdCIBIAVBDGpqIgIgAigCACICIAVBsAFqIAFqKAIA +QX9zaiIBIAZqIgM2AgAgASACSSABIANLcgUgBgtBAXFFDQ0LIAUgADYCrAEgD0EBaiEPCyAKIA5N +DQEgCSAOaiAPQTBqOgAAIABBKU8NCgJAIABFBEBBACEADAELIABBAWtB/////wNxIgFBAWoiAkED +cSEDAkAgAUEDSQRAIAVBDGohBEIAISYMAQsgAkH8////B3EhASAFQQxqIQRCACEmA0AgBCAENQIA +Qgp+ICZ8IiU+AgAgBEEEaiICIAI1AgBCCn4gJUIgiHwiJT4CACAEQQhqIgIgAjUCAEIKfiAlQiCI +fCIlPgIAIARBDGoiAiACNQIAQgp+ICVCIIh8IiU+AgAgJUIgiCEmIARBEGohBCABQQRrIgENAAsL +IAMEQANAIAQgBDUCAEIKfiAmfCIlPgIAIARBBGohBCAlQiCIISYgA0EBayIDDQALCyAlQoCAgIAQ +VA0AIABBKEYNCiAFQQxqIABBAnRqICY+AgAgAEEBaiEACyAFIAA2AqwBIA5BAWohDiAXIAggF0si +AWohFyABDQALQQEhBgwECyAOIApBuNjAABCAAQALIAggCkHI2MAAENYBAAsgAkEoQaz9wAAQ1gEA +CwwMCwJAAkACQCALQSlJBEACQCALRQRAQQAhCwwBCyALQQFrQf////8DcSIBQQFqIgJBA3EhAwJA +IAFBA0kEQCAFQbABaiEEQgAhJQwBCyACQfz///8HcSEBIAVBsAFqIQRCACElA0AgBCAENQIAQgV+ +ICV8IiU+AgAgBEEEaiICIAI1AgBCBX4gJUIgiHwiJT4CACAEQQhqIgIgAjUCAEIFfiAlQiCIfCIl +PgIAIARBDGoiAiACNQIAQgV+ICVCIIh8IiY+AgAgJkIgiCElIARBEGohBCABQQRrIgENAAsLIAME +QANAIAQgBDUCAEIFfiAlfCImPgIAIARBBGohBCAmQiCIISUgA0EBayIDDQALCyAmQoCAgIAQVA0A +IAtBKEYNCCAFQbABaiALQQJ0aiAlPgIAIAtBAWohCwsgBSALNgLQAiALIAAgACALSRsiBEEpTw0G +IARBAnQhBCAFQQhqIQAgBUGsAWohAQJAAkADQCAERQ0BIAEgBGohAiAAIARqIARBBGshBCgCACID +IAIoAgAiAkYNAAsgAiADTw0FDAELIAYgBEVxRQ0EIAhBAWsiACAKTw0CIAAgCWotAABBAXFFDQQL +IAggCksNAiAIIAlqQQAhBCAJIQMCQANAIAQgCEYNASAEQQFqIQQgA0EBayIDIAhqIgAtAABBOUYN +AAsgACAALQAAQQFqOgAAIAggBGtBAWogCE8NBCAEQQFrIgFFDQQgAEEBakEwIAH8CwAMBAsCQCAI +RQRAQTEhBAwBCyAJQTE6AAAgCEEBRgRAQTAhBAwBC0EwIQQgCEEBayIARQ0AIAlBAWpBMCAA/AsA +CyANQQFqIQ0gHiAIIApPcg0DIAQ6AAAgCEEBaiEIDAMLIAtBKEGs/cAAENYBAAsgACAKQYjYwAAQ +gAEACyAIIApBmNjAABDWAQALIAggCksNAQsgEiANOwEIIBIgCDYCBCASIAk2AgAgBUHABmokAAwF +CyAIIApBqNjAABDWAQALIARBKEGs/cAAENYBAAtBKEEoQaz9wAAQgAEACyAAQShBrP3AABDWAQAL +Qbz9wABBGkGs/cAAEJcBAAsLIBggBy4ByAgiAEgEQCAHQQhqIAcoAsAIIAcoAsQIIAAgESAHQZAI +ahBRIAcoAgwhACAHKAIIDAMLQQIhACAHQQI7AZAIIBFFBEBBASEAIAdBATYCmAggB0G76MAANgKU +CCAHQZAIagwDCyAHIBE2AqAIIAdBADsBnAggB0ECNgKYCCAHQbHowAA2ApQIIAdBkAhqDAILQbzo +wABBJUHk6MAAEJcBAAtBASEAIAdBATYCmAggB0G76MAANgKUCCAHQZAIagshASAHIAA2AswIIAcg +ATYCyAggByAdNgLECCAHIBs2AsAIIAwgB0HACGoQPyAHQfAIaiQADAELIAFBKEGs/cAAENYBAAsL +QgEBfyMAQSBrIgMkACADQQA2AhAgA0EBNgIEIANCBDcCCCADIAE2AhwgAyAANgIYIAMgA0EYajYC +ACADIAIQowEAC0ABAX8gASgCACIBIAEoAggiBEEBajYCCCAEQQBIBEAACyAAIAE2AgwgACADNgII +IAAgAjYCBCAAQcC3wAA2AgALPAAgACABKQAANwAAIABBGGogAUEYaikAADcAACAAQRBqIAFBEGop +AAA3AAAgAEEIaiABQQhqKQAANwAAC5QCAQN/IAAoAgAhAiABKAIIIgBBgICAEHFFBEAgAEGAgIAg +cUUEQCACIAEQ2AEPC0EAIQAjAEGAAWsiBCQAIAIoAgAhAgNAIAAgBGpB/wBqIAJBD3EiA0EwciAD +QTdqIANBCkkbOgAAIABBAWshACACQQ9LIAJBBHYhAg0ACyABQQFB9uvAAEECIAAgBGpBgAFqQQAg +AGsQNiAEQYABaiQADwtBACEAIwBBgAFrIgQkACACKAIAIQIDQCAAIARqQf8AaiACQQ9xIgNBMHIg +A0HXAGogA0EKSRs6AAAgAEEBayEAIAJBD0sgAkEEdiECDQALIAFBAUH268AAQQIgACAEakGAAWpB +ACAAaxA2IARBgAFqJAALOAACQCACQYCAxABGDQAgACACIAEoAhARAABFDQBBAQ8LIANFBEBBAA8L +IAAgAyAEIAEoAgwRAQALLQACQCAAIAEQuAFFDQAgAARAQbmCwQAtAAAaIAAgARDFASIBRQ0BCyAB +DwsACzcBAX8jAEEgayIBJAAgAUEANgIYIAFBATYCDCABQaj+wAA2AgggAUIENwIQIAFBCGogABCj +AQALugUBB38jAEEQayIFJAAjAEEQayIHJAAgB0EEaiEIIwBBoAFrIgQkACAEQSBqIAAgARA3AkAg +BCgCIEEBRgRAIARBATYCBCAEQaCHwAA2AgAgBEIBNwIMIAQgBEGfAWqtQoCAgIDAAIQ3A2ggBCAE +QegAajYCCCAEQfgAaiAEEEcgBCgCfCIGIAQoAoABELoBIQkgBCgCeCIKBEAgBiAKENEBCyAIQYCA +gIB4NgIAIAggCTYCBAwBCyAEQRhqIARBQGsiBikDADcDACAEQRBqIARBOGoiCSkDADcDACAEQQhq +IARBMGoiCikDADcDACAEIAQpAyg3AwAgBEEgaiACIAMQNyAEKAIgQQFGBEAgBEEBNgJ8IARBwIfA +ADYCeCAEQgE3AoQBIAQgBEGfAWqtQoCAgIDAAIQ3A5ABIAQgBEGQAWo2AoABIARB6ABqIARB+ABq +EEcgBCgCbCIGIAQoAnAQugEhCSAEKAJoIgoEQCAGIAoQ0QELIAhBgICAgHg2AgAgCCAJNgIEDAEL +IARB4ABqIAYpAwA3AwAgBEHYAGogCSkDADcDACAEQdAAaiAKKQMANwMAIAQgBCkDKDcDSCAEQSBq +IgYgBCAEQcgAahCJASAIIAYQZAsgBEGgAWokACADBEAgAiADENEBCyABBEAgACABENEBCwJAAkAC +fyAHKAIEIgNBgICAgHhGBEBBASEBQQAhAEEAIQIgBygCCAwBCyAHKAIIIQECQCAHKAIMIgIgA08E +QCABIQAMAQsgAkUEQEEBIQAgASADENEBDAELIAEgA0EBIAIQvQEiAEUNAgtBACEBQQALIQMgBSAB +NgIMIAUgAzYCCCAFIAI2AgQgBSAANgIAIAdBEGokAAwBC0EBIAJB3IbAABC3AQALIAUoAgAgBSgC +BCAFKAIIIAUoAgwgBUEQaiQAC+oZAht/AX4jAEEQayINJAAjAEEgayIJJAAjAEEgayIEJAAgAa1C +DH4iHachAwJAAkACQAJAIB1CIIinIANB/P///wdLcg0AAn8gA0UEQEEEIQVBAAwBC0G5gsEALQAA +GkEEIQIgA0EEEMUBIgVFDQEgAQshAiAEQQA2AhwgBCAFNgIYIAQgAjYCFCABBEAgAUECdCEKQQgh +AgNAIARBCGogACAIaigCACIDEO8BIAQoAggiEEUNAyAEKAIMIQsgA0GEAU8EQCADEG0LIAQoAhQg +BkYEQCMAQSBrIgMkAEEEIARBFGoiBSgCACIMQQF0IgcgB0EETRsiD61CDH4iHUIgiFBFBEBBAEEA +QbDDwAAQtwEACwJAIB2nIg5B/P///wdNBH8gAyAMBH8gAyAMQQxsNgIcIAMgBSgCBDYCFEEEBUEA +CzYCGCADQQhqQQQgDiADQRRqEHQgAygCCEEBRw0BIAMoAhAhByADKAIMBUEACyAHQbDDwAAQtwEA +CyADKAIMIQcgBSAPNgIAIAUgBzYCBCADQSBqJAAgBCgCGCEFCyACIAVqIgMgCzYCACADQQRrIBA2 +AgAgA0EIayALNgIAIAQgBkEBaiIGNgIcIAJBDGohAiAKIAhBBGoiCEcNAAsgACABQQJ0ENEBCyAE +KAIYIQACQCAGIAQoAhQiAU8EQCAAIQIMAQsgAUEMbCEBIAZFBEBBBCECIAAgARDRAQwBCyAAIAFB +BCAGQQxsIgAQvQEiAkUNAwsgCSAGNgIEIAkgAjYCACAEQSBqJAAMAwsgAiADQZDDwAAQtwEAC0HA +w8AAQSgQ5wEAC0EEIABBoMPAABC3AQALIAkgCSgCBCIANgIQIAkgCSgCADYCDCAJIAA2AgggCUEU +aiEQIwBBMGsiBCQAIAlBCGoiASgCACECIAEoAgQhACABKAIIIQEgBEEAOgAvIAQgACABQQxsajYC +DCAEIAI2AgggBCAANgIEIAQgADYCACAEIARBL2o2AhAgBEEgaiEFIwBB4ABrIgIkAAJAAkACQAJA +AkAgBCgCBCIBIAQoAgwiBkYEQCABIQAMAQsgBCgCECEMIAQgAUEMaiIANgIEIAEoAgAhAyACQThq +IAEoAgQiByABKAIIEDcgAwRAIAcgAxDRAQsgAigCOEEBcUUNASAMQQE6AAALIAVBADYCCCAFQoCA +gICAATcCACAGIABrQQxuIQEgACAGRwRAA0AgACgCACIDBEAgAEEEaigCACADENEBCyAAQQxqIQAg +AUEBayIBDQALCyAEKAIIIgBFDQEgBCgCACAAQQxsENEBDAELIAJBMGoiAyACQdgAaikDADcDACAC +QShqIgcgAkHQAGopAwA3AwAgAkEgaiIIIAJByABqKQMANwMAIAIgAikDQDcDGEG5gsEALQAAGkGA +AUEIEMUBIgFFDQEgASACKQMYNwMAIAFBGGogAykDADcDACABQRBqIAcpAwA3AwAgAUEIaiAIKQMA +NwMAIAJBATYCFCACIAE2AhAgAkEENgIMIAQoAgghCiAEKAIAIQ8CQCAAIAZGDQAgAkFAayEIQSAh +B0EBIQMDQCAAKAIAIQsgAkE4aiAAQQRqKAIAIg4gAEEIaigCABA3IAsEQCAOIAsQ0QELIAIoAjhB +AXEEQCAMQQE6AAAgAEEMaiEADAILIAJBMGoiDiAIQRhqKQMANwMAIAJBKGoiESAIQRBqKQMANwMA +IAJBIGoiEyAIQQhqKQMANwMAIAIgCCkDADcDGCACKAIMIANGBEAgAkEMaiADQQFBCEEgEFcgAigC +ECEBCyABIAdqIgsgAikDGDcDACALQRhqIA4pAwA3AwAgC0EQaiARKQMANwMAIAtBCGogEykDADcD +ACACIANBAWoiAzYCFCAHQSBqIQcgAEEMaiIAIAZHDQALCyAGIABrQQxuIQEgACAGRwRAA0AgACgC +ACIDBEAgAEEEaigCACADENEBCyAAQQxqIQAgAUEBayIBDQALCyAKBEAgDyAKQQxsENEBCyAFIAIp +Agw3AgAgBUEIaiACQRRqKAIANgIACyACQeAAaiQADAELQQhBgAFBgJLAABC3AQALAkACQAJAAkAC +QCAELQAvQQFGBEAgBCgCICIARQ0BIAQoAiQgAEEFdBDRAQwBCyAEKAIgIhNBgICAgHhHDQELIARB +ADYCKCAEQoCAgIAQNwIgIARBnIHAADYCBCAEQqCAgIAONwIIIAQgBEEgajYCACAEQS9qIAQQvgEN +AiAEKAIgIQAgBCgCJCIBIAQoAigQugEhAiAABEAgASAAENEBCyAQQYCAgIB4NgIAIBAgAjYCBAwB +CyAEKAIkIhkhACAEKAIoIQEjAEHgAGsiCCQAIAhBADYCKCAIQQA2AhggCCAANgI4IAggACABQQV0 +ajYCPCAIQQxqIQtBACEBIwBBEGsiBiQAAkACQAJ/AkACQCAIQRhqIgUiACgCACIDBEAgACgCBCIC +IAAoAgxHDQEgACgCCCICBEAgAyACENEBCyAAQQA2AgALIAAoAiAiA0UNASADIAAoAiRGDQEgACAD +QSBqNgIgQbmCwQAtAAAaQSBBARDFASICRQ0DIABBIDYCCCAAIAI2AgAgAiADKQAANwAAIAAgAkEg +ajYCDCACQRhqIANBGGopAAA3AAAgAkEQaiADQRBqKQAANwAAIAJBCGogA0EIaikAADcAAAsgACAC +QQFqNgIEIAItAAAhAEEBDAELIAAoAhAiAwRAIAAoAhQiAiAAKAIcRwRAIAAgAkEBajYCFCACLQAA +IQBBAQwCCyAAKAIYIgIEQCADIAIQ0QELIABBADYCEAtBAAshAiAGIAA6AAEgBiACOgAADAELQQFB +IEG8rMAAELcBAAsCQCAGLQAABEACQEEIQX8gBSgCDCIPIAUoAgQiDGsiAiAFKAIcIhcgBSgCFCIA +a0EAIAUoAhAiDhsiA2oiByACIAdLGyADIAUoAgAiAxtBAWoiAkF/IAIbIgIgAkEITRsiAkEASA0A +IAYtAAEhB0G5gsEALQAAGkEBIQEgAkEBEMUBIgpFDQAgCiAHOgAAIAZBATYCDCAGIAo2AgggBiAC +NgIEIAUoAiQhGiAFKAIgIQcgBSgCGCEYIAUoAgghEUEBIQUDQAJAAkACQAJ/AkAgA0UNACAMIAwg +D0cNARogEUUNACADIBEQ0QELIAdFIAcgGkZyDQFBuYLBAC0AABpBIEEBEMUBIgNFDQIgAyAHKQAA +NwAAIANBGGogB0EYaikAADcAACADQRBqIAdBEGopAAA3AAAgA0EIaiAHQQhqKQAANwAAQSAhESAD +QSBqIQ8gB0EgaiEHIAMLIgJBAWohDCAAIQEMAgsCQCAORQ0AIAAgF0cEQCAAQQFqIQFBACEDIAAh +AgwDCyAYRQ0AIA4gGBDRAQsgCyAGKQIENwIAIAtBCGogBkEMaigCADYCAAwFC0EBQSBBvKzAABC3 +AQALIAItAAAhGyAGKAIEIAVGBEAgBkEEaiEKIwBBIGsiACQAAkACQCAFQX8gDyAMayICIBcgAWtB +ACAOGyIUaiISIAIgEksbIBQgAxtBAWoiAkF/IAIbIAVqIgJLDQBBCCACIAooAgAiFEEBdCISIAIg +EksbIgIgAkEITRsiEq0iHUIgiFBFDQAgHaciHEH/////B0sNACAAIBQEfyAAIBQ2AhwgACAKKAIE +NgIUQQEFQQALNgIYIABBCGpBASAcIABBFGoQdCAAKAIIQQFHDQEgACgCECECIAAoAgwhFgsgFiAC +QfixwAAQtwEACyAAKAIMIQIgCiASNgIAIAogAjYCBCAAQSBqJAAgBigCCCEKCyAFIApqIBs6AAAg +BiAFQQFqIgU2AgwgASEADAALAAsgASACQcywwAAQtwEACyALQQA2AgggC0KAgICAEDcCAAJAIAUo +AgAiAEUNACAFKAIIIgFFDQAgACABENEBCyAFKAIQIgBFDQAgBSgCGCIBRQ0AIAAgARDRAQsgBkEQ +aiQAIAhBQGsiAEHcsMAAIAgoAhAiASAIKAIUEDQgBCAAEJkBIAgoAgwiAARAIAEgABDRAQsgCEHg +AGokACAQIAQQZCATRQ0AIBkgE0EFdBDRAQsgBEEwaiQADAELQcSBwABBNyAEQS9qQbSBwABB8ILA +ABB9AAsCQAJAIA0CfyAJKAIUIgJBgICAgHhGBEBBACEAIAkoAhghAUEBDAELIAkoAhghAQJAIAko +AhwiFSACTwRAIAEhAAwBCyAVRQRAQQEhACABIAIQ0QEMAQsgASACQQEgFRC9ASIARQ0CC0EAIQFB +AAs2AgwgDSABNgIIIA0gFTYCBCANIAA2AgAgCUEgaiQADAELQQEgFUHchsAAELcBAAsgDSgCACAN +KAIEIA0oAgggDSgCDCANQRBqJAALzw4CGX8BfiMAQRBrIgokACMAQSBrIgckAAJAAkACQCAABEAg +AEEIayINIA0oAgBBAWoiBjYCACAGRQ0BIAAoAgANAiAAQX82AgAgByANNgIQIAcgADYCDCAHIAI2 +AhwgByABNgIYIAcgAjYCFCAHIABBCGoiBjYCCEEAIQIjAEGAAWsiAyQAIANBCGohDiAHQRRqIhMo +AgQhFCATKAIIIQgjAEGAAWsiASQAIAFBADYCFCABQoCAgICAATcCDAJAAkAgCARAIAFByABqQQRy +IQQDQCACIAhLDQIgAUHIAGogBiACIBRqIAggAmtBABAyIAFBIGoiESAEQQhqKQIANwMAIAFBKGoi +EiAEQRBqKQIANwMAIAFBMGoiFSAEQRhqKQIANwMAIAFBOGoiFiAEQSBqKQIANwMAIAFBQGsiFyAE +QShqKAIANgIAIAEgBCkCADcDGCABKAJ4IRggASgCSCIZBEAgASgCFCIPIAEoAgxGBEAjAEEgayIF +JABBBCABQQxqIgwoAgAiEEEBdCIJIAlBBE0bIhqtQjB+IhxCIIhQRQRAQQBBAEGgl8AAELcBAAsC +QCAcpyIbQfj///8HTQRAIAUgEAR/IAUgEEEwbDYCHCAFIAwoAgQ2AhRBCAVBAAs2AhggBUEIakEI +IBsgBUEUahB0IAUoAghBAUcNASAFKAIMIQsgBSgCECEJCyALIAlBoJfAABC3AQALIAUoAgwhCSAM +IBo2AgAgDCAJNgIEIAVBIGokAAsgASgCECAPQTBsaiIFIAEpAxg3AgQgBSAZNgIAIAVBDGogESkD +ADcCACAFQRRqIBIpAwA3AgAgBUEcaiAVKQMANwIAIAVBJGogFikDADcCACAFQSxqIBcoAgA2AgAg +ASAPQQFqNgIUCyACIBhqIgIgCEcNAAsLIA4gASkCDDcCACAOQQhqIAFBFGooAgA2AgAgAUGAAWok +AAwBCyACIAhBsJfAABDVAQALAkACQAJAIAMoAhAiAkUEQEEEIQQMAQtBuYLBAC0AABogAkEUbCIB +QQQQxQEiBEUNAQsgA0EANgIcIAMgBDYCGCADIAI2AhQgAygCDCIFIAJBMGxqIQggAygCCCEMIAUh +AQJAIAIEQCADQSxqIQ4gA0EwaiEJIANBIGpBBHIiBEEIaiEPIARBGGohECAEQSBqIREgBEEoaiES +IAEhAgNAIAIoAgAiAQRAIAMgATYCICAEIAJBBGopAgA3AgAgDyACQQxqKQIANwIAIARBEGogAkEU +aikCADcCACAQIAJBHGopAgA3AgAgESACQSRqKQIANwIAIBIgAkEsaigCADYCACAGLQAwIQEgCRCD +ASELIANB0ABqIAkQZCADIAsgAUEBc3I6AGAgAyADKAIoIgE2AlwgDiADKAIkIAEgAygCICgCEBED +ACADKAIcIgEgAygCFEYEQCADQRRqQcyFwAAQZwsgAygCGCABQRRsaiILIAMpAlA3AgAgC0EIaiAD +QdgAaikCADcCACALQRBqIANB4ABqKAIANgIAIAZBAToAMCADIAFBAWo2AhwgAkEwaiICIAhHDQEM +AwsLIAJBMGohAQsgASAIRg0AIAggAWsiAkEwbiIGQQFxQQAhBCACQTBrQTBPBEAgBkH+//8/cSEG +IAEhAgNAIAJBDGogAkEEaigCACACQQhqKAIAIAIoAgAoAhARAwAgAkE8aiACQTRqKAIAIAJBOGoo +AgAgAkEwaigCACgCEBEDACACQeAAaiECIAYgBEECaiIERw0ACwtFDQAgASAEQTBsaiIBQQxqIAEo +AgQgASgCCCABKAIAKAIQEQMACyAMBEAgBSAMQTBsENEBCyADQQA2AmQgAygCGCECQQEhBiADQfQA +aiADQeQAaiADKAIcIgEQtgECQCADKAJ0RQRAIAMoAnghAQwBCyADQfAAaiADQfwAaigCADYCACAD +IAMpAnQ3A2gCQCABBEAgAUEUbCEGIANB6ABqQQRyIQUgAygCcCEEA0AgAyACIAMoAmgQYCADKAIE +IQEgAygCAEEBcQ0CIAUgBCABENMBIAMgBEEBaiIENgJwIAJBFGohAiAGQRRrIgYNAAsLQQAhBiAD +KAJsIQEMAQtBASEGIAMoAmwiAkGEAUkNACACEG0LIAMoAhwiBARAIAMoAhghAgNAIAIoAgAiBQRA +IAJBBGooAgAgBRDRAQsgAkEUaiECIARBAWsiBA0ACwsgAygCFCICBEAgAygCGCACQRRsENEBCyAT +KAIAIgIEQCAUIAIQ0QELIAcgATYCBCAHIAY2AgAgA0GAAWokAAwBC0EEIAFBvIXAABC3AQALIAco +AgQhASAHKAIAIQIgAEEANgIAIA0gDSgCAEEBayIANgIAIABFBEAgB0EQahCUAQsgCiACQQFxIgA2 +AgggCiABQQAgABs2AgQgCkEAIAEgABs2AgAgB0EgaiQADAMLEOUBCwALEOYBAAsgCigCACAKKAIE +IAooAgggCkEQaiQAC6AGAQh/IwBBEGsiBCQAEHAiAiAAJgEjAEEQayIIJAAgCEEEaiEDIwBB0ABr +IgEkACABQQxqIAIQLyABKAIQIQICQAJAAkAgASgCDCIFQYCAgIB4RgRAIAEgAjYCPCABQQA2Akgg +AUKAgICAEDcCQCABQZyBwAA2AhwgAUKggICADjcCICABIAFBQGs2AhggAUE8aiABQRhqEJIBDQIg +ASgCQCECIAEoAkQiBSABKAJIELoBIQYgAgRAIAUgAhDRAQsgASgCPCICQYQBTwRAIAIQbQsgA0GA +gICAeDYCACADIAY2AgQMAQsgASgCFCEGIAFBADoADCABIAIgBkEEdGo2AiQgASAFNgIgIAEgAjYC +HCABIAI2AhggASABQQxqNgIoIAFBQGsgAUEYahAsAkACQCABLQAMQQFGBEAgASgCQCICRQ0BIAEo +AkQgAkEobBDRAQwBCyABKAJAIgJBgICAgHhHDQELIAFBADYCSCABQoCAgIAQNwJAIAFBnIHAADYC +HCABQqCAgIAONwIgIAEgAUFAazYCGCABQc8AaiABQRhqEL4BDQIgASgCQCECIAEoAkQiBSABKAJI +ELoBIQYgAgRAIAUgAhDRAQsgA0GAgICAeDYCACADIAY2AgQMAQsgASgCRCEFAkAgASgCSCIGRQRA +IAFBMGpCADcDACABQShqQgA3AwAgAUEgakIANwMAIAFCADcDGAwBCyABQRhqIAUgBhAxCyADIAFB +GGoQZCACRQ0AIAUgAkEobBDRAQsgAUHQAGokAAwBC0HEgcAAQTcgAUHPAGpBtIHAAEHwgsAAEH0A +CwJAAkAgBAJ/IAgoAgQiAkGAgICAeEYEQCAIKAIIIQFBACEDQQEMAQsgCCgCCCEBAkAgCCgCDCID +IAJPBEAgASEHDAELIANFBEBBASEHIAEgAhDRAQwBCyABIAJBASADEL0BIgdFDQILQQAhAUEACzYC +DCAEIAE2AgggBCADNgIEIAQgBzYCACAIQRBqJAAMAQtBASADQdyGwAAQtwEACyAEKAIAIAQoAgQg +BCgCCCAEKAIMIARBEGokAAvCBgEJfyMAQRBrIgQkABBwIgIgACYBIwBBEGsiCCQAIAhBBGohAyMA +QfAAayIBJAAgAUEIaiACEC8gASgCDCECAkACQAJAIAEoAggiBkGAgICAeEYEQCABIAI2AmggAUEA +NgIwIAFCgICAgBA3AiggAUGcgcAANgJMIAFCoICAgA43AlAgASABQShqNgJIIAFB6ABqIAFByABq +EJIBDQIgASgCKCECIAEoAiwiBiABKAIwELoBIQUgAgRAIAYgAhDRAQsgASgCaCICQYQBTwRAIAIQ +bQsgA0GAgICAeDYCACADIAU2AgQMAQsgASgCECEFIAFBADoACCABIAIgBUEEdGo2AlQgASAGNgJQ +IAEgAjYCTCABIAI2AkggASABQQhqNgJYIAFBKGogAUHIAGoQLAJAAkAgAS0ACEEBRgRAIAEoAigi +AkUNASABKAIsIAJBKGwQ0QEMAQsgASgCKCICQYCAgIB4Rw0BCyABQQA2AjAgAUKAgICAEDcCKCAB +QZyBwAA2AkwgAUKggICADjcCUCABIAFBKGo2AkggAUHvAGogAUHIAGoQvgENAiABKAIoIQIgASgC +LCIGIAEoAjAQugEhBSACBEAgBiACENEBCyADQYCAgIB4NgIAIAMgBTYCBAwBCyABKAIsIQYCQCAB +KAIwIgVFBEAgAUEgakIANwMAIAFBGGpCADcDACABQRBqQgA3AwAgAUIANwMIDAELIAFBKGoiCSAG +IAUQMSABQcgAaiIFQeyGwAAQmQEgAUEIaiAJIAUQiQELIAMgAUEIahBkIAJFDQAgBiACQShsENEB +CyABQfAAaiQADAELQcSBwABBNyABQe8AakG0gcAAQfCCwAAQfQALAkACQCAEAn8gCCgCBCICQYCA +gIB4RgRAIAgoAgghAUEAIQNBAQwBCyAIKAIIIQECQCAIKAIMIgMgAk8EQCABIQcMAQsgA0UEQEEB +IQcgASACENEBDAELIAEgAkEBIAMQvQEiB0UNAgtBACEBQQALNgIMIAQgATYCCCAEIAM2AgQgBCAH +NgIAIAhBEGokAAwBC0EBIANB3IbAABC3AQALIAQoAgAgBCgCBCAEKAIIIAQoAgwgBEEQaiQAC/oB +AgJ/AX4jAEEQayICJAAgAkEBOwEMIAIgATYCCCACIAA2AgQjAEEQayIBJAAgAkEEaiIAKQIAIQQg +ASAANgIMIAEgBDcCBCMAQRBrIgAkACABQQRqIgEoAgAiAigCDCEDAkACQAJAAkAgAigCBA4CAAEC +CyADDQFBASECQQAhAwwCCyADDQAgAigCACICKAIEIQMgAigCACECDAELIABBgICAgHg2AgAgACAB +NgIMIABBgMnAACABKAIEIAEoAggiAC0ACCAALQAJEGYACyAAIAM2AgQgACACNgIAIABB5MjAACAB +KAIEIAEoAggiAC0ACCAALQAJEGYAC98IAQt/IwBBEGsiCCQAIwBBIGsiByQAAkACQAJAIAAEQCAA +QQhrIgkgCSgCAEEBaiICNgIAIAJFDQEgACgCAA0CIABBfzYCACAHIAk2AhwgByAANgIYIAcgAEEI +aiICNgIUIAdBCGohCiMAQbABayIBJAAgAUEANgIUIAFCgICAgMAANwIMIwBBQGoiAyQAIANBCGog +AkEBQQBBARAyIAFBGGoiBEEoaiADQTBqKQMANwMAIARBIGogA0EoaikDADcDACAEQRhqIANBIGop +AwA3AwAgBEEQaiADQRhqKQMANwMAIARBCGogA0EQaikDADcDACAEIAMpAwg3AwAgA0FAayQAAn8g +ASgCGCILRQRAQQQhBUEADAELIAFB8ABqIAFBQGspAwA3AwAgAUHoAGogAUE4aikDADcDACABQeAA +aiABQTBqKQMANwMAIAFB2ABqIgMgAUEoaikDADcDACABQdAAaiIFIAFBIGopAwA3AwAgASABKQMY +NwNIIAItADAhBiADEIMBIQQgAUH8AGogAxBkIAFBjAFqIgMgBCAGQQFzcjoAACABIAUoAgAiBDYC +iAEgAUHUAGogASgCTCAEIAEoAkgoAhARAwAgAUEMakHMhsAAEGcgASgCECIFIAEpAnw3AgAgBUEI +aiABQYQBaikCADcCACAFQRBqIAMoAgA2AgAgAkEBOgAwIAFBATYCFEEBCyECIAFBADYCmAFBASEG +IAFBGGogAUGYAWogAhC2AQJAIAEoAhhFBEAgASgCHCEDDAELIAFBqAFqIAFBIGooAgA2AgAgASAB +KQIYNwOgAQJAIAsEQCACQRRsIQQgAUGgAWpBBHIhAiABKAKoASEGA0AgASAFIAEoAqABEGAgASgC +BCEDIAEoAgBBAXENAiACIAYgAxDTASABIAZBAWoiBjYCqAEgBUEUaiEFIARBFGsiBA0ACwtBACEG +IAEoAqQBIQMMAQtBASEGIAEoAqQBIgJBhAFJDQAgAhBtCyABIAM2ApQBIAEgBjYCkAEgAUEBNgIc +IAFBsITAADYCGCABQgE3AiQgASABQZABaq1CgICAgDCENwOYASABIAFBmAFqNgIgIAFBoAFqIAFB +GGoQRyABKAKkASIEIAEoAqgBEAAgASgCoAEiAgRAIAQgAhDRAQsgASgCkAEhAyABKAKUASEEIAEo +AhQiBgRAIAEoAhAhBQNAIAUoAgAiAgRAIAVBBGooAgAgAhDRAQsgBUEUaiEFIAZBAWsiBg0ACwsg +ASgCDCICBEAgASgCECACQRRsENEBCyAKIAQ2AgQgCiADNgIAIAFBsAFqJAAgBygCDCEEIAcoAggh +AiAAQQA2AgAgCSAJKAIAQQFrIgA2AgAgAEUEQCAHQRxqEJQBCyAIIAJBAXEiADYCCCAIIARBACAA +GzYCBCAIQQAgBCAAGzYCACAHQSBqJAAMAwsQ5QELAAsQ5gEACyAIKAIAIAgoAgQgCCgCCCAIQRBq +JAALIQACQCABIAMQuAEEQCAAIAEgAyACEL0BIgANAQsACyAACyUAIABFBEBBiLTAAEEyEOcBAAsg +ACACIAMgBCAFIAEoAhAREwALIAEBf0EBIQEgACgCACIAQQFxBH8gAQUgACgCCEEBRgsLHwECfiAA +KQMAIgIgAkI/hyIDhSADfSACQgBZIAEQSQsjACAARQRAQYi0wABBMhDnAQALIAAgAiADIAQgASgC +EBEEAAsjACAARQRAQYi0wABBMhDnAQALIAAgAiADIAQgASgCEBEPAAsjACAARQRAQYi0wABBMhDn +AQALIAAgAiADIAQgASgCEBEoAAsjACAARQRAQYi0wABBMhDnAQALIAAgAiADIAQgASgCEBEqAAsj +ACAARQRAQYi0wABBMhDnAQALIAAgAiADIAQgASgCEBEsAAsmAQF/IAAoAgAiAUGAgICAeHJBgICA +gHhHBEAgACgCBCABENEBCwshACAARQRAQYi0wABBMhDnAQALIAAgAiADIAEoAhARAwALIgAgAC0A +AEUEQCABQZvuwABBBRA6DwsgAUGg7sAAQQQQOgsfACAARQRAQYi0wABBMhDnAQALIAAgAiABKAIQ +EQAACyEAIABBADYCDCAAIAM2AgggACACNgIEIABByLXAADYCAAtIACABUEUEQCAAKQMYIAGCDwsj +AEEgayIAJAAgAEEANgIYIABBATYCDCAAQez+wAA2AgggAEIENwIQIABBCGpBvLnAABCjAQALKQAg +ACAALQAEIAFBLkZyOgAEIAAoAgAiACgCACABIAAoAgQoAhARAAALGAEBfyAAKAIAIgEEQCAAKAIE +IAEQ0QELCyUBAW8QESEDEHAiAiADJgEgAEEANgIIIAAgAjYCBCAAIAE2AgALQgAgAARAIAAgARDs +AQALIwBBIGsiACQAIABBADYCGCAAQQE2AgwgAEGwysAANgIIIABCBDcCECAAQQhqIAIQowEACxUA +IAFpQQFGIABBgICAgHggAWtNcQscACAAQQA2AhAgAEIANwIIIABCgICAgMAANwIACxYBAW8gACAB +EAEhAhBwIgAgAiYBIAALFgEBbyAAIAEQBiECEHAiACACJgEgAAsWAQFvIAAlARAgIQEQcCIAIAEm +ASAAC+0GAQZ/An8CQAJAAkACQAJAIABBBGsiBSgCACIGQXhxIgRBBEEIIAZBA3EiBxsgAWpPBEAg +B0EAIAFBJ2oiCSAESRsNAQJAAkAgAkEJTwRAIAIgAxBIIggNAUEADAkLIANBzP97Sw0BQRAgA0EL +akF4cSADQQtJGyEBAkAgB0UEQCABQYACSSAEIAFBBHJJciAEIAFrQYGACE9yDQEMCQsgAEEIayIC +IARqIQcCQAJAAkACQCABIARLBEAgB0HUhsEAKAIARg0EIAdB0IbBACgCAEYNAiAHKAIEIgZBAnEN +BSAGQXhxIgYgBGoiBCABSQ0FIAcgBhBNIAQgAWsiA0EQSQ0BIAUgASAFKAIAQQFxckECcjYCACAB +IAJqIgEgA0EDcjYCBCACIARqIgIgAigCBEEBcjYCBCABIAMQRAwNCyAEIAFrIgNBD0sNAgwMCyAF +IAQgBSgCAEEBcXJBAnI2AgAgAiAEaiIBIAEoAgRBAXI2AgQMCwtByIbBACgCACAEaiIEIAFJDQIC +QCAEIAFrIgNBD00EQCAFIAZBAXEgBHJBAnI2AgAgAiAEaiIBIAEoAgRBAXI2AgRBACEDQQAhAQwB +CyAFIAEgBkEBcXJBAnI2AgAgASACaiIBIANBAXI2AgQgAiAEaiICIAM2AgAgAiACKAIEQX5xNgIE +C0HQhsEAIAE2AgBByIbBACADNgIADAoLIAUgASAGQQFxckECcjYCACABIAJqIgEgA0EDcjYCBCAH +IAcoAgRBAXI2AgQgASADEEQMCQtBzIbBACgCACAEaiIEIAFLDQcLIAMQKSIBRQ0BIANBfEF4IAUo +AgAiAkEDcRsgAkF4cWoiAiACIANLGyICBEAgASAAIAL8CgAACyAAEDkgAQwICyADIAEgASADSxsi +AgRAIAggACAC/AoAAAsgBSgCACICQXhxIgMgAUEEQQggAkEDcSICG2pJDQMgAkEAIAMgCUsbDQQg +ABA5CyAIDAYLQenGwABBLkGYx8AAEJcBAAtBqMfAAEEuQdjHwAAQlwEAC0HpxsAAQS5BmMfAABCX +AQALQajHwABBLkHYx8AAEJcBAAsgBSABIAZBAXFyQQJyNgIAIAEgAmoiAiAEIAFrIgFBAXI2AgRB +zIbBACABNgIAQdSGwQAgAjYCACAADAELIAALCxkAIAEoAgBBzLnAAEEeIAEoAgQoAgwRAQALDgAg +AQRAIAAgARDRAQsLGQAgASgCAEGH6cAAQQ4gASgCBCgCDBEBAAsWACAAKAIAIAEgAiAAKAIEKAIM +EQEACxQAIAAoAgAgASAAKAIEKAIMEQAAC4MIAQR/IwBB8ABrIgUkACAFIAM2AgwgBSACNgIIAn8g +AUGBAk8EQAJ/QYACIAAsAIACQb9/Sg0AGkH/ASAALAD/AUG/f0oNABpB/gFB/QEgACwA/gFBv39K +GwsiBiAAaiwAAEG/f0oEQEHf7sAAIQdBBQwCCyAAIAFBACAGIAQQwwEAC0EBIQcgASEGQQALIQgg +BSAGNgIUIAUgADYCECAFIAg2AhwgBSAHNgIYAkACQAJAAkAgASACSSIGIAEgA0lyRQRAIAIgA0sN +ASACRSABIAJNckUEQCAFQQxqIAVBCGogACACaiwAAEG/f0obKAIAIQMLIAUgAzYCICADIAEiAkkE +QCADQQFqIgIgA0EDayIGQQAgAyAGTxsiBkkNAwJ/IAIgBmsiB0EBayAAIANqLAAAQb9/Sg0AGiAH +QQJrIAAgAmoiAkECaywAAEG/f0oNABogB0EDayACQQNrLAAAQb9/Sg0AGiAHQXxBeyACQQRrLAAA +Qb9/ShtqCyAGaiECCwJAIAJFDQAgASACTQRAIAEgAkYNAQwFCyAAIAJqLAAAQb9/TA0ECwJ/AkAC +QCABIAJGDQACQAJAIAAgAmoiASwAACIAQQBIBEAgAS0AAUE/cSEGIABBH3EhAyAAQV9LDQEgA0EG +dCAGciEADAILIAUgAEH/AXE2AiRBAQwECyABLQACQT9xIAZBBnRyIQYgAEFwSQRAIAYgA0EMdHIh +AAwBCyADQRJ0QYCA8ABxIAEtAANBP3EgBkEGdHJyIgBBgIDEAEYNAQsgBSAANgIkIABBgAFPDQFB +AQwCCyAEENkBAAtBAiAAQYAQSQ0AGkEDQQQgAEGAgARJGwshACAFIAI2AiggBSAAIAJqNgIsIAVB +BTYCNCAFQejvwAA2AjAgBUIFNwI8IAUgBUEYaq1CgICAgJAMhDcDaCAFIAVBEGqtQoCAgICQDIQ3 +A2AgBSAFQShqrUKAgICAsAyENwNYIAUgBUEkaq1CgICAgMAMhDcDUCAFIAVBIGqtQoCAgICQCYQ3 +A0gMBAsgBSACIAMgBhs2AiggBUEDNgI0IAVBqPDAADYCMCAFQgM3AjwgBSAFQRhqrUKAgICAkAyE +NwNYIAUgBUEQaq1CgICAgJAMhDcDUCAFIAVBKGqtQoCAgICQCYQ3A0gMAwsgBUEENgI0IAVBiO/A +ADYCMCAFQgQ3AjwgBSAFQRhqrUKAgICAkAyENwNgIAUgBUEQaq1CgICAgJAMhDcDWCAFIAVBDGqt +QoCAgICQCYQ3A1AgBSAFQQhqrUKAgICAkAmENwNIDAILIAYgAkHA8MAAENcBAAsgACABIAIgASAE +EMMBAAsgBSAFQcgAajYCOCAFQTBqIAQQowEACxEAIAAoAgAgACgCBCABEO4BCxkAAn8gAUEJTwRA +IAEgABBIDAELIAAQKQsLDwAgACABKAIAIAIgAxBbCw8AIAAgASgCACACIAMQQwsRACAAKAIEIAAo +AgggARDuAQvgBgEPfyAAKAIAIQcgACgCBCEFQQAhACMAQRBrIgYkAEEBIQwCQCABKAIAIgpBIiAB +KAIEIg0oAhAiDhEAAA0AAkAgBUUEQAwBC0EAIAVrIQ8gByEBIAUhAAJAAn8CQANAIAAgAWohEEEA +IQMCQANAIAEgA2oiBC0AACIJQf8Aa0H/AXFBoQFJIAlBIkZyIAlB3ABGcg0BIAAgA0EBaiIDRw0A +CyAAIAhqDAMLIARBAWohAQJAIAQsAAAiAEEATgRAIABB/wFxIQAMAQsgAS0AAEE/cSELIABBH3Eh +CSAEQQJqIQEgAEFfTQRAIAlBBnQgC3IhAAwBCyABLQAAQT9xIAtBBnRyIQsgBEEDaiEBIABBcEkE +QCALIAlBDHRyIQAMAQsgCUESdEGAgPAAcSABLQAAQT9xIAtBBnRyciEAIARBBGohAQsgBkEEaiAA +QYGABBA1AkACQCAGLQAEQYABRg0AIAYtAA8gBi0ADmtB/wFxQQFGDQACQAJAIAIgAyAIaiIESw0A +AkAgAkUNACACIAVPBEAgAiAFRw0CDAELIAIgB2osAABBv39MDQELAkAgBEUNACAEIAVPBEAgBCAP +akUNAQwCCyAHIAhqIANqLAAAQUBIDQELIAogAiAHaiAIIAJrIANqIA0oAgwiAhEBAEUNAQwDCyAH +IAUgAiAEQaTuwAAQwwEACwJAIAYtAARBgAFGBEAgCiAGKAIIIA4RAAANAwwBCyAKIAYtAA4iBCAG +QQRqaiAGLQAPIARrIAIRAQANAgsCf0EBIABBgAFJDQAaQQIgAEGAEEkNABpBA0EEIABBgIAESRsL +IAhqIANqIQILAn9BASAAQYABSQ0AGkECIABBgBBJDQAaQQNBBCAAQYCABEkbCyAIaiIEIANqIQgg +ECABayIARQ0CDAELCwwECyADIARqCyIDIAJJDQBBACEAAkAgAkUNACACIAVPBEAgAiIAIAVHDQIM +AQsgAiIAIAdqLAAAQb9/TA0BCyADRQRAQQAhAwwCCyADIAVPBEAgAyAFRg0CIAAhAgwBCyADIAdq +LAAAQb9/Sg0BIAAhAgsgByAFIAIgA0G07sAAEMMBAAsgCiAAIAdqIAMgAGsgDSgCDBEBAA0AIApB +IiAOEQAAIQwLIAZBEGokACAMCxYAQZCDwQAgADYCAEGMg8EAQQE2AgALIgAgAELtuq22zYXU9eMA +NwMIIABC+IKZvZXuxsW5fzcDAAshACAAQoC834WrpfibJzcDCCAAQp/1lpTW7u3DoX83AwALEwAg +AEHUyMAANgIEIAAgATYCAAsRACABIAAoAgAgACgCBBDBAQsQACABIAAoAgAgACgCBBA6CxAAIAEo +AgAgASgCBCAAEDwLYQECfwJAAkAgAEEEaygCACICQXhxIgNBBEEIIAJBA3EiAhsgAWpPBEAgAkEA +IAMgAUEnaksbDQEgABA5DAILQenGwABBLkGYx8AAEJcBAAtBqMfAAEEuQdjHwAAQlwEACwsdAQFv +IAAoAgAlASABJQEgARBtIAIlASACEG0QDgsXAQFvIAAoAgAlASABIAIlASACEG0QGwsNACAAKAIA +KAIIQQFGC2sBAX8jAEEwayIDJAAgAyABNgIEIAMgADYCACADQQI2AgwgA0Go/8AANgIIIANCAjcC +FCADIANBBGqtQoCAgICQCYQ3AyggAyADrUKAgICAkAmENwMgIAMgA0EgajYCECADQQhqIAIQowEA +C2sBAX8jAEEwayIDJAAgAyABNgIEIAMgADYCACADQQI2AgwgA0HI/8AANgIIIANCAjcCFCADIANB +BGqtQoCAgICQCYQ3AyggAyADrUKAgICAkAmENwMgIAMgA0EgajYCECADQQhqIAIQowEAC2sBAX8j +AEEwayIDJAAgAyABNgIEIAMgADYCACADQQI2AgwgA0H8/8AANgIIIANCAjcCFCADIANBBGqtQoCA +gICQCYQ3AyggAyADrUKAgICAkAmENwMgIAMgA0EgajYCECADQQhqIAIQowEACwsAIAAoAgAgARBM +Cw8AQbDpwABBKyAAEJcBAAsNACAAKQMAQQEgARBJCw4AIAFBgIPAAEEFEMEBCw4AIAFB1ITAAEEQ +EMEBCw4AIAFB7IjAAEEKEMEBCwwAIAAoAgAgARDYAQuKAwEBfyAAKAIAIQIjAEHQAWsiACQAIAAg +AkEYaq1CgICAgJAHhDcDaCAAIAJBEGqtQoCAgICQB4Q3A2AgACACQQhqrUKAgICAkAeENwNYIAAg +Aq1CgICAgJAHhDcDUCAAQey5wAA2AjggAEEENgI8IABBBDYCTCAAQoOAgICAhICAaTcCyAEgAEGA +gMAANgLAASAAQQI7AbgBIABCgoCAgICEgIBpNwKwASAAQYCAwAA2AqgBIABBAjsBoAEgAEKBgICA +gISAgGk3ApgBIABBgIDAADYCkAEgAEECOwGIASAAQoCAgICAhICAaTcCgAEgAEKAgMAANwJ4IABB +AjsBcCAAIABB8ABqNgJIIABBBDYCRCAAIABB0ABqNgJAIABBLGoiAiAAQThqEEcgACACrUKAgICA +oAeENwMgIABBATYCDCAAQfy6wAA2AgggAEIBNwIUIAAgAEEgajYCECABKAIAIAEoAgQgAEEIahA8 +IAAoAiwiAgRAIAAoAjAgAhDRAQsgAEHQAWokAAsLACAAKAIAIAEQcwsNACAAQdyPwAAgARA8Cw4A +IAFB1I7AAEEFEMEBCw4AIAFBurTAAEELEMEBCw0AIABBrL7AACABEDwLDQBB6MPAAEEbEOcBAAsO +AEGDxMAAQc8AEOcBAAsJACAAIAEQJQALDQAgAEGoxsAAIAEQPAsMACAAIAEpAgA3AwALDQAgAEGE +ysAAIAEQPAsOACABQfzJwABBBRDBAQsaACAAIAFBlIPBACgCACIAQcoAIAAbEQIAAAsNACAAQdTr +wAAgARA8CwoAIAIgACABEDoLCgAgACABJQEQAgsOACABQcS+wABBCBDBAQsOACABQc7AwABBAxDB +AQsJACAAQQA2AgALCAAgACUBEAMLCAAgACUBEBILCAAgACUBECILBABBAAsCAAsL9oEBDgBBgIDA +AAuxAS9ob21lL2NveW90dGU1MDgvY29kZS9odWdnaW5nZmFjZS5qcy9wYWNrYWdlcy9odWIveGV0 +LWNvcmUtd2FzbS1idWlsZC9tZXJrbGVoYXNoL3NyYy9hZ2dyZWdhdGVkX2hhc2hlcy5ycwAAAAAA +EABpAAAAWQAAADgAAAAAABAAaQAAAFkAAAAPAAAAAAAQAGkAAABWAAAAOQAAAAUAAAAMAAAABAAA +AAYAAAAHAAAACABBvIHAAAutBQEAAAAJAAAAYSBEaXNwbGF5IGltcGxlbWVudGF0aW9uIHJldHVy +bmVkIGFuIGVycm9yIHVuZXhwZWN0ZWRseS9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29sY2hh +aW5zL3N0YWJsZS14ODZfNjQtdW5rbm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIvc3JjL3J1c3Qv +bGlicmFyeS9hbGxvYy9zcmMvc3RyaW5nLnJzAPsAEAB0AAAA0QoAAA4AAABFcnJvcgAAAPsAEAB0 +AAAAfQUAABsAAAAAAAAABAAAAAQAAAAKAAAAT2tFcnIvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAv +dG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3Ny +Yy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3NsaWNlLnJzrQEQAHMAAAC+AQAAHQAAAAEAAAAAAAAA +aGFzaGxlbmd0aAAAOAIQAAQAAAA8AhAABgAAAHN0cnVjdCBKc0NodW5rSW5Kc0NodW5rT3V0ZGVk +dXBhdHRlbXB0ZWQgdG8gdGFrZSBvd25lcnNoaXAgb2YgUnVzdCB2YWx1ZSB3aGlsZSBpdCB3YXMg +Ym9ycm93ZWRzcmMvbGliLnJzsgIQAAoAAAA9AAAAOAAAALICEAAKAAAAQQAAACEAAAAvaG9tZS9j b3lvdHRlNTA4Ly5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1 -YjU1N2Yvc2VyZGUtd2FzbS1iaW5kZ2VuLTAuNi41L3NyYy9saWIucnMAAACMCRAAaQAAADUAAAAO -AAAA//////////8IChAAQaCUwAALgSIBAAAAL2hvbWUvY295b3R0ZTUwOC9jb2RlL2h1Z2dpbmdm -YWNlLmpzL3BhY2thZ2VzL2h1Yi94ZXQtY29yZS13YXNtLWJ1aWxkL2RlZHVwbGljYXRpb24vc3Jj -L2NodW5raW5nLnJzACQKEABjAAAAHgAAAAkAAABhc3NlcnRpb24gZmFpbGVkOiB0YXJnZXRfY2h1 -bmtfc2l6ZSA+IDY0JAoQAGMAAAAiAAAACQAAACQKEABjAAAALgAAAB0AAABhc3NlcnRpb24gZmFp -bGVkOiBtYXhpbXVtX2NodW5rID4gbWluaW11bV9jaHVuawAkChAAYwAAADEAAAAJAAAAJAoQAGMA -AAA7AAAAFwAAACQKEABjAAAAZQAAADsAAAAkChAAYwAAAIcAAAAyAAAAJAoQAGMAAACJAAAAOgAA -ACQKEABjAAAAsQAAABUAAAAkChAAYwAAAK4AAABAAAAAL2hvbWUvY295b3R0ZTUwOC8uY2FyZ28v -cmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2xhenlfc3RhdGlj -LTEuNS4wL3NyYy9pbmxpbmVfbGF6eS5ycwAAgAsQAGoAAAAeAAAAEAAAAC9ob21lL2NveW90dGU1 -MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS14ODZfNjQtdW5rbm93bi1saW51eC1nbnUvbGli -L3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvcmF3X3ZlYy9tb2QucnMAAAD8CxAA -eQAAAC4CAAARAAAAT25jZSBpbnN0YW5jZSBoYXMgcHJldmlvdXNseSBiZWVuIHBvaXNvbmVkAACI -DBAAKgAAAG9uZS10aW1lIGluaXRpYWxpemF0aW9uIG1heSBub3QgYmUgcGVyZm9ybWVkIHJlY3Vy -c2l2ZWx5vAwQADgAAAAvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUt -eDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvc3Rk -L3NyYy9zeW5jL3BvaXNvbi9vbmNlLnJz/AwQAHwAAACbAAAAMgAAAFn1QOip04iw1iDtOffHUlar -comJaYmyRXfHjrbViQprtzF6iz5XjzZL2Tbp3DbGHbbVVFVOTHogy5ojKEazdKQSuaMcPqgGO/e6 -Ai9sjeeQipoNFfctyeGt04YQOgWVjiIHOrjx9C5arn+An5SsD6WB1tiA6wNzDg+tcBXcfrCZdjD9 -VbUvnWhopJ4RglAAACjMj6gGg7DE/Uo39opnsD42dK2Gq4ef8TbHa76/nxLy7aSYXFdJEUjFe0eV -BgEAAMzqnBqAN7ofbZukY9Zv8DtLh+OCl35omePYUKpzBqF5IPQRYp7PrORxkFeHH+cgJZuKGnj9 -09Urc8gR3c1N3gAvOYdaHDGp6v9AvBe2jnTbb78g9o2aV6+xwgkb2uWmhi6hIsMKwy/MZ0L3wf4q -XjV7pCHA9MiZLcPPBJRKS966aX1wHXIYtfcgLPN7WLaGMgwnr4aItgAAeZCK2+TWFaGZ4bKXnH5P -SAHjE1e3e8rMYPGwK6aEJb/IvF1iE+jnrVqVhw2UcAAAb2KeEwiR5oqiON4v12p3vc/A/MIfAGv7 -J8R75rh0pMdYXesQFvH2utFw521bH8sJR0x9l+YZsrBKraduOLzMAAE/l98KnYTMcPdqAX3vo3P+ -vb2G09IHyDAXeWyWySp/2gTFxmuoN9CdYKoeZnzx84fmqk2wJqasB1tKTzeZWnXerixb5n6DkIUH -Vv2Trehu2O1TEOHZAADX2xzSsjsGnrLSASrxd6sHRBtk5lUCVezGFJxEqJT7ePX1wMYbDlHH48rk -NgsyAAAtGossJjN8gkRB6kgLX2cU6+yNSabTeyZeA/WC+W+R8Yj7NPR/GyKG2ElvOOfOvp1Kjw/I -yvhY6thk/JKGGY0ANpq/uk9wOG1MvufRB8sy4JAIRa32IY0ipYklwL+xXGNxzqKcc6EgRlj75arj -3+en6w08K5PKEAx77a+E6P4nJx+r4vltHN+iI/V0B6zRzU1O4jOt/3AAABZ4l8V76KyiSWAotFon -kphZifHdgRGGwhk+SEKgcpm7eDBRZjfNcO9kmPyrEwUAAINAyVgYtljA3uAll4VQ6AmUfT74O/uX -kc5LthJtYh5+0Vd7f1BUDFIWJOJ0cXnhvodV6SIyrNlvPr/fmnyVIwAVvksjfn0coLuMo7hYx6Kr -MCs+7M6gHw2RuWB+i6W2CzVmop9b3TNDo8EBQH07/cInEXNUJIBB+8sYDaWFYaVlT7WEh70CevZj -UOZn3RFvaasUqPwiIAAAUti5LZG+1oxXiq7ptolRaSgM2gq1U5TuXoR4Gqle/Nhnp0oaGb+Gq+UV -ZMi1xgAALqIIjhcQcyYlyosHGxAt7fuoJrKE7UE7BtwoDxIi5hMmbXD76/UVo866ATNOwxaIrv1x -u5xbOelIFnIuIOksABzJsysd24NCpaax0hpGfddrhutu5Bfs4nzE+zlAvuC4BJ0p1cRgod40NozS -yIbsfpmjmJ8SrRkh74OiYWv0zKYXxlj23s5SLIPdrGkRh7Qt6cue89bwAACJlC+NydjVPYT1ASui -chiK8jx7DsSkgvKWoRvLLOwggBPjWZ7gtpNm64N8zBnOAAA7nEf2NVfLIFta11k3vy52dTlpPYL+ -eyDV2ZwzEsF91wN9YoRCg6eb6VFf6RPFfSEWeF78KRp7si1muzGYzdUATHN1bYCb43EjGvsG8CpX -foUf6WovT3Oi8t0sArXGgr/eoGEHxuo7XJhpQUe7k8jNAX4YXGGFEG1dfCesMK74d5EsKhKBa3yR -Z2nRrZm2dVubBprnas8AAAQR3mD6CsTzw2eRpXoSYyBNidFpIuYdYiZHK+YdrIjRPGdLFeI2cBAd -OlUoX7gAAD1vIxhMTu/yAva5EWbe1tkckUf7VXn8ob2NKS8D/YXr4fq+sy9QJ74eZs3EUUID4zYY -B1TTZBNEPpjydWyzggDwZvoWA5FFsffKR5icBhwCIVJLWsffECm1qFccPjVbc2zZjuksMUTOZfq9 -BkUulLwblFcSp4ZQ8K3OUdMVssP+AkIU4FUQrgBU5EJvhEBL9ci8vMjZfwAA/pveF/Oevb8SToXy -LzAEqNTY5aVXSc45hLo3VqTiuf+LgaCeHa25VYoXGfPLigAAOPv70Mi/4kjotUjoQZjji4uglgYW -EicOKiRES+iWENU64ZJnF7oBEZ1oMUUPdy7CbMW7cvLviRbsUFZ/GSqpAE54ob2QWXa8rrj8kuNB -FMag5DHtLDrhB02dTiOE6cuSxYp9u3L1T4/QO5YLwHCWCwHrAxpYWpViVAIA6uWDX2SZ8ojNFuX8 -Qc+YetpIl9q7+kVI/rKqAABVZfWbBht2GVattkODXo+L2SFIFP0cXT6PzbCiLB5c7H+1+6f+4Pf6 -G5YSutMAAACOsQGEF5A/2utfOuNtkP9w53BpwKfVJwXpE3xgc+fYIqw7PGTfcKvJ4xK+itzGpO2K -5zMAQR/v7MtyrHSywiQAtACpT5UNdAYEYz0ymyl6HdXqy5iyfMOzm3N4YcfjhsmK9UZLNuqrn1bM -ha/FFKJthI+jt9g+pBfr25odUezMbvtaMxMJs8r50u4V9MVgXkq0cjZQZ2kAAIe7VBQSHaWdFsi7 -uRMeMoSN3S+rtm89+40KFo7tXjBg6GyU6RRLv8vDEBs4Y08AABBOzG+Bt9UHVYFqanI2peXdf6BH -NLKvV5TTyav3RvMYPdMa1lXGbWP28/c5SauLzHsY3cEGqcdjL2hvbWUvY295b3R0ZTUwOC8ucnVz -dHVwL3Rvb2xjaGFpbnMvc3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9saWIvcnVzdGxp -Yi9zcmMvcnVzdC9saWJyYXJ5L2FsbG9jL3NyYy9zbGljZS5ycwCIFRAAcwAAAL4BAAAdAAAAT25j -ZSBpbnN0YW5jZSBoYXMgcHJldmlvdXNseSBiZWVuIHBvaXNvbmVkAAAMFhAAKgAAAG9uZS10aW1l -IGluaXRpYWxpemF0aW9uIG1heSBub3QgYmUgcGVyZm9ybWVkIHJlY3Vyc2l2ZWx5QBYQADgAAAAv -aG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24t -bGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvc3RkL3NyYy9zeW5jL3BvaXNv -bi9vbmNlLnJzgBYQAHwAAACbAAAAMgAAAC9ob21lL2NveW90dGU1MDgvLmNhcmdvL3JlZ2lzdHJ5 -L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9sYXp5X3N0YXRpYy0xLjUuMC9z -cmMvaW5saW5lX2xhenkucnMAAAwXEABqAAAAHgAAABAAAAAvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0 -dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGli -L3NyYy9ydXN0L2xpYnJhcnkvY29yZS9zcmMvaXRlci90cmFpdHMvaXRlcmF0b3IucnMAAACIFxAA -gQAAAMEHAAAJAAAAfxhX1s5W7WYSf/kT56XD86TNJtW120nmQSSYfyj7lMMvaG9tZS9jb3lvdHRl -NTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xp -Yi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3Jhd192ZWMvbW9kLnJzAAAAPBgQ -AHkAAAAuAgAAEQAAAAAAAAAEAAAABAAAABcAAAAvaG9tZS9jb3lvdHRlNTA4Ly5jYXJnby9yZWdp -c3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvanMtc3lzLTAuMy43Ny9z -cmMvbGliLnJzAADYGBAAXgAAAPsYAAABAAAAL2hvbWUvY295b3R0ZTUwOC8uY2FyZ28vcmVnaXN0 -cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3dhc20tYmluZGdlbi0wLjIu -MTAwL3NyYy9jb252ZXJ0L3NsaWNlcy5yc0gZEABwAAAAJAEAAA4AAABjbG9zdXJlIGludm9rZWQg -cmVjdXJzaXZlbHkgb3IgYWZ0ZXIgYmVpbmcgZHJvcHBlZExheW91dEVycm9yL2hvbWUvY295b3R0 -ZTUwOC8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9s -aWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2FsbG9jL3NyYy9zbGljZS5ycwUaEABzAAAAvgEA -AB0AAAAkAAAAJQAAACYAAAAnAAAAKAAAAC9ob21lL2NveW90dGU1MDgvLmNhcmdvL3JlZ2lzdHJ5 -L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9ieXRlcy0xLjEwLjEvc3JjL2J5 -dGVzLnJzACkAAAAqAAAAKwAAACwAAAAtAAAALgAAAC8AAAAwAAAALAAAADEAQay2wAALpRQBAAAA -MgAAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAnBoQAF8AAABI -BQAAMgAAAJwaEABfAAAAVgUAAEkAAAAzAAAANAAAADUAAAA2AAAANwAAAC9ob21lL2NveW90dGU1 -MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS14ODZfNjQtdW5rbm93bi1saW51eC1nbnUvbGli -L3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvc2xpY2UucnMAlBsQAHMAAAC+AQAA -HQAAAC9ob21lL2NveW90dGU1MDgvY29kZS9odWdnaW5nZmFjZS5qcy9wYWNrYWdlcy9odWIveGV0 -LWNvcmUtd2FzbS1idWlsZC9tZXJrbGVoYXNoL3NyYy9kYXRhX2hhc2gucnMAAAAYHBAAYQAAAHoA -AAAJAAAASW52YWxpZCBoZXggaW5wdXQgZm9yIERhdGFIYXNoAAABAAAAAAAAAAEAAAAAAAAAAQAA -AAAAAAABAAAAAAAAABgcEABhAAAAsgAAACoAAAAYHBAAYQAAALMAAAAqAAAAGBwQAGEAAAC0AAAA -KgAAAGaX9XdblVDeMTXLrKWXGByd5CEQm+srWLTQsEuTrfIpAX7Fx6VHKZb9lGZmtIoC5l3dU283 -x23S+GNS5kpTcT8BAAAAAAAAAG1pZCA+IGxlbgAAAEQdEAAJAAAAL2hvbWUvY295b3R0ZTUwOC8u -Y2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2JsYWtl -My0xLjguMi9zcmMvbGliLnJzAAAAWB0QAF0AAAALAgAAEQAAAFgdEABdAAAAvgIAAAoAAABYHRAA -XQAAAOwCAAAoAAAAWB0QAF0AAADsAgAANAAAAFgdEABdAAAA7AIAAAwAAABYHRAAXQAAANwCAAAX -AAAAWB0QAF0AAAAYAwAAHwAAAFgdEABdAAAANQMAAAwAAABYHRAAXQAAADwDAAASAAAAWB0QAF0A -AABgAwAAIQAAAFgdEABdAAAAYgMAABEAAABYHRAAXQAAAGIDAABBAAAAaW5zdWZmaWNpZW50IGNh -cGFjaXR5AAAAeB4QABUAAABDYXBhY2l0eUVycm9yOiAAmB4QAA8AAABjYWxsZWQgYFJlc3VsdDo6 -dW53cmFwKClgIG9uIGFuIGBFcnJgIHZhbHVlAAAAAAAEAAAABAAAADsAAAAAAAAACAAAAAQAAABD -AAAARAAAAEUAAABhIHN0cmluZ2J5dGUgYXJyYXlib29sZWFuIGBgFh8QAAkAAAAfHxAAAQAAAGlu -dGVnZXIgYAAAADAfEAAJAAAAHx8QAAEAAABmbG9hdGluZyBwb2ludCBgTB8QABAAAAAfHxAAAQAA -AGNoYXJhY3RlciBgAGwfEAALAAAAHx8QAAEAAABzdHJpbmcgAIgfEAAHAAAAdW5pdCB2YWx1ZU9w -dGlvbiB2YWx1ZW5ld3R5cGUgc3RydWN0c2VxdWVuY2VtYXBlbnVtdW5pdCB2YXJpYW50bmV3dHlw -ZSB2YXJpYW50dHVwbGUgdmFyaWFudHN0cnVjdCB2YXJpYW50AAAAAQAAAAAAAAAuMHUzMkxhenkg -aW5zdGFuY2UgaGFzIHByZXZpb3VzbHkgYmVlbiBwb2lzb25lZAARIBAAKgAAAC9ob21lL2NveW90 -dGU1MDgvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3 -Zi9vbmNlX2NlbGwtMS4yMS4zL3NyYy9saWIucnMAAABEIBAAYQAAAAgDAAAZAAAAcmVlbnRyYW50 -IGluaXQAALggEAAOAAAARCAQAGEAAAB6AgAADQAAAC9ob21lL2NveW90dGU1MDgvLmNhcmdvL3Jl -Z2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi93YXNtLWJpbmRnZW4t -MC4yLjEwMC9zcmMvY29udmVydC9pbXBscy5ycwDgIBAAbwAAAGECAAAWAAAA4CAQAG8AAABxAgAA -DAAAAOAgEABvAAAAbQIAABAAAABhcnJheSBjb250YWlucyBhIHZhbHVlIG9mIHRoZSB3cm9uZyB0 -eXBlbnVsbCBwb2ludGVyIHBhc3NlZCB0byBydXN0cmVjdXJzaXZlIHVzZSBvZiBhbiBvYmplY3Qg -ZGV0ZWN0ZWQgd2hpY2ggd291bGQgbGVhZCB0byB1bnNhZmUgYWxpYXNpbmcgaW4gcnVzdEpzVmFs -dWUoKQASIhAACAAAABoiEAABAAAAL3J1c3RjLzE3MDY3ZTlhYzZkN2VjYjcwZTUwZjkyYzE5NDRl -NTQ1MTg4ZDIzNTkvbGlicmFyeS9hbGxvYy9zcmMvc3RyaW5nLnJzACwiEABLAAAAfQUAABsAAAAv -cnVzdGMvMTcwNjdlOWFjNmQ3ZWNiNzBlNTBmOTJjMTk0NGU1NDUxODhkMjM1OS9saWJyYXJ5L2Fs -bG9jL3NyYy9yYXdfdmVjL21vZC5yc4giEABQAAAALgIAABEAAABKAAAADAAAAAQAAABLAAAATAAA -AE0AAAAvcnVzdC9kZXBzL2RsbWFsbG9jLTAuMi43L3NyYy9kbG1hbGxvYy5yc2Fzc2VydGlvbiBm -YWlsZWQ6IHBzaXplID49IHNpemUgKyBtaW5fb3ZlcmhlYWQAACMQACkAAACoBAAACQAAAGFzc2Vy -dGlvbiBmYWlsZWQ6IHBzaXplIDw9IHNpemUgKyBtYXhfb3ZlcmhlYWQAAAAjEAApAAAArgQAAA0A -AABtZW1vcnkgYWxsb2NhdGlvbiBvZiAgYnl0ZXMgZmFpbGVkAACoIxAAFQAAAL0jEAANAAAAbGli -cmFyeS9zdGQvc3JjL2FsbG9jLnJz3CMQABgAAABkAQAACQAAAEoAAAAMAAAABAAAAE4AAAAAAAAA -CAAAAAQAAABPAAAAAAAAAAgAAAAEAAAAUAAAAFEAAABSAAAAUwAAAFQAAAAQAAAABAAAAFUAAABW -AAAAVwAAAFgAAABIYXNoIHRhYmxlIGNhcGFjaXR5IG92ZXJmbG93XCQQABwAAAAvcnVzdC9kZXBz -L2hhc2hicm93bi0wLjE1LjIvc3JjL3Jhdy9tb2QucnMAAIAkEAAqAAAAIwAAACgAAABFcnJvcgAA -AFkAAAAMAAAABAAAAFoAAABbAAAAXAAAAGNhcGFjaXR5IG92ZXJmbG93AAAA3CQQABEAAABsaWJy -YXJ5L2FsbG9jL3NyYy9yYXdfdmVjL21vZC5yc/gkEAAgAAAALgIAABEAAABsaWJyYXJ5L2FsbG9j -L3NyYy9zdHJpbmcucnMAKCUQABsAAADoAQAAFwBB3MrAAAvIEgEAAABdAAAAYSBmb3JtYXR0aW5n -IHRyYWl0IGltcGxlbWVudGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHdoZW4gdGhlIHVuZGVybHlp -bmcgc3RyZWFtIGRpZCBub3RsaWJyYXJ5L2FsbG9jL3NyYy9mbXQucnMAALolEAAYAAAAigIAAA4A -AAAoJRAAGwAAAH0FAAAbAAAAAHAABwAtAQEBAgECAQFICzAVEAFlBwIGAgIBBCMBHhtbCzoJCQEY -BAEJAQMBBSsDOwkqGAEgNwEBAQQIBAEDBwoCHQE6AQEBAgQIAQkBCgIaAQICOQEEAgQCAgMDAR4C -AwELAjkBBAUBAgQBFAIWBgEBOgEBAgEECAEHAwoCHgE7AQEBDAEJASgBAwE3AQEDBQMBBAcCCwId -AToBAgIBAQMDAQQHAgsCHAI5AgEBAgQIAQkBCgIdAUgBBAECAwEBCAFRAQIHDAhiAQIJCwdJAhsB -AQEBATcOAQUBAgULASQJAWYEAQYBAgICGQIEAxAEDQECAgYBDwEAAwAEHAMdAh4CQAIBBwgBAgsJ -AS0DAQF1AiIBdgMEAgkBBgPbAgIBOgEBBwEBAQECCAYKAgEwHzEEMAoEAyYJDAIgBAIGOAEBAgMB -AQU4CAICmAMBDQEHBAEGAQMCxkAAAcMhAAONAWAgAAZpAgAEAQogAlACAAEDAQQBGQIFAZcCGhIN -ASYIGQsBASwDMAECBAICAgEkAUMGAgICAgwBCAEvATMBAQMCAgUCAQEqAggB7gECAQQBAAEAEBAQ -AAIAAeIBlQUAAwECBQQoAwQBpQIABEEFAAJPBEYLMQR7ATYPKQECAgoDMQQCAgcBPQMkBQEIPgEM -AjQJAQEIBAIBXwMCBAYBAgGdAQMIFQI5AgEBAQEMAQkBDgcDBUMBAgYBAQIBAQMEAwEBDgJVCAID -AQEXAVEBAgYBAQIBAQIBAusBAgQGAgECGwJVCAIBAQJqAQEBAghlAQEBAgQBBQAJAQL1AQoEBAGQ -BAICBAEgCigGAgQIAQkGAgMuDQECAAcBBgEBUhYCBwECAQJ6BgMBAQIBBwEBSAIDAQEBAAILAjQF -BQMXAQABBg8ADAMDAAU7BwABPwRRAQsCAAIALgIXAAUDBggIAgceBJQDADcEMggBDgEWBQEPAAcB -EQIHAQIBBWQBoAcAAT0EAAT+AgAHbQcAYIDwAGFzc2VydGlvbiBmYWlsZWQ6IGVkZWx0YSA+PSAw -bGlicmFyeS9jb3JlL3NyYy9udW0vZGl5X2Zsb2F0LnJzAAAAACkQACEAAABMAAAACQAAAAApEAAh -AAAATgAAAAkAAADBb/KGIwAAAIHvrIVbQW0t7gQAAAEfar9k7Thu7Zen2vT5P+kDTxgAAT6VLgmZ -3wP9OBUPL+R0I+z1z9MI3ATE2rDNvBl/M6YDJh/pTgIAAAF8Lphbh9O+cp/Z2IcvFRLGUN5rcG5K -zw/YldVucbImsGbGrSQ2FR1a00I8DlT/Y8BzVcwX7/ll8ii8VffH3IDc7W70zu/cX/dTBQBsaWJy -YXJ5L2NvcmUvc3JjL251bS9mbHQyZGVjL3N0cmF0ZWd5L2RyYWdvbi5yc2Fzc2VydGlvbiBmYWls -ZWQ6IGQubWFudCA+IDAA4CkQAC8AAAB2AAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGQubWludXMg -PiAwAAAA4CkQAC8AAAB3AAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGQucGx1cyA+IDDgKRAALwAA -AHgAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogYnVmLmxlbigpID49IE1BWF9TSUdfRElHSVRTAAAA -4CkQAC8AAAB7AAAABQAAAOApEAAvAAAAwgAAAAkAAADgKRAALwAAAPsAAAANAAAA4CkQAC8AAAAC -AQAAEgAAAGFzc2VydGlvbiBmYWlsZWQ6IGQubWFudC5jaGVja2VkX3N1YihkLm1pbnVzKS5pc19z -b21lKCkA4CkQAC8AAAB6AAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGQubWFudC5jaGVja2VkX2Fk -ZChkLnBsdXMpLmlzX3NvbWUoKQAA4CkQAC8AAAB5AAAABQAAAOApEAAvAAAACwEAAAUAAADgKRAA -LwAAAAwBAAAFAAAA4CkQAC8AAAANAQAABQAAAOApEAAvAAAAcgEAACQAAADgKRAALwAAAHcBAAAv -AAAA4CkQAC8AAACEAQAAEgAAAOApEAAvAAAAZgEAAA0AAADgKRAALwAAAEwBAAAiAAAA4CkQAC8A -AAAPAQAABQAAAOApEAAvAAAADgEAAAUAAADfRRo9A88a5sH7zP4AAAAAysaaxxf+cKvc+9T+AAAA -AE/cvL78sXf/9vvc/gAAAAAM1mtB75FWvhH85P4AAAAAPPx/kK0f0I0s/Oz+AAAAAIOaVTEoXFHT -Rvz0/gAAAAC1yaatj6xxnWH8/P4AAAAAy4vuI3cinOp7/AT/AAAAAG1TeECRScyulvwM/wAAAABX -zrZdeRI8grH8FP8AAAAAN1b7TTaUEMLL/Bz/AAAAAE+YSDhv6paQ5vwk/wAAAADHOoIly4V01wD9 -LP8AAAAA9Je/l83PhqAb/TT/AAAAAOWsKheYCjTvNf08/wAAAACOsjUq+2c4slD9RP8AAAAAOz/G -0t/UyIRr/Uz/AAAAALrN0xonRN3Fhf1U/wAAAACWySW7zp9rk6D9XP8AAAAAhKVifSRsrNu6/WT/ -AAAAAPbaXw1YZquj1f1s/wAAAAAm8cPek/ji8+/9dP8AAAAAuID/qqittbUK/nz/AAAAAItKfGwF -X2KHJf6E/wAAAABTMME0YP+8yT/+jP8AAAAAVSa6kYyFTpZa/pT/AAAAAL1+KXAkd/nfdP6c/wAA -AACPuOW4n73fpo/+pP8AAAAAlH10iM9fqfip/qz/AAAAAM+bqI+TcES5xP60/wAAAABrFQ+/+PAI -it/+vP8AAAAAtjExZVUlsM35/sT/AAAAAKx/e9DG4j+ZFP/M/wAAAAAGOysqxBBc5C7/1P8AAAAA -05JzaZkkJKpJ/9z/AAAAAA7KAIPytYf9Y//k/wAAAADrGhGSZAjlvH7/7P8AAAAAzIhQbwnMvIyZ -//T/AAAAACxlGeJYF7fRs//8/wBBrt3AAAsFQJzO/wQAQbzdwAALmSQQpdTo6P8MAAAAAAAAAGKs -xet4rQMAFAAAAAAAhAmU+Hg5P4EeABwAAAAAALMVB8l7zpfAOAAkAAAAAABwXOp7zjJ+j1MALAAA -AAAAaIDpq6Q40tVtADQAAAAAAEUimhcmJ0+fiAA8AAAAAAAn+8TUMaJj7aIARAAAAAAAqK3IjDhl -3rC9AEwAAAAAANtlqxqOCMeD2ABUAAAAAACaHXFC+R1dxPIAXAAAAAAAWOcbpixpTZINAWQAAAAA -AOqNcBpk7gHaJwFsAAAAAABKd++amaNtokIBdAAAAAAAhWt9tHt4CfJcAXwAAAAAAHcY3Xmh5FS0 -dwGEAAAAAADCxZtbkoZbhpIBjAAAAAAAPV2WyMVTNcisAZQAAAAAALOgl/pctCqVxwGcAAAAAADj -X6CZvZ9G3uEBpAAAAAAAJYw52zTCm6X8AawAAAAAAFyfmKNymsb2FgK0AAAAAADOvulUU7/ctzEC -vAAAAAAA4kEi8hfz/IhMAsQAAAAAAKV4XNObziDMZgLMAAAAAADfUyF781oWmIEC1AAAAAAAOjAf -l9y1oOKbAtwAAAAAAJaz41xT0dmotgLkAAAAAAA8RKek2Xyb+9AC7AAAAAAAEESkp0xMdrvrAvQA -AAAAABqcQLbvjquLBgP8AAAAAAAshFemEO8f0CADBAEAAAAAKTGR6eWkEJs7AwwBAAAAAJ0MnKH7 -mxDnVQMUAQAAAAAp9Dti2SAorHADHAEAAAAAhc+nel5LRICLAyQBAAAAAC3drANA5CG/pQMsAQAA -AACP/0ReL5xnjsADNAEAAAAAQbiMnJ0XM9TaAzwBAAAAAKkb47SS2xme9QNEAQAAAADZd9+6br+W -6w8ETAEAAAAAbGlicmFyeS9jb3JlL3NyYy9udW0vZmx0MmRlYy9zdHJhdGVneS9ncmlzdS5ycwAA -SDEQAC4AAAB9AAAAFQAAAEgxEAAuAAAAqQAAAAUAAABIMRAALgAAAKoAAAAFAAAASDEQAC4AAACr -AAAABQAAAEgxEAAuAAAArgAAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBkLm1hbnQgKyBkLnBsdXMg -PCAoMSA8PCA2MSkAAABIMRAALgAAAK8AAAAFAAAASDEQAC4AAAAKAQAAEQAAAEgxEAAuAAAADQEA -AAkAAABIMRAALgAAAEABAAAJAAAASDEQAC4AAACtAAAABQAAAEgxEAAuAAAArAAAAAUAAABhc3Nl -cnRpb24gZmFpbGVkOiAhYnVmLmlzX2VtcHR5KCkAAABIMRAALgAAANwBAAAFAAAAYXNzZXJ0aW9u -IGZhaWxlZDogZC5tYW50IDwgKDEgPDwgNjEpSDEQAC4AAADdAQAABQAAAEgxEAAuAAAA3gEAAAUA -AAABAAAACgAAAGQAAADoAwAAECcAAKCGAQBAQg8AgJaYAADh9QUAypo7SDEQAC4AAAAzAgAAEQAA -AEgxEAAuAAAANgIAAAkAAABIMRAALgAAAGwCAAAJAAAASDEQAC4AAADjAgAAJgAAAEgxEAAuAAAA -7wIAACYAAABIMRAALgAAAMwCAAAmAAAAbGlicmFyeS9jb3JlL3NyYy9udW0vZmx0MmRlYy9tb2Qu -cnMAWDMQACMAAAC7AAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGJ1ZlswXSA+IGInMCcAWDMQACMA -AAC8AAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IHBhcnRzLmxlbigpID49IDQAAFgzEAAjAAAAvQAA -AAUAAAAuMC4tK05hTmluZjBhc3NlcnRpb24gZmFpbGVkOiBidWYubGVuKCkgPj0gbWF4bGVuAAAA -WDMQACMAAAB+AgAADQAAACkuLjAxMjM0NTY3ODlhYmNkZWZCb3Jyb3dNdXRFcnJvcmFscmVhZHkg -Ym9ycm93ZWQ6IABVNBAAEgAAAGNhbGxlZCBgT3B0aW9uOjp1bndyYXAoKWAgb24gYSBgTm9uZWAg -dmFsdWVpbmRleCBvdXQgb2YgYm91bmRzOiB0aGUgbGVuIGlzICBidXQgdGhlIGluZGV4IGlzIAAA -AJs0EAAgAAAAuzQQABIAAAAAAAAABAAAAAQAAABkAAAAPT0hPW1hdGNoZXNhc3NlcnRpb24gYGxl -ZnQgIHJpZ2h0YCBmYWlsZWQKICBsZWZ0OiAKIHJpZ2h0OiAA+zQQABAAAAALNRAAFwAAACI1EAAJ -AAAAIHJpZ2h0YCBmYWlsZWQ6IAogIGxlZnQ6IAAAAPs0EAAQAAAARDUQABAAAABUNRAACQAAACI1 -EAAJAAAAOiAAAAEAAAAAAAAAgDUQAAIAAAAAAAAADAAAAAQAAABlAAAAZgAAAGcAAAAgICAgLAoo -KAosMHgwMDAxMDIwMzA0MDUwNjA3MDgwOTEwMTExMjEzMTQxNTE2MTcxODE5MjAyMTIyMjMyNDI1 -MjYyNzI4MjkzMDMxMzIzMzM0MzUzNjM3MzgzOTQwNDE0MjQzNDQ0NTQ2NDc0ODQ5NTA1MTUyNTM1 -NDU1NTY1NzU4NTk2MDYxNjI2MzY0NjU2NjY3Njg2OTcwNzE3MjczNzQ3NTc2Nzc3ODc5ODA4MTgy -ODM4NDg1ODY4Nzg4ODk5MDkxOTI5Mzk0OTU5Njk3OTg5OTAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw -MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDBsaWJyYXJ5L2NvcmUvc3Jj -L2ZtdC9tb2QucnNmYWxzZXRydWXANhAAGwAAANgKAAAmAAAAwDYQABsAAADhCgAAGgAAAGxpYnJh -cnkvY29yZS9zcmMvc3RyL21vZC5yc1suLi5dYmVnaW4gPD0gZW5kICggPD0gKSB3aGVuIHNsaWNp -bmcgYGAAJDcQAA4AAAAyNxAABAAAADY3EAAQAAAARjcQAAEAAABieXRlIGluZGV4ICBpcyBub3Qg -YSBjaGFyIGJvdW5kYXJ5OyBpdCBpcyBpbnNpZGUgIChieXRlcyApIG9mIGAAaDcQAAsAAABzNxAA -JgAAAJk3EAAIAAAAoTcQAAYAAABGNxAAAQAAACBpcyBvdXQgb2YgYm91bmRzIG9mIGAAAGg3EAAL -AAAA0DcQABYAAABGNxAAAQAAAAQ3EAAbAAAAnAEAACwAAABsaWJyYXJ5L2NvcmUvc3JjL3VuaWNv -ZGUvcHJpbnRhYmxlLnJzAAAAEDgQACUAAAAaAAAANgAAABA4EAAlAAAACgAAACsAAAAABgEBAwEE -AgUHBwIICAkCCgULAg4EEAERAhIFExwUARUCFwIZDRwFHQgfASQBagRrAq8DsQK8As8C0QLUDNUJ -1gLXAtoB4AXhAucE6ALuIPAE+AL6BPsBDCc7Pk5Pj56en3uLk5aisrqGsQYHCTY9Plbz0NEEFBg2 -N1ZXf6qur7014BKHiY6eBA0OERIpMTQ6RUZJSk5PZGWKjI2PtsHDxMbL1ly2txscBwgKCxQXNjk6 -qKnY2Qk3kJGoBwo7PmZpj5IRb1+/7u9aYvT8/1NUmpsuLycoVZ2goaOkp6iturzEBgsMFR06P0VR -pqfMzaAHGRoiJT4/5+zv/8XGBCAjJSYoMzg6SEpMUFNVVlhaXF5gY2Vma3N4fX+KpKqvsMDQrq9u -b93ek14iewUDBC0DZgMBLy6Agh0DMQ8cBCQJHgUrBUQEDiqAqgYkBCQEKAg0C04DNAyBNwkWCggY -O0U5A2MICTAWBSEDGwUBQDgESwUvBAoHCQdAICcEDAk2AzoFGgcEDAdQSTczDTMHLggKBiYDHQgC -gNBSEAM3LAgqFhomHBQXCU4EJAlEDRkHCgZICCcJdQtCPioGOwUKBlEGAQUQAwULWQgCHWIeSAgK -gKZeIkULCgYNEzoGCgYUHCwEF4C5PGRTDEgJCkZFG0gIUw1JBwqAtiIOCgZGCh0DR0k3Aw4ICgY5 -BwqBNhkHOwMdVQEPMg2Dm2Z1C4DEikxjDYQwEBYKj5sFgkeauTqGxoI5ByoEXAYmCkYKKAUTgbA6 -gMZbZUsEOQcRQAULAg6X+AiE1ikKoueBMw8BHQYOBAiBjIkEawUNAwkHEI9ggPoGgbRMRwl0PID2 -CnMIcBVGehQMFAxXCRmAh4FHA4VCDxWEUB8GBoDVKwU+IQFwLQMaBAKBQB8ROgUBgdAqgNYrBAGB -4ID3KUwECgQCgxFETD2AwjwGAQRVBRs0AoEOLARkDFYKgK44HQ0sBAkHAg4GgJqD2AQRAw0DdwRf -BgwEAQ8MBDgICgYoCCwEAj6BVAwdAwoFOAccBgkHgPqEBgABAwUFBgYCBwYIBwkRChwLGQwaDRAO -DA8EEAMSEhMJFgEXBBgBGQMaBxsBHAIfFiADKwMtCy4BMAQxAjIBpwSpAqoEqwj6AvsF/QL+A/8J -rXh5i42iMFdYi4yQHN0OD0tM+/wuLz9cXV/ihI2OkZKpsbq7xcbJyt7k5f8ABBESKTE0Nzo7PUlK -XYSOkqmxtLq7xsrOz+TlAAQNDhESKTE0OjtFRklKXmRlhJGbncnOzw0RKTo7RUlXW1xeX2RljZGp -tLq7xcnf5OXwDRFFSWRlgISyvL6/1dfw8YOFi6Smvr/Fx8/a20iYvc3Gzs9JTk9XWV5fiY6Psba3 -v8HGx9cRFhdbXPb3/v+AbXHe3w4fbm8cHV99fq6vTbu8FhceH0ZHTk9YWlxefn+1xdTV3PDx9XJz -j3R1liYuL6evt7/Hz9ffmgBAl5gwjx/Oz9LUzv9OT1pbBwgPECcv7u9ubzc9P0JFkJFTZ3XIydDR -2Nnn/v8AIF8igt8EgkQIGwQGEYGsDoCrBR8IgRwDGQgBBC8ENAQHAwEHBgcRClAPEgdVBwMEHAoJ -AwgDBwMCAwMDDAQFAwsGAQ4VBU4HGwdXBwIGFwxQBEMDLQMBBBEGDww6BB0lXyBtBGolgMgFgrAD -GgaC/QNZBxYJGAkUDBQMagYKBhoGWQcrBUYKLAQMBAEDMQssBBoGCwOArAYKBi8xgPQIPAMPAz4F -OAgrBYL/ERgILxEtAyEPIQ+AjASCmhYLFYiUBS8FOwcCDhgJgL4idAyA1hqBEAWA4QnyngM3CYFc -FIC4CIDdFTsDCgY4CEYIDAZ0Cx4DWgRZCYCDGBwKFglMBICKBqukDBcEMaEEgdomBwwFBYCmEIH1 -BwEgKgZMBICNBIC+AxsDDw1saWJyYXJ5L2NvcmUvc3JjL3VuaWNvZGUvdW5pY29kZV9kYXRhLnJz -AAAAAT4QACgAAABNAAAAKAAAAAE+EAAoAAAAWQAAABYAAABsaWJyYXJ5L2NvcmUvc3JjL251bS9i -aWdudW0ucnMAAEw+EAAeAAAAqwEAAAEAAABhc3NlcnRpb24gZmFpbGVkOiBub2JvcnJvd2Fzc2Vy -dGlvbiBmYWlsZWQ6IGRpZ2l0cyA8IDQwYXNzZXJ0aW9uIGZhaWxlZDogb3RoZXIgPiAwYXR0ZW1w -dCB0byBkaXZpZGUgYnkgemVybwDOPhAAGQAAAGF0dGVtcHQgdG8gY2FsY3VsYXRlIHRoZSByZW1h -aW5kZXIgd2l0aCBhIGRpdmlzb3Igb2YgemVybwAAAPA+EAA5AAAAcmFuZ2Ugc3RhcnQgaW5kZXgg -IG91dCBvZiByYW5nZSBmb3Igc2xpY2Ugb2YgbGVuZ3RoIDQ/EAASAAAARj8QACIAAAByYW5nZSBl -bmQgaW5kZXggeD8QABAAAABGPxAAIgAAAHNsaWNlIGluZGV4IHN0YXJ0cyBhdCAgYnV0IGVuZHMg -YXQgAJg/EAAWAAAArj8QAA0AAABjb3B5X2Zyb21fc2xpY2U6IHNvdXJjZSBzbGljZSBsZW5ndGgg -KCkgZG9lcyBub3QgbWF0Y2ggZGVzdGluYXRpb24gc2xpY2UgbGVuZ3RoICgAAADMPxAAJgAAAPI/ -EAArAAAANDQQAAEAAAAAAwAAgwQgAJEFYABdE6AAEhcgHwwgYB/vLCArKjCgK2+mYCwCqOAsHvvg -LQD+IDae/2A2/QHhNgEKITckDeE3qw5hOS8Y4TkwHOFK8x7hTkA0oVIeYeFT8GphVE9v4VSdvGFV -AM9hVmXRoVYA2iFXAOChWK7iIVrs5OFb0OhhXCAA7lzwAX9d8DQQAPI0EAD0NBAAAgAAAAIAAAAH -AEHwgcEACwFHAHAJcHJvZHVjZXJzAghsYW5ndWFnZQEEUnVzdAAMcHJvY2Vzc2VkLWJ5AwVydXN0 -Yx0xLjg3LjAgKDE3MDY3ZTlhYyAyMDI1LTA1LTA5KQZ3YWxydXMGMC4yMy4zDHdhc20tYmluZGdl -bgcwLjIuMTAwAGsPdGFyZ2V0X2ZlYXR1cmVzBisPbXV0YWJsZS1nbG9iYWxzKxNub250cmFwcGlu -Zy1mcHRvaW50KwtidWxrLW1lbW9yeSsIc2lnbi1leHQrD3JlZmVyZW5jZS10eXBlcysKbXVsdGl2 -YWx1ZQ== +YjU1N2Yvd2FzbS1iaW5kZ2VuLTAuMi4xMDAvc3JjL2NvbnZlcnQvc2xpY2VzLnJzsgIQAAoAAABM +AAAAFAAAANwCEABwAAAAJAEAAA4AQYyHwAALzQFJbnZhbGlkIGhhc2ggaGV4OiAAAIwDEAASAAAA +SW52YWxpZCBITUFDIGtleSBoZXg6IAAAqAMQABYAAAAvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAv +dG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3Ny +Yy9ydXN0L2xpYnJhcnkvY29yZS9zcmMvaXRlci90cmFpdHMvaXRlcmF0b3IucnMAAADIAxAAgQAA +AMEHAAAJAEHkiMAAC5UBAQAAAAsAAABhIHNlcXVlbmNlL2hvbWUvY295b3R0ZTUwOC8uY2FyZ28v +cmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3NlcmRlLTEuMC4y +MTkvc3JjL2RlL2ltcGxzLnJzAAAAdgQQAGMAAACVBAAAIgAAAHYEEABjAAAAmAQAABwAQYSKwAAL +BQEAAAAMAEGUisAACwUBAAAADQBBpIrAAAvlAQEAAAAOAAAAY2FsbGVkIGBPcHRpb246OnVud3Jh +cF90aHJvdygpYCBvbiBhIGBOb25lYCB2YWx1ZWhhc2hsZW5ndGgvaG9tZS9jb3lvdHRlNTA4Ly5y +dXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0 +bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3Jhd192ZWMvbW9kLnJzZwUQAHkAAAAuAgAA +EQAAACA6IAoBAAAAAAAAAPAFEAADAAAA8wUQAAEAQZSMwAALvwgBAAAAEgAAAGNhbGxlZCBgUmVz +dWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUvaG9tZS9jb3lvdHRlNTA4L2NvZGUvaHVn +Z2luZ2ZhY2UuanMvcGFja2FnZXMvaHViL3hldC1jb3JlLXdhc20tYnVpbGQvbWVya2xlaGFzaC9z +cmMvYWdncmVnYXRlZF9oYXNoZXMucnNHBhAAaQAAAD0AAAAqAAAARwYQAGkAAAA4AAAAHgAAAC9o +b21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS14ODZfNjQtdW5rbm93bi1s +aW51eC1nbnUvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvc3RyaW5nLnJz +0AYQAHQAAADoAQAAFwAAAEVycm9yAAAA0AYQAHQAAAB9BQAAGwAAAGludmFsaWQgdmFsdWU6ICwg +ZXhwZWN0ZWQgAABsBxAADwAAAHsHEAALAAAAbWlzc2luZyBmaWVsZCBgYJgHEAAPAAAApwcQAAEA +AABkdXBsaWNhdGUgZmllbGQgYAAAALgHEAARAAAApwcQAAEAAAATAAAADAAAAAQAAAAUAAAAFQAA +AAgAAAAvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVu +a25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3Ns +aWNlLnJzAPQHEABzAAAAvgEAAB0AAAAvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlu +cy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xp +YnJhcnkvYWxsb2Mvc3JjL3ZlYy9zcGVjX2Zyb21faXRlcl9uZXN0ZWQucnMAeAgQAIcAAAATAAAA +BQAAAGludmFsaWQgdHlwZTogLCBleHBlY3RlZCAAAAAQCRAADgAAAB4JEAALAAAAL2hvbWUvY295 +b3R0ZTUwOC8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdu +dS9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2FsbG9jL3NyYy9zbGljZS5ycwA8CRAAcwAA +AL4BAAAdAAAAAQAAAAAAAAAvaG9tZS9jb3lvdHRlNTA4Ly5jYXJnby9yZWdpc3RyeS9zcmMvaW5k +ZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvc2VyZGUtd2FzbS1iaW5kZ2VuLTAuNi41L3Ny +Yy9saWIucnMAAADICRAAaQAAADUAAAAOAAAAAAAAAP//////////SAoQAEHglMAAC4EiAQAAAC9o +b21lL2NveW90dGU1MDgvY29kZS9odWdnaW5nZmFjZS5qcy9wYWNrYWdlcy9odWIveGV0LWNvcmUt +d2FzbS1idWlsZC9kZWR1cGxpY2F0aW9uL3NyYy9jaHVua2luZy5ycwBkChAAYwAAAB4AAAAJAAAA +YXNzZXJ0aW9uIGZhaWxlZDogdGFyZ2V0X2NodW5rX3NpemUgPiA2NGQKEABjAAAAIgAAAAkAAABk +ChAAYwAAAC4AAAAdAAAAYXNzZXJ0aW9uIGZhaWxlZDogbWF4aW11bV9jaHVuayA+IG1pbmltdW1f +Y2h1bmsAZAoQAGMAAAAxAAAACQAAAGQKEABjAAAAOwAAABcAAABkChAAYwAAAGUAAAA7AAAAZAoQ +AGMAAACHAAAAMgAAAGQKEABjAAAAiQAAADoAAABkChAAYwAAALEAAAAVAAAAZAoQAGMAAACuAAAA +QAAAAC9ob21lL2NveW90dGU1MDgvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8t +MTk0OWNmOGM2YjViNTU3Zi9sYXp5X3N0YXRpYy0xLjUuMC9zcmMvaW5saW5lX2xhenkucnMAAMAL +EABqAAAAHgAAABAAAAAvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUt +eDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxs +b2Mvc3JjL3Jhd192ZWMvbW9kLnJzAAAAPAwQAHkAAAAuAgAAEQAAAE9uY2UgaW5zdGFuY2UgaGFz +IHByZXZpb3VzbHkgYmVlbiBwb2lzb25lZAAAyAwQACoAAABvbmUtdGltZSBpbml0aWFsaXphdGlv +biBtYXkgbm90IGJlIHBlcmZvcm1lZCByZWN1cnNpdmVsefwMEAA4AAAAL2hvbWUvY295b3R0ZTUw +OC8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9saWIv +cnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L3N0ZC9zcmMvc3luYy9wb2lzb24vb25jZS5yczwNEAB8 +AAAAmwAAADIAAABZ9UDoqdOIsNYg7Tn3x1JWq3KJiWmJskV3x4621YkKa7cxeos+V482S9k26dw2 +xh221VRVTkx6IMuaIyhGs3SkErmjHD6oBjv3ugIvbI3nkIqaDRX3LcnhrdOGEDoFlY4iBzq48fQu +Wq5/gJ+UrA+lgdbYgOsDcw4PrXAV3H6wmXYw/VW1L51oaKSeEYJQAAAozI+oBoOwxP1KN/aKZ7A+ +NnSthquHn/E2x2u+v58S8u2kmFxXSRFIxXtHlQYBAADM6pwagDe6H22bpGPWb/A7S4fjgpd+aJnj +2FCqcwaheSD0EWKez6zkcZBXhx/nICWbihp4/dPVK3PIEd3NTd4ALzmHWhwxqer/QLwXto5022+/ +IPaNmlevscIJG9rlpoYuoSLDCsMvzGdC98H+Kl41e6QhwPTImS3DzwSUSkveuml9cB1yGLX3ICzz +e1i2hjIMJ6+GiLYAAHmQitvk1hWhmeGyl5x+T0gB4xNXt3vKzGDxsCumhCW/yLxdYhPo561alYcN +lHAAAG9inhMIkeaKojjeL9dqd73PwPzCHwBr+yfEe+a4dKTHWF3rEBbx9rrRcOdtWx/LCUdMfZfm +GbKwSq2nbji8zAABP5ffCp2EzHD3agF976Nz/r29htPSB8gwF3lslskqf9oExcZrqDfQnWCqHmZ8 +8fOH5qpNsCamrAdbSk83mVp13q4sW+Z+g5CFB1b9k63obtjtUxDh2QAA19sc0rI7Bp6y0gEq8Xer +B0QbZOZVAlXsxhScRKiU+3j19cDGGw5Rx+PK5DYLMgAALRqLLCYzfIJEQepIC19nFOvsjUmm03sm +XgP1gvlvkfGI+zT0fxsihthJbzjnzr6dSo8PyMr4WOrYZPyShhmNADaav7pPcDhtTL7n0QfLMuCQ +CEWt9iGNIqWJJcC/sVxjcc6inHOhIEZY++Wq49/np+sNPCuTyhAMe+2vhOj+Jycfq+L5bRzfoiP1 +dAes0c1NTuIzrf9wAAAWeJfFe+isoklgKLRaJ5KYWYnx3YERhsIZPkhCoHKZu3gwUWY3zXDvZJj8 +qxMFAACDQMlYGLZYwN7gJZeFUOgJlH0++Dv7l5HOS7YSbWIeftFXe39QVAxSFiTidHF54b6HVeki +MqzZbz6/35p8lSMAFb5LI359HKC7jKO4WMeiqzArPuzOoB8Nkblgfoultgs1ZqKfW90zQ6PBAUB9 +O/3CJxFzVCSAQfvLGA2lhWGlZU+1hIe9Anr2Y1DmZ90Rb2mrFKj8IiAAAFLYuS2RvtaMV4qu6baJ +UWkoDNoKtVOU7l6EeBqpXvzYZ6dKGhm/hqvlFWTItcYAAC6iCI4XEHMmJcqLBxsQLe37qCayhO1B +OwbcKA8SIuYTJm1w++v1FaPOugEzTsMWiK79cbucWznpSBZyLiDpLAAcybMrHduDQqWmsdIaRn3X +a4brbuQX7OJ8xPs5QL7guASdKdXEYKHeNDaM0siG7H6Zo5ifEq0ZIe+DomFr9MymF8ZY9t7OUiyD +3axpEYe0LenLnvPW8AAAiZQvjcnY1T2E9QEronIYivI8ew7EpILylqEbyyzsIIAT41me4LaTZuuD +fMwZzgAAO5xH9jVXyyBbWtdZN78udnU5aT2C/nsg1dmcMxLBfdcDfWKEQoOnm+lRX+kTxX0hFnhe +/Ckae7ItZrsxmM3VAExzdW2Am+NxIxr7BvAqV36FH+lqL09zovLdLAK1xoK/3qBhB8bqO1yYaUFH +u5PIzQF+GFxhhRBtXXwnrDCu+HeRLCoSgWt8kWdp0a2ZtnVbmwaa52rPAAAEEd5g+grE88NnkaV6 +EmMgTYnRaSLmHWImRyvmHayI0TxnSxXiNnAQHTpVKF+4AAA9byMYTE7v8gL2uRFm3tbZHJFH+1V5 +/KG9jSkvA/2F6+H6vrMvUCe+HmbNxFFCA+M2GAdU02QTRD6Y8nVss4IA8Gb6FgORRbH3ykeYnAYc +AiFSS1rH3xAptahXHD41W3Ns2Y7pLDFEzmX6vQZFLpS8G5RXEqeGUPCtzlHTFbLD/gJCFOBVEK4A +VORCb4RAS/XIvLzI2X8AAP6b3hfznr2/Ek6F8i8wBKjU2OWlV0nOOYS6N1ak4rn/i4Ggnh2tuVWK +Fxnzy4oAADj7+9DIv+JI6LVI6EGY44uLoJYGFhInDiokREvolhDVOuGSZxe6ARGdaDFFD3cuwmzF +u3Ly74kW7FBWfxkqqQBOeKG9kFl2vK64/JLjQRTGoOQx7Sw64QdNnU4jhOnLksWKfbty9U+P0DuW +C8BwlgsB6wMaWFqVYlQCAOrlg19kmfKIzRbl/EHPmHraSJfau/pFSP6yqgAAVWX1mwYbdhlWrbZD +g16Pi9khSBT9HF0+j82woiweXOx/tfun/uD3+huWErrTAAAAjrEBhBeQP9rrXzrjbZD/cOdwacCn +1ScF6RN8YHPn2CKsOzxk33CryeMSvorcxqTtiuczAEEf7+zLcqx0ssIkALQAqU+VDXQGBGM9Mpsp +eh3V6suYsnzDs5tzeGHH44bJivVGSzbqq59WzIWvxRSibYSPo7fYPqQX69uaHVHszG77WjMTCbPK ++dLuFfTFYF5KtHI2UGdpAACHu1QUEh2lnRbIu7kTHjKEjd0vq7ZvPfuNChaO7V4wYOhslOkUS7/L +wxAbOGNPAAAQTsxvgbfVB1WBampyNqXl3X+gRzSyr1eU08mr90bzGD3TGtZVxm1j9vP3OUmri8x7 +GN3BBqnHYy9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS14ODZfNjQt +dW5rbm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMv +c2xpY2UucnMAyBUQAHMAAAC+AQAAHQAAAE9uY2UgaW5zdGFuY2UgaGFzIHByZXZpb3VzbHkgYmVl +biBwb2lzb25lZAAATBYQACoAAABvbmUtdGltZSBpbml0aWFsaXphdGlvbiBtYXkgbm90IGJlIHBl +cmZvcm1lZCByZWN1cnNpdmVseYAWEAA4AAAAL2hvbWUvY295b3R0ZTUwOC8ucnVzdHVwL3Rvb2xj +aGFpbnMvc3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9saWIvcnVzdGxpYi9zcmMvcnVz +dC9saWJyYXJ5L3N0ZC9zcmMvc3luYy9wb2lzb24vb25jZS5yc8AWEAB8AAAAmwAAADIAAAAvaG9t +ZS9jb3lvdHRlNTA4Ly5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhj +NmI1YjU1N2YvbGF6eV9zdGF0aWMtMS41LjAvc3JjL2lubGluZV9sYXp5LnJzAABMFxAAagAAAB4A +AAAQAAAAL2hvbWUvY295b3R0ZTUwOC8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLXg4Nl82NC11 +bmtub3duLWxpbnV4LWdudS9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2NvcmUvc3JjL2l0 +ZXIvdHJhaXRzL2l0ZXJhdG9yLnJzAAAAyBcQAIEAAADBBwAACQAAAH8YV9bOVu1mEn/5E+elw/Ok +zSbVtdtJ5kEkmH8o+5TDL2hvbWUvY295b3R0ZTUwOC8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxl +LXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2Fs +bG9jL3NyYy9yYXdfdmVjL21vZC5ycwAAAHwYEAB5AAAALgIAABEAAAAAAAAABAAAAAQAAAAYAAAA +L2hvbWUvY295b3R0ZTUwOC8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5 +Y2Y4YzZiNWI1NTdmL2pzLXN5cy0wLjMuNzcvc3JjL2xpYi5ycwAAGBkQAF4AAAD7GAAAAQAAAC9o +b21lL2NveW90dGU1MDgvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNm +OGM2YjViNTU3Zi93YXNtLWJpbmRnZW4tMC4yLjEwMC9zcmMvY29udmVydC9zbGljZXMucnOIGRAA +cAAAACQBAAAOAAAAY2xvc3VyZSBpbnZva2VkIHJlY3Vyc2l2ZWx5IG9yIGFmdGVyIGJlaW5nIGRy +b3BwZWRMYXlvdXRFcnJvci9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJs +ZS14ODZfNjQtdW5rbm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9h +bGxvYy9zcmMvc2xpY2UucnNFGhAAcwAAAL4BAAAdAAAAJQAAACYAAAAnAAAAKAAAACkAAAAvaG9t +ZS9jb3lvdHRlNTA4Ly5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhj +NmI1YjU1N2YvYnl0ZXMtMS4xMC4xL3NyYy9ieXRlcy5ycwAqAAAAKwAAACwAAAAtAAAALgAAAC8A +AAAwAAAAMQAAAC0AAAAyAEHstsAAC6UUAQAAADMAAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClg +IG9uIGFuIGBFcnJgIHZhbHVlANwaEABfAAAASAUAADIAAADcGhAAXwAAAFYFAABJAAAANAAAADUA +AAA2AAAANwAAADgAAAAvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUt +eDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxs +b2Mvc3JjL3NsaWNlLnJzANQbEABzAAAAvgEAAB0AAAAvaG9tZS9jb3lvdHRlNTA4L2NvZGUvaHVn +Z2luZ2ZhY2UuanMvcGFja2FnZXMvaHViL3hldC1jb3JlLXdhc20tYnVpbGQvbWVya2xlaGFzaC9z +cmMvZGF0YV9oYXNoLnJzAAAAWBwQAGEAAAB6AAAACQAAAEludmFsaWQgaGV4IGlucHV0IGZvciBE +YXRhSGFzaAAAAQAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAQAAAAAAAABYHBAAYQAAALIAAAAqAAAA +WBwQAGEAAACzAAAAKgAAAFgcEABhAAAAtAAAACoAAABml/V3W5VQ3jE1y6yllxgcneQhEJvrK1i0 +0LBLk63yKQF+xcelRymW/ZRmZrSKAuZd3VNvN8dt0vhjUuZKU3E/AQAAAAAAAABtaWQgPiBsZW4A +AACEHRAACQAAAC9ob21lL2NveW90dGU1MDgvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0 +ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9ibGFrZTMtMS44LjIvc3JjL2xpYi5ycwAAAJgdEABdAAAA +CwIAABEAAACYHRAAXQAAAL4CAAAKAAAAmB0QAF0AAADsAgAAKAAAAJgdEABdAAAA7AIAADQAAACY +HRAAXQAAAOwCAAAMAAAAmB0QAF0AAADcAgAAFwAAAJgdEABdAAAAGAMAAB8AAACYHRAAXQAAADUD +AAAMAAAAmB0QAF0AAAA8AwAAEgAAAJgdEABdAAAAYAMAACEAAACYHRAAXQAAAGIDAAARAAAAmB0Q +AF0AAABiAwAAQQAAAGluc3VmZmljaWVudCBjYXBhY2l0eQAAALgeEAAVAAAAQ2FwYWNpdHlFcnJv +cjogANgeEAAPAAAAY2FsbGVkIGBSZXN1bHQ6OnVud3JhcCgpYCBvbiBhbiBgRXJyYCB2YWx1ZQAA +AAAABAAAAAQAAAA8AAAAAAAAAAgAAAAEAAAARAAAAEUAAABGAAAAYSBzdHJpbmdieXRlIGFycmF5 +Ym9vbGVhbiBgYFYfEAAJAAAAXx8QAAEAAABpbnRlZ2VyIGAAAABwHxAACQAAAF8fEAABAAAAZmxv +YXRpbmcgcG9pbnQgYIwfEAAQAAAAXx8QAAEAAABjaGFyYWN0ZXIgYACsHxAACwAAAF8fEAABAAAA +c3RyaW5nIADIHxAABwAAAHVuaXQgdmFsdWVPcHRpb24gdmFsdWVuZXd0eXBlIHN0cnVjdHNlcXVl +bmNlbWFwZW51bXVuaXQgdmFyaWFudG5ld3R5cGUgdmFyaWFudHR1cGxlIHZhcmlhbnRzdHJ1Y3Qg +dmFyaWFudAAAAAEAAAAAAAAALjB1MzJMYXp5IGluc3RhbmNlIGhhcyBwcmV2aW91c2x5IGJlZW4g +cG9pc29uZWQAUSAQACoAAAAvaG9tZS9jb3lvdHRlNTA4Ly5jYXJnby9yZWdpc3RyeS9zcmMvaW5k +ZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvb25jZV9jZWxsLTEuMjEuMy9zcmMvbGliLnJz +AAAAhCAQAGEAAAAIAwAAGQAAAHJlZW50cmFudCBpbml0AAD4IBAADgAAAIQgEABhAAAAegIAAA0A +AAAvaG9tZS9jb3lvdHRlNTA4Ly5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5 +NDljZjhjNmI1YjU1N2Yvd2FzbS1iaW5kZ2VuLTAuMi4xMDAvc3JjL2NvbnZlcnQvaW1wbHMucnMA +ICEQAG8AAABhAgAAFgAAACAhEABvAAAAcQIAAAwAAAAgIRAAbwAAAG0CAAAQAAAAYXJyYXkgY29u +dGFpbnMgYSB2YWx1ZSBvZiB0aGUgd3JvbmcgdHlwZW51bGwgcG9pbnRlciBwYXNzZWQgdG8gcnVz +dHJlY3Vyc2l2ZSB1c2Ugb2YgYW4gb2JqZWN0IGRldGVjdGVkIHdoaWNoIHdvdWxkIGxlYWQgdG8g +dW5zYWZlIGFsaWFzaW5nIGluIHJ1c3RKc1ZhbHVlKCkAUiIQAAgAAABaIhAAAQAAAC9ydXN0Yy8x +NzA2N2U5YWM2ZDdlY2I3MGU1MGY5MmMxOTQ0ZTU0NTE4OGQyMzU5L2xpYnJhcnkvYWxsb2Mvc3Jj +L3N0cmluZy5ycwBsIhAASwAAAH0FAAAbAAAAL3J1c3RjLzE3MDY3ZTlhYzZkN2VjYjcwZTUwZjky +YzE5NDRlNTQ1MTg4ZDIzNTkvbGlicmFyeS9hbGxvYy9zcmMvcmF3X3ZlYy9tb2QucnPIIhAAUAAA +AC4CAAARAAAASwAAAAwAAAAEAAAATAAAAE0AAABOAAAAL3J1c3QvZGVwcy9kbG1hbGxvYy0wLjIu +Ny9zcmMvZGxtYWxsb2MucnNhc3NlcnRpb24gZmFpbGVkOiBwc2l6ZSA+PSBzaXplICsgbWluX292 +ZXJoZWFkAEAjEAApAAAAqAQAAAkAAABhc3NlcnRpb24gZmFpbGVkOiBwc2l6ZSA8PSBzaXplICsg +bWF4X292ZXJoZWFkAABAIxAAKQAAAK4EAAANAAAAbWVtb3J5IGFsbG9jYXRpb24gb2YgIGJ5dGVz +IGZhaWxlZAAA6CMQABUAAAD9IxAADQAAAGxpYnJhcnkvc3RkL3NyYy9hbGxvYy5ycxwkEAAYAAAA +ZAEAAAkAAABLAAAADAAAAAQAAABPAAAAAAAAAAgAAAAEAAAAUAAAAAAAAAAIAAAABAAAAFEAAABS +AAAAUwAAAFQAAABVAAAAEAAAAAQAAABWAAAAVwAAAFgAAABZAAAASGFzaCB0YWJsZSBjYXBhY2l0 +eSBvdmVyZmxvd5wkEAAcAAAAL3J1c3QvZGVwcy9oYXNoYnJvd24tMC4xNS4yL3NyYy9yYXcvbW9k +LnJzAADAJBAAKgAAACMAAAAoAAAARXJyb3IAAABaAAAADAAAAAQAAABbAAAAXAAAAF0AAABjYXBh +Y2l0eSBvdmVyZmxvdwAAABwlEAARAAAAbGlicmFyeS9hbGxvYy9zcmMvcmF3X3ZlYy9tb2QucnM4 +JRAAIAAAAC4CAAARAAAAbGlicmFyeS9hbGxvYy9zcmMvc3RyaW5nLnJzAGglEAAbAAAA6AEAABcA +QZzLwAALyBIBAAAAXgAAAGEgZm9ybWF0dGluZyB0cmFpdCBpbXBsZW1lbnRhdGlvbiByZXR1cm5l +ZCBhbiBlcnJvciB3aGVuIHRoZSB1bmRlcmx5aW5nIHN0cmVhbSBkaWQgbm90bGlicmFyeS9hbGxv +Yy9zcmMvZm10LnJzAAD6JRAAGAAAAIoCAAAOAAAAaCUQABsAAAB9BQAAGwAAAABwAAcALQEBAQIB +AgEBSAswFRABZQcCBgICAQQjAR4bWws6CQkBGAQBCQEDAQUrAzsJKhgBIDcBAQEECAQBAwcKAh0B +OgEBAQIECAEJAQoCGgECAjkBBAIEAgIDAwEeAgMBCwI5AQQFAQIEARQCFgYBAToBAQIBBAgBBwMK +Ah4BOwEBAQwBCQEoAQMBNwEBAwUDAQQHAgsCHQE6AQICAQEDAwEEBwILAhwCOQIBAQIECAEJAQoC +HQFIAQQBAgMBAQgBUQECBwwIYgECCQsHSQIbAQEBAQE3DgEFAQIFCwEkCQFmBAEGAQICAhkCBAMQ +BA0BAgIGAQ8BAAMABBwDHQIeAkACAQcIAQILCQEtAwEBdQIiAXYDBAIJAQYD2wICAToBAQcBAQEB +AggGCgIBMB8xBDAKBAMmCQwCIAQCBjgBAQIDAQEFOAgCApgDAQ0BBwQBBgEDAsZAAAHDIQADjQFg +IAAGaQIABAEKIAJQAgABAwEEARkCBQGXAhoSDQEmCBkLAQEsAzABAgQCAgIBJAFDBgICAgIMAQgB +LwEzAQEDAgIFAgEBKgIIAe4BAgEEAQABABAQEAACAAHiAZUFAAMBAgUEKAMEAaUCAARBBQACTwRG +CzEEewE2DykBAgIKAzEEAgIHAT0DJAUBCD4BDAI0CQEBCAQCAV8DAgQGAQIBnQEDCBUCOQIBAQEB +DAEJAQ4HAwVDAQIGAQECAQEDBAMBAQ4CVQgCAwEBFwFRAQIGAQECAQECAQLrAQIEBgIBAhsCVQgC +AQECagEBAQIIZQEBAQIEAQUACQEC9QEKBAQBkAQCAgQBIAooBgIECAEJBgIDLg0BAgAHAQYBAVIW +AgcBAgECegYDAQECAQcBAUgCAwEBAQACCwI0BQUDFwEAAQYPAAwDAwAFOwcAAT8EUQELAgACAC4C +FwAFAwYICAIHHgSUAwA3BDIIAQ4BFgUBDwAHARECBwECAQVkAaAHAAE9BAAE/gIAB20HAGCA8ABh +c3NlcnRpb24gZmFpbGVkOiBlZGVsdGEgPj0gMGxpYnJhcnkvY29yZS9zcmMvbnVtL2RpeV9mbG9h +dC5ycwAAAEApEAAhAAAATAAAAAkAAABAKRAAIQAAAE4AAAAJAAAAwW/yhiMAAACB76yFW0FtLe4E +AAABH2q/ZO04bu2Xp9r0+T/pA08YAAE+lS4Jmd8D/TgVDy/kdCPs9c/TCNwExNqwzbwZfzOmAyYf +6U4CAAABfC6YW4fTvnKf2diHLxUSxlDea3BuSs8P2JXVbnGyJrBmxq0kNhUdWtNCPA5U/2PAc1XM +F+/5ZfIovFX3x9yA3O1u9M7v3F/3UwUAbGlicmFyeS9jb3JlL3NyYy9udW0vZmx0MmRlYy9zdHJh +dGVneS9kcmFnb24ucnNhc3NlcnRpb24gZmFpbGVkOiBkLm1hbnQgPiAwACAqEAAvAAAAdgAAAAUA +AABhc3NlcnRpb24gZmFpbGVkOiBkLm1pbnVzID4gMAAAACAqEAAvAAAAdwAAAAUAAABhc3NlcnRp +b24gZmFpbGVkOiBkLnBsdXMgPiAwICoQAC8AAAB4AAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGJ1 +Zi5sZW4oKSA+PSBNQVhfU0lHX0RJR0lUUwAAACAqEAAvAAAAewAAAAUAAAAgKhAALwAAAMIAAAAJ +AAAAICoQAC8AAAD7AAAADQAAACAqEAAvAAAAAgEAABIAAABhc3NlcnRpb24gZmFpbGVkOiBkLm1h +bnQuY2hlY2tlZF9zdWIoZC5taW51cykuaXNfc29tZSgpACAqEAAvAAAAegAAAAUAAABhc3NlcnRp +b24gZmFpbGVkOiBkLm1hbnQuY2hlY2tlZF9hZGQoZC5wbHVzKS5pc19zb21lKCkAACAqEAAvAAAA +eQAAAAUAAAAgKhAALwAAAAsBAAAFAAAAICoQAC8AAAAMAQAABQAAACAqEAAvAAAADQEAAAUAAAAg +KhAALwAAAHIBAAAkAAAAICoQAC8AAAB3AQAALwAAACAqEAAvAAAAhAEAABIAAAAgKhAALwAAAGYB +AAANAAAAICoQAC8AAABMAQAAIgAAACAqEAAvAAAADwEAAAUAAAAgKhAALwAAAA4BAAAFAAAA30Ua +PQPPGubB+8z+AAAAAMrGmscX/nCr3PvU/gAAAABP3Ly+/LF3//b73P4AAAAADNZrQe+RVr4R/OT+ +AAAAADz8f5CtH9CNLPzs/gAAAACDmlUxKFxR00b89P4AAAAAtcmmrY+scZ1h/Pz+AAAAAMuL7iN3 +Ipzqe/wE/wAAAABtU3hAkUnMrpb8DP8AAAAAV862XXkSPIKx/BT/AAAAADdW+002lBDCy/wc/wAA +AABPmEg4b+qWkOb8JP8AAAAAxzqCJcuFdNcA/Sz/AAAAAPSXv5fNz4agG/00/wAAAADlrCoXmAo0 +7zX9PP8AAAAAjrI1KvtnOLJQ/UT/AAAAADs/xtLf1MiEa/1M/wAAAAC6zdMaJ0TdxYX9VP8AAAAA +lsklu86fa5Og/Vz/AAAAAISlYn0kbKzbuv1k/wAAAAD22l8NWGaro9X9bP8AAAAAJvHD3pP44vPv +/XT/AAAAALiA/6qorbW1Cv58/wAAAACLSnxsBV9ihyX+hP8AAAAAUzDBNGD/vMk//oz/AAAAAFUm +upGMhU6WWv6U/wAAAAC9filwJHf533T+nP8AAAAAj7jluJ+936aP/qT/AAAAAJR9dIjPX6n4qf6s +/wAAAADPm6iPk3BEucT+tP8AAAAAaxUPv/jwCIrf/rz/AAAAALYxMWVVJbDN+f7E/wAAAACsf3vQ +xuI/mRT/zP8AAAAABjsrKsQQXOQu/9T/AAAAANOSc2mZJCSqSf/c/wAAAAAOygCD8rWH/WP/5P8A +AAAA6xoRkmQI5bx+/+z/AAAAAMyIUG8JzLyMmf/0/wAAAAAsZRniWBe30bP//P8AQe7dwAALBUCc +zv8EAEH83cAAC5kkEKXU6Oj/DAAAAAAAAABirMXreK0DABQAAAAAAIQJlPh4OT+BHgAcAAAAAACz +FQfJe86XwDgAJAAAAAAAcFzqe84yfo9TACwAAAAAAGiA6aukONLVbQA0AAAAAABFIpoXJidPn4gA +PAAAAAAAJ/vE1DGiY+2iAEQAAAAAAKityIw4Zd6wvQBMAAAAAADbZasajgjHg9gAVAAAAAAAmh1x +QvkdXcTyAFwAAAAAAFjnG6YsaU2SDQFkAAAAAADqjXAaZO4B2icBbAAAAAAASnfvmpmjbaJCAXQA +AAAAAIVrfbR7eAnyXAF8AAAAAAB3GN15oeRUtHcBhAAAAAAAwsWbW5KGW4aSAYwAAAAAAD1dlsjF +UzXIrAGUAAAAAACzoJf6XLQqlccBnAAAAAAA41+gmb2fRt7hAaQAAAAAACWMOds0wpul/AGsAAAA +AABcn5ijcprG9hYCtAAAAAAAzr7pVFO/3LcxArwAAAAAAOJBIvIX8/yITALEAAAAAACleFzTm84g +zGYCzAAAAAAA31Mhe/NaFpiBAtQAAAAAADowH5fctaDimwLcAAAAAACWs+NcU9HZqLYC5AAAAAAA +PESnpNl8m/vQAuwAAAAAABBEpKdMTHa76wL0AAAAAAAanEC2746riwYD/AAAAAAALIRXphDvH9Ag +AwQBAAAAACkxkenlpBCbOwMMAQAAAACdDJyh+5sQ51UDFAEAAAAAKfQ7YtkgKKxwAxwBAAAAAIXP +p3peS0SAiwMkAQAAAAAt3awDQOQhv6UDLAEAAAAAj/9EXi+cZ47AAzQBAAAAAEG4jJydFzPU2gM8 +AQAAAACpG+O0ktsZnvUDRAEAAAAA2Xffum6/lusPBEwBAAAAAGxpYnJhcnkvY29yZS9zcmMvbnVt +L2ZsdDJkZWMvc3RyYXRlZ3kvZ3Jpc3UucnMAAIgxEAAuAAAAfQAAABUAAACIMRAALgAAAKkAAAAF +AAAAiDEQAC4AAACqAAAABQAAAIgxEAAuAAAAqwAAAAUAAACIMRAALgAAAK4AAAAFAAAAYXNzZXJ0 +aW9uIGZhaWxlZDogZC5tYW50ICsgZC5wbHVzIDwgKDEgPDwgNjEpAAAAiDEQAC4AAACvAAAABQAA +AIgxEAAuAAAACgEAABEAAACIMRAALgAAAA0BAAAJAAAAiDEQAC4AAABAAQAACQAAAIgxEAAuAAAA +rQAAAAUAAACIMRAALgAAAKwAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogIWJ1Zi5pc19lbXB0eSgp +AAAAiDEQAC4AAADcAQAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGQubWFudCA8ICgxIDw8IDYxKYgx +EAAuAAAA3QEAAAUAAACIMRAALgAAAN4BAAAFAAAAAQAAAAoAAABkAAAA6AMAABAnAACghgEAQEIP +AICWmAAA4fUFAMqaO4gxEAAuAAAAMwIAABEAAACIMRAALgAAADYCAAAJAAAAiDEQAC4AAABsAgAA +CQAAAIgxEAAuAAAA4wIAACYAAACIMRAALgAAAO8CAAAmAAAAiDEQAC4AAADMAgAAJgAAAGxpYnJh +cnkvY29yZS9zcmMvbnVtL2ZsdDJkZWMvbW9kLnJzAJgzEAAjAAAAuwAAAAUAAABhc3NlcnRpb24g +ZmFpbGVkOiBidWZbMF0gPiBiJzAnAJgzEAAjAAAAvAAAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBw +YXJ0cy5sZW4oKSA+PSA0AACYMxAAIwAAAL0AAAAFAAAALjAuLStOYU5pbmYwYXNzZXJ0aW9uIGZh +aWxlZDogYnVmLmxlbigpID49IG1heGxlbgAAAJgzEAAjAAAAfgIAAA0AAAApLi4wMTIzNDU2Nzg5 +YWJjZGVmQm9ycm93TXV0RXJyb3JhbHJlYWR5IGJvcnJvd2VkOiAAlTQQABIAAABjYWxsZWQgYE9w +dGlvbjo6dW53cmFwKClgIG9uIGEgYE5vbmVgIHZhbHVlaW5kZXggb3V0IG9mIGJvdW5kczogdGhl +IGxlbiBpcyAgYnV0IHRoZSBpbmRleCBpcyAAAADbNBAAIAAAAPs0EAASAAAAAAAAAAQAAAAEAAAA +ZQAAAD09IT1tYXRjaGVzYXNzZXJ0aW9uIGBsZWZ0ICByaWdodGAgZmFpbGVkCiAgbGVmdDogCiBy +aWdodDogADs1EAAQAAAASzUQABcAAABiNRAACQAAACByaWdodGAgZmFpbGVkOiAKICBsZWZ0OiAA +AAA7NRAAEAAAAIQ1EAAQAAAAlDUQAAkAAABiNRAACQAAADogAAABAAAAAAAAAMA1EAACAAAAAAAA +AAwAAAAEAAAAZgAAAGcAAABoAAAAICAgICwKKCgKLDB4MDAwMTAyMDMwNDA1MDYwNzA4MDkxMDEx +MTIxMzE0MTUxNjE3MTgxOTIwMjEyMjIzMjQyNTI2MjcyODI5MzAzMTMyMzMzNDM1MzYzNzM4Mzk0 +MDQxNDI0MzQ0NDU0NjQ3NDg0OTUwNTE1MjUzNTQ1NTU2NTc1ODU5NjA2MTYyNjM2NDY1NjY2NzY4 +Njk3MDcxNzI3Mzc0NzU3Njc3Nzg3OTgwODE4MjgzODQ4NTg2ODc4ODg5OTA5MTkyOTM5NDk1OTY5 +Nzk4OTkwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw +MDAwMDAwMDAwMDAwbGlicmFyeS9jb3JlL3NyYy9mbXQvbW9kLnJzZmFsc2V0cnVlADcQABsAAADY +CgAAJgAAAAA3EAAbAAAA4QoAABoAAABsaWJyYXJ5L2NvcmUvc3JjL3N0ci9tb2QucnNbLi4uXWJl +Z2luIDw9IGVuZCAoIDw9ICkgd2hlbiBzbGljaW5nIGBgAGQ3EAAOAAAAcjcQAAQAAAB2NxAAEAAA +AIY3EAABAAAAYnl0ZSBpbmRleCAgaXMgbm90IGEgY2hhciBib3VuZGFyeTsgaXQgaXMgaW5zaWRl +ICAoYnl0ZXMgKSBvZiBgAKg3EAALAAAAszcQACYAAADZNxAACAAAAOE3EAAGAAAAhjcQAAEAAAAg +aXMgb3V0IG9mIGJvdW5kcyBvZiBgAACoNxAACwAAABA4EAAWAAAAhjcQAAEAAABENxAAGwAAAJwB +AAAsAAAAbGlicmFyeS9jb3JlL3NyYy91bmljb2RlL3ByaW50YWJsZS5ycwAAAFA4EAAlAAAAGgAA +ADYAAABQOBAAJQAAAAoAAAArAAAAAAYBAQMBBAIFBwcCCAgJAgoFCwIOBBABEQISBRMcFAEVAhcC +GQ0cBR0IHwEkAWoEawKvA7ECvALPAtEC1AzVCdYC1wLaAeAF4QLnBOgC7iDwBPgC+gT7AQwnOz5O +T4+enp97i5OWorK6hrEGBwk2PT5W89DRBBQYNjdWV3+qrq+9NeASh4mOngQNDhESKTE0OkVGSUpO +T2RlioyNj7bBw8TGy9ZctrcbHAcICgsUFzY5Oqip2NkJN5CRqAcKOz5maY+SEW9fv+7vWmL0/P9T +VJqbLi8nKFWdoKGjpKeorbq8xAYLDBUdOj9FUaanzM2gBxkaIiU+P+fs7//FxgQgIyUmKDM4OkhK +TFBTVVZYWlxeYGNlZmtzeH1/iqSqr7DA0K6vbm/d3pNeInsFAwQtA2YDAS8ugIIdAzEPHAQkCR4F +KwVEBA4qgKoGJAQkBCgINAtOAzQMgTcJFgoIGDtFOQNjCAkwFgUhAxsFAUA4BEsFLwQKBwkHQCAn +BAwJNgM6BRoHBAwHUEk3Mw0zBy4ICgYmAx0IAoDQUhADNywIKhYaJhwUFwlOBCQJRA0ZBwoGSAgn +CXULQj4qBjsFCgZRBgEFEAMFC1kIAh1iHkgICoCmXiJFCwoGDRM6BgoGFBwsBBeAuTxkUwxICQpG +RRtICFMNSQcKgLYiDgoGRgodA0dJNwMOCAoGOQcKgTYZBzsDHVUBDzINg5tmdQuAxIpMYw2EMBAW +Co+bBYJHmrk6hsaCOQcqBFwGJgpGCigFE4GwOoDGW2VLBDkHEUAFCwIOl/gIhNYpCqLngTMPAR0G +DgQIgYyJBGsFDQMJBxCPYID6BoG0TEcJdDyA9gpzCHAVRnoUDBQMVwkZgIeBRwOFQg8VhFAfBgaA +1SsFPiEBcC0DGgQCgUAfEToFAYHQKoDWKwQBgeCA9ylMBAoEAoMRREw9gMI8BgEEVQUbNAKBDiwE +ZAxWCoCuOB0NLAQJBwIOBoCag9gEEQMNA3cEXwYMBAEPDAQ4CAoGKAgsBAI+gVQMHQMKBTgHHAYJ +B4D6hAYAAQMFBQYGAgcGCAcJEQocCxkMGg0QDgwPBBADEhITCRYBFwQYARkDGgcbARwCHxYgAysD +LQsuATAEMQIyAacEqQKqBKsI+gL7Bf0C/gP/Ca14eYuNojBXWIuMkBzdDg9LTPv8Li8/XF1f4oSN +jpGSqbG6u8XGycre5OX/AAQREikxNDc6Oz1JSl2EjpKpsbS6u8bKzs/k5QAEDQ4REikxNDo7RUZJ +Sl5kZYSRm53Jzs8NESk6O0VJV1tcXl9kZY2RqbS6u8XJ3+Tl8A0RRUlkZYCEsry+v9XX8PGDhYuk +pr6/xcfP2ttImL3Nxs7PSU5PV1leX4mOj7G2t7/BxsfXERYXW1z29/7/gG1x3t8OH25vHB1ffX6u +r027vBYXHh9GR05PWFpcXn5/tcXU1dzw8fVyc490dZYmLi+nr7e/x8/X35oAQJeYMI8fzs/S1M7/ +Tk9aWwcIDxAnL+7vbm83PT9CRZCRU2d1yMnQ0djZ5/7/ACBfIoLfBIJECBsEBhGBrA6AqwUfCIEc +AxkIAQQvBDQEBwMBBwYHEQpQDxIHVQcDBBwKCQMIAwcDAgMDAwwEBQMLBgEOFQVOBxsHVwcCBhcM +UARDAy0DAQQRBg8MOgQdJV8gbQRqJYDIBYKwAxoGgv0DWQcWCRgJFAwUDGoGCgYaBlkHKwVGCiwE +DAQBAzELLAQaBgsDgKwGCgYvMYD0CDwDDwM+BTgIKwWC/xEYCC8RLQMhDyEPgIwEgpoWCxWIlAUv +BTsHAg4YCYC+InQMgNYagRAFgOEJ8p4DNwmBXBSAuAiA3RU7AwoGOAhGCAwGdAseA1oEWQmAgxgc +ChYJTASAigarpAwXBDGhBIHaJgcMBQWAphCB9QcBICoGTASAjQSAvgMbAw8NbGlicmFyeS9jb3Jl +L3NyYy91bmljb2RlL3VuaWNvZGVfZGF0YS5ycwAAAEE+EAAoAAAATQAAACgAAABBPhAAKAAAAFkA +AAAWAAAAbGlicmFyeS9jb3JlL3NyYy9udW0vYmlnbnVtLnJzAACMPhAAHgAAAKsBAAABAAAAYXNz +ZXJ0aW9uIGZhaWxlZDogbm9ib3Jyb3dhc3NlcnRpb24gZmFpbGVkOiBkaWdpdHMgPCA0MGFzc2Vy +dGlvbiBmYWlsZWQ6IG90aGVyID4gMGF0dGVtcHQgdG8gZGl2aWRlIGJ5IHplcm8ADj8QABkAAABh +dHRlbXB0IHRvIGNhbGN1bGF0ZSB0aGUgcmVtYWluZGVyIHdpdGggYSBkaXZpc29yIG9mIHplcm8A +AAAwPxAAOQAAAHJhbmdlIHN0YXJ0IGluZGV4ICBvdXQgb2YgcmFuZ2UgZm9yIHNsaWNlIG9mIGxl +bmd0aCB0PxAAEgAAAIY/EAAiAAAAcmFuZ2UgZW5kIGluZGV4ILg/EAAQAAAAhj8QACIAAABzbGlj +ZSBpbmRleCBzdGFydHMgYXQgIGJ1dCBlbmRzIGF0IADYPxAAFgAAAO4/EAANAAAAY29weV9mcm9t +X3NsaWNlOiBzb3VyY2Ugc2xpY2UgbGVuZ3RoICgpIGRvZXMgbm90IG1hdGNoIGRlc3RpbmF0aW9u +IHNsaWNlIGxlbmd0aCAoAAAADEAQACYAAAAyQBAAKwAAAHQ0EAABAAAAAAMAAIMEIACRBWAAXROg +ABIXIB8MIGAf7ywgKyowoCtvpmAsAqjgLB774C0A/iA2nv9gNv0B4TYBCiE3JA3hN6sOYTkvGOE5 +MBzhSvMe4U5ANKFSHmHhU/BqYVRPb+FUnbxhVQDPYVZl0aFWANohVwDgoViu4iFa7OThW9DoYVwg +AO5c8AF/XTA1EAAyNRAANDUQAAIAAAACAAAABwBBsILBAAsBSABwCXByb2R1Y2VycwIIbGFuZ3Vh +Z2UBBFJ1c3QADHByb2Nlc3NlZC1ieQMFcnVzdGMdMS44Ny4wICgxNzA2N2U5YWMgMjAyNS0wNS0w +OSkGd2FscnVzBjAuMjMuMwx3YXNtLWJpbmRnZW4HMC4yLjEwMABrD3RhcmdldF9mZWF0dXJlcwYr +D211dGFibGUtZ2xvYmFscysTbm9udHJhcHBpbmctZnB0b2ludCsLYnVsay1tZW1vcnkrCHNpZ24t +ZXh0Kw9yZWZlcmVuY2UtdHlwZXMrCm11bHRpdmFsdWU= `) .trim() .replaceAll("\n", ""); diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.d.ts b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.d.ts index f065297e0d..f801c69db8 100644 --- a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.d.ts +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.d.ts @@ -8,6 +8,7 @@ export const chunker_finish: (a: number) => [number, number, number]; export const compute_xorb_hash: (a: any) => [number, number, number, number]; export const compute_file_hash: (a: any) => [number, number, number, number]; export const compute_verification_hash: (a: number, b: number) => [number, number, number, number]; +export const compute_hmac: (a: number, b: number, c: number, d: number) => [number, number, number, number]; export const __wbindgen_malloc: (a: number, b: number) => number; export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number; export const __wbindgen_exn_store: (a: number) => void; From 433284e81fa538af1d997b611b332e0f65471d4d Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Thu, 31 Jul 2025 23:25:04 +0200 Subject: [PATCH 26/43] add bench script --- packages/hub/package.json | 3 +- packages/hub/scripts/bench.ts | 243 ++++++++++++++++++ packages/hub/scripts/build-xet-wasm.sh | 7 +- .../xet-chunk/chunker_wasm_bg.wasm.base64.ts | 13 +- 4 files changed, 256 insertions(+), 10 deletions(-) create mode 100644 packages/hub/scripts/bench.ts diff --git a/packages/hub/package.json b/packages/hub/package.json index 4520cbc402..e110a5a059 100644 --- a/packages/hub/package.json +++ b/packages/hub/package.json @@ -42,7 +42,8 @@ "test": "vitest run", "test:browser": "vitest run --browser.name=chrome --browser.headless --config vitest-browser.config.mts", "check": "tsc", - "build:xet-wasm": "./scripts/build-xet-wasm.sh -t bundler --clean -b hmac-wasm" + "build:xet-wasm": "./scripts/build-xet-wasm.sh -t bundler --clean", + "bench": "tsx scripts/bench.ts" }, "files": [ "src", diff --git a/packages/hub/scripts/bench.ts b/packages/hub/scripts/bench.ts new file mode 100644 index 0000000000..c3c4b97809 --- /dev/null +++ b/packages/hub/scripts/bench.ts @@ -0,0 +1,243 @@ +import { uploadShards } from "../src/utils/uploadShards.js"; +import { sha256 } from "../src/utils/sha256.js"; +import { parseArgs } from "node:util"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { writeFile, readFile, stat, mkdir } from "node:fs/promises"; +import type { RepoId } from "../src/types/public.js"; + +const FILES_TO_DOWNLOAD = [ + { + url: "https://huggingface.co/openai-community/gpt2/resolve/main/64-8bits.tflite?download=true", + filename: "64-8bits.tflite", + }, + { + url: "https://huggingface.co/openai-community/gpt2/resolve/main/64-fp16.tflite?download=true", + filename: "64-fp16.tflite", + }, +]; + +async function downloadFileIfNotExists(url: string, filepath: string): Promise { + try { + await stat(filepath); + console.log(`File ${filepath} already exists, skipping download`); + return; + } catch { + // File doesn't exist, proceed with download + } + + console.log(`Downloading ${url} to ${filepath}...`); + const response = await fetch(url); + if (!response.ok) { + throw new Error(`Failed to download ${url}: ${response.status} ${response.statusText}`); + } + + const buffer = await response.arrayBuffer(); + await writeFile(filepath, new Uint8Array(buffer)); + console.log(`Downloaded ${filepath} (${buffer.byteLength} bytes)`); +} + +async function* createFileSource( + files: Array<{ filepath: string; filename: string }> +): AsyncGenerator<{ content: Blob; path: string; sha256: string }> { + for (const file of files) { + console.log(`Processing ${file.filename}...`); + const buffer = await readFile(file.filepath); + const blob = new Blob([buffer]); + + // Calculate sha256 + console.log(`Calculating SHA256 for ${file.filename}...`); + const sha256Iterator = sha256(blob, { useWebWorker: false }); + let res: IteratorResult; + do { + res = await sha256Iterator.next(); + } while (!res.done); + const sha256Hash = res.value; + + console.log(`SHA256 for ${file.filename}: ${sha256Hash}`); + yield { + content: blob, + path: file.filename, + sha256: sha256Hash, + }; + } +} + +function getBodySize(body: RequestInit["body"]): string { + if (!body) { + return "no body"; + } + if (body instanceof ArrayBuffer) { + return body.byteLength.toString(); + } + if (body instanceof Blob) { + return "blob"; + } + if (body instanceof Uint8Array) { + return body.byteLength.toString(); + } + return "unknown size"; +} + +function createMockFetch(): typeof fetch { + let uploadCount = 0; + + return async function mockFetch(input: string | URL | Request, init?: RequestInit): Promise { + const url = typeof input === "string" ? input : input.toString(); + + // Mock successful responses for xorb and shard uploads + if (url.includes("/xorb/") || url.includes("/shard/")) { + uploadCount++; + const bodySize = getBodySize(init?.body); + console.log(`[MOCK] Upload ${uploadCount}: ${init?.method || "GET"} ${url} (${bodySize})`); + + return new Response(null, { + status: 200, + statusText: "OK", + }); + } + + // For other requests, use real fetch + return fetch(input, init); + }; +} + +async function main() { + const { values: args } = parseArgs({ + options: { + token: { + type: "string", + short: "t", + }, + repo: { + type: "string", + short: "r", + }, + }, + }); + + if (!args.token || !args.repo) { + console.error("Usage: node bench.ts --token --repo "); + console.error("Example: node bench.ts --token hf_... --repo myuser/myrepo"); + process.exit(1); + } + + // Setup temp directory + const tempDir = tmpdir(); + const downloadDir = join(tempDir, "hf-bench-downloads"); + + // Ensure download directory exists + await mkdir(downloadDir, { recursive: true }); + + // Download files + const files: Array<{ filepath: string; filename: string }> = []; + + for (const fileInfo of FILES_TO_DOWNLOAD) { + const filepath = join(downloadDir, fileInfo.filename); + await downloadFileIfNotExists(fileInfo.url, filepath); + files.push({ filepath, filename: fileInfo.filename }); + } + + // Parse repo + const repoName = args.repo; + + const repo: RepoId = { + type: "model", + name: repoName, + }; + + // Create mock fetch + const mockFetch = createMockFetch(); + + // Setup upload parameters + const uploadParams = { + accessToken: args.token, + hubUrl: "https://huggingface.co", + customFetch: mockFetch, + repo, + rev: "main", + }; + + // Track statistics + const stats: Array<{ + filename: string; + size: number; + xorbCount: number; + shardCount: number; + dedupRatio: number; + }> = []; + + console.log("\n=== Starting upload simulation ==="); + + // Process files through uploadShards + const fileSource = createFileSource(files); + + for await (const event of uploadShards(fileSource, uploadParams)) { + switch (event.event) { + case "file": { + console.log(`\nšŸ“ Processed file: ${event.path}`); + console.log(` SHA256: ${event.sha256}`); + console.log(` Dedup ratio: ${(event.dedupRatio * 100).toFixed(2)}%`); + + // Find the file size + const file = files.find((f) => f.filename === event.path); + if (file) { + const fileStats = await stat(file.filepath); + + stats.push({ + filename: event.path, + size: fileStats.size, + xorbCount: 0, // Will be updated later + shardCount: 0, // Will be updated later + dedupRatio: event.dedupRatio, + }); + } + break; + } + + case "fileProgress": { + const progress = (event.progress * 100).toFixed(1); + console.log(` šŸ“ˆ Progress for ${event.path}: ${progress}%`); + break; + } + } + } + + // Note: xorb and shard counts are tracked internally by uploadShards + // For this demo, we'll make reasonable estimates based on file sizes + for (const stat of stats) { + // Rough estimates - in real usage these would come from the upload process + stat.xorbCount = Math.ceil(stat.size / (64 * 1024 * 1024)); // 64MB xorbs + stat.shardCount = Math.max(1, Math.ceil(stat.xorbCount / 100)); // Rough shard estimation + } + + // Output final statistics + console.log("\n=== BENCHMARK RESULTS ==="); + console.log("File Statistics:"); + console.log("================"); + + for (const stat of stats) { + console.log(`\nšŸ“„ ${stat.filename}:`); + console.log(` Size: ${(stat.size / 1024 / 1024).toFixed(2)} MB`); + console.log(` Xorbs: ${stat.xorbCount}`); + console.log(` Shards: ${stat.shardCount}`); + console.log(` Deduplication: ${(stat.dedupRatio * 100).toFixed(2)}%`); + } + + console.log("\n=== SUMMARY ==="); + const totalSize = stats.reduce((sum, s) => sum + s.size, 0); + const totalXorbs = stats.reduce((sum, s) => sum + s.xorbCount, 0); + const totalShards = stats.reduce((sum, s) => sum + s.shardCount, 0); + const avgDedup = stats.reduce((sum, s) => sum + s.dedupRatio, 0) / stats.length; + + console.log(`Total files: ${stats.length}`); + console.log(`Total size: ${(totalSize / 1024 / 1024).toFixed(2)} MB`); + console.log(`Total xorbs: ${totalXorbs}`); + console.log(`Total shards: ${totalShards}`); + console.log(`Average deduplication: ${(avgDedup * 100).toFixed(2)}%`); +} + +main().catch((error) => { + console.error("Error:", error); + process.exit(1); +}); diff --git a/packages/hub/scripts/build-xet-wasm.sh b/packages/hub/scripts/build-xet-wasm.sh index 6ef145714a..0c4bac670e 100755 --- a/packages/hub/scripts/build-xet-wasm.sh +++ b/packages/hub/scripts/build-xet-wasm.sh @@ -229,9 +229,10 @@ echo "// Generated by build-xet-wasm.sh" > "./src/vendor/xet-chunk/chunker_wasm_ echo "export const wasmBase64 = atob(\`" >> "./src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts" base64 "$CLONE_DIR/$PACKAGE/pkg/hf_xet_thin_wasm_bg.wasm" | fold -w 100 >> "./src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts" cat << 'EOF' >> "./src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts" -`) - .trim() - .replaceAll("\n", ""); +` + .trim() + .replaceAll("\n", "") +); const wasmBinary = new Uint8Array(wasmBase64.length); for (let i = 0; i < wasmBase64.length; i++) { wasmBinary[i] = wasmBase64.charCodeAt(i); diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts index 98a1f0d130..e359e1161c 100644 --- a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts @@ -54,7 +54,7 @@ cHV0ZV9maWxlX2hhc2gAogEZY29tcHV0ZV92ZXJpZmljYXRpb25faGFzaACfAQxjb21wdXRlX2ht YWMAngERX193YmluZGdlbl9tYWxsb2MAnAESX193YmluZGdlbl9yZWFsbG9jAKUBFF9fd2JpbmRn ZW5fZXhuX3N0b3JlAMoBF19fZXh0ZXJucmVmX3RhYmxlX2FsbG9jAHATX193YmluZGdlbl9leHBv cnRfNAEBGV9fZXh0ZXJucmVmX3RhYmxlX2RlYWxsb2MAbQ9fX3diaW5kZ2VuX2ZyZWUAvwEQX193 -YmluZGdlbl9zdGFydAAnCb4BAQBBAQto3gHfAYQBvgG1AYwBTuEB2wHgAfEB8AHdAdwBwgE4xAHi +YmluZGdlbl9zdGFydAAnCb4BAQBBAQto3gHfAYQBvgG1AYwBTuEB2wHgAfEB8AHcAd0BwgE4xAHi AbUBjAFPwgFzmgGqAXGpAaoBpgGxAa8BqQGpAasBrAGtAbIBgQF69gH3AYcBiwFdpwFsiAGPAV5v 4wGYAcYBxwHUAX55yAHEAYoBsAHaAagBZVnJAZYBYrQB5AHIAbkB2AGCAbUBjQFU6AHMAcsBzgGV Ac0B6QGuAXxaa/IBtQGRAVPqAesBwAHCAc8B0AE7d1w+kwHtAQwBDgra+QTQAYkbASB/IAAgACgC @@ -305,7 +305,7 @@ AEEwayIDJAAgA0HciMAANgIEIAMgAkHPAGo2AgAgA0ECNgIMIANBiI/AADYCCCADQgI3AhQgAyAD rUKAgICA8AGENwMoIAMgAkE4aq1CgICAgIAChDcDICADIANBIGo2AhAgA0EIahBjIQQgA0EwaiQA QQEMAQsgDqchBEEACyACKAIkIgVBhAFPBEAgBRBtC0EBIQlFDQIMAQtB4YrAAEEGEIYBIQQLIABB gICAgHg2AgAgACAENgIEIAFBgICAgHhyQYCAgIB4Rg0EIAYgARDRAQwECyACKAIYIgMgAigCHEcN -AAsMAQsgAkEMaiACQc8AakGcisAAEEIhBCAAQYCAgIB4NgIAIAAgBDYCBCABQYQBSQ0CIAEQbQwC +AAsMAQsgAkEMaiACQc8AakGMisAAEEIhBCAAQYCAgIB4NgIAIAAgBDYCBCABQYQBSQ0CIAEQbQwC CyABQYCAgIB4RwRAIAkEQCAAIAQ2AgwgACANNgIIIAAgBjYCBCAAIAE2AgAMAgtB4YrAAEEGEIUB IQQgAEGAgICAeDYCACAAIAQ2AgQgAUUNASAGIAEQ0QEMAQtB3YrAAEEEEIUBIQEgAEGAgICAeDYC ACAAIAE2AgQLIAIoAiAiAEGEAU8EQCAAEG0LIAIoAhBFDQAgAigCFCIAQYMBTQ0AIAAQbQsgAkHQ @@ -327,7 +327,7 @@ QCABKAIAIgAEQCABQQRqKAIAIAAQ0QELIAFBEGohASADQQFrIgMNAAsLIAIoAiQiAARAIAIoAigg AEEEdBDRAQsgAigCNCIBQYMBSw0DDAcLIAIpAkghCCACKAIsIgMgAigCJEYEQCACQSRqEGkLIAIo AiggA0EEdGoiBCAINwIIIAQgATYCBCAEIAU2AgAgAiADQQFqNgIsIAJBEGogAkE0ahB7IAIoAhQh ASACKAIQIgNBAkcNAAsLIAAgAikCJDcCACAAQQhqIAJBLGooAgA2AgAgAigCNCIBQYMBTQ0ECyAB -EG0MAwsgAkEgaiACQUBrQYyKwAAQQiEBIABBgICAgHg2AgAgACABNgIEDAILIAJBADYCPCACIAM2 +EG0MAwsgAkEgaiACQUBrQZyKwAAQQiEBIABBgICAgHg2AgAgACABNgIEDAILIAJBADYCPCACIAM2 AjggAiABNgI0A0AgAkEIaiEDIAJBJGoiASgCBCIEIAEoAghPBH9BAAUgASAEQQFqNgIEIAEoAgAo AgAlASAEEA8hCRBwIgEgCSYBQQELIQQgAyABNgIEIAMgBDYCACACKAIIQQFxRQ0BIAIoAgwhASAC IAIoAjBBAWo2AjAgAkFAayABEC4gAigCRCEBIAIoAkAiBUGAgICAeEYEQCAAQYCAgIB4NgIAIAAg @@ -1777,9 +1777,10 @@ Z2UBBFJ1c3QADHByb2Nlc3NlZC1ieQMFcnVzdGMdMS44Ny4wICgxNzA2N2U5YWMgMjAyNS0wNS0w OSkGd2FscnVzBjAuMjMuMwx3YXNtLWJpbmRnZW4HMC4yLjEwMABrD3RhcmdldF9mZWF0dXJlcwYr D211dGFibGUtZ2xvYmFscysTbm9udHJhcHBpbmctZnB0b2ludCsLYnVsay1tZW1vcnkrCHNpZ24t ZXh0Kw9yZWZlcmVuY2UtdHlwZXMrCm11bHRpdmFsdWU= -`) - .trim() - .replaceAll("\n", ""); +` + .trim() + .replaceAll("\n", "") +); const wasmBinary = new Uint8Array(wasmBase64.length); for (let i = 0; i < wasmBase64.length; i++) { wasmBinary[i] = wasmBase64.charCodeAt(i); From 74dfb714f71520efcdbc3c2bd7b19c8fee638d9d Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Thu, 31 Jul 2025 23:26:47 +0200 Subject: [PATCH 27/43] fix wasm instantiation --- packages/hub/src/vendor/xet-chunk/chunker_wasm.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts b/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts index 39d4ed87cf..4ce742d130 100644 --- a/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts @@ -33,7 +33,7 @@ async function init(): Promise { ) ).map(([from, names]) => ({ from, names })); const wasm = await WebAssembly.instantiate(wasmModule, { - "./chunker_wasm_bg.js": Object.fromEntries( + "./hf_xet_thin_wasm_bg.js": Object.fromEntries( // @ts-expect-error ok for any type (imports[0].names as string[]).map((name) => [name, __glue_imports[name]]) ), From b19209f0fe6c7a54b4aad9b4fcb04e4f2a5ab696 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Fri, 1 Aug 2025 00:53:36 +0200 Subject: [PATCH 28/43] fix api calls --- packages/hub/scripts/bench.ts | 6 ++---- packages/hub/src/utils/xetWriteToken.ts | 1 - 2 files changed, 2 insertions(+), 5 deletions(-) diff --git a/packages/hub/scripts/bench.ts b/packages/hub/scripts/bench.ts index c3c4b97809..1fccb3b260 100644 --- a/packages/hub/scripts/bench.ts +++ b/packages/hub/scripts/bench.ts @@ -5,6 +5,7 @@ import { tmpdir } from "node:os"; import { join } from "node:path"; import { writeFile, readFile, stat, mkdir } from "node:fs/promises"; import type { RepoId } from "../src/types/public.js"; +import { toRepoId } from "../src/utils/toRepoId.js"; const FILES_TO_DOWNLOAD = [ { @@ -141,10 +142,7 @@ async function main() { // Parse repo const repoName = args.repo; - const repo: RepoId = { - type: "model", - name: repoName, - }; + const repo: RepoId = toRepoId(repoName); // Create mock fetch const mockFetch = createMockFetch(); diff --git a/packages/hub/src/utils/xetWriteToken.ts b/packages/hub/src/utils/xetWriteToken.ts index db8077c5f4..05db4ee859 100644 --- a/packages/hub/src/utils/xetWriteToken.ts +++ b/packages/hub/src/utils/xetWriteToken.ts @@ -48,7 +48,6 @@ export async function xetWriteToken(params: XetWriteTokenParams): Promise<{ acce const resp = await params.customFetch( `${params.hubUrl}/api/${params.repo.type}s/${params.repo.name}/xet-write-token/${params.rev}`, { - method: "POST", headers: params.accessToken ? { Authorization: `Bearer ${params.accessToken}`, From 6d03446097506349e7be2d204c2bb753a89adfd8 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Fri, 1 Aug 2025 14:11:13 +0200 Subject: [PATCH 29/43] use custom fetch for chunk call --- packages/hub/scripts/bench.ts | 5 ++++- packages/hub/src/utils/createXorbs.ts | 2 +- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/packages/hub/scripts/bench.ts b/packages/hub/scripts/bench.ts index 1fccb3b260..1ffe5f21c9 100644 --- a/packages/hub/scripts/bench.ts +++ b/packages/hub/scripts/bench.ts @@ -99,7 +99,10 @@ function createMockFetch(): typeof fetch { } // For other requests, use real fetch - return fetch(input, init); + return fetch(input, init).then((res) => { + console.log(`[real] ${res.status} ${res.statusText} ${url} ${res.headers.get("content-length")}`); + return res; + }); }; } diff --git a/packages/hub/src/utils/createXorbs.ts b/packages/hub/src/utils/createXorbs.ts index 6a70cc540f..cd8e8d0ec5 100644 --- a/packages/hub/src/utils/createXorbs.ts +++ b/packages/hub/src/utils/createXorbs.ts @@ -140,7 +140,7 @@ export async function* createXorbs( const token = await xetWriteToken(params); bytesSinceRemoteDedup = 0; - const shardResp = await fetch(token.casUrl + "/v1/chunk/" + chunk.hash); + const shardResp = await params.customFetch(token.casUrl + "/v1/chunk/" + chunk.hash); // todo: handle non-404 non-429 errors, eg throw error if (shardResp.ok) { From 627f02421a03e912360def6c50a925b1b786bf47 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Fri, 1 Aug 2025 14:15:13 +0200 Subject: [PATCH 30/43] correct global dedup call --- packages/hub/src/utils/createXorbs.ts | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/packages/hub/src/utils/createXorbs.ts b/packages/hub/src/utils/createXorbs.ts index cd8e8d0ec5..81b60113a8 100644 --- a/packages/hub/src/utils/createXorbs.ts +++ b/packages/hub/src/utils/createXorbs.ts @@ -140,7 +140,11 @@ export async function* createXorbs( const token = await xetWriteToken(params); bytesSinceRemoteDedup = 0; - const shardResp = await params.customFetch(token.casUrl + "/v1/chunk/" + chunk.hash); + const shardResp = await params.customFetch(token.casUrl + "/v1/chunk/default/" + chunk.hash, { + headers: { + Authorization: `Bearer ${token.accessToken}`, + }, + }); // todo: handle non-404 non-429 errors, eg throw error if (shardResp.ok) { From e2fd1c13b3f8292d0dcc3f585b431d9be8a0d128 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Fri, 1 Aug 2025 18:17:48 +0200 Subject: [PATCH 31/43] fixes and add a shard file for tests --- packages/hub/src/utils/shardParser.spec.ts | 33 +++++++ packages/hub/src/utils/shardParser.ts | 89 +++++++++++++----- packages/hub/src/utils/uploadShards.ts | 35 +++++-- packages/hub/tests/gpt2-64-8bits.tflite.shard | Bin 0 -> 102104 bytes packages/hub/vitest-browser.config.mts | 2 + 5 files changed, 126 insertions(+), 33 deletions(-) create mode 100644 packages/hub/src/utils/shardParser.spec.ts create mode 100644 packages/hub/tests/gpt2-64-8bits.tflite.shard diff --git a/packages/hub/src/utils/shardParser.spec.ts b/packages/hub/src/utils/shardParser.spec.ts new file mode 100644 index 0000000000..de764b6ebe --- /dev/null +++ b/packages/hub/src/utils/shardParser.spec.ts @@ -0,0 +1,33 @@ +import { parseShardData } from "./shardParser"; +import { readFile } from "fs/promises"; +import { expect, describe, it } from "vitest"; +import { init, compute_hmac } from "../vendor/xet-chunk/chunker_wasm"; + +describe("shardParser", () => { + it("should parse a shard", async () => { + const shard = await parseShardData(new Blob([await readFile("tests/gpt2-64-8bits.tflite.shard")])); + // console.log(inspect(shard, { depth: null })); + expect(shard.xorbs.length).toBeGreaterThan(2); + + console.log("xorbs", shard.xorbs.length); + + // const firstXorb = shard.xorbs[0]; + // const secondXorb = shard.xorbs[1]; + + // console.log(firstXorb.chunks.slice(0, 10)); + // console.log(secondXorb.chunks.slice(0, 10)); + + expect(shard.hmacKey).toBe("16af3a84044b83d6be998a42e20399f2cc5650eaf99950639f50418aece7954e"); + + await init(); + + const chunkHash = "9502eec19d4b0c9f7b389228fa801f68ecdf15d69ccd1da2f9ddbd0219898335"; + const xorb = shard.xorbs.find((xorb) => + xorb.chunks.some((chunk) => compute_hmac(chunk.hash, shard.hmacKey) === chunkHash) + ); + expect(xorb).toBeDefined(); + expect(xorb?.chunks.length).toBe(1); + expect(xorb?.chunks[0].startOffset).toBe(0); + expect(xorb?.chunks[0].unpackedLength).toBe(1024); + }); +}); diff --git a/packages/hub/src/utils/shardParser.ts b/packages/hub/src/utils/shardParser.ts index 99fa584f33..c63b960394 100644 --- a/packages/hub/src/utils/shardParser.ts +++ b/packages/hub/src/utils/shardParser.ts @@ -1,6 +1,7 @@ -const SHARD_FOOTER_SIZE = 192; +import { SHARD_FOOTER_VERSION, SHARD_HEADER_VERSION, SHARD_MAGIC_TAG } from "./uploadShards"; + const HASH_LENGTH = 32; -const XORB_FOOTER_LENGTH = 48; +const XORB_HASH_BOOKEND = "ff".repeat(HASH_LENGTH); function readHashFromArray(array: Uint8Array, offset: number): string { let hash = ""; @@ -17,8 +18,7 @@ export interface ShardData { chunks: Array<{ hash: string; startOffset: number; - endOffset: number; - length: number; + unpackedLength: number; }>; }>; } @@ -27,53 +27,95 @@ export async function parseShardData(shardBlob: Blob): Promise { const shard = new Uint8Array(await shardBlob.arrayBuffer()); const shardView = new DataView(shard.buffer); + const magicTag = shard.slice(0, SHARD_MAGIC_TAG.length); + if (!magicTag.every((byte, i) => byte === SHARD_MAGIC_TAG[i])) { + throw new Error("Invalid shard magic tag"); + } + + const version = shardView.getBigUint64(SHARD_MAGIC_TAG.length, true); + if (version !== SHARD_HEADER_VERSION) { + throw new Error(`Invalid shard version: ${version}`); + } + + const footerSize = Number(shardView.getBigUint64(SHARD_MAGIC_TAG.length + 8, true)); + // Read footer to get section offsets - const footerStart = shard.length - SHARD_FOOTER_SIZE; + const footerStart = shard.length - footerSize; + const footerVersion = shardView.getBigUint64(footerStart, true); + if (footerVersion !== SHARD_FOOTER_VERSION) { + throw new Error(`Invalid shard footer version: ${footerVersion}`); + } + + // version: u64, // Footer version (must be 1) + // file_info_offset: u64, // Offset to file info section + // cas_info_offset: u64, // Offset to CAS info section + // file_lookup_offset: u64, // Offset to file lookup table + // file_lookup_num_entry: u64, // Number of file lookup entries + // cas_lookup_offset: u64, // Offset to CAS lookup table + // cas_lookup_num_entry: u64, // Number of CAS lookup entries + // chunk_lookup_offset: u64, // Offset to chunk lookup table + // chunk_lookup_num_entry: u64, // Number of chunk lookup entries + // chunk_hash_hmac_key: [u64; 4], // HMAC key for chunk hashes (32 bytes) + // shard_creation_timestamp: u64, // Creation time (seconds since epoch) + // shard_key_expiry: u64, // Expiry time (seconds since epoch) + // _buffer: [u64; 6], // Reserved space (48 bytes) + // stored_bytes_on_disk: u64, // Total bytes stored on disk + // materialized_bytes: u64, // Total materialized bytes + // stored_bytes: u64, // Total stored bytes + // footer_offset: u64, + + // const fileInfoStart = Number(shardView.getBigUint64(footerStart + 8, true)); const xorbInfoStart = Number(shardView.getBigUint64(footerStart + 16, true)); const fileLookupStart = Number(shardView.getBigUint64(footerStart + 24, true)); - - // Extract HMAC from footer (32 bytes starting at offset 112 from footer start) - const hmacKey = readHashFromArray(shard, footerStart + 112); + // const numFileLookups = Number(shardView.getBigUint64(footerStart + 32, true)); + // const xorbLookupStart = Number(shardView.getBigUint64(footerStart + 40, true)); + // const numXorbLookups = Number(shardView.getBigUint64(footerStart + 48, true)); + // const chunkLookupStart = Number(shardView.getBigUint64(footerStart + 56, true)); + // const numChunkLookups = Number(shardView.getBigUint64(footerStart + 64, true)); + const hmacKey = readHashFromArray(shard, footerStart + 72); + // const shardCreationTimestamp = Number(shardView.getBigUint64(footerStart + 104, true)); + // const shardKeyExpiry = Number(shardView.getBigUint64(footerStart + 112, true)); + // const storedBytesOnDisk = Number(shardView.getBigUint64(footerStart + 168, true)); + // const materializedBytes = Number(shardView.getBigUint64(footerStart + 176, true)); + // const storedBytes = Number(shardView.getBigUint64(footerStart + 184, true)); + // const footerOffset = Number(shardView.getBigUint64(footerStart + 192, true)); // Parse XORB Info Section const xorbs: ShardData["xorbs"] = []; let offset = xorbInfoStart; - while (offset < fileLookupStart - XORB_FOOTER_LENGTH) { - // Check if we've hit the xorb info bookend (32 bytes of 0xff) - if (shard[offset] === 0xff) { - break; - } - + while (offset < fileLookupStart) { // Read xorb entry const xorbHash = readHashFromArray(shard, offset); offset += HASH_LENGTH; - // Skip flags (4 bytes) + if (xorbHash === XORB_HASH_BOOKEND) { + break; + } + + // const flags = shardView.getUint32(offset, true); offset += 4; const chunkCount = shardView.getUint32(offset, true); offset += 4; - // Skip unpackedSize (4 bytes) + // const numBytesInXorb = shardView.getUint32(offset, true); offset += 4; - // Skip packedSize (4 bytes) + // const numBytesUnpacked = shardView.getUint32(offset, true); offset += 4; // Read chunks for this xorb - const chunks: ShardData["xorbs"][0]["chunks"] = []; + const chunks: ShardData["xorbs"][number]["chunks"] = []; for (let i = 0; i < chunkCount; i++) { const chunkHash = readHashFromArray(shard, offset); offset += HASH_LENGTH; - const length = shardView.getUint32(offset, true); - offset += 4; - const startOffset = shardView.getUint32(offset, true); offset += 4; - const endOffset = startOffset + length; + const length = shardView.getUint32(offset, true); + offset += 4; // Skip reserved 8 bytes offset += 8; @@ -81,8 +123,7 @@ export async function parseShardData(shardBlob: Blob): Promise { chunks.push({ hash: chunkHash, startOffset, - endOffset, - length, + unpackedLength: length, }); } diff --git a/packages/hub/src/utils/uploadShards.ts b/packages/hub/src/utils/uploadShards.ts index d15f865e45..2b3ffe2eee 100644 --- a/packages/hub/src/utils/uploadShards.ts +++ b/packages/hub/src/utils/uploadShards.ts @@ -10,13 +10,13 @@ const SHARD_FOOTER_SIZE = 192; const HASH_LENGTH = 32; const XORB_FOOTER_LENGTH = 48; const FILE_FOOTER_LENGTH = 48; -const SHARD_HEADER_VERSION = 2n; -const SHARD_FOOTER_VERSION = 1n; +export const SHARD_HEADER_VERSION = 2n; +export const SHARD_FOOTER_VERSION = 1n; const MDB_FILE_FLAG_WITH_VERIFICATION = 0x80000000; // Cannot define as 1 << 31 because it becomes a negative number const MDB_FILE_FLAG_WITH_METADATA_EXT = 0x40000000; -const SHARD_MAGIC_TAG = new Uint8Array([ +export const SHARD_MAGIC_TAG = new Uint8Array([ "H".charCodeAt(0), "F".charCodeAt(0), "R".charCodeAt(0), @@ -51,8 +51,6 @@ const SHARD_MAGIC_TAG = new Uint8Array([ 169, ]); -writeHashToArray("0".repeat(64), SHARD_MAGIC_TAG, 0); - interface UploadShardsParams { accessToken: string | undefined; hubUrl: string; @@ -120,10 +118,10 @@ export async function* uploadShards( for (const chunk of output.chunks) { writeHashToArray(chunk.hash, xorbInfoSection, xorbViewOffset); xorbViewOffset += HASH_LENGTH; - xorbView.setUint32(xorbViewOffset, chunk.length, true); - xorbViewOffset += 4; xorbView.setUint32(xorbViewOffset, chunk.offset, true); xorbViewOffset += 4; + xorbView.setUint32(xorbViewOffset, chunk.length, true); + xorbViewOffset += 4; xorbView.setBigUint64(xorbViewOffset, 0n, true); // reserved xorbViewOffset += 8; } @@ -254,9 +252,29 @@ export async function* uploadShards( shardOffset += 16; // Footer + const footerOffset = shardOffset; + + // version: u64, // Footer version (must be 1) + // file_info_offset: u64, // Offset to file info section + // cas_info_offset: u64, // Offset to CAS info section + // file_lookup_offset: u64, // Offset to file lookup table + // file_lookup_num_entry: u64, // Number of file lookup entries + // cas_lookup_offset: u64, // Offset to CAS lookup table + // cas_lookup_num_entry: u64, // Number of CAS lookup entries + // chunk_lookup_offset: u64, // Offset to chunk lookup table + // chunk_lookup_num_entry: u64, // Number of chunk lookup entries + // chunk_hash_hmac_key: [u64; 4], // HMAC key for chunk hashes (32 bytes) + // shard_creation_timestamp: u64, // Creation time (seconds since epoch) + // shard_key_expiry: u64, // Expiry time (seconds since epoch) + // _buffer: [u64; 6], // Reserved space (48 bytes) + // stored_bytes_on_disk: u64, // Total bytes stored on disk + // materialized_bytes: u64, // Total materialized bytes + // stored_bytes: u64, // Total stored bytes + // footer_offset: u64, + shardView.setBigUint64(shardOffset, SHARD_FOOTER_VERSION, true); shardOffset += 8; - shardView.setBigUint64(shardOffset, BigInt(SHARD_HEADER_SIZE), true); // begging of fileinfo section + shardView.setBigUint64(shardOffset, BigInt(SHARD_HEADER_SIZE), true); // beginning of fileinfo section shardOffset += 8; shardView.setBigUint64(shardOffset, BigInt(SHARD_FOOTER_SIZE + fileInfoSection.byteLength), true); // beginning of xorbinfo section shardOffset += 8; @@ -279,7 +297,6 @@ export async function* uploadShards( shardOffset += 8; // Footer - const footerOffset = shardOffset; shardView.setBigUint64( shardOffset, BigInt(SHARD_FOOTER_SIZE + fileInfoSection.byteLength + xorbInfoSection.byteLength + 16), diff --git a/packages/hub/tests/gpt2-64-8bits.tflite.shard b/packages/hub/tests/gpt2-64-8bits.tflite.shard new file mode 100644 index 0000000000000000000000000000000000000000..efa57c86539b023d99583cd7dbab43966cabcf37 GIT binary patch literal 102104 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 BI7k2h literal 0 HcmV?d00001 diff --git a/packages/hub/vitest-browser.config.mts b/packages/hub/vitest-browser.config.mts index e9bc06b024..31ca1abe61 100644 --- a/packages/hub/vitest-browser.config.mts +++ b/packages/hub/vitest-browser.config.mts @@ -14,6 +14,8 @@ export default defineConfig({ "src/lib/upload-files.fs.spec.ts", // Because we use redirect: "manual" in the test "src/lib/oauth-handle-redirect.spec.ts", + // Because we use a local file + "src/utils/shardParser.spec.ts", ], }, }); From 29eaef7504fd3782c9714f3180eefced1dcf0886 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Fri, 1 Aug 2025 18:27:22 +0200 Subject: [PATCH 32/43] more recent target for tsup --- packages/hub/tsup.config.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/hub/tsup.config.ts b/packages/hub/tsup.config.ts index adbb9fdfbd..50d667c77a 100644 --- a/packages/hub/tsup.config.ts +++ b/packages/hub/tsup.config.ts @@ -16,7 +16,7 @@ const nodeConfig: Options = { const browserConfig: Options = { ...baseConfig, platform: "browser", - target: "es2018", + target: "es2022", splitting: true, outDir: "dist/browser", }; From c6f922fd48f37acbba99a864d9dedf0502a46495 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Fri, 1 Aug 2025 18:50:10 +0200 Subject: [PATCH 33/43] fixes with xet protocol --- packages/hub/src/utils/ChunkCache.ts | 34 +++++------------ packages/hub/src/utils/createXorbs.ts | 51 +++++++++++--------------- packages/hub/src/utils/uploadShards.ts | 10 +++-- 3 files changed, 37 insertions(+), 58 deletions(-) diff --git a/packages/hub/src/utils/ChunkCache.ts b/packages/hub/src/utils/ChunkCache.ts index 0fe6d492a5..d95b322e90 100644 --- a/packages/hub/src/utils/ChunkCache.ts +++ b/packages/hub/src/utils/ChunkCache.ts @@ -6,18 +6,12 @@ export class ChunkCache { index = 0; // Index >= 0 means local xorb, < 0 means remote xorb xorbIndices = new Int32Array(CHUNK_CACHE_INITIAL_SIZE); - chunkOffsets = new Uint32Array(CHUNK_CACHE_INITIAL_SIZE); - chunkEndOffsets = new Uint32Array(CHUNK_CACHE_INITIAL_SIZE); + // Max 8K chunks per xorb, less than 64K uint16_t + chunkIndices = new Uint16Array(CHUNK_CACHE_INITIAL_SIZE); map = new Map(); // hash -> chunkCacheIndex. Less overhead that way, empty object is 60+B and empty array is 40+B hmacs = new Set(); // todo : remove old hmacs - addChunkToCache( - hash: string, - xorbIndex: number, - chunkOffset: number, - chunkEndOffset: number, - hmac: string | null - ): void { + addChunkToCache(hash: string, xorbIndex: number, chunkIndex: number, hmac: string | null): void { this.map.set(hash, this.index); if (hmac !== null) { this.hmacs.add(hmac); @@ -26,25 +20,19 @@ export class ChunkCache { if (this.index >= this.xorbIndices.length) { // todo: switch to resize() with modern browsers const oldXorbIndices = this.xorbIndices; - const oldChunkOffsets = this.chunkOffsets; - const oldChunkLengths = this.chunkEndOffsets; + const oldChunkIndices = this.chunkIndices; this.xorbIndices = new Int32Array( Math.min(this.xorbIndices.length * CHUNK_CACHE_GROW_FACTOR, CHUNK_CACHE_MAX_SIZE) ); - this.chunkOffsets = new Uint32Array( - Math.min(this.chunkOffsets.length * CHUNK_CACHE_GROW_FACTOR, CHUNK_CACHE_MAX_SIZE) - ); - this.chunkEndOffsets = new Uint32Array( - Math.min(this.chunkEndOffsets.length * CHUNK_CACHE_GROW_FACTOR, CHUNK_CACHE_MAX_SIZE) + this.chunkIndices = new Uint16Array( + Math.min(this.chunkIndices.length * CHUNK_CACHE_GROW_FACTOR, CHUNK_CACHE_MAX_SIZE) ); this.xorbIndices.set(oldXorbIndices); - this.chunkOffsets.set(oldChunkOffsets); - this.chunkEndOffsets.set(oldChunkLengths); + this.chunkIndices.set(oldChunkIndices); } this.xorbIndices[this.index] = xorbIndex; - this.chunkOffsets[this.index] = chunkOffset; - this.chunkEndOffsets[this.index] = chunkEndOffset; + this.chunkIndices[this.index] = chunkIndex; this.index = (this.index + 1) % CHUNK_CACHE_MAX_SIZE; while (this.map.size > CHUNK_CACHE_MAX_SIZE) { @@ -59,8 +47,7 @@ export class ChunkCache { ): | { xorbIndex: number; - offset: number; - endOffset: number; + chunkIndex: number; } | undefined { let index = this.map.get(hash); @@ -77,8 +64,7 @@ export class ChunkCache { } return { xorbIndex: this.xorbIndices[index], - offset: this.chunkOffsets[index], - endOffset: this.chunkEndOffsets[index], + chunkIndex: this.chunkIndices[index], }; } } diff --git a/packages/hub/src/utils/createXorbs.ts b/packages/hub/src/utils/createXorbs.ts index 81b60113a8..b977b2ad78 100644 --- a/packages/hub/src/utils/createXorbs.ts +++ b/packages/hub/src/utils/createXorbs.ts @@ -26,7 +26,7 @@ export async function* createXorbs( xorb: Uint8Array; hash: string; id: number; - chunks: Array<{ hash: string; length: number; offset: number }>; + chunks: Array<{ hash: string; length: number }>; files: Array<{ path: string; progress: number; @@ -41,8 +41,8 @@ export async function* createXorbs( dedupRatio: number; representation: Array<{ xorbId: number | string; // either xorb id (for local xorbs) or xorb hash (for remote xorbs) - offset: number; - endOffset: number; + indexStart: number; + indexEnd: number; /** Unpacked length */ length: number; rangeHash: string; @@ -59,7 +59,7 @@ export async function* createXorbs( const chunkCache = new ChunkCache(); let xorb = new Uint8Array(XORB_SIZE); let xorbOffset = 0; - let xorbChunks = Array<{ hash: string; length: number; offset: number }>(); + let xorbChunks = Array<{ hash: string; length: number }>(); /** * path => 0..1 mapping of the current xorb * @@ -81,8 +81,8 @@ export async function* createXorbs( sha256: string; representation: Array<{ xorbId: number | string; - offset: number; - endOffset: number; + indexStart: number; + indexEnd: number; length: number; rangeHash: string; }>; @@ -102,16 +102,15 @@ export async function* createXorbs( let currentChunkRangeBeginning = 0; const fileRepresentation: Array<{ xorbId: number | string; - offset: number; - endOffset: number; + indexStart: number; + indexEnd: number; length: number; rangeHash: string; }> = []; const addChunks = async function* (chunks: Array<{ hash: string; length: number; dedup: boolean }>) { for (const chunk of chunks) { - let chunkOffset = xorbOffset; - let chunkEndOffset; + let chunkIndex = xorbChunks.length; let chunkXorbId = xorbId; fileChunks.push({ hash: chunk.hash, length: chunk.length }); @@ -154,14 +153,9 @@ export async function* createXorbs( for (const xorb of shardData.xorbs) { const remoteXorbId = -remoteXorbHashes.length; remoteXorbHashes.push(xorb.hash); + let i = 0; for (const chunk of xorb.chunks) { - chunkCache.addChunkToCache( - chunk.hash, - remoteXorbId, - chunk.startOffset, - chunk.endOffset, - shardData.hmacKey - ); + chunkCache.addChunkToCache(chunk.hash, remoteXorbId, i++, shardData.hmacKey); } } cacheData = chunkCache.getChunk(chunk.hash, chunkModule.compute_hmac); @@ -182,7 +176,7 @@ export async function* createXorbs( }; xorbId++; xorb = new Uint8Array(XORB_SIZE); - chunkOffset = 0; + chunkIndex = 0; chunkXorbId = xorbId; xorbFileProgress = {}; @@ -198,13 +192,10 @@ export async function* createXorbs( } } - chunkEndOffset = xorbOffset; - - chunkCache.addChunkToCache(chunk.hash, xorbId, chunkOffset, chunkEndOffset, null); + chunkCache.addChunkToCache(chunk.hash, xorbId, chunkIndex, null); } else { chunkXorbId = cacheData.xorbIndex; - chunkOffset = cacheData.offset; - chunkEndOffset = cacheData.endOffset; + chunkIndex = cacheData.chunkIndex; dedupedBytes += chunk.length; // Track deduplicated bytes } bytesSinceRemoteDedup += chunk.length; @@ -214,15 +205,15 @@ export async function* createXorbs( if (!lastRep) { fileRepresentation.push({ xorbId: chunkXorbId >= 0 ? chunkXorbId : remoteXorbHashes[-chunkXorbId], - offset: chunkOffset, - endOffset: chunkEndOffset, + indexStart: chunkIndex, + indexEnd: chunkIndex + 1, length: chunk.length, rangeHash: "", }); currentChunkRangeBeginning = fileChunks.length - 1; } else { - if (lastRep.xorbId === chunkXorbId && lastRep.endOffset === chunkOffset) { - lastRep.endOffset = chunkEndOffset; + if (lastRep.xorbId === chunkXorbId && lastRep.indexEnd === chunkIndex) { + lastRep.indexEnd = chunkIndex + 1; lastRep.length += chunk.length; } else { lastRep.rangeHash = chunkModule.compute_verification_hash( @@ -230,15 +221,15 @@ export async function* createXorbs( ); fileRepresentation.push({ xorbId: chunkXorbId, - offset: chunkOffset, - endOffset: chunkEndOffset, + indexStart: chunkIndex, + indexEnd: chunkIndex + 1, length: chunk.length, rangeHash: "", }); currentChunkRangeBeginning = fileChunks.length - 1; } } - xorbChunks.push({ hash: chunk.hash, length: chunk.length, offset: chunkOffset }); + xorbChunks.push({ hash: chunk.hash, length: chunk.length }); xorbFileProgress[fileSource.path] = processedBytes / fileSource.content.size; if (xorbChunks.length >= MAX_XORB_CHUNKS) { yield { diff --git a/packages/hub/src/utils/uploadShards.ts b/packages/hub/src/utils/uploadShards.ts index 2b3ffe2eee..f138d2b7ba 100644 --- a/packages/hub/src/utils/uploadShards.ts +++ b/packages/hub/src/utils/uploadShards.ts @@ -115,15 +115,17 @@ export async function* uploadShards( xorbView.setUint32(xorbViewOffset, output.xorb.byteLength, true); xorbViewOffset += 4; + let chunkBytes = 0; for (const chunk of output.chunks) { writeHashToArray(chunk.hash, xorbInfoSection, xorbViewOffset); xorbViewOffset += HASH_LENGTH; - xorbView.setUint32(xorbViewOffset, chunk.offset, true); + xorbView.setUint32(xorbViewOffset, chunkBytes, true); xorbViewOffset += 4; - xorbView.setUint32(xorbViewOffset, chunk.length, true); + xorbView.setUint32(xorbViewOffset, chunkBytes + chunk.length, true); xorbViewOffset += 4; xorbView.setBigUint64(xorbViewOffset, 0n, true); // reserved xorbViewOffset += 8; + chunkBytes += chunk.length; } await uploadXorb(output, params); @@ -173,9 +175,9 @@ export async function* uploadShards( fileViewOffset += 4; fileInfoView.setUint32(fileViewOffset, repItem.length, true); fileViewOffset += 4; - fileInfoView.setUint32(fileViewOffset, repItem.offset, true); + fileInfoView.setUint32(fileViewOffset, repItem.indexStart, true); fileViewOffset += 4; - fileInfoView.setUint32(fileViewOffset, repItem.endOffset, true); + fileInfoView.setUint32(fileViewOffset, repItem.indexEnd, true); fileViewOffset += 4; } From 9dbd3afbfcfe91c50d115ff8c97ba8a72f711687 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Fri, 1 Aug 2025 20:37:53 +0200 Subject: [PATCH 34/43] endianness matters when writing/reading hashes --- packages/hub/src/utils/shardParser.spec.ts | 21 +- packages/hub/src/utils/shardParser.ts | 13 +- packages/hub/src/utils/uploadShards.ts | 13 +- .../hub/tests/gpt2-64-8bits.tflite.shard.json | 2137 +++++++++++++++++ 4 files changed, 2168 insertions(+), 16 deletions(-) create mode 100644 packages/hub/tests/gpt2-64-8bits.tflite.shard.json diff --git a/packages/hub/src/utils/shardParser.spec.ts b/packages/hub/src/utils/shardParser.spec.ts index de764b6ebe..1cea875bb3 100644 --- a/packages/hub/src/utils/shardParser.spec.ts +++ b/packages/hub/src/utils/shardParser.spec.ts @@ -6,18 +6,17 @@ import { init, compute_hmac } from "../vendor/xet-chunk/chunker_wasm"; describe("shardParser", () => { it("should parse a shard", async () => { const shard = await parseShardData(new Blob([await readFile("tests/gpt2-64-8bits.tflite.shard")])); - // console.log(inspect(shard, { depth: null })); - expect(shard.xorbs.length).toBeGreaterThan(2); + const expectedJson = JSON.parse(await readFile("tests/gpt2-64-8bits.tflite.shard.json", "utf-8")); - console.log("xorbs", shard.xorbs.length); - - // const firstXorb = shard.xorbs[0]; - // const secondXorb = shard.xorbs[1]; - - // console.log(firstXorb.chunks.slice(0, 10)); - // console.log(secondXorb.chunks.slice(0, 10)); - - expect(shard.hmacKey).toBe("16af3a84044b83d6be998a42e20399f2cc5650eaf99950639f50418aece7954e"); + expect(shard.hmacKey).toBe(expectedJson.hmac_key); + expect(shard.xorbs.length).toEqual(expectedJson.xorbs.length); + for (let i = 0; i < shard.xorbs.length; i++) { + expect(shard.xorbs[i].hash).toEqual(expectedJson.xorbs[i].hash); + expect(shard.xorbs[i].chunks.length).toEqual(expectedJson.xorbs[i].chunk_hashes.length); + for (let j = 0; j < shard.xorbs[i].chunks.length; j++) { + expect(shard.xorbs[i].chunks[j].hash).toEqual(expectedJson.xorbs[i].chunk_hashes[j]); + } + } await init(); diff --git a/packages/hub/src/utils/shardParser.ts b/packages/hub/src/utils/shardParser.ts index c63b960394..e1a45d40c9 100644 --- a/packages/hub/src/utils/shardParser.ts +++ b/packages/hub/src/utils/shardParser.ts @@ -3,10 +3,19 @@ import { SHARD_FOOTER_VERSION, SHARD_HEADER_VERSION, SHARD_MAGIC_TAG } from "./u const HASH_LENGTH = 32; const XORB_HASH_BOOKEND = "ff".repeat(HASH_LENGTH); +// Read 4 uint64 in little endian and convert to hex function readHashFromArray(array: Uint8Array, offset: number): string { let hash = ""; - for (let i = 0; i < HASH_LENGTH; i++) { - hash += array[offset + i].toString(16).padStart(2, "0"); + for (let i = 0; i < HASH_LENGTH; i += 8) { + hash += `${array[offset + i + 7].toString(16).padStart(2, "0")}${array[offset + i + 6] + .toString(16) + .padStart(2, "0")}${array[offset + i + 5].toString(16).padStart(2, "0")}${array[offset + i + 4] + .toString(16) + .padStart(2, "0")}${array[offset + i + 3].toString(16).padStart(2, "0")}${array[offset + i + 2] + .toString(16) + .padStart(2, "0")}${array[offset + i + 1].toString(16).padStart(2, "0")}${array[offset + i] + .toString(16) + .padStart(2, "0")}`; } return hash; } diff --git a/packages/hub/src/utils/uploadShards.ts b/packages/hub/src/utils/uploadShards.ts index f138d2b7ba..e45412de86 100644 --- a/packages/hub/src/utils/uploadShards.ts +++ b/packages/hub/src/utils/uploadShards.ts @@ -355,9 +355,16 @@ export async function* uploadShards( // Todo: switch from hex to non-hex when WASM switches. For now consider hash is hex function writeHashToArray(hash: string, array: Uint8Array, offset: number) { - for (let i = 0; i < hash.length; i += 2) { - const byte = parseInt(hash.substring(i, i + 2), 16); - array[offset + i / 2] = byte; + for (let i = 0; i < hash.length; i += 16) { + // Write a uint64 in little endian + array[offset + i / 2] = parseInt(hash.substring(i + 2 * 7, i + 2 * 8), 16); + array[offset + i / 2 + 1] = parseInt(hash.substring(i + 2 * 6, i + 2 * 7), 16); + array[offset + i / 2 + 2] = parseInt(hash.substring(i + 2 * 5, i + 2 * 6), 16); + array[offset + i / 2 + 3] = parseInt(hash.substring(i + 2 * 4, i + 2 * 5), 16); + array[offset + i / 2 + 4] = parseInt(hash.substring(i + 2 * 3, i + 2 * 4), 16); + array[offset + i / 2 + 5] = parseInt(hash.substring(i + 2 * 2, i + 2 * 3), 16); + array[offset + i / 2 + 6] = parseInt(hash.substring(i + 2 * 1, i + 2 * 2), 16); + array[offset + i / 2 + 7] = parseInt(hash.substring(i + 2 * 0, i + 2 * 1), 16); } } diff --git a/packages/hub/tests/gpt2-64-8bits.tflite.shard.json b/packages/hub/tests/gpt2-64-8bits.tflite.shard.json new file mode 100644 index 0000000000..4b55adb6c0 --- /dev/null +++ b/packages/hub/tests/gpt2-64-8bits.tflite.shard.json @@ -0,0 +1,2137 @@ +{ + "hmac_key": "d6834b04843aaf16f29903e2428a99be635099f9ea5056cc4e95e7ec8a41509f", + "xorbs": [ + { + "hash": "16fe54ff57e667703a42fee0714b243eabd2d219773fb88446da2795c901dc0d", + "chunk_hashes": [ + "2d35ee5d16461ade43e53cf039a35ed65ee18d0ef37eb0142c0399efcf0f99ea", + "117f7a8bfb5a999aba0984b6f291756a2445715dad27a58467eadd97c9304b2c", + "26b2c89bdd80a31b84ca3cd48076917fb95b6ee9536b1b51c5213504fd967189", + "6deed1dc1ece04aae502023438faa98cc960e85d5899b110e38863d04b9e289b", + "3f4a1c53a1499af960d07cc3c7875dfd2bbcd1b4081713afc7d6eaecfcc81379", + "18ac2a2dd96526d0895b275f3b99c65c9be17f4ea1001a45afe0c0667e9311f7", + "78ee665b9dce6ca5da6a0c264cd30c55914b47f30592f065e0dbd6351447a3a4", + "06b0f66ca507e65a78ca6bc334f38da48304edbe3c45b52e0197689c56383a91", + "ca2dc092b4ee1e5fdd5af8932b05ff697946dde25817c43b16632807adc9134c", + "ccc1c3e90a7f1a404812bb8e7122c5b42162c50e719a02eaf10b7674db175a1f", + "d019b794f0523412a1be7d545632476d6c7f326d00fec32a92dfd4dba5ecccfa", + "570e1b4a022fbab9a5867a352175ee6bc761839aff3fc833c9e8b2d740536757", + "e717f79d312a7e5b8873deef287278369caf03add73cb3709b0a5b2b45e50d05", + "b8e39299e888810fe644c486c9976bb39577aa63672aa907f1bbcc2e15aafbc7", + "a0dd2cb912dfb5b3d1aa356dfb4d00d0aaccaa4b0756e0410fbaffd2566cd2c2", + "b36c6a8e02a06467f6701c37dafd586628cee2a303b6a26112500e5683390b99", + "619341cf804fe41b5a3971d1b9f508b5b0138b72ec1759d169f77950f92eb769", + "5f0b18a98414543d9b5991b84b45b5353a42c0d87693d300aa494270af73e336", + "4fd42acd21a6b53aa342eb09e7f61831aacaf6667c658da849847a4b4a5af055", + "05259ce3685b1135139e0d0959dd677f758c090319a344854060b2947b025a7b", + "b82ef41b74a9f2994215792e7c754342e2081b89f1d6738e7da1f0401ea9d15b", + "ff21479cb8fbabafcf807a0f335d982cd37edf87f1f4058cae683adff3a02a49", + "303fe75b54bc90f3346196df692a7aba6f26e4d3990cfca66f81dc7ea41cc6e3", + "7233074bdfb88fcc474485aca30616c60031dd7aeb2a83476b632410dafeeb76", + "4c311d55e3623d05659fa181cf58b397ddbfcf6d4300f40711dea5c7aa38406f", + "bd48cee53a4aef5b51e8ee3d8fdcba925e61acd5e40f88b7356614a5fca1e23f", + "e2b6e8de8f9b013823ac1e14383943d689a6f215fb9d82b91cab5479a4f09a61", + "ed71f620939ce08765966c76ff6391cd54bfa4a74957ad5c92a15ad9aa879652", + "6d5c276e21611df916ab3c437d06d1734c39bfa7595096465592f5def83a7598", + "f184fa05e3335bcb88aa97028669058c5fa51617f9eb078369ac2723b8ba6a6f", + "a46f2b12be1b582fa3f3e2a16b6f7ee976fa6e33b250e76731e3326f956b2dfe", + "c55775661e6be054c64f92fe5a573c649124794f2b79a57e43bc7c09db7ac376", + "a1c9fe868b31612e50a220a689efbc183c2c3f93fc95fe6bf1a62432b4712354", + "235513098183a467b20e04e1fc522d9f64603afa211e39185e294aa7a09b705a", + "bbdd7ece70776246cc80a7eeb8a5e3d72ca02f40217e81cacfa71ab6e2278e29", + "060fb48cfec449eb2054a75ed821bc70cd43e925b2c1aafe5566d8203dfd5246", + "7d0f724eb232e15e3e432bcad94b5758dd96cf41a57fd581f8223ecc79a07eb4", + "a6da81793909b24d88d21a299b2ff24238e734481ffdf894fd1cf0b7cecf1de4", + "74097b8968a417d72ab10cf63b87fdecef51a77635c0d49fb10a3fe3d8fdaff3", + "b90d98c6bd77a31c0da810204bec419ca69bd9835339cd76c6d2ae50354b25d2", + "e5d790ba672cb5ffb0594a4f60fad576828c863ddb27280c43aa037baf1c6e75", + "2d861fbc4d4bba5d45b653416edcf0e21d98cd181038cf46e5bea860cdbbf335", + "c8d1df0dfeff7bb8978e80704dc8537b64e3dfc2d6ade73a756e8ef8f54d0214", + "61de10a16928f606a3090c4436952ddb4129cf2900be9af777dd90e6d8c9a2f4", + "191002728af89e67a6ca649e76c26850fc470bccf7180e1bb18565e15942c5de", + "c6940612f3417f5662603c2fc73c5dbad1423e0de96d205b68fba0212866701c", + "2c65eb06caa41a5828160f97484af5a82344ec308b046237f08d5f7eb709151f", + "802c055f53f2980a06c7a6a2f2b54da2b5dc5fbf9d7c3dec1309930b2fb4713d", + "a228e75bdc679a17a56175e336e41aa53a1e1e641040688e542960f9c3a45c65", + "5d8d52444a3a717aec1962bad8350920e109707ebf0aa9eb3f07e1e8499d7bea", + "abf78f3896b8270a6dfd4f502f545e167dd225d5a59210ffb0f8e5246c90488f", + "98bad0300f759c1f22119fffc813c8a5e513d465b95f7f99e15dec4cf4e8e7ff", + "ce2f7a67e8eabe14d517fb3ec32b6aca3b7e155edfb77ce69b954c867446edc9", + "bff28e680f950dab0543e87ee2400292c029aacc1387ec08f8ee81cefb1c658d", + "ce3c9c09198f4df4358de16cc50ffd2e41215018060ce8382203470e095e9348", + "e09c12ef4f0c9601e3bb5fed049a570ed7fef3f7262891920d75e412ac13c69f", + "851696764d2c4293a7e9717b3009a8168566fed0605ec5838e1bd313894aeb0f", + "ab9612bc415589f6d0ebdaa744577f9184bccdb6b5f4f9737f8f79006776cd08", + "6e6a4c466623c2b9aa4b06793f4a38abc3152aa52ebdc0264a9769d79d5f2335", + "c8ce01ca152af4e1a6124b189f61696a1ceafb2d2ce4711812f2355dee3abc80", + "0de09a52ed95b025b2058dcb238b525a36e1d59bf4cea1546c45a865921b0aea", + "ebe0de8cb7736bc75b988a3066dd5e15f1952c4e3c70531d49191e245443e7b7", + "95397107eee911710657f6ab103eba8c189d6621eef2fc2dda5a1c31dd96fc58", + "566f164c862cf3ed60f9caf9dd8a043d937c6d7ca27eab69fa0bd3b11610d740", + "241542898a9a19fb22e1768918367908026aa20a06be3dc7a29b6478817b2e54", + "a4cdb5efcfcfba555c2616d75973a381f4c067ab21464fac61a8a18ff00ba207", + "1787121fab3a3e950064bf4c55db858e11f6cecf2f0de7fd684a9d5119c4a93b", + "02bfa425c422bf814c019253ca5f55cff25493019888586c4ae60bf9617c4c1e", + "8d118475c14ac1fbd1291cac222107a8e838c59521859384c83ad45fae1b5367", + "6a42fcd549cb7beea852803dbd1549946d16686ce2f6b7a833dea2e1000e645f", + "b4ab383aefedd17d6ac50e492416d03be71f9de3680510d64f5c7961e12b946a", + "333df582fb4ec8d8dcafce9c72faefa5dc113cc1fc34ff3557e6647da1d1cf57", + "a78f24e4c18b13e9790c5dab6d7b1fb139a14bdc08388d06323bd1a2bd7a6d51", + "e9e63ab2fb0f63c6e5441b548a6d2d4b6a61db58e97b84b31e985772f8296505", + "232fc0cb64691e127f96ea1f97bfad4f7c3b0e90037c01ffbe0ff184a861a552", + "d194ff8ffe3046dc7ad6c29cccd12a6e74f9965153320c9e80af4c99f437420e", + "a675ef6a87007da5466ce0f296a1c0d8fe0dccd1fe17f6690dae5356195d70e7", + "17ce2eb6a9f58f7a0bda6a9d4b0ef7e01ac313749d688f87f1affa02ae73c38d", + "8d75072b5b71406b4718c6501c0d61689b3812e2915069ab44796919d1bc9104", + "175db02de880e8d4f8b5c284f8efd2f925121faf8a52dfba76e3b47b129c0ae6", + "7d2645756f221c891f37ad274bef4019bf55b7269ffd2c88f6be9b0928a408a2", + "027607bc0fd00a1a72fbe0d0846569872230625f47a56de4a93e06fdd497a667", + "dc5ad8c2627ec50d6f650f497968a48418feb373d800a9e72e99f9eba58b802a", + "689d45cd94bc8c233d3f60fe8b53369a23d3e56539fcfddc274dce4318b4db9d", + "bc8ba462e108d5fcd4c59a6fcadeac98e88be35d5fe307919b7a5c83277ac1a8", + "e1a32119d8e3de94ed935bddb2888e2c65941e90cbc96548396b59bf7a054ec9", + "d391ecc6e4c3f3fd58ebe09c08e8800e6691050cb3fa674ac838fdb7af80d0a2", + "7be3bee7fe08263795d914fa48d57e0f2a3a5af7628a4e73a3af199e38f0f12f", + "c5ae2e736bd8678afaf963ad23cd14702e375649ac10093667eaf73da7613ab3", + "b3d0f4dcbf80bf790e8b94e62dcc82a159b9a1935a0a46422d6175e67d27a3a8", + "31c485d786294d482eee369675ee07b49e392f88e612cf3538357fc72725cda7", + "8301332f392d843f176d5387bcd8687addab649c04d577199022c0f27df7ad72", + "ea82d88be2519be44def98c302e1f350540a5735301b4efc5b95648e8aab6fc1", + "fb718c5be896c782e6b08f5889fb72ce8829a931f9f9da468a94e496e055853b", + "f7483b64fbd4f49c9c67b80ce8ee8ee936b85e8d45c1f7ff49c7df464e75e870", + "1c1e332714be5ef89820d549c3c3e3a6003ee60068b5263530fa4b52e6d45b09", + "a0cfb53fb4b2fb79540e087f3b8d5f936f250723ccadc5181438afb3598fedc0", + "5d7c72969c6bf94be9b506fa78d2544d766e915b3ad81fac9b4da45cbd380746", + "eb77488f5a3b6a780d0d312f7482d065f233daf9b308784fd0ae166fa2cf890d", + "db2490fb2ac9854c1615b8fa92ecbe92795d89c4c94adc1b5cb7af23ddedac0a", + "2d0570dd353900d6cf3330b6cfe51466dbb74b9d1465f0181deab3cea8cf598c", + "732d59bba9b80ea90866be2f41dc8228c0599ff5fbe2a4034fdc0ab01307d3f6", + "5d18c4cff92f10bc751d013167e55974fa78d36a7e42dd38200a75e3c7865012", + "f8fa563a16f7279af6347285381e0971ff50b28f6c9a5ae0d90420c2e33201c1", + "445da8fa9638c108fce0e51c2feb346eb7e7bd783523d8c1aa470cabd4be60e3", + "7f49557def06eb8189802a479a61836bf4dc4e11c853baa0cd107dfdf9dc1d91", + "ea7b977040acca2f4cd45b718be4090013ca568a27c1f9df7df9571fb3d83489", + "0685250d17a9fbd1a7d53e8c7745904d99a57afc00ab46c5b9fcdd2de65fe8e6", + "c61743ac4556d1e5c81e2cd50f467f0657ba1d783dec42b26fd80dd1839ccc6f", + "b030e2ac55073ee693cc7141cf80af28a9c87d6f094ae69c53b9830fd1a2426e", + "1b6415fd0848a4c9bf4a4eeb2af70e7e9d45d50bf929534e3b5403227e0d625d", + "34ddc6e5b8673013303d7a215127a77b8e59c9c076383ccf8d68982c32ff2167", + "957b7e02f0fe744fc4c4ec67b85bdd6869c60c4a7d51bb307d9f0f01270cce64", + "eb1eaf5cef77a274e8a65c78bccd50847aacbf6997d37f5cdcf737cba846d23c", + "3f848d2fcd680e770bae54427d40273cdb70a4bf2fe245a655e44ad0fe702cc2", + "969849da34f558aa7b3dd1aff6e291b82894d5ca0809cc951557670baef0667d", + "58c149f7c04ec88ebd93231d16a2fa531ca8727f0bed0d26c85381098e104398", + "2bbbc32404de61ef3192008f14d363d09bb43f18143be84e8d52a482d0990c08", + "24436cdd1edd8c55039617d83e2bd85053ac2464191032c5d05a201f3db8de9f", + "011250b5bf6257582530bc26e216a19b0730e146d2e25c4b357393c457d8389f", + "64e70c71ca6b9b9c07c0cd6f5bcc908a46283d4f972c1eb4f6a90a8a8b1b6e2c", + "ff8408bfb163285915ed9cf932b492f2196eb9de29ab7818a5343278d6e16fa5", + "59320794af0c3556590082eb4739a4c6a13dfe9fa3e319963db74ede7e2d8758", + "766d9173252e4d2525a1b01d74f8531cb665fe061ce50f1f4bbb835235a73280", + "36fced07e0c7aa01501e9ba6ae332637fb1f506380702455c226e40ebedcb34f", + "ac2bef4ae06314d2270e2bc44f07385264f22130f4075d42b3a4e743b07590e4", + "83f953053693cb00f871578d1a254c4aba18d4b0d76959d1ecf5b72e6d52f848", + "fa46dca10a6ec2de156d9e1230cc35d4dd3c0ce440cc4bd60c41e8281654c356", + "9e2c0200617435916ee3cb9933b74a75c448ce7b343001a7a00ce9656c0030d1", + "0e70e821f2f398027b2937723f7c9a6719f5a8799aa22f57aa99846eceb0d77e", + "8c4e6c84f6877459443f147d18d78cf877a2c5855b4347fd134a46ae3626fd95", + "f01b9710bdbaccb64895a5cf26a475b37ae592f82ec73016a6abd79e2699c633", + "879b467f19c80bd71684de66f7cd113a35b2efb0c8ad51707f35bd912fe9f05c", + "3ab0316e2fcbcbde593388be712e44942b9db2bcdcc4c97d3624e11e3755a307", + "674d3d823e3b99a69a3b89e797f00dd1314121a6525d72c1e206bee00e04074c", + "e17321f255f5ceee232869d097c62ae9086169c5238711cb805b6621cb08abc4", + "3f4096785e811c173aff741bf1ca8b6fb5268392ad11075096fadfd4cb57a370", + "71bf8571b5af2ae6d9d99c95ae0e81e4d31561a58c15f47abba85c82d1aeae9b", + "0cbc44913219e583c7b595fc34bd1c7ff2013700e5dd38a31695453a15e16d81", + "0ff06b9d36475e0044bcd20f5ae89f50a8cd523fd6e6151a180fa328a0537bf6", + "df454e77d53fda6109539a04b79f4f9269c17e957d8c93f3d10dd3959d9c08b4", + "8b68d19d7d30ed95fcaa078bd5dc19eec98a9b10bd520fdfc59ca87b6a22b412", + "fff05b13e0787b668fa3132fd9345de7fb8b762bad4b0002cc507b04c044f2cf", + "b1bbe186b339807083e4b153744c5c554ac1336f07874b080d13fbc7e89718c0", + "92027b1b9eb483ff3ff3f8ad24910b7a3f10932568b519fb8aee8cceb23fea26", + "2115ecb8c7ad489d1c949f3c8943e7da6f88b26049c0108e2380a148c7b0a51d", + "f107058cd503dbbe9e91b0598fdfa4d792860c4ad2cea524b0f56fadb740df24", + "81c681d7de5babc2a8886516ca636bd01765db9b8b122abf6d3fc707d029d959", + "7cbcc290fdb2470224944be0b0b113787125f0c2f35963228fef2ba59478720c", + "562090616c7c63d418a1f4ebee5a88e550adbf1cb00f726bcb3f015c460464eb", + "5c4a343241e49e9f6628659826bc390dcf070c3ebcff628b21e48978b1fff454", + "a34148c9f0f03d160a04605a8be82ee415dd512cf3629b6ed93391da2deb24e7", + "0ff0bdfd7c97002cd7ae37b395c44f4cfbda78bedef769f43d397020b5e18727", + "4d22d66ecb60ea0c75b18cc8663725b30e7ebcf424b521c73b1f2d1f30e61a2a", + "df02e2b1ec8b2204ea4119e68a08463a34037a9c187bd5d0672d1014365ef092", + "f49d8338a27590d5b65df5faff7cdfcdf557dd74fcb7e2cbe7984cb76dd5144f", + "b6263653e0d7737dcf201af9446e60db7dee7c2788bb216375327158e0a33c97", + "f2cde01497f9e8ed77dfb51aff1f6a49c0dca8d4ce0879449df8e7521b531ca4", + "13a50da739427b75b3566c3d47a4c14fc0d04f7842890432ca14153e4bc8ca8c", + "a5c387a48dca5fdf0ca04906a8323357ff7e21c992b03559a9f33bb0ff717a33", + "c4ebf6e4a61e6986031895fd43b9156a35e7896ce63a97fc9b3b60f76e718370", + "aaaeaa25651cb875c93b72bcd3ee4afbc7e8c4a695977ff3c695d30203cd4248", + "c7d4d41b87c129126d9945f5f22e3f00f901a2a1067fb2f6fbc7cb98973006e2", + "1ccc451d3641af1c4aae9cf399dfb29074643fbb00fa87b3a085cf2191d087de", + "b9ebc75d5272603934f3dc16dbfef92972c9917df24c911642306512633d0f35", + "4651613537c75b2c2565f2534d9dd2c3769cf6a75c7aa83746a6bc2cd5e5dfe7", + "8082dfbb4162be62ce55d3b9cea5867303598dd0e08c5485c534ef3fa64d2cac", + "471f95cff059d7a20e2fa7cf867d88df026f2456e9d210cf3475c078fd44a161", + "6504072d69248d456201196eacb96c3c14464329318d6218472170c63bd1d697", + "399fb59ae7ec8df39dde56bc0d7b801ad9aea6edeae3b83abb7a13258e62ba67", + "c5256df3f4a0b589bc5edc17da62f53012db2344631c618c8751c5dde0ba1e6a", + "ad7fa7a65beabbcff180a5457a186b949a119bd494fcd92ddc15a8d9ab61efa8", + "bf2e0410a160af8708c71d5357bd92b2a16f89d8aabfaab5fabd671d41ed5163", + "c749fd4b81a36185f1432b01dcadab4ed6ba385158a5ae64a763bef98436d4e3", + "103c2681b18885e490e568acb93ede3f6231f8453dbb4ecc0c322596f048d952", + "eb5f0bda174df08b6458e6499c3aa2b5ec05c339434f78224bdeb540fef2ef18", + "30fa510f894127f1b2ea38e91c1d591faaa14600cdde73b7a4b4904be3acad0f", + "9b83739ded6f9005e97d37442a98f7984c88ebd33436542ea8455fecf5a60aa2", + "3e872dec96d85c60cb1a2fdc6afedbaa8890408ef435bde77806d2776c8ac918", + "235eda90551c203488d582f382df6a3895432de86d3bbdb10d699ac27f8505cb", + "a7f010a334d1c4774468919e669b90b0c2ecc38a18cb533dfb2c1d8104c59203", + "e0e919ea5b5158797811d53305d4a99f9c015690b17dbf52c04694ebe294ec85", + "818bfc91e7fef2a2555496fec70e281f98673f2f0376851990bf96f047cf3671", + "e8ea0e463e842721decff2dcfd66499917b37128d4fd670fb2bfdd3e2d217d9a", + "067f25814fd0ec70b50d59dd64ab25b47adb42e52764c952094bf5f86400575f", + "1df12836e78886d9b2a0f8c98d9bbf3e6dc78eb5c8da54e8e36366e30683bf77", + "814df2071b10bdac4a4091171ac207fb0429ade8b1adb121dd478a527c5cff68", + "e6483095cbeff8043a09f75e198a12bb837b92c50e9282977d0182b39906a604", + "fb84ca6e8728251c42c17a4ba9bdd09115d08168c359cd04a107094b9f9ba4e0", + "3e79d4b25fc16e72d24ff65478d2776f959634734d12eccc26080734b1258e7d", + "2c0122f976837c98ea468776ba5bb5307eb817bac6111fa45c4513d25d3cccf2", + "98eebfd1c00652c1972d7c3ae5be0c24e5f2a5cce700950bf42b4ed4361cbb8d", + "63ea15eb535cbb4908e6c5516434d7ffd2f0ae277c3e2881d20a629004835d7c", + "f25f0aae237bd730146c7453e4cfe96dc678b0094795bd16e6be08be0ace6e03", + "907785a4338fbe6232e6b39a2f718e5839687662e7318052d2b1e76455a6a89e", + "6ef64a0883870c02e483f0ce74b47d9290c7d1eeb509288b63cd54af0bbb84f4", + "0d4b7c10cf3777d46325ad80d3cf298f2e0732b95e64561da5d4672a9f90480d", + "26795c1b73017c396543c12ec010b211e27fc8b10072d23d68cd2f7e0e0bce9d", + "64fa33e1a6215988e0bb852d92e00478a64b40d062971f1ef9f53d3fe09fc984", + "bb276c2897a33f5141b5a029fa14911db496f7bba198042c71a2968817c6d616", + "1e3e4649893bc585d9de17105704e17d418499433d82c886cca0926483347622", + "d65c8aaa6b7c2cd3a0b3863c452be1c89d550c64b78e4773ea2facb2652a4223", + "6493b63e159d178985ee2e86acc448e5b8e33de0e8f0a0463e685dc1b36e0e97", + "0f718f25077eb1866656338b270e329701482620ff46825ad6d22745ba0f636e", + "a9192ef1c1d4c9e05fb2a41d0049a6fcd98605d2ba0236200b8f473bb722208b", + "be9ded9b3082eef4897bcadd93aa2d5c41dcea882f72cd6ba9761cca2d670238", + "d521a6004503fb31cd9e4e4b9b75d902df4e73119d55070cb928113ad5a3e20b", + "0b3a1158a63e35d9994ab382745792d0eb3f43754eaf12a2dc3661cc15c5a0b2", + "22d99dcd9d0f7915f4698c5a2b7d6567f526ee60a1096b0a9a388a51808998a8", + "fd1741412c26e03c965f4e2e52f6dcc096f098830f8be57db49c5dbd5dcec9e7", + "4ffe99545682ecccbc4e9cb5c6871d50309293fde3cdcdf0ec6202738235f123", + "8a3df56a58b5c6d6261589b9ff0f6598e76e5a3bc78321c82e4acdc6271f9f0b", + "8a29b6b03c9d3d0372d99d35eb694b16c73536f104666d03e186bef123cefe47", + "1d389625cb0d2cb4d13d2a98fd4770e8155c6d927fcfb05d740a8c0a91c15c85", + "2b1614339d37e8a7af1d656fe8b01217fbea509e53844fad596ab11851954d2c", + "9177447c2e60fd4d3e7e42bb5eaf3910f582c374a2d8f9d3c621b3aeedc07b19", + "ab707c4e9bc086df4d9e97a6c2546a8b908c7b951ab1c8a5117bcc0a640db066", + "68403b3a8dd444fcb5fca22da4e684235ebab4f928a14410c3fb100e255ca79b", + "da587a43c9004c00e0325a823dfc88cdddd6adc084c5dd335e65e97183c77f0e", + "2fda6fc31cb9f0d2e1386881cd664dadfe4a9b25e7f4780b4ff439da3f59ec15", + "8b98cde5eaa784962523b13501f190efe33ed30f00799130895055efe9e95d45", + "103cedc8de9ec9f18dd3b1dcc1b20a11016bf3b6b9a56a2ba4332391703e90dc", + "7ef4425b662d8f46c8b9f7d49184a484c486062759c4d571ca0864eaf5e58be7", + "bde5706f19b41ca8564369dd658f6c45a5f1a11f4e4514d977cb267a8c678b52", + "730a5745e1fe8db0a1140bdc33d8668279f518708af3e35b0d6b5df0f34a9fb1", + "2930cfd7e7e07252336967379bbe6597ce03f5efad9c91e21f39b12006002a2d", + "f813e9a0c13ac298ff094eb2fddb6f379d3828d51e57caf77d27d6fefc7be2ea", + "2daa5821017aa02d9f67894552941466b17185eddb909ae5c55aef424392af96", + "bbcc761073c13f2cb44472e235d3512424d46b7064392b8a219df3d84652f4b2", + "4d9369e06ede6fc8f9d2f77a2075b5a286d690bf5b09a68039ec54c4feb46a8e", + "875a43a471c082d545d5ee60547764743b79158160240b16311f6ed3ef764cc3", + "2fd72fe0eb1d91eb8a3f03c77318a9f238dc8e727a8e0ec27b4f75eda37181a4", + "2d59ba596c68515e4d68681ac6ef6d14f6b3219250ce29db8693561a4f88eef9", + "6159cd132aacd88967d4668f9e0b117c50e80c09f70597166d53267b1c4397d5", + "338f7279f58b51d01780e0ebdd6186cc1fdbbd113167cd90d2309819a8c8e87d", + "af91a88583bdbe18446856aa64a52984c154c01c74536a34fda3dd0346b5989d", + "561140383487278a1789c14f532c9521b07b59f8d50923ee6812ff5b6b96c3d9", + "9acac5c30ec19000cb1656e5350e2df0560d21c74c654edf92471f9fca79ec14", + "9d76a33df7574fbe3f53a8f3141fb4a54e996390fa20c9390c68830739318952", + "534262693b99c8a5478248b67c45dbc9e849ed8a42ed8ca6d18cdb8501528dd4", + "84163825338daf2b049c16f6f763a14dae9437d9114951700158890ac89163d5", + "0a3d0fc98f64b7520ab4ba79c12deb1ce0634177236bf9cd68712f130ef0dc42", + "6dd291ea07dc49ebb984a9b14a85a6876becb8d9c4988d828ba1ae8397342053", + "28287652259efaed3bb036bbd1faac8efb33c132bcd63e2226c1137b596c6fdc", + "793a37350c224471f0d86a733888886d90632e5a2f4d535001dd9263bf7f9c05", + "d745e07db13496df205b0bc66a2390d9a2e18fa210c7414cb5cf48a900c8c109", + "854300f0869d6d40c81b4139d865dea7b78f0d1aa94e531bedc1ccd7ec150d6f", + "b14d61694dfa4c3d7c19df722f4e7c279c58e14912e5dbd7eb6ff8b0dd3131c7", + "553e23e27ed68ceb249ad4208f00babea4963d14b972d73fd6f13c2c60fc0bb3", + "b3bebc3a02a9d8166799638976975d74560277edf4767c824201c2d7e744227b", + "e43ff20c9b35575fbdf20b37cc62f4f73df3c032ea09a9fb1b3a5ab2b5177ad5", + "149a16edf2b6e52162682925a0497e846bc06aba0fcc11022382ac1fc638207c", + "ab1047fdd9bee6b0b61a7ab656961c9f56251574b2769c36a9962dfbec2d16bd", + "0f8fb9c3e6b0369a436c0a332462058394f0da16d47756bc3e69565fae177171", + "9801fd7895bf21a420ce33884e1d93f8caed3675a4fd34af87dd3e9735c1ae5c", + "74b5632d315207096b00976c31002bcb3dc4b611d0a34e8d3d69ccd9adbe4f1c", + "d4da8f8d90dec43be329976f2827e9068d52b5e836933ce05950d9b5ed92bd40", + "f602c640e3067d54d9d79ce2e5b515b0638ccf24d35556baeaa1985dbc25592a", + "678e335d5d7b716097633f511487508cbeafaed74e1a5da202bebb0df557d57f", + "d48ff71d683c35ebc156edd912d25cff15670030cab3efe184f7a0998dcde701", + "9c79a7d0dd008931dd85878002ed6517d0babe090efaa46d7c893ca1da489132", + "8a4fde8ecfe7d2ed9e77c256fb8850711f0f64c221b0f09f95d38ba9d7fa4834", + "f0b0eb08025f125b8ed9720585f8247dba9194d60c2e23900554e930cb650fe6", + "ad3d55fde7ef5f32c3e015dae06d60c1d6c796b035d07bae67a1cd7a9c4c56fb", + "29d3dc43ad3bb5414b7d6542b2ea414b0dbe4d4b900c20f0a1fc7081fbe5feb7", + "0e4c569564dc8b0e8d4f1fc97a2f207b76b7012ef2f2fa165387c33d8bcfbe95", + "2579cd2949137a42bf62f830198e62edf27dcc5efe2cc7339aac9909476eba94", + "38183637ba9ae6c59819d6fb2fc179d1da8c2bc03a7d384d1400ec10995a3131", + "73fceb7beca936313398552c6287a0f9e9959095533a0ef35618f46bc75e2a6a", + "be8d8f69f419a210c1facd355648669cda560f8671cb42608508e94dece99537", + "a6b49c85a91cce4ec1a3c72db4095385cbee9ab73d6980fba99d569968974fdd", + "6e827c41b0fc2daa1eb9637561b40ca5a9470ff176211be43e041ef548b1c881", + "48cba21544cbf6040749b78a559e433e98fa2a9e9c38f2d69dac04db8d2c8d64", + "cfdf1405ce34d1a86ce62a2ee23dfe621d49868ee978312e6de84e40139fc80b", + "b6c3a1ff061a144f7ea2b740e639db15d6c0372eb24283f4ed235254a0153034", + "99808d7599fa62463fcaf3c650a77a4d141c4746a318f80817a85b6361703a89", + "e1dce4e9acf74f6e3a5e9c0ed0a43428d3a08f9933b69f5d0eaed26a7a074f82", + "c9b194704dd6391d41b46c60869faa500bea33b566eae87be7af27b6432098ce", + "fa18f61bcdaffd4bf247a6f44d745a7d337f81219435d7a30e2839ffe87e0776", + "d75bcab22d9fda501137798db980f9b338e1857c65bbe48f4c64ae3e9737a2df", + "93ba3983e34c4d98e842c06da2677efce62b2491a004c3ed7316bc0a225d46b6", + "8accc8b6220a62472bbb8e31a115b0523cf9cfe64b46b273fe91fe9530c94821", + "eb2e406bfe3f30e9c3795cd86048c950a86ae717701458fc4c4a4f0354b780a8", + "6cba680c260d8ba3aa7f96365e6f077d3a5e5bfa4488e85abac46e0abe3f7b0d", + "73b9ab058d3925def161d64ea2349f644aab5a4fca203c87c6d3d7027208cd48", + "999e6767d22c18c5afdb8e27614c4f9081af31b369c94813252b2b4bbfd0f570", + "f89cf006baa2cff91449faaf521d4bdf40ebf433b75524f09884f57c525232d8", + "b1ee86ca008c25e5e744c6e35c971f80fcb75628694e0392caeb05a60b564447", + "eebe4f830515623183a9001e22b54154922d2b8f73d0716f5db96914a4865d67", + "a284d28c2d8ac8555498a15647fb7f200aa967d12404cf3594d2ba7b436330c7", + "5a6c14f36d87b4664dc2edd4d76cfd2327b49c07d31cc4bac1d350727e4e739a", + "94a451d964e10420ceb9866a678aa9a32e28c42e98b8a19aaccf2e2a07163d33", + "b0ff623a824e11b03dfa14d2223ff868ac181571a3d51a50265b577554af4e8f", + "4818e4aafec767f959668ce24070c58c6e331d1cfe66da4e7deef80795289714", + "e94af8f0018537d99e9aa2e51a3b8f748c39f91b16d4fbee56ef61cb3de7529d", + "8b51eb235110b455ba92c528031a6a0e02d4841968fd9dcc642f552af1e7fd75", + "c3d1bf9e551ed3c8cd4ae83f68e896dd94b42f0d9d6733073fe5b59e67472308", + "b49c22fbb3231e6ed2ac3d83c14a3d6e37e471b51bfcf38e71739dea37b79f2b", + "6961509f2ac3f181c4bb65accaa3e39a93e687a78dff18b0c7ba11f8f55f5b27", + "741f41b91ae9633a1ac6169bf415855385f7c7a5ec21a5f465eb74c36b0bf8df", + "f24ae3cbcd6f62b5f791a26e8d8cad5999c873a4481396129ea2c377a955295f", + "3c94ea85b84b800cf118fa58d91d3802ce423999210d6636304e87a7e349f25b", + "d05446e1f385b3ceb1bd1d172ff6040c0ef67083981d6b238c8d772d3cbc2815", + "f80054c56ea560cd05636d80aba53681fd41cda544fef05da34e8c6372ee7358", + "482d9b940ef9686253511ce72ea2806e0b3cbb053e1e91448b37334b556f0b1a", + "3533397335174e68e52978f054fb6103b0d46009ee1bf71a28303a927a884aa6", + "875d071243914c0b36fb01d15dea27a2016349d14186948bbb595432e767a1b8", + "9a6a97c81bcd5b83f1c503de8b58dffda5ab3cdc427a1ef2668fdf20a2000c84", + "d3b99c5608c9ec7f3bfef8e310d61500d88a38f440fa7eef6773fc043ad5fb20", + "4e80f9a812e8c1e3f676a49ae94b7d5cece09e48246b621706711adca4de0fcf", + "d6cfcbc75a0c8917611195af82240456e51459bcb6ffaa648b8d720646036cf3", + "8528a2ba9ee017e5bf62320ec50dc2aa4464ecc34ad2bdd08e8073efdb1556e6", + "13468230bad65da1d67399025e9f9e44e3f0dc8ba2aff1008fc933c053f4ed82", + "8c8ac975cbd9eea2ac11856ee41dbc6ae597bdc4d23d19dfea42a9331c55634f", + "b3b5d130f012efbab49b01c1420da3ba3bb4fbbfff55d4d29f2475af883dd99e", + "a4eda7f676a229f66278300cfb3d542bec4ca1549f05d93d22c9402787b4ca57", + "4839948d12882648634362a75137015c3548f3548c0d5da3335b641e8a3b9a81", + "d3ded531183d1cce38779bbcf5329cb2b454d74a9642a48b091fcd0644619a16", + "859fc3239a2c742f75f3a68805a7aeee40a6d697fb85576f2cd28f11edff81e5", + "0ac8ffe3a993048bda847d19ec780e77aa2fb73f43284ce2c50770b49e35dee0", + "b8d6365602ef27e863c89161d4e3f307a734d4bd284d159efdf713292c187adb", + "9c357632b9a1bd07d6ff69f0968096529b106b8b402047291e0e4e71a62085cb", + "aff59619577641e76a78cb4343ce54e4b6c8cb10270d62072123af2aeb59a944", + "04ecc1f7b28c3acac4def50f01d62c5b26081edb347c4820c5727df9ecdc0555", + "94ce9fe30c430daee12e48a16fbf2e7aef9cc2da815ace7e20f28a13a9cbdf35", + "d5cbe6d7002ffa506572405953bbde3e3dcd384f50887b8dbe1fc3576dfddb26", + "8b4bb819e770c68552c39c980028cb84990f7298703e9f4a016d593c62e1ed8e", + "2b9f55a4b36b63ccf0ad17097594e045d46ce938ef70f1cb62acfcb5001ddcfe", + "b1586dc0d875b336ecf364676930fb618ee9747f6eb629d10a3f356844886c49", + "a315750eb1bc242e8f9939da70f15ac1cae6cd99090733a9c61d1cc937691d9e", + "ec6c4757641c34d2a2d29118cbd52f1bda6a549450124b924631094322f0096e", + "c37b37fbcfec0e218238d5034a9b0e35e6fd609b07947585de394b869849a4c8", + "1837b4c635dc33d3781e53a60ad19ceb9de2c9d1551d9e89918e9d453db7cd94", + "3ebedd148f082c47fea1200d656e1a1a545fac4d4e13ef5abd3e1977955eb250", + "97f75cd6c1c0dd5bc6c3e5b8b1ec22c432f28ed47ad6d218d7bd90ad3eb5efc2", + "712723119aec345f293a8c22a323bfbda89a39f64665f98029ff267cb474a690", + "80c52625ad5b8ab05565b1a28b600110770ec1327600530be1db8a19928a6afb", + "e3af588b7d62a3eba17751a787dbb11793cfdda6f819cb25f8f194babdf8b3ca", + "8f81e3ab21e9a9b848a07597d81c0fc219dc9e759d7614e54dfdd1b887d62fc0", + "b7833a03dbfab7e68bd0a41e392864fa2c9a37d2b9913260c8209af23cbe5ce7", + "5d0b92b905848249ae0d8107b82568134cd4ae13a48bbc4bee32d045e9961324", + "f016677256fc18c55d30fe5767d6ac36760a1dd4f9abf761b63f0cef0f7796b8", + "1583271a5f0c8db419233cf61de02dec7dff44446f5d2a885347eda126699e26", + "4918e5aa71150692d0a9f9bad0563159265874f90105cf8bd9efe33de17c0299", + "6427c054940e2251f1510398388a209d234b203fd1f27e04b1cedf9d579cce50", + "c8da0c2d4a32e87e65c00088815149cf5c28219c672d8ff382216c37c66c7dc4", + "df9e30b44e82e89c93144d212398a18111626d46c2c232c16e9bf0b9df3ac07b", + "4a111574aef412e1a134ed35ccaa97fbc796e98ff6f2582258dacafd4d695ead", + "d751d3fafd9c102c3204b1f764845163da5e0db36f17cc52a1d2afe1e1136749", + "325f1e1374dffbc9baa09c2d1e1fd2ffaef086397f6ed3ac80eb922056306299", + "60dd7780bfb44d42e628c8650ff2fcfb2b49b0ea105ee7140fe75fed85b86ce1", + "61b19d4d0914ecaafa101daa95feca5533609ad71db3950db0b27869bd2a6839", + "8397e4b15510fb9321be83358004fe36cd2a7fe1320dc07e1ae92cf04572139f", + "20de68ae2c7ded9eceed601ed70bfedb7369891a39db4001b0d57286bb0399a8", + "9dde70a0e831c15cacce6002987d21305f6babfe3655b078f8bb680879521f11", + "b7ab4d979e42c417ae0adf124ce367a32a57360948135988f73ddf04bd2f970f", + "128cc168ff7e01ced7824e7909e663ec5168feedf8584d5ace84992d3925696c", + "f9859b73ea88cad97000504b5a1b6d9f837af8e493778cac01dce5795c3c7a9b", + "e90039423c1a8c3713aba0fed2ea922ff4f71e93503957ea84559dd8818a07df", + "c8967bfbed73b9c0fd64d4d0b7dde04836c2fe2e7a1b751edeca9cce893c60d5", + "bea9a9eae4859a2241eec507747be4ff2ef39c0ee35361d207e5741a0af62e5c", + "48e593b8eb40226c1a4da936615e89079e5bd97bee987db90b73d7af1533c9a9", + "2a40d0f8f90eb81a9b8dc5f3c8c27cf15872500beb7c601bc65baba529ecab7b", + "f684a86705f0cbeb7266d921d3eba32d023e3855651f04817aa9060973ecbc37", + "31c961dcd0e2aaf823cbc1cf1027e6bd56bedfc9a8dea6a3081c0c9cd3f6551a", + "13ff57230bf82817cb8a6cde75a003b3490f906b22958bd3c131ef4dedabd097", + "5795e9a56ae31a22c1d05d7fba69a71944bf067a24b93ce3f35225eb17f2b268", + "8a17325d9b41286fe4aadef9dcbce34a32589bd43695ca5f01eb139fc3e19dcf", + "172cee139e1692e9abcf128233f1325927d4fdd48464072b008fa476d155863d", + "57aedb9a9e5e44495becd45730e75fa3cc6e42ceefea0b0253191515dda75e5e", + "567e3ad8f8098dcf3eb50593c526d6b73049542e74492aaebe0ff78bf2fdf3ea", + "39a13813d31c924036579915d42b0a79de098d87532c0c3eb0d39614a1fa94ac", + "ddb6f92897b5ddbf00fe9bd6f416aa5c33c969812f183a4dec8406bf1ba71e8a", + "a86b5495c2fd3a45ed90160ec0a60ac1aa822d84282c295556590083adac8f6e", + "7f13d06a7a17850f6ac64976c6f35ae4850dd57ff3264fca65aeb2740e5ea7ea", + "920226e36190ac4a9d80bf7916b38ef82b15f67ea3a2f1515a15e971b2c74e9e", + "10fa4008b1f81a2b2afc5128d822f8ce6650a61fd62a6ab24350351f9467566e", + "fee47ad544c9d96f0a1f3a879f7e0d1b206b3cff4621f5967c7508d15ca1335d", + "9015022b076cf8baae00bf10103250b22577cf8bd07726e9ce75fd7efa7ce79e", + "5cd35700f742fda8c34d6e626bb28735a5a5018debc12cfbd362d4360cbf215b", + "b0dd9e003475144bd4343f2a5782b23236b252ee5f9ef53bda5bd38a05bbe2b5", + "42f7d745b636ece4cf40166c0ee37f70cccd7447524dcc5588b551bcb698a0d4", + "cad1a83361d12b325de47245256900cf6ac2cfc7507a50b1c416d1e675c5b56b", + "6336ed0d5b98e037e2a07980097d01113b727cc47e72d8b0804aee197a327f34", + "06c6539e6ffb385a3e1b1f7bd207fa5210baedb88c7f7063b320a93d9932fad0", + "0dc391288370eb280fd7c6f93e4342d1ad965a8201deaa197a17b05716731607", + "22008190434f6e3b0b8b1d7838e785c381e2fe830c6d31a1dcf173a1a79bedb8", + "2e72bdc9ceb9d122518958e8b42a07deb88d4757285e5780cd15186a15e6d1a7", + "388ea505566092b17044e3fb24c9aca30ea7d1ab54b49243ec6411b97ca710be", + "c5e18019199510350b3fcc05b788220f2f749ad81d7b9e490662ffd4ca2ce83c", + "03b5bb4241249891d57eff003351033ce22025f86be7f27df6cccf26b7a2ee9d", + "03d285c32eec5b597fd013016499eff2a147f379c9fcc3da93b12e93e6833ed6", + "2ab424e188889df055faa38486c2ba4e3cf35b911089e3a0b0f63c6a57d889d4", + "d6c75d5064b238eba9f8ba10c31aa1ee2686a4e7178b67a8924e1ea13a7c4292", + "76b5b16042adfb9efeb3a581c94c67afe4ec0e45402205bdf50e5c43a4002d7d", + "e0a3caa439c64e0acde8f892feaffe385ba4518ab813a39e7c29452b3758d1e6", + "8854cefe163d7094c8937d4ac376041fdc4e9ea6396876c49df7faa87f473cda", + "08c6e29d54de4a97744f5d9fdf00d2c88614ae606b8583c90cf0627ef41c0eb0", + "0b2ccfbc82aee98c6ca70eb63610be660ba55ec9ce8857528da8df7cc44159ba", + "ea1464c5458cec3b76a834bb7312498a4a5c1f1eb28537c06202143f7c84b157", + "5b40845fcaf882fdb6bf065d678a039ea5b0b19e1742815404f3b0ac167a089a", + "36dde5cde11c87a9aa582d50afe5e8faab6ac1c9acc581c7b1600a9959aa8153", + "d4aec350c8e32bb8f7ce7714041abc2636452b9a592dfb54e3a56eab50f3221c", + "e14ad1a53b247e11e98563bee4051d126a1f1898234c835cb851edf64afa2b03", + "a7b6c27cee07d17b4863406b5d291c763d9202fa344f7058b036d6eb79875964", + "947407d56033b169b1f993309495eb9286db417ac959bcdd875428fb9b70103a", + "a23d767bf3fd9a0bb7df431105922b5af19b099db2c57902f5dc99494ea008e4", + "2448b3b7ba2e673aea9c8c2efddbbbef88c9d0d3baecf16f9682646dc3e90989", + "6690be106df640435a3079e61a72ec51913ba8aa25ab833ec2e3779ad97dff77", + "1353aea10c4dc555617ee2230e78c9e7674742316e5dc5c07f329b4fd6a8d13e", + "95e33a0f50283260086b4680e67fdf75585f5da568f8f2c45ffe26bc057f683f", + "965d30b1250673984e9a24a23bf60b0e67ca4f0ca983faf0f6528dc2f39094b7", + "acb0171cb71917fba9e7c69b46d8b5b703030986586d79a2c3fcfc9e9d839194", + "b497b9c7c337d183d78eabbb0edbb0fd65da1156651939ce4121ca18a7d0f319", + "256e7ac58d3e78ad58784791845a78cbc41f2e27c032c784526062b598c11fd7", + "18c035d37ee84bffb42960d43ebf6e9fd95255535366103dfda6c94c0e9df5e4", + "e64199ae61e47a4cc2308014bc5e1004c4dc9975f873c84b1bda18387848ae75", + "94da2d725e516998afd63e9692b25e85426d63672ea01882180b6c70eb316c4e", + "e843c41b9c20bc4de2477692b8e70ef5cb3640d179b02f5c40da105ce41b52b9", + "59f6be70a0fd34bd6f41a0c0731502aa8d643bd081f05f30f1084f0da0617222", + "c5de34e3ccfa6ad62691f0c4d3f7439b615a263920a5e7d506f3489320e90201", + "8ba331badd5ddc47303bc9421f29fbc4efcf7334dab223488debc07fc323f381", + "a2612e1a558cf3ddad9593595ea28d02c00fca467e33900626c08131f7f05a45", + "ea2afbb4f9434912e62c5ac0b7e6e2c7fbd8b672cb5e0c9c35b40b860bed816a", + "f3f9f418c1f0a835f10a3d155205f5e439794ccb9e951b1a9e504f290562bb1f", + "e40b80c929d4caa7879dca1aa724e24d8a38bf733630f3d6dfef7c06ce9393c2", + "68e6825362229839e2ae04d1522738edf2f65e7e60acb322eeaf9e1ca5e31f83", + "34452c9f653d75cb15867fdbcee47bee225c378941ae856710817028d28adad0", + "113653ce133be8fedefc7e7185469a75809f668ce5464cc92bd538dc26e63104", + "8c52750f884a4d60afb80a5d94bc760958ee5d51e9ef58e326f50992081ab4b7", + "ccec58e4681da1cedf52558d828a52e250d3aef0507a34679a28e6afe3c719dd", + "08e1fdf0f663dfc1e93c4e2a10407da4b390ff6a6e0f6bbf612105ad76374355", + "f78ccf1926d0c20c801ca84645a5da3d547a71a6a50dd7b1fbc6cf27f9391b22", + "1218f111f4a69030b6978d1d164a2bfcda5c52cbfe13eefe9bca1abfed5925a9", + "94b20e50b52f1ad373b98d939580689f82d4ed03ad4f8f7e743adf1314ad2686", + "58ea351cb217cecd4e4c0a6902ef7dad5cd283643c4e2dbb3917c89256fe374f", + "a6465b684a7329a10c0b74d6b7a7de7eb7ba7affa6a094e8c7a4f2295b6a6642", + "dea745db8060e1927dd27313a4aea94d25da631c0d130ce9e9edebace07ac746", + "367c183dff97f7bab42baf4b796ec432131e7b964f01af2ba90b63a0b0acf492", + "df7f13b4dacb0cf4360585043154b7448c253f843b124fcef1afcfb5c0e4246b", + "713d777997ed180ab3101ce05fb49f60426a91c874c19ef0d383aaf30d16ec55", + "e10253330432bc170a90555c6e4c0d3e2654377bfec00483e8553eec8fe6ab05", + "8137329dcbb8e16bcfc72e4b989f895af4275372a593b3fd0c6b17d4876dcc1e", + "48b8a42f015f129162cd4e087a35951cb5277c85155ea008dd443f8955d841b8", + "d38c76e552ba5f8ed3441f86d260431d423aa216e143fb957eb4703943d81f36", + "4d4aea4abdef8551079c755d800a5537605645aff635891c17c46ca007f5035b", + "72281cf949dd352b4c818dc91ff06b923d6542718692f57f85618d09e7e9e420", + "0246709694df349cdad0fe4d14a730c1c36f905d6cd4adf76e442591f25e10ff", + "f72985668468e42ed35d89066a9b048da8878749d0d0470deb0ab18ac7480820", + "84fafaf24d30aef449cb870887dfb6bdd5f82ff3a8eaa47ecd3a66d2066bf3ac", + "fae010f3579e71d7e07b97f1549c73ee3bc129920278eb126767535d654abee0", + "f7e94480c6fb0ac98a8619c38d852c5050e93e80d3feb6f28ae5ac57e8dce0b8", + "67e67ef07115dff32269f2c5b57fdcdb94bb7adc0fcff75cd9dcebb0f5622ee5", + "ea9ddec0d5e0c349e175c98a30df6929e1ccb416aa35928b576a30350643fc69", + "e4cc910dd35cb159a46f874207fc45662b57413511e3d8532c322b407dcf5c96", + "88203a20754dfaa95a8136383540d7914e43723df194d0553fdded8e52e46bac", + "0b04287938c9f884c29700f609974ccd3377c82101f4ff69601a07b51e102864", + "24dd34fceecac9f2e7aeac33a88165d85dc800a4bf392f660fbc944e06ad791f", + "6feeee7fa6340513d46248d2589e4ad59ce096c027e8c81e806a88ff7e327fc5", + "ce6cd1d842979b9e6d7646ecd8c0e21272d676d2f1ff5cd83fe624d80183ad22", + "ab36ace16025313bb171d496aa5293b9073cbaa4a597525682449fd1aa185eb0", + "c0c83991d92e2799693a54ddfd9ece1bd3d19b0908a79927a6a5007cd05ba12d", + "f95bebc5d2e8e7fece7b24dcafacf30d5b3f46a16071ef6cc6a7820fc6b11252", + "72b437e32f485e116c13c3ed5a17893a8e7a6eede3466b06c7d823f82a9cba4e", + "5e4955da53f3b83b55cd7051ad354410c48332a7f6eba51d3ecc43d9831ac5d4", + "f53da38b89449c2fb116a64059e947b964c9f8040bc70f41b437d258cdfeb7b2", + "afd15d1ac4260dde6f40d1372649499f29ecb67ceed789f88f3e414c381ff7b8", + "585d1f3fe1d7f0eaf6fe9594ddca3412ae1b928ae6984d957ba7104cf65131ed", + "c74b156be5b71b0846978725461c256d9a48d7c8d06eda16cca6f4d4a10ee2a1", + "effbf631f27522684e612bd32d39dc24dc23bbcb000fb95e0f0f17c28f081d3f", + "6d472de5b290a1b6b0bcf0a6f3b260a0e5dbb9dbde47be947f472e0e1811ec3a", + "df783a8393f2a88652063d31b11660aeac0b67faba50a9a960028dfcd490632f", + "88705102747f8a10fe1351cbc15f384ffc7b140d75726889491ea97d61d79be6", + "a25276580c90ab6cc08c555a82bd08bb02dddf0733134d65395be863dec694f0", + "1cc36c6e780be502b33cf21ab17d870404e28ddc6012d940d75aaf2a48362f47", + "e25773d35c3331bce147117ca9e96e7f5290ed01ee7c911974f3d15827005ab6", + "dbde8fca6d798bd596b2f9819085cdec1002508f0de29164c53acb9c816ee74f", + "ce84aad11711dc08feccc2c2fc9d0e1f291a999fbba2602c98f20fdc7aa7977f", + "1ac566d743084ea7ba4b9998114d71fc0fa3bd5c9b2efd9f43b241bf67535970", + "f9223c6e171069ba1245ac1793f09d0a08117d033ed2d7186d9c3d8ff97379f7", + "43ee8a4e0e760c4e2c5638004b09203dfbe2552c1a01a65ffd4b6bd47c5cc967", + "7b1b607f2ef22231a315c104b2c2345c20456a9cc6d2b2a9cbe4920751385e2a", + "f08bfb5dd07191d8e612e1ae35ec79d978ba64e32e510d7091a094f91657a24c", + "c887b2c85d0230ea938b3b5dc0d34911e1cc2530117c22c1caf1aaa80e222778", + "14d8a6a963e0ba9db72224f3ccb71839bdf20f25ae718a1bae2fde60013ca910", + "8ef7800f4ff8c4c7c36dd5b3bada8a32cfce0e8cdae108ab204f5591dac54d7a", + "09503b711c7efa406389b946604d035e895a218293fc83d9c63bc0009514899c", + "752c91d69f0358750f973877a06aaa72ce7275f975d9a54b2218078233682e9a", + "1710d58833a5c9b0149e8066ad8a47dd2c3bc7d6489bbcd6fe99a488fb72de8f", + "30dabedee93edfc8d6bf985803128f65446f1d9b64ebbc4a60bfda81577f70f3", + "ed69246e35411f11f931d56e763ae46b0543b913d2bc5be9ea93e587ccea109e", + "19ac3e081f62aa73066dc7d384f01c88f5c046b69528057b2c9489a66ffbc3b6", + "1cd40ce2ba8aa5d2458e91fafe4ef40cf5900fcc85cc213eb18645bbb1478334", + "e363c1113a588cad52664ab22c1d25505376f7c92d5e5c05f4b86c1681321a77", + "eda482c4ccd098c9163ab9ccf99bfacb6c3f9bd4872d60849151b48332febeed", + "950ee435415ee6059ee309db8a1f35651f757a12767abc4085903d7f2390387f", + "6c426835b5ffe6e36269f710fed16aff96e5f57d565ec2e7a76a8a7425581f14", + "b7f97a7b47f806cb17d5d09c6d1f05d2a395865a29c1f54f6fc1aeb3c20267c5", + "6a6542ae2c32272128205532d32ac7905db3ccbf4730d5c5d0fec09bd4f1e72d", + "f3f95bb39d4bcc21f595d72efb35e762af291ba3d68ec5fe6048c56b9cf731a6", + "2a831c7cda746018a0b7a1ec892496ad4c769841c1a0030ad6ebbc20738296c3", + "1e68b404d5ea5d08e0f4b36f20e599da68d36c5940d0be8a2c7350fc21dcb33a", + "14fd78000430bc451940045762a8c8073bdbb9e8ea1b5b40fb534727bc5a81bb", + "a06dfbf89647f197833aa5d312630dbbdc6cd0d81eff076b950dc14df2410b96", + "2dfc1d5d79d49b3dac7959a529adf073a131897ab6268208a0c95a6e4b736b09", + "0dba5ee1640064e9daebed3990a8a9811ccbedd0c754e1a4fa4c8651ef72953c", + "e23e25a226d05b5798cffbf9fff573edb5bc44aeca1fbbd46ea62e51d8820ec3", + "d937c94d298a5e12287bbba6a4d412b80e7880eb5bfc66bf62b2937725912de3", + "039aa117151a69df02c108d2d9d0fdb7eee75dbb810eebd684809fcabbce416f", + "8575f1775f25554ad351e37c91f5d1b82979ad57fe4a4cdd25c33481e65a0829", + "59b5806c46647ad61baf0717d3cd4a10a6c963204ccac53e3b7f9a1844ef2dd6", + "fa6e0398ff8f814c4d0789ea1239d772aaf24404c9798ca04c870e70c6104c03", + "7254d0ee9443e8a8a31c796381189619e650aa935a8d56aaad60eacd75c39d13", + "4e89a30c7ca76fa529494c9c3e9637d67307608f6dd9b90ef086a598d71330de", + "faabf2f3686a8e278fe81f78b997350e09d0f74b123324d1453ca98879139398", + "2f5f5b75d2e082749fc59f3c0beba35d4e317126ff6a9049a8ffde60f7cdbc1e", + "051556db5c864a40b510b71116edcf4e1f813116f86d26abc80503d28674d2be", + "7a45f4d963f027c09f41aeb9a409981fa7aae619684d079fffdce5cb7ca6a70a", + "5a6b71d4bde5c07ac951b21f8c4c8768665098ef4623de85cddf0049d68109f8", + "aa1064299e0f4a793a93ff26a20586dd1953134045227969a2100656f20b9200", + "6c68a8491159b6ffb5edbb951a080c318c4938a83e3a1d92b58eaed4a435b350", + "907b192964c3a6288e93e4fcf81973f1677bafebc82236855d53f7e0d73b29c9", + "664898ce819d28d376758cae96e6a6a99cddcad2a8acc088c91242d18da299a1", + "747d004ddd6b6c85bb641ed2e279050f925b6f6f3970f6df248accb6a5756313", + "2db716026124e6fcd14a06d494b4ed2de3af4eaa581b6a696510d3d6a21f2e2d", + "362247735f77e347c183cc5451ef78c3e5638a9c6df0b1263b36cb61f66814bd", + "a4bff2ff62560d22380a8c1abb40576fecb672c55264511d917186b4d9f4b31f", + "23972875c154ba7956d69b09ee7f31525e494c3bc00ed4c6892c459625cdfbec", + "659ec55cfd6e46f75b70d5cc00ef7a570a724106eb32542e779d8e452c820a60", + "330a738be5bf5f4062d4d2413e581f5ecbb7f441c10d71c70991e6b020a1dd59", + "54b3222d96cfd245c8e7583efbaf2cfb2c7a702b23c7fa31a0d8c496f4cf31c7", + "643328774fcd9dec58e9270b69628659d25ece2d62eb4d7b9eb4cad5721eedb2", + "507a6af97fbdcb142704d6fc5955c6606dd2e64f0d82978193ac6b0ddb985abc", + "856614aa9a6c64fcf1e7aba7a07e5a387184a9097ef0cd3b9a072a4bebc35a27", + "153d53e3ba3f6440de35c3ed5f805bb2ba4840e8d4dbde7d69f1a9814f1bf487", + "ad385383343718725984a483ead9358755a86a43bb7222a6537147ab7f8c80aa", + "5120defef70a3beea3e6f868534dde9152fa213522e63f82879c00e656655e9d", + "b91379fab5aeed9735b4554c876fbe19e36bb4023832a356b8b85a7e4c2c8287", + "d9aec8bc913ef2b484d3d9bd432f3eafe98eddda962c10302bb839cccc74a85c", + "e0d88dae49d46089eba37deaf628682cb0584f8a6f75fd5833f26ddcc4ce3d88", + "4867eaa5ae2167bde8fc827cbf716f816d872ef350b4799c2e0b4ec26af23a16", + "5f7ae3f5f39df086832a72d2613180367b041b3502485c1cf06fe72c67bc7f12", + "05cb202f7b255e1e220741238409053cb7ae0d4378a36eb0066c3116c774baf8", + "4e65baae06420a05db48c3c08712dfaa56be79416c7282d6cc50f7acb311f312", + "96b83dac6c6f9ff85bcf39189d57ae74a189c323fc465e131d02f7910f3a51b3", + "5908f5ba70fe1b0e67ae85c326596487ffc6653268f8ee9c98ac8f22809ce98b", + "d789c789f9028e1f70bc04b875a52127015d7016a0a34fe6447c66192549a580", + "916a0ca2bcfe0709581dccc05b89f75d56062f271ac906184d577c543c1e9482", + "05af992931d6b101168b70c27c67af1cedb7d2d9855f35839d2e063307e7f812", + "0f40e98dde3ff900854aa18c6e394bd160db3b847728d5402efa24558096f223", + "755b3eeb82200bfcd839944f4107ac38ff1da7f5b2c809acbe52a54dfbca39cb", + "2f85baa4b2a178303ba2a4a6a085a20f51fa83261a1b2fdff0c518e1cb8facb3", + "12777be924aa9f9c3d96da98449486f2be2793ddcbf86dac117438ef70ef22e6", + "88e58c884595e51bbd165e4ef9b8ae57825cf1728897129039b925a9338ba555", + "5e3e3e898425aabd93b2d6a4ff097cc88e860c4282f8bc21bc9d43c986f689a1", + "021c46ae22ac9cd7194cdc7944a6e352232c914b10f31b02812aa29cad9ea9e0", + "becbc40adfa18367060f0ad3a3d9bb7432697ed597f1fa07b2f465403a5ddeb6", + "5242e9221daaa426c538450c1707ad57ab8c9ab3e27082a01de30c2ae21966ed", + "f4f9afbd72e25e116b8ce9a0d7bf24783781f789802c19aca39fb0beb810af31", + "31ec50c72671138c6ed6dfe3e23ff599edc487360bdb9699f2823bfeebe211e6", + "3842a443031354921d89e347db5f946620dd9598a1107511286b67238e66f40a", + "5609f3bfaca049e476e6001e24147fe88a6a75a6f26b66b329da4145603f42c7", + "013362282788f7be2409fb7c695e719c910b75b9a3086aad692176058cc1acb1", + "948435eaf870b5b32516a48fa855a3b21978c8f6f8aec7dbfd570ebe365e1765", + "13b46a2e4f0319093fe3f109932e71396bcfeb9960eed3190a18572e0e767285", + "2876b95743d924cb5dc8dd0cb234113847de0051d67d33d96a16d537ad4c7db1", + "2d1e7b91daf8a3909da9461dca97801179c868fcbbec3bce8b7ead2550d15315", + "573c637bfbf9592fb4764af13af9a06165bd303bc8f051f96feb9ea7badb4c18", + "537516721b4db0b0dcd517dba548ced76d112f5b8d03ce21cb8efb199608800a", + "925b82a9a122db80f485b8149acd4c77c0c099bb91bb7525e674b7878e000f73", + "3fb75c0fffa629e60c7e295318f633fea60038f89071957f4a126fcb88d1420c", + "171af262876339149ab761737a02f527769bd358bb112b2bf272021d8707af92", + "9d2a20998bf53ac9b591c19a455075a6a7eabd11fce83b72a7fedc305fe7ff1c", + "0aba3c6d769f0fc95a27255f50f02299f9d2a3117c2c674ce8837eb55f8d16cb", + "ac705d2093668168d6304069f72472c886e068c1dd14dbee3ae755726ee7b005", + "e420075a9b8afecd43f638789ecf9c271c7e909e0b097c7f72ccd7bb17b7e465", + "7802632f639515d9e83dbaab5df9fd68bda6828ea99990740f02e04b3c81ece9", + "712e14ad1e70f1c7b26811d40aefbe479c2a83ba3238d29387bb9e5d8961092e", + "6af9da5b5bb5a884ddb66549fc24846745c24a59e337c9e0fbbe95773d019992", + "c0cb6cf655e288b81978f3a7a1e3fd608b1304bb1b3326d93f9c816c07b09d4a", + "6fff480d1188c0e56960c03bb10e8dca7fea747584266f8c1d283da7ec73d3af", + "fb540eae877882a3d4539926d6119cc4abb087b29977b407455e4beadefb8cd1", + "69ae564476a3eaa08aabe35f8083cea23a9c42c51434ecfa04f1b2076a63d6d0", + "d065e76feb51fa8b5359f4dad9d335ae6edd646b1f393355e077655aff82299d", + "c684d42796c4e8806ad0e44fdf1b4ca0b1780014bb3c8d077a4107c77b98388e", + "5894713c450635523ac3dc5d163f9db4be7c0585310da91be4b531533fb29b47", + "76c16c4fb43852ece0b78b9f34fd969babf7e699e2eec9bd1b5bb22b01921612", + "8dfd59616ffef9b448adad7d4d9418bac64b85b45b49ef5da4e4abbb2188d536", + "fe4d1b190245dc75270971c29845f37816900710e6472b872d546f55fb5d6e75", + "58a4f4b5ec071647916d7217a818bda8ac59f5c47158ca0ab93d1dd6499e60eb", + "ff3ae6a760fe5b46c78dd08fc15fbed98d0bb3ec257080bb99a5b68ac037795c", + "0c5debf6a2453dbdb13603b40f6b403ea9f6bb612f885bf9a507d842792a9752", + "868ea2883131e8bec9cd02be56fd2e25b925038fdc8074b547f75247ba7c0f91", + "b739b0a30504eae4f38c16fad83dc99808b2a16274a80d36bfc1d4561954a2d4", + "89bc14e1a4da694238fdf61d9c1e3f386d6018fef12943ff7f57e31995491ed3", + "834ed05ace54e49457eb94ccbc5ca92725b80d611bcbe4301cf6232b5188c582", + "498c05da74d6a2305811fd7abed53991accd447293b2e980085a6572023d9fc3", + "84f152ae6d60868ad834ba250336523dcfa3c7ad17003689d1f21dde1a66e56c", + "7182c8675f36549a9ed0259f3f63a49af8ffec8c12983f1ff341f29ac14cbb5f", + "abcbc31bde4ee5195db35fb6850e23ca797df2b5ac2749bce4b742ebc124f348", + "f20d0a2f1056862423e234cdd4b6149fc10015a3801e87226a2d9cded3e22890", + "0a327bb425d69b3ee07cdf446bb85e7c1cbc2c327a748375ee98a03a51915177", + "6dceb9f8e1d2f829d521dc2778fbfdc391d4c7b5905c20cc69f0ec52fcd8cef5", + "32b2913f56dae8eb06dda897736e4975811328f3eae7f47d34926f50c03f1719", + "35f294ab8c066e5d5b2c84e656beecaa7d9737ff88924f85af450a3d0d49e401", + "ceb2ec3808879640dae7b312bee1a4f95d2b77d8cdbacede8396a1ca74c89467", + "07f43deb2f05d369f783991cd7b4da96d1790f5b2eeb7b502e6f564f19cd0586", + "73d0951fdbb8cacae6b41a153c28e89b901d2829ed955f2a1f92e0a8bcbcdc2a", + "7af313a1d72f6e546eebd6a530db324a426fbd6349b8a70dca0af18eb3f0f07f", + "c6561c04c1f417a33913b549cb7a3dd9e8eff350cdf01c9bc1b70f238019d6ce", + "fa4a2407e7c8f03c7b71cae9114a04cd8859fe472dbb07989c7c3d70db1231cb", + "0fd8ee62594cdafafade0febfc6f9fb9e8c945d95adb4700dd36cb73a84909fa", + "5669027f6af7a3c5783e7b592c9654065c5f2ffe5b39ee88bd3c1a061de28701", + "a4e902567048d4f8a745f70a8d9db7215eba8338a1710429e1766359fa930e2a", + "49c8934272d54ffde8c223dd93b0d54888dc4f32fb0d2154357bbbdff8665412", + "1f54cd450dd88e0661c20f7d578a82f706c27ec7db576e72f6ea3da1fb3fafd5", + "0aab8c49b06acac2513245697fd0024be3236554e3badd2d551de0535437d673", + "8b053c4b70898b941dca656fbdc056ee959efde7b05f25c2d837f8327da6b171", + "9b0edc94c7eaba9d874fac7131fdd0e6c1914105b62089b95f74841f4f277969", + "102bdd935ee435d62578804ea72f3512da58fcd3e14432ebd9dea00748fef3fd", + "0d3db0ce3302104ae49cd6d976a3c7da620c4d843d831a494b5cdad0ad57b02e", + "4a80d7bf052b7f01c386a30dafdc4ba04b1136dc496edb811acb0926adf79efc", + "0fc9b49541a46ba2e232480e0eede5bdc77a983966f48634545978b07e494b93", + "b459f24abec93e4c1e2d37942c44617804a5040a51853127911cb90f5c639ab9", + "b2f420c12024da45398c06a3786e637d839ea4c9075f6e540ac123aedff81836", + "197561d1521db16f51633b9bed44e651113fb52d53a06a7655f3ad8be50dd7d5", + "08e68471c4d8edb970bdbf8c3e8e1a68b621c1e25841d69d85b81313c9f6d734", + "85a13da20748347afc0243526f7ad908453025e42eff0df11f6b15169a9e8630", + "eb21fb1bfff69313d35970465601e3886adef3f17685104a434d6c53bd694ff1", + "0f00334df9d5716dbbd7a98893130a7afe3258a6ac81adc4389768f76e9fb8c0", + "1f1ba7d443989b048522d7eb4fa2912c4cd94762286dc6669181cefc456a398b", + "639a8ae4252fa2146b434fa49a9328b0343cdd0d92792f57ff83d349c63aa930", + "bdb230a91c8e7eb2f719306cffda3cf8acf08d89cd788a67cd8096cddf8c11c7", + "e5f6db9222f9f38b8fd9c78154d0af1456623fa6b7befb8fc35ba1cd574422e6", + "85906a1dc5382af41385fdcc4bdbd80ee9ac9e9e0a0b3e1afdd226f43e85a810", + "44a1246c039540244c011a058820794dfd30c2e4275b20ffe36d77d8b1abf823", + "d6e4db468f3289a5a95a15947812752b50f18a4c472dfad3caed7700814f246d", + "3784c8ee5717b9b5ee45e2507f6ed76d08a7715dd80a6bbc7fb9376e4ab66877", + "eafb0020adca881ce6b0145dd85e0eef63b2cb8bf17446d53186a1d1ae033d37", + "4f4721d2480124775dcc7bcd88357a5efaee4215696a6c85c5fa3426d52d3c56", + "7bb8a43a155778fefcb717fd5b7c4de7716f4764f4df9e7899209819ac6fc990", + "ddc229bd91648b56b73dc20973d83e740e3f0086d2d9f94ed3f42887fa588585", + "47687ae1de7f72aaf6f6a239b55a38c61e91e1dd8238bb64b7f8c60db15b2818", + "1caaef223ddb7f4bf531fbc5b3db3ea62cc709f4d4a9feb4087d466e7003a898", + "d70ea12cab4504a0a70602e8d2bfe3116f8bbeb7d205f3fc954c60cf985e1378", + "ef04fb366c7224b55276e3ee42f577c574d5d0ec3ca6ac230b74184e97f9120b", + "7a1cf80567a3f0588475416e946a63477690bc830e3e8a59cbe5105094229c72", + "b5bd3f45a5811b18a302d275e6fe67be36c478e24bb19c83ef66554f1b6a0e41", + "7361c61070d80b529d52a660a0fb11122970d32bbe0012052fd3e619fa496877", + "c72eb24e0257a8ce0ec84cdbf545fc264448c9974e56ac47aec169daeac934e5", + "015c1b0566302fce8b821cf284486766621c026998718b162ba7046ecbe1a486", + "8b63820337434766c74b57e3e5fd97b0d5e7f2761cba23c79e74601b9871b2c4", + "1997a74370a14b2fa95f2207dcfe55397e88add1da1f355da81d76693112e846", + "8dd5958db03eb942b0c72e9f1a7f95f4587a1aa7a364100715d0bf8a4c0910bd", + "36e9691641151f14aa3bf1b939a71d5438268c73b30e788fde2da42527d3daa4", + "2ccfd7d3e9b293962e8a63187dc820b1aacbeedfb75689f71f312de68cba3d8b", + "9d1a6dc4f63b956bd2db095fbcd4756eeba21d7a06640b9f1a7ab0392d69126d", + "1e661abd72ef049950afdda7de315a910a553bf50ae92de077a1a3c87a650942", + "0d0ab3ea5fb4e3096322178240d10dc31416a086428215e6167bd7a2b1540531", + "0091b6e3ccd36dac037264cb095a22b226bc412efab16692fd398d4a94e05f85", + "a8176a97d42e98438f0d8ba9edcf17e937e776cf50eda8c0311cf6ca1ddcd83c", + "3140a98816e6991a3cb930bb20f5e31b8c87472351a39b54226b4b648a1a24d2", + "e97dc9b6e7dfd33dd7151c97678ef633c87b5e41ffaa5b9a40fbd50c80536602", + "723fad278678ac40c1ce8168a35a082dd6fea90e6b7ee45d23a8b702da70276a", + "9adb83f2dbf01f213eb7a9d9ca5993dedc090be00f5be3b22e770f761a70d04c", + "6ce9e7dba3934ae265df2d4ed4d4ce7befca6a08fda6cf41d54b878670b2d85f", + "3fa5a35e52fc3cc8812ac0740a3e255a33d3534c381ee9c5d678379972386980", + "40746881221bf2d8b8a84ddd9e6ea2fac9ad00046cc5b81d09671bce11f5a1e8", + "99b6e17692041cce01c736e10fe42c35382947721fc8ba56994c818b57404332", + "303c075c5cfe537dc08da3fc036101800b4fdc5e536883800421ae1f32993137", + "f3efebb5c9f3fba15c6c29e692fa11931d4596bf8cc21c73c2c9e24ed43b3c22", + "59b871bd550d7691d9f8ba61613aeaaf524699d0eae67653553a01a26a781c77", + "869937fd42be4a33d64181891d5a8f9ed9b3779d3db5cba5dc7fa464e517222a", + "74c225b32ad4de15198ebc730b28cb849c0afa1e033b452da11610eee6165fee", + "9e50aa3e84bf22d0d71572d447c1375aacf89ac0a20a77e5355bf4c8573ecfa1", + "2ea79f42a3229c1a081d11c6a8803cf7c10035b0f447dfc61c5ce6b8c7a5b298", + "b973ae192de72722698e84cfcf4752de6f48b085b50691c8a590616e7a0cf9bd", + "ccbc806f17971660c4429d1e021b5ebb7b2c7f76e9c57c77f410af519215ad38", + "462033629a7f6815be60e8599a8564177ce13b995ed2efb50b8507780018c3b3", + "f807b755c4305f0e35a9103dc78bdd9eb42af9b0d74d202363523bbc5ab07c25", + "b53df2e08ed891d708b9005a6e8d7606f90038b42666c6cddc733f828e28239f", + "59afbdc8d7fd0e1d3f2ddc70bf6b4d55a23e449da5b920b1c4795b1e5b7fb941", + "78d106a57a655da2391632b34a55d064eebf05ae6ef7f76d7ae066de371d6ab1", + "eae4f7a612c72cbab137e251d539f961908eca14c834e53bafab548e2fd2f798", + "3104626861ad2aace320e8efcd69db528a25f55155ce6825f11c4c3edc816280", + "6c63acdb1eeb73f9594414b51043a39fa1094cb731ca290a442f610e3ff0559f", + "65139f2284fabeac2df2ebf7855f97d22ab3e8d7beb4f0a79e98d4be09419d7d", + "b524f9b4611b5b8104be5f691bbe4deff765b666e4ba83edf0312a3d38c5224b", + "7a2720b48971c3d869d0a3343d4982e57f0daa2b76775673e6b7b86eaf758bb7", + "f246b0a6a15b40cc3001168a017a010047cbc1b51611f14fd9fb8fc3040d273a", + "e3dd7003059ae6f9b90da096cd4bd2f11a58ead431243b55b54ff02a620991a8", + "2946b0b04bd14638877afc84ddadc01a3817ae095302264803d18d138aa8f73d", + "0668f962dec81ab82609b05494f13834f7abf6a7be940c0ca8ce670196cb5d26", + "69bc0d1a3ab210bc553bbcb25ff00e9d11e9093b947e794823e62686c1e5d5b9", + "e1c11166d41f4621f4c2b395e7b3ddaf87f4ee109e8224795ffc4bda16f01043", + "0d76fc2aba8bcded1e703d2ae621a72cf2bb5a608abdecef008e17ed15dab9c2", + "097b5d58f07bc22fd0dc7099369fa3ec52a8b10ac876e69c7b8e74f50e92413c", + "d971ebcd696ad0bca62716bbdabcf53f84590d114d20c24e97e5eeb2d2764f85", + "354e587c06987e49779798b300f1708de831cfe302bd15195cd0e3f5476e07b5", + "291ed14d18b13c8f9325e3b72341f0a3585de7a14bb66e73b7e550577ec82690", + "c74d6345cce45f6f0aafc28e777727306866ff2b59e14885cdfdf13a238158b5", + "191a88135ed8a79d43d046e4d7a23ed6e65c9b43e1f9a6e2327f0932fe3e0c67", + "a2dc2ec41d594f99629a8792e456d377e8ffcba7c844ef5a0843ccb4a781ae5f", + "4092e0c4ca8fff43cb27bde47ae53c925dc69110a0d8be98cd35956e17acb5be", + "63feeaee98344fbe4545c82d7c1546da6e7ebe59568d18eff377fb7b2be1a757", + "3e2accccf2db37b39fca681ad7f39e9f87389b8cb67a4f73327865b61dcef319", + "4de19e68e526973f46a314ad8f22ba6a300f43170f7e3687ed27e94b52c19e6d", + "b1ea40815fc7d63b8559acd90404fd98d9072b085feed7b984b69f314ba46069", + "ee6a30abcbfa8da8267147f097c5a3d319209dc000551decce960b1e4290aee1", + "a8ebece7221769f135d3f2078ea5dfb4beeb0af3bb94242fa1c759d0303a479f", + "2e19698b190690acfc2b6d59972776bb219ee5d2eab28cd8f2bd30eaf9a19005", + "17bf5ad6d4f478443eda406e6cf83c735151bca81d3b6613618703020bb2f3ca", + "a0edb8666080348fa89b5d433f36014b6051f45b8b10984f603a3e92a857742a", + "3a94e97d3b54272104b85cf068c1c5ce45f843ac7b78398cfb210f8b66365e8e", + "6955aff0624b334d6050bed7a839f25b8c8427a08ceb78421cf338a6d557c760", + "e7d8d297b674cd580f3931680133189cb1433b0aa16d822dbc5bc4837ff51b23", + "3622f8c7fcb0f67e6adc992519c042b09caef152b5935acf9864dfc02acf3fdc", + "7362f3f84f278b17d608c4b8887d2466b382142e7cda09731ea3d456bbfe4a59", + "cdee9743399e692deb72b710b777cb2efada8c796b1e5716ad2f78833e62f0df", + "10f5156321212ffb8185002f326cbdbe7031a4ecbab315cd3cc018474593e9c9", + "d12ed3701d0c0ec2a49edaa4a91b6c5c3d9a7e8c432a6278234d41df4144a82e", + "9e65c93b923433474ba9fc00a01e31aa2f74442311cf88fa8218dbc08b4a0d0e", + "e6cbf7029203aa92386a2f8ad976042dafcc154f8f39b83f42e9849f47d2ff7b", + "364b06c5cef9973531a30ab5a6e87885b673aa11e99009f970ac93b9c07c2db4", + "d6eeee18806720db9af7df251b39d90c8f44cc2270df85df7fe9cdd5bffbc4d2", + "e9ee38588e228cc12436e32f22d0f600feba74bd4e1ab89579e4b1d9e34b42a4", + "ffc2e8d402025e2ffbfe0e565f43655fcf4ad0c6c6101697a81d4f33e5db783e", + "a03fc85cffb7fc60ad45b89a4f5808132d6bb3b149a7a87b5dea9a544288fac3", + "15cedf0ed957ea6d51e128bdc8a12db4c8dc69b7b545a5810208e21aee950690", + "58643f482e2f9c347965390f0b64da77db26433e5fa27e04e32fc22b8aa1ad03", + "2494217e96f752cc1f3e4f98ccbe138fc01e5ed270c85581bc52aca606cb7651", + "30ff9f40a6cfabe83deb66579486c91d5f0d542fd494f9c2a42696100897255d", + "df22d70abc8f8bbea79feaab85c123e2050c8bdb379fec80d3a6f169d4192084", + "a85244f701acedc905df89086073f6d760948a6de7609bd22997be16fb3fa7c2", + "c6e10ba5ca019f3cbed6ce9d2523132264eef6afbe3e7488c45f2382271aacdf", + "1a8ba9a12b148faf5d93bede371309e61c09c792bd149f6535ad7710df30c9c6", + "d0e46bf6f1490e9793d0aba61f958bcb63a5c231a036aaeb5bf44e8fa9349f56", + "8f9c0d9d04082ab28ab7491f3217eabd05d20be030d689d773d7a5d64511be29", + "99de3ce79a6c4ada1d9ab37cd81c6af733a7dac9781ba997c32f048716bf3e8e", + "4ac112924cc65d730bf03a9e231cd1765124b1b36705b88ce41db4f377851303", + "a5ba87a6ec998b7dd6480c2171ed75f204fea0b7201473c22dc9ff59bb1b6ef7", + "479f08126a22982b9dca9323a88f341e98ab0bc7241a24330f622d277777cc9b", + "f9476f7b25b46decea3a893b5f5f477f6373a3b06608407c3fffa666f519d95f", + "d27ae253c57327dd8ad2827858b102f38b3caaa7611b979fed8b333115e7b896", + "ea501f7b993740f9f20022a49ac36fc7ea9d70a25b6d5624a138a780d91b9c61", + "06be93eb7f3c2746a9e1fe9fd3958c84a27850cfde200fd259c2347029d9250c", + "54b9c4fd5c34edd0bd466afd7d7320d9be1d53a9ae75bc5854a5bf02c97c0077", + "b985c0f50a27d01112b2eadc03e00a2ed112446db46531ac8630a8173860d59a", + "0471285323666f0d9c9ee939aeb8476fa6621976caddd9f329a3956b22cc8eeb", + "c8c121749826933df37a9b820b1e326bac95cc4683970a027473a42d3bb7b305", + "0a79fccba0d219cc134eadb78d9751d6cd05d8cf9e9774631d645e61e5d7c120", + "bf9fa771c62e74d2b02113ddb8fc1e3cba0a78498c5d4a6ec5970024eae899dd", + "3fe52d9a0e7af61a665cad8c59aa6f8d9133f60e2c6f24fe3ff1b4a2d15b38b7", + "74906a9b1b7a10ea296c51ef3e8e2f099eaac9159b93e6e2c1635976efdd90f4", + "909d1c95078338ce2d5e3184fa99636ae8d9d706c61472bed3cb1e6cd9c6cf8c", + "55522b87382feb6cbf18a1c77b5899a5ed3d139d182dbd310325a6baeb49e7ea", + "9eb2cedd0f54ace49ba99dae5f8e579fefb13f055439081a1e33eafe7355a9cc", + "f4c532860b8895fa7ed05ccb2c600aa3e3a4a27b8bc9b0efb089e8d63aa7f8e1", + "b0e407437fb21055d0f22271e59baa410208f1f1fd3a4d08fad0a91ddcaf2d5b", + "7afbfa2ea2ff8ff4601b0c28247d6a677972e754251b08be20462b3b8c7aad80", + "802cf560f13d205f8ae62631b263bbe61baa8f026b04d9245d3c5928ffb7d251", + "e6ce0d90e7911b8c8a9d9df076129e86ba3ce6fed661badbc9a447a4dc77ff7f", + "6e53b391a0814387d5060411799ad198173a9f8626fb93537b45447edb97129c", + "6173edafd50442d48cf7acca1bf699dc0d23240bd78e05355f0d7ceda16e2b84", + "fc307dc5256235b6580b01ffae65ba48cb3f6fd3e813ca618dcb5cdc361f8081", + "b748fbd3d8c37552f88bcae62a12e62b22934e064d2d85b52276f0178dc5da0c", + "f6ee180ad7bd19c6e88bdcdfae34b87799a212ffa98593fc6f29457beaf0ead0", + "9ff4481f50e0975b5273b022ac9a10e02b303af221afcad950c312dfda48a4b6", + "d7411df5f7a5254bc77c5615701080ff534a278c498ad421cc161fb8729a142e", + "a4d8589d75607917186f499f01305bcbda3f4b76c87114b5dc336f17eb96163b", + "749c3f57bae77268ed0b54466c340c22a9ef933bd3619046bd4f8ed70ad4f964", + "fe91358bcbf7b9e5c381c5911fb12974f7312a57e7a3e43aca9bf18641710680", + "f3ef0f2ff54d4b9db7563bddc6c82cd0632dc21f42a6d32432cb4b81740e1114", + "39c8eddeba1fb3397893aca0c369edae1b6e2ac9f34a9b3660f442b106364ebb", + "cf0bb23940cbb8ea112b3df3972469c79b7b4b2b0dc00bc1e8d0727c6c215cee", + "3f8d7fe3e0e584d770c29a7561e53052a3683d9bfa50049017c7f5a107d06a89", + "19260a112975763c9b5004fbf8e2400b1d541a1c3967840d209f40d4b4a41ae6", + "6ce033301358e2d1650cd9190a688622f64ba1c2269fa07020abaf6e49f012ba", + "86a3b0c8b499c4c36350d6e832a8e7a6cd51db2b3a745e288508e05392a43332", + "746c21c2eb4f12eff443d05fa8a720091d3bad38a86f452d110fb2eab5497ca1", + "d0a343ca65d369d9ee91cb06e849112411fde9ee4075ffea303933fd75c6edd7", + "8c507a0c7133781dd3cf7f2c29849fa4e2a08e757d2ea99a27654e2a8ee38d22", + "888a2ba254c355e69278acc65406b5f4e65d53724b287fee7004e1c1804dbf81", + "60db2cc0274c527bb9a351442165554cbd2d0c3e87b1967e3f1104f370650e82", + "d05ad46273524d9c5a08cae50a6f7faf020954145b7f88f28660fae241a20e98", + "a35a4fc1859f4ffd39041b86e179f4f6bd992402db304a8de85cc39ee8e6224e", + "cf5942f25c52a082d645fc36d331606ead862c5c3bfdbae1a4cd4b0afa70288e", + "2159c1e76fa4d273ba8769c8f2d2cb5a91532bce4a8a448a581ba337f2dabcf3", + "7e9a67b5291acb26403f627d67716b2e6751d4b4e1185eaa6a87604bd22ba99e", + "47b11edde5038451d65585069df2a7879fab4f644b13cc2ab0e0a691819f176f", + "16eca1604f16bccb1faeacea9b2857fc0d86c901a0a9c9ad4c6719496a8dc6e2", + "9a5cf8b6b6776a97ae10818d239f885ebd3d8f232c84a27ded652cd6dffabc68", + "643f83a9bf76ee948ee6e64f19a5421f28d7951070184a01253dccc5b04dd942", + "53775859344040620c66efbdebe7b13f34dc7521bcbe475bbf30e612be24d08a", + "4125d5936de8644faebe071416eefa4bc5331ee1f6129f8a91b59a27a62610c2", + "c8694624df0c78442299f5132b1fc1ffe29562bfc395de417ab23a7e066b3106", + "f0b10631d299c3c6fc1731931bd67f71c412ef4bd2df154c395d2bd4baf9b783", + "7fc7dc8519f29a4d6a3180c15c59263ce2e97f3e306474fc893f6abbe6bee000", + "0067da9f4770297e81d6585914e24964569b627515902117d9f4ed41420474f3", + "46b8bed573cf874030aac705598f3e9b33d45a2615fcea5320b4cbdde39e14ff", + "ab731cf533908927a3cd8159cdfeb228d91287f481f4a64fd98fc748c1e9c3a9", + "b10a9761a69b8c4229f4af96f689715eeac26854b24f391cce100d91dd6e6a44", + "821b4304a6f7f4d638fbb144f8a983a7ec92bb6551c0b77cf84e199ef053e41a", + "d015ccfdb0bcd0a2f67d553ce7cf3423a6aec51b1b7ab507508e9c754f18bda2", + "2c6511d9978e68eba41b735b9f69c3c58e44a80499cffcbae379ef4248f5567a", + "885bd50c85fadda4af9350a8e5e9925280db80497e030358430580b9ace7a8c3", + "bdab1bde0ba5bec1f1227eebfcb4145367528c914fb7f9f5fe80b302e295ba39", + "f2a411f9496c170a7454ad15719cd35bfbf55d91d3ac9f97e10c13ffae07dedd", + "cf5a92c5aff43e93780f964dc2b2ddcfc87bde103e82d35b27b1a054a9175a53", + "92ecd6292821ebd1d8f722c95e8a1e80b385feaf3592ab505a08f244104db76f", + "62aa94088f012545c13762ff96f8a2220617afd4d28baa1ac48fedb832662128", + "577472a05d792b7c3ab30d3ea32e72e3bd7d592f3dccf4cda3c8feec50765e3a", + "3808abc673ba968f26c52881e2ba60e29d9179d0e4fc2037922fdcc9943e000f", + "16b269a68ee2838d5eaa6de529aaaf34f082f7a02979d5966d36f6c0f7e3570c", + "957c5670bf8092de70b4ee890f1b6517fb32a18e49439ca30324b7782d587895", + "1fd509319926996218ddb094ec234e4bea387bf42d9f74bacc19f220d689f882", + "da481383261761b5d1e3fdf8cfd97c2e0a828387ff972b0eaec01ec0841c84d1", + "f9e7230a978850c69a7cc2ef42d5f6435a58c49dc471c58fcd8b60cf42552e02", + "e1f23c3ae7af3eaab6395f49b39ac4a0a147d335baa8d5fd4a3d59457239c446", + "b1521fd5bb24e9df32e0a6a8a11a82ff3944cb0cb596f5b751988a182213d33e", + "d58d49820c2caec033b24e383a544fe8b7856829eda2423ad31efeb1ed39aea3", + "398bba2191261d764c29f5a7def2f2f2dd5c3566cd5e5bab73054ed5f8b6e7b7", + "2ddd58542868ab5a097c7976f966758649b5cf703e97b6f07c7cbeff2b378ee5", + "ac3ba64fd233efc40c2d523d6fea2f767287cfe37bcc1864d49302cbcb825989", + "d66d125cfde2e6d93fa5708a0157d63d138f36e13078789aec430f2a35b92f1f", + "38ce4e6a98751790141b33a517d3ac1b008d5f67b948c58270a5c720c06614e2", + "1a5519378bc05e75c51a92bd519b51a488e4f7295792433063879203795dfdb2", + "d980c11ee2b55354c58f06dce9b7971f39df69f03e778095b30a4dcfff8241fe", + "e50cd31e29208f44a1c0abc1a3ea61502e91211a3c8a626344a35d3f48c46a2f", + "fd97c0328e01ad083afe135c5eddce470565d98a06c1766a5aee2c0a0a9792f5", + "378c04b3d46e36a85e23cf468603363439a77e3849184adc5d4e2f9d7b0a6471", + "fdb5fa1fa99f32773bf2e158d9d7acd58ad4d9117aa74e5e3cfe5c6796a61730", + "ae95b6fc1a1dd748555e604a3be666cf9e6d4b9f09fadb347cc17614e2613e31", + "1b59f96cd2885d6bbd228f2ad48214860ec2986ddf81cbb8df2063f947fdb0de", + "2811118c41fce0cc4a2e84f8ab5479b8b11355b8d0e42f7839f28c6fadf6802b", + "f2b8f1b95ed1228feebfe6a9bb2bab7f7c41689183f8e59e061a34ecbab46d12", + "9a3392e0896cd7a4d74db40432bbf0f795daf26eb217e746a26723f62f26a9a1", + "f65a82c47b7ec03eae46d5b016bc10ace8f0564d40795509356d46865ec3ab7e", + "c48067f103f9e29909e3ad6b42fee9802dd00869faceb17eaf63954b46bdef48", + "0712ce46f97dec76e6a9af383b2c9691c73c12ab090761f3609cbce614a66d8b", + "d9eb0f9a67f37ecc47dc88907da83f5e100c6fd70459a4779be3ff440178136c", + "b0e932e363033187c4c0c5f37c94c53649d9a68275e951ee87112529d313cea3", + "5741b813093bf3d1523684e18491354360aba905b438c8e7ac6a86d8162d9cdc", + "4bdabc56faffd97c3eab6f413096507d0d36537890fa4a6920ea6a06cec5fc0c", + "7db1a9af683d131f0ff6729cb6b5642564c5c0420108b3b6ca304396fdbe8e46", + "688df2d23f0d4ea7d55242c14b1a4d863fe14a1ba38a7e74822fd42ca436b576", + "8bf876ef3e3f7971c6e696ee828c53641efe5713053fd325e242f447087cae59", + "3b5b4b95ffbccb16a7615374ef8fd6d6ece664b30880edfff0a426d670d25016", + "7c9781c9527bd7da3c32122483645d0a6007f33bfd2b6a55be9997f39a1cf3c1", + "8cb0fc66735a9f06341ab347ab1c256850a2ea4c002d4860b1b2bb5f25c158a2", + "82e44a8ff07a5c5aea7b69a425c83d9da91a7f36261e34f2d1a38841665f19a0", + "7ce0ebdf70cb4cc2469e06ce48261a4e0eb411fccdd22d3149559851b4db0dcf", + "7c02d71a5c584934b14a244238485e74f319490e2a3eca896ca8c45b397a318a", + "2b78581f9d2268ce3eacfed353cf2765d9b4e5a2ae9af012f4302f3223df920c", + "69d0d808b8ec4046d677bc899fc38f922a6c4e6c3d26abe8e7c5f3d7672888bd", + "c293415e1fea8057d013881f1f12f9bd46f884cd6fa1dacd85bf58279aaf0561", + "a84666d767f558e049cd28f378f85d5a721c86a9283d247a1d40c8495f447f23", + "10ebcf34323a3964e0924fc54d9d5732703c4c34440ff61a2fe32b3193fe8fbc", + "975f9886c1cdd82ff31d34c88a04d86036d8703b48873b33729be7b4709b2543", + "75ec19d35b0d15d39890b85a3f5c0f949782fab2d2c48a7466c2b424e9d04443", + "19f6f85e0f5efce8c837b8f00c6567cdaa48c6ff0ab7e22e64725faa4865cbab", + "05e36e07c820578b0925bd0571f7ad9204b5c6deda7302fb3540ac05ae93b973", + "fb40cd6c7260d5b085f244fa9000f1ee6a82eb971477dd10ee7147fa2feee87e", + "b63680e51b64f90268fa012ef3e23a1b9ccf711f5d4d7c57e26eb3a057fb612a", + "55546f2a2eb86e837be12fa90446321a669a56b79fbb664ee16636e4bea3598d", + "72064e6b059da79e40106dc7bee0fe97ff9ddf2ded37007762c3d208b0db9d0e", + "107dcd62d102831edc3e2694c5f5c67cc6b7739ad5b6660752b2484e7d8f2318", + "e47748f8efb474c2c5b837b387719c56f62e1b3cb5738c984aefeca2590d92b8", + "75e8874d94c5d1f96c9b107097e24fadd60d8fde65048f9ba88280a3cf692a53", + "e57c19113de3b4c7ebc1b4dbd0e249dc79162ff86371f79a1c9750b51038562e", + "18db72f5aa938352ee5fd98253fd1f78df8a429288e56b324c1f86fb32afd556", + "94c1073953a3da943172ecf53aa404d2419b6117259ec8375343f882e19be719", + "df898b1820920b71d7cb43a7ce74b1e38476dbe3bac5043c4d5cff3aaee191e4", + "e96d74dfeff91ba54a523c720a5c4c50732b3df680636715e6ccffb3675bd746", + "8b56dc5d5e6016565db0f3dc4a9ae170f81e57140cf8c24bfe5fed2b04e5afa6", + "e57aa6aa6558070f08566500c3d3d15a55b2f94d786725915255b69b32ba6ecc", + "5ee3802a0654794c7c100cbaa6a24f0ba72f3bea07d8f613efbd52f25e2fdea6", + "29f10905875da1a725945d66a412a025aa8a8a4da9a28e8bd0c2cb7829b6fb24", + "2c68d88169dfc9298a3796b6fa194b6a233f1aa2154708f6d69e5d67717a70ee", + "8983cb1451311b4a19ce2ccc35a69e1478691981295382b9f50a687b09320bf1", + "d439bee534333a85fe790871366eb64818f508807bea9333437c492a2ed504c5", + "a0d9716a6f80f63aed65e3765c8b655a08095d224ab1ea9ea40a9b3044953ba5", + "7f24d0d838067a79172d3fa98bf87a9c9abaea19364fa9b2606d7b1f8a2e6b44", + "7de4bbdeef9f53032d6ac3eef69925ee6f75e25380c853f16668b191f1cf21c9", + "2d6909371c1f47fee447cc84be22eb566ebe34f87251fda8e1cafb01d08f9604", + "1fda88bcad2bb038a2f233be2bc91677e6462d427a6cec853a5ba5e8c8a9208c", + "e0ec78f433e1b85c95616d88746c458cdb7c3395de7d030bebb08252de63ba93", + "15edb552db6cbfae584afc93ac379fa7f4867caaacfa69fdb756de9cd2e61d9c", + "a09656c062f6b62591808cc0016d62134a150a88f0dfc0632491d9f4684b748a", + "c64c14f05cf8fa41a0b3e1eff033184af56946fda63a644f76fce52b24fa2a06", + "dab967e0b927d36d14f4d52ff315fdd8593a393138becc02a5f076f33b9a2a84", + "380bf32eb7ecf9fa7c37a15470b6cb1b6f099f59845342ee0e9c72f3e0be85e4", + "1a08ab61d49a3b9ceea7d5c12d5bd775edf4e5c0dc124da97b87569e4f1077cf", + "eef4a9be616b1e48e64eaefc5333ef7bcd7aa01eaaa661ba5518d1883cde4925", + "f7cfe8b40e49cff23e35cf189dee29f30ed7d651f8cd2237a849ab422e2cce8f", + "b6186a75b40b704b0234588af00bbaf012a455de94e04b5d983e27b3eba0dd8b", + "6e06268fc77ba50b80d10d2617ea7b142dc9191922abd11888f21e90e86ca5dc", + "fdd8c51767ad434981a7939013d991faea89b096ffffa5ff79fcbece9f4848b6", + "0bd1156d71e471b573627637915b69bcc69d8a50ede84286f54b399409484fe4", + "248a96b34c2067235d17b15a2d9d1e9a2c7867e4993e8957e0e5508e904f414e", + "39c0d9bce4d7a1b91109dda5588f6b174f19365525cb905931345dec97d62448", + "760b0cfec7b24883b2e50e3e5e15df5e3f71ad364480d58b82faf122503abf9b", + "72856b1bda824601735150aabfe7c2e307436ea119f7364099d25b9950240dfe", + "49364035385d92ea8209d95d62e381fa5ae8e5a0e59596d1d1fe08efee3ac24d", + "7f2ee817872d14c1865f1913d5ea6b2cce8f330617f6123386818112f0f4199a", + "cf0940a356a686e48cb59986a4e6ec3d19ed4e0a7a6b304b333b529136268326", + "6d0cdc3ff7980d12dcb3a8fc646c29bb05a43b1f34d5f23cc5ac85943ee5ce87", + "41dd2910e4e3feb33993ae95a35eff8b8d0047b9ab25344465cb568da6a3c3db", + "b514b413f3caa115a0d88056a235910d761ce615a71c5d87ce4445822a247f03", + "c4ac24dd52caf58e380dfa8c3f1dfe8116415879923e6f2b690dddf11872262b", + "8872748eb77d63cc099a6efe966fc7aebff32e84002129fe12ca08c2c09992e3", + "c512ef284e506338f4d442a1c684e7350ebaed22ca0e99e8f6797bc12d16b585", + "e73507d5c74d90d43a2d7bb2fd24babecb78f18df27d0662f7eba48e470e001e", + "c629bedc1aafdb388782cb82b8389971ff328ecf7461384cf0d1a5d55a2f233a", + "2714b62d5adbb94e6c49ae6f19532f8fb4c50ba4aceac7e64d747d2bd72884d2", + "49b8f913f0dcface1986b41751e5b1db61c648b502c9fd1786b7c779336ad8e4", + "2b39e3c9d96534b99ac9ca9a8251d7dac5d320276da5f28619912ca9ceb7a944", + "bfbff3b303154d5b05fba76f81ee90bac22019194dd57d78e51945c4c457b2b7", + "33af43da44e5ecdf029639f0942f3f9935e86587c331c2cb524f05df1439b170", + "f476401e6ed91441da6a5c9079e247c6ca00b5b80a1e314da4bd870e351bc779", + "57057e1cd4ae90ba64388d5516a7a6922167df3d11767cc57408beb6b52ca1ca", + "0eb4ebceed12b1d2ce90fc0250311a0837b3e3ed10bf5440cd1ac2c4e299c642", + "8ae345a001f2613d483f465def0bcc8d32128a1222aaa721b1bffc6c1a0cee1b", + "48618f88203845866320e23d5f3232afdbe2da66c544a1f82885e0d898630ea4", + "236e9886b9b3625db733ce4bae2e93ebad3fcb8c6c6278c41c2eadbb417010cb", + "af67e9adc01c89fafc976c790816ee9620831118edd5f6708e44ea2131863813", + "915dd75eff4d50e9fa021877ddd97583dcf656084652df0073d3297d962038cd", + "a7a40870fbb2303d6b09b18285a585f21194b4fe404da41ffd9beaf4ebf21009", + "2e33a723b32275f9973fa0a6930d67fdb486393f37c9ae0409bc93be812fe2fc", + "b7e7bd0544418b9f46c4d2e8725cb08f0a4e35cf289deee51633b28041559c3d", + "46b26a37670d708ad4a46504010e4e0dfb22a1bc2c298522b89d01a9ff00231f", + "437c015b199bddf016f7ccd38ec0c34fa83106c77eae0004e0fd538460223940", + "146c678ef22f8479d3d9ec04c72558763e5da45f1754fbf864c2f595abf21f23" + ] + }, + { + "hash": "213031765f0b4d7bc826ccd5bdda3261f624187e2997a2de61111652d31b081c", + "chunk_hashes": [ + "81b34a5179857460a1a5ba079fcf7231c307a19940ccb769e49240df5ec6c466", + "9dca1d70a694aff1652bf62fce776a2c912ee920028734e65c188061a27ad804", + "b3b8498cddfd8644b77e12ff673ed556ea3d7c372e48405f5cf2567a0304eaf7", + "cbcbd448f3d68bdd8a867af199fff10154e22e29ac1a132be74726a098960b3e", + "8acbfe6efd41ce55fc7df4a832d1465e7146ae0afaacb583323abefef899aee5", + "d94f4fefb433639382c45f5e0887f05cd489ab503d62e27a6353c44fafc0fc39", + "2cc1d338918f92e4e66097610352f27f39baecfc8d3264f125aad50bf8a5a54b", + "f2548474d07f0853f94b31304376a05b91b89d1a7427be496d8657e5f7ae6144", + "9f360913aa39e73cf8708c2c84d842ad8dd54c364eeec2e85b0caf222109a0a3", + "b86dcbba15d2b12a4ef4150df01c4b10367f6c0a752c135d97d5898d63aaea15", + "64112ba7c9f5c60a3f2a7a4d7da9d5f7c331a6253bfa97d5ec2e934a834c5ae6", + "75ccb237bce7d53cbeaf01c1dcd6c1786b190a3ac3f937cf5b90d78b0b65c626", + "a46c46953bd1a45f12f5a4b3b260bf8ec404f40e4844d745fea0b3b5c2b1d6a4", + "857459fed6ccdd1638d9a87e07307d5b1cd273450ef757920b4da5994f554e80", + "a8236175af8f4ae7600cca78b357520b70e79759d0d1c562e22647b48eac6844", + "705274597be0eb4623d2c14721d6e129c1cf0165d21cf19aaedcd906a84bc1db", + "f943d44aee39557bd3a47eaf88ee3271cce3b8a7827133f7318b0f436b5b7330", + "dec38948344b517fcf986998ab4dd16740a8fea9cc6aa2469f81e37a8bbec59e", + "79a3156678a119d62309c794308cc76e17d2086a603a0fe761ef883de6e900d1", + "dbbc138e648bebe237b6af51c6979493504daca3afb51f3c9beff5b4ca6921fa", + "2138102618b83bcde958c27a85cddb3f51519b0be2b6bc6bfc16d06695c3e631", + "7488070475674d95de272faccc086bf0c8312e370bf142dd7efca3586b315de0", + "23b7726e507c69053dbc4913e8abc888ebfaf33e42b099d5dad0aed152e9242b", + "88d6de6ef8c3cf7f88c48743fef7366ed6ea4be5763306f7a300e8ac6f0fffb3", + "68ec8fa8cc7e42507cf57e5e9384bbb980e4e12d846482975401aa526b6c0541", + "94722287f26a8bb7d9c22d8b185b9b22f913feabeec79026d12d3603c18fb8a2", + "a4af4639c724c6835e7b19818ce3ca5d1e237225b90ba5278f174b1a83eb2bf8", + "bb176b739a47018be7cb223b31f765d1080a26bca93b93179d80a052059deed0", + "5f60798cda5b098c7be33e0beb7e57ea4c935f3980fb41233a3a6e145062b886", + "b873337bc7fdb48807aee9077d7129e0174e6f72c8a73a175dd2b8d12100d20d", + "585f172db35f624f0eae39e6bfac3b52b8a00b8600c86b4a8e7c4a3913b25870", + "9ab31de02edf3a3d0cba4a5971be59de08249f3b371159f6e3d0b996c0b22f2f", + "a5045e87f79093649861a74f2a99a95ccd7291c09b673067663bdd7eb85f6de6", + "29e80d023f7b434fb9b48f4e4b37b0d9ecc7fa79e9f1974d3fbb6d4b556c1420", + "f602952432597ea451aba6982b52845ca1f7343689cfd3c7cb214f06a6e0ede7", + "724cd02c97e268bfa70f11b81a41b7544282d423e62c4e52fb3e78bd049cbe27", + "30d5cc27ffe1e8ba7ff5ef80b5592f79feb9fbb218808b8212575ca02321c20a", + "4132c77862d30beef9878f7da627196ab9fbbccd5a62c0b5028b5d44412af734", + "97999ac59dd09d422de8749cf3b09e26c6d0bde44d767f487e24c5e6685bbbbd", + "531d9c8ef2b6d6ba57188714e07c3211d32e3982bc525751608512bf5f73ccf7", + "95e9cae83e534b960b0f4f33c95999bc25f988a5e3e71d627f771e921cb87f82", + "fd8c0298162496e4457c20b6fd86ad9955ef9aed09efd5a78526d8478709b634", + "90c9513a3d93cf428cd47d6f1277a8003480bbd02980eb626a87bbc64874e78d", + "e832891c1b1d31476e8487bbbc05ea4128314be0c0341cae5680e91d35b927c2", + "9c64ffd7efd1a52a6b59fd136471bcf6d8c805bf9eb433eadfe54bf5fed6dee1", + "b8b261662c7cd1c8163dec5e1da0cd2daf6779205cbe101b6fc67e469e0b23dc", + "949ddaad4d9107285ea7ce3937dc6efdafc56eb8211b84ade51905ef036b2643", + "7931160221589712454e78fb7ed99023bea0c6a441eecdabe5680ea3d18d865f", + "9fb924c352a96d30412803da56cfc27d8ff0eed65a6d6932c48511e546b2e757", + "28e28e96368a24a0e92314e7c25fbc5e2d4e8719f6ec1dc40745cc1f32bde32c", + "5cbdf801dba99dac3befd665ae69071f7227923d55b563688c0514ded1146696", + "c2637dc2e8807ed4e44699b83fac80a01a8859a6f1a156aaba12d81e92ab1bb7", + "920546c4a0db7834fe93d6a70946befe4d7990e5ef3cf41140884abc02f67d61", + "5159c3cb456af6c00fc0d26c06c7eccf8225a2672fac2980d0c49d2811ebbcbd", + "e5f93cfa2771bb11c2052d7b47311cf56e525d6c0e86e342a9120e8c0293524a", + "c2a7afc13c029497908b0b08de9363ba7757c8786e3a01f5ece6e4a5c1e777a3", + "db26637d4ff44e7cb2d6bff532c383331779c5b8de6e0f96a4d6db566a861f87", + "24bc0323fa7cd6487f0c5642a607fc8807b967da7ce7493889576441f2996388", + "4635aca17212a13115aa8dcec1ca0e3eefebbaf27d8bcb28fd73a97af5737e15", + "2115d28ba393efc4bede432f859223fcdfbc2ad29c95747c2388714eba21a5f2", + "ce71ee5cc6a0c74e615b3c125af77496be06d0d2f56593475ff2363e2c01599e", + "fc9358618d414c98b43a02ac24e6a39fef6b5120f5fbbf9d6453ec7617c02431", + "743dba25e03905fc04fc55c9aca22a91005914e5340adb5af90569d1f90ced6b", + "93cc617069177e19098258c7bc8448554862f90d65b125d26dfbc0431a62c088", + "785ea85c5fa43106b19fbdafb581abb19379cf083918fd9241a808505a7dd7be", + "4c1f2d4dfb7379363ec31e6e280d63910ae4a9cac0b31e44ebb48ae98702b684", + "1af0e78f77b16fee68235997eddf4bc489d896f8df5ef289a15287790ace0c70", + "ee83f9396ce2e5f23ce26d2bc5d105695ccd4a2c1f6153185c465c930029fb99", + "4daf7e521a1b864f18766b01c3fad69dd3fb1534e5d94a3b2597488b2e4e4b6d", + "00d1c248987de872bb3b7db8a96d0410ce99558a4922e87783e3d6189af81136", + "b638acb6b8a842d827d6449df558eedae37eaa7dca373fcc8fb76bcc3208051b", + "d7c0bd39264da4f6a72f5a80b624d94bcf3f2b6ee50b3c1bf6014e3c1135310b", + "89c05fce6bd585e5c085df66f74880a0727dfe7d78cecd1cf7081d179d958b6a", + "52fb741e912d4bfa5e9e0472661fc03b44b9f8b04e390082fddd95a47ec17290", + "638c282b3d27f8e6a42c73fafb8e09269d4b518901c915ffdbfa4dc17ff548b4", + "c5f8eff49bd3bb280e842a071b426ff7f0e64a390ff9ca0e1cb3c0fa10e71fbd", + "2a4bf945a60aa37e915dfcd713619fa130fb7e852f9dc7b29f0ee16427984fc1", + "a16b991c693bba4d517a5c9d2578b35565b7933a10352c9b412bb4a81b56274f", + "113f33124b7a1cf9daafb1b4da0896def77262a06dc3eec25a8a9822461975c6", + "ff564e746989da33e0930cf3f24ce70dbbea0e2dfcc80db85e901b487e5d4323", + "c07a27f0bd784bf5ae0bf62d2fcc00773534259d679a40932073e29479a42d95", + "5cc6d132da55987b19d5f2297d4236aed31077ecc8a517168fc0721cfc8b5db8", + "921a7d213e6fc1392b47ba508cb7553b7b3abc9b23575682165f3f11554fe9e2", + "083c87755ba8371ac1d699616583234ffcf88219ad7719b89c4ac75caf2bbfd6", + "e01192c7a7ffc2b998a3e80d0a525f14a2a1cb75df8a1c1c5105e208c73a72ec", + "5cac68dbf05ab40883629e49be7532ba64bfb5f565fcfb1a8a2e6017c7d15461", + "8674ed389743b339aaedbb0dc96a48d7d0b428353fdaf38de7aca6cd3efd1b1f", + "0acf5029406f5f6477dae5a1faa1993adec05927c5579c3d52ae44c56ef23204", + "9c3fe9d90fedea6c6c86791f268c1596d02f228f67abefe1554bbd280e5c017f", + "710b9c723359f36ddb4a76aa118a2a2608e9a7e79f6622c8c2e868c1d3e9bb59", + "410fe4eb9a15c5d281af0d3c7cc2b2607cb50189db5f68a84732791423781e3f", + "6767ab73f2451a0f82bd7934ca0222f82cda4d739ac54293ff0481b9653eb9b0", + "c8a96fc5d6980e0d46357f5b594f1817c0179b271665cafffc82dc073aeb1faf", + "5f09a457401f126fe38de5172b3e9a27ac21621cee99daa1d288b5f54b67ba68", + "dc7d61a69eda082caf2fee376ca3543eb8ea6ec20949c8caa10bc7687a9b7912", + "b42cf3a7a13a8766682b15e6173d01e3156460309657de188af2614cac13ae61", + "40f44c6ce8915fa81bc9d8ea208311ef336dd7fc8a2e22a5bbdd7598b8d85e4f", + "53000b49e34ba095d4543305cf884ce409cc1ad5d301de43aca8bd98cc94f5f1", + "105064c619371efb53b296dc8b409feef55faf78f039f50816e6be0e86484634", + "0f4a14c18dd97be1f3bb4d6168b0674be93bef074fecad7b646bbe36c4cc1237", + "bfff0e95309bf6f3c845815c75d66b74e50f1619575b334a4bacc3081a364758", + "aac974fc70fde69b323a8ca921a5271ffd38c83af03292ceaac5641d5095ac6a", + "a98fdd28f56ec6cf585012573fc41f009c604740ac722f7dbdc33f93ae2dcf66", + "0ac48d901a2daf7ad8c053dad511de371b7ff97153318a7842bf08055742f324", + "65f1bd91e1346c30b0e6816977dec7262c1be4647b6e151c8bbe0b5732c0e3b6", + "df0679cd932b14cc8cf83288e3230effa43551261abcdf10dfe6fea415a1abf8", + "9dcca37deeb040eb33088f90db5a156a33ca8d0779c547453c4a8c317489ff08", + "af5fe5f93338644ed5850aea0b89720acff07f4f2c2d300ee12a7a9f33ef65b8", + "af7793d4c4d80eb6607b82dc133c9fb0310003c6b0b4feb8abdf374acbed4a34", + "e1c97167d36977afcb2433be9b94c2907adacdab0833787e63306f453ff8c787", + "e0a70e4054348ce8c500961138448d31ac1d3ad665c0d765b711924448010bc4", + "0a0e37a6901da52c93efc4229ec62e31fce804c9a6069035189ba6b3aebfe555", + "8c01b6c4e264b1b8cd7e43f7d576f80bd5f06d1544a6ff939cb9e07101207795", + "1d01d3d66dee9af48895f5176d35678028f3cd1399c6c50062b453443dfcb657", + "cb04d1b7e4767f7a1be148b69a124776582ca51c8c5872d71f0ce8877149a58a", + "98baf1067039127ee1757d1c12ca4ec88b92ab08e5b395d4dda1df4145c066f3", + "708c8e93336c3274c634b37fa9292a5f6a81d2348046ca7e7b0477ad17216649", + "010a05d9106de87edd83d77ce1ebb0412a40ba95be6007780e66c2537492b0cf", + "5777b2b2be189d022e43db86fca52cc523c8be9336fa05aebac852f6fee0b9ca", + "743c5a874ed5a31e60f568ff6a565b9e4a33efebefeb73cf618b986943767534", + "1b9225a2d371696a6fcada7924d06493ea5b43fd78b0e59c7577fda5e333253b", + "5346e7b47dd1a8912422c8294e93c6a6904612953f42326be6185220742e08e0", + "924537f7a4ddfb8aac3b8e196abac45bbbc58ddcc809ea56d42349429cda3af7", + "014f6280f8b08af9de983cbf75762c8447d2af99aa7f508d3746672425d63ec2", + "75242d4175c587a7a4e5a6db905ec2c1681234ce07886b1cf8397ab6d39dc32e", + "39b2fb8a89b802d1594db78877f9f664f8f1b754e54aec8669e65d642681ed69", + "41dfb180f1581831bf7172c4828b4adc89b1aae250f8f2c5bb4f7b6465dfd4e5", + "48fe34aa784d9e8e8cdc31abf5d56b83e019b3038b41c2cf8f744115b250002d", + "c68144d2badd77e2a9a47be4f38867a9a83ebc32c01d15de600a5d09d9c30e8b", + "4560d78c5ab87f3988aa0dbb626a66ccb448c71fbb878720b9cd85366ed3eb2e", + "0ac3cf724bbdb73cddf618abccd27e435db8172da6a68d8f7a4780ca33032859", + "8cfe0d423f34f2e38dade822dc9d155bdefbe4efd164bd8fa85f7d6367922a9c", + "86b101a6170af04bf24f5fe1094e75f9bf810d73849bf838bba7ae07fe8c8b79", + "ba82cb4c94a68459755e1c326f2b97fce781ffe75f32434069d9f3b487cda011", + "c2a82e536d58fedcb00700de8068ab1ecd90b822486c83497d405d0fb3572f1c", + "da8ed95843af6fa5c29e3190c5599142153f3e3477a948775c952eb22ad9061b", + "97e45fadb59864e60753358d48bea8ae3eaad63072c243ea401a828005bb3d15", + "f0efeee904819df56ff672673ddad1145b853d4cf44ccc75f3b0d2f33ad19c48", + "2e90448369259dc1d32d6f5a52ea8017472707908582e44989dc6b280b7c738e", + "814442d8645dff746f58498257a4ce8f6b039f8338a9729de1621e5dafdaab9e", + "0f80a34fea890111ca2e7e83048a0e3c41abe7d1013b8584c83a7b1ec017ab43", + "200a83b7cbab3059a3a9e3dcd6086d2415b2d106ae841d797b7f3b2275b0db12", + "c6e55bace53c8ff92728c33dcdbcb05cca39b06ee563c14066179d6981996fcf", + "5f14672fe75f1fcf2779a25b27c36d840ec3a2eaa60e29f428f8236ecfd14b20", + "2b07daf35d6e9af3ed0e2bdd303dd0bb28c309c9a4ed8f3995429ac8470ce447", + "cc00750574890fca06d235541296e196db3813ebcae141804aacff7e9c55de25", + "0ae80fc8a65e1fa162f5ac640e75942269e154f8be43b93f0086f609444d4996", + "f9ff612834ba1c203123f09c61f906967f9e3f2b2229cdbcccbe519c8ce47b59", + "8389475fca6611e6b9efc68adfe23e79a2ee392d89beaa45c6bed32376cd111c", + "af5bddd4b09779f1d77a3d2e14dc4417db6cd6816acdfb34c86aeacbacb2de5f", + "16ab935f1ecc8779cb58e708664672de65896164956c18e5a7b29f31cc353e68", + "8e28334193985be8c6a46d9e4a864898bbe710aae9d218d9c05aca5d538d42d7", + "511b4cf9c6531dc85af3b82dfaeaacd0fcb058f28ce3c7d433bac754afca73fc", + "f257d741c5f61d087fe71c4b8a7bf2bd8ce4b634ddcd006bc00b15912fbb28b2", + "f6b6b27d2546ff616f4f926533bd188c5470cb0f331a04767ac1a44ec832a69a", + "fb1776840f82af51357162814e691636e0b783d83d61822d298f6f2cb8dd6d24", + "fc16ccac417a5118da09d4c6517d2608126a521ce1175f4848276a263f91dddb", + "d41202e764e1dacc09c2ade7fb5cbc950d0c39382404cc0adb855d8abfe2069f", + "a2bc88047a665eed08e1dc20555152adc9f098781b33ec198d90db776eedda7f", + "0d809d461201586f3d4b7d4564f5605ac779620f2bf4a09aca9df96d1d808281", + "4bb8f4bc8227737404642692dba6c99dd18eb02a4f7d96cd53942cd7517e96f2", + "8c1fb056ad370717b4339a6a12433c5a335c312ad4ec469e3ec374f45f94769b", + "9bcbbfd53b7b8e1c365df04f1ed4eb923c53f5ff393e8d116e9ba02cc8c4c719", + "b3bd5feb1ee0b619b73623758738e848ef3b5fe7f29cef7330c305173cbcf39b", + "1626600986b6d3664d0349d2cd0e0f5fac1a23ba1206c3c95652ac9076198072", + "6ef2ba780ad93c1cffd511413756cfc5611f6761eca3960c39a95e220b62601e", + "dab4da35e08396ba2a88b85d75ec120a1aac2df6089b9c3dde7983245b0e2491", + "a87642392ed816d07fd5deb94821e7bd67cc25461115d1a7753ac9072cadf01f", + "5a1e83d40fd26649d541f19b27ba84a335961c51ddaa8b4d093decaca520edf3", + "f8ccbbddc9a9408c69202ce50fb95cf79f0928e6d31b7f2a9bf70e903d2f6b77", + "02d98712e1d3a3d597e386cdfad50a333edb9fc747bd55714fa44fb3fe844e13", + "86d6ba27fbb0909f42e347211dc6eee814ad8ec092344d20d6e1a5db1b4b7748", + "53ac89edf535491b148084bf9575d19f4a9c65c374f0ff8bfc0f1dc6f86a1ff5", + "9e02260632795e94c3e8286a739e506e81b3c0cab101c7bc88dd4493f444ab39", + "428c1f3861710e261d67d001cb769138efe9f156725d765867645a01c13c7aba", + "74bca950c7175d0878328c62f2893be07b3efda786191308c62ef8e65c668bae", + "8a7a5c086499d6a794b17bf5f4c8a51b3a0a36afeb3141ef9adc8060908356b9", + "25373de41e8598f5f14a6ae81a0e6fa0c9a7d7256112d145808c66b29761e4bf", + "46d44fea4fdc1eae6dc173faaace49c37d58d65f5e8b4390dd5b530e9a264d76", + "13aa99c7c372a992214cb01e6501ecdc5e568a095fc5bdc1dec0c1fdd8930795", + "ae7c6858ea74ae1d8b92648edabf149d5c74fdc2c2531b9f65d047e7c4266696", + "38e31bac8f6c3dd5f42e9170628de01fa8997ed519ba0342a2fbb9c3b0d6b34e", + "d8360065f106696beb8945285d02cd4d6d2302a197aeb65b335386f2ca808b64", + "ee836e9cf845ec85f021b7fbcead060dd3682ad0754e1cc16f7a3b8d8a65b540", + "1d3a6a8adcceebfa22788c2dd995eaccdc8ccef1335162ccf6a08cbb3b9d8cef", + "01d905525e82065d74d1ed84322b62b4ef5f54f05a657e2ae3a417e900bcd77d", + "a5df5e426a80b2d84dd396aacf9e1f89e05701f583373cd73c33faea2ea9c9e1", + "0b2203dc29130460928c4b451444d7066e4493421599b2b3cc697d36c2ffcaee", + "3696346cc0f703a95564bf475b7c81ed4a1b278e328c2819e252721672243393", + "d4b7a62ef97c9aafc3a2458de07c8a7e47426d1a729ca29cde15b6f57a9d31a2", + "0d9976170924fae82bba2d562132454263e76da626f7691da3dd0e11526c4143", + "d79440a7d4bcac0c9e51b1f6bf669781efc71af70bb7772b34741e805874620d", + "bfeb1ba2cbb05339b34079bf7bb83c93ff2205312229de826e3d253e49833630", + "adf9da558fc6d715298673f36bd73d296023ec4d65bcff503742030aa75140d1", + "0685459ed33fcfe85dcd66d8305fc9b042fcf31fa3ea471bf053a2d73e3dbce0", + "b724b4e202ca67f41b4324cd4938b19232e44d9aac5325ebccf4daec375bd248", + "8305f28fa8e50c3fff4b019564d175444fc847134209ce694f639af2fe2b314d", + "eedcec92af29105cb1cff46c33e4195068958ba01d82ca5a859201cd9e1a1ae6", + "8e7ce91ae5bdcc8e52692e5a7ce3f7ce018f7004c43d5d256a922b533cae5548", + "5555ed3d8407cfb0567a4b46e492d36959718f098318a2b0da5157af7805c885", + "50ecb479d78ae59ef9378e3a71a712fb62d1b7c6fcd8cc430490183d37dafa63", + "acf108384156b726226c60a7e061685d782af0e4754aaffd5d35bf95fdcf87cf", + "c825305ba1357af6f670e3e5bb23e63d560ab8f3d039aaafe4aba82894de5fad", + "7eb9db923caef19a6256b905805eb603001e720d3923ade2c29e83e0ac267e3d", + "ae259ba3c34dfbf4652a7fdf5c11d2dc784e7fa1008fc4db2ae3b0cdba13896d", + "965498ed8e7e327ab9fde5c6848db94bdc522bfd0a9391046264091cb422705c", + "ed3a964ae6cfb4dc4d555520cafc2243d0124d38241f56b40773f168a14f6f27", + "1f2c6084af5f77d25c7a7162fe0fb82930264d926c3b122c1658454ec7defd98", + "c38b0bb2a1db828157c598a95e11dc032c3a9003f3e82c89d5c98212aa9f02e2", + "f7571c1f63a5d7eedc36007df15c7f06ca6b7c203832511c70bb90e20f497205", + "31463ff188ac402d26ac8c8ba2024cbbe72ded690eefaf3211d28bd9ff154680", + "9663cb279b02e0b6578c73cfdd95a7307a7265291e14c717cca64af6010a0a40", + "f5c21aeb8392cd7d134bd91ec3575134b4068085940e488dd524e8cf44fa308c", + "f7a22498679c4ec6b7c721ee931a5fe4e9bf3c889fd3cc5331e34384d3ef9d3a", + "0ea0252cbc58334a4189e52ca079befc818eb306982e989c6a0d4e5a9989825d", + "63682f4ce5a43f970b0d79af382f49837708499f64315bc37e4511923fee5026", + "ee4b817bf84bd2de11cea509469f81d6a94a869e5bcf214b2b0e4b5b6bf03be8", + "d23b10aa1198517b5afcb936515720da39273af7997d52e1c5512f5769c6a7ba", + "a6ca8def89ae2d9885771dfa3204ec5235cdfd1c7bed8b1d8ec2e682834f4353", + "9fcc8c5ce18fa615c06a5a56262f335924be502de36dc6c935872da30f7183fd", + "072d281ab1c5d1599701d73a46477526b24b226238c2700e6fb459f796076118", + "af29e3387242f625e7d83d48965b5c8303f4447d34f2c6494b019e358db52dfe", + "8df2c62c5ac7aacb73f6af1af8a6e771176f50b4f33c75e442f938487bd99f20", + "65faa4f78505738605d863f4ab6850d856d264de6e725f8c18c98504a4f1e54f", + "b4eafd0fcabbb8db2d29886dfe2d766731cb50e69d719555b97f612dae989a16", + "79aa080cef442cabcdf02cd0e9ed607e03e21ec397184aedc9651a741a3d0fcb", + "e07f75ea89239c24a3974e259f4d5f3f4e403132f4cd48aa650d0f6269bcc56a", + "55c8bd31554702585f4a6f7fa117235bba45050e13a28d2e60c35d0fdc5f4290", + "883d38c771d729f499f35a28e3d401d66f0ea456e7cc85c4d6e95039d33a873a", + "701215bc0a8996bee37bed89cf4ea0b7cf72a15b3270ff93226f1635ab2c5597", + "cf4f49f57c1ef80e28c4ad1b872d386c8d58cf3b681e314875261fcc9b01abb0", + "2780193d74ed6102633d0feb31810ed0f893f0a751719e911474f1e2f18e360d", + "da97bf0aa0372e067c3f1cdec3308c307ddec4f5fa8bd7fc7c1cc8ffbc398e75", + "c3f267905162c46b2a94d4c9fba0d0959f07bf451c568ae02ac0baed89a43a74", + "5a4c649bc4477c8cd77d1cde65ab7a0f14e4eb13c6f96aef286271def7510a0a", + "6f0b0c611f8d05a8825525dc68280c7f61dd3d13e3b440f971331fcf62e49080", + "aee22d68009669e15699b512eed6a57725622fb9c042e7d49056e42429e2c3f0", + "f32284651cc007007ca718fddf7204088a3950a7dac2bdfbd5ae5bdd17289003", + "a032c47f5528a4c6a21656eb0225d55af15783c52d97c0ff71d88ede002b7ae4", + "5aced6089ff7f014f49bcdc53306b0034eea2cf257112def7e801f6d1594dc02", + "aab1b115e4095e23a077d263ee864968a2e8c1233be66eaa9edc279eb1d259cc", + "dbc34d8d9cb595c2138e04e24dcfbc29cf8031d44bddacd301eff9f87032ca45", + "7c73338477b2c06ca01ff728f5b7d2aecf1b82bc29369d31fd41d409b3f2ac03", + "4253f5584af24860a06a984349ed25731a3118667ac520dff89184a93fd920e4", + "1a8545b03f45335fbf07e8cfb70ae23b18e0696f69b7fb34b13aa4dd6a5d4488", + "2bc5624d67ac07014f714cbe074ef7c3a96ad409b789787d417992f41f3038d3", + "b1643f5f314d263daeb0782978ef8345828885530e92319c2b1aa84d807929a4", + "b14f145af7d31a827c6d209a87ca198be9c70303ac948f1bd3db790dfa356c50", + "22feca8d84f6daba45087d23958da3c7cb7acc06be2d651e2f5b9622105ca8f5", + "c0b878dc21fd2c7c3b5c41ce638770f31685d18bee02e9a6470ff328ed16834d", + "fc60ad49905f0489d7922ff06b257669cd9185a2010d064fbf233d224ccd0e7b", + "86b4e7f3798d67d8f511d9c94cdeda169f95c6caa2069d8edaec4728e396f5a4", + "f8d817053759b10355763ceabf186208b7b0ee5f6970e8fc1732f961d8612360", + "508392c9f058bd7322ded5a0335c62edcb14819b97a86d6546b9d328755933ad", + "5aa6d6fabc99d4c3b84c64c20ef54b94a4ee8c512f622403baf2612768b0ac3a", + "2f15c8709f22f8fb4dfc74724a49430a59123bd7155cb30a551ff53aac05527e", + "9ae919c083c453418f638e629aff6e8d51324f82a77d14101a0c73261464bc89", + "f362c473c653e8cb4d5c6b513271935bf50baa17a07135267379dcbd02d5c904", + "4dcfbe1c06b85e9a91a55b67e5058696f3a538f2fa6e64c6c1de2f76a72647c4", + "485e8f6f374aac06f2ea0e89ae87a2cf9d9b17a63b4b2ceeeb7f4c70fad63b45", + "702bbf412500c1aca7f839082726e3dc92724fa33247131ebcbbac392691235e", + "e80b00c9043f5629d83e4b370c4380e9ed899b8cc1526e65671f05f927753832", + "57a93af2d561c02f64a9df29bee6ce1dd2dad36775a868b36c7088ca0f3d5c95", + "c1a1866dc3d2c7c263a719d735292beb31484406b7fbaf0219d1559d14c18c04", + "6018b3ad2a8129da7a7b1299aba2844b2663848f6cc76915b7f3198096ecfe58", + "265105629465a26d189f1844409761c50691e4471e8ef8acf14a7b0cf7f746d0", + "bfd667ee86cdcf39af602a59bfe1d13b670c4dfd42c3fe0a67bebe618db6c833", + "d8e91c8f7262436e610af2f94b7db068a47638fbad24a6c9084ed8555f1a6cc9", + "137bface38cfba3f27c375477c0e24ff11cf9bdb69edec3c2d2463758fab885e", + "d60bcfa3798fb4235e334dde9020072bc22266054608d48a90e380f20556f726", + "6160fdf8b05f2e1340d4fd8e60ad4cc801cb2a058f307451063ad862e039220f", + "1a3b150e2eaea57da8102b849612e9a7ef052a59c7de615a83cf4360e3bbfa89", + "d264ffbc0f98f13b592cd1c93520b29a88474babca306201657c724161a32894", + "96a7d27d02c3a91ec07f50646a043c3b625833ea5a0f2ca16a7c1e0ce6f6edf0", + "ed4cea574eba1b7849dafcb3e21dbc29ea932ece1f3ca1c32a68f3a705302cb0", + "e57b206ec47977a060096a193dd375c8ac86599fa973abafb046ac344b0310f1", + "e23a4083f6d8bb086cda2065450330b5f3d296fdeedc96ae5eec7582f297350a", + "17059dca2c0d868e703eb592de500957983cfae012fd6efebac0fd2d42e19f70", + "037b9b6d1e77828eaeabbfa5eeda963ceb3b9ed7b3d54e3de8c313473b59a71f", + "f7a3a601a934187ef74cc232ed68112c899b2ee1a822a8b75fb2874c7eac3425", + "2bab2740af06736f14e9765a3b4e6f69152de1e9bb1e0635a0e7864649ff0aa7", + "118a9352eef6d600e14d62910de8ed3395f4fd6fa8fd526dd50bf4f367386511", + "cc5649ead3937362a96359c5865260cecf32d0bfad93a16cb69a1b71e6f1eb3d", + "d82cf8ef3a3496a8a37aeff10dd41ec5c56a828e4a4f6a3de44f81afb37e6b3a", + "fe78333688ac9c78e3ce7ac576660cc67076469341905f4cd4c370c150dd5c1e", + "003a2e0918ab6bfe5c8423a32a4818c951f43ce18fc79c15ebe8e08543bff4ee", + "4665f080c54c2f5576164480fe9c4bccc44b70c6051a9e802848f78fdee2faa6", + "e59a786abd3b03ac8a1cdd6dd890961365666d27babbdabacce78edec4ec0257", + "b94e0819310d3327c98a79553abe43005dd2518c5db156bf3dc1b49ea917cc97", + "b62a529eb860781f2a21fe09618a1337a827d17007444dddcd7b17a35de2e424", + "4b292a4cbdfbc12289c88163ffd5dd23105ff72242fe1e8babae1dca88322bce", + "e06359be8e70555471e91865a7d84560cc6665cbf9f7eda94342373e07d08345", + "bc70e148202c46615cf3b0685963944613b90a804af22f20d445ef3ce94d3e67", + "50cacfc758adf7183d611cbc63a083e639671e274bc8652aa29bfb33e581bf69", + "35cb61905ef778d72af7a47163eaaf06f9be9014c01aa16b9c42fad5c3ec2d0f", + "3b6d86b41c35c4812ac207df40ae7c87963e06c2411a3a9c5af150e60176c7f6", + "ff104db6d1b8b069465a8cad9e6e5f3dfe4fecdab88800bd3f50d98a0459c4de", + "7b21aaa9709dc942593406e76c48e7a687cf627016218d6a542e2c0786f09b39", + "e363dcf69ef99fea9c60eb1f5e256203197836068a8143912f1c28d71517623c", + "425893b52199b50599b4263e54aeb69426039202d3dcb7eb187028dae67a4f67", + "529fc708683190cd0021dd519e52b26b7e56b8b4ebc3f91f13c806694be563e9", + "6e00201a15247ff17d049df0443c5e9a2b2cf462ac6ea18108071c6954d4b6f1", + "a4014a7bfb0abb6973d87165b3c46e22b867647e1fd3c1ffa9c37322804659c0", + "298eed1ee961e4f2d7ccfd773f5d0866055c48fef98affdb2453c7e2231fa162", + "6c37998009107423f098a30ac2340f6f515f7df76ae8bf7444b1b9bc97a7f150", + "3012ace9e455fb633b7febed089645713b451a9e4443727b8d82411c03bb2bd8", + "5907b2cf2cc24cf37eeec17e3cb3bbaf7e7bf670bb1c7532ff88b73e8305072b", + "3c40b83608a223a7a34ad51fe74c062cbfbea78420cc1112df4c3163cb3ca845", + "bef88f7e1db501bacc87ca2cbe2fffc29bebf42faf2d9bf52b42f7a34bb6f3b4", + "178901f61285dfc3ba4a7993424894cca715577c4f39d7ef2033c9ba73756500", + "7562d3c5d41cac93f4a01f2798345b9ca5ac681d8fb13f0dadae0a5c23631bba", + "1d474c06023d5030ed8fe748f287475d8190c83870f1e9aebfa1e0c30eaa3a23", + "931739a0bb673d9c22e1b4016cd2260ff2b3695f31feec988f533505a76fe3c9", + "d74f8a1a0b5eba2a4b4b39197d34f37d6cf1c77cdd86fb570ffb4c0846801d89", + "163c413c4c79eeeb3d9814a6f99ba4ccc3ef5da95291a845dd88d8a92d4a0a39", + "1773ec73e7055263dd32c309f7ad21df43b8583fe237d76137833f00cadfd0ab", + "dce66b365b5a377d75c422e504985acccf80e4d0d17f1f09a5fe8a73f9459afa", + "f14a2206a687b8a58225a9f1367e9da908817580b8a7f3f2c7eb1fba2e642aa5", + "0493f0f10a5587ca0b2215ef91afef253ff5d4898583f14572a6dccec267abd6", + "341c94244545d1c6afb6f63619d7dae392534fbdf9ced3ca5bb7b43d54cf77ea", + "7aa369af29780d579fb48aa6e83c35db2453002d1f8546315a17505d49c48f5c", + "2e196861943cb21c3150ca3d5d1790d9ff84b4fecf098d845a694d654dfa53fb", + "cab9c49d99731bb3ecb002df918dcce24dd8b72e0ee19fa9f4040893de05fee8", + "5716b48ef0aca55b14c6b3506e197f95b3351f49991326c16207955e6261d396", + "4c5358b2e73d023f0c4468cf8a14657aaa86e6950f7b2ed60d7247f2c77bff02", + "324d1c066d4e1020ff07739232e293c99cd19e597a63647dabfd69ddd8e29974", + "51a777c3f7f278cb708fe8dc3be4630d2595c247d0ddc9cc3a5b3e656b1e8eb6", + "dc47fb7aa040b440812e4b97e1bceafefda11cf9e2c25deb479950628d40e199", + "634a22cf99626c98df6d272881bd966b03119d8aeb27640fd1081835856ce040", + "1d1a99e62a5bb706a7540a91fa357d792fb956402e903c94b3064eba8834ae47", + "dac56ef273073fac1a8c8e52b22ad09adc64ab41fa45208ec9bb9d7b8328bc48", + "5b19f76b6c7a53a8364b34c1dc01972fa523913a1048a8cb4e07515ec220e483", + "711a9eefa50ee3365359afca2ccc377edadc50ca0dd3057444ee6556d37ec48d", + "8a2962336a755a2564871fbb840cdfe0d98a84dbeba5086f9cdd38778ee9c7dc", + "6ea693b485909438e11e9f705dc49556f4088234706973fd53201626d890ed1b", + "0e11a70b34468f473b59e81a5bcb84f9b5ce897e9ab336b57c62d9ba1c67c2f3", + "bc3f888a324509395434f5da3c79f53a99b5793dce1e53fa3bbc7b70180bc71a", + "ca2eb31012b8167536badc78616c95f40910d20d38997ba489bb62c1b2c2a149", + "dfdbd6f4057b15b43cb14c68069840ae436bf6ce3a105e90e0ab98a82f6ebdaa", + "8e10be3f22a33f22838a855363038d4991cf587a30fc0b19bcc36bc0096019a5", + "ed11a9fda56417af289e559a367d72826c417ebed3c8f94d510ef46a84ba0130", + "0b75d040167cb553a4b649d20147c91d13ef8e1e1fee387fb092f74a2b69e294", + "d1b00e9e6123bb55d42e745c56f30d6aa8c01ed5bbe564328bb6ccc517e22b2e", + "85726c1f8e7c1656f2a02ad9351ce94eb59259af00538c3347668b431c9b0db1", + "979635f995697925a3b974be4a65200fbd2e8605d7589ccce4bff941864eb1f0", + "10f18760da799555d399a9fe09255bc80f8f6af5539c27562c5a09c79f4f4418", + "62e9c28d8e4530dad69311678960f711f809841aa698c6253580457bb9f66431", + "48be7584df38c9d8edacb7d84f023fd8217701bdd9c22061d96ba323ad52850e", + "27c3359ae4c4cab20c046a4ababd94d7921eae6193b15d2f3b52e65a7361de57", + "29c71a8946ead2588abc3db591d4734e7d06803dfe486a95d97200f70c5f5c6c", + "e12ac3d32089ee5fd2603c20751bbf33ba1e681b493a6e3084e55fdb69c5b362", + "f49d8b502cb197d969d3843e0deb70ce1d584f5faf7a99ca6817f67a86b627a1", + "98e566811c34998be83cd6f7590f08c7f4f26c3709a008c18628e1be5dc315d2", + "dc172771f6de22de029ad7ef713e99074df8ab86225317a877093f20dc8229c1", + "2d238ccfc30dbd4a482928584be1bfa0e31f70282bb8a16a339b24e19e3b7335", + "fb1f64e8156ed28eac61cf2c17600dacb422918d36e2823cbc050efac07e7458", + "560170d4e29e1a032b9a26cdfdc001d2d50843386afa09c13993d6944f79e2ed", + "566438fbe5a0e49b9069c2f4327e59810fe699c9f13757a9b447153a38925d67", + "82ec98fa7778ca195dccaf884e097194ce7696a3c21fb7e26dd24bb918b26aba", + "3dde74eafd957dca56f379848711e516264df8f79b1daf72fc60f441ec1803ec", + "920e7c272043ff3092ae9ae0597d223a38770031f7f48105671346e1cff78449", + "5b2dc5a8f848a2fb0339fecfc9b158face6e05eef9f26c6ee9624ac0b83b4062", + "a54cdb069a04028fc015dd95100332470c5c93f8ce61cd2be46859eaa6b6436b", + "075019ee9319bc5b54d3c4a7a61071d7810f258f664075f8b7c1353ebdfc1748", + "55235ea556d72549f40625c3c332a69d0fca552a1661d7e35ff6baa88b65aca9", + "746dbfa3cf9478b599c471081e41d50335d7574ce59bfb1e0aad89a4e2a881f5", + "888a55eb3eb09d5f9fba95a325eaebd999277e2b4d0d3191842e1301003ac7df", + "027c26b08dae5892e107fa636280e2666b5241665a6d975e6065a6efb81d661c", + "649ac4d8649d0f0c84e06602ed9ab88917759d79127142bb7ed039718309db78", + "864140ae245d801b23d709629597b953f5ab2aa94478e71c1d81fd99b457c08a", + "b5ef2be787eade68e6905c22a0f5022cf548835bbafcbfb5e78bb198d41b29f4", + "92cda9221acab7efc1e90bbbc1bfb81c5660dc8d854b56f0a7aa358fa02ad965", + "a4c3e1ff3c20f630176ac39314fb9420f22f85b6f76b79723396f9e57d9a7a72", + "9eefca160a619c66cc516282293380dbcebb745525fcf626573a140c1866ff57", + "15041fd512df7df48fe75013536783045a250860a4c1215ba01b08b5065512da", + "16013a846bccedb5fc81d04d9eee311696aeed61b3576902ec266be4dc0cfa03", + "d1e94aabb78db31aa2f0ea02be3a3b5e181f2c000e7eaa439ac6136a15f5ae8e", + "a990dbd33c185c96fe9ef1b1b91b8f682624b816937e28141aa4f95d19fdcfa6", + "d68e95f75fc072eaf191588c42a17d74d6c98b8208aac1e1f753f1e0fdc45184", + "6d36d4201db3327979a1a6a0f3d3b27571a3bb875be1d210509059a03bdf2517", + "c949861fe2534f85c13094a9787ab579d587eafcfa15815e0f5b5475e4fc2ab9", + "3aecf5a080c19eca322849d203d51853143f062468323e7c8387178978a82f3a", + "10693169c3cac0b87ce5dbf464408a3aeca4d8301cb01bd2fa150fe0d18f3a3a", + "f7d2d874d81279acfba4f4f2be3c27a9c35769b40dcb075e9dc34a308fcdb2bd", + "d502efbd812f6048a0a5fa5cb85f1000d4688bf61731fa88f917cecf850ad867", + "55b6c87ac5937b284849169f9b4ec18e7a1cafa51dc5c0ac2d9391c132382e89", + "98f6aceb9581954ed7712981c8a672c35e93672e9a18056e23486148d60252fc", + "99700549bb9d9a68d9ed6265589cb512a519562810b5bd08599ec381cfbc1fed", + "f193eb09ac80abc2d723a2ae5ebf79308246a288b9633b566bb54448f615815d", + "de838488a3c0a6b41ee501bcdadb8d5fe860578831b70320342a29a0e6d7720e", + "8807314cea7f47cbf882f036041cec8f23d999dba47e6888cdda82d9e7a1248c", + "ed65e702db10101033824e09ef192c51a584e472387b09acb6c3c27b2810757b", + "6922c81f538f63d3020b028ca3f4fe3c8c9bd76c1ec25e4cfbc3df34cd66daac", + "86f1b6455e4d546dff4ee823b05174e390e71e1cbedf47d3dc6254d0eeb69239", + "21ee857a4150375fda66ec64d486655f9a299a8c21c1054282173fdc90571d72", + "2720c6c96417c76622f0a02bf6ecc4429c1c1d545113706518288b070bb459e2", + "8e8104d4a75d2ace1b160c27204ee89065a104e68f9a6465e28e7ba4d87300a6", + "d05a3c36e5175a14378d2577453c0bd138fed2f43ca5309f8430446037a93e86", + "1209cd2c993bef61315873e1bc43592e4a2114faeb6b74708bf3b2a791931e8f", + "77c4dfb4f03dd702ec1632eabb0d7c976be1ff235d33c5bf09aa04895a3123d0", + "9e5489982480d23eb6af4657fb0aacb7f4e28d882b461c999ed584ecd56b7ed1", + "c746a880cd73b9c2eac4a7e1f82eaa5e1010c0fb3c37aa1bb50d614f6602d1fe", + "2be701918bb5a0966d0630f3f512f4c2b0b59d958af39d71a3d22fc04bced99c", + "26862f1e1776da0a504a85af9fd83fc03b453425a0e091bc0a8094f6b43a1752", + "d532f305f454332a2f17a690450a4a752c1d6b9af3b4b460d44b959536b860c1", + "3ab76dbb1ccba6b8d82200be3b9930e566e6ebda9491835d2f64d9a49dfa74df", + "e2ca7bb5e3fb12ce2d8ed8528b2bc7d175d6ebca987e199e8ad76f0acd452a03", + "ddd71ad5f9d787742400b2e4e1d9fc6f56d218a8804138eba19b8b569a466149", + "576215d2b5ce7078a1f03e0740281de502ca887753f34751f115d5b887cd19d0", + "f9e88431cc9d1b356d04f25c1a091b5f3f247e2b28d8ee9a372af2d90d97f0ef", + "ead5d43681b1025fe0ac1c844fbe9fbad30dcdef3d5f4b3f6207094f099082a7", + "2414192a5d44b7679e609d08f52f5cae73fdbe6add468e29d3db3e2996ac4864", + "41cb78c8fc4c2baefe817c6a77c1b4646f1d89a6402fd636a0a6ce017c056a79", + "804c833f7b80d97c6c4a37dd81e01cb2cc1d9dcd6524ab38a2faa34fd34a30ac", + "95a45d7e83aaffc4cafb6196a1a90baa07e5b492fa3803cc38209e95a466e60a", + "36b5266859d6f19b52e1bd4a976dd8c06bd58911616f70174736546dc1477c14", + "52140d5b44db4a1c76ea437b2342d9d65acbaea771cc6c8db4944f0c5e5666dc", + "6bf0fe4bf273d3532befe312a8192dd8f394db9f557b9558d924db7e83a4dcae", + "6b9767cea95c63eb6d87dc235840482e0d6ca57bdd213fa80f4354a605bb407c", + "46b172897e7d4fbe39b1b5c0d7b7a4fb90e40dc55738f4a673e3283d4bc70f03", + "c7698cb50edf5f9a206b30af6c56c31d55db97afaa4cdd65c4fa65b3a52e81dc", + "cbf3a3a5f1cd33ffee4156f755a776f8968f08e077fc717c0e93ccea959bbe06", + "1d337e450bacd809dc4271dbcd134a586d4b4f0172b205c28ab77a2432036424", + "aff968d07433f5f82103034c16adaf63c08e7200a631d4bafe4bfe56956fb6f7", + "523b9db9d20cf1db5a9369d7ce4efe993fd35c1b7b10539a5a0f7a7badcbf938", + "71469751b2f3030714753c77c2af47c76770d505239bf2f516df593a42479dfc", + "59de7670061202fbbcdec00386ad9a1988c77295facbd1abb1153ac6a497222a", + "bb1ebf14543412f6d5f6e233061fec22321fc603ffd74c61d45a02c43e0300f7", + "b510bab4de380f04629080a313dc6ca4c82826e75aeefab1247c2a99a0391d11", + "d67857985fff194e89c7c06fd30fbd7c40548f558eef3adac0c9a1d888b36787", + "09c674532d9262e62503be18df05da52b3d9ec65537868510d8dab25a5bf7187", + "9b9799680cd7a2da2192bf9a269b1f3986404743b932033387458146fbf4d4a7", + "f5e7aa76e8484beeb5bd8a58a85ee2b0f42057e0103e80f3ce42ede6d02edc8a", + "40854310cf146da1879a58fe86900a0819c47dcd45e18360651757a5fad01d05", + "87283cd341b835c2d002bd5ef9e8d9a53323b8b503f5841dacbb758fced6d776", + "d075bfe4aaea6af534cf84180b0b50f2524abbbdd6499f9f1f4dce474e4f801b", + "7447a2f85c91a2194b05b205b1ccebddf4ae4c3ae74672ae4aad536e08b6a2c1", + "0dceb57acf5284d5a77ac270a74af4a21d66ee328e641231c96236f73ad9e5cf", + "43605c233978602d270400b97e18183eeeb9e22d6e90a3f8e8935ede99beab67", + "94c570eb70d6bfea6898d4a8961291527786bac8ffacc98154e592c5720c107e", + "6b0267c1e2ecff928ab867974705bb052c94de48c2318b8acecd6d73e8945f85", + "16d728779971c8af3b599ff82ca51a83aec751e18251975eb1a34a4db4cf6cea", + "7bb7ef2fdc36b3fb790523726e46288f67e832f25b4f06a3043eb48e7f154dd1", + "83fbcada41f4b16139d662256149e4a9c6464fd35f49250ab498e525dceccfb7", + "02798d725af315aac969fb1a892afdc43b10afd27a8ca0e8491c09cfef3c2d72", + "f9d77e2fb2b7815856f25dd678fee7d42f21b83cf6ff71a474b9c64fe1e142c6", + "d68238c51a251e049eee3b553e154a2e2e6272c8f61b4642793ebcfdf6aca2e1", + "829fb6c8048814fd761201c14a0bb5745fa2ec08cabe057a7cb8c9048eebf383", + "6a287a45a9c3886751b958ce70c6dec507fa41e0646c857c88df0e3c226f83fc", + "d01144a35209d3e7e83040223d93b73eb197346c31f990f1213fb13e846b5045", + "38deb613b9946bee4ee48b9057d39d8d7cf6c4cf29453b64417f5c23138e9a29", + "fa22bbc651d9a4665f7541d264bf3ee69bebfb68269678d9aa741861008105a4", + "75ac71d349ab88423b7a2da008df67ea7159d63c631b7acd1288b908e5b2a0f3", + "692cc75ad904826bf1fa598562761190e253065ecca96d9ab6c742e630621d75", + "13deb765e2364f1136ec1443193cf03deb47f34dbada903dd9b956efd4feac72", + "7b764d17907a5dd2705925c0bf367058dbeb9d18c6085bb2c4ae70a120c69d7d", + "6dc20c45a5b33984d2d1c58284635916540b3e7ab715d609285c649ddd3a567e", + "513050bd0e05f5c1e49331fc4c80b211dbb6d5431090f0a038b919747b28b53d", + "4615ecba856010110ab8700fe5a83f923ef1ad86ba8d32f1a17405225f7644ca", + "e0c6db849378d5d22abc7e4cb296d48fb3cee4baaedd0ffe600bba8303713b59", + "54bf90105ffb3e2faf1b02af4ca2682ebfacafe5910a82dc88348757c54d6e67", + "a5aa285fa29fc7c0b12be694cf38b8809354ae00dc31cf275564eb9dae66d7e1", + "09ba37f30dd752513bb622629b3b743e52f44c8edaf501661519295ba1f85bac", + "9dc27d92be9382420b5a9e519a90058d1e7191708e7b2f49aa4d7a6add9e10b0", + "4012a5774a00801496521a04334feedd92304e8b1db5400978e7a647b5dcd31e", + "ef3f9acae3ac915143a98941159f4139161920eb0eee7a7637e354ab0435e608", + "efcbf4fe83d47882fb91d79b00c8e130a8582003d8800fa59d7c8b6e1a1423d6", + "8d367ec10af32ac191b82b9de2b2883471e4d49d340f21c6bc6f171e35ac367c", + "407eac9916db49359fc79aec63d9953e4d9c74d29e58cf1a1ca916102eccadcc", + "ef57afd26b31e30fb299cd2151c62b52d85c392209df2fe3e52cf24d2d072519", + "bd44896b2729670bb6c3053510d670e1680101741fdaa7c7d0b983ad438bc684", + "fa0c76b3edfaaa475fd6cce21afab1fd73109a900e4378430f191a3d027adb35", + "46d4dbf5eade38f4c75477258226106f0d41b789fc0bddb9e6c0ac1174cdeab8", + "db7a67b5e5ab92910b04a44c8c41258e9de797ed4ec1bf68d72de508cc0410a9", + "2cad7f44764276028187378105fa60b37e04d4fbb2eed478510dc31db2e9a04d", + "f37d99309d1479744be676a7072df8e98bb5397a1a688d91e789989e307f85bf", + "34d2c83cc694a088aedc7c088dc617f4b724075cc6f6586da709253eded8831e", + "c294085de71f4b2f22e4d0652cdcd4638d50be497c5608f2f71a319af638d12c", + "b7afab63b16a27b37cfef11aea36a6dccf20e4f466de0bccfaee4226f583e87f", + "c4635963c05e38f560af593f8b83bc22509f3ade36618fd848dc51f52710231d", + "113a10b4b2cc7ceff5882610ad90f969aa79ba6b338f197411b1da97548a9915", + "dcacc27a4e67994e0c8fa96b8fbdf7caf8a3cc378d2fb4c824d5ee382c028cb5", + "8b9a215da1e2075507c1dc9c426bb3822e5f101676b842bd8f72e5b7cd7537a6", + "6859d70896ee113d5bc780ee8f77383ad2288ec27ed36853b8053de5ce9a7919", + "caaecc4318d4f8c675dde37b6e61c616be64e06928ff0794ce422d12269811c6", + "b917d2b07fea8a4dfc5a2c244d6f521007842d83f8444c087cd40c2d7fc4ac07", + "5a8b936beac71377f184caa7a77ad7e5038b6566fca52463485539839b83c170", + "45f8d4b93645041b9f8a924a30e75592f3c3728db85b11c4bfd6eae347d12bc5", + "ebc7a612353aff35fc404ec540f8e4a98ed23e1258afa60dc531068da4e85103", + "5c7fa287189e945de6be1c0c143ce27ac5bc673fa560e225c214360006db5878", + "98dbcb4f2b9d4db8260e9850d1636acba54061a7f73e5647c7e48585e1e554f6", + "44e6392beca324751478ce19dd4504e362abe26959ff3577dbe8a3e5ef304c64", + "50eaba4acaf7dc372b3bffefcfe0a07e0ec37198740c98dc729f429e850ffa89", + "54ea1b7f96f46682707633889ff46ddbf43912e9f3546467bca867239c6c4b55", + "a387e999d0561854bcbeb3c8bff688f8cdcfb4d52b1954665abbfc60b0e4c661", + "26e7e63ed5f3a4c0ac80fc6129c9dcb39840031b5181d3325fc144663b3bfa2b", + "5575c6b970f1207ccd83cbba14d8a9a143f54ef75bc8eeb5bf4a92735cd3400a", + "e02c6b1679392f9fd14cdfe8aa7b64ab21e4cabc6fc9ae0d2e1fee00a0154e53", + "3ee5c51778af741ca403f3fe51b3b2319e7d4fe29b286bfe9dd6861cf996f430", + "2f3609842b394b5829ac0f7185b2e34f221681c269bea496a33a978d585f3790", + "a6d6cf764e5348153d9b21cd4f3c6482b5f4ae4bb82f3022faabb677ea260f5c", + "75397481794d9f13ce76483e2f3a1525f8d982b1113451ec9f45364801f24663", + "9cce3bf631bc62c7e66882e6b68d6a2336c4e7b6117102858e6285f046d3a2c7", + "f705d5e684bbedfb66691a75f706cfc4081ea3419a0f0f9d4ca9e50826cf7c33", + "6b18235eb6d67c9d180292b6a2cfb9b6a8e2cfdbfa8c17fab5b3376bc05a3d97", + "b1d7b2adff7f77dc56d83b627f88ceea0d3905a74c3c78a9a080fa71f73d2ea8", + "d2bf32d59fb9127facd129c9ac4da2596d0ef0237522a62cd0709eab61eb0e3f", + "b3d8a9e55b4a090eb9f732dc8e249f9a3c794374d764940cfa9352432397ef72", + "ed7d16072f415437646c83f4b5bfc367890083887b53f32f2097cf00b04917d9", + "b711060d57d80ba59e3207e87a40968801068868ebea30b385eddba99494d7ad", + "830ff41e06a64b507ae89b8404c0e8f951a3f30144eaed4bee823a26ce05a5db", + "40e4359b69c23e2f730f54aefc6078923486855c31d7c52ab58f5073a863fbc5", + "842d171497458ad339386756ae9762fdea538fe7d0ba1f02d0557d392a8165d4", + "89baee13b4fa494e076cee833c313a19c8b9267ba31846012401e4a29a5fb4ae", + "165b09013c49ad27324abad7a5e0441f9b5179c2ed2a4efe5d0622f0a0886ab9", + "efd61f03354b49778eebf5f19c71b7c18db72644d32e80d2da09cce1acd30ff9", + "38b5c86e188ae95f6457fe8c8e06a7bf527f711d6fd1bcc4b9760e3957f9ea82", + "91eb424ae8ff1b8be735ded9ab0047c981667b837bd6973586b5c733dfa56d6b", + "84af9b79bb696dce18f7bdff9c2b8125a0b6be27f8862c18052c117e48441203", + "efa4206313d35305f2e691db8233b605f2612379f9c9b14c1619c5d253a75648", + "dff5561834ef3c633e63fe4406c4e209036f78c4f5fa2a1e72bf84e49ae673a5", + "e4b7bbd6609f7d88bd98c05ca05810b29198b0ec5757213c825990ceaea8956e", + "c270609100c0f58b2556097d76bcf980dd88edd8bea28534f8e2db7a3da90671", + "95d4b3c12db2eeb2987abedea9d9bf9652d19486c29b8a4ef65ea00f9351c47d", + "62d587fc518b012055394f67755db270ce7637bc323d51f1a82a70cb0db0125b", + "5f64205c7ceb0e9a3f547a84fe53547ba27c425314262e6fa4f00ce1d6adb369", + "1a37c8e61e1bca3f373569a8206920cfccf822342d6fcf855c202c1713533de9", + "19c44cf864974b324884ebce0a30500e9be113aa285b4e17f59c4e45acf5d093", + "178769aeb861b03fcfba3eb5ad160d2fe455c795b295ba20f59e3785fc0a314b", + "995462775e8652c0741a9f62eaa0abaee2880c2075241bc927f201e44d64bcf9", + "36f39d4fcea726233d2efb71645ea08b662d237e877456729deaf6f6d5f53fea", + "095751378df2a75b9c2184e2e8b1e325cc8fdfe9ef27fdce06ba235e6cd8c987", + "67976b515f7b4dfc8b129e6701e959b760f4f0581e82b59ee0eb46fd05d4f84f", + "06e7fbf9d0fe3257448787b84cc1bc7e9c4fa4b4bbeba8e7db5a0b859cbf7e00", + "ade3506079c261ed1566c686491a4f0c0951550bb5e424725fe296da66b084ec", + "d27cd5655776b5b09ac8f76b1fd304db588bc847dddc239a2f9becc2c0281aa6", + "193a3c50bf60679e3c1f1429089b75c1b15f5eacb66c290044eb0decb9930c43", + "6c184fe5a82ccdc47f80bdae9533b81692d93cf9c1d8521455c1aad8b8c47a41", + "e174c9e5fbd074549a1b3b94a251f47cd956c3aac7450e14cc6afafc09d19d3b", + "ce1545bf3dfac4b5ab603c3ba1f457dbf08eac97c489866d5b1218af97b9b235", + "551e42ee8c52a912e5a04e7def1e1bbfbad71873655ba3be0d43f7e00c622239", + "cef817b5c5c32330326af4b9590a437b3fa2dc302216adad1ac291873e3b4814", + "e8043e718980d2a96e50d89b080cd085e6d60b414849b55ed40e1ca3204667b2", + "7a0fd19153ba9330b973681a0096d9588f61d69b1577f2c3ec87c4d5a3471312", + "d2f344ec055974827617582911f68f4e11e6d25e051f3ccfd75bed70ed85bc3b", + "7fc0fd62507d0db2aa0ddcb37450238eb1a097e0ce01356dcab78c929428a581", + "f8fe320d4c1b8313ab7439673d51ab1984bc6d03a88faa3d475301ae31e5258b", + "738d8c986519ff8fb99653bcf0fc4298147abbf046afee720bdb8b9be2b01b99", + "94c20082b837a420288901fa225f1275f176aa1ba2f65efb8fbcf633f993f958", + "a7d63457e2240c5caedf160c76edf6b3038c5d3b33a0e276d329245041e9136d", + "a73c590326ad3d6201624cb4f1ff53f1d172f775cbc49a219581f0d654a19bfb", + "e76ae71a39cd248b03a641e55619e78ce5da673b233bed38bdd0b21ba3857835", + "7b41e4f897a52cd25f26769e775dcf799fa3dc14b50357354382c20f6554909e", + "90b1fc77d1bef048877d15c048bd14129a1bc529b2e6419765efedc45c3a7de2", + "aa26043120789b02dba559cc12deb9ebec178d73047da2660932d6253a4c631f", + "4a65a2c338c2549d163d5b1533ef7839826a2af0f66bc34ec48da7bc4205a860", + "d50316fdc815b9af4c2ced87a511a936863c2e0f3cb4300e77a17c0bf855b783", + "622ef0e3f5252554fffa5c1275d888dac34dbd8e2a1d155f9c06d40b8c4c5e67", + "69e1f6708c8a4108e7e7ef9326f9837a608f85cb6e6f6ffc7cdb99672a189fa1", + "07afecf1411062e2f8cba0131dd26273ab60c0cc32a5d56f1841a6bcac219694", + "2889815e6c5f57cb1cdbdbcdde7452cba0f982157c395e4fe2ef4650cc45ae17", + "d9868e1a30c668850eac8c735019a97e270fc8d5f22c7951f9125053a51c7755", + "3f435ba6c37d587dfe415bc30884cafe1ee7ecae671c0a5326fe9d43926a4adc", + "1a2e75bde08885184494974d5f620bc823f629ab3cf410f1f155145974d74ca1", + "c697d56942daa454b23faed424352a6da7ce0e77b5b35f29604b8effa7963d9b", + "0a773623658b7dcb8cc30388536d591f7bc2a559e92bc962ffb58d88be2e2c74", + "083ae89e1bd35ddc8ec749da1a2c1f40c4897199e190655009e5d9951370045d", + "62f99e76249b4683d03ab95750cbc320eb1ada3fa9abe09315ed5883d6338705", + "0de55a581e8d5e52f854cbbdd8310a69856358b375a7203dca410c03921e91f9", + "c2894d1a3e73c4210d94eabc7ddd4a32e3d1be2fece416acd98524562d96a535", + "2dc19c273bfd9d709d1ec3b0f1ae118f700a5f31d22dea711ac32bf27aed2103", + "0f4128d988c351e27d92969ae26d1630afb5c0e3253864673df98d90d7e203cd", + "fc9d8c9fbbfb4044dcee82dff1a29cfeb67c05100a7f4ce67160307348f4a931", + "11999faeb9ddee56825a372c244a369d1bf24bd12cef5bfbe4345df8bd1dfe7a", + "93c6ae82d4b00fab43b1a7d9b85f53d7131cbba332bd5329e239ca39b1b1f391", + "1715708bebbea9c31e3b72e62fbacee60fb66fe1874c467275bb9f9b8ef1179f", + "48722085694a1f71b8daadd123fb84915db5f6e242925f38fdfce9bff389131c", + "07687f59dd07feec503e68628b2c99638d68829283f78da9ec2e51b366cdc701", + "295f39950721d71de8d5306e396c6fd3dcb900c8e05cb04901f76e7a113190b6", + "311a3e5bf24baac4532ec4afd79752baf2ab096b7ea2779c58525ffbff099a87", + "f54e0192d7486ee7d1c33fefcfb4f7f01bc6278ca5bfdbce9009fae578b0547b", + "a757710028c316123d5f60e9d1cade01538f27cd657e534c3ce986e8f27a0c8a", + "49bb85d2cd7adbd3a1ecc0da5154b82d9eb8d62dc59c5d578cade8d8ae784e51", + "b2b8228a9227a4f100ba52d386da4e42c19ed79f39659cf95c5452a640ec7229", + "1267e7f1a96593744aea3c4ace9f44a9042bf0038163976d5230b5c5292243cb", + "e43f7501bdc7a3c10ee47107655110e22c18be879b1eee8126afa36de09e2699", + "37e5d0404205196f812e0912124c649356565fbe4e965ab8699355bcecdc87a5", + "6ea7fe24a4132bf747a059f9557228b8c48544f310866b44a1583ef51b4b3fb0", + "df3d2941fd236dab88e97c5d105f3608944fa1dbd7a24e8e17a85acb929c86cc", + "c01863170205ef7375af9281eaccb859aca52c74b1872e22f4dba77d9a634a76", + "f19c1150a272e10e97fa30278864200e1c551f7d62bc1a1ea3b8ca3e9b5d1c6f", + "6778ccbb05066a4132035ba6fa69d4a13f8d917e3ca3db3fb2bcf9d22166f1d9", + "f041e6bc9dee181bce6ffd4db09267bf19414f93af6bdd337a8599ace4bd523e", + "c9b5ff399653ddf51d21639f11579fdb43b3a1ad5d9f0f6b2b02f3e2c48e0a52", + "1f2cca9b5b673c25f2bc111e0197e8c68b12d01298d6383275144ec2aaf8e599", + "3e7c24e6aeba3c1615cef801fb30382c4800fb007e7ca9ec6418ed5268e73469", + "d13037ade8b2313d42d0db9de29af8437917a851980e6aaed6fc16dd0a9d8dab", + "9abeb99c0944ae1bf1f55701a6e89c3ed53863c63f10bd9c94ca9ba30a8720f3", + "6f67059d9b353de3d4747c18ac380cfd40903b52a2bccd057ba40238c264c3ac", + "df65186feb578482b20eebe73ae93884135693c1fae9bd7d68eef8238f927fb3", + "75e746529119536675801b3c2fb28adcc2d4892991b02cd1e6f69c0ced281222", + "c1670fc36ece57f51d1a46b3a7db83ef36eb6b800a23573bd8517f44e19d125f", + "3a10382a68b5b17f868a18fcbb255c58194442e80ebc6ed134ebc83cd3175ba7", + "66a928552536597d0085b61b639358736cd90d75d3e78fdad449bea750aa8164", + "079e2884404ed0764ddfa2a0e161576680a47d9282fa32c6840ddf76a5bfccb7", + "9027463575eaf645070d9483ef81595ef4fd2474f6dd1af4e3b4e033ab924ac8", + "b7568043c311fafc540c2e8b12e2b7e2f18537367230decac14ee642dd644f1a", + "6a26eebd4b4b6f7451e895e83f3e83700f17ee6fc6a6dc6d59836b52d44fd3e0", + "714d0ab318eec82f85bd0ccccc79870b84406546bdd97f09fa72dc6b82a4dfd5", + "28adb347be6f11830c8929ea61046df4826f8b7d35831d6c45bfb4810d6ce4a8", + "a82680d98a8950b81f82d3f6b4ee5bde9652ec171be803aa21f648e8febf2ce4", + "94ce801ce91f10b5321f2dca7147ae0b214b72446efb38305272af0f4a9c6a6c", + "80102035207dea76002085c2ea6a1e33fbc6c19c4a114b3a43652dc37f4987ce", + "9983281886aa6f1e0b367d67a07fb1deb55d42ad6cd8c616e972760ffde467e9", + "5c0732ff27481e91306c55e6875c0d5bd948a5365771fa4c32c1a5ea136fab8e", + "d567dbd07df02b7a98a3bcaa445b95495c06b57bafd2da95b4139c3b950b5301", + "72ec30148a9ebcabb97092e11ae2419b1c65860b801957e28038754ac0ea27fe", + "68107a66c9573a0f8d6c9a6427763c158461481852657e7322f1881fc03192ff", + "65ebf09eb0a4bc0b40ab15eb7fc2f97363118319f67d53f25e7a23a7d4ca56e4", + "ee630f1ca0ca8e92008264355ee1653472011b393b2dc30ac97e41a7d2d8d4aa", + "9aabec09252af674df018e0d7de3f5f2b49708e6dacf5a42964b7e9e757c848f", + "4589f2c2a69d4f4227e9949a060edc46aa4626b924708b5cf302e90093bef67e", + "e8aa69fb8fb1a4e8b3b445d896678a4dc51a65991df32b8973b17a938f71d6be", + "b14b3adfca240675701b6d15370862d221b3da320493fdb737e91ea6a4ff505f", + "b2a5a06f9bc5872315c4e140402ada12b570d0c1dc9ee17bac9a04364f6ae832", + "74ccdd9c2d78f7c0ba89430d78cfe37ff8a6c829452d255ff46253e7f10695ba", + "dc4477e5c367b61640d56640d06662eec29ebf104ac92e26cfdf40eaa0ba2df4", + "54aa0c6eb861c975e848a7eebaed02dee0b8a5c6c9a9b80adb347e8f02ea0ae4", + "5ca764b24b25892f8519f73cb2f6d6199727f5931d1b4d9c016a96290526eb48", + "b57a75b01bc4bde86b93747db2c4a0d6e3760d6ffd6f8cd193c4ce52f6580903", + "150369f82fa08c61cfce874e0d8d368678ff12d11e0556abd0dc38c737e30fd2", + "9867d074acad0876ab536922b612c5fd2bc5a394d0601c54f211f9d9482d4d89", + "bf302fd6f38b44f9a1f89b08f74a1962426150f3bcc530be8455693adc977ca0", + "9f59da60412ecac2249f0df135e9a08ae0078e632ce50a5fafadd16a2a093c8c", + "6b5774902f8a172ed770cac07cf16be8c38e942b575b07da5a02a9489052a45e", + "06acdfc4e870a417cc14502f13df69a8dcde224d4de91c3488e9d4566bb8fe5a", + "3a1b8e0cbf865282aaeffa15fb710bd266e253075c2950df2a9150103a1159cc", + "ba0389cb121809329e8894dd67b1b438df6768bb89afb7a7bf1db541125b85c4", + "a5c4c467d45d8ab1227280e492fe6162803eb21bca97bfa0bd8371dcceee639e", + "183e102733e8236290b9c8d73493358cee6e3d14b99ca9a89394337c6736be39", + "ffd7a4d93b0b107deb86453c12cad70e06f37a552846e39e0ac8be0d4757b863", + "d86b160e658bb2d80b5d745e920796c3ba499af46d9ac9614d62f1e05c4b6fbd", + "f96b834c2c0df3acdd5a0dcf5ab910de894a355c092d2621e76bb79dc005d475", + "7941a19b850c0998e5dd56b46a4db2b2007fa8a193a365f7f8ecbdf97a0c3470", + "eaecaa07e1ef3af527d515a732b9c72d6bff2f7b17c6823982f1c1858e4edfe1", + "572c391b29344989fe7e242e05d4de554cc4340f0620ccb612a71964d82b2329", + "fda041326df7f1ed272cdb1e8f43d264963ea4f557255f0981879cbc3ba58e04", + "69f86f391079176d97b001018a8fa860ee922506c49de2452f31c695ab49d801", + "89d729334890a07353d9b545f6deaf4c141406c6686966a78de70fd7a5013e2b", + "d15adaa091093c2bed22c7422c82d575d715b95a72e3d488c14751ee0bba9c43", + "20abf3cd18d041f3deecfb84cd66681ae05cf680e2618483a4c22d859bb16891", + "0caf8cc6d3beeea46bfe956a8d5047292dafb07a69831a56753b6f57d2f04e86", + "4ed108dec52bf04e508b2d077e8fa3df7c035f1c0ccf387aa7146ee5bf149f08", + "95ed7d27b1dd6f7bdfb61752404ccd2060a80db59fff09f06b1618d8b37e182a", + "28e1a34dadc496a9bfc46094def0e89bc2033c02c57982d4baa01b8eedc6f154", + "378312075c3d17f61c8f45241cf9e6819e552563cd29d2740f3e5ca125caf153", + "1cf4fd70d0bb5db708a8b6ccab88af26578af5f28f9b6fb9fbc710c61709b091", + "40d9f7160db801a4bca4de0b14bb2f15e1f633640d9e9b55361a4d626b8b3740", + "c1feb727ed3462287b1bd99f3a19085a32ed5666fc20aba66390efca00f9e5e0", + "42ec957e0596545752aa658a90cfcd7889a7058d42e09138b3f14ae2fbf1473e", + "7e7b3cf78d794ee32768f1440014a727a2e2a1b8f8c1a399faf7f2971e529771", + "a55c74bd0ce850c3df9d9ebb7778c1a710c4255ff2c838bdbdb34383a05cccd1", + "14afbaa5dbce1d3a282710403e8de8355a5a0e22f6c3bb48dbc5cb88b8f4973a", + "fd33663d070fec4cb49398dfb5b7eb9b17db6d113e649d5514d7e064497e37d4", + "2591f9cbc2577b170e624667a32c14535b05320e981c8753d9c2a0e665540233", + "05c3fc86ed9febdccf30b1a2845e62f67d28862bd99f97ed00db52c448d6073c", + "8e63838bff8076d719dc76714a09d0ca6a9f086012470d20bcd8f27d7e5544d4", + "0d82f532a2126449986b33038ec1c82a34376608a8df634e11f61858a4659e39", + "f7bde9209b8fc49ae7c0b80aa3322e6aa4bc783fec6a9f89c56c530a5a520f31", + "c6a5e984f9976e51ee5fbac124dcd643ac1e5df2260ea4b8a88c653b21c62bfb", + "f849cf65e86b5abb862014b0c06d6f7d4616869cf6cd0342e2f91e4ab80f5b8e", + "fdd0d59c0bb4d1a9d3421b2d47c8eb6a47b6c0045f62cda452c8e534b87435bd", + "a4ff3339f47190d0d8011b25acf831f8efeb7acb37e1fb07714bb23f28f05362", + "98ed03ce092b989f674796641d65bbc602675f507e2bd48292617067914e16fc", + "b4dbe1ad39d788db8f5c03afc71d2ccc153ca864ffa938a04f7b801a65ac9269", + "6a11270bdf904d6496d5195b61632c961348aac75156a7571094852c3ba2af3f", + "b26c7376334c3dfe1a5a2395fbd78c07b0792b470ba216dadcb4d7fb9519072a", + "18abc2ee29ad31ca825eec1a132e1eac3b5b8dc2da5efc9d41a243f2daa8a4be", + "c72e8b92f27f36a56168a7dd12f991bc6f0150c02e1e76b699059e4f5e16a92e", + "8cd758670454bba86697215ebbd2b95a7c0663693cd4f2ea58bfefc8c3c38182", + "0cbe8a05ac30188a704489a7a16eab84c18d2e343e87ae51f82e6eaff8a62555", + "78c74c55db569b137f9ba97c7846846481eb4b6fea50780f342a3cbba288048d", + "d04c377fcd7499b8d90d6c59c04db1845754fc58c3bd7a7d503d83d4677ef049", + "9a77f14f4048e23e5bd183764d9a838e2a8177fd81d136a77a2a65f67adda772", + "9949f83ed123da3327f2d5a88d20f08decc6efbc7116e49296aeb1d5c7ed82b1", + "5e1584002d152dd768afefbeb1e17a0ae3c997b3a3ed3125fd553036af23749c", + "3d911d587fa684788c79dea6b1c08136ef2fddc1dc51d5d50f28028b83535f74", + "fc5da62ce7590ff531682b5257bb673ddea6c2e922ebb90c0dcfc60efafbddce", + "d44dba0d8da6a9de8fce7e21ece1f8a45e323faf3ec6e41c925c0a3224c2e7cc", + "d20916a1c407e70691897c3efc3db1898c9125fb27e340361c4f768740fcbb4b", + "ac8c7f3b9434f0449cf0038adc008c2214a6307ce54dc74d38863b8a7b073ba5", + "c2346e845292e0dad0b4c7ec10200258c748076a4b49c988a52a04d69bff9324", + "5ee498a15a342515de7fd7618cc4a79f56bd5ea18f8ed2247b9a0f93efc87099", + "926b348b2574a627aa48b4aa9a1dcd1a4481c67078db202095e6feaca956e184", + "1e0f55e48a8ea801e4be813479b68a1a8acb040e3ceb27c6032f7355536a91b5", + "0f9fb5b8f87ba7d0e171748b6ec9706f0c192ffef8136e04e7dc0ca4954d46a9", + "1e490bac108adbbc146396f8720b03fc28aee4422c16d47c715eff5b05e04a8d", + "48d76ecf30ede5f9e6d77903fee5f3348a3c1500b84b1d40f93caae56b7d9ce5", + "d81cf0273f0422371313bfe6d72983f45db598d6c0e844df4e40db72d06bb71a", + "0c9a1b5211c36cb2cb7500eb313b674e016b44649be46135d2f446ed56ffd15e", + "8bf6de909bff9ce4920aa7ccae2b4531095b380d592188d8b36ecf2c9fa75389", + "5a762289c178cff9144b6fc06a5e4dbe50ad39d7e56f1dd54e5bb50436f8d527", + "42a84a62cfd45c0a1c4cb2482f8bfea4af1a2366ee91b2f4d9738254af0b0014", + "0deb457852ac5bff08f4ed9139740390fb38f2ab7d330b50abadd8c2b064e3d0", + "fd5782e542c0f2975833557fe803b0541fc34aee3c669baec2e6d466cf761568", + "a610d34fd9ff88006d7aab461820f7fd92102de2f443aba6f3607f6a25c00f10", + "f53426912dde42e11ace011bc652a093e58a0548014d3759b0f0eef3bc471e4f", + "70bdb5f3a3f419e8e394986a0141c7a567adebedff9b9fbe61c003664bf2b2e8", + "30a5646a47a75db9c9b66194adf631027cac97a905a7b5c9ac1a14e7af704325", + "a587dcfbb798d192614421a213843d9cab4c1dc0523d1a22f0191dd5e314323e", + "f527f89bca4947215e47fecda4f2f9aec687ae70c3610db20b0695c1bdff5ece", + "6e3ae3ad43034622272846a3847e0010638a31c5b224c7c1dec9adf2a2ac21db", + "57c0fc4ea5a4c36b3b801c4d0fad8822b9b8c7f2c108251f23755b82e334cb69", + "2e3a2162d5cf3d5c73032a2835c95ac88d27f60e283a285d4ac59d263a37caaa", + "915dfc80a1b096a379ea8a33b6875abeae763ff9bb84ac97191b73640de5339d", + "d75e59eddeb7c2351edfe5a2ebe198eaf7155b806dc01ec30d655eb2730edcb8", + "994a65d41a348e017fe7ba2bc5a8606670e0a88f50d8098118e226831f08dced", + "b1d10eb056507d54014f7614f846b5208db3e014dd89056065f4a2acb02d3ec1", + "7a5ed4ae2e8095499e4f4a9cb90f1e1d09818dab4136b384cafa51465b146d85", + "aa4ff00896500387f9e9ed0e9f9ddb71fcf44230966cd5eb09f729e4d114c581", + "4a5bb43d0beb19778ad2374aee08982854cd0933f01b42c971fc09cbd6f5cc50", + "0c919291a9b1aa556e0b4b6622ab0a12536013e97125b96f69c996170d5aca70", + "7d93921ef04aea88ac77a34fb9c3bd8b9b6126b5d4c4dbe93a7eac7505ec555a", + "3289e17485760f813c185a4272b7296e3839727ae4ca06b9d708245bab7c766b", + "2570bc81054db5f758ca3285c10df7df98c24c79eaa57b48db03c314e3e45dbf", + "f2e81e2f19f418839bfde2c3f8aaa0732a2395b814620345fac3cf822f3acd6a", + "46e9d49b7ca2ef3df8032b8c2159c18062470ca3430d7f3bf4bf63d200b75868", + "2bce8473b9adcadd661c4dfc5d06462502dfb5aad518c79669d3b8ddee668c15", + "16f125cd719e253d242d59f661e2fd3a56a7d70a42fc2a99983c7e2e20546bd1", + "16704110ce62cf91cc9aa7f2e7c7d5c08a72dc4035b184a5063ecdbcd0155ed8", + "960bd0df30f0cce47073c251f8093fd890cd80ba2e7de959976688133d8d1a10", + "fa42f801f33cf6e77d9a41f743dd0b39c1bc69c23436091827f0ba4d46e36af0", + "0bfdb22fdfa03c9b2638372a853ce25083db85afe06b9a1c82eece12ad235f20", + "12b1d005684c6ca4d342f47a313dc5a24ce945abeb8e972e47b3f123b5815f95", + "5b7264324b528a412b8dc046098bafbd1290de706f7bdeebd1e0ac2702e7c48e", + "16572143ebbe4e3993f39e8ef27ea2cad1932a1688532cf3811700ff6b467230", + "5b571f2d1ed0c31d26e881fb6ac3e8b16b99d677b520be7e9349263d00f7e8fe", + "22d3df3e7b278f0d74b5f05162b80f4585ebc2891488d78f5e3d39b7fc6a0c5f", + "69f03a6f6b8ce2c2ea848bd84b51344dbcafde555688989bc69f82b3c2a60112", + "8b9053d4f11fc62e3a455a6690e19c975208b9812ca16996b4ec9c88be44c486", + "ed4ff74426b372e92cf784b90ec63a8a07870ac618628a139522e0f1e68c0ee1", + "0faa6e2fffb87a43b77a22db07140511ef8c9932005c3b49eaef7fa6d435d002", + "908ca38aeebf7fb5dfb5b6ad465e6f2f57eb64c6b30fda5670826cb551ff7130", + "7d47093a952405e993079989c7ee9c3cb0885bef6971cb44f095ed70afe47858", + "122f0de14f4e6bb98825d4cc575ddf684ee9ff4c20404230f2a1b2508ef3d688", + "d5784f5195655e5294f78e8394508dc1236509c1019e813066b177f8d4767bda", + "7c58fe04d7f856dd927977a9f921e6c16e3324b4cbfdfe3ca3d89c98165e5278", + "7e9ed3eb407bf3b6d8303d6e7b8f01bc30725b573e3346cdc641c1f17ad416bf", + "ac9400f9bb6c333d13417b055fe1754f575743d4706267eaa1930486ade60f1d", + "b7397b5b69b669d08933b1999070420348186c6766449d394fcb6ec9bedee138", + "268b2132484ee2898a3527e7f8abe89b8cb6bded28f1ff5c647471b74b3083a4", + "4fe5e5951582a9db38eef5049b974fd0e6a37af9b56c6a82cfc5612796e91a46", + "3677301d002478e881b6df7a6a467f40a8e0ed02328afcd82c2f144bcb359027", + "80f375936fc3286b9cc27e1567e60649f3aadfc69d60f00f1bad5a8ecfbfabc5", + "fa460c1952d1fc70b9d0cb80c4e69464b06afa414a8c69ce521e4dd1dc884e61", + "3650d3483b2ff8fac01ffa92bc91d8797654b578da34d87de3ce8f346e878a59", + "4bddc3ff80fc4ee1311111c000f079860fe0bc479a19042ddf72dd993d24a977", + "d04ec96a998be333d1981cfcbcbe749aa4d14a38a6a551fec5e8155f28b6444e", + "379b980ba077ca0f68353e10908d56b93741152147f220356c72c78ffcd3579d", + "8c961cb7b67fe4b5f4055e9078fc23e1e91251c004347eade9bc125902f5d59d", + "ef29e283ea470e135a4cb3f983fd9e5aed669c63f43b38268068598ecaac269e", + "30486160257d6098b8695b3707b919de5d1bee15e7fdba919e9b7313db62d116", + "e018a9294694093d88ed3e7abc68fdd54793994eb824a3b72371395b63c13fa7", + "db3c43818bcba81f0d3925d93f48afd26fdb3cd54a2efe70ff7b1e350fb718ec", + "b9b32ffb7fa4f4c223cd86989c6ccccd98656e1ef5325be36ac4b7d76eb74f57", + "86db77b0bb0d521112fed03baf1b6149269443a30454bd70b31ce2da02be2a0f", + "6c3e9842c1920121341d1b822fae21e2d7091914aa2b1f1dd7d8879f8d65819c", + "04ce27a47ca3edbbbeed13cba4dc97715905c287c3e18766b70a5c07b59672ce", + "051ff4073b23b5409785aaf2aa0a63b280b7f822836a7553eba783dcc449a0c6", + "b70068a6cf7585b4a1bbb82eaa5659fe625c3db54ce7306bff5154c45dc18578", + "ee174b3fc208526a81a151ab098dc2aa53773e5de21e02eb6bf9669fed682515", + "d27ff4039c60f2e427ea38ea5537c356cbf8729ef7b3ff9d2d66b8f61bb8ac73", + "641abad9c4ef9061caf8b33f0c0c73e2aac0a56e54422400ca6fcc8de5566085", + "264caff337e35ed51f4d2854fce9ad083b88c39277cbdacb3b7aeb07a85bb986", + "d075e5fa984565c32cff5ed16e4c07daf4eb18dbe7b5d586752be64058803eba", + "13a507d3e78da7d1cfbda8c7b27766368ecf9ce9d47e4a1a10764cda5f730ba3", + "685a5e1692b7ad80a6d1855f14af1a555ab6ec99993178f1d136ea45b4a2d991", + "0e37f6e72c863aabc51be1e394f7a094615d2ec63e7f604812d53872ce9236c2", + "c8b3e0fb11267dd3ed3cb46271d933664ca775ee0f98834987f51826bc650309", + "4c8c50ad4d40f0546665448e312c64ebc3b21e51e4cd21b32e820f78b45eab81", + "9532a196f95570b2f56f4838a94535459fe662b9d8b2c51bfe0a3dea08f010b5", + "7efff733395a86c48ce6c311cb22054f660d323fd23e8149d0e67f4babee0c94", + "005155fbf77b9f8b5ae52d9c9811fde21359d0672cf8227b0a13f96cb9731bbc", + "6de371c720868313ea3bd0845a16cc99d5c6afa849c4a1f71977b1a30a63a769", + "846fca61fff87efc11815de6e3873d6b70517e0d25365fa5cda748224e96928f", + "a6bd99848bfe951857508773b51a060b34b67e43e3258d08be0eac91a7420c78", + "af7c057553ca5666a6c522b8e66f8f727692f99dd2788159f71356c1743b1d32", + "5fff4a5f004368f322b36931a24e8a1a53e531f85ddd06367a0387e4c26b2294", + "2cbe7aee162cf6bded7f7e2323ec6161f6a3751cd80c887721bb2a2b72511ae4", + "ec77f9f2b9bbf130cc8503aa3dceebdd81411e98e8ab8138b1cb99a4cc9e4a8a", + "92a7d4db9ede592c8c72cb1743e9e74ff126cef5b54b993cbf1f5d3f8ad1ac5d", + "c69c1dc4e51bf4b031124f5e81dcae4e79473bbe48ea4b4dbffe371a08bac2d7", + "8df85b18f1b780739163cb669102d94836ca6c3b5c98860a79f072a338ff22db", + "087cd9fbb4e542d2c136d71c051325419246f17d27894273b6cd6c4364704f99", + "83f59fb1e010604a329d1143f1b7264b87262c3b8e0a59ecd4e6895a64251312", + "4390132284cc792f6527a5fe4264731444fbd547a73d3dfb8f80890204a38117", + "fb5e0085e71dd67e5442762a80da8445782c6336591f8b0d4e3fcbc50d188f62", + "56225bd1a99375a1422242e839bb7c2d5835c8acb7ee90bc28221cce24488c60", + "5c21bf10fdefd202d3e80f23efe0e5414871c1324269420d6e8949295014650e", + "ca9eb5d96bb719bd3b7deab8640c07988244947c2aecf2299b792e0ac6c6c959", + "7ceca8de272ef2d5e16c9d160bc6fabe697cd8c36d1818fb0453b4a600d0d416", + "8f21d6088638fe9c5af3a67d61b7248c9cdc3e5b7fa206afebdb7e1a1fdada92", + "5b878f0d4d30b5dd3038caced5d16f0abff901280176516f53f1d3db6be642b9", + "a0a52c51ff9a90901871498a689185b87f1c8c1d6fe2759761f1f6b5ca8571be", + "ae62dbb6fba64e4a35b50d9add5f7976febe4370f4ff6ae12f0375efdb76825a", + "c81105e98e7544f07de53e7c47fb9343342a7ee6e854c27147bc6dbbdaef09e7", + "a3ea694b20f2ff75650819b01af328dfa663148e5bf8b5eeb0c286383caf7330", + "06accf162c674b6b873bfdcf5499dbcde7c808e33ba7f7d3a34b7dd5d50ec8ff", + "690dda5ff871e9596c4087626ad14373eb82cc49b69033e4206d295dff5f2b11", + "cfb87ce43816798db0e6225c5ac7ce610abe42770866a1ad8d956e24451e15a9", + "132f73e559e319e63dd1722abbb760e688cc7fea855fec8ef4c695e45bca571f", + "f260b986fc2b09a54ef994f777639c6b9371b9869570329c43360e7e76eea6cd", + "0f9ac0c1b7c9540415ab3420d4b386b1156cd30b731bd588d1c5831e79872a1a", + "499f57d32e746146ae362d79bb494da22f5004104e43a9a4c33771931c87effd", + "49856b00759f4f25c782e1c17f6e9569b36e012e0f429dbc2b9504dcb5ae8c96", + "16c12c327a6c9a42cdf6ff95f7e13361931245ecf210c77d648cca2a178c0c88", + "83f61fbcc83656dd647945b6379e866dd05ae5df8437d144451b68477d6e782d", + "3978ffaa2a740b2d1fb4bd7704fc0d697a59ba6475449b8ea57895cfadc81f6f", + "e5278e9a6add74b454b99574850f873e6cf09273cf80717c6e795a0ae630fb68", + "4c2b66b7963b7aba0a97ac6a51664aa7e062566128a7e072424f5c744ad73072", + "22df597028f7e736af2db3184a80d3b21572e6ae79cb0f03687ea9237e70c560", + "2e0508c8d89d91207bc285c67ba82bfb5d6c8998a34d0d7343453b71094af4f8", + "d92294c9e76db7174c7106a00a48c10b756bc8f747110f42346f112dd1a438cf", + "35ecad7f40408f26bc1d7cf205fb041862f80e86d7b06587ccd165b85142bfa1", + "819b9ddb51b809b247a5210e63909a013b42aef62ba4a7731de6b00f0ba72a3f", + "f5119488799fc83c4564a4def23f786e0c1179e8c6ed003b92f7b71f53b2e16b", + "d1390d7e8c9d98710da81be022ba420b12382ab3f810dba61eabd2b57659d0fe", + "4b10855410ebb94c74b8b2b7d53f48d67000de17cb6350ab2cfbe9de561ea177", + "67244265d8fcb9deceddb1742027658c7ff8d56ec2909b2f440f06ba33343647", + "348b234baab7b670bf3f42f3c3930a2a4a46aa4f949ae928c1ea019f8c543de5", + "4e1a2cddf831d115b4662a5b80e7a26914fdbc7119537c04cb8db9b028c5e667", + "68d721fbba35d9aa199092a95fa4dc652359d89c4f7030fd6fb1cf93d40b49d5", + "3a062a9bb1a61cdc168ff822a1ab7e211d5ebf7a296f3be3f5be2da1c506f07a", + "c6a9f3b8080af0e2ae1b4242173172b22a145257ab8e43be35bac283779b8b0d", + "2fbf94216cc041f1faed85a3c009a1f1a4ad58f653af00854a6a35103b904e18", + "476f7545e65542971085188074006976d1c6c90bdf87e16b351ba56c82244d49", + "5521351a5334ec54467821c6eddb1b646a9554bbae06c087c68632c96ffdb4ad", + "2d228dd17b1eca9d4871731fc2334eb1081daef4c7cc465d71f8922ffa2b49d2", + "e1e1ceb40023ae5c24f34c45ad194b69f8e5cd64b4e1aa7f88ef687ff9998012", + "3b79bbb70c330f6ee64c91f67c84d3fdd1c4458305ba330a0c9929919fc4018b", + "6e3db17ea19cc3616b27fe171ac4cfc7b64f1fc937836ec804f77562f0016468", + "11d63a85ae4c4b04e9ec4baa35f669031722e50aa2972d4bfa080f7b5224905e", + "ead781c51f8640969f5f5f308148cfc99de6b02725eff8d63faa050c21f76214", + "ec1eac06838526e74f9b7dd38b65687f1d5f5bd51101ab0994082956aad414af", + "5fe29325261d4f8e5885fc0bb0a4b09c9dd55e1de3f362729f1751ff4ef52d4b", + "32069d7e009e836e60937cdfe691ba334f0b2cec459321dc2ca9b0c8f57621f3", + "64ce0da347e1005c3b750cfa6e3a3aabfe7f3f12c6910d3c8aa3b12efa139f0c", + "864792605bbc6108526c5b128f5e94f6fd686973f6fd49e86f2276d2c78bff4a", + "c18be053318130705c83ecf91e9e5208147f56b7476acf43ee606db4b5614a89", + "2aa805fdbae44c58c9c307b2720e24fead5757afa01b4742d2f6b32761a7288c", + "992f37208169fdf243c6be82cbb66f9eca68a2102c42b257c165ffac22568bca", + "61dcf2ff6929367d8a0f3517f13fda16c377323f3d13916381b3490d19bb2629", + "ed189e1a6e8bc367a6dbbb04b4e57ed75a5df45c6026a5db980770f49c60716f", + "4dc277c13d4aac395da4f91f90f3978c0f41aec8d3abdb4648a573d4a97fab52", + "66a22ac434ba9e22dd335d1d742610e6982c404255230ad3d7c1f78c945cf7bf", + "e3fb95578d312906962dfc493b067dd262e1101e3c484edf7655dade9e614e75", + "0eecf0841dcadbb9261a44e4d2d38e58b5fb999c8a4dd4961ad9bd7c190cebc2", + "2549be3fe7f45dcb832e3d059c971768bf139c7130e876194eeed8145098a515", + "cae53eac196f6104057068410e21d71c237a81c4e691a03e57dcad633682ea4f", + "e192f1ac3229074b472ccfab10fd32e2f6b8b203b331e20c10b12039b1f7b48b", + "5c30439fbb5522e4d5f0cc35c0d11bfe852191056793d2262cab6216c421b508", + "7143a1bf251226ba31e70461451db7b17e8733165223b9526a17e9226c970169", + "95fbeb4fb736d5f45026f3cb50c956c2dcdc389fd629ad70c0be1c0763a0e701", + "922a252393711b55082c3e58e663ed0d62823b22a25e79ff789730ef21436711", + "3aa50926602747125478df397111399ef212640a0139886f24fda0df582b242f", + "7220367116337c66cbe4a46b3cca6c471d4246a6034d95cb6d49270658394754", + "7ad7ea7e8e361e1bd4ced9971c397fc37855262c2ff0b30e7501d76044275458", + "00008aac5847441f3ad51601a3d002d33fc5ba9dd8f14a5f0d1b4bd5b1428ef1", + "e223d32d91527875644bd9bc36b2a4bfa1eab7b3e5f06fb8a3e89e2a65305a26", + "b7c045d2fe7026cb5929a246e161baac2e6b5ed2db7f83104e5eb7994c25b138", + "768ca8be7b646d982716ad779fe875128d4d176442cf9b96791a5c5176586a74", + "a0d35b27020ea9126d02cd3773e2f2fe98b589cf789537beb1e149db3a5ed029", + "d6e81acd09819f8b9716b62adf95df050c0cb3ca7b8eb19ce9cbce3041cdbc8e", + "0a71e93f020b6db5129ef4ee55e5b1d4172af63dffe71c2702ec5fb152713604", + "51c9d41cb4946c66c2340f8f3e9a4344c013afac94922031afd19104a17365f2", + "ccd6e87288f1566f57ed30b20424ddd74ff802d34a9e7dd32a4754b80b014edf", + "06e176c49e29f300b40c3fe4f4b889784e93144107008b9a369632cfa14f98e4", + "28bac0362729e09fe984efe000a785b8ced9ce4225f4fa2c9b89aadbebaebdd6", + "c0c3cdeb27c44ee43a74d8eba47a389f00d340fc5cfc03cb9b5da1a06d45a26c", + "020d52889c0e12d5455db80d5ef5ab913ba04b25456a3ca5c0ef6555cfac2f75", + "9b83d36cb852a877f51e10f1e2d32f75a151aa29742edf3e06b1e5e712ce4bc1", + "c3e33b99ff98bfba33c514125fb98f852a9491b7bec40d97659a03feed46b536", + "9e88055d627628ca0b76f1466713fd0aa8cdf8dfb0dd5a9da14eda7198dc485c", + "c2df35abf1339fcfaa885bde6512d753124287d21fae5935a6c76f606ec4e8f6", + "7e5c2b79f78b75880b8821d7aaea6fe0cea8e5507523afed337befa547b71d1b", + "458bd50001e23513a2c98afd4d7faffd91c04c99ca058f2bedb3a57a955d3f28", + "bdf2b08fd136e8143a4adedfaf918f2d2fbaf52aeeb6a060d425b96d0b03934e", + "c171cce3842423d09c5e0aea3f72de7f7745d3852900b6b52b5f8a2f91e7490b", + "34e047d28d8f0d2255eae9d398b669a02fafd7413ea828b866800b4bf4d0f2e2", + "45c51f41e4912fd89ebcf7d0fb6641290ae20ab277406e2f0f159432016a75b5", + "860d4abf3cdd4bb407be69c3b827cd6b379c79f54107a4addbed6a6646c517d8", + "fbe38212b01a5da416bbeb970d288dac26f98e38958633514210f6e839533ce2", + "a35a885388f55491c3deeb7bb787ea6fd20d99b2c5387f4bc08065122f4a6332", + "9fe7860f4672961a9a8fe4b71d328786c427e98862ee4484cd6a826c4dc10e00", + "e7e389ba4651ac6722405adab17ad49ad159cf941f92cd1caf87b84e0cca1861", + "c6155a98faad4455114c74152ceb984cc9bc6bb4c294c11fa98a226229769866", + "796581d0b579fb3d75256f2011aa18d81473f6e978ce0985e6582f001240659d", + "46feff3a31be090bddd6ad472b33cdc2084f76356f5da6edec3c2d44643d2d3a", + "34cc815d51f71b4a4592ee517b8f2bdc08b748bedbd78960b091db5885107d05", + "996d1e107cb2e92c7a7609d62a4ea42ead476a6bf60a303709a62176957b1e86", + "b262adcbbaa1a371c9ce2af56f8b2ca4cad788644b3f06743201791f51cbf010", + "3272de1270c86eaa3094c865a4916826912f7ba28720dc50c166d13d4b2cacce", + "8a2301769ad783e66ada88a05d417fa238142700c31844a411578507e0dcdf7e", + "7ce1df87f20f9f79295356ba4e443f052f26e0d985f12c52b76d663597c3f5b2", + "2f3e803063d7601c339daed44c3ffab0c649cc888daa8d84f7810af3dbca28af", + "44a1ea692b2d6a54e67b49153cdf0c49d54d5b4d2d240cc3889134cbdd541922", + "0aae7aee0c162234237026815d1605aee37991294d6b6d7e7d62b33b604e904b", + "58c8f8ce48a15adf3e9a8c924988143ddfbd3ca7780eb7ec7979df6641d196fb", + "cfb0beb9fab8906677d8f179ea6890b68a3498000dc6f58e1d544b9867881b81", + "645867e43809c4001c3817b09e41860f9b0af85878545e130ddf02e946135ac3", + "b46719f206f25e1ae14da2a2282bed97c6e2cc507fffeee23d1b1b6447206225", + "95fc4e164bc2efe00b6ded9edd81501c65cbc63f46dd01200a6bb5a086f7fae7", + "d1a12dc86d34469bebaa1a11f2a71bb4938cba5984dff813b59f8f329f23223c", + "525e8a5829dcebec5a34a683e3e6b96021f7ba9ae40c3825ec2d9c2360ef6350", + "7500b060fde191e0933d98b9b543d3b83d9075199a3d7239fa6a071b72113a13", + "a8ea1208a246d056796c9b7cf46e243d02d8a1c40f9db8ffbc7127db567c936e", + "7c1fb52b8ae8fade5b461964c1ce3faba9896e66bb23f098e96aa53920a140a0", + "143e0a51f6aabe7271ec40d31b7bd3d2b6f0971d2679cac895b5e2dffcccdca9", + "38086aacf4fb54caae52685180cf465bfc2b5fea2887792a206c856350357492", + "d354421ce0a275cb69bcc56b3c77c3d207e99dd3d8e8882bb09c45f4910b1d9d", + "ef051c773379b087eac1ccb04c5c6a0d4ae9653b9516d62a60feb74e30ff8859", + "deacdf0e8a1aa3b1a8b3e67a23c8d5d75f150a2f4f42e56c53e64d3be600c58b", + "68175008e4ee9f0e3dae686fe236726083c290afdf57b80f0b961ea7b2d0f013", + "124cd4541b727ce68a76edad4fec5783d19b689d9b2025955da17dfdec250b3c", + "c5a3c3b8ab9938852024f1236a6debe1943d0f0c35ce5114107c1a3e5ff73299", + "8eb90ba450efdc4e379f0ed0ab758d1ff18bd13ff5ee5006646d4147e276a164", + "1fd5b8815671be8a414e3d986ec9d2830489a7c0197dc59226898e3853c76529", + "fd2dcb1c7dff3924e2d6878c6b6c2a6af9ec3b2949b245c42c6303b47b6528ec", + "6f407b4b1246a4e25048f15b37150361d8ab4c9ce673f501b5957329a12d70e7", + "4695fa629ed155a76faadb6b7611fe2906ed89be1d4ea5258a31937dfcb02a61", + "66454077549039012d68a7626accd48b1777be881d5ac41702430ff890e662f0", + "40945c1bf5fbaefefee7af94fabde8f74b262f718645379164e380526bc19021", + "e761a8637256bc8a761bb0cca49a18525b80bf848f71ceabf3fe092191a6d293", + "9b4f571aa0c0acc90815f8753d3ef9efceaeaa6cb5493370b0f13152bdaafdeb", + "757c5bd17373b5d96eb6c3531e50da10ff3451f6f891b8e4a0a5800a7a4dc8e4", + "56bce5eef68831f5a3b5b8b8e55e029e6150edc45afa84cdfec32d18a925a2a6", + "aeab635183ed3253d95cc916d7fba4f1aaa0f9404b6af2992798848baa8efdd3", + "5ae13343d1b8353fc95f8f34b89c961b1a436dfde2238be02d03f50c8d585e90", + "301ceb586263d6c76c985234662fea88091c3d63d139926b78ff68eaef460e9c", + "f368aa59dfe91a0565e24a9444af1d855ba87c705ae3964e2bf71627563ea893", + "b687d83cd4b81ba90ff753b739e92c6085f00b8265647f3893421047fd576de0", + "4ed7b0cd9c80bf3d14a9901948855319ec3d000c80d0aff148d30d9bb93461e6", + "dded4f53370094e8f905b3a98e247d2a96034f846d3ff80a40c6c0d15a9bd8af", + "603db905f79f0924f410db9bc31634c8b6230f4bf6f6db33a5637072fd830d77", + "7c8e95abc74012062afbcaad7449ddf1462b96b4cc1fbbba11c95f143ad88657", + "77af81823aeb874842a50d2bb9b7fc4fc6c0dcc0b7d9135fa1b3b98d69c7796e", + "5793ecaae5f319f901fff4113a68ee160a599a4202b87ced779c1c6c0bac9bd1", + "d50258330acef88818b02a6b06c4c3bbc1cf643183ce65cfa109cb8b54d9ed0d", + "998324b3f6086c354f9769a235755f901d3e94995eb8bf86e3df0a3c4b5afc65", + "2ca1bd1db16ab426bacc9b2e71032396d6666046a6c58b7ba156fcd5bf246b55", + "ec2db0d1932730f0e6b01908ffa14252cae3dcaa38dfa1c62fd30e6f3bd88b4e", + "b6f89b50bf22aa5694c93e48bdb72bf4c3dacd5b07507e639e7d8403023e0a77", + "abb7803705b2c6af3534641991448d523ddaf7f3c18c1eac3ce4155cc3434c10", + "ffaddd1c54b5cba468b45b4999fe9ae47e5510a27e951b1d49f0c072608084a2", + "83542ba48ad0ae25b2098c3a451316e7d08b64f050968ae35820301df378e740", + "982e00cdecab2e744c46e2a38cd8e23847e75f888b3b147f1d38968dbb0bc200", + "4e12f21df131a8b2ed476f6bbc0c663ec1ee86a2cd8ae96248fc5e27d48cd4f1", + "2b8da0e7580f4361dcf5475e7c36aa758bf464164c5d41d210e0bf28ab158d05", + "107b7059fb343b36b61b717bb5435f5b59e2f040ad25e188748aa18dcd354013", + "ff339c33524aefdb7f061f4ab8c191712d3fb341d80e31b58de66eb29aab44fe", + "9548f8c2324ce88cbd1a77e936067c0d1a6e0255e91f10d3f071316aeb6aa483", + "b48ae0b4989a5253ce35b3ee69ee39e7a3a6bf772bcdf5d580a8d8492327dc74", + "a14fac8abc0cb68ac1508683c9431f623794ab1c43bea8383730a0a9d39600c5", + "2e9b9abfa1a6d0dbde9d107030fa77307a36f2c72e557000fb50f505957f8734", + "18238a79ed4b5c93fe0ba143a2e11bb29e620ff48a8745ee29011e48d92cf7e0", + "face7556540dafaad95a94f0ba1b84716592cad436a7196b8f3a6c1fb5c99f18", + "fa234e342e0be980c11719176757e6635f5c1e9cce7cf0130ac43f9c373ab04b", + "3df727f8accc087cca29311348710089b4308ec3cd7bbc6aaabd0022f277af6a", + "7fc5c607b5fa97476763852c1b3d309066bac4b7164d5f206e3111189695c86b", + "390cf2e69c7fe5d1486c15f487d3efc703fd47f77aa74826641ac844d39f8839", + "e494f44c4bba9bd9c823087046c84ce78bc14e43195f8276e14533b84076e95b", + "5e5218b4889690e270d4c9838e59411ff758a718638b56915a1a60d5e85d719c", + "687e41261fbb0f39e363579ec95d7eb84862b108f23fbcb150dcad3f17f5da8b", + "27d97590d6fe223e1f44f03e5d32da19fd295d055ed484b4ddb89ee18d27d5df", + "f1194459652107b28bd9c01f8239045b130913d9d59c5631645b8f5f598f1484", + "c636a22af63556e85903cccc5b56c22257b8776716417fcf6d02ce197d5f46af", + "19d07232167d8124c6863c9202a06e5c8f4b4f3d9692b139f03852ee7bd37b45", + "e7a30382439b394f95a6a1d37781e1bf45f4c62b5913de0563662c4fee35d2b3", + "4e2ac64aebc40bd41734be7185de94041cd5fc7390fab54fb6a1333878ce8db6", + "c515cb871c327e77ab510a8baa501aff75be43b52caa00dc3d46915fe05912e6", + "cfceaebba5f4b200377e39040c48b4e02d18798684c84fcd6bf13a46f0c9c715", + "05dc32b230a640b72a22191082627bc616a5b850919a4637153753989800d04a", + "7def985154e47a82d0cdc199c9074fc7f0e00db904f2901db9e237b25b1551d3", + "af7add43b711bdb25f88d724733d21119d31d155c0d1ee48f00b4f0340ab9c60", + "d89738d97a30ca4fe59d435b88f00791cd1bee28389008ba38a95ac6d7374014", + "4aa6832a427acb2b19ec65bab97a21730479991315dc8bb79b536562d8e996c0", + "4c224883608b4b320f9067ce64d87f7a4a3798082013e947ee1733009c98b82f", + "fbcd91491b2c070287378f1e3834230698fb7592e598bcd47fe1cbabe3514e93", + "63d3bbfcaa998201981b9d93671536926c1f7f4257cbb3f86848cf96ef7c511e", + "c4be84de9f5feb67dadd2c2663b1d85858c4c84de555fb8f4c0cdbe82a3d34ca", + "0c09412b806b5ef57d738f6a9959a73f9f6d11fbd415af4aae5c583aba01e8f2", + "2b1d749f3409cf71d3c03559ee80b9ff0e70422c76a0065002847437cffc548c", + "3cfad78cdb300da88e2bfebfda29d8ded0b082526e2412485c9ed82ce8a8ab23", + "dd0943706e5627a0f3822e7c1e21eeaf9a2c699524907257c9af4df86d5ab0da", + "f9c8d7c36ba2e0b36bec4e2e6d1b24077e005493a7d8e4f5c844c59bcc62c839", + "37b07d851d32f4f167fd82ee05eb7697d4e8023b6a4d1aeac79aa33c59ca85f4", + "6e3d566a1e5e2ab39d57e2c025c2241ebafc051a1d7f3298163bd4c49b2c6d58", + "090d87d8e30a239dffecfd99837cef465d648effaa270dea201722e96e7edfbc", + "b3e5d5cced0c6354336afd9baf7e11d61e867b7551b431e5e66c1278d0e433e0", + "49083787441f9d2ce0e5ff5a5da111ca09a5937083b65acf64136dd4ee272715", + "fd3786d1a34451ac8414e10bd7b8271300d06bbd2bd2a7dda6e70c5003695139", + "66ff5a7decc8c23744d4b51d2082cc196dbedb0ac614bffb342a07bb2fd92ae4", + "f028b947582982d9ac7061512671d4c1ea3a41fd0e1d00d9aa712a11c88658ef", + "6ebbe26a4bc16a03c9824edc903542b294e639a384bcceb95af537139c775158", + "5fc558ffc03051e80893b2a50c6de173e127a46ee47e61c4205e5c66ed46817d", + "71c711e0241aa4263a33e14d6ddf162e1379137410fb0fa4526a1bdd88dce471", + "a39063641252fa5b56e51e36e4f82130f11906a0f61e9f214d1d45dfbb23d0a1", + "a5fb71fa41e4951b696b11cc34227fcea5936e4abcf3fc2dcaad96ab4de8eb1a", + "b90d158e6bdeb656ee2ce662f34a7ba378731a34b991cfe0a90a402c5bfed3ee", + "0a7bacc7b559435ac80723a4ac443034ef2e5b3b7261b53057007462bba394dd", + "231947f840fef12652b191bba72665e8bdfc7d31fb12bbc881d92bb80d19ded2", + "569cd56f0005fe7e15519386d54ef18ff98980f3cd9c3a7c8b73edbbdf6e4a2b", + "a755631fcf4e0be114d7aa52c2507360d740792f87b2223224f9e25f7a01cfac", + "b08e421f7f70bd52f2ea4576e3f5544e81f1630eaa37504f56b12d359523f13c", + "98938305ce8f78f58a9814629cb5e0959e190a831e7042beb967a39b69e3f0a0", + "6c42eba1811252f469b08de9d74535f2bbf96d3c9a9b3a2354ecaf0781b0b7f9", + "146c0d62af6bbf1955fe4ebdf54c681e560b45097623f1e24c20c471a882e2b1", + "504f13829a54df853cf1a8aa0b999071b00a42d020cf70677a2470464947081a", + "f4d7433a6fee10d1a8b06f991d07a1af3929ea6f989676b6e94f6e994eb6646c", + "e335189d5b1c86fb3aefe6f033fa73d8ccf2010be2ca15a22281b7e709687628", + "c53c468752718cfe823fd4ea449dc704803cd6fd60c3ccc88df0780d8faae0ff", + "fdb55790f7c42b699640124e6811632a620d7729e97ffd1d5e43131a32097367", + "4eefe47549343cfb1138676ba5b1e6ef63090c40a6ccd147128f114252d2b9d0", + "9d48017a280f7dda5ac8bebf6a1d935373d7683af81ff7b4efa1fb3cc7fbacb9", + "4d6cc961592b2b8b30f0115afd661e6578183ef659c89b75c6b9fb7c9ed02389", + "0fae2ffe118771974f840e9bfb372e6ce7808fefcd818f252f4b3d1d56a5a582", + "6cb82b76c494ff091f51a04ee1dd3ca1668f75fbdc6a6f71bf5b154adab03642", + "2e702cc05151e871b67fc14acde6d50555fa31e7d98a46f8bfda5c6677341802", + "6f27e2ccdfca167abe545df92b3e29bcd9842d0b7a1de9d0786abeea56b74e5c", + "ecfa085ef1908f9d68e16ca624e290641a9f6974eafaf133e1c3062f2782eac8", + "6dc065257733b638fe821a1ecd2b2d47960880cfca997e6efe5ff022c23333e1", + "872c1894e851a8082864937fdd3646764a8e750616b049cd32d93675b21fbb34", + "ceca469fd26068e243310a343eddd59f27fbacd130b6f91e0170640d4c01e58f", + "d2addd2b0ead1a534ade95c7e5575077c03811854c563a149b45902e6574457c", + "a07acd81037cc01bb7106c78ab3ce1254c3e7c20d0577c5718d3a33f211c468b", + "042db17228102ce12f6b5cabb2a4f3de5ccfe1e9afbf5b3c9a3b7e006cc69645", + "9d5b65a25bd3c345e57806a017b975c7aad859963ad2e08be8e7c08e291cd150", + "51dfef6b8a356bddaef06051eb737cb4d4e4a3ce1b45617517ac633a74f44f68", + "15bb08281d5ffbc3ad5b8f9d0197b4bf4af438eda398ac518ac468445b293faf", + "33e2765fa0304fc8b4391dcc47c977469868d7dce882f06cf806e74dd9aa6029", + "89900bbaf8045cbb8550dd89f8292ac7f34c713ce2f9d1e96b92697922168064", + "89c004d4ec949b73d9c7982d430415c32271d62c41bc9f30dfc3234ce2c6d82d", + "edacf51a12ee330a821145c7ad4b505004daf28f6b8fc2d2d1100c31b953b4d7", + "11d78feaa16f30c23494b4674f312955313a692dac178707ad2260fb2523104b", + "c45ce3a865c6aecef9fc02805f0edf169c79922a9b23924012ffa37becb4063e", + "95b89d2938ad292c211de83062da4954d5db5229844c97d0bbf4ee8dabb4799d", + "4d6a9a1bb132127fd2cc233f14fea5a320bdf585125ebdba9ac02f37bccbc8f6", + "47cec358de4154969d74c9163430857a2ef7010947f8057c49f6eae8cf088a0b", + "24b7306d41438dedc1217fa30baff91c902a4b97b97ccdc9bedf971c14058c9c", + "bbc12780def1003a7cd1b0b45f61d404672d42b770e52dc8c12e999da2557ad1", + "1fbb25255abf3eaabd1ef03d788cae245d0be3eaca35cd4e57d2360bb2975877", + "0572dce9c182a28ef0632720effc5135dca5d4152813ca78bedaab293e8d74dc", + "55688cff8035cdbce9b46ce76b8311c5b04dcef35e75a4fb0e0fa0b6066a126a", + "eb412fc76b59311d9d952fa5c8d173ceb9e6a268679b2c5de0140507c15ad170", + "56935c62f91d9a18678421f7106e4cdc41c01bad738e483585a0b64970961e1e", + "a5f0369b227511c64ca66e16b4ee081ba3763d13824443b4cf7ebb06afcaf031", + "9f842172c1d297d94aa86ada78f0f0703718deb23cdc7bd6603de21e7be43c24", + "ffefdca1011a8b2aeeac94e9c7611b09bc802d0a1e423a2980c52832b38a5989", + "9fcd341625af9e5f39ea87f244857c605ccdafa4b7f7dab8eddb90505a91ad01", + "90b21a1706107433a3c21c8bac989de4fa6296623787e4f5ce449c33d812c75a", + "48ac9000061b5911f81cde0cc4445d74aeb23100c51584af31ced9cada72fb65", + "33b8fb8dc1ce01e65aa4f9125a48f2eeb174332a576ee64a0c00e5083a8a6379" + ] + }, + { + "hash": "9ef98552e37030376ff099dde26b14ecb6327bdf4635c20f341bd4746c458fdf", + "chunk_hashes": [ + "2dafae99c4ff94dc325bf3b13b5d5b2d3b506adac61125ad2e02448f29d3bffb", + "1ce95b33152401b20948751e3767aaacaf08486362423962573a0e6e9dc0eb62", + "a9ee96560495a1bb49c8fed31538a8c24fa330c1421aae10a8ba99faed7c4a1d", + "fe680ea7c07efd979f166f6b2dedd4ebbb1852359c65ca4a0dd4cc26e2a3468f", + "761bbdeb3cb962fff580d84ac4fd8d0c6b8c1afe0915a00eba1d9e4ed8e23fe1", + "450250a13c3a6a8a3287b57ed64cdd3c276f5585d7f7612c9b00708d9fe253b4", + "40781274c1e2d30ee8b87e9ffaa4631ec0f502aa7d99485a222ac363184c32b8", + "5f9bca6da07c91b82dcdac0ddd8031a44a256e19bcfe6c79a1d56c20fc6d6824", + "adb4c024d3de6af52da8608928e51a0572f64d4c70369b7abbbe40fda7efb3ff", + "742b1f0cedd22b34488a6b43cc8626431257939b1ea31b7d944d6a9217a01efc", + "0963ef97ee954d02774ed9dd515446bbb777bac67131a54001e9351a4922912a", + "22e6e9682149e6fd9882be94d5af7277dc173bcfdce8580febefcce9247ac8b5", + "b8abad99e1fe06673e53066f06e53d6751ac8096083f6bc3550af41d8874310c", + "ad596090af9ef031d36ec897a70eb76820b2120dc238f7b2cb9acaa7c2ade8db", + "89c20b14be9b3125b7ccfc717c906fba949fa4b8863d1d39d400c6e76cd5e5e2", + "3a96590beeb15570e31d0006798523ed1f3a54e7ae8f85309ae547e8b13cc0f8", + "b72b07bb79486cc8738b53e594f22582a469abe61448574d66c012a12a0f254b", + "633d620e4d1c82c4172f7d3d93b25eec728806d8721a13ce0f8a98d31fc438d8", + "4f53a32a9b8b2c02a3ac6e4d66642ec4f963b0917749673e24e3d8406f74ad8f", + "d8ce01d0053dab111bfd1e72801398bd12588e51fdc691445878b3308fdcaddc", + "ccfcb175764086cce418226ce3b96851c302f1ba6c774e814dd17b3c24d4af90", + "34092c99c32318b78f22901556fdeebb0d0712f2f12b9c6169c91361a5465098", + "0c8911f9633fd673fec7590cd8281040956077c52858c1a664e588e4155cafce", + "6624a712f982407d9fb3c2d8ed9078af25e52aa5a3d3a4c329348f920cd11738", + "e2f0c3c4a1d8afa9828e151c513cf6715ad4184a06cb61953360fe60a90c1187", + "84d42b8625ce21999b5c86e9be97ab2b9c5aa178bbc93877bdc2819d1a8a6593", + "1bfaf192d0515cc9a136f11b3bba21d5a45b056f85e6b919ca42835ec2771a14", + "dfbce9f60558c7f1d4c6bc8211e2d760a5ef86edde284ef8d76076131dcd729c", + "608676c2e7e1af008f4ef38cee2b42c93ee6434a2aa61beb809ee123e9f590fa", + "439a1fa35d5561be541fa3367d1d33c07a826f0443c7f68f12b3503c4cbb225a", + "d622526c84e85bd7ae1e4c05cc6ec82730ad59251b7344e6dc8cf792a24e5d86", + "d5b8a56efa8ccdcda51f54ce5cb2c4d355fec7443d5e859573253432e8b15a39", + "38323e57de1b8e6387fab39e714763dc503361335a91a272ee6d2b339a2826f9", + "a65d80bd4d31f2322124adb1858e5825d70996313df11ba2d5f92bef2958d257", + "e790750f18428cc6fb6ca943242157a6ba58fc85cd371debec04c30b84d61fd3", + "b6b80a526f2f1734379533bc251af5e93980244c1ce87c1bac4cc984a4ed526d", + "f4b1c76151cb0043bb3d418951a11282816138a3421b03f2a2987e6faa7c0654", + "e9174eb11ec5199e41a198a9648901e5cbebb197c8c769d6f3dcbd4720dbbe55", + "01dd2547277b0c09de77f2efccf82fb3dd53233424c490c59fedf38f3c8f93db", + "47d0558999a20b50f42c7d563159d8449d38eba6f6ec31fd2e71e8de5f969dc2", + "84da68656eaae554524708092fec063ad1154814694e13047e1af3196b3857bc", + "0ce83a87e52c411595686073f8442368eaeac05ddb85bf529e55a03ad22671dd", + "7929252de95ffe7dfac380e9a46138fad0fbfbf724d3566b0af4cbe108dcef38", + "52e6ac31dd3085162028b54ef4818e3894cfb9d8d96f12c59f1581a1d496a651", + "ac0d5ee25f0f68000c65959fbc77f6364ebac7982b98ae977edcc4dfca8789d4", + "83d5b02512bfbe7cc1826681b9a809ede6e8b351c34919cd78ef819d93bcd829", + "b6b400c462cb2d0297e415629d1bf99e4750095b23fb80a035202040fcbb8899", + "4bdd389199400bf1532a8c7abe9711ade7605e766bd5b263f9a0552bf84dc508", + "9375a53a11c72a6766c1d7babea67a83dec9fc5cfce9c450db288492d12aeed6", + "aeae1089f16c39c5b2deb33150d71fda08c534fcc82abd745e04e6e3ead9b9e2", + "ee31ed91734c4b441f3292ad04f4c595fd1d388e637ad2fed49f3abf9d94d6c4", + "2b80e7cb37364c0f7588260a6fb7385ec7365e9ea801ce2c99a08adb55cd4378", + "af538e9e6dad0af86710a757515bbc06cefa55481f54917dd6eb818db695ab1c", + "1479911923b1c8b0895b68bdc851d005dc1713c8d04573643cbab8e5d049773a", + "5792508be67c6992d0c3e0ccca348f32d1a3f94d717c2f022142ae08a1f603fd", + "69e882e1a54f947285fcb77bdb10b447b97bf0ebbb4898e09d15ca8c0d6f966d", + "1e65b00653ff032dcba1f96f524a68065f2814df15fe5b4615682c7b599d8105", + "35ba6c035b1d7db4eaac7fb9ea89246a42f372f731c65305c5b1707a006c4a2a", + "8c1ac4fe1cc347dc5712ff7e749d913a44c14f90745f0e9a0057f15d825a4860", + "0fc44837a1bde1cd157e824f4f780c0b29a6b3fc884ad8529f737c56bdf67290", + "12146e4b98ca131505682d37b9e47357d1e975adaf45aabd7ed48beee05a4e43", + "dce8b1111abb2eeb1333a46c98eae26e06db668747ed7555ef8b336b9d1e9881", + "0df0509a2f15b17650f8209a5e351ebc4aef127adc8e2a8cbe9be0abac6c165d", + "ffed59137206dc3100f222ffa41428185fbbb80e08dab7b9e2e93c8a7ce054dc", + "95c38499b3f8cd562b1e65cfbc9ea25fe30750d0e1bddcda421e7f25e0e0b224", + "54e0efa96bd1e50cdb0298dcd654ab61e15165fcfb1c84d6fc501288278618db", + "63703f41d394ceba926440f66e139af545a5df3ae4c8b907bd5fb47ee03ae39f", + "64f8fd02387a0442343775b49afdcd04604d90e857e99a3a4714ade2b80a8d2d", + "dea1dd0b45d24ec2e9b9e07f307e9ca15a4f5a7f2b99854614acddcefe00d50f", + "ff308bec5a8959e48231a43173e0951bfa92df34ae1c5c03712ac59bdbd69d69", + "fb69878cb6cfa89c7849d9846834aa19899a0cb7418725f89aec25bc6f1c8ab8", + "887d6d2c5759e74da6867e37cf778c45c6f56cd7db5c5c43647d0b309d4eaa6e", + "3df045598894efd38616f8e92020590bbdac822426678f97270ecd54ab6eae24", + "4899268af5fed95612cf4ce5b174a1e0257497d82db83a53810f86043e4a0d96", + "6d519926621922040dfa2a1910cb7b943394fad5198c43b59a987d54aea4a6cb", + "41e1669da779bcb72629d86c88e2935f57fde04473fdff9f3f6dfee9f70f03ce", + "cf84b92f65f0ae8d46a6facc8e3036801b8a468bae4d1a90ad49d6569a582cac", + "a6d6bd0e3ee2bddd5a9de7d93257c448220ee464bda4a71fd52b98bfc77517b4", + "fb108bd65558d147d1db583d7e249deb6c94dff58d3287adef18c66164e52ed1", + "16d8a5403e3081958a6700a84686f8ae4b0b7f988a4f4b82638f52a0c04ed574", + "e05e0adbfb44d075b6698911defad0447e7ec07411ea1d44bf2114c634687e3a", + "66e84c57244356907e83ededf114f1c2fdc072b4fd121cf3fc3c8d2ad2eca9f0", + "46130211bebd183818e7286004651ed408226a9b45fda331b98abf413eb34867", + "e1f06479607bd2a4035a240762dc6832b481846bb93066faaf620239aa1eca09", + "91d1379a8f825e0bdff7af4de0b93dda61cd78a6b9c99c7bd398dd08d1d57944", + "fd355a46c19b197cf373b79b1ccdb1ec006aa0130656c266340441511011f8e5", + "89f585d282a150603dbd5a9bfe50f262f1df48dda829ce7bb97459e789db8610", + "86339d27d9716f3be47a5e3709d30977af97a06069c25cfc33c038d947064a3d", + "bdb9e9a34e1aa4e2e52a3326494798b4b05348dfd781f2d9fae32a6531b896a5", + "3687b0c0d4e6551717bb94d98e2031aa9a3f9dab6e1eebab0590b7e2e283ef2b", + "f3f83c813717eef880ec11f8857d57ccb31b3fc18395d2ede37b553447689f3d", + "ab1b5fc70085473685f8606632059897d9ea6454014cc755d0a4116727adf7f9", + "57f2bc7ddcbd818d96c49d44ef3933efdd9012040641878bd7a738fec874e2e2", + "22da4c143cdb34ac1b173b4486647922cb8388cab99de639b37a4d270805149d", + "af2d7d559c17db8a44202f8c0b799bdd88e6191462673adc965950c5c25a6dc3", + "e15e0294c8367a6a65d97fba013085707354d0238668a5d9d8c3fe60b8e90873", + "cd95f1a5a63746b5e2e833cbb92eef434588aef5e89bdb79efdcabf6ec36347b", + "f658fea91b089340c66ae0f6ecd8143d0f247c1d263df8aefa4a7abed2b7f595", + "f38bcf51ff1d97e5d9e1d78bf37544b59b0a53eebea180b5a05b9dda80cda75e", + "d316821474895349e058c149eb3ec315c582c8c82a2cff3ea5aab53cc2cf0244", + "8de8358aea29d713ae7002a88517e41fd7b4f2a032f4c3f617a847a4f581f88c", + "a90991f7838a47c3d0e11e5608b7a890d14384e6626930ac6e680b080410c3ae", + "99b97b185b13d494d3eb0ad49fcb30f41232afc6544dd839e4718f180213e463", + "7eff5fce967c622a9326203828d51cc22777d8a53289413799dedeacef03c341", + "989aabf90e0dd08d40bc02b55b348adfbabf7831af7308a24afb8e68b314a883", + "62ffe5de88f0024a3a11e4d76f9296948ef79cdf7c851eb09a31f6bd345b344c", + "60bb4a5edf08e90ddce78f8755becaa40d141d6df94a57b904e923ec74e3cf06", + "9842530c78060d298bb03e36d67936793cf008b82750274bfb0dde9448d2a342", + "b24114c52e335f94c8e7ced388bf034dd2fef622a422c71f2b2ebb21738092ab", + "e4fbcc5fba853e1b207f6c2ba7eb5170e24e55fce60d79bbe324bab1091e17cd", + "68282bb5dc54d6a4d4979297d86d55063dcd80c1ed30c50890b87e34faadd55c", + "ca6a10b5a6c2319a06188be31d6b02b6150b032a59998c144ed73eb133fa92c5", + "48239b8d9dc527772202aa387602c239b04c1da7534318af1b6f8cda19a18179", + "97cfe68cac82de107b4108e288a28b76e25bf2cf9a7e0f620ac9c5e90d444939", + "0357d643a85faf55c7d3267959a09ebcb6147c93fade02f8eee2038f986e41ca", + "88c28dbbd99e1f47b01c6a724ac310a20be467c600b4e130bbb56de0ecd11586", + "c97922e57bbf88e535bac0ab5f67fc5fa1be2467f6f6fdba9bd530b5f1bbeab0", + "1639723c3c05466e051add9f786d6cce3295ce6ea5754d6fea08a9e4e59a5256", + "9f2e37e2bfe57fe3cf5e8709e4b575089ea0d3200f4b5a5c27b556d0c9586e31", + "b2025ea0495a7bc7a53b96cc16d8552f60054e7ae26daf7837ff2dec0bea2bdd", + "25646b94db613ec1bd53d92165492d61279e3d9854ff6aa3a3cd195a9cd7c4ef", + "0302bf22cb2d4791b28263faf40280e1ae135ebd95e46bbaa7999fd82f79bafb" + ] + } + ] +} \ No newline at end of file From 072d889353bc4858655e7600144275e9da74c12e Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Fri, 1 Aug 2025 21:19:06 +0200 Subject: [PATCH 35/43] shard parser works --- packages/hub/src/utils/shardParser.spec.ts | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) diff --git a/packages/hub/src/utils/shardParser.spec.ts b/packages/hub/src/utils/shardParser.spec.ts index 1cea875bb3..c8ace91439 100644 --- a/packages/hub/src/utils/shardParser.spec.ts +++ b/packages/hub/src/utils/shardParser.spec.ts @@ -5,7 +5,8 @@ import { init, compute_hmac } from "../vendor/xet-chunk/chunker_wasm"; describe("shardParser", () => { it("should parse a shard", async () => { - const shard = await parseShardData(new Blob([await readFile("tests/gpt2-64-8bits.tflite.shard")])); + const buffer = await readFile("tests/gpt2-64-8bits.tflite.shard"); + const shard = await parseShardData(new Blob([buffer])); const expectedJson = JSON.parse(await readFile("tests/gpt2-64-8bits.tflite.shard.json", "utf-8")); expect(shard.hmacKey).toBe(expectedJson.hmac_key); @@ -21,12 +22,6 @@ describe("shardParser", () => { await init(); const chunkHash = "9502eec19d4b0c9f7b389228fa801f68ecdf15d69ccd1da2f9ddbd0219898335"; - const xorb = shard.xorbs.find((xorb) => - xorb.chunks.some((chunk) => compute_hmac(chunk.hash, shard.hmacKey) === chunkHash) - ); - expect(xorb).toBeDefined(); - expect(xorb?.chunks.length).toBe(1); - expect(xorb?.chunks[0].startOffset).toBe(0); - expect(xorb?.chunks[0].unpackedLength).toBe(1024); + expect(compute_hmac(chunkHash, shard.hmacKey)).toEqual(shard.xorbs[1].chunks[0].hash); }); }); From 82dffa6a1c178622a68ce76956c882cfabe2a012 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Fri, 1 Aug 2025 21:46:57 +0200 Subject: [PATCH 36/43] fix OOBs --- packages/hub/src/utils/createXorbs.ts | 14 +++++++++++++- packages/hub/src/utils/uploadShards.ts | 8 ++++---- 2 files changed, 17 insertions(+), 5 deletions(-) diff --git a/packages/hub/src/utils/createXorbs.ts b/packages/hub/src/utils/createXorbs.ts index b977b2ad78..ba45a94d96 100644 --- a/packages/hub/src/utils/createXorbs.ts +++ b/packages/hub/src/utils/createXorbs.ts @@ -181,6 +181,10 @@ export async function* createXorbs( xorbFileProgress = {}; for (const event of pendingFileEvents) { + event.representation = event.representation.map((rep) => ({ + ...rep, + xorbId: (rep.xorbId as number) >= 0 ? rep.xorbId : remoteXorbHashes[-rep.xorbId], + })); yield event; } pendingFileEvents.length = 0; @@ -204,7 +208,7 @@ export async function* createXorbs( if (!lastRep) { fileRepresentation.push({ - xorbId: chunkXorbId >= 0 ? chunkXorbId : remoteXorbHashes[-chunkXorbId], + xorbId: chunkXorbId, indexStart: chunkIndex, indexEnd: chunkIndex + 1, length: chunk.length, @@ -247,6 +251,10 @@ export async function* createXorbs( xorb = new Uint8Array(XORB_SIZE); for (const event of pendingFileEvents) { + event.representation = event.representation.map((rep) => ({ + ...rep, + xorbId: (rep.xorbId as number) >= 0 ? rep.xorbId : remoteXorbHashes[-rep.xorbId], + })); yield event; } pendingFileEvents.length = 0; @@ -296,6 +304,10 @@ export async function* createXorbs( } for (const event of pendingFileEvents) { + event.representation = event.representation.map((rep) => ({ + ...rep, + xorbId: (rep.xorbId as number) >= 0 ? rep.xorbId : remoteXorbHashes[-rep.xorbId], + })); yield event; } } finally { diff --git a/packages/hub/src/utils/uploadShards.ts b/packages/hub/src/utils/uploadShards.ts index e45412de86..b8c2e6e81c 100644 --- a/packages/hub/src/utils/uploadShards.ts +++ b/packages/hub/src/utils/uploadShards.ts @@ -226,8 +226,8 @@ export async function* uploadShards( shardOffset += 8; // File Info Section - shard.set(fileInfoSection, shardOffset); - shardOffset += fileInfoSection.length; + shard.set(fileInfoSection.slice(0, fileViewOffset), shardOffset); + shardOffset += fileViewOffset; // File info bookend for (let i = 0; i < 32; i++) { @@ -240,8 +240,8 @@ export async function* uploadShards( shardOffset += 16; // XORB Info Section - shard.set(xorbInfoSection, shardOffset); - shardOffset += xorbInfoSection.length; + shard.set(xorbInfoSection.slice(0, xorbViewOffset), shardOffset); + shardOffset += xorbViewOffset; // Xorb info bookend for (let i = 0; i < 32; i++) { From 63d2e07a1b3936963d24437c3c0a0bf01e32976d Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Fri, 1 Aug 2025 21:48:38 +0200 Subject: [PATCH 37/43] top-level comment --- packages/hub/scripts/bench.ts | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/packages/hub/scripts/bench.ts b/packages/hub/scripts/bench.ts index 1ffe5f21c9..279dbf4f3e 100644 --- a/packages/hub/scripts/bench.ts +++ b/packages/hub/scripts/bench.ts @@ -7,6 +7,15 @@ import { writeFile, readFile, stat, mkdir } from "node:fs/promises"; import type { RepoId } from "../src/types/public.js"; import { toRepoId } from "../src/utils/toRepoId.js"; +/** + * This script downloads the files from openai-community/gpt2 and simulates an upload to a xet repo. + * It prints the dedup % and the statistics + * + * Usage: + * + * pnpm --filter hub bench -t -r + */ + const FILES_TO_DOWNLOAD = [ { url: "https://huggingface.co/openai-community/gpt2/resolve/main/64-8bits.tflite?download=true", From ad697ae05dea9394561eceb938c2703c587c9c12 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Fri, 1 Aug 2025 21:50:53 +0200 Subject: [PATCH 38/43] update wasm --- .../src/vendor/xet-chunk/chunker_wasm_bg.js | 26 +- .../xet-chunk/chunker_wasm_bg.wasm.base64.ts | 3519 ++++++++--------- 2 files changed, 1759 insertions(+), 1786 deletions(-) diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.js b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.js index 0f20569017..f5e249e67d 100644 --- a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.js +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.js @@ -95,17 +95,6 @@ function handleError(f, args) { } } -const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder; - -let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true }); - -cachedTextDecoder.decode(); - -function getStringFromWasm0(ptr, len) { - ptr = ptr >>> 0; - return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len)); -} - function debugString(val) { // primitive types const type = typeof val; @@ -171,6 +160,17 @@ function debugString(val) { return className; } +const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder; + +let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true }); + +cachedTextDecoder.decode(); + +function getStringFromWasm0(ptr, len) { + ptr = ptr >>> 0; + return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len)); +} + function isLikeNone(x) { return x === undefined || x === null; } @@ -437,10 +437,6 @@ export function __wbg_length_e2d2a49132c1b256(arg0) { return ret; }; -export function __wbg_log_c5d1a8dc098212af(arg0, arg1) { - console.log(getStringFromWasm0(arg0, arg1)); -}; - export function __wbg_new_405e22f390576ce2() { const ret = new Object(); return ret; diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts index e359e1161c..8fe1e5e404 100644 --- a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts @@ -1,1782 +1,1759 @@ // Generated by build-xet-wasm.sh export const wasmBase64 = atob(` AGFzbQEAAAABwAIuYAJ/fwF/YAN/f38Bf2ACf38AYAN/f38AYAR/f39/AGABfwBgAW8Bf2ABfwF/ -YAAEf39/f2AFf39/f38AYAFvAW9gAn9vAGAAAW9gAABgBn9/f39/fwBgBH9/f38Bf2AAA39/f2AC -b28Bb2AGf39/f39/AX9gBX9/f39/AX9gAn9/AW9gAm9vAX9gAAF/YAFvBH9/f39gAW8BfGABfAFv +YAAEf39/f2AFf39/f38AYAFvAW9gAn9vAGAAAW9gAABgBn9/f39/fwBgAAN/f39gAm9vAW9gBn9/ +f39/fwF/YAV/f39/fwF/YAR/f39/AX9gAn9/AW9gAm9vAX9gAAF/YAFvBH9/f39gAW8BfGABfAFv YANvb28AYAJvfwFvYANvf28AYANvb38AYAV/f39+fwBgB39/f35/f38Bf2AJf39/f39/fn5+AGAD fn9/AX9gB39/f39/f38Bf2AEf39/fwR/f39/YAJ/fwR/f39/YAN/f38Df39/YAF/A39/f2AFf399 -f38AYAR/fX9/AGAFf398f38AYAR/fH9/AGAFf39+f38AYAR/fn9/AGACf34BfgL1ECgYLi9oZl94 -ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX2xvZ19jNWQxYThkYzA5ODIxMmFmAAIYLi9oZl94ZXRf -dGhpbl93YXNtX2JnLmpzFV9fd2JpbmRnZW5fc3RyaW5nX25ldwAUGC4vaGZfeGV0X3RoaW5fd2Fz -bV9iZy5qcxVfX3diaW5kZ2VuX3N0cmluZ19nZXQACxguL2hmX3hldF90aGluX3dhc21fYmcuanMU -X193YmluZGdlbl9pc19vYmplY3QABhguL2hmX3hldF90aGluX3dhc21fYmcuanMXX193YmluZGdl -bl9pc191bmRlZmluZWQABhguL2hmX3hldF90aGluX3dhc21fYmcuanMNX193YmluZGdlbl9pbgAV -GC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxRfX3diaW5kZ2VuX2Vycm9yX25ldwAUGC4vaGZfeGV0 -X3RoaW5fd2FzbV9iZy5qcxlfX3diaW5kZ2VuX2pzdmFsX2xvb3NlX2VxABUYLi9oZl94ZXRfdGhp -bl93YXNtX2JnLmpzFl9fd2JpbmRnZW5fYm9vbGVhbl9nZXQABhguL2hmX3hldF90aGluX3dhc21f -YmcuanMVX193YmluZGdlbl9udW1iZXJfZ2V0AAsYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzFF9f -d2JpbmRnZW5fYXNfbnVtYmVyABgYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzHV9fd2JnX1N0cmlu -Z184ZjBlYjM5YTRhNGMyZjY2AAsYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzFV9fd2JpbmRnZW5f -bnVtYmVyX25ldwAZGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcyRfX3diZ19nZXR3aXRocmVma2V5 -XzFkYzM2MWJkMTAwNTNiZmUAERguL2hmX3hldF90aGluX3dhc21fYmcuanMaX193Ymdfc2V0XzNm -MWQwYjk4NGVkMjcyZWQAGhguL2hmX3hldF90aGluX3dhc21fYmcuanMaX193YmdfZ2V0X2I5Yjkz -MDQ3ZmUzY2Y0NWIAGxguL2hmX3hldF90aGluX3dhc21fYmcuanMdX193YmdfbGVuZ3RoX2UyZDJh -NDkxMzJjMWIyNTYABhguL2hmX3hldF90aGluX3dhc21fYmcuanMaX193YmdfbmV3Xzc4ZmViMTA4 -YjY0NzI3MTMADBguL2hmX3hldF90aGluX3dhc21fYmcuanMWX193YmluZGdlbl9pc19mdW5jdGlv -bgAGGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxtfX3diZ19uZXh0XzI1ZmVhZGZjMDkxM2ZlYTkA -ChguL2hmX3hldF90aGluX3dhc21fYmcuanMbX193YmdfbmV4dF82NTc0ZTFhOGE2MmQxMDU1AAoY -Li9oZl94ZXRfdGhpbl93YXNtX2JnLmpzG19fd2JnX2RvbmVfNzY5ZTVlZGU0YjMxYzY3YgAGGC4v -aGZfeGV0X3RoaW5fd2FzbV9iZy5qcxxfX3diZ192YWx1ZV9jZDFmZmE3YjFhYjc5NGYxAAoYLi9o -Zl94ZXRfdGhpbl93YXNtX2JnLmpzH19fd2JnX2l0ZXJhdG9yXzlhMjRjODhkZjg2MGRjNjUADBgu -L2hmX3hldF90aGluX3dhc21fYmcuanMaX193YmdfZ2V0XzY3YjJiYTYyZmMzMGRlMTIAERguL2hm -X3hldF90aGluX3dhc21fYmcuanMbX193YmdfY2FsbF82NzJhNGQyMTYzNGQ0YTI0ABEYLi9oZl94 -ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX25ld180MDVlMjJmMzkwNTc2Y2UyAAwYLi9oZl94ZXRf -dGhpbl93YXNtX2JnLmpzGl9fd2JnX3NldF8zNzgzNzAyM2YzZDc0MGU4ABwYLi9oZl94ZXRfdGhp -bl93YXNtX2JnLmpzHl9fd2JnX2lzQXJyYXlfYTFlYWI3ZTBkMDY3MzkxYgAGGC4vaGZfeGV0X3Ro -aW5fd2FzbV9iZy5qcy1fX3diZ19pbnN0YW5jZW9mX0FycmF5QnVmZmVyX2UxNDU4NTQzMmUzNzM3 -ZmMABhguL2hmX3hldF90aGluX3dhc21fYmcuanMkX193YmdfaXNTYWZlSW50ZWdlcl8zNDNlMmJl -ZWVlY2UxYmIwAAYYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzHV9fd2JnX2J1ZmZlcl82MDljYzNl -ZWU1MWVkMTU4AAoYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX25ld19hMTIwMDJhN2Y5 -MWM3NWJlAAoYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX3NldF82NTU5NWJkZDg2OGIz -MDA5AB0YLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzHV9fd2JnX2xlbmd0aF9hNDQ2MTkzZGMyMmMx -MmY4AAYYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzLF9fd2JnX2luc3RhbmNlb2ZfVWludDhBcnJh -eV8xNzE1NmJjZjExODA4NmE5AAYYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzF19fd2JpbmRnZW5f -ZGVidWdfc3RyaW5nAAsYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzEF9fd2JpbmRnZW5fdGhyb3cA -AhguL2hmX3hldF90aGluX3dhc21fYmcuanMRX193YmluZGdlbl9tZW1vcnkADBguL2hmX3hldF90 -aGluX3dhc21fYmcuanMfX193YmluZGdlbl9pbml0X2V4dGVybnJlZl90YWJsZQANA9IB0AEeBx8C -AgACAgADCQMEAxIDAAUBAAEAAQABEgEEAiABAgAhAwcAAgAADg4iAAACFgkDAAIEAAQEAwMPAQcC -AAkCAwUCAgMFDgMWDgIABAICAAMABAIACQMBAwQCBwAAAAQEAwAEAQEFBA0BAAAFAgADBAIAEwAF -IyQlFxcCJg8SBwAJEycpKwUEAAEELQAFAwMABQAABw8AAwABAAkAAAQEAAAFAgICAAAAAgMDBwMD -AwAFAAAAAAAAAAAAAAANDQIAAgAAAgABAgAAAgcHBwcDBAkCcAFpaW8AgAEFAwEAEQYJAX8BQYCA -wAALB98CEQZtZW1vcnkCABJfX3diZ19jaHVua2VyX2ZyZWUAagtjaHVua2VyX25ldwBLEGNodW5r -ZXJfYWRkX2RhdGEAoAEOY2h1bmtlcl9maW5pc2gApAERY29tcHV0ZV94b3JiX2hhc2gAoQERY29t -cHV0ZV9maWxlX2hhc2gAogEZY29tcHV0ZV92ZXJpZmljYXRpb25faGFzaACfAQxjb21wdXRlX2ht -YWMAngERX193YmluZGdlbl9tYWxsb2MAnAESX193YmluZGdlbl9yZWFsbG9jAKUBFF9fd2JpbmRn -ZW5fZXhuX3N0b3JlAMoBF19fZXh0ZXJucmVmX3RhYmxlX2FsbG9jAHATX193YmluZGdlbl9leHBv -cnRfNAEBGV9fZXh0ZXJucmVmX3RhYmxlX2RlYWxsb2MAbQ9fX3diaW5kZ2VuX2ZyZWUAvwEQX193 -YmluZGdlbl9zdGFydAAnCb4BAQBBAQto3gHfAYQBvgG1AYwBTuEB2wHgAfEB8AHcAd0BwgE4xAHi -AbUBjAFPwgFzmgGqAXGpAaoBpgGxAa8BqQGpAasBrAGtAbIBgQF69gH3AYcBiwFdpwFsiAGPAV5v -4wGYAcYBxwHUAX55yAHEAYoBsAHaAagBZVnJAZYBYrQB5AHIAbkB2AGCAbUBjQFU6AHMAcsBzgGV -Ac0B6QGuAXxaa/IBtQGRAVPqAesBwAHCAc8B0AE7d1w+kwHtAQwBDgra+QTQAYkbASB/IAAgACgC -GCIdIAEoABAiJCAAKAIIamoiGyABKAAUIhVqIB0gGyACQf8BcXNBEHciAkHy5rvjA2oiHXNBFHci -G2oiIiACc0EYdyIJIB1qIhwgG3NBGXciDyAAKAIUIhsgASgACCICIAAoAgRqaiIZIAEoAAwiHWog -GSADQiCIp3NBEHciHkH7ouGkBGsiICAbc0EUdyIGaiIKIAEoACgiG2pqIiMgASgALCIZaiAPICMg -ACgCECIhIAEoAAAiDyAAKAIAamoiCCABKAAEIh9qICEgCCADp3NBEHciIUHnzKfQBmoiCHNBFHci -B2oiDiAhc0EYdyINc0EQdyILIAAoAhwiBSABKAAYIiMgACgCDGpqIgwgASgAHCIhaiAFIAwgBEH/ -AXFzQRB3IgRBxpXA1QVrIgVzQRR3IgxqIhEgBHNBGHciECAFaiIFaiISc0EUdyIUaiITIB1qIAYg -ICAKIB5zQRh3IiBqIgZzQRl3IgogDiABKAAgIgRqaiIOIAEoACQiHmogCiAcIA4gEHNBEHciHGoi -CnNBFHciDmoiECAcc0EYdyIWIApqIgogDnNBGXciHGoiDiAbaiAcIA4gBSAMc0EZdyIFICIgASgA -MCIcamoiDCABKAA0IiJqIAwgIHNBEHciICAIIA1qIghqIg0gBXNBFHciBWoiDCAgc0EYdyIXc0EQ -dyIOIAcgCHNBGXciCCARIAEoADgiIGpqIgcgASgAPCIBaiAHIAlzQRB3IgkgBmoiBiAIc0EUdyII -aiIHIAlzQRh3IgkgBmoiBmoiEXNBFHciGGoiGiAcaiALIBNzQRh3IgsgEmoiEiAUc0EZdyIUIAwg -IWpqIgwgD2ogCSAMc0EQdyIJIApqIgogFHNBFHciDGoiFCAJc0EYdyIJIApqIgogDHNBGXciDGoi -EyAVaiAMIBMgBiAIc0EZdyIGIAIgEGpqIgggI2ogBiAIIAtzQRB3IgYgDSAXaiIIaiINc0EUdyIL -aiIMIAZzQRh3IgZzQRB3IhAgBSAIc0EZdyIIIAcgJGpqIgcgImogCCAHIBZzQRB3IgggEmoiB3NB -FHciBWoiEiAIc0EYdyIIIAdqIgdqIhNzQRR3IhZqIhcgG2ogDiAac0EYdyIOIBFqIhEgGHNBGXci -GCAMIB9qaiIMIBlqIAogCCAMc0EQdyIKaiIIIBhzQRR3IgxqIhggCnNBGHciCiAIaiIIIAxzQRl3 -IgxqIhogHGogDCAaIAUgB3NBGXciByAUIB5qaiIFICBqIAcgBSAOc0EQdyIHIAYgDWoiBmoiDnNB -FHciDWoiBSAHc0EYdyIHc0EQdyIMIAYgC3NBGXciBiABIBJqaiILIARqIAYgCSALc0EQdyIJIBFq -IgZzQRR3IgtqIhEgCXNBGHciCSAGaiIGaiISc0EUdyIUaiIaIB5qIBAgF3NBGHciECATaiITIBZz -QRl3IhYgBSAiamoiBSACaiAFIAlzQRB3IgkgCGoiCCAWc0EUdyIFaiIWIAlzQRh3IgkgCGoiCCAF -c0EZdyIFaiIXIA9qIAUgFyAGIAtzQRl3IgYgGCAdamoiCyAkaiAGIAsgEHNBEHciBiAHIA5qIgdq -Ig5zQRR3IgtqIgUgBnNBGHciBnNBEHciECAHIA1zQRl3IgcgESAhamoiDSAgaiAHIAogDXNBEHci -CiATaiIHc0EUdyINaiIRIApzQRh3IgogB2oiB2oiE3NBFHciF2oiGCAcaiAMIBpzQRh3IgwgEmoi -EiAUc0EZdyIUIAUgI2pqIgUgFWogBSAKc0EQdyIKIAhqIgggFHNBFHciBWoiFCAKc0EYdyIKIAhq -IgggBXNBGXciBWoiGiAeaiAFIBogByANc0EZdyIHIBYgGWpqIg0gAWogByAMIA1zQRB3IgcgBiAO -aiIGaiIOc0EUdyINaiIFIAdzQRh3IgdzQRB3IgwgBiALc0EZdyIGIAQgEWpqIgsgH2ogBiAJIAtz -QRB3IgkgEmoiBnNBFHciC2oiESAJc0EYdyIJIAZqIgZqIhJzQRR3IhZqIhogGWogECAYc0EYdyIQ -IBNqIhMgF3NBGXciFyAFICBqaiIFIB1qIAUgCXNBEHciCSAIaiIIIBdzQRR3IgVqIhcgCXNBGHci -CSAIaiIIIAVzQRl3IgVqIhggAmogBSAYIAYgC3NBGXciBiAUIBtqaiILICFqIAYgCyAQc0EQdyIG -IAcgDmoiB2oiDnNBFHciC2oiBSAGc0EYdyIGc0EQdyIQIAcgDXNBGXciByARICJqaiINIAFqIAcg -CiANc0EQdyIKIBNqIgdzQRR3Ig1qIhEgCnNBGHciCiAHaiIHaiIUc0EUdyITaiIYIB5qIAwgGnNB -GHciDCASaiISIBZzQRl3IhYgBSAkamoiBSAPaiAFIApzQRB3IgogCGoiCCAWc0EUdyIFaiIWIApz -QRh3IgogCGoiCCAFc0EZdyIFaiIaIBlqIAUgGiAHIA1zQRl3IgcgFSAXamoiDSAEaiAHIAwgDXNB -EHciByAGIA5qIgZqIg5zQRR3Ig1qIgUgB3NBGHciB3NBEHciDCAGIAtzQRl3IgYgESAfamoiCyAj -aiAGIAkgC3NBEHciCSASaiIGc0EUdyILaiIRIAlzQRh3IgkgBmoiBmoiEnNBFHciF2oiGiAVaiAQ -IBhzQRh3IhAgFGoiFCATc0EZdyITIAEgBWpqIgUgG2ogBSAJc0EQdyIJIAhqIgggE3NBFHciBWoi -EyAJc0EYdyIJIAhqIgggBXNBGXciBWoiGCAdaiAFIBggBiALc0EZdyIGIBYgHGpqIgsgImogBiAL -IBBzQRB3IgYgByAOaiIHaiIOc0EUdyILaiIFIAZzQRh3IgZzQRB3IhAgByANc0EZdyIHIBEgIGpq -Ig0gBGogByAKIA1zQRB3IgogFGoiB3NBFHciDWoiESAKc0EYdyIKIAdqIgdqIhRzQRR3IhZqIhgg -GWogDCAac0EYdyIMIBJqIhIgF3NBGXciFyAFICFqaiIFIAJqIAUgCnNBEHciCiAIaiIIIBdzQRR3 -IgVqIhcgCnNBGHciCiAIaiIIIAVzQRl3IgVqIhogFWogBSAaIAcgDXNBGXciByAPIBNqaiINIB9q -IAcgDCANc0EQdyIHIAYgDmoiBmoiDnNBFHciDWoiBSAHc0EYdyIHc0EQdyIMIAYgC3NBGXciBiAR -ICNqaiILICRqIAYgCSALc0EQdyIJIBJqIgZzQRR3IgtqIhEgCXNBGHciCSAGaiIGaiISc0EUdyIT -aiIaIA9qIBAgGHNBGHciECAUaiIUIBZzQRl3IhYgBCAFamoiBSAcaiAFIAlzQRB3IgkgCGoiCCAW -c0EUdyIFaiIWIAlzQRh3IgkgCGoiCCAFc0EZdyIFaiIYIBtqIAUgGCAGIAtzQRl3IgYgFyAeamoi -CyAgaiAGIAsgEHNBEHciBiAHIA5qIgdqIg5zQRR3IgtqIgUgBnNBGHciBnNBEHciECAHIA1zQRl3 -IgcgASARamoiDSAfaiAHIAogDXNBEHciCiAUaiIHc0EUdyINaiIRIApzQRh3IgogB2oiB2oiFHNB -FHciF2oiGCAVaiAMIBpzQRh3IhUgEmoiDCATc0EZdyISIAUgImpqIgUgHWogBSAKc0EQdyIKIAhq -IgggEnNBFHciBWoiEiAKc0EYdyIKIAhqIgggBXNBGXciBWoiEyAPaiAFIBMgByANc0EZdyIPIAIg -FmpqIgcgI2ogDyAHIBVzQRB3IhUgBiAOaiIPaiIGc0EUdyIHaiIOIBVzQRh3IhVzQRB3Ig0gCyAP -c0EZdyIPIBEgJGpqIgsgIWogDyAJIAtzQRB3Ig8gDGoiCXNBFHciC2oiBSAPc0EYdyIPIAlqIglq -IgxzQRR3IhFqIhMgAmogHiAQIBhzQRh3IgIgFGoiHiAXc0EZdyIQIA4gH2pqIh9qIA8gH3NBEHci -DyAIaiIfIBBzQRR3IghqIg4gD3NBGHciDyAfaiIfIAhzQRl3IghqIhAgHGogECABIAkgC3NBGXci -ASASIBlqaiIZaiABIAIgGXNBEHciASAGIBVqIgJqIhVzQRR3IhlqIhwgAXNBGHciAXNBEHciCSAC -IAdzQRl3IgIgBCAFamoiBCAjaiACIAQgCnNBEHciAiAeaiIEc0EUdyIjaiIeIAJzQRh3IgIgBGoi -BGoiBiAIc0EUdyIKaiIIIAlzQRh3IgkgBmoiBiABIBVqIgEgGXNBGXciFSAeICFqaiIZICJqIBUg -DyAZc0EQdyIVIA0gE3NBGHciGSAMaiIPaiIhc0EUdyIeaiIiczYCDCAAIBsgDyARc0EZdyIPIBwg -IGpqIhxqIAIgHHNBEHciAiAfaiIbIA9zQRR3Ig9qIh8gAnNBGHciAiAbaiIbICQgBCAjc0EZdyIE -IA4gHWpqIh1qIAQgASAZIB1zQRB3IgFqIgRzQRR3IiRqIh1zNgIIIAAgFSAic0EYdyIVICFqIhkg -CHM2AgQgACABIB1zQRh3IgEgBGoiBCAfczYCACAAIAQgJHNBGXcgAnM2AhwgACAGIApzQRl3IBVz -NgIYIAAgDyAbc0EZdyABczYCFCAAIBkgHnNBGXcgCXM2AhALmyQCCX8BfiMAQRBrIggkAAJ/AkAC -QAJAAkACQAJAIABB9QFPBEBBACAAQcz/e0sNBxogAEELaiIBQXhxIQVBxIbBACgCACIJRQ0EQR8h -B0EAIAVrIQQgAEH0//8HTQRAIAVBBiABQQh2ZyIAa3ZBAXEgAEEBdGtBPmohBwsgB0ECdEGog8EA -aigCACIBRQRAQQAhAAwCC0EAIQAgBUEZIAdBAXZrQQAgB0EfRxt0IQMDQAJAIAEoAgRBeHEiBiAF -SQ0AIAYgBWsiBiAETw0AIAEhAiAGIgQNAEEAIQQgASEADAQLIAEoAhQiBiAAIAYgASADQR12QQRx -aigCECIBRxsgACAGGyEAIANBAXQhAyABDQALDAELQcCGwQAoAgAiAkEQIABBC2pB+ANxIABBC0kb -IgVBA3YiAHYiAUEDcQRAAkAgAUF/c0EBcSAAaiIGQQN0IgBBuITBAGoiAyAAQcCEwQBqKAIAIgEo -AggiBEcEQCAEIAM2AgwgAyAENgIIDAELQcCGwQAgAkF+IAZ3cTYCAAsgASAAQQNyNgIEIAAgAWoi -ACAAKAIEQQFyNgIEIAFBCGoMBwsgBUHIhsEAKAIATQ0DAkACQCABRQRAQcSGwQAoAgAiAEUNBiAA -aEECdEGog8EAaigCACICKAIEQXhxIAVrIQQgAiEBA0ACQCACKAIQIgANACACKAIUIgANACABKAIY -IQcCQAJAIAEgASgCDCIARgRAIAFBFEEQIAEoAhQiABtqKAIAIgINAUEAIQAMAgsgASgCCCICIAA2 -AgwgACACNgIIDAELIAFBFGogAUEQaiAAGyEDA0AgAyEGIAIiAEEUaiAAQRBqIAAoAhQiAhshAyAA -QRRBECACG2ooAgAiAg0ACyAGQQA2AgALIAdFDQQCQCABKAIcQQJ0QaiDwQBqIgIoAgAgAUcEQCAB -IAcoAhBHBEAgByAANgIUIAANAgwHCyAHIAA2AhAgAA0BDAYLIAIgADYCACAARQ0ECyAAIAc2Ahgg -ASgCECICBEAgACACNgIQIAIgADYCGAsgASgCFCICRQ0EIAAgAjYCFCACIAA2AhgMBAsgACgCBEF4 -cSAFayICIAQgAiAESSICGyEEIAAgASACGyEBIAAhAgwACwALAkBBAiAAdCIDQQAgA2tyIAEgAHRx -aCIGQQN0IgFBuITBAGoiAyABQcCEwQBqKAIAIgAoAggiBEcEQCAEIAM2AgwgAyAENgIIDAELQcCG -wQAgAkF+IAZ3cTYCAAsgACAFQQNyNgIEIAAgBWoiBiABIAVrIgNBAXI2AgQgACABaiADNgIAQciG -wQAoAgAiBARAIARBeHFBuITBAGohAUHQhsEAKAIAIQICf0HAhsEAKAIAIgVBASAEQQN2dCIEcUUE -QEHAhsEAIAQgBXI2AgAgAQwBCyABKAIICyEEIAEgAjYCCCAEIAI2AgwgAiABNgIMIAIgBDYCCAtB -0IbBACAGNgIAQciGwQAgAzYCACAAQQhqDAgLQcSGwQBBxIbBACgCAEF+IAEoAhx3cTYCAAsCQAJA -IARBEE8EQCABIAVBA3I2AgQgASAFaiIDIARBAXI2AgQgAyAEaiAENgIAQciGwQAoAgAiBkUNASAG -QXhxQbiEwQBqIQBB0IbBACgCACECAn9BwIbBACgCACIFQQEgBkEDdnQiBnFFBEBBwIbBACAFIAZy -NgIAIAAMAQsgACgCCAshBiAAIAI2AgggBiACNgIMIAIgADYCDCACIAY2AggMAQsgASAEIAVqIgBB -A3I2AgQgACABaiIAIAAoAgRBAXI2AgQMAQtB0IbBACADNgIAQciGwQAgBDYCAAsgAUEIagwGCyAA -IAJyRQRAQQAhAkECIAd0IgBBACAAa3IgCXEiAEUNAyAAaEECdEGog8EAaigCACEACyAARQ0BCwNA -IAAgAiAAKAIEQXhxIgMgBWsiBiAESSIHGyEJIAAoAhAiAUUEQCAAKAIUIQELIAIgCSADIAVJIgAb -IQIgBCAGIAQgBxsgABshBCABIgANAAsLIAJFDQAgBUHIhsEAKAIAIgBNIAQgACAFa09xDQAgAigC -GCEHAkACQCACIAIoAgwiAEYEQCACQRRBECACKAIUIgAbaigCACIBDQFBACEADAILIAIoAggiASAA -NgIMIAAgATYCCAwBCyACQRRqIAJBEGogABshAwNAIAMhBiABIgBBFGogAEEQaiAAKAIUIgEbIQMg -AEEUQRAgARtqKAIAIgENAAsgBkEANgIACyAHRQ0CAkAgAigCHEECdEGog8EAaiIBKAIAIAJHBEAg -AiAHKAIQRwRAIAcgADYCFCAADQIMBQsgByAANgIQIAANAQwECyABIAA2AgAgAEUNAgsgACAHNgIY -IAIoAhAiAQRAIAAgATYCECABIAA2AhgLIAIoAhQiAUUNAiAAIAE2AhQgASAANgIYDAILAkACQAJA -AkACQCAFQciGwQAoAgAiAUsEQCAFQcyGwQAoAgAiAE8EQCAFQa+ABGpBgIB8cSICQRB2QAAhACAI -QQRqIgFBADYCCCABQQAgAkGAgHxxIABBf0YiAhs2AgQgAUEAIABBEHQgAhs2AgBBACAIKAIEIgFF -DQkaIAgoAgwhBkHYhsEAIAgoAggiBEHYhsEAKAIAaiIANgIAQdyGwQAgAEHchsEAKAIAIgIgACAC -Sxs2AgACQAJAQdSGwQAoAgAiAgRAQaiEwQAhAANAIAEgACgCACIDIAAoAgQiB2pGDQIgACgCCCIA -DQALDAILQeSGwQAoAgAiAEEAIAAgAU0bRQRAQeSGwQAgATYCAAtB6IbBAEH/HzYCAEG0hMEAIAY2 -AgBBrITBACAENgIAQaiEwQAgATYCAEHEhMEAQbiEwQA2AgBBzITBAEHAhMEANgIAQcCEwQBBuITB -ADYCAEHUhMEAQciEwQA2AgBByITBAEHAhMEANgIAQdyEwQBB0ITBADYCAEHQhMEAQciEwQA2AgBB -5ITBAEHYhMEANgIAQdiEwQBB0ITBADYCAEHshMEAQeCEwQA2AgBB4ITBAEHYhMEANgIAQfSEwQBB -6ITBADYCAEHohMEAQeCEwQA2AgBB/ITBAEHwhMEANgIAQfCEwQBB6ITBADYCAEGEhcEAQfiEwQA2 -AgBB+ITBAEHwhMEANgIAQYCFwQBB+ITBADYCAEGMhcEAQYCFwQA2AgBBiIXBAEGAhcEANgIAQZSF -wQBBiIXBADYCAEGQhcEAQYiFwQA2AgBBnIXBAEGQhcEANgIAQZiFwQBBkIXBADYCAEGkhcEAQZiF -wQA2AgBBoIXBAEGYhcEANgIAQayFwQBBoIXBADYCAEGohcEAQaCFwQA2AgBBtIXBAEGohcEANgIA -QbCFwQBBqIXBADYCAEG8hcEAQbCFwQA2AgBBuIXBAEGwhcEANgIAQcSFwQBBuIXBADYCAEHMhcEA -QcCFwQA2AgBBwIXBAEG4hcEANgIAQdSFwQBByIXBADYCAEHIhcEAQcCFwQA2AgBB3IXBAEHQhcEA -NgIAQdCFwQBByIXBADYCAEHkhcEAQdiFwQA2AgBB2IXBAEHQhcEANgIAQeyFwQBB4IXBADYCAEHg -hcEAQdiFwQA2AgBB9IXBAEHohcEANgIAQeiFwQBB4IXBADYCAEH8hcEAQfCFwQA2AgBB8IXBAEHo -hcEANgIAQYSGwQBB+IXBADYCAEH4hcEAQfCFwQA2AgBBjIbBAEGAhsEANgIAQYCGwQBB+IXBADYC -AEGUhsEAQYiGwQA2AgBBiIbBAEGAhsEANgIAQZyGwQBBkIbBADYCAEGQhsEAQYiGwQA2AgBBpIbB -AEGYhsEANgIAQZiGwQBBkIbBADYCAEGshsEAQaCGwQA2AgBBoIbBAEGYhsEANgIAQbSGwQBBqIbB -ADYCAEGohsEAQaCGwQA2AgBBvIbBAEGwhsEANgIAQbCGwQBBqIbBADYCAEHUhsEAIAFBD2pBeHEi -AEEIayICNgIAQbiGwQBBsIbBADYCAEHMhsEAIARBKGsiAyABIABrakEIaiIANgIAIAIgAEEBcjYC -BCABIANqQSg2AgRB4IbBAEGAgIABNgIADAgLIAIgA0kgASACTXINACAAKAIMIgNBAXENACADQQF2 -IAZGDQMLQeSGwQBB5IbBACgCACIAIAEgACABSRs2AgAgASAEaiEDQaiEwQAhAAJAAkADQCADIAAo -AgAiB0cEQCAAKAIIIgANAQwCCwsgACgCDCIDQQFxDQAgA0EBdiAGRg0BC0GohMEAIQADQAJAIAIg -ACgCACIDTwRAIAIgAyAAKAIEaiIHSQ0BCyAAKAIIIQAMAQsLQdSGwQAgAUEPakF4cSIAQQhrIgM2 -AgBBzIbBACAEQShrIgkgASAAa2pBCGoiADYCACADIABBAXI2AgQgASAJakEoNgIEQeCGwQBBgICA -ATYCACACIAdBIGtBeHFBCGsiACAAIAJBEGpJGyIDQRs2AgRBqITBACkCACEKIANBEGpBsITBACkC -ADcCACADIAo3AghBtITBACAGNgIAQayEwQAgBDYCAEGohMEAIAE2AgBBsITBACADQQhqNgIAIANB -HGohAANAIABBBzYCACAAQQRqIgAgB0kNAAsgAiADRg0HIAMgAygCBEF+cTYCBCACIAMgAmsiAEEB -cjYCBCADIAA2AgAgAEGAAk8EQCACIAAQVQwICyAAQfgBcUG4hMEAaiEBAn9BwIbBACgCACIDQQEg -AEEDdnQiAHFFBEBBwIbBACAAIANyNgIAIAEMAQsgASgCCAshACABIAI2AgggACACNgIMIAIgATYC -DCACIAA2AggMBwsgACABNgIAIAAgACgCBCAEajYCBCABQQ9qQXhxQQhrIgIgBUEDcjYCBCAHQQ9q -QXhxQQhrIgQgAiAFaiIAayEFIARB1IbBACgCAEYNAyAEQdCGwQAoAgBGDQQgBCgCBCIBQQNxQQFG -BEAgBCABQXhxIgEQTSABIAVqIQUgASAEaiIEKAIEIQELIAQgAUF+cTYCBCAAIAVBAXI2AgQgACAF -aiAFNgIAIAVBgAJPBEAgACAFEFUMBgsgBUH4AXFBuITBAGohAQJ/QcCGwQAoAgAiA0EBIAVBA3Z0 -IgRxRQRAQcCGwQAgAyAEcjYCACABDAELIAEoAggLIQMgASAANgIIIAMgADYCDCAAIAE2AgwgACAD -NgIIDAULQcyGwQAgACAFayIBNgIAQdSGwQBB1IbBACgCACIAIAVqIgI2AgAgAiABQQFyNgIEIAAg -BUEDcjYCBCAAQQhqDAgLQdCGwQAoAgAhAAJAIAEgBWsiAkEPTQRAQdCGwQBBADYCAEHIhsEAQQA2 -AgAgACABQQNyNgIEIAAgAWoiASABKAIEQQFyNgIEDAELQciGwQAgAjYCAEHQhsEAIAAgBWoiAzYC -ACADIAJBAXI2AgQgACABaiACNgIAIAAgBUEDcjYCBAsgAEEIagwHCyAAIAQgB2o2AgRB1IbBAEHU -hsEAKAIAIgBBD2pBeHEiAUEIayICNgIAQcyGwQBBzIbBACgCACAEaiIDIAAgAWtqQQhqIgE2AgAg -AiABQQFyNgIEIAAgA2pBKDYCBEHghsEAQYCAgAE2AgAMAwtB1IbBACAANgIAQcyGwQBBzIbBACgC -ACAFaiIBNgIAIAAgAUEBcjYCBAwBC0HQhsEAIAA2AgBByIbBAEHIhsEAKAIAIAVqIgE2AgAgACAB -QQFyNgIEIAAgAWogATYCAAsgAkEIagwDC0EAQcyGwQAoAgAiACAFTQ0CGkHMhsEAIAAgBWsiATYC -AEHUhsEAQdSGwQAoAgAiACAFaiICNgIAIAIgAUEBcjYCBCAAIAVBA3I2AgQgAEEIagwCC0HEhsEA -QcSGwQAoAgBBfiACKAIcd3E2AgALAkAgBEEQTwRAIAIgBUEDcjYCBCACIAVqIgAgBEEBcjYCBCAA -IARqIAQ2AgAgBEGAAk8EQCAAIAQQVQwCCyAEQfgBcUG4hMEAaiEBAn9BwIbBACgCACIDQQEgBEED -dnQiBHFFBEBBwIbBACADIARyNgIAIAEMAQsgASgCCAshAyABIAA2AgggAyAANgIMIAAgATYCDCAA -IAM2AggMAQsgAiAEIAVqIgBBA3I2AgQgACACaiIAIAAoAgRBAXI2AgQLIAJBCGoLIAhBEGokAAvV -DAINfwF+IwBBoAJrIgckAAJAAkACQAJAAkAgAUGACE0EQCAHQQA2AogBIAEgAUEAIAFBgAhHGyIM -ayIOQYAITwRAIAdBATYCiAEgByAANgKMAUEBIQoLIAdBjAFqIQsgAyEUIAUhASMAQSBrIggkACAG -QQV2IgkgCiAJIApJGyINBEAgBEECciEPIARBAXIhEANAIAsoAgAhCSAIQRhqIhEgAkEYaikCADcD -ACAIQRBqIhIgAkEQaikCADcDACAIQQhqIhMgAkEIaikCADcDACAIIAIpAgA3AwAgCCAJQcAAIBQg -EBAoIAggCUFAa0HAACAUIAQQKCAIIAlBgAFqQcAAIBQgBBAoIAggCUHAAWpBwAAgFCAEECggCCAJ -QYACakHAACAUIAQQKCAIIAlBwAJqQcAAIBQgBBAoIAggCUGAA2pBwAAgFCAEECggCCAJQcADakHA -ACAUIAQQKCAIIAlBgARqQcAAIBQgBBAoIAggCUHABGpBwAAgFCAEECggCCAJQYAFakHAACAUIAQQ -KCAIIAlBwAVqQcAAIBQgBBAoIAggCUGABmpBwAAgFCAEECggCCAJQcAGakHAACAUIAQQKCAIIAlB -gAdqQcAAIBQgBBAoIAggCUHAB2pBwAAgFCAPECggAUEYaiARKQMANwAAIAFBEGogEikDADcAACAB -QQhqIBMpAwA3AAAgASAIKQMANwAAIAtBBGohCyABQSBqIQEgFEIBfCEUIA1BAWsiDQ0ACwsgCEEg -aiQAIAxFDQEgB0HIAWpCADcDACAHQcABakIANwMAIAdBuAFqQgA3AwAgB0GwAWpCADcDACAHQagB -akIANwMAIAdBoAFqQgA3AwAgB0GYAWpCADcDACAHQdgBaiIBIAJBCGopAgA3AwAgB0HgAWoiCCAC -QRBqKQIANwMAIAdB6AFqIgkgAkEYaikCADcDACAHQgA3A5ABIAcgBDoA+gEgB0EAOwH4ASAHIAIp -AgA3A9ABIAcgAyAKrXw3A/ABIAdBkAFqIAAgDmogDBBGIQAgB0HQAGogASkDADcDACAHQdgAaiAI -KQMANwMAIAdB4ABqIAkpAwA3AwAgB0EQaiAAQQhqKQMANwMAIAdBGGogAEEQaikDADcDACAHQSBq -IABBGGopAwA3AwAgB0EoaiAAQSBqKQMANwMAIAdBMGogAEEoaikDADcDACAHQThqIABBMGopAwA3 -AwAgB0FAayAAQThqKQMANwMAIAcgBykD0AE3A0ggByAAKQMANwMIIActAPoBIQAgBy0A+QEhAiAH -IActAPgBIgQ6AHAgByAHKQPwASIDNwNoIAcgACACRXJBAnIiADoAcSAHQZgCaiICIAkpAwA3AwAg -B0GQAmoiCSAIKQMANwMAIAdBiAJqIgggASkDADcDACAHIAcpA9ABNwOAAiAHQYACaiAHQQhqIAQg -AyAAECggCkEFdCIAQSBqIgEgBksNAiACKAIAIQEgCSgCACECIAgoAgAhBCAHKAKUAiEGIAcoAowC -IQggBygChAIhCSAHKAKAAiELIAAgBWoiACAHKAKcAjYAHCAAIAE2ABggACAGNgAUIAAgAjYAECAA -IAg2AAwgACAENgAIIAAgCTYABCAAIAs2AAAgCkEBaiEKDAELIAFCfyABrUIBfEIBiEIBfXmIpyII -TQ0CIAdBCGoiCUEAQYAB/AsAIAAgCEEBaiIIIAIgAyAEIAlBIEHAACAIQYAIRhsiChAqIQsgACAI -aiABIAhrIAIgAyAIQQp2rXwgBCAJIApqQYABIAprECogC0EBRgRAIAZBP00NBCAFIAcpAAg3AAAg -BUE4aiAHQUBrKQAANwAAIAVBMGogB0E4aikAADcAACAFQShqIAdBMGopAAA3AAAgBUEgaiAHQShq -KQAANwAAIAVBGGogB0EgaikAADcAACAFQRBqIAdBGGopAAA3AAAgBUEIaiAHQRBqKQAANwAAQQIh -CgwBCyALakEFdCIAQYEBTw0EIAdBCGogACACIAQgBSAGEEEhCgsgB0GgAmokACAKDwsgASAGQYi8 -wAAQ1gEACyAHQQA2AhggB0EBNgIMIAdBkLvAADYCCCAHQgQ3AhAgB0EIakHYvMAAEKMBAAtBwAAg -BkHovMAAENYBAAsgAEGAAUH4vMAAENYBAAvzCAIFfwN+AkACQAJAIAFBCE8EQCABQQdxIgJFDQEg -ACgCoAEiA0EpTw0CIANFBEAgAEEANgKgAQwCCyADQQFrQf////8DcSIFQQFqIgRBA3EhBiACQQJ0 -QZDmwABqKAIAIAJ2rSEJAkAgBUEDSQRAIAAhAgwBCyAEQfz///8HcSEFIAAhAgNAIAIgAjUCACAJ -fiAIfCIHPgIAIAJBBGoiBCAENQIAIAl+IAdCIIh8Igc+AgAgAkEIaiIEIAQ1AgAgCX4gB0IgiHwi -Bz4CACACQQxqIgQgBDUCACAJfiAHQiCIfCIHPgIAIAdCIIghCCACQRBqIQIgBUEEayIFDQALCyAG -BEADQCACIAI1AgAgCX4gCHwiBz4CACACQQRqIQIgB0IgiCEIIAZBAWsiBg0ACwsgACAHQoCAgIAQ -WgR/IANBKEYNBCAAIANBAnRqIAg+AgAgA0EBagUgAws2AqABDAELIAAoAqABIgNBKU8NASADRQRA -IABBADYCoAEPCyABQQJ0QZDmwABqNQIAIQkgA0EBa0H/////A3EiAUEBaiICQQNxIQYCQCABQQNJ -BEAgACECDAELIAJB/P///wdxIQUgACECA0AgAiACNQIAIAl+IAh8Igc+AgAgAkEEaiIBIAE1AgAg -CX4gB0IgiHwiBz4CACACQQhqIgEgATUCACAJfiAHQiCIfCIHPgIAIAJBDGoiASABNQIAIAl+IAdC -IIh8Igc+AgAgB0IgiCEIIAJBEGohAiAFQQRrIgUNAAsLIAYEQANAIAIgAjUCACAJfiAIfCIHPgIA -IAJBBGohAiAHQiCIIQggBkEBayIGDQALCyAAIAdCgICAgBBaBH8gA0EoRg0DIAAgA0ECdGogCD4C -ACADQQFqBSADCzYCoAEPCwJAIAFBCHEEQCAAKAKgASIDQSlPDQICQCADRQRAQQAhAwwBCyADQQFr -Qf////8DcSICQQFqIgVBA3EhBgJAIAJBA0kEQEIAIQcgACECDAELIAVB/P///wdxIQVCACEHIAAh -AgNAIAIgAjUCAELh6xd+IAd8Igc+AgAgAkEEaiIEIAQ1AgBC4esXfiAHQiCIfCIHPgIAIAJBCGoi -BCAENQIAQuHrF34gB0IgiHwiBz4CACACQQxqIgQgBDUCAELh6xd+IAdCIIh8Igg+AgAgCEIgiCEH -IAJBEGohAiAFQQRrIgUNAAsLIAYEQANAIAIgAjUCAELh6xd+IAd8Igg+AgAgAkEEaiECIAhCIIgh -ByAGQQFrIgYNAAsLIAhCgICAgBBUDQAgA0EoRg0CIAAgA0ECdGogBz4CACADQQFqIQMLIAAgAzYC -oAELIAFBEHEEQCAAQYTTwABBAhAzCyABQSBxBEAgAEGM08AAQQMQMwsgAUHAAHEEQCAAQZjTwABB -BRAzCyABQYABcQRAIABBrNPAAEEKEDMLIAFBgAJxBEAgAEHU08AAQRMQMwsgACABEC0aDwsMAQsg -A0EoQaz9wAAQ1gEAC0EoQShBrP3AABCAAQALtwgCDH8BfiMAQcABayICJAAgASgCECEDIAIgAUEQ -aiIENgIgIAIgAzYCHCACIAJBvwFqIgY2AhggAkGAAWoiBSABIAJBGGoiBxBKAkACQAJAIAIpA4AB -Ig5CAlENACACQfgAaiIDIAJBqAFqKQMANwMAIAJB8ABqIgggAkGgAWopAwA3AwAgAkHoAGoiCSAC -QZgBaikDADcDACACQeAAaiIKIAJBkAFqKQMANwMAIAIgAikDiAE3A1ggDqdBAXFFDQAgAkHQAGoi -CyADKQMANwMAIAJByABqIgwgCCkDADcDACACQUBrIg0gCSkDADcDACACQThqIgggCikDADcDACAC -IAIpA1g3AzBBuYLBAC0AABpBoAFBCBDFASIDRQ0CIAMgAikDMDcDACADQSBqIAspAwA3AwAgA0EY -aiAMKQMANwMAIANBEGogDSkDADcDACADQQhqIAgpAwA3AwAgAkEBNgIUIAIgAzYCECACQQQ2Agwg -AkEoaiIJIAQoAgAiBDYCACACQSBqIAFBCGopAgA3AwAgAiABKQIANwMYIAIgCTYCuAEgAiAENgK0 -ASACIAY2ArABIAUgByACQbABahBKAkAgAikDgAEiDkICUQ0AIAJBiAFqIQRBKCEBQQEhBgNAIAJB -+ABqIgUgBEEgaikDADcDACACQfAAaiIHIARBGGopAwA3AwAgAkHoAGoiCiAEQRBqKQMANwMAIAJB -4ABqIg0gBEEIaikDADcDACACIAQpAwA3A1ggDqdBAXFFDQEgCyAFKQMANwMAIAwgBykDADcDACAC -QUBrIgcgCikDADcDACAIIA0pAwA3AwAgAiACKQNYNwMwIAIoAgwgBkYEQCACQQxqIAZBAUEIQSgQ -VyACKAIQIQMLIAEgA2oiBSACKQMwNwMAIAVBIGogCykDADcDACAFQRhqIAwpAwA3AwAgBUEQaiAH -KQMANwMAIAVBCGogCCkDADcDACACIAZBAWoiBjYCFCACKAIoIQUgAiAJNgK4ASACIAU2ArQBIAFB -KGohASACIAJBvwFqNgKwASACQYABaiACQRhqIAJBsAFqEEogAikDgAEiDkICUg0ACwsgAigCJCIB -IAIoAhwiA0cEQCABIANrQQR2IQQDQCADKAIAIgEEQCADQQRqKAIAIAEQ0QELIANBEGohAyAEQQFr -IgQNAAsLIAIoAiAiAQRAIAIoAhggAUEEdBDRAQsgACACKQIMNwIAIABBCGogAkEUaigCADYCAAwB -CyAAQQA2AgggAEKAgICAgAE3AgAgASgCDCIAIAEoAgQiA0cEQCAAIANrQQR2IQQDQCADKAIAIgAE -QCADQQRqKAIAIAAQ0QELIANBEGohAyAEQQFrIgQNAAsLIAEoAggiAEUNACABKAIAIABBBHQQ0QEL -IAJBwAFqJAAPC0EIQaABQYCSwAAQtwEAC9AIAQh/AkAgAUGACkkEQCABQQV2IQcCQAJAIAAoAqAB -IgUEQCAFQQFrIQMgBUECdCAAakEEayECIAUgB2pBAnQgAGpBBGshBiAFQSlJIQUDQCAFRQ0CIAMg -B2oiBEEoTw0DIAYgAigCADYCACAGQQRrIQYgAkEEayECIANBAWsiA0F/Rw0ACwsgAUEgSQ0DIABB -ADYCACAHQQFqIgJBAkYNAyAAQQA2AgQgAkEDRg0DIABBADYCCCACQQRGDQMgAEEANgIMIAJBBUYN -AyAAQQA2AhAgAkEGRg0DIABBADYCFCACQQdGDQMgAEEANgIYIAJBCEYNAyAAQQA2AhwgAkEJRg0D -IABBADYCICACQQpGDQMgAEEANgIkIAJBC0YNAyAAQQA2AiggAkEMRg0DIABBADYCLCACQQ1GDQMg -AEEANgIwIAJBDkYNAyAAQQA2AjQgAkEPRg0DIABBADYCOCACQRBGDQMgAEEANgI8IAJBEUYNAyAA -QQA2AkAgAkESRg0DIABBADYCRCACQRNGDQMgAEEANgJIIAJBFEYNAyAAQQA2AkwgAkEVRg0DIABB -ADYCUCACQRZGDQMgAEEANgJUIAJBF0YNAyAAQQA2AlggAkEYRg0DIABBADYCXCACQRlGDQMgAEEA -NgJgIAJBGkYNAyAAQQA2AmQgAkEbRg0DIABBADYCaCACQRxGDQMgAEEANgJsIAJBHUYNAyAAQQA2 -AnAgAkEeRg0DIABBADYCdCACQR9GDQMgAEEANgJ4IAJBIEYNAyAAQQA2AnwgAkEhRg0DIABBADYC -gAEgAkEiRg0DIABBADYChAEgAkEjRg0DIABBADYCiAEgAkEkRg0DIABBADYCjAEgAkElRg0DIABB -ADYCkAEgAkEmRg0DIABBADYClAEgAkEnRg0DIABBADYCmAEgAkEoRg0DIABBADYCnAEgAkEpRg0D -QShBKEGs/cAAEIABAAsgA0EoQaz9wAAQgAEACyAEQShBrP3AABCAAQALQdb9wABBHUGs/cAAEJcB -AAsgACgCoAEiAyAHaiECIAFBH3EiBkUEQCAAIAI2AqABIAAPCwJAIAJBAWsiBEEnTQRAIAIhBSAA -IARBAnRqKAIAQQAgAWsiAXYiBEUNASACQSdNBEAgACACQQJ0aiAENgIAIAJBAWohBQwCCyACQShB -rP3AABCAAQALIARBKEGs/cAAEIABAAsCQCAHQQFqIgggAk8NACABQR9xIQEgA0EBcUUEQCAAIAJB -AWsiAkECdGoiBCAEKAIAIAZ0IARBBGsoAgAgAXZyNgIACyADQQJGDQAgAkECdCAAakEMayEDA0Ag -A0EIaiIEIAQoAgAgBnQgA0EEaiIEKAIAIgkgAXZyNgIAIAQgCSAGdCADKAIAIAF2cjYCACADQQhr -IQMgCCACQQJrIgJJDQALCyAAIAdBAnRqIgEgASgCACAGdDYCACAAIAU2AqABIAAL/wkDDH8BfgFv -QcSEwAAhAyMAQdAAayICJAAgAiABNgIMAkACQAJAAkAgARDzAUEBRgRAIAIgATYCICACQQA2AhAg -AkHEhMAANgIYIAJB1ITAADYCHCACQSBqIQpBgICAgHghAQNAIAIgA0EIajYCGCACIAMoAgAgAygC -BBA9NgI4IAooAgAlASACQThqKAIAJQEQDSEPEHAiBSAPJgECQAJAAkACQAJAAkAgBSUBEARBAUYE -QCACKAI4JQEgAigCICUBEAVBAUcNAQsCQCACKAIQRQ0AIAIoAhQiB0GEAUkNACAHEG0LIAIgBTYC -FCACQQE2AhAgAygCACEFAn8CQAJAAkAgAygCBEEEaw4DAQIAAgtBACEHQQYhCEG8hMAAIQMCQANA -IAUtAAAiCyADLQAAIgxGBEAgBUEBaiEFIANBAWohAyAIQQFrIggNAQwCCwsgCyAMayEHCyAHDQFB -AQwCC0EAIAUoAABBuITAACgAAEYNARoLQQILIAIoAjgiBUGDAUsEQCAFEG0LQQFrDgIDAQILIAVB -hAFPBEAgBRBtCyACKAI4IgNBhAFPBEAgAxBtCyACKAIYIgMgAigCHEcNBQwHCyACKAIQIAJBADYC -EEEBRgRAIAIoAhQiA0GEAUkNBCADEG0MBAsMCQsgAUGAgICAeEcEQEHdisAAQQQQhgEhBAwCCyAC -KAIQIAJBADYCEEUNCCACIAIoAhQiAzYCOCACIAMQ7wECfyACKAIAIgYEQCACKAIEIg0MAQsgAkE4 -aiACQc8AakH8icAAEEIhBkGAgICAeAshASADQYQBTwRAIAMQbQsgAUGAgICAeEcNAiAAQYCAgIB4 -NgIAIAAgBjYCBAwGCyAJRQRAIAIoAhAgAkEANgIQQQFHDQggAiACKAIUNgIkIAJBKGoiBCACQSRq -IgMoAgAlARAeBH4gBCADKAIAJQEQCvwGNwMIQgEFQgALNwMAAn8CQCACKAIoQQFGBEAgAikDMCIO -QgBZDQELIAJBJGogAkHPAGpB3IjAABBCIQRBAQwBCyAOQoCAgIAQWgRAIAJBAToAOCACIA43A0Aj -AEEwayIDJAAgA0HciMAANgIEIAMgAkHPAGo2AgAgA0ECNgIMIANBiI/AADYCCCADQgI3AhQgAyAD -rUKAgICA8AGENwMoIAMgAkE4aq1CgICAgIAChDcDICADIANBIGo2AhAgA0EIahBjIQQgA0EwaiQA -QQEMAQsgDqchBEEACyACKAIkIgVBhAFPBEAgBRBtC0EBIQlFDQIMAQtB4YrAAEEGEIYBIQQLIABB -gICAgHg2AgAgACAENgIEIAFBgICAgHhyQYCAgIB4Rg0EIAYgARDRAQwECyACKAIYIgMgAigCHEcN -AAsMAQsgAkEMaiACQc8AakGMisAAEEIhBCAAQYCAgIB4NgIAIAAgBDYCBCABQYQBSQ0CIAEQbQwC -CyABQYCAgIB4RwRAIAkEQCAAIAQ2AgwgACANNgIIIAAgBjYCBCAAIAE2AgAMAgtB4YrAAEEGEIUB -IQQgAEGAgICAeDYCACAAIAQ2AgQgAUUNASAGIAEQ0QEMAQtB3YrAAEEEEIUBIQEgAEGAgICAeDYC -ACAAIAE2AgQLIAIoAiAiAEGEAU8EQCAAEG0LIAIoAhBFDQAgAigCFCIAQYMBTQ0AIAAQbQsgAkHQ -AGokAA8LQayKwABBMRDnAQALswsDBn8BfgFvIwBB0ABrIgIkACACIAE2AiACQAJAAkACQAJAIAJB -IGoiASgCACUBEBwEQCACQSRqIgMgASgCACUBEBA2AgggA0EANgIEIAMgATYCAEEAIQEgAkEANgIw -IAIoAiQEQCACKAIsIgMgAigCKCIETQRAQQQhAwwDC0G5gsEALQAAGkGAgAQgAyAEayIBQQAgASAD -TRsiASABQYCABE8bIgFBBHQiBEEEEMUBIgMNAkEEIARB3InAABC3AQALIAJBADYCPCACQoCAgIDA -ADcCNAwCCyACQUBrIQEQFyEJEHAiAyAJJgEgAyEFIAJBIGooAgAiBCUBIAMlARAYIQkQcCIDIAkm -AUGQg8EAKAIAIQZBjIPBACgCACEHQYyDwQBCADcCAAJAAkACQCAHQQFGBEAgAUEDOgAEIAEgBjYC -AAwBCwJAIAMQ9AFBAUYEQCADJQEgBCUBEBkhCRBwIgQgCSYBQZCDwQAoAgAhBkGMg8EAKAIAIQdB -jIPBAEIANwIAAkAgB0EBRgRAIAFBAzoABCABIAY2AgAMAQsCQCAEEPMBQQFHDQAgBCUBEBMhCRBw -IgYgCSYBIAYQ9AEgBkGEAU8EQCAGEG0LQQFHDQAgAUEAOgAEIAEgBDYCACADQYQBTwRAIAMQbQsg -BUGEAUkNBgwFCyABQQI6AAQgBEGEAUkNACAEEG0LIANBhAFPDQEMAgsgAUECOgAEIANBhAFJDQEL -IAMQbQsgBUGDAU0NAQsgBRBtCyACKAJAIQECQAJAAkAgAi0ARCIDQQJrDgICAAELIABBgICAgHg2 -AgAgACABNgIEIAIoAiAiAUGDAUsNBQwGCyACIAM6ADggAiABNgI0IAJBADYCLCACQoCAgIDAADcC -JCACQRhqIAJBNGoQewJAIAIoAhgiA0ECRwRAIAIoAhwhAQNAAkAgA0EBcUUEQCACQUBrIAEQLiAC -KAJEIQEgAigCQCIFQYCAgIB4Rw0BCyAAQYCAgIB4NgIAIAAgATYCBCACKAIsIgMEQCACKAIoIQED -QCABKAIAIgAEQCABQQRqKAIAIAAQ0QELIAFBEGohASADQQFrIgMNAAsLIAIoAiQiAARAIAIoAigg -AEEEdBDRAQsgAigCNCIBQYMBSw0DDAcLIAIpAkghCCACKAIsIgMgAigCJEYEQCACQSRqEGkLIAIo -AiggA0EEdGoiBCAINwIIIAQgATYCBCAEIAU2AgAgAiADQQFqNgIsIAJBEGogAkE0ahB7IAIoAhQh -ASACKAIQIgNBAkcNAAsLIAAgAikCJDcCACAAQQhqIAJBLGooAgA2AgAgAigCNCIBQYMBTQ0ECyAB -EG0MAwsgAkEgaiACQUBrQZyKwAAQQiEBIABBgICAgHg2AgAgACABNgIEDAILIAJBADYCPCACIAM2 -AjggAiABNgI0A0AgAkEIaiEDIAJBJGoiASgCBCIEIAEoAghPBH9BAAUgASAEQQFqNgIEIAEoAgAo -AgAlASAEEA8hCRBwIgEgCSYBQQELIQQgAyABNgIEIAMgBDYCACACKAIIQQFxRQ0BIAIoAgwhASAC -IAIoAjBBAWo2AjAgAkFAayABEC4gAigCRCEBIAIoAkAiBUGAgICAeEYEQCAAQYCAgIB4NgIAIAAg -ATYCBCACKAI8IgMEQCACKAI4IQEDQCABKAIAIgAEQCABQQRqKAIAIAAQ0QELIAFBEGohASADQQFr -IgMNAAsLIAIoAjQiAEUNAyACKAI4IABBBHQQ0QEMAwsgAikCSCEIIAIoAjwiAyACKAI0RgRAIAJB -NGoQaQsgAigCOCADQQR0aiIEIAg3AgggBCABNgIEIAQgBTYCACACIANBAWo2AjwgAigCJA0ACwsg -ACACKQI0NwIAIABBCGogAkE8aigCADYCAAsgAigCICIBQYMBTQ0BCyABEG0LIAJB0ABqJAALzwYB -CH8CQAJAIAEgAEEDakF8cSIDIABrIghJDQAgASAIayIGQQRJDQAgBkEDcSEHQQAhAQJAIAAgA0Yi -CQ0AAkAgACADayIFQXxLBEBBACEDDAELQQAhAwNAIAEgACADaiICLAAAQb9/SmogAkEBaiwAAEG/ -f0pqIAJBAmosAABBv39KaiACQQNqLAAAQb9/SmohASADQQRqIgMNAAsLIAkNACAAIANqIQIDQCAB -IAIsAABBv39KaiEBIAJBAWohAiAFQQFqIgUNAAsLIAAgCGohAAJAIAdFDQAgACAGQXxxaiIDLAAA -Qb9/SiEEIAdBAUYNACAEIAMsAAFBv39KaiEEIAdBAkYNACAEIAMsAAJBv39KaiEECyAGQQJ2IQUg -ASAEaiEEA0AgACEDIAVFDQJBwAEgBSAFQcABTxsiBkEDcSEHIAZBAnQhCEEAIQIgBUEETwRAIAAg -CEHwB3FqIQkgACEBA0AgASgCACIAQX9zQQd2IABBBnZyQYGChAhxIAJqIAFBBGooAgAiAEF/c0EH -diAAQQZ2ckGBgoQIcWogAUEIaigCACIAQX9zQQd2IABBBnZyQYGChAhxaiABQQxqKAIAIgBBf3NB -B3YgAEEGdnJBgYKECHFqIQIgAUEQaiIBIAlHDQALCyAFIAZrIQUgAyAIaiEAIAJBCHZB/4H8B3Eg -AkH/gfwHcWpBgYAEbEEQdiAEaiEEIAdFDQALAn8gAyAGQfwBcUECdGoiACgCACIBQX9zQQd2IAFB -BnZyQYGChAhxIgEgB0EBRg0AGiABIAAoAgQiAUF/c0EHdiABQQZ2ckGBgoQIcWoiASAHQQJGDQAa -IAAoAggiAEF/c0EHdiAAQQZ2ckGBgoQIcSABagsiAUEIdkH/gRxxIAFB/4H8B3FqQYGABGxBEHYg -BGoPCyABRQRAQQAPCyABQQNxIQMCQCABQQRJBEAMAQsgAUF8cSEFA0AgBCAAIAJqIgEsAABBv39K -aiABQQFqLAAAQb9/SmogAUECaiwAAEG/f0pqIAFBA2osAABBv39KaiEEIAUgAkEEaiICRw0ACwsg -A0UNACAAIAJqIQEDQCAEIAEsAABBv39KaiEEIAFBAWohASADQQFrIgMNAAsLIAQLlQgCC38DfiMA -QeAAayIEJAAgAq1CKH4iDqchAwJAIA5CIIinIANB+P///wdLcg0AAn8gA0UEQEEIIQZBAAwBC0G5 -gsEALQAAGkEIIQcgA0EIEMUBIgZFDQEgAgshCyADBEAgBiABIAP8CgAACyACQQJPBEAgBkHQAGoh -DCAEQdwAaq1CgICAgBCEIQ4gBEHYAGqtQoCAgIAghCEPA0BBACEDQQAhBQJAAkACQAJAAkACQANA -IAMhCiACIAVJDQUgBUEobCEJAkAgAiAFayIBQQNJDQBBCSABIAFBCU8bIQggCSAMaiEDQQIhAQNA -IAEgCEYEQCAIIQEMAgsgAUEBaiEBIANCBBCzASADQShqIQNCAFINAAsLIAEgBWoiCCABSQ0BIAIg -CEkNAkH8gsEAIQVB+ILBACgCAEUEQAJ/QbmCwQAtAAAaQYAIQQEQxQEiAwRAQYiDwQBBADYCAEH8 -gsEAQQA2AgBBhIPBACgCACEFQYSDwQAgAzYCAEGAg8EAKAIAIQNBgIPBAEGACDYCAEH4gsEAKAIA -QfiCwQBBATYCAEUgA0VyRQRAIAUgAxDRAQtB/ILBAAwBC0EBQYAIQcSOwAAQtwEACyEFCyAFKAIA -DQNBACEDIAVBADYCDCAFQX82AgBBACEHIAEEQCAFQQRqIQ0gBiAJaiIDIAFBKGxqIQkDQCAEIAM2 -AlggBCADQSBqIgE2AlwgBEEDNgI0IARB9IvAADYCMCAEQgI3AjwgBCAONwMQIAQgDzcDCCAEIARB -CGo2AjggDUHcj8AAIARBMGoQPA0GIAEoAgAgB2ohByABQQhqIgMgCUcNAAsgBSgCDCEDCyAEQTBq -Qdy6wAAgBSgCCCADEDQgBEHQAGoiASAHNgIAIAUgBSgCAEEBajYCACAEQRBqIgMgBEE4aikDADcD -ACAEQRhqIgUgBEFAaykDADcDACAEQSBqIgcgBEHIAGopAwA3AwAgBEEoaiIJIAEpAwA3AwAgBCAE -KQMwNwMIIAIgCksEQCAGIApBKGxqIgEgBCkDCDcDACABQSBqIAkpAwA3AwAgAUEYaiAHKQMANwMA -IAFBEGogBSkDADcDACABQQhqIAMpAwA3AwAgCkEBaiEDIAgiBSACRg0HDAELCyAKIAJB/IDAABCA -AQALIAUgCEHsgMAAENcBAAsgCCACQeyAwAAQ1gEAC0HAjcAAEI4BAAtBnIzAAEErIARBMGpBjIzA -AEGwjcAAEH0ACyAFIAJBjIHAABDVAQALIAMhAiAKDQALCyAAIAYpAwA3AwAgAEEYaiAGQRhqKQMA -NwMAIABBEGogBkEQaikDADcDACAAQQhqIAZBCGopAwA3AwAgBiALQShsENEBIARB4ABqJAAPCyAH -IANBoITAABC3AQALyQcCCn8CfiMAQTBrIgYkAAJAAkACQAJAAkACQAJAIANFDQACfyABKAIYIgcg -ASgCKCIFQUBrTQRAIAEoAhwgBWsiByADIAMgB0sbIQhBACEHIAFBHGoMAQsgASgCHCAFayIJIAMg -AyAJSxshCCAJIAMgByAFa0HBAGsiByADIAdJGyIHSQ0CIAUgB2ohBSABQRxqCyEJIAZBCGohCiAC -IAdqIQ0gCCAHayELIAEpAxAhEEEAIQggASkDACEPIAEoAgghDgNAAkAgCCALRgRAQQAhDAwBCyAB -IA4gCCANai0AAEEDdGopAwAgD0IBhnwiDzcDAEEBIQwgCEEBaiEIIA8gEINCAFINAQsLIAogCDYC -BCAKIAw2AgACQAJAIAYoAghBAXEEQCAJKAIAIgggBigCDCIEIAVqTQ0BDAILIAkoAgAiCCAFIAtq -Sw0CCyAIIAVrIQQLIAFCADcDACAEIAdqIQUgASgCKCIHRQRAIAMgBUkNAyAGQSBqIAIgBRB4DAYL -IAMgBUkNAyABQSBqIQMgASgCICAHayAFSQRAIAMgByAFEFggASgCKCEHCyAFBEAgASgCJCAHaiAC -IAX8CgAACyABIAUgB2o2AiggBkEYaiADQQhqKAIANgIAIAFBADYCKCADKQIAIQ8gAUKAgICAEDcD -ICAGIA83AxAgBkEgaiAGQRBqEHUMBQsgBEUEQCABKAIgIAEoAigiBWsgA0kEQCABQSBqIAUgAxBY -IAEoAighBQsgAwRAIAEoAiQgBWogAiAD/AoAAAsgACADNgIwIABBADYCACABIAMgBWo2AigMBgsg -ASgCKCIFRQ0DIAFBIGohBCABKAIgIAVrIANJBEAgBCAFIAMQWCABKAIoIQULIAMEQCABKAIkIAVq -IAIgA/wKAAALIAEgAyAFajYCKCAGQRhqIARBCGooAgA2AgAgAUEANgIoIAQpAgAhDyABQoCAgIAQ -NwMgIAYgDzcDECAGQSBqIAZBEGoQdSADIQUMBAsgByAIQfCWwAAQ1wEACyAFIANBgJfAABDWAQAL -IAUgA0GQl8AAENYBAAsgBkEgaiACIAMQeCADIQULIAZBGGogBkEoaikCACIPNwMAIAYgBikCIDcD -ECAPpyIBRQRAIABBADYCMCAAQQA2AgAgBkEcaiAGKAIUQQAgBigCECgCEBEDAAwBCyAGKAIQIQIg -BigCHCEDIABBEGpBvLrAACAGKAIUIgQgARA0IAAgBTYCMCAAIAM2AgwgACABNgIIIAAgBDYCBCAA -IAI2AgALIAZBMGokAAvcBQIMfwN+IwBBoAFrIgkkACAJQQBBoAH8CwACQAJAAkAgAiAAKAKgASIF -TQRAIAVBKU8NASABIAJBAnRqIQwCQAJAIAUEQCAFQQFqIQ0gBUECdCEKA0AgCSAGQQJ0aiEDA0Ag -BiECIAMhBCABIAxGDQggA0EEaiEDIAJBAWohBiABKAIAIQcgAUEEaiILIQEgB0UNAAsgB60hEUIA -IQ8gCiEHIAIhASAAIQMDQCABQShPDQQgBCAPIAQ1AgB8IAM1AgAgEX58IhA+AgAgEEIgiCEPIARB -BGohBCABQQFqIQEgA0EEaiEDIAdBBGsiBw0ACyAIIBBCgICAgBBaBH8gAiAFaiIBQShPDQMgCSAB -QQJ0aiAPPgIAIA0FIAULIAJqIgEgASAISRshCCALIQEMAAsACwNAIAEgDEYNBiAEQQFqIQQgASgC -ACABQQRqIQFFDQAgCCAEQQFrIgIgAiAISRshCAwACwALIAFBKEGs/cAAEIABAAsgAUEoQaz9wAAQ -gAEACyAFQSlPDQEgAkECdCEMIAJBAWohDSAAIAVBAnRqIQ4gACEDAkADQCAJIAdBAnRqIQYDQCAH -IQsgBiEEIAMgDkYNBSAEQQRqIQYgB0EBaiEHIAMoAgAhCiADQQRqIgUhAyAKRQ0ACyAKrSERQgAh -DyAMIQogCyEDIAEhBgNAIANBKE8NAiAEIA8gBDUCAHwgBjUCACARfnwiED4CACAQQiCIIQ8gBEEE -aiEEIANBAWohAyAGQQRqIQYgCkEEayIKDQALAkAgCCAQQoCAgIAQWgR/IAIgC2oiA0EoTw0BIAkg -A0ECdGogDz4CACANBSACCyALaiIDIAMgCEkbIQggBSEDDAELCyADQShBrP3AABCAAQALIANBKEGs -/cAAEIABAAsgBUEoQaz9wAAQ1gEACyAFQShBrP3AABDWAQALIAAgCUGgAfwKAAAgACAINgKgASAJ -QaABaiQAC+QIAgp/AX4jAEGAAmsiBCQAIAQgASkAGDcCGCAEIAEpABA3AhAgBCABKQAINwIIIAQg -ASkAADcCAAJ/IANBgQhPBEAgBEEgaiEFIwBB4ABrIgEkACABQThqIgZCADcDACABQTBqIgdCADcD -ACABQShqIghCADcDACABQSBqIglCADcDACABQRhqIgpCADcDACABQRBqIgtCADcDACABQQhqIgxC -ADcDACABQgA3AwAgAiADIARCAEEQIAFBwAAQKiEDIAFB2ABqQgA3AwAgAUHQAGpCADcDACABQcgA -akIANwMAIAFCADcDQAJAAkACQAJAIANBA08EQANAIANBBXQiAkHBAE8NAiABIAIgBEEQIAFBQGsi -DUEgEEEiA0EFdCICQcEATw0DIAJBIU8NBCACBEAgASANIAL8CgAACyADQQJLDQALCyAFIAEpAwA3 -AAAgBUE4aiAGKQMANwAAIAVBMGogBykDADcAACAFQShqIAgpAwA3AAAgBUEgaiAJKQMANwAAIAVB -GGogCikDADcAACAFQRBqIAspAwA3AAAgBUEIaiAMKQMANwAAIAFB4ABqJAAMAwsgAkHAAEGIvcAA -ENYBAAsgAkHAAEGYvcAAENYBAAsgAkEgQai9wAAQ1gEACyAEQfgAaiAEQRhqKQIANwMAIARB8ABq -IARBEGopAgA3AwAgBEHoAGogBEEIaikCADcDACAEIAQpAgA3A2BBwAAhA0EUDAELIARByAFqQgA3 -AwAgBEHAAWpCADcDACAEQbgBakIANwMAIARBsAFqQgA3AwAgBEGoAWpCADcDACAEQZgBakIANwMA -IARBEDoA+gEgBEGgAWpCADcDACAEQdgBaiIFIARBCGopAgA3AwAgBEHoAWoiBiAEQRhqKQIANwMA -IARB4AFqIgcgBEEQaikCADcDACAEQgA3A5ABIAQgBCkCADcD0AEgBEEAOwH4ASAEQgA3A/ABIARB -kAFqIAIgAxBGIQEgBEHoAGogBSkDADcDACAEQfAAaiAHKQMANwMAIARB+ABqIAYpAwA3AwAgBEEo -aiABQQhqKQMANwMAIARBMGogAUEQaikDADcDACAEQThqIAFBGGopAwA3AwAgBEFAayABQSBqKQMA -NwMAIARByABqIAFBKGopAwA3AwAgBEHQAGogAUEwaikDADcDACAEQdgAaiABQThqKQMANwMAIAQg -BCkD0AE3A2AgBCABKQMANwMgIAQpA/ABIQ4gBC0A+AEhAyAELQD6ASAELQD5AUVyQQJyCyEBIAQg -DjcDgAEgBCADOgCIASAEIAE6AIkBIARBqAFqIgIgBEH4AGopAwA3AwAgBEGgAWoiBSAEQfAAaikD -ADcDACAEQZgBaiIGIARB6ABqKQMANwMAIAQgBCkDYDcDkAEgBEGQAWogBEEgaiADQgAgAUEIchAo -IAAgAikDADcAGCAAIAUpAwA3ABAgACAGKQMANwAIIAAgBCkDkAE3AAAgBEGAAmokAAvACwEFfyMA -QSBrIgQkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABDigGAQEBAQEBAQECBAEBAwEBAQEBAQEB -AQEBAQEBAQEBAQEBCAEBAQEHAAsgAUHcAEYNBAsgAkEBcUUgAUH/BU1yDQcCfwJAQRFBACABQa+w -BE8bIgIgAkEIciIDIAFBC3QiAiADQQJ0QfiAwQBqKAIAQQt0SRsiAyADQQRyIgMgA0ECdEH4gMEA -aigCAEELdCACSxsiAyADQQJyIgMgA0ECdEH4gMEAaigCAEELdCACSxsiAyADQQFqIgMgA0ECdEH4 -gMEAaigCAEELdCACSxsiAyADQQFqIgMgA0ECdEH4gMEAaigCAEELdCACSxsiA0ECdEH4gMEAaigC -AEELdCIFIAJGIAIgBUtqIANqIgNBIU0EQCADQQJ0QfiAwQBqIgYoAgBBFXYhAkHvBSEFAn8CQCAD -QSFGDQAgBigCBEEVdiEFIAMNAEEADAELIAZBBGsoAgBB////AHELIQMCQCAFIAJBf3NqRQ0AIAEg -A2shB0HvBSACIAJB7wVNGyEGIAVBAWshA0EAIQUDQCACIAZGDQMgBSACQbTMwABqLQAAaiIFIAdL -DQEgAyACQQFqIgJHDQALIAMhAgsgAkEBcQwCCyADQSJB7PzAABCAAQALIAZB7wVB/PzAABCAAQAL -RQ0HIARBADoACiAEQQA7AQggBCABQRR2QffowABqLQAAOgALIAQgAUEEdkEPcUH36MAAai0AADoA -DyAEIAFBCHZBD3FB9+jAAGotAAA6AA4gBCABQQx2QQ9xQffowABqLQAAOgANIAQgAUEQdkEPcUH3 -6MAAai0AADoADCABQQFyZ0ECdiICIARBCGoiA2oiBUH7ADoAACAFQQFrQfUAOgAAIAMgAkECayIC -akHcADoAACAEQRBqIgMgAUEPcUH36MAAai0AADoAACAAQQo6AAsgACACOgAKIAAgBCkCCDcCACAE -Qf0AOgARIABBCGogAy8BADsBAAwJCyAAQYAEOwEKIABCADcBAiAAQdzoATsBAAwICyAAQYAEOwEK -IABCADcBAiAAQdzkATsBAAwHCyAAQYAEOwEKIABCADcBAiAAQdzcATsBAAwGCyAAQYAEOwEKIABC -ADcBAiAAQdy4ATsBAAwFCyAAQYAEOwEKIABCADcBAiAAQdzgADsBAAwECyACQYACcUUNASAAQYAE -OwEKIABCADcBAiAAQdzOADsBAAwDCyACQf///wdxQYCABE8NAQsCf0EAIAFBIEkNABpBASABQf8A -SQ0AGiABQYCABE8EQCABQeD//wBxQeDNCkcgAUH+//8AcUGe8ApHcSABQcDuCmtBeklxIAFBsJ0L -a0FySXEgAUHw1wtrQXFJcSABQYDwC2tB3mxJcSABQYCADGtBnnRJcSABQdCmDGtBe0lxIAFBgII4 -a0GwxVRJcSABQfCDOElxIAFBgIAITw0BGiABQZjxwABBLEHw8cAAQdABQcDzwABB5gMQUgwBCyAB -Qab3wABBKEH298AAQaICQZj6wABBqQIQUgtFBEAgBEEAOgAWIARBADsBFCAEIAFBFHZB9+jAAGot -AAA6ABcgBCABQQR2QQ9xQffowABqLQAAOgAbIAQgAUEIdkEPcUH36MAAai0AADoAGiAEIAFBDHZB -D3FB9+jAAGotAAA6ABkgBCABQRB2QQ9xQffowABqLQAAOgAYIAFBAXJnQQJ2IgIgBEEUaiIDaiIF -QfsAOgAAIAVBAWtB9QA6AAAgAyACQQJrIgJqQdwAOgAAIARBHGoiAyABQQ9xQffowABqLQAAOgAA -IABBCjoACyAAIAI6AAogACAEKQIUNwIAIARB/QA6AB0gAEEIaiADLwEAOwEADAILIAAgATYCBCAA -QYABOgAADAELIABBgAQ7AQogAEIANwECIABB3MQAOwEACyAEQSBqJAAL0wUCB38BfgJ/IAFFBEAg -ACgCCCEHQS0hCyAFQQFqDAELQStBgIDEACAAKAIIIgdBgICAAXEiARshCyABQRV2IAVqCyEIAkAg -B0GAgIAEcUUEQEEAIQIMAQsgA0EQTwRAIAIgAxAwIAhqIQgMAQsgA0UNACADQQNxIQoCQCADQQRJ -BEBBACEBDAELIANBDHEhDEEAIQEDQCABIAIgCWoiBiwAAEG/f0pqIAZBAWosAABBv39KaiAGQQJq -LAAAQb9/SmogBkEDaiwAAEG/f0pqIQEgDCAJQQRqIglHDQALCyAKBEAgAiAJaiEGA0AgASAGLAAA -Qb9/SmohASAGQQFqIQYgCkEBayIKDQALCyABIAhqIQgLAkAgAC8BDCIJIAhLBEACQAJAIAdBgICA -CHFFBEAgCSAIayEJQQAhAUEAIQgCQAJAAkAgB0EddkEDcUEBaw4DAAEAAgsgCSEIDAELIAlB/v8D -cUEBdiEICyAHQf///wBxIQogACgCBCEHIAAoAgAhAANAIAFB//8DcSAIQf//A3FPDQJBASEGIAFB -AWohASAAIAogBygCEBEAAEUNAAsMBAsgACAAKQIIIg2nQYCAgP95cUGwgICAAnI2AghBASEGIAAo -AgAiByAAKAIEIgogCyACIAMQmwENA0EAIQEgCSAIa0H//wNxIQIDQCABQf//A3EgAk8NAiABQQFq -IQEgB0EwIAooAhARAABFDQALDAMLQQEhBiAAIAcgCyACIAMQmwENAiAAIAQgBSAHKAIMEQEADQJB -ACEBIAkgCGtB//8DcSECA0AgAUH//wNxIgMgAkkhBiACIANNDQMgAUEBaiEBIAAgCiAHKAIQEQAA -RQ0ACwwCCyAHIAQgBSAKKAIMEQEADQEgACANNwIIQQAPC0EBIQYgACgCACIBIAAoAgQiACALIAIg -AxCbAQ0AIAEgBCAFIAAoAgwRAQAhBgsgBguKBQIGfwV+QgEhDQJAAkACQAJAIAJBwABHDQBBACEC -A0AgAkHAAEcEQCABIAJqIgMtAAAiBEEwa0H/AXFBCk8EQCAEQV9xQcEAa0H/AXFBBUsNAwsgAkEC -aiECIANBAWotAAAiA0Ewa0H/AXFBCkkgA0FfcUHBAGtB/wFxQQZJcg0BDAILCyABLAAQIgVBQEgN -ASABQRBqIQZBD0EQIAEtAABBK0YiAhshAyABIAJqIQIDQCACLQAAIgRBwQBrQV9xQQpqIARBMGsg -BEE5SxsiBEEPSw0BIAJBAWohAiAErSAJQgSGhCEJIANBAWsiAw0ACyABLAAgIgdBQEgNAiABQSBq -IQggAUERaiAGIAVBK0YiAxshAkEPQRAgAxshAwNAIAItAAAiBEHBAGtBX3FBCmogBEEwayAEQTlL -GyIEQQ9LDQEgAkEBaiECIAStIApCBIaEIQogA0EBayIDDQALIAEsADAiBUFASA0DIAFBMGohBiAB -QSFqIAggB0ErRiIDGyECQQ9BECADGyEDA0AgAi0AACIEQcEAa0FfcUEKaiAEQTBrIARBOUsbIgRB -D0sNASACQQFqIQIgBK0gC0IEhoQhCyADQQFrIgMNAAsgAUExaiAGIAVBK0YiARshAkEPQRAgARsh -AwNAIAItAAAiAUHBAGtBX3FBCmogAUEwayABQTlLGyIBQQ9LDQEgAkEBaiECIAGtIAxCBIaEIQwg -A0EBayIDDQALIAAgDDcDICAAIAs3AxggACAKNwMQIAAgCTcDCEIAIQ0LIAAgDTcDAA8LIAFBwABB -AEEQQYy6wAAQwwEACyABQcAAQRBBIEGcusAAEMMBAAsgAUHAAEEgQTBBrLrAABDDAQALhAYCAX8B -fCMAQTBrIgIkAAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAAtAABBAWsO -EQECAwQFBgcICQoLDA0ODxARAAsgAiAALQABOgAIIAJBAjYCFCACQeC+wAA2AhAgAkIBNwIcIAIg -AkEIaq1CgICAgNAHhDcDKCACIAJBKGo2AhggASgCACABKAIEIAJBEGoQPAwRCyACIAApAwg3Awgg -AkECNgIUIAJB/L7AADYCECACQgE3AhwgAiACQQhqrUKAgICA4AeENwMoIAIgAkEoajYCGCABKAIA -IAEoAgQgAkEQahA8DBALIAIgACkDCDcDCCACQQI2AhQgAkH8vsAANgIQIAJCATcCHCACIAJBCGqt -QoCAgIDwB4Q3AyggAiACQShqNgIYIAEoAgAgASgCBCACQRBqEDwMDwsgACsDCCEDIAJBAjYCFCAC -QZy/wAA2AhAgAkIBNwIcIAIgAkEoaq1CgICAgIAIhDcDCCACIAM5AyggAiACQQhqNgIYIAEoAgAg -ASgCBCACQRBqEDwMDgsgAiAAKAIENgIIIAJBAjYCFCACQbi/wAA2AhAgAkIBNwIcIAIgAkEIaq1C -gICAgJAIhDcDKCACIAJBKGo2AhggASgCACABKAIEIAJBEGoQPAwNCyACIAApAgQ3AgggAkEBNgIU -IAJB0L/AADYCECACQgE3AhwgAiACQQhqrUKAgICAoAiENwMoIAIgAkEoajYCGCABKAIAIAEoAgQg -AkEQahA8DAwLIAFBzL7AAEEKEMEBDAsLIAFB2L/AAEEKEMEBDAoLIAFB4r/AAEEMEMEBDAkLIAFB -7r/AAEEOEMEBDAgLIAFB/L/AAEEIEMEBDAcLIAFBhMDAAEEDEMEBDAYLIAFBh8DAAEEEEMEBDAUL -IAFBi8DAAEEMEMEBDAQLIAFBl8DAAEEPEMEBDAMLIAFBpsDAAEENEMEBDAILIAFBs8DAAEEOEMEB -DAELIAEgACgCBCAAKAIIEMEBCyACQTBqJAAL/gUBBX8gAEEIayIBIABBBGsoAgAiA0F4cSIAaiEC -AkACQCADQQFxDQAgA0ECcUUNASABKAIAIgMgAGohACABIANrIgFB0IbBACgCAEYEQCACKAIEQQNx -QQNHDQFByIbBACAANgIAIAIgAigCBEF+cTYCBCABIABBAXI2AgQgAiAANgIADwsgASADEE0LAkAC -QAJAAkACQCACKAIEIgNBAnFFBEAgAkHUhsEAKAIARg0CIAJB0IbBACgCAEYNAyACIANBeHEiAhBN -IAEgACACaiIAQQFyNgIEIAAgAWogADYCACABQdCGwQAoAgBHDQFByIbBACAANgIADwsgAiADQX5x -NgIEIAEgAEEBcjYCBCAAIAFqIAA2AgALIABBgAJJDQIgASAAEFVBACEBQeiGwQBB6IbBACgCAEEB -ayIANgIAIAANBEGwhMEAKAIAIgAEQANAIAFBAWohASAAKAIIIgANAAsLQeiGwQBB/x8gASABQf8f -TRs2AgAPC0HUhsEAIAE2AgBBzIbBAEHMhsEAKAIAIABqIgA2AgAgASAAQQFyNgIEQdCGwQAoAgAg -AUYEQEHIhsEAQQA2AgBB0IbBAEEANgIACyAAQeCGwQAoAgAiA00NA0HUhsEAKAIAIgJFDQNBACEA -QcyGwQAoAgAiBEEpSQ0CQaiEwQAhAQNAIAIgASgCACIFTwRAIAIgBSABKAIEakkNBAsgASgCCCEB -DAALAAtB0IbBACABNgIAQciGwQBByIbBACgCACAAaiIANgIAIAEgAEEBcjYCBCAAIAFqIAA2AgAP -CyAAQfgBcUG4hMEAaiECAn9BwIbBACgCACIDQQEgAEEDdnQiAHFFBEBBwIbBACAAIANyNgIAIAIM -AQsgAigCCAshACACIAE2AgggACABNgIMIAEgAjYCDCABIAA2AggPC0GwhMEAKAIAIgEEQANAIABB -AWohACABKAIIIgENAAsLQeiGwQBB/x8gACAAQf8fTRs2AgAgAyAETw0AQeCGwQBBfzYCAAsL4QQB -Bn8CQAJAIAAoAggiB0GAgIDAAXFFDQACQAJAIAdBgICAgAFxRQRAIAJBEEkNASABIAIQMCEDDAIL -AkACQCAALwEOIgNFBEBBACECDAELIAEgAmohCEEAIQIgAyEFIAEhBANAIAQiBiAIRg0CAn8gBkEB -aiAGLAAAIgRBAE4NABogBkECaiAEQWBJDQAaIAZBA2ogBEFwSQ0AGiAGQQRqCyIEIAZrIAJqIQIg -BUEBayIFDQALC0EAIQULIAMgBWshAwwBCyACRQRAQQAhAgwBCyACQQNxIQYCQCACQQRJBEAMAQsg -AkEMcSEIA0AgAyABIAVqIgQsAABBv39KaiAEQQFqLAAAQb9/SmogBEECaiwAAEG/f0pqIARBA2os -AABBv39KaiEDIAggBUEEaiIFRw0ACwsgBkUNACABIAVqIQQDQCADIAQsAABBv39KaiEDIARBAWoh -BCAGQQFrIgYNAAsLIAMgAC8BDCIETw0AIAQgA2shBkEAIQNBACEFAkACQAJAIAdBHXZBA3FBAWsO -AgABAgsgBiEFDAELIAZB/v8DcUEBdiEFCyAHQf///wBxIQggACgCBCEHIAAoAgAhAANAIANB//8D -cSAFQf//A3FJBEBBASEEIANBAWohAyAAIAggBygCEBEAAEUNAQwDCwtBASEEIAAgASACIAcoAgwR -AQANAUEAIQMgBiAFa0H//wNxIQEDQCADQf//A3EiAiABSSEEIAEgAk0NAiADQQFqIQMgACAIIAco -AhARAABFDQALDAELIAAoAgAgASACIAAoAgQoAgwRAQAhBAsgBAueBAEEfyMAQYABayIEJAACQAJA -AkAgASgCCCICQYCAgBBxRQRAIAJBgICAIHENAUEBIQIgACgCACABEExFDQIMAwsgACgCACECA0Ag -AyAEakH/AGogAkEPcSIFQTByIAVB1wBqIAVBCkkbOgAAIANBAWshAyACQRBJIAJBBHYhAkUNAAtB -ASECIAFBAUH268AAQQIgAyAEakGAAWpBACADaxA2RQ0BDAILIAAoAgAhAgNAIAMgBGpB/wBqIAJB -D3EiBUEwciAFQTdqIAVBCkkbOgAAIANBAWshAyACQQ9LIAJBBHYhAg0AC0EBIQIgAUEBQfbrwABB -AiADIARqQYABakEAIANrEDYNAQsgASgCAEH16MAAQQIgASgCBCgCDBEBAA0AAkAgASgCCCICQYCA -gBBxRQRAIAJBgICAIHENASAAKAIEIAEQTCECDAILIAAoAgQhAkEAIQMDQCADIARqQf8AaiACQQ9x -IgBBMHIgAEHXAGogAEEKSRs6AAAgA0EBayEDIAJBD0sgAkEEdiECDQALIAFBAUH268AAQQIgAyAE -akGAAWpBACADaxA2IQIMAQsgACgCBCECQQAhAwNAIAMgBGpB/wBqIAJBD3EiAEEwciAAQTdqIABB -CkkbOgAAIANBAWshAyACQQ9LIAJBBHYhAg0ACyABQQFB9uvAAEECIAMgBGpBgAFqQQAgA2sQNiEC -CyAEQYABaiQAIAILvQQBCH8jAEEQayIDJAAgAyABNgIEIAMgADYCACADQqCAgIAONwIIAn8CQAJA -AkAgAigCECIJBEAgAigCFCIADQEMAgsgAigCDCIARQ0BIAIoAggiASAAQQN0aiEEIABBAWtB//// -/wFxQQFqIQYgAigCACEAA0ACQCAAQQRqKAIAIgVFDQAgAygCACAAKAIAIAUgAygCBCgCDBEBAEUN -AEEBDAULQQEgASgCACADIAFBBGooAgARAAANBBogAEEIaiEAIAQgAUEIaiIBRw0ACwwCCyAAQRhs -IQogAEEBa0H/////AXFBAWohBiACKAIIIQQgAigCACEAA0ACQCAAQQRqKAIAIgFFDQAgAygCACAA -KAIAIAEgAygCBCgCDBEBAEUNAEEBDAQLQQAhB0EAIQgCQAJAAkAgBSAJaiIBQQhqLwEAQQFrDgIB -AgALIAFBCmovAQAhCAwBCyAEIAFBDGooAgBBA3RqLwEEIQgLAkACQAJAIAEvAQBBAWsOAgECAAsg -AUECai8BACEHDAELIAQgAUEEaigCAEEDdGovAQQhBwsgAyAHOwEOIAMgCDsBDCADIAFBFGooAgA2 -AghBASAEIAFBEGooAgBBA3RqIgEoAgAgAyABQQRqKAIAEQAADQMaIABBCGohACAFQRhqIgUgCkcN -AAsMAQsLAkAgBiACKAIETw0AIAMoAgAgAigCACAGQQN0aiIAKAIAIAAoAgQgAygCBCgCDBEBAEUN -AEEBDAELQQALIANBEGokAAuvFQIWfwN+IwBBEGsiFSQAQbyCwQAoAgBFBEBBvILBACgCACEEQbyC -wQBCATcCAEHIgsEAKAIAIQpBxILBACgCACECQcSCwQBB0JTAACkCADcCAEHQgsEAKAIAIQVBzILB -AEHYlMAAKQIANwIAAkAgBEUgCkVyDQAgBQRAIAJBCGohCCACKQMAQn+FQoCBgoSIkKDAgH+DIRgg -AiEEA0AgGFAEQANAIARB4ABrIQQgCCkDACAIQQhqIQhCgIGChIiQoMCAf4MiGEKAgYKEiJCgwIB/ -UQ0ACyAYQoCBgoSIkKDAgH+FIRgLIAQgGHqnQQN2QXRsakEEaygCACIDQYQBTwRAIAMQbQsgGEIB -fSAYgyEYIAVBAWsiBQ0ACwsgCiAKQQxsQRNqQXhxIgNqQQlqIgRFDQAgAiADayAEENEBCwsCQAJA -QcCCwQAoAgBFBEBBwILBAEF/NgIAQciCwQAoAgAiAyAAcSEFIABBGXYiFq1CgYKEiJCgwIABfiEZ -QcSCwQAoAgAhAgNAIAIgBWopAAAiGiAZhSIYQn+FIBhCgYKEiJCgwIABfYNCgIGChIiQoMCAf4Mi -GFBFBEADQCAAIAIgGHqnQQN2IAVqIANxQXRsaiIEQQxrKAIARgRAIARBCGsoAgAgAUYNBgsgGEIB -fSAYgyIYUEUNAAsLIBogGkIBhoNCgIGChIiQoMCAf4NQRQ0CIAUgB0EIaiIHaiADcSEFDAALAAtB -tJTAABCOAQALQcyCwQAoAgBFBEAgFUEIaiEXIwBBIGsiDyQAAkACQEHQgsEAKAIAIghBAWoiBCAI -TwRAAkBByILBACgCACILIAtBAWoiDUEDdiICQQdsIAtBCEkbIhJBAXYgBEkEQCASQQFqIgIgBCAC -IARLGyICQQhJDQEgAkH/////AU0EQEF/IAJBA3RBB25BAWtndkEBaiEEDAQLEJABIA8oAhwhBCAP -KAIYIQIMBAtBACEEQcSCwQAoAgAhCQJAIAIgDUEHcUEAR2oiA0UNACADQQFHBEAgA0H+////A3Eh -AgNAIAQgCWoiByAHKQMAIhhCf4VCB4hCgYKEiJCgwIABgyAYQv/+/fv379+//wCEfDcDACAHQQhq -IgcgBykDACIYQn+FQgeIQoGChIiQoMCAAYMgGEL//v379+/fv/8AhHw3AwAgBEEQaiEEIAJBAmsi -Ag0ACwsgA0EBcUUNACAEIAlqIgQgBCkDACIYQn+FQgeIQoGChIiQoMCAAYMgGEL//v379+/fv/8A -hHw3AwALAkACQCANQQhPBEAgCSANaiAJKQAANwAADAELIA0EQCAJQQhqIAkgDfwKAAALIA1FDQEL -IAlBCGohECAJQQxrIRNBASECQQAhBANAIAQhByACIQQCQCAHIAlqIhQtAABBgAFHDQAgEyAHQXRs -aiEGAkADQCAGKAIAIgIgBigCBCACGyIKIAtxIgUhAiAFIAlqKQAAQoCBgoSIkKDAgH+DIhlQBEBB -CCEDA0AgAiADaiECIANBCGohAyAJIAIgC3EiAmopAABCgIGChIiQoMCAf4MiGVANAAsLIAkgGXqn -QQN2IAJqIAtxIgJqLAAAQQBOBEAgCSkDAEKAgYKEiJCgwIB/g3qnQQN2IQILIAIgBWsgByAFa3Mg -C3FBCEkNASACIAlqIgMtAAAgAyAKQRl2IgM6AAAgECACQQhrIAtxaiADOgAAIBMgAkF0bGohA0H/ -AUcEQCAGLQAAIQIgBiADLQAAOgAAIAMgAjoAACAGLQABIQIgBiADLQABOgABIAMgAjoAASAGLQAC -IQIgBiADLQACOgACIAMgAjoAAiAGLQADIQIgBiADLQADOgADIAMgAjoAAyAGLQAEIQIgBiADLQAE -OgAEIAMgAjoABCAGLQAFIQIgBiADLQAFOgAFIAMgAjoABSAGLQAGIQIgBiADLQAGOgAGIAMgAjoA -BiAGLQAHIQIgBiADLQAHOgAHIAMgAjoAByAGLQAIIQIgBiADLQAIOgAIIAMgAjoACCAGLQAJIQIg -BiADLQAJOgAJIAMgAjoACSAGLQAKIQIgBiADLQAKOgAKIAMgAjoACiAGLQALIQIgBiADLQALOgAL -IAMgAjoACwwBCwsgFEH/AToAACAQIAdBCGsgC3FqQf8BOgAAIANBCGogBkEIaigAADYAACADIAYp -AAA3AAAMAQsgFCAKQRl2IgI6AAAgECAHQQhrIAtxaiACOgAACyAEIAQgDUkiB2ohAiAHDQALC0HM -gsEAIBIgCGs2AgBBgYCAgHghAgwDC0EEQQggAkEESRshBAwBCxCQASAPKAIEIQQgDygCACECDAEL -AkACQCAErUIMfiIYQiCIpw0AIBinIgJBeEsNACACQQdqQXhxIgMgBEEIaiIHaiIFIANJIAVB+P// -/wdLcg0AQbmCwQAtAAAaIAVBCBDFASICDQFBCCAFEOwBAAsQkAEgDygCDCEEIA8oAgghAgwBCyAC -IANqIQwgBwRAIAxB/wEgB/wLAAsgBEEBayIRIARBA3ZBB2wgBEEJSRshEEHEgsEAKAIAIQMgCARA -IAxBDGshEiAMQQhqIRMgA0EMayEJIAMpAwBCf4VCgIGChIiQoMCAf4MhGSADIQJBACEEIAghBwNA -IBlQBEADQCAEQQhqIQQgAkEIaiICKQMAQoCBgoSIkKDAgH+DIhhCgIGChIiQoMCAf1ENAAsgGEKA -gYKEiJCgwIB/hSEZCyAMIAkgGXqnQQN2IARqIhRBdGxqIgooAgAiBSAKKAIEIAUbIgogEXEiDmop -AABCgIGChIiQoMCAf4MiGFAEQEEIIQYDQCAGIA5qIQUgBkEIaiEGIAwgBSARcSIOaikAAEKAgYKE -iJCgwIB/gyIYUA0ACwsgGUIBfSAZgyEZIAwgGHqnQQN2IA5qIBFxIg5qLAAAQQBOBEAgDCkDAEKA -gYKEiJCgwIB/g3qnQQN2IQ4LIAwgDmogCkEZdiIFOgAAIBMgDkEIayARcWogBToAACASIA5BdGxq -IgpBCGogCSAUQXRsaiIFQQhqKAAANgAAIAogBSkAADcAACAHQQFrIgcNAAsLQciCwQAgETYCAEHE -gsEAIAw2AgBBzILBACAQIAhrNgIAQYGAgIB4IQIgC0UNACALIA1BDGxBB2pBeHEiBGpBCWoiB0UN -ACADIARrIAcQ0QELIBcgAjYCACAXIAQ2AgQgD0EgaiQACyAAIAEQugEhB0HEgsEAKAIAIghByILB -ACgCACIEIABxIgVqKQAAQoCBgoSIkKDAgH+DIhhQBEBBCCEDA0AgAyAFaiECIANBCGohAyAIIAIg -BHEiBWopAABCgIGChIiQoMCAf4MiGFANAAsLIAggGHqnQQN2IAVqIARxIgVqLAAAIgNBAE4EQCAI -IAgpAwBCgIGChIiQoMCAf4N6p0EDdiIFai0AACEDCyAFIAhqIBY6AAAgCCAFQQhrIARxakEIaiAW -OgAAQcyCwQBBzILBACgCACADQQFxazYCAEHQgsEAQdCCwQAoAgBBAWo2AgAgCCAFQXRsaiIEQQRr -IAc2AgAgBEEIayABNgIAIARBDGsgADYCAAsgBEEEaygCACEBEHAiACABJQEmAUHAgsEAQcCCwQAo -AgBBAWo2AgAgFUEQaiQAIAALlQQBDH8gAUEBayEOIAAoAgQhCiAAKAIAIQsgACgCCCEMAkADQCAF -DQECfwJAIAIgA0kNAANAIAEgA2ohBQJAAkACQCACIANrIgdBB00EQCACIANHDQEgAiEDDAULAkAg -BUEDakF8cSIGIAVrIgQEQEEAIQADQCAAIAVqLQAAQQpGDQUgBCAAQQFqIgBHDQALIAQgB0EIayIA -TQ0BDAMLIAdBCGshAAsDQEGAgoQIIAYoAgAiCUGKlKjQAHNrIAlyQYCChAggBkEEaigCACIJQYqU -qNAAc2sgCXJxQYCBgoR4cUGAgYKEeEcNAiAGQQhqIQYgBEEIaiIEIABNDQALDAELQQAhAANAIAAg -BWotAABBCkYNAiAHIABBAWoiAEcNAAsgAiEDDAMLIAQgB0YEQCACIQMMAwsDQCAEIAVqLQAAQQpG -BEAgBCEADAILIAcgBEEBaiIERw0ACyACIQMMAgsgACADaiIGQQFqIQMCQCACIAZNDQAgACAFai0A -AEEKRw0AQQAhBSADIQYgAwwDCyACIANPDQALCyACIAhGDQJBASEFIAghBiACCyEAAkAgDC0AAARA -IAtB7OvAAEEEIAooAgwRAQANAQtBACEEIAAgCEcEQCAAIA5qLQAAQQpGIQQLIAAgCGshACABIAhq -IQcgDCAEOgAAIAYhCCALIAcgACAKKAIMEQEARQ0BCwtBASENCyANC8oEAgd/AX4jAEEQayIGJAAC -QCAALwEMIgVFBEAgACgCACAAKAIEIAEQQCECDAELIAYgASgCDCIENgIMIAYgASgCCCICNgIIIAYg -ASgCBCIDNgIEIAYgASgCACIBNgIAAkAgACkCCCIJpyIHQYCAgAhxBEAgACgCACABIAMgACgCBCgC -DBEBAA0BIAAgB0GAgID/eXFBsICAgAJyIgc2AgggBkIBNwIAIAUgA0H//wNxayIBQQAgASAFTRsh -BUEAIQMLIAQEQCAEQQxsIQgDQAJ/AkACQAJAIAIvAQBBAWsOAgIBAAsgAkEEaigCAAwCCyACQQhq -KAIADAELIAJBAmovAQAiBEHoB08EQEEEQQUgBEGQzgBJGwwBC0EBIARBCkkNABpBAkEDIARB5ABJ -GwsgAkEMaiECIANqIQMgCEEMayIIDQALCwJAAkAgBUH//wNxIANLBEAgBSADayEDQQAhAkEAIQEC -QAJAAkAgB0EddkEDcUEBaw4DAAEAAgsgAyEBDAELIANB/v8DcUEBdiEBCyAHQf///wBxIQggACgC -BCEHIAAoAgAhBANAIAJB//8DcSABQf//A3FPDQIgAkEBaiECIAQgCCAHKAIQEQAARQ0ACwwDCyAA -KAIAIAAoAgQgBhBAIQIMAQsgBCAHIAYQQA0BQQAhBSADIAFrQf//A3EhAQNAIAVB//8DcSIDIAFJ -IQIgASADTQ0BIAVBAWohBSAEIAggBygCEBEAAEUNAAsLIAAgCTcCCAwBC0EBIQILIAZBEGokACAC -C/4DAQl/IwBBEGsiBCQAAn8CQCACKAIEIgNFDQAgACACKAIAIAMgASgCDBEBAEUNAEEBDAELIAIo -AgwiBgRAIAIoAggiAyAGQQxsaiEIIARBDGohCQNAAkACQAJAAkAgAy8BAEEBaw4CAgEACwJAIAMo -AgQiAkHBAE8EQCABQQxqKAIAIQYDQEEBIABBwO3AAEHAACAGEQEADQgaIAJBQGoiAkHAAEsNAAsM -AQsgAkUNAwsgAEHA7cAAIAIgAUEMaigCABEBAEUNAkEBDAULIAAgAygCBCADKAIIIAFBDGooAgAR -AQBFDQFBAQwECyADLwECIQIgCUEAOgAAIARBADYCCAJ/QQRBBSACQZDOAEkbIAJB6AdPDQAaQQEg -AkEKSQ0AGkECQQMgAkHkAEkbCyIGIARBCGoiCmoiB0EBayIFIAIgAkEKbiILQQpsa0EwcjoAAAJA -IAUgCkYNACAHQQJrIgUgC0EKcEEwcjoAACAEQQhqIAVGDQAgB0EDayIFIAJB5ABuQQpwQTByOgAA -IARBCGogBUYNACAHQQRrIgUgAkHoB25BCnBBMHI6AAAgBEEIaiAFRg0AIAdBBWsgAkGQzgBuQTBy -OgAACyAAIARBCGogBiABQQxqKAIAEQEARQ0AQQEMAwsgA0EMaiIDIAhHDQALC0EACyAEQRBqJAAL -zAQBCn8jAEEwayIGJAACQAJAAkACf0EAIAFBQHEiCkUNABogBkEIaiAANgIAQQEgCkHAAEYNABog -BiAAQUBrNgIMIApBgAFHDQFBAgshByABQT9xIQEgBUEFdiIJIAcgByAJSxsiCARAIAZBCGohCSAD -QQRyIQsgCEEFdCEMQQAhAwNAIAkoAgAhCCAGQShqIg0gAkEYaikCADcDACAGQSBqIg4gAkEQaikC -ADcDACAGQRhqIg8gAkEIaikCADcDACAGIAIpAgA3AxAgBkEQaiAIQcAAQgAgCxAoIAMgBGoiCEEY -aiANKQMANwAAIAhBEGogDikDADcAACAIQQhqIA8pAwA3AAAgCCAGKQMQNwAAIAlBBGohCSAMIANB -IGoiA0cNAAsLAkAgAQRAIAUgB0EFdCICSQ0BIAUgAmsiA0EfTQ0DIAFBIEcNBCACIARqIgEgACAK -aiIAKQAANwAAIAFBGGogAEEYaikAADcAACABQRBqIABBEGopAAA3AAAgAUEIaiAAQQhqKQAANwAA -IAdBAWohBwsgBkEwaiQAIAcPCyACIAVBuLzAABDVAQALIAYgAEGAAWo2AhBB8L3AAEErIAZBEGpB -nL7AAEHIvMAAEH0AC0EgIANBmLzAABDWAQALIwBBMGsiACQAIABBIDYCBCAAIAE2AgAgAEEDNgIM -IABB4IDBADYCCCAAQgI3AhQgACAAQQRqrUKAgICAkAmENwMoIAAgAK1CgICAgJAJhDcDICAAIABB -IGo2AhAgAEEIakGovMAAEKMBAAuEBAIHfwF8IwBB0ABrIgMkAAJAAkACQAJAAkAgACgCACIEJQFB -gQElARAHRQRAIAQlARAIDgICAQMLIANBBzoAMCADQTBqIAEgAhB/IQAMBAtBASEGC0EBIQdBACEA -DAELIANBEGogBCUBEAkgAygCEARAIAMrAxghCkEDIQBBASEHDAELIANBCGogBBDvAQJ/IAMoAggi -BARAIAMoAgwiBSEGQQUMAQsCQAJAIAAoAgAlARAjBEAgA0EwaiAAEHYgAygCOCEGIAMoAjQhBCAD -KAIwIQgMAQsgACgCACUBEB1FDQEgAyAAKAIAELwBIgU2AkggA0EwaiADQcgAahB2IAMoAjghBiAD -KAI0IQQgAygCMCEIIAVBhAFJDQAgBRBtCyAIQYCAgIB4Rg0AQQEhB0EGDAELIANBATYCNCADQcCT -wAA2AjAgA0IBNwI8IAMgAK1CgICAgPAChDcDSCADIANByABqNgI4IANBJGogA0EwahBHQYCAgIB4 -IQggAygCLCEGIAMoAighBCADKAIkIQVBEQshACAGrb8hCiAHIQkLIAMgCjkDOCADIAQ2AjQgAyAG -OgAxIAMgADoAMCADQTBqIAEgAhB/IQACQCAJRQRAIAcgBUVyRQ0BDAILIAgEQCAEIAgQ0QELIAVF -IAdyDQELIAQgBRDRAQsgA0HQAGokACAAC+QDAQV/IwBBEGsiCCQAAkACQAJAAkACQCABKAIIQQFG -BEAgASgCACEFIAEoAgQhBCABQQwQ0QFBHUGBASAEQQp2Z0ECdGsgBEH//wdLGyEGIAIgBWsiByAD -aiEDIAIgBUYEQCAGIQEMBgsgBkEFdiICIAdqIgFBgICAwABPBEBBuYLBAC0AABpBFEEEEMUBIgFF -DQIgAUEBNgIQIAEgAiADajYCCCABIAUgAms2AgQgASACIARqNgIAIAEgBkECdkEHcTYCDAwFCyAG -QR1xIAFBBXRyIQEMBAsgA0EASA0BAkAgA0UEQEEBIQUMAQtBuYLBAC0AABpBASEEIANBARDFASIF -RQ0CCyADBEAgBSACIAP8CgAACyABIAEoAggiAkEBazYCCCACQQFGBEAgASgCACABQQRqKAIAIgRB -ARC4AUUNAyAEENEBIAFBDBDRAQtBHUGBASADQQp2Z0ECdGsgA0H//wdLGyEBIAMhBAwEC0EEQRQQ -7AEACyAEIANBuLXAABC3AQALQfS2wABBKyAIQQ9qQeS2wABBsLfAABB9AAsgAyAHayICQQAgAiAD -TRshAyAEIAdrIQQgBSAHaiEFCyAAIAE2AgwgACAENgIIIAAgAzYCBCAAIAU2AgAgCEEQaiQAC/kD -AQJ/IAAgAWohAgJAAkAgACgCBCIDQQFxDQAgA0ECcUUNASAAKAIAIgMgAWohASAAIANrIgBB0IbB -ACgCAEYEQCACKAIEQQNxQQNHDQFByIbBACABNgIAIAIgAigCBEF+cTYCBCAAIAFBAXI2AgQgAiAB -NgIADAILIAAgAxBNCwJAAkACQCACKAIEIgNBAnFFBEAgAkHUhsEAKAIARg0CIAJB0IbBACgCAEYN -AyACIANBeHEiAhBNIAAgASACaiIBQQFyNgIEIAAgAWogATYCACAAQdCGwQAoAgBHDQFByIbBACAB -NgIADwsgAiADQX5xNgIEIAAgAUEBcjYCBCAAIAFqIAE2AgALIAFBgAJPBEAgACABEFUPCyABQfgB -cUG4hMEAaiECAn9BwIbBACgCACIDQQEgAUEDdnQiAXFFBEBBwIbBACABIANyNgIAIAIMAQsgAigC -CAshASACIAA2AgggASAANgIMIAAgAjYCDCAAIAE2AggPC0HUhsEAIAA2AgBBzIbBAEHMhsEAKAIA -IAFqIgE2AgAgACABQQFyNgIEIABB0IbBACgCAEcNAUHIhsEAQQA2AgBB0IbBAEEANgIADwtB0IbB -ACAANgIAQciGwQBByIbBACgCACABaiIBNgIAIAAgAUEBcjYCBCAAIAFqIAE2AgALC44DAQR/AkAC -QAJAAkACQCAHIAhWBEAgByAIfSAIWA0BAkAgBiAHIAZ9VCAHIAZCAYZ9IAhCAYZacUUEQCAGIAhW -DQEMBwsgAiADSQ0DDAULIAcgBiAIfSIGfSAGVg0FIAIgA0kNAyABIANqIQwgASEKAkACQANAIAMg -CUYNASAJQQFqIQkgCkEBayIKIANqIgstAABBOUYNAAsgCyALLQAAQQFqOgAAIAMgCWtBAWogA08N -ASAJQQFrIgVFDQEgC0EBakEwIAX8CwAMAQsCQCADRQRAQTEhCQwBCyABQTE6AAAgA0EBRgRAQTAh -CQwBC0EwIQkgA0EBayIKRQ0AIAFBAWpBMCAK/AsACyAEQQFqwSIEIAXBTCACIANNcg0AIAwgCToA -ACADQQFqIQMLIAIgA08NBCADIAJB+ObAABDWAQALIABBADYCAA8LIABBADYCAA8LIAMgAkGI58AA -ENYBAAsgAyACQejmwAAQ1gEACyAAIAQ7AQggACADNgIEIAAgATYCAA8LIABBADYCAAunAwECfwJA -AkACQAJAIAAtAGgiAwRAIANBwQBPDQMgAkHAACADayIEIAIgBEkbIgQEQCAAIANqIAEgBPwKAAAL -IAAgAC0AaCAEaiIDOgBoIAEgBGohASACIARrIgJFBEBBACECDAILIABBQGsgAEHAACAAKQNgIAAt -AGogAC0AaUVyECggAEIANwMAIABBADoAaCAAQQhqQgA3AwAgAEEQakIANwMAIABBGGpCADcDACAA -QSBqQgA3AwAgAEEoakIANwMAIABBMGpCADcDACAAQThqQgA3AwAgACAALQBpQQFqOgBpC0EAIQMg -AkHBAEkNASAAQUBrIQQgAC0AaSEDA0AgBCABQcAAIAApA2AgAC0AaiADQf8BcUVyECggACAALQBp -QQFqIgM6AGkgAUFAayEBIAJBQGoiAkHAAEsNAAsgAC0AaCEDCyADQf8BcSIDQcEATw0CCyACQcAA -IANrIgQgAiAESRsiAgRAIAAgA2ogASAC/AoAAAsgACAALQBoIAJqOgBoIAAPCyADQcAAQfi7wAAQ -1QEACyADQcAAQfi7wAAQ1QEAC48DAQd/IwBBEGsiBCQAAkACQAJAAkAgASgCBCICBEAgASgCACEH -IAJBA3EhBQJAIAJBBEkEQEEAIQIMAQsgB0EcaiEDIAJBfHEhCEEAIQIDQCADKAIAIANBCGsoAgAg -A0EQaygCACADQRhrKAIAIAJqampqIQIgA0EgaiEDIAggBkEEaiIGRw0ACwsgBQRAIAZBA3QgB2pB -BGohAwNAIAMoAgAgAmohAiADQQhqIQMgBUEBayIFDQALCyABKAIMRQ0CIAJBD0sNASAHKAIEDQEM -AwtBACECIAEoAgxFDQILIAJBACACQQBKG0EBdCECC0EAIQUgAkEATgRAIAJFDQFBuYLBAC0AABpB -ASEFIAJBARDFASIDDQILIAUgAkGEy8AAELcBAAtBASEDQQAhAgsgBEEANgIIIAQgAzYCBCAEIAI2 -AgAgBEGEysAAIAEQPEUEQCAAIAQpAgA3AgAgAEEIaiAEQQhqKAIANgIAIARBEGokAA8LQaTLwABB -1gAgBEEPakGUy8AAQZTMwAAQfQAL5wIBBX8CQCABQc3/e0EQIAAgAEEQTRsiAGtPDQAgAEEQIAFB -C2pBeHEgAUELSRsiBGpBDGoQKSICRQ0AIAJBCGshAQJAIABBAWsiAyACcUUEQCABIQAMAQsgAkEE -ayIFKAIAIgZBeHEgAiADakEAIABrcUEIayICIABBACACIAFrQRBNG2oiACABayICayEDIAZBA3EE -QCAAIAMgACgCBEEBcXJBAnI2AgQgACADaiIDIAMoAgRBAXI2AgQgBSACIAUoAgBBAXFyQQJyNgIA -IAEgAmoiAyADKAIEQQFyNgIEIAEgAhBEDAELIAEoAgAhASAAIAM2AgQgACABIAJqNgIACwJAIAAo -AgQiAUEDcUUNACABQXhxIgIgBEEQak0NACAAIAQgAUEBcXJBAnI2AgQgACAEaiIBIAIgBGsiBEED -cjYCBCAAIAJqIgIgAigCBEEBcjYCBCABIAQQRAsgAEEIaiEDCyADC+oCAgZ/An4jAEEgayIFJABB -FCEDIAAiCULoB1oEQCAJIQoDQCAFQQxqIANqIgRBA2sgCiAKQpDOAIAiCUKQzgB+faciBkH//wNx -QeQAbiIHQQF0IghB+evAAGotAAA6AAAgBEEEayAIQfjrwABqLQAAOgAAIARBAWsgBiAHQeQAbGtB -//8DcUEBdCIGQfnrwABqLQAAOgAAIARBAmsgBkH468AAai0AADoAACADQQRrIQMgCkL/rOIEViAJ -IQoNAAsLIAlCCVYEQCADIAVqQQtqIAmnIgQgBEH//wNxQeQAbiIEQeQAbGtB//8DcUEBdCIGQfnr -wABqLQAAOgAAIANBAmsiAyAFQQxqaiAGQfjrwABqLQAAOgAAIAStIQkLIABQRSAJUHFFBEAgA0EB -ayIDIAVBDGpqIAmnQQF0QR5xQfnrwABqLQAAOgAACyACIAFBAUEAIAVBDGogA2pBFCADaxA2IAVB -IGokAAvQAgEEfyMAQfAAayIDJAACQCAAAn4CQCABKAIEIgQgASgCDEcEQCABIARBEGo2AgQgBCgC -DCEFIAQoAgAhASACKAIEIANByABqIAQoAgQiBiAEKAIIEDcgAygCSCIERQRAIANBQGsgA0HoAGop -AwA3AwAgA0E4aiADQeAAaikDADcDACADQTBqIANB2ABqKQMANwMAIAMgAykDUDcDKAsgAQRAIAYg -ARDRAQsgBEEBcUUNAUEBOgAAQgAMAgsgAEICNwMADAILIANBIGogA0FAaykDADcDACADQRhqIANB -OGopAwA3AwAgA0EQaiADQTBqKQMANwMAIAMgAykDKDcDCEIBCzcDACAAIAMpAwg3AwggACAFNgIo -IABBEGogA0EQaikDADcDACAAQRhqIANBGGopAwA3AwAgAEEgaiADQSBqKQMANwMACyADQfAAaiQA -C9wIAQh/IwBBgAFrIgIkACACQQhqIQQjAEEgayIDJAAgAyAAaSIBNgIcAkACQAJAAkACQAJAIAFB -AUYEQCAAQcAATQ0BIANB3ILBADYCGEHggsEALQAAQQNHBH8gAyADQRhqNgIcIAMgA0EcajYCACMA -QSBrIgEkAAJAAkACQAJAAkACQEHggsEALQAAQQFrDgMCBAEAC0HggsEAQQI6AAAgAygCACIGKAIA -IQUgBkEANgIAIAVFDQIgBSgCAEEINgIAQeCCwQBBAzoAAAsgAUEgaiQADAMLIAFBADYCGCABQQE2 -AgwgAUH0mcAANgIIDAoLQbibwAAQ2QEACyABQQA2AhggAUEBNgIMIAFBtJrAADYCCAwICyADKAIY -BUHcgsEACygCACIBRQ0CIANB1ILBADYCGCAAIAFuIgZB2ILBAC0AAEEDRwR/IAMgA0EYajYCHCAD -IANBHGo2AgAjAEEgayIBJAACQAJAAkACQAJAAkBB2ILBAC0AAEEBaw4DAgQBAAtB2ILBAEECOgAA -IAMoAgAiBygCACEFIAdBADYCACAFRQ0CIAUoAgBBAjYCAEHYgsEAQQM6AAALIAFBIGokAAwDCyAB -QQA2AhggAUEBNgIMIAFB9JnAADYCCAwKC0G4m8AAENkBAAsgAUEANgIYIAFBATYCDCABQbSawAA2 -AggMCAsgAygCGAVB1ILBAAsoAgAgAGwiAU8NAyABQQBIDQRBuYLBAC0AABpBASEIIAFBARDFASIF -RQ0EIAQgATYCHCAEIAY2AhggBEHIm8AANgIIIARCADcDACAEQQA2AiggBCAFNgIkIAQgATYCICAE -IABBAWsiAK0gAGdBIHOthjcDECADQSBqJAAMBQsgA0EANgIAIwBBEGsiACQAIABB4JTAADYCDCAA -IANBHGo2AgggAEEIakGIssAAIABBDGpBiLLAACADQciVwAAQUAALQdiVwABBKEGAlsAAEJcBAAtB -kJbAABCdAQALQaCWwABBL0HQlsAAEJcBAAsgCCABQeCWwAAQtwEACyACQThqIgBBADoAACACQfgA -aiAAKQMANwIAIAJB8ABqIAJBMGopAwA3AgAgAkHoAGogAkEoaikDADcCACACQeAAaiACQSBqKQMA -NwIAIAJB2ABqIAJBGGopAwA3AgAgAkHQAGogAkEQaikDADcCAEG5gsEALQAAGiACIAIpAwg3AkhB -yABBCBDFASIARQRAQQhByAAQ7AEACyAAQQA2AgggAEKBgICAEDcDACAAIAIpAkQ3AgwgAEEUaiAC -QcwAaikCADcCACAAQRxqIAJB1ABqKQIANwIAIABBJGogAkHcAGopAgA3AgAgAEEsaiACQeQAaikC -ADcCACAAQTRqIAJB7ABqKQIANwIAIABBPGogAkH0AGopAgA3AgAgAEHEAGogAkH8AGooAgA2AgAg -AkGAAWokACAAQQhqDwsgAUIENwIQIAFBCGpBrJjAABCjAQAL5gIBCH8jAEEQayIFJABBCiECIAAi -A0HoB08EQCADIQQDQCAFQQZqIAJqIgZBA2sgBCAEQZDOAG4iA0GQzgBsayIHQf//A3FB5ABuIghB -AXQiCUH568AAai0AADoAACAGQQRrIAlB+OvAAGotAAA6AAAgBkEBayAHIAhB5ABsa0H//wNxQQF0 -IgdB+evAAGotAAA6AAAgBkECayAHQfjrwABqLQAAOgAAIAJBBGshAiAEQf+s4gRLIAMhBA0ACwsC -QCADQQlNBEAgAyEEDAELIAIgBWpBBWogAyADQf//A3FB5ABuIgRB5ABsa0H//wNxQQF0IgNB+evA -AGotAAA6AAAgAkECayICIAVBBmpqIANB+OvAAGotAAA6AAALQQAgACAEG0UEQCACQQFrIgIgBUEG -amogBEEBdEEecUH568AAai0AADoAAAsgAUEBQQFBACAFQQZqIAJqQQogAmsQNiAFQRBqJAALggMB -BH8gACgCDCECAkACQAJAIAFBgAJPBEAgACgCGCEDAkACQCAAIAJGBEAgAEEUQRAgACgCFCICG2oo -AgAiAQ0BQQAhAgwCCyAAKAIIIgEgAjYCDCACIAE2AggMAQsgAEEUaiAAQRBqIAIbIQQDQCAEIQUg -ASICQRRqIAJBEGogAigCFCIBGyEEIAJBFEEQIAEbaigCACIBDQALIAVBADYCAAsgA0UNAgJAIAAo -AhxBAnRBqIPBAGoiASgCACAARwRAIAMoAhAgAEYNASADIAI2AhQgAg0DDAQLIAEgAjYCACACRQ0E -DAILIAMgAjYCECACDQEMAgsgACgCCCIAIAJHBEAgACACNgIMIAIgADYCCA8LQcCGwQBBwIbBACgC -AEF+IAFBA3Z3cTYCAA8LIAIgAzYCGCAAKAIQIgEEQCACIAE2AhAgASACNgIYCyAAKAIUIgBFDQAg -AiAANgIUIAAgAjYCGA8LDwtBxIbBAEHEhsEAKAIAQX4gACgCHHdxNgIAC+ACAQR/IwBBEGsiAiQA -AkAgAUGAAU8EQCACQQxqIgRBAnIhAyACQQA2AgwCQCABQYAQTwRAIARBA3IhBSABQYCABE8EQCAC -QRBqIQMgAiABQRJ2QfABcjoADCACIAFBBnZBP3FBgAFyOgAOIAIgAUEMdkE/cUGAAXI6AA0gBSEE -DAILIAIgAUEMdkHgAXI6AAwgAiABQQZ2QT9xQYABcjoADSADIQQgBSEDDAELIAJBDGpBAXIhBCAC -IAFBBnZBwAFyOgAMCyAEIAFBP3FBgAFyOgAAIAMgAkEMamsiASAAKAIAIAAoAggiA2tLBEAgACAD -IAFBAUEBEFcgACgCCCEDCyABBEAgACgCBCADaiACQQxqIAH8CgAACyAAIAEgA2o2AggMAQsgACgC -CCIDIAAoAgBGBEAgAEGIg8AAEHILIAAoAgQgA2ogAToAACAAIANBAWo2AggLIAJBEGokAEEAC+AC -AQR/IwBBEGsiAiQAAkAgAUGAAU8EQCACQQxqIgRBAnIhAyACQQA2AgwCQCABQYAQTwRAIARBA3Ih -BSABQYCABE8EQCACQRBqIQMgAiABQRJ2QfABcjoADCACIAFBBnZBP3FBgAFyOgAOIAIgAUEMdkE/ -cUGAAXI6AA0gBSEEDAILIAIgAUEMdkHgAXI6AAwgAiABQQZ2QT9xQYABcjoADSADIQQgBSEDDAEL -IAJBDGpBAXIhBCACIAFBBnZBwAFyOgAMCyAEIAFBP3FBgAFyOgAAIAMgAkEMamsiASAAKAIAIAAo -AggiA2tLBEAgACADIAFBAUEBEFcgACgCCCEDCyABBEAgACgCBCADaiACQQxqIAH8CgAACyAAIAEg -A2o2AggMAQsgACgCCCIDIAAoAgBGBEAgAEHcjsAAEHILIAAoAgQgA2ogAToAACAAIANBAWo2AggL -IAJBEGokAEEAC7MCAQF/IwBB8ABrIgYkACAGIAE2AgwgBiAANgIIIAYgAzYCFCAGIAI2AhAgBkGM -gsEAKAIANgIcIAZBgILBACgCADYCGAJAIAQoAgAEQCAGQTBqIARBEGopAgA3AwAgBkEoaiAEQQhq -KQIANwMAIAYgBCkCADcDICAGQQQ2AlwgBkGg68AANgJYIAZCBDcCZCAGIAZBEGqtQoCAgICADIQ3 -A1AgBiAGQQhqrUKAgICAgAyENwNIIAYgBkEgaq1CgICAgKAMhDcDQAwBCyAGQQM2AlwgBkHs6sAA -NgJYIAZCAzcCZCAGIAZBEGqtQoCAgICADIQ3A0ggBiAGQQhqrUKAgICAgAyENwNACyAGIAZBGGqt -QoCAgICQDIQ3AzggBiAGQThqNgJgIAZB2ABqIAUQowEAC/ICAQF/AkAgAgRAIAEtAABBME0NASAF -QQI7AQACQAJAAkACQAJAIAPBIgZBAEoEQCAFIAE2AgQgAiADQf//A3EiA0sNASAFQQA7AQwgBSAC -NgIIIAUgAyACazYCECAEDQJBAiEBDAULIAUgAjYCICAFIAE2AhwgBUECOwEYIAVBADsBDCAFQQI2 -AgggBUGx6MAANgIEIAVBACAGayIDNgIQQQMhASACIARPDQQgBCACayICIANNDQQgAiAGaiEEDAML -IAVBAjsBGCAFQQE2AhQgBUGw6MAANgIQIAVBAjsBDCAFIAM2AgggBSACIANrIgI2AiAgBSABIANq -NgIcIAIgBEkNAUEDIQEMAwsgBUEBNgIgIAVBsOjAADYCHCAFQQI7ARgMAQsgBCACayEECyAFIAQ2 -AiggBUEAOwEkQQQhAQsgACABNgIEIAAgBTYCAA8LQZjlwABBIUG858AAEJcBAAtBzOfAAEEfQezn -wAAQlwEAC8oCAQZ/IAEgAkEBdGohCSAAQYD+A3FBCHYhCiAAQf8BcSEMAkACQAJAAkADQCABQQJq -IQsgByABLQABIgJqIQggCiABLQAAIgFHBEAgASAKSw0EIAghByALIgEgCUcNAQwECyAHIAhLDQEg -BCAISQ0CIAMgB2ohAQNAIAJFBEAgCCEHIAsiASAJRw0CDAULIAJBAWshAiABLQAAIAFBAWohASAM -Rw0ACwtBACECDAMLIAcgCEGI8cAAENcBAAsgCCAEQYjxwAAQ1gEACyAAQf//A3EhByAFIAZqIQNB -ASECA0AgBUEBaiEAAkAgBSwAACIBQQBOBEAgACEFDAELIAAgA0cEQCAFLQABIAFB/wBxQQh0ciEB -IAVBAmohBQwBC0H48MAAENkBAAsgByABayIHQQBIDQEgAkEBcyECIAMgBUcNAAsLIAJBAXELygIB -A38jAEEQayICJAACQCABQYABTwRAIAJBADYCDAJ/IAFBgBBPBEAgAUGAgARPBEAgAkEMakEDciEE -IAIgAUESdkHwAXI6AAwgAiABQQZ2QT9xQYABcjoADiACIAFBDHZBP3FBgAFyOgANQQQMAgsgAkEM -akECciEEIAIgAUEMdkHgAXI6AAwgAiABQQZ2QT9xQYABcjoADUEDDAELIAJBDGpBAXIhBCACIAFB -BnZBwAFyOgAMQQILIQMgBCABQT9xQYABcjoAACAAKAIAIAAoAggiAWsgA0kEQCAAIAEgAxBoIAAo -AgghAQsgAwRAIAAoAgQgAWogAkEMaiAD/AoAAAsgACABIANqNgIIDAELIAAoAggiAyAAKAIARgRA -IABBpMzAABByCyAAIANBAWo2AgggACgCBCADaiABOgAACyACQRBqJABBAAvGAgECfyMAQRBrIgIk -AAJAIAFBgAFPBEAgAkEANgIMAn8gAUGAEE8EQCABQYCABE8EQCACIAFBP3FBgAFyOgAPIAIgAUES -dkHwAXI6AAwgAiABQQZ2QT9xQYABcjoADiACIAFBDHZBP3FBgAFyOgANQQQMAgsgAiABQT9xQYAB -cjoADiACIAFBDHZB4AFyOgAMIAIgAUEGdkE/cUGAAXI6AA1BAwwBCyACIAFBP3FBgAFyOgANIAIg -AUEGdkHAAXI6AAxBAgsiASAAKAIAIAAoAggiA2tLBEAgACADIAEQXyAAKAIIIQMLIAEEQCAAKAIE -IANqIAJBDGogAfwKAAALIAAgASADajYCCAwBCyAAKAIIIgMgACgCAEYEQCAAQbjFwAAQcgsgACgC -BCADaiABOgAAIAAgA0EBajYCCAsgAkEQaiQAQQALxAIBBH8gAEIANwIQIAACf0EAIAFBgAJJDQAa -QR8gAUH///8HSw0AGiABQQYgAUEIdmciA2t2QQFxIANBAXRrQT5qCyICNgIcIAJBAnRBqIPBAGoh -BEEBIAJ0IgNBxIbBACgCAHFFBEAgBCAANgIAIAAgBDYCGCAAIAA2AgwgACAANgIIQcSGwQBBxIbB -ACgCACADcjYCAA8LAkACQCABIAQoAgAiAygCBEF4cUYEQCADIQIMAQsgAUEZIAJBAXZrQQAgAkEf -Rxt0IQUDQCADIAVBHXZBBHFqIgQoAhAiAkUNAiAFQQF0IQUgAiEDIAIoAgRBeHEgAUcNAAsLIAIo -AggiASAANgIMIAIgADYCCCAAQQA2AhggACACNgIMIAAgATYCCA8LIARBEGogADYCACAAIAM2Ahgg -ACAANgIMIAAgADYCCAv3AgEEfyMAQTBrIgAkAAJAAkBBmILBACgCAEUEQEGwgsEAKAIAIQFBsILB -AEEANgIAIAFFDQEgAEEYaiABEQUAIABBEGoiAiAAQSRqKQIANwMAIAAgACkCHDcDCCAAKAIYIQFB -mILBACgCACIDDQICQCADRQ0AQZyCwQAoAgAiAkUNAEGggsEAKAIAIAJBAnQQ0QELQZyCwQAgATYC -AEGYgsEAQQE2AgBBoILBACAAKQMINwIAQaiCwQAgAEEQaikDADcCAAsgAEEwaiQAQZyCwQAPCyAA -QQA2AiggAEEBNgIcIABB/MDAADYCGCAAQgQ3AiAgAEEYakHowcAAEKMBAAsgAEEoaiACKQMANwIA -IAAgACkDCDcCICAAIAE2AhwgAEEBNgIYAkAgAEEYaiIBKAIARQ0AIAEoAgQiAkUNACABKAIIIAJB -AnQQ0QELIABBADYCKCAAQQE2AhwgAEGIwsAANgIYIABCBDcCICABQZDCwAAQowEAC/wBAgR/AX4j -AEEgayIFJAACQAJAIARFDQAgASABIAJqIgJLDQAgAyAEakEBa0EAIANrca0gAiAAKAIAIgFBAXQi -BiACIAZLGyICQQhBBEEBIARBgQhJGyAEQQFGGyIGIAIgBksbIgatfiIJQiCIUEUNACAJpyIIQYCA -gIB4IANrSw0AQQAhAiAFIAEEfyAFIAEgBGw2AhwgBSAAKAIENgIUIAMFIAILNgIYIAVBCGogAyAI -IAVBFGoQdCAFKAIIQQFHDQEgBSgCECECIAUoAgwhBwsgByACQeCLwAAQtwEACyAFKAIMIQEgACAG -NgIAIAAgATYCBCAFQSBqJAALygECBH8BfiMAQSBrIgMkAAJAAkAgASABIAJqIgJLDQBBCCACIAAo -AgAiAUEBdCIEIAIgBEsbIgIgAkEITRsiBK0iB0IgiFBFDQAgB6ciBUH/////B0sNACADIAEEfyAD -IAE2AhwgAyAAKAIENgIUQQEFQQALNgIYIANBCGpBASAFIANBFGoQdCADKAIIQQFHDQEgAygCECEC -IAMoAgwhBgsgBiACQbiZwAAQtwEACyADKAIMIQEgACAENgIAIAAgATYCBCADQSBqJAALiQIBAX8j -AEEQayICJAAgACgCACEAAn8gAS0AC0EYcUUEQCABKAIAIAAgASgCBCgCEBEAAAwBCyACQQA2Agwg -ASACQQxqAn8gAEGAAU8EQCAAQYAQTwRAIABBgIAETwRAIAIgAEE/cUGAAXI6AA8gAiAAQRJ2QfAB -cjoADCACIABBBnZBP3FBgAFyOgAOIAIgAEEMdkE/cUGAAXI6AA1BBAwDCyACIABBP3FBgAFyOgAO -IAIgAEEMdkHgAXI6AAwgAiAAQQZ2QT9xQYABcjoADUEDDAILIAIgAEE/cUGAAXI6AA0gAiAAQQZ2 -QcABcjoADEECDAELIAIgADoADEEBCxA6CyACQRBqJAALqgICA38BfiMAQUBqIgIkACABKAIAQYCA -gIB4RgRAIAEoAgwhAyACQSRqIgRBADYCACACQoCAgIAQNwIcIAJBMGogAygCACIDQQhqKQIANwMA -IAJBOGogA0EQaikCADcDACACIAMpAgA3AyggAkEcakGoxsAAIAJBKGoQPBogAkEYaiAEKAIAIgM2 -AgAgAiACKQIcIgU3AxAgAUEIaiADNgIAIAEgBTcCAAsgASkCACEFIAFCgICAgBA3AgAgAkEIaiID -IAFBCGoiASgCADYCACABQQA2AgBBuYLBAC0AABogAiAFNwMAQQxBBBDFASIBRQRAQQRBDBDsAQAL -IAEgAikDADcCACABQQhqIAMoAgA2AgAgAEHEyMAANgIEIAAgATYCACACQUBrJAALmgIBA38jAEEQ -ayIGJAAgASABKAIIIgVBACAFQQFHGzYCCAJAAkACQCAFQQFGBEAgASgCBCEEIAEoAgAhBSABQQwQ -0QEgA0UNASAFIAIgA/wKAAAMAQsgA0EASA0BAkAgA0UEQEEBIQUMAQtBuYLBAC0AABpBASEEIANB -ARDFASIFRQ0CCyADBEAgBSACIAP8CgAACyABIAEoAggiAkEBazYCCCADIQQgAkEBRw0AIAEoAgAg -AUEEaigCACIEQQEQuAFFDQIgBBDRASABQQwQ0QEgAyEECyAAIAM2AgggACAFNgIEIAAgBDYCACAG -QRBqJAAPCyAEIANBuLXAABC3AQALQfS2wABBKyAGQQ9qQeS2wABBsLfAABB9AAuCAgIBfgJ/IwBB -gAFrIgQkACAAKAIAKQMAIQICfwJAIAEoAggiAEGAgIAQcUUEQCAAQYCAgCBxDQEgAkEBIAEQSQwC -C0EAIQADQCAAIARqQf8AaiACp0EPcSIDQTByIANB1wBqIANBCkkbOgAAIABBAWshACACQg9WIAJC -BIghAg0ACyABQQFB9uvAAEECIAAgBGpBgAFqQQAgAGsQNgwBC0EAIQADQCAAIARqQf8AaiACp0EP -cSIDQTByIANBN2ogA0EKSRs6AAAgAEEBayEAIAJCD1YgAkIEiCECDQALIAFBAUH268AAQQIgACAE -akGAAWpBACAAaxA2CyAEQYABaiQAC4gCAQV/AkACQAJAAkAgASgCACIBQQFxBEBBHUGBASACIAFB -fnEiBWsiBiADaiIBQQp2Z0ECdGsgAUH//wdLGyEEIAIgBUYEQCAEIQIgASEDDAULIARBBXYiByAG -aiICQYCAgMAASQ0CQbmCwQAtAAAaQRRBBBDFASICRQ0BIAJBATYCECACIAEgB2oiCDYCCCACIAUg -B2s2AgQgAiAINgIAIAIgBEECdkEHcTYCDAwDCyAAIAEgAiADEEMPC0EEQRQQ7AEACyAEQR1xIAJB -BXRyIQILIAEgBmsiBEEAIAEgBE8bIQEgBSAGaiEFCyAAIAI2AgwgACADNgIIIAAgATYCBCAAIAU2 -AgALgwIBBX8CQAJAAkACQCABKAIAIgFBAXEEQEEdQYEBIAIgAWsiBiADaiIEQQp2Z0ECdGsgBEH/ -/wdLGyEFIAEgAkYEQCAFIQIgBCEDDAULIAVBBXYiByAGaiICQYCAgMAASQ0CQbmCwQAtAAAaQRRB -BBDFASICRQ0BIAJBATYCECACIAQgB2oiCDYCCCACIAEgB2s2AgQgAiAINgIAIAIgBUECdkEHcTYC -DAwDCyAAIAEgAiADEEMPC0EEQRQQ7AEACyAFQR1xIAJBBXRyIQILIAQgBmsiBUEAIAQgBU8bIQQg -ASAGaiEBCyAAIAI2AgwgACADNgIIIAAgBDYCBCAAIAE2AgAL1QECBH8BfiMAQSBrIgMkAAJAAkAg -ASABIAJqIgJLBEBBACEBDAELQQAhAUEIIAIgACgCACIFQQF0IgQgAiAESxsiAiACQQhNGyIErSIH -QiCIUEUNACAHpyIGQf////8HSw0AIAMgBQR/IAMgBTYCHCADIAAoAgQ2AhRBAQVBAAs2AhggA0EI -akEBIAYgA0EUahB0IAMoAghBAUcNASADKAIQIQIgAygCDCEBCyABIAJBmMbAABC3AQALIAMoAgwh -ASAAIAQ2AgAgACABNgIEIANBIGokAAvKAgIEfwFvIwBBIGsiAyQAEBohBxBwIgUgByYBIANBGGoi -BCAFNgIEIAQgAjYCACADKAIcIQICQCADKAIYIgRFBEBBASEFDAELIAMgAjYCHCADIAQ2AhggA0EQ -aiIEIAEoAgQgASgCCBC6ATYCBCAEQQA2AgBBASEFIAMoAhQhBAJAAkAgAygCEEEBcQRAIAIhASAE -IQIMAQsgA0EcaiIGQbiEwABBBBA9IAQQ0gEgASgCDLgQDCEHEHAiBCAHJgEgA0EIaiICIAQ2AgQg -AkEANgIAIAMoAgwhAiADKAIIQQFxRQ0BIAMoAhwhAQsgAUGEAUkNASABEG0MAQsgBkG8hMAAQQYQ -PSACENIBIAEtABAhASAGQe6EwABBBRA9QYIBQYMBIAEbENIBQQAhBSADKAIcIQILIAAgAjYCBCAA -IAU2AgAgA0EgaiQAC6gCAQR/IwBBIGsiBCQAQQEhBgJAIAAoAgAiBSABIAIgACgCBCIHKAIMIgER -AQANAAJAIAAtAApBgAFxRQRAIAVB8uvAAEEBIAERAQANAiADIABBpIPAACgCABEAAEUNAQwCCyAF -QfPrwABBAiABEQEADQEgBEEBOgAPIAQgBzYCBCAEIAU2AgAgBEHU68AANgIUIAQgACkCCDcCGCAE -IARBD2o2AgggBCAENgIQIAMgBEEQakGkg8AAKAIAEQAADQEgBCgCEEHw68AAQQIgBCgCFCgCDBEB -AA0BCwJAIAINACAALQAKQYABcQ0AIAAoAgBB9evAAEEBIAAoAgQoAgwRAQANAQsgACgCAEH06MAA -QQEgACgCBCgCDBEBACEGCyAEQSBqJAAgBgvZAwEHfyMAQRBrIgYkAAJAAkAgAkEHTQRAIAINAQwC -CyAGQQhqIQcCQAJAAkACQCABQQNqQXxxIgMgAUYNACACIAMgAWsiAyACIANJGyIERQ0AQQAhA0EB -IQUDQCABIANqLQAAQS5GDQQgBCADQQFqIgNHDQALIAQgAkEIayIISw0CDAELIAJBCGshCEEAIQQL -Qa7cuPECIQMDQEGAgoQIIAEgBGoiCSgCAEGu3LjxAnMiBWsgBXJBgIKECCAJQQRqKAIAQa7cuPEC -cyIFayAFcnFBgIGChHhxQYCBgoR4Rw0BIARBCGoiBCAITQ0ACwsgAiAERwRAQS4hA0EBIQUDQCAB -IARqLQAAQS5GBEAgBCEDDAMLIAIgBEEBaiIERw0ACwtBACEFCyAHIAM2AgQgByAFNgIAIAYoAghB -AUYhAwwBCyABLQAAQS5GIgMgAkEBRnINACABLQABQS5GIgMgAkECRnINACABLQACQS5GIgMgAkED -RnINACABLQADQS5GIgMgAkEERnINACABLQAEQS5GIgMgAkEFRnINACABLQAFQS5GIgMgAkEGRnIN -ACABLQAGQS5GIQMLIAAgAyAALQAEcjoABCAAKAIAIAEgAhDBASAGQRBqJAAL5AEBBH8jAEEQayID -JAAgACgCDCEBAkACfwJAAkACQAJAAkAgACgCBA4CAAECCyABDQFBASEBQQAhAEEBIQIMAwsgAUUN -AQsgA0EEaiAAEEcgAygCBCEAIAMoAgghAiADKAIMDAILIAAoAgAiASgCBCIAQQBIDQIgASgCACEB -IABFBEBBASECQQAhAAwBC0G5gsEALQAAGkEBIQQgAEEBEMUBIgJFDQILIAAEQCACIAEgAPwKAAAL -IAALIQEgAiABELsBIAAEQCACIAAQ0QELIANBEGokAA8LIAQgAEHokMAAELcBAAuUAgIBfwF+IwBB -oAFrIgIkACACQoCAgICQByIDIAFBGGqthDcDOCACIAMgAUEQaq2ENwMwIAIgAyABQQhqrYQ3Aygg -AiADIAGthDcDICACQey5wAA2AgggAkEENgIMIAJBBDYCHCACQoOAgICAhICAaTcCmAEgAkGAgMAA -NgKQASACQQI7AYgBIAJCgoCAgICEgIBpNwKAASACQYCAwAA2AnggAkECOwFwIAJCgYCAgICEgIBp -NwJoIAJBgIDAADYCYCACQQI7AVggAkKAgICAgISAgGk3AlAgAkKAgMAANwJIIAJBAjsBQCACIAJB -QGs2AhggAkEENgIUIAIgAkEgajYCECAAIAJBCGoQRyACQaABaiQAC/IBAQJ/IwBBMGsiAiQAAkAg -ACkDAEL///////////8Ag0KAgICAgICA+P8AWgRAIAJBATYCFCACQcTAwAA2AhAgAkIBNwIcIAIg -AK1CgICAgLAIhDcDKCACIAJBKGo2AhggASgCACABKAIEIAJBEGoQPCEDDAELIAJBADoADCACIAE2 -AghBASEDIAJBATYCFCACQcTAwAA2AhAgAkIBNwIcIAIgAK1CgICAgLAIhDcDKCACIAJBKGo2Ahgg -AkEIakGsvsAAIAJBEGoQPA0AIAItAAxFBEAgAUHMwMAAQQIQwQENAQtBACEDCyACQTBqJAAgAwuV -AgECfyMAQSBrIgUkAEGkg8EAQaSDwQAoAgAiBkEBajYCAAJ/QQAgBkEASA0AGkEBQfCGwQAtAAAN -ABpB8IbBAEEBOgAAQeyGwQBB7IbBACgCAEEBajYCAEECC0H/AXEiBkECRwRAIAZBAXEEQCAFQQhq -IAAgASgCGBECAAsACwJAQZiDwQAoAgAiBkEATgRAQZiDwQAgBkEBajYCAEGcg8EAKAIABEAgBSAA -IAEoAhQRAgAgBSAEOgAdIAUgAzoAHCAFIAI2AhggBSAFKQMANwIQQZyDwQAoAgAgBUEQakGgg8EA -KAIAKAIUEQIAC0GYg8EAQZiDwQAoAgBBAWs2AgBB8IbBAEEAOgAAIANFDQEACwALAAvEAQIGfwF+ -IwBBIGsiAiQAQQQgACgCACIFQQF0IgMgA0EETRsiBq1CFH4iCEIgiFBFBEBBAEEAIAEQtwEACwJA -IAinIgdB/P///wdNBEBBACEDIAIgBQR/IAIgBUEUbDYCHCACIAAoAgQ2AhRBBAUgAws2AhggAkEI -akEEIAcgAkEUahB0IAIoAghBAUcNASACKAIMIQQgAigCECEDCyAEIAMgARC3AQALIAIoAgwhASAA -IAY2AgAgACABNgIEIAJBIGokAAu7AQECfyMAQSBrIgMkAAJAAn9BACABIAEgAmoiAksNABpBAEEI -IAIgACgCACIBQQF0IgQgAiAESxsiAiACQQhNGyIEQQBIDQAaQQAhAiADIAEEfyADIAE2AhwgAyAA -KAIENgIUQQEFIAILNgIYIANBCGpBASAEIANBFGoQdCADKAIIQQFHDQEgAygCECEAIAMoAgwLIABB -2MrAABC3AQALIAMoAgwhASAAIAQ2AgAgACABNgIEIANBIGokAAvAAQEFfyMAQSBrIgEkACAAKAIA -IgJB////P0sEQEEAQQBB7InAABC3AQALAkBBBCACQQF0IgMgA0EETRsiA0EEdCIEQfz///8HTQR/ -IAEgAgR/IAEgAkEEdDYCHCABIAAoAgQ2AhRBBAVBAAs2AhggAUEIakEEIAQgAUEUahB0IAEoAghB -AUcNASABKAIQIQUgASgCDAVBAAsgBUHsicAAELcBAAsgASgCDCECIAAgAzYCACAAIAI2AgQgAUEg -aiQAC70BAQN/IwBBEGsiAiQAAkACQAJAIAFFBEAgAEUNASAAQQhrIgEoAgBBAUcNAiAAKAIsIAAo -AighAyABQQA2AgACQCABQX9GDQAgAEEEayIAIAAoAgBBAWsiADYCACAADQAgAUHIABDRAQsgA0UN -AyADENEBDAMLIABFDQAgAiAAQQhrIgA2AgwgACAAKAIAQQFrIgA2AgAgAA0CIAJBDGoQlAEMAgsQ -5QEAC0HzhMAAQT8Q5wEACyACQRBqJAALwQECA38BfiMAQTBrIgIkACABKAIAQYCAgIB4RgRAIAEo -AgwhAyACQRRqIgRBADYCACACQoCAgIAQNwIMIAJBIGogAygCACIDQQhqKQIANwMAIAJBKGogA0EQ -aikCADcDACACIAMpAgA3AxggAkEMakGoxsAAIAJBGGoQPBogAkEIaiAEKAIAIgM2AgAgAiACKQIM -IgU3AwAgAUEIaiADNgIAIAEgBTcCAAsgAEHEyMAANgIEIAAgATYCACACQTBqJAALtgEBAX8jAEEQ -ayIDJAACQAJAAkAgACgCACIAQQFxBEAgASAAQX5xIgBrIAJqIgFBARC4AUUNAiAAIAEQ0QEMAQsg -ACAAKAIIIgFBAWs2AgggAUEBRw0AIAAoAgAgAEEEaigCACICQQEQuAFFDQIgAhDRASAAQQwQ0QEL -IANBEGokAA8LQfS2wABBKyADQQ9qQeS2wABBoLfAABB9AAtB9LbAAEErIANBD2pB5LbAAEGwt8AA -EH0AC7ABAQZ/AkACQCAAQYQBSQ0AIADQbyYBEFYiASgCDCEFIAEoAhAhAiABQgA3AgwgASgCCCED -IAEoAgQhBCABQgQ3AgQgASgCACEGIAFBADYCACAAIAJJDQEgACACayIAIANPDQEgBCAAQQJ0aiAF -NgIAIAEgAjYCECABIAA2AgwgASADNgIIIAEoAgQgASAENgIEIAEoAgAhACABIAY2AgAgAEUNACAA -QQJ0ENEBCw8LAAu5AQEBf0G5gsEALQAAGgJAQQxBBBDFASIGBEAgBkECNgIIIAYgAzYCACAGIAQg -A2sgBWo2AgQgASAGIAEoAgAiASABIAJGIgIbNgIAIAJFBEAgASABKAIIIgJBAWo2AgggAkEASA0C -IAAgATYCDCAAIAU2AgggACAENgIEIABBwLfAADYCACAGQQwQ0QEPCyAAIAY2AgwgACAFNgIIIAAg -BDYCBCAAQcC3wAA2AgAPC0EEQQwQ7AEACwALsQEBAX8jAEEQayIDJAACQAJAAkAgACgCACIAQQFx -BEAgASAAayACaiIBQQEQuAFFDQIgACABENEBDAELIAAgACgCCCIBQQFrNgIIIAFBAUcNACAAKAIA -IABBBGooAgAiAkEBELgBRQ0CIAIQ0QEgAEEMENEBCyADQRBqJAAPC0H0tsAAQSsgA0EPakHktsAA -QaC3wAAQfQALQfS2wABBKyADQQ9qQeS2wABBsLfAABB9AAvPAwIMfwF+IwBBIGsiBCQAIARBGGoi -CRBWIgVBEGoiBygCADYCACAEQRBqIgogBUEIaiIIKQIANwMAIAdBADYCACAIQgA3AgAgBSkCACEM -IAVCgICAgMAANwIAIAQgDDcDCAJ/IwBBIGsiAyQAAkACQCAEQQhqIgAoAgwiASAAKAIIIgJGBEAC -QCAAKAIAIgIgAUYEQNBvQYABIAEgAUGAAU0bIgb8DwEiAkF/Rg0EAkAgACgCECILRQRAIAAgAjYC -EAwBCyABIAtqIAJHDQULIAEgBmoiAkH/////AUsNBCADIAEEfyADIAFBAnQ2AhwgAyAAKAIENgIU -QQQFQQALNgIYIANBCGpBBCACQQJ0IANBFGoQdCADKAIIQQFGDQQgAygCDCEGIAAgAjYCACAAIAY2 -AgQMAQsgASACTw0DCyAAIAFBAWoiAjYCCCAAKAIEIAFBAnRqIAI2AgAMAQsgASACTw0BCyAAIAAo -AgQgAUECdGooAgA2AgwgACgCECADQSBqJAAgAWoMAQsACyAIIAopAwA3AgAgByAJKAIANgIAIAUo -AgQhAyAFKAIAIQEgBSAEKQMINwIAIAEEQCADIAFBAnQQ0QELIARBIGokAAusAQEBfyMAQRBrIgYk -AAJAIAEEQCAGQQRqIAEgAyAEIAUgAigCEBEJAAJAIAYoAgQiAiAGKAIMIgFNBEAgBigCCCEFDAEL -IAJBAnQhAiAGKAIIIQMgAUUEQEEEIQUgAyACENEBDAELIAMgAkEEIAFBAnQiAhC9ASIFRQ0CCyAA -IAE2AgQgACAFNgIAIAZBEGokAA8LQYi0wABBMhDnAQALQQQgAkH4s8AAELcBAAuaAQEEfyMAQSBr -IgIkAEEIIAAoAgAiBEEBdCIDIANBCE0bIgNBAEgEQEEAQQAgARC3AQALIAIgBAR/IAIgBDYCHCAC -IAAoAgQ2AhRBAQUgBQs2AhggAkEIakEBIAMgAkEUahB0IAIoAghBAUYEQCACKAIMIAIoAhAgARC3 -AQALIAIoAgwhASAAIAM2AgAgACABNgIEIAJBIGokAAukAQEBfyMAQUBqIgIkACAAKAIAIQAgAkIA -NwM4IAJBOGogACUBECQgAiACKAI8IgA2AjQgAiACKAI4NgIwIAIgADYCLCACIAJBLGqtQoCAgIDw -CIQ3AyAgAkECNgIMIAJB3MTAADYCCCACQgE3AhQgAiACQSBqNgIQIAEoAgAgASgCBCACQQhqEDwg -AigCLCIBBEAgAigCMCABENEBCyACQUBrJAALjwEBAX8gAkEATgRAAn8gAygCBARAAkAgAygCCCIE -RQRADAELIAMoAgAgBCABIAIQvQEMAgsLIAEgAkUNABpBuYLBAC0AABogAiABEMUBCyIDRQRAIAAg -AjYCCCAAIAE2AgQgAEEBNgIADwsgACACNgIIIAAgAzYCBCAAQQA2AgAPCyAAQQA2AgQgAEEBNgIA -C60BAQN/IAEoAgQhAgJ/AkAgASgCCCIEIAEoAgAiA0cEQEG5gsEALQAAGkEMQQQQxQEiAQ0BQQRB -DBDsAQALIARFBEBBACEBQQEhAkHItcAADAILIAJBAXEEQCACIQFB0LbAAAwCCyACQQFyIQFBvLbA -AAwBCyABQQE2AgggASADNgIEIAEgAjYCAEHAt8AACyEDIAAgATYCDCAAIAQ2AgggACACNgIEIAAg -AzYCAAvAAQIFfwFvAkAgASgCACIFEPUBIgNBAEgNAAJAIANFBEBBASEEDAELQbmCwQAtAAAaQQEh -AiADQQEQxQEiBEUNAQsQJiEHEHAiASAHJgEgASIGJQEQHyEHEHAiASAHJgEgARC8ASECIAFBhAFP -BEAgARBtCyACJQEgBSUBIAQQISACQYQBTwRAIAIQbQsgBkGEAU8EQCAGEG0LIAAgBRD1ATYCCCAA -IAQ2AgQgACADNgIADwsgAiADQfiywAAQtwEAC5QBAQN/IwBBEGsiAiQAAn9BASABKAIAIgNBJyAB -KAIEIgQoAhAiAREAAA0AGiACQQRqIAAoAgBBgQIQNQJAIAItAARBgAFGBEAgAyACKAIIIAERAABF -DQFBAQwCCyADIAItAA4iACACQQRqaiACLQAPIABrIAQoAgwRAQBFDQBBAQwBCyADQScgAREAAAsg -AkEQaiQAC5UBAQJ/AkAgAkEASA0AIAACfyACRQRAQci1wAAhA0EBIQRBAAwBC0G5gsEALQAAGkEB -IQMgAkEBEMUBIgRFDQEgAgRAIAQgASAC/AoAAAsgBEEBcQRAQdC2wAAhAyAEDAELQby2wAAhAyAE -QQFyCzYCDCAAIAI2AgggACAENgIEIAAgAzYCAA8LIAMgAkG4tcAAELcBAAt5AgF+An8jAEGAAWsi -BCQAIAApAwAhAkEAIQADQCAAIARqQf8AaiACp0EPcSIDQTByIANB1wBqIANBCkkbOgAAIABBAWsh -ACACQg9WIAJCBIghAg0ACyABQQFB9uvAAEECIAAgBGpBgAFqQQAgAGsQNiAEQYABaiQAC4QBAQF/ -AkAgA0EASA0AAkAgA0UEQEEBIQEMAQtBuYLBAC0AABpBASEEIANBARDFASIBRQ0BCyADBEAgASAC -IAP8CgAACyAAIAM2AgggACADNgIEIAAgATYCACAAQR1BgQEgA0EKdmdBAnRrIANB//8HSxs2AgwP -CyAEIANByLjAABC3AQALowECBH8BbwJAIAEtAAQEQEECIQMMAQsgASgCACUBEBQhBhBwIgIgBiYB -QZCDwQAoAgAhBEGMg8EAKAIAQYyDwQBCADcCAEEBIQNBAUYEQCABQQE6AAQMAQsCfyACJQEQFUUE -QCACJQEQFiEGEHAiASAGJgEgASEEQQAMAQsgAUEBOgAEQQILIQMgAkGEAUkNACACEG0LIAAgBDYC -BCAAIAM2AgALegEBfyMAQSBrIgIkAAJ/IAAoAgBBgICAgHhHBEAgASAAKAIEIAAoAggQwQEMAQsg -AkEQaiAAKAIMKAIAIgBBCGopAgA3AwAgAkEYaiAAQRBqKQIANwMAIAIgACkCADcDCCABKAIAIAEo -AgQgAkEIahA8CyACQSBqJAALfAEBfyMAQUBqIgUkACAFIAE2AgwgBSAANgIIIAUgAzYCFCAFIAI2 -AhAgBUECNgIcIAVBxOvAADYCGCAFQgI3AiQgBSAFQRBqrUKAgICAgAyENwM4IAUgBUEIaq1CgICA -gJAMhDcDMCAFIAVBMGo2AiAgBUEYaiAEEKMBAAtwAQF/IwBBEGsiASQAIAAoAgAiACAAKAIIIgJB -AWs2AggCQCACQQFGBEAgACgCACAAQQRqKAIAIgNBARC4AUUNASADENEBIABBDBDRAQsgAUEQaiQA -DwtB9LbAAEErIAFBD2pB5LbAAEGwt8AAEH0AC80CAQN/IwBBMGsiAyQAIAMgAjYCBCADIAE2AgAg -A0ECNgIMIANBrJLAADYCCCADQgI3AhQgAyADrUKAgICA4AKENwMoIAMgAK1CgICAgIAChDcDICAD -IANBIGo2AhACfyMAQRBrIgIkACADQQhqIgAoAgwhAQJAAn8CQAJAAkACQAJAIAAoAgQOAgABAgsg -AQ0BQQEhBUEAIQBBASEBDAMLIAFFDQELIAJBBGogABBHIAIoAgwhACACKAIIIQEgAigCBAwCCyAA -KAIAIgEoAgQiAEEASA0CIAEoAgAhBSAARQRAQQEhAUEAIQAMAQtBuYLBAC0AABpBASEEIABBARDF -ASIBRQ0CCyAABEAgASAFIAD8CgAACyAACyEEIAEgABC7ASAEBEAgASAEENEBCyACQRBqJAAMAQsg -BCAAQbCTwAAQtwEACyADQTBqJAALagIBfwF+IwBBMGsiAyQAIAMgATYCBCADIAA2AgAgA0ECNgIM -IANBkOrAADYCCCADQgI3AhQgA0KAgICAkAkiBCADrYQ3AyggAyAEIANBBGqthDcDICADIANBIGo2 -AhAgA0EIaiACEKMBAAtoAQF/AkAgA0EASA0AAkAgA0UEQEEBIQEMAQtBuYLBAC0AABpBASEEIANB -ARDFASIBRQ0BCyADBEAgASACIAP8CgAACyAAIAM2AgggACABNgIEIAAgAzYCAA8LIAQgA0G4tcAA -ELcBAAtpACMAQTBrIgAkAEG4gsEALQAARQRAIABBMGokAA8LIABBAjYCDCAAQYzIwAA2AgggAEIB -NwIUIAAgATYCLCAAIABBLGqtQoCAgICQCYQ3AyAgACAAQSBqNgIQIABBCGpBtMjAABCjAQALnAIC -A38BfiMAQRBrIgEkACABQeiCwQA2AgQgAEHwgsEALQAAQQNHBH8gASABQQRqNgIIIAEgAUEIajYC -DCABQQxqIQIjAEEgayIAJAACQAJAAkACQAJAAkACQEHwgsEALQAAQQFrDgMCBAEAC0HwgsEAQQI6 -AAAgAigCACIDKAIAIQIgA0EANgIAIAJFDQIgAigCAEKACDcDAEHwgsEAQQM6AAALIABBIGokAAwE -CyAAQQA2AhggAEEBNgIMIABB+KzAADYCCAwCC0G8rsAAENkBAAsgAEEANgIYIABBATYCDCAAQbit -wAA2AggLIABCBDcCECAAQQhqQbivwAAQowEACyABKAIEBUHogsEACykDABCzASABQRBqJABQC1kB -An8jAEEQayICJAAgAEEEaiEDAn8gACgCAEEBRgRAIAIgAzYCDCABQaqDwABBAyACQQxqEGEMAQsg -AiADNgIIIAFBqIPAAEECIAJBCGoQYQsgAkEQaiQAC14BAX8jAEEwayICJAAgAiABNgIMIAIgADYC -CCACQQI2AhQgAkGoj8AANgIQIAJCATcCHCACIAJBCGqtQoCAgICQAoQ3AyggAiACQShqNgIYIAJB -EGoQYyACQTBqJAALXgEBfyMAQTBrIgIkACACIAE2AgwgAiAANgIIIAJBAjYCFCACQcyPwAA2AhAg -AkIBNwIcIAIgAkEIaq1CgICAgJAChDcDKCACIAJBKGo2AhggAkEQahBjIAJBMGokAAtbAQF/IAEo -AgAiBEEBcQRAIAAgASAEIARBfnEgAiADEG4PCyAEIAQoAggiAUEBajYCCCABQQBOBEAgACAENgIM -IAAgAzYCCCAAIAI2AgQgAEHAt8AANgIADwsAC1gBAX8gASgCACIEQQFxBEAgACABIAQgBCACIAMQ -bg8LIAQgBCgCCCIBQQFqNgIIIAFBAE4EQCAAIAQ2AgwgACADNgIIIAAgAjYCBCAAQcC3wAA2AgAP -CwALWAEBfyMAQSBrIgMkACADQRhqIAJBGGopAAA3AwAgA0EQaiACQRBqKQAANwMAIANBCGogAkEI -aikAADcDACADIAIpAAA3AwAgACADIAFBIBA0IANBIGokAAtOACMAQSBrIgAkACAAQQE2AgQgAEHo -vcAANgIAIABCATcCDCAAQtC9wICwBzcDGCAAIABBGGo2AgggASgCACABKAIEIAAQPCAAQSBqJAAL -SwAgASgCACIBQQFxBEAgAUF+cSEBIAMEQCABIAIgA/wKAAALIAAgAzYCCCAAIAE2AgQgACACIANq -IAFrNgIADwsgACABIAIgAxBbC0sBAX8gACgCACAAKAIIIgNrIAJJBEAgACADIAJBAUEBEFcgACgC -CCEDCyACBEAgACgCBCADaiABIAL8CgAACyAAIAIgA2o2AghBAAtHAQF/IAAoAgAgACgCCCIDayAC -SQRAIAAgAyACEF8gACgCCCEDCyACBEAgACgCBCADaiABIAL8CgAACyAAIAIgA2o2AghBAAtNAQF/ -IwBBMGsiASQAIAFBATYCDCABQajpwAA2AgggAUIBNwIUIAEgAUEvaq1CgICAgPALhDcDICABIAFB -IGo2AhAgAUEIaiAAEKMBAAtEACABKAIAIgFBAXEEQCADBEAgASACIAP8CgAACyAAIAM2AgggACAB -NgIEIAAgAiADaiABazYCAA8LIAAgASACIAMQWws6AQF/IwBBIGsiACQAIABBADYCGCAAQQE2Agwg -AEG4ycAANgIIIABCBDcCECAAQQhqQezJwAAQowEAC0cBAX8gACgCACAAKAIIIgNrIAJJBEAgACAD -IAIQaCAAKAIIIQMLIAIEQCAAKAIEIANqIAEgAvwKAAALIAAgAiADajYCCEEAC0EBAn8jAEEQayIC -JAAgAkEIaiAAKAIAJQEQCyACKAIIIgMgAigCDCIAIAEQ7gEgAARAIAMgABDRAQsgAkEQaiQAC08B -An8gACgCBCECIAAoAgAhAwJAIAAoAggiAC0AAEUNACADQezrwABBBCACKAIMEQEARQ0AQQEPCyAA -IAFBCkY6AAAgAyABIAIoAhARAAALQgEBfyAAKAIAIgAoAjAiAQRAIAAoAjQgARDRAQsCQCAAQX9G -DQAgACAAKAIEQQFrIgE2AgQgAQ0AIABByAAQ0QELC08BAn9BuYLBAC0AABogASgCBCECIAEoAgAh -A0EIQQQQxQEiAUUEQEEEQQgQ7AEACyABIAI2AgQgASADNgIAIABB1MjAADYCBCAAIAE2AgALnnQD -I38afgF8IAEoAggiA0GAgIABcSECIAArAwAhPyADQYCAgIABcUUEQCABIAJBAEchAUEAIQAjAEGA -AWsiByQAID+9ISUCf0EDID+ZRAAAAAAAAPB/YQ0AGkECICVCgICAgICAgPj/AIMiJkKAgICAgICA -+P8AUQ0AGiAlQv////////8HgyIpQoCAgICAgIAIhCAlQgGGQv7///////8PgyAlQjSIp0H/D3Ei -ABsiJ0IBgyEoICZQBEBBBCApUA0BGiAAQbMIayEAQgEhJiAoUAwBC0KAgICAgICAICAnQgGGICdC -gICAgICAgAhRIgIbISdCAkIBIAIbISZBy3dBzHcgAhsgAGohACAoUAshAiAHIAA7AXggByAmNwNw -IAdCATcDaCAHICc3A2AgByACOgB6An8CQAJAAkAgAkECayICBEBBASEAQbPowABBtOjAACAlQgBT -IgMbQbPowABBASADGyABGyEXICVCP4inIAFyIRtBAyACIAJBA08bQQJrDgIDAgELIAdBAzYCKCAH -QbXowAA2AiQgB0ECOwEgQQEhF0EBIQAgB0EgagwDCyAHQQM2AiggB0G46MAANgIkIAdBAjsBICAH -QSBqDAILIAdBIGohBiAHQQ9qIQwjAEEwayIDJAACQAJAAn8CQAJAAkACQAJAAkACQAJAIAdB4ABq -IgApAwAiJVBFBEAgACkDCCInUA0BIAApAxAiJlANAiAlICZ8IiYgJVQNAyAlICdUDQQgJkKAgICA -gICAgCBaDQUgAyAALwEYIgA7AQggAyAlICd9Iic3AwAgACAAQSBrIAAgJkKAgICAEFQiARsiAkEQ -ayACICZCIIYgJiABGyImQoCAgICAgMAAVCIBGyICQQhrIAIgJkIQhiAmIAEbIiZCgICAgICAgIAB -VCIBGyICQQRrIAIgJkIIhiAmIAEbIiZCgICAgICAgIAQVCIBGyICQQJrIAIgJkIEhiAmIAEbIiZC -gICAgICAgIDAAFQiARsgJkIChiAmIAEbIihCAFkiAmsiAWvBIgpBAEgNBiADQn8gCq0iKYgiJiAn -gzcDECAmICdUDQogAyAAOwEIIAMgJTcDACADICUgJoM3AxAgJSAmVg0KQaB/IAFrwUHQAGxBsKcF -akHOEG0iAEHRAE8NByAAQQR0IgBB+NjAAGopAwAiKkL/////D4MiJiAlIClCP4MiJYYiK0IgiCI1 -fiIsQiCIIjEgKkIgiCIpIDV+IjJ8ICkgK0L/////D4MiKn4iK0IgiCI2fCEzICxC/////w+DICYg -Kn5CIIh8ICtC/////w+DfCI3QoCAgIAIfEIgiCErQgFBACABIABBgNnAAGovAQBqa0E/ca0iLIYi -KkIBfSEuICYgJyAlhiIlQiCIIid+Ii1C/////w+DICYgJUL/////D4MiJX5CIIh8ICUgKX4iJUL/ -////D4N8Ij5CgICAgAh8QiCIITQgJyApfiE4ICVCIIghOSAtQiCIITogAEGC2cAAai8BACEBICkg -KCACrYYiJUIgiCI7fiI8ICYgO34iJ0IgiCIvfCApICVC/////w+DIiV+IihCIIgiMHwgJ0L///// -D4MgJSAmfkIgiHwgKEL/////D4N8Ij1CgICAgAh8QiCIfEIBfCItICyIpyIAQZDOAE8EQCAAQcCE -PUkNCSAAQYDC1y9PBEBBCEEJIABBgJTr3ANJIgIbIQpBgMLXL0GAlOvcAyACGwwLC0EGQQcgAEGA -reIESSICGyEKQcCEPUGAreIEIAIbDAoLIABB5ABPBEBBAkEDIABB6AdJIgIbIQpB5ABB6AcgAhsM -CgtBCkEBIABBCUsiChsMCQtBz9TAAEEcQcjjwAAQlwEAC0H81MAAQR1B2OPAABCXAQALQazVwABB -HEHo48AAEJcBAAtBkNfAAEE2QYjlwAAQlwEAC0HI1sAAQTdB+OTAABCXAQALQYjkwABBLUG45MAA -EJcBAAtBo9LAAEEdQeTSwAAQlwEACyAAQdEAQbjjwAAQgAEAC0EEQQUgAEGgjQZJIgIbIQpBkM4A -QaCNBiACGwshAiArIDN8ITMgLSAugyEmIAogAWtBAWohBSAtIDggOnwgOXwgNHx9IjRCAXwiKCAu -gyEnQQAhAQJAAkACQAJAAkACQAJAAkADQCAAIAJuIQsgAUERRg0CIAEgDGoiDiALQTBqIg06AAAC -QCAAIAIgC2xrIgCtICyGIisgJnwiJSAoWgRAIAEgCkcNASABQQFqIQFCASElA0AgJSEoICchKSAB -QRFPDQYgASAMaiAmQgp+IiYgLIinQTBqIgI6AAAgAUEBaiEBICVCCn4hJSAnQgp+IicgJiAugyIm -WA0ACyAlIC0gM31+IiwgJXwhKyAnICZ9ICpUIgANByAsICV9IiwgJlYNAwwHCyAoICV9IicgAq0g -LIYiKFQhAiAtIDN9IixCAXwhKiAnIChUICUgLEIBfSIsWnINBSA9QoCAgIAIfEIgiCItIC8gMHx8 -IDx8ISdCAiA5IDp8ID5CgICAgAh8QiCIfCA4fCAmICh8IiUgK3x8fSEuQgAgMSA2fCA3QoCAgIAI -fEIgiHwiMSAyfCAmICt8fH0hMiAlIDF8ICkgNSA7fX58IC99IDB9IC19ISkDQCAlICt8Ii8gLFQg -JyAyfCApICt8WnJFBEAgJiArfCElQQAhAgwHCyAOIA1BAWsiDToAACAmICh8ISYgJyAufCEtICwg -L1YEQCAoICl8ISkgJSAofCElICcgKH0hJyAoIC1YDQELCyAoIC1WIQIgJiArfCElDAULIAFBAWoh -ASACQQpJIAJBCm4hAkUNAAtByOTAABCdAQALIAEgDGpBAWshCiAqIDEgNnwgN0KAgICACHxCIIh8 -IDJ8Qgp+IC8gMHwgPUKAgICACHxCIIh8IDx8Qgp+fSAofnwhLSApQgp+ICYgKnx9IS4gLCAmfSEv -QgAhKQNAICYgKnwiJSAsVCApIC98ICYgLXxackUEQEEAIQAMBQsgCiACQQFrIgI6AAAgKSAufCIw -ICpUIQAgJSAsWg0FICkgKn0hKSAlISYgKiAwWA0ACwwEC0ERQRFB2OTAABCAAQALIAFBEUHo5MAA -EIABAAsCQCAlICpaIAJyDQAgKiAlICh8IiZYICogJX0gJiAqfVRxDQAgBkEANgIADAQLICUgNEID -fVggJUICWnFFBEAgBkEANgIADAQLIAYgBTsBCCAGIAFBAWo2AgQMAgsgJiElCwJAICUgK1ogAHIN -ACArICUgKnwiJlggKyAlfSAmICt9VHENACAGQQA2AgAMAgsgJSAoQlh+ICd8WCAlIChCFH5acUUE -QCAGQQA2AgAMAgsgBiAFOwEIIAYgATYCBAsgBiAMNgIACyADQTBqJAAMAQsgA0EANgIYIwBBEGsi -ACQAIAAgAzYCDCAAIANBEGo2AgggAEEIakGg6sAAIABBDGpBoOrAACADQRhqQfTSwAAQUAALAkAg -BygCIARAIAdB2ABqIAdBKGooAgA2AgAgByAHKQIgNwNQDAELIAdB0ABqIQ8gB0EPaiENIwBBoApr -IgEkAAJAAkACQAJAAkACQAJAAkAgB0HgAGoiACkDACIlUEUEQCAAKQMIIiZQRQRAIAApAxAiJ1BF -BEAgJSAlICd8IihYBEAgJSAmWgRAIAAsABohGCAALgEYIQAgASAlPgIAIAFBAUECICVCgICAgBBU -IgIbNgKgASABQQAgJUIgiKcgAhs2AgQgAUEIakEAQZgB/AsAIAEgJj4CpAEgAUEBQQIgJkKAgICA -EFQiAhs2AsQCIAFBACAmQiCIpyACGzYCqAEgAUGsAWpBAEGYAfwLACABICc+AsgCIAFBAUECICdC -gICAgBBUIgIbNgLoAyABQQAgJ0IgiKcgAhs2AswCIAFB0AJqQQBBmAH8CwAgAUHwA2pBAEGcAfwL -ACABQQE2AuwDIAFBATYCjAUgAKwgKEIBfXl9QsKawegEfkKAoc2gtAJ8QiCIpyICwSEOAkAgAEEA -TgRAIAEgABAtGiABQaQBaiAAEC0aIAFByAJqIAAQLRoMAQsgAUHsA2pBACAAa8EQLRoLAkAgDkEA -SARAIAFBACAOa0H//wNxIgAQKyABQaQBaiAAECsgAUHIAmogABArDAELIAFB7ANqIAJB//8BcRAr -CyABKAKgASEDIAFB/AhqIAFBoAH8CgAAIAEgAzYCnAoCQAJAAkACQCABKALoAyIGIAMgAyAGSRsi -AkEoTQRAIAJFBEBBACECDAQLIAJBAXEhCyACQQFHDQEMAgsMDAsgAkE+cSERIAFB/AhqIQAgAUHI -AmohBQNAIAAgCCAAKAIAIhIgBSgCAGoiCmoiCDYCACAAQQRqIgwgDCgCACITIAVBBGooAgBqIgwg -CiASSSAIIApJcmoiCjYCACAMIBNJIAogDElyIQggBUEIaiEFIABBCGohACARIAlBAmoiCUcNAAsL -IAsEfyAJQQJ0IgAgAUH8CGpqIgogCigCACIKIAFByAJqIABqKAIAaiIAIAhqIgk2AgAgACAKSSAA -IAlLcgUgCAtFDQAgAkEoRg0BIAFB/AhqIAJBAnRqQQE2AgAgAkEBaiECCyABIAI2ApwKIAIgASgC -jAUiCSACIAlLGyIAQSlJBEAgAEECdCEAAkACQAJ/AkADQCAARQ0BIABBBGsiACABQewDamooAgAi -AiAAIAFB/AhqaigCACIKRg0ACyACIApLIAIgCklrDAELQX9BACAAGwsgGE4EQAJAIANFBEBBACED -DAELIANBAWtB/////wNxIgBBAWoiAkEDcSEFAkAgAEEDSQRAIAEhAEIAISUMAQsgAkH8////B3Eh -CiABIQBCACElA0AgACAANQIAQgp+ICV8IiU+AgAgAEEEaiICIAI1AgBCCn4gJUIgiHwiJT4CACAA -QQhqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIABBDGoiAiACNQIAQgp+ICVCIIh8IiY+AgAgJkIgiCEl +f38AYAR/fX9/AGAFf398f38AYAR/fH9/AGAFf39+f38AYAR/fn9/AGACf34BfgK/ECcYLi9oZl94 +ZXRfdGhpbl93YXNtX2JnLmpzFV9fd2JpbmRnZW5fc3RyaW5nX25ldwAUGC4vaGZfeGV0X3RoaW5f +d2FzbV9iZy5qcxVfX3diaW5kZ2VuX3N0cmluZ19nZXQACxguL2hmX3hldF90aGluX3dhc21fYmcu +anMUX193YmluZGdlbl9pc19vYmplY3QABhguL2hmX3hldF90aGluX3dhc21fYmcuanMXX193Ymlu +ZGdlbl9pc191bmRlZmluZWQABhguL2hmX3hldF90aGluX3dhc21fYmcuanMNX193YmluZGdlbl9p +bgAVGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxRfX3diaW5kZ2VuX2Vycm9yX25ldwAUGC4vaGZf +eGV0X3RoaW5fd2FzbV9iZy5qcxlfX3diaW5kZ2VuX2pzdmFsX2xvb3NlX2VxABUYLi9oZl94ZXRf +dGhpbl93YXNtX2JnLmpzFl9fd2JpbmRnZW5fYm9vbGVhbl9nZXQABhguL2hmX3hldF90aGluX3dh +c21fYmcuanMVX193YmluZGdlbl9udW1iZXJfZ2V0AAsYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpz +FF9fd2JpbmRnZW5fYXNfbnVtYmVyABgYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzHV9fd2JnX1N0 +cmluZ184ZjBlYjM5YTRhNGMyZjY2AAsYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzFV9fd2JpbmRn +ZW5fbnVtYmVyX25ldwAZGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcyRfX3diZ19nZXR3aXRocmVm +a2V5XzFkYzM2MWJkMTAwNTNiZmUAEBguL2hmX3hldF90aGluX3dhc21fYmcuanMaX193Ymdfc2V0 +XzNmMWQwYjk4NGVkMjcyZWQAGhguL2hmX3hldF90aGluX3dhc21fYmcuanMaX193YmdfZ2V0X2I5 +YjkzMDQ3ZmUzY2Y0NWIAGxguL2hmX3hldF90aGluX3dhc21fYmcuanMdX193YmdfbGVuZ3RoX2Uy +ZDJhNDkxMzJjMWIyNTYABhguL2hmX3hldF90aGluX3dhc21fYmcuanMaX193YmdfbmV3Xzc4ZmVi +MTA4YjY0NzI3MTMADBguL2hmX3hldF90aGluX3dhc21fYmcuanMWX193YmluZGdlbl9pc19mdW5j +dGlvbgAGGC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxtfX3diZ19uZXh0XzI1ZmVhZGZjMDkxM2Zl +YTkAChguL2hmX3hldF90aGluX3dhc21fYmcuanMbX193YmdfbmV4dF82NTc0ZTFhOGE2MmQxMDU1 +AAoYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzG19fd2JnX2RvbmVfNzY5ZTVlZGU0YjMxYzY3YgAG +GC4vaGZfeGV0X3RoaW5fd2FzbV9iZy5qcxxfX3diZ192YWx1ZV9jZDFmZmE3YjFhYjc5NGYxAAoY +Li9oZl94ZXRfdGhpbl93YXNtX2JnLmpzH19fd2JnX2l0ZXJhdG9yXzlhMjRjODhkZjg2MGRjNjUA +DBguL2hmX3hldF90aGluX3dhc21fYmcuanMaX193YmdfZ2V0XzY3YjJiYTYyZmMzMGRlMTIAEBgu +L2hmX3hldF90aGluX3dhc21fYmcuanMbX193YmdfY2FsbF82NzJhNGQyMTYzNGQ0YTI0ABAYLi9o +Zl94ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX25ld180MDVlMjJmMzkwNTc2Y2UyAAwYLi9oZl94 +ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX3NldF8zNzgzNzAyM2YzZDc0MGU4ABwYLi9oZl94ZXRf +dGhpbl93YXNtX2JnLmpzHl9fd2JnX2lzQXJyYXlfYTFlYWI3ZTBkMDY3MzkxYgAGGC4vaGZfeGV0 +X3RoaW5fd2FzbV9iZy5qcy1fX3diZ19pbnN0YW5jZW9mX0FycmF5QnVmZmVyX2UxNDU4NTQzMmUz +NzM3ZmMABhguL2hmX3hldF90aGluX3dhc21fYmcuanMkX193YmdfaXNTYWZlSW50ZWdlcl8zNDNl +MmJlZWVlY2UxYmIwAAYYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzHV9fd2JnX2J1ZmZlcl82MDlj +YzNlZWU1MWVkMTU4AAoYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX25ld19hMTIwMDJh +N2Y5MWM3NWJlAAoYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzGl9fd2JnX3NldF82NTU5NWJkZDg2 +OGIzMDA5AB0YLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzHV9fd2JnX2xlbmd0aF9hNDQ2MTkzZGMy +MmMxMmY4AAYYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzLF9fd2JnX2luc3RhbmNlb2ZfVWludDhB +cnJheV8xNzE1NmJjZjExODA4NmE5AAYYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzF19fd2JpbmRn +ZW5fZGVidWdfc3RyaW5nAAsYLi9oZl94ZXRfdGhpbl93YXNtX2JnLmpzEF9fd2JpbmRnZW5fdGhy +b3cAAhguL2hmX3hldF90aGluX3dhc21fYmcuanMRX193YmluZGdlbl9tZW1vcnkADBguL2hmX3hl +dF90aGluX3dhc21fYmcuanMfX193YmluZGdlbl9pbml0X2V4dGVybnJlZl90YWJsZQANA8wBygEe +Bx8CAgACAgADCQMEAxEDAAUBAAEAAAERAQQCIAECACEDBwACAAAODiIAAAIWCQMAAgQABAQDAwEH +AgAJAgMFAgIDBQ4DFg4CAAQCAgADAAQCAAkDAQMEAgcAAAQEAwAEAQEFBA0BAAUCAAMEAgASAAUj +JCUXFwImExEHAAkSJykrBQQAAQQtAAUDAwAFAAAHEwADAAEACQAABAQAAAUCAgIAAAACAwMHAwMD +AAUAAAAAAAAAAAAADQ0CAAIAAAIBAgAAAgcHBwcDBAkCcAFkZG8AgAEFAwEAEQYJAX8BQYCAwAAL +B98CEQZtZW1vcnkCABJfX3diZ19jaHVua2VyX2ZyZWUAZwtjaHVua2VyX25ldwBJEGNodW5rZXJf +YWRkX2RhdGEAmwEOY2h1bmtlcl9maW5pc2gAnwERY29tcHV0ZV94b3JiX2hhc2gAnAERY29tcHV0 +ZV9maWxlX2hhc2gAnQEZY29tcHV0ZV92ZXJpZmljYXRpb25faGFzaACaAQxjb21wdXRlX2htYWMA +mQERX193YmluZGdlbl9tYWxsb2MAlwESX193YmluZGdlbl9yZWFsbG9jAKABFF9fd2JpbmRnZW5f +ZXhuX3N0b3JlAMUBF19fZXh0ZXJucmVmX3RhYmxlX2FsbG9jAG0TX193YmluZGdlbl9leHBvcnRf +NAEBGV9fZXh0ZXJucmVmX3RhYmxlX2RlYWxsb2MAag9fX3diaW5kZ2VuX2ZyZWUAugEQX193Ymlu +ZGdlbl9zdGFydAAmCbMBAQBBAQtj2QHaAbkBsAGIAUzbAdYB6gHpAdcB2AG9ATe/AdwBsAGIAU29 +AXCVAaUBbqQBpQGhAawBqgGkAaQBpgGnAagBrQF+d+8B8AGDAYcBW6IBaYQBiwFcbN0BkwHBAcIB +zwF7dsMBvwGGAasB1QGjAWJXxAGRAV+vAd4BwwG0AdMBf7ABiQFS4gHHAcYByQGQAcgB4wGpAXlY +aOsBsAGNAVHkAeUBuwG9AcoBywE6dFoMAQ4KsPAEygGJGwEgfyAAIAAoAhgiHSABKAAQIiQgACgC +CGpqIhsgASgAFCIVaiAdIBsgAkH/AXFzQRB3IgJB8ua74wNqIh1zQRR3IhtqIiIgAnNBGHciCSAd +aiIcIBtzQRl3Ig8gACgCFCIbIAEoAAgiAiAAKAIEamoiGSABKAAMIh1qIBkgA0IgiKdzQRB3Ih5B ++6LhpARrIiAgG3NBFHciBmoiCiABKAAoIhtqaiIjIAEoACwiGWogDyAjIAAoAhAiISABKAAAIg8g +ACgCAGpqIgggASgABCIfaiAhIAggA6dzQRB3IiFB58yn0AZqIghzQRR3IgdqIg4gIXNBGHciDXNB +EHciCyAAKAIcIgUgASgAGCIjIAAoAgxqaiIMIAEoABwiIWogBSAMIARB/wFxc0EQdyIEQcaVwNUF +ayIFc0EUdyIMaiIRIARzQRh3IhAgBWoiBWoiEnNBFHciFGoiEyAdaiAGICAgCiAec0EYdyIgaiIG +c0EZdyIKIA4gASgAICIEamoiDiABKAAkIh5qIAogHCAOIBBzQRB3IhxqIgpzQRR3Ig5qIhAgHHNB +GHciFiAKaiIKIA5zQRl3IhxqIg4gG2ogHCAOIAUgDHNBGXciBSAiIAEoADAiHGpqIgwgASgANCIi +aiAMICBzQRB3IiAgCCANaiIIaiINIAVzQRR3IgVqIgwgIHNBGHciF3NBEHciDiAHIAhzQRl3Iggg +ESABKAA4IiBqaiIHIAEoADwiAWogByAJc0EQdyIJIAZqIgYgCHNBFHciCGoiByAJc0EYdyIJIAZq +IgZqIhFzQRR3IhhqIhogHGogCyATc0EYdyILIBJqIhIgFHNBGXciFCAMICFqaiIMIA9qIAkgDHNB +EHciCSAKaiIKIBRzQRR3IgxqIhQgCXNBGHciCSAKaiIKIAxzQRl3IgxqIhMgFWogDCATIAYgCHNB +GXciBiACIBBqaiIIICNqIAYgCCALc0EQdyIGIA0gF2oiCGoiDXNBFHciC2oiDCAGc0EYdyIGc0EQ +dyIQIAUgCHNBGXciCCAHICRqaiIHICJqIAggByAWc0EQdyIIIBJqIgdzQRR3IgVqIhIgCHNBGHci +CCAHaiIHaiITc0EUdyIWaiIXIBtqIA4gGnNBGHciDiARaiIRIBhzQRl3IhggDCAfamoiDCAZaiAK +IAggDHNBEHciCmoiCCAYc0EUdyIMaiIYIApzQRh3IgogCGoiCCAMc0EZdyIMaiIaIBxqIAwgGiAF +IAdzQRl3IgcgFCAeamoiBSAgaiAHIAUgDnNBEHciByAGIA1qIgZqIg5zQRR3Ig1qIgUgB3NBGHci +B3NBEHciDCAGIAtzQRl3IgYgASASamoiCyAEaiAGIAkgC3NBEHciCSARaiIGc0EUdyILaiIRIAlz +QRh3IgkgBmoiBmoiEnNBFHciFGoiGiAeaiAQIBdzQRh3IhAgE2oiEyAWc0EZdyIWIAUgImpqIgUg +AmogBSAJc0EQdyIJIAhqIgggFnNBFHciBWoiFiAJc0EYdyIJIAhqIgggBXNBGXciBWoiFyAPaiAF +IBcgBiALc0EZdyIGIBggHWpqIgsgJGogBiALIBBzQRB3IgYgByAOaiIHaiIOc0EUdyILaiIFIAZz +QRh3IgZzQRB3IhAgByANc0EZdyIHIBEgIWpqIg0gIGogByAKIA1zQRB3IgogE2oiB3NBFHciDWoi +ESAKc0EYdyIKIAdqIgdqIhNzQRR3IhdqIhggHGogDCAac0EYdyIMIBJqIhIgFHNBGXciFCAFICNq +aiIFIBVqIAUgCnNBEHciCiAIaiIIIBRzQRR3IgVqIhQgCnNBGHciCiAIaiIIIAVzQRl3IgVqIhog +HmogBSAaIAcgDXNBGXciByAWIBlqaiINIAFqIAcgDCANc0EQdyIHIAYgDmoiBmoiDnNBFHciDWoi +BSAHc0EYdyIHc0EQdyIMIAYgC3NBGXciBiAEIBFqaiILIB9qIAYgCSALc0EQdyIJIBJqIgZzQRR3 +IgtqIhEgCXNBGHciCSAGaiIGaiISc0EUdyIWaiIaIBlqIBAgGHNBGHciECATaiITIBdzQRl3Ihcg +BSAgamoiBSAdaiAFIAlzQRB3IgkgCGoiCCAXc0EUdyIFaiIXIAlzQRh3IgkgCGoiCCAFc0EZdyIF +aiIYIAJqIAUgGCAGIAtzQRl3IgYgFCAbamoiCyAhaiAGIAsgEHNBEHciBiAHIA5qIgdqIg5zQRR3 +IgtqIgUgBnNBGHciBnNBEHciECAHIA1zQRl3IgcgESAiamoiDSABaiAHIAogDXNBEHciCiATaiIH +c0EUdyINaiIRIApzQRh3IgogB2oiB2oiFHNBFHciE2oiGCAeaiAMIBpzQRh3IgwgEmoiEiAWc0EZ +dyIWIAUgJGpqIgUgD2ogBSAKc0EQdyIKIAhqIgggFnNBFHciBWoiFiAKc0EYdyIKIAhqIgggBXNB +GXciBWoiGiAZaiAFIBogByANc0EZdyIHIBUgF2pqIg0gBGogByAMIA1zQRB3IgcgBiAOaiIGaiIO +c0EUdyINaiIFIAdzQRh3IgdzQRB3IgwgBiALc0EZdyIGIBEgH2pqIgsgI2ogBiAJIAtzQRB3Igkg +EmoiBnNBFHciC2oiESAJc0EYdyIJIAZqIgZqIhJzQRR3IhdqIhogFWogECAYc0EYdyIQIBRqIhQg +E3NBGXciEyABIAVqaiIFIBtqIAUgCXNBEHciCSAIaiIIIBNzQRR3IgVqIhMgCXNBGHciCSAIaiII +IAVzQRl3IgVqIhggHWogBSAYIAYgC3NBGXciBiAWIBxqaiILICJqIAYgCyAQc0EQdyIGIAcgDmoi +B2oiDnNBFHciC2oiBSAGc0EYdyIGc0EQdyIQIAcgDXNBGXciByARICBqaiINIARqIAcgCiANc0EQ +dyIKIBRqIgdzQRR3Ig1qIhEgCnNBGHciCiAHaiIHaiIUc0EUdyIWaiIYIBlqIAwgGnNBGHciDCAS +aiISIBdzQRl3IhcgBSAhamoiBSACaiAFIApzQRB3IgogCGoiCCAXc0EUdyIFaiIXIApzQRh3Igog +CGoiCCAFc0EZdyIFaiIaIBVqIAUgGiAHIA1zQRl3IgcgDyATamoiDSAfaiAHIAwgDXNBEHciByAG +IA5qIgZqIg5zQRR3Ig1qIgUgB3NBGHciB3NBEHciDCAGIAtzQRl3IgYgESAjamoiCyAkaiAGIAkg +C3NBEHciCSASaiIGc0EUdyILaiIRIAlzQRh3IgkgBmoiBmoiEnNBFHciE2oiGiAPaiAQIBhzQRh3 +IhAgFGoiFCAWc0EZdyIWIAQgBWpqIgUgHGogBSAJc0EQdyIJIAhqIgggFnNBFHciBWoiFiAJc0EY +dyIJIAhqIgggBXNBGXciBWoiGCAbaiAFIBggBiALc0EZdyIGIBcgHmpqIgsgIGogBiALIBBzQRB3 +IgYgByAOaiIHaiIOc0EUdyILaiIFIAZzQRh3IgZzQRB3IhAgByANc0EZdyIHIAEgEWpqIg0gH2og +ByAKIA1zQRB3IgogFGoiB3NBFHciDWoiESAKc0EYdyIKIAdqIgdqIhRzQRR3IhdqIhggFWogDCAa +c0EYdyIVIBJqIgwgE3NBGXciEiAFICJqaiIFIB1qIAUgCnNBEHciCiAIaiIIIBJzQRR3IgVqIhIg +CnNBGHciCiAIaiIIIAVzQRl3IgVqIhMgD2ogBSATIAcgDXNBGXciDyACIBZqaiIHICNqIA8gByAV +c0EQdyIVIAYgDmoiD2oiBnNBFHciB2oiDiAVc0EYdyIVc0EQdyINIAsgD3NBGXciDyARICRqaiIL +ICFqIA8gCSALc0EQdyIPIAxqIglzQRR3IgtqIgUgD3NBGHciDyAJaiIJaiIMc0EUdyIRaiITIAJq +IB4gECAYc0EYdyICIBRqIh4gF3NBGXciECAOIB9qaiIfaiAPIB9zQRB3Ig8gCGoiHyAQc0EUdyII +aiIOIA9zQRh3Ig8gH2oiHyAIc0EZdyIIaiIQIBxqIBAgASAJIAtzQRl3IgEgEiAZamoiGWogASAC +IBlzQRB3IgEgBiAVaiICaiIVc0EUdyIZaiIcIAFzQRh3IgFzQRB3IgkgAiAHc0EZdyICIAQgBWpq +IgQgI2ogAiAEIApzQRB3IgIgHmoiBHNBFHciI2oiHiACc0EYdyICIARqIgRqIgYgCHNBFHciCmoi +CCAJc0EYdyIJIAZqIgYgASAVaiIBIBlzQRl3IhUgHiAhamoiGSAiaiAVIA8gGXNBEHciFSANIBNz +QRh3IhkgDGoiD2oiIXNBFHciHmoiInM2AgwgACAbIA8gEXNBGXciDyAcICBqaiIcaiACIBxzQRB3 +IgIgH2oiGyAPc0EUdyIPaiIfIAJzQRh3IgIgG2oiGyAkIAQgI3NBGXciBCAOIB1qaiIdaiAEIAEg +GSAdc0EQdyIBaiIEc0EUdyIkaiIdczYCCCAAIBUgInNBGHciFSAhaiIZIAhzNgIEIAAgASAdc0EY +dyIBIARqIgQgH3M2AgAgACAEICRzQRl3IAJzNgIcIAAgBiAKc0EZdyAVczYCGCAAIA8gG3NBGXcg +AXM2AhQgACAZIB5zQRl3IAlzNgIQC5skAgl/AX4jAEEQayIIJAACfwJAAkACQAJAAkACQCAAQfUB +TwRAQQAgAEHM/3tLDQcaIABBC2oiAUF4cSEFQYSGwQAoAgAiCUUNBEEfIQdBACAFayEEIABB9P// +B00EQCAFQQYgAUEIdmciAGt2QQFxIABBAXRrQT5qIQcLIAdBAnRB6ILBAGooAgAiAUUEQEEAIQAM +AgtBACEAIAVBGSAHQQF2a0EAIAdBH0cbdCEDA0ACQCABKAIEQXhxIgYgBUkNACAGIAVrIgYgBE8N +ACABIQIgBiIEDQBBACEEIAEhAAwECyABKAIUIgYgACAGIAEgA0EddkEEcWooAhAiAUcbIAAgBhsh +ACADQQF0IQMgAQ0ACwwBC0GAhsEAKAIAIgJBECAAQQtqQfgDcSAAQQtJGyIFQQN2IgB2IgFBA3EE +QAJAIAFBf3NBAXEgAGoiBkEDdCIAQfiDwQBqIgMgAEGAhMEAaigCACIBKAIIIgRHBEAgBCADNgIM +IAMgBDYCCAwBC0GAhsEAIAJBfiAGd3E2AgALIAEgAEEDcjYCBCAAIAFqIgAgACgCBEEBcjYCBCAB +QQhqDAcLIAVBiIbBACgCAE0NAwJAAkAgAUUEQEGEhsEAKAIAIgBFDQYgAGhBAnRB6ILBAGooAgAi +AigCBEF4cSAFayEEIAIhAQNAAkAgAigCECIADQAgAigCFCIADQAgASgCGCEHAkACQCABIAEoAgwi +AEYEQCABQRRBECABKAIUIgAbaigCACICDQFBACEADAILIAEoAggiAiAANgIMIAAgAjYCCAwBCyAB +QRRqIAFBEGogABshAwNAIAMhBiACIgBBFGogAEEQaiAAKAIUIgIbIQMgAEEUQRAgAhtqKAIAIgIN +AAsgBkEANgIACyAHRQ0EAkAgASgCHEECdEHogsEAaiICKAIAIAFHBEAgASAHKAIQRwRAIAcgADYC +FCAADQIMBwsgByAANgIQIAANAQwGCyACIAA2AgAgAEUNBAsgACAHNgIYIAEoAhAiAgRAIAAgAjYC +ECACIAA2AhgLIAEoAhQiAkUNBCAAIAI2AhQgAiAANgIYDAQLIAAoAgRBeHEgBWsiAiAEIAIgBEki +AhshBCAAIAEgAhshASAAIQIMAAsACwJAQQIgAHQiA0EAIANrciABIAB0cWgiBkEDdCIBQfiDwQBq +IgMgAUGAhMEAaigCACIAKAIIIgRHBEAgBCADNgIMIAMgBDYCCAwBC0GAhsEAIAJBfiAGd3E2AgAL +IAAgBUEDcjYCBCAAIAVqIgYgASAFayIDQQFyNgIEIAAgAWogAzYCAEGIhsEAKAIAIgQEQCAEQXhx +QfiDwQBqIQFBkIbBACgCACECAn9BgIbBACgCACIFQQEgBEEDdnQiBHFFBEBBgIbBACAEIAVyNgIA +IAEMAQsgASgCCAshBCABIAI2AgggBCACNgIMIAIgATYCDCACIAQ2AggLQZCGwQAgBjYCAEGIhsEA +IAM2AgAgAEEIagwIC0GEhsEAQYSGwQAoAgBBfiABKAIcd3E2AgALAkACQCAEQRBPBEAgASAFQQNy +NgIEIAEgBWoiAyAEQQFyNgIEIAMgBGogBDYCAEGIhsEAKAIAIgZFDQEgBkF4cUH4g8EAaiEAQZCG +wQAoAgAhAgJ/QYCGwQAoAgAiBUEBIAZBA3Z0IgZxRQRAQYCGwQAgBSAGcjYCACAADAELIAAoAggL +IQYgACACNgIIIAYgAjYCDCACIAA2AgwgAiAGNgIIDAELIAEgBCAFaiIAQQNyNgIEIAAgAWoiACAA +KAIEQQFyNgIEDAELQZCGwQAgAzYCAEGIhsEAIAQ2AgALIAFBCGoMBgsgACACckUEQEEAIQJBAiAH +dCIAQQAgAGtyIAlxIgBFDQMgAGhBAnRB6ILBAGooAgAhAAsgAEUNAQsDQCAAIAIgACgCBEF4cSID +IAVrIgYgBEkiBxshCSAAKAIQIgFFBEAgACgCFCEBCyACIAkgAyAFSSIAGyECIAQgBiAEIAcbIAAb +IQQgASIADQALCyACRQ0AIAVBiIbBACgCACIATSAEIAAgBWtPcQ0AIAIoAhghBwJAAkAgAiACKAIM +IgBGBEAgAkEUQRAgAigCFCIAG2ooAgAiAQ0BQQAhAAwCCyACKAIIIgEgADYCDCAAIAE2AggMAQsg +AkEUaiACQRBqIAAbIQMDQCADIQYgASIAQRRqIABBEGogACgCFCIBGyEDIABBFEEQIAEbaigCACIB +DQALIAZBADYCAAsgB0UNAgJAIAIoAhxBAnRB6ILBAGoiASgCACACRwRAIAIgBygCEEcEQCAHIAA2 +AhQgAA0CDAULIAcgADYCECAADQEMBAsgASAANgIAIABFDQILIAAgBzYCGCACKAIQIgEEQCAAIAE2 +AhAgASAANgIYCyACKAIUIgFFDQIgACABNgIUIAEgADYCGAwCCwJAAkACQAJAAkAgBUGIhsEAKAIA +IgFLBEAgBUGMhsEAKAIAIgBPBEAgBUGvgARqQYCAfHEiAkEQdkAAIQAgCEEEaiIBQQA2AgggAUEA +IAJBgIB8cSAAQX9GIgIbNgIEIAFBACAAQRB0IAIbNgIAQQAgCCgCBCIBRQ0JGiAIKAIMIQZBmIbB +ACAIKAIIIgRBmIbBACgCAGoiADYCAEGchsEAIABBnIbBACgCACICIAAgAksbNgIAAkACQEGUhsEA +KAIAIgIEQEHog8EAIQADQCABIAAoAgAiAyAAKAIEIgdqRg0CIAAoAggiAA0ACwwCC0GkhsEAKAIA +IgBBACAAIAFNG0UEQEGkhsEAIAE2AgALQaiGwQBB/x82AgBB9IPBACAGNgIAQeyDwQAgBDYCAEHo +g8EAIAE2AgBBhITBAEH4g8EANgIAQYyEwQBBgITBADYCAEGAhMEAQfiDwQA2AgBBlITBAEGIhMEA +NgIAQYiEwQBBgITBADYCAEGchMEAQZCEwQA2AgBBkITBAEGIhMEANgIAQaSEwQBBmITBADYCAEGY +hMEAQZCEwQA2AgBBrITBAEGghMEANgIAQaCEwQBBmITBADYCAEG0hMEAQaiEwQA2AgBBqITBAEGg +hMEANgIAQbyEwQBBsITBADYCAEGwhMEAQaiEwQA2AgBBxITBAEG4hMEANgIAQbiEwQBBsITBADYC +AEHAhMEAQbiEwQA2AgBBzITBAEHAhMEANgIAQciEwQBBwITBADYCAEHUhMEAQciEwQA2AgBB0ITB +AEHIhMEANgIAQdyEwQBB0ITBADYCAEHYhMEAQdCEwQA2AgBB5ITBAEHYhMEANgIAQeCEwQBB2ITB +ADYCAEHshMEAQeCEwQA2AgBB6ITBAEHghMEANgIAQfSEwQBB6ITBADYCAEHwhMEAQeiEwQA2AgBB +/ITBAEHwhMEANgIAQfiEwQBB8ITBADYCAEGEhcEAQfiEwQA2AgBBjIXBAEGAhcEANgIAQYCFwQBB ++ITBADYCAEGUhcEAQYiFwQA2AgBBiIXBAEGAhcEANgIAQZyFwQBBkIXBADYCAEGQhcEAQYiFwQA2 +AgBBpIXBAEGYhcEANgIAQZiFwQBBkIXBADYCAEGshcEAQaCFwQA2AgBBoIXBAEGYhcEANgIAQbSF +wQBBqIXBADYCAEGohcEAQaCFwQA2AgBBvIXBAEGwhcEANgIAQbCFwQBBqIXBADYCAEHEhcEAQbiF +wQA2AgBBuIXBAEGwhcEANgIAQcyFwQBBwIXBADYCAEHAhcEAQbiFwQA2AgBB1IXBAEHIhcEANgIA +QciFwQBBwIXBADYCAEHchcEAQdCFwQA2AgBB0IXBAEHIhcEANgIAQeSFwQBB2IXBADYCAEHYhcEA +QdCFwQA2AgBB7IXBAEHghcEANgIAQeCFwQBB2IXBADYCAEH0hcEAQeiFwQA2AgBB6IXBAEHghcEA +NgIAQfyFwQBB8IXBADYCAEHwhcEAQeiFwQA2AgBBlIbBACABQQ9qQXhxIgBBCGsiAjYCAEH4hcEA +QfCFwQA2AgBBjIbBACAEQShrIgMgASAAa2pBCGoiADYCACACIABBAXI2AgQgASADakEoNgIEQaCG +wQBBgICAATYCAAwICyACIANJIAEgAk1yDQAgACgCDCIDQQFxDQAgA0EBdiAGRg0DC0GkhsEAQaSG +wQAoAgAiACABIAAgAUkbNgIAIAEgBGohA0Hog8EAIQACQAJAA0AgAyAAKAIAIgdHBEAgACgCCCIA +DQEMAgsLIAAoAgwiA0EBcQ0AIANBAXYgBkYNAQtB6IPBACEAA0ACQCACIAAoAgAiA08EQCACIAMg +ACgCBGoiB0kNAQsgACgCCCEADAELC0GUhsEAIAFBD2pBeHEiAEEIayIDNgIAQYyGwQAgBEEoayIJ +IAEgAGtqQQhqIgA2AgAgAyAAQQFyNgIEIAEgCWpBKDYCBEGghsEAQYCAgAE2AgAgAiAHQSBrQXhx +QQhrIgAgACACQRBqSRsiA0EbNgIEQeiDwQApAgAhCiADQRBqQfCDwQApAgA3AgAgAyAKNwIIQfSD +wQAgBjYCAEHsg8EAIAQ2AgBB6IPBACABNgIAQfCDwQAgA0EIajYCACADQRxqIQADQCAAQQc2AgAg +AEEEaiIAIAdJDQALIAIgA0YNByADIAMoAgRBfnE2AgQgAiADIAJrIgBBAXI2AgQgAyAANgIAIABB +gAJPBEAgAiAAEFMMCAsgAEH4AXFB+IPBAGohAQJ/QYCGwQAoAgAiA0EBIABBA3Z0IgBxRQRAQYCG +wQAgACADcjYCACABDAELIAEoAggLIQAgASACNgIIIAAgAjYCDCACIAE2AgwgAiAANgIIDAcLIAAg +ATYCACAAIAAoAgQgBGo2AgQgAUEPakF4cUEIayICIAVBA3I2AgQgB0EPakF4cUEIayIEIAIgBWoi +AGshBSAEQZSGwQAoAgBGDQMgBEGQhsEAKAIARg0EIAQoAgQiAUEDcUEBRgRAIAQgAUF4cSIBEEsg +ASAFaiEFIAEgBGoiBCgCBCEBCyAEIAFBfnE2AgQgACAFQQFyNgIEIAAgBWogBTYCACAFQYACTwRA +IAAgBRBTDAYLIAVB+AFxQfiDwQBqIQECf0GAhsEAKAIAIgNBASAFQQN2dCIEcUUEQEGAhsEAIAMg +BHI2AgAgAQwBCyABKAIICyEDIAEgADYCCCADIAA2AgwgACABNgIMIAAgAzYCCAwFC0GMhsEAIAAg +BWsiATYCAEGUhsEAQZSGwQAoAgAiACAFaiICNgIAIAIgAUEBcjYCBCAAIAVBA3I2AgQgAEEIagwI +C0GQhsEAKAIAIQACQCABIAVrIgJBD00EQEGQhsEAQQA2AgBBiIbBAEEANgIAIAAgAUEDcjYCBCAA +IAFqIgEgASgCBEEBcjYCBAwBC0GIhsEAIAI2AgBBkIbBACAAIAVqIgM2AgAgAyACQQFyNgIEIAAg +AWogAjYCACAAIAVBA3I2AgQLIABBCGoMBwsgACAEIAdqNgIEQZSGwQBBlIbBACgCACIAQQ9qQXhx +IgFBCGsiAjYCAEGMhsEAQYyGwQAoAgAgBGoiAyAAIAFrakEIaiIBNgIAIAIgAUEBcjYCBCAAIANq +QSg2AgRBoIbBAEGAgIABNgIADAMLQZSGwQAgADYCAEGMhsEAQYyGwQAoAgAgBWoiATYCACAAIAFB +AXI2AgQMAQtBkIbBACAANgIAQYiGwQBBiIbBACgCACAFaiIBNgIAIAAgAUEBcjYCBCAAIAFqIAE2 +AgALIAJBCGoMAwtBAEGMhsEAKAIAIgAgBU0NAhpBjIbBACAAIAVrIgE2AgBBlIbBAEGUhsEAKAIA +IgAgBWoiAjYCACACIAFBAXI2AgQgACAFQQNyNgIEIABBCGoMAgtBhIbBAEGEhsEAKAIAQX4gAigC +HHdxNgIACwJAIARBEE8EQCACIAVBA3I2AgQgAiAFaiIAIARBAXI2AgQgACAEaiAENgIAIARBgAJP +BEAgACAEEFMMAgsgBEH4AXFB+IPBAGohAQJ/QYCGwQAoAgAiA0EBIARBA3Z0IgRxRQRAQYCGwQAg +AyAEcjYCACABDAELIAEoAggLIQMgASAANgIIIAMgADYCDCAAIAE2AgwgACADNgIIDAELIAIgBCAF +aiIAQQNyNgIEIAAgAmoiACAAKAIEQQFyNgIECyACQQhqCyAIQRBqJAAL1QwCDX8BfiMAQaACayIH +JAACQAJAAkACQAJAIAFBgAhNBEAgB0EANgKIASABIAFBACABQYAIRxsiDGsiDkGACE8EQCAHQQE2 +AogBIAcgADYCjAFBASEKCyAHQYwBaiELIAMhFCAFIQEjAEEgayIIJAAgBkEFdiIJIAogCSAKSRsi +DQRAIARBAnIhDyAEQQFyIRADQCALKAIAIQkgCEEYaiIRIAJBGGopAgA3AwAgCEEQaiISIAJBEGop +AgA3AwAgCEEIaiITIAJBCGopAgA3AwAgCCACKQIANwMAIAggCUHAACAUIBAQJyAIIAlBQGtBwAAg +FCAEECcgCCAJQYABakHAACAUIAQQJyAIIAlBwAFqQcAAIBQgBBAnIAggCUGAAmpBwAAgFCAEECcg +CCAJQcACakHAACAUIAQQJyAIIAlBgANqQcAAIBQgBBAnIAggCUHAA2pBwAAgFCAEECcgCCAJQYAE +akHAACAUIAQQJyAIIAlBwARqQcAAIBQgBBAnIAggCUGABWpBwAAgFCAEECcgCCAJQcAFakHAACAU +IAQQJyAIIAlBgAZqQcAAIBQgBBAnIAggCUHABmpBwAAgFCAEECcgCCAJQYAHakHAACAUIAQQJyAI +IAlBwAdqQcAAIBQgDxAnIAFBGGogESkDADcAACABQRBqIBIpAwA3AAAgAUEIaiATKQMANwAAIAEg +CCkDADcAACALQQRqIQsgAUEgaiEBIBRCAXwhFCANQQFrIg0NAAsLIAhBIGokACAMRQ0BIAdByAFq +QgA3AwAgB0HAAWpCADcDACAHQbgBakIANwMAIAdBsAFqQgA3AwAgB0GoAWpCADcDACAHQaABakIA +NwMAIAdBmAFqQgA3AwAgB0HYAWoiASACQQhqKQIANwMAIAdB4AFqIgggAkEQaikCADcDACAHQegB +aiIJIAJBGGopAgA3AwAgB0IANwOQASAHIAQ6APoBIAdBADsB+AEgByACKQIANwPQASAHIAMgCq18 +NwPwASAHQZABaiAAIA5qIAwQRCEAIAdB0ABqIAEpAwA3AwAgB0HYAGogCCkDADcDACAHQeAAaiAJ +KQMANwMAIAdBEGogAEEIaikDADcDACAHQRhqIABBEGopAwA3AwAgB0EgaiAAQRhqKQMANwMAIAdB +KGogAEEgaikDADcDACAHQTBqIABBKGopAwA3AwAgB0E4aiAAQTBqKQMANwMAIAdBQGsgAEE4aikD +ADcDACAHIAcpA9ABNwNIIAcgACkDADcDCCAHLQD6ASEAIActAPkBIQIgByAHLQD4ASIEOgBwIAcg +BykD8AEiAzcDaCAHIAAgAkVyQQJyIgA6AHEgB0GYAmoiAiAJKQMANwMAIAdBkAJqIgkgCCkDADcD +ACAHQYgCaiIIIAEpAwA3AwAgByAHKQPQATcDgAIgB0GAAmogB0EIaiAEIAMgABAnIApBBXQiAEEg +aiIBIAZLDQIgAigCACEBIAkoAgAhAiAIKAIAIQQgBygClAIhBiAHKAKMAiEIIAcoAoQCIQkgBygC +gAIhCyAAIAVqIgAgBygCnAI2ABwgACABNgAYIAAgBjYAFCAAIAI2ABAgACAINgAMIAAgBDYACCAA +IAk2AAQgACALNgAAIApBAWohCgwBCyABQn8gAa1CAXxCAYhCAX15iKciCE0NAiAHQQhqIglBAEGA +AfwLACAAIAhBAWoiCCACIAMgBCAJQSBBwAAgCEGACEYbIgoQKSELIAAgCGogASAIayACIAMgCEEK +dq18IAQgCSAKakGAASAKaxApIAtBAUYEQCAGQT9NDQQgBSAHKQAINwAAIAVBOGogB0FAaykAADcA +ACAFQTBqIAdBOGopAAA3AAAgBUEoaiAHQTBqKQAANwAAIAVBIGogB0EoaikAADcAACAFQRhqIAdB +IGopAAA3AAAgBUEQaiAHQRhqKQAANwAAIAVBCGogB0EQaikAADcAAEECIQoMAQsgC2pBBXQiAEGB +AU8NBCAHQQhqIAAgAiAEIAUgBhA/IQoLIAdBoAJqJAAgCg8LIAEgBkHou8AAENEBAAsgB0EANgIY +IAdBATYCDCAHQfC6wAA2AgggB0IENwIQIAdBCGpBuLzAABCeAQALQcAAIAZByLzAABDRAQALIABB +gAFB2LzAABDRAQAL8ggCBX8DfgJAAkACQCABQQhPBEAgAUEHcSICRQ0BIAAoAqABIgNBKU8NAiAD +RQRAIABBADYCoAEMAgsgA0EBa0H/////A3EiBUEBaiIEQQNxIQYgAkECdEHw5cAAaigCACACdq0h +CQJAIAVBA0kEQCAAIQIMAQsgBEH8////B3EhBSAAIQIDQCACIAI1AgAgCX4gCHwiBz4CACACQQRq +IgQgBDUCACAJfiAHQiCIfCIHPgIAIAJBCGoiBCAENQIAIAl+IAdCIIh8Igc+AgAgAkEMaiIEIAQ1 +AgAgCX4gB0IgiHwiBz4CACAHQiCIIQggAkEQaiECIAVBBGsiBQ0ACwsgBgRAA0AgAiACNQIAIAl+ +IAh8Igc+AgAgAkEEaiECIAdCIIghCCAGQQFrIgYNAAsLIAAgB0KAgICAEFoEfyADQShGDQQgACAD +QQJ0aiAIPgIAIANBAWoFIAMLNgKgAQwBCyAAKAKgASIDQSlPDQEgA0UEQCAAQQA2AqABDwsgAUEC +dEHw5cAAajUCACEJIANBAWtB/////wNxIgFBAWoiAkEDcSEGAkAgAUEDSQRAIAAhAgwBCyACQfz/ +//8HcSEFIAAhAgNAIAIgAjUCACAJfiAIfCIHPgIAIAJBBGoiASABNQIAIAl+IAdCIIh8Igc+AgAg +AkEIaiIBIAE1AgAgCX4gB0IgiHwiBz4CACACQQxqIgEgATUCACAJfiAHQiCIfCIHPgIAIAdCIIgh +CCACQRBqIQIgBUEEayIFDQALCyAGBEADQCACIAI1AgAgCX4gCHwiBz4CACACQQRqIQIgB0IgiCEI +IAZBAWsiBg0ACwsgACAHQoCAgIAQWgR/IANBKEYNAyAAIANBAnRqIAg+AgAgA0EBagUgAws2AqAB +DwsCQCABQQhxBEAgACgCoAEiA0EpTw0CAkAgA0UEQEEAIQMMAQsgA0EBa0H/////A3EiAkEBaiIF +QQNxIQYCQCACQQNJBEBCACEHIAAhAgwBCyAFQfz///8HcSEFQgAhByAAIQIDQCACIAI1AgBC4esX +fiAHfCIHPgIAIAJBBGoiBCAENQIAQuHrF34gB0IgiHwiBz4CACACQQhqIgQgBDUCAELh6xd+IAdC +IIh8Igc+AgAgAkEMaiIEIAQ1AgBC4esXfiAHQiCIfCIIPgIAIAhCIIghByACQRBqIQIgBUEEayIF +DQALCyAGBEADQCACIAI1AgBC4esXfiAHfCIIPgIAIAJBBGohAiAIQiCIIQcgBkEBayIGDQALCyAI +QoCAgIAQVA0AIANBKEYNAiAAIANBAnRqIAc+AgAgA0EBaiEDCyAAIAM2AqABCyABQRBxBEAgAEHk +0sAAQQIQMgsgAUEgcQRAIABB7NLAAEEDEDILIAFBwABxBEAgAEH40sAAQQUQMgsgAUGAAXEEQCAA +QYzTwABBChAyCyABQYACcQRAIABBtNPAAEETEDILIAAgARAsGg8LDAELIANBKEHs/MAAENEBAAtB +KEEoQez8wAAQfQALtwgCDH8BfiMAQcABayICJAAgASgCECEDIAIgAUEQaiIENgIgIAIgAzYCHCAC +IAJBvwFqIgY2AhggAkGAAWoiBSABIAJBGGoiBxBIAkACQAJAIAIpA4ABIg5CAlENACACQfgAaiID +IAJBqAFqKQMANwMAIAJB8ABqIgggAkGgAWopAwA3AwAgAkHoAGoiCSACQZgBaikDADcDACACQeAA +aiIKIAJBkAFqKQMANwMAIAIgAikDiAE3A1ggDqdBAXFFDQAgAkHQAGoiCyADKQMANwMAIAJByABq +IgwgCCkDADcDACACQUBrIg0gCSkDADcDACACQThqIgggCikDADcDACACIAIpA1g3AzBB+YHBAC0A +ABpBoAFBCBDAASIDRQ0CIAMgAikDMDcDACADQSBqIAspAwA3AwAgA0EYaiAMKQMANwMAIANBEGog +DSkDADcDACADQQhqIAgpAwA3AwAgAkEBNgIUIAIgAzYCECACQQQ2AgwgAkEoaiIJIAQoAgAiBDYC +ACACQSBqIAFBCGopAgA3AwAgAiABKQIANwMYIAIgCTYCuAEgAiAENgK0ASACIAY2ArABIAUgByAC +QbABahBIAkAgAikDgAEiDkICUQ0AIAJBiAFqIQRBKCEBQQEhBgNAIAJB+ABqIgUgBEEgaikDADcD +ACACQfAAaiIHIARBGGopAwA3AwAgAkHoAGoiCiAEQRBqKQMANwMAIAJB4ABqIg0gBEEIaikDADcD +ACACIAQpAwA3A1ggDqdBAXFFDQEgCyAFKQMANwMAIAwgBykDADcDACACQUBrIgcgCikDADcDACAI +IA0pAwA3AwAgAiACKQNYNwMwIAIoAgwgBkYEQCACQQxqIAZBAUEIQSgQVSACKAIQIQMLIAEgA2oi +BSACKQMwNwMAIAVBIGogCykDADcDACAFQRhqIAwpAwA3AwAgBUEQaiAHKQMANwMAIAVBCGogCCkD +ADcDACACIAZBAWoiBjYCFCACKAIoIQUgAiAJNgK4ASACIAU2ArQBIAFBKGohASACIAJBvwFqNgKw +ASACQYABaiACQRhqIAJBsAFqEEggAikDgAEiDkICUg0ACwsgAigCJCIBIAIoAhwiA0cEQCABIANr +QQR2IQQDQCADKAIAIgEEQCADQQRqKAIAIAEQzAELIANBEGohAyAEQQFrIgQNAAsLIAIoAiAiAQRA +IAIoAhggAUEEdBDMAQsgACACKQIMNwIAIABBCGogAkEUaigCADYCAAwBCyAAQQA2AgggAEKAgICA +gAE3AgAgASgCDCIAIAEoAgQiA0cEQCAAIANrQQR2IQQDQCADKAIAIgAEQCADQQRqKAIAIAAQzAEL +IANBEGohAyAEQQFrIgQNAAsLIAEoAggiAEUNACABKAIAIABBBHQQzAELIAJBwAFqJAAPC0EIQaAB +QeSRwAAQsgEAC8sIAQh/AkAgAUGACkkEQCABQQV2IQcCQAJAIAAoAqABIgUEQCAFQQFrIQMgBUEC +dCAAakEEayECIAUgB2pBAnQgAGpBBGshBiAFQSlJIQUDQCAFRQ0CIAMgB2oiBEEoTw0DIAYgAigC +ADYCACAGQQRrIQYgAkEEayECIANBAWsiA0F/Rw0ACwsgAUEgSQ0DIABBADYCACAHQQFqIgJBAkYN +AyAAQQA2AgQgAkEDRg0DIABBADYCCCACQQRGDQMgAEEANgIMIAJBBUYNAyAAQQA2AhAgAkEGRg0D +IABBADYCFCACQQdGDQMgAEEANgIYIAJBCEYNAyAAQQA2AhwgAkEJRg0DIABBADYCICACQQpGDQMg +AEEANgIkIAJBC0YNAyAAQQA2AiggAkEMRg0DIABBADYCLCACQQ1GDQMgAEEANgIwIAJBDkYNAyAA +QQA2AjQgAkEPRg0DIABBADYCOCACQRBGDQMgAEEANgI8IAJBEUYNAyAAQQA2AkAgAkESRg0DIABB +ADYCRCACQRNGDQMgAEEANgJIIAJBFEYNAyAAQQA2AkwgAkEVRg0DIABBADYCUCACQRZGDQMgAEEA +NgJUIAJBF0YNAyAAQQA2AlggAkEYRg0DIABBADYCXCACQRlGDQMgAEEANgJgIAJBGkYNAyAAQQA2 +AmQgAkEbRg0DIABBADYCaCACQRxGDQMgAEEANgJsIAJBHUYNAyAAQQA2AnAgAkEeRg0DIABBADYC +dCACQR9GDQMgAEEANgJ4IAJBIEYNAyAAQQA2AnwgAkEhRg0DIABBADYCgAEgAkEiRg0DIABBADYC +hAEgAkEjRg0DIABBADYCiAEgAkEkRg0DIABBADYCjAEgAkElRg0DIABBADYCkAEgAkEmRg0DIABB +ADYClAEgAkEnRg0DIABBADYCmAEgAkEoRg0DIABBADYCnAEgAkEpRg0DQShBKEHs/MAAEH0ACyAD +QShB7PzAABB9AAsgBEEoQez8wAAQfQALQZb9wABBHUHs/MAAEJIBAAsgACgCoAEiAyAHaiECIAFB +H3EiBkUEQCAAIAI2AqABIAAPCwJAIAJBAWsiBEEnTQRAIAIhBSAAIARBAnRqKAIAQQAgAWsiAXYi +BEUNASACQSdNBEAgACACQQJ0aiAENgIAIAJBAWohBQwCCyACQShB7PzAABB9AAsgBEEoQez8wAAQ +fQALAkAgB0EBaiIIIAJPDQAgAUEfcSEBIANBAXFFBEAgACACQQFrIgJBAnRqIgQgBCgCACAGdCAE +QQRrKAIAIAF2cjYCAAsgA0ECRg0AIAJBAnQgAGpBDGshAwNAIANBCGoiBCAEKAIAIAZ0IANBBGoi +BCgCACIJIAF2cjYCACAEIAkgBnQgAygCACABdnI2AgAgA0EIayEDIAggAkECayICSQ0ACwsgACAH +QQJ0aiIBIAEoAgAgBnQ2AgAgACAFNgKgASAAC/8JAwx/AX4Bb0GohMAAIQMjAEHQAGsiAiQAIAIg +ATYCDAJAAkACQAJAIAEQ7AFBAUYEQCACIAE2AiAgAkEANgIQIAJBqITAADYCGCACQbiEwAA2Ahwg +AkEgaiEKQYCAgIB4IQEDQCACIANBCGo2AhggAiADKAIAIAMoAgQQPDYCOCAKKAIAJQEgAkE4aigC +ACUBEAwhDxBtIgUgDyYBAkACQAJAAkACQAJAIAUlARADQQFGBEAgAigCOCUBIAIoAiAlARAEQQFH +DQELAkAgAigCEEUNACACKAIUIgdBhAFJDQAgBxBqCyACIAU2AhQgAkEBNgIQIAMoAgAhBQJ/AkAC +QAJAIAMoAgRBBGsOAwECAAILQQAhB0EGIQhBoITAACEDAkADQCAFLQAAIgsgAy0AACIMRgRAIAVB +AWohBSADQQFqIQMgCEEBayIIDQEMAgsLIAsgDGshBwsgBw0BQQEMAgtBACAFKAAAQZyEwAAoAABG +DQEaC0ECCyACKAI4IgVBgwFLBEAgBRBqC0EBaw4CAwECCyAFQYQBTwRAIAUQagsgAigCOCIDQYQB +TwRAIAMQagsgAigCGCIDIAIoAhxHDQUMBwsgAigCECACQQA2AhBBAUYEQCACKAIUIgNBhAFJDQQg +AxBqDAQLDAkLIAFBgICAgHhHBEBBwYrAAEEEEIIBIQQMAgsgAigCECACQQA2AhBFDQggAiACKAIU +IgM2AjggAiADEOgBAn8gAigCACIGBEAgAigCBCINDAELIAJBOGogAkHPAGpB4InAABBAIQZBgICA +gHgLIQEgA0GEAU8EQCADEGoLIAFBgICAgHhHDQIgAEGAgICAeDYCACAAIAY2AgQMBgsgCUUEQCAC +KAIQIAJBADYCEEEBRw0IIAIgAigCFDYCJCACQShqIgQgAkEkaiIDKAIAJQEQHQR+IAQgAygCACUB +EAn8BjcDCEIBBUIACzcDAAJ/AkAgAigCKEEBRgRAIAIpAzAiDkIAWQ0BCyACQSRqIAJBzwBqQcCI +wAAQQCEEQQEMAQsgDkKAgICAEFoEQCACQQE6ADggAiAONwNAIwBBMGsiAyQAIANBwIjAADYCBCAD +IAJBzwBqNgIAIANBAjYCDCADQeyOwAA2AgggA0ICNwIUIAMgA61CgICAgNABhDcDKCADIAJBOGqt +QoCAgIDgAYQ3AyAgAyADQSBqNgIQIANBCGoQYCEEIANBMGokAEEBDAELIA6nIQRBAAsgAigCJCIF +QYQBTwRAIAUQagtBASEJRQ0CDAELQcWKwABBBhCCASEECyAAQYCAgIB4NgIAIAAgBDYCBCABQYCA +gIB4ckGAgICAeEYNBCAGIAEQzAEMBAsgAigCGCIDIAIoAhxHDQALDAELIAJBDGogAkHPAGpB8InA +ABBAIQQgAEGAgICAeDYCACAAIAQ2AgQgAUGEAUkNAiABEGoMAgsgAUGAgICAeEcEQCAJBEAgACAE +NgIMIAAgDTYCCCAAIAY2AgQgACABNgIADAILQcWKwABBBhCBASEEIABBgICAgHg2AgAgACAENgIE +IAFFDQEgBiABEMwBDAELQcGKwABBBBCBASEBIABBgICAgHg2AgAgACABNgIECyACKAIgIgBBhAFP +BEAgABBqCyACKAIQRQ0AIAIoAhQiAEGDAU0NACAAEGoLIAJB0ABqJAAPC0GQisAAQTEQ4QEAC7ML +AwZ/AX4BbyMAQdAAayICJAAgAiABNgIgAkACQAJAAkACQCACQSBqIgEoAgAlARAbBEAgAkEkaiID +IAEoAgAlARAPNgIIIANBADYCBCADIAE2AgBBACEBIAJBADYCMCACKAIkBEAgAigCLCIDIAIoAigi +BE0EQEEEIQMMAwtB+YHBAC0AABpBgIAEIAMgBGsiAUEAIAEgA00bIgEgAUGAgARPGyIBQQR0IgRB +BBDAASIDDQJBBCAEQcCJwAAQsgEACyACQQA2AjwgAkKAgICAwAA3AjQMAgsgAkFAayEBEBYhCRBt +IgMgCSYBIAMhBSACQSBqKAIAIgQlASADJQEQFyEJEG0iAyAJJgFB0ILBACgCACEGQcyCwQAoAgAh +B0HMgsEAQgA3AgACQAJAAkAgB0EBRgRAIAFBAzoABCABIAY2AgAMAQsCQCADEO0BQQFGBEAgAyUB +IAQlARAYIQkQbSIEIAkmAUHQgsEAKAIAIQZBzILBACgCACEHQcyCwQBCADcCAAJAIAdBAUYEQCAB +QQM6AAQgASAGNgIADAELAkAgBBDsAUEBRw0AIAQlARASIQkQbSIGIAkmASAGEO0BIAZBhAFPBEAg +BhBqC0EBRw0AIAFBADoABCABIAQ2AgAgA0GEAU8EQCADEGoLIAVBhAFJDQYMBQsgAUECOgAEIARB +hAFJDQAgBBBqCyADQYQBTw0BDAILIAFBAjoABCADQYQBSQ0BCyADEGoLIAVBgwFNDQELIAUQagsg +AigCQCEBAkACQAJAIAItAEQiA0ECaw4CAgABCyAAQYCAgIB4NgIAIAAgATYCBCACKAIgIgFBgwFL +DQUMBgsgAiADOgA4IAIgATYCNCACQQA2AiwgAkKAgICAwAA3AiQgAkEYaiACQTRqEHgCQCACKAIY +IgNBAkcEQCACKAIcIQEDQAJAIANBAXFFBEAgAkFAayABEC0gAigCRCEBIAIoAkAiBUGAgICAeEcN +AQsgAEGAgICAeDYCACAAIAE2AgQgAigCLCIDBEAgAigCKCEBA0AgASgCACIABEAgAUEEaigCACAA +EMwBCyABQRBqIQEgA0EBayIDDQALCyACKAIkIgAEQCACKAIoIABBBHQQzAELIAIoAjQiAUGDAUsN +AwwHCyACKQJIIQggAigCLCIDIAIoAiRGBEAgAkEkahBmCyACKAIoIANBBHRqIgQgCDcCCCAEIAE2 +AgQgBCAFNgIAIAIgA0EBajYCLCACQRBqIAJBNGoQeCACKAIUIQEgAigCECIDQQJHDQALCyAAIAIp +AiQ3AgAgAEEIaiACQSxqKAIANgIAIAIoAjQiAUGDAU0NBAsgARBqDAMLIAJBIGogAkFAa0GAisAA +EEAhASAAQYCAgIB4NgIAIAAgATYCBAwCCyACQQA2AjwgAiADNgI4IAIgATYCNANAIAJBCGohAyAC +QSRqIgEoAgQiBCABKAIITwR/QQAFIAEgBEEBajYCBCABKAIAKAIAJQEgBBAOIQkQbSIBIAkmAUEB +CyEEIAMgATYCBCADIAQ2AgAgAigCCEEBcUUNASACKAIMIQEgAiACKAIwQQFqNgIwIAJBQGsgARAt +IAIoAkQhASACKAJAIgVBgICAgHhGBEAgAEGAgICAeDYCACAAIAE2AgQgAigCPCIDBEAgAigCOCEB +A0AgASgCACIABEAgAUEEaigCACAAEMwBCyABQRBqIQEgA0EBayIDDQALCyACKAI0IgBFDQMgAigC +OCAAQQR0EMwBDAMLIAIpAkghCCACKAI8IgMgAigCNEYEQCACQTRqEGYLIAIoAjggA0EEdGoiBCAI +NwIIIAQgATYCBCAEIAU2AgAgAiADQQFqNgI8IAIoAiQNAAsLIAAgAikCNDcCACAAQQhqIAJBPGoo +AgA2AgALIAIoAiAiAUGDAU0NAQsgARBqCyACQdAAaiQAC88GAQh/AkACQCABIABBA2pBfHEiAyAA +ayIISQ0AIAEgCGsiBkEESQ0AIAZBA3EhB0EAIQECQCAAIANGIgkNAAJAIAAgA2siBUF8SwRAQQAh +AwwBC0EAIQMDQCABIAAgA2oiAiwAAEG/f0pqIAJBAWosAABBv39KaiACQQJqLAAAQb9/SmogAkED +aiwAAEG/f0pqIQEgA0EEaiIDDQALCyAJDQAgACADaiECA0AgASACLAAAQb9/SmohASACQQFqIQIg +BUEBaiIFDQALCyAAIAhqIQACQCAHRQ0AIAAgBkF8cWoiAywAAEG/f0ohBCAHQQFGDQAgBCADLAAB +Qb9/SmohBCAHQQJGDQAgBCADLAACQb9/SmohBAsgBkECdiEFIAEgBGohBANAIAAhAyAFRQ0CQcAB +IAUgBUHAAU8bIgZBA3EhByAGQQJ0IQhBACECIAVBBE8EQCAAIAhB8AdxaiEJIAAhAQNAIAEoAgAi +AEF/c0EHdiAAQQZ2ckGBgoQIcSACaiABQQRqKAIAIgBBf3NBB3YgAEEGdnJBgYKECHFqIAFBCGoo +AgAiAEF/c0EHdiAAQQZ2ckGBgoQIcWogAUEMaigCACIAQX9zQQd2IABBBnZyQYGChAhxaiECIAFB +EGoiASAJRw0ACwsgBSAGayEFIAMgCGohACACQQh2Qf+B/AdxIAJB/4H8B3FqQYGABGxBEHYgBGoh +BCAHRQ0ACwJ/IAMgBkH8AXFBAnRqIgAoAgAiAUF/c0EHdiABQQZ2ckGBgoQIcSIBIAdBAUYNABog +ASAAKAIEIgFBf3NBB3YgAUEGdnJBgYKECHFqIgEgB0ECRg0AGiAAKAIIIgBBf3NBB3YgAEEGdnJB +gYKECHEgAWoLIgFBCHZB/4EccSABQf+B/AdxakGBgARsQRB2IARqDwsgAUUEQEEADwsgAUEDcSED +AkAgAUEESQRADAELIAFBfHEhBQNAIAQgACACaiIBLAAAQb9/SmogAUEBaiwAAEG/f0pqIAFBAmos +AABBv39KaiABQQNqLAAAQb9/SmohBCAFIAJBBGoiAkcNAAsLIANFDQAgACACaiEBA0AgBCABLAAA +Qb9/SmohBCABQQFqIQEgA0EBayIDDQALCyAEC5QIAgt/A34jAEHgAGsiBCQAIAKtQih+Ig6nIQMC +QCAOQiCIpyADQfj///8HS3INAAJ/IANFBEBBCCEGQQAMAQtB+YHBAC0AABpBCCEHIANBCBDAASIG +RQ0BIAILIQsgAwRAIAYgASAD/AoAAAsgAkECTwRAIAZB0ABqIQwgBEHcAGqtQoCAgIAQhCEOIARB +2ABqrUKAgICAIIQhDwNAQQAhA0EAIQUCQAJAAkACQAJAAkADQCADIQogAiAFSQ0FIAVBKGwhCQJA +IAIgBWsiAUEDSQ0AQQkgASABQQlPGyEIIAkgDGohA0ECIQEDQCABIAhGBEAgCCEBDAILIAFBAWoh +ASADQgQQrgEgA0EoaiEDQgBSDQALCyABIAVqIgggAUkNASACIAhJDQJBvILBACEFQbiCwQAoAgBF +BEACf0H5gcEALQAAGkGACEEBEMABIgMEQEHIgsEAQQA2AgBBvILBAEEANgIAQcSCwQAoAgAhBUHE +gsEAIAM2AgBBwILBACgCACEDQcCCwQBBgAg2AgBBuILBACgCAEG4gsEAQQE2AgBFIANFckUEQCAF +IAMQzAELQbyCwQAMAQtBAUGACEGojsAAELIBAAshBQsgBSgCAA0DQQAhAyAFQQA2AgwgBUF/NgIA +QQAhByABBEAgBUEEaiENIAYgCWoiAyABQShsaiEJA0AgBCADNgJYIAQgA0EgaiIBNgJcIARBAzYC +NCAEQdiLwAA2AjAgBEICNwI8IAQgDjcDECAEIA83AwggBCAEQQhqNgI4IA1BwI/AACAEQTBqEDsN +BiABKAIAIAdqIQcgAUEIaiIDIAlHDQALIAUoAgwhAwsgBEEwakG8usAAIAUoAgggAxAzIARB0ABq +IgEgBzYCACAFIAUoAgBBAWo2AgAgBEEQaiIDIARBOGopAwA3AwAgBEEYaiIFIARBQGspAwA3AwAg +BEEgaiIHIARByABqKQMANwMAIARBKGoiCSABKQMANwMAIAQgBCkDMDcDCCACIApLBEAgBiAKQShs +aiIBIAQpAwg3AwAgAUEgaiAJKQMANwMAIAFBGGogBykDADcDACABQRBqIAUpAwA3AwAgAUEIaiAD +KQMANwMAIApBAWohAyAIIgUgAkYNBwwBCwsgCiACQfyAwAAQfQALIAUgCEHsgMAAENIBAAsgCCAC +QeyAwAAQ0QEAC0GkjcAAEIoBAAtBgIzAAEErIARBMGpB8IvAAEGUjcAAEHoACyAFIAJBjIHAABDQ +AQALIAMhAiAKDQALCyAAIAYpAwA3AwAgAEEYaiAGQRhqKQMANwMAIABBEGogBkEQaikDADcDACAA +QQhqIAZBCGopAwA3AwAgBiALQShsEMwBIARB4ABqJAAPCyAHIANBjITAABCyAQALyQcCCn8CfiMA +QTBrIgYkAAJAAkACQAJAAkACQAJAIANFDQACfyABKAIYIgcgASgCKCIFQUBrTQRAIAEoAhwgBWsi +ByADIAMgB0sbIQhBACEHIAFBHGoMAQsgASgCHCAFayIJIAMgAyAJSxshCCAJIAMgByAFa0HBAGsi +ByADIAdJGyIHSQ0CIAUgB2ohBSABQRxqCyEJIAZBCGohCiACIAdqIQ0gCCAHayELIAEpAxAhEEEA +IQggASkDACEPIAEoAgghDgNAAkAgCCALRgRAQQAhDAwBCyABIA4gCCANai0AAEEDdGopAwAgD0IB +hnwiDzcDAEEBIQwgCEEBaiEIIA8gEINCAFINAQsLIAogCDYCBCAKIAw2AgACQAJAIAYoAghBAXEE +QCAJKAIAIgggBigCDCIEIAVqTQ0BDAILIAkoAgAiCCAFIAtqSw0CCyAIIAVrIQQLIAFCADcDACAE +IAdqIQUgASgCKCIHRQRAIAMgBUkNAyAGQSBqIAIgBRB1DAYLIAMgBUkNAyABQSBqIQMgASgCICAH +ayAFSQRAIAMgByAFEFYgASgCKCEHCyAFBEAgASgCJCAHaiACIAX8CgAACyABIAUgB2o2AiggBkEY +aiADQQhqKAIANgIAIAFBADYCKCADKQIAIQ8gAUKAgICAEDcDICAGIA83AxAgBkEgaiAGQRBqEHIM +BQsgBEUEQCABKAIgIAEoAigiBWsgA0kEQCABQSBqIAUgAxBWIAEoAighBQsgAwRAIAEoAiQgBWog +AiAD/AoAAAsgACADNgIwIABBADYCACABIAMgBWo2AigMBgsgASgCKCIFRQ0DIAFBIGohBCABKAIg +IAVrIANJBEAgBCAFIAMQViABKAIoIQULIAMEQCABKAIkIAVqIAIgA/wKAAALIAEgAyAFajYCKCAG +QRhqIARBCGooAgA2AgAgAUEANgIoIAQpAgAhDyABQoCAgIAQNwMgIAYgDzcDECAGQSBqIAZBEGoQ +ciADIQUMBAsgByAIQdCWwAAQ0gEACyAFIANB4JbAABDRAQALIAUgA0HwlsAAENEBAAsgBkEgaiAC +IAMQdSADIQULIAZBGGogBkEoaikCACIPNwMAIAYgBikCIDcDECAPpyIBRQRAIABBADYCMCAAQQA2 +AgAgBkEcaiAGKAIUQQAgBigCECgCEBEDAAwBCyAGKAIQIQIgBigCHCEDIABBEGpBnLrAACAGKAIU +IgQgARAzIAAgBTYCMCAAIAM2AgwgACABNgIIIAAgBDYCBCAAIAI2AgALIAZBMGokAAvYBQIMfwN+ +IwBBoAFrIgkkACAJQQBBoAH8CwACQAJAAkAgAiAAKAKgASIFTQRAIAVBKU8NASABIAJBAnRqIQwC +QAJAIAUEQCAFQQFqIQ0gBUECdCEKA0AgCSAGQQJ0aiEDA0AgBiECIAMhBCABIAxGDQggA0EEaiED +IAJBAWohBiABKAIAIQcgAUEEaiILIQEgB0UNAAsgB60hEUIAIQ8gCiEHIAIhASAAIQMDQCABQShP +DQQgBCAPIAQ1AgB8IAM1AgAgEX58IhA+AgAgEEIgiCEPIARBBGohBCABQQFqIQEgA0EEaiEDIAdB +BGsiBw0ACyAIIBBCgICAgBBaBH8gAiAFaiIBQShPDQMgCSABQQJ0aiAPPgIAIA0FIAULIAJqIgEg +ASAISRshCCALIQEMAAsACwNAIAEgDEYNBiAEQQFqIQQgASgCACABQQRqIQFFDQAgCCAEQQFrIgIg +AiAISRshCAwACwALIAFBKEHs/MAAEH0ACyABQShB7PzAABB9AAsgBUEpTw0BIAJBAnQhDCACQQFq +IQ0gACAFQQJ0aiEOIAAhAwJAA0AgCSAHQQJ0aiEGA0AgByELIAYhBCADIA5GDQUgBEEEaiEGIAdB +AWohByADKAIAIQogA0EEaiIFIQMgCkUNAAsgCq0hEUIAIQ8gDCEKIAshAyABIQYDQCADQShPDQIg +BCAPIAQ1AgB8IAY1AgAgEX58IhA+AgAgEEIgiCEPIARBBGohBCADQQFqIQMgBkEEaiEGIApBBGsi +Cg0ACwJAIAggEEKAgICAEFoEfyACIAtqIgNBKE8NASAJIANBAnRqIA8+AgAgDQUgAgsgC2oiAyAD +IAhJGyEIIAUhAwwBCwsgA0EoQez8wAAQfQALIANBKEHs/MAAEH0ACyAFQShB7PzAABDRAQALIAVB +KEHs/MAAENEBAAsgACAJQaAB/AoAACAAIAg2AqABIAlBoAFqJAAL5AgCCn8BfiMAQYACayIEJAAg +BCABKQAYNwIYIAQgASkAEDcCECAEIAEpAAg3AgggBCABKQAANwIAAn8gA0GBCE8EQCAEQSBqIQUj +AEHgAGsiASQAIAFBOGoiBkIANwMAIAFBMGoiB0IANwMAIAFBKGoiCEIANwMAIAFBIGoiCUIANwMA +IAFBGGoiCkIANwMAIAFBEGoiC0IANwMAIAFBCGoiDEIANwMAIAFCADcDACACIAMgBEIAQRAgAUHA +ABApIQMgAUHYAGpCADcDACABQdAAakIANwMAIAFByABqQgA3AwAgAUIANwNAAkACQAJAAkAgA0ED +TwRAA0AgA0EFdCICQcEATw0CIAEgAiAEQRAgAUFAayINQSAQPyIDQQV0IgJBwQBPDQMgAkEhTw0E +IAIEQCABIA0gAvwKAAALIANBAksNAAsLIAUgASkDADcAACAFQThqIAYpAwA3AAAgBUEwaiAHKQMA +NwAAIAVBKGogCCkDADcAACAFQSBqIAkpAwA3AAAgBUEYaiAKKQMANwAAIAVBEGogCykDADcAACAF +QQhqIAwpAwA3AAAgAUHgAGokAAwDCyACQcAAQei8wAAQ0QEACyACQcAAQfi8wAAQ0QEACyACQSBB +iL3AABDRAQALIARB+ABqIARBGGopAgA3AwAgBEHwAGogBEEQaikCADcDACAEQegAaiAEQQhqKQIA +NwMAIAQgBCkCADcDYEHAACEDQRQMAQsgBEHIAWpCADcDACAEQcABakIANwMAIARBuAFqQgA3AwAg +BEGwAWpCADcDACAEQagBakIANwMAIARBmAFqQgA3AwAgBEEQOgD6ASAEQaABakIANwMAIARB2AFq +IgUgBEEIaikCADcDACAEQegBaiIGIARBGGopAgA3AwAgBEHgAWoiByAEQRBqKQIANwMAIARCADcD +kAEgBCAEKQIANwPQASAEQQA7AfgBIARCADcD8AEgBEGQAWogAiADEEQhASAEQegAaiAFKQMANwMA +IARB8ABqIAcpAwA3AwAgBEH4AGogBikDADcDACAEQShqIAFBCGopAwA3AwAgBEEwaiABQRBqKQMA +NwMAIARBOGogAUEYaikDADcDACAEQUBrIAFBIGopAwA3AwAgBEHIAGogAUEoaikDADcDACAEQdAA +aiABQTBqKQMANwMAIARB2ABqIAFBOGopAwA3AwAgBCAEKQPQATcDYCAEIAEpAwA3AyAgBCkD8AEh +DiAELQD4ASEDIAQtAPoBIAQtAPkBRXJBAnILIQEgBCAONwOAASAEIAM6AIgBIAQgAToAiQEgBEGo +AWoiAiAEQfgAaikDADcDACAEQaABaiIFIARB8ABqKQMANwMAIARBmAFqIgYgBEHoAGopAwA3AwAg +BCAEKQNgNwOQASAEQZABaiAEQSBqIANCACABQQhyECcgACACKQMANwAYIAAgBSkDADcAECAAIAYp +AwA3AAggACAEKQOQATcAACAEQYACaiQAC74LAQV/IwBBIGsiBCQAAkACQAJAAkACQAJAAkACQAJA +AkACQAJAIAEOKAYBAQEBAQEBAQIEAQEDAQEBAQEBAQEBAQEBAQEBAQEBAQEIAQEBAQcACyABQdwA +Rg0ECyACQQFxRSABQf8FTXINBwJ/AkBBEUEAIAFBr7AETxsiAiACQQhyIgMgAUELdCICIANBAnRB +uIDBAGooAgBBC3RJGyIDIANBBHIiAyADQQJ0QbiAwQBqKAIAQQt0IAJLGyIDIANBAnIiAyADQQJ0 +QbiAwQBqKAIAQQt0IAJLGyIDIANBAWoiAyADQQJ0QbiAwQBqKAIAQQt0IAJLGyIDIANBAWoiAyAD +QQJ0QbiAwQBqKAIAQQt0IAJLGyIDQQJ0QbiAwQBqKAIAQQt0IgUgAkYgAiAFS2ogA2oiA0EhTQRA +IANBAnRBuIDBAGoiBigCAEEVdiECQe8FIQUCfwJAIANBIUYNACAGKAIEQRV2IQUgAw0AQQAMAQsg +BkEEaygCAEH///8AcQshAwJAIAUgAkF/c2pFDQAgASADayEHQe8FIAIgAkHvBU0bIQYgBUEBayED +QQAhBQNAIAIgBkYNAyAFIAJBlMzAAGotAABqIgUgB0sNASADIAJBAWoiAkcNAAsgAyECCyACQQFx +DAILIANBIkGs/MAAEH0ACyAGQe8FQbz8wAAQfQALRQ0HIARBADoACiAEQQA7AQggBCABQRR2Qdfo +wABqLQAAOgALIAQgAUEEdkEPcUHX6MAAai0AADoADyAEIAFBCHZBD3FB1+jAAGotAAA6AA4gBCAB +QQx2QQ9xQdfowABqLQAAOgANIAQgAUEQdkEPcUHX6MAAai0AADoADCABQQFyZ0ECdiICIARBCGoi +A2oiBUH7ADoAACAFQQFrQfUAOgAAIAMgAkECayICakHcADoAACAEQRBqIgMgAUEPcUHX6MAAai0A +ADoAACAAQQo6AAsgACACOgAKIAAgBCkCCDcCACAEQf0AOgARIABBCGogAy8BADsBAAwJCyAAQYAE +OwEKIABCADcBAiAAQdzoATsBAAwICyAAQYAEOwEKIABCADcBAiAAQdzkATsBAAwHCyAAQYAEOwEK +IABCADcBAiAAQdzcATsBAAwGCyAAQYAEOwEKIABCADcBAiAAQdy4ATsBAAwFCyAAQYAEOwEKIABC +ADcBAiAAQdzgADsBAAwECyACQYACcUUNASAAQYAEOwEKIABCADcBAiAAQdzOADsBAAwDCyACQf// +/wdxQYCABE8NAQsCf0EAIAFBIEkNABpBASABQf8ASQ0AGiABQYCABE8EQCABQeD//wBxQeDNCkcg +AUH+//8AcUGe8ApHcSABQcDuCmtBeklxIAFBsJ0La0FySXEgAUHw1wtrQXFJcSABQYDwC2tB3mxJ +cSABQYCADGtBnnRJcSABQdCmDGtBe0lxIAFBgII4a0GwxVRJcSABQfCDOElxIAFBgIAITw0BGiAB +QdjwwABBLEGw8cAAQdABQYDzwABB5gMQUAwBCyABQeb2wABBKEG298AAQaICQdj5wABBqQIQUAtF +BEAgBEEAOgAWIARBADsBFCAEIAFBFHZB1+jAAGotAAA6ABcgBCABQQR2QQ9xQdfowABqLQAAOgAb +IAQgAUEIdkEPcUHX6MAAai0AADoAGiAEIAFBDHZBD3FB1+jAAGotAAA6ABkgBCABQRB2QQ9xQdfo +wABqLQAAOgAYIAFBAXJnQQJ2IgIgBEEUaiIDaiIFQfsAOgAAIAVBAWtB9QA6AAAgAyACQQJrIgJq +QdwAOgAAIARBHGoiAyABQQ9xQdfowABqLQAAOgAAIABBCjoACyAAIAI6AAogACAEKQIUNwIAIARB +/QA6AB0gAEEIaiADLwEAOwEADAILIAAgATYCBCAAQYABOgAADAELIABBgAQ7AQogAEIANwECIABB +3MQAOwEACyAEQSBqJAAL0wUCB38BfgJ/IAFFBEAgACgCCCEHQS0hCyAFQQFqDAELQStBgIDEACAA +KAIIIgdBgICAAXEiARshCyABQRV2IAVqCyEIAkAgB0GAgIAEcUUEQEEAIQIMAQsgA0EQTwRAIAIg +AxAvIAhqIQgMAQsgA0UNACADQQNxIQoCQCADQQRJBEBBACEBDAELIANBDHEhDEEAIQEDQCABIAIg +CWoiBiwAAEG/f0pqIAZBAWosAABBv39KaiAGQQJqLAAAQb9/SmogBkEDaiwAAEG/f0pqIQEgDCAJ +QQRqIglHDQALCyAKBEAgAiAJaiEGA0AgASAGLAAAQb9/SmohASAGQQFqIQYgCkEBayIKDQALCyAB +IAhqIQgLAkAgAC8BDCIJIAhLBEACQAJAIAdBgICACHFFBEAgCSAIayEJQQAhAUEAIQgCQAJAAkAg +B0EddkEDcUEBaw4DAAEAAgsgCSEIDAELIAlB/v8DcUEBdiEICyAHQf///wBxIQogACgCBCEHIAAo +AgAhAANAIAFB//8DcSAIQf//A3FPDQJBASEGIAFBAWohASAAIAogBygCEBEAAEUNAAsMBAsgACAA +KQIIIg2nQYCAgP95cUGwgICAAnI2AghBASEGIAAoAgAiByAAKAIEIgogCyACIAMQlgENA0EAIQEg +CSAIa0H//wNxIQIDQCABQf//A3EgAk8NAiABQQFqIQEgB0EwIAooAhARAABFDQALDAMLQQEhBiAA +IAcgCyACIAMQlgENAiAAIAQgBSAHKAIMEQEADQJBACEBIAkgCGtB//8DcSECA0AgAUH//wNxIgMg +AkkhBiACIANNDQMgAUEBaiEBIAAgCiAHKAIQEQAARQ0ACwwCCyAHIAQgBSAKKAIMEQEADQEgACAN +NwIIQQAPC0EBIQYgACgCACIBIAAoAgQiACALIAIgAxCWAQ0AIAEgBCAFIAAoAgwRAQAhBgsgBguK +BQIGfwV+QgEhDQJAAkACQAJAIAJBwABHDQBBACECA0AgAkHAAEcEQCABIAJqIgMtAAAiBEEwa0H/ +AXFBCk8EQCAEQV9xQcEAa0H/AXFBBUsNAwsgAkECaiECIANBAWotAAAiA0Ewa0H/AXFBCkkgA0Ff +cUHBAGtB/wFxQQZJcg0BDAILCyABLAAQIgVBQEgNASABQRBqIQZBD0EQIAEtAABBK0YiAhshAyAB +IAJqIQIDQCACLQAAIgRBwQBrQV9xQQpqIARBMGsgBEE5SxsiBEEPSw0BIAJBAWohAiAErSAJQgSG +hCEJIANBAWsiAw0ACyABLAAgIgdBQEgNAiABQSBqIQggAUERaiAGIAVBK0YiAxshAkEPQRAgAxsh +AwNAIAItAAAiBEHBAGtBX3FBCmogBEEwayAEQTlLGyIEQQ9LDQEgAkEBaiECIAStIApCBIaEIQog +A0EBayIDDQALIAEsADAiBUFASA0DIAFBMGohBiABQSFqIAggB0ErRiIDGyECQQ9BECADGyEDA0Ag +Ai0AACIEQcEAa0FfcUEKaiAEQTBrIARBOUsbIgRBD0sNASACQQFqIQIgBK0gC0IEhoQhCyADQQFr +IgMNAAsgAUExaiAGIAVBK0YiARshAkEPQRAgARshAwNAIAItAAAiAUHBAGtBX3FBCmogAUEwayAB +QTlLGyIBQQ9LDQEgAkEBaiECIAGtIAxCBIaEIQwgA0EBayIDDQALIAAgDDcDICAAIAs3AxggACAK +NwMQIAAgCTcDCEIAIQ0LIAAgDTcDAA8LIAFBwABBAEEQQey5wAAQvgEACyABQcAAQRBBIEH8ucAA +EL4BAAsgAUHAAEEgQTBBjLrAABC+AQALhAYCAX8BfCMAQTBrIgIkAAJ/AkACQAJAAkACQAJAAkAC +QAJAAkACQAJAAkACQAJAAkACQAJAIAAtAABBAWsOEQECAwQFBgcICQoLDA0ODxARAAsgAiAALQAB +OgAIIAJBAjYCFCACQcC+wAA2AhAgAkIBNwIcIAIgAkEIaq1CgICAgLAHhDcDKCACIAJBKGo2Ahgg +ASgCACABKAIEIAJBEGoQOwwRCyACIAApAwg3AwggAkECNgIUIAJB3L7AADYCECACQgE3AhwgAiAC +QQhqrUKAgICAwAeENwMoIAIgAkEoajYCGCABKAIAIAEoAgQgAkEQahA7DBALIAIgACkDCDcDCCAC +QQI2AhQgAkHcvsAANgIQIAJCATcCHCACIAJBCGqtQoCAgIDQB4Q3AyggAiACQShqNgIYIAEoAgAg +ASgCBCACQRBqEDsMDwsgACsDCCEDIAJBAjYCFCACQfy+wAA2AhAgAkIBNwIcIAIgAkEoaq1CgICA +gOAHhDcDCCACIAM5AyggAiACQQhqNgIYIAEoAgAgASgCBCACQRBqEDsMDgsgAiAAKAIENgIIIAJB +AjYCFCACQZi/wAA2AhAgAkIBNwIcIAIgAkEIaq1CgICAgPAHhDcDKCACIAJBKGo2AhggASgCACAB +KAIEIAJBEGoQOwwNCyACIAApAgQ3AgggAkEBNgIUIAJBsL/AADYCECACQgE3AhwgAiACQQhqrUKA +gICAgAiENwMoIAIgAkEoajYCGCABKAIAIAEoAgQgAkEQahA7DAwLIAFBrL7AAEEKELwBDAsLIAFB +uL/AAEEKELwBDAoLIAFBwr/AAEEMELwBDAkLIAFBzr/AAEEOELwBDAgLIAFB3L/AAEEIELwBDAcL +IAFB5L/AAEEDELwBDAYLIAFB57/AAEEEELwBDAULIAFB67/AAEEMELwBDAQLIAFB97/AAEEPELwB +DAMLIAFBhsDAAEENELwBDAILIAFBk8DAAEEOELwBDAELIAEgACgCBCAAKAIIELwBCyACQTBqJAAL +/gUBBX8gAEEIayIBIABBBGsoAgAiA0F4cSIAaiECAkACQCADQQFxDQAgA0ECcUUNASABKAIAIgMg +AGohACABIANrIgFBkIbBACgCAEYEQCACKAIEQQNxQQNHDQFBiIbBACAANgIAIAIgAigCBEF+cTYC +BCABIABBAXI2AgQgAiAANgIADwsgASADEEsLAkACQAJAAkACQCACKAIEIgNBAnFFBEAgAkGUhsEA +KAIARg0CIAJBkIbBACgCAEYNAyACIANBeHEiAhBLIAEgACACaiIAQQFyNgIEIAAgAWogADYCACAB +QZCGwQAoAgBHDQFBiIbBACAANgIADwsgAiADQX5xNgIEIAEgAEEBcjYCBCAAIAFqIAA2AgALIABB +gAJJDQIgASAAEFNBACEBQaiGwQBBqIbBACgCAEEBayIANgIAIAANBEHwg8EAKAIAIgAEQANAIAFB +AWohASAAKAIIIgANAAsLQaiGwQBB/x8gASABQf8fTRs2AgAPC0GUhsEAIAE2AgBBjIbBAEGMhsEA +KAIAIABqIgA2AgAgASAAQQFyNgIEQZCGwQAoAgAgAUYEQEGIhsEAQQA2AgBBkIbBAEEANgIACyAA +QaCGwQAoAgAiA00NA0GUhsEAKAIAIgJFDQNBACEAQYyGwQAoAgAiBEEpSQ0CQeiDwQAhAQNAIAIg +ASgCACIFTwRAIAIgBSABKAIEakkNBAsgASgCCCEBDAALAAtBkIbBACABNgIAQYiGwQBBiIbBACgC +ACAAaiIANgIAIAEgAEEBcjYCBCAAIAFqIAA2AgAPCyAAQfgBcUH4g8EAaiECAn9BgIbBACgCACID +QQEgAEEDdnQiAHFFBEBBgIbBACAAIANyNgIAIAIMAQsgAigCCAshACACIAE2AgggACABNgIMIAEg +AjYCDCABIAA2AggPC0Hwg8EAKAIAIgEEQANAIABBAWohACABKAIIIgENAAsLQaiGwQBB/x8gACAA +Qf8fTRs2AgAgAyAETw0AQaCGwQBBfzYCAAsL4QQBBn8CQAJAIAAoAggiB0GAgIDAAXFFDQACQAJA +IAdBgICAgAFxRQRAIAJBEEkNASABIAIQLyEDDAILAkACQCAALwEOIgNFBEBBACECDAELIAEgAmoh +CEEAIQIgAyEFIAEhBANAIAQiBiAIRg0CAn8gBkEBaiAGLAAAIgRBAE4NABogBkECaiAEQWBJDQAa +IAZBA2ogBEFwSQ0AGiAGQQRqCyIEIAZrIAJqIQIgBUEBayIFDQALC0EAIQULIAMgBWshAwwBCyAC +RQRAQQAhAgwBCyACQQNxIQYCQCACQQRJBEAMAQsgAkEMcSEIA0AgAyABIAVqIgQsAABBv39KaiAE +QQFqLAAAQb9/SmogBEECaiwAAEG/f0pqIARBA2osAABBv39KaiEDIAggBUEEaiIFRw0ACwsgBkUN +ACABIAVqIQQDQCADIAQsAABBv39KaiEDIARBAWohBCAGQQFrIgYNAAsLIAMgAC8BDCIETw0AIAQg +A2shBkEAIQNBACEFAkACQAJAIAdBHXZBA3FBAWsOAgABAgsgBiEFDAELIAZB/v8DcUEBdiEFCyAH +Qf///wBxIQggACgCBCEHIAAoAgAhAANAIANB//8DcSAFQf//A3FJBEBBASEEIANBAWohAyAAIAgg +BygCEBEAAEUNAQwDCwtBASEEIAAgASACIAcoAgwRAQANAUEAIQMgBiAFa0H//wNxIQEDQCADQf// +A3EiAiABSSEEIAEgAk0NAiADQQFqIQMgACAIIAcoAhARAABFDQALDAELIAAoAgAgASACIAAoAgQo +AgwRAQAhBAsgBAueBAEEfyMAQYABayIEJAACQAJAAkAgASgCCCICQYCAgBBxRQRAIAJBgICAIHEN +AUEBIQIgACgCACABEEpFDQIMAwsgACgCACECA0AgAyAEakH/AGogAkEPcSIFQTByIAVB1wBqIAVB +CkkbOgAAIANBAWshAyACQRBJIAJBBHYhAkUNAAtBASECIAFBAUG068AAQQIgAyAEakGAAWpBACAD +axA1RQ0BDAILIAAoAgAhAgNAIAMgBGpB/wBqIAJBD3EiBUEwciAFQTdqIAVBCkkbOgAAIANBAWsh +AyACQQ9LIAJBBHYhAg0AC0EBIQIgAUEBQbTrwABBAiADIARqQYABakEAIANrEDUNAQsgASgCAEHV +6MAAQQIgASgCBCgCDBEBAA0AAkAgASgCCCICQYCAgBBxRQRAIAJBgICAIHENASAAKAIEIAEQSiEC +DAILIAAoAgQhAkEAIQMDQCADIARqQf8AaiACQQ9xIgBBMHIgAEHXAGogAEEKSRs6AAAgA0EBayED +IAJBD0sgAkEEdiECDQALIAFBAUG068AAQQIgAyAEakGAAWpBACADaxA1IQIMAQsgACgCBCECQQAh +AwNAIAMgBGpB/wBqIAJBD3EiAEEwciAAQTdqIABBCkkbOgAAIANBAWshAyACQQ9LIAJBBHYhAg0A +CyABQQFBtOvAAEECIAMgBGpBgAFqQQAgA2sQNSECCyAEQYABaiQAIAILvQQBCH8jAEEQayIDJAAg +AyABNgIEIAMgADYCACADQqCAgIAONwIIAn8CQAJAAkAgAigCECIJBEAgAigCFCIADQEMAgsgAigC +DCIARQ0BIAIoAggiASAAQQN0aiEEIABBAWtB/////wFxQQFqIQYgAigCACEAA0ACQCAAQQRqKAIA +IgVFDQAgAygCACAAKAIAIAUgAygCBCgCDBEBAEUNAEEBDAULQQEgASgCACADIAFBBGooAgARAAAN +BBogAEEIaiEAIAQgAUEIaiIBRw0ACwwCCyAAQRhsIQogAEEBa0H/////AXFBAWohBiACKAIIIQQg +AigCACEAA0ACQCAAQQRqKAIAIgFFDQAgAygCACAAKAIAIAEgAygCBCgCDBEBAEUNAEEBDAQLQQAh +B0EAIQgCQAJAAkAgBSAJaiIBQQhqLwEAQQFrDgIBAgALIAFBCmovAQAhCAwBCyAEIAFBDGooAgBB +A3RqLwEEIQgLAkACQAJAIAEvAQBBAWsOAgECAAsgAUECai8BACEHDAELIAQgAUEEaigCAEEDdGov +AQQhBwsgAyAHOwEOIAMgCDsBDCADIAFBFGooAgA2AghBASAEIAFBEGooAgBBA3RqIgEoAgAgAyAB +QQRqKAIAEQAADQMaIABBCGohACAFQRhqIgUgCkcNAAsMAQsLAkAgBiACKAIETw0AIAMoAgAgAigC +ACAGQQN0aiIAKAIAIAAoAgQgAygCBCgCDBEBAEUNAEEBDAELQQALIANBEGokAAuvFQIWfwN+IwBB +EGsiFSQAQfyBwQAoAgBFBEBB/IHBACgCACEEQfyBwQBCATcCAEGIgsEAKAIAIQpBhILBACgCACEC +QYSCwQBBsJTAACkCADcCAEGQgsEAKAIAIQVBjILBAEG4lMAAKQIANwIAAkAgBEUgCkVyDQAgBQRA +IAJBCGohCCACKQMAQn+FQoCBgoSIkKDAgH+DIRggAiEEA0AgGFAEQANAIARB4ABrIQQgCCkDACAI +QQhqIQhCgIGChIiQoMCAf4MiGEKAgYKEiJCgwIB/UQ0ACyAYQoCBgoSIkKDAgH+FIRgLIAQgGHqn +QQN2QXRsakEEaygCACIDQYQBTwRAIAMQagsgGEIBfSAYgyEYIAVBAWsiBQ0ACwsgCiAKQQxsQRNq +QXhxIgNqQQlqIgRFDQAgAiADayAEEMwBCwsCQAJAQYCCwQAoAgBFBEBBgILBAEF/NgIAQYiCwQAo +AgAiAyAAcSEFIABBGXYiFq1CgYKEiJCgwIABfiEZQYSCwQAoAgAhAgNAIAIgBWopAAAiGiAZhSIY +Qn+FIBhCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MiGFBFBEADQCAAIAIgGHqnQQN2IAVqIANxQXRs +aiIEQQxrKAIARgRAIARBCGsoAgAgAUYNBgsgGEIBfSAYgyIYUEUNAAsLIBogGkIBhoNCgIGChIiQ +oMCAf4NQRQ0CIAUgB0EIaiIHaiADcSEFDAALAAtBmJTAABCKAQALQYyCwQAoAgBFBEAgFUEIaiEX +IwBBIGsiDyQAAkACQEGQgsEAKAIAIghBAWoiBCAITwRAAkBBiILBACgCACILIAtBAWoiDUEDdiIC +QQdsIAtBCEkbIhJBAXYgBEkEQCASQQFqIgIgBCACIARLGyICQQhJDQEgAkH/////AU0EQEF/IAJB +A3RBB25BAWtndkEBaiEEDAQLEIwBIA8oAhwhBCAPKAIYIQIMBAtBACEEQYSCwQAoAgAhCQJAIAIg +DUEHcUEAR2oiA0UNACADQQFHBEAgA0H+////A3EhAgNAIAQgCWoiByAHKQMAIhhCf4VCB4hCgYKE +iJCgwIABgyAYQv/+/fv379+//wCEfDcDACAHQQhqIgcgBykDACIYQn+FQgeIQoGChIiQoMCAAYMg +GEL//v379+/fv/8AhHw3AwAgBEEQaiEEIAJBAmsiAg0ACwsgA0EBcUUNACAEIAlqIgQgBCkDACIY +Qn+FQgeIQoGChIiQoMCAAYMgGEL//v379+/fv/8AhHw3AwALAkACQCANQQhPBEAgCSANaiAJKQAA +NwAADAELIA0EQCAJQQhqIAkgDfwKAAALIA1FDQELIAlBCGohECAJQQxrIRNBASECQQAhBANAIAQh +ByACIQQCQCAHIAlqIhQtAABBgAFHDQAgEyAHQXRsaiEGAkADQCAGKAIAIgIgBigCBCACGyIKIAtx +IgUhAiAFIAlqKQAAQoCBgoSIkKDAgH+DIhlQBEBBCCEDA0AgAiADaiECIANBCGohAyAJIAIgC3Ei +AmopAABCgIGChIiQoMCAf4MiGVANAAsLIAkgGXqnQQN2IAJqIAtxIgJqLAAAQQBOBEAgCSkDAEKA +gYKEiJCgwIB/g3qnQQN2IQILIAIgBWsgByAFa3MgC3FBCEkNASACIAlqIgMtAAAgAyAKQRl2IgM6 +AAAgECACQQhrIAtxaiADOgAAIBMgAkF0bGohA0H/AUcEQCAGLQAAIQIgBiADLQAAOgAAIAMgAjoA +ACAGLQABIQIgBiADLQABOgABIAMgAjoAASAGLQACIQIgBiADLQACOgACIAMgAjoAAiAGLQADIQIg +BiADLQADOgADIAMgAjoAAyAGLQAEIQIgBiADLQAEOgAEIAMgAjoABCAGLQAFIQIgBiADLQAFOgAF +IAMgAjoABSAGLQAGIQIgBiADLQAGOgAGIAMgAjoABiAGLQAHIQIgBiADLQAHOgAHIAMgAjoAByAG +LQAIIQIgBiADLQAIOgAIIAMgAjoACCAGLQAJIQIgBiADLQAJOgAJIAMgAjoACSAGLQAKIQIgBiAD +LQAKOgAKIAMgAjoACiAGLQALIQIgBiADLQALOgALIAMgAjoACwwBCwsgFEH/AToAACAQIAdBCGsg +C3FqQf8BOgAAIANBCGogBkEIaigAADYAACADIAYpAAA3AAAMAQsgFCAKQRl2IgI6AAAgECAHQQhr +IAtxaiACOgAACyAEIAQgDUkiB2ohAiAHDQALC0GMgsEAIBIgCGs2AgBBgYCAgHghAgwDC0EEQQgg +AkEESRshBAwBCxCMASAPKAIEIQQgDygCACECDAELAkACQCAErUIMfiIYQiCIpw0AIBinIgJBeEsN +ACACQQdqQXhxIgMgBEEIaiIHaiIFIANJIAVB+P///wdLcg0AQfmBwQAtAAAaIAVBCBDAASICDQFB +CCAFEOYBAAsQjAEgDygCDCEEIA8oAgghAgwBCyACIANqIQwgBwRAIAxB/wEgB/wLAAsgBEEBayIR +IARBA3ZBB2wgBEEJSRshEEGEgsEAKAIAIQMgCARAIAxBDGshEiAMQQhqIRMgA0EMayEJIAMpAwBC +f4VCgIGChIiQoMCAf4MhGSADIQJBACEEIAghBwNAIBlQBEADQCAEQQhqIQQgAkEIaiICKQMAQoCB +goSIkKDAgH+DIhhCgIGChIiQoMCAf1ENAAsgGEKAgYKEiJCgwIB/hSEZCyAMIAkgGXqnQQN2IARq +IhRBdGxqIgooAgAiBSAKKAIEIAUbIgogEXEiDmopAABCgIGChIiQoMCAf4MiGFAEQEEIIQYDQCAG +IA5qIQUgBkEIaiEGIAwgBSARcSIOaikAAEKAgYKEiJCgwIB/gyIYUA0ACwsgGUIBfSAZgyEZIAwg +GHqnQQN2IA5qIBFxIg5qLAAAQQBOBEAgDCkDAEKAgYKEiJCgwIB/g3qnQQN2IQ4LIAwgDmogCkEZ +diIFOgAAIBMgDkEIayARcWogBToAACASIA5BdGxqIgpBCGogCSAUQXRsaiIFQQhqKAAANgAAIAog +BSkAADcAACAHQQFrIgcNAAsLQYiCwQAgETYCAEGEgsEAIAw2AgBBjILBACAQIAhrNgIAQYGAgIB4 +IQIgC0UNACALIA1BDGxBB2pBeHEiBGpBCWoiB0UNACADIARrIAcQzAELIBcgAjYCACAXIAQ2AgQg +D0EgaiQACyAAIAEQtQEhB0GEgsEAKAIAIghBiILBACgCACIEIABxIgVqKQAAQoCBgoSIkKDAgH+D +IhhQBEBBCCEDA0AgAyAFaiECIANBCGohAyAIIAIgBHEiBWopAABCgIGChIiQoMCAf4MiGFANAAsL +IAggGHqnQQN2IAVqIARxIgVqLAAAIgNBAE4EQCAIIAgpAwBCgIGChIiQoMCAf4N6p0EDdiIFai0A +ACEDCyAFIAhqIBY6AAAgCCAFQQhrIARxakEIaiAWOgAAQYyCwQBBjILBACgCACADQQFxazYCAEGQ +gsEAQZCCwQAoAgBBAWo2AgAgCCAFQXRsaiIEQQRrIAc2AgAgBEEIayABNgIAIARBDGsgADYCAAsg +BEEEaygCACEBEG0iACABJQEmAUGAgsEAQYCCwQAoAgBBAWo2AgAgFUEQaiQAIAALygQCB38BfiMA +QRBrIgYkAAJAIAAvAQwiBUUEQCAAKAIAIAAoAgQgARA+IQIMAQsgBiABKAIMIgQ2AgwgBiABKAII +IgI2AgggBiABKAIEIgM2AgQgBiABKAIAIgE2AgACQCAAKQIIIgmnIgdBgICACHEEQCAAKAIAIAEg +AyAAKAIEKAIMEQEADQEgACAHQYCAgP95cUGwgICAAnIiBzYCCCAGQgE3AgAgBSADQf//A3FrIgFB +ACABIAVNGyEFQQAhAwsgBARAIARBDGwhCANAAn8CQAJAAkAgAi8BAEEBaw4CAgEACyACQQRqKAIA +DAILIAJBCGooAgAMAQsgAkECai8BACIEQegHTwRAQQRBBSAEQZDOAEkbDAELQQEgBEEKSQ0AGkEC +QQMgBEHkAEkbCyACQQxqIQIgA2ohAyAIQQxrIggNAAsLAkACQCAFQf//A3EgA0sEQCAFIANrIQNB +ACECQQAhAQJAAkACQCAHQR12QQNxQQFrDgMAAQACCyADIQEMAQsgA0H+/wNxQQF2IQELIAdB//// +AHEhCCAAKAIEIQcgACgCACEEA0AgAkH//wNxIAFB//8DcU8NAiACQQFqIQIgBCAIIAcoAhARAABF +DQALDAMLIAAoAgAgACgCBCAGED4hAgwBCyAEIAcgBhA+DQFBACEFIAMgAWtB//8DcSEBA0AgBUH/ +/wNxIgMgAUkhAiABIANNDQEgBUEBaiEFIAQgCCAHKAIQEQAARQ0ACwsgACAJNwIIDAELQQEhAgsg +BkEQaiQAIAIL/gMBCX8jAEEQayIEJAACfwJAIAIoAgQiA0UNACAAIAIoAgAgAyABKAIMEQEARQ0A +QQEMAQsgAigCDCIGBEAgAigCCCIDIAZBDGxqIQggBEEMaiEJA0ACQAJAAkACQCADLwEAQQFrDgIC +AQALAkAgAygCBCICQcEATwRAIAFBDGooAgAhBgNAQQEgAEH+7MAAQcAAIAYRAQANCBogAkFAaiIC +QcAASw0ACwwBCyACRQ0DCyAAQf7swAAgAiABQQxqKAIAEQEARQ0CQQEMBQsgACADKAIEIAMoAggg +AUEMaigCABEBAEUNAUEBDAQLIAMvAQIhAiAJQQA6AAAgBEEANgIIAn9BBEEFIAJBkM4ASRsgAkHo +B08NABpBASACQQpJDQAaQQJBAyACQeQASRsLIgYgBEEIaiIKaiIHQQFrIgUgAiACQQpuIgtBCmxr +QTByOgAAAkAgBSAKRg0AIAdBAmsiBSALQQpwQTByOgAAIARBCGogBUYNACAHQQNrIgUgAkHkAG5B +CnBBMHI6AAAgBEEIaiAFRg0AIAdBBGsiBSACQegHbkEKcEEwcjoAACAEQQhqIAVGDQAgB0EFayAC +QZDOAG5BMHI6AAALIAAgBEEIaiAGIAFBDGooAgARAQBFDQBBAQwDCyADQQxqIgMgCEcNAAsLQQAL +IARBEGokAAvMBAEKfyMAQTBrIgYkAAJAAkACQAJ/QQAgAUFAcSIKRQ0AGiAGQQhqIAA2AgBBASAK +QcAARg0AGiAGIABBQGs2AgwgCkGAAUcNAUECCyEHIAFBP3EhASAFQQV2IgkgByAHIAlLGyIIBEAg +BkEIaiEJIANBBHIhCyAIQQV0IQxBACEDA0AgCSgCACEIIAZBKGoiDSACQRhqKQIANwMAIAZBIGoi +DiACQRBqKQIANwMAIAZBGGoiDyACQQhqKQIANwMAIAYgAikCADcDECAGQRBqIAhBwABCACALECcg +AyAEaiIIQRhqIA0pAwA3AAAgCEEQaiAOKQMANwAAIAhBCGogDykDADcAACAIIAYpAxA3AAAgCUEE +aiEJIAwgA0EgaiIDRw0ACwsCQCABBEAgBSAHQQV0IgJJDQEgBSACayIDQR9NDQMgAUEgRw0EIAIg +BGoiASAAIApqIgApAAA3AAAgAUEYaiAAQRhqKQAANwAAIAFBEGogAEEQaikAADcAACABQQhqIABB +CGopAAA3AAAgB0EBaiEHCyAGQTBqJAAgBw8LIAIgBUGYvMAAENABAAsgBiAAQYABajYCEEHQvcAA +QSsgBkEQakH8vcAAQai8wAAQegALQSAgA0H4u8AAENEBAAsjAEEwayIAJAAgAEEgNgIEIAAgATYC +ACAAQQM2AgwgAEGggMEANgIIIABCAjcCFCAAIABBBGqtQoCAgIDwCIQ3AyggACAArUKAgICA8AiE +NwMgIAAgAEEgajYCECAAQQhqQYi8wAAQngEAC4QEAgd/AXwjAEHQAGsiAyQAAkACQAJAAkACQCAA +KAIAIgQlAUGBASUBEAZFBEAgBCUBEAcOAgIBAwsgA0EHOgAwIANBMGogASACEHwhAAwEC0EBIQYL +QQEhB0EAIQAMAQsgA0EQaiAEJQEQCCADKAIQBEAgAysDGCEKQQMhAEEBIQcMAQsgA0EIaiAEEOgB +An8gAygCCCIEBEAgAygCDCIFIQZBBQwBCwJAAkAgACgCACUBECIEQCADQTBqIAAQcyADKAI4IQYg +AygCNCEEIAMoAjAhCAwBCyAAKAIAJQEQHEUNASADIAAoAgAQtwEiBTYCSCADQTBqIANByABqEHMg +AygCOCEGIAMoAjQhBCADKAIwIQggBUGEAUkNACAFEGoLIAhBgICAgHhGDQBBASEHQQYMAQsgA0EB +NgI0IANBpJPAADYCMCADQgE3AjwgAyAArUKAgICA0AKENwNIIAMgA0HIAGo2AjggA0EkaiADQTBq +EEVBgICAgHghCCADKAIsIQYgAygCKCEEIAMoAiQhBUERCyEAIAatvyEKIAchCQsgAyAKOQM4IAMg +BDYCNCADIAY6ADEgAyAAOgAwIANBMGogASACEHwhAAJAIAlFBEAgByAFRXJFDQEMAgsgCARAIAQg +CBDMAQsgBUUgB3INAQsgBCAFEMwBCyADQdAAaiQAIAAL5AMBBX8jAEEQayIIJAACQAJAAkACQAJA +IAEoAghBAUYEQCABKAIAIQUgASgCBCEEIAFBDBDMAUEdQYEBIARBCnZnQQJ0ayAEQf//B0sbIQYg +AiAFayIHIANqIQMgAiAFRgRAIAYhAQwGCyAGQQV2IgIgB2oiAUGAgIDAAE8EQEH5gcEALQAAGkEU +QQQQwAEiAUUNAiABQQE2AhAgASACIANqNgIIIAEgBSACazYCBCABIAIgBGo2AgAgASAGQQJ2QQdx +NgIMDAULIAZBHXEgAUEFdHIhAQwECyADQQBIDQECQCADRQRAQQEhBQwBC0H5gcEALQAAGkEBIQQg +A0EBEMABIgVFDQILIAMEQCAFIAIgA/wKAAALIAEgASgCCCICQQFrNgIIIAJBAUYEQCABKAIAIAFB +BGooAgAiBEEBELMBRQ0DIAQQzAEgAUEMEMwBC0EdQYEBIANBCnZnQQJ0ayADQf//B0sbIQEgAyEE +DAQLQQRBFBDmAQALIAQgA0GYtcAAELIBAAtB1LbAAEErIAhBD2pBxLbAAEGQt8AAEHoACyADIAdr +IgJBACACIANNGyEDIAQgB2shBCAFIAdqIQULIAAgATYCDCAAIAQ2AgggACADNgIEIAAgBTYCACAI +QRBqJAAL+QMBAn8gACABaiECAkACQCAAKAIEIgNBAXENACADQQJxRQ0BIAAoAgAiAyABaiEBIAAg +A2siAEGQhsEAKAIARgRAIAIoAgRBA3FBA0cNAUGIhsEAIAE2AgAgAiACKAIEQX5xNgIEIAAgAUEB +cjYCBCACIAE2AgAMAgsgACADEEsLAkACQAJAIAIoAgQiA0ECcUUEQCACQZSGwQAoAgBGDQIgAkGQ +hsEAKAIARg0DIAIgA0F4cSICEEsgACABIAJqIgFBAXI2AgQgACABaiABNgIAIABBkIbBACgCAEcN +AUGIhsEAIAE2AgAPCyACIANBfnE2AgQgACABQQFyNgIEIAAgAWogATYCAAsgAUGAAk8EQCAAIAEQ +Uw8LIAFB+AFxQfiDwQBqIQICf0GAhsEAKAIAIgNBASABQQN2dCIBcUUEQEGAhsEAIAEgA3I2AgAg +AgwBCyACKAIICyEBIAIgADYCCCABIAA2AgwgACACNgIMIAAgATYCCA8LQZSGwQAgADYCAEGMhsEA +QYyGwQAoAgAgAWoiATYCACAAIAFBAXI2AgQgAEGQhsEAKAIARw0BQYiGwQBBADYCAEGQhsEAQQA2 +AgAPC0GQhsEAIAA2AgBBiIbBAEGIhsEAKAIAIAFqIgE2AgAgACABQQFyNgIEIAAgAWogATYCAAsL +jgMBBH8CQAJAAkACQAJAIAcgCFYEQCAHIAh9IAhYDQECQCAGIAcgBn1UIAcgBkIBhn0gCEIBhlpx +RQRAIAYgCFYNAQwHCyACIANJDQMMBQsgByAGIAh9IgZ9IAZWDQUgAiADSQ0DIAEgA2ohDCABIQoC +QAJAA0AgAyAJRg0BIAlBAWohCSAKQQFrIgogA2oiCy0AAEE5Rg0ACyALIAstAABBAWo6AAAgAyAJ +a0EBaiADTw0BIAlBAWsiBUUNASALQQFqQTAgBfwLAAwBCwJAIANFBEBBMSEJDAELIAFBMToAACAD +QQFGBEBBMCEJDAELQTAhCSADQQFrIgpFDQAgAUEBakEwIAr8CwALIARBAWrBIgQgBcFMIAIgA01y +DQAgDCAJOgAAIANBAWohAwsgAiADTw0EIAMgAkHY5sAAENEBAAsgAEEANgIADwsgAEEANgIADwsg +AyACQejmwAAQ0QEACyADIAJByObAABDRAQALIAAgBDsBCCAAIAM2AgQgACABNgIADwsgAEEANgIA +C6cDAQJ/AkACQAJAAkAgAC0AaCIDBEAgA0HBAE8NAyACQcAAIANrIgQgAiAESRsiBARAIAAgA2og +ASAE/AoAAAsgACAALQBoIARqIgM6AGggASAEaiEBIAIgBGsiAkUEQEEAIQIMAgsgAEFAayAAQcAA +IAApA2AgAC0AaiAALQBpRXIQJyAAQgA3AwAgAEEAOgBoIABBCGpCADcDACAAQRBqQgA3AwAgAEEY +akIANwMAIABBIGpCADcDACAAQShqQgA3AwAgAEEwakIANwMAIABBOGpCADcDACAAIAAtAGlBAWo6 +AGkLQQAhAyACQcEASQ0BIABBQGshBCAALQBpIQMDQCAEIAFBwAAgACkDYCAALQBqIANB/wFxRXIQ +JyAAIAAtAGlBAWoiAzoAaSABQUBrIQEgAkFAaiICQcAASw0ACyAALQBoIQMLIANB/wFxIgNBwQBP +DQILIAJBwAAgA2siBCACIARJGyICBEAgACADaiABIAL8CgAACyAAIAAtAGggAmo6AGggAA8LIANB +wABB2LvAABDQAQALIANBwABB2LvAABDQAQALjwMBB38jAEEQayIEJAACQAJAAkACQCABKAIEIgIE +QCABKAIAIQcgAkEDcSEFAkAgAkEESQRAQQAhAgwBCyAHQRxqIQMgAkF8cSEIQQAhAgNAIAMoAgAg +A0EIaygCACADQRBrKAIAIANBGGsoAgAgAmpqamohAiADQSBqIQMgCCAGQQRqIgZHDQALCyAFBEAg +BkEDdCAHakEEaiEDA0AgAygCACACaiECIANBCGohAyAFQQFrIgUNAAsLIAEoAgxFDQIgAkEPSw0B +IAcoAgQNAQwDC0EAIQIgASgCDEUNAgsgAkEAIAJBAEobQQF0IQILQQAhBSACQQBOBEAgAkUNAUH5 +gcEALQAAGkEBIQUgAkEBEMABIgMNAgsgBSACQeTKwAAQsgEAC0EBIQNBACECCyAEQQA2AgggBCAD +NgIEIAQgAjYCACAEQeTJwAAgARA7RQRAIAAgBCkCADcCACAAQQhqIARBCGooAgA2AgAgBEEQaiQA +DwtBhMvAAEHWACAEQQ9qQfTKwABB9MvAABB6AAvnAgEFfwJAIAFBzf97QRAgACAAQRBNGyIAa08N +ACAAQRAgAUELakF4cSABQQtJGyIEakEMahAoIgJFDQAgAkEIayEBAkAgAEEBayIDIAJxRQRAIAEh +AAwBCyACQQRrIgUoAgAiBkF4cSACIANqQQAgAGtxQQhrIgIgAEEAIAIgAWtBEE0baiIAIAFrIgJr +IQMgBkEDcQRAIAAgAyAAKAIEQQFxckECcjYCBCAAIANqIgMgAygCBEEBcjYCBCAFIAIgBSgCAEEB +cXJBAnI2AgAgASACaiIDIAMoAgRBAXI2AgQgASACEEIMAQsgASgCACEBIAAgAzYCBCAAIAEgAmo2 +AgALAkAgACgCBCIBQQNxRQ0AIAFBeHEiAiAEQRBqTQ0AIAAgBCABQQFxckECcjYCBCAAIARqIgEg +AiAEayIEQQNyNgIEIAAgAmoiAiACKAIEQQFyNgIEIAEgBBBCCyAAQQhqIQMLIAML6gICBn8CfiMA +QSBrIgUkAEEUIQMgACIJQugHWgRAIAkhCgNAIAVBDGogA2oiBEEDayAKIApCkM4AgCIJQpDOAH59 +pyIGQf//A3FB5ABuIgdBAXQiCEG368AAai0AADoAACAEQQRrIAhBtuvAAGotAAA6AAAgBEEBayAG +IAdB5ABsa0H//wNxQQF0IgZBt+vAAGotAAA6AAAgBEECayAGQbbrwABqLQAAOgAAIANBBGshAyAK +Qv+s4gRWIAkhCg0ACwsgCUIJVgRAIAMgBWpBC2ogCaciBCAEQf//A3FB5ABuIgRB5ABsa0H//wNx +QQF0IgZBt+vAAGotAAA6AAAgA0ECayIDIAVBDGpqIAZBtuvAAGotAAA6AAAgBK0hCQsgAFBFIAlQ +cUUEQCADQQFrIgMgBUEMamogCadBAXRBHnFBt+vAAGotAAA6AAALIAIgAUEBQQAgBUEMaiADakEU +IANrEDUgBUEgaiQAC9ACAQR/IwBB8ABrIgMkAAJAIAACfgJAIAEoAgQiBCABKAIMRwRAIAEgBEEQ +ajYCBCAEKAIMIQUgBCgCACEBIAIoAgQgA0HIAGogBCgCBCIGIAQoAggQNiADKAJIIgRFBEAgA0FA +ayADQegAaikDADcDACADQThqIANB4ABqKQMANwMAIANBMGogA0HYAGopAwA3AwAgAyADKQNQNwMo +CyABBEAgBiABEMwBCyAEQQFxRQ0BQQE6AABCAAwCCyAAQgI3AwAMAgsgA0EgaiADQUBrKQMANwMA +IANBGGogA0E4aikDADcDACADQRBqIANBMGopAwA3AwAgAyADKQMoNwMIQgELNwMAIAAgAykDCDcD +CCAAIAU2AiggAEEQaiADQRBqKQMANwMAIABBGGogA0EYaikDADcDACAAQSBqIANBIGopAwA3AwAL +IANB8ABqJAAL3AgBCH8jAEGAAWsiAiQAIAJBCGohBCMAQSBrIgMkACADIABpIgE2AhwCQAJAAkAC +QAJAAkAgAUEBRgRAIABBwABNDQEgA0GcgsEANgIYQaCCwQAtAABBA0cEfyADIANBGGo2AhwgAyAD +QRxqNgIAIwBBIGsiASQAAkACQAJAAkACQAJAQaCCwQAtAABBAWsOAwIEAQALQaCCwQBBAjoAACAD +KAIAIgYoAgAhBSAGQQA2AgAgBUUNAiAFKAIAQQg2AgBBoILBAEEDOgAACyABQSBqJAAMAwsgAUEA +NgIYIAFBATYCDCABQdSZwAA2AggMCgtBmJvAABDUAQALIAFBADYCGCABQQE2AgwgAUGUmsAANgII +DAgLIAMoAhgFQZyCwQALKAIAIgFFDQIgA0GUgsEANgIYIAAgAW4iBkGYgsEALQAAQQNHBH8gAyAD +QRhqNgIcIAMgA0EcajYCACMAQSBrIgEkAAJAAkACQAJAAkACQEGYgsEALQAAQQFrDgMCBAEAC0GY +gsEAQQI6AAAgAygCACIHKAIAIQUgB0EANgIAIAVFDQIgBSgCAEECNgIAQZiCwQBBAzoAAAsgAUEg +aiQADAMLIAFBADYCGCABQQE2AgwgAUHUmcAANgIIDAoLQZibwAAQ1AEACyABQQA2AhggAUEBNgIM +IAFBlJrAADYCCAwICyADKAIYBUGUgsEACygCACAAbCIBTw0DIAFBAEgNBEH5gcEALQAAGkEBIQgg +AUEBEMABIgVFDQQgBCABNgIcIAQgBjYCGCAEQaibwAA2AgggBEIANwMAIARBADYCKCAEIAU2AiQg +BCABNgIgIAQgAEEBayIArSAAZ0Egc62GNwMQIANBIGokAAwFCyADQQA2AgAjAEEQayIAJAAgAEHA +lMAANgIMIAAgA0EcajYCCCAAQQhqQeixwAAgAEEMakHoscAAIANBqJXAABBOAAtBuJXAAEEoQeCV +wAAQkgEAC0HwlcAAEJgBAAtBgJbAAEEvQbCWwAAQkgEACyAIIAFBwJbAABCyAQALIAJBOGoiAEEA +OgAAIAJB+ABqIAApAwA3AgAgAkHwAGogAkEwaikDADcCACACQegAaiACQShqKQMANwIAIAJB4ABq +IAJBIGopAwA3AgAgAkHYAGogAkEYaikDADcCACACQdAAaiACQRBqKQMANwIAQfmBwQAtAAAaIAIg +AikDCDcCSEHIAEEIEMABIgBFBEBBCEHIABDmAQALIABBADYCCCAAQoGAgIAQNwMAIAAgAikCRDcC +DCAAQRRqIAJBzABqKQIANwIAIABBHGogAkHUAGopAgA3AgAgAEEkaiACQdwAaikCADcCACAAQSxq +IAJB5ABqKQIANwIAIABBNGogAkHsAGopAgA3AgAgAEE8aiACQfQAaikCADcCACAAQcQAaiACQfwA +aigCADYCACACQYABaiQAIABBCGoPCyABQgQ3AhAgAUEIakGMmMAAEJ4BAAvmAgEIfyMAQRBrIgUk +AEEKIQIgACIDQegHTwRAIAMhBANAIAVBBmogAmoiBkEDayAEIARBkM4AbiIDQZDOAGxrIgdB//8D +cUHkAG4iCEEBdCIJQbfrwABqLQAAOgAAIAZBBGsgCUG268AAai0AADoAACAGQQFrIAcgCEHkAGxr +Qf//A3FBAXQiB0G368AAai0AADoAACAGQQJrIAdBtuvAAGotAAA6AAAgAkEEayECIARB/6ziBEsg +AyEEDQALCwJAIANBCU0EQCADIQQMAQsgAiAFakEFaiADIANB//8DcUHkAG4iBEHkAGxrQf//A3FB +AXQiA0G368AAai0AADoAACACQQJrIgIgBUEGamogA0G268AAai0AADoAAAtBACAAIAQbRQRAIAJB +AWsiAiAFQQZqaiAEQQF0QR5xQbfrwABqLQAAOgAACyABQQFBAUEAIAVBBmogAmpBCiACaxA1IAVB +EGokAAuCAwEEfyAAKAIMIQICQAJAAkAgAUGAAk8EQCAAKAIYIQMCQAJAIAAgAkYEQCAAQRRBECAA +KAIUIgIbaigCACIBDQFBACECDAILIAAoAggiASACNgIMIAIgATYCCAwBCyAAQRRqIABBEGogAhsh +BANAIAQhBSABIgJBFGogAkEQaiACKAIUIgEbIQQgAkEUQRAgARtqKAIAIgENAAsgBUEANgIACyAD +RQ0CAkAgACgCHEECdEHogsEAaiIBKAIAIABHBEAgAygCECAARg0BIAMgAjYCFCACDQMMBAsgASAC +NgIAIAJFDQQMAgsgAyACNgIQIAINAQwCCyAAKAIIIgAgAkcEQCAAIAI2AgwgAiAANgIIDwtBgIbB +AEGAhsEAKAIAQX4gAUEDdndxNgIADwsgAiADNgIYIAAoAhAiAQRAIAIgATYCECABIAI2AhgLIAAo +AhQiAEUNACACIAA2AhQgACACNgIYDwsPC0GEhsEAQYSGwQAoAgBBfiAAKAIcd3E2AgAL4AIBBH8j +AEEQayICJAACQCABQYABTwRAIAJBDGoiBEECciEDIAJBADYCDAJAIAFBgBBPBEAgBEEDciEFIAFB +gIAETwRAIAJBEGohAyACIAFBEnZB8AFyOgAMIAIgAUEGdkE/cUGAAXI6AA4gAiABQQx2QT9xQYAB +cjoADSAFIQQMAgsgAiABQQx2QeABcjoADCACIAFBBnZBP3FBgAFyOgANIAMhBCAFIQMMAQsgAkEM +akEBciEEIAIgAUEGdkHAAXI6AAwLIAQgAUE/cUGAAXI6AAAgAyACQQxqayIBIAAoAgAgACgCCCID +a0sEQCAAIAMgAUEBQQEQVSAAKAIIIQMLIAEEQCAAKAIEIANqIAJBDGogAfwKAAALIAAgASADajYC +CAwBCyAAKAIIIgMgACgCAEYEQCAAQYiDwAAQbwsgACgCBCADaiABOgAAIAAgA0EBajYCCAsgAkEQ +aiQAQQAL4AIBBH8jAEEQayICJAACQCABQYABTwRAIAJBDGoiBEECciEDIAJBADYCDAJAIAFBgBBP +BEAgBEEDciEFIAFBgIAETwRAIAJBEGohAyACIAFBEnZB8AFyOgAMIAIgAUEGdkE/cUGAAXI6AA4g +AiABQQx2QT9xQYABcjoADSAFIQQMAgsgAiABQQx2QeABcjoADCACIAFBBnZBP3FBgAFyOgANIAMh +BCAFIQMMAQsgAkEMakEBciEEIAIgAUEGdkHAAXI6AAwLIAQgAUE/cUGAAXI6AAAgAyACQQxqayIB +IAAoAgAgACgCCCIDa0sEQCAAIAMgAUEBQQEQVSAAKAIIIQMLIAEEQCAAKAIEIANqIAJBDGogAfwK +AAALIAAgASADajYCCAwBCyAAKAIIIgMgACgCAEYEQCAAQcCOwAAQbwsgACgCBCADaiABOgAAIAAg +A0EBajYCCAsgAkEQaiQAQQALswIBAX8jAEHwAGsiBiQAIAYgATYCDCAGIAA2AgggBiADNgIUIAYg +AjYCECAGQcyBwQAoAgA2AhwgBkHAgcEAKAIANgIYAkAgBCgCAARAIAZBMGogBEEQaikCADcDACAG +QShqIARBCGopAgA3AwAgBiAEKQIANwMgIAZBBDYCXCAGQYDrwAA2AlggBkIENwJkIAYgBkEQaq1C +gICAgOALhDcDUCAGIAZBCGqtQoCAgIDgC4Q3A0ggBiAGQSBqrUKAgICAgAyENwNADAELIAZBAzYC +XCAGQczqwAA2AlggBkIDNwJkIAYgBkEQaq1CgICAgOALhDcDSCAGIAZBCGqtQoCAgIDgC4Q3A0AL +IAYgBkEYaq1CgICAgPALhDcDOCAGIAZBOGo2AmAgBkHYAGogBRCeAQAL8gIBAX8CQCACBEAgAS0A +AEEwTQ0BIAVBAjsBAAJAAkACQAJAAkAgA8EiBkEASgRAIAUgATYCBCACIANB//8DcSIDSw0BIAVB +ADsBDCAFIAI2AgggBSADIAJrNgIQIAQNAkECIQEMBQsgBSACNgIgIAUgATYCHCAFQQI7ARggBUEA +OwEMIAVBAjYCCCAFQZHowAA2AgQgBUEAIAZrIgM2AhBBAyEBIAIgBE8NBCAEIAJrIgIgA00NBCAC +IAZqIQQMAwsgBUECOwEYIAVBATYCFCAFQZDowAA2AhAgBUECOwEMIAUgAzYCCCAFIAIgA2siAjYC +ICAFIAEgA2o2AhwgAiAESQ0BQQMhAQwDCyAFQQE2AiAgBUGQ6MAANgIcIAVBAjsBGAwBCyAEIAJr +IQQLIAUgBDYCKCAFQQA7ASRBBCEBCyAAIAE2AgQgACAFNgIADwtB+OTAAEEhQZznwAAQkgEAC0Gs +58AAQR9BzOfAABCSAQALygIBBn8gASACQQF0aiEJIABBgP4DcUEIdiEKIABB/wFxIQwCQAJAAkAC +QANAIAFBAmohCyAHIAEtAAEiAmohCCAKIAEtAAAiAUcEQCABIApLDQQgCCEHIAsiASAJRw0BDAQL +IAcgCEsNASAEIAhJDQIgAyAHaiEBA0AgAkUEQCAIIQcgCyIBIAlHDQIMBQsgAkEBayECIAEtAAAg +AUEBaiEBIAxHDQALC0EAIQIMAwsgByAIQcjwwAAQ0gEACyAIIARByPDAABDRAQALIABB//8DcSEH +IAUgBmohA0EBIQIDQCAFQQFqIQACQCAFLAAAIgFBAE4EQCAAIQUMAQsgACADRwRAIAUtAAEgAUH/ +AHFBCHRyIQEgBUECaiEFDAELQbjwwAAQ1AEACyAHIAFrIgdBAEgNASACQQFzIQIgAyAFRw0ACwsg +AkEBcQvKAgEDfyMAQRBrIgIkAAJAIAFBgAFPBEAgAkEANgIMAn8gAUGAEE8EQCABQYCABE8EQCAC +QQxqQQNyIQQgAiABQRJ2QfABcjoADCACIAFBBnZBP3FBgAFyOgAOIAIgAUEMdkE/cUGAAXI6AA1B +BAwCCyACQQxqQQJyIQQgAiABQQx2QeABcjoADCACIAFBBnZBP3FBgAFyOgANQQMMAQsgAkEMakEB +ciEEIAIgAUEGdkHAAXI6AAxBAgshAyAEIAFBP3FBgAFyOgAAIAAoAgAgACgCCCIBayADSQRAIAAg +ASADEGUgACgCCCEBCyADBEAgACgCBCABaiACQQxqIAP8CgAACyAAIAEgA2o2AggMAQsgACgCCCID +IAAoAgBGBEAgAEGEzMAAEG8LIAAgA0EBajYCCCAAKAIEIANqIAE6AAALIAJBEGokAEEAC8YCAQJ/ +IwBBEGsiAiQAAkAgAUGAAU8EQCACQQA2AgwCfyABQYAQTwRAIAFBgIAETwRAIAIgAUE/cUGAAXI6 +AA8gAiABQRJ2QfABcjoADCACIAFBBnZBP3FBgAFyOgAOIAIgAUEMdkE/cUGAAXI6AA1BBAwCCyAC +IAFBP3FBgAFyOgAOIAIgAUEMdkHgAXI6AAwgAiABQQZ2QT9xQYABcjoADUEDDAELIAIgAUE/cUGA +AXI6AA0gAiABQQZ2QcABcjoADEECCyIBIAAoAgAgACgCCCIDa0sEQCAAIAMgARBdIAAoAgghAwsg +AQRAIAAoAgQgA2ogAkEMaiAB/AoAAAsgACABIANqNgIIDAELIAAoAggiAyAAKAIARgRAIABBmMXA +ABBvCyAAKAIEIANqIAE6AAAgACADQQFqNgIICyACQRBqJABBAAvEAgEEfyAAQgA3AhAgAAJ/QQAg +AUGAAkkNABpBHyABQf///wdLDQAaIAFBBiABQQh2ZyIDa3ZBAXEgA0EBdGtBPmoLIgI2AhwgAkEC +dEHogsEAaiEEQQEgAnQiA0GEhsEAKAIAcUUEQCAEIAA2AgAgACAENgIYIAAgADYCDCAAIAA2AghB +hIbBAEGEhsEAKAIAIANyNgIADwsCQAJAIAEgBCgCACIDKAIEQXhxRgRAIAMhAgwBCyABQRkgAkEB +dmtBACACQR9HG3QhBQNAIAMgBUEddkEEcWoiBCgCECICRQ0CIAVBAXQhBSACIQMgAigCBEF4cSAB +Rw0ACwsgAigCCCIBIAA2AgwgAiAANgIIIABBADYCGCAAIAI2AgwgACABNgIIDwsgBEEQaiAANgIA +IAAgAzYCGCAAIAA2AgwgACAANgIIC/cCAQR/IwBBMGsiACQAAkACQEHYgcEAKAIARQRAQfCBwQAo +AgAhAUHwgcEAQQA2AgAgAUUNASAAQRhqIAERBQAgAEEQaiICIABBJGopAgA3AwAgACAAKQIcNwMI +IAAoAhghAUHYgcEAKAIAIgMNAgJAIANFDQBB3IHBACgCACICRQ0AQeCBwQAoAgAgAkECdBDMAQtB +3IHBACABNgIAQdiBwQBBATYCAEHggcEAIAApAwg3AgBB6IHBACAAQRBqKQMANwIACyAAQTBqJABB +3IHBAA8LIABBADYCKCAAQQE2AhwgAEHcwMAANgIYIABCBDcCICAAQRhqQcjBwAAQngEACyAAQShq +IAIpAwA3AgAgACAAKQMINwIgIAAgATYCHCAAQQE2AhgCQCAAQRhqIgEoAgBFDQAgASgCBCICRQ0A +IAEoAgggAkECdBDMAQsgAEEANgIoIABBATYCHCAAQejBwAA2AhggAEIENwIgIAFB8MHAABCeAQAL +/AECBH8BfiMAQSBrIgUkAAJAAkAgBEUNACABIAEgAmoiAksNACADIARqQQFrQQAgA2txrSACIAAo +AgAiAUEBdCIGIAIgBksbIgJBCEEEQQEgBEGBCEkbIARBAUYbIgYgAiAGSxsiBq1+IglCIIhQRQ0A +IAmnIghBgICAgHggA2tLDQBBACECIAUgAQR/IAUgASAEbDYCHCAFIAAoAgQ2AhQgAwUgAgs2Ahgg +BUEIaiADIAggBUEUahBxIAUoAghBAUcNASAFKAIQIQIgBSgCDCEHCyAHIAJBxIvAABCyAQALIAUo +AgwhASAAIAY2AgAgACABNgIEIAVBIGokAAvKAQIEfwF+IwBBIGsiAyQAAkACQCABIAEgAmoiAksN +AEEIIAIgACgCACIBQQF0IgQgAiAESxsiAiACQQhNGyIErSIHQiCIUEUNACAHpyIFQf////8HSw0A +IAMgAQR/IAMgATYCHCADIAAoAgQ2AhRBAQVBAAs2AhggA0EIakEBIAUgA0EUahBxIAMoAghBAUcN +ASADKAIQIQIgAygCDCEGCyAGIAJBmJnAABCyAQALIAMoAgwhASAAIAQ2AgAgACABNgIEIANBIGok +AAuJAgEBfyMAQRBrIgIkACAAKAIAIQACfyABLQALQRhxRQRAIAEoAgAgACABKAIEKAIQEQAADAEL +IAJBADYCDCABIAJBDGoCfyAAQYABTwRAIABBgBBPBEAgAEGAgARPBEAgAiAAQT9xQYABcjoADyAC +IABBEnZB8AFyOgAMIAIgAEEGdkE/cUGAAXI6AA4gAiAAQQx2QT9xQYABcjoADUEEDAMLIAIgAEE/ +cUGAAXI6AA4gAiAAQQx2QeABcjoADCACIABBBnZBP3FBgAFyOgANQQMMAgsgAiAAQT9xQYABcjoA +DSACIABBBnZBwAFyOgAMQQIMAQsgAiAAOgAMQQELEDkLIAJBEGokAAuqAgIDfwF+IwBBQGoiAiQA +IAEoAgBBgICAgHhGBEAgASgCDCEDIAJBJGoiBEEANgIAIAJCgICAgBA3AhwgAkEwaiADKAIAIgNB +CGopAgA3AwAgAkE4aiADQRBqKQIANwMAIAIgAykCADcDKCACQRxqQYjGwAAgAkEoahA7GiACQRhq +IAQoAgAiAzYCACACIAIpAhwiBTcDECABQQhqIAM2AgAgASAFNwIACyABKQIAIQUgAUKAgICAEDcC +ACACQQhqIgMgAUEIaiIBKAIANgIAIAFBADYCAEH5gcEALQAAGiACIAU3AwBBDEEEEMABIgFFBEBB +BEEMEOYBAAsgASACKQMANwIAIAFBCGogAygCADYCACAAQaTIwAA2AgQgACABNgIAIAJBQGskAAua +AgEDfyMAQRBrIgYkACABIAEoAggiBUEAIAVBAUcbNgIIAkACQAJAIAVBAUYEQCABKAIEIQQgASgC +ACEFIAFBDBDMASADRQ0BIAUgAiAD/AoAAAwBCyADQQBIDQECQCADRQRAQQEhBQwBC0H5gcEALQAA +GkEBIQQgA0EBEMABIgVFDQILIAMEQCAFIAIgA/wKAAALIAEgASgCCCICQQFrNgIIIAMhBCACQQFH +DQAgASgCACABQQRqKAIAIgRBARCzAUUNAiAEEMwBIAFBDBDMASADIQQLIAAgAzYCCCAAIAU2AgQg +ACAENgIAIAZBEGokAA8LIAQgA0GYtcAAELIBAAtB1LbAAEErIAZBD2pBxLbAAEGQt8AAEHoAC4IC +AgF+An8jAEGAAWsiBCQAIAAoAgApAwAhAgJ/AkAgASgCCCIAQYCAgBBxRQRAIABBgICAIHENASAC +QQEgARBHDAILQQAhAANAIAAgBGpB/wBqIAKnQQ9xIgNBMHIgA0HXAGogA0EKSRs6AAAgAEEBayEA +IAJCD1YgAkIEiCECDQALIAFBAUG068AAQQIgACAEakGAAWpBACAAaxA1DAELQQAhAANAIAAgBGpB +/wBqIAKnQQ9xIgNBMHIgA0E3aiADQQpJGzoAACAAQQFrIQAgAkIPViACQgSIIQINAAsgAUEBQbTr +wABBAiAAIARqQYABakEAIABrEDULIARBgAFqJAALiAIBBX8CQAJAAkACQCABKAIAIgFBAXEEQEEd +QYEBIAIgAUF+cSIFayIGIANqIgFBCnZnQQJ0ayABQf//B0sbIQQgAiAFRgRAIAQhAiABIQMMBQsg +BEEFdiIHIAZqIgJBgICAwABJDQJB+YHBAC0AABpBFEEEEMABIgJFDQEgAkEBNgIQIAIgASAHaiII +NgIIIAIgBSAHazYCBCACIAg2AgAgAiAEQQJ2QQdxNgIMDAMLIAAgASACIAMQQQ8LQQRBFBDmAQAL +IARBHXEgAkEFdHIhAgsgASAGayIEQQAgASAETxshASAFIAZqIQULIAAgAjYCDCAAIAM2AgggACAB +NgIEIAAgBTYCAAuDAgEFfwJAAkACQAJAIAEoAgAiAUEBcQRAQR1BgQEgAiABayIGIANqIgRBCnZn +QQJ0ayAEQf//B0sbIQUgASACRgRAIAUhAiAEIQMMBQsgBUEFdiIHIAZqIgJBgICAwABJDQJB+YHB +AC0AABpBFEEEEMABIgJFDQEgAkEBNgIQIAIgBCAHaiIINgIIIAIgASAHazYCBCACIAg2AgAgAiAF +QQJ2QQdxNgIMDAMLIAAgASACIAMQQQ8LQQRBFBDmAQALIAVBHXEgAkEFdHIhAgsgBCAGayIFQQAg +BCAFTxshBCABIAZqIQELIAAgAjYCDCAAIAM2AgggACAENgIEIAAgATYCAAvVAQIEfwF+IwBBIGsi +AyQAAkACQCABIAEgAmoiAksEQEEAIQEMAQtBACEBQQggAiAAKAIAIgVBAXQiBCACIARLGyICIAJB +CE0bIgStIgdCIIhQRQ0AIAenIgZB/////wdLDQAgAyAFBH8gAyAFNgIcIAMgACgCBDYCFEEBBUEA +CzYCGCADQQhqQQEgBiADQRRqEHEgAygCCEEBRw0BIAMoAhAhAiADKAIMIQELIAEgAkH4xcAAELIB +AAsgAygCDCEBIAAgBDYCACAAIAE2AgQgA0EgaiQAC8oCAgR/AW8jAEEgayIDJAAQGSEHEG0iBSAH +JgEgA0EYaiIEIAU2AgQgBCACNgIAIAMoAhwhAgJAIAMoAhgiBEUEQEEBIQUMAQsgAyACNgIcIAMg +BDYCGCADQRBqIgQgASgCBCABKAIIELUBNgIEIARBADYCAEEBIQUgAygCFCEEAkACQCADKAIQQQFx +BEAgAiEBIAQhAgwBCyADQRxqIgZBnITAAEEEEDwgBBDNASABKAIMuBALIQcQbSIEIAcmASADQQhq +IgIgBDYCBCACQQA2AgAgAygCDCECIAMoAghBAXFFDQEgAygCHCEBCyABQYQBSQ0BIAEQagwBCyAG +QaCEwABBBhA8IAIQzQEgAS0AECEBIAZB0oTAAEEFEDxBggFBgwEgARsQzQFBACEFIAMoAhwhAgsg +ACACNgIEIAAgBTYCACADQSBqJAAL2QMBB38jAEEQayIGJAACQAJAIAJBB00EQCACDQEMAgsgBkEI +aiEHAkACQAJAAkAgAUEDakF8cSIDIAFGDQAgAiADIAFrIgMgAiADSRsiBEUNAEEAIQNBASEFA0Ag +ASADai0AAEEuRg0EIAQgA0EBaiIDRw0ACyAEIAJBCGsiCEsNAgwBCyACQQhrIQhBACEEC0Gu3Ljx +AiEDA0BBgIKECCABIARqIgkoAgBBrty48QJzIgVrIAVyQYCChAggCUEEaigCAEGu3LjxAnMiBWsg +BXJxQYCBgoR4cUGAgYKEeEcNASAEQQhqIgQgCE0NAAsLIAIgBEcEQEEuIQNBASEFA0AgASAEai0A +AEEuRgRAIAQhAwwDCyACIARBAWoiBEcNAAsLQQAhBQsgByADNgIEIAcgBTYCACAGKAIIQQFGIQMM +AQsgAS0AAEEuRiIDIAJBAUZyDQAgAS0AAUEuRiIDIAJBAkZyDQAgAS0AAkEuRiIDIAJBA0ZyDQAg +AS0AA0EuRiIDIAJBBEZyDQAgAS0ABEEuRiIDIAJBBUZyDQAgAS0ABUEuRiIDIAJBBkZyDQAgAS0A +BkEuRiEDCyAAIAMgAC0ABHI6AAQgACgCACABIAIQvAEgBkEQaiQAC+QBAQR/IwBBEGsiAyQAIAAo +AgwhAQJAAn8CQAJAAkACQAJAIAAoAgQOAgABAgsgAQ0BQQEhAUEAIQBBASECDAMLIAFFDQELIANB +BGogABBFIAMoAgQhACADKAIIIQIgAygCDAwCCyAAKAIAIgEoAgQiAEEASA0CIAEoAgAhASAARQRA +QQEhAkEAIQAMAQtB+YHBAC0AABpBASEEIABBARDAASICRQ0CCyAABEAgAiABIAD8CgAACyAACyEB +IAIgARC2ASAABEAgAiAAEMwBCyADQRBqJAAPCyAEIABBzJDAABCyAQALlAICAX8BfiMAQaABayIC +JAAgAkKAgICA8AYiAyABQRhqrYQ3AzggAiADIAFBEGqthDcDMCACIAMgAUEIaq2ENwMoIAIgAyAB +rYQ3AyAgAkHMucAANgIIIAJBBDYCDCACQQQ2AhwgAkKDgICAgISAgGk3ApgBIAJBgIDAADYCkAEg +AkECOwGIASACQoKAgICAhICAaTcCgAEgAkGAgMAANgJ4IAJBAjsBcCACQoGAgICAhICAaTcCaCAC +QYCAwAA2AmAgAkECOwFYIAJCgICAgICEgIBpNwJQIAJCgIDAADcCSCACQQI7AUAgAiACQUBrNgIY +IAJBBDYCFCACIAJBIGo2AhAgACACQQhqEEUgAkGgAWokAAvyAQECfyMAQTBrIgIkAAJAIAApAwBC +////////////AINCgICAgICAgPj/AFoEQCACQQE2AhQgAkGkwMAANgIQIAJCATcCHCACIACtQoCA +gICQCIQ3AyggAiACQShqNgIYIAEoAgAgASgCBCACQRBqEDshAwwBCyACQQA6AAwgAiABNgIIQQEh +AyACQQE2AhQgAkGkwMAANgIQIAJCATcCHCACIACtQoCAgICQCIQ3AyggAiACQShqNgIYIAJBCGpB +jL7AACACQRBqEDsNACACLQAMRQRAIAFBrMDAAEECELwBDQELQQAhAwsgAkEwaiQAIAMLlQIBAn8j +AEEgayIFJABB5ILBAEHkgsEAKAIAIgZBAWo2AgACf0EAIAZBAEgNABpBAUGwhsEALQAADQAaQbCG +wQBBAToAAEGshsEAQayGwQAoAgBBAWo2AgBBAgtB/wFxIgZBAkcEQCAGQQFxBEAgBUEIaiAAIAEo +AhgRAgALAAsCQEHYgsEAKAIAIgZBAE4EQEHYgsEAIAZBAWo2AgBB3ILBACgCAARAIAUgACABKAIU +EQIAIAUgBDoAHSAFIAM6ABwgBSACNgIYIAUgBSkDADcCEEHcgsEAKAIAIAVBEGpB4ILBACgCACgC +FBECAAtB2ILBAEHYgsEAKAIAQQFrNgIAQbCGwQBBADoAACADRQ0BAAsACwALxAECBn8BfiMAQSBr +IgIkAEEEIAAoAgAiBUEBdCIDIANBBE0bIgatQhR+IghCIIhQRQRAQQBBACABELIBAAsCQCAIpyIH +Qfz///8HTQRAQQAhAyACIAUEfyACIAVBFGw2AhwgAiAAKAIENgIUQQQFIAMLNgIYIAJBCGpBBCAH +IAJBFGoQcSACKAIIQQFHDQEgAigCDCEEIAIoAhAhAwsgBCADIAEQsgEACyACKAIMIQEgACAGNgIA +IAAgATYCBCACQSBqJAALuwEBAn8jAEEgayIDJAACQAJ/QQAgASABIAJqIgJLDQAaQQBBCCACIAAo +AgAiAUEBdCIEIAIgBEsbIgIgAkEITRsiBEEASA0AGkEAIQIgAyABBH8gAyABNgIcIAMgACgCBDYC +FEEBBSACCzYCGCADQQhqQQEgBCADQRRqEHEgAygCCEEBRw0BIAMoAhAhACADKAIMCyAAQbjKwAAQ +sgEACyADKAIMIQEgACAENgIAIAAgATYCBCADQSBqJAALwAEBBX8jAEEgayIBJAAgACgCACICQf// +/z9LBEBBAEEAQdCJwAAQsgEACwJAQQQgAkEBdCIDIANBBE0bIgNBBHQiBEH8////B00EfyABIAIE +fyABIAJBBHQ2AhwgASAAKAIENgIUQQQFQQALNgIYIAFBCGpBBCAEIAFBFGoQcSABKAIIQQFHDQEg +ASgCECEFIAEoAgwFQQALIAVB0InAABCyAQALIAEoAgwhAiAAIAM2AgAgACACNgIEIAFBIGokAAu9 +AQEDfyMAQRBrIgIkAAJAAkACQCABRQRAIABFDQEgAEEIayIBKAIAQQFHDQIgACgCLCAAKAIoIQMg +AUEANgIAAkAgAUF/Rg0AIABBBGsiACAAKAIAQQFrIgA2AgAgAA0AIAFByAAQzAELIANFDQMgAxDM +AQwDCyAARQ0AIAIgAEEIayIANgIMIAAgACgCAEEBayIANgIAIAANAiACQQxqEI8BDAILEN8BAAtB +14TAAEE/EOEBAAsgAkEQaiQAC8EBAgN/AX4jAEEwayICJAAgASgCAEGAgICAeEYEQCABKAIMIQMg +AkEUaiIEQQA2AgAgAkKAgICAEDcCDCACQSBqIAMoAgAiA0EIaikCADcDACACQShqIANBEGopAgA3 +AwAgAiADKQIANwMYIAJBDGpBiMbAACACQRhqEDsaIAJBCGogBCgCACIDNgIAIAIgAikCDCIFNwMA +IAFBCGogAzYCACABIAU3AgALIABBpMjAADYCBCAAIAE2AgAgAkEwaiQAC7YBAQF/IwBBEGsiAyQA +AkACQAJAIAAoAgAiAEEBcQRAIAEgAEF+cSIAayACaiIBQQEQswFFDQIgACABEMwBDAELIAAgACgC +CCIBQQFrNgIIIAFBAUcNACAAKAIAIABBBGooAgAiAkEBELMBRQ0CIAIQzAEgAEEMEMwBCyADQRBq +JAAPC0HUtsAAQSsgA0EPakHEtsAAQYC3wAAQegALQdS2wABBKyADQQ9qQcS2wABBkLfAABB6AAuw +AQEGfwJAAkAgAEGEAUkNACAA0G8mARBUIgEoAgwhBSABKAIQIQIgAUIANwIMIAEoAgghAyABKAIE +IQQgAUIENwIEIAEoAgAhBiABQQA2AgAgACACSQ0BIAAgAmsiACADTw0BIAQgAEECdGogBTYCACAB +IAI2AhAgASAANgIMIAEgAzYCCCABKAIEIAEgBDYCBCABKAIAIQAgASAGNgIAIABFDQAgAEECdBDM +AQsPCwALuQEBAX9B+YHBAC0AABoCQEEMQQQQwAEiBgRAIAZBAjYCCCAGIAM2AgAgBiAEIANrIAVq +NgIEIAEgBiABKAIAIgEgASACRiICGzYCACACRQRAIAEgASgCCCICQQFqNgIIIAJBAEgNAiAAIAE2 +AgwgACAFNgIIIAAgBDYCBCAAQaC3wAA2AgAgBkEMEMwBDwsgACAGNgIMIAAgBTYCCCAAIAQ2AgQg +AEGgt8AANgIADwtBBEEMEOYBAAsAC7EBAQF/IwBBEGsiAyQAAkACQAJAIAAoAgAiAEEBcQRAIAEg +AGsgAmoiAUEBELMBRQ0CIAAgARDMAQwBCyAAIAAoAggiAUEBazYCCCABQQFHDQAgACgCACAAQQRq +KAIAIgJBARCzAUUNAiACEMwBIABBDBDMAQsgA0EQaiQADwtB1LbAAEErIANBD2pBxLbAAEGAt8AA +EHoAC0HUtsAAQSsgA0EPakHEtsAAQZC3wAAQegALzwMCDH8BfiMAQSBrIgQkACAEQRhqIgkQVCIF +QRBqIgcoAgA2AgAgBEEQaiIKIAVBCGoiCCkCADcDACAHQQA2AgAgCEIANwIAIAUpAgAhDCAFQoCA +gIDAADcCACAEIAw3AwgCfyMAQSBrIgMkAAJAAkAgBEEIaiIAKAIMIgEgACgCCCICRgRAAkAgACgC +ACICIAFGBEDQb0GAASABIAFBgAFNGyIG/A8BIgJBf0YNBAJAIAAoAhAiC0UEQCAAIAI2AhAMAQsg +ASALaiACRw0FCyABIAZqIgJB/////wFLDQQgAyABBH8gAyABQQJ0NgIcIAMgACgCBDYCFEEEBUEA +CzYCGCADQQhqQQQgAkECdCADQRRqEHEgAygCCEEBRg0EIAMoAgwhBiAAIAI2AgAgACAGNgIEDAEL +IAEgAk8NAwsgACABQQFqIgI2AgggACgCBCABQQJ0aiACNgIADAELIAEgAk8NAQsgACAAKAIEIAFB +AnRqKAIANgIMIAAoAhAgA0EgaiQAIAFqDAELAAsgCCAKKQMANwIAIAcgCSgCADYCACAFKAIEIQMg +BSgCACEBIAUgBCkDCDcCACABBEAgAyABQQJ0EMwBCyAEQSBqJAALrAEBAX8jAEEQayIGJAACQCAB +BEAgBkEEaiABIAMgBCAFIAIoAhARCQACQCAGKAIEIgIgBigCDCIBTQRAIAYoAgghBQwBCyACQQJ0 +IQIgBigCCCEDIAFFBEBBBCEFIAMgAhDMAQwBCyADIAJBBCABQQJ0IgIQuAEiBUUNAgsgACABNgIE +IAAgBTYCACAGQRBqJAAPC0Hos8AAQTIQ4QEAC0EEIAJB2LPAABCyAQALmgEBBH8jAEEgayICJABB +CCAAKAIAIgRBAXQiAyADQQhNGyIDQQBIBEBBAEEAIAEQsgEACyACIAQEfyACIAQ2AhwgAiAAKAIE +NgIUQQEFIAULNgIYIAJBCGpBASADIAJBFGoQcSACKAIIQQFGBEAgAigCDCACKAIQIAEQsgEACyAC +KAIMIQEgACADNgIAIAAgATYCBCACQSBqJAALpAEBAX8jAEFAaiICJAAgACgCACEAIAJCADcDOCAC +QThqIAAlARAjIAIgAigCPCIANgI0IAIgAigCODYCMCACIAA2AiwgAiACQSxqrUKAgICA0AiENwMg +IAJBAjYCDCACQbzEwAA2AgggAkIBNwIUIAIgAkEgajYCECABKAIAIAEoAgQgAkEIahA7IAIoAiwi +AQRAIAIoAjAgARDMAQsgAkFAayQAC48BAQF/IAJBAE4EQAJ/IAMoAgQEQAJAIAMoAggiBEUEQAwB +CyADKAIAIAQgASACELgBDAILCyABIAJFDQAaQfmBwQAtAAAaIAIgARDAAQsiA0UEQCAAIAI2Aggg +ACABNgIEIABBATYCAA8LIAAgAjYCCCAAIAM2AgQgAEEANgIADwsgAEEANgIEIABBATYCAAutAQED +fyABKAIEIQICfwJAIAEoAggiBCABKAIAIgNHBEBB+YHBAC0AABpBDEEEEMABIgENAUEEQQwQ5gEA +CyAERQRAQQAhAUEBIQJBqLXAAAwCCyACQQFxBEAgAiEBQbC2wAAMAgsgAkEBciEBQZy2wAAMAQsg +AUEBNgIIIAEgAzYCBCABIAI2AgBBoLfAAAshAyAAIAE2AgwgACAENgIIIAAgAjYCBCAAIAM2AgAL +wAECBX8BbwJAIAEoAgAiBRDuASIDQQBIDQACQCADRQRAQQEhBAwBC0H5gcEALQAAGkEBIQIgA0EB +EMABIgRFDQELECUhBxBtIgEgByYBIAEiBiUBEB4hBxBtIgEgByYBIAEQtwEhAiABQYQBTwRAIAEQ +agsgAiUBIAUlASAEECAgAkGEAU8EQCACEGoLIAZBhAFPBEAgBhBqCyAAIAUQ7gE2AgggACAENgIE +IAAgAzYCAA8LIAIgA0HYssAAELIBAAuUAQEDfyMAQRBrIgIkAAJ/QQEgASgCACIDQScgASgCBCIE +KAIQIgERAAANABogAkEEaiAAKAIAQYECEDQCQCACLQAEQYABRgRAIAMgAigCCCABEQAARQ0BQQEM +AgsgAyACLQAOIgAgAkEEamogAi0ADyAAayAEKAIMEQEARQ0AQQEMAQsgA0EnIAERAAALIAJBEGok +AAuVAQECfwJAIAJBAEgNACAAAn8gAkUEQEGotcAAIQNBASEEQQAMAQtB+YHBAC0AABpBASEDIAJB +ARDAASIERQ0BIAIEQCAEIAEgAvwKAAALIARBAXEEQEGwtsAAIQMgBAwBC0GctsAAIQMgBEEBcgs2 +AgwgACACNgIIIAAgBDYCBCAAIAM2AgAPCyADIAJBmLXAABCyAQALeQIBfgJ/IwBBgAFrIgQkACAA +KQMAIQJBACEAA0AgACAEakH/AGogAqdBD3EiA0EwciADQdcAaiADQQpJGzoAACAAQQFrIQAgAkIP +ViACQgSIIQINAAsgAUEBQbTrwABBAiAAIARqQYABakEAIABrEDUgBEGAAWokAAuEAQEBfwJAIANB +AEgNAAJAIANFBEBBASEBDAELQfmBwQAtAAAaQQEhBCADQQEQwAEiAUUNAQsgAwRAIAEgAiAD/AoA +AAsgACADNgIIIAAgAzYCBCAAIAE2AgAgAEEdQYEBIANBCnZnQQJ0ayADQf//B0sbNgIMDwsgBCAD +Qai4wAAQsgEAC6MBAgR/AW8CQCABLQAEBEBBAiEDDAELIAEoAgAlARATIQYQbSICIAYmAUHQgsEA +KAIAIQRBzILBACgCAEHMgsEAQgA3AgBBASEDQQFGBEAgAUEBOgAEDAELAn8gAiUBEBRFBEAgAiUB +EBUhBhBtIgEgBiYBIAEhBEEADAELIAFBAToABEECCyEDIAJBhAFJDQAgAhBqCyAAIAQ2AgQgACAD +NgIAC3oBAX8jAEEgayICJAACfyAAKAIAQYCAgIB4RwRAIAEgACgCBCAAKAIIELwBDAELIAJBEGog +ACgCDCgCACIAQQhqKQIANwMAIAJBGGogAEEQaikCADcDACACIAApAgA3AwggASgCACABKAIEIAJB +CGoQOwsgAkEgaiQAC3wBAX8jAEFAaiIFJAAgBSABNgIMIAUgADYCCCAFIAM2AhQgBSACNgIQIAVB +AjYCHCAFQaTrwAA2AhggBUICNwIkIAUgBUEQaq1CgICAgOALhDcDOCAFIAVBCGqtQoCAgIDwC4Q3 +AzAgBSAFQTBqNgIgIAVBGGogBBCeAQALcAEBfyMAQRBrIgEkACAAKAIAIgAgACgCCCICQQFrNgII +AkAgAkEBRgRAIAAoAgAgAEEEaigCACIDQQEQswFFDQEgAxDMASAAQQwQzAELIAFBEGokAA8LQdS2 +wABBKyABQQ9qQcS2wABBkLfAABB6AAvNAgEDfyMAQTBrIgMkACADIAI2AgQgAyABNgIAIANBAjYC +DCADQZCSwAA2AgggA0ICNwIUIAMgA61CgICAgMAChDcDKCADIACtQoCAgIDgAYQ3AyAgAyADQSBq +NgIQAn8jAEEQayICJAAgA0EIaiIAKAIMIQECQAJ/AkACQAJAAkACQCAAKAIEDgIAAQILIAENAUEB +IQVBACEAQQEhAQwDCyABRQ0BCyACQQRqIAAQRSACKAIMIQAgAigCCCEBIAIoAgQMAgsgACgCACIB +KAIEIgBBAEgNAiABKAIAIQUgAEUEQEEBIQFBACEADAELQfmBwQAtAAAaQQEhBCAAQQEQwAEiAUUN +AgsgAARAIAEgBSAA/AoAAAsgAAshBCABIAAQtgEgBARAIAEgBBDMAQsgAkEQaiQADAELIAQgAEGU +k8AAELIBAAsgA0EwaiQAC2oCAX8BfiMAQTBrIgMkACADIAE2AgQgAyAANgIAIANBAjYCDCADQfDp +wAA2AgggA0ICNwIUIANCgICAgPAIIgQgA62ENwMoIAMgBCADQQRqrYQ3AyAgAyADQSBqNgIQIANB +CGogAhCeAQALaAEBfwJAIANBAEgNAAJAIANFBEBBASEBDAELQfmBwQAtAAAaQQEhBCADQQEQwAEi +AUUNAQsgAwRAIAEgAiAD/AoAAAsgACADNgIIIAAgATYCBCAAIAM2AgAPCyAEIANBmLXAABCyAQAL +aQAjAEEwayIAJABB+IHBAC0AAEUEQCAAQTBqJAAPCyAAQQI2AgwgAEHsx8AANgIIIABCATcCFCAA +IAE2AiwgACAAQSxqrUKAgICA8AiENwMgIAAgAEEgajYCECAAQQhqQZTIwAAQngEAC5wCAgN/AX4j +AEEQayIBJAAgAUGogsEANgIEIABBsILBAC0AAEEDRwR/IAEgAUEEajYCCCABIAFBCGo2AgwgAUEM +aiECIwBBIGsiACQAAkACQAJAAkACQAJAAkBBsILBAC0AAEEBaw4DAgQBAAtBsILBAEECOgAAIAIo +AgAiAygCACECIANBADYCACACRQ0CIAIoAgBCgAg3AwBBsILBAEEDOgAACyAAQSBqJAAMBAsgAEEA +NgIYIABBATYCDCAAQdiswAA2AggMAgtBnK7AABDUAQALIABBADYCGCAAQQE2AgwgAEGYrcAANgII +CyAAQgQ3AhAgAEEIakGYr8AAEJ4BAAsgASgCBAVBqILBAAspAwAQrgEgAUEQaiQAUAteAQF/IwBB +MGsiAiQAIAIgATYCDCACIAA2AgggAkECNgIUIAJBjI/AADYCECACQgE3AhwgAiACQQhqrUKAgICA +8AGENwMoIAIgAkEoajYCGCACQRBqEGAgAkEwaiQAC14BAX8jAEEwayICJAAgAiABNgIMIAIgADYC +CCACQQI2AhQgAkGwj8AANgIQIAJCATcCHCACIAJBCGqtQoCAgIDwAYQ3AyggAiACQShqNgIYIAJB +EGoQYCACQTBqJAALWwEBfyABKAIAIgRBAXEEQCAAIAEgBCAEQX5xIAIgAxBrDwsgBCAEKAIIIgFB +AWo2AgggAUEATgRAIAAgBDYCDCAAIAM2AgggACACNgIEIABBoLfAADYCAA8LAAtYAQF/IAEoAgAi +BEEBcQRAIAAgASAEIAQgAiADEGsPCyAEIAQoAggiAUEBajYCCCABQQBOBEAgACAENgIMIAAgAzYC +CCAAIAI2AgQgAEGgt8AANgIADwsAC1gBAX8jAEEgayIDJAAgA0EYaiACQRhqKQAANwMAIANBEGog +AkEQaikAADcDACADQQhqIAJBCGopAAA3AwAgAyACKQAANwMAIAAgAyABQSAQMyADQSBqJAALTgAj +AEEgayIAJAAgAEEBNgIEIABByL3AADYCACAAQgE3AgwgAEKwvcCAkAc3AxggACAAQRhqNgIIIAEo +AgAgASgCBCAAEDsgAEEgaiQAC0sAIAEoAgAiAUEBcQRAIAFBfnEhASADBEAgASACIAP8CgAACyAA +IAM2AgggACABNgIEIAAgAiADaiABazYCAA8LIAAgASACIAMQWQtLAQF/IAAoAgAgACgCCCIDayAC +SQRAIAAgAyACQQFBARBVIAAoAgghAwsgAgRAIAAoAgQgA2ogASAC/AoAAAsgACACIANqNgIIQQAL +RwEBfyAAKAIAIAAoAggiA2sgAkkEQCAAIAMgAhBdIAAoAgghAwsgAgRAIAAoAgQgA2ogASAC/AoA +AAsgACACIANqNgIIQQALTQEBfyMAQTBrIgEkACABQQE2AgwgAUGI6cAANgIIIAFCATcCFCABIAFB +L2qtQoCAgIDQC4Q3AyAgASABQSBqNgIQIAFBCGogABCeAQALRAAgASgCACIBQQFxBEAgAwRAIAEg +AiAD/AoAAAsgACADNgIIIAAgATYCBCAAIAIgA2ogAWs2AgAPCyAAIAEgAiADEFkLOgEBfyMAQSBr +IgAkACAAQQA2AhggAEEBNgIMIABBmMnAADYCCCAAQgQ3AhAgAEEIakHMycAAEJ4BAAtHAQF/IAAo +AgAgACgCCCIDayACSQRAIAAgAyACEGUgACgCCCEDCyACBEAgACgCBCADaiABIAL8CgAACyAAIAIg +A2o2AghBAAtBAQJ/IwBBEGsiAiQAIAJBCGogACgCACUBEAogAigCCCIDIAIoAgwiACABEOcBIAAE +QCADIAAQzAELIAJBEGokAAtCAQF/IAAoAgAiACgCMCIBBEAgACgCNCABEMwBCwJAIABBf0YNACAA +IAAoAgRBAWsiATYCBCABDQAgAEHIABDMAQsLTwECf0H5gcEALQAAGiABKAIEIQIgASgCACEDQQhB +BBDAASIBRQRAQQRBCBDmAQALIAEgAjYCBCABIAM2AgAgAEG0yMAANgIEIAAgATYCAAuSdAMjfxp+ +AXwgASgCCCIDQYCAgAFxIQIgACsDACE/IANBgICAgAFxRQRAIAEgAkEARyEBQQAhACMAQYABayIH +JAAgP70hJQJ/QQMgP5lEAAAAAAAA8H9hDQAaQQIgJUKAgICAgICA+P8AgyImQoCAgICAgID4/wBR +DQAaICVC/////////weDIilCgICAgICAgAiEICVCAYZC/v///////w+DICVCNIinQf8PcSIAGyIn +QgGDISggJlAEQEEEIClQDQEaIABBswhrIQBCASEmIChQDAELQoCAgICAgIAgICdCAYYgJ0KAgICA +gICACFEiAhshJ0ICQgEgAhshJkHLd0HMdyACGyAAaiEAIChQCyECIAcgADsBeCAHICY3A3AgB0IB +NwNoIAcgJzcDYCAHIAI6AHoCfwJAAkACQCACQQJrIgIEQEEBIQBBk+jAAEGU6MAAICVCAFMiAxtB +k+jAAEEBIAMbIAEbIRcgJUI/iKcgAXIhG0EDIAIgAkEDTxtBAmsOAgMCAQsgB0EDNgIoIAdBlejA +ADYCJCAHQQI7ASBBASEXQQEhACAHQSBqDAMLIAdBAzYCKCAHQZjowAA2AiQgB0ECOwEgIAdBIGoM +AgsgB0EgaiEGIAdBD2ohDCMAQTBrIgMkAAJAAkACfwJAAkACQAJAAkACQAJAAkAgB0HgAGoiACkD +ACIlUEUEQCAAKQMIIidQDQEgACkDECImUA0CICUgJnwiJiAlVA0DICUgJ1QNBCAmQoCAgICAgICA +IFoNBSADIAAvARgiADsBCCADICUgJ30iJzcDACAAIABBIGsgACAmQoCAgIAQVCIBGyICQRBrIAIg +JkIghiAmIAEbIiZCgICAgICAwABUIgEbIgJBCGsgAiAmQhCGICYgARsiJkKAgICAgICAgAFUIgEb +IgJBBGsgAiAmQgiGICYgARsiJkKAgICAgICAgBBUIgEbIgJBAmsgAiAmQgSGICYgARsiJkKAgICA +gICAgMAAVCIBGyAmQgKGICYgARsiKEIAWSICayIBa8EiCkEASA0GIANCfyAKrSIpiCImICeDNwMQ +ICYgJ1QNCiADIAA7AQggAyAlNwMAIAMgJSAmgzcDECAlICZWDQpBoH8gAWvBQdAAbEGwpwVqQc4Q +bSIAQdEATw0HIABBBHQiAEHY2MAAaikDACIqQv////8PgyImICUgKUI/gyIlhiIrQiCIIjV+IixC +IIgiMSAqQiCIIikgNX4iMnwgKSArQv////8PgyIqfiIrQiCIIjZ8ITMgLEL/////D4MgJiAqfkIg +iHwgK0L/////D4N8IjdCgICAgAh8QiCIIStCAUEAIAEgAEHg2MAAai8BAGprQT9xrSIshiIqQgF9 +IS4gJiAnICWGIiVCIIgiJ34iLUL/////D4MgJiAlQv////8PgyIlfkIgiHwgJSApfiIlQv////8P +g3wiPkKAgICACHxCIIghNCAnICl+ITggJUIgiCE5IC1CIIghOiAAQeLYwABqLwEAIQEgKSAoIAKt +hiIlQiCIIjt+IjwgJiA7fiInQiCIIi98ICkgJUL/////D4MiJX4iKEIgiCIwfCAnQv////8PgyAl +ICZ+QiCIfCAoQv////8Pg3wiPUKAgICACHxCIIh8QgF8Ii0gLIinIgBBkM4ATwRAIABBwIQ9SQ0J +IABBgMLXL08EQEEIQQkgAEGAlOvcA0kiAhshCkGAwtcvQYCU69wDIAIbDAsLQQZBByAAQYCt4gRJ +IgIbIQpBwIQ9QYCt4gQgAhsMCgsgAEHkAE8EQEECQQMgAEHoB0kiAhshCkHkAEHoByACGwwKC0EK +QQEgAEEJSyIKGwwJC0Gv1MAAQRxBqOPAABCSAQALQdzUwABBHUG448AAEJIBAAtBjNXAAEEcQcjj +wAAQkgEAC0Hw1sAAQTZB6OTAABCSAQALQajWwABBN0HY5MAAEJIBAAtB6OPAAEEtQZjkwAAQkgEA +C0GD0sAAQR1BxNLAABCSAQALIABB0QBBmOPAABB9AAtBBEEFIABBoI0GSSICGyEKQZDOAEGgjQYg +AhsLIQIgKyAzfCEzIC0gLoMhJiAKIAFrQQFqIQUgLSA4IDp8IDl8IDR8fSI0QgF8IiggLoMhJ0EA +IQECQAJAAkACQAJAAkACQAJAA0AgACACbiELIAFBEUYNAiABIAxqIg4gC0EwaiINOgAAAkAgACAC +IAtsayIArSAshiIrICZ8IiUgKFoEQCABIApHDQEgAUEBaiEBQgEhJQNAICUhKCAnISkgAUERTw0G +IAEgDGogJkIKfiImICyIp0EwaiICOgAAIAFBAWohASAlQgp+ISUgJ0IKfiInICYgLoMiJlgNAAsg +JSAtIDN9fiIsICV8ISsgJyAmfSAqVCIADQcgLCAlfSIsICZWDQMMBwsgKCAlfSInIAKtICyGIihU +IQIgLSAzfSIsQgF8ISogJyAoVCAlICxCAX0iLFpyDQUgPUKAgICACHxCIIgiLSAvIDB8fCA8fCEn +QgIgOSA6fCA+QoCAgIAIfEIgiHwgOHwgJiAofCIlICt8fH0hLkIAIDEgNnwgN0KAgICACHxCIIh8 +IjEgMnwgJiArfHx9ITIgJSAxfCApIDUgO31+fCAvfSAwfSAtfSEpA0AgJSArfCIvICxUICcgMnwg +KSArfFpyRQRAICYgK3whJUEAIQIMBwsgDiANQQFrIg06AAAgJiAofCEmICcgLnwhLSAsIC9WBEAg +KCApfCEpICUgKHwhJSAnICh9IScgKCAtWA0BCwsgKCAtViECICYgK3whJQwFCyABQQFqIQEgAkEK +SSACQQpuIQJFDQALQajkwAAQmAEACyABIAxqQQFrIQogKiAxIDZ8IDdCgICAgAh8QiCIfCAyfEIK +fiAvIDB8ID1CgICAgAh8QiCIfCA8fEIKfn0gKH58IS0gKUIKfiAmICp8fSEuICwgJn0hL0IAISkD +QCAmICp8IiUgLFQgKSAvfCAmIC18WnJFBEBBACEADAULIAogAkEBayICOgAAICkgLnwiMCAqVCEA +ICUgLFoNBSApICp9ISkgJSEmICogMFgNAAsMBAtBEUERQbjkwAAQfQALIAFBEUHI5MAAEH0ACwJA +ICUgKlogAnINACAqICUgKHwiJlggKiAlfSAmICp9VHENACAGQQA2AgAMBAsgJSA0QgN9WCAlQgJa +cUUEQCAGQQA2AgAMBAsgBiAFOwEIIAYgAUEBajYCBAwCCyAmISULAkAgJSArWiAAcg0AICsgJSAq +fCImWCArICV9ICYgK31UcQ0AIAZBADYCAAwCCyAlIChCWH4gJ3xYICUgKEIUflpxRQRAIAZBADYC +AAwCCyAGIAU7AQggBiABNgIECyAGIAw2AgALIANBMGokAAwBCyADQQA2AhgjAEEQayIAJAAgACAD +NgIMIAAgA0EQajYCCCAAQQhqQYDqwAAgAEEMakGA6sAAIANBGGpB1NLAABBOAAsCQCAHKAIgBEAg +B0HYAGogB0EoaigCADYCACAHIAcpAiA3A1AMAQsgB0HQAGohDyAHQQ9qIQ0jAEGgCmsiASQAAkAC +QAJAAkACQAJAAkACQCAHQeAAaiIAKQMAIiVQRQRAIAApAwgiJlBFBEAgACkDECInUEUEQCAlICUg +J3wiKFgEQCAlICZaBEAgACwAGiEYIAAuARghACABICU+AgAgAUEBQQIgJUKAgICAEFQiAhs2AqAB +IAFBACAlQiCIpyACGzYCBCABQQhqQQBBmAH8CwAgASAmPgKkASABQQFBAiAmQoCAgIAQVCICGzYC +xAIgAUEAICZCIIinIAIbNgKoASABQawBakEAQZgB/AsAIAEgJz4CyAIgAUEBQQIgJ0KAgICAEFQi +Ahs2AugDIAFBACAnQiCIpyACGzYCzAIgAUHQAmpBAEGYAfwLACABQfADakEAQZwB/AsAIAFBATYC +7AMgAUEBNgKMBSAArCAoQgF9eX1CwprB6AR+QoChzaC0AnxCIIinIgLBIQ4CQCAAQQBOBEAgASAA +ECwaIAFBpAFqIAAQLBogAUHIAmogABAsGgwBCyABQewDakEAIABrwRAsGgsCQCAOQQBIBEAgAUEA +IA5rQf//A3EiABAqIAFBpAFqIAAQKiABQcgCaiAAECoMAQsgAUHsA2ogAkH//wFxECoLIAEoAqAB +IQMgAUH8CGogAUGgAfwKAAAgASADNgKcCgJAAkACQAJAIAEoAugDIgYgAyADIAZJGyICQShNBEAg +AkUEQEEAIQIMBAsgAkEBcSELIAJBAUcNAQwCCwwMCyACQT5xIREgAUH8CGohACABQcgCaiEFA0Ag +ACAIIAAoAgAiEiAFKAIAaiIKaiIINgIAIABBBGoiDCAMKAIAIhMgBUEEaigCAGoiDCAKIBJJIAgg +CklyaiIKNgIAIAwgE0kgCiAMSXIhCCAFQQhqIQUgAEEIaiEAIBEgCUECaiIJRw0ACwsgCwR/IAlB +AnQiACABQfwIamoiCiAKKAIAIgogAUHIAmogAGooAgBqIgAgCGoiCTYCACAAIApJIAAgCUtyBSAI +C0UNACACQShGDQEgAUH8CGogAkECdGpBATYCACACQQFqIQILIAEgAjYCnAogAiABKAKMBSIJIAIg +CUsbIgBBKUkEQCAAQQJ0IQACQAJAAn8CQANAIABFDQEgAEEEayIAIAFB7ANqaigCACICIAAgAUH8 +CGpqKAIAIgpGDQALIAIgCksgAiAKSWsMAQtBf0EAIAAbCyAYTgRAAkAgA0UEQEEAIQMMAQsgA0EB +a0H/////A3EiAEEBaiICQQNxIQUCQCAAQQNJBEAgASEAQgAhJQwBCyACQfz///8HcSEKIAEhAEIA +ISUDQCAAIAA1AgBCCn4gJXwiJT4CACAAQQRqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIABBCGoiAiAC +NQIAQgp+ICVCIIh8IiU+AgAgAEEMaiICIAI1AgBCCn4gJUIgiHwiJj4CACAmQiCIISUgAEEQaiEA +IApBBGsiCg0ACwsgBQRAA0AgACAANQIAQgp+ICV8IiY+AgAgAEEEaiEAICZCIIghJSAFQQFrIgUN +AAsLICZCgICAgBBUDQAgA0EoRg0DIAEgA0ECdGogJT4CACADQQFqIQMLIAEgAzYCoAEgASgCxAIi +AkEpTw0NIAECf0EAIAJFDQAaIAJBAWtB/////wNxIgBBAWoiA0EDcSEFAkAgAEEDSQRAIAFBpAFq +IQBCACElDAELIANB/P///wdxIQogAUGkAWohAEIAISUDQCAAIAA1AgBCCn4gJXwiJT4CACAAQQRq +IgMgAzUCAEIKfiAlQiCIfCIlPgIAIABBCGoiAyADNQIAQgp+ICVCIIh8IiU+AgAgAEEMaiIDIAM1 +AgBCCn4gJUIgiHwiJj4CACAmQiCIISUgAEEQaiEAIApBBGsiCg0ACwsgBQRAA0AgACAANQIAQgp+ +ICV8IiY+AgAgAEEEaiEAICZCIIghJSAFQQFrIgUNAAsLIAIgJkKAgICAEFQNABogAkEoRg0RIAFB +pAFqIAJBAnRqICU+AgAgAkEBags2AsQCIAEgBgR/IAZBAWtB/////wNxIgBBAWoiAkEDcSEFAkAg +AEEDSQRAIAFByAJqIQBCACElDAELIAJB/P///wdxIQogAUHIAmohAEIAISUDQCAAIAA1AgBCCn4g +JXwiJT4CACAAQQRqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIABBCGoiAiACNQIAQgp+ICVCIIh8IiU+ +AgAgAEEMaiICIAI1AgBCCn4gJUIgiHwiJj4CACAmQiCIISUgAEEQaiEAIApBBGsiCg0ACwsgBQRA +A0AgACAANQIAQgp+ICV8IiY+AgAgAEEEaiEAICZCIIghJSAFQQFrIgUNAAsLICZCgICAgBBUBEAg +ASAGNgLoAwwDCyAGQShGDREgAUHIAmogBkECdGogJT4CACAGQQFqBUEACzYC6AMMAQsgDkEBaiEO +CyABQZAFaiICIAFB7ANqIgBBoAH8CgAAIAEgCTYCsAYgAkEBECwhHSABKAKMBSECIAFBtAZqIgMg +AEGgAfwKAAAgASACNgLUByADQQIQLCEeIAEoAowFIQIgAUHYB2oiAyAAQaAB/AoAACABIAI2AvgI +IANBAxAsIR8CQAJAAkACQAJAAkAgASgC+AgiEiABKAKgASIJIAkgEkkbIgJBKE0EQCABQYwFaiEg +IAFBsAZqISEgAUHUB2ohIiABKAKMBSERIAEoArAGIRMgASgC1AchGUEAIQYDQCAGIQogAkECdCEA +An8CQAJAAkADQCAARQ0BIAAgImohAyAAQQRrIgAgAWooAgAiBiADKAIAIgNGDQALIAMgBksNAQwC +CyAARQ0BCyAJIQJBAAwBCyACBEBBASEIQQAhCSACQQFHBEAgAkE+cSEMIAEiAEHYB2ohBQNAIAAg +CCAAKAIAIgsgBSgCAEF/c2oiA2oiCDYCACAAQQRqIgYgBigCACIQIAVBBGooAgBBf3NqIgYgAyAL +SSADIAhLcmoiAzYCACAGIBBJIAMgBklyIQggBUEIaiEFIABBCGohACAMIAlBAmoiCUcNAAsLIAJB +AXEEfyABIAlBAnQiAGoiAyADKAIAIgMgACAfaigCAEF/c2oiACAIaiIGNgIAIAAgA0kgACAGS3IF +IAgLRQ0WCyABIAI2AqABQQgLIQsgGSACIAIgGUkbIgZBKU8NAyAGQQJ0IQACQAJAAkADQCAARQ0B +IAAgIWohAyAAQQRrIgAgAWooAgAiCSADKAIAIgNGDQALIAMgCU0NASACIQYMAgsgAEUNACACIQYM +AQsgBgRAQQEhCEEAIQkgBkEBRwRAIAZBPnEhDCABIgBBtAZqIQUDQCAAIAggACgCACIQIAUoAgBB +f3NqIgJqIgg2AgAgAEEEaiIDIAMoAgAiFCAFQQRqKAIAQX9zaiIDIAIgEEkgAiAIS3JqIgI2AgAg +AyAUSSACIANJciEIIAVBCGohBSAAQQhqIQAgDCAJQQJqIglHDQALCyAGQQFxBH8gASAJQQJ0IgBq +IgIgAigCACICIAAgHmooAgBBf3NqIgAgCGoiAzYCACAAIAJJIAAgA0tyBSAIC0UNFgsgASAGNgKg +ASALQQRyIQsLIBMgBiAGIBNJGyIDQSlPDQQgA0ECdCEAAkACQAJAA0AgAEUNASAAICBqIQIgAEEE +ayIAIAFqKAIAIgkgAigCACICRg0ACyACIAlNDQEgBiEDDAILIABFDQAgBiEDDAELIAMEQEEBIQhB +ACEJIANBAUcEQCADQT5xIQwgASIAQZAFaiEFA0AgACAIIAAoAgAiECAFKAIAQX9zaiICaiIINgIA +IABBBGoiBiAGKAIAIhQgBUEEaigCAEF/c2oiBiACIBBJIAIgCEtyaiICNgIAIAYgFEkgAiAGSXIh +CCAFQQhqIQUgAEEIaiEAIAwgCUECaiIJRw0ACwsgA0EBcQR/IAEgCUECdCIAaiICIAIoAgAiAiAA +IB1qKAIAQX9zaiIAIAhqIgY2AgAgACACSSAAIAZLcgUgCAtFDRYLIAEgAzYCoAEgC0ECaiELCyAR +IAMgAyARSRsiAkEpTw0TIAJBAnQhAAJAAkACQANAIABFDQEgAEEEayIAIAFqKAIAIgYgACABQewD +amooAgAiCUYNAAsgBiAJTw0BIAMhAgwCCyAARQ0AIAMhAgwBCyACBEBBASEIQQAhCSACQQFHBEAg +AkE+cSEMIAEiAEHsA2ohBQNAIAAgCCAAKAIAIhAgBSgCAEF/c2oiA2oiCDYCACAAQQRqIgYgBigC +ACIUIAVBBGooAgBBf3NqIgYgAyAQSSADIAhLcmoiAzYCACAGIBRJIAMgBklyIQggBUEIaiEFIABB +CGohACAMIAlBAmoiCUcNAAsLIAJBAXEEfyABIAlBAnQiAGoiAyADKAIAIgMgAUHsA2ogAGooAgBB +f3NqIgAgCGoiBjYCACAAIANJIAAgBktyBSAIC0UNFgsgASACNgKgASALQQFqIQsLIApBEUYNBiAK +IA1qIAtBMGo6AAAgASgCxAIiDCACIAIgDEkbIgBBKU8NFSAKQQFqIQYgAEECdCEAAn8CQANAIABF +DQEgAEEEayIAIAFqKAIAIgMgACABQaQBamooAgAiCUYNAAsgAyAJSyADIAlJawwBC0F/QQAgABsL +IRQgAUH8CGogAUGgAfwKAAAgASACNgKcCiABKALoAyILIAIgAiALSRsiA0EoSw0FAkAgA0UEQEEA +IQMMAQtBACEIQQAhCSADQQFHBEAgA0E+cSEjIAFB/AhqIQAgAUHIAmohBQNAIAAgCCAAKAIAIiQg +BSgCAGoiEGoiFTYCACAAQQRqIgggCCgCACIWIAVBBGooAgBqIgggECAkSSAQIBVLcmoiEDYCACAI +IBZJIAggEEtyIQggBUEIaiEFIABBCGohACAjIAlBAmoiCUcNAAsLIANBAXEEfyAJQQJ0IgAgAUH8 +CGpqIgkgCSgCACIJIAFByAJqIABqKAIAaiIAIAhqIgU2AgAgACAJSSAAIAVLcgUgCAtFDQAgA0Eo +Rg0XIAFB/AhqIANBAnRqQQE2AgAgA0EBaiEDCyABIAM2ApwKIAMgESADIBFLGyIAQSlPDRUgAEEC +dCEAAn8CQANAIABFDQEgAEEEayIAIAFB7ANqaigCACIDIAAgAUH8CGpqKAIAIglGDQALIAMgCUsg +AyAJSWsMAQtBf0EAIAAbCyAYTiIAIBQgGEgiA0VxRQRAIAANEyADDQMMEgtBACEDIAECf0EAIAJF +DQAaIAJBAWtB/////wNxIgBBAWoiCkEDcSEFAkAgAEEDSQRAIAEhAEIAISUMAQsgCkH8////B3Eh +CiABIQBCACElA0AgACAANQIAQgp+ICV8IiU+AgAgAEEEaiIJIAk1AgBCCn4gJUIgiHwiJT4CACAA +QQhqIgkgCTUCAEIKfiAlQiCIfCIlPgIAIABBDGoiCSAJNQIAQgp+ICVCIIh8IiY+AgAgJkIgiCEl IABBEGohACAKQQRrIgoNAAsLIAUEQANAIAAgADUCAEIKfiAlfCImPgIAIABBBGohACAmQiCIISUg -BUEBayIFDQALCyAmQoCAgIAQVA0AIANBKEYNAyABIANBAnRqICU+AgAgA0EBaiEDCyABIAM2AqAB -IAEoAsQCIgJBKU8NDSABAn9BACACRQ0AGiACQQFrQf////8DcSIAQQFqIgNBA3EhBQJAIABBA0kE -QCABQaQBaiEAQgAhJQwBCyADQfz///8HcSEKIAFBpAFqIQBCACElA0AgACAANQIAQgp+ICV8IiU+ -AgAgAEEEaiIDIAM1AgBCCn4gJUIgiHwiJT4CACAAQQhqIgMgAzUCAEIKfiAlQiCIfCIlPgIAIABB -DGoiAyADNQIAQgp+ICVCIIh8IiY+AgAgJkIgiCElIABBEGohACAKQQRrIgoNAAsLIAUEQANAIAAg -ADUCAEIKfiAlfCImPgIAIABBBGohACAmQiCIISUgBUEBayIFDQALCyACICZCgICAgBBUDQAaIAJB -KEYNESABQaQBaiACQQJ0aiAlPgIAIAJBAWoLNgLEAiABIAYEfyAGQQFrQf////8DcSIAQQFqIgJB -A3EhBQJAIABBA0kEQCABQcgCaiEAQgAhJQwBCyACQfz///8HcSEKIAFByAJqIQBCACElA0AgACAA -NQIAQgp+ICV8IiU+AgAgAEEEaiICIAI1AgBCCn4gJUIgiHwiJT4CACAAQQhqIgIgAjUCAEIKfiAl -QiCIfCIlPgIAIABBDGoiAiACNQIAQgp+ICVCIIh8IiY+AgAgJkIgiCElIABBEGohACAKQQRrIgoN -AAsLIAUEQANAIAAgADUCAEIKfiAlfCImPgIAIABBBGohACAmQiCIISUgBUEBayIFDQALCyAmQoCA -gIAQVARAIAEgBjYC6AMMAwsgBkEoRg0RIAFByAJqIAZBAnRqICU+AgAgBkEBagVBAAs2AugDDAEL -IA5BAWohDgsgAUGQBWoiAiABQewDaiIAQaAB/AoAACABIAk2ArAGIAJBARAtIR0gASgCjAUhAiAB -QbQGaiIDIABBoAH8CgAAIAEgAjYC1AcgA0ECEC0hHiABKAKMBSECIAFB2AdqIgMgAEGgAfwKAAAg -ASACNgL4CCADQQMQLSEfAkACQAJAAkACQAJAIAEoAvgIIhIgASgCoAEiCSAJIBJJGyICQShNBEAg -AUGMBWohICABQbAGaiEhIAFB1AdqISIgASgCjAUhESABKAKwBiETIAEoAtQHIRlBACEGA0AgBiEK -IAJBAnQhAAJ/AkACQAJAA0AgAEUNASAAICJqIQMgAEEEayIAIAFqKAIAIgYgAygCACIDRg0ACyAD -IAZLDQEMAgsgAEUNAQsgCSECQQAMAQsgAgRAQQEhCEEAIQkgAkEBRwRAIAJBPnEhDCABIgBB2Adq -IQUDQCAAIAggACgCACILIAUoAgBBf3NqIgNqIgg2AgAgAEEEaiIGIAYoAgAiECAFQQRqKAIAQX9z -aiIGIAMgC0kgAyAIS3JqIgM2AgAgBiAQSSADIAZJciEIIAVBCGohBSAAQQhqIQAgDCAJQQJqIglH -DQALCyACQQFxBH8gASAJQQJ0IgBqIgMgAygCACIDIAAgH2ooAgBBf3NqIgAgCGoiBjYCACAAIANJ -IAAgBktyBSAIC0UNFgsgASACNgKgAUEICyELIBkgAiACIBlJGyIGQSlPDQMgBkECdCEAAkACQAJA -A0AgAEUNASAAICFqIQMgAEEEayIAIAFqKAIAIgkgAygCACIDRg0ACyADIAlNDQEgAiEGDAILIABF -DQAgAiEGDAELIAYEQEEBIQhBACEJIAZBAUcEQCAGQT5xIQwgASIAQbQGaiEFA0AgACAIIAAoAgAi -ECAFKAIAQX9zaiICaiIINgIAIABBBGoiAyADKAIAIhQgBUEEaigCAEF/c2oiAyACIBBJIAIgCEty -aiICNgIAIAMgFEkgAiADSXIhCCAFQQhqIQUgAEEIaiEAIAwgCUECaiIJRw0ACwsgBkEBcQR/IAEg -CUECdCIAaiICIAIoAgAiAiAAIB5qKAIAQX9zaiIAIAhqIgM2AgAgACACSSAAIANLcgUgCAtFDRYL -IAEgBjYCoAEgC0EEciELCyATIAYgBiATSRsiA0EpTw0EIANBAnQhAAJAAkACQANAIABFDQEgACAg -aiECIABBBGsiACABaigCACIJIAIoAgAiAkYNAAsgAiAJTQ0BIAYhAwwCCyAARQ0AIAYhAwwBCyAD -BEBBASEIQQAhCSADQQFHBEAgA0E+cSEMIAEiAEGQBWohBQNAIAAgCCAAKAIAIhAgBSgCAEF/c2oi -AmoiCDYCACAAQQRqIgYgBigCACIUIAVBBGooAgBBf3NqIgYgAiAQSSACIAhLcmoiAjYCACAGIBRJ -IAIgBklyIQggBUEIaiEFIABBCGohACAMIAlBAmoiCUcNAAsLIANBAXEEfyABIAlBAnQiAGoiAiAC -KAIAIgIgACAdaigCAEF/c2oiACAIaiIGNgIAIAAgAkkgACAGS3IFIAgLRQ0WCyABIAM2AqABIAtB -AmohCwsgESADIAMgEUkbIgJBKU8NEyACQQJ0IQACQAJAAkADQCAARQ0BIABBBGsiACABaigCACIG -IAAgAUHsA2pqKAIAIglGDQALIAYgCU8NASADIQIMAgsgAEUNACADIQIMAQsgAgRAQQEhCEEAIQkg -AkEBRwRAIAJBPnEhDCABIgBB7ANqIQUDQCAAIAggACgCACIQIAUoAgBBf3NqIgNqIgg2AgAgAEEE -aiIGIAYoAgAiFCAFQQRqKAIAQX9zaiIGIAMgEEkgAyAIS3JqIgM2AgAgBiAUSSADIAZJciEIIAVB -CGohBSAAQQhqIQAgDCAJQQJqIglHDQALCyACQQFxBH8gASAJQQJ0IgBqIgMgAygCACIDIAFB7ANq -IABqKAIAQX9zaiIAIAhqIgY2AgAgACADSSAAIAZLcgUgCAtFDRYLIAEgAjYCoAEgC0EBaiELCyAK -QRFGDQYgCiANaiALQTBqOgAAIAEoAsQCIgwgAiACIAxJGyIAQSlPDRUgCkEBaiEGIABBAnQhAAJ/ -AkADQCAARQ0BIABBBGsiACABaigCACIDIAAgAUGkAWpqKAIAIglGDQALIAMgCUsgAyAJSWsMAQtB -f0EAIAAbCyEUIAFB/AhqIAFBoAH8CgAAIAEgAjYCnAogASgC6AMiCyACIAIgC0kbIgNBKEsNBQJA -IANFBEBBACEDDAELQQAhCEEAIQkgA0EBRwRAIANBPnEhIyABQfwIaiEAIAFByAJqIQUDQCAAIAgg -ACgCACIkIAUoAgBqIhBqIhU2AgAgAEEEaiIIIAgoAgAiFiAFQQRqKAIAaiIIIBAgJEkgECAVS3Jq -IhA2AgAgCCAWSSAIIBBLciEIIAVBCGohBSAAQQhqIQAgIyAJQQJqIglHDQALCyADQQFxBH8gCUEC -dCIAIAFB/AhqaiIJIAkoAgAiCSABQcgCaiAAaigCAGoiACAIaiIFNgIAIAAgCUkgACAFS3IFIAgL -RQ0AIANBKEYNFyABQfwIaiADQQJ0akEBNgIAIANBAWohAwsgASADNgKcCiADIBEgAyARSxsiAEEp -Tw0VIABBAnQhAAJ/AkADQCAARQ0BIABBBGsiACABQewDamooAgAiAyAAIAFB/AhqaigCACIJRg0A -CyADIAlLIAMgCUlrDAELQX9BACAAGwsgGE4iACAUIBhIIgNFcUUEQCAADRMgAw0DDBILQQAhAyAB -An9BACACRQ0AGiACQQFrQf////8DcSIAQQFqIgpBA3EhBQJAIABBA0kEQCABIQBCACElDAELIApB -/P///wdxIQogASEAQgAhJQNAIAAgADUCAEIKfiAlfCIlPgIAIABBBGoiCSAJNQIAQgp+ICVCIIh8 -IiU+AgAgAEEIaiIJIAk1AgBCCn4gJUIgiHwiJT4CACAAQQxqIgkgCTUCAEIKfiAlQiCIfCImPgIA -ICZCIIghJSAAQRBqIQAgCkEEayIKDQALCyAFBEADQCAAIAA1AgBCCn4gJXwiJj4CACAAQQRqIQAg -JkIgiCElIAVBAWsiBQ0ACwsgAiAmQoCAgIAQVA0AGiACQShGDRcgASACQQJ0aiAlPgIAIAJBAWoL -Igk2AqABAkAgDEUNACAMQQFrQf////8DcSIAQQFqIgJBA3EhBQJAIABBA0kEQCABQaQBaiEAQgAh -JQwBCyACQfz///8HcSEKIAFBpAFqIQBCACElA0AgACAANQIAQgp+ICV8IiU+AgAgAEEEaiICIAI1 -AgBCCn4gJUIgiHwiJT4CACAAQQhqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIABBDGoiAiACNQIAQgp+ -ICVCIIh8IiY+AgAgJkIgiCElIABBEGohACAKQQRrIgoNAAsLIAUEQANAIAAgADUCAEIKfiAlfCIm -PgIAIABBBGohACAmQiCIISUgBUEBayIFDQALCyAmQoCAgIAQVARAIAwhAwwBCyAMQShGDRcgAUGk -AWogDEECdGogJT4CACAMQQFqIQMLIAEgAzYCxAICQCALRQRAQQAhCwwBCyALQQFrQf////8DcSIA -QQFqIgJBA3EhBQJAIABBA0kEQCABQcgCaiEAQgAhJQwBCyACQfz///8HcSEKIAFByAJqIQBCACEl -A0AgACAANQIAQgp+ICV8IiU+AgAgAEEEaiICIAI1AgBCCn4gJUIgiHwiJT4CACAAQQhqIgIgAjUC -AEIKfiAlQiCIfCIlPgIAIABBDGoiAiACNQIAQgp+ICVCIIh8IiY+AgAgJkIgiCElIABBEGohACAK -QQRrIgoNAAsLIAUEQANAIAAgADUCAEIKfiAlfCImPgIAIABBBGohACAmQiCIISUgBUEBayIFDQAL -CyAmQoCAgIAQVA0AIAtBKEYNFyABQcgCaiALQQJ0aiAlPgIAIAtBAWohCwsgASALNgLoAyASIAkg -CSASSRsiAkEoTQ0ACwsMEQsgAUEBEC0aIAEoAowFIgAgASgCoAEiAiAAIAJLGyIAQSlPDQQgAEEC -dCEAIAFBBGshAiABQegDaiEDA0AgAEUNDiAAIANqIQkgACACaiAAQQRrIQAoAgAiDCAJKAIAIglG -DQALIAkgDE0NDgwPCyAGQShBrP3AABDWAQALIANBKEGs/cAAENYBAAsgA0EoQaz9wAAQ1gEAC0ER -QRFBmNbAABCAAQALDA0LDA0LDAsLDAsLQcjWwABBN0GA18AAEJcBAAtBkNfAAEE2QcjXwAAQlwEA -C0Gs1cAAQRxByNXAABCXAQALQfzUwABBHUGc1cAAEJcBAAtBz9TAAEEcQezUwAAQlwEACyAADQEL -IAYgDWohAiAKIQBBfyEFAkADQCAAQX9GDQEgBUEBaiEFIAAgDWogAEEBayEALQAAQTlGDQALIAAg -DWoiAkEBaiIDIAMtAABBAWo6AAAgBUUgAEECaiAKS3INASACQQJqQTAgBfwLAAwBCyANQTE6AAAg -CgRAIA1BAWpBMCAK/AsACyAGQRFJBEAgAkEwOgAAIA5BAWohDiAKQQJqIQYMAQsgBkERQajWwAAQ -gAEACyAGQRFNBEAgDyAOOwEIIA8gBjYCBCAPIA02AgAgAUGgCmokAAwFCyAGQRFBuNbAABDWAQAL -IAJBKEGs/cAAENYBAAtBvP3AAEEaQaz9wAAQlwEACyAAQShBrP3AABDWAQALQShBKEGs/cAAEIAB -AAsLIAcgBygCUCAHKAJUIAcvAVhBACAHQSBqEFEgBygCBCEAIAcoAgAMAQsgB0ECOwEgIAdBATYC -KCAHQbvowAA2AiQgB0EgagshASAHIAA2AlwgByABNgJYIAcgGzYCVCAHIBc2AlAgB0HQAGoQPyAH -QYABaiQADwsCfyABIQwgAkEARyECIAEvAQ4hEUEAIQEjAEHwCGsiByQAID+9IScCf0EDID+ZRAAA -AAAAAPB/YQ0AGkECICdCgICAgICAgPj/AIMiJkKAgICAgICA+P8AUQ0AGiAnQv////////8HgyIp -QoCAgICAgIAIhCAnQgGGQv7///////8PgyAnQjSIp0H/D3EiABsiJUIBgyEoICZQBEBBBCApUA0B -GiAAQbMIayEBQgEhJiAoUAwBC0KAgICAgICAICAlQgGGICVCgICAgICAgAhRIgEbISVCAkIBIAEb -ISZBy3dBzHcgARsgAGohASAoUAshACAHIAE7AegIIAcgJjcD4AggB0IBNwPYCCAHICU3A9AIIAcg -ADoA6ggCQAJ/AkACQAJAAkAgAEECayIDBEBBASEAQbPowABBtOjAACAnQgBTIgYbQbPowABBASAG -GyACGyEbICdCP4inIAJyIR1BAyADIANBA08bQQJrDgICAwELIAdBAzYCmAggB0G16MAANgKUCCAH -QQI7AZAIQQEhG0EBIQAgB0GQCGoMBAsgB0EDNgKYCCAHQbjowAA2ApQIIAdBAjsBkAggB0GQCGoM -AwtBAiEAIAdBAjsBkAggEUUNASAHIBE2AqAIIAdBADsBnAggB0ECNgKYCCAHQbHowAA2ApQIIAdB -kAhqDAILQXRBBSABwSIAQQBIGyAAbCIAQcD9AEkEQCAHQZAIaiEEIAdBEGohBSAAQQR2QRVqIgoh -AUGAgH5BACARayARwUEASBshCQJAAkACfwJAAkACQAJAIAdB0AhqIgApAwAiJVBFBEAgJUKAgICA -gICAgCBaDQEgAUUNAkGgfyAALwEYIgBBIGsgACAlQoCAgIAQVCIAGyICQRBrIAIgJUIghiAlIAAb -IiVCgICAgICAwABUIgAbIgJBCGsgAiAlQhCGICUgABsiJUKAgICAgICAgAFUIgAbIgJBBGsgAiAl -QgiGICUgABsiJUKAgICAgICAgBBUIgAbIgJBAmsgAiAlQgSGICUgABsiJUKAgICAgICAgMAAVCIA -GyAlQgKGICUgABsiJUIAWWsiA2vBQdAAbEGwpwVqQc4QbSIAQdEATw0DIABBBHQiAkH42MAAaikD -ACImQv////8PgyInICUgJUJ/hUI/iIYiJUIgiCIofiIpQiCIICZCIIgiJiAofnwgJiAlQv////8P -gyIlfiImQiCIfCApQv////8PgyAlICd+QiCIfCAmQv////8Pg3xCgICAgAh8QiCIfCIlQUAgAyAC -QYDZwABqLwEAamsiC0E/ca0iJ4inIQAgAkGC2cAAai8BACECICVCASAnhiIoQgF9IimDIiZQBEAg -AUEKSw0HIAFBAnRBjObAAGooAgAgAEsNBwsgAEGQzgBPBEAgAEHAhD1JDQUgAEGAwtcvTwRAQQhB -CSAAQYCU69wDSSIDGyEGQYDC1y9BgJTr3AMgAxsMBwtBBkEHIABBgK3iBEkiAxshBkHAhD1BgK3i -BCADGwwGCyAAQeQATwRAQQJBAyAAQegHSSIDGyEGQeQAQegHIAMbDAYLQQpBASAAQQlLIgYbDAUL -Qc/UwABBHEG85cAAEJcBAAtBzOXAAEEkQfDlwAAQlwEAC0GY5cAAQSFBgObAABCXAQALIABB0QBB -uOPAABCAAQALQQRBBSAAQaCNBkkiAxshBkGQzgBBoI0GIAMbCyEDAkACQAJAAkAgBiACa0EBasEi -CCAJwSICSgRAIAtB//8DcSEOIAggCWvBIAEgCCACayABSRsiC0EBayEPQQAhAgNAIAAgA24hDSAB -IAJGDQMgACADIA1sayEAIAIgBWogDUEwajoAACACIA9GDQQgAiAGRg0CIAJBAWohAiADQQpJIANB -Cm4hA0UNAAtBuObAABCdAQALIAQgBSABQQAgCCAJICVCCoAgA60gJ4YgKBBFDAULIAJBAWohAiAO -QQFrQT9xrSEqQgEhJQNAICUgKohQRQRAIARBADYCAAwGCyABIAJNDQMgAiAFaiAmQgp+IiYgJ4in -QTBqOgAAICVCCn4hJSAmICmDISYgCyACQQFqIgJHDQALIAQgBSABIAsgCCAJICYgKCAlEEUMBAsg -ASABQcjmwAAQgAEACyAEIAUgASALIAggCSAArSAnhiAmfCADrSAnhiAoEEUMAgsgAiABQdjmwAAQ -gAEACyAEQQA2AgALIAnBIRgCQCAHKAKQCARAIAdByAhqIAdBmAhqKAIANgIAIAcgBykCkAg3A8AI -DAELIAdBwAhqIRIgB0EQaiEJIwBBwAZrIgUkAAJAAkACQAJAAkACQAJAAkACQAJAAkACQCAHQdAI -aiIAKQMAIiVQRQRAIAApAwgiJlANASAAKQMQIidQDQIgJSAnfCAlVA0DICUgJlQNBCAALgEYIQAg -BSAlPgIMIAVBAUECICVCgICAgBBUIgEbNgKsASAFQQAgJUIgiKcgARs2AhAgBUEUakEAQZgB/AsA -IAVBtAFqQQBBnAH8CwAgBUEBNgKwASAFQQE2AtACIACsICVCAX15fULCmsHoBH5CgKHNoLQCfEIg -iKciAcEhDQJAIABBAE4EQCAFQQxqIAAQLRoMAQsgBUGwAWpBACAAa8EQLRoLAkAgDUEASARAIAVB -DGpBACANa0H//wNxECsMAQsgBUGwAWogAUH//wFxECsLIAUoAtACIQsgBUGcBWogBUGwAWpBoAH8 -CgAAIAUgCzYCvAYgCiIGQQpPBEAgBUGUBWohAgNAIAUoArwGIgRBKU8NCgJAIARFDQAgBEH///// -A2ohACAEQQJ0IQECfyAEQQFGBEBCACElIAVBnAVqIAFqDAELIAEgAmohBCAAQf////8DcUEBakH+ -////B3EhA0IAISUDQCAEQQRqIgEgATUCACAlQiCGhCIlQoCU69wDgCImPgIAIAQgBDUCACAlICZC -gJTr3AN+fUIghoQiJUKAlOvcA4AiJj4CACAlICZCgJTr3AN+fSElIARBCGshBCADQQJrIgMNAAsg -JUIghiElIARBCGoLIABBAXENAEEEayIAICUgADUCAIRCgJTr3AOAPgIACyAGQQlrIgZBCUsNAAsL -IAZBAnRBkObAAGooAgBBAXQiAkUNBSAFKAK8BiIEQSlPDQggBAR/IARB/////wNqIQAgBEECdCEB -IAKtISUCfyAEQQFGBEBCACEmIAVBnAVqIAFqDAELIAEgBWpBlAVqIQQgAEH/////A3FBAWpB/v// -/wdxIQNCACEmA0AgBEEEaiIBIAE1AgAgJkIghoQiJiAlgCInPgIAIAQgBDUCACAmICUgJ359QiCG -hCImICWAIic+AgAgJiAlICd+fSEmIARBCGshBCADQQJrIgMNAAsgJkIghiEmIARBCGoLIQEgAEEB -cUUEQCABQQRrIgAgJiAANQIAhCAlgD4CAAsgBSgCvAYFQQALIQECQAJAAkAgBSgCrAEiACABIAAg -AUsbIgFBKE0EQCABRQRAQQAhAQwECyABQQFxIQ4gAUEBRw0BQQAhBkEAIQgMAgsMFAsgAUE+cSEP -QQAhBiAFQZwFaiEEIAVBDGohA0EAIQgDQCAEIAQoAgAiFyADKAIAaiICIAZBAXFqIhM2AgAgBEEE -aiIGIAYoAgAiGSADQQRqKAIAaiIGIAIgF0kgAiATS3JqIgI2AgAgBiAZSSACIAZJciEGIANBCGoh -AyAEQQhqIQQgDyAIQQJqIghHDQALCyAOBH8gCEECdCICIAVBnAVqaiIDIAMoAgAiAyAFQQxqIAJq -KAIAaiICIAZqIgY2AgAgAiADSSACIAZLcgUgBgtBAXFFDQAgAUEoRg0KIAVBnAVqIAFBAnRqQQE2 -AgAgAUEBaiEBCyAFIAE2ArwGIAsgASABIAtJGyIEQSlPDQggBEECdCEEAkACQANAIARFDQEgBEEE -ayIEIAVBnAVqaigCACIBIAQgBUGwAWpqKAIAIgJGDQALIAEgAk8NAQwICyAEDQcLIA1BAWohDQwH -C0HP1MAAQRxB2NfAABCXAQALQfzUwABBHUHo18AAEJcBAAtBrNXAAEEcQfjXwAAQlwEAC0GQ18AA -QTZB6NjAABCXAQALQcjWwABBN0HY2MAAEJcBAAtB8/3AAEEbQaz9wAAQlwEACyAARQRAQQAhACAF -QQA2AqwBDAELIABBAWtB/////wNxIgFBAWoiAkEDcSEDAkAgAUEDSQRAIAVBDGohBEIAISUMAQsg -AkH8////B3EhASAFQQxqIQRCACElA0AgBCAENQIAQgp+ICV8IiU+AgAgBEEEaiICIAI1AgBCCn4g -JUIgiHwiJT4CACAEQQhqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIARBDGoiAiACNQIAQgp+ICVCIIh8 -IiY+AgAgJkIgiCElIARBEGohBCABQQRrIgENAAsLIAMEQANAIAQgBDUCAEIKfiAlfCImPgIAIARB -BGohBCAmQiCIISUgA0EBayIDDQALCyAmQoCAgIAQWgRAIABBKEYNAyAFQQxqIABBAnRqICU+AgAg -AEEBaiEACyAFIAA2AqwBC0EAIQYCQAJAAkACQCANwSIBIBjBIgJIIh5FBEAgDSAYa8EgCiABIAJr -IApJGyIIDQELQQAhCAwBCyAFQdQCaiIBIAVBsAFqIgBBoAH8CgAAIAUgCzYC9ANBASEXIAFBARAt -IR8gBSgC0AIhASAFQfgDaiICIABBoAH8CgAAIAUgATYCmAUgAkECEC0hICAFKALQAiEBIAVBnAVq -IgIgAEGgAfwKAAAgBSABNgK8BiAFQawBaiEhIAVB0AJqISIgBUH0A2ohFCAFQZgFaiEjQQAhDiAC -QQMQLSEkIAUoAqwBIQAgBSgC0AIhCyAFKAL0AyETIAUoApgFIRkgBSgCvAYhEAJAAkACQAJAA0Ag -AEEpTw0KIABBAnQhAUEAIQQCfwJAAkADQCABIARGDQEgBUEMaiAEaiAEQQRqIQQoAgBFDQALIBAg -ACAAIBBJGyIBQSlPDRQgAUECdCEEAkADQCAERQ0BIAQgI2ohAiAEQQRrIgQgBUEMamooAgAiAyAC -KAIAIgJGDQALIAIgA00NAkEADAMLIARFDQFBAAwCCyAIIApLDQQgCCAORg0IIAggDmsiAEUNCCAJ -IA5qQTAgAPwLAAwIC0EBIQZBACEAIAFBAUcEQCABQT5xIQ8gBUEMaiEEIAVBnAVqIQMDQCAEIAQo -AgAiFSADKAIAQX9zaiICIAZBAXFqIhY2AgAgBEEEaiIGIAYoAgAiGiADQQRqKAIAQX9zaiIGIAIg -FUkgAiAWS3JqIgI2AgAgBiAaSSACIAZJciEGIANBCGohAyAEQQhqIQQgDyAAQQJqIgBHDQALCyAB -QQFxBH8gAEECdCIAIAVBDGpqIgIgAigCACICIAAgJGooAgBBf3NqIgAgBmoiAzYCACAAIAJJIAAg -A0tyBSAGC0EBcUUNDCAFIAE2AqwBIAEhAEEICyEPIBkgACAAIBlJGyICQSlPDQMgAkECdCEEAkAC -QAJAA0AgBEUNASAEIBRqIQEgBEEEayIEIAVBDGpqKAIAIgMgASgCACIBRg0ACyABIANNDQEgACEC -DAILIARFDQAgACECDAELIAIEQEEBIQZBACEAIAJBAUcEQCACQT5xIRUgBUEMaiEEIAVB+ANqIQMD -QCAEIAQoAgAiFiADKAIAQX9zaiIBIAZBAXFqIho2AgAgBEEEaiIGIAYoAgAiHCADQQRqKAIAQX9z -aiIGIAEgFkkgASAaS3JqIgE2AgAgBiAcSSABIAZJciEGIANBCGohAyAEQQhqIQQgFSAAQQJqIgBH -DQALCyACQQFxBH8gAEECdCIAIAVBDGpqIgEgASgCACIBIAAgIGooAgBBf3NqIgAgBmoiAzYCACAA -IAFJIAAgA0tyBSAGC0EBcUUNDQsgBSACNgKsASAPQQRyIQ8LIBMgAiACIBNJGyIBQSlPDQQgAUEC -dCEEAkACQAJAA0AgBEUNASAEICJqIQAgBEEEayIEIAVBDGpqKAIAIgMgACgCACIARg0ACyAAIANN -DQEgAiEBDAILIARFDQAgAiEBDAELIAEEQEEBIQZBACEAIAFBAUcEQCABQT5xIRUgBUEMaiEEIAVB -1AJqIQMDQCAEIAQoAgAiFiADKAIAQX9zaiICIAZBAXFqIho2AgAgBEEEaiIGIAYoAgAiHCADQQRq -KAIAQX9zaiIGIAIgFkkgAiAaS3JqIgI2AgAgBiAcSSACIAZJciEGIANBCGohAyAEQQhqIQQgFSAA -QQJqIgBHDQALCyABQQFxBH8gAEECdCIAIAVBDGpqIgIgAigCACICIAAgH2ooAgBBf3NqIgAgBmoi -AzYCACAAIAJJIAAgA0tyBSAGC0EBcUUNDQsgBSABNgKsASAPQQJqIQ8LIAsgASABIAtJGyIAQSlP -DQogAEECdCEEAkACQAJAA0AgBEUNASAEICFqIQIgBEEEayIEIAVBDGpqKAIAIgMgAigCACICRg0A -CyACIANNDQEgASEADAILIARFDQAgASEADAELIAAEQEEBIQZBACEBIABBAUcEQCAAQT5xIRUgBUEM -aiEEIAVBsAFqIQMDQCAEIAQoAgAiFiADKAIAQX9zaiICIAZBAXFqIho2AgAgBEEEaiIGIAYoAgAi -HCADQQRqKAIAQX9zaiIGIAIgFkkgAiAaS3JqIgI2AgAgBiAcSSACIAZJciEGIANBCGohAyAEQQhq -IQQgFSABQQJqIgFHDQALCyAAQQFxBH8gAUECdCIBIAVBDGpqIgIgAigCACICIAVBsAFqIAFqKAIA -QX9zaiIBIAZqIgM2AgAgASACSSABIANLcgUgBgtBAXFFDQ0LIAUgADYCrAEgD0EBaiEPCyAKIA5N -DQEgCSAOaiAPQTBqOgAAIABBKU8NCgJAIABFBEBBACEADAELIABBAWtB/////wNxIgFBAWoiAkED -cSEDAkAgAUEDSQRAIAVBDGohBEIAISYMAQsgAkH8////B3EhASAFQQxqIQRCACEmA0AgBCAENQIA -Qgp+ICZ8IiU+AgAgBEEEaiICIAI1AgBCCn4gJUIgiHwiJT4CACAEQQhqIgIgAjUCAEIKfiAlQiCI -fCIlPgIAIARBDGoiAiACNQIAQgp+ICVCIIh8IiU+AgAgJUIgiCEmIARBEGohBCABQQRrIgENAAsL -IAMEQANAIAQgBDUCAEIKfiAmfCIlPgIAIARBBGohBCAlQiCIISYgA0EBayIDDQALCyAlQoCAgIAQ -VA0AIABBKEYNCiAFQQxqIABBAnRqICY+AgAgAEEBaiEACyAFIAA2AqwBIA5BAWohDiAXIAggF0si -AWohFyABDQALQQEhBgwECyAOIApBuNjAABCAAQALIAggCkHI2MAAENYBAAsgAkEoQaz9wAAQ1gEA -CwwMCwJAAkACQCALQSlJBEACQCALRQRAQQAhCwwBCyALQQFrQf////8DcSIBQQFqIgJBA3EhAwJA -IAFBA0kEQCAFQbABaiEEQgAhJQwBCyACQfz///8HcSEBIAVBsAFqIQRCACElA0AgBCAENQIAQgV+ -ICV8IiU+AgAgBEEEaiICIAI1AgBCBX4gJUIgiHwiJT4CACAEQQhqIgIgAjUCAEIFfiAlQiCIfCIl -PgIAIARBDGoiAiACNQIAQgV+ICVCIIh8IiY+AgAgJkIgiCElIARBEGohBCABQQRrIgENAAsLIAME -QANAIAQgBDUCAEIFfiAlfCImPgIAIARBBGohBCAmQiCIISUgA0EBayIDDQALCyAmQoCAgIAQVA0A -IAtBKEYNCCAFQbABaiALQQJ0aiAlPgIAIAtBAWohCwsgBSALNgLQAiALIAAgACALSRsiBEEpTw0G -IARBAnQhBCAFQQhqIQAgBUGsAWohAQJAAkADQCAERQ0BIAEgBGohAiAAIARqIARBBGshBCgCACID -IAIoAgAiAkYNAAsgAiADTw0FDAELIAYgBEVxRQ0EIAhBAWsiACAKTw0CIAAgCWotAABBAXFFDQQL -IAggCksNAiAIIAlqQQAhBCAJIQMCQANAIAQgCEYNASAEQQFqIQQgA0EBayIDIAhqIgAtAABBOUYN -AAsgACAALQAAQQFqOgAAIAggBGtBAWogCE8NBCAEQQFrIgFFDQQgAEEBakEwIAH8CwAMBAsCQCAI -RQRAQTEhBAwBCyAJQTE6AAAgCEEBRgRAQTAhBAwBC0EwIQQgCEEBayIARQ0AIAlBAWpBMCAA/AsA -CyANQQFqIQ0gHiAIIApPcg0DIAQ6AAAgCEEBaiEIDAMLIAtBKEGs/cAAENYBAAsgACAKQYjYwAAQ -gAEACyAIIApBmNjAABDWAQALIAggCksNAQsgEiANOwEIIBIgCDYCBCASIAk2AgAgBUHABmokAAwF -CyAIIApBqNjAABDWAQALIARBKEGs/cAAENYBAAtBKEEoQaz9wAAQgAEACyAAQShBrP3AABDWAQAL -Qbz9wABBGkGs/cAAEJcBAAsLIBggBy4ByAgiAEgEQCAHQQhqIAcoAsAIIAcoAsQIIAAgESAHQZAI -ahBRIAcoAgwhACAHKAIIDAMLQQIhACAHQQI7AZAIIBFFBEBBASEAIAdBATYCmAggB0G76MAANgKU -CCAHQZAIagwDCyAHIBE2AqAIIAdBADsBnAggB0ECNgKYCCAHQbHowAA2ApQIIAdBkAhqDAILQbzo -wABBJUHk6MAAEJcBAAtBASEAIAdBATYCmAggB0G76MAANgKUCCAHQZAIagshASAHIAA2AswIIAcg -ATYCyAggByAdNgLECCAHIBs2AsAIIAwgB0HACGoQPyAHQfAIaiQADAELIAFBKEGs/cAAENYBAAsL -QgEBfyMAQSBrIgMkACADQQA2AhAgA0EBNgIEIANCBDcCCCADIAE2AhwgAyAANgIYIAMgA0EYajYC -ACADIAIQowEAC0ABAX8gASgCACIBIAEoAggiBEEBajYCCCAEQQBIBEAACyAAIAE2AgwgACADNgII -IAAgAjYCBCAAQcC3wAA2AgALPAAgACABKQAANwAAIABBGGogAUEYaikAADcAACAAQRBqIAFBEGop -AAA3AAAgAEEIaiABQQhqKQAANwAAC5QCAQN/IAAoAgAhAiABKAIIIgBBgICAEHFFBEAgAEGAgIAg -cUUEQCACIAEQ2AEPC0EAIQAjAEGAAWsiBCQAIAIoAgAhAgNAIAAgBGpB/wBqIAJBD3EiA0EwciAD -QTdqIANBCkkbOgAAIABBAWshACACQQ9LIAJBBHYhAg0ACyABQQFB9uvAAEECIAAgBGpBgAFqQQAg -AGsQNiAEQYABaiQADwtBACEAIwBBgAFrIgQkACACKAIAIQIDQCAAIARqQf8AaiACQQ9xIgNBMHIg -A0HXAGogA0EKSRs6AAAgAEEBayEAIAJBD0sgAkEEdiECDQALIAFBAUH268AAQQIgACAEakGAAWpB -ACAAaxA2IARBgAFqJAALOAACQCACQYCAxABGDQAgACACIAEoAhARAABFDQBBAQ8LIANFBEBBAA8L -IAAgAyAEIAEoAgwRAQALLQACQCAAIAEQuAFFDQAgAARAQbmCwQAtAAAaIAAgARDFASIBRQ0BCyAB -DwsACzcBAX8jAEEgayIBJAAgAUEANgIYIAFBATYCDCABQaj+wAA2AgggAUIENwIQIAFBCGogABCj -AQALugUBB38jAEEQayIFJAAjAEEQayIHJAAgB0EEaiEIIwBBoAFrIgQkACAEQSBqIAAgARA3AkAg -BCgCIEEBRgRAIARBATYCBCAEQaCHwAA2AgAgBEIBNwIMIAQgBEGfAWqtQoCAgIDAAIQ3A2ggBCAE -QegAajYCCCAEQfgAaiAEEEcgBCgCfCIGIAQoAoABELoBIQkgBCgCeCIKBEAgBiAKENEBCyAIQYCA -gIB4NgIAIAggCTYCBAwBCyAEQRhqIARBQGsiBikDADcDACAEQRBqIARBOGoiCSkDADcDACAEQQhq -IARBMGoiCikDADcDACAEIAQpAyg3AwAgBEEgaiACIAMQNyAEKAIgQQFGBEAgBEEBNgJ8IARBwIfA -ADYCeCAEQgE3AoQBIAQgBEGfAWqtQoCAgIDAAIQ3A5ABIAQgBEGQAWo2AoABIARB6ABqIARB+ABq -EEcgBCgCbCIGIAQoAnAQugEhCSAEKAJoIgoEQCAGIAoQ0QELIAhBgICAgHg2AgAgCCAJNgIEDAEL -IARB4ABqIAYpAwA3AwAgBEHYAGogCSkDADcDACAEQdAAaiAKKQMANwMAIAQgBCkDKDcDSCAEQSBq -IgYgBCAEQcgAahCJASAIIAYQZAsgBEGgAWokACADBEAgAiADENEBCyABBEAgACABENEBCwJAAkAC -fyAHKAIEIgNBgICAgHhGBEBBASEBQQAhAEEAIQIgBygCCAwBCyAHKAIIIQECQCAHKAIMIgIgA08E -QCABIQAMAQsgAkUEQEEBIQAgASADENEBDAELIAEgA0EBIAIQvQEiAEUNAgtBACEBQQALIQMgBSAB -NgIMIAUgAzYCCCAFIAI2AgQgBSAANgIAIAdBEGokAAwBC0EBIAJB3IbAABC3AQALIAUoAgAgBSgC -BCAFKAIIIAUoAgwgBUEQaiQAC+oZAht/AX4jAEEQayINJAAjAEEgayIJJAAjAEEgayIEJAAgAa1C -DH4iHachAwJAAkACQAJAIB1CIIinIANB/P///wdLcg0AAn8gA0UEQEEEIQVBAAwBC0G5gsEALQAA -GkEEIQIgA0EEEMUBIgVFDQEgAQshAiAEQQA2AhwgBCAFNgIYIAQgAjYCFCABBEAgAUECdCEKQQgh -AgNAIARBCGogACAIaigCACIDEO8BIAQoAggiEEUNAyAEKAIMIQsgA0GEAU8EQCADEG0LIAQoAhQg -BkYEQCMAQSBrIgMkAEEEIARBFGoiBSgCACIMQQF0IgcgB0EETRsiD61CDH4iHUIgiFBFBEBBAEEA -QbDDwAAQtwEACwJAIB2nIg5B/P///wdNBH8gAyAMBH8gAyAMQQxsNgIcIAMgBSgCBDYCFEEEBUEA -CzYCGCADQQhqQQQgDiADQRRqEHQgAygCCEEBRw0BIAMoAhAhByADKAIMBUEACyAHQbDDwAAQtwEA -CyADKAIMIQcgBSAPNgIAIAUgBzYCBCADQSBqJAAgBCgCGCEFCyACIAVqIgMgCzYCACADQQRrIBA2 -AgAgA0EIayALNgIAIAQgBkEBaiIGNgIcIAJBDGohAiAKIAhBBGoiCEcNAAsgACABQQJ0ENEBCyAE -KAIYIQACQCAGIAQoAhQiAU8EQCAAIQIMAQsgAUEMbCEBIAZFBEBBBCECIAAgARDRAQwBCyAAIAFB -BCAGQQxsIgAQvQEiAkUNAwsgCSAGNgIEIAkgAjYCACAEQSBqJAAMAwsgAiADQZDDwAAQtwEAC0HA -w8AAQSgQ5wEAC0EEIABBoMPAABC3AQALIAkgCSgCBCIANgIQIAkgCSgCADYCDCAJIAA2AgggCUEU -aiEQIwBBMGsiBCQAIAlBCGoiASgCACECIAEoAgQhACABKAIIIQEgBEEAOgAvIAQgACABQQxsajYC -DCAEIAI2AgggBCAANgIEIAQgADYCACAEIARBL2o2AhAgBEEgaiEFIwBB4ABrIgIkAAJAAkACQAJA -AkAgBCgCBCIBIAQoAgwiBkYEQCABIQAMAQsgBCgCECEMIAQgAUEMaiIANgIEIAEoAgAhAyACQThq -IAEoAgQiByABKAIIEDcgAwRAIAcgAxDRAQsgAigCOEEBcUUNASAMQQE6AAALIAVBADYCCCAFQoCA -gICAATcCACAGIABrQQxuIQEgACAGRwRAA0AgACgCACIDBEAgAEEEaigCACADENEBCyAAQQxqIQAg -AUEBayIBDQALCyAEKAIIIgBFDQEgBCgCACAAQQxsENEBDAELIAJBMGoiAyACQdgAaikDADcDACAC -QShqIgcgAkHQAGopAwA3AwAgAkEgaiIIIAJByABqKQMANwMAIAIgAikDQDcDGEG5gsEALQAAGkGA -AUEIEMUBIgFFDQEgASACKQMYNwMAIAFBGGogAykDADcDACABQRBqIAcpAwA3AwAgAUEIaiAIKQMA -NwMAIAJBATYCFCACIAE2AhAgAkEENgIMIAQoAgghCiAEKAIAIQ8CQCAAIAZGDQAgAkFAayEIQSAh -B0EBIQMDQCAAKAIAIQsgAkE4aiAAQQRqKAIAIg4gAEEIaigCABA3IAsEQCAOIAsQ0QELIAIoAjhB -AXEEQCAMQQE6AAAgAEEMaiEADAILIAJBMGoiDiAIQRhqKQMANwMAIAJBKGoiESAIQRBqKQMANwMA -IAJBIGoiEyAIQQhqKQMANwMAIAIgCCkDADcDGCACKAIMIANGBEAgAkEMaiADQQFBCEEgEFcgAigC -ECEBCyABIAdqIgsgAikDGDcDACALQRhqIA4pAwA3AwAgC0EQaiARKQMANwMAIAtBCGogEykDADcD -ACACIANBAWoiAzYCFCAHQSBqIQcgAEEMaiIAIAZHDQALCyAGIABrQQxuIQEgACAGRwRAA0AgACgC -ACIDBEAgAEEEaigCACADENEBCyAAQQxqIQAgAUEBayIBDQALCyAKBEAgDyAKQQxsENEBCyAFIAIp -Agw3AgAgBUEIaiACQRRqKAIANgIACyACQeAAaiQADAELQQhBgAFBgJLAABC3AQALAkACQAJAAkAC -QCAELQAvQQFGBEAgBCgCICIARQ0BIAQoAiQgAEEFdBDRAQwBCyAEKAIgIhNBgICAgHhHDQELIARB -ADYCKCAEQoCAgIAQNwIgIARBnIHAADYCBCAEQqCAgIAONwIIIAQgBEEgajYCACAEQS9qIAQQvgEN -AiAEKAIgIQAgBCgCJCIBIAQoAigQugEhAiAABEAgASAAENEBCyAQQYCAgIB4NgIAIBAgAjYCBAwB -CyAEKAIkIhkhACAEKAIoIQEjAEHgAGsiCCQAIAhBADYCKCAIQQA2AhggCCAANgI4IAggACABQQV0 -ajYCPCAIQQxqIQtBACEBIwBBEGsiBiQAAkACQAJ/AkACQCAIQRhqIgUiACgCACIDBEAgACgCBCIC -IAAoAgxHDQEgACgCCCICBEAgAyACENEBCyAAQQA2AgALIAAoAiAiA0UNASADIAAoAiRGDQEgACAD -QSBqNgIgQbmCwQAtAAAaQSBBARDFASICRQ0DIABBIDYCCCAAIAI2AgAgAiADKQAANwAAIAAgAkEg -ajYCDCACQRhqIANBGGopAAA3AAAgAkEQaiADQRBqKQAANwAAIAJBCGogA0EIaikAADcAAAsgACAC -QQFqNgIEIAItAAAhAEEBDAELIAAoAhAiAwRAIAAoAhQiAiAAKAIcRwRAIAAgAkEBajYCFCACLQAA -IQBBAQwCCyAAKAIYIgIEQCADIAIQ0QELIABBADYCEAtBAAshAiAGIAA6AAEgBiACOgAADAELQQFB -IEG8rMAAELcBAAsCQCAGLQAABEACQEEIQX8gBSgCDCIPIAUoAgQiDGsiAiAFKAIcIhcgBSgCFCIA -a0EAIAUoAhAiDhsiA2oiByACIAdLGyADIAUoAgAiAxtBAWoiAkF/IAIbIgIgAkEITRsiAkEASA0A -IAYtAAEhB0G5gsEALQAAGkEBIQEgAkEBEMUBIgpFDQAgCiAHOgAAIAZBATYCDCAGIAo2AgggBiAC -NgIEIAUoAiQhGiAFKAIgIQcgBSgCGCEYIAUoAgghEUEBIQUDQAJAAkACQAJ/AkAgA0UNACAMIAwg -D0cNARogEUUNACADIBEQ0QELIAdFIAcgGkZyDQFBuYLBAC0AABpBIEEBEMUBIgNFDQIgAyAHKQAA -NwAAIANBGGogB0EYaikAADcAACADQRBqIAdBEGopAAA3AAAgA0EIaiAHQQhqKQAANwAAQSAhESAD -QSBqIQ8gB0EgaiEHIAMLIgJBAWohDCAAIQEMAgsCQCAORQ0AIAAgF0cEQCAAQQFqIQFBACEDIAAh -AgwDCyAYRQ0AIA4gGBDRAQsgCyAGKQIENwIAIAtBCGogBkEMaigCADYCAAwFC0EBQSBBvKzAABC3 -AQALIAItAAAhGyAGKAIEIAVGBEAgBkEEaiEKIwBBIGsiACQAAkACQCAFQX8gDyAMayICIBcgAWtB -ACAOGyIUaiISIAIgEksbIBQgAxtBAWoiAkF/IAIbIAVqIgJLDQBBCCACIAooAgAiFEEBdCISIAIg -EksbIgIgAkEITRsiEq0iHUIgiFBFDQAgHaciHEH/////B0sNACAAIBQEfyAAIBQ2AhwgACAKKAIE -NgIUQQEFQQALNgIYIABBCGpBASAcIABBFGoQdCAAKAIIQQFHDQEgACgCECECIAAoAgwhFgsgFiAC -QfixwAAQtwEACyAAKAIMIQIgCiASNgIAIAogAjYCBCAAQSBqJAAgBigCCCEKCyAFIApqIBs6AAAg -BiAFQQFqIgU2AgwgASEADAALAAsgASACQcywwAAQtwEACyALQQA2AgggC0KAgICAEDcCAAJAIAUo -AgAiAEUNACAFKAIIIgFFDQAgACABENEBCyAFKAIQIgBFDQAgBSgCGCIBRQ0AIAAgARDRAQsgBkEQ -aiQAIAhBQGsiAEHcsMAAIAgoAhAiASAIKAIUEDQgBCAAEJkBIAgoAgwiAARAIAEgABDRAQsgCEHg -AGokACAQIAQQZCATRQ0AIBkgE0EFdBDRAQsgBEEwaiQADAELQcSBwABBNyAEQS9qQbSBwABB8ILA -ABB9AAsCQAJAIA0CfyAJKAIUIgJBgICAgHhGBEBBACEAIAkoAhghAUEBDAELIAkoAhghAQJAIAko -AhwiFSACTwRAIAEhAAwBCyAVRQRAQQEhACABIAIQ0QEMAQsgASACQQEgFRC9ASIARQ0CC0EAIQFB -AAs2AgwgDSABNgIIIA0gFTYCBCANIAA2AgAgCUEgaiQADAELQQEgFUHchsAAELcBAAsgDSgCACAN -KAIEIA0oAgggDSgCDCANQRBqJAALzw4CGX8BfiMAQRBrIgokACMAQSBrIgckAAJAAkACQCAABEAg -AEEIayINIA0oAgBBAWoiBjYCACAGRQ0BIAAoAgANAiAAQX82AgAgByANNgIQIAcgADYCDCAHIAI2 -AhwgByABNgIYIAcgAjYCFCAHIABBCGoiBjYCCEEAIQIjAEGAAWsiAyQAIANBCGohDiAHQRRqIhMo -AgQhFCATKAIIIQgjAEGAAWsiASQAIAFBADYCFCABQoCAgICAATcCDAJAAkAgCARAIAFByABqQQRy -IQQDQCACIAhLDQIgAUHIAGogBiACIBRqIAggAmtBABAyIAFBIGoiESAEQQhqKQIANwMAIAFBKGoi -EiAEQRBqKQIANwMAIAFBMGoiFSAEQRhqKQIANwMAIAFBOGoiFiAEQSBqKQIANwMAIAFBQGsiFyAE -QShqKAIANgIAIAEgBCkCADcDGCABKAJ4IRggASgCSCIZBEAgASgCFCIPIAEoAgxGBEAjAEEgayIF -JABBBCABQQxqIgwoAgAiEEEBdCIJIAlBBE0bIhqtQjB+IhxCIIhQRQRAQQBBAEGgl8AAELcBAAsC -QCAcpyIbQfj///8HTQRAIAUgEAR/IAUgEEEwbDYCHCAFIAwoAgQ2AhRBCAVBAAs2AhggBUEIakEI -IBsgBUEUahB0IAUoAghBAUcNASAFKAIMIQsgBSgCECEJCyALIAlBoJfAABC3AQALIAUoAgwhCSAM -IBo2AgAgDCAJNgIEIAVBIGokAAsgASgCECAPQTBsaiIFIAEpAxg3AgQgBSAZNgIAIAVBDGogESkD -ADcCACAFQRRqIBIpAwA3AgAgBUEcaiAVKQMANwIAIAVBJGogFikDADcCACAFQSxqIBcoAgA2AgAg -ASAPQQFqNgIUCyACIBhqIgIgCEcNAAsLIA4gASkCDDcCACAOQQhqIAFBFGooAgA2AgAgAUGAAWok -AAwBCyACIAhBsJfAABDVAQALAkACQAJAIAMoAhAiAkUEQEEEIQQMAQtBuYLBAC0AABogAkEUbCIB -QQQQxQEiBEUNAQsgA0EANgIcIAMgBDYCGCADIAI2AhQgAygCDCIFIAJBMGxqIQggAygCCCEMIAUh -AQJAIAIEQCADQSxqIQ4gA0EwaiEJIANBIGpBBHIiBEEIaiEPIARBGGohECAEQSBqIREgBEEoaiES -IAEhAgNAIAIoAgAiAQRAIAMgATYCICAEIAJBBGopAgA3AgAgDyACQQxqKQIANwIAIARBEGogAkEU -aikCADcCACAQIAJBHGopAgA3AgAgESACQSRqKQIANwIAIBIgAkEsaigCADYCACAGLQAwIQEgCRCD -ASELIANB0ABqIAkQZCADIAsgAUEBc3I6AGAgAyADKAIoIgE2AlwgDiADKAIkIAEgAygCICgCEBED -ACADKAIcIgEgAygCFEYEQCADQRRqQcyFwAAQZwsgAygCGCABQRRsaiILIAMpAlA3AgAgC0EIaiAD -QdgAaikCADcCACALQRBqIANB4ABqKAIANgIAIAZBAToAMCADIAFBAWo2AhwgAkEwaiICIAhHDQEM -AwsLIAJBMGohAQsgASAIRg0AIAggAWsiAkEwbiIGQQFxQQAhBCACQTBrQTBPBEAgBkH+//8/cSEG -IAEhAgNAIAJBDGogAkEEaigCACACQQhqKAIAIAIoAgAoAhARAwAgAkE8aiACQTRqKAIAIAJBOGoo -AgAgAkEwaigCACgCEBEDACACQeAAaiECIAYgBEECaiIERw0ACwtFDQAgASAEQTBsaiIBQQxqIAEo -AgQgASgCCCABKAIAKAIQEQMACyAMBEAgBSAMQTBsENEBCyADQQA2AmQgAygCGCECQQEhBiADQfQA -aiADQeQAaiADKAIcIgEQtgECQCADKAJ0RQRAIAMoAnghAQwBCyADQfAAaiADQfwAaigCADYCACAD -IAMpAnQ3A2gCQCABBEAgAUEUbCEGIANB6ABqQQRyIQUgAygCcCEEA0AgAyACIAMoAmgQYCADKAIE -IQEgAygCAEEBcQ0CIAUgBCABENMBIAMgBEEBaiIENgJwIAJBFGohAiAGQRRrIgYNAAsLQQAhBiAD -KAJsIQEMAQtBASEGIAMoAmwiAkGEAUkNACACEG0LIAMoAhwiBARAIAMoAhghAgNAIAIoAgAiBQRA -IAJBBGooAgAgBRDRAQsgAkEUaiECIARBAWsiBA0ACwsgAygCFCICBEAgAygCGCACQRRsENEBCyAT -KAIAIgIEQCAUIAIQ0QELIAcgATYCBCAHIAY2AgAgA0GAAWokAAwBC0EEIAFBvIXAABC3AQALIAco -AgQhASAHKAIAIQIgAEEANgIAIA0gDSgCAEEBayIANgIAIABFBEAgB0EQahCUAQsgCiACQQFxIgA2 -AgggCiABQQAgABs2AgQgCkEAIAEgABs2AgAgB0EgaiQADAMLEOUBCwALEOYBAAsgCigCACAKKAIE -IAooAgggCkEQaiQAC6AGAQh/IwBBEGsiBCQAEHAiAiAAJgEjAEEQayIIJAAgCEEEaiEDIwBB0ABr -IgEkACABQQxqIAIQLyABKAIQIQICQAJAAkAgASgCDCIFQYCAgIB4RgRAIAEgAjYCPCABQQA2Akgg -AUKAgICAEDcCQCABQZyBwAA2AhwgAUKggICADjcCICABIAFBQGs2AhggAUE8aiABQRhqEJIBDQIg -ASgCQCECIAEoAkQiBSABKAJIELoBIQYgAgRAIAUgAhDRAQsgASgCPCICQYQBTwRAIAIQbQsgA0GA -gICAeDYCACADIAY2AgQMAQsgASgCFCEGIAFBADoADCABIAIgBkEEdGo2AiQgASAFNgIgIAEgAjYC -HCABIAI2AhggASABQQxqNgIoIAFBQGsgAUEYahAsAkACQCABLQAMQQFGBEAgASgCQCICRQ0BIAEo -AkQgAkEobBDRAQwBCyABKAJAIgJBgICAgHhHDQELIAFBADYCSCABQoCAgIAQNwJAIAFBnIHAADYC -HCABQqCAgIAONwIgIAEgAUFAazYCGCABQc8AaiABQRhqEL4BDQIgASgCQCECIAEoAkQiBSABKAJI -ELoBIQYgAgRAIAUgAhDRAQsgA0GAgICAeDYCACADIAY2AgQMAQsgASgCRCEFAkAgASgCSCIGRQRA -IAFBMGpCADcDACABQShqQgA3AwAgAUEgakIANwMAIAFCADcDGAwBCyABQRhqIAUgBhAxCyADIAFB -GGoQZCACRQ0AIAUgAkEobBDRAQsgAUHQAGokAAwBC0HEgcAAQTcgAUHPAGpBtIHAAEHwgsAAEH0A -CwJAAkAgBAJ/IAgoAgQiAkGAgICAeEYEQCAIKAIIIQFBACEDQQEMAQsgCCgCCCEBAkAgCCgCDCID -IAJPBEAgASEHDAELIANFBEBBASEHIAEgAhDRAQwBCyABIAJBASADEL0BIgdFDQILQQAhAUEACzYC -DCAEIAE2AgggBCADNgIEIAQgBzYCACAIQRBqJAAMAQtBASADQdyGwAAQtwEACyAEKAIAIAQoAgQg -BCgCCCAEKAIMIARBEGokAAvCBgEJfyMAQRBrIgQkABBwIgIgACYBIwBBEGsiCCQAIAhBBGohAyMA -QfAAayIBJAAgAUEIaiACEC8gASgCDCECAkACQAJAIAEoAggiBkGAgICAeEYEQCABIAI2AmggAUEA -NgIwIAFCgICAgBA3AiggAUGcgcAANgJMIAFCoICAgA43AlAgASABQShqNgJIIAFB6ABqIAFByABq -EJIBDQIgASgCKCECIAEoAiwiBiABKAIwELoBIQUgAgRAIAYgAhDRAQsgASgCaCICQYQBTwRAIAIQ -bQsgA0GAgICAeDYCACADIAU2AgQMAQsgASgCECEFIAFBADoACCABIAIgBUEEdGo2AlQgASAGNgJQ -IAEgAjYCTCABIAI2AkggASABQQhqNgJYIAFBKGogAUHIAGoQLAJAAkAgAS0ACEEBRgRAIAEoAigi -AkUNASABKAIsIAJBKGwQ0QEMAQsgASgCKCICQYCAgIB4Rw0BCyABQQA2AjAgAUKAgICAEDcCKCAB -QZyBwAA2AkwgAUKggICADjcCUCABIAFBKGo2AkggAUHvAGogAUHIAGoQvgENAiABKAIoIQIgASgC -LCIGIAEoAjAQugEhBSACBEAgBiACENEBCyADQYCAgIB4NgIAIAMgBTYCBAwBCyABKAIsIQYCQCAB -KAIwIgVFBEAgAUEgakIANwMAIAFBGGpCADcDACABQRBqQgA3AwAgAUIANwMIDAELIAFBKGoiCSAG -IAUQMSABQcgAaiIFQeyGwAAQmQEgAUEIaiAJIAUQiQELIAMgAUEIahBkIAJFDQAgBiACQShsENEB -CyABQfAAaiQADAELQcSBwABBNyABQe8AakG0gcAAQfCCwAAQfQALAkACQCAEAn8gCCgCBCICQYCA -gIB4RgRAIAgoAgghAUEAIQNBAQwBCyAIKAIIIQECQCAIKAIMIgMgAk8EQCABIQcMAQsgA0UEQEEB -IQcgASACENEBDAELIAEgAkEBIAMQvQEiB0UNAgtBACEBQQALNgIMIAQgATYCCCAEIAM2AgQgBCAH -NgIAIAhBEGokAAwBC0EBIANB3IbAABC3AQALIAQoAgAgBCgCBCAEKAIIIAQoAgwgBEEQaiQAC/oB -AgJ/AX4jAEEQayICJAAgAkEBOwEMIAIgATYCCCACIAA2AgQjAEEQayIBJAAgAkEEaiIAKQIAIQQg -ASAANgIMIAEgBDcCBCMAQRBrIgAkACABQQRqIgEoAgAiAigCDCEDAkACQAJAAkAgAigCBA4CAAEC -CyADDQFBASECQQAhAwwCCyADDQAgAigCACICKAIEIQMgAigCACECDAELIABBgICAgHg2AgAgACAB -NgIMIABBgMnAACABKAIEIAEoAggiAC0ACCAALQAJEGYACyAAIAM2AgQgACACNgIAIABB5MjAACAB -KAIEIAEoAggiAC0ACCAALQAJEGYAC98IAQt/IwBBEGsiCCQAIwBBIGsiByQAAkACQAJAIAAEQCAA -QQhrIgkgCSgCAEEBaiICNgIAIAJFDQEgACgCAA0CIABBfzYCACAHIAk2AhwgByAANgIYIAcgAEEI -aiICNgIUIAdBCGohCiMAQbABayIBJAAgAUEANgIUIAFCgICAgMAANwIMIwBBQGoiAyQAIANBCGog -AkEBQQBBARAyIAFBGGoiBEEoaiADQTBqKQMANwMAIARBIGogA0EoaikDADcDACAEQRhqIANBIGop -AwA3AwAgBEEQaiADQRhqKQMANwMAIARBCGogA0EQaikDADcDACAEIAMpAwg3AwAgA0FAayQAAn8g -ASgCGCILRQRAQQQhBUEADAELIAFB8ABqIAFBQGspAwA3AwAgAUHoAGogAUE4aikDADcDACABQeAA -aiABQTBqKQMANwMAIAFB2ABqIgMgAUEoaikDADcDACABQdAAaiIFIAFBIGopAwA3AwAgASABKQMY -NwNIIAItADAhBiADEIMBIQQgAUH8AGogAxBkIAFBjAFqIgMgBCAGQQFzcjoAACABIAUoAgAiBDYC -iAEgAUHUAGogASgCTCAEIAEoAkgoAhARAwAgAUEMakHMhsAAEGcgASgCECIFIAEpAnw3AgAgBUEI -aiABQYQBaikCADcCACAFQRBqIAMoAgA2AgAgAkEBOgAwIAFBATYCFEEBCyECIAFBADYCmAFBASEG -IAFBGGogAUGYAWogAhC2AQJAIAEoAhhFBEAgASgCHCEDDAELIAFBqAFqIAFBIGooAgA2AgAgASAB -KQIYNwOgAQJAIAsEQCACQRRsIQQgAUGgAWpBBHIhAiABKAKoASEGA0AgASAFIAEoAqABEGAgASgC -BCEDIAEoAgBBAXENAiACIAYgAxDTASABIAZBAWoiBjYCqAEgBUEUaiEFIARBFGsiBA0ACwtBACEG -IAEoAqQBIQMMAQtBASEGIAEoAqQBIgJBhAFJDQAgAhBtCyABIAM2ApQBIAEgBjYCkAEgAUEBNgIc -IAFBsITAADYCGCABQgE3AiQgASABQZABaq1CgICAgDCENwOYASABIAFBmAFqNgIgIAFBoAFqIAFB -GGoQRyABKAKkASIEIAEoAqgBEAAgASgCoAEiAgRAIAQgAhDRAQsgASgCkAEhAyABKAKUASEEIAEo -AhQiBgRAIAEoAhAhBQNAIAUoAgAiAgRAIAVBBGooAgAgAhDRAQsgBUEUaiEFIAZBAWsiBg0ACwsg -ASgCDCICBEAgASgCECACQRRsENEBCyAKIAQ2AgQgCiADNgIAIAFBsAFqJAAgBygCDCEEIAcoAggh -AiAAQQA2AgAgCSAJKAIAQQFrIgA2AgAgAEUEQCAHQRxqEJQBCyAIIAJBAXEiADYCCCAIIARBACAA -GzYCBCAIQQAgBCAAGzYCACAHQSBqJAAMAwsQ5QELAAsQ5gEACyAIKAIAIAgoAgQgCCgCCCAIQRBq -JAALIQACQCABIAMQuAEEQCAAIAEgAyACEL0BIgANAQsACyAACyUAIABFBEBBiLTAAEEyEOcBAAsg -ACACIAMgBCAFIAEoAhAREwALIAEBf0EBIQEgACgCACIAQQFxBH8gAQUgACgCCEEBRgsLHwECfiAA -KQMAIgIgAkI/hyIDhSADfSACQgBZIAEQSQsjACAARQRAQYi0wABBMhDnAQALIAAgAiADIAQgASgC -EBEEAAsjACAARQRAQYi0wABBMhDnAQALIAAgAiADIAQgASgCEBEPAAsjACAARQRAQYi0wABBMhDn -AQALIAAgAiADIAQgASgCEBEoAAsjACAARQRAQYi0wABBMhDnAQALIAAgAiADIAQgASgCEBEqAAsj -ACAARQRAQYi0wABBMhDnAQALIAAgAiADIAQgASgCEBEsAAsmAQF/IAAoAgAiAUGAgICAeHJBgICA -gHhHBEAgACgCBCABENEBCwshACAARQRAQYi0wABBMhDnAQALIAAgAiADIAEoAhARAwALIgAgAC0A -AEUEQCABQZvuwABBBRA6DwsgAUGg7sAAQQQQOgsfACAARQRAQYi0wABBMhDnAQALIAAgAiABKAIQ -EQAACyEAIABBADYCDCAAIAM2AgggACACNgIEIABByLXAADYCAAtIACABUEUEQCAAKQMYIAGCDwsj -AEEgayIAJAAgAEEANgIYIABBATYCDCAAQez+wAA2AgggAEIENwIQIABBCGpBvLnAABCjAQALKQAg -ACAALQAEIAFBLkZyOgAEIAAoAgAiACgCACABIAAoAgQoAhARAAALGAEBfyAAKAIAIgEEQCAAKAIE -IAEQ0QELCyUBAW8QESEDEHAiAiADJgEgAEEANgIIIAAgAjYCBCAAIAE2AgALQgAgAARAIAAgARDs -AQALIwBBIGsiACQAIABBADYCGCAAQQE2AgwgAEGwysAANgIIIABCBDcCECAAQQhqIAIQowEACxUA -IAFpQQFGIABBgICAgHggAWtNcQscACAAQQA2AhAgAEIANwIIIABCgICAgMAANwIACxYBAW8gACAB -EAEhAhBwIgAgAiYBIAALFgEBbyAAIAEQBiECEHAiACACJgEgAAsWAQFvIAAlARAgIQEQcCIAIAEm -ASAAC+0GAQZ/An8CQAJAAkACQAJAIABBBGsiBSgCACIGQXhxIgRBBEEIIAZBA3EiBxsgAWpPBEAg -B0EAIAFBJ2oiCSAESRsNAQJAAkAgAkEJTwRAIAIgAxBIIggNAUEADAkLIANBzP97Sw0BQRAgA0EL -akF4cSADQQtJGyEBAkAgB0UEQCABQYACSSAEIAFBBHJJciAEIAFrQYGACE9yDQEMCQsgAEEIayIC -IARqIQcCQAJAAkACQCABIARLBEAgB0HUhsEAKAIARg0EIAdB0IbBACgCAEYNAiAHKAIEIgZBAnEN -BSAGQXhxIgYgBGoiBCABSQ0FIAcgBhBNIAQgAWsiA0EQSQ0BIAUgASAFKAIAQQFxckECcjYCACAB -IAJqIgEgA0EDcjYCBCACIARqIgIgAigCBEEBcjYCBCABIAMQRAwNCyAEIAFrIgNBD0sNAgwMCyAF -IAQgBSgCAEEBcXJBAnI2AgAgAiAEaiIBIAEoAgRBAXI2AgQMCwtByIbBACgCACAEaiIEIAFJDQIC -QCAEIAFrIgNBD00EQCAFIAZBAXEgBHJBAnI2AgAgAiAEaiIBIAEoAgRBAXI2AgRBACEDQQAhAQwB -CyAFIAEgBkEBcXJBAnI2AgAgASACaiIBIANBAXI2AgQgAiAEaiICIAM2AgAgAiACKAIEQX5xNgIE -C0HQhsEAIAE2AgBByIbBACADNgIADAoLIAUgASAGQQFxckECcjYCACABIAJqIgEgA0EDcjYCBCAH -IAcoAgRBAXI2AgQgASADEEQMCQtBzIbBACgCACAEaiIEIAFLDQcLIAMQKSIBRQ0BIANBfEF4IAUo -AgAiAkEDcRsgAkF4cWoiAiACIANLGyICBEAgASAAIAL8CgAACyAAEDkgAQwICyADIAEgASADSxsi -AgRAIAggACAC/AoAAAsgBSgCACICQXhxIgMgAUEEQQggAkEDcSICG2pJDQMgAkEAIAMgCUsbDQQg -ABA5CyAIDAYLQenGwABBLkGYx8AAEJcBAAtBqMfAAEEuQdjHwAAQlwEAC0HpxsAAQS5BmMfAABCX -AQALQajHwABBLkHYx8AAEJcBAAsgBSABIAZBAXFyQQJyNgIAIAEgAmoiAiAEIAFrIgFBAXI2AgRB -zIbBACABNgIAQdSGwQAgAjYCACAADAELIAALCxkAIAEoAgBBzLnAAEEeIAEoAgQoAgwRAQALDgAg -AQRAIAAgARDRAQsLGQAgASgCAEGH6cAAQQ4gASgCBCgCDBEBAAsWACAAKAIAIAEgAiAAKAIEKAIM -EQEACxQAIAAoAgAgASAAKAIEKAIMEQAAC4MIAQR/IwBB8ABrIgUkACAFIAM2AgwgBSACNgIIAn8g -AUGBAk8EQAJ/QYACIAAsAIACQb9/Sg0AGkH/ASAALAD/AUG/f0oNABpB/gFB/QEgACwA/gFBv39K -GwsiBiAAaiwAAEG/f0oEQEHf7sAAIQdBBQwCCyAAIAFBACAGIAQQwwEAC0EBIQcgASEGQQALIQgg -BSAGNgIUIAUgADYCECAFIAg2AhwgBSAHNgIYAkACQAJAAkAgASACSSIGIAEgA0lyRQRAIAIgA0sN -ASACRSABIAJNckUEQCAFQQxqIAVBCGogACACaiwAAEG/f0obKAIAIQMLIAUgAzYCICADIAEiAkkE -QCADQQFqIgIgA0EDayIGQQAgAyAGTxsiBkkNAwJ/IAIgBmsiB0EBayAAIANqLAAAQb9/Sg0AGiAH -QQJrIAAgAmoiAkECaywAAEG/f0oNABogB0EDayACQQNrLAAAQb9/Sg0AGiAHQXxBeyACQQRrLAAA -Qb9/ShtqCyAGaiECCwJAIAJFDQAgASACTQRAIAEgAkYNAQwFCyAAIAJqLAAAQb9/TA0ECwJ/AkAC -QCABIAJGDQACQAJAIAAgAmoiASwAACIAQQBIBEAgAS0AAUE/cSEGIABBH3EhAyAAQV9LDQEgA0EG -dCAGciEADAILIAUgAEH/AXE2AiRBAQwECyABLQACQT9xIAZBBnRyIQYgAEFwSQRAIAYgA0EMdHIh -AAwBCyADQRJ0QYCA8ABxIAEtAANBP3EgBkEGdHJyIgBBgIDEAEYNAQsgBSAANgIkIABBgAFPDQFB -AQwCCyAEENkBAAtBAiAAQYAQSQ0AGkEDQQQgAEGAgARJGwshACAFIAI2AiggBSAAIAJqNgIsIAVB -BTYCNCAFQejvwAA2AjAgBUIFNwI8IAUgBUEYaq1CgICAgJAMhDcDaCAFIAVBEGqtQoCAgICQDIQ3 -A2AgBSAFQShqrUKAgICAsAyENwNYIAUgBUEkaq1CgICAgMAMhDcDUCAFIAVBIGqtQoCAgICQCYQ3 -A0gMBAsgBSACIAMgBhs2AiggBUEDNgI0IAVBqPDAADYCMCAFQgM3AjwgBSAFQRhqrUKAgICAkAyE -NwNYIAUgBUEQaq1CgICAgJAMhDcDUCAFIAVBKGqtQoCAgICQCYQ3A0gMAwsgBUEENgI0IAVBiO/A -ADYCMCAFQgQ3AjwgBSAFQRhqrUKAgICAkAyENwNgIAUgBUEQaq1CgICAgJAMhDcDWCAFIAVBDGqt -QoCAgICQCYQ3A1AgBSAFQQhqrUKAgICAkAmENwNIDAILIAYgAkHA8MAAENcBAAsgACABIAIgASAE -EMMBAAsgBSAFQcgAajYCOCAFQTBqIAQQowEACxEAIAAoAgAgACgCBCABEO4BCxkAAn8gAUEJTwRA -IAEgABBIDAELIAAQKQsLDwAgACABKAIAIAIgAxBbCw8AIAAgASgCACACIAMQQwsRACAAKAIEIAAo -AgggARDuAQvgBgEPfyAAKAIAIQcgACgCBCEFQQAhACMAQRBrIgYkAEEBIQwCQCABKAIAIgpBIiAB -KAIEIg0oAhAiDhEAAA0AAkAgBUUEQAwBC0EAIAVrIQ8gByEBIAUhAAJAAn8CQANAIAAgAWohEEEA -IQMCQANAIAEgA2oiBC0AACIJQf8Aa0H/AXFBoQFJIAlBIkZyIAlB3ABGcg0BIAAgA0EBaiIDRw0A -CyAAIAhqDAMLIARBAWohAQJAIAQsAAAiAEEATgRAIABB/wFxIQAMAQsgAS0AAEE/cSELIABBH3Eh -CSAEQQJqIQEgAEFfTQRAIAlBBnQgC3IhAAwBCyABLQAAQT9xIAtBBnRyIQsgBEEDaiEBIABBcEkE -QCALIAlBDHRyIQAMAQsgCUESdEGAgPAAcSABLQAAQT9xIAtBBnRyciEAIARBBGohAQsgBkEEaiAA -QYGABBA1AkACQCAGLQAEQYABRg0AIAYtAA8gBi0ADmtB/wFxQQFGDQACQAJAIAIgAyAIaiIESw0A -AkAgAkUNACACIAVPBEAgAiAFRw0CDAELIAIgB2osAABBv39MDQELAkAgBEUNACAEIAVPBEAgBCAP -akUNAQwCCyAHIAhqIANqLAAAQUBIDQELIAogAiAHaiAIIAJrIANqIA0oAgwiAhEBAEUNAQwDCyAH -IAUgAiAEQaTuwAAQwwEACwJAIAYtAARBgAFGBEAgCiAGKAIIIA4RAAANAwwBCyAKIAYtAA4iBCAG -QQRqaiAGLQAPIARrIAIRAQANAgsCf0EBIABBgAFJDQAaQQIgAEGAEEkNABpBA0EEIABBgIAESRsL -IAhqIANqIQILAn9BASAAQYABSQ0AGkECIABBgBBJDQAaQQNBBCAAQYCABEkbCyAIaiIEIANqIQgg -ECABayIARQ0CDAELCwwECyADIARqCyIDIAJJDQBBACEAAkAgAkUNACACIAVPBEAgAiIAIAVHDQIM -AQsgAiIAIAdqLAAAQb9/TA0BCyADRQRAQQAhAwwCCyADIAVPBEAgAyAFRg0CIAAhAgwBCyADIAdq -LAAAQb9/Sg0BIAAhAgsgByAFIAIgA0G07sAAEMMBAAsgCiAAIAdqIAMgAGsgDSgCDBEBAA0AIApB -IiAOEQAAIQwLIAZBEGokACAMCxYAQZCDwQAgADYCAEGMg8EAQQE2AgALIgAgAELtuq22zYXU9eMA -NwMIIABC+IKZvZXuxsW5fzcDAAshACAAQoC834WrpfibJzcDCCAAQp/1lpTW7u3DoX83AwALEwAg -AEHUyMAANgIEIAAgATYCAAsRACABIAAoAgAgACgCBBDBAQsQACABIAAoAgAgACgCBBA6CxAAIAEo -AgAgASgCBCAAEDwLYQECfwJAAkAgAEEEaygCACICQXhxIgNBBEEIIAJBA3EiAhsgAWpPBEAgAkEA -IAMgAUEnaksbDQEgABA5DAILQenGwABBLkGYx8AAEJcBAAtBqMfAAEEuQdjHwAAQlwEACwsdAQFv -IAAoAgAlASABJQEgARBtIAIlASACEG0QDgsXAQFvIAAoAgAlASABIAIlASACEG0QGwsNACAAKAIA -KAIIQQFGC2sBAX8jAEEwayIDJAAgAyABNgIEIAMgADYCACADQQI2AgwgA0Go/8AANgIIIANCAjcC -FCADIANBBGqtQoCAgICQCYQ3AyggAyADrUKAgICAkAmENwMgIAMgA0EgajYCECADQQhqIAIQowEA -C2sBAX8jAEEwayIDJAAgAyABNgIEIAMgADYCACADQQI2AgwgA0HI/8AANgIIIANCAjcCFCADIANB -BGqtQoCAgICQCYQ3AyggAyADrUKAgICAkAmENwMgIAMgA0EgajYCECADQQhqIAIQowEAC2sBAX8j -AEEwayIDJAAgAyABNgIEIAMgADYCACADQQI2AgwgA0H8/8AANgIIIANCAjcCFCADIANBBGqtQoCA -gICQCYQ3AyggAyADrUKAgICAkAmENwMgIAMgA0EgajYCECADQQhqIAIQowEACwsAIAAoAgAgARBM -Cw8AQbDpwABBKyAAEJcBAAsNACAAKQMAQQEgARBJCw4AIAFBgIPAAEEFEMEBCw4AIAFB1ITAAEEQ -EMEBCw4AIAFB7IjAAEEKEMEBCwwAIAAoAgAgARDYAQuKAwEBfyAAKAIAIQIjAEHQAWsiACQAIAAg -AkEYaq1CgICAgJAHhDcDaCAAIAJBEGqtQoCAgICQB4Q3A2AgACACQQhqrUKAgICAkAeENwNYIAAg -Aq1CgICAgJAHhDcDUCAAQey5wAA2AjggAEEENgI8IABBBDYCTCAAQoOAgICAhICAaTcCyAEgAEGA -gMAANgLAASAAQQI7AbgBIABCgoCAgICEgIBpNwKwASAAQYCAwAA2AqgBIABBAjsBoAEgAEKBgICA -gISAgGk3ApgBIABBgIDAADYCkAEgAEECOwGIASAAQoCAgICAhICAaTcCgAEgAEKAgMAANwJ4IABB -AjsBcCAAIABB8ABqNgJIIABBBDYCRCAAIABB0ABqNgJAIABBLGoiAiAAQThqEEcgACACrUKAgICA -oAeENwMgIABBATYCDCAAQfy6wAA2AgggAEIBNwIUIAAgAEEgajYCECABKAIAIAEoAgQgAEEIahA8 -IAAoAiwiAgRAIAAoAjAgAhDRAQsgAEHQAWokAAsLACAAKAIAIAEQcwsNACAAQdyPwAAgARA8Cw4A -IAFB1I7AAEEFEMEBCw4AIAFBurTAAEELEMEBCw0AIABBrL7AACABEDwLDQBB6MPAAEEbEOcBAAsO -AEGDxMAAQc8AEOcBAAsJACAAIAEQJQALDQAgAEGoxsAAIAEQPAsMACAAIAEpAgA3AwALDQAgAEGE -ysAAIAEQPAsOACABQfzJwABBBRDBAQsaACAAIAFBlIPBACgCACIAQcoAIAAbEQIAAAsNACAAQdTr -wAAgARA8CwoAIAIgACABEDoLCgAgACABJQEQAgsOACABQcS+wABBCBDBAQsOACABQc7AwABBAxDB -AQsJACAAQQA2AgALCAAgACUBEAMLCAAgACUBEBILCAAgACUBECILBABBAAsCAAsL9oEBDgBBgIDA -AAuxAS9ob21lL2NveW90dGU1MDgvY29kZS9odWdnaW5nZmFjZS5qcy9wYWNrYWdlcy9odWIveGV0 -LWNvcmUtd2FzbS1idWlsZC9tZXJrbGVoYXNoL3NyYy9hZ2dyZWdhdGVkX2hhc2hlcy5ycwAAAAAA -EABpAAAAWQAAADgAAAAAABAAaQAAAFkAAAAPAAAAAAAQAGkAAABWAAAAOQAAAAUAAAAMAAAABAAA -AAYAAAAHAAAACABBvIHAAAutBQEAAAAJAAAAYSBEaXNwbGF5IGltcGxlbWVudGF0aW9uIHJldHVy -bmVkIGFuIGVycm9yIHVuZXhwZWN0ZWRseS9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29sY2hh -aW5zL3N0YWJsZS14ODZfNjQtdW5rbm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIvc3JjL3J1c3Qv -bGlicmFyeS9hbGxvYy9zcmMvc3RyaW5nLnJzAPsAEAB0AAAA0QoAAA4AAABFcnJvcgAAAPsAEAB0 -AAAAfQUAABsAAAAAAAAABAAAAAQAAAAKAAAAT2tFcnIvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAv -dG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3Ny -Yy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3NsaWNlLnJzrQEQAHMAAAC+AQAAHQAAAAEAAAAAAAAA -aGFzaGxlbmd0aAAAOAIQAAQAAAA8AhAABgAAAHN0cnVjdCBKc0NodW5rSW5Kc0NodW5rT3V0ZGVk -dXBhdHRlbXB0ZWQgdG8gdGFrZSBvd25lcnNoaXAgb2YgUnVzdCB2YWx1ZSB3aGlsZSBpdCB3YXMg -Ym9ycm93ZWRzcmMvbGliLnJzsgIQAAoAAAA9AAAAOAAAALICEAAKAAAAQQAAACEAAAAvaG9tZS9j -b3lvdHRlNTA4Ly5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1 -YjU1N2Yvd2FzbS1iaW5kZ2VuLTAuMi4xMDAvc3JjL2NvbnZlcnQvc2xpY2VzLnJzsgIQAAoAAABM -AAAAFAAAANwCEABwAAAAJAEAAA4AQYyHwAALzQFJbnZhbGlkIGhhc2ggaGV4OiAAAIwDEAASAAAA -SW52YWxpZCBITUFDIGtleSBoZXg6IAAAqAMQABYAAAAvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAv -dG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3Ny -Yy9ydXN0L2xpYnJhcnkvY29yZS9zcmMvaXRlci90cmFpdHMvaXRlcmF0b3IucnMAAADIAxAAgQAA -AMEHAAAJAEHkiMAAC5UBAQAAAAsAAABhIHNlcXVlbmNlL2hvbWUvY295b3R0ZTUwOC8uY2FyZ28v -cmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3NlcmRlLTEuMC4y -MTkvc3JjL2RlL2ltcGxzLnJzAAAAdgQQAGMAAACVBAAAIgAAAHYEEABjAAAAmAQAABwAQYSKwAAL -BQEAAAAMAEGUisAACwUBAAAADQBBpIrAAAvlAQEAAAAOAAAAY2FsbGVkIGBPcHRpb246OnVud3Jh -cF90aHJvdygpYCBvbiBhIGBOb25lYCB2YWx1ZWhhc2hsZW5ndGgvaG9tZS9jb3lvdHRlNTA4Ly5y -dXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0 -bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3Jhd192ZWMvbW9kLnJzZwUQAHkAAAAuAgAA -EQAAACA6IAoBAAAAAAAAAPAFEAADAAAA8wUQAAEAQZSMwAALvwgBAAAAEgAAAGNhbGxlZCBgUmVz -dWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUvaG9tZS9jb3lvdHRlNTA4L2NvZGUvaHVn -Z2luZ2ZhY2UuanMvcGFja2FnZXMvaHViL3hldC1jb3JlLXdhc20tYnVpbGQvbWVya2xlaGFzaC9z -cmMvYWdncmVnYXRlZF9oYXNoZXMucnNHBhAAaQAAAD0AAAAqAAAARwYQAGkAAAA4AAAAHgAAAC9o -b21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS14ODZfNjQtdW5rbm93bi1s -aW51eC1nbnUvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvc3RyaW5nLnJz -0AYQAHQAAADoAQAAFwAAAEVycm9yAAAA0AYQAHQAAAB9BQAAGwAAAGludmFsaWQgdmFsdWU6ICwg -ZXhwZWN0ZWQgAABsBxAADwAAAHsHEAALAAAAbWlzc2luZyBmaWVsZCBgYJgHEAAPAAAApwcQAAEA -AABkdXBsaWNhdGUgZmllbGQgYAAAALgHEAARAAAApwcQAAEAAAATAAAADAAAAAQAAAAUAAAAFQAA -AAgAAAAvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVu -a25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3Ns -aWNlLnJzAPQHEABzAAAAvgEAAB0AAAAvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlu -cy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xp -YnJhcnkvYWxsb2Mvc3JjL3ZlYy9zcGVjX2Zyb21faXRlcl9uZXN0ZWQucnMAeAgQAIcAAAATAAAA -BQAAAGludmFsaWQgdHlwZTogLCBleHBlY3RlZCAAAAAQCRAADgAAAB4JEAALAAAAL2hvbWUvY295 -b3R0ZTUwOC8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdu -dS9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2FsbG9jL3NyYy9zbGljZS5ycwA8CRAAcwAA -AL4BAAAdAAAAAQAAAAAAAAAvaG9tZS9jb3lvdHRlNTA4Ly5jYXJnby9yZWdpc3RyeS9zcmMvaW5k -ZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvc2VyZGUtd2FzbS1iaW5kZ2VuLTAuNi41L3Ny -Yy9saWIucnMAAADICRAAaQAAADUAAAAOAAAAAAAAAP//////////SAoQAEHglMAAC4EiAQAAAC9o -b21lL2NveW90dGU1MDgvY29kZS9odWdnaW5nZmFjZS5qcy9wYWNrYWdlcy9odWIveGV0LWNvcmUt -d2FzbS1idWlsZC9kZWR1cGxpY2F0aW9uL3NyYy9jaHVua2luZy5ycwBkChAAYwAAAB4AAAAJAAAA -YXNzZXJ0aW9uIGZhaWxlZDogdGFyZ2V0X2NodW5rX3NpemUgPiA2NGQKEABjAAAAIgAAAAkAAABk -ChAAYwAAAC4AAAAdAAAAYXNzZXJ0aW9uIGZhaWxlZDogbWF4aW11bV9jaHVuayA+IG1pbmltdW1f -Y2h1bmsAZAoQAGMAAAAxAAAACQAAAGQKEABjAAAAOwAAABcAAABkChAAYwAAAGUAAAA7AAAAZAoQ -AGMAAACHAAAAMgAAAGQKEABjAAAAiQAAADoAAABkChAAYwAAALEAAAAVAAAAZAoQAGMAAACuAAAA -QAAAAC9ob21lL2NveW90dGU1MDgvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8t -MTk0OWNmOGM2YjViNTU3Zi9sYXp5X3N0YXRpYy0xLjUuMC9zcmMvaW5saW5lX2xhenkucnMAAMAL -EABqAAAAHgAAABAAAAAvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUt +BUEBayIFDQALCyACICZCgICAgBBUDQAaIAJBKEYNFyABIAJBAnRqICU+AgAgAkEBagsiCTYCoAEC +QCAMRQ0AIAxBAWtB/////wNxIgBBAWoiAkEDcSEFAkAgAEEDSQRAIAFBpAFqIQBCACElDAELIAJB +/P///wdxIQogAUGkAWohAEIAISUDQCAAIAA1AgBCCn4gJXwiJT4CACAAQQRqIgIgAjUCAEIKfiAl +QiCIfCIlPgIAIABBCGoiAiACNQIAQgp+ICVCIIh8IiU+AgAgAEEMaiICIAI1AgBCCn4gJUIgiHwi +Jj4CACAmQiCIISUgAEEQaiEAIApBBGsiCg0ACwsgBQRAA0AgACAANQIAQgp+ICV8IiY+AgAgAEEE +aiEAICZCIIghJSAFQQFrIgUNAAsLICZCgICAgBBUBEAgDCEDDAELIAxBKEYNFyABQaQBaiAMQQJ0 +aiAlPgIAIAxBAWohAwsgASADNgLEAgJAIAtFBEBBACELDAELIAtBAWtB/////wNxIgBBAWoiAkED +cSEFAkAgAEEDSQRAIAFByAJqIQBCACElDAELIAJB/P///wdxIQogAUHIAmohAEIAISUDQCAAIAA1 +AgBCCn4gJXwiJT4CACAAQQRqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIABBCGoiAiACNQIAQgp+ICVC +IIh8IiU+AgAgAEEMaiICIAI1AgBCCn4gJUIgiHwiJj4CACAmQiCIISUgAEEQaiEAIApBBGsiCg0A +CwsgBQRAA0AgACAANQIAQgp+ICV8IiY+AgAgAEEEaiEAICZCIIghJSAFQQFrIgUNAAsLICZCgICA +gBBUDQAgC0EoRg0XIAFByAJqIAtBAnRqICU+AgAgC0EBaiELCyABIAs2AugDIBIgCSAJIBJJGyIC +QShNDQALCwwRCyABQQEQLBogASgCjAUiACABKAKgASICIAAgAksbIgBBKU8NBCAAQQJ0IQAgAUEE +ayECIAFB6ANqIQMDQCAARQ0OIAAgA2ohCSAAIAJqIABBBGshACgCACIMIAkoAgAiCUYNAAsgCSAM +TQ0ODA8LIAZBKEHs/MAAENEBAAsgA0EoQez8wAAQ0QEACyADQShB7PzAABDRAQALQRFBEUH41cAA +EH0ACwwNCwwNCwwLCwwLC0Go1sAAQTdB4NbAABCSAQALQfDWwABBNkGo18AAEJIBAAtBjNXAAEEc +QajVwAAQkgEAC0Hc1MAAQR1B/NTAABCSAQALQa/UwABBHEHM1MAAEJIBAAsgAA0BCyAGIA1qIQIg +CiEAQX8hBQJAA0AgAEF/Rg0BIAVBAWohBSAAIA1qIABBAWshAC0AAEE5Rg0ACyAAIA1qIgJBAWoi +AyADLQAAQQFqOgAAIAVFIABBAmogCktyDQEgAkECakEwIAX8CwAMAQsgDUExOgAAIAoEQCANQQFq +QTAgCvwLAAsgBkERSQRAIAJBMDoAACAOQQFqIQ4gCkECaiEGDAELIAZBEUGI1sAAEH0ACyAGQRFN +BEAgDyAOOwEIIA8gBjYCBCAPIA02AgAgAUGgCmokAAwFCyAGQRFBmNbAABDRAQALIAJBKEHs/MAA +ENEBAAtB/PzAAEEaQez8wAAQkgEACyAAQShB7PzAABDRAQALQShBKEHs/MAAEH0ACwsgByAHKAJQ +IAcoAlQgBy8BWEEAIAdBIGoQTyAHKAIEIQAgBygCAAwBCyAHQQI7ASAgB0EBNgIoIAdBm+jAADYC +JCAHQSBqCyEBIAcgADYCXCAHIAE2AlggByAbNgJUIAcgFzYCUCAHQdAAahA9IAdBgAFqJAAPCwJ/ +IAEhDCACQQBHIQIgAS8BDiERQQAhASMAQfAIayIHJAAgP70hJwJ/QQMgP5lEAAAAAAAA8H9hDQAa +QQIgJ0KAgICAgICA+P8AgyImQoCAgICAgID4/wBRDQAaICdC/////////weDIilCgICAgICAgAiE +ICdCAYZC/v///////w+DICdCNIinQf8PcSIAGyIlQgGDISggJlAEQEEEIClQDQEaIABBswhrIQFC +ASEmIChQDAELQoCAgICAgIAgICVCAYYgJUKAgICAgICACFEiARshJUICQgEgARshJkHLd0HMdyAB +GyAAaiEBIChQCyEAIAcgATsB6AggByAmNwPgCCAHQgE3A9gIIAcgJTcD0AggByAAOgDqCAJAAn8C +QAJAAkACQCAAQQJrIgMEQEEBIQBBk+jAAEGU6MAAICdCAFMiBhtBk+jAAEEBIAYbIAIbIRsgJ0I/ +iKcgAnIhHUEDIAMgA0EDTxtBAmsOAgIDAQsgB0EDNgKYCCAHQZXowAA2ApQIIAdBAjsBkAhBASEb +QQEhACAHQZAIagwECyAHQQM2ApgIIAdBmOjAADYClAggB0ECOwGQCCAHQZAIagwDC0ECIQAgB0EC +OwGQCCARRQ0BIAcgETYCoAggB0EAOwGcCCAHQQI2ApgIIAdBkejAADYClAggB0GQCGoMAgtBdEEF +IAHBIgBBAEgbIABsIgBBwP0ASQRAIAdBkAhqIQQgB0EQaiEFIABBBHZBFWoiCiEBQYCAfkEAIBFr +IBHBQQBIGyEJAkACQAJ/AkACQAJAAkAgB0HQCGoiACkDACIlUEUEQCAlQoCAgICAgICAIFoNASAB +RQ0CQaB/IAAvARgiAEEgayAAICVCgICAgBBUIgAbIgJBEGsgAiAlQiCGICUgABsiJUKAgICAgIDA +AFQiABsiAkEIayACICVCEIYgJSAAGyIlQoCAgICAgICAAVQiABsiAkEEayACICVCCIYgJSAAGyIl +QoCAgICAgICAEFQiABsiAkECayACICVCBIYgJSAAGyIlQoCAgICAgICAwABUIgAbICVCAoYgJSAA +GyIlQgBZayIDa8FB0ABsQbCnBWpBzhBtIgBB0QBPDQMgAEEEdCICQdjYwABqKQMAIiZC/////w+D +IicgJSAlQn+FQj+IhiIlQiCIIih+IilCIIggJkIgiCImICh+fCAmICVC/////w+DIiV+IiZCIIh8 +IClC/////w+DICUgJ35CIIh8ICZC/////w+DfEKAgICACHxCIIh8IiVBQCADIAJB4NjAAGovAQBq +ayILQT9xrSIniKchACACQeLYwABqLwEAIQIgJUIBICeGIihCAX0iKYMiJlAEQCABQQpLDQcgAUEC +dEHs5cAAaigCACAASw0HCyAAQZDOAE8EQCAAQcCEPUkNBSAAQYDC1y9PBEBBCEEJIABBgJTr3ANJ +IgMbIQZBgMLXL0GAlOvcAyADGwwHC0EGQQcgAEGAreIESSIDGyEGQcCEPUGAreIEIAMbDAYLIABB +5ABPBEBBAkEDIABB6AdJIgMbIQZB5ABB6AcgAxsMBgtBCkEBIABBCUsiBhsMBQtBr9TAAEEcQZzl +wAAQkgEAC0Gs5cAAQSRB0OXAABCSAQALQfjkwABBIUHg5cAAEJIBAAsgAEHRAEGY48AAEH0AC0EE +QQUgAEGgjQZJIgMbIQZBkM4AQaCNBiADGwshAwJAAkACQAJAIAYgAmtBAWrBIgggCcEiAkoEQCAL +Qf//A3EhDiAIIAlrwSABIAggAmsgAUkbIgtBAWshD0EAIQIDQCAAIANuIQ0gASACRg0DIAAgAyAN +bGshACACIAVqIA1BMGo6AAAgAiAPRg0EIAIgBkYNAiACQQFqIQIgA0EKSSADQQpuIQNFDQALQZjm +wAAQmAEACyAEIAUgAUEAIAggCSAlQgqAIAOtICeGICgQQwwFCyACQQFqIQIgDkEBa0E/ca0hKkIB +ISUDQCAlICqIUEUEQCAEQQA2AgAMBgsgASACTQ0DIAIgBWogJkIKfiImICeIp0EwajoAACAlQgp+ +ISUgJiApgyEmIAsgAkEBaiICRw0ACyAEIAUgASALIAggCSAmICggJRBDDAQLIAEgAUGo5sAAEH0A +CyAEIAUgASALIAggCSAArSAnhiAmfCADrSAnhiAoEEMMAgsgAiABQbjmwAAQfQALIARBADYCAAsg +CcEhGAJAIAcoApAIBEAgB0HICGogB0GYCGooAgA2AgAgByAHKQKQCDcDwAgMAQsgB0HACGohEiAH +QRBqIQkjAEHABmsiBSQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAdB0AhqIgApAwAiJVBFBEAg +ACkDCCImUA0BIAApAxAiJ1ANAiAlICd8ICVUDQMgJSAmVA0EIAAuARghACAFICU+AgwgBUEBQQIg +JUKAgICAEFQiARs2AqwBIAVBACAlQiCIpyABGzYCECAFQRRqQQBBmAH8CwAgBUG0AWpBAEGcAfwL +ACAFQQE2ArABIAVBATYC0AIgAKwgJUIBfXl9QsKawegEfkKAoc2gtAJ8QiCIpyIBwSENAkAgAEEA +TgRAIAVBDGogABAsGgwBCyAFQbABakEAIABrwRAsGgsCQCANQQBIBEAgBUEMakEAIA1rQf//A3EQ +KgwBCyAFQbABaiABQf//AXEQKgsgBSgC0AIhCyAFQZwFaiAFQbABakGgAfwKAAAgBSALNgK8BiAK +IgZBCk8EQCAFQZQFaiECA0AgBSgCvAYiBEEpTw0KAkAgBEUNACAEQf////8DaiEAIARBAnQhAQJ/ +IARBAUYEQEIAISUgBUGcBWogAWoMAQsgASACaiEEIABB/////wNxQQFqQf7///8HcSEDQgAhJQNA +IARBBGoiASABNQIAICVCIIaEIiVCgJTr3AOAIiY+AgAgBCAENQIAICUgJkKAlOvcA359QiCGhCIl +QoCU69wDgCImPgIAICUgJkKAlOvcA359ISUgBEEIayEEIANBAmsiAw0ACyAlQiCGISUgBEEIagsg +AEEBcQ0AQQRrIgAgJSAANQIAhEKAlOvcA4A+AgALIAZBCWsiBkEJSw0ACwsgBkECdEHw5cAAaigC +AEEBdCICRQ0FIAUoArwGIgRBKU8NCCAEBH8gBEH/////A2ohACAEQQJ0IQEgAq0hJQJ/IARBAUYE +QEIAISYgBUGcBWogAWoMAQsgASAFakGUBWohBCAAQf////8DcUEBakH+////B3EhA0IAISYDQCAE +QQRqIgEgATUCACAmQiCGhCImICWAIic+AgAgBCAENQIAICYgJSAnfn1CIIaEIiYgJYAiJz4CACAm +ICUgJ359ISYgBEEIayEEIANBAmsiAw0ACyAmQiCGISYgBEEIagshASAAQQFxRQRAIAFBBGsiACAm +IAA1AgCEICWAPgIACyAFKAK8BgVBAAshAQJAAkACQCAFKAKsASIAIAEgACABSxsiAUEoTQRAIAFF +BEBBACEBDAQLIAFBAXEhDiABQQFHDQFBACEGQQAhCAwCCwwUCyABQT5xIQ9BACEGIAVBnAVqIQQg +BUEMaiEDQQAhCANAIAQgBCgCACIXIAMoAgBqIgIgBkEBcWoiEzYCACAEQQRqIgYgBigCACIZIANB +BGooAgBqIgYgAiAXSSACIBNLcmoiAjYCACAGIBlJIAIgBklyIQYgA0EIaiEDIARBCGohBCAPIAhB +AmoiCEcNAAsLIA4EfyAIQQJ0IgIgBUGcBWpqIgMgAygCACIDIAVBDGogAmooAgBqIgIgBmoiBjYC +ACACIANJIAIgBktyBSAGC0EBcUUNACABQShGDQogBUGcBWogAUECdGpBATYCACABQQFqIQELIAUg +ATYCvAYgCyABIAEgC0kbIgRBKU8NCCAEQQJ0IQQCQAJAA0AgBEUNASAEQQRrIgQgBUGcBWpqKAIA +IgEgBCAFQbABamooAgAiAkYNAAsgASACTw0BDAgLIAQNBwsgDUEBaiENDAcLQa/UwABBHEG418AA +EJIBAAtB3NTAAEEdQcjXwAAQkgEAC0GM1cAAQRxB2NfAABCSAQALQfDWwABBNkHI2MAAEJIBAAtB +qNbAAEE3QbjYwAAQkgEAC0Gz/cAAQRtB7PzAABCSAQALIABFBEBBACEAIAVBADYCrAEMAQsgAEEB +a0H/////A3EiAUEBaiICQQNxIQMCQCABQQNJBEAgBUEMaiEEQgAhJQwBCyACQfz///8HcSEBIAVB +DGohBEIAISUDQCAEIAQ1AgBCCn4gJXwiJT4CACAEQQRqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIARB +CGoiAiACNQIAQgp+ICVCIIh8IiU+AgAgBEEMaiICIAI1AgBCCn4gJUIgiHwiJj4CACAmQiCIISUg +BEEQaiEEIAFBBGsiAQ0ACwsgAwRAA0AgBCAENQIAQgp+ICV8IiY+AgAgBEEEaiEEICZCIIghJSAD +QQFrIgMNAAsLICZCgICAgBBaBEAgAEEoRg0DIAVBDGogAEECdGogJT4CACAAQQFqIQALIAUgADYC +rAELQQAhBgJAAkACQAJAIA3BIgEgGMEiAkgiHkUEQCANIBhrwSAKIAEgAmsgCkkbIggNAQtBACEI +DAELIAVB1AJqIgEgBUGwAWoiAEGgAfwKAAAgBSALNgL0A0EBIRcgAUEBECwhHyAFKALQAiEBIAVB ++ANqIgIgAEGgAfwKAAAgBSABNgKYBSACQQIQLCEgIAUoAtACIQEgBUGcBWoiAiAAQaAB/AoAACAF +IAE2ArwGIAVBrAFqISEgBUHQAmohIiAFQfQDaiEUIAVBmAVqISNBACEOIAJBAxAsISQgBSgCrAEh +ACAFKALQAiELIAUoAvQDIRMgBSgCmAUhGSAFKAK8BiEQAkACQAJAAkADQCAAQSlPDQogAEECdCEB +QQAhBAJ/AkACQANAIAEgBEYNASAFQQxqIARqIARBBGohBCgCAEUNAAsgECAAIAAgEEkbIgFBKU8N +FCABQQJ0IQQCQANAIARFDQEgBCAjaiECIARBBGsiBCAFQQxqaigCACIDIAIoAgAiAkYNAAsgAiAD +TQ0CQQAMAwsgBEUNAUEADAILIAggCksNBCAIIA5GDQggCCAOayIARQ0IIAkgDmpBMCAA/AsADAgL +QQEhBkEAIQAgAUEBRwRAIAFBPnEhDyAFQQxqIQQgBUGcBWohAwNAIAQgBCgCACIVIAMoAgBBf3Nq +IgIgBkEBcWoiFjYCACAEQQRqIgYgBigCACIaIANBBGooAgBBf3NqIgYgAiAVSSACIBZLcmoiAjYC +ACAGIBpJIAIgBklyIQYgA0EIaiEDIARBCGohBCAPIABBAmoiAEcNAAsLIAFBAXEEfyAAQQJ0IgAg +BUEMamoiAiACKAIAIgIgACAkaigCAEF/c2oiACAGaiIDNgIAIAAgAkkgACADS3IFIAYLQQFxRQ0M +IAUgATYCrAEgASEAQQgLIQ8gGSAAIAAgGUkbIgJBKU8NAyACQQJ0IQQCQAJAAkADQCAERQ0BIAQg +FGohASAEQQRrIgQgBUEMamooAgAiAyABKAIAIgFGDQALIAEgA00NASAAIQIMAgsgBEUNACAAIQIM +AQsgAgRAQQEhBkEAIQAgAkEBRwRAIAJBPnEhFSAFQQxqIQQgBUH4A2ohAwNAIAQgBCgCACIWIAMo +AgBBf3NqIgEgBkEBcWoiGjYCACAEQQRqIgYgBigCACIcIANBBGooAgBBf3NqIgYgASAWSSABIBpL +cmoiATYCACAGIBxJIAEgBklyIQYgA0EIaiEDIARBCGohBCAVIABBAmoiAEcNAAsLIAJBAXEEfyAA +QQJ0IgAgBUEMamoiASABKAIAIgEgACAgaigCAEF/c2oiACAGaiIDNgIAIAAgAUkgACADS3IFIAYL +QQFxRQ0NCyAFIAI2AqwBIA9BBHIhDwsgEyACIAIgE0kbIgFBKU8NBCABQQJ0IQQCQAJAAkADQCAE +RQ0BIAQgImohACAEQQRrIgQgBUEMamooAgAiAyAAKAIAIgBGDQALIAAgA00NASACIQEMAgsgBEUN +ACACIQEMAQsgAQRAQQEhBkEAIQAgAUEBRwRAIAFBPnEhFSAFQQxqIQQgBUHUAmohAwNAIAQgBCgC +ACIWIAMoAgBBf3NqIgIgBkEBcWoiGjYCACAEQQRqIgYgBigCACIcIANBBGooAgBBf3NqIgYgAiAW +SSACIBpLcmoiAjYCACAGIBxJIAIgBklyIQYgA0EIaiEDIARBCGohBCAVIABBAmoiAEcNAAsLIAFB +AXEEfyAAQQJ0IgAgBUEMamoiAiACKAIAIgIgACAfaigCAEF/c2oiACAGaiIDNgIAIAAgAkkgACAD +S3IFIAYLQQFxRQ0NCyAFIAE2AqwBIA9BAmohDwsgCyABIAEgC0kbIgBBKU8NCiAAQQJ0IQQCQAJA +AkADQCAERQ0BIAQgIWohAiAEQQRrIgQgBUEMamooAgAiAyACKAIAIgJGDQALIAIgA00NASABIQAM +AgsgBEUNACABIQAMAQsgAARAQQEhBkEAIQEgAEEBRwRAIABBPnEhFSAFQQxqIQQgBUGwAWohAwNA +IAQgBCgCACIWIAMoAgBBf3NqIgIgBkEBcWoiGjYCACAEQQRqIgYgBigCACIcIANBBGooAgBBf3Nq +IgYgAiAWSSACIBpLcmoiAjYCACAGIBxJIAIgBklyIQYgA0EIaiEDIARBCGohBCAVIAFBAmoiAUcN +AAsLIABBAXEEfyABQQJ0IgEgBUEMamoiAiACKAIAIgIgBUGwAWogAWooAgBBf3NqIgEgBmoiAzYC +ACABIAJJIAEgA0tyBSAGC0EBcUUNDQsgBSAANgKsASAPQQFqIQ8LIAogDk0NASAJIA5qIA9BMGo6 +AAAgAEEpTw0KAkAgAEUEQEEAIQAMAQsgAEEBa0H/////A3EiAUEBaiICQQNxIQMCQCABQQNJBEAg +BUEMaiEEQgAhJgwBCyACQfz///8HcSEBIAVBDGohBEIAISYDQCAEIAQ1AgBCCn4gJnwiJT4CACAE +QQRqIgIgAjUCAEIKfiAlQiCIfCIlPgIAIARBCGoiAiACNQIAQgp+ICVCIIh8IiU+AgAgBEEMaiIC +IAI1AgBCCn4gJUIgiHwiJT4CACAlQiCIISYgBEEQaiEEIAFBBGsiAQ0ACwsgAwRAA0AgBCAENQIA +Qgp+ICZ8IiU+AgAgBEEEaiEEICVCIIghJiADQQFrIgMNAAsLICVCgICAgBBUDQAgAEEoRg0KIAVB +DGogAEECdGogJj4CACAAQQFqIQALIAUgADYCrAEgDkEBaiEOIBcgCCAXSyIBaiEXIAENAAtBASEG +DAQLIA4gCkGY2MAAEH0ACyAIIApBqNjAABDRAQALIAJBKEHs/MAAENEBAAsMDAsCQAJAAkAgC0Ep +SQRAAkAgC0UEQEEAIQsMAQsgC0EBa0H/////A3EiAUEBaiICQQNxIQMCQCABQQNJBEAgBUGwAWoh +BEIAISUMAQsgAkH8////B3EhASAFQbABaiEEQgAhJQNAIAQgBDUCAEIFfiAlfCIlPgIAIARBBGoi +AiACNQIAQgV+ICVCIIh8IiU+AgAgBEEIaiICIAI1AgBCBX4gJUIgiHwiJT4CACAEQQxqIgIgAjUC +AEIFfiAlQiCIfCImPgIAICZCIIghJSAEQRBqIQQgAUEEayIBDQALCyADBEADQCAEIAQ1AgBCBX4g +JXwiJj4CACAEQQRqIQQgJkIgiCElIANBAWsiAw0ACwsgJkKAgICAEFQNACALQShGDQggBUGwAWog +C0ECdGogJT4CACALQQFqIQsLIAUgCzYC0AIgCyAAIAAgC0kbIgRBKU8NBiAEQQJ0IQQgBUEIaiEA +IAVBrAFqIQECQAJAA0AgBEUNASABIARqIQIgACAEaiAEQQRrIQQoAgAiAyACKAIAIgJGDQALIAIg +A08NBQwBCyAGIARFcUUNBCAIQQFrIgAgCk8NAiAAIAlqLQAAQQFxRQ0ECyAIIApLDQIgCCAJakEA +IQQgCSEDAkADQCAEIAhGDQEgBEEBaiEEIANBAWsiAyAIaiIALQAAQTlGDQALIAAgAC0AAEEBajoA +ACAIIARrQQFqIAhPDQQgBEEBayIBRQ0EIABBAWpBMCAB/AsADAQLAkAgCEUEQEExIQQMAQsgCUEx +OgAAIAhBAUYEQEEwIQQMAQtBMCEEIAhBAWsiAEUNACAJQQFqQTAgAPwLAAsgDUEBaiENIB4gCCAK +T3INAyAEOgAAIAhBAWohCAwDCyALQShB7PzAABDRAQALIAAgCkHo18AAEH0ACyAIIApB+NfAABDR +AQALIAggCksNAQsgEiANOwEIIBIgCDYCBCASIAk2AgAgBUHABmokAAwFCyAIIApBiNjAABDRAQAL +IARBKEHs/MAAENEBAAtBKEEoQez8wAAQfQALIABBKEHs/MAAENEBAAtB/PzAAEEaQez8wAAQkgEA +CwsgGCAHLgHICCIASARAIAdBCGogBygCwAggBygCxAggACARIAdBkAhqEE8gBygCDCEAIAcoAggM +AwtBAiEAIAdBAjsBkAggEUUEQEEBIQAgB0EBNgKYCCAHQZvowAA2ApQIIAdBkAhqDAMLIAcgETYC +oAggB0EAOwGcCCAHQQI2ApgIIAdBkejAADYClAggB0GQCGoMAgtBnOjAAEElQcTowAAQkgEAC0EB +IQAgB0EBNgKYCCAHQZvowAA2ApQIIAdBkAhqCyEBIAcgADYCzAggByABNgLICCAHIB02AsQIIAcg +GzYCwAggDCAHQcAIahA9IAdB8AhqJAAMAQsgAUEoQez8wAAQ0QEACwtCAQF/IwBBIGsiAyQAIANB +ADYCECADQQE2AgQgA0IENwIIIAMgATYCHCADIAA2AhggAyADQRhqNgIAIAMgAhCeAQALQAEBfyAB +KAIAIgEgASgCCCIEQQFqNgIIIARBAEgEQAALIAAgATYCDCAAIAM2AgggACACNgIEIABBoLfAADYC +AAs8ACAAIAEpAAA3AAAgAEEYaiABQRhqKQAANwAAIABBEGogAUEQaikAADcAACAAQQhqIAFBCGop +AAA3AAALlAIBA38gACgCACECIAEoAggiAEGAgIAQcUUEQCAAQYCAgCBxRQRAIAIgARDTAQ8LQQAh +ACMAQYABayIEJAAgAigCACECA0AgACAEakH/AGogAkEPcSIDQTByIANBN2ogA0EKSRs6AAAgAEEB +ayEAIAJBD0sgAkEEdiECDQALIAFBAUG068AAQQIgACAEakGAAWpBACAAaxA1IARBgAFqJAAPC0EA +IQAjAEGAAWsiBCQAIAIoAgAhAgNAIAAgBGpB/wBqIAJBD3EiA0EwciADQdcAaiADQQpJGzoAACAA +QQFrIQAgAkEPSyACQQR2IQINAAsgAUEBQbTrwABBAiAAIARqQYABakEAIABrEDUgBEGAAWokAAs4 +AAJAIAJBgIDEAEYNACAAIAIgASgCEBEAAEUNAEEBDwsgA0UEQEEADwsgACADIAQgASgCDBEBAAst +AAJAIAAgARCzAUUNACAABEBB+YHBAC0AABogACABEMABIgFFDQELIAEPCwALNwEBfyMAQSBrIgEk +ACABQQA2AhggAUEBNgIMIAFB6P3AADYCCCABQgQ3AhAgAUEIaiAAEJ4BAAu4BQEHfyMAQRBrIgUk +ACMAQRBrIgckACAHQQRqIQgjAEGgAWsiBCQAIARBIGogACABEDYCQCAEKAIgQQFGBEAgBEEBNgIE +IARBhIfAADYCACAEQgE3AgwgBCAEQZ8Baq1CgICAgDCENwNoIAQgBEHoAGo2AgggBEH4AGogBBBF +IAQoAnwiBiAEKAKAARC1ASEJIAQoAngiCgRAIAYgChDMAQsgCEGAgICAeDYCACAIIAk2AgQMAQsg +BEEYaiAEQUBrIgYpAwA3AwAgBEEQaiAEQThqIgkpAwA3AwAgBEEIaiAEQTBqIgopAwA3AwAgBCAE +KQMoNwMAIARBIGogAiADEDYgBCgCIEEBRgRAIARBATYCfCAEQaSHwAA2AnggBEIBNwKEASAEIARB +nwFqrUKAgICAMIQ3A5ABIAQgBEGQAWo2AoABIARB6ABqIARB+ABqEEUgBCgCbCIGIAQoAnAQtQEh +CSAEKAJoIgoEQCAGIAoQzAELIAhBgICAgHg2AgAgCCAJNgIEDAELIARB4ABqIAYpAwA3AwAgBEHY +AGogCSkDADcDACAEQdAAaiAKKQMANwMAIAQgBCkDKDcDSCAEQSBqIgYgBCAEQcgAahCFASAIIAYQ +YQsgBEGgAWokACADBEAgAiADEMwBCyABBEAgACABEMwBCwJAAkACfyAHKAIEIgNBgICAgHhGBEBB +ASEBQQAhAEEAIQIgBygCCAwBCyAHKAIIIQECQCAHKAIMIgIgA08EQCABIQAMAQsgAkUEQEEBIQAg +ASADEMwBDAELIAEgA0EBIAIQuAEiAEUNAgtBACEBQQALIQMgBSABNgIMIAUgAzYCCCAFIAI2AgQg +BSAANgIAIAdBEGokAAwBC0EBIAJBwIbAABCyAQALIAUoAgAgBSgCBCAFKAIIIAUoAgwgBUEQaiQA +C+oZAht/AX4jAEEQayINJAAjAEEgayIJJAAjAEEgayIEJAAgAa1CDH4iHachAwJAAkACQAJAIB1C +IIinIANB/P///wdLcg0AAn8gA0UEQEEEIQVBAAwBC0H5gcEALQAAGkEEIQIgA0EEEMABIgVFDQEg +AQshAiAEQQA2AhwgBCAFNgIYIAQgAjYCFCABBEAgAUECdCEKQQghAgNAIARBCGogACAIaigCACID +EOgBIAQoAggiEEUNAyAEKAIMIQsgA0GEAU8EQCADEGoLIAQoAhQgBkYEQCMAQSBrIgMkAEEEIARB +FGoiBSgCACIMQQF0IgcgB0EETRsiD61CDH4iHUIgiFBFBEBBAEEAQZDDwAAQsgEACwJAIB2nIg5B +/P///wdNBH8gAyAMBH8gAyAMQQxsNgIcIAMgBSgCBDYCFEEEBUEACzYCGCADQQhqQQQgDiADQRRq +EHEgAygCCEEBRw0BIAMoAhAhByADKAIMBUEACyAHQZDDwAAQsgEACyADKAIMIQcgBSAPNgIAIAUg +BzYCBCADQSBqJAAgBCgCGCEFCyACIAVqIgMgCzYCACADQQRrIBA2AgAgA0EIayALNgIAIAQgBkEB +aiIGNgIcIAJBDGohAiAKIAhBBGoiCEcNAAsgACABQQJ0EMwBCyAEKAIYIQACQCAGIAQoAhQiAU8E +QCAAIQIMAQsgAUEMbCEBIAZFBEBBBCECIAAgARDMAQwBCyAAIAFBBCAGQQxsIgAQuAEiAkUNAwsg +CSAGNgIEIAkgAjYCACAEQSBqJAAMAwsgAiADQfDCwAAQsgEAC0Ggw8AAQSgQ4QEAC0EEIABBgMPA +ABCyAQALIAkgCSgCBCIANgIQIAkgCSgCADYCDCAJIAA2AgggCUEUaiEQIwBBMGsiBCQAIAlBCGoi +ASgCACECIAEoAgQhACABKAIIIQEgBEEAOgAvIAQgACABQQxsajYCDCAEIAI2AgggBCAANgIEIAQg +ADYCACAEIARBL2o2AhAgBEEgaiEFIwBB4ABrIgIkAAJAAkACQAJAAkAgBCgCBCIBIAQoAgwiBkYE +QCABIQAMAQsgBCgCECEMIAQgAUEMaiIANgIEIAEoAgAhAyACQThqIAEoAgQiByABKAIIEDYgAwRA +IAcgAxDMAQsgAigCOEEBcUUNASAMQQE6AAALIAVBADYCCCAFQoCAgICAATcCACAGIABrQQxuIQEg +ACAGRwRAA0AgACgCACIDBEAgAEEEaigCACADEMwBCyAAQQxqIQAgAUEBayIBDQALCyAEKAIIIgBF +DQEgBCgCACAAQQxsEMwBDAELIAJBMGoiAyACQdgAaikDADcDACACQShqIgcgAkHQAGopAwA3AwAg +AkEgaiIIIAJByABqKQMANwMAIAIgAikDQDcDGEH5gcEALQAAGkGAAUEIEMABIgFFDQEgASACKQMY +NwMAIAFBGGogAykDADcDACABQRBqIAcpAwA3AwAgAUEIaiAIKQMANwMAIAJBATYCFCACIAE2AhAg +AkEENgIMIAQoAgghCiAEKAIAIQ8CQCAAIAZGDQAgAkFAayEIQSAhB0EBIQMDQCAAKAIAIQsgAkE4 +aiAAQQRqKAIAIg4gAEEIaigCABA2IAsEQCAOIAsQzAELIAIoAjhBAXEEQCAMQQE6AAAgAEEMaiEA +DAILIAJBMGoiDiAIQRhqKQMANwMAIAJBKGoiESAIQRBqKQMANwMAIAJBIGoiEyAIQQhqKQMANwMA +IAIgCCkDADcDGCACKAIMIANGBEAgAkEMaiADQQFBCEEgEFUgAigCECEBCyABIAdqIgsgAikDGDcD +ACALQRhqIA4pAwA3AwAgC0EQaiARKQMANwMAIAtBCGogEykDADcDACACIANBAWoiAzYCFCAHQSBq +IQcgAEEMaiIAIAZHDQALCyAGIABrQQxuIQEgACAGRwRAA0AgACgCACIDBEAgAEEEaigCACADEMwB +CyAAQQxqIQAgAUEBayIBDQALCyAKBEAgDyAKQQxsEMwBCyAFIAIpAgw3AgAgBUEIaiACQRRqKAIA +NgIACyACQeAAaiQADAELQQhBgAFB5JHAABCyAQALAkACQAJAAkACQCAELQAvQQFGBEAgBCgCICIA +RQ0BIAQoAiQgAEEFdBDMAQwBCyAEKAIgIhNBgICAgHhHDQELIARBADYCKCAEQoCAgIAQNwIgIARB +nIHAADYCBCAEQqCAgIAONwIIIAQgBEEgajYCACAEQS9qIAQQuQENAiAEKAIgIQAgBCgCJCIBIAQo +AigQtQEhAiAABEAgASAAEMwBCyAQQYCAgIB4NgIAIBAgAjYCBAwBCyAEKAIkIhkhACAEKAIoIQEj +AEHgAGsiCCQAIAhBADYCKCAIQQA2AhggCCAANgI4IAggACABQQV0ajYCPCAIQQxqIQtBACEBIwBB +EGsiBiQAAkACQAJ/AkACQCAIQRhqIgUiACgCACIDBEAgACgCBCICIAAoAgxHDQEgACgCCCICBEAg +AyACEMwBCyAAQQA2AgALIAAoAiAiA0UNASADIAAoAiRGDQEgACADQSBqNgIgQfmBwQAtAAAaQSBB +ARDAASICRQ0DIABBIDYCCCAAIAI2AgAgAiADKQAANwAAIAAgAkEgajYCDCACQRhqIANBGGopAAA3 +AAAgAkEQaiADQRBqKQAANwAAIAJBCGogA0EIaikAADcAAAsgACACQQFqNgIEIAItAAAhAEEBDAEL +IAAoAhAiAwRAIAAoAhQiAiAAKAIcRwRAIAAgAkEBajYCFCACLQAAIQBBAQwCCyAAKAIYIgIEQCAD +IAIQzAELIABBADYCEAtBAAshAiAGIAA6AAEgBiACOgAADAELQQFBIEGcrMAAELIBAAsCQCAGLQAA +BEACQEEIQX8gBSgCDCIPIAUoAgQiDGsiAiAFKAIcIhcgBSgCFCIAa0EAIAUoAhAiDhsiA2oiByAC +IAdLGyADIAUoAgAiAxtBAWoiAkF/IAIbIgIgAkEITRsiAkEASA0AIAYtAAEhB0H5gcEALQAAGkEB +IQEgAkEBEMABIgpFDQAgCiAHOgAAIAZBATYCDCAGIAo2AgggBiACNgIEIAUoAiQhGiAFKAIgIQcg +BSgCGCEYIAUoAgghEUEBIQUDQAJAAkACQAJ/AkAgA0UNACAMIAwgD0cNARogEUUNACADIBEQzAEL +IAdFIAcgGkZyDQFB+YHBAC0AABpBIEEBEMABIgNFDQIgAyAHKQAANwAAIANBGGogB0EYaikAADcA +ACADQRBqIAdBEGopAAA3AAAgA0EIaiAHQQhqKQAANwAAQSAhESADQSBqIQ8gB0EgaiEHIAMLIgJB +AWohDCAAIQEMAgsCQCAORQ0AIAAgF0cEQCAAQQFqIQFBACEDIAAhAgwDCyAYRQ0AIA4gGBDMAQsg +CyAGKQIENwIAIAtBCGogBkEMaigCADYCAAwFC0EBQSBBnKzAABCyAQALIAItAAAhGyAGKAIEIAVG +BEAgBkEEaiEKIwBBIGsiACQAAkACQCAFQX8gDyAMayICIBcgAWtBACAOGyIUaiISIAIgEksbIBQg +AxtBAWoiAkF/IAIbIAVqIgJLDQBBCCACIAooAgAiFEEBdCISIAIgEksbIgIgAkEITRsiEq0iHUIg +iFBFDQAgHaciHEH/////B0sNACAAIBQEfyAAIBQ2AhwgACAKKAIENgIUQQEFQQALNgIYIABBCGpB +ASAcIABBFGoQcSAAKAIIQQFHDQEgACgCECECIAAoAgwhFgsgFiACQdixwAAQsgEACyAAKAIMIQIg +CiASNgIAIAogAjYCBCAAQSBqJAAgBigCCCEKCyAFIApqIBs6AAAgBiAFQQFqIgU2AgwgASEADAAL +AAsgASACQaywwAAQsgEACyALQQA2AgggC0KAgICAEDcCAAJAIAUoAgAiAEUNACAFKAIIIgFFDQAg +ACABEMwBCyAFKAIQIgBFDQAgBSgCGCIBRQ0AIAAgARDMAQsgBkEQaiQAIAhBQGsiAEG8sMAAIAgo +AhAiASAIKAIUEDMgBCAAEJQBIAgoAgwiAARAIAEgABDMAQsgCEHgAGokACAQIAQQYSATRQ0AIBkg +E0EFdBDMAQsgBEEwaiQADAELQcSBwABBNyAEQS9qQbSBwABB8ILAABB6AAsCQAJAIA0CfyAJKAIU +IgJBgICAgHhGBEBBACEAIAkoAhghAUEBDAELIAkoAhghAQJAIAkoAhwiFSACTwRAIAEhAAwBCyAV +RQRAQQEhACABIAIQzAEMAQsgASACQQEgFRC4ASIARQ0CC0EAIQFBAAs2AgwgDSABNgIIIA0gFTYC +BCANIAA2AgAgCUEgaiQADAELQQEgFUHAhsAAELIBAAsgDSgCACANKAIEIA0oAgggDSgCDCANQRBq +JAALzw4CGX8BfiMAQRBrIgokACMAQSBrIgckAAJAAkACQCAABEAgAEEIayINIA0oAgBBAWoiBjYC +ACAGRQ0BIAAoAgANAiAAQX82AgAgByANNgIQIAcgADYCDCAHIAI2AhwgByABNgIYIAcgAjYCFCAH +IABBCGoiBjYCCEEAIQIjAEGAAWsiAyQAIANBCGohDiAHQRRqIhMoAgQhFCATKAIIIQgjAEGAAWsi +ASQAIAFBADYCFCABQoCAgICAATcCDAJAAkAgCARAIAFByABqQQRyIQQDQCACIAhLDQIgAUHIAGog +BiACIBRqIAggAmtBABAxIAFBIGoiESAEQQhqKQIANwMAIAFBKGoiEiAEQRBqKQIANwMAIAFBMGoi +FSAEQRhqKQIANwMAIAFBOGoiFiAEQSBqKQIANwMAIAFBQGsiFyAEQShqKAIANgIAIAEgBCkCADcD +GCABKAJ4IRggASgCSCIZBEAgASgCFCIPIAEoAgxGBEAjAEEgayIFJABBBCABQQxqIgwoAgAiEEEB +dCIJIAlBBE0bIhqtQjB+IhxCIIhQRQRAQQBBAEGAl8AAELIBAAsCQCAcpyIbQfj///8HTQRAIAUg +EAR/IAUgEEEwbDYCHCAFIAwoAgQ2AhRBCAVBAAs2AhggBUEIakEIIBsgBUEUahBxIAUoAghBAUcN +ASAFKAIMIQsgBSgCECEJCyALIAlBgJfAABCyAQALIAUoAgwhCSAMIBo2AgAgDCAJNgIEIAVBIGok +AAsgASgCECAPQTBsaiIFIAEpAxg3AgQgBSAZNgIAIAVBDGogESkDADcCACAFQRRqIBIpAwA3AgAg +BUEcaiAVKQMANwIAIAVBJGogFikDADcCACAFQSxqIBcoAgA2AgAgASAPQQFqNgIUCyACIBhqIgIg +CEcNAAsLIA4gASkCDDcCACAOQQhqIAFBFGooAgA2AgAgAUGAAWokAAwBCyACIAhBkJfAABDQAQAL +AkACQAJAIAMoAhAiAkUEQEEEIQQMAQtB+YHBAC0AABogAkEUbCIBQQQQwAEiBEUNAQsgA0EANgIc +IAMgBDYCGCADIAI2AhQgAygCDCIFIAJBMGxqIQggAygCCCEMIAUhAQJAIAIEQCADQSxqIQ4gA0Ew +aiEJIANBIGpBBHIiBEEIaiEPIARBGGohECAEQSBqIREgBEEoaiESIAEhAgNAIAIoAgAiAQRAIAMg +ATYCICAEIAJBBGopAgA3AgAgDyACQQxqKQIANwIAIARBEGogAkEUaikCADcCACAQIAJBHGopAgA3 +AgAgESACQSRqKQIANwIAIBIgAkEsaigCADYCACAGLQAwIQEgCRCAASELIANB0ABqIAkQYSADIAsg +AUEBc3I6AGAgAyADKAIoIgE2AlwgDiADKAIkIAEgAygCICgCEBEDACADKAIcIgEgAygCFEYEQCAD +QRRqQbCFwAAQZAsgAygCGCABQRRsaiILIAMpAlA3AgAgC0EIaiADQdgAaikCADcCACALQRBqIANB +4ABqKAIANgIAIAZBAToAMCADIAFBAWo2AhwgAkEwaiICIAhHDQEMAwsLIAJBMGohAQsgASAIRg0A +IAggAWsiAkEwbiIGQQFxQQAhBCACQTBrQTBPBEAgBkH+//8/cSEGIAEhAgNAIAJBDGogAkEEaigC +ACACQQhqKAIAIAIoAgAoAhARAwAgAkE8aiACQTRqKAIAIAJBOGooAgAgAkEwaigCACgCEBEDACAC +QeAAaiECIAYgBEECaiIERw0ACwtFDQAgASAEQTBsaiIBQQxqIAEoAgQgASgCCCABKAIAKAIQEQMA +CyAMBEAgBSAMQTBsEMwBCyADQQA2AmQgAygCGCECQQEhBiADQfQAaiADQeQAaiADKAIcIgEQsQEC +QCADKAJ0RQRAIAMoAnghAQwBCyADQfAAaiADQfwAaigCADYCACADIAMpAnQ3A2gCQCABBEAgAUEU +bCEGIANB6ABqQQRyIQUgAygCcCEEA0AgAyACIAMoAmgQXiADKAIEIQEgAygCAEEBcQ0CIAUgBCAB +EM4BIAMgBEEBaiIENgJwIAJBFGohAiAGQRRrIgYNAAsLQQAhBiADKAJsIQEMAQtBASEGIAMoAmwi +AkGEAUkNACACEGoLIAMoAhwiBARAIAMoAhghAgNAIAIoAgAiBQRAIAJBBGooAgAgBRDMAQsgAkEU +aiECIARBAWsiBA0ACwsgAygCFCICBEAgAygCGCACQRRsEMwBCyATKAIAIgIEQCAUIAIQzAELIAcg +ATYCBCAHIAY2AgAgA0GAAWokAAwBC0EEIAFBoIXAABCyAQALIAcoAgQhASAHKAIAIQIgAEEANgIA +IA0gDSgCAEEBayIANgIAIABFBEAgB0EQahCPAQsgCiACQQFxIgA2AgggCiABQQAgABs2AgQgCkEA +IAEgABs2AgAgB0EgaiQADAMLEN8BCwALEOABAAsgCigCACAKKAIEIAooAgggCkEQaiQAC6AGAQh/ +IwBBEGsiBCQAEG0iAiAAJgEjAEEQayIIJAAgCEEEaiEDIwBB0ABrIgEkACABQQxqIAIQLiABKAIQ +IQICQAJAAkAgASgCDCIFQYCAgIB4RgRAIAEgAjYCPCABQQA2AkggAUKAgICAEDcCQCABQZyBwAA2 +AhwgAUKggICADjcCICABIAFBQGs2AhggAUE8aiABQRhqEI4BDQIgASgCQCECIAEoAkQiBSABKAJI +ELUBIQYgAgRAIAUgAhDMAQsgASgCPCICQYQBTwRAIAIQagsgA0GAgICAeDYCACADIAY2AgQMAQsg +ASgCFCEGIAFBADoADCABIAIgBkEEdGo2AiQgASAFNgIgIAEgAjYCHCABIAI2AhggASABQQxqNgIo +IAFBQGsgAUEYahArAkACQCABLQAMQQFGBEAgASgCQCICRQ0BIAEoAkQgAkEobBDMAQwBCyABKAJA +IgJBgICAgHhHDQELIAFBADYCSCABQoCAgIAQNwJAIAFBnIHAADYCHCABQqCAgIAONwIgIAEgAUFA +azYCGCABQc8AaiABQRhqELkBDQIgASgCQCECIAEoAkQiBSABKAJIELUBIQYgAgRAIAUgAhDMAQsg +A0GAgICAeDYCACADIAY2AgQMAQsgASgCRCEFAkAgASgCSCIGRQRAIAFBMGpCADcDACABQShqQgA3 +AwAgAUEgakIANwMAIAFCADcDGAwBCyABQRhqIAUgBhAwCyADIAFBGGoQYSACRQ0AIAUgAkEobBDM +AQsgAUHQAGokAAwBC0HEgcAAQTcgAUHPAGpBtIHAAEHwgsAAEHoACwJAAkAgBAJ/IAgoAgQiAkGA +gICAeEYEQCAIKAIIIQFBACEDQQEMAQsgCCgCCCEBAkAgCCgCDCIDIAJPBEAgASEHDAELIANFBEBB +ASEHIAEgAhDMAQwBCyABIAJBASADELgBIgdFDQILQQAhAUEACzYCDCAEIAE2AgggBCADNgIEIAQg +BzYCACAIQRBqJAAMAQtBASADQcCGwAAQsgEACyAEKAIAIAQoAgQgBCgCCCAEKAIMIARBEGokAAvC +BgEJfyMAQRBrIgQkABBtIgIgACYBIwBBEGsiCCQAIAhBBGohAyMAQfAAayIBJAAgAUEIaiACEC4g +ASgCDCECAkACQAJAIAEoAggiBkGAgICAeEYEQCABIAI2AmggAUEANgIwIAFCgICAgBA3AiggAUGc +gcAANgJMIAFCoICAgA43AlAgASABQShqNgJIIAFB6ABqIAFByABqEI4BDQIgASgCKCECIAEoAiwi +BiABKAIwELUBIQUgAgRAIAYgAhDMAQsgASgCaCICQYQBTwRAIAIQagsgA0GAgICAeDYCACADIAU2 +AgQMAQsgASgCECEFIAFBADoACCABIAIgBUEEdGo2AlQgASAGNgJQIAEgAjYCTCABIAI2AkggASAB +QQhqNgJYIAFBKGogAUHIAGoQKwJAAkAgAS0ACEEBRgRAIAEoAigiAkUNASABKAIsIAJBKGwQzAEM +AQsgASgCKCICQYCAgIB4Rw0BCyABQQA2AjAgAUKAgICAEDcCKCABQZyBwAA2AkwgAUKggICADjcC +UCABIAFBKGo2AkggAUHvAGogAUHIAGoQuQENAiABKAIoIQIgASgCLCIGIAEoAjAQtQEhBSACBEAg +BiACEMwBCyADQYCAgIB4NgIAIAMgBTYCBAwBCyABKAIsIQYCQCABKAIwIgVFBEAgAUEgakIANwMA +IAFBGGpCADcDACABQRBqQgA3AwAgAUIANwMIDAELIAFBKGoiCSAGIAUQMCABQcgAaiIFQdCGwAAQ +lAEgAUEIaiAJIAUQhQELIAMgAUEIahBhIAJFDQAgBiACQShsEMwBCyABQfAAaiQADAELQcSBwABB +NyABQe8AakG0gcAAQfCCwAAQegALAkACQCAEAn8gCCgCBCICQYCAgIB4RgRAIAgoAgghAUEAIQNB +AQwBCyAIKAIIIQECQCAIKAIMIgMgAk8EQCABIQcMAQsgA0UEQEEBIQcgASACEMwBDAELIAEgAkEB +IAMQuAEiB0UNAgtBACEBQQALNgIMIAQgATYCCCAEIAM2AgQgBCAHNgIAIAhBEGokAAwBC0EBIANB +wIbAABCyAQALIAQoAgAgBCgCBCAEKAIIIAQoAgwgBEEQaiQAC/oBAgJ/AX4jAEEQayICJAAgAkEB +OwEMIAIgATYCCCACIAA2AgQjAEEQayIBJAAgAkEEaiIAKQIAIQQgASAANgIMIAEgBDcCBCMAQRBr +IgAkACABQQRqIgEoAgAiAigCDCEDAkACQAJAAkAgAigCBA4CAAECCyADDQFBASECQQAhAwwCCyAD +DQAgAigCACICKAIEIQMgAigCACECDAELIABBgICAgHg2AgAgACABNgIMIABB4MjAACABKAIEIAEo +AggiAC0ACCAALQAJEGMACyAAIAM2AgQgACACNgIAIABBxMjAACABKAIEIAEoAggiAC0ACCAALQAJ +EGMAC9UHAQx/IwBBEGsiBiQAIwBBIGsiBSQAAkACQAJAIAAEQCAAQQhrIgggCCgCAEEBaiIDNgIA +IANFDQEgACgCAA0CIABBfzYCACAFIAg2AhwgBSAANgIYIAUgAEEIaiIDNgIUIAVBCGohCyMAQaAB +ayIBJAAgAUEANgIUIAFCgICAgMAANwIMIwBBQGoiAiQAIAJBCGogA0EBQQBBARAxIAFBGGoiBEEo +aiACQTBqKQMANwMAIARBIGogAkEoaikDADcDACAEQRhqIAJBIGopAwA3AwAgBEEQaiACQRhqKQMA +NwMAIARBCGogAkEQaikDADcDACAEIAIpAwg3AwAgAkFAayQAAn8gASgCGCIERQRAQQQhAkEADAEL +IAFB8ABqIAFBQGspAwA3AwAgAUHoAGogAUE4aikDADcDACABQeAAaiABQTBqKQMANwMAIAFB2ABq +IgIgAUEoaikDADcDACABQdAAaiIJIAFBIGopAwA3AwAgASABKQMYNwNIIAMtADAhByACEIABIQog +AUH4AGogAhBhIAFBiAFqIgwgCiAHQQFzcjoAACABIAkoAgAiAjYChAEgAUHUAGogASgCTCACIAEo +AkgoAhARAwAgAUEMakGwhsAAEGQgASgCECICIAEpAng3AgAgAkEIaiABQYABaikCADcCACACQRBq +IAwoAgA2AgAgA0EBOgAwIAFBATYCFEEBCyEDIAFBADYCjAFBASEJIAFBGGogAUGMAWogAxCxAQJA +IAEoAhhFBEAgASgCHCEEDAELIAFBmAFqIAFBIGooAgA2AgAgASABKQIYNwOQAQJAIAQEQCADQRRs +IQcgAUGQAWpBBHIhCiABKAKYASEDA0AgASACIAEoApABEF4gASgCBCEEIAEoAgBBAXENAiAKIAMg +BBDOASABIANBAWoiAzYCmAEgAkEUaiECIAdBFGsiBw0ACwtBACEJIAEoApQBIQQMAQsgASgClAEi +A0GEAUkNACADEGoLIAEoAhQiAwRAIAEoAhAhAgNAIAIoAgAiBwRAIAJBBGooAgAgBxDMAQsgAkEU +aiECIANBAWsiAw0ACwsgASgCDCIDBEAgASgCECADQRRsEMwBCyALIAQ2AgQgCyAJNgIAIAFBoAFq +JAAgBSgCDCEDIAUoAgghASAAQQA2AgAgCCAIKAIAQQFrIgA2AgAgAEUEQCAFQRxqEI8BCyAGIAFB +AXEiADYCCCAGIANBACAAGzYCBCAGQQAgAyAAGzYCACAFQSBqJAAMAwsQ3wELAAsQ4AEACyAGKAIA +IAYoAgQgBigCCCAGQRBqJAALIQACQCABIAMQswEEQCAAIAEgAyACELgBIgANAQsACyAACyUAIABF +BEBB6LPAAEEyEOEBAAsgACACIAMgBCAFIAEoAhAREgALIAEBf0EBIQEgACgCACIAQQFxBH8gAQUg +ACgCCEEBRgsLHwECfiAAKQMAIgIgAkI/hyIDhSADfSACQgBZIAEQRwsjACAARQRAQeizwABBMhDh +AQALIAAgAiADIAQgASgCEBEEAAsjACAARQRAQeizwABBMhDhAQALIAAgAiADIAQgASgCEBETAAsj +ACAARQRAQeizwABBMhDhAQALIAAgAiADIAQgASgCEBEoAAsjACAARQRAQeizwABBMhDhAQALIAAg +AiADIAQgASgCEBEqAAsjACAARQRAQeizwABBMhDhAQALIAAgAiADIAQgASgCEBEsAAsmAQF/IAAo +AgAiAUGAgICAeHJBgICAgHhHBEAgACgCBCABEMwBCwshACAARQRAQeizwABBMhDhAQALIAAgAiAD +IAEoAhARAwALIgAgAC0AAEUEQCABQdntwABBBRA5DwsgAUHe7cAAQQQQOQsfACAARQRAQeizwABB +MhDhAQALIAAgAiABKAIQEQAACyEAIABBADYCDCAAIAM2AgggACACNgIEIABBqLXAADYCAAtIACAB +UEUEQCAAKQMYIAGCDwsjAEEgayIAJAAgAEEANgIYIABBATYCDCAAQaz+wAA2AgggAEIENwIQIABB +CGpBnLnAABCeAQALKQAgACAALQAEIAFBLkZyOgAEIAAoAgAiACgCACABIAAoAgQoAhARAAALGAEB +fyAAKAIAIgEEQCAAKAIEIAEQzAELCyUBAW8QECEDEG0iAiADJgEgAEEANgIIIAAgAjYCBCAAIAE2 +AgALQgAgAARAIAAgARDmAQALIwBBIGsiACQAIABBADYCGCAAQQE2AgwgAEGQysAANgIIIABCBDcC +ECAAQQhqIAIQngEACxUAIAFpQQFGIABBgICAgHggAWtNcQscACAAQQA2AhAgAEIANwIIIABCgICA +gMAANwIACxYBAW8gACABEAAhAhBtIgAgAiYBIAALFgEBbyAAIAEQBSECEG0iACACJgEgAAsWAQFv +IAAlARAfIQEQbSIAIAEmASAAC+0GAQZ/An8CQAJAAkACQAJAIABBBGsiBSgCACIGQXhxIgRBBEEI +IAZBA3EiBxsgAWpPBEAgB0EAIAFBJ2oiCSAESRsNAQJAAkAgAkEJTwRAIAIgAxBGIggNAUEADAkL +IANBzP97Sw0BQRAgA0ELakF4cSADQQtJGyEBAkAgB0UEQCABQYACSSAEIAFBBHJJciAEIAFrQYGA +CE9yDQEMCQsgAEEIayICIARqIQcCQAJAAkACQCABIARLBEAgB0GUhsEAKAIARg0EIAdBkIbBACgC +AEYNAiAHKAIEIgZBAnENBSAGQXhxIgYgBGoiBCABSQ0FIAcgBhBLIAQgAWsiA0EQSQ0BIAUgASAF +KAIAQQFxckECcjYCACABIAJqIgEgA0EDcjYCBCACIARqIgIgAigCBEEBcjYCBCABIAMQQgwNCyAE +IAFrIgNBD0sNAgwMCyAFIAQgBSgCAEEBcXJBAnI2AgAgAiAEaiIBIAEoAgRBAXI2AgQMCwtBiIbB +ACgCACAEaiIEIAFJDQICQCAEIAFrIgNBD00EQCAFIAZBAXEgBHJBAnI2AgAgAiAEaiIBIAEoAgRB +AXI2AgRBACEDQQAhAQwBCyAFIAEgBkEBcXJBAnI2AgAgASACaiIBIANBAXI2AgQgAiAEaiICIAM2 +AgAgAiACKAIEQX5xNgIEC0GQhsEAIAE2AgBBiIbBACADNgIADAoLIAUgASAGQQFxckECcjYCACAB +IAJqIgEgA0EDcjYCBCAHIAcoAgRBAXI2AgQgASADEEIMCQtBjIbBACgCACAEaiIEIAFLDQcLIAMQ +KCIBRQ0BIANBfEF4IAUoAgAiAkEDcRsgAkF4cWoiAiACIANLGyICBEAgASAAIAL8CgAACyAAEDgg +AQwICyADIAEgASADSxsiAgRAIAggACAC/AoAAAsgBSgCACICQXhxIgMgAUEEQQggAkEDcSICG2pJ +DQMgAkEAIAMgCUsbDQQgABA4CyAIDAYLQcnGwABBLkH4xsAAEJIBAAtBiMfAAEEuQbjHwAAQkgEA +C0HJxsAAQS5B+MbAABCSAQALQYjHwABBLkG4x8AAEJIBAAsgBSABIAZBAXFyQQJyNgIAIAEgAmoi +AiAEIAFrIgFBAXI2AgRBjIbBACABNgIAQZSGwQAgAjYCACAADAELIAALCxkAIAEoAgBBrLnAAEEe +IAEoAgQoAgwRAQALDgAgAQRAIAAgARDMAQsLGQAgASgCAEHn6MAAQQ4gASgCBCgCDBEBAAsWACAA +KAIAIAEgAiAAKAIEKAIMEQEACxQAIAAoAgAgASAAKAIEKAIMEQAAC4MIAQR/IwBB8ABrIgUkACAF +IAM2AgwgBSACNgIIAn8gAUGBAk8EQAJ/QYACIAAsAIACQb9/Sg0AGkH/ASAALAD/AUG/f0oNABpB +/gFB/QEgACwA/gFBv39KGwsiBiAAaiwAAEG/f0oEQEGf7sAAIQdBBQwCCyAAIAFBACAGIAQQvgEA +C0EBIQcgASEGQQALIQggBSAGNgIUIAUgADYCECAFIAg2AhwgBSAHNgIYAkACQAJAAkAgASACSSIG +IAEgA0lyRQRAIAIgA0sNASACRSABIAJNckUEQCAFQQxqIAVBCGogACACaiwAAEG/f0obKAIAIQML +IAUgAzYCICADIAEiAkkEQCADQQFqIgIgA0EDayIGQQAgAyAGTxsiBkkNAwJ/IAIgBmsiB0EBayAA +IANqLAAAQb9/Sg0AGiAHQQJrIAAgAmoiAkECaywAAEG/f0oNABogB0EDayACQQNrLAAAQb9/Sg0A +GiAHQXxBeyACQQRrLAAAQb9/ShtqCyAGaiECCwJAIAJFDQAgASACTQRAIAEgAkYNAQwFCyAAIAJq +LAAAQb9/TA0ECwJ/AkACQCABIAJGDQACQAJAIAAgAmoiASwAACIAQQBIBEAgAS0AAUE/cSEGIABB +H3EhAyAAQV9LDQEgA0EGdCAGciEADAILIAUgAEH/AXE2AiRBAQwECyABLQACQT9xIAZBBnRyIQYg +AEFwSQRAIAYgA0EMdHIhAAwBCyADQRJ0QYCA8ABxIAEtAANBP3EgBkEGdHJyIgBBgIDEAEYNAQsg +BSAANgIkIABBgAFPDQFBAQwCCyAEENQBAAtBAiAAQYAQSQ0AGkEDQQQgAEGAgARJGwshACAFIAI2 +AiggBSAAIAJqNgIsIAVBBTYCNCAFQajvwAA2AjAgBUIFNwI8IAUgBUEYaq1CgICAgPALhDcDaCAF +IAVBEGqtQoCAgIDwC4Q3A2AgBSAFQShqrUKAgICAkAyENwNYIAUgBUEkaq1CgICAgKAMhDcDUCAF +IAVBIGqtQoCAgIDwCIQ3A0gMBAsgBSACIAMgBhs2AiggBUEDNgI0IAVB6O/AADYCMCAFQgM3Ajwg +BSAFQRhqrUKAgICA8AuENwNYIAUgBUEQaq1CgICAgPALhDcDUCAFIAVBKGqtQoCAgIDwCIQ3A0gM +AwsgBUEENgI0IAVByO7AADYCMCAFQgQ3AjwgBSAFQRhqrUKAgICA8AuENwNgIAUgBUEQaq1CgICA +gPALhDcDWCAFIAVBDGqtQoCAgIDwCIQ3A1AgBSAFQQhqrUKAgICA8AiENwNIDAILIAYgAkGA8MAA +ENIBAAsgACABIAIgASAEEL4BAAsgBSAFQcgAajYCOCAFQTBqIAQQngEACxEAIAAoAgAgACgCBCAB +EOcBCxkAAn8gAUEJTwRAIAEgABBGDAELIAAQKAsLDwAgACABKAIAIAIgAxBZCw8AIAAgASgCACAC +IAMQQQsRACAAKAIEIAAoAgggARDnAQvgBgEPfyAAKAIAIQcgACgCBCEFQQAhACMAQRBrIgYkAEEB +IQwCQCABKAIAIgpBIiABKAIEIg0oAhAiDhEAAA0AAkAgBUUEQAwBC0EAIAVrIQ8gByEBIAUhAAJA +An8CQANAIAAgAWohEEEAIQMCQANAIAEgA2oiBC0AACIJQf8Aa0H/AXFBoQFJIAlBIkZyIAlB3ABG +cg0BIAAgA0EBaiIDRw0ACyAAIAhqDAMLIARBAWohAQJAIAQsAAAiAEEATgRAIABB/wFxIQAMAQsg +AS0AAEE/cSELIABBH3EhCSAEQQJqIQEgAEFfTQRAIAlBBnQgC3IhAAwBCyABLQAAQT9xIAtBBnRy +IQsgBEEDaiEBIABBcEkEQCALIAlBDHRyIQAMAQsgCUESdEGAgPAAcSABLQAAQT9xIAtBBnRyciEA +IARBBGohAQsgBkEEaiAAQYGABBA0AkACQCAGLQAEQYABRg0AIAYtAA8gBi0ADmtB/wFxQQFGDQAC +QAJAIAIgAyAIaiIESw0AAkAgAkUNACACIAVPBEAgAiAFRw0CDAELIAIgB2osAABBv39MDQELAkAg +BEUNACAEIAVPBEAgBCAPakUNAQwCCyAHIAhqIANqLAAAQUBIDQELIAogAiAHaiAIIAJrIANqIA0o +AgwiAhEBAEUNAQwDCyAHIAUgAiAEQeTtwAAQvgEACwJAIAYtAARBgAFGBEAgCiAGKAIIIA4RAAAN +AwwBCyAKIAYtAA4iBCAGQQRqaiAGLQAPIARrIAIRAQANAgsCf0EBIABBgAFJDQAaQQIgAEGAEEkN +ABpBA0EEIABBgIAESRsLIAhqIANqIQILAn9BASAAQYABSQ0AGkECIABBgBBJDQAaQQNBBCAAQYCA +BEkbCyAIaiIEIANqIQggECABayIARQ0CDAELCwwECyADIARqCyIDIAJJDQBBACEAAkAgAkUNACAC +IAVPBEAgAiIAIAVHDQIMAQsgAiIAIAdqLAAAQb9/TA0BCyADRQRAQQAhAwwCCyADIAVPBEAgAyAF +Rg0CIAAhAgwBCyADIAdqLAAAQb9/Sg0BIAAhAgsgByAFIAIgA0H07cAAEL4BAAsgCiAAIAdqIAMg +AGsgDSgCDBEBAA0AIApBIiAOEQAAIQwLIAZBEGokACAMCxYAQdCCwQAgADYCAEHMgsEAQQE2AgAL +IgAgAELtuq22zYXU9eMANwMIIABC+IKZvZXuxsW5fzcDAAshACAAQoC834WrpfibJzcDCCAAQp/1 +lpTW7u3DoX83AwALEwAgAEG0yMAANgIEIAAgATYCAAsRACABIAAoAgAgACgCBBC8AQsQACABIAAo +AgAgACgCBBA5CxAAIAEoAgAgASgCBCAAEDsLYQECfwJAAkAgAEEEaygCACICQXhxIgNBBEEIIAJB +A3EiAhsgAWpPBEAgAkEAIAMgAUEnaksbDQEgABA4DAILQcnGwABBLkH4xsAAEJIBAAtBiMfAAEEu +QbjHwAAQkgEACwsdAQFvIAAoAgAlASABJQEgARBqIAIlASACEGoQDQsXAQFvIAAoAgAlASABIAIl +ASACEGoQGgsNACAAKAIAKAIIQQFGC2sBAX8jAEEwayIDJAAgAyABNgIEIAMgADYCACADQQI2Agwg +A0Ho/sAANgIIIANCAjcCFCADIANBBGqtQoCAgIDwCIQ3AyggAyADrUKAgICA8AiENwMgIAMgA0Eg +ajYCECADQQhqIAIQngEAC2sBAX8jAEEwayIDJAAgAyABNgIEIAMgADYCACADQQI2AgwgA0GI/8AA +NgIIIANCAjcCFCADIANBBGqtQoCAgIDwCIQ3AyggAyADrUKAgICA8AiENwMgIAMgA0EgajYCECAD +QQhqIAIQngEAC2sBAX8jAEEwayIDJAAgAyABNgIEIAMgADYCACADQQI2AgwgA0G8/8AANgIIIANC +AjcCFCADIANBBGqtQoCAgIDwCIQ3AyggAyADrUKAgICA8AiENwMgIAMgA0EgajYCECADQQhqIAIQ +ngEACwsAIAAoAgAgARBKCw8AQZDpwABBKyAAEJIBAAsNACAAKQMAQQEgARBHCw4AIAFBgIPAAEEF +ELwBCw4AIAFBuITAAEEQELwBCw4AIAFB0IjAAEEKELwBCwwAIAAoAgAgARDTAQuKAwEBfyAAKAIA +IQIjAEHQAWsiACQAIAAgAkEYaq1CgICAgPAGhDcDaCAAIAJBEGqtQoCAgIDwBoQ3A2AgACACQQhq +rUKAgICA8AaENwNYIAAgAq1CgICAgPAGhDcDUCAAQcy5wAA2AjggAEEENgI8IABBBDYCTCAAQoOA +gICAhICAaTcCyAEgAEGAgMAANgLAASAAQQI7AbgBIABCgoCAgICEgIBpNwKwASAAQYCAwAA2AqgB +IABBAjsBoAEgAEKBgICAgISAgGk3ApgBIABBgIDAADYCkAEgAEECOwGIASAAQoCAgICAhICAaTcC +gAEgAEKAgMAANwJ4IABBAjsBcCAAIABB8ABqNgJIIABBBDYCRCAAIABB0ABqNgJAIABBLGoiAiAA +QThqEEUgACACrUKAgICAgAeENwMgIABBATYCDCAAQdy6wAA2AgggAEIBNwIUIAAgAEEgajYCECAB +KAIAIAEoAgQgAEEIahA7IAAoAiwiAgRAIAAoAjAgAhDMAQsgAEHQAWokAAsNACAAQcCPwAAgARA7 +Cw4AIAFBuI7AAEEFELwBCw4AIAFBmrTAAEELELwBCw0AIABBjL7AACABEDsLDQBByMPAAEEbEOEB +AAsOAEHjw8AAQc8AEOEBAAsJACAAIAEQJAALDQAgAEGIxsAAIAEQOwsMACAAIAEpAgA3AwALDQAg +AEHkycAAIAEQOwsOACABQdzJwABBBRC8AQsaACAAIAFB1ILBACgCACIAQcgAIAAbEQIAAAsKACAC +IAAgARA5CwoAIAAgASUBEAELDgAgAUGkvsAAQQgQvAELDgAgAUGuwMAAQQMQvAELCQAgAEEANgIA +CwgAIAAlARACCwgAIAAlARARCwgAIAAlARAhCwQAQQALAgALC7aBAQ4AQYCAwAALsQEvaG9tZS9j +b3lvdHRlNTA4L2NvZGUvaHVnZ2luZ2ZhY2UuanMvcGFja2FnZXMvaHViL3hldC1jb3JlLXdhc20t +YnVpbGQvbWVya2xlaGFzaC9zcmMvYWdncmVnYXRlZF9oYXNoZXMucnMAAAAAABAAaQAAAFkAAAA4 +AAAAAAAQAGkAAABZAAAADwAAAAAAEABpAAAAVgAAADkAAAAEAAAADAAAAAQAAAAFAAAABgAAAAcA +QbyBwAALkQUBAAAACAAAAGEgRGlzcGxheSBpbXBsZW1lbnRhdGlvbiByZXR1cm5lZCBhbiBlcnJv +ciB1bmV4cGVjdGVkbHkvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUt eDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxs -b2Mvc3JjL3Jhd192ZWMvbW9kLnJzAAAAPAwQAHkAAAAuAgAAEQAAAE9uY2UgaW5zdGFuY2UgaGFz -IHByZXZpb3VzbHkgYmVlbiBwb2lzb25lZAAAyAwQACoAAABvbmUtdGltZSBpbml0aWFsaXphdGlv -biBtYXkgbm90IGJlIHBlcmZvcm1lZCByZWN1cnNpdmVsefwMEAA4AAAAL2hvbWUvY295b3R0ZTUw -OC8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9saWIv -cnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L3N0ZC9zcmMvc3luYy9wb2lzb24vb25jZS5yczwNEAB8 -AAAAmwAAADIAAABZ9UDoqdOIsNYg7Tn3x1JWq3KJiWmJskV3x4621YkKa7cxeos+V482S9k26dw2 -xh221VRVTkx6IMuaIyhGs3SkErmjHD6oBjv3ugIvbI3nkIqaDRX3LcnhrdOGEDoFlY4iBzq48fQu -Wq5/gJ+UrA+lgdbYgOsDcw4PrXAV3H6wmXYw/VW1L51oaKSeEYJQAAAozI+oBoOwxP1KN/aKZ7A+ -NnSthquHn/E2x2u+v58S8u2kmFxXSRFIxXtHlQYBAADM6pwagDe6H22bpGPWb/A7S4fjgpd+aJnj -2FCqcwaheSD0EWKez6zkcZBXhx/nICWbihp4/dPVK3PIEd3NTd4ALzmHWhwxqer/QLwXto5022+/ -IPaNmlevscIJG9rlpoYuoSLDCsMvzGdC98H+Kl41e6QhwPTImS3DzwSUSkveuml9cB1yGLX3ICzz -e1i2hjIMJ6+GiLYAAHmQitvk1hWhmeGyl5x+T0gB4xNXt3vKzGDxsCumhCW/yLxdYhPo561alYcN -lHAAAG9inhMIkeaKojjeL9dqd73PwPzCHwBr+yfEe+a4dKTHWF3rEBbx9rrRcOdtWx/LCUdMfZfm -GbKwSq2nbji8zAABP5ffCp2EzHD3agF976Nz/r29htPSB8gwF3lslskqf9oExcZrqDfQnWCqHmZ8 -8fOH5qpNsCamrAdbSk83mVp13q4sW+Z+g5CFB1b9k63obtjtUxDh2QAA19sc0rI7Bp6y0gEq8Xer -B0QbZOZVAlXsxhScRKiU+3j19cDGGw5Rx+PK5DYLMgAALRqLLCYzfIJEQepIC19nFOvsjUmm03sm -XgP1gvlvkfGI+zT0fxsihthJbzjnzr6dSo8PyMr4WOrYZPyShhmNADaav7pPcDhtTL7n0QfLMuCQ -CEWt9iGNIqWJJcC/sVxjcc6inHOhIEZY++Wq49/np+sNPCuTyhAMe+2vhOj+Jycfq+L5bRzfoiP1 -dAes0c1NTuIzrf9wAAAWeJfFe+isoklgKLRaJ5KYWYnx3YERhsIZPkhCoHKZu3gwUWY3zXDvZJj8 -qxMFAACDQMlYGLZYwN7gJZeFUOgJlH0++Dv7l5HOS7YSbWIeftFXe39QVAxSFiTidHF54b6HVeki -MqzZbz6/35p8lSMAFb5LI359HKC7jKO4WMeiqzArPuzOoB8Nkblgfoultgs1ZqKfW90zQ6PBAUB9 -O/3CJxFzVCSAQfvLGA2lhWGlZU+1hIe9Anr2Y1DmZ90Rb2mrFKj8IiAAAFLYuS2RvtaMV4qu6baJ -UWkoDNoKtVOU7l6EeBqpXvzYZ6dKGhm/hqvlFWTItcYAAC6iCI4XEHMmJcqLBxsQLe37qCayhO1B -OwbcKA8SIuYTJm1w++v1FaPOugEzTsMWiK79cbucWznpSBZyLiDpLAAcybMrHduDQqWmsdIaRn3X -a4brbuQX7OJ8xPs5QL7guASdKdXEYKHeNDaM0siG7H6Zo5ifEq0ZIe+DomFr9MymF8ZY9t7OUiyD -3axpEYe0LenLnvPW8AAAiZQvjcnY1T2E9QEronIYivI8ew7EpILylqEbyyzsIIAT41me4LaTZuuD -fMwZzgAAO5xH9jVXyyBbWtdZN78udnU5aT2C/nsg1dmcMxLBfdcDfWKEQoOnm+lRX+kTxX0hFnhe -/Ckae7ItZrsxmM3VAExzdW2Am+NxIxr7BvAqV36FH+lqL09zovLdLAK1xoK/3qBhB8bqO1yYaUFH -u5PIzQF+GFxhhRBtXXwnrDCu+HeRLCoSgWt8kWdp0a2ZtnVbmwaa52rPAAAEEd5g+grE88NnkaV6 -EmMgTYnRaSLmHWImRyvmHayI0TxnSxXiNnAQHTpVKF+4AAA9byMYTE7v8gL2uRFm3tbZHJFH+1V5 -/KG9jSkvA/2F6+H6vrMvUCe+HmbNxFFCA+M2GAdU02QTRD6Y8nVss4IA8Gb6FgORRbH3ykeYnAYc -AiFSS1rH3xAptahXHD41W3Ns2Y7pLDFEzmX6vQZFLpS8G5RXEqeGUPCtzlHTFbLD/gJCFOBVEK4A -VORCb4RAS/XIvLzI2X8AAP6b3hfznr2/Ek6F8i8wBKjU2OWlV0nOOYS6N1ak4rn/i4Ggnh2tuVWK -Fxnzy4oAADj7+9DIv+JI6LVI6EGY44uLoJYGFhInDiokREvolhDVOuGSZxe6ARGdaDFFD3cuwmzF -u3Ly74kW7FBWfxkqqQBOeKG9kFl2vK64/JLjQRTGoOQx7Sw64QdNnU4jhOnLksWKfbty9U+P0DuW -C8BwlgsB6wMaWFqVYlQCAOrlg19kmfKIzRbl/EHPmHraSJfau/pFSP6yqgAAVWX1mwYbdhlWrbZD -g16Pi9khSBT9HF0+j82woiweXOx/tfun/uD3+huWErrTAAAAjrEBhBeQP9rrXzrjbZD/cOdwacCn -1ScF6RN8YHPn2CKsOzxk33CryeMSvorcxqTtiuczAEEf7+zLcqx0ssIkALQAqU+VDXQGBGM9Mpsp -eh3V6suYsnzDs5tzeGHH44bJivVGSzbqq59WzIWvxRSibYSPo7fYPqQX69uaHVHszG77WjMTCbPK -+dLuFfTFYF5KtHI2UGdpAACHu1QUEh2lnRbIu7kTHjKEjd0vq7ZvPfuNChaO7V4wYOhslOkUS7/L -wxAbOGNPAAAQTsxvgbfVB1WBampyNqXl3X+gRzSyr1eU08mr90bzGD3TGtZVxm1j9vP3OUmri8x7 -GN3BBqnHYy9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS14ODZfNjQt -dW5rbm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMv -c2xpY2UucnMAyBUQAHMAAAC+AQAAHQAAAE9uY2UgaW5zdGFuY2UgaGFzIHByZXZpb3VzbHkgYmVl -biBwb2lzb25lZAAATBYQACoAAABvbmUtdGltZSBpbml0aWFsaXphdGlvbiBtYXkgbm90IGJlIHBl -cmZvcm1lZCByZWN1cnNpdmVseYAWEAA4AAAAL2hvbWUvY295b3R0ZTUwOC8ucnVzdHVwL3Rvb2xj -aGFpbnMvc3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9saWIvcnVzdGxpYi9zcmMvcnVz -dC9saWJyYXJ5L3N0ZC9zcmMvc3luYy9wb2lzb24vb25jZS5yc8AWEAB8AAAAmwAAADIAAAAvaG9t -ZS9jb3lvdHRlNTA4Ly5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhj -NmI1YjU1N2YvbGF6eV9zdGF0aWMtMS41LjAvc3JjL2lubGluZV9sYXp5LnJzAABMFxAAagAAAB4A -AAAQAAAAL2hvbWUvY295b3R0ZTUwOC8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLXg4Nl82NC11 -bmtub3duLWxpbnV4LWdudS9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2NvcmUvc3JjL2l0 -ZXIvdHJhaXRzL2l0ZXJhdG9yLnJzAAAAyBcQAIEAAADBBwAACQAAAH8YV9bOVu1mEn/5E+elw/Ok -zSbVtdtJ5kEkmH8o+5TDL2hvbWUvY295b3R0ZTUwOC8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxl -LXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2Fs -bG9jL3NyYy9yYXdfdmVjL21vZC5ycwAAAHwYEAB5AAAALgIAABEAAAAAAAAABAAAAAQAAAAYAAAA -L2hvbWUvY295b3R0ZTUwOC8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5 -Y2Y4YzZiNWI1NTdmL2pzLXN5cy0wLjMuNzcvc3JjL2xpYi5ycwAAGBkQAF4AAAD7GAAAAQAAAC9o -b21lL2NveW90dGU1MDgvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNm -OGM2YjViNTU3Zi93YXNtLWJpbmRnZW4tMC4yLjEwMC9zcmMvY29udmVydC9zbGljZXMucnOIGRAA -cAAAACQBAAAOAAAAY2xvc3VyZSBpbnZva2VkIHJlY3Vyc2l2ZWx5IG9yIGFmdGVyIGJlaW5nIGRy -b3BwZWRMYXlvdXRFcnJvci9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJs +b2Mvc3JjL3N0cmluZy5ycwD7ABAAdAAAANEKAAAOAAAARXJyb3IAAAD7ABAAdAAAAH0FAAAbAAAA +L2hvbWUvY295b3R0ZTUwOC8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLXg4Nl82NC11bmtub3du +LWxpbnV4LWdudS9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2FsbG9jL3NyYy9zbGljZS5y +cwCYARAAcwAAAL4BAAAdAAAAaGFzaGxlbmd0aAAAHAIQAAQAAAAgAhAABgAAAHN0cnVjdCBKc0No +dW5rSW5Kc0NodW5rT3V0ZGVkdXBhdHRlbXB0ZWQgdG8gdGFrZSBvd25lcnNoaXAgb2YgUnVzdCB2 +YWx1ZSB3aGlsZSBpdCB3YXMgYm9ycm93ZWRzcmMvbGliLnJzlgIQAAoAAAA9AAAAOAAAAJYCEAAK +AAAAQQAAACEAAAAvaG9tZS9jb3lvdHRlNTA4Ly5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3Jh +dGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvd2FzbS1iaW5kZ2VuLTAuMi4xMDAvc3JjL2NvbnZlcnQv +c2xpY2VzLnJzlgIQAAoAAABMAAAAFAAAAMACEABwAAAAJAEAAA4AQfCGwAALzQFJbnZhbGlkIGhh +c2ggaGV4OiAAAHADEAASAAAASW52YWxpZCBITUFDIGtleSBoZXg6IAAAjAMQABYAAAAvaG9tZS9j +b3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgt +Z251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvY29yZS9zcmMvaXRlci90cmFpdHMvaXRl +cmF0b3IucnMAAACsAxAAgQAAAMEHAAAJAEHIiMAAC5UBAQAAAAkAAABhIHNlcXVlbmNlL2hvbWUv +Y295b3R0ZTUwOC8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZi +NWI1NTdmL3NlcmRlLTEuMC4yMTkvc3JjL2RlL2ltcGxzLnJzAAAAWgQQAGMAAACVBAAAIgAAAFoE +EABjAAAAmAQAABwAQeiJwAALBQEAAAAKAEH4icAACwUBAAAACwBBiIrAAAvlAQEAAAAMAAAAY2Fs +bGVkIGBPcHRpb246OnVud3JhcF90aHJvdygpYCBvbiBhIGBOb25lYCB2YWx1ZWhhc2hsZW5ndGgv +aG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24t +bGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3Jhd192ZWMv +bW9kLnJzSwUQAHkAAAAuAgAAEQAAACA6IAoBAAAAAAAAANQFEAADAAAA1wUQAAEAQfiLwAALuwgB +AAAAEAAAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUvaG9tZS9j +b3lvdHRlNTA4L2NvZGUvaHVnZ2luZ2ZhY2UuanMvcGFja2FnZXMvaHViL3hldC1jb3JlLXdhc20t +YnVpbGQvbWVya2xlaGFzaC9zcmMvYWdncmVnYXRlZF9oYXNoZXMucnMrBhAAaQAAAD0AAAAqAAAA +KwYQAGkAAAA4AAAAHgAAAC9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJs ZS14ODZfNjQtdW5rbm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9h -bGxvYy9zcmMvc2xpY2UucnNFGhAAcwAAAL4BAAAdAAAAJQAAACYAAAAnAAAAKAAAACkAAAAvaG9t -ZS9jb3lvdHRlNTA4Ly5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhj -NmI1YjU1N2YvYnl0ZXMtMS4xMC4xL3NyYy9ieXRlcy5ycwAqAAAAKwAAACwAAAAtAAAALgAAAC8A -AAAwAAAAMQAAAC0AAAAyAEHstsAAC6UUAQAAADMAAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClg -IG9uIGFuIGBFcnJgIHZhbHVlANwaEABfAAAASAUAADIAAADcGhAAXwAAAFYFAABJAAAANAAAADUA -AAA2AAAANwAAADgAAAAvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUt -eDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxs -b2Mvc3JjL3NsaWNlLnJzANQbEABzAAAAvgEAAB0AAAAvaG9tZS9jb3lvdHRlNTA4L2NvZGUvaHVn -Z2luZ2ZhY2UuanMvcGFja2FnZXMvaHViL3hldC1jb3JlLXdhc20tYnVpbGQvbWVya2xlaGFzaC9z -cmMvZGF0YV9oYXNoLnJzAAAAWBwQAGEAAAB6AAAACQAAAEludmFsaWQgaGV4IGlucHV0IGZvciBE -YXRhSGFzaAAAAQAAAAAAAAABAAAAAAAAAAEAAAAAAAAAAQAAAAAAAABYHBAAYQAAALIAAAAqAAAA -WBwQAGEAAACzAAAAKgAAAFgcEABhAAAAtAAAACoAAABml/V3W5VQ3jE1y6yllxgcneQhEJvrK1i0 -0LBLk63yKQF+xcelRymW/ZRmZrSKAuZd3VNvN8dt0vhjUuZKU3E/AQAAAAAAAABtaWQgPiBsZW4A -AACEHRAACQAAAC9ob21lL2NveW90dGU1MDgvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0 -ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9ibGFrZTMtMS44LjIvc3JjL2xpYi5ycwAAAJgdEABdAAAA -CwIAABEAAACYHRAAXQAAAL4CAAAKAAAAmB0QAF0AAADsAgAAKAAAAJgdEABdAAAA7AIAADQAAACY -HRAAXQAAAOwCAAAMAAAAmB0QAF0AAADcAgAAFwAAAJgdEABdAAAAGAMAAB8AAACYHRAAXQAAADUD -AAAMAAAAmB0QAF0AAAA8AwAAEgAAAJgdEABdAAAAYAMAACEAAACYHRAAXQAAAGIDAAARAAAAmB0Q -AF0AAABiAwAAQQAAAGluc3VmZmljaWVudCBjYXBhY2l0eQAAALgeEAAVAAAAQ2FwYWNpdHlFcnJv -cjogANgeEAAPAAAAY2FsbGVkIGBSZXN1bHQ6OnVud3JhcCgpYCBvbiBhbiBgRXJyYCB2YWx1ZQAA -AAAABAAAAAQAAAA8AAAAAAAAAAgAAAAEAAAARAAAAEUAAABGAAAAYSBzdHJpbmdieXRlIGFycmF5 -Ym9vbGVhbiBgYFYfEAAJAAAAXx8QAAEAAABpbnRlZ2VyIGAAAABwHxAACQAAAF8fEAABAAAAZmxv -YXRpbmcgcG9pbnQgYIwfEAAQAAAAXx8QAAEAAABjaGFyYWN0ZXIgYACsHxAACwAAAF8fEAABAAAA -c3RyaW5nIADIHxAABwAAAHVuaXQgdmFsdWVPcHRpb24gdmFsdWVuZXd0eXBlIHN0cnVjdHNlcXVl -bmNlbWFwZW51bXVuaXQgdmFyaWFudG5ld3R5cGUgdmFyaWFudHR1cGxlIHZhcmlhbnRzdHJ1Y3Qg -dmFyaWFudAAAAAEAAAAAAAAALjB1MzJMYXp5IGluc3RhbmNlIGhhcyBwcmV2aW91c2x5IGJlZW4g -cG9pc29uZWQAUSAQACoAAAAvaG9tZS9jb3lvdHRlNTA4Ly5jYXJnby9yZWdpc3RyeS9zcmMvaW5k -ZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvb25jZV9jZWxsLTEuMjEuMy9zcmMvbGliLnJz -AAAAhCAQAGEAAAAIAwAAGQAAAHJlZW50cmFudCBpbml0AAD4IBAADgAAAIQgEABhAAAAegIAAA0A -AAAvaG9tZS9jb3lvdHRlNTA4Ly5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5 -NDljZjhjNmI1YjU1N2Yvd2FzbS1iaW5kZ2VuLTAuMi4xMDAvc3JjL2NvbnZlcnQvaW1wbHMucnMA -ICEQAG8AAABhAgAAFgAAACAhEABvAAAAcQIAAAwAAAAgIRAAbwAAAG0CAAAQAAAAYXJyYXkgY29u -dGFpbnMgYSB2YWx1ZSBvZiB0aGUgd3JvbmcgdHlwZW51bGwgcG9pbnRlciBwYXNzZWQgdG8gcnVz -dHJlY3Vyc2l2ZSB1c2Ugb2YgYW4gb2JqZWN0IGRldGVjdGVkIHdoaWNoIHdvdWxkIGxlYWQgdG8g -dW5zYWZlIGFsaWFzaW5nIGluIHJ1c3RKc1ZhbHVlKCkAUiIQAAgAAABaIhAAAQAAAC9ydXN0Yy8x -NzA2N2U5YWM2ZDdlY2I3MGU1MGY5MmMxOTQ0ZTU0NTE4OGQyMzU5L2xpYnJhcnkvYWxsb2Mvc3Jj -L3N0cmluZy5ycwBsIhAASwAAAH0FAAAbAAAAL3J1c3RjLzE3MDY3ZTlhYzZkN2VjYjcwZTUwZjky -YzE5NDRlNTQ1MTg4ZDIzNTkvbGlicmFyeS9hbGxvYy9zcmMvcmF3X3ZlYy9tb2QucnPIIhAAUAAA -AC4CAAARAAAASwAAAAwAAAAEAAAATAAAAE0AAABOAAAAL3J1c3QvZGVwcy9kbG1hbGxvYy0wLjIu -Ny9zcmMvZGxtYWxsb2MucnNhc3NlcnRpb24gZmFpbGVkOiBwc2l6ZSA+PSBzaXplICsgbWluX292 -ZXJoZWFkAEAjEAApAAAAqAQAAAkAAABhc3NlcnRpb24gZmFpbGVkOiBwc2l6ZSA8PSBzaXplICsg -bWF4X292ZXJoZWFkAABAIxAAKQAAAK4EAAANAAAAbWVtb3J5IGFsbG9jYXRpb24gb2YgIGJ5dGVz -IGZhaWxlZAAA6CMQABUAAAD9IxAADQAAAGxpYnJhcnkvc3RkL3NyYy9hbGxvYy5ycxwkEAAYAAAA -ZAEAAAkAAABLAAAADAAAAAQAAABPAAAAAAAAAAgAAAAEAAAAUAAAAAAAAAAIAAAABAAAAFEAAABS -AAAAUwAAAFQAAABVAAAAEAAAAAQAAABWAAAAVwAAAFgAAABZAAAASGFzaCB0YWJsZSBjYXBhY2l0 -eSBvdmVyZmxvd5wkEAAcAAAAL3J1c3QvZGVwcy9oYXNoYnJvd24tMC4xNS4yL3NyYy9yYXcvbW9k -LnJzAADAJBAAKgAAACMAAAAoAAAARXJyb3IAAABaAAAADAAAAAQAAABbAAAAXAAAAF0AAABjYXBh -Y2l0eSBvdmVyZmxvdwAAABwlEAARAAAAbGlicmFyeS9hbGxvYy9zcmMvcmF3X3ZlYy9tb2QucnM4 -JRAAIAAAAC4CAAARAAAAbGlicmFyeS9hbGxvYy9zcmMvc3RyaW5nLnJzAGglEAAbAAAA6AEAABcA -QZzLwAALyBIBAAAAXgAAAGEgZm9ybWF0dGluZyB0cmFpdCBpbXBsZW1lbnRhdGlvbiByZXR1cm5l -ZCBhbiBlcnJvciB3aGVuIHRoZSB1bmRlcmx5aW5nIHN0cmVhbSBkaWQgbm90bGlicmFyeS9hbGxv -Yy9zcmMvZm10LnJzAAD6JRAAGAAAAIoCAAAOAAAAaCUQABsAAAB9BQAAGwAAAABwAAcALQEBAQIB -AgEBSAswFRABZQcCBgICAQQjAR4bWws6CQkBGAQBCQEDAQUrAzsJKhgBIDcBAQEECAQBAwcKAh0B -OgEBAQIECAEJAQoCGgECAjkBBAIEAgIDAwEeAgMBCwI5AQQFAQIEARQCFgYBAToBAQIBBAgBBwMK -Ah4BOwEBAQwBCQEoAQMBNwEBAwUDAQQHAgsCHQE6AQICAQEDAwEEBwILAhwCOQIBAQIECAEJAQoC -HQFIAQQBAgMBAQgBUQECBwwIYgECCQsHSQIbAQEBAQE3DgEFAQIFCwEkCQFmBAEGAQICAhkCBAMQ -BA0BAgIGAQ8BAAMABBwDHQIeAkACAQcIAQILCQEtAwEBdQIiAXYDBAIJAQYD2wICAToBAQcBAQEB -AggGCgIBMB8xBDAKBAMmCQwCIAQCBjgBAQIDAQEFOAgCApgDAQ0BBwQBBgEDAsZAAAHDIQADjQFg -IAAGaQIABAEKIAJQAgABAwEEARkCBQGXAhoSDQEmCBkLAQEsAzABAgQCAgIBJAFDBgICAgIMAQgB -LwEzAQEDAgIFAgEBKgIIAe4BAgEEAQABABAQEAACAAHiAZUFAAMBAgUEKAMEAaUCAARBBQACTwRG -CzEEewE2DykBAgIKAzEEAgIHAT0DJAUBCD4BDAI0CQEBCAQCAV8DAgQGAQIBnQEDCBUCOQIBAQEB -DAEJAQ4HAwVDAQIGAQECAQEDBAMBAQ4CVQgCAwEBFwFRAQIGAQECAQECAQLrAQIEBgIBAhsCVQgC -AQECagEBAQIIZQEBAQIEAQUACQEC9QEKBAQBkAQCAgQBIAooBgIECAEJBgIDLg0BAgAHAQYBAVIW -AgcBAgECegYDAQECAQcBAUgCAwEBAQACCwI0BQUDFwEAAQYPAAwDAwAFOwcAAT8EUQELAgACAC4C -FwAFAwYICAIHHgSUAwA3BDIIAQ4BFgUBDwAHARECBwECAQVkAaAHAAE9BAAE/gIAB20HAGCA8ABh -c3NlcnRpb24gZmFpbGVkOiBlZGVsdGEgPj0gMGxpYnJhcnkvY29yZS9zcmMvbnVtL2RpeV9mbG9h -dC5ycwAAAEApEAAhAAAATAAAAAkAAABAKRAAIQAAAE4AAAAJAAAAwW/yhiMAAACB76yFW0FtLe4E -AAABH2q/ZO04bu2Xp9r0+T/pA08YAAE+lS4Jmd8D/TgVDy/kdCPs9c/TCNwExNqwzbwZfzOmAyYf -6U4CAAABfC6YW4fTvnKf2diHLxUSxlDea3BuSs8P2JXVbnGyJrBmxq0kNhUdWtNCPA5U/2PAc1XM -F+/5ZfIovFX3x9yA3O1u9M7v3F/3UwUAbGlicmFyeS9jb3JlL3NyYy9udW0vZmx0MmRlYy9zdHJh -dGVneS9kcmFnb24ucnNhc3NlcnRpb24gZmFpbGVkOiBkLm1hbnQgPiAwACAqEAAvAAAAdgAAAAUA -AABhc3NlcnRpb24gZmFpbGVkOiBkLm1pbnVzID4gMAAAACAqEAAvAAAAdwAAAAUAAABhc3NlcnRp -b24gZmFpbGVkOiBkLnBsdXMgPiAwICoQAC8AAAB4AAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGJ1 -Zi5sZW4oKSA+PSBNQVhfU0lHX0RJR0lUUwAAACAqEAAvAAAAewAAAAUAAAAgKhAALwAAAMIAAAAJ -AAAAICoQAC8AAAD7AAAADQAAACAqEAAvAAAAAgEAABIAAABhc3NlcnRpb24gZmFpbGVkOiBkLm1h -bnQuY2hlY2tlZF9zdWIoZC5taW51cykuaXNfc29tZSgpACAqEAAvAAAAegAAAAUAAABhc3NlcnRp -b24gZmFpbGVkOiBkLm1hbnQuY2hlY2tlZF9hZGQoZC5wbHVzKS5pc19zb21lKCkAACAqEAAvAAAA -eQAAAAUAAAAgKhAALwAAAAsBAAAFAAAAICoQAC8AAAAMAQAABQAAACAqEAAvAAAADQEAAAUAAAAg -KhAALwAAAHIBAAAkAAAAICoQAC8AAAB3AQAALwAAACAqEAAvAAAAhAEAABIAAAAgKhAALwAAAGYB -AAANAAAAICoQAC8AAABMAQAAIgAAACAqEAAvAAAADwEAAAUAAAAgKhAALwAAAA4BAAAFAAAA30Ua -PQPPGubB+8z+AAAAAMrGmscX/nCr3PvU/gAAAABP3Ly+/LF3//b73P4AAAAADNZrQe+RVr4R/OT+ -AAAAADz8f5CtH9CNLPzs/gAAAACDmlUxKFxR00b89P4AAAAAtcmmrY+scZ1h/Pz+AAAAAMuL7iN3 -Ipzqe/wE/wAAAABtU3hAkUnMrpb8DP8AAAAAV862XXkSPIKx/BT/AAAAADdW+002lBDCy/wc/wAA -AABPmEg4b+qWkOb8JP8AAAAAxzqCJcuFdNcA/Sz/AAAAAPSXv5fNz4agG/00/wAAAADlrCoXmAo0 -7zX9PP8AAAAAjrI1KvtnOLJQ/UT/AAAAADs/xtLf1MiEa/1M/wAAAAC6zdMaJ0TdxYX9VP8AAAAA -lsklu86fa5Og/Vz/AAAAAISlYn0kbKzbuv1k/wAAAAD22l8NWGaro9X9bP8AAAAAJvHD3pP44vPv -/XT/AAAAALiA/6qorbW1Cv58/wAAAACLSnxsBV9ihyX+hP8AAAAAUzDBNGD/vMk//oz/AAAAAFUm -upGMhU6WWv6U/wAAAAC9filwJHf533T+nP8AAAAAj7jluJ+936aP/qT/AAAAAJR9dIjPX6n4qf6s -/wAAAADPm6iPk3BEucT+tP8AAAAAaxUPv/jwCIrf/rz/AAAAALYxMWVVJbDN+f7E/wAAAACsf3vQ -xuI/mRT/zP8AAAAABjsrKsQQXOQu/9T/AAAAANOSc2mZJCSqSf/c/wAAAAAOygCD8rWH/WP/5P8A -AAAA6xoRkmQI5bx+/+z/AAAAAMyIUG8JzLyMmf/0/wAAAAAsZRniWBe30bP//P8AQe7dwAALBUCc -zv8EAEH83cAAC5kkEKXU6Oj/DAAAAAAAAABirMXreK0DABQAAAAAAIQJlPh4OT+BHgAcAAAAAACz -FQfJe86XwDgAJAAAAAAAcFzqe84yfo9TACwAAAAAAGiA6aukONLVbQA0AAAAAABFIpoXJidPn4gA -PAAAAAAAJ/vE1DGiY+2iAEQAAAAAAKityIw4Zd6wvQBMAAAAAADbZasajgjHg9gAVAAAAAAAmh1x -QvkdXcTyAFwAAAAAAFjnG6YsaU2SDQFkAAAAAADqjXAaZO4B2icBbAAAAAAASnfvmpmjbaJCAXQA -AAAAAIVrfbR7eAnyXAF8AAAAAAB3GN15oeRUtHcBhAAAAAAAwsWbW5KGW4aSAYwAAAAAAD1dlsjF -UzXIrAGUAAAAAACzoJf6XLQqlccBnAAAAAAA41+gmb2fRt7hAaQAAAAAACWMOds0wpul/AGsAAAA -AABcn5ijcprG9hYCtAAAAAAAzr7pVFO/3LcxArwAAAAAAOJBIvIX8/yITALEAAAAAACleFzTm84g -zGYCzAAAAAAA31Mhe/NaFpiBAtQAAAAAADowH5fctaDimwLcAAAAAACWs+NcU9HZqLYC5AAAAAAA -PESnpNl8m/vQAuwAAAAAABBEpKdMTHa76wL0AAAAAAAanEC2746riwYD/AAAAAAALIRXphDvH9Ag -AwQBAAAAACkxkenlpBCbOwMMAQAAAACdDJyh+5sQ51UDFAEAAAAAKfQ7YtkgKKxwAxwBAAAAAIXP -p3peS0SAiwMkAQAAAAAt3awDQOQhv6UDLAEAAAAAj/9EXi+cZ47AAzQBAAAAAEG4jJydFzPU2gM8 -AQAAAACpG+O0ktsZnvUDRAEAAAAA2Xffum6/lusPBEwBAAAAAGxpYnJhcnkvY29yZS9zcmMvbnVt -L2ZsdDJkZWMvc3RyYXRlZ3kvZ3Jpc3UucnMAAIgxEAAuAAAAfQAAABUAAACIMRAALgAAAKkAAAAF -AAAAiDEQAC4AAACqAAAABQAAAIgxEAAuAAAAqwAAAAUAAACIMRAALgAAAK4AAAAFAAAAYXNzZXJ0 -aW9uIGZhaWxlZDogZC5tYW50ICsgZC5wbHVzIDwgKDEgPDwgNjEpAAAAiDEQAC4AAACvAAAABQAA -AIgxEAAuAAAACgEAABEAAACIMRAALgAAAA0BAAAJAAAAiDEQAC4AAABAAQAACQAAAIgxEAAuAAAA -rQAAAAUAAACIMRAALgAAAKwAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogIWJ1Zi5pc19lbXB0eSgp -AAAAiDEQAC4AAADcAQAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGQubWFudCA8ICgxIDw8IDYxKYgx -EAAuAAAA3QEAAAUAAACIMRAALgAAAN4BAAAFAAAAAQAAAAoAAABkAAAA6AMAABAnAACghgEAQEIP -AICWmAAA4fUFAMqaO4gxEAAuAAAAMwIAABEAAACIMRAALgAAADYCAAAJAAAAiDEQAC4AAABsAgAA -CQAAAIgxEAAuAAAA4wIAACYAAACIMRAALgAAAO8CAAAmAAAAiDEQAC4AAADMAgAAJgAAAGxpYnJh -cnkvY29yZS9zcmMvbnVtL2ZsdDJkZWMvbW9kLnJzAJgzEAAjAAAAuwAAAAUAAABhc3NlcnRpb24g -ZmFpbGVkOiBidWZbMF0gPiBiJzAnAJgzEAAjAAAAvAAAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBw -YXJ0cy5sZW4oKSA+PSA0AACYMxAAIwAAAL0AAAAFAAAALjAuLStOYU5pbmYwYXNzZXJ0aW9uIGZh -aWxlZDogYnVmLmxlbigpID49IG1heGxlbgAAAJgzEAAjAAAAfgIAAA0AAAApLi4wMTIzNDU2Nzg5 -YWJjZGVmQm9ycm93TXV0RXJyb3JhbHJlYWR5IGJvcnJvd2VkOiAAlTQQABIAAABjYWxsZWQgYE9w -dGlvbjo6dW53cmFwKClgIG9uIGEgYE5vbmVgIHZhbHVlaW5kZXggb3V0IG9mIGJvdW5kczogdGhl -IGxlbiBpcyAgYnV0IHRoZSBpbmRleCBpcyAAAADbNBAAIAAAAPs0EAASAAAAAAAAAAQAAAAEAAAA -ZQAAAD09IT1tYXRjaGVzYXNzZXJ0aW9uIGBsZWZ0ICByaWdodGAgZmFpbGVkCiAgbGVmdDogCiBy -aWdodDogADs1EAAQAAAASzUQABcAAABiNRAACQAAACByaWdodGAgZmFpbGVkOiAKICBsZWZ0OiAA -AAA7NRAAEAAAAIQ1EAAQAAAAlDUQAAkAAABiNRAACQAAADogAAABAAAAAAAAAMA1EAACAAAAAAAA -AAwAAAAEAAAAZgAAAGcAAABoAAAAICAgICwKKCgKLDB4MDAwMTAyMDMwNDA1MDYwNzA4MDkxMDEx -MTIxMzE0MTUxNjE3MTgxOTIwMjEyMjIzMjQyNTI2MjcyODI5MzAzMTMyMzMzNDM1MzYzNzM4Mzk0 -MDQxNDI0MzQ0NDU0NjQ3NDg0OTUwNTE1MjUzNTQ1NTU2NTc1ODU5NjA2MTYyNjM2NDY1NjY2NzY4 -Njk3MDcxNzI3Mzc0NzU3Njc3Nzg3OTgwODE4MjgzODQ4NTg2ODc4ODg5OTA5MTkyOTM5NDk1OTY5 -Nzk4OTkwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw -MDAwMDAwMDAwMDAwbGlicmFyeS9jb3JlL3NyYy9mbXQvbW9kLnJzZmFsc2V0cnVlADcQABsAAADY -CgAAJgAAAAA3EAAbAAAA4QoAABoAAABsaWJyYXJ5L2NvcmUvc3JjL3N0ci9tb2QucnNbLi4uXWJl -Z2luIDw9IGVuZCAoIDw9ICkgd2hlbiBzbGljaW5nIGBgAGQ3EAAOAAAAcjcQAAQAAAB2NxAAEAAA -AIY3EAABAAAAYnl0ZSBpbmRleCAgaXMgbm90IGEgY2hhciBib3VuZGFyeTsgaXQgaXMgaW5zaWRl -ICAoYnl0ZXMgKSBvZiBgAKg3EAALAAAAszcQACYAAADZNxAACAAAAOE3EAAGAAAAhjcQAAEAAAAg -aXMgb3V0IG9mIGJvdW5kcyBvZiBgAACoNxAACwAAABA4EAAWAAAAhjcQAAEAAABENxAAGwAAAJwB -AAAsAAAAbGlicmFyeS9jb3JlL3NyYy91bmljb2RlL3ByaW50YWJsZS5ycwAAAFA4EAAlAAAAGgAA -ADYAAABQOBAAJQAAAAoAAAArAAAAAAYBAQMBBAIFBwcCCAgJAgoFCwIOBBABEQISBRMcFAEVAhcC -GQ0cBR0IHwEkAWoEawKvA7ECvALPAtEC1AzVCdYC1wLaAeAF4QLnBOgC7iDwBPgC+gT7AQwnOz5O -T4+enp97i5OWorK6hrEGBwk2PT5W89DRBBQYNjdWV3+qrq+9NeASh4mOngQNDhESKTE0OkVGSUpO -T2RlioyNj7bBw8TGy9ZctrcbHAcICgsUFzY5Oqip2NkJN5CRqAcKOz5maY+SEW9fv+7vWmL0/P9T -VJqbLi8nKFWdoKGjpKeorbq8xAYLDBUdOj9FUaanzM2gBxkaIiU+P+fs7//FxgQgIyUmKDM4OkhK -TFBTVVZYWlxeYGNlZmtzeH1/iqSqr7DA0K6vbm/d3pNeInsFAwQtA2YDAS8ugIIdAzEPHAQkCR4F -KwVEBA4qgKoGJAQkBCgINAtOAzQMgTcJFgoIGDtFOQNjCAkwFgUhAxsFAUA4BEsFLwQKBwkHQCAn -BAwJNgM6BRoHBAwHUEk3Mw0zBy4ICgYmAx0IAoDQUhADNywIKhYaJhwUFwlOBCQJRA0ZBwoGSAgn -CXULQj4qBjsFCgZRBgEFEAMFC1kIAh1iHkgICoCmXiJFCwoGDRM6BgoGFBwsBBeAuTxkUwxICQpG -RRtICFMNSQcKgLYiDgoGRgodA0dJNwMOCAoGOQcKgTYZBzsDHVUBDzINg5tmdQuAxIpMYw2EMBAW -Co+bBYJHmrk6hsaCOQcqBFwGJgpGCigFE4GwOoDGW2VLBDkHEUAFCwIOl/gIhNYpCqLngTMPAR0G -DgQIgYyJBGsFDQMJBxCPYID6BoG0TEcJdDyA9gpzCHAVRnoUDBQMVwkZgIeBRwOFQg8VhFAfBgaA -1SsFPiEBcC0DGgQCgUAfEToFAYHQKoDWKwQBgeCA9ylMBAoEAoMRREw9gMI8BgEEVQUbNAKBDiwE -ZAxWCoCuOB0NLAQJBwIOBoCag9gEEQMNA3cEXwYMBAEPDAQ4CAoGKAgsBAI+gVQMHQMKBTgHHAYJ -B4D6hAYAAQMFBQYGAgcGCAcJEQocCxkMGg0QDgwPBBADEhITCRYBFwQYARkDGgcbARwCHxYgAysD -LQsuATAEMQIyAacEqQKqBKsI+gL7Bf0C/gP/Ca14eYuNojBXWIuMkBzdDg9LTPv8Li8/XF1f4oSN -jpGSqbG6u8XGycre5OX/AAQREikxNDc6Oz1JSl2EjpKpsbS6u8bKzs/k5QAEDQ4REikxNDo7RUZJ -Sl5kZYSRm53Jzs8NESk6O0VJV1tcXl9kZY2RqbS6u8XJ3+Tl8A0RRUlkZYCEsry+v9XX8PGDhYuk -pr6/xcfP2ttImL3Nxs7PSU5PV1leX4mOj7G2t7/BxsfXERYXW1z29/7/gG1x3t8OH25vHB1ffX6u -r027vBYXHh9GR05PWFpcXn5/tcXU1dzw8fVyc490dZYmLi+nr7e/x8/X35oAQJeYMI8fzs/S1M7/ -Tk9aWwcIDxAnL+7vbm83PT9CRZCRU2d1yMnQ0djZ5/7/ACBfIoLfBIJECBsEBhGBrA6AqwUfCIEc -AxkIAQQvBDQEBwMBBwYHEQpQDxIHVQcDBBwKCQMIAwcDAgMDAwwEBQMLBgEOFQVOBxsHVwcCBhcM -UARDAy0DAQQRBg8MOgQdJV8gbQRqJYDIBYKwAxoGgv0DWQcWCRgJFAwUDGoGCgYaBlkHKwVGCiwE -DAQBAzELLAQaBgsDgKwGCgYvMYD0CDwDDwM+BTgIKwWC/xEYCC8RLQMhDyEPgIwEgpoWCxWIlAUv -BTsHAg4YCYC+InQMgNYagRAFgOEJ8p4DNwmBXBSAuAiA3RU7AwoGOAhGCAwGdAseA1oEWQmAgxgc -ChYJTASAigarpAwXBDGhBIHaJgcMBQWAphCB9QcBICoGTASAjQSAvgMbAw8NbGlicmFyeS9jb3Jl -L3NyYy91bmljb2RlL3VuaWNvZGVfZGF0YS5ycwAAAEE+EAAoAAAATQAAACgAAABBPhAAKAAAAFkA -AAAWAAAAbGlicmFyeS9jb3JlL3NyYy9udW0vYmlnbnVtLnJzAACMPhAAHgAAAKsBAAABAAAAYXNz -ZXJ0aW9uIGZhaWxlZDogbm9ib3Jyb3dhc3NlcnRpb24gZmFpbGVkOiBkaWdpdHMgPCA0MGFzc2Vy -dGlvbiBmYWlsZWQ6IG90aGVyID4gMGF0dGVtcHQgdG8gZGl2aWRlIGJ5IHplcm8ADj8QABkAAABh -dHRlbXB0IHRvIGNhbGN1bGF0ZSB0aGUgcmVtYWluZGVyIHdpdGggYSBkaXZpc29yIG9mIHplcm8A -AAAwPxAAOQAAAHJhbmdlIHN0YXJ0IGluZGV4ICBvdXQgb2YgcmFuZ2UgZm9yIHNsaWNlIG9mIGxl -bmd0aCB0PxAAEgAAAIY/EAAiAAAAcmFuZ2UgZW5kIGluZGV4ILg/EAAQAAAAhj8QACIAAABzbGlj -ZSBpbmRleCBzdGFydHMgYXQgIGJ1dCBlbmRzIGF0IADYPxAAFgAAAO4/EAANAAAAY29weV9mcm9t -X3NsaWNlOiBzb3VyY2Ugc2xpY2UgbGVuZ3RoICgpIGRvZXMgbm90IG1hdGNoIGRlc3RpbmF0aW9u -IHNsaWNlIGxlbmd0aCAoAAAADEAQACYAAAAyQBAAKwAAAHQ0EAABAAAAAAMAAIMEIACRBWAAXROg -ABIXIB8MIGAf7ywgKyowoCtvpmAsAqjgLB774C0A/iA2nv9gNv0B4TYBCiE3JA3hN6sOYTkvGOE5 -MBzhSvMe4U5ANKFSHmHhU/BqYVRPb+FUnbxhVQDPYVZl0aFWANohVwDgoViu4iFa7OThW9DoYVwg -AO5c8AF/XTA1EAAyNRAANDUQAAIAAAACAAAABwBBsILBAAsBSABwCXByb2R1Y2VycwIIbGFuZ3Vh -Z2UBBFJ1c3QADHByb2Nlc3NlZC1ieQMFcnVzdGMdMS44Ny4wICgxNzA2N2U5YWMgMjAyNS0wNS0w -OSkGd2FscnVzBjAuMjMuMwx3YXNtLWJpbmRnZW4HMC4yLjEwMABrD3RhcmdldF9mZWF0dXJlcwYr -D211dGFibGUtZ2xvYmFscysTbm9udHJhcHBpbmctZnB0b2ludCsLYnVsay1tZW1vcnkrCHNpZ24t -ZXh0Kw9yZWZlcmVuY2UtdHlwZXMrCm11bHRpdmFsdWU= +bGxvYy9zcmMvc3RyaW5nLnJztAYQAHQAAADoAQAAFwAAAEVycm9yAAAAtAYQAHQAAAB9BQAAGwAA +AGludmFsaWQgdmFsdWU6ICwgZXhwZWN0ZWQgAABQBxAADwAAAF8HEAALAAAAbWlzc2luZyBmaWVs +ZCBgYHwHEAAPAAAAiwcQAAEAAABkdXBsaWNhdGUgZmllbGQgYAAAAJwHEAARAAAAiwcQAAEAAAAR +AAAADAAAAAQAAAASAAAAEwAAAAcAAAAvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlu +cy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xp +YnJhcnkvYWxsb2Mvc3JjL3NsaWNlLnJzANgHEABzAAAAvgEAAB0AAAAvaG9tZS9jb3lvdHRlNTA4 +Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9y +dXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3ZlYy9zcGVjX2Zyb21faXRlcl9uZXN0 +ZWQucnMAXAgQAIcAAAATAAAABQAAAGludmFsaWQgdHlwZTogLCBleHBlY3RlZCAAAAD0CBAADgAA +AAIJEAALAAAAL2hvbWUvY295b3R0ZTUwOC8ucnVzdHVwL3Rvb2xjaGFpbnMvc3RhYmxlLXg4Nl82 +NC11bmtub3duLWxpbnV4LWdudS9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5L2FsbG9jL3Ny +Yy9zbGljZS5ycwAgCRAAcwAAAL4BAAAdAAAAAQAAAAAAAAAvaG9tZS9jb3lvdHRlNTA4Ly5jYXJn +by9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvc2VyZGUtd2Fz +bS1iaW5kZ2VuLTAuNi41L3NyYy9saWIucnMAAACsCRAAaQAAADUAAAAOAAAA//////////8oChAA +QcCUwAALgSIBAAAAL2hvbWUvY295b3R0ZTUwOC9jb2RlL2h1Z2dpbmdmYWNlLmpzL3BhY2thZ2Vz +L2h1Yi94ZXQtY29yZS13YXNtLWJ1aWxkL2RlZHVwbGljYXRpb24vc3JjL2NodW5raW5nLnJzAEQK +EABjAAAAHgAAAAkAAABhc3NlcnRpb24gZmFpbGVkOiB0YXJnZXRfY2h1bmtfc2l6ZSA+IDY0RAoQ +AGMAAAAiAAAACQAAAEQKEABjAAAALgAAAB0AAABhc3NlcnRpb24gZmFpbGVkOiBtYXhpbXVtX2No +dW5rID4gbWluaW11bV9jaHVuawBEChAAYwAAADEAAAAJAAAARAoQAGMAAAA7AAAAFwAAAEQKEABj +AAAAZQAAADsAAABEChAAYwAAAIcAAAAyAAAARAoQAGMAAACJAAAAOgAAAEQKEABjAAAAsQAAABUA +AABEChAAYwAAAK4AAABAAAAAL2hvbWUvY295b3R0ZTUwOC8uY2FyZ28vcmVnaXN0cnkvc3JjL2lu +ZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2xhenlfc3RhdGljLTEuNS4wL3NyYy9pbmxp +bmVfbGF6eS5ycwAAoAsQAGoAAAAeAAAAEAAAAC9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29s +Y2hhaW5zL3N0YWJsZS14ODZfNjQtdW5rbm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIvc3JjL3J1 +c3QvbGlicmFyeS9hbGxvYy9zcmMvcmF3X3ZlYy9tb2QucnMAAAAcDBAAeQAAAC4CAAARAAAAT25j +ZSBpbnN0YW5jZSBoYXMgcHJldmlvdXNseSBiZWVuIHBvaXNvbmVkAACoDBAAKgAAAG9uZS10aW1l +IGluaXRpYWxpemF0aW9uIG1heSBub3QgYmUgcGVyZm9ybWVkIHJlY3Vyc2l2ZWx53AwQADgAAAAv +aG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24t +bGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvc3RkL3NyYy9zeW5jL3BvaXNv +bi9vbmNlLnJzHA0QAHwAAACbAAAAMgAAAFn1QOip04iw1iDtOffHUlarcomJaYmyRXfHjrbViQpr +tzF6iz5XjzZL2Tbp3DbGHbbVVFVOTHogy5ojKEazdKQSuaMcPqgGO/e6Ai9sjeeQipoNFfctyeGt +04YQOgWVjiIHOrjx9C5arn+An5SsD6WB1tiA6wNzDg+tcBXcfrCZdjD9VbUvnWhopJ4RglAAACjM +j6gGg7DE/Uo39opnsD42dK2Gq4ef8TbHa76/nxLy7aSYXFdJEUjFe0eVBgEAAMzqnBqAN7ofbZuk +Y9Zv8DtLh+OCl35omePYUKpzBqF5IPQRYp7PrORxkFeHH+cgJZuKGnj909Urc8gR3c1N3gAvOYda +HDGp6v9AvBe2jnTbb78g9o2aV6+xwgkb2uWmhi6hIsMKwy/MZ0L3wf4qXjV7pCHA9MiZLcPPBJRK +S966aX1wHXIYtfcgLPN7WLaGMgwnr4aItgAAeZCK2+TWFaGZ4bKXnH5PSAHjE1e3e8rMYPGwK6aE +Jb/IvF1iE+jnrVqVhw2UcAAAb2KeEwiR5oqiON4v12p3vc/A/MIfAGv7J8R75rh0pMdYXesQFvH2 +utFw521bH8sJR0x9l+YZsrBKraduOLzMAAE/l98KnYTMcPdqAX3vo3P+vb2G09IHyDAXeWyWySp/ +2gTFxmuoN9CdYKoeZnzx84fmqk2wJqasB1tKTzeZWnXerixb5n6DkIUHVv2Trehu2O1TEOHZAADX +2xzSsjsGnrLSASrxd6sHRBtk5lUCVezGFJxEqJT7ePX1wMYbDlHH48rkNgsyAAAtGossJjN8gkRB +6kgLX2cU6+yNSabTeyZeA/WC+W+R8Yj7NPR/GyKG2ElvOOfOvp1Kjw/IyvhY6thk/JKGGY0ANpq/ +uk9wOG1MvufRB8sy4JAIRa32IY0ipYklwL+xXGNxzqKcc6EgRlj75arj3+en6w08K5PKEAx77a+E +6P4nJx+r4vltHN+iI/V0B6zRzU1O4jOt/3AAABZ4l8V76KyiSWAotFonkphZifHdgRGGwhk+SEKg +cpm7eDBRZjfNcO9kmPyrEwUAAINAyVgYtljA3uAll4VQ6AmUfT74O/uXkc5LthJtYh5+0Vd7f1BU +DFIWJOJ0cXnhvodV6SIyrNlvPr/fmnyVIwAVvksjfn0coLuMo7hYx6KrMCs+7M6gHw2RuWB+i6W2 +CzVmop9b3TNDo8EBQH07/cInEXNUJIBB+8sYDaWFYaVlT7WEh70CevZjUOZn3RFvaasUqPwiIAAA +Uti5LZG+1oxXiq7ptolRaSgM2gq1U5TuXoR4Gqle/Nhnp0oaGb+Gq+UVZMi1xgAALqIIjhcQcyYl +yosHGxAt7fuoJrKE7UE7BtwoDxIi5hMmbXD76/UVo866ATNOwxaIrv1xu5xbOelIFnIuIOksABzJ +sysd24NCpaax0hpGfddrhutu5Bfs4nzE+zlAvuC4BJ0p1cRgod40NozSyIbsfpmjmJ8SrRkh74Oi +YWv0zKYXxlj23s5SLIPdrGkRh7Qt6cue89bwAACJlC+NydjVPYT1ASuichiK8jx7DsSkgvKWoRvL +LOwggBPjWZ7gtpNm64N8zBnOAAA7nEf2NVfLIFta11k3vy52dTlpPYL+eyDV2ZwzEsF91wN9YoRC +g6eb6VFf6RPFfSEWeF78KRp7si1muzGYzdUATHN1bYCb43EjGvsG8CpXfoUf6WovT3Oi8t0sArXG +gr/eoGEHxuo7XJhpQUe7k8jNAX4YXGGFEG1dfCesMK74d5EsKhKBa3yRZ2nRrZm2dVubBprnas8A +AAQR3mD6CsTzw2eRpXoSYyBNidFpIuYdYiZHK+YdrIjRPGdLFeI2cBAdOlUoX7gAAD1vIxhMTu/y +Ava5EWbe1tkckUf7VXn8ob2NKS8D/YXr4fq+sy9QJ74eZs3EUUID4zYYB1TTZBNEPpjydWyzggDw +ZvoWA5FFsffKR5icBhwCIVJLWsffECm1qFccPjVbc2zZjuksMUTOZfq9BkUulLwblFcSp4ZQ8K3O +UdMVssP+AkIU4FUQrgBU5EJvhEBL9ci8vMjZfwAA/pveF/Oevb8SToXyLzAEqNTY5aVXSc45hLo3 +VqTiuf+LgaCeHa25VYoXGfPLigAAOPv70Mi/4kjotUjoQZjji4uglgYWEicOKiRES+iWENU64ZJn +F7oBEZ1oMUUPdy7CbMW7cvLviRbsUFZ/GSqpAE54ob2QWXa8rrj8kuNBFMag5DHtLDrhB02dTiOE +6cuSxYp9u3L1T4/QO5YLwHCWCwHrAxpYWpViVAIA6uWDX2SZ8ojNFuX8Qc+YetpIl9q7+kVI/rKq +AABVZfWbBht2GVattkODXo+L2SFIFP0cXT6PzbCiLB5c7H+1+6f+4Pf6G5YSutMAAACOsQGEF5A/ +2utfOuNtkP9w53BpwKfVJwXpE3xgc+fYIqw7PGTfcKvJ4xK+itzGpO2K5zMAQR/v7MtyrHSywiQA +tACpT5UNdAYEYz0ymyl6HdXqy5iyfMOzm3N4YcfjhsmK9UZLNuqrn1bMha/FFKJthI+jt9g+pBfr +25odUezMbvtaMxMJs8r50u4V9MVgXkq0cjZQZ2kAAIe7VBQSHaWdFsi7uRMeMoSN3S+rtm89+40K +Fo7tXjBg6GyU6RRLv8vDEBs4Y08AABBOzG+Bt9UHVYFqanI2peXdf6BHNLKvV5TTyav3RvMYPdMa +1lXGbWP28/c5SauLzHsY3cEGqcdjL2hvbWUvY295b3R0ZTUwOC8ucnVzdHVwL3Rvb2xjaGFpbnMv +c3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJy +YXJ5L2FsbG9jL3NyYy9zbGljZS5ycwCoFRAAcwAAAL4BAAAdAAAAT25jZSBpbnN0YW5jZSBoYXMg +cHJldmlvdXNseSBiZWVuIHBvaXNvbmVkAAAsFhAAKgAAAG9uZS10aW1lIGluaXRpYWxpemF0aW9u +IG1heSBub3QgYmUgcGVyZm9ybWVkIHJlY3Vyc2l2ZWx5YBYQADgAAAAvaG9tZS9jb3lvdHRlNTA4 +Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9y +dXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvc3RkL3NyYy9zeW5jL3BvaXNvbi9vbmNlLnJzoBYQAHwA +AACbAAAAMgAAAC9ob21lL2NveW90dGU1MDgvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0 +ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9sYXp5X3N0YXRpYy0xLjUuMC9zcmMvaW5saW5lX2xhenku +cnMAACwXEABqAAAAHgAAABAAAAAvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9z +dGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJh +cnkvY29yZS9zcmMvaXRlci90cmFpdHMvaXRlcmF0b3IucnMAAACoFxAAgQAAAMEHAAAJAAAAfxhX +1s5W7WYSf/kT56XD86TNJtW120nmQSSYfyj7lMMvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9v +bGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9y +dXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3Jhd192ZWMvbW9kLnJzAAAAXBgQAHkAAAAuAgAAEQAAAAAA +AAAEAAAABAAAABYAAAAvaG9tZS9jb3lvdHRlNTA4Ly5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXgu +Y3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvanMtc3lzLTAuMy43Ny9zcmMvbGliLnJzAAD4GBAA +XgAAAPsYAAABAAAAL2hvbWUvY295b3R0ZTUwOC8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNy +YXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3dhc20tYmluZGdlbi0wLjIuMTAwL3NyYy9jb252ZXJ0 +L3NsaWNlcy5yc2gZEABwAAAAJAEAAA4AAABjbG9zdXJlIGludm9rZWQgcmVjdXJzaXZlbHkgb3Ig +YWZ0ZXIgYmVpbmcgZHJvcHBlZExheW91dEVycm9yL2hvbWUvY295b3R0ZTUwOC8ucnVzdHVwL3Rv +b2xjaGFpbnMvc3RhYmxlLXg4Nl82NC11bmtub3duLWxpbnV4LWdudS9saWIvcnVzdGxpYi9zcmMv +cnVzdC9saWJyYXJ5L2FsbG9jL3NyYy9zbGljZS5ycyUaEABzAAAAvgEAAB0AAAAjAAAAJAAAACUA +AAAmAAAAJwAAAC9ob21lL2NveW90dGU1MDgvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0 +ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9ieXRlcy0xLjEwLjEvc3JjL2J5dGVzLnJzACgAAAApAAAA +KgAAACsAAAAsAAAALQAAAC4AAAAvAAAAKwAAADAAQcy2wAALpRQBAAAAMQAAAGNhbGxlZCBgUmVz +dWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAvBoQAF8AAABIBQAAMgAAALwaEABfAAAA +VgUAAEkAAAAyAAAAMwAAADQAAAA1AAAANgAAAC9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29s +Y2hhaW5zL3N0YWJsZS14ODZfNjQtdW5rbm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIvc3JjL3J1 +c3QvbGlicmFyeS9hbGxvYy9zcmMvc2xpY2UucnMAtBsQAHMAAAC+AQAAHQAAAC9ob21lL2NveW90 +dGU1MDgvY29kZS9odWdnaW5nZmFjZS5qcy9wYWNrYWdlcy9odWIveGV0LWNvcmUtd2FzbS1idWls +ZC9tZXJrbGVoYXNoL3NyYy9kYXRhX2hhc2gucnMAAAA4HBAAYQAAAHoAAAAJAAAASW52YWxpZCBo +ZXggaW5wdXQgZm9yIERhdGFIYXNoAAABAAAAAAAAAAEAAAAAAAAAAQAAAAAAAAABAAAAAAAAADgc +EABhAAAAsgAAACoAAAA4HBAAYQAAALMAAAAqAAAAOBwQAGEAAAC0AAAAKgAAAGaX9XdblVDeMTXL +rKWXGByd5CEQm+srWLTQsEuTrfIpAX7Fx6VHKZb9lGZmtIoC5l3dU283x23S+GNS5kpTcT8BAAAA +AAAAAG1pZCA+IGxlbgAAAGQdEAAJAAAAL2hvbWUvY295b3R0ZTUwOC8uY2FyZ28vcmVnaXN0cnkv +c3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL2JsYWtlMy0xLjguMi9zcmMvbGli +LnJzAAAAeB0QAF0AAAALAgAAEQAAAHgdEABdAAAAvgIAAAoAAAB4HRAAXQAAAOwCAAAoAAAAeB0Q +AF0AAADsAgAANAAAAHgdEABdAAAA7AIAAAwAAAB4HRAAXQAAANwCAAAXAAAAeB0QAF0AAAAYAwAA +HwAAAHgdEABdAAAANQMAAAwAAAB4HRAAXQAAADwDAAASAAAAeB0QAF0AAABgAwAAIQAAAHgdEABd +AAAAYgMAABEAAAB4HRAAXQAAAGIDAABBAAAAaW5zdWZmaWNpZW50IGNhcGFjaXR5AAAAmB4QABUA +AABDYXBhY2l0eUVycm9yOiAAuB4QAA8AAABjYWxsZWQgYFJlc3VsdDo6dW53cmFwKClgIG9uIGFu +IGBFcnJgIHZhbHVlAAAAAAAEAAAABAAAADoAAAAAAAAACAAAAAQAAABCAAAAQwAAAEQAAABhIHN0 +cmluZ2J5dGUgYXJyYXlib29sZWFuIGBgNh8QAAkAAAA/HxAAAQAAAGludGVnZXIgYAAAAFAfEAAJ +AAAAPx8QAAEAAABmbG9hdGluZyBwb2ludCBgbB8QABAAAAA/HxAAAQAAAGNoYXJhY3RlciBgAIwf +EAALAAAAPx8QAAEAAABzdHJpbmcgAKgfEAAHAAAAdW5pdCB2YWx1ZU9wdGlvbiB2YWx1ZW5ld3R5 +cGUgc3RydWN0c2VxdWVuY2VtYXBlbnVtdW5pdCB2YXJpYW50bmV3dHlwZSB2YXJpYW50dHVwbGUg +dmFyaWFudHN0cnVjdCB2YXJpYW50AAAAAQAAAAAAAAAuMHUzMkxhenkgaW5zdGFuY2UgaGFzIHBy +ZXZpb3VzbHkgYmVlbiBwb2lzb25lZAAxIBAAKgAAAC9ob21lL2NveW90dGU1MDgvLmNhcmdvL3Jl +Z2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9vbmNlX2NlbGwtMS4y +MS4zL3NyYy9saWIucnMAAABkIBAAYQAAAAgDAAAZAAAAcmVlbnRyYW50IGluaXQAANggEAAOAAAA +ZCAQAGEAAAB6AgAADQAAAC9ob21lL2NveW90dGU1MDgvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRl +eC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi93YXNtLWJpbmRnZW4tMC4yLjEwMC9zcmMvY29u +dmVydC9pbXBscy5ycwAAIRAAbwAAAGECAAAWAAAAACEQAG8AAABxAgAADAAAAAAhEABvAAAAbQIA +ABAAAABhcnJheSBjb250YWlucyBhIHZhbHVlIG9mIHRoZSB3cm9uZyB0eXBlbnVsbCBwb2ludGVy +IHBhc3NlZCB0byBydXN0cmVjdXJzaXZlIHVzZSBvZiBhbiBvYmplY3QgZGV0ZWN0ZWQgd2hpY2gg +d291bGQgbGVhZCB0byB1bnNhZmUgYWxpYXNpbmcgaW4gcnVzdEpzVmFsdWUoKQAyIhAACAAAADoi +EAABAAAAL3J1c3RjLzE3MDY3ZTlhYzZkN2VjYjcwZTUwZjkyYzE5NDRlNTQ1MTg4ZDIzNTkvbGli +cmFyeS9hbGxvYy9zcmMvc3RyaW5nLnJzAEwiEABLAAAAfQUAABsAAAAvcnVzdGMvMTcwNjdlOWFj +NmQ3ZWNiNzBlNTBmOTJjMTk0NGU1NDUxODhkMjM1OS9saWJyYXJ5L2FsbG9jL3NyYy9yYXdfdmVj +L21vZC5yc6giEABQAAAALgIAABEAAABJAAAADAAAAAQAAABKAAAASwAAAEwAAAAvcnVzdC9kZXBz +L2RsbWFsbG9jLTAuMi43L3NyYy9kbG1hbGxvYy5yc2Fzc2VydGlvbiBmYWlsZWQ6IHBzaXplID49 +IHNpemUgKyBtaW5fb3ZlcmhlYWQAICMQACkAAACoBAAACQAAAGFzc2VydGlvbiBmYWlsZWQ6IHBz +aXplIDw9IHNpemUgKyBtYXhfb3ZlcmhlYWQAACAjEAApAAAArgQAAA0AAABtZW1vcnkgYWxsb2Nh +dGlvbiBvZiAgYnl0ZXMgZmFpbGVkAADIIxAAFQAAAN0jEAANAAAAbGlicmFyeS9zdGQvc3JjL2Fs +bG9jLnJz/CMQABgAAABkAQAACQAAAEkAAAAMAAAABAAAAE0AAAAAAAAACAAAAAQAAABOAAAAAAAA +AAgAAAAEAAAATwAAAFAAAABRAAAAUgAAAFMAAAAQAAAABAAAAFQAAABVAAAAVgAAAFcAAABIYXNo +IHRhYmxlIGNhcGFjaXR5IG92ZXJmbG93fCQQABwAAAAvcnVzdC9kZXBzL2hhc2hicm93bi0wLjE1 +LjIvc3JjL3Jhdy9tb2QucnMAAKAkEAAqAAAAIwAAACgAAABFcnJvcgAAAFgAAAAMAAAABAAAAFkA +AABaAAAAWwAAAGNhcGFjaXR5IG92ZXJmbG93AAAA/CQQABEAAABsaWJyYXJ5L2FsbG9jL3NyYy9y +YXdfdmVjL21vZC5ycxglEAAgAAAALgIAABEAAABsaWJyYXJ5L2FsbG9jL3NyYy9zdHJpbmcucnMA +SCUQABsAAADoAQAAFwBB/MrAAAvIEgEAAABcAAAAYSBmb3JtYXR0aW5nIHRyYWl0IGltcGxlbWVu +dGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHdoZW4gdGhlIHVuZGVybHlpbmcgc3RyZWFtIGRpZCBu +b3RsaWJyYXJ5L2FsbG9jL3NyYy9mbXQucnMAANolEAAYAAAAigIAAA4AAABIJRAAGwAAAH0FAAAb +AAAAAHAABwAtAQEBAgECAQFICzAVEAFlBwIGAgIBBCMBHhtbCzoJCQEYBAEJAQMBBSsDOwkqGAEg +NwEBAQQIBAEDBwoCHQE6AQEBAgQIAQkBCgIaAQICOQEEAgQCAgMDAR4CAwELAjkBBAUBAgQBFAIW +BgEBOgEBAgEECAEHAwoCHgE7AQEBDAEJASgBAwE3AQEDBQMBBAcCCwIdAToBAgIBAQMDAQQHAgsC +HAI5AgEBAgQIAQkBCgIdAUgBBAECAwEBCAFRAQIHDAhiAQIJCwdJAhsBAQEBATcOAQUBAgULASQJ +AWYEAQYBAgICGQIEAxAEDQECAgYBDwEAAwAEHAMdAh4CQAIBBwgBAgsJAS0DAQF1AiIBdgMEAgkB +BgPbAgIBOgEBBwEBAQECCAYKAgEwHzEEMAoEAyYJDAIgBAIGOAEBAgMBAQU4CAICmAMBDQEHBAEG +AQMCxkAAAcMhAAONAWAgAAZpAgAEAQogAlACAAEDAQQBGQIFAZcCGhINASYIGQsBASwDMAECBAIC +AgEkAUMGAgICAgwBCAEvATMBAQMCAgUCAQEqAggB7gECAQQBAAEAEBAQAAIAAeIBlQUAAwECBQQo +AwQBpQIABEEFAAJPBEYLMQR7ATYPKQECAgoDMQQCAgcBPQMkBQEIPgEMAjQJAQEIBAIBXwMCBAYB +AgGdAQMIFQI5AgEBAQEMAQkBDgcDBUMBAgYBAQIBAQMEAwEBDgJVCAIDAQEXAVEBAgYBAQIBAQIB +AusBAgQGAgECGwJVCAIBAQJqAQEBAghlAQEBAgQBBQAJAQL1AQoEBAGQBAICBAEgCigGAgQIAQkG +AgMuDQECAAcBBgEBUhYCBwECAQJ6BgMBAQIBBwEBSAIDAQEBAAILAjQFBQMXAQABBg8ADAMDAAU7 +BwABPwRRAQsCAAIALgIXAAUDBggIAgceBJQDADcEMggBDgEWBQEPAAcBEQIHAQIBBWQBoAcAAT0E +AAT+AgAHbQcAYIDwAGFzc2VydGlvbiBmYWlsZWQ6IGVkZWx0YSA+PSAwbGlicmFyeS9jb3JlL3Ny +Yy9udW0vZGl5X2Zsb2F0LnJzAAAAICkQACEAAABMAAAACQAAACApEAAhAAAATgAAAAkAAADBb/KG +IwAAAIHvrIVbQW0t7gQAAAEfar9k7Thu7Zen2vT5P+kDTxgAAT6VLgmZ3wP9OBUPL+R0I+z1z9MI +3ATE2rDNvBl/M6YDJh/pTgIAAAF8Lphbh9O+cp/Z2IcvFRLGUN5rcG5Kzw/YldVucbImsGbGrSQ2 +FR1a00I8DlT/Y8BzVcwX7/ll8ii8VffH3IDc7W70zu/cX/dTBQBsaWJyYXJ5L2NvcmUvc3JjL251 +bS9mbHQyZGVjL3N0cmF0ZWd5L2RyYWdvbi5yc2Fzc2VydGlvbiBmYWlsZWQ6IGQubWFudCA+IDAA +ACoQAC8AAAB2AAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGQubWludXMgPiAwAAAAACoQAC8AAAB3 +AAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGQucGx1cyA+IDAAKhAALwAAAHgAAAAFAAAAYXNzZXJ0 +aW9uIGZhaWxlZDogYnVmLmxlbigpID49IE1BWF9TSUdfRElHSVRTAAAAACoQAC8AAAB7AAAABQAA +AAAqEAAvAAAAwgAAAAkAAAAAKhAALwAAAPsAAAANAAAAACoQAC8AAAACAQAAEgAAAGFzc2VydGlv +biBmYWlsZWQ6IGQubWFudC5jaGVja2VkX3N1YihkLm1pbnVzKS5pc19zb21lKCkAACoQAC8AAAB6 +AAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGQubWFudC5jaGVja2VkX2FkZChkLnBsdXMpLmlzX3Nv +bWUoKQAAACoQAC8AAAB5AAAABQAAAAAqEAAvAAAACwEAAAUAAAAAKhAALwAAAAwBAAAFAAAAACoQ +AC8AAAANAQAABQAAAAAqEAAvAAAAcgEAACQAAAAAKhAALwAAAHcBAAAvAAAAACoQAC8AAACEAQAA +EgAAAAAqEAAvAAAAZgEAAA0AAAAAKhAALwAAAEwBAAAiAAAAACoQAC8AAAAPAQAABQAAAAAqEAAv +AAAADgEAAAUAAADfRRo9A88a5sH7zP4AAAAAysaaxxf+cKvc+9T+AAAAAE/cvL78sXf/9vvc/gAA +AAAM1mtB75FWvhH85P4AAAAAPPx/kK0f0I0s/Oz+AAAAAIOaVTEoXFHTRvz0/gAAAAC1yaatj6xx +nWH8/P4AAAAAy4vuI3cinOp7/AT/AAAAAG1TeECRScyulvwM/wAAAABXzrZdeRI8grH8FP8AAAAA +N1b7TTaUEMLL/Bz/AAAAAE+YSDhv6paQ5vwk/wAAAADHOoIly4V01wD9LP8AAAAA9Je/l83PhqAb +/TT/AAAAAOWsKheYCjTvNf08/wAAAACOsjUq+2c4slD9RP8AAAAAOz/G0t/UyIRr/Uz/AAAAALrN +0xonRN3Fhf1U/wAAAACWySW7zp9rk6D9XP8AAAAAhKVifSRsrNu6/WT/AAAAAPbaXw1YZquj1f1s +/wAAAAAm8cPek/ji8+/9dP8AAAAAuID/qqittbUK/nz/AAAAAItKfGwFX2KHJf6E/wAAAABTMME0 +YP+8yT/+jP8AAAAAVSa6kYyFTpZa/pT/AAAAAL1+KXAkd/nfdP6c/wAAAACPuOW4n73fpo/+pP8A +AAAAlH10iM9fqfip/qz/AAAAAM+bqI+TcES5xP60/wAAAABrFQ+/+PAIit/+vP8AAAAAtjExZVUl +sM35/sT/AAAAAKx/e9DG4j+ZFP/M/wAAAAAGOysqxBBc5C7/1P8AAAAA05JzaZkkJKpJ/9z/AAAA +AA7KAIPytYf9Y//k/wAAAADrGhGSZAjlvH7/7P8AAAAAzIhQbwnMvIyZ//T/AAAAACxlGeJYF7fR +s//8/wBBzt3AAAsFQJzO/wQAQdzdwAAL+SMQpdTo6P8MAAAAAAAAAGKsxet4rQMAFAAAAAAAhAmU ++Hg5P4EeABwAAAAAALMVB8l7zpfAOAAkAAAAAABwXOp7zjJ+j1MALAAAAAAAaIDpq6Q40tVtADQA +AAAAAEUimhcmJ0+fiAA8AAAAAAAn+8TUMaJj7aIARAAAAAAAqK3IjDhl3rC9AEwAAAAAANtlqxqO +CMeD2ABUAAAAAACaHXFC+R1dxPIAXAAAAAAAWOcbpixpTZINAWQAAAAAAOqNcBpk7gHaJwFsAAAA +AABKd++amaNtokIBdAAAAAAAhWt9tHt4CfJcAXwAAAAAAHcY3Xmh5FS0dwGEAAAAAADCxZtbkoZb +hpIBjAAAAAAAPV2WyMVTNcisAZQAAAAAALOgl/pctCqVxwGcAAAAAADjX6CZvZ9G3uEBpAAAAAAA +JYw52zTCm6X8AawAAAAAAFyfmKNymsb2FgK0AAAAAADOvulUU7/ctzECvAAAAAAA4kEi8hfz/IhM +AsQAAAAAAKV4XNObziDMZgLMAAAAAADfUyF781oWmIEC1AAAAAAAOjAfl9y1oOKbAtwAAAAAAJaz +41xT0dmotgLkAAAAAAA8RKek2Xyb+9AC7AAAAAAAEESkp0xMdrvrAvQAAAAAABqcQLbvjquLBgP8 +AAAAAAAshFemEO8f0CADBAEAAAAAKTGR6eWkEJs7AwwBAAAAAJ0MnKH7mxDnVQMUAQAAAAAp9Dti +2SAorHADHAEAAAAAhc+nel5LRICLAyQBAAAAAC3drANA5CG/pQMsAQAAAACP/0ReL5xnjsADNAEA +AAAAQbiMnJ0XM9TaAzwBAAAAAKkb47SS2xme9QNEAQAAAADZd9+6br+W6w8ETAEAAAAAbGlicmFy +eS9jb3JlL3NyYy9udW0vZmx0MmRlYy9zdHJhdGVneS9ncmlzdS5ycwAAaDEQAC4AAAB9AAAAFQAA +AGgxEAAuAAAAqQAAAAUAAABoMRAALgAAAKoAAAAFAAAAaDEQAC4AAACrAAAABQAAAGgxEAAuAAAA +rgAAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBkLm1hbnQgKyBkLnBsdXMgPCAoMSA8PCA2MSkAAABo +MRAALgAAAK8AAAAFAAAAaDEQAC4AAAAKAQAAEQAAAGgxEAAuAAAADQEAAAkAAABoMRAALgAAAEAB +AAAJAAAAaDEQAC4AAACtAAAABQAAAGgxEAAuAAAArAAAAAUAAABhc3NlcnRpb24gZmFpbGVkOiAh +YnVmLmlzX2VtcHR5KCkAAABoMRAALgAAANwBAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogZC5tYW50 +IDwgKDEgPDwgNjEpaDEQAC4AAADdAQAABQAAAGgxEAAuAAAA3gEAAAUAAAABAAAACgAAAGQAAADo +AwAAECcAAKCGAQBAQg8AgJaYAADh9QUAypo7aDEQAC4AAAAzAgAAEQAAAGgxEAAuAAAANgIAAAkA +AABoMRAALgAAAGwCAAAJAAAAaDEQAC4AAADjAgAAJgAAAGgxEAAuAAAA7wIAACYAAABoMRAALgAA +AMwCAAAmAAAAbGlicmFyeS9jb3JlL3NyYy9udW0vZmx0MmRlYy9tb2QucnMAeDMQACMAAAC7AAAA +BQAAAGFzc2VydGlvbiBmYWlsZWQ6IGJ1ZlswXSA+IGInMCcAeDMQACMAAAC8AAAABQAAAGFzc2Vy +dGlvbiBmYWlsZWQ6IHBhcnRzLmxlbigpID49IDQAAHgzEAAjAAAAvQAAAAUAAAAuMC4tK05hTmlu +ZjBhc3NlcnRpb24gZmFpbGVkOiBidWYubGVuKCkgPj0gbWF4bGVuAAAAeDMQACMAAAB+AgAADQAA +ACkuLjAxMjM0NTY3ODlhYmNkZWZCb3Jyb3dNdXRFcnJvcmFscmVhZHkgYm9ycm93ZWQ6IAB1NBAA +EgAAAGNhbGxlZCBgT3B0aW9uOjp1bndyYXAoKWAgb24gYSBgTm9uZWAgdmFsdWVpbmRleCBvdXQg +b2YgYm91bmRzOiB0aGUgbGVuIGlzICBidXQgdGhlIGluZGV4IGlzIAAAALs0EAAgAAAA2zQQABIA +AAAAAAAABAAAAAQAAABjAAAAPT0hPW1hdGNoZXNhc3NlcnRpb24gYGxlZnQgIHJpZ2h0YCBmYWls +ZWQKICBsZWZ0OiAKIHJpZ2h0OiAAGzUQABAAAAArNRAAFwAAAEI1EAAJAAAAIHJpZ2h0YCBmYWls +ZWQ6IAogIGxlZnQ6IAAAABs1EAAQAAAAZDUQABAAAAB0NRAACQAAAEI1EAAJAAAAOiAAAAEAAAAA +AAAAoDUQAAIAAAAweDAwMDEwMjAzMDQwNTA2MDcwODA5MTAxMTEyMTMxNDE1MTYxNzE4MTkyMDIx +MjIyMzI0MjUyNjI3MjgyOTMwMzEzMjMzMzQzNTM2MzczODM5NDA0MTQyNDM0NDQ1NDY0NzQ4NDk1 +MDUxNTI1MzU0NTU1NjU3NTg1OTYwNjE2MjYzNjQ2NTY2Njc2ODY5NzA3MTcyNzM3NDc1NzY3Nzc4 +Nzk4MDgxODI4Mzg0ODU4Njg3ODg4OTkwOTE5MjkzOTQ5NTk2OTc5ODk5MDAwMDAwMDAwMDAwMDAw +MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMGxpYnJhcnkv +Y29yZS9zcmMvZm10L21vZC5yc2ZhbHNldHJ1ZQAAvjYQABsAAADYCgAAJgAAAL42EAAbAAAA4QoA +ABoAAABsaWJyYXJ5L2NvcmUvc3JjL3N0ci9tb2QucnNbLi4uXWJlZ2luIDw9IGVuZCAoIDw9ICkg +d2hlbiBzbGljaW5nIGBgACQ3EAAOAAAAMjcQAAQAAAA2NxAAEAAAAEY3EAABAAAAYnl0ZSBpbmRl +eCAgaXMgbm90IGEgY2hhciBib3VuZGFyeTsgaXQgaXMgaW5zaWRlICAoYnl0ZXMgKSBvZiBgAGg3 +EAALAAAAczcQACYAAACZNxAACAAAAKE3EAAGAAAARjcQAAEAAAAgaXMgb3V0IG9mIGJvdW5kcyBv +ZiBgAABoNxAACwAAANA3EAAWAAAARjcQAAEAAAAENxAAGwAAAJwBAAAsAAAAbGlicmFyeS9jb3Jl +L3NyYy91bmljb2RlL3ByaW50YWJsZS5ycwAAABA4EAAlAAAAGgAAADYAAAAQOBAAJQAAAAoAAAAr +AAAAAAYBAQMBBAIFBwcCCAgJAgoFCwIOBBABEQISBRMcFAEVAhcCGQ0cBR0IHwEkAWoEawKvA7EC +vALPAtEC1AzVCdYC1wLaAeAF4QLnBOgC7iDwBPgC+gT7AQwnOz5OT4+enp97i5OWorK6hrEGBwk2 +PT5W89DRBBQYNjdWV3+qrq+9NeASh4mOngQNDhESKTE0OkVGSUpOT2RlioyNj7bBw8TGy9Zctrcb +HAcICgsUFzY5Oqip2NkJN5CRqAcKOz5maY+SEW9fv+7vWmL0/P9TVJqbLi8nKFWdoKGjpKeorbq8 +xAYLDBUdOj9FUaanzM2gBxkaIiU+P+fs7//FxgQgIyUmKDM4OkhKTFBTVVZYWlxeYGNlZmtzeH1/ +iqSqr7DA0K6vbm/d3pNeInsFAwQtA2YDAS8ugIIdAzEPHAQkCR4FKwVEBA4qgKoGJAQkBCgINAtO +AzQMgTcJFgoIGDtFOQNjCAkwFgUhAxsFAUA4BEsFLwQKBwkHQCAnBAwJNgM6BRoHBAwHUEk3Mw0z +By4ICgYmAx0IAoDQUhADNywIKhYaJhwUFwlOBCQJRA0ZBwoGSAgnCXULQj4qBjsFCgZRBgEFEAMF +C1kIAh1iHkgICoCmXiJFCwoGDRM6BgoGFBwsBBeAuTxkUwxICQpGRRtICFMNSQcKgLYiDgoGRgod +A0dJNwMOCAoGOQcKgTYZBzsDHVUBDzINg5tmdQuAxIpMYw2EMBAWCo+bBYJHmrk6hsaCOQcqBFwG +JgpGCigFE4GwOoDGW2VLBDkHEUAFCwIOl/gIhNYpCqLngTMPAR0GDgQIgYyJBGsFDQMJBxCPYID6 +BoG0TEcJdDyA9gpzCHAVRnoUDBQMVwkZgIeBRwOFQg8VhFAfBgaA1SsFPiEBcC0DGgQCgUAfEToF +AYHQKoDWKwQBgeCA9ylMBAoEAoMRREw9gMI8BgEEVQUbNAKBDiwEZAxWCoCuOB0NLAQJBwIOBoCa +g9gEEQMNA3cEXwYMBAEPDAQ4CAoGKAgsBAI+gVQMHQMKBTgHHAYJB4D6hAYAAQMFBQYGAgcGCAcJ +EQocCxkMGg0QDgwPBBADEhITCRYBFwQYARkDGgcbARwCHxYgAysDLQsuATAEMQIyAacEqQKqBKsI ++gL7Bf0C/gP/Ca14eYuNojBXWIuMkBzdDg9LTPv8Li8/XF1f4oSNjpGSqbG6u8XGycre5OX/AAQR +EikxNDc6Oz1JSl2EjpKpsbS6u8bKzs/k5QAEDQ4REikxNDo7RUZJSl5kZYSRm53Jzs8NESk6O0VJ +V1tcXl9kZY2RqbS6u8XJ3+Tl8A0RRUlkZYCEsry+v9XX8PGDhYukpr6/xcfP2ttImL3Nxs7PSU5P +V1leX4mOj7G2t7/BxsfXERYXW1z29/7/gG1x3t8OH25vHB1ffX6ur027vBYXHh9GR05PWFpcXn5/ +tcXU1dzw8fVyc490dZYmLi+nr7e/x8/X35oAQJeYMI8fzs/S1M7/Tk9aWwcIDxAnL+7vbm83PT9C +RZCRU2d1yMnQ0djZ5/7/ACBfIoLfBIJECBsEBhGBrA6AqwUfCIEcAxkIAQQvBDQEBwMBBwYHEQpQ +DxIHVQcDBBwKCQMIAwcDAgMDAwwEBQMLBgEOFQVOBxsHVwcCBhcMUARDAy0DAQQRBg8MOgQdJV8g +bQRqJYDIBYKwAxoGgv0DWQcWCRgJFAwUDGoGCgYaBlkHKwVGCiwEDAQBAzELLAQaBgsDgKwGCgYv +MYD0CDwDDwM+BTgIKwWC/xEYCC8RLQMhDyEPgIwEgpoWCxWIlAUvBTsHAg4YCYC+InQMgNYagRAF +gOEJ8p4DNwmBXBSAuAiA3RU7AwoGOAhGCAwGdAseA1oEWQmAgxgcChYJTASAigarpAwXBDGhBIHa +JgcMBQWAphCB9QcBICoGTASAjQSAvgMbAw8NbGlicmFyeS9jb3JlL3NyYy91bmljb2RlL3VuaWNv +ZGVfZGF0YS5ycwAAAAE+EAAoAAAATQAAACgAAAABPhAAKAAAAFkAAAAWAAAAbGlicmFyeS9jb3Jl +L3NyYy9udW0vYmlnbnVtLnJzAABMPhAAHgAAAKsBAAABAAAAYXNzZXJ0aW9uIGZhaWxlZDogbm9i +b3Jyb3dhc3NlcnRpb24gZmFpbGVkOiBkaWdpdHMgPCA0MGFzc2VydGlvbiBmYWlsZWQ6IG90aGVy +ID4gMGF0dGVtcHQgdG8gZGl2aWRlIGJ5IHplcm8Azj4QABkAAABhdHRlbXB0IHRvIGNhbGN1bGF0 +ZSB0aGUgcmVtYWluZGVyIHdpdGggYSBkaXZpc29yIG9mIHplcm8AAADwPhAAOQAAAHJhbmdlIHN0 +YXJ0IGluZGV4ICBvdXQgb2YgcmFuZ2UgZm9yIHNsaWNlIG9mIGxlbmd0aCA0PxAAEgAAAEY/EAAi +AAAAcmFuZ2UgZW5kIGluZGV4IHg/EAAQAAAARj8QACIAAABzbGljZSBpbmRleCBzdGFydHMgYXQg +IGJ1dCBlbmRzIGF0IACYPxAAFgAAAK4/EAANAAAAY29weV9mcm9tX3NsaWNlOiBzb3VyY2Ugc2xp +Y2UgbGVuZ3RoICgpIGRvZXMgbm90IG1hdGNoIGRlc3RpbmF0aW9uIHNsaWNlIGxlbmd0aCAoAAAA +zD8QACYAAADyPxAAKwAAAFQ0EAABAAAAAAMAAIMEIACRBWAAXROgABIXIB8MIGAf7ywgKyowoCtv +pmAsAqjgLB774C0A/iA2nv9gNv0B4TYBCiE3JA3hN6sOYTkvGOE5MBzhSvMe4U5ANKFSHmHhU/Bq +YVRPb+FUnbxhVQDPYVZl0aFWANohVwDgoViu4iFa7OThW9DoYVwgAO5c8AF/XRA1EAASNRAAFDUQ +AAIAAAACAAAABwBB8IHBAAsBRgBwCXByb2R1Y2VycwIIbGFuZ3VhZ2UBBFJ1c3QADHByb2Nlc3Nl +ZC1ieQMFcnVzdGMdMS44Ny4wICgxNzA2N2U5YWMgMjAyNS0wNS0wOSkGd2FscnVzBjAuMjMuMwx3 +YXNtLWJpbmRnZW4HMC4yLjEwMABrD3RhcmdldF9mZWF0dXJlcwYrD211dGFibGUtZ2xvYmFscysT +bm9udHJhcHBpbmctZnB0b2ludCsLYnVsay1tZW1vcnkrCHNpZ24tZXh0Kw9yZWZlcmVuY2UtdHlw +ZXMrCm11bHRpdmFsdWU= ` .trim() .replaceAll("\n", "") From c85003ffd451dcfcb61cfa2dfc55017b75470beb Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Fri, 1 Aug 2025 22:01:16 +0200 Subject: [PATCH 39/43] improve stats in bench scritp --- packages/hub/scripts/bench.ts | 66 +++++++++++++++++++++-------------- 1 file changed, 40 insertions(+), 26 deletions(-) diff --git a/packages/hub/scripts/bench.ts b/packages/hub/scripts/bench.ts index 279dbf4f3e..462d055bca 100644 --- a/packages/hub/scripts/bench.ts +++ b/packages/hub/scripts/bench.ts @@ -89,17 +89,36 @@ function getBodySize(body: RequestInit["body"]): string { return "unknown size"; } -function createMockFetch(): typeof fetch { - let uploadCount = 0; - - return async function mockFetch(input: string | URL | Request, init?: RequestInit): Promise { +function createMockFetch(): { + fetch: typeof fetch; + getStats: () => { xorbCount: number; shardCount: number; xorbBytes: number; shardBytes: number }; +} { + let xorbCount = 0; + let shardCount = 0; + let xorbBytes = 0; + let shardBytes = 0; + + const mockFetch = async function (input: string | URL | Request, init?: RequestInit): Promise { const url = typeof input === "string" ? input : input.toString(); // Mock successful responses for xorb and shard uploads - if (url.includes("/xorb/") || url.includes("/shard/")) { - uploadCount++; + if (url.includes("/xorb/")) { + xorbCount++; const bodySize = getBodySize(init?.body); - console.log(`[MOCK] Upload ${uploadCount}: ${init?.method || "GET"} ${url} (${bodySize})`); + xorbBytes += parseInt(bodySize); + console.log(`[MOCK] Xorb upload ${xorbCount}: ${init?.method || "GET"} ${url} (${bodySize})`); + + return new Response(null, { + status: 200, + statusText: "OK", + }); + } + + if (url.includes("/shard/")) { + shardCount++; + const bodySize = getBodySize(init?.body); + shardBytes += parseInt(bodySize); + console.log(`[MOCK] Shard upload ${shardCount}: ${init?.method || "GET"} ${url} (${bodySize})`); return new Response(null, { status: 200, @@ -113,6 +132,11 @@ function createMockFetch(): typeof fetch { return res; }); }; + + return { + fetch: mockFetch, + getStats: () => ({ xorbCount, shardCount, xorbBytes, shardBytes }), + }; } async function main() { @@ -157,13 +181,13 @@ async function main() { const repo: RepoId = toRepoId(repoName); // Create mock fetch - const mockFetch = createMockFetch(); + const mockFetchObj = createMockFetch(); // Setup upload parameters const uploadParams = { accessToken: args.token, hubUrl: "https://huggingface.co", - customFetch: mockFetch, + customFetch: mockFetchObj.fetch, repo, rev: "main", }; @@ -172,8 +196,6 @@ async function main() { const stats: Array<{ filename: string; size: number; - xorbCount: number; - shardCount: number; dedupRatio: number; }> = []; @@ -197,8 +219,6 @@ async function main() { stats.push({ filename: event.path, size: fileStats.size, - xorbCount: 0, // Will be updated later - shardCount: 0, // Will be updated later dedupRatio: event.dedupRatio, }); } @@ -213,13 +233,9 @@ async function main() { } } - // Note: xorb and shard counts are tracked internally by uploadShards - // For this demo, we'll make reasonable estimates based on file sizes - for (const stat of stats) { - // Rough estimates - in real usage these would come from the upload process - stat.xorbCount = Math.ceil(stat.size / (64 * 1024 * 1024)); // 64MB xorbs - stat.shardCount = Math.max(1, Math.ceil(stat.xorbCount / 100)); // Rough shard estimation - } + // Get actual upload counts from the mock fetch + const uploadStats = mockFetchObj.getStats(); + console.log(`\nšŸ“Š Actual upload counts: ${uploadStats.xorbCount} xorbs, ${uploadStats.shardCount} shards`); // Output final statistics console.log("\n=== BENCHMARK RESULTS ==="); @@ -229,21 +245,19 @@ async function main() { for (const stat of stats) { console.log(`\nšŸ“„ ${stat.filename}:`); console.log(` Size: ${(stat.size / 1024 / 1024).toFixed(2)} MB`); - console.log(` Xorbs: ${stat.xorbCount}`); - console.log(` Shards: ${stat.shardCount}`); console.log(` Deduplication: ${(stat.dedupRatio * 100).toFixed(2)}%`); } console.log("\n=== SUMMARY ==="); const totalSize = stats.reduce((sum, s) => sum + s.size, 0); - const totalXorbs = stats.reduce((sum, s) => sum + s.xorbCount, 0); - const totalShards = stats.reduce((sum, s) => sum + s.shardCount, 0); const avgDedup = stats.reduce((sum, s) => sum + s.dedupRatio, 0) / stats.length; console.log(`Total files: ${stats.length}`); console.log(`Total size: ${(totalSize / 1024 / 1024).toFixed(2)} MB`); - console.log(`Total xorbs: ${totalXorbs}`); - console.log(`Total shards: ${totalShards}`); + console.log(`Total xorbs: ${uploadStats.xorbCount}`); + console.log(`Total shards: ${uploadStats.shardCount}`); + console.log(`Total xorb bytes: ${uploadStats.xorbBytes.toLocaleString("fr")} bytes`); + console.log(`Total shard bytes: ${uploadStats.shardBytes.toLocaleString("fr")} bytes`); console.log(`Average deduplication: ${(avgDedup * 100).toFixed(2)}%`); } From 846de2b4173880036a03a95c7413238bf2173641 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Fri, 1 Aug 2025 22:36:28 +0200 Subject: [PATCH 40/43] fix data intake for createXorb --- packages/hub/src/utils/createXorbs.ts | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/packages/hub/src/utils/createXorbs.ts b/packages/hub/src/utils/createXorbs.ts index ba45a94d96..2e4b1e9ab8 100644 --- a/packages/hub/src/utils/createXorbs.ts +++ b/packages/hub/src/utils/createXorbs.ts @@ -126,12 +126,22 @@ export async function* createXorbs( chunkToCopy = new Uint8Array(chunk.length); let copyOffset = 0; let index = 0; + let toSlice = -1; while (copyOffset < chunk.length) { - chunkToCopy.set(sourceChunks[index].subarray(0, chunk.length - copyOffset), copyOffset); - copyOffset += sourceChunks[index].length; - index++; + const nToCopy = Math.min(sourceChunks[index].length, chunk.length - copyOffset); + chunkToCopy.set(sourceChunks[index].subarray(0, nToCopy), copyOffset); + copyOffset += nToCopy; + + if (nToCopy === sourceChunks[index].length) { + index++; + } else { + toSlice = nToCopy; + } } sourceChunks.splice(0, index); + if (toSlice !== -1) { + sourceChunks[0] = sourceChunks[0].subarray(toSlice); + } } let cacheData = chunkCache.getChunk(chunk.hash, chunkModule.compute_hmac); From 23afed844d19f3916461db6d825b84793769b432 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Fri, 1 Aug 2025 22:36:42 +0200 Subject: [PATCH 41/43] add commit option to bench script --- packages/hub/scripts/bench.ts | 36 +++++++++++++++++++++++++++++++++-- 1 file changed, 34 insertions(+), 2 deletions(-) diff --git a/packages/hub/scripts/bench.ts b/packages/hub/scripts/bench.ts index 462d055bca..7d16427bcd 100644 --- a/packages/hub/scripts/bench.ts +++ b/packages/hub/scripts/bench.ts @@ -6,6 +6,8 @@ import { join } from "node:path"; import { writeFile, readFile, stat, mkdir } from "node:fs/promises"; import type { RepoId } from "../src/types/public.js"; import { toRepoId } from "../src/utils/toRepoId.js"; +import { commitIter } from "../src/index.js"; +import { pathToFileURL } from "node:url"; /** * This script downloads the files from openai-community/gpt2 and simulates an upload to a xet repo. @@ -14,6 +16,7 @@ import { toRepoId } from "../src/utils/toRepoId.js"; * Usage: * * pnpm --filter hub bench -t -r + * pnpm --filter hub bench -t -r --commit # Actually upload files */ const FILES_TO_DOWNLOAD = [ @@ -150,12 +153,17 @@ async function main() { type: "string", short: "r", }, + commit: { + type: "boolean", + short: "c", + default: false, + }, }, }); if (!args.token || !args.repo) { - console.error("Usage: node bench.ts --token --repo "); - console.error("Example: node bench.ts --token hf_... --repo myuser/myrepo"); + console.error("Usage: pnpm --filter hub bench -t -r "); + console.error("Example: pnpm --filter hub bench -t hf_... -r myuser/myrepo"); process.exit(1); } @@ -259,6 +267,30 @@ async function main() { console.log(`Total xorb bytes: ${uploadStats.xorbBytes.toLocaleString("fr")} bytes`); console.log(`Total shard bytes: ${uploadStats.shardBytes.toLocaleString("fr")} bytes`); console.log(`Average deduplication: ${(avgDedup * 100).toFixed(2)}%`); + + if (args.commit) { + console.log("\n=== Committing files ==="); + const iterator = commitIter({ + repo, + operations: files.map((file) => ({ + operation: "addOrUpdate", + content: pathToFileURL(file.filepath), + path: file.filename, + })), + accessToken: args.token, + title: "Upload xet files with JS lib", + xet: true, + }); + for await (const event of iterator) { + if (event.event === "fileProgress" && event.state === "hashing") { + // We don't care about the hashing progress + } else { + console.log(event); + } + } + + console.log("Done committing"); + } } main().catch((error) => { From 235ce447853a68ce1b6fc105fd8341b7e1b42968 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Fri, 1 Aug 2025 22:38:19 +0200 Subject: [PATCH 42/43] fix PUT => POST calls --- packages/hub/src/utils/uploadShards.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/packages/hub/src/utils/uploadShards.ts b/packages/hub/src/utils/uploadShards.ts index b8c2e6e81c..7e55cdaf0f 100644 --- a/packages/hub/src/utils/uploadShards.ts +++ b/packages/hub/src/utils/uploadShards.ts @@ -372,7 +372,7 @@ async function uploadXorb(xorb: { hash: string; xorb: Uint8Array }, params: Uplo const token = await xetWriteToken(params); const resp = await params.customFetch(`${token.casUrl}/v1/xorb/default/${xorb.hash}`, { - method: "PUT", + method: "POST", body: xorb.xorb, headers: { Authorization: `Bearer ${token.accessToken}`, @@ -388,7 +388,7 @@ async function uploadShard(shard: Uint8Array, params: UploadShardsParams) { const token = await xetWriteToken(params); const resp = await params.customFetch(`${token.casUrl}/v1/shard/default-merkledb`, { - method: "PUT", + method: "POST", body: shard, headers: { Authorization: `Bearer ${token.accessToken}`, From ab9ced2447dfe06da165482ac8cde171bf39b9ff Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Sat, 2 Aug 2025 01:34:28 +0200 Subject: [PATCH 43/43] error in dedup --- packages/hub/src/utils/createXorbs.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/hub/src/utils/createXorbs.ts b/packages/hub/src/utils/createXorbs.ts index 2e4b1e9ab8..0a90ca572e 100644 --- a/packages/hub/src/utils/createXorbs.ts +++ b/packages/hub/src/utils/createXorbs.ts @@ -207,6 +207,7 @@ export async function* createXorbs( } chunkCache.addChunkToCache(chunk.hash, xorbId, chunkIndex, null); + xorbChunks.push({ hash: chunk.hash, length: chunk.length }); } else { chunkXorbId = cacheData.xorbIndex; chunkIndex = cacheData.chunkIndex; @@ -243,7 +244,6 @@ export async function* createXorbs( currentChunkRangeBeginning = fileChunks.length - 1; } } - xorbChunks.push({ hash: chunk.hash, length: chunk.length }); xorbFileProgress[fileSource.path] = processedBytes / fileSource.content.size; if (xorbChunks.length >= MAX_XORB_CHUNKS) { yield {