From 3b5e2b92e8875102b00f3e4f291a2fcd145ed494 Mon Sep 17 00:00:00 2001 From: coyotte508 Date: Wed, 16 Jul 2025 16:18:40 +0200 Subject: [PATCH 01/11] 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/11] 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/11] 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/11] 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/11] 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/11] 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/11] 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/11] 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/11] 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/11] 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/11] 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 {