diff --git a/yarn-project/README.md b/yarn-project/README.md index df9eeeafcf7..2561fc4b85a 100644 --- a/yarn-project/README.md +++ b/yarn-project/README.md @@ -38,3 +38,5 @@ To add a new package, make sure to add it to the `build_manifest.json`, to the ` - `package.json` - `README.md` - `tsconfig.json` + +You may also need to modify the [Dockerfile](yarn-project/yarn-project-base/Dockerfile) to copy your new `package.json` into the container to get CI to pass. diff --git a/yarn-project/aztec.js/package.json b/yarn-project/aztec.js/package.json index 44e2441449b..87846f730cb 100644 --- a/yarn-project/aztec.js/package.json +++ b/yarn-project/aztec.js/package.json @@ -5,8 +5,8 @@ "type": "module", "exports": { "node": "./dest/index.js", - "default": "./dest/main.js", - "import": "./dest/index.js" + "import": "./dest/index.js", + "default": "./dest/main.js" }, "typedocOptions": { "entryPoints": [ diff --git a/yarn-project/boxes/private-token/.eslintrc.cjs b/yarn-project/boxes/private-token/.eslintrc.cjs new file mode 100644 index 00000000000..93359038995 --- /dev/null +++ b/yarn-project/boxes/private-token/.eslintrc.cjs @@ -0,0 +1,61 @@ +module.exports = { + root: true, + env: { browser: true, es2020: true }, + extends: [ + 'eslint:recommended', + 'plugin:@typescript-eslint/recommended', + 'plugin:react-hooks/recommended', + 'plugin:import/recommended', + 'plugin:import/typescript', + 'prettier', + ], + settings: { + 'import/resolver': { + typescript: true, + node: true, + }, + }, + ignorePatterns: ['dist', '.eslintrc.cjs'], + parser: '@typescript-eslint/parser', + plugins: ['react-refresh'], + overrides: [ + { + files: ['*.ts', '*.tsx'], + parserOptions: { + // hacky workaround for CI not having the same tsconfig setup + project: true, + }, + }, + ], + rules: { + 'react-refresh/only-export-components': ['warn', { allowConstantExport: true }], + '@typescript-eslint/explicit-module-boundary-types': 'off', + '@typescript-eslint/no-non-null-assertion': 'off', + '@typescript-eslint/no-explicit-any': 'off', + '@typescript-eslint/no-empty-function': 'off', + '@typescript-eslint/await-thenable': 'error', + '@typescript-eslint/no-floating-promises': 2, + '@typescript-eslint/no-unused-vars': ['error', { argsIgnorePattern: '^_', varsIgnorePattern: '^_' }], + 'require-await': 2, + 'no-console': 'warn', + 'no-constant-condition': 'off', + camelcase: 2, + 'no-restricted-imports': [ + 'error', + { + patterns: [ + { + group: ['client-dest'], + message: "Fix this absolute garbage import. It's your duty to solve it before it spreads.", + }, + { + group: ['dest'], + message: 'You should not be importing from a build directory. Did you accidentally do a relative import?', + }, + ], + }, + ], + 'import/no-unresolved': 'error', + 'import/no-extraneous-dependencies': 'error', + }, +}; diff --git a/yarn-project/boxes/private-token/.gitignore b/yarn-project/boxes/private-token/.gitignore new file mode 100644 index 00000000000..a547bf36d8d --- /dev/null +++ b/yarn-project/boxes/private-token/.gitignore @@ -0,0 +1,24 @@ +# Logs +logs +*.log +npm-debug.log* +yarn-debug.log* +yarn-error.log* +pnpm-debug.log* +lerna-debug.log* + +node_modules +dist +dist-ssr +*.local + +# Editor directories and files +.vscode/* +!.vscode/extensions.json +.idea +.DS_Store +*.suo +*.ntvs* +*.njsproj +*.sln +*.sw? diff --git a/yarn-project/boxes/private-token/.prettierrc.json b/yarn-project/boxes/private-token/.prettierrc.json new file mode 100644 index 00000000000..7c3bbec6848 --- /dev/null +++ b/yarn-project/boxes/private-token/.prettierrc.json @@ -0,0 +1,6 @@ +{ + "singleQuote": true, + "trailingComma": "all", + "printWidth": 120, + "arrowParens": "avoid" +} diff --git a/yarn-project/boxes/private-token/Dockerfile b/yarn-project/boxes/private-token/Dockerfile new file mode 100644 index 00000000000..ecdb1d7ba07 --- /dev/null +++ b/yarn-project/boxes/private-token/Dockerfile @@ -0,0 +1,15 @@ +FROM 278380418400.dkr.ecr.eu-west-2.amazonaws.com/yarn-project-base AS builder + +COPY . . + +WORKDIR /usr/src/yarn-project/boxes/private-token +RUN yarn build && yarn formatting + +# this feels wrong +RUN yarn cache clean +RUN yarn workspaces focus --production > /dev/null + +FROM node:18-alpine +COPY --from=builder /usr/src/yarn-project/boxes/private-token /usr/src/yarn-project/boxes/private-token +WORKDIR /usr/src/yarn-project/boxes/private-token +ENTRYPOINT ["yarn"] \ No newline at end of file diff --git a/yarn-project/boxes/private-token/README.md b/yarn-project/boxes/private-token/README.md new file mode 100644 index 00000000000..272fc2cdfbc --- /dev/null +++ b/yarn-project/boxes/private-token/README.md @@ -0,0 +1,95 @@ +This is a minimal [Aztec](https://aztec.network/) Noir smart contract and frontend bootstrapped with [`aztec-cli unbox`](https://github.com/AztecProtocol/aztec-packages/tree/master/yarn-project/cli). It is recommended you use the `aztec-cli unbox PrivateToken` command so that the repository is copied with needed modifications from the monorepo subpackage. + +Some contract specific settings for `PrivateToken` are in a [config](src/config.ts) will require manual updates depending on your changes to the source code. `aztec-cli` can be installed with `npm i -g @aztec/cli`, if you don't have it already. + +## Setup + +Dependencies can be installed from the root of the package: + +```bash +yarn +yarn install:noir +yarn install:sandbox +yarn build +``` + +In addition to the usual javascript dependencies, this project requires `nargo` (package manager) and `noir` (Aztec ZK smart contract language) in addition to `@aztec/aztec-cli`. + +The former are installed within `yarn install:noir` which executes + +```bash +curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash + +noirup -v aztec +``` + +This sandbox requires [Docker](https://www.docker.com/) to be installed _and running_ locally. In the event the image needs updating, you can run `yarn install:sandbox` which executes + +```bash +docker pull aztecprotocol/aztec-sandbox:latest +``` + +## Getting started + +After `yarn build` has run,`yarn start:sandbox` in one terminal will launch a local instance of the Aztec sandbox via Docker Compose and `yarn start:dev` will launch a frontend app for deploying and interacting with the PrivateToken contract. + +At this point, [http://localhost:5173](http://localhost:5173) should provide a minimal smart contract frontend. + +This folder should have the following directory structure: + +``` +|— README.md +|— package.json +|— src + |-config.ts - PrivateToken specific configuration for the frontend. + | You may need to update this if you modify the contract functions. + |— app + |— [frontend React .tsx code files] + |- scripts + |- [helpers for frontend to interact with contract on the sandbox] + |— contracts + |— src + | The Noir smart contract source files are here. + |— main.nr - the cloned noir contract, your starting point + |- interface.nr - autogenerated from main.nr when you compile + |— Nargo.toml [Noir build file, includes Aztec smart contract dependencies] + |— artifacts + | These are both generated from `contracts/` by the compile command + |— private_token_contract.json + |— private_token.ts + |— tests + | A simple end2end test deploying and testing the PrivateToken on a local sandbox + | using the front end helper methods in app/scripts/ + | The test requires the sandbox and anvil to be running (yarn start:sandbox). + |- privatetoken.test.ts +``` + +Most relevant to you is likely `src/contracts/main.nr` (and the build config `src/contracts/Nargo.toml`). This contains the example PrivateToken logic that the frontend interacts with and is a good place to start writing Noir. + +The `src/artifacts` folder can be re-generated from the command line with `yarn compile` which is an alias for + +```bash +aztec-cli compile src/contracts --outdir ../artifacts --typescript ../artifacts +``` + +This will generate a [Contract ABI](https://www.alchemy.com/overviews/what-is-an-abi-of-a-smart-contract-examples-and-usage) and TypeScript class for the Aztec smart contract in `src/contracts/main.nr`, which the frontend uses to generate the UI. + +Note: the `compile` command seems to generate a Typescript file which needs a single change - + +``` +import PrivateTokenContractAbiJson from 'PrivateToken.json' assert { type: 'json' }; +// need to update the relative import to +import PrivateTokenContractAbiJson from './PrivateToken.json' assert { type: 'json' }; +``` + +After compiling, you can re-deploy the upated noir smart contract from the web UI. The function interaction forms are generated from parsing the ContractABI, so they should update automatically after you recompile. + +## Learn More + +To learn more about Noir Smart Contract development, take a look at the following resources: + +- [Awesome Noir](https://github.com/noir-lang/awesome-noir) - learn about the Noir programming language. + +## Deploy on Aztec3 + +Coming Soon :) diff --git a/yarn-project/boxes/private-token/package.json b/yarn-project/boxes/private-token/package.json new file mode 100644 index 00000000000..730dcde145d --- /dev/null +++ b/yarn-project/boxes/private-token/package.json @@ -0,0 +1,96 @@ +{ + "name": "private-token", + "private": true, + "version": "0.1.0", + "type": "module", + "main": "./dest/index.js", + "scripts": { + "build": "yarn clean && webpack", + "install:noir": "curl -L https://raw.githubusercontent.com/noir-lang/noirup/main/install | bash noirup -v aztec", + "install:sandbox": "docker pull aztecprotocol/aztec-sandbox:latest", + "clean": "rm -rf ./dest .tsbuildinfo", + "start": "serve -p 3000 ./dest", + "start:dev": "webpack serve --mode=development", + "start:sandbox": "SANDBOX_VERSION=latest /bin/bash -c \"$(curl -fsSL 'https://sandbox.aztec.network')\" ", + "formatting": "prettier --check ./src && eslint ./src", + "formatting:fix": "prettier -w ./src", + "compile": "aztec-cli compile src/contracts --outdir ../artifacts --typescript ../artifacts", + "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules $(yarn bin jest) --runInBand", + "test:integration": "concurrently -k -s first -c reset,dim -n test,anvil \"yarn test\" \"anvil\"" + }, + "jest": { + "preset": "ts-jest/presets/default-esm", + "globals": { + "ts-jest": { + "useESM": true + } + }, + "transform": { + "^.+\\.(ts|tsx)$": "ts-jest" + }, + "moduleNameMapper": { + "^(\\.{1,2}/.*)\\.js$": "$1" + }, + "testRegex": "./src/.*\\.test\\.ts$", + "rootDir": "./src" + }, + "dependencies": { + "@aztec/aztec.js": "workspace:^", + "@aztec/circuits.js": "workspace:^", + "@aztec/cli": "workspace:^", + "@aztec/foundation": "workspace:^", + "formik": "^2.4.3", + "react": "^18.2.0", + "react-dom": "^18.2.0", + "serve": "^14.2.1", + "tailwindcss": "^3.3.3", + "yup": "^1.2.0" + }, + "devDependencies": { + "@types/node": "^20.5.9", + "@types/react": "^18.2.15", + "@types/react-dom": "^18.2.7", + "@typescript-eslint/eslint-plugin": "^6.0.0", + "@typescript-eslint/parser": "^6.0.0", + "autoprefixer": "^10.4.15", + "copy-webpack-plugin": "^11.0.0", + "css-loader": "^6.8.1", + "eslint": "^8.45.0", + "eslint-import-resolver-typescript": "^3.5.5", + "eslint-plugin-import": "^2.27.5", + "eslint-plugin-react-hooks": "^4.6.0", + "eslint-plugin-react-refresh": "^0.4.3", + "jest": "^29.6.4", + "postcss": "^8.4.29", + "postcss-loader": "^7.3.3", + "prettier": "^3.0.3", + "resolve-typescript-plugin": "^2.0.1", + "style-loader": "^3.3.3", + "ts-jest": "^29.1.0", + "ts-loader": "^9.4.4", + "ts-node": "^10.9.1", + "typescript": "^5.0.4", + "util": "^0.12.5", + "webpack": "^5.88.2", + "webpack-cli": "^5.1.4", + "webpack-dev-server": "^4.15.1" + }, + "browserslist": { + "production": [ + ">0.5%", + "not dead", + "not op_mini all" + ], + "development": [ + "last 1 chrome version", + "last 1 firefox version", + "last 1 safari version" + ] + }, + "files": [ + "dest", + "src", + "!*.test.*" + ], + "types": "./dest/index.d.ts" +} diff --git a/yarn-project/boxes/private-token/postcss.config.cjs b/yarn-project/boxes/private-token/postcss.config.cjs new file mode 100644 index 00000000000..95cd618b13f --- /dev/null +++ b/yarn-project/boxes/private-token/postcss.config.cjs @@ -0,0 +1,6 @@ +const tailwindcss = require('tailwindcss'); +const autoprefixer = require('autoprefixer'); + +module.exports = { + plugins: [tailwindcss('./tailwind.config.cjs'), autoprefixer], +}; diff --git a/yarn-project/boxes/private-token/src/@types/index.d.ts b/yarn-project/boxes/private-token/src/@types/index.d.ts new file mode 100644 index 00000000000..091d25e2101 --- /dev/null +++ b/yarn-project/boxes/private-token/src/@types/index.d.ts @@ -0,0 +1,4 @@ +declare module '*.svg' { + const content: any; + export default content; +} diff --git a/yarn-project/boxes/private-token/src/app/components/banner.tsx b/yarn-project/boxes/private-token/src/app/components/banner.tsx new file mode 100644 index 00000000000..6157e1c93d1 --- /dev/null +++ b/yarn-project/boxes/private-token/src/app/components/banner.tsx @@ -0,0 +1,43 @@ +interface Props { + background: string; + direction: string; + animated?: boolean; +} + +/** + * + * @param background - background color, either "black" or "purple" + * @returns a moving banner repeating the word PRIVACY + */ +export function Banner({ background, direction, animated }: Props) { + // Determine direction + const start = !animated ? '' : direction === 'reverse' ? 'animate-marquee' : 'animate-marquee3'; + const end = !animated ? '' : direction === 'reverse' ? 'animate-marquee2' : 'animate-marquee4'; + + // Apply relevant color styles + const containerStyles = + background === 'black' + ? `relative flex overflow-x-hidden bg-indigo-950 text-orange-100` + : `relative flex overflow-x-hidden bg-orange-100 text-indigo-950`; + + return ( +
+
+ {/* Generate text elements */} + {Array.from({ length: 50 }, (_, index) => ( + + PRIVACY + + ))} +
+
+ {/* Generate text elements */} + {Array.from({ length: 50 }, (_, index) => ( + + PRIVACY + + ))} +
+
+ ); +} diff --git a/yarn-project/boxes/private-token/src/app/components/button.tsx b/yarn-project/boxes/private-token/src/app/components/button.tsx new file mode 100644 index 00000000000..4ac24cadb53 --- /dev/null +++ b/yarn-project/boxes/private-token/src/app/components/button.tsx @@ -0,0 +1,28 @@ +import { Spinner } from './spinner.js'; + +interface Props { + children: string; + isLoading?: boolean; + disabled?: boolean; + onClick?: () => void; +} + +export function Button({ children, isLoading, disabled, onClick }: Props) { + return ( + + ); +} diff --git a/yarn-project/boxes/private-token/src/app/components/contract_function_form.tsx b/yarn-project/boxes/private-token/src/app/components/contract_function_form.tsx new file mode 100644 index 00000000000..89dade558b9 --- /dev/null +++ b/yarn-project/boxes/private-token/src/app/components/contract_function_form.tsx @@ -0,0 +1,168 @@ +import { AztecAddress, CompleteAddress, Fr } from '@aztec/aztec.js'; +import { ContractAbi, FunctionAbi } from '@aztec/foundation/abi'; +import { useFormik } from 'formik'; +import * as Yup from 'yup'; +import { CONTRACT_ADDRESS_PARAM_NAMES, DEFAULT_PUBLIC_ADDRESS, rpcClient } from '../../config.js'; +import { callContractFunction, deployContract, viewContractFunction } from '../../scripts/index.js'; +import { convertArgs } from '../../scripts/util.js'; +import { Button } from './index.js'; + +type NoirFunctionYupSchema = { + // hack: add `any` at the end to get the array schema to typecheck + // eslint-disable-next-line @typescript-eslint/no-explicit-any + [key: string]: Yup.NumberSchema | Yup.ArraySchema | Yup.BooleanSchema | any; +}; + +type NoirFunctionFormValues = { + [key: string]: string | number | number[] | boolean; +}; + +function generateYupSchema(functionAbi: FunctionAbi) { + const parameterSchema: NoirFunctionYupSchema = {}; + const initialValues: NoirFunctionFormValues = {}; + for (const param of functionAbi.parameters) { + if (CONTRACT_ADDRESS_PARAM_NAMES.includes(param.name)) { + // these are hex strings instead, but yup doesn't support bigint so we convert back to bigint on execution + parameterSchema[param.name] = Yup.string().required(); + initialValues[param.name] = DEFAULT_PUBLIC_ADDRESS; + continue; + } + switch (param.type.kind) { + case 'field': + parameterSchema[param.name] = Yup.number().required(); + initialValues[param.name] = 100; + break; + // not really needed for private token, since we hide the nullifier helper method which has the array input + case 'array': + // eslint-disable-next-line no-case-declarations + const arrayLength = param.type.length; + parameterSchema[param.name] = Yup.array() + .of(Yup.number()) + .min(arrayLength) + .max(arrayLength) + .transform(function (value: number[], originalValue: string) { + if (typeof originalValue === 'string') { + return originalValue.split(',').map(Number); + } + return value; + }); + initialValues[param.name] = Array(arrayLength).fill( + CONTRACT_ADDRESS_PARAM_NAMES.includes(param.name) ? DEFAULT_PUBLIC_ADDRESS : 200, + ); + break; + case 'boolean': + parameterSchema[param.name] = Yup.boolean().required(); + initialValues[param.name] = false; + break; + } + } + return { validationSchema: Yup.object().shape(parameterSchema), initialValues }; +} + +async function handleFunctionCall( + contractAddress: AztecAddress | undefined, + contractAbi: ContractAbi, + functionName: string, + args: any, + wallet: CompleteAddress, +) { + const functionAbi = contractAbi.functions.find(f => f.name === functionName)!; + const typedArgs: any[] = convertArgs(functionAbi, args); + + if (functionName === 'constructor' && !!wallet) { + if (functionAbi === undefined) { + throw new Error('Cannot find constructor in the ABI.'); + } + // hack: addresses are stored as string in the form to avoid bigint compatibility issues with formik + // convert those back to bigints before sending + + // for now, dont let user change the salt. requires some change to the form generation if we want to let user choose one + // since everything is currently based on parsing the contractABI, and the salt parameter is not present there + const salt = Fr.random(); + return await deployContract(wallet, contractAbi, typedArgs, salt, rpcClient); + } + + if (functionAbi.functionType === 'unconstrained') { + return await viewContractFunction(contractAddress!, contractAbi, functionName, typedArgs, rpcClient, wallet); + } else { + return await callContractFunction(contractAddress!, contractAbi, functionName, typedArgs, rpcClient, wallet); + } +} + +interface ContractFunctionFormProps { + wallet: CompleteAddress; + contractAddress?: AztecAddress; + contractAbi: ContractAbi; + functionAbi: FunctionAbi; + title?: string; + buttonText?: string; + isLoading: boolean; + disabled: boolean; + onSubmit: () => void; + onSuccess: (result: any) => void; + onError: (msg: string) => void; +} + +export function ContractFunctionForm({ + wallet, + contractAddress, + contractAbi, + functionAbi, + title, + buttonText = 'Submit', + isLoading, + disabled, + onSubmit, + onSuccess, + onError, +}: ContractFunctionFormProps) { + const { validationSchema, initialValues } = generateYupSchema(functionAbi); + const formik = useFormik({ + initialValues: initialValues, + validationSchema: validationSchema, + onSubmit: async (values: any) => { + onSubmit(); + try { + const result = await handleFunctionCall(contractAddress, contractAbi, functionAbi.name, values, wallet); + onSuccess(result); + } catch (e: any) { + onError(e.message); + } + }, + }); + + return ( +
+

{title || `${functionAbi.name} (${functionAbi.functionType})`}

+
+
+ {functionAbi.parameters.map(input => ( +
+ +
+ +
+ {formik.touched[input.name] && formik.errors[input.name] && ( +
{formik.errors[input.name]?.toString()}
+ )} +
+ ))} +
+
+ +
+
+
+ ); +} diff --git a/yarn-project/boxes/private-token/src/app/components/index.ts b/yarn-project/boxes/private-token/src/app/components/index.ts new file mode 100644 index 00000000000..e1b6f869eb0 --- /dev/null +++ b/yarn-project/boxes/private-token/src/app/components/index.ts @@ -0,0 +1,5 @@ +export * from './banner.js'; +export * from './button.js'; +export * from './contract_function_form.js'; +export * from './popup.js'; +export * from './spinner.js'; diff --git a/yarn-project/boxes/private-token/src/app/components/popup.tsx b/yarn-project/boxes/private-token/src/app/components/popup.tsx new file mode 100644 index 00000000000..c4214c94400 --- /dev/null +++ b/yarn-project/boxes/private-token/src/app/components/popup.tsx @@ -0,0 +1,42 @@ +import { Button } from './button.js'; + +interface Props { + children: string; + buttonText?: string; + isWarning?: boolean; + onClose?: () => void; +} + +export function Popup({ children, buttonText = 'Close', isWarning = false, onClose }: Props) { + return ( +
+
+
+
+
+ {isWarning && ( + + )} +
{children}
+ +
+
+
+
+
+ ); +} diff --git a/yarn-project/boxes/private-token/src/app/components/spinner.tsx b/yarn-project/boxes/private-token/src/app/components/spinner.tsx new file mode 100644 index 00000000000..10fc7bb60ff --- /dev/null +++ b/yarn-project/boxes/private-token/src/app/components/spinner.tsx @@ -0,0 +1,20 @@ +export function Spinner() { + return ( + + ); +} diff --git a/yarn-project/boxes/private-token/src/app/components/wallet_dropdown.tsx b/yarn-project/boxes/private-token/src/app/components/wallet_dropdown.tsx new file mode 100644 index 00000000000..deff55b6ffd --- /dev/null +++ b/yarn-project/boxes/private-token/src/app/components/wallet_dropdown.tsx @@ -0,0 +1,58 @@ +import { CompleteAddress } from '@aztec/aztec.js'; +import { useEffect, useState } from 'react'; +import { rpcClient } from '../../config.js'; + +interface Props { + selected: CompleteAddress | undefined; + onSelectChange: (value: CompleteAddress) => void; + onError: (msg: string) => void; +} + +export function WalletDropdown({ selected, onSelectChange, onError }: Props) { + const [wallets, setOptions] = useState(); + + useEffect(() => { + if (wallets) { + return; + } + const loadOptions = async () => { + const fetchedOptions = await rpcClient.getAccounts(); + setOptions(fetchedOptions); + onSelectChange(fetchedOptions[0]); + }; + loadOptions().catch(e => { + setOptions([]); + onError(e.message); + }); + }); + + return ( +
+
+
+ {'Active Wallet: '} + {!wallets && 'loading...'} +
+ {!!wallets && ( + + )} +
+ {!!selected &&
{selected.address.toString()}
} +
+ ); +} diff --git a/yarn-project/boxes/private-token/src/app/contract.tsx b/yarn-project/boxes/private-token/src/app/contract.tsx new file mode 100644 index 00000000000..4108b0b38d2 --- /dev/null +++ b/yarn-project/boxes/private-token/src/app/contract.tsx @@ -0,0 +1,91 @@ +import { AztecAddress, CompleteAddress } from '@aztec/aztec.js'; +import { FunctionAbi } from '@aztec/foundation/abi'; +import { useState } from 'react'; +import { FILTERED_FUNCTION_NAMES, contractAbi } from '../config.js'; +import { ContractFunctionForm, Popup } from './components/index.js'; + +const functionTypeSortOrder = { + secret: 0, + open: 1, + unconstrained: 2, +}; + +interface Props { + wallet: CompleteAddress; + onDeploy: () => void; +} + +export function Contract({ wallet, onDeploy }: Props) { + const [contractAddress, setContractAddress] = useState(); + const [processingFunction, setProcessingFunction] = useState(''); + const [errorMsg, setError] = useState(''); + const [result, setResult] = useState(''); + + const handleSubmitForm = (functionName: string) => setProcessingFunction(functionName); + const handleContractDeployed = (address: AztecAddress) => { + setContractAddress(address); + setResult(`Contract deployed at: ${address}`); + }; + const handleResult = (returnValues: any) => { + // TODO: Serialise returnValues to string according to the returnTypes defined in the function abi. + setResult(`Return values: ${returnValues}`); + }; + const handleClosePopup = () => { + setResult(''); + setError(''); + setProcessingFunction(''); + onDeploy(); + }; + + const constructorAbi = contractAbi.functions.find(f => f.name === 'constructor')!; + const hasResult = !!(result || errorMsg); + + return ( +
+
+
{`${contractAbi.name} Noir Smart Contract`}
+ {!!contractAddress &&
{`Contract address: ${contractAddress}`}
} +
+ {!contractAddress && ( + handleSubmitForm('constructor')} + onSuccess={handleContractDeployed} + onError={setError} + /> + )} + {!!contractAddress && ( +
+ {contractAbi.functions + .filter(f => f.name !== 'constructor' && !f.isInternal && !FILTERED_FUNCTION_NAMES.includes(f.name)) + .sort((a, b) => functionTypeSortOrder[a.functionType] - functionTypeSortOrder[b.functionType]) + .map((functionAbi: FunctionAbi) => ( + handleSubmitForm(functionAbi.name)} + onSuccess={handleResult} + onError={setError} + /> + ))} +
+ )} + {!!(errorMsg || result) && ( + + {errorMsg || result} + + )} +
+ ); +} diff --git a/yarn-project/boxes/private-token/src/app/home.tsx b/yarn-project/boxes/private-token/src/app/home.tsx new file mode 100644 index 00000000000..5eab48a1308 --- /dev/null +++ b/yarn-project/boxes/private-token/src/app/home.tsx @@ -0,0 +1,68 @@ +import { CompleteAddress } from '@aztec/aztec.js'; +import { useState } from 'react'; +import { Banner, Spinner } from './components/index.js'; +import { WalletDropdown } from './components/wallet_dropdown.js'; +import { Contract } from './contract.js'; + +const ANIMATED_BANNER = true; + +export function Home() { + const [isLoadingWallet, setIsLoadingWallet] = useState(true); + const [selectedWallet, setSelectedWallet] = useState(); + const [selectWalletError, setSelectedWalletError] = useState(''); + const [isContractDeployed, setIsContractDeployed] = useState(false); + + const handleSelectWallet = (address: CompleteAddress | undefined) => { + setSelectedWallet(address); + setIsLoadingWallet(false); + }; + + const handleSelectWalletError = (msg: string) => { + setSelectedWalletError(msg); + setIsLoadingWallet(false); + }; + + return ( +
+
+ + +
+ +
+
+
+ Aztec +
+
+ +
+
+
+ {isLoadingWallet && ( +
+ +
+ )} + {!isLoadingWallet && !!selectedWallet && ( +
+ {!!selectWalletError && `Failed to load accounts: ${selectWalletError}`} + {!selectWalletError && setIsContractDeployed(true)}/>} +
+ )} + {!isLoadingWallet && !selectedWallet && `${selectWalletError} ${selectedWallet}`} +
+
+ +
+
+ + +
+
+ ); +} diff --git a/yarn-project/boxes/private-token/src/app/index.css b/yarn-project/boxes/private-token/src/app/index.css new file mode 100644 index 00000000000..84cd8b41763 --- /dev/null +++ b/yarn-project/boxes/private-token/src/app/index.css @@ -0,0 +1,60 @@ +@tailwind base; +@tailwind components; +@tailwind utilities; + +:root { + font-family: Inter, system-ui, Avenir, Helvetica, Arial, sans-serif; + line-height: 1.5; + font-weight: 400; + + color-scheme: light dark; + color: rgba(255, 255, 255, 0.87); + background-color: #242424; + + font-synthesis: none; + text-rendering: optimizeLegibility; + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; + -webkit-text-size-adjust: 100%; + overflow-x: hidden; + + --foreground-rgb: 0, 0, 0; + --background-start-rgb: 214, 219, 220; + --background-end-rgb: 255, 255, 255; +} + +body { + color: rgb(var(--foreground-rgb)); + background: linear-gradient(to bottom, transparent, rgb(var(--background-end-rgb))) rgb(var(--background-start-rgb)); +} + +#root { + width: 100%; + max-width: 1280px; + margin: 0 auto; + padding: 0rem; + text-align: center; +} + +body { + margin: 0; + display: flex; + place-items: center; + min-width: 320px; + min-height: 100vh; +} + +@media (prefers-color-scheme: dark) { + :root { + --foreground-rgb: 255, 255, 255; + --background-start-rgb: 0, 0, 0; + --background-end-rgb: 0, 0, 0; + } +} + +@media (prefers-color-scheme: light) { + :root { + color: #213547; + background-color: #ffffff; + } +} diff --git a/yarn-project/boxes/private-token/src/app/index.html b/yarn-project/boxes/private-token/src/app/index.html new file mode 100644 index 00000000000..57ece0ccf91 --- /dev/null +++ b/yarn-project/boxes/private-token/src/app/index.html @@ -0,0 +1,13 @@ + + + + + + + Private Token Noir Smart Contract + + +
+ + + diff --git a/yarn-project/boxes/private-token/src/app/index.tsx b/yarn-project/boxes/private-token/src/app/index.tsx new file mode 100644 index 00000000000..c5f7c020418 --- /dev/null +++ b/yarn-project/boxes/private-token/src/app/index.tsx @@ -0,0 +1,11 @@ +import * as React from 'react'; +import * as ReactDOM from 'react-dom/client'; +import { Home } from './home.js'; +import './index.css'; + +const root = ReactDOM.createRoot(document.getElementById('root') as HTMLElement); +root.render( + + + , +); diff --git a/yarn-project/boxes/private-token/src/artifacts/PrivateToken.ts b/yarn-project/boxes/private-token/src/artifacts/PrivateToken.ts new file mode 100644 index 00000000000..09f9be3854e --- /dev/null +++ b/yarn-project/boxes/private-token/src/artifacts/PrivateToken.ts @@ -0,0 +1,106 @@ +/* Autogenerated file, do not edit! */ + +/* eslint-disable */ +import { + AztecAddress, + CompleteAddress, + ContractBase, + ContractFunctionInteraction, + ContractMethod, + DeployMethod, + FieldLike, + Wallet, +} from '@aztec/aztec.js'; +import { ContractAbi } from '@aztec/foundation/abi'; +import { Point } from '@aztec/foundation/fields'; +import { AztecRPC, PublicKey } from '@aztec/types'; + +import PrivateTokenContractAbiJson from './private_token_contract.json' assert { type: 'json' }; + +export const PrivateTokenContractAbi = PrivateTokenContractAbiJson as unknown as ContractAbi; + +/** + * Type-safe interface for contract PrivateToken; + */ +export class PrivateTokenContract extends ContractBase { + private constructor( + /** The deployed contract's complete address. */ + completeAddress: CompleteAddress, + /** The wallet. */ + wallet: Wallet, + ) { + super(completeAddress, PrivateTokenContractAbi, wallet); + } + + /** + * Creates a contract instance. + * @param address - The deployed contract's address. + * @param wallet - The wallet to use when interacting with the contract. + * @returns A promise that resolves to a new Contract instance. + */ + public static async at( + /** The deployed contract's address. */ + address: AztecAddress, + /** The wallet. */ + wallet: Wallet, + ) { + const extendedContractData = await wallet.getExtendedContractData(address); + if (extendedContractData === undefined) { + throw new Error('Contract ' + address.toString() + ' is not deployed'); + } + return new PrivateTokenContract(extendedContractData.getCompleteAddress(), wallet); + } + + /** + * Creates a tx to deploy a new instance of this contract. + */ + public static deploy(rpc: AztecRPC, initial_supply: FieldLike, owner: FieldLike) { + return new DeployMethod( + Point.ZERO, + rpc, + PrivateTokenContractAbi, + Array.from(arguments).slice(1), + ); + } + + /** + * Creates a tx to deploy a new instance of this contract using the specified public key to derive the address. + */ + public static deployWithPublicKey(rpc: AztecRPC, publicKey: PublicKey, initial_supply: FieldLike, owner: FieldLike) { + return new DeployMethod( + publicKey, + rpc, + PrivateTokenContractAbi, + Array.from(arguments).slice(2), + ); + } + + /** + * Returns this contract's ABI. + */ + public static get abi(): ContractAbi { + return PrivateTokenContractAbi; + } + + /** Type-safe wrappers for the public methods exposed by the contract. */ + public methods!: { + /** compute_note_hash_and_nullifier(contract_address: field, nonce: field, storage_slot: field, preimage: array) */ + compute_note_hash_and_nullifier: (( + contract_address: FieldLike, + nonce: FieldLike, + storage_slot: FieldLike, + preimage: FieldLike[], + ) => ContractFunctionInteraction) & + Pick; + + /** getBalance(owner: field) */ + getBalance: ((owner: FieldLike) => ContractFunctionInteraction) & Pick; + + /** mint(amount: field, owner: field) */ + mint: ((amount: FieldLike, owner: FieldLike) => ContractFunctionInteraction) & Pick; + + /** transfer(amount: field, recipient: field) */ + transfer: ((amount: FieldLike, recipient: FieldLike) => ContractFunctionInteraction) & + Pick; + }; +} diff --git a/yarn-project/boxes/private-token/src/artifacts/private_token_contract.json b/yarn-project/boxes/private-token/src/artifacts/private_token_contract.json new file mode 100644 index 00000000000..83ba8d8f7fa --- /dev/null +++ b/yarn-project/boxes/private-token/src/artifacts/private_token_contract.json @@ -0,0 +1,158 @@ +{ + "name": "PrivateToken", + "functions": [ + { + "name": "compute_note_hash_and_nullifier", + "functionType": "unconstrained", + "isInternal": false, + "parameters": [ + { + "name": "contract_address", + "type": { + "kind": "field" + }, + "visibility": "private" + }, + { + "name": "nonce", + "type": { + "kind": "field" + }, + "visibility": "private" + }, + { + "name": "storage_slot", + "type": { + "kind": "field" + }, + "visibility": "private" + }, + { + "name": "preimage", + "type": { + "kind": "array", + "length": 3, + "type": { + "kind": "field" + } + }, + "visibility": "private" + } + ], + "returnTypes": [ + { + "kind": "array", + "length": 4, + "type": { + "kind": "field" + } + } + ], + "bytecode": "H4sIAAAAAAAA/+3dWVcURxQH8J4VegYQhwHcdxHFZYYBxX3cQAUVwQ03UILGxGgk5iFPfsF8g7zlPR8gb7EqfZ0/xaTPcLxl/+ec1Dkcuqd6qn73VnVNT7t0MQiCVPBvyXz+yQbri9TXo9+VryvVlF5bFZ/OdJs4M4rOVDQPfHqzHvKqbcy1gTGvPO5ilDWg4/NP5+ef8PNPIWiUqegA83ouek3mTAjvT8NrGScHIdRLycN2XSeuWl4/75Vc5A/gN8bbE8XSodvvaOjkCPPp5i2A/vPgVLLUTHudG7CEYCnoWiqmzaJym6aNLvBLrGIvQn0RYuvSddjPyoKTU9nvgn7/j1+137aKH9fnfMKWIhg6/VlqxeDbzAPMrbRtPt+Goc9u5dhMm73KcZix6wka5RPE1Qux+Oh3k9Nvt9NvyhnDT2CV92bgmD8yjXGQi6uCE4f89rEulIJGkT6L4NgcbZfA0afrqJo2yk0cfeCQ/svg6Nd1jJo2Bpo4+sEh/Q+AY1DZEToOU+KuRwbBstWDZcsGLFvBst2DZdsGLNvBstODZccGLDvBstuDZdcGLLvBsteDZc8GLNK/ed++aBvPrf26Pvu5v8+xyL70VQTDZo+WYpO+MQ9bCPIghlKCedhGkAcxlBPMww6CPIghnWAedhHkQQyZBPOwhyAPYsh+4zx46KcWOjGbEvfZhZYDuhZ7bX4Q+hLXAci91ONn1EHl3KegT2lX9tHXqrXURtZywlYf88q0OaTbpr3mw5yaEnfeDEF8h3QtNfO92twrlnGV9t3c4ueXj+/VhyFe6RO/V8s9l8PgOKLrsOOCDlPixuUIWEZ0LTYnR6EvcY1AbqQeP0uO6jrseTfixC/76GvVOpyw1dcaoRyLnYsYiylxcxHjO6ZskTVCxlXalzyK0/cacQLixbllilkjjkfbJ8BRUc5F6DhMiRuXCliquhbb9Cj0Ja4q5EbqcWxGdR32vKs68cs++lq1Hk/Y6mGsxkybNd027VzEnJoSNxdrEN+YskXWCBlXad/Nre814iTEK33iGjEebZ8ExynlXISOw5S4cTkFlgldi83JaehLXBOQG6nH7+andR32vJtw4pd99LVqHU/Y6mGs7J/9ndFt085FzKkpcXPxDMR3Vtkia4SMq7Tv5tb3GnEe4pU+cY04F22f/0YOc/2ecRwZqB9KNY77HUwXdU32fs6FYG2JmysXwVLXtdj8XIK+LjjtF6Ee7+dc0nWs+fuq0q7so69Va6mNrOWErb6+qynHYtdYjMWUuPMG47usa/lyP0fGVdp38+h7jb0arI8d19gr0fZVcFzTddhxQYcpceNyDSyTuhabkynoS1yTkBupx/s5U7oOe95NOvHLPvpatV5J2OprjVCOxc5FjMWUuLmI8V1XtsgaIeMq7Usexel7jbgJ8eLcMsWsETei7ZvgmFbOReg4TIkbl2mwzOhabE5uQV/imoHcSD2OzS1dhz3vZpz4ZR99rVpvJGz1dT9HORY7FzEWU+LmIsZ3W9kia4SMq7QveRSn7zViFuLFuWWKWSPuRNuz4LirnIvQcZgSNy53wTKna7E5mYe+xDUHuZF6vJ8zr+uw592cE7/so69V652Erb7u5yjHYucixmJK3FzE+O4pW2SNkHGV9iWP4vS9RjyAeHFumWLWiPvRthwXwrbUmWvuB6mG85Gu095beRisLXHj9ghytqBrsTl7DH2JawFyJ/V4b+WxrsOelwtO/LKPvlatpTaylhO2+vrepByLXe8wFlPizhuM74mu5cu9FRlXaV/yKE7f690ziBfnlilmvXsabT8Dx3Ndhx0XdJgSNy7PwbKoa7E5WYK+xLUIuZF6vLeypOuw592iE7/sL8HrrVqfJmz1tUYox2LnIsZiStxcXIL4XihbZI2QcZX2JY/i9L1GLEO8OLdMMWvEy2hbjsNrIqnDa6IitIf2ZV17NW7cloP1lgyRJUtkyRFZ8kSWDiJLJ5ElJLIUiCxFIksXkaWbyNJDZNlEZOklsmwmspSILH1EljKRpZ/IMkBkGSSybCGybCWybCOybCey7CCy7CSy7CKy7Cay7CGy7CWy7COy7CeyHCCyHCSyDBFZDhFZhoksh4ksR4gsI0SWo0SWY0SW40SWE0SWCpGlSmQZJbLUiCxjRJZxIstJIsspIssEkeU0keUMkeUskeUckeU8keUCkeUikaVOZLlEZLlMZLlCZLlKZLlGZJkkskwRWa4TWW4QWW4SWaaJLDNElltElttEljtEllkiy10iyxyRZZ7Ico/Icp/I8oDI8pDI8ojIskBkeUxkeUJkeUpkeUZkeU5kWSSyLBFZXhBZXhJZUglbwmD9v3ULob4Er6Wd95p/I/R3plG/Er2ehve8irYzTdpegde+i7ZfNXkv5mjFiaXydcXmCPupw770VQDDKwLLSyLLCyLLEpFlkcjynMjyjMjylMjyhMjymMiyQGR5RGR5SGR5QGS5T2S5R2SZJ7LMEVnuEllmiSx3iCy3iSy3iCwzRJZpIstNIssNIst1IssUkWWSyHKNyHKVyHKFyHKZyHKJyFInslwkslwgspwnspwjspwlspwhspwmskwQWU4RWU4SWcaJLGNElhqRZZTIUiWyVIgsJ4gsx4ksx4gsR4ksI0SWI0SWw0SWYSLLISLLEJHlIJHlAJFlP5FlH5FlL5FlD5FlN5FlF5FlJ5FlB5FlO5FlG5FlK5FlC5FlkMgyQGTpJ7KUiSx9RJYSkWUzkaWXyLKJyNJDZOkmsnQRWYpElgKRJSSydBJZOogseSJLjsiSJbJkiCzpJpbXupYa/nuyAExY6rD9Gizf61rsHwu9gb7EJf0UoR7/rfsbXYcdn++d+GUffa1al9vI+l3CVtOvj2cZKsdin2WIsZgSd95gfD/oWr4871TGVdqXPIozDQYfzzJ8C/Hi3DLFrGc/RttvwfGTrmMsdBymxI3LT2B5p2uxOXkPfYnrHeRG6vH/Zn6v67Dn3TsnftlHX6vW8Taynmsj648JW0N47S28lnbMZq0pwH4e2v0ZtuUaswC/3zvHmfd+0I3VXtOgw5S4NeADWH7RtVRMvx+h/Tr0gf3+qttvFftNRT/Sh7yege2/5MIXjjNFxljMZgxXmxyH2z877ylC/arnmH8BRx32pS/zXeNPiHW1ibsAbql/D+4+Zbdp4wM4pH/pJ3TyJr+V56rN36qTP9nHscw7+fJgqRWb9B1CbiRfZjyHwSYFr3UyHvIUOHmSkmliSSVs+a//eyTj5ArXeqkza3g926jPNnmPHJsN1h+Hsec8xI791GEfP3tSji9JS7qJJa9rsdedct8rCNY+e1scYsLnLHcq58S0ETZxdIJD+sfnGhd0Hfav4TZ7Fjlel0j/+BzhLl2HvS5Bhylx5y8+R7hb12LnSA/0Ja5u2Jf6HDh6dB32vOl24pd99LVq7Wgja5iw1cO8emXa3KTbpr3Xgjk1Je68wWc79+pavtxrkXGV9t3c4vWHj/W91Ah3zXiagn/ejMfJdhbq8fNe6qvZRkwernfteKLLlLjxlP7N54asia9XPs6vLK+ufJxe+S0FbZScuNLQTg62cZ3wMT790Bc+x9oU/Dsb+PxkH5+/A00c+Pkr/ctxIWyX4bVBx4vXivhe+WyV4zui2LK6sdWwLylxcygLscMcmv315ds3y84cknYzTdrF696ccxzmBK+vXJfaAOcBmI4g2ajzfJPgO6IE4BcpU/4B/5C962HKAAA=", + "verificationKey": "0000000200000800000000740000000f00000003515f3109623eb3c25aa5b16a1a79fd558bac7a7ce62c4560a8c537c77ce80dd339128d1d37b6582ee9e6df9567efb64313471dfa18f520f9ce53161b50dbf7731bc5f900000003515f322bc4cce83a486a92c92fd59bd84e0f92595baa639fc2ed86b00ffa0dfded2a092a669a3bdb7a273a015eda494457cc7ed5236f26cee330c290d45a33b9daa94800000003515f332729426c008c085a81bd34d8ef12dd31e80130339ef99d50013a89e4558eee6d0fa4ffe2ee7b7b62eb92608b2251ac31396a718f9b34978888789042b790a30100000003515f342be6b6824a913eb7a57b03cb1ee7bfb4de02f2f65fe8a4e97baa7766ddb353a82a8a25c49dc63778cd9fe96173f12a2bc77f3682f4c4448f98f1df82c75234a100000003515f351f85760d6ab567465aadc2f180af9eae3800e6958fec96aef53fd8a7b195d7c000c6267a0dd5cfc22b3fe804f53e266069c0e36f51885baec1e7e67650c62e170000000c515f41524954484d455449430d9d0f8ece2aa12012fa21e6e5c859e97bd5704e5c122064a66051294bc5e04213f61f54a0ebdf6fee4d4a6ecf693478191de0c2899bcd8e86a636c8d3eff43400000003515f43224a99d02c86336737c8dd5b746c40d2be6aead8393889a76a18d664029096e90f7fe81adcc92a74350eada9622ac453f49ebac24a066a1f83b394df54dfa0130000000c515f46495845445f42415345060e8a013ed289c2f9fd7473b04f6594b138ddb4b4cf6b901622a14088f04b8d2c83ff74fce56e3d5573b99c7b26d85d5046ce0c6559506acb7a675e7713eb3a00000007515f4c4f4749430721a91cb8da4b917e054f72147e1760cfe0ef3d45090ac0f4961d84ec1996961a25e787b26bd8b50b1a99450f77a424a83513c2b33af268cd253b0587ff50c700000003515f4d05dbd8623b8652511e1eb38d38887a69eceb082f807514f09e127237c5213b401b9325b48c6c225968002318095f89d0ef9cf629b2b7f0172e03bc39aacf6ed800000007515f52414e474504b57a3805e41df328f5ca9aefa40fad5917391543b7b65c6476e60b8f72e9ad07c92f3b3e11c8feae96dedc4b14a6226ef3201244f37cfc1ee5b96781f48d2b000000075349474d415f3125001d1954a18571eaa007144c5a567bb0d2be4def08a8be918b8c05e3b27d312c59ed41e09e144eab5de77ca89a2fd783be702a47c951d3112e3de02ce6e47c000000075349474d415f3223994e6a23618e60fa01c449a7ab88378709197e186d48d604bfb6931ffb15ad11c5ec7a0700570f80088fd5198ab5d5c227f2ad2a455a6edeec024156bb7beb000000075349474d415f3300cda5845f23468a13275d18bddae27c6bb189cf9aa95b6a03a0cb6688c7e8d829639b45cf8607c525cc400b55ebf90205f2f378626dc3406cc59b2d1b474fba000000075349474d415f342d299e7928496ea2d37f10b43afd6a80c90a33b483090d18069ffa275eedb2fc2f82121e8de43dc036d99b478b6227ceef34248939987a19011f065d8b5cef5c0000000010000000000000000100000002000000030000000400000005000000060000000700000008000000090000000a0000000b0000000c0000000d0000000e0000000f" + }, + { + "name": "constructor", + "functionType": "secret", + "isInternal": false, + "parameters": [ + { + "name": "initial_supply", + "type": { + "kind": "field" + }, + "visibility": "private" + }, + { + "name": "owner", + "type": { + "kind": "field" + }, + "visibility": "private" + } + ], + "returnTypes": [], + "bytecode": "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", + "verificationKey": "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" + }, + { + "name": "getBalance", + "functionType": "unconstrained", + "isInternal": false, + "parameters": [ + { + "name": "owner", + "type": { + "kind": "field" + }, + "visibility": "private" + } + ], + "returnTypes": [ + { + "kind": "field" + } + ], + "bytecode": "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", + "verificationKey": "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" + }, + { + "name": "mint", + "functionType": "secret", + "isInternal": false, + "parameters": [ + { + "name": "amount", + "type": { + "kind": "field" + }, + "visibility": "private" + }, + { + "name": "owner", + "type": { + "kind": "field" + }, + "visibility": "private" + } + ], + "returnTypes": [], + "bytecode": "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", + "verificationKey": "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" + }, + { + "name": "transfer", + "functionType": "secret", + "isInternal": false, + "parameters": [ + { + "name": "amount", + "type": { + "kind": "field" + }, + "visibility": "private" + }, + { + "name": "recipient", + "type": { + "kind": "field" + }, + "visibility": "private" + } + ], + "returnTypes": [], + "bytecode": "H4sIAAAAAAAA/+ydB3wVRdvF96ZBCCAi0kVERcR2J3QLXqKioCBV7EpJVGzYsWLvvffeK/aOvTfsvffeu8K3E3feDJu7vp/MefLOkdnfb7mb5WZmznOe/2zJzs7yZ0ZR212i+iUXryXxWpZsm5/LUz9XJNv2Yn4uJJ998v379q0dUF2r+qiJ+epBkwb2y/ftN6n/QDVQ9RvYb0r1wD59agf2HThg0KRBA/KDVN8+taqu36A+dfm/lo5WWXnHRbKdnUja2ZmknV1I2tmVpJ2LkbSzG0k7FydpZ3eSdi5B0s4eJO1ckqSdS5G0c2mSdvYkaecyJO3sRdLOZUna2ZukncuRtHN5knauQNLOFUnauRJJO/Mk7VQk7awmaWcfknb2JWlnP2A7ddv0vbvuSXnt43VOvHZIPjsmn52Sz87JZ5fks2vyuVjy2S35XDz57J58LpF89kg+l0w+l0o+l04+eyafyySfvZLPZZPP3snncsnn8snnCsnnisnnSslnPvlUyWd18tkn+eybfPazyusfrwOiv+5x6qUk+TT7Jb0dGHHk4CCSdq5M0s5VSNq5Kkk7VyNp52CSdq5O0s4CSTuHkLSzhqSda5C0c02Sdq5F0s6hEf5cuE1Snj7f0+eEA5PPQcnnysnnKsnnqsnnasnn4ORz9eSzkHwOST5rks81ks81k8+1ks+hUcO56Nrxuk7U8Pd2cy5q9kvGdhgutsrE1rR/WKIxl3zqZXi8rptoLbG+a/aXRo2fMSimO++2qOERNqfMsp61XZZ8llj7SpPPCgFNUaqedBxbF9kHrVzCpPUEyh0R4QCS0j0C75FoJz0C2E6dvAtFjRefO4EizQWV3a+vYNn9BMvuL1j2AMGyBwqWPUjncGVUfMHU0TgXQ7mhXOZykWU3AX+KLN5s7Q3lNnG5wLKVXNnVov2GXNl95zlPQp/jto+wfadp4zvJ9sh4XT9eR8Xr6HgdE69j43VcvI6P1w3idUK8bhivG8XrxvG6SbxuGq+bxevm8bpFvG4ZrxPjdVK8To7XKfFaG6918bpVvG4dr9vE69R43TZet4vX7eN1h3jdMV6nxetO8bpzvOpxDbvG627xunu87hGv0+N1z3jdK173jtd94nXfeN0vXmfE6/7xekC8HhivB8XrwfF6SLweGq+Hxevh8XpEvB4Zr0fF69Hxeky8Hhuvx8Xr8fF6QryeGK8nxevJ8XpKvJ4ar6fF6+nxeka8nhmvZ8Xr2fF6TryeG6/nxev58XpBvF4YrxfF68Xxekm8Xhqvl8Xr5fF6RbxeGa9XxevV8XpNvF4br9fF68x4vT5eb4jXG+P1pni9OV5viddb4/W2eL09Xu+I1zvj9a54vTteZ8XrPfF6b7zeF6/3x+sD8fpgvD4Urw/H6yPx+mi8Phavj8frE/H6ZLw+Fa9Px+sz8To7Xp+N1+fi9fl4fSFeX4zXl+L15Xh9JV5fjdfX4vX1eH0jXt+M17fi9e3or3x6N17fi9f34/WDeP0wXj+K14/j9ZN4/TReP4vXz+P1i3j9Ml6/itev4/WbeP02Xr+L1+/j9Yd4/TFef4rXn+P1l3j9NV5/i9ff4/WPeP0z+uvG1Nx41Umdi9eSeC2N17J4LY/XinhtFq/N47UyXlvEa1W8tozXVvHaOl4Xitc28bpwvLaN10XitV28Lhqv7eO1Q7x2jNdO8do5XrvEa9d4XSxeu8Xr4vHaPV6XiNce8bpkvC4Vr0vHa894XSZee8XrsvHaO16Xi9fl43UF627OTl3++tTnNubmZuuoYZ+5nm5l7TP/39LaZ/6/ytpn/r+Ftc/+f/Np/r+5tc/8fzNrn/n/Cmuf+f9ya5/5/zJrn/n/Umtf+kZbpfX/OWuf+f8oVb9eCsln3mlR1QI39vJacztLR5TSq32sKrJft2VhbFtU+gZiwdo2ddltKfWoLWUetaXco7ZUeNSWZh61pblHban0qC0tPGpLlUdtaelRW1p51JbWHrVlIY/a0sajtuT+x22pjBr/cbIy9f/ms22ybZ+PLpLSpPeZcyb7/LakSL3mHKWttc+cKyxi7TPHbFOu/nn5jg3/3z7Zb5+Hdki27fPV5FfmOa/tZJVp9nVOtiuKaGpv7TNt7GDtM1o6WvuM5k7WvkWT7c5F6rVzwvxOIfnMuy31OWHXU7B+NnW1sNrQ2YO2tPGoLQt51JbWHrWllUdtaelRW6o8aksLj9pS6VFbmnvUlmYetaXCo7aUe9SWMo/aUupRW0qKtKUjtC21efucLbLaZC8Fa7uj1ZYO0Lbk87rM9uAydRldrPYbrabtVdb/t7e0dcG2o97zDtG8MTU/d5Grt15/1/+iv2uRdnRtQv1dg/6gP+gP+oN+kePf/1d/ew/0h/yH1hv0R0F/0B/0s+gPxz9ovSH/o6A/6A/6g34O/eH4B6035H8U9Af9QX/Qz6E/HP+g9Yb8j4L+oD/oD/o59IfjH7TekP9R0B/0B/1BP4f+cPyD1hvyPwr6g/6gP+jn0B+Of9B6Q/5HQX/QH/QH/Rz6w/EPWm/I/yjoD/qD/qCfQ384/kHrDfkfBf1Bf9Af9HPoD8c/aL0h/6OgP+gP+oN+Dv3h+AetN+R/FPQH/UF/0M+hPxz/oPWG/I+C/qA/6A/6OfSH4x+03pD/UdAf9Af9QT+H/nD8g9Yb8j8K+oP+oD/o59Afjn/QekP+R0F/0B/0B/0c+sPxD1pvyP8o6A/6g/6gn0N/OP5B6w35HwX9QX/QH/Rz6A/HP2i9If+joD/oD/qDfg794fgHrTfkfxT0B/1Bf9DPoT8c/6D1hvyPgv6gP+gP+jn0h+MftN6Q/1HQH/QH/UE/h/5w/IPWG/I/CvqD/qA/6OfQH45/0HpD/kdBf9Af9Af9HPrD8Q9ab8j/KOgP+oP+oJ9Dfzj+QesN+R8F/UF/0B/0c+gPxz9ovSH/o6A/6A/6g34O/eH4B6035H8U9Af9QX/Qz6E/HP+g9Yb8j4L+oD/oD/o59IfjH7TekP9R0B/0B/1BP4f+cPyD1hvyPwr6g/6gP+jn0B+Of9B6Q/5HQX/QH/QH/Rz6ofVWT6yuTNWrl1zq54K1bbdlMWRb4kXK325W+41W0/Yq6/9tf7th21Hv72LRvDE1P3ez6g36ofUG/VHQH/QH/UF/0B/0B/1Bf9Af9Af9QX/QH/QH/UF/0B/0B/1Bf9Af9Af9QX/QH/QH/UF/0B/0B/2FoD/oD/qD/qA/6A/6g/6gP+gP+oP+oD/oD/qD/qA/6A/6g/6gP+gP+oP+oD/oD/qD/qA/6A/6g/6gP+gP+oP+KOgP+oP+oD/oD/qD/qA/6A/6g/6gP+gP+oP+oD/oD/qD/qAfWm/QHwX9QX/QH/QH/UF/0B/0B/1Bf9Af9Af9QX/QH/QH/UF/0B/0B/1Bf9Af9Af9QX/QH/QH/UF/0F8I+oP+oD/oD/qD/qA/6A/6g/6gP+gP+oP+oD/oD/qD/qA/6A/6g/6gP+gP+oP+oD/oD/qD/qA/6A/6g/6gP+iPgv6gP+gP+oP+oD/oD/qD/qA/6A/6g/6gP+gP+oP+oD/oD/qh9Qb9UdAf9Af9QX/QH/QH/UF/0B/0B/1Bf9Af9Af9QX/QH/QH/UF/0B/0B/1Bf9Af9Af9QX/QH/QH/YWgP+gP+oP+oD/oD/qD/qA/6A/6g/6gP+gP+oP+oD/oD/qD/qA/6A/6g/6gP+gP+oP+oD/oD/qD/qA/6A/6g/4o6A/6g/6gP+gP+oP+oD/oD/qD/qA/6A/6g/6gP+gP+oP+oB9ab9AfBf1Bf9Af9Af9QX/QH/QH/UF/0B/0B/1Bf9Af9Af9QX/QH/QH/UF/0B/0B/1Bf9Af9Af9QX/QXwj6g/6gP+gP+oP+oD/oD/qD/qA/6A/6g/6gP+gP+oP+oD/oD/qD/qA/6A/6g/6gP+gP+oP+oD/oD/qD/qA/6I+C/qA/6A/6g/6gP+gP+oP+oD/oD/qD/qA/6A/6g/6gP+gP+qH1Bv1R0B/0B/1Bf9Af9Af9QX/QH/QH/UF/0B/0B/1Bf9Af9Af9QX/QH/QH/UF/0B/0B/1Bf9Af9Af9haA/6A/6g/6gP+gP+oP+oD/oD/qD/qA/6A/6g/6gP+gP+oP+oD/oD/qD/qA/6A/6g/6gP+gP+oP+oD/oD/qD/ijoD/qD/qA/6A/6g/6gP+gP+oP+oD/oD/qD/qA/6A/6g/6gH1pv0B8F/UF/0B/0B/1Bf9Af9Af9QX/QH/QH/UF/0B/0B/1Bf9Af9Af9QX/QH/QH/UF/0B/0B/1Bf9BfCPqD/qA/6A/6g/6gP+gP+oP+oD/oD/qD/qA/6A/6g/6gP+gP+oP+oD/oD/qD/qA/6A/6g/6gP+gP+oP+oD/oj4L+oD/oD/qD/qA/6A/6g/6gP+gP+oP+oD/oD/qD/qA/6A/6ofUG/VHQH/QH/UF/0B/0B/1Bf9Af9Af9QX/QH/QH/UF/0B/0B/1Bf9Af9Af9QX/QH/QH/UF/0B/0B/2FoD/oD/qD/qA/6A/6g/6gP+gP+oP+oD/oD/qD/qA/6A/6g/6gP+gP+oP+oD/oD/qD/qA/6A/6g/6gP+gP+oP+KOgP+oP+oD/oD/qD/qA/6A/6g/6gP+gP+oP+oD/oD/qD/qAfWm/QHwX9QX/QH/QH/UF/0B/0B/1Bf9Af9Af9QX/QH/QH/UF/0B/0B/1Bf9Af9Af9QX/QH/QH/UF/0F8I+oP+oD/oD/qD/qA/6A/6g/6gP+gP+oP+oD/oB+qvsv6/xGrLYgJtiVJtiYrExSylHrWlzKO2lHvUlgqP2tLMo7Y096gtlR61pYVHbanyqC0tPWpLK4/a0tqjtizkUVvaeNSWhT1qS1uP2rKIR21p51FbFvWoLe09aksHj9rS0aO2dPKoLZ09aksXj9rS1aO25P7Hbam02hBZ+8z/l1j7zDV4qbVv8WS7zNrXPdkut/YtYek0+3ok282sfUsm282tfUsl2+2sfUsn24tY+3om222tfcsk2wtb+3ol24ta+5ZNtltZ+3on262tfcsl252sfcsn2x2sfSZudpxN3LpZ+0zcFrf2mbh1t/aZuC1h7TNx62HtM3Fb0tpnrqmWsvaZa5ulrX0mL3ta+8y5/jLWPhOjXtY+E6NlrX3mHLS3tc+cCy5n7TPemDhq/Sd2avh/8107F5cvUo7ZtpkydReSz7zbUs+UXU/B+tnU1cJqw3IetKWrR23p4lFbOnvUlk4etaWjR23p4FFb2nvUlkU9aks7j9qyiEdtaetRWxb2qC1tPGrLQh61pbVHbWnlUVtaetSWKo/a0sKjtlR61JbmHrWlmUdtqfCoLeUetaXMo7aUetSWkiJtWRbblmr7PktktcleCtb2slZbloG2pTZv3xv6/7RlGastPaFtyed1me3BZeoylrbab7SatldZ/2//rWFpbDvq869nNG9Mzc9LW/VKPOf0/9XfJegP+oP+oD/o/5/pD8c/aL0h/6OgP+gP+oN+Dv3h+AetN+R/FPQH/UF/0M+hPxz/oPWG/I+C/qA/6A/6OfSH4x+03pD/UdAf9Af9QT+H/nD8g9Yb8j8K+oP+oD/o59Afjn/QekP+R0F/0B/0B/0c+sPxD1pvyP8o6A/6g/6gn0N/OP5B6w35HwX9QX/QH/Rz6A/HP2i9If+joD/oD/qDfg794fgHrTfkfxT0B/1Bf9DPoT8c/6D1hvyPgv6gP+gP+jn0h+MftN6Q/1HQH/QH/UE/h/5w/IPWG/I/CvqD/qA/6OfQH45/0HpD/kdBf9Af9Af9HPrD8Q9ab8j/KOgP+oP+oJ9Dfzj+QesN+R8F/UF/0B/0c+gPxz9ovSH/o6A/6A/6g34O/eH4B6035H8U9Af9QX/Qz6E/HP+g9Yb8j4L+oD/oD/o59IfjH7TekP9R0B/0B/1BP4f+cPyD1hvyPwr6g/6gP+jn0B+Of9B6Q/5HQX/QH/QH/Rz6w/EPWm/I/yjoD/qD/qCfQ384/kHrDfkfBf1Bf9Af9HPoD8c/aL0h/6OgP+gP+oN+Dv3h+AetN+R/FPQH/UF/0M+hPxz/oPWG/I+C/qA/6A/6OfSH4x+03pD/UdAf9Af9QT+H/nD8g9Yb8j8K+oP+oD/o59Afjn/QekP+R0F/0B/0B/0c+sPxD1pvyP8o6A/6g/6g33/9lda+3v/jtlRZbegl1pbafFVUPA/AmqsrU5r1kkv9XLC27bYshW1LXrdlyaSsnlY9PbD11Pu8ZEqf+dnUZcd/KcG2VBWpW4J3O7am7LJ4ndShoc4loHVW53WZ3cA6tHfdo4ZlhqWrmxU/iXoXT9W7RKreXMrDGVZbze+WWt/ZoUODD1OT7RZWeaaf0d4tlqpL7ytJts3/NUvqXQGrfYBdh67TxNvUo5eVrO3lU+3SmlZMfa+FtW2zrrBtr/ctb7Vtery2SbZNXTlruyL5jmlb3vpOtRWDnKXJ/G6p9Z09LW97dWwoW8KbPla70t7oOvth66yX2zdqWEz9/ax9A6xtkw/md7T3/VPf0+0ciG1ndbodpp0DrX0rF2nnAKudg1Lf0+1cBdvOPul2mHauYu1brUg7V7bauWrqe7qdg7Ht7Jtuh2nnYGtfoUg7V7PauXrqe7qdQ7Dt7Jduh2nnEGvfGkXaWbDaWZP6nm7nmth29k+3w7RzTWvf0CLtXMNq51qp77Wwtu1z5bWxbVe6zGHQMmvrz1HWieZd/u5cdJilb12svvrjxnpW+QWrDrveEeC42vXmktXUYfaXWtsXd2iIx4iGzf/kgGmzzovhRb5nb6+T+p0q6/+HC2te12pHwfrZ1KWPo2dYWocXaXcfq93m/9e22j0c2u6/8nVYNO/yd/lqx3A9aFv+ytcRVvkFqw673pHYepVdr8lXU4fZX2pt32x5OLJh8z8emjbrfF23yPfs7WGp36my/n9dYc3rWe0oWD+bunS+XmlpXbdIu/ta7Tb/399qt8R5m82Nqb+fVSc2L/9ixNaul79jxO5zwb7VM7K+VX7BqsOudxQ47na9hhFTh9lfam0/auXNqIbN/+SNabNmZESR79nbaYaqrP8fIazZZrVg/Wzq0ozcnXH8Mu0ebrXb/P8gq90SjNhsm/ptRrB5+Rcjtna9/B0jI622gH2rZ2S0VX7BqsOudww47na9hhFTh9lfam2/buXNmIbN/+SNabNmZP0i37O30wxVWf+/vrBmm9WC9bOpSzMy29K6fpF228c/8/+rWu2WYMRm29RvM4LNy78YsbXr5e8YGWW1BexbPSNjrfILVh12vePAcbfrNYyYOsz+Umv7KytvxjVs/idvTJs1I6OLfM/eTjNUZf3/aGHNNqsF62dTl2bkfUvr6CLtto9/5v9Xt9otwYjNtqnfZgSbl38xYmvXy98xMsZqC9i3ekbGW+UXrDrsejcAx92u1zBi6jD7S+3vdGyIxwYNm//JG9NmzcjYIt+zt9MMVVn/P1ZYs81qwfrZ1KUZ+cliZGyRdtvHP/P/NVa7JRix2Tb124xg8/IvRmztevk7RsZZbQH7Vs/IBKv8glWHXe+G4Ljb9RpGTB1mf6m13c5iZMOGzf/kjWmzZmR8ke/Z22mGqqz/Hy+s2Wa1YP1s6tKMVFpaxxdpt338M/9v7sHq3DK+2fdexwtoyeJ9vNW+3qm249vy13MK6bpbWPt6WnVL8GN7pP9uZ+6fmLrSvk8v0l7t24TU7+l9GxbRsBFWg7LZM+Wan01d9rMIEwTbUlWk7vTfLyWOAbZ+8/fLfpYPZp/Nqf3cQjNsm+qfiamI5l3+7hhh6te/0xzblvrjVaVVvvlsga2nPg8rU/rMz6auKqsNzQXbUlWkboF6qitTmvXydz7bbWmJbUufyiS+/9+2tLTa0grblrxEHusyWlvtN1pbWT+b/7dzqzW2HfV53iqaN6bm59ZWvUE/tF4q/ZXWvsr/cVvsvrBKri19qqLieQCup7oypVkvf9fP2W1pA9as27LQP2hLG6stC2PbUt/ntgWXqctYxGq/0WraXmX9f1tL2yLYdtTn+cLRvDE1Py9i1Rv0Q+ul0l9p7Wv1P26L3ReamAm0pb7PbYo8sGNrytbXUDtZ13Xo8YU6zu2ihmWG1QZ7PKFEvYum6i1N1ZtLxXuG1Vbzu6XWd3p1aojZdCtmHbBtrz82to/mXf7ueNTB0tAJ25b6Y2PHf9CWTlZbOmPbInY90sVqv9Fq2l5l/b99Pgoel1HfH3WO5o2p+dkedxX0Q+ul0l9p7Wv/P25LldWGjnJtqT82FssDcD3VlSnNevm7fs5uy2JgzbotXf9BWxaz2oIe76TLXBxcpi6ju9V+o9W0vSpqPF6qwtpXwLSjPs+7RfPG1Pzc3ao36IfWS6W/0trX+X/cFrsv7CrXlvo+t1geSFyPmHrs65EbrXPrJcF16jgvETUsM6w2LBnJ1tsjVW95qt5cKt722FLzu6XWdx7v2BCzO5LtFikdZp8Zu2z/PcWM4W5l7euZbLe39i2TbHe2yuiVarvet2yybddl/vZsj+FfLtnuae0zY5qWsfaVJNu9rH3mGm5Za19Zsm2PkzWxXc7aZ+Jh6jLjZM13Csln3m2ptvWY5e+O33Ybe6faWGFpBbWvvq/pnWqL+dnUVWW1oUyuLYOqitQtUE91ZUqzXv7OEzu/TP7Zz3KAx+/We9Ir1Rbzs6nLjlW5YFuqitQtUE++mOZuRepdUaDeFVL1mniauuxx3RUZfuj9eXDsdb1mzHl5qh2mrlLrOx8m/X6rSGTcfP1QOlNXieWPqUcvfaxt01fY4/urU9/T7ewLjlu6HaZ+e3x6/yLt7GO1s1/qe7qdA7DtrE63w7TTHp8+qEg7+1vtHJj6nv2+ge+tc4KlOjX8jvmufd8APX5d95X2+HW9/F0fu4rVltWwbalnfLBVfsGqw653dWy9yq7XPFNp6jD7S+1tc8PU+p5ejF/2mPlVi3zP3l459TtV1v+vKqzZfh9AwfrZ1KXz8RfrRvKqRdptX/+Z/7ef/zK+2Tm8qoCWVVJaVkm12b73tbJcW+qvw9J1t7D22dejYH7qWbY90svfsWy/bwKcX/UsF6zyC1Yddr1DsPUqu17DcrqOUmu7i8XykIbN//hl2qw9HFzke/Z2mvUq6/8HC2u2+5SC9bOpS7PcxtI6uEi7bZbN/5vjls4t45udw+D3lPxtvzTYal/nVNsF2lLPcrpu+xgtdU5k6zee9LV8MPtWs9pk338Bs1x/HWbni17+rl9Z3WprIRU/aeZNueZnU5ed0yVybam/Nk7XLVBPtR1bs/ydJ6Z+/Xs1qf/X7VsD2756T2pSbTE/m7rsWJUKtqUqKv5OIHA9+WKaFy5SL/hdRPX1rpGq18TT1JWztisy/JC6NjZjbMpT7bCvjc131kj6VslrY1NXieWPfW28trVt+grzO/Y7muz300gcB+x2mPrta+NhRdq5ttXOdVLfk7o2Hlaknfa18bpF2jnMaufw1Pd0PpgYj7ae3znWujY237XvjdvvATGf4PeQ9Anve/jn73uYZJ13/tvf9zDB0vr/fd+D4VTn1khr22hZX0BL1vtd1rfaV5lqu0Bb+lQVqbuFtc/+O5ftr/kcDW6P1mz7rJe/49vmbyy2LXl7rKjhe2yReiXHqBq+TR1mf6m1vbeV8/aYTuOhabP2cEyR79nbo1K/Y4/VHSOs2R5bXrB+NnVpvqdl9GXpd0LZ/ZI5vtnveLCfk5bsn025o1Nttp+TFnzfSp+qInXb7yyxWQbz0+j9I82tesdanqTfbaH3jS/SPsn3XZhyzc/2GHvTBsH3GaiqInXb51xS57i2fnMubt/rMPtsBu1n38HP9ddfV7eN5l3+rv+3x0CY59Dt8RiLgmOWfja/EDV+/r3KakMbsbb89f6AYnWbxb7P0g5a919xiFJxMEu7Im0p9agtZR61pdyjtlR41JZmHrWluUdtqfSoLS08akuVR21p6VFbWnnUltYetWUhj9rSxqO2LOxRW9p61JZFPGpL7n/clsqo8Tm5ff5dYu1b1No2n/Zz0mZfh5ROewxlS2ufufy33zFh/hZtv4PCjDVayNpnnv9f2NpXUkSbOVe1227OGdtb+8y5WwdrnzmH6mjtM+cynax95pzCfj7cxMgeu2ZiZNqu69ymS2OdJUV02uWYbTt3wGNN63PHrqdg/WzqamG1oYsHbVnEo7a09agtC3vUljYetWUhj9rS2qO2tPKoLS09akuVR21p4VFbKj1qS3OP2tLMo7ZUeNSWco/aUuZRW0o9aktJkbaA361S/8iS/W4Vc67byWqHaZP9jgXw+2bq/zZst6O7Va/9bhnwO3rq/2azaBH99jWVqX9RQR/saztTtuZipc4NdWLf8fDXnLjdwTq0j/YY8hmWru5W/CTqTc+Ju1iqXvtvTWZss2mrPSeu+c4qnRt8GJBst7DKM9cX2rslUnXZ18Lm/8xY3x4C2k0dpg0m5j0s7T0s7d2t3+loaf9P2yztQ7s0/B54nu36oTVm/HaJ1W57nuue2Drrn/Gz55s35dvzcNtjQk2fYH7HHo9uz7su0TfZ7TD12+/l6l2knb2sdi6b+p7AWPP6/LPbkbPqNXWVWt8ZaeXWWlZuSfi8XNQ4fj2tWIDHE//jcff2ON6VsG2pf/ZrxX/QlpWstoCfm85LnbvYzzmnxyhXWf9vvxMO/Ax2/flcPhVT87M9l3fQD62XSn+ltW/5/3Fb7PdqrCjXlvpn5ZoiD+zY2ufOO1rnztVgbbpM8PwT9cdR+/0BMyxd9jxEEvX2TdVbnao3l/JwhtVW87ul1neGd2nwYQ/r3NmUZzMg0S/Y4zVMnfY1rXmXwQCrHRLnbwOLtMO+tjT1D7TaIXEeNKhIO3pa7Ui/z0G3Y2VwOypT7dDL352PCI5rr7bH8v9/2iI4LrfaHov8/2lL+p0S6Las/g/aUrDaUiPQliH/oC01VlvAYxLr27LGP2iLqV//nhlDZrM1FNu+ecYlmnLNz6auKqsN/QXbUlWkbjsOq3gQB9OGAf/DOKzmQRxMGwb+D+OwugdxMG3o8D+MwxAP4mDasMz/MA5reBAH04aSJo5DC2uf/bze2ti6B9h12vdd7THg64D16jKHQ8v8aw7VYdG8y98dl4db+tbD6qu/jrLHlhasOux6wWO4lV2vGd9o6jD7S63tx62XjNvjZk3emTbb49Lt79nbw1K/Y49/XVdY83pWOwrWz6Yufe15j6V13SLttpk3/7+O1W6Ja8LhVjtM/fb7xLB5+Rcjtna9/B0j9nsHwL7VM2KPey5Yddj1gt8toOx6DSPpMa6l1vabVt7Y46dN3pg2a0ZGFPmevZ1mqMr6/xHCmrPGxZu6NCPPWVpHFGn3cKvd5v/t6wcJRmy2Tf02I9i8/IuR8B6Mf/YejG+svPm3vwfjQ0vr//c9GNL3Fm22Tf02I9i8/IsRW7te/o4RwXH49YzYc4kXrDrseseB427XaxgxdZj9pfa2NbGPPU+6yZti7xCwv2dvpxmy5zsfLazZZrVg/Wzqqn+3qsXI6CLtto9/5v/t+w4SjNhsm/ptRrB5+Rcjtna9/B0j9jtAwL7NMye9YWRckXol3wNhGDF1mP2l1nZ7i5ENGjb/kzemzZqRsUW+Z2+nGaqy/n+ssGab1YL1s/3+iSpL69gi7baPf+b/pZ9/LPbeF5sRbF7+xYitXS9/x4jge0LqGZlglV+w6rDr3RAcd7tew4ipw+wvtbaXtfJmw4bN/+SNabNmZHyR79nbaYaqrP8fL6zZZrVg/Wzq0ox0s7SOL9Ju+/hn/t++XynBiM22qd9mBJuXfzFia9fL3zGygdUWsG/1jGxklV+w6rDr3Rgcd7tew4ipw+wvtbZXtfJm44bN/+SNabNmZEKR79nbaYaqrP+fIKzZZrVg/Wzq0owoS+uEIu22j3/m/829bJ1bxjf7HvMEAS1ZvE+w2tc21XZ8W/56t0+6bvv50/RzzhJ9iB0Lc7/dHv9s9tnnCytZz86YdtvPl9q5Yp4Vsp95tXO6a+p3dJkbpb6ntW+C1V7/HKrdDr38XV+2idWWzbBtqe/LNrfKL1h12PVuga1X2fWavszUYfaXWtubWXxv0bD5nxwwbdYeblrke/b2xqnfqbL+f1NhzZtZ7ShYP5u6dI6PsbRuWqTd9vOc5v/t45EEq5tY7TD126yadtjPsYFztT5+m6biZ362vVw+FS+BtvSpKlK3/dyliVf6ucsqZDuqJ1brMluBy9Q6zBhns/xd/2Tqbx41jHXdqnbXkTvuWrtLzvp9U+aFyYG3hVVGibVdav1OWZF95UX2VRTZ1yy1z7TRLJXWdpX1ey1S7dTfM2Ph7XeFmDab/2sWNY4TFMJcqsw++f59+9YOqK5VfdTEfPWgSQP75fv2m9R/oBqo+g3sN6V6YJ8+tQP7DhwwaNKgAflBqm+fWlXXb1CfuqRQLWCkQLmfD8Y+vJoDx1JrHiOg+wuwbrOUgPUD/VFfCHvt6slwoRz/miDHxwno/oYkx4H+KKTm0qjIQULA/7G4svJ2e1e0fihLeacX+0WsaE1Rqp50HFtHTXwAzrst9SbpgKLLXSmHA15K90o5uEd5cyZoklD/xWRO9NddfP05Ovmsryv+sr6kKE++X5Lab8oy+8clv6v/35RRHW/3Scoos75r9ttLuoNz9QXpcd8c9irt/+tBv/jL/ZP4lVsxMvuzPOhneTAg3h6YlGF/1+xPlzEmKWNAUob2bVC8vXJSRjPru2Z/uoyxSRmDkjK01lXi7VWTMppb3zX79SLBeXUOf5D/3vOTG52vqwjo/kHo5KYU3M7VgLwCvVY/eH4xoJkcL1Duz57zojVvJKD7F5KLAaA/6heCC16JHP+dIMc3EdD9B0mOA/1RfxBe8G6MK2ueC97B4YIXa9JggQve1T2/4NW6V2+CC179p3J9QTIh+dwwarhQKsRfHpJcoNh/vjD70xc5myS/W7Autmri7TWSMuxXMpr99oK+4EV6vKbgBe/febBW/OWhSfyqrBiZ/VkerGV5sHa8vU5SRkvru2Z/uoyNkjLWti54h8Xbw5MyWlnfNfvTZWyclDHMuuBdN95eLymjtfVds99e0AflEfOfC/lUWaqpDlAjcjIHqJHhAIU1aaTAAWp9zw9QWvf6AgeoyFokY5p3XEqjeZ8TkGrzyEgmto6+KcGyG9Vld06jkgCPtnLPPJdREs37vgHjh/FJd3Zzo8Ze5aztkuQ7pX/znVxGOfbzIeb3W1ttAcYkL9A550U731wSXG3grKQi/fNoC8p08FB12xC5Hv1HATvm0bmm6Thd2zmG8OxpjNDZ09hw9oQ1aazA2dM4z8+etO5xQmdPEvdJJdraVGdQLp1s3TxLbZOdQUl4CCorb3d245OGbjCfZ2M1RTSnz8Zqov9+NlasnH/V2ZjPCWHO5MbnGozRP+ukGBLNu6DP7IA61AbAg8YEWKdTV2fiOcGKp0Q+jM7hzxzn+vXHz0Zno+OtvEXq1u9D9Eh3o/aNT/hEl5sD6zaLa7+RPpAj+w07x50fOPE0fqlFAfNbAXNGScUP/bep8cBjzYY5oK+RzLFlw5xMH4b0WuLW7WoCujfKyeQ4up0bk7RzE5J2bkrSzs1I2rk5STu3IGnnliTtnEjSzkkk7ZxM0s4pJO2sJWlnHUk7tyJp59Yk7dyGpJ1TSdq5LUk7tyNp5/Yk7dyBpJ07krRzGkk7dyJp584k7dyFpJ27krRzN5J27k7Szj1I2jkd2E79jP9C8do9KU/fs9T3A/W9Nn0fS98j0vdf9L0Nfd9AX5Pr6119Lamv0/Q1kL6+0Ofu+rxYn3Pq8zl9rqTPQ/QxXh8/9bFJ9/u6T9X9le4LNGc6h3V+6NhPzxWPV95tqR9DVCNwf7eZ8N8O826L0mNh1hXQ3byJ/vbl2s49gX9vAXqtkPErS/hNL6i2mvIk/uaCioFUG4H5M+8DaWgg98rRJJSYWXvl/G/j3lIJBf+rN7CsfTz/q7fUX3/3JTmb3A/oD2vnsR9B5zGD5Wi0P66h1awJtT9BQh3AklAH4hrahzWhDiRIqINYEupgXEP7sibUwQQJdQhLQh2Ka2g/1oQ6lCChDmNJqMNxDe3PmlCHEyTUESwJdSSuoQNYE+pIgoQ6iiWhjsY1dCBrQh1NkFDHsCTUsbiGDmJNqGMJEuo4loQ6HtfQiawJdTxBQp3AklAn4ho6iTWhTiRIqJNYEupkXEMnsybUyQQJdQpLQp2Ka+gU1oQ6lSChTmNJqNNxDa1lTajTCRLqDJaEOhPX0DrWhDqTIKHOYkmos2ENVbTPvp1NkFDnsCTUubiEon0e6lyChDqPJaHOxyUU7fNQ5xMk1AUsCXUhLqFon4e6kCChLmJJqItxCUX7PNTFBAl1CUtCXYpLKNrnoS4lSKjLWBLqclxC0T4PdTlBQl3BklBX4hKK9nmoKwkS6iqWhLoal1C0z0NdTZBQ17Ak1LW4hKJ9HupagoS6jiWhZuISivZ5qJkECXU9S0LdgEso2uehbiBIqBtZEuomXELRPg91E0FC3cySULfgEor2eahbCBLqVpaEug2XULTPQ91GkFC3syTUHbiEon0e6g6ChLpTKqFKwA11mEK5UXLehROtJODRsdtUoNwqz1/sqDVvKaC7ZRNNypV3WxTQH9XS8wkAhwvl+EIEOT5JQHcbkhwH+qOQmptqWviJuLLmmRb+buuHMC28Y5kTk4Ciy52VwwEvpXtWDu5RfaJWRA1JuFm8zonXzZPPLZJPvdwTf/neeNVv8G4TNSSx2W/KMvsnJb+r/9+UcV+8fX9SxsLWd81+e0l3cK6+ID1+AHii+k88eDD+8kNJ/NpaMTL7szx40PLg4Xj7kaSMRazvmv3pMrZMyng4KUN3Yo/G248lZbSzvmv2p8uYmJTxaFKG1vp4vP1EUsai1nfNfntBH5SfnP9caDRTdFMdoJ7MyRygngoHKKxJTwkcoJ72/ACldT8tcICKrEUypnnHpTRqAEUv6LNz/YJs5N0R/ZLskZGsX45lK8GyG9Vld3jPJIk228rnSstX892K5DNnea870LlWWTnrM2eVMdf6nWLfyWWUU2ntM7/f2moLMCZ5gQ4/L9qh55LgagNnJRXpn2db4KA7EQ3RPjn8Gcoint8uMR0SWnc7P+d6aXTW9wzwgDwbWNaiTRS/vNuigPmtgDmjpOKH5uRZwiuYZ4WuYJ4LVzBYk54TuIJ53vMrGK37eaErGIm/VUi0NX0VYxZ0+2c7dAR18yy1TXbFIeEhqKy83dm9kDT0xfm8eqkpojl99VIT/ferl2Ll/KuuXnxOCHPl80KuwRj9s06KIdG8C/rMDqhDvQg8aLwE63Tq6kw8X7LiKZEPswWusDr59QBCo7PRTa28Reru7PmDF5smfKLL7eLpFWH6QI7sN+wcd41fV5IramB+K2DOqK5N9ACMq88vAI81L+OudEUu8jRrL+dk+jCk1xJ3LfcW0L2E53dr9R3qfQV09yCZmfsVII9Ar1UPgrv8MwTy5tWc/7oPEND9GoHugwR0v06g+xAB3W8Q6D5MQPebBLqPEND9FoHuowR0v02g+xgB3e8Q6D5OQPe7BLpPEND9HoHukwR0v0+g+xQB3R8Q6D5NQPeHBLrPEND9EYHuswR0f0yg+xwB3Z8Q6D5PQPenBLovEND9GYHuiwR0f06g+xIB3V8Q6L5MQPeXBLqvEND9FYHuqwR0f02g+xoB3d8Q6L5OQPe3BLqvF9D9HYHuGwV0f0+g+2YB3T8Q6L5VQPePBLpvF9D9E4HuOwV0/wzUrcfTt4/X7kl5+m/f+u+t+m+P+u9w+m9S+u8z+m8V+r79O/Gq7+fqe5v6Pp++56Xv/+h7Ifq+gL5G1teL+tpJX0foc2p9fqnPtfR5hz4G6+OR7pt1P6WZ1fmrvfzZBCpZ0H/X/wUXN19HJInksX4Xxn0Ceby057r1ezseF9Ddk+Q5mF+BvAC9Vsj46UEM7aPGC6qtpjx0bgL7MrG3Uv6ak8lzOJC/5WgSSsys3wgS6nephCoBJ9SmwLL+yOF7I72gjxZ/Atvp81OTWcntGr85wPixdkJzCDqhueg2Slx2SjyGq3tJtDmRAEg5XDurWUHKlfjfxpISApAknusuJQGpDNfOPqwglRGAVM4AksRAgQoSkJrh2tmXFaRmBCA1ZwBJYuRJJQlILXDt7McKUgsCkKoYQJIYytSSBKRWuHb2ZwWpFQFIrRlAkhgbtxAJSG1w7RzAClIbApAWZgBJYrBlWxKQFsG1cyArSIsQgNSOASSJ0buLkoDUHtfOQawgtScAqQMDSBLDwTuSgNQJ186JrCB1IgCpMwNIEu8X6EICUldcOyexgtSVAKTFGECSeGFFNxKQFse1czIrSIsTgNSdASSJN6AsQQJSD1w7p7CC1IMApCUZQJJ4pc5SJCAtjWtnLStISxOA1JMBJIl3NC1DAlIvXDvrWEHqRQDSsgwgSbz0qzcJSMvB2qlox3ItRwDS8gwgSbxFbgUSkFbEgUQ7HmlFApBWYgBJ4rWEeRKQFA4k2vFIigCkagaQJN5z2YcEpL44kGjHI/UlAKkfA0gSL07tTwLSABxItOORBhCANJABJIk38Q4iAWllHEi045FWJgBpFQaQJF7tvCoJSKvhQKIdj7QaAUiDGUCSeFf46iQgFXAg0Y5HKhCANIQBJImXz9eQgLQGDiTa8UhrEIC0JgNIErMZrEUC0lAcSLTjkYYSgLQ2A0gS02OsQwLSMBxItOORhhGANJwBJIn5VtYlAWk9HEi045HWIwBpBANIEhP4jCQBaX0cSLTjkdYnAGkUA0gSM0KNJgFpDA4k2vFIYwhAGssAksQUY+NIQBqPA4l2PNJ4ApA2YABJYs66CSQgbYgDiXY80oYEIG3EAJLEJIgbC4GEnhZnE1w7fZ10UHRaoU3//fHLF+PONW5x2KLJAuUu6/mkjVrzVgK6ewtNI1UC1g/0R/X2PMeHC+X4CgQ5vo2A7hVJchzoj0JqLrU8sRe0/1vjysrb7d2spGG7LOWdXsyxvUJAU5SqJx3H1kX2QSuXMEkHFF3u5iU44KV0b14C96g+USuihiScEq9z4rU2+axLPvWyRVz/lvGqZzfvEDUksdlvyjL7t0l+V/+/KWNivD0pKaOj9V2z317SHZyrL0iPJwNPoP+JB1PiemuT+HWyYmT2Z3kwxfKgLt7eKimjs/Vdsz9dxlamHUkZuhPbOt7eJimji/Vdsz9dxtZJGVsnZWitU+PtbZMyulrfNfvtBX1Q3m7+cyGfKks11QFquxKZA9T24QCFNWl7gQPUDp4foLTuHQQOUJG1SMY077iURg2g6AV9dq4nv0be9dITYG8q7Jdj2Uqw7EZ12R3ejskP06ydlZavZndF8pmzvNcd6FyrrJz1mbPKmGv9TrHv5DLKqbT2md9vbbUFGJO8QIefF+3Qc0lwtYGzkor0z9MscNCdiAETfYaiPL9dYjoQtO5qodsljrfQG5317Qg8IE8DltWnieKXd1sUML8VMGeUVPzQnOxEeAWzk9AVzM7hCgZr0s4CVzC7eH4Fo3XvInRGLPG3Com2pq9izIJu/zSHjqBunqW2ya44JDwElZW3O7tdkx92m8+rl5oimtNXLzXRf796KVbOv+rqxeeEMFc+u5Y0GKN/1kkxJJp3QZ/ZAXWo3YAHjd1hnU5dnYnn7lY8JfJhmsAV1gC/HkBodDY62cpbpO6Bnj94MTnhE13uIE+vCNMHcmS/Yee48/vISK6ogfmtgDmjVm6iB2Bcfd4VeKzZA3elK3KRp1nbo0SmD0N6LXG39neBB6dXJ7hb+6eA7oKfd2sbtXM6kEeg16rged5oXuYK5M0aBLxEAv3jmiS87AnkBei1WpOAlxKBvFmbgJdSAd3rkPCyF5AXoNdqHQJeygXyZl0CXioEdK9HwsveQF6AXqv1CHhpLpA36xPwUimgexQJL/sAeQF6rUYR8FIlkDdjCXhpKaB7HAkv+wJ5AXqtxhHw0logbyYQ8LKQgO4NSXjZD8gL0Gu1IQEvCwvkzSYEvLQV0L0pCS8zgLwAvVabEvDSTiBvtiDgZVEB3VuS8LI/kBeg12pLAl46SPydloCXjgK6p5DwcgCQF6DXagoBL50F8mYrAl66COjemoSXA4G8AL1WWxPwsphA3mxLwEs3Ad3bkfByEJAXoNdqOwJeugvkzY4EvCwhoHsaCS8HA3kBeq2mEfCypEDe7ELAy1ICuncl4eUQIC9Ar9WuBLz0FMibPQh4WUZA93QSXg4F8gL0Wk0n4GVZgbzZm4CX3gK69yHh5TAgL0Cv1T4EvCwvkDczCHhZQUD3/iS8HA7kBei12p+Al5UE8uYgAl7yAroPJuHlCCAvQK/VwQS8VAvkzWEEvPQR0H04CS9HAnkBeq0OJ+Cln0DeHEXAS38B3UeT8HIUkBeg1+poAl4GCuTNcQS8DBLQfTwJL0cDeQF6rY4n4GUVgbw5iYCXVQV0n0zCyzFAXoBeq5MJeBkskDenEfCyuoDu00l4ORbIC9BrdToBL0ME8uYsAl5qBHSfTcLLcUBegF6rswl4WVMgb84j4GUtAd3nk/ByPJAXoNfqfAJe1hbIm4sIeFlHQPfFJLycAOQF6LW6mICX4QJ5cxkBL+sK6L6chJcTgbwAvVaXE/AyQiBvriLgZaSA7qtJeDkJyAvQa3U1AS+jBPLmOgJeRgvonknCy8lAXoBeq5kEvIwVyJsbCXgZJ6D7JhJeTgHyAvRa3UTAywYCeXMrAS8TBHTfRsLLqUBegF6r2wh42Uggb+4k4GVjAd13kfByGpAXoNcKGb/yuIzF4rV7Up6ew0PPS6Dfta7fH63fiavf86nfXajfx7Z/vOr35uh3gej3G+gx23ocqh5bp8cL6TEQ+rlu/ayqfv5OP1Okn5PQf/vVf8/S9+j1fUd9L0VfH+pzXn0c132Tjrekn6cD/fR0ZmWRfmDzOG4TBfqBezzXPTnWPFVA970k/d8ZQF6AXitk/PRkrItFjRdUW0156NwE9mV5qTaeUSKT53AgzyyhSSgxs84kSKizpBKqBJxQk4FlnV2C7430gj5anANsp8+zv2Ult2v8zgXGj7UTOpegEzpPqhNCA3k+MKF8nl4uy2jX+F2Ai181K5AXEAB5IQuQFwGB9Hn+uiyjnZ+rw8WvDyuQFxMAeQkLkJcCgfR5grwso50fWMTFry8rkJcRAHk5C5BXAIH0eQa+LKNd43clLn79WIG8kgDIq1iAvBoIpM9T/GUZ7Rq/a3Dx688K5DUEQF7LAuR1QCB9nkMwy2jnZ4Fx8RvACuRMAiCvZwHyBiCQPk9SmGW080PWuPgNZAXyRgIgb2IB8mYgkD7PgphltGv8bsHFbxArkLcQAHkrC5C3AYH0eZrFLKNd43c7Ln4TWYG8nQDIO1iAvBMIpM/zOGYZ7Tx+ARe/SaxA3kUA5N0sQM4CAunzRJFZRjsPJMDFbzIrkPcQAHkvC5D3AYH0eSbKLKNd43c/Ln5TWIG8nwDIB1iAfBAIpM9TXWYZ7Rq/h3Dxq2UF8iECIB9mAfIRIJA+z6WZZbRr/B7Fxa+OFchHCYB8jAXIx4FA+jxZZ5bRrvF7AhY/RTsG9AkCIJ9kAfIpIJA+zwaaZbRr/J7GAUk7HvJpAiCfYQFyNhBIn6cbzTLaNX7P4oCkHQ/5LAGQz7EA+TwQSJ/nM80y2jV+L+CApB0P+QIBkC+yAPkSEEifJ0zNMto1fi/jgKQdD/kyAZCvsAD5KhBIn2dkzTLaNX6v4YCkHQ/5GgGQr7MA+QYQSJ+nfM0y2jV+b+KApB0P+SYBkG+xAPk2EEif55TNMto1fu/ggKQdD/kOAZDvsgD5HhBInyetzTLaNX7v44CkHQ/5PgGQH7AA+SEQSJ9nxc0y2jV+H+GApB0P+REBkB+zAPkJEEifp93NMto1fp/igKQdD/kpAZCfsQD5ORBIn+f1zTLaNX5f4ICkHQ/5BQGQX7IA+RUQSJ8nDs4y2jV+X+OApB0P+TUBkN+wAPktEEifZybOMto1ft/hgKQdD/kdAZDfswD5AxBIn6c+zjLaNX4/4oCkHQ/5IwGQP7EA+TMQSJ/nVs4y2jV+v+CApB0P+QsBkL+yAPkbEEhfJ2+WjN/vwPh5Olmy6HSIf/z741eff+gDQRy2aKpAuQ94Ptm01ryDgO4HhfqbErB+oD/qQc9zfLhQjj9CkOPTBHQ/SpLjQH8UUnOp5Ym9oP3fEVdW3m7vnyUN22Up7/Riju0VApqiVD3pOLYusg9auYRJOqDocueU4ICX0j2nBO5RfaJWRA1JuK2uJ163Sz63Tz71Mrfkry+Wxx/dooYkNvtNWWb/tOR39f+bMnLx90qSMha3vmv220u6g3P1BelxaSnO23/iQZmOXRK/7laMzP4sD/T/mzIq4u1mSRlLWN81+9Nl7JCUUZGUoTux5vF2ZVJGD+u7Zn+6jB2TMponZWitLeJ/qpIylrS+a/bbC/qg3LJ0vsvKp8pSTXWAalkqc4BqZcU6HKAcy9QmtSrFl9u61O8DlNbduhTu0d/e1s27LfPENO+4lEYNoOgFfXY+OS4Dedfr7LisPwROKKIiy3yWrQTLblSX3eEtlBjZxjK00vL1PwfM5DNnea870LlWWTnrM2eVMdf6nWLfyWWUU2ntM7/f2moLMCZ5gQ4/L9qh55LgagNnJRXpn9tYoKM7EQMm/JV/nt8uMR0IWveTfv4JotFZ30LAA3IbYFlPNVH88m6LAua3AuaMeorkb9ILE17BLCx0BdM2XMFgTWorcAWziOdXMFr3IkJXMBJ/q5Boa/oqxizo9rdx6Ajq5llqm+yKQ8JDUFl5u7Nrlxi46HxevdQU0Zy+eqmJ/vvVS7Fy/lVXLz4nhLnyaVfaYIz+WSfFkGjeBX1mB9ShFgUeNNrDOp26OhPP9lY8JfKhTanAq3L9egCh0dnoVCtvkbqf8/zBi6kJn+hyn/f0ijB9IEf2G3aOO7/JluSKGpjfCpgz6oUmegDG1ed2wGNNB+Dfh3UZEseWDqUyfRjSa4m7tWcJ3LV8leBu7TkCul8jeWC8I5BHoNfqNc/zRvNynkDevEnAy/kCut8i4aUTkBeg1+otAl4uFMibdwl4uUhA93skvHQG8gL0Wr1HwMslAnnzIQEvlwro/oiEly5AXoBeq48IeLlcIG8+JeDlCgHdn5Hw0hXIC9Br9RkBL1cJ5M2XBLxcLaD7KxJeFgPyAvRafUXAy7UCefMtAS/XCej+joSXbkBegF6r7wh4uV4gb34k4OUGAd0/kfCyOJAXoNfqJwJebhLIm18JeLlZQPdvJLx0B/IC9Fr9RsDLrQJ58ycBL7cJ6J5DwssSQF6AXqs5BLzcIZA3uYL/vNwpoLukwMFLD+T7GHCaFTp+ErzcLZA35QS8zBLQXVHg4GVJIC9ArxU6fhK83CuQN5UEvNwnoLtFgYOXpYC8AL1W6PhJ8PKAQN60IuDlQQHdrQscvCwN5AXotULHT4KXhwXyZmECXh4R0N22wMFLTyAvQK8VOn4SvDwmkDeLEvDyuIDu9gUOXpYB8gL0WqHjJ8HLkwJ504mAl6cEdHcucPDSC8gL0GuFjp8EL88I5M1iBLzMFtDdrcDBy7JAXoBeK3T8JHh5TiBvliDg5XkB3T0KHLz0BvIC9Fqh4yfBy4sCebM0AS8vCejuWeDgZTkgL0CvFTp+Ery8IpA3yxLw8qqA7t4FDl6WB/IC9Fqh4yfBy+sCebMCAS9vCOhescDBywpAXoBeK3T8JHh5SyBvFAEvbwvori5w8LIikBeg1wodPwle3hXIm34EvLwnoLt/gYOXlYC8AL1W6PhJ8PKBQN4MIuDlQwHdKxc4eMkDeQF6rdDxk+DlY4G8WY2Al08EdA8ucPCigLwAvVbo+Enw8plA3gwh4OVzAd01BQ5eqoG8AL1W6PhJ8PKlQN6sRcDLVwK6hxY4eOkD5AXotULHT4KXbwTyZhgBL98K6B5e4OClL5AXoNcKHT8JXr4XyJsRBLz8IKB7ZIGDl35AXoBeK3T8JHj5SSBvRhPw8rOA7jEFDl76A3kBeq3Q8ZPg5VeBvBlPwMtvAro3KHDwMgDIC9BrhYxfeVzGUvHaPSlPz+Gh5yXQ71rX74/W78TV7/nU7y7U72PT75jS783R7wLR7zfQY7b1OFQ9tk6PF9JjIPRz3fpZVf38nX6mSD8nof/2q/+epe/R6/uO+l6Kvj7U57z6OK77pgGlUSTp50Cgn0/4ObOySD8wR/cBpfh+YKOC37pLY80tBHRvXODo/wYBeQF6rZDx05OxLhU1XlBtNeWhcxPYl+Wl2jioVCbP8X/gLqVJKDGzViZIqFWkEqoEnFBTgWWtWorvjfSCPlqsBmynz7O/ZSW381MDwPixdkKDCTqh1aU6ITSQBWBC+Ty9XJbRzo9j4OJXzQrkEAIga1iAXAMIpM/z12UZ7Rq/NXHx68MK5JoEQK7FAuRQIJA+T5CXZbRr/NbGxa8vK5BrEwC5DguQw4BA+jwDX5bRzk864eLXjxXI4QRArssC5HpAIH2e4i/LaOdHyHDx688K5AgCIEeyALk+EEif5xDMMto1fqNw8RvACuQoAiBHswA5Bgikz5MUZhntGr+xuPgNZAVyLAGQ41iAHA8E0udZELOMdn46Exe/QaxAbkAA5AQWIDcEAunzNItZRjs/JomL30RWIDciAHJjFiA3AQKZK+DKKilwALkpLn6TWIHclADIzViA3BwIpM8TRWYZ7Rq/LXDxm8wK5BYEQG7JAuREIJA+z0SZZbRr/Cbh4jeFFchJBEBOZgFyChBIn6e6zDLaNX61uPjVsgJZSwBkHQuQWwGB9HkuzSyjXeO3NS5+daxAbk0A5DYsQE4FAunzZJ1ZRrvGb1tY/BTtGNBtCYDcjgXI7YFA+jwbaJbRrvHbAQck7XjIHQiA3JEFyGlAIH2ebjTLaNf47YQDknY85E4EQO7MAuQuQCCXKODK6lHgAHJXHJC04yF3JQByNxYgdwcC6fOEqVlGu8ZvDxyQtOMh9yAAcjoLkHsCgfR5RtYso13jtxcOSNrxkHsRALk3C5D7AIH0ecrXLKNd47cvDkja8ZD7EgC5HwuQM4BA+jynbJbRrvHbHwck7XjI/QmAPIAFyAOBQPo8aW2W0a7xOwgHJO14yIMIgDyYBchDgED6PCtultGu8TsUByTteMhDCYA8jAXIw4FA+jztbpbRrvE7Agck7XjIIwiAPJIFyKOAQA4p4MqqKXAAeTQOSNrxkEcTAHkMC5DHAoH0eeLgLKNd43ccDkja8ZDHEQB5PAuQJwCB9Hlm4iyjXeN3Ig5I2vGQJxIAeRILkCcDgfR56uMso13jdwoOSNrxkKcQAHkqC5CnAYH0eW7lLKNd43c6Dkja8ZCnEwB5BguQZwKB9HXyZsn4nQWMn6eTJYtOh3j2vz9+9fmHPhCUxGXsJFDuZgVZ3Xm3RWnNuwno3rwg09+UgPUD/VFozfBpWoRyfCJBju8hoHtSgSPHgf4opOZSyxN7Qfu/O66svN3ec0obtstS3unF/HeFgKYoVU86jq2L7INWLmGSDii63HNLccBL6T63FO5RfaJWRA1JuHO8zonXXZLPXZNPvZwXf+n8eC2Pt5eOGpLY7Ddlmf17JL+r/9+UcUG8fWFSRk/ru2a/vaQ7OFdfkB5fBDyB/iceXBx/6ZIkfstYMTL7szy42PLg0nj7sqSMXtZ3zf50GbslZVyalKE7scvj7SuSMpa1vmv2p8vYPSnj8qQMrfXK+J+rkjJ6W9+9MtlvL+iD8tXznwv5VFmqqQ5QV5fKHKCuCQcorEnXCBygrvX8AKV1XytwgIqsRTKmecelNGoARS/os/OpcRnIu16rxmWdLeyXY9lKsOxGddkd3nVJXGZa8am0fDXfrUg+c5b3ugOda5WVsz5zVhlzrd8p9p1cRjmV1j7z+62ttgBjkhfo8POiHXouCa42cFZSkf55pgUOuhMxYMJfilvw+3aJ6UDQuusKMp2R4y30Rmd91wEPyDOBZW3VRPHLuy0KmN8KmDNKKn5oTq4nvIK5XugK5oZwBYM16QaBK5gbPb+C0bpvFDojlvhbhURb01cxZkG3f6ZDR1A3z1LbZFccEh6Cysrbnd1NiYE3z+fVS00Rzemrl5rov1+9FCvnX3X14nNCmCufm0objNE/66QYEs27oM/sgDrUzcCDxi2wTqeuzsTzFiueEvkwU+AKa9uCVw8gNDob3cnKW6Tu7fzS3fgVxgmf6HK3B+s2i2u/kT6QI/sNO8ed3/XuafxSiwLmtwLmjJKKXwmYk5uAx5pbgbfqdRkSx5ZbS2X6MKTXEndrVxHQvUvBb936bu1qArp3LTRN3+jaztuAPAK9Vuj4SfCyukDe7EHAS0FA9/QCBy+3A3kBeq3Q8ZPgpUYgb/Ym4GUNAd37FDh4uQPIC9BrhY6fBC9rCeTNDAJehgro3r/AwcudQF6AXit0/CR4WUcgbw4i4GWYgO6DCxy83AXkBei1QsdPgpd1BfLmMAJe1hPQfXiBg5e7gbwAvVbo+EnwMlIgb44i4GV9Ad1HFzh4mQXkBei1QsdPgpfRAnlzHAEvYwR0H1/g4OUeIC9ArxU6fhK8jBPIm5MIeBkvoPvkAgcv9wJ5AXqt0PGT4GWCQN6cRsDLhgK6Ty9w8HIfkBeg1wodPwleNhbIm7MIeNlEQPfZBQ5e7gfyAvRaoeMnwctmAnlzHgEvmwvoPr/AwcsDQF6AXit0/CR42VIgby4i4GWigO6LCxy8PAjkBei1QsdPgpfJAnlzGQEvUwR0X17g4OUhIC9ArxU6fhK81AnkzVUEvGwloPvqAgcvDwN5AXqt0PGT4GUbgby5joCXqQK6ZxY4eHkEyAvQa4WOnwQv2wnkzY0EvGwvoPumAgcvjwJ5AXqt0PGT4GVHgby5lYCXaQK6bytw8PIYkBeg1wodPwledhbImzsJeNlFQPddBQ5eHgfyAvRaoeMnwctuAnlzDwEvuwvovrfAwcsTQF6AXit0/CR4mS6QNw8Q8LKngO4HCxy8PAnkBei1QsdPgpe9BfLmEQJe9hHQ/WiBg5engLwAvVbo+Enwsp9A3jxBwMsMAd1PFjh4eRrIC9BrhY6fBC8HCOTNMwS8HCige3aBg5dngLwAvVbo+EnwcrBA3jxPwMshArpfKHDwMhvIC9BrhY6fBC+HCeTNywS8HC6g+5UCBy/PAnkBeq3Q8ZPg5UiBvHmdgJejBHS/UeDg5TkgL0CvFTp+ErwcI5A3bxPwcqyA7ncKHLw8D+QF6LVCx0+Cl+MF8uZ9Al5OEND9QYGDlxeAvAC9Vuj4SfBykkDefEzAy8kCuj8pcPDyIpAXoNcKHT8JXk4VyJvPCXg5TUD3FwUOXl4C8gL0WqHjJ8HLGQJ58zUBL2cK6P6mwMHLy0BegF4rZPzK4zKWi9fuSXl6Dg89L4F+17p+f7R+J65+z6d+d6F+H5t+x5R+b45+F4h+v4Ees63HoeqxdXq8kB4DoZ/r1s+q6ufv9DNF+jkJ/bdf/fcsfY9e33fU91L09aE+59XHcd03vVwaRZJ+vgL009OZlUX6gXPjuF0g0A9877nui2LNVwro/qHA0f+9CuQF6LVCxk9Pxrpc1HhBtdWUh85NYF+Wl2rjq6UyeQ4H8rVSmoQSM+s1goR6XSqhSsAJtROwrDdK8b2RXtBHizeB7fR59res5HaN31vA+LF2Qm8RdEJvS3VCaCDfASaUz9PLZRntGr93cfGrZgXyXQIg32MB8n0gkD7PX5dltPPfcXHx68MK5AcEQH7IAuRHQCB9niAvy2jnP5Dj4teXFciPCYD8hAXIT4FAHlTAlSU1gyEayM9w8evHCuRnBEB+zgLkF0AgfZ7iL8to1/h9iYtff1YgvyQA8isWIL8GAunzHIJZRjs/e4KL3wBWIL8hAPJbFiC/AwLp8ySFWUY7PwSCi99AViC/JwDyBxYgfwQC6fMsiFlGu8bvJ1z8BrEC+RMBkD+zAPkLEEifp1nMMto1fr/i4jeRFchfCYD8jQXI34FA+jyPY5bRrvH7Axe/SaxA/kEA5J8sQM4BAunzRJFZRrvGby4ufpNZgZxLAGRURgJkDtdQr2eizDLaNX4luPhNYQWypMz/NpayAFkGBNLnqS6zjHaNXzkufrWsQJYTAFnBAmQzIJA+z6WZZbRr/Jrj4lfHCmRzAiArWYBsAQTS58k6s4x2jV8VLH6KdgxoFQGQLVmAbAUE0ufZQLOMdo1faxyQtOMhWxMAuRALkG2AQPo83WiW0a7xWxgHJO14yIUJgGzLAuQiQCB9ns80y2jX+LXDAUk7HrIdAZCLsgDZHgikzxOmZhntGr8OOCBpx0N2IACyIwuQnYBA+jwja5bRrvHrjAOSdjxkZwIgu7AA2RUIpM9TvmYZ7Rq/xXBA0o6HXIwAyG4sQC4OBNLnOWWzjHaNX3cckLTjIbsTALkEC5A9gED6PGltltGu8VsSByTteMglCYBcigXIpYFA+jwrbpbRrvHriQOSdjxkTwIgl2EBshcQSJ+n3c0y2jV+y+KApB0PuSwBkL1ZgFwOCKTP8/pmGe0av+VxQNKOh1yeAMgVWIBcEQikzxMHZxntGr+VcEDSjodciQDIPAuQCgikzzMTZxntGr9qHJC04yGrCYDswwJkXyCQPk99nGW0a/z64YCkHQ/ZjwDI/ixADgAC6fPcyllGu8ZvIA5I2vGQAwmAHMQC5MpAIH2dvFkyfqsA4+fpZMmi0yGu+u+PX33+wV8dE5cxXaDcn4V1590WpTXvI6D7l4JMf1MC1g/0R6E1oz0ZLpTjvxPk+H4Cuv8ocOQ40B+F1FxqeWIvaP/3xZWVt9u7WlnDdlnKO72YY3uFgKYoVU86jq2L7INWLmGSDii63MFlOOCldA8ug3tUn6gVUUMS7hmvc+J1r+Rz7+RTL6vrGMVreby9fNSQxGa/Kcvs3y/5Xf3/powh8XZNUsYK1nfNfntJd3CuviA9XgN4Av1PPFgzrnetJH4rWjEy+7M8WNPyYGi8vXZSxkrWd83+dBn7JGUMTcrQNq0T/zMsKSNvfdfsT5exb1LGOkkZWuvweHvdpAxlfdfstxf0QXm9+c+FfKos1VQHqPXKZA5QI8IBCmvSCIED1EjPD1Ba90iBA1RkLZIxzTsupVEDKHpBn53vFJeBvOv1RtzYVYX9cixbCZbdqC67w1s/icsoKz6Vlq/muxXJZ87yXv/KXKusnPWZs8qYa/1Ose/kMsqptPaZ329ttQUYk7xAh58X7dBzSXC1gbOSivTPoyxw0J2IARP+2viC37dLTAeC1h0N8fJPEI3O+tYHHpBHAcvKNVH88m6LAua3AuaMkoofmpPRhFcwo4WuYMaEKxisSWMErmDGen4Fo3WPFTojlvhbhURb01cxZkG3f5RDR1A3z1LbZFccEh6Cysrbnd24JC/Gz+fVS00Rzemrl5rov1+9FCvnX3X14nNCmCufcWUNxuifdVIMieZd0Gd2QB1qPPCgsQGs06mrM/HcwIqnRD6MErjCKh8ie3BzPRudbuUtUneFX7obtW96wie63GaeXhGmD+TIfsPOcefZUEiuqIH5rYA5o6TiVwLmZBzwWDMBeKtelyFxbJlQJtOHIb2WuFv7eiled6shfuvWd2vfFNDd2s+7tY3auSGQR6DXqrXneaN5eVsgbxYm4OUdAd1tSXjZCMgL0GvVloCX9wTyZlECXt4X0N2ehJeNgbwAvVbtCXj5UCBvOhHw8pGA7s4kvGwC5AXotepMwMsnAnmzGAEvnwro7kbCy6ZAXoBeq24EvHwukDdLEPDyhYDuHiS8bAbkBei16kHAy1cCebM0AS9fC+juScLL5kBegF6rngS8fCuQN8sS8PKdgO7eJLxsAeQF6LXqTcDLDwJ5swIBLz8K6F6RhJctgbwAvVYrEvDys0DeKAJefhHQXU3Cy0QgL0CvVTUBL78J5E0/Al5+F9Ddn4SXSUBegF6r/gS8/CmQN4MIeJkjoHtlEl4mA3kBeq1WJuAlEnhubjUCXnICugeT8DIFyAvQazWYgJdSgbwZQsBLmYDuGhJeaoG8AL1WNQS8VAjkzVoEvDQT0D2UhJc6IC9Ar9VQAl4qBfJmGAEvLQR0DyfhZSsgL0Cv1XACXloK5M0IAl5aCegeScLL1kBegF6rkQS8LCSQN6MJeGkjoHsMCS/bAHkBeq3GEPDSViBvxhPwsoiA7g1IeJkK5AXotdqAgJdFBfJmIwJe2gvo3piEl22BvAC9VhsT8NJRIG82I+Clk4DuzUl42Q7IC9BrtTkBL10E8mYiAS9dBXRPIuFleyAvQK/VJAJeugnkTS0BL4sL6K4j4WUHIC9Ar1UdAS9LCOTNNgS89BDQPZWElx2BvAC9VlMJeFlKIG+2J+BlaQHdO5DwMg3IC9BrtQMBL8sI5M1OBLz0EtC9MwkvOwF5AXqtdibgpbdA3uxGwMtyArp3J+FlZyAvQK/V7gS8rCCQN3sS8LKigO69SHjZBcgL0Gu1FwEveYG82ZeAFyWgez8SXnYF8gL0Wu1HwEsfgbw5gICXvgK6DyThZTcgL0Cv1YEEvPQXyJtDCHgZIKD7UBJedgfyAvRaHUrAyyCBvDmCgJeVBXQfScLLHkBegF4rZPzK4zKq47V7Up6ew0PPS6Dfta7fH63fiavf86nfXajfx6bfMaXfm6PfBaLfb6DHbOtxqHpsnR4vpMdA6Oe69bOq+vk7/UyRfk5C/+1X/z1L36PX9x31vRR9fajPefVxXPdNe5RFkaSf04F+ejqzskg/MFjPvyfQDxzjue41Ys3DBXQfS9L/7QnkBei1QsZPdznVUeMF1VZTHjo3gX1ZXqqNe5bJ5Dn+hmoZTUKJmbUXQULtLZVQJeCEmg4sa58yfG+kF/TRYt8FZPa3rOR2vksNjB9rJ7QfQSc0Q6oTQgO5/wIyvVyW0c63/3Hxq2YF8gACIA9kAfIgIJA+z1+XZbRr/A7Gxa8PK5AHEwB5CAuQhwKB9HmCvCyjXeN3GC5+fVmBPIwAyMNZgDwCCKTPM/BlGe38lzVc/PqxAnkkAZBHsQB5NBBIn6f4yzLa+U9cuPj1ZwXyGAIgj2UB8jggkD7PIZhltGv8jsfFbwArkMcTAHkCC5AnAoH0eZLCLKNd43cSLn4DWYE8iQDIk1mAPAUIpM+zIGYZ7Rq/U3HxG8QK5KkEQJ7GAuTpQCB9nmYxy2jX+J2Bi99EViDPIADyTBYgzwIC6fM8jllGu8bvbFz8JrECeTYBkOewAHkuEEifJ4rMMto1fufh4jeZFcjzCIA8nwXIC4BA+jwTZZbRrvG7EBe/KaxAXkgA5EUsQF4MBNLnqS6zjHaN3yW4+NWyAnkJAZCXsgB5GRBIn+fSzDLaNX6X4+JXxwrk5QRAXsEC5JVAIH2erDPLaNf4XQWLn6IdA3oVAZBXswB5DRBIn2cDzTLaNX7X4oCkHQ95LQGQ17EAORMIpM/TjWYZ7Rq/63FA0o6HvJ4AyBtYgLwRCKTP85lmGe0av5twQNKOh7yJAMibWYC8BQikzxOmZhntGr9bcUDSjoe8lQDI21iAvB0IpM8zsmYZ7Rq/O3BA0o6HvIMAyDtZgLwLCKTPU75mGe0av7txQNKOh7ybAMhZLEDeAwTS5zlls4x2jd+9OCBpx0PeSwDkfSxA3g8E0udJa7OMdo3fAzggacdDPkAA5IMsQD4EBNLnWXGzjHaN38M4IGnHQz5MAOQjLEA+CgTS52l3s4x2jd9jOCBpx0M+RgDk4yxAPgEE0ud5fbOMdo3fkzggacdDPkkA5FMsQD4NBNLniYOzjHaN3zM4IGnHQz5DAORsFiCfBQLp88zEWUa7xu85HJC04yGfIwDyeRYgXwAC6fPUx1lGu8bvRRyQtOMhXyQA8iUWIF8GAunz3MpZRrvG7xUckLTjIV8hAPJVFiBfAwLp6+TNkvF7HRg/TydLFp0O8Y1/f/zq8w99ICiJy5ghUO4JwrrzbovSmg8S0H2iUH9TAtYP9Eed6HmODxfK8VMIcvwQAd2nkuQ40B+F1FxqeWIvaP8PxpWVt9v7ZlnDdlnKO72YY3uFgKYoVU86jq2L7INWLmGSDii63LfKcMBL6X6rDO5RfaJWRA1JuH+8zonXA5LPA5NPvbwd1/9OvJbrGEUNSWz2m7LM/kOS39X/b8p4N95+Lymjr/Vds99e0h2cqy9Ij98HnkD/Ew8+iOv9MIlfPytGZn+WBx9YHnwUb3+clNHf+q7Zny7joKSMj5IytE2fxP98mpQxwPqu2Z8u4+CkjE+SMrTWz+Ltz5MyBlrfNfvtBX1Q/mL+cyGfKks11QHqizKZA9SX4QCFNelLgQPUV54foLTurwQOUJG1SMY077iURg2g6AV9dj49LgN512ufuKw3hP1yLFsJlt2oLrvD+zqJyzdWfCotX813K5LPnOW9/pW5Vlk56zNnlTHX+p1i38lllFNp7TO/39pqCzAmeYEOPy/aoeeS4GoDZyUV6Z+/scBBdyIGTPQZyhlD/L5dYjoQtO4z/fwTRKOzvq+BB+RvgGWd1UTxy7stCpjfCpgzSip+aE6+JbyC+VboCua7cAWDNek7gSuY7z2/gtG6vxc6I5b4W4VEW9NXMWZBt/8bh46gbp6ltsmuOCQ8BJWVtzu7H5K8+HE+r15qimhOX73URP/96qVYOf+qqxefE8Jc+fxQ1mCM/lknxZBo3gV9ZgfUoX4EHjR+gnU6dXUmnj9Z8ZTIh28ErrDO8+sBhEZnozOsvEXqPt/zBy9mJHyiy73A0yvC9IEc2W/YOe48XxjJFTUwvxUwZ5RU/ErAnPwAPNb8DLxVr8uQOLb8XCbThyG9lrhbu7eA7ssI7tbuK6D7cj/v1jZq5y9AHoFeq8s9zxvNywyBvLmKgJf9BXRfTcLLr0BegF6rqwl4OVAgb64j4OUgAd0zSXj5DcgL0Gs1k4CXQwTy5kYCXg4V0H0TCS+/A3kBeq1uIuDlcIG8uZWAlyMEdN9GwssfQF6AXqvbCHg5SiBv7iTg5WgB3XeR8PInkBeg1+ouAl6OFcibewh4OU5A970kvMwB8gL0Wt1LwMsJAnnzAAEvJwrofpCEl7lAXoBeqwcJeDlZIG8eIeDlFAHdj5Lwogd5omIJ9Fo9SsDLaQJ58wQBL6cL6H6ShJcckBeg1+pJAl7OFMibZwh4OUtA92wSXkqAvAC9VrMJeDlHIG+eJ+DlXAHdL5DwUgrkBei1eoGAl/MF8uZlAl4uEND9CgkvZUBegF6rVwh4uUggb14n4OViAd1vkPBSDuQF6LV6g4CXSwXy5m0CXi4T0P0OCS8VQF6AXqt3CHi5QiBv3ifg5UoB3R+Q8NIMyAvQa/UBAS9XC+TNxwS8XCOg+xMSXpoDeQF6rT4h4OU6gbz5nICXmQK6vyDhpRLIC9Br9QUBLzcI5M3XBLzcKKD7GxJeWgB5AXqtviHg5WaBvPmegJdbBHT/QMJLFZAXoNfqBwJebhPIm58JeLldQPcvJLy0BPIC9Fr9QsDLnQJ58zsBL3cJ6P6DhJdWQF6AXqs/CHiZJZA3cwl4uUdAt34LJFK3FC+tgbwAvVbo+Enwcp9A3pR6rlvzcr+A7jISXhYC8gL0WpUR8PKgQN40I+DlIQHdzUl4aQPkBei1ak7AyyMCeVNFwMujArpbkvCyMJAXoNeqJQEvjwvkzUIEvDwhoLsNCS9tgbwAvVZtCHh5SiBvFiHg5WkB3e1IeFkEyAvQa9WOgJfZAnnTgYCXZwV0dyThpR2QF6DXqiMBL88L5E0XAl5eENDdlYSXRYG8AL1WXQl4eUkgbxYn4OVlAd3dSXhpD+QF6LXqTsDLqwJ5syQBL68J6F6KhJcOQF6AXitk/GKJ0aB47Z6Up+fw0PMS6Het6/dH63fi6vd86ncX6vex6XdM6ffm6HeB6Pcb6DHbehyqHlunxwvpMRD6uW79rKp+/k4/U6Sfk9B/+9V/z9L36PV9R30vRV8f6nNefRzXfZOOt6SfHYF+ejqzskg/8Fbs+7sC/cAynvd/78eaPxPQ3Yuk/+sE5AXotULGT3dpg6LGC6qtpjx0bgL7srxUGzuVy+Q5HMjO5TQJJWZWZ4KE6iKVUCXghJoBLKtrOb430gv6aLEYsJ0+z/6Wldyu8esGjB9rJ9SNoBNaXKoTQgPZHZhQPk8vl2W0a/yWwMWvmhXIJQiA7MEC5JJAIH2evy7LaOf7hrj49WEFcikCIJdmAbInEEifJ8jLMtr5Bh4ufn1ZgVyGAMheLEAuCwTS5xn4sox2jV9vXPz6sQLZmwDI5ViAXB4IpM9T/GUZ7Rq/FXDx688K5AoEQK7IAuRKQCB9nkMwy2jX+OVx8RvACmSeAEjFAmQ1EEifJynMMto1fn1w8RvICmQfAiD7sgDZbwGZBTHLaNf49cfFbxArkP0JgBzAAuTABWSaxSyjXeM3CBe/iaxADiIAcmUWIFdZQOZxzDLaNX6r4uI3iRXIVQmAXI0FyMELyESRWUa7xm91XPwmswK5OgGQBRYghywgM1FmGe0avxpc/KawAllDAOQaLECuuYBMdZlltGv81sLFr5YVyLUIgBzKAuTaC8hcmllGu8ZvHVz86liBXIcAyGEsQA5fQCbrzDLaNX7rwuKnaMeArksA5HosQI5YQGYDzTLaNX4jcUDSjoccSQDk+ixAjlpAphvNMto1fqNxQNKOhxxNAOQYFiDHLiDzmWYZ7Rq/cTggacdDjiMAcjwLkBssIBOmZhntGr8JOCBpx0NOIAByQxYgN1pAZmTNMto1fhvjgKQdD7kxAZCbsAC5KRBIn6d8zTLaNX6b4YCkHQ+5GQGQm7MAuQUQSJ/nlM0y2jV+W+KApB0PuSUBkBNZgJwEBNLnSWuzjHaN32QckLTjIScTADmFBchaIJA+z4qbZbRr/OpwQNKOh6wjAHIrFiC3BgLp87S7WUa7xm8bHJC04yG3IQByKguQ2wKB9Hle3yyjXeO3HQ5I2vGQ2xEAuT0LkDsAgfR54uAso13jtyMOSNrxkDsSADmNBcidgED6PDNxltGu8dsZByTteMidCYDchQXIXYFA+jz1cZbRrvHbDQck7XjI3QiA3J0FyD2AQPo8t3KW0a7xm44DknY85HQCIPdkAXIvIJC+Tt4sGb+9gfHzdLJk0ekQ9/n3x68+/9AHgpK4jEMFyl2uRlZ33m1RWvORArqXF+pvSsD6gf6o5Wv8zvHhQjm+EkGOHy2gO0+S40B/FFJzqeWJvaD9PwpXVt5u777lDdtlKe/0Yo7tFQKaolQ96Ti2LrIPWrmESTqg6HL3K8cBL6V7v3K4R/WJWhE1JOFh8TonXg9PPo9IPvUyI65//3jVzVg5akhis9+UZfYfnfyu/n9TxgHx9oFJGatY3zX77SXdwbn6gvT4IOAJ9D/x4OC43kOS+K1qxcjsz/LgYMuDQ+Ptw5IyVrO+a/anyzgyKePQpAzdiR0ebx+RlDHY+q7Zny7jKKMpKUNrPTLePiopY3W7vmS/vaAPykfPfy7kU2WppjpAHV0uc4A6JhygsCYdI3CAOtbzA5TWfazAASqyFsmY5h2X0qgBFL2gz85nxGUg73p1jcvaR9gvx7KVYNmN6rI7vOOSuBxvxafS8tV8tyL5zFne6w50rlVWzvrMWWXMtX6n2HdyGeVUWvvM77e22gKMSV6gw8+Ldui5JLjawFlJRfrn4y1w0J2IARN9htLH89slpgNB6+5bI9MZOd5Cb3TWdxzwgHw8sKx+TRS/vNuigPmtgDmjpOKH5uQEwiuYE4SuYE4MVzBYk04UuII5yfMrGK37JKEzYom/VUi0NX0VYxZ0+4936Ajq5llqm+yKQ8JDUFl5u7M7OcmLU+bz6qWmiOb01UtN9N+vXoqV86+6evE5IcyVz8nlDcbon3VSDInmXdBndkAd6hTgQeNUWKdTV2fieaoVT4l8OF7gCmuQ8JWl69nooVbeInWv7JfuRu07NOETXe4qnl4Rpg/kyH7DznHnGTVJrqiB+a2AOaOk4lcC5uRk4LHmNOCtel2GxLHltHKZPgzptcTd2i4CuocQ3K1dTEB3jZ93axu183Qgj0CvVY3neaN5WVwgb9Yi4KW7gO6hJLycAeQF6LUaSsBLD4G8GUbAy5ICuoeT8HImkBeg12o4AS9LC+TNCAJeegroHknCy1lAXoBeq5EEvPQSyJvRBLwsK6B7DAkvZwN5AXqtxhDwspxA3own4GV5Ad0bkPByDpAXoNdqAwJeVhTIm40IeFlJQPfGJLycC+QF6LXamIAXJZA3mxHwUi2ge3MSXs4D8gL0Wm1OwEtfgbyZSMBLPwHdk0h4OR/IC9BrNYmAlwECeVNLwMtAAd11JLxcAOQF6LWqI+BlZYG82YaAl1UEdE8l4eVCIC9Ar9VUAl5WE8ib7Ql4GSygewcSXi4C8gL0Wu1AwEtBIG92IuBliIDunUl4uRjIC9BrtTMBL2sI5M1uBLysKaB7dxJeLgHyAvRa7U7Ay1CBvNmTgJe1BXTvRcLLpUBegF6rvQh4GSaQN/sS8DJcQPd+JLxcBuQF6LXaj4CX9QTy5gACXkYI6D6QhJfLgbwAvVYHEvCyvkDeHELAyyiJ8YEkvFwB5AXotTqUgJcxAnlzBAEvYwV0H0nCy5VAXoBeqyMJeBkvkDfHEPCygYDuY0l4uQrIC9BrdSwBLxsK5M0JBLxsJKD7RBJergbyAvRanUjAyyYCeXMKAS+bCug+lYSXa4C8AL1WpxLwsrlA3pxBwMsWArrPJOHlWiAvQK/VmQS8TBTIm3MIeJkkoPtcEl6uA/IC9FqdS8DLFIG8uYCAl1oB3ReS8DITyAvQa3UhAS9bCeTNJQS8bC2g+1ISXq4H8gL0Wl1KwMtUgby5goCXbQV0X0nCyw1AXoBeqysJeNleIG+uIeBlBwHd15LwciOQF6DX6loCXqYJ5M31BLzsJKD7BhJebgLyAvRa3UDAyy4CeXMzAS+7Cui+hYSXm4G8AL1WtxDwsrtA3txOwMseArrvIOHlFiAvQK/VHQS87CmQN3cT8LKXgO5ZJLzcCuQF6LVCxq88iVf3pDw9h4eel0C/a12/P1q/E1e/51O/u1C/j02/Y0q/N0e/C0S/30CP2dbjUPXYOj1eSI+B0M9162dV9fN3+pki/ZyE/tuv/nuWvkev7zvqeyn6+lCf8+rjuO6bdLwl/bwN6KenMyuL9AP7xXE7QKAfuM9z3QfFmo8U0H0/Sf93O5AXoNcKGb8yK172gmqrKQ+dm8C+LC/VxtvLZfIcfwJfTpNQYmbdQZBQd0olVAk4oQ4FlnVXOb430gv6aHE3sJ0+z/6WldzOV0XA+LF2QrMIOqF7pDohNJD3AhPK5+nlsox2vjzBxa+aFcj7CIC8nwXIB4BA+jx/XZbRrvF7EBe/PqxAPkgA5EMsQD4MBNLnCfKyjHaN3yO4+PVlBfIRAiAfZQHyMSCQPs/Al2W0a/wex8WvHyuQjxMA+QQLkE8CgfR5ir8so13j9xQufv1ZgXyKAMinWYB8Bgikz3MIZhntGr/ZuPgNYAVyNgGQz7IA+RwQSJ8nKcwy2jV+z+PiN5AVyOcJgHyBBcgXgUD6PAtiltGu8XsJF79BrEC+RADkyyxAvgIE0udpFrOMdo3fq7j4TWQF8lUCIF9jAfJ1IJA+z+OYZbRr/N7AxW8SK5BvEAD5JguQbwGB9HmiyCyjXeP3Ni5+k1mBfJsAyHdYgHwXCKTPM1FmGe0av/dw8ZvCCuR7BEC+zwLkB0AgfZ7qMsto1/h9iItfLSuQHxIA+RELkB8DgfR5Ls0so13j9wkufnWsQH5CAOSnLEB+BgTS58k6s4x2jd/nsPgp2jGgnxMA+QULkF8CgfR5NtAso13j9xUOSNrxkF8RAPk1C5DfAIH0ebrRLKNd4/ctDkja8ZDfEgD5HQuQ3wOB9Hk+0yyjXeP3Aw5I2vGQPxAA+SMLkD8BgfR5wtQso13j9zMOSNrxkD8TAPkLC5C/AoH0eUbWLKNd4/cbDkja8ZC/EQD5OwuQfwCB9HnK1yyjXeP3Jw5I2vGQfxIAOYcFyLlAIH2eUzbLaNf4RRUwIGnHQ+JiINfGXAUJkCW4hno9aW2W0a7xK8UBSTsespQAyDIWIMuBQPo8K26W0a7xq8ABSTsesoIAyGYsQDYHAunztLtZRrvGrxIHJO14yEoCIFuwAFkFBNLneX2zjHaNX0sckLTjIVsSANmKBcjWQCB9njg4y2jX+C2EA5J2PORCBEC2YQFyYSCQPs9MnGW0a/za4oCkHQ/ZlgDIRViAbAcE0uepj7OMdo3fojggacdDLkoAZHsWIDsAgfR5buUso13j1xEHJO14yI4EQHZiAbIzEEhfJ2+WjF8XYPw8nSxZdDrErv/++NXnH/pAUBKXcYxAuQ8J6867LUprPkFA98NC/U0JWD/QH/Ww5zk+XCjHHyPI8ZMEdD9OkuNAfxRSc6nlib2g/T8RV1bebu9iFQ3bZSnv9GKO7RUCmqJUPek4ti6yD1q5hEk6oOhyu1XggJfS3a0C7lF9olZEDUl4bLzOidfjks/jk0+9LB5/sXu8lsfbQ6KGJDb7TVlm/0nJ7+r/N2UsEW/3SMqosb5r9ttLuoNz9QXp8ZLAE+h/4sFS8ReXTuK3hhUjsz/Lg6UsD3rG28skZaxpfdfsT5dxQlJGz6QM3Yn1ireXTcpYy/qu2Z8u48SkjF5JGVpr73h7uaSModZ3zX57QR+Ul5//XMinylJNdYBavkLmALVCOEBhTVpB4AC1oucHKK17RYEDVGQtkjHNOy6lUQMoekGfnR8al4G863VX3Ot2FfbLsWwlWHajuuwOb6UkLnkrPpWWr+a75r9zlve6A51rlZWzPnNWGXOt3yn2nVxGOZXWPvP7ra22AGOSF+jw86Idei4JrjZwVlKR/jlvgYPuRAyY8Mk5Pb9dYjoQtO6na2Q6I8db6I3O+lYCHpDzwLKeaaL45d0WBcxvBcwZJRU/NCeK8ApGCV3BVIcrGKxJ1QJXMH08v4LRuvsInRFL/K1Coq3pqxizoNufd+gI6uZZapvsikPCQ1BZebuz65vkRb/5vHqpKaI5ffVSE/33q5di5fyrrl58Tghz5dO3osEY/bNOiiHRvAv6zA6oQ/UDHjT6wzqdujoTz/5WPCXyIS9whfW88JWl69noMVbeInW/4JfuRu07JuETXe6Lnl4Rpg/kyH7DznHnOadJrqiB+a2AOaOk4lcC5qQv8FgzAHirXpchcWwZUCHThyG9lrhbe2c5XvfrBHdr7xbQ/Yafd2sbtXMgkEeg1+oNz/NG83KPQN68TcDLvQK63yHhZRCQF6DX6h0CXu4XyJv3CXh5QED3ByS8rAzkBei1+oCAl4cE8uZjAl4eFtD9CQkvqwB5AXqtPiHg5VGBvPmcgJfHBHR/QcLLqkBegF6rLwh4eUIgb74m4OVJAd3fkPCyGpAXoNfqGwJenhbIm+8JeHlGQPcPJLwMBvIC9Fr9QMDLswJ58zMBL88J6P6FhJfVgbwAvVa/EPDygkDe/E7Ay4sCuv8g4aUA5AXotfqDgJeXBfJmLgEvrwjo1oOmkbqleBkC5AXotULHT4KX1wTyptRz3ZqX1wV0l5HwUgPkBei1KiPg5U2BvGlGwMtbArqbk/CyBpAXoNeqOQEv7wjkTRUBL+8K6G5JwsuaQF6AXquWBLy8L5A3CxHw8oGA7jYkvKwF5AXotWpDwMtHAnmzCAEvHwvobkfCy1AgL0CvVTsCXj4VyJsOBLx8JqC7IwkvawN5AXqtOhLw8oVA3nQh4OVLAd1dSXhZB8gL0GvVlYCXrwXyZnECXr4R0N2dhJdhQF6AXqvuBLx8J5A3SxLw8r2A7qVIeBkO5AXotVqKgJcfBfJmGQJefhLQ3YuEl3WBvAC9Vr0IePlFIG+WI+DlVwHdy5Pwsh6QF6DXankCXn4XyJuVCHj5Q0B3noSXEUBegF6rPAEvcwTypg8BL3MFdPcl4WUkkBeg16ovAS85gfdIDSDgpURA90ASXtYH8gL0Wg0k4KVMIG9WIeClXED3qiS8jALyAvRarUrASzOBvFmdgJfmAroLJLyMBvIC9FoVCHhpIZA3axDwUiWge00SXsYAeQF6rdYk4KWVQN6sTcBLawHd65DwMhbIC9BrtQ4BL20E8mZdAl4WFtC9Hgkv44C8AL1W6xHwsohA3qxPwEs7Ad2jSHgZD+QF6LUaRcBLe4G8GUvASwcB3eNIeNkAyAvQazWOgJdOAnkzgYCXzgK6NyThZQKQF6DXChm/2OJo7XjtnpSn5/DQ8xLod63r90frd+Lq93zqdxfWv49Nz8UWr/pdIPr9BnrMth6HqsfW6fFCegyEfq5bP6uqn7/TzxTp5yT0337137P0PXp931HfS9HXh/qcVx/Hdd80wZ6hUMDPDYF+ejqzskg/0C2O2xIC/cAmnvd/S8aaewvo3pSk/9sIyAvQa4WMn56Mde2o8YJqqykPnZvAviwv1caNKmTyHA7kxhU0CSVm1sYECbWJVEKVgBPqGGBZm1bgeyO9oI8Wmy0gs79lJbdr/DYHxo+1E9qcoBPaQqoTQgO5JTChfJ5eLsto1/hNxMWvmhXIiQRATmIBcjIQSJ/nr8sy2jV+U3Dx68MK5BQCIGtZgKwDAunzBHlZRrvGbytc/PqyArkVAZBbswC5DRBIn2fgyzLaNX5TcfHrxwrkVAIgt2UBcjsgkD5P8ZdltGv8tsfFrz8rkNsTALkDC5A7AoH0eQ7BLKNd4zcNF78BrEBOIwByJxYgdwYC6fMkhVlGu8ZvF1z8BrICuQsBkLuyALkbEEifZ0HMMto1frvj4jeIFcjdCYDcgwXI6UAgfZ5mMcto1/jtiYvfRFYg9yQAci8WIPcGAunzPI5ZRrvGbx9c/CaxArkPAZD7sgC5HxBInyeKzDLaNX4zcPGbzArkDAIg92cB8gAgkD7PRJlltGv8DsTFbworkAcSAHkQC5AHA4H0earLLKNd43cILn61rEAeQgDkoSxAHgYE0ue5NLOMdo3f4bj41bECeTgBkEewAHkkEEifJ+vMMto1fkfB4qdox4AeRQDk0SxAHgME0ufZQLOMdo3fsTggacdDHksA5HEsQB4PBNLn6UazjHaN3wk4IGnHQ55AAOSJLECeBATS5/lMs4x2jd/JOCBpx0OeTADkKSxAngoE0ucJU7OMdo3faTggacdDnkYA5OksQJ4BBNLnGVmzjHaN35k4IGnHQ55JAORZLECeDQTS5ylfs4x2jd85OCBpx0OeQwDkuSxAngcE0uc5ZbOMdo3f+TggacdDnk8A5AUsQF4IBNLnSWuzjHaN30U4IGnHQ15EAOTFLEBeAgTS51lxs4x2jd+lOCBpx0NeSgDkZSxAXg4E0udpd7OMdo3fFTggacdDXkEA5JUsQF4FBNLneX2zjHaN39U4IGnHQ15NAOQ1LEBeCwTS54mDs4x2jd91OCBpx0NeRwDkTBYgrwcC6fPMxFlGu8bvBhyQtOMhbyAA8kYWIG8CAunz1MdZRrvG72YckLTjIW8mAPIWFiBvBQLp89zKWUa7xu82HJC04yFvIwDydhYg7wAC6evkzZLxuxMYP08nSxadDvGuf3/86vMPfSAoics4WaDcLTyfbFprPl1A95ZC/U0JWD/QH7XlGn7n+HChHJ9MkONnCuieQpLjQH8UUnOp5Ym9oP0/A1dW3m7v3RUN22Up7/Riju0VApqiVD3pOLYusg9auYRJOqDocmdV4ICX0j2rAu5RfaJWRA1JeEq8zonXU5PP05JPvdwTf/HeeC2Pt9eJGpLY7Ddlmf1nJr+r/9+UcV+8fX9SxjDru2a/vaQ7OFdfkB4/ADyB/icePBh/8aEkfsOtGJn9WR48aHnwcLz9SFLGutZ3zf50GacnZTyclKE7sUfj7ceSMtazvmv2p8s4Iynj0aQMrfXxePuJpIwR1nfNfntBH5SfnP9cyKfKUk11gHqyQuYA9VQ4QGFNekrgAPW05wcorftpgQNUZC2SMc07LqVRAyh6QZ+dHxOXgbzrtWlc1l3CfjmWrQTLblSX3eE9k8RlthWfSstX813z3znLe92BzrXKylmfOauMudbvFPtOLqOcSmuf+f3WVluAMckLdPh50Q49lwRXGzgrqUj/PNsCB92JGDDRZyhbeX67xHQgaN1b+/kniEZnfc8AD8izgWVt00Txy7stCpjfCpgzSip+aE6eJbyCeVboCua5cAWDNek5gSuY5z2/gtG6nxc6I5b4W4VEW9NXMWZBt3+2Q0dQN89S22RXHBIegsrK253dC0levDifVy81RTSnr15qov9+9VKsnH/V1YvPCWGufF6oaDBG/6yTYkg074I+swPqUC8CDxovwTqdujoTz5eseErkw2yBK6zt/XoAodHZ6MlW3iJ17+D5gxcnJ3yiy93R0yvC9IEc2W/YOe4av2kkV9TA/FbAnFFS8SsBc/IC8FjzMvBWvS5D4tjycoVMH4b0WuJu7SYCuncjuFu7mYDu3UkeGH8FyCPQa7W753mjedlCIG/2JOBlSwHde5Hw8iqQF6DXai8CXiYJ5M2+BLxMFtC9HwkvrwF5AXqt9iPgpVYgbw4g4KVOQPeBJLy8DuQF6LU6kICXrQXy5hACXrYR0H0oCS9vAHkBeq0OJeBlW4G8OYKAl+0EdB9JwsubQF6AXqsjCXjZQSBvjiHgZUcB3ceS8PIWkBeg1+pYAl52EsibEwh42VlA94kkvLwN5AXotTqRgJddBfLmFAJedhPQfSoJL+8AeQF6rU4l4GUPgbw5g4CX6QK6zyTh5V0gL0Cv1ZkEvOwlkDfnEPCyt4Duc0l4eQ/IC9BrdS4BL/sK5M0FBLzsJ6D7QhJe3gfyAvRaXUjAy/4CeXMJAS8HCOi+lISXD4C8AL1WlxLwcpBA3lxBwMvBArqvJOHlQyAvQK/VlQS8HCqQN9cQ8HKYgO5rSXj5CMgL0Gt1LQEvRwjkzfUEvBwpoPsGEl4+BvIC9FrdQMDL0QJ5czMBL8cI6L6FhJdPgLwAvVa3EPBynEDe3E7Ay/ECuu8g4eVTIC9Ar9UdBLycKJA3dxPwcpKA7lkkvHwG5AXotZpFwMspAnlzHwEvpwrovp+El8+BvAC9VvcT8HK6QN48RMDLGQK6Hybh5QsgL0Cv1cMEvJwlkDePEfBytoDux0l4+RLIC9Br9TgBL+cK5M1TBLycJ6D7aRJevgLyAvRaPU3AywUCefMsAS8XCuh+joSXr4G8AL1WzxHwcrFA3rxIwMslArpfIuHlGyAvQK/VSwS8XCaQN68S8HK5gO7XSHj5FsgL0Gv1GgEvVwrkzZsEvFwloPstEl6+A/IC9Fq9RcDLNQJ58y4BL9cK6H6PhJfvgbwAvVbvEfAyUyBvPiTg5XoB3R+R8PIDkBeg1+ojAl5uFMibTwl4uUlA92ckvPwI5AXotfqMgJdbBPLmSwJebhXQ/RUJLz8BeQF6rb4i4OV2gbz5loCXOwR0f0fCy89AXoBeK2T8yuMyRsZr96Q8PYeHnpdAv2tdvz9avxNXv+dTv7tQv49Nv2NKvzdHvwtEv99Aj9nW41D12Do9XkiPgdDPdetnVfXzd/qZIv2chP7br/57lr5Hr+876nsp+vpQn/Pq47jum3S8Jf38BeinpzMri/QDs+K43SfQD/zoue4HYs2PC+j+iaT/+xXIC9BrhYyfnox1ZNR4QbXVlIfOTWBflpdq468VMnkOB/K3CpqEEjPrN4KE+l0qoUrACXUysKw/KvC9kV7QR4s/ge30efa3rOR2jd8cYPxYO6E5BJ3QXKlOCA1k1Awn2ufp5bKMdo1fDhe/alYggTEQa2NJMxIgS4FA+jx/XZbRrvErw8WvDyuQZQRAlrMAWQEE0ucJ8rKMdo1fM1z8+rIC2YwAyOYsQFYCgfR5Br4so13j1wIXv36sQLYgALKKBciWQCB9nuIvy2jX+LXCxa8/K5CtCIBszQLkQkAgfZ5DMMto1/i1wcVvACuQbQiAXJgFyLZAIH2epDDLaNf4LYKL30BWIBchALIdC5CLAoH0eRbELKNd49ceF79BrEC2JwCyAwuQHYFA+jzNYpbRrvHrhIvfRFYgOxEA2ZkFyC5AIH2exzHLaNf4dcXFbxIrkF0JgFyMBchuQCB9nigyy2jX+C2Oi99kViAXJwCyOwuQSwCB9HkmyiyjXePXAxe/KaxA9iAAckkWIJcCAunzVJdZRrvGb2lc/GpZgVyaAMieLEAuAwTS57k0s4x2jV8vXPzqWIHsRQDksixA9gYC6fNknVlGu8ZvOVj8FO0Y0OUIgFyeBcgVgED6PBtoltGu8VsRByTteMgVCYBciQXIPBBIn6cbzTLaNX4KByTteEhFAGQ1C5B9gED6PJ9pltGu8euLA5J2PGRfAiD7sQDZHwikzxOmZhntGr8BOCBpx0MOIAByIAuQg4BA+jwja5bRrvFbGQck7XjIlQmAXIUFyFWBQPo85WuW0a7xWw0HJO14yNUIgBzMAuTqQCB9nlM2y2jX+BVwQNKOhywQADmEBcgaIJA+T1qbZbRr/NbAAUk7HnINAiDXZAFyLSCQPs+Km2W0a/yG4oCkHQ85lADItVmAXAcIpM/T7mYZ7Rq/YTggacdDDiMAcjgLkOsCgfR5Xt8so13jtx4OSNrxkOsRADmCBciRQCB9njg4y2jX+K2PA5J2POT6BECOYgFyNBBIn2cmzjLaNX5jcEDSjoccQwDkWBYgxwGB9Hnq4yyjXeM3Hgck7XjI8QRAbsAC5AQgkD7PrZxltGv8NsQBSTseckMCIDdiAXJjIJC+Tt4sGb9NgPHzdLJk0ekQN/33x68+/9AHgpK4jLMEyv3V88mmtebzBHT/JtTflID1A/1Rv3me48OFcvxPghy/QED3HJIcB/qjkJpLLU/sBe3/+biy8nZ7N2vWsF2W8k4v5theIaApStWTjmPrIvuglUuYpAOKLnfzZjjgpXRv3gzuUX2iVkQNSXh2vM6J13OSz3OTT71sEde/ZbyWx9vrRw1JbPabssz+C5Lf1f9vypgYb09Kyhhlfdfst5d0B+fqC9LjycAT6H/iwZS43tokfqOtGJn9WR5MsTyoi7e3SsoYY33X7E+XcV5SRl1Shu7Eto63t0nKGGt91+xPl3F+UsbWSRla69R4e9ukjHHWd81+e0EflLeb/1zIp8pSTXWA2q6ZzAFq+3CAwpq0vcABagfPD1Ba9w4CB6jIWiRjmndcSqMGUPSCPjs/OS4Dedfrj5jmTYX9cixbCZbdqC67w9sxics0Kz6Vlq/muxXJZ87yXnegc62yctZnzipjrvU7xb6Tyyin0tpnfr+11RZgTPICHX5etEPPJcHVBs5KKtI/T7PAQXciBkz0GUpuTb9vl5gOBH6LdU2ZzsjxFnqjs74dgQfkacCySpsofnm3RQHzWwFzRknFD83JToRXMDsJXcHsHK5gsCbtLHAFs4vnVzBa9y5CZ8QSf6uQaGv6KsYs6PZPc+gI6uZZapvsikPCQ1BZebuz2zXJi93m8+qlpojm9NVLTfTfr16KlfOvunrxOSHMlc+uzRqM0T/rpBgSzbugz+yAOtRuwIPG7rBOp67OxHN3K54S+TBN4AqrmfCVpevZ6FlW3iJ1N/dLd6P2nZXwiS630tMrwvSBHNlv2DnuGr8WJFfUwPxWwJxRUvErAXOyK/BYswfwVr0uQ+LYskczmT4M6bXE3drfK/C6FyK4W/ungO42ft6tbdTO6UAegV6rNp7njeZlrkDeLELASyTQP7Yj4WVPIC9Ar1U7Al5KBPKmAwEvpQK6O5LwsheQF6DXqiMBL+UCedOFgJcKAd1dSXjZG8gL0GvVlYCX5gJ5szgBL5UCuruT8LIPkBeg16o7AS9VAnmzJAEvLQV0L0XCy75AXoBeq6UIeGktkDfLEPCykIDuXiS87AfkBei16kXAy8ICebMcAS9tBXQvT8LLDCAvQK/V8gS8tBPIm5UIeFlUQHeehJf9gbwAvVZ5Al46CORNHwJeOgro7kvCywFAXoBeq74EvHQWyJsBBLx0EdA9kISXA4G8AL1WAwl4WUwgb1Yh4KWbgO5VSXg5CMgL0Gu1KgEv3QXyZnUCXpYQ0F0g4eVgIC9Ar1WBgJclBfJmDQJelhLQvSYJL4cAeQF6rdYk4KWnQN6sTcDLMgK61yHh5VAgL0Cv1ToEvCwrkDfrEvDSW0D3eiS8HAbkBei1Wo+Al+UF8mZ9Al5WENA9ioSXw4G8AL1Wowh4WUkgb8YS8JIX0D2OhJcjgLwAvVbjCHipFsibCQS89BHQvSEJL0cCeQF6rTYk4KWfQN5sQsBLfwHdm5LwchSQF6DXalMCXgYK5M0WBLwMEtC9JQkvRwN5AXqttiTgZRWBvJlMwMuqArqnkPByDJAXoNdqCgEvgwXyZisCXlYX0L01CS/HAnkBeq22JuBliEDebEvAS42A7u1IeDkOyAvQa7UdAS9rCuTNjgS8rCWgexoJL8cDeQF6raYR8LK2QN7sQsDLOgK6dyXh5QQgL0Cv1a4EvAwXyJs9CHhZV0D3dBJeTgTyAvRaTSfgZYRA3uxNwMtIAd37kPByEpAXoNdqHwJeRgnkzQwCXkYL6N6fhJeTgbwAvVb7E/AyViBvDiLgZZyA7oNJeDkFyAvQa3UwAS8bCOTNYQS8TBDQfTgJL6cCeQF6rQ4n4GUjgbw5ioCXjQV0H03Cy2lAXoBeK2T8yuMyxsdr96Q8PYeHnpdAv2tdvz9avxNXv+dTv7tQv49Nv2NKvzdHvwtEv99Aj9nW41D12Do9XkiPgdDPdetnVfXzd/qZIv2chP7br/57lr5Hr+876nsp+vpQn/Pq47jum3S8Jf08HeinpzMri/QDm8dxmyjQDxznue7JseapArqPJ+n/zgDyAvRaIeNXFv3V/6UXVFtNeejcBPZleak2ntFMJs/hQJ7ZjCahxMw6kyChzpJKqBJwQp0FLOvsZvjeSC/oo8U5wHb6PPtbVnK7xu9cYPxYO6FzCTqh86Q6ITSQ5wMTyufp5bKMdo3fBbj4VbMCeQEBkBeyAHkREEif56/LMto1fhfj4teHFciLCYC8hAXIS4FA+jxBXpbRrvG7DBe/vqxAXkYA5OUsQF4BBNLnGfiyjHaN35W4+PVjBfJKAiCvYgHyaiCQPk/xl2W0a/yuwcWvPyuQ1xAAeS0LkNcBgfR5DsEso13jNxMXvwGsQM4kAPJ6FiBvAALp8ySFWUa7xu9GXPwGsgJ5IwGQN7EAeTMQSJ9nQcwy2jV+t+DiN4gVyFsIgLyVBcjbgED6PM1iltGu8bsdF7+JrEDeTgDkHSxA3gkE0ud5HLOMdo3fXbj4TWIF8i4CIO9mAXIWEEifJ4rMMto1fvfg4jeZFch7CIC8lwXI+4BA+jwTZZbRrvG7Hxe/KaxA3k8A5AMsQD4IBNLnqS6zjHaN30O4+NWyAvkQAZAPswD5CBBIn+fSzDLaNX6P4uJXxwrkowRAPsYC5ONAIH2erDPLaNf4PQGLn6IdA/oEAZBPsgD5FBBIn2cDzTLaNX5P44CkHQ/5NAGQz7AAORsIpM/TjWYZ7Rq/Z3FA0o6HfJYAyOdYgHweCKTP85lmGe0avxdwQNKOh3yBAMgXWYB8CQikzxOmZhntGr+XcUDSjod8mQDIV1iAfBUIpM8zsmYZ7Rq/13BA0o6HfI0AyNdZgHwDCKTPU75mGe0avzdxQNKOh3yTAMi3WIB8Gwikz3PKZhntGr93cEDSjod8hwDId1mAfA8IpM+T1mYZ7Rq/93FA0o6HfJ8AyA9YgPwQCKTPs+JmGe0av49wQNKOh/yIAMiPWYD8BAikz9PuZhntGr9PcUDSjof8lADIz1iA/BwIpM/z+mYZ7Rq/L3BA0o6H/IIAyC9ZgPwKCKTPEwdnGe0av69xQNKOh/yaAMhvWID8FgikzzMTZxntGr/vcEDSjof8jgDI71mA/AEIpM9TH2cZ7Rq/H3FA0o6H/JEAyJ9YgPwZCKTPcytnGe0av19wQNKOh/yFAMhfWYD8DQikr5M3S8bvd2D8PJ0sWXQ6xD/+/fGrzz/0gaAkLuNCgXJP8nyyaa35UgHdJwv1NyVg/UB/1Mme5/hwoRw/jSDHLxfQfTpJjgP9UUjNpZYn9gKfKwtXVt5u75/NGrbLUt7pxRzbKwQ0Ral60nFsXWQftHIJk3RA0eXOaYYDXkr3nGZwj+oTtSJqSMKLdD3xenHyeUnyqZe5uv7mUVQef2wQNSSx2W/KMvsvT35X/78pIxd/ryQpY4L1XbPfXtIdnKsvSI9LmwNPoP+BB2U6dkn8NrRiZPZneaD/35RREW83S8rYyPqu2Z8u49KkjIqkDN2JNY+3K5MyNra+a/any7gsKaN5UobW2iLerkrK2MT6rtlvL+iDcsvm811WPlWWaqoDVMvmMgeoVlaswwHKsUxtUqvm+HJbN/f7AKV1t24O9+hvb+vm3ZZ5Ypp3XEqjBlD0gj47PysuA3nX6+y4rD8ETiiiIst8lq0Ey25Ul93hLZTkcRsrnystX/9zwEw+c5b3ugOda5WVsz5zVhlzrd8p9p1cRjmV1j7z+62ttgBjkhfo8POiHXouCa42cFZSkf65jQU6uhMxYKLPUM7y/HaJ6UDQus/2808Qjc76FgIekNsAyzqnieKXd1sUML8VMGfUOSR/k16Y8ApmYaErmLbhCgZrUluBK5hFPL+C0boXEbqCkfhbhURb01cxZkG3v41DR1A3z1LbZFccEh6CysrbnV27JC8Wnc+rl5oimtNXLzXRf796KVbOv+rqxeeEMFc+7Zo3GKN/1kkxJJp3QZ/ZAXWoRYEHjfawTqeuzsSzvRVPiXxo0xx/5niBXw8gNDobvdDKW6TuCz1/8OLChE90uRd5ekWYPpAj+w07x13jdzHJFTUwvxUwZ9TFTfQAjKvP7YDHmg7Avw/rMiSOLR2ay/RhSK8l7taeJXDX8gqCu7XnCOi+kuSB8Y5AHoFeqys9zxvNy3kCeXMNAS/nC+i+loSXTkBegF6rawl4uVAgb64n4OUiAd03kPDSGcgL0Gt1AwEvlwjkzc0EvFwqoPsWEl66AHkBeq1uIeDlcoG8uZ2AlysEdN9BwktXIC9Ar9UdBLxcJZA3dxPwcrWA7lkkvCwG5AXotZpFwMu1AnlzHwEv1wnovp+El25AXoBeq/sJeLleIG8eIuDlBgHdD5PwsjiQF6DX6mECXm4SyJvHCHi5WUD34yS8dAfyAvRaPU7Ay60CefMUAS+3Ceh+moSXJYC8AL1WTxPwcodA3jxLwMudArqfI+GlB5AXoNfqOQJe7hbImxcJeJkloPslEl6WBPIC9Fq9RMDLvQJ58yoBL/cJ6H6NhJelgLwAvVavEfDygEDevEnAy4MCut8i4WVpIC9Ar9VbBLw8LJA37xLw8oiA7vdIeOkJ5AXotXqPgJfHBPLmQwJeHhfQ/REJL8sAeQF6rT4i4OVJgbz5lICXpwR0f0bCSy8gL0Cv1WcEvDwjkDdfEvAyW0D3VyS8LAvkBei1+oqAl+cE8uZbAl6eF9D9HQkvvYG8AL1W3xHw8qJA3vxIwMtLArp/IuFlOSAvQK/VTwS8vCKQN78S8PKqgO7fSHhZHsgL0Gv1GwEvrwvkzZ8EvLwhoHsOCS8rAHkBeq3mEPDylkDe5Nbyn5e3BXSXrMXBy4rI+XxwmlWJ53mjeXlXIG/KCXh5T0B3BQkvKwF5AXqtKgh4+UAgbyoJePlQQHcLEl7yQF6AXqsWBLx8LJA3rQh4+URAd2sSXhSQF6DXqjUBL58J5M3CBLx8LqC7LQkv1UBegF6rtgS8fCmQN4sS8PKVgO72JLz0AfIC9Fq1J+DlG4G86UTAy7cCujuT8NIXyAvQa9WZgJfvBfJmMQJefhDQ3Y2El35AXoBeq24EvPwkkDdLEPDys4DuHiS89AfyAvRa9SDg5VeBvFmagJffBHT3JOFlAJAXoNcKGb/yuIxN47V7Up6ew0PPS6Dfta7fH63fiavf86nfXajfx6bfMaXfm6PfBaLfb6DHbOtxqHpsnR4vpMdA6Oe69bOq+vk7/UyRfk5C/+1X/z1L36PX9x31vRR9fajPefVxXPdNA5pHkaSfA4F+ejqzskg/MEf3AQLzGC3ref9XGmtuIaC7N0n/NwjIC9BrhYxfWfRX/5deUG015aFzE9iX5aXaOKi5TJ7DgVy5OU1CiZm1MkFCrSKVUCXghLoQWNaqzfG9kV7QR4vVFpDZ37KS2zV+g4HxY+2EBhN0QqtLdUJoIAsLyPRyWUa7xm8ILn7VrEAOIQCyhgXINRaQ+euyjHaN35q4+PVhBXJNAiDXYgFy6AIyQV6W0a7xWxsXv76sQK5NAOQ6LEAOW0Bm4Msy2jV+w3Hx68cK5HACINdlAXK9BWSKvyyjXeM3Ahe//qxAjiAAciQLkOsvIHMIZhntGr9RuPgNYAVyFAGQo1mAHLOATFKYZbRr/Mbi4jeQFcixBECOYwFy/AIyC2KW0a7x2wAXv0GsQG5AAOQEFiA3XECmWcwy2jV+G+HiN5EVyI0IgNyYBchNFpB5HLOMdo3fprj4TWIFclMCIDdjAXLzBWSiyCyjXeO3BS5+k1mB3IIAyC1ZgJy4gMxEmWW0a/wm4eI3hRXISQRATmYBcsoCMtVlltGu8avFxa+WFchaAiDrWIDcagGZSzPLaNf4bY2LXx0rkFsTALkNC5BTF5DJOrOMdo3ftrD4KdoxoNsSALkdC5DbLyCzgWYZ7Rq/HXBA0o6H3IEAyB1ZgJy2gEw3mmW0a/x2wgFJOx5yJwIgd2YBchcgkD7PZ5pltGv8dsUBSTseclcCIHdjAXJ3IJA+T5iaZbRr/PbAAUk7HnIPAiCnswC5JxBIn2dkzTLaNX574YCkHQ+5FwGQe7MAuQ8QSJ+nfM0y2jV+++KApB0PuS8BkPuxADkDCKTPc8pmGe0av/1xQNKOh9yfAMgDWIA8EAikz5PWZhntGr+DcEDSjoc8iADIg1mAPAQIpM+z4mYZ7Rq/Q3FA0o6HPJQAyMNYgDwcCKTP0+5mGe0avyNwQNKOhzyCAMgjWYA8Cgikz/P6ZhntGr+jcUDSjoc8mgDIY1iAPBYIpM8TB2cZ7Rq/43BA0o6HPI4AyONZgDwBCKTPMxNnGe0avxNxQNKOhzyRAMiTWIA8GQikz1MfZxntGr9TcEDSjoc8hQDIU1mAPA0IpM9zK2cZ7Rq/03FA0o6HPJ0AyDNYgDwTCKSvkzdLxu8sYPw8nSxZdDrEs//98avPP/SBoCQu4wqBclfwfLJprfkaAd0rCvU3JWD9QH/Uimv5nePDhXJcEeT4dQK6q0lyHOiPQmoutTyxF7T/1+LKytvtPad5w3ZZyju9mGN7hYCmKFVPOo6ti+yDVi5hkg4outxzm+OAl9J9bnO4R/WJWhE1JOGV8TonXq9KPq9OPvVyXlz/+fFaHm9vFjUksdlvyjL7r0t+V/+/KeOCePvCpIzNre+a/faS7uBcfUF6fBHyye5/4MHFcb2XJPHbwoqR2Z/lwcWWB5fG25clZWxpfdfsT5dxTVLGpUkZuhO7PN6+IiljovVdsz9dxrVJGZcnZWitV8bbVyVlTLK+a/bbC/qgfPX850I+VZZqqgPU1c1lDlDXhAMU1qRrBA5Q13p+gNK6rxU4QEXWIhnTvONSGjWAohf02fmFcRnIu16rxmWdLeyXY9lKsOxGddkd3nVJXGZa8am0fDXfrUg+c5b3ugOda5WVsz5zVhlzrd8p9p1cRjmV1j7z+62ttgBjkhfo8POiHXouCa42cFZSkf55pgUOuhMxYKLPUPp5frvEdCBo3f39/BNEo7O+64AH5JnAsgY0UfzybosC5rcC5owaQPI36esJr2CuF7qCuSFcwWBNukHgCuZGz69gtO4bhc6IJf5WIdHW9FWMWdDtn+nQEdTNs9Q22RWHhIegsvJ2Z3dTkhc3z+fVS00Rzemrl5rov1+9FCvnX3X14nNCmCufm5o3GKN/1kkxJJp3QZ/ZAXWom4EHjVtgnU5dnYnnLVY8JfJhpsAV1ip+PYDQ6Gz0CitvkbpX9fzBiysSPtHlrubpFWH6QI7sN+wcd43fYJIramB+K2DOqMFN9ACMq883AY81twJv1esyJI4ttzaX6cOQXkvcrV1FQPcaBHdrVxPQvSbJA+O3AXkEeq3W9DxvNC+rC+TN2gS8FAR0r0PCy+1AXoBeq3UIeKkRyJt1CXhZQ0D3eiS83AHkBei1Wo+Al7UE8mZ9Al6GCugeRcLLnUBegF6rUQS8rCOQN2MJeBkmoHscCS93AXkBeq3GEfCyrkDeTCDgZT0B3RuS8HI3kBeg12pDAl5GCuTNJgS8rC+ge1MSXmYBeQF6rTYl4GW0QN5sQcDLGAHdW5Lwcg+QF6DXaksCXsYJ5M1kAl7GC+ieQsLLvUBegF6rKQS8TBDIm60IeNlQQPfWJLzcB+QF6LXamoCXjQXyZlsCXjYR0L0dCS/3A3kBeq22I+BlM4G82ZGAl80FdE8j4eUBIC9Ar9U0Al62FMibXQh4mSige1cSXh4E8gL0Wu1KwMtkgbzZg4CXKQK6p5Pw8hCQF6DXajoBL3UCebM3AS9bCejeh4SXh4G8AL1W+xDwso1A3swg4GWqgO79SXh5BMgL0Gu1PwEv2wnkzUEEvGwvoPtgEl4eBfIC9FodTMDLjgJ5cxgBL9MEdB9OwstjQF6AXqvDCXjZWSBvjiLgZRcB3UeT8PI4kBeg1+poAl52E8ib4wh42V1A9/EkvDwB5AXotTqegJfpAnlzEgEvewroPpmElyeBvAC9VicT8LK3QN6cRsDLPgK6Tyfh5SkgL0Cv1ekEvOwnkDdnEfAyQ0D32SS8PA3kBei1OpuAlwME8uY8Al4OFNB9PgkvzwB5AXqtzifg5WCBvLmIgJdDBHRfTMLLbCAvQK/VxQS8HCaQN5cR8HK4gO7LSXh5FsgL0Gt1OQEvRwrkzVUEvBwloPtqEl6eA/IC9FpdTcDLMQJ5cx0BL8cK6J5JwsvzQF6AXquZBLwcL5A3NxLwcoKA7ptIeHkByAvQa3UTAS8nCeTNrQS8nCyg+zYSXl4E8gL0Wt1GwMupAnlzJwEvpwnovouEl5eAvAC9VncR8HKGQN7cQ8DLmQK67yXh5WUgL0CvFTJ+5XEZk+O1e1KensNDz0ug37Wu3x+t34mr3/Op312o38em3zGl35uj3wWi32+gx2zrcah6bJ0eL6THQOjnuvWzqvr5O/1MkX5OQv/tV/89S9+j1/cd9b0UfX2oz3n1cVz3TTrekn6+AvTT05mVRfqBc+O4XSDQDzzgue6LYs1XCuh+kKT/exXIC9BrhYyfnox1ctR4QbXVlIfOTWBflpdq46vNZfIcDuRrzWkSSsys1wgS6nWphCoBJ9QVwLLeaI7vjfSCPlq8CWynz7O/ZSW3a/zeAsaPtRN6i6ATeluqE0ID+Q4woXyeXi7LaNf4vYuLXzUrkO8SAPkeC5DvA4H0ef66LKNd4/cBLn59WIH8gADID1mA/AgIpM8T5GUZ7Rq/j3Hx68sK5McEQH7CAuSnQCB9noEvy2jX+H2Gi18/ViA/IwDycxYgvwAC6fMUf1lGu8bvS1z8+rMC+SUBkF+xAPk1EEif5xDMMto1ft/g4jeAFchvCID8lgXI74BA+jxJYZbRrvH7Hhe/gaxAfk8A5A8sQP4IBNLnWRCzjHaN30+4+A1iBfInAiB/ZgHyFyCQPk+zmGW0a/x+xcVvIiuQvxIA+RsLkL8DgfR5Hscso13j9wcufpNYgfyDAMg/WYCcAwTS54kis4x2jd9cXPwmswI5lwDIqJIEyByuoV7PRJlltGv8SnDxm8IKZEml/20sZQGyDAikz1NdZhntGr9yXPxqWYEsJwCyggXIZkAgfZ5LM8to1/g1x8WvjhXI5gRAVrIA2QIIpM+TdWYZ7Rq/Klj8FO0Y0CoCIFuyANkKCKTPs4FmGe0av9Y4IGnHQ7YmAHIhFiDbAIH0ebrRLKNd47cwDkja8ZALEwDZlgXIRYBA+jyfaZbRrvFrhwOSdjxkOwIgF2UBsj0QSJ8nTM0y2jV+HXBA0o6H7EAAZEcWIDsBgfR5RtYso13j1xkHJO14yM4EQHZhAbIrEEifp3zNMto1fovhgKQdD7kYAZDdWIBcHAikz3PKZhntGr/uOCBpx0N2JwByCRYgewCB9HnS2iyjXeO3JA5I2vGQSxIAuRQLkEsDgfR5Vtwso13j1xMHJO14yJ4EQC7DAmQvIJA+T7ubZbRr/JbFAUk7HnJZAiB7swC5HBBIn+f1zTLaNX7L44CkHQ+5PAGQK7AAuSIQSJ8nDs4y2jV+K+GApB0PuRIBkHkWIBUQSJ9nJs4y2jV+1TggacdDVhMA2YcFyL5AIH2e+jjLaNf49cMBSTsesh8BkP1ZgBwABNLnuZWzjHaN30AckLTjIQcSADmIBciVgUD6OnmzZPxWAcbP08mSRadDXPXfH7/6/IO/OiYuY6ZAuY94Ptm01nyTgO5HhfqbErB+oD/qUc9zfLhQjj9BkOO3COh+kiTHgf4opOZSyxN7Qft/M66svN3e1SobtstS3unFHNsrBDRFqXrScWxdZB+0cgmTdEDR5Q6uxAEvpXtwJdyj+kStiBqS8Pp4nROvNySfNyafelldxyhey+PtKVFDEpv9piyz/5bkd/X/mzKGxNs1SRm11nfNfntJd3CuviA9XgN4Av1PPFgzrnetJH51VozM/iwP1rQ8GBpvr52UsZX1XbM/XcZNSRlDkzJ0J7ZOvD0sKWNr67tmf7qMm5My1knK0FqHx9vrJmVsY33X7LcX9EF5vfnPhXyqLNVUB6j1KmUOUCPCAQpr0giBA9RIzw9QWvdIgQNUZC2SMc07LqVRAyh6QZ+dXxGXgbzr9UbzKFpV2C/HspVg2Y3qsju89ZO4jLLiU2n5ar5bkXzmLO91BzrXKitnfeasMuZav1PsO7mMcuzjovn91lZbgDHJC3T4edEOPZcEVxs4K6lI/zzKAgfdiRgw0Wcoz3h+u8R0IGjds/38E0Sjs771gQfkUcCynm2i+OXdFgXMbwXMGfUsyd+kRxNewYwWuoIZE65gsCaNEbiCGev5FYzWPVbojFjibxUSbU1fxZgF3f5RDh1B3TxLbZNdcUh4CCorb3d245K8GD+fVy81RTSnr15qov9+9VKsnH/V1YvPCWGufMZVNhijf9ZJMSSad0Gf2QF1qPHAg8YGsE6nrs7EcwMrnhL5MErgCutFvx5AaHQ2OtPKW6Tulzx/8GJmwie63Jc9vSJMH8iR/Yad467xe4XkihqY3wqYM+qVJnoAxtXnccBjzQTgrXpdhsSxZUKlTB+G9Fribu3rzfG63yS4W/umgO63SB4Y3xDII9Br9ZbneaN5eVsgb94l4OUdAd3vkfCyEZAXoNfqPQJe3hPImw8JeHlfQPdHJLxsDOQF6LX6iICXDwXy5lMCXj4S0P0ZCS+bAHkBeq0+I+DlE4G8+ZKAl08FdH9FwsumQF6AXquvCHj5XCBvviXg5QsB3d+R8LIZkBeg1+o7Al6+EsibHwl4+VpA908kvGwO5AXotfqJgJdvBfLmVwJevhPQ/RsJL1sAeQF6rX4j4OUHgbz5k4CXHwV0zyHhZUsgL0Cv1RwCXn4WyJvcUP95+UVAd8lQDl4mIseX4zSrEs/zRvPym0DelBPw8ruA7goSXiYBeQF6rSoIePlTIG8qCXiZI6C7BQkvk4G8AL1WLQh4iQSem2tFwEtOQHdrEl6mAHkBeq1aE/BSKpA3CxPwUiaguy0JL7VAXoBeq7YEvFQI5M2iBLw0E9DdnoSXOiAvQK9VewJeKgXyphMBLy0EdHcm4WUrIC9Ar1VnAl5aCuTNYgS8tBLQ3Y2El62BvAC9Vt0IeFlIIG+WIOCljYDuHiS8bAPkBei16kHAS1uBvFmagJdFBHT3JOFlKpAXoNeqJwEviwrkzbIEvLQX0N2bhJdtgbwAvVa9CXjpKJA3KxDw0klA94okvGwH5AXotVqRgJcuAnmjCHjpKqC7moSX7YG8AL1W1QS8dBPIm34EvCwuoLs/CS87AHkBeq36E/CyhEDeDCLgpYeA7pVJeNkRyAvQa7UyAS9LCeTNagS8LC2gezAJL9OAvAC9VoMJeFlGIG+GEPDSS0B3DQkvOwF5AXqtagh46S2QN2sR8LKcgO6hJLzsDOQF6LUaSsDLCgJ5M4yAlxUFdA8n4WUXIC9Ar9VwAl7yAnkzgoAXJaB7JAkvuwJ5AXqtRhLw0kcgb0YT8NJXQPcYEl52A/IC9FqNIeClv0DejCfgZYCA7g1IeNkdyAvQa7UBAS+DBPJmIwJeVhbQvTEJL3sAeQF6rZDxK4/LmBqv3ZPy9Bweel4C/a51/f5o/U5c/Z5P/e5C/T42/Y4p/d4c/S4Q/X4DPWZbj0PVY+v0eCE9BkI/162fVdXP3+lnivRzEvpvv/rvWfoevb7vqO+l6OtDfc6rj+O6b9LxlvRzOtBPT2dWFukHBsdxGyLQD2zmef+3Rqx5uIDuzUn6vz2BvAC9Vsj46clYp0aNF1RbTXno3AT2ZXmpNu5ZKZPncCD3qqRJKDGz9iJIqL2lEqoEnFAzgWXtU4nvjfSCPlrsC2ynz7O/ZSW3a/z2A8aPtRPaj6ATmiHVCaGB3B+YUD5PL5dltGv8DsDFr5oVyAMIgDyQBciDgED6PH9dltGu8TsYF78+rEAeTADkISxAHgoE0ucJ8rKMdo3fYbj49WUF8jACIA9nAfIIIJA+z8CXZbRr/I7Exa8fK5BHEgB5FAuQRwOB9HmKvyyjXeN3DC5+/VmBPIYAyGNZgDwOCKTPcwhmGe0av+Nx8RvACuTxBECewALkiUAgfZ6kMMto1/idhIvfQFYgTyIA8mQWIE8BAunzLIhZRrvG71Rc/AaxAnkqAZCnsQB5OhBIn6dZzDLaNX5n4OI3kRXIMwiAPJMFyLOAQPo8j2OW0a7xOxsXv0msQJ5NAOQ5LECeCwTS54kis4x2jd95uPhNZgXyPAIgz2cB8gIgkD7PRJlltGv8LsTFbworkBcSAHkRC5AXA4H0earLLKNd43cJLn61rEBeQgDkpSxAXgYE0ue5NLOMdo3f5bj41bECeTkBkFewAHklEEifJ+vMMto1flfB4qdox4BeRQDk1SxAXgME0ufZQLOMdo3ftTggacdDXksA5HUsQM4EAunzdKNZRrvG73ockLTjIa8nAPIGFiBvBALp83ymWUa7xu8mHJC04yFvIgDyZhYgbwEC6fOEqVlGu8bvVhyQtOMhbyUA8jYWIG8HAunzjKxZRrvG7w4ckLTjIe8gAPJOFiDvAgLp85SvWUa7xu9uHJC04yHvJgByFguQ9wCB9HlO2SyjXeN3Lw5I2vGQ9xIAeR8LkPcDgfR50toso13j9wAOSNrxkA8QAPkgC5APAYH0eVbcLKNd4/cwDkja8ZAPEwD5CAuQjwKB9Hna3SyjXeP3GA5I2vGQjxEA+TgLkE8AgfR5Xt8so13j9yQOSNrxkE8SAPkUC5BPA4H0eeLgLKNd4/cMDkja8ZDPEAA5mwXIZ4FA+jwzcZbRrvF7Dgck7XjI5wiAfJ4FyBeAQPo89XGW0a7xexEHJO14yBcJgHyJBciXgUD6PLdyltGu8XsFByTteMhXCIB8lQXI14BA+jp5s2T8XgfGz9PJkkWnQ3zj3x+/+vxDHwhK4jJuFSh3oueTTWvNdwroniTU35SA9QP9UZOG+p3jw4VyvJYgx+8W0F1HkuNAfxRSc6nlib2g/b8LV1bebu+blQ3bZSnv9GKO7RUCmqJUPek4ti6yD1q5hEk6oOhy36rEAS+l+61KuEf1iVoRNSThbfE6J15vTz7vSD718nZc/zvxWh5vbxs1JLHZb8oy++9Oflf/vynj3Xj7vaSM7azvmv32ku7gXH1Bevw+8rXh/8CDD+J6P0zit70VI7M/y4MPLA8+irc/TsrYwfqu2Z8u486kjI+SMnQn9km8/WlSxo7Wd83+dBl3JWV8kpShtX4Wb3+elDHN+q7Zby/og/IX858L+VRZqqkOUF9UyhygvgwHKKxJXwocoL7y/ACldX8lcICKrEUypnnHpTRqAEUv6LPzmXEZyLte+8RlvSHsl2PZSrDsRnXZHd7XSVy+seJTaflqvluRfOYs73UHOtcqK2d95qwy5lq/U+w7uYxy7OOi+f3WVluAMckLdPh50Q49lwRXGzgrqUj//I0FDroTMWCiz1C28fx2ielA0Lqn+vkniEZnfV8DD8jfAMvatonil3dbFDC/FTBn1LYkf5P+lvAK5luhK5jvwhUM1qTvBK5gvvf8Ckbr/l7ojFjibxUSbU1fxZgF3f5vHDqCunmW2ia74pDwEFRW3u7sfkjy4sf5vHqpKaI5ffVSE/33q5di5fyrrl58Tghz5fNDZYMx+medFEOieRf0mR1Qh/oReND4Cdbp1NWZeP5kxVMiH74RuMLa0a8HEBqdjd5q5S1S9zTPH7y4NeETXe5Onl4Rpg/kyH7DznHX+O1MckUNzG8FzBm1cxM9AOPq8w/AY83PwFv1ugyJY8vPlTJ9GNJribu1ewvo3oPgbu2+Arqnkzww/guQR6DXarrneaN5mSGQN3sT8LK/gO59SHj5FcgL0Gu1DwEvBwrkzQwCXg4S0L0/CS+/AXkBeq32J+DlEIG8OYiAl0MFdB9MwsvvQF6AXquDCXg5XCBvDiPg5QgB3YeT8PIHkBeg1+pwAl6OEsibowh4OVpA99EkvPwJ5AXotTqagJdjBfLmOAJejhPQfTwJL3OAvAC9VscT8HKCQN6cRMDLiQK6TybhZS6QF6DX6mQCXk4WyJvTCHg5RUD36SS8RC1wsQR6rU4n4OU0gbw5i4CX0wV0n03CSw7IC9BrdTYBL2cK5M15BLycJaD7fBJeSoC8AL1W5xPwco5A3lxEwMu5ArovJuGlFMgL0Gt1MQEv5wvkzWUEvFwgoPtyEl7KgLwAvVaXE/BykUDeXEXAy8UCuq8m4aUcyAvQa3U1AS+XCuTNdQS8XCageyYJLxVAXoBeq5kEvFwhkDc3EvBypYDum0h4aQbkBei1uomAl6slxv0Q8HKNgO7bSHhpDuQF6LW6jYCX6wTy5k4CXmYK6L6LhJdKIC9Ar9VdBLzcIJA39xDwcqOA7ntJeGkB5AXotbqXgJebBfLmAQJebhHQ/SAJL1VAXoBeqwcJeLlNIG8eIeDldgHdj5Lw0hLIC9Br9SgBL3cK5M0TBLzcJaD7SRJeWgF5AXqtniTgZZZA3jxDwMs9Arpnk/DSGsgL0Gs1m4CX+wTy5nkCXu4X0P0CCS8LAXkBeq1eIODlQYG8eZmAl4cEdL9CwksbIC9Ar9UrBLw8IpA3rxPw8qiA7jdIeFkYyAvQa/UGAS+PC+TN2wS8PCGg+x0SXtoCeQF6rd4h4OUpgbx5n4CXpwV0f0DCyyJAXoBeqw8IeJktkDcfE/DyrIDuT0h4aQfkBei1+oSAl+cF8uZzAl5eEND9BQkviwJ5AXqtviDg5SWBvPmagJeXBXR/Q8JLeyAvQK/VNwS8vCqQN98T8PKagO4fSHjpAOQF6LVCxq88LmOneO2elKfn8NDzEuh3rev3R+t34ur3fOp3F+r3sel3TOn35uh3gej3G+gx23ocqh5bp8cL6TEQ+rlu/ayqfv5OP1Okn5PQf/vVf8/S9+j1fUd9L0VfH+pzXn0c132Tjreknx2Bfno6s7JIP/BW7Pu7Av3Az57rfj/W/JmA7l9I+r9OQF6AXitk/PRkrDtFjRdUW0156NwE9mV5qTZ2aiGT53AgO7egSSgxszoTJFQXqYQqASfUrcCyurbA90Z6QR8tFgO20+fZ37KS2zV+3YDxY+2EuhF0QotLdUJoILsDE8rn6eWyjHaN3xK4+FWzArkEAZA9WIBcEgikz/PXZRntGr+lcPHrwwrkUgRALs0CZE8gkD5PkJdltGv8lsHFry8rkMsQANmLBchlgUD6PANfltGu8euNi18/ViB7EwC5HAuQywOB9HmKvyyjXeO3Ai5+/VmBXIEAyBVZgFwJCKTPcwhmGe0avzwufgNYgcwTAKlYgKwGAunzJIVZRrvGrw8ufgNZgexDAGRfFiD7LSCzIGYZ7Rq//rj4DWIFsj8BkANYgBy4gEyzmGW0a/wG4eI3kRXIQQRArswC5CoLyDyOWUa7xm9VXPwmsQK5KgGQq7EAOXgBmSgyy2jX+K2Oi99kViBXJwCywALkkAVkJsoso13jV4OL3xRWIGsIgFyDBcg1F5CpLrOMdo3fWrj41bICuRYBkENZgFx7AZlLM8to1/itg4tfHSuQ6xAAOYwFyOELyGSdWUa7xm9dWPwU7RjQdQmAXI8FyBELyGygWUa7xm8kDkja8ZAjCYBcnwXIUQvIdKNZRrvGbzQOSNrxkKMJgBzDAuTYBWQ+0yyjXeM3Dgck7XjIcQRAjmcBcoMFZMLULKNd4zcBByTteMgJBEBuyALkRgvIjKxZRrvGb2MckLTjITcmAHITFiA3XUCmfM0y2jV+m+GApB0PuRkBkJuzALkFEEif55TNMto1flvigKQdD7klAZATWYCcBATS50lrs4x2jd9kHJC04yEnEwA5hQXIWiCQPs+Km2W0a/zqcEDSjoesIwByKxYgtwYC6fO0u1lGu8ZvGxyQtOMhtyEAcioLkNsCgfR5Xt8so13jtx0OSNrxkNsRALk9C5A7AIH0eeLgLKNd47cjDkja8ZA7EgA5jQXInYBA+jwzcZbRrvHbGQck7XjInQmA3IUFyF2BQPo89XGW0a7x2w0HJO14yN0IgNydBcg9gED6PLdyltGu8ZuOA5J2POR0AiD3ZAFyLyCQvk7eLBm/vYHx83SyZNHpEPf598evPv/QB4KSuIxZAuX+7vlk01rz/QK6/xDqb0rA+oH+qD88z/HhQjk+lyDHHxTQHa3NkeNzkccuoOZSyxN7Qfv/AK6svN3efVs0bJelvNOLObZXCGiKUvWk49i6yD5o5RIm6YCiy92vBRB4Id37tYB7VJ+oFVFDEt4Tr3Pi9d7k877kUy8z4vr3j9fyeHvnqCGJzX5Tltn/YPK7+v9NGQfE2wcmZexifdfst5d0B+fqC9Ljg4An0P/Eg4Pjeg9J4rerFSOzP8uDgy0PDo23D0vK2M36rtmfLuP+pIxDkzJ0J3Z4vH1EUsbu1nfN/nQZDyRlHJ6UobUeGW8flZSxh/Vds99e0Aflo+c/F/KpslRTHaCObiFzgDomHKCwJh0jcIA61vMDlNZ9rMABKrIWyZjmHZfSqAEUvaDPzm+Ny0De9eoal7WPsF+OZSvBshvVZXd4xyVxOd6KT6Xlq/luRfKZs7zXHehcq6yc9Zmzyphr/U6x7+Qyyqm09pnfb221BRiTvECHnxft0HNJcLWB5haG/vl4Cxx0J2LARJ+hlIJvG6B1mw4ErbtM6HaJ4y30Rmd9xwEPyMcDyypvovjl3RYFzG8FzBklFT80JycQXsGcIHQFc2K4gsGadKLAFcxJnl/BaN0nCZ0RS/ytQqKt6asYs6Dbf7xDR1A3z1LbZFccEh6Cysrbnd3JSV6cMp9XLzVFNKevXmqi/371Uqycf9XVi88JYa58Tm7RYIz+WSfFkGjeBX1mB9ShTgEeNE6FdTp1dSaep1rxlMiH4wWusCqFryxdz0ZnWXmL1N3CL92N2jcr4RNdbpWnV4TpAzmy37Bz3DV+LUmuqIH5rYA5o1o20QMwrj6fDDzWnAa8Va/LkDi2nNZCpg9Dei1xt7aLgO6FCe7WLiagu62fd2sbtfN0II9Ar1Vbz/NG87K4QN4sSsBLdwHd7Ul4OQPIC9Br1Z6Alx4CedOJgJclBXR3JuHlTCAvQK9VZwJelhbIm8UIeOkpoLsbCS9nAXkBeq26EfDSSyBvliDgZVkB3T1IeDkbyAvQa9WDgJflBPJmaQJelhfQ3ZOEl3OAvAC9Vj0JeFlRIG+WJeBlJQHdvUl4ORfIC9Br1ZuAFyWQNysQ8FItoHtFEl7OA/IC9FqtSMBLX4G8UQS89BPQXU3Cy/lAXoBeq2oCXgYI5E0/Al4GCujuT8LLBUBegF6r/gS8rCyQN4MIeFlFQPfKJLxcCOQF6LVamYCX1QTyZjUCXgYL6B5MwstFQF6AXqvBBLwUBPJmCAEvQwR015DwcjGQF6DXqoaAlzUE8mYtAl7WFNA9lISXS4C8AL1WQwl4GSqQN8MIeFlbQPdwEl4uBfIC9FoNJ+BlmEDejCDgZbiA7pEkvFwG5AXotRpJwMt6AnkzmoCXEQK6x5DwcjmQF6DXagwBL+sL5M14Al5GCejegISXK4C8AL1WGxDwMkYgbzYi4GWsgO6NSXi5EsgL0Gu1MQEv4wXyZjMCXjYQ0L05CS9XAXkBeq02J+BlQ4G8mUjAy0YCuieR8HI1kBeg12oSAS+bCORNLQEvmwroriPh5RogL0CvVR0BL5sL5M02BLxsIaB7Kgkv1wJ5AXqtphLwMlEgb7Yn4GWSgO4dSHi5DsgL0Gu1AwEvUwTyZicCXmoFdO9MwstMIC9Ar9XOBLxsJZA3uxHwsrWA7t1JeLkeyAvQa7U7AS9TBfJmTwJethXQvRcJLzcAeQF6rfYi4GV7gbzZl4CXHQR070fCy41AXoBeq/0IeJkmkDcHEPCyk4DuA0l4uQnIC9BrdSABL7sI5M0hBLzsKqD7UBJebgbyAvRaHUrAy+4CeXMEAS97COg+koSXW4C8AL1WRxLwsqdA3hxDwMteArqPJeHlViAvQK8VMn7lcRnT47V7Up6ew0PPS6Dfta7fH63fiavf86nfXajfx6bfMaXfm6PfBaLfb6DHbOtxqHpsnR4vpMdA6Oe69bOq+vk7/UyRfk5C/+1X/z1L36PX9x31vRR9fajPefVxXPdNOt6Sft4G9NPTmZVF+oH94rgdINAPnOC57oNizUcK6D6RpP+7HcgL0GuFjJ+ejHV61HhBtdWUh85NYF+Wl2rj7S1k8hwO5B0taBJKzKw7CBLqTqmEKgEn1CxgWXe1wPdGekEfLe4GttPn2d+ykts5Z4DxY+2EZhF0QvdIdUJoIO8FJpTP08tlGe0av/tw8atmBfI+AiDvZwHyASCQPs9fl2W0a/wexMWvDyuQDxIA+RALkA8DgfR5grwso13j9wgufn1ZgXyEAMhHWYB8DAikzzPwZRntGr/HcfHrxwrk4wRAPsEC5JNAIH2e4i/LaNf4PYWLX39WIJ8iAPJpFiCfAQLp8xyCWUa7xm82Ln4DWIGcTQDksyxAPgcE0udJCrOMdo3f87j4DWQF8nkCIF9gAfJFIJA+z4KYZbRr/F7CxW8QK5AvEQD5MguQrwCB9HmaxSyjXeP3Ki5+E1mBfJUAyNdYgHwdCKTP8zhmGe0avzdw8ZvECuQbBEC+yQLkW0AgfZ4oMsto1/i9jYvfZFYg3yYA8h0WIN8FAunzTJRZRrvG7z1c/KawAvkeAZDvswD5ARBIn6e6zDLaNX4f4uJXywrkhwRAfsQC5MdAIH2eSzPLaNf4fYKLXx0rkJ8QAPkpC5CfAYH0ebLOLKNd4/c5LH6Kdgzo5wRAfsEC5JdAIH2eDTTLaNf4fYUDknY85FcEQH7NAuQ3QCB9nm40y2jX+H2LA5J2POS3BEB+xwLk90AgfZ7PNMto1/j9gAOSdjzkDwRA/sgC5E9AIH2eMDXLaNf4/YwDknY85M8EQP7CAuSvQCB9npE1y2jX+P2GA5J2PORvBED+zgLkH0AgfZ7yNcto1/j9iQOSdjzknwRAzmEBci4QSJ/nlM0y2jV+URUMSNrxkLgYyLUxV0UCZAmuoV5PWptltGv8SnFA0o6HLCUAsowFyHIgkD7PiptltGv8KnBA0o6HrCAAshkLkM2BQPo87W6W0a7xq8QBSTsespIAyBYsQFYBgfR5Xt8so13j1xIHJO14yJYEQLZiAbI1EEifJw7OMto1fgvhgKQdD7kQAZBtWIBcGAikzzMTZxntGr+2OCBpx0O2JQByERYg2wGB9Hnq4yyjXeO3KA5I2vGQixIA2Z4FyA5AIH2eWznLaNf4dcQBSTsesiMBkJ1YgOwMBNLXyZsl49cFGD9PJ0sWnQ6x678/fvX5hz4QlMRlPCRQ7imeTzatNT8moPtUof6mBKwf6I861fMcHy6U42cQ5PgTArrPJMlxoD8KqbnU8sRe4FPz4MrK2+1drKphuyzlnV7Msb1CQFOUqicdx9ZF9kErlzBJBxRdbrcqHPBSurtVwT2qT9SKqCEJH47XOfH6SPL5aPKpl8Xj+rvHa3m8vWfUkMRmvynL7H8i+V39/6aMJeLtHkkZe1nfNfvtJd3BufqC9HhJ4An0P/FgqbjepZP47W3FyOzP8mApy4Oe8fYySRn7WN81+9NlPJaU0TMpQ3diveLtZZMy9rW+a/any3g8KaNXUobW2jveXi4pYz/ru2a/vaAPysvPfy7kU2WppjpALV8lc4BaIRygsCatIHCAWtHzA5TWvaLAASqyFsmY5h2X0qgBFL2gz85nxWUg73rd1SKKugr75Vi2Eiy7UV12h7dSEpe8FZ9Ky1fz3YrkM2d5rzvQuVZZOeszZ5Ux1/qdYt/JZZRTae0zv9/aagswJnmBDj8v2qHnkuBqA2clFemf8xY46E7EgIk+QznH89slpgNB6z7Xzz9BNDrrWwl4QM4DyzqvieKXd1sUML8VMGfUeSR/k1aEVzBK6AqmOlzBYE2qFriC6eP5FYzW3UfojFjibxUSbU1fxZgF3f68Q0dQN89S22RXHBIegsrK251d3yQv+s3n1UtNEc3pq5ea6L9fvRQr51919eJzQpgrn75VDcbon3VSDInmXdBndkAdqh/woNEf1unU1Zl49rfiKZEPeYErrIv8egCh0dnoQ1beInVf7PmDFw8lfKLLvcTTK8L0gRzZb9g57hq/S0muqIH5rYA5oy5togdgXH3uCzzWDADeqtdlSBxbBlTJ9GFIryXu1t7ZAq/7KoK7tXcL6L6a5IHxgUAegV6rqz3PG83LPQJ5cx0BL/cK6J5JwssgIC9Ar9VMAl7uF8ibGwl4eUBA900kvKwM5AXotbqJgJeHBPLmVgJeHhbQfRsJL6sAeQF6rW4j4OVRgby5k4CXxwR030XCy6pAXoBeq7sIeHlCIG/uIeDlSQHd95LwshqQF6DX6l4CXp4WyJsHCHh5RkD3gyS8DAbyAvRaPUjAy7MCefMIAS/PCeh+lISX1YG8AL1WjxLw8oJA3jxBwMuLArqfJOGlAOQF6LV6koCXlwXy5hkCXl4R0D2bhJchQF6AXqvZBLy8JpA3zxPw8rqA7hdIeKkB8gL0Wr1AwMubAnnzMgEvbwnofoWElzWAvAC9Vq8Q8PKOQN68TsDLuwK63yDhZU0gL0Cv1RsEvLwvkDdvE/DygYDud0h4WQvIC9Br9Q4BLx8J5M37BLx8LKD7AxJehgJ5AXqtPiDg5VOBvPmYgJfPBHR/QsLL2kBegF6rTwh4+UIgbz4n4OVLAd1fkPCyDpAXoNfqCwJevhbIm68JePlGQPc3JLwMA/IC9Fp9Q8DLdwJ58z0BL98L6P6BhJfhQF6AXqsfCHj5USBvfibg5ScB3b+Q8LIukBeg1+oXAl5+Ecib3wl4+VVA9x8kvKwH5AXotfqDgJffBfJmLgEvfwjojtbh4GUEkBeg1wodPwle5gjkTannujUvcwV0l5HwMhI5ISZOsyoj4CUn8B6pZgS8lAjobk7Cy/pAXoBeq+YEvJQJ5E0VAS/lArpbkvAyCsgL0GvVkoCXZgJ5sxABL80FdLch4WU0kBeg16oNAS8tBPJmEQJeqgR0tyPhZQyQF6DXqh0BL60E8qYDAS+tBXR3JOFlLJAXoNeqIwEvbQTypgsBLwsL6O5Kwss4IC9Ar1VXAl4WEcibxQl4aSeguzsJL+OBvAC9Vt0JeGkvkDdLEvDSQUD3UiS8bADkBei1WoqAl04CebMMAS+dBXT3IuFlApAXoNcKGb/yuIwZ8do9KU/P4aHnJdDvWtfvj9bvxNXv+dTvLqx/H5ueiy1e9btA9PsN9JhtPQ5Vj63T44X0GAj9XLd+VlU/f6efKdLPSei//eq/Z+l79Pq+o76Xoq8P9TmvPo7rvmlCVRRJ+rkh0E9PZ1YW6Qe6xXFbQqAfWM7z/m/JWHNvAd3Lk/R/GwF5AXqtkPHTk7HOiBovqLaa8tC5CezL8lJt3KhKJs/hQG5cRZNQYmZtTJBQm0glVAk4oR4ClrVpFb430gv6aLHZAjL7W1Zyu8Zvc2D8WDuhzQk6oS2kOiE0kFsuINPLZRntGr+JuPhVswI5kQDISSxATl5A5q/LMto1flNw8evDCuQUAiBrWYCsW0AmyMsy2jV+W+Hi15cVyK0IgNyaBchtFpAZ+LKMdo3fVFz8+rECOZUAyG1ZgNxuAZniL8to1/htj4tff1YgtycAcgcWIHdcQOYQzDLaNX7TcPEbwArkNAIgd2IBcucFZJLCLKNd47cLLn4DWYHchQDIXVmA3G0BmQUxy2jX+O2Oi98gViB3JwByDxYgpy8g0yxmGe0avz1x8ZvICuSeBEDuxQLk3gvIPI5ZRrvGbx9c/CaxArkPAZD7sgC53wIyUWSW0a7xm4GL32RWIGcQALk/C5AHAIH0eSbKLKNd43cgLn5TWIE8kADIg1iAPBgIpM9TXWYZ7Rq/Q3Dxq2UF8hACIA9lAfIwIJA+z6WZZbRr/A7Hxa+OFcjDCYA8ggXII4FA+jxZZ5bRrvE7ChY/RTsG9CgCII9mAfIYIJA+zwaaZbRr/I7FAUk7HvJYAiCPYwHyeCCQPk83mmW0a/xOwAFJOx7yBAIgT2QB8iQgkD7PZ5pltGv8TsYBSTse8mQCIE9hAfJUIJA+T5iaZbRr/E7DAUk7HvI0AiBPZwHyDCCQPs/ImmW0a/zOxAFJOx7yTAIgz2IB8mwgkD5P+ZpltGv8zsEBSTse8hwCIM9lAfI8IJA+zymbZbRr/M7HAUk7HvJ8AiAvYAHyQiCQPk9am2W0a/wuwgFJOx7yIgIgL2YB8hIgkD7PiptltGv8LsUBSTse8lICIC9jAfJyIJA+T7ubZbRr/K7AAUk7HvIKAiCvZAHyKiCQPs/rm2W0a/yuxgFJOx7yagIgr2EB8logkD5PHJxltGv8rsMBSTse8joCIGeyAHk9EEifZybOMto1fjfggKQdD3kDAZA3sgB5ExBIn6c+zjLaNX4344CkHQ95MwGQt7AAeSsQSJ/nVs4y2jV+t+GApB0PeRsBkLezAHkHEEhfJ2+WjN+dwPh5Olmy6HSId/3741eff+gDQUlcxpMC5a7k+WTTWvNsAd15of6mBKwf6I/Kr+N3jg8XyvE+BDn+nIDuviQ5DvRHITWXWp7YC9r/Z3Fl5e323l3VsF2W8k4v5theIaApStWTjmPrIvuglUuYpAOKLndWFQ54Kd2zquAe1SdqRdSQhE/F65x4fTr5fCb51Ms9cf33xmt5vL1/1JDEZr8py+x/Lvld/f+mjPvi7fuTMg6wvmv220u6g3P1BenxA8AT6H/iwYNxvQ8l8TvQipHZn+XBg5YHD8fbjyRlHGR91+xPlzE7KePhpAzdiT0abz+WlHGw9V2zP13Gs0kZjyZlaK2Px9tPJGUcYn3X7LcX9EH5yfnPhXyqLNVUB6gnq2QOUE+FAxTWpKcEDlBPe36A0rqfFjhARdYiGdO841IaNYCiF/TZ+UNxGci7XpvGZd0l7Jdj2Uqw7EZ12R3eM0lcZlvxqbR8Nd+tSD5zlve6A51rlZWzPnNWGXOt3yn2nVxGOZXWPvP7ra22AGOSF+jw86Idei4JrjZwVlKR/nm2BQ66EzFgos9QBnh+u8R0IGjdA/38E0Sjs75ngAfk2cCyBjVR/PJuiwLmtwLmjBpE8jfpZwmvYJ4VuoJ5LlzBYE16TuAK5nnfb7HF7Xte6IxY4m8VEm1NX8WYBd3+2Q4dQd08S22TXXFIeAgqK293di8kefHifF691BTRnL56qYn++9VLsXL+VVcvPieEufJ5oarBGP2zTooh0bwL+swOqEO9CDxovATrdOrqTDxfsuIp8tCFwBXWan49gNDobPRJK2+Rugd7/uDFkwmf6HJX9/SKMH0gR/Ybdo67xq9AckUNzG8FzBlVaKIHYFx9fgF4rHkZeKtelyFxbHm5SqYPQ3otcbd2EwHdaxHcrd1MQPdQkgfGXwHyCPRaDfU8bzQvWwjkzTACXrYU0D2chJdXgbwAvVbDCXiZJJA3Iwh4mSygeyQJL68BeQF6rUYS8FIrkDejCXipE9A9hoSX14G8AL1WYwh42Vogb8YT8LKNgO4NSHh5A8gL0Gu1AQEv2wrkzUYEvGwnoHtjEl7eBPIC9FptTMDLDgJ5sxkBLzsK6N6chJe3gLwAvVabE/Cyk0DeTCTgZWcB3ZNIeHkbyAvQazWJgJddBfKmloCX3QR015Hw8g6QF6DXqo6Alz0E8mYbAl6mC+ieSsLLu0BegF6rqQS87CWQN9sT8LK3gO4dSHh5D8gL0Gu1AwEv+wrkzU4EvOwnoHtnEl7eB/IC9FrtTMDL/gJ5sxsBLwcI6N6dhJcPgLwAvVa7E/BykEDe7EnAy8ECuvci4eVDIC9Ar9VeBLwcKpA3+xLwcpiA7v1IePkIyAvQa7UfAS9HCOTNAQS8HCmg+0ASXj4G8gL0Wh1IwMvRAnlzCAEvxwjoPpSEl0+AvAC9VocS8HKcQN4cQcDL8QK6jyTh5VMgL0Cv1ZEEvJwokDfHEPBykoDuY0l4+QzIC9BrdSwBL6cI5M0JBLycKqD7RBJePgfyAvRanUjAy+kCeXMKAS9nCOg+lYSXL4C8AL1WpxLwcpZA3pxBwMvZArrPJOHlSyAvQK/VmQS8nCuQN+cQ8HKegO5zSXj5CsgL0Gt1LgEvFwjkzQUEvFwooPtCEl6+BvIC9FpdSMDLxQJ5cwkBL5cI6L6UhJdvgLwAvVaXEvBymUDeXEHAy+UCuq8k4eVbIC9Ar9WVBLxcKZA31xDwcpWA7mtJePkOyAvQa3UtAS/XCOTN9QS8XCug+wYSXr4H8gL0Wt1AwMtMgby5mYCX6wV030LCyw9AXoBeq1sIeLlRIG9uJ+DlJgHdd5Dw8iOQF6DX6g4CXm4RyJu7CXi5VUD3LBJefgLyAvRazSLg5XaBvLmPgJc7BHTfT8LLz0BegF4rZPzK4zIOjdfuSXl6Dg89L4F+17p+f7R+J65+z6d+d6F+H5t+x5R+b45+F4h+v4Ees63HoeqxdXq8kB4DoZ/r1s+q6ufv9DNF+jkJ/bdf/fcsfY9e33fU91L09aE+59XHcd036XhL+vkL0E9PZ1YW6QdmxXG7T6AfeMhz3Q/Emh8X0P0wSf/3K5AXoNcKGT89GeuhUeMF1VZTHjo3gX1ZXqqNv1bJ5DkcyN+qaBJKzKzfCBLqd6mEKgEn1JPAsv6owvdGekEfLf4EttPn2d+ykts1fnOA8WPthOYQdEJzpTohNJBRS5xon6eXyzLaNX45XPyqWYEExkCsjSUtSYAsBQLp8/x1WUa7xq8MF78+rECWEQBZzgJkBRBInyfIyzLaNX7NcPHrywpkMwIgm7MAWQkE0ucZ+LKMdo1fC1z8+rEC2YIAyCoWIFsCgfR5ir8so13j1woXv/6sQLYiALI1C5ALAYH0eQ7BLKNd49cGF78BrEC2IQByYRYg2wKB9HmSwiyjXeO3CC5+A1mBXIQAyHYsQC4KBNLnWRCzjHaNX3tc/AaxAtmeAMgOLEB2BALp8zSLWUa7xq8TLn4TWYHsRABkZxYguwCB9HkexyyjXePXFRe/SaxAdiUAcjEWILsBgfR5osgso13jtzgufpNZgVycAMjuLEAuAQTS55kos4x2jV8PXPymsALZgwDIJVmAXAoIpM9TXWYZ7Rq/pXHxq2UFcmkCIHuyALkMEEif59LMMto1fr1w8atjBbIXAZDLsgDZGwikz5N1ZhntGr/lYPFTtGNAlyMAcnkWIFcAAunzbKBZRrvGb0UckLTjIVckAHIlFiDzQCB9nm40y2jX+CkckLTjIRUBkNUsQPYBAunzfKZZRrvGry8OSNrxkH0JgOzHAmR/IJA+T5iaZbRr/AbggKQdDzmAAMiBLEAOAgLp84ysWUa7xm9lHJC04yFXJgByFRYgVwUC6fOUr1lGu8ZvNRyQtOMhVyMAcjALkKsDgfR5Ttkso13jV8ABSTseskAA5BAWIGuAQPo8aW2W0a7xWwMHJO14yDUIgFyTBci1gED6PCtultGu8RuKA5J2PORQAiDXZgFyHSCQPk+7m2W0a/yG4YCkHQ85jADI4SxArgsE0ud5fbOMdo3fejggacdDrkcA5AgWIEcCgfR54uAso13jtz4OSNrxkOsTADmKBcjRQCB9npk4y2jX+I3BAUk7HnIMAZBjWYAcBwTS56mPs4x2jd94HJC04yHHEwC5AQuQE4BA+jy3cpbRrvHbEAck7XjIDQmA3IgFyI2BQPo6ebNk/DYBxs/TyZJFp0Pc9N8fv/r8Qx8ISuIynhco9zHPJ5vWml8W0P24UH9TAtYP9Ec97nmODxfK8acIcvxVAd1Pk+Q40B+F1FxqeWIvaP9fwZWVt9u7WcuG7bKUd3oxx/YKAU1Rqp50HFsX2QetXMIkHVB0uZu3xAEvpXvzlnCP6hO1ImpIwhfidU68vph8vpR86mWLuP4t47U83j4sakhis9+UZfa/mvyu/n9TxsR4e1JSxuHWd81+e0l3cK6+ID2eDDyB/iceTInrrU3id4QVI7M/y4Mplgd18fZWSRlHWt81+9NlvJyUUZeUoTuxrePtbZIyjrK+a/any3glKWPrpAytdWq8vW1SxtH/x967wNlU/f//ZwbDhHGbQbpQUSrVWe6iXCsUuVNUbjNS7lEpRSrdVIrcikIhJZdcoiiKFEWhoigqqRS5VQr/vXz2/s9yzP58frVe7/mulzn78fCYY8+Zdfb7/Xo911rvfTnLeG+w39zQg3KPf++FaExbKrsGqB4FZAaonvEBCitST4EBqpfjA5SOu5fAABUxNsmcRi23XJFMUPSGnp2v8dpAnvX6O38k0kFYL8u2lWDbJ3yW2eH19vPSx8hPsqFr8N4k/2eCob3uQI8abSUYPxOMNo4af5PVexJC2kk29gV/n2IcCzAnUYEOPyraoSf4ydUCLvU/SP+/jwEOuhMJwETPUD5x/HRJ0IGg4/7UzUsQJ8z6egMH5D7AttZnU/6idpsC+lsBPaPWk1yT7ktYwfQVqmD6xSsYrEj9BCqY2xyvYHTctwnNiCWuVUgca2wVE2zo4+9j0RFkHLelZ1vFIaEhqK2o2dn1930x4F9WL/WyiDm2eqkX+d/VS1btnFTVi8uGCCqf/gUyhdH/16aoGzl+Q8/sgHGoAcBB43ZYp5OREeTzdiOfEn7oI1Bhfe7WDQgnzEbXG75Fxv2F4zderPf5RLe7ydGKMHYgR/Ybpsdt87eZpKIG+lsBPaM2Z9MNMLY69weONXcAT9XrNiTGljsKyPRhSK0lztb+lR8f99cEZ2sPC8T9DckN43cCeQRqrb5x3Deal6MCvvmWgJeIQP/4HQkvA4G8ALVW3xHwkijgmx8IeMklEPdOEl7uAvIC1FrtJOAlj4BvfibgJUkg7l0kvNwN5AWotdpFwEs+Ad/sJuAlWSDuPSS8DALyAtRa7SHgJb+Ab/YR8FJAIO79JLzcA+QFqLXaT8BLioBvfifgpZBA3H+Q8HIvkBeg1uoPAl6KCPjmLwJeigrE/TcJL4OBvAC1Vn8T8JIq4JujBLykCcQdacTByxAgL0CtFTp/EryUEPBNLsfj1ryUFIg7Nwkv9wF5AWqtchPwUkrAN3kJeDlNIO58JLwMBfIC1FrlI+DlDAHf5Cfg5UyBuAuQ8HI/kBeg1qoAAS9lBHxTiICXswTiLkzCywNAXoBaq8IEvJwj4JtiBLyUFYg7lYSXB4G8ALVWqQS8nCvgmxIEvJwnEHdJEl6GAXkBaq1KEvByvoBvTiPg5QKBuE8n4eUhIC9ArdXpBLxUEPBNaQJeLhKIuwwJLw8DeQFqrcoQ8HKJgG/OIeAlKhB3WRJeHgHyAtRalSXgpaKAb84j4KWSQNzlSXh5FMgLUGtVnoCXKgK+uZCAl6oCcVcg4eUxIC9ArVUFAl6qC/jmEgJeagjEHSXhZTiQF6DWKkrAS00B31Qi4KWWQNyVSXh5HMgLUGtVmYCXywV8U42Al9oCcVcn4eUJIC9ArVV1Al7qCvimJgEv9QTirkXCy5NAXoBaq1oEvDQQ8E1tAl6uEIi7DgkvI4C8ALVWdQh4uUrAN/UJeGkoEHcDEl6eAvIC1Fo1IOClsYBvriLg5WqBuBuS8PI0kBeg1qohAS9NBHxzNQEvTQXivoaEl5FAXoBaq2sIeGkm4JtrCXhpLhB3MxJeRgF5AWqtmhHw0lLANy0JeGklEHcrEl6eAfIC1Fq1IuCljYBv2hLw0lYg7nYkvIwG8gLUWrUj4OU6Ad+0J+DleoG4O5DwMgbIC1BrhcxfHq+Nx71/Zfz29Boeel0C/V3r+vuj9Xfi6u/51N9dqL+PTX/HlP7eHP1dIPr7DfQz2/o5VP1snX5eSD8Doe/r1veq6vvv9D1F+j4Jfe1XX8/S5+j1eUd9LkXXh3rOq8dx3TfpfEvqORaop6MrK4v0Azd6eesk0A/c5Hj/18WL+RaBuDuS9H/jgLwAtVbI/OnFWB+PnLihjjVoD+1NYF8WlTrGcQVkfA4HcnwBGkOJiTWewFDPShkqEWyo9cC2niuA7430hh4tJgCP0+XV38LMbZu/icD8sXZCEwk6oeelOiE0kC8ADeXy8nJhQtvmbxIufxVZgZxEAORkFiCnAIF0ef26MKFt8/ciLn+VWIF8kQDIl1iAnAoE0uUF8sKEts3fNFz+KrMCOY0AyOksQL4MBNLlFfjChLbN3wxc/qqwAjmDAMhXWIB8FQiky0v8hQltm7+ZuPxVZQVyJgGQr7EAOQsIpMtrCIYJbZu/2bj8VWMFcjYBkHNYgJwLBNLlRQrDhLbN3+u4/FVnBfJ1AiDnsQA5Hwiky6sghgltm78FuPzVYAVyAQGQC1mAfAMIpMvLLIYJbZu/Rbj8dWIFchEBkItZgHwTCKTL6ziGCW2bv7dw+evMCuRbBEAuYQFyKRBIlxeKDBPaNn9v4/LXhRXItwmAfIcFyGVAIF1eiTJMaNv8LcflrysrkMsJgHyXBcj3gEC6vNRlmNC2+VuBy186K5ArCIBcyQLk+0AgXV5LM0xo2/ytwuUvgxXIVQRAfsAC5IdAIF1erDNMaNv8rYblT9E+A7qaAMg1LEB+BATS5dVAw4S2zd/HOCBpn4f8mADItSxArgMC6fJyo2FC2+bvExyQtM9DfkIA5KcsQK4HAunyeqZhQtvmbwMOSNrnITcQALmRBcjPgEC6vGBqmNC2+fscByTt85CfEwD5BQuQm4BAurwia5jQtvnbjAOS9nnIzQRAfskC5FdAIF1e8jVMaNv8bcEBSfs85BYCILeyAPk1EEiX15QNE9o2f9/ggKR9HvIbAiC3sQC5HQiky4vWhgltm79vcUDSPg/5LQGQ37EA+T0QSJdXxQ0T2jZ/O3BA0j4PuYMAyB9YgNwJBNLlZXfDhLbN3484IGmfh/yRAMifWID8GQiky+v6hgltm79dOCBpn4fcRQDkLyxA/goE0uWFg8OEts3fbhyQtM9D7iYAcg8LkL8BgXR5ZeIwoW3ztxcHJO3zkHsJgNzHAuR+IJAuL30cJrRt/g7ggKR9HvIAAZAHWYD8HQiky2srhwltm78/cEDSPg/5BwGQf7IAeQgIpKuLN0vm7y9g/hxdLFl0OcS/T/78HfMfeiBI9NrYLNBuF8cXm9YxbxWIu6tQf5MIjh+oj+rayG2PNxbyeDcCj38jEPfNJB4H6qOQMecyNDE3tP5f49qKmsd7uEDm69wx2uktGNuTBGKKxHxObB5TstgH/XAJkXRC0e0eKYADXiruIwXgGh0zalIk04Rf6s/x/n3l/9zi/9TbUf35BSORPN6PJyKZJg72B20F+7/x/1b/PmgjwXtfot/Gk8Z7g/3mFtvB2eqC1DhXQZy2/0SD3Dp3fv5GGDkK9odpoH8ftJHkvc7rt/GU8d5gf2wbW/02kvw2dCeWz3ud7LfxtPHeYH9sG1/7beTz29CxnuK9zu+3MdJ4b7Df3NCDcoGC/7qtaExbKrsGqAIFZQaogkau4wOUZZtapIIF8e2mFHR7gNJxpxSEa/RfT+tG7bbjchq13HJFMkHRG3p2vt5rA3nW6zmvrb8FJhSRLLZ/2bYSbPuEzzI7vEK+jwsbfk42dP3/B0z/Z4Khve5AjxptJRg/E4w2jhp/k9V7EkLaSTb2BX+fYhwLMCdRgQ4/KtqhJ/jJ1QIu9T9I/7+wATq6EwnARM9QbnX8dEnQgaDj7uHmJYgTZn2FgANyYWBbPbMpf1G7TQH9rYCeUT1JrkkXIaxgighVMEXjFQxWpKICFUwxxysYHXcxoQpG4lqFxLHGVjHBhj7+whYdQcZxW3q2VRwSGoLaipqdXarvi7R/Wb3UyyLm2OqlXuR/Vy9ZtXNSVS8uGyKofFILZgqj/69NUTdy/Iae2QHjUGnAQaM4rNPJyAjyWdzIp4QfChfEzxz7unUDwgmz0c2Gb5Fx93P8xovNPp/odm9ztCKMHciR/Ybpcdv89SepqIH+VkDPqP7ZdAOMrc6pwLGmBPD6sG5DYmwpUVCmD0NqLXG29lmBs5YDCc7WThCI+y6SG8ZLAnkEaq3uctw3mpfnBXxzDwEvLwjEfS8JL6cCeQFqre4l4GWygG/uI+BlikDcQ0l4KQXkBai1GkrAy0sCvnmQgJepAnEPI+HlNCAvQK3VMAJepgv45hECXl4WiPtREl5OB/IC1Fo9SsDLKwK+eZyAl1cF4n6ChJczgLwAtVZPEPDymoBvniLgZZZA3E+T8HImkBeg1uppAl7mCPjmGQJe5grEPZqEl9JAXoBaq9EEvMwT8M04Al7mC8Q9noSXMkBegFqr8QS8LBTwzQQCXt4QiHsiCS9nAXkBaq0mEvCyWMA3kwh4eVMg7skkvJwN5AWotZpMwMsSAd+8RMDLUoG4p5Lwcg6QF6DWaioBL+8I+OZlAl6WCcQ9g4SXskBegFqrGQS8vCvgm5kEvLwnEPdrJLyUA/IC1Fq9RsDLSgHfzCHg5X2BuOeS8HIukBeg1mouAS8fCPhmPgEvHwrEvYCEl/OAvAC1VgsIeFkj4JtFBLx8JBD3YhJeygN5AWqtFhPwslbAN0sIeFknEPdSEl7OB/IC1FotJeDlUwHfLCPgZb1A3MtJeLkAyAtQa7WcgJeNAr5ZQcDLZwJxryTh5UIgL0Ct1UoCXr4Q8M0HBLxsEoj7QxJeKgB5AWqtPiTg5UsB33xEwMtXAnF/TMLLRUBegFqrjwl42Srgm08IePlaIO5PSXi5GMgLUGv1KQEv2wR8s5GAl+0CcX9GwsslQF6AWqvPCHj5TsA3mwh4+V4g7s0kvESBvAC1VpsJePlBwDdbCHjZKRD3VhJeFJAXoNZqKwEvPwn4ZhsBLz8LxL2dhJeKQF6AWqvtBLz8IuCb7wl4+VUg7h0kvFQC8gLUWu0g4GWPgG9+JODlN4G4fyLhpTKQF6DW6icCXvYJ+OYXAl72C8T9KwkvVYC8ALVWvxLwclDAN78R8PK7QNx7SXipCuQFqLXaS8DLnwK+OUDAyyGBuA+S8FINyAtQa4XMXx6vjVHevzJ+e3oND70ugf6udf390fo7cfX3fOrvLtTfx6a/Y0p/b47+LhD9/Qb6mW39HKp+tk4/L6SfgdD3det7VfX9d/qeIn2fhL72q69n6XP0+ryjPpei60M959XjuO6bqhWMRCT1rA7U09GVlUX6gSO6DxBYx+hPx+PO5cV8ikDch0j6vxpAXoBaK2T+9GKsoyInbqhjDdpDexPYl0WljrFGQRmfw4G8tCCNocTEupTAUDWlDJUINtRmYFu1CuJ7I72hR4vLcsjqb2Hmts3f5cD8sXZClxN0QrWlOiE0kHVyyPJyYULb5q8uLn8VWYGsSwBkPRYg6+eQ9evChLbNXwNc/iqxAtmAAMgrWIC8MocskBcmtG3+rsLlrzIrkFcRANmQBchGOWQFvjChbfPXGJe/KqxANiYA8moWIK/JIUv8hQltm78muPxVZQWyCQGQTVmAvDaHrCEYJrRt/prh8leNFchmBEA2ZwGyRQ5ZpDBMaNv8tcTlrzorkC0JgGzFAmTrHLIKYpjQtvlrg8tfDVYg2xAA2ZYFyHY5ZJnFMKFt83cdLn+dWIG8jgDI61mAbJ9D1nEME9o2fx1w+evMCmQHAiBvYAHyxhyyUGSY0Lb5uwmXvy6sQN5EAGRHFiA75ZCVKMOEts1fZ1z+urIC2ZkAyC4sQHbNIUtdhgltm790XP7SWYFMJwAygwXIbjlkLc0woW3zdzMufxmsQN5MAGR3FiBvySGLdYYJbZu/W2H5U7TPgN5KAGQPFiB75pDVQMOEts1fLxyQtM9D9iIAsjcLkH1yyHKjYULb5q8vDkja5yH7EgDZjwXI24BAuryeaZjQtvnrjwOS9nnI/gRADmAB8nYgkC4vmBomtG3+7sABSfs85B0EQN7JAuRAIJAur8gaJrRt/u7CAUn7PORdBEDezQLkICCQLi/5Gia0bf7uwQFJ+zzkPQRA3ssC5GAgkC6vKRsmtG3+huCApH0ecggBkPexADkUCKTLi9aGCW2bv/txQNI+D3k/AZAPsAD5IBBIl1fFDRPaNn/DcEDSPg85jADIh1iAfBgIpMvL7oYJbZu/R3BA0j4P+QgBkI+yAPkYEEiX1/UNE9o2f8NxQNI+DzmcAMjHWYB8AgikywsHhwltm78ncUDSPg/5JAGQI1iAfAoIpMsrE4cJbZu/p3FA0j4P+TQBkCNZgBwFBNLlpY/DhLbN3zM4IGmfh3yGAMjRLECOAQLp8trKYULb5m8sDkja5yHHEgA5jgXI8UAgXV28WTJ/zwLz5+hiyaLLIT538ufvmP/QA0Gi18Y2gXYPO77YtI75e4G4jwj1N4ng+IH6qCOOe7yxkMcTGrvv8R8E4k5szOFxoD4KGXMuQxNzQ+u/A9dW1DzeCQUzX+eO0U5vwdieJBBTJOZzYvOYksU+6IdLiKQTim53YkEc8FJxTywI1+iYUZMimSbc7v074v371v/5nf9Tb897n/+C9y+P9/qZSKaJg/1BW8H+H/y/1b8P2pjkvZ7stzHaeG+w39xiOzhbXZAaTwFOoP+JBi96n/uSn78xRo6C/WEavGhoMNV7Pc1vY6zx3mB/bBvf+21M9dvQndh07/XLfhvjjPcG+2Pb2OG3Md1vQ8c6w3v9it/GeOO9wX5zQw/Kr/57L0Rj2lLZNUC9WlBmgJoZH6CwIs0UGKBec3yA0nG/JjBARYxNMqdRyy1XJBMUvaFn55u9NpBnvWp5bT0nrJdl20qw7RM+y+zwZvl5mW3kJ9nQNXhvkv8zwdBed6BHjbYSjJ8JRhtHjb/J6j0JIe0kG/uCv08xjgWYk6hAhx8V7dAT/ORqAZf6H6T/P9sAB92JBGCiZyh5HD9dEnQg6LiThE6XWJ5CP2HWNws4IM8GtpU3m/IXtdsU0N8K6BkllT80J3MIK5g5QhXM3HgFgxVprkAF87rjFYyO+3WhGbHEtQqJY42tYoINffyzLTqCjOO29GyrOCQ0BLUVNTu7eb4v5v/L6qVeFjHHVi/1Iv+7esmqnZOqenHZEEHlM69gpjD6/9oUdSPHb+iZHTAONR84aCyAdToZGUE+Fxj5lPDDbIEKK79wZWk7G91m+BYZdwG34j7h+Lb5fKLbLehoRRg7kCP7DdPjtvlLIamogf5WQM+olGy6AcZW53nAsWYh8FS9bkNibFlYUKYPQ2otcba2pkDcxQjO1l4mEHeqm2drTzjON4A8ArVWqY77RvNSW8A3JQh4qSMQd0kSXhYBeQFqrUoS8FJPwDenEfBSXyDu00l4WQzkBai1Op2AlysEfFOagJcrBeIuQ8LLm0BegFqrMgS8NBTwzTkEvDQSiLssCS9vAXkBaq3KEvBytYBvziPg5RqBuMuT8LIEyAtQa1WegJemAr65kICXawXirkDCy1IgL0CtVQUCXpoL+OYSAl5aCMQdJeHlbSAvQK1VlICXVgK+qUTAS2uBuCuT8PIOkBeg1qoyAS9tBXxTjYCXdgJxVyfhZRmQF6DWqjoBL9cL+KYmAS/tBeKuRcLLciAvQK1VLQJebhDwTW0CXm4UiLsOCS/vAnkBaq3qEPDSUcA39Ql46SQQdwMSXt4D8gLUWjUg4KWLgG+uIuClq0DcDUl4WQHkBai1akjAS4aAb64m4KWbQNzXkPCyEsgLUGt1DQEv3QV8cy0BL7cIxN2MhJf3gbwAtVbNCHjpIeCblgS89BSIuxUJL6uAvAC1Vq0IeOkt4Ju2BLz0EYi7HQkvHwB5AWqt2hHw0k/AN+0JeLlNIO4OJLx8COQFqLXqQMDLAAHf3ETAy+0CcXck4WU1kBeg1qojAS93CvimCwEvAwXi7krCyxogL0CtVVcCXu4W8E03Al4GCcR9MwkvHwF5AWqtbibg5V4B39xKwMtggbh7kPDyMZAXoNaqBwEv9wn4pjcBL0MF4u5DwstaIC9ArVUfAl4eEPDNbQS8PCgQd38SXtYBeQFqrfoT8PKQgG/uIODlYYG47yTh5RMgL0Ct1Z0EvDwq4Ju7CXh5TCDuQSS8fArkBai1GkTAy+MCvhlMwMsTAnEPIeFlPZAXoNZqCAEvIwR8cz8BL08JxP0ACS8bgLwAtVYPEPAyUsA3DxHwMkog7odJeNkI5AWotXqYgJfRAr55jICXMQJxDyfh5TMgL0Ct1XACXsYJ+OZJAl7GC8Q9goSXz4G8ALVWyPzl8dp41vtXxm9Pr+Gh1yXQ37Wuvz9afyeu/p5P/d2F+vvY9HdM6e/N0d8For/fQD+zrZ9D1c/W6eeF9DMQ+r5ufa+qvv9O31Ok75PQ13719Sx9jl6fd9TnUnR9qOe8ehzXfZPOt6SeXwD1dHRlZZF+YKKXt0kC/cBIx+Oe4sU8QyDuUST93yYgL0CtFTJ/ejHWZyMnbqhjDdpDexPYl0WljnFTQRmfw4HcXJDGUGJibSYw1JdShkoEG2obsK2vCuJ7I72hR4stwON0efW3MHPb5m8rMH+sndBWgk7oa6lOCA3kN0BDuby8XJjQ1p04Ln8VWYHcRgDkdhYgvwUC6fL6dWFC2+bvO1z+KrEC+R0BkN+zALkDCKTLC+SFCW2bvx9w+avMCuQPBEDuZAHyRyCQLq/AFya0bf5+wuWvCiuQPxEA+TMLkLuAQLq8xF+Y0Lb5+wWXv6qsQP5CAOSvLEDuBgLp8hqCYULb5m8PLn/VWIHcQwDkbyxA7gUC6fIihWFC2+ZvHy5/1VmB3EcA5H4WIA8AgXR5FcQwoW3zdxCXvxqsQB4kAPJ3FiD/AALp8jKLYULb5u9PXP46sQL5JwGQh1iA/AsIpMvrOIYJbZu/v3H568wK5N8EQB5mAfIIEEiXF4oME9o2f0dx+evCCuRRAiAjKSRAJuAO1OmVKMOEts1fIi5/XVmBTExx/xhzsQCZGwiky0tdhgltm788uPylswKZhwDIJBYg8wKBdHktzTChbfOXD5e/DFYg8xEAmcwC5ClAIF1erDNMaNv85YflT9E+A5qfAMgCLEAWBALp8mqgYULb5i8FByTt85ApBEAWYgGyMBBIl5cbDRPaNn9FcEDSPg9ZhADIoixAFgMC6fJ6pmFC2+YvFQck7fOQqQRAprEAWRwIpMsLpoYJbZu/EjggaZ+HLEEAZEkWIE8FAunyiqxhQtvmrxQOSNrnIUsRAHkaC5CnA4F0ecnXMKFt83cGDkja5yHPIADyTBYgSwOBdHlN2TChbfNXBgck7fOQZQiAPIsFyLOBQLq8aG2Y0Lb5OwcHJO3zkOcQAFmWBchyQCBdXhU3TGjb/J2LA5L2echzCYA8jwXI8kAgXV52N0xo2/ydjwOS9nnI8wmAvIAFyAuBQLq8rm+Y0Lb5q4ADkvZ5yAoEQF7EAuTFQCBdXjg4TGjb/F2CA5L2echLCICMsgCpgEC6vDJxmNC2+auIA5L2eciKBEBWYgGyMhBIl5c+DhPaNn9VcEDSPg9ZhQDIqixAVgMC6fLaymFC2+avOg5I2uchqxMAWYMFyEuBQLq6eLNk/moC8+foYsmiyyHWOvnzd8x/8K+O8drYKdDuGMcXm9Yx7xKIe6xQf5MIjh+ojxrruMcbC3n8WQKP/yoQ93MkHgfqo5Ax5zI0MTf4SiC4tqLm8V6Wkvk6d4x2egvG9iSBmCIxnxObx5Qs9kE/XEIknVB0u5en4ICXivvyFLhGx4yaFMk04Y/evyPev5/8nz/7P/VWW+fI+5fHe/1cJNPEwf6grWD/r/7f6t8HbdT1Xtfz25hgvDfYb26xHZytLkiN6wMn0P9Egwbe517h52+ikaNgf5gGDQwNrvReX+W38bzx3mB/bBu7/Dau9NvQnVhD73Ujv40XjPcG+2Pb+MVvo6Hfho61sff6ar+NScZ7g/3mhh6Ur/n3XojGtKWya4C6JkVmgGoSH6CwIjURGKCaOj5A6bibCgxQEWOTzGnUcssVyQRFb+jZ+TavDeRZr68KRiK1hPWybFsJtn3CZ5kd3rV+XpoZ+Uk2dA3em+T/TDC01x3oUaOtBONngtHGUeNvsnpPQkg7yca+4O9TjGMB5iQq0OFHRTv0BD+5WsCl/gfp/zczwEF3IgGY6BnK846fLgk6EHTcL7h5CeKEWd+1wAG5GbCtSdmUv6jdpoD+VkDPqEkk16SbE1YwzYUqmBbxCgYrUguBCqal4xWMjrul0IxY4lqFxLHGVjHBhj7+ZhYdQcZxW3q2VRwSGoLaipqdXSvfF63/ZfVSL4uYY6uXepH/Xb1k1c5JVb24bIig8mmVkimM/r82Rd3I8Rt6ZgeMQ7UGDhptYJ1ORkaQzzZGPiX80EygwnrJrRsQTpiN7jR8i4x7quM3Xuz0+US3O83RijB2IEf2G6bHbfM3naSiBvpbAT2jpmfTDTC2OrcCjjVtgafqdRsSY0vbFJk+DKm1xNnaLwvi455JcLZ2i0Dcr5HcMN4OyCNQa/Wa477RvHwt4Js5BLx8IxD3XBJergPyAtRazSXgZbuAb+YT8PKtQNwLSHi5HsgLUGu1gICX7wV8s4iAlx0CcS8m4aU9kBeg1moxAS87BXyzhICXHwXiXkrCSwcgL0Ct1VICXn4W8M0yAl52CcS9nISXG4C8ALVWywl4+VXANysIeNktEPdKEl5uBPIC1FqtJODlNwHffEDAy16BuD8k4eUmIC9ArdWHBLzsF/DNRwS8HBCI+2MSXjoCeQFqrT4m4OV3Ad98QsDLHwJxf0rCSycgL0Ct1acEvBwS8M1GAl7+Eoj7MxJeOgN5AWqtPiPg5bCAbzYR8HJEIO7NJLx0AfIC1FptJuAlInDf3BYCXhIE4t5KwktXIC9ArdVWAl5yCfhmGwEvuQXi3k7CSzqQF6DWajsBL0kCvvmegJe8AnHvIOElA8gLUGu1g4CXZAHf/EjAyykCcf9Ewks3IC9ArdVPBLwUEPDNLwS8FBSI+1cSXm4G8gLUWv1KwEshAd/8RsBLYYG495Lw0h3IC1BrtZeAl6ICvjlAwEsxgbgPkvByC5AXoNbqIAEvaQK++ZOAl+ICcR8i4eVWIC9ArdUhAl5KCvjmMAEvpwrEfYSElx5AXoBaqyMEvJwm4JuEq93n5XSBuBOv5uClJ3J9ElzMKtFx32hezhTwTR4CXkoLxJ1EwksvIC9ArVUSAS9nCfgmmYCXswXiPoWEl95AXoBaq1MIeCkr4JuCBLyUE4g7hYSXPkBegFqrFAJezhPwTRECXsoLxF2UhJe+QF6AWquiBLxcIOCbNAJeLhSIuzgJL/2AvAC1VsUJeLlIwDenEvBysUDcpUh4uQ3IC1BrVYqAl6iAb84g4EUJxH0mCS/9gbwAtVZnEvBSScA3ZxHwUlkg7rNJeBkA5AWotTqbgJeqAr4pR8BLNYG4zyXh5XYgL0Ct1bkEvNQQ8M35BLxcKhD3BSS83AHkBai1QuYvj9fGZO9fGb89vYaHXpdAf9e6/v5o/Z24+ns+9XcX6u9j098xpb83R38XiP5+A/3Mtn4OVT9bp58X0s9A6Pu69b2q+v47fU+Rvk9CX/vV17P0OXp93lGfS9H1oZ7z6nFc9013pEQiknreCdTT0ZWVRfqBy/X6ewL9wEWO93/1vZgbC8R9MUn/NxDIC1BrhcyfXox1cuTEDXWsQXtobwL7sqjUMQ5MkfE5HMi7UmgMJSbWXQSGulvKUIlgQ+0EtjUoBd8b6Q09WtyTQ1Z/CzO3bf7uBeaPtRO6l6ATGizVCaGBHJJDlpcLE9o2f/fh8leRFcj7CIAcygLk/Tlk/bowoW3z9wAuf5VYgXyAAMgHWYAclkMWyAsT2jZ/D+HyV5kVyIcIgHyYBchHgEC6vAJfmNC2+XsUl78qrEA+SgDkYyxADgcC6fISf2FC2+bvcVz+qrIC+TgBkE+wAPkkEEiX1xAME9o2fyNw+avGCuQIAiCfYgHyaSCQLi9SGCa0bf5G4vJXnRXIkQRAjmIB8hkgkC6vghgmtG3+RuPyV4MVyNEEQI5hAXIsEEiXl1kME9o2f+Nw+evECuQ4AiDHswD5LBBIl9dxDBPaNn/P4fLXmRXI5wiAnMAC5EQgkC4vFBkmtG3+nsflrwsrkM8TAPkCC5CTgEC6vBJlmNC2+ZuMy19XViAnEwA5hQXIF4FAurzUZZjQtvl7CZe/dFYgXyIAcioLkNOAQLq8lmaY0Lb5m47LXwYrkNMJgHyZBcgZQCBdXqwzTGjb/L0Cy5+ifQb0FQIgX2UBciYQSJdXAw0T2jZ/r+GApH0e8jUCIGexADkbCKTLy42GCW2bvzk4IGmfh5xDAORcFiBfBwLp8nqmYULb5m8eDkja5yHnEQA5nwXIBUAgXV4wNUxo2/wtxAFJ+zzkQgIg32ABchEQSJdXZA0T2jZ/i3FA0j4PuZgAyDdZgHwLCKTLS76GCW2bvyU4IGmfh1xCAORSFiDfBgLp8pqyYULb5u8dHJC0z0O+QwDkMhYglwOBdHnR2jChbfP3Lg5I2uch3yUA8j0WIFcAgXR5VdwwoW3ztxIHJO3zkCsJgHyfBchVQCBdXnY3TGjb/H2AA5L2ecgPCID8kAXI1UAgXV7XN0xo2/ytwQFJ+zzkGgIgP2IB8mMgkC4vHBwmtG3+1uKApH0eci0BkOtYgPwECKTLKxOHCW2bv09xQNI+D/kpAZDrWYDcAATS5aWPw4S2zd9GHJC0z0NuJADyMxYgPwcC6fLaymFC2+bvCxyQtM9DfkEA5CYWIDcDgXR18WbJ/H0JzJ+jiyWLLof41cmfv2P+Qw8EiV4buwXaVY4vNq1j3icQd0Wh/iYRHD9QH1Xxarc93ljI41UIPH5AIO6qJB4H6qOQMecyNDE3tP77cW1FzePdkpL5OneMdnoLxvYkgZgiMZ8Tm8eULPZBP1xCJJ1QdLtbU3DAS8W9NQWu0TGjJkUyTbjH+3fE+/eb/3Ov/1NvX3uf/433L4/3ekok08TB/qCtYP8B/2/174M2tnmvt/ttvGi8N9hvbrEdnK0uSI2/RT5q8Q80+M773O/9/L1k5CjYH6bBd4YGO7zXP/htTDXeG+yPbWOf38YOvw3die30Xv/otzHNeG+wP7aN/X4bO/02dKw/ea9/9tuYbrw32G9u6EF517/3QjSmLZVdA9SuFJkB6pf4AIUV6ReBAepXxwcoHfevAgNUxNgkcxq13HJFMkHRG3p2vtNrA3nWa5DX1lfCelm2rQTbPuGzzA5vt5+XPUZ+kg1dg/cm+T8TDO11B3rUaCvB+JlgtHHU+Jus3pMQ0k6ysS/4+xTjWIA5iQp0+FHRDj3BT64WcKn/Qfr/ewxw0J1IACZ6hlLD8dMlQQeCjvtSNy9BnDDr2w0ckPcA26qZTfmL2m0K6G8F9IyqSXJN+jfCCuY3oQpmb7yCwYq0V6CC2ed4BaPj3ic0Ixa5HidwrLFVTLChj3+PRUeQcdyWnm0Vh4SGoLaiZme33/fFgX9ZvdTLIubY6qVe5H9XL1m1c1JVLy4bIqh89qdkCqP/r01RN3L8hp7ZAeNQB4CDxkFYp5OREeTzoJFPCT/sEaiwart1A8KJlZXhW2TcdRy/8WK3zye63bqOVoSxAzmy3zA9bpu/eiQVNdDfCugZVS+bboCx1Xk/cKz5HXiqXrchMbb8niLThyG1ljhbe7dA3FcRnK29RyDuhiQ3jP8B5BGotWrouG80L4MFfHM1AS9DBOK+hoSXP4G8ALVW1xDwMlTAN9cS8HK/QNzNSHg5BOQFqLVqRsDLgwK+aUnAyzCBuFuR8PIXkBeg1qoVAS8PC/imLQEvjwjE3Y6El7+BvAC1Vu0IeHlMwDftCXgZLhB3BxJeDgN5AWqtOhDw8oSAb24i4OVJgbg7kvByBMgLUGvVkYCXpwR804WAl6cF4u5KwstRIC9ArVVXAl5GCfimGwEvzwjEfTMJL5FCuFwCtVY3E/AyRsA3txLwMlYg7h4kvCQAeQFqrXoQ8DJewDe9CXh5ViDuPiS8JAJ5AWqt+hDwMkHAN7cR8DJRIO7+JLzkAvIC1Fr1J+DlBQHf3EHAyySBuO8k4SU3kBeg1upOAl6mCPjmbgJeXhSIexAJL3mAvAC1VoMIeJkq4JvBBLxME4h7CAkvSUBegFqrIQS8vCzgm/sJeJkhEPcDJLzkBfIC1Fo9QMDLqwK+eYiAl5kCcT9Mwks+IC9ArdXDBLzMEvDNYwS8zBaIezgJL8lAXoBaq+EEvMwV8M2TBLy8LhD3CBJeTgHyAtRajSDgZb6Ab0YS8LJAIO5RJLzkB/IC1FqNIuDlDQHfjCHgZZFA3GNJeCkA5AWotRpLwMubAr55loCXtwTifo6El4JAXoBaq+cIeFkq4JvnCXh5WyDuF0h4SQHyAtRavUDAyzIB30wh4GW5QNwvkvBSCMgLUGv1IgEv7wn4ZhoBLysE4p5OwkthIC9ArdV0Al7eF/DNKwS8rBKI+1USXooAeQFqrV4l4OVDAd/MIuBltUDcs0l4KQrkBai1mk3Ay0cCvnmdgJePBeKeR8JLMSAvQK3VPAJe1gn4ZiEBL58IxP0GCS+pQF6AWqs3CHhZL+CbNwl42SAQ91skvKQBeQFqrd4i4OUzAd+8TcDL5wJxv0PCS3EgL0Ct1TsEvGwS8M27BLxsFoj7PRJeSgB5AWqtkPnL47XxsvevjN+eXsNDr0ugv2tdf3+0/k5c/T2f+rsL9fex6e+Y0t+bo78LRH+/gX5mWz+Hqp+t088L6Wcg9H3d+l5Vff+dvqdI3yehr/3q61n6HL0+76jPpej6UM959Tiu+yadb0k9SwL1dHRlZZF+YKun+zaBfuB9x+P+1ov5J4G4V5H0f6cCeQFqrZD504uxvhw5cUMda9Ae2pvAviwqdYynFpLxORzIUoVoDCUmVikCQ50mZahEsKF2A9s6vRC+N9IberQ4A3icLq/+FmZu2/ydCcwfayd0JkEnVFqqE0IDWQZoKJeXlwsT2jZ/Z+HyV5EVyLMIgDybBchzgEC6vH5dmNC2+SuLy18lViDLEgBZjgXIc4FAurxAXpjQtvk7D5e/yqxAnkcAZHkWIM8HAunyCnxhQtvm7wJc/qqwAnkBAZAXsgBZAQiky0v8hQltm7+LcPmrygrkRQRAXswC5CVAIF1eQzBMaNv8RXH5q8YKZJQASMUCZEUgkC4vUhgmtG3+KuHyV50VyEoEQFZmAbJKDlkFMUxo2/xVxeWvBiuQVQmArMYCZPUcssximNC2+auBy18nViBrEAB5KQuQNXPIOo5hQtvmrxYuf51ZgaxFAORlLEBenkMWigwT2jZ/tXH568IKZG0CIOuwAFk3h6xEGSa0bf7q4fLXlRXIegRA1mcBskEOWeoyTGjb/F2By186K5BXEAB5JQuQV+WQtTTDhLbNX0Nc/jJYgWxIAGQjFiAb55DFOsOEts3f1bD8KdpnQK8mAPIaFiCb5JDVQMOEts1fUxyQtM9DNiUA8loWIJvlkOVGw4S2zV9zHJC0z0M2JwCyBQuQLXPIeqZhQtvmrxUOSNrnIVsRANmaBcg2OWTB1DChbfPXFgck7fOQbQmAbMcC5HU5ZEXWMKFt83c9Dkja5yGvJwCyPQuQHYBAurzka5jQtvm7AQck7fOQNxAAeSMLkDcBgXR5TdkwoW3z1xEHJO3zkB0JgOzEAmRnIJAuL1obJrRt/rrggKR9HrILAZBdWYBMBwLp8qq4YULb5i8DByTt85AZBEB2YwHyZiCQLi+7Gya0bf6644CkfR6yOwGQt7AAeSsQSJfX9Q0T2jZ/PXBA0j4P2YMAyJ4sQPYCAunywsFhQtvmrzcOSNrnIXsTANmHBci+QCBdXpk4TGjb/PXDAUn7PGQ/AiBvYwGyPxBIl5c+DhPaNn8DcEDSPg85gADI21mAvAMIpMtrK4cJbZu/O3FA0j4PeScBkANZgLwLCKSrizdL5u9uYP4cXSxZdDnEQSd//o75Dz0QJHptHBRod7Xji03rmA8JxL1GqL9JBMcP1EetcdzjjYU8vpbA438LxL2OxONAfRQy5lyGJuaG1v8vXFtR83jvKZT5OneMdnoLxvYkgZgiMZ8Tm8eULPZBP1xCJJ1QdLv3FsIBLxX3vYXgGh0zalIk04S/e/+OeP/+8H/+6f/U22Dv84d4//J4r2dEMk0c7A/aCvb/7f+t/n3Qxn3e66F+G68Y7w32m1tsB2erC1Lj+4ET6H+iwQPe5z7o5+9VI0fB/jANHjA0GOa9fshvY6bx3mB/bBuH/DaG+W3oTuxh7/UjfhuvGe8N9se28ZffxsN+GzrWR73Xj/ltzDLeG+w3N/SgPPzfeyEa05bKrgFqeCGZAerx+ACFFelxgQHqCccHKB33EwIDVMTYJHMatdxyRTJB0Rt6dr7bawN51ut0r61BwnpZtq0E2z7hs8wO70k/LyOM/CQbugbvTfJ/Jhja6w70qNFWgvEzwWjjqPE3Wb0nIaSdZGNf8PcpxrEAcxIV6PCjoh16gp9cLeBS/4P0/0cY4KA7kQBM9AxlveOnS4IOBB33BjcvQZww63sSOCCPALa1MZvyF7XbFNDfCugZtZHkmvRThBXMU0IVzNPxCgYr0tMCFcxIxysYHfdIoRmxxLUKiWONrWKCDX38Iyw6gozjtvRsqzgkNAS1FTU7u1G+L575l9VLvSxijq1e6kX+d/WSVTsnVfXisiGCymdUoUxh9P+1KepGjt/QMztgHOoZ4KAxGtbpZGQE+Rxt5FPCDyMEKqxNbt2AcMJs9KDhW2Tcmx2/8eKgzye63S8drQhjB3Jkv2F63DZ/X5FU1EB/K6Bn1FfZdAOMrc6jgGPNGOCpet2GxNgyppBMH4bUWuJs7WkCcW8jOFt7hkDc20luGB8L5BGotdruuG80L6UFfPM9AS9lBOLeQcLLOCAvQK3VDgJezhbwzY8EvJwjEPdPJLyMB/IC1Fr9RMBLOQHf/ELAy7kCcf9KwsuzQF6AWqtfCXgpL+Cb3wh4OV8g7r0kvDwH5AWotdpLwMuFAr45QMBLBYnzOyS8TADyAtRaHSTg5WIB3/xJwMslAnEfIuFlIpAXoNbqEAEvSsA3hwl4qSgQ9xESXp4H8gLUWh0h4KWygG8SrnGflyoCcSdew8HLC8jnZXExq0THfaN5qSbgmzwEvFQXiDuJhJdJQF6AWqskAl4uFfBNMgEvNQXiPoWEl8lAXoBaq1MIeLlMwDcFCXi5XCDuFBJepgB5AWqtUgh4qSPgmyIEvNQViLsoCS8vAnkBaq2KEvBSX8A3aQS8NBCIuzgJLy8BeQFqrYoT8HKlgG9OJeDlKoG4S5HwMhXIC1BrVYqAl0YCvjmDgJfGAnGfScLLNCAvQK3VmQS8XCPgm7MIeGkiEPfZJLxMB/IC1FqdTcDLtQK+KUfASzOBuM8l4eVlIC9ArdW5BLy0EPDN+QS8tBSI+wISXmYAeQFqrS4g4KW1gG8uIuCljUDcF5Pw8gqQF6DW6mICXtoJ+EYR8HKdQNwVSXh5FcgLUGtVkYCX9gK+qULASweBuKuS8DITyAtQa1WVgJcbBXxTg4CXmwTivpSEl9eAvAC1VpcS8NJJwDeXEfDSWSDuy0l4mQXkBai1upyAl64CvqlLwEu6QNz1SHiZDeQFqLWqR8BLNwHfXEHAy80CcV9JwsscIC9ArdWVBLzcIuCbRgS83CoQd2MSXuYCeQFqrRoT8NJTwDdNCHjpJRB3UxJeXgfyAtRaNSXgpY+Ab5oT8NJXIO4WJLzMA/IC1Fq1IODlNgHftCbgpb9A3G1IeJkP5AWotWpDwMvtAr65joCXOwTivp6ElwVAXoBaq+sJeBko4JsbCHi5SyDuG0l4WQjkBai1QuYvj9fGbO9fGb89vYaHXpdAf9e6/v5o/Z24+ns+9XcX6u9j098xpb83R38XiP5+A/3Mtn4OVT9bp58X0s9A6Pu69b2q+v47fU+Rvk9CX/vV17P0OXp93lGfS9H1oZ7z6nFc900635J6vgHU09GVlUX6gXu9vN0n0A90crz/u9+L+VGBuDuT9H+LgLwAtVbI/OnFWGdHTtxQxxq0h/YmsC+LSh3jokIyPocDubgQjaHExFpMYKg3pQyVCDbUQWBbbxXC90Z6Q48WS4DH6fLqb2Hmts3fUmD+WDuhpQSd0NtSnRAayHeAhnJ5ebkwoW3ztwyXv4qsQC4jAHI5C5DvAoF0ef26MKFt8/ceLn+VWIF8jwDIFSxArgQC6fICeWFC2+bvfVz+KrMC+T4BkKtYgPwACKTLK/CFCW2bvw9x+avCCuSHBECuZgFyDRBIl5f4CxPaNn8f4fJXlRXIjwiA/JgFyLVAIF1eQzBMaNv8rcPlrxorkOsIgPyEBchPgUC6vEhhmNC2+VuPy191ViDXEwC5gQXIjUAgXV4FMUxo2/x9hstfDVYgPyMA8nMWIL8AAunyMothQtvmbxMuf51YgdxEAORmFiC/BALp8jqOYULb5u8rXP46swL5FQGQW1iA3AoE0uWFIsOEts3f17j8dWEF8msCIL9hAXIbEEiXV6IME9o2f9tx+evKCuR2AiC/ZQHyOyCQLi91GSa0bf6+x+UvnRXI7wmA3MEC5A9AIF1eSzNMaNv87cTlL4MVyJ0EQP7IAuRPQCBdXqwzTGjb/P0My5+ifQb0ZwIgd7EA+QsQSJdXAw0T2jZ/v+KApH0e8lcCIHezALkHCKTLy42GCW2bv99wQNI+D/kbAZB7WYDcBwTS5fVMw4S2zd9+HJC0z0PuJwDyAAuQB4FAurxgapjQtvn7HQck7fOQvxMA+QcLkH8CgXR5RdYwoW3zdwgHJO3zkIcIgPyLBci/gUC6vORrmNC2+TuMA5L2ecjDBEAeYQHyKBBIl9eUDRPaNn+RwjAgaZ+HxOVA7hgTCpMAmYg7UKcXrQ0T2jZ/uXBA0j4PmYsAyNwsQOYBAunyqrhhQtvmLwkHJO3zkEkEQOZlATIfEEiXl90NE9o2f8k4IGmfh0wmAPIUFiDzA4F0eV3fMKFt81cAByTt85AFCIAsyAJkChBIlxcODhPaNn+FcEDSPg9ZiADIwixAFgEC6fLKxGFC2+avKA5I2uchixIAWYwFyFQgkC4vfRwmtG3+0nBA0j4PmUYAZHEWIEsAgXR5beUwoW3zVxIHJO3zkCUJgDyVBchSQCBdXbxZMn+nAfPn6GLJosshnn7y5++Y/9ADQaLXxmGBdtMdX2z6WMwJ+LgzhPqbRHD8QH1UxjVue7yxkMe7E3g8l4DHbyHxOFAfhYw5l6G1uaH1T0zAHbN5vGcUznydO0Y7vQVje5JATJGYz4nNY0oW+6AfLiGSTii63TML44CXivvMwnCNjhk1KZJpwiP+v6P+Tx3IEf93pb3PL+P9y+O9nhPJNHGwP2gr2J/L/1v9+6CNs7zXZ/ttzDXeG+w3t9gOzlYXpMbnACfQ/0SDst7nlvPz97qRo2B/mAZlDQ3O9V6f57cxz3hvsD+2jQS/jXP9NnQnVt57fb7fxnzjvcH+2DYS/TbK+23oWC/wXl/ot7HAeG+w39zQg3KFf++FaExbKrsGqAqFZQaoi+IDFFakiwQGqIsdH6B03BcLDFARY5PMadRyyxXJBEVv6Nn5Qa8N5FmvtwpFIqcL62XZthJs+4TPMju8S/y8RI38JBu6Bu9N8n8mGNrrDvSo0VaC8TPBaOOo8TdZvSchpJ1kY1/w9ynGsQBzEhXo8KOiHXqCn1wt4FL/g/T/owY46E4kABM9Q+np+OmSoANBx93LzUsQJ8z6LgEOyFFgW72zKX9Ru00B/a2AnlG9Sa5JK8IKRglVMBXjFQxWpIoCFUwlxysYHXcloRmxxLUKiWONrWKCDX38UYuOIOO4LT3bKg4JDUFtRc3OrrLviyr/snqpl0XMsdVLvcj/rl6yauekql5cNkRQ+VQunCmM/r82Rd3I8Rt6ZgeMQ1UBDhpVYZ1ORkaQz6pGPiX8EBWosG5z6waEE2ajhw3fIuPu7/iNF4d9PtHtDnC0IowdyJH9hulx2/zdTlJRA/2tgJ5Rt2fTDTC2OlcGjjXVgKfqdRsSY0u1wjJ9GFJribO1bxbCx303wdnaJQJxDyK5Ybw6kEeg1mqQ477RvLwt4JvBBLy8IxD3EBJeagB5AWqthhDwslzAN/cT8PKuQNwPkPByKZAXoNbqAQJeVgj45iECXlYKxP0wCS81gbwAtVYPE/CySsA3jxHw8oFA3MNJeKkF5AWotRpOwMtqAd88ScDLGoG4R5DwchmQF6DWagQBLx8L+GYkAS9rBeIeRcLL5UBegFqrUQS8fCLgmzEEvHwqEPdYEl5qA3kBaq3GEvCyQcA3zxLwslEg7udIeKkD5AWotXqOgJfPBXzzPAEvXwjE/QIJL3WBvAC1Vi8Q8LJZwDdTCHj5UiDuF0l4qQfkBai1epGAly0CvplGwMtWgbink/BSH8gLUGs1nYCXbwR88woBL9sE4n6VhJcGQF6AWqtXCXj5VsA3swh4+U4g7tkkvFwB5AWotZpNwMsOAd+8TsDLDwJxzyPh5UogL0Ct1TwCXn4U8M1CAl5+Eoj7DRJergLyAtRavUHAyy4B37xJwMsvAnG/RcJLQyAvQK3VWwS87BbwzdsEvOwRiPsdEl4aAXkBaq3eIeBlr4Bv3iXgZZ9A3O+R8NIYyAtQa/UeAS8HBHzzPgEvBwXiXkXCy9VAXoBaq1UEvPwh4JvVBLz8KRD3GhJergHyAtRarSHg5S8B36wl4OVvgbjXkfDSBMgLUGu1joCXIwK+WU/Ay1GBuDeQ8NIUyAtQa7WBgJcEge+R+pyAl0SBuL8g4eVaIC9ArdUXBLzkFvDNlwS85BGI+ysSXpoBeQFqrb4i4CWvgG++JuAln0Dc35Dw0hzIC1Br9Q0BL6cI+OZbAl7yC8T9HQkvLYC8ALVW3xHwUlDANz8Q8JIiEPdOEl5aAnkBaq12EvBSWMA3PxPwUkQg7l0kvLQC8gLUWu0i4KWYgG92E/CSKhD3HhJeWgN5AWqt9hDwUlzAN/sIeCkhEPd+El7aAHkBaq32E/ByqoBvfifgpZRA3H+Q8NIWyAtQa4XMXx6vjYXevzJ+e3oND70ugf6udf390fo7cfX3fOrvLjz2fWzeP/29Ofq7QPT3G+hntvVzqPrZOv28kH4GQt/Xre9V1fff6XuK9H0S+tqvvp6lz9Hr8476XIquD/WcV4/jum/S+ZbUsx1QT0dXVhbpB8708naWQD/wl+Nxn+PFfIFA3H+T9H/XAXkBaq2Q+dOLsS6MnLihjjVoD+1NYF8WlTrG6wrL+BwO5PWFaQwlJtb1BIZqL2WoRLChDgPb6lAY3xvpDT1a3AA8TpdXfwszt23+bgTmj7UTupGgE7pJqhNCA9kRaCiXl5cLE9o2f51w+avICmQnAiA7swDZBQiky+vXhQltm7+uuPxVYgWyKwGQ6SxAZgCBdHmBvDChbfPXDZe/yqxAdiMA8mYWILsDgXR5Bb4woW3zdwsuf1VYgbyFAMhbWYDsAQTS5SX+woS2zV9PXP6qsgLZkwDIXixA9gYC6fIagmFC2+avDy5/1ViB7EMAZF8WIPsBgXR5kcIwoW3zdxsuf9VZgbyNAMj+LEAOAALp8iqIYULb5u92XP5qsAJ5OwGQd7AAeScQSJeXWQwT2jZ/A3H568QK5EACIO9iAfJuIJAur+MYJrRt/gbh8teZFchBBEDewwLkvUAgXV4oMkxo2/wNxuWvCyuQgwmAHMIC5H1AIF1eiTJMaNv8DcXlrysrkEMJgLyfBcgHgEC6vNRlmNC2+XsQl790ViAfJAByGAuQDwGBdHktzTChbfP3MC5/GaxAPkwA5CMsQD4KBNLlxTrDhLbN32Ow/CnaZ0AfIwByOAuQjwOBdHk10DChbfP3BA5I2uchnyAA8kkWIEcAgXR5udEwoW3z9xQOSNrnIZ8iAPJpFiBHAoF0eT3TMKFt8zcKByTt85CjCIB8hgXI0UAgXV4wNUxo2/yNwQFJ+zzkGAIgx7IAOQ4IpMsrsoYJbZu/8TggaZ+HHE8A5LMsQD4HBNLlJV/DhLbN3wQckLTPQ04gAHIiC5DPA4F0eU3ZMKFt8/cCDkja5yFfIAByEguQk4FAurxobZjQtvmbggOS9nnIKQRAvsgC5EtAIF1eFTdMaNv8TcUBSfs85FQCIKexADkdCKTLy+6GCW2bv5dxQNI+D/kyAZAzWIB8BQiky+v6hgltm79XcUDSPg/5KgGQM1mAfA0IpMsLB4cJbZu/WTggaZ+HnEUA5GwWIOcAgXR5ZeIwoW3zNxcHJO3zkHMJgHydBch5QCBdXvo4TGjb/M3HAUn7POR8AiAXsAC5EAiky2srhwltm783cEDSPg/5BgGQi1iAXAwE0tXFmyXz9yYwf44uliy6HOJbJ3/+jvkPPRAkem3kTsC3e9TxxaZ1zPkE4o40kelvEsHxH0Vy3cRtjzcW8niuJu57/BSBuHOTeByoj0LGnMvQ2tzQ+icn4I7ZPN4lhTNf547RTm/B2J4kEFMk5nNi85iSxT7oh0uIpBOKbndpYeCgJhT30sJwjY4ZNSmSacI83o4jep//M6//U29ve5//jvcvj/f6jUimiYP9QVvB/lP8v9W/D9pY5r1e7rexyHhvsN/cYjs4W12QGr8LnED/Ew3e8z53hZ+/xUaOgv1hGrxnaLDSe/2+38abxnuD/bFt5PPbWOm3oTuxVd7rD/w23jLeG+yPbSPZb2OV34aO9UPv9Wq/jSXGe4P95oYelNf8ey9EY9pS2TVArSksM0B9FB+gsCJ9JDBAfez4AKXj/lhggIoYm2ROo5abNm8Ait7Qs/PDXhvIs14dvLbeEtbLsm0l2PYJn2V2eGv9vKwz8pNs6Bq8N8n/mWBorzvQo0ZbCcbPBKONo8bfZPWehJB2ko19wd+nGMcCzElUoMOPinboCX5ytYBL/Q/S/19ngIPuRAIw0TOUvI6fLgk6EHTc+YROl1ieQj9h1rcWOCCvA7aVnE35i9ptCuhvBfSMksofmpNPCCuYT4QqmE/jFQxWpE8FKpj1jlcwOu71QjNiiWsVEscaW8UEG/r411l0BBnHbenZVnFIaAhqK2p2dht8X2z8l9VLvSxijq1e6kX+d/WSVTsnVfXisiGCymdD4Uxh9P+1KepGjt/QMztgHGojcND4DNbpZGQE+fzMyKeEH9YJVFgF3boB4YTZqI57g0DcKY7feKHj3igQdyFHK8LYgRzZb5get81fYZKKGuhvBfSMKpxNN8DY6rwBONZ8DjxVr9uQGFs+LyzThyG1ljhb214g7jSCs7U3CMRd3M2ztScc5xdAHoFaq+KO+0bzcpOAb04l4KWjQNylSHjZBOQFqLUqRcBLZwHfnEHASxeBuM8k4WUzkBeg1upMAl7SBXxzFgEvGQJxn03Cy5dAXoBaq7MJeLlZwDflCHjpLhD3uSS8fAXkBai1OpeAl1sFfHM+AS89BOK+gISXLUBegFqrCwh46SXgm4sIeOktEPfFJLxsBfIC1FpdTMBLXwHfKAJe+gnEXZGEl6+BvAC1VhUJeOkv4JsqBLwMEIi7Kgkv3wB5AWqtqhLwcoeAb2oQ8HKnQNyXkvCyDcgLUGt1KQEvdwn45jICXu4WiPtyEl62A3kBaq0uJ+DlHgHf1CXg5V6BuOuR8PItkBeg1qoeAS9DBHxzBQEv9wnEfSUJL98BeQFqra4k4OV+Ad80IuDlAYG4G5Pw8j2QF6DWqjEBL8MEfNOEgJeHBOJuSsLLDiAvQK1VUwJeHhHwTXMCXh4ViLsFCS8/AHkBaq1aEPAyXMA3rQl4eVwg7jYkvOwE8gLUWrUh4OVJAd9cR8DLCIG4ryfh5UcgL0Ct1fUEvDwt4JsbCHgZKRD3jSS8/ATkBai1upGAl2cEfNOJgJfRAnF3JuHlZyAvQK1VZwJexgr4Jp2Al3ECcWeQ8LILyAtQa5VBwMuzAr7pTsDLcwJx30LCyy9AXoBaq1sIeJko4JueBLw8LxB3LxJefgXyAtRa9SLgZZKAb/oS8DJZIO5+JLzsBvIC1Fr1I+DlRQHfDCDg5SWBuG8n4WUPkBeg1up2Al6mCfhmIAEv0wXivouEl9+AvAC1VncR8DJDwDf3EPDyikDc95LwshfIC1BrdS8BLzMFfHMfAS+vCcQ9lISXfUBegFqroQS8zBbwzYMEvMwRiHsYCS/7gbwAtVbDCHh5XcA3jxDwMk8g7kdJeDkA5AWotXqUgJcFAr55nICXhQJxP0HCy0EgL0Ct1RMEvCwS8M1TBLwsFoj7aRJefgfyAtRaIfOXJ/KfVbzL+O3pNTz0ugT6u9b190fr78TV3/Opv7tQfx+b/o4p/b05+rtA9Pcb6Ge29XOo+tk6/byQfgZC39et71XV99/pe4r0fRL62q++nqXP0evzjvpciq4P9ZxXj+O6b9L5ltTzD6Cejq6sLNIPLPXytkygH3jG8bjf9WL+UCDu0ST9359AXoBaK2T+9GKsSyMnbqhjDdpDexPYl0WljvHPwjI+hwN5qDCNocTEOkRgqL+kDJUINpS5Qp9tW38XxvdGekOPFoeBx+ny6m9h5rbN3xFg/lg7oSMEndBRqU4IDWSkCC5ol5eXCxPaNn8JuPxVZAUSmAOxY0wsQgJkLiCQLq9fFya09awKl79KrEDmJgAyDwuQSUAgXV4gL0xo2/zlxeWvMiuQeQmAzMcCZDIQSJdX4AsT2jZ/p+DyV4UVyFMIgMzPAmQBIJAuL/EXJrRt/gri8leVFciCBECmsABZCAiky2sIhgltm7/CuPxVYwWyMAGQRViALAoE0uVFCsOEts1fMVz+qrMCWYwAyFQWINOAQLq8CmKY0Lb5K47LXw1WIIsTAFmCBciSQCBdXmYxTGjb/J2Ky18nViBPJQCyFAuQpwGBdHkdxzChbfN3Oi5/nVmBPJ0AyDNYgDwTCKTLC0WGCW2bv9K4/HVhBbI0AZBlWIA8CwikyytRhgltm7+zcfnrygrk2QRAnsMCZFkgkC4vdRkmtG3+yuHyl84KZDkCIM9lAfI8IJAur6UZJrRt/srj8pfBCmR5AiDPZwHyAiCQLi/WGSa0bf4uhOVP0T4DeiEBkBVYgLwICKTLq4GGCW2bv4txQNI+D3kxAZCXsAAZBQLp8nKjYULb5k/hgKR9HlIRAFmRBchKQCBdXs80TGjb/FXGAUn7PGRlAiCrsABZFQikywumhgltm79qOCBpn4esRgBkdRYgawCBdHlF1jChbfN3KQ5I2uchLyUAsiYLkLWAQLq85GuY0Lb5uwwHJO3zkJcRAHk5C5C1gUC6vKZsmNC2+auDA5L2ecg6BEDWZQGyHhBIlxetDRPaNn/1cUDSPg9ZnwDIBixAXgEE0uVVccOEts3flTggaZ+HvJIAyKtYgGwIBNLlZXfDhLbNXyMckLTPQzYiALIxC5BXA4F0eV3fMKFt83cNDkja5yGvIQCyCQuQTYFAurxwcJjQtvm7Fgck7fOQ1xIA2YwFyOZAIF1emThMaNv8tcABSfs8ZAsCIFuyANkKCKTLSx+HCW2bv9Y4IGmfh2xNAGQbFiDbAoF0eW3lMKFt89cOByTt85DtCIC8jgXI64FAurp4s2T+2gPz5+hiyUoyfx1O/vwd8x96IEj02sifgG93nOOLTeuYCwnEPV6ov0kExw/UR4133OONhTw+gcDjRQTinkjicaA+ChlzLkNrc4MvPJCAO2bzeG8okvk6d4x2egvG9iSBmCIxnxObx5Qs9kE/XEIknVB0uzcWwQEvFfeNReAaHTNqUiTThAW8HUe8nwX9nyn+T73d5H1+R+9fHu/125FMEwf7g7aC/UX8v9W/D9ro5L3u7LfxjvHeYL+5xXZwtrogNe4CnED/Ew26ep+b7udvmZGjYH+YBl0NDTK81938NpYb7w32x7ZRyG8jw29Dd2I3e6+7+228a7w32B/bRmG/jZv9NnSst3ivb/XbeM94b7Df3NCDco9/74VoTFsquwaoHkVkBqie8QEKK1JPgQGql+MDlI67l8AAFTE2yZxGLbdckUxQ9Iaenef2gkee9fq7cCTSQVgvy7aVYNsnfJbZ4fX289LHyE+yoWvw3iT/Z4Khve5AjxptJRg/E4w2jhp/k9V7EkLaSTb2BX+fYhwLMCdRgQ4/KtqhJ/jJ1QIu9T9I/7+PAQ66EwnARM9QJjl+uiToQNBxT3bzEsQJs77ewAG5D7CtKdmUv6jdpoD+VkDPqCkk16T7ElYwfYUqmH7xCgYrUj+BCuY2xysYHfdtQjNiiWsVEscaW8UEG/r4+1h0BBnHbenZVnFIaAhqK2p2dv19Xwz4l9VLvSxijq1e6kX+d/WSVTsnVfXisiGCyqd/kUxh9P+1KepGjt/QMztgHGoAcNC4HdbpZGQE+bzdyKeEH/oIVFjT3LoB4YTZqI67v0Dc0x2/8ULHPUAg7pcdrQhjB3Jkv2F63DZ/M0gqaqC/FdAzakY23QBjq3N/4FhzB/BUvW5DYmy5o4hMH4bUWuJs7V+F8XHPIjhbe1gg7tkkN4zfCeQRqLWa7bhvNC9HBXzzOgEvEYH+cR4JLwOBvAC1VvMIeEkU8M1CAl5yCcT9BgkvdwF5AWqt3iDgJY+Ab94k4CVJIO63SHi5G8gLUGv1FgEv+QR88zYBL8kCcb9DwssgIC9ArdU7BLzkF/DNuwS8FBCI+z0SXu4B8gLUWr1HwEuKgG/eJ+ClkEDcq0h4uRfIC1BrtYqAlyICvllNwEtRgbjXkPAyGMgLUGu1hoCXVAHfrCXgJU0g7nUkvAwB8gLUWq0j4KWEgG/WE/BSUiDuDSS83AfkBai12kDASykB33xOwMtpAnF/QcLLUCAvQK3VFwS8nCHgmy8JeDlTIO6vSHi5H8gLUGv1FQEvZQR88zUBL2cJxP0NCS8PAHkBaq2+IeDlHAHffEvAS1mBuL8j4eVBIC9ArdV3BLycK+CbHwh4OU8g7p0kvAwD8gLUWu0k4OV8Ad/8TMDLBQJx7yLh5SEgL0Ct1S4CXioI+GY3AS8XCcS9h4SXh4G8ALVWewh4uUTAN/sIeIkKxL2fhJdHgLwAtVb7CXipKOCb3wl4qSQQ9x8kvDwK5AWotfqDgJcqAr75i4CXqgJx/03Cy2NAXoBaq78JeKku4JujBLzUEIg70pSDl+FAXoBaK3T+JHipKeCbXI7HrXmpJRB3bhJeHgfyAtRa5Sbg5XIB3+Ql4KW2QNz5SHh5AsgLUGuVj4CXuhLfI0XASz2BuAuQ8PIkkBeg1qoAAS8NBHxTiICXKwTiLkzCywggL0CtVWECXq4S8E0xAl4aCsSdSsLLU0BegFqrVAJeGgv4pgQBL1cLxF2ShJengbwAtVYlCXhpIuCb0wh4aSoQ9+kkvIwE8gLUWp1OwEszAd+UJuCluUDcZUh4GQXkBai1KkPAS0sB35xDwEsrgbjLkvDyDJAXoNaqLAEvbQR8cx4BL20F4i5PwstoIC9ArVV5Al6uE/DNhQS8XC8QdwUSXsYAeQFqrZD5y+O1scL7V8ZvT6/hodcl0N+1rr8/Wn8nrv6eT/3dhfr72PR3TOnvzdHfBaK/30A/s62fQ9XP1unnhfQzEPq+bn2vqr7/Tt9TpO+T0Nd+9fUsfY5en3fU51J0fajnvHoc132TzreknmOBejq6srJIP3Cjl7dOAv3AJY73f128mG8RiDtK0v+NA/IC1Foh86cXY10ROXFDHWvQHtqbwL4sKnWM44rI+BwO5PgiNIYSE2s8gaGelTJUIthQ5gp9tm09VwTfG+kNPVpMAB6ny6u/hZnbNn8Tgflj7YQmEnRCz0t1QmggXwAayuXl5cKEts3fJFz+KrICOYkAyMksQE4BAuny+nVhQtvm70Vc/iqxAvkiAZAvsQA5FQikywvkhQltm79puPxVZgVyGgGQ01mAfBkIpMsr8IUJbZu/Gbj8VWEFcgYBkK+wAPkqEEiXl/gLE9o2fzNx+avKCuRMAiBfYwFyFhBIl9cQDBPaNn+zcfmrxgrkbAIg57AAORcIpMuLFIYJbZu/13H5q84K5OsEQM5jAXI+EEiXV0EME9o2fwtw+avBCuQCAiAXsgD5BhBIl5dZDBPaNn+LcPnrxArkIgIgF7MA+SYQSJfXcQwT2jZ/b+Hy15kVyLcIgFzCAuRSIJAuLxQZJrRt/t7G5a8LK5BvEwD5DguQy4BAurwSZZjQtvlbjstfV1YglxMA+S4LkO8BgXR5qcswoW3ztwKXv3RWIFcQALmSBcj3gUC6vJZmmNC2+VuFy18GK5CrCID8gAXID4FAurxYZ5jQtvlbDcufon0GdDUBkGtYgPwICKTLq4GGCW2bv49xQNI+D/kxAZBrWYBcBwTS5eVGw4S2zd8nOCBpn4f8hADIT1mAXA8E0uX1TMOEts3fBhyQtM9DbiAAciMLkJ8BgXR5wdQwoW3z9zkOSNrnIT8nAPILFiA3AYF0eUXWMKFt87cZByTt85CbCYD8kgXIr4BAurzka5jQtvnbggOS9nnILQRAbmUB8msgkC6vKRsmtG3+vsEBSfs85DcEQG5jAXI7EEiXF60NE9o2f9/igKR9HvJbAiC/YwHyeyCQLq+KGya0bf524ICkfR5yBwGQP7AAuRMIpMvL7oYJbZu/H3FA0j4P+SMBkD+xAPkzEEiX1/UNE9o2f7twQNI+D7mLAMhfWID8FQikywsHhwltm7/dOCBpn4fcTQDkHhYgfwMC6fLKxGFC2+ZvLw5I2uch9xIAuY8FyP1AIF1e+jhMaNv8HcABSfs85AECIA+yAPk7EEiX11YOE9o2f3/ggKR9HvIPAiD/ZAHyEBBIVxdvlszfX8D8ObpYspLM398nf/6O+Q89ECR6bRRNwLdbyfHFpnXMxQXirizU3ySC4wfqoyo3ddvjjYU8Xo3A4yUF4q5O4nGgPgoZcy5Da3ND618iAXfM5vEeLpL5OneMdnoLxvYkgZgiMZ8Tm8eULPZBP1xCJJ1QdLtHiuCAl4r7SBG4RseMmhTJNGEx/Tnez1T/Z5r/U29H9ecXjUTyeD9WRjJNHOwP2gr2l/T/Vv8+aCPBe1+i38b7xnuD/eYW28HZ6oLUOFdRnLb/RIPcOnd+/lYZOQr2h2mgfx+0keS9zuu38YHx3mB/bBvF/TaS/DZ0J5bPe53st/Gh8d5gf2wbJfw28vlt6FhP8V7n99tYbbw32G9u6EG5QNF/3VY0pi2VXQNUgaIyA1RBI9fxAcqyTS1SwaL4dlOKuj1A6bhTisI1+q+ndaN223E5jVpuuSKZoOgNPTvP7wWPPOv1nNfW3wITikgW279sWwm2fcJnmR1eId/HhQ0/Jxu6/v8Dpv8zwdBed6BHjbYSjJ8JRhtHjb/J6j0JIe0kG/uCv08xjgWYk6hAhx8V7dAT/ORqAZf6H6T/X9gAHd2JBGCiZyg1HT9dEnQg6LhruXkJ4oRZXyHggFwY2NZl2ZS/qN2mgP5WQM+oy0iuSRchrGCKCFUwReMVDFakogIVTDHHKxgddzGhCkbiWoXEscZWMcGGPv7CFh1BxnFberZVHBIagtqKmp1dqu+LtH9ZvdTLIubY6qVe5H9XL1m1c1JVLy4bIqh8UotmCqP/r01RN3L8hp7ZAeNQacBBozis08nICPJZ3MinhB8KF8XPHOu6dQPCCbNRHXeqQNz1HL/xQsedJhB3fUcrwtiBHNlvmB63zV8Dkooa6G8F9IxqkE03wNjqnAoca0oArw/rNiTGlhJFZfowpNYSZ2ufFThr2YjgbO0Egbgbk9wwXhLII1Br1dhx32henhfwTRMCXl4QiLspCS+nAnkBaq2aEvAyWcA3zQl4mSIQdwsSXkoBeQFqrVoQ8PKSgG9aE/AyVSDuNiS8nAbkBai1akPAy3QB31xHwMvLAnFfT8LL6UBegFqr6wl4eUXANzcQ8PKqQNw3kvByBpAXoNbqRgJeXhPwTScCXmYJxN2ZhJczgbwAtVadCXiZI+CbdAJe5grEnUHCS2kgL0CtVQYBL/MEfNOdgJf5AnHfQsJLGSAvQK3VLQS8LBTwTU8CXt4QiLsXCS9nAXkBaq16EfCyWMA3fQl4eVMg7n4kvJwN5AWotepHwMsSAd8MIOBlqUDct5Pwcg6QF6DW6nYCXt4R8M1AAl6WCcR9FwkvZYG8ALVWdxHw8q6Ab+4h4OU9gbjvJeGlHJAXoNbqXgJeVgr45j4CXt4XiHsoCS/nAnkBaq2GEvDygYBvHiTg5UOBuIeR8HIekBeg1moYAS9rBHzzCAEvHwnE/SgJL+WBvAC1Vo8S8LJWwDePE/CyTiDuJ0h4OR/IC1Br9QQBL58K+OYpAl7WC8T9NAkvFwB5AWqtnibgZaOAb54h4OUzgbhHk/ByIZAXoNZqNAEvXwj4ZhwBL5sE4h5PwksFIC9ArdV4Al6+FPDNBAJevhKIeyIJLxcBeQFqrSYS8LJVwDeTCHj5WiDuySS8XAzkBai1mkzAyzYB37xEwMt2gbinkvByCZAXoNZqKgEv3wn45mUCXr4XiHsGCS9RIC9ArdUMAl5+EPDNTAJedgrE/RoJLwrIC1Br9RoBLz8J+GYOAS8/C8Q9l4SXikBegFqruQS8/CLgm/kEvPwqEPcCEl4qAXkBaq0WEPCyR8A3iwh4+U0g7sUkvFQG8gLUWi0m4GWfgG+WEPCyXyDupSS8VAHyAtRaLSXg5aCAb5YR8PK7QNzLSXipCuQFqLVaTsDLnwK+WUHAyyGBuFeS8FINyAtQa4XMXx6vjTXevzJ+e3oND70ugf6udf390fo7cfX3fOrvLtTfx6a/Y0p/b47+LhD9/Qb6mW39HKp+tk4/L6SfgdD3det7VfX9d/qeIn2fhL72q69n6XP0+ryjPpei60M959XjuO6bqhWNRCT1rA7U09GVlUX6gSO6DxBYx+gDx+PO5cV8ikDcH5L0fzWAvAC1Vsj86cVY10RO3FDHGrSH9iawL4tKHWONojI+hwN5aVEaQ4mJdSmBoWpKGSoRbChzhT7btmoVxfdGekOPFpflkNXfwsxtm7/Lgflj7YQuJ+iEakt1Qmgg6+SQ5eXChLZewhuXv4qsQNYlALIeC5D1c8j6dWFCW68RjstfJVYgGxAAeQULkFfmkAXywoS2zd9VuPxVZgXyKgIgG7IA2SiHrMAXJrT1SvG4/FVhBbIxAZBXswB5TQ5Z4i9MaNv8NcHlryorkE0IgGzKAuS1OWQNwTChbfPXDJe/aqxANiMAsjkLkC1yyCKFYULb5q8lLn/VWYFsSQBkKxYgW+eQVRDDhLbNXxtc/mqwAtmGAMi2LEC2yyHLLIYJbZu/63D568QK5HUEQF7PAmT7HLKOY5jQtvnrgMtfZ1YgOxAAeQMLkDfmkIUiw4S2zd9NuPx1YQXyJgIgO7IA2SmHrEQZJrRt/jrj8teVFcjOBEB2YQGyaw5Z6jJMaNv8pePyl84KZDoBkBksQHbLIWtphgltm7+bcfnLYAXyZgIgu7MAeUsOWawzTGjb/N0Ky5+ifQb0VgIge7AA2TOHrAYaJrRt/nrhgKR9HrIXAZC9WYDsk0OWGw0T2jZ/fXFA0j4P2ZcAyH4sQN4GBNLl9UzDhLbNX38ckLTPQ/YnAHIAC5C3A4F0ecHUMKFt83cHDkja5yHvIADyThYgBwKBdHlF1jChbfN3Fw5I2uch7yIA8m4WIAcBgXR5ydcwoW3zdw8OSNrnIe8hAPJeFiAHA4F0eU3ZMKFt8zcEByTt85BDCIC8jwXIoUAgXV60Nkxo2/zdjwOS9nnI+wmAfIAFyAeBQLq8Km6Y0Lb5G4YDkvZ5yGEEQD7EAuTDQCBdXnY3TGjb/D2CA5L2echHCIB8lAXIx4BAuryub5jQtvkbjgOS9nnI4QRAPs4C5BNAIF1eODhMaNv8PYkDkvZ5yCcJgBzBAuRTQCBdXpk4TGjb/D2NA5L2ecinCYAcyQLkKCCQLi99HCa0bf6ewQFJ+zzkMwRAjmYBcgwQSJfXVg4T2jZ/Y3FA0j4POZYAyHEsQI4HAunq4s2S+XsWmD9HF0sWXQ7xuZM/f8f8hx4IEr02Tk3At/uR44tN65jPEIj7Y6H+JhEcP1Af9bHjHm8s5PFPCDxeWiDuT0k8DtRHIWPOZWhtbmj9z0zAHbN5vBOKZr7OHaOd3oKxPUkgpkjM58TmMSWLfdAPlxBJJxTd7sSiOOCl4p5YFK7RMaMmRTJNWMrbccT7eZr/83T/p96e9z7/Be9fHu/1R5FMEwf7g7aC/aX9v9W/D9qY5L2e7LfxsfHeYL+5xXZwtrogNZ4CnED/Ew1e9D73JT9/a40cBfvDNHjR0GCq93qa38Y6473B/tg2zvDbmOq3oTux6d7rl/02PjHeG+yPbeNMv43pfhs61hne61f8Nj413hvsNzf0oPzqv/dCNKYtlV0D1KtFZQaomfEBCivSTIEB6jXHBygd92sCA1TE2CRzGrXcckUyQdEbenZe1AseedarltfWc8J6WbatBNs+4bPMDm+Wn5fZRn6SDV2D9yb5PxMM7XUHetRoK8H4mWC0cdT4m6zekxDSTrKxL/j7FONYgDmJCnT4UdEOPcFPrhZwqf9B+v+zDXDQnUgAJnqGstHx0yVBB4KO+zM3L0GcMOubBRyQZwPb+jyb8he12xTQ3wroGfU5yTXpOYQVzByhCmZuvILBijRXoIJ53fEKRsf9utCMWOJahcSxxlYxwYY+/tkWHUHGcVt6tlUcEhqC2oqand083xfz/2X1Ui+LmGOrl3qR/129ZNXOSVW9uGyIoPKZVzRTGP1/bYq6keM39MwOGIeaDxw0FsA6nYyMIJ8LjHxK+GG2QIX1pVs3IJwwG9VxzxOI+yvHb7zQcc8XiHuLoxVh7ECO7DdMj9vmbytJRQ30twJ6Rm3NphtgbHWeBxxrFgJP1es2JMaWhUVl+jCk1hJna2sKxP0twdnaywTi/o7khvE3gDwCtVbfOe4bzUttAd/8QMBLHYG4d5LwsgjIC1BrtZOAl3oCvvmZgJf6AnHvIuFlMZAXoNZqFwEvVwj4ZjcBL1cKxL2HhJc3gbwAtVZ7CHhpKOCbfQS8NBKIez8JL28BeQFqrfYT8HK1gG9+J+DlGoG4/yDhZQmQF6DW6g8CXpoK+OYvAl6uFYj7bxJelgJ5AWqt/ibgpbmAb44S8NJCIO7ItRy8vA3kBai1QudPgpdWAr7J5XjcmpfWAnHnJuHlHSAvQK1VbgJe2gr4Ji8BL+0E4s5HwssyIC9ArVU+Al6uF/BNfgJe2gvEXYCEl+VAXoBaqwIEvNwg4JtCBLzcKBB3YRJe3gXyAtRaFSbgpaOAb4oR8NJJIO5UEl7eA/IC1FqlEvDSRcA3JQh46SoQd0kSXlYAeQFqrUoS8JIh4JvTCHjpJhD36SS8rATyAtRanU7AS3cB35Qm4OUWgbjLkPDyPpAXoNaqDAEvPQR8cw4BLz0F4i5LwssqIC9ArVVZAl56C/jmPAJe+gjEXZ6Elw+AvAC1VuUJeOkn4JsLCXi5TSDuCiS8fAjkBai1qkDAywAB31xCwMvtAnFHSXhZDeQFqLWKEvByp4BvKhHwMlAg7sokvKwB8gLUWlUm4OVuAd9UI+BlkEDc1Ul4+QjIC1BrVZ2Al3sFfFOTgJfBAnHXIuHlYyAvQK1VLQJe7hPwTW0CXoYKxF2HhJe1QF6AWqs6BLw8IOCb+gS8PCgQdwMSXtYBeQFqrRoQ8PKQgG+uIuDlYYG4G5Lw8gmQF6DWqiEBL48K+OZqAl4eE4j7GhJePgXyAtRaXUPAy+MCvrmWgJcnBOJuRsLLeiAvQK1VMwJeRgj4piUBL08JxN2KhJcNQF6AWqtWBLyMFPBNWwJeRgnE3Y6El41AXoBaq3YEvIwW8E17Al7GCMTdgYSXz4C8ALVWHQh4GSfgm5sIeBkvEHdHEl4+B/IC1Foh85fHa2O996+M355ew0OvS6C/a11/f7T+Tlz9PZ/6uwv197Hp75jS35ujvwtEf7+BfmZbP4eqn63TzwvpZyD0fd36XlV9/52+p0jfJ6Gv/errWfocvT7vqM+l6PpQz3n1OK77Jp1vST2/AOrp6MrKIv3ARC9vkwT6gS6O939TvJhnCMTdlaT/2wTkBai1QuZPL8a6PnLihjrWoD20N4F9WVTqGDcVlfE5HMjNRWkMJSbWZgJDfSllqESwocwV+qxXVC2K7430hh4ttgCP0+XV38LMbb0CKjB/rJ3QVoJO6GupTggN5DdAQ7m8vFyY0Lb524bLX0VWILcRALmdBchvgUC6vH5dmNDW6+Di8leJFcjvCID8ngXIHUAgXV4gL0xo6wWGcfmrzArkDwRA7mQB8kcgkC6vwBcmtG3+fsLlrworkD8RAPkzC5C7gEC6vMRfmNC2+fsFl7+qrED+QgDkryxA7gYC6fIagmFCW6/djctfNVYg9xAA+RsLkHuBQLq8SGGY0NaLouPyV50VyH0EQO5nAfIAEEiXV0EME9o2fwdx+avBCuRBAiB/ZwHyDyCQLi+zGCa0bf7+xOWvEyuQfxIAeYgFyL+AQLq8jmOY0Lb5+xuXv86sQP5NAORhFiCPAIF0eaHIMKFt83cUl78urEAeJQAyUowEyATcgTq9EmWY0Lb5S8TlrysrkInF3D/GXCxA5gYC6fJSl2FC2+YvDy5/6axA5iEAMokFyLxAIF1eSzNMaNv85cPlL4MVyHwEQCazAHkKEEiXF+sME9o2f/lh+VO0z4DmJwCyAAuQBYFAurwaaJjQtvlLwQFJ+zxkCgGQhViALAwE0uXlRsOEts1fERyQtM9DFiEAsigLkMWAQLq8nmmY0Lb5S8UBSfs8ZCoBkGksQBYHAunygqlhQtvmrwQOSNrnIUsQAFmSBchTgUC6vCJrmNC2+SuFA5L2echSBECexgLk6UAgXV7yNUxo2/ydgQOS9nnIMwiAPJMFyNJAIF1eUzZMaNv8lcEBSfs8ZBkCIM9iAfJsIJAuL1obJrRt/s7BAUn7POQ5BECWZQGyHBBIl1fFDRPaNn/n4oCkfR7yXAIgz2MBsjwQSJeX3Q0T2jZ/5+OApH0e8nwCIC9gAfJCIJAur+sbJrRt/irggKR9HrICAZAXsQB5MRBIlxcODhPaNn+X4ICkfR7yEgIgoyxAKiCQLq9MHCa0bf4q4oCkfR6yIgGQlViArAwE0uWlj8OEts1fFRyQtM9DViEAsioLkNWAQLq8tnKY0Lb5q44DkvZ5yOoEQNZgAfJSIJCuLt4smb+awPw5uliy6HKItU7+/B3zH/yrY7w2yiTg2+3m+GLTOuayAnHfLNTfJILjB+qjbr7WbY83FvL4rQQeP1cg7h4kHgfqo5Ax5zK0Nje0/uUScMdsHu9lxTJf547RTm/B2J4kEFMk5nNi85iSxT7oh0uIpBOKbvfyYjjgpeK+vBhco2NGTYpkmvAsb8cR7+fZ/s9z/J96q61z5P3L473eEMk0cbA/aCvYf67/t/r3QRt1vdf1/DY2Gu8N9ptbbAdnqwtS4/rACfQ/0aCB97lX+Pn7zMhRsD9MgwaGBld6r6/y2/jceG+wP7aNsn4bV/pt6E6sofe6kd/GF8Z7g/2xbZTz22jot6Fjbey9vtpvY5Px3mC/uaEH5Wv+vReiMW2p7BqgrikmM0A1iQ9QWJGaCAxQTR0foHTcTQUGqIixSeY0arnlimSCojf07PxUL3jkWa+vikYitYT1smxbCbZ9wmeZHd61fl6aGflJNnQN3pvk/0wwtNcd6FGjrQTjZ4LRxlHjb7J6T0JIO8nGvuDvU4xjAeYkKtDhR0U79AQ/uVrApf4H6f83M8BBdyIBmOgZSm/HT5cEHQg67j5uXoI4YdZ3LXBAbgZsq2825S9qtymgvxXQM6ovyTXp5oQVTHOhCqZFvILBitRCoIJp6XgFo+NuKTQjlrhWIXGssVVMsKGPv5lFR5Bx3JaebRWHhIagtqJmZ9fK90Xrf1m91Msi5tjqpV7kf1cvWbVzUlUvLhsiqHxaFcsURv9fm6Ju5PgNPbMDxqFaAweNNrBOJyMjyGcbI58SfmgmUGENcOsGhBNmozruVgJx3+74jRc67tYCcd/haEUYO5Aj+w3T47b5u5Okogb6WwE9o+7MphtgbHVuBRxr2gJP1es2JMaWtsVk+jCk1hJna78sio/7HoKztVsE4r6X5IbxdkAegVqrex33jeblawHf3EfAyzcCcQ8l4eU6IC9ArdVQAl62C/jmQQJevhWIexgJL9cDeQFqrYYR8PK9gG8eIeBlh0Dcj5Lw0h7IC1Br9SgBLzsFfPM4AS8/CsT9BAkvHYC8ALVWTxDw8rOAb54i4GWXQNxPk/ByA5AXoNbqaQJefhXwzTMEvOwWiHs0CS83AnkBaq1GE/Dym4BvxhHwslcg7vEkvNwE5AWotRpPwMt+Ad9MIODlgEDcE0l46QjkBai1mkjAy+8CvplEwMsfAnFPJuGlE5AXoNZqMgEvhwR88xIBL38JxD2VhJfOQF6AWqupBLwcFvDNywS8HBGIewYJL12AvAC1VjMIeIkI3Dc3k4CXBIG4XyPhpSuQF6DW6jUCXnIJ+GYOAS+5BeKeS8JLOpAXoNZqLgEvSQK+mU/AS16BuBeQ8JIB5AWotVpAwEuygG8WEfByikDci0l46QbkBai1WkzASwEB3ywh4KWgQNxLSXi5GcgLUGu1lICXQgK+WUbAS2GBuJeT8NIdyAtQa7WcgJeiAr5ZQcBLMYG4V5LwcguQF6DWaiUBL2kCvvmAgJfiAnF/SMLLrUBegFqrDwl4KSngm48IeDlVIO6PSXjpAeQFqLX6mICX0wR88wkBL6cLxP0pCS89gbwAtVafEvBypoBvNhLwUlog7s9IeOmFXBATyMtnBLycJeCbTQS8nC0Q92YSXnoDeQFqrTYT8FJWwDdbCHgpJxD3VhJe+gB5AWqtthLwcp6Ab7YR8FJeIO7tJLz0BfIC1FptJ+DlAgHffE/Ay4UCce8g4aUfkBeg1moHAS8XCfjmRwJeLhaI+ycSXm4D8gLUWv1EwEtUwDe/EPCiBOL+lYSX/kBegFqrXwl4qSTgm98IeKksEPdeEl4GAHkBaq32EvBSVcA3Bwh4qSYQ90ESXm4H8gLUWh0k4KWGgG/+JODlUoG4D5HwcgeQF6DWCpm/PF4bm71/Zfz29Boeel0C/V3r+vuj9Xfi6u/51N9dqL+PTX/HlP7eHP1dIPr7DfQz2/o5VP1snX5eSD8Doe/r1veq6vvv9D1F+j4Jfe1XX8/S5+j1eUd9LkXXh3rOq8dx3TfdUSwSkdTzTqCejq6sLNIPXK7X3xPoBw47Hnd9L+bGAnEfIen/BgJ5AWqtkPnTi7Fujpy4oY41aA/tTWBfFpU6xoHFZHwOB/KuYjSGEhPrLgJD3S1lqESwocok4NoaVAzfG+kNPVrck0NWfwszt/Uqf8D8sXZC9xJ0QoOlOiE0kENyyPJyYUJbL5+Iy19FViDvIwByKAuQ9+eQ9evChLbN3wO4/FViBfIBAiAfZAFyWA5ZIC9MaNv8PYTLX2VWIB8iAPJhFiAfAQLp8gp8YUJbr0yKy18VViAfJQDyMRYghwOBdHmJvzChrZd8xeWvKiuQjxMA+QQLkE8CgXR5DcEwoW3zNwKXv2qsQI4gAPIpFiCfBgLp8iKFYULb5m8kLn/VWYEcSQDkKBYgnwEC6fIqiGFCW6+mjMtfDVYgRxMAOYYFyLFAIF1eZjFMaOtlqnH568QK5DgCIMezAPksEEiX13EME9o2f8/h8teZFcjnCICcwALkRCCQLi8UGSa0bf6ex+WvCyuQzxMA+QILkJOAQLq8EmWY0NYrwOPy15UVyMkEQE5hAfJFIJAuL3UZJrRt/l7C5S+dFciXCICcygLkNCCQLq+lGSa0bf6m4/KXwQrkdAIgX2YBcgYQSJcX6wwT2jZ/r8Dyp2ifAX2FAMhXWYCcCQTS5dVAw4S2zd9rOCBpn4d8jQDIWSxAzgYC6fJyo2FC2+ZvDg5I2uch5xAAOZcFyNeBQLq8nmmY0Lb5m4cDkvZ5yHkEQM5nAXIBEEiXF0wNE9o2fwtxQNI+D7mQAMg3WIBcBATS5RVZw4S2zd9iHJC0z0MuJgDyTRYg3wIC6fKSr2FC2+ZvCQ5I2uchlxAAuZQFyLeBQLq8pmyY0Lb5ewcHJO3zkO8QALmMBcjlQCBdXrQ2TGjb/L2LA5L2ech3CYB8jwXIFUAgXV4VN0xo2/ytxAFJ+zzkSgIg32cBchUQSJeX3Q0T2jZ/H+CApH0e8gMCID9kAXI1EEiX1/UNE9o2f2twQNI+D7mGAMiPWID8GAikywsHhwltm7+1OCBpn4dcSwDkOhYgPwEC6fLKxGFC2+bvUxyQtM9DfkoA5HoWIDcAgXR56eMwoW3ztxEHJO3zkBsJgPyMBcjPgUC6vLZymNC2+fsCByTt85BfEAC5iQXIzUAgXV28WTJ/XwLz5+hiyaLLIX518ufvmP/QA0Gi18Z5Cfh2E5rJxh2125SO+UKBuBObyfQ3ieD4gfqoxGZue7yxkMfzEHj8IoG4k0g8DtRHIWPOZWhtbmj9KyTgjtk83i3FMl/njtFOb8HYniQQUyTmc2LzmJLFPuiHS4ikE4pud2sxHPBScW8tBtfomFGTIpkmLO/tOOL9PN//eYH/U29fe5//jfcvj/f6y0imiYP9QVvB/ov8v9W/D9rY5r3e7rfxlfHeYL+5xXZwtrogNf4WOIH+Jxp8533u937+thg5CvaHafCdocEO7/UPfhtbjfcG+2PbuNBvY4ffhu7Ednqvf/Tb+Np4b7A/to0Kfhs7/TZ0rD95r3/22/jGeG+w39zQg/Kuf++FaExbKrsGqF3FZAaoX+IDFFakXwQGqF8dH6B03L8KDFARY5PMadRyyxXJBEVv6Nl5GS945FmvQV5bXwnrZdm2Emz7hM8yO7zdfl72GPlJNnQN3pvk/0wwtNcd6FGjrQTjZ4LRxlHjb7J6T0JIO8nGvuDvU4xjAeYkKtDhR0U79AQ/uVrApf4H6f/vMcBBdyIBmOgZSrLjp0uCDgQd9ylCp0ssT6GfMOvbDRyQ9wDbyp9N+YvabQrobwX0jJLKH5qT3wgrmN+EKpi98QoGK9JegQpmn+MVjI57n9CMWOJahcSxxlYxwYY+/j0WHUHGcVt6tlUcEhqC2oqand1+3xcH/mX1Ui+LmGOrl3qR/129ZNXOSVW9uGyIoPLZXyxTGP1/bYq6keM39MwOGIc6ABw0DsI6nYyMIJ8HjXxK+GGPQIVVyK0bEE6Yjeq49wvEXdjxGy903AcE4i7iaEUYO5Aj+w3T47b5K0pSUQP9rYCeUVL5SwRzsh841vwOPFWv25AYW34vJtOHIbWWOFt7t0DcJQjO1t4jEHdJN8/WnnCcfwB5BGqtSjruG83LYAHfnEbAyxCBuE8n4eVPIC9ArdXpBLwMFfBNaQJe7heIuwwJL4eAvAC1VmUIeHlQwDfnEPAyTCDusiS8/AXkBai1KkvAy8MSdRsBL48IxF2ehJe/gbwAtVblCXh5TMA3FxLwMlwg7gokvBwG8gLUWlUg4OUJAd9cQsDLkwJxR0l4OQLkBai1ihLw8pSAbyoR8PK0QNyVSXg5CuQFqLWqTMDLKAHfVCPg5RmBuKuT8BJJxeUSqLWqTsDLGAHf1CTgZaxA3LVIeEkA8gLUWtUi4GW8gG9qE/DyrEDcdUh4SQTyAtRa1SHgZYKAb+oT8DJRIO4GJLzkAvIC1Fo1IODlBQHfXEXAyySBuBuS8JIbyAtQa9WQgJcpAr65moCXFwXivoaElzxAXoBaq2sIeJkq4JtrCXiZJhB3MxJekoC8ALVWzQh4eVnANy0JeJkhEHcrEl7yAnkBaq1aEfDyqoBv2hLwMlMg7nYkvOQD8gLUWrUj4GWWgG/aE/AyWyDuDiS8JAN5AWqtOhDwMlfANzcR8PK6QNwdSXg5BcgLUGvVkYCX+QK+6ULAywKBuLuS8JIfyAtQa9WVgJc3BHzTjYCXRQJx30zCSwEgL0Ct1c0EvLwp4JtbCXh5SyDuHiS8FATyAtRa9SDgZamAb3oT8PK2QNx9SHhJAfIC1Fr1IeBlmYBvbiPgZblA3P1JeCkE5AWotepPwMt7Ar65g4CXFQJx30nCS2EgL0Ct1Z0EvLwv4Ju7CXhZJRD3IBJeigB5AWqtBhHw8qGAbwYT8LJaIO4hJLwUBfIC1FoNIeDlIwHf3E/Ay8cCcT9AwksxIC9ArdUDBLysE/DNQwS8fCIQ98MkvKQCeQFqrR4m4GW9gG8eI+Blg0Dcw0l4SQPyAtRaDSfg5TMB3zxJwMvnAnGPIOGlOJAXoNZqBAEvmwR8M5KAl80CcY8i4aUEkBeg1gqZvzxeG9u8f2X89vQaHnpdAv1d6/r7o/V34urv+dTfXai/j01/x5T+3hz9XSD6+w30M9v6OVT9bJ1+Xkg/A6Hv69b3qur77/Q9Rfo+CX3tV1/P0ufo9XlHfS5F14d6zqvHcd036XxL6lkSqKejKyuL9ANbPd23CfQDYxyP+1sv5p8E4h5L0v+dCuQFqLVC5k8vxrotcuKGOtagPbQ3gX1ZVOoYT02V8TkcyFKpNIYSE6sUgaFOkzJUIthQ5gp91qtZpeJ7I72hR4szgMfp8upvYea2zd+ZwPyxdkJnEnRCpaU6ITSQZYCGcnl5uTChbfN3Fi5/FVmBPIsAyLNZgDwHCKTL69eFCW297houf5VYgSxLAGQ5FiDPBQLp8gJ5YUJblzm4/FVmBfI8AiDLswB5PhBIl1fgCxPaNn8X4PJXhRXICwiAvJAFyApAIF1e4i9MaNv8XYTLX1VWIC8iAPJiFiAvAQLp8hqCYUJbrxWJy181ViCjBEAqFiArAoGsBASyMgmQlXD5q84KZCUCICuzAFklh6yCGCa0bf6q4vJXgxXIqgRAVmMBsnoOWWYxTGjb/NXA5a8TK5A1CIC8lAXImjlkHccwoa3Xt8XlrzMrkLUIgLyMBcjLc8hCkWFCWy8cjMtfF1YgaxMAWYcFyLo5ZCXKMKFt81cPl7+urEDWIwCyPguQDXLIUpdhQtvm7wpc/tJZgbyCAMgrWYC8KoespRkmtPWa3Lj8ZbAC2ZAAyEYsQDbOIYt1hgltvdg5LH+K9hnQqwmAvIYFyCY5ZDXQMKFt89cUByTt85BNCYC8lgXIZjlkudEwoW3z1xwHJO3zkM0JgGzBAmTLHLKeaZjQtvlrhQOS9nnIVgRAtmYBsk0OWTA1TGjb/LXFAUn7PGRbAiDbsQB5XQ5ZkTVMaNv8XY8DkvZ5yOsJgGzPAmSHHLLka5jQtvm7AQck7fOQNxAAeSMLkDcBgXR5TdkwoW3z1xEHJO3zkB0JgOzEAmRnIJC3AYHsTwJkFxyQtM9DdiEAsisLkOlAIF1eFTdMaNv8ZeCApH0eMoMAyG4sQN4MBNLlZXfDhLbNX3cckLTPQ3YnAPIWFiBvBQLp8rq+YULb5q8HDkja5yF7EADZkwXIXkAgXV44OExo2/z1xgFJ+zxkbwIg+7AA2RcIpMsrE4cJbZu/fjggaZ+H7EcA5G0sQPYHAuny0sdhQtvmbwAOSNrnIQcQAHk7C5B3AIF0eW3lMKFt83cnDkja5yHvJAByIAuQdwGBHAkEkmXx67uB+XN0sWTR5RAHnfz5O+Y/9ECg22sq0O6zwnFH7TalY24mEPdzQv1NIjh+oD4KGbPWIymS2T9c6/074mulfzb3f+rtHo/5e71/ebzX240cBfuDtoL9rfy/1b8P2hjsvR7it/Gt8d5g/z85nvu89w/12/rOaCvYH3Y89xnHc7/3+gG/je+N9wb7Y9to4bdxv9+Gnow96L0e5rexw3hvsD+2jZZ+Gw/6behYH/JeP+y38YPx3mC/3uDrW3kN3p2Kb/d5x/tgveTwIIG4XyCZ+zwCHLuBWitk/nIZvjE39LgGzGXUPN5HUzNf5/Z/JmbhiSSBmCIxnxObx5Qs9kE/XEKkR1Px7T6WioNSKu7HUuEa/deJkm0ekDkdnuq2L/UAfJrAQDTF8QH4koT/TPjQ7b7oeNyVE/4zoUO3+5LjxZ+ecJ0hEPfUbJpwRe02BeRRmR63zd80kvwB/a2mAvM3nWTC/zhwHAR6Rk0nnPA/LjThfyI+4ceK9ITAhP9Jxyf8Ou4nhSf86M5pxMl/NkJlV+c0QqhzeireOWFFekqgc3ra8c5Jx/20UOckcWZHHyu6s0Oe3UDqPZLgTElpgQpyFkHlXEYg7tkklR/wjI6aBaz85uTAynk2MH9zSSrnUcB+EegZNZewch4lNDl9Jj45xYr0jMDkdLTjk1Md92iSyelwv8pHTwrGpObMuBc6ftlI+3KMQNxvkExiRgMH4YXAScwikknMWGD+gJ5RixznLuwkQNRuO+62kajdBj3pMy6Vw8/jT/4zxhWza1I+XmhS/mx8Uo4V6VmBSflzjk/KddzPkUzKx/nHiu7sxgE1Quo9geCM8dkCk+YlBGeMzxGIe2kOPGO8BFgsvJ0DzxgvBebvHZJiayKwXwR6RiHzl12T04lCk9Pn45NTrEjPC0xOX3B8cqrjfoFkcqov748VmBSscHwypM+ajhOIeyXJYDQJOBgBtVYrHT/zp7meJOCbD0gmgS8I+cY2fx+S5A/ob/UBMH+rSfqtyUD/AT2jVjveb4WdhIrabQp4ZQB60nEKyRWLF0/+KxaVsqsofFGoKHwpXhRiRXpJoCic6nhRqOOeSlIUTvGPFd3ZTQFqhNR7GsEVi3ICRcdagisW5wrEvS4HXrFYCywWPsmBVyzWAfP3KUmxNR3YLwI9o5D5y67J6XShyenL8ckpVqSXBSanMxyfnOq4Z5BMTvXtJZMFJgWfOz4Z0medpwjE/QXJYPQKcDACaq2+cPzMn+b6FQHffEkyCZwh5Bvb/H1Fkj+gv9WXwPxtIem3XgX6D+gZtcXxfivsJFTUblPAKwPQk44zSa5YvHbyX7GonF1F4WtCReGseFGIFWmWQFE42/GiUMc9m6QonOkfK7qzmwnUCKn3HIIrFuUFio5tBFcszheIe3sOvGKxDVgsfJsDr1hsB+bvO5Jiay6wXwR6RiHzl12T07lCk9PX45NTrEivC0xO5zk+OdVxzyOZnOrbS14VmBT86PhkSJ91nikQ908kg9F84GAE1Fr95PiZP831fAHf/EIyCZwn5Bvb/P1Kkj+gv9UvwPztJum3FgD9B/SM2u14vxV2EipqtynglQHoSceFJFcs3jj5r1hUya6i8A2honBRvCjEirRIoChc7HhRqONeTFIULvSPFd3ZLQRqhNT7TYIrFhcKFB37CK5YVBCIe38OvGKxD1gsHMiBVyz2A/N3kKTYegvYLwI9o5D5y67J6VtCk9Ml8ckpVqQlApPTpY5PTnXcS0kmp/r2kgUCk4K/HJ8M6bPOCwXi/ptkMHobOBgBtVZ/O37mT3P9toBvjpJMApcK+ca6H2/OkT+gv9VRYP4SmnP0W+8gTy7gYlbo/MHXtwk5CRW12xTwygD0pOMykisWy0/+KxZVs6soXC5UFL4bLwqxIr0rUBS+53hRqON+j6QoXOYfK7qzWwbUCKn3CoIrFhcLFB15mrvtQ33F4hKBuJNIigXkFQtTa9v85SXJH/KKRRIwf/lIiq2VwH4R6BmFzF92TU5XCk1O349PTrEivS8wOV3l+ORUx72KZHKqby95R2BSUNDxyZA+67xMIO4UksHoA+BgBNRapTh+5k9z/YGAb4qQTAJXCfnGNn9FSfIH9LcqAsxfMZJ+60Og/4CeUcUc77fCTkJF7TYFvDIAPem4muSKxZqT/4pFtewqCtcIFYUfxYtCrEgfCRSFHzteFOq4PyYpClf7x4ru7FYDNULqvZbgioUSKDpKEFyxqCgQd8kceMWiBLBYODUHXrEoCcxfKZJiax2wXwR6RpUivGKxTmhy+kl8cooV6ROByemnjk9OddyfkkxO9e0lHwpMCko7PhnSZ51XC8RdhmQwWg8cjIBaqzKOn/nTXK8X8M05JJPAT4V8Y5u/siT5A/pbnQPMXzmSfmsD0H9Az6hyjvdbYSehonabAl4ZgJ503EhyxeKzk/+KRfXsKgo/EyoKP48XhViRPhcoCr9wvCjUcX9BUhRu9I8V3dltBGqE1HsTwRWLygJFx/kEVyyqCMR9QQ68YnE+sFi4MAdesbgAmL8KJMXWZmC/CPSMqkB4xWKz0OT0y/jkFCvSlwKT068cn5zquL8imZzq20s2CEwKlOOTIX3WeaNA3BVJBqMtwMEIqLWq6PiZP831FgHfVCGZBH4l5Bvb/FUlyR/Q36oKMH/VSPqtrUD/AT2jqjneb4WdhIrabQp4ZQB60vFrkisW35z8VyxqZFdR+I1QUbgtXhRiRdomUBRud7wo1HFvJykKv/aPFd3ZfQ3UCKn3twRXLKoJFB01Ca5YVBeIu1YOvGJRE1gsXJYDr1jUAubvcpJi6ztgvwj0jLqc8IrFd0KT0+/jk1OsSN8LTE53OD451XHvIJmc6ttLtgpMCuo7PhnSZ52/Foi7Aclg9ANwMAJqrRo4fuZPc/2DgG+uIpkE7hDyjW3+GpLkD+hvdRUwf41I+q2dQP8BPaMaOd5vhZ2EitptCnhlAHrS8UeSKxY/nfxXLDplV1H4k1BR+HO8KMSK9LNAUbjL8aJQx72LpCj80T9WdGf3I1AjpN6/EFyxuFSg6GhCcMWipkDcTXPgFYsmwGLh2hx4xaIpMH/NSIqtX4H9ItAzqhnhFYtfhSanu+OTU6xIuwUmp3scn5zquPeQTE717SU7BSYFrR2fDOmzzj8KxN2GZDD6DTgYAbVWbRw/86e5/k3AN9eRTAL3CPnGNn/Xk+QP6G91HTB/7Un6rb1A/wE9o9o73m+FnYSK2m0KeGUAetJxH8kVi/0n/xWLztlVFO4XKgoPxItCrEgHBIrCg44XhTrugyRF4T7/WNGd3T6gRki9fye4YnGZQNFxE8EVi8sF4u6YA69Y3AQsFjrlwCsWHYH560xSbP0B7BeBnlGdCa9Y/CE0Of0zPjnFivSnwOT0kOOTUx33IZLJqb69ZK/ApKCb45MhfdZ5n0DcN5MMRn8BByOg1upmx8/8aa7/EvDNrSSTwENCvrHNXw+S/AH9rW4F5q8nSb/1N9B/QM+ono73W2EnoaJ2mwJeGYCedDxMcsXiyMl/xaJLdhWFR4SKwqPxohAr0lGBojCS5nZRqOPWxwjWSORYD/vHiu7sDiMLd6DeCWnuX7GoI1B09CW4YlFXIO5+OfCKRV9gsXBbDrxi0Q+Yv/4kxVYisF8Eekb1J7xiAczlcZPTXMacIj45tWxTi6QTim43t+OTUx13bpLJqb695G+BScFAxydD+qzzYYG47yIZjPIAByOg1uoux8/8aa7zpOHbvYdkEphbyDe2+buXJH9Af6t7gPkbTNJvJQH9B/SMGux4vxV2EipqtynglQHoSce8aRx+zgf0s6NXLLpmV1GYT6goTI4XhViRkgWKwlMcLwp13KeQFIV5/WNFd3Z5gRoh9c5PcMWivkCxej/BFYsGAnE/kAOvWNwPLBYezIFXLB4A5m8YSbFVANgvAj2jhhFesSggNDktGJ+cYkUqKDA5TXF8cqrjTiGZnOrbS5IEzsA+5vhkSJ91zisQ93CSwagQcDACaq2GO37mT3NdSMA3T5JMAlOEfGObvxEk+QP6Wz0JzN9TJP1WYaD/gJ5RTzneb4WdhIrabQp4ZQB60rEIyRWLoif/FYv07CoKiwoVhcXiRSFWpGICRWGq40WhjjuVpCgs4h8rurMrAtQIqXcawRWLKwXO3D9DcMXiKoG4R+fAKxbPAIuFMTnwisVoYP7GkhRbxYH9ItAzaizhFYviQpPTEvHJKVakEgKT05KOT0513CVJJqf69pLCAmdgJzg+GdJnnYsIxD2RZDA6FTgYAbVWEx0/86e5PlXAN5NIJoElhXxjm7/JJPkD+ltNAuZvCkm/VQroP6Bn1BTH+62wk1BRu00BrwxATzqeRnLF4vST/4pFRnYVhacLFYVnxItCrEhnCBSFZzpeFOq4zyQpCk/zjxXd2Z0G1Aipd2mCKxaNBM7cTyO4YtFYIO7pOfCKxTRgsfByDrxiMR2YvxkkxVYZYL8I9IyaQXjFoozQ5PSs+OQUK9JZApPTsx2fnOq4zyaZnOrbS0oJnIGd5fhkSJ91Pk0g7tkkg9E5wMEIqLWa7fiZP831OQK+eZ1kEni2kG9s8zePJH9Af6vXgfmbT9JvlQX6D+gZNd/xfivsJFTUblPAKwPQk47lSK5YnHvSX7FQ2VYUnitUFJ4XLwqxIp0nUBSWd7wo1HGXJykKy/nHiu7sygE1Qup9PsEVi2sEztwvIrhi0UQg7sU58IrFImCx8GYOvGKxGJi/t0iKrQuA/SLQM+otwisWFwhNTi+MT06xIl0oMDmt4PjkVMddgWRyqm8vKStwBnaZ45Mhfda5nEDcy0kGo4uAgxFQa7Xc8TN/muuLBHyzgmQSWEHIN7b5W0mSP6C/1Qpg/t4n6bcuBvoP6Bn1vuP9VthJqKjdpoBXBqAnHS8huWIRPfmvWKjsKgqjQkWhiheFWJGUQFFY0fGiUMddkaQovMQ/VnRndwlQI6TelQiuWFwrcOZ+NcEVi2YCca/JgVcsVgOLhY9y4BWLNcD8fUxSbFUG9otAz6iPCa9YVBaanFaJT06xIlURmJxWdXxyquOuSjI51beXXCxwBna945Mhfdb5EoG4N5AMRtWAgxFQa7XB8TN/mutqAr75nGQSWFXIN7b5+4Ikf0B/q8+B+dtE0m9VB/oP6Bm1yfF+K+wkVNRuU8ArA9CTjjVIrlhcevJfsaiYXUXhpUJFYc14UYgVqaZAUVjL8aJQx12LpCis4R8rurOrAdQIqfdlBFcsWgicud9CcMWipUDcW3PgFYstwGLh6xx4xWIrMH/fkBRblwP7RaBn1DeEVywuF5qc1o5PTrEi1RaYnNZxfHJ6zJwkk1N9e0l1gTOw3zs+GdJnnWsIxL2DZDCqCxyMgFqrHY6f+dNc1xXwzY8kk8A6Qr6xzd9PJPkD+lv9CMzfzyT9Vj2g/4CeUT873m+FnYSK2m0KeGUAetKxPskViwYn/xWLStlVFDYQKgqviBeFWJGuECgKr3S8KNRxX0lSFNb3jxXd2dUHaoTU+yqCKxatBc7c7ya4YtFGIO49OfCKxW5gsfBbDrxisQeYv70kxVZDYL8I9IzaS3jFoqHQ5LRRfHKKFamRwOS0seOTUx13Y5LJqb69pJ7AGdjfHZ8M6bPO9QXi/oNkMLoaOBgBtVZ/OH7mT3N9tYBv/iKZBDYW8o1t/v4myR/Q3+ovYP4Ok/Rb1wD9B/SMOux4vxV2EipqtynglQHoSccmJFcsmp78VywqZ1dR2FSoKLw2XhRiRbpWoChs5nhRqONuRlIUNvGPFd3ZNQFqhNS7OcEVi3YCZ+4TWrh/xeI6gbgTW2TP5CBqt0GvWJha2+YvF0n+kFcsEoH5y92CY3LaAtgvAj2jkPnLrslpC6HJacv45BQrUkuByWkrxyenOu5WJJNTfXvJNQJnYJMdnwzps85NBOI+hWQwag0cjIBaq1OEfWObN811awHfFCSZBLYS8o1t/lJI8gf0tyoIzF8hkn6rDdB/QM+oQo73W2EnoaJ2mwJeGYCedGxLcsWi3cl/xaJKdhWF7YSKwuviRSFWpOsEisLrHS8KddzXkxSFbf1jRXd2bYEaIfVuT3DFor3AmftiBFcsOgjEnZoDr1gUAxYLaTnwikUqMH/FSYqtDsB+EegZVZzwikUHocnpDfHJKVakGwQmpzc6PjnVcd9IMjnVt5e0ETgDe5rjkyF91rmtQNynkwxGNwEHI6DW6nTHz/xprm8S8E1pkkngjUK+sc1fGZL8Af2tSgPzdxZJv9UR6D+gZ9RZjvdbYSehonabAl4ZgJ507ERyxaLzyX/Fomp2FYWdhYrCLvGiECtSF4GisKvjRaGOuytJUdjJP1Z0Z9cJqBFS73SCKxY3Cpy5L0dwxeImgbjPzYFXLMoBi4XzcuAVi3OB+StPUmxlAPtFoGdUecIrFhlCk9Nu8ckpVqRuApPTmx2fnOq4byaZnOrbSzoKnIG9yPHJkD7r3Ekg7otJBqPuwMEIqLW62PEzf5rr7gK+USSTwJuFfGObv4ok+QP6Wylg/iqR9Fu3AP0H9Iyq5Hi/FXYSKmq3KeCVAehJx1tJrlj0OPmvWFTLrqKwh1BR2DNeFGJF6ilQFPZyvCjUcfciKQpv9Y8V3dndCtQIqXdvgisWnQTO3FcjuGLRWSDu6jnwikU1YLFQIwdesagOzN+lJMVWH2C/CPSMupTwikUfoclp3/jkFCtSX4HJaT/HJ6c67n4kk1N9e8ktAmdgazs+GdJnnW8ViLsOyWB0G3AwAmqt6jh+5k9zfZuAb+qTTAL7CfnGegVbkvwB/a3qA/N3BUm/1R/oP6Bn1BWO91thJ6GidpsCXhmAnnQcQHLF4vaT/4pF9ewqCm8XKgrviBeFWJHuECgK73S8KNRx30lSFA7wjxXd2Q0AaoTUeyDBFYuuAmfuGxFcsUgXiLtxDrxi0QhYLFydA69YNAbm7xqSYusuYL8I9Iy6hvCKxV1Ck9O745NTrEh3C0xOBzk+OdVxDyKZnOrbS/oLnIFt7vhkSJ91HiAQdwuSwege4GAE1Fq1cPzMn+b6HgHftCaZBA4S8o31+gYk+QP6W7UG5q8tSb91L9B/QM+oto73W2EnoaJ2mwJeGYCedBxMcsViyMl/xaJGdhWFQ4SKwvviRSFWpPsEisKhjheFOu6hJEXhYP9Y0Z3dYKBGSL3vJ7hi0U3gzH17gisWNwvE3SEHXrFoDywWbsiBVyw6APN3I0mx9QCwXwR6Rt1IeMXiAaHJ6YPxySlWpAcFJqfDHJ+c6riHkUxO9e0l9wqcge3i+GRIn3UeLBB3V5LB6CHgYATUWnV1/Myf5vohAd90I5kEDhPyjfW3dZHkD+hv1Q2Yv+4k/dbDQP8BPaO6O95vhZ2EitptCnhlAHrS8RGSKxaPnvxXLDplV1H4qFBR+Fi8KMSK9JhAUTjc8aJQxz2cpCh8xD9WdGf3CFAjpN6PE1yxuEXgzH1PgisWtwrE3SsHXrHoCSwWeufAKxa9gPnrQ1JsPQHsF4GeUX0Ir1g8ITQ5fTI+OcWK9KTA5HSE45NTHfcIksmpvr3kYYEzsAMcnwzps86PCMR9O8lg9BRwMAJqrW53/Myf5vopAd8MJJkEjhDyjfUDrCT5A/pbDQTm726SfutpoP+AnlF3O95vhZ2EitptCnhlAHrScSTJFYtRJ/8Vi87ZVRSOEioKn4kXhViRnhEoCkc7XhTquEeTFIUj/WNFd3YjgRoh9R5DcMWip8CZ+8EEVyx6CcQ9JAdesRgMLBbuy4FXLIYA8zeUpNgaC+wXgZ5RQwmvWIwVmpyOi09OsSKNE5icjnd8cqrjHk8yOdW3lzwtcAb2IccnQ/qs80iBuB8mGYyeBQ5GQK3Vw46f+dNcPyvgm8dIJoHjhXxjfcsdSf6A/laPAfP3OEm/9RzyDDlQi8cd77fCTkJF7TYFvDIAPek4geSKxcST/4pFl+wqCicKFYXPx4tCrEjPCxSFLzheFOq4XyApCif4x4ru7CYANULqPYngikUfgTP3TxFcsegrEPfTOfCKxVPAYmFkDrxi8TQwf6NIiq3JwH4R6Bk1ivCKxWShyemU+OQUK9IUgcnpi45PTnXcL5JMTvXtJc8JnIEd5/hkSJ91niAQ93iSwegl4GAE1FqNd/zMn+b6JQHfTGCZRAv5xvrMH8sVHyArE4D5e56k35oK9B/QM+p5x/utsJNQUbtNAa8MQE86TiO5YjH95L9i0TW7isLpQkXhy/GiECvSywJF4QzHi0Id9wySonCaf6zozm4aUCOk3q8QXLG4TeDM/RSCKxb9BeJ+MQdesZgCLBZeyoFXLF4E5m8qSbH1KrBfBHpGTSW8YvGq0OR0ZnxyihVppsDk9DXHJ6c67tdIJqf69pKpAmdgX3F8MqTPOk8TiPtVksFoFnAwAmqtXnX8zJ/mepaAb2aRTAJfE/KNbf5mk+QP6G81C5i/OST91myg/4CeUXMc77fCTkJF7TYFvDIAPek4h+SKxdyT/4pFenYVhXOFisLX40UhVqTXBYrCeY4XhTrueSRF4Rz/WNGd3RygRki95xNcsbhd4Mz9fIIrFncIxL0gB16xmA8sFhbmwCsWC4D5e4Ok2FoA7BeBnlFvEF6xWCA0OV0Yn5xiRVooMDl9w/HJqY77DZLJqb69ZLbAGdgljk+G9FnnOQJxLyUZjBYBByOg1mqp42f+NNeLBHyzjGQS+IaQb2zzt5wkf0B/q2XA/L1L0m8tBvoP6Bn1ruP9VthJqKjdpoBXBqAnHd8kuWLx1sl/xSIju4rCt4SKwiXxohAr0hKBonCp40WhjnspSVH4pn+s6M7uTaBGSL3fJrhiMVDgzP37BFcs7hKIe1UOvGLxPrBY+CAHXrFYBczfhyTF1jvAfhHoGfUh4RWLd4Qmp8vik1OsSMsEJqfLHZ+c6riXk0xO9e0liwXOwK51fDKkzzq/KRD3OpLB6F3gYATUWq1z/Myf5vpdAd+sJ5kELhfyjW3+NpDkD+hvtR6Yv40k/dZ7QP8BPaM2Ot5vhZ2EitptCnhlAHrScUWa2/MPfZLsPYFxZJPj8y49dq4QiHszSf+1EsgLUGu12XHfNPXaWCngm6a4Yzx2IiHJ8My13r8j3r9m/s/m/k+9ve/Fssr7l8d7vTOSeZIh2B+0Fexv5f+t/n3Qxgfe6w/9Nn403hvs/yfHs9p7/xq/rZ+MtoL9Ycez2jiej7zXH/tt/Gy8N9gf20YLv42P/Db0CZe13ut1fhu7jPcG+2PbaOm3sdZvQ8f6iff6U7+NX4z3Bvuz6yRVM1xb0UTjONf75xY2GOcYWvs/kyPHn7CK+PmKYGOLCpwAi2q98hpxBFuisS/4zMDT+qRY/izea/q+Dub4VKxn6hivg88yjyXh//hYzHxFjH25YnJleib4ndaiqfH73Fn8TfDe3Fm8z4w9j0Ds5ufUMf4ffNYpxjHkduBYErM4liTssRwbdwN+IpHjT1YHxxEcU17jd/nAOdFtJGdxHPmM44jlPMnfDzyOirqN/FkcxynGz+Dz8xvHUQB7HJWSY45Db/+N3wLGsRTEHssxj6QYnxUcV0Hj/8Hv8xjHkYI9jmPcFIyJP/i/eXz/r8eal+hYk/+Pj1XAVxm6zULYNismR47Pqd7+GzeFjPgKY4+lkmYybyRT16D92Nya8w+J/r2oEa+pp950f1bEf22+L3id2/i9Od4Hv69txKTbLIY9/mN6mselt/+mZ/D5etwI+sRu6f1bpnfpl97/6vSBCUYbRWPiMufAeYzXZj8hoY8xJf//j8nUJ9V/nWb8TmL8LZ7FcZjjb/D5wfuSjdepxr4SMcdrzhXNvw3G1uD9ef3YcmNjq2R+VrD9Nw/lNmI3PNRsQOce3bvEeChoN1cW7Zrz3jwx7zNzYs6vEmIPsE4EkgSFPGkhcXyXJPznJAT6ZM0Wx09SVU74z0kGdNxbSU5ubgSe3ARqrZD5iz2pttE/8bTe/7nBOCH2mff6c/9E1K+RzE4i2P9PTtB94b1/k9/WbqOtYH/YCbovjOPZ7L3+0m9jj/HeYH+uyImdq97QnDSOyPgZfZyfOX4RSfezm7E3WGVUrlg5qvsxVNzmIPqVMTsKBuP/dXIpwdjHfGIznxFHJCbeFP/3wYS3V+/+3TMGNh3Qo0f3jO7pXZv27p9upjF2/mE2FbvfPDeXFPP3ZkqD3+XoeYs+vq9IbtwLY992DN/m/o00J/RR1vNK4Lxlm+M3guj2Wgu0+63jc3Mdc1uBuL8T4iURHD9QH/Wd4Hy6TeQ/89W2/s92kcz561aP06/9+etvRo6C/bFz4Pb+32415sDfeK+3+W3sNd4b7P8nx7Pde/+3flv7jLaC/WHHs904nu+819/7bew33hvsj23jOr+N74yL5ju81z/4bRww3hvsj23jer+NHcZF853e6x/9Ng4a7w326w3NTu2E/+Qd3e4PjvfBDRL+k1d0uztJboKdAnyS7AfgTbA/kuRvKjB/O4H5+4nkPNVPwPke0DMKmb/suskJmMvjzhX8bNRh8SfxLNvUIv2chm93l+NP4um4dwkV9KZBkMc8y9HBcTfJ4Djb0cFxD8ng+AtwcAR6Ru0hHBx/ERocf40PjliRfhUYHHc7PjjquHeTnO0envqfgRxdMe9x/AqfVNz7HD9Don25RyDu/SSTmN3AQXgfcBJzgGQS8xswf0DPqAMk/lviaBHyJ8sXEztahBwi4XcvkF+gZ9QhwiJkr1ARsi9ehGBF2idQhOx3vAjRce8nKUJGepPx3wQmpYcdv3ViXKrMZPwIyWB0ADgYAbVWRxwv4jTXBwR8k9CSYxK4X8g3tvlLJMkf0N/K9Ixt/nK15Oi3DgL9B/SMykXiv7WOFsF5SfK3ztEiOB8Jv78D+QV6RiHzl11F8O9CRfAf8SIYK9IfAkXwn44XwTruP0mK4AleMXhQYFKfv6XbcU9JlSlmCpAMRoeAgxFQa1VA2DfWVyy8vB0S8E0hkkngn0K+sc1fYZL8Af2tCgHzV4Sk3/oL6D+gZ1QREv9tc7QITiPJ33ZHi+DiJPz+DeQX6BlVnLAI/luoCD4cL4KxIh0WKIKPOF4E67iPkBTB07xi8C+BSf2pjhfBM1NliplSJIPRUeBgBNRalXK8CNZcHxXwzRksVzKFfGObvzNJ8gf0tzoDmL/SJP2W/qpOVP6AnlGlSfy3z9Ei+ByWO2EcLYLLkvCbAOQX6BlVlrAIBubyuCI40fjK5XgRbNmmFkknFN1uruJuF8E67lzF4RqJHOsc/T3hxfGT+vMcL4IXpsoUM+VJBqPcwMEIqLUq73gRrLnOLcDLhSSTwFxCvrHNXwWS/AH9rS4E5u8ikn4rD9B/QM+oi0j8l6e5m0WwIslfEjB/yCK4Igm/SUB+gZ5RFQmL4CShIjhvvAjGipRXoAjO53gRrOPOR1IEv+kVg3kEJvVVHC+Cl6XKFDNVSQajZOBgBNRaVXW8CNZcJwv4pgbJJDCfkG9s83cpSf6A/lY1gPmrSdJvnQL0H9AzqiaJ/0o4WgTXJslfSUeL4Dok/OYH8gv0jKpDWATnFyqCC8SLYKxIBQSK4IKOF8E67oIkRfAKrxg8RWBSX9/xInh1qkwx04BkMEoBDkZArVUDx4tgzXWKgG+uIpkEFhTyjW3+GpLkD+hvdRUwf41I+q1CQP8BPaMakfjvfEeL4CYk+bvA0SK4KQm/hYH8Aj2jmhIWwYWFiuAi8SIYK1IRgSK4qONFsI67KEkRvNYrBgsJTOqbO14Eb0yVKWZakAxGxYCDEVBr1cLxIlhzXUzAN61JJoFFhXxjm782JPkD+lu1BuavLUm/lQr0H9Azqi2J/2o6WgS3J8lfLUeL4A4k/KYB+QV6RnUgLILThIrg4vEiGCtScYEiuITjRbCOuwRJEbzJKwZTBSb1NzleBH+dKlPMdCQZjEoCByOg1qqj40Ww5rqkgG+6sNxOKeQb2/x1Jckf0N+qCzB/6ST91qlA/wE9o9JJ/NfE0SK4O0n+mjpaBN9Cwm8pIL9Az6hbCIvgUkJF8GnxIhgr0mkCRfDpjhfBOu7TSYrgb71i8FSBSX1Px4vgH1NlipleJIPRGcDBCKi16uV4Eay5PkPAN31JJoGnC/nGNn/9SPIH9LfqC8zfbST91plA/wE9o24j8d9NjhbBd7CcxHK0CL6ThN/SQH6BnlF3EhbBpYWK4DLxIhgrUhmBIvgsx4tgHfdZJEXwL14xeKbApP5ux4vgfakyxcwgksHobOBgBNRaDXK8CNZcny3gm8Ekk8CzhHxjm78hJPkD+lsNBubvPpJ+6xyg/4CeUfeR+K+vo0XwgyT56+doETyMhN+yQH6BnlHDCIvgskJFcLl4EYwVqZxAEXyu40WwjvtckiL4d68YPEdgUv+I40Xw4VSZYuZRksHoPOBgBNRaPep4Eay5Pk/AN4+TTALPFfKNbf6eIMkf0N/qcWD+niTpt8oD/Qf0jHqSxH/3O1oEjyTJ3wOOFsGjSPg9H8gv0DNqFGERfL5QEXxBvAjGinSBQBF8oeNFsI77QpIiOCEtEikvMKkf43gRnDdNppgZSzIYVQAORkCt1VjHi2DNdQUB3zxLMgm8UMg3tvl7jiR/QH+rZ4H5m0DSb10E9B/QM2oCif+ecbQInkSSv9GOFsGTSfi9GMgv0DNqMmERfLFQEXxJvAjGinSJQBEcdbwI1nFHSYrg/F4xeJHApP4lx4vgImkyxcxUksFIAQcjoNZqquNFsOZaCfjmZZJJYFTIN7b5m0GSP6C/1cvA/L1C0m9VBPoP6Bn1Con/pjlaBM8iyd90R4vg2ST8VgLyC/SMmk1YBFcSKoIrx4tgrEiVBYrgKo4XwTruKiRFcJpXDFYUmNS/7ngRfFqaTDEzj2QwqgocjIBaq3mOF8Ga66oCvllIMgmsIuQb2/y9QZI/oL/VQmD+FpH0W9WA/gN6Ri0i8d8iR4vgJST5W+xoEbyUhN/qQH6BnlFLCYvg6kJFcI14EYwVqYZAEXyp40WwjvtSkiK4tFcMVhOY1C9zvAgulyZTzCwnGYxqAgcjoNZqueNFsOa6poBvVpBMAi8V8o1t/laS5A/ob7UCmL/3SfqtWkD/AT2j3ifx32pHi+DVJPlb42gRvIaE38uA/AI9o9YQFsGXCRXBl8eLYKxIlwsUwbUdL4J13LVJiuDzvWKwlsCkfq3jRfAlaTLFzDqSwagOcDACaq3WOV4EH+t7BHyznmQSWFvIN7b520CSP6C/1Xpg/jaS9Ft1gf4DekZtJPHfFkeL4E0k+dvqaBG8mYTfekB+gZ5RmwmL4HpCRXD9eBGMFam+QBHcwPEiWMfdgKQIruQVg3UFJvVbHC+Ca6TJFDNbSQajK4CDEVBrtdXxIlhzfYWAb7aRTAIbCPnGNn/bWSbRQFa2AfP3LUm/dSXQf0DPqG9J/Lfb0SL4B5L87XG0CN5Jwu9VQH6BnlE7CYvgq4SK4IbxIhgrUkOBIriR40WwjrsRSRF8mVcMXikwqf/Z8SK4fppMMbOLZDBqDByMgFqrXY4XwZrrxgK+2U0yCWwk5Bvb/O0hyR/Q32o3MH+/kfRbVwP9B/SM+o3Efwkt3CyCD5DkLxGYP2QRfJCE32uA/AI9ow4SFsHXCBXBTeJFMFakJgJFcFPHi2Add1OSIvgqrxi8WmBS/6fjRXCTNJli5hDJYHQtcDACaq0OOV4Ea66vFfDNYZJJYFMh39jm7whJ/oD+VoeB+TtK0m81A/oP6Bl1lMR/xRwtgnO14shfqqNFcO5WHPw2B/IL9IxC5i+7iuDmQkVwi3gRjBWphUAR3NLxIljH3ZKkCG7uFYPNBCb1eVu5HXfbNJliJh/JYNQKOBgBtVb5hH1jmzfNdSsB3+QnmQS2FPKNbf4KkOQP6G+VH5i/giT9Vmug/4CeUQVJ/FfO0SK4CEn+znW0CC5Kwm8bIL9Az6iihEVwG6EiuG28CMaK1FagCG7neBGs425HUgS394rB1gKT+jTHi+BOaTLFTHGSweg64GAE1FoVd7wI1lxfJ+CbU0kmge2EfGObv1Ik+QP6W50KzN9pJP3W9UD/AT2jTiPxXzVHi+DSJPmr7mgRXIaE3/ZAfoGeUWUIi+D2QkVwh3gRjBWpg0ARfIPjRbCO+waSIjjdKwavF5jUn+N4EXxrmkwxU5ZkMLoROBgBtVZlHS+CNdc3CvjmPJJJ4A1CvrHNX3mS/AH9rc4D5u98kn7rJqD/gJ5R55P4r5GjRfBFJPlr7GgRfDEJvx2B/AI9oy4mLII7ChXBneJFMFakTgJFcGfHi2Add2eSIri3VwzeJDCpV44XwQPSZIqZiiSDURfgYATUWlV0vAjWXHcR8E0VkklgZyHf2OavKkn+gP5WVYD5q0bSb3UF+g/oGVWNxH/tHS2Ca5Lkr4OjRXAtEn7TgfwCPaNqERbB6UJFcEa8CMaKlCFQBHdzvAjWcXcjKYIHesVgV4FJfW3Hi+DBaTLFTB2Swehm4GAE1FrVcbwI1lzfLOCb+iSTwG5CvrFeuookf0B/q/rA/F1B0m91B/oP6Bl1BYn/ejpaBDciyV8vR4vgxiT83gLkF+gZ1ZiwCL5FqAi+NV4EY0W6VaAI7uF4Eazj7kFSBN/vFYPdBSb1TRwvgh9JkylmmpIMRj2BgxFQa9XU8SJYc91TwDfNSSaBPYR8Y5u/FiT5A/pbNQfmryVJv9UL6D+gZ1RLEv8NdrQIbkuSvyGOFsHtSPjtDeQX6BnVjrAI7i1UBPeJF8FYkfoIFMF9HS+Cddx9SYrgx71isJfApL6940XwyDSZYqYDyWDUDzgYAbVWHRwvgjXX/QR8cxPJJLCvkG+snzVjuZ0SyMpNwPx1Ium3bgP6D+gZ1YnEf085WgSnk+TvaUeL4AwSfvsD+QV6RmUQFsH9hYrgAfEiGCvSAIEi+HbHi2Ad9+0kRfAYrxi8TWBS393xInhCmkwxcwvJYHQHcDACaq1ucbwI1lzfIeCbniSTwNuFfGN9hZAkf0B/q57A/PUm6bfuBPoP6BnVm8R/Uxwtgm8jyd+LjhbB/Un4HQjkF+gZ1Z+wCB4oVATfFS+CsSLdJVAE3+14EazjvpukCJ7kFYN3Ckzq73C8CJ6WJlPM3EkyGA0CDkZArdWdjhfBmutBAr65m2QSeLeQb6z9TJI/oL/V3cD83UPSb90D9B/QM+oeEv/Nd7QIvo8kfwscLYKHkvB7L5BfoGfUUMIi+F6hInhwvAjGijRYoAge4ngRrOMeQlIEv+IVg/cITOofdLwInpMmU8wMIxmM7gMORkCt1TDHi2DN9X0CvnmE5Zk4Id/Y5u9RkvwB/a0eAebvMZJ+ayjQf0DPqMdI/Pe+o0XwkyT5W+VoETyChN/7gfwCPaNGEBbB9wsVwQ/Ei2CsSA8IFMEPOl4E67gfJCmC53vF4FCBSf1Ix4vgN9NkiplRJIPRMOBgBNRajXK8CNZcDxPwzRiSSeCDQr6xzd9YkvwB/a3GAPM3jqTfegjoP6Bn1DjHx7u3vfHuIYF+a4Ljca9Ik+mvJ5Lw8jCQF6DWaqLjvmnttfGwgG9a447xWOGaZHimjffviPevrf+znf9Tb494sTzq/cvjvf49klnUBvuDtoL97f2/1b8P2njMez3cb+MP473B/n9yPI9773/Cb+tPo61gf9jxPG4cz5Pe6xF+G4eM9wb7Y9u4zm/jSb8NXeA/5b1+2m/jL+O9wf7YNq7323jKb0PHOtJ7Pcpv42/jvcH+7Dop0hbXVjTROM5n/Fp2tFHTtvZ/JkeOP0ES8fMVwcYWFTjhEtV65TXiCLZEY1/wmYGn9UmY/Fm81/R9HczxqVjP1DFeB59lHkvC//GxmPmKGPtyxeTK9EzwO61FU+P3ubP4m+C9ubN4nxl7HoHYzc+pY/w/+KxTjGPI7cCxJGZxLEnYYzk27gb8RCLHnxwNjiM4przG7/KBc6LbSM7iOPIZxxHLeZK/H3gcFXUb+bM4jlOMn8Hn5zeOowD2OColxxyH3v4bvwWMYymIPZZjHkkxPis4roLG/4Pf5zGOIwV7HMe4KRgTf/B/8/j+X481L9GxJv8fH6uArzJ0m4WwbVZMjhyfU739N24KGfEVxh5LJc1k3kimrkH7sbk15x8S/XtRI15TT73p/qyI/9p8X/A6t/F7c7wPfl/biEm3WQx7/Mf0NI9Lb/9Nz+Dz9bgR9Ind0vu3TO/SL73/1ekDE4w2isbEZc6B8xivzX5CQp8047OKGp+lN61Pqv86zfidxPhbPIvjMMff4POD9yUbr1ONfSVijtecK5p/G4ytwfvz+rHlxsZWyfysYPtvHsptxG54qNmAzj26d4nxUNBurizaNee9eWLeZ+bEnF8lxB5gnQgkCQp50kLi+Gon/OckBPpkzSTHT1I1SPjPSQZ03JNJTm6OAZ7cBGqtkPmLPak2xj/x9Iz/c7RxQmys93qcfyLqcCSzkwj2/5MTdOO99z/rt3XEaCvYH3aCbrxxPM95ryf4bRw13hvszxU5sXPVG5qTxhEZP6OPc2xx9/vZ57A39GRUrlg5qvsxVNzmIDrRmJUEg/H/OrmUYOxjPrGZz4gjEhNviv/7YMLbq3f/7hkDmw7o0aN7Rvf0rk1790830xg7/zCbit1vnptLivl7M6XB73L0vEUf30ShG8XCcmo75j7/72++i8a0pbLrwsjzQneLvhC/WxQr0gsCd4tOcvxuUR33JJK7RXWHJXGs2TURbG4x0cg4fotmcbj/tm0Vu0MyB8hB0ezsJvu+mGL4I5h8JEZOHPnNMyC686yXRcwJxutE/z25/st7EkLayerqUEqEZ0J3XGfusiESfKEmF88URv9fm6Ju5PgNfYkaGIeaAhw0XiwO63Qygny+aOTTcoZ3wqystaGfRbsn5OElx2/tbu37FN3uVEdvTY4d0JD8HL0cl79pJLd2A/2tgJ5RUvlLBHMyGdjnvgQ8M6zbkBhzX3L89lKJuPUtXp+lCfSxxWU8jj7OaSTHOZ3kOF8mOc4ZJMf5CslxvkpynDNJjvM1kuOcRXKcs0mOcw7Jcc4lOc7XSY5zHslxzgceZx7/AINbKfWcUc/H9FxHzyP0GK3HPz226H5b94m6v9Esa060B7W+Onf6uHKbARsb6HhVWE6jdtuxOTgqp1LHiL4TQiSJWwQKmQUkYC4kOc43SI5zEclxLiY5zjdJjvMtkuNcQnKcS0mO822S43yH5DiXkRzncpLjfJfkON8jOc4V4EImwShk9JxRz8f0XEfPI/QYrcc/Pbboflv3ibq/0SxrTrQHtb46dyuKZx1v1G4LvVXY+gSl+xcDT7il2TbmlcCLWcj85fZ9GLuhjjUSwmLUbqMogFcK9WtwIN8vjjWU4BkVMbHeL+7+Ma5iOKMicWn4A5IZwofAXp4VpA8JQFrN0jOvwR1oRVZDrSEw1EcshvoYd6CVWA31MYGh1rIYah3uQCuzGmodgaE+YTHUp7gDrcJqqE8JDLWexVAbcAdaldVQGwgMtZHFUJ/hDrQaq6E+IzDU5yyG+gJ3oNVZDfUFgaE2sRhqM+5Aa7AaajOBob5kMdRXuAPtxGqorwgMtYXFUFtxB9qZ1VBbCQz1NYuhvsEdaBdWQ31DYKhtLIbajjvQrqyG2k5gqG9ZDPUd7kDTWQ31HYGhvmcx1A7cgWawGmoHgaF+YDHUTvB9YAmEhtpJYKgfc+qTdT+R3Af2M/g+MEaQfiYAaRdLz/wL+D4wRkP9QmCoX1kMtRt8HxijoXYTGGoPi6F+A98Hxmio3wgMtZfFUPvA94ExGmofgaH2sxjqAPg+MEZDHSAw1EEWQ/0Ovg+M0VC/ExjqDxZD/Qm+D4zRUH8SGOoQi6H+At8HxmiovwgM9TeLoQ6D7wNjNNRhAkMdYTHUUfB9YIyGOkpgKL1IM/oYRQyVgDvQLqyGSijh/jEmshgqF+5Au7IaKheBoXKzGCoP7kDTWQ2Vh8BQSSyGyos70AxWQ+UlMFQ+9DFK3LZzrYBBZ5Ks/tUGGHMyTmw1U3jVvajdJuabU0rIxm1da3htdBBod5bjeuuYbxSIe3Y2rXIXtdsUUB+FjFnroZeuDfrFG7x/R3yt9M+b/J96y++xVcD7p7+INjEhM0fB/qCtYH9n/2/174M2CnqvU/w2chltBPv/yfEU8t5f2G8rt9FWsD/seAoZx1PEe13UbyOP0UawP7aNjn4bRfw29OSnmPc61W8jyWgj2B/bRie/jWJ+GzrWNO91cb+NvEYbwX69odlZmvCfvKPbfd3xFV/fTfhPXtHtziOZs0xphmvL1Np61R+S/E0F5m8eMH8Lsil/tsdZAjjPBXpGIfOnc5ZFTQyfVwFzGTWPt2SJzNe5/Z+JWXhCYNl7FYn5nNg8pmSxD/rhEiKVLIFv99QSOCil4j61BFwj0c59lqOD45skg+NsRwfHt0gGx1LAwRHoGfUW4eBYSmhwPC0+OGJFOk1gcDzd8cFRx3260OCIPtbhqf8ZyNEV8xklcmbcbzt+hkT78gyBuN8hmcScDhyE3wZOYpaRTGLOBOYP6Bm1jMR/SxwtQlaQ5G+po0XIShJ+SwP5BXpGrSQsQkoLFSFl4kUIVqQyAkXIWY4XITrus0iKkJHeZPxMgUnpB47fOjEuVWYy/iHJYHQ2cDACaq0+dLyI01yfLeCbj0gmgWcJ+cZ6PTWS/AH9rT4C5m8tSb91DtB/QM+otST+W+toEbyeJH/rHC2CN5DwWxbIL9AzagNhEVxWqAguFy+CsSKVEyiCz3W8CNZxn0tSBE/wisFzBCb1nzteBE9JlSlmviAZjM4DDkZArdUXjhfBmuvzBHzzJckk8Fwh31ivDkaSP6C/1ZfA/G0h6bfKA/0H9IzaQuK/bY4WwdtI8rfd0SJ4Owm/5wP5BXpGbScsgs8XKoIviBfBWJEuECiCL3S8CNZxX0hSBE/zisHyApP67x0vgmemyhQzO0gGowrAwQiotdrheBGsua4g4JsfSSaBFwr5xnptKpL8Af2tfgTm72eSfusioP+AnlE/k/hvn6NF8G6S/O13tAjeQ8LvxUB+gZ5RewiL4IuFiuBL4kUwVqRLBIrgqONFsI47SlIEz/GKwYsEJvX7HC+CF6bKFDP7SQYjBRyMgFqr/Y4XwZprJeCb30kmgVEh39jm7w+WSTSQld+B+fuTpN+qCPQf0DPqTxL/5WnuZhF8mCR/ScD8IYvgIyT8VgLyC/SMOkJYBFcSKoIrx4tgrEiVBYrgKo4XwTruKiRF8JteMVhRYFKf0NrtuJelyhQzia05BqOqwMEIqLVKFPaNbd4011UFfJMnm3wTtduO63ujdttxvrHNXxJJ/oD+VnmA+ctL0m9VA/oP6BmVl8R/JRwtgvOT5K+ko0VwARJ+qwP5BXpGIfOXXUVwdaEiuEa8CMaKVEOgCL7U8SJYx30pSRG8wisGqwlM6gs5XgSvTpUpZgqTDEY1gYMRUGtV2PEiWHNdU8A3xUgmgZcK+cY2f6kk+QP6WxUD5i+NpN+qBfQf0DMqjcR/5ztaBJ9Kkr8LHC2CS5HwexmQX6BnVCnCIvgyoSL48ngRjBXpcoEiuLbjRbCOuzZJEbzWKwZrSSxR43gRvDFVppg5k2QwqgMcjIBaqzMdL4KP9T0CvjmLZBJYW8g31t92TpI/oL/VWcD8nUPSb9UF+g/oGXUOif9qOloEn0eSv1qOFsHlSfitB+QX6BlVnrAIridUBNePF8FYkeoLFMENHC+CddwNSIrgTV4xWFdgUn+h40Xw16kyxUwFksHoCuBgBNRaVXC8CNZcXyHgm0tIJoENhHxj/aw2Sf6A/laXAPOnSPqtK4H+A3pGKRL/NXG0CK5Ckr+mjhbBVUn4vQrIL9AzqiphEXyVUBHcMF4EY0VqKFAEN3K8CNZxNyIpgr/1isErBSb1NRwvgn9MlSlmLiUZjBoDByOg1upSx4tgzXVjAd9cRjIJbCTkG9v8Xc5yOzmQlcuA+atN0m9dDfQf0DOqNon/bnK0CK5Pkr+OjhbBDUj4vQbIL9AzqgFhEXyNUBHcJF4EY0VqIlAEN3W8CNZxNyUpgn/xisGrBSb1VzleBO9LlSlmGpIMRtcCByOg1qqh40Ww5vpaAd9czXIlRMg31pMrkvwB/a2uBuavCUm/1QzoP6BnVBMS//V1tAhuTpK/fo4WwS1I+G0O5BfoGdWCsAhuLlQEt4gXwViRWggUwS0dL4J13C1JiuDfvWKwmcCkvrXjRfDhVJlipg3JYNQKOBgBtVZtHC+CNdetBHxzHckksKWQb2zzdz1J/oD+VtcB89eepN9qDfQf0DOqPYn/7ne0CL6JJH8POFoEdyThtw2QX6BnVEfCIriNUBHcNl4EY0VqK1AEt3O8CNZxtyMpghPSIpHWApP6Lo4XwXnTZIqZriSD0XXAwQioterqeBGsub5OwDfdSCaB7YR8Y5u/m0nyB/S36gbMX3eSfut6oP+AnlHdSfz3jKNFcE+S/I12tAjuRcJveyC/QM+oXoRFcHuhIrhDvAjGitRBoAi+wfEiWMd9A0kRnN8rBq8XmNT3dbwILpImU8z0IxmMbgQORkCtVT/Hi2DN9Y0CvhlAMgm8Qcg3tvm7neV2SiArA4D5u4Ok37oJ6D+gZ9QdJP6b5mgRfDdJ/qY7WgQPIuG3I5BfoGfUIMIiuKNQEdwpXgRjReokUAR3drwI1nF3JimC07xi8CaBSf1gx4vg09JkipkhJINRF+BgBNRaDXG8CNZcdxHwzf0kk8DOQr6xzd8DJPkD+lvdD8zfgyT9Vleg/4CeUQ+S+G+Ro0XwIyT5W+xoEfwoCb/pQH6BnlGPEhbB6UJFcEa8CMaKlCFQBHdzvAjWcXcjKYJLe8VgV4FJ/eOOF8Hl0mSKmSdIBqObgYMRUGv1hONFsOb6ZgHfPEUyCewm5Bvb/D1Nkj+gv9VTwPyNJOm3ugP9B/SMGkniv9WOFsFjSPK3xtEieCwJv7cA+QV6Ro0lLIJvESqCb40XwViRbhUogns4XgTruHuQFMHne8Vgd4FJ/bOOF8GXpMkUM8+RDEY9gYMRUGv1nONFsOa6p4BvnieZBPYQ8o1t/l4gyR/Q3+p5YP4mkfRbvYD+A3pGTSLx3xZHi+CXSPK31dEieCoJv72B/AI9o6YSFsG9hYrgPvEiGCtSH4EiuK/jRbCOuy9JEVzJKwZ7CUzqX3a8CK6RJlPMzCAZjPoBByOg1mqG40Ww5rqfgG9msiyxIuQb2/y9RpI/oL/VTGD+ZpH0W7cB/Qf0jJpF4r/djhbBr5Pkb4+jRfA8En77A/kFekbNIyyC+wsVwQPiRTBWpAECRfDtjhfBOu7bSYrgy7xi8DaBSf1Cx4vg+mkyxcwbJIPRHcDBCKi1esPxIlhzfYeAb94kmQTeLuQb2/y9RZI/oL/Vm8D8LSHpt+4E+g/oGbWExH8JLdwsgpeR5C8RmD9kEbychN+BQH6BnlHLCYvggUJF8F3xIhgr0l0CRfDdjhfBOu67SYrgq7xi8E6BSf0Kx4vgJmkyxcxKksFoEHAwAmqtVjpeBGuuBwn45gOSSeDdQr6xzd+HJPkD+lt9AMzfapJ+6x6g/4CeUatJ/FfM0SJ4LUn+Uh0tgteR8HsvkF+gZ9Q6wiL4XqEieHC8CMaKNFigCB7ieBGs4x5CUgQ394rBewQm9esdL4LbpskUMxtIBqP7gIMRUGu1wfEiWHN9n4BvPmf5dmMh39jm7wuS/AH9rT4H5m8TSb81FOg/oGfUJhL/lXO0CN5Ckr9zHS2Ct5Lwez+QX6Bn1FbCIvh+oSL4gXgRjBXpAYEi+EHHi2Ad94MkRXB7rxgcKjCp3+Z4EdwpTaaY2U4yGA0DDkZArdV2x4tgzfUwAd98TzIJfFDIN7b520GSP6C/1ffA/P1A0m89BPQf0DPqBxL/VXO0CP6ZJH/VHS2Cd5Hw+zCQX6Bn1C7CIvhhoSL4kXgRjBXpEYEi+FHHi2Ad96MkRXC6Vww+JDCp3+14EXxrmkwxs4dkMHoMOBgBtVZ7HC+CNdePCfhmH8kk8FEh39jmbz/LF+sAWdkHzN8Bkn5rONB/QM+oAyT+a+RoEfwnSf4aO1oEHyLh93Egv0DPqEOERfDjQkXwE/EiGCvSEwJF8JOOF8E67idJiuDeXjE4XGBSf9jxInhAmkwxc4RkMBoBHIyAWqsjjhfBmusRAr5JaMMxCXxSyDe2+UskyR/Q38r0jG3+crXh6LeeAvoP6BmVi8R/7R0tgvOS5K+Do0VwPhJ+nwbyC/SMQuYvu4rgp4WK4JHxIhgr0kiBIniU40WwjnsUSRE80CsGnxKY1Odv43bcg9NkipkCJIPRM8DBCKi1KiDsG9u8aa6fEfBNIZJJ4Cgh39jmrzBJ/oD+VoWA+StC0m+NBvoP6BlVhMR/PR0tgtNI8tfL0SK4OAm/Y4D8Aj2jihMWwWOEiuCx8SIYK9JYgSJ4nONFsI57HEkRfL9XDI4WmNSf6ngR/EiaTDFTimQwGg8cjIBaq1KOF8Ga6/ECvjmDZBI4Tsg3tvk7kyR/QH+rM4D5K03Sbz0L9B/QM6o0if8GO1oEn0OSvyGOFsFlSfh9Dsgv0DOqLGER/JxQETwhXgRjRZogUARPdLwI1nFPJCmCH/eKwWcFJvXnOV4Ej0yTKWbKkwxGzwMHI6DWqrzjRbDm+nkB31xIMgmcKOQb2/xVIMkf0N/qQmD+LiLpt14A+g/oGXURif+ecrQIViT5e9rRIrgiCb+TgPwCPaMqEhbBk4SK4MnxIhgr0mSBIniK40WwjnsKSRE8xisGXxCY1FdxvAiekCZTzFQlGYxeBA5GQK1VVceLYM31iwK+qUEyCZwi5Bvb/F1Kkj+gv1UNYP5qkvRbLwH9B/SMqsnCr6NFcG2S/L3oaBFch4TfqUB+gZ5RdQiL4KlCRfC0eBGMFWmaQBE83fEiWMc9naQInuQVgy8JTOrrO14ET0uTKWYakAxGLwMHI6DWqoHjRbDm+mUB31xFMgmcLuQb2/w1JMkf0N/qKmD+GpH0WzOA/gN6RjUi8d98R4vgJiT5W+BoEdyUhN9XgPwCPaOaEhbBrwgVwa/Gi2CsSK8KFMEzHS+CddwzSYrgV7xicIbApL6540XwnDSZYqYFyWD0GnAwAmqtWjheBGuuXxPwTWuSSeBMId/Y5q8NSf6A/latgflrS9JvzQL6D+gZ1ZbEf+87WgS3J8nfKkeL4A4k/M4G8gv0jOpAWATPFiqC58SLYKxIcwSK4LmOF8E67rkkRfB8rxicJTCpv8nxIvjNNJlipiPJYPQ6cDACaq06Ol4Ea65fF/BNF5JJ4Fwh39jmrytJ/oD+Vl2A+Usn6bfmAf0H9IxKd3y8e9sb7+YJ9FvdHY97RZpMf30LCS/zgbwAtVa3OO6bDl4b8wV80wF3jMcK1yTDMzd4/454/270f97k/9TbAi+Whd6/PN7rfAmZRW2wP2gr2N/Z/1v9+6CNN7zXi/w2ko02gv3/5HgWe+9/02/rFKOtYH/Y8Sw2juct7/USv438RhvB/tg2OvptvOW3oQv8pd7rt/02ChhtBPtj2+jkt7HUb0PH+o73epnfRkGjjWB/dp0UuRHXVjTROM7lfi37rlHTtvZ/JkeOP0ES8fMVwcYWFTjhEtV65TXiCLZEY1/wmYGn9UmY/Fm81/R9HczxqVjP1DFeB59lHkvC//GxmPmKGPtyxeTK9EzwO61FU+P3ubP4m+C9ubN4nxl7HoHYzc+pY/w/+KxTjGPI7cCxJGZxLEnYYzk27gb8RCLHnxwNjiM4przG7/KBc6LbSM7iOPIZxxHLeZK/H3gcFXUb+bM4jlOMn8Hn5zeOowD2OColxxyH3v4bvwWMYymIPZZjHkkxPis4roLG/4Pf5zGOIwV7HMe4KRgTf/B/8/j+X481L9GxJv8fH6uArzJ0m4WwbVZMjhyfU739N24KGfEVxh5LJc1k3kimrkH7sbk15x8S/XtRI15TT73p/qyI/9p8X/A6t/F7c7wPfl/biEm3WQx7/Mf0NI9Lb/9Nz+Dz9bgR9Ind0vu3TO/SL73/1ekDE4w2isbEZc6B8xivzX5CQp8047OKGp+lN61Pqv86zfidxPhbPIvjMMff4POD9yUbr1ONfSVijtecK5p/G4ytwfvz+rHlxsZWyfysYPtvHsptxG54qNmAzj26d4nxUNBurizaNee9eWLeZ+bEnF8lxB5gnQgkCQp50kLi+JYm/OckBPpkTU/HT1K9m/CfkwzouHuRnNx8D3hyE6i1QuYv9qTae/6Jp+X+z3eNE2IrvNcr/RNRKcaJqGD/PzlB9773/lV+W4WMtoL9YSfo3jeO5wPv9Yd+G4WNNoL9uSIndq56Q3PSOCLjZ/jFihLu97MfYG/oyahcsXJU92OouM1BdLVxwjIYjP/XyaUEYx/zic18RhyRmHhT/N8HE95evft3zxjYdECPHt0zuqd3bdq7f7qZxtj5h9lU7H7z3FxSzN+bKQ1+l6PnLfr4VgvdKBaWU9sxd82/v/kuGtOWyq4LI2uE7hb9KH63KFakjwTuFv3Y8btFddwfk9wtqjssiWPNrongOouJRsbxWzSLw/23bavYHZI5QA6KZme31vfFOsMfweQjMXLiyG+eAdGdZ70sYk4wXif678n1X96TENJOVleHUiI8E7rjOnOXDZHgC7W2RKYw+v/aFHUjx2/oS9TAONQ64KDxSQlYp5MR5PMTI5+WM7wTZmUdDP0s2j0hD30dv7W7g+9TdLv9HL01OXZAQ/Jzam1c/m4jubUb6G8F9IySyl8imJO1wD73U+CZYd2GxJj7qeO3l0rErW8bXFUcH/cdjl+pGaTPnArEfSfJlZr1QB6BWqs7HfeN5mW1gG82OH6lQcf9kUDcGwniXisQ92cEcX8iEPfnBHGvF4j7C4K4NwrEvYkg7s8F4t5MEPcmgbi/JIj7S4G4vyKIe4tA3FsI4v5aIO6tBHFvE4j7a4K4vxWI+xuCuL8XiHsbQdw/CMS9HRi3vt2mSELmIwO69tb1nq59dB2g58R6fqjnSnreoMdQPZ7ovlX3M5o57T+thT6u3H57sRsqp0F78HNsifhzI67f8Sdi+B8FDH83wQm7nwTiHkRywu5b4Ak7oNZqEMEJu10CvvmOYGD8VSDu7wni3iMQ9w6CuPcKxP0DQdz7BeLeSRD3QYG4fySI+w+BuH8iiPuQQNw/E8T9t0DcuwjiPiIQ9y8EcUcEbsT4lSDuRIG4dxPEnVsg7j0EcScJxP0bQdz5BOLeCz5hV9Q4Yadrb13v6dpH1wF6Tqznh3qupOcNegzV44nuW3U/o5nT/tNa7PXvvkfnMezRT9s8Dnb/5s4THlG1jXkf8NwKMn+5fR/GbqhjDdrLiSd695WQ8TkcyP0lsIYSvHIgJtb+Eu4f4wEpQ6HPJB/MIbd+hgltm7/fgfljBfJ3AiD/YLiUJ3Ev8Z8lOEA6hDvOiqwgHSIA6S8GkCRuTv+bBKTDuOOsxArSYQKQjjCAJPG0w1ESkCIlYcdZmRUkYA7EjjGhJAFIEo/PJJbkACkX7jirsIKUiwCk3AwgSTyPlYcEpCTccVZlBSmJAKS8DCBJPOCXjwSkZNxxVmMFKZkApFMYQJJ4YjQ/CUgFcMdZnRWkAgQgFWQASeIR5BQSkArhjrMGK0iFCEAqzACSxDPtRUhAKoo7zk6sIBUlAKkYA0gSX5KQSgJSGu44O7OClEYAUnEGkCS+daMECUglccfZhRWkkgQgncoAksTXuJQiAek03HF2ZQXpNAKQTmcASeJ7gc4gAelM3HGms4J0JgFIpRlAkviiqTIkIJ2FO84MVpDOIgDpbAaQJL657BwSkMoCj1P4QTkxk5YlAKmckJ/gzzWdiztQp78hK0xo2/ydB8wfK5DnEQBZnmFkk/jKtfNJRrYLcMdZkRWkCwhAupABJInv8KtAAtJFuOOsxArSRQQgXcwAksSXQl5CAlIU/FwTI0hRApAUA0gS3zJakQSkSuDnmhhBqkQAUmUGkCS+trYKCUhVwc81MYJUlQCkagwgSXwPcnUSkGqAn2tiBKkGAUiXMoAk8cXaNUlAqgV+rokRpFoEIF3GAJLEN7VfTgJSbfBzTYwg1SYAqQ4DSBJf/V+XBKR64OeaGEGqRwBSfQaQJNaSaEAC0hXg55oYQbqCAKQrGUCSWJzkKhKQGoKfa2IEqSEBSI0YQJJY7aYxCUhXg59rYgTpagKQrmEASWL5pCYkIDUFP9fECFJTApCuZQBJYj2uZiQgNQc/18QIUnMCkFowgCSxwFtLcOAScScLxH2f4wusD/IaPEUg7qHuL0SnN3UDsC1Ta9v83Z9N+bM9zlbAx46AnlEs+WtdUsZ/UbtNDRXut2zzptvrItDuQ4731zrmdIG4HxbiJREcP1AfhYxZ65EUyewfunr/jvha6Z8Z/k+9tfGYb+v90wvVFkvIzFGwP2gr2N/d/1v9+6CNdt7r6/w2Uo02gv3/5Hiu997f3m8rzWgr2B92PNcbx9PBe32D30Zxo41gf2wb3fw2Ovht6KLjRu/1TX4bJYw2gv2xbdzst3Gj34aOtaP3upPfRkmjjWC/3tDs3Jj4n7yj233M8T64S+J/8opudzjJ3HFKM1xbjwHnjo+T5G8qMH/Dgfl7gmTu2Bk4dwR6RiHzp3OWxbko+LwKmMuoebxdSma+zu3/TMzCE0kCMUViPic2jylZ7IN+uIRIXUri2+1aEgelVNxdS8I1Eu3cZzk6OI4kGRxnOzo4jiIZHNOBgyPQM2oU4eCYLjQ4ZsQHR6xIGQKDYzfHB0cddzehwRF9rMNT/zOQoyvmmx2/uiYV9xjHz5BoX94sEPdYkklMN+AgPAY4iRlHMonpDswf0DNqHIn/ljhahEwgyd9SR4uQiST83gLkF+gZNZGwCLlFqAi5NV6EYEW6VaAI6eF4EaLj7kFShIz0JuPdBSalkxy/dWJcqsxkfDLJYNQTOBgBtVaTHS/iNNc9BXzzEskksIeQb2zzN5Ukf0B/q5eA+ZtG0m/1AvoP6Bk1jcR/ax0tgl8hyd86R4vgV0n47Q3kF+gZ9SphEdxbqAjuEy+CsSL1ESiC+zpeBOu4+5IUwRO8YrCXwKR+luNF8JRUmWJmNslg1A84GAG1VrMdL4I11/0EfPM6ySSwr5BvbPM3j+V2NiArrwPzN5+k37oN6D+gZ9R8Ev9tc7QIXkSSv+2OFsGLSfjtD+QX6Bm1mLAI7i9UBA+IF8FYkQYIFMG3O14E67hvJymCp3nF4G0Ck/oljhfBM1NlipmlJIPRHcDBCKi1Wup4Eay5vkPAN8tIJoG3C/nGNn/LWW6nBLKyDJi/d0n6rTuB/gN6Rr1L4r99jhbB75Pkb7+jRfAqEn4HAvkFekatIiyCBwoVwXfFi2CsSHcJFMF3O14E67jvJimC53jF4J0Ck/rVjhfBC1Nlipk1JIPRIOBgBNRarXG8CNZcDxLwzVqSSeDdQr6xzd86kvwB/a3WAvP3CUm/dQ/Qf0DPqE9I/JenuZtF8EaS/CUB84csgj8j4fdeIL9Az6jPCIvge4WK4MHxIhgr0mCBIniI40WwjnsISRH8plcM3iMwqd/keBG8LFWmmNlMMhjdBxyMgFqrzY4XwZrr+wR8s4VkEjhEyDe2+dtKkj+gv9UWYP6+Jum3hgL9B/SM+prEfyUcLYK/JclfSUeL4O9I+L0fyC/QM+o7wiL4fqEi+IF4EYwV6QGBIvhBx4tgHfeDJEXwCq8YHCowqf/B8SJ4dapMMbOTZDAaBhyMgFqrnY4XwZrrYQK++ZlkEvigkG9s87eLJH9Af6ufgfn7haTfegjoP6Bn1C8k/jvf0SL4N5L8XeBoEbyXhN+HgfwCPaP2EhbBDwsVwY/Ei2CsSI8IFMGPOl4E67gfJSmC13rF4EMCk/oDjhfBG1NlipmDJIPRY8DBCKi1Ouh4Eay5fkzAN3+STAIfFfKNbf4OkeQP6G/1JzB/f5H0W8OB/gN6Rv1F4r+ajhbBR0nyV8vRIjjSloPfx4H8Aj2jkPnLriL4caEi+Il4EYwV6QmBIvhJx4tgHfeTJEXwJq8YHC4wqc/V1u24v06VKWZykwxGI4CDEVBrlVvYN7Z501yPEPBN3mzyTdRuO67vjdptx/nGNn/5SPIH9LfKC8xfMkm/9RTQf0DPqGQS/zVxtAguSJK/po4WwSkk/D4N5BfoGZVCWAQ/LVQEj4wXwViRRgoUwaMcL4J13KNIiuBvvWLwKYFJfRHHi+AfU2WKmaIkg9EzwMEIqLUq6ngRrLl+RsA3aSSTwFFCvrHNX3GS/AH9rdKA+StB0m+NBvoP6BlVgsR/NzlaBJ9Gkr+OjhbBp5PwOwbIL9Az6nTCIniMUBE8Nl4EY0UaK1AEj3O8CNZxjyMpgn/xisHRApP60o4XwftSZYqZMiSD0XjgYATUWpVxvAjWXI8X8M05JJPAcUK+sc1fWZL8Af2tzgHmrxxJv/Us0H9Az6hyJP7r62gRfD5J/vo5WgRfQMLvc0B+gZ5RFxAWwc8JFcET4kUwVqQJAkXwRMeLYB33RJIi+HevGHxWYFJ/keNF8OFUmWLmYpLB6HngYATUWl3seBGsuX5ewDeKZBI4Ucg3tvmrSJI/oL+VAuavEkm/9QLQf0DPqEok/rvf0SK4Gkn+HnC0CK5Owu8kIL9Az6jqhEXwJKEieHK8CMaKNFmgCJ7ieBGs455CUgQnpEUiLwhM6ms6XgTnTZMpZmqRDEYvAgcjoNaqluNFsOb6RQHf1CaZBE4R8o1t/uqQ5A/ob1UbmL+6JP3WS0D/AT2j6pL47xlHi+ArSPI32tEi+EoSfqcC+QV6Rl1JWARPFSqCp8WLYKxI0wSK4OmOF8E67ukkRXB+rxh8SWBS38jxIrhImkwx05hkMHoZOBgBtVaNHS+CNdcvC/imCckkcLqQb2zz15Qkf0B/qybA/F1L0m/NAPoP6Bl1LYn/pjlaBLdk6f8cLYJbkfD7CpBfoGdUK8Ii+BWhIvjVeBGMFelVgSJ4puNFsI57JkkRnOYVgzMEJvVtHS+CT0uTKWbakQxGrwEHI6DWqp3jRbDm+jUB37QnmQTOFPKNbf46kOQP6G/VHpi/G0j6rVlA/wE9o24g8d8iR4vgTiT5W+xoEdyZhN/ZQH6BnlGdCYvg2UJF8Jx4EYwVaY5AETzX8SJYxz2XpAgu7RWDswQm9emOF8Hl0mSKmQySweh14GAE1FplOF4Ea65fF/BNd5JJ4Fwh39jm7xaS/AH9rboD83crSb81D+g/oGfUrST+W+1oEdybJH9rHC2C+5DwOx/IL9Azqg9hETxfqAheEC+CsSItECiCFzpeBOu4F5IUwed7xeA8gUn9bY4XwZekyRQz/UkGozeAgxFQa9Xf8SJYc/2GgG/uIJkELhTyjW3+7iTJH9Df6g5g/gaS9FuLgP4DekYNJPHfFkeL4HtI8rfV0SL4XhJ+FwP5BXpG3UtYBC8WKoLfjBfBWJHeFCiC33K8CNZxv0VSBFfyisFFApP6+xwvgmukyRQzQ0kGoyXAwQiotRrqeBGsuV4i4JsHSSaBbwn5xjZ/w0jyB/S3ehCYv4dI+q2lQP8BPaMeIvHfbkeL4MdI8rfH0SJ4OAm/bwP5BXpGDScsgt8WKoLfiRfBWJHeESiClzleBOu4l5EUwZd5xeBSgUn9k44XwfXTZIqZESSD0XLgYATUWo1wvAjWXC8X8M1IkkngMiHf2OZvFEn+gP5WI4H5e4ak33oX6D+gZ9QzJP5LaOFmETyOJH+JwPwhi+DxJPy+B+QX6Bk1nrAIfk+oCF4RL4KxIq0QKIJXOl4E67hXkhTBV3nF4LsCk/oJjhfBTdJkipmJJIPR+8DBCKi1muh4Eay5fl/AN5NIJoErhXxjm7/JJPkD+ltNAuZvCkm/tQroP6Bn1BQS/xVztAieRpK/VEeL4Okk/H4A5BfoGTWdsAj+QKgI/jBeBGNF+lCgCF7teBGs415NUgQ394rBVQKT+lccL4LbpskUM6+SDEZrgIMRUGv1quNFsOZ6jYBvZrF8sY6Qb6y/dZQkf0B/q1nA/M0h6bc+AvoP6Bk1h8R/5RwtgueT5O9cR4vgBST8fgzkF+gZtYCwCP5YqAheGy+CsSKtFSiC1zleBOu415EUwe29YvAjgUn9IseL4E5pMsXMYpLB6BPgYATUWi12vAjWXH8i4JslJJPAdUK+sX5WlGWJFSArS4D5e5uk3/oU6D+gZ9TbJP6r5mgR/C5J/qo7WgS/R8LveiC/QM+o9wiL4PVCRfCGeBGMFWmDQBG80fEiWMe9kaQITveKwU8FJvXvO14E35omU8ysIhmMPgMORkCt1SrHi2DN9WcCvllNMgncKOQb6zsbSPIH9LdaDczfRyT91udA/wE9oz4i8V8jR4vgT0jy19jRIvhTEn6/APIL9Iz6lLAI/kKoCN4UL4KxIm0SKII3O14E67g3kxTBvb1i8HOBSf1Gx4vgAWkyxcxnJIPRl8DBCKi1+szxIlhz/aWAbzaRTAI3C/nm/2PvTeCtmt7/8XNvd2ge79FcpwiZOqtBZWxASCmZi27DvZVKSiFTUQiFhEyZijIXEkKmiJB5JmQeoygk/71q7/9d97jH78t6P/fzvF/37Ner193tc1pnPe/n/V7P8953n5Z3XkjwA/LbvAvE732SdesDIP+AnDHvk/Cvv1ITvJoEvwFKTfDHJPr9EKhfIGfMx4Qm+EMhE/xRxgRjk/SRgAlerdwE27hXk5jgiYEZ/ECgqV+j3ARPisuYmc9IitHHwGIEzLX5TLkJtrr+WIA3X5I0gauFeOOL31ck+AH5bb4E4vc1ybr1CZB/QM6Yr0n4N1qpCf6eBL8TlZrgH0j0+ylQv0DOmB8ITfCnQiZ4TcYEY5O0RsAEf6bcBNu4PyMxwVMCM/iJQFP/k3ITfGFcxsz8TFKMPgcWI2Cuzc/KTbDV9ecCvPmFxcQJ8cYXv19J8APy2/wCxG8Dybr1BZB/QM6YDST8m6TUBP9Bgt9kpSZ4E4l+vwTqF8gZs4nQBH8pZIK/yphgbJK+EjDBXys3wTbur0lM8IzADH4h0NT/pdwEz4rLmJnY0RzF6BtgMQLm2qDxQ+fX6vobAd5UKifeJP2OUmtv0u8oxRtf/HJI8APy27ic8cUvl2Td+hbIPyBnTC4J/2YqNcFVSPC7XKkJrkqi3++A+gVyxiDxKy8T/J2QCf4+Y4KxSfpewAT/oNwE27h/IDHBswMz+K1AU1/jaN1xz4nLmJmaJMXoR2AxAuba1FRugq2ufxTgTR2SJvAHId744leXBD8gv00dIH71SNattUD+ATlj6pHwb65SE1yfBL95Sk1wAxL9/gTUL5AzpgGhCf5JyAT/nDHB2CT9LGCC1yk3wTbudSQm+ObADK4VaOobKzfB8+MyZqYJSTFaDyxGwFybJspNsNX1egHeNCdpAtcJ8cYXvwQJfkB+m+ZA/FqQrFu/APkH5IxpQcK/xUpNcCsS/B5UaoK3J9Hvr0D9Ajljtic0wb8KmeANGROMTdIGARO8UbkJtnFvJDHBdwZm8BeBpr61chO8KC5jZnYiKUa/AYsRMNdmJ+Um2Or6NwHe7ErSBG4U4o0vfruR4Afkt9kViF8bknXrdyD/gJwxbUj495xSE9yOBL8VSk1wexL9/gHUL5Azpj2hCf5DyARvyphgbJI2CZjgP5WbYBv3nyQmeHFgBn8XaOo7KjfBS+MyZqYTSTHaDCxGwFybTspNsNX1ZgHe7EnSBP4pxBtf/PYiwQ/Ib7MnEL+9Sdatv4D8A3LG7K283i0L6t1fAutWV+VxL4/LrNfdSPQSa4jDEphr0005b4bYQRrieTMEN8ctxjXP4czQ4M/m4E9R+LM4/LkFnyCW7OBPrg0rq8TURtejsaLrI8J/a1+PxqgUnOeEYzRyxoiu/5v55AbvzwvHauyMFV1PN59cZz75wXnlcIwmzhjR9dQxhoVj5IdjWINfJTivGo7R1Bkjup46xvBwjCrhGDbWasF59XCMZs4Y0fXyuilShBsrme3Ms0bDrT9rNiy5dkSEU6z0DZJYiFcMG1tS4IZL0uYr34kjOrKda9FnRpy2N2GqlfFel/ddMPMzqZzp4pxHn+XOJet/PBcXr5hzrVIKVi5notdsLno7r+eU8W+i9+aU8T439lyB2N3P6eL8Pfqsqs4cchTMJbuMueRh57Kl7kb6icVK3xyN5hHNKd95rTIYEztGlTLmUdmZR6rO88LrwHm0tWNUK2MeVZ2f0edXc+ZRHTuPdlVS5mGPf9JvdWcuNbBz2cKRms5nRfOq4fw9ej3XmUdN7Dy26KZGSvzR3935/V/nmk801yr/47kK8KrYjlkLO2bbKrHSmNrjn3RTy4mvNnYu7awm82MleY3GT8XW7T8k1ve6TrxuPu1h17M64bn7vug8x3ndrffR6/s6Mdkx62HnvyWf7rzs8U/5jD7f1o1oTRxWNL5f0ZBxReN7Fk3McsaomxKX2wPnOufuOiGRn7jzWXWdz7KHzU9BeB53XpOov9uUMQ+3/kafH72vinNe4FyrnzJft1d0/21UW6P354ex5WBja+d+VnT8E4dynNgdDvWZMHjUiCEpHIrGrVTGuG7fm5vyPhcTt7/KSp1glxgEBIO8aSExv+Ozt96EQN+s2V/7TarsrTcZ0HEfQHJzsxbw5iYw1waJX+pNtVrhjaca4c+azg2x2sF5nfBGVHPnRlR0/d/coKsbvL9eOFbCGSu6nu4GXV1nPgXBeTwco4UzRnS9Uuzvi6s90Do5OCbDZ/Q8azfUv84WNISOW9y+bfukXcdQcbtFdBvnhmVUjP9fN5eynGtuU2cPphublZ04Yinx1gxfjxreE8eMH1E8sfeEUaNGFI8oGtp7zPgiF8bU/sMdKvW6e28uL+Xfu5BGr1XovsXOz+Uocq7pMPX+f6sa/uexkiljmfL6xUj9hjLrSwMnd5mnRT3HtElq0BA/bsOGOPJLxd1QaBGQWLAk5lpejeBJHo1GcekjWcZ0/+vYJvWCJAbIougudo1CXjR2+BE1H9mxv1d+9w6IXTy7lRFzlnOeHb6n0j+8JyvNOGX9dqhmjKehK7WYayZEVpioRg1LEmP/bknRNVb6QP+KGhiHaQwsGk0awhad4gjPJg6enh3e37qyIU7+PMb9Gw4HKX+0e0jIU/S4Byt9NDm1oCH103FfHH49SR7tBvLbADljpPDLBuukEXDNbQq8M2zHkKi5TZU/XioR94BgjF/q4+M+VPlvajYFA/4qEHcfkt/UNAPqEZhr00c5b6xeNgrwph+BXn4TiPtwEr00B+oFmGtzOIFe/hDgzVEEetkkEPfRJHpJAPUCzLU5mkAvmwV4059AL38JxD2ARC8tgHoB5toMINBLlsDXSQcS6CVbIO5CEr20BOoFmGtTSKCXHAHeDCHQS65A3ENJ9LItUC/AXJuhBHrJF+DNMAK9VBaIeziJXrYD6gWYazOcQC9VBXgzkkAv1QTiHkWil1ZAvQBzbUYR6KWGAG/GEOilpkDcJ5HoZXugXoC5NicR6KW2AG9OJtBLHYG4x5PoZQegXoC5NuMJ9FJPgDenEuilQCDu00j0siNQL8Bcm9MI9LKNAG/OINBLfYG4zyTRS2ugXoC5NmcS6KWhAG8mEeilkUDck0n0shNQL8Bcm8kEemkiwJspBHppKhD3VBK97AzUCzDXZiqBXpoL8OYCAr0kBOKeRqKXXYB6AebaTCPQS0sB3lxMoJdtBeKeTqKXXYF6AebaIPGz/21Jy6yS/3rRfofBPpdtnzW1z8/ZZ4Lscw72d7f291H2Hru9b2jvhVh/Z3tWW4ft2mLxygnHSz1QsUfjwbmejeckeo7o/zlJZKFsJbBgXEqwUG4vEPdlJAvlbsCFEphrcxlBY7GjAG9mEeiltUDcV5DopQ1QL8BcmysI9LKzAG9mE+hlF4G4rybRSxKoF2CuzdUEetlNgDfXEeiljUDc15PoxQD1Asy1uZ5AL0aANzcS6KWtQNw3keilLVAvwFybmwj00l6AN3MJ9NJBIO55JHppB9QLMNdmHoFeOgrwZj6BXjoJxL2ARC/tgXoB5tosINDLHgK8uZNAL3sKxH0XiV46APUCzLW5i0Avewvw5l4CvewjEPdCEr3sDtQLMNdmIYFeugjw5n4CvXQViPsBEr10BOoFmGvzAIFeugvwZgmBXvYTiPshEr10AuoFmGvzEIFeDhDgzVICvfQQiPtREr10BuoFmGvzKIFeDhLgzTICvRwsEPcTJHrZA6gXYK7NEwR6OUSAN08T6KWXQNzPkOhlT6BegLk2zxDo5VAB3jxHoJc+AnGvINHLXkC9AHNtVhDo5TAB3qwk0Es/gbhfJNHL3kC9AHNtkPjZLz5t63zxyX6HwT6XbZ81tc/P2WeC7HMO9ne39vdR9h67vW9o74VYf2d7VluH7dqyd7gbJJqH6bYi983vqnLiYfK/H3/bMt035n2AnEbilxPyMPVAzTUaryJ+YQ6Y89I74aIFuW9DLKEEv4Eplqx9G+qfYxcpQqEreNcKshVZukT74tcNiB+rILsRCLI7iyD3qyB7naVLtC9+++Pwa8sqyP0JBHkAiyB7VJDN1NIl2he/A3H4tWMV5IEEgjyIRZAHV5Dd2tIl2nsHeRx+7VkF2ZNAkIewCLJXBdkOLl2iffHrjcOvA6sgexMI8lAWQfapIPvNpUu0L359cfjtzirIvgSCPIxFkP0qyIZ26RLti9/hOPw6sgrycAJBHsEiyCMryI556RLti99ROPw6sQryKAJBHs0iyGMqyJZ86RLti9+xOPw6swryWAJB9mcR5IAKsudfukT74nccDr9BrII8jkCQx7MIcmAF2VQwXaJ98SvE4TeYVZCFBIIcxCLIwRVk18J0ifbFbwgOvyGsghxCIMihLIIsqiDbIqZLtC9+xTj8hrIKsphAkMNYBDm8guy7mC7RvviNwOFXxCrIEQSCPIFFkCMryMaO6RLti98oHH7FrIIcRSDI0SyCPLEC7Bzp4ocW5Bjw9yG3JRTkGAJBnsQiyLEVZIfCdIn2xW8c+PuQjIIcRyDIk1kEOb6CbIGYLtG++E0Afx+SUZATCAR5CosgT60geyymS7QvfqeBvw/JKMjTCAQ5kUWQp1eQTRzTJdoXvzPA34dkFOQZBII8k0WQZ1WQXSLTJdoXv7PB34dkFOTZBIKcxCLIyRVkG8p0ifbF7xzw9yEZBXkOgSDPZRHklAqyz2W6RPviNxX8fUhGQU4lEOR5LII8v4JspJku0b74XQD+PiSjIC8gEOQ0FkFeWEF26kyXaF/8LgJ/H5JRkBcRCPJiFkFOBwpS81ag6RLti98M8PchGQU5g0CQl7AI8lKgIDXvNZou0b74XQb+PiSjIC8jEORMFkFeDhSk5s1M0yXaF79Z4O9DMgpyFoEgr2AR5JVAQWreLTVdon3xuwr8fUhGQV5FIMjZLIK8GihIzduxpku0L37XgL8PySjIawgEeS2LIK8DClLzfq/pEu2L3/Xg70MyCvJ6AkHOYRHkDUBBat1QViLBdgPmwxvgBf4qwQbMRwjE/Zr+jW/tYYYCx3Jz7Yvf6yQbWN8IXG+AnDEs+N3UUIZ/Sb/DvCa8bvniZsc7QWDct5Wv1zbmUQJxvyOkl2xw/MD8GGTMNh95sZL1YWTwZ3OYK/tzdPjTHjcHmr8l+JMbnG+XVYJRdD0aK7p+Uvhv7evRGHOD83nhGK2cMaLr/2Y+twbvvy0ca3tnrOh6uvnc6sxnfnC+IBxjB2eM6HrqGCeGY8wPx7Dm5fbg/I5wjB2dMaLrqWOMCce4PRzDxnpncH5XOEZrZ4zouj3Q2tmcvRV39LjvK1+DK1Xaiit63A9Iese5fXBjvQ/sHT8kwe82IH4fAPH7iKR3vBvYOwI5Y5D4WczKuKcF76uAWCbd+d7TsOQ8J/yZXQYn8gRiiqV8TiqONcu4Bv1wiSTd0xA/7r0NcaKUivvehvAciS7u9yotjmtIiuNCpcXxM5LiuBBYHIGcMZ8RFseFQsVxUaY4YpO0SKA43qe8ONq47xMqjui5Ti/YWsjRjvn+hhUz7i+V3yGxvLxfIO6vSJqY+4BF+EtgE/M1SRPzABA/IGfM1yT8e0ypCfmeBL/HlZqQH0j0uxioXyBnzA+EJmSxkAl5MGNCsEl6UMCELFFuQmzcS0hMyKygGX9AoCn9SfmjE9cUyDTjP5MUo4eAxQiYa/OzchNndf2QAG9+IWkClwjxxhe/X0nwA/Lb/ALEbwPJuvUwkH9AzpgNJPxbpdQE/0GC3ytKTfAmEv0+AtQvkDNmE6EJfkTIBC/NmGBskpYKmOBHlZtgG/ejJCZ4TmAGHxZo6v9SboLnFsiYmdgxHMXoMWAxAubaoPFD59fq+jEB3lQqJ94k/Y5Sa2/S7yjFG1/8ckjwA/LbuJzxxS+XZN16HMg/IGdMLgn/PlFqgquQ4PepUhNclUS/y4D6BXLGIPErLxO8TMgEP5ExwdgkPSFggp9UboJt3E+SmOD5gRl8XKCpr3GM7rjvLpAxMzVJitFTwGIEzLWpqdwEW10/JcCbOiRN4JNCvPHFry4JfkB+mzpA/OqRrFtPA/kH5IypR8K/dUpNcH0S/NYrNcENSPT7DFC/QM6YBoQm+BkhE7w8Y4KxSVouYIKfVW6CbdzPkpjgRYEZfFqgqW+s3AQvKZAxM01IitFzwGIEzLVpotwEW10/J8Cb5iRN4LNCvPHFL0GCH5DfpjkQvxYk69YKIP+AnDEtSPiX21enCW5Fgl8eED+kCd6eRL/PA/UL5IzZntAEPy9kgl/ImGBskl4QMMErlZtgG/dKEhO8NDCDKwSa+tbKTfCTBTJmZieSYvQisBgBc212Um6Cra5fFODNriRN4Eoh3vjitxsJfkB+m12B+LUhWbdeAvIPyBnThoR/9ZWa4HYk+DVQaoLbk+j3ZaB+gZwx7QlN8MtCJnhVxgRjk7RKwAS/otwE27hfITHBywMz+JJAU99RuQleWSBjZjqRFKNXgcUImGvTSbkJtrp+VYA3e5I0ga8I8cYXv71I8APy2+wJxG9vknXrNSD/gJwxe5Pwr7VSE9yV5SaWUhPcjUS/rwP1C+SM6UZogl8XMsFvZEwwNklvCJjgN5WbYBv3myQmeFVgBl8TaOr3V26C3yyQMTMHkBSjt4DFCJhrc4ByE2x1/ZYAbw4iaQLfFOKNL34Hk+AH5Lc5CIhfT5J1620g/4CcMT1J+LenUhN8KAl+eyk1wX1I9PsOUL9Azpg+hCb4HSET/G7GBGOT9K6ACX5PuQm2cb9HYoLfDczg2wJNfT/lJnh1gYyZOZykGL0PLEbAXJvDlZtgq+v3BXhzFEkT+J4Qb3zxO5oEPyC/zVFA/I4hWbc+APIPyBlzDAn/eik1wceR4NdbqQk+nkS/HwL1C+SMOZ7QBH8oZII/yphgbJI+EjDBq5WbYBv3ahITvCYwgx8INPWDlJvgrwtkzMxgkmL0MbAYAXNtBis3wVbXHwvwpoikCVwtxBtf/IpJ8APy2xQB8RtGsm59AuQfkDNmGAn/Bio1wSNJ8CtUaoJHkej3U6B+gZwxowhN8KdCJnhNxgRjk7RGwAR/ptwE27g/IzHB3wdm8BOBpn6MchO8rkDGzJxEUow+BxYjYK7NScpNsNX15wK8OZmkCfxMiDe++I0nwQ/Ib3MyEL8JJOvWF0D+ATljJpDwb6xSEzyRBL9xSk3w6ST6/RKoXyBnzOmEJvhLIRP8VcYEY5P0lYAJ/lq5CbZxf01igjcEZvALgab+LOUm+M8CGTNzNkkx+gZYjIC5NmcrN8FW198I8OYckibwayHe+OJ3Lgl+QH6bc4D4TSFZt74F8g/IGTOFhH9TlJrgC0jwm6rUBE8j0e93QP0COWOmEZrg74RM8PcZE4xN0vcCJvgH5SbYxv0DiQnOisdi3wo09RcrN8H5cRkzM52kGP0ILEbAXJvpyk2w1fWPAry5lKQJ/EGIN774XUaCH5Df5lIgfjNJ1q21QP4BOWNmkvDvSqUm+EoS/K5SaoKvItHvT0D9AjljriI0wT8JmeCfMyYYm6SfBUzwOuUm2Ma9jsQEVwvM4FqBpv4a5Sa4TlzGzFxLUozWA4sRMNfmWuUm2Op6vQBv5pA0geuEeOOL3w0k+AH5beYA8buRZN36Bcg/IGfMjST8m6/UBM8lwW+BUhM8j0S/vwL1C+SMmUdogn8VMsEbMiYYm6QNAiZ4o3ITbOPeSGKC44EZ/EWgqZ+v3AQ3jsuYmQUkxeg3YDEC5tosUG6Cra5/E+DNnSRN4EYh3vjidxdLEw3Uyp1A/O4mWbd+B/IPyBlzNwn/HlZqgheR4PeIUhN8H4l+/wDqF8gZcx+hCf5DyARvyphgbJI2CZjgP5WbYBv3nyQmuHlgBn8XaOoXKzfBreIyZuZBkmK0GViMgLk2Dyo3wVbXmwV48zBJE/inEG988XuEBD8gv83DQPyWkqxbfwH5B+SMWUrCv5VKTfAyEvxeVGqCnyDRb6wRDj8gZ8wThCYYiGUpE5zVqOQ8Y4J9x2y0FVD0uNmNdJtgG3d2I3iORObaOjCDfwk09U8rN8Ft4jJm5hmSYlQJWIyAuTbPKDfBVteVGuHHfY6kCcwW4o0vfitI8APy2zwHxO95knUrB8g/IGfM8yT8+1CpCX6JBL+PlJrgl0n0mwvUL5Az5mVCE5wrZILzMiYYm6Q8AROcr9wE27jzSUxwu8AM5gg09a8qN8Gd4zJm5jWSYlQZWIyAuTavKTfBVteVBXjzJkkTmC/EG1/83iLBD8hv8yYQv7dJ1q0qQP4BOWPeJuHfj0pN8Psk+K1VaoI/INFvVaB+gZwxHxCa4KpCJrhaxgRjk1RNwARXV26CbdzVSUzw3oEZrCLQ1K9WboK7x2XMzMckxagGsBgBc20+Vm6Cra5rCPBmDUkTWF2IN977N5PgB+S3WQPE73OSdasmkH9AzpjPSfiXdZhOE/w1y5MwQPyQJvgbEv3WAuoXyBnzDaEJriVkgmtnTDA2SbUFTHAd5SbYxl2HxAT3CMxgTYGm/nvlJrhXXMbM/EBSjOoCixEw1+YH5SbY6rquAG9+ImkC6wjxxhe/n0nwA/Lb/ATEbx3JulUPyD8gZ8w6Ev7VU2qCN5DgV6DUBG8k0W8BUL9AzpiNhCa4QMgExzMmGJukuIAJ3ka5CbZxb0NigvsGZrCeQFP/h3ITfFRcxsxsIilG9YHFCJhrs0m5Cba6ri/Am79ImsBthHjjvY4fy4EfkN/mLyB+WcdyrFsNgPwDcsZkkfCvlVITnEuC3/ZKTXAeiX4bAvUL5IxB4ldeJrihkAlulDHB2CQ1EjDBjZWbYBt3YxIT3D8wgw0Emvoqx+qOe1BcxsxUJSlGTYDFCJhrU1WYN764WV03EeBNDZImsLEQb7wfkyXBD8hvUwOIXy2SdaspkH9AzphaJPzrqNQE1yPBr5NSE1xAot9mQP0COWMKCE1wMyET3DxjgrFJai5gghPKTbCNO0FigosCM9hUoKmvr9wEj4zLmJkGJMWoBbAYAXNtGig3wVbXLQR405ikCUwI8cb7pg4JfkB+m8ZA/JqSrFstgfwDcsY0JeHfQUpNcAsS/A5WaoJbkuh3W6B+gZwxLQlN8LZCJni7jAnGJmk7ARPcSrkJtnG3IjHBYwIz2FKgqW+l3ARPiMuYme1JitH2wGIEzLXZXrkJtrreXoA3rVkepxTijS9+O7E8TgnUSmsgfjuTrFs7APkH5IzZmYR//ZWa4DYk+A1QaoKTJPrdEahfIGdMktAE7yhkgltnTDA2Sa0FTPBOyk2wjXsnEhM8MTCDOwg09e2Um+BJcRkz056kGO0MLEbAXJv2yk2w1fXOArzpSNIE7iTEG1/8OpHgB+S36QjErzPJurULkH9AzpjOJPwbrdQE702C34lKTfA+JPrdFahfIGfMPoQmeFchE7xbxgRjk7SbgAluo9wE27jbkJjgKYEZ3EWgqe+q3ARfGJcxM91IilESWIyAuTbdlJtgq+ukAG/2J2kC2wjxxhe/A0jwA/Lb7A/ErwfJumWA/ANyxvQg4d8kpSa4Jwl+k5Wa4ENI9NsWqF8gZ8whhCa4rZAJbpcxwdgktRMwwe2Vm2Abd3sSEzwjMINGoKk/VLkJnhWXMTN9SIpRB2AxAuba9FFugq2uOwjwph/LbzKFeOOL3+Ek+AH5bfoB8TuCZN3aHcg/IGfMEST8m6nUBB9Dgt/lSk3wsST67QjUL5Az5lhCE9xRyAR3yphgbJI6CZjgzspNsI27M4kJnh2Ywd0FmvrjlJvgOXEZM3M8STHaA1iMgLk2xys3wVbXewjwZhBJE9hZiDe++A0mwQ/IbzMIiN8QknVrTyD/gJwxQ0j4N1epCR5Ggt88pSZ4OIl+9wLqF8gZM5zQBO8lZIL3zphgbJL2FjDB+yg3wTbufUhM8M2BGdxToKkfqdwEz4/LmJlRJMVoX2AxAubajFJugq2u9xXgzRiSJnAfId744ncSCX5AfpsxQPzGkqxbXYD8A3LGjCXh32KlJngCCX4PKjXBp5DotytQv0DOmFMITXBXIRPcLWOCsUnqJmCCuys3wTbu7iQm+M7ADHYRaOonKjfBi+IyZuZ0kmK0H7AYAXNtTldugq2u9xPgzVkkTWB3Id744nc2CX5AfpuzgPhNIlm39gfyD8gZM4mEf88pNcFTSPBbodQETyXR7wFA/QI5Y6YSmuADhExwj4wJxiaph4AJPlC5CbZxH0highcHZnB/gab+AuUmeGlcxsxMIylGBwGLETDXZppyE2x1fZAAby4maQIPFOKNL37TSfAD8ttcDMRvBsm6dTCQf0DOmBnK692yoN4dLLBuzVQe9/K4zHp9OYleegL1Asy1uVw5b04IxugpwJsTcHPcYlzzHM6MDP5sDv6MCn+ODn/a45Agll7Bn9zgfKesElMbXY/Giq6fFP5b+3o0Ru/g/NBwjJ2dMaLr/2Y+fYL39w3H2sUZK7qebj59nPkcFpz3C8fY1Rkjup46xonhGIeFY1iDf3hwfkQ4xm7OGNH11DHGhGMcHo5hYz0yOD8qHKONM0Z0vbxuiozCjZXMduZ5dOhlj3E87RHhzyqx0jdIYiFeMWxsSYEbLkmbr3wnjujIdq5Fnxlx2t6EqVbGe13ed8HMz6RypotzHn2WO5es//FcXLxizrVKKVi5nIles7no7byeU8a/id6bU8b73NhzBWJ3P6eL8/fos6o6c8hRMJfsMuaSh53Llrob6ScWK31zNJpHNKd857XKYEzsGFXKmEdlZx6pOs8LrwPn0daOUa2MeVR1fkafX82ZR3XsPNpVSZmHPf5Jv9WdudTAzmULR2o6nxXNq4bz9+j1XGceNbHz2KKbGinxR3935/d/nWs+0Vyr/I/nKsCrYjtmLeyYbavESmNqj3/STS0nvtrYubSzmsyPleQ1Gj8VW7f/kFjf6zrxuvm0h13P6oTn7vui8xzndbfeR6/v68Rkx6yHnf+WfLrzssc/5TP6fFs3ojVxWNH4fkVDxhWN71k0McsZo25KXG4PnOucu+uERH7izmfVdT7LHjY/BeF53HlNov5uU8Y83PobfX70virOeYFzrX7KfN1e0f23UW2N3p8fxpaDja2d+1nR8U8cynFidzjUZ8LgUSOGpHAoGrdSGeO6fW9uyvtcTNz+Kit1gl1iEBAM8qaFxPw2Z2+9CYG+WXOl8ptUlSptvcmAjvsqkpubxwJvbgJzbZD4pd5UOza88XR0+PMY54ZY/+B8QHgjKunciIqu/5sbdMcF7z8+HMs4Y0XX092gO86Zz8DgvDAco60zRnS9Uuzvi6s90Do5OCbDZ/Q8+zfSv84OxD7QU9y+bfukXcdQcbtFdJBzwzIqxv+vm0tZzjXmG5uVnThiKfHWDF+PGt4Tx4wfUTyx94RRo0YUjyga2nvM+CIXxtT+wx0q9bp7by4v5d+7kEavVei+xc5vkNCDYukw9f5/5/77w3fJlLFMef1iZLDQ06JDMk+LYpM0ROBp0aHKnxa1cQ8leVrULlgScy2vRrC2R6NRXPpIljHd/zq2Sb0giQGyKLqLXVHIi2KHH1HzkR37e+V374DYxbNbGTFnOefZ4Xsq/cN7stKMU9Zvh2rGeBq6Uou5ZkJkhYkqalSSGPt3S4qusdIH+lfUwDhMMbBoDGsEW3SKIzyHOXh6dnh/68pOcPLnMe7fcLhG+G4a4tGsYoG4r1X6aHJqQUPq59V9cfhdpxS/lMMA+W2AnDFS+GWDdVIEXHOHA+8M2zEkau5w5Y+XSsQ9xI7VEB/3jcp/U3N9IJauAnHfRPKbmhFAPQJzbW5Szhurl+4CvJlLoJf9BOKeR6KXE4B6AebazCPQywECvJlPoJceAnEvINHLSKBegLk2Cwj0cpAAb+4k0MvBAnHfRaKXUUC9AHNt7iLQyyECvLmXQC+9BOJeSKKX0UC9AHNtFhLo5VAB3txPoJc+AnE/QKKXE4F6AebaPECgl8MEeLOEQC/9BOJ+iEQvY4B6AebaPESglyMEeLOUQC9HCsT9KIleTgLqBZhr8yiBXo4W4M0yAr0cIxD3EyR6GQvUCzDX5gkCvfQX4M3TBHoZIBD3MyR6GQfUCzDX5hkCvRwvwJvnCPQyUCDuFSR6ORmoF2CuzQoCvQwS4M1KAr0MFoj7RRK9jAfqBZhr8yKBXoYK8GYVgV6KBOJ+hUQvE4B6AebavEKgl2ECvHmdQC/DBeJ+g0QvpwD1Asy1eYNALycI8OZtAr2MFIj7HRK9nArUCzDX5h0CvYwW4M37BHo5USDuD0j0chpQL8BcGyR+9r8taZdV8l8v2u8w2Oey7bOm9vk5+0yQfc7B/u7W/j7K3mO39w3tvRDr72zPauuwXVssXjnheKkHKvZoPDjXK+E5qf1/ThJZKE8SWDBWEyyUYwXi/phkoZwIXCiBuTYfEzQWJwvwZg2BXsYLxP0ZiV5OB+oFmGvzGYFeThHgzZcEejlVIO6vSPRyBlAvwFybrwj0MlGAN98S6OV0gbi/I9HLmUC9AHNtviPQy5kCvPmRQC9nCcS9lkQvZwH1Asy1WUugl0kCvFlHoJfJAnGvJ9HL2UC9AHNt1hPo5VwB3mwg0MsUgbg3kuhlElAvwFybjQR6OU+AN38Q6OV8gbg3kehlMlAvwFybTQR6mSbAm78I9HKhQNyx/hx6OQeoF2CuDRo/Cb1cLMCbSsrjtnqZLhB3DolezgXqBZhrk0Ogl0sEeJNPoJdLBeKuTKKXKUC9AHNtKhPoZaYAb6oR6OVygbirk+hlKlAvwFyb6gR6uUKAN7UI9HKlQNy1SfRyHlAvwFyb2gR6mS3Am3oEerlaIO4CEr2cD9QLMNemgEAv1wrwpj6BXq4TiLsBiV4uAOoFmGvTgEAvcwR405hALzcIxN2ERC/TgHoB5tog8bNffGrvfPHJfofBPpdtnzW1z8/ZZ4Lscw72d7f291H2Hru9b2jvhVh/Z3tWW4ft2mLxkuBhuq3IffPbvJx4mPzvx9+2TPeN+UIgp5H45YQ8TD1Qc43Gq4hfmAPmvPROuGhBXtQISyjBb2CKJeuiRvrneLEUodAVfDpwtdO8FVm6RPviNwOIH6sgZxAI8hIWQV4KJJTmvc7SJdoXv8tw+LVlFeRlBIKcySLIy4GC1LyZWrpE++I3C4dfO1ZBziIQ5BUsgrwSKEjNu7WlS7Qvflfh8GvPKsirCAQ5m0WQVwMFqXk7uHSJ9sXvGhx+HVgFeQ2BIK9lEeR1QEFq3m8uXaJ98bseh9/urIK8nkCQc1gEeQNQkJo3tEuXaF/8bsTh15FVkDcSCPImFkHeDBSk5h3z0iXaF79bcPh1YhXkLQSCnMsiyHlAQWreki9don3xuxWHX2dWQd5KIMjbWAQ5HyhIzXv+pUu0L34LcPgNYhXkAgJB3s4iyDuAgtS8qWC6RPvidycOv8GsgryTQJB3sQjybqAgNe9amC7Rvvjdg8NvCKsg7yEQ5L0sglwIFKTmbRHTJdoXv0U4/IayCnIRgSDvYxHk/UBBat53MV2iffF7AIdfEasgHyAQ5GIWQT4IFKTmjR3TJdoXvyU4/IpZBbmEQJAPsQjyYaAgte4c6eKHFuQj4O9DticU5CMEglzKIshHgYLUvENhukT74vcY+PuQjIJ8jECQj7MIchmQUJq3QEyXaF/8ngB/H5JRkE8QCPJJFkE+BRSk5j0W0yXaF7+nwd+HZBTk0wSCfIZFkMuBgtS8iWO6RPvi9yz4+5CMgnyWQJDPsQhyBVCQmneJTJdoX/yeB38fklGQzxMI8gUWQa4EClLzNpTpEu2L34vg70MyCvJFAkG+xCLIl4GC1LzPZbpE++K3Cvx9SEZBriIQ5CssgnwVKEjNG2mmS7Qvfq+Bvw/JKMjXCAT5Oosg3wAKUvNOnekS7Yvfm+DvQzIK8k0CQb7FIsi3gYLUvBVoukT74vcO+PuQjIJ8h0CQ77II8j2gIDXvNZou0b74vQ/+PiSjIN8nEOQHLIL8EChIzZuZpku0L34fgb8PySjIjwgEuZpFkB8DBal5t9R0ifbF7xPw9yEZBfkJgSA/ZRHkGqAgNW/Hmi7Rvvh9Bv4+JKMgPyMQ5OcsgvwCKEjN+72mS7Qvfl+Cvw/JKMgvCQT5FYsgvwYKUuuGshIJHhKMcaPARsQtCDZgvkkg7pb6N761hxkJHMvNtS9+25JsYP0NcL0Bcsaw4PdtIxn+Jf0O01J43fLFzY43VmDcHZSv1zbmkwXi3lFIL9ng+IH5MciYbT7yYiXrw7jgz+YwV/bn+PCnPb4LNP998Cc3OO+QVYJRdD0aK7p+avhv7evRGD8E5z+GY+zujBFd/zfzWRu8/6dwrI7OWNH1dPNZ68zn5+B8XThGJ2eM6HrqGBPCMX4Ox7DmZX1w/ks4RmdnjOh66hinhGOsD8ewsf4anG8Ix9jDGSO6bg+0dm6otBV39Lg7K1+D51baiit63F1Iese5fXBj7QzsHXclwe82IH67APHbjaR33AjsHYGcMUj8LGZl3NOC91VALJPufH9rVHKeE/7MLoMTeQIxxVI+JxXHmmVcg364RJJ+a4Qf9/dGOFFKxf17I3iORBf3e5UWx3YkxXGh0uLYnqQ4/gEsjkDOmPaExfEPoeK4KVMcsUnaJFAc/1ReHG3cfwoVR/RcpxdsLeRox7y5UcWMu6PyOySWl5sF4u5E0sT8CSzCHYFNTGeSJuYvIH5AzpjOJPx7TKkJ2ZsEv8eVmpB9SPQba4zDD8gZsw+hCQFiWcqEZDUuOc+YEN8xG28FFD1udmPdJsTGnd0YniORuc4KmvG/BJrSrsofnbimQKYZ70ZSjCoBixEw16abchNndV2pMX7c/UmawGwh3vjidwAJfkB+m/2B+PUgWbdygPwDcsb0IOHfKqUmuCcJfq8oNcGHkOg3F6hfIGfMIYQmOFfIBOdlTDA2SXkCJjhfuQm2ceeTmOA5gRnMEWjqD1VugucWyJiZPiTFqDKwGAFzbfoI88YXN6vrygK86UfSBOYL8cYXv8NJ8APy2/QD4ncEybpVBcg/IGfMEST8+0SpCT6GBL9PlZrgY0n0WxWoXyBnzLGEJriqkAmuljHB2CRVEzDB1ZWbYBt3dRITPD8wg1UEmvrjlJvguwtkzMzxJMWoBrAYAXNtjhfmjS9uVtc1BHgziKQJrC7EG1/8BpPgB+S3GQTEbwjJulUTyD8gZ8wQEv6tU2qCh5Hgt16pCR5Oot9aQP0COWOGE5rgWkImuHbGBGOTVFvABNdRboJt3HVITPCiwAzWFGjqRyo3wUsKZMzMKJJiVBdYjIC5NqOEeeOLm9V1XQHejCFpAusI8cYXv5NI8APy24wB4jeWZN2qB+QfkDNmLAn/cvvqNMETSPDLA+KHNMGnkOi3AKhfIGfMKYQmuEDIBMczJhibpLiACd5GuQm2cW9DYoKXBmawnkBTP1G5CX6yQMbMnE5SjOoDixEw1+Z0Yd744mZ1XV+AN2eRNIHbCPHGF7+zSfAD8tucBcRvEsm61QDIPyBnzCQS/tVXaoKnkODXQKkJnkqi34ZA/QI5Y6YSmuCGQia4UcYEY5PUSMAEN1Zugm3cjUlM8PLADDYQaOovUG6CVxbImJlpJMWoCbAYAXNtpgnzxhc3q+smAry5mKQJbCzEG1/8ppPgB+S3uRiI3wySdaspkH9AzpgZJPxrrdQEzyTBbyelJvhyEv02A+oXyBlzOaEJbiZkgptnTDA2Sc0FTHBCuQm2cSdITPCqwAw2FWjqr1Rugt8skDEzV5EUoxbAYgTMtblKmDe+uFldtxDgzTUkTWBCiDe++F1Lgh+Q3+YaIH7XkaxbLYH8A3LGXEfCvz2VmuAbSfDbS6kJvolEv9sC9QvkjLmJ0ARvK2SCt8uYYGySthMwwa2Um2AbdysSE/xuYAZbCjT1c5Wb4NUFMmZmHkkx2h5YjIC5NvOEeeOLm9X19gK8mU/SBLYS4o0vfgtI8APy28wH4nc7ybq1A5B/QM6Y20n410upCb6bBL/eSk3wPST63RGoXyBnzD2EJnhHIRPcOmOCsUlqLWCCd1Jugm3cO5GY4DWBGdxBoKlfpNwEf10gY2buIylGOwOLETDX5j5h3vjiZnW9swBvFrM8DijEG1/8HiTBD8hvsxiI3xKSdWsXIP+AnDFLSPg3UKkJXkqCX6FSE/woiX53BeoXyBnzKKEJ3lXIBO+WMcHYJO0mYILbKDfBNu42JCb4+8AM7iLQ1C9TboLXFciYmSdIilESWIyAuTZPCPPGFzer66QAb54maQLbCPHGF79nSPAD8ts8DcRvOcm6ZYD8A3LGLCfh31ilJvh5EvzGKTXBL5Doty1Qv0DOmBcITXBbIRPcLmOCsUlqJ2CC2ys3wTbu9iQmeENgBo1AU/+SchP8Z4GMmXmZpBh1ABYjYK7Ny8K88cXN6rqDAG9eJWkC2wvxxhe/10jwA/LbvArE73WSdWt3IP+AnDGvk/BvilIT/DYJflOVmuB3SPTbEahfIGfMO4QmuKOQCe6UMcHYJHUSMMGdlZtgG3dnEhOcFY/Fdhdo6t9XboLz4zJm5gOSYrQHsBgBc20+EOaNL25W13sI8GY1SRPYWYg3vvh9TIIfkN9mNRC/T0jWrT2B/ANyxnxCwr8rlZrgz0nwu0qpCf6CRL97AfUL5Iz5gtAE7yVkgvfOmGBskvYWMMH7KDfBNu59SExwtcAM7inQ1H+t3ATXicuYmW9IitG+wGIEzLX5Rpg3vrhZXe8rwJvvSZrAfYR444vfDyT4Afltvgfi9yPJutUFyD8gZ8yPJPybr9QEryPBb4FSE7yeRL9dgfoFcsasJzTBXYVMcLeMCcYmqZuACe6u3ATbuLuTmOB4YAa7CDT1G5Sb4MZxGTOzkaQY7QcsRsBcm43CvPHFzep6PwHe/EHSBHYX4o0vfptI8APy2/wBxO9PknVrfyD/gJwxf5Lw72GlJjhrAAd+jyg1wdkDOPR7AFC/QM4YJH7lZYIPEDLBPTImGJukHgIm+EDlJtjGfSCJCW4emMH9BZr63AG6424VlzEzeSTF6CBgMQLm2uQJ88YXN6vrgwR4U4WkCTxQiDe++FUlwQ/Ib1MFiF81knXrYCD/gJwx1Uj4t1KpCa5Fgt+LSk1wbRL99gTqF8gZU5vQBPcUMsGHZEwwNkmHCJjgXspNsI27F4kJbh2YwYMFmvp6yk1wm7iMmSkgKUa9gcUImGtToNwEW133FuBNfZImsJcQb3zxa0CCH5Dfpj4Qv4Yk69ahQP4BOWMakvDvQ6UmuCkJfh8pNcHNSPTbB6hfIGdMM0IT3EfIBPfNmGBskvoKmODDlJtgG/dhJCa4XWAGDxVo6lsoN8Gd4zJmpiVJMeoHLEbAXJuWyk2w1XU/Ad60ImkCDxPijS9+25PgB+S3aQXEbweSdetwIP+AnDE7kPDvR6UmeGcS/NYqNcG7kOj3CKB+gZwxuxCa4COETPCRGROMTdKRAib4KOUm2MZ9FIkJ3jswg4cLNPVtlJvg7nEZM5MkKUZHA4sRMNcmqdwEW10fLcCbdiRN4FFCvPHeuooEPyC/TTsgfh1I1q1jgPwDcsZ0IOFf1mE6TXBnEvyygfghTfAeJPo9FqhfIGfMHoQm+FghE9w/Y4KxSeovYIIHKDfBNu4BJCa4R2AGjxFo6vdWboJ7xWXMzD4kxeg4YDEC5trso9wEW10fJ8CbriRN4AAh3vji140EPyC/TVcgft1J1q3jgfwDcsZ0J+FfPaUmuAfL1xmUmuADSfQ7EKhfIGfMgYQmeKCQCS7MmGBskgoFTPAg5SbYxj2IxAT3Dczg8QJNfU/lJviouIyZOYSkGA0GFiNgrs0hyk2w1fVgAd4cStIEDhLijfd3zUjwA/LbHArEry/JujUEyD8gZ0xfEv61UmqCjyDBb3ulJvhIEv0OBeoXyBlzJKEJHipkgosyJhibpCIBE1ys3ATbuItJTHD/wAwOEWjqj1FuggfFZczMsSTFaBiwGAFzbY5VboKtrocJ8OY4kiawWIg33r8hJMEPyG9zHBC/gSTr1nAg/4CcMQNJ+NdRqQkeQoJfJ6UmeCiJfkcA9QvkjBlKaIJHCJngEzImGJukEwRM8EjlJtjGPZLEBBcFZnC4QFM/TLkJHhmXMTPDSYrRKGAxAubaDFdugq2uRwnwZiRJEzhSiDfefCbBD8hvMxKI32iSdWs0kH9AzpjRJPw7SKkJHkuC38FKTfA4Ev2eCNQvkDNmHKEJPlHIBI/JmGBsksYImOCTlJtgG/dJJCZ4TGAGRws09ROUm+AJcRkzcwpJMRoLLEbAXJtTlJtgq+uxAryZSNIEniTEG1/8TifBD8hvMxGI3xkk69Y4IP+AnDFnkPCvv1ITPInl/0RQaoInk+j3ZKB+gZwxkwlN8MlCJnh8xgRjkzRewARPUG6CbdwTSEzwxMAMjhNo6qcoN8GT4jJmZipJMToFWIyAuTZTlZtgq+tTBHhzAUkTOEGIN774TSPBD8hvcwEQvwtJ1q1TgfwDcsZcSMK/0UpN8AwS/E5UaoIvIdHvaUD9AjljLiE0wacJmeCJGROMTdJEARN8unITbOM+ncQETwnM4KkCTf1M5Sb4wriMmbmcpBidASxGwFyby5WbYKvrMwR4cyVJE3i6EG988buKBD8gv82VQPxmk6xbZwL5B+SMmU3Cv0lKTfB1JPhNVmqCryfR71lA/QI5Y64nNMFnCZngszMmGJukswVM8CTlJtjGPYnEBM8IzOCZAk39jcpN8Ky4jJm5iaQYTQYWI2CuzU3KTbDV9WQB3sxlaaKFeOOL3zwS/ID8NnOB+N1Ksm6dA+QfkDPmVhL+zVRqgm9nuYml1ATfQaLfc4H6BXLG3EFogs8VMsFTMiYYm6QpAiZ4qnITbOOeSmKCZwdm8ByBpv5u5SZ4TlzGzNxDUozOAxYjYK7NPcpNsNX1eQK8WcTyOK8Qb3zxu48EPyC/zSIgfveTrFvnA/kH5Iy5n4R/c5Wa4CUk+M1TaoIfItHvBUD9AjljHiI0wRcImeBpGROMTdI0ARN8oXITbOO+kMQE3xyYwfMFmvqlyk3w/LiMmXmUpBhdBCxGwFybR5WbYKvriwR4s4ykCbxQiDe++D1Bgh+Q32YZEL8nSdati4H8A3LGPEnCv8VKTfByEvweVGqCnyXR73SgfoGcMc8SmuDpQiZ4RsYEY5M0Q8AEX6LcBNu4LyExwXcGZvBigab+eeUmeFFcxsy8QFKMLgUWI2CuzQvKTbDV9aUCvHmJpAm8RIg3vvi9TIIfkN/mJSB+q0jWrcuA/ANyxqwi4d9zSk3w6yT4rVBqgt8g0e9MoH6BnDFvEJrgmUIm+PKMCcYm6XIBEzxLuQm2cc8iMcGLAzN4mUBT/7ZyE7w0LmNm3iEpRlcAixEw1+Yd5SbY6voKAd68T9IEzhLijS9+H5DgB+S3eR+I34ck69aVQP4BOWM+VF7vlgX17kqBdesT5XEvj8us15+S6OUqoF6AuTafKufN2GCMqwR4MxY3xy3GNc/hzLjgz+bgz8nhz/HhT3vMDmK5OviTG5zvmVViaqPr0VjR9VPDf2tfj8a4Jji/NhxjL2eM6Pq/mc91wfuvD8fa2xkrup5uPtc585kTnN8QjrGPM0Z0PXWMCeEYc8IxrMG/MTi/KRxjX2eM6HrqGKeEY9wYjmFjvTk4vyUco4szRnS93LbMwo2VzHbmOTf0svMcT3tE+LNKrPQNkliIVwwbW1LghkvS5ivfiSM6sp1r0WdGnLY3YaqV8V6X910w8zOpnOninEef5c4l6388FxevmHOtUgpWLmei12wuejuv55Txb6L35pTxPjf2XIHY3c/p4vw9+qyqzhxyFMwlu4y55GHnsqXuRvqJxUrfHI3mEc0p33mtMhgTO0aVMuZR2ZlHqs7zwuvAebS1Y1QrYx5VnZ/R51dz5lEdO492VVLmYY9/0m91Zy41sHPZwpGazmdF86rh/D16PdeZR03sPLbopkZK/NHf3fn9X+eaTzTXKv/juQrwqtiOWQs7ZtsqsdKY2uOfdFPLia82di7trCbzYyV5jcZPxdbtPyTW97pOvG4+7WHXszrhufu+6DzHed2t99Hr+zox2THrYee/JZ/uvOzxT/mMPt/WjWhNHFY0vl/RkHFF43sWTcxyxqibEpfbA+c65+46IZGfuPNZdZ3PsofNT0F4Hndek6i/25QxD7f+Rp8fva+Kc17gXKufMl+3V3T/bVRbo/fnh7HlYGNr535WdPwTh3Kc2B0O9ZkweNSIISkcisatVMa4bt+bm/I+FxO3v8pKnWCXGAQEg7xpITG/GyptvQmBvlnzufKbVHMrbb3JgI77C5Kbm7cCb24Cc22Q+KXeVLs1vPE0N/w5z7khdltwPj+8EdXVuREVXf83N+gWBO+/PRyrmzNWdD3dDboFznzuCM7vDMfo7owRXa8U+/viag+0Tg6OyfAZPc/bGutfZ+/APtBT3L5t+6Rdx1Bxu0X0LueGZVSM/183l7Kca8w3Nis7ccRS4q0Zvh41vCeOGT+ieGLvCaNGjSgeUTS095jxRS6Mqf2HO1TqdffeXF7Kv3chjV6r0H2Lnd9dQg+KpcPU+/+5/O8P3yVTxjLl9YuRu4WeFr0n87QoNkn3CDwteq/yp0Vt3PeSPC1qFyyJuZZXI7jQo9EoLn0ky5jufx3bpF6QxABZFN3FbmHIi0UOP6LmIzv298rv3gGxi2e3MmLOcs6zw/dU+of3ZKUZp6zfDtWM8TR0pRZzzYTIChO1sHFJYuzfLSm6xkof6F9RA+Mwi4BF477GsEWnOMLzPgdPzw7vb13ZWCd/HuP+DYevlT/aPTbkKXrcb5Q+mpxa0JD6GdkFh9+3JI92A/ltgJwxUvhlg3WyELjm3g+8M2zHkKi59yt/vFQi7hOCMS5uhI/7R+W/qdkrWGymC8S9luQ3NQ8A9QjMtVmrnDdWL5cI8GYdgV4uFYh7PYleFgP1Asy1WU+gl5kCvNlAoJfLBeLeSKKXB4F6AebabCTQyxUCvPmDQC9XCsS9iUQvS4B6AebabCLQy2wB3vxFoJerBeKOHcehl4eAegHm2qDxk9DLtQK8qaQ8bquX6wTiziHRy8NAvQBzbXII9DJHgDf5BHq5QSDuyiR6eQSoF2CuTWUCvdwkwJtqBHq5WSDu6iR6WQrUCzDXpjqBXuYK8KYWgV7mCcRdm0QvjwL1Asy1qU2gl9sEeFOPQC/zBeIuINHLY0C9AHNtCgj0crsAb+oT6OUOgbgbkOjlcaBegLk2DQj0cpcAbxoT6OVugbibkOhlGVAvwFybJgR6uVeAN80J9LJQIO4EiV6eAOoFmGuTINDLfQK82ZZAL/cLxL0diV6eBOoFmGuzHYFeFgvwZgcCvTwoEPeOJHp5CqgXYK7NjgR6eUiANzsT6OVhgbh3IdHL00C9AHNtkPjZ/7Zkv6yS/3rRfofBPpdtnzW1z8/ZZ4Lscw72d7f291H2Hru9b2jvhVh/Z3tWW4ft2mLxygnHSz1QsUfjwbmeg+ek9v85SWShXCqwYLQhWCgfFYg7SbJQPgNcKIG5NkmCxuJxAd60I9DLMoG425PoZTlQL8Bcm/YEenlSgDcdCfTylEDcnUj08ixQL8Bcm04EenlGgDd7EuhluUDce5Ho5TmgXoC5NnsR6OU5Ad7sS6CXFQJxdyHRywqgXoC5Nl0I9PKCAG+6E+hlpUDc+5Ho5XmgXoC5NvsR6OUlAd70INDLywJxH0iilxeAegHm2hxIoJdXBHjTk0AvrwrEfQiJXlYC9QLMtTmEQC+vC/DmUAK9vCEQdx8SvbwI1Asw16YPgV7eEuBNPwK9vC0Q9+EkenkJqBdgrs3hBHp5V4A3RxHo5T2BuI8m0cvLQL0Ac22OJtDLBwK86U+glw8F4h5AopdVQL0Ac20GEOhltQBvBhLo5WOBuAtJ9PIKUC/AXJtCAr18KsCbIQR6WSMQ91ASvbwK1Asw12YogV4+F+DNMAK9fCEQ93ASvbwG1Asw12Y4gV6+EuDNSAK9fC0Q9ygSvbwO1Asw1waJn/3i0/7OF5/sdxjsc9n2WVP7/Jx9Jsg+52B/d2t/H2Xvsdv7hvZeiPV3tme1ddiuLa+Hu0GieZhuK3Lf/I4pJx4m//vxty3TfWN+A8hpJH45IQ9TD9Rco/Eq4hfmgDkvvRMuWpBvNsYSSvAbmGLJerOx/jm+JUUodAV/u4JsRZYu0b74vQPEj1WQ7xAI8l0WQb5XQfY6S5doX/zex+HXllWQ7xMI8gMWQX5YQTZTS5doX/w+wuHXjlWQHxEIcjWLID+uILu1pUu0L36f4PBrzyrITwgE+SmLINdUkO3g0iXaF7/PcPh1YBXkZwSC/JxFkF9UkP3m0iXaF78vcfjtzirILwkE+RWLIL+uIBvapUu0L37f4PDryCrIbwgE+S2LIL+rIDvmpUu0L37f4/DrxCrI7wkE+QOLIH+sIFvypUu0L35rcfh1ZhXkWgJB/sQiyJ8ryJ5/6RLti986HH6DWAW5jkCQ61kE+UsF2VQwXaJ98fsVh99gVkH+SiDIDSyC3FhBdi1Ml2hf/H7D4TeEVZC/EQjydxZB/lFBtkVMl2hf/Dbh8BvKKshNBIL8k0WQmyvIvovpEu2L3184/IpYBfkXgSBjTUgEmYWbqOqNHdMl2he/bBx+xayCzG6if46VWASZAxSk1p0jXfzQgswFJlr4C7ZiZM8lEGQeiyDzgYLUvENhukT74lcZiB+rICsTCLIKiyCrAgmleQvEdIn2xa8aDr+2rIKsRiDI6iyCrAEUpOY9FtMl2he/mjj82rEKsiaBIGuxCLI2UJCaN3FMl2hf/Org8GvPKsg6BIKsyyLIekBBat4lMl2iffErwOHXgVWQBQSCjLMIchugIDVvQ5ku0b741cfhtzurIOsTCLIBiyAbAgWpeZ/LdIn2xa8RDr+OrIJsRCDIxiyCbAIUpOaNNNMl2he/pjj8OrEKsimBIJuxCLI5UJCad+pMl2hf/BI4/DqzCjJBIMgWLIJsCRSk5q1A0yXaF79tcfgNYhXktgSC3I5FkK2AgtS812i6RPvitz0Ov8GsgtyeQJA7sAhyR6AgNW9mmi7Rvvi1xuE3hFWQrQkEuROLIHcGClLzbqnpEu2L3y44/IayCnIXAkHuyiLI3YCC1Lwda7pE++LXBodfEasg2xAIMskiSAMUpOb9XtMl2he/tuDvQzIKsi2BINuxCLI9UJBaN5SVSLDdgPkbgY2IxxJswPytQNzj9G98aw8zDjiWm2tf/E4m2cC6A3C9AXLGsOC3exMZ/iX9DjNOeN3y/o84gjFOExj3VOXrtY35dIG4TxPSSzY4fmB+DDJmm4+8WMn6MDH4sznMlf15RvjTHh0DzXcK/uQG5wdklWAUXY/Giq6fHf5b+3o0RufgfI9wjB7OGNH1fzOfPYP37xWOdaAzVnQ93Xz2dOazd3C+TzjGQc4Y0fXUMc4Mx9g7HMOal33tWhiOcbAzRnQ9dYyzwjH2DcewsXYNzruFY/R0xoiu2wOtnX1ytuKOHvcM5Wtw95ytuKLHPZOkd5zbBzfWGcDe8SwS/G4D4ncmEL+zSXrH7sDeEcgZg8TPYlbGPS14XwXEMunOd78mJec54c/sMjiRJxBTLOVzUnGsWcY16IdLJGm/Jvhx92+CE6VU3Ps3gedIdHG/V2lxnEJSHBcqLY5TSYrjAcDiCOSMmUpYHA8QKo49MsURm6QeAsXxQOXF0cZ9oFBxRM91esHWQo52zAc1qZhxX6D8Donl5UECcU8jaWIOBBbhC4BNzIUkTczBQPyAnDEXkvDvMaUmZAYJfo8rNSGXkOi3J1C/QM6YSwhNSE8hE3JIxoRgk3SIgAnppdyE2Lh7kZiQWUEzfrBAUzpT+aMT1xTINOOXkxSj3sBiBMy1uVy5ibO67i3AmytJmsBeQrzxxe8qEvyA/DZXAvGbTbJuHQrkH5AzZjYJ/1YpNcHXkeD3ilITfD2JfvsA9QvkjLme0AT3ETLBfTMmGJukvgIm+DDlJtjGfRiJCZ4TmMFDBZr6G5Wb4LkFMmbmJpJi1A9YjIC5NjcpN8FW1/0EeDOXpAk8TIg3vvjNI8EPyG8zF4jfrSTr1uFA/gE5Y24l4d8nSk3w7ST4farUBN9Bot8jgPoFcsbcQWiCjxAywUdmTDA2SUcKmOCjlJtgG/dRJCZ4fmAGDxdo6u9WboLvLpAxM/eQFKOjgcUImGtzj3ITbHV9tABvFpE0gUcJ8cYXv/tI8APy2ywC4nc/ybp1DJB/QM6Y+0n4t06pCV5Cgt96pSb4IRL9HgvUL5Az5iFCE3yskAnunzHB2CT1FzDBA5SbYBv3ABITvCgwg8cINPVLlZvgJQUyZuZRkmJ0HLAYAXNtHlVugq2ujxPgzTKSJnCAEG988XuCBD8gv80yIH5PkqxbxwP5B+SMeZKEf7l9dZrg5ST45QHxQ5rgZ0n0OxCoXyBnzLOEJnigkAkuzJhgbJIKBUzwIOUm2MY9iMQELw3M4PECTf3zyk3wkwUyZuYFkmI0GFiMgLk2Lyg3wVbXgwV48xJJEzhIiDe++L1Mgh+Q3+YlIH6rSNatIUD+ATljVpHwr75SE/w6CX4NlJrgN0j0OxSoXyBnzBuEJniokAkuyphgbJKKBExwsXITbOMuJjHBywMzOESgqX9buQleWSBjZt4hKUbDgMUImGvzjnITbHU9TIA375M0gcVCvPHF7wMS/ID8Nu8D8fuQZN0aDuQfkDPmQxL+tVZqgj8hwW8npSb4UxL9jgDqF8gZ8ymhCR4hZIJPyJhgbJJOEDDBI5WbYBv3SBITvCowg8MFmvrPlZvgNwtkzMwXJMVoFLAYAXNtvlBugq2uRwnw5muSJnCkEG988fuGBD8gv83XQPy+JVm3RgP5B+SM+ZaEf3sqNcE/kuC3l1ITvJZEvycC9QvkjFlLaIJPFDLBYzImGJukMQIm+CTlJtjGfRKJCX43MIOjBZr6dcpN8OoCGTOznqQYjQUWI2CuzXrlJtjqeqwAbzaQNIEnCfHGF7+NLP+xDlArG4D4/Uaybo0D8g/IGfMbCf96KTXBf5Lg11upCd5Mot+TgfoFcsZsJjTBJwuZ4PEZE4xN0ngBEzxBuQm2cU8gMcFrAjM4TqCpzzped9xfF8iYmezjOYrRKcBiBMy1yRbmjS9uVtenCPAmt5x4k/Q7Sq29Sb+jFG988csjwQ/Ib5MLxC+fZN06Fcg/IGdMPgn/Bio1wdVI8CtUaoKrk+j3NKB+gZwxSPzKywSfJmSCJ2ZMMDZJEwVM8OnKTbCN+3QSE/x9YAZPFWjqayk3wesKZMxMbZJidAawGAFzbWorN8FW12cI8KYeSRN4uhBvfPErIMEPyG9TD4hfnGTdOhPIPyBnTJyEf2OVmuCGJPiNU2qCG5Ho9yygfoGcMY0ITfBZQib47IwJxibpbAETPEm5CbZxTyIxwRsCM3imQFPfVLkJ/rNAxsw0IylGk4HFCJhr00y5Cba6nizAmxYkTeAkId744teSBD8gv00LIH7bkqxb5wD5B+SM2ZaEf1OUmuAdSPCbqtQE70ii33OB+gVyxuxIaILPFTLBUzImGJukKQImeKpyE2zjnkpigrPisdg5Ak39zspNcH5cxszsQlKMzgMWI2CuzS7KTbDV9XkCvGnD0gQK8cYXvyQJfkB+mzZA/AzJunU+kH9AzhhDwr8rlZrgDiT4XaXUBO9Oot8LgPoFcsbsTmiCLxAywdMyJhibpGkCJvhC5SbYxn0hiQmuFpjB8wWa+s7KTXCduIyZ2YOkGF0ELEbAXJs9lJtgq+uLBHizN0kTeKEQb3zx24cEPyC/zd5A/PYlWbcuBvIPyBmzLwn/5is1wd1J8Fug1ATvR6Lf6UD9Ajlj9iM0wdOFTPCMjAnGJmmGgAm+RLkJtnFfQmKC44EZvFigqe+h3AQ3jsuYmQNJitGlwGIEzLU5ULkJtrq+VIA3PUmawEuEeOOL3yEk+AH5bXoC8etFsm5dBuQfkDOmFwn/HlZqgvuS4PeIUhN8GIl+ZwL1C+SMOYzQBM8UMsGXZ0wwNkmXC5jgWcpNsI17FokJbh6YwcsEmvojlJvgVnEZM3MkSTG6AliMgLk2Ryo3wVbXVwjw5hiSJnCWEG988TuWBD8gv80xQPz6k6xbVwL5B+SM6U/Cv5VKTfBAEvxeVGqCC0n0exVQv0DOmEJCE3yVkAmenTHB2CTNFjDBVys3wTbuq0lMcOvADF4p0NQPUW6C28RlzMxQkmJ0DbAYAXNthio3wVbX1wjwZhhJE3i1EG988RtOgh+Q32YYEL8RJOvWtUD+ATljRpDw70OlJng0CX4fKTXBJ5Lo9zqgfoGcMScSmuDrhEzw9RkTjE3S9QImeI5yE2zjnkNigtsFZvBagaZ+rHIT3DkuY2bGkRSjG4DFCJhrM065Cba6vkGANxNImsA5Qrzx3veaZYsVoFYmAPE7lWTduhHIPyBnzKkk/PtRqQk+gwS/tUpN8Jkk+r0JqF8gZ8yZhCb4JiETfHPGBGOTdLOACb5FuQm2cd9CYoL3DszgjQJN/STlJrh7XMbMTCYpRnOBxQiYazNZuQm2up4rwJspJE3gLUK88f5fu0nwA/LbTAHidx7JujUPyD8gZ8x5JPzLOkynCb6QBL9sIH5IE3wRiX5vBeoXyBlzEaEJvlXIBN+WMcHYJN0mYILnKzfBNu75JCa4R2AG5wk09TOUm+BecRkzcwlJMVoALEbAXJtLlJtgq+sFAryZyfK/ywrxxhe/y1n+YzGgVmYC8ZtFsm7dDuQfkDNmFgn/6ik1wbNJ8CtQaoKvJtHvHUD9AjljriY0wXcImeA7MyYYm6Q7BUzwXcpNsI37LhIT3Dcwg7cLNPXXKTfBR8VlzMz1JMXobmAxAubaXK/cBFtd3y3AmxtJmsC7hHjj/ZgdCX5AfpsbgfjdTLJu3QPkH5Az5mYS/rVSaoJvJcFve6Um+DYS/d4L1C+QM+Y2QhN8r5AJXpgxwdgkLRQwwYuUm2Ab9yISE9w/MIP3CDT1tys3wYPiMmbmDpJidB+wGAFzbe5QboKtru8T4M3dJE3gIiHeeJsjEvyA/DZ3A/G7l2Tduh/IPyBnzL0k/Ouo1ATfT4JfJ6Um+AES/T4A1C+QM+YBQhP8gJAJXpwxwdgkLRYwwQ8qN8E27gdJTHBRYAbvF2jqlyg3wSPjMmbmIZJitARYjIC5Ng8pN8FW10sEeLOUpAl8UIg3vvg9SoIfkN9mKRC/x0jWrYeA/ANyxjxGwr+DlJrgJ0nwO1ipCX6KRL8PA/UL5Ix5itAEPyxkgh/JmGBskh4RMMFLlZtgG/dSEhM8JjCDDwk09cuVm+AJcRkz8yxJMXoUWIyAuTbPKjfBVtePCvDmeZImcKkQb3zxe4EEPyC/zfNA/FaSrFuPAfkH5IxZScK//kpN8CoS/AYoNcGvkOj3caB+gZwxrxCa4MeFTPCyjAnGJmmZgAl+QrkJtnE/QWKCJwZm8DGBpv515SZ4UlzGzLxBUoyeBBYjYK7NG8pNsNX1kwK8eZukCXxCiDe++L1Dgh+Q3+ZtIH7vkqxbTwH5B+SMeZeEf6OVmuAPSfA7UakJ/ohEv08D9QvkjPmI0AQ/LWSCn8mYYGySnhEwwcuVm2Ab93ISEzwlMINPCTT1nyg3wRfGZczMpyTF6FlgMQLm2nyq3ARbXT8rwJvPSZrA5UK88cXvCxL8gPw2nwPx+5Jk3XoOyD8gZ8yXJPybpNQEf8uyxZlSE/wdiX5XAPUL5Iz5jtAErxAywc9nTDA2Sc8LmOAXlJtgG/cLJCZ4RmAGnxNo6n9UboJnxWXMzFqSYrQSWIyAuTZrlZtgq+uVArxZR9IEviDEG1/81pPgB+S3WQfE7xeSdetFIP+AnDG/kPBvplIT/BsJfpcrNcG/k+j3JaB+gZwxvxOa4JeETPDLGROMTdLLAiZ4lXITbONeRWKCZwdm8EWBpv5P5SZ4TlzGzGwmKUavAIsRMNdms3ITbHX9igBvsgZyNIGrhHjji182CX5AfhuXM774VRrIsW69CuQfkDOmEgn/5io1wfkk+M1TaoIrk+j3NaB+gZwxSPzKywS/JmSCX8+YYGySXhcwwW8oN8E27jdITPDNgRl8VaCprzZQd9zz4zJmpjpJMXoTWIyAuTbVhXnj/Z3vALc3BXhTi6QJfEOIN7741SbBD8hvUwuIXx2SdestIP+AnDF1SPi3WKkJjpPg96BSE7wNiX7fBuoXyBmzDaEJflvIBL+TMcHYJL0jYILfVW6CbdzvkpjgOwMz+JZAU99QuQleFJcxM41IitF7wGIEzLVppNwEW12/J8CbpiRN4LtCvPHFrxkJfkB+m6ZA/JqTrFvvA/kH5IxpTsK/55Sa4G1J8Fuh1ARvR6LfD4D6BXLGbEdogj8QMsEfZkwwNkkfCpjgj5SbYBv3RyQmeHFgBt8XaOp3UG6Cl8ZlzMyOJMVoNbAYAXNtdlRugq2uVwvwZmeSJvAjId744rcLCX5AfpudgfjtSrJufQzkH5AzZlfl9W5ZUO8+Fli3jPK4l8dl1uu2JHr5BKgXYK5NW+W8OS0Y4xMB3pyGm+MW45rncGZi8Gdz8Of08OcZ4U97fBrEsib4kxucH5JVYmqj69FY0fWzw39rX4/G+Cw4/zwco5czRnT938zni+D9X4Zj9XbGiq6nm88Xzny+Cs6/Dsc41Bkjup46xpnhGF+FY1iD/01w/m04Rh9njOh66hhnhWN8E45hY/0uOP8+HKOvM0Z0vbxuipyOGyuZ7czzh9DL/uh42iPCn1VipW+QxEK8YtjYkgI3XJI2X/lOHNGR7VyLPjPitL0JU62M97q874KZn0nlTBfnPPosdy5Z/+O5uHjFnGuVUrByORO9tmUdcF7PKePfRO/NKeN9buy5ArG7n9PF+Xv0WVWdOeQomEt2GXPJw85lS92N9BOLlb45Gs0jmlO+81plMCZ2jCplzKOyM49UneeF14HzaGvHqFbGPKo6P6PPr+bMozp2Hu2qpMzDHv+k3+rOXGpg57KFIzWdz4rmVcP5e/R6rjOPmth5bNFNjZT4o7+78/u/zjWfaK5V/sdzFeBVsR2zFnbMtlVipTG1xz/pppYTX23sXNpZTebHSvIajZ+Krdt/SKzvdZ143Xzaw65ndcJz933ReY7zulvvo9f3dWKyY9bDzn9LPt152eOf8hl9vq0b0Zo4rGh8v6Ih44rG9yyamOWMUTclLrcHznXO3XVCIj9x57PqOp9lD5ufgvA87rwmUX+3KWMebv2NPj96XxXnvMC5Vj9lvm6v6P7bqLZG788PY8vBxtbO/azo+CcO5TixOxzqM2HwqBFDUjgUjVupjHHdvjc35X0uJm5/lZU6wS4xCAgGedNCYn775Gy9CYG+WdNB+U2q7jlbbzKg496d5ObmWuDNTWCuDRK/1Jtqa8MbTz+EP390boj9FJz/HN6IOsy5ERVd/zc36NYF718fjtXPGSu6nu4G3TpnPr8E57+GYxzujBFdrxT7++JqD7RODo7J8Bk9z5+a6F9nf8E+0FPcvm37pF3HUHG7RXSDc8MyKsb/r5tLWc415hublZ04Yinx1gxfjxreE8eMH1E8sfeEUaNGFI8oGtp7zPgiF8bU/sMdKvW6e28uL+Xfu5BGr1XovsXOb4PQg2LpMPWtuRv/+8N3yZSxTHn9YmSj0NOiv2WeFsUm6TeBp0V/V/60qI37d5KnRe2CJTHX8moE+3g0GsWlj2QZ0/2vY5vUC5IYIIuiu9j9EfJik8OPqPnIjv298rt3QOzi2a2MmLOc8+zwPZX+4T1ZacYp67dDNWM8DV2pxVwzIbLCRP3RpCQx9u+WFF1jpQ/0r6iBcZhNwKLxZxPYolMc4fmng6dnh/e3ruw0J38e4/4Nh87KH+0+LeQpetw9lD6anFrQkPrJ7YrDb0+SR7uB/DZAzhgp/LLBOvkDuOZuBt4ZtmNI1NzNyh8vlYh7bDDGW43xce+r/Dc1HwSLzdsCcXch+U3NX0A9AnNtuijnjdXLuwK86U6gl/cE4t6PRC+xpsDfEgP1sh+BXj4Q4E0PAr18KBD3gSR6yQLqBZhrcyCBXlYL8KYngV4+Foj7EBK9ZAP1Asy1OYRAL58K8OZQAr2sEYi7D4leKgH1Asy16UOgl88FeNOPQC9fCMR9OIlecoB6AebaHE6gl68EeHMUgV6+Foj7aBK95AL1Asy1OZpAL98K8KY/gV6+E4h7AIle8oB6AebaDCDQyw8CvBlIoJcfBeIuJNFLPlAvwFybQgK9/CTAmyEEevlZIO6hJHqpDNQLMNdmKIFe1gvwZhiBXn4RiHs4iV6qAPUCzLUZTqCXDQK8GUmgl40CcY8i0UtVoF6AuTajCPTyuwBvxhDo5Q+BuE8i0Us1oF6AuTYnEejlTwHenEygl80CcY8n0Ut1oF6AuTbjCfQSE3gu+1QCvWRJPI9OopcaQL0Ac21OI9BLJQHenEGglxyBuM8k0UtNoF6AuTZI/Ox/W3JEVsl/vWi/w2Cfy7bPmtrn5+wzQfY5B/u7W/v7KHuP3d43tPdCrL+zPautw3ZtsXjlhOOlHqjYo/HgXM/Bc1L7/5wkslDmCSwYkwgWynyBuCeTLJS1gAslMNdmMkFjUUWAN1MI9FJVIO6pJHqpDdQLMNdmKoFeqgvw5gICvdQQiHsaiV7qAPUCzLWZRqCXWgK8uZhAL7UF4p5Oope6QL0Ac22mE+ilrgBvLiXQSz2BuC8j0Us9oF6AuTaXEeglLsCbWQR62UYg7itI9FIA1Asw1+YKAr00EODNbAK9NBSI+2oSvcSBegHm2lxNoJfGAry5jkAvTQTivp5EL9sA9QLMtbmeQC/NBHhzI4FemgvEfROJXuoD9QLMtbmJQC8tBHgzl0AvLQXinkeilwZAvQBzbeYR6GU7Ad7MJ9BLK4G4F5DopSFQL8BcmwUEetlBgDd3EuhlR4G47yLRSyOgXoC5NncR6GUnAd7cS6CXnQXiXkiil8ZAvQBzbRYS6GVXAd7cT6CX3QTifoBEL02AegHm2jxAoJekAG+WEOjFCMT9EIlemgL1Asy1eYhAL+0EeLOUQC/tBeJ+lEQvzYB6AebaIPGzX3w60vnik/0Og30u2z5rap+fs88E2ecc7O9u7e+j7D12e9/Q3gux/s72rLYO27XF4iXBw3Rbkfvmd1k58TD534+/bZnuG3NzIKeR+OWEPEw9UHONxquIX5gD5rz0TrhoQSaaYgkl+A1MsWQlmuqfYwspQqEreEvgaqd5K7J0ifbFb1sgfqyC3JZAkNuxCLJVBdnrLF2iffHbHodfW1ZBbk8gyB1YBLljBdlMLV2iffFrjcOvHasgWxMIcicWQe5cQXZrS5doX/x2weHXnlWQuxAIclcWQe5WQbaDS5doX/za4PDrwCrINgSCTLII0lSQ/ebSJdoXv7Y4/HZnFWRbAkG2YxFk+wqyoV26RPvi1wGHX0dWQXYgEOTuLILsWEF2zEuXaF/8OuHw68QqyE4EguzMIsg9KsiWfOkS7Yvfnjj8OrMKck8CQe7FIsi9K8ief+kS7YvfPjj8BrEKch8CQe7LIsguFWRTwXSJ9sWvKw6/wayC7EogyG4sguxeQXYtTJdoX/z2w+E3hFWQ+xEIcn8WQR5QQbZFTJdoX/x64PAbyirIHgSCPJBFkAdVkH0X0yXaF7+DcfgVsQryYAJB9mQR5CEVZGPHdIn2xa8XDr9iVkH2IhBkbxZBHloBdo508UMLsg/4+5BHEgqyD4Eg+7II8rAKskNhukT74tcP/H1IRkH2IxDk4SyCPKKCbIGYLtG++B0J/j4koyCPJBDkUSyCPLqC7LGYLtG++B0D/j4koyCPIRDksSyC7F9BNnFMl2hf/AaAvw/JKMgBBII8jkWQx1eQXSLTJdoXv4Hg70MyCnIggSALWQQ5qIJsQ5ku0b74DQZ/H5JRkIMJBDmERZBDK8g+l+kS7YtfEfj7kIyCLCIQZDGLIIdVkI000yXaF7/h4O9DMgpyOIEgR7AI8oQKslNnukT74jcS/H1IRkGOJBDkKBZBjgYKUvNWoOkS7YvfieDvQzIK8kQCQY5hEeRJQEFq3ms0XaJ98RsL/j4koyDHEghyHIsgTwYKUvNmpukS7YvfePD3IRkFOZ5AkBNYBHkKUJCad0tNl2hf/E4Ffx+SUZCnEgjyNBZBTgQKUvN2rOkS7Yvf6eDvQzIK8nQCQZ7BIsgzgYLUvN9rukT74ncW+PuQjII8i0CQZ7MIchJQkFo3lJVIsN2AuYPABrBPEmzAvLtA3E/p3/jWHmYicCw31774PU2ygfVk4HoD5Ixhwe+cpjL8S/od5inhdcsXNzveJIFxn1O+XtuYzxGIe4WQXrLB8QPzY5Ax23zkxUrWh8nBn81hruzPc8Of9jg30PyU4E9ucH5UVglG0fVorOj6edEYTUvGmBqcnxeOcbQzRnT938zn/OD9F4RjHeOMFV1PN5/znflMC84vDMc41hkjup46xpRwjGnhGNa8XBScXxyO0d8ZI7qeOsbUcIyLwjFsrNOD8xnhGAOcMaLr9kBr56Ocrbijx12pfA1ek7MVV/S4L5L0jnP74MZaCewdXyLB7zYgfi8C8XuZpHe8BNg7AjljkPhZzMq4pwXvq4BYJt35Xtq05Dwn/JldBifyBGKKpXxOKo41y7gG/XCJJF3aFD/uZU1xopSK+7Km8ByJLu73Ki2Or5MUx4VKi+MbJMVxJrA4Ajlj3iAsjjOFiuPlmeKITdLlAsVxlvLiaOOeJVQc0XOdXrC1kKMd8xVNK2bcbyu/Q2J5eYVA3O+QNDGzgEX4bWAT8y5JE3MlED8gZ8y7JPx7TKkJ+ZAEv8eVmpCPSPR7FVC/QM6YjwhNyFVCJmR2xoRgkzRbwIRcrdyE2LivJjEhs4Jm/EqBpvQT5Y9OXFMg04x/SlKMrgEWI2CuzafKTZzV9TUCvPmcpAm8Wog3vvh9QYIfkN/mcyB+X5KsW9cC+QfkjPmShH+rlJrgb0nwe0WpCf6ORL/XAfUL5Iz5jtAEXydkgq/PmGBskq4XMMFzlJtgG/ccEhM8JzCD1wo09T8qN8FzC2TMzFqSYnQDsBgBc23WKjfBVtc3CPBmHUkTOEeIN774rSfBD8hvsw6I3y8k69aNQP4BOWN+IeHfJ0pN8G8sN7GUmuDfSfR7E1C/QM6Y3wlN8E1CJvjmjAnGJulmARN8i3ITbOO+hcQEzw/M4I0CTf2fyk3w3QUyZmYzSTGaCyxGwFybzcpNsNX1XAHeZBVyNIG3CPHGF79sEvyA/DYuZ3zxq1TIsW7NA/IPyBlTXvgl/Q6zTqkJzifBb71SE1y5kEO/twL1C+SMQeJXXib4ViETfFvGBGOTdJuACZ6v3ATbuOeTmOBFgRmcJ9DUVyvUHfeSAhkzU72QoxgtABYjYK4NGj90fq2uFwjwplYhRxM4X4g3vvjVJsEPyG9TC4hfnUKOdet2IP+AnDHlhV/S7zC5fXWa4DgJfnlA/JAmeJtCDv3eAdQvkDMGiV95meA7hEzwnRkTjE3SnQIm+C7lJtjGfReJCV4amMHbBZr6hoW6436yQMbMNCrkKEZ3A4sRMNcGjR86v1bXdwvwpmkhRxN4lxBvfPFrRoIfkN+mKRC/5oUc69Y9QP4BOWPKC7+k32HqKzXB25Lg10CpCd6ukEO/9wL1C+SMQeJXXib4XiETvDBjgrFJWihgghcpN8E27kUkJnh5YAbvEWjqdyjUHffKAhkzs2MhRzG6D1iMgLk2aPzQ+bW6vk+ANzsXcjSBi4R444vfLiT4Afltdgbit2shx7p1P5B/QM6Y8sIv6XeY1kpNsCHBbyelJrhtIYd+HwDqF8gZg8SvvEzwA0ImeHHGBGOTtFjABD+o3ATbuB8kMcGrAjN4v0BT36FQd9xvFsiYmd0LOYrREmAxAubaoPFD59fqeokAbzoXcjSBDwrxxhe/PUjwA/LbdAbit2chx7r1EJB/QM6Y8sIv6XeYPZWa4H1J8NtLqQnuUsih34eB+gVyxiDxKy8T/LCQCX4kY4KxSXpEwAQvVW6CbdxLSUzwu4EZfEigqe9eqDvu1QUyZma/Qo5i9CiwGAFzbdD4ofNrdf2oAG96FHI0gUuFeOOL34Ek+AH5bXoA8TuokGPdegzIPyBnTHnhl/Q7TC+lJrgXCX69lZrg3oUc+n0cqF8gZwwSv/IywY8LmeBlGROMTdIyARP8hHITbON+gsQErwnM4GMCTX3fQt1xf10gY2YOK+QoRk8CixEw1waNHzq/VtdPCvDmiEKOJvAJId744nckCX5AfpsjgPgdVcixbj0F5B+QM6a88Ev6HWagUhPcnwS/QqUmeEAhh36fBuoXyBmDxK+8TPDTQib4mYwJxibpGQETvFy5CbZxLycxwd8HZvApgaZ+YKHuuNcVyJiZwkKOYvQssBgBc23Q+KHza3X9rABvhhRyNIHLhXjji99QEvyA/DZDgPgVFXKsW88B+QfkjCkv/JJ+hxmr1ASPIMFvnFITfEIhh35XAPUL5IxB4ldeJniFkAl+PmOCsUl6XsAEv6DcBNu4XyAxwRsCM/icQFM/ulB33H8WyJiZEws5itFKYDEC5tqg8UPn1+p6pQBvxhZyNIEvCPHGF79xJPgB+W3GAvE7uZBj3XoRyD8gZ0x54Zf0O8wUpSb4VBL8pio1wacVcuj3JaB+gZwxSPzKywS/JGSCX86YYGySXhYwwauUm2Ab9yoSE5wVj8VeFGjqzyjUHXd+XMbMnFnIUYxeARYjYK4NGj90fq2uXxHgzaRCjiZwlRBvfPGbTIIfkN9mEhC/cwo51q1XgfwDcsaUF35Jv8NcqdQEn0eC31VKTfD5hRz6fQ2oXyBnDBK/8jLBrwmZ4NczJhibpNcFTPAbyk2wjfsNEhNcLTCDrwo09RcW6o67TlzGzFxUyFGM3gQWI2CuDRo/dH6trt8U4M2MQo4m8A0h3vjidwkJfkB+mxlA/C4t5Fi33gLyD8gZU174Jf0OM1+pCZ5Fgt8CpSb4ikIO/b4N1C+QMwaJX3mZ4LeFTPA7GROMTdI7Aib4XeUm2Mb9LokJjgdm8C2Bpn52oe64G8dlzMzVhRzF6D1gMQLm2qDxQ+fX6vo9Ad5cV8jRBL4rxBtf/K4nwQ/Ib3MdEL85hRzr1vtA/gE5Y8oLv6TfYR5WaoJvJsHvEaUm+JZCDv1+ANQvkDMGiV95meAPhEzwhxkTjE3ShwIm+CPlJtjG/RGJCW4emMH3BZr6Wwt1x90qLmNmbivkKEargcUImGuDxg+dX6vr1QK8ub2Qown8SIg3vvjdQYIfkN/mdiB+dxZyrFsfA/kH5IwpL/ySfodZqdQE30uC34tKTfDCQg79fgLUL5AzBolfeZngT4RM8KcZE4xN0qcCJniNchNs415DYoJbB2bwY4Gm/v5C3XG3icuYmQcKOYrRZ8BiBMy1QeOHzq/V9WcCvFlSyNEErhHijS9+D5HgB+S3WQLE7+FCjnXrcyD/gJwx5YVf0u8wHyo1wY+R4PeRUhP8eCGHfr8A6hfIGYPEr7xM8BdCJvjLjAnGJulLARP8lXITbOP+isQEtwvM4OcCTf2Thbrj7hyXMTNPFXIUo6+BxQiYa4PGD51fq+uvBXizvJCjCfxKiDfeW36R4Afkt1kOxO+5Qo516xsg/4CcMeWFX9LvMD8qNcErSfBbq9QEv1jIod9vgfoFcsYg8SsvE/ytkAn+LmOCsUn6TsAEf6/cBNu4vycxwXsHZvAbgaZ+VaHuuLvHZczMK4UcxegHYDEC5tqg8UPn1+r6BwHevF7I0QR+L8Qb7/+wjAQ/IL/N60D83izkWLd+BPIPyBlTXvgl/Q6TdZhOE/wuCX7ZQPyQJvi9Qg79rgXqF8gZg8SvvEzwWiET/FPGBGOT9JOACf5ZuQm2cf9MYoJ7BGbwR4Gm/sNC3XH3isuYmY8KOYrROmAxAubaoPFD59fqep0Abz4p5GgCfxbijS9+n5LgB+S3+QSI35pCjnVrPZB/QM6Y8sIv6XeYekpN8Jck+BUoNcFfFXLo9xegfoGcMUj8yssE/yJkgn/NmGBskn4VMMEblJtgG/cGEhPcNzCD6wWa+m8Ldcd9VFzGzHxXyFGMNgKLETDXBo0fOr9W1xsFePNjIUcTuEGIN96/YSDBD8hv8yMQv58KOdat34D8A3LGlBd+Sb/DtFJqgn8hwW97pSb410IO/f4O1C+QMwaJX3mZ4N+FTPAfGROMTdIfAiZ4k3ITbOPeRGKC+wdm8DeBpv63Qt1xD4rLmJnfCzmK0Z/AYgTMtUHjh86v1fWfArz5s5CjCdwkxBtf/DaT4Afkt/kTiN9fhRzr1mYg/4CcMeWFX9LvMB2VmuBKgzjw66TUBOcM4tDvX0D9AjljkPiVlwn+S8gEx5qVnGZMsOeYNkkWUPS4Wc10m2Abd1YzeI5E5loUmMHNAk19/iDdcY+My5iZyiTFKLsZDktgrk1lYd744mZ1nd0MP241kiYwS4g3vvhVJ8EPyG9TDYhfDZJ1qxKQf0DOmBok/DtIqQmuQ4LfwUpNcF0S/eYA9QvkjKlLaIKBWJYywbkZE4xNUq6ACc5TboJt3HkkJnhMYAYrCTT1ceUmeEJcxsxsQ1KM8oHFCJhrs41yE2x1nS/Am4YkTWCeEG988WtEgh+Q36YhEL/GJOtWZSD/gJwxjUn411+pCW5Ogt8ApSY4QaLfKkD9AjljEoQmuIqQCa6aMcHYJFUVMMHVlJtgG3c1EhM8MTCDlQWa+m2Vm+BJcRkzsx1JMaoOLEbAXJvtlJtgq+vqArzZgaQJrCbEG1/8diTBD8hvswMQv9Yk61YNIP+AnDGtSfg3WqkJ3pUEvxOVmuDdSPRbE6hfIGfMboQmuKaQCa6VMcHYJNUSMMG1lZtgG3dtEhM8JTCDNQSaeqPcBF8YlzEzbUmKUR1gMQLm2rRVboKtrusI8KYDSRNYW4g3vvjtToIfkN+mAxC/jiTrVl0g/4CcMR1J+DdJqQnekwS/yUpN8F4k+q0H1C+QM2YvQhNcT8gEF2RMMDZJBQImOK7cBNu44yQmeEZgBusKNPX7KjfBs+IyZqYLSTHaBliMgLk2XZSbYKvrbQR4052kCYwL8cYXv/1I8APy23QH4rc/ybpVH8g/IGfM/iT8m6nUBB9Egt/lSk3wwST6bQDUL5Az5mBCE9xAyAQ3zJhgbJIaCpjgRspNsI27EYkJnh2YwfoCTX0v5SZ4TlzGzPQmKUaNgcUImGvTW7kJtrpuLMCbviRNYCMh3vjidxgJfkB+m75A/PqRrFtNgPwDcsb0I+HfXKUm+CgS/OYpNcFHk+i3KVC/QM6YowlNcFMhE9wsY4KxSWomYIKbKzfBNu7mJCb45sAMNhFo6vsrN8Hz4zJmZgBJMUoAixEw12aAchNsdZ0Q4M1AkiawuRBvfPErJMEPyG8zEIjfIJJ1qwWQf0DOmEEk/Fus1AQXkeD3oFITXEyi35ZA/QI5Y4oJTXBLIRO8bcYEY5O0rYAJ3k65CbZxb0digu8MzGALgaZ+hHITvCguY2ZOIClGrYDFCJhrc4JyE2x13UqAN6NJmsDthHjji9+JJPgB+W1GA/EbQ7JubQ/kH5AzZgwJ/55TaoJPJsFvhVITPJ5EvzsA9QvkjBlPaIJ3EDLBO2ZMMDZJOwqY4NbKTbCNuzWJCV4cmMHtBZr6U5Wb4KVxGTNzGkkx2glYjIC5NqcpN8FW1zsJ8OYMkiawtRBvfPE7kwQ/IL/NGUD8ziJZt3YG8g/IGXOW8nq3LKh3OwusW+coj3t5XGa9PpdEL7sA9QLMtTlXOW8mBWPsIsCbSbg5bjGueQ5nJgd/Ngd/zgl/nhv+tMeuQSy72S1rg/PjskpMbXQ9Giu6fl74b+3r0RhtgvNkOMbxzhjR9X8zHxO8v2041kBnrOh6uvkYZz7tgvP24RiFzhjR9dQxpoRjtAvHsAa/Q3C+ezjGIGeM6HrqGFPDMTqEY9hYOwbnncIxBjtjRNfL66bIObixktnOPDuHXnYPx9MeEf6sEit9gyQW4hXDxpYUuOGStPnKd+KIjmznWvSZEaftTZhqZbzX5X0XzPxMKme6OOfRZ7lzyfofz8XFK+Zcq5SClcuZ6DWbi97O6zll/JvovTllvM+NPVcgdvdzujh/jz6rqjOHHAVzyS5jLnnYuWypu5F+YrHSN0ejeURzyndeqwzGxI5RpYx5VHbmkarzvPA6cB5t7RjVyphHVedn9PnVnHlUx86jXZWUedjjn/Rb3ZlLDexctnCkpvNZ0bxqOH+PXs915lETO48tuqmREn/0d3d+/9e55hPNtcr/eK4CvCq2Y9bCjtm2Sqw0pvb4J93UcuKrjZ1LO6vJ/FhJXqPxU7F1+w+J9b2uE6+bT3vY9axOeO6+LzrPcV536330+r5OTHbMetj5b8mnOy97/FM+o8+3dSNaE4cVje9XNGRc0fieRROznDHqpsTl9sC5zrm7TkjkJ+58Vl3ns+xh81MQnsed1yTq7zZlzMOtv9HnR++r4pwXONfqp8zX7RXdfxvV1uj9+WFsOdjY2rmfFR3/xKEcJ3aHQ30mDB41YkgKh6JxK5Uxrtv35qa8z8XE7a+yUifYJQYBwSBvWkjM76OcrTch0DdrzhukO+41OVtvMqDjPp/k5uaewJubwFwbJH6pN9X2DG88dQ5/7uHcENsrON87vBE1xLkRFV3/Nzfo9gnev2841lBnrOh6uht0+zjz6RKcdw3HKHLGiK5Xiv19cbUHWicHx2T4jJ7nXs30r7NdsA/0FLdv2z5p1zFU3G4R7ebcsIyK8f/r5lKWc81t6uzBdGOzshNHLCXemuHrUcN74pjxI4on9p4watSI4hFFQ3uPGV/kwpjaf7hDpV53783lpfx7F9LotQrdt9j5dRN6UCwdpt7/ef1/f/gumTKWKa9fjHQXelp0v8zTotgk7SfwtOj+yp8WtXHvT/K0qF2wJOZaXo3gWo9Go7j0kSxjuv91bJN6QRIDZFF0F7sDQl70cPgRNR/Zsb9XfvcOiF08u5URc5Zznh2+p9I/vCcrzThl/XaoZoynoSu1mGsmRFaYqAOalSTG/t2Somus9AHf8xE4Vg9g0TiwGWzRKY7wPNDB07PD+1tXNsnJn8e4f8PhwkGyxQ3xaFYPgbgvKqe7acl/eaQWNKR+buyKw+9ipfilHAbIbwPkjJHCLzuG1ckBwDX3IOCdYTuGRM09SPnjpRJxnxaM0aIpPu5Llf+m5sygw20pEPdlJL+pORioR2CuzWXKeWP1sp0Ab2YR6KWVQNxXkOilJ1AvwFybKwj0soMAb2YT6GVHgbivJtHLIUC9AHNtribQy04CvLmOQC87C8R9PYleegH1Asy1uZ5AL7sK8OZGAr3sJhD3TSR66Q3UCzDX5iYCvSQFeDOXQC9GIO55JHo5FKgXYK7NPAK9tBPgzXwCvbQXiHsBiV76APUCzLVZQKCX3QV4cyeBXjoKxH0XiV76AvUCzLW5i0AvnQV4cy+BXvYQiHshiV4OA+oFmGuzkEAvewnw5n4CvewtEPcDJHrpB9QLMNfmAQK97CvAmyUEeukiEPdDJHo5HKgXYK7NQwR66SbAm6UEeukuEPejJHo5AqgXYK7NowR62V+AN8sI9HKAQNxPkOjlSKBegLk2TxDo5UAB3jxNoJeDBOJ+hkQvRwH1Asy1eYZALz0FePMcgV4OEYh7BYlejgbqBZhrs4JAL70FeLOSQC+HCsT9IolejgHqBZhrg8TP/rcl9guXtcPx7HcY7HPZ9llT+/ycfSbIPudgf3drfx9l77Hb+4b2Xoj1d7ZntXXYri0Wr5xwvNQDFXs0HpzruXhOoueI/p+TRBbKvgILxiqChfIwgbhfIVkojwUulMBcm1cIGovDBXjzOoFejhCI+w0SvfQH6gWYa/MGgV6OEuDN2wR6OVog7ndI9DIAqBdgrs07BHo5VoA37xPopb9A3B+Q6OU4oF6AuTYfEOjlOAHerCbQy/ECcX9MopfjgXoB5tp8TKCXQgHerCHQyyCBuD8j0ctAoF6AuTafEehliABvviTQy1CBuL8i0UshUC/AXJuvCPRSLMCbbwn0Mkwg7u9I9DIIqBdgrs13BHoZIcCbHwn0coJA3GtJ9DIYqBdgrs1aAr2MEuDNOgK9jBaIez2JXoYA9QLMtVlPoJcxArzZQKCXkwTi3kiil6FAvQBzbTYS6GWcAG/+INDLyQJxbyLRSxFQL8Bcm00EepkgwJu/CPRyikDcscEceikG6gWYa4PGT0IvpwnwppLyuK1eJgrEnUOil2FAvQBzbXII9HKGAG/yCfRypkDclUn0MhyoF2CuTWUCvZwtwJtqBHqZJBB3dRK9jADqBZhrg8TPfvFpmPPFJ/sdBvtctn3W1D4/Z58Jss852N/d2t9H2Xvs9r6hvRdi/Z3tWW0dtmvLiHA3SDQP021F7pvfWuXEw+R/P/62ZbpvzCcAOY3ELyfkYeqBmms0XkX8whww56V3wkULcmQzLKEEv4EplqyRzfTPcZQUodAVfHQF2YosXaJ98TsRiB+rIE8kEOQYFkGeVEH2OkuXaF/8xuLwa8sqyLEEghzHIsiTK8hmaukS7YvfeBx+7VgFOZ5AkBNYBHlKBdmtLV2iffE7FYdfe1ZBnkogyNNYBDmxgmwHly7RvvidjsOvA6sgTycQ5Bksgjyzguw3ly7RvvidhcNvd1ZBnkUgyLNZBDmpgmxoly7RvvhNxuHXkVWQkwkEeQ6LIM+tIDvmpUu0L35TcPh1YhXkFAJBTmUR5HkVZEu+dIn2xe98HH6dWQV5PoEgL2AR5LQKsudfukT74nchDr9BrIK8kECQF7EI8uIKsqlgukT74jcdh99gVkFOJxDkDBZBXlJBdi1Ml2hf/C7F4TeEVZCXEgjyMhZBzqwg2yKmS7Qvfpfj8BvKKsjLCQQ5i0WQV1SQfRfTJdoXvytx+BWxCvJKAkFexSLI2RVkY8d0ifbF72ocfsWsgryaQJDXsAjy2gqwc6SLH1qQ14G/DzmMUJDXEQjyehZBzqkgOxSmS7QvfjeAvw/JKMgbCAR5I4sgb6ogWyCmS7QvfjeDvw/JKMibCQR5C4sg51aQPRbTJdoXv3ng70MyCnIegSBvZRHkbRVkE8d0ifbFbz74+5CMgpxPIMgFLIK8vYLsEpku0b743QH+PiSjIO8gEOSdLIK8q4JsQ5ku0b743Q3+PiSjIO8mEOQ9LIK8t4Lsc5ku0b74LQR/H5JRkAsJBLmIRZD3VZCNNNMl2he/+8Hfh2QU5P0EgnyARZCLK8hOnekS7Yvfg+DvQzIK8kECQS5hEeRDQEFq3go0XaJ98XsY/H1IRkE+TCDIR1gEuRQoSM17jaZLtC9+j4K/D8koyEcJBPkYiyAfBwpS82am6RLti98y8PchGQW5jECQT7AI8kmgIDXvlpou0b74PQX+PiSjIJ8iEOTTLIJ8BijISjgRmRwSQS4Hfx+SUZDLCQT5LIsgnwMKUvN+r+kS7YvfCvD3IRkFuYJAkM+zCPIFoCC1bigrkWC7AfNkgY2I6yiP227AfI5A3HWFFmDgxrf2MJOBY7m59sWvXjnh5zvPlcD1BsgZw4Lfi81k+Jf0O0xd4XXLFzc73vkC49ZXvl7bmKcJxN1ASC/Z4PiB+THImG0+8mIl68MFwZ/NYa7szwvDn/Z4KdD8y8Gf3OB8eFYJRtH1aKzo+vTw39rXozFWBeevhGOMcMaIrv+b+bwavP+1cKwTnLGi6+nm86ozn9eD8zfCMUY6Y0TXU8e4KBzj9XAMa17eDM7fCscY5YwRXU8d4+JwjDfDMWysbwfn74RjjHbGiK7bA62ds3O34o4et7HyNXhK7lZc0eM2Iekd5/bBjdUY2Ds2JcHvNiB+TYD4NSPpHd8F9o5AzhgkfhazMu5pwfsqIJZJd77vNSs5zwl/ZpfBiTyBmGIpn5OKY80yrkE/XCJJ7zXDj/t+M5wopeJ+vxk8R6KL+71Ki+O2JMVxodLiuB1JcfwAWByBnDHbERbHD4SK44eZ4ohN0ocCxfEj5cXRxv2RUHFEz3V6wdZCjnbMq5tVzLh3UH6HxPJytUDcO5I0MR8Bi/AOwCamNUkT8zEQPyBnTGsS/j2m1ITsSoLf40pNyG4k+v0EqF8gZwwSv/IyIZ8ImZBPMyYEm6RPBUzIGuUmxMa9hsSEzAqa8Y8FmlIzWHfc1xTINONtSYrRZ8BiBMy1aSvMG1/crK4/E+BNB5ImcI0Qb3zx250EPyC/TQcgfh1J1q3PgfwDcsZ0JOHfKqUmeE8S/F5RaoL3ItHvF0D9AjljkPiVlwn+QsgEf5kxwdgkfSlggr9SboJt3F+RmOA5gRn8XKCp31e5CZ5bIGNmupAUo6+BxQiYa9NFmDe+uFldfy3Am+4kTeBXQrzxxW8/EvyA/DbdgfjtT7JufQPkH5AzZn8S/n2i1AQfRILfp0pN8MEk+v0WqF8gZwwSv/Iywd8KmeDvMiYYm6TvBEzw98pNsI37exITPD8wg98INPW9lJvguwtkzExvkmL0A7AYAXNtegvzxhc3q+sfBHjTl6QJ/F6IN774HUaCH5Dfpi8Qv34k69aPQP4BOWP6kfBvnVITfBQJfuuVmuCjSfS7FqhfIGcMEr/yMsFrhUzwTxkTjE3STwIm+GflJtjG/TOJCV4UmMEfBZr6/spN8JICGTMzgKQYrQMWI2CuzQBh3vjiZnW9ToA3A0mawJ+FeOOLXyEJfkB+m4FA/AaRrFvrgfwDcsYMIuFfbl+dJriIBL88IH5IE1xMot9fgPoFcsYg8SsvE/yLkAn+NWOCsUn6VcAEb1Bugm3cG0hM8NLADK4XaOpHKDfBTxbImJkTSIrRRmAxAubanCDMG1/crK43CvBmNEkTuEGIN774nUiCH5DfZjQQvzEk69ZvQP4BOWPGkPCvvlITfDIJfg2UmuDxJPr9HahfIGcMEr/yMsG/C5ngPzImGJukPwRM8CblJtjGvYnEBC8PzOBvAk39qcpN8MoCGTNzGkkx+hNYjIC5NqcJ88YXN6vrPwV4cwZJE7hJiDe++J1Jgh+Q3+YMIH5nkaxbm4H8A3LGnEXCv9ZKTfA5JPjtpNQEn0ui37+A+gVyxiDxKy8T/JeQCY41LznNmGDPMW2SLKDocbOa6zbBNu6s5vAcicx1VWAGNws09ecpN8FvFsiYmfNJilF2cxyWwFyb84V5470RfYBbdnP8uBeSNIFZQrzxxe8iEvyA/DYXAvG7mGTdqgTkH5Az5mIS/u2p1ARfSoLfXkpN8GUk+s0B6hfIGYPEr7xMMBDLUiY4N2OCsUnKFTDBecpNsI07j8QEvxuYwUoCTf0s5SZ4dYGMmbmCpBjlA4sRMNfmCmHe+OJmdZ0vwJvZJE1gnhBvfPG7mgQ/IL/NbCB+15CsW5WB/ANyxlxDwr9eSk3wHBL8eis1wTeQ6LcKUL9AzhgkfuVlgqsImeCqGROMTVJVARNcTbkJtnFXIzHBawIzWFmgqb9ZuQn+ukDGzNxCUoyqA4sRMNfmFmHe+OJmdV1dgDe3kjSB1YR444vfbST4AfltbgXiN59k3aoB5B+QM2Y+Cf8GKjXBd5LgV6jUBN9Fot+aQP0COWOQ+JWXCa4pZIJrZUwwNkm1BExwbeUm2MZdm8QEfx+YwRoCTf29yk3wugIZM7OQpBjVARYjYK7NQmHe+OJmdV1HgDf3kzSBtYV444vfAyT4Aflt7gfit5hk3aoL5B+QM2YxCf/GKjXBD5PgN06pCX6ERL/1gPoFcsYg8SsvE1xPyAQXZEwwNkkFAiY4rtwE27jjJCZ4Q2AG6wo09Y8pN8F/FsiYmcdJitE2wGIEzLV5XJg3vrhZXW8jwJsnSZrAuBBvfPF7igQ/IL/Nk0D8niZZt+oD+QfkjHmahH9TlJrg50jwm6rUBK8g0W8DoH6BnDFI/MrLBDcQMsENMyYYm6SGAia4kXITbONuRGKCs+KxWH2Bpn6lchOcH5cxMy+SFKPGwGIEzLV5UZg3vrhZXTcW4M0qkiawkRBvfPF7hQQ/IL/NKiB+r5KsW02A/ANyxrxKwr8rlZrgN0nwu0qpCX6LRL9NgfoFcsYg8SsvE9xUyAQ3y5hgbJKaCZjg5spNsI27OYkJrhaYwSYCTf27yk1wnbiMmXmPpBglgMUImGvznjBvfHGzuk4I8OZDkiawuRBvfPH7iAQ/IL/Nh0D8VpOsWy2A/ANyxqwm4d98pSZ4DQl+C5Sa4M9I9NsSqF8gZwwSv/IywS2FTPC2GROMTdK2AiZ4O+Um2Ma9HYkJjgdmsIVAU/+lchPcOC5jZr4iKUatgMUImGvzlTBvfHGzum4lwJtvSZrA7YR444vfdyT4AfltvgXi9z3JurU9kH9AzpjvSfj3sFIT/BMJfo8oNcE/k+h3B6B+gZwxSPzKywTvIGSCd8yYYGySdhQwwa2Vm2Abd2sSE9w8MIPbCzT1vyg3wa3iMmbmV5JitBOwGAFzbX4V5o0vblbXOwnw5jeSJrC1EG988fudBD8gv81vQPz+IFm3dgbyD8gZ8wcJ/1YqNcF/keD3olITHBvCod9dgPoFcsYg8SsvE7yLkAneNWOCsUnaVcAE76bcBNu4dyMxwa0DM7izQFNfaYjuuNvEZcxMDkkxagMsRsBcmxxh3vjiZnXdRoA3+eXEm6TfUWrtTfodpXjjvX8sCX5Afpt8IH5VSNatJJB/QM6YKiT8+1CpCa5Bgt9HSk1wTRL9GqB+gZwxNQlNsBEywW0zJhibpLYCJridchNs425HYoLbBWYwKdDU11FugjvHZcxMXZJi1B5YjIC5NnWVm2Cr6/YCvImTNIHthHjj/b+dk+AH5LeJA/GrT7JudQDyD8gZU5+Efz8qNcGNSfBbq9QENyHR7+5A/QI5Y5oQmuDdhUxwx4wJxiapo4AJ7qTcBNu4O5GY4L0DM9hBoKlvrtwEd4/LmJkESTHqDCxGwFybhHITbHXdWYA325I0gZ2EeOP9XW0S/ID8NtsC8WtFsm7tAeQfkDOmFQn/sg7TaYJbk+CXDcQPaYJ3ItHvnkD9AjljdiI0wXsKmeC9MiYYm6S9BEzw3spNsI17bxIT3CMwg3sINPW7KjfBveIyZmY3kmK0D7AYAXNtdlNugq2u9xHgjSFpAvcW4o0vfm1ZHicHasUA8WtHsm7tC+QfkDOmHQn/6ik1wR1J8CtQaoI7kei3C1C/QM6YToQmuIuQCe6aMcHYJHUVMMHdlJtgG3c3EhPcNzCD+wo09XsqN8FHxWXMzF4kxag7sBgBc232Um6Cra67C/BmX5ImsJsQb7ybKxL8gPw2+wLx60qybu0H5B+QM6YrCf9aKTXB+5Pgt71SE3wAiX73B+oXyBlzAKEJ3l/IBB+QMcHYJB0gYIJ7KDfBNu4eJCa4f2AG9xNo6g9SboIHxWXMzMEkxehAYDEC5tocrNwEW10fKMCbXiRNYA8h3vji15sEPyC/TS8gfoeSrFsHAfkH5Iw5lIR/HZWa4H4sXwdRaoIPJ9HvwUD9AjljDic0wQcLmeCeGROMTVJPARN8iHITbOM+hMQEFwVm8CCBpv4o5SZ4ZFzGzBxNUox6AYsRMNfmaOUm2Oq6lwBv+pM0gYcI8cYXvwEk+AH5bfoD8TuOZN3qDeQfkDPmOBL+HaTUBA9iuYml1AQPJtHvoUD9AjljBhOa4EOFTHCfjAnGJqmPgAnuq9wE27j7kpjgMYEZ7C3Q1BcpN8ET4jJmppikGB0GLEbAXJti5SbY6vowAd6MIGkC+wrxxhe/E0jwA/LbjADiN5Jk3eoH5B+QM2YkCf/6KzXBY0jwG6DUBJ9Eot/DgfoFcsacRGiCDxcywUdkTDA2SUcImOAjlZtgG/eRJCZ4YmAG+wk09ScrN8GT4jJmZjxJMToKWIyAuTbjlZtgq+ujBHhzKkkTeKQQb3zxO40EPyC/zalA/CaSrFtHA/kH5IyZSMK/0UpN8Fkk+J2o1ASfTaLfY4D6BXLGnE1ogo8RMsHHZkwwNknHCpjg/spNsI27P4kJnhKYwaMFmvpzlJvgC+MyZuZckmI0AFiMgLk25yo3wVbXAwR4cx7Lb5KEeOOL3/kk+AH5bc4D4ncBybp1HJB/QM6YC0j4N0mpCb6YBL/JSk3wdBL9Hg/UL5AzZjqhCT5eyAQPzJhgbJIGCpjgQuUm2MZdSGKCZwRm8DiBpv5S5SZ4VlzGzFxGUowGAYsRMNfmMuUm2Op6kABvZpE0gYVCvPHF7woS/ID8NrOA+F1Jsm4NBvIPyBlzJQn/Zio1wdeQ4He5UhN8LYl+hwD1C+SMuZbQBA8RMsFDMyYYm6ShAia4SLkJtnEXkZjg2YEZHCzQ1M9RboLnxGXMzA0kxagYWIyAuTY3KDfBVtfFAry5maQJLBLijS9+t5DgB+S3uRmI31ySdWsYkH9Azpi5JPybq9QEzyfBb55SE7yARL/DgfoFcsYsIDTBw4VM8IiMCcYmaYSACT5BuQm2cZ9AYoJvDszgMIGm/k7lJnh+XMbM3EVSjEYCixEw1+Yu5SbY6nqkAG/uJWkCTxDijS9+C0nwA/Lb3AvEbxHJujUKyD8gZ8wiEv4tVmqCF5Pg96BSE/wgiX5HA/UL5Ix5kNAEjxYywSdmTDA2SScKmOAxyk2wjXsMiQm+MzCDowSa+oeVm+BFcRkz8whJMToJWIyAuTaPKDfBVtcnCfDmMZImcIwQb3zxe5wEPyC/zWNA/JaRrFtjgfwDcsYsI+Hfc0pN8NMk+K1QaoKfIdHvOKB+gZwxzxCa4HFCJvjkjAnGJulkARM8XrkJtnGPJzHBiwMzOFagqX9OuQleGpcxMytIitEEYDEC5tqsUG6Cra4nCPBmJUkTOF6IN774vcjSRAO1shKI30sk69YpQP4BOWNeUl7vlgX17hSBdetV5XEvj8us16+R6OVUoF6AuTavKefN+cEYpwrw5nzcHLcY1zyHMxcEfzYHf6aFPy8Mf9rjtCCWicGf3OD8xKwSUxtdj8aKrk8P/619PRrj9OD8jHCMMc4Y0fV/M58zg/efFY51kjNWdD3dfM505nN2cD4pHGOsM0Z0PXWMi8Ixzg7HsAZ/cnB+TjjGOGeM6HrqGBeHY0wOx7CxnhucTwnHONkZI7peXjdFpuHGSmY785waetnzHE97RPizSqz0DZJYiFcMG1tS4IZL0uYr34kjOrKda9FnRpy2N2GqlfFel/ddMPMzqZzp4pxHn+XOJet/PBcXr5hzrVIKVi5notdsLno7r+eU8W+i9+aU8T439lyB2N3P6eL8Pfqsqs4cchTMJbuMueRh57Kl7kb6icVK3xyN5hHNKd95rTIYEztGlTLmUdmZR6rO88LrwHm0tWNUK2MeVZ2f0edXc+ZRHTuPdlVS5mGPf9JvdWcuNbBz2cKRms5nRfOq4fw9ej3XmUdN7Dy26KZGSvzR3935/V/nmk801yr/47kK8KrYjlkLO2bbKrHSmNrjn3RTy4mvNnYu7awm82MleY3GT8XW7T8k1ve6TrxuPu1h17M64bn7vug8x3ndrffR6/s6Mdkx62HnvyWf7rzs8U/5jD7f1o1oTRxWNL5f0ZBxReN7Fk3McsaomxKX2wPnOufuOiGRn7jzWXWdz7KHzU9BeB53XpOov9uUMQ+3/kafH72vinNe4FyrnzJft1d0/21UW6P354ex5WBja+d+VnT8E4dynNgdDvWZMHjUiCEpHIrGrVTGuG7fm5vyPhcTt7/KSp1glxgEBIO8aSExv7Nzt96EQN+seVP5TaopuVtvMqDjfovk5ub5wJubwFwbJH6pN9XOD288TQ1/nufcELsgOJ8W3oga79yIiq7/mxt0Fwbvvygca4IzVnQ93Q26C535XBycTw/HOMUZI7peKfb3xdUeaJ0cHJPhM3qeFzTXv85ejH2gp7h92/ZJu46h4naL6AznhmVUjP9fN5eynGvMNzYrO3HEUuKtGb4eNbwnjhk/onhi7wmjRo0oHlE0tPeY8UUujKn9hztU6nX33lxeyr93IY1eq9B9i53fDKEHxdJh6ltzL/nvD98lU8Yy5fWLkUuEnha9NPO0KDZJlwo8LXqZ8qdFbdyXkTwtahcsibmWVyN4mUejUVz6SJYx3f86tkm9IIkBsii6i93MkBeXO/yImo/s2N8rv3sHxC6e3cqIOcs5zw7fU+kf3pOVZpyyfjtUM8bT0JVazDUTIitM1MzmJYmxf7ek6BorfaB/RQ2Mw1wOLBqzmsMWneIIz1kOnp4d3t+6svOd/HmM+zcc3lX+aPf5IU/R476n9NHk1IKG1E/nbjj83id5tBvIbwPkjJHCLxusk5nANfcK4J1hO4ZEzb1C+eOlEnFPCsYY1Qwf92rlv6lpEhiP0QJxf0zym5orgXoE5tp8rJw3Vi9jBHizhkAvJwnE/RmJXq4C6gWYa/MZgV7GCfDmSwK9nCwQ91ckepkN1Asw1+YrAr1MEODNtwR6OUUg7u9I9HI1UC/AXJvvCPRymgBvfiTQy0SBuNeS6OUaoF6AuTZrCfRyhgBv1hHo5UyBuNeT6OVaoF6AuTbrCfRytgBvNhDoZZJA3BtJ9HIdUC/AXJuNBHo5R4A3fxDo5VyBuDeR6OV6oF6AuTabCPQyVYA3fxHo5TyBuGNDOfQyB6gXYK4NGj8JvVwgwJtKyuO2epkmEHcOiV5uAOoFmGuTQ6CXiwR4k0+gl4sF4q5MopcbgXoB5tpUJtDLDAHeVCPQyyUCcVcn0ctNQL0Ac22qE+jlMgHe1CLQy0yBuGuT6OVmoF6AuTa1CfQyS4A39Qj0coVA3AUkerkFqBdgrk0BgV6uEuBNfQK9zBaIuwGJXuYC9QLMtWlAoJdrBHjTmEAv1wrE3YREL/OAegHm2iDxs/9tyalZJf/1ov0Og30u2z5rap+fs88E2ecc7O9u7e+j7D12e9/Q3gux/s72rLYO27XF4pUTjpd6oGKPxoNzPQ/PSe3/c5LIQnm9wILRnGChnCMQd4JkobwVuFACc20SBI3FjQK82ZZALzcJxL0diV5uA+oFmGuzHYFebhHgzQ4EepkrEPeOJHqZD9QLMNdmRwK93CrAm50J9HKbQNy7kOhlAVAvwFybXQj0skCAN20I9HK7QNxJEr3cDtQLMNcmSaCXOwV4045AL3cJxN2eRC93APUCzLVpT6CXewR405FAL/cKxN2JRC93AvUCzLXpRKCXRQK82ZNAL/cJxL0XiV7uAuoFmGuzF4FeHhDgzb4EelksEHcXEr3cDdQLMNemC4FelgjwpjuBXh4SiHs/Er3cA9QLMNdmPwK9PCLAmx4EelkqEPeBJHq5F6gXYK7NgQR6eUyANz0J9PK4QNyHkOhlIVAvwFybQwj08oQAbw4l0MuTAnH3IdHLIqBegLk2fQj08rQAb/oR6OUZgbgPJ9HLfUC9AHNtDifQy7MCvDmKQC/PCcR9NIle7gfqBZhrczSBXp4X4E1/Ar28IBD3ABK9PADUCzDXBomf/eLTac4Xn+x3GOxz2fZZU/v8nH0myD7nYH93a38fZe+x2/uG9l6I9Xe2Z7V12K4tD4S7QaJ5mG4rct/8DiwnHib/+/G3LdN9Y14M5DQSv5yQh6kHaq7ReBXxC3PAnJfeCRctyAebYwkl+A1MsWQ92Fz/HJdIEQpdwR+qIFuRpUu0L34PA/FjFeTDBIJ8hEWQSyvIXmfpEu2L36M4/NqyCvJRAkE+xiLIxyvIZmrpEu2L3zIcfu1YBbmMQJBPsAjyyQqyW1u6RPvi9xQOv/asgnyKQJBPswjymQqyHVy6RPvitxyHXwdWQS4nEOSzLIJ8roLsN5cu0b74rcDhtzurIFcQCPJ5FkG+UEE2tEuXaF/8VuLw68gqyJUEgnyRRZAvVZAd89Il2he/l3H4dWIV5MsEglzFIshXKsiWfOkS7Yvfqzj8OrMK8lUCQb7GIsjXK8ief+kS7YvfGzj8BrEK8g0CQb7JIsi3KsimgukS7Yvf2zj8BrMK8m0CQb7DIsh3K8iuhekS7Yvfezj8hrAK8j0CQb7PIsgPKsi2iOkS7Yvfhzj8hrIK8kMCQX7EIsjVQEFq3ncxXaJ98fsYh18RqyA/JhDkJyyC/BQoSM0bO6ZLtC9+a3D4FbMKcg2BID9jEeTnQEFq3TnSxQ8tyC/A34c8jVCQXxAI8ksWQX5VQXYoTJdoX/y+Bn8fklGQXxMI8hsWQX5bQbZATJdoX/y+A38fklGQ3xEI8nsWQf5QQfZYTJdoX/x+BH8fklGQPxIIci2LIH+qIJs4pku0L34/g78PySjInwkEuY5FkOsryC6R6RLti98v4O9DMgryFwJB/soiyA0VZBvKdIn2xW8j+PuQjILcSCDI31gE+TtQkJr3uUyXaF/8/gB/H5JRkH8QCHITiyD/BApS80aa6RLti99m8PchGQW5mUCQf7EIMpbABa15p850ifbFLwuHX2dWQQIxEJtjdoJEkJVwE1W9FWi6RPvil4PDbxCrIIEYiM0xN0EiyDzcRFXvNZou0b745ePwG8wqSCAGYnOsnCARZBXcRFVvZpou0b74VcXhN4RVkEAMxOZYLUEiyOq4iareLTVdon3xq4HDbyirIIEYiM2xZoJEkLVwE1W9HWu6RPviVxuHXxGrIIEYiM2xToJEkHVxE1W932u6RPviVw+HXzGrIIEYiM2xIEEiyDhuomo3lJVI8KRgjJUCGxEPItiA+UWBuAfr3/jWHuYC4Fhurn3xG0KygfU2CRx+QM4YFvzqJ2T4l/Q7zGDhdcv719PBGDMExh2mfL22MV8qEPdwIb1kg+MH5scgY7b5yIuVrA+XBH82h7myPy8Lf9qjQSIWaxj8CUpvbGJWCUbR9Wis6Pqs8N/a16MxGgXnjcMxTnfGiK7/m/k0Cd7fNBzrDGes6Hq6+TRx5tMsOG8ejnGmM0Z0PXWMmeEYzcIxrHlJBOctwjHOcsaIrqeOcXk4RiIcw8baMjjfNhzjbGeM6Lo90NpplrcVd/S4I5WvwdvmbcUVPe4okt5xbh/cWCOBveNoEvxuA+I3CojfiSS943YJHH5AzhgkfhazMu5pwfsqIJZJd76tEiXnOeHP7DI4kScQUyzlc1JxrFnGNeiHSyTJAooed/sETpRScds5gnMkurjfq7Q4nkxSHBcqLY7jSYrjDgkcfkDOmPGExRGIZaniuGOi5DxTHD3HtEmygKLHbZ3QXRxt3HaO4ByJzHV6wdZCjnbMOyUqZtynKr9DYnm5k0Dcp5E0Me7akfQ7zKnAJmYiSROzMxA/IGfMRBL+PabUhJxFgt/jSk3I2ST63SWBww/IGXM2oQkBYlnKhOyaKDnPmBDPMW2SLKDocXdL6DYhNm47R3COROY6K2jGd07gm9JzlD86cU2BTDN+LkkxapPAYQnMtTlXuYmzum4jwJvzSJpAd+1N+h2leOOL3/kk+AH5bc4D4ncBybqVTODwA3LGXEDCv1VKTfDFJPi9otQETyfRr0ng8ANyxkwnNMFALEuZ4LaJkvOMCfYc0ybJAooet11Ctwm2cds5gnMkMtc5gRlMJvBN/aXKTfDcAhkzcxlJMWqfwGEJzLW5TLkJtrpuL8CbWSRNoLv2Jv2OUrzxxe8KEvyA/DazgPhdSbJudUjg8ANyxlxJwr9PlJrga0jw+1SpCb6WRL+7J4C/yADq91pCEwzEspQJ7pgoOc+YYM8xbZIsoOhxOyV0m2Abt50jOEcic50fmMEOCXxTP0e5Cb67QMbM3EBSjDongDdSgMXoBuUm2Oq6swBvbiZpAt21N+l3lOKNL363kOAH5Le5GYjfXJJ1a48EDj8gZ8xcEv6tU2qC55Pgt16pCV5Aot89E8DeFajfBYQmGIhlKRO8V6LkPGOCPce0SbKAosfdO6HbBNu47RzBORKZ66LADO6RwDf1dyo3wUsKZMzMXSTFaJ8EDktgrs1dyk2w1fU+Ary5l6QJdNfepN9Rije++C0kwQ/Ib3MvEL9FJOvWvgkcfkDOmEUk/Mvtq9MELybBLw+IH9IEP0ii3y4JHH5AzpgHCU0wEMtSJrhrouQ8Y4I9x7RJsoCix+2W0G2Cbdx2juAcicx1aWAG903gm/qHlZvgJwtkzMwjJMWoewKHJTDX5hHlJtjqursAbx4jaQLdtTfpd5TijS9+j5PgB+S3eQyI3zKSdWu/BA4/IGfMMhL+1Vdqgp8mwa+BUhP8DIl+90/g8ANyxjxDaIKBWJYywQckSs4zJthzTJskCyh63B4J3SbYxm3nCM6RyFyXB2ZwvwS+qX9OuQleWSBjZlaQFKMDEzgsgbk2K5SbYKvrAwV4s5KkCXTX3qTfUYo3vvi9SIIfkN9mJRC/l0jWrYMSOPyAnDEvkfCvtVIT/CoJfjspNcGvkej34AQOPyBnzGuEJhiIZSkT3DNRcp4xwZ5j2iRZQNHjHpLQbYJt3HaO4ByJzHVVYAYPSuCb+jeVm+A3C2TMzFskxahXAoglsBi9pdwEW133EuDNuyRNoLv2Jv2OUrzxxe89EvyA/DbvAvF7n2Td6p3A4QfkjHmfhH97KjXBq0nw20upCf6YRL+HJnD4ATljPiY0wUAsS5ngPomS84wJ9hzTJskCih63b0K3CbZx2zmCcyQy13cDM9g7gW/q1yg3wasLZMzMZyTF6LAEDktgrs1nyk2w1fVhArz5kqQJdNfepN9Rije++H1Fgh+Q3+ZLIH5fk6xb/RI4/ICcMV+T8K+XUhP8PQl+vZWa4B9I9Ht4AocfkDPmB0ITDMSylAk+IlFynjHBnmPaJFlA0eMemdBtgm3cdo7gHInMdU1gBvsl8E39T8pN8NcFMmbmZ5JidFQChyUw1+Zn5SbY6vooAd78QtIEumtv0u8oxRtf/H4lwQ/Ib/MLEL8NJOvW0QkcfkDOmA0k/Buo1AT/QYJfoVITvIlEv8ckcPgBOWM2EZpgIJalTPCxiZLzjAn2HNMmyQKKHrd/QrcJtnHbOYJzJDLX7wMzeHQC39T/pdwEryuQMTOxIo5iNCCBwxKYa4PGD51fq+sBArypVE68SfodpdbepN9Rije++OWQ4Afkt3E544tfLsm6dVwChx+QMyaXhH9jlZrgKiT4jVNqgquS6Pf4BA4/IGcMEr/yMsFALEuZ4IGJkvOMCfYc0ybJAooetzCh2wTbuO0cwTkSmeuGwAwel8A39TWKdMf9Z4GMmalJUowGJXBYAnNtaio3wVbXgwR4U4ekCXTX3qTfUYo3vvjVJcEPyG9TB4hfPZJ1a3AChx+QM6YeCf+mKDXB9Unwm6rUBDcg0e+QBA4/IGdMA0ITDMSylAkemig5z5hgzzFtkiyg6HGLErpNsI3bzhGcI5G5ZsVjscEJfFPfWLkJzo/LmJkmJMWoOIHDEphr00S5Cba6LhbgTXOSJtBde5N+Ryne+OKXIMEPyG/THIhfC5J1a1gChx+QM6YFCf+uVGqCW5Hgd5VSE7w9iX6HJ3D4ATljtic0wUAsS5ngEYmS84wJ9hzTJskCih73hIRuE2zjtnME50hkrtUCMzgsgW/qWys3wXXiMmZmJ5JiNDKBwxKYa7OTchNsdT1SgDe7kjSB7tqb9DtK8cYXv91I8APy2+wKxK8Nybo1KoHDD8gZ04aEf/OVmuB2JPgtUGqC25Pod3QChx+QM6Y9oQkGYlnKBJ+YKDnPmGDPMW2SLKDoccckdJtgG7edIzhHInONB2ZwVALf1HdUboIbx2XMTCeSYnRSAoclMNemk3ITbHV9kgBv9iRpAt21N+l3lOKNL357keAH5LfZE4jf3iTr1tgEDj8gZ8zeJPx7WKkJ7kqC3yNKTXA3Ev2OS+DwA3LGdCM0wUAsS5ngkxMl5xkT7DmmTZIFFD3u+IRuE2zjtnME50hkrs0DMzg2gW/q91duglvFZczMASTFaEIChyUw1+YA5SbY6nqCAG8OImkC3bU36XeU4o0vfgeT4AfktzkIiF9PknXrlAQOPyBnTE8S/q1UaoIPJcHvRaUmuA+Jfk9N4PADcsb0ITTBQCxLmeDTEiXnGRPsOaZNkgUUPe7EhG4TbOO2cwTnSGSurQMzeEoC39T3U26C28RlzMzhJMXo9AQOS2CuzeHKTbDV9ekCvDmKpAl0196k31GKN95b55DgB+S3OQqI3zEk69YZCRx+QM6YY0j496FSE3wcCX4fKTXBx5Po98wEDj8gZ8zxhCYYiGUpE3xWouQ8Y4I9x7RJsoCixz07odsE27jtHME5Eplru8AMnpHAN/WDlJvgznEZMzOYpBhNSuCwBObaDFZugq2uJwnwpoikCXTX3qTfUYo33v/RGwl+QH6bIiB+w0jWrckJHH5AzphhJPz7UakJHkmC31qlJngUiX7PSQD5B9TvKEITDMSylAk+N1FynjHBnmPaJFlA0eNOSeg2wTZuO0dwjkTmundgBicnBL47qdwEd4/LmJmTSIrR1AQOS2CuzUnKTbDV9VQB3pzMssVKQoY33o+pk+AH5Lc5GYjfBJJ167wEDj8gZ8wEEv5lHabTBE8kwS8biB/SBJ9Oot/zE8CnkoD6PZ3QBAOxLGWCL0iUnGdMsOeYNkkWUPS40xK6TbCN284RnCORufYIzOB5CXxTf5ZyE9wrLmNmziYpRhcmcFgCc23OVm6Cra4vFODNOSRNoLv2Jv2OUrzxxe9clt+kA7VyDhC/KSTr1kUJHH5AzpgpJPyrp9QEX0CCX4FSEzyNRL8XJ3D4ATljphGaYCCWpUzw9ETJecYEe45pk2QBRY87I6HbBNu47RzBORKZa9/ADF6UwDf1Fys3wUfFZczMdJJidEkCyHdgMZqu3ARbXV8iwJtLSZpAd+1N+h2leOOL32Uk+AH5bS4F4jeTZN26NIHDD8gZM5OEf62UmuArSfDbXqkJvopEv5clcPgBOWOuIjTBQCxLmeCZiZLzjAn2HNMmyQKKHvfyhG4TbOO2cwTnSGSu/QMzeGkC39Rfo9wED4rLmJlrSYrRrAQOS2CuzbXKTbDV9SwB3swhaQLdtTfpd5TijS9+N5DgB+S3mQPE70aSdeuKBA4/IGfMjST866jUBM9l2eJMqQmeR6LfKxM4/ICcMfMITTAQy1Im+KpEyXnGBHuOaZNkAUWPOzuh2wTbuO0cwTkSmWtRYAavSOCb+vnKTfDIuIyZWUBSjK5O4LAE5tosUG6Cra6vFuDNnSRNoLv2Jv2OUrzxxe8uEvyA/DZ3AvG7m2TduiaBww/IGXM3Cf8OUmqCF5Hgd7BSE3wfiX6vTeDwA3LG3EdogoFYljLB1yVKzjMm2HNMmyQLKHrc6xO6TbCN284RnCORuY4JzOA1CXxTv1i5CZ4QlzEzD5IUozkJHJbAXJsHlZtgq+s5Arx5mKQJdNfepN9Rije++D1Cgh+Q3+ZhIH5LSdatGxI4/ICcMUtJ+NdfqQleRoLfAKUm+AkS/d6YwOEH5Ix5gtAEA7EsZYJvSpScZ0yw55g2SRZQ9Lg3J3SbYBu3nSM4RyJznRiYwRsS+Kb+aeUmeFJcxsw8Q1KMbkngsATm2jyj3ATfHOB2iwBvniNpAm8W4o0vfitI8APy2zwHxO95knVrbgKHH5Az5nkS/o1WaoJfIsHvRKUm+GUS/c5L4PADcsa8TGiCgViWMsG3JkrOMybYc0ybJAsoetzbErpNsI3bzhGcI5G5TgnM4NwEvql/VbkJvjAuY2ZeIylG8xM4LIG5Nq8pN8FW1/MFePMmSRPorr1Jv6MUb3zxe4sEPyC/zZtA/N4mWbcWJHD4ATlj3ibh3ySlJvh9EvwmKzXBH5Do9/YEDj8gZ8wHhCYYiGUpE3xHouQ8Y4I9x7RJsoCix70zodsE27jtHME5EpnrjMAMLkjgm/rVyk3wrLiMmfmYpBjdlcBhCcy1+Vi5Cba6vkuAN2tImkB37U36HaV444vfZyT4Aflt1gDx+5xk3bo7gcMPyBnzOQn/Zio1wV+z/MeASk3wNyT6vSeBww/IGfMNoQkGYlnKBN+bKDnPmGDPMW2SLKDocRcmdJtgG7edIzhHInOdHZjBuxP4pv575SZ4TlzGzPxAUowWJXBYAnNtflBugq2uFwnw5ieSJtBde5N+Ryne+OL3Mwl+QH6bn4D4rSNZt+5L4PADcsasI+HfXKUmeAMJfvOUmuCNJPq9P4HDD8gZs5HQBAOxLGWCH0iUnGdMsOeYNkkWUPS4ixO6TbCN284RnCORud4cmMH7Evim/g/lJnh+XMbMbCIpRg8mcFgCc202KTfBVtcPCvDmL5Im0F17k35HKd54r+PFHPgB+W3+AuKXVcyxbi1JAHseXMwmi4R/i5Wa4FwS/B5UaoLzSPT7UAKHH5AzBolfeZlgIJalTPDDiZLzjAn2HNMmyQKKHveRhG4TbOO2cwTnSGSudwZmcEkC39RXKdYd96K4jJmpSlKMliZwWAJzbaoK88b7fyEOcFsqwJsaJE2gu/Ym/Y5SvPHFryYJfkB+mxpA/GqRrFuPJnD4ATljapHw7zmlJrgeCX4rlJrgAhL9PpbA4QfkjCkgNMFALEuZ4McTJecZE+w5pk2SBRQ97rKEbhNs47ZzBOdIZK6LAzP4aALf1NdXboKXxmXMTAOSYvREAoclMNemgXITbHX9hABvGpM0ge7am/Q7SvHGF78mJPgB+W0aA/FrSrJuPZnA4QfkjGmqvN4tC+qdxQ69brVQHvfyuMx63ZJEL08lcFgCc21aKufNjGCMpwR4MwM3xy3GNc/hzCXBn83Bn0vDn5eFP+3xdBDLM8Gf3OB8UlaJqY2uR2NF12eF/9a+Ho2xPDh/NhxjsjNGdP3fzOe54P0rwrHOccaKrqebz3POfJ4Pzl8IxzjXGSO6njrGzHCM58MxrMFfGZy/GI4xxRkjup46xuXhGCvDMWysLwXnL4djTHXGiK6X102RS3FjJbOdea5KbP35SqLk2hHhzyqx0jdIYiFeMWxsSYEbLkmbr3wnjujIdq5Fnxlx2t6EqVbGe13ed8HMz6RypotzHn2WO5es//FcXLxizrVKKVi5nIles7no7byeU8a/id6bU8b73NhzBWJ3P6eL8/fos6o6c8hRMJfsMuaSh53Llrob6ScWK31zNJpHNKd857XKYEzsGFXKmEdlZx6pOs8LrwPn0daOUa2MeVR1fkafX82ZR3XsPNpVSZmHPf5Jv9WdudTAzmULR2o6nxXNq4bz9+j1XGceNbHz2KKbGinxR3935/d/nWs+0Vyr/I/nKsCrYjtmLeyYbavESmNqj3/STS0nvtrYubSzmsyPleQ1Gj8VW7f/kFjf6zrxuvm0h13P6oTn7vui8xzndbfeR6/v68Rkx6yHnf+WfLrzssc/5TP6fFs3ojVxWNH4fkVDxhWN71k0McsZo25KXG4PnOucu+uERH7izmfVdT7LHjY/BeF53HlNov5uU8Y83PobfX70virOeYFzrX7KfN1e0f23UW2N3p8fxpaDja2d+1nR8U8cynFidzjUZ8LgUSOGpHAoGrdSGeO6fW9uyvtcTNz+Kit1gl1iEBAM8qaFxPya5W29CYG+WdNK+U2qbfO23mRAx709yc3NVxM4LIG5Nkj8Um+q2ZjtjadV4c9XEiU3xF4Lzl9PbF0UznNuREXX/80NujeC978ZjnW+M1Z0Pd0Nujec+bwVnL8djnGBM0Z0vVLs74urPdA6OTgmw2f0PG2ekPOUWGffSkDHLW7ftn3SrmOouN0i+k6i5Dwqxv+vm0tZzjXmG5uVnThiKfHWDF+PGt4Tx4wfUTyx94RRo0YUjyga2nvM+CIXxtT+wx0q9bp7by4v5d+7kEavVei+xc7P5Shyrukw9a257yb+81jJlLFMef1ixJ1z0vNw5/teouQ887So55g2SRZQ9LjvJ3Dkl4rbzhGcI7EFS2Ku5dUIJj0ajeLSR7KM6f7XsU3qBUkMkEXRXew+SGz9+WGi5FrUfGTH/l753TsgdvHsVkbMWc55dvieSv/wnqw045T126GaMZ6GrtRirpkQWWGiLBmixNi/W1J0jZU+0L+iBsZh7HyjsXyLxkcJ2KJTHOH5kYOnZ4f3t65shpM/j3H/hkNr5Y92zwh5ih53J6WPJqcWNKR+Xu+Gw29nkke7gfw2QM4YKfyywTqxaw5qrNUJ3WbHas3OUfPjpRJxnx+MsaQ5Pu42yn9T82hwD+whgbiTJL+p+TiBwxKYa5NUzhurl0cEeNOOQC9LBeJuT6KXTxI4LIG5Nu0J9PKYAG86EujlcYG4O5Ho5dMEDktgrk0nAr08IcCbPQn08qRA3HuR6GVNAoclMNdmLwK9PC3Am30J9PKMQNxdSPTyWQKHJTDXpguBXp4V4E13Ar08JxD3fiR6+TyBwxKYa7MfgV6eF+BNDwK9vCAQ94EkevkigcMSmGtzIIFeXhTgTU8CvbwkEPchJHr5MoHDEphrcwiBXlYJ8OZQAr28IhB3HxK9fJXAYQnMtelDoJfXBHjTj0AvrwvEfTiJXr5O4LAE5tocTqCXNwV4cxSBXt4SiPtoEr18k8BhCcy1OZpAL+8I8KY/gV7eFYh7AIlevk3gsATm2gwg0Mv7ArwZSKCXDwTiLiTRy3cJHJbAXJtCAr18JMCbIQR6WS0Q91ASvXyfwGEJzLUZSqCXTwR4M4xAL58KxD2cRC8/JHBYAnNthhPo5TMB3owk0MvnAnGPItHLjwkclsBcGyR+9r8tmZZV8l8v2u8wfBL8sc+a2ufn7DNB9jkH+7tb+/soe4/d3je090Ksv7M9q63Ddm2xeOWE46UeXUCxR+PBuZ6H56T2/zlJZKH8UmDBGEOwUH4lEPdJJAvl2gQOS2CuzUkEjcU3Arw5mUAv3wrEPZ5ELz8lcFgCc23GE+jlewHenEqglx8E4j6NRC8/J3BYAnNtTiPQy1oB3pxBoJefBOI+k0Qv6xI4LIG5NmcS6GWdAG8mEehlvUDck0n0sj6BwxKYazOZQC+/CvBmCoFeNgjEPZVEL78kcFgCc22mEujlNwHeXECgl98F4p5GopdfEzgsgbk20wj0skmANxcT6OVPgbink+hlQwKHJTDXZjqBXv4S4M2lBHqJJfBxX0ail40JHJbAXJvLCPSSncDzZhaBXioJxH0FiV5+S+CwBObaXEGgl9wEnjezCfSSJxD31SR6+T2BwxKYa3M1gV4qJ/C8uY5AL1UE4r6eRC9/JHBYAnNtrifQS7UEnjc3EuilukDcN5HoZVMChyUw1+YmAr3UTOB5M5dAL7UE4p5Hopc/Ezgsgbk28wj0UieB5818Ar3UFYh7AYleNidwWAJzbRYQ6KUggefNnQR6iQvEfReJXv5K4LAE5tog8bO/MrjQ+eKT/Q6DfS7bPmtqn5+zzwTZ5xzs727t76PsPXZ739DeC7H+zvastg7btcXiJcHDdFuR++b33nLiYfK/H3/bMt17V9sWuLwg8csJeZh6oOYajVcRvzAHzHnpnXDRgsxqgSWU4DcwxZKV1UL/HLOlCIWu4JWAq53mrcjSJdoXvxwgfqyCzCEQZC6LIPOAhNK811m6RPvil4/Dry2rIPMJBFmZRZBVgILUvJlaukT74lcVh187VkFWJRBkNRZBVgcKUvNubekS7YtfDRx+7VkFWYNAkDVZBFkLKEjN28GlS7QvfrVx+HVgFWRtAkHWYRFkXaAgNe83ly7RvvjVw+G3O6sg6xEIsoBFkHGgIDVvaJcu0b74bYPDryOrILchEGR9FkE2AApS84556RLti19DHH6dWAXZkECQjVgE2RgoSM1b8qVLtC9+TXD4dWYVZBMCQTZlEWQzoCA17/mXLtG++DXH4TeIVZDNCQSZYBFkC6AgNW8qmC7Rvvi1xOE3mFWQLQkEuS2LILcDClLzroXpEu2LXyscfkNYBdmKQJDbswhyB6AgNW+LmC7RvvjtiMNvKKsgdyQQZGsWQe4EFKTmfRfTJdoXv51x+BWxCnJnAkHuwiLIXYGC1LyxY7pE++K3Gw6/YlZB7kYgyDYsgkwCBal150gXP7QgDTDRwl+wFSO7IRBkWxZBtgMKUvMOhekS7YtfeyB+rIJsTyDIDiyC3B1IKM1bIKZLtC9+HXH4tWUVZEcCQXZiEWRnoCA177GYLtG++O2Bw68dqyD3IBDkniyC3AsoSM2bOKZLtC9+e+Pwa88qyL0JBLkPiyD3BQpS8y6R6RLti18XHH4dWAXZhUCQXVkE2Q0oSM3bUKZLtC9+3XH47c4qyO4EgtyPRZD7AwWpeZ/LdIn2xe8AHH4dWQV5AIEge7AI8kCgIDVvpJku0b74HYTDrxOrIA8iEOTBLILsCRSk5p060yXaF79DcPh1ZhXkIQSC7MUiyN5AQWreCjRdon3xOxSH3yBWQR5KIMg+LILsCxSk5r1G0yXaF7/DcPgNZhXkYQSC7MciyMOBgtS8mWm6RPvidwQOvyGsgjyCQJBHsgjyKKAgNe+Wmi7RvvgdjcNvKKsgjyYQ5DEsgjwWKEjN27GmS7Qvfv1x+BWxCrI/gSAHsAjyOKAgNe/3mi7Rvvgdj8OvmFWQxxMIciCLIAuBgtS6oaxEgs8PxtgmgRf4IoINmOsLxH2f/o1v7WEuAY7l5toXv/tJNrAeBFxvgJwxLPgNbiHDv6TfYe4TXre89/ENxrhCYNwlytdrG/NVAnE/JKSXbHD8wPwYZMw2H3mxkvXhyuDP5jBX9ufs8Kc9hgSaHxr8CUpv7KKsEoyi69FY0fVrw39rX4/GKArOi8MxLnbGiK7/m/kMC94/PBxrujNWdD3dfIY58xkRnJ8QjjHDGSO6njrG1eEYI8IxrHkZGZyPCse4xBkjup46xjXhGCPDMWyso4PzE8MxLnXGiK7bA62dx/O24o4ed6nyNfjpvK24osd9lKR3nNsHN9ZSYO/4GAl+twHxexSI3+MkveMYYO8I5IxB4mcxK+OeFryvAmKZdOd7UouS85zwZ3YZnMgTiCmW8jmpONYs4xr0wyWSdFIL/LhjW+BEKRX32BbwHIku7vcqLY5PkxTHhUqL4zMkxXEcsDgCOWOeISyO44SK48mZ4ohN0skCxXG88uJo4x4vVBzRc51esLWQox3zhBYVM+7nlN8hsbycIBD3CpImZjywCD8HbGKeJ2liTgHiB+SMeZ6Ef48pNSEvkeD3uFIT8jKJfk8F6hfIGfMyoQk5VciEnJYxIdgknSZgQiYqNyE27okkJmRW0IyfItCUvqr80YlrCmSa8ddIitHpwGIEzLV5TbmJs7o+XYA3b5I0gROFeOOL31sk+AH5bd4E4vc2ybp1BpB/QM6Yt0n4t0qpCX6fBL9XlJrgD0j0eyZQv0DOmA8ITfCZQib4rIwJxibpLAETfLZyE2zjPpvEBM8JzOAZAk39auUmeG6BjJn5mKQYTQIWI2CuzcfKTbDV9SQB3qwhaQLPFuKNL36fkeAH5LdZA8Tvc5J1azKQf0DOmM9J+PeJUhP8NQl+nyo1wd+Q6PccoH6BnDHfEJrgc4RM8LkZE4xN0rkCJniKchNs455CYoLnB2ZwskBT/71yE3x3gYyZ+YGkGE0FFiNgrs0Pyk2w1fVUAd78RNIEThHijS9+P5PgB+S3+QmI3zqSdes8IP+AnDHrSPi3TqkJ3kCC33qlJngjiX7PB+oXyBmzkdAEny9kgi/ImGBski4QMMHTlJtgG/c0EhO8KDCD5wk09X8oN8FLCmTMzCaSYnQhsBgBc202KTfBVtcXCvDmL5ImcJoQb7zX8WEc+AH5bf4C4pc1jGPdugjIPyBnTBYJ/3L76jTBuST45QHxQ5rgPBL9XgzUL5AzBolfeZngi4VM8PSMCcYmabqACZ6h3ATbuGeQmOClgRm8SKCprzJMd9xPFsiYmaokxegSYDEC5tpUFeaNL25W15cI8KYGSRM4Q4g3vvjVJMEPyG9TA4hfLZJ161Ig/4CcMbVI+FdfqQmuR4JfA6UmuIBEv5cB9QvkjCkgNMGXCZngmRkTjE3STAETfLlyE2zjvpzEBC8PzOClAk19feUmeGWBjJlpQFKMZgGLETDXpoFyE2x1PUuAN41JmsDLhXjji18TliYaqJXGQPyakqxbVwD5B+SMaUrCv9ZKTXALEvx2UmqCW5Lo90qgfoGcMS0JTfCVQib4qowJxibpKgETPFu5CbZxzyYxwasCM3iFQFPfSrkJfrNAxsxsT1KMrgYWI2CuzfbKTbDV9dUCvGlN0gTOFuKNL347keAH5LdpDcRvZ5J16xog/4CcMTuT8G9PpSa4DQl+eyk1wUkS/V4L1C+QMyZJaIKvFTLB12VMMDZJ1wmY4OuVm2Ab9/UkJvjdwAxeI9DUt1NuglcXyJiZ9iTFaA6wGAFzbdorN8FW13MEeNORpAm8Xog3vvh1IsEPyG/TEYhfZ5J16wYg/4CcMZ1J+NdLqQnemwS/3kpN8D4k+r0RqF8gZ8w+hCb4RiETfFPGBGOTdJOACb5ZuQm2cd9MYoLXBGbwBoGmvqtyE/x1gYyZ6UZSjG4BFiNgrk035SbY6voWAd7sT9IE3izEG1/8DiDBD8hvsz8Qvx4k69ZcIP+AnDE9SPg3UKkJ7kmCX6FSE3wIiX7nAfUL5Iw5hNAEzxMywbdmTDA2SbcKmODblJtgG/dtJCb4+8AMzhVo6g9VboLXFciYmT4kxWg+sBgBc236KDfBVtfzBXjTj6QJvE2IN774HU6CH5Dfph8QvyNI1q0FQP4BOWOOIOHfWKUm+BgS/MYpNcHHkuj3dqB+gZwxxxKa4NuFTPAdGROMTdIdAib4TuUm2MZ9J4kJ3hCYwQUCTf1xyk3wnwUyZuZ4kmJ0F7AYAXNtjldugq2u7xLgzSCSJvBOId744jeYBD8gv80gIH5DSNatu4H8A3LGDCHh3xSlJngYCX5TlZrg4ST6vQeoXyBnzHBCE3yPkAm+N2OCsUm6V8AEL1Rugm3cC0lMcFY8FrtboKkfqdwE58dlzMwokmK0CFiMgLk2o5SbYKvrRQK8GUPSBC4U4o0vfieR4AfktxkDxG8sybp1H5B/QM6YsST8u1KpCZ5Agt9VSk3wKST6vR+oXyBnzCmEJvh+IRP8QMYEY5P0gIAJXqzcBNu4F5OY4GqBGbxPoKmfqNwE14nLmJnTSYrRg8BiBMy1OV25Cba6flCAN2eRNIGLhXjji9/ZJPgB+W3OAuI3iWTdWgLkH5AzZhIJ/+YrNcFTSPBboNQETyXR70NA/QI5Y6YSmuCHhEzwwxkTjE3SwwIm+BHlJtjG/QiJCY4HZnCJQFN/gXIT3DguY2amkRSjpcBiBMy1mabcBFtdLxXgzcUkTeAjQrzxxW86CX5AfpuLgfjNIFm3HgXyD8gZM4OEfw8rNcEzWdY/pSb4chL9PgbUL5Az5nJCE/yYkAl+PGOCsUl6XMAEL1Nugm3cy0hMcPPADD4q0NRfqdwEt4rLmJmrSIrRE8BiBMy1uUq5Cba6fkKAN9eQNIHLhHjjvf8ky+OUQK1cA8TvOpJ160kg/4CcMdeR8G+lUhN8Iwl+Lyo1wTeR6PcpoH6BnDE3EZrgp4RM8NMZE4xN0tMCJvgZ5SbYxv0MiQluHZjBJwWa+rnKTXCbuIyZmUdSjJYDixEw12aechNsdb1cgDfzSZrAZ4R44/2/BpPgB+S3mQ/E73aSdetZIP+AnDG3k/DvQ6Um+G4S/D5SaoLvIdHvc0D9Ajlj7iE0wc8JmeAVGROMTdIKARP8vHITbON+nsQEtwvM4LMCTf0i5Sa4c1zGzNxHUoxeABYjYK7NfcpNsNX1CwK8WUzSBD4vxBvv77iT4Afkt1kMxG8Jybq1Esg/IGfMEhL+/ajUBC8lwW+tUhP8KIl+XwTqF8gZ8yihCX5RyAS/lDHB2CS9JGCCX1Zugm3cL5OY4L0DM7hSoKlfptwEd4/LmJknSIrRKmAxAubaPKHcBFtdrxLgzdMkTeDLQrzx/g09CX5AfpungfgtJ1m3XgHyD8gZs5yEf1mH6TTBz5Pglw3ED2mCXyDR76tA/QI5Y14gNMGvCpng1zImGJuk1wRM8OvKTbCN+3USE9wjMIOvCDT1Lyk3wb3iMmbmZZJi9AawGAFzbV5WboKtrt8Q4M2rJE3g60K88cXvNZabCECtvArE73WSdetNIP+AnDGvk/CvnlIT/DYJfgVKTfA7JPp9C6hfIGfMO4Qm+C0hE/x2xgRjk/S2gAl+R7kJtnG/Q2KC+wZm8E2Bpv595Sb4qLiMmfmApBi9CyxGwFybD5SbYKvrdwV4s5qkCXxHiDe++H1Mgh+Q32Y1EL9PSNat94D8A3LGfELCv1ZKTfDnJPhtr9QEf0Gi3/eB+gVyxnxBaILfFzLBH2RMMDZJHwiY4A+Vm2Ab94ckJrh/YAbfE2jqv1ZuggfFZczMNyTF6CNgMQLm2nyj3ARbXX8kwJvvWf5jHSHe+OL3Awl+QH6b74H4/Uiybq0G8g/IGfMjCf86KjXB60jw66TUBK8n0e/HQP0COWPWE5rgj4VM8CcZE4xN0icCJvhT5SbYxv0piQkuCszgaoGmfoNyEzwyLmNmNpIUozXAYgTMtdmo3ARbXa8R4M0fJE3gp0K88cVvEwl+QH6bP4D4/Umybn0G5B+QM+ZPEv4dpNQEZw3nwO9gpSY4eziHfj8H6hfIGYPEr7xM8OdCJviLjAnGJukLARP8pXITbOP+ksQEjwnM4GcCTX3ucN1xT4jLmJk8kmL0FbAYAXNt8oR544ub1fVXArypQtIEfinEG1/8qpLgB+S3qQLErxrJuvU1kH9AzphqJPzrr9QE1yLBb4BSE1ybRL/fAPUL5IypTWiCvxEywd9mTDA2Sd8KmODvlJtgG/d3JCZ4YmAGvxZo6uspN8GT4jJmpoCkGH0PLEbAXJsC5SbY6vp7Ad7UJ2kCvxPijS9+DUjwA/Lb1Afi15Bk3foByD8gZ0xDEv6NVmqCm5Lgd6JSE9yMRL8/AvUL5IxpRmiCfxQywWszJhibpLUCJvgn5SbYxv0TiQmeEpjBHwSa+hbKTfCFcRkz05KkGP0MLEbAXJuWyk2w1fXPArxpRdIE/iTEG1/8tifBD8hv0wqI3w4k69Y6IP+AnDE7kPBvklITvDMJfpOVmuBdSPS7HqhfIGfMLoQmeL2QCf4lY4KxSfpFwAT/qtwE27h/JTHBMwIzuE6gqW+j3ATPisuYmSRJMdoALEbAXJukchNsdb1BgDftSJrAX4V444tfexL8gPw27YD4dSBZtzYC+QfkjOlAwr+ZSk1wZxL8Lldqgvcg0e9vQP0COWP2IDTBvwmZ4N8zJhibpN8FTPAfyk2wjfsPEhM8OzCDGwWa+r2Vm+A5cRkzsw9JMdoELEbAXJt9lJtgq+tNArzpStIE/iHEG1/8upHgB+S36QrErzvJuvUnkH9AzpjuJPybq9QE9yDBb55SE3wgiX43A/UL5Iw5kNAEbxYywX9lTDA2SX8JmOBYS90m2MZt5wjOkchcbw7M4J8CTX1P5SZ4flzGzBxCUoyyWuKwBObaHKLcBFtdW+zQ4x5K0gTGhHjji18fEvyA/DaHAvHrS7JuZQP5B+SM6UvCv8VKTfARJPg9qNQEH0mi30pA/QI5Y44kNMFALEuZ4BzHu2RMsOeYNkk5LfHj5io3wTbuXBITfGdgBrMFmvpjlJvgRXEZM3MsSTHKAxYjYK7NscpNsNV1ngBvjiNpAnOFeOOL3/Ek+AH5bY4D4jeQZN3KB/IPyBkzkIR/zyk1wUNI8Fuh1AQPJdFvZaB+gZwxQwlNMBDLUia4iuNdMibYc0ybpCoCJriqchNs465KYoIXB2YwX6CpH6bcBC+Ny5iZ4STFqBqwGAFzbYYrN8FW19UEeDOSpAmsKsQbX/xGkeAH5LcZCcRvNMm6VR3IPyBnzGjl9W5ZUO+qC6xbY5XHvTwus16PI9FLDaBegLk245Tz5opgjBoCvLkCN8ctxjXP4cyVwZ/NwZ+rwp+zw5/2qBnEUsv+ci44vyyrxNRG16OxouvXhv/Wvh6NUTs4rxOOMdMZI7r+b+ZTN3h/vXCsy52xouvp5lPXmU9BcB4Px5jljBFdTx3j6nCMgnAMa/C3Cc7rh2Nc4YwRXU8d45pwjG3CMWysDYLzhuEYVzpjRNfL66bIVbixktnOPBu13PqzccuSa0eEP6vESt8giYV4xbCxJQVuuCRtvvKdOKIj27kWfWbEaXsTploZ73V53wUzP5PKmS7OefRZ7lyy/sdzcfGKOdcqpWDlciZ6zeait/N6Thn/JnpvThnvc2PPFYjd/Zwuzt+jz6rqzCFHwVyyy5hLHnYuW+pupJ9YrPTN0Wge0ZzyndcqgzGxY1QpYx6VnXmk6jwvvA6cR1s7RrUy5lHV+Rl9fjVnHtWx82hXJWUe9vgn/VZ35lIDO5ctHKnpfFY0rxrO36PXc5151MTOY4tuaqTEH/3dnd//da75RHOt8j+eqwCviu2YtbBjtq0SK42pPf5JN7Wc+Gpj59LOajI/VpLXaPxUbN3+Q2J9r+vE6+bTHnY9qxOeu++LznOc1916H72+rxOTHbMedv5b8unOyx7/lM/o823diNbEYUXj+xUNGVc0vmfRxCxnjLopcbk9cK5z7q4TEvmJO59V1/kse9j8FITncec1ifq7TRnzcOtv9PnR+6o45wXOtfop83V7RfffRrU1en9+GFsONrZ27mdFxz9xKPr8FA71mTB41IghKRyKxq3kXIsOt+/NTXmfi4nbX/3//17iZghoLJGbNY/nbb0Jgb5ZM0H5Taqn87beZEDHfQrJzc0mwJubwFwbJH6pN9WahDeeGoU/G7csuSHWNDhvFt6Iusq5ERVd/zc36JoH70+EY812xoqup7tB19yZT4vgvGU4xtXOGNH1SrG/L672QOvk4JgMn9HzbNpS/zrboiV03OL2bdsn7TqGitstotu2LDmPivH/6+ZSlnPNberswXRjs7ITRywl3prh61HDe+KY8SOKJ/aeMGrUiOIRRUN7jxlf5MKY2n+4Q6Ved+/N5aX8exfS6LUK3bfY+bkcRc41Haa+NXe7lv95rGTKWKa8fjGyXUuZ9aWVk7vM06KeY9oktWqJH3f7ljjyS8W9vdAiILFgScy1vBrBVzwajeLSR7KM6f7XsU3qBUkMkEXRXex2CHmxo8OPqPnIjv298rt3QOzi2a2MmLOc8+zwPZX+4T1ZacYp67dDNWM8DV2pxVwzIbLCRO3QsiQx9u+WFF1jpQ/0r6iBcZgdgUWjdUvYolMc4dnawdOzw/tbV3aFkz+Pcf+Gw0Tlj3ZfEfIUPe7pSh9NTi1oSP2M7o7D7wySR7uB/DZAzhgp/LLBOtkBuObuhHN8ImbHam2nljJrGDLX6LhnWN60wMc9SflvagYEXWElgbgnk/ymZmegHoG5NpOV88bqJVeAN1MI9JInEPdUEr3sAtQLMNdmKoFeKgvw5gICvVQRiHsaiV52BeoFmGszjUAv1QR4czGBXqoLxD2dRC+7AfUCzLWZTqCXmgK8uZRAL7UE4r6MRC9tgHoB5tpcRqCXOgK8mUWgl7oCcV9BopckUC/AXJsrCPRSIMCb2QR6iQvEfTWJXgxQL8Bcm6sJ9FJfgDfXEeilgUDc15PopS1QL8Bcm+sJ9NJIgDc3EuilsUDcN5HopR1QL8Bcm5sI9NJUgDdzCfTSTCDueSR6aQ/UCzDXZh6BXhICvJlPoJcWAnEvINFLB6BegLk2Cwj0sq0Ab+4k0Mt2AnHfRaKX3YF6Aeba3EWgl+0FeHMvgV52EIh7IYleOgL1Asy1WUigl9YCvLmfQC87CcT9AIleOgH1Asy1eYBAL7sI8GYJgV52FYj7IRK9dAbqBZhr8xCBXtoI8GYpgV6SAnE/SqKXPYB6AebaIPGz/23JNVkl//Wi/Q6DfS7bPmtqn5+zzwTZ5xzs727t76PsPXZ739DeC7H+zvastg7btcXilROOl3qgYo/Gg3M9H89J9BzR/3OSyELZVmDBWEawULYTiPsJkoVyT+BCCcy1eYKgseggwJunCfSyu0Dcz5DoZS+gXoC5Ns8Q6KWTAG+eI9BLZ4G4V5DoZW+gXoC5NisI9LKnAG9WEuhlL4G4XyTRyz5AvQBzbV4k0Ms+ArxZRaCXfQXifoVEL/sC9QLMtXmFQC9dBXjzOoFeugnE/QaJXroA9QLMtXmDQC/7CfDmbQK97C8Q9zskeukK1Asw1+YdAr30EODN+wR6OVAg7g9I9NINqBdgrs0HBHo5WIA3qwn00lMg7o9J9NIdqBdgrs3HBHrpJcCbNQR66S0Q92cketkPqBdgrs1nBHrpI8CbLwn00lcg7q9I9LI/UC/AXJuvCPTST4A33xLo5XCBuL8j0csBQL0Ac22+I9DLkQK8+ZFAL0cJxL2WRC89gHoB5tqsJdDLMQK8WUegl2MF4l5PopcDgXoB5tqsJ9DLAAHebCDQy3ECcW8k0ctBQL0Ac202EuhloABv/iDQS6FA3JtI9HIwUC/AXBskfvaLT9c6X3yy32Gwz2XbZ03t83NbngkK/tjf3drfR9l77Pa+ob0XYv2d7VltHbZri8VLgofptiL3ze9f5cTD5H8//rZlum/MPYGcRuKXE/Iw9UDNNRqvIn5hDpjz0jvhogV5SEssoQS/gSmWrENa6p9jLylCoSt4b+Bqp3krsnSJ9sXvUCB+rII8lECQfVgE2RdIKM17naVLtC9+h+Hwa8sqyMMIBNmPRZCHAwWpeTO1dIn2xe8IHH7tWAV5BIEgj2QR5FFAQWrerS1don3xOxqHX3tWQR5NIMhjWAR5LFCQmreDS5doX/z64/DrwCrI/gSCHMAiyOOAgtS831y6RPvidzwOv91ZBXk8gSAHsgiyEChIzRvapUu0L36DcPh1ZBXkIAJBDmYR5BCgIDXvmJcu0b74DcXh14lVkEMJBFnEIshioCA1b8mXLtG++A3D4deZVZDDCAQ5nEWQI4CC1LznX7pE++J3Ag6/QayCPIFAkCNZBDkKKEjNmwqmS7QvfqNx+A1mFeRoAkGeyCLIMUBBat61MF2iffE7CYffEFZBnkQgyLEsghwHFKTmbRHTJdoXv5Nx+A1lFeTJBIIczyLICUBBat53MV2iffE7BYdfEasgTyEQ5KksgjwNKEjNGzumS7QvfhNx+BWzCnIigSBPZxHkGUBBat050sUPLcgzgYkW/oKtGNnPJBDkWSyCPBsoSM07FKZLtC9+k4D4sQpyEoEgJ7MI8hwgoTRvgZgu0b74nYvDry2rIM8lEOQUFkFOBQpS8x6L6RLti995OPzasQryPAJBns8iyAuAgtS8iWO6RPviNw2HX3tWQU4jEOSFLIK8CChIzbtEpku0L34X4/DrwCrIiwkEOZ1FkDOAgtS8DWW6RPvidwkOv91ZBXkJgSAvZRHkZUBBat7nMl2iffGbicOvI6sgZxII8nIWQc4CClLzRprpEu2L3xU4/DqxCvIKAkFeySLIq4CC1LxTZ7pE++I3G4dfZ1ZBziYQ5NUsgrwGKEjNW4GmS7Qvftfi8BvEKshrCQR5HYsgrwcKUvNeo+kS7YvfHBx+g1kFOYdAkDewCPJGoCA1b2aaLtG++N2Ew28IqyBvIhDkzSyCvAUoSM27paZLtC9+c3H4DWUV5FwCQc5jEeStQEFq3o41XaJ98bsNh18RqyBvIxDkfBZBLgAKUvN+r+kS7Yvf7Tj8ilkFeTuBIO9gEeSdQEFq3VBWIsF2A+ZBLfACzxqhO267AfNggbizR8gIBrjxrT3MlcCx3Fz74lepnPDzneddwPUGyBnDgt/dLWX4l/Q7TLbwuuW9rgZjXCcwbr7y9drGPEcg7spCeskGxw/Mj0HGbPOR56wP1wd/Noe5sj9vCH/a455A8/cGf3Ith7NKMIquR2NF128O/619PRpjYXC+KBzjemeM6Pq/mc99wfvvD8ea44wVXU83n/uc+TwQnC8Ox7jBGSO6njrGjeEYD4RjWPPyYHC+JBzjRmeM6HrqGDeFYzwYjmFjfSg4fzgc4yZnjOi6PdDaOT5/K+7ocaspX4OH5G/FFT1udZLecW4f3FjVgL1jDRL8bgPiVx2IX02S3vERYO8I5IxB4mcxK+OeFryvAmKZdOe7tGXJeU74M7sMTuQJxBRL+ZxUHGuWcQ364RJJWtoSP+6jLXGilIr70ZbwHIku7vcqLY71SIrjQqXFsYCkOD4GLI5AzpgCwuL4mFBxfDxTHLFJelygOC5TXhxt3MuEiiP8C/8FWws52jE/0bJixl1f+R0Sy8snBOJuQNLELAMW4frAJqYhSRPzJBA/IGdMQxL+PabUhDQlwe9xpSakGYl+nwLqF8gZ04zQhACxLGVCns6YEGySnhYwIc8oNyE27mdITMisoBl/UqApbaH80YlrCmSa8ZYkxWg5sBgBc21aKjdxVtfLBXjTiqQJfEaIN774bU+CH5DfphUQvx1I1q1ngfwDcsbsQMK/VUpN8M4k+L2i1ATvQqLf54D6BXLG7EJogoFYljLBKxzvkjHBnmPaJK0QMMHPKzfBNu7nSUzwnMAMPivQ1LdRboLnFsiYmSRJMXoBWIyAuTZJ5SbY6voFAd60I2kCnxfijS9+7UnwA/LbtAPi14Fk3VoJ5B+QM6YDCf8+UWqCO5Pg96lSE7wHiX5fBOoXyBmzB6EJBmJZygS/5HiXjAn2HNMm6SUBE/yychNs436ZxATPD8zgSoGmfm/lJvjuAhkzsw9JMVoFLEbAXJt9lJtgq+tVArzpStIEvizEG1/8upHgB+S36QrErzvJuvUKkH9AzpjuJPxbp9QE9yDBb71SE3wgiX5fBeoXyBlzIKEJBmJZygS/5niXjAn2HNMm6TUBE/y6chNs436dxAQvCszgKwJNfU/lJnhJgYyZOYSkGL0BLEbAXJtDlJtgq+s3BHhzKEkT+LoQb3zx60OCH5Df5lAgfn1J1q03gfwDcsb0JeFfbl+dJvgIEvzygPghTfCRJPp9C6hfIGfMkYQmGIhlKRP8tuNdMibYc0ybpLcFTPA7yk2wjfsdEhO8NDCDbwo09ccoN8FPFsiYmWNJitG7wGIEzLU5VrkJtrp+V4A3x5E0ge8I8cb7v2InwQ/Ib3McEL+BJOvWe0D+ATljBpLwr75SEzyEBL8GSk3wUBL9vg/UL5AzZiihCQZiWcoEf+B4l4wJ9hzTJukDARP8oXITbOP+kMQELw/M4HsCTf0w5SZ4ZYGMmRlOUow+AhYjYK7NcOUm2Or6IwHejCRpAj8U4o0vfqNI8APy24wE4jeaZN1aDeQfkDNmNAn/Wis1wWNJ8NtJqQkeR6Lfj4H6BXLGjCM0wUAsS5ngTxzvkjHBnmPaJH0iYII/VW6CbdyfkpjgVYEZXC3Q1E9QboLfLJAxM6eQFKM1wGIEzLU5RbkJtrpeI8CbiSz/MYwQb3zxO50EPyC/zUQgfmeQrFv/H3tnAm/V9P7/c2+3brd5uEcRQrPCfSoNiiJEKSWEovFGpEhRRJF5JmQKDRRJhSSpTCmKMs9j5qIoMpX/Xtn71ep0j/+P/Xn6Pp/XPef16nVP+97W2c/n+XzWWu99z2l/AfQf0DNyAYn/WhmF4NEk+rU2CsFjSPL7JTC/QM/IGEIIBmq5DQR/5bFLBoJjjuma9JUCBH9tHIJd3V+TQPB7AQx+obCpH2scgj/J14GZS0kWo2+AixGw13KpcQh2uf5GwTdXkGwCv1byTVz9riTRD+hvuQKo31Uk89a3QP8BPSNXkfivk1EIvo5Ev85GIfh6kvx+B8wv0DNyPSEEA7XcBoJXe+ySgeCYY7omrVaA4DXGIdjVvYYEglcFMPitwqb+JuMQ/G2+DszcTLIYfQ9cjIC9lpuNQ7DL9fcKvrmVZBO4Rsk3cfW7jUQ/oL/lVqB+40nmrR+A/gN6RsaT+K+XUQi+i0S/3kYh+G6S/K4F5hfoGbmbEIKBWm4Dwes8dslAcMwxXZPWKUDwj8Yh2NX9IwkEfx/A4A8Km/p7jUPw+nwdmLmPZDH6CbgYAXst9xmHYJfrnxR8M5lkE/ijkm/i6jeFRD+gv2UyUL/7Seat9UD/AT0j95P472yjEPwgiX5DjULwQyT53QDML9Az8hAhBAO13AaCf/bYJQPBMcd0TfpZAYJ/MQ7Bru5fSCB4YwCD6xU29TOMQ/CmfB2YeYRkMdoIXIyAvZZHjEOwy/VGBd/MJtkE/qLkm7j6PUqiH9DfMhuo32Mk89avQP8BPSOPkfhvrFEInsvycQajEPwkSX5/A+YX6Bl5khCCgVpuA8G/e+ySgeCYY7om/a4AwX8Yh2BX9x8kEJyVTCR+VdjUzzcOwblJHZh5mmQx+hO4GAF7LU8bh2CX6z8VfLOIZBP4h5Jv4ur3DIl+QH/LIqB+z5LMW5uA/gN6Rp4l8d+tRiF4MYl+txmF4BdJ8rsZmF+gZ+RFQggGarkNBP/lsUsGgmOO6Zr0lwIEJ2rZhmBXtztHcI9UzrVsAIObFDb1LxmH4MpJHZh5mWQxyqqF0xLYa3nZOAS7XDvt0OO+QrIJTCj5Jq5+r5LoB/S3vALUbwXJvJUN9B/QM7KCxH9TjULwGyT6TTMKwW+S5LcEML9Az8ibhBAM1HIbCM7x2CUDwTHHdE3KqYUft6RxCHZ1lySB4GQAg9kKm/p3jENwjaQOzLxLshiVAi5GwF7Lu8Yh2OW6lIJvPiDZBJZU8k1c/T4k0Q/ob/kAqN9HJPNWLtB/QM/IRyT+m2cUgj8j0e8poxD8OUl+SwPzC/SMfE4IwaWVIDgvA8HYJuUpQHAZ4xDs6i5DAsE1AxjMVdjUf2kcguskdWDmK5LFqCxwMQL2Wr4yDsEu12UVfPMtySawjJJvYt96g0Q/oL/lW6B+q0nmrXJA/wE9I6tJ/LfMKASvJdFvuVEIXkeS3/LA/AI9I+sIIbi8EgRXyEAwtkkVFCC4onEIdnVXJIHgBgEMllPY1K83DsH7JXVgZgPJYlQJuBgBey0bjEOwy3UlBd9sJNkEVlTyTez/MIlEP6C/ZSNQv99I5q3KQP8BPSO/kfjvI6MQvIlEv4+NQvBmkvxWAeYX6BnZTAjBVZQguGoGgrFNqqoAwfnGIdjVnU8CwU0CGKyssKnPOt123S2TOjCTfTrHYpQELkbAXku2sm/i6uZynVTwTckd5JuCeI9t5t6CeI9tfBP77f0k+gH9LSWB+uWSzFs7Af0H9IzkkvhvrVEILkui3zqjEFyOJL/VgPkFekaQ+u0oCK6mBMHVMxCMbVJ1BQje2TgEu7p3JoHgAwMY3ElhU1/ROAS3S+rATCWSxWgX4GIE7LVUMg7BLte7KPimKskmcGcl38S+OEGiH9DfUhWoX5Jk3qoB9B/QM5Ik8V/WMTYheGeWi1hA/ZAQvAtJfncF5hfoGdmFEIJ3VYLg3TIQjG3SbgoQvLtxCHZ1704Cwe0DGKyhsKnfzTgEd0rqwMzuJItRTeBiBOy17G4cgl2uayr4Zk+STeDuSr6Jq99eLPoBs7InUL9aJPPWHkD/AT0jtUj8V9UoBNdjeSeMUQiuT5LfPYH5BXpG6hNC8J5KELxXBoKxTdpLAYJrGYdgV3ctEgjuGsDgHgqb+obGIbh7UgdmGpEsRrWBixGw19LIOAS7XNdW8M1+JJvAWkq+iatfAYl+QH/LfkD9hGTeqgP0H9AzIiT+q2MUgvcn0a+uUQhuRpLfusD8Aj0jzQghuK4SBNfLQDC2SfUUILi+cQh2ddcngeAeAQzWUdjUtzQOwX2SOjBzAMli1AC4GAF7LQcYh2CX6wYKvjmQZBNYX8k3cfU7iEQ/oL/lQKB+bUjmrb2B/gN6RtqQ+K+5UQhuR6JfC6MQfChJfhsC8wv0jBxKCMENlSC4UQaCsU1qpADB+xiHYFf3PiQQXBjA4N4Km/r2xiH4jKQOzBxBshjtC1yMgL2WI4xDsMv1vgq+6UiyCdxHyTdx9TuKRD+gv6UjUL9OJPPWfkD/AT0jnUj8d6RRCO5Kol8HoxB8DEl+C4D5BXpGjiGE4AIlCJYMBGObJAoQ3Ng4BLu6G5NA8JAABvdT2NQfZxyChyd1YOZ4ksWoCXAxAvZajjcOwS7XTRR8cyLJJrCxkm/i6ncSiX5Af8uJQP16kMxbTYH+A3pGepD4r4dRCO5Fol9PoxDcmyS/+wPzC/SM9CaE4P2VILhZBoKxTWqmAMHNjUOwq7s5CQSPDGCwqcKmvp9xCB6d1IGZ/iSLUQvgYgTstfQ3DsEu1y0UfHMqy9splXwTV7/TSPQD+ltOBeo3kGTeagn0H9AzMpDEf2caheAzSfQbbBSCB5Pk9wBgfoGekcGEEHyAEgS3ykAwtkmtFCC4tXEIdnW3JoHgsQEMtlTY1J9tHIKvSurAzFCSxehA4GIE7LUMNQ7BLtcHKvhmOMkmsLWSb+Lqdy6JfkB/y3CgfueRzFsHAf0H9IycR+K/0UYh+AIS/cYYheBRJPltA8wv0DMyihCC2yhBcNsMBIObpADBBxuHYFf3wSQQfF0AgwcpbOpHG4fgcUkdmBlDshgdAlyMgL2WMcYh2OX6EAXfjCXZBB6s5Ju4+l3KsokGZmUsUL/LSOatdkD/AT0jl5H47yajEHwViX43G4Xgq0nyeygwv0DPyNWEEHyoEgQfloFgbJMOU4Dgw41DsKv7cBIIHh/AYDuFTf11xiF4QlIHZq4nWYzaAxcjYK/leuMQ7HLdXsE3N5FsAg9X8k1c/W4m0Q/ob7kJqN84knnrCKD/gJ6RcST+m2wUgseT6DfFKATfTpLfI4H5BXpGbieE4COVILhDBoKxTeqgAMEdjUOwq7sjCQRPDGDwCIVN/V3GIXhqUgdm7iZZjI4CLkbAXsvdxiHY5fooBd/cS7IJ7Kjkm7j63UeiH9Dfci9Qv4kk81YnoP+AnpGJJP6bYxSC7yfR7wmjEPwASX47A/ML9Iw8QAjBnZUg+OgMBGObdLQCBHcxDsGu7i4kEDw9gMFOCpv6B41D8OykDsw8RLIYdQUuRsBey0PGIdjluquCb2aQbAK7KPkmrn6PkOgH9LfMAOo3k2TeOgboP6BnZCaJ/5YYheDHSPRbahSCHyfJbzdgfoGekccJIbibEgQfm4FgbJOOVYDg44xDsKv7OBIInhPA4DEKm/q5xiF4flIHZp4kWYyOBy5GwF7Lk8Yh2OX6eAXfzCfZBB6n5Ju4+j1Noh/Q3zIfqN8CknmrO9B/QM/IAuPr3aJgveuuMG89a7zuxUmd+fo5krycAMwLsNfynHHf3BWMcYLGOyRx57gFXEt5nrk7+LM5+DMh/HpP+NU9TgxqOSn4UzJ4PjFrK9RGx6OxouMTw3/rvh+N0SN43jMcY5I3RnT835zPycHPnxKONdkbKzqe7nxO9s6nV/C8dzjGFG+M6HjqGPeGY/QKx3CA3yd43jcc435vjOh46hj3hWP0CcdwtfYLnvcPx3jAGyM6vqMuikzAjVWQ7Z1nYciyAzymPS78mpfY9gJJItQrga2tQOGCS4HrV65XR/TI9o5Frxl52l2EKVvEz/q+b4s5P0n1TFvvefRa/rlk/Y/Pxdcr4R0rkaKV75noe64Xnb3v5xTxb6KfzSni5/zaSyrU7r9OW+/v0WuV8c4hx8C5ZBdxLqWw57Jl3Y3yk0hse3E0Oo/onHK975UGa+LGyCviPEp755Ga81LhceB5NHZjlC3iPMp4X6PXL+udRznseTTJSzkP9/in/JbzzqU89ly2eKSC91rReZX3/h59v6R3HhWw57ElN+VT6o/+7p/f//Vcc4nONe9/fK4KvhrgxqyIHbNxXmJbTd3jn3JT0auvEvZcmrhM5ia29jUaP1Vbf/+hMb9X8er1++kebj6rHD73fy56nuN931/vo++38WpyY1bFnv+Wfvrn5R7/1M/o9d26Ec2JpxYO61bYb2jhsI6FI7O8Maqk1OXvgUt6z/15QqM/Se+1qniv5R6uP/nh86T3PY31d6cizsNff6PXj34uz3ue7x2rlnK+/l7R/7fR2hr9fG5YWw62tib+a0WPf/JQjle756Euw/sOGtgvxUPRuCWKGNff95ZM+TlfE39/lZV6gm0TEBEEedFC4/xOyf37IgT6Ys1i4xep+uX+fZEBXfeLJBc3TwVe3AT2WpD6pV5UOzW88FQYfh3gXRA7LXg+MLwQNdW7EBUd/zcX6E4Pfv6McKxp3ljR8XQX6E73zmdQ8PzMcIwHvTGi4yUS20+u7oHOSYeEjp/R53laLfvz7CDsG3oGNG3ctMDNY6i6/UV0sHfBMlqM/38Xl7K8Y8wXNkt7dSRS6q0Qfj/a8A4eMmzggJGdhw8aNHDAwML+nYcMK/RlTN1/+EOlHvevzZVK+fe+pNH3ivW+xZ3fYKU3iqXTNO6aO+S/v/muIGUs2VG/GBmi9G7RszLvFsU26axa+HHPNv5uUVf32STvFnUTlsa57qiN4FkxNhoDtn0UFHG6/3VsST2gqQFyUfQnu6GhL87x/BFtPrIT26/8/hUQN3keUkTNWd7z7PBnSvzDz2SlGaeo3w5VSPBs6LaZzC0bIits1NBaWxvj/u5McXBi2wf6V9TAOuQc4KIxrBZs0hkQ6TnM0zPmDm+7XdldXv9ijLudDi8Zf2v3XaFP0eO+bPStyakLGjI/uYfi9FtG8tZuoL8F6BnR0i8bnJOhwDl3OPDKsBtDY80dbvztpRp13xKM0WkvfN0rjP+m5s9gV9hZoe6VJL+pOReYR2CvZaVx37i8dFHwzRsEeemqUPebJHk5D5gXYK/lTYK8dFPwzTsEeTlWoe53SfIyApgXYK/lXYK8HK/gmw8I8tJdoe4PSfIyEpgXYK/lQ4K8nKjgm08I8nKSQt2fkuTlfGBegL2WTwny0lPBN6sI8nKyQt1fkOTlAmBegL2WLwjy0kvBN18T5KW3Qt3fkORlFDAvwF7LNwR56avgm9UEeemnUPcakrxcCMwLsNeyhiAvhQq+WUuQlwEKda8jyctFwLwAey3rCPJymoJv1hPkZaBC3RtI8jIamBdgr2UDQV7OUPDNRoK8DFKo+1eSvIwB5gXYa/mVIC+DFXzzB0FehijU/SdJXi4G5gXYa/mTIC9nK/jmL4K8DFWoO3EGR14uAeYF2GtB66eRl2EKvilhvG6Xl+EKdeeQ5GUsMC/AXksOQV7OU/BNLkFeRijUXZokL5cC8wLstZQmyMv5Cr4pS5CXCxTqLkeSl8uAeQH2WpD6uf+25KGsrf/1ovsMg3tftnuvqXv/nHtPkHufg/vdrft9lLvG7q4bumshju/cntWtw25ucXrlhOOlPlC1R+PBvZ6L96T1/zlJZaK8UGHCqEgwUV6kUHclkonycuBECey1VCLYWIxR8E1VgrxcrFB3PklergDmBdhrySfIy1gF31QjyMulCnVXJ8nLlcC8AHst1QnycrmCb2oQ5OUKhbp3JcnLVcC8AHstuxLk5SoF39QkyMvVCnXvQZKXq4F5AfZa9iDIy7UKvqlFkJfrFOquTZKXa4B5AfZaahPk5QYF39QjyMuNCnXXJ8nLtcC8AHst9QnycrOCbxoS5GWcQt2NSPJyHTAvwF5LI4K83Krgm/0I8nKbQt0FJHm5HpgXYK+lgCAvtyv4pglBXu5QqLspSV5uAOYF2GtpSpCXuxR805wgL3cr1N2CJC83AvMC7LW0IMjLPQq+aUWQl3sV6m5NkpebgHkB9lpaE+RlooJv2hDkZZJC3W1J8nIzMC/AXktbgrxMUfBNO4K83K9Q96EkeRkHzAuw13IoQV6mKvimPUFepinUfQRJXm4B5gXYazmCIC8PKfimI0FepivUfRRJXm4F5gXYa0Hq5z74NN374JP7DIN7X7Z7r6l7/5x7T5B7n4P73a37fZS7xu6uG7prIY7v3J7VrcNubnF6afgw3a3I4/b36B3kw4L//tjululxa74N6GmkfjmhD1MfqHONxiuOH5gD9nzbO+GiAzm+FtZQip/AVGvW+Fr2z/F2LUOhV/A7ismtyNI1Oq5+dwL1Yw3knQSBvIslkHcXk3udpWt0XP0m4PRrzBrICQSBvIclkPcWk5uppWt0XP3uw+nXhDWQ9xEEciJLICcVk7u1pWt0XP0m4/RryhrIyQSBnMISyPuLye3g0jU6rn4P4PTbnzWQDxAEcipLIKcVk/vNpWt0XP0exOnXjDWQDxIE8iGWQE4vJje0S9fouPo9jNOvOWsgHyYI5AyWQD5STO6Yl67RcfWbidOvBWsgZxIEchZLIGcDA2n5lnzpGh1Xv0dx+rVkDeSjBIF8jCWQjwMDafmef+kaHVe/OTj9+rAGcg5BIJ9gCeRcYCAt31QwXaPj6vckTr++rIF8kiCQ81gC+RQwkJbvWpiu0XH1m4/Trx9rIOcTBPJplkAuAAbS8m0R0zU6rn4Lcfr1Zw3kQoJALmIJ5DPAQFq+72K6RsfV71mcfoWsgXyWIJDPsQTyeWAgLd/YMV2j4+r3Ak6/AayBfIEgkItZAvkiMJBW7xzp64cO5BLw5yGnEwZyCUEgl7IE8iVgIC3foTBdo+Pq9zL485CMgXyZIJDLWAK5HGgoy7dATNfouPq9Av48JGMgXyEI5KssgVwBDKTleyyma3Rc/VaCPw/JGMiVBIF8jSWQrwMDafkmjukaHVe/N8Cfh2QM5BsEgXyTJZBvAQNp+S6R6RodV7+3wZ+HZAzk2wSBfIclkO8CA2n5NpTpGh1Xv/fAn4dkDOR7BIF8nyWQHwADafk+l+kaHVe/D8Gfh2QM5IcEgfyIJZAfAwNp+Uaa6RodV79PwJ+HZAzkJwSB/JQlkJ8BA2n5Tp3pGh1Xv8/Bn4dkDOTnBIFcxRLIL4CBtHwr0HSNjqvfl+DPQzIG8kuCQH7FEsivgYG0fK/RdI2Oq9834M9DMgbyG4JAfssSyO+AgbR8M9N0jY6r32rw5yEZA7maIJBrWAL5PTCQlu+Wmq7RcfX7Afx5SMZA/kAQyLUsgVwHDKTl27Gma3Rc/X4Efx6SMZA/EgTyJ5ZArgcG0vL9XtM1Oq5+G8Cfh2QM5AaCQP7MEshfgIG0ekNZjQa7GzA/vBc+4F0JbsA8Q6HuY+zf+NY95G7gWH6v4+rXjeQG1huB8w3QM8Ki36+1dPxXEO8hxyjPW3F1c+NNUhi3u/H52tU8RaHuE5Tykg2uH9gfQdbs+lHKmx8mB382h71yX+8Pv7rHb0Hmfw/+lAyeP5y1VaPoeDRWdHxa+G/d96Mx/gie/xmOMcMbIzr+b85nkxs3HOsRb6zoeLrz2eSdz1/B80Ttv8eY6Y0RHU8d44FwjL/CMRy8ZAU/lx2OMcsbIzqeOsbUcAz3/c1hrSWC5znhGLO9MaLjW8YLj7UNv8bNzubcv3VHj9vD+BxcovTfuqLH7Umyd5zcBTdWD+De8WQS/R4A6tcTqN8pJHvHkrVx+gE9I0j9nGZFXNOC76uAWhb451uq9tbnOeHX7CI8UUqhpkTK66TqWKGIY9AX12hSqdr4cXNr40KpVXdubXiPVCf3mUYXx34ki+Mso4tjf5LFsTRwcQR6RvoTLo6llRbHvMziiG1SnsLiWMb44ujqLqO0OKLP9dr8vxdyNDGXrV086z7V+BUS58uyCnWfRrKJKQNchE8FbmIGkmxiygH1A3pGBpL4b4FRCDmTRL+FRiFkMEl+ywPzC/SMDCaEkPJKEFIhAyHYJlVQgJCKxiHE1V2RBELGBZvxcgqb0rONv3XijnydzfhQksWoEnAxAvZahhqHOJfrSgq+GU6yCayo5Ju4+p1Loh/Q3zIcqN95JPNWZaD/gJ6R80j8t8IoBF9Aot9KoxA8iiS/VYD5BXpGRhFCcBUlCK6agWBsk6oqQHC+cQh2deeTQPCEAAYrK2zqRxuH4Mn5OjAzhmQxSgIXI2CvZYxxCHa5Tir4ZizJJjBfyTdx9buURD+gv2UsUL/LSOatnYD+A3pGLiPx32dGIfgqEv0+NwrBV5Pktxowv0DPyNWEEFxNCYKrZyAY26TqChC8s3EIdnXvTALBUwMY3ElhU3+dcQieka8DM9eTLEa7ABcjYK/leuMQ7HK9i4JvbiLZBO6s5Ju4+t1Moh/Q33ITUL9xJPNWDaD/gJ6RcST+W28UgseT6LfBKATfTpLfXYH5BXpGbieE4F2VIHi3DARjm7SbAgTvbhyCXd27k0Dw7AAGayhs6u8yDsFz83Vg5m6SxagmcDEC9lruNg7BLtc1FXxzL8kmcHcl38TV7z6W/3EXmJV7gfpNJJm39gD6D+gZmUjiv5JdbULw/ST6lQLqh4TgB0jyuycwv0DPyAOEELynEgTvlYFgbJP2UoDgWsYh2NVdiwSC5wcwuIfCpv5B4xD8bL4OzDxEshjVBi5GwF7LQ8Yh2OW6toJvZpBsAmsp+Saufo+Q6Af0t8wA6jeTZN6qA/Qf0DMyk8R/1YxC8GMk+lU3CsGPk+S3LjC/QM/I44QQXFcJgutlIBjbpHoKEFzfOAS7uuuTQPDiAAbrKGzq5xqH4GX5OjDzJMli1AC4GAF7LU8ah2CX6wYKvplPsgmsr+SbuPo9TaIf0N8yH6jfApJ5a2+g/4CekQUk/mtgFIKfJdFvb6MQ/BxJfhsC8wv0jDxHCMENlSC4UQaCsU1qpADB+xiHYFf3PiQQvCKAwb0VNvWLjUPwW/k6MPMiyWK0L3AxAvZaXjQOwS7X+yr45iWSTeA+Sr6Jq9/LJPoB/S0vAfVbRjJv7Qf0H9AzsozEf62MQvAKEv1aG4XglST5LQDmF+gZWUkIwQVKECwZCMY2SRQguLFxCHZ1NyaB4PcCGNxPYVP/hnEI/iRfB2beJFmMmgAXI2Cv5U3jEOxy3UTBN++QbAIbK/kmrn7vkugH9Le8A9TvPZJ5qynQf0DPyHsk/utkFII/ItGvs1EI/pgkv/sD8wv0jHxMCMH7K0FwswwEY5vUTAGCmxuHYFd3cxIIXhXAYFOFTf1nxiH423wdmPmcZDFqAVyMgL2Wz41DsMt1CwXffEmyCWyu5Ju4+n3FcosVYFa+BOr3Ncm81RLoP6Bn5GsS//UyCsGrSfTrbRSC15Dk9wBgfoGekTWEEHyAEgS3ykAwtkmtFCC4tXEIdnW3JoHg7wMYbKmwqV9rHILX5+vAzDqSxehA4GIE7LWsMw7BLtcHKvhmPcvbAZV8E1e/DST6Af0t64H6/Uwybx0E9B/QM/Izif/ONgrBv5HoN9QoBP9Okt82wPwCPSO/E0JwGyUIbpuBYHCTFCD4YOMQ7Oo+mASCNwYweJDCpn6TcQjelK8DM5tJFqNDgIsRsNey2TgEu1wfouCbrEEcm8CDlXwTV79sEv2A/hbfM3H1KzGIY95qB/Qf0DNSgsR/Y41CcC6JfpcaheDSJPk9FJhfoGcEqd+OguBDlSD4sAwEY5t0mAIEH24cgl3dh5NAcFYykWinsKkvO8h23blJHZgpR7IYtQcuRsBeSzll38TVzeW6vYJvKpJsAg9X8k1c/SqR6Af0t1QE6leZZN46Aug/oGekMon/bjUKwUkS/W4zCsE7keT3SGB+gZ6RnQgh+EglCO6QgWBskzooQHBH4xDs6u5IAsFlAxg8QmFTv7NxCK6c1IGZXUgWo6OAixGw17KLcQh2uT5KwTe7kWwCOyr5Jq5+u5PoB/S37AbUrybJvNUJ6D+gZ6Qmif+mGoXgWiT6TTMKwbVJ8tsZmF+gZ6Q2IQR3VoLgozMQjG3S0QoQ3MU4BLu6u5BAcDKAwU4Km/p6xiG4RlIHZuqTLEZdgYsRsNdS3zgEu1x3VfBNQ5JNYBcl38TVrxGJfkB/S0OgfvuQzFvHAP0H9IzsQ+K/eUYhWEj0e8ooBDcmyW83YH6BnpHGhBDcTQmCj81AMLZJxypA8HHGIdjVfRwJBNcMYPAYhU39/sYhuE5SB2aakSxGxwMXI2CvpZlxCHa5Pl7BNy1JNoHHKfkm9v86SqIf0N/SEqhfK5J5qzvQf0DPSCsS/y0zCsFtSPRbbhSC25Lk9wRgfoGekbaEEHyCEgSfmIFgbJNOVIDgk4xDsKv7JBIIbhDAYHeFTX074xC8X1IHZg4lWYx6ABcjYK/lUOMQ7HLdQ8E37Uk2gScp+Sb2Z0VJ9AP6W9oD9TuSZN7qCfQf0DNyJIn/PjIKwZ1I9PvYKAR3JsnvycD8Aj0jnQkh+GQlCD4lA8HYJp2iAMG9jEOwq7sXCQQ3CWCwp8KmvqtxCG6Z1IGZY0gWo97AxQjYaznGOAS7XPdW8M1xJJvAXkq+if3OBhL9gP6W44D6dSeZt/oA/Qf0jHQn8d9aoxDcg0S/dUYhuCdJfvsC8wv0jPQkhOC+ShDcLwPB2Cb1U4Dg/sYh2NXdnwSCDwxgsI/Cpr6XcQhul9SBmd4ki1EhcDEC9lp6G4dgl+tCBd/0I9kE9lfyTey+kOgH9Lf0A+pXSDJvDQD6D+gZKSTxX9YxNiF4IIl+2UD9kBB8Okl+TwXmF+gZOZ0Qgk9VguDTMhCMbdJpChA80DgEu7oHkkBw+wAGByhs6s80DsGdkjowM5hkMToduBgBey2DjUOwy/XpCr45m2QTOFDJN3H1G0qiH9DfcjZQv3NI5q0zgP4DekbOIfFfVaMQfB6JfvlGIXgESX4HAfML9IyMIITgQUoQfGYGgrFNOlMBggcbh2BX92ASCO4awOAZCpv6C4xDcPekDsyMIlmMhgAXI2CvZZRxCHa5HqLgm9EsEKfkm7j6jSHRD+hvGQ3U72KSeessoP+AnpGLSfxXxygEX0aiX12jEHw5SX7PBuYX6Bm5nBCCz1aC4KEZCMY2aagCBJ9jHIJd3eeQQHCPAAbPUtjUX2UcgvskdWDmapLFaBhwMQL2Wq42DsEu18MUfHMdySbwHCXfxNXvehL9gP6W64D63UAybw0H+g/oGbmBxH/NjULwOBL9WhiF4FtI8nsuML9Az8gthBB8rhIEn5eBYGyTzlOA4BHGIdjVPYIEggsDGByusKkfbxyCz0jqwMztJIvRSOBiBOy13G4cgl2uRyr45i6STeAIJd/E1e9uEv2A/pa7gPpNIJm3zgf6D+gZmUDivyONQvBEEv06GIXgSST5vQCYX6BnZBIhBF+gBMGjMhCMbdIoBQi+0DgEu7ovJIHgIQEMnq+wqb/fOAQPT+rAzAMki9FFwMUI2Gt5wDgEu1xfpOCbB0k2gRcq+Saufg+R6Af0tzwI1G86ybw1Gug/oGdkOon/ehiF4Jkk+vU0CsGzSPI7BphfoGdkFiEEj1GC4IszEIxt0sUKEHyJcQh2dV9CAsEjAxgcrbCpf8w4BI9O6sDM4ySL0VjgYgTstTxuHIJdrscq+GYuySbwEiXfxNXvSRL9gP6WuUD95pHMW5cC/Qf0jMwj8d+ZRiF4Acv/iWAUgheS5PcyYH6BnpGFhBB8mRIEX56BYGyTLleA4CuMQ7Cr+woSCB4bwOClCpv6Z41D8FVJHZh5jmQxuhK4GAF7Lc8Zh2CX6ysVfLOYZBN4hZJv4ur3Iol+QH/LYqB+S0jmrauA/gN6RpaQ+G+0UQheRqLfGKMQvJwkv1cD8wv0jCwnhOCrlSD4mgwEY5t0jQIEX2scgl3d15JA8HUBDF6lsKlfYRyCxyV1YGYlyWJ0HXAxAvZaVhqHYJfr6xR88wbJJvBaJd/E1e9NEv2A/pY3gPq9RTJvXQ/0H9Az8haJ/24yCsHvkeh3s1EIfp8kvzcA8wv0jLxPCME3KEHwjRkIxjbpRgUIvsk4BLu6byKB4PEBDF6vsKn/yDgET0jqwMzHJIvRzcDFCNhr+dg4BLtc36zgm89YNtFKvomr3+ck+gH9LZ8B9VtFMm+NA/oP6BlZReK/yUYh+GsS/aYYheBvSPJ7CzC/QM/IN4QQfIsSBN+agWBsk25VgODbjEOwq/s2EgieGMDgOIVN/WrjEDw1qQMza0gWo/HAxQjYa1ljHIJdrscr+GYtySbwNiXfxNVvHYl+QH/LWqB+P5LMW7cD/Qf0jPxI4r85RiH4ZxL9njAKwb+Q5PcOYH6BnpFfCCH4DiUIvjMDwdgm3akAwXcZh2BX910kEDw9gMHbFTb1vxmH4NlJHZj5nWQxuhu4GAF7Lb8bh2CX67sVfLOJZBN4l5Jv4uq3mUQ/oL9lE1C/v0jmrQlA/wE9I3+R+G+JUQgucSaHfkuNQnDOmRz5vQeYX6BnBKnfjoLge5Qg+N4MBGObdK8CBN9nHIJd3feRQPCcAAYnKGzqc8+0Xff8pA7MlCZZjCYCFyNgr6W0sm/i6uZyPVHBN2VJNoH3Kfkmrn7lSPQD+lvKAvUrTzJvTQL6D+gZKW98vVsUrHeTFOatysbrXpzUma+rkORlMjAvwF5LFeO+mRSMMVnBN5Nw57gFXEt5npkc/Nkc/JkSfr0//OoeU4Ja7g/+lAyeP5q1FWqj49FY0fFp0Vi1t47xQPB8ajjGY94Y0fF/cz7Tgp9/MBzrcW+s6Hi685nmnc9DwfPp4RhzvDGi46ljPBCO8VA4hgP8h4PnM8IxnvDGiI6njjE1HOPhcAxX6yPB85nhGHO9MaLjO+qiyBTcWAXZ3nnOCll2tse0x4Vf8xLbXiBJhHolsLUVKFxwKXD9yvXqiB7Z3rHoNSNPu4swZYv4Wd/3bTHnJ6meaes9j17LP5es//G5+HolvGMlUrTyPRN9z/Wis/f9nCL+TfSzOUX8nF97SYXa/ddp6/09eq0y3jnkGDiX7CLOpRT2XLasu1F+EoltL45G5xGdU673vdJgTdwYeUWcR2nvPFJzXio8DjyPxm6MskWcRxnva/T6Zb3zKIc9jyZ5KefhHv+U33LeuZTHnssWj1TwXis6r/Le36Pvl/TOowL2PLbkpnxK/dHf/fP7v55rLtG55v2Pz1XBVwPcmBWxYzbOS2yrqXv8U24qevVVwp5LE5fJ3MTWvkbjp2rr7z805vcqXr1+P93DzWeVw+f+z0XPc7zv++t99P02Xk1uzKrY89/ST/+83OOf+hm9vls3ojnx1MJh3Qr7DS0c1rFwZJY3RpWUuvw9cEnvuT9PaPQn6b1WFe+13MP1Jz98nvS+p7H+7lTEefjrb/T60c/lec/zvWPVUs7X3yv6/zZaW6Ofzw1ry8HW1sR/rejxTx7K8Wr3PNRleN9BA/uleCgat0QR4/r73pIpP+dr4u+vslJPsG0CIoIgL1ponN/m3L8vQqAv1iSNX6QqUfrviwzounciubj5KPDiJrDXgtQv9aLao+GFp1nh19neBbHHguePhxeinvQuREXH/80FujnBzz8RjjXPGys6nu4C3RzvfOYGz58Mx3jKGyM6XiKx/eTqHuicdEjo+Bl9no/Vtj/PzsW+oWdA08ZNC9w8hqrbX0TneRcso8X4/3dxKcs75m/q3IPpwmZpr45ESr0Vwu9HG97BQ4YNHDCy8/BBgwYOGFjYv/OQYYW+jKn7D3+o1OP+tblSKf/elzT6XrHet7jzm6f0RrF0msZdc5/672++K0gZS3bUL0aeUnq36PzMu0WxTZpfGz/u08bfLerqfprk3aJuwtI41x21EawUY6MxYNtHQRGn+1/HltQDmhogF0V/slsQ+mKh549o85Gd2H7l96+AuMnzkCJqzvKeZ4c/U+IffiYrzThF/XaoQoJnQ7fNZG7ZEFlhoxbU3toY93dnioMT2z7Qv6IG1iELgYvGotqwSWdApOciT8+YO7ztdmWTvP7FGHc7HXY2/tbuSaFP0ePuYvStyakLGjI/Ew/F6VeD5K3dQH8L0DOipV82OCcLgHPuM8Arw24MjTX3GeNvL9Wo+65gjNtr4euuafw3NXcH17nuUKh7D5Lf1DwLzCOw17KHcd+4vNyl4JtaBHm5W6Hu2iR5eQ6YF2CvpTZBXu5R8E09grzcq1B3fZK8PA/MC7DXUp8gLxMVfNOQIC+TFOpuRJKXF4B5AfZaGhHkZYqCb/YjyMv9CnUXkORlMTAvwF5LAUFepir4pglBXqYp1N2UJC8vAvMC7LU0JcjLQwq+aU6Ql+kKdbcgycsSYF6AvZYWBHmZoeCbVgR5eUSh7tYkeVkKzAuw19KaIC+zFHzThiAvsxXqbkuSl5eAeQH2WtoS5OUxBd+0I8jL4wp1H0qSl5eBeQH2Wg4lyMsTCr5pT5CXuQp1H0GSl2XAvAB7LUcQ5GWegm86EuTlKYW6jyLJy3JgXoC9lqMI8vK0gm+OJsjLAoW6u5Dk5RVgXoC9li4EeVmk4JtuBHl5RqHuY0ny8iowL8Bey7EEeXlOwTfdCfLyvELdJ5DkZQUwL8BeywkEeVms4JseBHl5UaHuniR5WQnMC7DXgtTP/bcl87O2/teL7jMM7n3Z7r2m7v1z7j1B7n0O7ne37vdR7hq7u27oroU4vnN7VrcOu7nF6ZUTjpf6QNUejQf3emm8J63/z0kqE+VShQmjF8FE+ZJC3b1JJsrXgBMlsNfSm2BjsUzBN/0I8rJcoe7+JHl5HZgXYK+lP0FeXlXwzakEeVmhUPdpJHl5A5gXYK/lNIK8vKbgmzMI8vK6Qt2DSPLyJjAvwF7LIIK8vKngmyEEeXlLoe6zSPLyFjAvwF7LWQR5eUfBN+cQ5OVdhbqHkeTlbWBegL2WYQR5eV/BN+cR5OUDhbpHkOTlHWBegL2WEQR5+UjBNxcQ5OVjhbpHkeTlXWBegL2WUQR5+VTBN6MJ8vKZQt1jSPLyHjAvwF7LGIK8rFLwzViCvHyhUPelJHl5H5gXYK/lUoK8fKXgmysI8vK1Qt1XkuTlA2BegL2WKwny8q2Cb64hyMt3CnVfS5KXD4F5AfZariXIyxoF39xAkJfvFeq+kSQvHwHzAuy13EiQl7UKvhlHkJd1CnXfQpKXj4F5AfZabiHIy08KvhlPkJf1CnXfTpKXT4B5AfZabifIy88KvrmLIC+/KNR9N0lePgXmBdhrQernPvj0tPfBJ/cZBve+bPdeU/f+OfeeIPc+B/e7W/f7KHeN3V03dNdCHN+5Patbh93c8ml4N0i0D9Pdijxuf+/dQT4s+O+P7W6ZHrfmz4CeRuqXE/ow9YE612i84viBOWDPt70TLjqQn9fGGkrxE5hqzfq8tv1zXKVlKPQK/kUxuRVZukbH1e9LoH6sgfySIJBfsQTy62Jyr7N0jY6r3zc4/RqzBvIbgkB+yxLI74rJzdTSNTqufqtx+jVhDeRqgkCuYQnk98Xkbm3pGh1Xvx9w+jVlDeQPBIFcyxLIdcXkdnDpGh1Xvx9x+u3PGsgfCQL5E0sg1xeT+82la3Rc/Tbg9GvGGsgNBIH8mSWQvxSTG9qla3Rc/Tbi9GvOGsiNBIH8lSWQvxWTO+ala3Rc/X7H6deCNZC/EwTyD5ZA/llMbsmXrtFx9duE068layA3EQRyM0sg/yom9/xL1+i4+iXqwM6zD2sggRqonWNWHZJAZuNO1PRNBdM1Oq5+JXD69WUNZAmCQOawBLIkMJCW71qYrtFx9SuF068fayBLEQQylyWQpYGBtHxbxHSNjqtfHk6//qyBzCMIZBmWQJYFBtLyfRfTNTqufuVw+hWyBrIcQSDLswSyAjCQlm/smK7RcfWriNNvAGsgKxIEshJLICsDA2n1zpG+fuhAVgE2WvkDtmpmr0IQyKosgcwHBtLyHQrTNTqufkmgfqyBTBIEcieWQFYDGsryLRDTNTquftVx+jVmDWR1gkDuzBLIXYCBtHyPxXSNjqtfDZx+TVgDWYMgkLuyBHI3YCAt38QxXaPj6rc7Tr+mrIHcnSCQNVkCuQcwkJbvEpmu0XH12xOn3/6sgdyTIJB7sQSyFjCQlm9Dma7RcfWrjdOvGWsgaxMEsg5LIOsCA2n5PpfpGh1Xv3o4/ZqzBrIeQSDrswSyATCQlm+kma7RcfXbG6dfC9ZA7k0QyIYsgWwEDKTlO3Wma3Rc/fbB6deSNZD7EARyX5ZA7gcMpOVbgaZrdFz9CsCfh2QMZAFBIIUlkI2BgbR8r9F0jY6rXxPw5yEZA9mEIJBNWQK5PzCQlm9mmq7RcfVrBv48JGMgmxEEsjlLIFsAA2n5bqnpGh1Xv5bgz0MyBrIlQSAPYAlkK2AgLd+ONV2j4+rXGvx5SMZAtiYI5IEsgTwIGEjL93tN1+i4+rUBfx6SMZBtCALZliWQBwMDafWGshoNdjdg3qhwI+KJBDdg/lWh7kn2b3zrHjIZOJbf67j6TSa5gfUhwPkG6Blh0a9dHR3/FcR7yCTleSuubm68BxXGnWp8vnY1T1eoe5pSXrLB9QP7I8iaXT9KJbbODw8FfzaHvXJfHw6/usehQeYPC/6UDJ4vyNqqUXQ8Gis6PjP8t+770RiHB8/bh2Ms9MaIjv+b8zki+Pkjw7EWeWNFx9OdzxHe+XQInncMx3jGGyM6njrGjHCMDuEYDl6OCp53Csd41hsjOp46xiPhGEeFY7haOwfPjw7HeM4bIzruHujs3FP6b93R4043PgdPLv23ruhxH2bZO3bBjTUduHecQaLfA0D9Hgbq9wjJ3rELcO8I9Iwg9XOaFXFNC76vAmpZ4J9v1zpbn+eEX7OL8EQphZoSKa+TqmOFIo5BX1yjSV3r4Mc9pg4ulFp1H1MH3iPVyX2m0cXxMZLFcZbRxfFxksWxG3BxBHpGHidcHLspLY7HZhZHbJOOVVgcjzO+OLq6j1NaHNHnem3+3ws5mpiPr1M8655r/AqJ8+XxCnU/SbKJOQ64CM8FbmLmkWxiugP1A3pG5pH4b4FRCFlAot9CoxCykCS/JwDzC/SMLCSEkBOUIOTEDIRgm3SiAoScZBxCXN0nkUDIuGAz3l1hU/qs8bdO3JGvsxl/jmQx6gFcjIC9lueMQ5zLdQ8F3ywm2QSepOSbuPq9SKIf0N+yGKjfEpJ5qyfQf0DPyBIS/60wCsHLSPRbaRSCl5Pk92RgfoGekeWEEHyyEgSfkoFgbJNOUYDgXsYh2NXdiwSCJwQw2FNhU7/COARPzteBmZUki1Fv4GIE7LWsNA7BLte9FXzzBskmsJeSb+Lq9ybLJhqYlTeA+r1FMm/1AfoP6Bl5i8R/nxmF4PdI9PvcKAS/T5LfvsD8Aj0j7xNCcF8lCO6XgWBsk/opQHB/4xDs6u5PAsFTAxjso7Cp/8g4BM/I14GZj0kWo0LgYgTstXxsHIJdrgsVfPMZySawv5Jv4ur3OYl+QH/LZ0D9VpHMWwOA/gN6RlaR+G+9UQj+mkS/DUYh+BuS/J4KzC/QM/INIQSfqgTBp2UgGNuk0xQgeKBxCHZ1DySB4NkBDA5Q2NSvNg7Bc/N1YGYNyWJ0OnAxAvZa1hiHYJfr0xV8s5ZkEzhQyTdx9VtHoh/Q37IWqN+PJPPWGUD/AT0jP5L4r2RXmxD8M4l+pYD6ISH4F5L8DgLmF+gZ+YUQggcpQfCZGQjGNulMBQgebByCXd2DSSB4fgCDZyhs6n8zDsHP5uvAzO8ki9EQ4GIE7LX8bhyCXa6HKPhmE8kmcLCSb+Lqt5lEP6C/ZRNQv79I5q2zgP4Dekb+IvFfNaMQXGIwh37VjUJwzmCO/J4NzC/QM4LUb0dB8NlKEDw0A8HYJg1VgOBzjEOwq/scEgheHMDgWQqb+tzBtutelq8DM6VJFqNhwMUI2GspreybuLq5XA9T8E1Zkk3gOUq+iatfORL9gP6WskD9ypPMW8OB/gN6RsqT+K+BUQiuTKLf3kYhuApJfs8F5hfoGalCCMHnKkHweRkIxjbpPAUIHmEcgl3dI0ggeEUAg8MVNvVJ4xD8Vr4OzOxEshiNBC5GwF7LTsYh2OV6pIJvdibZBI5Q8k1c/XYh0Q/ob9kZqF8NknnrfKD/gJ6RGiT+a2UUgmuS6NfaKATvQZLfC4D5BXpG9iCE4AuUIHhUBoKxTRqlAMEXGodgV/eFJBD8XgCD5yts6msZh+BP8nVgpjbJYnQRcDEC9lpqG4dgl+uLFHxTj2QTeKGSb+LqV59EP6C/pR5QvwYk89ZooP+AnpEGJP7rZBSC9yHRr7NRCN6XJL9jgPkFekb2JYTgMUoQfHEGgrFNulgBgi8xDsGu7ktIIHhVAIOjFTb1YhyCv83XgZnGJIvRWOBiBOy1NDYOwS7XYxV8sz/JJvASJd/E1a8ZiX5Af8v+QP2ak8xblwL9B/SMNCfxXy+jENyKRL/eRiG4NUl+LwPmF+gZaU0IwZcpQfDlGQjGNulyBQi+wjgEu7qvIIHg7wMYvFRhU9/GOASvz9eBmbYki9GVwMUI2GtpaxyCXa6vVPBNO5JN4BVKvomr36Ek+gH9Le2A+h1GMm9dBfQf0DNyGIn/zjYKwUeS6DfUKAR3IMnv1cD8Aj0jHQgh+GolCL4mA8HYJl2jAMHXGodgV/e1JBC8MYDBqxQ29Z2MQ/CmfB2Y6UyyGF0HXIyAvZbOxiHY5fo6Bd90JdkEXqvkm7j6HcPydkpgVroC9etGMm9dD/Qf0DPSjcR/Y41CcHcS/S41CsEnkOT3BmB+gZ6REwgh+AYlCL4xA8HYJt2oAME3GYdgV/dNJBCclUwkrlfY1PcwDsG5SR2Y6UmyGN0MXIyAvZaexiHY5fpmBd/0ItkE3qTkm7j69SbRD+hv6QXUrw/JvDUO6D+gZ6QPif9uNQrBhST63WYUggeQ5PcWYH6BnpEBhBB8ixIE35qBYGyTblWA4NuMQ7Cr+zYSCC4bwOA4hU39QOMQXDmpAzOnkyxG44GLEbDXcrpxCHa5Hq/gmzNZNoFKvol9/2YS/YD+ljOB+g0hmbduB/oP6BkZQuK/qUYh+BwS/aYZheBhJPm9A5hfoGdkGCEE36EEwXdmIBjbpDsVIPgu4xDs6r6LBIKTAQzerrCpP884BNdI6sDMCJLF6G7gYgTstYwwDsEu13cr+OYCkk3gXUq+iavfKJZbTAGzcgFQvwtJ5q0JQP8BPSMXkvhvnlEIvphEv6eMQvAlJPm9B5hfoGfkEkIIvkcJgu/NQDC2SfcqQPB9xiHY1X0fCQTXDGBwgsKm/jLjEFwnqQMzl5MsRhOBixGw13K5cQh2uZ6o4JurSDaB9yn5JvZ/uEKiH9DfchVQv2tI5q1JQP8BPSPXkPhvmVEIvoFEv+VGIfhGkvxOBuYX6Bm5kRCCJytB8JQMBGObNEUBgu83DsGu7vtJILhBAIOTFDb144xD8H5JHZi5hWQxegC4GAF7LbcYh2CX6wcUfDOeZBN4v5JvYr9NlkQ/oL9lPFC/O0jmralA/wE9I3eQ+O8joxA8gUS/j41C8D0k+Z0GzC/QM3IPIQRPU4LgBzMQjG3SgwoQ/JBxCHZ1P0QCwU0CGJyqsKmfaByCWyZ1YGYSyWI0HbgYAXstk4xDsMv1dAXf3E+yCXxIyTexL+qQ6Af0t9wP1G8qybz1MNB/QM/IVBL/rTUKwdNJ9FtnFIIfJsnvDGB+gZ6RhwkheIYSBD+SgWBskx5RgOCZxiHY1T2TBIIPDGDwYYVN/UzjENwuqQMzs0gWo1nAxQjYa5llHIJdrmcp+OYxkk3gTCXfxNXvcRL9gP6Wx4D6zSGZt2YD/Qf0jMwh8V/WMTYheB6JftlA/ZAQ/BRJfh8F5hfoGXmKEIIfVYLgxzIQjG3SYwoQ/LhxCHZ1P04Cwe0DGJytsKlfYByCOyV1YGYhyWI0B7gYAXstC41DsMv1HAXfPEuyCXxcyTdx9XuORD+gv+VZoH7Pk8xbTwD9B/SMPE/iv6pGIXgJiX75RiF4KUl+5wLzC/SMLCWE4LlKEPxkBoKxTXpSAYLnGYdgV/c8EgjuGsDgEwqb+mXGIbh7UgdmlpMsRk8BFyNgr2W5cQh2uX5KwTcrWP53WSXfxNVvJct/rAPMygqgfq+RzFvzgf4DekZeI/FfHaMQ/BaJfnWNQvDbJPl9GphfoGfkbUIIfloJghdkIBjbpAUKELzQOAS7uheSQHCPAAbnK2zq3zMOwX2SOjDzPslitAi4GAF7Le8bh2CX60UKvvmI5TeZSr6Jq9/HJPoB/S0fAfX7hGTeegboP6Bn5BMS/zU3CsGrSPRrYRSCvyDJ77PA/AI9I18QQvCzShD8XAaCsU16TgGCnzcOwa7u50kguDCAwWcUNvVfG4fgM5I6MPMNyWL0AnAxAvZavjEOwS7XLyj4ZjXJJvB5Jd/E1W8NiX5Af8tqoH7fk8xbi4H+A3pGvifx35FGIfhHEv06GIXgn0jy+yIwv0DPyE+EEPyiEgQvyUAwtklLFCB4qXEIdnUvJYHgIQEMLlbY1P9sHIKHJ3Vg5heSxegl4GIE7LX8YhyCXa5fUvDNbySbwKVKvomr3+8k+gH9Lb8B9fuDZN56Geg/oGfkDxL/9TAKwX+R6NfTKAQnhnDkdxkwv0DPCFK/HQXBy5QgeHkGgrFNWq4Awa8Yh2BX9yskEDwygMGXFTb1JYbYrnt0UgdmckgWo1eBixGw15Kj7Ju4urlcv6rgm9wd5JuCeI9t5t6CeI9tfBNXv9Ik+gH9LblA/fJI5q0VQP8BPSN5JP470ygElyfRb7BRCK5Akt+VwPwCPSMVCCF4pRIEv5aBYGyTXlOA4NeNQ7Cr+3USCB4bwOAKhU19ZeMQfFVSB2aqkCxGbwAXI2CvpYpxCHa5fkPBN0mSTeDrSr6Jq99OJPoB/S1JoH7VSOatN4H+A3pGqpH4b7RRCK5Bot8YoxC8K0l+3wLmF+gZ2ZUQgt9SguC3MxCMbdLbChD8jnEIdnW/QwLB1wUw+KbCpr6mcQgel9SBmT1IFqN3gYsRsNeyh3EIdrl+V8E3tUg2ge8o+SaufrVJ9AP6W2oB9atDMm+9B/Qf0DNSh8R/NxmF4AYk+t1sFIL3Jsnv+8D8Aj0jexNC8PtKEPxBBoKxTfpAAYI/NA7Bru4PSSB4fACD7yls6vcxDsETkjowsy/JYvQRcDEC9lr2NQ7BLtcfKfhGSDaBHyr5Jq5+jUn0A/pbBKhfE5J562Og/4CekSYk/ptsFIKbk+g3xSgEtyDJ7yfA/AI9Iy0IIfgTJQj+NAPB2CZ9qgDBnxmHYFf3ZyQQPDGAwY8VNvWtjEPw1KQOzLQmWYw+By5GwF5La+MQ7HL9uYJv2pBsAj9T8k1c/dqS6Af0t7QB6ncwyby1Cug/oGfkYBL/zTEKwYeR6PeEUQg+nCS/XwDzC/SMHE4IwV8oQfCXGQjGNulLBQj+yjgEu7q/IoHg6QEMrlLY1B9pHIJnJ3VgpgPJYvQ1cDEC9lo6GIdgl+uvFXzTiWQT+JWSb+Lq15lEP6C/pRNQv6NJ5q1vgP4DekaOJvHfEqMQ3I1Ev6VGIfhYkvx+C8wv0DNyLCEEf6sEwd9lIBjbpO8UIHi1cQh2da8mgeA5AQx+o7Cp724cgucndWDmBJLFaA1wMQL2Wk4wDsEu12sUfNODZBO4Wsk3cfXrSaIf0N/SA6jfySTz1vdA/wE9IycbX+8WBevd9wrzVh/jdS9O6szXfUny8gMwL8BeS1/jvnkwGOMHBd88iDvHLeBayvPMQ8GfzcGf6eHXh8Ov7rE2qGVd8Kdk8Pz5rK1QGx2PxoqOzwz/rft+NMaPwfOfwjFe8MaIjv+b81kf/PyGcKzF3ljR8XTns947n5+D57+EY7zojREdTx1jRjjGz+EYDvA3Bs9/DcdY4o0RHU8d45FwjI3hGK7W34Lnv4djLPXGiI7vqIsi03FjFWR75/lHyLJ/ekx7XPg1L7HtBZJEqFcCW1uBwgWXAtevXK+O6JHtHYteM/K0uwhTtoif9X3fFnN+kuqZtt7z6LX8c8n6H5+Lr1fCO1YiRSvfM9H3XC86e9/PKeLfRD+bU8TP+bWXVKjdf5223t+j1yrjnUOOgXPJLuJcSmHPZcu6G+Unkdj24mh0HtE55XrfKw3WxI2RV8R5lPbOIzXnpcLjwPNo7MYoW8R5lPG+Rq9f1juPctjzaJKXch7u8U/5LeedS3nsuWzxSAXvtaLzKu/9Pfp+Se88KmDPY0tuyqfUH/3dP7//67nmEp1r3v/4XBV8NcCNWRE7ZuO8xLaausc/5aaiV18l7Lk0cZnMTWztazR+qrb+/kNjfq/i1ev30z3cfFY5fO7/XPQ8x/u+v95H32/j1eTGrIo9/y399M/LPf6pn9Hru3UjmhNPLRzWrbDf0MJhHQtHZnljVEmpy98Dl/Se+/OERn+S3mtV8V7LPVx/8sPnSe97GuvvTkWch7/+Rq8f/Vye9zzfO1Yt5Xz9vaL/b6O1Nfr53LC2HGxtTfzXih7/5KEcr3bPQ12G9x00sF+Kh6JxSxQxrr/vLZnyc74m/v4qK/UE2yYgIgjyooXG+d1T+u+LEOiLNYXGL1JNLv33RQZ03QNILm5uAl7cBPZakPqlXlTbFF54+iP8+qd3QWxz8Pyv8ELUS96FqOj4v7lAl6gb/Hzdv8d62RsrOp7uAp37fjRGdvC8RDjGMm+M6HiJxPaTq3ugc9IhoeNn9HlurmN/ns2uCx13QNPGTQvcPIaq219Ec+pufR4txv+/i0tZ3jHmC5ulvToSKfVWCL8fbXgHDxk2cMDIzsMHDRo4YGBh/85DhhX6MqbuP/yhUo/71+ZKpfx7X9Loe8V63+LOz/co8lzTaRp3zS1Z9z+PVZAyluyoX4z451wQ8+Gfbymvd5l3i8Yc0zWpVF38uLl1cebXqjtXaRLQmLA0znVHbQRnxdhoDNj2UVDE6f7XsSX1gKYGyEXRn+xKh77I8/wRbT6yE9uv/P4VEDd5HlJEzVne8+zwZ0r8w89kpRmnqN8OVUjwbOi2mcwtGyIrbFTpulsb4/7uTHFwYtsH+lfUwDokD7holKkLm3QGRHqW8fSMucPbblf2oNe/GONup8NA42/tfjD0KXrc042+NTl1QUPmp9VhOP3OIHlrN9DfAvSMaOmXDc5JaeCcWxZHfCqw47JWtq7OHIbsNbruScEYq2rj6x5i/Dc1rQPw+EKh7rNIflNTDphHYK/lLOO+cXn5SsE35xDk5WuFuoeR5KU8MC/AXsswgrx8q+Cb8wjy8p1C3SNI8lIBmBdgr2UEQV7WKPjmAoK8fK9Q9yiSvFQE5gXYaxlFkJe1Cr4ZTZCXdQp1jyHJSyVgXoC9ljEEeflJwTdjCfKyXqHuS0nyUhmYF2Cv5VKCvPys4JsrCPLyi0LdV5LkpQowL8Bey5UEeflVwTfXEOTlN4W6ryXJS1VgXoC9lmsJ8vKHgm9uIMjLnwp130iSl3xgXoC9lhsJ8rJZwTfjCPLyl0Ldt5DkJQnMC7DXcgtBXrIUPpE4niAv2Qp1306Sl52AeQH2Wm4nyEuOgm/uIshLSYW67ybJSzVgXoC9lrsJ8pKr4Jt7CfJSWqHu+0jyUh2YF2Cv5T6CvJRR8M1kgryUVah7CkledgbmBdhrmUKQl/IKvplKkJcKCnVPI8nLLsC8AHst0wjyUknBN9MJ8lJZoe6HSfJSA5gXYK8FqZ/7b0uWZ239rxfdZxjc+7Lde03d++fce4Lc+xzc727d76PcNXZ33dBdC3F85/asbh12c4vTKyccL/WBqj0aD+71PLwnrf/PSSoTZVWFCWMmwUSZr1D3LJKJclfgRAnstcwi2FjspOCbxwjyUk2h7sdJ8rIbMC/AXsvjBHnZWcE3cwnysotC3U+S5GV3YF6AvZYnCfKyq4Jv5hPkZTeFup8myUtNYF6AvZanCfJSU8E3iwjysodC3c+Q5GUPYF6AvZZnCPKyl4JvnifISy2Ful8gycuewLwAey0vEOSljoJvlhDkpa5C3UtJ8rIXMC/AXstSgrzUV/DNMoK8NFCoezlJXmoB8wLstSwnyEtDBd+sIMhLI4W6V5LkpTYwL8Bey0qCvOyr4Js3CPKyn0Ldb5LkpQ4wL8Bey5sEeREF37xDkJfGCnW/S5KXusC8AHst7xLkpamCbz4gyMv+CnV/SJKXesC8AHstHxLkpbmCbz4hyEsLhbo/JclLfWBegL2WTwnycoCCb1YR5KWVQt1fkOSlATAvwF7LFwR5OVDBN18T5OUghbq/IcnL3sC8AHst3xDkpa2Cb1YT5OVghbrXkOSlITAvwF4LUj/3wadXvA8+uc8wuPdlu/eauvfPufcEufc5uN/dut9HuWvs7rqhuxbi+M7tWd067OaWhuHdINE+THcr8rj9XbuDfFjw3x/b3TI9bs2NgJ5G6pcT+jD1gTrXaLzi+IE5YM+3vRMuOpD71MUaSvETmGrN2qeu/XPcV8tQ6BV8v2JyK7J0jY6rXwFQP9ZAFhAEUlgC2biY3OssXaPj6tcEp19j1kA2IQhkU5ZA7l9MbqaWrtFx9WuG068JayCbEQSyOUsgWxSTu7Wla3Rc/Vri9GvKGsiWBIE8gCWQrYrJ7eDSNTqufq1x+u3PGsjWBIE8kCWQBxWT+82la3Rc/drg9GvGGsg2BIFsyxLIg4vJDe3SNTqufofg9GvOGshDCALZjiWQhxaTO+ala3Rc/Q7D6deCNZCHEQTycJZAti8mt+RL1+i4+h2B068layCPIAjkkSyB7FBM7vmXrtFx9euI068PayA7EgTyKJZAdiomNxVM1+i4+nXG6deXNZCdCQJ5NEsguxSTuxama3Rc/bri9OvHGsiuBIE8hiWQ3YrJbRHTNTqufsfi9OvPGshjCQJ5HEsgjy8m911M1+i4+nXH6VfIGsjuBIE8gSWQJxaTGzuma3Rc/U7C6TeANZAnEQSyB0sgexaDO0f6+qEDeTL485CvEAbyZIJAnsISyF7F5A6F6RodV7/e4M9DMgayN0Eg+7AEsm8xuQViukbH1a8f+POQjIHsRxDI/iyBLCwm91hM1+i4+g0Afx6SMZADCAJ5KksgTysmN3FM1+i4+g0Efx6SMZADCQJ5Oksgzygmd4lM1+i4+g0Cfx6SMZCDCAJ5JksgBxeT21Cma3Rc/YaAPw/JGMghBIE8iyWQZxeT+1yma3Rc/YaCPw/JGMihBIE8hyWQw4rJjTTTNTqufsPBn4dkDORwgkCeyxLI84rJnTrTNTqufiPAn4dkDOQIgkCOZAnk+cBAWr4VaLpGx9XvAvDnIRkDeQFBIEexBPJCYCAt32s0XaPj6ncR+POQjIG8iCCQo1kCOQYYSMs3M03X6Lj6XQz+PCRjIC8mCOQlLIEcCwyk5bulpmt0XP0uBX8ekjGQlxIE8jKWQF4ODKTl27Gma3Rc/a4Afx6SMZBXEATySpZAXgUMpOX7vaZrdFz9rgZ/HpIxkFcTBPIalkBeCwyk1RvKajR4UjDGIQo3Iv6R4AbM7RTq/sn+jW/dQx4CjuX3Oq5+60luYH0dcL4BekZY9Lu+ro7/CuI95CfleSuubm68WQrjbjQ+X7uaH1Wo+1elvGSD6wf2R5A1u36USmydH2YHfzaHvXJfHwu/uscNQeZvDP6UDJ6/mrVVo+h4NFZ0/Inw37rvR2PcFDy/ORxjhTdGdPzfnM+44OdvCcda6Y0VHU93PuO887k1eH5bOMZr3hjR8dQxHg/HuDUcw8HL+OD57eEYr3tjRMdTx5gTjjE+HMPVekfw/M5wjDe8MaLj7oHOzkF5f+uOHvcP43Nwu7y/dUWP+yfJ3nFyF9xYfwD3jptI9HsAqN+fQP02k+wd7wLuHYGeEaR+TrMirmnB91VALQv887277tbnOeHX7CI8UUqhpkTK66TqWKGIY9AX12jS3XXx406oiwulVt0T6sJ7pDq5zzS6OJY4i0O/WUYXx5yzOBbHe4CLI9AzgtRvRy2O9ygtjvdmFkdsk+5VWBzvM744urrvU1oc0ed6bf7fCzmamCfWLZ51556lW3fc83O+nKhQd2mSTcx9wEXY73Vc/fJINjGTgPoBPSN5JP5bYBRCypPot9AohFQgye9kYH6BnpEKhBAyWQlCpmQgBNukKQoQcr9xCHF1308CIeOCzfgkhU1p5bNs131Hvs5mvArJYvQAcDEC9lqqGIc4l+sHFHyTJNkE3q/km7j67USiH9DfkgTqV41k3poK9B/QM1KNxH8rjEJwDRL9VhqF4F1J8jsNmF+gZ2RXQgiepgTBD2YgGNukBxUg+CHjEOzqfogEgicEMDhVYVNf0zgET87XgZk9SBaj6cDFCNhr2cM4BLtcT1fwTS2STeBDSr6Jq19tEv2A/pZaQP3qkMxbDwP9B/SM1CHx32dGIbgBiX6fG4XgvUnyOwOYX6BnZG9CCJ6hBMGPZCAY26RHFCB4pnEIdnXPJIHgqQEMPqywqd/HOATPyNeBmX1JFqNZwMUI2GvZ1zgEu1zPUvCNkGwCZyr5Jq5+jUn0A/pbBKhfE5J5azbQf0DPSBMS/603CsHNSfTbYBSCW5Dk91FgfoGekRaEEPyoEgQ/loFgbJMeU4Dgx41DsKv7cRIInh3A4GyFTX0r4xA8N18HZlqTLEZzgIsRsNfS2jgEu1zPUfBNG5JN4ONKvomrX1sS/YD+ljZA/Q4mmbeeAPoP6Bk5mMR/JbvahODDSPQrBdQPCcGHk+R3LjC/QM/I4YQQPFcJgp/MQDC2SU8qQPA84xDs6p5HAsHzAxh8QmFTf6RxCH42XwdmOpAsRk8BFyNgr6WDcQh2uX5KwTedSDaB85R8E1e/ziT6Af0tnYD6HU0yb80H+g/oGTmaxH/VjEJwNxL9qhuF4GNJ8vs0ML9Az8ixhBD8tBIEL8hAMLZJCxQgeKFxCHZ1LySB4MUBDM5X2NR3Nw7By/J1YOYEksVoEXAxAvZaTjAOwS7XixR804NkE7hQyTdx9etJoh/Q39IDqN/JJPPWM0D/AT0jJ5P4r4FRCO5Dot/eRiG4L0l+nwXmF+gZ6UsIwc8qQfBzGQjGNuk5BQh+3jgEu7qfJ4HgFQEMPqOwqS80DsFv5evAzACSxegF4GIE7LUMMA7BLtcvKPhmIMkm8Hkl38TV73QS/YD+loFA/c4gmbcWA/0H9IycQeK/VkYheAjLxxmMQvBZJPl9EZhfoGfkLEIIflEJgpdkIBjbpCUKELzUOAS7upeSQPB7AQwuVtjUn2Mcgj/J14GZYSSL0UvAxQjYaxlmHIJdrl9S8M15JJvApUq+iavfCBL9gP6W84D6jSSZt14G+g/oGRlJ4r9ORiH4QhL9OhuF4ItI8rsMmF+gZ+QiQghepgTByzMQjG3ScgUIfsU4BLu6XyGB4FUBDL6ssKm/2DgEf5uvAzOXkCxGrwIXI2Cv5RLjEOxy/aqCby4j2QS+ouSbuPpdTqIf0N9yGVC/K0jmrRVA/wE9I1eQ+K+XUQi+hkS/3kYh+FqS/K4E5hfoGbmWEIJXKkHwaxkIxjbpNQUIft04BLu6XyeB4O8DGFyhsKm/wTgEr8/XgZkbSRajN4CLEbDXcqNxCHa5fkPBN+NINoGvK/kmrn63kOgH9LeMA+p3K8m89SbQf0DPyK0k/jvbKATfQaLfUKMQfCdJft8C5hfoGbmTEILfUoLgtzMQjG3S2woQ/I5xCHZ1v0MCwRsDGHxTYVM/wTgEb8rXgZl7SBajd4GLEbDXco9xCHa5flfBNxNJNoHvKPkmrn6TSPQD+lsmAvWbTDJvvQf0H9AzMpnEf2ONQvBUEv0uNQrB00jy+z4wv0DPyDRCCH5fCYI/yEAwtkkfKEDwh8Yh2NX9IQkEZyUTifcUNvXTjUNwblIHZh4mWYw+Ai5GwF7Lw8Yh2OX6IwXfzCTZBH6o5Ju4+s0i0Q/ob5kJ1G82ybz1MdB/QM/IbBL/3WoUgueQ6HebUQh+giS/nwDzC/SMPEEIwZ8oQfCnGQjGNulTBQj+zDgEu7o/I4HgsgEMfqywqZ9nHIIrJ3Vg5imSxehz4GIE7LU8ZRyCXa4/V/DNApJN4GdKvol96yoS/YD+lgVA/RaRzFurgP4DekYWkfhvqlEIfp5Ev2lGIfgFkvx+Acwv0DPyAiEEf6EEwV9mIBjbpC8VIPgr4xDs6v6KBIKTAQyuUtjULzEOwTWSOjCzlGQx+hq4GAF7LUuNQ7DL9dcKvllGsgn8Ssk3cfVbTqIf0N+yDKjfKyTz1jdA/wE9I6+Q+G+eUQh+jeUillEIfp0kv98C8wv0jLxOCMHfKkHwdxkIxjbpOwUIXm0cgl3dq0kguGYAg98obOrfMg7BdZI6MPM2yWK0BrgYAXstbxuHYJfrNQq+eY9kE7hayTexP2tGoh/Q3/IeUL8PSOat74H+A3pGPiDx3zKjEPwJiX7LjULwpyT5/QGYX6Bn5FNCCP5BCYLXZiAY26S1ChC8zjgEu7rXkUBwgwAGv1fY1K8yDsH7JXVg5guSxehH4GIE7LV8YRyCXa5/VPDN1ySbwHVKvon9G0IS/YD+lq+B+n1LMm/9BPQf0DPyLYn/PjIKwd+T6PexUQj+gSS/64H5BXpGfiCE4PVKELwhA8HYJm1QgOCfjUOwq/tnEghuEsDgTwqb+h+NQ3DLpA7M/ESyGP0CXIyAvZafjEOwy/UvCr75mWQT+LOSb2L7mUQ/oL/lZ6B+G0nmrY1A/wE9IxtJ/LfWKAT/wXIR0CgE/0mS31+B+QV6Rv4khOBflSD4twwEY5v0mwIE/24cgl3dv5NA8IEBDG5U2NT/ZRyC2yV1YCZxNsdi9AdwMQL2WtD6ofvrcv2Hgm9K7CDfFMR7bDP3FsR7bOObuPrlkOgH9Lf4nomrX0mSeetPoP+AnpGSJP7LOsYmBOeR6JcN1A8JwWVI8rsJmF+gZwSp346C4E1KELw5A8HYJm1WgOC/jEOwq/svEghuH8Dgnwqb+vJn2667U1IHZiqQLEaJejgtgb2WCsYheEuu6+HHrUyyCfyrro5v4upXhUQ/oL+lMlC/qiTzVhZw3gJ6RqqS+K+qUQiuRqJfvlEIrk6S32xgfoGekeqEEAzUchsILlFv6/MMBMcc0zWpRD38uDn1bEOwqzunHrxHKufaNYDBLIVNfQ3jENw9qFsDZnYlWYxKAhcjYK9lV+MQ7HJdUsE3NUk2gTlKvomr3x4k+gH9LTWB+u1JMm+VAvoP6BnZk8R/dYxCcB0S/eoaheC6JPnNBeYX6BmpSwjBuUoQXDoDwdgmlVaA4DzjEOzqziOB4B4BDJZS2NQ3MA7BfZI6MLM3yWJUBrgYAXstexuHYJfrMgq+2YdkE5in5Ju4+u1Loh/Q37IPUL/9SOatskD/AT0j+5H4r7lRCG5Col8LoxDclCS/5YD5BXpGmhJCcDklCC6fgWBsk8orQHAF4xDs6q5AAsGFAQyWVdjUNzcOwWckdWCmBcliVBG4GAF7LS2MQ7DLdUUF37RieTuvkm/i6teaZRMNzEoroH4HksxblYD+A3pGDiTx35FGIfhgEv06GIXgQ0jyWxmYX6Bn5BBCCK6sBMFVMhCMbVIVBQiuahyCXd1VSSB4SACDlRQ29YcZh+DhSR2YOZxkMcoHLkbAXsvhxiHY5TpfwTdHsnymUMk3cfXrQKIf0N9yJFC/jiTzVhLoP6BnpCOJ/3oYheCjSfTraRSCu5DkdydgfoGekS6EELyTEgRXy0AwtknVFCC4unEIdnVXJ4HgkQEMJhU29d2MQ/DopA7MHEuyGO0MXIyAvZZjjUOwy/XOCr7pTrIJrK7km7j6nUCiH9Df0h2o34kk89YuQP8BPSMnkvjvTKMQfDKJfoONQvApJPmtAcwv0DNyCiEE11CC4F0zEIxt0q4KELybcQh2de9GAsFjAxjcRWFT38c4BF+V1IGZviSL0e7AxQjYa+lrHIJdrndX8E0hySZwNyXfxNVvAIl+QH9LIVC/U0nmrZpA/wE9I6eS+G+0UQg+g0S/MUYheBBJfvcA5hfoGRlECMF7KEHwnhkIxjZpTwUI3ss4BLu69yKB4OsCGKypsKkfYhyCxyV1YOYsksWoFnAxAvZazjIOwS7XtRR8cw7JJnAvJd/E1W8YiX5Af8s5QP2Gk8xbtYH+A3pGhpP47yajEDySRL+bjULw+ST5rQPML9Azcj4hBNdRguC6GQjGNqmuAgTXMw7Bru56JBA8PoDB2gqb+guNQ/CEpA7MXESyGNUHLkbAXstFxiHY5bq+gm8uJtkE1lPyTVz9LiHRD+hvuRio31iSeasB0H9Az8hYEv9NNgrBV5DoN8UoBF9Jkt+9gfkFekauJITgvZUguGEGgrFNaqgAwY2MQ7CruxEJBE8MYLCBwqb+GuMQPDWpAzPXkixG+wAXI2Cv5VrjEOxyvY+Cb24g2QQ2UvJNXP1uJNEP6G+5AajfTSTz1r5A/wE9IzeR+G+OUQi+lUS/J4xC8G0k+d0PmF+gZ+Q2QgjeTwmCCzIQjG1SgQIEi3EIdnULCQRPD2BwX4VN/R3GIXh2Ugdm7iRZjBoDFyNgr+VO4xDsct1YwTcTSDaBouSbuPrdQ6If0N8yAajfvSTzVhOg/4CekXtJ/LfEKARPJtFvqVEInkKS36bA/AI9I1MIIbipEgTvn4FgbJP2V4DgZsYh2NXdjASC5wQw2ERhUz/VOATPT+rAzDSSxag5cDEC9lqmGYdgl+vmCr6ZTrIJbKbkm7j6PUyiH9DfMh2o3wySeasF0H9Az8gM4+vdomC9a6Ewb802XvfipM58/ShJXloC8wLstTxq3DezgjFaKvhmFu4ct4BrKc8zs4M/m4M/j4ZfHwu/uscBQS2tgj8lg+dvZm2F2uh4NFZ0/Inw37rvR2O0Dp4fGI7xljdGdPzfnM9Bwc+3Ccd62xsrOp7ufA7yzqdt8PzgcIx3vDGi46ljPB6O0TYcwwH+IcHzduEY73pjRMdTx5gTjnFIOIar9dDg+WHhGO95Y0THd9RFkUdxYxVke+d5eMiy7T2mPS78mpfY9gJJItQrga2tQOGCS4HrV65XR/TI9o5Frxl52l2EKVvEz/q+b4s5P0n1TFvvefRa/rlk/Y/Pxdcr4R0rkaKV75noe64Xnb3v5xTxb6KfzSni5/zaSyrU7r9OW+/v0WuV8c4hx8C5ZBdxLqWw57Jl3Y3yk0hse3E0Oo/onHK975UGa+LGyCviPEp755Ga81LhceB5NHZjlC3iPMp4X6PXL+udRznseTTJSzkP9/in/JbzzqU89ly2eKSC91rReZX3/h59v6R3HhWw57ElN+VT6o/+7p/f//Vcc4nONe9/fK4KvhrgxqyIHbNxXmJbTd3jn3JT0auvEvZcmrhM5ia29jUaP1Vbf/+hMb9X8er1++kebj6rHD73fy56nuN931/vo++38WpyY1bFnv+Wfvrn5R7/1M/o9d26Ec2JpxYO61bYb2jhsI6FI7O8Maqk1OXvgUt6z/15QqM/Se+1qniv5R6uP/nh86T3PY31d6cizsNff6PXj34uz3ue7x2rlnK+/l7R/7fR2hr9fG5YWw62tib+a0WPf/JQjle756Euw/sOGtgvxUPRuCWKGNff95ZM+TlfE39/lZV6gm0TEBEEedFC4/wOyvv7IgT6Ys0c4xep2uX9fZEBXfcTJBc3jwBe3AT2WpD6pV5UOyK88HR4+LW9d0HsyOB5h/BC1Pvehajo+L+5QNcx+PmjwrE+8MaKjqe7QNfRO59OwfPO4RgfemNEx0sktp9c3QOdkw4JHT+jz/PIevbn2U7YN/QMaNq4aYGbx1B1+4vo0d4Fy2gx/v9dXMryjjFf2Czt1ZFIqbdC+P1owzt4yLCBA0Z2Hj5o0MABAwv7dx4yrNCXMXX/4Q+Vety/Nlcq5d/7kkbfK9b7Fnd+Ryu9USydpnHX3C7//c13BSljyY76xUgXpXeLds28WxTbpK718OMeY/zdoq7uY0jeLeomLI1z3VEbwS4xNhoDtn0UFHG6/3VsST2gqQFyUfQnu26hL471/BFtPrIT26/8/hWQLb+JL6LmLO95dvgzJf7hZ7LSjFPUb4cqJHg2dNtM5pYNkRU2qlu9rY1xf3emODix7QP9K2pgHXIscNE4rh5s0hkQ6Xmcp2fMHd52u7JZXv9ijLudDvOMv7V7VuhT9LhPGX1rcuqChszPW4fh9JtP8tZuoL8F6BnR0i8bnJNuwDn3eOCVYTeGxpp7vPG3l2rU/WAwxr518XUvMv6bmg+Dy237KdT9DMlvaroD8wjstTxj3DcuL6Lgm+cJ8tJYoe4XSPJyAjAvwF7LCwR5aargmyUEedlfoe6lJHk5EZgXYK9lKUFemiv4ZhlBXloo1L2cJC8nAfMC7LUsJ8jLAQq+WUGQl1YKda8kyUsPYF6AvZaVBHk5UME3bxDk5SCFut8kyUtPYF6AvZY3CfLSVsE37xDk5WCFut8lycvJwLwAey3vEuSlnYJvPiDIy6EKdX9IkpdTgHkB9lo+JMjL4Qq++YQgL+0V6v6UJC+9gHkB9lo+JcjLkQq+WUWQlw4KdX9BkpfewLwAey1fEOTlKAXffE2Ql04KdX9Dkpc+wLwAey3fEOTlaAXfrCbISxeFuteQ5KUvMC/AXssagrwco+CbtQR56aZQ9zqSvPQD5gXYa1lHkJfjFHyzniAvxyvUvYEkL/2BeQH2WjYQ5OUEBd9sJMjLiQp1/0qSl0JgXoC9ll8J8tJDwTd/EOSlp0Ldf5LkZQAwL8BeC1I/99+WfJS19b9edJ9hcO/Ldu81de+fc+8Jcu9zcL+7db+PctfY3XVDdy3E8Z3bs7p12M0tTq+ccLzUB6r2aDy41/PwnrT+PyepTJSnKEwYfxFMlL0U6k4M5ZgoTwVOlMBeC1o/jbz0UfBNCeN1u7z0Vag7hyQvpwHzAuy15BDkpb+Cb3IJ8lKoUHdpkrwMBOYF2GspTZCXUxV8U5YgL6cp1F2OJC+nA/MC7LWUI8jL6Qq+qUiQlzMU6q5EkpczgHkB9loqEeTlTAXfVCXIy2CFuvNJ8jIImBdgryWfIC9nKfimGkFezlaouzpJXs4E5gXYa6lOkJdzFHxTgyAvwxTq3pUkL4OBeQH2WnYlyMu5Cr6pSZCX8xTq3oMkL0OAeQH2WvYgyMtIBd/UIsjL+Qp11ybJy1nAvAB7LbUJ8jJKwTf1CPJyoULd9UnycjYwL8BeS32CvIxW8E1DgryMUai7EUlehgLzAuy1NCLIyyUKvtmPIC9jFeouIMnLOcC8AHstBQR5uUzBN00I8nK5Qt1NSfIyDJgXYK+lKUFerlTwTXOCvFylUHcLkrwMB+YF2GtpQZCXaxR804ogL9cq1N2aJC/nAvMC7LUg9XMffPrY++CT+wyDe1+2e6+pe/+ce0+Qe5+D+92t+32Uu8burhu6ayGO79ye1a3Dbm45N7wbJNqH6W5FHre/bXaQDwv++2O7W6bHrfk8oKeR+uWEPkx9oM41Gq84fmAO2PNt74SLDuSIelhDKX4CU61ZI+rZP8eRWoZCr+DnF5NbkaVrdFz9LgDqxxrICwgCOYolkBcWk3udpWt0XP0uwunXmDWQFxEEcjRLIMcUk5uppWt0XP0uxunXhDWQFxME8hKWQI4tJndrS9fouPpditOvKWsgLyUI5GUsgby8mNwOLl2j4+p3BU6//VkDeQVBIK9kCeRVxeR+c+kaHVe/q3H6NWMN5NUEgbyGJZDXFpMb2qVrdFz9rsPp15w1kNcRBPJ6lkDeUEzumJeu0XH1uxGnXwvWQN5IEMibWAJ5czG5JV+6RsfVbxxOv5asgRxHEMhbWAJ5azG551+6RsfV7zacfn1YA3kbQSDHswTy9mJyU8F0jY6r3x04/fqyBvIOgkDeyRLIu4rJXQvTNTqufnfj9OvHGsi7CQI5gSWQ9xST2yKma3Rc/e7F6defNZD3EgTyPpZATiwm911M1+i4+k3C6VfIGshJBIGczBLIKcXkxo7pGh1Xv/tx+g1gDeT9BIF8gCWQU4vBnSN9/dCBnAb+POTHhIGcRhDIB1kC+VAxuUNhukbH1W86+POQjIGcThDIh1kCOaOY3AIxXaPj6vcI+POQjIF8hCCQM1kCOauY3GMxXaPj6jcb/HlIxkDOJgjkoyyBfKyY3MQxXaPj6vc4+POQjIF8nCCQc1gC+UQxuUtkukbH1W8u+POQjIGcSxDIJ1kCOa+Y3IYyXaPj6vcU+POQjIF8iiCQ81kC+XQxuc9lukbH1W8B+POQjIFcQBDIhSyBXFRMbqSZrtFx9XsG/HlIxkA+QxDIZ1kC+VwxuVNnukbH1e958OchGQP5PEEgX2AJ5GJgIC3fCjRdo+Pq9yL485CMgXyRIJBLWAK5FBhIy/caTdfouPq9BP48JGMgXyII5MssgVwGDKTlm5mma3Rc/ZaDPw/JGMjlBIF8hSWQrwIDafluqekaHVe/FeDPQzIGcgVBIFeyBPI1YCAt3441XaPj6vc6+POQjIF8nSCQb7AE8k1gIC3f7zVdo+Pq9xb485CMgXyLIJBvswTyHWAgrd5QVqPB7gbM1ynciPhgghswX69Q9yH2b3zrHjIbOJbf67j6tSO5gfW7wPkG6Blh0e+9ejr+K4j3kEOU5624urnx5iqM2974fO1qnqdQ9xFKeckG1w/sjyBrdv0oldg6PzwZ/Nkc9sp9fSr86h7vB5n/IPhTMnj+SdZWjaLj0VjR8QXhv3Xfj8b4MHj+UTjGp94Y0fF/cz4fBz//STjWZ95Y0fF05/Oxdz6fBs8/C8f43BsjOp46xvxwjE/DMRy8fB48XxWOscobIzqeOsbT4Rifh2O4Wr8Inn8ZjvGFN0Z03D3Q2fk472/d0eN2ND4Hr8r7W1f0uEeR7B0nd8GN1RG4d+xEot8DQP2OAurXmWTv+BVw7wj0jCD1c5oVcU0Lvq8Calngn+/X9bY+zwm/ZhfhiVIKNSVSXidVxwpFHIO+uEaTvq6HH/eberhQatX9TT14j1Qn95lGF8duJIvjLKOL47Eki+O3wMUR6Bk5lnBx/FZpcfwuszhim/SdwuK42vji6OperbQ4os/12vy/F3I0Ma+pVzzr7m78Conz5RqFuk8g2cSsBi7C3YGbmBNJNjHfA/UDekZOJPHfAqMQcjKJfguNQsgpJPn9AZhfoGfkFEII+UEJQtZmIATbpLUKELLOOIS4uteRQMi4YDP+vcKmtI/xt07cka+zGe9Lshj9CFyMgL2WvsYhzuX6RwXfFJJsAtcp+SaufgNI9AP6WwqB+p1KMm/9BPQf0DNyKon/VhiF4DNI9FtpFIIHkeR3PTC/QM/IIEIIXq8EwRsyEIxt0gYFCP7ZOAS7un8mgeAJAQz+pLCpH2Icgifn68DMWSSL0S/AxQjYaznLOAS7XP+i4JtzSDaBPyv5Jq5+w0j0A/pbzgHqN5xk3toI9B/QMzKcxH+fGYXgkST6fW4Ugs8nye+vwPwCPSPnE0Lwr0oQ/FsGgrFN+k0Bgn83DsGu7t9JIHhqAIMbFTb1FxqH4Bn5OjBzEcli9AdwMQL2Wi4yDsEu138o+OZikk3g70q+iavfJST6Af0tFwP1G0syb/0J9B/QMzKWxH/rjULwFST6bTAKwVeS5HcTML9Az8iVhBC8SQmCN2cgGNukzQoQ/JdxCHZ1/0UCwbMDGPxTYVN/jfX/SS5fB2auJVmMEvVxWgJ7Ldcah+Atua6PH/cGkk3gX/V0fBNXvxtJ9AP6W24A6ncTybyVBZy3gJ6Rm0j8V7KrTQi+lUS/UkD9kBB8G0l+s4H5BXpGbiOEYKCW20Bwifpbn2cgOOaYrkkl6uPHzalvG4Jd3Tn14T1SOdf5AQxmKWzq7zAOwc8GdWvAzJ0ki1FJ4GIE7LXcaRyCXa5LKvhmAskmMEfJN3H1u4dEP6C/ZQJQv3tJ5q1SQP8BPSP3kvivmlEInkyiX3WjEDyFJL+5wPwCPSNTCCE4VwmCS2cgGNuk0goQnGccgl3deSQQvDiAwVIKm/qpxiF4Wb4OzEwjWYzKABcjYK9lmnEIdrkuo+Cb6SSbwDwl38TV72ES/YD+lulA/WaQzFtlgf4DekZmkPivgVEInk2i395GIfhRkvyWA+YX6Bl5lBCCyylBcPkMBGObVF4BgisYh2BXdwUSCF4RwGBZhU39HOMQ/Fa+Dsw8QbIYVQQuRsBeyxPGIdjluqKCb+aRbAIrKPkmrn5PkegH9LfMA+o3n2TeqgT0H9AzMp/Ef62MQvAiEv1aG4XgZ0jyWxmYX6Bn5BlCCK6sBMFVMhCMbVIVBQiuahyCXd1VSSD4vQAGKyls6p83DsGf5OvAzAski1E+cDEC9lpeMA7BLtf5Cr5ZQrIJrKrkm7j6LSXRD+hvWQLU7yWSeSsJ9B/QM/ISif86GYXgV0j062wUgl8lye9OwPwCPSOvEkLwTkoQXC0DwdgmVVOA4OrGIdjVXZ0EglcFMJhU2NS/ZhyCv83XgZnXSRajnYGLEbDX8rpxCHa53lnBN2+xfCZOyTdx9XubRD+gv+UtoH7vkMxbuwD9B/SMvEPiv15GIfgDEv16G4XgD0nyWwOYX6Bn5ENCCK6hBMG7ZiAY26RdFSB4N+MQ7OrejQSCvw9gcBeFTf0nxiF4fb4OzHxKshjtDlyMgL2WT41DsMv17gq+WUWyCdxNyTdx9fuCRD+gv2UVUL8vSeatmkD/AT0jX5L472yjEPwtiX5DjULwdyT53QOYX6Bn5DtCCN5DCYL3zEAwtkl7KkDwXsYh2NW9FwkEbwxgsKbCpv574xC8KV8HZn4gWYxqARcjYK/lB+MQ7HJdS8E3P5JsAvdS8k1c/X4i0Q/ob/kRqN96knmrNtB/QM/IehL/jTUKwRtJ9LvUKAT/SpLfOsD8Aj0jvxJCcB0lCK6bgWBsk+oqQHA94xDs6q5HAsFZyUSitsKm/g/jEJyb1IGZP0kWo/rAxQjYa/nTOAS7XNdX8M1fJJvAekq+iT2Pn8OhH9Df8hdQv6xzOOatBkD/AT0jWST+u9UoBJck0e82oxBciiS/ewPzC/SMIPXbURC8txIEN8xAMLZJDRUguJFxCHZ1NyKB4LIBDDZQ2NTnnWO77spJHZgpQ7IY7QNcjIC9ljLKvomrm8v1Pgq+KU+yCWyk5JvY/2s3iX5Af0t5oH4VSeatfYH+A3pGKpL4b6pRCK5Kot80oxCcT5Lf/YD5BXpG8gkheD8lCC7IQDC2SQUKECzGIdjVLSQQnAxgcF+FTX014xBcI6kDM9VJFqPGwMUI2GupbhyCXa4bK/imBskmUJR8E1e/XUn0A/pbagD1241k3moC9B/QM7Ibif/mGYXgPUn0e8ooBO9Fkt+mwPwCPSN7EUJwUyUI3j8Dwdgm7a8Awc2MQ7CruxkJBNcMYLCJwqa+jnEIrpPUgZm6JItRc+BiBOy11DUOwS7XzRV804BkE9hMyTex32ZHoh/Q39IAqF9DknmrBdB/QM9IQxL/LTMKwfuR6LfcKAQXkOS3JTC/QM9IASEEt1SC4AMyEIxt0gEKENzKOAS7uluRQHCDAAZbKGzqmxiH4P2SOjDTlGQxag1cjIC9lqbGIdjlurWCb5qTbAJbKfkmNhyR6Af0tzQH6teSZN46EOg/oGekJYn/PjIKwQeS6PexUQg+iCS/BwHzC/SMHEQIwQcpQXCbDARjm9RGAYLbGofgLeYkgeAmAQweqLCpP9g4BLdM6sDMISSL0cHAxQjYaznEOAS7XB+s4JvDSDaBbZV8E1e/w0n0A/pbDgPq155k3joE6D+gZ6Q9if/WGoXgjiT6rTMKwUeR5LcdML9Az8hRhBDcTgmCD81AMLZJhypA8GHGIdjVfRgJBB8YwOAhCpv6o41DcLukDsx0IVmMDgcuRsBeSxfjEOxyfbiCb7qRbAIPU/JNXP2OJdEP6G/pBtTvOJJ5qz3Qf0DPyHEk/ss6xiYEn0iiXzZQPyQEn0SS3yOA+QV6Rk4ihOAjlCD4yAwEY5t0pAIEdzAOwa7uDiQQ3D6AwfYKm/qTjUNwp6QOzJxCshh1BC5GwF7LKcYh2OW6o4Jv+pBsAjso+Saufn1J9AP6W/oA9etHMm8dBfQf0DPSj8R/VY1C8Kkk+uUbheDTSPLbCZhfoGfkNEII7qQEwZ0zEIxtUmcFCD7aOAS7uo8mgeCuAQwepbCpP8M4BHdP6sDMIJLFqAtwMQL2WgYZh2CX6y4KvhlCsgk8Wsk3cfU7i0Q/oL9lCFC/s0nmra5A/wE9I2eT+K+OUQgezvIf2xmF4HNJ8nsMML9Az8i5hBB8jBIEd8tAMLZJ3RQg+FjjEOzqPpYEgnsEMNhVYVM/0jgE90nqwMz5JIvRccDFCNhrOd84BLtcH6fgmwtJNoHHKvkmrn4XkegH9LdcCNRvNMm8dTzQf0DPyGgS/zU3CsFjSfRrYRSCLyXJb3dgfoGekUsJIbi7EgSfkIFgbJNOUIDgE41DsKv7RBIILgxg8HiFTf0VxiH4jKQOzFxJshidBFyMgL2WK41DsMv1SQq+uYZkE3iikm/i6nctiX5Af8s1QP2uI5m3egD9B/SMXEfivyONQvBNLB8HMQrBN5Pktycwv0DPyM2EENxTCYJPzkAwtkknK0DwKcYh2NV9CgkEDwlgsIfCpv5W4xA8PKkDM7eRLEa9gIsRsNdym3EIdrnupeCbO1g+06rkm7j63UmiH9DfcgdQv7tI5q3eQP8BPSN3kfivh1EIvpdEv55GIfg+kvz2AeYX6Bm5jxCC+yhBcN8MBGOb1FcBgvsZh2BXdz8SCB4ZwGBvhU39ZOMQPDqpAzNTSBaj/sDFCNhrmWIcgl2u+yv4ZirJJrCfkm/i6jeNRD+gv2UqUL8HSeatQqD/gJ6RB0n8d6ZRCJ5Bot9goxD8CEl+BwDzC/SMPEIIwQOUIPjUDARjm3SqAgSfZhyCXd2nkUDw2AAGCxU29bONQ/BVSR2YeZRkMRoIXIyAvZZHjUOwy/VABd/MIdkEnqbkm7j6PUGiH9DfMgeo31ySeet0oP+AnpG5JP4bbRSC55PoN8YoBD9Nkt8zgPkFekaeJoTgM5QgeFAGgrFNGqQAwWcah2BX95kkEHxdAIOnK2zqFxmH4HFJHZh5hmQxGgxcjIC9lmeMQ7DL9WAF3zzP8pskJd/E1e8FEv2A/pbngfotJpm3hgD9B/SMLCbx301GIfglEv1uNgrBL5Pk9yxgfoGekZcJIfgsJQg+OwPB2CadrQDBQ41DsKt7KAkEjw9gcIjCpv4V4xA8IakDM6+SLEbnABcjYK/lVeMQ7HJ9joJvXiPZBA5V8k1c/V4n0Q/ob3kNqN8bJPPWMKD/gJ6RN0j8N9koBL/D8nEGoxD8Lkl+hwPzC/SMvEsIwcOVIPjcDARjm3SuAgSfZxyCXd3nkUDwxAAGhyls6j8wDsFTkzow8yHJYjQCuBgBey0fGodgl+sRCr75hGQTeJ6Sb+Lq9ymJfkB/yydA/T4jmbdGAv0H9Ix8RuK/OUYh+EsS/Z4wCsFfkeT3fGB+gZ6Rrwgh+HwlCL4gA8HYJl2gAMGjjEOwq3sUCQRPD2BwpMKm/lvjEDw7qQMz35EsRhcCFyNgr+U74xDscn2hgm++J9kEjlLyTVz9fiDRD+hv+R6o31qSeesioP+AnpG1JP5bYhSC15Pot9QoBG8gye9oYH6BnpENhBA8WgmCx2QgGNukMQoQfLFxCHZ1X0wCwXMCGLxIYVO/0TgEz0/qwMyvJIvRJcDFCNhr+dU4BLtcX6Lgmz9INoEXK/kmrn5/kugH9Lf8AdRvE8m8NRboP6BnZJPx9W5RsN6NVZi3sobZrntxUme+zh7GkZdLgXkB9lqyjftmbjDGpQq+mYs7xy3gWsrzzJPBn83Bn3nh16fCr+5xWVDL5cGfksHzL7O2Qm10PBorOr4g/Lfu+9EYVwTPrwzH+MobIzr+b87nquDnrw7H+tobKzqe7nyu8s7nmuD5teEY33hjRMdTx5gfjnFNOIYD/OuC59eHY3zrjREdTx3j6XCM68IxXK03BM9vDMf4zhsjOr6jLorMw41VkO2d500hy97sMe1x4de8xLYXSBKhXglsbQUKF1wKXL9yvTqiR7Z3LHrNyNPuIkzZIn7W931bzPlJqmfaes+j1/LPJet/fC6+XgnvWIkUrXzPRN9zvejsfT+niH8T/WxOET/n115SoXb/ddp6f49eq4x3DjkGziW7iHMphT2XLetulJ9EYtuLo9F5ROeU632vNFgTN0ZeEedR2juP1JyXCo8Dz6OxG6NsEedRxvsavX5Z7zzKYc+jSV7KebjHP+W3nHcu5bHnssUjFbzXis6rvPf36PslvfOogD2PLbkpn1J/9Hf//P6v55pLdK55/+NzVfDVADdmReyYjfMS22rqHv+Um4pefZWw59LEZTI3sbWv0fip2vr7D435vYpXr99P93DzWeXwuf9z0fMc7/v+eh99v41XkxuzKvb8t/TTPy/3+Kd+Rq/v1o1oTjy1cFi3wn5DC4d1LByZ5Y1RJaUufw9c0nvuzxMa/Ul6r1XFey33cP3JD58nve9prL87FXEe/vobvX70c3ne83zvWLWU8/X3iv6/jdbW6Odzw9pysLU18V8revyTh3K82j0PdRned9DAfikeisYtUcS4/r63ZMrP+Zr4+6us1BNsm4CIIMiLFhrn93He3xch0BdrShq/SLUq7++LDOi6S5Fc3BwHvLgJ7LUg9Uu9qDYuvPB0U/j1Zu+C2C3B81vDC1GrvQtR0fF/c4HutuDnx4djrfHGio6nu0B3m3c+twfP7wjH+N4bIzpeIrH95Ooe6Jx0SOj4GX2et9S3P8/ejn1Dz4CmjZsWuHkMVbe/iN7pXbCMFuP/38WlLO8Y84XN0l4diZR6K4Tfjza8g4cMGzhgZOfhgwYNHDCwsH/nIcMKfRlT9x/+UKnH/WtzpVL+vS9p9L1ivW9x53en0hvF0mkad82967+/+a4gZSzZUb8YuUvp3aJ3Z94tim3S3QrvFp1g/N2iru4JJO8WdROWxrnuqI3guhgbjQHbPgqKON3/OrakHtDUALko+pPdPaEv7vX8EW0+shPbr/z+FRA3eR5SRM1Z3vPs8GdK/MPPZKUZp6jfDlVI8GzotpnMLRsiK2zUPfW3Nsb93Zni4MS2D/SvqIF1yL3AReO++rBJZ0Ck532enjF3eNvtyuZ6/Ysx7nY65ClfTUO8NetehbrL7KCraQX/8pG6oCHzM+RwnH5ljeqX8hCgvwXoGdHSLxuck3uAc+5E4JVhN4bGmjvR+NtLNeqeFYwxsh6+7orGf1MzKtiBnq9QdyWS39RMAuYR2GupZNw3Li+jFHxTlSAvFyrUnU+Sl8nAvAB7LfkEeRmt4JtqBHkZo1B3dZK8TAHmBdhrqU6Ql0sUfFODIC9jFerelSQv9wPzAuy17EqQl8sUfFOTIC+XK9S9B0leHgDmBdhr2YMgL1cq+KYWQV6uUqi7NklepgLzAuy11CbIyzUKvqlHkJdrFequT5KXacC8AHst9Qnycr2CbxoS5OUGhbobkeTlQWBegL2WRgR5uUnBN/sR5OVmhboLSPLyEDAvwF5LAUFeblHwTROCvNyqUHdTkrxMB+YF2GtpSpCX8Qq+aU6Ql9sV6m5BkpeHgXkB9lpaEOTlTgXftCLIy10KdbcmycsMYF6AvZbWBHmZoOCbNgR5uUeh7rYkeXkEmBdgr6UtQV7uU/BNO4K8TFSo+1CSvMwE5gXYazmUIC+TFXzTniAvUxTqPoIkL7OAeQH2Wo4gyMsDCr7pSJCXqQp1H0WSl9nAvAB7LUj93H9b8kPW1v960X2Gwb0v273X1L1/zr0nyL3Pwf3u1v0+yl1jd9cN3bUQx3duz+rWYTe3OL1ywvFSH6jao/HgXi+D96T1/zlJZaJ8UGHCOJpgonxIoe4uJBPlo8CJEthr6UKwsXhYwTfdCPIyQ6HuY0ny8hgwL8Bey7EEeZmp4JvuBHmZpVD3CSR5eRyYF2Cv5QSCvDyq4JseBHl5TKHuniR5mQPMC7DX0pMgL3MUfNOLIC9PKNTdmyQvTwDzAuy19CbIy5MKvulHkJd5CnX3J8nLXGBegL2W/gR5ma/gm1MJ8vK0Qt2nkeTlSWBegL2W0wjyslDBN2cQ5GWRQt2DSPIyD5gXYK9lEEFenlXwzRCCvDynUPdZJHl5CpgXYK/lLIK8vKDgm3MI8rJYoe5hJHmZD8wLsNcyjCAvSxR8cx5BXpYq1D2CJC9PA/MC7LWMIMjLywq+uYAgL8sU6h5FkpcFwLwAey2jCPLyioJvRhPk5VWFuseQ5GUhMC/AXssYgrysVPDNWIK8vKZQ96UkeVkEzAuw13IpQV7eUPDNFQR5eVOh7itJ8vIMMC/AXsuVBHl5W8E31xDk5R2Fuq8lycuzwLwAey1I/dwHn9Z6H3xyn2Fw78t27zV1759z7wly73Nwv7t1v49y19jddUN3LcTxnduzunXYzS3PhneDRPsw3a3I4/b3hh3kw4L//tjululxa34O6GmkfjmhD1MfqHONxiuOH5gD9nwbn8MD+Xx9rKEUP4Gp1qzn69s/xxe0DIVewRcXk1uRpWt0XP1eBOrHGsgXCQK5hCWQS4vJvc7SNTqufi/h9GvMGsiXCAL5MksglxWTm6mla3Rc/Zbj9GvCGsjlBIF8hSWQrxaTu7Wla3Rc/Vbg9GvKGsgVBIFcyRLI14rJ7eDSNTqufq/j9NufNZCvEwTyDZZAvllM7jeXrtFx9XsLp18z1kC+RRDIt1kC+U4xuaFdukbH1e9dnH7NWQP5LkEg32MJ5PvF5I556RodV78PcPq1YA3kBwSB/JAlkB8Vk1vypWt0XP0+xunXkjWQHxME8hOWQH5aTO75l67RcfX7DKdfH9ZAfkYQyM9ZArmqmNxUMF2j4+r3BU6/vqyB/IIgkF+yBPKrYnLXwnSNjqvf1zj9+rEG8muCQH7DEshvi8ltEdM1Oq5+3+H0688ayO8IArmaJZBrisl9F9M1Oq5+3+P0K2QN5PcEgfyBJZBri8mNHdM1Oq5+63D6DWAN5DqCQP7IEsifisGdI3390IFcD/485FrCQK4nCOQGlkD+XEzuUJiu0XH1+wX8eUjGQP5CEMiNLIH8tZjcAjFdo+Pq9xv485CMgfyNIJC/swTyj2Jyj8V0jY6r35/gz0MyBvJPgkBuYgnk5mJyE8d0jY6r31/gz0MyBvIvgkAmGpAEMgt3oqbvEpmu0XH1y8bptz9rILMb2D/HEiyBzAEG0vJtKNM1Oq5+JXH6NWMNZEmCQJZiCWQuMJCW73OZrtFx9SuN0685ayBLEwQyjyWQZYCBtHwjzXSNjqtfWZx+LVgDWZYgkOVYAlkeGEjLd+pM1+i4+lXA6deSNZAVCAJZkSWQlYCBtHwr0HSNjqtfZZx+fVgDWZkgkFVYAlkVGEjL9xpN1+i4+uXj9OvLGsh8gkAmWQK5EzCQlm9mmq7RcfWrhtOvH2sgqxEEsjpLIHcGBtLy3VLTNTqufrvg9OvPGshdCAJZgyWQuwIDafl2rOkaHVe/3XD6FbIGcjeCQO7OEsiawEBavt9rukbH1W8PnH4DWAO5B0Eg92QJ5F7AQFq9oaxGg2cFY7yrcCPimwhuwPyeQt0327/xrXvIk8Cx/F7H1W8cyQ2sawHnG6BnhEW/2g10/FcQ7yE3K89bsd8iHoyxUGHc8cbna1fzMwp1366Ul2xw/cD+CLJm149Sia3zw6Lgz+awV+7rs+FX96gTZL5u8Kdk8Hxd1laNouPRWNHxF8J/674fjVEveF4/HONHb4zo+L85nwbBz+8djvWTN1Z0PN35NPDOp2HwvFE4xnpvjOh46hjPhWM0DMdw8LJP8HzfcIwN3hjR8dQxng/H2Cccw9W6X/C8IBzjZ2+M6Lh7oLNzUZm/dUePe5fxOXhsmb91RY97N8necXIX3Fh3AfeOE0j0ewCo391A/e4h2TsKcO8I9Iwg9XOaFXFNC76vAmpZ4J9v4wZbn+eEX7OL8EQphZoSKa+TqmOFIo5BX1yjSY0b4Mdt0gAXSq26mzSA90h1cp9pdHGcTLI4zjK6OE4hWRybAhdHoGdkCuHi2FRpcdw/szhim7S/wuLYzPji6OpuprQ4os/12vy/F3I0MTdvUDzrnmr8ConzZXOFuqeRbGKaARfhqcBNzIMkm5gWQP2AnpEHSfy3wCiEzCDRb6FRCHmEJL8tgfkFekYeIYSQlkoQckAGQrBNOkABQloZhxBXdysSCBkXbMZbKGxKZxt/68Qd+Tqb8UdJFqPWwMUI2Gt51DjEuVy3VvDNHJJNYCsl38TV7wkS/YD+ljlA/eaSzFsHAv0H9IzMJfHfCqMQPJ9Ev5VGIfhpkvweBMwv0DPyNCEEH6QEwW0yEIxtUhsFCG5rHIK3mJMEgicEMHigwqZ+kXEInpyvAzPPkCxGBwMXI2Cv5RnjEOxyfbCCb54n2QS2VfJNXP1eINEP6G95HqjfYpJ56xCg/4CekcUk/vvMKAS/RKLf50Yh+GWS/LYD5hfoGXmZEILbKUHwoRkIxjbpUAUIPsw4BLu6DyOB4KkBDB6isKl/xTgEz8jXgZlXSRajw4GLEbDX8qpxCHa5PlzBN6+RbAIPU/JNXP1eJ9EP6G95DajfGyTzVnug/4CekTdI/LfeKAS/Q6LfBqMQ/C5Jfo8A5hfoGXmXEIKPUILgIzMQjG3SkQoQ3ME4BLu6O5BA8OwABtsrbOo/MA7Bc/N1YOZDksWoI3AxAvZaPjQOwS7XHRV88wnJJrCDkm/i6vcpiX5Af8snQP0+I5m3jgL6D+gZ+YzEfyW72oTgL0n0KwXUDwnBX5HktxMwv0DPyFeEENxJCYI7ZyAY26TOChB8tHEIdnUfTQLB8wMYPEphU/+tcQh+Nl8HZr4jWYy6ABcjYK/lO+MQ7HLdRcE335NsAo9W8k1c/X4g0Q/ob/keqN9aknmrK9B/QM/IWhL/VTMKwetJ9KtuFII3kOT3GGB+gZ6RDYQQfIwSBHfLQDC2Sd0UIPhY4xDs6j6WBIIXBzDYVWFTv9E4BC/L14GZX0kWo+OAixGw1/KrcQh2uT5OwTd/kGwCj1XyTVz9/iTRD+hv+QOo3yaSeet4oP+AnpFNJP5rYBSCs4Zz6Le3UQjOHs6R3+7A/AI9I0j9dhQEd1eC4BMyEIxt0gkKEHyicQh2dZ9IAsErAhg8XmFTX3K47brfyteBmVIki9FJwMUI2GsppeybuLq5XJ+k4Js8kk3giUq+iatfGRL9gP6WPKB+ZUnmrR5A/wE9I2VJ/NfKKARXJNGvtVEIrkSS357A/AI9I5UIIbinEgSfnIFgbJNOVoDgU4xDsKv7FBIIfi+AwR4Km/qqxiH4k3wdmMknWYx6ARcjYK8l3zgEu1z3UvBNNZJN4ClKvomrX3US/YD+lmpA/XYmmbd6A/0H9IzsTOK/TkYheDcS/TobheDdSfLbB5hfoGdkd0II7qMEwX0zEIxtUl8FCO5nHIJd3f1IIHhVAIO9FTb1exqH4G/zdWBmL5LFqD9wMQL2WvYyDsEu1/0VfFOHZBPYT8k3cfWrS6If0N9SB6hfPZJ5qxDoP6BnpB6J/3oZheCGJPr1NgrBjUjyOwCYX6BnpBEhBA9QguBTMxCMbdKpChB8mnEIdnWfRgLB3wcwWKiwqd/POASvz9eBmQKSxWggcDEC9loKjEOwy/VABd80IdkEnqbkm7j6NSXRD+hvaQLUb3+Seet0oP+AnpH9Sfx3tlEIbkmi31CjEHwASX7PAOYX6Bk5gBCCz1CC4EEZCMY2aZACBJ9pHIJd3WeSQPDGAAZPV9jUH2gcgjfl68DMQSSL0WDgYgTstRxkHIJdrgcr+OZgkk3gmUq+iavfIST6Af0tBwP1a0cybw0B+g/oGWlH4r+xRiG4PYl+lxqF4CNI8nsWML9Az8gRhBB8lhIEn52BYGyTzlaA4KHGIdjVPZQEgrOSicQQhU19R+MQnJvUgZmjSBajc4CLEbDXcpRxCHa5PkfBN0ez/CZEyTexb/lFoh/Q33I0UL+uJPPWMKD/gJ6RriT+u9UoBB9Hot9tRiH4eJL8DgfmF+gZOZ4QgocrQfC5GQjGNulcBQg+zzgEu7rPI4HgsgEMDlPY1J9oHIIrJ3Vg5iSSxWgEcDEC9lpOMg7BLtcjFHxzMskm8Dwl38T+D8tI9AP6W04G6teLZN4aCfQf0DPSi8R/U41CcD8S/aYZheD+JPk9H5hfoGekPyEEn68EwRdkIBjbpAsUIHiUcQh2dY8igeBkAIMjFTb1pxqH4BpJHZg5jWQxuhC4GAF7LacZh2CX6wsVfHMGySZwlJJv4uo3iOUz1cCsnAHU70ySeesioP+AnpEzSfw3zygEn02i31NGIXgoSX5HA/ML9IwMJYTg0UoQPCYDwdgmjVGA4IuNQ7Cr+2ISCK4ZwOBFCpv64cYhuE5SB2bOJVmMLgEuRsBey7nGIdjl+hIF34wk2QRerOSb2L9hINEP6G8ZCdTvApJ5ayzQf0DPyAUk/ltmFIJHk+i33CgEjyHJ76XA/AI9I2MIIfhSJQi+LAPB2CZdpgDBlxuHYFf35SQQ3CCAwbEKm/qxxiF4v6QOzFxKshhdAVyMgL2WS41DsMv1FQq+uYJkE3i5km/i6ncly3+sA8zKFUD9riKZt64E+g/oGbmKxH8fGYXg60j0+9goBF9Pkt+rgPkFekauJ4Tgq5Qg+OoMBGObdLUCBF9jHIJd3deQQHCTAAavVNjU32QcglsmdWDmZpLF6FrgYgTstdxsHIJdrq9V8M2tJJvAa5R8E1e/20j0A/pbbgXqN55k3roO6D+gZ2Q8if/WGoXgu0j0W2cUgu8mye/1wPwCPSN3E0Lw9UoQfEMGgrFNukEBgm80DsGu7htJIPjAAAavU9jU32scgtsldWDmPpLF6CbgYgTstdxnHIJdrm9S8M1kkk3gjUq+iavfFBL9gP6WyUD97ieZt24G+g/oGbmfxH9Zx9iE4AdJ9MsG6oeE4IdI8jsOmF+gZ+QhQggepwTBt2QgGNukWxQg+FbjEOzqvpUEgtsHMHizwqZ+hnEI7pTUgZlHSBaj24CLEbDX8ohxCHa5vk3BN7NZbrGi5Ju4+j1Koh/Q3zIbqN9jJPPWeKD/gJ6Rx0j8V9UoBM8l0S/fKAQ/SZLf24H5BXpGniSE4NuVIPiODARjm3SHAgTfaRyCXd13kkBw1wAGxyts6ucbh+DuSR2YeZpkMboLuBgBey1PG4dgl+u7FHyziGQTeKeSb+Lq9wyJfkB/yyKgfs+SzFt3A/0H9Iw8S+K/OkYheDGJfnWNQvCLJPmdAMwv0DPyIiEET1CC4HsyEIxt0j0KEHyvcQh2dd9LAsE9Ahi8W2FT/5JxCO6T1IGZl0kWo/uAixGw1/KycQh2ub5PwTevkGwC71XyTVz9XiXRD+hveQWo3wqSeWsi0H9Az8gKEv81NwrBb5Do18IoBL9Jkt9JwPwCPSNvEkLwJCUInpyBYGyTJitA8BTjEOzqnkICwYUBDE5U2NS/YxyCz0jqwMy7JIvR/cDFCNhredc4BLtc36/gmw9INoFTlHwTV78PSfQD+ls+AOr3Ecm89QDQf0DPyEck/jvSKAR/RqJfB6MQ/DlJfqcC8wv0jHxOCMFTlSB4WgaCsU2apgDBDxqHYFf3gyQQPCSAwQcUNvVfGofg4UkdmPmKZDF6CLgYAXstXxmHYJfrhxR88y3JJvBBJd/E1e87Ev2A/pZvgfqtJpm3pgP9B/SMrCbxXw+jELyWRL+eRiF4HUl+HwbmF+gZWUcIwQ8rQfCMDARjmzRDAYIfMQ7Bru5HSCB4ZACD0xU29euNQ/DopA7MbCBZjGYCFyNgr2WDcQh2uZ6p4JuNLP+xk5Jv4ur3K4l+QH/LRqB+v5HMW7OA/gN6Rn4j8d+ZRiF4E4l+g41C8GaS/M4G5hfoGdlMCMGzlSD40QwEY5v0qAIEP2Ycgl3dj5FA8NgABmcpbOqzzrVd91VJHZjJPpdjMXocuBgBey3Zyr6J/b/oBro9ruCbkjvINwXxHtvMvQXxHtv4Jq5+pUj0A/pbSgL1yyWZt+YA/Qf0jOSS+G+0UQguS6LfGKMQXI4kv08A8wv0jCD121EQ/IQSBM/NQDC2SXMVIPhJ4xDs6n6SBIKvC2BwjsKmvqJxCB6X1IGZSiSL0TzgYgTstVQyDsEu1/MUfFOVZBP4pJJv4uqXT6If0N9SFahfkmTeegroP6BnJEniv5uMQvDOJPrdbBSCdyHJ73xgfoGekV0IIXi+EgQ/nYFgbJOeVoDgBcYh2NW9gASCxwcw+JTCpn434xA8IakDM7uTLEYLgYsRsNeyu3EIdrleqOCbPUk2gQuUfBNXv71I9AP6W/YE6leLZN5aBPQf0DNSi8R/k41CcD0S/aYYheD6JPl9BphfoGekPiEEP6MEwc9mIBjbpGcVIPg54xDs6n6OBIInBjC4SGFT39A4BE9N6sBMI5LF6HngYgTstTQyDsEu188r+GY/kk3gc0q+iatfAYl+QH/LfkD9hGTeegHoP6BnREj8N8coBO9Pot8TRiG4GUl+FwPzC/SMNCOE4MVKEPxiBoKxTXpRAYKXGIdgV/cSEgieHsDgCwqb+pbGIXh2UgdmDiBZjJYCFyNgr+UA4xDscr1UwTcHkmwClyj5Jq5+B5HoB/S3HAjUrw3JvPUS0H9Az0gblvwaheB2JPotNQrBh5Lk92VgfoGekUMJIfhlJQheloFgbJOWKUDwcuMQ7OpeTgLBcwIYfElhU9/eOATPT+rAzBEki9ErwMUI2Gs5wjgEu1y/ouCbjiSbwOVKvomr31Ek+gH9LR2B+nUimbdeBfoP6BnpZHy9WxSsd68qzFtdjde9OKkzXx9DkpcVwLwAey3HGPfNwmCMFQq+WYg7xy3gWsrzzKLgz+bgzzPh12fDr+6xMqjlteBPyeD5L1lboTY6Ho0VHX8h/Lfu+9EYrwfP3wjH2OiNER3/N+fzZvDzb4Vj/eqNFR1Pdz5veufzdvD8nXCM37wxouOpYzwXjvF2OIYD/HeD5++FY/zujREdTx3j+XCMd8MxXK3vB88/CMf4wxsjOr7D3h6PG6sg2zvPD0OW/chj2uPCr3mJbS+QJEK9EtjaChQuuBS4fuV6dUSPbO9Y9JqRp91FmLJF/Kzv+7aY85NUz7T1nkev5Z9L1v/4XHy9Et6xEila+Z6Jvud60dn7fk4R/yb62Zwifs6vvaRC7f7rtPX+Hr1WGe8ccgycS3YR51IKey5b1t0oP4nEthdHo/OIzinX+15psCZujLwizqO0dx6pOS8VHgeeR2M3RtkizqOM9zV6/bLeeZTDnkeTvJTzcI9/ym8571zKY89li0cqeK8VnVd57+/R90t651EBex5bclM+pf7o7/75/V/PNZfoXPP+x+eq4KsBbsyK2DEb5yW21dQ9/ik3Fb36KmHPpYnLZG5ia1+j8VO19fcfGvN7Fa9ev5/u4eazyuFz/+ei5zne9/31Pvp+G68mN2ZV7Plv6ad/Xu7xT/2MXt+tG9GceGrhsG6F/YYWDutYODLLG6NKSl3+Hrik99yfJzT6k/Req4r3Wu7h+pMfPk9639NYf3cq4jz89Td6/ejn8rzn+d6xainn6+8V/X8bra3Rz+eGteVga2viv1b0+CcP5Xi1ex7qMrzvoIH9UjwUjVuiiHH9fW/JlJ/zNfH3V1mpJ9g2ARFBkBctNM7vojJ/X4RAX6w5zvhFqrFl/r7IgK77eJKLmx8DL24Cey1I/VIvqn0cXnj6MPz6kXdB7JPg+afhhag/vQtR0fF/c4Hus+DnPw/H2uSNFR1Pd4HuM+98VgXPvwjH2OyNER0vkdh+cnUPdE46JHT8jD7PTxrYn2dXYd/QM6Bp46YFbh5D1e0vol96Fyyjxfj/d3EpyzvGfGGztFdHIqXeCuH3ow3v4CHDBg4Y2Xn4oEEDBwws7N95yLBCX8bU/Yc/VOpx/9pcqZR/70safa9Y71vc+X2p9EaxdJrGXXO/+u9vvitIGUt21C9GvlJ6t+jXmXeLYpv0dQP8uN8Yf7eoq/sbkneLuglL41x31EbwxhgbjQHbPgqKON3/OrakHtDUALko+pPdt6EvvvP8EW0+shPbr/z+FRA3eR5SRM1Z3vPs8GdK/MPPZKUZp6jfDlVI8GzotpnMLRsiK2zUtw22Nsb93Zni4MS2D/SvqIF1yHfARWN1A9ikMyDSc7WnZ8wd3na7soVe/2KMu50OJxp/a/fC0KfocU8y+tbk1AUNmZ+89jj9epC8tRvobwF6RrT0ywbn5FvgnLsGeGXYjaGx5q4x/vZSjbrnBmO8UB9fdy/jv6nZNQCPxQp19yb5Tc33wDwCey29jfvG5WWJgm/6EeRlqULd/Uny8gMwL8BeS3+CvLys4JtTCfKyTKHu00jyshaYF2Cv5TSCvLyi4JszCPLyqkLdg0jysg6YF2CvZRBBXlYq+GYIQV5eU6j7LJK8/AjMC7DXchZBXt5Q8M05BHl5U6HuYSR5+QmYF2CvZRhBXt5W8M15BHl5R6HuESR5WQ/MC7DXMoIgL+8p+OYCgry8r1D3KJK8bADmBdhrGUWQlw8VfDOaIC8fKdQ9hiQvPwPzAuy1jCHIyycKvhlLkJdPFeq+lCQvvwDzAuy1XEqQl88VfHMFQV5WKdR9JUleNgLzAuy1XEmQly8VfHMNQV6+Uqj7WpK8/ArMC7DXci1BXr5R8M0NBHn5VqHuG0ny8hswL8Bey40EeVmt4JtxBHlZo1D3LSR5+R2YF2Cv5RaCvPyg4JvxBHlZq1D37SR5+QOYF2Cv5XaCvPyo4Ju7CPLyk0Ldd5Pk5U9gXoC9FqR+7r8t+Str63+96D7D4N6X7d5r6t4/594T5N7n4H53634f5a6xu+uG7lqI4zu3Z3XrsJtbnF454XipD1Tt0Xhwr5fFe9L6/5ykMlFuUJgw7iWYKH9WqPs+kolyE3CiBPZa7iPYWGxU8M1kgrz8qlD3FJK8bAbmBdhrmUKQl98VfDOVIC9/KNQ9jSQvfwHzAuy1TCPIyyYF30wnyMtmhbofJslLYm+clsBey8MEeUko/IcVMwnykqVQ9yySvGQB8wLstcwiyEsJBd88RpCXHIW6HyfJSzYwL8Bey+MEeSml4Ju5BHnJVaj7SZK8lADmBdhreZIgL3kKvplPkJcyCnU/TZKXHGBegL2WpwnyUk7BN4sI8lJeoe5nSPJSEpgXYK/lGYK8VFTwzfMEeamkUPcLJHkpBcwLsNfyAkFeqij4ZglBXqoq1L2UJC+5wLwAey1LCfKSVPDNMoK87KRQ93KSvJQG5gXYa1lOkJfqCr5ZQZCXnRXqXkmSlzxgXoC9lpUEeamh4Js3CPKyq0Ldb5LkpQwwL8Bey5sEedldwTfvEOSlpkLd75LkpSwwL8Bey7sEedlTwTcfEORlL4W6PyTJSzlgXoC9FqR+W+7XnL31g0/uMwzufdnuvabu/XPuPUHufQ7ud7fu91HuGru7buiuhTi+c3tWtw67ucXppeHDdLcij9vfT3aQDwv++2O7W6bHrbk80NNI/XJCH6Y+UOcajVccPzAH7Pm2d8JFB7LC3lhDKX4CU61ZFfa2f44VtQyFXsErAWc7y7ciS9fouPpVBurHGsjKBIGswhLIqkBDWb7XWbpGx9UvH6dfY9ZA5hMEMskSyJ2AgbR8M7V0jY6rXzWcfk1YA1mNIJDVWQK5MzCQlu/Wlq7RcfXbBadfU9ZA7kIQyBosgdwVGEjLt4NL1+i4+u2G029/1kDuRhDI3VkCWRMYSMv3m0vX6Lj67YHTrxlrIPcgCOSeLIHcCxhIyze0S9fouPrVwunXnDWQtQgCWZslkHWAgbR8x7x0jY6rX12cfi1YA1mXIJD1WAJZHxhIy7fkS9fouPo1wOnXkjWQDQgCuTdLIBsCA2n5nn/pGh1Xv0Y4/fqwBrIRQSD3YQnkvsBAWr6pYLpGx9VvP5x+fVkDuR9BIAtYAinAQFq+a2G6RsfVrzFOv36sgWxMEMgmLIFsCgyk5dsipmt0XP32x+nXnzWQ+xMEshlLIJsDA2n5vovpGh1XvxY4/QpZA9mCIJAtWQJ5ADCQlm/smK7RcfVrhdNvAGsgWxEEsjVLIA8EBtLqnSN9/dCBPAj8echEdmK7B1oHtNkPIghkG5ZAtgUG0vIdCtM1Oq5+B4M/D8kYyIMJAnkISyDbAQ1l+RaI6RodV79DwZ+HZAzkoQSBPIwlkIcDA2n5HovpGh1Xv/bgz0MyBrI9QSCPYAnkkcXkJo7pGh1Xvw7gz0MyBrIDQSA7sgTyqGJyl8h0jY6rXyfw5yEZA9mJIJCdWQJ5dDG5DWW6RsfVrwv485CMgexCEMiuLIE8ppjc5zJdo+Pq1w38eUjGQHYjCOSxLIE8DhhIyzfSTNfouPodD/48JGMgjycIZHeWQJ4ADKTlO3Wma3Rc/U4Efx6SMZAnEgTyJJZA9gAG0vKtQNM1Oq5+PcGfh2QMZE+CQJ7MEshTgIG0fK/RdI2Oq18v8OchGQPZiyCQvVkC2QcYSMs3M03X6Lj69QV/HpIxkH0JAtmPJZD9gYG0fLfUdI2Oq18h+POQjIEsJAjkAJZAngoMpOXbsaZrdFz9TgN/HpIxkKcRBHIgSyBPBwbS8v1e0zU6rn5ngD8PyRjIMwgCOYglkGcCA2n1hrIaDXY3YK6lcAPYzwhuwFxboe7P7d/41j1kEXAsv9dx9VtFcgPrwcD5BugZYdFvyN46/iuI95DPleetuLq58RYrjPu18fna1bxEoe5vlPKSDa4f2B9B1uz6USqxdX54MfizOeyV+7o0/OoeZwWZPzv4U9L1MXurRtHxaKzo+LLw37rvR2MMDZ6fE46R7Y0RHf835zMs+Pnh4VglvLGi4+nOZ5h3PucGz88Lx8jxxoiOp47xUjjGueEYDl5GBM9HhmOU9MaIjqeO8XI4xohwDFfr+cHzC8IxSnljRMfdA52d3cv+rTt63NXG5+BaZf/WFT3uGpK94+QuuLFWA/eO35Po9wBQvzVA/X4g2TuOAu4dgZ4RpH5OsyL+jy/4vgqoZYF/vhfuvfV5Tvg1uwhPlFKoKZHyOqk6VijiGPTFNZp04d74cS/aGxdKrbov2hveI9XJfabRxXE9yeI4y+jiuIFkcRwNXByBnpENhIvjaKXFcUxmccQ2aYzC4nix8cXR1X2x0uKIPtdr8/9eyNHEfMnexbPujcavkDhfXqJQ968km5iLgYvwRuAm5jeSTcxYoH5Az8hvJP5bYBRCNpHot9AohGwmye+lwPwCPSObCSHkUiUIuSwDIdgmXaYAIZcbhxBX9+UkEDIu2IyPVdiUZp1nu+478nU249nncSxGVwAXI2CvJVvZN3F1c7m+QsE3JXeQbwriPbaZewviPbbxTVz9SpHoB/S3lATql0syb10J9B/QM5JL4r8VRiG4LIl+K41CcDmS/F4FzC/QM4LUb0dB8FVKEHx1BoKxTbpaAYKvMQ7Bru5rSCB4QgCDVyps6isah+DJ+TowU4lkMboWuBgBey2VjEOwy/W1Cr6pSrIJvEbJN3H1yyfRD+hvqQrUL0kyb10H9B/QM5Ik8d9nRiF4ZxL9PjcKwbuQ5Pd6YH6BnpFdCCH4eiUIviEDwdgm3aAAwTcah2BX940kEDw1gMHrFDb1uxmH4Bn5OjCzO8lidBNwMQL2WnY3DsEu1zcp+GZPkk3gjUq+iavfXiT6Af0tewL1q0Uyb90M9B/QM1KLxH/rjUJwPRL9NhiF4Pok+R0HzC/QM1KfEILHKUHwLRkIxjbpFgUIvtU4BLu6byWB4NkBDN6ssKlvaByC5+brwEwjksXoNuBiBOy1NDIOwS7Xtyn4Zj+STeCtSr6Jq18BiX5Af8t+QP2EZN4aD/Qf0DMiJP4r2dUmBO9Pol8poH5ICG5Gkt/bgfkFekaaEULw7UoQfEcGgrFNukMBgu80DsGu7jtJIHh+AIPjFTb1LY1D8LP5OjBzAMlidBdwMQL2Wg4wDsEu13cp+OZAkk3gnUq+iavfQST6Af0tBwL1a0Myb90N9B/QM9KGxH/VjEJwOxL9qhuF4ENJ8jsBmF+gZ+RQQgieoATB92QgGNukexQg+F7jEOzqvpcEghcHMHi3wqa+vXEIXpavAzNHkCxG9wEXI2Cv5QjjEOxyfZ+CbzqSbALvVfJNXP2OItEP6G/pCNSvE8m8NRHoP6BnpBOJ/xoYheCuJPrtbRSCjyHJ7yRgfoGekWMIIXiSEgRPzkAwtkmTFSB4inEIdnVPIYHgFQEMTlTY1B9nHILfyteBmeNJFqP7gYsRsNdyvHEIdrm+X8E3J5JsAqco+SaufieR6Af0t5wI1K8Hybz1ANB/QM9IDxL/tTIKwb1I9GttFIJ7k+R3KjC/QM9Ib0IInqoEwdMyEIxt0jQFCH7QOAS7uh8kgeD3Ahh8QGFT3884BH+SrwMz/UkWo4eAixGw19LfOAS7XD+k4JtTSTaBDyr5Jq5+p5HoB/S3nArUbyDJvDUd6D+gZ2Qgif86GYXgM0n062wUggeT5PdhYH6BnpHBhBD8sBIEz8hAMLZJMxQg+BHjEOzqfoQEglcFMDhdYVN/tnEI/jZfB2aGkixGM4GLEbDXMtQ4BLtcz1TwzXCSTeAjSr6Jq9+5JPoB/S3DgfqdRzJvzQL6D+gZOY/Ef72MQvAFJPr1NgrBo0jyOxuYX6BnZBQhBM9WguBHMxCMbdKjChD8mHEIdnU/RgLB3wcwOEthUz/aOASvz9eBmTEki9HjwMUI2GsZYxyCXa4fV/DNWJJN4GNKvomr36Uk+gH9LWOB+l1GMm/NAfoP6Bm5jMR/ZxuF4KtYLmIZheCrSfL7BDC/QM/I1YQQ/IQSBM/NQDC2SXMVIPhJ4xDs6n6SBII3BjA4R2FTf51xCN6UrwMz15MsRvOAixGw13K9cQh2uZ6n4JubSDaBTyr5Jvb9Y0n0A/pbbgLqN45k3noK6D+gZ2Qcif/GGoXg8ST6XWoUgm8nye98YH6BnpHbCSF4vhIEP52BYGyTnlaA4AXGIdjVvYAEgrOSicRTCpv6u4xDcG5SB2buJlmMFgIXI2Cv5W7jEOxyvVDBN/eSbAIXKPkm9v92TqIf0N9yL1C/iSTz1iKg/4CekYkk/rvVKATfT6LfbUYh+AGS/D4DzC/QM/IAIQQ/owTBz2YgGNukZxUg+DnjEOzqfo4EgssGMLhIYVP/oHEIrpzUgZmHSBaj54GLEbDX8pBxCHa5fl7BNzNINoHPKfkm9me1SfQD+ltmAPWbSTJvvQD0H9AzMpPEf1ONQvBjJPpNMwrBj5PkdzEwv0DPyOOEELxYCYJfzEAwtkkvKkDwEuMQ7OpeQgLByQAGX1DY1M81DsE1kjow8yTJYrQUuBgBey1PGodgl+ulCr6ZT7IJXKLkm7j6Pc3ydnJgVuYD9VtAMm+9BPQf0DOygMR/84xC8LMk+j1lFIKfI8nvy8D8Aj0jzxFC8MtKELwsA8HYJi1TgODlxiHY1b2cBIJrBjD4ksKmfrFxCK6T1IGZF0kWo1eAixGw1/KicQh2uX5FwTcvkWwClyv5JvbmikQ/oL/lJaB+y0jmrVeB/gN6RpaR+G+ZUQhewTL/GYXglST5XQHML9AzspIQglcoQfDKDARjm7RSAYJfMw7Bru7XSCC4QQCDryps6t8wDsH7JXVg5k2Sxeh14GIE7LW8aRyCXa5fV/DNOySbwNeUfBNXv3dJ9AP6W94B6vceybz1BtB/QM/IeyT++8goBH9Eot/HRiH4Y5L8vgnML9Az8jEhBL+pBMFvZSAY26S3FCD4beMQ7Op+mwSCmwQw+IbCpv4z4xDcMqkDM5+TLEbvABcjYK/lc+MQ7HL9joJvviTZBL6t5Ju4+n1Foh/Q3/IlUL+vSeatd4H+A3pGvibx31qjELyaRL91RiF4DUl+3wPmF+gZWUMIwe8pQfD7GQjGNul9BQj+wDgEu7o/IIHgAwMYfFdhU7/WOAS3S+rAzDqSxehD4GIE7LWsMw7BLtcfKvhmPckm8AMl38TVbwPLJhqYlfVA/X4mmbc+AvoP6Bn5mcR/WcfYhODfSPTLBuqHhODfSfL7MTC/QM/I74QQ/LESBH+SgWBskz5RgOBPjUOwq/tTEghuH8DgRwqb+k3GIbhTUgdmNpMsRp8BFyNgr2WzcQh2uf5MwTdZIzg2gZ8q+Sauftkk+gH9Lb5n4upXYgTHvPU50H9Az0gJEv9VNQrBuST65RuF4NIk+V0FzC/QM4LUb0dB8ColCP4iA8HYJn2hAMFfGodgV/eXJBDcNYDBzxU29WVH2K67e1IHZsqRLEZfARcjYK+lnLJvYr9tOdDtKwXfVCTZBH6p5Ju4+lUi0Q/ob6kI1K8yybz1NdB/QM9IZRL/1TEKwUkS/eoaheCdSPL7DTC/QM/IToQQ/I0SBH+bgWBsk75VgODvjEOwq/s7EgjuEcDg1wqb+p2NQ3CfpA7M7EKyGK0GLkbAXssuxiHY5Xq1gm92I9kEfqfkm7j67U6iH9DfshtQv5ok89YaoP+AnpGaJP5rbhSCa5Ho18IoBNcmye/3wPwCPSO1CSH4eyUI/iEDwdgm/aAAwWuNQ7Crey0JBBcGMLhGYVNfzzgEn5HUgZn6JIvROuBiBOy11DcOwS7X6xR805BkE7hWyTdx9WtEoh/Q39IQqN8+JPPWj0D/AT0j+5D470ijECwk+nUwCsGNSfL7EzC/QM9IY0II/kkJgtdnIBjbpPUKELzBOAS7ujeQQPCQAAZ/VNjU728cgocndWCmGcli9DNwMQL2WpoZh2CX658VfNOSZBO4Qck3cfU7gEQ/oL+lJVC/ViTz1i9A/wE9I61I/NfDKAS3IdGvp1EIbkuS343A/AI9I20JIXijEgT/moFgbJN+VYDg34xDsKv7NxIIHhnA4C8Km/p2xiF4dFIHZg4lWYx+By5GwF7LocYh2OX6dwXftCfZBP6m5Ju4+h1Boh/Q39IeqN+RJPPWH0D/AT0jR5L470yjENyJRL/BRiG4M0l+/wTmF+gZ6UwIwX8qQfCmDARjm7RJAYI3G4dgV/dmEggeG8DgHwqb+q7GIfiqpA7MHEOyGP0FXIyAvZZjjEOwy/VfCr45juV/N1byTVz9jifRD+hvOQ6oX3eSeSvREKcf0DPSncR/o41CcA8S/cYYheCeJPnNAuYX6BnpSQjBQC23geDshlufZyA45piuSU5Q9LglGtqGYFd3iYbwHqmc63UBDCYa4jf1vYxD8LikDsz0JlmMcoCLEbDX0ts4BLtc5yjkpR/JJrCEkm/i6tefRD+gv6UfUL9CknmrJNB/QM9IIYn/bjIKwQNJ9LvZKASfTpLfUsD8Aj0jpxNCcCklCM7NQDC2SbkKEFzaOAS7ukuTQPD4AAZLKmzqzzQOwROSOjAzmGQxygMuRsBey2DjEOxynafgm7NJNoGllXwTV7+hLG+nBGblbKB+55DMW2WA/gN6Rs4h8d9koxB8Hol+U4xC8AiS/JYF5hfoGRlBCMFllSC4XAaCsU0qpwDB5Y1DsKu7PAkETwxgsIzCpv4C4xA8NakDM6NIFqMKwMUI2GsZZRyCXa4rKPhmNMkmsLySb+LqN4ZEP6C/ZTRQv4tJ5q2KQP8BPSMXk/hvjlEIvoxEvyeMQvDlJPmtBMwv0DNyOSEEV1KC4MoZCMY2qbICBFcxDsGu7iokEDw9gMGKCpv6q4xD8OykDsxcTbIYVQUuRsBey9XGIdjluqqCb64j2QRWUfJNXP2uJ9EP6G+5DqjfDSTzVj7Qf0DPyA0k/ltiFILHkei31CgE30KS3yQwv0DPyC2EEJxUguCdMhCMbdJOChBczTgEu7qrkUDwnAAG8xU29eONQ/D8pA7M3E6yGFUHLkbAXsvtxiHY5bq6gm/uItkEVlPyTVz97ibRD+hvuQuo3wSSeWtnoP+AnpEJxte7RcF6t7PCvDXReN2Lkzrz9SSSvOwCzAuw1zLJum+CMXZR8M1i3DluAddSnmdeDP5sDv4sCb8uDb+6R42gll2DPyWD57nZW6E2Oh6NFR1fFv5b9/1ojN2C57uHY5T2xoiO/5vzqRn8/B7hWHneWNHxdOdT0zufPYPne4VjlPHGiI6njvFSOMae4RgO8GsFz2uHY5T1xoiOp47xcjhGrXAMV2ud4HndcIxy3hjR8R11UWQJbqyCbO8864UsW99j2uPCr3mJbS+QJEK9EtjaChQuuBRsyYJXR/TI9o5Frxl52l2EKVvEz/q+b4s5P0n1TFvvefRa/rlk/Y/Pxdcr4R0rkaKV75noe64Xnb3v5xTxb6KfzSni5/zaSyrU7r9OW+/v0WuV8c4hx8C5ZBdxLqWw57Jl3Y3yk0hse3E0Oo/onHK975UGa+LGyCviPEp755Ga81LhceB5NHZjlC3iPMp4X6PXL+udRznseTTJSzkP9/in/JbzzqU89ly2eKSC91rReZX3/h59v6R3HhWw57ElN+VT6o/+7p/f//Vcc4nONe9/fK4KvhrgxqyIHbNxXmJbTd3jn3JT0auvEvZcmrhM5ia29jUaP1Vbf/+hMb9X8er1++kebj6rHD73fy56nuN931/vo++38WpyY1bFnv+Wfvrn5R7/1M/o9d26Ec2JpxYO61bYb2jhsI6FI7O8Maqk1OXvgUt6z/15QqM/Se+1qniv5R6uP/nh86T3PY31d6cizsNff6PXj34uz3ue7x2rlnK+/l7R/7fR2hr9fG5YWw62tib+a0WPf/JQjle756Euw/sOGtgvxUPRuCWKGNff95ZM+TlfE39/lZV6gm0TEBEEedFC4/x2L/v3RQj0xZr7jV+kqlX274sM6LofILm42QB4cRPYa0Hql3pRrUF44ale+LW+d0Fs7+B5w/BCVHnvQlR0/N9coGsU/Pw+4VgVvLGi4+ku0DXyzmff4Pl+4RgVvTGi4yUS20+u7oHOSYeEjp/R57l3Q/vz7L7YN/QMaNq4aYGbx1B1+4togXfBMlqM/38Xl7K8Y/6mzj2YLmyW9upIpNRbIfx+tOEdPGTYwAEjOw8fNGjggIGF/TsPGVboy5i6//CHSj3uX5srlfLvfUmj7xXrfYs7vwKlN4ql0zTumiv//c13BSljyY76xYgovVu0cebdotgmNW6IH7eJ8XeLurqbkLxb1E1YGue6ozaCBTE2GgO2fRQUcbr/dWxJPaCpAXJR9Ce7pqEv9vf8EW0+shPbr/z+FRA3eR5SRM1Z3vPs8GdK/MPPZKUZp6jfDlVI8GzotpnMLRsiK2xU04ZbG+P+7kxxcGLbB/pX1MA6ZH/gotGsIWzSGRDp2czTM+YOb7td2WKvfzHG3U6HB42/tXtx6FP0uA8ZfWty6oKGzM/k9jj9ppO8tRvobwF6RrT0ywbnpClwzm0OvDLsxtBYc5sbf3upRt0LgzEqKtyKcabx39Q8HfwOtJJC3bNIflPTAphHYK9llnHfuLxUUfDNYwR5qapQ9+MkeWkJzAuw1/I4QV6SCr6ZS5CXnRTqfpIkLwcA8wLstTxJkJfqCr6ZT5CXnRXqfpokL62AeQH2Wp4myEsNBd8sIsjLrgp1P0OSl9bAvAB7Lc8Q5GV3Bd88T5CXmgp1v0CSlwOBeQH2Wl4gyMueCr5ZQpCXvRTqXkqSl4OAeQH2WpYS5KW2gm+WEeSljkLdy0ny0gaYF2CvZTlBXuop+GYFQV7qK9S9kiQvbYF5AfZaVhLkZW8F37xBkJeGCnW/SZKXg4F5AfZa3iTIyz4KvnmHIC/7KtT9LkleDgHmBdhreZcgLwUKvvmAIC+iUPeHJHlpB8wLsNfyIUFemij45hOCvDRVqPtTkrwcCswLsNfyKUFemin4ZhVBXpor1P0FSV4OA+YF2Gv5giAvLRV88zVBXg5QqPsbkrwcDswLsNfyDUFeWiv4ZjVBXg5UqHsNSV7aA/MC7LUg9XP/bUml7K3/9aL7DIN7X7Z7r6l7/5x7T5B7n4P73e2W30e5z2QGf9y1EMd3bs/q1mE3tzi9csLxUh+o2qPx4F4vi/ek9f85SWWibKMwYawlmCjbKtS9jmSiPAI4UQJ7LesINhaHKPhmPUFe2inUvYEkL0cC8wLstWwgyMthCr7ZSJCXwxXq/pUkLx2AeQH2Wn4lyMsRCr75gyAvRyrU/SdJXjoC8wLstfxJkJeOCr75iyAvRynUnRjJkZejgHkB9lrQ+mnkpbOCb0oYr9vl5WiFunNI8tIJmBdgryWHIC9dFXyTS5CXYxTqLk2Sl87AvAB7LaUJ8nKsgm/KEuTlOIW6y5Hk5WhgXoC9lnIEeemu4JuKBHk5QaHuSiR56QLMC7DXUokgLycp+KYqQV56KNSdT5KXrsC8AHst+QR5OVnBN9UI8nKKQt3VSfJyDDAvwF5LdYK89FbwTQ2CvPRRqHtXkrx0A+YF2GvZlSAv/RR8U5MgL/0V6t6DJC/HAvMC7LXsQZCXAQq+qUWQl1MV6q5NkpfjgHkB9lpqE+RloIJv6hHk5XSFuuuT5OV4YF6AvZb6BHkZpOCbhgR5OVOh7kYkeekOzAuw14LUz33wqXL21g8+uc8wuPdlu/eauvfPufcEufc5uN/dut9HuWvs7rqhuxbi+M7tWd067OaW7uHdINE+THcr8rj93W8H+bDgvz+2u2V63JpPAHoaqV9O6MPUB+pco/GK4wfmgD3f9k646ECe2BBrKMVPYKo168SG9s/xJC1DoVfwHsXkVmTpGh1Xv55A/VgD2ZMgkCezBPKUYnKvs3SNjqtfL5x+jVkD2YsgkL1ZAtmnmNxMLV2j4+rXF6dfE9ZA9iUIZD+WQPYvJndrS9fouPoV4vRryhrIQoJADmAJ5KnF5HZw6RodV7/TcPrtzxrI0wgCOZAlkKcXk/vNpWt0XP3OwOnXjDWQZxAEchBLIM8sJje0S9fouPoNxunXnDWQgwkCOYQlkGcVkzvmpWt0XP3OxunXgjWQZxMEcihLIM8pJrfkS9fouPoNw+nXkjWQwwgCOZwlkOcWk3v+pWt0XP3Ow+nXhzWQ5xEEcgRLIEcWk5sKpmt0XP3Ox+nXlzWQ5xME8gKWQI4qJnctTNfouPpdiNOvH2sgLyQI5EUsgRxdTG6LmK7RcfUbg9OvP2sgxxAE8mKWQF5STO67mK7RcfUbi9OvkDWQYwkCeSlLIC8rJjd2TNfouPpdjtNvAGsgLycI5BUsgbyyGNw50tcPHcirwJ+HrEwYyKsIAnk1SyCvKSZ3KEzX6Lj6XQv+PCRjIK8lCOR1LIG8vpjcAjFdo+PqdwP485CMgbyBIJA3sgTypmJyj8V0jY6r383gz0MyBvJmgkCOYwnkLcXkJo7pGh1Xv1vBn4dkDOStBIG8jSWQ44vJXSLTNTqufreDPw/JGMjbCQJ5B0sg7ywmt6FM1+i4+t0F/jwkYyDvIgjk3SyBnFBM7nOZrtFx9bsH/HlIxkDeQxDIe1kCeV8xuZFmukbH1W8i+POQjIGcSBDISSyBnAwMpOU7daZrdFz9poA/D8kYyCkEgbyfJZAPAANp+Vag6RodV7+p4M9DMgZyKkEgp7EE8kFgIC3fazRdo+Pq9xD485CMgXyIIJDTWQL5MDCQlm9mmq7RcfWbAf48JGMgZxAE8hGWQM4EBtLy3VLTNTqufrPAn4dkDOQsgkDOZgnko8BAWr4da7pGx9XvMfDnIRkD+RhBIB9nCeQcYCAt3+81XaPj6vcE+POQjIF8giCQc1kC+SQwkFZvKKvRYHcD5sEKNyIWghswD1Gou7H9G9+6h7wIHMvvdVz9mpDcwHoecL4BekZY9HuqoY7/CuI9pLHyvBVXNzfecoVxmxufr13NryrU3UIpL9ng+oH9EWTNrh+lElvnh1eCP5vDXrmvK8Kv7jE/yPzTwZ+SwfMq2Vs1io5HY0XHXw//rft+NMaC4PnCcIyq3hjR8X9zPouCn38mHCvfGys6nu58Fnnn82zw/LlwjKQ3RnQ8dYyV4RjPhmM4eHk+eP5COMZO3hjR8dQxXgvHeD4cw9W6OHj+YjhGNW+M6Lh7oLOzsOzfuqPHbWV8Dn6+7N+6osdtTbJ3nNwFN1Yr4N7xQBL9HgDq1xqo30Eke8clwL0j0DOC1M9plpXY/oHeVwG1LPDPd2nDrc9zwq/ZRXiilEJNiZTXSdWxQhHHoC+u0aSlDfHjvtQQF0qtul9qCO+R6uQ+0+ji2I5kcZxldHE8lGRxfBm4OAI9I4cSLo4vKy2OyzKLI7ZJyxQWx+XGF0dX93KlxRH+H9vl/72Qo4n5lYbFs+72xq+QOF++olD3ESSbmOXARbg9cBNzJMkm5lWgfkDPyJEk/ltgFEI6kei30CiEdCbJ7wpgfoGekc6EELJCCUJWZiAE26SVChDymnEIcXW/RgIh44LN+KsKm9Kuxt86cUe+zmb8GJLF6HXgYgTstRxjHOJcrl9X8M1xJJvA15R8E1e/40n0A/pbjgPq151k3noD6D+gZ6Q7if9WGIXgHiT6rTQKwT1J8vsmML9Az0hPQgh+UwmC38pAMLZJbylA8NvGIdjV/TYJBE8IYPANhU19L+MQPDlfB2Z6kyxG7wAXI2CvpbdxCHa5fkfBN/1INoFvK/kmrn79SfQD+lv6AfUrJJm33gX6D+gZKSTx32dGIXggiX6fG4Xg00ny+x4wv0DPyOmEEPyeEgS/n4FgbJPeV4DgD4xDsKv7AxIInhrA4LsKm/ozjUPwjHwdmBlMshh9CFyMgL2WwcYh2OX6QwXfnE2yCfxAyTdx9RtKoh/Q33I2UL9zSOatj4D+A3pGziHx33qjEHweiX4bjELwCJL8fgzML9AzMoIQgj9WguBPMhCMbdInChD8qXEIdnV/SgLBswMY/EhhU3+BcQiem68DM6NIFqPPgIsRsNcyyjgEu1x/puCb0SSbwE+VfBNXvzEk+gH9LaOB+l1MMm99DvQf0DNyMYn/Sna1CcGXkehXCqgfEoIvJ8nvKmB+gZ6RywkheJUSBH+RgWBsk75QgOAvjUOwq/tLEgieH8Dg5wqb+quMQ/Cz+TowczXJYvQVcDEC9lquNg7BLtdfKfjmOpJN4JdKvomr3/Uk+gH9LdcB9buBZN76Gug/oGfkBhL/VTMKweNI9KtuFIJvIcnvN8D8Aj0jtxBC8DdKEPxtBoKxTfpWAYK/Mw7Bru7vSCB4cQCDXyts6scbh+Bl+TowczvJYrQauBgBey23G4dgl+vVCr65i2QT+J2Sb+LqdzeJfkB/y11A/SaQzFtrgP4DekYmkPivgVEInkii395GIXgSSX6/B+YX6BmZRAjB3ytB8A8ZCMY26QcFCF5rHIJd3WtJIHhFAINrFDb19xuH4LfydWDmAZLFaB1wMQL2Wh4wDsEu1+sUfPMgySZwrZJv4ur3EIl+QH/Lg0D9ppPMWz8C/Qf0jEwn8V8roxA8k0S/1kYheBZJfn8C5hfoGZlFCME/KUHw+gwEY5u0XgGCNxiHYFf3BhIIfi+AwR8VNvWPGYfgT/J1YOZxksXoZ+BiBOy1PG4cgl2uf1bwzVyW/xhGyTdx9XuSRD+gv2UuUL95JPPWL0D/AT0j80j818koBC8g0a+zUQheSJLfjcD8Aj0jCwkheKMSBP+agWBsk35VgODfjEOwq/s3EgheFcDgLwqb+meNQ/C3+Tow8xzJYvQ7cDEC9lqeMw7BLte/K/hmMckm8Dcl38TV70US/YD+lsVA/ZaQzFt/AP0H9IwsIfFfL6MQvIxEv95GIXg5SX7/BOYX6BlZTgjBfypB8KYMBGObtEkBgjcbh2BX92YSCP4+gME/FDb1K4xD8Pp8HZhZSbIY/QVcjIC9lpXGIdjl+i8F37xBsgncrOSbuPq9SaIf0N/yBlC/t0jmrUQjnH5Az8hbJP472ygEv0ei31CjEPw+SX6zgPkFekbeJ4RgoJbbQHB2o63PMxAcc0zXJCcoetwSjWxDsKu7RCN4j3R+ax3AYKIRflP/kXEI3pSvAzMfkyxGOcDFCNhr+dg4BLtc5yjk5TOSTWAJJd/EvnUOiX5Af8tnQP1WkcxbJYH+A3pGVpH4b6xRCP6aRL9LjULwNyT5LQXML9Az8g0hBJdSguDcDARjm5SrAMGljUOwq7s0CQRnJROJkgqb+tXGITg3qQMza0gWozzgYgTstawxDsEu13kKvllLsgksreSb2P/RG4l+QH/LWqB+P5LMW2WA/gN6Rn4k8d+tRiH4ZxL9bjMKwb+Q5LcsML9Az8gvhBBcVgmCy2UgGNukcgoQXN44BLu6y5NAcNkABssobOp/Mw7BlZM6MPM7yWJUAbgYAXstvxuHYJfrCgq+2USyCSyv5JvYb1Mn0Q/ob9kE1O8vknmrItB/QM/IXyT+m2oUgkucz6HfNKMQnHM+R34rAfML9Iwg9dtREFxJCYIrZyAY26TKChBcxTgEu7qrkEBwMoDBigqb+tzzbdddI6kDM6VJFqOqwMUI2GspreybuLq5XFdV8E1Zkk1gFSXfxNWvHIl+QH9LWaB+5UnmrXyg/4CekfIk/ptnFIIrk+j3lFEIrkKS3yQwv0DPSBVCCE4qQfBOGQjGNmknBQiuZhyCXd3VSCC4ZgCD+Qqb+qRxCK6T1IGZnUgWo+rAxQjYa9nJOAS7XFdX8M3OJJvAakq+iavfLiT6Af0tOwP1q0Eyb+0M9B/QM1KDxH/LjEJwTRL9lhuF4D1I8rsLML9Az8gehBC8ixIE18hAMLZJNRQgeFfjEOzq3pUEghsEMLizwqa+lnEI3i+pAzO1SRaj3YCLEbDXUts4BLtc76bgm3okm8BdlXwTV7/6JPoB/S31gPo1IJm3dgf6D+gZaUDiv4+MQvA+JPp9bBSC9yXJb01gfoGekX0JIbimEgTvkYFgbJP2UIDgPY1DsKt7TxIIbhLA4O4Km3oxDsEtkzow05hkMdoLuBgBey2NjUOwy/VeCr7Zn2QTuKeSb+Lq14xEP6C/ZX+gfs1J5q1aQP8BPSPNSfy31igEtyLRb51RCG5Nkt/awPwCPSOtCSG4thIE18lAMLZJdRQguK5xCHZ11yWB4AMDGKylsKlvYxyC2yV1YKYtyWJUD7gYAXstbY1DsMt1PQXftCPZBNZV8k1c/Q4l0Q/ob2kH1O8wknmrPtB/QM/IYST+yzrGJgQfSaJfNlA/JAR3IMlvA2B+gZ6RDoQQ3EAJgvfOQDC2SXsrQHBD4xDs6m5IAsHtAxisr7Cp72QcgjsldWCmM8li1Ai4GAF7LZ2NQ7DLdSMF33Ql2QQ2VPJNXP2OIdEP6G/pCtSvG8m8tQ/Qf0DPSDcS/1U1CsHdSfTLNwrBJ5Dkd19gfoGekRMIIXhfJQjeLwPB2CbtpwDBBcYh2NVdQALBXQMY3EdhU9/DOAR3T+rATE+SxUiAixGw19LTOAS7XIuCb3qRbAILlHwTV7/eJPoB/S29gPr1IZm3GgP9B/SM9CHxXx2jEFzI8k4YoxA8gCS/TYD5BXpGBhBCcBMlCG6agWBsk5oqQPD+xiHY1b0/CQT3CGCwscKmfqBxCO6T1IGZ00kWo2bAxQjYazndOAS7XDdT8M2ZJJvA/ZV8E1e/wST6Af0tZwL1G0IybzUH+g/oGRlC4r/mRiH4HBL9WhiF4GEk+W0BzC/QMzKMEIJbKEFwywwEY5vUUgGCDzAOwa7uA0gguDCAweYKm/rzjEPwGUkdmBlBshi1Ai5GwF7LCOMQ7HLdSsE3F5BsAg9Q8k1c/UaR6Af0t1wA1O9CknmrNdB/QM/IhST+O9IoBF9Mol8HoxB8CUl+DwTmF+gZuYQQgg9UguCDMhCMbdJBChDcxjgEu7rbkEDwkAAGWyts6i8zDsHDkzowcznJYtQWuBgBey2XG4fgLXOPgm+uItkEtlHyTVz9ribRD+hvuQqo3zUk89bBQP8BPSPXkPivh1EIvoHl4wxGIfhGkvweAswv0DNyIyEEH6IEwe0yEIxtUjsFCD7UOAS7ug8lgeCRAQwerLCpH2ccgkcndWDmFpLF6DDgYgTstdxiHIJdrg9T8M14kk3goUq+iavf7ST6Af0t44H63UEybx0O9B/QM3IHif/ONArBE0j0G2wUgu8hyW97YH6BnpF7CCG4vRIEH5GBYGyTjlCA4CONQ7Cr+0gSCB4bwODhCpv6icYh+KqkDsxMIlmMOgAXI2CvZZJxCHa57qDgm/tZ3k6p5Ju4+j1Aoh/Q33I/UL+pJPNWR6D/gJ6RqST+G20UgqeT6DfGKAQ/TJLfo4D5BXpGHiaE4KOUILhTBoKxTeqkAMGdjUOwq7szCQRfF8BgR4VN/UzjEDwuqQMzs0gWo6OBixGw1zLLOAS7XB+t4JvHWG7xo+SbuPo9TqIf0N/yGFC/OSTzVheg/4CekTkk/rvJKATPI9HvZqMQ/BRJfrsC8wv0jDxFCMFdlSD4mAwEY5t0jAIEdzMOwa7ubiQQPD6AwS4Km/oFxiF4QlIHZhaSLEbHAhcjYK9loXEIdrk+VsE3z5JsArsp+Saufs+R6Af0tzwL1O95knnrOKD/gJ6R50n8N9koBC8h0W+KUQheSpLf44H5BXpGlhJC8PFKENw9A8HYJnVXgOATjEOwq/sEEgieGMDgcQqb+mXGIXhqUgdmlpMsRicCFyNgr2W5cQh2uT5RwTcrSDaBJyj5Jq5+K0n0A/pbVgD1e41k3joJ6D+gZ+Q1Ev/NMQrBb5Ho94RRCH6bJL89gPkFekbeJoTgHkoQ3DMDwdgm9VSA4JONQ7Cr+2QSCJ4ewOBJCpv694xD8OykDsy8T7IYnQJcjIC9lveNQ7DL9SkKvvmIZBN4spJv4ur3MYl+QH/LR0D9PiGZt3oB/Qf0jHxC4r8lRiF4FYl+S41C8Bck+e0NzC/QM/IFIQT3VoLgPhkIxjapjwIE9zUOwa7uviQQPCeAwV4Km/qvjUPw/KQOzHxDshj1Ay5GwF7LN8Yh2OW6n4JvVpNsAvsq+SaufmtI9AP6W1YD9fueZN7qD/Qf0DPyvfH1blGw3vVXmLd+NF734qTOfP0TSV4KgXkB9lp+Mu6b5cEYhRrvFMSd4xZwLeV55pXgz+bgz6vh1xXhV/cYENRyavCnZPC8evZWqI2OR2NFx18P/637fjTGacHzgeEYO3tjRMf/zfmcHvz8GeFYu3hjRcfTnc/p3vkMCp6fGY5RwxsjOp46xspwjEHhGA7wBwfPh4Rj7OqNER1PHeO1cIzB4Riu1rOC52eHY+zmjREd31EXRV7FjVWQ7Z3n0JBlz/GY9rjwa15i2wskiVCvBLa2AoULLgWuX7leHdEj2zsWvWbkaXcRpmwRP+v7vi3m/CTVM22959Fr+eeS9T8+F1+vhHesRIpWvmei77ledPa+n1PEv4l+NqeIn/NrL6lQu/86bb2/R69VxjuHHAPnkl3EuZTCnsuWdTfKTyKx7cXR6Dyic8r1vlcarIkbI6+I8yjtnUdqzkuFx4Hn0diNUbaI8yjjfY1ev6x3HuWw59EkL+U83OOf8lvOO5fy2HPZ4pEK3mtF51Xe+3v0/ZLeeVTAnseW3JRPqT/6u39+/9dzzSU617z/8bkq+GqAG7MidszGeYltNXWPf8pNRa++SthzaeIymZvY2tdo/FRt/f2HxvxexavX76d7uPmscvjc/7noeY73fX+9j77fxqvJjVkVe/5b+umfl3v8Uz+j13frRjQnnlo4rFthv6GFwzoWjszyxqiSUpe/By7pPffnCY3+JL3XquK9lnu4/uSHz5Pe9zTW352KOA9//Y1eP/q5PO95vnesWsr5+ntF/99Ga2v087lhbTnY2pr4rxU9/slDOV7tnoe6DO87aGC/FA9F45YoYlx/31sy5ed8Tfz9VVbqCbZNQEQQ5EULjfNbWPbvixDoizU/G79I9XzZvy8yoOv+heTi5jDgxU1grwWpX+pFtWHhhaeh4ddzvAtiw4Pn54YXonb3LkRFx//NBbrzgp8fEY5V0xsrOp7uAt153vmMDJ6fH46xhzdGdLxEYvvJ1T3QOemQ0PEz+jyHN7I/z47EvqFnQNPGTQvcPNYWVLe/iF7gXbCMFuP/38WlLO+Yv6lzD6YLm6W9OhIp9VYIvx9teAcPGTZwwMjOwwcNGjhgYGH/zkOGFfoypu4//KFSj/vX5kql/Htf0uh7xXrf4s7vAqU3iqXTNO6aO+q/v/muIGUs2VG/GBml9G7RCzPvFsU26UKFd4teZPzdoq7ui0jeLeomLI1z3VEbwZUxNhoDtn0UFHG6/3VsST2gqQFyUfQnu9GhL8Z4/og2H9mJ7Vd+/wqImzwPKaLmLO95dvgzJf7hZ7LSjFPUb4cqJHg2dNtM5pYNkRU2anSjrY1xf3emODix7QP+n+wAxxoDXDQubgSbdAZEel7s6Rlzh7fdrmy5178Y426nw2/G39q9PPQpetzfjb41OXVBQ+bnwCNw+v1B8tZuoL8F6BnR0i8bnJPRwDn3EuCVYTeGxpp7ifG3l2rUvTgY46SG+Lr/Mv6bmp4BePRQqDtxAcdvasYC8wjstaD108jLyQq+KWG8bpeXUxTqziHJy6XAvAB7LTkEeemt4Jtcgrz0Uai7NEleLgPmBdhrKU2Ql34KvilLkJf+CnWXI8nL5cC8AHst5QjyMkDBNxUJ8nKqQt2VSPJyBTAvwF5LJYK8DFTwTVWCvJyuUHc+SV6uBOYF2GvJJ8jLIAXfVCPIy5kKdVcnyctVwLwAey3VCfIyRME3NQjycpZC3buS5OVqYF6AvZZdCfIyVME3NQnyco5C3XuQ5OUaYF6AvZY9CPIyXME3tQjycq5C3bVJ8nItMC/AXkttgryMUPBNPYK8jFSouz5JXq4D5gXYa6lPkJcLFHzTkCAvoxTqbkSSl+uBeQH2WhoR5OUiBd/sR5CX0Qp1F5Dk5QZgXoC9lgKCvFys4JsmBHm5RKHupiR5uRGYF2CvpSlBXi5V8E1zgrxcplB3C5K83ATMC7DX0oIgL1co+KYVQV6uVKi7NUlebgbmBdhrQern/tuSPbO3/teL7jMM7n3Z7r2m7v1z7j1B7n0O7ne37vdR7hq7u27oroU4vnN7VrcOu7nF6ZUTjpf6QNUejQf3ejm8J63/z0kqE+XVChNGG4KJ8hqFutuSTJTjgBMlsNfSlmBjcZ2Cb9oR5OV6hboPJcnLLcC8AHsthxLk5UYF37QnyMtNCnUfQZKXW4F5AfZajiDIyzgF33QkyMstCnUfRZKX24B5AfZajiLIy20KvjmaIC/jFeruQpKX8cC8AHstXQjycoeCb7oR5OVOhbqPJcnL7cC8AHstxxLk5W4F33QnyMsEhbpPIMnLHcC8AHstJxDk5V4F3/QgyMt9CnX3JMnLncC8AHstPQnyMknBN70I8jJZoe7eJHm5C5gXYK+lN0Fe7lfwTT+CvDygUHd/krzcDcwLsNfSnyAv0xR8cypBXh5UqPs0krxMAOYF2Gs5jSAv0xV8cwZBXh5WqHsQSV7uAeYF2GsZRJCXRxR8M4QgLzMV6j6LJC/3AvMC7LWcRZCX2Qq+OYcgL48q1D2MJC/3AfMC7LUMI8jL4wq+OY8gL3MU6h5BkpeJwLwAey0jCPIyV8E3FxDk5UmFukeR5GUSMC/AXgtSP/fBp72yt37wyX2Gwb0v273X1L1/zr0nyL3Pwf3u1v0+yl1jd9cN3bUQx3duz+rWYTe3TArvBon2Ybpbkce+CdUO8mHBf39sd8v0uDVPBnoaqV9O6MPUB+pco/GK4wfmgD3f9k646EBOaYQ1lOInMNWaNaWR/XO8X8tQ6BX8gWJyK7J0jY6r31SgfqyBnEoQyGksgXywmNzrLF2j4+r3EE6/xqyBfIggkNNZAvlwMbmZWrpGx9VvBk6/JqyBnEEQyEdYAjmzmNytLV2j4+o3C6dfU9ZAziII5GyWQD5aTG4Hl67RcfV7DKff/qyBfIwgkI+zBHJOMbnfXLpGx9XvCZx+zVgD+QRBIOeyBPLJYnJDu3SNjqvfPJx+zVkDOY8gkE+xBHJ+MbljXrpGx9XvaZx+LVgD+TRBIBewBHJhMbklX7pGx9VvEU6/lqyBXEQQyGdYAvlsMbnnX7pGx9XvOZx+fVgD+RxBIJ9nCeQLxeSmgukaHVe/xTj9+rIGcjFBIF9kCeSSYnLXwnSNjqvfUpx+/VgDuZQgkC+xBPLlYnJbxHSNjqvfMpx+/VkDuYwgkMtZAvlKMbnvYrpGx9XvVZx+hayBfJUgkCtYArmymNzYMV2j4+r3Gk6/AayBfI0gkK+zBPKNYnDnSF8/dCDfBH8eci/CQL5JEMi3WAL5djG5Q2G6RsfV7x3w5yEZA/kOQSDfZQnke8XkFojpGh1Xv/fBn4dkDOT7BIH8gCWQHxaTeyyma3Rc/T4Cfx6SMZAfEQTyY5ZAflJMbuKYrtFx9fsU/HlIxkB+ShDIz1gC+XkxuUtkukbH1W8V+POQjIFcRRDIL1gC+WUxuQ1lukbH1e8r8OchGQP5FUEgv2YJ5DfF5D6X6RodV79vwZ+HZAzktwSB/I4lkKuLyY000zU6rn5rwJ+HZAzkGoJAfs8SyB+KyZ060zU6rn5rwZ+HZAzkWoJArmMJ5I/AQFq+FWi6RsfV7yfw5yEZA/kTQSDXswRyAzCQlu81mq7RcfX7Gfx5SMZA/kwQyF9YArkRGEjLNzNN1+i4+v0K/jwkYyB/JQjkbyyB/B0YSMt3S03X6Lj6/QH+PCRjIP8gCOSfLIHcBAyk5duxpmt0XP02gz8PyRjIzQSB/IslkIl9cEVbvt9rukbH1S8Lp98A1kACNVA7x+x9SAJZAhhIqzeU1WiwuwHzPIUbEV9McAPmpxTqvsT+jW/dQ14BjuX3Oq5+Y0luYJ0DnG+AnhEW/Uruo+O/gngPuUR53oq9cQrGeENh3CuMz9eu5rcU6r5SKS/Z4PqB/RFkza4fpRJb54c3gz+bw165r2+HX92jVJD53OBPyeB5reytGkXHo7Gi4++F/9Z9PxqjdPA8LxyjtjdGdPzfnE+Z4OfLhmPV8caKjqc7nzLe+ZQLnpcPx6jrjREdTx3jnXCMcuEYDl4qBM8rhmPU88aIjqeO8W44RoVwDFdrpeB55XCM+t4Y0XH3QGfnlHJ/644e9xrjc3C/cn/rih73WpK94+QuuLGuAe4dryPR7wGgftcC9bueZO9YBbh3BHpGkPo5zbIS2z/Q+yqglgX++VbdZ+vznPBrdhGeKKVQUyLldVJ1rFDEMeiLazSp6j74cfP3AV4RV6o7fx94j1Qn95lGF8dxJIvjLKOL4y0ki2MSuDgCPSO3EC6OSaXFcafM4oht0k4Ki2M144ujq7ua0uKIPtdr8/9eyNHEXH2f4ln3eONXSJwvqyvUfTvJJqYacBEeD9zE3EGyidkZqB/QM3IHif8WGIWQCST6LTQKIfeQ5HcXYH6BnpF7CCFkFyUIqZGBEGyTaihAyK7GIcTVvSsJhIwLNuM7K2xKJxp/68Qd+Tqb8Ukki9FuwMUI2GuZZBziXK53U/DN/SSbwF2VfBNXvwdI9AP6W+4H6jeVZN7aHeg/oGdkKon/VhiF4Okk+q00CsEPk+S3JjC/QM/Iw4QQXFMJgvfIQDC2SXsoQPCexiHY1b0nCQRPCGBwd4VN/UzjEDw5XwdmZpEsRnsBFyNgr2WWcQh2ud5LwTePkWwC/x97bwJn5fj+j5+ZZtr35iiyE7LUXE2rShuilBJCoW0mKSKFbA1lL1t2shVFoZAQsqUosoVsIVtIURTC/7nzPP/uTnP8vjzvaz7X+zXneb16zek5Z+5zX+/r/b6v6/2c58y9ixJv4uL3GMvtbECtPArEbzbJurUbkH9AzshsEv59ZtQEP0mC3+dGTfBTJPrdHahfIGfkKUITvLuSCW6QMcHYJDVQMMF7GDfBLu49SEzw1MAM7qbQ1D9j3AQ/mKdjZp4lKUZ7AosRMNfyrHET7HS9pwJvnidpAvdQ4k1c/F5guZ0SqJXngfi9SLJu7QXkH5Az8iIJ/9YaNcELSPBbZ9QELyTRb0OgfoGckYWEJrihkgneO2OCsUnaW8EE72PcBLu49yExwbMCM7iXQlO/yLgJnpOnY2YWkxSjfYHFCJhrWWzcBDtd76vAmyUkTeA+SryJi98bJPgB+S1LgPi9SbJu7QfkH5Az8iYJ/3J72jTBS0nwKw/ED2mC3yXRbyOgfoGckXcJTXAjJRPcOGOCsUlqrGCC842bYBd3PokJnhuYwf0Umvplxk3w83k6ZuYDkmIkwGIEzLV8YNwEO12LAm8+JmkC85V4Exe/T0jwA/JbPgbit5xk3WoC5B+QM7KchH91jZrgFST41TNqgr8g0W8BUL9AzsgXhCa4QMkEN82YYGySmiqY4GbGTbCLuxmJCZ4fmMEmCk3918ZN8KI8HTPzDUkxag4sRsBcyzfGTbDTdXMF3nxH0gQ2U+JNXPy+J8EPyG/5DojfKpJ1qwWQf0DOyCoS/jU0aoJ/JMFvb6Mm+CcS/bYE6hfIGfmJ0AS3VDLBrTImGJukVgomeH/jJtjFvT+JCV4SmMEWCk39z8ZN8NI8HTPzC0kxag0sRsBcyy/GTbDTdWsF3vxK0gTur8SbuPj9RoIfkN/yKxC/30nWrTZA/gE5I7+T8K+1URP8Fwl+bYya4MR5HPptC9QvkDOCxK+0THBbJRN8QMYEY5N0gIIJbmfcBLu425GY4GWBGWyj0NSXO8923MvzdMxMDkkxag8sRsBcS44yb+LitmntUeBNhVLiTX68Y4u1Nz/esQVv4uJXkQQ/IL+lAhC/SiTrVgcg/4CckUok/Otm1ARXI8Gvu1ETXJ1Evx2B+gVyRqoTmuCOSia4U8YEY5PUScEEH2jcBLu4DyQxwSsCM9hBoamvZdwEr8zTMTO1SYrRQcBiBMy11DZugp2uD1LgTZKkCTxQiTdx8duGBD8gvyUJxK8uybp1MJB/QM5IXRL+nWjUBNcnwa+fURO8PYl+OwP1C+SMbE9ogjsrmeBDMiYYm6RDFEzwocZNsIv7UBITvCowgwcrNPU7GTfBa/N0zMzOJMWoC7AYAXMtOxs3wU7XXRR4sxtJE3ioEm9i7z9Jgh+Q37IbEL8GJOtWVyD/gJyRBiT8O92oCW5Igt8IoyZ4bxL9HgbUL5AzsjehCT5MyQR3y5hgbJK6KZjg7sZNsIu7O4kJXh+Ywa4KTf1+xk3wH3k6ZqYRSTE6HFiMgLmWRsZNsNP14Qq8EZbbAZV4E/uvBpPgB+S3CBC/ApJ1qweQf0DOSAEJ/8YaNcEtSPAbZ9QEtyTRb0+gfoGckZaEJrinkgk+ImOCsUk6QsEE9zJugl3cvUhMcFYykeih0NS3Nm6CKyR1zEwbkmJ0JLAYAXMtbYybYKfrIxV4046kCeylxJvY33EnwQ/Ib2kHxK8Dybp1FJB/QM5IBxL+3WDUBB9Egt+NRk3wwST6PRqoXyBn5GBCE3y0kgnunTHB2CT1VjDBxxg3wS7uY0hMcJXADB6l0NQfatwE10rqmJkuJMXoWGAxAuZauhg3wU7XxyrwphtJE3iMEm9if0JPgh+Q39INiN/hJOvWcUD+ATkjh5Pwb6pRE9yLBL9pRk3wkST67QPUL5AzciShCe6jZIL7ZkwwNkl9FUzw8cZNsIv7eBITnAzM4HEKTX1v4ya4flLHzBxDUoxOABYjYK7lGOMm2On6BAXe9CFpAo9X4k1c/PqyXEQAaqUPEL/jSdatE4H8A3JGjifh35NGTXB/EvyeMmqCB5Dotx9Qv0DOyABCE9xPyQT3z5hgbJL6K5jgAcZNsIt7AIkJ3ikwgycqNPWFxk1wg6SOmSkiKUYDgcUImGspMm6Cna4HKvBmCEkTOECJN3HxO5kEPyC/ZQgQv6Ek69YgIP+AnJGhJPxbZNQEDyfBb7FRE3waiX4LgfoFckZOIzTBhUomuChjgrFJKlIwwYONm2AX92ASE9wwMIODFJr6M4yb4MZJHTMzkqQYnQQsRsBcy0jjJtjp+iQF3pxF0gQOVuJNXPzOJsEPyG85C4jfaJJ1awiQf0DOyGgS/n1s1ASfT4LfJ0ZN8AUk+j0ZqF8gZ+QCQhN8spIJHpoxwdgkDVUwwcOMm2AX9zASE1wQmMEhCk39hcZNcKukjpm5iKQYnQIsRsBcy0XGTbDT9SkKvLmYpAkcpsSbuPhdQoIfkN9yMRC/S0nWrVOB/ANyRi4l4d9qoyb4ShL81hg1weNJ9DscqF8gZ2Q8oQkermSCT8uYYGySTlMwwacbN8Eu7tNJTHDbwAyeqtDUX23cBHdK6piZa0iK0QhgMQLmWq4xboKdrkco8GYiyz6jSryJi9/1JPgB+S0TgfjdQLJunQHkH5AzcgMJ/7KOsGmCbyHBLxuIH9IE30qi35FA/QI5I7cSmuCRSiZ4VMYEY5M0SsEEn2ncBLu4zyQxwZ0DM3iGQlM/ybgJ7pbUMTN3kBSjs4DFCJhrucO4CXa6PkuBN3eTNIFnKvEmLn73kOAH5LfcDcRvMsm6dTaQf0DOyGQS/tUxaoKnkuCXZ9QETyPR72igfoGckWmEJni0kgk+J2OCsUk6R8EEn2vcBLu4zyUxwT0DM3i2QlM/3bgJ7p3UMTMzSIrRecBiBMy1zDBugp2uz1PgzcMkTeC5SryJi99MEvyA/JaHgfjNIlm3zgfyD8gZmUXCvwZGTfBsEvz2MGqCHyfR7wVA/QI5I48TmuALlEzwmIwJxiZpjIIJLjZugl3cxSQmuE9gBs9XaOqfNG6C+yd1zMxTJMXoQmAxAuZanjJugp2uL1TgzTMkTWCxEm/i4vcsyxYrQK08A8RvHsm6dRGQf0DOyDwS/rUwaoJfJMGvpVET/BKJfscC9QvkjLxEaILHKpngcRkTjE3SOAUTfLFxE+zivpjEBBcGZvAihaZ+gXETPDSpY2YWkhSjS4DFCJhrWWjcBDtdX6LAm0UkTeDFSryJi99iEvyA/JZFQPxeI1m3LgXyD8gZeY2Ef4caNcFvkuDXxagJfotEv5cB9QvkjLxFaIIvUzLBl2dMMDZJlyuY4CuMm2AX9xUkJnh4YAYvVWjqlxo3waOSOmbmXZJidCWwGAFzLe8aN8FO11cq8GYZSRN4hRJv4uL3AQl+QH7LMiB+H5KsW+OB/ANyRj4k4V8foyZ4OQl+fY2a4E9J9DsBqF8gZ+RTQhM8QckEX5UxwdgkXaVggq82boJd3FeTmODRgRkcr9DUrzBugsckdczMFyTF6BpgMQLmWr4wboKdrq9R4M3XJE3g1Uq8iYvfNyT4AfktXwPxW0mybl0L5B+QM7KShH+nGDXBq0jwO9WoCf6BRL/XAfUL5Iz8QGiCr1MywRMzJhibpIkKJvh64ybYxX09iQkeG5jBaxWa+h+Nm+DLkzpm5ieSYnQDsBgBcy0/GTfBTtc3KPDmZ5Im8Hol3sTF7xcS/ID8lp+B+K0nWbduBPIPyBlZT8K/MUZN8O8sfxPBqAneSKLfm4D6BXJGNhKa4JuUTPDNGROMTdLNCib4FuMm2MV9C4kJnhCYwRsVmvq/jJvgiUkdM5M4n6MY3QosRsBcCxo/dH6drm9V4E25UuJNfrxji7U3P96xBW/i4pdDgh+Q3+JzJi5+uSTr1m1A/gE5I7kk/LvWqAmuRILfdUZNcGUS/d4O1C+QM4LEr7RM8O1KJnhSxgRjkzRJwQTfYdwEu7jvIDHBNwVm8DaFpr7a+bbjnpTUMTPVSYrRncBiBMy1VDdugp2u71TgTS2SJvAOJd7Exa82CX5AfkstIH51SNatu4D8A3JG6pDwb7JRE1yXBL8pRk1wPRL93g3UL5AzUo/QBN+tZILvyZhgbJLuUTDBk42bYBf3ZBITfHdgBu9SaOrrGzfBU5M6ZmZ7kmI0BViMgLmW7Y2bYKfrKQq82YmliVbiTVz8dibBD8hv2QmI3y4k69a9QP4BOSO7kPBvtlET3IAEv8eNmuA9SPR7H1C/QM7IHoQm+D4lEzw1Y4KxSZqqYIKnGTfBLu5pJCZ4emAG71Vo6hsaN8GzkjpmZm+SYnQ/sBgBcy17GzfBTtf3K/BmP5ImcJoSb+Li14gEPyC/ZT8gfo1J1q0HgPwDckYak/BvgVETXECC30KjJrgpiX6nA/UL5Iw0JTTB05VM8IyMCcYmaYaCCX7QuAl2cT9IYoJnB2bwAYWmvoVxEzw3qWNmWpIUo4eAxQiYa2lp3AQ7XT+kwJvWJE3gg0q8iYtfGxL8gPyW1kD82pKsWw8D+QfkjLQ1Xu/mBfXuYYV1q4PxuOcnddbrjiR6mQnUCzDX0tE4b94OxpipwJu3cXPcZFzLe5x5J/j3Z/Bvafjz3fCnO2YFsTwS/MsNHjfM3mxqo/PRWNH5ZeHvuuejMR4NHj8WjrG3N0Z0/t/MZ3bw+sfDsfbxxorOp5vPbG8+c4LHT4Rj7OuNEZ1PHeO9cIw54RjO4D8ZPH4qHGM/b4zofOoY74djPBmO4WKdGzx+OhyjkTdGdL60LoosxY2Vn+3N85nQyz7redqjwp+VElteIEmEeCWwseUrXHDJd/mq4MURHdneueg9I067izBVSnitz/v2mPlJKmfae4+j9/LnkvU/nouPV8I7Vy4FK58z0XMuF92953NK+J3otTklvM6PPVchdv992nv/j96rsjeHHANzyS5hLuWxc9lUdyP9JBJbXhyN5hHNqYL3XEUwJm6MSiXMo6I3j1Sdlw/PA+fRxI1RpYR5VPZ+Ru9fxZtHVew8CiqlzMMd/6Tfqt5cqmHnsokj1b33iuZVzft/9HyuN4/q2Hls0k21lPij//vz+7/OtQLRXCv9j+eqwKsiN2YN7JhNKiW2xNQd/6SbGl58NbFzKXCarJDYnNdo/FRs/f5DY32v7cXr59Mdbj2rFT72Xxc9zvGe9+t99Hw7LyY3Zh3s/Dfl05+XO/4pn9H7u7oRrYmDC0f2Khw4onBk18LRWd4YtVPi8nvgXO+xv05o5CfpvVdt773c4fKTFz5Oes9p1N9tSpiHX3+j949eV8l7nOedq5syX79X9H83qq3R6yuEseVgYyvw3ys6/olDOV7sHod6jBowbMjAFA5F45YrYVy/781NeZ2Pid9fZaVOsH0CAoIgL1pozO+Eqn9fhEBfrDnI+EWqgVX/vsiAjvtgkoub84AXN4G5FiR+qRfV5oUXnp4Jfz7rXRB7Lnj8fHghqrF3ISo6/28u0L0QvP7FcKx8b6zofLoLdC9483kpeDw/HEO8MaLz5RJbL67uQOukS0KHz+h5Pref/XX2JewNPUVNmzTNd+sYKm6/iL7sXbCMivH/6+JSlnfOb+rcwXRhs6IXRyIl3urh81HDe+rwkUOKRncfNWzYkKIhhYO6Dx9Z6MOY2n/4Q6We96/NlU/5fR/S6Lky3be4+b2sdKNYOkzj1twF//3mu/yUsaS0PhhZoHS36MLM3aLYJC3cDz/uK8bvFnVxv0Jyt6hbsDTmWlqN4GkxGo2iLY/8Eqb7X8eW1BOaGCCLor/YvRryYpHHj6j5yE5sXfn9KyBu8exYQsxZ3uPs8DXl/uE1WWnGKenToeoJnoZui8XcMiGywkS9ut/mxLj/O1J0SGx5oD+iBsYhi4BFY/F+sEWnKMJzsYdnzA5vq67sbS9/McbdCodDjd/a/XbIU/S4XYzempxa0JD6ee8QHH5dSW7tBvJbgJwRLfyywTp5Fbjmvga8MuzG0Ki5rxm/vVQj7sXBGPfui4/7cOOf1GwMPse/TyHuHiSf1LwO1CMw19LDOG+cXqYp8KYXgV7uV4j7SBK9LAHqBZhrOZJAL9MVeNObQC8zFOI+hkQvbwD1Asy1HEOgl4cUeNOHQC8PK8Tdl0QvbwL1Asy19CXQyywF3pxIoJdHFOLuR6KXt4B6AeZa+hHo5TEF3gwk0MtshbgHkejlbaBegLmWQQR6maPAm8EEenlCIe6TSPTyDlAvwFzLSQR6eUqBN0MJ9DJXIe5hJHpZCtQLMNcyjEAvzyjwZjiBXp5ViPs0Er28C9QLMNdyGoFenlPgzRkEenleIe6RJHp5D6gXYK5lJIFeXlTgzVkEenlJIe6zSfTyPlAvwFzL2QR6eVmBN+cS6GWBQtznkehlGVAvwFzLeQR6eUWBN2MI9PKqQtzFJHr5AKgXYK6lmEAvixV4M5ZAL68pxD2ORC8fAvUCzLWMI9DLEgXeXEqglzcU4r6MRC8fAfUCzLVcRqCXtxR4cyWBXt5WiHs8iV4+BuoFmGtB4uf+bEmT7M1/etF9h8Hdl+3uNXX3z7l7gtx9Du6zW/d5lLvG7q4bumshzt+5ntXVYbe2OLxywvFSD1Ts0XhwrlfFc9L6X05SWSiXKiwYVxMslO8qxH0NyUL5CXChBOZariFoLN5X4M1EAr0sU4j7ehK9LAfqBZhruZ5ALx8q8OYmAr18pBD3zSR6+RSoF2Cu5WYCvXyiwJvbCPSyXCHu20n08hlQL8Bcy+0EevlMgTd3Eujlc4W47yLRy+dAvQBzLXcR6OULBd5MJtDLlwpxTyHRywqgXoC5likEevlagTdTCfTyjULc00j08gVQL8BcyzQCvXyrwJvpBHr5TiHuGSR6+RKoF2CuZQaBXlYp8OZhAr38oBD3TBK9fAXUCzDXMpNAL2sUePMogV5+VIj7MRK9fA3UCzDX8hiBXtYq8GYOgV7WKcT9BIlevgHqBZhreYJAL78o8GYugV7WK8T9NIleVgL1Asy1PE2gl18VeDOPQC+/KcT9HIlevgXqBZhreY5ALxsVePMigV7+UIj7JRK9fAfUCzDX8hKBXv5S4M0CAr0kFDbiWEiil++BegHmWhYS6CVbgTeLCPRSTiHuxSR6WQXUCzDXgsTPffGpIHvzF5/cdxjcfdnuXlN3/5y7J8jd5+A+u3WfR7lr7O66obsW4vyd61ldHXZry6pwN0g0D9NtRR57441S4mH+fz+22jI9bsw/ADmNxC8n5GHqgZprNF5Z/MIcMOdb7oSLFuTq/bCEUvwGplqyVu9nf45rtAiFruA/lpGtyNIlOi5+PwHxYxXkTwSCXMsiyHVlZK+zdImOi9/POPyasAryZwJB/sIiyPVlZDO1dImOi98GHH4FrILcQCDIX1kE+VsZ2a0tXaLj4vc7Dr+mrIL8nUCQG1kE+UcZ2Q4uXaLj4vcnDr9mrIL8k0CQf7EIMtEIF7Tl/ebSJTouflk4/JqzChKIgdocsxuRCLIcUJCWN7RLl+i4+OXg8GvBKsgcAkHmsgiyPFCQlnfMS5fouPhVwOHXklWQFQgEWZFFkJWAgrS8JV+6RMfFrzIOv1asgqxMIMgqLIKsChSk5T3/0iU6Ln7VcPj1ZxVkNQJBVmcRZA2gIC1vKpgu0XHxq4nDbwCrIGsSCLIWiyBrAwVpedfCdImOi18dHH4DWQVZh0CQeSyCTAIFaXlbxHSJjovfNjj8BrEKchsCQdZlEWQ9oCAt77uYLtFx8dsWh18hqyC3JRDkdiyCrA8UpOWNHdMlOi5+2+PwK2IV5PYEgtyBRZA7AgVpdedIHz+0IHcCJlr5C7ZqZN+JQJA7swhyF6AgLe9QmC7RcfHbFYgfqyB3JRDkbiyC3B1IKMtbIKZLdFz8GuDwa8IqyAYEgtyDRZB7AgVpeY/FdImOi99eOPwKWAW5F4EgG7IIcm+gIC1v4pgu0XHx2weHX1NWQe5DIMh9WQS5H1CQlneJTJfouPg1wuHXjFWQjQgE2ZhFkPlAQVrehjJdouPiJ+DvQzIKUggE2YRFkAVAQVre5zJdouPi1xT8fUhGQTYlEGQzFkE2BwrS8kaa6RIdF78W4O9DMgqyBYEgW7IIshVQkJZ36kyX6Lj47Q/+PiSjIPcnEGRrFkG2AQrS8lag6RIdF7+24O9DMgqyLYEgD2ARZDugIC3vNZou0XHxaw/+PiSjINsTCLIDiyA7AgVpeTPTdImOi18n8PchGQXZiUCQB7II8iCgIC3vlpou0XHxOxj8fUhGQR5MIMjOLII8BChIy9uxpkt0XPwOBX8fklGQhxIIsguLILsCBWl5v9d0iY6L32Hg70MyCvIwAkF2YxFkd6AgrW4oq5FgtwFzjsIGsG8SbMCcqxD3W/Y3vnWHvAMcy891XPzeJtnA+nDgegPkjLDg16ORDv/y4x3ylvK6FXuHiWCMDxTGfc/4eu1i/kgh7veV9JINjh+YH0HG7PJRPrF5ffgw+PdnmCv38+Pwpzt6Bpo/IviXGzxumr0Zo+h8NFZ0/tPwd93z0Ri9gsdHhmM088aIzv+b+RwVvP7ocKzm3ljR+XTzOcqbT+/g8THhGC28MaLzqWN8Eo7ROxzDmZdjg8fHhWO09MaIzqeOsTwc49hwDBdrn+Bx33CMVt4Y0Xl3wLefqvo37uhxPzS+Bper9jeu6HE/IukdJ/fAjfUhsHf8mAS/+4D4fQTE7xOS3vF4YO8I5Iwg8XOYZSW2PtB9FRDLfH++JzTa/Dgn/JldAifKK8SUSHmfVByrl3AO+uYaSTqhEX7cExvhRKkV94mN4DlSXdwfNlocV5AUx5lGi+MXJMWxH7A4AjkjXxAWx35KxbF/pjhik9RfoTgOMF4cXdwDlIojeq7j8/4u5GjHPLBR2Yz7a+NXSBwvByrE/Q1JEzMAWIS/BjYxK0mamEFA/ICckZUk/HvGqAlZRYLfs0ZNyA8k+i0E6hfIGfmB0IQUKpmQoowJwSapSMGEDDZuQlzcg0lMyMSgGR+k0JT+aPzWiVvydJrxn0iK0UnAYgTMtfxk3MQ5XZ+kwJufSZrAwUq8iYvfLyT4AfktPwPxW0+ybg0B8g/IGVlPwr8lRk3w7yT4vWHUBG8k0e/JQP0COSMbCU3wyUomeGjGBGOTNFTBBA8zboJd3MNITPCkwAwOUWjq/zJugifn6ZiZxAUcxegUYDEC5lrQ+KHz63R9igJvypUSb/LjHVusvfnxji14Exe/HBL8gPwWnzNx8cslWbdOBfIPyBnJJeHfZ0ZNcCUS/D43aoIrk+h3OFC/QM4IEr/SMsHDlUzwaRkTjE3SaQom+HTjJtjFfTqJCZ4amMFTFZr6ahfYjvvBPB0zU52kGI0AFiNgrqW6cRPsdD1CgTe1SJrA05V4Exe/2iT4AfkttYD41SFZt84A8g/IGalDwr+1Rk1wXRL81hk1wfVI9DsSqF8gZ6QeoQkeqWSCR2VMMDZJoxRM8JnGTbCL+0wSEzwrMINnKDT19Y2b4Dl5OmZme5JidBawGAFzLdsbN8FO12cp8GYnkibwTCXexMVvZxL8gPyWnYD47UKybp0N5B+QM7ILCf9ye9o0wQ1I8CsPxA9pgvcg0e9ooH6BnJE9CE3waCUTfE7GBGOTdI6CCT7XuAl2cZ9LYoLnBmbwbIWmvqFxE/x8no6Z2ZukGJ0HLEbAXMvexk2w0/V5CrzZj6QJPFeJN3Hxa0SCH5Dfsh8Qv8Yk69b5QP4BOSONSfhX16gJLiDBr55RE9yURL8XAPUL5Iw0JTTBFyiZ4DEZE4xN0hgFE1xs3AS7uItJTPD8wAyer9DUtzBughfl6ZiZliTF6EJgMQLmWloaN8FO1xcq8KY1SRNYrMSbuPi1IcEPyG9pDcSvLcm6dRGQf0DOSFsS/jU0aoI7sFzEMmqCO5LodyxQv0DOSEdCEzxWyQSPy5hgbJLGKZjgi42bYBf3xSQmeElgBi9SaOoPMm6Cl+bpmJmDSYrRJcBiBMy1HGzcBDtdX6LAm0NJmsCLlXgTF78uJPgB+S2HAvHrSrJuXQrkH5Az0pWEf62NmuDDSfBrY9QE9yDR72VA/QI5Iz0ITfBlSib48owJxibpcgUTfIVxE+zivoLEBC8LzOClCk19L+MmeHmejpk5kqQYXQksRsBcy5HGTbDT9ZUKvOlN0gReocSbuPgdQ4IfkN/SG4jfsSTr1ngg/4CckWNJ+NfNqAk+ngS/7kZN8Akk+p0A1C+QM3ICoQmeoGSCr8qYYGySrlIwwVcbN8Eu7qtJTPCKwAyOV2jq+xs3wSvzdMzMAJJidA2wGAFzLQOMm2Cn62sUeFNI0gRercSbuPgVkeAH5LcUAvEbTLJuXQvkH5AzMpiEfycaNcFDSfDrZ9QEDyPR73VA/QI5I8MITfB1SiZ4YsYEY5M0UcEEX2/cBLu4rycxwasCM3itQlM/3LgJXpunY2ZOIylGNwCLETDXcppxE+x0fYMCb84gaQKvV+JN7K03SPAD8lvOAOI3imTduhHIPyBnZBQJ/043aoJHk+A3wqgJPodEvzcB9QvkjJxDaIJvUjLBN2dMMDZJNyuY4FuMm2AX9y0kJnh9YAZvVGjqzzdugv/I0zEzF5AUo1uBxQiYa7nAuAl2ur5VgTcXkjSBtyjxJvYfTCLBD8hvuRCI31iSdes2IP+AnJGxJPwba9QEX0qC3zijJvgyEv3eDtQvkDNyGaEJvl3JBE/KmGBskiYpmOA7jJtgF/cdJCY4K5lI3KbQ1F9p3ARXSOqYmfEkxehOYDEC5lrGGzfBTtd3KvDmapIm8A4l3sS+vZ8EPyC/5WogfteSrFt3AfkH5IxcS8K/G4ya4BtI8LvRqAm+kUS/dwP1C+SM3Ehogu9WMsH3ZEwwNkn3KJjgycZNsIt7MokJrhKYwbsUmvpbjJvgWkkdM3MrSTGaAixGwFzLrcZNsNP1FAXeTCJpAicr8Sb2xQkS/ID8lklA/O4kWbfuBfIPyBm5k4R/U42a4Mkk+E0zaoKnkOj3PqB+gZyRKYQm+D4lEzw1Y4KxSZqqYIKnGTfBLu5pJCY4GZjBexWa+qnGTXD9pI6ZmUZSjO4HFiNgrmWacRPsdH2/Am+mszSBSryJi98MFvyAWpkOxO9BknXrASD/gJyRB0n496RREzyLBL+njJrgR0j0Ox2oXyBn5BFCEzxdyQTPyJhgbJJmKJjgB42bYBf3gyQmeKfADD6g0NTPNm6CGyR1zMzjJMXoIWAxAuZaHjdugp2uH1LgzZMkTeCDSryJi99TJPgB+S1PAvGbS7JuPQzkH5AzMpeEf4uMmuB5JPgtNmqCnyPR70ygfoGckecITfBMJRM8K2OCsUmapWCCHzFugl3cj5CY4IaBGXxYoal/0bgJbpzUMTMvkRSjR4HFCJhrecm4CXa6flSBNwtImsBHlHgTF7+FJPgB+S0LgPi9QrJuPQbkH5Az8goJ/z42aoJfI8HvE6Mm+HUS/c4G6hfIGXmd0ATPVjLBj2dMMDZJjyuY4DnGTbCLew6JCS4IzOBjCk39m8ZNcKukjpl5i6QYPQEsRsBcy1vGTbDT9RMKvFlK0gTOUeJNXPzeJcEPyG9ZCsTvPZJ160kg/4CckfdI+LfaqAn+kAS/NUZN8Eck+n0KqF8gZ+QjQhP8lJIJnpsxwdgkzVUwwU8bN8Eu7qdJTHDbwAw+qdDULzdugjsldczMpyTF6BlgMQLmWj41boKdrp9R4M0KkibwaSXexMXvCxL8gPyWFUD8viRZt54F8g/IGfmShH9ZR9g0wStJ8MsG4oc0wd+S6HceUL9Azsi3hCZ4npIJfi5jgrFJek7BBD9v3AS7uJ8nMcGdAzP4rEJTv8q4Ce6W1DEzP5AUoxeAxQiYa/nBuAl2un5BgTc/kjSBzyvxJi5+P5HgB+S3/AjEby3JuvUikH9AzshaEv7VMWqC15Pgl2fUBG8g0e9LQP0COSMbCE3wS0omeH7GBGOTNF/BBL9s3AS7uF8mMcE9AzP4okJT/7txE9w7qWNmNpIUowXAYgTMtWw0boKdrhco8OYvkibwZSXexF7Hx3DgB+S3/AXEL2sMx7q1EMg/IGcki4R/DYya4FwS/PYwaoLLk+j3FaB+gZwRJH6lZYJfUTLBr2ZMMDZJryqY4EXGTbCLexGJCe4TmMGFCk19pTG24+6f1DEzlUmK0WJgMQLmWior8yYubk7XixV4U42kCVykxJu4+FUnwQ/Ib6kGxK8Gybr1GpB/QM5IDRL+tTBqguuQ4NfSqAnOI9Hv60D9AjkjeYQm+HUlE7wkY4KxSVqiYILfMG6CXdxvkJjgwsAMvqbQ1Nc1boKHJnXMTD2SYvQmsBgBcy31jJtgp+s3FXhTn6QJfEOJN3Hx254EPyC/pT4Qvx1I1q23gPwDckZ2IOHfoUZN8C4k+HUxaoJ3JdHv20D9AjkjuxKa4LeVTPA7GROMTdI7CiZ4qXET7OJeSmKChwdm8C2Fpr6BcRM8KqljZvYgKUbvAosRMNeyh3ET7HT9rgJvGpI0gUuVeBMXv71ZbqcEaqUhEL99SNat94D8A3JG9iHhXx+jJrgxCX59jZrgfBL9vg/UL5Azkk9ogt9XMsHLMiYYm6RlCib4A+Mm2MX9AYkJHh2YwfcUmvoC4yZ4TFLHzDQlKUYfAosRMNfS1LgJdrr+UIE3LUiawA+UeBMXv5Yk+AH5LS2A+LUiWbc+AvIPyBlpRcK/U4ya4LYk+J1q1AQfQKLfj4H6BXJGDiA0wR8rmeBPMiYYm6RPFEzwcuMm2MW9nMQEjw3M4EcKTX0H4yb48qSOmelIUow+BRYjYK6lo3ET7HT9qQJvDiJpApcr8SYufgeT4AfktxwExK8zybr1GZB/QM5IZxL+jTFqgruS4Fds1AQfRqLfz4H6BXJGDiM0wZ8rmeAVGROMTdIKBRP8hXET7OL+gsQETwjM4GcKTf3hxk3wxKSOmelBUoy+BBYjYK6lh3ET7HT9pQJvepE0gV8o8SYufkeS4Afkt/QC4ncUybr1FZB/QM7IUST8u9aoCT6WBL/rjJrg40j0+zVQv0DOyHGEJvhrJRP8TcYEY5P0jYIJXmncBLu4V5KY4JsCM/iVQlN/vHETPCmpY2ZOIClG3wKLETDXcoJxE+x0/a0Cb/qTNIErlXgTF78BJPgB+S39gfgNJFm3vgPyD8gZGUjCv8lGTfBgEvymGDXBJ5Ho93ugfoGckZMITfD3SiZ4VcYEY5O0SsEE/2DcBLu4fyAxwXcHZvA7haZ+qHETPDWpY2aGkRSj1cBiBMy1DDNugp2uVyvwZjhJE/iDEm/i4ncaCX5AfstwIH6nk6xba4D8A3JGTifh32yjJngUCX6PGzXBZ5Lo90egfoGckTMJTfCPSib4p4wJxibpJwUTvNa4CXZxryUxwdMDM7hGoakfbdwEz0rqmJlzSIrROmAxAuZazjFugp2u1ynw5nySJnCtEm/i4ncBCX5Afsv5QPzGkKxbPwP5B+SMjCHh3wKjJngsCX4LjZrgcST6/QWoXyBnZByhCf5FyQSvz5hgbJLWK5jgDcZNsIt7A4kJnh2YwZ8VmvpLjZvguUkdM3MZSTH6FViMgLmWy4ybYKfrXxV4cyVJE7hBiTdx8RtPgh+Q33IlEL8JJOvWb0D+ATkjE4zXu3lBvftNYd261njc85M66/V1JHr5HagXYK7lOuO8+SAY43cF3nyAm+Mm41re48yHwb8/g38fhT8/Dn+6Y2MQyx/Bv9zg8f7Zm01tdD4aKzr/afi77vlojD+Dx3+FY7T2xojO/5v5JBoHr2/891htvLGi8+nm456PxsgOHpcLx2jrjRGdTx3jk3CM7HAMZ/Bz3O+HYxzgjRGdTx1jeThGTjiGi7V88LhCOEY7b4zofGldFPkIN1a+f9GjYuO/f1ZqvPncUeHPSoktL5Bsitt73B40H4ULLvkuXxW8OKIj2zsXvWfEaXcRpkoJr/V53x4zP0nlTHvvcfRe/lyy/sdz8fFKeOfKpWDlcyZ6zuWiu/d8Tgm/E702p4TX+bHnKsTuv0977//Re1X25pBjYC7ZJcylPHYum+pupJ9EYsuLo9E8ojlV8J6rCMbEjVGphHlU9OaRqvPy4XngPJq4MaqUMI/K3s/o/at486iKnUdBpZR5uOOf9FvVm0s17Fw2caS6917RvKp5/4+ez/XmUR07j026qZYSf/R/f37/17lWIJprpf/xXBV4VeTGrIEds0mlxJaYuuOfdFPDi68mdi4FTpMVEpvzGo2fiq3ff2is77W9eP18usOtZ7XCx/7rosc53vN+vY+eb+fF5Masg53/pnz683LHP+Uzen9XN6I1cXDhyF6FA0cUjuxaODrLG6N2Slx+D5zrPfbXCY38JL33qu29lztcfvLCx0nvOY36u00J8/Drb/T+0esqeY/zvHN1U+br94r+70a1NXp9hTC2HGxsBf57Rcc/cSjHi93jUI9RA4YNGZjCoWjcciWM6/e9uSmv8zHx+6us1Am2T0BAEORFC435/Vn174sQ6Is1Nxi/SFWu2t8XGdBx30hycbNyYxyWwFwLEr/Ui2qVwwtPFcOflbwLYlWCx1XDC1HtvQtR0fl/c4GuWvD66uFYHbyxovPpLtBV8+ZTI3hcMxyjozdGdL5cYuvF1R1onXRJ6PAZPc8qje2vszUaQ8ctatqkab5bx1Bx+0W0lnfBMirG/6+LS1neOb+pcwfThc2KXhyJlHirh89HDe+pw0cOKRrdfdSwYUOKhhQO6j58ZKEPY2r/4Q+Vet6/Nlc+5fd9SKPnynTf4ubncxQ513SYxq25tRv/57HyU8aS0vpgpHZjnfWljpe7zN2iMcd0SarTGD9uXmMc+bXizlNaBDQWLI25llYjWDNGo1G05ZFfwnT/69iSekITA2RR9Be7ZMiLbTx+RM1HdmLryu9fAXGLZ8cSYs7yHmeHryn3D6/JSjNOSZ8OVU/wNHRbLOaWCZEVJirZeHNi3P8dKToktjzQH1ED45BtgEWjbmPYolMU4VnXwzNmh7dVV/aBl78Y426Fwy3Gb+3+IOQpetxbjd6anFrQkPo5/VAcfreR3NoN5LcAOSNa+GWDdZIErrn1gFeG3RgaNbdeY501DJlrdNxvB2Os2Q8f953GP6m5Pbj8+KNC3HeRfFKzLVCPwFzLXcZ54/SyVoE3kwn0sk4h7ikketkOqBdgrmUKgV5+UeDNVAK9rFeIexqJXuoD9QLMtUwj0MuvCryZTqCX3xTinkGil+2BegHmWmYQ6GWjAm8eJtDLHwpxzyTRyw5AvQBzLTMJ9PKXAm8eJdBLQuGO1MdI9LIjUC/AXMtjBHrJVuDNHAK9lFOI+wkSvewE1Asw1/IEgV5yFXgzl0Av5RXifppELzsD9QLMtTxNoJeKCryZR6CXSgpxP0eil12AegHmWp4j0EsVBd68SKCXqgpxv0Sil12BegHmWl4i0Et1Bd4sINBLDYW4F5LoZTegXoC5loUEeqmlwJtFBHqprRD3YhK97A7UCzDXsphAL3kKvFlCoJekQtxvkOilAVAvwFzLGwR6qavAm7cJ9FJPIe53SPSyB1AvwFzLOwR62U6BN+8R6KW+Qtzvk+hlT6BegLmW9wn0soMCbz4k0MuOCnF/RKKXvYB6AeZakPi5P1vSKXvzn15032Fw92W7e03d/XPuniB3n4P77NZ9HuWusbvrhu5aiPN3rmd1dditLQ6vnHC81AMVezQenOvV8Jy0/peTVBbKnRUWjOUEC+UuCnF/SrJQNgQulMBcy6cEjcVuCrxZQaCX3RXi/oJEL3sD9QLMtXxBoJc9FHjzNYFe9lSI+xsSvewD1Asw1/INgV4aKvDmOwK97K0Q9/cketkXqBdgruV7Ar3sq8Cb1QR62U8h7jUketkPqBdgrmUNgV4aK/BmLYFe8hXiXkeil0ZAvQBzLesI9NJEgTfrCfRSoBD3BhK9NAbqBZhr2UCgl2YKvPmdQC/NFeLeSKKXfKBegLmWjQR6aanAm78I9NJKIe5EMYdeBKgXYK4FjZ+GXlor8Kac8bidXtooxJ1TzKGXJkC9AHMtaPw09HKAAm8qGI/b6aWdQtwVizn0UgDUCzDXgsZPQy8dFHhTxXjcTi8dFeKuWsyhl6ZAvQBzLWj8NPRyoAJvahiP2+nlIIW4axZz6KUZUC/AXAsaPw29dFbgTR3jcTu9HKIQd14xh16aA/UCzLWg8dPQSxcF3tQ1HrfTS1eFuOsVc+ilBVAvwFwLGj8NvXRT4E1943E7vXRXiHv7Yg69tATqBZhrQeLnvvh0YPbmLz657zC4+7Ldvabu/jl3T5C7z8F9dus+j3LX2N11Q3ctxPk717O6OuzWlpbhbpBoHqbbijz2H+IsLh0e5v/3Y6st0+PG3ArIaSR+OSEPUw/UXKPxyuIX5oA533InXLQg92+MJZTiNzDVkrV/Y/tzbK1FKHQFb1NGtiJLl+i4+LUF4scqyLYEgjyARZDtysheZ+kSHRe/9jj8mrAKsj2BIDuwCLJjGdlMLV2i4+LXCYdfAasgOxEI8kAWQR5URnZrS5fouPgdjMOvKasgDyYQZGcWQR5SRraDS5fouPgdisOvGasgDyUQZBcWQXYtI/vNpUt0XPwOw+HXnFWQhxEIshuLILuXkQ3t0iU6Ln6H4/BrwSrIwwkE2YNFkD3LyI556RIdF78jcPi1ZBXkEQSC7MUiyCPLyJZ86RIdF7+jcPi1YhXkUQSCPJpFkL3LyJ5/6RIdF79jcPj1ZxXkMQSCPJZFkMeVkU0F0yU6Ln59cPgNYBVkHwJB9mUR5PFlZNfCdImOi98JOPwGsgryBAJBnsgiyH5lZFvEdImOi19/HH6DWAXZn0CQA1gEObCM7LuYLtFx8RuEw6+QVZCDCARZyCLIojKysWO6RMfFbzAOvyJWQQ4mEORJLIIcUgZ2jvTxQwvyZPD3IQ8kFOTJBIIcyiLIYWVkh8J0iY6L3yng70MyCvIUAkGeyiLI4WVkC8R0iY6L32ng70MyCvI0AkGeziLIEWVkj8V0iY6L3xng70MyCvIMAkGOZBHkqDKyiWO6RMfF70zw9yEZBXkmgSDPYhHk2WVkl8h0iY6L32jw9yEZBTmaQJDnsAjy3DKyDWW6RMfF7zzw9yEZBXkegSDPZxHkBWVkn8t0iY6L3xjw9yEZBTmGQJDFLIK8sIxspJku0XHxuwj8fUhGQV5EIMixLIIcBxSk5Z060yU6Ln4Xg78PySjIiwkEeQmLIC8FCtLyVqDpEh0Xv8vA34dkFORlBIK8nEWQVwAFaXmv0XSJjovfleDvQzIK8koCQY5nEeQEoCCrFOPG0toMFi3Iq8Dfh2QU5FUEgryaRZDXAAVpebfUdImOi9+14O9DMgryWgJBXsciyIlAQVrejjVdouPidz34+5CMgryeQJA3sAjyRqAgLe/3mi7RcfG7Cfx9SEZB3kQgyJtZBHkLUJBWN5TVSLDbgPlwhY2IdzEet9uAuYdC3LsW6wgGuPGtO+RD4Fh+ruPit1sp4Rd3nrcC1xsgZ4QFv9sa6/AvP94haP2i1xc33mcK4+5ZbHu9djGvUIh7r2IdvWSD4wfmR5Axu3yUT2xeHz4P/v0Z5sr9/CL86Y7bA81PCv7lBo8Pyt6MUXQ+Gis6/3X4u+75aIw7gsd3hmMc7I0Rnf8387kreP3d4VidvbGi8+nmc5c3n3uCx5PDMQ7xxojOp47xZTjGPeEYzrxMCR7fG45xqDdGdD51jK/CMaaEY7hY7wseTw3H6OKNEZ13B1o7d1T7G3f0uPsU216DJ1f7G1f0uPsW66xF6N5xcg/cWH6u4+K3Hwl+9wHx2xeIX6NSwi/uPKcBe0cgZwSJn8MsK7H1ge6rgFjm+/O9v/Hmxznhz+wSOFFeIaZEyvuk4li9hHPQN9dI0v2N8eM+0BgnSq24H2gMz5Hq4v6w0eJYUMyB30yjxbFpMUdxnA4sjkDOCBK/0iqO05WK44xMccQmaYZCcXzQeHF0cT+oVBzht6Lm/V3I0Y75ocZlM+4WxbavkDhePqQQd8tijibmQWAR9nMdF79WxRxNzMNA/ICckdLCLz/eIc8YNSFtSfB71qgJOaCYQ78zgfoFckaQ+JWWCZmpZEJmZUwINkmzFEzII8ZNiIv7ERITMjFoxh9WaEo7FNuO+5Y8nWa8YzFHMXoUWIyAuRY0fuj8Ol0/qsCbg4o5msBHlHgTF7+DSfAD8lsOAuLXuZhj3XoMyD8gZ6S08MuPd8gSoya4Kwl+bxg1wYcVc+h3NlC/QM4IEr/SMsGzlUzw4xkTjE3S4womeI5xE+zinkNigicFZvAxhab+8GLbcU/O0zEzPYo5itETwGIEzLWg8UPn1+n6CQXe9CrmaALnKPEmLn5HkuAH5Lf0AuJ3VDHHuvUkkH9Azkhp4Zcf75DPjJrgY0nw+9yoCT6umEO/TwH1C+SMIPErLRP8lJIJnpsxwdgkzVUwwU8bN8Eu7qdJTPDUwAw+qdDUH19sO+4H83TMzAnFHMXoGWAxAuZa0Pih8+t0/YwCb/oXczSBTyvxJi5+A0jwA/Jb+gPxG1jMsW49C+QfkDNSWvjlxztkrVETPJgEv3VGTfBJxRz6nQfUL5AzgsSvtEzwPCUT/FzGBGOT9JyCCX7euAl2cT9PYoJnBWbwWYWmfmix7bjn5OmYmWHFHMXoBWAxAuZa0Pih8+t0/YICb4YXczSBzyvxJi5+p5HgB+S3DAfid3oxx7r1IpB/QM5IaeGXH++Q3J42TfAoEvzKA/FDmuAzizn0+xJQv0DOCBK/0jLBLymZ4PkZE4xN0nwFE/yycRPs4n6ZxATPDczgiwpN/ehi23E/n6djZs4p5ihGC4DFCJhrQeOHzq/T9QIF3pxfzNEEvqzEm7j4XUCCH5Dfcj4QvzHFHOvWQiD/gJyR0sIvP94hdY2a4LEk+NUzaoLHFXPo9xWgfoGcESR+pWWCX1Eywa9mTDA2Sa8qmOBFxk2wi3sRiQmeH5jBhQpN/aXFtuNelKdjZi4r5ihGi4HFCJhrQeOHzq/T9WIF3lxZzNEELlLiTVz8xpPgB+S3XAnEb0Ixx7r1GpB/QM5IaeGXH++QhkZN8LUk+O1t1ARfV8yh39eB+gVyRpD4lZYJfl3JBC/JmGBskpYomOA3jJtgF/cbJCZ4SWAGX1No6m8oth330jwdM3NjMUcxehNYjIC5FjR+6Pw6Xb+pwJtbijmawDeUeBMXv1tJ8APyW24B4ndbMce69RaQf0DOSGnhlx/vkNZGTfCdJPi1MWqC7yrm0O/bQP0COSNI/ErLBL+tZILfyZhgbJLeUTDBS42bYBf3UhITvCwwg28pNPWTi23HvTxPx8xMKeYoRu8CixEw14LGD51fp+t3FXgztZijCVyqxJu4+E0jwQ/Ib5kKxO/+Yo516z0g/4CckdLCLz/eId2MmuAHSfDrbtQEP1TMod/3gfoFckaQ+JWWCX5fyQQvy5hgbJKWKZjgD4ybYBf3ByQmeEVgBt9TaOpnFduOe2Wejpl5pJijGH0ILEbAXAsaP3R+na4/VODN7GKOJvADJd7Exe9xEvyA/JbZQPzmFHOsWx8B+QfkjJQWfvnxDjnRqAmeS4JfP6Mm+OliDv1+DNQvkDOCxK+0TPDHSib4k4wJxibpEwUTvNy4CXZxLycxwasCM/iRQlM/r9h23GvzdMzMc8UcxehTYDEC5lrQ+KHz63T9qQJvXizmaAKXK/Em9l8dJcEPyG95EYjf/GKOdeszIP+AnJHSwi8/3iGnGzXBr5DgN8KoCX61mEO/nwP1C+SMIPErLRP8uZIJXpExwdgkrVAwwV8YN8Eu7i9ITPD6wAx+ptDUv1ZsO+4/8nTMzOvFHMXoS2AxAuZa0Pih8+t0/aUCb94s5mgCv1DiTezvipLgB+S3vAnE7+1ijnXrKyD/gJyR0sIvP94hY42a4PdI8Btn1AS/X8yh36+B+gVyRpD4lZYJ/lrJBH+TMcHYJH2jYIJXGjfBLu6VJCY4K5lIfKXQ1H9YbDvuCkkdM/NRMUcx+hZYjIC5FjR+6Pw6XX+rwJvlxRxN4Eol3sS+s4EEPyC/ZTkQv8+KOdat74D8A3JGSgu//HiH3GDUBH9Jgt+NRk3wV8Uc+v0eqF8gZwSJX2mZ4O+VTPCqjAnGJmmVggn+wbgJdnH/QGKCqwRm8DuFpn5lse24ayV1zMy3xRzFaDWwGAFzLWj80Pl1ul6twJtVxRxN4A9KvImdFxL8gPyWVUD8VhdzrFtrgPwDckZKC7/8eIdMNWqC15LgN82oCV5XzKHfH4H6BXJGkPiVlgn+UckE/5Qxwdgk/aRggtcaN8Eu7rUkJjgZmME1Ck39+mLbcddP6piZDcUcxWgdsBgBcy1o/ND5dbpep8Cb34s5msC1SryJi99GEvyA/Jbfgfj9Ucyxbv0M5B+QM1Ja+OXHO+RJoyY460IO/J4yaoKzL+TQ7y9A/QI5I0j8SssE/6JkgtdnTDA2SesVTPAG4ybYxb2BxATvFJjBnxWa+twLbcfdIKljZsqTFKNfgcUImGspr8yb2Bc5Atx+VeBNJZImcIMSb+LiV5kEPyC/pRIQvyok69ZvQP4BOSNVSPi3yKgJrkGC32KjJrgmiX5/B+oXyBmpSWiCf1cywRszJhibpI0KJvgP4ybYxf0HiQluGJjB3xSa+jrGTXDjpI6ZySMpRn8CixEw15Jn3AQ7Xf+pwJu6JE3gH0q8iYtfPRL8gPyWukD8tiVZt/4C8g/IGdmWhH8fGzXBO5Dg94lRE7wjiX4T+Tj8gJyRHQlNMBDLLUxwlseAjAmOO2b+34Cix83Ot22CXdzZ+fAcqcy1IDCDfyk09bsYN8GtkjpmZleSYlQOWIyAuZZdjZtgp+ty+fhxG5A0gdlKvImL3x4k+AH5LQ2A+O1Jsm7lAPkH5IzsScK/1UZN8D4k+K0xaoL3JdFvLlC/QM7IvoQmOFfJBJfPmGBsksormOAKxk2wi7sCiQluG5jBHIWmvrFxE9wpqWNm8kmKUUVgMQLmWvKNm2Cn64oKvCkgaQIrKPEmLn5NSfAD8lsKgPg1I1m3KgH5B+SMNCPhX9YRNk1wK5aLgED8kCZ4fxL9VgbqF8gZ2Z/QBFdWMsFVMiYYm6QqCia4qnET7OKuSmKCOwdmsJJCU9/WuAnultQxMweQFKNqwGIEzLUcYNwEO11XU+BNB5ImsKoSb+Li15EEPyC/pQMQv04k61Z1IP+AnJFOJPyrY9QEd2b5OoNRE3wIiX5rAPUL5IwcQmiCayiZ4JoZE4xNUk0FE1zLuAl2cdciMcE9AzNYXaGp72rcBPdO6piZw0iKUW1gMQLmWg4zboKdrmsr8OZwkiawlhJv4uLXgwQ/IL/lcCB+PUnWrTpA/gE5Iz1J+NfAqAk+igS/PYya4KNJ9JsH1C+QM3I0oQnOUzLByYwJxiYpqWCCtzFugl3c25CY4D6BGayj0NQfa9wE90/qmJnjSIpRXWAxAuZajjNugp2u6yrw5niSJnAbJd7Exe8EEvyA/JbjgfidSLJu1QPyD8gZOZGEfy2MmuCBJPi1NGqCB5Hod1ugfoGckUGEJnhbJRO8XcYEY5O0nYIJrm/cBLu465OY4MLADNZTaOoHGzfBQ5M6ZuYkkmK0PbAYAXMtJxk3wU7X2yvwZihJE1hfiTdx8RtGgh+Q3zIUiN8pJOvWDkD+ATkjp5Dw71CjJvh0Evy6GDXBI0j0uyNQv0DOyAhCE7yjkgneKWOCsUnaScEE72zcBLu4dyYxwcMDM7iDQlM/yrgJHpXUMTNnkhSjXYDFCJhrOdO4CXa63kWBN6NJmsCdlXgTF79zSPAD8ltGA/E7l2Td2hXIPyBn5FwS/vUxaoLHkODX16gJLibR725A/QI5I8WEJng3JRO8e8YEY5O0u4IJbmDcBLu4G5CY4NGBGdxVoakfa9wEj0nqmJlxJMVoD2AxAuZaxhk3wU7Xeyjw5lKW7xQq8SYufpeR4Afkt1wKxO9yknVrTyD/gJyRy0n4d4pREzyBBL9TjZrgq0j0uxdQv0DOyFWEJngvJRPcMGOCsUlqqGCC9zZugl3ce5OY4LGBGdxToam/1rgJvjypY2auIylG+wCLETDXcp1xE+x0vY8Cb24gaQL3VuJNXPxuJMEPyG+5AYjfTSTr1r5A/gE5IzeR8G+MURN8Gwl+xUZN8O0k+t0PqF8gZ+R2QhO8n5IJbpQxwdgkNVIwwY2Nm2AXd2MSEzwhMIP7KjT1dxo3wROTOmbmLpJilA8sRsBcy13GTbDTdb4CbyaTNIGNlXgTF78pJPgB+S2TgfjdS7JuCZB/QM7IvST8u9aoCb6f5SKWURP8AIl+mwD1C+SMPEBogpsomeCCjAnGJqlAwQQ3NW6CXdxNSUzwTYEZFIWm/kHjJnhSUsfMPERSjJoBixEw1/KQcRPsdN1MgTezSJrApkq8iYvfIyT4Afkts4D4PUqybjUH8g/IGXmUhH+TjZrgOST4TTFqgp8g0W8LoH6BnJEnCE1wCyUT3DJjgrFJaqlgglsZN8Eu7lYkJvjuwAw2V2jq5xo3wVOTOmbmaZJitD+wGAFzLU8bN8FO1/sr8GYeSRPYSok3cfF7jgQ/IL9lHhC/50nWrdZA/gE5I8+T8G+2URM8nwS/x42a4JdJ9NsGqF8gZ+RlQhPcRskEt82YYGyS2iqY4AOMm2AX9wEkJnh6YAZbKzT1rxg3wbOSOmbmVZJi1A5YjIC5lleNm2Cn63YKvHmNpAk8QIk3cfF7nQQ/IL/lNSB+S0jWrfZA/gE5I0tI+LfAqAl+mwS/hUZN8Dsk+u0A1C+QM/IOoQnuoGSCO2ZMMDZJHRVMcCfjJtjF3YnEBM8OzGB7hab+PeMmeG5Sx8y8T1KMDgQWI2Cu5X3jJtjp+kAF3nxI0gR2UuJNXPw+IsEPyG/5EIjfxyTr1kFA/gE5Ix8br3fzgnp3kMK69ZnxuOcnddbrz0n0cjBQL8Bcy+fGefNZMMbBGnrBzXGTcS3vcebz4N+fwb8V4c8vwp/u6BzEckjwLzd43DV7s6mNzkdjRee/Dn/XPR+NcWjwuEs4xmHeGNH5fzOfrsHrDwvH6uaNFZ1PN5+u3ny6BY+7h2N098aIzqeO8WU4RrdwDGfwDw8e9wjHONwbIzqfOsZX4RiHh2O4WHsGj48Ix+jhjRGdL62LIitwY+Vne/PsFa5QR3or1VHhz0qJLS+QJEK8EtjY8hUuuOS7fFXw4oiObO9c9J4Rp91FmColvNbnfXvM/CSVM+29x9F7+XPJ+h/Pxccr4Z0rl4KVz5nouU0a9p7PKeF3otfmlPA6P/Zchdj992nv/T96r8reHHIMzCW7hLmUx85l02oQ6SeR2PLiaDSPaE4VvOcqgjFxY1QqYR4VvXmk6rx8eB44jyZujColzKOy9zN6/yrePKpi51FQKWUe7vgn/Vb15lINO5dNHKnuvVc0r2re/6Pnc715VMfOY5NuqqXEH/3fn9//da4ViOZa6X88VwVeFbkxa2DHbFIpsSWm7vgn3dTw4quJnUuB02SFxOa8RuOnYuv3Hxrre20vXj+f7nDrWa3wsf+66HGO97xf76Pn23kxuTHrYOe/KZ/+vNzxT/mM3t/VjWhNHFw4slfhwBGFI7sWjs7yxqidEpffA+d6j/11QiM/Se+9anvv5Q6Xn7zwcdJ7TqP+blPCPPz6G71/9LpK3uM871zdlPn6vaL/u1FtjV5fIYwtBxtbgf9e0fFPHMrxYvc41GPUgGFDBqZwKBq3XAnj+n1vbsrrfEz8/iordYLtExAQBHnRQmN+d1T7+yIE+mLNl8YvUk2u9vdFBnTcX5Fc3DwKeHETmGtB4pd6Ue2o8MJTr/Dnkd4FsaODx73DC1E9vQtR0fl/c4HumOD1x4ZjHeGNFZ1Pd4HuGG8+xwWP+4Rj9PLGiM6XS2y9uLoDrZMuCR0+o+d5dL79dfY47A09RU2bNM136xgqbr+I9vWyFRXj/9fFpSzvnN/UuYPpwmZFL45ESrzVw+ejhvfU4SOHFI3uPmrYsCFFQwoHdR8+stCHMbX/8IdKPe9fmyuf8vs+pNFzZbpvcfPrq3SjWDpM49bc4//7zXf5KWNJaX0wcrzS3aInZO4WxSbphHz8uCcav1vUxX0iyd2ibsHSmGtpNYIzYzQaRVse+SVM97+OLaknNDFAFkV/sesXzrq/N/uo+chObF35/SsgbvHsWELMWd7j7PA15f7hNVlpxinp06HqCZ6GbovF3DIhssJE9cvfnBj3f0eKDoktD/RH1MA4pD+waAzIhy06RRGeAzw8Y3Z4W3Vln3n5izHuVjisvFC3uCFuzeqvEPe3pXQ1Lf9fHqkFDamfKl1w+H1nFL+UQ4D8FiBnRAu/bLBO+gHX3IHAK8NuDI2aO9D47aUacX8QjNG6MT7u1cY/qWkTGI82CnGvIfmkZhBQj8BcyxrjvHF6OUCBN2sJ9NJOIe51JHopBOoFmGtZR6CXDgq8WU+gl44KcW8g0UsRUC/AXMsGAr0cqMCb3wn0cpBC3BtJ9DIYqBdgrmUjgV46K/DmLwK9HKIQd+IiDr2cBNQLMNeCxk9DL10UeFPOeNxOL10V4s4h0csQoF6AuZYcAr10U+BNBQK9dFeIuyKJXk4G6gWYa6lIoJceCrypQqCXngpxVyXRy1CgXoC5lqoEeumlwJsaBHo5UiHumiR6GQbUCzDXUpNAL0cr8KYOgV56K8SdR6KXU4B6AeZa8gj0cqwCb+oS6OU4hbjrkejlVKBegLmWegR66avAm/oEejleIe7tSfQyHKgXYK5lewK9nKjAm50I9NJPIe6dSfRyGlAvwFzLzgR6GaDAm90I9DJQIe7dSfRyOlAvwFzL7gR6KVTgzZ4EeilSiHsvEr2MAOoFmGvZi0AvJynwZh8CvQxRiHtfEr2cAdQLMNeCxM/92ZIjszf/6UX3HQZ3X7a719TdP+fuCXL3ObjPbt3nUe4au7tu6K6FOH/nelZXh93a4vDKCcdLPVCxR+PBuV4dz0n0HNF/OUlloRyqsGA0JlgohynEnU+yUI4ELpTAXEu+cd44vZyqwJsCAr0MV4i7KYleRgH1Asy1NCXQy+kKvGlBoJcRCnG3JNHLmUC9AHMtLQn0MlKBN60J9DJKIe42JHo5C6gXYK6lDYFezlLgTTsCvZytEHd7Er2cDdQLMNfSnkAv5yjwphOBXs5ViPtAEr2MBuoFmGs5kEAv5yvwpjOBXi5QiPsQEr2cA9QLMNdyCIFeihV405VALxcqxH0YiV7OBeoFmGs5jEAvYxV4cziBXsYpxN2DRC/nAfUCzLX0INDLJQq86UWgl0sV4j6SRC/nA/UCzLUcSaCXyxV405tAL1coxH0MiV4uAOoFmGs5hkAv4xV404dALxMU4u5LopcxQL0Acy19CfRytQJvTiTQyzUKcfcj0UsxUC/AXEs/Ar1cp8CbgQR6magQ9yASvVwI1Asw1zKIQC83KPBmMIFeblSI+yQSvVwE1Asw13ISgV5uVuDNUAK93KIQ9zASvYwF6gWYa0Hi5774dFT25i8+ue8wuPuy3b2m7v45d0+Qu8/BfXbrPo9y19jddUN3LcT5O9ezujrs1paxYTbQPEy3FXnsP8xRSjzM/+/HVlumx415HJDTSPxyQh6mHqi5RuOVxS/MAXO+Bc/hgrw4H0soxW9gqiXr4nz7c7xEi1DoCn4pcLWzvBVZukTHxe8yIH6sgryMQJCXswjyCiChLO91li7RcfG7EodfE1ZBXkkgyPEsgpwAFKTlzdTSJTouflfh8CtgFeRVBIK8mkWQ1wAFaXm3tnSJjovftTj8mrIK8loCQV7HIsiJQEFa3g4uXaLj4nc9Dr9mrIK8nkCQN7AI8kagIC3vN5cu0XHxuwmHX3NWQd5EIMibWQR5C1CQlje0S5fouPjdisOvBasgbyUQ5G0sgrwdKEjLO+alS3Rc/Cbh8GvJKshJBIK8g0WQdwIFaXlLvnSJjovfXTj8WrEK8i4CQd7NIsh7gIK0vOdfukTHxW8yDr/+rIKcTCDIKSyCvBcoSMubCqZLdFz87sPhN4BVkPcRCHIqiyCnAQVpedfCdImOi9/9OPwGsgryfgJBPsAiyOlAQVreFjFdouPiNwOH3yBWQc4gEOSDLIJ8CChIy/supkt0XPwexuFXyCrIhwkEOZNFkLOAgrS8sWO6RMfF7xEcfkWsgnyEQJCPsgjyMaAgre4c6eOHFuRsYKKVv2CrRvbZBIJ8nEWQc4CCtLxDYbpEx8XvCSB+rIJ8gkCQT7II8ikgoSxvgZgu0XHxm4vDrwmrIOcSCPJpFkE+AxSk5T0W0yU6Ln7P4vArYBXkswSCnMciyOeAgrS8iWO6RMfF73kcfk1ZBfk8gSBfYBHki0BBWt4lMl2i4+L3Eg6/ZqyCfIlAkPNZBPkyUJCWt6FMl+i4+C3A4decVZALCAS5kEWQrwAFaXmfy3SJjovfqzj8WrAK8lUCQS5iEeRioCAtb6SZLtFx8XsNh19LVkG+RiDI11kEuQQoSMs7daZLdFz83sDh14pVkG8QCPJNFkG+BRSk5a1A0yU6Ln5v4/DrzyrItwkE+Q6LIJcCBWl5r9F0iY6L37s4/AawCvJdAkG+xyLI94GCtLyZabpEx8VvGQ6/gayCXEYgyA9YBPkhUJCWd0tNl+i4+H2Ew28QqyA/IhDkxyyC/AQoSMvbsaZLdFz8luPwK2QV5HICQX7KIsjPgIK0vN9rukTHxe9zHH5FrIL8nECQK1gE+QVQkFY3lNVIsNuA+VaFjYhPNx6324D5NoW4RygtwMCNb90hnwPH8nMdF78zSgm/uPP8ErjeADkjLPh9la/Dv/x4h4xQXrfi4ubG+0Zh3LOMr9cu5m8V4j5bSS/Z4PiB+RFkzC4f5ROb14eVwb8/w1y5n9+FP93xdYDQN8G/3ODx0dmbMYrOR2NF538If9c9H42xMnj8bThGb2+M6Py/mc93weu/D8c6xhsrOp9uPt9581kVPP4hHONYb4zofOoY34djrArHcOZldfB4TTjGcd4Y0fnUMVaFY6wOx3Cx/hg8/ikco483RnTeHWjtHFD9b9zR455rfA3uVP1vXNHjnkfSO07ugRvrXGDveD4JfvcB8TsPiN8FJL3jWmDvCOSMIPFzmGUltj7QfRUQy3x/vus8BuSEP7NL4ER5hZgSKe+TimP1Es5B31wjSevy8eP+nI8TpVbcP+fDc6S6uD9stDiOJSmOM40Wx3EkxfEXYHEEckbGERbHX5SK4/pMccQmab1CcdxgvDi6uDcoFUf0XMfn/V3I0Y751/yyGfelxq+QOF7+qhD3ZSRNzAZgEb4U2MRcTtLE/AbED8gZuZyEf88YNSETSPB71qgJuYpEv78D9QvkjCDxKy0T8ruSCdmYMSHYJG1UMCF/GDchLu4/SEzIxKAZ/02hKb32Ittx35Kn04xfR1KM/gQWI2Cu5Tpl3sTFzen6TwXe3EDSBP6hxJu4+N1Igh+Q33IDEL+bSNatv4D8A3JGbiLh3xKjJvg2EvzeMGqCbyfRb0Jw+AE5I0j8SssEA7HcwgRneVY0Y4Ljjil/A4oeN1tsm2AXd7bAc6Qy10mBGfxLoam/07gJnpynY2buIilG5YDFCJhruUuZN3Fxc7ouJ/hxJ5M0gdlKvImL3xQS/ID8lslA/O4lWbdygPwDckbuJeHfZ0ZN8P0k+H1u1AQ/QKLfXKB+gZwRJH6lZYJzlUxw+YwJxiapvIIJrmDcBLu4K5CY4KmBGcxRaOofNG6CH8zTMTMPkRSjisBiBMy1PKTMm7i4OV1XVODNLJImsIISb+Li9wgJfkB+yywgfo+SrFuVgPwDckYeJeHfWqMmeA4JfuuMmuAnSPRbGahfIGcEiV9pmeDKSia4SsYEY5NURcEEVzVugl3cVUlM8KzADFZSaOrnGjfBc/J0zMzTJMWoGrAYAXMtTyvzJi5uTtfVFHgzj6QJrKrEm7j4PUeCH5DfMg+I3/Mk61Z1IP+AnJHnSfiX29OmCZ5Pgl95IH5IE/wyiX5rAPUL5Iwg8SstE1xDyQTXzJhgbJJqKpjgWsZNsIu7FokJnhuYweoKTf0rxk3w83k6ZuZVkmJUG1iMgLmWV5V5Exc3p+vaCrx5jaQJrKXEm7j4vU6CH5Df8hoQvyUk61YdIP+AnJElJPyra9QEv02CXz2jJvgdEv3mAfUL5Iwg8SstE5ynZIKTGROMTVJSwQRvY9wEu7i3ITHB8wMzWEehqX/PuAlelKdjZt4nKUZ1gcUImGt5X5k3cXFzuq6rwJsPSZrAbZR4Exe/j0jwA/JbPgTi9zHJulUPyD8gZ+RjEv41NGqCPyPBb2+jJvhzEv1uC9QvkDOCxK+0TPC2SiZ4u4wJxiZpOwUTXN+4CXZx1ycxwUsCM1hPoan/0rgJXpqnY2a+IilG2wOLETDX8pUyb+Li5nS9vQJvVpI0gfWVeBMXv29J8APyW1YC8fuOZN3aAcg/IGfkOxL+tTZqgleT4NfGqAleQ6LfHYH6BXJGkPiVlgneUckE75Qxwdgk7aRggnc2boJd3DuTmOBlgRncQaGpX2vcBC/P0zEz60iK0S7AYgTMtaxT5k1c3Jyud1HgzXqSJnBnJd7E3n+YBD8gv2U9EL9fSdatXYH8A3JGfiXhXzejJvgPEvy6GzXBf5LodzegfoGcESR+pWWCd1MywbtnTDA2SbsrmOAGxk2wi7sBiQleEZjBXRWa+qyxtuNemadjZrLHchSjPYDFCJhryVbmTVzcnK73UOBNbinxJj/escXamx/v2II3cfErT4IfkN+SC8SvAsm6tSeQf0DOSAUS/p1o1ARXIcGvn1ETXJVEv3sB9QvkjCDxKy0TvJeSCW6YMcHYJDVUMMF7GzfBLu69SUzwqsAM7qnQ1NcwboLX5umYmZokxWgfYDEC5lpqGjfBTtf7KPCmDkkTuLcSb2L/wRUS/ID8ljpA/JIk69a+QP4BOSNJEv6dbtQEb0uC3wijJng7Ev3uB9QvkDOyHaEJ3k/JBDfKmGBskhopmODGxk2wi7sxiQleH5jBfRWa+h2Mm+A/8nTMzI4kxSgfWIyAuZYdjZtgp+t8Bd7sQtIENlbiTezbZEnwA/JbdgHitxvJuiVA/gE5I7uR8G+sURO8Jwl+44ya4L1I9NsEqF8gZ2QvQhPcRMkEF2RMMDZJBQomuKlxE+zibkpigrOSiYQoNPX7GDfBFZI6ZmZfkmLUDFiMgLmWfY2bYKfrZgq8aUzSBDZV4k3sizok+AH5LY2B+AnJutUcyD8gZ0RI+HeDURPcjAS/G42a4OYk+m0B1C+QM9Kc0AS3UDLBLTMmGJuklgomuJVxE+zibkVigqsEZrC5QlPfyrgJrpXUMTP7kxSj/YHFCJhr2d+4CXa63l+BN21JmsBWSryJi98BJPgB+S1tgfi1I1m3WgP5B+SMtCPh31SjJrgTCX7TjJrgA0n02waoXyBn5EBCE9xGyQS3zZhgbJLaKpjgA4ybYBf3ASQmOBmYwdYKTX1n4ya4flLHzBxCUozaAYsRMNdyiHET7HTdToE3XUmawAOUeBMXv8NI8APyW7oC8etGsm61B/IPyBnpRsK/J42a4J4k+D1l1AQfQaLfDkD9AjkjRxCa4A5KJrhjxgRjk9RRwQR3Mm6CXdydSEzwToEZbK/Q1B9l3AQ3SOqYmaNJitGBwGIEzLUcbdwEO10fqMCbY0mawE5KvImL33Ek+AH5LccC8etDsm4dBOQfkDPSh4R/i4ya4BNJ8Fts1AT3I9HvwUD9Ajkj/QhN8MFKJrhzxgRjk9RZwQQfYtwEu7gPITHBDQMzeJBCUz/QuAlunNQxM4NIitGhwGIEzLUMMm6Cna4PVeDNYJZPMpV4Exe/k0jwA/JbBgPxG0KybnUB8g/IGRlCwr+PjZrgU0jw+8SoCT6VRL9dgfoFckZOJTTBXZVM8GEZE4xN0mEKJribcRPs4u5GYoILAjPYRaGpP924CW6V1DEzI0iKUXdgMQLmWkYYN8FO190VeDOKpAnspsSbuPidSYIfkN8yCojfWSTr1uFA/gE5I2eR8G+1URN8Lgl+a4ya4PNI9NsDqF8gZ+Q8QhPcQ8kE98yYYGySeiqY4COMm2AX9xEkJrhtYAYPV2jqxxg3wZ2SOmammKQY9QIWI2Cupdi4CXa67qXAm7EkTeARSryJi984EvyA/JaxQPwuJlm3jgTyD8gZuZiEf1lH2DTBl5Pglw3ED2mCryDR71FA/QI5I1cQmuCjlEzw0RkTjE3S0QomuLdxE+zi7k1igjsHZvBIhaZ+gnET3C2pY2auIilGxwCLETDXcpVxE+x0fYwCb64laQJ7K/EmLn7XkeAH5LdcC8RvIsm6dSyQf0DOyEQS/tUxaoJvIsEvz6gJvplEv8cB9QvkjNxMaIKPUzLBfTImGJukPgomuK9xE+zi7ktignsGZvBYhab+NuMmuHdSx8zcTlKMjgcWI2Cu5XbjJtjp+ngF3txJ0gT2VeJNXPzuIsEPyG+5E4jf3STr1glA/gE5I3eT8K+BURN8Lwl+exg1wfeR6PdEoH6BnJH7CE3wiUomuF/GBGOT1E/BBPc3boJd3P1JTHCfwAyeoNDU32/cBPdP6piZB0iK0QBgMQLmWh4wboKdrgco8OZBkiawvxJv4uL3EAl+QH7Lg0D8HiZZtwYC+QfkjDxMwr8WRk3woyT4tTRqgh8j0e8goH6BnJHHCE3wICUTXJgxwdgkFSqY4CLjJtjFXURiggsDMzhQoamfY9wED03qmJknSIrRYGAxAuZanjBugp2uByvwZi5JE1ikxJu4+D1Ngh+Q3zIXiN8zJOvWSUD+ATkjz5Dw71CjJvh5Evy6GDXBL5DodwhQv0DOyAuEJniIkgk+OWOCsUk6WcEEDzVugl3cQ0lM8PDADJ6k0NTPN26CRyV1zMzLJMVoGLAYAXMtLxs3wU7XwxR48wpJEzhUiTdx8XuVBD8gv+UVIH6LSNatU4D8A3JGFpHwr49RE7yE5esgRk3wGyT6PRWoXyBn5A1CE3yqkgkenjHB2CQNVzDBpxk3wS7u00hM8OjADJ6i0NS/bdwEj0nqmJl3SIrR6cBiBMy1vGPcBDtdn67Am/dImsDTlHgTF7/3SfAD8lveA+K3jGTdGgHkH5AzsoyEf6cYNcEfk+B3qlET/AmJfs8A6hfIGfmE0ASfoWSCR2ZMMDZJIxVM8CjjJtjFPYrEBI8NzOAIhab+M+Mm+PKkjpn5nKQYnQksRsBcy+fGTbDT9ZkKvPmSpAkcpcSbuPh9RYIfkN/yJRC/r0nWrbOA/ANyRr4m4d8Yoyb4OxL8io2a4O9J9Hs2UL9Azsj3hCb4bCUTPDpjgrFJGq1ggs8xboJd3OeQmOAJgRk8S6GpX23cBE9M6piZNSTF6FxgMQLmWtYYN8FO1+cq8GYtSRN4jhJv4uK3jgQ/IL9lLRC/n0nWrfOA/ANyRn4m4d+1Rk3wryT4XWfUBP9Got/zgfoFckZ+IzTB5yuZ4AsyJhibpAsUTPAY4ybYxT2GxATfFJjB8xSa+j+Mm+BJSR0z8ydJMSoGFiNgruVP4ybY6bpYgTdZ40g+SVLiTVz8sknwA/JbfM7Exa/cOI5160Ig/4CckXIk/Jts1ARXIMFvilETXJFEvxcB9QvkjCDxKy0TfJGSCR6bMcHYJI1VMMHjjJtgF/c4EhN8d2AGL1Ro6quMsx331KSOmalKUowuBhYjYK6lqjJv4uLmdH2xAm9qkDSB45R4Exe/miT4AfktNYD41SJZty4B8g/IGalFwr/ZRk1wkgS/x42a4G1I9HspUL9Azsg2hCb4UiUTfFnGBGOTdJmCCb7cuAl2cV9OYoKnB2bwEoWmflvjJnhWUsfMbEdSjK4AFiNgrmU74ybY6foKBd7sQNIEXq7Em7j47UiCH5DfsgMQv51I1q0rgfwDckZ2IuHfAqMmeDcS/BYaNcG7k+h3PFC/QM7I7oQmeLySCZ6QMcHYJE1QMMFXGTfBLu6rSEzw7MAMXqnQ1O9p3ATPTeqYmb1IitHVwGIEzLXsZdwEO11frcCbfUiawKuUeBMXv31J8APyW/YB4rcfybp1DZB/QM7Ifsbr3byg3l2jsG6J8bjnJ3XW6yYkerkWqBdgrqWJcd58E4xxrQJvvsHNcZNxLe9xZmXw78/g37fhz+/Cn+64LohlYvAvN3jcN3uzqY3OR2NF538If9c9H41xffD4hnCM470xovP/Zj43Bq+/KRzrBG+s6Hy6+dzozefm4PEt4RgnemNE51PH+D4c4+ZwDGfwbw0e3xaO0c8bIzqfOsaqcIxbwzFcrLcHjyeFY/T3xojOl9ZFkW9xY+Vne/O8I/Syd3qe9qjwZ6XElhdIEiFeCWxs+QoXXPJdvip4cURHtncues+I0+4iTJUSXuvzvj1mfpLKmfbe4+i9/Llk/Y/n4uOV8M6VS8HK50z0nMtFd+/5nBJ+J3ptTgmv82PPVYjdf5/23v+j96rszSHHwFyyS5hLeexcNtXdSD+JxJYXR6N5RHOq4D1XEYyJG6NSCfOo6M0jVeflw/PAeTRxY1QpYR6VvZ/R+1fx5lEVO4+CSinzcMc/6beqN5dq2Lls4kh1772ieVXz/h89n+vNozp2Hpt0Uy0l/uj//vz+r3OtQDTXSv/juSrwqsiNWQM7ZpNKiS0xdcc/6aaGF19N7FwKnCYrJDbnNRo/FVu//9BY32t78fr5dIdbz2qFj/3XRY9zvOf9eh89386LyY1ZBzv/Tfn05+WOf8pn9P6ubkRr4uDCkb0KB44oHNm1cHSWN0btlLj8HjjXe+yvExr5SXrvVdt7L3e4/OSFj5Pecxr1d5sS5uHX3+j9o9dV8h7neefqpszX7xX9341qa/T6CmFsOdjYCvz3io5/4lCOF7vHoR6jBgwbMjCFQ9G45UoY1+97c1Ne52Pi91dZqRNsn4CAIMiLFhrzO6D63xch0Bdrmhm/SNWp+t8XGdBxNye5uHkX8OImMNeCxC/1otpd4YWnO8Kfd3oXxO4OHt8TXoga4F2Iis7/mwt0k4PXTwnHGuiNFZ1Pd4Fusjefe4PH94VjDPLGiM6XS2y9uLoDrZMuCR0+w7+WL/bX2XuxN/QUNW3SNN+tY6i4/SI61btgGRXj/9fFpSzvnN/UuYPpwmZFL45ESrzVw+ejhvfU4SOHFI3uPmrYsCFFQwoHdR8+stCHMbX/8IdKPe9fmyuf8vs+pNFzZbpvcfObqnSjWDpM49bcaf/95rv8lLGktD4YmaZ0t+j9mbtFsUm6X+Fu0QeM3y3q4n6A5G5Rt2BpzLW0GsEeMRqNoi2P/BKm+1/HltQTmhggi6K/2E0PeTHD40fUfGQntq78/hUQt3h2LCHmLO9xdviacv/wmqw045T06VD1BE9Dt8VibpkQWWGipsvmxLj/O1J0SGx5oD+iBsYhM4BF40GBLTpFEZ4PenjG7PC26sq+8fIXY9ytcGhl/Nbub0Keosfd3+ityakFDamfe7vg8GtNcms3kN8C5Ixo4ZcN1sl04Jr7EPDKsBtDo+Y+ZPz2Uo24PwvGuCQfH3c745/UfBR8xn2pQtztST6peRioR2Cupb1x3ji9XK7Am04EerlCIe4DSfQyE6gXYK7lQAK9jFfgTWcCvUxQiPsQEr3MAuoFmGs5hEAvVyvwpiuBXq5RiPswEr08AtQLMNdyGIFerlPgzeEEepmoEHcPEr08CtQLMNfSg0AvNyjwpheBXm5UiPtIEr08BtQLMNdyJIFeblbgTW8CvdyiEPcxJHqZDdQLMNdyDIFeblPgTR8CvdyuEHdfEr08DtQLMNfSl0Avdyjw5kQCvdypEHc/Er3MAeoFmGvpR6CXuxV4M5BAL/coxD2IRC9PAPUCzLUMItDLFAXeDCbQy70KcZ9EopcngXoB5lpOItDLVAXeDCXQyzSFuIeR6OUpoF6AuZZhBHp5QIE3wwn0Ml0h7tNI9DIXqBdgruU0Ar08qMCbMwj08pBC3CNJ9PI0UC/AXMtIAr3MVODNWQR6maUQ99kkenkGqBdgruVsAr08qsCbcwn08phC3OeR6OVZoF6AuRYkfu7PlhRmb/7Ti+47DO6+bHevqbt/zt0T5O5zcJ/dus+j3DV2d93QXQtx/s71rK4Ou7XF4ZUTjpd6oGKPxoNzvTqek+g5ov9ykspC+bjCgjGGYKGcoxB3MclCOQ+4UAJzLcUEjcWTCrwZS6CXpxTiHkeil+eAegHmWsYR6OVpBd5cSqCXZxTivoxEL88D9QLMtVxGoJd5Cry5kkAvzynEPZ5ELy8A9QLMtYwn0MsLCry5mkAvLyrEfQ2JXl4E6gWYa7mGQC/zFXgzkUAvLyvEfT2JXl4C6gWYa7meQC8LFXhzE4FeXlGI+2YSvcwH6gWYa7mZQC+LFHhzG4FeFivEfTuJXl4G6gWYa7mdQC+vK/DmTgK9LFGI+y4SvSwA6gWYa7mLQC9vKvBmMoFe3lKIewqJXhYC9QLMtUwh0Ms7CryZSqCXpQpxTyPRyytAvQBzLdMI9PKeAm+mE+jlfYW4Z5Do5VWgXoC5lhkEevlAgTcPE+jlQ4W4Z5LoZRFQL8Bcy0wCvXyswJtHCfTyiULcj5HoZTFQL8Bcy2MEevlUgTdzCPTymULcT5Do5TWgXoC5licI9LJCgTdzCfTyhULcT5Po5XWgXoC5FiR+7otPRdmbv/jkvsPg7st295q6++fcPUHuPgf32a37PMpdY3fXDd21EOfvXM/q6rBbW14Pv5aE5mG6rchjf1+jlHiY/9+PrbZMjxvzEiCnkfjlhDxMPVBzjcYri1+YA+Z8C57DBfmGYAml+A1MtWS9Ifbn+KYWodAV/K0yshVZukTHxe9tIH6sgnybQJDvsAhyaRnZ6yxdouPi9y4OvyasgnyXQJDvsQjy/TKymVq6RMfFbxkOvwJWQS4jEOQHLIL8sIzs1pYu0XHx+wiHX1NWQX5EIMiPWQT5SRnZDi5douPitxyHXzNWQS4nEOSnLIL8rIzsN5cu0XHx+xyHX3NWQX5OIMgVLIL8ooxsaJcu0XHx+xKHXwtWQX5JIMivWAT5dRnZMS9douPi9w0Ov5asgvyGQJArWQT5bRnZki9douPi9x0Ov1asgvyOQJDfswhyVRnZ8y9douPi9wMOv/6sgvyBQJCrWQS5poxsKpgu0XHx+xGH3wBWQf5IIMifWAS5tozsWpgu0XHxW4fDbyCrINcRCPJnFkH+Uka2RUyX6Lj4rcfhN4hVkOsJBLmBRZC/lpF9F9MlOi5+v+HwK2QV5G8EgvydRZAby8jGjukSHRe/P3D4FbEK8g8CQf7JIsi/ysDOkT5+aEEmmuDmqfwFWzWyIzHQmmNWExJBZuMmanqHwnSJjotfOSB+rIIsRyDIHBZB5gIJZXkLxHSJjotfeRx+TVgFWZ5AkBVYBFkRKEjLeyymS3Rc/Crh8CtgFWQlAkFWZhFkFaAgLW/imC7RcfGrisOvKasgqxIIshqLIKsDBWl5l8h0iY6LXw0cfs1YBVmDQJA1WQRZCyhIy9tQpkt0XPxq4/BrzirI2gSCrMMiyDygIC3vc5ku0XHxS+Lwa8EqyCSBILdhEWRdoCAtb6SZLtFx8auHw68lqyDrEQhyWxZBbgcUpOWdOtMlOi5+9XH4tWIVZH0CQW7PIsgdgIK0vBVoukTHxW9HHH79WQW5I4Egd2IR5M5AQVreazRdouPitwsOvwGsgtyFQJC7sghyN6AgLW9mmi7RcfHbHYffQFZB7k4gyAYsgtwDKEjLu6WmS3Rc/PbE4TeIVZB7EghyLxZBNgQK0vJ2rOkSHRe/vXH4FbIKcm8CQe7DIsh9gYK0vN9rukTHxW8/HH5FrILcj0CQjVgE2RgoSKsbymok+LNgjC/z8QJ/nmAD5q8U4n7B/sa37pCVwLH8XMfF70WSDazzgesNkDPCgp800eFffrxDXlBet+Li5sZbrTDuAuPrtYv5R4W4FyrpJRscPzA/gozZ5aN8YvP6sCb492eYK/fzp/CnO5oEmi8I/uUGjwdnb8YoOh+NFZ3/Ofxd93w0RtPgcbNwjJO8MaLz/2Y+zYPXtwjHGuKNFZ1PN5/m3nxaBo9bhWOc7I0RnU8dY204RstwDGde9g8etw7HGOqNEZ1PHWNdOMb+4Rgu1jbB47bhGMO8MaLz7kBr55Pqf+OOHneR8TV4RfW/cUWPu5ikd5zcAzfWImDv+BoJfvcB8VsMxO91kt7xAGDvCOSMIPFzmGUltj7QfRUQy3x/vu2abH6cE/7MLoET5RViSqS8TyqO1Us4B31zjSS1a4Ift30TnCi14m7fBJ4j1cX9YaPF8W2S4jjTaHF8h6Q4dgAWRyBn5B3C4thBqTh2zBRHbJI6KhTHTsaLo4u7k1JxRM91fN7fhRztmA9sUjbjfs/4FRLHywMV4n6fpInpBCzC7wGbmGUkTcxBQPyAnJFlJPx7xqgJ+ZgEv2eNmpBPSPR7MFC/QM7IJ4Qm5GAlE9I5Y0KwSeqsYEIOMW5CXNyHkJiQiUEzfpBCU/qZ8VsnbsnTacY/JylGhwKLETDX8rlxE+d0fagCb74kaQIPUeJNXPy+IsEPyG/5Eojf1yTrVhcg/4Ccka9J+LfEqAn+jgS/N4ya4O9J9NsVqF8gZ+R7QhPcVckEH5YxwdgkHaZggrsZN8Eu7m4kJnhSYAa7KDT1q42b4Ml5OmZmDUkx6g4sRsBcyxrjJtjpursCb9aSNIHdlHgTF791JPgB+S1rgfj9TLJuHQ7kH5Az8jMJ/z4zaoJ/ZbmIZdQE/0ai3x5A/QI5I78RmuAeSia4Z8YEY5PUU8EEH2HcBLu4jyAxwVMDM3i4QlP/h3ET/GCejpn5k6QY9QIWI2Cu5U/jJtjpupcCb7Iu5mgCj1DiTVz8sknwA/JbfM7Exa/cxRzr1pFA/gE5I+VI+LfWqAmuQILfOqMmuCKJfo8C6hfIGUHiV1om+CglE3x0xgRjk3S0ggnubdwEu7h7k5jgWYEZPFKhqa9yse245+TpmJmqJMXoGGAxAuZaqirzJi5uTtfHKPCmBkkT2FuJN3Hxq0mCH5DfUgOIXy2SdetYIP+AnJFaJPzL7WnTBCdJ8CsPxA9pgrch0e9xQP0COSPbEJrg45RMcJ+MCcYmqY+CCe5r3AS7uPuSmOC5gRk8VqGp39a4CX4+T8fMbEdSjI4HFiNgrmU74ybY6fp4Bd7sQNIE9lXiTexN0knwA/JbdgDitxPJunUCkH9AzshOJPyra9QE70aCXz2jJnh3Ev2eCNQvkDOyO6EJPlHJBPfLmGBskvopmOD+xk2wi7s/iQmeH5jBExSa+j2Nm+BFeTpmZi+SYjQAWIyAuZa9jJtgp+sBCrzZh6QJ7K/Em9ibcpPgB+S37APEbz+SdWsgkH9Azsh+JPxraNQECwl+exs1wU1I9DsIqF8gZ6QJoQkepGSCCzMmGJukQgUTXGTcBLu4i0hM8JLADA5UaOqbGTfBS/N0zExzkmI0GFiMgLmW5sZNsNP1YAXetCJpAouUeBMXv/1J8APyW1oB8WtNsm6dBOQfkDPSmoR/rY2a4HYk+LUxaoLbk+h3CFC/QM5Ie0ITPETJBJ+cMcHYJJ2sYIKHGjfBLu6hJCZ4WWAGT1Jo6jsZN8HL83TMzIEkxWgYsBgBcy0HGjfBTtfDFHjTmaQJHKrEm9hbV5HgB+S3dAbidyjJunUKkH9AzsihJPzrZtQEdyPBr7tRE9ydRL+nAvUL5Ix0JzTBpyqZ4OEZE4xN0nAFE3yacRPs4j6NxASvCMzgKQpNfU/jJnhlno6ZOYKkGJ0OLEbAXMsRxk2w0/XpCrw5iqQJPE2JN3HxO5rlr2sDtXIUEL/eJOvWCCD/gJyR3iT8O9GoCe5Dgl8/oya4L4l+zwDqF8gZ6Utogs9QMsEjMyYYm6SRCiZ4lHET7OIeRWKCVwVmcIRCU3+icRO8Nk/HzPQjKUZnAosRMNfSz7gJdro+U4E3A0mawFFKvIn9XTOWJhqolYFA/ApJ1q2zgPwDckYKSfh3ulETPIQEvxFGTfDJJPo9G6hfIGfkZEITfLaSCR6dMcHYJI1WMMHnGDfBLu5zSEzw+sAMnqXQ1J9i3AT/kadjZk4lKUbnAosRMNdyqnET7HR9rgJvTidpAs9R4k3sTwhJ8APyW04H4ncGybp1HpB/QM7IGST8G2vUBJ9Fgt84oyb4bBL9ng/UL5AzcjahCT5fyQRfkDHB2CRdoGCCxxg3wS7uMSQmOCuZSJyn0NSfa9wEV0jqmJnzSIpRMbAYAXMt5xk3wU7XxQq8GUPSBI5R4k1sPpPgB+S3jAHidyHJunUhkH9AzsiFJPy7wagJvpgEvxuNmuBLSPR7EVC/QM7IJYQm+CIlEzw2Y4KxSRqrYILHGTfBLu5xJCa4SmAGL1Ro6i83boJrJXXMzBUkxehiYDEC5lquMG6Cna4vVuDNBJZPQpR4Exe/q0jwA/JbJgDxu5pk3boEyD8gZ+RqEv5NNWqCJ5LgN82oCb6eRL+XAvUL5IxcT2iCL1UywZdlTDA2SZcpmODLjZtgF/flJCY4GZjBSxSa+puMm+D6SR0zczNJMboCWIyAuZabjZtgp+srFHhzG0kTeLkSb+LidzsJfkB+y21A/CaRrFtXAvkH5IxMIuHfk0ZN8N0k+D1l1ATfQ6Lf8UD9Ajkj9xCa4PFKJnhCxgRjkzRBwQRfZdwEu7ivIjHBOwVm8EqFpv5e4ya4QVLHzNxHUoyuBhYjYK7lPuMm2On6agXe3E/SBF6lxJu4+D1Agh+Q33I/EL/pJOvWNUD+ATkj00n4t8ioCX6YBL/FRk3wTBL9XgvUL5AzMpPQBF+rZIKvy5hgbJKuUzDBE42bYBf3RBIT3DAwg9coNPWPGjfBjZM6ZuYxkmJ0PbAYAXMtjxk3wU7X1yvwZg5JEzhRiTdx8XuCBD8gv2UOEL8nSdatG4D8A3JGniTh38dGTfAzJPh9YtQEP0ui3xuB+gVyRp4lNME3KpngmzImGJukmxRM8M3GTbCL+2YSE1wQmMEbFJr6542b4FZJHTPzAkkxugVYjIC5lheMm2Cn61sUeDOf5XZeJd7Exe9lEvyA/Jb5QPwWkKxbtwL5B+SMLCDh32qjJngRCX5rjJrgxST6vQ2oXyBnZDGhCb5NyQTfnjHB2CTdrmCCJxk3wS7uSSQmuG1gBm9VaOqXGDfBnZI6ZuYNkmJ0B7AYAXMtbxg3wU7Xdyjw5m2SJnCSEm/i4vcOCX5AfsvbQPyWkqxbdwL5B+SMLCXhX9YRNk3wMhL8soH4IU3wByT6vQuoXyBn5ANCE3yXkgm+O2OCsUm6W8EE32PcBLu47yExwZ0DM3inQlP/sXET3C2pY2Y+ISlGk4HFCJhr+cS4CXa6nqzAm89ImsB7lHgTF7/PWW6nBGrlMyB+K0jWrSlA/gE5IytI+FfHqAn+mgS/PKMm+BsS/d4L1C+QM/INoQm+V8kE35cxwdgk3adggqcaN8Eu7qkkJrhnYAanKDT13xk3wb2TOmbme5JiNA1YjIC5lu+Nm2Cn62kKvFnNssWKEm/i4reGBD8gv2U1EL8fSdat+4H8A3JGfiThXwOjJvhnEvz2MGqCfyHR7wNA/QI5I78QmuAHlEzw9IwJxiZpuoIJnmHcBLu4Z5CY4D6BGbxfoan/1bgJ7p/UMTO/kRSjB4HFCJhr+c24CXa6flCBN3+QNIEzlHgTF78/SfAD8lv+AOL3F8m69RCQf0DOyF8k/Gth1ASXu4QDv5ZGTXDOJRz6fRioXyBnBIlfaZngh5VM8MyMCcYmaaaCCZ5l3AS7uGeRmODCwAw+pNDUV7jEdtxDkzpmpiJJMXoEWIyAuZaKyryJi5vT9SMKvKlC0gTOUuJNXPyqkuAH5LdUAeJXjWTdehTIPyBnpBoJ/w41aoJrkeDXxagJrk2i38eA+gVyRmoTmuDHlEzw7IwJxiZptoIJfty4CXZxP05igocHZvBRhaY+adwEj0rqmJltSIrRHGAxAuZatjFugp2u5yjwZluSJvBxJd7ExW87EvyA/JZtgfjVJ1m3ngDyD8gZqU/Cvz5GTfBOJPj1NWqCdybR75NA/QI5IzsTmuAnlUzwUxkTjE3SUwomeK5xE+zinktigkcHZvAJhaZ+N+MmeExSx8zsTlKMngYWI2CuZXfjJtjp+mkF3uxJ0gTOVeJNXPz2IsEPyG/ZE4hfQ5J16xkg/4CckYYk/DvFqAnejwS/U42a4EYk+n0WqF8gZ6QRoQl+VskEz8uYYGyS5imY4OeMm2AX93MkJnhsYAafUWjqxbgJvjypY2aakBSj54HFCJhraWLcBDtdP6/Am2YkTeBzSryJi19zEvyA/JZmQPxakKxbLwD5B+SMtCDh3xijJrg1CX7FRk1wGxL9vgjUL5Az0obQBL+oZIJfyphgbJJeUjDB842bYBf3fBITPCEwgy8oNPXtjJvgiUkdM9OepBi9DCxGwFxLe+Mm2On6ZQXedCJpAucr8SYufgeS4Afkt3QC4ncQybq1AMg/IGfkIBL+XWvUBB9Kgt91Rk1wFxL9LgTqF8gZ6UJoghcqmeBXMiYYm6RXFEzwq8ZNsIv7VRITfFNgBhcoNPXdjJvgSUkdM9OdpBgtAhYjYK6lu3ET7HS9SIE3PUmawFeVeBMXvyNI8APyW3oC8etFsm4tBvIPyBnpRcK/yUZNcG8S/KYYNcHHkOj3NaB+gZyRYwhN8GtKJvj1jAnGJul1BRO8xLgJdnEvITHBdwdmcLFCU9/HuAmemtQxM31JitEbwGIEzLX0NW6Cna7fUODNiSRN4BIl3sTFrx/LH9YBauVEIH79SdatN4H8A3JG+pPwb7ZRE1zI8ocBjZrgIhL9vgXUL5AzUkRogt9SMsFvZ0wwNklvK5jgd4ybYBf3OyQmeHpgBt9UaOqHGDfBs5I6ZuZkkmK0FFiMgLmWk42bYKfrpQq8OYWkCXxHiTdx8TuVBD8gv+UUIH7DSdatd4H8A3JGhpPwb4FRE3wGCX4LjZrgkST6fQ+oXyBnZCShCX5PyQS/nzHB2CS9r2CClxk3wS7uZSQmeHZgBt9VaOrPMm6C5yZ1zMzZJMXoA2AxAuZazjZugp2uP1DgzbkkTeAyJd7Exe88EvyA/JZzgfidT7JufQjkH5Azcr7xejcvqHcfKqxbFxqPe35SZ72+iEQvHwH1Asy1XGScN6uDMT5S4M1q3Bw3GdfyHmfWBP/+DP79GP78Kfzpjo+DWD4J/uUGj0/J3mxqo/PRWNH5n8Pfdc9HYywPHn8ajnGqN0Z0/t/M57Pg9Z+HYw33xorOp5vPZ958VgSPvwjHOM0bIzqfOsbacIwV4RjO4H8ZPP4qHON0b4zofOoY68IxvgzHcLF+HTz+JhxjhDdGdL60Lor8iBsrP9ub58rQy37redqjwp+VElteIEmEeCWwseUrXHDJd/mq4MURHdneueg9I067izBVSnitz/v2mPlJKmfae4+j9/LnkvU/nouPV8I7Vy4FK58z0XMuF92953NK+J3otTklvM6PPVchdv992nv/j96rsjeHHANzyS5hLuWxc9lUdyP9JBJbXhyN5hHNqYL3XEUwJm6MSiXMo6I3j1Sdlw/PA+exaXWsUsI8Kns/o/ev4s2jKnYeBZVS5uGOf9JvVW8u1bBz2cSR6t57RfOq5v0/ej7Xm0d17Dw26aZaSvzR//35/V/nWoForpX+x3NV4FWRG7MGdswmlRJbYuqOf9JNDS++mti5FDhNVkhszms0fiq2fv+hsb7X9uL18+kOt57VCh/7r4se53jP+/U+er6dF5Mbsw52/pvy6c/LHf+Uz+j9Xd2I1sTBhSN7FQ4cUTiya+HoLG+M2ilx+T1wrvfYXyc08pP03qu2917ucPnJCx8nvec06u82JczDr7/R+0evq+Q9zvPO1U2Zr98r+r8b1dbo9RXC2HKwsRX47xUd/8ShHC92j0M9Rg0YNmRgCoeiccuVMK7f9+amvM7HxO+vslIn2D4BAUGQFy005vdJ9b8vQqAv1lxs/CLViup/X2RAx30JycXN74AXN4G5FiR+qRfVvgsvPK0Mf37rXRD7Pni8KrwQdYZ3ISo6/28u0P0QvH51ONZIb6zofLoLdD9481kTPP4xHGOUN0Z0vlxi68XVHWiddEno8Bk9z++b2F9n12Bv6Clq2qRpvlvHUHH7RfQn74JlVIz/XxeXsrxzflPnDqYLmxW9OBIp8VYPn48a3lOHjxxSNLr7qGHDhhQNKRzUffjIQh/G1P7DHyr1vH9trnzK7/uQRs+V6b7Fze8npRvF0mEat+au/e833+WnjCWl9cHIWqW7Rddl7hbFJmmdwt2iPxu/W9TF/TPJ3aJuwdKYa2k1gmtiNBpFWx75JUz3v44tqSc0MUAWRX+x+yXkxXqPH1HzkZ3YuvL7V0Dc4tmxhJizvMfZ4WvK/cNrstKMU9KnQ9UTPA3dFou5ZUJkhYn6pcnmxLj/O1J0SGx5oD+iBsYh64FFY0MT2KJTFOG5wcMzZoe3VVe22stfjHG3wuFy47d2rw55ih73CqO3JqcWNKR+2nXF4Xclya3dQH4LkDOihV82WCe/ANfcX4FXht0YGjX3V+O3l2rE/U0wxpuCj/tq45/UnBd0cG8pxH0NySc1vwH1CMy1XGOcN04v7yjwZiKBXpYqxH09iV5+B+oFmGu5nkAv7ynw5iYCvbyvEPfNJHrZCNQLMNdyM4FePlDgzW0EevlQIe7bSfTyB1AvwFzL7QR6+ViBN3cS6OUThbjvItHLn0C9AHMtdxHo5VMF3kwm0MtnCnFPIdHLX0C9AHMtUwj0skKBN1MJ9PKFQtzTSPSSKMBhCcy1TCPQy1cKvJlOoJevFeKeQaKXLKBegLmWGQR6WanAm4cJ9PKtQtwzSfSSDdQLMNcyk0Av3yvw5lECvaxSiPsxEr2UA+oFmGt5jEAvqxV4M4dAL2sU4n6CRC85QL0Acy1PEOjlJwXezCXQy1qFuJ8m0UsuUC/AXMvTBHr5WYE38wj08otC3M+R6KU8UC/AXMtzBHrZoMCbFwn08qtC3C+R6KUCUC/AXMtLBHr5XYE3Cwj0slEh7oUkeqkI1Asw17KQQC9/KvBmEYFe/lKIezGJXioB9QLMtSDxc3+25MzszX960X2Hwd2X7e41dffPuXuC3H0O7rNb93mUu8burhu6ayHO37me1dVht7Y4vHLC8VIPVOzReHCu18Bz0vpfTlJZKLMUvvC1hGChzFaI+w2ShbIycKEE5lreIGgschR48zaBXnIV4n6HRC9VgHoB5lreIdBLBQXevEegl4oKcb9PopeqQL0Acy3vE+ilsgJvPiTQSxWFuD8i0Us1oF6AuZaPCPRSTYE3ywn0Ul0h7k9J9FIdqBdgruVTAr3UVODNCgK91FKI+wsSvdQA6gWYa/mCQC91FHjzNYFe8hTi/oZELzWBegHmWr4h0Ms2Crz5jkAvdRXi/p5EL7WAegHmWr4n0Mu2Gn9wj0Av2ynEvYZEL7WBegHmWtYQ6GV7Bd6sJdDLDgpxryPRSx2gXoC5lnUEetlJgTfrCfSys0LcG0j0kgfUCzDXsoFAL7sq8OZ3Ar3sphD3RhK9JIF6AeZaNhLopYECb/4i0MseCnEnLuXQyzZAvQBzLWj8NPSylwJvyhmP2+mloULcOSR6qQvUCzDXkkOgl30UeFOBQC/7KsRdkUQv9YB6AeZaKhLopZECb6oQ6KWxQtxVSfSyLVAvwFwLEj/3xaezsjd/8cl9h8Hdl+3uNXX3z7l7gtx9Du6zW/d5lLvG7q4bumshzt+5ntXVYbe2OLw0eJhuK/LY92+UEg/z//ux1ZbpcWPeDshpJH45IQ9TD9Rco/HK4hfmgDnfcidctCDrF2AJpfgNTLVk1S+wP8fttQiFruA7AFc7y1uRpUt0XPx2BOLHKsgdCQS5E4sgdwYSyvJeZ+kSHRe/XXD4NWEV5C4EgtyVRZC7AQVpeTO1dImOi9/uOPwKWAW5O4EgG7AIcg+gIC3v1pYu0XHx2xOHX1NWQe5JIMi9WATZEChIy9vBpUt0XPz2xuHXjFWQexMIch8WQe4LFKTl/ebSJToufvvh8GvOKsj9CATZiEWQjcvIhnbpEh0Xv3wcfi1YBZlPIEhhEWSTMrJjXrpEx8WvAIdfS1ZBFhAIsimLIJuVkS350iU6Ln7Ncfi1YhVkcwJBtmARZMsysudfukTHxa8VDr/+rIJsRSDI/VkE2bqMbCqYLtFx8WuDw28AqyDbEAiyLYsgDygjuxamS3Rc/Nrh8BvIKsh2BIJszyLIDmVkW8R0iY6LX0ccfoNYBdmRQJCdWAR5YBnZdzFdouPidxAOv0JWQR5EIMiDWQTZuYxs7Jgu0XHxOwSHXxGrIA8hEOShLILsUgZ2jvTxQwuyK/j7kGcRCrIrgSAPYxFktzKyQ2G6RMfFrzv4+5CMguxOIMjDWQTZo4xsgZgu0XHx6wn+PiSjIHsSCPIIFkH2KiN7LKZLdFz8jgR/H5JRkEcSCPIoFkEeXUY2cUyX6Lj49QZ/H5JRkL0JBHkMiyCPLSO7RKZLdFz8jgN/H5JRkMcRCLIPiyD7lpFtKNMlOi5+x4O/D8koyOMJBHkCiyBPLCP7XKZLdFz8+oG/D8koyH4EguzPIsgBZWQjzXSJjovfQPD3IRkFOZBAkINYBFlYRnbqTJfouPgVgb8PySjIIgJBDmYR5ElAQVreCjRdouPiNwT8fUhGQQ4hEOTJLIIcChSk5b1G0yU6Ln7DwN+HZBTkMAJBnsIiyFOBgrS8mWm6RMfFbzj4+5CMghxOIMjTWAR5OlCQlndLTZfouPiNAH8fklGQIwgEeQaLIEcCBWl5O9Z0iY6L3yjw9yEZBTmKQJBnsgjyLKAgLe/3mi7RcfE7G/x9SEZBnk0gyNEsgjwHKEirG8pqJNhtwJyvsAFsLYINmEUh7tr2N751h6wBjuXnOi5+dUg2sD4XuN4AOSMs+J1XoMO//HiH1FZet+Li5sb7RWHcusbXaxfzBoW46ynpJRscPzA/gozZ5aN8YvP6sD7492eYK/fz1/CnO84PNH9B8C83eHx29maMovPRWNH5jeHvuuejMcYEj4vDMUZ7Y0Tn/818Lgxef1E41jneWNH5dPO50JvP2ODxuHCMc70xovOpY/wWjjE2HMOZl4uDx5eEY5znjRGdTx3j93CMi8MxXKyXBo8vC8c43xsjOu8OtHYuqPE37vC9yo2vwWNr/I0retztSXrHyT1wY9UH9o47kOB3HxC/7YH47UjSO14O7B2BnBEkfg6zrMTWB7qvAmKZ78/3ioLNj3PCn9klcKK8QkyJlPdJxbF6Ceegb66RpCsK8ONeWYATpVbcVxbAc6S6uD9stDjuRlIcZxotjruTFMfxwOII5IzsTlgcxysVxwmZ4ohN0gSF4niV8eLo4r5KqTjC55r3dyFHO+arC8pm3Hsav0LieHm1Qtx7kTQxVwGL8J7AJqYhSRNzDRA/IGekIQn/njFqQvYjwe9ZoyakEYl+rwXqF8gZaURoQq5VMiHXZUwINknXKZiQicZNiIt7IokJmRg049coNKVi/NaJW/J0mvEmJMXoemAxAuZamhg3cU7X1yvwphlJEzhRiTexd2wnwQ/Ib2kGxK8Fybp1A5B/QM5ICxL+LTFqgluT4PeGURPchkS/NwL1C+SMtCE0wTcqmeCbMiYYm6SbFEzwzcZNsIv7ZhITPCkwgzcoNPXtjJvgyXk6ZqY9STG6BViMgLmW9sZNsNP1LQq86UTSBN6sxJvYO4ST4Afkt3QC4ncQybp1K5B/QM7IQST8+8yoCT6UBL/PjZrgLiT6vQ2oXyBnpAuhCb5NyQTfnjHB2CTdrmCCJxk3wS7uSSQmeGpgBm9VaOq7GTfBD+bpmJnuJMXoDmAxAuZauhs3wU7XdyjwpidJEzhJiTdx8TuCBD8gv6UnEL9eJOvWnUD+ATkjvUj4t9aoCe5Ngt86oyb4GBL93gXUL5AzcgyhCb5LyQTfnTHB2CTdrWCC7zFugl3c95CY4FmBGbxToanvY9wEz8nTMTN9SYrRZGAxAuZa+ho3wU7XkxV4cyJJE3iPEm9ib2lMgh+Q33IiEL/+JOvWFCD/gJyR/iT8y+1p0wQXkuBXHogf0gQXkej3XqB+gZyRIkITfK+SCb4vY4KxSbpPwQRPNW6CXdxTSUzw3MAMTlFo6ocYN8HP5+mYmZNJitE0YDEC5lpONm6Cna6nKfDmFJImcKoSb2JvoUuCH5DfcgoQv+Ek69b9QP4BOSPDSfhX16gJPoMEv3pGTfBIEv0+ANQvkDMyktAEP6BkgqdnTDA2SdMVTPAM4ybYxT2DxATPD8zg/QpN/VnGTfCiPB0zczZJMXoQWIyAuZazjZtgp+sHFXhzLkkTOEOJN7H3lCTBD8hvOReI3/kk69ZDQP4BOSPnk/CvoVETfCEJfnsbNcEXkej3YaB+gZyRiwhN8MNKJnhmxgRjkzRTwQTPMm6CXdyzSEzwksAMPqTQ1F9s3AQvzdMxM5eQFKNHgMUImGu5xLgJdrp+RIE3l5M0gbOUeBMXvytI8APyWy4H4nclybr1KJB/QM7IlST8a23UBF9Ngl8boyb4GhL9PgbUL5Azcg2hCX5MyQTPzphgbJJmK5jgx42bYBf34yQmeFlgBh9VaOonGjfBy/N0zMz1JMVoDrAYAXMt1xs3wU7XcxR4cxNJE/i4Em9i/9VuEvyA/JabgPjdQrJuPQHkH5AzcgsJ/7oZNcGTWP6wnVETfAeJfp8E6hfIGbmD0AQ/qWSCn8qYYGySnlIwwXONm2AX91wSE7wiMINPKDT1dxs3wSvzdMzMPSTF6GlgMQLmWu4xboKdrp9W4M29JE3gXCXexMXvPpY/LAbUyr1A/KaSrFvPAPkH5IxMJeHfiUZN8HQS/PoZNcEzSPT7LFC/QM7IDEIT/KySCZ6XMcHYJM1TMMHPGTfBLu7nSEzwqsAMPqPQ1D9s3ASvzdMxMzNJitHzwGIEzLXMNG6Cna6fV+DNoyRN4HNKvIl9mx0JfkB+y6NA/GaTrFsvAPkH5IzMJuHf6UZN8JMk+I0waoKfItHvi0D9AjkjTxGa4BeVTPBLGROMTdJLCiZ4vnET7OKeT2KC1wdm8AWFpv4Z4yb4jzwdM/MsSTF6GViMgLmWZ42bYKfrlxV48zxJEzhfiTexzREJfkB+y/NA/F4kWbcWAPkH5Iy8SMK/sUZN8AIS/MYZNcELSfS7EKhfIGdkIaEJXqhkgl/JmGBskl5RMMGvGjfBLu5XSUxwVjKRWKDQ1C8yboIrJHXMzGKSYrQIWIyAuZbFxk2w0/UiBd4sIWkCX1XiTVz83iDBD8hvWQLE702SdWsxkH9AzsibJPy7wagJXkqC341GTfC7JPp9DahfIGfkXUIT/JqSCX49Y4KxSXpdwQQvMW6CXdxLSExwlcAMLlZo6pcZN8G1kjpm5gOSYvQGsBgBcy0fGDfBTtdvKPDmY5ImcIkSb+Li9wkJfkB+y8dA/JaTrFtvAvkH5IwsJ+HfVKMmeAUJftOMmuAvSPT7FlC/QM7IF4Qm+C0lE/x2xgRjk/S2ggl+x7gJdnG/Q2KCk4EZfFOhqf/auAmun9QxM9+QFKOlwGIEzLV8Y9wEO10vVeDNdyRN4DtKvImL3/ck+AH5Ld8B8VtFsm69C+QfkDOyioR/Txo1wT+S4PeUURP8E4l+3wPqF8gZ+YnQBL+nZILfz5hgbJLeVzDBy4ybYBf3MhITvFNgBt9VaOp/Nm6CGyR1zMwvJMXoA2AxAuZafjFugp2uP1Dgza8kTeAyJd7Exe83EvyA/JZfgfj9TrJufQjkH5Az8jsJ/xYZNcF/sXydwagJTlzGod+PgPoFckaQ+JWWCf5IyQR/nDHB2CR9rGCCPzFugl3cn5CY4IaBGfxQoakvd5ntuBsndcxMDkkxWg4sRsBcS44yb2LfdhvgtlyBNxVKiTf58Y4t1t78eMcWvImLX0US/ID8lgpA/CqRrFufAvkH5IxUIuHfx0ZNcDWW9c+oCa5Oot/PgPoFckaqE5rgz5RM8OcZE4xN0ucKJniFcRPs4l5BYoILAjP4qUJTX8u4CW6V1DEztUmK0RfAYgTMtdQ2boKdrr9Q4E2SpAlcocSbuPhtQ4IfkN+SBOJXl2Td+hLIPyBnpC4J/1YbNcH1SfBbY9QEb0+i36+A+gVyRrYnNMFfKZngrzMmGJukrxVM8DfGTbCL+xsSE9w2MINfKjT1Oxk3wZ2SOmZmZ5JitBJYjIC5lp2Nm2Cn65UKvNmNpAn8Rok3cfHbnQQ/IL9lNyB+DUjWrW+B/ANyRhqQ8C/rCJsmuCEJftlA/JAmeG8S/X4H1C+QM7I3oQn+TskEf58xwdgkfa9gglcZN8Eu7lUkJrhzYAa/VWjq9zNugrsldcxMI5Ji9AOwGAFzLY2Mm2Cn6x8UeCMkTeAqJd7Exa8JCX5AfosA8SsgWbdWA/kH5IwUkPCvjlET3IIEvzyjJrgliX7XAPUL5Iy0JDTBa5RM8I8ZE4xN0o8KJvgn4ybYxf0TiQnuGZjB1QpNfWvjJrh3UsfMtCEpRmuBxQiYa2lj3AQ7Xa9V4E07kibwJyXexMWvPQl+QH5LOyB+HUjWrXVA/gE5Ix1I+NfAqAk+iAS/PYya4INJ9PszUL9AzsjBhCb4ZyUT/EvGBGOT9IuCCV5v3AS7uNeTmOA+gRlcp9DUH2rcBPdP6piZLiTFaAOwGAFzLV2Mm2Cn6w0KvOlG0gSuV+JNXPy6k+AH5Ld0A+J3OMm69SuQf0DOyOEk/Gth1AT3IsGvpVETfCSJfn8D6hfIGTmS0AT/pmSCf8+YYGySflcwwRuNm2AX90YSE1wYmMFfFZr63sZN8NCkjpk5hqQY/QEsRsBcyzHGTbDT9R8KvOlD0gRuVOJNXPz6kuAH5Lf0AeJ3PMm69SeQf0DOyPEk/DvUqAnuz3IRy6gJHkCi37+A+gVyRgYQmuC/lExwounmhxkTHHNMlyQHKHrcrKa2TbCLO6spPEcqcx0emME/FZr6QuMmeFRSx8wUkRSj7KbACynAYlRk3AQ7XWc3xY87hOUP6yjxJi5+J5PgB+S3DAHiN5Rk3SoH5B+QMzKUhH99jJrg4ST49TVqgk8j0W8OUL9AzshphCYYiOUWJjg3Y4KxScpVMMHljZtgF3d5EhM8OjCD5RSa+jOMm+AxSR0zM5KkGFUAFiNgrmWkcRPsdF1BgTdnkTSB5ZV4Exe/s0nwA/JbzgLiN5pk3aoI5B+QMzKahH+nGDXB55Pgd6pRE3wBiX4rAfUL5IxcQGiCKymZ4MoZE4xNUmUFE1zFuAl2cVchMcFjAzNYUaGpv9C4Cb48qWNmLiIpRlWBxQiYa7nIuAl2uq6qwJuLSZrAKkq8iYvfJST4AfktFwPxu5Rk3aoG5B+QM3IpCf/GGDXBV5LgV2zUBI8n0W91oH6BnJHxhCa4upIJrpExwdgk1VAwwTWNm2AXd00SEzwhMIPVFJr6q42b4IlJHTNzDUkxqgUsRsBcyzXGTbDTdS0F3kwkaQJrKvEmLn7Xk+AH5LdMBOJ3A8m6VRvIPyBn5AYS/l1r1ATfQoLfdUZN8K0k+q0D1C+QM3IroQmuo2SC8zImGJukPAUTnDRugl3cSRITfFNgBmsrNPWTjJvgSUkdM3MHSTHaBliMgLmWO4ybYKfrbRR4czdJE5hU4k1c/O4hwQ/Ib7kbiN9kknWrLpB/QM7IZBL+TTZqgqeS4DfFqAmeRqLfekD9Ajkj0whNcD0lE7xtxgRjk7StggnezrgJdnFvR2KC7w7MYF2Fpn66cRM8NaljZmaQFKP6wGIEzLXMMG6Cna7rK/DmYZImcDsl3sTFbyYJfkB+y8NA/GaRrFvbA/kH5IzMIuHfbKMmeDYJfo8bNcGPk+h3B6B+gZyRxwlN8A5KJnjHjAnGJmlHBRO8k3ET7OLeicQETw/M4PYKTf2Txk3wrKSOmXmKpBjtDCxGwFzLU8ZNsNP1zgq8eYakCdxJiTdx8XuWBD8gv+UZIH7zSNatXYD8A3JG5pHwb4FRE/wiCX4LjZrgl0j0uytQv0DOyEuEJnhXJRO8W8YEY5O0m4IJ3t24CXZx705igmcHZnAXhaZ+gXETPDepY2YWkhSjBsBiBMy1LDRugp2uGyjwZhFJE7i7Em/i4reYpYkGamUREL/XSNatPYD8A3JGXjNe7+YF9W4PhXXrTeNxz0/qrNdvkehlT6BegLmWt4zz5pdgjD0VePMLbo6bjGt5jzPrg39/Bv82hD9/DX+6Y68gloZut57g8QXZm01tdD4aKzq/Mfxd93w0xt7B433CMcZ4Y0Tn/8189g1ev184VrE3VnQ+3Xz29ebTKHjcOBzjQm+M6HzqGL+FYzQKx3AGPz94LOEYF3ljROdTx/g9HCM/HMPF2iR4XBCOMdYbIzpfWhdFNuDGys/25tk09LLNPE97VPizUmLLCySJEK8ENrZ8hQsu+S5fFbw4oiPbOxe9Z8RpdxGmSgmv9XnfHjM/SeVMe+9x9F7+XLL+x3Px8Up458qlYOVzJnrO5aK793xOCb8TvTanhNf5secqxO6/T3vv/9F7VfbmkGNgLtklzKU8di6b6m6kn0Riy4uj0TyiOVXwnqsIxsSNUamEeVT05pGq8/LheeA8mrgxqpQwj8rez+j9q3jzqIqdR0GllHm445/0W9WbSzXsXDZxpLr3XtG8qnn/j57P9eZRHTuPTbqplhJ/9H9/fv/XuVYgmmul//FcFXhV5MasgR2zSaXElpi64590U8OLryZ2LgVOkxUSm/MajZ+Krd9/aKzvtb14/Xy6w61ntcLH/uuixzne8369j55v58XkxqyDnf+mfPrzcsc/5TN6f1c3ojVxcOHIXoUDRxSO7Fo4Ossbo3ZKXH4PnOs99tcJjfwkvfeq7b2XO1x+8sLHSe85jfq7TQnz8Otv9P7R6yp5j/O8c3VT5uv3iv7vRrU1en2FMLYcbGwF/ntFxz9xKMeL3eNQj1EDhg0ZmMKhaNxyJYzr9725Ka/zMfH7q6zUCbZPQEAQ5EULjfldUOPvixDoizVLjV+kGlvj74sM6LjfJbm42Rx4cROYa0Hil3pRrXl44alp+LOZd0GsRfC4ZXghapx3ISo6/28u0LUKXr9/ONbF3ljR+XQX6Fp582kdPG4TjnGJN0Z0vlxi68XVHWiddEno8Bk9zxZN7a+zrbE39BQ1bdI0361jqLj9ItrWu2AZFeP/18WlLO+c39S5g+nCZkUvjkRKvNXD56OG99ThI4cUje4+atiwIUVDCgd1Hz6y0Icxtf/wh0o971+bK5/y+z6k0XNlum9x82urdKNYOkzj1twD/vvNd/kpY0lpfTBygNLdou0yd4tik9RO4W7R9sbvFt1ETpK7RTctqApzLa1G8JoYjUbRlkd+CdP9r2NL6glNDJBF0V/sOoS86OjxI2o+shNbV37/CohbPDuWEHOW9zg7fE25f3hNVppxSvp0qHqCp6HbYjG3TIisMFEdmm5OzKbEBf/vkNjyQH9EDYxDOgKLRqemsEWnKMKzk4dnzA5vq67sFy9/McbdCodlxm/t/iXkKXrcD4zempxa0JD6WdYVh9+HJLd2A/ktQM6IFn7ZYJ10AK65BwKvDLsxNGrugcZvL9WIe3UwxvYF+LiXG/+kZvvAeOygEPenJJ/UHATUIzDX8qlx3ji97KTAmxUEetlZIe4vSPRyMFAvwFzLFwR62VWBN18T6GU3hbi/IdFLZ6BegLmWbwj00kCBN98R6GUPhbi/J9HLIUC9AHMt3xPoZS8F3qwm0EtDhbjXkOjlUKBegLmWNQR62UeBN2sJ9LKvQtzrSPTSBagXYK5lHYFeGinwZj2BXhorxL2BRC9dgXoB5lo2EOhFFHjzO4FemijEvZFEL4cB9QLMtWwk0EtTBd78RaCXZgpxJy7n0Es3oF6AuRY0fhp6aaHAm3LG43Z6aakQdw6JXroD9QLMteQQ6GV/Bd5UINBLa4W4K5Lo5XCgXoC5looEemmrwJsqBHo5QCHuqiR66QHUCzDXUpVAL+0VeFODQC8dFOKuSaKXnkC9AHMtNQn00kmBN3UI9HKgQtx5JHo5AqgXYK4lj0AvByvwpi6BXjorxF2PRC+9gHoB5lrqEejlUAXe1CfQSxeFuLcn0cuRQL0Acy1I/NyfLbk0e/OfXnTfYXD3Zbt7Td39c+6eIHefg/vs1n0e5a6xu+uG7lqI83euZ3V12K0tDq+ccLzUAxV7NB6c6zXxnLT+l5NUFsrDFBaMnQgWym4Kce9MslAeBVwogbmWnQkai8MVeLMbgV56KMS9O4lejgbqBZhr2Z1AL0co8GZPAr30Uoh7LxK99AbqBZhr2YtAL0cp8GYfAr0crRD3viR6OQaoF2CuZV8CvRyjwJvGBHo5ViHufBK9HAvUCzDXkk+glz4KvCkg0EtfhbibkujlOKBegLmWpgR6OUGBNy0I9HKiQtwtSfTSB6gXYK6lJYFe+ivwpjWBXgYoxN2GRC99gXoB5lraEOhlkAJv2hHopVAh7vYkejkeqBdgrqU9gV4GK/CmE4FeTlKI+0ASvZwA1Asw13IggV5OVuBNZwK9DFWI+xASvZwI1Asw13IIgV5OUeBNVwK9nKoQ92EkeukH1Asw13IYgV5OU+DN4QR6OV0h7h4keukP1Asw19KDQC9nKPCmF4FeRirEfSSJXgYA9QLMtRxJoJczFXjTm0AvZynEfQyJXgYC9QLMtRxDoJfRCrzpQ6CXcxTi7kuil0FAvQBzLUj83BefLsve/MUn9x0Gd1+2u9fU3T/n7gly9zm4z27d51HuGru7buiuhTh/53pWV4fd2jIo3A0SzcN0W5HHvp5TSjzM/+/HVlumx425EMhpJH45IQ9TD9Rco/HK4hfmgDnfcidctCCLmmIJpfgNTLVkFTW1P8fBWoRCV/CTyshWZOkSHRe/IUD8WAU5hECQJ7MIcmgZ2essXaLj4jcMh18TVkEOIxDkKSyCPLWMbKaWLtFx8RuOw6+AVZDDCQR5GosgTy8ju7WlS3Rc/Ebg8GvKKsgRBII8g0WQI8vIdnDpEh0Xv1E4/JqxCnIUgSDPZBHkWWVkv7l0iY6L39k4/JqzCvJsAkGOZhHkOWVkQ7t0iY6L37k4/FqwCvJcAkGexyLI88vIjnnpEh0Xvwtw+LVkFeQFBIIcwyLI4jKyJV+6RMfF70Icfq1YBXkhgSAvYhHk2DKy51+6RMfFbxwOv/6sghxHIMiLWQR5SRnZVDBdouPidykOvwGsgryUQJCXsQjy8jKya2G6RMfF7wocfgNZBXkFgSCvZBHk+DKyLWK6RMfFbwIOv0GsgpxAIMirWAR5dRnZdzFdouPidw0Ov0JWQV5DIMhrWQR5XRnZ2DFdouPiNxGHXxGrICcSCPJ6FkHeUAZ2jvTxQwvyRvD3IS8jFOSNBIK8iUWQN5eRHQrTJToufreAvw/JKMhbCAR5K4sgbysjWyCmS3Rc/G4Hfx+SUZC3EwhyEosg7ygjeyymS3Rc/O4Efx+SUZB3EgjyLhZB3l1GNnFMl+i4+N0D/j4koyDvIRDkZBZBTikju0SmS3Rc/O4Ffx+SUZD3EgjyPhZBTi0j21CmS3Rc/KaBvw/JKMhpBIK8n0WQD5SRfS7TJTouftPB34dkFOR0AkHOYBHkg2VkI810iY6L30Pg70MyCvIhAkE+zCLImWVkp850iY6L3yzw9yEZBTmLQJCPsAjyUaAgLW8Fmi7RcfF7DPx9SEZBPkYgyNksgnwcKEjLe42mS3Rc/OaAvw/JKMg5BIJ8gkWQTwIFaXkz03SJjovfU+DvQzIK8ikCQc5lEeTTQEFa3i01XaLj4vcM+PuQjIJ8hkCQz7IIch5QkJa3Y02X6Lj4PQf+PiSjIJ8jEOTzLIJ8AShIy/u9pkt0XPxeBH8fklGQLxII8iUWQc4HCtLqhrIaCXYbMJ+rsBFxf4INmM9TiHuA/Y1v3SHrgWP5uY69kTrJBtYvA9cbIGeEBb8FTXX4lx/vkAHK61Zc3Nx4fyiMO9j4eu1i/ksh7pOU9JINjh+YH0HG7PJRPrF5ffgz/PdX+NMl7M/wuYWB5l8J/uUGjy/P3oxRdD4aKzpfLvxd93w0xqvB40XhGFd4Y0Tn/818Fgevfy0c60pvrOh8uvks9ubzevB4STjGeG+M6HzqGFnhGK+HYzjz8kbw+M1wjAneGNH51DGywzHeCMdwsb4VPH47HOMqb4zofBj6pqN9+DOudnas+Tfu6HGHGl+Dd6v5N67wHWhJesfJPXBjDQX2jqeQ4HcfEL9hQPxOJekd3wH2jkDOCBI/h1lWYusD3VcBscz357u06ebHOeHP7BI4UV4hpkTK+6TiWL2Ec9A310jS0qb4cd9tihOlVtzvNoXnSHVxf9hocTyDpDjONFocR5IUx/eAxRHIGRlJWBzfUyqO72eKIzZJ7ysUx2XGi6OLe5lScUTPdXze34Uc7Zg/aFo24z7L+BUSx8sPFOI+m6SJWQYswmcBm5jRJE3Mh0D8gJyR0ST8e8aoCTmfBL9njZqQC0j0+xFQv0DOyAWEJuQjJRPyccaEYJP0sYIJ+cS4CXFxf0JiQiYGzfiHCk3phcZvnbglT6cZv4ikGC0HFiNgruUi4ybO6Xq5Am8uJmkCP1HiTez9fEnwA/JbLgbidynJuvUpkH9AzsilJPxbYtQEX0mC3xtGTfB4Ev1+BtQvkDMyntAEf6Zkgj/PmGBskj5XMMErjJtgF/cKEhM8KTCDnyo09VcbN8GT83TMzDUkxegLYDEC5lquMW6Cna6/UODNRJImcIUSb+Lidz0JfkB+y0QgfjeQrFtfAvkH5IzcQMK/z4ya4FtI8PvcqAm+lUS/XwH1C+SM3Epogr9SMsFfZ0wwNklfK5jgb4ybYBf3NyQmeGpgBr9UaOonGTfBD+bpmJk7SIrRSmAxAuZa7jBugp2uVyrw5m6SJvAbJd7E3oCUBD8gv+VuIH6TSdatb4H8A3JGJpPwb61REzyVBL91Rk3wNBL9fgfUL5AzMo3QBH+nZIK/z5hgbJK+VzDBq4ybYBf3KhITPCswg98qNPXTjZvgOXk6ZmYGSTH6AViMgLmWGcZNsNP1Dwq8eZikCVylxJvYG16S4AfktzwMxG8Wybq1Gsg/IGdkFgn/cnvaNMGzSfArD8QPaYIfJ9HvGqB+gZyRxwlN8BolE/xjxgRjk/Sjggn+ybgJdnH/RGKC5wZmcLVCU/+kcRP8fJ6OmXmKpBitBRYjYK7lKeMm2Ol6rQJvniFpAn9S4k1c/J4lwQ/Ib3kGiN88knVrHZB/QM7IPBL+1TVqgl8kwa+eURP8Eol+fwbqF8gZeYnQBP+sZIJ/yZhgbJJ+UTDB642bYBf3ehITPD8wg+sUmvoFxk3wojwdM7OQpBhtABYjYK5loXET7HS9QYE3i0iawPVKvImL32IS/ID8lkVA/F4jWbd+BfIPyBl5jYR/DY2a4DdJ8NvbqAl+i0S/vwH1C+SMvEVogn9TMsG/Z0wwNkm/K5jgjcZNsIt7I4kJXhKYwV8Vmvqlxk3w0jwdM/MuSTH6A1iMgLmWd42bYKfrPxR4s4ykCdyoxJvYW2KR4AfktywD4vchybr1J5B/QM7IhyT8a23UBC8nwa+NURP8KYl+/wLqF8gZ+ZTQBP+lZIITzTY/zJjgmGO6JDlA0eNmNbNtgl3cWc3gOVKZ67LADP6p0NSvMG6Cl+fpmJkvSIpRdjMclsBcyxfGTbDTdXYz/LhfkzSBWUq8if0Hy0jwA/Jbvgbit5Jk3SoH5B+QM7KShH/djJrgVST4dTdqgn8g0W8OUL9AzsgPhCYYiOUWJjg3Y4KxScpVMMHljZtgF3d5EhO8IjCD5RSa+h+Nm+CVeTpm5ieSYlQBWIyAuZafjJtgp+sKCrz5meUPwyjxJi5+v7B8pxqolZ+B+K0nWbcqAvkH5IysJ+HfiUZN8O8k+PUzaoI3kui3ElC/QM7IRkITXEnJBFfOmGBskiormOAqxk2wi7sKiQleFZjBigpN/V/GTfDaPB0zk7iCoxhVBRYjYK4FjR86v07XVRV4U66UeJMf79hi7c2Pd2zBm9ifMJDgB+S3+JyJi18uybpVDcg/IGckl4R/pxs1wZVI8Bth1ARXJtFvdaB+gZwRJH6lZYKrK5ngGhkTjE1SDQUTXNO4CXZx1yQxwesDM1hNoamvdoXtuP/I0zEz1UmKUS1gMQLmWqobN8FO17UUeFOLpAmsqcSbuPjVJsEPyG+pBcSvDsm6VRvIPyBnpA4J/8YaNcF1SfAbZ9QE1yPRbx2gfoGckXqEJriOkgnOy5hgbJLyFExw0rgJdnEnSUxwVjKRqK3Q1Nc3boIrJHXMzPYkxWgbYDEC5lq2N26Cna63UeDNTiRNYFKJN3Hx25kEPyC/ZScgfruQrFt1gfwDckZ2IeHfDUZNcAMS/G40aoL3INFvPaB+gZyRPQhNcD0lE7xtxgRjk7StggnezrgJdnFvR2KCqwRmsK5CU9/QuAmuldQxM3uTFKP6wGIEzLXsbdwEO13XV+DNfiRN4HZKvImLXyMS/ID8lv2A+DUmWbe2B/IPyBlpTMK/qUZNcAEJftOMmuCmJPrdAahfIGekKaEJ3kHJBO+YMcHYJO2oYIJ3Mm6CXdw7kZjgZGAGt1do6lsYN8H1kzpmpiVJMdoZWIyAuZaWxk2w0/XOCrxpTdIE7qTEm7j4tSHBD8hvaQ3Ery3JurULkH9AzkhbEv49adQEdyDB7ymjJrgjiX53BeoXyBnpSGiCd1UywbtlTDA2SbspmODdjZtgF/fuJCZ4p8AM7qLQ1B9k3AQ3SOqYmYNJilEDYDEC5loONm6Cna4bKPDmUJImcHcl3sTFrwsJfkB+y6FA/LqSrFt7APkH5Ix0JeHfIqMm+HAS/BYbNcE9SPS7J1C/QM5ID0ITvKeSCd4rY4KxSdpLwQQ3NG6CXdwNSUxww8AM7qHQ1PcyboIbJ3XMzJEkxWhvYDEC5lqONG6Cna73VuBNb5ImsKESb+LidwwJfkB+S28gfseSrFv7APkH5IwcS8K/j42a4ONJ8PvEqAk+gUS/+wL1C+SMnEBogvdVMsH7ZUwwNkn7KZjgRsZNsIu7EYkJLgjM4D4KTX1/4ya4VVLHzAwgKUaNgcUImGsZYNwEO103VuBNIUkT2EiJN3HxKyLBD8hvKQTiN5hk3coH8g/IGRlMwr/VRk3wUBL81hg1wcNI9CtA/QI5I8MITbAomeAmGROMTVITBRNcYNwEu7gLSExw28AM5is09cONm+BOSR0zcxpJMWoKLEbAXMtpxk2w03VTBd6cQdIEFijxJi5+I0nwA/JbzgDiN4pk3WoG5B+QMzKKhH9ZR9g0waNJ8MsG4oc0weeQ6Lc5UL9Azsg5hCa4uZIJbpExwdgktVAwwS2Nm2AXd0sSE9w5MIPNFJr6842b4G5JHTNzAUkxagUsRsBcywXGTbDTdSsF3lzI8oedlHgTF7+LSPAD8lsuBOI3lmTd2h/IPyBnZCwJ/+oYNcGXkuCXZ9QEX0ai39ZA/QI5I5cRmuDWSia4TcYEY5PURsEEtzVugl3cbUlMcM/ADO6v0NRfadwE907qmJnxJMXoAGAxAuZaxhs3wU7XByjw5mqSJrCtEm/i4ncNCX5AfsvVQPyuJVm32gH5B+SMXEvCvwZGTfANJPjtYdQE30ii3/ZA/QI5IzcSmuD2Sia4Q8YEY5PUQcEEdzRugl3cHUlMcJ/ADLZTaOpvMW6C+yd1zMytJMWoE7AYAXMttxo3wU7XnRR4M4mkCeyoxJu4+N1Bgh+Q3zIJiN+dJOvWgUD+ATkjd5Lwr4VREzyZ5U4YoyZ4Col+DwLqF8gZmUJogg9SMsEHZ0wwNkkHK5jgzsZNsIu7M4kJLgzM4IEKTf1U4yZ4aFLHzEwjKUaHAIsRMNcyzbgJdro+RIE300mawM5KvImL3wwS/ID8lulA/B4kWbcOBfIPyBl5kIR/hxo1wbNI8Oti1AQ/QqLfLkD9AjkjjxCa4C5KJrhrxgRjk9RVwQQfZtwEu7gPIzHBwwMzeKhCUz/buAkeldQxM4+TFKNuwGIEzLU8btwEO113U+DNkyRN4GFKvImL31Mk+AH5LU8C8ZtLsm51B/IPyBmZS8K/PkZN8DwS/PoaNcHPkej3cKB+gZyR5whN8OFKJrhHxgRjk9RDwQT3NG6CXdw9SUzw6MAMdldo6l80boLHJHXMzEskxegIYDEC5lpeMm6Cna6PUODNApImsKcSb+Lit5AEPyC/ZQEQv1dI1q1eQP4BOSOvkPDvFKMm+DUS/E41aoJfJ9HvkUD9AjkjrxOa4COVTPBRGROMTdJRCib4aOMm2MV9NIkJHhuYwV4KTf2bxk3w5UkdM/MWSTHqDSxGwFzLW8ZNsNN1bwXeLCVpAo9W4k1c/N4lwQ/Ib1kKxO89knXrGCD/gJyR90j4N8aoCf6QBL9ioyb4IxL9HgvUL5Az8hGhCT5WyQQflzHB2CQdp2CC+xg3wS7uPiQmeEJgBo9RaOqXGzfBE5M6ZuZTkmLUF1iMgLmWT42bYKfrvgq8WcFyO6USb+Li9wUJfkB+ywogfl+SrFvHA/kH5Ix8ScK/a42a4JUk+F1n1AR/S6LfE4D6BXJGviU0wScomeATMyYYm6QTFUxwP+Mm2MXdj8QE3xSYweMVmvpVxk3wpKSOmfmBpBj1BxYjYK7lB+Mm2Om6vwJvfiRpAvsp8SYufj+R4Afkt/wIxG8tybo1AMg/IGdkLQn/Jhs1wetJ8Jti1ARvINHvQKB+gZyRDYQmeKCSCR6UMcHYJA1SMMGFxk2wi7uQxATfHZjBAQpN/e/GTfDUpI6Z2UhSjIqAxQiYa9lo3AQ7XRcp8OYvkiawUIk3sdfxKznwA/Jb/gLil3Ulx7o1GMg/IGcki4R/s42a4FwS/B43aoLLk+j3JKB+gZwRJH6lZYJPUjLBQzImGJukIQom+GTjJtjFfTKJCZ4emMHBCk19pSttxz0rqWNmKpMUo6HAYgTMtVRW5k1c3JyuhyrwphpJE3iyEm/i4ledBD8gv6UaEL8aJOvWMCD/gJyRGiT8W2DUBNchwW+hUROcR6LfU4D6BXJG8ghN8ClKJvjUjAnGJulUBRM83LgJdnEPJzHBswMzOEyhqa9r3ATPTeqYmXokxeg0YDEC5lrqGTfBTtenKfCmPkkTOFyJN3Hx254EPyC/pT4Qvx1I1q3TgfwDckZ2MF7v5gX17nSFdWsX43HPT+qs17uS6GUEUC/AXMuuxnnzRzDGCAXe/IGb4ybjWt7jzJ/hv7/Cn27yf4bPnRHEMjL4lxs8vjp7s6mNzkdjRefLhb/rno/GGBU8PjMc4xpvjOj8v5nPWcHrzw7HutYbKzqfbj5nefMZHTw+JxzjOm+M6HzqGFnhGKPDMZzBPzd4fF44xkRvjOh86hjZ4RjnhmO4WM8PHl8QjnG9N0Z0vrQuivyFGys/25vnmNDLFnue9qjwZ6XElhdIEiFeCWxs+QoXXPJdvip4cURHtncues+I0+4iTJUSXuvzvj1mfpLKmfbe4+i9/Llk/Y/n4uOV8M6VS8HK50z0nMtFd+/5nBJ+J3ptTgmv82PPVYjdf5/23v+j96rszSHHwFyyS5hLeexcNtXdSD+JxJYXR6N5RHOq4D1XEYyJG6NSCfOo6M0jVeflw/PAeTRxY1QpYR6VvZ/R+1fx5lEVO4+CSinzcMc/6beqN5dq2Lls4kh1772ieVXz/h89n+vNozp2Hpt0Uy0l/uj//vz+r3OtQDTXSv/juSrwqsiNWQM7ZpNKiS0xdcc/6aaGF19N7FwKnCYrJDbnNRo/FVu//9BY32t78fr5dIdbz2qFj/3XRY9zvOf9eh89386LyY1ZBzv/Tfn05+WOf8pn9P6ubkRr4uDCkb0KB44oHNm1cHSWN0btlLj8HjjXe+yvExr5SXrvVdt7L3e4/OSFj5Pecxr1d5sS5uHX3+j9o9dV8h7neefqpszX7xX9341qa/T6CmFsOdjYCvz3io5/4lCOF7vHoR6jBgwbMjCFQ9G45UoY1+97c1Ne52Pi91dZqRNsn4CAIMiLFhrz27Hm3xch0BdrGhi/SLVbzb8vMqDj3oPk4uaFwIubwFwLEr/Ui2oXhheexoQ/i70LYhcFj8eGF6Ju8C5ERef/zQW6ccHrLw7HutEbKzqf7gLdOG8+lwSPLw3HuMkbIzpfLrH14hpOYwue5Mc7pEtCh8/oeV7UzP46ewn2hp6ipk2a5rt1DBW3X0Qv8y5YRsX4/3VxKcs75zd17mC6sFnRiyOREm/18Pmo4T11+MghRaO7jxo2bEjRkMJB3YePLPRhTO0//KFSz/vX5sqn/L4PafRcme5b3PwuU7pRLB2mcWvu5f/95rv8lLGktD4YuVzpbtErMneLYpN0hcLdolcav1vUxX0lyd2ibsHSmGtpNYL5MRqNoi2P/BKm+1/HltQTmhggi6K/2I0PeTHB40fUfGQntq78/hUQt3h2LCHmLO9xdviacv/wmqw045T06VD1BE9Dt8VibpkQWWGixjfbnBj3f0eKDoktD/RH1MA4ZAKwaFzVDLboFEV4XuXhGbPD26or+8PLX4xxt8KhofFbu/8IeYoed2+jtyanFjSkfs44DIffPiS3dgP5LUDOiBZ+2WCdjAeuuVcDrwy7MTRq7tXGby/ViPuXYIzBTfFxNzb+Sc3TNRKJkxTizif5pOYaoB6BuZZ847xxejlZgTcFBHoZqhB3UxK9XAvUCzDX0pRAL6co8KYFgV5OVYi7JYlergPqBZhraUmgl9MUeNOaQC+nK8TdhkQvE4F6AeZa2hDo5QwF3rQj0MtIhbjbk+jleqBegLmW9gR6OVOBN50I9HKWQtwHkujlBqBegLmWAwn0MlqBN50J9HKOQtyHkOjlRqBegLmWQwj0cp4Cb7oS6OV8hbgPI9HLTUC9AHMthxHoZYwCbw4n0EuxQtw9SPRyM1AvwFxLDwK9XKTAm14EehmrEPeRJHq5BagXYK7lSAK9XKzAm94EerlEIe5jSPRyK1AvwFzLMQR6uUyBN30I9HK5Qtx9SfRyG1AvwFxLXwK9XKnAmxMJ9DJeIe5+JHq5HagXYK6lH4FerlLgzUACvVytEPcgEr1MAuoFmGsZRKCXaxV4M5hAL9cpxH0SiV7uAOoFmGs5iUAv1yvwZiiBXm5QiHsYiV7uBOoFmGtB4uf+bMnN2Zv/9KL7DoO7L9vda+run3P3BLn7HNxnt+7zKHeN3V03dNdCnL9zPaurw25tcXjlhOOlHqjYo/HgXK+J56T1v5ykslDepLBgDCdYKG9WiPs0koXyLuBCCcy1nEbQWNyqwJszCPRym0LcI0n0cjdQL8Bcy0gCvUxS4M1ZBHq5QyHus0n0cg9QL8Bcy9kEerlLgTfnEujlboW4zyPRy2SgXoC5lvMI9DJZgTdjCPQyRSHuYhK9TAHqBZhrKSbQy30KvBlLoJepCnGPI9HLvUC9AHMt4wj0cr8Cby4l0MsDCnFfRqKX+4B6AeZaLiPQywwF3lxJoJcHFeIeT6KXqUC9AHMt4wn08rACb64m0MtMhbivIdHLNKBegLmWawj08ogCbyYS6OVRhbivJ9HL/UC9AHMt1xPoZbYCb24i0MvjCnHfTKKXB4B6AeZabibQyxMKvLmNQC9PKsR9O4lepgP1Asy13E6gl7kKvLmTQC9PK8R9F4leZgD1Asy13EWgl2cVeDOZQC/zFOKeQqKXB4F6AeZaphDo5XkF3kwl0MsLCnFPI9HLQ0C9AHMt0wj08pICb6YT6GW+QtwzSPTyMFAvwFwLEj/3xadbsjd/8cl9h8Hdl+3uNXX3z7l7gtx9Du6zW/d5lLvG7q4bumshzt+5ntXVYbe2PBzuBonmYbqtyGPnt5R4mP/fj622TI8b80wgp5H45YQ8TD1Qc43GK4tfmAPmfMudcNGCnNUMSyjFb2CqJWtWM/tzfESLUOgK/mgZ2YosXaLj4vcYED9WQT5GIMjZLIJ8vIzsdZYu0XHxm4PDrwmrIOcQCPIJFkE+WUY2U0uX6Lj4PYXDr4BVkE8RCHIuiyCfLiO7taVLdFz8nsHh15RVkM8QCPJZFkHOKyPbwaVLdFz8nsPh14xVkM8RCPJ5FkG+UEb2m0uX6Lj4vYjDrzmrIF8kEORLLIKcX0Y2tEuX6Lj4vYzDrwWrIF8mEOQCFkEuLCM75qVLdFz8XsHh15JVkK8QCPJVFkEuKiNb8qVLdFz8FuPwa8UqyMUEgnyNRZCvl5E9/9IlOi5+S3D49WcV5BICQb7BIsg3y8imgukSHRe/t3D4DWAV5FsEgnybRZDvlJFdC9MlOi5+S3H4DWQV5FICQb7LIsj3ysi2iOkSHRe/93H4DWIV5PsEglzGIsgPysi+i+kSHRe/D3H4FbIK8kMCQX7EIsiPy8jGjukSHRe/T3D4FbEK8hMCQS5nEeSnZWDnSB8/tCA/A38f8hZCQX5GIMjPWQS5oozsUJgu0XHx+wL8fUhGQX5BIMgvWQT5VRnZAjFdouPi9zX4+5CMgvyaQJDfsAhyZRnZYzFdouPi9y34+5CMgvyWQJDfsQjy+zKyiWO6RMfFbxX4+5CMglxFIMgfWAS5uozsEpku0XHxWwP+PiSjINcQCPJHFkH+VEa2oUyX6Lj4rQV/H5JRkGsJBLmORZA/l5F9LtMlOi5+v4C/D8koyF8IBLmeRZAbyshGmukSHRe/X8Hfh2QU5K8EgvyNRZC/l5GdOtMlOi5+G8Hfh2QU5EYCQf7BIsg/gYK0vBVoukTHxe8v8PchGQX5F4EgE81JBJmFm6jpvUbTJTouftk4/AawCjK7uf05lmMRZA5QkJY3M02X6Lj45eLwG8gqyFwCQZZnEWQFoCAt75aaLtFx8auIw28QqyArEgiyEosgKwMFaXk71nSJjotfFRx+hayCrEIgyKosgqwGFKTl/V7TJTouftVx+BWxCrI6gSBrsAiyJlCQVjeU1Uiw24D5ZYWNiGcRbMC8QCHuR+xvfOsO+RM4lp/r2NtKkmxgXQu43gA5Iyz41W6uw7/8eIc8orxuxf7wIhgjJ0th90Pj67WLubxC3E8o6SUbHD8wP4KM2eWjvLc+5AYnXG0pH/6sEP50R51A83nBv9zg8a3ZmzGKzkdjRecrh7/rno/GSAaPtwnHuM0bIzr/b+ZTN3h9vXCs272xovPp5lPXm8+2wePtwjEmeWNE51PHqBiOsW04hjMv9YPH24dj3OGNEZ1PHaNSOEb9cAwX6w7B4x3DMe70xojOuwOtnWdr/o07ety5xtfgF2v+jSt63KdJesfJPXBjzQX2js+Q4HcfEL+ngfg9S9I77gTsHYGcESR+DrOsxNYHuq8CYpnvz3fn5psf54Q/s0vgRHmFmBIp75OKY/USzkHfXCNJOzfHj7tLc5woteLepTk8R6qL+8NGi+OLJMVxptHi+BJJcdwVWByBnJGXCIvjrkrFcbdMccQmaTeF4ri78eLo4t5dqTii5zo+7+9CjnbMDZqXzbgXGL9C4njZQCHuhSRNzO7AIrwA2MS8QtLE7AHED8gZeYWEf88YNSGvkeD3rFET8jqJfvcE6hfIGXmd0ITsqWRC9sqYEGyS9lIwIQ2NmxAXd0MSEzIxaMb3UGhK3zR+68QteTrN+FskxWhvYDEC5lreMm7inK73VuDNUpImsKESb+Li9y4JfkB+y1Igfu+RrFv7APkH5Iy8R8K/JUZN8Ick+L1h1AR/RKLffYH6BXJGPiI0wfsqmeD9MiYYm6T9FExwI+Mm2MXdiMQETwrM4D4KTf1y4yZ4cp6OmfmUpBg1BhYjYK7lU+Mm2Om6sQJvVpA0gY2UeBN7u0AS/ID8lhVA/L4kWbfygfwDcka+JOHfZ0ZN8EoS/D43aoK/JdGvAPUL5Ix8S2iCRckEN8mYYGySmiiY4ALjJtjFXUBigqcGZjBfoalfZdwEP5inY2Z+IClGTYHFCJhr+cG4CXa6bqrAmx9JmsACJd7E3p6OBD8gv+VHIH5rSdatZkD+ATkja0n4t9aoCV5Pgt86oyZ4A4l+mwP1C+SMbCA0wc2VTHCLjAnGJqmFggluadwEu7hbkpjgWYEZbKbQ1P9u3ATPydMxMxtJilErYDEC5lo2GjfBTtetFHjzF0kT2FKJN7HX8fEc+AH5LX8B8csaz7Fu7Q/kH5AzkkXCv9yeNk1wLgl+5YH4IU1weRL9tgbqF8gZQeJXWia4tZIJbpMxwdgktVEwwW2Nm2AXd1sSEzw3MIP7KzT1lcbbjvv5PB0zU5mkGB0ALEbAXEtlZd7Exc3p+gAF3lQjaQLbKvEm9n5aJPgB+S3VgPjVIFm32gH5B+SM1CDhX12jJrgOCX71jJrgPBL9tgfqF8gZySM0we2VTHCHjAnGJqmDggnuaNwEu7g7kpjg+YEZbKfQ1Nc1boIX5emYmXokxagTsBgBcy31jJtgp+tOCrypT9IEdlTiTVz8tmdpooFaqQ/EbweSdetAIP+AnJEdSPjX0KgJ3oUEv72NmuBdSfR7EFC/QM7IroQm+CAlE3xwxgRjk3SwggnubNwEu7g7k5jgJYEZPFBjixrjJnhpno6Z2YOkGB0CLEbAXMsexk2w0/UhCrxpSNIEdlbiTey/dk6CH5Df0hCI3z4k69ahQP4BOSP7kPCvtVET3JgEvzZGTXA+iX67APUL5IzkE5rgLkomuGvGBGOT1FXBBB9m3AS7uA8jMcHLAjN4qEJTX2DcBC/P0zEzTUmKUTdgMQLmWpoaN8FO190UeNOCpAk8TIk3sb+rTYIfkN/SAohfK5J1qzuQf0DOSCsS/nUzaoLbkuDX3agJPoBEv4cD9QvkjBxAaIIPVzLBPTImGJukHgomuKdxE+zi7kliglcEZrC7QlPfwbgJXpmnY2Y6khSjI4DFCJhr6WjcBDtdH6HAm4NImsCeSryJi9/BLLeTA7VyEBC/ziTrVi8g/4Cckc4k/DvRqAnuSoJfP6Mm+DAS/R4J1C+QM3IYoQk+UskEH5UxwdgkHaVggo82boJd3EeTmOBVgRnspdDUH27cBK/N0zEzPUiKUW9gMQLmWnoYN8FO170VeNOLpAk8Wok3sZsrEvyA/JZeQPyOIlm3jgHyD8gZOYqEf6cbNcHHkuA3wqgJPo5Ev8cC9QvkjBxHaIKPVTLBx2VMMDZJxymY4D7GTbCLuw+JCV4fmMFjFJr6442b4D/ydMzMCSTFqC+wGAFzLScYN8FO130VeNOfpAnso8SbuPgNIMEPyG/pD8RvIMm6dTyQf0DOyEAS/o01aoIHk+A3zqgJPolEvycA9QvkjJxEaIJPUDLBJ2ZMMDZJJyqY4H7GTbCLux+JCc5KJhLHKzT1Q42b4ApJHTMzjKQY9QcWI2CuZZhxE+x03V+BN8NZbgdU4k1c/E4jwQ/IbxkOxO90knVrAJB/QM7I6ST8u8GoCR5Fgt+NRk3wmST6HQjUL5AzciahCR6oZIIHZUwwNkmDFExwoXET7OIuJDHBVQIzOEChqR9t3ATXSuqYmXNIilERsBgBcy3nGDfBTtdFCrw5n6QJLFTiTVz8LiDBD8hvOR+I3xiSdWswkH9AzsgYEv5NNWqCx5LgN82oCR5Hot+TgPoFckbGEZrgk5RM8JCMCcYmaYiCCT7ZuAl2cZ9MYoKTgRkcrNDUX2rcBNdP6piZy0iK0VBgMQLmWi4zboKdrocq8OZKkibwZCXexMVvPAl+QH7LlUD8JpCsW8OA/ANyRiaQ8O9Joyb4WhL8njJqgq8j0e8pQP0COSPXEZrgU5RM8KkZE4xN0qkKJni4cRPs4h5OYoJ3CszgMIWm/gbjJrhBUsfM3EhSjE4DFiNgruVG4ybY6fo0Bd7cQtIEDlfiTVz8bmW5nRKolVuA+N1Gsm6dDuQfkDNyGwn/Fhk1wXeS4LfYqAm+i0S/I4D6BXJG7iI0wSOUTPAZGROMTdIZCiZ4pHET7OIeSWKCGwZm8HSFpn6ycRPcOKljZqaQFKNRwGIEzLVMMW6Cna5HKfBmKkkTOFKJN3Hxm0aCH5DfMhWI3/0k69aZQP4BOSP3k/DvY6Mm+EES/D4xaoIfItHvWUD9AjkjDxGa4LOUTPDZGROMTdLZCiZ4tHET7OIeTWKCCwIzeKZCUz/LuAluldQxM4+QFKNzgMUImGt5xLgJdro+R4E3s0mawNFKvImL3+Mk+AH5LbOB+M0hWbfOBfIPyBmZQ8K/1UZN8FwS/NYYNcFPk+j3PKB+gZyRpwlN8HlKJvj8jAnGJul8BRN8gXET7OK+gMQEtw3M4LkKTf084ya4U1LHzDxHUozGAIsRMNfynHET7HQ9RoE3L5I0gRco8SYufi+R4Afkt7wIxG8+ybpVDOQfkDMyn4R/WUfYNMGvkOCXDcQPaYJfJdHvhUD9AjkjrxKa4AuVTPBFGROMTdJFCiZ4rHET7OIeS2KCOwdmsFihqX/NuAnultQxM6+TFKNxwGIEzLW8btwEO12PU+DNmyz7jCrxJi5+b5HgB+S3vAnE722SdetiIP+AnJG3SfhXx6gJfo8EvzyjJvh9Ev1eAtQvkDPyPqEJvkTJBF+aMcHYJF2qYIIvM26CXdyXkZjgnoEZvFihqf/QuAnundQxMx+RFKPLgcUImGv5yLgJdrq+XIE3y1n+urESb+Li9ykJfkB+y3Igfp+RrFtXAPkH5Ix8RsK/BkZN8Jck+O1h1AR/RaLfK4H6BXJGviI0wVcqmeDxGROMTdJ4BRM8wbgJdnFPIDHBfQIzeIVCU7/SuAnun9QxM9+SFKOrgMUImGv51rgJdrq+SoE3q0iawAlKvImL3w8k+AH5LauA+K0mWbeuBvIPyBlZTcK/FkZN8FoS/FoaNcHrSPR7DVC/QM7IOkITfI2SCb42Y4KxSbpWwQRfZ9wEu7ivIzHBhYEZvFqhqV9v3AQPTeqYmQ0kxWgisBgBcy0bjJtgp+uJCrz5naQJvE6JN3Hx20iCH5Df8jsQvz9I1q3rgfwDckb+IOHfoUZNcNYEDvy6GDXB2RM49HsDUL9AzggSv9IywTcomeAbMyYYm6QbFUzwTcZNsIv7JhITPDwwg9crNPW5E2zHPSqpY2bKkxSjm4HFCJhrKa/Mm7i4OV3frMCbSiRN4E1KvImLX2US/ID8lkpA/KqQrFu3APkH5IxUIeFfH6MmuAYJfn2NmuCaJPq9FahfIGekJqEJvlXJBN+WMcHYJN2mYIJvN26CXdy3k5jg0YEZvEWhqa9j3ASPSeqYmTySYjQJWIyAuZY84ybY6XqSAm/qkjSBtyvxJi5+9UjwA/Jb6gLx25Zk3boDyD8gZ2RbEv6dYtQE70CC36lGTfCOJPq9E6hfIGdkR0ITfKeSCb4rY4KxSbpLwQTfbdwEu7jvJjHBYwMzeIdCU7+LcRN8eVLHzOxKUozuARYjYK5lV+Mm2On6HgXeNCBpAu9W4k1c/PYgwQ/Ib2kAxG9PknVrMpB/QM7IniT8G2PUBO9Dgl+xURO8L4l+pwD1C+SM7EtogqcomeB7MyYYm6R7FUzwfcZNsIv7PhITPCEwg5MVmvrGxk3wxKSOmcknKUZTgcUImGvJN26Cna6nKvCmgKQJvE+JN3Hxa0qCH5DfUgDErxnJujUNyD8gZ6QZCf+uNWqCW5Hgd51RE7w/iX7vB+oXyBnZn9AE369kgh/ImGBskh5QMMHTjZtgF/d0EhN8U2AGpyk09W2Nm+BJSR0zcwBJMZoBLEbAXMsBxk2w0/UMBd50IGkCpyvxJi5+HUnwA/JbOgDx60Sybj0I5B+QM9KJhH+TjZrgziT4TTFqgg8h0e9DQP0COSOHEJrgh5RM8MMZE4xN0sMKJnimcRPs4p5JYoLvDszggwpNfVfjJnhqUsfMHEZSjGYBixEw13KYcRPsdD1LgTeHkzSBM5V4Exe/HiT4AfkthwPx60mybj0C5B+QM9KThH+zjZrgo0jwe9yoCT6aRL+PAvUL5IwcTWiCH1UywY9lTDA2SY8pmODZxk2wi3s2iQmeHpjBRxSa+mONm+BZSR0zcxxJMXocWIyAuZbjjJtgp+vHFXhzPEsTrcSbuPidQIIfkN9yPBC/E0nWrTlA/gE5IyeS8G+BURM8kAS/hUZN8CAS/T4B1C+QMzKI0AQ/oWSCn8yYYGySnlQwwU8ZN8Eu7qdITPDswAzOUWjqBxs3wXOTOmbmJJJiNBdYjIC5lpOMm2Cn67kKvBlK0gQ+pcSbuPgNI8EPyG8ZCsTvFJJ162kg/4CckVOM17t5Qb17WmHdOt143POTOuv1CBK9PAPUCzDXMsI4b3KCAZ9R4I0bFxW3m1t5jzO5wYk/3bnwZ4XwpzueDWKZF/zLDR7flb3Z1Ebno7Gi85XD33XPR2M8Fzx+Phzjbm+M6Py/mc8LwetfDMe6xxsrOp9uPi9483kpeDw/HGOyN0Z0PnWMiuEYL4VjOIP/cvB4QTjGFG+M6HzqGJXCMV4Ox3CxLgwevxKOca83RnS+tC6KlAdyK9ub56uhl13kedqjIjwSW14gSYR4JbCx5StccMl3+argxREd2d656D0jTruLMFVKeK3P+/aY+UkqZ9p7j6P38ueS9T+ei49XwjtXLgUrnzP//1oR/OvuPZ9Twu9Er80p4XV+7LkKsfvv0977f/Relb055BiYS3YJcymPncumuhvpJ5HY8uJoNI9oThW85yqCMXFjVCphHhW9eaTqvHx4HjiPJm6MKiXMo7L3M3r/Kt48qmLnUVApZR7u+Cf9VvXmUg07l00cqe69VzSvat7/o+dzvXlUx85jk26qpcQf/d+f3/91rhWI5lrpfzxXBV4VuTFrYMdsUimxJabu+Cfd1PDiq4mdS4HTZIXE5rxG46di6/cfGut7bS9eP5/ucOtZrfCx/7rocY73vF/vo+fbeTG5Metg578pn/683PFP+Yze39WNaE0cXDiyV+HAEYUjuxaOzvLGqJ0Sl98D53qP/XVCIz9J771qe+/lDpefvPBx0ntOo/5uU8I8/PobvX/0ukre4zzvXN2U+fq9ov+7UW2NXl8hjC0HG1uB/17R8U8cyvFi9zjUY9SAYUMGpnAoGrdcCeP6fW9uyut8TPz+Kit1gu0TEBAEedFCY37P1vz7IgT6Ys0o4xepXqz590UGdNxnklzcXAy8uAnMtSDxS72otji88PRq+HORd0HsteDx6+GFqPu8C1HR+X9zgW5J8Po3wrGmemNF59NdoFvizefN4PFb4RjTvDGi8+USWy+u7kDrpEtCh8/oeb7W3P46+yb2hp6ipk2a5rt1DBW3X0Tf9i5YRsX4/3VxKcs75zd17mC6sFnRiyOREm/18Pmo4T11+MghRaO7jxo2bEjRkMJB3YePLPRhTO0//KFSz/vX5sqn/L4PafRcme5b3PzeVrpRLB2mcWvuO//95rv8lLGktD4YeUfpbtGlmbtFsUlaqnC36LvG7xZ1cb9LcreoW7A05lpajeAbMRqNoi2P/BKm+1/HltQTmhggi6K/2L0X8uJ9jx9R85Gd2Lry+1dA3OLZsYSYs7zH2eFryv3Da7LSjFPSp0PVEzwN3RaLuWVCZIWJeq/55sS4/ztSdEhseaA/ogbGIe8Di8ay5rBFpyjCc5mHZ8wOb6uuzOH4nsJVpdHGb+12cb+vEPc5Rm9NTi1oSP1U64bD71ySW7uB/BYgZ0QLv2ywTt4DrrkfAK8MuzE0au4Hxm8v1Yj7j2CMR5rh4x5j/JOavoHxeFQh7mKST2o+BOoRmGspNs4bp5fZCrwZS6CXxxXiHkeil4+AegHmWsYR6OUJBd5cSqCXJxXivoxELx8D9QLMtVxGoJe5Cry5kkAvTyvEPZ5EL58A9QLMtYwn0MuzCry5mkAv8xTivoZEL8uBegHmWq4h0MvzCryZSKCXFxTivp5EL58C9QLMtVxPoJeXFHhzE4Fe5ivEfTOJXj4D6gWYa7mZQC8LFHhzG4FeFirEfTuJXj4H6gWYa7mdQC+vKvDmTgK9LFKI+y4SvawA6gWYa7mLQC+vKfBmMoFeXleIewqJXr4A6gWYa5lCoJc3FHgzlUAvbyrEPY1EL18C9QLMtUwj0MvbCryZTqCXdxTinkGil6+AegHmWmYQ6OVdBd48TKCX9xTinkmil6+BegHmWmYS6GWZAm8eJdDLBwpxP0ail2+AegHmWh4j0MtHCryZQ6CXjxXifoJELyuBegHmWp4g0MtyBd7MJdDLpwpxP02il2+BegHmWpD4uT9bcn/25j+96L7D4O7Ldveauvvn3D1B7j4H99mt+zzKXWN31w3dtRDn71zP6uqwW1scXjnheKkHKvZoPDjXa+E5af0vJ6kslJ8rLBjzCBbKFQpxP0eyUH4HXCiBuZbnCBqLLxV48yKBXr5SiPslEr18D9QLMNfyEoFevlHgzQICvaxUiHshiV5WAfUCzLUsJNDLdwq8WUSgl+8V4l5MopcfgHoB5loWE+jlBwXeLCHQy2qFuN8g0ctqoF6AuZY3CPTyowJv3ibQy08Kcb9Dopc1QL0Acy3vEOhlnQJv3iPQy88Kcb9PopcfgXoB5lreJ9DLegXefEiglw0KcX9EopefgHoB5lo+ItDLbwq8WU6gl98V4v6URC9rgXoB5lo+JdDLHwq8WUGglz8V4v6CRC/rgHoB5lq+INBLQuEPun5NoJcshbi/IdHLz0C9AHMt3xDopZwCb74j0EuOQtzfk+jlF6BegLmW7wn0Ul6BN6sJ9FJBIe41JHpZD9QLMNeyhkAvlRR4s5ZAL5UV4l5HopcNQL0Acy3rCPRSVYE36wn0Uk0h7g0kevkVqBdgrmUDgV5qKPDmdwK91FSIeyOJXn4D6gWYa0Hi57749ED25i8+ue8wuPuy3b2m7v45d0+Qu8/BfXbrPo9y19jddUN3LcT5O9ezujrs1pbfwt0g0TxMtxV53Pz+VUo8zP/vx1Zbpsdec4CcRuKXE/Iw9UDNNRqvLH5hDpjzLXiOLwzNsYRS/AamWrI2Nrc/xz+0CIWu4H+Wka3I0iU6doUE4scqyL8IBJloQSLILNxETe91li7RcfHLxuHXhFWQ2S3sz7EciyBzgIK0vJlaukTHxS8Xh18BqyBzCQRZnkWQFYCCtLxbW7pEx8WvIg6/pqyCrEggyEosgqwMFKTl7eDSJTouflVw+DVjFWQVAkFWZRFkNaAgLe83ly7RcfGrjsOvOasgqxMIsgaLIGsCBWl5Q7t0iY6LXy0cfi1YBVmLQJC1WQRZByhIyzvmpUt0XPzycPi1ZBVkHoEgkyyC3AYoSMtb8qVLdFz86uLwa8UqyLoEgqzHIshtgYK0vOdfukTHxW87HH79WQW5HYEg67MIcnugIC1vKpgu0XHx2wGH3wBWQe5AIMgdWQS5E1CQlnctTJfouPjtjMNvIKsgdyYQ5C4sgtwVKEjL2yKmS3Rc/HbD4TeIVZC7EQhydxZBNgAK0vK+i+kSHRe/PXD4FbIKcg8CQe7JIsi9gIK0vLFjukTHxa8hDr8iVkE2JBDk3iyC3AcoSKs7R/r4oQW5LzDRyl+wVSP7vgSC3I9FkI2AgrS8Q2G6RMfFrzEQP1ZBNiYQZD6LIAVIKMtbIKZLdFz8moC/D8koyCYEgixgEWRToCAt77GYLtFx8WsG/j4koyCbEQiyOYsgWwAFaXkTx3SJjotfS/D3IRkF2ZJAkK1YBLk/UJCWd4n8/9r7Enibqvf9c687mMd7UBSFQqq7UOYpjUSGSkVlulcyxlVpomjWgJBKJUJJqBBCKlEUDRoNoaKR0lz03yt7/y2ne/Sr/by+7/M5Z38+dY59zl1nvc/7PGu9zzp7nxUv0WHxawS+H5JRkI0IBNmYRZBNgILUvA1lvESHxa8p+H5IRkE2JRBkMxZBNgcKUvM+l/ESHRa/FuD7IRkF2YJAkKewCLIlUJCaN9KMl+iw+J0Kvh+SUZCnEgjyNBZBng4UpOadOuMlOix+Z4Dvh2QU5BkEgjyTRZBnAQWpeSvQeIkOi18r8P2QjIJsRSDI1iyCPBsoSM17jcZLdFj82oDvh2QUZBsCQbZlEeQ5QEFq3sw0XqLD4tcOfD8koyDbEQiyPYsgOwAFqXm31HiJDotfR/D9kIyC7EggyHNZBHkeUJCat2ONl+iw+J0Pvh+SUZDnEwiyE4sgLwAKUvN+r/ESHRa/C8H3QzIK8kICQV7EIsjOQEFq3VBWIsF2A+ZSAhvAptytO267AXNpgbhT75YRDHDjW3uY9BRcW26uw+JX4BDhF7afXYDjDZAzhgW/i+vJ8C873GFShcet0OOq10aRFHy7mcrHaxtzMYG4CwrpJRUcPzA/BhmzzUeGMz4U9U7sjezLlX0s7j/a4xJP85d6/6V7z2em7scoOB+0FZwv5f+tfT1oo6v3vJvfxlNOG8H5f9Of7t77e/htzXLaCs7H6093pz89vec5fhtPO20E52PbKOG30dNvw5qXXO95L7+N2U4bwfnYNkr6beT6bdhYL/Oe9/bbmOO0EZy3B1o7l5Tahzt8WyvlY3CPUvtwRbdblKR2nNIOOK4Da8diJPhNA+JXFIhfcZLa8XJg7QjkjEHiZzFLifz9QNdVQCyz3f72qbf/eZr/mJoPJzIEYorEfE4sjsXzOQf9cIkk9amHb7dvPZwopeLuWw+eI9HBfbbSybEMyeQ4R+nkmEUyOfYDTo5Azpgswsmxn9Dk2D85OWKT1F9gchygfHK0cQ8QmhzRfR2VtW8iRzvmgfUSM+5yyldILC8HCsRdnqSIGQCchMsBi5jDSIqYK4D4ATljDiPh3xKlJuQIEvyWKjUhR5LodxBQv0DOmCMJTcggIRMyOGlCsEkaLGBC8pSbEBt3HokJGesV41cIFKVHKb90YmKWTDF+NMlkNAQ4GQFzbY5WbuKsrocI8KYaSRGYJ8Sb0Jt7keAH5LepBsTvWJJx60og/4CcMceS8G+tUhN8HAl+65Sa4Fok+r0KqF8gZ0wtQhN8lZAJvjppgrFJulrABA9VboJt3ENJTPAkzwxeKVDUn6jcBE/JkjEz2SST0TXAyQiYa5Ot3ARbXV8jwJs6JEXgUCHehN5MigQ/IL9NHSB+J5GMW9cC+QfkjDmJhH9blJrgBiT4bVVqghuS6Pc6oH6BnDENCU3wdUIm+PqkCcYm6XoBE3yDchNs476BxARP98zgtQJFfRPlJnhWloyZaUoyGQ0DTkbAXJumyk2w1fUwAd60ICkCbxDiTVj8TiHBD8hv0wKIX0uScWs4kH9AzpiWJPzbrdQEn0GC3w9KTfCZJPq9EahfIGfMmYQm+EYhE3xT0gRjk3STgAkeodwE27hHkJjguZ4ZHC5Q1LdWboIXZMmYmbNJJqORwMkImGtztnITbHU9UoA355AUgSOEeBN69xsS/ID8NucA8WtPMm7dDOQfkDOmPQn/0tvrNMHnkeCXAcQPaYLPJ9HvLUD9Ajljzic0wbcImeBbkyYYm6RbBUzwbcpNsI37NhITvNgzgzcLFPUXKjfBy7NkzMxFJJPR7cDJCJhrc5FyE2x1fbsAby4mKQJvE+JN6J9iJ8EPyG9zMRC/S0nGrTuA/ANyxlxKwr9ySk1wDxL8yis1wT1J9HsnUL9AzpiehCb4TiETPCppgrFJGiVggu9SboJt3HeRmOAVnhm8Q6Co76XcBK/OkjEzl5FMRncDJyNgrs1lyk2w1fXdArzpQ1IE3iXEm7D49SXBD8hv0weIXz+SceseIP+AnDH9SPhXQ6kJvoIEv5pKTfAgEv3eC9QvkDNmEKEJvlfIBI9OmmBskkYLmOAxyk2wjXsMiQle65nBewSK+iHKTfD6LBkzcyXJZDQWOBkBc22uVG6Cra7HCvBmKEkROEaIN6F/6I0EPyC/zVAgfteSjFv3AfkH5Iy5loR/jZSa4GEk+DVWaoKHk+h3HFC/QM6Y4YQmeJyQCR6fNMHYJI0XMMETlJtgG/cEEhP8oWcG7xMo6kcoN8Gbs2TMzEiSyeh+4GQEzLUZqdwEW13fL8CbW0mKwAlCvAl9mToJfkB+m1uB+N1OMm5NBPIPyBlzOwn/2ig1wXeR4NdWqQm+m0S/DwD1C+SMuZvQBD8gZIIfTJpgbJIeFDDBDyk3wTbuh0hM8DbPDE4UKOpHKzfBX2TJmJkxJJPRJOBkBMy1GaPcBFtdTxLgzTiSIvAhId6ExW88yzfpQK2MA+I3gWTcehjIPyBnzAQS/l2q1AQ/SIJfV6Um+CES/T4C1C+QM+YhQhP8iJAJfjRpgrFJelTABE9WboJt3JNJTPA3nhl8WKCof0S5Cd6dJWNmHiWZjB4DTkbAXJtHlZtgq+vHBHgzhaQInCzEm7D4TSXBD8hvMwWI3+Mk49YUIP+AnDGPk/DvCqUm+AkS/AYpNcFPkuh3KlC/QM6YJwlN8FQhE/x40gRjk/S4gAmeptwE27inkZjgnz0zOEWgqJ+l3ATvyZIxM0+TTEbTgZMRMNfmaeUm2Op6ugBv5pIUgdOEeBMWv2dI8APy28wF4vcsybg1A8g/IGfMsyT8G6HUBC9guZ1BqQl+nkS/TwD1C+SMeZ7QBD8hZIKfTJpgbJKeFDDBM5WbYBv3TBITnBKNRGYIFPWLlZvgzKiMmXmBZDJ6CjgZAXNtXlBugq2unxLgzTKSInCmEG/C4vciCX5AfptlQPyWk4xbs4D8A3LGLCfh3zilJngFCX7jlZrgV0n0+zRQv0DOmFcJTfDTQiZ4dtIEY5M0W8AEz1Fugm3cc0hMcBHPDM4SKOpfU26CS0VlzMzrJJPRXOBkBMy1eV25Cba6nivAmzdIisA5QrwJi9+bJPgB+W3eAOK3lmTcegbIPyBnzFoS/k1XaoLfIcFvhlIT/C6Jfp8F6hfIGfMuoQl+VsgEP5c0wdgkPSdggucpN8E27nkkJjjqmcFnBIr695Wb4ApRGTPzAclkNB84GQFzbT5QboKtrucL8OZjkiJwnhBvwuK3gQQ/IL/Nx0D8NpKMWwuA/ANyxmwk4d9CpSZ4Cwl+i5Sa4K0k+n0eqF8gZ8xWQhP8vJAJXpg0wdgkLRQwwYuUm2Ab9yISE1zJM4MLBIr6z5Sb4GpRGTPzOclktBg4GQFzbT5XboKtrhcL8OYLliJQiDdh8fuSBD8gv80XQPy+Ihm3XgDyD8gZ8xUJ/1YrNcE7SfBbo9QE7yLR7xKgfoGcMbsITfASIRO8NGmCsUlaKmCClyk3wTbuZSQmuIZnBl8QKOp3KzfBJ0ZlzMwPJJPRi8DJCJhr84NyE2x1/aIAb34mKQKXCfEmLH6/kOAH5Lf5GYjfryTj1nIg/4CcMb+S8G+jUhO8hwS/TUpN8F4S/b4E1C+QM2YvoQl+ScgEv5w0wdgkvSxggl9RboJt3K+QmOA6nhlcLlDUp9yjO+4GURkzk3oPx2S0AjgZAXNtUoV5ExY3q+sVArxJP0S8yQ53HDD2Zoc7DuBNWPwySPAD8tukA/HLJBm3XgXyD8gZk0nCv51KTXAREvx2KTXBRUn0uxKoXyBnDBK/Q2WCVwqZ4FVJE4xN0ioBE/yachNs436NxAQ38czgqwJFfQnlJrhlVMbMlCSZjF4HTkbAXJuSyk2w1fXrArwpQ1IEvibEm7D4ZZHgB+S3KQPEL0oybq0G8g/IGRMl4V9KB50m+DCWRSwgfkgTfDiJftcA9QvkjDmc0ASvETLBbyRNMDZJbwiY4DeVm2Ab95skJvgMzwyuFijqj1BugttEZczMkSST0VrgZATMtTlSuQm2ul4rwJujSIrAN4V4Exa/o0nwA/LbHAXErwrJuLUOyD8gZ0wVEv6VUWqCjyXBL0upCa5Oot+3gPoFcsZUJzTBbwmZ4LeTJhibpLcFTPA7yk2wjfsdEhPc3jOD6wSK+uOUm+BOURkzU4tkMnoXOBkBc21qKTfBVtfvCvDmRJIi8B0h3oTFL5sEPyC/zYlA/AzJuLUeyD8gZ4wh4V81pSb4JBL8jlFqgk8m0e97QP0COWNOJjTB7wmZ4PeTJhibpPcFTPAHyk2wjfsDEhPc2TOD6wWK+gbKTXC3qIyZaUgyGX0InIyAuTYNlZtgq+sPBXjThKQI/ECIN2Hxa0qCH5DfpgkQv2Yk49ZHQP4BOWOakfCvnlIT3JIEv/pKTfCpJPr9GKhfIGfMqYQm+GMhE7whaYKxSdogYII3KjfBNu6NJCY4xzODHwkU9WcoN8F9ojJm5kySyWgTcDIC5tqcqdwEW11vEuBNa5IicKMQb8LidzYJfkB+m9ZA/NqQjFubgfwDcsa0IeHfWUpNcHsS/FopNcEdSPT7CVC/QM6YDoQm+BMhE7wlaYKxSdoiYIK3KjfBNu6tJCZ4gGcGNwsU9ecpN8FDojJm5nySyWgbcDIC5tqcr9wEW11vE+DNhSRF4FYh3oTF7yIS/ID8NhcC8etMMm59CuQfkDOmMwn/Ois1wZeS4NdFqQnuSqLfz4D6BXLGdCU0wZ8JmeDPkyYYm6TPBUzwduUm2Ma9ncQED/XM4KcCRX0P5SZ4WFTGzPQkmYx2ACcjYK5NT+Um2Op6hwBvepEUgduFeBMWv8tI8APy2/QC4tebZNz6Asg/IGdMbxL+9VNqgvuR4NdfqQnuT6LfL4H6BXLG9Cc0wV8KmeCvkiYYm6SvBEzw18pNsI37axITPMIzg18IFPVXKDfBt0dlzMwgksnoG+BkBMy1GaTcBFtdfyPAmyEkReDXQrwJi9+VJPgB+W2GAPG7imTc+hbIPyBnzFUk/Bum1ARfS4LfcKUm+DoS/e4E6hfIGXMdoQneKWSCdyVNMDZJuwRM8HfKTbCN+zsSE3yXZwa/FSjqhyk3wWOjMmZmOMlk9D1wMgLm2gxXboKtrr8X4M0IkiLwOyHehMVvJEsRDdTKCCB+N5OMW7uB/ANyxtxMwr/RSk3w7ST4jVFqgu8g0e8PQP0COWPuIDTBPwiZ4B+TJhibpB8FTPBPyk2wjfsnEhM8wTODuwWK+ruUm+BJURkzczfJZPQzcDIC5trcrdwEW13/LMCb0SRF4E9CvAmL3xgS/ID8NqOB+I0lGbd+AfIPyBkzloR/U5Sa4Akk+E1VaoLvJ9Hvr0D9Ajlj7ic0wb8KmeDfkiYYm6TfBEzw78pNsI37dxITPNkzg78IFPUPKjfB06MyZuYhksnoD+BkBMy1eUi5Cba6/kOAN4+QFIG/C/EmLH6PkuAH5Ld5BIjfZJJxaw+Qf0DOmMkk/Jun1AQ/ToLffKUmeBqJfvcC9QvkjJlGaIL3CpngP5MmGJukPwVMcKS+bhNs47Z9BOdIpK8zPTO4R6Cof0K5CZ4blTEzT5JMRin1cVgCc22eVG6Cra4tduh2Z5EUgREh3oTF72kS/ID8NrOA+M0mGbdSgfwDcsbMJuHfSqUm+FkS/FYpNcHPkei3AFC/QM6Y5whNMBDLA0xwmuNdkiY4ZJs2SWn18e2mKzfBNu50EhM8zzODqQJF/QLlJnhxVMbMPE8yGWUAJyNgrs3zyk2w1XWGAG8WkxSB6UK8CYvfCyT4AfltFgPxW0IybmUC+QfkjFmifL5b5s13mQLj1nLlca+IyozXL5HopSBQL8Bcm5eU86aI12BBAd7YdlFx275lOJwp6p3Y6z0W8x+L+4/2KOTFUtj6Eu/53NT9pjY4H7QVnC/l/619PWijiPe8qN/GM04bwfl/059i3vuL+20967QVnI/Xn2JOf0p4z0v6bTzntBGcj22jhN9GCb8Na/BLec9L+23Mc9oIzse2UdJvo5Tfho21jPc8y29jvtNGcP5QLYoUA3Ir1eln1PeyZR1Pe57/WChy4AJJxMcrgo0tW2DBJdvmK9OJIzhSnXPBZwactoswRfJ5r8v75pj+mVjONHeeB5/l9iXlf9wXF6+Ic65ADFYuZ4LXbC7aOq+n5fM3wXvT8nmfG3u6QOzu5zR3/h18VmGnD2kK+pKaT18ysH35a94N9BOJHLg4GvQj6FOm81pBMCa2jUL59KOg049YnWf454H9qG3bKJJPPwo7j8HnF3H6URTbjzqFYvphj4Ppt6jTl2LYvvzFkeLOZwX9Kub8O3g93elHcWw//tJNsZj4g3+7/fu/9jWTqK+F/sd9FeBVrm2zBLbN2oUiB2Jqj4PppoQTX0lsX+pYTWZG9uc1aD8WW7f+kBjfSzvxuvm0hx3PSvnP3fcFz9Oc1935Pni9mROTbbMMtv9/5dPtlz0Ols/g8+28EYyJvXLyOub0GJST1zpnaIrTRumYuNwaON157o4TEvmJOp9V2vkse9j8ZPnPo85rEvNv2Xz64c6/wecH7yvkPM9yzpWL6a9bK7p/G8ytwfsz/djSsLHVcT8rOA7GoTQndodD7YZ079u7RwyHgnYL5NOuW/emx7zPxcStr1JiO9g8AgHBIBctJPp3Sal9ixDoxZoVyhepepTat8iAjvtVksXNcsDFTWCuDRK/2EW1cv7CU9R/LOssiJX3nh/mL0QtcBaigvP/ZoHucO/9Ffy2nnfaCs7HW6A73OlPRe/5EX4bC502gvMFIn8fXO2B1kmriAyf0f0sX1//OFsRe0FPbt3adbPtOIaK251Ej3QWLIPJ+J8Wl1Kcc25RZw+mhc2CThyRmHiL+68HBW//AXm9c4e2HdK3b+/c3jk92w7Iy3FhjK0/3KZiz7trcxkxf+9CGryW0HWL7d+RQheKxcM07Jxb6b9ffJcd05Y5VF+MVBK6WrRy8mpRbJIqC1wtepTyq0Vt3EeRXC1qByyJvh6qQnBgiEIj98AjO5/u/te2TewJSQyQk6I72B3t86KKw4+g+EiN/H3md1dA7OB5Sj4xpzjPU/33FDjIe1LitJPft0PFIzwF3QGDuWZCpPiJOrr+/sTYf1tStIgceKC/ogbGYaoAJ42q9WGDTm6AZ1UHz5AV3t+qMovj0QKrSq8pv7Tbxl1FIO7XlV6aHDuhIfUzvQ0Ov9Ukl3YD+W2AnDFS+KWCdXI0cMytBlwZtm1IzLnVlF9eKhF3mtfgnpPxca9V/k3NH97393sF4l5H8k3NMUA9AnNt0PhJ6CUi8Fs97yiP2+olRSDud+/h0MuxQL0Ac23eJdBLAQHevE+glzSBuD8g0Ut1oF6AuTYfEOglQ4A3HxPoJVMg7g0keqkB1Asw12YDgV4KCfBmM4FeCgvE/QmJXmoC9QLMtfmEQC9FBXizjUAvxQTi/pREL8cB9QLMtfmUQC8lBHiznUAvJQXi3kGil1pAvQBzbXYQ6KW0AG++ItBLGYG4vybRy/FAvQBzbb4m0EtUgDc7CfRSViDuXSR6OQGoF2CuzS4CvZQX4M1uAr0cJhD3DyR6ORGoF2CuzQ8EeqkgwJufCfRSUSDuX0j0kg3UCzDX5hcCvRwpwJvfCfRSSSDuP0j0YoB6Aeba/EGgl6MEePMngV6OFog7ci+HXmoD9QLMtUHjJ6GXqgK8KaA8bquXagJxp5HopQ5QL8BcmzQCvRwrwJtMAr1UF4i7IIle6gL1Asy1KUigl5oCvClCoJfjBOIuSqKXk4B6AebaIPGzP1uyKHX/Ty/aexjsddn2WlN7/Zy9Jshe52C/u7XfR9k1drtuaNdCrL+zNaudh+3YYvFK89uLPVCxB+3BuV4Kz0l0H9G/nCQyUB4vMGCUIBgoTxCIuyTJQHkycKAE5tqUJCgssgV4U4ZAL0Yg7iwSvdQD6gWYa5NFoJc6ArwpR6CXugJxlyfRS32gXoC5NuUJ9HKyAG8qEOilnkDcFUn00gCoF2CuTUUCvTQQ4E0lAr00FIi7MoleGgL1Asy1qUygl8YCvKlCoJcmAnFXJdFLI6BegLk2VQn00kyAN8cS6KW5QNzVSfTSGKgXYK5NdQK9nCLAm+MI9NJSIO5aJHppAtQLMNemFoFeThPgzYkEejldIO5sEr00BeoFmGuTTaCXMwV4U4dAL2cJxF2XRC/NgHoB5trUJdBLawHe1CPQy9kCcdcn0UtzoF6AuTb1CfTSVoA3jQj0co5A3I1J9NICqBdgrk1jAr20F+BNMwK9dBCIuzmJXk4B6gWYa9OcQC/nCvCmJYFezhOI+1QSvbQE6gWYa3MqgV46CfDmDAK9XCAQ95kkejkVqBdgrs2ZBHq5SIA3rQn00lkg7rNJ9HIaUC/AXBskfvbGp8Wp+298svcw2Ouy7bWm9vo5e02Qvc7Bfndrv4+ya+x/rRvaTem8/2zNaudhO7ac5u8GieZhvK3Iw+b3nEPEw+z/fvxty/SwMZ8O5DQSvzSfh7EHqq9Be4l4wxww5wfwHF9A1scSSvAOTLFknVFffx/PlCIUegY/K0G2IouX6LD4tQLixyrIVgSCbM0iyLMTZK+zeIkOi18bHH61WQXZhkCQbVkEeU6CbKYWL9Fh8WuHw68OqyDbEQiyPYsgOyTIbm3xEh0Wv444/OqyCrIjgSDPZRHkeQmyHVy8RIfF73wcfiexCvJ8AkF2YhHkBQmy31y8RIfF70IcfiezCvJCAkFexCLIzgmyoV28RIfFrwsOv3qsguxCIMiLWQR5SYLsmBcv0WHxuxSHX31WQV5KIMiuLILsliBb8sVLdFj8uuPwa8AqyO4EguzBIsieCbLnX7xEh8UvB4dfN1ZB5hAIMpdFkL0SZFPBeIkOi99lOPy6swryMgJB9mYR5OUJsmthvESHxa8PDr8erILsQyDIviyC7Jcg2yLGS3RY/Prj8OvJKsj+BIIcwCLIgQmy72K8RIfF7wocfjmsgryCQJCDWAQ5OEE2doyX6LD45eHwy2UVZB6BIIewCPLKBNg50sUPLcirwPdDLiYU5FUEgryaRZBDE2SHwniJDovfNeD7IRkFeQ2BIK9lEeR1CbIFYrxEh8XvevD9kIyCvJ5AkDewCHJYguyxGC/RYfEbDr4fklGQwwkEeSOLIG9KkE0c4yU6LH4jwPdDMgpyBIEgR7II8uYE2SUyXqLD4ncL+H5IRkHeQiDIW1kEeVuCbEMZL9Fh8bsdfD8koyBvJxDkHSyCvDNB9rmMl+iw+I0C3w/JKMhRBIK8i0WQdyfIRprxEh0Wv3vA90MyCvIeAkHeyyLI0QmyU2e8RIfFbwz4fkhGQY4hEORYFkHeBxSk5q1A4yU6LH7jwPdDMgpyHIEgx7MIcgJQkJr3Go2X6LD43Q++H5JRkPcTCHIiiyAfAApS82am8RIdFr8HwfdDMgryQQJBPsQiyElAQWreLTVeosPi9zD4fkhGQT5MIMhHWAT5KFCQmrdjjZfosPhNBt8PySjIyQSCfIxFkFOAgtS832u8RIfFbyr4fkhGQU4lEOTjLIKcBhSk1g1lJRJsN2DuIrARcXvlcdsNmC8WiLuD0AAM3PjWHqZoCq4tN9eh95g5RPiF7ed04HgD5IxhwW9GfRn+ZYc7TAfhcSssbra90in4djspH69tzFkCcV8gpJdUcPzA/BhkzDYfGc74UMY7sTeyL1f2Meo/2uMJT/NPev+le89fSN2PUXA+aCs4X97/W/t60MZM7/lTfhtLnDaC8/+mP7O89z/tt7XUaSs4H68/s5z+zPaez/HbWOa0EZyPbaOs38Zsvw1rXuZ6z5/x23jRaSM4H9tGOb+NuX4bNtZnvefP+W0sd9oIztsDrZ29pfbhjm63s/IxuEDpfbjCNyshqR2ntMO11RlYO15Mgt80IH5dgPhdQlI7zgPWjkDOGCR+FrOUyN8PdF0FxDLb7e/8+vufp/mPqflwIkMgpkjM58TiWDyfc9APl0jS/Pr4dhfUx4lSKu4F9eE5Eh3cZyudHHuQTI5zlE6OPUkmx+eBkyOQM6Yn4eT4vNDkuDA5OWKTtFBgclykfHK0cS8Smhzht1xm7ZvI0Y55cf3EjLuX8hUSy8vFAnFfRlLELAJOwr2ARUxvkiLmBSB+QM6Y3iT8W6LUhPQjwW+pUhPSn0S/S4D6BXLG9Cc0IUuETMjSpAnBJskCim53WX3dJsTGbfsIzpFIX8d6xfgL9QU221F+6cTELJlifBDJZPRifRyWwFybQcpNnNX1iwK8GUJSBC4T4k3orV9I8APy2wwB4ncVybi1HMg/IGfMVST8W6vUBF9Lgt86pSb4OhL9vgTUL5Az5jpCEwzE8gAT/LLjXZImOGSbNkkvC5jgV5SbYBv3KyQmeJJnBpcLFPXDlJvgKVkyZmY4yWS0AjgZAXNthis3wVbXKwR4M4KkCHxFiDdh8RtJgh+Q32YEEL+bScatV4H8A3LG3EzCvy1KTfDtJPhtVWqC7yDR70qgfoGcMXcQmuCVQiZ4VdIEY5O0SsAEv6bcBNu4XyMxwdM9M/iqQFF/l3ITPCtLxszcTTIZvQ6cjIC5NncrN8FW168L8GY0SRH4mhBvQu9VQYIfkN9mNBC/sSTj1mog/4CcMWNJ+LdbqQmeQILfD0pN8P0k+l0D1C+QM+Z+QhO8RsgEv5E0wdgkvSFggt9UboJt3G+SmOC5nhlcLVDUP6jcBC/IkjEzD5FMRmuBkxEw1+Yh5SbY6nqtAG8eISkC3xTiTei9EUjwA/LbPALEbzLJuLUOyD8gZ8xkEv6lt9dpgh8nwS8DiB/SBE8j0e9bQP0COWOmEZrgt4RM8NtJE4xN0tsCJvgd5SbYxv0OiQle7JnBdQJF/RPKTfDyLBkz8yTJZPQucDIC5to8qdwEW12/K8CbWSRF4DtCvAmL39Mk+AH5bWYB8ZtNMm6tB/IPyBkzm4R/5ZSa4GdJ8Cuv1AQ/R6Lf94D6BXLGPEdogt8TMsHvJ00wNknvC5jgD5SbYBv3ByQmeIVnBtcLFPULlJvg1VkyZuZ5ksnoQ+BkBMy1eV65Cba6/lCAN4tJisAPhHgT+leDSfAD8tssBuK3hGTc+gjIPyBnzBIS/tVQaoKXk+BXU6kJfolEvx8D9QvkjHmJ0AR/LGSCNyRNMDZJGwRM8EblJtjGvZHEBK/1zOBHAkX9CuUmeH2WjJl5lWQy2gScjIC5Nq8qN8FW15sEePMaSRG4UYg3oe9xJ8EPyG/zGhC/1STj1mYg/4CcMatJ+NdIqQleS4JfY6UmeB2Jfj8B6hfIGbOO0AR/ImSCtyRNMDZJWwRM8FblJtjGvZXEBH/omcHNAkX9O8pN8OYsGTPzLslktA04GQFzbd5VboKtrrcJ8OZ9kiJwqxBvQn9DT4IfkN/mfSB+H5KMW58C+QfkjPmQhH9tlJrgjST4tVVqgjeR6PczoH6BnDGbCE3wZ0Im+POkCcYm6XMBE7xduQm2cW8nMcHbPDP4qUBRv0W5Cf4iS8bMbCWZjHYAJyNgrs1W5SbY6nqHAG8+IykCtwvxJix+n7MsIgC18hkQv+0k49YXQP4BOWO2k/DvUqUm+CsS/LoqNcFfk+j3S6B+gZwxXxOa4C+FTPBXSROMTdJXAib4a+Um2Mb9NYkJ/sYzg18IFPU7lZvg3VkyZmYXyWT0DXAyAuba7FJugq2uvxHgzW6SIvBrId6Exe8HEvyA/Da7gfj9SDJufQvkH5Az5kcS/l2h1AT/SoLfIKUm+DcS/e4E6hfIGfMboQneKWSCdyVNMDZJuwRM8HfKTbCN+zsSE/yzZwa/FSjq9yg3wXuyZMzMXpLJ6HvgZATMtdmr3ARbXX8vwJuU0RxF4HdCvAmLXyoJfkB+G5czYfErMJpj3NoN5B+QM6YACf9GKDXBmST4jVRqgguS6PcHoH6BnDFI/A6VCf5ByAT/mDTB2CT9KGCCf1Jugm3cP5GY4JRoJLJboKgvMlp33JlRGTNTlGQy+hk4GQFzbYoK8yYsblbXPwvwpgRJEfiTEG/C4leSBD8gv00JIH6lSMatX4D8A3LGlCLh3zilJjhKgt94pSa4LIl+fwXqF8gZU5bQBP8qZIJ/S5pgbJJ+EzDBvys3wTbu30lMcBHPDP4iUNQfptwEl4rKmJnDSSajP4CTETDX5nDlJtjq+g8B3hxBUgT+LsSbsPgdSYIfkN/mCCB+lUjGrT1A/gE5YyqR8G+6UhNchQS/GUpNcFUS/e4F6hfIGVOV0ATvFTLBfyZNMDZJfwqY4EgD3SbYxm37CM6RSF+jnhncI1DUH6vcBFeIypiZ6iSTUUoDHJbAXJvqyk2w1bXFDt3ucSRFYESIN2Hxq0WCH5Df5jggfseTjFupQP4BOWOOJ+HfQqUm2JDgt0ipCa5Not8CQP0COWNqE5pgIJYHmOA0x7skTXDINm2S0hrg201XboJt3OkkJriSZwZTBYr6k5Sb4GpRGTNzMslklAGcjIC5NicrN8FW1xkCvGlAUgSmC/EmLH4NSfAD8ts0AOLXiGTcygTyD8gZ04iEf6uVmuBmJPitUWqCm5PotyBQv0DOmOaEJrigkAkulDTB2CQVEjDBhZWbYBt3YRITXMMzg5kCRX1L5Sb4xKiMmTmVZDIqApyMgLk2pyo3wVbXRQR4cwZJEVhYiDdh8TuTBD8gv80ZQPzOIhm3igL5B+SMOYuEfxuVmuA2JPhtUmqC25LotxhQv0DOmLaEJriYkAkunjTB2CQVFzDBJZSbYBt3CRITXMczg0UFivr2yk1wg6iMmelAMhmVBE5GwFybDspNsNV1SQHenEdSBJYQ4k1Y/M4nwQ/Ib3MeEL9OJONWKSD/gJwxnUj4t1OpCe5Mgt8upSa4C4l+SwP1C+SM6UJogksLmeAySROMTVIZAROcpdwE27izSExwE88MlhIo6i9VboJbRmXMTFeSySgKnIyAuTZdlZtgq+uoAG96kBSBWUK8CYtfTxL8gPw2PYD45ZCMW2WB/ANyxuSQ8C+lg04T3JsEv1QgfkgTfDmJfssB9QvkjLmc0ASXEzLB5ZMmGJuk8gIm+DDlJtjGfRiJCT7DM4NlBYr6fspNcJuojJnpTzIZHQ6cjIC5Nv2Vm2Cr68MFeHMFSRF4mBBvwuI3iAQ/IL/NFUD8BpOMWxWA/ANyxgwm4V8ZpSb4KpZFQKUm+GoS/VYE6hfIGXM1oQmuKGSCj0iaYGySjhAwwUcqN8E27iNJTHB7zwxWECjqr1VugjtFZczMdSSTUSXgZATMtblOuQm2uq4kwJthJEXgkUK8CYvfcBL8gPw2w4D43UgyblUG8g/IGXMjCf+qKTXBN5Pgd4xSE3wLiX6PAuoXyBlzC6EJPkrIBB+dNMHYJB0tYIKrKDfBNu4qJCa4s2cGKwsU9bcrN8HdojJm5g6SyagqcDIC5trcodwEW11XFeDNXSRFYBUh3oTF724S/ID8NncB8buHZNyqBuQfkDPmHhL+1VNqgseS4FdfqQm+j0S/xwD1C+SMuY/QBB8jZIKPTZpgbJKOFTDB1ZWbYBt3dRITnOOZwWoCRf0E5Sa4T1TGzNxPMhnVAE5GwFyb+5WbYKvrGgK8eZCkCKwuxJuw+D1Egh+Q3+ZBIH6TSMatmkD+ATljJpHw7yylJngyCX6tlJrgx0j0exxQv0DOmMcITfBxQia4VtIEY5NUS8AEH6/cBNu4jycxwQM8M1hToKh/XLkJHhKVMTPTSCajE4CTETDXZppyE2x1fYIAb54gKQKPF+JNWPyeJMEPyG/zBBC/mSTj1olA/gE5Y2aS8K+zUhM8mwS/LkpN8BwS/WYD9QvkjJlDaIKzhUywSZpgbJKMgAmurdwE27hrk5jgoZ4ZPFGgqH9WuQkeFpUxM8+RTEZ1gJMRMNfmOeUm2Oq6jgBvFpAUgbWFeBMWv+dJ8APy2ywA4reQZNyqC+QfkDNmIQn/+ik1wUtYfthOqQleSqLfk4D6BXLGLCU0wScJmeCTkyYYm6STBUxwPeUm2MZdj8QEj/DMYF2Bon65chN8e1TGzLxEMhnVB05GwFybl5SbYKvr+gK8WcFyT6EQb8Li9yoJfkB+mxVA/FaSjFsNgPwDcsasJOHfMKUmeDUJfsOVmuA1JPptCNQvkDNmDaEJbihkghslTTA2SY0ETHBj5SbYxt2YxATf5ZnBBgJF/VrlJnhsVMbMrCOZjJoAJyNgrs065SbY6rqJAG/eISkCGwvxJix+75LgB+S3eQeI33qScaspkH9Azpj1JPwbrdQEf0iC3xilJvgjEv02A+oXyBnzEaEJbiZkgpsnTTA4SQImuIVyE2zjbkFigid4ZrCpQFG/UbkJnhSVMTObSCajU4CTETDXZpNyE2x1fYoAb7aQFIEthHgTFr+tJPgB+W22APHbRjJutQTyD8gZs42Ef1OUmuDtJPhNVWqCd5Do91SgfoGcMTsITfCpQib4tKQJxibpNAETfLpyE2zjPp3EBE/2zGBLgaL+K+UmeHpUxsx8TTIZnQGcjIC5Nl8rN8FW12cI8GYnSRF4uhBvwuK3iwQ/IL/NTiB+35GMW2cC+QfkjPmOhH/zlJrgH0nwm6/UBP9Eot+zgPoFcsb8RGiCzxIywa2SJhibpFYCJri1chNs425NYoJnembwTIGi/lflJnhuVMbM/EYyGZ0NnIyAuTa/KTfBVtdnC/BmD0kR2FqIN2Hx20uCH5DfZg8Qvz9Jxq02QP4BOWP+JOHfSqUmuMAYDvxWKTXBaWM49NsWqF8gZwwSv0NlgtsKmeBzkiYYm6RzBExwO+Um2MbdjsQEz/PMYBuBoj5zjO64F0dlzExBksmoPXAyAubaFBTmTVjcrK7bC/CmCEkR2E6IN2HxK0qCH5DfpggQv2Ik41YHIP+AnDHFlM93y7z5roPAuFVKedwrojLjdWkSvXQE6gWYa1NaOW9Kew12lOBNCta4ZjicKeOd2Os9ZvmPUf/RHud6sZzn/ZfuPX8pdb+pDc4HbQXny/t/a18P2jjfe97Jb+Nlp43g/L/pzwXe+y/023rFaSs4H68/Fzj9uch73tlvY4XTRnA+to2yfhsX+W1Yg9/Fe36x38arThvB+dg2yvltdPHbsLFe4j2/1G9jpdNGcP5QLYpkAbmV6vSzq+9luzme9jz/sVDkwAWSiI9XBBtbtsCCS7bNV6YTR3CkOueCzww4bRdhiuTzXpf3zTH9M7Gcae48Dz7L7UvK/7gvLl4R51yBGKxczgSv2Vy0dV5Py+dvgvem5fM+N/Z0gdjdz2nu/Dv4rMJOH9IU9CU1n75kYPvy17wb6CcSOXBxNOhH0KdM57WCYExsG4Xy6UdBpx+xOs/wzwP7Udu2USSffhR2HoPPL+L0oyi2H3UKxfTDHgfTb1GnL8WwffmLI8Wdzwr6Vcz5d/B6utOP4th+/KWbYjHxB/92+/d/7WsmUV8L/Y/7KsCrXNtmCWybtQtFDsTUHgfTTQknvpLYvtSxmsyM7M9r0H4stm79ITG+l3bidfNpDzuelfKfu+8Lnqc5r7vzffB6Mycm22YZbP//yqfbL3scLJ/B59t5IxgTe+XkdczpMSgnr3XO0BSnjdIxcbk1cLrz3B0nJPITdT6rtPNZ9rD5yfKfR53XJObfsvn0w51/g88P3lfIeZ7lnCsX01+3VnT/Nphbg/dn+rGlYWOr435WcByMQ2lO7A6H2g3p3rd3jxgOBe0WyKddt+5Nj3mfi4lbX6XEdrB5BAKCQS5aSPRvb6l9ixDoxZqo8kWqAqX3LTKg4y5LsrjZHbi4Ccy1QeIXu6jW3V946uo/dnMWxHp4z3v6C1GrnIWo4Py/WaDL8d6f67f1mtNWcD7eAl2O059e3vPL/DZed9oIzheI/H1wtQdaJ60iMnxG97NHA/3jbC/sBT25dWvXzbbjGCpudxLt7SxYBpPxPy0upTjn3KLOHkwLmwWdOCIx8Rb3Xw8K3v4D8nrnDm07pG/f3rm9c3q2HZCX48IYW3+4TcWed9fmMmL+3oU0eC2h6xbbv95CF4rFwzTsnHv5f7/4LjumLXOovhi5XOhq0T7Jq0WxSeojcLVoX+VXi9q4+5JcLWoHLIm+HqpCsGSIQiP3wCM7n+7+17ZN7AlJDJCTojvY9fN50d/hR1B8pEb+PvO7KyB28Dwln5hTnOep/nsKHOQ9KXHaye/boeIRnoLugMFcMyFS/ET1a7A/MfbflhQtIgce6K+ogXGY/sBJY0AD2KCTG+A5wMEzZIX3t6rM4thPYFXpMOWXdtu4+wvEfbjSS5NjJzSkflq0xeFXgeTSbiC/DZAzRgq/VLBO+gHH3IHAlWHbhsScO1D55aUScRfxGjyzPj7uSsq/qXnIWzk9SyDuyiTf1FwB1CMw16ayct5YvbQW4E0VAr2cLRB3VRK9DALqBZhrU5VAL20FeHMsgV7OEYi7OoleBgP1Asy1qU6gl/YCvDmOQC8dBOKuRaKXPKBegLk2tQj0cq4Ab04k0Mt5AnFnk+hlCFAvwFybbAK9dBLgTR0CvVwgEHddEr1cCdQLMNemLoFeLhLgTT0CvXQWiLs+iV6uAuoFmGtTn0AvFwvwphGBXi4RiLsxiV6uBuoFmGvTmEAvXQV404xAL90E4m5OopehQL0Ac22aE+ilhwBvWhLopadA3KeS6OUaoF6AuTanEuglV4A3ZxDopZdA3GeS6OVaoF6AuTZnEuiltwBvWhPo5XKBuM8m0ct1QL0Ac23OJtBLXwHenEOgl34Ccbcj0cv1QL0Ac23aEehlgABvOhLoZaBA3OeS6OUGoF6AuTbnEuhlkABvOhHoZbBA3BeQ6GUYUC/AXJsLCPQyRIA3nQn0cqVA3F1I9DIcqBdgrg0SP/uzJatT9//0or2HwV6Xba81tdfP2WuC7HUO9rtb+32UXWO364Z2LcT6O1uz2nnYji0WrzS/vdgDFXvQHpzrpfGcRPcR/ctJIgPl1QIDxqUEA+VQgbi7kgyUNwIHSmCuTVeCwuJaAd70INDLdQJx9yTRy01AvQBzbXoS6OUGAd70ItDLMIG4LyPRywigXoC5NpcR6OVGAd70IdDLTQJx9yXRy0igXoC5Nn0J9DJSgDcDCPRys0DcA0n0cjNQL8Bcm4EEerlVgDeDCfRym0DceSR6uQWoF2CuTR6BXu4Q4M1VBHq5UyDuq0n0citQL8Bcm6sJ9HKXAG+uJdDL3QJxX0eil9uAegHm2lxHoJd7BXgzjEAvowXiHk6il9uBegHm2gwn0MtYAd6MINDLfQJxjyTRyx1AvQBzbUYS6GW8AG9uJdDLBIG4byPRy51AvQBzbW4j0MtEAd7cSaCXBwTiHkWil1FAvQBzbUYR6OUhAd7cQ6CXSQJx30uil7uAegHm2txLoJdHBHgzlkAvjwrEfR+JXu4G6gWYa3MfgV4eE+DNBAK9TBGI+34SvdwD1Asw1+Z+Ar08LsCbBwn0Mk0g7odI9HIvUC/AXBskfvbGpzWp+298svcw2Ouy7bWm9vo5e02Qvc7Bfndrv4+ya+x23dCuhVh/Z2tWOw/bseVefzdINA/jbUUeNr+PHCIeZv/3429bpoeNeTSQ00j80nwexh6ovgbtJeINc8CcH7gTLlqQYxpgCSV4B6ZYssY00N/HsVKEQs/g9yXIVmTxEh0Wv3FA/FgFOY5AkONZBDkhQfY6i5fo0EsNOPxqswryfgJBTmQR5AMJsplavESHXsPB4VeHVZAPEgjyIRZBTkqQ3driJTosfg/j8KvLKsiHCQT5CIsgH02Q7eDiJTosfpNx+J3EKsjJBIJ8jEWQUxJkv7l4iQ6L31QcfiezCnIqgSAfZxHktATZ0C5eosPiNx2HXz1WQU4nEOQMFkE+kSA75sVLdFj8nsThV59VkE8SCHImiyCfSpAt+eIlOix+s3D4NWAV5CwCQT7NIsjZCbLnX7xEh8VvDg6/bqyCnEMgyLksgnwmQTYVjJfosPg9i8OvO6sgnyUQ5HMsgpyXILsWxkt0WPzm4/DrwSrI+QSCXMAiyOcTZFvEeIkOi99CHH49WQW5kECQi1gEuThB9l2Ml+iw+L2Awy+HVZAvEAhyCYsglybIxo7xEh0Wv2U4/HJZBbmMQJAvsghyeQLsHOnihxbkS+D7IdcQCvIlAkG+zCLIVxJkh8J4iQ6L3wrw/ZCMglxBIMhXWQS5MkG2QIyX6LD4rQLfD8koyFUEgnyNRZCvJ8gei/ESHRa/1eD7IRkFuZpAkGtYBPlGgmziGC/RYfF7E3w/JKMg3yQQ5FoWQa5LkF0i4yU6LH5vge+HZBTkWwSCfJtFkO8kyDaU8RIdFr93wfdDMgryXQJBrmcR5HsJss9lvESHxe998P2QjIJ8n0CQH7AI8sME2UgzXqLD4vcR+H5IRkF+RCDIj1kEuSFBduqMl+iw+G0E3w/JKMiNBILcxCLIzUBBat4KNF6iw+L3Cfh+SEZBfkIgyC0sgtwKFKTmvUbjJTosftvA90MyCnIbgSA/ZRHkZ0BBat7MNF6iw+L3Ofh+SEZBfk4gyO0sgtwBFKTm3VLjJTosfl+A74dkFOQXBIL8kkWQXwEFqXk71niJDovf1+D7IRkF+TWBIL9hEeS3QEFq3u81XqLD4rcTfD8koyB3EghyF4sgvwMKUuuGshIJthswTxfYiHgywQbMMwTifkz/xrf2MGVScG25uQ69AwHJBtbfA8cbIGcMC367G8jwLzvcYR4THrfC4mbbOyxF4IfylY/XNuYKAnHPENJLKjh+YH4MMmabjwxnfDjcO7E3si9X9rGi/2iPHzzN/+j9l+49fyN1P0bB+aCt4Hwl/2/t60EbP3nPf/bbeNNpIzj/b/rzi/f+X/221jptBefj9ecXpz+/ec9/99tY57QRnI9t4wi/jd/8Nqx5+cN7vsdv4y2njeB8bBtH+m384bdhY93rPf/Tb+Ntp43gvD3g+8GV3oc7ut2ZysfgKaX34Ypu9ymS2nFKO1xbM4G14ywS/KYB8XsKiN/TJLVjpCEOPyBnDBI/i1lK5O8Huq4CYpnt9jel4f7naf5jaj6cyJCIKeZzYnEsns856IdLJMkCim43tSFQlEJxpzaE50h0cJ+tdHJ8lmRynKN0cnyOZHIsAJwcgZwxzxFOjgWEJse05OSITVKawOSYrnxytHGnC02O6L6Oyto3kaMdc0bDxIx7gfIVEsvLDIG4nycpYtKBk/ACYBGzkKSIyQTiB+SMWUjCvyVKTcgSEvyWKjUhS0n0WxCoXyBnzFJCE1JQyIQUSpoQbJIKCZiQwspNiI27MIkJGesV45kCRely5ZdOTMySKcZfIpmMigAnI2CuzUvKTZzVdREB3qwgKQILC/EmLH6vkuAH5LdZAcRvJcm4VRTIPyBnzEoS/q1VaoJXk+C3TqkJXkOi32JA/QI5Y9YQmuBiQia4eNIEY5NUXMAEl1Bugm3cJUhM8CTPDBYVKOrXKjfBU7JkzMw6ksmoJHAyAubarFNugq2uSwrw5h2SIrCEEG9C/7I8SxEN1Mo7QPzWk4xbpYD8A3LGrCfh3xalJvhDEvy2KjXBH5HotzRQv0DOmI8ITXBpIRNcJmmCsUkqI2CCs5SbYBt3FokJnu6ZwVICRf1G5SZ4VpaMmdlEMhlFgZMRMNdmk3ITbHUdFeDNFpIiMEuIN6F/yZwEPyC/zRYgfttIxq2yQP4BOWO2kfBvt1ITvJ0Evx+UmuAdJPotB9QvkDNmB6EJLidkgssnTTA2SeUFTPBhyk2wjfswEhM81zODZQWK+q+Um+AFWTJm5muSyehw4GQEzLX5WrkJtro+XIA3O0mKwMOEeBMWv10k+AH5bXYC8fuOZNyqAOQfkDPmOxL+pbfXaYJ/JMEvA4gf0gT/RKLfikD9AjljfiI0wRWFTPARSROMTdIRAib4SOUm2MZ9JIkJXuyZwQoCRf2vyk3w8iwZM/MbyWRUCTgZAXNtflNugq2uKwnwZg9JEXikEG/C4reXBD8gv80eIH5/koxblYH8A3LG/EnCv3JKTXCBsRz4lVdqgtPGcuj3KKB+gZwxSPwOlQk+SsgEH500wdgkHS1ggqsoN8E27iokJniFZwYrCxT1mWN1x706S8bMFCSZjKoCJyNgrk1BYd6Exc3quqoAb4qQFIFVhHgT+geTSPAD8tsUAeJXjGTcqgbkH5AzphgJ/2ooNcGlSPCrqdQElybR7zFA/QI5Y0oTmuBjhEzwsUkTjE3SsQImuLpyE2zjrk5igtd6ZrCaQFEfVW6C12fJmJmyJJNRDeBkBMy1KavcBFtd1xDgzWEkRWB1Id6EvryfBD8gv81hQPwqkIxbNYH8A3LGVCDhXyOlJrgSCX6NlZrgyiT6PQ6oXyBnTGVCE3yckAmulTTB2CTVEjDBxys3wTbu40lM8IeeGawpUNRXUW6CN2fJmJmqJJPRCcDJCJhrU1W5Cba6PkGAN8eSFIHHC/Em9OIECX5AfptjgfjVIBm3TgTyD8gZU4OEf22UmuDjSfBrq9QEn0Ci32ygfoGcMScQmuBsIRNskiYYmyQjYIJrKzfBNu7aJCZ4m2cGTxQo6o1yE/xFloyZqU0yGdUBTkbAXJvayk2w1XUdAd6cRFIE1hbiTVj8TmbBD6iVk4D41SMZt+oC+QfkjKlHwr9LlZrgRiT4dVVqghuT6PckoH6BnDGNCU3wSUIm+OSkCcYm6WQBE1xPuQm2cdcjMcHfeGawrkBR30y5Cd6dJWNmmpNMRvWBkxEw16a5chNsdV1fgDctSYrAekK8CYvfqST4AfltWgLxO41k3GoA5B+QM+Y0Ev5dodQEn0WC3yClJrgViX4bAvUL5IxpRWiCGwqZ4EZJE4xNUiMBE9xYuQm2cTcmMcE/e2awgUBR30a5Cd6TJWNm2pJMRk2AkxEw16atchNsdd1EgDftWe6JE+JNWPw6sFxOCdRKeyB+HUnGraZA/gE5YzqS8G+EUhPciQS/kUpN8AUk+m0G1C+QM+YCQhPcTMgEN0+aYHCSBExwC+Um2MbdgsQEp0QjkaYCRX1n5SY4MypjZrqQTEanACcjYK5NF+Um2Or6FAHeXEpSBLYQ4k1Y/LqS4Afkt7kUiF83knGrJZB/QM6YbiT8G6fUBOeQ4DdeqQnOJdHvqUD9AjljcglN8KlCJvi0pAnGJuk0ARN8unITbOM+ncQEF/HMYEuBor63chNcKipjZi4nmYzOAE5GwFyby5WbYKvrMwR404+kCDxdiDdh8etPgh+Q36YfEL8BJOPWmUD+ATljBpDwb7pSEzyYBL8ZSk1wHol+zwLqF8gZk0dogs8SMsGtkiYYm6RWAia4tXITbONuTWKCo54ZPFOgqL9KuQmuEJUxM1eTTEZnAycjYK7N1cpNsNX12QK8uZakCGwtxJuw+F1Hgh+Q3+ZaIH7Xk4xbbYD8A3LGXE/Cv4VKTfCNJPgtUmqCbyLRb1ugfoGcMTcRmuC2Qib4nKQJxibpHAET3E65CbZxtyMxwZU8M9hGoKi/WbkJrhaVMTO3kExG7YGTETDX5hblJtjqur0Ab24nKQLbCfEmLH53kOAH5Le5HYjfnSTjVgcg/4CcMXeS8G+1UhN8Dwl+a5Sa4HtJ9NsRqF8gZ8y9hCa4o5AJPjdpgrFJOlfABJ+n3ATbuM8jMcE1PDPYQaCoH6vcBJ8YlTEz95FMRucDJyNgrs19yk2w1fX5AryZQFIEnifEm7D43U+CH5DfZgIQv4kk41YnIP+AnDETSfi3UakJnkSC3yalJvhhEv1eANQvkDPmYUITfIGQCb4waYKxSbpQwARfpNwE27gvIjHBdTwz2EmgqJ+s3AQ3iMqYmcdIJqPOwMkImGvzmHITbHXdWYA3j5MUgRcJ8SYsftNI8APy2zwOxG86ybjVBcg/IGfMdBL+7VRqgmeS4LdLqQl+ikS/FwP1C+SMeYrQBF8sZIIvSZpgbJIuETDBlyo3wTbuS0lMcBPPDHYRKOpnKzfBLaMyZmYOyWTUFTgZAXNt5ig3wVbXXQV48yxJEXipEG/C4vccCX5AfptngfjNIxm3ugH5B+SMmUfCv5QOOk3wQhL8UoH4IU3wIhL9dgfqF8gZs4jQBHcXMsE9kiYYm6QeAia4p3ITbOPuSWKCz/DMYDeBon6JchPcJipjZpaSTEY5wMkImGuzVLkJtrrOEeDNcpIisKcQb8Li9xIJfkB+m+VA/F4mGbdygfwDcsa8TMK/MkpN8EoS/LKUmuBVJPrtBdQvkDNmFaEJ7iVkgi9LmmBski4TMMG9lZtgG3dvEhPc3jODuQJF/WrlJrhTVMbMrCGZjC4HTkbAXJs1yk2w1fXlArxZS1IE9hbiTVj81rH8sA5QK2uB+L1FMm71AfIPyBnzFgn/qik1wetJ8DtGqQl+j0S/fYH6BXLGvEdogvsKmeB+SROMTVI/ARPcX7kJtnH3JzHBnT0z2EegqP9QuQnuFpUxMx+RTEYDgJMRMNfmI+Um2Op6gABvNpIUgf2FeBMWv00k+AH5bTYC8dtMMm4NBPIPyBmzmYR/9ZSa4G0k+NVXaoI/JdHvFUD9AjljPiU0wVcImeBBSROMTdIgARM8WLkJtnEPJjHBOZ4ZHChQ1G9XboL7RGXMzA6SySgPOBkBc212KDfBVtd5Arz5iqQIHCzEm7D4fU2CH5Df5isgft+QjFtDgPwDcsZ8Q8K/s5Sa4O9I8Gul1AR/T6LfK4H6BXLGfE9ogq8UMsFXJU0wNklXCZjgq5WbYBv31SQmeIBnBocIFPU/KjfBQ6IyZuYnksloKHAyAuba/KTcBFtdDxXgza8kReDVQrwJi99vJPgB+W1+BeL3O8m4dQ2Qf0DOmN9J+NdZqQn+kwS/LkpNcOQ+Dv1eC9QvkDMGid+hMsHXCpng65ImGJuk6wRM8PXKTbCN+3oSEzzUM4PXCBT1Be7THfewqIyZSSOZjG4ATkbAXJs0Yd6Exc3q+gYB3mQeIt5khzsOGHuzwx0H8CYsfgVJ8APy22QC8StEMm4NA/IPyBlTiIR//ZSa4GIk+PVXaoKLk+h3OFC/QM6Y4oQmeLiQCb4xaYKxSbpRwATfpNwE27hvIjHBIzwzOEygqC+l3ATfHpUxM6VJJqMRwMkImGtTWrkJtroeIcCbKEkReJMQb8LiV5YEPyC/TRSIXzmScWskkH9AzphyJPwbptQEVyDBb7hSE1yRRL83A/UL5IypSGiCbxYywbckTTA2SbcImOBblZtgG/etJCb4Ls8MjhQo6ispN8FjozJmpjLJZHQbcDIC5tpUVm6Cra5vE+BNFZIi8FYh3oTFryoJfkB+mypA/KqRjFu3A/kH5IypRsK/0UpNcA0S/MYoNcE1SfR7B1C/QM6YmoQm+A4hE3xn0gRjk3SngAkepdwE27hHkZjgCZ4ZvF2gqD9euQmeFJUxMyeQTEZ3AScjYK7NCcpNsNX1XQK8MSRF4Cgh3oTFrzYJfkB+GwPErw7JuHU3kH9Azpg6JPybotQE1yPBb6pSE1yfRL/3APUL5IypT2iC7xEywfcmTTA2SfcKmODRyk2wjXs0iQme7JnBuwWK+kbKTfD0qIyZaUwyGY0BTkbAXJvGyk2w1fUYAd40Y/kmSYg3YfFrToIfkN+mGRC/FiTj1lgg/4CcMS1I+DdPqQk+jQS/+UpN8Okk+r0PqF8gZ8zphCb4PiETPC5pgrFJGidggscrN8E27vEkJnimZwbHChT1Zyk3wXOjMmamFclkNAE4GQFzbVopN8FW1xMEeNOGpAgcL8SbsPi1JcEPyG/TBojfOSTj1v1A/gE5Y84h4d9KpSa4Iwl+q5Sa4HNJ9DsRqF8gZ8y5hCZ4opAJfiBpgrFJekDABD+o3ATbuB8kMcHzPDN4v0BR30m5CV4clTEzF5BMRg8BJyNgrs0Fyk2w1fVDArzpTFIEPijEm7D4dSHBD8hv0xmI38Uk49YkIP+AnDEXK5/vlnnz3SSBcaub8rhXRGXG6+4kenkYqBdgrk135bw5zGvwYQHe2HZRcdu+ZTicOdw7sdd7rOA/VvQf7fGIF8uj3n/p3vN3Uveb2uB80FZwvpL/t/b1oI3J3vPH/DbeddoIzv+b/kzx3j/Vb2u901ZwPl5/pjj9edx7Ps1v4z2njeB8bBtH+G087rdhDf507/kMv433nTaC87FtHOm3Md1vw8b6hPf8Sb+ND5w2gvOHalGkApBbqU4/Z/pe9inH057nPxaKHLhAEvHximBjyxZYcMm2+cp04giOVOdc8JkBp+0iTJF83uvyvjmmfyaWM82d58FnuX1J+R/3xcUr4pwrEIOVy5ngNZuLts7rafn8TfDetHze58aeLhC7+znNnX8Hn1XY6UOagr6k5tOXDGxf/pp3A/1EIgcujgb9CPqU6bxWEIyJbaNQPv0o6PQjVucZ/nlgP2rbNork04/CzmPw+UWcfhTF9qNOoZh+2ONg+i3q9KUYti9/caS481lBv4o5/w5eT3f6URzbj790Uywm/uDfbv/+r33NJOprof9xXwV4lWvbLIFts3ahyIGY2uNguinhxFcS25c6VpOZkf15DdqPxdatPyTG99JOvG4+7WHHs1L+c/d9wfM053V3vg9eb+bEZNssg+3/X/l0+2WPg+Uz+Hw7bwRjYq+cvI45PQbl5LXOGZritFE6Ji63Bk53nrvjhER+os5nlXY+yx42P1n+86jzmsT8Wzaffrjzb/D5wfsKOc+znHPlYvrr1oru3wZza/D+TD+2NGxsddzPCo6DcSjNid3hULsh3fv27hHDoaDdAvm069a96THvczFx66uU2A42j0BAMMhFC4n+PVx63yIEerEmR/ki1ZTS+xYZ0HHnkixuzgIubgJzbZD4xS6qzfIXnmb6j085C2JPe89n+wtRHzoLUcH5f7NAN8d7/1y/rY+ctoLz8Rbo5jj9ecZ7/qzfxsdOG8H5ApG/D672QOukVUSGz+h+Pt1Q/zj7DPaCnty6tetm23EMFbc7iT7nLFgGk/E/LS6lOOfcos4eTAubBZ04IjHxFvdfDwre/gPyeucObTukb9/eub1zerYdkJfjwhhbf7hNxZ531+YyYv7ehTR4LaHrFtu/54QuFIuHadg5d95/v/guO6Ytc6i+GJkndLXo/OTVotgkzRe4WnSB8qtFbdwLSK4WtQOWRF8PVSE4J0ShkXvgkZ1Pd/9r2yb2hCQGyEnRHeye93mx0OFHUHykRv4+87srIHbwPCWfmFOc56n+ewoc5D0pcdrJ79uh4hGegu6AwVwzIVL8RD3fcH9i7L8tKVpEDjzQX1ED4zALgZPGooawQSc3wHORg2fICu9vVZnF8XmBVaXeyi/ttnEvFIj7cqWXJsdOaEj9fNwWh18fkku7gfw2QM4YKfxSwTp5HjjmLgauDNs2JObcxcovL5WIu7TX4NgG+LgHKP+mprFnPO4TiHsgyTc1LwD1CMy1GaicN1Yv4wV4M5hALxME4s4j0csSoF6AuTZ5BHqZKMCbqwj08oBA3FeT6GUpUC/AXJurCfTykABvriXQyySBuK8j0csyoF6AuTbXEejlEQHeDCPQy6MCcQ8n0cuLQL0Ac22GE+jlMQHejCDQyxSBuEeS6GU5UC/AXJuRBHp5XIA3txLoZZpA3LeR6OUloF6AuTa3EehlhgBv7iTQyxMCcY8i0cvLQL0Ac21GEehlpgBv7iHQy1MCcd9LopdXgHoB5trcS6CXpwV4M5ZAL7MF4r6PRC8rgHoB5trcR6CXuQK8mUCgl2cE4r6fRC+vAvUCzLW5n0Avzwnw5kECvcwTiPshEr2sBOoFmGvzEIFeFgjw5hECvTwvEPejJHpZBdQLMNfmUQK9LBLgzRQCvSwWiHsqiV5eA+oFmGszlUAvSwR4M51AL0sF4p5BopfXgXoB5trMINDLiwK8mUmgl+UCcT9FopfVQL0Ac22Q+NmfLdmQuv+nF+09DPa6bHutqb1+zl4TZK9zsN/d2u+j7Bq7XTe0ayHW39ma1c7DdmyxeKX57cUeqNiD9uBcL4PnJLqP6F9OEhkoXxYYMGYTDJSvCMQ9h2SgXAMcKIG5NnMICotXBXjzLIFeVgrE/RyJXt4A6gWYa/McgV5eE+DNAgK9vC4Q9/MkenkTqBdgrs3zBHpZI8CbxQR6eUMg7hdI9LIWqBdgrs0LBHpZK8CbZQR6WScQ94skelkH1Asw1+ZFAr28LcCblwn08o5A3K+Q6OUtoF6AuTavEOhlvQBvVhLo5T2BuFeR6OVtoF6AuTarCPTygQBvVhPo5UOBuNeQ6OUdoF6AuTZrCPTysQBv1hLoZYNA3OtI9PIuUC/AXJt1BHrZJMCbdwj0slkg7ndJ9LIeqBdgrs27BHrZIsCb9wn0slUg7g9I9PIeUC/AXJsPCPTyqQBvPibQy2cCcW8g0cv7QL0Ac202EOhluwBvNhPoZYdA3J+Q6OUDoF6AuTafEOjlSwHebCPQy1cCcX9KopcPgXoB5tp8SqCXbwR4s51AL98KxL2DRC8fAfUCzLXZQaCXXQK8+YpAL98JxP01iV4+BuoFmGuDxM/e+LQxdf+NT/YeBntdtr3W1F4/Z68Jstc52O9u7fdRdo3drhvatRDr72zNaudhO7Z87O8GieZhvK3Iw+Z35yHiYfZ/P/62ZXrotQMgp5H4pfk8jD1QfQ3aS8Qb5oA5P3AnXLQgNzbEEkrwDkyxZG1sqL+Pm6QIhZ7BNyfIVmTxEh165QyIH6sgPyEQ5BYWQW5NkL3O4iU69JIkDr/arILcRiDIT1kE+VmCbKYWL9Fh8fsch18dVkF+TiDI7SyC3JEgu7XFS3RY/L7A4VeXVZBfEAjySxZBfpUg28HFS3To1X4cfiexCvJrAkF+wyLIbxNkv7l4iQ79tQcOv5NZBbmTQJC7WAT5XYJsaBcv0WHx+x6HXz1WQX5PIMjdLIL8IUF2zIuX6LD4/YjDrz6rIH8kEORPLIL8OUG25IuX6LD4/YLDrwGrIH8hEOSvLIL8LUH2/IuX6LD4/Y7DrxurIH8nEOQfLILckyCbCsZLdFj89uLw684qyL0EgvyTRZCRRrigNe9aGC/RYfFLweHXg1WQQAzE+pjaiESQBYCC1LwtYrxEh8UvDYdfT1ZBphEIMp1FkBlAQWredzFeosPil4nDL4dVkJkEgizIIshCQEFq3tgxXqLD4lcYh18uqyALEwiyCIsgiwIFqXXnSBc/tCCLARMtfIOtGNmLEQiyOIsgSwAFqXmHwniJDotfSSB+rIIsSSDIUiyCLA0klOYtEOMlOix+ZXD41WYVZBkCQWaxCDIKFKTmPRbjJTosfmVx+NVhFWRZAkGWYxFkeaAgNW/iGC/RYfE7DIdfXVZBHkYgyMNZBFkBKEjNu0TGS3RY/Cri8DuJVZAVCQR5BIsgjwQKUvM2lPESHRa/Sjj8TmYVZCUCQVZmEeRRQEFq3ucyXqLD4nc0Dr96rII8mkCQVVgEWRUoSM0bacZLdFj8quHwq88qyGoEgjyGRZDHAgWpeafOeIkOi191HH4NWAVZnUCQNVgEWRMoSM1bgcZLdFj8jsPh141VkMcRCLIWiyCPBwpS816j8RIdFr8TcPh1ZxXkCQSCPJFFkNlAQWrezDReosPiZ8D3QzIK0hAIsjaLIOsABal5t9R4iQ6LX13w/ZCMgqxLIMiTWAR5MlCQmrdjjZfosPjVA98PySjIegSCrM8iyAZAQWre7zVeosPi1xB8PySjIBsSCLIRiyAbAwWpdUNZiQTbDZi/F9iI+DuCDZh3C8T9vf6Nb+1hDk/BteXmOix+u0k2sG4CHG+AnDEs+DVtJMO/7HCH+V543Ar922deG5VT8O3+rHy8tjEfLRD3L0J6SQXHD8yPQcZs85HhjA9HeSf2Rvblyj5W8R/t0cxq3vsv3Xu+KXU/RsH5oK3g/DH+39rXgzZaeM9P8dvY7LQRnP83/Wnpvf9Uv61PnLaC8/H609Lpz2ne89P9NrY4bQTnY9uo6rdxmt+GNS9neM/P9NvY6rQRnI9to5rfxhl+GzbWs7znrfw2tjltBOftgdZO0zL7cIf/ArLyMbhlmX24otv9g6R2nNIO19bvwNpxDwl+04D4/QHEby9J7dgaWDsCOWOQ+FnMUiJ/P9B1FRDLbLe/Zzfa/zzNf0zNhxMZAjFFYj4nFsfi+ZyDfrhEks5uhG+3TSOcKKXibtMIniPRwX220smxwDgO/OYonRzTxnFMjm2BkyOQMwaJ36GaHNsKTY7nJCdHbJLOEZgc2ymfHG3c7YQmR3RfR2Xtm8jRjrl9o8SMO3OcbNxh+2d52V4g7oIkRUw74CTs5jr0z3iTFDEdgPgBOWMKkfBviVITUowEv6VKTUhxEv12BOoXyBlTnNCEdBQyIecmTQg2SecKmJDzlJsQG/d5JCZkrFeMdxAoSkuN0x33xCyZYrw0yWR0PnAyAubalFZu4qyuzxfgTZSkCDxPiDehfweaBD8gv00UiF85knGrE5B/QM6YciT8W6vUBFcgwW+dUhNckUS/FwD1C+SMqUhogi8QMsEXJk0wNkkXCpjgi5SbYBv3RSQmeJJnBjsJFPWVlJvgKVkyZqYyyWTUGTgZAXNtKis3wVbXnQV4U4WkCLxIiDehf3eYBD8gv00VIH7VSMatLkD+ATljqpHwb4tSE1yDBL+tSk1wTRL9XgzUL5AzpiahCb5YyARfkjTB2CRdImCCL1Vugm3cl5KY4OmeGewiUNQfr9wEz8qSMTMnkExGXYGTETDX5gTlJtjquqsAbwxJEXipEG/C4lebBD8gv40B4leHZNzqBuQfkDOmDgn/dis1wfVI8PtBqQmuT6Lf7kD9Ajlj6hOa4O5CJrhH0gRjk9RDwAT3VG6Cbdw9SUzwXM8MdhMo6hspN8ELsmTMTGOSySgHOBkBc20aKzfBVtc5ArxpRlIE9hTiTVj8mpPgB+S3aQbErwXJuJUL5B+QM6YFCf/S2+s0waeR4JcBxA9pgk8n0W8voH6BnDGnE5rgXkIm+LKkCcYm6TIBE9xbuQm2cfcmMcGLPTOYK1DUn6XcBC/PkjEzrUgmo8uBkxEw16aVchNsdX25AG/akBSBvYV4E/pXH0nwA/LbtAHidw7JuNUHyD8gZ8w5JPwrp9QEdyTBr7xSE3wuiX77AvUL5Iw5l9AE9xUywf2SJhibpH4CJri/chNs4+5PYoJXeGawj0BR30m5CV6dJWNmLiCZjAYAJyNgrs0Fyk2w1fUAAd50JikC+wvxJvS9oiT4AfltOgPxu5hk3BoI5B+QM+ZiEv7VUGqCu5HgV1OpCe5Oot8rgPoFcsZ0JzTBVwiZ4EFJE4xN0iABEzxYuQm2cQ8mMcFrPTM4UKCoz1FugtdnyZiZXJLJKA84GQFzbXKVm2Cr6zwB3vQmKQIHC/Em9JUNJPgB+W16A/HrQzJuDQHyD8gZ04eEf42UmuABLLczKDXBA0n0eyVQv0DOmIGEJvhKIRN8VdIEY5N0lYAJvlq5CbZxX01igj/0zOAQgaJ+sHITvDlLxszkkUxGQ4GTETDXJk+5Cba6HirAm6tIisCrhXgTOi8k+AH5ba4C4jeUZNy6Bsg/IGfMUBL+tVFqgq8nwa+tUhN8A4l+rwXqF8gZcwOhCb5WyARflzTB2CRdJ2CCr1dugm3c15OY4G2eGbxGoKi/UbkJ/iJLxszcRDIZ3QCcjIC5NjcpN8FW1zcI8OZmkiLweiHehMXvFhL8gPw2NwPxu5Vk3BoG5B+QM+ZWEv5dqtQE30mCX1elJngUiX6HA/UL5IwZRWiChwuZ4BuTJhibpBsFTPBNyk2wjfsmEhP8jWcGhwkU9fcoN8G7s2TMzL0kk9EI4GQEzLW5V7kJtroeIcCbsSwmTog3YfG7jwQ/IL/NWCB+40jGrZFA/gE5Y8aR8O8KpSZ4Igl+g5Sa4AdI9HszUL9AzpgHCE3wzUIm+JakCcYm6RYBE3yrchNs476VxAT/7JnBkQJF/STlJnhPloyZeZhkMroNOBkBc20eVm6Cra5vE+DNZJIi8FYh3oTF7zES/ID8NpOB+E0hGbduB/IPyBkzhYR/I5Sa4Okk+I1UaoJnkOj3DqB+gZwxMwhN8B1CJvjOpAnGJulOARM8SrkJtnGPIjHBKdFI5HaBon6mchOcGZUxM0+RTEZ3AScjYK7NU8pNsNX1XQK8mU1SBI4S4k1Y/OaQ4Afkt5kNxG8uybh1N5B/QM6YuST8G6fUBM8jwW+8UhM8n0S/9wD1C+SMmU9ogu8RMsH3Jk0wNkn3Cpjg0cpNsI17NIkJLuKZwbsFivqFyk1wqaiMmVlEMhmNAU5GwFybRcpNsNX1GAHeLCEpAkcL8SYsfktJ8APy2ywB4reMZNwaC+QfkDNmGQn/pis1wS+T4DdDqQl+hUS/9wH1C+SMeYXQBN8nZILHJU0wNknjBEzweOUm2MY9nsQERz0zOFagqF+p3ARXiMqYmVUkk9EE4GQEzLVZpdwEW11PEODNapZvQoR4Exa/NST4AfltVgPxe4Nk3LofyD8gZ8wbJPxbqNQEv8WyiKXUBL9Not+JQP0COWPeJjTBE4VM8ANJE4xN0gMCJvhB5SbYxv0giQmu5JnB+wWK+vXKTXC1qIyZeY9kMnoIOBkBc23eU26Cra4fEuDNhyRF4INCvAmL30ck+AH5bT4E4vcxybg1Ccg/IGfMxyT8W63UBG8mwW+NUhP8CYl+HwbqF8gZ8wmhCX5YyAQ/kjTB2CQ9ImCCH1Vugm3cj5KY4BqeGZwkUNRvU26CT4zKmJlPSSajycDJCJhr86lyE2x1PVmAN9tJisBHhXgTFr8dJPgB+W22A/H7gmTcegzIPyBnzBck/Nuo1AR/Q4LfJqUm+FsS/U4B6hfIGfMtoQmeImSCpyZNMDZJUwVM8OPKTbCN+3ESE1zHM4OPCRT13yk3wQ2iMmbme5LJaBpwMgLm2nyv3ARbXU8T4M2PJEXg40K8CYvfTyT4AfltfgTi9zPJuDUdyD8gZ8zPJPzbqdQE/06C3y6lJvgPEv3OAOoXyBnzB6EJniFkgp9ImmBskp4QMMFPKjfBNu4nSUxwE88MThco6v9UboJbRmXMTGQ8x2Q0EzgZAXNt0Pih82t1PVOANwUOEW+ywx0HjL3Z4Y4DeBMWvzQS/ID8Ni5nwuKXTjJuPQXkH5AzJp2EfykddJrgQiT4pQLxQ5rgwiT6nQXUL5AzBonfoTLBs4RM8NNJE4xN0tMCJni2chNs455NYoLP8MzgUwJFfbHxuuNuE5UxM8VJJqM5wMkImGtTXLkJtrqeI8CbUiRF4Gwh3oTFrzQJfkB+m1JA/MqQjFtzgfwDcsaUIeFfGaUmuBwJfllKTXB5Ev0+A9QvkDOmPKEJfkbIBD+bNMHYJD0rYIKfU26CbdzPkZjg9p4ZnCtQ1FdQboI7RWXMTEWSyWgecDIC5tpUVG6Cra7nCfCmEkkR+JwQb8LiV5kEPyC/TSUgfkeRjFvzgfwDcsYcRcK/akpNcDUS/I5RaoKPIdHvAqB+gZwxxxCa4AVCJvj5pAnGJul5ARO8ULkJtnEvJDHBnT0zOF+gqK+h3AR3i8qYmZokk9Ei4GQEzLWpqdwEW10vEuDN8SRF4EIh3oTF7wQS/ID8NscD8TuRZNxaDOQfkDPmRBL+1VNqguuQ4FdfqQmuS6LfF4D6BXLG1CU0wS8ImeAlSROMTdISARO8VLkJtnEvJTHBOZ4ZXCxQ1NdTboL7RGXMTH2SyWgZcDIC5trUV26Cra6XCfCmEUkRuFSIN2Hxa8xSRAO10giIXxOScetFIP+AnDFNSPh3llIT3IIEv1ZKTfApJPpdDtQvkDPmFEITvFzIBL+UNMHYJL0kYIJfVm6Cbdwvk5jgAZ4ZfFGgqD9NuQkeEpUxM6eTTEavACcjYK7N6cpNsNX1KwK8OYukCHxZiDdh8WtFgh+Q3+YsIH6tScatFUD+ATljWpPwr7NSE3wOCX5dlJrgdiT6fRWoXyBnTDtCE/yqkAlemTTB2CStFDDBq5SbYBv3KhITPNQzgysEivqOyk3wsKiMmTmXZDJ6DTgZAXNtzlVugq2uXxPgTSeSInCVEG/C4ncBCX5AfptOQPwuJBm3XgfyD8gZcyEJ//opNcEXk+DXX6kJvoREv6uB+gVyxlxCaIJXC5ngNUkTjE3SGgET/IZyE2zjfoPEBI/wzODrAkV9N+Um+PaojJnpTjIZvQmcjIC5Nt2Vm2Cr6zcFeJNDUgS+IcSbsPjlkuAH5LfJAeLXi2TcWgvkH5AzphcJ/4YpNcF9SPAbrtQE9yXR7zqgfoGcMX0JTfA6IRP8VtIEY5P0loAJflu5CbZxv01igu/yzOBagaJ+gHITPDYqY2YGkkxG7wAnI2CuzUDlJtjq+h0B3gwmKQLfFuJNWPzySPAD8tsMBuI3hGTcehfIPyBnzBAS/o1WaoKHkuA3RqkJvoZEv+uB+gVyxlxDaILXC5ng95ImGJuk9wRM8PvKTbCN+30SEzzBM4PvChT11ys3wZOiMmbmBpLJ6APgZATMtblBuQm2uv5AgDc3khSB7wvxJix+N5HgB+S3uRGI3wiScetDIP+AnDEjSPg3RakJvpUEv6lKTfBtJPr9CKhfIGfMbYQm+CMhE/xx0gRjk/SxgAneoNwE27g3kJjgyZ4Z/FCgqL9TuQmeHpUxM6NIJqONwMkImGszSrkJtrreKMCbe0iKwA1CvAmL370k+AH5be4B4jeaZNzaBOQfkDNmNAn/5ik1weNI8Juv1ASPJ9HvZqB+gZwx4wlN8GYhE/xJ0gRjk/SJgAneotwE27i3kJjgmZ4Z3CRQ1E9UboLnRmXMzAMkk9FW4GQEzLV5QLkJtrreKsCbSSRF4BYh3oTF72ES/ID8NpOA+D1CMm5tA/IPyBnzCAn/Vio1wVNYfhhQqQmeSqLfT4H6BXLGTCU0wZ8KmeDPkiYYm6TPBEzw58pNsI37cxITPM8zg9sEivrpyk3w4qiMmZlBMhltB05GwFybGcpNsNX1dgHezCQpAj8X4k1Y/J4iwQ/IbzMTiN8sknFrB5B/QM6YWcrnu2XefLdDYNyaqzzuFVGZ8foZEr18AdQLMNfmGeW8qew1+IUAb2y7qLht3zIczhzlndjrPR7tP1bxH+3xpRfLV95/6d7zT1P3m9rgfNBWcP4Y/2/t60EbX3vPv/Hb+MxpIzj/b/rzrff+nX5bnzttBefj9edbpz+7vOff+W1sd9oIzse2UdVvY5ffhjX433vPd/tt7HDaCM7HtlHNb+N7vw0b6w/e8x/9Nr5w2gjOH6pFkaOB3Ep1+vmT72V/djztef5jociBCyQRH68INrZsgQWXbJuvTCeO4Eh1zgWfGXDaLsIUyee9Lu+bY/pnYjnT3HkefJbbl5T/cV9cvCLOuQIxWLmcCV6zuWjrvJ6Wz98E703L531u7OkCsbuf09z5d/BZhZ0+pCnoS2o+fcnA9uWveTfQTyRy4OJo0I+gT5nOawXBmNg2CuXTj4JOP2J1nuGfB/ajtm2jSD79KOw8Bp9fxOlHUWw/6hSK6Yc9Dqbfok5fimH78hdHijufFfSrmPPv4PV0px/Fsf34SzfFYuIP/u327//a10yivhb6H/dVgFe5ts0S2DZrF4ociKk9DqabEk58JbF9qWM1mRnZn9eg/Vhs3fpDYnwv7cTr5tMedjwr5T933xc8T3Ned+f74PVmTky2zTLY/v+VT7df9jhYPoPPt/NGMCb2ysnrmNNjUE5e65yhKU4bpWPicmvgdOe5O05I5CfqfFZp57PsYfOT5T+POq9JzL9l8+mHO/8Gnx+8r5DzPMs5Vy6mv26t6P5tMLcG78/0Y0vDxlbH/azgOBiH0pzYHQ61G9K9b+8eMRwK2i2QT7tu3Zse8z4XE7e+SontYPMIBASDXLSQ6F/TMvsWIdCLNfOUL1K1LLNvkQEd93ySxc1fgIubwFwbJH6xi2q/+AtPP/mPPzsLYr96z3/zF6K+dBaigvP/ZoHud+/9f/htfeW0FZyPt0D3u9OfPfa538bXThvB+QKRvw+u9kDrpFVEhs/ofv7aSP84uwd7QU9u3dp1s+04horbnUT/dBYsg8n4nxaXUpxzblFnD6aFzYJOHJGYeIv7rwcFb/8Beb1zh7Yd0rdv79zeOT3bDsjLcWGMrT/cpmLPu2tzGTF/70IavJbQdYvt359CF4rFwzT0BXON/3Nb2TFtmUP1xYjb5+yQh9vflMb7nyevFg3bZuN9gKLbTW0MJL9Q3KmN4TkSG7Ak+nqoCsF2IQqN3AOP7Hy6+1/bNrEnJDFATooHDHY+L9IcfgTFR2rk7zO/uwJiB89T8ok5xXme6r+nwEHekxKnnfy+HSoe4SnoDhjMNRMixU9Ugcb7E2P/bUnRInLggf6KGhiHSQNOGumNYYNOboBnuoNnyArvb1WZxbFAY3zluFD5pd027jSBuBcpvTQ5dkJD6mfIOTj8FpNc2g3ktwFyxkjhlwrWSQHgmJuBc3wiZsdqLaOxzBiGzDU67sO8Bjc1xMe9TPk3NRu870Q3C8T9Isk3NZlAPQJzbV5Uzhurly0CvHmZQC9bBeJ+hUQvBYF6AebavEKgl08FeLOSQC+fCcS9ikQvhYB6AebarCLQy3YB3qwm0MsOgbjXkOilMFAvwFybNQR6+VKAN2sJ9PKVQNzrSPRSBKgXYK7NOgK9fCPAm3cI9PKtQNzvkuilKFAvwFybdwn0skuAN+8T6OU7gbg/INFLMaBegLk2HxDoZbcAbz4m0MsPAnFvINFLcaBegLk2Gwj08pMAbzYT6OVngbg/IdFLCaBegLk2nxDo5VcB3mwj0MtvAnF/SqKXkkC9AHNtPiXQyx8CvNlOoJc9AnHvINFLKaBegLk2Owj08qcAb74i0EtE4M7lr0n0UhqoF2CuzdcEekkV4M1OAr0UEIh7F4leygD1Asy12UWgl3QB3uwm0EuGQNw/kOglC6gXYK7NDwR6KSjAm58J9FJIIO5fSPQSBeoFmGvzC4Feigjw5ncCvRQViPsPEr2UBeoFmGuDxM/+bMk3qft/etHew2Cvy7bXmtrr5+w1QfY6B/vdrf0+yq6x23VDuxZi/Z2tWe08bMcWi1ea317sgYo9aA/O9TJ4TqL7iP7lJJGBsrjAgPEnwUBZQiDuyASOgbIccKAE5tqg8ZPQSykB3hRQHrfVS2mBuNNI9FIeqBdgrk0agV6yBHiTSaCXqEDcBUn0chhQL8Bcm4IEeiknwJsiBHopLxB3URK9HA7UCzDXpiiBXg4X4E0JAr1UEIi7JIleKgD1Asy1KUmglyMEeFOGQC9HCsSdRaKXikC9AHNtsgj0UlmAN+UI9HKUQNzlSfRyBFAvwFyb8gR6qSLAmwoEeqkqEHdFEr0cCdQLMNemIoFejhHgTSUCvRwrsY81iV4qAfUCzLWpTKCXGgK8qUKgl5oCcVcl0UtloF6AuTZVCfRSS4A3xxLo5XiBuKuT6OUooF6AuTbVCfRyogBvjiPQS7ZA3LVI9HI0UC/AXJtaBHqpLcCbEwn0Ukcg7mwSvVQB6gWYa5NNoJeTBHhTh0AvJwvEXZdEL1WBegHm2tQl0Et9Ad7UI9BLA4G465PopRpQL8Bcm/oEemkkwJtGBHppLBB3YxK9HAPUCzDXBomfvfHp29T9Nz7Zexjsddn2WlN7/Zy9Jshe52C/u7XfR9k1drtuaNdCrL+zNaudh+3Ycoy/GySah/G2Ig+b32aHiIfZ//3425bpodcYgZxG4pfm8zD2QPU1aC8Rb5gD5vzAnXDhC8GNsYQSvANTLFnVG+vvYw0pQqFn8JoJshVZvESHXmEH4scqyOMIBFmLRZDHJ8heZ/ESHRa/E3D41WYV5AkEgjyRRZDZCbKZWrxEh8XP4PCrwypIQyDI2iyCrJMgu7XFS3ToL69w+NVlFWRdAkGexCLIkxNkO7h4iQ79rSAOv5NYBVmPQJD1WQTZIEH2m4uX6LD4NcThdzKrIBsSCLIRiyAbJ8iGdvESHRa/Jjj86rEKsgmBIJuyCLJZguyYFy/RYfFrjsOvPqsgmxMIsgWLIE9JkC354iU6LH4tcfg1YBVkSwJBnsoiyNMSZM+/eIkOi9/pOPy6sQrydAJBnsEiyDMTZFPBeIkOi99ZOPy6swryLAJBtmIRZOsE2bUwXqLD4nc2Dr8erII8m0CQbVgE2TZBtkWMl+iw+J2Dw68nqyDPIRBkOxZBtk+QfRfjJTosfh1w+OWwCrIDgSA7sgjy3ATZ2DFeosPidx4Ov1xWQZ5HIMjzWQTZKQF2jnTxQwvyAvD9kN8SCvICAkFeyCLIixJkh8J4iQ6LX2fw/ZCMguxMIMguLIK8OEG2QIyX6LD4XQK+H5JRkJcQCPJSFkF2TZA9FuMlOix+3cD3QzIKshuBILuzCLJHgmziGC/RYfHrCb4fklGQPQkEmcMiyNwE2SUyXqLD4tcLfD8koyB7EQjyMhZB9k6QbSjjJTosfpeD74dkFOTlBILswyLIvgmyz2W8RIfFrx/4fkhGQfYjEGR/FkEOSJCNNOMlOix+A8H3QzIKciCBIK9gEeSgBNmpM16iw+I3GHw/JKMgBxMIMo9FkEOAgtS8FWi8RIfF70rw/ZCMgrySQJBXsQjyaqAgNe81Gi/RYfEbCr4fklGQQwkEeQ2LIK8FClLzZqbxEh0Wv+vA90MyCvI6AkFezyLIG4CC1LxbarxEh8VvGPh+SEZBDiMQ5HAWQd4IFKTm7VjjJTosfjeB74dkFORNBIIcwSLIkUBBat7vNV6iw+J3M/h+SEZB3kwgyFtYBHkrUJBaN5SVSLDdgLmJwAawLQg2YG4qEPcp+je+tYc5KgXXlpvr0D9HSrKB9W3A8QbIGcOC3+2NZfiXHe4wpwiPW2Fxs+0dm4Jv9wzl47WNuYZA3GcK6SUVHD8wPwYZs81HhjM+VPdO7I3sy5V9rOk/2uMOT/N3ev+le893pu7HKDgftBWcP97/W/t60MYo7/ldfhu7nDaC8/+mP3d777/Hb+s7p63gfLz+3O30517v+Wi/je+dNoLzsW0c57dxr9+GNS9jvOdj/TZ2O20E52PbqOW3McZvw8Z6n/d8nN/GD04bwXl7oLWzqcw+3NHttlY+Bm8rsw9X+O9aktSOU9rh2moNrB3bkOA3DYjf2UD82pLUjuOBtSOQMwaJn8UsJfL3A11XAbHMdvs7ofH+52n+Y2o+nMgQiCkS8zmxOBbP5xz0wyWSNKExvt37G+NEKRX3/Y3hORId3GcrnRw7kkyOc5ROjueSTI4TgZMjkDPmXMLJcaLQ5PhAcnLEJukBgcnxQeWTo437QaHJEd3XUVn7JnK0Y36ocWLG3Un5Conl5UMCcV9AUsQ8CJyEOwGLmAtJiphJQPyAnDEXkvBviVITcjEJfkuVmpBLSPT7MFC/QM6YSwhNyMNCJuSRpAnBJukRARPyqHITYuN+lMSEjPWK8UkCRWk35ZdOTMySKca7k0xGk4GTETDXprtyE2d1PVmANzkkReCjQrwJ/SuhJPgB+W1ygPj1Ihm3HgPyD8gZ04uEf2uVmuA+JPitU2qC+5LodwpQv0DOmL6EJniKkAmemjTB2CRNFTDBjys3wTbux0lM8CTPDD4mUNQPUG6Cp2TJmJmBJJPRNOBkBMy1GajcBFtdTxPgzWCSIvBxId6ExS+PBD8gv81gIH5DSMat6UD+ATljhpDwb4tSEzyUBL+tSk3wNST6nQHUL5Az5hpCEzxDyAQ/kTTB2CQ9IWCCn1Rugm3cT5KY4OmeGZwuUNRfr9wEz8qSMTM3kExGM4GTETDX5gblJtjqeqYAb24kKQKfFOJN6J81JMEPyG9zIxC/ESTj1lNA/gE5Y0aQ8G+3UhN8Kwl+Pyg1wbeR6HcWUL9AzpjbCE3wLCET/HTSBGOT9LSACZ6t3ATbuGeTmOC5nhl8SqCov1O5CV6QJWNmRpFMRnOAkxEw12aUchNsdT1HgDf3kBSBs4V4Exa/e0nwA/Lb3APEbzTJuDUXyD8gZ8xoEv6lt9dpgseR4JcBxA9pgseT6PcZoH6BnDHjCU3wM0Im+NmkCcYm6VkBE/ycchNs436OxAQv9szgXIGifqJyE7w8S8bMPEAyGc0DTkbAXJsHlJtgq+t5AryZRFIEPifEm9A/uEKCH5DfZhIQv0dIxq35QP4BOWMeIeFfOaUmeAoJfuWVmuCpJPpdANQvkDNmKqEJXiBkgp9PmmBskp4XMMELlZtgG/dCEhO8wjOD8wWK+unKTfDqLBkzM4NkMloEnIyAuTYzlJtgq+tFAryZSVIELhTiTejLZEnwA/LbzATiN4tk3FoM5B+QM2YWCf9qKDXBc0nwq6nUBD9Dot8XgPoFcsY8Q2iCXxAywUuSJhibpCUCJnipchNs415KYoLXemZwsUBRP0+5CV6fJWNm5pNMRsuAkxEw12a+chNsdb1MgDcLWbYIEeJN6EUdEvyA/DYLgfgtJhm3XgTyD8gZs5iEf42UmuBlJPg1VmqCXyTR73KgfoGcMS8SmuDlQib4paQJxibpJQET/LJyE2zjfpnEBH/omcEXBYr6l5Wb4M1ZMmbmFZLJ6BXgZATMtXlFuQm2un5FgDcrSYrAl4V4Exa/VST4AfltVgLxe41k3FoB5B+QM+Y1Ev61UWqC3yDBr61SE/wmiX5fBeoXyBnzJqEJflXIBK9MmmBsklYKmOBVyk2wjXsViQne5pnBFQJF/VvKTfAXWTJm5m2Syeg14GQEzLV5W7kJtrp+TYA360mKwFVCvAmL33sk+AH5bdYD8XufZNx6Hcg/IGfM+yT8u1SpCf6YBL+uSk3wBhL9rgbqF8gZs4HQBK8WMsFrkiYYm6Q1Aib4DeUm2Mb9BokJ/sYzg68LFPWblZvg3VkyZuYTksnoTeBkBMy1+US5Cba6flOAN9tIisA3hHgTFr9PSfAD8ttsA+L3Gcm4tRbIPyBnzGck/LtCqQn+ggS/QUpN8Jck+l0H1C+QM+ZLQhO8TsgEv5U0wdgkvSVggt9WboJt3G+TmOCfPTO4VqCo/0a5Cd6TJWNmviWZjN4BTkbAXJtvlZtgq+t3BHjzHcs3mUK8CYvf9yT4AfltvgPit5tk3HoXyD8gZ8xuEv6NUGqCfybBb6RSE/wLiX7XA/UL5Iz5hdAErxcywe8lTTA2Se8JmOD3lZtgG/f7JCY4JRqJvCtQ1P+u3ARnRmXMzB8kk9EHwMkImGvzh3ITbHX9gQBv/iQpAt8X4k3ocfx+DvyA/DZ/AvFLuZ9j3PoQyD8gZ0wKCf/GKTXB6ST4jVdqgjNI9PsRUL9AzhgkfofKBH8kZII/TppgbJI+FjDBG5SbYBv3BhITXMQzgx8KFPWF7tcdd6mojJkpTDIZbQRORsBcm8LCvAl975WH20YB3hQjKQI3CPEmLH7FSfAD8tsUA+JXgmTc2gTkH5AzpgQJ/6YrNcFlSPCbodQEZ5HodzNQv0DOmCxCE7xZyAR/kjTB2CR9ImCCtyg3wTbuLSQmOOqZwU0CRX055Sa4QlTGzJQnmYy2AicjYK5NeeUm2Op6qwBvKpAUgVuEeBMWv4ok+AH5bSoA8TuCZNzaBuQfkDPmCBL+LVRqgo8iwW+RUhN8NIl+PwXqF8gZczShCf5UyAR/ljTB2CR9JmCCP1dugm3cn5OY4EqeGdwmUNRXU26Cq0VlzMwxJJPRduBkBMy1OUa5Cba63i7AmxokReDnQrwJi19NEvyA/DY1gPgdRzJu7QDyD8gZcxwJ/1YrNcEnkuC3RqkJzibR7xdA/QI5Y7IJTfAXQib4y6QJxibpSwET/JVyE2zj/orEBNfwzOAOgaK+jnITfGJUxszUJZmMvgZORsBcm7rKTbDV9dcCvKlHUgR+JcSbsPjVJ8EPyG9TD4hfA5Jx6xsg/4CcMQ1I+LdRqQluQoLfJqUmuCmJfr8F6hfIGdOU0AR/K2SCdyZNMDZJOwVM8C7lJtjGvYvEBNfxzOA3AkV9C+UmuEFUxsycQjIZfQecjIC5NqcoN8FW198J8OY0kiJwlxBvwuJ3Ogl+QH6b04D4nUEybn0P5B+QM+YMEv7tVGqCW7OMf0pN8Nkk+t0N1C+QM+ZsQhO8W8gE/5A0wdgk/SBggn9UboJt3D+SmOAmnhn8XqCoP0e5CW4ZlTEz7Ugmo5+AkxEw16adchNsdf2TAG86khSBPwrxJix+55LgB+S36QjE7zyScetnIP+AnDHnkfAvpYNOE3whCX6pQPyQJvgiEv3+AtQvkDPmIkIT/IuQCf41aYKxSfpVwAT/ptwE27h/IzHBZ3hm8GeBov5i5Sa4TVTGzFxCMhn9DpyMgLk2lyg3wVbXvwvwphtJEfibEG/C4tedBD8gv003IH49SMatP4D8A3LG9CDhXxmlJrgXCX5ZSk3wZST63QPUL5Az5jJCE7xHyATvTZpgbJL2CpjgP5WbYBv3nyQmuL1nBv8QKOr7KDfBnaIyZqYvyWQUaYLDEphr01e5Cf5L103w7Q4gKQL/bCzDm7D4DSTBD8hvMwCI3xUk41YKcNwCcsZcQcK/akpN8BCWH7ZTaoKvJNFvKlC/QM6YKwlNMBDLA0xwgSb7nydNcMg2bZIKNMG3m9ZEtwm2cac1gedIpK+dPTOYIlDUD1Vugrt5cUuYmWtIJqN04GQEzLW5RrkJtrpOF+DN9SRFYJoQb8LidwMJfkB+m+uB+A0jGbcygPwDcsYMI+FfPaUmeAQJfvWVmuCRJPrNBOoXyBkzktAEZwqZ4IJJE4xNUkEBE1xIuQm2cRciMcE5nhnMECjqb1VugvtEZczMbSSTUWHgZATMtblNuQm2ui4swJs7SYrAQkK8CYvfKBL8gPw2dwLxu4tk3CoC5B+QM+YuEv6dpdQEjybBr5VSEzyGRL9FgfoFcsaMITTBRYVMcLGkCcYmqZiACS6u3ATbuIuTmOABnhksIlDUj1NugodEZczMeJLJqARwMgLm2oxXboKtrksI8GYiSRFYXIg3YfF7gAQ/IL/NRCB+D5KMWyWB/ANyxjxIwr/OSk3wIyT4dVFqgh8l0W8poH6BnDGPEprgUkImuHTSBGOTVFrABJdRboJt3GVITPBQzwyWFCjqpyg3wcOiMmZmKslklAWcjIC5NlOVm2Cr6ywB3kxn+WEdId6ExW8GCX5AfpvpQPyeIBm3okD+ATljniDhXz+lJngWCX79lZrgp0n0WxaoXyBnzNOEJriskAkulzTB2CSVEzDB5ZWbYBt3eRITPMIzg1GBon6uchN8e1TGzDxDMhkdBpyMgLk2zyg3wVbXhwnwZh5JEVheiDdh8ZtPgh+Q32YeEL8FJOPW4UD+ATljFpDwb5hSE7yYBL/hSk3wCyT6rQDUL5Az5gVCE1xByARXTJpgbJIqCpjgI5SbYBv3ESQm+C7PDB4uUNQvU26Cx0ZlzMyLJJPRkcDJCJhr86JyE2x1faQAb14mKQKPEOJNWPxeIcEPyG/zMhC/FSTjViUg/4CcMStI+DdaqQl+jQS/MUpN8Osk+q0M1C+QM+Z1QhNcWcgEH5U0wdgkHSVggo9WboJt3EeTmOAJnhmsJFDUv6HcBE+KypiZN0kmoyrAyQiYa/OmchNsdV1FgDdvkRSBRwvxJix+b5PgB+S3eQuI3zsk41ZVIP+AnDHvkPBvilIT/D7L7QxKTfAHJPqtBtQvkDPmA0ITXE3IBB+TNMHYJB0jYIKPVW6CbdzHkpjgyZ4ZrCpQ1H+s3ARPj8qYmQ0kk1F14GQEzLXZoNwEW11XF+DNZpIi8Fgh3oTF7xMS/ID8NpuB+G0hGbdqAPkH5IzZQsK/eUpN8Gck+M1XaoI/J9FvTaB+gZwxnxOa4JpCJvi4pAnGJuk4ARNcS7kJtnHXIjHBMz0zWEOgqP9CuQmeG5UxM1+STEbHAycjYK7Nl8pNsNX18QK8+YakCKwlxJuw+H1Lgh+Q3+YbIH47ScatE4D8A3LG7CTh30qlJng3CX6rlJrgH0j0eyJQv0DOmB8ITfCJQiY4O2mCsUnKFjDBRrkJtnEbEhM8zzODJwgU9T8rN8GLozJm5heSyag2cDIC5tr8otwEW13XFuDN7yRFoBHiTVj8/iDBD8hv8zsQvz0k41YdIP+AnDF7lM93y7z5ro7AuJUyUXfcK6Iy43XqRA691AXqBZhrk6qcN8d6DdYV4I1tFxW37VuGw5nq3om93mMN/7Gm/2iPk7xYTvb+S/ee/5i639QG54O2gvPH+39rXw/aqOc9r++38ZPTRnD+3/Sngff+hn5bPzttBefj9aeB059G3vPGfhu/OG0E52PbOM5vo5HfhjX4TbznTf02fnXaCM7HtlHLb6OJ34aNtZnVmN/Gb04bwflDtShSA8itVKefLXwve4rjac/zHwtFDlwgifh4RbCxZQssuGTbfGU6cQRHqnMu+MyA03YRpkg+73V53xzTPxPLmebO8+Cz3L6k/I/74uIVcc4ViMHK5Uzwms1FW+f1tHz+JnhvWj7vc2NPF4jd/Zzmzr+Dzyrs9CFNQV9S8+lLBrYvf827gX4ikQMXR4N+BH3KdF4rCMbEtlEon34UdPoRq/MM/zywH7VtG0Xy6Udh5zH4/CJOP4pi+1GnUEw/7HEw/RZ1+lIM25e/OFLc+aygX8Wcfwevpzv9KI7tx1+6KRYTf/Bvt3//175mEvW10P+4rwK8yrVtlsC2WbtQ5EBM7XEw3ZRw4iuJ7Usdq8nMyP68Bu3HYuvWHxLje2knXjef9rDjWSn/ufu+4Hma87o73wevN3Nism2Wwfb/r3y6/bLHwfIZfL6dN4IxsVdOXsecHoNy8lrnDE1x2igdE5dbA6c7z91xQiI/UeezSjufZQ+bnyz/edR5TWL+LZtPP9z5N/j84H2FnOdZzrlyMf11a0X3b4O5NXh/ph9bGja2Ou5nBcfBOJTmxO5wqN2Q7n1794jhUNBugXzadeve9Jj3uZi49VVKbAebRyAgGOSihUT/NpXZtwiBXqxJV75Ita3MvkUGdNwZJIubLYGLm8BcGyR+sYtqLf2Fpxb+4ynOgtip3vPT/IWo352FqOD8v1mgO917/xl+W384bQXn4y3Qne7050zv+Vl+G3ucNoLzBSJ/H1ztgdZJq4gMn9H9PLWJ/nH2TOwFPbl1a9fNtuMYKm53Em3lLFgGk/E/LS6lOOfcos4eTAubBZ04IjHxFvdfDwre/gPyeucObTukb9/eub1zerYdkJfjwhhbf7hNxZ531+YyYv7ehTR4LaHrFtu/VkIXisXDNOyc2/q/X3yXHdOWOVRfjLQWulr07OTVotgknS1wtWgb5VeL2rjbkFwtagcsib4eqkJwV4hCI/fAIzuf7v7Xtk3sCUkMkJOiO9i19XlxjsOPoPhIjfx95ndXQOzgeUo+Mac4z1P99xQ4yHtS4rST37dDxSM8Bd0Bg7lmQqT4iWrbZH9i7L8tKVpEDjzgP1KEi8OcA5w02jWBDTq5AZ7tHDxDVnh/q8osjm0FVpUKCa+mIS7NOkcg7sKHaDUt+18esRMaUj8l2uHwK6IUv5jDAPltgJwxUvilgnXSFjjmtgeuDNs2JObc9sovL5WIu7LXYI3G+LhLKP+m5jrPeNQUiLskyTc1HYB6BObalFTOG6uXWgK8KUOgl+MF4s4i0UtHoF6AuTZZBHo5UYA35Qj0ki0Qd3kSvZwL1Asw16Y8gV5qC/CmAoFe6gjEXZFEL+cB9QLMtalIoJeTBHhTiUAvJwvEXZlEL+cD9QLMtalMoJf6ArypQqCXBgJxVyXRSyegXoC5NlUJ9NJIgDfHEuilsUDc1Un0cgFQL8Bcm+oEemkqwJvjCPTSTCDuWiR6uRCoF2CuTS0CvbQQ4M2JBHo5RSDubBK9XATUCzDXJptAL6cK8KYOgV5OE4i7LoleOgP1Asy1qUuglzMEeFOPQC9nCsRdn0QvXYB6Aeba1CfQSysB3jQi0Etrgbgbk+jlYqBegLk2jQn00kaAN80I9NJWIO7mJHq5BKgXYK5NcwK9tBPgTUsCvbQXiPtUEr1cCtQLMNfmVAK9dBTgzRkEejlXIO4zSfTSFagXYK7NmQR6OV+AN60J9NJJIO6zSfTSDagXYK4NEj/7syV7U/f/9KK9h8Fel22vNbXXz9lrgux1Dva7W/t9lF1jt+uGdi3E+jtbs9p52I4tFq80v73YAxV70B6c61l4TqL7iP7lJJGB8kKBAeMcgoHyIoG425EMlN2BAyUw16YdQWHRRYA3HQn0crFA3OeS6KUHUC/AXJtzCfRyqQBvOhHopatA3BeQ6KUnUC/AXJsLCPTSXYA3nQn00kMg7i4keskB6gWYa9OFQC85Ary5lEAvuQJxdyXRSy5QL8Bcm64EerlMgDc9CPTSWyDuniR66QXUCzDXpieBXvoI8KYXgV76CsR9GYleLgPqBZhrcxmBXvoL8KYPgV4GCMTdl0QvvYF6Aeba9CXQyxUCvBlAoJdBAnEPJNHL5UC9AHNtBhLoJU+AN4MJ9DJEIO48Er30AeoFmGuTR6CXqwR4cxWBXq4WiPtqEr30BeoFmGtzNYFerhHgzbUEerlWIO7rSPTSD6gXYK7NdQR6uV6AN8MI9HKDQNzDSfTSH6gXYK7NcAK9DBfgzQgCvdwoEPdIEr0MAOoFmGszkkAvIwR4cyuBXkYKxH0biV4GAvUCzLW5jUAvtwjw5k4CvdwqEPcoEr1cAdQLMNcGiZ+98enP1P03Ptl7GOx12fZaU3v9nL0myF7nYL+7td9H2TV2u25o10Ksv7M1q52H7dhyhb8bJJqH8bYiD5vfew4RD7P/+/G3LdPDxjwIyGkkfmk+D2MPVF+D9hLxhjlgzg/cCRf+hVETLKEE78AUS9bgJvr7mCdFKPQMPiRBtiKLl+iw+F0JxI9VkFcSCPIqFkFenSB7ncVLdFj8huLwq80qyKEEgryGRZDXJshmavESHfq7WBx+dVgFeR2BIK9nEeQNCbJbW7xEh/6SG4dfXVZBDiMQ5HAWQd6YINvBxUt0WPxuwuF3EqsgbyIQ5AgWQY5MkP3m4iU6LH434/A7mVWQNxMI8hYWQd6aIBvaxUt06OtHcPjVYxXkbQSCvJ1FkHckyI558RId+sIcHH71WQV5J4EgR7EI8q4E2ZIvXqLD4nc3Dr8GrIK8m0CQ97AI8t4E2fMvXqLD4jcah183VkGOJhDkGBZBjk2QTQXjJTosfvfh8OvOKsj7CAQ5jkWQ4xNk18J4iQ6L3wQcfj1YBTmBQJD3swhyYoJsixgv0WHxewCHX09WQT5AIMgHWQT5UILsuxgv0WHxm4TDL4dVkJMIBPkwiyAfSZCNHeMlOix+j+Lwy2UV5KMEgpzMIsjHEmDnSBc/tCCngO+H/JNQkFMIBDmVRZCPJ8gOhfESHRa/aeD7IRkFOY1AkNNZBDkjQbZAjJfosPg9Ab4fklGQTxAI8kkWQc5MkD0W4yU6LH5Pge+HZBTkUwSCnMUiyKcTZBPHeIkOi99s8P2QjIKcTSDIOSyCnJsgu0TGS3RY/J4B3w/JKMhnCAT5LIsgn0uQbSjjJTosfvPA90MyCnIegSDnswhyQYLscxkv0WHxex58PySjIJ8nEORCFkEuSpCNNOMlOix+i8H3QzIKcjGBIF9gEeSSBNmpM16iw+K3FHw/JKMglxIIchmLIF8EClLzVqDxEh0Wv+Xg+yEZBbmcQJAvsQjyZaAgNe81Gi/RYfF7BXw/JKMgXyEQ5AoWQb4KFKTmzUzjJTosfivB90MyCnIlgSBXsQjyNaAgNe+WGi/RYfF7HXw/JKMgXycQ5GoWQa4BClLzdqzxEh0WvzfA90MyCvINAkG+ySLItUBBat7vNV6iw+K3Dnw/JKMg1xEI8i0WQb4NFKTWDWUlElzZa/A2gY2IRxNswHy7QNxj9G98aw9TPQXXlpvr0D9WR7KB9TvA8QbIGcOC37tNZPiXHe4wY0gKqPVN/kVb9Q7aling9O9gfc4Od5j1wGLC7e97TfY/T/MfU/PhboZATJGYz4nFsXg+56AfLpEkCyi63feb4MgvFff7TeA5OuggkB3uOADT7JBHgch+odgjFdzXY73gkZNmxaxI5F3hfP3rto1g2//wye6A94GPy4cOPoWcvAbvzfAfU5zc/+WmnbZSnMcUp40/nb/J7z0pcdop5JwL/r640xcgJtkCA3626ICe4oNrE3iL/0H23zaRV8cAifrMQJjwX2lV7gCDAQQd9/1aKvB/qPo+AE7IHwLbmkjioIH8NkDOmIkkDuYjQgfzkZCD+TjpYLBJ+ljAwWxQ7mBs3BvIHMwGQQcj1eeyERls/3XelLiNjT7nNiXdBqfb2BjjNjY5biMWPNRnuyIKO/tvBA7Mm5pwVE+bCaunzULV0yfJ6gmbpE8EqqctyqsnG/cWsuppyyGonmLXgZFLBdnhDvOvBmvJaklJJbbV5++2/1iJXeO0Fa8Suybyz5VYfu0kK7H4x/+vxLY22Q+m/fe2/0MlplWQofcwIVlH3QqMeRswF/8Kv38xgKEnBCR+nwLxC8WZf+jnZ8B+Kl2HFr16CLgEcwB+obfJIcHv8yYqOWOQ+LnFrDtxb8+nOGIpQtK9NtJj+m6PYEy2RUpB/9EevXLyOnTr33NAv9N75/TtmZLPX7hIFIh5rZDzPHgtM0LmZ+2U8LnA17w7wIsZGQ7Itu29Phb2cbv/b3t84T3/solPgwL7ExScD9oKzrfy2/jCaeMr7/nXfhspThvB+UO1kt4qgsWwgFA/Aw5FsO2K3bWRQtDH7YdooTU73GG+Elq0/MbhU1H/0Q64sQuY7sDseunYAVxgCqsjNYUVdOKIxMQbTGGl/H/3H5DXO3doy0E53fJyerYdkJfjghjMhflduOgOCO7rac6HZ8S04wIbvCY+40WcDiPb/gasMJaZ+Vvwquih+GrkW6FRZmfyqxFsknYKfDWyS/lXIzbuXQLlz6ESF7Iccpe5A/F852HzvfffbgejYv7jIZqqxdxmhhNHcLhTtX09Dfu5ddySJ+LgHckHt4jz+bZsCEopz/m2G9K9b+8erXOG5pezAvm065ZcsZWFm8fgtQMqA/QstqsJVgCuv/zO94Lf+4+7/ccS3n8/eM9/9L1hquMNg/ORfACTiDlsWz81kZ1MwvbPtveTQPUzWfll95ZHEnE/JrT0mgqOH5gf8xh4uTQ98vcDnf/UiEyeNK9NSfbzO5J1lO/BDie51revv4m21ucWc8HY/LPX/i9Ozir4j+4Sj7vsk19xlwjrboWdOCIx8QbrbiX9f+f06513Wv8eg4YO9Nbdzh7Qyy2UM/3H9HzacXG1R5rzPN3BMyPmvRlOv5pjYq5dKLJ/rTHifLZ7NHeeu18HFsb25S9tFXE+K+hX8DlFnNcznX4Uwfbjr/GicEz8bh+EPvev+Iv+Q/xF8+lH0UMYv7sOXzimn672g9cOagCzwx3mJ/DELnEbzKcChfzjyg2MvV7pM4G4pyXgtTfAXJtpJPe9/iqwsBMMTL/6CznlIvu/7P/NO/e7v6BTwFnQCc4fqlXY34S+4vgj+RUHNkl/CHzFsUf5Vxw27j2H+O6PsDjsAX/PGdtPe+xNXiwXUXqxXOyivp2X3bF/r3PB1582jU33wZHmzAHB+dh55Df/b/902kjx3pfqt5HutBGcP1QXjf0mtJAk1V+J28XRfSxH0Me9JAudVg+ofrqDR4Gm+58nLxhLXjCGZ26BptiC4lC4CuTo6vY3renfCZB0Ff+xzbI+oOh205vqdhU27vSm8BwdMnEhy4L8LsLJ8LDJ9P4r6GCUvHDqPx/JC6f+Ar8psJaLHOixLGGtH8r0Hws23X/hVCHveWHfH2U4/ig4H8kHMImYw7ZVpKnsZBK2f3ZQKtIU3+4Tyr93sDySiPtJkgungPkxTyYvnBLr528kPj2jKUc/M8HrCcn1rsRb78rvoqmiHq+KOXVJ8qKpvx/Ji6b2f7Z7NHeeJy+aEvvc5EVT/7ajRQ7RpB626C5O0s8SJP0sSdLPUkL9RF/kVRq4CDClHfAir3Yc+JUB4jcbiN8cEvyygPgtAeK3lAS/KBC/tUD81pHgVxaI3xYgfltJ8CsHxG83EL8fSPArD8QvvT1w0aw9B36HAfErB8SvPAl+hwPxqwHEryYJfhWA+DUC4teYBL+KQPzaAPFrS4LfEUD8LgXi15UEvyOB+F0BxG8QCX6VgPiNAOI3kgS/ykD8xgHxG0+C31FA/KYD8ZtBgt/RQPwWAvFbRIJfFSB+q4H4rSHBryoQv41A/DaR4FcNiN9OIH67SPA7BnkRaQfgRWAdOPA7FohfGSB+WST4VQfiVw2I3zEk+NUA4lcPiF99EvxqAvE7C4hfKxL8jgPi1xmIXxcS/GoB8esHxK8/CX7HA/EbBsRvOAl+JwDxGw3EbwwJficirx8C4jeVBL9sIH7zgPjNJ8HPAPFbCcRvlRB+6OsUa5NcT1mHpJ91Sfp5Ekk/TybpZz2SftYn6WcDkn42JOlnI5J+NibpZxOSfjYl6WczcD/R9xsd6zWYJ/BjwLOU/xhBxaxIZIhA3E+T/Ahyc6C/AObaPK2cN1YvVwnwZi6BXq4WiPsZEr20AOoFmGvzDIFerhHgzTwCvVwrEPd8Er2cglz/A+plPoFerhfgzUICvdwgEPciEr20RF6vCNTLIgK9DBfgzRICvdwoEPdSEr2ciry/GqiXpQR6GSHAm+UEehkpEPdLJHo5DagXYK7NSwR6uUWANysI9HKrQNyvkujldKBegLk2rxLo5XYB3rxGoJc7BOJ+nUQvZwD1Asy1eZ1AL6MEePMGgV7uEoj7TRK9nAnUCzDX5k0CvdwjwJu3CPRyr0Dcb5Po5SygXoC5Nm8T6GWMAG/WE+hlrEDc75HopRVQL8Bcm/cI9DJOgDcfEuhlvEDcH5HopTVQL8Bcm48I9HK/AG82EuhlokDcm0j0cjby9y2AetlEoJcHBXizhUAvDwnEvZVEL22Qv8cL1MtWAr08LMCbzwj08ohA3J+T6KUtUC/AXJvPCfQyWYA3XxDo5TGBuL8k0cs5QL0Ac22+JNDLVAHefEOgl8cF4v6WRC/tgHoB5tp8S6CX6QK8+Y5ALzME4v6eRC/tgXoB5tp8T6CXJwV48yOBXmYKxP0TiV46APUCzLX5iUAvswR48yuBXp4WiPs3Er10BOoFmGvzG4Fe5gjwZg+BXuYKxL2XRC/nAvUCzLXZS6CXZwV4k/KAfr08JxB36gMcejkP+XvouJhNqnLeWL3MF+BNOoFeFgjEnUGil/OR+zcC9ZJBoJeFArwpRKCXRQJxFybRSyegXoC5NoUJ9PKCAG+KEehliUDcxUn0cgFQL8Bcm+IEelkmwJtSBHp5USDu0iR6uRCoF2CuTWkCvbwkwJsogV5eFoi7LIleLgLqBZhrU5ZALysEeHMYgV5eFYj7cBK9dAbqBZhrcziBXlYJ8OYIAr28JhD3kSR66QLUCzDX5kgCvawW4M1RBHpZIxD30SR6uRioF2CuzdEEenlTgDfVCPSyViDuY0j0cgly/1ygXo4h0MtbArypQaCXtwXirkmil0uBegHm2kjhh85zV5L9dLqR9LM7ST97kPSzJ0k/c0j6mUvSz14k/byMpJ+9Sfp5OUk/+5D0sy9JP/uR9LM/ST8HCPUzNaaf2eEOkwKMeSBJzKnAmK8gibkAMOZBJDGnAWMeTBJzOjDmPJKYM4AxDyGJ+QxgzFeSxFy8KS7mq0hiLgGM+WqSmEsCYx5KEnMpYMzXkMRcGhjztSQxlwHGfB1JzFnAmK8niTkKjPkGkpjLAmMeRhJzOWDMw0liLg+M+UaSmA8DxnwTScyHA2MeQRJzBWDMI0lirgiM+WaSmI8AxnwLScxHAmO+lSTmSsCYbyOJuTIw5ttJYj4KGPMdJDEfDYz5TpKYqwBjHkUSc1VgzHeRxFwNGPPdJDEfA4z5HpKYjwXGfC9JzNWBMY8mibkGMOYxJDHXBMY8liTm44Ax30cScy1gzONIYj4eGPN4kphPAMY8gSTmE4Ex308SczYw5okkMRtgzA+QxPxVE1zMD7Jc7wnM80MkMdcGxjyJJOY6wJgfJom5LjDmR0hiPgkY86MkMZ8MjHkyScz1gDE/RhJzfWDMU0hibgCMeSpJzA2BMT9OEnMjYMzTSGJuDIx5OknMTYAxzyCJuSkw5idIYm4GjPlJkpibA2OeSRJzC2DMT5HEfAow5lkkMbcExvw0ScynAmOeTRLzacCY55DEfDow5rks90sCY36GJOYzgTE/SxLzWcCYnyOJuRUw5nkkMbcGxjyfJOazgTEvIIm5DTDm50libguMeSFJzOcAY15EEnM7YMyLSWJuD4z5BZKYOwBjXkISc0dgzEtJYj4XGPMykpjPA8b8IknM5wNjXk4ScydgzC+RxHwBMOaXSWK+EBjzKyQxXwSMeQVJzJ2BMb9KEnMXYMwrSWK+GBjzKpKYLwHG/BpJzJcCY36dJOauwJhXk8TcDRjzGpKYuwNjfoMk5h7AmN8kibknMOa1JDHnAGNeRxJzLjDmt0hi7gWM+W2SmC8DxvwOScy9gTG/SxLz5cCY15PE3AcY83skMfcFxvw+Scz9gDF/QBJzf2DMH5LEPAAY80ckMWdGcDF/TBJzQWDMG0hiLgSMeSNJzIWBMW8iibkIMObNJDEXBcb8CUnMxYAxbyGJuTgw5q0kMZcAxryNJOaSwJg/JYm5FDDmz0hiLg2M+XOSmMsAY95OEnMWMOYdJDFHgTF/AYy5nN9Oih+z3RPS7pFo9wy0e+hZP2j9kfULtn629aStr2y9YedfOx/Z8dmOV1a/ls82vzbest5/5RxMr/Ef7Z6gdo9Mu2ek3UPR7ilo99ize87ZPdjsnmR2jy67Z5Xdw8nuaWT3+LF73tg9YOyeKHaPELtnht1Dwu6pYPcYsL+5b3+D3v4mu/2Ncvub3fY3rO1vOtvfOLa/+Wt/A9f+Jqz9jVT7m6H2NzTtb0ra31i0vzlof4PP/iad/Y02+5tl9je87G9a2d94sr95ZH8DyP4mjv2NGPubKfY3ROxvatjfmLC/uWB/g8Dek2/vUbf3bNt7mO09vfYeV3vPp70H0t4TaO+Rs/eM2Xuo7D1F9h4be8+JvQfD3pNgr9G316zba7jtNc32Gl97zau9BtReE2mvEbTXzNlryOw1VfYaI3vNjb0GxV6TYa9RsN/Z2++w7Xe69jtO+52f/Q7MfidkvyOx3xnYNXS7pmzXWO2ao12Ds2tSdo3GrllYD289rfV41vNYD2BrYlsj2prJ1hB2TrVzjB1z7RhkNWk5Ws3JfUP/sbH/2DFvwKBuvXIqD+47IK9yduX+3v+79e074KqcnidUdl8bXLnfkMF5lQfndRuUVzl30IB+lc0J9u+3Vd7XTj2/vZbd+lce0L/v0MqDcvoNuDKncjfbZE7lvMu65VW+rNvgyt1zcvp7r3Xrua+RvMu85nPy/mrqiaNhTe2oCmuq9bGwpr6sAWvq9lqwpqqfCGtqpYE1lVsX1lR6PVhTUxvAmmrZGNaU1T+oqRtbwJqqfCqsqWWnw5q65CxYU3taw5p6qC2sqUbtYU191BHW1NDzYU2VvxDW1ILOsKbOvwTW1I9dYU3d1wPWVJ1cWFNvXwZr6oo+sKZK9oc1NXsgrKmPrtjXRAm/qVO69e3Wv4f3twMGVPbKNHvq439+y4Z/fss2/y2IwvD/AaLX89RZLYQA", + "verificationKey": "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" + } + ], + "debug": { + "debugSymbols": [ + "eJyrVsrJT04syczPK1ayqq6tBQAz9wY7", + "eJyrVsrJT04syczPK1ayqq6tBQAz9wY7", + "eJyrVsrJT04syczPK1ayqq6tBQAz9wY7", + "eJyrVsrJT04syczPK1ayqq6tBQAz9wY7", + "eJyrVsrJT04syczPK1ayqq6tBQAz9wY7" + ], + "fileMap": {} + } +} diff --git a/yarn-project/boxes/private-token/src/assets/aztec_logo.svg b/yarn-project/boxes/private-token/src/assets/aztec_logo.svg new file mode 100644 index 00000000000..64a3648326d --- /dev/null +++ b/yarn-project/boxes/private-token/src/assets/aztec_logo.svg @@ -0,0 +1,8 @@ + + + + + + + + diff --git a/yarn-project/boxes/private-token/src/assets/favicon.ico b/yarn-project/boxes/private-token/src/assets/favicon.ico new file mode 100644 index 00000000000..1c85cef482e Binary files /dev/null and b/yarn-project/boxes/private-token/src/assets/favicon.ico differ diff --git a/yarn-project/boxes/private-token/src/config.ts b/yarn-project/boxes/private-token/src/config.ts new file mode 100644 index 00000000000..264052da3a4 --- /dev/null +++ b/yarn-project/boxes/private-token/src/config.ts @@ -0,0 +1,14 @@ +import { AztecRPC, createAztecRpcClient } from '@aztec/aztec.js'; +import { ContractAbi } from '@aztec/foundation/abi'; +import { PrivateTokenContractAbi } from './artifacts/PrivateToken.js'; // update this if using a different contract + +export const contractAbi: ContractAbi = PrivateTokenContractAbi; + +const SANDBOX_URL: string = process.env.SANDBOX_URL || 'http://localhost:8080'; +export const rpcClient: AztecRPC = createAztecRpcClient(SANDBOX_URL); + +export const CONTRACT_ADDRESS_PARAM_NAMES = ['owner', 'contract_address', 'recipient']; +export const FILTERED_FUNCTION_NAMES = ['compute_note_hash_and_nullifier']; + +// ALICE smart contract wallet public key, available on sandbox by default +export const DEFAULT_PUBLIC_ADDRESS: string = '0x0c8a6673d7676cc80aaebe7fa7504cf51daa90ba906861bfad70a58a98bf5a7d'; diff --git a/yarn-project/boxes/private-token/src/contracts/Nargo.toml b/yarn-project/boxes/private-token/src/contracts/Nargo.toml new file mode 100644 index 00000000000..a5e601e1620 --- /dev/null +++ b/yarn-project/boxes/private-token/src/contracts/Nargo.toml @@ -0,0 +1,9 @@ +[package] +name = "private_token_contract" +authors = [""] +compiler_version = "0.1" +type = "contract" + +[dependencies] +aztec = { git="https://github.com/AztecProtocol/aztec-packages", tag="master", directory="yarn-project/noir-libs/noir-aztec" } +value_note = { git="https://github.com/AztecProtocol/aztec-packages", tag="master", directory="yarn-project/noir-libs/value-note" } \ No newline at end of file diff --git a/yarn-project/boxes/private-token/src/contracts/src/interface.nr b/yarn-project/boxes/private-token/src/contracts/src/interface.nr new file mode 100644 index 00000000000..1eee266adcb --- /dev/null +++ b/yarn-project/boxes/private-token/src/contracts/src/interface.nr @@ -0,0 +1,67 @@ +/* Autogenerated file, do not edit! */ + +use dep::std; +use dep::aztec::context::{ PrivateContext, PublicContext }; +use dep::aztec::constants_gen::RETURN_VALUES_LENGTH; + + + +// Interface for calling PrivateToken functions from a private context +struct PrivateTokenPrivateContextInterface { + address: Field, +} + +impl PrivateTokenPrivateContextInterface { + fn at(address: Field) -> Self { + Self { + address, + } + } + + fn mint( + self, + context: &mut PrivateContext, + amount: Field, + owner: Field + ) -> [Field; RETURN_VALUES_LENGTH] { + let mut serialised_args = [0; 2]; + serialised_args[0] = amount; + serialised_args[1] = owner; + + context.call_private_function(self.address, 0x1535439c, serialised_args) + } + + + fn transfer( + self, + context: &mut PrivateContext, + amount: Field, + recipient: Field + ) -> [Field; RETURN_VALUES_LENGTH] { + let mut serialised_args = [0; 2]; + serialised_args[0] = amount; + serialised_args[1] = recipient; + + context.call_private_function(self.address, 0xc0888d22, serialised_args) + } + +} + + + + +// Interface for calling PrivateToken functions from a public context +struct PrivateTokenPublicContextInterface { + address: Field, +} + +impl PrivateTokenPublicContextInterface { + fn at(address: Field) -> Self { + Self { + address, + } + } + +} + + diff --git a/yarn-project/boxes/private-token/src/contracts/src/main.nr b/yarn-project/boxes/private-token/src/contracts/src/main.nr new file mode 100644 index 00000000000..292d2e7e704 --- /dev/null +++ b/yarn-project/boxes/private-token/src/contracts/src/main.nr @@ -0,0 +1,101 @@ +contract PrivateToken { + use dep::std::option::Option; + use dep::value_note::{ + balance_utils, + utils::{increment, decrement}, + value_note::{VALUE_NOTE_LEN, ValueNote, ValueNoteMethods}, + }; + use dep::aztec::{ + context::{PrivateContext, PublicContext, Context}, + note::{ + note_header::NoteHeader, + utils as note_utils, + }, + state_vars::{map::Map, set::Set}, + }; + + struct Storage { + // maps an aztec address to its balance + balances: Map>, + } + + impl Storage { + fn init(context: Context) -> pub Self { + Storage { + balances: Map::new( + context, + 1, // Storage slot + |context, slot| { + Set::new(context, slot, ValueNoteMethods) + }, + ), + } + } + } + + // Constructs the contract and sets `initial_supply` which is fully owned by `owner`. + #[aztec(private)] + fn constructor( + initial_supply: Field, + owner: Field + ) { + let storage = Storage::init(Context::private(&mut context)); + // Insert new note to a set of user notes and emit the newly created encrypted note preimage via oracle call. + let owner_balance = storage.balances.at(owner); + if (initial_supply != 0) { + increment(owner_balance, initial_supply, owner); + } + } + + // Mints `amount` of tokens to `owner`. + #[aztec(private)] + fn mint( + amount: Field, + owner: Field + ) { + let storage = Storage::init(Context::private(&mut context)); + + // Insert new note to a set of user notes and emit the newly created encrypted note preimage via oracle call. + let owner_balance = storage.balances.at(owner); + increment(owner_balance, amount, owner); + } + + // Transfers `amount` of tokens from msg_sender to a `recipient`. + #[aztec(private)] + fn transfer( + amount: Field, + recipient: Field, + ) { + let storage = Storage::init(Context::private(&mut context)); + let sender = context.msg_sender(); + + // Pick from the set of sender's notes to spend amount. + let sender_balance = storage.balances.at(sender); + decrement(sender_balance, amount, sender); + + // Creates new note for the recipient. + let recipient_balance = storage.balances.at(recipient); + increment(recipient_balance, amount, recipient); + } + + // Helper function to get the balance of a user ("unconstrained" is a Noir alternative of Solidity's "view" function). + unconstrained fn getBalance( + owner: Field, + ) -> Field { + let storage = Storage::init(Context::none()); + + // Get the set of notes owned by the user. + let owner_balance = storage.balances.at(owner); + + // Return the sum of all notes in the set. + balance_utils::get_balance(owner_balance) + } + + // Computes note hash and nullifier. + // Note 1: Needs to be defined by every contract producing logs. + // Note 2: Having it in all the contracts gives us the ability to compute the note hash and nullifier differently for different kind of notes. + unconstrained fn compute_note_hash_and_nullifier(contract_address: Field, nonce: Field, storage_slot: Field, preimage: [Field; VALUE_NOTE_LEN]) -> [Field; 4] { + let note_header = NoteHeader { contract_address, nonce, storage_slot }; + note_utils::compute_note_hash_and_nullifier(ValueNoteMethods, note_header, preimage) + } +} \ No newline at end of file diff --git a/yarn-project/boxes/private-token/src/scripts/call_contract_function.ts b/yarn-project/boxes/private-token/src/scripts/call_contract_function.ts new file mode 100644 index 00000000000..04fa7209f23 --- /dev/null +++ b/yarn-project/boxes/private-token/src/scripts/call_contract_function.ts @@ -0,0 +1,30 @@ +import { AztecAddress, AztecRPC, CompleteAddress, Contract } from '@aztec/aztec.js'; +import { ContractAbi } from '@aztec/foundation/abi'; +import { getWallet } from './util.js'; + +export async function callContractFunction( + address: AztecAddress, + abi: ContractAbi, + functionName: string, + typedArgs: any[], // for the exposed functions, this is an array of field elements Fr[] + rpc: AztecRPC, + wallet: CompleteAddress, +) { + // selectedWallet is how we specify the "sender" of the transaction + const selectedWallet = await getWallet(wallet, rpc); + + // TODO: switch to the generated typescript class? + const contract = await Contract.at(address, abi, selectedWallet); + + const returnVal = await contract.methods[functionName](...typedArgs) + .send() + .wait(); + + if (returnVal.error) { + throw new Error(returnVal.error); + } + + return `Transaction (${returnVal.txHash}) ${returnVal.status} on block ${ + returnVal.blockNumber + } (hash ${returnVal.blockHash?.toString('hex')})!`; +} diff --git a/yarn-project/boxes/private-token/src/scripts/deploy_contract.ts b/yarn-project/boxes/private-token/src/scripts/deploy_contract.ts new file mode 100644 index 00000000000..2285937d2e1 --- /dev/null +++ b/yarn-project/boxes/private-token/src/scripts/deploy_contract.ts @@ -0,0 +1,22 @@ +import { AztecAddress, CompleteAddress, DeployMethod, Fr } from '@aztec/aztec.js'; +import { ContractAbi } from '@aztec/foundation/abi'; +import { AztecRPC } from '@aztec/types'; + +export async function deployContract( + activeWallet: CompleteAddress, + contractAbi: ContractAbi, + typedArgs: Fr[], // encode prior to passing in + salt: Fr, + client: AztecRPC, +): Promise { + const tx = new DeployMethod(activeWallet.publicKey, client, contractAbi, typedArgs).send({ + contractAddressSalt: salt, + }); + await tx.wait(); + const receipt = await tx.getReceipt(); + if (receipt.contractAddress) { + return receipt.contractAddress; + } else { + throw new Error(`Contract not deployed (${receipt.toJSON()})`); + } +} diff --git a/yarn-project/boxes/private-token/src/scripts/index.ts b/yarn-project/boxes/private-token/src/scripts/index.ts new file mode 100644 index 00000000000..a5d6bcf1a9b --- /dev/null +++ b/yarn-project/boxes/private-token/src/scripts/index.ts @@ -0,0 +1,4 @@ +export * from './call_contract_function.js'; +export * from './deploy_contract.js'; +export { getWallet } from './util.js'; +export * from './view_contract_function.js'; diff --git a/yarn-project/boxes/private-token/src/scripts/util.ts b/yarn-project/boxes/private-token/src/scripts/util.ts new file mode 100644 index 00000000000..b5f8f09d0d0 --- /dev/null +++ b/yarn-project/boxes/private-token/src/scripts/util.ts @@ -0,0 +1,37 @@ +import { AccountWallet, Fr, getSandboxAccountsWallets } from '@aztec/aztec.js'; +import { FunctionAbi, encodeArguments } from '@aztec/foundation/abi'; +import { AztecRPC, CompleteAddress } from '@aztec/types'; + +export function convertArgs(functionAbi: FunctionAbi, args: any): Fr[] { + const untypedArgs = functionAbi.parameters.map(param => { + switch (param.type.kind) { + case 'field': + // hack: addresses are stored as string in the form to avoid bigint compatibility issues with formik + // convert those back to bigints before turning into Fr + return BigInt(args[param.name]); + default: + // they are all fields in the privatetoken contract, need more testing on other types + return args[param.name]; + } + }); + + const typedArgs = encodeArguments(functionAbi, untypedArgs); + return typedArgs; +} + +/** + * terminology is confusing, but the `account` points to a smart contract's public key information + * while the "wallet" has the account's private key and is used to sign transactions + * we need the "wallet" to actually submit transactions using the "account" identity + * @param account + * @param rpc + * @returns + */ +export async function getWallet(account: CompleteAddress, rpc: AztecRPC): Promise { + const accountWallets: AccountWallet[] = await getSandboxAccountsWallets(rpc); + const selectedWallet: AccountWallet = accountWallets.find(w => w.getAddress().equals(account.address))!; + if (!selectedWallet) { + throw new Error(`Wallet for account ${account.address.toShortString()} not found in the RPC server.`); + } + return selectedWallet; +} diff --git a/yarn-project/boxes/private-token/src/scripts/view_contract_function.ts b/yarn-project/boxes/private-token/src/scripts/view_contract_function.ts new file mode 100644 index 00000000000..2d0e47d2d2c --- /dev/null +++ b/yarn-project/boxes/private-token/src/scripts/view_contract_function.ts @@ -0,0 +1,20 @@ +import { AztecAddress, AztecRPC, CompleteAddress, Contract } from '@aztec/aztec.js'; +import { ContractAbi } from '@aztec/foundation/abi'; +import { getWallet } from './util.js'; + +export async function viewContractFunction( + address: AztecAddress, + abi: ContractAbi, + functionName: string, + typedArgs: any[], + rpc: AztecRPC, + wallet: CompleteAddress, +) { + // we specify the account that is calling the view function by passing in the wallet to the Contract + const selectedWallet = await getWallet(wallet, rpc); + const contract = await Contract.at(address, abi, selectedWallet); + + // TODO: see if we can remove the {from: wallet.address}? + const viewResult = await contract.methods[functionName](...typedArgs).view({ from: wallet.address }); + return viewResult; +} diff --git a/yarn-project/boxes/private-token/src/tests/privatetoken.frontend.test.ts b/yarn-project/boxes/private-token/src/tests/privatetoken.frontend.test.ts new file mode 100644 index 00000000000..fa067e3e25a --- /dev/null +++ b/yarn-project/boxes/private-token/src/tests/privatetoken.frontend.test.ts @@ -0,0 +1,144 @@ +import { + AccountWallet, + AztecAddress, + AztecRPC, + CompleteAddress, + Contract, + Fr, + Wallet, + createAztecRpcClient, + makeFetch, + waitForSandbox, +} from '@aztec/aztec.js'; +import { FunctionAbi } from '@aztec/foundation/abi'; +import { createDebugLogger } from '@aztec/foundation/log'; +import { PrivateTokenContract } from '../artifacts/PrivateToken.js'; +import { rpcClient } from '../config.js'; +import { callContractFunction, deployContract, getWallet, viewContractFunction } from '../scripts/index.js'; +import { convertArgs } from '../scripts/util.js'; + +const logger = createDebugLogger('aztec:http-rpc-client'); + +const INITIAL_BALANCE = 444n; +const TRANSFER_AMOUNT = 44n; +const MINT_AMOUNT = 11n; + +// assumes sandbox is running locally, which this script does not trigger +// as well as anvil. anvil can be started with yarn test:integration +const setupSandbox = async () => { + const { SANDBOX_URL = 'http://localhost:8080' } = process.env; + const aztecRpc = createAztecRpcClient(SANDBOX_URL, makeFetch([1, 2, 3], true)); + await waitForSandbox(aztecRpc); + return aztecRpc; +}; + +const getFunctionAbi = (contractAbi: any, functionName: string) => { + const functionAbi = contractAbi.functions.find((f: FunctionAbi) => f.name === functionName); + if (!functionAbi) throw new Error(`Function ${functionName} not found in abi`); + return functionAbi; +}; + +async function deployZKContract(owner: CompleteAddress, wallet: Wallet, rpcClient: AztecRPC) { + logger('Deploying PrivateToken contract...'); + const constructorArgs = { + // eslint-disable-next-line camelcase + initial_supply: INITIAL_BALANCE, + owner: owner.address, + }; + const constructorAbi = getFunctionAbi(PrivateTokenContract.abi, 'constructor'); + const typedArgs = convertArgs(constructorAbi, constructorArgs); + + const contractAddress = await deployContract(owner, PrivateTokenContract.abi, typedArgs, Fr.random(), rpcClient); + + logger(`L2 contract deployed at ${contractAddress}`); + const contract = await PrivateTokenContract.at(contractAddress, wallet); + return contract; +} + +async function getBalance(contractAddress: AztecAddress, privateTokenContract: Contract, owner: CompleteAddress) { + const getBalanceAbi = getFunctionAbi(PrivateTokenContract.abi, 'getBalance'); + const viewArgs = { owner: owner.address }; + const typedArgs = convertArgs(getBalanceAbi, viewArgs); + + return await viewContractFunction( + contractAddress, + privateTokenContract.abi, + 'getBalance', + typedArgs, + rpcClient, + owner, + ); +} + +async function mint( + contractAddress: AztecAddress, + privateTokenContract: Contract, + from: CompleteAddress, + to: CompleteAddress, + amount: bigint, +) { + const getBalanceAbi = getFunctionAbi(PrivateTokenContract.abi, 'mint'); + const mintArgs = { amount, owner: to.address }; + const typedArgs = convertArgs(getBalanceAbi, mintArgs); + + return await callContractFunction(contractAddress, privateTokenContract.abi, 'mint', typedArgs, rpcClient, from); +} + +async function transfer( + contractAddress: AztecAddress, + privateTokenContract: Contract, + from: CompleteAddress, + to: CompleteAddress, + amount: bigint, +) { + const getBalanceAbi = getFunctionAbi(PrivateTokenContract.abi, 'transfer'); + const transferArgs = { amount, recipient: to.address }; + const typedArgs = convertArgs(getBalanceAbi, transferArgs); + + return await callContractFunction(contractAddress, privateTokenContract.abi, 'transfer', typedArgs, rpcClient, from); +} + +describe('ZK Contract Tests', () => { + let wallet: AccountWallet; + let owner: CompleteAddress; + let account2: CompleteAddress; + let _account3: CompleteAddress; + let privateTokenContract: Contract; + let contractAddress: AztecAddress; + let rpcClient: AztecRPC; + + beforeAll(async () => { + rpcClient = await setupSandbox(); + const accounts = await rpcClient.getAccounts(); + [owner, account2, _account3] = accounts; + + wallet = await getWallet(owner, rpcClient); + + privateTokenContract = await deployZKContract(owner, wallet, rpcClient); + contractAddress = privateTokenContract.address; + }, 60000); + + test('Initial balance is correct', async () => { + const balance = await getBalance(contractAddress, privateTokenContract, owner); + expect(balance).toEqual(INITIAL_BALANCE); + }, 40000); + + test('Balance after mint is correct', async () => { + const mintTx = mint(contractAddress, privateTokenContract, owner, owner, MINT_AMOUNT); + await mintTx; + + const balanceAfterMint = await getBalance(contractAddress, privateTokenContract, owner); + expect(balanceAfterMint).toEqual(INITIAL_BALANCE + MINT_AMOUNT); + }, 40000); + + test('Balance after transfer is correct for both sender and receiver', async () => { + const transferTx = transfer(contractAddress, privateTokenContract, owner, account2, TRANSFER_AMOUNT); + await transferTx; + + const balanceAfterTransfer = await getBalance(contractAddress, privateTokenContract, owner); + expect(balanceAfterTransfer).toEqual(INITIAL_BALANCE + MINT_AMOUNT - TRANSFER_AMOUNT); + + const receiverBalance = await getBalance(contractAddress, privateTokenContract, account2); + expect(receiverBalance).toEqual(TRANSFER_AMOUNT); + }, 40000); +}); diff --git a/yarn-project/boxes/private-token/tailwind.config.cjs b/yarn-project/boxes/private-token/tailwind.config.cjs new file mode 100644 index 00000000000..25a9d03b9ac --- /dev/null +++ b/yarn-project/boxes/private-token/tailwind.config.cjs @@ -0,0 +1,39 @@ +module.exports = { + content: ['./src/app/**/*.{html,tsx}'], + theme: { + extend: { + colors: { + 'aztec-purple': '#646cff', + }, + animation: { + marquee: 'marquee 120s linear infinite', + marquee2: 'marquee2 120s linear infinite', + marquee3: 'marquee3 120s linear infinite', + marquee4: 'marquee4 120s linear infinite', + }, + keyframes: { + marquee: { + '0%': { transform: 'translateX(0%)' }, + '100%': { transform: 'translateX(-100%)' }, + }, + marquee2: { + '0%': { transform: 'translateX(100%)' }, + '100%': { transform: 'translateX(0%)' }, + }, + marquee3: { + '0%': { transform: 'translateX(-100%)' }, + '100%': { transform: 'translateX(0%)' }, + }, + marquee4: { + '0%': { transform: 'translateX(0%)' }, + '100%': { transform: 'translateX(100%)' }, + }, + }, + backgroundImage: { + 'gradient-radial': 'radial-gradient(var(--tw-gradient-stops))', + 'gradient-conic': 'conic-gradient(from 180deg at 50% 50%, var(--tw-gradient-stops))', + }, + }, + }, + plugins: [], +}; diff --git a/yarn-project/boxes/private-token/tsconfig.dest.json b/yarn-project/boxes/private-token/tsconfig.dest.json new file mode 100644 index 00000000000..d388fae5337 --- /dev/null +++ b/yarn-project/boxes/private-token/tsconfig.dest.json @@ -0,0 +1,12 @@ +{ + "extends": ".", + "references": [ + { "path": "../../aztec.js" }, + { "path": "../../cli" }, + { "path": "../../foundation" }, + { "path": "../../noir-compiler" }, + { "path": "../../noir-contracts" }, + { "path": "../../types" } + ], + "exclude": ["src/**/*.test.ts"] +} diff --git a/yarn-project/boxes/private-token/tsconfig.json b/yarn-project/boxes/private-token/tsconfig.json new file mode 100644 index 00000000000..5d087f2521d --- /dev/null +++ b/yarn-project/boxes/private-token/tsconfig.json @@ -0,0 +1,52 @@ +{ + "compilerOptions": { + "rootDir": "src", + "outDir": "dest", + "tsBuildInfoFile": ".tsbuildinfo", + "target": "es2020", + "lib": [ + "esnext", + "dom", + "DOM.Iterable" + ], + "module": "NodeNext", + "moduleResolution": "NodeNext", + "strict": true, + "declaration": true, + "allowSyntheticDefaultImports": true, + "allowJs": true, + "esModuleInterop": true, + "downlevelIteration": true, + "inlineSourceMap": true, + "declarationMap": true, + "importHelpers": true, + "resolveJsonModule": true, + "composite": true, + "skipLibCheck": true, + "jsx": "react-jsx" + }, + "include": [ + "src", + "src/**/*.json" + ], + "references": [ + { + "path": "../../aztec.js" + }, + { + "path": "../../circuits.js" + }, + { + "path": "../../cli" + }, + { + "path": "../../foundation" + }, + { + "path": "../../noir-compiler" + }, + { + "path": "../../types" + } + ] +} diff --git a/yarn-project/boxes/private-token/webpack.config.js b/yarn-project/boxes/private-token/webpack.config.js new file mode 100644 index 00000000000..e65a4134d91 --- /dev/null +++ b/yarn-project/boxes/private-token/webpack.config.js @@ -0,0 +1,95 @@ +import CopyWebpackPlugin from 'copy-webpack-plugin'; +import { createRequire } from 'module'; +import { dirname, resolve } from 'path'; +import ResolveTypeScriptPlugin from 'resolve-typescript-plugin'; +import { fileURLToPath } from 'url'; +import webpack from 'webpack'; + +const require = createRequire(import.meta.url); + +export default (_, argv) => ({ + target: 'web', + mode: 'production', + devtool: false, + entry: { + main: './src/app/index.tsx', + }, + module: { + rules: [ + { + test: /\.tsx?$/, + use: [ + { + loader: 'ts-loader', + options: { + configFile: 'tsconfig.dest.json', + }, + }, + ], + }, + { + test: /\.css$/i, + use: ['style-loader', 'css-loader', 'postcss-loader'], + }, + ], + }, + output: { + path: resolve(dirname(fileURLToPath(import.meta.url)), './dest'), + filename: 'index.js', + }, + plugins: [ + new webpack.DefinePlugin({ + 'process.env': { + NODE_ENV: JSON.stringify(argv.mode || 'production'), + }, + }), + new webpack.ProvidePlugin({ Buffer: ['buffer', 'Buffer'] }), + new CopyWebpackPlugin({ + patterns: [ + { + from: `${dirname(require.resolve(`@aztec/circuits.js`)).replace( + /\/dest$/, + '', + )}/resources/aztec3-circuits.wasm`, + to: 'aztec3-circuits.wasm', + }, + { + from: './src/assets', + }, + { + from: './src/app/index.html', + to: 'index.html', + }, + ], + }), + ], + resolve: { + plugins: [new ResolveTypeScriptPlugin()], + alias: { + // All node specific code, wherever it's located, should be imported as below. + // Provides a clean and simple way to always strip out the node code for the web build. + './node/index.js': false, + }, + fallback: { + crypto: false, + os: false, + fs: false, + path: false, + url: false, + worker_threads: false, + events: require.resolve('events/'), + buffer: require.resolve('buffer/'), + util: require.resolve('util/'), + stream: require.resolve('stream-browserify'), + string_decoder: require.resolve('string_decoder/'), + tty: require.resolve('tty-browserify'), + }, + }, + devServer: { + port: 5173, + historyApiFallback: true, + client: { + overlay: false, + }, + }, +}); diff --git a/yarn-project/cli/package.json b/yarn-project/cli/package.json index fe7da02af0b..8a9dce35fdf 100644 --- a/yarn-project/cli/package.json +++ b/yarn-project/cli/package.json @@ -41,7 +41,9 @@ "@aztec/noir-contracts": "workspace:^", "@aztec/types": "workspace:^", "commander": "^9.0.0", + "jszip": "^3.10.1", "lodash.startcase": "^4.4.0", + "node-fetch": "^3.3.2", "semver": "^7.5.4", "tslib": "^2.4.0", "viem": "^1.2.5" diff --git a/yarn-project/cli/src/index.ts b/yarn-project/cli/src/index.ts index a597a07e21f..90bdaf8eb23 100644 --- a/yarn-project/cli/src/index.ts +++ b/yarn-project/cli/src/index.ts @@ -24,6 +24,7 @@ import { mnemonicToAccount } from 'viem/accounts'; import { createCompatibleClient } from './client.js'; import { encodeArgs, parseStructString } from './encoding.js'; +import { unboxContract } from './unbox.js'; import { deployAztecContracts, getAbiFunction, @@ -474,6 +475,18 @@ export function getProgram(log: LogFn, debugLogger: DebugLogger): Command { names.forEach(name => log(name)); }); + program + .command('unbox') + .description( + 'Unboxes an example contract from @aztec/boxes. Also Copies `noir-libs` dependencies and setup simple frontend for the contract using its ABI.', + ) + .argument('', 'Name of the contract to unbox, e.g. "PrivateToken"') + .argument('[localDirectory]', 'Local directory to unbox to (relative or absolute), defaults to ``') + .action(async (contractName, localDirectory) => { + const unboxTo: string = localDirectory ? localDirectory : contractName; + await unboxContract(contractName, unboxTo, version, log); + }); + program .command('get-node-info') .description('Gets the information of an aztec node at a URL.') diff --git a/yarn-project/cli/src/unbox.ts b/yarn-project/cli/src/unbox.ts new file mode 100644 index 00000000000..4202b080db6 --- /dev/null +++ b/yarn-project/cli/src/unbox.ts @@ -0,0 +1,303 @@ +// inspired by https://github.com/trufflesuite/truffle/blob/develop/packages/box/lib/utils/unbox.ts +// however, their boxes are stored as standalone git repositories, while ours are subpackages in a monorepo +// so we do some hacky conversions post copy to make them work as standalone packages. +// We download the master branch of the monorepo, and then +// (1) copy "boxes/{CONTRACT_NAME}" subpackage to the specified output directory +// (2) if the box doesnt include noir source code, we copy it from the "noir-contracts" subpackage to into a new subdirectory "X/src/contracts", +// These are used by a simple frontend to interact with the contract and deploy to a local sandbox instance of aztec3. +// The unbox logic can be tested locally by running `$ts-node --esm src/bin/index.ts unbox PrivateToken` +// from `yarn-project/cli/` +import { LogFn } from '@aztec/foundation/log'; + +import { promises as fs } from 'fs'; +import JSZip from 'jszip'; +import fetch from 'node-fetch'; +import * as path from 'path'; + +const GITHUB_OWNER = 'AztecProtocol'; +const GITHUB_REPO = 'aztec-packages'; +const NOIR_CONTRACTS_PATH = 'yarn-project/noir-contracts/src/contracts'; +const BOXES_PATH = 'yarn-project/boxes'; + +/** + * Converts a contract name in "upper camel case" to a folder name in snake case. + * @param contractName - The contract name. + * @returns The folder name. + * */ +function contractNameToFolder(contractName: string): string { + return contractName.replace(/[\w]([A-Z])/g, m => m[0] + '_' + m[1]).toLowerCase(); +} + +/** + * If the box contains the noir contract source code, we don't need to download it from github. + * Otherwise, we download the contract source code from the `noir-contracts` and `noir-libs` subpackages. + */ +async function isDirectoryNonEmpty(directoryPath: string): Promise { + const files = await fs.readdir(directoryPath); + return files.length > 0; +} + +/** + * + * @param data - in memory unzipped clone of a github repo + * @param repositoryFolderPath - folder to copy from github repo + * @param localOutputPath - local path to copy to + */ +async function copyFolderFromGithub(data: JSZip, repositoryFolderPath: string, localOutputPath: string, log: LogFn) { + log('downloading from github:', repositoryFolderPath); + const repositoryDirectories = Object.values(data.files).filter(file => { + return file.dir && file.name.startsWith(repositoryFolderPath); + }); + + for (const directory of repositoryDirectories) { + const relativePath = directory.name.replace(repositoryFolderPath, ''); + const targetPath = `${localOutputPath}/${relativePath}`; + await fs.mkdir(targetPath, { recursive: true }); + } + + const starterFiles = Object.values(data.files).filter(file => { + return !file.dir && file.name.startsWith(repositoryFolderPath); + }); + + for (const file of starterFiles) { + const relativePath = file.name.replace(repositoryFolderPath, ''); + const targetPath = `${localOutputPath}/${relativePath}`; + const content = await file.async('nodebuffer'); + await fs.writeFile(targetPath, content); + } +} + +/** + * Not flexible at at all, but quick fix to download a noir smart contract from our + * monorepo on github. this will copy over the `yarn-projects/boxes/{contract_name}` folder + * as well as the specified `directoryPath` if the box doesn't include source code + * `directoryPath` should point to a single noir contract in `yarn-projects/noir-contracts/src/contracts/...` + * @param tagVersion - the version of the CLI that is running. we pull from the corresponding tag in the monorepo + * @param directoryPath - path to a noir contract's source code (folder) in the github repo + * @param outputPath - local path that we will copy the noir contracts and web3 starter kit to + * @returns + */ +async function downloadContractAndBoxFromGithub( + tagVersion: string, + contractName: string, + outputPath: string, + log: LogFn, +): Promise { + // small string conversion, in the ABI the contract name looks like PrivateToken + // but in the repostory it looks like private_token + const snakeCaseContractName = contractNameToFolder(contractName); + + log(`Downloaded '@aztex/boxes/${snakeCaseContractName}' to ${outputPath}`); + // Step 1: Fetch the monorepo ZIP from GitHub, matching the CLI version + const url = `https://github.com/${GITHUB_OWNER}/${GITHUB_REPO}/archive/refs/tags/aztec-packages-v${tagVersion}.zip`; + const response = await fetch(url); + const buffer = await response.arrayBuffer(); + + const zip = new JSZip(); + const data = await zip.loadAsync(buffer); + + // Step 2: copy the '@aztec/boxes/{contract-name}' subpackage to the output directory + // this is currently only implemented for PrivateToken under 'boxes/private-token/' + const repoDirectoryPrefix = `${GITHUB_REPO}-v${tagVersion}/`; + + const boxPath = `${repoDirectoryPrefix}${BOXES_PATH}/${snakeCaseContractName}`; + await copyFolderFromGithub(data, boxPath, outputPath, log); + + const boxContainsNoirSource = await isDirectoryNonEmpty(`${outputPath}/src/contracts`); + if (boxContainsNoirSource) { + return; + } + // this remaining logic only kicks in if the box doesn't already have a src/contracts folder + // in which case we optimistically grab the noir source files from the + // noir-contracts and noir-libs subpackages and pray that the versions are compatible + + // source noir files for the contract are in this folder + const contractFolder = `${NOIR_CONTRACTS_PATH}/${snakeCaseContractName}_contract`; + // copy the noir contracts to the output directory under subdir /src/contracts/ + const contractDirectoryPath = `${repoDirectoryPrefix}${contractFolder}/`; + + const contractFiles = Object.values(data.files).filter(file => { + return !file.dir && file.name.startsWith(contractDirectoryPath); + }); + + const contractTargetDirectory = path.join(outputPath, 'src', 'contracts'); + await fs.mkdir(contractTargetDirectory, { recursive: true }); + // Nargo.toml file needs to be in the root of the contracts directory, + // and noir files in the src/ subdirectory + await fs.mkdir(path.join(contractTargetDirectory, 'src'), { recursive: true }); + for (const file of contractFiles) { + const targetPath = path.join(contractTargetDirectory, file.name.replace(contractDirectoryPath, '')); + log(`Copying ${file.name} to ${targetPath}`); + const content = await file.async('nodebuffer'); + await fs.writeFile(targetPath, content); + log(`Copied ${file.name} to ${targetPath}`); + } +} +/** + * Does some conversion from the package/build configurations in the monorepo to the + * something usable by the copied standalone unboxed folder. Adjusts relative paths + * and package versions. + * @param packageVersion - CLI npm version, which determines what npm version to grab + * @param outputPath - relative path where we are copying everything + * @param log - logger + */ +async function updatePackagingConfigurations(packageVersion: string, outputPath: string, log: LogFn): Promise { + await updatePackageJsonVersions(packageVersion, outputPath, log); + await updateTsConfig(outputPath, log); + await updateNargoToml(packageVersion, outputPath, log); +} + +/** + * adjust the contract Nargo.toml file to use the same repository version as the npm packages + * @param packageVersion - CLI npm version, which determines what npm version to grab + * @param outputPath - relative path where we are copying everything + * @param log - logger + */ +async function updateNargoToml(packageVersion: string, outputPath: string, log: LogFn): Promise { + const nargoTomlPath = path.join(outputPath, 'src', 'contracts', 'Nargo.toml'); + const fileContent = await fs.readFile(nargoTomlPath, 'utf-8'); + const lines = fileContent.split('\n'); + const updatedLines = lines.map(line => line.replace(/tag="master"/g, `tag="v${packageVersion}"`)); + const updatedContent = updatedLines.join('\n'); + await fs.writeFile(nargoTomlPath, updatedContent); + log(`Updated Nargo.toml to point to local copy of noir-libs`); +} + +/** + * The `tsconfig.json` also needs to be updated to remove the "references" section, which + * points to the monorepo's subpackages. Those are unavailable in the cloned subpackage, + * so we remove the entries to install the the workspace packages from npm. + * @param outputPath - directory we are unboxing to + */ +async function updateTsConfig(outputPath: string, log: LogFn) { + try { + const tsconfigJsonPath = path.join(outputPath, 'tsconfig.json'); + const data = await fs.readFile(tsconfigJsonPath, 'utf8'); + const config = JSON.parse(data); + + delete config.references; + + const updatedData = JSON.stringify(config, null, 2); + await fs.writeFile(tsconfigJsonPath, updatedData, 'utf8'); + + log('tsconfig.json has been updated'); + } catch (error) { + log('Error updating tsconfig.json:', error); + throw error; + } +} + +/** + * We pin to "workspace:^" in the package.json for subpackages, but we need to replace it with + * an the actual version number in the cloned starter kit + * We modify the copied package.json and pin to the version of the package that was downloaded + * @param packageVersion - CLI npm version, which determines what npm version to grab + * @param outputPath - directory we are unboxing to + * @param log - logger + */ +async function updatePackageJsonVersions(packageVersion: string, outputPath: string, log: LogFn): Promise { + const packageJsonPath = path.join(outputPath, 'package.json'); + const fileContent = await fs.readFile(packageJsonPath, 'utf-8'); + const packageData = JSON.parse(fileContent); + + // Check and replace "workspace^" pins in dependencies, which are monorepo yarn workspace references + if (packageData.dependencies) { + for (const [key, value] of Object.entries(packageData.dependencies)) { + if (value === 'workspace:^') { + packageData.dependencies[key] = `^${packageVersion}`; + } + } + } + + // Check and replace in devDependencies + if (packageData.devDependencies) { + for (const [key, value] of Object.entries(packageData.devDependencies)) { + if (value === 'workspace:^') { + // TODO: check if this right post landing. the package.json version looks like 0.1.0 + // but the npm versions look like v0.1.0-alpha63 so we are not fully pinned + packageData.devDependencies[key] = `^${packageVersion}`; + } + } + } + + // modify the version of the sandbox to pull - it's set to "latest" version in the monorepo, + // but we need to replace with the same tagVersion as the cli and the other aztec npm packages + // similarly, make sure we spinup the sandbox with the same version. + packageData.scripts['install:sandbox'] = packageData.scripts['install:sandbox'].replace( + 'latest', + `v${packageVersion}`, + ); + + packageData.scripts['start:sandbox'] = packageData.scripts['start:sandbox'].replace('latest', `v${packageVersion}`); + + // Convert back to a string and write back to the package.json file + const updatedContent = JSON.stringify(packageData, null, 2); + await fs.writeFile(packageJsonPath, updatedContent); + + log(`Updated package.json versions to ${packageVersion}`); +} + +/** + * + * @param outputDirectoryName - user specified directory we are "unboxing" files into + * @param log - logger + * @returns + */ +async function createDirectory(outputDirectoryName: string, log: LogFn): Promise { + const absolutePath = path.resolve(outputDirectoryName); + + try { + // Checking if the path exists and if it is a directory + const stats = await fs.stat(absolutePath); + if (!stats.isDirectory()) { + throw new Error(`The specified path ${outputDirectoryName} is not a directory/folder.`); + } + } catch (error: any) { + if (error.code === 'ENOENT') { + await fs.mkdir(absolutePath, { recursive: true }); + log(`The directory did not exist and has been created: ${absolutePath}`); + } else { + throw error; + } + } + + return absolutePath; +} + +/** + * Unboxes a contract from `@aztec/boxes` by performing the following operations: + * 1. Copies the frontend template from `@aztec/boxes/{contract_name}` to the outputDirectory + * 2. Checks if the contract source was copied over from `@aztec/boxes/{contract_name}/src/contracts` + * 3. If not, copies the contract from the appropriate `@aztec/noir-contracts/src/contracts/...` folder. + * + * The box provides a simple React app which parses the contract ABI + * and generates a UI to deploy + interact with the contract on a local aztec testnet. + * @param contractName - name of contract from `@aztec/noir-contracts`, in a format like "PrivateToken" (rather than "private_token", as it appears in the noir-contracts repo) + * @param log - Logger instance that will output to the CLI + */ +export async function unboxContract( + contractName: string, + outputDirectoryName: string, + packageVersion: string, + log: LogFn, +) { + const contractNames = ['PrivateToken']; + + if (!contractNames.includes(contractName)) { + log( + `The noir contract named "${contractName}" was not found in "@aztec/boxes" package. Valid options are: + ${contractNames.join('\n\t')} + We recommend "PrivateToken" as a default.`, + ); + return; + } + const outputPath = await createDirectory(outputDirectoryName, log); + + // downloads the selected contract's relevant folder in @aztec/boxes/{contract_name} + // and the noir source code from `noir-contracts` into `${outputDirectoryName}/src/contracts` + // if not present in the box + await downloadContractAndBoxFromGithub(packageVersion, contractName, outputPath, log); + // make adjustments for packaging to work as a standalone, as opposed to part of yarn workspace + // as in the monorepo source files + await updatePackagingConfigurations(packageVersion, outputPath, log); +} diff --git a/yarn-project/package.json b/yarn-project/package.json index b02bb1c561f..af3ab10b2a7 100644 --- a/yarn-project/package.json +++ b/yarn-project/package.json @@ -21,6 +21,7 @@ "aztec-rpc", "aztec-sandbox", "aztec.js", + "boxes", "canary", "circuits.js", "cli", @@ -35,6 +36,7 @@ "l1-artifacts", "p2p", "p2p-bootstrap", + "boxes/private-token", "prover-client", "rollup-provider", "aztec-node", diff --git a/yarn-project/yarn-project-base/Dockerfile b/yarn-project/yarn-project-base/Dockerfile index dca9635efdc..31b0b5239e8 100644 --- a/yarn-project/yarn-project-base/Dockerfile +++ b/yarn-project/yarn-project-base/Dockerfile @@ -25,6 +25,7 @@ COPY aztec-sandbox/package.json aztec-sandbox/package.json COPY aztec.js/package.json aztec.js/package.json COPY aztec.js/package.local.json aztec.js/package.local.json COPY canary/package.json canary/package.json +COPY boxes/private-token/package.json boxes/private-token/package.json COPY docs/package.json docs/package.json COPY end-to-end/package.json end-to-end/package.json COPY ethereum/package.json ethereum/package.json diff --git a/yarn-project/yarn.lock b/yarn-project/yarn.lock index c634d40c204..375e0596fac 100644 --- a/yarn-project/yarn.lock +++ b/yarn-project/yarn.lock @@ -47,6 +47,13 @@ __metadata: languageName: node linkType: hard +"@alloc/quick-lru@npm:^5.2.0": + version: 5.2.0 + resolution: "@alloc/quick-lru@npm:5.2.0" + checksum: bdc35758b552bcf045733ac047fb7f9a07c4678b944c641adfbd41f798b4b91fffd0fdc0df2578d9b0afc7b4d636aa6e110ead5d6281a2adc1ab90efd7f057f8 + languageName: node + linkType: hard + "@ampproject/remapping@npm:^2.2.0": version: 2.2.1 resolution: "@ampproject/remapping@npm:2.2.1" @@ -331,7 +338,9 @@ __metadata: commander: ^9.0.0 jest: ^29.5.0 jest-mock-extended: ^3.0.5 + jszip: ^3.10.1 lodash.startcase: ^4.4.0 + node-fetch: ^3.3.2 semver: ^7.5.4 ts-jest: ^29.1.0 ts-node: ^10.9.1 @@ -1523,6 +1532,30 @@ __metadata: languageName: node linkType: hard +"@eslint/eslintrc@npm:^2.1.2": + version: 2.1.2 + resolution: "@eslint/eslintrc@npm:2.1.2" + dependencies: + ajv: ^6.12.4 + debug: ^4.3.2 + espree: ^9.6.0 + globals: ^13.19.0 + ignore: ^5.2.0 + import-fresh: ^3.2.1 + js-yaml: ^4.1.0 + minimatch: ^3.1.2 + strip-json-comments: ^3.1.1 + checksum: bc742a1e3b361f06fedb4afb6bf32cbd27171292ef7924f61c62f2aed73048367bcc7ac68f98c06d4245cd3fabc43270f844e3c1699936d4734b3ac5398814a7 + languageName: node + linkType: hard + +"@eslint/js@npm:8.48.0": + version: 8.48.0 + resolution: "@eslint/js@npm:8.48.0" + checksum: b2755f9c0ee810c886eba3c50dcacb184ba5a5cd1cbc01988ee506ad7340653cae0bd55f1d95c64b56dfc6d25c2caa7825335ffd2c50165bae9996fe0f396851 + languageName: node + linkType: hard + "@eslint/js@npm:^8.46.0": version: 8.46.0 resolution: "@eslint/js@npm:8.46.0" @@ -1603,6 +1636,20 @@ __metadata: languageName: node linkType: hard +"@jest/console@npm:^29.6.4": + version: 29.6.4 + resolution: "@jest/console@npm:29.6.4" + dependencies: + "@jest/types": ^29.6.3 + "@types/node": "*" + chalk: ^4.0.0 + jest-message-util: ^29.6.3 + jest-util: ^29.6.3 + slash: ^3.0.0 + checksum: 1caf061a39266b86e96ca13358401839e4d930742cbaa9e87e79d7ce170a83195e52e5b2d22eb5aa9a949219b61a163a81e337ec98b8323d88d79853051df96c + languageName: node + linkType: hard + "@jest/core@npm:^29.6.2": version: 29.6.2 resolution: "@jest/core@npm:29.6.2" @@ -1644,6 +1691,47 @@ __metadata: languageName: node linkType: hard +"@jest/core@npm:^29.6.4": + version: 29.6.4 + resolution: "@jest/core@npm:29.6.4" + dependencies: + "@jest/console": ^29.6.4 + "@jest/reporters": ^29.6.4 + "@jest/test-result": ^29.6.4 + "@jest/transform": ^29.6.4 + "@jest/types": ^29.6.3 + "@types/node": "*" + ansi-escapes: ^4.2.1 + chalk: ^4.0.0 + ci-info: ^3.2.0 + exit: ^0.1.2 + graceful-fs: ^4.2.9 + jest-changed-files: ^29.6.3 + jest-config: ^29.6.4 + jest-haste-map: ^29.6.4 + jest-message-util: ^29.6.3 + jest-regex-util: ^29.6.3 + jest-resolve: ^29.6.4 + jest-resolve-dependencies: ^29.6.4 + jest-runner: ^29.6.4 + jest-runtime: ^29.6.4 + jest-snapshot: ^29.6.4 + jest-util: ^29.6.3 + jest-validate: ^29.6.3 + jest-watcher: ^29.6.4 + micromatch: ^4.0.4 + pretty-format: ^29.6.3 + slash: ^3.0.0 + strip-ansi: ^6.0.0 + peerDependencies: + node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 + peerDependenciesMeta: + node-notifier: + optional: true + checksum: 0f36532c909775814cb7d4310d61881beaefdec6229ef0b7493c6191dfca20ae5222120846ea5ef8cdeaa8cef265aae9cea8989dcab572d8daea9afd14247c7a + languageName: node + linkType: hard + "@jest/environment@npm:^29.6.2": version: 29.6.2 resolution: "@jest/environment@npm:29.6.2" @@ -1656,6 +1744,18 @@ __metadata: languageName: node linkType: hard +"@jest/environment@npm:^29.6.4": + version: 29.6.4 + resolution: "@jest/environment@npm:29.6.4" + dependencies: + "@jest/fake-timers": ^29.6.4 + "@jest/types": ^29.6.3 + "@types/node": "*" + jest-mock: ^29.6.3 + checksum: 810d8f1fc26d293acfc44927bcb78adc58ed4ea580a64c8d94aa6c67239dcb149186bf25b94ff28b79de15253e0c877ad8d330feac205f185f3517593168510c + languageName: node + linkType: hard + "@jest/expect-utils@npm:^29.6.2": version: 29.6.2 resolution: "@jest/expect-utils@npm:29.6.2" @@ -1665,6 +1765,15 @@ __metadata: languageName: node linkType: hard +"@jest/expect-utils@npm:^29.6.4": + version: 29.6.4 + resolution: "@jest/expect-utils@npm:29.6.4" + dependencies: + jest-get-type: ^29.6.3 + checksum: a17059e02a4c0fca98e2abb7e9e58c70df3cd3d4ebcc6a960cb57c571726f7bd738c6cd008a9bf99770b77e92f7e21c75fe1f9ceec9b7a7710010f9340bb28ad + languageName: node + linkType: hard + "@jest/expect@npm:^29.6.2": version: 29.6.2 resolution: "@jest/expect@npm:29.6.2" @@ -1675,6 +1784,16 @@ __metadata: languageName: node linkType: hard +"@jest/expect@npm:^29.6.4": + version: 29.6.4 + resolution: "@jest/expect@npm:29.6.4" + dependencies: + expect: ^29.6.4 + jest-snapshot: ^29.6.4 + checksum: e9d7306a96e2f9f9f7a0d93d41850cbad987ebda951a5d9a63d3f5fb61da4c1e41adb54af7f7222e4a185454ecb17ddc77845e18001ee28ac114f7a7fe9e671d + languageName: node + linkType: hard + "@jest/fake-timers@npm:^29.6.2": version: 29.6.2 resolution: "@jest/fake-timers@npm:29.6.2" @@ -1689,6 +1808,20 @@ __metadata: languageName: node linkType: hard +"@jest/fake-timers@npm:^29.6.4": + version: 29.6.4 + resolution: "@jest/fake-timers@npm:29.6.4" + dependencies: + "@jest/types": ^29.6.3 + "@sinonjs/fake-timers": ^10.0.2 + "@types/node": "*" + jest-message-util: ^29.6.3 + jest-mock: ^29.6.3 + jest-util: ^29.6.3 + checksum: 3f06d1090cbaaf781920fe59b10509ad86b587c401818a066ee1550101c6203e0718f0f83bbd2afa8bdf7b43eb280f89fb9f8c98886094e53ccabe5e64de9be1 + languageName: node + linkType: hard + "@jest/globals@npm:^29.5.0, @jest/globals@npm:^29.6.2": version: 29.6.2 resolution: "@jest/globals@npm:29.6.2" @@ -1701,6 +1834,18 @@ __metadata: languageName: node linkType: hard +"@jest/globals@npm:^29.6.4": + version: 29.6.4 + resolution: "@jest/globals@npm:29.6.4" + dependencies: + "@jest/environment": ^29.6.4 + "@jest/expect": ^29.6.4 + "@jest/types": ^29.6.3 + jest-mock: ^29.6.3 + checksum: a41b18871a248151264668a38b13cb305f03db112bfd89ec44e858af0e79066e0b03d6b68c8baf1ec6c578be6fdb87519389c83438608b91471d17a5724858e0 + languageName: node + linkType: hard + "@jest/reporters@npm:^29.6.2": version: 29.6.2 resolution: "@jest/reporters@npm:29.6.2" @@ -1738,6 +1883,43 @@ __metadata: languageName: node linkType: hard +"@jest/reporters@npm:^29.6.4": + version: 29.6.4 + resolution: "@jest/reporters@npm:29.6.4" + dependencies: + "@bcoe/v8-coverage": ^0.2.3 + "@jest/console": ^29.6.4 + "@jest/test-result": ^29.6.4 + "@jest/transform": ^29.6.4 + "@jest/types": ^29.6.3 + "@jridgewell/trace-mapping": ^0.3.18 + "@types/node": "*" + chalk: ^4.0.0 + collect-v8-coverage: ^1.0.0 + exit: ^0.1.2 + glob: ^7.1.3 + graceful-fs: ^4.2.9 + istanbul-lib-coverage: ^3.0.0 + istanbul-lib-instrument: ^6.0.0 + istanbul-lib-report: ^3.0.0 + istanbul-lib-source-maps: ^4.0.0 + istanbul-reports: ^3.1.3 + jest-message-util: ^29.6.3 + jest-util: ^29.6.3 + jest-worker: ^29.6.4 + slash: ^3.0.0 + string-length: ^4.0.1 + strip-ansi: ^6.0.0 + v8-to-istanbul: ^9.0.1 + peerDependencies: + node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 + peerDependenciesMeta: + node-notifier: + optional: true + checksum: 9ee0db497f3a826f535d3af0575ceb67984f9708bc6386450359517c212c67218ae98b8ea93ab05df2f920aed9c4166ef64209d66a09b7e30fc0077c91347ad0 + languageName: node + linkType: hard + "@jest/schemas@npm:^29.6.0": version: 29.6.0 resolution: "@jest/schemas@npm:29.6.0" @@ -1747,6 +1929,15 @@ __metadata: languageName: node linkType: hard +"@jest/schemas@npm:^29.6.3": + version: 29.6.3 + resolution: "@jest/schemas@npm:29.6.3" + dependencies: + "@sinclair/typebox": ^0.27.8 + checksum: 910040425f0fc93cd13e68c750b7885590b8839066dfa0cd78e7def07bbb708ad869381f725945d66f2284de5663bbecf63e8fdd856e2ae6e261ba30b1687e93 + languageName: node + linkType: hard + "@jest/source-map@npm:^29.6.0": version: 29.6.0 resolution: "@jest/source-map@npm:29.6.0" @@ -1758,6 +1949,17 @@ __metadata: languageName: node linkType: hard +"@jest/source-map@npm:^29.6.3": + version: 29.6.3 + resolution: "@jest/source-map@npm:29.6.3" + dependencies: + "@jridgewell/trace-mapping": ^0.3.18 + callsites: ^3.0.0 + graceful-fs: ^4.2.9 + checksum: bcc5a8697d471396c0003b0bfa09722c3cd879ad697eb9c431e6164e2ea7008238a01a07193dfe3cbb48b1d258eb7251f6efcea36f64e1ebc464ea3c03ae2deb + languageName: node + linkType: hard + "@jest/test-result@npm:^29.6.2": version: 29.6.2 resolution: "@jest/test-result@npm:29.6.2" @@ -1770,6 +1972,18 @@ __metadata: languageName: node linkType: hard +"@jest/test-result@npm:^29.6.4": + version: 29.6.4 + resolution: "@jest/test-result@npm:29.6.4" + dependencies: + "@jest/console": ^29.6.4 + "@jest/types": ^29.6.3 + "@types/istanbul-lib-coverage": ^2.0.0 + collect-v8-coverage: ^1.0.0 + checksum: a13c82d29038e80059191a1a443240678c6934ea832fdabaec12b3ece397b6303022a064494a6bbd167a024f04e6b4d9ace1001300927ff70405ec9d854f1193 + languageName: node + linkType: hard + "@jest/test-sequencer@npm:^29.6.2": version: 29.6.2 resolution: "@jest/test-sequencer@npm:29.6.2" @@ -1782,6 +1996,18 @@ __metadata: languageName: node linkType: hard +"@jest/test-sequencer@npm:^29.6.4": + version: 29.6.4 + resolution: "@jest/test-sequencer@npm:29.6.4" + dependencies: + "@jest/test-result": ^29.6.4 + graceful-fs: ^4.2.9 + jest-haste-map: ^29.6.4 + slash: ^3.0.0 + checksum: 517fc66b74a87431a8a1429e4505d85bd09c11f2ba835e46c07c79911fbee23b89c01ec444c7c1d12d1b36f9eba60fcbbccc8e1bc1ae54a1a8b03b5f530ff81b + languageName: node + linkType: hard + "@jest/transform@npm:^29.6.2": version: 29.6.2 resolution: "@jest/transform@npm:29.6.2" @@ -1805,6 +2031,29 @@ __metadata: languageName: node linkType: hard +"@jest/transform@npm:^29.6.4": + version: 29.6.4 + resolution: "@jest/transform@npm:29.6.4" + dependencies: + "@babel/core": ^7.11.6 + "@jest/types": ^29.6.3 + "@jridgewell/trace-mapping": ^0.3.18 + babel-plugin-istanbul: ^6.1.1 + chalk: ^4.0.0 + convert-source-map: ^2.0.0 + fast-json-stable-stringify: ^2.1.0 + graceful-fs: ^4.2.9 + jest-haste-map: ^29.6.4 + jest-regex-util: ^29.6.3 + jest-util: ^29.6.3 + micromatch: ^4.0.4 + pirates: ^4.0.4 + slash: ^3.0.0 + write-file-atomic: ^4.0.2 + checksum: 0341a200a0bb926fc67ab9aede91c7b4009458206495e92057e72a115c55da5fed117457e68c6ea821e24c58b55da75c6a7b0f272ed63c2693db583d689a3383 + languageName: node + linkType: hard + "@jest/types@npm:^29.6.1": version: 29.6.1 resolution: "@jest/types@npm:29.6.1" @@ -1819,6 +2068,20 @@ __metadata: languageName: node linkType: hard +"@jest/types@npm:^29.6.3": + version: 29.6.3 + resolution: "@jest/types@npm:29.6.3" + dependencies: + "@jest/schemas": ^29.6.3 + "@types/istanbul-lib-coverage": ^2.0.0 + "@types/istanbul-reports": ^3.0.0 + "@types/node": "*" + "@types/yargs": ^17.0.8 + chalk: ^4.0.0 + checksum: a0bcf15dbb0eca6bdd8ce61a3fb055349d40268622a7670a3b2eb3c3dbafe9eb26af59938366d520b86907b9505b0f9b29b85cec11579a9e580694b87cd90fcc + languageName: node + linkType: hard + "@jridgewell/gen-mapping@npm:^0.3.0, @jridgewell/gen-mapping@npm:^0.3.2": version: 0.3.3 resolution: "@jridgewell/gen-mapping@npm:0.3.3" @@ -1904,6 +2167,13 @@ __metadata: languageName: node linkType: hard +"@leichtgewicht/ip-codec@npm:^2.0.1": + version: 2.0.4 + resolution: "@leichtgewicht/ip-codec@npm:2.0.4" + checksum: 468de1f04d33de6d300892683d7c8aecbf96d1e2c5fe084f95f816e50a054d45b7c1ebfb141a1447d844b86a948733f6eebd92234da8581c84a1ad4de2946a2d + languageName: node + linkType: hard + "@libp2p/bootstrap@npm:^9.0.4": version: 9.0.4 resolution: "@libp2p/bootstrap@npm:9.0.4" @@ -2847,6 +3117,25 @@ __metadata: languageName: node linkType: hard +"@types/bonjour@npm:^3.5.9": + version: 3.5.10 + resolution: "@types/bonjour@npm:3.5.10" + dependencies: + "@types/node": "*" + checksum: bfcadb042a41b124c4e3de4925e3be6d35b78f93f27c4535d5ff86980dc0f8bc407ed99b9b54528952dc62834d5a779392f7a12c2947dd19330eb05a6bcae15a + languageName: node + linkType: hard + +"@types/connect-history-api-fallback@npm:^1.3.5": + version: 1.5.0 + resolution: "@types/connect-history-api-fallback@npm:1.5.0" + dependencies: + "@types/express-serve-static-core": "*" + "@types/node": "*" + checksum: f180e7c540728d6dd3a1eb2376e445fe7f9de4ee8a5b460d5ad80062cdb6de6efc91c6851f39e9d5933b3dcd5cd370673c52343a959aa091238b6f863ea4447c + languageName: node + linkType: hard + "@types/connect@npm:*": version: 3.4.35 resolution: "@types/connect@npm:3.4.35" @@ -2925,6 +3214,18 @@ __metadata: languageName: node linkType: hard +"@types/express-serve-static-core@npm:*": + version: 4.17.36 + resolution: "@types/express-serve-static-core@npm:4.17.36" + dependencies: + "@types/node": "*" + "@types/qs": "*" + "@types/range-parser": "*" + "@types/send": "*" + checksum: 410b13cbd663f18c0f8729e7f2ff54d960d96de76ebbae7cadb612972f85cc66c54051e00d32f11aa230c0a683d81a6d6fc7f7e4e383a95c0801494c517f36e1 + languageName: node + linkType: hard + "@types/express-serve-static-core@npm:^4.17.33": version: 4.17.35 resolution: "@types/express-serve-static-core@npm:4.17.35" @@ -2937,7 +3238,7 @@ __metadata: languageName: node linkType: hard -"@types/express@npm:*": +"@types/express@npm:*, @types/express@npm:^4.17.13": version: 4.17.17 resolution: "@types/express@npm:4.17.17" dependencies: @@ -2982,6 +3283,15 @@ __metadata: languageName: node linkType: hard +"@types/http-proxy@npm:^1.17.8": + version: 1.17.11 + resolution: "@types/http-proxy@npm:1.17.11" + dependencies: + "@types/node": "*" + checksum: 38ef4f8c91c7a5b664cf6dd4d90de7863f88549a9f8ef997f2f1184e4f8cf2e7b9b63c04f0b7b962f34a09983073a31a9856de5aae5159b2ddbb905a4c44dc9f + languageName: node + linkType: hard + "@types/istanbul-lib-coverage@npm:*, @types/istanbul-lib-coverage@npm:^2.0.0, @types/istanbul-lib-coverage@npm:^2.0.1": version: 2.0.4 resolution: "@types/istanbul-lib-coverage@npm:2.0.4" @@ -3017,7 +3327,7 @@ __metadata: languageName: node linkType: hard -"@types/json-schema@npm:*, @types/json-schema@npm:^7.0.12, @types/json-schema@npm:^7.0.8": +"@types/json-schema@npm:*, @types/json-schema@npm:^7.0.12, @types/json-schema@npm:^7.0.8, @types/json-schema@npm:^7.0.9": version: 7.0.12 resolution: "@types/json-schema@npm:7.0.12" checksum: 00239e97234eeb5ceefb0c1875d98ade6e922bfec39dd365ec6bd360b5c2f825e612ac4f6e5f1d13601b8b30f378f15e6faa805a3a732f4a1bbe61915163d293 @@ -3385,6 +3695,13 @@ __metadata: languageName: node linkType: hard +"@types/node@npm:^20.5.9": + version: 20.5.9 + resolution: "@types/node@npm:20.5.9" + checksum: 717490e94131722144878b4ca1a963ede1673bb8f2ef78c2f5b50b918df6dc9b35e7f8283e5c2a7a9f137730f7c08dc6228e53d4494a94c9ee16881e6ce6caed + languageName: node + linkType: hard + "@types/normalize-package-data@npm:^2.4.0": version: 2.4.1 resolution: "@types/normalize-package-data@npm:2.4.1" @@ -3399,6 +3716,13 @@ __metadata: languageName: node linkType: hard +"@types/prop-types@npm:*": + version: 15.7.5 + resolution: "@types/prop-types@npm:15.7.5" + checksum: 5b43b8b15415e1f298243165f1d44390403bb2bd42e662bca3b5b5633fdd39c938e91b7fce3a9483699db0f7a715d08cef220c121f723a634972fdf596aec980 + languageName: node + linkType: hard + "@types/qs@npm:*": version: 6.9.7 resolution: "@types/qs@npm:6.9.7" @@ -3413,6 +3737,33 @@ __metadata: languageName: node linkType: hard +"@types/react-dom@npm:^18.2.7": + version: 18.2.7 + resolution: "@types/react-dom@npm:18.2.7" + dependencies: + "@types/react": "*" + checksum: e02ea908289a7ad26053308248d2b87f6aeafd73d0e2de2a3d435947bcea0422599016ffd1c3e38ff36c42f5e1c87c7417f05b0a157e48649e4a02f21727d54f + languageName: node + linkType: hard + +"@types/react@npm:*, @types/react@npm:^18.2.15": + version: 18.2.21 + resolution: "@types/react@npm:18.2.21" + dependencies: + "@types/prop-types": "*" + "@types/scheduler": "*" + csstype: ^3.0.2 + checksum: ffed203bfe7aad772b8286f7953305c9181ac3a8f27d3f5400fbbc2a8e27ca8e5bbff818ee014f39ca0d19d2b3bb154e5bdbec7e232c6f80b59069375aa78349 + languageName: node + linkType: hard + +"@types/retry@npm:0.12.0": + version: 0.12.0 + resolution: "@types/retry@npm:0.12.0" + checksum: 61a072c7639f6e8126588bf1eb1ce8835f2cb9c2aba795c4491cf6310e013267b0c8488039857c261c387e9728c1b43205099223f160bb6a76b4374f741b5603 + languageName: node + linkType: hard + "@types/retry@npm:0.12.1": version: 0.12.1 resolution: "@types/retry@npm:0.12.1" @@ -3420,6 +3771,13 @@ __metadata: languageName: node linkType: hard +"@types/scheduler@npm:*": + version: 0.16.3 + resolution: "@types/scheduler@npm:0.16.3" + checksum: 2b0aec39c24268e3ce938c5db2f2e77f5c3dd280e05c262d9c2fe7d890929e4632a6b8e94334017b66b45e4f92a5aa42ba3356640c2a1175fa37bef2f5200767 + languageName: node + linkType: hard + "@types/semver@npm:^7.5.0": version: 7.5.0 resolution: "@types/semver@npm:7.5.0" @@ -3437,7 +3795,16 @@ __metadata: languageName: node linkType: hard -"@types/serve-static@npm:*": +"@types/serve-index@npm:^1.9.1": + version: 1.9.1 + resolution: "@types/serve-index@npm:1.9.1" + dependencies: + "@types/express": "*" + checksum: 026f3995fb500f6df7c3fe5009e53bad6d739e20b84089f58ebfafb2f404bbbb6162bbe33f72d2f2af32d5b8d3799c8e179793f90d9ed5871fb8591190bb6056 + languageName: node + linkType: hard + +"@types/serve-static@npm:*, @types/serve-static@npm:^1.13.10": version: 1.15.2 resolution: "@types/serve-static@npm:1.15.2" dependencies: @@ -3473,6 +3840,15 @@ __metadata: languageName: node linkType: hard +"@types/sockjs@npm:^0.3.33": + version: 0.3.33 + resolution: "@types/sockjs@npm:0.3.33" + dependencies: + "@types/node": "*" + checksum: b9bbb2b5c5ead2fb884bb019f61a014e37410bddd295de28184e1b2e71ee6b04120c5ba7b9954617f0bdf962c13d06249ce65004490889c747c80d3f628ea842 + languageName: node + linkType: hard + "@types/stack-utils@npm:^2.0.0": version: 2.0.1 resolution: "@types/stack-utils@npm:2.0.1" @@ -3506,7 +3882,7 @@ __metadata: languageName: node linkType: hard -"@types/ws@npm:^8.5.4": +"@types/ws@npm:^8.5.4, @types/ws@npm:^8.5.5": version: 8.5.5 resolution: "@types/ws@npm:8.5.5" dependencies: @@ -3540,6 +3916,31 @@ __metadata: languageName: node linkType: hard +"@typescript-eslint/eslint-plugin@npm:^6.0.0": + version: 6.5.0 + resolution: "@typescript-eslint/eslint-plugin@npm:6.5.0" + dependencies: + "@eslint-community/regexpp": ^4.5.1 + "@typescript-eslint/scope-manager": 6.5.0 + "@typescript-eslint/type-utils": 6.5.0 + "@typescript-eslint/utils": 6.5.0 + "@typescript-eslint/visitor-keys": 6.5.0 + debug: ^4.3.4 + graphemer: ^1.4.0 + ignore: ^5.2.4 + natural-compare: ^1.4.0 + semver: ^7.5.4 + ts-api-utils: ^1.0.1 + peerDependencies: + "@typescript-eslint/parser": ^6.0.0 || ^6.0.0-alpha + eslint: ^7.0.0 || ^8.0.0 + peerDependenciesMeta: + typescript: + optional: true + checksum: d81525c9a081186ec1ae7d957972065d50bae8fe4b3de111e573adc7267bb830baaec8f1ae47d3b937984ac34324bacc3951868b7986d4f9974bbe480f2261c0 + languageName: node + linkType: hard + "@typescript-eslint/eslint-plugin@npm:^6.2.1": version: 6.2.1 resolution: "@typescript-eslint/eslint-plugin@npm:6.2.1" @@ -3566,6 +3967,24 @@ __metadata: languageName: node linkType: hard +"@typescript-eslint/parser@npm:^6.0.0": + version: 6.5.0 + resolution: "@typescript-eslint/parser@npm:6.5.0" + dependencies: + "@typescript-eslint/scope-manager": 6.5.0 + "@typescript-eslint/types": 6.5.0 + "@typescript-eslint/typescript-estree": 6.5.0 + "@typescript-eslint/visitor-keys": 6.5.0 + debug: ^4.3.4 + peerDependencies: + eslint: ^7.0.0 || ^8.0.0 + peerDependenciesMeta: + typescript: + optional: true + checksum: e9a70886ec2660aee5c77cdff67ba11651eb855b7ecd3ad1e70837fce997d6e6db9dfe1e1eab46a9b2147cbc034ae9c109951f3bc24ce54e78cae669b6bc9c95 + languageName: node + linkType: hard + "@typescript-eslint/parser@npm:^6.2.1": version: 6.2.1 resolution: "@typescript-eslint/parser@npm:6.2.1" @@ -3594,6 +4013,16 @@ __metadata: languageName: node linkType: hard +"@typescript-eslint/scope-manager@npm:6.5.0": + version: 6.5.0 + resolution: "@typescript-eslint/scope-manager@npm:6.5.0" + dependencies: + "@typescript-eslint/types": 6.5.0 + "@typescript-eslint/visitor-keys": 6.5.0 + checksum: 30d78143f68e07d6bd15a147f64cc16830f8a8c8409b37aa7c7d205d7585f3648ec1c5365b3f177b7561971b407f773f6dba83b3b78fa63091045f2d6bbc6b9f + languageName: node + linkType: hard + "@typescript-eslint/type-utils@npm:6.2.1": version: 6.2.1 resolution: "@typescript-eslint/type-utils@npm:6.2.1" @@ -3611,6 +4040,23 @@ __metadata: languageName: node linkType: hard +"@typescript-eslint/type-utils@npm:6.5.0": + version: 6.5.0 + resolution: "@typescript-eslint/type-utils@npm:6.5.0" + dependencies: + "@typescript-eslint/typescript-estree": 6.5.0 + "@typescript-eslint/utils": 6.5.0 + debug: ^4.3.4 + ts-api-utils: ^1.0.1 + peerDependencies: + eslint: ^7.0.0 || ^8.0.0 + peerDependenciesMeta: + typescript: + optional: true + checksum: 80b9e5099f5bdb05348ea8664c0a5084efc851de43ef6c1997041e1f07e9cc34ac874cc9e8afb317c887513d657e2583ad360e3d57feaab775bde0acc1807982 + languageName: node + linkType: hard + "@typescript-eslint/types@npm:6.2.1": version: 6.2.1 resolution: "@typescript-eslint/types@npm:6.2.1" @@ -3618,6 +4064,13 @@ __metadata: languageName: node linkType: hard +"@typescript-eslint/types@npm:6.5.0": + version: 6.5.0 + resolution: "@typescript-eslint/types@npm:6.5.0" + checksum: 950ec16991d71494d10cb752535bbc4395295e3f03a716d53ec55bbb0aaff487aa774cc5002f775ffcc80b9f0e16ac53ecebf7cac1444ca4f7a847b0859ffbfb + languageName: node + linkType: hard + "@typescript-eslint/typescript-estree@npm:6.2.1": version: 6.2.1 resolution: "@typescript-eslint/typescript-estree@npm:6.2.1" @@ -3636,16 +4089,34 @@ __metadata: languageName: node linkType: hard -"@typescript-eslint/utils@npm:6.2.1": - version: 6.2.1 - resolution: "@typescript-eslint/utils@npm:6.2.1" +"@typescript-eslint/typescript-estree@npm:6.5.0": + version: 6.5.0 + resolution: "@typescript-eslint/typescript-estree@npm:6.5.0" dependencies: - "@eslint-community/eslint-utils": ^4.4.0 - "@types/json-schema": ^7.0.12 - "@types/semver": ^7.5.0 - "@typescript-eslint/scope-manager": 6.2.1 - "@typescript-eslint/types": 6.2.1 - "@typescript-eslint/typescript-estree": 6.2.1 + "@typescript-eslint/types": 6.5.0 + "@typescript-eslint/visitor-keys": 6.5.0 + debug: ^4.3.4 + globby: ^11.1.0 + is-glob: ^4.0.3 + semver: ^7.5.4 + ts-api-utils: ^1.0.1 + peerDependenciesMeta: + typescript: + optional: true + checksum: 05717fa1f2609fa5669803191cf309a379c815aaf4fff6850f40560eec8749759c36b288f05cecffd5c1d0be8de1fe414ecfee6ecf99b6ae521baa48c8b58455 + languageName: node + linkType: hard + +"@typescript-eslint/utils@npm:6.2.1": + version: 6.2.1 + resolution: "@typescript-eslint/utils@npm:6.2.1" + dependencies: + "@eslint-community/eslint-utils": ^4.4.0 + "@types/json-schema": ^7.0.12 + "@types/semver": ^7.5.0 + "@typescript-eslint/scope-manager": 6.2.1 + "@typescript-eslint/types": 6.2.1 + "@typescript-eslint/typescript-estree": 6.2.1 semver: ^7.5.4 peerDependencies: eslint: ^7.0.0 || ^8.0.0 @@ -3653,6 +4124,23 @@ __metadata: languageName: node linkType: hard +"@typescript-eslint/utils@npm:6.5.0": + version: 6.5.0 + resolution: "@typescript-eslint/utils@npm:6.5.0" + dependencies: + "@eslint-community/eslint-utils": ^4.4.0 + "@types/json-schema": ^7.0.12 + "@types/semver": ^7.5.0 + "@typescript-eslint/scope-manager": 6.5.0 + "@typescript-eslint/types": 6.5.0 + "@typescript-eslint/typescript-estree": 6.5.0 + semver: ^7.5.4 + peerDependencies: + eslint: ^7.0.0 || ^8.0.0 + checksum: 58a82213c8a7bac97a6538b9845c1de5c5692fbf72548f95ed5e044a222608590bcafbb9eacba92a8c4e9eb3e5d0a2fd553eae0d6694ed2d6152aed4dabf9480 + languageName: node + linkType: hard + "@typescript-eslint/visitor-keys@npm:6.2.1": version: 6.2.1 resolution: "@typescript-eslint/visitor-keys@npm:6.2.1" @@ -3663,6 +4151,16 @@ __metadata: languageName: node linkType: hard +"@typescript-eslint/visitor-keys@npm:6.5.0": + version: 6.5.0 + resolution: "@typescript-eslint/visitor-keys@npm:6.5.0" + dependencies: + "@typescript-eslint/types": 6.5.0 + eslint-visitor-keys: ^3.4.1 + checksum: 768a02dd0d8aae45708646bb0c51e67da09e71dc101bb0a0e55d7e0c8eadfea2f531acd3035d1ec34bf2380b66188f3fc47c6bef0201eae36b2dcc48d1934442 + languageName: node + linkType: hard + "@wagmi/chains@npm:1.6.0": version: 1.6.0 resolution: "@wagmi/chains@npm:1.6.0" @@ -3873,6 +4371,13 @@ __metadata: languageName: node linkType: hard +"@zeit/schemas@npm:2.29.0": + version: 2.29.0 + resolution: "@zeit/schemas@npm:2.29.0" + checksum: 3cea06bb67d790336aca0cc17580fd492ff3fc66ef4d180dce7053ff7ff54ab81b56bf718ba6f537148c581161d06306a481ec218d540bff922e0e009844ffd1 + languageName: node + linkType: hard + "abbrev@npm:^1.0.0": version: 1.1.1 resolution: "abbrev@npm:1.1.1" @@ -3932,7 +4437,7 @@ __metadata: languageName: node linkType: hard -"accepts@npm:^1.3.5": +"accepts@npm:^1.3.5, accepts@npm:~1.3.4, accepts@npm:~1.3.5, accepts@npm:~1.3.8": version: 1.3.8 resolution: "accepts@npm:1.3.8" dependencies: @@ -4015,6 +4520,20 @@ __metadata: languageName: node linkType: hard +"ajv-formats@npm:^2.1.1": + version: 2.1.1 + resolution: "ajv-formats@npm:2.1.1" + dependencies: + ajv: ^8.0.0 + peerDependencies: + ajv: ^8.0.0 + peerDependenciesMeta: + ajv: + optional: true + checksum: 4a287d937f1ebaad4683249a4c40c0fa3beed30d9ddc0adba04859026a622da0d317851316ea64b3680dc60f5c3c708105ddd5d5db8fe595d9d0207fd19f90b7 + languageName: node + linkType: hard + "ajv-keywords@npm:^3.5.2": version: 3.5.2 resolution: "ajv-keywords@npm:3.5.2" @@ -4024,6 +4543,29 @@ __metadata: languageName: node linkType: hard +"ajv-keywords@npm:^5.1.0": + version: 5.1.0 + resolution: "ajv-keywords@npm:5.1.0" + dependencies: + fast-deep-equal: ^3.1.3 + peerDependencies: + ajv: ^8.8.2 + checksum: c35193940b853119242c6757787f09ecf89a2c19bcd36d03ed1a615e710d19d450cb448bfda407b939aba54b002368c8bff30529cc50a0536a8e10bcce300421 + languageName: node + linkType: hard + +"ajv@npm:8.11.0": + version: 8.11.0 + resolution: "ajv@npm:8.11.0" + dependencies: + fast-deep-equal: ^3.1.1 + json-schema-traverse: ^1.0.0 + require-from-string: ^2.0.2 + uri-js: ^4.2.2 + checksum: 5e0ff226806763be73e93dd7805b634f6f5921e3e90ca04acdf8db81eed9d8d3f0d4c5f1213047f45ebbf8047ffe0c840fa1ef2ec42c3a644899f69aa72b5bef + languageName: node + linkType: hard + "ajv@npm:^6.12.4, ajv@npm:^6.12.5, ajv@npm:~6.12.6": version: 6.12.6 resolution: "ajv@npm:6.12.6" @@ -4036,6 +4578,27 @@ __metadata: languageName: node linkType: hard +"ajv@npm:^8.0.0, ajv@npm:^8.9.0": + version: 8.12.0 + resolution: "ajv@npm:8.12.0" + dependencies: + fast-deep-equal: ^3.1.1 + json-schema-traverse: ^1.0.0 + require-from-string: ^2.0.2 + uri-js: ^4.2.2 + checksum: 4dc13714e316e67537c8b31bc063f99a1d9d9a497eb4bbd55191ac0dcd5e4985bbb71570352ad6f1e76684fb6d790928f96ba3b2d4fd6e10024be9612fe3f001 + languageName: node + linkType: hard + +"ansi-align@npm:^3.0.1": + version: 3.0.1 + resolution: "ansi-align@npm:3.0.1" + dependencies: + string-width: ^4.1.0 + checksum: 6abfa08f2141d231c257162b15292467081fa49a208593e055c866aa0455b57f3a86b5a678c190c618faa79b4c59e254493099cb700dd9cf2293c6be2c8f5d8d + languageName: node + linkType: hard + "ansi-escapes@npm:^4.2.1": version: 4.3.2 resolution: "ansi-escapes@npm:4.3.2" @@ -4045,6 +4608,15 @@ __metadata: languageName: node linkType: hard +"ansi-html-community@npm:^0.0.8": + version: 0.0.8 + resolution: "ansi-html-community@npm:0.0.8" + bin: + ansi-html: bin/ansi-html + checksum: 04c568e8348a636963f915e48eaa3e01218322e1169acafdd79c384f22e5558c003f79bbc480c1563865497482817c7eed025f0653ebc17642fededa5cb42089 + languageName: node + linkType: hard + "ansi-regex@npm:^5.0.1": version: 5.0.1 resolution: "ansi-regex@npm:5.0.1" @@ -4098,6 +4670,13 @@ __metadata: languageName: node linkType: hard +"any-promise@npm:^1.0.0": + version: 1.3.0 + resolution: "any-promise@npm:1.3.0" + checksum: 0ee8a9bdbe882c90464d75d1f55cf027f5458650c4bd1f0467e65aec38ccccda07ca5844969ee77ed46d04e7dded3eaceb027e8d32f385688523fe305fa7e1de + languageName: node + linkType: hard + "any-signal@npm:^4.1.1": version: 4.1.1 resolution: "any-signal@npm:4.1.1" @@ -4105,7 +4684,7 @@ __metadata: languageName: node linkType: hard -"anymatch@npm:^3.0.3": +"anymatch@npm:^3.0.3, anymatch@npm:~3.1.2": version: 3.1.3 resolution: "anymatch@npm:3.1.3" dependencies: @@ -4122,6 +4701,13 @@ __metadata: languageName: node linkType: hard +"arch@npm:^2.2.0": + version: 2.2.0 + resolution: "arch@npm:2.2.0" + checksum: e21b7635029fe8e9cdd5a026f9a6c659103e63fff423834323cdf836a1bb240a72d0c39ca8c470f84643385cf581bd8eda2cad8bf493e27e54bd9783abe9101f + languageName: node + linkType: hard + "are-we-there-yet@npm:^3.0.0": version: 3.0.1 resolution: "are-we-there-yet@npm:3.0.1" @@ -4132,6 +4718,13 @@ __metadata: languageName: node linkType: hard +"arg@npm:5.0.2, arg@npm:^5.0.2": + version: 5.0.2 + resolution: "arg@npm:5.0.2" + checksum: 6c69ada1a9943d332d9e5382393e897c500908d91d5cb735a01120d5f71daf1b339b7b8980cbeaba8fd1afc68e658a739746179e4315a26e8a28951ff9930078 + languageName: node + linkType: hard + "arg@npm:^4.1.0": version: 4.1.3 resolution: "arg@npm:4.1.3" @@ -4165,6 +4758,20 @@ __metadata: languageName: node linkType: hard +"array-flatten@npm:1.1.1": + version: 1.1.1 + resolution: "array-flatten@npm:1.1.1" + checksum: a9925bf3512d9dce202112965de90c222cd59a4fbfce68a0951d25d965cf44642931f40aac72309c41f12df19afa010ecadceb07cfff9ccc1621e99d89ab5f3b + languageName: node + linkType: hard + +"array-flatten@npm:^2.1.2": + version: 2.1.2 + resolution: "array-flatten@npm:2.1.2" + checksum: e8988aac1fbfcdaae343d08c9a06a6fddd2c6141721eeeea45c3cf523bf4431d29a46602929455ed548c7a3e0769928cdc630405427297e7081bd118fdec9262 + languageName: node + linkType: hard + "array-includes@npm:^3.1.6": version: 3.1.6 resolution: "array-includes@npm:3.1.6" @@ -4285,6 +4892,24 @@ __metadata: languageName: node linkType: hard +"autoprefixer@npm:^10.4.15": + version: 10.4.15 + resolution: "autoprefixer@npm:10.4.15" + dependencies: + browserslist: ^4.21.10 + caniuse-lite: ^1.0.30001520 + fraction.js: ^4.2.0 + normalize-range: ^0.1.2 + picocolors: ^1.0.0 + postcss-value-parser: ^4.2.0 + peerDependencies: + postcss: ^8.1.0 + bin: + autoprefixer: bin/autoprefixer + checksum: d490b14fb098c043e109fc13cd23628f146af99a493d35b9df3a26f8ec0b4dd8937c5601cdbaeb465b98ea31d3ea05aa7184711d4d93dfb52358d073dcb67032 + languageName: node + linkType: hard + "available-typed-arrays@npm:^1.0.5": version: 1.0.5 resolution: "available-typed-arrays@npm:1.0.5" @@ -4316,6 +4941,23 @@ __metadata: languageName: node linkType: hard +"babel-jest@npm:^29.6.4": + version: 29.6.4 + resolution: "babel-jest@npm:29.6.4" + dependencies: + "@jest/transform": ^29.6.4 + "@types/babel__core": ^7.1.14 + babel-plugin-istanbul: ^6.1.1 + babel-preset-jest: ^29.6.3 + chalk: ^4.0.0 + graceful-fs: ^4.2.9 + slash: ^3.0.0 + peerDependencies: + "@babel/core": ^7.8.0 + checksum: c574f1805ab6b51a7d0f5a028aad19eec4634be81e66e6f4631b79b34d8ea05dfb53629f3686c77345163872730aa0408c9e5937ed85f846984228f7ab5e5d96 + languageName: node + linkType: hard + "babel-plugin-istanbul@npm:^6.1.1": version: 6.1.1 resolution: "babel-plugin-istanbul@npm:6.1.1" @@ -4341,6 +4983,18 @@ __metadata: languageName: node linkType: hard +"babel-plugin-jest-hoist@npm:^29.6.3": + version: 29.6.3 + resolution: "babel-plugin-jest-hoist@npm:29.6.3" + dependencies: + "@babel/template": ^7.3.3 + "@babel/types": ^7.3.3 + "@types/babel__core": ^7.1.14 + "@types/babel__traverse": ^7.0.6 + checksum: 51250f22815a7318f17214a9d44650ba89551e6d4f47a2dc259128428324b52f5a73979d010cefd921fd5a720d8c1d55ad74ff601cd94c7bd44d5f6292fde2d1 + languageName: node + linkType: hard + "babel-preset-current-node-syntax@npm:^1.0.0": version: 1.0.1 resolution: "babel-preset-current-node-syntax@npm:1.0.1" @@ -4375,6 +5029,18 @@ __metadata: languageName: node linkType: hard +"babel-preset-jest@npm:^29.6.3": + version: 29.6.3 + resolution: "babel-preset-jest@npm:29.6.3" + dependencies: + babel-plugin-jest-hoist: ^29.6.3 + babel-preset-current-node-syntax: ^1.0.0 + peerDependencies: + "@babel/core": ^7.0.0 + checksum: aa4ff2a8a728d9d698ed521e3461a109a1e66202b13d3494e41eea30729a5e7cc03b3a2d56c594423a135429c37bf63a9fa8b0b9ce275298be3095a88c69f6fb + languageName: node + linkType: hard + "balanced-match@npm:^1.0.0": version: 1.0.2 resolution: "balanced-match@npm:1.0.2" @@ -4396,6 +5062,13 @@ __metadata: languageName: node linkType: hard +"batch@npm:0.6.1": + version: 0.6.1 + resolution: "batch@npm:0.6.1" + checksum: 61f9934c7378a51dce61b915586191078ef7f1c3eca707fdd58b96ff2ff56d9e0af2bdab66b1462301a73c73374239e6542d9821c0af787f3209a23365d07e7f + languageName: node + linkType: hard + "benchmark@npm:^2.1.4": version: 2.1.4 resolution: "benchmark@npm:2.1.4" @@ -4413,6 +5086,13 @@ __metadata: languageName: node linkType: hard +"binary-extensions@npm:^2.0.0": + version: 2.2.0 + resolution: "binary-extensions@npm:2.2.0" + checksum: ccd267956c58d2315f5d3ea6757cf09863c5fc703e50fbeb13a7dc849b812ef76e3cf9ca8f35a0c48498776a7478d7b4a0418e1e2b8cb9cb9731f2922aaad7f8 + languageName: node + linkType: hard + "bn.js@npm:^4.0.0, bn.js@npm:^4.1.0, bn.js@npm:^4.11.9": version: 4.12.0 resolution: "bn.js@npm:4.12.0" @@ -4427,6 +5107,54 @@ __metadata: languageName: node linkType: hard +"body-parser@npm:1.20.1": + version: 1.20.1 + resolution: "body-parser@npm:1.20.1" + dependencies: + bytes: 3.1.2 + content-type: ~1.0.4 + debug: 2.6.9 + depd: 2.0.0 + destroy: 1.2.0 + http-errors: 2.0.0 + iconv-lite: 0.4.24 + on-finished: 2.4.1 + qs: 6.11.0 + raw-body: 2.5.1 + type-is: ~1.6.18 + unpipe: 1.0.0 + checksum: f1050dbac3bede6a78f0b87947a8d548ce43f91ccc718a50dd774f3c81f2d8b04693e52acf62659fad23101827dd318da1fb1363444ff9a8482b886a3e4a5266 + languageName: node + linkType: hard + +"bonjour-service@npm:^1.0.11": + version: 1.1.1 + resolution: "bonjour-service@npm:1.1.1" + dependencies: + array-flatten: ^2.1.2 + dns-equal: ^1.0.0 + fast-deep-equal: ^3.1.3 + multicast-dns: ^7.2.5 + checksum: 832d0cf78b91368fac8bb11fd7a714e46f4c4fb1bb14d7283bce614a6fb3aae2f3fe209aba5b4fa051811c1cab6921d073a83db8432fb23292f27dd4161fb0f1 + languageName: node + linkType: hard + +"boxen@npm:7.0.0": + version: 7.0.0 + resolution: "boxen@npm:7.0.0" + dependencies: + ansi-align: ^3.0.1 + camelcase: ^7.0.0 + chalk: ^5.0.1 + cli-boxes: ^3.0.0 + string-width: ^5.1.2 + type-fest: ^2.13.0 + widest-line: ^4.0.1 + wrap-ansi: ^8.0.1 + checksum: b917cf7a168ef3149635a8c02d5c9717d66182348bd27038d85328ad12655151e3324db0f2815253846c33e5f0ddf28b6cd52d56a12b9f88617b7f8f722b946a + languageName: node + linkType: hard + "bplist-parser@npm:^0.2.0": version: 0.2.0 resolution: "bplist-parser@npm:0.2.0" @@ -4455,7 +5183,7 @@ __metadata: languageName: node linkType: hard -"braces@npm:^3.0.2": +"braces@npm:^3.0.2, braces@npm:~3.0.2": version: 3.0.2 resolution: "braces@npm:3.0.2" dependencies: @@ -4535,7 +5263,7 @@ __metadata: languageName: node linkType: hard -"browserslist@npm:^4.14.5, browserslist@npm:^4.21.9": +"browserslist@npm:^4.14.5, browserslist@npm:^4.21.10, browserslist@npm:^4.21.9": version: 4.21.10 resolution: "browserslist@npm:4.21.10" dependencies: @@ -4635,6 +5363,13 @@ __metadata: languageName: node linkType: hard +"bytes@npm:3.0.0": + version: 3.0.0 + resolution: "bytes@npm:3.0.0" + checksum: a2b386dd8188849a5325f58eef69c3b73c51801c08ffc6963eddc9be244089ba32d19347caf6d145c86f315ae1b1fc7061a32b0c1aa6379e6a719090287ed101 + languageName: node + linkType: hard + "bytes@npm:3.1.2, bytes@npm:^3.1.2": version: 3.1.2 resolution: "bytes@npm:3.1.2" @@ -4689,6 +5424,13 @@ __metadata: languageName: node linkType: hard +"camelcase-css@npm:^2.0.1": + version: 2.0.1 + resolution: "camelcase-css@npm:2.0.1" + checksum: 1cec2b3b3dcb5026688a470b00299a8db7d904c4802845c353dbd12d9d248d3346949a814d83bfd988d4d2e5b9904c07efe76fecd195a1d4f05b543e7c0b56b1 + languageName: node + linkType: hard + "camelcase-keys@npm:^6.2.2": version: 6.2.2 resolution: "camelcase-keys@npm:6.2.2" @@ -4714,6 +5456,13 @@ __metadata: languageName: node linkType: hard +"camelcase@npm:^7.0.0": + version: 7.0.1 + resolution: "camelcase@npm:7.0.1" + checksum: 86ab8f3ebf08bcdbe605a211a242f00ed30d8bfb77dab4ebb744dd36efbc84432d1c4adb28975ba87a1b8be40a80fbd1e60e2f06565315918fa7350011a26d3d + languageName: node + linkType: hard + "caniuse-lite@npm:^1.0.30001517": version: 1.0.30001518 resolution: "caniuse-lite@npm:1.0.30001518" @@ -4721,6 +5470,13 @@ __metadata: languageName: node linkType: hard +"caniuse-lite@npm:^1.0.30001520": + version: 1.0.30001525 + resolution: "caniuse-lite@npm:1.0.30001525" + checksum: a0d190c185b8e1220dbc72e42f310633059aa175ca3396eb781b249ac3da6c62b30cb8efc5fa24d632cb938f58d90b0c7772d1c9942b6643cf418c27c2cb8632 + languageName: node + linkType: hard + "catering@npm:^2.0.0, catering@npm:^2.1.0": version: 2.1.1 resolution: "catering@npm:2.1.1" @@ -4728,6 +5484,22 @@ __metadata: languageName: node linkType: hard +"chalk-template@npm:0.4.0": + version: 0.4.0 + resolution: "chalk-template@npm:0.4.0" + dependencies: + chalk: ^4.1.2 + checksum: 6c706802a79a7963cbce18f022b046fe86e438a67843151868852f80ea7346e975a6a9749991601e7e5d3b6a6c4852a04c53dc966a9a3d04031bd0e0ed53c819 + languageName: node + linkType: hard + +"chalk@npm:5.0.1": + version: 5.0.1 + resolution: "chalk@npm:5.0.1" + checksum: 7b45300372b908f0471fbf7389ce2f5de8d85bb949026fd51a1b95b10d0ed32c7ed5aab36dd5e9d2bf3191867909b4404cef75c5f4d2d1daeeacd301dd280b76 + languageName: node + linkType: hard + "chalk@npm:^2.0.0": version: 2.4.2 resolution: "chalk@npm:2.4.2" @@ -4749,6 +5521,13 @@ __metadata: languageName: node linkType: hard +"chalk@npm:^5.0.1": + version: 5.3.0 + resolution: "chalk@npm:5.3.0" + checksum: 623922e077b7d1e9dedaea6f8b9e9352921f8ae3afe739132e0e00c275971bdd331268183b2628cf4ab1727c45ea1f28d7e24ac23ce1db1eb653c414ca8a5a80 + languageName: node + linkType: hard + "char-regex@npm:^1.0.2": version: 1.0.2 resolution: "char-regex@npm:1.0.2" @@ -4756,6 +5535,25 @@ __metadata: languageName: node linkType: hard +"chokidar@npm:^3.5.3": + version: 3.5.3 + resolution: "chokidar@npm:3.5.3" + dependencies: + anymatch: ~3.1.2 + braces: ~3.0.2 + fsevents: ~2.3.2 + glob-parent: ~5.1.2 + is-binary-path: ~2.1.0 + is-glob: ~4.0.1 + normalize-path: ~3.0.0 + readdirp: ~3.6.0 + dependenciesMeta: + fsevents: + optional: true + checksum: b49fcde40176ba007ff361b198a2d35df60d9bb2a5aab228279eb810feae9294a6b4649ab15981304447afe1e6ffbf4788ad5db77235dc770ab777c6e771980c + languageName: node + linkType: hard + "chownr@npm:^2.0.0": version: 2.0.0 resolution: "chownr@npm:2.0.0" @@ -4823,6 +5621,24 @@ __metadata: languageName: node linkType: hard +"cli-boxes@npm:^3.0.0": + version: 3.0.0 + resolution: "cli-boxes@npm:3.0.0" + checksum: 637d84419d293a9eac40a1c8c96a2859e7d98b24a1a317788e13c8f441be052fc899480c6acab3acc82eaf1bccda6b7542d7cdcf5c9c3cc39227175dc098d5b2 + languageName: node + linkType: hard + +"clipboardy@npm:3.0.0": + version: 3.0.0 + resolution: "clipboardy@npm:3.0.0" + dependencies: + arch: ^2.2.0 + execa: ^5.1.1 + is-wsl: ^2.2.0 + checksum: 2c292acb59705494cbe07d7df7c8becff4f01651514d32ebd80f4aec2d20946d8f3824aac67ecdf2d09ef21fdf0eb24b6a7f033c137ccdceedc4661c54455c94 + languageName: node + linkType: hard + "cliui@npm:^8.0.1": version: 8.0.1 resolution: "cliui@npm:8.0.1" @@ -4932,7 +5748,7 @@ __metadata: languageName: node linkType: hard -"colorette@npm:^2.0.14": +"colorette@npm:^2.0.10, colorette@npm:^2.0.14": version: 2.0.20 resolution: "colorette@npm:2.0.20" checksum: 0c016fea2b91b733eb9f4bcdb580018f52c0bc0979443dad930e5037a968237ac53d9beb98e218d2e9235834f8eebce7f8e080422d6194e957454255bde71d3d @@ -4979,6 +5795,13 @@ __metadata: languageName: node linkType: hard +"commander@npm:^4.0.0": + version: 4.1.1 + resolution: "commander@npm:4.1.1" + checksum: d7b9913ff92cae20cb577a4ac6fcc121bd6223319e54a40f51a14740a681ad5c574fd29a57da478a5f234a6fa6c52cbf0b7c641353e03c648b1ae85ba670b977 + languageName: node + linkType: hard + "commander@npm:^9.0.0": version: 9.5.0 resolution: "commander@npm:9.5.0" @@ -5012,7 +5835,7 @@ __metadata: languageName: node linkType: hard -"compressible@npm:^2.0.18": +"compressible@npm:^2.0.18, compressible@npm:~2.0.16": version: 2.0.18 resolution: "compressible@npm:2.0.18" dependencies: @@ -5021,6 +5844,21 @@ __metadata: languageName: node linkType: hard +"compression@npm:1.7.4, compression@npm:^1.7.4": + version: 1.7.4 + resolution: "compression@npm:1.7.4" + dependencies: + accepts: ~1.3.5 + bytes: 3.0.0 + compressible: ~2.0.16 + debug: 2.6.9 + on-headers: ~1.0.2 + safe-buffer: 5.1.2 + vary: ~1.1.2 + checksum: 35c0f2eb1f28418978615dc1bc02075b34b1568f7f56c62d60f4214d4b7cc00d0f6d282b5f8a954f59872396bd770b6b15ffd8aa94c67d4bce9b8887b906999b + languageName: node + linkType: hard + "concat-map@npm:0.0.1": version: 0.0.1 resolution: "concat-map@npm:0.0.1" @@ -5068,6 +5906,13 @@ __metadata: languageName: node linkType: hard +"connect-history-api-fallback@npm:^2.0.0": + version: 2.0.0 + resolution: "connect-history-api-fallback@npm:2.0.0" + checksum: dc5368690f4a5c413889792f8df70d5941ca9da44523cde3f87af0745faee5ee16afb8195434550f0504726642734f2683d6c07f8b460f828a12c45fbd4c9a68 + languageName: node + linkType: hard + "console-control-strings@npm:^1.1.0": version: 1.1.0 resolution: "console-control-strings@npm:1.1.0" @@ -5075,7 +5920,14 @@ __metadata: languageName: node linkType: hard -"content-disposition@npm:~0.5.2": +"content-disposition@npm:0.5.2": + version: 0.5.2 + resolution: "content-disposition@npm:0.5.2" + checksum: 298d7da63255a38f7858ee19c7b6aae32b167e911293174b4c1349955e97e78e1d0b0d06c10e229405987275b417cf36ff65cbd4821a98bc9df4e41e9372cde7 + languageName: node + linkType: hard + +"content-disposition@npm:0.5.4, content-disposition@npm:~0.5.2": version: 0.5.4 resolution: "content-disposition@npm:0.5.4" dependencies: @@ -5084,7 +5936,7 @@ __metadata: languageName: node linkType: hard -"content-type@npm:^1.0.4": +"content-type@npm:^1.0.4, content-type@npm:~1.0.4": version: 1.0.5 resolution: "content-type@npm:1.0.5" checksum: 566271e0a251642254cde0f845f9dd4f9856e52d988f4eb0d0dcffbb7a1f8ec98de7a5215fc628f3bce30fe2fb6fd2bc064b562d721658c59b544e2d34ea2766 @@ -5119,6 +5971,20 @@ __metadata: languageName: node linkType: hard +"cookie-signature@npm:1.0.6": + version: 1.0.6 + resolution: "cookie-signature@npm:1.0.6" + checksum: f4e1b0a98a27a0e6e66fd7ea4e4e9d8e038f624058371bf4499cfcd8f3980be9a121486995202ba3fca74fbed93a407d6d54d43a43f96fd28d0bd7a06761591a + languageName: node + linkType: hard + +"cookie@npm:0.5.0": + version: 0.5.0 + resolution: "cookie@npm:0.5.0" + checksum: 1f4bd2ca5765f8c9689a7e8954183f5332139eb72b6ff783d8947032ec1fdf43109852c178e21a953a30c0dd42257828185be01b49d1eb1a67fd054ca588a180 + languageName: node + linkType: hard + "cookiejar@npm:^2.1.4": version: 2.1.4 resolution: "cookiejar@npm:2.1.4" @@ -5143,6 +6009,22 @@ __metadata: languageName: node linkType: hard +"copy-webpack-plugin@npm:^11.0.0": + version: 11.0.0 + resolution: "copy-webpack-plugin@npm:11.0.0" + dependencies: + fast-glob: ^3.2.11 + glob-parent: ^6.0.1 + globby: ^13.1.1 + normalize-path: ^3.0.0 + schema-utils: ^4.0.0 + serialize-javascript: ^6.0.0 + peerDependencies: + webpack: ^5.1.0 + checksum: df4f8743f003a29ee7dd3d9b1789998a3a99051c92afb2ba2203d3dacfa696f4e757b275560fafb8f206e520a0aa78af34b990324a0e36c2326cefdeef3ca82e + languageName: node + linkType: hard + "core-js@npm:^3.6.5": version: 3.32.0 resolution: "core-js@npm:3.32.0" @@ -5150,7 +6032,7 @@ __metadata: languageName: node linkType: hard -"core-util-is@npm:^1.0.2": +"core-util-is@npm:^1.0.2, core-util-is@npm:~1.0.0": version: 1.0.3 resolution: "core-util-is@npm:1.0.3" checksum: 9de8597363a8e9b9952491ebe18167e3b36e7707569eed0ebf14f8bba773611376466ae34575bca8cfe3c767890c859c74056084738f09d4e4a6f902b2ad7d99 @@ -5169,6 +6051,23 @@ __metadata: languageName: node linkType: hard +"cosmiconfig@npm:^8.2.0": + version: 8.3.0 + resolution: "cosmiconfig@npm:8.3.0" + dependencies: + import-fresh: ^3.3.0 + js-yaml: ^4.1.0 + parse-json: ^5.2.0 + path-type: ^4.0.0 + peerDependencies: + typescript: ">=4.9.5" + peerDependenciesMeta: + typescript: + optional: true + checksum: 535e2d542aa31c764840a25e2d22189a59d0bbad56df2eaf3eb85a9e8c696f7ba19e8545e1ff03720e281f5a284f7a73e0f8729b30804474207bcbc8de83cb7c + languageName: node + linkType: hard + "create-ecdh@npm:^4.0.0": version: 4.0.4 resolution: "create-ecdh@npm:4.0.4" @@ -5261,14 +6160,55 @@ __metadata: languageName: node linkType: hard -"data-uri-to-buffer@npm:^5.0.1": - version: 5.0.1 - resolution: "data-uri-to-buffer@npm:5.0.1" - checksum: 10958f89c0047b84bd86d572b6b77c9bf238ebe7b55a9a9ab04c90fbf5ab1881783b72e31dc0febdffd30ec914930244f2f728e3629bb8911d922baba129426f +"css-loader@npm:^6.8.1": + version: 6.8.1 + resolution: "css-loader@npm:6.8.1" + dependencies: + icss-utils: ^5.1.0 + postcss: ^8.4.21 + postcss-modules-extract-imports: ^3.0.0 + postcss-modules-local-by-default: ^4.0.3 + postcss-modules-scope: ^3.0.0 + postcss-modules-values: ^4.0.0 + postcss-value-parser: ^4.2.0 + semver: ^7.3.8 + peerDependencies: + webpack: ^5.0.0 + checksum: 7c1784247bdbe76dc5c55fb1ac84f1d4177a74c47259942c9cfdb7a8e6baef11967a0bc85ac285f26bd26d5059decb848af8154a03fdb4f4894f41212f45eef3 languageName: node linkType: hard -"datastore-core@npm:^9.0.1": +"cssesc@npm:^3.0.0": + version: 3.0.0 + resolution: "cssesc@npm:3.0.0" + bin: + cssesc: bin/cssesc + checksum: f8c4ababffbc5e2ddf2fa9957dda1ee4af6048e22aeda1869d0d00843223c1b13ad3f5d88b51caa46c994225eacb636b764eb807a8883e2fb6f99b4f4e8c48b2 + languageName: node + linkType: hard + +"csstype@npm:^3.0.2": + version: 3.1.2 + resolution: "csstype@npm:3.1.2" + checksum: e1a52e6c25c1314d6beef5168da704ab29c5186b877c07d822bd0806717d9a265e8493a2e35ca7e68d0f5d472d43fac1cdce70fd79fd0853dff81f3028d857b5 + languageName: node + linkType: hard + +"data-uri-to-buffer@npm:^4.0.0": + version: 4.0.1 + resolution: "data-uri-to-buffer@npm:4.0.1" + checksum: 0d0790b67ffec5302f204c2ccca4494f70b4e2d940fea3d36b09f0bb2b8539c2e86690429eb1f1dc4bcc9e4df0644193073e63d9ee48ac9fce79ec1506e4aa4c + languageName: node + linkType: hard + +"data-uri-to-buffer@npm:^5.0.1": + version: 5.0.1 + resolution: "data-uri-to-buffer@npm:5.0.1" + checksum: 10958f89c0047b84bd86d572b6b77c9bf238ebe7b55a9a9ab04c90fbf5ab1881783b72e31dc0febdffd30ec914930244f2f728e3629bb8911d922baba129426f + languageName: node + linkType: hard + +"datastore-core@npm:^9.0.1": version: 9.2.0 resolution: "datastore-core@npm:9.2.0" dependencies: @@ -5298,6 +6238,15 @@ __metadata: languageName: node linkType: hard +"debug@npm:2.6.9": + version: 2.6.9 + resolution: "debug@npm:2.6.9" + dependencies: + ms: 2.0.0 + checksum: d2f51589ca66df60bf36e1fa6e4386b318c3f1e06772280eea5b1ae9fd3d05e9c2b7fd8a7d862457d00853c75b00451aa2d7459b924629ee385287a650f58fe6 + languageName: node + linkType: hard + "debug@npm:4, debug@npm:4.3.4, debug@npm:^4.1.0, debug@npm:^4.1.1, debug@npm:^4.3.1, debug@npm:^4.3.2, debug@npm:^4.3.3, debug@npm:^4.3.4": version: 4.3.4 resolution: "debug@npm:4.3.4" @@ -5355,6 +6304,13 @@ __metadata: languageName: node linkType: hard +"deep-extend@npm:^0.6.0": + version: 0.6.0 + resolution: "deep-extend@npm:0.6.0" + checksum: 7be7e5a8d468d6b10e6a67c3de828f55001b6eb515d014f7aeb9066ce36bd5717161eb47d6a0f7bed8a9083935b465bc163ee2581c8b128d29bf61092fdf57a7 + languageName: node + linkType: hard + "deep-is@npm:^0.1.3": version: 0.1.4 resolution: "deep-is@npm:0.1.4" @@ -5362,6 +6318,13 @@ __metadata: languageName: node linkType: hard +"deepmerge@npm:^2.1.1": + version: 2.2.1 + resolution: "deepmerge@npm:2.2.1" + checksum: 284b71065079e66096229f735a9a0222463c9ca9ee9dda7d5e9a0545bf254906dbc7377e3499ca3b2212073672b1a430d80587993b43b87d8de17edc6af649a8 + languageName: node + linkType: hard + "deepmerge@npm:^4.2.2": version: 4.3.1 resolution: "deepmerge@npm:4.3.1" @@ -5391,7 +6354,7 @@ __metadata: languageName: node linkType: hard -"default-gateway@npm:^6.0.2": +"default-gateway@npm:^6.0.2, default-gateway@npm:^6.0.3": version: 6.0.3 resolution: "default-gateway@npm:6.0.3" dependencies: @@ -5410,6 +6373,13 @@ __metadata: languageName: node linkType: hard +"define-lazy-prop@npm:^2.0.0": + version: 2.0.0 + resolution: "define-lazy-prop@npm:2.0.0" + checksum: 0115fdb065e0490918ba271d7339c42453d209d4cb619dfe635870d906731eff3e1ade8028bb461ea27ce8264ec5e22c6980612d332895977e89c1bbc80fcee2 + languageName: node + linkType: hard + "define-lazy-prop@npm:^3.0.0": version: 3.0.0 resolution: "define-lazy-prop@npm:3.0.0" @@ -5483,7 +6453,7 @@ __metadata: languageName: node linkType: hard -"destroy@npm:^1.0.4": +"destroy@npm:1.2.0, destroy@npm:^1.0.4": version: 1.2.0 resolution: "destroy@npm:1.2.0" checksum: 0acb300b7478a08b92d810ab229d5afe0d2f4399272045ab22affa0d99dbaf12637659411530a6fcd597a9bdac718fc94373a61a95b4651bbc7b83684a565e38 @@ -5497,7 +6467,7 @@ __metadata: languageName: node linkType: hard -"detect-node@npm:^2.1.0": +"detect-node@npm:^2.0.4, detect-node@npm:^2.1.0": version: 2.1.0 resolution: "detect-node@npm:2.1.0" checksum: 832184ec458353e41533ac9c622f16c19f7c02d8b10c303dfd3a756f56be93e903616c0bb2d4226183c9351c15fc0b3dba41a17a2308262afabcfa3776e6ae6e @@ -5528,6 +6498,13 @@ __metadata: languageName: node linkType: hard +"didyoumean@npm:^1.2.2": + version: 1.2.2 + resolution: "didyoumean@npm:1.2.2" + checksum: d5d98719d58b3c2fa59663c4c42ba9716f1fd01245c31d5fce31915bd3aa26e6aac149788e007358f778ebbd68a2256eb5973e8ca6f221df221ba060115acf2e + languageName: node + linkType: hard + "diff-sequences@npm:^29.4.3": version: 29.4.3 resolution: "diff-sequences@npm:29.4.3" @@ -5535,6 +6512,13 @@ __metadata: languageName: node linkType: hard +"diff-sequences@npm:^29.6.3": + version: 29.6.3 + resolution: "diff-sequences@npm:29.6.3" + checksum: f4914158e1f2276343d98ff5b31fc004e7304f5470bf0f1adb2ac6955d85a531a6458d33e87667f98f6ae52ebd3891bb47d420bb48a5bd8b7a27ee25b20e33aa + languageName: node + linkType: hard + "diff@npm:^4.0.1": version: 4.0.2 resolution: "diff@npm:4.0.2" @@ -5562,6 +6546,20 @@ __metadata: languageName: node linkType: hard +"dlv@npm:^1.1.3": + version: 1.1.3 + resolution: "dlv@npm:1.1.3" + checksum: d7381bca22ed11933a1ccf376db7a94bee2c57aa61e490f680124fa2d1cd27e94eba641d9f45be57caab4f9a6579de0983466f620a2cd6230d7ec93312105ae7 + languageName: node + linkType: hard + +"dns-equal@npm:^1.0.0": + version: 1.0.0 + resolution: "dns-equal@npm:1.0.0" + checksum: a8471ac849c7c13824f053babea1bc26e2f359394dd5a460f8340d8abd13434be01e3327a5c59d212f8c8997817450efd3f3ac77bec709b21979cf0235644524 + languageName: node + linkType: hard + "dns-over-http-resolver@npm:^2.1.0": version: 2.1.1 resolution: "dns-over-http-resolver@npm:2.1.1" @@ -5574,6 +6572,15 @@ __metadata: languageName: node linkType: hard +"dns-packet@npm:^5.2.2": + version: 5.6.1 + resolution: "dns-packet@npm:5.6.1" + dependencies: + "@leichtgewicht/ip-codec": ^2.0.1 + checksum: 64c06457f0c6e143f7a0946e0aeb8de1c5f752217cfa143ef527467c00a6d78db1835cfdb6bb68333d9f9a4963cf23f410439b5262a8935cce1236f45e344b81 + languageName: node + linkType: hard + "doctrine@npm:^2.1.0": version: 2.1.0 resolution: "doctrine@npm:2.1.0" @@ -5670,7 +6677,7 @@ __metadata: languageName: node linkType: hard -"encodeurl@npm:^1.0.2": +"encodeurl@npm:^1.0.2, encodeurl@npm:~1.0.2": version: 1.0.2 resolution: "encodeurl@npm:1.0.2" checksum: e50e3d508cdd9c4565ba72d2012e65038e5d71bdc9198cb125beb6237b5b1ade6c0d343998da9e170fb2eae52c1bed37d4d6d98a46ea423a0cddbed5ac3f780c @@ -5913,7 +6920,7 @@ __metadata: languageName: node linkType: hard -"escape-html@npm:^1.0.3": +"escape-html@npm:^1.0.3, escape-html@npm:~1.0.3": version: 1.0.3 resolution: "escape-html@npm:1.0.3" checksum: 6213ca9ae00d0ab8bccb6d8d4e0a98e76237b2410302cf7df70aaa6591d509a2a37ce8998008cbecae8fc8ffaadf3fb0229535e6a145f3ce0b211d060decbb24 @@ -6057,6 +7064,24 @@ __metadata: languageName: node linkType: hard +"eslint-plugin-react-hooks@npm:^4.6.0": + version: 4.6.0 + resolution: "eslint-plugin-react-hooks@npm:4.6.0" + peerDependencies: + eslint: ^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0-0 + checksum: 23001801f14c1d16bf0a837ca7970d9dd94e7b560384b41db378b49b6e32dc43d6e2790de1bd737a652a86f81a08d6a91f402525061b47719328f586a57e86c3 + languageName: node + linkType: hard + +"eslint-plugin-react-refresh@npm:^0.4.3": + version: 0.4.3 + resolution: "eslint-plugin-react-refresh@npm:0.4.3" + peerDependencies: + eslint: ">=7" + checksum: 0332c950bb46c3058fd06acb1dbdc3ea0af05238645f4c0f575e0e367440dc56afb928f855833d321b9e8109e08c63d5f476cc55d507f883a80c289bfcd509cb + languageName: node + linkType: hard + "eslint-plugin-tsdoc@npm:^0.2.17": version: 0.2.17 resolution: "eslint-plugin-tsdoc@npm:0.2.17" @@ -6094,6 +7119,13 @@ __metadata: languageName: node linkType: hard +"eslint-visitor-keys@npm:^3.4.3": + version: 3.4.3 + resolution: "eslint-visitor-keys@npm:3.4.3" + checksum: 36e9ef87fca698b6fd7ca5ca35d7b2b6eeaaf106572e2f7fd31c12d3bfdaccdb587bba6d3621067e5aece31c8c3a348b93922ab8f7b2cbc6aaab5e1d89040c60 + languageName: node + linkType: hard + "eslint@npm:^8.21.0, eslint@npm:^8.35.0, eslint@npm:^8.37.0": version: 8.46.0 resolution: "eslint@npm:8.46.0" @@ -6141,6 +7173,53 @@ __metadata: languageName: node linkType: hard +"eslint@npm:^8.45.0": + version: 8.48.0 + resolution: "eslint@npm:8.48.0" + dependencies: + "@eslint-community/eslint-utils": ^4.2.0 + "@eslint-community/regexpp": ^4.6.1 + "@eslint/eslintrc": ^2.1.2 + "@eslint/js": 8.48.0 + "@humanwhocodes/config-array": ^0.11.10 + "@humanwhocodes/module-importer": ^1.0.1 + "@nodelib/fs.walk": ^1.2.8 + ajv: ^6.12.4 + chalk: ^4.0.0 + cross-spawn: ^7.0.2 + debug: ^4.3.2 + doctrine: ^3.0.0 + escape-string-regexp: ^4.0.0 + eslint-scope: ^7.2.2 + eslint-visitor-keys: ^3.4.3 + espree: ^9.6.1 + esquery: ^1.4.2 + esutils: ^2.0.2 + fast-deep-equal: ^3.1.3 + file-entry-cache: ^6.0.1 + find-up: ^5.0.0 + glob-parent: ^6.0.2 + globals: ^13.19.0 + graphemer: ^1.4.0 + ignore: ^5.2.0 + imurmurhash: ^0.1.4 + is-glob: ^4.0.0 + is-path-inside: ^3.0.3 + js-yaml: ^4.1.0 + json-stable-stringify-without-jsonify: ^1.0.1 + levn: ^0.4.1 + lodash.merge: ^4.6.2 + minimatch: ^3.1.2 + natural-compare: ^1.4.0 + optionator: ^0.9.3 + strip-ansi: ^6.0.1 + text-table: ^0.2.0 + bin: + eslint: bin/eslint.js + checksum: f20b359a4f8123fec5c033577368cc020d42978b1b45303974acd8da7a27063168ee3fe297ab5b35327162f6a93154063e3ce6577102f70f9809aff793db9bd0 + languageName: node + linkType: hard + "espree@npm:^9.6.0, espree@npm:^9.6.1": version: 9.6.1 resolution: "espree@npm:9.6.1" @@ -6201,6 +7280,13 @@ __metadata: languageName: node linkType: hard +"etag@npm:~1.8.1": + version: 1.8.1 + resolution: "etag@npm:1.8.1" + checksum: 571aeb3dbe0f2bbd4e4fadbdb44f325fc75335cd5f6f6b6a091e6a06a9f25ed5392f0863c5442acb0646787446e816f13cbfc6edce5b07658541dff573cab1ff + languageName: node + linkType: hard + "event-iterator@npm:^2.0.0": version: 2.0.0 resolution: "event-iterator@npm:2.0.0" @@ -6223,7 +7309,7 @@ __metadata: languageName: node linkType: hard -"eventemitter3@npm:^4.0.7": +"eventemitter3@npm:^4.0.0, eventemitter3@npm:^4.0.7": version: 4.0.7 resolution: "eventemitter3@npm:4.0.7" checksum: 1875311c42fcfe9c707b2712c32664a245629b42bb0a5a84439762dd0fd637fc54d078155ea83c2af9e0323c9ac13687e03cfba79b03af9f40c89b4960099374 @@ -6248,7 +7334,7 @@ __metadata: languageName: node linkType: hard -"execa@npm:^5.0.0": +"execa@npm:^5.0.0, execa@npm:^5.1.1": version: 5.1.1 resolution: "execa@npm:5.1.1" dependencies: @@ -6303,6 +7389,19 @@ __metadata: languageName: node linkType: hard +"expect@npm:^29.6.4": + version: 29.6.4 + resolution: "expect@npm:29.6.4" + dependencies: + "@jest/expect-utils": ^29.6.4 + jest-get-type: ^29.6.3 + jest-matcher-utils: ^29.6.4 + jest-message-util: ^29.6.3 + jest-util: ^29.6.3 + checksum: 019b187d665562e4948b239e011a8791363e916f3076a229298d625e67fdadb06e8c2748798c49b4cf418ea223673eadd1de06537e08ba3c055c6f0efefc2306 + languageName: node + linkType: hard + "exponential-backoff@npm:^3.1.1": version: 3.1.1 resolution: "exponential-backoff@npm:3.1.1" @@ -6310,6 +7409,45 @@ __metadata: languageName: node linkType: hard +"express@npm:^4.17.3": + version: 4.18.2 + resolution: "express@npm:4.18.2" + dependencies: + accepts: ~1.3.8 + array-flatten: 1.1.1 + body-parser: 1.20.1 + content-disposition: 0.5.4 + content-type: ~1.0.4 + cookie: 0.5.0 + cookie-signature: 1.0.6 + debug: 2.6.9 + depd: 2.0.0 + encodeurl: ~1.0.2 + escape-html: ~1.0.3 + etag: ~1.8.1 + finalhandler: 1.2.0 + fresh: 0.5.2 + http-errors: 2.0.0 + merge-descriptors: 1.0.1 + methods: ~1.1.2 + on-finished: 2.4.1 + parseurl: ~1.3.3 + path-to-regexp: 0.1.7 + proxy-addr: ~2.0.7 + qs: 6.11.0 + range-parser: ~1.2.1 + safe-buffer: 5.2.1 + send: 0.18.0 + serve-static: 1.15.0 + setprototypeof: 1.2.0 + statuses: 2.0.1 + type-is: ~1.6.18 + utils-merge: 1.0.1 + vary: ~1.1.2 + checksum: 3c4b9b076879442f6b968fe53d85d9f1eeacbb4f4c41e5f16cc36d77ce39a2b0d81b3f250514982110d815b2f7173f5561367f9110fcc541f9371948e8c8b037 + languageName: node + linkType: hard + "extract-zip@npm:2.0.1": version: 2.0.1 resolution: "extract-zip@npm:2.0.1" @@ -6341,7 +7479,7 @@ __metadata: languageName: node linkType: hard -"fast-glob@npm:^3.2.9, fast-glob@npm:^3.3.0": +"fast-glob@npm:^3.2.11, fast-glob@npm:^3.2.12, fast-glob@npm:^3.2.9, fast-glob@npm:^3.3.0": version: 3.3.1 resolution: "fast-glob@npm:3.3.1" dependencies: @@ -6375,6 +7513,15 @@ __metadata: languageName: node linkType: hard +"fast-url-parser@npm:1.1.3": + version: 1.1.3 + resolution: "fast-url-parser@npm:1.1.3" + dependencies: + punycode: ^1.3.2 + checksum: 5043d0c4a8d775ff58504d56c096563c11b113e4cb8a2668c6f824a1cd4fb3812e2fdf76537eb24a7ce4ae7def6bd9747da630c617cf2a4b6ce0c42514e4f21c + languageName: node + linkType: hard + "fastest-levenshtein@npm:^1.0.12": version: 1.0.16 resolution: "fastest-levenshtein@npm:1.0.16" @@ -6391,6 +7538,15 @@ __metadata: languageName: node linkType: hard +"faye-websocket@npm:^0.11.3": + version: 0.11.4 + resolution: "faye-websocket@npm:0.11.4" + dependencies: + websocket-driver: ">=0.5.1" + checksum: d49a62caf027f871149fc2b3f3c7104dc6d62744277eb6f9f36e2d5714e847d846b9f7f0d0b7169b25a012e24a594cde11a93034b30732e4c683f20b8a5019fa + languageName: node + linkType: hard + "fb-watchman@npm:^2.0.0": version: 2.0.2 resolution: "fb-watchman@npm:2.0.2" @@ -6416,6 +7572,16 @@ __metadata: languageName: node linkType: hard +"fetch-blob@npm:^3.1.2, fetch-blob@npm:^3.1.4": + version: 3.2.0 + resolution: "fetch-blob@npm:3.2.0" + dependencies: + node-domexception: ^1.0.0 + web-streams-polyfill: ^3.0.3 + checksum: f19bc28a2a0b9626e69fd7cf3a05798706db7f6c7548da657cbf5026a570945f5eeaedff52007ea35c8bcd3d237c58a20bf1543bc568ab2422411d762dd3d5bf + languageName: node + linkType: hard + "file-entry-cache@npm:^6.0.1": version: 6.0.1 resolution: "file-entry-cache@npm:6.0.1" @@ -6443,6 +7609,21 @@ __metadata: languageName: node linkType: hard +"finalhandler@npm:1.2.0": + version: 1.2.0 + resolution: "finalhandler@npm:1.2.0" + dependencies: + debug: 2.6.9 + encodeurl: ~1.0.2 + escape-html: ~1.0.3 + on-finished: 2.4.1 + parseurl: ~1.3.3 + statuses: 2.0.1 + unpipe: ~1.0.0 + checksum: 92effbfd32e22a7dff2994acedbd9bcc3aa646a3e919ea6a53238090e87097f8ef07cced90aa2cc421abdf993aefbdd5b00104d55c7c5479a8d00ed105b45716 + languageName: node + linkType: hard + "find-up@npm:^4.0.0, find-up@npm:^4.1.0": version: 4.1.0 resolution: "find-up@npm:4.1.0" @@ -6487,6 +7668,16 @@ __metadata: languageName: node linkType: hard +"follow-redirects@npm:^1.0.0": + version: 1.15.2 + resolution: "follow-redirects@npm:1.15.2" + peerDependenciesMeta: + debug: + optional: true + checksum: faa66059b66358ba65c234c2f2a37fcec029dc22775f35d9ad6abac56003268baf41e55f9ee645957b32c7d9f62baf1f0b906e68267276f54ec4b4c597c2b190 + languageName: node + linkType: hard + "for-each@npm:^0.3.3": version: 0.3.3 resolution: "for-each@npm:0.3.3" @@ -6517,6 +7708,15 @@ __metadata: languageName: node linkType: hard +"formdata-polyfill@npm:^4.0.10": + version: 4.0.10 + resolution: "formdata-polyfill@npm:4.0.10" + dependencies: + fetch-blob: ^3.1.2 + checksum: 82a34df292afadd82b43d4a740ce387bc08541e0a534358425193017bf9fb3567875dc5f69564984b1da979979b70703aa73dee715a17b6c229752ae736dd9db + languageName: node + linkType: hard + "formidable@npm:^2.1.2": version: 2.1.2 resolution: "formidable@npm:2.1.2" @@ -6529,6 +7729,37 @@ __metadata: languageName: node linkType: hard +"formik@npm:^2.4.3": + version: 2.4.3 + resolution: "formik@npm:2.4.3" + dependencies: + deepmerge: ^2.1.1 + hoist-non-react-statics: ^3.3.0 + lodash: ^4.17.21 + lodash-es: ^4.17.21 + react-fast-compare: ^2.0.1 + tiny-warning: ^1.0.2 + tslib: ^2.0.0 + peerDependencies: + react: ">=16.8.0" + checksum: d98dabfce97beb5cf2ff10bdaff61e0cb9e1d29090cfcad706efc793d06674cfe65299d432d32518a2756a58b6b6bfe85ceec8b47b4f5f9dcc375bcd7a37107a + languageName: node + linkType: hard + +"forwarded@npm:0.2.0": + version: 0.2.0 + resolution: "forwarded@npm:0.2.0" + checksum: fd27e2394d8887ebd16a66ffc889dc983fbbd797d5d3f01087c020283c0f019a7d05ee85669383d8e0d216b116d720fc0cef2f6e9b7eb9f4c90c6e0bc7fd28e6 + languageName: node + linkType: hard + +"fraction.js@npm:^4.2.0": + version: 4.3.6 + resolution: "fraction.js@npm:4.3.6" + checksum: e96ae77e64ebfd442d3a5a01a3f0637b0663fc2440bcf2841b3ad9341ba24c81fb2e3e7142e43ef7d088558c6b3f8609df135b201adc7a1c674aea6a71384162 + languageName: node + linkType: hard + "freeport-promise@npm:^2.0.0": version: 2.0.0 resolution: "freeport-promise@npm:2.0.0" @@ -6536,7 +7767,7 @@ __metadata: languageName: node linkType: hard -"fresh@npm:~0.5.2": +"fresh@npm:0.5.2, fresh@npm:~0.5.2": version: 0.5.2 resolution: "fresh@npm:0.5.2" checksum: 13ea8b08f91e669a64e3ba3a20eb79d7ca5379a81f1ff7f4310d54e2320645503cc0c78daedc93dfb6191287295f6479544a649c64d8e41a1c0fb0c221552346 @@ -6590,6 +7821,13 @@ __metadata: languageName: node linkType: hard +"fs-monkey@npm:^1.0.4": + version: 1.0.4 + resolution: "fs-monkey@npm:1.0.4" + checksum: 8b254c982905c0b7e028eab22b410dc35a5c0019c1c860456f5f54ae6a61666e1cb8c6b700d6c88cc873694c00953c935847b9959cc4dcf274aacb8673c1e8bf + languageName: node + linkType: hard + "fs.realpath@npm:^1.0.0": version: 1.0.0 resolution: "fs.realpath@npm:1.0.0" @@ -6759,7 +7997,7 @@ __metadata: languageName: node linkType: hard -"glob-parent@npm:^5.1.2": +"glob-parent@npm:^5.1.2, glob-parent@npm:~5.1.2": version: 5.1.2 resolution: "glob-parent@npm:5.1.2" dependencies: @@ -6768,7 +8006,7 @@ __metadata: languageName: node linkType: hard -"glob-parent@npm:^6.0.2": +"glob-parent@npm:^6.0.1, glob-parent@npm:^6.0.2": version: 6.0.2 resolution: "glob-parent@npm:6.0.2" dependencies: @@ -6784,6 +8022,20 @@ __metadata: languageName: node linkType: hard +"glob@npm:7.1.6": + version: 7.1.6 + resolution: "glob@npm:7.1.6" + dependencies: + fs.realpath: ^1.0.0 + inflight: ^1.0.4 + inherits: 2 + minimatch: ^3.0.4 + once: ^1.3.0 + path-is-absolute: ^1.0.0 + checksum: 351d549dd90553b87c2d3f90ce11aed9e1093c74130440e7ae0592e11bbcd2ce7f0ebb8ba6bfe63aaf9b62166a7f4c80cb84490ae5d78408bb2572bf7d4ee0a6 + languageName: node + linkType: hard + "glob@npm:^10.2.2": version: 10.3.3 resolution: "glob@npm:10.3.3" @@ -6852,7 +8104,7 @@ __metadata: languageName: node linkType: hard -"globby@npm:^13.1.3": +"globby@npm:^13.1.1, globby@npm:^13.1.3": version: 13.2.2 resolution: "globby@npm:13.2.2" dependencies: @@ -6888,6 +8140,13 @@ __metadata: languageName: node linkType: hard +"handle-thing@npm:^2.0.0": + version: 2.0.1 + resolution: "handle-thing@npm:2.0.1" + checksum: 68071f313062315cd9dce55710e9496873945f1dd425107007058fc1629f93002a7649fcc3e464281ce02c7e809a35f5925504ab8105d972cf649f1f47cb7d6c + languageName: node + linkType: hard + "hard-rejection@npm:^2.1.0": version: 2.1.0 resolution: "hard-rejection@npm:2.1.0" @@ -7017,6 +8276,15 @@ __metadata: languageName: node linkType: hard +"hoist-non-react-statics@npm:^3.3.0": + version: 3.3.2 + resolution: "hoist-non-react-statics@npm:3.3.2" + dependencies: + react-is: ^16.7.0 + checksum: b1538270429b13901ee586aa44f4cc3ecd8831c061d06cb8322e50ea17b3f5ce4d0e2e66394761e6c8e152cd8c34fb3b4b690116c6ce2bd45b18c746516cb9e8 + languageName: node + linkType: hard + "hosted-git-info@npm:^2.1.4": version: 2.8.9 resolution: "hosted-git-info@npm:2.8.9" @@ -7024,6 +8292,25 @@ __metadata: languageName: node linkType: hard +"hpack.js@npm:^2.1.6": + version: 2.1.6 + resolution: "hpack.js@npm:2.1.6" + dependencies: + inherits: ^2.0.1 + obuf: ^1.0.0 + readable-stream: ^2.0.1 + wbuf: ^1.1.0 + checksum: 2de144115197967ad6eeee33faf41096c6ba87078703c5cb011632dcfbffeb45784569e0cf02c317bd79c48375597c8ec88c30fff5bb0b023e8f654fb6e9c06e + languageName: node + linkType: hard + +"html-entities@npm:^2.3.2": + version: 2.4.0 + resolution: "html-entities@npm:2.4.0" + checksum: 25bea32642ce9ebd0eedc4d24381883ecb0335ccb8ac26379a0958b9b16652fdbaa725d70207ce54a51db24103436a698a8e454397d3ba8ad81460224751f1dc + languageName: node + linkType: hard + "html-escaper@npm:^2.0.0": version: 2.0.2 resolution: "html-escaper@npm:2.0.2" @@ -7048,6 +8335,13 @@ __metadata: languageName: node linkType: hard +"http-deceiver@npm:^1.2.7": + version: 1.2.7 + resolution: "http-deceiver@npm:1.2.7" + checksum: 64d7d1ae3a6933eb0e9a94e6f27be4af45a53a96c3c34e84ff57113787105a89fff9d1c3df263ef63add823df019b0e8f52f7121e32393bb5ce9a713bf100b41 + languageName: node + linkType: hard + "http-errors@npm:2.0.0, http-errors@npm:^2.0.0": version: 2.0.0 resolution: "http-errors@npm:2.0.0" @@ -7086,6 +8380,13 @@ __metadata: languageName: node linkType: hard +"http-parser-js@npm:>=0.5.1": + version: 0.5.8 + resolution: "http-parser-js@npm:0.5.8" + checksum: 6bbdf2429858e8cf13c62375b0bfb6dc3955ca0f32e58237488bc86cd2378f31d31785fd3ac4ce93f1c74e0189cf8823c91f5cb061696214fd368d2452dc871d + languageName: node + linkType: hard + "http-proxy-agent@npm:^5.0.0": version: 5.0.0 resolution: "http-proxy-agent@npm:5.0.0" @@ -7107,6 +8408,35 @@ __metadata: languageName: node linkType: hard +"http-proxy-middleware@npm:^2.0.3": + version: 2.0.6 + resolution: "http-proxy-middleware@npm:2.0.6" + dependencies: + "@types/http-proxy": ^1.17.8 + http-proxy: ^1.18.1 + is-glob: ^4.0.1 + is-plain-obj: ^3.0.0 + micromatch: ^4.0.2 + peerDependencies: + "@types/express": ^4.17.13 + peerDependenciesMeta: + "@types/express": + optional: true + checksum: 2ee85bc878afa6cbf34491e972ece0f5be0a3e5c98a60850cf40d2a9a5356e1fc57aab6cff33c1fc37691b0121c3a42602d2b1956c52577e87a5b77b62ae1c3a + languageName: node + linkType: hard + +"http-proxy@npm:^1.18.1": + version: 1.18.1 + resolution: "http-proxy@npm:1.18.1" + dependencies: + eventemitter3: ^4.0.0 + follow-redirects: ^1.0.0 + requires-port: ^1.0.0 + checksum: f5bd96bf83e0b1e4226633dbb51f8b056c3e6321917df402deacec31dd7fe433914fc7a2c1831cf7ae21e69c90b3a669b8f434723e9e8b71fd68afe30737b6a5 + languageName: node + linkType: hard + "https-proxy-agent@npm:^5.0.0": version: 5.0.1 resolution: "https-proxy-agent@npm:5.0.1" @@ -7168,6 +8498,15 @@ __metadata: languageName: node linkType: hard +"icss-utils@npm:^5.0.0, icss-utils@npm:^5.1.0": + version: 5.1.0 + resolution: "icss-utils@npm:5.1.0" + peerDependencies: + postcss: ^8.1.0 + checksum: 5c324d283552b1269cfc13a503aaaa172a280f914e5b81544f3803bc6f06a3b585fb79f66f7c771a2c052db7982c18bf92d001e3b47282e3abbbb4c4cc488d68 + languageName: node + linkType: hard + "ieee754@npm:^1.1.13, ieee754@npm:^1.2.1": version: 1.2.1 resolution: "ieee754@npm:1.2.1" @@ -7182,7 +8521,14 @@ __metadata: languageName: node linkType: hard -"import-fresh@npm:^3.2.1": +"immediate@npm:~3.0.5": + version: 3.0.6 + resolution: "immediate@npm:3.0.6" + checksum: f9b3486477555997657f70318cc8d3416159f208bec4cca3ff3442fd266bc23f50f0c9bd8547e1371a6b5e82b821ec9a7044a4f7b944798b25aa3cc6d5e63e62 + languageName: node + linkType: hard + +"import-fresh@npm:^3.2.1, import-fresh@npm:^3.3.0": version: 3.3.0 resolution: "import-fresh@npm:3.3.0" dependencies: @@ -7235,7 +8581,7 @@ __metadata: languageName: node linkType: hard -"inherits@npm:2, inherits@npm:2.0.4, inherits@npm:^2.0.1, inherits@npm:^2.0.3, inherits@npm:^2.0.4, inherits@npm:~2.0.4": +"inherits@npm:2, inherits@npm:2.0.4, inherits@npm:^2.0.1, inherits@npm:^2.0.3, inherits@npm:^2.0.4, inherits@npm:~2.0.3, inherits@npm:~2.0.4": version: 2.0.4 resolution: "inherits@npm:2.0.4" checksum: 4a48a733847879d6cf6691860a6b1e3f0f4754176e4d71494c41f3475553768b10f84b5ce1d40fbd0e34e6bfbb864ee35858ad4dd2cf31e02fc4a154b724d7f1 @@ -7249,6 +8595,13 @@ __metadata: languageName: node linkType: hard +"ini@npm:~1.3.0": + version: 1.3.8 + resolution: "ini@npm:1.3.8" + checksum: dfd98b0ca3a4fc1e323e38a6c8eb8936e31a97a918d3b377649ea15bdb15d481207a0dda1021efbd86b464cae29a0d33c1d7dcaf6c5672bee17fa849bc50a1b3 + languageName: node + linkType: hard + "interface-datastore@npm:^8.2.0": version: 8.2.3 resolution: "interface-datastore@npm:8.2.3" @@ -7306,7 +8659,14 @@ __metadata: languageName: node linkType: hard -"ipaddr.js@npm:^2.1.0": +"ipaddr.js@npm:1.9.1": + version: 1.9.1 + resolution: "ipaddr.js@npm:1.9.1" + checksum: f88d3825981486f5a1942414c8d77dd6674dd71c065adcfa46f578d677edcb99fda25af42675cb59db492fdf427b34a5abfcde3982da11a8fd83a500b41cfe77 + languageName: node + linkType: hard + +"ipaddr.js@npm:^2.0.1, ipaddr.js@npm:^2.1.0": version: 2.1.0 resolution: "ipaddr.js@npm:2.1.0" checksum: 807a054f2bd720c4d97ee479d6c9e865c233bea21f139fb8dabd5a35c4226d2621c42e07b4ad94ff3f82add926a607d8d9d37c625ad0319f0e08f9f2bd1968e2 @@ -7357,6 +8717,15 @@ __metadata: languageName: node linkType: hard +"is-binary-path@npm:~2.1.0": + version: 2.1.0 + resolution: "is-binary-path@npm:2.1.0" + dependencies: + binary-extensions: ^2.0.0 + checksum: 84192eb88cff70d320426f35ecd63c3d6d495da9d805b19bc65b518984b7c0760280e57dbf119b7e9be6b161784a5a673ab2c6abe83abb5198a432232ad5b35c + languageName: node + linkType: hard + "is-boolean-object@npm:^1.1.0": version: 1.1.2 resolution: "is-boolean-object@npm:1.1.2" @@ -7390,6 +8759,15 @@ __metadata: languageName: node linkType: hard +"is-core-module@npm:^2.13.0": + version: 2.13.0 + resolution: "is-core-module@npm:2.13.0" + dependencies: + has: ^1.0.3 + checksum: 053ab101fb390bfeb2333360fd131387bed54e476b26860dc7f5a700bbf34a0ec4454f7c8c4d43e8a0030957e4b3db6e16d35e1890ea6fb654c833095e040355 + languageName: node + linkType: hard + "is-date-object@npm:^1.0.1": version: 1.0.5 resolution: "is-date-object@npm:1.0.5" @@ -7399,7 +8777,7 @@ __metadata: languageName: node linkType: hard -"is-docker@npm:^2.0.0": +"is-docker@npm:^2.0.0, is-docker@npm:^2.1.1": version: 2.2.1 resolution: "is-docker@npm:2.2.1" bin: @@ -7454,7 +8832,7 @@ __metadata: languageName: node linkType: hard -"is-glob@npm:^4.0.0, is-glob@npm:^4.0.1, is-glob@npm:^4.0.3": +"is-glob@npm:^4.0.0, is-glob@npm:^4.0.1, is-glob@npm:^4.0.3, is-glob@npm:~4.0.1": version: 4.0.3 resolution: "is-glob@npm:4.0.3" dependencies: @@ -7532,6 +8910,13 @@ __metadata: languageName: node linkType: hard +"is-plain-obj@npm:^3.0.0": + version: 3.0.0 + resolution: "is-plain-obj@npm:3.0.0" + checksum: a6ebdf8e12ab73f33530641972a72a4b8aed6df04f762070d823808303e4f76d87d5ea5bd76f96a7bbe83d93f04ac7764429c29413bd9049853a69cb630fb21c + languageName: node + linkType: hard + "is-plain-object@npm:^2.0.4": version: 2.0.4 resolution: "is-plain-object@npm:2.0.4" @@ -7541,6 +8926,13 @@ __metadata: languageName: node linkType: hard +"is-port-reachable@npm:4.0.0": + version: 4.0.0 + resolution: "is-port-reachable@npm:4.0.0" + checksum: 47b7e10db8edcef27fbf9e50f0de85ad368d35688790ca64a13db67260111ac5f4b98989b11af06199fa93f25d810bd09a5b21b2c2646529668638f7c34d3c04 + languageName: node + linkType: hard + "is-regex@npm:^1.1.4": version: 1.1.4 resolution: "is-regex@npm:1.1.4" @@ -7626,7 +9018,14 @@ __metadata: languageName: node linkType: hard -"isexe@npm:^2.0.0": +"isarray@npm:~1.0.0": + version: 1.0.0 + resolution: "isarray@npm:1.0.0" + checksum: f032df8e02dce8ec565cf2eb605ea939bdccea528dbcf565cdf92bfa2da9110461159d86a537388ef1acef8815a330642d7885b29010e8f7eac967c9993b65ab + languageName: node + linkType: hard + +"isexe@npm:^2.0.0": version: 2.0.0 resolution: "isexe@npm:2.0.0" checksum: 26bf6c5480dda5161c820c5b5c751ae1e766c587b1f951ea3fcfc973bafb7831ae5b54a31a69bd670220e42e99ec154475025a468eae58ea262f813fdc8d1c62 @@ -7669,6 +9068,19 @@ __metadata: languageName: node linkType: hard +"istanbul-lib-instrument@npm:^6.0.0": + version: 6.0.0 + resolution: "istanbul-lib-instrument@npm:6.0.0" + dependencies: + "@babel/core": ^7.12.3 + "@babel/parser": ^7.14.7 + "@istanbuljs/schema": ^0.1.2 + istanbul-lib-coverage: ^3.2.0 + semver: ^7.5.4 + checksum: b9dc3723a769e65dbe1b912f935088ffc07cf393fa78a3ce79022c91aabb0ad01405ffd56083cdd822e514798e9daae3ea7bfe85633b094ecb335d28eb0a3f97 + languageName: node + linkType: hard + "istanbul-lib-report@npm:^3.0.0": version: 3.0.1 resolution: "istanbul-lib-report@npm:3.0.1" @@ -7962,6 +9374,17 @@ __metadata: languageName: node linkType: hard +"jest-changed-files@npm:^29.6.3": + version: 29.6.3 + resolution: "jest-changed-files@npm:29.6.3" + dependencies: + execa: ^5.0.0 + jest-util: ^29.6.3 + p-limit: ^3.1.0 + checksum: 55bc820a70c220a02fec214d5c48d5e0d829549e5c7b9959776b4ca3f76f5ff20c7c8ff816a847822766f1d712477ab3027f7a66ec61bf65de3f852e878b4dfd + languageName: node + linkType: hard + "jest-circus@npm:^29.6.2": version: 29.6.2 resolution: "jest-circus@npm:29.6.2" @@ -7990,6 +9413,34 @@ __metadata: languageName: node linkType: hard +"jest-circus@npm:^29.6.4": + version: 29.6.4 + resolution: "jest-circus@npm:29.6.4" + dependencies: + "@jest/environment": ^29.6.4 + "@jest/expect": ^29.6.4 + "@jest/test-result": ^29.6.4 + "@jest/types": ^29.6.3 + "@types/node": "*" + chalk: ^4.0.0 + co: ^4.6.0 + dedent: ^1.0.0 + is-generator-fn: ^2.0.0 + jest-each: ^29.6.3 + jest-matcher-utils: ^29.6.4 + jest-message-util: ^29.6.3 + jest-runtime: ^29.6.4 + jest-snapshot: ^29.6.4 + jest-util: ^29.6.3 + p-limit: ^3.1.0 + pretty-format: ^29.6.3 + pure-rand: ^6.0.0 + slash: ^3.0.0 + stack-utils: ^2.0.3 + checksum: 31f64ddf6df4aefe30ef5f8de9da137c9cba58ab5e2a25cf749450735088dc88a9974591a4256d481af0fe64608173c921219f9fad9a7dd87cbe47a79e111be8 + languageName: node + linkType: hard + "jest-cli@npm:^29.6.2": version: 29.6.2 resolution: "jest-cli@npm:29.6.2" @@ -8017,6 +9468,33 @@ __metadata: languageName: node linkType: hard +"jest-cli@npm:^29.6.4": + version: 29.6.4 + resolution: "jest-cli@npm:29.6.4" + dependencies: + "@jest/core": ^29.6.4 + "@jest/test-result": ^29.6.4 + "@jest/types": ^29.6.3 + chalk: ^4.0.0 + exit: ^0.1.2 + graceful-fs: ^4.2.9 + import-local: ^3.0.2 + jest-config: ^29.6.4 + jest-util: ^29.6.3 + jest-validate: ^29.6.3 + prompts: ^2.0.1 + yargs: ^17.3.1 + peerDependencies: + node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 + peerDependenciesMeta: + node-notifier: + optional: true + bin: + jest: bin/jest.js + checksum: 87a85a27eff0e502717b6ee0ce861d3e50d8c47d7298477f8ca10964b958f06c20241d28f1360ce2a85072763483e4924248106a8ed530ca460a56db3fdfc53e + languageName: node + linkType: hard + "jest-config@npm:^29.6.2": version: 29.6.2 resolution: "jest-config@npm:29.6.2" @@ -8055,6 +9533,44 @@ __metadata: languageName: node linkType: hard +"jest-config@npm:^29.6.4": + version: 29.6.4 + resolution: "jest-config@npm:29.6.4" + dependencies: + "@babel/core": ^7.11.6 + "@jest/test-sequencer": ^29.6.4 + "@jest/types": ^29.6.3 + babel-jest: ^29.6.4 + chalk: ^4.0.0 + ci-info: ^3.2.0 + deepmerge: ^4.2.2 + glob: ^7.1.3 + graceful-fs: ^4.2.9 + jest-circus: ^29.6.4 + jest-environment-node: ^29.6.4 + jest-get-type: ^29.6.3 + jest-regex-util: ^29.6.3 + jest-resolve: ^29.6.4 + jest-runner: ^29.6.4 + jest-util: ^29.6.3 + jest-validate: ^29.6.3 + micromatch: ^4.0.4 + parse-json: ^5.2.0 + pretty-format: ^29.6.3 + slash: ^3.0.0 + strip-json-comments: ^3.1.1 + peerDependencies: + "@types/node": "*" + ts-node: ">=9.0.0" + peerDependenciesMeta: + "@types/node": + optional: true + ts-node: + optional: true + checksum: 177352658774344896df3988dbe892e0b117579f45cc43aebc588493665bf19a557e202f097f5b4a987314ec2d84afa0769299ac6e702c5923d1fd3cfa4692b0 + languageName: node + linkType: hard + "jest-diff@npm:^29.6.2": version: 29.6.2 resolution: "jest-diff@npm:29.6.2" @@ -8067,6 +9583,18 @@ __metadata: languageName: node linkType: hard +"jest-diff@npm:^29.6.4": + version: 29.6.4 + resolution: "jest-diff@npm:29.6.4" + dependencies: + chalk: ^4.0.0 + diff-sequences: ^29.6.3 + jest-get-type: ^29.6.3 + pretty-format: ^29.6.3 + checksum: e205c45ab6dbcc660dc2a682cddb20f6a3cbbbdecd2821cce2050619f96dbd7560ee25f7f51d42c302596aeaddbea54390b78be3ab639340d24d67e4d270a8b0 + languageName: node + linkType: hard + "jest-docblock@npm:^29.4.3": version: 29.4.3 resolution: "jest-docblock@npm:29.4.3" @@ -8076,6 +9604,15 @@ __metadata: languageName: node linkType: hard +"jest-docblock@npm:^29.6.3": + version: 29.6.3 + resolution: "jest-docblock@npm:29.6.3" + dependencies: + detect-newline: ^3.0.0 + checksum: 6f3213a1e79e7eedafeb462acfa9a41303f9c0167893b140f6818fa16d7eb6bf3f9b9cf4669097ca6b7154847793489ecd6b4f6cfb0e416b88cfa3b4b36715b6 + languageName: node + linkType: hard + "jest-each@npm:^29.6.2": version: 29.6.2 resolution: "jest-each@npm:29.6.2" @@ -8089,6 +9626,19 @@ __metadata: languageName: node linkType: hard +"jest-each@npm:^29.6.3": + version: 29.6.3 + resolution: "jest-each@npm:29.6.3" + dependencies: + "@jest/types": ^29.6.3 + chalk: ^4.0.0 + jest-get-type: ^29.6.3 + jest-util: ^29.6.3 + pretty-format: ^29.6.3 + checksum: fe06e80b3554e2a8464f5f5c61943e02db1f8a7177139cb55b3201a1d1513cb089d8800401f102729a31bf8dd6f88229044e6088fea9dd5647ed11e841b6b88c + languageName: node + linkType: hard + "jest-environment-node@npm:^29.6.2": version: 29.6.2 resolution: "jest-environment-node@npm:29.6.2" @@ -8103,6 +9653,20 @@ __metadata: languageName: node linkType: hard +"jest-environment-node@npm:^29.6.4": + version: 29.6.4 + resolution: "jest-environment-node@npm:29.6.4" + dependencies: + "@jest/environment": ^29.6.4 + "@jest/fake-timers": ^29.6.4 + "@jest/types": ^29.6.3 + "@types/node": "*" + jest-mock: ^29.6.3 + jest-util: ^29.6.3 + checksum: 518221505af4bd32c84f2af2c03f9d771de2711bd69fe7723b648fcc2e05d95b4e75f493afa9010209e26a4a3309ebee971f9b18c45b540891771d3b68c3a16e + languageName: node + linkType: hard + "jest-get-type@npm:^29.4.3": version: 29.4.3 resolution: "jest-get-type@npm:29.4.3" @@ -8110,6 +9674,13 @@ __metadata: languageName: node linkType: hard +"jest-get-type@npm:^29.6.3": + version: 29.6.3 + resolution: "jest-get-type@npm:29.6.3" + checksum: 88ac9102d4679d768accae29f1e75f592b760b44277df288ad76ce5bf038c3f5ce3719dea8aa0f035dac30e9eb034b848ce716b9183ad7cc222d029f03e92205 + languageName: node + linkType: hard + "jest-haste-map@npm:^29.6.2": version: 29.6.2 resolution: "jest-haste-map@npm:29.6.2" @@ -8133,6 +9704,29 @@ __metadata: languageName: node linkType: hard +"jest-haste-map@npm:^29.6.4": + version: 29.6.4 + resolution: "jest-haste-map@npm:29.6.4" + dependencies: + "@jest/types": ^29.6.3 + "@types/graceful-fs": ^4.1.3 + "@types/node": "*" + anymatch: ^3.0.3 + fb-watchman: ^2.0.0 + fsevents: ^2.3.2 + graceful-fs: ^4.2.9 + jest-regex-util: ^29.6.3 + jest-util: ^29.6.3 + jest-worker: ^29.6.4 + micromatch: ^4.0.4 + walker: ^1.0.8 + dependenciesMeta: + fsevents: + optional: true + checksum: 4f720fd3813bb38400b7a9a094e55664cbddd907ba1769457ed746f6c870c615167647a5b697a788183d832b1dcb1b66143e52990a6f4403283f6686077fa868 + languageName: node + linkType: hard + "jest-leak-detector@npm:^29.6.2": version: 29.6.2 resolution: "jest-leak-detector@npm:29.6.2" @@ -8143,6 +9737,16 @@ __metadata: languageName: node linkType: hard +"jest-leak-detector@npm:^29.6.3": + version: 29.6.3 + resolution: "jest-leak-detector@npm:29.6.3" + dependencies: + jest-get-type: ^29.6.3 + pretty-format: ^29.6.3 + checksum: 27548fcfc7602fe1b88f8600185e35ffff71751f3631e52bbfdfc72776f5a13a430185cf02fc632b41320a74f99ae90e40ce101c8887509f0f919608a7175129 + languageName: node + linkType: hard + "jest-matcher-utils@npm:^29.6.2": version: 29.6.2 resolution: "jest-matcher-utils@npm:29.6.2" @@ -8155,6 +9759,18 @@ __metadata: languageName: node linkType: hard +"jest-matcher-utils@npm:^29.6.4": + version: 29.6.4 + resolution: "jest-matcher-utils@npm:29.6.4" + dependencies: + chalk: ^4.0.0 + jest-diff: ^29.6.4 + jest-get-type: ^29.6.3 + pretty-format: ^29.6.3 + checksum: 9e17bce282e74bdbba2ce5475c490e0bba4f464cd42132bfc5df0337e0853af4dba925c7f4f61cbb0a4818fa121d28d7ff0196ec8829773a22fce59a822976d2 + languageName: node + linkType: hard + "jest-message-util@npm:^29.6.2": version: 29.6.2 resolution: "jest-message-util@npm:29.6.2" @@ -8172,6 +9788,23 @@ __metadata: languageName: node linkType: hard +"jest-message-util@npm:^29.6.3": + version: 29.6.3 + resolution: "jest-message-util@npm:29.6.3" + dependencies: + "@babel/code-frame": ^7.12.13 + "@jest/types": ^29.6.3 + "@types/stack-utils": ^2.0.0 + chalk: ^4.0.0 + graceful-fs: ^4.2.9 + micromatch: ^4.0.4 + pretty-format: ^29.6.3 + slash: ^3.0.0 + stack-utils: ^2.0.3 + checksum: 59f5229a06c073a8877ba4d2e304cc07d63b0062bf5764d4bed14364403889e77f1825d1bd9017c19a840847d17dffd414dc06f1fcb537b5f9e03dbc65b84ada + languageName: node + linkType: hard + "jest-mock-extended@npm:^3.0.3, jest-mock-extended@npm:^3.0.4": version: 3.0.4 resolution: "jest-mock-extended@npm:3.0.4" @@ -8207,6 +9840,17 @@ __metadata: languageName: node linkType: hard +"jest-mock@npm:^29.6.3": + version: 29.6.3 + resolution: "jest-mock@npm:29.6.3" + dependencies: + "@jest/types": ^29.6.3 + "@types/node": "*" + jest-util: ^29.6.3 + checksum: 35772968010c0afb1bb1ef78570b9cbea907c6f967d24b4e95e1a596a1000c63d60e225fb9ddfdd5218674da4aa61d92a09927fc26310cecbbfaa8278d919e32 + languageName: node + linkType: hard + "jest-pnp-resolver@npm:^1.2.2": version: 1.2.3 resolution: "jest-pnp-resolver@npm:1.2.3" @@ -8226,6 +9870,13 @@ __metadata: languageName: node linkType: hard +"jest-regex-util@npm:^29.6.3": + version: 29.6.3 + resolution: "jest-regex-util@npm:29.6.3" + checksum: 0518beeb9bf1228261695e54f0feaad3606df26a19764bc19541e0fc6e2a3737191904607fb72f3f2ce85d9c16b28df79b7b1ec9443aa08c3ef0e9efda6f8f2a + languageName: node + linkType: hard + "jest-resolve-dependencies@npm:^29.6.2": version: 29.6.2 resolution: "jest-resolve-dependencies@npm:29.6.2" @@ -8236,6 +9887,16 @@ __metadata: languageName: node linkType: hard +"jest-resolve-dependencies@npm:^29.6.4": + version: 29.6.4 + resolution: "jest-resolve-dependencies@npm:29.6.4" + dependencies: + jest-regex-util: ^29.6.3 + jest-snapshot: ^29.6.4 + checksum: 34f81d22cbd72203130cc14cbb66d5783d9f59fba4d366b9653f8fb4f6feeaac25d89696f2f77c700659843d5440dc92f58ad443ba05da1da46c39234866d916 + languageName: node + linkType: hard + "jest-resolve@npm:^29.6.2": version: 29.6.2 resolution: "jest-resolve@npm:29.6.2" @@ -8253,6 +9914,23 @@ __metadata: languageName: node linkType: hard +"jest-resolve@npm:^29.6.4": + version: 29.6.4 + resolution: "jest-resolve@npm:29.6.4" + dependencies: + chalk: ^4.0.0 + graceful-fs: ^4.2.9 + jest-haste-map: ^29.6.4 + jest-pnp-resolver: ^1.2.2 + jest-util: ^29.6.3 + jest-validate: ^29.6.3 + resolve: ^1.20.0 + resolve.exports: ^2.0.0 + slash: ^3.0.0 + checksum: 5f0ef260aec79ef00e16e0ba7b27d527054e1faed08a144279cd191b5c5b71af67c52b9ddfd24aa2f563d254618ce9bf7519809f23fb2abf6c4fa375503caa28 + languageName: node + linkType: hard + "jest-runner@npm:^29.6.2": version: 29.6.2 resolution: "jest-runner@npm:29.6.2" @@ -8282,6 +9960,35 @@ __metadata: languageName: node linkType: hard +"jest-runner@npm:^29.6.4": + version: 29.6.4 + resolution: "jest-runner@npm:29.6.4" + dependencies: + "@jest/console": ^29.6.4 + "@jest/environment": ^29.6.4 + "@jest/test-result": ^29.6.4 + "@jest/transform": ^29.6.4 + "@jest/types": ^29.6.3 + "@types/node": "*" + chalk: ^4.0.0 + emittery: ^0.13.1 + graceful-fs: ^4.2.9 + jest-docblock: ^29.6.3 + jest-environment-node: ^29.6.4 + jest-haste-map: ^29.6.4 + jest-leak-detector: ^29.6.3 + jest-message-util: ^29.6.3 + jest-resolve: ^29.6.4 + jest-runtime: ^29.6.4 + jest-util: ^29.6.3 + jest-watcher: ^29.6.4 + jest-worker: ^29.6.4 + p-limit: ^3.1.0 + source-map-support: 0.5.13 + checksum: ca977dd30262171fe000de8407a3187c16e7057ddf690bcc21068155aacd4824ee927b544e0fa9f2885948b47a5123b472da41e095e3bcbdebb79f1fa2f2fc56 + languageName: node + linkType: hard + "jest-runtime@npm:^29.6.2": version: 29.6.2 resolution: "jest-runtime@npm:29.6.2" @@ -8312,6 +10019,36 @@ __metadata: languageName: node linkType: hard +"jest-runtime@npm:^29.6.4": + version: 29.6.4 + resolution: "jest-runtime@npm:29.6.4" + dependencies: + "@jest/environment": ^29.6.4 + "@jest/fake-timers": ^29.6.4 + "@jest/globals": ^29.6.4 + "@jest/source-map": ^29.6.3 + "@jest/test-result": ^29.6.4 + "@jest/transform": ^29.6.4 + "@jest/types": ^29.6.3 + "@types/node": "*" + chalk: ^4.0.0 + cjs-module-lexer: ^1.0.0 + collect-v8-coverage: ^1.0.0 + glob: ^7.1.3 + graceful-fs: ^4.2.9 + jest-haste-map: ^29.6.4 + jest-message-util: ^29.6.3 + jest-mock: ^29.6.3 + jest-regex-util: ^29.6.3 + jest-resolve: ^29.6.4 + jest-snapshot: ^29.6.4 + jest-util: ^29.6.3 + slash: ^3.0.0 + strip-bom: ^4.0.0 + checksum: 93deacd06f8f2bb808dbfb8acbcbc0b724187b3d3fffafd497a32c939bf385ca21f5a3f03eebd5b958a0e93865d0e68a0db73bd0fe16dafbd5e922558aa7b359 + languageName: node + linkType: hard + "jest-snapshot@npm:^29.6.2": version: 29.6.2 resolution: "jest-snapshot@npm:29.6.2" @@ -8340,6 +10077,34 @@ __metadata: languageName: node linkType: hard +"jest-snapshot@npm:^29.6.4": + version: 29.6.4 + resolution: "jest-snapshot@npm:29.6.4" + dependencies: + "@babel/core": ^7.11.6 + "@babel/generator": ^7.7.2 + "@babel/plugin-syntax-jsx": ^7.7.2 + "@babel/plugin-syntax-typescript": ^7.7.2 + "@babel/types": ^7.3.3 + "@jest/expect-utils": ^29.6.4 + "@jest/transform": ^29.6.4 + "@jest/types": ^29.6.3 + babel-preset-current-node-syntax: ^1.0.0 + chalk: ^4.0.0 + expect: ^29.6.4 + graceful-fs: ^4.2.9 + jest-diff: ^29.6.4 + jest-get-type: ^29.6.3 + jest-matcher-utils: ^29.6.4 + jest-message-util: ^29.6.3 + jest-util: ^29.6.3 + natural-compare: ^1.4.0 + pretty-format: ^29.6.3 + semver: ^7.5.3 + checksum: 0c9b5ec640457fb780ac6c9b6caa814436e9e16bf744772eee3bfd055ae5f7a3085a6a09b2f30910e31915dafc3955d92357cc98189e4d5dcb417b5fdafda6e3 + languageName: node + linkType: hard + "jest-util@npm:^29.0.0, jest-util@npm:^29.6.2": version: 29.6.2 resolution: "jest-util@npm:29.6.2" @@ -8354,6 +10119,20 @@ __metadata: languageName: node linkType: hard +"jest-util@npm:^29.6.3": + version: 29.6.3 + resolution: "jest-util@npm:29.6.3" + dependencies: + "@jest/types": ^29.6.3 + "@types/node": "*" + chalk: ^4.0.0 + ci-info: ^3.2.0 + graceful-fs: ^4.2.9 + picomatch: ^2.2.3 + checksum: 7bf3ba3ac67ac6ceff7d8fdd23a86768e23ddd9133ecd9140ef87cc0c28708effabaf67a6cd45cd9d90a63d645a522ed0825d09ee59ac4c03b9c473b1fef4c7c + languageName: node + linkType: hard + "jest-validate@npm:^29.6.2": version: 29.6.2 resolution: "jest-validate@npm:29.6.2" @@ -8368,6 +10147,20 @@ __metadata: languageName: node linkType: hard +"jest-validate@npm:^29.6.3": + version: 29.6.3 + resolution: "jest-validate@npm:29.6.3" + dependencies: + "@jest/types": ^29.6.3 + camelcase: ^6.2.0 + chalk: ^4.0.0 + jest-get-type: ^29.6.3 + leven: ^3.1.0 + pretty-format: ^29.6.3 + checksum: caa489ed11080441c636b8035ab71bafbdc0c052b1e452855e4d2dd24ac15e497710a270ea6fc5ef8926b22c1ce4d6e07ec2dc193f0810cff5851d7a2222c045 + languageName: node + linkType: hard + "jest-watcher@npm:^29.6.2": version: 29.6.2 resolution: "jest-watcher@npm:29.6.2" @@ -8384,6 +10177,22 @@ __metadata: languageName: node linkType: hard +"jest-watcher@npm:^29.6.4": + version: 29.6.4 + resolution: "jest-watcher@npm:29.6.4" + dependencies: + "@jest/test-result": ^29.6.4 + "@jest/types": ^29.6.3 + "@types/node": "*" + ansi-escapes: ^4.2.1 + chalk: ^4.0.0 + emittery: ^0.13.1 + jest-util: ^29.6.3 + string-length: ^4.0.1 + checksum: 13c0f96f7e9212e4f3ef2daf3e787045bdcec414061bf286eca934c7f4083fb04d38df9ced9c0edfbe15f3521ca581eb2ed6108c338a0db1f3e1def65687992f + languageName: node + linkType: hard + "jest-worker@npm:^27.4.5": version: 27.5.1 resolution: "jest-worker@npm:27.5.1" @@ -8407,6 +10216,18 @@ __metadata: languageName: node linkType: hard +"jest-worker@npm:^29.6.4": + version: 29.6.4 + resolution: "jest-worker@npm:29.6.4" + dependencies: + "@types/node": "*" + jest-util: ^29.6.3 + merge-stream: ^2.0.0 + supports-color: ^8.0.0 + checksum: 05d19a5759ebfeb964036065be55ad8d8e8ddffa85d9b3a4c0b95765695efb1d8226ec824a4d8e660c38cda3389bfeb98d819f47232acf9fb0e79f553b7c0a76 + languageName: node + linkType: hard + "jest@npm:^29.5.0": version: 29.6.2 resolution: "jest@npm:29.6.2" @@ -8426,6 +10247,34 @@ __metadata: languageName: node linkType: hard +"jest@npm:^29.6.4": + version: 29.6.4 + resolution: "jest@npm:29.6.4" + dependencies: + "@jest/core": ^29.6.4 + "@jest/types": ^29.6.3 + import-local: ^3.0.2 + jest-cli: ^29.6.4 + peerDependencies: + node-notifier: ^8.0.1 || ^9.0.0 || ^10.0.0 + peerDependenciesMeta: + node-notifier: + optional: true + bin: + jest: bin/jest.js + checksum: ba28ca7a86d029bcd742bb254c0c8d0119c1e002ddae128ff6409ebabc0b29c36f69dbf3fdd326aff16e7b2500c9a918bbc6a9a5db4d966e035127242239439f + languageName: node + linkType: hard + +"jiti@npm:^1.18.2": + version: 1.19.3 + resolution: "jiti@npm:1.19.3" + bin: + jiti: bin/jiti.js + checksum: de3dacdfe30948d96b69712b04cc28127c17f43d5233a5aa069933e04ac4c9aaf265bef4cdf2b0c2a6f5af236a58aea9bfea83e8e289e2490802bdff7f99bff7 + languageName: node + linkType: hard + "jju@npm:~1.4.0": version: 1.4.0 resolution: "jju@npm:1.4.0" @@ -8433,7 +10282,7 @@ __metadata: languageName: node linkType: hard -"js-tokens@npm:^4.0.0": +"js-tokens@npm:^3.0.0 || ^4.0.0, js-tokens@npm:^4.0.0": version: 4.0.0 resolution: "js-tokens@npm:4.0.0" checksum: 8a95213a5a77deb6cbe94d86340e8d9ace2b93bc367790b260101d2f36a2eaf4e4e22d9fa9cf459b38af3a32fb4190e638024cf82ec95ef708680e405ea7cc78 @@ -8493,6 +10342,13 @@ __metadata: languageName: node linkType: hard +"json-schema-traverse@npm:^1.0.0": + version: 1.0.0 + resolution: "json-schema-traverse@npm:1.0.0" + checksum: 02f2f466cdb0362558b2f1fd5e15cce82ef55d60cd7f8fa828cf35ba74330f8d767fcae5c5c2adb7851fa811766c694b9405810879bc4e1ddd78a7c0e03658ad + languageName: node + linkType: hard + "json-stable-stringify-without-jsonify@npm:^1.0.1": version: 1.0.1 resolution: "json-stable-stringify-without-jsonify@npm:1.0.1" @@ -8552,6 +10408,18 @@ __metadata: languageName: node linkType: hard +"jszip@npm:^3.10.1": + version: 3.10.1 + resolution: "jszip@npm:3.10.1" + dependencies: + lie: ~3.3.0 + pako: ~1.0.2 + readable-stream: ~2.3.6 + setimmediate: ^1.0.5 + checksum: abc77bfbe33e691d4d1ac9c74c8851b5761fba6a6986630864f98d876f3fcc2d36817dfc183779f32c00157b5d53a016796677298272a714ae096dfe6b1c8b60 + languageName: node + linkType: hard + "keygrip@npm:~1.1.0": version: 1.1.0 resolution: "keygrip@npm:1.1.0" @@ -8693,6 +10561,16 @@ __metadata: languageName: node linkType: hard +"launch-editor@npm:^2.6.0": + version: 2.6.0 + resolution: "launch-editor@npm:2.6.0" + dependencies: + picocolors: ^1.0.0 + shell-quote: ^1.7.3 + checksum: 48e4230643e8fdb5c14c11314706d58d9f3fbafe2606be3d6e37da1918ad8bfe39dd87875c726a1b59b9f4da99d87ec3e36d4c528464f0b820f9e91e5cb1c02d + languageName: node + linkType: hard + "level-concat-iterator@npm:^3.0.0": version: 3.1.0 resolution: "level-concat-iterator@npm:3.1.0" @@ -8823,6 +10701,22 @@ __metadata: languageName: node linkType: hard +"lie@npm:~3.3.0": + version: 3.3.0 + resolution: "lie@npm:3.3.0" + dependencies: + immediate: ~3.0.5 + checksum: 33102302cf19766f97919a6a98d481e01393288b17a6aa1f030a3542031df42736edde8dab29ffdbf90bebeffc48c761eb1d064dc77592ca3ba3556f9fe6d2a8 + languageName: node + linkType: hard + +"lilconfig@npm:^2.0.5, lilconfig@npm:^2.1.0": + version: 2.1.0 + resolution: "lilconfig@npm:2.1.0" + checksum: 8549bb352b8192375fed4a74694cd61ad293904eee33f9d4866c2192865c44c4eb35d10782966242634e0cbc1e91fe62b1247f148dc5514918e3a966da7ea117 + languageName: node + linkType: hard + "lines-and-columns@npm:^1.1.6": version: 1.2.4 resolution: "lines-and-columns@npm:1.2.4" @@ -8867,6 +10761,13 @@ __metadata: languageName: node linkType: hard +"lodash-es@npm:^4.17.21": + version: 4.17.21 + resolution: "lodash-es@npm:4.17.21" + checksum: 05cbffad6e2adbb331a4e16fbd826e7faee403a1a04873b82b42c0f22090f280839f85b95393f487c1303c8a3d2a010048bf06151a6cbe03eee4d388fb0a12d2 + languageName: node + linkType: hard + "lodash.camelcase@npm:^4.3.0": version: 4.3.0 resolution: "lodash.camelcase@npm:4.3.0" @@ -9045,6 +10946,17 @@ __metadata: languageName: node linkType: hard +"loose-envify@npm:^1.1.0": + version: 1.4.0 + resolution: "loose-envify@npm:1.4.0" + dependencies: + js-tokens: ^3.0.0 || ^4.0.0 + bin: + loose-envify: cli.js + checksum: 6517e24e0cad87ec9888f500c5b5947032cdfe6ef65e1c1936a0c48a524b81e65542c9c3edc91c97d5bddc806ee2a985dbc79be89215d613b1de5db6d1cfe6f4 + languageName: node + linkType: hard + "lru-cache@npm:^5.1.1": version: 5.1.1 resolution: "lru-cache@npm:5.1.1" @@ -9200,6 +11112,15 @@ __metadata: languageName: node linkType: hard +"memfs@npm:^3.4.3": + version: 3.5.3 + resolution: "memfs@npm:3.5.3" + dependencies: + fs-monkey: ^1.0.4 + checksum: 18dfdeacad7c8047b976a6ccd58bc98ba76e122ad3ca0e50a21837fe2075fc0d9aafc58ab9cf2576c2b6889da1dd2503083f2364191b695273f40969db2ecc44 + languageName: node + linkType: hard + "meow@npm:^7.1.1": version: 7.1.1 resolution: "meow@npm:7.1.1" @@ -9219,6 +11140,13 @@ __metadata: languageName: node linkType: hard +"merge-descriptors@npm:1.0.1": + version: 1.0.1 + resolution: "merge-descriptors@npm:1.0.1" + checksum: 5abc259d2ae25bb06d19ce2b94a21632583c74e2a9109ee1ba7fd147aa7362b380d971e0251069f8b3eb7d48c21ac839e21fa177b335e82c76ec172e30c31a26 + languageName: node + linkType: hard + "merge-options@npm:^3.0.4": version: 3.0.4 resolution: "merge-options@npm:3.0.4" @@ -9242,14 +11170,14 @@ __metadata: languageName: node linkType: hard -"methods@npm:^1.1.2": +"methods@npm:^1.1.2, methods@npm:~1.1.2": version: 1.1.2 resolution: "methods@npm:1.1.2" checksum: 0917ff4041fa8e2f2fda5425a955fe16ca411591fbd123c0d722fcf02b73971ed6f764d85f0a6f547ce49ee0221ce2c19a5fa692157931cecb422984f1dcd13a languageName: node linkType: hard -"micromatch@npm:^4.0.0, micromatch@npm:^4.0.4": +"micromatch@npm:^4.0.0, micromatch@npm:^4.0.2, micromatch@npm:^4.0.4, micromatch@npm:^4.0.5": version: 4.0.5 resolution: "micromatch@npm:4.0.5" dependencies: @@ -9278,7 +11206,23 @@ __metadata: languageName: node linkType: hard -"mime-types@npm:^2.1.12, mime-types@npm:^2.1.18, mime-types@npm:^2.1.27, mime-types@npm:~2.1.24, mime-types@npm:~2.1.34": +"mime-db@npm:~1.33.0": + version: 1.33.0 + resolution: "mime-db@npm:1.33.0" + checksum: 281a0772187c9b8f6096976cb193ac639c6007ac85acdbb8dc1617ed7b0f4777fa001d1b4f1b634532815e60717c84b2f280201d55677fb850c9d45015b50084 + languageName: node + linkType: hard + +"mime-types@npm:2.1.18": + version: 2.1.18 + resolution: "mime-types@npm:2.1.18" + dependencies: + mime-db: ~1.33.0 + checksum: 729265eff1e5a0e87cb7f869da742a610679585167d2f2ec997a7387fc6aedf8e5cad078e99b0164a927bdf3ace34fca27430d6487456ad090cba5594441ba43 + languageName: node + linkType: hard + +"mime-types@npm:^2.1.12, mime-types@npm:^2.1.18, mime-types@npm:^2.1.27, mime-types@npm:^2.1.31, mime-types@npm:~2.1.17, mime-types@npm:~2.1.24, mime-types@npm:~2.1.34": version: 2.1.35 resolution: "mime-types@npm:2.1.35" dependencies: @@ -9287,6 +11231,15 @@ __metadata: languageName: node linkType: hard +"mime@npm:1.6.0": + version: 1.6.0 + resolution: "mime@npm:1.6.0" + bin: + mime: cli.js + checksum: fef25e39263e6d207580bdc629f8872a3f9772c923c7f8c7e793175cee22777bbe8bba95e5d509a40aaa292d8974514ce634ae35769faa45f22d17edda5e8557 + languageName: node + linkType: hard + "mime@npm:2.6.0": version: 2.6.0 resolution: "mime@npm:2.6.0" @@ -9331,7 +11284,7 @@ __metadata: languageName: node linkType: hard -"minimatch@npm:^3.0.4, minimatch@npm:^3.0.5, minimatch@npm:^3.1.1, minimatch@npm:^3.1.2": +"minimatch@npm:3.1.2, minimatch@npm:^3.0.4, minimatch@npm:^3.0.5, minimatch@npm:^3.1.1, minimatch@npm:^3.1.2": version: 3.1.2 resolution: "minimatch@npm:3.1.2" dependencies: @@ -9500,6 +11453,13 @@ __metadata: languageName: node linkType: hard +"ms@npm:2.0.0": + version: 2.0.0 + resolution: "ms@npm:2.0.0" + checksum: 0e6a22b8b746d2e0b65a430519934fefd41b6db0682e3477c10f60c76e947c4c0ad06f63ffdf1d78d335f83edee8c0aa928aa66a36c7cd95b69b26f468d527f4 + languageName: node + linkType: hard + "ms@npm:2.1.2": version: 2.1.2 resolution: "ms@npm:2.1.2" @@ -9507,13 +11467,25 @@ __metadata: languageName: node linkType: hard -"ms@npm:^2.0.0, ms@npm:^2.1.1": +"ms@npm:2.1.3, ms@npm:^2.0.0, ms@npm:^2.1.1": version: 2.1.3 resolution: "ms@npm:2.1.3" checksum: aa92de608021b242401676e35cfa5aa42dd70cbdc082b916da7fb925c542173e36bce97ea3e804923fe92c0ad991434e4a38327e15a1b5b5f945d66df615ae6d languageName: node linkType: hard +"multicast-dns@npm:^7.2.5": + version: 7.2.5 + resolution: "multicast-dns@npm:7.2.5" + dependencies: + dns-packet: ^5.2.2 + thunky: ^1.0.2 + bin: + multicast-dns: cli.js + checksum: 00b8a57df152d4cd0297946320a94b7c3cdf75a46a2247f32f958a8927dea42958177f9b7fdae69fab2e4e033fb3416881af1f5e9055a3e1542888767139e2fb + languageName: node + linkType: hard + "multiformats@npm:^11.0.0, multiformats@npm:^11.0.2": version: 11.0.2 resolution: "multiformats@npm:11.0.2" @@ -9528,6 +11500,17 @@ __metadata: languageName: node linkType: hard +"mz@npm:^2.7.0": + version: 2.7.0 + resolution: "mz@npm:2.7.0" + dependencies: + any-promise: ^1.0.0 + object-assign: ^4.0.1 + thenify-all: ^1.0.0 + checksum: 8427de0ece99a07e9faed3c0c6778820d7543e3776f9a84d22cf0ec0a8eb65f6e9aee9c9d353ff9a105ff62d33a9463c6ca638974cc652ee8140cd1e35951c87 + languageName: node + linkType: hard + "nanoid@npm:^3.3.6": version: 3.3.6 resolution: "nanoid@npm:3.3.6" @@ -9604,6 +11587,13 @@ __metadata: languageName: node linkType: hard +"node-domexception@npm:^1.0.0": + version: 1.0.0 + resolution: "node-domexception@npm:1.0.0" + checksum: ee1d37dd2a4eb26a8a92cd6b64dfc29caec72bff5e1ed9aba80c294f57a31ba4895a60fd48347cf17dd6e766da0ae87d75657dfd1f384ebfa60462c2283f5c7f + languageName: node + linkType: hard + "node-fetch@npm:^2.6.12": version: 2.6.12 resolution: "node-fetch@npm:2.6.12" @@ -9618,7 +11608,18 @@ __metadata: languageName: node linkType: hard -"node-forge@npm:^1.1.0": +"node-fetch@npm:^3.3.2": + version: 3.3.2 + resolution: "node-fetch@npm:3.3.2" + dependencies: + data-uri-to-buffer: ^4.0.0 + fetch-blob: ^3.1.4 + formdata-polyfill: ^4.0.10 + checksum: 06a04095a2ddf05b0830a0d5302699704d59bda3102894ea64c7b9d4c865ecdff2d90fd042df7f5bc40337266961cb6183dcc808ea4f3000d024f422b462da92 + languageName: node + linkType: hard + +"node-forge@npm:^1, node-forge@npm:^1.1.0": version: 1.3.1 resolution: "node-forge@npm:1.3.1" checksum: 08fb072d3d670599c89a1704b3e9c649ff1b998256737f0e06fbd1a5bf41cae4457ccaee32d95052d80bbafd9ffe01284e078c8071f0267dc9744e51c5ed42a9 @@ -9694,13 +11695,20 @@ __metadata: languageName: node linkType: hard -"normalize-path@npm:^3.0.0": +"normalize-path@npm:^3.0.0, normalize-path@npm:~3.0.0": version: 3.0.0 resolution: "normalize-path@npm:3.0.0" checksum: 88eeb4da891e10b1318c4b2476b6e2ecbeb5ff97d946815ffea7794c31a89017c70d7f34b3c2ebf23ef4e9fc9fb99f7dffe36da22011b5b5c6ffa34f4873ec20 languageName: node linkType: hard +"normalize-range@npm:^0.1.2": + version: 0.1.2 + resolution: "normalize-range@npm:0.1.2" + checksum: 9b2f14f093593f367a7a0834267c24f3cb3e887a2d9809c77d8a7e5fd08738bcd15af46f0ab01cc3a3d660386f015816b5c922cea8bf2ee79777f40874063184 + languageName: node + linkType: hard + "npm-run-path@npm:^4.0.1": version: 4.0.1 resolution: "npm-run-path@npm:4.0.1" @@ -9731,6 +11739,13 @@ __metadata: languageName: node linkType: hard +"object-assign@npm:^4.0.1": + version: 4.1.1 + resolution: "object-assign@npm:4.1.1" + checksum: fcc6e4ea8c7fe48abfbb552578b1c53e0d194086e2e6bbbf59e0a536381a292f39943c6e9628af05b5528aa5e3318bb30d6b2e53cadaf5b8fe9e12c4b69af23f + languageName: node + linkType: hard + "object-hash@npm:^2.0.1": version: 2.2.0 resolution: "object-hash@npm:2.2.0" @@ -9738,6 +11753,13 @@ __metadata: languageName: node linkType: hard +"object-hash@npm:^3.0.0": + version: 3.0.0 + resolution: "object-hash@npm:3.0.0" + checksum: 80b4904bb3857c52cc1bfd0b52c0352532ca12ed3b8a6ff06a90cd209dfda1b95cee059a7625eb9da29537027f68ac4619363491eedb2f5d3dddbba97494fd6c + languageName: node + linkType: hard + "object-inspect@npm:^1.12.3, object-inspect@npm:^1.9.0": version: 1.12.3 resolution: "object-inspect@npm:1.12.3" @@ -9805,7 +11827,14 @@ __metadata: languageName: node linkType: hard -"on-finished@npm:^2.3.0": +"obuf@npm:^1.0.0, obuf@npm:^1.1.2": + version: 1.1.2 + resolution: "obuf@npm:1.1.2" + checksum: 41a2ba310e7b6f6c3b905af82c275bf8854896e2e4c5752966d64cbcd2f599cfffd5932006bcf3b8b419dfdacebb3a3912d5d94e10f1d0acab59876c8757f27f + languageName: node + linkType: hard + +"on-finished@npm:2.4.1, on-finished@npm:^2.3.0": version: 2.4.1 resolution: "on-finished@npm:2.4.1" dependencies: @@ -9814,6 +11843,13 @@ __metadata: languageName: node linkType: hard +"on-headers@npm:~1.0.2": + version: 1.0.2 + resolution: "on-headers@npm:1.0.2" + checksum: 2bf13467215d1e540a62a75021e8b318a6cfc5d4fc53af8e8f84ad98dbcea02d506c6d24180cd62e1d769c44721ba542f3154effc1f7579a8288c9f7873ed8e5 + languageName: node + linkType: hard + "once@npm:^1.3.0, once@npm:^1.3.1, once@npm:^1.4.0": version: 1.4.0 resolution: "once@npm:1.4.0" @@ -9857,6 +11893,17 @@ __metadata: languageName: node linkType: hard +"open@npm:^8.0.9": + version: 8.4.2 + resolution: "open@npm:8.4.2" + dependencies: + define-lazy-prop: ^2.0.0 + is-docker: ^2.1.1 + is-wsl: ^2.2.0 + checksum: 6388bfff21b40cb9bd8f913f9130d107f2ed4724ea81a8fd29798ee322b361ca31fa2cdfb491a5c31e43a3996cfe9566741238c7a741ada8d7af1cb78d85cf26 + languageName: node + linkType: hard + "open@npm:^9.1.0": version: 9.1.0 resolution: "open@npm:9.1.0" @@ -9954,6 +12001,16 @@ __metadata: languageName: node linkType: hard +"p-retry@npm:^4.5.0": + version: 4.6.2 + resolution: "p-retry@npm:4.6.2" + dependencies: + "@types/retry": 0.12.0 + retry: ^0.13.1 + checksum: 45c270bfddaffb4a895cea16cb760dcc72bdecb6cb45fef1971fa6ea2e91ddeafddefe01e444ac73e33b1b3d5d29fb0dd18a7effb294262437221ddc03ce0f2e + languageName: node + linkType: hard + "p-retry@npm:^5.0.0": version: 5.1.2 resolution: "p-retry@npm:5.1.2" @@ -10019,6 +12076,13 @@ __metadata: languageName: node linkType: hard +"pako@npm:~1.0.2": + version: 1.0.11 + resolution: "pako@npm:1.0.11" + checksum: 1be2bfa1f807608c7538afa15d6f25baa523c30ec870a3228a89579e474a4d992f4293859524e46d5d87fd30fa17c5edf34dbef0671251d9749820b488660b16 + languageName: node + linkType: hard + "parent-module@npm:^1.0.0": version: 1.0.1 resolution: "parent-module@npm:1.0.1" @@ -10053,7 +12117,7 @@ __metadata: languageName: node linkType: hard -"parseurl@npm:^1.3.2": +"parseurl@npm:^1.3.2, parseurl@npm:~1.3.2, parseurl@npm:~1.3.3": version: 1.3.3 resolution: "parseurl@npm:1.3.3" checksum: 407cee8e0a3a4c5cd472559bca8b6a45b82c124e9a4703302326e9ab60fc1081442ada4e02628efef1eb16197ddc7f8822f5a91fd7d7c86b51f530aedb17dfa2 @@ -10074,6 +12138,13 @@ __metadata: languageName: node linkType: hard +"path-is-inside@npm:1.0.2": + version: 1.0.2 + resolution: "path-is-inside@npm:1.0.2" + checksum: 0b5b6c92d3018b82afb1f74fe6de6338c4c654de4a96123cb343f2b747d5606590ac0c890f956ed38220a4ab59baddfd7b713d78a62d240b20b14ab801fa02cb + languageName: node + linkType: hard + "path-key@npm:^3.0.0, path-key@npm:^3.1.0": version: 3.1.1 resolution: "path-key@npm:3.1.1" @@ -10105,6 +12176,20 @@ __metadata: languageName: node linkType: hard +"path-to-regexp@npm:0.1.7": + version: 0.1.7 + resolution: "path-to-regexp@npm:0.1.7" + checksum: 69a14ea24db543e8b0f4353305c5eac6907917031340e5a8b37df688e52accd09e3cebfe1660b70d76b6bd89152f52183f28c74813dbf454ba1a01c82a38abce + languageName: node + linkType: hard + +"path-to-regexp@npm:2.2.1": + version: 2.2.1 + resolution: "path-to-regexp@npm:2.2.1" + checksum: b921a74e7576e25b06ad1635abf7e8125a29220d2efc2b71d74b9591f24a27e6f09078fa9a1b27516a097ea0637b7cab79d19b83d7f36a8ef3ef5422770e89d9 + languageName: node + linkType: hard + "path-to-regexp@npm:^6.2.1": version: 6.2.1 resolution: "path-to-regexp@npm:6.2.1" @@ -10155,14 +12240,21 @@ __metadata: languageName: node linkType: hard -"picomatch@npm:^2.0.4, picomatch@npm:^2.2.3, picomatch@npm:^2.3.1": +"picomatch@npm:^2.0.4, picomatch@npm:^2.2.1, picomatch@npm:^2.2.3, picomatch@npm:^2.3.1": version: 2.3.1 resolution: "picomatch@npm:2.3.1" checksum: 050c865ce81119c4822c45d3c84f1ced46f93a0126febae20737bd05ca20589c564d6e9226977df859ed5e03dc73f02584a2b0faad36e896936238238b0446cf languageName: node linkType: hard -"pirates@npm:^4.0.4": +"pify@npm:^2.3.0": + version: 2.3.0 + resolution: "pify@npm:2.3.0" + checksum: 9503aaeaf4577acc58642ad1d25c45c6d90288596238fb68f82811c08104c800e5a7870398e9f015d82b44ecbcbef3dc3d4251a1cbb582f6e5959fe09884b2ba + languageName: node + linkType: hard + +"pirates@npm:^4.0.1, pirates@npm:^4.0.4": version: 4.0.6 resolution: "pirates@npm:4.0.6" checksum: 46a65fefaf19c6f57460388a5af9ab81e3d7fd0e7bc44ca59d753cb5c4d0df97c6c6e583674869762101836d68675f027d60f841c105d72734df9dfca97cbcc6 @@ -10185,6 +12277,145 @@ __metadata: languageName: node linkType: hard +"postcss-import@npm:^15.1.0": + version: 15.1.0 + resolution: "postcss-import@npm:15.1.0" + dependencies: + postcss-value-parser: ^4.0.0 + read-cache: ^1.0.0 + resolve: ^1.1.7 + peerDependencies: + postcss: ^8.0.0 + checksum: 7bd04bd8f0235429009d0022cbf00faebc885de1d017f6d12ccb1b021265882efc9302006ba700af6cab24c46bfa2f3bc590be3f9aee89d064944f171b04e2a3 + languageName: node + linkType: hard + +"postcss-js@npm:^4.0.1": + version: 4.0.1 + resolution: "postcss-js@npm:4.0.1" + dependencies: + camelcase-css: ^2.0.1 + peerDependencies: + postcss: ^8.4.21 + checksum: 5c1e83efeabeb5a42676193f4357aa9c88f4dc1b3c4a0332c132fe88932b33ea58848186db117cf473049fc233a980356f67db490bd0a7832ccba9d0b3fd3491 + languageName: node + linkType: hard + +"postcss-load-config@npm:^4.0.1": + version: 4.0.1 + resolution: "postcss-load-config@npm:4.0.1" + dependencies: + lilconfig: ^2.0.5 + yaml: ^2.1.1 + peerDependencies: + postcss: ">=8.0.9" + ts-node: ">=9.0.0" + peerDependenciesMeta: + postcss: + optional: true + ts-node: + optional: true + checksum: b61f890499ed7dcda1e36c20a9582b17d745bad5e2b2c7bc96942465e406bc43ae03f270c08e60d1e29dab1ee50cb26970b5eb20c9aae30e066e20bd607ae4e4 + languageName: node + linkType: hard + +"postcss-loader@npm:^7.3.3": + version: 7.3.3 + resolution: "postcss-loader@npm:7.3.3" + dependencies: + cosmiconfig: ^8.2.0 + jiti: ^1.18.2 + semver: ^7.3.8 + peerDependencies: + postcss: ^7.0.0 || ^8.0.1 + webpack: ^5.0.0 + checksum: c724044d6ae56334535c26bb4efc9c151431d44d60bc8300157c760747281a242757d8dab32db72738434531175b38a408cb0b270bb96207c07584dcfcd899ff + languageName: node + linkType: hard + +"postcss-modules-extract-imports@npm:^3.0.0": + version: 3.0.0 + resolution: "postcss-modules-extract-imports@npm:3.0.0" + peerDependencies: + postcss: ^8.1.0 + checksum: 4b65f2f1382d89c4bc3c0a1bdc5942f52f3cb19c110c57bd591ffab3a5fee03fcf831604168205b0c1b631a3dce2255c70b61aaae3ef39d69cd7eb450c2552d2 + languageName: node + linkType: hard + +"postcss-modules-local-by-default@npm:^4.0.3": + version: 4.0.3 + resolution: "postcss-modules-local-by-default@npm:4.0.3" + dependencies: + icss-utils: ^5.0.0 + postcss-selector-parser: ^6.0.2 + postcss-value-parser: ^4.1.0 + peerDependencies: + postcss: ^8.1.0 + checksum: 2f8083687f3d6067885f8863dd32dbbb4f779cfcc7e52c17abede9311d84faf6d3ed8760e7c54c6380281732ae1f78e5e56a28baf3c271b33f450a11c9e30485 + languageName: node + linkType: hard + +"postcss-modules-scope@npm:^3.0.0": + version: 3.0.0 + resolution: "postcss-modules-scope@npm:3.0.0" + dependencies: + postcss-selector-parser: ^6.0.4 + peerDependencies: + postcss: ^8.1.0 + checksum: 330b9398dbd44c992c92b0dc612c0626135e2cc840fee41841eb61247a6cfed95af2bd6f67ead9dd9d0bb41f5b0367129d93c6e434fa3e9c58ade391d9a5a138 + languageName: node + linkType: hard + +"postcss-modules-values@npm:^4.0.0": + version: 4.0.0 + resolution: "postcss-modules-values@npm:4.0.0" + dependencies: + icss-utils: ^5.0.0 + peerDependencies: + postcss: ^8.1.0 + checksum: f7f2cdf14a575b60e919ad5ea52fed48da46fe80db2733318d71d523fc87db66c835814940d7d05b5746b0426e44661c707f09bdb83592c16aea06e859409db6 + languageName: node + linkType: hard + +"postcss-nested@npm:^6.0.1": + version: 6.0.1 + resolution: "postcss-nested@npm:6.0.1" + dependencies: + postcss-selector-parser: ^6.0.11 + peerDependencies: + postcss: ^8.2.14 + checksum: 7ddb0364cd797de01e38f644879189e0caeb7ea3f78628c933d91cc24f327c56d31269384454fc02ecaf503b44bfa8e08870a7c4cc56b23bc15640e1894523fa + languageName: node + linkType: hard + +"postcss-selector-parser@npm:^6.0.11, postcss-selector-parser@npm:^6.0.2, postcss-selector-parser@npm:^6.0.4": + version: 6.0.13 + resolution: "postcss-selector-parser@npm:6.0.13" + dependencies: + cssesc: ^3.0.0 + util-deprecate: ^1.0.2 + checksum: f89163338a1ce3b8ece8e9055cd5a3165e79a15e1c408e18de5ad8f87796b61ec2d48a2902d179ae0c4b5de10fccd3a325a4e660596549b040bc5ad1b465f096 + languageName: node + linkType: hard + +"postcss-value-parser@npm:^4.0.0, postcss-value-parser@npm:^4.1.0, postcss-value-parser@npm:^4.2.0": + version: 4.2.0 + resolution: "postcss-value-parser@npm:4.2.0" + checksum: 819ffab0c9d51cf0acbabf8996dffbfafbafa57afc0e4c98db88b67f2094cb44488758f06e5da95d7036f19556a4a732525e84289a425f4f6fd8e412a9d7442f + languageName: node + linkType: hard + +"postcss@npm:^8.4.21, postcss@npm:^8.4.23, postcss@npm:^8.4.29": + version: 8.4.29 + resolution: "postcss@npm:8.4.29" + dependencies: + nanoid: ^3.3.6 + picocolors: ^1.0.0 + source-map-js: ^1.0.2 + checksum: dd6daa25e781db9ae5b651d9b7bfde0ec6e60e86a37da69a18eb4773d5ddd51e28fc4ff054fbdc04636a31462e6bf09a1e50986f69ac52b10d46b7457cd36d12 + languageName: node + linkType: hard + "postcss@npm:^8.4.26": version: 8.4.27 resolution: "postcss@npm:8.4.27" @@ -10212,6 +12443,15 @@ __metadata: languageName: node linkType: hard +"prettier@npm:^3.0.3": + version: 3.0.3 + resolution: "prettier@npm:3.0.3" + bin: + prettier: bin/prettier.cjs + checksum: e10b9af02b281f6c617362ebd2571b1d7fc9fb8a3bd17e371754428cda992e5e8d8b7a046e8f7d3e2da1dcd21aa001e2e3c797402ebb6111b5cd19609dd228e0 + languageName: node + linkType: hard + "pretty-format@npm:^29.0.0, pretty-format@npm:^29.6.2": version: 29.6.2 resolution: "pretty-format@npm:29.6.2" @@ -10223,6 +12463,17 @@ __metadata: languageName: node linkType: hard +"pretty-format@npm:^29.6.3": + version: 29.6.3 + resolution: "pretty-format@npm:29.6.3" + dependencies: + "@jest/schemas": ^29.6.3 + ansi-styles: ^5.0.0 + react-is: ^18.0.0 + checksum: 4e1c0db48e65571c22e80ff92123925ff8b3a2a89b71c3a1683cfde711004d492de32fe60c6bc10eea8bf6c678e5cbe544ac6c56cb8096e1eb7caf856928b1c4 + languageName: node + linkType: hard + "private-ip@npm:^3.0.0": version: 3.0.1 resolution: "private-ip@npm:3.0.1" @@ -10235,6 +12486,57 @@ __metadata: languageName: node linkType: hard +"private-token@workspace:boxes/private-token": + version: 0.0.0-use.local + resolution: "private-token@workspace:boxes/private-token" + dependencies: + "@aztec/aztec.js": "workspace:^" + "@aztec/circuits.js": "workspace:^" + "@aztec/cli": "workspace:^" + "@aztec/foundation": "workspace:^" + "@types/node": ^20.5.9 + "@types/react": ^18.2.15 + "@types/react-dom": ^18.2.7 + "@typescript-eslint/eslint-plugin": ^6.0.0 + "@typescript-eslint/parser": ^6.0.0 + autoprefixer: ^10.4.15 + copy-webpack-plugin: ^11.0.0 + css-loader: ^6.8.1 + eslint: ^8.45.0 + eslint-import-resolver-typescript: ^3.5.5 + eslint-plugin-import: ^2.27.5 + eslint-plugin-react-hooks: ^4.6.0 + eslint-plugin-react-refresh: ^0.4.3 + formik: ^2.4.3 + jest: ^29.6.4 + postcss: ^8.4.29 + postcss-loader: ^7.3.3 + prettier: ^3.0.3 + react: ^18.2.0 + react-dom: ^18.2.0 + resolve-typescript-plugin: ^2.0.1 + serve: ^14.2.1 + style-loader: ^3.3.3 + tailwindcss: ^3.3.3 + ts-jest: ^29.1.0 + ts-loader: ^9.4.4 + ts-node: ^10.9.1 + typescript: ^5.0.4 + util: ^0.12.5 + webpack: ^5.88.2 + webpack-cli: ^5.1.4 + webpack-dev-server: ^4.15.1 + yup: ^1.2.0 + languageName: unknown + linkType: soft + +"process-nextick-args@npm:~2.0.0": + version: 2.0.1 + resolution: "process-nextick-args@npm:2.0.1" + checksum: 1d38588e520dab7cea67cbbe2efdd86a10cc7a074c09657635e34f035277b59fbb57d09d8638346bf7090f8e8ebc070c96fa5fd183b777fff4f5edff5e9466cf + languageName: node + linkType: hard + "process@npm:^0.11.10": version: 0.11.10 resolution: "process@npm:0.11.10" @@ -10285,6 +12587,13 @@ __metadata: languageName: node linkType: hard +"property-expr@npm:^2.0.5": + version: 2.0.5 + resolution: "property-expr@npm:2.0.5" + checksum: 4ebe82ce45aaf1527e96e2ab84d75d25217167ec3ff6378cf83a84fb4abc746e7c65768a79d275881602ae82f168f9a6dfaa7f5e331d0fcc83d692770bcce5f1 + languageName: node + linkType: hard + "protobufjs@npm:^7.0.0": version: 7.2.4 resolution: "protobufjs@npm:7.2.4" @@ -10317,6 +12626,16 @@ __metadata: languageName: node linkType: hard +"proxy-addr@npm:~2.0.7": + version: 2.0.7 + resolution: "proxy-addr@npm:2.0.7" + dependencies: + forwarded: 0.2.0 + ipaddr.js: 1.9.1 + checksum: 29c6990ce9364648255454842f06f8c46fcd124d3e6d7c5066df44662de63cdc0bad032e9bf5a3d653ff72141cc7b6019873d685708ac8210c30458ad99f2b74 + languageName: node + linkType: hard + "proxy-agent@npm:6.3.0": version: 6.3.0 resolution: "proxy-agent@npm:6.3.0" @@ -10375,6 +12694,13 @@ __metadata: languageName: node linkType: hard +"punycode@npm:^1.3.2": + version: 1.4.1 + resolution: "punycode@npm:1.4.1" + checksum: fa6e698cb53db45e4628559e557ddaf554103d2a96a1d62892c8f4032cd3bc8871796cae9eabc1bc700e2b6677611521ce5bb1d9a27700086039965d0cf34518 + languageName: node + linkType: hard + "punycode@npm:^2.1.0": version: 2.3.0 resolution: "punycode@npm:2.3.0" @@ -10444,6 +12770,15 @@ __metadata: languageName: node linkType: hard +"qs@npm:6.11.0": + version: 6.11.0 + resolution: "qs@npm:6.11.0" + dependencies: + side-channel: ^1.0.4 + checksum: 6e1f29dd5385f7488ec74ac7b6c92f4d09a90408882d0c208414a34dd33badc1a621019d4c799a3df15ab9b1d0292f97c1dd71dc7c045e69f81a8064e5af7297 + languageName: node + linkType: hard + "qs@npm:^6.11.0, qs@npm:^6.5.2": version: 6.11.2 resolution: "qs@npm:6.11.2" @@ -10493,6 +12828,20 @@ __metadata: languageName: node linkType: hard +"range-parser@npm:1.2.0": + version: 1.2.0 + resolution: "range-parser@npm:1.2.0" + checksum: bdf397f43fedc15c559d3be69c01dedf38444ca7a1610f5bf5955e3f3da6057a892f34691e7ebdd8c7e1698ce18ef6c4d4811f70e658dda3ff230ef741f8423a + languageName: node + linkType: hard + +"range-parser@npm:^1.2.1, range-parser@npm:~1.2.1": + version: 1.2.1 + resolution: "range-parser@npm:1.2.1" + checksum: 0a268d4fea508661cf5743dfe3d5f47ce214fd6b7dec1de0da4d669dd4ef3d2144468ebe4179049eff253d9d27e719c88dae55be64f954e80135a0cada804ec9 + languageName: node + linkType: hard + "rate-limiter-flexible@npm:^2.3.11": version: 2.4.2 resolution: "rate-limiter-flexible@npm:2.4.2" @@ -10500,15 +12849,67 @@ __metadata: languageName: node linkType: hard -"raw-body@npm:^2.3.3": - version: 2.5.2 - resolution: "raw-body@npm:2.5.2" - dependencies: - bytes: 3.1.2 - http-errors: 2.0.0 - iconv-lite: 0.4.24 - unpipe: 1.0.0 - checksum: ba1583c8d8a48e8fbb7a873fdbb2df66ea4ff83775421bfe21ee120140949ab048200668c47d9ae3880012f6e217052690628cf679ddfbd82c9fc9358d574676 +"raw-body@npm:2.5.1": + version: 2.5.1 + resolution: "raw-body@npm:2.5.1" + dependencies: + bytes: 3.1.2 + http-errors: 2.0.0 + iconv-lite: 0.4.24 + unpipe: 1.0.0 + checksum: 5362adff1575d691bb3f75998803a0ffed8c64eabeaa06e54b4ada25a0cd1b2ae7f4f5ec46565d1bec337e08b5ac90c76eaa0758de6f72a633f025d754dec29e + languageName: node + linkType: hard + +"raw-body@npm:^2.3.3": + version: 2.5.2 + resolution: "raw-body@npm:2.5.2" + dependencies: + bytes: 3.1.2 + http-errors: 2.0.0 + iconv-lite: 0.4.24 + unpipe: 1.0.0 + checksum: ba1583c8d8a48e8fbb7a873fdbb2df66ea4ff83775421bfe21ee120140949ab048200668c47d9ae3880012f6e217052690628cf679ddfbd82c9fc9358d574676 + languageName: node + linkType: hard + +"rc@npm:^1.0.1, rc@npm:^1.1.6": + version: 1.2.8 + resolution: "rc@npm:1.2.8" + dependencies: + deep-extend: ^0.6.0 + ini: ~1.3.0 + minimist: ^1.2.0 + strip-json-comments: ~2.0.1 + bin: + rc: ./cli.js + checksum: 2e26e052f8be2abd64e6d1dabfbd7be03f80ec18ccbc49562d31f617d0015fbdbcf0f9eed30346ea6ab789e0fdfe4337f033f8016efdbee0df5354751842080e + languageName: node + linkType: hard + +"react-dom@npm:^18.2.0": + version: 18.2.0 + resolution: "react-dom@npm:18.2.0" + dependencies: + loose-envify: ^1.1.0 + scheduler: ^0.23.0 + peerDependencies: + react: ^18.2.0 + checksum: 7d323310bea3a91be2965f9468d552f201b1c27891e45ddc2d6b8f717680c95a75ae0bc1e3f5cf41472446a2589a75aed4483aee8169287909fcd59ad149e8cc + languageName: node + linkType: hard + +"react-fast-compare@npm:^2.0.1": + version: 2.0.4 + resolution: "react-fast-compare@npm:2.0.4" + checksum: 06046595f90a4e3e3a56f40a8078c00aa71bdb064ddb98343f577f546aa22e888831fd45f009c93b34707cc842b4c637737e956fd13d6f80607ee92fb9cf9a1c + languageName: node + linkType: hard + +"react-is@npm:^16.7.0": + version: 16.13.1 + resolution: "react-is@npm:16.13.1" + checksum: f7a19ac3496de32ca9ae12aa030f00f14a3d45374f1ceca0af707c831b2a6098ef0d6bdae51bd437b0a306d7f01d4677fcc8de7c0d331eb47ad0f46130e53c5f languageName: node linkType: hard @@ -10519,6 +12920,24 @@ __metadata: languageName: node linkType: hard +"react@npm:^18.2.0": + version: 18.2.0 + resolution: "react@npm:18.2.0" + dependencies: + loose-envify: ^1.1.0 + checksum: 88e38092da8839b830cda6feef2e8505dec8ace60579e46aa5490fc3dc9bba0bd50336507dc166f43e3afc1c42939c09fe33b25fae889d6f402721dcd78fca1b + languageName: node + linkType: hard + +"read-cache@npm:^1.0.0": + version: 1.0.0 + resolution: "read-cache@npm:1.0.0" + dependencies: + pify: ^2.3.0 + checksum: cffc728b9ede1e0667399903f9ecaf3789888b041c46ca53382fa3a06303e5132774dc0a96d0c16aa702dbac1ea0833d5a868d414f5ab2af1e1438e19e6657c6 + languageName: node + linkType: hard + "read-pkg-up@npm:^7.0.1": version: 7.0.1 resolution: "read-pkg-up@npm:7.0.1" @@ -10542,7 +12961,22 @@ __metadata: languageName: node linkType: hard -"readable-stream@npm:^3.4.0, readable-stream@npm:^3.5.0, readable-stream@npm:^3.6.0": +"readable-stream@npm:^2.0.1, readable-stream@npm:~2.3.6": + version: 2.3.8 + resolution: "readable-stream@npm:2.3.8" + dependencies: + core-util-is: ~1.0.0 + inherits: ~2.0.3 + isarray: ~1.0.0 + process-nextick-args: ~2.0.0 + safe-buffer: ~5.1.1 + string_decoder: ~1.1.1 + util-deprecate: ~1.0.1 + checksum: 65645467038704f0c8aaf026a72fbb588a9e2ef7a75cd57a01702ee9db1c4a1e4b03aaad36861a6a0926546a74d174149c8c207527963e0c2d3eee2f37678a42 + languageName: node + linkType: hard + +"readable-stream@npm:^3.0.6, readable-stream@npm:^3.4.0, readable-stream@npm:^3.5.0, readable-stream@npm:^3.6.0": version: 3.6.2 resolution: "readable-stream@npm:3.6.2" dependencies: @@ -10553,6 +12987,15 @@ __metadata: languageName: node linkType: hard +"readdirp@npm:~3.6.0": + version: 3.6.0 + resolution: "readdirp@npm:3.6.0" + dependencies: + picomatch: ^2.2.1 + checksum: 1ced032e6e45670b6d7352d71d21ce7edf7b9b928494dcaba6f11fba63180d9da6cd7061ebc34175ffda6ff529f481818c962952004d273178acd70f7059b320 + languageName: node + linkType: hard + "receptacle@npm:^1.3.2": version: 1.3.2 resolution: "receptacle@npm:1.3.2" @@ -10599,6 +13042,25 @@ __metadata: languageName: node linkType: hard +"registry-auth-token@npm:3.3.2": + version: 3.3.2 + resolution: "registry-auth-token@npm:3.3.2" + dependencies: + rc: ^1.1.6 + safe-buffer: ^5.0.1 + checksum: c9d7ae160a738f1fa825556e3669e6c771d2c0239ce37679f7e8646157a97d0a76464738be075002a1f754ef9bfb913b689f4bbfd5296d28f136fbf98c8c2217 + languageName: node + linkType: hard + +"registry-url@npm:3.1.0": + version: 3.1.0 + resolution: "registry-url@npm:3.1.0" + dependencies: + rc: ^1.0.1 + checksum: 6d223da41b04e1824f5faa63905c6f2e43b216589d72794111573f017352b790aef42cd1f826463062f89d804abb2027e3d9665d2a9a0426a11eedd04d470af3 + languageName: node + linkType: hard + "repeat-string@npm:^1.6.1": version: 1.6.1 resolution: "repeat-string@npm:1.6.1" @@ -10613,6 +13075,20 @@ __metadata: languageName: node linkType: hard +"require-from-string@npm:^2.0.2": + version: 2.0.2 + resolution: "require-from-string@npm:2.0.2" + checksum: a03ef6895445f33a4015300c426699bc66b2b044ba7b670aa238610381b56d3f07c686251740d575e22f4c87531ba662d06937508f0f3c0f1ddc04db3130560b + languageName: node + linkType: hard + +"requires-port@npm:^1.0.0": + version: 1.0.0 + resolution: "requires-port@npm:1.0.0" + checksum: eee0e303adffb69be55d1a214e415cf42b7441ae858c76dfc5353148644f6fd6e698926fc4643f510d5c126d12a705e7c8ed7e38061113bdf37547ab356797ff + languageName: node + linkType: hard + "resolve-cwd@npm:^3.0.0": version: 3.0.0 resolution: "resolve-cwd@npm:3.0.0" @@ -10671,6 +13147,19 @@ __metadata: languageName: node linkType: hard +"resolve@npm:^1.1.7, resolve@npm:^1.22.2": + version: 1.22.4 + resolution: "resolve@npm:1.22.4" + dependencies: + is-core-module: ^2.13.0 + path-parse: ^1.0.7 + supports-preserve-symlinks-flag: ^1.0.0 + bin: + resolve: bin/resolve + checksum: 23f25174c2736ce24c6d918910e0d1f89b6b38fefa07a995dff864acd7863d59a7f049e691f93b4b2ee29696303390d921552b6d1b841ed4a8101f517e1d0124 + languageName: node + linkType: hard + "resolve@npm:^1.10.0, resolve@npm:^1.20.0, resolve@npm:^1.22.1, resolve@npm:^1.22.3": version: 1.22.3 resolution: "resolve@npm:1.22.3" @@ -10694,6 +13183,19 @@ __metadata: languageName: node linkType: hard +"resolve@patch:resolve@^1.1.7#~builtin, resolve@patch:resolve@^1.22.2#~builtin": + version: 1.22.4 + resolution: "resolve@patch:resolve@npm%3A1.22.4#~builtin::version=1.22.4&hash=c3c19d" + dependencies: + is-core-module: ^2.13.0 + path-parse: ^1.0.7 + supports-preserve-symlinks-flag: ^1.0.0 + bin: + resolve: bin/resolve + checksum: c45f2545fdc4d21883861b032789e20aa67a2f2692f68da320cc84d5724cd02f2923766c5354b3210897e88f1a7b3d6d2c7c22faeead8eed7078e4c783a444bc + languageName: node + linkType: hard + "resolve@patch:resolve@^1.10.0#~builtin, resolve@patch:resolve@^1.20.0#~builtin, resolve@patch:resolve@^1.22.1#~builtin, resolve@patch:resolve@^1.22.3#~builtin": version: 1.22.3 resolution: "resolve@patch:resolve@npm%3A1.22.3#~builtin::version=1.22.3&hash=c3c19d" @@ -10812,7 +13314,14 @@ __metadata: languageName: node linkType: hard -"safe-buffer@npm:5.2.1, safe-buffer@npm:^5.0.1, safe-buffer@npm:^5.1.0, safe-buffer@npm:^5.1.1, safe-buffer@npm:^5.1.2, safe-buffer@npm:^5.2.0, safe-buffer@npm:~5.2.0": +"safe-buffer@npm:5.1.2, safe-buffer@npm:~5.1.0, safe-buffer@npm:~5.1.1": + version: 5.1.2 + resolution: "safe-buffer@npm:5.1.2" + checksum: f2f1f7943ca44a594893a852894055cf619c1fbcb611237fc39e461ae751187e7baf4dc391a72125e0ac4fb2d8c5c0b3c71529622e6a58f46b960211e704903c + languageName: node + linkType: hard + +"safe-buffer@npm:5.2.1, safe-buffer@npm:>=5.1.0, safe-buffer@npm:^5.0.1, safe-buffer@npm:^5.1.0, safe-buffer@npm:^5.1.1, safe-buffer@npm:^5.1.2, safe-buffer@npm:^5.2.0, safe-buffer@npm:~5.2.0": version: 5.2.1 resolution: "safe-buffer@npm:5.2.1" checksum: b99c4b41fdd67a6aaf280fcd05e9ffb0813654894223afb78a31f14a19ad220bba8aba1cb14eddce1fcfb037155fe6de4e861784eb434f7d11ed58d1e70dd491 @@ -10860,6 +13369,15 @@ __metadata: languageName: node linkType: hard +"scheduler@npm:^0.23.0": + version: 0.23.0 + resolution: "scheduler@npm:0.23.0" + dependencies: + loose-envify: ^1.1.0 + checksum: d79192eeaa12abef860c195ea45d37cbf2bbf5f66e3c4dcd16f54a7da53b17788a70d109ee3d3dde1a0fd50e6a8fc171f4300356c5aee4fc0171de526bf35f8a + languageName: node + linkType: hard + "schema-utils@npm:^3.1.1, schema-utils@npm:^3.2.0": version: 3.3.0 resolution: "schema-utils@npm:3.3.0" @@ -10871,6 +13389,34 @@ __metadata: languageName: node linkType: hard +"schema-utils@npm:^4.0.0": + version: 4.2.0 + resolution: "schema-utils@npm:4.2.0" + dependencies: + "@types/json-schema": ^7.0.9 + ajv: ^8.9.0 + ajv-formats: ^2.1.1 + ajv-keywords: ^5.1.0 + checksum: 26a0463d47683258106e6652e9aeb0823bf0b85843039e068b57da1892f7ae6b6b1094d48e9ed5ba5cbe9f7166469d880858b9d91abe8bd249421eb813850cde + languageName: node + linkType: hard + +"select-hose@npm:^2.0.0": + version: 2.0.0 + resolution: "select-hose@npm:2.0.0" + checksum: d7e5fcc695a4804209d232a1b18624a5134be334d4e1114b0721f7a5e72bd73da483dcf41528c1af4f4f4892ad7cfd6a1e55c8ffb83f9c9fe723b738db609dbb + languageName: node + linkType: hard + +"selfsigned@npm:^2.1.1": + version: 2.1.1 + resolution: "selfsigned@npm:2.1.1" + dependencies: + node-forge: ^1 + checksum: aa9ce2150a54838978d5c0aee54d7ebe77649a32e4e690eb91775f71fdff773874a4fbafd0ac73d8ec3b702ff8a395c604df4f8e8868528f36fd6c15076fb43a + languageName: node + linkType: hard + "semver-match@npm:0.1.1": version: 0.1.1 resolution: "semver-match@npm:0.1.1" @@ -10909,7 +13455,28 @@ __metadata: languageName: node linkType: hard -"serialize-javascript@npm:^6.0.1": +"send@npm:0.18.0": + version: 0.18.0 + resolution: "send@npm:0.18.0" + dependencies: + debug: 2.6.9 + depd: 2.0.0 + destroy: 1.2.0 + encodeurl: ~1.0.2 + escape-html: ~1.0.3 + etag: ~1.8.1 + fresh: 0.5.2 + http-errors: 2.0.0 + mime: 1.6.0 + ms: 2.1.3 + on-finished: 2.4.1 + range-parser: ~1.2.1 + statuses: 2.0.1 + checksum: 74fc07ebb58566b87b078ec63e5a3e41ecd987e4272ba67b7467e86c6ad51bc6b0b0154133b6d8b08a2ddda360464f71382f7ef864700f34844a76c8027817a8 + languageName: node + linkType: hard + +"serialize-javascript@npm:^6.0.0, serialize-javascript@npm:^6.0.1": version: 6.0.1 resolution: "serialize-javascript@npm:6.0.1" dependencies: @@ -10918,6 +13485,70 @@ __metadata: languageName: node linkType: hard +"serve-handler@npm:6.1.5": + version: 6.1.5 + resolution: "serve-handler@npm:6.1.5" + dependencies: + bytes: 3.0.0 + content-disposition: 0.5.2 + fast-url-parser: 1.1.3 + mime-types: 2.1.18 + minimatch: 3.1.2 + path-is-inside: 1.0.2 + path-to-regexp: 2.2.1 + range-parser: 1.2.0 + checksum: 7a98ca9cbf8692583b6cde4deb3941cff900fa38bf16adbfccccd8430209bab781e21d9a1f61c9c03e226f9f67689893bbce25941368f3ddaf985fc3858b49dc + languageName: node + linkType: hard + +"serve-index@npm:^1.9.1": + version: 1.9.1 + resolution: "serve-index@npm:1.9.1" + dependencies: + accepts: ~1.3.4 + batch: 0.6.1 + debug: 2.6.9 + escape-html: ~1.0.3 + http-errors: ~1.6.2 + mime-types: ~2.1.17 + parseurl: ~1.3.2 + checksum: e2647ce13379485b98a53ba2ea3fbad4d44b57540d00663b02b976e426e6194d62ac465c0d862cb7057f65e0de8ab8a684aa095427a4b8612412eca0d300d22f + languageName: node + linkType: hard + +"serve-static@npm:1.15.0": + version: 1.15.0 + resolution: "serve-static@npm:1.15.0" + dependencies: + encodeurl: ~1.0.2 + escape-html: ~1.0.3 + parseurl: ~1.3.3 + send: 0.18.0 + checksum: af57fc13be40d90a12562e98c0b7855cf6e8bd4c107fe9a45c212bf023058d54a1871b1c89511c3958f70626fff47faeb795f5d83f8cf88514dbaeb2b724464d + languageName: node + linkType: hard + +"serve@npm:^14.2.1": + version: 14.2.1 + resolution: "serve@npm:14.2.1" + dependencies: + "@zeit/schemas": 2.29.0 + ajv: 8.11.0 + arg: 5.0.2 + boxen: 7.0.0 + chalk: 5.0.1 + chalk-template: 0.4.0 + clipboardy: 3.0.0 + compression: 1.7.4 + is-port-reachable: 4.0.0 + serve-handler: 6.1.5 + update-check: 1.5.4 + bin: + serve: build/main.js + checksum: c39a517b5d795a0a5c2f9fb9ff088b7e4962c579e34ace5b85dd62f93e0eacbc8a90359792c153c444a83258ffda392113dff7bfd10d41ced574a2d1886c2994 + languageName: node + linkType: hard + "set-blocking@npm:^2.0.0": version: 2.0.0 resolution: "set-blocking@npm:2.0.0" @@ -10925,6 +13556,13 @@ __metadata: languageName: node linkType: hard +"setimmediate@npm:^1.0.5": + version: 1.0.5 + resolution: "setimmediate@npm:1.0.5" + checksum: c9a6f2c5b51a2dabdc0247db9c46460152ffc62ee139f3157440bd48e7c59425093f42719ac1d7931f054f153e2d26cf37dfeb8da17a794a58198a2705e527fd + languageName: node + linkType: hard + "setprototypeof@npm:1.1.0": version: 1.1.0 resolution: "setprototypeof@npm:1.1.0" @@ -11076,6 +13714,17 @@ __metadata: languageName: node linkType: hard +"sockjs@npm:^0.3.24": + version: 0.3.24 + resolution: "sockjs@npm:0.3.24" + dependencies: + faye-websocket: ^0.11.3 + uuid: ^8.3.2 + websocket-driver: ^0.7.4 + checksum: 355309b48d2c4e9755349daa29cea1c0d9ee23e49b983841c6bf7a20276b00d3c02343f9f33f26d2ee8b261a5a02961b52a25c8da88b2538c5b68d3071b4934c + languageName: node + linkType: hard + "socks-proxy-agent@npm:^7.0.0": version: 7.0.0 resolution: "socks-proxy-agent@npm:7.0.0" @@ -11190,6 +13839,33 @@ __metadata: languageName: node linkType: hard +"spdy-transport@npm:^3.0.0": + version: 3.0.0 + resolution: "spdy-transport@npm:3.0.0" + dependencies: + debug: ^4.1.0 + detect-node: ^2.0.4 + hpack.js: ^2.1.6 + obuf: ^1.1.2 + readable-stream: ^3.0.6 + wbuf: ^1.7.3 + checksum: 0fcaad3b836fb1ec0bdd39fa7008b9a7a84a553f12be6b736a2512613b323207ffc924b9551cef0378f7233c85916cff1118652e03a730bdb97c0e042243d56c + languageName: node + linkType: hard + +"spdy@npm:^4.0.2": + version: 4.0.2 + resolution: "spdy@npm:4.0.2" + dependencies: + debug: ^4.1.0 + handle-thing: ^2.0.0 + http-deceiver: ^1.2.7 + select-hose: ^2.0.0 + spdy-transport: ^3.0.0 + checksum: 2c739d0ff6f56ad36d2d754d0261d5ec358457bea7cbf77b1b05b0c6464f2ce65b85f196305f50b7bd9120723eb94bae9933466f28e67e5cd8cde4e27f1d75f8 + languageName: node + linkType: hard + "split@npm:0.3": version: 0.3.3 resolution: "split@npm:0.3.3" @@ -11371,6 +14047,15 @@ __metadata: languageName: node linkType: hard +"string_decoder@npm:~1.1.1": + version: 1.1.1 + resolution: "string_decoder@npm:1.1.1" + dependencies: + safe-buffer: ~5.1.0 + checksum: 9ab7e56f9d60a28f2be697419917c50cac19f3e8e6c28ef26ed5f4852289fe0de5d6997d29becf59028556f2c62983790c1d9ba1e2a3cc401768ca12d5183a5b + languageName: node + linkType: hard + "strip-ansi-cjs@npm:strip-ansi@^6.0.1, strip-ansi@npm:^6.0.0, strip-ansi@npm:^6.0.1": version: 6.0.1 resolution: "strip-ansi@npm:6.0.1" @@ -11433,6 +14118,40 @@ __metadata: languageName: node linkType: hard +"strip-json-comments@npm:~2.0.1": + version: 2.0.1 + resolution: "strip-json-comments@npm:2.0.1" + checksum: 1074ccb63270d32ca28edfb0a281c96b94dc679077828135141f27d52a5a398ef5e78bcf22809d23cadc2b81dfbe345eb5fd8699b385c8b1128907dec4a7d1e1 + languageName: node + linkType: hard + +"style-loader@npm:^3.3.3": + version: 3.3.3 + resolution: "style-loader@npm:3.3.3" + peerDependencies: + webpack: ^5.0.0 + checksum: f59c953f56f6a935bd6a1dfa409f1128fed2b66b48ce4a7a75b85862a7156e5e90ab163878962762f528ec4d510903d828da645e143fbffd26f055dc1c094078 + languageName: node + linkType: hard + +"sucrase@npm:^3.32.0": + version: 3.34.0 + resolution: "sucrase@npm:3.34.0" + dependencies: + "@jridgewell/gen-mapping": ^0.3.2 + commander: ^4.0.0 + glob: 7.1.6 + lines-and-columns: ^1.1.6 + mz: ^2.7.0 + pirates: ^4.0.1 + ts-interface-checker: ^0.1.9 + bin: + sucrase: bin/sucrase + sucrase-node: bin/sucrase-node + checksum: 61860063bdf6103413698e13247a3074d25843e91170825a9752e4af7668ffadd331b6e99e92fc32ee5b3c484ee134936f926fa9039d5711fafff29d017a2110 + languageName: node + linkType: hard + "superagent@npm:^8.0.5": version: 8.0.9 resolution: "superagent@npm:8.0.9" @@ -11505,6 +14224,39 @@ __metadata: languageName: node linkType: hard +"tailwindcss@npm:^3.3.3": + version: 3.3.3 + resolution: "tailwindcss@npm:3.3.3" + dependencies: + "@alloc/quick-lru": ^5.2.0 + arg: ^5.0.2 + chokidar: ^3.5.3 + didyoumean: ^1.2.2 + dlv: ^1.1.3 + fast-glob: ^3.2.12 + glob-parent: ^6.0.2 + is-glob: ^4.0.3 + jiti: ^1.18.2 + lilconfig: ^2.1.0 + micromatch: ^4.0.5 + normalize-path: ^3.0.0 + object-hash: ^3.0.0 + picocolors: ^1.0.0 + postcss: ^8.4.23 + postcss-import: ^15.1.0 + postcss-js: ^4.0.1 + postcss-load-config: ^4.0.1 + postcss-nested: ^6.0.1 + postcss-selector-parser: ^6.0.11 + resolve: ^1.22.2 + sucrase: ^3.32.0 + bin: + tailwind: lib/cli.js + tailwindcss: lib/cli.js + checksum: 0195c7a3ebb0de5e391d2a883d777c78a4749f0c532d204ee8aea9129f2ed8e701d8c0c276aa5f7338d07176a3c2a7682c1d0ab9c8a6c2abe6d9325c2954eb50 + languageName: node + linkType: hard + "tapable@npm:^2.1.1, tapable@npm:^2.2.0": version: 2.2.1 resolution: "tapable@npm:2.2.1" @@ -11609,6 +14361,24 @@ __metadata: languageName: node linkType: hard +"thenify-all@npm:^1.0.0": + version: 1.6.0 + resolution: "thenify-all@npm:1.6.0" + dependencies: + thenify: ">= 3.1.0 < 4" + checksum: dba7cc8a23a154cdcb6acb7f51d61511c37a6b077ec5ab5da6e8b874272015937788402fd271fdfc5f187f8cb0948e38d0a42dcc89d554d731652ab458f5343e + languageName: node + linkType: hard + +"thenify@npm:>= 3.1.0 < 4": + version: 3.3.1 + resolution: "thenify@npm:3.3.1" + dependencies: + any-promise: ^1.0.0 + checksum: 84e1b804bfec49f3531215f17b4a6e50fd4397b5f7c1bccc427b9c656e1ecfb13ea79d899930184f78bc2f57285c54d9a50a590c8868f4f0cef5c1d9f898b05e + languageName: node + linkType: hard + "through@npm:2, through@npm:^2.3.8, through@npm:~2.3, through@npm:~2.3.1": version: 2.3.8 resolution: "through@npm:2.3.8" @@ -11616,6 +14386,27 @@ __metadata: languageName: node linkType: hard +"thunky@npm:^1.0.2": + version: 1.1.0 + resolution: "thunky@npm:1.1.0" + checksum: 993096c472b6b8f30e29dc777a8d17720e4cab448375041f20c0cb802a09a7fb2217f2a3e8cdc11851faa71c957e2db309357367fc9d7af3cb7a4d00f4b66034 + languageName: node + linkType: hard + +"tiny-case@npm:^1.0.3": + version: 1.0.3 + resolution: "tiny-case@npm:1.0.3" + checksum: 3f7a30c39d5b0e1bc097b0b271bec14eb5b836093db034f35a0de26c14422380b50dc12bfd37498cf35b192f5df06f28a710712c87ead68872a9e37ad6f6049d + languageName: node + linkType: hard + +"tiny-warning@npm:^1.0.2": + version: 1.0.3 + resolution: "tiny-warning@npm:1.0.3" + checksum: da62c4acac565902f0624b123eed6dd3509bc9a8d30c06e017104bedcf5d35810da8ff72864400ad19c5c7806fc0a8323c68baf3e326af7cb7d969f846100d71 + languageName: node + linkType: hard + "titleize@npm:^3.0.0": version: 3.0.0 resolution: "titleize@npm:3.0.0" @@ -11660,6 +14451,13 @@ __metadata: languageName: node linkType: hard +"toposort@npm:^2.0.2": + version: 2.0.2 + resolution: "toposort@npm:2.0.2" + checksum: d64c74b570391c9432873f48e231b439ee56bc49f7cb9780b505cfdf5cb832f808d0bae072515d93834dd6bceca5bb34448b5b4b408335e4d4716eaf68195dcb + languageName: node + linkType: hard + "tr46@npm:~0.0.3": version: 0.0.3 resolution: "tr46@npm:0.0.3" @@ -11724,6 +14522,13 @@ __metadata: languageName: node linkType: hard +"ts-interface-checker@npm:^0.1.9": + version: 0.1.13 + resolution: "ts-interface-checker@npm:0.1.13" + checksum: 20c29189c2dd6067a8775e07823ddf8d59a33e2ffc47a1bd59a5cb28bb0121a2969a816d5e77eda2ed85b18171aa5d1c4005a6b88ae8499ec7cc49f78571cb5e + languageName: node + linkType: hard + "ts-jest@npm:^29.1.0": version: 29.1.1 resolution: "ts-jest@npm:29.1.1" @@ -11845,6 +14650,13 @@ __metadata: languageName: node linkType: hard +"tslib@npm:^2.0.0": + version: 2.6.2 + resolution: "tslib@npm:2.6.2" + checksum: 329ea56123005922f39642318e3d1f0f8265d1e7fcb92c633e0809521da75eeaca28d2cf96d7248229deb40e5c19adf408259f4b9640afd20d13aecc1430f3ad + languageName: node + linkType: hard + "tslib@npm:^2.0.1, tslib@npm:^2.1.0, tslib@npm:^2.4.0, tslib@npm:^2.5.0, tslib@npm:^2.6.0": version: 2.6.1 resolution: "tslib@npm:2.6.1" @@ -11917,7 +14729,14 @@ __metadata: languageName: node linkType: hard -"type-is@npm:^1.6.16, type-is@npm:^1.6.18": +"type-fest@npm:^2.13.0, type-fest@npm:^2.19.0": + version: 2.19.0 + resolution: "type-fest@npm:2.19.0" + checksum: a4ef07ece297c9fba78fc1bd6d85dff4472fe043ede98bd4710d2615d15776902b595abf62bd78339ed6278f021235fb28a96361f8be86ed754f778973a0d278 + languageName: node + linkType: hard + +"type-is@npm:^1.6.16, type-is@npm:^1.6.18, type-is@npm:~1.6.18": version: 1.6.18 resolution: "type-is@npm:1.6.18" dependencies: @@ -12122,7 +14941,7 @@ __metadata: languageName: node linkType: hard -"unpipe@npm:1.0.0": +"unpipe@npm:1.0.0, unpipe@npm:~1.0.0": version: 1.0.0 resolution: "unpipe@npm:1.0.0" checksum: 4fa18d8d8d977c55cb09715385c203197105e10a6d220087ec819f50cb68870f02942244f1017565484237f1f8c5d3cd413631b1ae104d3096f24fdfde1b4aa2 @@ -12157,6 +14976,16 @@ __metadata: languageName: node linkType: hard +"update-check@npm:1.5.4": + version: 1.5.4 + resolution: "update-check@npm:1.5.4" + dependencies: + registry-auth-token: 3.3.2 + registry-url: 3.1.0 + checksum: 2c9f7de6f030364c5ea02a341e5ae2dfe76da6559b32d40dd3b047b3ac0927408cf92d322c51cd8e009688210a85ccbf1eba449762a65a0d1b14f3cdf1ea5c48 + languageName: node + linkType: hard + "uri-js@npm:^4.2.2": version: 4.4.1 resolution: "uri-js@npm:4.4.1" @@ -12173,7 +15002,7 @@ __metadata: languageName: node linkType: hard -"util-deprecate@npm:^1.0.1": +"util-deprecate@npm:^1.0.1, util-deprecate@npm:^1.0.2, util-deprecate@npm:~1.0.1": version: 1.0.2 resolution: "util-deprecate@npm:1.0.2" checksum: 474acf1146cb2701fe3b074892217553dfcf9a031280919ba1b8d651a068c9b15d863b7303cb15bd00a862b498e6cf4ad7b4a08fb134edd5a6f7641681cb54a2 @@ -12193,6 +15022,22 @@ __metadata: languageName: node linkType: hard +"utils-merge@npm:1.0.1": + version: 1.0.1 + resolution: "utils-merge@npm:1.0.1" + checksum: c81095493225ecfc28add49c106ca4f09cdf56bc66731aa8dabc2edbbccb1e1bfe2de6a115e5c6a380d3ea166d1636410b62ef216bb07b3feb1cfde1d95d5080 + languageName: node + linkType: hard + +"uuid@npm:^8.3.2": + version: 8.3.2 + resolution: "uuid@npm:8.3.2" + bin: + uuid: dist/bin/uuid + checksum: 5575a8a75c13120e2f10e6ddc801b2c7ed7d8f3c8ac22c7ed0c7b2ba6383ec0abda88c905085d630e251719e0777045ae3236f04c812184b7c765f63a70e58df + languageName: node + linkType: hard + "v8-compile-cache-lib@npm:^3.0.1": version: 3.0.1 resolution: "v8-compile-cache-lib@npm:3.0.1" @@ -12228,7 +15073,7 @@ __metadata: languageName: node linkType: hard -"vary@npm:^1.1.2": +"vary@npm:^1.1.2, vary@npm:~1.1.2": version: 1.1.2 resolution: "vary@npm:1.1.2" checksum: ae0123222c6df65b437669d63dfa8c36cee20a504101b2fcd97b8bf76f91259c17f9f2b4d70a1e3c6bbcee7f51b28392833adb6b2770b23b01abec84e369660b @@ -12352,6 +15197,22 @@ __metadata: languageName: node linkType: hard +"wbuf@npm:^1.1.0, wbuf@npm:^1.7.3": + version: 1.7.3 + resolution: "wbuf@npm:1.7.3" + dependencies: + minimalistic-assert: ^1.0.0 + checksum: 2abc306c96930b757972a1c4650eb6b25b5d99f24088714957f88629e137db569368c5de0e57986c89ea70db2f1df9bba11a87cb6d0c8694b6f53a0159fab3bf + languageName: node + linkType: hard + +"web-streams-polyfill@npm:^3.0.3": + version: 3.2.1 + resolution: "web-streams-polyfill@npm:3.2.1" + checksum: b119c78574b6d65935e35098c2afdcd752b84268e18746606af149e3c424e15621b6f1ff0b42b2676dc012fc4f0d313f964b41a4b5031e525faa03997457da02 + languageName: node + linkType: hard + "webidl-conversions@npm:^3.0.0": version: 3.0.1 resolution: "webidl-conversions@npm:3.0.1" @@ -12391,6 +15252,68 @@ __metadata: languageName: node linkType: hard +"webpack-dev-middleware@npm:^5.3.1": + version: 5.3.3 + resolution: "webpack-dev-middleware@npm:5.3.3" + dependencies: + colorette: ^2.0.10 + memfs: ^3.4.3 + mime-types: ^2.1.31 + range-parser: ^1.2.1 + schema-utils: ^4.0.0 + peerDependencies: + webpack: ^4.0.0 || ^5.0.0 + checksum: dd332cc6da61222c43d25e5a2155e23147b777ff32fdf1f1a0a8777020c072fbcef7756360ce2a13939c3f534c06b4992a4d659318c4a7fe2c0530b52a8a6621 + languageName: node + linkType: hard + +"webpack-dev-server@npm:^4.15.1": + version: 4.15.1 + resolution: "webpack-dev-server@npm:4.15.1" + dependencies: + "@types/bonjour": ^3.5.9 + "@types/connect-history-api-fallback": ^1.3.5 + "@types/express": ^4.17.13 + "@types/serve-index": ^1.9.1 + "@types/serve-static": ^1.13.10 + "@types/sockjs": ^0.3.33 + "@types/ws": ^8.5.5 + ansi-html-community: ^0.0.8 + bonjour-service: ^1.0.11 + chokidar: ^3.5.3 + colorette: ^2.0.10 + compression: ^1.7.4 + connect-history-api-fallback: ^2.0.0 + default-gateway: ^6.0.3 + express: ^4.17.3 + graceful-fs: ^4.2.6 + html-entities: ^2.3.2 + http-proxy-middleware: ^2.0.3 + ipaddr.js: ^2.0.1 + launch-editor: ^2.6.0 + open: ^8.0.9 + p-retry: ^4.5.0 + rimraf: ^3.0.2 + schema-utils: ^4.0.0 + selfsigned: ^2.1.1 + serve-index: ^1.9.1 + sockjs: ^0.3.24 + spdy: ^4.0.2 + webpack-dev-middleware: ^5.3.1 + ws: ^8.13.0 + peerDependencies: + webpack: ^4.37.0 || ^5.0.0 + peerDependenciesMeta: + webpack: + optional: true + webpack-cli: + optional: true + bin: + webpack-dev-server: bin/webpack-dev-server.js + checksum: cd0063b068d2b938fd76c412d555374186ac2fa84bbae098265212ed50a5c15d6f03aa12a5a310c544a242943eb58c0bfde4c296d5c36765c182f53799e1bc71 + languageName: node + linkType: hard + "webpack-merge@npm:^5.7.3": version: 5.9.0 resolution: "webpack-merge@npm:5.9.0" @@ -12445,6 +15368,24 @@ __metadata: languageName: node linkType: hard +"websocket-driver@npm:>=0.5.1, websocket-driver@npm:^0.7.4": + version: 0.7.4 + resolution: "websocket-driver@npm:0.7.4" + dependencies: + http-parser-js: ">=0.5.1" + safe-buffer: ">=5.1.0" + websocket-extensions: ">=0.1.1" + checksum: fffe5a33fe8eceafd21d2a065661d09e38b93877eae1de6ab5d7d2734c6ed243973beae10ae48c6613cfd675f200e5a058d1e3531bc9e6c5d4f1396ff1f0bfb9 + languageName: node + linkType: hard + +"websocket-extensions@npm:>=0.1.1": + version: 0.1.4 + resolution: "websocket-extensions@npm:0.1.4" + checksum: 5976835e68a86afcd64c7a9762ed85f2f27d48c488c707e67ba85e717b90fa066b98ab33c744d64255c9622d349eedecf728e65a5f921da71b58d0e9591b9038 + languageName: node + linkType: hard + "whatwg-url@npm:^5.0.0": version: 5.0.0 resolution: "whatwg-url@npm:5.0.0" @@ -12510,6 +15451,15 @@ __metadata: languageName: node linkType: hard +"widest-line@npm:^4.0.1": + version: 4.0.1 + resolution: "widest-line@npm:4.0.1" + dependencies: + string-width: ^5.0.1 + checksum: 64c48cf27171221be5f86fc54b94dd29879165bdff1a7aa92dde723d9a8c99fb108312768a5d62c8c2b80b701fa27bbd36a1ddc58367585cd45c0db7920a0cba + languageName: node + linkType: hard + "wildcard@npm:^2.0.0": version: 2.0.1 resolution: "wildcard@npm:2.0.1" @@ -12572,7 +15522,7 @@ __metadata: languageName: node linkType: hard -"wrap-ansi@npm:^8.1.0": +"wrap-ansi@npm:^8.0.1, wrap-ansi@npm:^8.1.0": version: 8.1.0 resolution: "wrap-ansi@npm:8.1.0" dependencies: @@ -12685,6 +15635,13 @@ __metadata: languageName: node linkType: hard +"yaml@npm:^2.1.1": + version: 2.3.2 + resolution: "yaml@npm:2.3.2" + checksum: acd80cc24df12c808c6dec8a0176d404ef9e6f08ad8786f746ecc9d8974968c53c6e8a67fdfabcc5f99f3dc59b6bb0994b95646ff03d18e9b1dcd59eccc02146 + languageName: node + linkType: hard + "yaml@npm:^2.1.3": version: 2.3.1 resolution: "yaml@npm:2.3.1" @@ -12769,3 +15726,15 @@ __metadata: checksum: f77b3d8d00310def622123df93d4ee654fc6a0096182af8bd60679ddcdfb3474c56c6c7190817c84a2785648cdee9d721c0154eb45698c62176c322fb46fc700 languageName: node linkType: hard + +"yup@npm:^1.2.0": + version: 1.2.0 + resolution: "yup@npm:1.2.0" + dependencies: + property-expr: ^2.0.5 + tiny-case: ^1.0.3 + toposort: ^2.0.2 + type-fest: ^2.19.0 + checksum: f0cdceb144e358c6155670f3e27404b65b090cc12594fde6db2699523661e13542aaf87ebe8e542b67f29a5f3f9bc5f23a3a3bb09e17f10d125353d35b841fac + languageName: node + linkType: hard