diff --git a/packages/hub/.gitignore b/packages/hub/.gitignore new file mode 100644 index 0000000000..1d6b547d34 --- /dev/null +++ b/packages/hub/.gitignore @@ -0,0 +1 @@ +xet-core-wasm-build diff --git a/packages/hub/.prettierignore b/packages/hub/.prettierignore index 4fafcf634d..03481c7d5d 100644 --- a/packages/hub/.prettierignore +++ b/packages/hub/.prettierignore @@ -2,4 +2,5 @@ pnpm-lock.yaml # In order to avoid code samples to have tabs, they don't display well on npm README.md dist -sha256.js \ No newline at end of file +sha256.js +src/vendor/xet-chunk/chunker_wasm_bg.js \ No newline at end of file diff --git a/packages/hub/package.json b/packages/hub/package.json index 871d9ef1f5..005023f025 100644 --- a/packages/hub/package.json +++ b/packages/hub/package.json @@ -41,7 +41,8 @@ "prepare": "pnpm run build", "test": "vitest run", "test:browser": "vitest run --browser.name=chrome --browser.headless --config vitest-browser.config.mts", - "check": "tsc" + "check": "tsc", + "build:xet-wasm": "./scripts/build-xet-wasm.sh -t bundler -c -b hoytak/250714-eliminate-mdb-v1" }, "files": [ "src", diff --git a/packages/hub/scripts/build-xet-wasm.sh b/packages/hub/scripts/build-xet-wasm.sh new file mode 100755 index 0000000000..73faa23212 --- /dev/null +++ b/packages/hub/scripts/build-xet-wasm.sh @@ -0,0 +1,241 @@ +#!/bin/bash + +# Regenerate xet-chunk wasm files directly from xet-core codebase + +set -euo pipefail + +# Configuration +REPO_URL="https://github.com/huggingface/xet-core.git" +DEFAULT_BRANCH="main" +DEFAULT_PACKAGE="hf_xet_thin_wasm" +DEFAULT_JS_TARGET="web" +CLONE_DIR="xet-core-wasm-build" + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' # No Color + +# Function to print colored output +log() { + echo -e "${GREEN}[INFO]${NC} $1" +} + +warn() { + echo -e "${YELLOW}[WARN]${NC} $1" +} + +error() { + echo -e "${RED}[ERROR]${NC} $1" + exit 1 +} + +# Function to check if a command exists +command_exists() { + command -v "$1" >/dev/null 2>&1 +} + +# Help function +show_help() { + cat << EOF +Usage: $0 [OPTIONS] + +Build WASM packages from xet-core repository. + +OPTIONS: + -b, --branch BRANCH Git branch to checkout (default: $DEFAULT_BRANCH) + -p, --package PACKAGE WASM package to build: hf_xet_thin_wasm or hf_xet_wasm (default: $DEFAULT_PACKAGE) + -t, --target TARGET JavaScript target: web, nodejs, bundler, no-modules, deno (default: $DEFAULT_JS_TARGET) + -o, --output DIR Output directory to copy built WASM files + -c, --clean Clean clone directory before starting + -h, --help Show this help message + +EXAMPLES: + $0 # Build hf_xet_thin_wasm from main branch + $0 -b feature-branch # Build from specific branch + $0 -p hf_xet_wasm # Build the full WASM package + $0 -o ./my-project/wasm # Copy output to specific directory + $0 -t nodejs -o ./dist # Build for Node.js and copy to dist + +REQUIREMENTS: + - Git + - Rust (will install nightly toolchain automatically) + - Internet connection for downloading dependencies + +EOF +} + +# Parse command line arguments +BRANCH="$DEFAULT_BRANCH" +PACKAGE="$DEFAULT_PACKAGE" +JS_TARGET="$DEFAULT_JS_TARGET" +OUTPUT_DIR="" +CLEAN=false +ORIGINAL_DIR=$(pwd) + +while [[ $# -gt 0 ]]; do + case $1 in + -b|--branch) + BRANCH="$2" + shift 2 + ;; + -p|--package) + PACKAGE="$2" + if [[ "$PACKAGE" != "hf_xet_thin_wasm" && "$PACKAGE" != "hf_xet_wasm" ]]; then + error "Invalid package: $PACKAGE. Must be 'hf_xet_thin_wasm' or 'hf_xet_wasm'" + fi + shift 2 + ;; + -t|--target) + JS_TARGET="$2" + shift 2 + ;; + -o|--output) + OUTPUT_DIR="$2" + shift 2 + ;; + -c|--clean) + CLEAN=true + shift + ;; + -h|--help) + show_help + exit 0 + ;; + *) + error "Unknown option: $1. Use -h for help." + ;; + esac +done + +# Check prerequisites +log "Checking prerequisites..." + +if ! command_exists git; then + error "Git is not installed. Please install Git first." +fi + +if ! command_exists rustup; then + error "Rustup is not installed. Please install Rust from https://rustup.rs/" +fi + +# Clean previous build if requested +if [[ "$CLEAN" == true && -d "$CLONE_DIR" ]]; then + log "Cleaning previous build directory: $CLONE_DIR" + rm -rf "$CLONE_DIR" +fi + +# Clone the repository +if [[ -d "$CLONE_DIR" ]]; then + log "Directory $CLONE_DIR already exists. Using existing clone." + cd "$CLONE_DIR" + log "Fetching latest changes..." + git fetch origin + git checkout "$BRANCH" + git reset --hard "origin/$BRANCH" +else + log "Cloning xet-core repository (branch: $BRANCH, depth: 1)..." + git clone --depth=1 --branch="$BRANCH" "$REPO_URL" "$CLONE_DIR" + cd "$CLONE_DIR" +fi + +log "Repository cloned successfully. Current directory: $(pwd)" + +# Install required Rust toolchain and components +log "Setting up Rust toolchain..." + +# # Install nightly toolchain +# log "Installing Rust nightly toolchain..." +# rustup toolchain install nightly + +# # Add WASM target +# log "Adding wasm32-unknown-unknown target..." +# rustup target add wasm32-unknown-unknown --toolchain nightly + +# # Add rust-src component for nightly +# log "Adding rust-src component..." +# rustup component add rust-src --toolchain nightly + +# Install required tools +log "Installing wasm-pack and wasm-bindgen-cli..." +if ! command_exists wasm-pack; then + cargo install wasm-pack +else + log "wasm-pack already installed" +fi + +if ! command_exists wasm-bindgen; then + cargo install wasm-bindgen-cli +else + log "wasm-bindgen-cli already installed" +fi + +# Change to the package directory +log "Building WASM package: $PACKAGE" +cd "$PACKAGE" + +# Set environment variable for JS target +export JS_TARGET="$JS_TARGET" + +# Build the WASM package +log "Starting WASM build (target: $JS_TARGET)..." +if [[ "$PACKAGE" == "hf_xet_thin_wasm" ]]; then + # Use the existing build script for thin WASM + chmod +x build_wasm.sh + ./build_wasm.sh +else + # For hf_xet_wasm, use the more complex build process + chmod +x build_wasm.sh + ./build_wasm.sh +fi + +log "WASM build completed successfully!" + +# Check if pkg directory exists (created by wasm-pack) +if [[ -d "pkg" ]]; then + log "Generated files in pkg directory:" + ls -la pkg/ + + # Copy to output directory if specified + if [[ -n "$OUTPUT_DIR" ]]; then + log "Copying WASM files to output directory: $OUTPUT_DIR" + mkdir -p "$OUTPUT_DIR" + cp -r pkg/* "$OUTPUT_DIR/" + log "Files copied to $OUTPUT_DIR" + log "Contents of output directory:" + ls -la "$OUTPUT_DIR" + fi +else + warn "pkg directory not found. Build may have failed or used different output location." +fi + +# Return to original directory +cd "$ORIGINAL_DIR" + +log "Build process completed!" +log "Built package: $PACKAGE" +log "Branch: $BRANCH" +log "JavaScript target: $JS_TARGET" +if [[ -n "$OUTPUT_DIR" ]]; then + log "Output copied to: $OUTPUT_DIR" +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" +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" +cat << 'EOF' >> "./src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts" +`) + .trim() + .replaceAll("\n", ""); +const wasmBinary = new Uint8Array(wasmBase64.length); +for (let i = 0; i < wasmBase64.length; i++) { + wasmBinary[i] = wasmBase64.charCodeAt(i); +} +export { wasmBinary }; +EOF + +echo -e "\n${GREEN}🎉 Success!${NC} Your WASM package is ready to use." diff --git a/packages/hub/src/utils/XetBlob.spec.ts b/packages/hub/src/utils/XetBlob.spec.ts index e3233fab6d..9a12d2f20d 100644 --- a/packages/hub/src/utils/XetBlob.spec.ts +++ b/packages/hub/src/utils/XetBlob.spec.ts @@ -1,6 +1,6 @@ import { describe, expect, it } from "vitest"; import type { ReconstructionInfo } from "./XetBlob"; -import { bg4_regoup_bytes, XetBlob } from "./XetBlob"; +import { bg4_regroup_bytes, bg4_split_bytes, XetBlob } from "./XetBlob"; import { sum } from "./sum"; describe("XetBlob", () => { @@ -173,30 +173,72 @@ describe("XetBlob", () => { describe("bg4_regoup_bytes", () => { it("should regroup bytes when the array is %4 length", () => { - expect(bg4_regoup_bytes(new Uint8Array([1, 5, 2, 6, 3, 7, 4, 8]))).toEqual( + expect(bg4_regroup_bytes(new Uint8Array([1, 5, 2, 6, 3, 7, 4, 8]))).toEqual( new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]) ); }); it("should regroup bytes when the array is %4 + 1 length", () => { - expect(bg4_regoup_bytes(new Uint8Array([1, 5, 9, 2, 6, 3, 7, 4, 8]))).toEqual( + expect(bg4_regroup_bytes(new Uint8Array([1, 5, 9, 2, 6, 3, 7, 4, 8]))).toEqual( new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9]) ); }); it("should regroup bytes when the array is %4 + 2 length", () => { - expect(bg4_regoup_bytes(new Uint8Array([1, 5, 9, 2, 6, 10, 3, 7, 4, 8]))).toEqual( + expect(bg4_regroup_bytes(new Uint8Array([1, 5, 9, 2, 6, 10, 3, 7, 4, 8]))).toEqual( new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) ); }); it("should regroup bytes when the array is %4 + 3 length", () => { - expect(bg4_regoup_bytes(new Uint8Array([1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8]))).toEqual( + expect(bg4_regroup_bytes(new Uint8Array([1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8]))).toEqual( new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) ); }); }); + describe("bg4_split_bytes", () => { + it("should split bytes when the array is %4 length", () => { + expect(bg4_split_bytes(new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]))).toEqual( + new Uint8Array([1, 5, 2, 6, 3, 7, 4, 8]) + ); + }); + + it("should split bytes when the array is %4 + 1 length", () => { + expect(bg4_split_bytes(new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9]))).toEqual( + new Uint8Array([1, 5, 9, 2, 6, 3, 7, 4, 8]) + ); + }); + + it("should split bytes when the array is %4 + 2 length", () => { + expect(bg4_split_bytes(new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))).toEqual( + new Uint8Array([1, 5, 9, 2, 6, 10, 3, 7, 4, 8]) + ); + }); + + it("should split bytes when the array is %4 + 3 length", () => { + expect(bg4_split_bytes(new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]))).toEqual( + new Uint8Array([1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8]) + ); + }); + + it("should be the inverse of bg4_regroup_bytes", () => { + const testArrays = [ + new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]), + new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9]), + new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), + new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]), + new Uint8Array([42]), + new Uint8Array([1, 2]), + new Uint8Array([1, 2, 3]), + ]; + + testArrays.forEach((arr) => { + expect(bg4_regroup_bytes(bg4_split_bytes(arr))).toEqual(arr); + }); + }); + }); + describe("when mocked", () => { describe("loading many chunks every read", () => { it("should load different slices", async () => { diff --git a/packages/hub/src/utils/XetBlob.ts b/packages/hub/src/utils/XetBlob.ts index 3b787b0e54..0846d1a535 100644 --- a/packages/hub/src/utils/XetBlob.ts +++ b/packages/hub/src/utils/XetBlob.ts @@ -56,26 +56,26 @@ export interface ReconstructionInfo { offset_into_first_range: number; } -enum CompressionScheme { +export enum XetChunkCompressionScheme { None = 0, LZ4 = 1, ByteGroupingLZ4 = 2, } -const compressionSchemeLabels: Record = { - [CompressionScheme.None]: "None", - [CompressionScheme.LZ4]: "LZ4", - [CompressionScheme.ByteGroupingLZ4]: "ByteGroupingLZ4", +const compressionSchemeLabels: Record = { + [XetChunkCompressionScheme.None]: "None", + [XetChunkCompressionScheme.LZ4]: "LZ4", + [XetChunkCompressionScheme.ByteGroupingLZ4]: "ByteGroupingLZ4", }; interface ChunkHeader { version: number; // u8, 1 byte compressed_length: number; // 3 * u8, 3 bytes - compression_scheme: CompressionScheme; // u8, 1 byte + compression_scheme: XetChunkCompressionScheme; // u8, 1 byte uncompressed_length: number; // 3 * u8, 3 bytes } -const CHUNK_HEADER_BYTES = 8; +export const XET_CHUNK_HEADER_BYTES = 8; /** * XetBlob is a blob implementation that fetches data directly from the Xet storage @@ -338,7 +338,7 @@ export class XetBlob extends Blob { continue fetchData; } - const header = new DataView(result.value.buffer, result.value.byteOffset, CHUNK_HEADER_BYTES); + const header = new DataView(result.value.buffer, result.value.byteOffset, XET_CHUNK_HEADER_BYTES); const chunkHeader: ChunkHeader = { version: header.getUint8(0), compressed_length: header.getUint8(1) | (header.getUint8(2) << 8) | (header.getUint8(3) << 16), @@ -353,9 +353,9 @@ export class XetBlob extends Blob { } if ( - chunkHeader.compression_scheme !== CompressionScheme.None && - chunkHeader.compression_scheme !== CompressionScheme.LZ4 && - chunkHeader.compression_scheme !== CompressionScheme.ByteGroupingLZ4 + chunkHeader.compression_scheme !== XetChunkCompressionScheme.None && + chunkHeader.compression_scheme !== XetChunkCompressionScheme.LZ4 && + chunkHeader.compression_scheme !== XetChunkCompressionScheme.ByteGroupingLZ4 ) { throw new Error( `Unsupported compression scheme ${ @@ -364,19 +364,19 @@ export class XetBlob extends Blob { ); } - if (result.value.byteLength < chunkHeader.compressed_length + CHUNK_HEADER_BYTES) { + if (result.value.byteLength < chunkHeader.compressed_length + XET_CHUNK_HEADER_BYTES) { // We need more data to read the full chunk leftoverBytes = result.value; continue fetchData; } - result.value = result.value.slice(CHUNK_HEADER_BYTES); + result.value = result.value.slice(XET_CHUNK_HEADER_BYTES); let uncompressed = - chunkHeader.compression_scheme === CompressionScheme.LZ4 + chunkHeader.compression_scheme === XetChunkCompressionScheme.LZ4 ? lz4_decompress(result.value.slice(0, chunkHeader.compressed_length), chunkHeader.uncompressed_length) - : chunkHeader.compression_scheme === CompressionScheme.ByteGroupingLZ4 - ? bg4_regoup_bytes( + : chunkHeader.compression_scheme === XetChunkCompressionScheme.ByteGroupingLZ4 + ? bg4_regroup_bytes( lz4_decompress( result.value.slice(0, chunkHeader.compressed_length), chunkHeader.uncompressed_length @@ -529,7 +529,7 @@ function cacheKey(params: { refreshUrl: string; initialAccessToken: string | und } // exported for testing purposes -export function bg4_regoup_bytes(bytes: Uint8Array): Uint8Array { +export function bg4_regroup_bytes(bytes: Uint8Array): Uint8Array { // python code // split = len(x) // 4 @@ -590,6 +590,40 @@ export function bg4_regoup_bytes(bytes: Uint8Array): Uint8Array { // } } +export function bg4_split_bytes(bytes: Uint8Array): Uint8Array { + // This function does the opposite of bg4_regroup_bytes + // It takes interleaved bytes and groups them by 4 + + const ret = new Uint8Array(bytes.byteLength); + const split = Math.floor(bytes.byteLength / 4); + const rem = bytes.byteLength % 4; + + // Calculate group positions in the output array + const g1_pos = split + (rem >= 1 ? 1 : 0); + const g2_pos = g1_pos + split + (rem >= 2 ? 1 : 0); + const g3_pos = g2_pos + split + (rem == 3 ? 1 : 0); + + // Extract every 4th byte starting from position 0, 1, 2, 3 + // and place them in their respective groups + for (let i = 0, j = 0; i < bytes.byteLength; i += 4, j++) { + ret[j] = bytes[i]; + } + + for (let i = 1, j = g1_pos; i < bytes.byteLength; i += 4, j++) { + ret[j] = bytes[i]; + } + + for (let i = 2, j = g2_pos; i < bytes.byteLength; i += 4, j++) { + ret[j] = bytes[i]; + } + + for (let i = 3, j = g3_pos; i < bytes.byteLength; i += 4, j++) { + ret[j] = bytes[i]; + } + + return ret; +} + async function getAccessToken( initialAccessToken: string | undefined, customFetch: typeof fetch, diff --git a/packages/hub/src/utils/createXorbs.ts b/packages/hub/src/utils/createXorbs.ts new file mode 100644 index 0000000000..e239dc0f0a --- /dev/null +++ b/packages/hub/src/utils/createXorbs.ts @@ -0,0 +1,130 @@ +/** + * Todo: add dedup: we actually need to remember chunks already written, and not add them to the xorb, and also + * take that into account for file reconstruction + * Todo: byte grouping? + */ + +import { bg4_split_bytes, XET_CHUNK_HEADER_BYTES, XetChunkCompressionScheme } from "./XetBlob"; +import { compress as lz4_compress } from "../vendor/lz4js"; + +const TARGET_CHUNK_SIZE = 64 * 1024; +/* eslint-disable @typescript-eslint/no-unused-vars */ +const MAX_CHUNK_SIZE = 2 * TARGET_CHUNK_SIZE; +const XORB_SIZE = 64 * 1024 * 1024; +const MAX_XORB_CHUNKS = 8 * 1024; + +export async function* createXorbs( + fileSource: Blob +): AsyncGenerator<{ xorb: Uint8Array; hash: string }, void, undefined> { + const chunkModule = await import("../vendor/xet-chunk/chunker_wasm"); + await chunkModule.init(); + const chunker = new chunkModule.Chunker(TARGET_CHUNK_SIZE); + + let xorb = new Uint8Array(XORB_SIZE); + const sourceChunks: Array = []; + + try { + const reader = fileSource.stream().getReader(); + let xorbOffset = 0; + let xorbChunks = Array<{ hash: string; length: number }>(); + + const addChunks = function* (chunks: Array<{ hash: string; length: number }>) { + for (const chunk of chunks) { + 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); + } + 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: "" }; + xorb = new Uint8Array(XORB_SIZE); + xorbOffset = writeChunk(xorb, 0, chunkToCopy); + + if (xorbOffset === 0) { + throw new Error("Failed to write chunk into xorb"); + } + } + xorbChunks.push(chunk); + if (xorbChunks.length >= MAX_XORB_CHUNKS) { + yield { xorb: xorb.subarray(0, xorbOffset), hash: chunkModule.compute_xorb_hash(xorbChunks) }; + 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); + yield* addChunks(chunker.add_data(value)); + } + } finally { + chunker.free(); + // ^ is this really needed ? + } +} + +// interface ChunkHeader { +// version: number; // u8, 1 byte +// compressed_length: number; // 3 * u8, 3 bytes +// compression_scheme: CompressionScheme; // u8, 1 byte +// uncompressed_length: number; // 3 * u8, 3 bytes +// } + +// const CHUNK_HEADER_BYTES = 8; + +/** + * Write a chunk header to the xorb and return the offset of where to write the next chunk + * + * If it returns 0, it means there wasn't enough space in the xorb + * + * Todo: add bg4 compression maybe? + */ +function writeChunk(xorb: Uint8Array, offset: number, chunk: Uint8Array): number { + const regularCompressedChunk = lz4_compress(chunk); + const bgCompressedChunk = lz4_compress(bg4_split_bytes(chunk)); + const compressedChunk = + regularCompressedChunk.length < bgCompressedChunk.length ? regularCompressedChunk : bgCompressedChunk; + const chunkToWrite = compressedChunk.length < chunk.length ? compressedChunk : chunk; + + if (offset + XET_CHUNK_HEADER_BYTES + chunkToWrite.length > XORB_SIZE) { + return 0; + } + + xorb[offset] = 0; + xorb[offset + 1] = chunkToWrite.length & 0xff; + xorb[offset + 2] = (chunkToWrite.length >> 8) & 0xff; + xorb[offset + 3] = (chunkToWrite.length >> 16) & 0xff; + xorb[offset + 4] = + chunkToWrite.length < chunk.length + ? bgCompressedChunk.length < chunk.length + ? XetChunkCompressionScheme.ByteGroupingLZ4 + : XetChunkCompressionScheme.LZ4 + : XetChunkCompressionScheme.None; + xorb[offset + 5] = chunk.length & 0xff; + xorb[offset + 6] = (chunk.length >> 8) & 0xff; + xorb[offset + 7] = (chunk.length >> 16) & 0xff; + + xorb.set(chunkToWrite, offset + XET_CHUNK_HEADER_BYTES); + return offset + XET_CHUNK_HEADER_BYTES + chunkToWrite.length; +} diff --git a/packages/hub/src/vendor/lz4js/index.ts b/packages/hub/src/vendor/lz4js/index.ts index e258051c1b..067101fc21 100644 --- a/packages/hub/src/vendor/lz4js/index.ts +++ b/packages/hub/src/vendor/lz4js/index.ts @@ -519,7 +519,7 @@ export function decompress(src: Uint8Array, maxSize: number) { // Compresses a buffer to an Lz4 frame. maxSize is optional; if not provided, // a buffer will be created based on the theoretical worst output size for a // given input size. The buffer returned will always be perfectly-sized. -export function compress(src: Uint8Array, maxSize: number) { +export function compress(src: Uint8Array, maxSize?: number) { let dst, size; if (maxSize === undefined) { diff --git a/packages/hub/src/vendor/xet-chunk/.prettierignore b/packages/hub/src/vendor/xet-chunk/.prettierignore new file mode 100644 index 0000000000..4c43fe68f6 --- /dev/null +++ b/packages/hub/src/vendor/xet-chunk/.prettierignore @@ -0,0 +1 @@ +*.js \ No newline at end of file diff --git a/packages/hub/src/vendor/xet-chunk/README.md b/packages/hub/src/vendor/xet-chunk/README.md new file mode 100644 index 0000000000..f586b083aa --- /dev/null +++ b/packages/hub/src/vendor/xet-chunk/README.md @@ -0,0 +1,7 @@ +# Xet-Chunk + +WASM utilities to chunk & hash data. + +An assembly script implementation is available in `@huggingface/xetchunk-wasm`, but for performance reasons we're using WASM directly compiled from the rust source, see https://github.com/huggingface/xet-core/tree/main/hf_xet_wasm which on my local machine processes data at 480MB/s. + +We hope in the future to include the build step directly in this package, or to use assembly script WASM (but blake 3 hashing perf needs to be significantly improved). \ No newline at end of file diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts b/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts new file mode 100644 index 0000000000..2446dd4574 --- /dev/null +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm.ts @@ -0,0 +1,62 @@ +// export * from "./chunker_wasm_bg.js"; +import * as __glue_imports from "./chunker_wasm_bg.js"; +// @ts-expect-error no types +import { __wbg_set_wasm } from "./chunker_wasm_bg.js"; +// @ts-expect-error no types +import { wasmBinary } from "./chunker_wasm_bg.wasm.base64.ts"; + +let initPromise: Promise | null = null; + +async function init(): Promise { + if (initPromise) { + return initPromise; + } + let resolve: (value: void) => void; + let reject: (reason?: unknown) => void; + initPromise = new Promise((_resolve, _reject) => { + resolve = _resolve; + reject = _reject; + }); + + await Promise.resolve(); + + try { + const wasmModule = await WebAssembly.compile(wasmBinary); + const imports = Object.entries( + WebAssembly.Module.imports(wasmModule).reduce( + (result, item) => ({ + ...result, + // @ts-expect-error ok for any type + [item.module]: [...(result[item.module] || []), item.name], + }), + {} + ) + ).map(([from, names]) => ({ from, names })); + const wasm = await WebAssembly.instantiate(wasmModule, { + "./chunker_wasm_bg.js": Object.fromEntries( + // @ts-expect-error ok for any type + (imports[0].names as string[]).map((name) => [name, __glue_imports[name]]) + ), + }); + __wbg_set_wasm(wasm.exports); + // console.log("exports", exports); + // @ts-expect-error it's assigned + wasm.exports.__wbindgen_start(); + + // @ts-expect-error it's assigned + resolve(); + } catch (error) { + // @ts-expect-error it's assigned + reject(error); + } +} + +init(); + +export { init }; + +export { compute_xorb_hash, Chunker } from "./chunker_wasm_bg.js"; + +// const exports = WebAssembly.Module.exports(wasmModule).map((item) => item.name); + +// console.log("imports", imports); 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 new file mode 100644 index 0000000000..3ec1cf3934 --- /dev/null +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.d.ts @@ -0,0 +1,9 @@ +/* tslint:disable */ +/* eslint-disable */ +export function compute_xorb_hash(chunks_array: any): string; +export class Chunker { + free(): void; + constructor(target_chunk_size: number); + add_data(data: Uint8Array): Array<{ hash: string; length: number }>; + finish(): Array<{ hash: string; length: number }>; +} diff --git a/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.js b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.js new file mode 100644 index 0000000000..d41d63de51 --- /dev/null +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.js @@ -0,0 +1,490 @@ +let wasm; +export function __wbg_set_wasm(val) { + wasm = val; +} + + +let WASM_VECTOR_LEN = 0; + +let cachedUint8ArrayMemory0 = null; + +function getUint8ArrayMemory0() { + if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) { + cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer); + } + return cachedUint8ArrayMemory0; +} + +const lTextEncoder = typeof TextEncoder === 'undefined' ? (0, module.require)('util').TextEncoder : TextEncoder; + +let cachedTextEncoder = new lTextEncoder('utf-8'); + +const encodeString = (typeof cachedTextEncoder.encodeInto === 'function' + ? function (arg, view) { + return cachedTextEncoder.encodeInto(arg, view); +} + : function (arg, view) { + const buf = cachedTextEncoder.encode(arg); + view.set(buf); + return { + read: arg.length, + written: buf.length + }; +}); + +function passStringToWasm0(arg, malloc, realloc) { + + if (realloc === undefined) { + const buf = cachedTextEncoder.encode(arg); + const ptr = malloc(buf.length, 1) >>> 0; + getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf); + WASM_VECTOR_LEN = buf.length; + return ptr; + } + + let len = arg.length; + let ptr = malloc(len, 1) >>> 0; + + const mem = getUint8ArrayMemory0(); + + let offset = 0; + + for (; offset < len; offset++) { + const code = arg.charCodeAt(offset); + if (code > 0x7F) break; + mem[ptr + offset] = code; + } + + if (offset !== len) { + if (offset !== 0) { + arg = arg.slice(offset); + } + ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0; + const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len); + const ret = encodeString(arg, view); + + offset += ret.written; + ptr = realloc(ptr, len, offset, 1) >>> 0; + } + + WASM_VECTOR_LEN = offset; + return ptr; +} + +let cachedDataViewMemory0 = null; + +function getDataViewMemory0() { + if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) { + cachedDataViewMemory0 = new DataView(wasm.memory.buffer); + } + return cachedDataViewMemory0; +} + +function addToExternrefTable0(obj) { + const idx = wasm.__externref_table_alloc(); + wasm.__wbindgen_export_4.set(idx, obj); + return idx; +} + +function handleError(f, args) { + try { + return f.apply(this, args); + } catch (e) { + const idx = addToExternrefTable0(e); + wasm.__wbindgen_exn_store(idx); + } +} + +const lTextDecoder = typeof TextDecoder === 'undefined' ? (0, module.require)('util').TextDecoder : TextDecoder; + +let cachedTextDecoder = new lTextDecoder('utf-8', { ignoreBOM: true, fatal: true }); + +cachedTextDecoder.decode(); + +function getStringFromWasm0(ptr, len) { + ptr = ptr >>> 0; + return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len)); +} + +function debugString(val) { + // primitive types + const type = typeof val; + if (type == 'number' || type == 'boolean' || val == null) { + return `${val}`; + } + if (type == 'string') { + return `"${val}"`; + } + if (type == 'symbol') { + const description = val.description; + if (description == null) { + return 'Symbol'; + } else { + return `Symbol(${description})`; + } + } + if (type == 'function') { + const name = val.name; + if (typeof name == 'string' && name.length > 0) { + return `Function(${name})`; + } else { + return 'Function'; + } + } + // objects + if (Array.isArray(val)) { + const length = val.length; + let debug = '['; + if (length > 0) { + debug += debugString(val[0]); + } + for(let i = 1; i < length; i++) { + debug += ', ' + debugString(val[i]); + } + debug += ']'; + return debug; + } + // Test for built-in + const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val)); + let className; + if (builtInMatches && builtInMatches.length > 1) { + className = builtInMatches[1]; + } else { + // Failed to match the standard '[object ClassName]' + return toString.call(val); + } + if (className == 'Object') { + // we're a user defined class or Object + // JSON.stringify avoids problems with cycles, and is generally much + // easier than looping through ownProperties of `val`. + try { + return 'Object(' + JSON.stringify(val) + ')'; + } catch (_) { + return 'Object'; + } + } + // errors + if (val instanceof Error) { + return `${val.name}: ${val.message}\n${val.stack}`; + } + // TODO we could test for more things here, like `Set`s and `Map`s. + return className; +} + +function isLikeNone(x) { + return x === undefined || x === null; +} + +function passArray8ToWasm0(arg, malloc) { + const ptr = malloc(arg.length * 1, 1) >>> 0; + getUint8ArrayMemory0().set(arg, ptr / 1); + WASM_VECTOR_LEN = arg.length; + return ptr; +} + +function takeFromExternrefTable0(idx) { + const value = wasm.__wbindgen_export_4.get(idx); + wasm.__externref_table_dealloc(idx); + return value; +} +/** + * @param {any} chunks_array + * @returns {string} + */ +export function compute_xorb_hash(chunks_array) { + let deferred2_0; + let deferred2_1; + try { + const ret = wasm.compute_xorb_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); + } +} + +const ChunkerFinalization = (typeof FinalizationRegistry === 'undefined') + ? { register: () => {}, unregister: () => {} } + : new FinalizationRegistry(ptr => wasm.__wbg_chunker_free(ptr >>> 0, 1)); + +export class Chunker { + + __destroy_into_raw() { + const ptr = this.__wbg_ptr; + this.__wbg_ptr = 0; + ChunkerFinalization.unregister(this); + return ptr; + } + + free() { + const ptr = this.__destroy_into_raw(); + wasm.__wbg_chunker_free(ptr, 0); + } + /** + * @param {number} target_chunk_size + */ + constructor(target_chunk_size) { + const ret = wasm.chunker_new(target_chunk_size); + this.__wbg_ptr = ret >>> 0; + ChunkerFinalization.register(this, this.__wbg_ptr, this); + return this; + } + /** + * @param {Uint8Array} data + * @returns {any} + */ + add_data(data) { + const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc); + const len0 = WASM_VECTOR_LEN; + const ret = wasm.chunker_add_data(this.__wbg_ptr, ptr0, len0); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return takeFromExternrefTable0(ret[0]); + } + /** + * @returns {any} + */ + finish() { + const ret = wasm.chunker_finish(this.__wbg_ptr); + if (ret[2]) { + throw takeFromExternrefTable0(ret[1]); + } + return takeFromExternrefTable0(ret[0]); + } +} + +export function __wbg_String_8f0eb39a4a4c2f66(arg0, arg1) { + const ret = String(arg1); + const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true); +}; + +export function __wbg_buffer_609cc3eee51ed158(arg0) { + const ret = arg0.buffer; + return ret; +}; + +export function __wbg_call_672a4d21634d4a24() { return handleError(function (arg0, arg1) { + const ret = arg0.call(arg1); + return ret; +}, arguments) }; + +export function __wbg_done_769e5ede4b31c67b(arg0) { + const ret = arg0.done; + return ret; +}; + +export function __wbg_get_67b2ba62fc30de12() { return handleError(function (arg0, arg1) { + const ret = Reflect.get(arg0, arg1); + return ret; +}, arguments) }; + +export function __wbg_get_b9b93047fe3cf45b(arg0, arg1) { + const ret = arg0[arg1 >>> 0]; + return ret; +}; + +export function __wbg_getwithrefkey_1dc361bd10053bfe(arg0, arg1) { + const ret = arg0[arg1]; + return ret; +}; + +export function __wbg_instanceof_ArrayBuffer_e14585432e3737fc(arg0) { + let result; + try { + result = arg0 instanceof ArrayBuffer; + } catch (_) { + result = false; + } + const ret = result; + return ret; +}; + +export function __wbg_instanceof_Uint8Array_17156bcf118086a9(arg0) { + let result; + try { + result = arg0 instanceof Uint8Array; + } catch (_) { + result = false; + } + const ret = result; + return ret; +}; + +export function __wbg_isArray_a1eab7e0d067391b(arg0) { + const ret = Array.isArray(arg0); + return ret; +}; + +export function __wbg_isSafeInteger_343e2beeeece1bb0(arg0) { + const ret = Number.isSafeInteger(arg0); + return ret; +}; + +export function __wbg_iterator_9a24c88df860dc65() { + const ret = Symbol.iterator; + return ret; +}; + +export function __wbg_length_a446193dc22c12f8(arg0) { + const ret = arg0.length; + return ret; +}; + +export function __wbg_length_e2d2a49132c1b256(arg0) { + const ret = arg0.length; + return ret; +}; + +export function __wbg_log_c5d1a8dc098212af(arg0, arg1) { + console.log(getStringFromWasm0(arg0, arg1)); +}; + +export function __wbg_new_405e22f390576ce2() { + const ret = new Object(); + return ret; +}; + +export function __wbg_new_78feb108b6472713() { + const ret = new Array(); + return ret; +}; + +export function __wbg_new_a12002a7f91c75be(arg0) { + const ret = new Uint8Array(arg0); + return ret; +}; + +export function __wbg_next_25feadfc0913fea9(arg0) { + const ret = arg0.next; + return ret; +}; + +export function __wbg_next_6574e1a8a62d1055() { return handleError(function (arg0) { + const ret = arg0.next(); + return ret; +}, arguments) }; + +export function __wbg_set_37837023f3d740e8(arg0, arg1, arg2) { + arg0[arg1 >>> 0] = arg2; +}; + +export function __wbg_set_3f1d0b984ed272ed(arg0, arg1, arg2) { + arg0[arg1] = arg2; +}; + +export function __wbg_set_65595bdd868b3009(arg0, arg1, arg2) { + arg0.set(arg1, arg2 >>> 0); +}; + +export function __wbg_value_cd1ffa7b1ab794f1(arg0) { + const ret = arg0.value; + return ret; +}; + +export function __wbindgen_as_number(arg0) { + const ret = +arg0; + return ret; +}; + +export function __wbindgen_boolean_get(arg0) { + const v = arg0; + const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2; + return ret; +}; + +export function __wbindgen_debug_string(arg0, arg1) { + const ret = debugString(arg1); + const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + const len1 = WASM_VECTOR_LEN; + getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true); +}; + +export function __wbindgen_error_new(arg0, arg1) { + const ret = new Error(getStringFromWasm0(arg0, arg1)); + return ret; +}; + +export function __wbindgen_in(arg0, arg1) { + const ret = arg0 in arg1; + return ret; +}; + +export function __wbindgen_init_externref_table() { + const table = wasm.__wbindgen_export_4; + const offset = table.grow(4); + table.set(0, undefined); + table.set(offset + 0, undefined); + table.set(offset + 1, null); + table.set(offset + 2, true); + table.set(offset + 3, false); + ; +}; + +export function __wbindgen_is_function(arg0) { + const ret = typeof(arg0) === 'function'; + return ret; +}; + +export function __wbindgen_is_object(arg0) { + const val = arg0; + const ret = typeof(val) === 'object' && val !== null; + return ret; +}; + +export function __wbindgen_is_undefined(arg0) { + const ret = arg0 === undefined; + return ret; +}; + +export function __wbindgen_jsval_loose_eq(arg0, arg1) { + const ret = arg0 == arg1; + return ret; +}; + +export function __wbindgen_memory() { + const ret = wasm.memory; + return ret; +}; + +export function __wbindgen_number_get(arg0, arg1) { + const obj = arg1; + const ret = typeof(obj) === 'number' ? obj : undefined; + getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true); +}; + +export function __wbindgen_number_new(arg0) { + const ret = arg0; + return ret; +}; + +export function __wbindgen_string_get(arg0, arg1) { + const obj = arg1; + const ret = typeof(obj) === 'string' ? obj : undefined; + var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc); + var len1 = WASM_VECTOR_LEN; + getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true); + getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true); +}; + +export function __wbindgen_string_new(arg0, arg1) { + const ret = getStringFromWasm0(arg0, arg1); + return ret; +}; + +export function __wbindgen_throw(arg0, arg1) { + throw new Error(getStringFromWasm0(arg0, arg1)); +}; + 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 new file mode 100644 index 0000000000..86d5cfc1d1 --- /dev/null +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.base64.ts @@ -0,0 +1,1693 @@ +// 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 +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 +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 +cC90b29sY2hhaW5zL3N0YWJsZS14ODZfNjQtdW5rbm93bi1saW51eC1nbnUvbGliL3J1c3RsaWIv +c3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvc2xpY2UucnMAYAUQAHMAAAC+AQAAHQAAAC9ob21l +L2NveW90dGU1MDgvY29kZS9odWdnaW5nZmFjZS5qcy9wYWNrYWdlcy9odWIveGV0LWNvcmUtd2Fz +bS1idWlsZC9tZXJrbGVoYXNoL3NyYy9hZ2dyZWdhdGVkX2hhc2hlcy5ycwAAAOQFEABpAAAAWQAA +ADgAAAATAAAA5AUQAGkAAABZAAAADwAAAOQFEABpAAAAVgAAADkAAAAvaG9tZS9jb3lvdHRlNTA4 +Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0LXVua25vd24tbGludXgtZ251L2xpYi9y +dXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3JjL3ZlYy9zcGVjX2Zyb21faXRlcl9uZXN0 +ZWQucnMAhAYQAIcAAAA0AAAABQAAABQAAAAMAAAABAAAABUAAAAWAAAACABBvI7AAAupBgEAAAAX +AAAAYSBEaXNwbGF5IGltcGxlbWVudGF0aW9uIHJldHVybmVkIGFuIGVycm9yIHVuZXhwZWN0ZWRs +eS9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJsZS14ODZfNjQtdW5rbm93 +bi1saW51eC1nbnUvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9zcmMvc3RyaW5n +LnJzAHsHEAB0AAAA0QoAAA4AAABFcnJvcgAAAHsHEAB0AAAAfQUAABsAAAAAAAAABAAAAAQAAAAY +AAAAT2tFcnIvaG9tZS9jb3lvdHRlNTA4Ly5ydXN0dXAvdG9vbGNoYWlucy9zdGFibGUteDg2XzY0 +LXVua25vd24tbGludXgtZ251L2xpYi9ydXN0bGliL3NyYy9ydXN0L2xpYnJhcnkvYWxsb2Mvc3Jj +L3NsaWNlLnJzLQgQAHMAAAC+AQAAHQAAAAEAAAAAAAAASnNDaHVua2hhc2hsZW5ndGgAAAC/CBAA +BAAAAMMIEAAGAAAAc3RydWN0IEpzQ2h1bmthdHRlbXB0ZWQgdG8gdGFrZSBvd25lcnNoaXAgb2Yg +UnVzdCB2YWx1ZSB3aGlsZSBpdCB3YXMgYm9ycm93ZWQvaG9tZS9jb3lvdHRlNTA4Ly5jYXJnby9y +ZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2Yvd2FzbS1iaW5kZ2Vu +LTAuMi4xMDAvc3JjL2NvbnZlcnQvc2xpY2VzLnJzc3JjL2xpYi5ycwCZCRAACgAAADcAAAAUAAAA +KQkQAHAAAAAkAQAADgAAAC9ob21lL2NveW90dGU1MDgvLnJ1c3R1cC90b29sY2hhaW5zL3N0YWJs +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= +`) + .trim() + .replaceAll("\n", ""); +const wasmBinary = new Uint8Array(wasmBase64.length); +for (let i = 0; i < wasmBase64.length; i++) { + wasmBinary[i] = wasmBase64.charCodeAt(i); +} +export { wasmBinary }; 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 new file mode 100644 index 0000000000..1535d5a6fb --- /dev/null +++ b/packages/hub/src/vendor/xet-chunk/chunker_wasm_bg.wasm.d.ts @@ -0,0 +1,16 @@ +/* tslint:disable */ +/* eslint-disable */ +export const memory: WebAssembly.Memory; +export const __wbg_chunker_free: (a: number, b: number) => void; +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 __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; +export const __externref_table_alloc: () => number; +export const __wbindgen_export_4: WebAssembly.Table; +export const __externref_table_dealloc: (a: number) => void; +export const __wbindgen_free: (a: number, b: number, c: number) => void; +export const __wbindgen_start: () => void; diff --git a/packages/xetchunk-wasm/tests/bench.js b/packages/xetchunk-wasm/tests/bench.js index 736742138a..f34263cb51 100644 --- a/packages/xetchunk-wasm/tests/bench.js +++ b/packages/xetchunk-wasm/tests/bench.js @@ -8,36 +8,38 @@ const { positionals } = parseArgs({ allowPositionals: true, }); -if (!positionals[0]) { - console.error("Usage: node tests/bench.js "); - process.exit(1); -} - const BYTES = 100_000_000; const CHUNK_SIZE = 10_000_000; - -console.log(`loading first ${BYTES.toLocaleString("en-US")} bytes of data in memory`); const data = new Uint8Array(BYTES); -const stream = createReadStream(positionals[0]); -let totalRead = 0; +if (!positionals[0]) { + // Fill the data with random bytes + for (let i = 0; i < data.length; i++) { + data[i] = Math.floor(Math.random() * 256); + } +} else { + console.log(`loading first ${BYTES.toLocaleString("en-US")} bytes of data in memory`); -for await (const chunk of stream) { - data.set(chunk.slice(0, data.length - totalRead), totalRead); - totalRead += chunk.length; + const stream = createReadStream(positionals[0]); + let totalRead = 0; - if (totalRead >= data.length) { - stream.close(); - break; + for await (const chunk of stream) { + data.set(chunk.slice(0, data.length - totalRead), totalRead); + totalRead += chunk.length; + + if (totalRead >= data.length) { + stream.close(); + break; + } } -} -if (totalRead < data.length) { - console.log("not enough data, repeating in memory"); + if (totalRead < data.length) { + console.log("not enough data, repeating in memory"); - while (totalRead < data.length) { - data.set(data.slice(0, BYTES), totalRead); - totalRead += BYTES; + while (totalRead < data.length) { + data.set(data.slice(0, BYTES), totalRead); + totalRead += BYTES; + } } } @@ -48,6 +50,8 @@ console.log( ); function testAssemblyChunker() { + console.log("testing assembly Chunker"); + const start = performance.now(); const chunker = createChunker(64 * 1024); @@ -87,9 +91,8 @@ function testAssemblyChunker() { testAssemblyChunker(); -console.log("testing rust Chunker"); - function testRustChunker() { + console.log("testing rust Chunker"); const start = performance.now(); const chunker = new Chunker(64 * 1024); @@ -100,7 +103,7 @@ function testRustChunker() { let chunks = []; for (let i = 0; i < data.length; i += CHUNK_SIZE) { chunks = chunker.add_data(data.subarray(i, i + CHUNK_SIZE)); - console.log("chunks", chunks.length); + // console.log("chunks", chunks.length, chunks.slice(0, 10)); totalProcessed += CHUNK_SIZE; totalChunks += chunks.length; @@ -130,6 +133,4 @@ function testRustChunker() { testRustChunker(); -console.log("testing assembly Chunker again"); - testAssemblyChunker();