diff --git a/.gitignore b/.gitignore index 2bcb244..37abf11 100644 --- a/.gitignore +++ b/.gitignore @@ -24,4 +24,6 @@ dist-ssr *.sw? .env -yarn.lock \ No newline at end of file +yarn.lock +tsconfig.app.tsbuildinfo +tsconfig.node.tsbuildinfo \ No newline at end of file diff --git a/eslint.config.js b/eslint.config.js index b81f688..1b50b91 100644 --- a/eslint.config.js +++ b/eslint.config.js @@ -22,6 +22,7 @@ export default tseslint.config( 'react-refresh/only-export-components': ['warn', { allowConstantExport: true }], '@typescript-eslint/no-explicit-any': 'off', '@typescript-eslint/no-duplicate-enum-values': 'off', + '@typescript-eslint/no-unused-expressions': 'warn', }, }, ); diff --git a/package-lock.json b/package-lock.json index c3bab52..d1fb356 100644 --- a/package-lock.json +++ b/package-lock.json @@ -22,19 +22,23 @@ "react-dom": "^18.3.1", "react-icons": "^5.3.0", "react-intl": "^6.7.0", + "react-router-dom": "^6.26.2", "recoil": "^0.7.7" }, "devDependencies": { "@eslint/js": "^9.9.0", "@types/crypto-js": "^4.2.2", "@types/lodash": "^4.17.9", + "@types/node": "^22.7.4", "@types/react": "^18.3.3", "@types/react-dom": "^18.3.0", "@vitejs/plugin-react-swc": "^3.5.0", "autoprefixer": "^10.4.20", "eslint": "^9.9.0", + "eslint-config-prettier": "^9.1.0", + "eslint-plugin-prettier": "^5.2.1", "eslint-plugin-react-hooks": "^5.1.0-rc.0", - "eslint-plugin-react-refresh": "^0.4.9", + "eslint-plugin-react-refresh": "^0.4.12", "globals": "^15.9.0", "less": "^4.2.0", "postcss": "^8.4.47", @@ -917,6 +921,18 @@ "node": ">=14" } }, + "node_modules/@pkgr/core": { + "version": "0.1.1", + "resolved": "https://registry.npmjs.org/@pkgr/core/-/core-0.1.1.tgz", + "integrity": "sha512-cq8o4cWH0ibXh9VGi5P20Tu9XF/0fFXl9EUinr9QfTM7a7p0oTA4iJRCQWppXR1Pg8dSM0UCItCkPwsk9qWWYA==", + "dev": true, + "engines": { + "node": "^12.20.0 || ^14.18.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/unts" + } + }, "node_modules/@rc-component/async-validator": { "version": "5.0.4", "resolved": "https://registry.npmjs.org/@rc-component/async-validator/-/async-validator-5.0.4.tgz", @@ -1057,6 +1073,14 @@ "react-dom": ">=16.9.0" } }, + "node_modules/@remix-run/router": { + "version": "1.19.2", + "resolved": "https://registry.npmjs.org/@remix-run/router/-/router-1.19.2.tgz", + "integrity": "sha512-baiMx18+IMuD1yyvOGaHM9QrVUPGGG0jC+z+IPHnRJWUAUvaKuWKyE8gjDj2rzv3sz9zOGoRSPgeBVHRhZnBlA==", + "engines": { + "node": ">=14.0.0" + } + }, "node_modules/@rollup/rollup-android-arm-eabi": { "version": "4.23.0", "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.23.0.tgz", @@ -1511,6 +1535,15 @@ "integrity": "sha512-w9iWudx1XWOHW5lQRS9iKpK/XuRhnN+0T7HvdCCd802FYkT1AMTnxndJHGrNJwRoRHkslGr4S29tjm1cT7x/7w==", "dev": true }, + "node_modules/@types/node": { + "version": "22.7.4", + "resolved": "https://registry.npmjs.org/@types/node/-/node-22.7.4.tgz", + "integrity": "sha512-y+NPi1rFzDs1NdQHHToqeiX2TIS79SWEAw9GYhkkx8bD0ChpfqC+n2j5OXOCpzfojBEBt6DnEnnG9MY0zk1XLg==", + "dev": true, + "dependencies": { + "undici-types": "~6.19.2" + } + }, "node_modules/@types/prop-types": { "version": "15.7.13", "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.13.tgz", @@ -2516,6 +2549,48 @@ } } }, + "node_modules/eslint-config-prettier": { + "version": "9.1.0", + "resolved": "https://registry.npmjs.org/eslint-config-prettier/-/eslint-config-prettier-9.1.0.tgz", + "integrity": "sha512-NSWl5BFQWEPi1j4TjVNItzYV7dZXZ+wP6I6ZhrBGpChQhZRUaElihE9uRRkcbRnNb76UMKDF3r+WTmNcGPKsqw==", + "dev": true, + "bin": { + "eslint-config-prettier": "bin/cli.js" + }, + "peerDependencies": { + "eslint": ">=7.0.0" + } + }, + "node_modules/eslint-plugin-prettier": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/eslint-plugin-prettier/-/eslint-plugin-prettier-5.2.1.tgz", + "integrity": "sha512-gH3iR3g4JfF+yYPaJYkN7jEl9QbweL/YfkoRlNnuIEHEz1vHVlCmWOS+eGGiRuzHQXdJFCOTxRgvju9b8VUmrw==", + "dev": true, + "dependencies": { + "prettier-linter-helpers": "^1.0.0", + "synckit": "^0.9.1" + }, + "engines": { + "node": "^14.18.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/eslint-plugin-prettier" + }, + "peerDependencies": { + "@types/eslint": ">=8.0.0", + "eslint": ">=8.0.0", + "eslint-config-prettier": "*", + "prettier": ">=3.0.0" + }, + "peerDependenciesMeta": { + "@types/eslint": { + "optional": true + }, + "eslint-config-prettier": { + "optional": true + } + } + }, "node_modules/eslint-plugin-react-hooks": { "version": "5.1.0-rc-fb9a90fa48-20240614", "resolved": "https://registry.npmjs.org/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-5.1.0-rc-fb9a90fa48-20240614.tgz", @@ -2630,6 +2705,12 @@ "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==", "dev": true }, + "node_modules/fast-diff": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/fast-diff/-/fast-diff-1.3.0.tgz", + "integrity": "sha512-VxPP4NqbUjj6MaAOafWeUn2cXWLcCtljklUtZf0Ind4XQ+QPtmA0b18zZy0jIQx+ExRVCR/ZQpBmik5lXshNsw==", + "dev": true + }, "node_modules/fast-glob": { "version": "3.3.2", "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.2.tgz", @@ -3827,6 +3908,18 @@ "url": "https://github.com/prettier/prettier?sponsor=1" } }, + "node_modules/prettier-linter-helpers": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/prettier-linter-helpers/-/prettier-linter-helpers-1.0.0.tgz", + "integrity": "sha512-GbK2cP9nraSSUF9N2XwUwqfzlAFlMNYYl+ShE/V+H8a9uNl/oUqB1w2EL54Jh0OlyRSd8RfWYJ3coVS4TROP2w==", + "dev": true, + "dependencies": { + "fast-diff": "^1.1.2" + }, + "engines": { + "node": ">=6.0.0" + } + }, "node_modules/prop-types": { "version": "15.8.1", "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz", @@ -4517,6 +4610,36 @@ "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz", "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==" }, + "node_modules/react-router": { + "version": "6.26.2", + "resolved": "https://registry.npmjs.org/react-router/-/react-router-6.26.2.tgz", + "integrity": "sha512-tvN1iuT03kHgOFnLPfLJ8V95eijteveqdOSk+srqfePtQvqCExB8eHOYnlilbOcyJyKnYkr1vJvf7YqotAJu1A==", + "dependencies": { + "@remix-run/router": "1.19.2" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "react": ">=16.8" + } + }, + "node_modules/react-router-dom": { + "version": "6.26.2", + "resolved": "https://registry.npmjs.org/react-router-dom/-/react-router-dom-6.26.2.tgz", + "integrity": "sha512-z7YkaEW0Dy35T3/QKPYB1LjMK2R1fxnHO8kWpUMTBdfVzZrWOiY9a7CtN8HqdWtDUWd5FY6Dl8HFsqVwH4uOtQ==", + "dependencies": { + "@remix-run/router": "1.19.2", + "react-router": "6.26.2" + }, + "engines": { + "node": ">=14.0.0" + }, + "peerDependencies": { + "react": ">=16.8", + "react-dom": ">=16.8" + } + }, "node_modules/read-cache": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/read-cache/-/read-cache-1.0.0.tgz", @@ -4927,6 +5050,22 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/synckit": { + "version": "0.9.1", + "resolved": "https://registry.npmjs.org/synckit/-/synckit-0.9.1.tgz", + "integrity": "sha512-7gr8p9TQP6RAHusBOSLs46F4564ZrjV8xFmw5zCmgmhGUcw2hxsShhJ6CEiHQMgPDwAQ1fWHPM0ypc4RMAig4A==", + "dev": true, + "dependencies": { + "@pkgr/core": "^0.1.0", + "tslib": "^2.6.2" + }, + "engines": { + "node": "^14.18.0 || >=16.0.0" + }, + "funding": { + "url": "https://opencollective.com/unts" + } + }, "node_modules/tailwindcss": { "version": "3.4.13", "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-3.4.13.tgz", @@ -5100,6 +5239,12 @@ } } }, + "node_modules/undici-types": { + "version": "6.19.8", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.19.8.tgz", + "integrity": "sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==", + "dev": true + }, "node_modules/update-browserslist-db": { "version": "1.1.1", "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.1.1.tgz", diff --git a/package.json b/package.json index 04362b3..d293304 100644 --- a/package.json +++ b/package.json @@ -24,19 +24,23 @@ "react-dom": "^18.3.1", "react-icons": "^5.3.0", "react-intl": "^6.7.0", + "react-router-dom": "^6.26.2", "recoil": "^0.7.7" }, "devDependencies": { "@eslint/js": "^9.9.0", "@types/crypto-js": "^4.2.2", "@types/lodash": "^4.17.9", + "@types/node": "^22.7.4", "@types/react": "^18.3.3", "@types/react-dom": "^18.3.0", "@vitejs/plugin-react-swc": "^3.5.0", "autoprefixer": "^10.4.20", "eslint": "^9.9.0", + "eslint-config-prettier": "^9.1.0", + "eslint-plugin-prettier": "^5.2.1", "eslint-plugin-react-hooks": "^5.1.0-rc.0", - "eslint-plugin-react-refresh": "^0.4.9", + "eslint-plugin-react-refresh": "^0.4.12", "globals": "^15.9.0", "less": "^4.2.0", "postcss": "^8.4.47", diff --git a/src/base/data/local-data-services/index.ts b/src/base/data/local-data-services/index.ts new file mode 100644 index 0000000..f499f83 --- /dev/null +++ b/src/base/data/local-data-services/index.ts @@ -0,0 +1,19 @@ +import { LocalStorageService } from './local-storage.services'; +import { + LS_DEFAULT_URL, + LS_ACTIVE_ACCOUNT, + IDB_T_NAME__USER_DATA, + IDB_T_NAME__ACCESS_TOKEN, + IDB_T_NAME__PRIVILEGE, +} from './storage.key'; +import { IndexedDbService } from './indexed-db.services'; +import { appConfig } from './indexed-db.init'; + +// LOCAL STORAGE NO NEED PROMISE FOR CALL +export const StorageActiveAccount = new LocalStorageService(LS_ACTIVE_ACCOUNT); +export const StorageDefaultURL = new LocalStorageService(LS_DEFAULT_URL); + +// LOCAL STORAGE NEED PROMISE FOR CALL +export const StorageUserData = new IndexedDbService(appConfig, IDB_T_NAME__USER_DATA); +export const StorageAccessToken = new IndexedDbService(appConfig, IDB_T_NAME__ACCESS_TOKEN); +export const StoragePrivilege = new IndexedDbService(appConfig, IDB_T_NAME__PRIVILEGE); diff --git a/src/base/data/local-data-services/indexed-db.init.ts b/src/base/data/local-data-services/indexed-db.init.ts new file mode 100644 index 0000000..eb367a3 --- /dev/null +++ b/src/base/data/local-data-services/indexed-db.init.ts @@ -0,0 +1,27 @@ +import { openDB } from 'idb'; +import { IDB_NAME, IDB_T_NAME__ACCESS_TOKEN, IDB_T_NAME__USER_DATA, IDB_T_NAME__PRIVILEGE } from './storage.key'; + +export const appConfig = openDB(IDB_NAME, 3, { + upgrade(db) { + if (!db.objectStoreNames.contains(IDB_T_NAME__ACCESS_TOKEN)) { + db.createObjectStore(IDB_T_NAME__ACCESS_TOKEN, { + keyPath: 'id', + autoIncrement: false, + }); + } + + if (!db.objectStoreNames.contains(IDB_T_NAME__USER_DATA)) { + db.createObjectStore(IDB_T_NAME__USER_DATA, { + keyPath: 'id', + autoIncrement: false, + }); + } + + if (!db.objectStoreNames.contains(IDB_T_NAME__PRIVILEGE)) { + db.createObjectStore(IDB_T_NAME__PRIVILEGE, { + keyPath: 'id', + autoIncrement: false, + }); + } + }, +}); diff --git a/src/base/data/local-data-services/indexed-db.services.ts b/src/base/data/local-data-services/indexed-db.services.ts new file mode 100644 index 0000000..3b72a3e --- /dev/null +++ b/src/base/data/local-data-services/indexed-db.services.ts @@ -0,0 +1,92 @@ +import { DBSchema, IDBPDatabase } from 'idb'; +import { IIndexedDbService } from './storage.interface'; +import { decryptData, encryptData } from '@pos/base'; +import { StorageActiveAccount } from './index'; + +export type IndexedDbValueEntity = any; + +export class IndexedDbService implements IIndexedDbService { + dbPromise: IDBPDatabase | any; + dbTableName: string | any; + + constructor(dbPromise: IDBPDatabase | any, dbTableName: string | any) { + this.dbPromise = dbPromise; + this.dbTableName = dbTableName; + } + + async create(payload: IndexedDbValueEntity): Promise { + const id = StorageActiveAccount.get(); + const dataIsExist = await this.get(); + if (!dataIsExist && id) { + const d = encryptData(JSON.stringify(payload)); + const item = { id, d }; + + const db = await this.dbPromise; + const tx = db?.transaction(this.dbTableName, 'readwrite'); + const store = tx?.objectStore(this.dbTableName); + + await store?.add(item); + } else { + this.update(payload); + } + } + + async get(): Promise { + const id = StorageActiveAccount.get(); + if (!id) return undefined; + + const db = await this.dbPromise; + const tx = db.transaction(this.dbTableName, 'readwrite'); + const store = tx.objectStore(this.dbTableName); + const result = await store.get(id); + + if (!result) return undefined; + + const d = JSON.parse(decryptData(result.d)); + return d; + } + + async getAll(): Promise { + const db = await this.dbPromise; + const tx = db.transaction(this.dbTableName, 'readwrite'); + const store = tx.objectStore(this.dbTableName); + const result = await store.getAll(); + + if (!result) return undefined; + + const newResult = result.map((item: any) => { + return { + ...item, + d: JSON.parse(decryptData(item.d)), + }; + }); + + return newResult; + } + + async update(payload: IndexedDbValueEntity): Promise { + const id = StorageActiveAccount.get(); + + if (id) { + const d = encryptData(JSON.stringify(payload)); + const item = { id, d }; + + const db = await this.dbPromise; + const tx = db.transaction(this.dbTableName, 'readwrite'); + const store = tx.objectStore(this.dbTableName); + + await store.put(item); + } + } + + async delete(): Promise { + const id = StorageActiveAccount.get(); + + if (id) { + const db = await this.dbPromise; + const tx = db.transaction(this.dbTableName, 'readwrite'); + const store = tx.objectStore(this.dbTableName); + await store.delete(id); + } + } +} diff --git a/src/base/data/local-data-services/local-storage.services.ts b/src/base/data/local-data-services/local-storage.services.ts new file mode 100644 index 0000000..7699bdd --- /dev/null +++ b/src/base/data/local-data-services/local-storage.services.ts @@ -0,0 +1,31 @@ +import { decryptData, encryptData } from '@pos/base'; +import { ILocalStorageStorage, LSSetItemEntity } from './storage.interface'; + +export class LocalStorageService implements ILocalStorageStorage { + storageKey?: string; + constructor(storageKey?: string) { + this.storageKey = storageKey; + } + + create(payload: LSSetItemEntity): void { + const keyData = this.storageKey ?? payload.key; + if (keyData && payload.value) { + const value = encryptData(JSON.stringify(payload.value)); + localStorage.setItem(keyData, value); + } + } + + get(key?: string): string | null | undefined { + const keyData = this.storageKey ?? key; + if (keyData) { + const value = localStorage.getItem(keyData); + if (value) return JSON.parse(decryptData(value)); + return undefined; + } + } + + delete(key?: string): void { + const keyData = this.storageKey ?? key; + if (keyData) localStorage.removeItem(keyData); + } +} diff --git a/src/base/data/local-data-services/storage.interface.ts b/src/base/data/local-data-services/storage.interface.ts new file mode 100644 index 0000000..8e8998d --- /dev/null +++ b/src/base/data/local-data-services/storage.interface.ts @@ -0,0 +1,18 @@ +export interface IIndexedDbService { + create(payload: E): Promise; + get(): Promise; + getAll(): Promise; + update(payload: E): Promise; + delete(): Promise; +} + +export interface LSSetItemEntity { + key?: string; + value: string; +} + +export interface ILocalStorageStorage { + create(payload: LSSetItemEntity): void; + get(key: string): string | null | undefined; + delete(key: string): void; +} diff --git a/src/base/data/local-data-services/storage.key.ts b/src/base/data/local-data-services/storage.key.ts new file mode 100644 index 0000000..04fabf4 --- /dev/null +++ b/src/base/data/local-data-services/storage.key.ts @@ -0,0 +1,7 @@ +export const IDB_NAME = 'pos__gen__conf'; +export const IDB_T_NAME__USER_DATA = 'pos__Wl9Yf85G'; +export const IDB_T_NAME__ACCESS_TOKEN = 'pos__vRtgHurGCD'; +export const IDB_T_NAME__PRIVILEGE = 'pos__AzyMJGe21c'; + +export const LS_ACTIVE_ACCOUNT = 'pos__acc__log'; +export const LS_DEFAULT_URL = 'pros__deft_u'; diff --git a/src/base/data/remote-data-services/base-remote.data-services.ts b/src/base/data/remote-data-services/base-remote.data-services.ts new file mode 100644 index 0000000..a16d115 --- /dev/null +++ b/src/base/data/remote-data-services/base-remote.data-services.ts @@ -0,0 +1,544 @@ +import { IBaseDataServicesRepository } from '../../domain/repositories'; +import { + DataServicesConstructorEntity, + ResponseEntity, + ApiURLEntity, + RequestMethodEntity, + ManagerParamsEntity, + BaseEntity, +} from '../../domain/entities'; + +import { DEFAULT_METHOD, REQUEST_ACTION } from '../../infrastructure/constants'; +import axios, { AxiosResponse } from 'axios'; + +export abstract class BaseRemoteDataServices implements IBaseDataServicesRepository { + protected baseUrl?: string; + protected URLs: ApiURLEntity; + protected methods: RequestMethodEntity; + protected moduleKey: string | undefined; + + constructor(params: DataServicesConstructorEntity) { + const moduleKeyEncrypt = params.moduleKey; + + this.moduleKey = moduleKeyEncrypt; + + this.baseUrl = params.baseUrl; + this.URLs = { + ...(this.makeDefaultURL(params.apiUrl ?? '') ?? {}), + ...(params.urls ?? {}), + }; + this.methods = { + ...(DEFAULT_METHOD ?? {}), + ...(params.requestMethods ?? {}), + }; + } + + protected makeApiUrl(variable = {} as any, url = '' as string): string { + return url + .split('/') + .map((item: string) => { + if (item.includes(':')) return variable[item.slice(1)]; + return item; + }) + .join('/'); + } + + protected makeIds(payload: E[]): string[] { + const ids: string[] = []; + for (const entity of payload) { + if (entity.id) ids.push(entity.id.toString()); + } + return ids; + } + + protected makeId(payload: E): string { + if (payload.id) return payload.id; + return ''; + } + + protected makeHeader(action: string) { + return { + 'ex-model-key': this.moduleKey, + 'ex-model-action': action, + }; + } + + protected makeDefaultURL(apiUrl: string): ApiURLEntity { + return { + getManyUrl: `${apiUrl}`, + getOneUrl: `${apiUrl}/:id`, + createUrl: `${apiUrl}`, + editUrl: `${apiUrl}/:id`, + + deleteUrl: `${apiUrl}/:id`, + batchDeleteUrl: `${apiUrl}/batch-delete`, + + activateUrl: `${apiUrl}/:id/active`, + batchActivateUrl: `${apiUrl}/batch-active`, + + deactivateUrl: `${apiUrl}/:id/inactive`, + batchDeactivateUrl: `${apiUrl}/batch-inactive`, + + confirmProcessDataUrl: `${apiUrl}/:id/confirm`, + batchConfirmProcessDataUrl: `${apiUrl}/batch-confirm`, + + cancelProcessDataUrl: `${apiUrl}/:id/cancel`, + batchCancelProcessDataUrl: `${apiUrl}/batch-cancel`, + + confirmProcessTransactionUrl: `${apiUrl}/:id/confirm-data`, + batchConfirmProcessTransactionUrl: `${apiUrl}/batch-confirm-data`, + + cancelProcessTransactionUrl: `${apiUrl}/:id/cancel`, + batchCancelProcessTransactionUrl: `${apiUrl}/batch-cancel`, + + rollbackProcessTransactionUrl: `${apiUrl}/:id/confirm-rollback`, + batchRollbackProcessTransactionUrl: `${apiUrl}/batch-confirm-rollback`, + + holdProcessTransactionUrl: `${apiUrl}/:id/confirm-hold`, + batchHoldProcessTransactionUrl: `${apiUrl}/batch-confirm-hold`, + }; + } + + //custom request + async handleCustomRequest(manager: ManagerParamsEntity): Promise { + try { + const response: AxiosResponse = await axios.request({ + ...(manager.config ?? {}), + baseURL: this.baseUrl, + params: { + ...(manager?.config?.params ?? {}), + }, + }); + + if (manager.onSuccess) manager.onSuccess(response as ResponseEntity); + } catch (error) { + if (manager.onFailed) manager.onFailed(error as ResponseEntity); + } + } + + async handleGetOne(manager: ManagerParamsEntity): Promise { + try { + const response: AxiosResponse = await axios.request({ + baseURL: this.baseUrl, + url: this.makeApiUrl(manager.variableURL, this.URLs.getOneUrl), + method: this.methods.getOneMethod, + ...(manager.config ?? {}), + headers: this.makeHeader(REQUEST_ACTION.VIEW), + }); + + if (manager.onSuccess) manager.onSuccess(response as ResponseEntity); + } catch (error) { + if (manager.onFailed) manager.onFailed(error as ResponseEntity); + } + } + + async handleGetMany(manager: ManagerParamsEntity): Promise { + try { + const response: AxiosResponse = await axios.request({ + baseURL: this.baseUrl, + url: this.makeApiUrl(manager.variableURL, this.URLs.getManyUrl), + method: this.methods.getManyMethod, + ...(manager.config ?? {}), + params: { + ...(manager?.config?.params ?? {}), + }, + headers: { ...this.makeHeader(REQUEST_ACTION.VIEW), ...(manager?.config?.headers ?? {}) }, + }); + + if (manager.onSuccess) manager.onSuccess(response as ResponseEntity); + } catch (error) { + if (manager.onFailed) manager.onFailed(error as ResponseEntity); + } + } + + async handleCreate(manager: ManagerParamsEntity): Promise { + try { + const response: AxiosResponse = await axios.request({ + baseURL: this.baseUrl, + url: this.makeApiUrl(manager.variableURL, this.URLs.createUrl), + method: this.methods.createMethod, + // headers: HeaderPost, + ...(manager.config ?? {}), + params: { + ...(manager?.config?.params ?? {}), + }, + headers: this.makeHeader(REQUEST_ACTION.CREATE), + }); + + if (manager.onSuccess) manager.onSuccess(response as ResponseEntity); + } catch (error) { + if (manager.onFailed) manager.onFailed(error as ResponseEntity); + } + } + + async handleEdit(manager: ManagerParamsEntity): Promise { + try { + const response: AxiosResponse = await axios.request({ + baseURL: this.baseUrl, + url: this.makeApiUrl(manager.variableURL, this.URLs.editUrl), + method: this.methods.editMethod, + // headers: HeaderPost, + ...(manager.config ?? {}), + params: { + ...(manager?.config?.params ?? {}), + }, + headers: this.makeHeader(REQUEST_ACTION.EDIT), + }); + + if (manager.onSuccess) manager.onSuccess(response as ResponseEntity); + } catch (error) { + if (manager.onFailed) manager.onFailed(error as ResponseEntity); + } + } + + async handleDelete(manager: ManagerParamsEntity): Promise { + try { + const response: AxiosResponse = await axios.request({ + baseURL: this.baseUrl, + url: this.makeApiUrl(manager.variableURL, this.URLs.deleteUrl), + method: this.methods.deleteMethod, + ...(manager.config ?? {}), + params: { + ...(manager?.config?.params ?? {}), + }, + headers: this.makeHeader(REQUEST_ACTION.DELETE), + }); + + if (manager.onSuccess) manager.onSuccess(response as ResponseEntity); + } catch (error) { + if (manager.onFailed) manager.onFailed(error as ResponseEntity); + } + } + + async handleBatchDelete(manager: ManagerParamsEntity): Promise { + try { + const response: AxiosResponse = await axios.request({ + baseURL: this.baseUrl, + url: this.makeApiUrl(manager.variableURL, this.URLs.batchDeleteUrl), + method: this.methods.batchDeleteMethod, + // data: { ids: this.makeIds(manager.config?.data) }, + ...(manager.config ?? {}), + params: { + ...(manager?.config?.params ?? {}), + }, + headers: this.makeHeader(REQUEST_ACTION.DELETE), + }); + + if (manager.onSuccess) manager.onSuccess(response as ResponseEntity); + } catch (error) { + if (manager.onFailed) manager.onFailed(error as ResponseEntity); + } + } + + async handleConfirmProcessData(manager: ManagerParamsEntity): Promise { + try { + const response: AxiosResponse = await axios.request({ + baseURL: this.baseUrl, + url: this.makeApiUrl(manager.variableURL, this.URLs.confirmProcessDataUrl), + method: this.methods.confirmProcessDataMethod, + ...(manager.config ?? {}), + params: { + ...(manager?.config?.params ?? {}), + }, + headers: this.makeHeader(REQUEST_ACTION.CONFIRM_DATA), + }); + + if (manager.onSuccess) manager.onSuccess(response as ResponseEntity); + } catch (error) { + if (manager.onFailed) manager.onFailed(error as ResponseEntity); + } + } + + async handleBatchConfirmProcessData(manager: ManagerParamsEntity): Promise { + try { + const response: AxiosResponse = await axios.request({ + baseURL: this.baseUrl, + url: this.makeApiUrl(manager.variableURL, this.URLs.batchConfirmProcessDataUrl), + method: this.methods.batchConfirmProcessDataMethod, + // data: { ids: this.makeIds(manager.config?.data) }, + ...(manager.config ?? {}), + params: { + ...(manager?.config?.params ?? {}), + }, + headers: this.makeHeader(REQUEST_ACTION.CONFIRM_DATA), + }); + + if (manager.onSuccess) manager.onSuccess(response as ResponseEntity); + } catch (error) { + if (manager.onFailed) manager.onFailed(error as ResponseEntity); + } + } + + async handleCancelProcessData(manager: ManagerParamsEntity): Promise { + try { + const response: AxiosResponse = await axios.request({ + baseURL: this.baseUrl, + url: this.makeApiUrl(manager.variableURL, this.URLs.cancelProcessDataUrl), + method: this.methods.cancelProcessDataMethod, + ...(manager.config ?? {}), + params: { + ...(manager?.config?.params ?? {}), + }, + headers: this.makeHeader(REQUEST_ACTION.CANCEL_DATA), + }); + + if (manager.onSuccess) manager.onSuccess(response as ResponseEntity); + } catch (error) { + if (manager.onFailed) manager.onFailed(error as ResponseEntity); + } + } + + async handleBatchCancelProcessData(manager: ManagerParamsEntity): Promise { + try { + const response: AxiosResponse = await axios.request({ + baseURL: this.baseUrl, + url: this.makeApiUrl(manager.variableURL, this.URLs.batchCancelProcessDataUrl), + method: this.methods.batchCancelProcessDataMethod, + // data: { ids: this.makeIds(manager.config?.data) }, + ...(manager.config ?? {}), + params: { + ...(manager?.config?.params ?? {}), + }, + headers: this.makeHeader(REQUEST_ACTION.CANCEL_DATA), + }); + + if (manager.onSuccess) manager.onSuccess(response as ResponseEntity); + } catch (error) { + if (manager.onFailed) manager.onFailed(error as ResponseEntity); + } + } + + async handleActivate(manager: ManagerParamsEntity): Promise { + try { + const response: AxiosResponse = await axios.request({ + baseURL: this.baseUrl, + url: this.makeApiUrl(manager.variableURL, this.URLs.activateUrl), + method: this.methods.activateMethod, + ...(manager.config ?? {}), + params: { + ...(manager?.config?.params ?? {}), + }, + headers: this.makeHeader(REQUEST_ACTION.CONFIRM_DATA), + }); + + if (manager.onSuccess) manager.onSuccess(response as ResponseEntity); + } catch (error) { + if (manager.onFailed) manager.onFailed(error as ResponseEntity); + } + } + + async handleBatchActivate(manager: ManagerParamsEntity): Promise { + try { + const response: AxiosResponse = await axios.request({ + baseURL: this.baseUrl, + url: this.makeApiUrl(manager.variableURL, this.URLs.batchActivateUrl), + method: this.methods.batchActivateMethod, + // data: { ids: this.makeIds(manager.config?.data) }, + ...(manager.config ?? {}), + params: { + ...(manager?.config?.params ?? {}), + }, + headers: this.makeHeader(REQUEST_ACTION.CONFIRM_DATA), + }); + + if (manager.onSuccess) manager.onSuccess(response as ResponseEntity); + } catch (error) { + if (manager.onFailed) manager.onFailed(error as ResponseEntity); + } + } + + async handleDeactivate(manager: ManagerParamsEntity): Promise { + try { + const response: AxiosResponse = await axios.request({ + baseURL: this.baseUrl, + url: this.makeApiUrl(manager.variableURL, this.URLs.deactivateUrl), + method: this.methods.deactivateMethod, + ...(manager.config ?? {}), + params: { + ...(manager?.config?.params ?? {}), + }, + headers: this.makeHeader(REQUEST_ACTION.CONFIRM_DATA), + }); + + if (manager.onSuccess) manager.onSuccess(response as ResponseEntity); + } catch (error) { + if (manager.onFailed) manager.onFailed(error as ResponseEntity); + } + } + + async handleBatchDeactivate(manager: ManagerParamsEntity): Promise { + try { + const response: AxiosResponse = await axios.request({ + baseURL: this.baseUrl, + url: this.makeApiUrl(manager.variableURL, this.URLs.batchDeactivateUrl), + method: this.methods.batchDeactivateMethod, + // data: { ids: this.makeIds(manager.config?.data) }, + ...(manager.config ?? {}), + params: { + ...(manager?.config?.params ?? {}), + }, + headers: this.makeHeader(REQUEST_ACTION.CONFIRM_DATA), + }); + + if (manager.onSuccess) manager.onSuccess(response as ResponseEntity); + } catch (error) { + if (manager.onFailed) manager.onFailed(error as ResponseEntity); + } + } + + async handleConfirmProcessTransaction(manager: ManagerParamsEntity): Promise { + try { + const response: AxiosResponse = await axios.request({ + baseURL: this.baseUrl, + url: this.makeApiUrl(manager.variableURL, this.URLs.confirmProcessTransactionUrl), + method: this.methods.confirmProcessTransactionMethod, + ...(manager.config ?? {}), + params: { + ...(manager?.config?.params ?? {}), + }, + headers: this.makeHeader(REQUEST_ACTION.CONFIRM_PROCESS_TRANSACTION), + }); + + if (manager.onSuccess) manager.onSuccess(response as ResponseEntity); + } catch (error) { + if (manager.onFailed) manager.onFailed(error as ResponseEntity); + } + } + + async handleBatchConfirmProcessTransaction(manager: ManagerParamsEntity): Promise { + try { + const response: AxiosResponse = await axios.request({ + baseURL: this.baseUrl, + url: this.makeApiUrl(manager.variableURL, this.URLs.batchConfirmProcessTransactionUrl), + method: this.methods.batchConfirmProcessTransactionMethod, + // data: { ids: this.makeIds(manager.config?.data) }, + ...(manager.config ?? {}), + params: { + ...(manager?.config?.params ?? {}), + }, + headers: this.makeHeader(REQUEST_ACTION.CONFIRM_PROCESS_TRANSACTION), + }); + + if (manager.onSuccess) manager.onSuccess(response as ResponseEntity); + } catch (error) { + if (manager.onFailed) manager.onFailed(error as ResponseEntity); + } + } + + async handleCancelProcessTransaction(manager: ManagerParamsEntity): Promise { + try { + const response: AxiosResponse = await axios.request({ + baseURL: this.baseUrl, + url: this.makeApiUrl(manager.variableURL, this.URLs.cancelProcessTransactionUrl), + method: this.methods.cancelProcessTransactionMethod, + ...(manager.config ?? {}), + params: { + ...(manager?.config?.params ?? {}), + }, + headers: this.makeHeader(REQUEST_ACTION.CANCEL_PROCESS_TRANSACTION), + }); + + if (manager.onSuccess) manager.onSuccess(response as ResponseEntity); + } catch (error) { + if (manager.onFailed) manager.onFailed(error as ResponseEntity); + } + } + + async handleBatchCancelProcessTransaction(manager: ManagerParamsEntity): Promise { + try { + const response: AxiosResponse = await axios.request({ + baseURL: this.baseUrl, + url: this.makeApiUrl(manager.variableURL, this.URLs.batchCancelProcessTransactionUrl), + method: this.methods.batchCancelProcessTransactionMethod, + // data: { ids: this.makeIds(manager.config?.data) }, + ...(manager.config ?? {}), + params: { + ...(manager?.config?.params ?? {}), + }, + headers: this.makeHeader(REQUEST_ACTION.CANCEL_PROCESS_TRANSACTION), + }); + + if (manager.onSuccess) manager.onSuccess(response as ResponseEntity); + } catch (error) { + if (manager.onFailed) manager.onFailed(error as ResponseEntity); + } + } + + async handleRollbackProcessTransaction(manager: ManagerParamsEntity): Promise { + try { + const response: AxiosResponse = await axios.request({ + baseURL: this.baseUrl, + url: this.makeApiUrl(manager.variableURL, this.URLs.rollbackProcessTransactionUrl), + method: this.methods.rollbackProcessTransactionMethod, + ...(manager.config ?? {}), + params: { + ...(manager?.config?.params ?? {}), + }, + headers: this.makeHeader(REQUEST_ACTION.CONFIRM_PROCESS_TRANSACTION), + }); + + if (manager.onSuccess) manager.onSuccess(response as ResponseEntity); + } catch (error) { + if (manager.onFailed) manager.onFailed(error as ResponseEntity); + } + } + + async handleBatchRollbackProcessTransaction(manager: ManagerParamsEntity): Promise { + try { + const response: AxiosResponse = await axios.request({ + baseURL: this.baseUrl, + url: this.makeApiUrl(manager.variableURL, this.URLs.batchRollbackProcessTransactionUrl), + method: this.methods.batchRollbackProcessTransactionMethod, + // data: { ids: this.makeIds(manager.config?.data) }, + ...(manager.config ?? {}), + params: { + ...(manager?.config?.params ?? {}), + }, + headers: this.makeHeader(REQUEST_ACTION.CONFIRM_PROCESS_TRANSACTION), + }); + + if (manager.onSuccess) manager.onSuccess(response as ResponseEntity); + } catch (error) { + if (manager.onFailed) manager.onFailed(error as ResponseEntity); + } + } + + async handleHoldProcessTransaction(manager: ManagerParamsEntity): Promise { + try { + const response: AxiosResponse = await axios.request({ + baseURL: this.baseUrl, + url: this.makeApiUrl(manager.variableURL, this.URLs.holdProcessTransactionUrl), + method: this.methods.holdProcessTransactionMethod, + ...(manager.config ?? {}), + params: { + action: REQUEST_ACTION.CONFIRM_PROCESS_TRANSACTION, + ...(manager?.config?.params ?? {}), + }, + }); + + if (manager.onSuccess) manager.onSuccess(response as ResponseEntity); + } catch (error) { + if (manager.onFailed) manager.onFailed(error as ResponseEntity); + } + } + + async handleBatchHoldProcessTransaction(manager: ManagerParamsEntity): Promise { + try { + const response: AxiosResponse = await axios.request({ + baseURL: this.baseUrl, + url: this.makeApiUrl(manager.variableURL, this.URLs.batchHoldProcessTransactionUrl), + method: this.methods.batchHoldProcessTransactionMethod, + // data: { ids: this.makeIds(manager.config?.data) }, + ...(manager.config ?? {}), + params: { + action: REQUEST_ACTION.CONFIRM_PROCESS_TRANSACTION, + ...(manager?.config?.params ?? {}), + }, + }); + + if (manager.onSuccess) manager.onSuccess(response as ResponseEntity); + } catch (error) { + if (manager.onFailed) manager.onFailed(error as ResponseEntity); + } + } +} diff --git a/src/base/data/remote-data-services/common-remote.data-services.ts b/src/base/data/remote-data-services/common-remote.data-services.ts new file mode 100644 index 0000000..290367d --- /dev/null +++ b/src/base/data/remote-data-services/common-remote.data-services.ts @@ -0,0 +1,4 @@ +import { BaseEntity } from '../../domain/entities'; +import { BaseRemoteDataServices } from './base-remote.data-services'; + +export class CommonRemoteDataServices extends BaseRemoteDataServices {} diff --git a/src/base/data/remote-data-services/index.ts b/src/base/data/remote-data-services/index.ts new file mode 100644 index 0000000..f36a8ab --- /dev/null +++ b/src/base/data/remote-data-services/index.ts @@ -0,0 +1,2 @@ +export * from './base-remote.data-services'; +export * from './common-remote.data-services'; diff --git a/src/base/domain/entities/base-data-services.entity.ts b/src/base/domain/entities/base-data-services.entity.ts new file mode 100644 index 0000000..329b51d --- /dev/null +++ b/src/base/domain/entities/base-data-services.entity.ts @@ -0,0 +1,100 @@ +import { AxiosRequestConfig, Method as AxiosMethod } from 'axios'; + +export interface ResponseErrorEntity { + message?: Error | string | string[]; + status: number; +} + +export interface ResponseSuccessEntity { + data?: T; + status: number; +} + +export interface VariableURLEntity { + [key: string]: string; +} + +export interface ManagerParamsEntity { + config?: AxiosRequestConfig; + variableURL?: VariableURLEntity; + onFailed?(error: ResponseErrorEntity): void; + onSuccess?(response: ResponseSuccessEntity): void; +} + +export type ResponseEntity = ResponseSuccessEntity | ResponseErrorEntity; + +export interface ApiURLEntity { + getManyUrl?: string; + getOneUrl?: string; + createUrl?: string; + editUrl?: string; + + deleteUrl?: string; + batchDeleteUrl?: string; + + confirmProcessDataUrl?: string; + batchConfirmProcessDataUrl?: string; + + cancelProcessDataUrl?: string; + batchCancelProcessDataUrl?: string; + + activateUrl?: string; + batchActivateUrl?: string; + + deactivateUrl?: string; + batchDeactivateUrl?: string; + + confirmProcessTransactionUrl?: string; + batchConfirmProcessTransactionUrl?: string; + + cancelProcessTransactionUrl?: string; + batchCancelProcessTransactionUrl?: string; + + rollbackProcessTransactionUrl?: string; + batchRollbackProcessTransactionUrl?: string; + + holdProcessTransactionUrl?: string; + batchHoldProcessTransactionUrl?: string; +} + +export interface RequestMethodEntity { + getManyMethod?: AxiosMethod; + getOneMethod?: AxiosMethod; + createMethod?: AxiosMethod; + editMethod?: AxiosMethod; + + deleteMethod?: AxiosMethod; + batchDeleteMethod?: AxiosMethod; + + confirmProcessDataMethod?: AxiosMethod; + batchConfirmProcessDataMethod?: AxiosMethod; + + cancelProcessDataMethod?: AxiosMethod; + batchCancelProcessDataMethod?: AxiosMethod; + + activateMethod?: AxiosMethod; + batchActivateMethod?: AxiosMethod; + + deactivateMethod?: AxiosMethod; + batchDeactivateMethod?: AxiosMethod; + + confirmProcessTransactionMethod?: AxiosMethod; + batchConfirmProcessTransactionMethod?: AxiosMethod; + + cancelProcessTransactionMethod?: AxiosMethod; + batchCancelProcessTransactionMethod?: AxiosMethod; + + rollbackProcessTransactionMethod?: AxiosMethod; + batchRollbackProcessTransactionMethod?: AxiosMethod; + + holdProcessTransactionMethod?: AxiosMethod; + batchHoldProcessTransactionMethod?: AxiosMethod; +} + +export interface DataServicesConstructorEntity { + baseUrl?: string; + apiUrl?: string; + urls?: ApiURLEntity; + requestMethods?: RequestMethodEntity; + moduleKey?: string; +} diff --git a/src/base/domain/entities/base.entity.ts b/src/base/domain/entities/base.entity.ts new file mode 100644 index 0000000..4f9965f --- /dev/null +++ b/src/base/domain/entities/base.entity.ts @@ -0,0 +1,6 @@ +export type FormPageActionEntity = 'create' | 'edit' | 'duplicate'; + +export interface BaseEntity { + id?: string; + [key: string]: any; +} diff --git a/src/base/domain/entities/index.ts b/src/base/domain/entities/index.ts new file mode 100644 index 0000000..6354063 --- /dev/null +++ b/src/base/domain/entities/index.ts @@ -0,0 +1,2 @@ +export * from './base-data-services.entity'; +export * from './base.entity'; diff --git a/src/base/domain/factories/base-data-services.factory.ts b/src/base/domain/factories/base-data-services.factory.ts new file mode 100644 index 0000000..bd34ad2 --- /dev/null +++ b/src/base/domain/factories/base-data-services.factory.ts @@ -0,0 +1,7 @@ +import { CommonRemoteDataServices } from '@pos/base'; +import { IBaseDataServicesRepository } from '../repositories'; +import { DataServicesConstructorEntity } from '../entities'; + +export function makeCommonDataServices(params: DataServicesConstructorEntity): IBaseDataServicesRepository { + return new CommonRemoteDataServices(params); +} diff --git a/src/base/domain/factories/base-transformer.factory.ts b/src/base/domain/factories/base-transformer.factory.ts new file mode 100644 index 0000000..3bf416b --- /dev/null +++ b/src/base/domain/factories/base-transformer.factory.ts @@ -0,0 +1,7 @@ +import { BaseEntity } from '../entities'; +import { CommonTransformer } from '../transformers'; +import { IBaseTransformerRepository } from '../repositories'; + +export function makeCommonTransformer(): IBaseTransformerRepository { + return new CommonTransformer(); +} diff --git a/src/base/domain/factories/index.ts b/src/base/domain/factories/index.ts new file mode 100644 index 0000000..12b949c --- /dev/null +++ b/src/base/domain/factories/index.ts @@ -0,0 +1,2 @@ +export * from './base-data-services.factory'; +export * from './base-transformer.factory'; diff --git a/src/base/domain/repositories/base-services.repository.ts b/src/base/domain/repositories/base-services.repository.ts new file mode 100644 index 0000000..2c0c404 --- /dev/null +++ b/src/base/domain/repositories/base-services.repository.ts @@ -0,0 +1,49 @@ +import { ManagerParamsEntity } from '../entities'; + +export interface IBaseDataServicesRepository { + handleCustomRequest(manager: ManagerParamsEntity): Promise; + + //get data + handleGetOne(manager: ManagerParamsEntity): Promise; + handleGetMany(manager: ManagerParamsEntity): Promise; + + //create and edit + handleCreate(manager: ManagerParamsEntity): Promise; + handleEdit(manager: ManagerParamsEntity): Promise; + + //delete + handleDelete(manager: ManagerParamsEntity): Promise; + handleBatchDelete(manager: ManagerParamsEntity): Promise; + + //confirm process data + handleConfirmProcessData(manager: ManagerParamsEntity): Promise; + handleBatchConfirmProcessData(manager: ManagerParamsEntity): Promise; + + //cancel data + handleCancelProcessData(manager: ManagerParamsEntity): Promise; + handleBatchCancelProcessData(manager: ManagerParamsEntity): Promise; + + //activate + handleActivate(manager: ManagerParamsEntity): Promise; + handleBatchActivate(manager: ManagerParamsEntity): Promise; + + //deactivate + handleDeactivate(manager: ManagerParamsEntity): Promise; + handleBatchDeactivate(manager: ManagerParamsEntity): Promise; + + //confirm process transaction + handleConfirmProcessTransaction(manager: ManagerParamsEntity): Promise; + handleBatchConfirmProcessTransaction(manager: ManagerParamsEntity): Promise; + + //confirm cancel transaction + handleCancelProcessTransaction(manager: ManagerParamsEntity): Promise; + handleBatchCancelProcessTransaction(manager: ManagerParamsEntity): Promise; + + //confirm rollback transaction + handleRollbackProcessTransaction(manager: ManagerParamsEntity): Promise; + handleBatchRollbackProcessTransaction(manager: ManagerParamsEntity): Promise; + + //confirm hold transaction + handleHoldProcessTransaction(manager: ManagerParamsEntity): Promise; + handleBatchHoldProcessTransaction(manager: ManagerParamsEntity): Promise; +} diff --git a/src/base/domain/repositories/base-transformer.repository.ts b/src/base/domain/repositories/base-transformer.repository.ts new file mode 100644 index 0000000..0890ec7 --- /dev/null +++ b/src/base/domain/repositories/base-transformer.repository.ts @@ -0,0 +1,11 @@ +import { BaseEntity } from '../entities'; + +export interface IBaseTransformerRepository { + transformerGetList(payload: PayloadEntity[]): PayloadEntity[]; + transformerGetOne(payload: PayloadEntity): PayloadEntity; + transformerCreate(payload: PayloadEntity): PayloadEntity; + transformerEdit(payload: PayloadEntity): PayloadEntity; + transformerDuplicate(payload: PayloadEntity): PayloadEntity; + transformerFilterIndexTable(payload: any): any; + transformerDefaultFilterIndexTable(payload: any): any; +} diff --git a/src/base/domain/repositories/index.ts b/src/base/domain/repositories/index.ts new file mode 100644 index 0000000..37d439f --- /dev/null +++ b/src/base/domain/repositories/index.ts @@ -0,0 +1,2 @@ +export * from './base-services.repository'; +export * from './base-transformer.repository'; diff --git a/src/base/domain/transformers/base.transformer.ts b/src/base/domain/transformers/base.transformer.ts new file mode 100644 index 0000000..bc5434c --- /dev/null +++ b/src/base/domain/transformers/base.transformer.ts @@ -0,0 +1,26 @@ +import { BaseEntity } from '../entities'; +import { IBaseTransformerRepository } from '../repositories'; + +export abstract class BaseTransformer implements IBaseTransformerRepository { + transformerGetList(payload: any): E[] { + return payload; + } + transformerGetOne(payload: any): E { + return payload; + } + transformerCreate(payload: any): E { + return { ...payload, id: undefined }; + } + transformerEdit(payload: any): E { + return { ...payload, id: undefined }; + } + transformerDuplicate(payload: any): E { + return { ...payload, id: undefined }; + } + transformerFilterIndexTable(payload: any): any { + return payload; + } + transformerDefaultFilterIndexTable(payload: any): any { + return payload; + } +} diff --git a/src/base/domain/transformers/common.transformer.ts b/src/base/domain/transformers/common.transformer.ts new file mode 100644 index 0000000..6f958b9 --- /dev/null +++ b/src/base/domain/transformers/common.transformer.ts @@ -0,0 +1,4 @@ +import { BaseEntity } from '../entities'; +import { BaseTransformer } from '../transformers'; + +export class CommonTransformer extends BaseTransformer {} diff --git a/src/base/domain/transformers/index.ts b/src/base/domain/transformers/index.ts new file mode 100644 index 0000000..365e9b7 --- /dev/null +++ b/src/base/domain/transformers/index.ts @@ -0,0 +1,2 @@ +export * from './base.transformer'; +export * from './common.transformer'; diff --git a/src/base/index.ts b/src/base/index.ts new file mode 100644 index 0000000..3bf75bc --- /dev/null +++ b/src/base/index.ts @@ -0,0 +1,18 @@ +// Data +export * from './data/local-data-services'; +export * from './data/remote-data-services'; + +// Domain +export * from './domain/entities'; +export * from './domain/factories'; +export * from './domain/repositories'; +export * from './domain/transformers'; + +// Infrastructure +export * from './infrastructure/constants'; +export * from './infrastructure/helpers'; + +// Presentations +export * from './presentation/hooks'; +export * from './presentation/providers'; +export * from './presentation/states'; diff --git a/src/base/infrastructure/constants/api-url/index.ts b/src/base/infrastructure/constants/api-url/index.ts new file mode 100644 index 0000000..bd938ce --- /dev/null +++ b/src/base/infrastructure/constants/api-url/index.ts @@ -0,0 +1,9 @@ +export const API_URL = { + LOGIN: '/v1/auth', + LOGOUT: '/v1/auth/logout', + FORCE_LOGOUT: '/v1/auth/force-logout', + + REPORT: '/v1/report', + REPORT_TENANT: '/v1/report', + REPORT_BOOKMARK: '/v1/report-bookmark', +}; diff --git a/src/base/infrastructure/constants/app-source/index.ts b/src/base/infrastructure/constants/app-source/index.ts new file mode 100644 index 0000000..39c9ee1 --- /dev/null +++ b/src/base/infrastructure/constants/app-source/index.ts @@ -0,0 +1,6 @@ +export enum AppSource { + POS_ADMIN = 'POS_ADMIN', + POS_COUNTER = 'POS_COUNTER', + QUEUE_ADMIN = 'QUEUE_ADMIN', + QUEUE_CUSTOMER = 'QUEUE_CUSTOMER', +} diff --git a/src/base/infrastructure/constants/environment/index.ts b/src/base/infrastructure/constants/environment/index.ts new file mode 100644 index 0000000..edadee5 --- /dev/null +++ b/src/base/infrastructure/constants/environment/index.ts @@ -0,0 +1,10 @@ +export const APP_MODE: 'development' | 'production' = import.meta.env.VITE_APP_MODE; +export const BASE_API_URL: string = import.meta.env.VITE_BASE_API_URL; +export const BASE_ASSET_URL: string = import.meta.env.VITE_BASE_ASSET_URL; +export const BASE_API_REPORT_URL: string = import.meta.env.VITE_BASE_API_REPORT_URL; +export const SUPERSET_URL: string = import.meta.env.VITE_SUPERSET_URL; +export const EMBED_DASHBOARD_ID = import.meta.env.VITE_EMBED_DASHBOARD_ID; + +export const DOWLOAD_POS_WINDOWS_URL = import.meta.env.VITE_DOWLOAD_POS_WINDOWS_URL; +export const DOWLOAD_POS_LINUX_DEB_URL = import.meta.env.VITE_DOWLOAD_POS_LINUX_DEB_URL; +export const DOWLOAD_POS_LINUX_SNAP_URL = import.meta.env.VITE_DOWLOAD_POS_LINUX_SNAP_URL; diff --git a/src/base/infrastructure/constants/format-date/index.ts b/src/base/infrastructure/constants/format-date/index.ts new file mode 100644 index 0000000..7a3a341 --- /dev/null +++ b/src/base/infrastructure/constants/format-date/index.ts @@ -0,0 +1,5 @@ +export const formatDate = 'DD/MM/YYYY'; + +export const formatTime = 'HH:mm'; + +export const formatDateTime = `${formatDate} ${formatTime}`; diff --git a/src/base/infrastructure/constants/index.ts b/src/base/infrastructure/constants/index.ts new file mode 100644 index 0000000..64ad0b0 --- /dev/null +++ b/src/base/infrastructure/constants/index.ts @@ -0,0 +1,14 @@ +export * from './environment'; +export * from './web-url'; +export * from './sidebar'; +export * from './module-key'; +export * from './page-action'; +export * from './request-action'; +export * from './request-info'; +export * from './request-method'; +export * from './status-data'; +export * from './api-url'; +export * from './query-params'; +export * from './privilege'; +export * from './format-date'; +export * from './app-source'; diff --git a/src/base/infrastructure/constants/module-key/index.ts b/src/base/infrastructure/constants/module-key/index.ts new file mode 100644 index 0000000..d0e54b0 --- /dev/null +++ b/src/base/infrastructure/constants/module-key/index.ts @@ -0,0 +1,47 @@ +export * from './report-group.constant'; + +export const MODULE_KEY = { + DASHBOARD: 'DASHBOARD', + CALENDAR: 'CALENDAR', + BOOKING: 'BOOKING', + REFUND: 'REFUND', + RECONCILIATION: 'RECONCILIATION', + ITEM: { + INDEX: 'ITEM', + ITEM_ITEM_RATE: 'ITEM.ITEM_RATE', + ITEM_ITEM: 'ITEM.ITEM', + ITEM_ITEM_CATEGORY: 'ITEM.ITEM_CATEGORY', + }, + SEASON: { + INDEX: 'SEASON', + SEASON_TYPE: 'SEASON.SEASON_TYPE', + SEASON_PERIOD: 'SEASON.SEASON_PERIOD', + }, + USER: { + INDEX: 'USER', + USER_USER: 'USER.USER', + USER_USER_PRIVILEGE: 'USER.USER_PRIVILEGE', + }, + TENANT: 'TENANT', + CMS: { + INDEX: 'WEB_INFORMATION', + CMS_TERMS_AND_CONDITION: 'WEB_INFORMATION.TERMS_AND_CONDITION', + CMS_FAQ: 'WEB_INFORMATION.FAQ', + CMS_NEWS: 'WEB_INFORMATION.NEWS', + CMS_BANNER: 'WEB_INFORMATION.BANNER', + }, + SETTING: { + INDEX: 'SETTING', + SETTING_TAX: 'SETTING.TAX', + SETTING_VIP_CATEGORY: 'SETTING.VIP_CATEGORY', + SETTING_PAYMENT_METHOD: 'SETTING.PAYMENT_METHOD', + SETTING_GATE: 'SETTING.GATE', + SETTING_PROFIT_SHARE_FORMULA: 'SETTING.PROFIT_SHARE_FORMULA', + SETTING_SALES_PRICE_FORMULA: 'SETTING.SALES_PRICE_FORMULA', + SETTING_QR_SUPER_ADMIN: 'SETTING.QR_SUPER_ADMIN', + }, + REPORT: { INDEX: 'REPORT', REPORT_TRANSACTION: 'REPORT.TRANSACTION', REPORT_TENANT: 'REPORT.TENANT' }, + REPORT_TENANT: 'REPORT_TENANT', + DISCOUNT_CODE: 'DISCOUNT_CODE', + DOWNLOAD_POS_APP: 'DOWNLOAD_POS_APP', +}; diff --git a/src/base/infrastructure/constants/module-key/report-group.constant.ts b/src/base/infrastructure/constants/module-key/report-group.constant.ts new file mode 100644 index 0000000..523d707 --- /dev/null +++ b/src/base/infrastructure/constants/module-key/report-group.constant.ts @@ -0,0 +1,4 @@ +export enum REPORT_GROUP { + transaction_report = 'transaction_report', + tenant_report = 'tenant_report', +} diff --git a/src/base/infrastructure/constants/page-action/index.ts b/src/base/infrastructure/constants/page-action/index.ts new file mode 100644 index 0000000..4e2aa89 --- /dev/null +++ b/src/base/infrastructure/constants/page-action/index.ts @@ -0,0 +1,30 @@ +export enum PAGE_ACTION { + SAVE = 'create.save', + DETAIL = 'view', + + CREATE = 'create', + EDIT = 'edit', + DELETE = 'delete', + DUPLICATE = 'create.duplicate', + + PRINT = 'print', + PRINT_COPY = 'print_copy', + PRINT_PREVIEW = 'print_preview', + RESET_PRINT_COUNT = 'reset_print_count', + + APPROVAL_DATA = 'edit.approval_data', + CONFIRM_DATA = 'confirm.confirm_data', + CANCEL_DATA = 'cancel.cancel_data', + ACTIVATE_DATA = 'edit.activate_data', + DEACTIVATE_DATA = 'edit.deactivate_data', + + CONFIRM_TRANSACTION = 'confirm.confirm_transaction', + CANCEL_TRANSACTION = 'cancel.cancel_transaction', + ROLLBACK_TRANSACTION = 'confirm.rollback_transaction', + ON_HOLD_TRANSACTION = 'confirm.on_hold_transaction', + + OPEN_DRAWER_FILTER = 'view.open_drawer_filter', + + LOGS = 'log', + NOTES = 'note', +} diff --git a/src/base/infrastructure/constants/privilege/index.ts b/src/base/infrastructure/constants/privilege/index.ts new file mode 100644 index 0000000..b7eba5f --- /dev/null +++ b/src/base/infrastructure/constants/privilege/index.ts @@ -0,0 +1,8 @@ +export const defaultAppPrivilege = { + view: true, + create: true, + edit: true, + delete: true, + cancel: true, + confirm: true, +}; diff --git a/src/base/infrastructure/constants/query-params/index.ts b/src/base/infrastructure/constants/query-params/index.ts new file mode 100644 index 0000000..3670c3c --- /dev/null +++ b/src/base/infrastructure/constants/query-params/index.ts @@ -0,0 +1,16 @@ +export function makeArrayIds({ data, valueWhenNull }: { data: any; valueWhenNull?: string }): string[] { + const ids = []; + if (!data) { + if (valueWhenNull) return [valueWhenNull]; + else return []; + } else if (Array.isArray(data)) { + data?.forEach((item) => { + const id = item?.id ?? item?.uuid; + if (item?.id) ids.push(id); + }); + } else { + const id = data?.id ?? data?.uuid; + if (id) ids.push(id); + } + return ids; +} diff --git a/src/base/infrastructure/constants/request-action/index.ts b/src/base/infrastructure/constants/request-action/index.ts new file mode 100644 index 0000000..16a80c9 --- /dev/null +++ b/src/base/infrastructure/constants/request-action/index.ts @@ -0,0 +1,17 @@ +export const REQUEST_ACTION = { + VIEW: 'view', + CREATE: 'create', + EDIT: 'edit', + DELETE: 'delete', + + CONFIRM_DATA: 'edit', + CANCEL_DATA: 'edit', + ACTIVATE_DATA: 'edit', + DEACTIVATE_DATA: 'edit', + + CONFIRM_PROCESS_TRANSACTION: 'confirm', + ROLLBACK_PROCESS_TRANSACTION: 'reverse', + CANCEL_PROCESS_TRANSACTION: 'cancel', + + PRINT: 'print', +}; diff --git a/src/base/infrastructure/constants/request-info/index.ts b/src/base/infrastructure/constants/request-info/index.ts new file mode 100644 index 0000000..5962755 --- /dev/null +++ b/src/base/infrastructure/constants/request-info/index.ts @@ -0,0 +1,12 @@ +export const RequestInfoOptions = [ + { label: 'Create Data', value: 'Create Data' }, + { label: 'Edit Data', value: 'Edit Data' }, + { label: 'Edit Active', value: 'Edit Active' }, + { label: 'Edit Inactive', value: 'Edit Inactive' }, + { label: 'Edit Data & Status Active', value: 'Edit Data & Status Active' }, + { label: 'Edit Data & Status Inactive', value: 'Edit Data & Status Inactive' }, + { label: 'Delete Data', value: 'Delete Data' }, + { label: 'Process Transaction', value: 'Process Transaction' }, + { label: 'Cancel Transaction', value: 'Cancel Transaction' }, + { label: 'Rollback Transaction', value: 'Rollback Transaction' }, +]; diff --git a/src/base/infrastructure/constants/request-method/index.ts b/src/base/infrastructure/constants/request-method/index.ts new file mode 100644 index 0000000..6bf6487 --- /dev/null +++ b/src/base/infrastructure/constants/request-method/index.ts @@ -0,0 +1,43 @@ +import { RequestMethodEntity } from '../../../domain/entities'; + +export const DEFAULT_METHOD: RequestMethodEntity = { + getManyMethod: 'GET', + getOneMethod: 'GET', + createMethod: 'POST', + editMethod: 'PUT', + + deleteMethod: 'DELETE', + // batchDeleteMethod: 'DELETE', + batchDeleteMethod: 'PUT', + + activateMethod: 'PATCH', + // activateMethod: 'PUT', + batchActivateMethod: 'PUT', + + deactivateMethod: 'PATCH', + // deactivateMethod: 'PUT', + batchDeactivateMethod: 'PUT', + + confirmProcessDataMethod: 'PATCH', + // confirmProcessDataMethod: 'PUT', + batchConfirmProcessDataMethod: 'PUT', + + cancelProcessDataMethod: 'PATCH', + // cancelProcessDataMethod: 'PUT', + batchCancelProcessDataMethod: 'PUT', + + confirmProcessTransactionMethod: 'PATCH', + // confirmProcessTransactionMethod: 'PUT', + batchConfirmProcessTransactionMethod: 'PUT', + + cancelProcessTransactionMethod: 'PATCH', + // cancelProcessTransactionMethod: 'PUT', + batchCancelProcessTransactionMethod: 'PUT', + + rollbackProcessTransactionMethod: 'PATCH', + // rollbackProcessTransactionMethod: 'PUT', + batchRollbackProcessTransactionMethod: 'PUT', + + holdProcessTransactionMethod: 'PUT', + batchHoldProcessTransactionMethod: 'PUT', +}; diff --git a/src/base/infrastructure/constants/sidebar/index.ts b/src/base/infrastructure/constants/sidebar/index.ts new file mode 100644 index 0000000..79e14ad --- /dev/null +++ b/src/base/infrastructure/constants/sidebar/index.ts @@ -0,0 +1 @@ +export const sideConf = { width: 230, collapsedWidth: 75 }; diff --git a/src/base/infrastructure/constants/status-data/index.ts b/src/base/infrastructure/constants/status-data/index.ts new file mode 100644 index 0000000..2d6e3fe --- /dev/null +++ b/src/base/infrastructure/constants/status-data/index.ts @@ -0,0 +1,247 @@ +import { capitalizeEachWord } from '../../helpers'; + +export enum DATA_TYPE { + REQUESTED = 'requested', + ORIGINAL = 'original', +} +export enum STATUS_DATA { + DRAFT = 'draft', + ACTIVE = 'active', + INACTIVE = 'inactive', + REQUESTED = 'requested', + OPEN = 'open', + DECLINE = 'declined', + DELETED = 'deleted', + WAITING = 'waiting', + CANCEL = 'cancel', + DONE = 'done', + IN_PROCESS = 'in_process', + CLOSED = 'closed', + TODO = 'todo', + ON_HOLD = 'on_hold', + BLOCKED = 'blocked', + BLACKLIST = 'blacklist', + PROBLEM = 'problem', + POSTED = 'posted', + PAID = 'paid', + APPROVED = 'approved', + PENDING = 'pending', + REJECTED = 'rejected', + SETTLED = 'settled', + CONFIRMED = 'confirmed', + PROCESS_REFUND = 'proses refund', + PROCESS_REFUND_WAHANA = 'proses refund wahana', + REFUNDED = 'refunded', + PARTIAL_REFUND = 'partial refund', +} + +export enum STATUS_DATA_COLOR { + // DRAFT = '#4A6785', + // ACTIVE = '#00875a', + // INACTIVE = '#cf1322', + // REQUESTED = '#faad14', + // OPEN = '#0052cc', + // DECLINE = '#cf1322', + // DELETED = '#cf1322', + // WAITING = '#faad14', + // CANCEL = '#cf1322', + // DONE = '#00875a', + // IN_PROCESS = '#0052cc', + // CLOSED = '#cf1322', + // TODO = '#4A6785', + // ON_HOLD = '#4A6785', + // BLOCKED = '#cf1322', + // BLACKLIST = '#cf1322', + + DRAFT = '#95A5A6', + ACTIVE = '#3EBD93', + INACTIVE = '#E74C3C', + REQUESTED = '#F39C12', + OPEN = '#6F7CBA', + DECLINE = '#B71C1C', + DELETED = '#FF5252', + WAITING = '#6c5dd0', + CANCEL = '#9B59B6', + // CANCEL = '#FF5252', + // DONE = '#27AE60', + DONE = '#3EBD93', + IN_PROCESS = '#3498DB', + // CLOSED = '#8E44AD', + CLOSED = '#FF5252', + // TODO = '#95A5A6', + TODO = '#9B59B6', + ON_HOLD = '#607D8B', + BLOCKED = '#FF5722', + BLACKLIST = '#D32F2F', + PROBLEM = '#FF5722', + POSTED = '#3EBD93', + PAID = '#3EBD93', + APPROVED = '#3EBD93', + PENDING = '#d4940d', + REJECTED = '#ef4444', + SETTLED = '#5dadd0', + CONFIRMED = '#5dadd0', + PROCESS_REFUND = '#d7a29a', + REFUNDED = '#fe725e', +} + +export const STATUS_DATA_OPTIONS = [ + { + label: capitalizeEachWord(STATUS_DATA.DRAFT.split('_').join(' ')), + value: STATUS_DATA.DRAFT, + color: STATUS_DATA_COLOR.DRAFT, + }, + + { + label: capitalizeEachWord(STATUS_DATA.ON_HOLD.split('_').join(' ')), + value: STATUS_DATA.ON_HOLD, + color: STATUS_DATA_COLOR.ON_HOLD, + }, + + { + label: capitalizeEachWord(STATUS_DATA.OPEN.split('_').join(' ')), + value: STATUS_DATA.OPEN, + color: STATUS_DATA_COLOR.OPEN, + }, + + { + label: capitalizeEachWord(STATUS_DATA.TODO.split('_').join(' ')), + value: STATUS_DATA.TODO, + color: STATUS_DATA_COLOR.TODO, + }, + { + label: capitalizeEachWord(STATUS_DATA.IN_PROCESS.split('_').join(' ')), + value: STATUS_DATA.IN_PROCESS, + color: STATUS_DATA_COLOR.IN_PROCESS, + }, + { + label: capitalizeEachWord(STATUS_DATA.WAITING.split('_').join(' ')), + value: STATUS_DATA.WAITING, + color: STATUS_DATA_COLOR.WAITING, + }, + { + label: capitalizeEachWord(STATUS_DATA.REQUESTED.split('_').join(' ')), + value: STATUS_DATA.REQUESTED, + color: STATUS_DATA_COLOR.REQUESTED, + }, + { + label: capitalizeEachWord(STATUS_DATA.BLOCKED.split('_').join(' ')), + value: STATUS_DATA.BLOCKED, + color: STATUS_DATA_COLOR.BLOCKED, + }, + + { + label: capitalizeEachWord(STATUS_DATA.PROBLEM.split('_').join(' ')), + value: STATUS_DATA.PROBLEM, + color: STATUS_DATA_COLOR.PROBLEM, + }, + { + label: capitalizeEachWord(STATUS_DATA.CANCEL.split('_').join(' ')), + value: STATUS_DATA.CANCEL, + color: STATUS_DATA_COLOR.CANCEL, + }, + { + label: capitalizeEachWord(STATUS_DATA.CLOSED.split('_').join(' ')), + value: STATUS_DATA.CLOSED, + color: STATUS_DATA_COLOR.CLOSED, + }, + { + label: capitalizeEachWord(STATUS_DATA.DELETED.split('_').join(' ')), + value: STATUS_DATA.DELETED, + color: STATUS_DATA_COLOR.DELETED, + }, + + { + label: capitalizeEachWord(STATUS_DATA.INACTIVE.split('_').join(' ')), + value: STATUS_DATA.INACTIVE, + color: STATUS_DATA_COLOR.INACTIVE, + }, + + { + label: capitalizeEachWord(STATUS_DATA.BLACKLIST.split('_').join(' ')), + value: STATUS_DATA.BLACKLIST, + color: STATUS_DATA_COLOR.BLACKLIST, + }, + { + label: capitalizeEachWord(STATUS_DATA.DECLINE.split('_').join(' ')), + value: STATUS_DATA.DECLINE, + color: STATUS_DATA_COLOR.DECLINE, + }, + { + label: capitalizeEachWord(STATUS_DATA.APPROVED.split('_').join(' ')), + value: STATUS_DATA.APPROVED, + color: STATUS_DATA_COLOR.APPROVED, + }, + { + label: capitalizeEachWord(STATUS_DATA.ACTIVE.split('_').join(' ')), + value: STATUS_DATA.ACTIVE, + color: STATUS_DATA_COLOR.ACTIVE, + }, + { + label: capitalizeEachWord(STATUS_DATA.DONE.split('_').join(' ')), + value: STATUS_DATA.DONE, + color: STATUS_DATA_COLOR.DONE, + }, + { + label: capitalizeEachWord(STATUS_DATA.POSTED.split('_').join(' ')), + value: STATUS_DATA.POSTED, + color: STATUS_DATA_COLOR.POSTED, + }, + { + label: capitalizeEachWord(STATUS_DATA.PAID.split('_').join(' ')), + value: STATUS_DATA.PAID, + color: STATUS_DATA_COLOR.PAID, + }, + { + label: capitalizeEachWord(STATUS_DATA.PENDING.split('_').join(' ')), + value: STATUS_DATA.PENDING, + color: STATUS_DATA_COLOR.PENDING, + }, + { + label: capitalizeEachWord(STATUS_DATA.REJECTED.split('_').join(' ')), + value: STATUS_DATA.REJECTED, + color: STATUS_DATA_COLOR.REJECTED, + }, + { + label: capitalizeEachWord(STATUS_DATA.REJECTED.split('_').join(' ')), + value: STATUS_DATA.REJECTED, + color: STATUS_DATA_COLOR.REJECTED, + }, + { + label: capitalizeEachWord(STATUS_DATA.SETTLED.split('_').join(' ')), + value: STATUS_DATA.SETTLED, + color: STATUS_DATA_COLOR.SETTLED, + }, + { + label: capitalizeEachWord(STATUS_DATA.CONFIRMED.split('_').join(' ')), + value: STATUS_DATA.CONFIRMED, + color: STATUS_DATA_COLOR.CONFIRMED, + }, + { + label: capitalizeEachWord(STATUS_DATA.PROCESS_REFUND.split('_').join(' ')), + value: STATUS_DATA.PROCESS_REFUND, + color: STATUS_DATA_COLOR.PROCESS_REFUND, + }, + { + label: capitalizeEachWord(STATUS_DATA.PROCESS_REFUND_WAHANA.split('_').join(' ')), + value: STATUS_DATA.PROCESS_REFUND_WAHANA, + color: STATUS_DATA_COLOR.PROCESS_REFUND, + }, + { + label: capitalizeEachWord(STATUS_DATA.REFUNDED.split('_').join(' ')), + value: STATUS_DATA.REFUNDED, + color: STATUS_DATA_COLOR.REFUNDED, + }, + { + label: capitalizeEachWord(STATUS_DATA.PARTIAL_REFUND.split('_').join(' ')), + value: STATUS_DATA.PARTIAL_REFUND, + color: STATUS_DATA_COLOR.REFUNDED, + }, +]; + +export function makeColorStatus(status: STATUS_DATA): STATUS_DATA_COLOR | undefined { + const color = STATUS_DATA_OPTIONS.find( + (item) => item.value?.split('_').join('') === status?.split('_').join('').toLowerCase(), + ); + return color?.color; +} diff --git a/src/base/infrastructure/constants/user-role/index.ts b/src/base/infrastructure/constants/user-role/index.ts new file mode 100644 index 0000000..583ee85 --- /dev/null +++ b/src/base/infrastructure/constants/user-role/index.ts @@ -0,0 +1,12 @@ +export enum UserRole { + SUPERADMIN = 'superadmin', + STAFF = 'staff', + TENANT = 'tenant', + QUEUE_ADMIN = 'queue_admin', +} + +export const UserRoleOptions = [ + { value: UserRole.SUPERADMIN, label: 'Super Admin' }, + { value: UserRole.QUEUE_ADMIN, label: 'Admin Antrian' }, + { value: UserRole.STAFF, label: 'Staff' }, +]; diff --git a/src/base/infrastructure/constants/web-url/index.ts b/src/base/infrastructure/constants/web-url/index.ts new file mode 100644 index 0000000..c192f41 --- /dev/null +++ b/src/base/infrastructure/constants/web-url/index.ts @@ -0,0 +1,4 @@ +export const WEB_URL = { + ITEM: '/app/item', + ITEM_MASTER: '/app/item-master', +}; diff --git a/src/base/infrastructure/helpers/access-control/access-control.constant.ts b/src/base/infrastructure/helpers/access-control/access-control.constant.ts new file mode 100644 index 0000000..07f3d44 --- /dev/null +++ b/src/base/infrastructure/helpers/access-control/access-control.constant.ts @@ -0,0 +1,80 @@ +import { capitalizeEachWord } from '@pos/base'; + +export enum ACCESS_CONTROL_ROLE { + SYSTEM = 'System', + GLOBAL = 'Global', + ORGANIZATION = 'Organization', + CONTACT_LEVEL = 'Contact Level', + ACCESS_TO_CONTACT = 'Access to Contact', + SUPER_ADMIN = 'Super Admin', +} + +export enum ACCESS_TO_CONTACT_TYPE { + RESTRICTED = 'Restricted', + ADDITIONAL = 'Additional', +} + +export enum PRIVILEGE_ACTION { + VIEW = 'VIEW', + CREATE = 'CREATE', + EDIT = 'EDIT', + DELETE = 'DELETE', + CHANGE_STATUS = 'CHANGE_STATUS', + CONFIRM = 'CONFIRM', + VIEW_EXTERNAL_LINK = 'VIEW_EXTERNAL_LINK', + DOWNLOAD = 'DOWNLOAD', + CANCEL = 'CANCEL', +} + +export enum PRIVILEGE_CONDITION { + ORGANIZATION = 'ORGANIZATION', + DEPARTMENT = 'DEPARTMENT', + MINISTRY_POSITION = 'MINISTRY_POSITION', + TEAM = 'TEAM', + CARE_GROUP = 'CARE_GROUP', + TASK = 'TASK', + EVENT = 'EVENT', + ONLY_OWN = 'ONLY_OWN', +} + +export enum PRIVILEGE_CONDITION_VALUE { + OWN = 'OWN', + ALL = 'ALL', + WITH_CHILD = 'WITH_CHILD', + TRUE = 'TRUE', + FALSE = 'FALSE', + PIC = 'PIC', + COORDINATOR = 'COORDINATOR', +} + +export function generatePrivilegeValueOptions() { + const options = {}; + Object.values(PRIVILEGE_CONDITION_VALUE).forEach((el) => { + Object.assign(options, { + [`${el}`]: { + label: capitalizeEachWord(el.split('_').join(' ').toLowerCase()), + value: el, + }, + }); + }); + return options; +} + +export const AccessControlRoleOpt: any = { + [`${ACCESS_CONTROL_ROLE.SUPER_ADMIN}`]: { + label: 'Super Admin', + value: ACCESS_CONTROL_ROLE.SUPER_ADMIN, + }, + [`${ACCESS_CONTROL_ROLE.SYSTEM}`]: { + label: 'System Admin', + value: ACCESS_CONTROL_ROLE.SYSTEM, + }, + [`${ACCESS_CONTROL_ROLE.GLOBAL}`]: { + label: 'Global Officer', + value: ACCESS_CONTROL_ROLE.GLOBAL, + }, + [`${ACCESS_CONTROL_ROLE.ORGANIZATION}`]: { + label: 'Organization Officer', + value: ACCESS_CONTROL_ROLE.ORGANIZATION, + }, +}; diff --git a/src/base/infrastructure/helpers/access-control/index.ts b/src/base/infrastructure/helpers/access-control/index.ts new file mode 100644 index 0000000..c28bb9e --- /dev/null +++ b/src/base/infrastructure/helpers/access-control/index.ts @@ -0,0 +1,62 @@ +import { StoragePrivilege } from '@pos/base/data/local-data-services'; +import { omit } from 'lodash'; +export * from './access-control.constant'; + +export const DefaultAccessControl = { + view_index: false, + view_detail: false, + create: false, + update: false, + delete: false, + change_status: false, + confirm: false, + view_external_link: false, + download: false, +}; + +export const DefaultAccessControlTrue = { + view_index: true, + view_detail: true, + create: true, + update: true, + delete: true, + change_status: true, + confirm: true, + view_external_link: true, + download: true, +}; + +export enum ControlTypeEnum { + view_index = 'view_index', + view_detail = 'view_detail', + create = 'create', + update = 'update', + delete = 'delete', + change_status = 'change_status', + confirm = 'confirm', + view_external_link = 'view_external_link', + download = 'download', +} + +export type ControlType = { + view_index: boolean; + view_detail: boolean; + create: boolean; + update: boolean; + delete: boolean; + change_status: boolean; + confirm: boolean; + view_external_link: boolean; + download: boolean; +}; + +interface GetProps { + moduleKey: string; +} +export function getAccessControlByModule(props: GetProps): ControlType { + const { moduleKey } = props; + const list: any[] = StoragePrivilege.get() as any; + const control = list?.find((el: any) => el.module_key === moduleKey) ?? DefaultAccessControl; + const fixControl = omit(control, ['module_key']) as ControlType; + return fixControl; +} diff --git a/src/base/infrastructure/helpers/auth-handler/index.ts b/src/base/infrastructure/helpers/auth-handler/index.ts new file mode 100644 index 0000000..7db02e8 --- /dev/null +++ b/src/base/infrastructure/helpers/auth-handler/index.ts @@ -0,0 +1,41 @@ +import { StorageDefaultURL, StoragePrivilege, WEB_URL, encryptData } from '@pos/base'; +import { StorageAccessToken, StorageUserData, StorageActiveAccount } from '@pos/base'; + +export async function handleLogout(authParam?: string) { + // INDEXED-DB + await StorageUserData.delete(); //remove user data from indexed-db + await StorageAccessToken.delete(); //remove access token from local indexed-db + await StoragePrivilege.delete(); + + //LOCAL STORAGE + await StorageActiveAccount.delete(); // remove active account from local storage + await StorageDefaultURL.delete(); + + window.location.replace( + `/auth/login${authParam ? `?u=${encodeURIComponent(encryptData(JSON.stringify(authParam)))}` : ''}`, + ); +} + +export async function handleLogin(respLogin: any) { + await StorageAccessToken.delete(); + try { + // save user id to StorageActiveAccount on Local storage + const userID = respLogin?.id; // adjust key "id" with key that have userID value + await StorageActiveAccount.create({ value: userID }); + + // save access token to StorageAccessToken + const accessToken = respLogin?.token; + await StorageAccessToken.create('Bearer ' + accessToken); + + // save user data information to + const userData = respLogin; // adjustment with value user data + await StorageUserData.create(userData); + + // find web url module for first menu to access + await StorageDefaultURL.create({ value: WEB_URL.ITEM }); + + // save default url to local storage + } catch (error) { + console.error(error); + } +} diff --git a/src/base/infrastructure/helpers/encryption/encryption-key.ts b/src/base/infrastructure/helpers/encryption/encryption-key.ts new file mode 100644 index 0000000..eca9c8a --- /dev/null +++ b/src/base/infrastructure/helpers/encryption/encryption-key.ts @@ -0,0 +1 @@ +export const ENC_STORAGE_KEY = 'zkwqyo3RpNEh8un2CIAs'; //TODO change value from environment diff --git a/src/base/infrastructure/helpers/encryption/index.ts b/src/base/infrastructure/helpers/encryption/index.ts new file mode 100644 index 0000000..5193b28 --- /dev/null +++ b/src/base/infrastructure/helpers/encryption/index.ts @@ -0,0 +1,13 @@ +import { AES } from 'crypto-js'; +import enc from 'crypto-js/enc-utf8'; +import { ENC_STORAGE_KEY } from './encryption-key'; + +// Encryption function +export function encryptData(data: any) { + return AES.encrypt(data, ENC_STORAGE_KEY).toString(); +} + +// Decryption function +export function decryptData(encryptedData: any) { + return AES.decrypt(encryptedData, ENC_STORAGE_KEY).toString(enc); +} diff --git a/src/base/infrastructure/helpers/error-handlings/access-denied-error.ts b/src/base/infrastructure/helpers/error-handlings/access-denied-error.ts new file mode 100644 index 0000000..6019128 --- /dev/null +++ b/src/base/infrastructure/helpers/error-handlings/access-denied-error.ts @@ -0,0 +1,6 @@ +export class AccessDeniedError extends Error { + constructor() { + super('Denied access!'); + this.name = 'AccessDeniedError'; + } +} diff --git a/src/base/infrastructure/helpers/error-handlings/index.ts b/src/base/infrastructure/helpers/error-handlings/index.ts new file mode 100644 index 0000000..4013f7d --- /dev/null +++ b/src/base/infrastructure/helpers/error-handlings/index.ts @@ -0,0 +1,3 @@ +export * from './unexpected-error'; +export * from './access-denied-error'; +export * from './invalid-credentials-error'; diff --git a/src/base/infrastructure/helpers/error-handlings/invalid-credentials-error.ts b/src/base/infrastructure/helpers/error-handlings/invalid-credentials-error.ts new file mode 100644 index 0000000..ab3cb9d --- /dev/null +++ b/src/base/infrastructure/helpers/error-handlings/invalid-credentials-error.ts @@ -0,0 +1,6 @@ +export class InvalidCredentialsError extends Error { + constructor() { + super('Invalid credentials.'); + this.name = 'InvalidCredentialsError'; + } +} diff --git a/src/base/infrastructure/helpers/error-handlings/unexpected-error.ts b/src/base/infrastructure/helpers/error-handlings/unexpected-error.ts new file mode 100644 index 0000000..f85e459 --- /dev/null +++ b/src/base/infrastructure/helpers/error-handlings/unexpected-error.ts @@ -0,0 +1,25 @@ +export class UnexpectedError extends Error { + constructor() { + super('Something went wrong. Please try again later.'); + this.name = 'UnexpectedError'; + } +} + +export class HttpError extends Error { + public errorObject: any; + constructor(object: any) { + super('Something went wrong. Please try again later.'); + this.name = 'HttpError'; + this.errorObject = object; + } +} + +export class ErrorRequest extends Error { + constructor( + public data: T = null as any, + public message = 'Internal server error.', + public status = 500, + ) { + super(message); + } +} diff --git a/src/base/infrastructure/helpers/filter-menu/filter-menu.ts b/src/base/infrastructure/helpers/filter-menu/filter-menu.ts new file mode 100644 index 0000000..7779899 --- /dev/null +++ b/src/base/infrastructure/helpers/filter-menu/filter-menu.ts @@ -0,0 +1,21 @@ +import * as _ from 'lodash'; + +export function findMenuItemByPath(menu: any, targetTo: any) { + let result; + _.forEach(menu, (item): any => { + if (item.label && item.label.props && item.label.props.to === targetTo) { + result = item; + return false; // exit the loop + } + + if (item.children) { + const nestedResult = findMenuItemByPath(item.children, targetTo); + if (nestedResult) { + result = nestedResult; + return false; // exit the loop + } + } + }); + + return result || undefined; // return result or undefined explicitly +} diff --git a/src/base/infrastructure/helpers/filter-menu/index.ts b/src/base/infrastructure/helpers/filter-menu/index.ts new file mode 100644 index 0000000..902d8d5 --- /dev/null +++ b/src/base/infrastructure/helpers/filter-menu/index.ts @@ -0,0 +1 @@ +export * from './filter-menu'; diff --git a/src/base/infrastructure/helpers/formatter/currency.formatter.ts b/src/base/infrastructure/helpers/formatter/currency.formatter.ts new file mode 100644 index 0000000..92eacf0 --- /dev/null +++ b/src/base/infrastructure/helpers/formatter/currency.formatter.ts @@ -0,0 +1,18 @@ +import { CustomFormatConfig } from '@formatjs/intl'; + +interface CurrencyProps { + currencyOptions?: CustomFormatConfig; + value?: number | bigint; +} + +export function currencyFormatter(props: CurrencyProps) { + const { currencyOptions, value } = props; + if (!value) return 'Rp 0,00'; + return new Intl.NumberFormat('id', { + style: 'currency', + currency: 'IDR', + minimumFractionDigits: 0, + currencyDisplay: 'narrowSymbol', + ...currencyOptions, + }).format(value); +} diff --git a/src/base/infrastructure/helpers/formatter/index.ts b/src/base/infrastructure/helpers/formatter/index.ts new file mode 100644 index 0000000..57f5bff --- /dev/null +++ b/src/base/infrastructure/helpers/formatter/index.ts @@ -0,0 +1,2 @@ +export * from './string.formatter'; +export * from './currency.formatter'; diff --git a/src/base/infrastructure/helpers/formatter/string.formatter.ts b/src/base/infrastructure/helpers/formatter/string.formatter.ts new file mode 100644 index 0000000..85291cd --- /dev/null +++ b/src/base/infrastructure/helpers/formatter/string.formatter.ts @@ -0,0 +1,54 @@ +interface CurrencyEntity { + value: number; + currency?: ' IDR' | 'EUR' | 'JPY'; +} +export interface IStringFormatter { + capitalizeFistWord(string: string): string; + capitalizeEachWord(string: string): string; + stringLimiter(string: string, limit: number): string; + upperCase(string: string): string; + lowerCase(string: string): string; + currency(payload: CurrencyEntity): string; +} + +export class BaseStringFormatter implements IStringFormatter { + capitalizeFistWord(string: string): string { + if (typeof string !== 'string') return ''; + return string.charAt(0).toUpperCase() + string.slice(1); + } + + capitalizeEachWord(string: string): string { + if (typeof string !== 'string') return ''; + const newStringSplit = string.split(' '); + const newString = newStringSplit.map((item) => { + return item.charAt(0).toUpperCase() + item.slice(1); + }); + return newString.join(' '); + } + + stringLimiter(string: string, limit: number): string { + if (!limit || !string) return string; + return string.length > limit ? `${string.substring(0, limit)} ...` : string; + } + + upperCase(string: string): string { + if (!string) return ''; + return string.toUpperCase(); + } + lowerCase(string: string): string { + if (!string) return ''; + return string.toLowerCase(); + } + currency(payload: CurrencyEntity): any { + const { value, currency = 'IDR' } = payload; + if (!value) return ''; + return new Intl.NumberFormat('en-IN', { + style: 'currency', + currency, + }).format(value); + } +} + +const stringFormatter = new BaseStringFormatter(); +export const { capitalizeFistWord, capitalizeEachWord, stringLimiter, upperCase, lowerCase, currency } = + stringFormatter; diff --git a/src/base/infrastructure/helpers/get-data-pagination/index.ts b/src/base/infrastructure/helpers/get-data-pagination/index.ts new file mode 100644 index 0000000..f7a7686 --- /dev/null +++ b/src/base/infrastructure/helpers/get-data-pagination/index.ts @@ -0,0 +1,76 @@ +import axios, { AxiosRequestConfig } from 'axios'; + +async function getData(params: any, url: string, axiosParams?: AxiosRequestConfig) { + try { + const response = await axios({ + url: url, + method: 'get', + params: { + limit: 10, + ...params, + }, + ...(axiosParams ? axiosParams : {}), + }); + return response; + } catch (error) { + console.log(error); + } +} + +interface Result { + currentPage: number; + data: any[]; +} + +async function manipulatedGenerateDataPagination( + url: string, + params: any, + prevData: any[] = [], + currentPage = 1, + axiosParams?: AxiosRequestConfig, +): Promise { + try { + const response = await getData({ ...params, page: currentPage }, url, axiosParams); + + const data = response?.data?.data ?? []; + const meta = response?.data?.meta; + + if (meta.totalPages <= currentPage) { + return { + currentPage: currentPage, + data: [...prevData, ...data], + }; + } else { + const response2 = await manipulatedGenerateDataPagination( + url, + params, + [...prevData, ...data], + currentPage + 1, + axiosParams, + ); + const data2: any[] = response2?.data ?? []; + const newCurrentPage: number = response2?.currentPage; + return { + currentPage: newCurrentPage, + data: data2, + }; + } + } catch (error) { + return { + currentPage: 1, + data: prevData, + }; + } +} + +interface GenerateDataPagination { + url: string; + params: any; + axiosParams?: AxiosRequestConfig; +} + +export async function generateDataPagination(props: GenerateDataPagination): Promise { + const { url, params = {}, axiosParams } = props; + const data = await manipulatedGenerateDataPagination(url, params, [], 1, axiosParams); + return data; +} diff --git a/src/base/infrastructure/helpers/index.ts b/src/base/infrastructure/helpers/index.ts new file mode 100644 index 0000000..ec67889 --- /dev/null +++ b/src/base/infrastructure/helpers/index.ts @@ -0,0 +1,12 @@ +export * from './auth-handler'; +export * from './encryption'; +export * from './error-handlings'; +export * from './filter-menu'; +export * from './notifications'; +export * from './formatter'; +export * from './timeout'; +export * from './localstorage-effect'; +export * from './access-control'; +export * from './use-query-param'; +export * from './get-data-pagination'; +export * from './validate-formula'; diff --git a/src/base/infrastructure/helpers/localstorage-effect/index.ts b/src/base/infrastructure/helpers/localstorage-effect/index.ts new file mode 100644 index 0000000..55e9be2 --- /dev/null +++ b/src/base/infrastructure/helpers/localstorage-effect/index.ts @@ -0,0 +1,12 @@ +export const localStorageEffect = + (key: string) => + ({ setSelf, onSet }: any) => { + const savedValue = localStorage.getItem(key); + if (savedValue != null) { + setSelf(JSON.parse(savedValue)); + } + + onSet((newValue: any, _: any, isReset: any) => { + isReset ? localStorage.removeItem(key) : localStorage.setItem(key, JSON.stringify(newValue)); + }); + }; diff --git a/src/base/infrastructure/helpers/notifications/index.tsx b/src/base/infrastructure/helpers/notifications/index.tsx new file mode 100644 index 0000000..642a6ff --- /dev/null +++ b/src/base/infrastructure/helpers/notifications/index.tsx @@ -0,0 +1,53 @@ +import { notification } from 'antd'; +import { ReactNode } from 'react'; + +notification.config({ + duration: 1.5, +}); + +export function notificationSuccess(content?: ReactNode | any): void { + notification.success({ + message: 'Success', + description: content, + className: 'no-print', + }); +} + +export function notificationError(content?: ReactNode | any): void { + notification.error({ + message: 'Error', + description: content, + className: 'no-print', + }); +} + +export function notificationWarning(content?: ReactNode | any): void { + notification.warning({ + message: 'Warning', + description: content, + className: 'no-print', + }); +} + +export function notificationInfo(content?: ReactNode | any): void { + notification.info({ + message: 'Info', + description: content, + className: 'no-print', + }); +} + +interface MultiNotificationParams { + success?: string[]; + failed?: string[]; + warning?: string[]; + info?: string[]; +} + +export function multiNotification(message: MultiNotificationParams) { + const { success = [], failed = [], warning = [], info = [] } = message; + success.forEach((item) => notificationSuccess(item)); + failed.forEach((item) => notificationError(item)); + warning.forEach((item) => notificationWarning(item)); + info.forEach((item) => notificationInfo(item)); +} diff --git a/src/base/infrastructure/helpers/timeout/index.ts b/src/base/infrastructure/helpers/timeout/index.ts new file mode 100644 index 0000000..da11d19 --- /dev/null +++ b/src/base/infrastructure/helpers/timeout/index.ts @@ -0,0 +1,3 @@ +export function timeout(ms: number) { + return new Promise((resolve) => setTimeout(resolve, ms)); +} diff --git a/src/base/infrastructure/helpers/use-query-param/index.tsx b/src/base/infrastructure/helpers/use-query-param/index.tsx new file mode 100644 index 0000000..2e67a96 --- /dev/null +++ b/src/base/infrastructure/helpers/use-query-param/index.tsx @@ -0,0 +1,11 @@ +// A custom hook that builds on useLocation to parse + +import React from 'react'; +import { useLocation } from 'react-router-dom'; + +// the query string for you. +export function useQueryParam() { + const { search } = useLocation(); + + return React.useMemo(() => new URLSearchParams(search), [search]); +} diff --git a/src/base/infrastructure/helpers/validate-formula/index.ts b/src/base/infrastructure/helpers/validate-formula/index.ts new file mode 100644 index 0000000..71c3a11 --- /dev/null +++ b/src/base/infrastructure/helpers/validate-formula/index.ts @@ -0,0 +1,14 @@ +// Fungsi untuk mengecek apakah suatu string merupakan angka +function isNumeric(value: any) { + return !isNaN(value - parseFloat(value)); +} + +// Fungsi untuk memvalidasi formula number berderet +export function validateFormula(formula: any) { + for (let i = 0; i < formula.length - 1; i++) { + if (isNumeric(formula[i]?.name) && isNumeric(formula[i + 1]?.name)) { + return false; // Formula tidak valid + } + } + return true; // Formula valid +} diff --git a/src/base/presentation/assets/fonts/Paytone_One/OFL.txt b/src/base/presentation/assets/fonts/Paytone_One/OFL.txt new file mode 100644 index 0000000..ab151ff --- /dev/null +++ b/src/base/presentation/assets/fonts/Paytone_One/OFL.txt @@ -0,0 +1,94 @@ +Copyright 2011 The Paytone Project Authors (https://github.com/googlefonts/paytoneFont), +with Reserved Font Names "Paytone" and "Paytone One". + +This Font Software is licensed under the SIL Open Font License, Version 1.1. +This license is copied below, and is also available with a FAQ at: +https://openfontlicense.org + + +----------------------------------------------------------- +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +----------------------------------------------------------- + +PREAMBLE +The goals of the Open Font License (OFL) are to stimulate worldwide +development of collaborative font projects, to support the font creation +efforts of academic and linguistic communities, and to provide a free and +open framework in which fonts may be shared and improved in partnership +with others. + +The OFL allows the licensed fonts to be used, studied, modified and +redistributed freely as long as they are not sold by themselves. The +fonts, including any derivative works, can be bundled, embedded, +redistributed and/or sold with any software provided that any reserved +names are not used by derivative works. The fonts and derivatives, +however, cannot be released under any other type of license. The +requirement for fonts to remain under this license does not apply +to any document created using the fonts or their derivatives. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this license and clearly marked as such. This may +include source files, build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the +copyright statement(s). + +"Original Version" refers to the collection of Font Software components as +distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, deleting, +or substituting -- in part or in whole -- any of the components of the +Original Version, by changing formats or by porting the Font Software to a +new environment. + +"Author" refers to any designer, engineer, programmer, technical +writer or other person who contributed to the Font Software. + +PERMISSION & CONDITIONS +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Font Software, to use, study, copy, merge, embed, modify, +redistribute, and sell modified and unmodified copies of the Font +Software, subject to the following conditions: + +1) Neither the Font Software nor any of its individual components, +in Original or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, +redistributed and/or sold with any software, provided that each copy +contains the above copyright notice and this license. These can be +included either as stand-alone text files, human-readable headers or +in the appropriate machine-readable metadata fields within text or +binary files as long as those fields can be easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font +Name(s) unless explicit written permission is granted by the corresponding +Copyright Holder. This restriction only applies to the primary font name as +presented to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font +Software shall not be used to promote, endorse or advertise any +Modified Version, except to acknowledge the contribution(s) of the +Copyright Holder(s) and the Author(s) or with their explicit written +permission. + +5) The Font Software, modified or unmodified, in part or in whole, +must be distributed entirely under this license, and must not be +distributed under any other license. The requirement for fonts to +remain under this license does not apply to any document created +using the Font Software. + +TERMINATION +This license becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM +OTHER DEALINGS IN THE FONT SOFTWARE. diff --git a/src/base/presentation/assets/fonts/Paytone_One/PaytoneOne-Regular.ttf b/src/base/presentation/assets/fonts/Paytone_One/PaytoneOne-Regular.ttf new file mode 100644 index 0000000..29cccb5 Binary files /dev/null and b/src/base/presentation/assets/fonts/Paytone_One/PaytoneOne-Regular.ttf differ diff --git a/src/base/presentation/assets/fonts/Urbanist/OFL.txt b/src/base/presentation/assets/fonts/Urbanist/OFL.txt new file mode 100644 index 0000000..d96caaf --- /dev/null +++ b/src/base/presentation/assets/fonts/Urbanist/OFL.txt @@ -0,0 +1,93 @@ +Copyright 2021 The Urbanist Project Authors (https://github.com/coreyhu/Urbanist) + +This Font Software is licensed under the SIL Open Font License, Version 1.1. +This license is copied below, and is also available with a FAQ at: +https://openfontlicense.org + + +----------------------------------------------------------- +SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007 +----------------------------------------------------------- + +PREAMBLE +The goals of the Open Font License (OFL) are to stimulate worldwide +development of collaborative font projects, to support the font creation +efforts of academic and linguistic communities, and to provide a free and +open framework in which fonts may be shared and improved in partnership +with others. + +The OFL allows the licensed fonts to be used, studied, modified and +redistributed freely as long as they are not sold by themselves. The +fonts, including any derivative works, can be bundled, embedded, +redistributed and/or sold with any software provided that any reserved +names are not used by derivative works. The fonts and derivatives, +however, cannot be released under any other type of license. The +requirement for fonts to remain under this license does not apply +to any document created using the fonts or their derivatives. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this license and clearly marked as such. This may +include source files, build scripts and documentation. + +"Reserved Font Name" refers to any names specified as such after the +copyright statement(s). + +"Original Version" refers to the collection of Font Software components as +distributed by the Copyright Holder(s). + +"Modified Version" refers to any derivative made by adding to, deleting, +or substituting -- in part or in whole -- any of the components of the +Original Version, by changing formats or by porting the Font Software to a +new environment. + +"Author" refers to any designer, engineer, programmer, technical +writer or other person who contributed to the Font Software. + +PERMISSION & CONDITIONS +Permission is hereby granted, free of charge, to any person obtaining +a copy of the Font Software, to use, study, copy, merge, embed, modify, +redistribute, and sell modified and unmodified copies of the Font +Software, subject to the following conditions: + +1) Neither the Font Software nor any of its individual components, +in Original or Modified Versions, may be sold by itself. + +2) Original or Modified Versions of the Font Software may be bundled, +redistributed and/or sold with any software, provided that each copy +contains the above copyright notice and this license. These can be +included either as stand-alone text files, human-readable headers or +in the appropriate machine-readable metadata fields within text or +binary files as long as those fields can be easily viewed by the user. + +3) No Modified Version of the Font Software may use the Reserved Font +Name(s) unless explicit written permission is granted by the corresponding +Copyright Holder. This restriction only applies to the primary font name as +presented to the users. + +4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font +Software shall not be used to promote, endorse or advertise any +Modified Version, except to acknowledge the contribution(s) of the +Copyright Holder(s) and the Author(s) or with their explicit written +permission. + +5) The Font Software, modified or unmodified, in part or in whole, +must be distributed entirely under this license, and must not be +distributed under any other license. The requirement for fonts to +remain under this license does not apply to any document created +using the Font Software. + +TERMINATION +This license becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT +OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM +OTHER DEALINGS IN THE FONT SOFTWARE. diff --git a/src/base/presentation/assets/fonts/Urbanist/README.txt b/src/base/presentation/assets/fonts/Urbanist/README.txt new file mode 100644 index 0000000..907b200 --- /dev/null +++ b/src/base/presentation/assets/fonts/Urbanist/README.txt @@ -0,0 +1,81 @@ +Urbanist Variable Font +====================== + +This download contains Urbanist as both variable fonts and static fonts. + +Urbanist is a variable font with this axis: + wght + +This means all the styles are contained in these files: + Urbanist/Urbanist-VariableFont_wght.ttf + Urbanist/Urbanist-Italic-VariableFont_wght.ttf + +If your app fully supports variable fonts, you can now pick intermediate styles +that aren’t available as static fonts. Not all apps support variable fonts, and +in those cases you can use the static font files for Urbanist: + Urbanist/static/Urbanist-Thin.ttf + Urbanist/static/Urbanist-ExtraLight.ttf + Urbanist/static/Urbanist-Light.ttf + Urbanist/static/Urbanist-Regular.ttf + Urbanist/static/Urbanist-Medium.ttf + Urbanist/static/Urbanist-SemiBold.ttf + Urbanist/static/Urbanist-Bold.ttf + Urbanist/static/Urbanist-ExtraBold.ttf + Urbanist/static/Urbanist-Black.ttf + Urbanist/static/Urbanist-ThinItalic.ttf + Urbanist/static/Urbanist-ExtraLightItalic.ttf + Urbanist/static/Urbanist-LightItalic.ttf + Urbanist/static/Urbanist-Italic.ttf + Urbanist/static/Urbanist-MediumItalic.ttf + Urbanist/static/Urbanist-SemiBoldItalic.ttf + Urbanist/static/Urbanist-BoldItalic.ttf + Urbanist/static/Urbanist-ExtraBoldItalic.ttf + Urbanist/static/Urbanist-BlackItalic.ttf + +Get started +----------- + +1. Install the font files you want to use + +2. Use your app's font picker to view the font family and all the +available styles + +Learn more about variable fonts +------------------------------- + + https://developers.google.com/web/fundamentals/design-and-ux/typography/variable-fonts + https://variablefonts.typenetwork.com + https://medium.com/variable-fonts + +In desktop apps + + https://theblog.adobe.com/can-variable-fonts-illustrator-cc + https://helpx.adobe.com/nz/photoshop/using/fonts.html#variable_fonts + +Online + + https://developers.google.com/fonts/docs/getting_started + https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Fonts/Variable_Fonts_Guide + https://developer.microsoft.com/en-us/microsoft-edge/testdrive/demos/variable-fonts + +Installing fonts + + MacOS: https://support.apple.com/en-us/HT201749 + Linux: https://www.google.com/search?q=how+to+install+a+font+on+gnu%2Blinux + Windows: https://support.microsoft.com/en-us/help/314960/how-to-install-or-remove-a-font-in-windows + +Android Apps + + https://developers.google.com/fonts/docs/android + https://developer.android.com/guide/topics/ui/look-and-feel/downloadable-fonts + +License +------- +Please read the full license text (OFL.txt) to understand the permissions, +restrictions and requirements for usage, redistribution, and modification. + +You can use them in your products & projects – print or digital, +commercial or otherwise. + +This isn't legal advice, please consider consulting a lawyer and see the full +license for all details. diff --git a/src/base/presentation/assets/fonts/Urbanist/Urbanist-Italic-VariableFont_wght.ttf b/src/base/presentation/assets/fonts/Urbanist/Urbanist-Italic-VariableFont_wght.ttf new file mode 100644 index 0000000..8aa8270 Binary files /dev/null and b/src/base/presentation/assets/fonts/Urbanist/Urbanist-Italic-VariableFont_wght.ttf differ diff --git a/src/base/presentation/assets/fonts/Urbanist/Urbanist-VariableFont_wght.ttf b/src/base/presentation/assets/fonts/Urbanist/Urbanist-VariableFont_wght.ttf new file mode 100644 index 0000000..eda2a96 Binary files /dev/null and b/src/base/presentation/assets/fonts/Urbanist/Urbanist-VariableFont_wght.ttf differ diff --git a/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-Black.ttf b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-Black.ttf new file mode 100644 index 0000000..e1ec32b Binary files /dev/null and b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-Black.ttf differ diff --git a/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-BlackItalic.ttf b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-BlackItalic.ttf new file mode 100644 index 0000000..85323c9 Binary files /dev/null and b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-BlackItalic.ttf differ diff --git a/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-Bold.ttf b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-Bold.ttf new file mode 100644 index 0000000..330e84f Binary files /dev/null and b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-Bold.ttf differ diff --git a/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-BoldItalic.ttf b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-BoldItalic.ttf new file mode 100644 index 0000000..08d47a8 Binary files /dev/null and b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-BoldItalic.ttf differ diff --git a/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-ExtraBold.ttf b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-ExtraBold.ttf new file mode 100644 index 0000000..7971b6d Binary files /dev/null and b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-ExtraBold.ttf differ diff --git a/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-ExtraBoldItalic.ttf b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-ExtraBoldItalic.ttf new file mode 100644 index 0000000..050297e Binary files /dev/null and b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-ExtraBoldItalic.ttf differ diff --git a/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-ExtraLight.ttf b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-ExtraLight.ttf new file mode 100644 index 0000000..a20a0bf Binary files /dev/null and b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-ExtraLight.ttf differ diff --git a/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-ExtraLightItalic.ttf b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-ExtraLightItalic.ttf new file mode 100644 index 0000000..6896847 Binary files /dev/null and b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-ExtraLightItalic.ttf differ diff --git a/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-Italic.ttf b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-Italic.ttf new file mode 100644 index 0000000..79688a6 Binary files /dev/null and b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-Italic.ttf differ diff --git a/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-Light.ttf b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-Light.ttf new file mode 100644 index 0000000..5903400 Binary files /dev/null and b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-Light.ttf differ diff --git a/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-LightItalic.ttf b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-LightItalic.ttf new file mode 100644 index 0000000..1a455ce Binary files /dev/null and b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-LightItalic.ttf differ diff --git a/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-Medium.ttf b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-Medium.ttf new file mode 100644 index 0000000..e9a6dbb Binary files /dev/null and b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-Medium.ttf differ diff --git a/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-MediumItalic.ttf b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-MediumItalic.ttf new file mode 100644 index 0000000..44a9c89 Binary files /dev/null and b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-MediumItalic.ttf differ diff --git a/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-Regular.ttf b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-Regular.ttf new file mode 100644 index 0000000..2a794b2 Binary files /dev/null and b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-Regular.ttf differ diff --git a/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-SemiBold.ttf b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-SemiBold.ttf new file mode 100644 index 0000000..6d393d1 Binary files /dev/null and b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-SemiBold.ttf differ diff --git a/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-SemiBoldItalic.ttf b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-SemiBoldItalic.ttf new file mode 100644 index 0000000..327aa04 Binary files /dev/null and b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-SemiBoldItalic.ttf differ diff --git a/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-Thin.ttf b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-Thin.ttf new file mode 100644 index 0000000..9e27216 Binary files /dev/null and b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-Thin.ttf differ diff --git a/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-ThinItalic.ttf b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-ThinItalic.ttf new file mode 100644 index 0000000..5cf054f Binary files /dev/null and b/src/base/presentation/assets/fonts/Urbanist/static/Urbanist-ThinItalic.ttf differ diff --git a/src/base/presentation/assets/fonts/fonts.less b/src/base/presentation/assets/fonts/fonts.less new file mode 100644 index 0000000..ca8eaae --- /dev/null +++ b/src/base/presentation/assets/fonts/fonts.less @@ -0,0 +1,34 @@ +@font-face { + font-family: 'Paytone One'; + src: url('./Paytone_One/PaytoneOne-Regular.ttf') format('truetype'); + font-weight: normal; + font-style: normal; +} + +@font-face { + font-family: 'Urbanist'; + src: url('./Urbanist/static/Urbanist-Regular.ttf') format('truetype'); + font-weight: normal; + font-style: normal; +} + +@font-face { + font-family: 'Urbanist'; + src: url('./Urbanist/static/Urbanist-Bold.ttf') format('truetype'); + font-weight: bold; + font-style: normal; +} + +@font-face { + font-family: 'Urbanist'; + src: url('./Urbanist/static/Urbanist-Italic.ttf') format('truetype'); + font-weight: normal; + font-style: italic; +} + +@font-face { + font-family: 'Urbanist'; + src: url('./Urbanist/static/Urbanist-BoldItalic.ttf') format('truetype'); + font-weight: bold; + font-style: italic; +} diff --git a/src/base/presentation/assets/images/404.svg b/src/base/presentation/assets/images/404.svg new file mode 100644 index 0000000..fb9902b --- /dev/null +++ b/src/base/presentation/assets/images/404.svg @@ -0,0 +1,24 @@ + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/base/presentation/assets/images/coming-soon.jpg b/src/base/presentation/assets/images/coming-soon.jpg new file mode 100644 index 0000000..e76beda Binary files /dev/null and b/src/base/presentation/assets/images/coming-soon.jpg differ diff --git a/src/base/presentation/assets/images/linux-logo.png b/src/base/presentation/assets/images/linux-logo.png new file mode 100644 index 0000000..bda094c Binary files /dev/null and b/src/base/presentation/assets/images/linux-logo.png differ diff --git a/src/base/presentation/assets/images/login-bg.png b/src/base/presentation/assets/images/login-bg.png new file mode 100644 index 0000000..416cd4e Binary files /dev/null and b/src/base/presentation/assets/images/login-bg.png differ diff --git a/src/base/presentation/assets/images/no-data.png b/src/base/presentation/assets/images/no-data.png new file mode 100644 index 0000000..306a785 Binary files /dev/null and b/src/base/presentation/assets/images/no-data.png differ diff --git a/src/base/presentation/assets/images/search-icon.png b/src/base/presentation/assets/images/search-icon.png new file mode 100644 index 0000000..fe14d24 Binary files /dev/null and b/src/base/presentation/assets/images/search-icon.png differ diff --git a/src/base/presentation/assets/images/we-logo.png b/src/base/presentation/assets/images/we-logo.png new file mode 100644 index 0000000..bcd0149 Binary files /dev/null and b/src/base/presentation/assets/images/we-logo.png differ diff --git a/src/base/presentation/assets/images/we-logo.ts b/src/base/presentation/assets/images/we-logo.ts new file mode 100644 index 0000000..1e81b47 --- /dev/null +++ b/src/base/presentation/assets/images/we-logo.ts @@ -0,0 +1,4 @@ +const logo = + 'iVBORw0KGgoAAAANSUhEUgAACJ4AAAQWCAYAAAEI7dAOAAAACXBIWXMAAC4jAAAuIwF4pT92AAAgAElEQVR4nOy9CbitZ1UmuP55z+MZ75CbBIgEkUwk9zIlpLQUERFRecoCp5JS+6nWsm2eUtoRLVQ0TVtl2WKrJU3ZimULlFqt4gABDEmAJJQgGDLd8Yz77Hn6x37e9X3f3v8ezskdzr33DHvluU/O2fP+z/7f/a53vWstLYoiupSo3nfqjcUHH/7TS7rTLGZxCdH50pvfkLr1Q38+O2b7L54XUGr3ndr2Bn4UURgR2brmFx582Jq4wSxm8TzRe+p7t/18xSPxwvdrExfOYs/FtoACIOmHETn6xf8d3Sj6y4VPPPKNE1fMYhZj0f3K2+qaZuYmrniemAHL3o6pgAIwccOI3IgoY1zc368bRISb2rpGhQcfnv3RZ7FtXCwr2S5moLJ3Qx9/ZSuvOcl/bAADwATAMh64rBWMXq5JMKHnSZNmcbjjSsGEdukxZnF1YoShAAiCKKJuOJ2ZAEPGL8btDW14IcAGwNKNIlr+xCOTDzKLQxu7DQQzprL3YsBQFKsAOGzHTOIRTAEToiFLSWqzv/UshtF44t5Tu304Zkxl78VEyqPCniLGKnYC9mFI8Akkw5kGQLPUZxYq7MzNn54djIMfDCiVe09yRUdFw98ZB5IjKY5gKjSJP7OYxVWP7j9959nZUd47wYACpmHGQCJnDn/2YxpLN5gEGhAZ3H+8WKR+nbGUWVzN1EQznGMTF87iusUg5RmkMzGmAtaigAZYkpQ3in86cEkniGhcMtHGbjeLWczi4AcDiqt0EPl/VRKOm9ri1Z04dkBrSRka2ZpGKm3C/Wt+NMuCZjGLQxYmSR3ENohBoRdFXOWJV3AAFMCYkKaXk8FQUPWx5VXx27hTjHOzmMUsDmaY4+9KQUG8HKyYSrANOKRkmRlsBQBix+5rz8rHs5jFoQlOeeKMYggek4cgDjLRmEaiyszjANLdBoRmMYtZHLwYiLJgGB2JIkhxFMb42wACKj7j3KMXE3Sho7CQO2Mos5jFoQkGlJ5MV1ISReJirLkNIDhTLHEJXRsIukldU6D09MQNZzGLWRzI0CUQfISkuHqxMW65V6HSJ8VwCg8+/MKJG83iUMXV7LmZ9fPsrWBAKTz48LeSFFfjMc1OfzHRvcz7zWIWs9jfEU9cbkSFJk5Sno+wIL2BxqK0EwVASZkyzeaizELF1WASM3ay92IAKIUHHz4dN6eRrNwokOhPYR1Ib6CxJFSFJ6a9zMBkFuPhtZ/91okLZ3GgYkRaBQjE0x4jNjTJkeAyDVhUNP2B4/b7Jq6cxaGP7G0PfiTy21/ejeMwYyd7M7YdARn/XYHItPmy7SCitDFjJrO4+Gg8ce8Ndubm05dzyEKv/rnUrR9++cQVs9gTMRVQVMSBBRUgsBfoJpiFkoyBiJrkNgOTWVxKXGoX8oyV7P3YEVBUTBtBADFWelR+t/Dgw2+fuNMsZnGR0f7iNz9oOOV7p906ivxG8kW/n5+4YhZ7Mi550dcsZjGLWWwXU/yus5jFLGZxeTEDlFnMYha7FjNAmcUsZrFrMTEPZRZXFo333Lm9KNXziCyDyNAfzP34Y6+duH4Ws9jncdGibO2+U48T0e3xy2Zl4mE03nNnjYhENcINiMKQKLHD/niAS8L6D7kff+xHJ647hNF84r63W5mbfjv+zv3O2f+Uednf/vBhPi4PPHT/x7eq2ftKxebEdSp83/j7n7j3b149ccV1iB0BpXLvqZqhUR7NfskppjblP0EP0MIh3hI4wUoEWEzcjoEGx9sZJYa5H3/s0B67i/WieK1n/3X29gd/Z+KKAxAPPHR/gYiql/pO6o005XNtareTZNseWZY/cZt3vPJj1/SztS2gTPOeKACJZCMgnLN9+X8Vh421TIAJAs5iPyCyxzJKLxApj4q+T2TqDDK5n/z8oTpul7ta46CY2x546P7I900yzUkQUFGtZahYaI1c1u06lEz2qdezKZFwiSKNvMAgz7MolewObhcEOhlGOPFYVxtgJgBl896TzxqadmMviNgNC/ahxwYtxYdXx+fHRnIeLUCn/InDASpTwcQPBUjsFEEIHUXcoOsRJQWbOSxM5Ur39OxXUAGItFopymQ6zCo0iiiV7g2YBkJd3+0mKJns0dZWjrK5DgOHZXkjjxcGOoWRRqYZTDwXsSlQJ00bgop6TM8zmc1cDXAZX5b+O60g+n705jzfMymn7LQF6nQImErjXS97khLmi0YujIHDIMZZCZFIe6YNqAqjUu6dj18y9d1PsVtLv/YLqDzw0P3QHaE/Ur9vk+O4E7cZZxOITifB/0+leoPLfN/g27Y7Cf4IlUtN2qpmaVxfabWSlMkItlKrZ6iQbw3uD/Dp9y1ynCE47SawjHyVBlH0/ZkYmGy3AiOQYIK5sgpM0OsTH6w0LWU6UDEOJohxMEHEwSSQHxoFJpOd21sT9z9AsZsbBPf6ovRf/sTXfQqMRIEJAmCC1IMkW1ABMAETiQeApNOx5W0d/j/AoFpLk+cZDCZgOQATgApAQgWnQjIUmKj7g9V05OORTIXe/bGvj+RrveIYMJQ4AMTTmnh4UUSWZCVgKNO6j1VIBhMVHnz4efj//ovGu2//I6LoLWQaAhSghQBMILraxvT3g9uNH68ptz+oac/VAoC9xlQeeOj+NxHRh8NQo37f4RQDbCPONEieyLblU7vtkGUHrG8oXcTzTbKktqLYBNjF1laGFhbqtLaWp3yuR4lkf+QxFQOhMWYC8MJI+bjGEr/N+Ou7EsYyMvVeBcBkGjuxJMhMA5PxW8uHO5hpj6kLMCG53Fkxk3EwAWCg4gNmosdYiTq29phAC7D65TsmD/ws9kXIb/kPQ+/Q9YhMy+f0Q52sYBIICKjpVJ/S6R4DRCHf4ZNbMQsFJkhvuj3BJgwj4tsiCoXOCJgodqLABMwllewRQG1tvcCgFgQatdsJ1lVUKMDB63PdIcPB+/iZv/rmy/oc8qODndixifUk9+tMG1odxYYtxaMXW8FBDDriSugyEw+y32MyVRG+k/EAYKB8bMRIGoBFsT+ASE/msio1msIM93tczfRkL6Q+KmXo9e2RywEMmibX87ZSA60D4mq9kaLNikhz+j2LCrk2XVgpsfiK6PUcBoO0BKONjSyf9AAe3DceYDCNZpoZDiKd7pJt+4Qq0uJCTb6WgGw7YJG22Rq9//pGfvCxA4iB6aRTHQaWd/3N698/8YZ3iJF0ZHzNqJp/AqzA/wEW6hZqkttgbYa8rSZ9KbivnDX7/ds//T6NEXYmP8/TQOb5wjKGfpUd0sdZ7N3ASYcTGqwgoQRXbfhZAAvZ2Mhz5WZjcziFYX6uTnPlBv/MbEOLOAVS900k+nRkeYuCUKfNzRyf6CC2YBUL83VaWS3y7ZDOgPl4rs6VG6RS586VBs8D0EJVB4+nvvOgweD1KvBKJV0GOTxWEIq0CbqO65qUTnW/51L0lQGgtKewET4ghkadUOw7jqc5ionEQQi7jcFsFJFPHIqTRBNgYk7RTlBCnsZcVOAT4sZKfsEOt53FnooHHrq/pk40MAewApz044F0ZB4AsFJkEEG6Q1K/iEenm6S5uQaf/OvrAnjAOKJQJ9MKaXm5ykxEibnLS1VmMXjObKZLiYTHwOLYPs3NiRI0zG4ArSjSmIWoyo5je/x6+67FYIWKkHrtdqw0DYbDEWl0saCi1+47xTt50tNqv1IEyU65bpogC9YiKj/D66alTQciGAykKWnKsRj4UXR98nIVSIXiOoox+YGcxd6Ln/7LN0SDNgt54pKs1vR6zsjrZSYAAFiucrWmVhfpRrz6cmGlSMmE0ETAMlzXoE47wZrKxmaaMuneoAoE9qAYCFhHp2uRaYZkWQHlcx3WQzY309RspunsufLg9ZWKrRiIyTnRjssgxh9hnVhr6ckK0B89md/85cci+rm/T9AXVpKcsgFUng9YAEFT53MifRlPgUiVkqPRCfcUc9Ei9Yl7U8Z3/RyYAGjCCat8JuN+k7i5DVoJjhvSG1wORtPxiDL25NHwppuUZrE3AidUXlZ4wSDwLQ9TGpgH0gZ806+uFfgETzg+lUoNNq75vk69nkVHjwhnwNpagRYXhb5RKnao0UySbQXUajl09GiNul3x2VherrObNp9vieqP5VGhIHQVl92xHusith3S+fMlWlxs8P0BSobh0NmzZTp+vMK3h0gbBhp1u4JRKdctP5Zr0v9+tkh+vUNhTyMjo83plkmGY9JHahbRZkChZ1DImt/90XaVIJ1kmXgn2PGiUbF2HEwotikQy9ED+WjRDqnUgQmAiOoi3i7QuxPv7cHxU2Aynubs9DizuK4BMFGCJk5GMAjlcNV18UWg6yGVyy32idQbIj3BbUrFNoMMotlKU6nUZm2F5ImO24AhEGv2ITMNgEGjkeTrkepo8rxqthxmG52OQ7oWsk4CllOea1G749D6epbCUKcoJAYYsAswGwCabkTMSvDYAJMLF0r0rodT9Cv/mKSg51Gk6xTh8wlMCELyu0IX0rMJisKI9ITFt8/+xpumntiDr1EFEX25KiPDTEPcx9qm8hDEgAamNqQ7WI6u7PioBG2XSh2IAPPAPwUWSIHAPpRA24tZpXve9Hc8S3P2RQBMcGJnMx1+uclY2RbpBdIdVEdweeCLL4XFhcbgNgAJgIzQPNosjEJbQfoC8MCJDS0G6c2ZM3Ncbj52rMr3QQkaoi7SKYCDDgHX9FnwdRIu9fsmHVmuUrOZJLdvUq9vMXjNzTX5PtVqkjWaVEqAA54HQANW8rvrAWm2SXrKYfYRNLtklzKkJx1yimnSdJ3crSb1zm9R0PfISNgU+AEZpkGl//wdE6DCn+a45qHF9BF1+bgOokrGI+Y3bXQSPm2jsxyEGJjPwDycKSNlFNAqoFHpjgoFOLDqu6PNYYe583ivhtINcGIrp6sKnLDZrEh5lB8EwiqxpqJ8IQlaXS3wbUX1xKJmU7AXwxSfhaXFKmsdcMLm8j3OqFUfTmUry6Iu2EinY5Ht+LS5laGN9RxfXi61+DHnyk3SYeGPkFLlWIQV328aVSopLh3jdeB56u0E/eqzRQq7LpnFNAXtHqc3Vi7JOh9+9+odsvMpSsxlyXQscpaLzFK0KCK/26coiKjwvjePgMPI1yOAYlo6Ax1kfKMgjTGU5DYs5lAFNBUcmwHrkMdH04YgQzERN27Vh1g700/2XIyIkJHGjlac4KiOIPquyVrK5maGGQOiXk+MAA/8H75kLdBXiIHI5NQH1RqkH65n09PPLrLICkYB/wnKzLis2UgwC0Ejoe0IV62hh1xiBtOo1dLU5deQpXyuSydObFIy6XPVJ/DFZy2Z8Mh2PE61zlwo0G+vORS5gp0EtQ7pCZvZCJiBlrKZIBhph7xWjwKlAfY80jMOWYUMha4vUqBsgnK//sbBMboovj1oBBwDkWn2fH+Kw/YgBjMJ6B+qauPHwKCt0puYO3a7/h2AEO5r6pT7qcM1wmCvx8//zTeO/LE8WUZFGgIdAicstA8IqjCwgSUABPL5Hn+nAESgfUBIXVyss76ytFjj24OFVKsJeubZBU5FNjYyrJHg9Dl+rEo912LdI5VwaXm5xv/ALtY3M5weHT26RfPzTWq2EvxaTCOkWiPJ9ny8DqiizYZDxUKbxd52xya3b9HZlTz93nmf/L5PuqVzCmOoLzbLYJYS1DukOzYZKYescoYiPyBzPke61Pfwu51LkdfsUNDocrr0+j984+soDigAgmnshOToAmQzhqzm7AQaZgxkDroeS/1gWM1RPhSgedoaLQ+72zCPen94Xzf40MT1s7huAWYy3n8DYEA5V4VyvsJoVi63uZvY0CPqdk0GGOgjEFqRlsDdCl8Hm8wcnyst0FNuvmmdhVJUYvDzieNbdGGlwFWeXtdiZgKQWF3Nk5PwWT/p9U0WYeHERal4ZaVA6xsZOn50i3K5Lr8OLkLaAbNkxwnoxA2bFGgB/ZdzLQp7Ln/V+R2XvFqbIs6viDTLoNALyMinyG92+Tp8aZqlDANHZBnkbjRIk591M51g4Raf9U9taX9BcUAxY0IqTenNUQHQCWPX71TFUcOYDmrk3vUPkwgMTWV8JkoiprPEQTs9THlyP/35b5t4rFlclxj3Wqh0BZFKD0EGjKHRlN3DPYf6fYNMK+CeG+gqS8ui9wZ9ODCY4bJWO8FdxACKm27cYH9JrZbk1AZNfwJwPGo1HcpkXTnvJGRwgO4CHQTAAxEW98F3OwRYmNeq1TSXmJEyCcZk0LnzZdrcSlG1laT3/oNJIRp/cykyckky0gmyjxRJNw3yG13yNpucwvDHeC5Luj1sGwFzCVt90jSNDbah5/O5rSdtToestLgf33qkh0d+4NXHvjVFkEUVR10PN+w2378jj3NQY0JE5f6codAaIf2JaSNRKzYPQxzrd008xiyuWzzw0P0fiT830hykEKp5TgmuOKuWlmqUy4puXfwfqUejLoxhp8/M0QbKt4FGCws1dqoiRUL6Ae3j+DHhR8lmuyz2JhMuC7Twh9QbosKzsZFmnwnYTK2ZpEza5dvisSECo9LTaiepUOhSJtNnpvOVZxapUOxR4IsZKwsLTYqMgH79SYvsfJo0Q+cKTf9chTTb4PQm6Lhkl0fFZkwhQEoEfSVE8cCxhH4yl+UUHWkOHguoErg+9Wttyv/mt0Z8dOIGtnFD27i5TQGO0lWmVYXj4w92So8OSihA4AluYCixYTlaenRGigb/CSo7tkm5dz4+5ejN4jrHt8SfHhWauKtVzW0NQo2ZB0nHKkkmc+zYFv8fKcb5CyX+Nz/fYsMaLkPak0z4zEbKpTbpRsCaC5oDMTgJ+kjE82JTLKQaZkjFtEslrUN+IE5ggNLKao7KpQ6dPl+kTMKlRMLnkjP8Ls+eKdMtL1hlQ13XJ/qDMzV0B/JrNGyT+tUWJZaLFLZ67DPRSeOqjZVPMcAg5eFwLNJclIh1fk1Bu89CLQBE13QycwmKXJ91Fne9zqxnouapACQ+mBppTVqOg1QeE3OKIKtCjT/geczb6DIHMUaAhaRGkncm3mnup//HDEj2YLznk18bGYbwaUBABWAoMMHJiY8yDGwYAWDLGSVIdTzXEFQ8IvaWNJop6vdMnlkCcxvE1WJRjHVE6Re9M33XGIwgCAKfVlYLbGBzPYNOHK/Q6bNzVCx0yPd0MlIBbW2lGKxaTZvnp8DKj0rSXKFNnm9QtZFg7SZfEKMKnnxqmQqlFv3WmQSR1iFd10jjfwYRzGp+wFUdeE78Zo/MlMOpj6bARKY6bGiTfyqAB6UdTnsAJn6tTUHX5WoPwq+2yXTDyJgmxsan3Ctz2vj8WJIelWn2elsKPYcxZinM/gvoJkjkR4YNyW5cnvOa7nIKoea0In1BKoIUBIwBZWBUcnCSN5sOWVbI4IHroGug9JvO9MmxiZ56eoEfq9uxKJH0+fbLSw2q1ZN0dL7KJ+xcucXpUq2ZoA6aBCNivSWdccntG/TFLx+l40drVG07DCiFfJc7jtH7Uy50qeNF9L6nI/L7PT5b4XCFgKoZBplJm/rVNlmZJIXtPjMMRNgR6TiXjccCaQ/8KtT3RNoDUpFNkpVPU3+lylqMe3qT2c620d2mJT9+F4CJUgjiesv0e85iFns3oEGMVHZQUenZ7FIFAMDuDjA5d64sgMQOKJn0qFxuMJigdAuPCEAE4qnl+Mwm0CCIFKlSTTMzweP6gcGVHQiyhXyPVteE3nLufIk1lMpWitOkW29ZYebi+Tp1OiZtVtLUbDvMetotm8XXG45tkeP45HompZMe9YOQPnDe55QGOgeqMkhTQj+gsNun0A8psVhgMRU+FDAPaCVIfyC24n7xiLyAdFla5ooQig7QCg2djXFIkVhnSdpk2po2UAyjMbBIxmaeZIzhACZDzj9RFSHVDBjXWwZzabcBpVnMYq/ERAetXE0BX0h8PiuqJuvrBU43ADBo8Kt3Ely63djI8eUoFS8tCUs9ToJGM0E337gBMYEcy2cPC8rGW9UUA83cXIt/bzQc9qagWrO2LhhDqdwR4xhf+fwH6kc++B3R0SM1OreWpv/7TJ+0UICFOEEDJlto9gu6fU51eucrXOUBqEDxMwop0mFvQCoUYyhKNxmc1zDCNbqsl/RXa8KPUmuz4AvGws/YlSszMHXN0if1EQUU6v91P6KkFGjxl7DHGInSWnbytsxiFnsl0LIPPSMIDGGX1yLui4HPBA180EXQ95JJy9voEacf6BaGyArW0u5a7HhFpQaXgb3AJm9oIZ0+XWYAssyQUyKwjFymT41GgsvCYvdOltY3svSbb/3gZZ0w//Ff/LH2bx7eLLUX+pWbWv+pf3rts46eSQjjmSO63M1sgvrsQYnIXshT1PeZkbDQWodBzR40pyrQiIdXaZGBak/SpqjjkrNUYHaTOCrGKcCjwoCienDGe3FUjK/KyJsizTFiTCR+z7hwO2Mos9jLCTDYSUKeN6r3hqRpDRUefLDxf4AI5oe02ynWTzQ9ZCBCXwyaA7PpPpeUMWUNJeIjR7bE7bSIPNfk/hsACHWJErZP9WaC5kodZkDwk1wukKj47r87v/BcrbX28hsX6auP/ZBjpZv0krk8/ekTP0BRGBLyELANXdPYi+JutfjP4sznOKUx4JWyDAYKdszmkpz66LF5PtBawmaPDXBeo0tWyhaMpd7hMjMeb6LKM23t6DSciXv2x1Ml9RjbzVQ5DNF4z52/RkH4b6npigOIQUq28fbcTzz+u4fygOzBkCtAR0MKsWAp6M1R/Tlwu6J6srDYpPW1LFdckP6kUgYb1jYr88KoBhBBQ18FoEPMSnwvYtcrdJVqI0VzRVGZweP9zNf9xRWfID/2WK2w1uysbbR79I/nNijv2PTiuTzl0wm6+eiv0EI6QY8+92Osd4BdoAoLTcXKCMD0ttqcruCc5oqN6wttxQ9JLyTY9AbvCjQWBhUItGAvfY96MMPBPpJyqPW//Lk2ABR18k8b2zjeNDj++/g9FCBljMPFUBrvufN7qd7/PUoaoken5hKVE/Gb/E7jF2//HWq4RFlrLveTn69MPMhBjL3rRRosVVMrLNbW82wSg8FM9OZkKZ12WR9RQ5RyOZfBZEEOgMbP5XKXnn1unrWXG45ucbMeQowdyLGfBHrK8mKdq0P/51v/aPJEu4z4Vw9emPeCaP2rj89T65kVOl7MUafv0hc2arTQcmg5naDFbIpeuPhL9JUz7wh1y9SjICB7IUf9sxWyy1mu+qBPB0CB68K2T1rPY10Fl7Gwm7LJNHUGF4CJSn9wX4ATrPoUd8oqJqHeZdyQZo2BzPPpIuqeeNzDoqE0fun2iPr+77HvBO8Zs2SLMQ+K6u2pu0TFBNYEbDZ+4WWHAm2jq/zfbgTABOMFoIsATDC0COnMwnxjsLsGWgmYCkAln+9wVUbMjMUQI4sZCgxlmKRWzIuZJzCq4f/EskHIM1/f+20f2pWTAsykkE2t51IOXag0edNEEIbUlrN3HFOnlXaPVhttMnWdvun2/0tfSPwUXwenrA4WIrcweJUmV3LgR8EXADwpABPu7XFkhccNBDOBcItBau0eBZ0+O8HbP/FX/J4YUMbTkmYQjQiz4+9+3I4fDzc2Gf8wpDuNn/maRd6lo3JNmH8AHm5IEcY84meAM3p7UGrDIdnqUdQLuPO48UuzPTzXI3hgUjD6+exg7GKk8XAj9N5AkIXBjaS+AsYCpoIhSijtttppFl8husLcdvr0HKc8nbZFTz69yN2/6LlBM1+lmmIBdjdSHJJgUql3mGEFKKpYBr10qUSFbJJuXCrSVxVzVM6k6NQNC7SQTVHaNGir06PbFot03w3vJTOTFNmdF5DX6gqPShhxA6BVEPNRABroRMbP3Meja+RvNCj0Qh53gCoR+oJec9z5efW6JsYXYPUFhlI3/MnPeTeanHQ/HnFCghkqB3ZItYyo56/yGAP066CHp+1T1PZZM9FSFq4nqvWJKl058RtKusZ/PB66pGvYRHjAD1J4df9dRrBr1Rg97Nw9rEXsZFVDoeF6Jbn7plpL8RwUsJJO26ZaTbCWG2/coEy2T4sLTfaPYNSiDR+KEdCzp+com+1T0vF2Lc15+ydW54IwqiK1IR78pFExl2IA+Myza/z7Vt+lbt/jgsoX1mu0mEmSY+hUzCTpdLNNN5ffTYZtkdvoCDYSRdRfrXIpGJPbrHKWu+AxwQ0+E6/ZJbfe5svgZYHQi98tTXf/8q1/+rPqtTGgxA8rNBSIqjlz9L1HsSFK4xgRN8DFmQ0eYpqL9qBE450vibRyUhwcWJXzCXFEEwZRsy+ooRsSpU0ieTuU6ijrDNIhbhb0A2r8wm0zpnKN4j2f/Lo6xgqMr7JQi7LgjM3lOoMVoeoyDJhGzwy6ejUdm/waXOHB43AFR4voRS9Yoy7WamRcWl5ssMkN7OTXv/OPd+VEQDUnl0lsGLpGxxcK1Ov79A8XKvT4c2v0pfUqLUnPyMuOz1PCsZi5fM1ikZ7calDNDegzZ9f5+oSh0zfe8us8DwWGN/hIUEqGrwR6SX+zQf5WS3Qc90UKhcFK3BAYhFwuvvXI24LKD/3JSG8JA8p2oqoKAEi8+3gcI+K3l8u9OPWBmtw/oKIsswr1vlG7r8rZJm5ImmMQpW05jNoUAi0ABuJW2qYIbCUSuormhYKp2AY13nHrQd05cpX/XVoYRsD0A9oI+nEwb5WkjiJWgvbZN4LroZkg1WGHKzMWh/cEo9EPS8dX1zNU2UozeISRQWfOztHR5Tp7UJAWoRP4t7/7D3cFTH7kM1vFuUJ6Tf3eaPUo4Zh0902LdMeNi3THsXkKwohWtpr0xOl1Ol9vsY3/TLVJSdOgluuSZRj01XMFmk/a5PkBve6W/0iF+R9ntuHXOhT0XAYLgIuWEFPvvVZfiLatLvltzMwNaSH/8+Hn3va2iSrx4AJlRlMlX4iy6G3gwfvXvYkAACAASURBVEqxwxFPd1S1J171UVUi9fuBbQ5E+qdGPSLdUW9zPrbmEamQ1Ex4UlvgDmegsH05EGyG5CrTvEUHM/YuTsLCbprDJeKw1GNiPNIbiKnwlWBgkW2F7GwF4ygWxQxXpEiblQzv1HF9k/fhYGcxhiDBkr8w16B3vOrvdk0z2Wp0tuYKGf6sPLteY+9HLiOqiGGAmSkm6yeI5VJ2cN+7blqiv/nyWbq1nKNMwqbPnN+kF+TT9JVqkxlFhvL01bf8Or1wsUj/z+NvZxbtVprklLLkYnobvjBRam716PjSL9F8Kul+8tu+arLrFceTTwW1vzs2+nRaN/G430SBhsKMaR6Wg8hQuJuYhddAAASAo5QQk+0hvnZ8sdwZaQ3PAuwTW5A1yUrKSZ6TogFMugFFuH3CJK3l8WMfuObCPVQ2/sWPf/0XbVssLEd/DdaHopNYrcPA/hw76zEwAGxgVtsCA1mucmMgzG1gL+cvFCmX65NjedyUh0Y/fAWjp+dLTx6hfLaHzuHXTbyAywiACUrcC0WZohk6vWC5NPJAX7pQIZSOEV88K7woxUyC0imHHnlmhY5l0HiYJz8I6eZcmja6Lr3ihgV6drPO52jD9Wir2aFC4qfo9sUSzWdT9NdPnaN/dtsRqnf6dLrRobAA8dfcFkxILgyLQDriTAJWfCWmxmfI4mc8+bi3RIFPfKOMukV4AAkKpyw4aKZEYKQtGKQEvaQfCoR1jOHox4IjGIobicHUfV/MScExhkCLgVW4Pe633pl4vv0feyfl0bToJWAaKP2qXcQAE7AQOFxZmI00smyfy8ZIa2BCU13GuB0qOemUS7VqkkqlLl+PSg6a9J56ZoErQ52uSf/ba//6ryZewCWGApOd7tXpenRjOUfPrVY51UEcW8jzR+7ZlS06efMyvfjYHK1UxFoPfMdlbIPWam166Q0L1Oh7/Bn83IVNskyTvCCkT59Zo5fNF+jhsxt0odWlcsKiG3Op7kPf/uJtwQShBzhSUidpyVEEsODjXMFl8WlsnpxvophJ3Q8HwDPuOcFPNT86kNPwWYiFaa0TCO2EhVdLgEvL40oPObrQVjY64kOP++D4qIltax0BPllH2JZxwLMm0YFcbzwNBK4PoGBAEnwm4mXJsaeexcwjl5VT65vDtBWLxLPZHoMJBFjMK9ncSnNvD0YvYukW5p5gaNL58wUeeoR+n/e97corOhcDJmAcqaTFTKSQTtCJYmZwzjqOxSTgC2c26NNPr3B52TR0SmO3ThDRmZb48nrZUok1FmgrJ3IpyqeETjSfF4wo41h0ptkNPvxNN6cmXsBY6IYm1r2PdwvrUjuxY4Cg0hlXloPzpj5SxemOUduCeUD1E18CSM4S7ANIWxNzJxhJF1NEm30xYAnXQZRFOgSQAfiglAy9BCnRaofFL06ReILPxLPt/5iGAdcHTwaBVGajIkrDakE4xFiUhJmxyIoPRFtUetBZDIs9vt1hXlPDkKCxtNo2DzfCknIY144f3REDLiriYNKVRjU/tmWyJp2pptTxoKHAg4Ly8dccm6d6G3uP+/TCI2W6ZblINxczBAMcseQX0tecWKBeENLHnzxHT1XqdDSXolI2SUlDp2qnxwDzufMb1PV9OlvvBF/+rtsmBNhpwUsH40Y15ZBVaQxSnPExjmAi4+XghD60BODxDrTlHtb5pCnSFwiySymR9gAwCrL129YF6yjZzErYm4Lxj0lZAfLC0duBuQB4Fp73S2AfxjQUuPaI8sBD939c/QygQPcwxRaak/SbEM+S1dkdi/IyVmOk0uLyXK7FXcWYJ4tQfpVkyuMKELb2vevr//sVfZMCTFqdftWVS+CSckmcGdsyCfCIh27odHa9RvVml75yoUKe55MFzwgKJpZJmaTDZWX06lS7fRZp71gs0ovLeSo6Ns0XM/TY+U3KJmzK2TbdcaRMN2SS9LUvONr6p+++ODCh4ebAoVbS8kb/QI6cct/0oxG/SRyE8DMOdygBCExHpT+1KQa5fR8AhY7cvYNjgr06asFXTaY0EGnRENjwmFlrSrQFCKGig9sCRHIyVYLhzd9p3Pd+jmkgcF0oyn0kV3FiOj3vEpbLukia3Ygb+3LMUjBm4MzZMuWyXXa/8j7hbpJnlmDHMc94xUTDtMuOWdOIeA/OlQTAxA/CaiblcNUGUW2I1ARayU4BX0o+m6Rbjpap2cV0OJNOrwm29I+rVdZSmp0+nSjn6Y7lMlv0wXrySZsNca+6eZm+vFlnllNpdihhmd3fvXcpu8NTTgQfEV3OgeU0xhYHSbES4IZKe1TKE8nysQIV/AzToQKSONiEB1ETEKqW+BlVHewpgUYCcEE1BylRpUcR9JS5hDhga12iqitEV0jhYCiw32MtAUAXPT50MEXZiOcLX71/FxtqVSjEVuy0UZHNCGCBsIpUCOVinkSf9BkksD8HPT7ttk3raxkez4jOYUxag3iLubEY45jPt6laT//lFR6uKphIqzPcnYwTHGwllbw4WwHE15uWS3xOL5dy9BQqQEsl2qi16enNOlUabfKDgG4+UqKnak1aLGXppcslBqCvKufIdVmk7f7x6268ZLqsu2FkgoVAYDWkBFBzw0HK0wkj8qKIvFh1p+pGbM1PSgYGFhJfvwFgAZsBqynZB1BHARjUe6Lao1gb2EXLF4BCrF6TBofsZk+U2ucTwnMCMNrsieHVqOygfAwQhxYDcCrtKKLv05jGKq49Q0E6A8freKDiw53EZsDaCJr91tfzPCAa7leMVkQnMZgIWAmMbGfOF7msjNGNSwst7tnB98Qvvv5Pv3HiCS4yfuyx2uDNWKYxcifFVuLRbPdHfl+vClfvclmkYWAjML7NZVMMRvOFNN26XKYbFovMTmrNDt1zfJH1l8fPbbDbFtPsH1/Z8j70+psmD9RFhGloFMLUptNw105BspRAnif1gNiKj16qjX5I8464nrWSYAgaABYlxCalwOgexDUaTY91Ew2iK9ZmQCPpBaTNJQXDMDWK+gFpGWnLB0tDeoNUCZWdckocWBjbwE4ANLDk4/cDmfXsnc9AJj00saEvB7t0EFjpCWeszpv/EtxlfPZciVeAIkVCnw4qQWA2lUqGRxR0Olj12aW1jQwFIYYpTTzdRcf//PBmFAcNsAWIscnEdFYCR2w2Pfrlo3wqlXqHyvkUl4IpprfAn1JI2NT1fAYZgNYXVip0LJ+mu04sMrNJJ+zWE9/50ktKc+Ih3FaRYO34rINVrPdDBgJgZNHW+PPekiVgy9D4+k1XaCVZZfyMBLgAcJA6RdK3Yh/EJerQPQAQANaqcMFyzw5+xsHaQklZsBgGn5Yn0hrcBqwEJeNKX+w7hmgLwZZ9Lfr4/JRZ7GLwsi5tCG4FqXfAVwL/CcAEPyN9gf+kUOjxbFgMrl5fz/LPGLiEHp6+a3F1B9+bi/MtLkEnLP+yX6wCk3Ys1cEogr47fEykLCq26m2W3sJgUlMoy1UYABylvyDm0gk2ty3k0lRr9+i5zTrddmxOuGqx/c80Or/9msXLBhMSZWMK2eHK4xphhdCoYGkMBGAcABZRThZ2fGgiKVOjoiWAwoIlNxr2+wCAUAEKI7mf5yBWe3Rhq+fKTSgrNSlDiLDwpiwkSTuSFM2CAJ/FFGk4QBC8oa+grAzgkUwvsnWKADwJg6K2O/F0+z72SLcxtBNxwMW6DJjUSHpNEJj3mkr2eRhSu+OQH2g8OBp7hNHsh2bBp55epPX1HI92LJU6PIkejluY2tzAWJt40ouIeKrTk1smPT8kCLOOBBpoKkhZVKAqIwbQD9+/SnniAf0FAYPborTju0FI8/k0O2vx+O1unz53Zt37o6+/IT3xAJcYehCRhoLFSj+ksj3ah+MF0cguHpwT6HWLIsE+Kq44DgAN6DBIhTZ6EQNR1YsmJrsdmICGAgDFe1NpC8AkEgcoWu1StNKlaLNLEXQVsBmUg4u20FnAXABC3UA0E3ohaUiTai43Dx68mKZ7XFsNZWTcoybWZSiDG/wn0FBEZ7HGIu38XJ1HFBAvQ28wm/E9g15w8wblC11e5AWnLCazwa6/spqn9731g0sTT3yR4ckBXIpdQBhVAZaSSU1qa30vGLAWVIDwcYzrKnF2c5O06oOxzOVTLM6SLFJaptF4+C0v2ZUPHhhKtJzUWfu40A35zwNAQOpjyMn1pNIX6ZJVe8ALltBUcFkQCb0Ej6WRGLIE5rPTMKZ9Gy0BBHJFgPhMc5eVzairlW2eJ6rlbQE6uA2+eZoupz4RmAqARYEKWI1jCHG23jtwh2svVHmiSP+x8cuwt1gFhNnKVpbBBR4VDKA+enSLgQNb/KCdZDIurW/kKJ3qDRaUA5zwJ0ZX8ZWEJU8qiKWbtRY7X1WARSgjWzwcy+AUhphlWYTGwbiugvsBQHCIVitNvgwAAr/KXNJhB2292Wn9xqm5/MSDX2bwEV3phpS1NTqS1BlMsgYNdhOzpR6Ibg5FW+xLTcpWlKQpOpKVR6Up15aKzE0bVIIOVBQt7GcVYMAGN5MIHgFsaYMQhQoOQAJuWThiG55gMUmDNGgm+B0pEgCpmOCZKBrul7OJVg5qL8/1DU0L742/AOgpmMzm+xqlUh5PU8POHFwO9gLBFqs10BQIlyyiVGqwL+XZ0/OCG4Ua7x/GTh0MWLqiIwQdTtconbD4Xzwgzo4b2cbD8wKyrNHK0GZdsBHEUlmkO2BAZUpxCrVUzDR+7e7SroEJKR+KY2ii1BuIKg3A5FwnpLV+yNUagIX6IlClYGguBoOLYCG6NMg5cq8PQAWVoQOoCIj0RmkgqtaOoUkQYnG5Gk2Q0inqSp0FWkpfXr6QoMiQ3cf1Pmm4PQC5509fMbDvY1qacm1TnmYzfd/In9D2GCDYpNZ0KIfJ9Zs5WlsTJddUSnxywWLQy4Oy8VeeXqS5uQ7/qUw9pK960QpvC+z7BpebLyfe8penfwZ303aQBlSlZ5yMgcmoUGASxTRL1/NHRNl4ZFJOfbfBhBRDwfmBwUg1NyII4bDRH0sJaiGcrgJssAgsZ2kMNGkTwi1RxhLAgrQHTKfgiPGRABP09rTcA5jywITmyYoNRj+sdFEnJw1eE4AC/gFYdJ00TLsCmGBEAXJEAMp6jzSUxzRRWo/cSDQcNvui9fugxR6wDmSz7QeVUxZl4W5P7CWGYY3kmgywkW5XTtKLxAS3rWqa5ueatDAvZp9sVVJ0ZKnBe4vhlm11bSqgqfAy36Km0ZMkRde4TjKtZBwvmEIfyWcmrSJxYDoyl5u4Xkb9vXcWJleI7ELo/TD6EtISfJFC/wCYKHBASoPfIc4uODqLrkoSgaay3pfzT+R7AJjgd02mQA13t2aS752o3Xfqw/xiDKl/yJOFUxYIq3XZbZy1BoNi+DIuMXvC+gdg4XKyP/wgVnqszWipSQPTLK48fN8YHFjH6XOZGL4TFdBERIhJ9qgAwW+SyXjsnkW5GLNhUemBCHthtUCVzTTZRkD1VoIM4/I+6X/0DSc+SIIx8DhHFXEwUc2B8JeoMAyddRdFSOLXQaDdlGItrvdilaPNeqd9tcAEoXsR/U2XXeDCQ4JqzSrARE5x64XEQKIGJeEcQmk4Y+p8LsFz0pKCdNOLqB0IIFHZnHvAjFp+FL2JgQIfz5ItlkcTCbay0uVqDaNwpc9VGzAVLW+hA5OobAvdBBoKymUAGYi4ABFNJKBR1aXmE6/5oYkn3qfRfOLeN02mKNc+5THN4KcADCSnsqlAqVgFxhNgDCQctbbt8+16XZNLyWgQxLS2xYUaL+/CqAMMp/ZDjSe0VWqTbOFSA67WaaHARZWAARCqUVARklJ++Pyu79GcLDHj+nq7x+MiLVOvf+D+I5kpT7FroR/71CPvAQAgdSnZOp3uhLSQ0Ph3ZDtdT9jsATTQT3AerPciNroVHdE4CLYCHSVrCe2kYGvUj4hZDVKns68++XsH5QQBLoixjWJgjNb0SJuzBcAsJeWIgohFV61oi5y24ZGWMobVIIwtgPek5gmAqXuivJwU4KMZ6d+ceOJ9GpqR+vC0ysy1rvK845Uf+3i7EzMNylkoKBXDjg9fCebGVqvifIMrtlxusg3/mefmGWCwtIuYMcDU5vD9UkmfjW25TI9+7qPf9KaJJ76MCGI6SPxngANYjCHBJF4WjifKhewQXHB7gEsuk7hqaU48+JUtJnU2tAEUyg7SnYjPCzVkDCABz0ndjdiblZK6IwRZ3jZoCB2l1o9otR9SG2VnV/QAbYn7fe/EM+/TQPrH4wtA1dDcx2/cEwku/CYovbtylqxy0BZEORkOWjbDQWOpuKQtJnj0YwSTID4tbihyzwOVKE5jFNeeoZAcSj0ILWLWgcY/AAXAA7t4MC8WQiwGKPmeSe22wyMf1YhIYibjMDtHtzL6edodizodG/f58MSTXlw8GL+VIWkHOoGNMbEWLEZX85qn9PeoUEAkWc81ARNSgNIPIq7qRFKYxckAcMBSdABMQBGb3tQQJoAKfrcNUXLGyAOcXyg9o10FE9/mExpfhorQsQNUOwaL43wQaQ37UGS1BuDiRRSBtUhhFf08bLmH9b4nFn7Bm8Lgg/SH06I+p0lcTgbzQQl6BihXBVBIzkFRAfNaFA1PWIyAhIcq8AzWTNpdh3f0zJXb9Nxz87w0HYvNca7alk+dTpI7kzNplxbmW9RsXZ437L13Fl5LXLUZHX0QBCGb1yg2wsD1h85YsI9aa+hbijtlY9WdawYmpAAFAJGxBQDgcHP644hxBtW+cMuqCk4gLfVgLFv9iM8ngIcywEEzQQFktSsA6Vw3PFDLvtZ6IYOGMLGFgqkkdIrS8tsCP+P6ps9eFY3HGUSkAWnlyAJOdQA2WZOXM+F2PKiambh22cur9mRMs8pfJ+s9cdow+lmsN1IDg1vgi+7iINTZo4I0Bwa3Vkv4TDCsGtpJPtcXA6oTLn83VCpiNkqjdUV9WHfMFUad72AgMK9BTFX6iW0Ov5zBPgqZ4XOq5kCY4ORjXVMwoeHmwIgnOy0kdE5x4EVhht6PGESQtiBtA7jUvYi3jJm6cNLyfGboJ9LgxlmAHrFHa8sNua/noFSOT7/qngiTHzUISefawtyGyk4zINoSVRuMLOC+HYBFVnxQ0auDYdRc3cFGwXmHIpSUIzlPBZ9KVImgo1SF/6HxxL1PTLyAfRbNJ+59aE+94kgj3RgFIJjZMO4Rc2XZ7Yrb6CEzE6Q5a+tZandsardsWlqqU60u5ttgyv3mZpbyuS4DUJ+HVF/+6Mf33ll4oh+r8qjKDKLanO4lITnCoN0ddXvJdOeagwkpQBGpiU4NOa0N8042+mKhl6OJWctoAsSfooOuY0PjebKo9uAuTVdkAZVeJJbm4fdQGPAh5MKLcu7VJ/c9rHR5jINMcbKWqBhDLjE00vKm6NXBjQAgzEJCTnk0UQ4TD8JrSfukQYeBqIi8EWtPLDFoyfjnhT6K7Zpu3TbxAvZb6NYrrvai9EsyJmiTt0VlBxpKvZ5iTaTXt3l3MeahIAXCnNhjR7com3V5wDVWiqLLOJV2KeH47LCFxqL2JGNn8sSTXGT8xivmNCW0xl2vYB7bac+w2qeTItVSKU85n7ouYEKDEZDSYg8x1ZC7NeYdjVKWRis9AQh4f9BCUNmBOIvGP5wiEGjzjkaVfsSpD0rM+D9YCkTbEymdK6rBdkdkHwU8aTD19Z5KChBIGSK94T5y2W6tyYMidRSu7vhyL2tbgE0ExTstJtxrahwkLkvqFJ1IC8XvIMyRUe/jKv6Lwv7PTDzvNsFT692hkIl0BoOnK5Us6ykwvAE08P9SqUWZVJ8bCLG3B+lPs5WmxcUGayYs0moRJRyPjizXWUvpdS165tmF6U9+kfEbp+YGok68wvN8U0CgrciU547rBSbEmC0/uF+85x6ucPI+Yum7AoCgjAyQQc8O965Js9rxlM66Cp8LhhBrkQ4BoXo8NhLsXqONbsj/R+qDc2jhk488z6HZm/HMK+6BoZWPBcjGTa9qiF/8SIAHUpaS6CZmIZbdgiFpOZOipi8228tPhZbBmIJAuBoBOC7PhGABSvvOxZH3n73tY/vyeDU/f/nf1JcSl3p8pjEIVHvAMPL5DldtWu0k9+dgBCT6dcBIbr5J7Lt56plFOnakxvNRsNQLYJTJutwTBKbSbDjU7Tv+b33XH0yfjHQJER9rEA+kOPChjFd53ntn4bp/VgYKD4xrYCGenCG74GisjcBij2/dhhuyTlJOiCbBZ9sBO2uZfYSi1Axw6UUiPcI5hYoRStIYH1n3QmY7+zUsrGcNiPKyksXpjWz4Uwu7ILZGqNggK4KdHkY1jCZIiJ4fDRoKDkHDF984oDwoI0OIMuR6jiuoYOytmFaNub4VHhWw13ekJwX2erATWPDr9SStreW5vHzD8QpPxcecWPyMy4nXWAfU6doMHq5ns96yvpFi05uaq5J0+tvXcy8hABAKJDB4SVV8kOLArCbj8/HbXe8YMJTP331PhHOjy65xUeGBVgIlxMTJxOs0xHClMBJMhWcLYegY+nfATiDSYiCTqbGgy+KtpjHoYBwdhjLhy7zw4MP76lu3dt8pXjWCtE21GiS+piq0kkgOWEJxphOIag48bJZBGkpeAAmkOdBS+qJ5ECIt+1OgYEPgxWNaOkXrfdL/9fLE82dv+/i+Ol7Nz7/2miHhpR6bcYaC9AanADqM1e/1eoKrOVvVFB07tiX8Kr7OjOTCSoHBAxZ8uGjxd683E5SwRRtFp29TMdch3YjoV77lIwd0MdX2MWAoYB8QUEkTNnw+OHJQEkRafJHyPCB8qXqiigPAQHqk5qjgd7ATMBOwkkimSjin8ERgKWA2+ynW7z35PSiRs67qEWtFYGP90InEpDad58kyA8kaFOEgQZDFGEjgDSzDSH1UPoxqT02uLfXFFDdmNk2P9LcvTdcb9ltMew9X5Z//6JUeGQixhjH8TGKyvWmJiW2mGZLvm+ymtR2fv1yxJRC3wUBr7OppNBOUS6M3SFR7lhcbzEyhqRzG0OLW5S/cc08EIMhbGtWkHgJmodJ8zIwNpbN2oxfSYkKn9V7IoMFapKmxIQ6lZgiy/UCsm0HgZIykZolU6uWf+8y+QG9oJ3h/MP6VbZ1B1pHzd4/fU+fqDL8xlIjhPZFrRQEkfB0OXF4yYDQHomlQrSpFKgSAxX03XaIfmmQnKnK3f2JfHK/GE/deMwS83GMyTUchOVsWm/8gxKLKIxoFDTp+vMLXnzk7R8tLdTp9tshFh2PHqlTZzHBzYLnYIccJqNWyeTo+xiGcO1emX3vL/7vvWMrPfvQNq+cv5BZLxQ6Daqvp0PKR2t3vvPevPztx47EYAZTHX343/6LLWSc4kRpeyL/Py74dAEVbTnODM3arH3I1TlX3oTWAqfADRUKdRh8QUqiirTMLwvW47CWPPrqnD/Y/3H0PTxOAk3gpqXN/UrUfUs7SuZfppq9rcU2dmwBRsckZ7ElhptIU6Q/SIEbRhD5sLYfijetcUR3ihkI80XfPT7yGeORu/+SePl6NJ14z9US9WnG5x0MBCnQUpDpIaaCjQCfJZPrUbCa40rmwUOOBSnDTnrhhk86fL1Gx2OFZKris13N4klujmaRaA1Pzu/yn3qonyTYD8gKD5ood+sU3/Lc9Dyrf95/fFqUSLq8MKRfbvA0AIx0Akiird7piKwAGdf/aW/5k2/cz4onXpc4h508zKGCKm83rMyJmJbhNWq7KQOMgTi5oLJGciWKxxCAYC1zNuC1mrSwkdTa6EY9EEJedftXJ3594RXskoCmZUm9FrxLSOoDnPMx/vFSeKOpGIbqDNXQUGyTYBlIbgKwh9xTDbq8csa7M/eTiaBZvLfkn+K65500LGo+/es/mP80nXt2b9pqv1j9wwIkXcQmBgUi+dMgCTBDQSDBYCWtGASZgGOmUS8mkaKfHSMiq7CpGeRmpkh8YfNtCrkeVappHG3zVC1eZwUDAXd9M00/9xTe/9lr9HS4nfuAD3xmlJZgglUMa12knuAGyWk/S1laGdxGh7QBp3r/5g7dE7/rr10/9LI4Aym2feVQzDTnqUVMd+SElJcIAbKpuyGVTTW59MHXhMQEzSchBTfClJCXogMlAmF3vhnxigvGbutjb4wbRWyde0R4IOGILtuhJIhINkgofAKqoiOH3yiM57EUSDARpDlgKr1rUKQIKdwPRo+PLkjGYG1y1stLDfhRc5k+rXkz/13j8lVesG+x2NB5/9X+IosjZ7jVfjX/Z2z912T73d7zyYxpGE2BPsQo1AR/DplXAvIbmQawiJV5IrtHiQp0azRQ99cwCdyRDT8HPABXH8nmBOr5JMS3/6NEa5bOMsx+beBF7IH7wA//S+3cfeVOUTffZwIf0BmY9OIaDSGdhGYOkoCmlky6dOL5JjXqCr0da+Kt//7UToDLRtYcu4a7cEojOWhjZQPNxgtV9kdLg2zkUuq1IeZD+mMKHAvAAc/ECASYAG2grWHFqyE7KntTAcL8v3H1PdP7VJ2/dKwcZOhL0HlSpICbjOGD6XEq2I4BxiV3PorWASA5hBhCrkZCo9jiyd6fq8vVaWwAJPChs9uGSmnTSike52DLp3Y3HX/mZiRd+nUK8lvBHJl/n3isXTwuABGz3AA7Mk4VGQjxz1uQhTGJvsUenT8/xCQafCljI8mKT2p0Ug878XJsXqPuhzsxncytLW1spOn2mRM22w4a3n/izb9lT7PKH//A7omKhbaIHCUzk3AUBpN2+Rb2exe/xyFKNwaPTsViURroDIE6n+rRZwSqRkN75Z28ceV8TgGIa2tM8dS0SVU2cWHlJy/Gla5Da/hBxqRgnAzqSO7741kbZGFUigBLKxy2pmSinLAMQCSZj6RE3FXpB9I/PverkdR8/+9yrTnLvKfQepHY5UwyTqrgh9wFqcmsG3peYF+PvaAAAIABJREFUMa3R5qMFBkYACMYWAFgiAOZmnyKUhC2dNF5Rqg1GRjKVQ+lYl31Bby9POWF2/PfyxuOvuO4fUPEaopc/z2vd9X+5Ox7aNoe/hHgQqzMAErblMd0HcOAk4ffWFKkNxhLg5AGwnL9Q4m7lUrHF39Aws2FqG1yzABJUeDBjFiVmGOHQ24PNgkGgcS/Q29//L6N/+1+//XPX5I+zQ0AvwZ4hMA+sBkGJ/MW3rNDSQoMMMBIjFOtWz5WoXkvyNDr0LoG1lEptNvWp8HyDfviD3zH4LGrTBtRAjIwk2qjPP9IcgAL0D4tbVSLF9Clj6XIfMrGmEskJiWg4RGMh+oQG6zhCMRQbQiduA4EXJy98LliB+oJPXx8n7WfvuluMc5WlKF8uf3dk2oPXCy8KwDYgUVpX86lf+MqGcMSiHAww9kOK8P9AMheARj8UNfeMJQ6CL1MdPMj3liZez8VG/s5PX5fjVX/s+gHabr1niLNgJpjkFkU6l5A5Io03AyKlwRAlsBKcYNyNjN6ahQb3/LSaNgMRzoTF+SatrGV53myjkeBmwWyux53KKCHfeGKT13TgsZBW/Ow///+uy9/t5z76TdGzZ0qUTYmFZhhr6faxpiNBxTxGNTS507rbM1lLgdAcYmZMtk86hawhJZIeZTNd6vYcBh8ct7W1wtavfuuHyxMMhWTfAO/1lsPdAR5gJ0hr0N+Db2TVugJnrdIZUbkBI4FoCeMbdylrIjVgPVITQ5w6vJFQ+FzQyoJvfHw6MVflM3fdfU0/qF95xcnuP526h5kJa8bSqIfSOQAPVamaF3KpmzMV+GrkqhB2GmhE5/8py45Y1b8Tmbqo3BQt0Y9mCWqHDmOxvzgSLOYKwYTkid184jXfPnHFVYrGE6955fUEE03TfmPiwisIbuwLh2DSaKZ5+DTAhMToSN7Vc/TIFt1wwyZrzBgTiTQGbOXokRodO1LlsZHlYpevz+e7VCh2+URdXGjwhkGMmsRjOXZA9UaCfvC//Itregz/3X9708fe8aE3R6fPFWlpvkmtns3pjdBE2lTIdqnTtqjbtalaTfK5jUl0YGhMKpweA2eh0GFfDjQnx3b5HwBocbHGH+SpDAWBExtA4cglXvBw4Xzoyf1Uas8VvrktyTjwbY7rMFs2JU+ujrycIpEOmdJNi1EJKEGHrLiLx9ZJgJda3XH3VfaqoEweSpJgyqVmAAyY8+puyD19ouIrqAhApOqF/NorrLGI94n3v/DapujP4f3FosEJ09mYneAAdgOK0obQUkIp3OLNf19x4nVdbuTvvLoO5Ppjp6Z/WK5h7PZ7BEup1TODaW7tdpLTmfhlK6tFWl4ajiZAsyCYDfwZxWKXGwyxZgPf9lu1FIuzSIFQIVpYqNPZc2U6fqzCjYNeoDMTwLf+Vj1FC+Um/fIbr25Z+Uf/67dF8JRU6ynq9S0q5LqUTLjUbCf4NZ69UOBGyOWlGld0kApBKwHYZjPD0QlI/RCYbAeAxG0SEnjB2BKO+6JtAQXiZEqyE0OmJMxEdCG08pIvXUxtA4PvyOXGEDD7gQAPnJg9WRFJS/MbUifokRA5u754bpyQEHIDCTrKAGdJ38ZLd9Gv8swrTv6tH0X/jNfmmFxpYvZB8vnwO6pQuA5A2PEk6EXYw6WxUI00TZqKeRgVbmOmiW64rcFrRSltCKEplOsVfQkohpxDyyKuTvR9V6cpVNPtG3O3f/L0xBWXGfXH9sboCU23X5W7/ZO7OmPlZ//qDRF0E8w/Id5lY7GmEo8gMJh5NFtJua5UTH5bWS1wSRknGEmBt95Ms0cF7ASC7NEjdapspiib64vHaCQ4ffBcg2fYwuexOF+njc0cvWcXrfr//m9f9/qnT8/9d+g6+OKqVDO8DgSMBG0DeG2IpYUmgyMDTDPJvUnJpMsT6+DPQXrW65lkWgG/Z4AMhnZXtjLM2mD2u+H4Jj8WQGVbQCGppQAIkJqAMcApCvqvS9Mb2AoEVzmvmVOChKlxhYe/+XnThGAceBx8u2vyviziklimjhQLHhacxHg9Yhi2rBrxDCKRYoFB3HUZrAV+l/Ve+NajSZ2FZrwH5YVRGxINmYEwmYi1jUNHwe1we10X+k+lF/JrQibDZj+5A/qme6qcL7JuojqOO3I+CkAmlIq2So3etut7libicsCl8cRrTkSh+9zEFdc58ndeHX1tmnMWgq2hBzyQaWsrx5oCTiDWVCyfatU0LUnWgolv1Wqaul2LThyvULWeFikR2Eihy1rEkeUt9nGgejI/1+ITGykQBM9aM8laBOuWWsiA9Fvf9cFLfq//65+8+Qc9z3hfp2dRqdBhj4wmJ8YsLdTpC/90lF72krPMpvL5Hjczbm5mhNCd75PrGtyfBNZVqaRpfr5Fq2tZrvQASHFMACqoCuFxIVTDi9NsJTiVw+veEVDOvOrkSzf74T9EkjJkJBDgV6V7BKESYEUapNKhlCn0B09qJLouXLahHHoNLQVi7Sav7sAXucadyi3JVOBZAVihwgTvC6otYBXCXBoN0qRIto7okgWZshKD14DxrKhEgXmgpQDXZVF1iYmsaSm8opuagSu2xxnCK7QUPJ5hiNeP52h5gnUl5c+4nyErYEfvqPL6UXbIRiKf4uFJ6D4O5dwUVIL+1dUHk4MU+TuvXvr7rr9+/fek0933Dy6QO4vxDY1Vo/i2BouBNR+lZABMPt8i17VZe0EqA0NYOu2xVR87kLe2krS8XOd9P7gvSq4YxoRxCLDyV7ZyVKslaWkR6091LlNDyEV5Fn4QsJ6nnl2kuRKWtOucShGJaYgw36FFYGU9x5UlpE916dQFk0AqBsEV6z4q1RSdOL7FFRtsOkTzI14zp2iZPusiaBc4drRKq6t5QvUHryuX6zG4oDkSgdsvLjTZWQyHMHQl4hQxwcdHHZsdAYUkS/GlVZ6HKvHUe3Gy6fIyW3Yjpy2N9RMwElRIIcLCuk8kqj8AD6REnSAajIa0ZSsM+z0s0SuDtCdtaoOytGjGFZ+nQIrAvE85iAZ7SfAsKbU2lUS1Bpep14JVIQVHPL5iO3gNSG8gJIOBIPVR/1eA6egClPCLLsbDMvh1A/H8GGdgyBWtuM/SyboQlwAiauZJVxpvTMFe9NvTFNx2OJvHLjcKd11dPS3OUiAyYvZsKt3jChBcsST3IQMgIFzixFLWfZxga2tZ/obGrh5Y1nt9kwdXB9KbAgaC1AGWdqw8RaqDD/fGRppXeOC+YAKoCuGT5zg+pyYXVvP04hetcqWo1U4wi8BISoCecjCZRsBl6tXVAm1WMwyC+MJFKgMWZJshj2B46tl57oo2TdHs2sLjkEY33rDJ7xFAqekhAwrEZszbRbkY9wXAovUA90OVCwOniL/M9UGpnXYSZePx2Mvv5pvxCSrpOgBFnewJKdwGMnVwZXkZqYLcJsGMQzUGJiQQSa2WWYjyqUCfAIvANz8YRlUOpM1LhhJK/Yb7grxQMgrxYrEmFSzC1sWsW1OuAiEpDovRrgIw8DMADI+Rlp3WuJ8pRWX8nJT6UFsCoB/RwCWLFIf3pKDcbensVUnJ/dC33NtkigQRlgdVJ/ThIKZ2QOEPzNjJpUThrs9ekxLrtNRHibTxAOBAc0H64/n6QFch1lF0Hh2JdAgnNBjFRiXHFvZbXrAqlokl+8JQ59rU7Zos3GKqftc1ueyM8QhnzhWZ9WiasltodGSxQedWisxaVjcyNF9qM8BosPlzZ7TOO4PgDUnjOUKdXN9gEbbZcjjNwWgGpCdHjgjmAWaBtSBHj1R5YyJP+5fvGcCHNE41RxI7ii2uaGHaXafr8H5oKcjy9VPLxuNRcvRHdBLMxJOL04VjVugeCDADZWgz5fxZkYpozG4MXZzUoRReIWbCmoGTGRsLO+w8FQcPwihAqR8IkRdpCZiFJf0hEQkdxJfOVZz8uLAtRd62vL8vnwsMBY+DZAc/c2VGF20EYk6uYDKcBskua7xPMJe2TItIXpaXbQgAFhAXgFlNakMt6Xr9yoNZsbQLgBpEwnMSiLQx/IHcNXaU7u9/1wpMZHx+5LdI42FKavUGKhv4l0n36MJKiU9yaCWoCCFOn5ljzQXpBgBibb3A3+wAjaPSgYv0QjQUpthIh9QC94e4e/xInfcAwccCEEA3M3wufdckC2JouseiKVKkUr5L8/N1tvoDtOBmxdR9MBukMui5gQ8G5yC0jmNHa7RVTTJrSiR8HjIFwIOOgsvQBAkwweuGUxbMA/eLgwmOB0AQAVAEmCCajeTgGFwUQyFZ9cG3r6UJkTSIBEtRKYcu0w6xs0pUgjQ5IREDm/AzUgdHCqz4Zlc9PR2ufIjKijqBRaU14vGRYApgKqYUQU3JihrSnavE1EimOIop9eVQqKx8XOWXUYIvfvZClaEIRmXK94HHwutQFSfoLbguYQndhMdl4rbytWDaHUBPidMvuK8pDgy0lJQUZN+c9cNUMFtefAlRuOuxa2oAA0uBzmAgVbA8HvEYRjp7NSqbWWYeSA2y2Q6nCWAcqNbAjo7UZmMjy2lPo5mhXFYwF9weQAONRCPRxcxW/UBnsEKqgwZFXIYKEITSxYUW9foGp0JwskIIBbs4fqxKGxsYmZCk5YUm1RsOP07SEX1E6IpG0yOqVRBUARioKIG1YEI/xlXCZ4LKD8AK2sm580XWZJyEz1PqlD4CDQmpVrnUYl8OfgdgYTTDdnHRgIL43F13R0qXcJXzVTpKcXJbEiBIAokpGwiVqzYh/SoorKjbNXxxYmvyBA6kYBpJ/4dKT4jESa82gcYrTOq2nuy90aRAasq0i2hQWCFZ3WZgA3tRbmCAIPSclkzlDAk8bV8wEdVFbchF8CTTuI40vJF8TIqldTeeqvOTadK3H35fevyQzmKHKLz88eviJlWpD6csRjgQMvENjXmzOOFQQYHOgtEFEC+F6avHIISTD0wGqRC+udFAmEh41MFgJitgxgHPCuz4AAN4QQBGuNzQQ1pertFzZ+a54nPTjRucgiDVAMNQJz5SJtsJaH0jw4CDqXHlQoe1G4BQNoMysE3JlMcOX6RCvIysicHcPVpZy/HvYERYJYI0BnoRSuS1epJfD+LI8tB/A2C0bJ+9KRsbeWZIANSsBJhqLfPsJa30Q8lWkxoJNIQkpxECNJB68AktF6jjNgALpU2kpb6Ak1yjYWkWYGFK0RX3Y1YSE2AtXYCFL6mCy6kVvvAjNp5Z0rWL5wZADDQVOXlOJwUGInDbvGRMCtQMNURKyhzQYiKZwliyPNwPadA+kGTWJMAqZw4/830JZqYm3teTn84JXwqDSerQpy+X8u96gQnJbmSXy8YRm9gAJjiZQKMBFkhX6rUUgwPAACc2i/ZawMvASO5MRgWEPy9Jj09aiJkYjQAWgbQCjYUADLhRceLD8wFXLQABfTVgLqurRcEu8i2e1YKuYABTudzmag7WeiScQDYr2qyvAAwg6MIJC00H4IUKUyrZo7m5Fpd5U0kx0wXgosY4qOrN0mKNgQSPC+EZ6R1xeVxnARhOYvQnASwBYAAhxLtf/2c3XxJDUfGZO++O1HmUkMYuNebfC0VakZQAkpQl1Z6sEBlSBwml/iHnO/PvumQ0SEdwWUo2F6bkGMm+1G90yXC4wVDTRnwjcZ1FBQAKfUW+vN6UJWE8t6MLAPKlGziU4rMqb+M5kbLVveEjqteakZWqQJr4AHbqvjQce0I3vW/UKDWLnaP48ieu+0CiBx66H67DwdczXKIwfyG1Uft9cLIvxRy0SF9QVVGBqW/JFL7R23xiIlXhWbQ9i1eZAmjAgvAPDAK/w5ELoRRs5MRxpCMFZiDwsqB6g/JyvtBlARblZXQ1AzCQ2sA7AsYDkEKqhsZHNPcBkMqlDnU6Jv+8MN/kKg1SNug8yYRP7bZFy8tVbj0AywLzwvPi/ZjmcAEZhnqLWTDhoMpFUqz9yfs/ql0WoHzp1D3VlhcV1Imly/QCj6XOO/XtT5KNhLJE7ErWQZIZGIPOY3HSG1IcpRircKQ715TgoZrygBqOoQ10kHas8qT6/GxZ1VFhDBiELA8bQy0GTEiVolUJHGyGy9eRWAsSytm5YuC9qlYJFqPeeyAZHFjanZ8V5c7qZ2679AN9CKN49+f3zHSzBx66H9sbRxau4VvZNn0GAHTexkumJCfqY1GYCgi1J7gHSKez54p0ZLnGKRRb2lUFJzBodS1PR5erbIpD2RazRwAIJCtNAAriXUIWV15SPFYhoEy6y+a4tbUcAwCqQHC/JhI92tjI8VAokuCHAVJnzpRYB4FtHiVtsLCF+Tp1e7YQgwtdZmFwwCLlgg8F+4gAimqyHYcsW0MXQm8TWB1dbJVnPG59+NFi0tAG6YgT+8ZPyvIwvtlxwvakZR+Bk9+UABRIgCGZtuDEdKXHxDZE5YaHNqnyswQT5Q3zI9EGoKpGbVlB0uTuZT8UQNQOhtb/rKRVjkyhktJg50iDHB5fl2ADgRVg0pZGvvjwbl++ToCPWFcciXKy9NMosFJggjCt7FsOexrzfP8MM/W+iQ/bdYx3vPJjt48/O/p78GrL5eYImKi0AWCidiUDfMAGwCrgIUmlPDa4+YHGJVeYxVB6Pnu2xOnO+maObe3MMKqibwaeFlSa4E/BWlQwHIi+SKGgh4CJ4HXMzTVZSMbiMQyOOoNpcxlRyr1wocRM6ty5Iqc+4vU4zIbgAD57vsSlZ1ScVFMk7PScymFccgYjCwpDMCGxhRHPGweTywYUivXX9EJhRFOip8o1IlmNCWLpR0eKrapbGfdV/0imHGAn6ObFSepKUNLkiarYhyIcvmx5BjCYquPZEP04XKaWZWRdmuBc6ZYFI+nK5zBi34f8s6Z+Fr4Xir2tUL5fJeSqu+ZkSuZJhy3ew8nHRo1Y2ds/9cemlZuByjb/DDP9vtwdn/6fJj5o1zniJwtYBoRLlFdVID0h7koWxjCEJVMEsAcADHpkwEjgfgUY9HsmpwoADoihRegmbFCL+Hf+9o8EM4HPBGADJgFBFr4UeECQXimBFtWhs3DihgZrH2BA5VKb7wPxFiY3aEFgKFj0zhqLJT7cuA0aF/EmsY6VJCPCa1iYa3BaA+EVVSpY72Hui0f8+NClVnmmxeN33RP67FWW4qosvyq9RJ38KSliqlRAnaXcsRwqcVb6PaLR+4ey9AtA6MsvBV2mLqqaJIenDaz/0D/wOPhZlZsTUhDG64APButA1LuPAwRYjmMK1qVJfUcwK1kZ0gTgKEAyY+kOAAWjNKccKg70yQRudc/1yVzPMO3CWwC4e/k1/vu/e10EwRInFPwj46H0k7hzFCmC2zdYaMV9oJXE7yuqKjptVdMMBBA7ueE00xFirKezDwRMJ53qMctByoN5JDC/cTUm0CiR9Pm2eAxoGXgNeK2YMofAXmZ8qAEkKAuD8aCUjOVmJKs38JQAdESFqMMaCcASqRGAEedBtZYWA9VkM+Q4mNBuAAqJ5rv/Y70X/qgSI7miI6m/G0aDKklCWmPdaFiaZSYgUxmljSjRNCHL05pMkZTvAylLP4xGNJa4IMqjFrShCS+ux2iSaZDUf+SoV35tkWRN7JMLxUpiSxePH0mXbBRz5iZkCwLSqa70z1zsJP/qoy+98gN/AKJ4zxf2jGbyfPHAQ/ej3+d7Rm4WocM4xVPblEjJVZGIBm5UTHqDPoI0BFUVfOZwQgeB4Lqe7OKF4Qz9MMqpCuaB6k+BV6T6bDrL5fosqOLEh7EO3pSlxQYzCKz0gK4DPQVApMrdADsxSMqiWi3BuggqUGBPqGaBQc0DJDRoMQUqltqDjmuIsLhNLtPh50OFCxWsaWBCuwUoKjApXi34Us11KqWIpFCrbOyBFHDjFn11sms0ZDrMREic3LYUfjWpuSSNocFOhS7VWEMf9Obx88iNqqx5hLHOYvX/gblNpkus86jtoLFQlRvZosSgooTlS901tPXoVx9qUCnd88V9AybxgE8FJ6clTzqwgno9zeKm65sT4w/ADGCDh5UdWgYAZ2kB/y+yzpFO9/k+SvSEboIKDkqzAINkyuUyL8AB14GhIA1C/9DiYpPds7id2ieEIUhgE4tYA3JmjgdDkUzZcDmqTNBgINoeO1YZXNft2OzGxetDd7Rq+BuP7cCEdhtQSA5mIskULHlSq7TEH6QFw2lvqlIUxq4LY3t+Bn+Usdupx8NzeLEbq6oT0fAxYlXlgbOXVNVGVmzU7VR6FErhVZnkSIKacgQnYqY5MLDbP3t5zWtbj956KEGldM+X9iWYqPiFv31dxNUciJxyHq1Ke8BUULnJTnGUQhDF6EQ1gwT/ACxwyMKBClCBTgK9pVLJDdILktZ/sAOIuehSRqUJegxACbNhYfEvlrqc/qhzJfANFnpFk6LOlvm11Rw5CTGKssF9PGIsQ0YOU0KJfC72vCpQUv75b/jzHf9uuw4oxLrK3ZGqXIdjYDLoDo6GJ6c6idV8EeVmjSTTUB3GphxDoCzzqM54MTBQ+kncou+GQyBSKZN6rCASJV9XzjthcZlEmhWOaUBx4FKvG89XdPSP3vj3j3zDxEG4hKg++lI/ivxD035cOvnlHT+U+yXizYTxJkLoGij5Il1A41wy0Rczf8b0E/zDF1sqJvKiCoSUBPetVIRvBSkPVqPGmxAp5uRVQAb2ghQJOovyx6A6k0qJ51evDy5XlJrhZUEbABgW0hpUbJSgDD0nPq3N86yH3nnfR1/1fH+aqwIoKmDVjyQwODLN4RNbah46DYFGndCRBAcFFlrMMatOfhpjLHFz2gCkFKPQaOAR4TELUTRIY5Swq0BHG6Q0w+chuf1Q6UHaAEx2Fl8vJ7YeueVAs5XSyScPBJCMhwIWlSJA3ET3LVdsUN1sJ3hOCQAFAitKuwABCKdIUZTWopgB2AJcr9Dx4KwFUKAqgwHSyruiQAu+F/hHwD5gTFMT58BmsE9oq5phxoMRj5btcesA9B6IvkiNoMGg+qMCDEqNJsBrxOzYSxmofVUBhWQKFMbcrcpklpCmMAUIvlwyF091FJtRDXsKKAKpsQB+/GiohVCsVD0i7ErBdoRlDDwwo6mXAiTFUKJYymRJ4CpY+sqLHn7kyMSb3YXYeuSFBxJUSiefOpBgomJ89AGAA8Ir+l3iM1VUKPDA+lMMslZAQcxSyqxtKCs8gAprQpGuwGSWSnYHzARDkcBo1OPBDwMBVw0+gn6DSg1GLkD8jY+wjLt644H7AkhKpcbpd7zyYzdO3GCHuOqAouKRO++O4hqI0iDUZYlYwyHFVngE0ZBJBNGQreD4R9oYQMRqv7qcEatctypGytbyduPpmCMdswOgiwHMtVryflCA5aADyXhgTQW0CLWeA2kETl4e/myKXqC0HNwEMRXAQFIURXUGjIQFX6Qe2uhHAKwE+ovywUB7wZgDpExqTgnJcvWICS3S2IGLzmF2xcrqj0qZFPjEYyfhdae4ZoCiAsAycaGcjEaxkqwvNQ9oKFzVCaIJoZZirEGPeEnZIC1RTxLXafwYtlhyyv12wm1cP8F9rhWQjEfl4ZunHq+9HuVTzxwqIBmPacOaSIICxiEodqBs7agAwV6Pxjwlvo4HPDCNRpJTFdVfgxQHqZECExXT/DIKQFR0ukmuVFmxXp3LBRIV1xxQVChgiQu2KuIVFEca30ie6LY+BBfFSpRAyg1+2vC+cfMbSWBQaQzR0Jw2HrE2pKu+yuNiY78Ay2EHkvEAsMSb6FSoVGQwGkEKqNmscNdClEX6Av0DYqorh2Z7rsWpjwpuLOwmeBYKqjlgRCrgKcEcF4CNYiEKwMbjSoFExXUDFBXoXKZYM59KdcRYAtnfEyv16rKCo4BDAYYScRWzUGKuqvyo1EoBijLHqcdJ8IDqSD3NSB/OXorKwzfuSWApn3puBiQ7hGIs0FYc2xtpIBwPNf0MfUNK6wBrSbGGkuQPKGbTxku9JPuJ4p3Batj2TrFbQKLiugNKPDC7lmi4iJ1oWF0Jx16mKV2u0FDQZOiPpS3xUICkSV1FeU/iugxivP9mr0fl0zds846vTZRfcWYGIpcRAJf4RLfxiE+VHw+IrzzmESXgMbBA6RpsB8yHNxUa0cALEzep7TaIxGNPAUo81ObCKKa1xueXhLHSMcUGYfeCaAAwGg37bOJl5phl3nvpo4/aE0++D6Py6ePX5A9ZfsXZGYjsYrz7Y98QqQ7feCgdhSeixUYdbFedUWXkEVYy/PmSqzWXG3sWUKZFXHcJY/Z+NXnfDaORik28uRCDm+7ao2nM1YrNTx+7oj/u3CvOzcDjOgQYjJqsH58oT7K3Rukkcf0lHleTgTxfXDKg1O479YbCgw//+cQVs5jFLkTnS29+Q+rWD80+X/s0dgSU2n2nfomIfiLe2q/ClQOeIXge+dTVWRE5i4Mfvae+d/sPoIzEC98/+3ztk9gWUNZeczJSWwIvJjCuYPmTM2CZxcXFxQDJeMyAZe/HBKDU7jsVqXGMhjY6G3anUKMPCw8+PPujz2LbaDxx7w125uZLWt4ej8hvfzn54j++deKKWeyJGAEUgMn4i3LlmEVbG+JES1ZS7G3AZgYqs5gWzc/f9yYrfdOHp1x1SRFFfiP5ot+f7XPdgzGYKVu779QKSbCIB0DDGFNQMnKINMk5seNx/tUnJy+cxaGP3QAT4hk1Zm7iwlnsiYgPqV5SYKFCgcu4jBLI6zCOYJrGglGI09jOLA5vXI5mslPs9uPNYneCAWXz3umMIjMFLMBIDBLu1JG5IbOYxTbR+h9f9/7p11xZzEBl7wUDShw2GrFOvWnpjAqV8thy8hnFOnxVoFI0ccdZHLowU8e+Z/ZXPxyhb9578gOGpg3AIL6r15ETzuIxLcUxpGAbZyuRdLTOYhazOESAYmrad9EU41o/VDtnxDU7kJUBk/n/2XsTKNnOqzx0n7FOzdVdPd1ZsiwbsLFkybqaLAtAAtpkAAAgAElEQVSR2ICZVx55gElimyTkPR7rsRI9jMEBYyNsgxYJCQ48QrAJK8DLsOABMcEmCNlY1mBL8vRsbA137rG6az5VZ3zr2///V52uqr5j33u7656t1brdXfPpOl99+9vf3juTqPpoCaBJ48aN1ue/5aeu5otP0569FZzyqAlm+Lc9ARxogjCrZo4oYbYvf1a3r8vUqf7gPS/cOIczjdGw8jd9aOyXaUxtCEBRW/c0baIQSxP0FEcCDlhI8rKC3JVTwfIrnmcS3zJ2Z2mkkcZUhunuYL0fjUnaiYrRy9SP2TTlSSONGyrMbHKTlYxuONlfokI1C05qGkwGDy+i+N1jF6SRRhpTGUljGwMJtJAkmAQibdn22l2Z4iTBpDfiR2nLNaQLn3zqg+lb58aNq93QF/bW/nzsl2lct9DRdwMwUOKqmrWqAlUeeyR1wdQ0tV9HXdcZEXHRVDhq408jjd2O/Gs/9tb0oO6dYIYCMEiKq6rCowbNhSMMBdfNSxbj74AZuHgngTeNNNKYzmBAcaP4NCXEVeAKjzAY9PIMgWHUam/o24+Lm7g87TpOg65i2pPOR9l7wXBw4FNPHfUSWomaxZqdwDCSXcZIabJyDYUCmqye9vekkcaNGjvOQ1H7gtXgJGglo2a30UjuGE7ZSRqjsZuu1pSd7M3YlrAkQQDAwIOUEmDSPw/zaAXx4DYpmKQxKXYLBFIw2bsxNgKSdpjcNspQAByTRNcUTNK4UFwJU0nBZG/HREChCaDSlfuEJ4EIUp3qJ1MgSePio/n8m+6xC6/4zMXeAH6TtES892NHQFGx/qa7b7E0bVuDH8xuqgs5ZSRpXGmcj7GkjGR/xb7aHJhGGmns7dDTv08aaaSxW5ECShpppLFrkQJKGmmksWthpodyd6P5oTuGopQfElkGEfw7KLmHEfcqlN71bCo0pjGVcdGi7ARvSr3y+JMzY1e8QWMAJF5IZBvnPwg9n8ixUmBJxKRKz41e4Xnvx7/z33i+8ROVUod0Ixq7XEUQmG/+6Td94i/HLrgOcV5AmQAi3IFsSKMbSsdsz49jzD25If/4zQ/d8XYi+sjgFxIsOPoBUSZBAkd/xpaBGxhUJoHITjHN4PLoEw8NjkOvlyHH6Y9dhy9zM+Rkxy/rdLKUz7vD6/VtcjIevv21h+977CfHbnAVYyKgrD1wd7zT3mKa4JpNxE2Vx5+87EXY+y2aH7rjo0TxP9o2akqlNxeKIBIpEAAmjKqln3l+8wK3mJrofOmtHzOche+4nNczDcDy6BMPYfEZ7yryfItsyx+7zla9QDOVNn/f71uUyYjruG6GNC0mR/5MWkx+YJJlBsMbxxr/fvT+Hnnrn171YzcGKFsP3hOrRx10H8sRBpiLsm2UQRyPDV+6kVyzE/WSy4wbhansRoPgfgSVR5946O2+b36k37epUOgOWIXvm2RZwdj1VSiw8H2LrBHgCQKDTFNMLarVSlStNgeXxbFOvm+QbW+/DR5f1yN694OfuCrHcKzb+EJzYjGpDRPbsCVjdEpbMqbdQbsNTFS4PlHWGv4MtgIWcjFAE8VUevdzU33MbsRuY5XO4ETOiDSEwlAnYwdNJIo00vWYul2HcrnetssALlGoUbvjUHW2RZtbRb5updwesJh2O0uFfI8ZSrudoyDU+fJkJBkP4uH7Htu1YzkAlBr0kgQDSbKPpNVeBW7VwzwU2duDwUrZ7QAztenPRDBJBtIZM1GRD0IicwKoJNMj8f1DpXc9+9dj15uCcL/6A1/RzPw37OYr2cugktRFVCDtQCCVcV2HstkegwJSlCgimptrDtKVjY0SFYsuRZFO2YRusrJaoaXF+rZUCfcxO9Pi75m1AKy0sYenKNRZ3MXzyGRCymVdBhfDiMk0g10BloFCGEoAUWlNMpVJggm6jC1NjIlMDmBKggn2I+cMOnEBsrN/QwEEQACvsBcIZqIqPOaIvcc0JmsrAB68kyDiissem9ZjtttgslcDQAKWgRQligx8Rg+YhtJEiIVTk1qtMi0sNIa/69mo2FDG8QS4yABbQeqC9AZgAnGW4cISjAZgslErUaXcGaRAiGQ61XWzDCDqeQCQ6o0C2VZAlikAS4HglQALM5Rzb7w7Tk66n8A2LiqSTEYNZprG1OeCDIVk+RjHFNqKqvpMApWRmEYt5WquC90rLGXASCTDQFoTxfpALE2yiEYzT1nHG+gbOLFVWgLRFYyE0yI95vsC6wCL0LTJaRJYBoRa2w5Ym8GmclSDkA6trlXIcXz+HqlQt5vZVhHaKTqd7Pf8/Js/9qc7XLxj8EepAhM1pR5gktwGqL6P5XWSIx79hAaTZDLBlPYcXhSYIMBUcGychKYyCib9cTGu+aE7vm/sl2ns6UimN9A5ENBIFJhAPwGY4F9EudShRjM3eEnwmSDOLc8OtBUAwaZMkcA61teL/D3AJxnQTKCHaBjF2rMZLHL5HjMdMJTFhTrZVkiWGTIg9XoWtdrDx15bL2+7PwAZXoPj9P/kvR//zks+i/Wk1yQ56yQJMvge/2oMNsO5sghL2w5GqjKE24zu85m+SLy+YMKnxyTdJBmTxdo/GvtNGjtG9yvf/9mdLrvaASDBF1gFmAFCVWLAQhDr62VqNrO0vlGmjGQkYBzzc8NUR+kdSD82agIwDh7YFKnMRol/xokO7QNMZnllhsEHOkyh4DL7qdUKnN6cOTPL6ZZ4LgGnQo7jDbwtqASh+sMRa5TLCqEY98WPExnUbjsMbKhG4fU98thbfuZiD+V5e3ngN1HrMhTY6JoYBRmOXNeWGGMkWAt0mPqD9zw3dsfTEMl6GBjbqG6iACaaADQqkoAbyuv1xj0J+zmuZrqD0K3ynWO/vAaRZCVIUUbTiLJkHfPzDfEFAIFnxLdYNFVMA6wC+gbSFugm1dkOra2V+fcI04qo03HowIEtssyIT/wDS1sMOAAZAEix4FKpKIBlbq5DnmdyOoXHmKs2mZkkmQiAbXOzRH3PYkBSgaoQhN6k1sPXz/iPTBKZJ4WumEVnwlIuCK/ayF4eTf4+GJkvayeWpyfTnW4Y3z52x/s9cDy0BJiMpjJJgNF1UU6mCSwGO0i8cPi9629PkdLYk/HBT755/GSRLtedAiyGOGXJkecbA82kXoee0h+UcVFa9jyDWUWrlWfdw/NNBgAwhqTo2nUtsuyITDNid2y51KWNjTz7TE6fqVK3K0AJADU7Ix4P7AhnMfQWVcYmBsUe3z8E30bPpPc/X6H3ftqhR5/JdgA0EH8vBlRMxTzyE0Y7Dt73E0rJOzhlxfoNfTx1mqpQYALBFd+PHovRn1EBSlry2x5RwZYXJv5Go0uO0thT8egTDz1PRLeZpmAWmUxAzVaWsllPfPCGOp+w0EfgE0EaBB9IPofycJ6yPXuQ6qyuVmhxsU6lksv30e+bVCz0qdFw6NChOl8HQivKuWAMuO9z52bp4EFhqEYJOJf1GQRIsiToLLgtGIlh5Bk0Tp+u0oEDdXkbjTY2igxAEGqVALyyMkO/07apf2aTjKLN72nNIDLyGeoZRv5fvxRTBG0ojqkX/J34PW/6nzue1MxQRjcDjoaXSGFGI7nYy+NUKOZqj4pJzGdfhx9+YvD0LVkivpg0Jck8BmCCg5ro7bGNtGFwj4b8dL6NJNsAg8CJi9QmDAzS9ZCZQacrTGeeZ1Gj6fDlYBWWFQ6qPLj97KxIibquLa8TMUuYnW3z/QIIcHswg7NnhV7S94T2gVQGVRtdi7ikDJ3E7dlUnWvT2lqR2UkcERXyfVpcbLIYjOegG6gERZxa4WeAyS8+nQ9/82SfQryHbZNiXScNrDqOKXA98tsu6UWHzJk8xVFMH/i0QcVf/c74Fz7x1vlJfyl9dOi0WpWRBJkkkCR/j+8VG8EC9XgC6JyP+ezHKL3n828ZHqxAaB8AC6QzXiDSHZqghaif3fOAjzde9Unj+oei+ji5SbKBZAAIIGLi90o7gYaxuCC8JAADgAxEVTANYo+IwfpHudxl5jELb4hn0cpqmU6dmqPDh7c49QFwLC42mIkszLeFzmEGgiE5Hq2uFZndVEptarWy1OtbdGCpQXNzLRZikYYB6KDTDN5mnigzv+9zRYpMwzAcm6KeT3EUUdhyKdY00rMZBpbMXJF6ZzfZexX2fbIPVykMQvq10/m17/i97/rI6B+HX12yPyeT0EImRfL3+H6wMVAuWqeR8vFUBxr7VJqiNBMFuKNaiPpZWfMBRKPgcqGqUBrXPJK6AU7uZKBfRukmqrKi/sUJbxghC6o4oXG9QkEADyo5rZZDhhlTv2fT0uIWra6VGIRyOZ9K5R6zlJkZl2qbRWYTy8sz7Jrtdi3a2CxQq+3w7wAy1dk2La/O0Fy1xRn0ykqZNRk218U83oBqtRytrFTI7QnB9lf+tkBGQTAPo5QlI2OSVXDIKmUp7LgUdnpkl3MUdjwyMxbFmk6ZAzMUtnswr1EcxvTJtejtd/777/nvyWOij6YsNGE5OiWYSzLYXbuDljLlMZgDE3cSoGAnACapjeDYjR5TXC/Z9+OHU9/Ls98CYIJP80HEGp/gKiB69j2Rsm5siKoNysZgIoYpBHjbDgfip++Z0jrfpF7P5GrNVj1Lnm9TGBr04suLXJXZ2hJl5o1ajlpNh4VSsBAAk50JydAj6vcNTmfAUCDs+p7B+sixYxtUKPaFpR8Gu0BjBpV1fE6zDh3cpPc/Xyav3qHYCymsdylYbzIbMco5IdhWS1x98ds9MspZfu+GrS6z7Kjvk1UpcPoD1vL1Hm1bbaKrBr+k1KFPYBimtOUnY5TFjJaSxyFoOqL0rmfrnO4EEWn5ESYyAJjEscExxrGaAMpcVoaV3ztPeTmNax6KmYBlkOzDgeELqQs++XHC5vO9QYqDFAIgQPKzAqY2CLQAGNHEF1EY6cI637OZhbz08gKVyxBTCyzQwuEKTeTI4S1mJa+8eZ0F1bWNAv/r9iz+/tChTZqfbzFLAUOBJnLkSI3qzSynM+sbeWo1M/wcZiodfr6drs3M5QMvLlHkh2TmM6RbOhlZi8xSlvVAb63JTCUOI9IzNllVaaybL5FZyZNuGWSVcxQHIfmtLgOLnstQ/tHvGLI49bYPEmxD/c6VKNOUa0aToONOYDGKsCs2Mw5L0xOln/uCts174ks4HQWY0UimOY2+KCubBpXe98WUneyRePSJhwZWB7hNSfa/KNMa/oXAqsxsxIaxDlvlcfIqcIFGgrQE1w0GYwhMMvSQXNeiV9y8RqVim8HghZcX+Gf0/ZxbrlDPtajZztHmJtiAxmAA4VbXYjq3PENuL8NlYmgry8sVTqWOHNpkAfbIoS1mRi+8tMgf62Aox45u0O+cbpO7vEVRz+OUO+h6rJcAYDTLILOY5e9xedByxXWaPQqbLmlRTLFlMKvRTIPMvEOR5/OHKjSYv/ufvvc3KGlsm1QGVs1/JVP8qwAHcJGdwGIm3dc47ExPbKvIqNec9JqMmttwnWSaI8EnrezsuRiYMVHNAdPgFEIGhFHoESgJN1viUxwnuGmF1GhmqVjscHl46UCDe3BwW/wOZV2MHvACk1MYeEvAfJDq5CGwrpaZoWB4UqHo0WYtxyCSz3sMENBwYKE/eGCLRV18pkObQQUJ/25t5TldwnOGoDtT6dKZs1UGtvc/V6YIvXa5DBmlHDNmI++QbhqkFxzyN1qsjaiKDsRYplpRyKwlCkKK2n0ycja3K7Gt0xTtJZEf0HO+889IAUr7PKXd5GXQWJQFPxkq1elOuJ9pP1MGYDCo7iQqNf1QaCy6wO247W2/sa6lYLLHYlJfDtIIVfIl7q0JaGmpTnGsMcNA4N9mI8MayMlTcww662tFWlioSx9KkaJY474agMGRw5s8ngDGNTQKzsx0WaQFQwEora/nqTrXZSZTq+eo3soywOiKBVFM7U6WTp+ZoUrFZQ0HZeHKTI9OnZ5jxoLnt7DQon//cpvQBKwZOkWuR4Yp7A6abVDY9ShqiW5oLSfsDGHD5etDX2HkyFh8W72QoRgfikEo7ssPKfRE6t+vi9SP3+k7lY5HLwNDQZkY6VGyKdAYXD4u6AYTUqNpCwYFLxQOI8cclojz1jaNRYP/RB0P1//9VITdW5EEE3g9UKEBgxgddARDG2J0cNHhw5vce4P0gh2rRszMASkJtBb8XjldwUZw0iKlObhUZz0GwunXX1wSGYDjU6PucKXn6KE6HTlYJ8cJ+ARfXinxZ9S51RKVSz32niAATitrBQoCnYqlPl/3g58JIASxz8SAzwStM1ttioOIonZPVG1yNusoEFrDRpdZCgKgIYRaIQyFHVEuB4jA9BZDoK0W+HrqfT1xjcZo+gPioXBF/Dv5PDATjlqSnpQbpYRcet+XuBus+aE7bqKO9zL1I6LyuBW79NMpiOzFgG6ixi0ixeEO4JEhRbDCQx+BJhEEFl+32c5zigKBFGkOBFLoJvmCx6AAADl2rMbgBL0jDHTqtG2uxMDJinRmeaXC36MTGKzi2JENarZyZNkhi8J4PKQtPc8kxw6Y3Zw8OUdzlQ5fxw90NrKBpYShRlk75Pv58ImYjBmRksFnolsmm9UQGtpqgEqWQf5mmzLVIrOPAYCQNgAWFTHYiGlwZ3NQ75CWy7BHxSpmyW+5VPntH4gnAsponM+bNmlk5CRH7Y0SpXc9O72DpaY7ngNAjI5eRKOd59n8PocOQrIfZqNW5BIsUpJC3iWvbzCbwYkMUQDiKZysSI9w8gNAwmaehVsblv2mw9dFaoKU5dSZGSoVewR7KM5z3EvGDml5tUy2lefyNLqRAVRf/uohOnSgQZubOfLqBhcQX/3KFTpzdoaqFZe9Jv/ma0SR26cQwBFEZFaEbmLlHTawmbMF1kTAMKCfAHDAVOKuN0h9EBBjw35AOqpBcMt2PbKgr4QRV4Pibp8iLyDn0Cz1T23s3G3sTipxTghNaiijOky6gj2N/RIq1QEDSYIJyrtgDmAWxUKX06AzZ6rMOiCS9rgXxudOYbhZUQlSwmku55GVEQOPFhdbVNvKs0sW9nl0GwehQfV6llnJymqRbrl5jXtt4MaFhtJuZ+j0ubKcyNZhFlIs9mmjlufHx++ZLTk+HT28SS+dmOcmQpSnP/q3NU5nYFxDOpJZLHOawgADAAgiTm2QpoB1ACDAXKClQGBNBlgLwER1w2swcwZiYR1XeMo5rvJEri+qP+q2oRRU1EfrpIltAA2lqUAbAeZAV/Hk75OT3gaT8y8SmNJI43qHYiBIfTDZDLpHcucNKicYI0Cy0a62medKD/Esk5DTDfhF0IdTqXTYcAb3KkAjYwXUamVYRwHDAeMoFPrsmrWMkNyew96UUqnPOsjiQptyrvXOX/6+Pxqzt4/Gez/+nX/lh/pDNx3ZpEee0UjLO1yxiaSVwWt2hT4ShGQvVsiHkS2XYfBA6gMgQckYIi0YyAATOn3WSjikYRPAAYYTdPtkZCz+F+wEbCdfyJxkQHHlsGk3MXSaEmMc1XKvpEDL2oj8Ud3G1sZXa9ygTto09kn84v/89tjJbn+u6IlBVQfDkTDLRAWa7ZCyCEZS3zbg+YWXFiiXDTiFAXs5cWqOU5ST7SrfGkJuLA1yrmszAMFp69g+Mxe3a1Grk6HfeNsfXvIJ8963/Pdvxb8//uRG/G2vadJfPvtPSIN2wg5Xj3SkMqZOYRiRxhaGmAFCjw3S8xkhsPoh6yIoJSPgPRntfvdrbTa44T4yJXHQkAaBvaACtPq237+JAUUBQjbBPgAYgxknIy8gTAy1ToIQnLOj100Zyo0ee/fv/+gTD1VGwQShhj7jAxMAwNpFvscWepR/C0V3sMUPYwSgkRS5s7fBxjWMGEB1B53EAXbjSM0Ec1BwprQ7GT4uhw/WqVbL06//8H++4k/dH/z4qfhc26WlnENvecN/oIxp0KdefFdry/KLEVdyMuyAj/xIjPCxDS712o5FYb0zcMMyQ7EM7u/B9yzmOpZIjaoFCpqucNZKBoMScnIVjzlpC2A0SWmV0ZLpjbLdA0zU1UU5WVSFCnJs5GhJ+kaJ5i/dHpMravRcStakuzaNPRO9nr0FE9i2kEOm5xJLszhijcu/xO7ZPAuhW/Uc6xqYkra2XmCw8fpi0jya/0STX0y5bJ8ZCLSPrWaOvunVZ9l232hkf+zX/tf/+ltXejz++bP1+GSjQ/WeRwfyDh1bQBOgT/fe9IHiVzeb9OKJf0G6Ad+JKSzzeYeCrQ43//n4tzREVaRG6k0KcRbfK6EWDAWggrQHwrECFGg1yodlTnLIni9NMSR4KCBKgobJZeLhdfH7G4mh8ABrWVqjukdUlWU3WOzLGQaZuBeSltGp9LOf3/kgT1PsYR+SligLQ4DFz9A9kM5gJiyE0RKqM5HGnhOIq5hl0mhk2C6vwAepT7XqsvbxqltWmNUcPFinTlesDT17rsIT8JHaHFhs0Msn5unfve3/2ZW//9/78xNxLmORH0U0m7XJNHQ6ubJJzX5ALT9ggImOPkq2qdNLjZ8XaQz+JrZJXq1FViXPnfAMEtBQQqG7sN3eMlmQBZgAgEyUkZHeZC3WTOyFEvVX6sxgtt4hWNZEp6zq4ZnkfFXtKwqI7ESa1ZYzUVTcKN3IzZ99Tdz86W+KuWFQl6szZjJiMhsCfhQwlYZHWh7Gt5CaH7g9br7/tq+O3dmURXwN/rucQGUnuT1PDEwiBhOkO+wynW9y1QRggqlmGCmAPh44XiHKKjBB7027bTGYYHbrTLnDIAJHLL7KpT4ZWkRLCy1yMsHvfHgXUhySzOTYYoVKuQy9arbEo1c7PZ8OVsuUMXW675UHabnTo2+aK5Op67TgvIerPIjY9UhHdzw8JVsdUcmR1nwELPnc1yNdtFwy9kLy4YjFbJROTzhpob00h3NpTZWeqEBKU5Q/TxrfOOoxSf48mt7sNFNlmoJZCcbmAURitQSdKPZ90pDyIN2BEGabMo3UiFkKPiUs/dXN970uTlOhax8MCDhxjMRKGOgdVjBId8AooH2gyoN+GVjwUVZeWoyo3clTqdRmARZdxBgfgJSn3zPpay8u0sGlJjtZUcFB3w5A6H3fvnvLygEm6vswjKlaylHWsamYtanb86hayNEXTq/TPUcXmJDkuz06tjhDN5X/NX1x9b1dN9/PBd0eT2SzWGiNKcJ8Y7ARgIYfkgH2gmpRu8/lYlSEjIzNOowh/SwQdJs/8SeD16UrDFBkpCg1kSsJZb9HxWcSy5mWaPzUN8Zss1f7i3sBxZ0AQEFaziKaz1GM3h6ASc0lBh5pFuKcE0OXDI2aj9w+vQcJFs6r/XWJAXYCIEmCCSIvdwKjaQ9T1uBWPbAk5rHCVwLNBIyk3shTve5wRzFYC1ZRwLhW28zxik/bFE5VgAk0lqWlxq6lOIj/87Nbgyd+eq1Ouq6RZRmiuU/X6JnTa+T2fZrLZvi83mp3abGQpZlCljpBSAuld+eq9q2eYVuiOdDUqb+yxfoJpzA8uqDI09u8WptdsOgB8hod8utt9rPg+6DZ3QYmpFKeOOGGdROiTLIPZ/QdnwSKUROcYiZgL5NYzjQEUhatmhVgEcumwLJD5BiCpWDGCealqDkn1SzFamQk0qGy1Ff64rrN99/WmsoDtQcDw4xGF2Yh1DyTUqnLw6JhVGt1hBUd9nc4Y9HRC8axsNDk4UUww2VsUcW59ZZV6nQtdrPC03JgsUm1rRy951v/YtdOAlRzDCkj9PoBHVmo0BfP1fjnr6wJj4xjmuRkLKr3+pS1DILG8rXNJgPNoYJ4Pfcc+XH7O171b7mL2IMwu1CmKAjIRidyEFJ/o0m6bVHmgBCieaIb5p84Nr+HTdukzrvGX5cO0Ej+NmloS/bhaCNaSxIoshOGNCkxdtKkt6mIutRHtnqCnWSER1DLGAKmdY3iep+oIJsFW33S8jZx5SemAeAwAIGpNLzxd/hURHwNvi4t0B+jGvuSs1bRiwOggZcE3cToySkWOpzqqNknOFtmKi51XSG4QohFPw7AA12+Bw80eEzj119YYsfrTUdqt+7WXxFpzsG50uBnJ2PSmbUG3XXzIn359Dq9/vA8LW+26N5bDtDZRps6fsR9N6ZhUNY0yDIMBpbXzFVoueWSH4S0NPcIv10DqYeEPY/1FAAMD1vqejxYiZ20bZc0U6dK9rVh8yf/bAxMiLWXCTqHmIQ/BAX1JxvVSNTl6t8ky4EYG09oNJyGaP7ibTHNSoYBlgL9RL1OVHjagVhFYMlJbVDLwERwPXQcA0jaABmPqCat3mWLmu95zRSi794ClJ//i+/adgO1QJzkEGpY59Gng4ArFms7kb5ARwGoLMw32D4PrwoGQWOuLJryMOMEC7TQBAg7PgZFLy406Gcf+vgLY0/iMgJgslJrcab84vLm4A4OLwhW9Zoj82TbJh2YLdIL52p029EFyls6p0KObVHLC+ibF2fI0HX60nqdqlmbvr7VYtLw7d/wYfqR4x/hIdSw6kN87S9vkdfoshNWl5sZFmZ/kQ6X30+nfuyDO/YAmoKhaNsaAME48LNKXZKQkOw8VhUc/DNpwbo2rQwFgLDVJ1rIEdV7gmWg/IWUBimOLnf1AFws+eX3xO0sMRgHNmd1YOOaS1rAIu3YQ+372GNlY2Wvx2IsJ+NxeViNcUQqhNb/fK7P9ngAiWmEtLmZJ8PI0fy82MIHC71pFnhjX8byyYX3pCvcs7VaiW976uwM/c47/tOufJr+75/ZiMFGFjCGUSO65cDs4LKTq3VCpUcFmArApdMdTuYPo4gOF7KUz2VoMZchW9fpKxtNuv+mRfrqWp2+uF6n23SNjh36Fep4Hh0u5ekbXz3Dt3vqzDplTZPcIKCMYdBzP/Ta874mZiiGNsR5lIyT4AKBNZm+tHyhCST3FpsjDtmsPhR2o/M+/P6L5r987ZdwgHjQDI5BxSHCMQH4KjApWYxQTYoAACAASURBVGIjoDLlrHWFCIvSHMbtYUYKRFuU2W3RDs63y03j1PtJjOL6MRQEmIYjB0crMMHoxFYrx8zDskWDHNIaXjoeGOS6JoMJKjmY41rfylKrnaXZWZdyjk+9vsn2e/TodF1z18AEzMSR6bSesMK3JWAATLquT2fXG3RiRWgodYioyDDCmF5e3iTLMukbDs/xZRs9j60oZcei1XqHmn2ficPnzm3QXYfmyDJNOlLK02dOrdKTp9dpxrGp6ljUxVS2C4AJJUdAKo0kKx2uSg+BzcWSzAPpS0UaT/CbRmLc4ajfRHUhn29U5D6N10A/0WBaA0tp9QWQgJ0AYDrBgInw9+tdHDiRGsGXArRe7YpJbv2INLSA43ZFk1MjLkNPVUwCgOsDKKqrmJv9Yo3Lwp5cewFb/ezs0B2LjmBUbzCeoFjs8TR5CLAbm3l2xaKMjBWirXaGOj2bsk5A1dkul52jaHc+GJKlYcRGfTjQqZDLUCA7gHNZiw7Nl6mSd/icqxSzlMlYdOtChQlBs+3SZ15cZtPbq6olyjs2+VFMp9pdet3SLF8HusqTp9foWClHX16vk1JWZzMWvVBv04l33HlRJ7Ku2IebcLwKa724Aio1o/eECo+laVRODGl2E0xGxVRumQFIgGEAECoZomIG2+EpbvkCRhdzUmTtE+ss6EXIy1WknjC3QS/R+tL8VsqQBq8KABn6ymZv7CH3dUw6/68jQVHi6nqtJBr5rKG5DVUelIWxK4eXEQQG6yqo9iyvzHC6BPNawEBk8JZALC039YgZDKo9eAv81j/8/Sv+FFVgAgt9Vw42n6sI3R4MhBj0dPITH+oAkm8+LBb6dd0+2ZZJrzxYpblKnl4hBy1BiPUlEPXCiF6oNZiZzBazVM5YlDV0ansBi7hIc4pOhl56+x0X/XpMW9rnRx2vClwm9fpMKgXH/KE8tOKrTuWpCwCGWpDeF28gWsqR1uwPbMPxhsv2eo5ZIcLCn6LlTKK6L1KhvNS1kA6VbVF+Rul51pmyI7a3CBeWXJHsHCYJMGo8gdo7jFQnjA2xzybbY6DBDh0ERhOgygMdBZPpN+MSe014YHTfGvvwvZwAmHhewCJrdsLyfACHCkt+qDdaLjXdPrl+SL0oolvmMEslYkCEwQ1sBT4TgEm3H9AbX3mQVjdb1HA9OrnVogZ8K3mHio5Nbzy6QBnLZOb8Hx48cEkvid/VwIftIweGV1D9OoKVi+uMNv2pcrKWqAQpMKkHMQ0loykIZadnB2xMBGYyqwlBVea4Go4TRFdUdZo+0VxWDKbRNAEsuB5+BgjlxBJqLiPjOHbPs6p0X8beAhQ07qEMDKBAQPOI4xwPUarVilSttlhXQbXn1OkqdxMfONBgIMGcVgi1ABOwlJsPrrMJDg5bGN+w1uL/un/nReIXEwATpDK2rKxsNbtUzDvMRpIRRcLEpqIMhiGBBqlRxjb5NtBQAAz/38oWvXpeWPCPVcucAi1mM1TO2lRwbHptMUuPv3COat0e5SyTFrIZ+qPvfMUlvxYTTEKXoKBL9sH4oAljGxIegEQrEG+MTS+iWVvnn4FBuGwUXNTPAJNo2vZXyUXncccTlZqiJao5gXS/go3g+7ZPWtYkmnMEsGx5rFhpWUOIuACOXsiVIkzDZxAytcSmpOmIeA9VeZDOoH9HsRREsdAb7Nup8FIs0S2Mfh7TiMmQ80rQOYxmwblqm3cKQ5x94cVFbhhsNDMUhhBwr6xKp9IcBR5hFNNMSRjRFGNRocCk7wUMHiqWa006UC2JzX4ofc+W6DBSIz+kv13dpNuPLtDp9Tr1w5BecVBUi2qNLt/HLTMFNsKhSPAHbz56WW9EHUwCLETpJnUvImvgJyHqorITxCziIAqmxou/wFaycsp9XYINdBQFJigjV0yNZu0pS3uQojR6bPBhAKnLNye0EfhPIGdldNEE6IaQ1QVIzDuCweB3aBZElQcmuJUuaaCEuL+mP4UbBCeJHtdeRPmVT/+dk8lmQJL7dRSYYDUFNBWkCGtrZZ5jAhs+SsEYrdjt2Gxgw5Q2dBxjFIGmE49vBFvBrhzc/nJjVIAlHpImzp1Wp89gUm91x+7dTOzDXttqM5jwbbp9OldrsfkNaRGE2288UOV+nKOLM/QtrzrM9xeFEesqz51YZfaia/plgwlCZwNbPExZUMVp+KJCI9eXMngASNb7EacyavEXAMdD5dTUGFTU8jwwG+VJ8aZtjQa8J7DN43VlZMMf0iBoK6j8QCSDiQ1DaRzJYDb64jo4bmAoGEqz4fLenkGdDX6W2fEp+fs/JgHAtQeURjN3NPkz1l0gzVGBqfXnlmeZwaDLeGlpi/9FeqSGQ2OuLA+hjnUGHGzqg56Cxj9s/nvkrbvX/Of2EixKjmHMZeTenETxw0gw2oWZArMN4tEMGh2sCoPeC+eEEa7W7Mifa/TUS8tcIl6pd6jV63N5GCXo33/zkSt6DWy9V38TnAdr/YiqtvCVlE2NZmzhKWkHMYuuG17MX12Z2gyAAymTJipAGonbsDA7bWVj+EsADhDLYLvXJfKudsXPm544nGAxoHrQWLBgDSwOjKQbEtX6okFQ04SAhcoRGAqs+tYUCtl7IGC1Ty4+R3qDQOqCSffwn6Biwz+7GdZTsLrC7dncYVyr5fhn9PDUGw61OzZ7V9hodtO6mI1ymTGJnYQJrUCZ1FTKs9kQzz0KxxlRVa7BUCAEDeZAhTe8cGm53u7RQilPizmHTmw02Fl789Is2aZBv3pH5YrffMxQkJ6gmgO2XbEEGKg0BgzDlyPc8BrnbI1mLG1bqo/70KSpJSdTp8EA62lzyrqywQ+CKv6eYCBIWVDVgaaykCVtLitYTCsQJreFHGmh0Ff4No4hjHG4DRpxcXuwGfwbTNnx2kPdxgPtJNYYDJC6wGuiJt2jrwfT1TAYybQi1k0g0GKX8MEDdd6Bs7ZWooX5Fs3OdmmjlqNu1+QNfpg8v5sBn4nyncDh2k44X+dlCTgYESiR8iSj2e6xBoPbvyzt+iv1NnlhRFnbFI5at8+azR++5fLTnGToeA9DH4SOAmYCEGhw+iLe2GAYtb4YY4M+NwAEdJOGH1PNiwdMZD6jM5goINryY2Y701Y6xrBfftGgc33ZwxPEQvvAWoIVl3URTmlQwGlLwxtSJfW9rQuAgZ6SNUjzI4rRbAhPS90be8z9HZNSlOtoREFoMZeKs9k+OU6f2u0sayiir0fj8jFGDyDOnZvl1IdbsjAsiXfozLJTlh20PZuaDYeWV0RPzaXGD3/idJz0kiQDvhOIriQBZjTW5fpPFclTDbezpL6C9OnmA7PMVrKWSXPlHBWy4v6sXWImg+cA2/yBrM7GtnNuxIDgsf1eo5V+xHpIxdYG09fUHuPFjE4V+LtC8fuhDjPcfwzd5Xx7k/dj8GAkgAfQ1dQEAMRSWynYpFVtvkyDtwSmQDXBzQ9F2oN3ZlvuPrHFbhOkQRBm0dPDjGaKAlWeq/11OaH2FiMKBZfFWXQXA2AwgLrZdnhYEhoBT56eo2YzS4WCx3uK0d8DLaWQ9xicADJY1nU5Ad0DoqkCDhpxxKoKjjKzJQMpTDKU8Q1jDXA7lJ8ZRByLVGMhdBLMUMlnbfrSqXX68D1zu/qJb+KEb3kxOYZGB7M6A0cgKz/r/Zh6kSgNKyCp92OqONpgILWq6uAc2/QjKlkaC0LY9C5K0FNG4QECfclSUBZGCRj/QlTFoeBUpy+EWICDKUcdoMwOk5snWU0nFGmOJlgP+nu0VZdo/INon8ce+fvL+a+qGbDVzLHVHpUepEJoFkR3MXQWTKWvznZEBSjWaHWtTL2eybuLsXs4n/PYcm+YEW/3g00fXpTLCZR/UeJNln4VMJBkFwAEmNlQ7VHayGi5OBmo7Gw0usxESOooS1KgRWCGSsf16OPfd+uupw86NMCMIcRXVzITfICu9iMq2EJ0BXMBLqB8DDaD/pymH7NwC2Bpy4ZCkBHVKJhXQDP2kPs8eKyjQTH+xWtkJiLPm24kGAdSmZzO6Yy4ni7ABSlSxqDY0MVt8NUJeVUkT3vDAWxOo7FtD6Q8ciC1agZUfTswqQFQSrILeXW1xCa15eUys5iTp6rcywO/yddfXBSD9jIBvfrWZe5MBpjAHBddQResdh5ZIOmUdRIAMgomowzG8wMGI4CJ8rIk4/++f2HnB72C0LuB0BIBCnVPiLOQCZDS2GrGrAQbfDhDX2kr5xuJcwdWk1pP6ClNqaHgXMP12t6UMRRoJx1f9N+gQAYgWHYFU4HXBD/z+AJdmNv6Mj3CgZaDl/jIFYRzlnUWKdhqzFimrMrDVcSr/HURgUn0KjDeEYOUUP7lmSetPKc7MLDNzbX5LtH8t75epPm5NhvdMDMWy7kwK7bdtnlOygF879pswb9cIgbWkRRcYYefdAgRnZ74eE6mRyqSdnzcJwYxAYwmgcluaiajoZdsYVADEwf7sOUsFFH9IXLk1P2FjD7sQI7FQue1fixGeGjok9PINrTB+YDKUWEX5tPuuZjPCsYBlyucxEpPQ0nYFCVgDWxE1ND5ohgMJCMPFBgISsm61FLUp1M7FBg9lR2V1z9QvVGRyfS5jKyKJGj6A4CgGRB/BFSAMg52Gvvk9ix2zy6vlblnB6zk6NENqm3kOTWyjZC9K4Zxee90pDBKcIX2Ucht7+UCy1DnlAINQ60FTTyk8p+gkVClRaPX2ah3riqYIPR2EAlHbBCzcW3FjYYrRXHeRMRGNjAXNnmyyU0Xw6xj0TzIw8f8mM+nphfTmW7E58WyGzFQTVVAYDVl6Rd/adX4hBcKpgIE7oeiaqOL60FTigEYQF8cpIJ00WbYaiyaBnU5uGnqhixNSlGufcqDkx7AAK0EfTrEJ6ZEFOkhwXWwTgML0p2MTz3XJMfxGYywlBwMxTIj+toLS3TTTes8RzaINKrOtqlWH2cCF3V0Ek8f2kd+pBlwUnOgsuYnMyXlP/GC7Smzug5KyP/xWw9ddfqr66QxCMw7GvfoLDgal4R5gBhWjfrxoOO4INM2mNzAQGYyGssCYCxFS3yPitDhnE79WHQf4/upCqQuoBLYsQOmgdkoczbFeMFLWWEdxjVmbAYM7qmAZJKTs2ZjKezC7AbbPlInWJOht/Rj2rYpbQpir1R5MPcE4wbUYCUVEGWhr2A+LBjK1lZBrBzdFBPaYLF/6cQ8V3TgrAVjyWc9vh1qmdhnjEHWpcLljZ34V3eOM4ZwxLuVLA+DxZDs7ZkUlWJuW5VIXf+337Q09jhXI3iNxmJWH3QVL7sxOabGVAnAoSQQeE5Q1QHrUGVzN4g5FUKFCNUfCLSdQAAQKkdoZ9mcNg1FE8JRnBGgwIyi7pOWN9hBG6PcJRsFwUp46j30FXRsd6SOUhOlZm3R4RQptsS0N80QIu10xSRGce0ZCuaeqMHUlJhwD5AAc0GXceCbNDMDR61JTjagTifDOguYTG1TpBsQcSHAolv5lptXGXCCQOPF57sRSHFgpw8SLlgr0WmsprfZO1R4aCTNwfWvdpqTDAaUvpzQxp+mmqx+mhr1sEAoo3HaA9ObKhFXpR0fYi4qP21fCLdeKHYdowIExgOQmabmwBfvvTsWTlddVHRMfbibFcDix6ThGBXBWJR+wuUxinuR8KZ4fDBFT0+tz2DDncaOEE/0dx6l5vMP/MuxB9+H0Xr+gX82fvJfpyrPSKjZJyRHGiCw/BzvbOznwbwU+FPEnuMOlYo9HkCNUySf96nbFQCDcvHWVo7HQl5BnCSpcahmvzCMWFwlqZ2gWkOc0gyBBjZ6FTDHKafsgnTSQle5lmCC0AEWvOCchEZSsEQVAj05YB5bfSGugpkoURZsBX/HzX48AA+S5xV35gdEK27MQu0ZN6LVB+6eCpqCF1H7mjSwmbLEhVft6IMdIlyxOdcV5WBHJ83SGVR4bEFPsg9oLOsexRj7iPQnyUriiHQ9876xB9+HoemZ3xizye/yVxy6/9uVHBmUhlH1GYQWs3O2Xs+xwW1jvcBjCwwz5mHVWCvK09kcjytDkNFecfMadxz/09/7oct6n//qHZWbiP0n+cHAJJSFIa4qF62q1tiJKYmVwvB543YAkmT5+HcfOnjNP831Y59+ikdUn+1EtODo3Dm85cUMFpqs3qz2Ii5sQFsxudNe9PfAs8JjVKUPpYymQj2mvKVRySZa6wlzGwxy0xDoY9JXdaIzHTkHRVR14lZIMXSQdiAs9dgcWDSZlSDY0GbJoUtwxOrCh8LWCC8aumfnprHb+OpG8fZP/eZFPsDrIb4mGwQRGPcIAxs0FtjscR0wE3Qbr64VWVfpdG1+X2MDID5VMOV+Y6PIa0jLJZeXn2P5l2NP1jUuJsAk+v3ttwcb2ZowskCFYjAwqalQ+su1ZiYqGO7wQTvn6Mw2ACZBJAACKUxGpkAQaFEJAmvBLFl82MIMB8AR62Vi1kvwPUCHN9bbIiWqTEHa88K9dz9+shNRCS+uKN+UkfSVoFw+Y+GACMaBlAYDqMuWSHlCYa/nbuItn7SmR1pZTmrDfalu5I3+YLX4NMReWpT+8H2PPQ8ETw5XIqmhbG4WqNHI0cGDm1wFwjwU/Ds31+FqzuFDm9z3g9QIXcaFnM/mtib0lFijcrnHu5KPHtkYe9xLiQ/fu90Gb0vWQTRut4E8ocrDsNGDmSDlQbXneoEJKUBB1rbRj1hQxYfnLBr9wDIsouVeTFVH4yHuqOrU+hE3A4o0ibhxsJzROO1BIQP/ZnkaYsygcywn7Pyfv+v4vj5LekH8pgNZjR3EfMC8iNMbTnGEjVggLw7Cisxtmz5Xd2JTelQANgCevBwfGUkHIOgfDpqmDQxgrc9/674+Xvz894ipbfCcWvnBkGqkMzCyYUxBqdRjTWVlpcKgMTvb5mqQmjULu75pBtRq57na0+rYTC/xPcrLmIQPLeWllxfoJ/7wB67o76bAAEwj+fLw1kga2kbdtdBZAD7XE0xIAQrStKM5XeJ9zKABUVZpJnDJQmOEnnJT3hh0EKOkfMARfTtc3QlFlzE3EcpFeS+3Q1bFi/u8HAqrCKQjlszQihCJlHAACrKpL24GvBKDGQd+h1QHw6dRGWqHIj2CSAtfClgLLsN94ZjynV+Z2Lh3YpJ4en0FWRjYFEhAgOUJbbHOJ+7qaoXXj+L7c8sVZhxraxV22KKyw7cvdNiGD7csmgRh0YebFp3JWJaOQUzwqlxpABRQ6Rl1xCq7/SSnLFK66w0mpAAFLN6Vq2QwruBo3mBdpBeh9KuxeafpRcxUTnUjerkTMkDAWQt9BOkNf8iaGqdGEG1xPiEdQkm64Udc1PjK8f3JUk7df3eM3UQbvYh1Ij+T89iCj9EDlrQVY7ASysdwFnfFeECo0zGqOMxqxDY1pEYAIhZpgcCRVLJhvf+HS9tOltbnv2VfHi/xvCed/Lv7Fcfh8tiDX0RgDooKMBOkMxj1iEFLq6tlOnqkRrWtEpXLHer3LP5ZWfe7rs1pjufbdHa5TLoeccqjgKRcdiHO7ix8XGQAHP6dSIFupsSQJUSj0xtUeHA9+fX8rvzxrjAY8m598mnti3cdj+Eed3mecsQNg1Vb56HUvGnMFowFlc+mp3Gp+WRX6C1zGTQUauxLAYisuxHX0nm4EjqSLZ37hABA+zGgLUEHiuX5sPaYaR96QBM24lhMYosj+cmUM8S8WV/4T3gyW9nmnh9Nia8oEcOCD4EW4FOxKIa2si+PzvWL0u2fPHgpD/7wfY9pjzz2bXFW2vABEtilAyMb2Ao8JRic1O04g7Jyudzl62EQEzwpIQZRs7irU6XU48y1tpljQOn2bJqZ6VKllNjAfoXxq3dUToxsA0aCs2f/JoMzHA5ZCKg9OcsEAix+RgqD38CTBZEW36OCg+tFPCtF525kfA9AAnDMZ3WuAlmSteiSBYHZfP4N+4ulwHuiwASt5rW+YG5sm8+JLuK4J/pwtKIhhlbHwh0bYwAVKlxw1UZsPRaaiyd7e1BOhg6jBl1P0Ahazz+4r44XP98Jr+N66ycqMgmnLBZ4GUY4sODbvOzc5olt6OfBGtIo0vl6SI3gUcHlGAGZy/tkWiE1Ww7ZAKIZlw4sNhl0oKf8xB9cmZayX2Ngt+tJe70jN0L0sQKDNB5HAGs+GDuYC4xrcMJytcfWWDvJYQI+hikFw2FMmIuCAUvoCcJEONjwYdfI7qOZqc/deVe8lNPZoAcXMYOuJ1azsrcEyrQl9A82BcLsBhG2EbBZTUMZeK1HMVIjkxukhms00D9SNjjXZJetF+xYtWg+d/+XSq//9GvHLthj0Xzu/qeE3Xf/BPp30HkMFy3s9NmsABWUl+t1hxkLmAtA59SZKqf/c9Uup0lbmwW23OfyAQ9iApCg9+fQwU3e17Mf4+f/4rsWXNda3axn2axXKnYZJN/94Mcv6sTVVC/EyfuPr2z240Vd0ziNAfOA3wR+lKKlc/GiI1kLdBKwFO5l0InOdiOWAnISbEK5WE89g5D1SY01yKIp/Cyv/+wzex5ZvnTX8diX4uuio3M6CD0Ixwi4sPQWVwAGRjrysnPVKCgPQMsXs09kqsfAA8NbRgynjl2ZEgFs3rEw9vjJKN3+qT1/vJrPPzAZEa9CXO7x+Ln/8d0vlErtW6CXYJYsLPhJ1yzcsPjixlfPoCOHt+jU6VkxT1yPaHGxwWXmbDbgvceloktnlsuCyZRd2qznWJzFvmOkQb/1D/5gX3yC/vjv//04kwl4+j+e/803iSVmna7FXdaYUgd/DvYVffC7/98dX5OWbK5CaRcEAuVhpDhtP2Ld4yw0EU0wjpYvvhdDqIlHFnTlDBSwm66cO4S+HlwPv0NvUC+I+TKkPro852575ukdn9j1jq/cczwGSwNrAyagmxqvC34daEUAxVvva4qmP3UIIbICHCISjYG8CTAUwApQseSkN95PEgukxQEH03n7/AVfcen1f7Nnj1fzuTdeU4p/JccCS9ObzQKVSuN2eXwaa1rEugkqPaoKhA7luWqTjW7r6yUWX9tthys9KCk3mzkKQ42/AC6tboZyjsdjIz/0PX+8Z/9u//Q//lAMLWirkeXiCsx5eHseXGzyyAYwMIzDtM2AvMBk0MRis0rFfd0jb/3TL47e3zaVtCKHj8FmDz0EFZ5lCSYIpDxVLLGS08ZMuX0TKQ7rjIHwpCB9yso0CLddc0WOCg8X/jjKPfz1e/amnnLy/uMxUrsMz8oVvwOYQFRdh2tYAgtXcixBxaCj8AB2oCx+54rGQLhk47wYdYCSMaGs3Awo7keiwRD9P7fnLqr60Xzu/j15vMTzGn++e61/JxkAE+gkKtT3atg02AV8KjCwgYVUyl0GmGYrR3ZGCLndrsXpEW6zsICFYAaVy32elg82c+hQndOl9/z5d+/Jv9uPfvSH42K+z53WphmxBoTXe+RQncIYS78imp9vcHd1zzPp2JEN6vcNnp9bKXe/8LMfG39d2mj797NvuCvG2MeM7LbX5CwhxxCjUVUHPqo9/VCkL/CdIDVw5HAmUx9WRLOGOBGbvgCjzX7EugxSJj8SzOW1e4ipqNcPzQcpHmbBoMqDsbFgKRjT4MoxDfDazN3TEN3CaP6zZXWHRCkYIKK8amyzL5miA9kSGgzJ40tvr449j/NF6fVP7Jnj1XzuvrE31dWOK339jz7xEHpnXiY51gDT2PB3QgokRFWdGQlABr4V+KjUDJW19TKvL/UDi0wjoDDS+XJMvkc/D0xyjUaWq0fdnkUFZjARf8r/xtv+cM/83X7qj78vxmvaqud4St3mVl7aP2JujLRlG0G7lZFLzlw6e3aGtyei8gUBu9nKU6nQpYfv/6vB6xqr4+JkQhrTk42C0FBkI6yYFStXaUBoxYmGzmN0JHPXciSqRDxWNRK3g1ALBlOxBJg4cgRik8XNmGesPPeGu/YEgn/5+HGZpQBIiLWkGvfaCPc8Wg0AlMhyNmSfDs86UcDB7lketEuxGvEo+3qYtcRyaj40F1sTYAKPytin7/m/ms/duyeOl3ge53+ue5GdPHzfYyewNoPkWAN0F2PdKJywSHfAQnA5RhKgeRC6AeLsuVmanWkzmGBkAbqMMbkNchlABfNlMXQJzYIAmqOHtzgFwjQ3gNTP/Nn37om/2zt+50disC/ePVTs8etcWmjyNDpDg0YY88rVRj3Lnhu3a7HfBqwF82DW1sTAa8zhPXl6+4fhGEPBSSWnGJAhtmay4Q0nkkr3ASgDjwq69S2d9RZN6iwoIeMTHufLWk9Mwu/4ojKEtAg7fPw4VqNF2CSHdOrOz10fofaLx4+j2VoHgKDlgHuWdJG6lS3BycR8aXEZTH/K+IvXdPjuhrDYozkQlmlMsQdTQaoD5iJQWHYWB4OVpHDM0o9eGjtJhq4b/0fx9r/58NgFVzlazz/wv0RR8F+u9eMSMzrzptLtnzo5dsElBnQU3KLHzYEBeZ7N09oAKDwCMuPJ3ccBr8xAA+HZs2JzIK6HLYKYgg+7/fxch9MGfCHtwYkIRy3e4AAd0NNiwaN606G52Q594Lv+5Lq8z3/hE2/9rOcbd545VyEIsNmMz1P73Z5JuZywLsxVsfw9R55nCJbWM2lmVriLdYoYznt9i1kXhFpUu8BU3vdtf6bRJIbymqef1vAJDTDxZKrT8GIeC4mTzZZbAQEAGgmdRSexKEw0FIoxCLhNRwqZnqySovRqSo+L8roAgGCSi6Uo/Myd15atfOn48dgLeaw0P0cAx2xGCLH4Xd2PuHzO+4cM4avJy+2ISkdipmEIoSVWS9TRs1OwRKoDM5shRVsecZCw7F9BRFH4641nry1bweNdLzAhUd25YjAhaXIjPoZigBIGJtUbOT45lFcF+gcux64egAlmyQJMEGL+LNGhg3WuBqH8zB5HO6DKjMsDm7y+yWVnfNDivsAKcAJ/4PE3xz/2ez94T/fDZQAAIABJREFUTf9u//y//b34xOnZOzE8amm+RccO18jtW7yS1bIi6nYsnqvrujanOXx+dsVsXSfTY+0EZ+1WPc++nIztMWvBqAdUhR594qE6JX0oyVjK6oLS8wmmDUTURj+W4z+EEGnJVEBu8+VP64YXsU/D1gaDy5ilsn6pi7IyvCmgggAjT1r8i9awWgRQsQ0tuO3pp8cHau5SoA0AjANgBjDktoFY9B8hl0R5GOkcKlMNpGqmxvN2ueVGE3uKcrrGuNBeKVDhZoHiDC7o5YEXxYlEnRz5o0yRWFcxJMj849ldofCNZ+/hOynf8eRV++RTj3E9Q9OMX9/th0eqo/cyDBo4UdA8CF9KIe/y76CpLK/MMJiQbBTEKg6lqcCvgtEFZ85WyA8NOnKwTltbWR4hCS0Coi3ETegq5UKPzq6UOBMu5fv003/yvfHcXPN3H77vsbePPbFdind+5G0xKjdLC2J8ZW0rR4tzbd7fXC726MUT88w0bj62QadOV/k55/Ievz4IsgBYoSeZDIjKEO72MnyMSHp5Gs08q9ljKY+Kl+49zhMLkZrghIM2YurCfwEhtiJnyKoP2S7SoIzOazMAGjjx8lLQRMrDQ6ylcU6joVkUqVFbGudwgjekqImJ5BlTrEc98DdP7dqJ8rV7jsdgUOzelfcK9gFvjcdtBDqzkhn8CwFZ1wa7m/G68Lrx+tXrE719Mb3i3qZwy8JVi8oN9BSkPgUpQKEhkHhhkTCzmRrF/+Dy1ldeKMp37N7xajy7d4Zj7ebrUvHej7+VrfjKLQuRFrqKCjAR9qAYIZeSFehsbuXoyOEa6ysoJ5O08ufzfdqsFcjJ+rS+USDH9jk9wM8Qc8+dqzA4oRkR75fFhTqtr5fZdfvIW/90114fdBIwDqRYYB/dXoYyls/pG6pUmNiPP+x8tcMAWauVWFQG2ygWXQYJdGe32jab/XAMYNyDZwdpIpjaysoMz40Ru5+3mPXtCCgv3nv3RtOPqtAQACpNmb440pdBJBplxWR8kcKIkrDYKgijclaa2OZs9PIIxoMKjyUrSK4ELIi/ngQnW1o18LOw74txk47oM4pf98zTY2nahQKp1HxG2OZ9uVIVd4IqDgRokY3EDGhgKtCGEACPttRT+PWGMc04OqdzrBPpQmh1pcv4pru2BruPNTux8xgo7MjJbBChHJ3iH7k6YDIal3MS7iUQUXE1wISElgKqvu2PAUHWkqAChoLB1WoxGOakqEHXOAmr1SadOjXHgLEw16QzZ2dYhAUbwAmN77FlEKCCdzL2IRdyfT45oWMAyBqtLGVRhsYMlpku5qzUfv2H/vPc2JO9QPzoR98W4zFuuXmd1jdK5Hs6D4HCY2Gmi25EPJ1uZbVI+ZxPpZJLGxt5np9LzLbMAQNBqse+FCegA0tbzMzQz4TjAjMgmAze6GiWrM62WG9ynP6bdwQUkj4ROGNR+QED0aVmQvKEBzCoUip/UpMAElsX2gJmzcLHgd0/YUiD1CaSc5xz0iiH03fWEhsLexJEIJDOyBUV0GtiuY1wAF6yYwq3hYsV4m9ZsQcJZirckAbT0UuWzvcHV68vTaoAk4AtJOK1oSqFVM3QxGApZmHAA1U2DmIGRsXE4JwFfhy6Y0uMLMDz9YXGFMtdRfCoYEMgnLO8HP3H9m6D116M8h1XT7BXAu1o4CTBiVUsdlms3dwqstCm6RH7NXByQRuB67ZWw8yUiJsDV1eLlM357F1BeRUpVLOZ4YqRqYfU802arbh8H2AAXJzoWVxdYTagx1RvZmmm5PKHdKHQp1NnZgbemJlKl5kTWA2aFbl7XW5GxMrUmRmXXbwYuP3CSwt8OwAZqk69vsksC2wKtwXYoZUAbQbQS/AaUErGJDowLzweUqEl7lPS+PWgxwnpoApcB4AzO9PaOeVRgS5klda4ctRjLM9mnEg9OXsWvhVf7qrC/zLSvxJwX4/OWglJGz5OxEiewJamUg7x4S3K1uLkjZRqLB+f2Uoi/cDJ3QmE1V+TVn/1cjQ5VQCPwRssNDGCAf+aumAbtupdioazTnC/ADsAZywrWvw8oAfJ55GRndQFCS4QlkP5XJfe2BJjC/AgMAHiRblSjJV7eOJ3Xht2Mi1RufPqV/+SoIJu41y+x9Pw1QBrpCXwX+BExkkF7QTvMYi5ABmsLD12bINOnJjnDzvuAcLO48DgkjJMcfg0x1Q3XKda7dL6Rp5PRrAU7Eu27JCrK/DFYL4KblOpdHncAty4YD9w5mIaP7wj6xtFBjp4R44c2aTaRoE6cjQDytR4fFQFsEvo2JHagD3heXcwhiEiuulojQECYmyx1GX3b7dj0/x8i1ZWynTo0CY/P6Q30D1x27m5JvtUcDs8r0HE2niVZzS0weYIkRKYUpA0Zc8Pqqq2rI4gnYDgipMVUkhfzrfsSTBBlSeUQIJ0Io4FGJFkPmAYACA3EMwjiIdZQ0EOfOrL8ZSGfEzFXOT6G35e+EIpOmeIxwCwwVgXyCZIPB9dOuQ7cseQxguUSDKOYeqlmJDqmiYJHAAbiMgxCZGWXz+qWaEeDSbj9wRTEQu/dJ6LEr+zNMFXkX7t9IXPmbE35VUKnCAIgAkAIzl/FtQfQAJwUF3IYAX4pMduY4BJBG+HGXEfjLiNSG0aDYdPwqOHa6xLgNXYtsdpw4GlBjMTGOJW1wt8vxg9iXKzbsTcR4QxlSj1QuNodxzyQ53q9Szls3269ZZVbkh8+cQcMwjet6yHlHN8vh+8e48d3aCXT84xuOH54DWg8Q+3xTCprXqWK1sb60VmLzCy4bXi9SltCe93gAvbqOyA+3zAynoJtzHvN7qYRUlgKYE0pwTyUz+WYi1ORrCKppw3q8n1GmJnuGABYC9AQzVfFiexQSJ9UWCCahEGUqF/xpfpRlZa31nW1MR52ZFVGTAEtnOYkqXIpXs4uXvyOYVSe9GkXqPuQ3VLK8aVla9D+W9IMhzWeySDAjix4U0KzEWZXlkSmNQxwFvy1nsb3LvDzX9AwbxY4oWUJ/on+7ML9XpF5c7PXTPPxrbUJ9ZovVZigRJVkFZbjDiZKXf4xMbSMExtQ18PRkZCxFQBBgITGLYNwgAHdyl0BgQm5QM8wFYg0p4+W6FSoc+9QWA/SEmQiszMdqjdytLaRp5gj2fTmRFRzxPuWzAZaBwAI4fXpvbozLkZKhb6PKJyYa7NoIPnevTwJo92hUaCig3YCNjG7GyL/TcAq1tvWaHaZpFaTYcOH97ixwL7QdoHQFPHpN3JDn+WzA3VIKR1thV85KIAhaRfI5A9Oj25LVB4t8TJqCIj0xic1GAVDVnlwac5NxXS8GM/iIdzM5ECGmJECIuguE8FXDkJOF3JLBx58oKFdMPhY6tyNkn/JkAna6il7oJNlGWaxGmNNNoBLEL5XFRpOydNbHhsV3ZQGxLAmtKXE0ggiaWlROk7+HrFg63BbmMhxugU/cjlrau8UaNy57PX3AAGUEGlB9PwMUQJfhLVkQzaD5FTCbQwt6F3B8vTkZqsrooPi9mqS62WPRhjgA9TOGdzWZ+1jYzjs1UfBjH4WGD5P3lyjk92GMxQQQLAsCsXz8Uzxf6fRpaOHd6kF16ep8W5FusfuD6GZWvMrGO+v3PLZQpCg3UQ3A5gBDA5dKhBuazLjl9oNQAcxOJCizUc2OshQq+vF+jIkRqdW54VzOTgJgOGqvLsFKjyTPShTAoQeJhdc1K0VLutcA4XJKioXjmkKPh0B5gooZTUknVRGCGbxVuxrZBDftI7hjYY8oR/LZ0GOomjiwoRtBo1SN+Q5Vswoo5kSYEcOYD774bx4IQH08Fz0STwdZntiMfFdQJpzInlQKhyRh8Y+BQTCcNhtzS/JhIWfQAQxmeCzQCoXni8SK98Q51iWO8xjOpt2cseCnQjRuUNz10XN2kUak3b8kvdbobBBCEqGkRLi3X+xCfpP4EeAVMbBNiNWoEOHGgwSODTHychsdhqqvvlVAHggjIttBPcF64Puz7SG6QiSDkqlTYLofXmPB1aajAbMY2YqjMdtr1XKx3KZELa2DQZqKC/gNWgarSyWhJZghkwwKDShOcCR2+j7vDcHgANRhGAhaBidfbcDB05vMkay4GlJvtQRCl4k1SLAq4XhQ4P9VbHZVJcdAn2m55+OqvJExInji3NYG4odvWArURyQVhPmddikebgBMOXqYuZs5o8EUl6QSLJDHCfrgQYU5PL+CIBJAXZ1Qt2hPsO1MK+hH6hHp8NeZEApFiCAcmKEAAuI/uJ1FZ7NYFAjV0oyXJxCyY9TYCcGAsrbpCVTlk0DnqSnQVS3zElU+GXkZEVnXcWop00gvRrp6/rEz/1wF+VwVAwcAmVC/57Z4WmAhqNPh/ibYMhHTiwNTiZ8ZSxCAxCqKqiYK4KmABSHlj2s47Hg7DhY+n1LNZawAoASBle0B5waRdaCDp6HSsY6B7lcpvcrljtUa12uJoD6/zNx9bJyYgh2dgfxD1FZsQuWDwudB0exRBroglwM88zT8CuhOZi8mP1ehkWkqH7ID2DrwTVK6Q9iLW1EvmBYGytdo4ZC/4Nw+0DtS465VGBblxNKZVgDUhnfMEIkILUfcFUMsawIuPLMqyuDbdHaJKNKE0DwADfSV6mR32piShBFN4PU/4s5rEIsAC49eX9y/47PrlNqfeI8ZPixFePqaz+CmzwWLrUV1R1CKkMnndeLj7TteF9kppaoAkPCwDOlmVk9dgqtXv18TqF/zg/dhzT2Dlm3vD8de/K/bn/8d3x6LwUAESeqz8W1WoFfn8DVJLVIBVIk2AVWFho8CIwnXcChfyeg+vUYmE2ZGYChgI9BGs5ABQYeg19BWVpMAKwEDhuccKjTygPnaTpCCaNtoGcz6VemOiQqpw5U+XrANig52CcAvQPzDGBxpKV83GhhWAuTKdj8euAHoLScadtk2FGNDvTYV0HIJPsuAa7Qr8TUjUVqpXhkk1id3z2GU15NkD7PUk1cEdqMbouwUbpG+yKNTT+V7WwaLKE3JV7lUN5Mvek94vkHCJPruPAfWYkQ+AnHQswUdsnwIDEyazxCa0YR06mULivnEyHAvk9xcMepGyiUsSmOwlyTR7PIMrGor9PPIdYpnD9UG5QlMDFVS95n/i39Jtf18ZmoaZfO37tBTBBvO/bx12rABOUlHGiY3IbTkIEJuXTyDR9BMAEsbjYZm8Jrr8w3+T04vChLb4cXg+kKlWeSVvnEi+qQngMnOwQXDEdDmBS52pMwCc0gAj3g6hCFLYCqs52+DbQTFD6xagFLCqDYMvNftjTPNekVsthMEFLATqGcRleA1K4jO0zQIFBoSSs/CYAE7VgXvQ+ecmXOhBWLpmhqPjsnXdxR50SZtWns5EY/UiDE098byZ0Dxr4OQRd8SJRMVFlaUOCUiQZjE5DZkPSk6JmsIBJMBtRXhHJoHLGMIXKyQfVJINRDEWlLEpM1aSZLSNHXiqWQxLgbOkEVq9rwIRktUikZULgvevZoX9i65nXpQLKBWLmri+MncTXO1TlR3lTFEtBQHBVAq3yZKhJcCgPg3Xksj3WKDBGEScuGgaJwabFJWKc2HDcwsgGVoL0SQEVLO6oLuH3GCcAwKnLXiKwJO4PqnRZ3zh5ao6WFhuqr4bTGYwdwH2pmblgShhpCfs/fCZoOTh9psrGOSwsA1CgXAwDH0xqCAjRABMMkEJsbJQYlIidwkXe+fyL3zEE38sGFJLpjy+78tVUQ/Vpr6oqiQKQABuchJI14Haqqz+QKQ6qOQEN9RNL3reqsoTSdNaXWglAiS30mgAZnOyRrJtHsnJECe+IJ9mJqhip+1RpCgAqSjKkhGtWvZ7k96a2/f7UbSeNYth65ptTUNkhZu764tjx2iuhQEWNh0wGTj4wgoX57dUP1WCIFaeouKBnR/XAcFu7FjMooKkQYAPhF0IwwCGX63NZGk2GqCLVajlmKu2uRdXZLuWyfb4tRF2MFwBQIdVRS9/hYcF9BqFG5WKH3J4Y/hQGBms09a0sMxcV6CsCAKGjGH4ajljjBkI8ZyVXoIRuwcgmXbnQgn7+zR/b9ne7okU5SH/0xCe02o7oK1FSBk44fOGTP1JsRIIIqU96XWgZ6K3RpRtXMSCu8BjagOG48uRVXhdcBqDwE7oK0g8lFsex0F28eFjexcT+KB4CgCevh+cGVy8Pi5IX2vqQVRkSuDQaAotiZ4F07E4CE1InzXno/o36tZfBhBL6wCiYgIXgkxzCLLQGAA7b81GlKgthFmVdJMQQdR3pVenK1AjVIAioSHvAQCy1bF2LuVsZYAKWAzYBMRRg0nMtZkMYLdBqZti3onpxIB7DjAb7/+ZmllMjMBAAE74HUEG7YU1FBrOsapuyOY/BBECongM6sfHvTKXDTKzRzA7ABG0Eo2BCVwooiLs+94ymZp6A8ju6NgAYknpKV56gJC3sxONDxAmvwEP24wmrezyswKixkvwHiIZaR6LaLDqh1dwVWUHqhcPp+4O0SRvWD1qe1EYkw7DkkWBQ0If3n5PajKUNmYuqHoWyOgXwUpWsOy4wzX/m+JfOe/mNFvvleChQSQZWm+KTHGMi4X4F4ABgzp2b5d/DswFPCbSSldWynCdSENP218tUr+e4EoMSLU54VHNEWiX8IbmcS4V8jwVQiL48hyQjZrRAk0HlBi5YzLzF/WI3MzwkAJaFhTYDFUBClJZ73AiI54rnCC8KhFYAFiz7SKMQYDzQXkiWiiEsYz4uyT1GKt79pk+MHQ+60pQnGejoVXpEJBmFarJLpj6GTFN6iVxIpRGGcuJq2oBtsG4hQcGUKKU6fZUTV1n7dW3kMcJ4ULVR1RyiYRql0h1d/ktq/YemKkBDN20YD0186qkzM5KuXJ/i6PXPPHPRS2k2n37NDZ/+zB7/8sQ35V6OnRoJsQe5MtMZjD5Q6ZGqjqhWfxXwpTRaef4X7APX36gVab7apOWVCjONUrlPrmtyGRfpTNbp82Uo8wI0+HfZ3mDCHEl/DExs8Jkg0Am9KLUVsCfoMegBgscE1aDDh2sszpaLLoPZaExI8xoP3/fYjp2tuwYoJEAl9KJYz+jDE1G9Y9QnumOIkq+uDT0cSbAxEoOZlCaRXDQ/+nv1GF40FEYVG1ElXMV+lE6iq8dMlIIdWVoeHDp1ecLwpssuaDsBiPjn7mfPz0p2iubzDxwLvI0TO1w8tWHZ1b9fvP1vrtvUtyuNUYv+Zr0wEDFJpkLwbCR/pwInO/fCQPjEJz57W/Js7wdzAfCgixhvqKqcs6JCicAKSJaXRcMegAfAhXIv/CjtdoaFVrAOdRuwHjvjs6jcbtk8vhLPk1nWRcYkljYauwooKp65465YnazqZFaf5ramDYROnYYpCckTXrESLVFapoTvQ1nkjYTnRBupJCXvT/lGkGoFid/h+ah5K7pMtbjhUYq6SiPxZBVLGfWSIjNA6LbPXvnE/s2nvuGGYSuzd391alI+BSwqRUE60WwVqFQUVR6UfsE0kn0+xGMRsvw73zMZPFBZUSc3GAUGMGHkJJrxVFczBiJhDEFeTklDVQfpDkq5YqVqzN3BPAgp0Hn4E0nmpEYgqNsi3SqVutRo5HkhPD+XwBSCqwyY1oqyZwcC8CVvDtztwBhHtXJDrdlQoVIX5Qkh1YcjTWJqlEESKJQYqhawK+qjmIpiHZFkE4Y+NKwpMFL6jGI4ii2phkcFVsoIp/Qdkq/BlVqNyaMfLy3FuVBsPvWqqQeV2bu/NnX6EUBl1NjW71vsfAX7UOVm4hmtDgudqP7AmQpDG3p2cKKjbwbMBc5ZnMDoD4IfBH4StTcH/yI9QpoEDQTOV5wImLWChkO1BL4vh0h3ulmxR6fc5XJ03zcH9n7isnRm21wTkgwK5WN8ASjx3C6Gmai4aoCiQg2djkYeRjEWpW0onUKFSnM0Of85TIwS0Addw8M0SZV+8TvlwFXGOp3UQrKRFCoWekrSKavYjbKzbGMk8jnftUMVZzdi86lXTh2wzN79wtQL0Yqt8DKwdp6rPGACYgh0MHZ9jI4MA40FU9jcYWHHmEmc5BsbBQYLnJpuz+bUqedmyMn2edVHsdBhIRePhUpQkc1pFjMdkkvLlKaiNBywIqWrUML1u1MgVfql79p55ehOccVVngsFTj5T0wZDmlT3r2ILChQggIKlKIu7Kumyt2QETFTfjiPnvYaStCiHbSBLvuqxaER0VaWeiLaDmAITaECmNkzJVGB16tUEE5Inn2HP/9LYBfswTLv6X28EMCGpL6DVHw5WlSrAt6Emqanl6TiRcfKXS10WS0tFMQh7Y6PIVRqd9yc3mTmAcQBMwDgAJuyQ1YQ1HdWh2ZkuXx+hwAQpUKcrHbvx0C7vB0MyDQ0GYIL7w/OZEDdfDpjQtWAoyXjqDuGuTaYdJDt7DbFsbyCmGhJY2PGhDYc0qesHiYoNboc0J+mSnSTqqhQslilOspKUfD7q+ipVK1r66quffGpp7AVd5dh66tVhFPtXHfSvRlTveemGLY+PVYKkkY0kgwHoEOsUeRZVA19n9+nKaoUW5hpc/UmWaJORdKqiidHQQ/bAJHWabTNMzhNdN8vjDAaGO6KTD9/32E073+LCcU0BRQVs+9ZIuXf0pCbRrDso9VKiRyii7WmLWimMWbJK8E1enxICL+8rj4TXJI5pm4bTkxZ/pc/M2PonX/mZpx4cewHXODaffk0/jlz7ej+PC4WmZ73Z41/OXOBqN0wAWKCbJJvoVCAV6fczYoSkDAioyuI+CgoAD6w+9TAkm52yJrMTaB3quglgYPcrgKtU7DLYgIlEscEANPp8Wu3847/wlj/7lrEneTnvgesBKCpO3H/3u9Z70QcpYWTT5BjHJCsZWOSj4dQ1BQSqqjOYVxJP1j8oMZ8Wv8/K/iNbPnAvGrYCXG4Z+FpE7cmb9pzGUr3nRGrWO088+sRDP0lE/wopBqon0FdUqLUdPHTaDLnagpMf1+HdwcUOu1dxmoK1JNd2kFzdgd+Lak9nOOMV5WyUpmebOz6xSxFbLzauK6Ak4xmZDikjWtIcp/QPRVaSvx/trVGgoCIp7obycgVGSXNbNbM32MjFxtZnbz8T+ZuHrtfjG2Zls3LXFy5/j+oNGiodUuXlSTFafVFgQ1LMncM4SW37eYtGPfT7qNLwqMck0fB3VReL7RlAScbJNx5/uN6jX/HjoX0+6SOJEo15EW33uyjAUHqJqW0fh6AqNVdiSNuLUfvMkav+h6zeezplIrsYv/TXb/lBovgPbHtYBUrOHeFI6C+UAJdRB6vqKCa1VyjRxHc1mMhOsScBZVJ85fjx1WYQLygQSVruibZ3/NJIRYjEetVfPfbpp/7FhLueyqh/7q7HAm/5svNi0z7w15U7n3lo7II0rmo8+sRDf0xE37vTYyR1kh3iHQ/f99hHJ1909WPXAKX+4D3PhTHdntz/rYZXZ+X8Vrm3iys38npB5fEnr9r+4jTSSCONi43eC2+/ZDD0OyfeVbztr3957II00kjjiuOyCEr9wXv+iIi+L/k7NVa1JQXPoil0U5ID4rP6+bM4NfweA/Qrjz95/iunkUYaaVxBXA4Zudjw2i8dK93+yVPp3yeNNK4sLpqgLD9wdzOrazyMSo1KCuPhpNbdjKTykpKVNNJIYzfiapKSncLvvPz9xdse/+MdLk4jjTTOExckKMsP3B2fT/1QE5LETo2h7XTS9dSqPVsb7qIYjZ4cYz8aKVFJI400LjXaX/jWR8zc0Z/ZCwfOeeVHUwxLI41LiB0JytaD9/AFKNOYO5COZMBjwjtw5P1lE7dJkpjRCOWsk2QkByoh1H3ieguffGr8TtJII400RuJ6KCYXirC39uf5137srRe4Whpp3PBBOxGUuiQnJAmKK53rhQuUc9QertHvzxe8yTPauVTkyXnQiA5c9WIjaGvxU0+Vxq6cRhpp3PCxF4nJaKRqShppXDi2EZT6g/d8gIh+OjH9+bwRnEddAZnI70A6LhSTVJhJkZZ90kgjjWTsB3KiIiUpaaRx/hgQlNqD97wpjuPHdyIcVxIo/2DWoiIcSVVETUhSPycvu5hISUoaaaRB+4ycqEhJShpp7ByDSeoGEZMTtYriYiKMhYoSTCgTuSNDj5JqSJKABPH2n5P31B8dBqum1cvvQW7qD97z22NXSiONNG6o2I/khPbx804jjWsRTFBqbxp6TpJ7zVWAKCTJQqjMrZoYTD9JdcleZHknk1BO8JVJkBX1fZIEaYnykyEe90fH7jSNNNJIY59E+wt/97pN6kwjjb0cTFDAJdAi7CWUEPUzZpJgVryf4PnGhM6bS4neiDICJQQqilJSRglRLxJfiHoQ81cy6g/e88b0XZZGGjdm7HcVwswd/kdjv0wjjTR4DzDH6PwS9TMIyoW6dy41Ri0mxshjjyoyycfPyaLUiEH3Uxfp600jjTTSSCONNPZBDAhKctR8MkarN1A7RgkFSdUjI3fuIKIJ96Vi0jA3dbtQDnKjCcQlHPGroNvnSpScNNJII4000khjbwYTFKgkO7UEj2qnk8gJJfwiasHqTuSEdpiRouagJAmQGv42fOztt0kYb+tjD5JGGmmkkUYaaezb4IIJRtlrO9RIkmPuQRjCC1R7QUx2IieqAwcXxxPID40QoJ2Gt6nAc4GKUnn8yZmxC9NII40bIoLumd9N/9JppDF9odqMn4dxtTdYAjiJOghicQHOcN6I4pi/MMQtSYgmtROraIejhtrhKHwoPxca5pZGGmlMdxRe95dv388vMJ2FkkYak4MJSuXxJ1+PBX1qSV9SxUjyA1XGAWkYJQ4kjavqskkkB/eLr2Q5CWQlc57BbFBjkl09SZKEy9JBbWmkkYbXfuneG/4gpJHGlMW2Ufdn3nh3vFN5hhLeEW+gtFzcvJMLTYdFmeZ8SogrH290q3JKTtJIIw0V3a98/2eBkip0AAAgAElEQVR1q3znfjogqXqSRho7x9iyQCwK3KlTh6Ti4UhSshsdNGpZoHq4URKSjOSOoJScpJFGGqOBoWf7Za5ISk7SSOP8MUZQEGtvuns4WZa0Md+JGmN/sdNiRwNmW9Xt4+hi7onyv6DMpBSaUdVFKTEpOUkjjTTOF3t5eJvfOfGu4m1//ctjF6SRRhrbYiJBUQE1JfmzmnWSJBBqBP2kcfc7RbLkE8hlgermyRkpo1uVg5humfvkky/tcLdppJFGGoNwv/oDX9HM/DfspSOSqiZppHHxcV6ComKUqKiAGTbpWekndumAhKgbnc8EOylacpR90RS38+P4lfOffOrFCVdNI4000jhvdP5/9t4EWpLzrBL8IjIj9/XtrxaVVsvYbWsBS0KyJKvdbbAxmMU2NDRgGPqcHmiWATMGZtzGgOEI1DYwNH3ow9JwBtMG3LYxYGCwZXkpZAOyLC/Y2kqlqnr7kvsaGTHn/v/3Rfy5PT0tVfVeVdxzSnq5RUZmREbcuN/97vfF1/11LLXw2r2ec74REZMIEZ499kVQBJW7b/sJInrP2AMGJBEWGSZmOi3KQnuVhKQpyHiKX3rgQXvsiREiRIjwHHEhSz8RKYkQ4fnhWRGUUVTuvs3jSJOAWEjJB8MFpxlep3X1RN6SCBEiXCjUHr7rtkTu6n94od5u0Nn4SPZf/fXrxh6IECHCc8LzIih7gdWWd5Au/cSStjXoeP5jS5/8zC17vCxChAgRLjpqD991hWXZv2rZyZfJuvhe9wvke/fnb/zE70RbKEKE84/zRlAiRIgQIUKECBGeKyKPR4QIESJEiBDhwCEiKBEiRIgQIUKEA4d4tEkiHBbU7r35KfK8E2RP4NW+EaYT4kOFtz30rWPPjRAhQoQIBx6RByXCgUTt3pvDHbM30P9PxIg6faKU89xWGa8losI7vjDGZCJEiBAhwsHC8yYo23ffdhf5/gPTZveYmJB1IngYE5XH7o1wWaF2701+kB3s8jCE+AS1ZL8Y8DJi05dReNtD43tjhMsK7a/+uzNWLHns+XzmKPPk0sN9J++5kog+2Os5NyQS/Wf9+eqNLOVzzeD2YKCPQ7GYN/bcfeCdb739/p+/3LbBsyYolbtv+wARPaNsLpOPBT6FU5DNZFkzfdZElIlyeaB2780fJ/LvHh5qMALebwj7Sc8lSuyjMtkfEDlTxlmC/AwMAgQCM/BmCz/38M7YcyNccrgQYW0RYTnYuPeTry7HYp76vff6DiWc/ROQ3UpO/b9cagzd3+06lEwOL6fdTqr/p9Nd6nQS6u8UnmP5RD7vIpZPfVcf0/p9hzLp9th7KvgWDTxrL4Lzh2+9/f63jN17iLHfqPsTRPSU3O7za5xnMX+n7fuU5udjMGBqhJSwiD9pQnKUKHsJonbvza8iovvVJ+u6RMkR0sHlmD3LOWa5B6RjL7UFZaLEhL1rBJGicmniYg4PjMjKxcN9J+/5IBG9YdIK9PtMCnpxymQ7wf3dboKSyZ76u9dzCOpJrZ5Vt23Lp1yuNbasZ4Od3TzNlOvP6bWuG6N4nM+WvkXVekb9WSw0qVbPUTqlP4fjuKOvKb/19vsrYws84NiToFTuvu3xnudf4zCZsHiSsUTW94zX2vy4WeoZ8OOTyj/y2sTIY6MDAgfG6s1+IlJVLgXU3nWDT/E9yIKpfjwT8dgvoJhMKvW0+0TpcRIUEZVLAwdpqnGv8eSJwo2feHrsgQgvCO47eY8PIlHI67IKCAjIBiCkotlMq/9b5AekBM9rtZPqJD+KRiMzREja7RSl0yGZ2dkpUL6gH3firlJA1N/PoMh4A5s8VlACwsHY3i7Q7Gxt6mt93+b1jtG00pO5nvgObNvj9XLNp/0fb739/l8fe/EBwlSCMm1AIHFZhp6hVOMbSouQEJOwCPHASEFzEvK0ko8Bt/TAg+NnlAiHAoH59ZlKNX3+0YJYyPMm7Rdt/oFCHTEJCJYvz9+LDI2uh0FkIpJyeHGQiMkoIkXl+eO+k/fgxPrjIBzZrC6JmMoHUK1lx0iHEIheLx68bhSTCIJZqhFAmajVM3uqIa1mSv1/4Mcom9FExrbl5Kd3A0yLcdmf4vuWKjetb5TUbccZBMuHhwXEo+/q546WmDzPUo8Tl5tmZmpDjw299xS89fb7D9S+OUZQQEzUqeE5qB+YwxOf8HxiciLLwqs7zFBGBwhi2KAsYtosH4o8KocSQ505zwXPpKa4g5CMTFNMBKavZY/HIpJy+HCQyYnAbZ39w9zL//6S8gucT9x38p7/4bqx76cJisM0iFeEjJO5nMCHVBAuuUANIXUyJ5qbMwgKiIQV7lJbW/p5+XxbeU4mkRfB2romGjinLS7oCgs8L/0RgoR1ALKZzpiPBURIfW54T6z979oekx475g35ZlrtdOBzwf0ZXu9YzKd4fEhhueiEZYigrLzyVj9u0cRBfkDb85XxdZSY7Af7UEYUzBLPJMIjRlusY0RSDg+eNzkxIW3H2BlFaXFi44TEJCGTc1LGMeqH8X0q/Mznov3sEOCFHv53IRCpKdOBko160DCTEisJHpc5uh2HcrlhJURO9qayAeWk1U5QOqUVltHSCMom1Zr2c5SKw8oECIhJPoJuHNunSi0bPB9EAid5tarWsJF1koF29HEAz4G6k0iERMEsS8UdNyBoUENEaQH5gWIkColteZTJ6M/aaiWnqkWjEM/NFJx+6+33Xzn5ofODgKCMlnTafH/KsoY8IfWBT0m+IzFS0jGfByUkM6GfeOwL8f0xwmOSkL3QGPh07FOf2ftJES46avfe/K3Ucz8wVHLBNja3rxBl3D9N+dgvyRjFFJ/JEHp8QJhQdopUlMOBw6CcjMLrV/858zUf+LqxBy5D3Hfynp+XAbOjwFW/zSf9VKpLrZZWQjKZDnXYZ5JMuIoY4CRLE0jIGJj4jHbGDBlRGVIaaraSwaEKzxu4Ni0t7arbK6tlrXLgeikxGCrBgIAkEnqZq6slWlrcpSobb/G8wUCrJN1eYqiLB2SrXNJlKiE9Q2pISxShnnoPfDcCUW+WFse9sSAz8p0JccLyQYaELOXzrVHPyhAuhLqiCMp+W4cnoSGlGttSF7Ry27FCj4pZ3hkFnp8bITKyDNxvGnFNIoNOIJvVnEhJOdiYrp7I3cbmQ5kGt/cq5bwQ2KvEMwERSTnYOIzkRHA5qyjiJSFWKjxP/+73uuIf9ZZsbhaDv+fnq7S5pW/Pw0dilEQmEY9pkDIOSj0gHkeWdyc+E+SoUU8Fz11dLau/Z2YaynhrkpTVNf0YfCZHlneGyk2i+vieNu3icwDwuDQbmoAtLtaV+dYkYFvbej2LhRbF415AYkYVG1k+CIn6bg1VqtHQCo0oUeZ69ZiYwRcDYiSfZ1TlOV9kRS4Xp5KT0TIL1A1T2RglF6O3aYKPBcvse9OfbyIx5b3BYfrexAveCIcGxrYXs+teSkfHJUpN2eD7SZgNgtusfROT56zaRLhgaH7pmx+IJWcP7RcOcnU5kRQOQDtFRvkCJ02zjAJzqXTZdNpJShmPjRpf5WSuckIGNs3PVcfek9i7ghMrqZO7qzp09Ht3qNeLBSf0jY0SLbBfBMpNqdQJVAXLRllJE4Z8vkmpZE+VUML38IL/42QuBKLbjdPcrC454XACUhWst+oA8oJl4nOIaRbLSDiaMKytF+j4sW3a3NJk4+iRHZpjMy9IRr0OBUWXdeqN1JDnpduJB+8DwpXJ6M+Kw9uw0pOgZkt/PtvG96X/hlJkPk9KWcY29UVl+tm7/+4F25fHjvbNgU9ZgzSMekASI507chuqR34K2ZDyj3T/xG2L0ns0ViRGFiPdP+aqmOuI8lSkohwiTDrpj+agTIKQEzNl1uO/9xN/b5aOhKyA6Y7mo5gJtFjPzjNIxREuKmLJ2buiLXDwEXhKDIhSMup9SKbCbpzUBPOpYEgpsHxFLpYNtWOo7de3qMXqQCLRCNqHEaCGEzvICFAshgTIifeVqlOtajKzsFAlbxAeu6A2iO+j2UwNkQ4QoCz7QOZGuoLy+U5AkCqVFC0u1oJlYOlNNt5mM92ADMyU9fqCmKjXVXOB/wWECwrIBqtJQk6I1Y9CQX/PIGNoTxYvTp3VHwFMsrLO+O7y+fHWa+LvPZMx1CjfClqrje38vNuY45W7bztr3pGdQjIEZknGNL1OIidmt09vnyZZdb4Ye56+7UQU5NKAkBMxuFpGSWevBFiBWf6RwYFibp0W8AZy3OLHcomQrMQmtBrLYzDjWhOWFSFChH3hvpP3QJ3/gPlcSVRNJl2q1ZkUFJrqSl8O8TjZibqC1uGt7bxquQVmZ+pDyov4KdABk0i6dG5lRt1Op/vDLcCWHygJFFaFFAHpdJLU7+vffaOboXxOk6JGI0mDgRUQCHg+4HshJiAgUmZHkBhoYeKt1VJ0hMmEmaeC7hp01hB35xw7FgZYw/OBUlevqx8rl9zAH4PyDYjB9o5WUEBKzpzRyuHx49uqhDVT1oQFJZ1SQf8N0iLKDggKiKC0HZvdSmtrZSqXm8Hn+csv59oPtfPqi/Y6fbLTCbL42Djo9CmW1F+iFeMGBVdvH88d0LUZ2vruF9fe8677X/MeEMjnWgKKD3zfnuYPoQklHZAE33hMHpqUKmuWZ8ZJxzAkFwWdQqNlH3+SVyHC4cYoETFNqpMUFoGpZpjEQUjFJDIhBCSXCO8LFJQ96oShsvIbY49FiBBhKky1pB2oFn2KxQZBGYKMcg1OmLjSB1Eg5e3IqLIIsWcDZMYsMZh5J3JqsSxfkZdJAIkBgTFPyKJgCHEQ/wbWRU7grbZDiws1OntO+0egnpw40QleBzIkisZTT83T3Jz+PNs7GUqn+sFnx3M7rIpAEapXcoosqEPQIKa+F+KSV6WSDoy4UDuqNU3G8NnanWTQnQP1xC2Gx67VtZIqARF3MG1saAKxtDRskgV56rac4L2lnPS7OzEanE1SLKEJX6/WSjtZvf7xQobcWpM8PlEnyjnyB9xNFLep3wxJmh2P0VPJzNwvn8qSu9sky87SLzz0Bv/HrvHol1774SkH9smwdu+6FQrK0Wmpr1KWIRo2vU567jRMMslOWwYIChn+RVN1Mf0wo23LUYnnYGPMKNs13OEyD0eAEo6UbsyQNdne01SSaY/tp4tnEpjYRAbZg43DbJAVXCoeFCEm+w0GE9Tr2aFywqihFcTF7FCRrhc5sZORnioqBgymhXyLn+cpZcJncyhUkLNntdKyuFRTKbArrLzAENvjGHwsa3MrF5hKZ2aalM3q9Xjq9CxddeXmxHUG+QFhkvdrNhOUz3WC7yTmDIKupKfPzAYdPiA7IEHbu9q7gnMhSJJ+rMLrxBWMZJ9qNd3RU60maW6uQT7pzw5PjZR/kO9itmLr6z+9Xe79cpZ8PsdDHbFTCXLr+rmDTi9oJkguFmnQcSnGx1XL86hX089LzGSpsx6WtlKLxeB2spxTx+Luqi67JYpZsh2bfvb6nf/tp+/46O+P7QgjCOhXm88H2diwTjGpLLMfYgKiIUFreL7ZdoyEWVNxMZ+ryjjSjcrPmRQMh/Xab7ZKhAMAnOzN/cb0nEBNMas6qoSzRxfPJGKy12OiyIlK49F0sy1RIFUqZcX1fnjs8QgRIgxh1F8is2viscFYTskkmGUSUmmueVpc0Ce5lbUSzc02wtk5/XhQZoEykmbigmWAhFSrWnFIpd3gRIw5NfV6gkpFvS5QO+yYXCQPlBLi8zmw2UoNdRF5g0KwnJ2dbHB/qdRWZakeG2hBgtBCTEq1qCpDrstECqQmzi27OAyaJOTEFVvU41bp00/P0cxMKzD6gnQlUwM+LNnKlBvnQxdKPaIYJZNdct14sJ6KnASkqha0JjfqSSKnT793mtUPxw/U5H6rSwknHhz/UnN56m1rkuN3XRrUmhQv6JLSoNajGB/DPdfTHbUL+rOD4MT4wrJfaZKdiJMtafKNDrmeR+88mfi9X/jnb/69GzLeP33qh/7qFRN2Cb3/yB/TumlGSzzTMJp7MpoCGzdujpaDzHMTrn/To8bcKYQoIieHB4W3P2KNqSiCSZ4TIRPY0UXvnJaPQlOMtwIQDVwJSCkHP0jpGlLJgyNkRVQbz6fC//XwfxtbXoQIERTe8bev9ycZKeXq3UxzHf/J2kF3jKgjYmrNQW3gk+38XEP5VuR9RCEhLhE1OU5eha1V05TP62Ulkv1AwUklu0plgKcEuPLKzaDtF+ZYUS6Aza1CQFBWVmcol+8GHg4nPggeg0kVZSkxms7OoNVXkyMkxXpeLPCS+An4QjS5QekHpRtRmUBCRAlaXqqqLp0cl3+gnihSoQhQUhGQo0d1SamQ76h1IKWgpGim3KZKVb4Li+r8uoFnq8/X6Mboj9bT5Hdj5JT0Y+5Og5wlTSxwFERJJpbl18Fnwn8r70nMVo+r5fdcckrZ4HmJ2Ty5Ff1YDKoJH4r9Vo88zyO/wyU5J0ZOISgh0Rfd1Nflfu21fuOnPzLx4B2UeMw791ImRgPZqq7eAYpxa0gZMc20e5GcSTkozwVRiedwYIikiA/Ep71zT8TciueMdtyYHT3T8EwlHjM0LiQ6pwtve+iCpiZGeG6ISjwXHr/w96/1RcUYTVrFlXu3J8mooVcEz2s0hjtdBCod1osFoWv5XDPI4NjdzZLr2lRg4pHNtKnPBtPNzQIdY98FykBo+Y1xmQUnaYlxR/ssCM6Zs1oBKBa7tL2tycSR5apaTznZg1xJlkoh3w6WpZbTi9P2NoecJV013Tg9oWUXnwelmyPLuizje3bQpQSytbpRpGQQgubT/LxWQpCd0mk7FHf0cQ2tySAzxB4emF8dfgzJsj1+rNV0dJJtXF7XpA57eFKZLv2Xr2pjrdd3ySlmSGLp/FaX3JbeRnYiRrGEo0yuQDydoH6Dy1JOnCzbIovP1ZZtk88Xll6jq8pB8YL+PnFMlrKRnUsqMuNz+rfX61NcCFDX1Y/xecDzfWr+1F8P/Q7iNIF0xLnrhp4hLZaYmBD7QxxjCCBm7IjPZBo5oT2UG/UB1EYfj7vfa30iHGzAz1H7xZf/AcXstwTeZ5NcmPN0zA1NNE5OzNeOJtOSEca2FzmRN3BDz0vkOYkQYTIwE4eIvp8obE8dTWzdrWYplx1vDYYKAXIyKYoe5YqF+Wp48k84QfQ8WmbhURGSgA6YGP89OxuqN4iyR/qpzK5BeUXWTXUL1bOU4+6cSiVpkI6EUlZaLSFHrUB9gCJxdLkahpJZPpW53bdcbCpjqpSY1jcKASECqYKSc5oJUS7dCzp6QKCuOL5Nde5gSjiDoFMHf8M38+RTC+q271lU4iTZx55YVK3GO0ysTpzYCubtdDtFmp2t08amJllQZ3aqKfrj7R45xVkadDRxshJxVXYRkoAuyEQxHXyHsP6hW0ctc7dJCSYdg26fKOYEZbCYEx6zQUJAPCxRohNENndoyqHbd6WkFKfujl4XJ59R6rXNr/N2G5T/zW/x6z/2F8HxVz0yejQGZxCfial+WHuQAiERQ3zDDFkz1BXzKaO5K0PrMbKMUVjGFxDh8KDw9kd+gIh+YGLJB+RkdNBfcgIxoZHhgdhH1a/LbEGevu8MKS94Db8sIicRIkyG6TMR9YTYexEMtIsP1IlfMjFMoJyjklC57AH/iMXH9wVWVTJZTQRqtbRSKACEnY3miIi3A76TDZ5HE3cGqk1X4tnRguvy5F+cyAeepzpkAJhbZTggmlFq9VQw3wc+EuSPkCo1aXVBvCfoLCqV9Wd/6vQceb5FNSZSmXSfdnY0QYDCk8m2A5VEyAmxeRfvd+L4lv4sbpy2OHwNJOvIskc5fv+ZmTqtrOhS1HXXrA+VzEDqmlyy6vTiyjy7MF+nzsCmX/uiRV4/JIBCHqByuFt18i39Wa1MjCy+kPNti9yNmlJKACeXCjx9oTmW5yG1eoqYqPUH4ZnJEXVZSbIs8lgxGVRblJjJkSdqSxdlIy5DeZ5eLyYzKCOBEM3+j+/0t9/yPrUSqsTT9fyj00o6ddenfHzyYzQ5rFyv9B7Kx37RHvhD044ndQMJohLP4cVEomJClBAkyWYco1MnHu55YOiKaPDtUUXFLPPgxyNRxll1X7XwtodKY+8b4VAgKvGcX0wKWCNzaJ4xxwY+kNFBeeLtaLYy5A6soc4ac67MNIhxVNqT0f0i74lSjKgbyDhZmK+pVlwaMd5CgUkkekGUPrp0kFNCPCUY0fTbTC5wkpepvjDTplIuNbgtF+SrVNTLhZEV3wEMvfr9XKpzLP3SQlWRlCbPyul04sE5MpXuK0Jns8em1XKoK2UclG8wjoxLNY1mMghomy3X6ImnFmhpQX9XpvcHWSfZYoN+7WH9fijV2Hy8G7S6FMvo76RfbSmSYQvxKGbIlzwq3w9VEAErH/1qm5zZXOAzcQoZRWjU8qttsp1YUKqx8ylyNzWhVGWfpBMQm95OQ5WZgORyWZV45GIRnhQB2psr//F/WWptppETGhEwJnlTpr3SJCco+4BnuFzy8ScYZSdBVKRpLclE4TIjHF6IalH7lRuvIdt+nBq94cySYG4O357UqTNaFhodRGiqdCAnWSdSSyJEeAZMIieSYFrnHBHTezFKTkiVZHi2Wq6tRE6T0MjrUJIwW5LNll0km6KMIrdBGhxuywX5kfbd3Z0MPfnUvOqKEXS74XEEyoWoN7MzzaBLaHc3p0jNEckLsfwgCA7tv/VmOCBwYb5BbSYrZ8/OUjLlKmJCrB6JT6bWyCgviYS/obzVZzUn6dmUSffoNGerzJVaQbkplXS5RVifrEGWTj2ty0QoO0FFkWA6zAsqFNvU7Nr0X7/cwoRCblEk8uOe6pgh9nq4Tb1eqaUS9ZFNwgp1d61CNp/F4/N56m3WlEdF3xEjj18HcgJfSVzntily4tXZn5JPkT3wyM+E37XFhAjkRL3PtlZz7GSCknOa0PVWdsmZy5PFr7Pr7WBEEJZJk6LuR6EG9kkv9B5EZi8IOTHbhqcpL2paMp+IEkHZaPx9MW0Z3T7PV6WJcHBQ+NmHnzB3idq9N1dU5qOUcfB/MO4+7z1QPyRPRdqWR2+r+wbSVvyHhbc99JZok0eIsDcmERNBgssWJQ5Z842jeN+Nq0wRKfmodmGepgvysrFRDrpsEF4m8fIywVdm16CkI0PsQHBQdjlyRGdpLC9XggtnNYOmkeL3jqnOFgl7Q/dKmzNE4GPp9gpB3ki761A+5/LzdDAbPCTquYtVqtYkYK2nFA8hNo16QrUvq/VyfaWirK1p8bXTyQSfDRkluZxHaxv6ZDw7W1XlG1KKSVy1/s4W9Xpi7s+pp+bV3yhTVetJaq9pky4UqSNLmkitrueVf0fKVuu7afrtJ7k8koYB1Q2IB7we/QYbfN2BMrwC3c0axZB3wiUXMb+q76GulRApr3u1NsVKTFYGHllQWoyLQyER6uGuR7bwAyzfMpTteIycWf094L2kEyixUKTebiMo80Hlsfi43VvZofJvf9dj+xq1Z5pczcwSE/CSpHiiMTEJMduDTSIxrW2YpkTmC8zJxvY0M0yESwbTyi61d7zsZeT5v0tEt4zN8EnG31l420M/P/aiCBEi7AsgJ6qrxrcV2SCelWPb+uocRlCzlGMZTkB00RQLrpGgGs6cQcllFmFiLKBA/YBaADQbRTWfRpSE0WF6RPkgGRUdLmjVBdqduEp6Je54qVQzwTIK+SbF7bAFGe26OSYQZkkJqgdUnW5HEyKQKp9bgLd30op0iV/k9Jm5IJcEZRhMLy5ytgoSWyX8bXa2Ro8/uUApNumCnIiP5vTpOVXakswS/C3EaXM7S9lULyifFUtNOrOiPzeMtlvbOSrNNOh3TtvkDZqBwdSvtVTZxePyN1JeJQUWpROX/SHINoGa4nM3SxzlGFZC4AmJ59IBubCEnBBHPOwR82CPNCIM+P3iUEeg4HD4GxQTOW+jQwjkyZOOn0RcKTj6dUnyE4NrrbVX3rLmES1OIh3TIOmy4BI93tkyexCLvbCXSfbZIPKgRIhweSLyoLwwuO/kPSXXjSmZwkxxFcgMmElx8qN+lHZbfCDd4LFqNUfFYiM4MQ8G8cBMi7JRR6kdHDRWbtHGulY0EHqGbhx4UYiTWMVAi3k74uVAPgnWMcFtuGgdliF/u9W0IlhHl/UJEIrJOQ5Vu/bqNTbaSikqbI1eWSvSTLkZmGtR/knwTCBMBm62HSoV9Al+p5ohh/NMoN7AO1LmDhy0Jw9YVTq7UqL+wKbjnAwLD4wMPIRZFvOEXPakNJoJ5b8BWj2LfucrYXcU1A8pbQetukwMYulE0PaLkDVRO5BLgpKKzzlT8JxIqQbeEJhdXe6yUcZXA3gPawpJsYzEeXTeyvqodmQoO1zGcWsd7UpWQz4dpZgM+P2RkSK5K1gnbzBQwoY/Goz2TJAKYhIllikNFvuFkBP5OcQ4G4WmtCBPKw1FiBAhQoTnhvtO3vMwEd1gEpPR+PlRYiJD/2BeNX0lpE7I+ooaBAUqA6mheNuKiEiuRz7boWYrzB5pxlPBiRon7SvYS4LXbG/nVJeMOi/kwlRWhLTZvM4o7cD42ucOn7mZph7Kx3N6CrkunWHfx4uuXSWLJwaurZeV96Na0yfHubk6ra+zWhMbKFVjntuZdyvpoLV3t5Wkl1y/Qo89saRuH12q0NO8/GK+sxqLeeura6VTpOPpv8Yd2PleP3YUwXMw9O7saPIEwrXAOSgp1QkUKhdYr3rLpt/7Sossd6BMreILsbLxQKnAiTFZzlKPNxHUEHTQkCIeA6K2Jl3J+QK5MMpytyMes1mFhpoyqLQCvw1Igs8jR1QMfm548rEJD+RFAjcHodlWkZNkPDDCxvF3MiRLIE8S1Ame6XGApov1RWkqYVlq67aZFEjXjNyGUXXU5yFqy2gA22AkFdYEAt2KE7qBpFITM24LMTu6QnYAACAASURBVJGuHTPqXpbwQnQJRYgQIcLljl/66Dfi9KaG2AXH8kFsbNT+aH6J5HiYw/8Q746uGvGpgOQc4+RTtBnj5C4x7rgtianEk3ZRFiHlrRxQLK6P+0eWdyiVTAatvlAgZPlSihGAKKVYXUHnTDodtjujNbnIwWsgTTJ0b+BaNLNco1pN+0B2dvLUYYJ1zVXr9OjjS6o8M3Ui7+1j97wg+Lm/+p6P/cbnd+9RJTRLG/9BTmwxseK8yJ47O+moMor4OeLFjPKbUBBZr7cZVBIr4QTdOX63T5ZkopDuihHlZdDsBC3BQj4GPH8nVkjTgIkSVA/LTAOP2dTniHyoJJRGGng4nFW+RFFyYmbCtyg0jTbdtRx/qWozbvv+0cCQOvLN7pUCSzQ82dg00ZotwjC+WobqsVdJZzQyn4xJx7jb/NtMoY1KPBEiXJ6ISjzPHaYZFvNqCjlNSnbYIyFEYODFlKcDgBdkYWE8DZY4tr3dcQISs7ZeCjwiiHBH3onE269vFAMy0Ww5KptkfV2XXZCWCiMpsfG2XssEM31Q7hEzLbGhllhNQekHagupNtwObXJwWTbXo42tPGU5VA0lGMk6gWdlZrapYutJKzb/8Zde++HfGftwFwhv+punltea3RW821I2Sae5/TYVj9G1swX608/+oF4RJxYQEh9kohRGzCsjKgdbqnJPijtsUo5qAZbyDco5FnfaxDgjRVqSQSCkrRgmW98w1JrYq/QzCpCaGDc9ICsFZRyf1RWVKsvEKXnFHO18z3t1m7E90oVpwqxETiIrcmu0wyc9skAQib2OIvKYSU5EJREFBQRLCImUgSJEiHC5IzoWPBf80se+wU8Zqn0hHxpHg5RXf/zEMI2ckEpoTdOyYRZdWKzTuXMh6SDlRdFKCObaiIqBTha09srk3qsWNwPFpteNK2VEZt7U6yUqcBYJ/CAw1JKKr28pD4eUKCrVNDWDTBSXXnL9OXrylFZo8rkube9qJeJ33/Le8Q95EfCTD1VKXzqzuVvruVTh2TVZx6arivr7OjpfpJXtOn3vHX+kbm/XWvSVnRqdXvkZuDpiIBPB7BwnpiYTA4N2j6T2AAUE3TY+Ky8gKjIQEEqGnU2RZRhebZ5MiPA1k5ygFCQdPiAnbi0cEAhiIwoK2pMBKd0oUy+XjVDGgaIjptwYSkjsZQE5IWkzBrlo8Ql/VL0wzbOJZ5ggjGVIFcckMml7bzPstHk8UsJJGUm2bS8sRU0rJ0W4tFD7lRvZ5m0T7XSIZvio2uyHk4eLI/VRMzK/N6DC2z8/voNFuDQQZSE9a0A5EXLSYUNrq5MYip8n1fbLM1w8KyAmEo4muSWIhpcwtuXlXZXTIbNyoEpIh0qn46iOFRmMt7BQp3qDyzZnZ9R8nCzPtUHnT5UH32GAHspIEoiWSvVpwK2257ZydIzNpoizrzWSdMUx3Y6MNFqQEuLOGag7UIVsi3r3vuGDRl3j4uI7//b0Urs/WMVKvPT4PH3qsXP0qmuOqHVyBx49vaMVoiceO6dO5osdrfw83WhTKmbT9cd/NfbK647SR750mmbSCXr4sR8nKx4LfCZ4zaCnv1fcFy9lVXuv2j6ZQjCVGDEOKnSNCYoiPAn9N7wqFgIuRSmxtIeEmLwgIyUwwiJLZV4rXMqMG4+FptxkilzOZ7F8Xxl946zYgKzAY3N9wv2obJCgRzNjKBMmWRjt5p1GTqCuTOvkQaeP8wyBb3vBfOZot1HPiw5OlxJq73zZAnW9deKMAKp2dQ2TeCQ2yMk2161ncQAz2tvwXHmdROZjH+57VPuZl/iUd4LHopC2Swd+pKA8K0hZB6UWmFLFe4L/m8ZXPC4dODLDhlSJxaV0qqdKNgq+pbJEiM2umDCMIDJBittyEROPKb9QS+R1eS4pIfwMSa+SqbK5lQ3MrlgXrJcEvs3km9Rs6d/59detqsAyoN5IUrnUDrpzsO4Op8wi2O3tr548Mfdi4QcfWJnvud6G6/lUzIR8CUetR1a0QfglizM0xz6QnBOjx6tN6nBJJB2LUZHLM1sgE5ZFbXdA11/1bmr1XfKsNm0071OhabaEnRYzSu3wpR0ZXT0yHgR5JTDhstqBUDYJewMBiZWzoQfFeB4IjZhpZTlCSDDpOJ61KcbzfqCsxHid7XJWlZgkrwWR+Mda9ZMPfu9f/ptgUa7v2+ZwQNOgShySZppUyWgzHiUZk0pAxGqHNcGIK8B7mo9Ne96oP6UXXTldMqi9i1USTzN5v6kPcGDZ1ODwNScIXAvR4ANhwibKjjwmMx6wy4CcNNgwN+iH7xe3I7IS4bKB6TmRjhkT0n0DUoASjFwdooVXJg2nkj2V0Do7o6/CpZUXWO8UVdDZqgSNebpNWL9ffGimzuOn5qlY4AnF2a5aH1knnO9kCN+5czMqbn6WX4sk2WJJn9T+5dFlOnZE37+xnVCkxGVShTLOu1734QP32/6RB7dm2t3e9i6f/K9anqEWn+y/fHaTXjJfDETBL67t0CuuXFR/VxsdsqtNMn3Bq029jCPFLKWcGM1xINtCrkT/eG6bljP/ma4pZemBUz+p7vdhnHVigQdF+Uy2tGqGbhuv1aMBR9HH08lgcCC6ckBOpMyDCcYmUFqSeHs7nVQDCYnD2IK5Z3wslqj7/mpLXUT6zCt2f+BPx7aVMskOfDo6RfxQqDNh2CtE7ZkwrYzzTJhGekYRmWQPH2r/+WWL1BusUTkVyvTYWcG+zX5yUckG2h0tpiqr7ZJ6LbFrGoQkYSTKtpjY4Dk7nWAEuIWoYpmjIMOqnBgVfvZz0T50CNF+7N8f+iuV9HX/73nf9+47eQ9SlP9AyjFkxNCPAv6PZKIfGEkbzVRgUiUOUpvhtmOYZlHaIVZlkO6aZgXFHCqIxzChOJXUFw6FQkMFqJEqwcyS69lBjgiQZ/LSbCTIcQZU48TYI0s1WuGMlBddvU6nTut8FIuH5sGX8tvf874D91uGxwTnYfy9XW3RbDEkdkJQuv0+5dJJarECUcwmgyCzVqdHlUaH0qxAnKs16epZ/T20un1KJxx6fFOrU45tUZE9KNVOj1LsJTm1+VutM73TGbeltwtISJ9JjlPSikZySStQCH2Tsg1yTvow6/JFn+rukc4d3ycPPpcYe1CS4QBAdAKBsASloYExt8nz1GE+43uVtR/+UHnsC5MSD47te+WLTOgOVpjU6jttOWZpZlKnTuAtGSEj08jJXoMDIxx81H72JT6VUjquHttedlzsyCDEYtSqdshn17dyrHddstJMQlBEr7GCkouH5ET2xQS/DsueSemoZqLwh4XnNHp6ub6L8pIPn0vkVzlkiJTUfWEwiP0B/B819n2gHDMNSIutN9Kq9VfDUlN3SYWJ5VTcu2Sf5PJhOaffdwKlg9hL0uABehjQh01V4FZfRMRns/rEXCq3VbtvrT7sOyGl0MxTo51UuSbEEflXMJE5t1Kmnhv+ng+K4dXE933s3MJcKbtu3gdy0mGjaioZpy+t6VZsnGtvujJDXzmzoW4fyaXp+IImDF9Y3aGvv2aZtjjfBM9NsM+u3XMVuamy1yTrOLS5qwnkdeUCfXVXb5Nc7j9kvqmco9ObH+o/svV3zoCJEIA25TiGAHK5Br6V4JvNoMQWI5ef78MUy7komGoc833q7ujtk3Sy5EkabdKhQaenlXDiC1D+23Gyve0fed+eXiBr/c5bVhOWtTTayruX2GGWfEbLPeZtKRtNIxnTMPo6c93a8t5kDa1jpKAcDtR+5ab/SvXuD6uVzTAJqfXZT6IJibo/CP3x9Cwd0kqK3x2QleXXQUmRoYIS+CN7QcsNyTL2GXP4IDws8n67Ha2wbPAkTb6/8HMPR/vTIUH70e8+/ArKi87vidUs7YivBMP+QFJk5g0UEomol0nAPS75oLW3xZN5A1WEO3wwsVdm3uSyXbJsL1BGEPGe5eejfNNqpqhS0+8H06yksmZzXRXgJiFo3W6Mjh/TJ+1TT8+rdNKFOf0b3drOBNN/kZeCAX4//5q/OnC/V3hMSvmMYhqn1yt0YlETjTMbFUU6cB+p7eGp+TjEYwPWWz16xVW6rNNs96jDpKDNoWxPVjWxvOu6o8F7rW3XKZN06MGnNbHJJx168bwus+ECzGEi809nNqnR61OGza+3HJ+n9z6ox5MpoysC2bisE+M8FKC3USUbxlteT3hQZKo8unFgdB1w5xGIi+SuxDMptZvE+eKxs1WjE0v3Dr7871++rzE7qsSDDqZgRUZm6Jizdxpq3g6FLUv+cPnl2YzHGSUh+yEzo3OAzPeLCMrBR+2XbmDqHNMdOFnD4CrqRr0fdumMYqtNNJcO1Rb4T4Tk4HVQTDq8HFxeyPIxCny7HSovcKPL4ToV069dYLkVVw9SM3X9NxXe+YU/H1uPCAcKEUHZG+/429f7o6Fr+wE6dxpN/buA7wTlGQBBayurMypAjZjoSF4KCA3eS6YBg7iUy/qEig4eqCcJnk8DovTEKX0iBrFB6Unah7e2skF5yXF8ZcyVFmQYcCXgbbeaffJdr/vwNefru3suQClnY7exi9LMwgwbiT2PTm1oQnLN8gw9vrJN1x6ZHVs6ElntKZkio69RfpVj88FtKDKfOqWagehrZguU4xLPw6s71GdV5JpiluIxm766w9OFsY24E/KGhTI9vvEB99Ezf6UOlFCuZXoxjLQgJ70qqyQzeerXw5KfGjIomSyep7wsQLyco4XMTa2FxLdnLMvqffI7rt9TMRlFfIxU8B3yi48Z5GHUQ2KWWCaVbaZhkh9lL2IiGC3/RIzk8KB2780fp102VuUc8tuublsDSslQJZGNyvKn7/pkSY2xnCTabOn/E7cWNw2jnxVm7ViZePhY3iILKomQIJ9C78o6lpcIFRQcHIqstiT8P4t2s0OAqMSzJ0AYRpURYsJgDs3b2SkoIkDsTWk2E1TiWTIYGggSISiXWsHEYsTLl3hgXjzu0srKjERdKBIyN6dvzM3UQShog6cGI/qeeI7OkaVdajTTwZyemO0FE4u3dzLqJ5tkEqSj8q0Dp5qYHpOF8vAcm9Vqk7KJ8IIsEbNplUnC8kyeNrjtV17X52OVg4srfs0VrIhsVfRzjxRz1GjpbXJ2p05z+Qx9LROYrXqLHuX25BfNFIKfyFO1Jn3tsXk6zUTj9muP0sknVCYcFTJJum7x2+Ju/NXqdssd0M0L2hqSSXbp75/41VpvUFcbr1dtBROS3XaXUrFc47ryG3OF1A10pt6ihaN6f2tA9bHt+Kfe+OLntK3inlLA/UAVGfWQuH7YgrxX6WeUnJjEZ/R1k8yyLn+D8LRM86NMmqTcjdqMDwvuDtp8632yYFIVklDpaCUDyLFh1jcMrWJ2bbrDUzVNFaaplZeA9MBAm+Rl8vNBdvQyY0RsSlNm2aZLvuyTqRhZ0sbs2CBWftTlc9ARHQOm4Zc//ho/kQiJCTwi0hIs5AS5JYAktwqceD+Is0c+ipzkQEzgZZGpwXqYnlZXYJbFa+bn9bIGhiEXZlb4VgpsfkWcfpKnJZ9+elZ5SQrczux6MVpY0K22sZhPG9s5chKa6FRqKXrPG99/YH6TQkygYKSM6eqmGrIsSgrjisXQE2qWf750ZlNloTiGT+7LZzbV/3H/2Y0qldn7cXqnFigo1bUdOp6I05lt/b2/+NgcXcVK8+OrO5TgVmL8/5NPrtId3Bn05TMblObyz6dPr6u25ZfMaSL0yEaFPrOi3/vGxRk6Ufqpwje+SK/3//f4WfrXV+usls+c3aQXzxRySLxtt7qqsrLT7iF/pf/P3/VSo7b+7DFW4qEJOSXmz7/h+pSf4JoFeVDHeH6yqYhAMUlYz96L8myMsFGJ5+ACJ3mqdXUJhnTcslJChFxgf6pw6I9tkQWy0mZSgh+4KJ4+a5JioAXJKBqhbbjqyMlViqVaiAO0+mE5CO7xNrcgy74sew9qpVUmKGhprvbIzzhPFX/xC1ddVhvtEKH91e88/CWe61/4rpP7Tt5zJXgB8YwcUp6Q1J7mWJlYjHC1Rj1Jmaz+XSLbBIZXUp6ThJpxk+euHsvyqFbXJAf34XarLT6TOLWa+nd39GiFnn56JijjgCCJsgMVBqpNoOBYFMwC+upjy2TZPiViA4rHvad+/c1/fiB+iz/2jzvleMzeMdWOaWi2EEKnld9ao0OFXEp18pAKYxvQIhMY5JnEYxaV8vq7Vh08zAyF7PS5BP3E2g4tccpsKZ+mzz21rpQZ4GgpR5kU+4ecuHpMvXfPpYwTpwwfG6+cLdCX1nQH1kuXyor0bLAq0+4P6I4TmsggLA4JtD02hK432zST1tsuEbPoVKVBR/N6XeIWde//9uun1OmfHYIcFAHeH+TEnCgsj+K+pD1sWhXDLJQNn4Iy1JDaMaqY9H0/SK51LGtIfTHLP3uRkwoTpem7RIQDA3hFCsmwjIKrDPzGxC+CFD/e5tZsWpd32CxHHSMAqOho0iHBQnj5Ji8TZRmXwvRYqCBJfh7KPVj+un6un3PIkveGKbbWVWFu+v1jofKC+yAx5pwro53pICNSUKbglNwtJ/5EohGYW6GkQNHo9eVE1g8mFmMysLQOE6ssGfaE5LJtVZrp8+t2dwtBIBrIiVq2K513PrU4P+Wp07Nq9k6rqW9n0kiW1SdiZK7sVtNUymvy0mo55LL6Mltu0sY25uj0/+I9b/rzN0z+qBcOopjEmQxMIyYoxcyVeBaQEcRWYAWkyP+PG56TuZI+yVfY34Hqxhkux7z8uFZLZG8/PlugVe7UObvboOOlHD3GCkqx3VOkBdhQj+nlrlZbVO271OxrBfmlmSRdw63Knzi1Rsu5NF2R09vkX3ZqdIrLRAu5NH1xfTc49992xSL9w2lNeq4tZenqcp7O1lqDr3zvDfsyv+4X8TjvUSYhAekQkjDaSjyqggSyHw0/b7QUYwKkZNJkY1Kx9hSQFwl4G1o3LumUprw+wgEEOmgQUT/HrnDsJ4uZwGeiNnKef8AgHEmDJKTD9mF/i4OCJJYYZlp2kqu44qQ2w5IQHSnjrHeI5lOoQ+rHsO+IjwXr5Xpkie+k0iXV/gx0XKKlMKsgwgFF5EHZE/1+nBz2b7RVrL3+/QRlH1ZXZFgeqQ7+4SAuKCjwrJDq9umo10g3D5JhEX9PyjCbVemwpikXSox6v0xfqSZPn9E+CUTXI4CNFAFKUrnYDjZlIukGJSQcLq66Yvv9b3/1R9641+c83wAxabS6u9Lam0jsfS4WcjIN8Slm2Gq9TfW2/v4L6SSl+ILskTObdCSfCXJQ8Pqrl/TMI6gbD5/eoJezB+WLq9t0dC7MSGm5+nteb3fp37z4OK2z/wXdPzXuvlnIJOnGEwv0sa+cUbePF7M0z8Rq4Hp049IMJR39mderDbr9Cj3XaLPe6vz9G64NW35eQATfsKlymF08fT/MQZGBf56RMjstst6cvYOSETiGsC+cexJT1JHGYJh8DEbWzZnSxRPhAKPFB75qVzaiPqkIKWn3yRdDa8bRbcRSZul6RBlWN7DtQSRMD4pptMVAK5Y1VfuwROQXHKItQ1FJcxictNaVEuT32Z8CoiPEqcvJtY0w5yHCQUREUEYhbcXopkEKrAAdNJJfIjAfF6yslimT6atBfaRC1dqBOo7kWCTCdngQ385uViXBKoxsCqS+YpIwqeF9KdqphITfbYUGUCTKQqERgtLpOtRu64sGeE5+/wf++KKRExCTZqur5KRcJhkYWGlC4JqJAWwPU86PozDLRMV8Omg7RomnzCSh2x9QuZChL53T3hwoHxWOiV+ptdRrfP4C51PJIPUVJR7xvDgrW4HPRVDkizyQHAwjlPmQfXdAj3K78A3LM/TI2g7lmaDMZZK01Wi3P/RNV0/+8C8Q1LtBlZAdRco7wu3MuHmUbXDxKkqJa5hr5Wl1NiKaPpWm61M5YQdkAs/pWZM7gzIjpNIeUVDMZ1ddP3CLl87ntxTh+SHDpRke/40YeyuXDLtqQAzMlmMoFxJp74V/+50uWZVeMHtFtQ2z8gGCo4y3u0wm8EPlso0iKnNGxw9ICMfeWyjx4GDQ49fFDRMuhJQNo2sowoGEHykoY0BqK00gH6PkhNg4S+rkGCoo2mPSIo8PyFA7lpZ0yWdru6AUk34vFixTxeJzRgrKQY1G+JvJ8qwfGG1BalpMPDAMsFDQFyJr63mlosTjev0W5mtBXsvv/8AfX5TrULMrR0o06JrJiarg+WPkpNeTUlp83+Sk23MpOaLG5IyS0CqXbY4taJXqZUc5OddGiU5vg3qnRycWygHRyWeSge/kxisW6MyG3nZQZP5lK5xG/fFHz9KrXnRM/Q2yVc6m6NWzx9XtJ1Z3aDnPx2zfp+tm8iqTxbKs9p9945UXRFpW34plDTPfSV02xGWbqusFXkfc3u7xFOS4vu2O7//qeO8ZhtdJJtuKK+FvCGELsdvzaSYRPn+zq99gPmlHZZ7DAqTBxmyymE2CZqpyDW9zRR6kcwYGWRCPGl+RgUzwY1bRIX+7pxQPUoOuwlZlC/ssvC1zvHOivCMKTc8lv9rV3TtkROcT+2PySbKYPFHdDVUZm7TqMpiwU0eIcEBx38l7XpWcwqlhdEUSK3FmCRQVuchb3yjRIg/ykw4fITTz81VaX9eXgal0n2K2r/JQAJRsmhw9n3AyakoxSkKyzPVNbQA9eqSiVBKPQ9za7QG1W+xHSfXVNOV8Xv/uV1ZLqnvnN7/zzy4WOZnIepWCwic5Jz5eopGyj2mKFVTZV1LMD1dDRsnJaDfQMntEiCPxM+nwYk6eJ/kosk6PbuzSTdypY2K2mKVXzeSDEs81pRx96nHdZnzriUWl4Nz/VV3iufnoPP3jWd3Fc0T5ZazO33zL+SnlTEO85/lx5SsR+c71qBi3hxJhKz2ONHYs9ZgAM3rkuA6uAGVErm7xEvGrKGLTx8WpfqwQt4aGEQ6MKyDTMIvUWJOcyDoQqzCTiE6EA4iuR1Y2FmadQBHBpiszFd3sEC0zIUdo0GY77MDBAEBpQUZ2CoyyfFNF1PO+qRgyrh7kqgXkR0jPwCPltJo1qK/UG/H0jTbRDD+2mA6XgfXAOnYjgnKwMfFccvl+G759v5hVTUJCHBMvEIIiA/pATkRNweRhJMuKEgNlQzJKQCpwyK6xt+SK49tUqWq/xe5umra3c8pvAtTrSUomJMQtTk88NU9LC1oR6Lsx6rIKs7TQoFbHCYhRsdCmRnMKyzqP+MmHKh9XkQhTMEntENSbXcpn9TqDnFTqraAbh0aIifnc0VIQSMdoLooA5KTGQwaRMXJkVpM/mGpLxvLhJTGj9KXE8+TKDl19BF4S/b3n0yk6ygRoo9KkJ3frVEpyaa3ZoX81r0hp673/9nh27ANfAICcqE8hJEEIiJALEJZkXEo6moiYJZcdVlBw7sG5RDwpKAdJngkuSOeTw2zT7NCp9n0qOPJ+fmCgTVuWUlDkMXCXBnsFZpJ2QKYiHHCgxFLthYQEfDifoCC4LWMrRUU9hKwUSHRCCqBeCGlFjRUkRQKPUHpZ4wOualXuhubaslHSwQ8OO2Ew+TgGJ7b6009YahBWcI7DekirMt4XywjHVUQ4kIgIigkhJ2QQklpNn+gwoA+mWeJvDfH1YnZFLomUeaCqnD07q8PUlJclLMfAvGrbHq2xagKfS72mT7ZXXblJq6tlarEycu014QiaR59YooXZRtCenEwOSAYXgsikk/0gkwXdPf/te/7nBb0C/b6PnVM7Ejpp2uzLSLOnzWUVdRo5oZGyjIIVnpuwvBZH1aMsJOQEqLe6VMoNd+XO72GwtfjcCXISelekjVy/B4iMqCuffXKNrmKis9Pr00w9NCN/fmWLbuSSUToRp2P5NJW5i+fRzUr3gReoXfi5Ig67ifaSaKDCD2LQYPkdzpE6k4KFpD3U4UPqolT/rWPwQSj0hpxJ2EHZBt/nRtdDcIv+8mKhUtJXKkm4IbMI5eGTUyZuKZ+LnKtAfuaY6KBktFenUIQDBPxQYkZ/OiTKTj/MRYHCIirJdlcTAyG0+Jt9JWr4X9tDczwvx5hkCYkOCcjSLqxyV4yWYxMIfuPXWWDVZEw+RvlIVBn8iovpwFAb4YDCjxSuUZgzdIiJiUCUkDyTF0wuJnWl3adMRp/woKqAnMhjbt+mHIeoIb4+kfDI58A3d2DT8eOayMAUq+KKrJA0djqarICAIM/kzFndeTI32+JUWBCpnuoqeuLUQvDcCwmUdKTFlwxiIqUas+NG0ltBSExFpdUOyzqblSbNjyyv0Q47o1QWJdfWRskJGXEdk2CSG1kmzLNmWQklHMlWedFCKfCUzqUSShlp9vUx7ebj88pES2zQTSUd2qq1Wu97zRVZovES0YUG1kyFaG52eIeysXNYQ+UT+RuEA74P0wciAGlZbXsqtIW4cycwvKoLYis45+z2fWpLDEVCdwZ1jNbihWT43vWeTyzSUMYi2upJmYio0veHnhvhYAKkQflPhKCoEg4mP8pOkAwNrSAIMLA64b4l5x94VnxFQpj4ormdSaoiOFknuLpQl4AbTEygkKDEJIQFwwnlEoLbkwPzVNsNly9t0VvDLZcRDhoiBWUUQkwmIR4fDN0L8yqpclB6zDCLuTeAnfXCZfpa4ZDAtWYjGQwEPHpsVxGXtTVt6MTQwC6TJXTmwEwr5GV1PR9cGJfLLdrdLQdm21yutzxh1c8rJnlLRn0kTcMkS6yodPkCxnyuSU6C+4xyTc8dBJH1RznCngyPiTyWdJwhQkJcZiLp8CmEJSTbDtcb5GS3xupZuxck1T61W6dr5op0JcfU49DYY7LS7bmN371raTjy9iIj3hj4qYRqctC7inxEySKB0iHnlRwf30fLNcQlHbLDFuS4ZQfKPNQVbHshOqAks4a3xFLeSCt4XyEknqrNUZBeh5NaQea9sSpf5Z0q6uI5pZNBgAAAIABJREFUuFBbNpsI23eTpM2u0gaM8o8M6wN5wf5lEGRL/CEo0zgx3a1DXCpi8uBbA7KwL3A3kF/rkSUZJghog/Iix2UrjL9X3hWoNvNMRuBSd40DOCTT1OQgpggHA1EXTwgYZMfuDPJP0J3TVV04pDpucDJs08aGPkGWSi3a2tInUZhj0UqMIYHA6lopCG6DybVUalO9rq/8+66tWo81LKWSSJw+FJKdHf3Y7ExT3ZbgtnwmJP4yKHCD3/+XX/+htbEPcZ4ghthJptdR1Nu9MdKyV9lnGpClYhITgRhgE3G9zElZKTLV2PScbFVbakKxx6UopM4KecH/Jfjt5UZ7MbCxU6dz9dZFL+VMQ7wYt4b60NqKDPhUYZaQTlvKDEukiQLOKXKxi3LPXCI0wkKPkTZjs/oC7hGLh0MHUSoSzws8LOm4FZRrUMaJ8xVRgncYISEgOuKzhOEWhCcSdw8BsK3X24G5FTN5rJITllV8JZXxY3EdhS+oGhH5cZsskJl5/i2peTucWIm6obHTIYzNP6s7CdDh4zsWWUJ0fYOJg5xgGeJlARliz5OagBy3wvePcEARERSB79u/YHpQBOl0SAaKRb2vO1wqXVgI206FhCDyHh04crtYbFOHSU6jmaClxYqKpyeeelzhScfXXLVOW1sFlWtCykuSpePH9NRjlHYK+Q6lWYlRAwlbPKE401elp7mZZz91+fkCF8K2cewwyzbNTp+yqVDRWJrdW2AQIlDK793sslcJh4y0WRPS3SPLhtEWMfnAbCGjlrnGuSVYT4nSh+dFgt/ggzkyV6AvPr2J53f+9g3X7b2iFxlqK+DE32ZiwenedCwdHpSlnbdh6UyTEh/AE36oroBwoLyTMJojBCAfq11esLp4hYISDlhpuT5luVTT4VA3oOvrCckpY+fJBcrLcEkpwgFHjEIFAwZVME3ZBwpImpUQNwusVZdkiH/Jso2hoKActMmlm7lkWH7BsvBvO7ytSJDsLRg0KCbdhqvfkzQx8psDsiSdttIPhwrOJ8nf6JI1FykoEQ4HLOnlH4F02WAOjxAT4jZgx9E/zHbLUaUWUmpHXRENE31Xn7QX5mrU7SYCLwu8JBJL/8SpRUVSEPRGqhunQysr4WC8rZ0cXX/dqvq7Xs+SzWSq3UZnXzzIVrlQ+M6/Pf1domRs8Ql9zsg26fU0QdkrFdYkJaNGWSE2eH23K5Oi7X2pNQLT82JitPQDLBoEKsUkyxxGSJqQVf/uW687FEUH9QlwbO4xpZtPcxeO4QkR4JwC03CFr1gKCagdYpL1qNn1Ke+EzzdD25aNstBOzxtqLUYrcTOYzROq79Wenv1jptWac4CW07ZqRY5wwAHZEVkn7DnxOy5ZuXjYSoyNKaoINj5SYFt8nAVRsUMzLTW7IXmJ2+SLggLS4XhEOZZbcVt2G5Ro5lPhgED4TiQkzuLhhHJc9JG3wuFEW12yEqFJN8JBRXQMENTr2bvNmHnB1AGBPlG3o38zR4/uBHeDnMzN1egMx9LDBIuOH+DsuRm64ootmp3Tv9GVcyWan9fLB+GAj6XJXTylUofaHKU/P9OiSjU8lm9tZyiZ0L/DRjtB87PNgCxdDMxNSIQ1PR7TYKolUpLBacl1B0PEJmlkm5hzekZhtgwj6XqUmKxs6Tbtci5NnV5/aD3Ny/Us+0zk/zilvvvm0qFyQ8Tbnu+gpbjo6B852np9Jg3EZldpOYaXEBexc3zlC99J3wpbiZFRYpprhdugdRgmWCnlQ07b6OrXQanpqPfQjyECX9qTHSgydlhiyvOcIFJTGX1aTNrKRAtccEdVhH2hcvdtP2G/NqlbgMXsip8RVJQc7yAtBKlxsqvN2SfL/AM91yJLzLRQQMzsk42ObhGWcSx5W/tQSMo4YoLSZMWqs8kP0fdNY1AhjNq9MEQOKor6G/VM7LSN6YbDCAcA0UVKgHS68+lu17kjOdIF47EnxLbD7wpJrYuLlaHniWoyp1QSh+bmNNnB39KNk8t36dy5GcoXNHGX7h7iNmOoKLMzWo1A+/DCnCYvyDjZ3s2oTh8AoWwypwc/a5jhY/aF3Zbv+4YT//MnH6r8yej9ZoaIlHmmYbQlGdipjUfgS6sySAzIieRFmnYIKcsIkBZrtg5j2vGRuVDZSvJcHrQbm0MLYfitcgz+XCl76IiJAN/V56o97xsyQdaJr9qBxS8CktExkjdRYhHigc6dde7oQfw9AtikRdg3QtfqnHMinkgVXMs/GLxeEx79HlBWgm5Um6jm+oFfEh084nnZlqGBTlTiOchoef4v5noD8utuaHbFJOG0kXWCLBLZyOmYIisWn3SUgmGK1vCd8C/aH/hh1ACUlJ1+GLiWt0PSA2KDH29yEC5D3rtL5BcToTEW6zXLBxb4X0BqCtMPThEOAiKCIvB8+1PJZP+OYKAKX0AKMUFZRRQWlRLrW0Er8cxMjbqsdqBNeWsrH8zRKRU7VK/ri4a52QZR2aeVVWkXrgVGW2SqoAlCwtlgkL3man3Fj46ecqlFnbb+PSEHJZfVj+3sZqhWTx2Y2Wpmkute5AR+FSEmXSOOYNJ8nkZbf5cY9uf2XWqziptLJYL3wwm5OOI/MZNjR02zQm5sJiebHPCGjqFiLl37f26ZGXfiHiJYapzzHbf6knWCEk3CDuftnG17dIzLPjC0QtUwCcpaWx/os441VI5BeUdUEdyH5eSNwDUT8KDIXTDMxsILa9XtI+UfDB+sGyFx2wZhKT3wYMRUDiCeuuNWf+auuo6v7zAJED8IEwi18Yv8I+yCzAzIOmqQBN431ahrn8LSUH8wPOQP5ETUFnTnyJU11BoEwAW3XfIbXO4p8ZygCmet9LzAu+JXXbLK+nX2mxe+mnv5/S++vLbewUf98696yLLTNx32z5F72UdesOPXLz/wGr/V0srEWGkHxMUaJnRImyUOdcPMHfU0sqhUbFKNg9NAXiTgbX29QAsLNXIcfezv9WJ0jn0ms7NNpUKauSsy6bjXjVGn59DivDZyIgI/ndLHgDxUGHgcm/q3d9+3feCCHc//04PbZxKJ2LGxBwwM5IJ9JHvLTIEdzT4hQ4lJOLHAiIt5Pf5z6P6ZVBYylR4Dh1YxGYX6VCi/SJkf3TsLqbDMUkyEabHJmEXNvq+8H8SlGzGpojAEf6J4D81SjwppMzZy1Q29Llttn8pJKwh/g/dFfLB2nOhMy6McL2sXV73yWEJ7ImXd2nfe6i9/8jMRSTlggI9IXWeBnMjsHXTVoM04w14PGFqlbIPQNhimZRYPyENbiExMl2uSXNbBJGIhHQUmGo44rAdhlorDKbMykLDN70Ecu49Jx+xdsZCRIl4VvK7FWStW4vrLZqMdIlh28iaKevmGkHD65Mb1bwu+EeSXSPYJjK7hxOCk8oyYs3lSTBgymR5Va5kgZRaPCUHJZPvU6yVoY0MrKvPzdVpc0KQjHnep003QKS7jZDN9NXiQOOzt2JEdNbtHrcsgRjE2ycaKA6XeFLj75z/9yZu3f+vf/ens2Ic7D/it22aPj87ekQwR8XbYE9puRgnDpOwTIQ7mDJ3EPohJlePsoabI33gvROBL/D1Op7J8lfJhXTrERKA+XTZuKfJBFHoFO67kmcAAq+/DsbyUtBQxIZk07IZekpTtq/MHUOl66rnEHkmU8kUnmUkidVy/7jinudWN99voiCyplfl+MELaom32ruDcA9VSLAe4P/KhHCys33nrbyoOYrFJifcj1fILdskbz+qRMVMnpp3QcqVSd8OgNrSYIYwnmPveD11hWWu4dNP3yU/w8rFvYwcUxQZKTM6QbR2bfOlf97isRLxOMYvsVxXbnFsbIcKhQCbbmbiaCGATRQPD/mRiMHHCbNZ4XUrN6dEHdHcQluHhZwGxQW4KcfT91rY+OZ+4YksN+oMXRfAkp8MihO3MuRm6+qoNdRslpo1NvS4o7+C91ta0glMqdmbGVv484t03lyyTpJjmWHhMTH+JeElG1YzReTgmzDLNfmCWeeRvkBMM+xMYYk7117/20iImArV3ghzgShf/kBaLLht8ePxTBMTSJ5n+wFcEBmFq+Ie5OAtpS/2DmRbEAs/HP3T48MvUtH2o+lDdM6z0I+wN/1a5RIR5PPgHBQcKDf45lqXm8mB/GLB4UkpY6h/ea6vjqwtn/JtNWuqEOPYJI1w0dDz6UU9NHbb6PkgFiEHKJguMFyd/KB5xe3gYHwL4EkxChIig5FJylI9FxeZD5aiNGFc3u+RXXD2fp5xU6ooKZ2vzjoPJxhgEiH8dTxtf8W+zrdQ/C8oN/uF1IEL4t5BWxMa6opDGijW+8JrI7HCAoLeHT4f9nz/orLyQ36rE3JPRXrxbyal/pDwjdfWv3U4F04pJRdInlcKCf2fOzqrpwshUwT8EsVX4HzwndtxTwwTxL5XqUsz21D+Ql+XlMFcF83zgX8G/o0d2yPNs9Z749+jjS8Yy6yqRFjkp+JfPt+j//OC3vX7sw51HgKRMWnp6xIMCH4jpBVndrql/ICcISsM/Kb1MgjthOjqyWPBv1O8tgwGJBweOlJigmFiXmmpiQikoecc61/foKPFPHd04253wm5IJwvifrwYKsjLi6xINsRKSTIM4cFywrTtyiLQiAm+J5HLBq3KKuyhQvjnX9mgpFfpcZBghvCn4U9Sd1bYfsEa8H8pQa7yequvIoh8loh8b+5QRLjhW77z1z/pMLM+dzDpHb6sSlfjqAiUUkBXppFHzcLhsE7d0Jw7vA75jdNXgP1udMKcE7cYSO+zwNEv2kqhlzHJ7Hso0Z5tkFXlIGp7HBik8zzLkWz8TC+cCbbSVgTaa9XJAcYlsl/yNDxwdu/N5IJHoPyATeQtcvpEpwWQME8TsGwSyFQq62wNlIMlIice8IAJfPTfVV7N6gLW1MqUzPSJudIB6In4UGG4x+Xhzg+f7pN0gVXZ1rUwL83XqcZx+PtsNVPVz58p04sRWQKi+8tgSFJUPj3TOnneMKin7wVwxVFJsJi6pCQmwgknpsPaUuXIIbJsQ/nbJlXKmwZKY6K/cdov6Ywmtu64flE7QRVNgQlLt64O5KOAgDhI7gcoLyjYSWa+MrbyZi/wC8aWsGIZZEBKoHxUu3ZSMvwes+Iv6jg4iz+giRZosn4+UsiMlpWOfirwoFxvYn3ARcUVW/xhjr6yHZtek7rCxTLe0HBJAOtTd/BhYjpR/YIJd74Teklyc/F0mLylOfGVFbqhLCEQIrFjeLhfWgH3b1nc3Q0XGZ9KjOoQKDtlvGh6alXv5R6P96yKj8cirLxk163zsT/edvGdf34/Z1YNOHOmKQ/mHWFUBoJJIp06h2KZaLU3ZjD74ZrNt6nH3Dwy3hUJLeVFIKSgz1Hc14U+nXEVsBny7WksGbczo9kHbsWSyZLI9KhbUY9W33n7/RTkZg6iYqbL7gSggEywrAZR3bgohIS4V9bircMGY37Nb7zT+4O6DNSvnfCP45sWICvXCo9BLgotJ9lvRrG0rQiGKStUgJOAjKMu40h5qW6okJM87mrFVJw9xmUY25ImMrd5TyMVuV5tmif0tCWPGG/6/xiedxZRNnQFal/WCQGIk/G337tuuLD/w4FOHdJscenzpllt8tJQjRE86sAogJxLW5xnqCGeP+NLhU3OVMuLzDqjMrNLmDjZadIKJxbTbD1QRNcm44obmVyh5bMJVbWHlFPmr+moSJDtoQU6z50XyoeJGlwPUlDcujM16aTxyTzv38vsnF5sjnHfUP/+qnXBWQYRni1ZTexrgUzFD3VB+WVrYDW4PBrFA7YBXRSLxq7UsLcxXaX1d84ZWK0GtdlgG6fVsGnh6+8zOtujsiiY2S0u7ag6Q+F7Uc7gdOuEMVNknx23N1WqSNvVcniLdfnE2sZR8QFT2QzxGH0dTSLvDWTFG2NpOva3akCU/ZafeCubyoPwDpUQG+DE+/+6bSzeOvdllgEBBOfPKW/+y0fO/CYd+lFtW2qFpNcP73k7XJ8e2ghj8rlFiwakgn4DvkXc4WxMT4FjGVt04Yog93fICFQZqF7JMpGsI3TzVvpR49MWuVJsQzLbLV9PoHoLS0ufX4XYm6CgiuvofIhXlYuDJr9dKHDY9SK+MUECn71V3cB4CTLLYbvyYPzCMqV0vzDIhHbJmlnQCb4m0CAvZgT8F/pYWp9Vaw+qMlY+pSHtBcAUDEoPfgKg7MEn1+HlQDL/vyMRv0fe7P1+48dPvHHsgwnlF/eFX/u9kJX77UvmW8zd87Lwcp+47ec+vE9GPjz0wAWKazWU7ShkhnteTSvXIZbWj0UxTraZPsujE2d4tBFlWTsKl3V1tKhUDrODxJxfp2BEdBgdisr2dpcVFTXRcN07Vqn6/XL5H29tpKvKEZJCVOr9fLObTf/mO/3XRj+c/+VDlJ4joPXJbZuPsB812Lyjt7FeRmeaJuZxgmVeHyKyAZwAXlXJBC2+HdNGg1Wqj7SliQnzlm3UkjM2jmaQVzHzDRamcI3A/zj9CPEAm5PrH48n4oryAf8hj0swhJTs8Ly8JtwNd4onxm4A8idKC8tTRtE3lKBvlguJfbrnFyzi6YgKxYy5pBZWbzY5H13wLTx5G7g1KKqKotML2cWWIrRqPgbBIScfWs3IkklgpMJ2w5qdID3tLVD4KE2ncr27LVRBYt6QGKsIzCOf0dAdBScm6p9ij4xmDLQ3D9wcnCjd+4umxByKcF9QevusKy4qdvpS+3fwN95+3Y5RZ5hGiAZJgpsw2m2lVopkEGGVTKX0lj5LPKs/XQdgayIsIm+dWZuj4se1gCfChiH/l9NNzdGRZExTHcZVp9hg/d3u7QDVOkkU2yuZ2jsolTVAq1VQQe7+8tEtrayW679svXDbKfiBeFXMo3yiqTX3MK06YmzMB97z75tLHx+++fDFEUE7fcUtlu+sXF1J20D7cUx03rIrELCVbycUmSEWfWXRHTTq2qMYH96tysUAV2ez46twiRKfo2EGUPiYVo5lCZv7AGJvnUwLUGLzGsUJlxDOIDEpFQmbEnEtc/kGUPt7iaz772YikXACcuuNWz2gAVuoZ9o8jrJqhOws84KrXd8jf7uonCklQgySFPXCLsCgcqTAjBZteKR+yz2JiccwKXjbUDVRwQn8KwtYwgFCyeUBwpAsIhCY1xMh1eixe971Lz/zF+YM35m/85PvH7o/wgqL28J23W1bs05fSt5q/4ePn9dh038l7KqpEoobx6RMkWoIl24SUxyShyMYo1teLyhMiyog5pweKSy7bJdvWv5nd3ZyKxidFOnKUSA4CU+7p03OU52wTEI5aNUWFor69upanQk6vS6OVoJlyW5V6SKXM9ml9XRJuW8qjUm+l6Pfe8seH4nj+I5/Z/uWkE7tdzMqkhxE+ELPo3X/wqiN/MfaCCBNhjdbX1++81UfXjemPl/OI8oRYVjBRuN33A3VDYi7yrF7h/hrv9zgvoJt0hq9ut3ueIhfEnTlQ2dPxUBkRElJOWOqCWbws+J+MG8D5BKWmlXYYrV/gZe52PGXglRC5a6Nyz3mFGKyR3Cz7TYnP87KdUY5Dqc++cVfzC5/CmHo3VDegeijS0ZLZOH4QPaxKQdhZmECAxFiifKio+16gmijpjbt/1GMeBUoM/C4WJ9f6Oz2yMPeHJyQjNA47vP2qfINmEpOneY3BezJ/4yevGbs7wguC+sN3PkFkX32pfZv5Gx8478elSWZZaUNGgNs0QC3BnB7pqoEiIm3KIB/1RpbyufGhhAiGazaTlM/r3xPMspJGS6osEqM4+wa3KxnKpvVJYnamSWsbBYrHNEEpFDoBWYHJFom4kqfy29/zvuh4fplgjKCs3Hnr+2NE3y6GVkTey7gbi0mCvELlkRizeNCtI8P7PKNrx7Y1mQm8LB0/kPRR/oFSUmPjI0LjzL0PZSWZrIz3W+f1wvkH84Mkkr838IN2ZJhlY0ZJCX0aWIeXRWrKC46VV94qQ4LVMEnZnZCRg10hyDzzQ+J5zWuams1KKmDMmJuDzpwGph1zGQex99JSNpvQRthC+JhAlW2gwsjOim3PbNmvuZoQiYJiek7Q4gyfSyxUbOBxsX9ouHNnP8jf+Ilo/3qBUX/4rrET7KWAC7Wv7MeLgkGAxKrFKGR4oDKhs1qOtmQoK3M8BBCvTyY10ajVM6rlOJ/VZQ94V7a2NEHxfEslzoqB1nXtIOANLceIzJ+Z0eWmza2sUk6IW54xHRnPJ06kLRS7X3jX6/7i5WMrHOGSwhhBAR677RZfSjxkxPy6nq/m6ojaAQ/ITjf0p4BcSOOEp2ay8YAqV5d4xC+COHzpf9/pekoJOcdXzKZyA9Nr3zixmQGj5A87prFeLekYcSz1XpJOi/OUkJWb/ukfo5PIC4Cn7rj1wUbPvxXbo8vfO7YHymvEbefwDFWZeBacsGx41e11jzKWHchhGx2tXBAnuSpnNqsdICh5fh4mbSNMTSS9ep98kfAsJhcMs40P5ljL80IpEFH70o7s8Z4o5AVE5fvmn/MXVLjxk9H+9QKh9vCd4wenSwQXcj/5vz/yzb45kwcqB/FgPzJMstJaTFzigZm1yR0/9XoqGIeCwzHUFYmsP35sl54+o4NfkST79Jk5FdoGlMutQKnZ2clRudwMWpfbbYcKeU1IavU01RoJ1UlEKkm2HVyo7lQyqrMuwXH9zU4iUFf++/f+SfR7Ow/4qfd/+5/6RG+qN/T2ny03qd5IBgnBUNiSPHy12XJocaFKrbZ+LlQwBPgR0Yfeevv93/p81m4iQQH+6WtfoR7AcbuUlLYwTRaEsECpkIgKLAaKRsOIwRfja8mx1c69y2oLyIScV+TqOzx3WMEJj0iPTxl4w0oMcXgcfA1iXSgliVp8AYByEs6LrUB5sYNWUZR9ep7vXvcPn41G1D5HfO7r9L5hcyaOlGpQnhPVDB6j001PtayTCvmzKMWPgbie+IamTn5liGKCHUoGAJIYXLP6MYvvDx4fPTSl7VAlwb4mhtnGQHf8bPN8H+wPo+/BAwjV/J3nQVAEEVF57riUiQldpH1jUqmHRnJQRoFANjk9zM411Iwf4lTadKoXBLdVatngeZiajPwSMdSWSm0VCEdqHk1aRdlfdeWWuq0SamvD0e07O7qrp1DsUL8f4/fLUCbdUz4V9ViuS05cn0saTXho3Efe/R3vv2HsA0TYN374vW+ul0vtHMpsRzkJeHWtoIL1SEX1d5XCJmQWahaULACeo4X5mhoiCSwu1gK1a3OroFKCKxXtZfrVb/3gs9r3pxKUtTtv/dOu579JKREykM/DhGIrCF7DvJ6mKwFrdtBWTCptlmiLb+OqGvkpoqKDN4jS4sTEo8CeAytUYWqsvJSZIG11woA3vC+uyuWaGbd7XqigdI0YDLQrJ40Onx6/f86xrl/+5GceHfvwESbi9B3aayLqF8giNr+oXiCZLUN5w7YU9cvi7UKcmghBY+4W7e5XElfgvPaGO27ANMtOsOPgbmvEDKvQ9VRkvfk6n/mP6u6R+iTWH/uckB5eVtDK/EPPn5yE8NcLN53ch9M2AlD73O1fIrJecil/GYWbPn1RiOt9J+/5IBG9wbyv200EpRnzPlLlHn3/ChONI8thPgo6fzDYT05Q6bSrZvyQCnTrqfZh29JXnp5vq7IP8UXsbiVNV53QBOXMmdlgkGC9maCY7QdX6PCbSAw/zLP5XEsRIWBtPU9XX6WXsb2VoxQv412v+3B0UfAs8OPve+Mnkkn3TsmlQQIwtgemTJP63pvUZlKI7zib6VKPB0ZubObVPCYA2wz5Ni4TSmxL2cYI6sOMJdlG8C/5vnq/6k/f8dFnDOCbSlCAh7/uFbpbk0mEmnfT9gIPylLaDlJfoaRgor0oI+jMEcIgwwjrhvohSgheh+gJicFXg2N5+XhbkAlZRwTBSammN9AKTUYC5lyf0izrdzzd+SOlKJCXciJMrlUTmvnENJO06cpPRybavfDlW27xpVynBjjy94wMGnz/fVbBBhSG5YHYYraEaCQglhIG6DGpSV3Xo0y6odULLs+o6cR4E5HmLAr6zrEzqnj7lrxhmKWiGKfaCdl3grIOb3Mkw6pOIM5XUX4X6f5xfZ1I2x6Q9YNze3wLzx2WZf1G/sZP/cT52j6HHbXP3YEZWj966X9S/y8KN518w9jdFwi/+sl/7dux4eM9ou5nZ+pTV8D0p4hhFuWiTjtJPVf/1gr5Ju3s6KtnXHhA+RCTLBSVzU39OkTZo91ZTog4Ua2s6ity3FeEMZaHEybQkryqz19HFmuqiyed0Se5TjtOs7Na9VlbL9DcnPaqJBNdOn1mjv779703Op7vgR9575t98QH13Bg5XI6DRyiTDgkrjMobPLIA22ankqYXX7embp86PRckCSPAr90OhxuurBVpYV6XFKGIoewHAgM06kmljhEbr6G07ZVxsydBIZ1t4Uu7MAgA/i7JlTCF8j68KDhZyRiTikHMbe7slHIOxptIfH2D5+0k+KSHEsEOn5xSts7RENVezZUzToZmpyrKDfJJYLjFumYkTr/rBWZaCZ4L2qONK/7FtPX985/4zB+NfQmXKb54C4euecPkL8/dME01EsEPurNqfcxc0t+VkFFRvLCdxYMEszNyUfA6paJgOzvGPtrx9LRj4hpg3HisEJZqEMYmPiQVXdsaBCGwyizLO4cq8cTC8Z++sc2VBwXLf8sFmezeLdx0MjV272WK2uduh5ZcuFw+feGmk1MPxBcKo6Ueb4AmBf2j7fdiwe8Jc3ngHeGrXVWOkTh7kA48DiWFOOre4+MpVJETfPUskInF+VxHeUwGnv5dxmNuYJiV16MNGWj3HHKMjh60R9dq+rFkwqVWh7vwfEsZbIkVAMv2qcphc0sLtYV3/Nu/3qQICv/hD7/bx4RqqCTYhkCvH1NdVwBMz+sb+WCuEqwVMX4eZjFB0Uo2b8xpAAAgAElEQVQkNIFEea/D5BWkA8+SFOB8rq1mK8m+gvdD8B+x1wjDJvXfWer3bJqdUWTmkbfe8bGxMt0zEhTg868IT1S48BSfQaUflm1wHy5sza6NtNESjL/Fn5JVgwPDv1F26TAJAimJS36XS+qEJ6/zw45TRYZ6XqjS4P3lk8Bn0uqH/pRYDBHC+m+s+sCnIKNlPmWTDJeUTiK6jM20Z19560s6A/pStedRWTwcYYcubXc95SEivq81GH69lNwgZIC8ioka37NZKgThkcC/q7+uEpRcfM6zsYygNkmFVUTCZqZKOulVvCSKgAg7JtJhb9LzjvXthTN9VHuyG25r6/Ul11uO73/gxguA4s3/cNle5VUf+vpL2mMyCQdpe//iR79Rff/pdHdPD8ooREFBtw0mDmM+j0CC4OJsZIW0D8zP12ljU3NQlAyy2TCDRZZHnBxrWz5tsNqSTAwol9fLx33XXr2uAuFInQi7tLUtk5kbMrNHAbkrSQ6X63XjwYn419/855ft7+3tf/N6X0zF+C5BSqRU89IXn6OvPLqs/gZZLBfaag4S8fm2wUF6icRAdVLBU0SKzNrU52XMzdep1UoGyhhC9q7hRGF8/08/PReE7iFbJ8cDLPH6ra28IpnAkSM79Nbbh4ML90VQgC+8QvwH4UnIPPHj3DAgQ+HwfUU2iDs+ocBX+GQym7ADlSTOE5LlqrzS84ILZngYTOIBP4N4VlA+iNvh9GRcjYspt9n3VcJtQDxcn+b5hAcDrm3MjYMKIKZfvJdE6cNYi1bZRJx6X/PgZ/cVA3iYcfaVt/pr7dDErL5LqZ44IaFUFZH/n703AZfkvKoEb2RG7ut7r3aptNgyxrSxZNmWCmFLlnEbDLjHwHhgesP00NM9S7O1BgE9YBsDtozoxjR8Q8P0ZzENAzM0YAY3pjEglxdZku2yFvuzwZJd2mp59dbct4iY7/xxb8TNyMhXr0q1vFf1n+970nuZkZGREVn5nzz33HOzsZrSEOZC4bsjUsa8wFxneZzHYX76mss1wDyna28PjVlO3TVPIrN4SJEJUwqC4iEmakTfC6HBTISA4tIQaoDVnFzksIQkykkpG0bj43GHchS89fJ+ib8ayMrVSEoEO/H6ipKCRUUWGiS9jkZhGRTGVqgnMvkYM3OGIyn3hAsYBgPK42SRWV2r0IH9G/TCC4vRc+3bF35jhj8FpKTTDp/j2mvXomwT+Nr27emQwxLoydM1OnQgfBwW1EE/R8NheJymfMRntNMpRGZayKc3XLdqylZkzLtF2rMYkpdiYWJamvM57y9/5fv++NtnTsgVhp/88NuDMpfExpMMPX8iLJfV4CPxslRigzMIw4jPa3/g0nDs0kIjThaGwTU8zyWjqICcklE/iqbTCsCAR6guQijJcITwfQODc7PZi9QWqCt97uIKM2+cyEQNRaXbyU+VfLZNUMiYJBHi5sdjuhyiQtTRQzShgMqZuONmMIm3yzvx2oG/RdEHYcACJV/EhyrPBLeDlEi5AN4HXQnAeiMKinmM+CyDgEtDHP7mB1F7MlJyV4fBVDu0TEge+LGnJcNliWhN4/LW6z5/ZSgrUEpGHn1JCBlOn5wveHcwukA8PPCYyHmBsiKXdQlenlFMRM214+0qWccE8iXPO0l3V0DR7CScbHiG9t28FhpicTdLM8Y7ImoKVBZEmnSZXIB0iJqCN+DYj+f7VLLkdOO5PI4Xd/WYpNqsQ07doeD7FmbOzeXElURWrmZSItjJ11NIiigZkO21KkJsiCUu48h21Uo/UkqIvSSnTodlHMTSJyGdOlA6EIMv38qvu27FKDhkFsquUUhkAcTCucadH4cPbZhv/lIGAhmqclkH/gdE8hN3lsCwKaQHpaBOPyRDWHQ3WiWq8+PWNst0YG+7/0vf/aez+fS7FP/z731/cIDJ4PpmOSIFw1GW9nNmDbqvQEKkXAcfyXNMXkAYQOQOHgibF9BGLufZ5bKPKFJQvGpVKdtUjA9JcOp005TbBPAMgYwSd4DJPvA+EuWN2Ock75X3fsdHzMU+J4ICfP41rwvkqfFNWr7MjlkxkfUC36RFwsc3cDyoq9qHxXMCApIMZ5P8EodJSINZCTwOMj0ZxER9yTfbynqHhRZdO6Lig1hE5R4nvF1SZ4lDxYA9xQytsHm27jrmNYgqg/WNvySYFlrPkCMa/b1Hd4+6IqU64unVCMCTYYt7ChlzfonT38EPxNS6MYrfbDh/UuJBxQZKWV6ZZmUsgRlRACXGF9XEia4P2r8dlVgPA7OYn19yRytkjTJHh080sc8EZR4Z+mdMsOzKNibXYTzICfkoRo2hUE1B7olRWYglnIUsBW/a+Z9NjVt3zzypzWNHrnpCorEbrl3SkyIyvXTQrLK5Ed6OGsfSS8eOGGMXF1tTj8dj8Y2bjMnWNcFuxAm2IDqnmcyAhIjpxfMcQ3TarK7g27z4Hxr1oRlUeAN3+GA/a2vhQlYsTcibsKI7zNHCQj9qcW1tFmjI05jRcTIYuVRlEyh8ESgVkZmcXKS1zQotNXtHP/D2P3njzEnaofgX/+kHotINcmeQDyMeonzWC88vt2KLmtLvu9TuFqnB13Iwiivb1fKICsUxbW6E1w6TqDudfHQdF5d6RskiHhC5wdtNvAwtNPuRt4S4fZ3YxwJTtSa6AlzHZJoxEoqJDc8/88aPOedMUEiVe7B4i8QPKT+XpWiRg7y/MY7NrsZoqcyOoq6AoIB0iAcF65EO/Czl4i4RPF+GqQzWJTMxeRwbeCtqQQ1UN5BJw41ajgOeshv+jeOSi4ruIhlkW3bDPBb50t3mxxFXD0B65NLmMnEZqujS2ss+8+glcVxuBSS8QrHAOZHrACIh6hfOtxEVsvE1ES6L143XL3yypIzLGjBLJ/1DAiho8AEtcHfO6sA3JTniaw6SE+1ReYIwSuHGb90M1RAK09+ilNeACYvE2U9i8mIuFLaTsDZfhezgPaJD3N5Q9f3rs7o2tZswatz6yGUnxZvHbsen39xBilc7Grfuns7AeRkpSYx5sQdB8b0MZbIyIytj5vEQE4trDsVze1AGcnNirByZbJUDrLKA/CzxojaeuHTyRDNqR0WI2/WHw6GCz7+wQJXqKFoc+4Nc5GnAwohyA5nFrUAvf9lJevrrYQo0PpXH/A19754O9Xu5qBwEBSibjdWA1Y2KSawFSoUR9bjduloa/fW//W//6M0zJ+MS44cf+IfBS288Q+vrFZp44WuADwTeEGLrBdp8r+WZSV/822voVd/0HJ/LomnNJjOlemC2E9K4slIl+ZoPsof9iYoFlcXnj1AQv/X1UhSkt3dvJ9onBkoWi+No/hJUEOkGgkKCEo7kp+CaVCrSQROEU6slDG6xHZUNoZK959s/cn4EhaQFWSkRHqvrQ7VYyb9QLD5VtRDqUorvq9JPuMBH2SpYrDzVqWPahVnux3werD/S1howSZHnU2KNORZZRPNcJpIwOCzQYsLV6oBPYVlqqFqlhXyhNAE/hRy2q5SCDFea5Pkd5bVAR0su63zsxk8/8paZE3qO+OJtt40GXpCDujRQSg8UjJFK3sXrlXOE8ykTn/FaYIJdicLzYjWqakhNfM2gislaP1RqFIilQ/HjlChlzjdOq3R8QaWq8u8gNQHFLem4rlk+Sx6FSty1dzAbn6gSDzwyVTf0lBCJ8zr8vZkLu3XEeGRMtywJO2H7MtqN6QcbPsU87YqD47gfqb/6obe92Ne1eexbPkLkfdfMHRZnRePW3TdS4wOfelMg0rtB+I9mahuUZ4jbQ7HgILyLzLfiwdR2aE3OcQlofaNCuXy4n143R6XyiLRh8xCHgqHdGISkNwgXKyySWBABxOPDywBvC/E3b1mk0cIsZY3BKGdIiAw2RKmnxioJFlGYNzd5MXzly09Qu1vm566bUoYsnC+cbJg2ZzLEpmtKS2t8LEhPlzbZk6frtNjo/eyvfN8f/8LMCT1H/Mvf/YHlwSi3F0oIJjtLNxNauWU+UQ/nFZ00fGwHD7SiMg6O8cxKNcofQWiaXM9c3ovIHQzESPOV64Phjlkux2BGEkjeoYPh+UMisKhMKJeh/CejDxaXOiSlFBPcVxpTnUs+eN+gzEOGQHbZyyTvpSAiujDLiuJGkk7LBmeehv3MeRMU4kj8tuqwwcLd49WrmujU6SQUCFE0PE58lXZUTVh8Xqz0l2RXKRp4zZINh31LFLOHiflBvJBi3+IzgXkT+xSCtGK6UuT5iBb5ODAuCAZgrexIeWnCnhZtEBUvxwL7MipSilJR/Q6/XjlOR0X7YxPkyojpt2LmDIX3QSXS56Gk+k1ANBCAFokFUHbUxyPMx/InjlF8HzgPIGOybUFNop4wqdOaSURyMk5kdsWuqlwKk79l6UduCk5dTREUXYLD9ZfSGs6lGJWxjSg5e189CPLUd4gH+5mUWTNYMD6f0TRjPA/MtSK8mLAVfm+i3EMB+T/UIAuLiwXHyX61cevD37BbT/CWSkqCsICgoPWUzGd2hmq1cHESU60mM1IKcjI+1Wu9yIgLJUa8LCATB/a3aJVn81QqYxoOw08CxOXDyCsps8hDaXLbKpQUeU4x4Ppci4cq4/LE5cOHV+mrX9tPi9yFgvLEgf2hAbTdyZsFWHwZUGgy/FqRy4JSk8OLPcoYT7FCg44XLO4SWIfF/NnnY08biJiUzMoon3CLLlSFM2sVOrg/JFbeJBOp+Jut2HxKxvvhRZ4dqBitdiFK0V1Y6NBTXwv9NtcfXqOTpxqRYgQlSbJJBkM3Uje+fnyv6cTxJtKh6URlnD1LPUNCTp0KPydBFsRLgvOFbRusvGhfiZAM7BvAdRTTNMYp4PVOODNn1uNUjAgu9iMeFCYo5+5BSeLZ19/+RH8SfDMWm5wqIYAg5JTpEp4EIQkgJGJ2nQRx3gnxN2/dJYJ9iE/CU94VaVvW6our9llRxlsQBP2VxjHLVUysZDs8RnwyZWPQjUsPUs4QeKoNZaxUBZfPQdSJlInNp0JitB8mnlEXTl+WUgqeryUOXT8kEJFRdexHr0cGAcuXHzfrRGoK7sjwMcn5kfj/AvuHhDxNVGktw+dciIImKgWlRpEhZDEBAomRtmOQGLwla3kx0Mb7x0v0KN6HIbBMVgr8XvDVPm96PQdJ4VhB4GS6cTau45nSjyrjmCjhqEaVJf8fbXMwsYXFeaD5ms9dEebm+x+6+zjWO/zealUj8yNaULPZ6UwB3E8mp6QzdTvSaOUbM0pB8i8d5AOfh1ICAoHo93kuTy9nunOk/RXqTH8QLpwovSCfo8nKBXwqB1l5gYeh1a7ydhPeb/jJVSoOo9yO41iYF/qUc8O/nz+xEEX1YxGGelJgPwRamOU40MYM9aHLiaoIhRv0w/3LbaIIQZ1ZWgiJ0+IiyMPeqIyEQYtNXtx7/ZxRN2T4IrpfxAAMFePEco0O7Qs/89Y3S3Qtn68XTiwYUjhh0gNVaIW9OJiVg6RX+UDE+VrgY8HxS9lmYWFAE8+Jrg9IgXRH4RzgnGyyetPtFSK15sCBTXNd5TVjSZPZTSCjo2E28v6AuEj2Tbk0NkpYpRoHo8l5xvXXM6JITdqeeC6VS/0XT1AEx177uqCkBvYZn6PyDuC8yTfvAntSSJVEpDzjKcJgDJiqZOGrzo8BkwJ5Cl8pHBl+SiEb2nuB54XiIGUk/FeUEHSdNFWbUEBxdDuUCFlEQQCgDKyzfJNRCypSarMU54OAAMRdsSEJaY+lcyYkbvK6Qcw6auBhPzILOyZzRGwZSN6NVKZApjeHx91TvplJEJ7XrmrvFZuIDO+T6w+SIGoYCBW2c5UaIlwJ51Ln2+B0afOzXJ9JwMSNb886YYnJ7M8LvTGa6DTVNcgrZQfb4lhuekM7rDNh0B9nppiSD+/DdPSYIJ5M/IRdj4Kb8hS8yWajWVw8NF/z+SuuTRxqCr71uu5k5j4xN6YZHyllvo8YZkEE8A1afAZQT/ocuIZv+OFU5Ng06fNCjLh9PFa8K/iWXeXnhLpxRlJKO3kae1n6hpeGaadQfdr8XMXSkE6fqptclvA15I1hlFjdwHC746wA7N/fpuPPccT/gZYJMltohos9FBIpj4AAiFGUOPJdFA2k3z77wkKklqPd+RRnvKDFt1oZRaQBJSkZKQB1BKREwudwfoRwIWQNSoX4QFBqkmnQID979rQiFQNeEyEaWROsF34SI2sERtRaNbw+IBdtVmigRmGmjqQHt1olOsgjDnCtcRxCKFDq6XPZ6DB7hQQo1cjjsC9knUjZDQnEPSal47FjBlIO2O9TTIxdoAuhoGigw0dahPtKJTEKivpCiwVVFlssPtLCS4nFnjgQVOR//C6LmsOL6qZKLJVPiR4vqNpPIjQejy8qlUGTqvCEhP83Jlk/XpgrqmPJHGsQG0wDFbkP0lJ3p4maLLZiIhVlpKa2yzo05ZvRpI34vqy6TwgedlVTNR2QhYzaTsowJMmvwfR5l2PJcatvdH2gqMg1UKFqAZ8LOc8ld9prJK/BZVVYjNEdFZwHUcVUYOT9oRQ0lH58n1JN0wdfOwnKlX78YnVKHPrGoZpI2Q2K3T+xqonFxYPjZE80bn30miv1FOuSD8oFWV6Yh4O8ISCrq2EZZ2mpHZkgm82uUSlghiXzzXt9qtsHpZocfytHmFujES7EaIVFkm2TiYDxVPBMGAAdPKKUQEHRRlwds492WFEE8O1dFtF9+zYMsRFvB1QIaXG95tCGUQtEEUDYW9QKC3XDy9Daekh09u/r0IBLT4sLHZO5UudYf8wnEhMuyAF07uu5DAKvzCYTtf172oa4bLbChRodNi0mCaXCxHTWSIkJMfFSHoFPBwpOZHit96PnMynAmSAqU+G+am3E56EfhdyhBF6ujCNide0168aETOz1we3iA0FmiSQJg1giJVjICK63PDeWUihNko+DUpvchzk89W0GASaB0LYLSlAEICoTpXZgwcO38r4y0EYLUmgdmCIlAixkHS9uY4UCI+uPxx2lLj8HthW1A2RhEsSLnKsWfyy2Y/XNHQ+X2TIwbcriLt4YuW/kT7fTFrOxCgRlQAgPwuVGqsMH2wmLRp5LQHEGTEH5Ssac3dJUwxBdlTEzCmLigfMqr0BMq+nnL2ztlWXceGf4d7O9E5ebXNX1FAa1xeUgQ2aUYbajcmmkI4eYHAmpGvPUazEP45iFDGGTauI1FJXBWStjk2C6JR3n6xVv4pLPRKUGEks6oiz9cI0sLC4Wmq89dsWpJmm4/6G7b8EAcxghxcegjY0CaStF+QDbtfhvvTjJ45aXQwMlSIOG9iP0ekVj+iRepPHNu1iK/QsD/hYOs6yUnuDXQKIpgsOISz0yjBCeBhyTLPwos3S78s19YqY1r/DzYTCiBM3hmKEsrHN8PsLkhLzg+PYudY2HhdiDIn4RKBZQMfL5cNGGYiMkxJhRu4Vo2B5acW96SZi82usWTRx8iefcIDvm754O5426mdAgK/OU4FU5cUrIWfhBKDNwUFaR0tPiYi+yVyAsDybVk/w4xNMHkRofekyk/LO2XonWBGyHwLcuv1ZMMJbyGa43rn+3G5LBAwemrytInHhScC7rtT4fs2OukSgnUOZEscM5vmgEBXj8tbcFY9VhoyV+/E8W7d44LmkQWwe66lt9Vi1yxich5Qs+qblI0Xemukg0scnyghkfS7ytLjNg8dNGWKhBfS8mVUNFeKAbiI/CdDOJUsCG3yiDRR2Hx14YUTF0jgyOw7Te8t/jYLoTiSiuXoziuA+z2PuK9ASqq0aObVH5QAR4mX1FWEAmpHTT5rk5njKjSgs3ykLRaWYVSQgfvC7dSXyO8HcUw+NMq1gBxYm0HaX6EJeRhPwVs7EpV9QbbH/41iGVUXOVycbcYuz/9yWysLhYcDK5pxu3PnrT1XaCoaaMuPsijxyUwKFNnlKso+ahZqBcIvkWUEzarByAJJw+3YySZWFuFSMnukdQiuj1wudYXOyaEgPxLB5dRgJZEm8EfAzi38CihhKElCiwKGJBFqBMIXN6UEqSIYk4RsyOWVgM1RsQHFlQ4YsRoyexv2YkU3tbRdOWK63RIDzSaXRmJZzuK0MNT59GmSO8b2OjbJQdWXrh2djkEDy0buN2UTjQ0SPThVH+aTQH9MKJkFxcf3idNjfD7UCOQCBW2ZPykuvPRDOPTp2qR0FrOFcgJKKuyIgBYgUI10jIJj6C9bXVwHWWc4trDc9J1P3zbDxuAGTEjFTgUhsIDtqZ5bkHg5xRosK/4wVKIu8vGkERfO41rwvKrDY4qlQjiy+UBz27jZQagAUZC718ex/pUDB04+SciOD4RFOqhQ5nC5QxVUjPSJENUTE4Sd0ASkZbHRgWelmkhXSMvFn/BvEiKmoR/ifkxZSXoO6IP0W97DyfE/FzVN2Y5Bh1JVD9ygraGCyQxR4EIeByDfEaLq+vwG3g8nza44LttE9H55t0JnEqLxQeXCPtcZEuX5A7TbJyah8R+ZODduJyVpfNtfJaS1knOi4pz4mxF9fxhtvDf/SZu2re+EZPDeOxsLiwWHjtYyn/Aq8upHX6JL0q8JjIvJXp7bLGdxIn144iNUBIz5jLGcbMqrqGnn9+KVrssXiLx4FU5H4Yz+9EBAWpqT0hQOh+gRLC6bQgPRJeJn4M8aDAgCuEpNMtmM6d09w2a1LRWTnY2CwZ02q9JsMKJ3TiVLjdNQfXTWkoz56aTrcUESkxrY7ZY7NnqRt1+2Bw3nPPLVKDu40atR6dWm7w6xsbE6uUUvA6kfZKRo1qG4J3Uso/taEpm5FZ+IOIDO3d0zZqS4a7m/Ba5JyDEHY7BbrmmvDcouVZlBdMiUYpTEysmUy8eoHAad8JkFTJTvF5gboiZSg5jwLxIOl5PBedoFDY6fMTp3v+r0RWCfVtushf/YVoOOojIJxsHC+IGYm0Z5Kgs1ayyp/CFpEpA62cTikfFKPyk4rdV0moGc5KqeSkcyZQ24XtxJ3IxBp7LSasALmxFSI6flFuBsrPERlHuXVZCTpTqoinUnNdZ5aQRCFo8M2o0yxKBnEAmzzM4+OS5zCjCpQ/xVXH4ihC6QexB2UcTLcSr6trlTxOX52HHOfNSIt4lskncY6LQ3H+jE/TZaiJ2g9eDMpyt37us876Z2+++G9ki6sSC697/KonJhrv/svv+r+q1d4/mbnDdMDUzYKOcg2ZKPVhRDRQWkBrsfhT8E9eL2ranyJkJg3wP0hZolSeRAQDBlH4KM6wGRXqhnwo4Js6ShdicMViL6QAJAkeDjHsouRS5UwURPdjvw3uIEIeCpQL4jZp3CceFHQ6SdkIxAXt0JLKCsIhXS5QXqDWrK2xWTjrm23J+EVG9MLJpjHEEntlbuQEXZC0UikmdSitCKlCqcQQOFZ+ej03MtciC6ZUErVjYlQgIZCnl5tUYrVDSjRyTc6caURKCAgkQuIkMwWvWa4PrpVuHwYRkzLYYJA3SotOKEb5jpjYJHHewwIvBL585Lbx2CN3pGbjYEGC10EWPfMNWqkCptvDi4mAQNpi5eidhIpQc+PyDCmyMg7iBZKka0jtZKRITkG1COt/KtmEadVXC2qeQ9uShEgQqFbpsfJeDHhStF7QRREC8daKDY4zyjOZBFP7N54Xdaz63E4Uycnwa5DXi3Myjnc/NRTScWgqwl6bbkmdd/28kSE2isWfNu8GKcSDRDULpkP3REHD+8AL4ud53bHpuUitx95wvTfePE4WFhcAbq7+39Vu+dQf2nOZjjQ1hdhHUVbhbRFZSQS6oUygY/KJ1RhiNUKAduZSeRC1CKME4bEaUTCdLeGnM9pw9+zpRiZZqBQyCA8EAWRhH7fvog0XIWzEgWFY6CUaHjN7JNa/UQeRqMaL9kojMtNi8cWiLeUTPEZKLGjHvenGZdpQuR6ySIOowb8iHpFGsxf5MLDY43Uc2B8+x+nlBl13OAxfg8kXj9vDShJas+W4TpxYNFOIpcsGhlZpRz587Tqd4Hk7uO3ggU1TdgGeeVYZgpnISPszyISOokfHj+SToKSzb294jJIOPM9bhI4fdBglAZM1DNaiqP3CW/9s5ovAJSUoAqTQajKh80ewEPq8jGrVgHgRFcLgq04WShCUDE/lL6jFMVnuKSozpzZkagOrzgaBAVe6ThzpLuGVEsfk+/Hqro24I9VYgudsqxKJJi/SrSILes8LphQHbTImpbxIiUwUIW0ApkTXjSmzUXxOcPNY1ZnkWCrs+5CPCK1+lFQOCs6RKT9JOFomnq+DJ8bgwK660EKqhKAI4cqqFFsx9gpZGnBLMknirEP02rMMbGw/9vp3TMat/3fmDguLbSDrVn6z/urP/E/2XG0P84gKsUckp8iGjref2m7sGoVDJhHv37dBA556u75eNj4P6chBaUYi3rMZLyp5mMnME5dG3LaKGTTii0CJAZ0lQiYWGr3IdIvSAuYDyTReU0I6EPtkoAAIcXr++QW65tqQFIyGOZOGu59bl08t100ImgAdQxLwhmMWg+kN16+Yib6i2OB1i8Jx6mTDZI7I84E8rXAbNVQemG/3MjEAudjPhAufoGjXFYKCrh1pjQapgdGYmEwMBm401wjkQB4Dbw+WlTGXhkACJccFihCORUhIxSTvstkVYw/wOlkpw3Ms7eEQvHbJkBopDWnCI+3qSdVE47IQFMETr7st6HvTZQFK+Cr0gug6055I/S2c1AJIrEjIIj5KvMas8kqAPOh96rRTkISyKmeIgJFJKXsIaiaUjqJ8kaEiALF3I/y/Mbuq22BUHSjVJ68kCWwrRMOjOGAt8s8I6VGeEVFPdElJyjHdcUhskuoOpag+xrsi3hKlaAlJ00pI9FopzK+RmzIORVktY25H1s8hjx0H04RIR/WjlEPngJCobFqiYrEtZN2qJSYvAiAqIBVa7k8bCCdI5qXAxCpkA+UDaXFFXI+4u48AACAASURBVL58cxdIWzMCwhbZ3AqfydJSJ1IqjJFW+VhQWpCyAgiRbHdmpWbUgkOsRmBxh0eF+Msoum1EEcLiO+bk2GZzYI5fFAAQMfFVdFg1koh5ECxRTJCrAkOr7/GX7cCJ/DDY9yFV9gJ5kvMAfw18NmiDBhB+JqSnVhuZsg5aiInLLDKJ2ISxse8D5GP//mmFQ9q0a/WeeQ16+rS8Nkwu1p1bUFNEecFzISFY7BlQtIRUOaYNfZqQiuflp+/82Fk/zy8rQRF8+chtm4NJYF4RFid5obKIRYGgmWkVIatKD1iMRUWQYDitsEjJYMjtwjpHJJtymsSjEakwftxyPObfpcTT9eJSDQ4HpEsfisB1pmfl+KpMlGPVQi/oIj7keHGXt4dueTZDGNV50b9HSpHybMhzS1ux7AfKjg6666nXNEqOjWboRFxSZSO5zUmUf+S6jhUxk2PWqb+67IbtXncWxWQ7WH/0ldajYpGKbH7hhvotn3wm7T6Lc8f9D92NFTCaKyGLHL6pG0+ChLE5wVQkvgZMl1ASaF58Pv+Ob/ZRyutSy6gu47GUeDLRLBks0lBgOp1Qlbn+ulXqshfC87JTabjIZ5FAN5Rjer28ibyX1wAvCJnum1VDwGQJhcFTDKArqzVabPZiz5+XMd1NxN6OPXvaUaR8pQqjbfj8IAvIm6mxOoGuHiEM+CwEIZJQN3ha5IOxVh+a8LqY1JXNHBxSU6SJCRbasWt8LHjtSG0Nz+WAlpfrUaiazj0hk4VTiGb/wP8yz+wK4lkpx8cvx0Amdj9PP//tH9n25/mOICgan33N6wJZ+KT0I8qBtKdSohWVeBHXSkguExtUjCdElWd0GQkL/1DVf3TyqQ4Jc9UMGtMJRDHRyCcSYU0QnAS1KZIjapFcHa0iFDgwTishuvPIoTiwbqAJUDBNGvSVFx/JVGKBLoMpD0+gykRDVp+08hI9n0+k3444toJSbDQRnCRKWIKMMz3TB88r2/V5H9jmmx698EPX1h79e5aoWBgs3vYla369iJAMlS2fgU2daFnWLa1a7SATUrYYfVgZhUEpIxJCZsLbAoeeZQJx+No12tgMjaj46AS5OMMR7KF6wp/fBc+YW0UhgA9EiI0QJ52a+xx3zhw6tG7KIjIXqNUqR54aeFpQRhF1Aou4tC5jNg46iiTpFeWXIZelsKB3OsUoywXt1hj8RyqxVVqzoaYIkt4VEKuNjXA7mZlD7AfCOTnIqbxoHUcZxpyTiRM+Xp1b6V5aWOya9mjxnRB7cIgVoVzenxoWKOpUq12O8nO2KuXMw44jKILHX3dbYPwViW/bvlpgHaVQaIIipkvJOhkF0/tQafaGoAzmqA8ZZ7oTSBZiidkX4tRXk41hrB2rhRlqgTbC4phG6pTrQYVjlcMS+kVkG4fvjwlD8jzIttqPMuLj1F1Q8rsk7co+8+oEDRMlGK1iadImZS4ppelMGTk2fVPyuOT8Dfk6A4fKmZ84/KlH/h1dZKx/7pbNwB/WL/bzWOwsOOR6C7c96drLcmkxz6ci7bwSNCblICgkMrPF97PGN9FgIoBv4wNewPH4/ftjpQUtx+iuIS6JDPmbO8yy8G6kmXCTQHlCSAe2gwIkE4WhgsjCDG8Knk+UBENOmIQgmRZqxpg7d1BaEfPuNYfWaQVeG1Gbs0FUBllebpjpw1U26SJNV8LmZKGX8glMuaIIoUSE0kmJy2tyDgTSio3yG8pnIFakQtaIc1wajf4U8ZHHwX8C0igqOJ5ndS3cB4yuSaj9//g9dzz4qzMbbBM7lqAInv3W2195euA/SbxQ95WKYcpBvJ02tAaJb+w6O8NRaa+UMIAm1tcpT0qyVTlJmvQ+0ggVKfOuNvNqIgPPySjFs1JSIXGUKP9QIstFw3Wm1ZOM7q7hbJq0HJViipoz9VrlDyZHUqaaqCyaiepoooQ3Jklk8Oftx158Ged8sfboN1pV5QrH4m1fsWrJDsAv/M23v7VYHP15dCS8oGM4H3wbolgk24yxOHocc4RFP1kSmod4QnHBKDRxaWhkfgycwHTBiEkWZETUG3hdMPnXZf8IykirTBDSzL4CLNCBn4kUFbQjy/RkEAAch6gknudQnSP/Ee4GFUW8JQuL/cjzAjKCzBX5+DSvhxUaDFeE6VeUHhA+MQFDNcGUZzITij3ThSSkBOm2emzAvAwbaR/fLs5HLUnDjicoGn935LbO5jgwZ1a3rBKXKCQjZZySKSJZIOLf0Om0Grq7J+kXEbVDt+NSggwJcdIR+RGY5KQRGFFe5HVN1O9CEGTxzypjr+70kWPT/hRDZtS2WnnJZ5wps602po5VK3gQTJ8/QYbNszq7Rj+3Vlt8dd+A/UI3f/bCl3BeDNCmPBmesW3KVwjc/N7X11/9yU9f7edhpyLpVdE5KLqllbjFVlpxC/mE+ZUNqTCyalMuSI1MJYbvBWqIdAZBSVjmADSoBjqpFuUk8VVgUYZRdcwpuvC7xBksY0MSTrInBN04MpRvz1LbKAxaXRBTLEpSKNfIJGesJC2eywNigXlE0gaMEkye1RAcBwbtSVR8t1eiIc8FwnMjpt5jxSaXH5twOGITq6gv0hIs5wFlJlGg0qB9JnrEAQiklKXk3F0oUqKxqwiKxuO33TYeTAI3zYuRc6ZVFG+bCocxjkpZg6aTULPqvonyushz5xR5MeZa3lhP+i1wxofepzaD6lKNn/CTJBd7YWbaMxP9X7w3TOS0SjOV0qteu5Po4knen3a+KGF+LShfiag8WqHJZc69E+dyofWF179+Mlr+5G44VosYbmHf99dv+ZTt3NplAFkJgkxDDLEaIAdoES7zor22UQ3HXKRMwEWkek0UgMAxOSJkfCaTaJEm9k9IFwoWXhACKZ3AeCshZ/Ct6H3qmUTIAmk2uhGZgblW/B4gIQf3r9MydxshAl/Mu/i0RfS9bDulFgWOMe9K1w1Imh8FyoXnxvhxzF6CqA0Y2SMgPCU1r0iAUpOk6+oOq/A8FKJzCAMr7o/8NlCRnJRFQM1VuhikRGPXEhSN499y26+dHgb/Sm5KtiCXEjN1dC6KVhV0V5CJ1VcKCtG0uqHJhR4cKP4Xra5E5MUPfTGBIkG63JFVplVShEtIlVZUxA8zZP9LslVb9pHPqNeQMNT6CQIRvc6UfWmjryhJklOjiY1+LXJ+Lmf55kJh7ZGbbBloh2Lx9qds+eYKwi/8zXf8drE4/GHtf6DI2CozXGIfiPhYsMhDFXHd8J8qyis6JA7qigzCQ1S7qAFS1pAOGHSyyEdmGM2ei76EJSP4NSSqnVgtgYtQjlOH1EENgt+jWQ+VB2wnKoTeh0BaqnG8U6UtLCRyLPy7eD9A6LShNWms1edyXpBeGuDh+alttAdfKFwRBCUJzP/RmSkaUtrQHpR50ITBV+bTAQ+302pEmgeEuCwjhESMpzqBNun90CWleKZOqNrIU2hSJc+d5u+IiJPc5EwrL8mSz9RxJ3wtQrL07qRkpb0/KG0t5p37D3/6kf9t5mRcIdj43C0r3qSzdKW+vp0OJ1McLd72xcLufhUW24Ux2OrFOAHdfgyyIqoC1BjdfaOhJycLZD8YyqfzWYhVCDKTeauRF6Nr5uvE7cOgJC0mVZhjA7Ih+VFIUpUyESLuy4jo5+dAiSiOuh+aEpU2sWqgrCJZMbr8M3NOEim9rXa4P2ln1hCC12pVZpJ9Gb9zzx0PvnPm1kuAK5KgJKFblymlu0TgZmLyQCl5HUImsvxvJcuLtkNx7/BIdfSk7X+SuDOn1Agdb+8qVYY4G0aTJd2Zo+fT6Nj4jFI3iEtR4gNBh1SQuD9NVdLnjBLKiBC9as7ZfMXDjzZnXvBVgvVHXu75wThztb7+S4GlI1+zKomFwbyOoDQSE4ehZWZm+7Q7oVEUJlWUchDJTkwmTnF7LUoz2Mcmm0qThGEexAsj+4SvJNk5JNOhkYYrJCGpnmhA6cE+5wXfaWi/SBp6/ZC4odtHkn5lbg5Cau+548EbUh52yXFVEJQkvvDa2/yJNKUnguHcBCHRrbFS5nB4gSelrklkfOTdUKqFNodq6LKNkIqkEVeOMZ+ZLQeRajmWlupJindFttUR/BlnmoAlB/uRSrJNqjf7i5lXXvfpR740c2ItDFpfOPJb4+Gpf27PxvnBze/7m8atj37bbjx2i0uPuYQlERJHCUOtIG1WjBCb/qBo1Bfxp+hOFj2XhxLzaVBSQTlFFBxMNdaR/zI4kRJlHUT9Ly3GZRydB5N8vjQky2KU8M3gd5CXWAUyStLd99zx4MdTdnfZcVUSlDQ89trb/LEfOI5a+LVpNaDYn0JOODV4lFBlBDpKP6NafTMcoa+JhvaA6OnC45SQM30syRKPPg5fKShJ5UUG70XDDVWGyVReC5OTPcXM9x7+1CN/knLKLM4Bm8du/6PJ8OT32nM2Dbew71jj1s+9ZuYOC4sXAZAWLMRtXrCRqZJmIKWUUkmyxRn5IuLTIEV2Wu0KlUvxVF+QIVlOUaoB6RBigw9hTYJ0O68mEMRERFJgU/Na+Lu16XRKL8lshR+6544HH9ji/h0FS1DOgidvu80bekFGdwJhUZcSCSW6hJywrT5KW4UiEs3s4dv07BotwmnfRzEbd8TkuVYj+9SlGz3DhhLlH3meZECafm5RcBbyzq+/5DOPRkZji0uDzWOv/fxkuHzrlX66LRGx2AnQaou0ycKrkoxr10CbrnT8JMmEmSekElST0AZeAfwsad1KxMpNq1OJSJAuW0Wqi5gaE8+HlmD1OnYVEZkHS1BeBJ751tu/+czQf8JLKBiaaEi+icBRaounPCFgHFpZyWWm81VI5Yggu0SrJjPdR6qkJLtv5jNfe9lnHnnpTjhvFtvHxmdfteZN1hd2+inLugvrzdc9sThzh4XFLsEvf/rbbg2C4PPDYWEqTVVDkxXi1lxBsuWZeNYNsWlWCAW6ePQgPqgwfc4lwe1JBWd1lc27+YDq1a7s57IZVy8lLEG5DDj+rbd/sO8FP+j5VO1OAvMONn6UYHrOjS7x8LyacSHrPJfP0J9e/+lHfuKqOFkW54zWF+74Ud8fv538wc2TcyA3rruwTpni45lM7sP1Vz/0wZkNLCwsZnD/Q3e/nYhAFjB76HriwXrzSkrqvqNEBO/Hx3eqB+Ry46ITlI27jnw3/t88+vBHZu60sLCw2MHoffl7zedX+RV/bD+/LCwuIS4YOVm984jZUVYZRTF0TybbYq5LPsPtuPF2728effinZ3ZmYWFhcQnR/dJ3/UG2sPf7z+UZA2/4fOnlv3945g4LC4sXjRdFTjbuOjIVeEqJ1tY0SACZHliHzpVy1rmhefThZ1IeYmFhYXHB0XniTb/olq/7mQux32DS/UrpG//wFTN3WFhYnBfOi5xoUkIqCh5oTwKqcTuJF8Ttt6VkPGkCHS+gaiinWJJiYWFx0dB54s0PuOVrf/Bi7D8IJq3Sy363MXOHhYXFOeGcyMnGXUfQHO4O/XhoXjm7Nek4H6AcdPCTj9ikSAsLiwuKwVPvvCRdAOPu8XtrN3/8AzN3WFhYbAvbJidaLbkU5ISVlh9oHn34/5nZwMLCwuJcPlO+8o4vO27lG2fuuMgo3vSA/ZJlYXEeOCs52bjrCNqjjo9UFsdIpZmerVxzLpDJwlkVAw9LSvPowzl7cS0sLM4Hl0otmQdLUCwszh1bDjFbufP2f9r3g+PEQWDyA28ISElJTf4dGX/J/M8AbAdfCf4/SpvGx9HrzjQxAdykx8XCwsJiO7jcxIR2yDFYWOw2zCUnG3cd+f5xQL8zc8dlgiUoFhYW54KdRAosQbGwODfMJScB0R/k1GC6eYDKYTJMHMf89BPqiVZKoLiI+gJ4/CPAIDr8JOPb+6zKrNx5e3/OYVhYWFhE2IlkwBIUC4vtI5WcQKVw1JTeTpItJABTLDbBT8mJf6dEOWgGIDJBYMiNhvbYgthgnxj5P/SpeObO2+2cGAsLi7mA+XXefZcblqBYWGwPM+Rkp5dPJkRPzdxoYWFhwbgcXTnngu4Xv+MP7bWysNgaU9060pkz7xFSnoEKImpKNaWVWISQ5F2e6sgpZXD/7GO3i+bRh60D3sLCYgq7RZmwHTwWFlsjqZwcD1QUfRK6PFPMhD9pGPiB+Ukiy2Smaqbszv+3mfStWFhYWJwNiKM/yyY7Bra8Y2GxNSJ6sXrnkQ+R8pmcDa7jmJ80VLKO+SEe+IcfIRzaIIt4exNx70/fV5qzXw3bvWNhYaFxoebkWFhYXH5E5CSg4J32elhYWOxGtB+764d322Fb9cTCYj4icuJwLH0aWpPZ20UR2S5EDdGloZEf/uRN+3AwJdtsVV4SnH7D7f7MjRYWFlcdctUbf9tedQuLKweGnCy/4fYgy2WaNFJQd2fLLIWMY34mKf4QmF7F+Io243nzd8BRpMMYz8+dxQbzkmT1La6zrQqUhYWFxY5E+/E3/qS9MhYWs5hjabWwsLDYHeg88W3/frdeqlzlhvtmbrSwsAjJiXTOQOBIM8Qmyz0eb4ufNFNsCbN35qglGqK+ECsl+m/9u1Zn9F5x3Bt3HbG5JxYWVzHc8uH/1V5/C4srCxiq92PzeETfl0yS6Q0mfkDZtMRXzjhJ21+QQnp0boqxtTAJyScIT5IACVXhW21irIWFhYWFxRUEKCe/TDxVWEP/nYyvL8whJpQSvCaQm3UGiphjYYaFL0Xm8ySVGv38G5MgVd2xsLCwsLCwuDIAcuLaa2lhYWFxedB54s0P2FNvYTGNyBCbLKWYv7l1Jy2i/nyhO3QEybTYZBlHP385E3pQ0rqELCwsLHYbMrnaK+1Fs7CYRqSaoHSSJCFJr6vHhCBJJoZsZiXOP5HwkTRSkyRBAjzOi7aZfQ495ViA1NnszJ4sLCwsdg8yucZr7OWysJiGbSW2sLCwsLCw2FFwtxqyl9Q45g3r0wZZGFu9LfY5D3ic7t4RwJgLtSVFhNnWDB4LCwuLnYzAGz5vL5CFxTRc6cutpKz+55MNn1Ye0pDyTNom+raeSpi1sLCwuFLhDc/8tb24FhbTcJMZJhr6PpAFUUi24gtbEZNAPTYt90QrM9shJeAvIwqoOXOPhYWFxe6A749+zl4qC4tpwHPy/plbLSwsLCwuCeq3fOJZe6YtLKaRaR59+KflFj1oT08cRjcOlAyJrNeQll54Q5JBbkn0vfQY+iQGKQP/BCgbYTeSRFtynI2ZjSwsLCwsLCx2LaJuHRACSWuVxFYByjnJ1FaBZJJIuutWKGSIul5gfjSS+y6qclIynRalJiFJuK959OGFLZ7SwsLiCoc3WP6ovcYWFlcWbCuxhYXFrkbllX/+nbv1+Ce953595kYLC4uInNxQjMyuTmRMlfIJJdqFk2oGUZzaGpZdgtR2YuwXXUHSGSQqylazemCw1cqKLittZb61sLCw2Omovuqv/5W9SBYWszDkpHn04WeS98BzkuYxISYFSHP11G0yjK+adaYIzlYQopJGdjTmkZfm0YfT77CwsLiq4A1O/Wd7xS0srhxEZZ2+HzynX1WylVfzBxhnR174I5hHSMy2c/wq0WPPUlzqn+XxFhYWVzcqr/yLd+y2E1C86YHZD0wLCwuDiBYc/OQj1+2mU2JVEwsLCw1/vPl5e0IsLK4MJDWLD8/3i8QekWzGoVI2/Dkb0AGUn1OWkecK/K3VEXTo8IBkCwsLi1SUX/Enr027fSfCqiYWFltjipw0jz78PeIlGQXBlCGWlEdkdBaPyFaAlwU/8JkI4UAJSf9LTSsDjf3A/JBVTSwsLOZg1Pnat6Tfs3MQBJOWvX4WFltjxu2x7xOP7PSF/8Mzt1hYWFiEaasP7/TzUHrZ7zZmbrSwsJjCDDmh0Nz6jxCohhbetPC1qanB/taBaklAJcEPunoQ4CYhbjp4LQyDm1ZtpDwEdWdmpxYWFhaMnVwyseUcC4vtIZWcLB19+P8moqeFSFCCdGhPStJOMq/tV6C7dyQbBftORt9jN3pX8KTYco6FhcV2sBNJwKjztetnbrSwsEiFE6SYXwUbdx3pQYWcuUMFsVUT5AXkRMhHsA2ykob2JKCaOx36du2ndny5ycLCYodh8NQ753/AXUKAmNgBfxYW28eW5IRCgvIUEb00efulJCdWMbGwsDhfXG6CYks5FhbnjrOSEwoJCuTI4zN3MEBMhITo39OgSY0MAKzMb0nuN48+XJ651cLCwuIccLkIiiUmFhbnh22RE8HGXUfOujHahMWnAiIiykrfC7bMRQFP0XdbtcTCwuJCov34G38yV7nhvktxUtEubLtyLCzOH+dETmgbKsoFICenmkcfPjizgYWFhcUFwMVWUaxaYmHx4nHO5ESwcdeR1xPRJ5OKB7pvxrzLUkp5R/woKamxTzePPnzTzAMsLCwsLgL6X/3Hm47j1i/Uni0psbC4cDhvcqIxzzSbBIiLmxgOaMs3FhYWlxOtx+68Ll99ycxk9u1g0nv2l6qv+pt/Yy+ghcWFxQUhJ2nYuOvIx4no5qEfZCns2nl66Ad/tP+Tj/xCyuYWFhYWOwbtx+78F0629CP6eAJ/+GTt5o//gL1KFhYXHxeNnFhYWFhYWFhYnA9SE2ItLCwsLCwsLC4XLDmxsLCwsLCw2FGw5MTCwsLCwsJiR8GSEwsLCwsLC4sdBUtOLCwsLCwsLHYULDmxsLCwsLCw2FFw7eWw2A1o3XfrO8n3P2QONZPg1NIO78zk+d1Yv/fY3FELFhYWFhY7EzbnxGLHonXfrW8noj9JPb6xF/4/l41vw2gEjEUYjOP7siGRqd97bIa5WFhYWFjsTFhyYrHj0Lrv1ncT0bui4xp5RPlsTDqKufM7ZDy+mLNqioWFhcUOxwUlJxt3Hfl+IvqDmTtm8eHm0Ye/Z+ZWi6serftunX1DXlhyYn61SopFGrpf/M4/zxb3vTXlrgj+ePPz5Vf8yWtn7rC4avCej33nP6hU+j9BRHetrdeoWe+al57J+udzCo5OJtlP/9Sdf2VnNCm8aHKyeueRftah4swdKUhOMBbY4X8Wrfe/eoMcpxGdiIlP5L5Iv7bnR2WdOfjx+r3HfjX9LourAa3H7jySr77kMy/qbTY49Z8rr/yLd8zcYbGrcf9Dd797NMoZBTefH5/zS2l3KlSrduP3iZeh7PmRl8eJ6J333PHgYzP3XME4b3KycdeR6IF9P6BSJp1fsDOAxBkw9MOHYTqxJiqjIKC84/zH5tGHf3hmJxZXNFLVEg2leEQYTsLfCime7hG/6/DeTrs/AauiXH3offl7PpfJNV5zoV948aYH7HtpF+L+T7/pg+QEP5I88sGgYP5fLA7P+UUN+gUqltIft9mqUKMeE5dutxQRoFyOP9v0vob58DgKI33zjffc8eAVW6I+Z3KiSck8eLyFJh+4aeQHmE4c3SZEpTBLbG5oHn34vEaYW+wutO57tbTazD9uMbqO+B9t/iyEI80sK5jwNxdPKTPZjCUoVwk6T7z5Abd87Q9ezFcbBJNW6WW/25i5w2LH4P2fePPvua73D0fjHOVz56aKrG9UaaHZmbptOAy/PBUK0/vq9wtUYoIyGOSpKPc7AVHghP/HR9bEpfE43Ee51E95U4UfT57vbKW+LNxzx4MbM7fuUmybnKzcefuTruO8cuaOFFwAcmJgyz1XNkLFRN5/W1zqS0BOaOJR/d88vsVBWOx2DJ565yV1/486X7u+fssnnp25w+Ky4P6H7jbXfzIJPz9cd0JXGDnRx/Y799zx4DtnNthF2BY5Saol4yCg3GymxJboBwGVHIcGTEiKCULiqdKPhiUoVyaiUs688kxaKSd5P7E5VgjHVh4VMdWeBVZBufLQfvyut+cqN6a3pF9kBJPuV0rf+IevuNqvweXA/Q/d3cR6Pe+px2OXxiOXypVBdNuQyyeFwohGo1xUamm1K5RhIlGt9mb2tV3APAssLrTP6/GTSZZc14vIyma7HJWHWu0qlYqDqbIQtncc+i/3vuGvvntmZzscZyUny2+4PchlHPO9ts+SSCnrGI+IIKO+92YVafGCYOpvDfaYTN2W9h3aC78037hw9GHb/nmFYEuPiVY9tkM6tos0c2yfCU5pigS9p37vsXdfnVfmysN2um8uBawX5dIBCgmIBzHZ0GQC3g6HVxqQEmzX64e+Eu0BATqd8tRj+/2w76NUCsnM2lrd/L9W71HODQkB1I/cNpQY38uQHzgh0UhgdbVOS0utmdsFQZCh8Tj8opVm1NXHKWQrk/GFtPzQPXc8+MDMg3YgtvzUBzGZufEywA/o6xt3Hbl+N5xQi63R+sVbvn3LDS4/3rXDj89im+h/5R1f3gnEhC5DSelqw/0P3f1jP/dfvzvAz9V+Ls6CD4G8SYlrJ2OucoJSToeVkkrW2coRsCW6ah+TIKAJPx3KOmnelK1gSzy7H1uqJhpQNUpblHW4PGgUkTRvSRJ4n89R8WbgB1T/6S/Y99ouxqUwvp4PrIJyYZG2yEItKEx3tZg2XiDNr7HVfb4fXq5MJqBeL07MKJcHM9sKUEohUwlwyPcc6vLj8BG0tBiXc1DiwX6BZiP2sMC/or0rnU6JqlJ64tISVB1g4mWmHkvq+bUqk9xnAq/eiW3KqeTkbB05wxRjq/5bHjxOlG50mcczVsi4rZi2YZAlS1B2NSJish1jK8o7nh9vN+89ARIjXhIp28j+8Rh3C+KSPA55vnA/d9fvPfbxmcdY7ArsVKXCelAuDEBKUKIBKpX+DCFBqy6llGpQdhmN3OhxSaCkAiTLKtrYSkwAWu2QIGzlH+l1i+QF4WdQpdyLyIhB4BgCQ0wyAvaRwKB7erlJuZwX7V8IFEo240lmxpBLTKRwv5hzFxdbU/dNPXc6dpSJdoacrN915JRPtJ/O0S8yCaaJRhJCTOTZBl5gvCsaPZZSsIt5uSlkCcquxbZVkzRsJ5RtmnhDtwAAIABJREFU4oVkZJpkpEM6gNLA91lz7O7ETi+hWPXk/JGmlKQBXSsCvZBj8RbPCLF6IeQCHhKfPzr27OGFnQmDKBbAykqdarV+pEQkiYvGqdPNSLDdv2/DdAcBMOJqcoTjqLAak1Q4jAlWVB1n+29t+FoksVa6eHr9kNChI0jOUbk0pGw2MN1LjKP33PHgG2d2eIkx8+ltiMkOx8ZdR76w04/RYhqt975q/teLHYrWfbfeYC/j7sJu8HZY/8m5A6Tk/Z94sz1vlwZ3sS/lshpnp5QTlHOkC2deOWY7GPM+0G4svhUoIVBXtirZbIUWm1XK2VCdserJ7kLrF29maS0xRViu4mAy7THZZuvvDLZSRDT0/rdoW7bqye5B67E7r8tXX7IrwhsDb/h86eW/f3jmDospaKUEpQnpwvH9bKSAwAuylQdEA2pBnlttu90C7du3GSkIWmExmSTFUeTtKBRHUUeOQGebiB8F3TNra+H+sG/g9Okwj69RH0SVA1FatKdFsLJap2ajm9rJs7FZNR4TOQ/owNHdOVBGUnNSGKLc9HqFyKuCYy8WhpTJzuV+33PPHQ9+eObWi4yInJy58/aXBgE9lZ/zwY6IeqnCJEs620HSl5IG3Uo8r0yEIDc5RktQdgda9926Zd7AOQPEQt6M8KbkEp4TgSYq2zHEpmSuWHKye7DbFAlb3pmP+x+6G9ER10dlFQpLGuK98IMMDQfhQlutTi/GulRD7DPp9cOW2lJxNNN+i9ZcMj6V8oy5tM9txrpsY2bkZALaYF8LHiMmVJRHHGfaWDsvoC25jdwPT0w+HxMh3f7s5iaGtAiZgTcF5SJinw1uz/Dzl8sjQ0Jojr8mCeS60Jz2ZOCeOx68pO/X6NN87NNTM/daWFwYXDhiconRev+r/wf7Htj5gGqy2465/9V/vDlz41WO+x+6+xZWS2x0xA4DrsvP/de3XbIvANFXxHLCnIpE1yJ/03S4LNOW3l8nVi+IFQ/9aDG26n2mqSbJEpJsodWRJPTtJ15/++TQpx7ZouXDYkcg2T0jbcD6GuO9gNvnmVi18qHLPfO2l/2nB63NAseYNiTQcf5PIvqPM7db7CjslnKOhuO49Zkbr2Kkml3ZAIpyBRQBGcA37OUjxQRD8Qr5SaRYVCvTJR6EojXSgtECZyoOXisgUlIRxQTqS5dVCHwUYTtvwp89DaLlM+GlhHE1lw8fm+yogUJz8mTT/H5g/zpttivRNq7rT5lVSaXJLjS7U2qMjs+vVQeR8oNzoAcUwox7YH/6qB2oLAVWZ6DYYP9SKkLrcq3W43M3Xcqq1zpynd5zzx0PXtSwSlPWSWsdhlekOieABOQjSWbSCEmgck6wr3mkQ+LwdQKtIFkOSj63Le3sfLTex8P9Uq79FGCVz2xBNjQmXI/dqlV4K6CEI34r8ZukkSZb2tkV2K0m03H3+L21mz/+gZk7riL80sff8h+CgP5HKWvoCbwyb8b4PRKdKt1u6LWoVMIkVFlckeqqY+g1zqw0yOH97OF24UFfJg+Pouc4cXKRDh1YpxHvE6UOmVC8tl6hYnFMNSZHegFfXm5Qs9mLHgOPyGgUfkbt2zsrlIEIEJemEJFPXHryPCc8nhSg/CKvQT83vCe4XcgWSJm0RucLE6rNid1fPtMwxxada0XkPG5xlpZnEETZP/w4737Lf7lon40pXxVDzCMmlCAgIDFQVeQ2/J3ju0EqSmqtSRKTjiIupEiJJkb4sqxbl/E8Mp/nPL21Fpcacy9UQnPDdfW3GVl/vqREAJ9K8rjmHqfFTgZH1O/Ka5Sr3HAfEV215ATfwvMhjzD+Dt/PTPkjklHwOr+kwgrJmTOh4XQvL/4gIHsTOSWiiOzdM0sQiiltwMY06wS0shqaWw8dXI9UiUMHeZAfE6DNlXrUehwu5uE+kgMCT55aiLJMDh1cM2RC1B+oJAF/9PW6VfNaxKjb7eRp//721PkQUgLzbKMekg6QGSgg4nEhldeC/cO7Ep1bNXSwXBpN7Vu3W3t+1uSuaNOw5MSABLKK8sF77njwx2ZO4ovEWVaAnY+Nu46k6HUWOwWt+2694G9aCwuNnRJRb7F9IG4+tYxjsRvxoxfjWrpbZYYkO2ZGrFhoBSSpsCT/TrYgyz7H/uy2acinPLdYX7CPvDtf/bHYEXj7/INQ1/9scfVoNS7OudR6QvFWMMP/+Dm3q5KkJChbWFicP/RCpr/Ni7+jx+UaDOaLSi58XzLxlUQxgX+EO3nS1BHxkOhOGJQloL5I2QVlpeXl0BOyb9+G8YA0m6GCADXC4a/yw0GearWuKTsRt+XGz+ObH2KVAcrGcBh+bu1Zake2Oag9e1WZJ+f6Zp/hZ45jEmNFdcnninTqdFieOXztKp1ZqdE1h9Z4n62oNNRu54x60u6E50+Hvg0HrnmOEycXwnNbHkcfbfI8Ugrr9vKUycj5yhtvjVaAsnNajt939C1BLje+8Z47HrwgQ3px1m6RP+APqSjCkGzjzSci6+U2lGFqc4iGbg/GY9yMlHBmNo2fJ7Er5KzoQ6nMeS6LHYm7pt8Qc1p608yoGpqY6LRYlIHORkoE2jwLoiIsN5mnoicYpx2rhcUFBOYAVV/1VzsmNvxiIvkNG8Qk2cJaUF6LtJKLYKpF1wkiYnHwYNwcGE0J5nJKr1+kfD5caFGWkDwTYtNtoxGTn5w7NmUmYHOzHOWWYF4Oqem/aN8V/4smHIb8lEeRt0WjVhuY+zc2mEjsb0X7wN67/QJVyuFrBxlYXIj9IiAm8LIQm3iFbKFEBP+ItBYTR+ED9XrfEDGZZgxfS7tdnDomSYjFMYv/JCJMKee9XGbfH59bLgt9/f6H7t68544HmzMPPEfs+rKOhYXF1Yvd2EKcxE4cUHihYcs4VxUaF+Jau9qUCkVCTxHeCrqDBqqJxxpRsoyj/8JjRHHJbiGra4WmzzN4pKyTSzwM3TsvmqJZXEwcjdQTUU30wL05HTIz8IN4W22W1d09ydLQVvN4oIyIYJJMo8V9221BtrisyGTyP2+vwM7Gz/7FdweVcqh8uomUVUoJ/ZJuEHTH6NbYJGTwn3T5iGKiZ91sbJZNmWfEikEyZG1jo0J+EJpsDx7YnGrZ1Z0wo1F1qtzUbldonVWPQwc3o1LKcK0eDdyDMgMF4vnnF83f1167Fu0PrwsqRy7v83nxKQhCJQJlGphc5bzg8UtLoYKB593YLEallWYjPn/oFFpc7EypKmIElpU4H7UPj2Y6meSjVM8eQllN1KvPnKi1Pr+eHS2v9/eY7Z0iFbLO4GW1TP9tN40W8FrL5T7vKzAq2YsJbnOTvo+tSEmyu0YjLd5ed9lIG3Fa3olAVHa9+1I29JjMGwSYbGm22HH4eEROopwSLtEg3VVuw/XVaa9J4P4574Eo2RVEQkfRa2ICYtMbE1XzMw+Pi48KUtYZz0ZIW+wcZHK1V9rLsXOBBaqRSHNBKaVQCP/NttqlyEcCf4SjukbgIZHFdWW1Zqb0Li2GXSsgJkIC0MGDoXlIeA33n6PSIPx3Lv4TWZRPn27SfpX9gXKHpK3iWMQfUqsOqdMpmJZe4JprNqjfjz870LJ78GC4bxAu8WTgmMeTcB9nlut06NBa5FshHsZH5ntTlsqlsSEwgjwTlVIpQ2fO1EypR55bSNNwiFbeQvR6nntuiQ4fXjW/g5iQisRH+WllpcbH6LO3J3ytyWGFp04t0MJCeB1AWnB+P/DZCWVrefIHDmVK5rXXHTQ55sLXly245GWzxa84meJXni6ZeAefX/tPvqpDjpeVMt4P3XPHg+c8p2fO10oLiwuGX7Wn0uJiIZNrvMae3J0JW8bZffidL+dav/TUfkNMXgw+8HiF3ve5LL3/CzUwog/d/9Ddj53r7rZ0ISa7c6SkEqj7cFcuRTWhxAyetPA1DagjfT9dmQlmMmgtdgvq9x7baN136/TRihqhVRKUeqCoiIU87T01UPKvNsFqo2vSHKtLSFo1MYZYP74vifMZOmhhYWGgiUnfmFDDf7vZrDcVLgbVRL7pw7yJUs5gGCogUDEkFwRKi+4Y0SUJLC1QMkRVSUKUFUDySIgNq1q5gDoRqQ6+Q71+jvbvC7d//oWFyAh7/fUD87gXToTlGhhUjx/fy/vv0upaePyl4pizTMLn0CWS9kbVGFQ9T2byeFGZamOjZD4Gxby62SpFr60/KJiZOVKemjTiz66Tp5qmm0fmCqHMc+DAdEKsz2myw14uem50Bj06pJUvPFlAuaae7Y0oYNXZyWTIrZdp0gpVFd8LKL8Qlo0Cz6OMm6FxN1aGMpw/lW1UaLLepbGTKb33sSZlg+CbRqO3BD/zxr9M+WBPhxtPDcZFdqYoQJJQjPntVkh4TpDwKu/E8xkKCFKCso0mJUJ+8H7IJtqadQdQ13pOdh/SSjf+FqREMK8rZ56vhOYQDzpL7L2FhcV54f6H7o6GfLZ5oi+SSWWAHr4PlxIdOFJWCUnMKPKZuNlClNBarYYLoHT2IBztEHtMpKNEYtzRaqvTWOGlkPRYlDfW1sJSBzpr0OorIWSYbNztSeps3wwLzGTCLzBY9AUopWCCL1JiiYkMSk6Caw6Fx/Xc84umwwfha2TKNeOImGVd35R4htwN1OtXopbmUnlM5fIw6oqZjDP03PNL5vc9Sx1aW6tQsVDg1+ZHk5OlowfptsRBb2trYU0NJTAc9969IXGp17p0gsnVbz87oMAZ7snmw+cLMo4hJea14afTJ7cSEqcsBTRuc5CbQzTpjyjXCD07GeXPG6+0yck4NNlkUlPI5d73pTJ1vb8f/OK3fWyLD/kYkefEtOsm7hTzKjEZ0dtqj8k85US2pRRPit6H+ElEOSE1TLbE20xU3oQQFxzTVh4Zix2KoZIMhVgI8ZiwmoEWYZ0Cq4my9pUkkbxvK2PrVgQlVlwen7nPwsJiBvc/dPcbiehB4gVbx6UnCYlGm2PbhWSIzwSPkcdBUUGEvSgwomhE/8xVqilUBkk0rdd6VKt2I3IENULafWE03X+gFUbjY1E/sRgRHpAgzOg5dTpMn0W77OJieHzXXrtOx59ZirJGzPHsF/+JF5GFfXs75vcMJ7Hm3Ynx2xBH7iMK/tnnQtKRz3vR/qDQrK7XIyvcYJijaw7FCsiePe3IBNxqVWlzs8C3d0w7NJSVJPB64GGRZRR5L3/d8lrHB1R38i5lshnKFMNjm7T7FHBSt9fuU2F/g7xBeI6yRfiFws/SUatP+cUKDU7HRLC4Pzxf3nBMhYUqZZvhtR2eXKd8pUi/8VSd/o9n3hGs/bM/POvCvcWns4XFBcMHd+uprN977JaZGy0sLKZw/0N3v1OIicXOx/ufLBGIyeU60PIHvuOsfqRI8+776NSZbf1NQ1pnjoYoIFBEZFsZ2DcOpCVYtQtzWSdqE3amA+B0148+ruRQQIudifq9x36s9d5X/WhUstGBa+I/EZEkKtFswZvnqSZp92llDWqIdArOS5slHio4rxxkYWExBSYmH9K3YYidmw3/bcv8mHnQravA6mpYdtm/b5NOnAqL9ihnoDQj5Zmy6c6RQXlDsw9RRzY3S1Qshd/04UVptavUboeqQLPRj/whKM1kHS/yjmC2jS7rkFEx6tF+UE4RNJv9KH11NMxF7c+YOnzgQKgkQJ2YeFmqVLhMlZtEH4Gijlx/3QrvI0/PPGs6dGlxsWe6jCTkrVD0jC+EeBii6xKtcmkKKlGhEO5/MnHNcUbt0kbtCRUmKEmddsGUjH7tSwPKFHxj4zDwfBr3hpTnLhx8/hX3hPsfrXYoGE7IY8+JW18ir8WlqYJL/sSPRO38vqZRXcx9bpbGG13K8OconsvrhNd54vuULeao9mtvC9o/8mdzF/DoEzitPTgtrj4NyUnBaW2/Lt+UVgKSdUnsjqVkMm3KY2gL8mSxA4H3UhohSPOfEBMJKeuA0G5VgtnKRCskA8+P38UEi3KPvGeTRATPi+0denJmfxYWFhHSiAlxxoaUVtIg/hD4KnSWCbIyxF+C1Ne9e8KFdsCR8RJRTyrKHsmq2B9ICZny0JDyXPaAn6VYGEalD7QH33DDGfM7vCAog+hyypmVkIyAnMC7Ua0xsXB9ynEEPu5DloikryJpdWmxx9uVaMyD8Xw/S6NhlgL24WOacYl9KigvofQlBASG2IMHZHBhzZSUYMg1x9wumPZhYpJ0zTVrVK+F5wjHsbkZ7mNxoW8yUMRE3G4XyGNPC14jPh5//Zkc5ZsVcgouTdbCc5s70DREAAZWcyyVAnncfIDfHZMJxS3Q610KuOSda1bMdvmlkMhMNrqUZbMsBIagNyKfy0PBYBR91ufqFRq1wvPV/M3vDTb+5R+nfHBv+fXUwuLCof6uJ1PfgDsZ9Z/6wqvsW8DCIh3v+dh3/ngaMbHYmfiNU6UdeVzVX35raonH1SUYDQlNEyRNsBpaNZlXakmqL3p/cl9SMbG48hF0Q4buVBLlmCk1I/m+SLSWR1ppEN6c9j6S958oMGhPGyV6+cWMa/r4fLKwsEjH/Q/dfUOlQv82ORcn/ifqRK2/KEFIK+zKSt208/Z6bL407azhGoROlpWV6tRsHAlkO326ThPPiVUV/VGR98x2k0ktuk3Ui9XVKi0udOkAB5qdONGgdkcSYddNF8z6erho793bidprn/76fvMxgI4X4OvH99KN14clmDMrDdpsFWiVyzxZx6cKd/yg/RkJssRBcfmCF5VZet08DYfh/lFS2r+/Tc89z4P4SmMqsZF1PMqa8DQJRcO5k9RXdPisrdeoVgvLJ95EVSxKA7N/UY0Wc7GB+L2PNShbDGi4Ee4T7cAOf8Z6Gz0KxhPKVMPz4AQBZaqhGuNt9skp5ynPKrbXGxg1xRxnZ0C5pSp5rX70uem1Q0UEnT+ZaoEmZ8LznmtWacSdO0EpCEvnOA+1ImXGE2re/9b+xj0fnWJPbpKUDFUnjEY20cIr2JwE1HBjL0mBBwESl4rmlYawv60SZy2uPNTvPea07rs1ZsmeT05hTllHA8mu8KLkp6OYDXREfQop3rJbR5d88Fh5HzoZqv/vj6fszMLCgswk3uLX4fvQZZYIgUPDUS7KIsHiKn4QKTlUKjHJkH2Ykk4t7jSBp2N9vcL/JANyjUdEklJzdOZMWIK59tpV082DSbvEuR3yPCAmmLYrnUAgBXIfCAei5+U4QQAOcYkHBKRe60eTeg8eaNFmO+zCQbmkVJxEXTjwcfS57RclI3k9y2fQ7rwRTVY+eGAj6tY5udwwhCvPEfkLC+i0Cbcz6blOHOMPAigEB8Qkl/PNZGT+qKIstzuj+wgtyhX25QyGrtnH+59aJCfr0aQ3otI1ob/GN2WT8PhxeyafNaTE3DfxyGUvILp2/M7QtAWTIQz5qM0YBAb3+fwlz22Uoy94gR92/+Ya4TkLRp55rHlcLsxOMc+90qYAnhfHmZ5CiP0lCYebiJuP3m8p318BEBO0+YqXxETNq5bjrfwqW5ES6RoPgmBmOvLZjsliBwNtxEImgkRGCdi0m0JWgi1C0fD4efN5cHsaKZlBwCSHn2Mwft/MJhYWFgZhwFq4lswoJjBfblaoWpluHYZngzhbBAusBIURxeZOZJOsrlaowHkbiKOXCbtoNwapyPCCnQ2caN4MmZwQEJDwWztakSesgOD4EEtP3K5crQ5pYyMmSsNR3vhQzD56+aj9GQQE/o1rDqr4eyYjCws9Wmh0TegZsSH39HJIlMqlYUSo4H155vklqrKqAuKTZd/KdYdXqd0uUZ7zUUAi5He0P3/t+D4KOBCu2ezSV5/eb35HlsnaaomuZxXHZKUMwvbdpaW2IUQSJNduFek3V6uUccO2XyglY1ZOXKgfTDLyjVCwYHuIiaofsv8kXy+ZtmDKcgYKBrbn4s9sqCP+iNVvfNljf01m7E0NBQkmXhR7P1zrUK4WkhN8QYRp1l/vUOX+twbdez4afYin0F4Li4uH+s89seP5ZP1dT/7MzI0WFhY2kn4X4YGV2byTnY63/O4/iAZ5Out33h692aCAyPC9NN+IRl+SZVn9aE3Cv+tu/DitvkxYAemzdHSu/hJdbkoOCGwefdgKKLsMrXd9c0DlFFVDR9tLWJu0HosnJJkIywFBM91AeM/ooYAam0OiRmH6ttGE6j+788mTRYzBU++8IhbL4k0P7Pj3XRoxkTKFjqQX6Cm+SUhUu7TsClDakX2io0W8FevrZSqVJqZUAXQ7+bjr5uSC8akg7RUosAeFWJFAaSbD5aCNVjzc70Z+vHQVwSPzt08dML+//KZTppwiytCzz+2hGnfIDPo5qlRHtLYafvtHGUbSXYF6I9wOS9zKaiUq/yBRVkpPKNPA35Lldmukt0q7MI4rPAcOnwc3ej0o/QwHLnV5COFLrl+mjc1QeZK2YWz/3keypn3X5/UWJRuUUoIhK11ulvx+eM1ye2phBw4rx5lijnwph0PxqBWjTh5/HEbWE5dxJt0RuXX2p7T65LJXBSmzozMtckvqM5aPBdWQgD0nOElQVPwxf047RK3/5U/NC5/6NAd5UNxixi+iS0ClRElGkxKBLun4/HhNSrrMMraT8qrJkt585l+Lxe5AOfdqIvrCzLFqUqxJCf5BTJWAFFERUgJdMpOZ3te8sk7SgIv3sCUmFhapSCMmpEgJSikulyykbKNJiaSmYs7MqVNN49Mgk4dSpXotnpmD2TGjIZcbCp6ZKwMgBp5MqYT4//GcrGw2MM+5ZylOjX2Ok1fRCgxzbJ6nIIOYCClBtLuT8c0sG+JW3wq/ntOnG1StjqK02mJhbFp6gebCgFZXyuSzd8W0GXNJBoQKrcXEWShoP5YsE2IvC7Hh9vrDK8YrQ8b469GYnwu3gYzt3Ru+nuXlGl13XZfPT94QoYVmWH56/oUlGrD5t9dzTanrvieylMmFRMItMznIZihbL9FkhZNeK0VyF9jP4wcU5F0aLYfP53QG0eOcWvha9LZebxTtk/w4tj/MPWGvysgjx3EoW2bjc38UtSCDBDlMhEwpaOxF5ASpsm/7g//mO/7sB/70L2xZx+KyoH7vMUyp/KGdcvZh1p250cLCAsTEThbfJbj/KzO+0l2HT6xnPopjdud155AppYT/zzOFmd0i3ZSqh/QJ0oLUtlJMkmWjeTN65u/BYqejfu+xB1r33frYlIKSFraG9yY6dqQMZObnKNFPJEJRTdIMspApoaKMeNtx3OVjiYmFxZb40bQ70ZUiHSVQTSRYTZtdicPNpEMGJRQoAvK4ZFCbUVHijuAoNbVQKBuVRsozSEoVFaJQHJtSB/FzQH05fDge1AczLQYKmm33j6Nk2W4vR27WNx01ZIy5VdrHg/Fcd2KSZIvF8Bt9p5eLXsNg4E515SDRtlgMP1dG4yxdyx0/UEJqtQydOBm2C+PRxdKYX+eANjcr1OuFn2nDcZbyufC1QSlB183TX9/H57MXTURGmejAvk7UfYROqOUz4Xn4ja/0ySnkKFsI1YpcM0deLzQmI5EVZRaHPxv9/pCy+TJfHx+LNuX3paTZTzwab/ZNy7B5Ta0e5bjTxqz9TsaErZm/Pd+UgMx7YxPblUx5h7jLZ8RlJL87oMLB8JwYNSWbMd095tyutilXYbVGSAnaepPdM7WUUk0S3ZTH6Y6fEa8TaZ052jviqaRYSinXzMtYsdjdYAUlbjFO85yASFRjGddE1HM+ivkHkk+0EksZsjMiRx4n5R3p+rHExMLirJhXziEev5/leRC9XjEq6+Tz4W0SNZ/LTSLPRK06Nl0vktsBn0ePI+PRmqyB1lhdEgFRkSRWZJNIsivag4eFHC1zuivKLOhaIRN736X+wI28Kng+GSYYTiMO6MTJJh+nF/lRNjbLkacF+OpTB+imly6b379+fA8VixXjeyHT6pul9ZZ0vGSoWAjPQ6tVCKcPc/cM2pYlxXbQd6lWH5qhfmSmHq9Ti8tBo6FrXoOUjQoFj54/EZapFhp9k3Y7ZI8LuqK63Tz9p9Xw3GXcrCEixF0xQkaQOwK/ieSXZBtlQyAAJ5s1fhCHvxiO17vGhxKezGyYZbIZen/cWslkogBefxz6RxyOqAcx4QRud+800UGsfZafO4PW4dWwlJctF8jrj6LjxOc+9nnT77zvn00ZYpPQOSTzwtXOBk1AoKjIk6XF2E+9GKW+bBUAh+32fOKR9DstdhUMQelwPVOTEfhLoI5sNVNnHiTafszzcpjUUCX3RP3eYzfPeZTFLoE1xF48pBETIRUwdOJ3+eclgWvzIKoKbGGimghk8UbUPKmpxCA7K0w40E6Lv2UuTi7vRWoCwtNOnapHizkIjTwHzLAwtgo5QZz80qJknni0vl6lAqsjTcThs3kVhl0QCTGe4nViyjDQ7+WMaiKPKxYmETHD7WJshXF2PM5EbdTjSYaqlfDzB1OFn3lhgfawdwRqjKg0xlOy0DXhcsDXn10il7NMXnLjslF+xkxO6o0+/eJDfCK5VVfIiQlF4y94yCspHmga4iHbjHnWTYYccvfWaCxx9sgmYU+ID1LRKEfKhqNGifjtATmVgiEb5jnUKBKvO4zC2sxrOtOiDCs6MNCOToRBeyBBpsWZJxvjEub3hUpQyrATC4vLAxPS9p5v3keT4PTFPID6z+++KH0Li0sJ6zPZHfilTyWaAK4gbElOpBQzehHTf6WaI63EI2knSvGLtD3xv0x7VJKqiW5HnhfQZrE7UX/Xk8tc5rkBXxrMi5BOHXF7j4O42wbfDPSU45m/uUxUdG0Jx8Ji+0j1mUiiKbHSEKhP8fGEyzjuxKgf0XTh/RvkOOKnWDDhZFUOO8PgvXIpbidGO7B03XQ6JVOyIZ72e+jQOh1kfwg+9nE/0O4Ujb9DhuGh20UG3vX7ORPkNhyFCgzUCElzrVUn5PlOpNwgSG3//vAb/GaraLp1xCMCxaXDk40x8TgzCczkYABk9d/UAAAgAElEQVTdR4NB6MPAaytwfHy16tOp5RotLW3ya82bjhritt+lRoH2ccgc0mpd7vjZbBeof6oRqU2HDmzSydPhuURX0mSSMWWn31veMF03okMhqRWlGQk7G3f6UcsuPB/DM/D6cLprLhtth/RXr903txlkM+RzJH22WQ6TvKXcrtTryF/C5tSMSdnm/eMCqVDN3FItSplFW7KoI6P1Dnf1cHdQwaXRibBctyU5EUhL8Lw5PPCdFPk2kBEhIJpgCIlIM8YKaim+FIHs07zwtBx9iysK9XuPHZcrbEyzm4ObqcFO9L5Knywk3sLJv4vuB+v3Hvsx++6wsNge7vvktwV+EBMNmZ+TyfgmAZW4TAPC4Sh3YK8XLjCN+sRM25U5OGgjxtwXYGlPx6SMSkkGJYxuJ1yokCMC0+kZNngiTTZGjZaXG+SyaRTTfeElAfbva9GepbZZsImTX+tsGHUz4cRiaQNGa7EuQdVrw7gENChFhArprKtrpYhwoe33mefYnFv0jJfkJBtdG40+HTgQkgz4ZJaYXD31tX1UzI8NKSHjf2nRM8+E+4ARGBOGxRAM0nRmNTTqop0Z5aFGM3wNz51oRCmzK6uhaff3NzomWdVxMxTwhF8YVf3BmAIvJBIwlsr038lwTMU9NZp0+fp5AblMLibtgSn7uDxbB8TCaZbjU6+mEqchkxLXgFRZF23EXFaC5yTysTgUlZRAnnw/MK+FuPwjbcy2rGOx41G/99gt+hhbP/fKXyGi78NnRuLYjxLRu+v3Hvu4vaoWFueO+x+6+zEbHL6z8e+/luXksCsb50ROkoqJINkSnKaOpJVxeqpdePYR05jap1VMrmrUf/6L/5qI/vXVfh4sLC4CboYaAsWEuAsn2UVDFPlGacQBYKNRnqqc9trulE2rq5QloLCIybXTKZpSi3Ta4HeZKYP2XZRPpLQCVUHadzHrBgPvJG0VLcX6cVAkZImoVIfkcbtwNhPQU0/vowrP+mm1isbQSlyegWqywZ09GO73LE8JRonomr3r9HVuZYatY89SqLhA9SkopaM3yFM+F/4+HLkm3I1MCcwzSbIjnkT8pa9cE83qgfl3vVug0QaHkTkwGYfnb//eTXr+hQU6sxLuc6nZj1Si33/mNDlQSLgt1zNrMpdLNnrkNsumpZe4C0facqGMYF5O4UDYmWQG9rGKgm6c8Uo7UkD83shMIjaPU7+nwQS4MS9Aqqzsw4S2DcdGoSE2vgpMxw8fY6ZRpuHJ9Wh4YPGaRRo9E3ZoufNKNVsBnTvCR0Y+UXmLcowgbQtbnbGwsLDYGUB3jk56pUR7Lwb0IVfDgEmCGYjHMfFSHsHwPEwhlpZdlChaTBYajQ41G4GJqSdDCNajDiB05mAfMrQPg+sOHAgXc2SnoJXY88LHwStSYj8IOmswCE8GCCIvRCYNb26WzTrT64ePu+ZgK/KYvHCySTe95JRp3Q23jQf9Acef3UtLC2Fp5ZlnF+PXjDTXcdakv5rXVBvQGpeUclmP1jhxFvkkzUbPEBYyHpQRPX8iJAdjL0OHD22YnBXi7p2VFfaVbFRNO/ZozM9XmFAuP6FffXIUdhwORlEZBJ4OWejNflt9yvL0XyefjboV4R3J9uIRA7jPrYblE9N1o9Z/bzAKSzLYTkhKRHimVTUQk6hdueBG2+H/pkXZiz1Kkxa/lzyPsgUeJIj3Dco4qtPHXQzfD+65kBIBnr7ANDVtiOx2oRUXnXOSlrkSnQxLZiwsLCwuKO5/6G7jyxJi0m7LZN148m9ETBiY/yLx9cn24OEoF5ETeDOuvTYMRQMRMTNzONq+26uatmTzu1s0i7Qs2NddtxIRl9XVKpVLYzNV2BxnbkJdnt2TcT1jgoUqQmbhz9KeqF3YN96OOj/uuRcW6BtuOml+d6hBp04vmFZgMibYAu3ZE75GxNe72Vgd2bvUpXUmHZgEvN4r0De9/IT5+6tPH6Br2HPy7AsLVCuHz4Xnfepre83/yRCqDO3dE75WhMatrZWj9mn4SMR8i9uJW5SByThDv/GFtim2OY2yUTycSkhOzMRgmYe3UKFRO1RJiIPQfDGy9kdU2FuniWSbZDLRfZmCa/wn3kZ4H/gMCAux4mJMttX5ybO+EBcQDFZK0B6MgDVHjSBx5fdCMQ5ugycll42UOKgvE1aFrOfEwsLCwuLfXfVn4AIimw2eymboZKU8XjG+z0nmdZ5HYDqL5/osv/5k76r8Qj5DTkTQy2yhUCTVlqTSIeFtpNqREUcPb4mEq/nxJqYbaOTFpSI8Zl65KXlMI70jCwsLC4tzQlrYmlZMJBYeioR05FTKA6OazJsujC6c5eWwhIGJwQKoJKdPN2l1LVQkEFjWqIff2NGJgpKJbI/OF2kdrlYc83eTO1g2NipRoupLzBTfuGOkkJsYjwpxIBsUCCnzoMQix7xnT8c8pwzRQ6JrfxDuE5OF4XeR9ebUchyzv7jUI7dV/PI9dzz4TeaGO178++3nP/bWt7U2i/8fccnnhsNrJk7/t768ST66cgrx6A6oEpEiQmGZxJzzVs+EpUmLsNcfUn4/l5HOtGjwwirlmuHrMIP2ZC3m0o5E1GcwtI+TtLfynEjQmqNKMrqrxxxnh7uDfN8MHgSGpzaisg7+P97oGq8JsRcGnhTS5ETIQ1b9nePnScsS0ROLQSbkVGXnRNUjxr6k9+VMR9TjufXfeT0dOQimDLE6PTZ/nvkrFhYWFhZIMi1QsRS35+tR/uFndfh5226XpubmoOVXt/uKORY+FMSqe+wdgSl1yNkiIAbIPZG/MVFYMlBAJNB+KxOFs24QlYtQtkG77XE2qCJvJcuPe+YZ3p63zbl+tJbAVIt5NBWeggzyI+UfJMqi1VfanNGuLGbZdrdAL73xNP3dUwfM399w06kP3nPHgxctkuDn/v5H/0x/9/7Zj75t/3/42/YpOHEzE48cj8d1ZLjEwmug1x5Rhhd65IUEbiZqER4OEAsv5bbAZIuIQTUTZKNJwCAY+JGI+kw5T5MNTpKtTJdzPHhamGRsBcTTg3g44n/x/aiUI6Zc4tk6hpiIQbZaMO3ElKacWFhYWFhcHQhVk4K92un48d/6p79/WZJy1xY+dOr7joSEsd0f0l8d++cz21zpcCVtNZ9QO6BkRCWTFHFCFIsgJUFWTxSW1FfsHmFt2gSb3K08Dt0/OhU2q7bEJqK+bGWctbCwsLA4O6CatNqhpF+vdmmzVY5MnFAoPD9UQKCaIAgN2LdvMxGSBsUl/K67th4qLKdOh9+Qq1XH7NM8bu+mUU1O835QcumyWnHjDWeoVhmZlmHiFFUJQUM5CWbVQ/lQQUCSrADhZjDHFthACvNsjdNiz5xB2aZPy9wJUykOo/TYSnlouk1G3DmEQX//P3tvAi1JWpWL7ojMiJyHc06eqcYeaOahu5FuhKYBnyAiiIjTAy8Xfe+51nvK8tLXAfUienHCx0WWC73vuryo9y2Hp1dFUURFsaFpaMSmmaGnquqqOqfOnPMUmRFvff+/d8R/MvNUVRdVZ6r41sp18mRERkRG/BGxY+/v+zY6/P766z64pzeVO//sq4Fr27TAvWnOt7p027N+W0/s/B09uPT3obrFzqUoaHGPnHJeSZL7y+yi6yZCcqk7XVBKn6FkJabz5G+yHJmzIdLQj7wEJctcdqu2lLtsIH17jKwJsi1alTPuiyMlomjmBA1ZLpzoeeRzd3h/OKSg3tHdidmULXWiQi/Nd3/too3/TIj9/CQgYLicGGGo5h13j5WS0pUAgdHcJ+LGfzFiXI/oPvrvD0njvz/Y9WvYJK7JpSBBQSbdp3YnFXUiRpmFlScIdiAfbrV0QAK79XxBlwxarRRlUl5YRoLypdXWN7zNzQyl017YzRgKH3m/Vc2pwAblHWIreAmgvH5SyW0FKNv0PX3zzmX6av2dnvAmAqpwZ2NwZjY2ctQfJCELfuI3v//PRk0ddx3f+5HTQcK2aanZoW+6YV6t/txqLbxvPlZt0jMrJVqYKdDvfuLfhf4gCj2PrGxKcT3Uvu30KVnUx6Bfa6kgIsXdgnur9fA9ugAPEYRI4JGK+DuTOCc+u7tC8YPgzjYs7SXIUHyTRpd8oWAUM2EnYtXlmD1WdDmprbYhXH5/SM23/Y2V7PnSz2b83DBJqf5FNLwXiyskcwJrentCnxwy+CbmFJNXgu0Qji0yJZMItzFixIgR4/LwSx/7tpn05VRzAtP8Mgj73pAiwW43ZxM798V0X/XCmZvX/JTVlQJ5nn4SB98ERNmtatSLRsi3sMdfXcurDApxHxnxIAGfBNbyjUZEWHW42+/AC5St/uamflqH/4gETVv1LFWmWnT8uJYPP35qjoZsnQ/DtXyuX/uvb/qTiASxh/i2v3pE3djq/QFVu336yjm9H0opl07Olfm3JaiUS6uA5VVPez99bbNOj5++Rx8q8FHQF4ezJXbGJa/B1va5tMpcDLgrsYvOw3xovc0WucUMCT3FzIOobsSQBLsRAyQYMD+knFaLGEgfnmQiDGQQiCAIkWVBIhwGPz0vDE5AhoVdfkKkysrKnrtS74eDEiPG5aD+7tthY/85RZ7q8BMDThQJUJHqtNTf+4o/87mXxDs1RowdEND65AnXD373LX+0b55s73mwesUZwBc+67epUb+XvnT2T8emHUTcUab/B5udlIwJrORHnV5NGS84JhfLsogVfdKibQqaDIdOo3wTE5O4I2YJCU0F5T9kUaQE9A34v8U4IKj//HM+SZnEi5R/9CY/qU2niQzVFxVGHgEHw7vqv/y8QDkEorZp0Y8V/9Pnfys+5ocQwaGo6uw6xDyNWK0DC3ZiXomJ9Y1C6KgKnsnauuaKQJEDA7ECdxeGpbtIgGv1nOoS7DqskHGHodQX6hkogebm9HoazZySCJNyj+0pVQ0aBRI7ti6yQ6wuwRRU2QcYDmw6v64zJceOVKneyFC9qa8DJ45tUb2un9Kf+bTzytoejQiJjdHevcecklG89C++HpRch551fFZNue+R8/Sym4/QgBUsT2zW6bFHzqv3yDLMd3v0RFNnK9IJm56rvvc9VKcX0Lmln4bHv7rrouxi83Vy2PfU/8IlQTdgN6vLOnB2Rdf3UK2TcSK1juso2bLFHBElFea9h5JPAIUQxwXImgyY0+LMFnWJh11atSEbNxpsdsni8xayZzT6C5VDpSx99E1//H+SmTnJcrnEDBJG7eUnBSXEvI+dLOz7nCpyePLFApydYM456nsS+5wcTtTffXtANZY3Diwd9U5z6m+jSzQjEjejIybmL6Ui2+KhT4GnBuD7629/5vup4DSKP/f54iHfdTFiXBTgmoCUKq39wf8QDoi4vorUF9wRcWUlw64enJM1kEy57AM7eXF6LRVblM1EwU86PaQel2fAD5mbq4bfK+RboXzXdfsUkBX2lIGvigRR2C47EdA0l4Ba7RQ97RZdqoHtfaOZUsRXYlt6bDcA23fHHdKFlQKB+/pbb/zTfSVNesPfnQ4qmRRlDZ4HrlhfWFqnZ87roK2SS1OeCbCP1lrUHfiUSej/SymH1iWQsCy65eR77LY3oLPnfkpxTCzu8GsHgbrxSwkmQPdilvYiaME10ynpoFCVYNhrZNjsquAjMaWPiSLPGvMhkAl8wx3YCEaGXY+SOX0cEqWIcwKJsc3LG2w2yWt2yGXL+ly1fjZc1NjeihFjD1H/2WcFfNZdi40oqKCH6N7iTz/4srGpMQ4cAoofTmJcGvlc/+i7X/fBpf20q37wn85ds8F7/Niv04X2u8Y+3+8499a/PSGbGAYnk0or5n+jpmxtQ/brXCQLkuTviDpnUsbEHVcihaTX/ASyrExDySg2YTscqL/zOc+mdOKLoXUwei5IgDIY4jGKwgE4lSJq8pNZ3mCSY35wUGTQ1fpkTfMyco7+TlaNl5fW3/XcoPiOL8SDJ8Z1BVHoSNZkFMhUQBEDcioxgVUApU6SSaiu69HcbJ36ff3EXyh0VAdjUmqZDFUq9ZAgWy63yQ/0tFKprUpAyIIAyNDMzupSwOkzM0oOLIRYANJeUts1oKlSi06d0SZsuVyflpZ0ZgGlmlKxFxJdYc42O6ezCehY/Muv/tC+O8/BMZmbiuS2vf6AljZ0qeup00WlyhlyRqLV9ej4rN4PyJykkjY95+QR9f9Hv3Y2VLpAxXO63qJbOePy4PJ/om7n9wcbrUeSkAP3zm2E7rFoHCjdhMm3FFFWlDbOfElfc7H/sinyGpH7r51MqIyJ+hquyYNh2GiQpBuxOL0qhY7+TcjKSCln2OoqybB63+6pEg0yOi+bt55u7qMwOHFHDh+kS6KsgUOrKfXtjZRxPKO0MhosOJchGUbgYk7rjARKlsFpwXplGrZrGJd1Djzqv/S8BrmJPHWHMNxRPweMcKvDHBOf64Iytur9qKyDgEOiW0w3O1FmE0RtJs5iHgQuWxzUlFziLMrriz/94Aev92MQIwYxXwRlGZ/LIiurZZqfYwv5fJfExxuNAR0H/BAd/Ou/etrCwhY9cbZCgag/bJ8yab7xJQcqMIETLKkSUC8sAUlQIs3+Mukeef3IZRZqIbkrOM6QNrZ0eeHYkTqdPV8mN8mN8oY2NZr6hvkb37P/ApP/61PrQbffp61ml25c1IHEcBhQla93c/kMPXW6QF9d1fv9BTfMU43lu7a6P/p0/6NREugoW9J/cWWLKhmXXH44gyT5uUffqu7x9566R1vGc3nIcpKhBNhbb6hAwpf7/Vqdkhl9XFX34um8Kueo/9U1WM9nQ0acjzLc4JvY/L1Bu0tuPkVOSQcr6oGRr99WIkmDTlQqRJCEwOhDP/B3Xzf3k7X+Eu1zMiFmCAE5cOFiM1wGJmVmLgfglFwqO1K+99MXnyHGvgUHCJrYqByEOJgw02UIQIfRINWBC883lY4GLyJ5SN56PA2ByRQHMZu6dmqlOJBBFkbkcd7w4eLPf+Fp8Sg5eOg88u8OxdNJ5pb/95pfw95z/8sfIqLn+ZxhkOzFKCDhTbHZGYzKmtz9N5+PnqBhXT89HZmygQwrPJVmM0OZTJ+y2UhqLNNgxpZODalY1PyDILBD+/mBb5Nj2OYXij1qcZCBYKTeTNORBZ1lWVop0lNvWlHvkU3BL+qKfb6DZVjt337Tn+TGftweQ1Q5G7U2zTB3g5Rvi0c9T+/zfCZF7f6ASmzC5vsBtbs6gKs2u5RJOXS+rjNDN80Uqd3T38u4Dj26Vg0rGaW0SzX+XjqZpHvP3EMWP7wheJAAxGt1ySnnFP+D2F7e7+plguRq+QF5dU18xjU2tLRHoBMEoXTZSiSiLsTeUGVIJFhRRNphxE0RnoraGYMh1d/612Pjf0JBJUaM3UH97c+cfHXcfTy1/qu31eLDfhARHJLXruB518OIcN3BZ/ZzYLJXeN0z3r+nv38nTApMgDGHWPE3w8Nol0smkPLiXWOg/y8mJy4rhFjiZyYYrj1ZiDOtOOSh1CSKHywemfoj98UOsQcNtZ98hsrRWjmOtJH2CwySUr2nyzlsBGQV3GgaUZgiDJp9sjyeEVmSjQ5RgZnvioXO32n0kA8F6Un/XzIaWqn6p4XB9aHi2z/3ndf7sTlI6Dz8psOROXnqH17Ta9h77n95udNJK61v1OjuyWFzs6gyIsRlnKQzVDwQBSs6DJDtbm5lKcXKHvBRqjUdK0CZAwlyhhvxzVaiZ4Kl5SnFOcnxOs4ulalU0On/Nit6Zmakg3GUdYCRWz7XpZWVIpQ5n3rvG/7iKvQJvrp48z+fD6aKWUrwdevsapWOz5XVX7UfSnlKpyJ9Sr3Zpa+v6X3zghvn6WNf1yKWmWyaplOuKqmQcsBN0b+xWdtTyjlKJhLU6un9tzhVoC9f2NTHyxsohTGufo/Vfl5xPjy2vUe5xylnqbui16eq40VWTEFJU8wqyTCx7NhnE7Zhs0PD3oBSi9ogrrdcpSRnewatLiXSrsqeqO/BuZazNuCwCP+k9dN/v+O4D4OTixjAam+RkdKK6eBqYqfliMW9yR251Dp2ghmoUFzWOXCo/+yzzlEQHKVymkICLFJ+SP1JSSbjENX0wEanTXTcJGkTnknqwIOYf5Lnk1rKND3p0+CTlebPsGxFqo04KQGTatWyExzM2FQp/tznN673Y3RQEAcnl4d3f+JbA+k0DE6HyH4nAbLdRlNLSRE8iO8IyLLr7C2SzgzUMuBTQiwJlvny7H0i/zebLvXZhh6X7vm5OlXZITaX85QMmZR3iUX1xnZvk1OntfdHt+9QZboVBjPwZtnY1OtudnTp59hi7YPvfMWHXz/hJ+0pdsqYdHuDMCD511MrJM/8t90wTw88vkxH8voYIIj51GNaNv3NNy/Seq1Nqw0dFD5lbopqbR3AIYXwpdUq5Rwur/X7dMuUdk74+ladsskk3cQk3A999UdDiyB4jEB2LGUeO51UXiTEPico7cCKHgBXhJtBK1dXxTnhslJvs0WpaSbE+qR69Yi9viVlex4ECHYaP35xPlBc1omxq6j/6m1TKjDZr/Bj58wYMQ4a3KS/uR8Dkx/4hycmBiZ7jVc/fW89KS8VmJCp1vE5s2GWdQRjxmdBEEqDeyMdic0OxSaZVZa3k1lbZmQZJgnWbCyIkpE7MTcT40Cg0dsMDx8yGXWWNEJ9g0xJ1jBVY5mw1RuqARpwWVFF7kKchTGbZFswiFWzB8M+UIizWBayJhvdcH3bykGr7VABVP+VW4Pizz4UD7IDgVitdym85/6XvyVhiNjg6mpmT0BgFbIrSjIo+4j5GaTCkgmBVHhhIZIWw0jN5sdoGKHlc/oJHuRXEF2l+d7UVCuULrdbKPnkQsfYwSBBOTZ5Q7dgqHpQniHl1bFJfsBmaskBpdyh6o2j1uElKOXoTNDRhTr9wiv/duYSu2HX8QP/eDY4UinSmRW9z07OR2UcZENWIBdmkugcyh48lpFFufOmRWox0RTk2eMFnWlCT53Ha026+5bo+W7IUl8YufUHPqUSepm3Ls7orDAs7gvz9Nmza/TZJZ0UzroOvfH5v0urm/fTRx/+HQpAYPU5U+27oZOsGgOrNSUhJi4BiQkbdT0lQU6y0VsSfXWEcLvRoGQ2rfr7qGlukrrrdcql57zVH/uD7Z0Ed0BytDyzQ+ywDWZHYQQiZvCwLVAJiC5rK0aXz8sEvCBQnBcBCOZmh+ZeLCU+MKj/8q11pbqR/KUqsUROkjSg7QdX7OqntH+JFXYqCyho6guThbq21GrBMEfAkdEXPgt8Ey7dBBsdzVspcfAzMFwNcYGYi2rYtNah+i8+55nFd37xK9flgYpx2PB75u9BEz0EJggMSKl2ommjfBR0HhbPk4zh+gosXyiHlvWOM6BGUwf3afBGch3FOyEVrORhgqbeo8kfSjQJXiYUOD0u+RxdrKpY0+eE/rmlaTp2RC+/13doaysTOr9Olzqhc+07X/Hhffcg8bbPbgVHZgrqPYISwXFu4AdOCT5HsAEcmyuF8zTOrlG/P6C1mi7dpNxkOP2hM6vKFRYBDHDrsUqo3Lm5UqJS2qE2W8F/ebVKffYTeeZsmY7m09T09PVvKu3SZqNNSedWmqv8Mq1tvYMGUoJBg0C2ocf1GEoeS+7ByURobY9mgghWPC4BqXINB0qwzQe3JMHX4m69Q5XpX6IzP/z8yw4JkiZnxMyI0EhXYkiB03zfQKcb4X0gkEBgMmp1T5foGDyaHRn9X74qvBJzWwTBDqZuMfYpgqCgMh0twwBqhjtVekM9eMzjOWsEDNU+UYUDi6FPlvRDwPiQIAZeJj0fjST0/zBeE5O2XkcHJNIjIlCNKfR7ZFMQnIgNMwKY3vDLO9CnYsQ4UIAniXT+NSGde5PJztg06acD8qrv6ws/OgkL52NpeZqOLG5Sg3klrjMg19HnDwKTVivDkl5kTpqqpw6Q6juqf48EGbVGVvmZkMq+5FW34XW2r4eMucUyZtjmZzIezUzr3wEC7GY1T7/yHZOVHnsJcX6FBHhuuhBeV06tVulm9jVZrbeomE9vC0p8zqJIj50bFqbCaY9yxuPWkzpzJB2LHSdBz79xQb0Hh6XRH9AzZnTmKZ926aFlTYj90lqVbi7laIYzGV/fbIScDsQAr3r6b6lOyJ8+/TbyYVnPQgLY2AfITPNDIzxQUtM66OrXdEbNFh6f6rOjfwMM2pypvLK3XwjeTtPzLt33PU9/Uscq5pzE2BXUf2bfyIYvG8q1NsY+Rywlvhh+8R9f/baLTD7Q2I+ByU7k14OCF97wG/Tmb/ljumXu5cNvZJPz2aO9hdTPqcAEeLKBCY311jGkNoHR9RdZjdEsSMLIsEzqaLwTTFt6E5cyWpuk5Bn/JMa+RZl5HXmHgo6kD4dEZS7V9IbbD2hvEHFMUAZCaWeNjYDwXqTAZhbG4lYH2WQ0rcCuhOCVIDsjlw78vyLLc/W2SUmp5EIHj3dfjIfZPkdc1b0ocrnOe8ngkgiQyZgqR4odyIRJug0nAmq19BN2udxSfA9S2YrI1XOq3FZloXpdn4flUkdZxQOwlccDtGRHKhWfKtPaxnyrlqPV1SIdO8aCOCugIwu6dNNsZZQVvZR8cIvZ2NSZGZUldwbkeXJXsi5c7HfvBSQwMW3pgWUuz+TciE/nJmxa3mzQImchVrea277nIfPAGQks9MRslGFZrzbpSEnP22z36Nym3reVQpaef2SG1hv6uvbwZl1Z4ROrpGBt//xjOitzptaiFz1F81buf2yJiuC88JXuvlPL1E68KrG4+Cq6fW5KTfv44x/orfY+m0LWWjImsMRXTq9Bgm4s3F47Un5j6Syvey6XTjVZxfPA9z/riq6hIefECuk4xP9HvEIEHiavZBSjgYlZ4hkl2O5U6hE/E9pBVjyprEMx5+RAoP7u279LbSf8RxoeWWGPnDRRlS+YKLHk01EL/MBwc4XTaytKLaq/EnLVCiYAACAASURBVJSgdCPvp9M64BESbCqxjcOCYMdK8cUN/SFkO1oDCjAuucxjoczjxEnFg4H4/L8cIDDxmG8A6a4ZmMCyfnq6vm0pTlKfU41GRpVhiG9wwlOBLDkILJqe0jdeSIOFf4LvoF+O9LohdnEl5rsUVR8cvZxUckBnntBc1v4gQcV8jwa+njY3t04JdrFd3ciT4/pU5WDoN77nzxf3Yj/uBFjSk+LbRM/7KNPYCTsMQEycmNclG5Ms++WzulSDso5jWB585exaWOoBR2Uqn6Yzm/p4PfPYLNXYy+S4m6SzG3V6+jG9r28c+vQol3Vc21avTzyuJckvvmGevnJ2Vb3PJBP0yTMristC3KPnC0zcfWBpTfXqmc2/PjWbfz094xlT9I+PnlPTvuWmI/TAuTV6ug6ASmfq7ZDusdnpUzqZoE997zMm3/AvA/EVOMZu4C8P6l6uv/v2uO9OjBj7CB/4oWvrCfNkcdBLOdcK30hgQqOE2IRlbct6CKQp3yQDNWkQ2PcjgqxET5i9w+mXbNJS0/pCpB0xb9u2HWObGWVMRk3e/Djpvu8BpQxgFRzV5MkStQ7GQpnLM3BwHXo6E0Kqlqj76RCTZItJTXZV04aR4geQ0pAqzVha9UNMbBXjNrjM5gyZMlQ8TKoNbFvLlSWrgkxNNiHLfN11dbAOHOL7wk741XtfEbAflyKogqgKOCPzo9GfoNdzqVbPUJIzFiqjEujzxHEH4XzoSoyMiySyvUFCyYdJlZCSZFk+9Xqa7F5vJGluVmdqut0kVbcy4XKmpzu0sqpLFNm0R91ekk4c00/7aA6Yzeh1QjHU7iRprrKzedxeQAITM2MisBPjz/5NNkzLs/xWlDzorXMDE1nPr9XIG/pU5bIIeuVUWQUDAm2j1aM+34tPLW8q2TGpzJOvsibLGzqrMlvO0zr31jmeT1PeTVDAR3+l2qJnn9Dk2o99/Zy6h4vs+N+W1ulFJzXJ9pNnV9W2HGfH2E89sULPndXb/OmzazSdcWmpqbdtJu3Qw1s6E/6VH3zeN3xnHtujEmRABSNBiFC2hhOuA/hRKLlIvGKqbnD/8EYijdGgZBLMACcxMv/ot6+GRX6Ma4uwjIMAoZKJuCOJQRRkdIYU2H5oa6w4KNKYDF9v+FGeD1dcbtutZMTiVwK1Tt7ZPkokPdrm+aXhFE5G3i41N1qJi9U9WnTH4yrGAQfkvQJ0EJZuvxdzh222UkoV02zom6d0KQZ6XZdabc1FwTzFQkcFITQSIp48uU7tToZ63Iiv3XJoqqyXASVOqdwJtwFcmAJLgsF1ybs95VALPOWmVfr6I/rGa9kBJe2Afu21f7VvTkwJTEx+yCS0OCDJZVNKwSOAf8lgqB+e5qcLtM4S3VzaoXIhG80bBNsCnXTKoTT/P5WPAr0vn1tTXBbpUuz7Pt31lCPq/edOr1C9P6Cso49JZziMtstJ0rOOT4Wlot7Qpc+wGuhlNyzQE5t1qnb1vPO5DD3OHJpKNk1uwqJTVX0snUSOjhfz9Ik3PO2qHKNtwQmCD5Hmml2ELf5fKAAm/wSZkIxtZFys7fyQUY6JxzcfZGEcvgFIEGSSZUeDEhNVzsYUktbELEuM/YP6O5/936hoZDYQTIjFSHcYZi8woCzIisVQDWS6ruFFgiyIBA+wmZesCgKdEsuFB1qHHxqtYcAKORZjbKVNQZ49ULBuNl1DH5/A88ma4dGEDIoEPMYmxNiPmPDEFGMMILq6LgclgaV4Jwk26+p7DrmODt5nphvU7aZC/ghxgAJks+hhw7JjK1Aclq0t/bSPrIoEKur0HdiK3Aq0ey6d5s7D8EBpt1zKsv8F5MkOS5q3ahkqF7phH53B0KIZ5rSsbhQom/I+PvbD9ghmKWenwATE1Uo5r4ISAeTDglI+TUkj6KgYxmfIlAR8rzxba9FzmXNCPOKPc5ZleatB57b0cT1eztMjG3UqsXlbuZBRRFs9LUfLtTbV2AOl5Xn0LN6um2eK9PFTF2iRA50T+Sx9lQOVU5t1mstn6EsrejzgFv3CE/Pq/afOrKh+PjdNaU7N41sNevwtt+98436SGM87xYhxNeHTjxz0/Vl/9+0vG/swRox9DDT6O2zH533f9z9fOvbhHiDmmEzG1QxMgKTJFcHDZWcHqS/+H4SlluhzKdOYc0+S/WI9SHhIlqR0kc7GsKiXjP4kiXH5It+Nsc8AlY003xNlTZGr3siiyPG90FbKnVA+jJKLHGZxb73A5SBkRKb5CWSpFTX8w7LgEispPvBWPDZks3X2xWpzygVyZFneQpYsbJfI07AczrAo/km99x+J6F/iobUPEd8mdoJ61AXXhNgYzWMnVnQINrsBS9ZEkE73aG1dS1eLhXZY1kEjv0SGHUATWrkjZm1Q/6ys6HjIDyxaXNiiel2XF5568wV65DH9tI35YWvfauvzF0Zu0twvafuKr1Kp6PUpnslQZ0VPHtv8zR1+565iUmDS6XqhyBAZoQGbqVXK2yXFyIYgmyFA1sRjp2onaYcmbCjhmPOVC5EZZa3VU0ZnOW7S95QjM9TnbIjrJGno+5QxJMseO8Sii/FzTs7RfY8uqf+7Q5/+5WGtuoFa5wVHK2GmxkkmqNTSxzmTsGmr3aUmu8dOowvyeV3y6QwGVEin6Mvn1656YELK8n6kjGNyeExre7PMY6LHfJPR7sSjwHou5VubNu4pjrEuc92jTrIx9jnms5GDK4ir5rFDCUf+XciqEk0o9QV/JGN0EF7vkOXyADGD02k3tKjH50FroMtDxHLhKl94Z9P6/5xRyZTlrXJpSJYDkm6Xy0s6MHpJPMz2K8buFTEMgLgqEBmw6VdCI2RZgRm8CLyBTcNAL6PbTlI22w29UxDMZHN6XehQDBSLuqRw9uwMTZX18hHEPHF2hrodfQPdDIrh8guFnrrJ15nvkk4PwsvDO1/x4R8f26Bdxo/ct6IGm5tMkOtG15FMejvFODmBCEtcZhmFk4zmFV5JrdGheqdHRQ5AVupt6jJX7kghS5mUo/gkxMGeyzwSWNvfMlemLy1rD5k7sguKzEqqtDagL3/tLH3r04/rZW42woCq3u3Tma1G6DT7z187S5WcDh4LaZeGw4DuYvJsyknSSk0f17kjFVqpt65JYEJxWSdGjMtCKd5NMWLsDSw7OL3Xu35SxiQG0d+89inXLFMQhn+SmTDVNB4fDjyoYrocHZ/lw7RDb5sWl4ZyCSs0ScNHinArD8YTMi3cy21b2WY4UmJyRnrrjC8lxr5C20gZ13ra3ExC9kIqVN0EKKtknUjuiw7FIh3O+rrxlBBfTRM202UWChw8xbCcTWVepIS03tXlnowwuQcU8Ni0yi4FXkBWn9eHjE6PByNKUs3tDc9i7CfE94ydMJoRkSyKEGEFo1mTpeUpymb1vP1ekopFtgKwiGo1XWKozNQVcRYdhkktozd2KE5zuSaX71O1pp/EN6v6+4N25H5aKupMDgi3uDR0e/qc7XRcZbr2gR/6wxt3+Im7AgQmULaI/Ndje4INdkqdKWUnbsYQVYUJ98dJMBU/pUKGEgk7VOtMZVPU43VOFbP05fPrisQKVJsdWqq3+bjaqjQzyw1Scc2UrApM35yl9W1Gb4JS11Nln6UNNtuzonLQwxsNet7iNH2Bjd4KTpIqvB/++0sXr+ntNwxOoLCBgtJUyfS4Bp9xrW1NAUeVNJgm13UMLiNTtS14QXlmUlAi0yRwMcs4g5EDbH7bYuXOoWN+HSbgBJPyDKLTtCHZRWDS0BdBazpFVOtHubwsmu9x+hnN++AkK+lSBA9Skml5FHAAZEEBYFG0vrSjykF6+a7mlCQjLxMEJQrdofZeEfXO6CCOy4gxDhDec//LFYHbDDr6fUfJcUn5SG0PTja3CmGTvny+rUowopiZm6vSxoa+EU5NNVQjQAClGVIuqPo8mZn2lEssKbfYGSoUezQ3r9P/62s5SvD3KlNNWlvP0S1P0V11YZs/YCdZBDrZbJ88liAvLlTJccbdVXcTkjFJpaLSjQQREpRs1dtU4DIISjptfuASRZIJCTjskWvKqOInbyh8iJU/ar+vbNEzj8yEpaPVWotuu0HzeSAX/upKlV5wo/4fnY+Fx9Lp9mk6n6WH13W57vGlTVWeIi4t4dJ8noOcu25cpHuZmwJ6heMkKcXrK6OkFBD9+bffcM0viiEh1uagQ+S8ij/oRhdofDygiINi2t4j4HB53zYG263nNzlqmXJtFXA0hPBobc+I4L1sS8b43LV35rsgMPFjqef+BgIL6QScSVDQ6pOV5KAAAUCBT2CcKOCKCNcDY0H8UQa+tp5niXBAAVkZjqsraU1aJe5svNWPMjMJjywJVCA/9rwokwMpsWRp8i4FzT5Zbc6QFN2I1wI+ytT2C0WM/QMh8cXYho/1eg6lUlHW0uSejKKQ7yofFAGM0MrsSwISrfSzQWCyzoFKJjMgr5+gBC8XfXTm57XlOaTHzWaKqltsQz/boFRan1vItpRLXXqUCbLz8w3aWCnwJcCn4TBFc7Naxrqxmadspj83tsG7BLOUg2DANFAzsyLIZgj68BKZEJQIRoOSHhNNU+6Y5VgImKotcqakUqYw4wssThfDjsXPPjarMjBr7JdyrtqkW5krcnatqvgiPfZVuenIdEiIfdlTj6ks0LO5YzK25Wbu85NxEtTve3SipDNk3f5gVwITijknMWLEiBFjv+Kdr/jw2l5sWswxmYy//I6bdi2NHIls+FBMylAQy4NrLHtSQgqOADf6gfK5kv8HI5kMycQLT6WwgwwYWRCXJ5mqnq1+QNNu9J21nk+zLBWNJcUHALUuBTwILN/XDSal1IIsWoVLKciKoPGeZETqPQprhRtdskoOBRv66UtxRNpRZ2NLxiykyRU7co8Fp4WfTIJaTyuBzEaRwiUppMhC6q/BGRhkeiRsx1gbxum5GAcLZtZEACkwcekGZR7JpiD7vLKqi+Pzc9VtTQHBT5md1aUASIXTGeat2IFS9Eh5p7VSJNfRy5+bayj5sSxzZa1AR4/orAp4JX5gU6ejn+A7bVfZ1gPtrqsUO0vLZV733sQH9zxYrY59aJRaIP81VTYmoOIxHWFNQIVTGlHsTMqYdHuDbXb4kjUhtrk3MzOYD3JiAbbr4VVtmCblHsFMKUcv4yaEUOvczFJnyIvvPDkflpY+9vWzdPtRzUn513NrdCSfVsnov3/dLbt6w02KSytq9Qg+SrzTQWQVvki171PescJpQIPLP7imI0aQcg1S7v3QTdwKg5aaR8p+uMgBxdAg1YpVvdmzp8OfmYEJgO1oGA6xMfY5ej5ZOS6tgGQKzokctimXaI3Jq4tZWEISrXGdHGNNZL8IWjoDFaAoJCjsA6EGm7jAoqyD8SZ+JQh4OLBQ5pUzRtiL8SvbsdrRkuR5vnBgGbId2MZeHJzsX8QPuKNAjxu4tSIYQSAiMN+bwQkCGQQlpMo4DvV6Scrn9fhHeSiZ5HPIClQwQUzLguT3xHFdUoA1/hb3zNnYyFMm61GDJcEpd0B95pE8dnqWFubqqhePWn4/QQtzOhhqdx0VGJWYgNvtOc8a+3HXGPc8WC3vpM67WAkG/W6AQi4VBiXVRnubR4kZmGB+zDvkhyWTV4mAA86uc1PbfVKIeSzgkjS5786RmULYd0ekyreenOP9FwU5IMSCZ4JyjvoNToIKGf1geHSmSKvVlnJ4VctJuVRt6evys2fL9KW1Kn3hjc/Z9Zvt5PAvRowYMWLE2EP84iv/9it7sPatsU+uc+xFYAIkpZnfkAKyDS2MuTVl11blG3nwHFKUHUdKsDYkqrhikkbE5OttJZjpEQe2jk9hZ0Vk8s0SDUo8EjVJll8IuCoTY4RU/ZgQt78BEzPDiRUOrpZk4BDVW1xaafYpgGpm3pDlrfL3MDZ6vjRHJSufoYA5thasKiWxsd4jyhrmbch4CFMbJZ7BkIIql4YwgCXDImNP+vogwzPNKVnMn57cOyPGfkB8/o+iVs+qxnr5EYmwYH29SJVKfexzoNFMq+8uLesnbDi4ojkfKWJrXfXUITZWW1ysqgwMKXfSAc3P6SfvwTBBuWyHnKQ+n5BJkY7FJ45uUrudouNHtTS13sjQyho3qgssevTU3J713PyxT68H7oSsiEAyJnCEHTVeQxZkFNnU9pueSaKV+XeSGptZE5BVTbkyssbImAgkY/Lo0iY95ch0KBcup106OlviaRtUKWTpgceX1f/PXpwJzdqOlXLU6vbo+Sd1GQgEXOmW/N7by5M3cBeQDCspwfYyibONY2JtM9aExb2UZzb7erBKs78ERUEH7gtrnBKXIEWguC18zYeiB41mWxN8TsA5KTpWSI7B8qZ5WU2jDBVjn6LRiyJZcEFw3CXiXGkj2tTDD4FJwfAo6RldiPF1lG46wgkZRGodBD4S+SZZBiYXjqEXGetApYOuyEWed6NHAY8jC+vCOljWrKzra/1omV3pMhgjxv7Ge+5/+VvKUpSwosANVvLi2FoqtakBK3pbX5vh9Doc6vNkeqqhSjn+MLoGiyKy23Mp4CcE8ErOL01RZUYrQzY3s3ScSzzLy1NKrYPAhpSkuUsPP6bdR2fKbZqaalLf0+chGgHmMvpcGw4t5TK7VZ3sG3KtUW/3qLJDAAJLepHvjgYmRJFA0Ays2v2B4qBgWer/njfmiVJt6utd2WgIKMuTZe3ko0Lsj9Ln0jUCE3BSTA+Tzzx+Qf29cSpPj27U6WmzOuiA5b3QKaZyacq5SVrhZn8zhSz926kLdO8bnr6nvImkmKRhK/oUUIb3SHMQZVIaXkBzKTvMUpik2RlXS33THAFu9X2aZgkyMiCyg1d7PtmWRVm+V4Bf4oW8Ej1/jglQmDfLAQoyJrh3CP+lkrIVuZZ26OETY58B2RFhRSNoBZmLT1bFrObg1UJ2YqMXNW5C4CDvt/oUYN4OXyXxRCblW4yTGi/PIt1duM7+KK7RoVggsuOkRVYYcQ/05+J7gvSfXG1KmZBUGyPGAcBbaIRTQoaVPDF3pGDwT+BzkmYCbTY7VByUY8c2wmkDT5+/+XyPOmw777o+Bb5FA/Y5QWAipmuBom1FgVG361KGlw+vlbPnpqkyo9cPmXI+r4MTWOE/dmpOzZvN9r99N3c11DlmV2AEICC2Cn/EtKRvsiGbyUFpdyISrEh5Z3l5Esw0O1HbAFxe0CNnNCgRXCx7ZGZpsEyRMsv2guwKzE8X6KlzOhixletCxCVpeQO6nYMYGLWBDJtmL5eNenvPAxMyTdhixIgR48AhiMnKI9gXnXu/Ufzad/7VRw72Lzi4+JNXntgXT/0h5wRZDJRIJJOCh8cZVyzqdTQs7q7KlZUzG8immAZqeHwVfgjSgcJFgTU9Mh2ewRFxjPBQ7O2JszgSp0651ramgpgnETrVkrHeGPsSKMVISc/zlUQY2Q1iA7/QhM1S6bToF0DWJmWWuYzmqYikF08xkhGBPb2RZrUUT0W6C/sRHwVqoJqxbsNgEPME6DopbrWwyedxqkzjLvYYEyPGPsSY6VpgUbujn7hRmvE8nzIZto3P9FUnYsFWNU+p1JCn9agV6O+12ilyXZ0tgKtrsdQNOxbD8j7HGRB0MoaBmhitwX12fl6XDNodl6an27S+oZ/2neSQ8gV9TjZbGTpxbJMeP1PZ1R36tgervz/pDO96Q8oZ/0sHYWRN4Nhqdh2WDAuyKrPl3NiygFmDR4JLiuf75O7QJHAntY6gzuUg0wAO23BqeZNuZDM14AI7y4JvMlvKhdmbGxamwnkkE3T/48v02e9/1qRdsSdIyjUarUzaQ58W+UZicnnAOTEDEg8RQnJ7L56NnvBMrDDIyCej4CEItGS4xg17WlYU/ATcbVicYWdT0f5Z7viqEiDr3vLAd9HTqlxuirF/ESRtsjzpbaCjXks4RfA6yIsMmMmrTb6oIhjhacGFjvpOIATWtE2Ww2OnOdB+KersdDQBV4rkq92oPIMB7ibIEv5Ix+CRZBJ6G3m7QJq1KrpupD5ZasUjbN8ifji5LFiB4pZMAgKTZlOP91RqsM3nBI6ucJAlDnjaLV2G2GpklVx4aUnfCOfmavBtVu9VucdL0M03aWImSK9PnNPzFXJdJVUWKTE6JaczOuBpt1waDLNUyk/ezmu2a4j+PU3wLxnlesAplVRAldoWmKC8I2TZUdv5nYBeOevVVkhYJfYwIZYLg7FgypNNYH1OcpykD26LGZjAVj/DvXUqpSx94ewa3VyJ1ifP9VgWgp39FJhQLCWOESNGjBgxrm/87t0L+y49nJTkXyVtbYtU2sMgNEVDJiRvBGqjyhul1DGcYJOW/gdfl149yIhBDSS9jWcMczVL+WxZap2kSkVRgyRkvfpGpgZZExYIqSVBURQ3/tu/UEctx2k4SHVTFDm9QvIrqhhkPGB8JmPLUGyppn1wbWUHQws9d0RWvN6jwNJZEAuDLOdQUOflQ7q8wsQ/kGmHhkYeA0vM20DEnY2Ir9bAyKrgaSaWEu9bxL11Lg+dTios46A/DroOZzNaary6WqJyWZ8n6+t55QqLrsOk1DR9Wr6gr7CLi1vK3RUolzvUaKTJG+j/dbdifXKB9Dr0rbAnD5Q8M9PSqydB7Z5LhWxURhJlEMpEq+t5yibH3W2vFdh0TWEn11dBo6OvK6POr5NM2S4FNN0zsyY00ijQTSa3kXBNdHpeKB8G1rk7ctZ1VKM/m7+Hko+UfWDU9lxDxQOsMnH2j15xfF/WrZMZo57eUcGBPtmr/YAy3F4ebrAIEMQ+AhlwUe6AU6JUM3x84N5qimhEcJHgEo+UYVDiERlyJqmXIYqcJAXkGgMFAYgEObCgSNqRQ2xMh9vnwDhZYb+FhOq5TVaZT0IoZOTe0ujjgG7jj4AjooDaI8pDEsjMpiNZccomS7gqPH6kbBSca4XW9oFjkYUxJOuzOSjhZWyTJDsWBRudaFnu5ItEjBgHBRKYEEuJxYOEuCQjQACysVkIrefxf6nEjq2dFDVb+hxZmK9SvZ4m32ceYj1LN9+oOw3DR6VU7NFWVXMvjh/bVAodUnyULmVcj2xWZrbajgqUiFVElekWmgh+dbd2q+8H95rN+EwFTqvrUY6vR+CYLMxcukMygoDyiEX9JFyKxlYcUfF02YMJjq9YvpR8BsMhzXAAgmVe2GiE22n6ozQ6PSVlPlLRVvhfemKNjpZz9HsvO3KJLdk7xGqdGDFiHGDEmZPDhoQdfGoXf9Jzxz65TrCfAxMgKRmJRj+ggmup9iTAkYytSLBAIUE0MDIbpMzQ9LQueIxWRGY1M+dAledLJSxFbBUlD3ixGX7CFd+UjqG82WQSJczgcgkrVExojxP9PqvIt/HFaV8DWYcpzobAZS8wyKgwUhOyLN6jhNJlMpxFUU+bUkqbuYmhGpxgi7xMhNd1Iw2MMcspvrAchPcYqMiwiNMfSjVT/HTS9TRxV9ZXdMmSbA8+K8aZkxgHBKGNsr4u1uo6ewFVjbi5gvw6PV1X5RxS3iZeqO6B0drMdCP8rfiOEGmREZHyDHFWRda3shqVKLrdJB07thk2BTx1ZpZyWZ313KjmFGE2wf16Uu6Q6nVdJpmdbaqyj0XBR3drZ5tZkwD95IwSTc7I4poE2FGYhm3lCf1zTFysP4/HN19pwGfCbASIMk5lgjEbCLBmdsck9B6fKytVTotLU//wXbvbxO9KEP5iVFHq/SAsk0yRtc2pFYFDlS/eZccKAwuIJgIOSogiR3DBIjuALvd86nUjP64Z1w4DkPYg2MZjQbzk2FEAogIaDkKKxjZByQN10AzF2LeAJl2Mz2SQSEBi6UBAYb2rB5MECGgWKFwPnNAIXPMGR4TVOtsCFah9NnvRwzS+I+VBdP7D8mSAYt6qvugGraFW/4ioqNEma5Zll6u9qOtxjBj7Hdb2C7BIfdGYD7b0wPS0DkREXdP3ElSr6UB9akq4Jzr9D5v7dltPg7w4YeuTuNdzaWsrS7mcXpabGtBjp7R0GOUdSItnpvWyNjZy1OvpcxmBydNuWaZGQwdNrZZDQ5tNO2sZ8voJev8b//SP92IvbzQ62276uNmbUt2d0PMGYXBiOskiMDElx73eIOSDTMKkoIQMqa9gUmBCzDEJjOQAApH1uj4GsKPHMsDlfN83TR2IC1pSrvF9y6LZzHb+Sca4KIPrIVmVKgVUdIUfAodYn1qcISk40XfAPxFLfJEob3LLYjPjgc7DrWEQ3m9w/GrMR8HXzIyN9jnR7xH4dOLMyf4GvEkqnKHoDCnoDsiSICNpuMCCR4IDL/b1bV8HKKQeb3TQwnVW9TkHHbCgt5oc/Di+DmDkf4uiAGc2TUFnSJa0zMZg5myccqdNRBUCq5SgYF2vy8I43+pfl4fuYCA+/y8HEphsA++6XjdJR7nXDY303kEPHbGlR5By7rzmjpw4sU4zFZ+WzmtuCrIetqXPLXQ2brVdKpf1udzpJ2mWA5VqTZ9z4nOCzEmzox9QZmda5Dh71ypi9KZ/OYEJjWRLEJjILWkwGG7LuKTM7MeIT4oJ4a0EXEkYlScvrddpKq/X2e1727bTjDpyGVe9TByUwIRiKXGMGJeBp0+2mI4RI0aMg4K9bOJ3JUhKxh1Z7q4fhFlvcFC4RAnPK/Wgeixrll6YqzLUiaQCB2idQUBd5rGgYV+NF4jPciqLEu2fPKdKQEFAhsTlDAnKNWE7FlAKBlGjQTxoS7YED+VY38bdd/7UzMcf+PV9s1djREDGw+fMA/rewChtEJmyIZOisOWpJoCWOPghkyLTugMKbIusNA8KZFLYrE3xRKSs49hamixqIKT7JOu22tWNBSVrYxndrZOkDN6sGX4CavR0NoWlqrFD7D5GnDndBri7AqaRGikpcZo6XX1e2HZApWKb5uer4XQpszSbruKSDLlnTqUSLQe7WjIb6JezuZWjWZ7ugOxTNgAAIABJREFUOAOam9VcFZRm4Aq7ydmRIwt12trU7+fn6qrp4OKCzsw8cX6KygWdYel2HEomdzdzYvJCRssngNmnRhr4Xarxn1wuWt0+lZ0oq2KatZXyO2dlJBNjGRUD05BNFDc7bcskHLTABEhKeQZ7F7xCOdVRMhEre5dt55e58dpc2g57sGnX74BsTs+bjq3iWyJAQCMEpNVeQMeYj9LFWo1dV05ZIfUAEuOBcQEC96XOLrPzKVvxVXo+Tc6Pxdh7wD+kyuUYRJxwaBXOSd4KS+SBBBrSjA+OsNzQD3Jea8qNznqUZhqRFFLmQ1BiYfxt8f8gwNajaVT1okAGpR+pI6oxGUSW+H0/9FtB92P7aCru/BfjQCBrSIZNpFI91VhPgOAjYVAcCgXNTRFuyGAgEy3VpZiYZ5JK61NhYyNPhWI/DHhw/Ub3YQDck6lyO/Q5GQxsVQYCHnlsgZwELOv1drqJIdWaOjM5U26pBb3jI6/57ne96m/+YuxHXAOYhFUzMIF0FyTUfDbKmu4UCIx2MN5g35FRh9mEwTeBp4qyBzPue/K90e/COVa2E66yZoNCLGM42E6kFZv9WrOj5j2IgQkdlrKOT/SdYx/GiHGVENhWTDqJEWO3EFivjPf11cFBDUyAZI0JgtmkzlDY/HQKwzThKnaFmONGpRWR/670fNWYT8ouqz0/zL5AadPwohIPFJ6yp8DaXuH0SEWZXAVhqUh11uewCSUdLHq9H5m+bRiSYyiHAqJnj/2yGPsD/SEFnOVQ0t7uMDq4PaVD19NwkDOJKFuCcopk9URCJsZrtkUBZ+WUGbFk6zY9baRWYLJszdMZF+JGgmhmJsvAuvkhMyi52hVWtmsmGxnAoRngbHry42iMfYC4rGMileJMISS+hnIHpRwp3SBLAhdYkQFvbhWUtJhU6SGp5MPr61qSimZ+5ZLOiDQaGarMcJlnKqCl5enQSRayZJEc44qccgfKGRa4+aY6Bewsi4wKyjfSWDCfq9Pmlp6v3kir+8NMpX3H2A+7drh3Uidnke7mdsiWkCELRtZE3tOEjImg2elTJsWqHm9AHW9I+bQbrk9UPqURAzbTOXbUNRaZF9tQ+axtNcMGg//jW44e6Hp0+FtBDUE2SAIE3P9F3rvW9WkmZalSjPpSKhJZwL/ElByXnMgPZaMflW76Evjw+dIc6GWq90Nf2R1P882oPfBVsEQcCG31g7Cm109qagExN2Wo/VIS82M/Lca+AK6RJT65QBKCn4k07fOCyM21phv4WRIgoG4o5yFqh+CPtPUFDYGJNP5TzrHi4JpJUrDVD2XAKjDpcQ0bHBXY1YdeJk5YXrKg3MH/4r8Cy3updmKbkolLWz7GiLGPgMZ64IHAt4TYhl5KN4Ktmg5WVGDCgQqCCpRvRL0jQYVaRnoQdjau1TKUTPjkefomfuzoJq2tl8L50Pn4KTdrx9hmM0tLFzRPolTs0rFjG/T4qTn1v37O1Ot+yo2r9PDj8whubtutPfne28svu+fB6hVFuKZXiflenp2lZCP+JWUj6Eg5CRrtXTzqCiuoNtpULuiAZ5L7LEo9pLxYcpTiRn8HOWMiwKVdvYXHCWTAcp1HNuRMW1+8j2UsZTUvBFYEMmne8x3PJ/PhFYFJg0mwecNnZrUbqO74EtRMpSLredw/EG03+d6A7RCirurB45IyYiMm4AqvBcHPomvRUic2sd+3wIHM8EBA1gSEVc5mWMhKiGdURQcSQYMzIkeN7AWyZmlLc0hUlsUOde0qwBFeybSrrexNi3p5P5XSrDWuxwZVL7LRx/KqfQo4i4jPESyp91MOWY47+aoRY88R82G3o+/pMd1up5R8GEFJiBGDNiHNInjI5zXfARbyvX6CMsw5qddzYVYllerTyooOMubm6uQ4PvX7er7HT8/SzIy+SUIeLMsjxclwKJfR29FspSjXzIYeK9mMR4W8Ps8brSwV892wX89+whCVBHv7/X4Y9n+zaI0DhNlybhuPBNwV18hs9DnDEkwwYtspmkBgAukxTTCDw/JNDgoCnMMQmFAsJY5xLbH8kju/zfeSu9v//JogvgPuXwQH/hX43a9f70cxxtXBYQlMgKTIfm1bN/ubS0dW8iUusyBrgvJNi/kjUPKIRBgOrQEFYQ81GH4WjDLPKqfRbY40+YFUGb6tdziCT1mKw9LhbcFqbQ4qz7Z9yict2upFrqI20wiQ5cG2TaViqed+hE30Z916ws26/PQ20A56YVfibIICTtUpc7SeT5Ycy3ovcneFrb2ViMzVUkFoUARuSmRlbxM5QVTKQf1Pyj9QDEHGzFk2tZ40DzK40+aTUQamM4zKRiqFFwcn+xcH/9gEweCLYx9eIVxHj+FBMqFM08SWHhJdb5Dk9eGJOxWapiHLIdb26bRH2WyfanVdRgCPRKahhJNlR9h+36XV1QzNsnx4fq5BSW4miFLSqdOwrGfpbcajgafP5WNHtK29N9TZhITlU6LErrP9JBWLPTq3VLri33+FeD0R/aX51VF3WHvETmDURG22PFqk0QCXBGobYu6IO8G2fhJqzW7IPcF7WdfqVpPmpvJh6QjLl/fve/7hCUyAZI4DCQQfpnlul4mopDgh+jpe5hsHAhNJuTQHmleS5k7BuH+ENvcpS9EMiI06kcqbZrVWsx/QccM3pWGsDyUgdjRWPEbImGc5aNroBSHnxOYsPT5bHPtpMfYaXkCFzhccyt7FfWqG3B1YaocDn0IdTJ973wyNgi0TaQMfvBC4v/IIxYVC5MMYFjkeOCC7YuxxEB24fmQ9jwGI74hXSt4gujk2BQhoJP5FdCxOslJO/PxL7ys879674kG1f9B46O6PWIeADmSRddXt2rO58YSlw4ELuCGzlVroZUJczgFEDpzmoCaVGtAgnC8IuxAjsCmX24pbQsrxNUcnWS68tFymG29YC5cNfonD/iVnz0/TTTeuakIurvVrJUWElXVduFCgylRUEtoNvPf28gfvebC6bU0SmEzyNoFF/Wh5Ba6utAMnxCS0Xi5MUizeIyghRbbN8f6PFoT3hyljIoA9ydmxTw8gTr/4zi8fht8RY3/CstMvjg/N/oKVyHzbYfgdhVs/fjU9Pe4d++QA4h0fee1P7fJW18Y+OSA4jIEJcXDyfjwc9oYBnWtr9QteSJujzIOXUlxwh2G8SklLOb7iBcXNkALVnRgvEFixPFNuTNyFGNOkQgxHWqht8ELWpOkFSiyBF7ojo5ksXpAfo8cPjNfwQgZF5sO2QOGDzE05aT1z7NfF2FMgGTGNLMmQrX6RtQDJWpVb2HYYyZAEZ0BAmJVpXqBUOUqZg3FUiHpEBL3IRRJqGqXEwasxoACDkBtFWiVXZ0DwQrZlxpUBpZoHBlX9Us61MHoDoRZS5LSRQ1Rk3iAu7exLHHy+yTUYV78gbyIjte1A1oRUeccKMx9Q9uBFnM1IZ3rqhSv20EuoF7Iq+VxPvVqdFOXzHU2utQKqzLTo9OlZ9SoWutRqpZUZG14oO6BBIF6uM6B2O8ouwKgtn+urFxoJzs02qdF0qVpNv3tsw68h3nt7uWwuXRQwyWRCvUwMh75ybO15Q/UizpjgtVXfnvXpDyaLNUBkrTbHs1vEJmqSKRGglIOXLB+GbXgd1sAEsCsff+DXq16g7gvwMal5vnolEpa6d0jZv8+BCF7oMIx9jhekyPgLtQ9eUPjkHEu90Mwv65B6IdAAjwX3FbxKySilCI7KkHSAhBeCGpSb8HItSwUukCjjhew+vFPwUvLnIFDL7fhX/SSP8Q1g5SV3/jAO8XrfpwBur1yzs3CcWgP9Im7wh5eirycosCz1AqEIQQleQSFJwVKbCN4DqaR2kmUoKTJ4JB2fAqi+FjMSm1BwoSudIzG4IZzX7rF4oWEgghLPV6Umag11h2O8oCKay+hXLAeJcYDwEy/62L8IR6TZioIAsbUnlgfDzh48FLGLhwcKXuCl9HpJ5X2CFwKPZjulXueXpimd7qlXoaDLGFAD4bW1lVEusHjl8j0VyKScgXpNl7tULjXUC3wUSJoffnRBvVrtVLhMWN53u0k6slhVrz1AmHUSBQycXJ3kdt0IVDZwbIUcGK/ljXo4rZRLq8ADL8Ad+S5KQniBK2JKi9EtWK5bWB8CkXqzq14mZLvgpfIHLz9yqMmWip2T5gxHYPS72ehGF2V85kQWJSpzItQAkFrBHUlxR+PVrh9yQhBYrPJyMkktDxbJ8anWUBFdgfMdnxbSWq5MiuMSKFt6YkM28GGWmTyL+ppwVRCQXOgGoT9KjP2DxoD+O7G1SegtUs7olJfwPhAQiF09aNXIXsiTBrImIZnV0zK7dX2iKu8R6ViMMSMlXYyZaj9axkyKRJMenGuRVUrqTAtpNrXMJ71zApEqI3Oyqi++MGhTpBdwdB96yTuKt37iXfEw23vgWNh2ar9v5p5ASLBFQ85r9tqxLF9Z2W9saqO1YrETBilOcqD8S6anGuH8mbReXjrl0YULU/qzbJ/ItxTXRH3P8XUwo7INPq2tFiid0ecePKyW+XvovwO5cyGnFRTgIZ4/r6edPLlO1VqevvbIgl7xmDXatcWVep5USlHgZydsSid2FsGOmqiF37PH72HieyJdik0c5oyJYPKeOqBYvfvOLx2m3xNj72HfVQhr0bad+s/xIdkfiI/F4cd//PPv/i+7/SMPwk3/eghMSDIneECFIsb3ic5zpuNELkHnWHa5mLTUe8lQbPaCULmDv8h4iCQZWawtdpLFA6hktfwAcuSo51vCssL3SGWhBBRKkC0KZczgvBTdQJWJ1LbaAW2ykgJiDnyHEy602Q2eNTf2E2PsBSpupOyyxI3vXIuokoqa8eF4tyJFDuoyAZdRVP9qdnqldk/zUFitAyfZgN1i0bkzlCMXE9qeUczVQGyS7IhkTUwfKhmcPeakSIYH81XYZXYhu+u6xhgxvmEEFtkJP5QBSzbFxMy0zo7AhC3NHRqQ1SiXO7S0NK3+P7K4Rbatz4tMpqd5JowzZyohZ6XvJSnB801Pd2hhoUann5hR/5eLXer09DUANvrttqucaImlyyurOuMC+XE269GJY1vq/1otcw9ilLENv/b4oV5v8Hup1HbZrzi9osEeuCRSstlqtFUZ5snC7Ijc6vQpl3EnLmFoUBaul8CEJDip9QPVo2QhZaubPyCdfwHYxw/8gNbYy0QpLZmTqO47CcNawrKozwUglGZKRskFgYS4uU65URkHPJaqCnj0fNVuQEJ5RKa90deUAeIUoWxZ2dWEXaErlWO/k32Bh7/5joCl/XQiZ1NzOR3kj3QtZRFsthf3I02cqqzkjOZLeCN28gg+QFRd4fqrY4eW+MGWR5ZcQ4aaexL2yAHZtcXLaA/1Oko8cxBQ4HKwg78tL5QdBzgf1qWdzvYsb/2hu08Ub/34E4fqgB1IHA4ukO/3r033XZYGTwpKBGavHfTGIe5VBcKsdDDudlMqKCHun1Ms6eCkXs9QpdKiXE7/3+8nVZBDHMTA8yTDfX6aLZfy4nmS7dNwkKBaXV/s3dQglBUXCj3qdaOA4MTx9bFt3g289/by79/zYPU/9PqD55kuro7h9GpySczABNc26yK3odCfyba2dUQ2AxOUcfqDYbhc8Evw2QdeuniRJR8+qD3sJqzJtOEDiDMvvvPx6+kA7keMcpM3vpQ4sCfVqK7Csp0zYzPF2FU0vvC/BJM0LwfxVbz1E2+4Bvvu82OfHFD87N+87uf3Ysvfe3v5Vgy1sQl7hOstMCHJnNz8qQcy5+66MwARVXoKw0xNFJUQOczYdpjpAEG21pfSjSbHLvLTKtQzFj8Ne8MgnO9o1laloTJnUnB1OcnEVqwXWQ8pB8HxtRk60EYv4ELPp3kmVHaH6HQchFkbNC3MJ6wbx35ljF0FDnGH0yMo1ykHX2TiwIY2IhdlyMapkgBysfogJLoGzUHkFutroitJtgT1wC3uXoxMiDTpq/J3ulyeQdotbOaUpmC5HZFf0bE4k5CBo6XOSaPmw+TYWK2zDxEfk0vhu1Al2WmediutTNrMRoC+r6+pC3O6pDJkB1eUecSsbW6uRrW6zrbMzdZoZaWsSjRqmZ3IaKzft2no2zQzowm5cHxdWNDLXd8oquUNeX0oP0GlAyCDks/3qVbTGYW19TzM236RiPaEX/RbL6wU73mw+i+g5l4qIyIw50E5ptPtUz4bZUg22awN2RAYvG029D46OltSKh5iWXLfi7ocX0+lHBNhzqozCJSiZpMDBJRnuMRGPmfbZ/lmgfvMQkaUNoG6Gcm1HHQQ6VLcUpQCvcPPt31ljb/MnBaUe9a4xg/6wLTRCBD0EkmgQXLcw82Jr0eYL9zGBNF8yg6XA5zrBDQz9jNj7Ba+9II7oOhVwSiw6QVUTPIBxVjwtW09AN6I3GbCso5wSaairsGq6V/V01wQTomGAwSDUdxcUfqBS2w/UvxIcBJsdckqJEksixUPRjKz6FYM7oucDbAnvkgzycZDL/lU4dZPfPPYhBjXHPXP3fUXlj25Nh9D4yde9LHT7/z711Aq1SOPGwFK+YWY94EAQcopGxsF5fYqgMy4VtNKEdjTC28Fvimlog5oEODMz0dyX7jOiqoHdviNZi60swfn5JHHdN/4W25eUaqeUoGdaNN99QJOPTFDaciPU/p7fW/vg1BW8NxgWVGwh6ADdvaXClYGg+G2wIQ4KBHAdfZoOqK0mRln9xB1F75ShMEJ7hvIcpzgm8pSJ7KTJ9U7B7bx+gOYnvWMPYl7gPTFGYATwk82WN4N/CSMHjmu+r6e1vECElXVIozV/EB1P1bf86JsSLXvE+KZedYgtwYRGRc8lVPNoervQ9xJGfefx7/5zuCmTz0QE1D2ALjPI1kmJGUc/bVeQHlLe5qobInUXS3FgdVAhFsf6ABDwEGnkg7D60TGXMePOgrDH0Bk792B4qkEctVA3wXhtxQSFDSipxEV4EhEje9h2Ul9Olj+kCgRkPW9FVyxo6tJ+GXnhWOfxdgVWLb7+nhPXxqSFXHdwdi86Uxv2/9+YIfJKGRDSqU2LSzowAMBCXrekApAcqo3DikCZ4qarTQ5vPxGIxWauwGFfIsefVwHJMeOVFW/HuCJJyo0P1+jAff5WVsrUL6gpzmJIeULvTBo8jwEUAFUO8F/ecNf7Nn1/L23l09j6InMGF2I4WOSTl28T47wVUB2JZYRj3YiNjHiifK2995eft/YTNcR4q7EMa4aQITdaVndamrnVMR+RcbJ7sRkqD/0khfFI2d3ATLypGNxUF9B4F21hn8xrj04i3HNaQNYz/UemJCZOSm41lJvSEekQgJ3VpEOQ2acz9m0yqnu061hyBWAxLeh0u/czRhW9PK0amk+CTCf1mUc4ZwgKpK7FTLqyNhf4DSeGTEhy48MywVeN6ztJasCR/OEZYdlnl4QiHKUtl76wmDq3k/H2ZNdBEwRUy66i5LKYBGb7zUHPp3/TNK++TtdfaBbrCDIJchqi54chexU1NAPmTKhgGR1XdGSzEc6EVnYd/0oOwJljmuHjf+g2pEsTdDSWRRL0oGZRJRHhSpoyo0kZxjPkUP+RFhW8pNkaItiXHtYVuJQkZGLt37iuWMfXj2AFPs8WRoyIMIdSbGKpsUOsmbGQ5Q5Z8/p4ng6PQind9qO6kasvjNTV6fPeZYco5mfAGUbmLhJs79EYhhKlWFRj/U3m3rdvX6CyrY+r1FuSiYCqtb0NMcZ0iJzVX7yg6/f+L+/6y/3vGJvZFFeRkQfI7aSN8s1JmqtHpVyl2cWeD2XcCYhDE6O3ffA0Qe/6QVBimst/SCgJ9r64g2uCQipMyHnxFLEV+LrOMo9A+5W6fk+3ch+FCjVrHWjgANBTolT7uCc1AYR5wT9c6QclHUpWl4QqHJNwBl4yJOFUlBOWDrI4e8hOy9k2SfaPk1N+MExrg3O3XXnAMfUUqUcHHd9kI5kbZLO1yqIALFVTkHHuL3jSrfVjzoK4y8fS6s71BK9VCKc1+LgIUjbUYSAyBrTpiKZMfF7a7OvCa/SERnrkvdgfuN/KSmpYPvSfU9iWfHuAfvasuJE7+XiJ170sVvfc//LwwHsecnQk4RIBycIGiZhZaVEM9O6LIRgQrC4uKW4JcTOrrY9JCepz3MEPxsbWvrqpuTk1H8azYwKNIi7H4OPssHLLea7tLRSVO+npzrKU2VxQQdDKysFarc198Xr29MTNnXP8N7by/8iV697HqSHJBBstXuUZL4IrO3NwAT9coRLItb1zXbvab9z1/zD++m37RfsXAA7BPjqHXcEz/jMZ+JodBfgR3YzhwLW3cXBpc4Py7LPxNmT3QHv6xjXMX7kf7xx8Dtv/qOLnpN7AZYdh/jRBza+FZwRInq18fG9Cdv+4gfuXnhrPIYvD9sONFxbRc6Lh9TAyHpv9f2wDIMsxww/dcKttejAGC1S4axybSibtKjED6N4pq71dXM/4Exbq3xISYIDqqSifj3ImnRYmQEZM7Zljcs6ICNJpgQP4VitPJlDJlplJiZIuwfXXeNgofrSFwZi2oeyHcptm+KcE1BYyvPXh0PbtRLhQJIOwsQDThFko6c5kf2CuGol7ZDoasEBkJU8qmwTZkBcCroDstiBVsmSm+xAi47DSLmJOy2+w861ASTMINiKzLgbkHVz7rIugo2H7vr9wq33vWVsQoyrhsZDd70vcto7HAiC4fJu/JBeT1+AMyMkWDQCTLMqBtmJVEqTNkFGBWFVFDrT0226cEE37EW3YSnxnDs3TceObSryrCwPDQVJKU366n3S0efocGAryTCQy/ep1XSUgoc4YSqy4o3NrJYV8yWh3XNpakovH/16yqX2gXgA+q07Zz5KRB8dm0DlsU9i7AwrMDwDVu++8/RKJzhJBh+EuDwP3xGXL97oXtzhmxGqQLhXyC0FXANR4dT7kXVE0tbt8ze4JoMbljTzA6UA3AQp+SP4mBL7ek/7pUjgAvlwl+dDAALHWfkFRdeiLS4noFkgVDx1z6fbP/uvcZhyDfG1F94RhLJzdWx1Y1/i41zlgPdY1ibreVsRR8SmUB6sPsvYFEhE2fYp9AJGyW8YSZCx8ECcZcEVkW6SKN3Ab0eaaFW9aJqvnWUDHjxwmA029QUZnYxprRva4GPA2999+eXtwq33xuPrGqLx0EsvXl87gNiNMfOe+1/+kMk7ESDwuJhz7PLyVCgTRiM+aQKIAEQaCKI0A0WOCSnBtFopKhS6oZS4zt4oQLeXULySjaou6+Qy/bCEdGG1SMnEkIocuCBQ8Qb6nC+XmvT4qTkVrPzyqz8Un2/XAbYFJ6Rb3asPYJiW5GAEviMWS4aJ7yPyNIwsCeYTm/pGPwgDG9jV23y9RzCTdVT/G/2BpT1LiDMlCCLCDIixPdCTQ6Ys61vp+OG9B5kZrLs/lGyPpYzYSN/PlCQZjIRyyvrDk5984Aev94N9LbB0150BMmspw7Os6QWhlFi1OuD3CDpvfmUrimQTFEayyhQtn1Tma6R8SCD95UAC3KQZV5msEffQkWnqf4mA8RjmWBEhFvLjOpNohQwr490Loo7IzYEOiqRbMsbY/77wpPZWHKBcGxzGwIR2cbyYvJOd0Os5IUl2FOvrxcjk0LdUB2NiLkql0lTfJUWy7VO9oQMOdCgu5NrUZMLt+nqOfM6czM81VKZkMNDnGroaS4fifj+h+vJAskyctUmyrLjVdtV3Bp5Nubx3+6+99oOfG9vYGIcK1wXDrNoL3jT2YYxvGMt333lo2h6YsN4y23+y8lQtc41x9TG+rw/HK8aVotV0Hox33uHHWCG3y/LKlI2uwWxRn7RU9l14IFoGHBmfIdte70cZiwFnMtAwMMNpepRcoOBIJyK1ziqXYPAAm40c31h+yvJgNl2TjAj4LVL+KaqOxEHYXLbtBeTw8sFjSdsWZbib8Wef/4Lgm/4tLu9cTXS8QFHRceykdAPpOPhIWW4giaaNUo3p+RbVPpej4s119b+FY+OYrq/G4UFZJ3RwTVBQM8ykYMLGXYNptavrjmLWpjod81MgGviJRT0yMsr1jddRSkRNAVO25qes6zIPJW33Cm4fMTn2KqP+0N2H8i5ukf+jYx/uIZA1QfmGuHwCKbBYymcyXugui8Z/wkVBRnx5uaSyG6Q4IcOw/NPuZOiJczOh6gaZ8Qpb2a+u5enYsS3a2tTrg1qn1tTloMX5ppIWz87qMk+z6aquxbIdxUKLNje1suc//On3BO/7vv8Zn2+7gF/4h+/4zXbbVUTezWqGpg0eULHQpqUlrYtdXKz+yc+89B//16u1RWNlHeCRF94RSHBAXFpBV+IU11MQPCT55gOPEUyXkgxuRFLWQTDTMAIaEG6LTJCFFG2TibPgjsDe3uS5ZBORVT7KAVJSMkxmQ/tg2a72MFDBC/G6sG7x20CJp+Taazfd/8Dc2A+O8aQBm3opr4HkLMcCUm7EKb4v+x2Eae6hhBYJCaKFl+u6tSIQrerki+J7+EaJJmtHZZ1CQgUaAY8XFXAwqSVIRH4oofTYjq5ZAQcgFjYoE/XaCTp+6HOiPkkawdGbZ694QBRv/UR8wbwKqD/0kvEL0yHBbo6RX/iHVz9jMEx8BUGHANyQbDZKekIebHqdQEoMUiwp/kiaGg0dPCAgkdsFOClPnJ2h48e0D8kTZ6fp5Il1fl+hhO2HZFbwWzY5GJmaaqlOxx3uxVMsdKje0OWfetNVPX7K3PnYUjdDljJbAbnJIbW6+gaC4Gl+tvlr73rVh35m7EfH+IZxz59/tzrSjWaaZqZa1Gjqh8Ebb1hTnCRSQe2QWm2H5uf0WGl30oozRKqFQQeB5OKvvOavLlzptlxXxgHdQXDld50YIb74gp2dYA86rNeWv6FSVf1zL/7M2Icxnuw+/OexD2NcEX7hlR/+6mHdc8OB/faxD2NcMX7iL7/7hT+QjaaMAAAgAElEQVT0gR8MfvSPvu+qXN/b7eTy2z/0uuA//d1r/9vYxMvAxMwJSI5LihCr/y+nbNUvTSS8yJRImaXPalApy+DpWCIeGLWV+akZUfdWzw+zHHjg7RgeQPqhVk8TuTEpB1pIzbYTa/OcHYFsGA+/Zc7wtz0KSzxQmrYVkZYJl0EQ9uA5+cm4786V4it33tHrDQMXY0Ck4Ci/hK697Cx8pqWzHNBSOXxcUR5UDSaP+zT3zE5IcCUmwGIwBUazr9DdFU6yxudqnklHEI6wGIdic+zaFDQ5cwKp8EYvlB2PridI2rrM9A1kTSJYJ2NztivHYc6aUBD8ZvG2+3587PNriJ1IsY2GJp6a3YkFFy5M8eYSzVR01sV1PKXYIdW0rk9plINYiYP5bM6mozkgnq7LZZ0ByWS6qtRDarkFuvGGdbIsfY7WDCUPbg2bmxkqlvTzgeclaIszJ9lMn5ptl4p5TZ6F+VuzpbMov/2m/2/S1SDGk8DPffi1AdRSwNHFGi1f0O/nZhuUzfRCwjSybEJmBjkZhntzs7pMv7JSpPl5/R7zrK0XqTKjS33VapbS6eGz//OrPvTly92qicEJ8PkX3BGUuCQCB1e0vd/oRhyUJvtMLGa0fXzHF85J5EOCdH7DE16JpSTA4hiOe4TwQyx2fu0ZfJc0UwUg1EAAJBl3BDxR92I9n5SgKmkb2RH1HmUcTJdgxWbHWtnG5/1rbM72ZHH2rjt/fLMXvA9uweACSTCpKiK8nxueLvFIgIpj0mA+Eo4FjkvBsWjxzhoFRodiVarrGbKf3lBxSAArrUs+IY8wbVMgAWx7qGTBCrC+h5R4GM0XfgecE6xLypVDowd6kuuHGKv/x/xV2VfF2+6Lx9cVoP65uyZfkA4J9mJcvOufXvXUTKb3dZ9dt5vNHBWLzbH5JgF+JRJIEMuJSZFSU5TJ9FXTQOLgZG5Wp/fXN3BTqofW9kj7r63pmx1cZlFWajLPBA0B0cUY6HZdqtezocy4XOjQcMjNZo9tqqaBjbZ+Es2m+2FDwpnpNr37Oz8Yn29XgJ/64Os71Xo6Dd+ZdltfR3teUiUESFlH6QdIuW8fma/T+WXt12InAsUZkmOEZpAuy8f7gyRNodM1c/xq9RTNzeox985XfPiyjtWOwcmZF98RyM0HNxfc2F07IrNKEKC7BNuqA7FAgpr1fhDayW/2AxVgyD0F9wnHIEBWe35ouqUItgZXZSpl0zqTZ3Fjaw2i4MfmbVA7xI84J3h4xnLa/HCOe5703cGmYtotn44DlCcDjAlivhAyWHKf9ynkpKogkwwDNQSqspNxbGyY6PlElRfVdKAgpCAEBwMjc4LYgQNbZUE/DMI4w+oZ7KSiE3UvxhzG94JBlH0RLXzoo4JsjLEcRaZ988yAXHuMJH6lKN72yXh8PQnUP/fiyRejQ4S9GhOj2ROYs4nx2sU+X1qeoiOLW+H/0o8HgQGenDMZfYF1HI/Saf09dBy2rWEYuEBiLLeZrWqGbjy5TmfPah8hEF0bnAFJ2IHiNMDPhNgQDpb2pLoct1WW5sJKQf1/043rtLGuA6V0xlPPGb/07bH/yZPBT33wu9RRQc8lkFtxLICVNfRG0tm0TttV+zeXZbm3l6TVNX0MbMtXxwvBKKlMSiI8ljjGMOpLsdEfliEeOQh4f/LF/3TJY7Uj58QOu5ccXjz8wsPLnbjakMDkamH9/tL++5FXMTCh6+Rme7VwXewry75h7LMYVw0/dpW4EtcD/rfff+Oe7iuUkX7xH1990Rr6jpkT4F+f/wI1UdnVpyxlgEacXV/I6LgGElKUXQqcWUd6vylKTj8IVTwwSGsYfBE8eUsDv2xSZzhEZGFRVMZBlgPbuMjrQ1mgz2ETSjxZQ3acsa1QCo2SDlRFklWB4+wmZ3eQ+YFSaJrdQ2+IOSgXxVfuuCMAV0R4Pw7LzIVn5BkOweAiqdIeH4cBZ7uAfNJS6UHJV0w/d1NxPRTQwE8XrvX/GBxyVGzNEVFyX+I6Y9jrIIi0ymogJiOFjmtRwMdcWddPu8rsTSFhkSWpH5i/dYZk/XDlYrvhihFnUC6O6yWI2+txMJo92djUT8Az042xeQWmQRvkxqL66XZSKnVfZL4KJL6i0ANXBA6xwkFZW8vTyZNaySPdkcXqfmm5FHZLLhW75KYG5Dr6afvcclmVEfTys5TJetTtcClnpkUXuGFgpdKmlNujM2f1+fs7b/6j+Hy7CEB4hRFen913HdtXJnng9QjEpXd1taCOCyTEwNNvuUCnzuj9nMv2aW6uRp1OOvze0gX90IkSDvhDouBCdqXZ0CU5cIpEdr65VVj4le/465VJW3vR4ASN84i5GrjxC2ej7FhhygVkSHBO5EYFDkjVyBbKfPgcBFjptQN6gQQVQ9UexVJkSuJ+PWmOVALmNMg9rGfcCC0uJ9hWNG+dU/rY3qwTyZXhxxKqVB3QC6LSFPDsmIMyEehUTSOBX8GxVdA34P/RlkB662SSmnciQGAixxlBS5n9boBb7m4NLfLVGRI40miJ5cKuwZiWA1fkCHijF/XZgXVJJgparIAtjUkPjpAQm9CMu8A45qGUGMt/y7Xtxl687f54fE1A/XMv2vkCdLhQL962t+nC0eDEH4pDd5K8vj6HcD7Bs0Ts7U3OSb+fDAMOzIMSj3iggM8ipRoJRASrayUq5LmXjg9xBSzsdQCCm6RwYYB6LU0d9lJxDCt7dFSu19OUYg5Eu+uEXZbhMIuyhMXbVqtn6L++6U/i820CpJSD49j39DFHuwG4/a6s6mAVDr/COUGpLZP2VImNlCx8oIjQpFoROCrgkEGVz/epkNfj4fz5KbUOKRWhB5NIxsFHqjMZ2+vb9Kuv/euJx2rHsg7pDMNrxj48pIBC6Xr5rZeDpbvu/I4v3XFty14bny4cqk7GF8N1dBO+bFxP+2SvAxPG28Y+OaR4x0deE59vBn7yg68/9tY//t59uU/e88lvmbhdF82cEDur5qSJXj9qqjeX1sHO2bZPJcdWEZagzZnzYaBLNsRiCVXm4XpNaxiEpZuSo5cvLqNeEITsYETyeBoWZ1k4kE6zHBQlBDzB5/nJ2udyDrEcGU/6koHBtnj8W5NsBicdmJEJ2uKn/dviJoH0yDffseHY1nTLC5QcmziKTfK+XExb6rhLc0aUyxyeho+QYStz9qI1iAQ4lspsBeFykClTxFhiKQ+Oa12e2IwN8kmXfERaDBJtmzMsWI90goRqx2z0Y1HYlVg6EIes6EFAIgmzXlf0gozljO2IawEreUPx1k9c1+3/6w+95CQFg9NjEw4xird9al9cV5A98TxHEVgnQUo3aOxHiogayYyRmkcqn1gevLZWojITJ7e2cmRbrJqsaKWOmHMRu8aSMl3TDrQdVoagBHTDDWvqPaTNKAVMs5tsdStDAy75ZDMeG7/pksL8XD18Eu91E5TNDqjR0Gn5Ts+huYrerl95zV9d99fzt/7x936h2Uk9Z362EWbIUCJDlgr4/9l7EyA5zuvO88u6q7q7uvoA0DgIHiItUrZIEDzQBI8mtGNLo7Es0fJ9rCiPvDEbtkOyBzG0ZI912JJNB2as3bEjdsOaWXp8W+OgZMv2WLYFNUlBAEjxkDmmDookQBB3X9XVdVflxv/L72W+ysrsruquvt+P0cHuqqy8qlD58r3/+z+IVnGe9+6Z1n8jI3bmnNNKnknWVCYDwbHJSs2n3DJcMl7X2SpkrTS2UmNjzsDI187uULt25NX0jPM5gng2ZcTTyJwQFy/lVKUS0+/nr77t71veqyWDk1fuOVScr9tpBBYUTOCiMktTiS3n76K5PvBBb2k2QZgmG5MGpch+x/WCBxK4TlGXDcoEeB3tJrZHJaRq0wl4qByERcjLBFb2uJZFqSW54VUHcL3FBXSH6SRqNL1yENiZityy96lT32g7GduAl+9xMkhzVQQfETdlB7uaKVMiQ6s3/i4GSKYjZjI1Wc+j5Efnmbq+0hHqqHIClf0HZ3T3jF323gMLeiDqwrEsp/RCeT58QKgjB1oUyr9Q/znpSrAjJGRyPizeNOM669T52dXRmizCNwYPfvWW8Ke3LnPP3gNTsJu30zEPHtwYgYkyGQVoOtLpyqI+J0EgcKmai1t2oKxSqYq7FLQkKPUQ6NTYscPRFVy+knW7P/r6nDIN2eUr05Wj9AXM1vb2yYRxGR2o6L/BjTdc0gFPv/E5uTrVr0ZHHP0LfFXAGaOFSKbqqlpxbkZQWtjONveUQYKjLs4llXLQdfPdN7+hf//Gt3br8tqQGeqY6au611uUbRKJhh68COBdg1KM0oFlTI3umFdF096NoGXWBDxvuv6yPvdo/1a6VNRQAwPOe4fWcbxW6aGQA7o8t8cJjD5+9PDxj9G+LxmcKOYISktqK3p20cc1gT6WWhNi1olgg+QH0CwioBlJUGuxZ/JmGx3DbJX0IV4rKgIPW3kGcGg/JrElLmyYz0OZFAhkF8wG++KWE3QYjcGOZMQ1d4sYx3MSy0KzQgHOTLWpjduQMXjr6e2lQ0GWjEzycC5x4jNxL5h09aNRR38yGOdVQedJrSVqeO8zXkefDcw70oOBzd+WcjJi19ybd1p5szHXh0RPJ2aBhBbOkkYE76MRxyKgsSgrYlMQYrbYH3dSN8p4nmDdNIdnvq4j3cg9fXbzzcl1eZ830kVrLZh79p5tmWrfaO8zaU/oDhgXirgRoVarCZ0VIcGq1psYbUelGm9pMy4UMu7rcIGZmnaCnbFds+qNN4bd5XbuzLttxghKCvMJ7VsC0DZMZgM7Rwv6Dv2CaRfeM5Z3L6blUlzfYUNo6+wYtp80+x/V6fXr9k/pvyH0nc07F8nR4QWVStbRwnzp0z/8l92NGt/kfOyL/8auGcO0c+dzaiBTUdWGyZwka26wgECuVI5pfxMwZMYH6PM3Mq8KhbSrQUFwmjfjDDBmoFKOaY2KMsEkEVFNbaCXyxkPm0rc1aOUyknX5h5vJD5vpEH5xNu/YHnrEAKB8vyFO7dHq/GFBw5dPbeOmptLL/W3PbZWrFdgoszFOv/8/YfbnthioIyzXQOTSCT6820PCmtOoxHZ9Qt/tjE1F73mI3/zA58h4etm4+jjP+hGRh1lTsCpg3fZpDFAzEM3p5QRIY1INua5siLLUap5GQ+UBdjwYbelFJoT6EBmWacNxVVYL27emTeXOy25z9zBU1cp7sKrTc+gDVkQksJAJ0PrTEfNHb3ZAZjIVc1KoIXRuhW3GqDLErXrvnIq0XZStgAQvVICpFDzhjvq8xBx9Dn6PUp4FvXKZEQou4VMGQ33Q/YLlTUq5eA1sxVPq4SMDH3kEIyTXkg7xiYj7uA/3WXTojux2VDAKOp3zu9XKkoNG7nItOMQaxstkS73ULonbjmmbBnKuDSUtTOm7HdmN8SbuFWzKNs1KCE26vvKO3f8gwAVc4KNRj0TRX/5BwP8qGMGd78EUvn79191yyy8ewe2+OVyzNWZwPSNwJC5wWxJzRstCTqGIkzLiFIEtTLDHn/IlIqKpaS+S8+arEok0tRGYmD/3lmVn0+qHaNOiem1syNqKFf6x9961+e/t+2kbAF+6S/fa5P2B067yBwpUzK7NNWvbrr+sv77zLkRlTJZr7GxOXV1asDNZmAo46AZMYYS4NWr/e77AH1KKlU3n5G0dvilDByGR9I4gpQ2X7PVzKzz957d066BH/RO9LmJxxr6/SPdCkqFRw8f1092HJycufeQfdloAvSumE9sUs/ZgZ+Fs55MxJuDU657y2ktStP7GwEHlVlSJnCgv3ERIwEsyjloTSXBZZz9U8d1B8FDksQwtilHuC3IlmuJj5fvNBfMKbQ+s+nJTaN5UWb8f0R5bc66EmC2nU1Yb93/lVMvtp2cTchzd95lD5oAjk5fzHjDKG1D39S/1ygIjVlah6KMd8kI841B+c5972KWDhqnqlRHbj3vVC5SNHnafFYGr22o/htK7nM22oLJCAf6E5RxTIXGXqg7lvbK6E8oOkVwC32SKflYCw2v5RiRKEpNJsrVTrHv91LPGwHLsr6cvf3Eka3w+co/d/jztm3/QNsT2wjLivxu9vav/MJGPGIenKDUQu2hXEeijDiS2oWxXL/5nfQlVP65eGlQ7R6bUUHggkW6EIhhoWPYb/wvoHuhoAeaEpQNqNyAicTX7HEEltBLoOWYLmr9fRXtsQFePzeiZ7lcbwIelIqo5bhQSugyxWzeCHL7Kmp6zrHH/2/v/6Mtc0PwS//jveVyJZYc25lXM+b4UEqpGI3QrtGCnodEpRu0hZO4+fXzOR2YpIyb6+4xZ+K0Muc5Fvf0eQhSSCME116UY7IsaIXAVenPh7MM+dKgjEcBL9ZBn6O68VohLx18VlLJ6l/8ypEv/mjHZR0ZlqfUpXLzn5FBantiE/HKPYfmnrtz4x1D8WxPzVmXxMpaJoTdOD+23Xxw7tlxe/75e39uTU9GD8G+4xhsu/kDG+38rvXPRg1MAN2dbmd++a/ebYcNRdws/Pyf/fALH/qL99rNpkpunbfS+hHVTeYEfM04xjaNKFKxFl3eaUPpf2QtSFCJIW8LbNowTNdI5IquHf4vZb7upRKRuUDZh0y+eOmGbsJpWewSlSFolg4Zx+nOHbMgHs8mvC2inDFq7sSvVpq6NFVhLrRU/kHQjom7dBibaTbPS+N3l6sN5wNMpZRSw9YlslHjlItzbHSsuhMHy5FIWTHXXpR+kDQh4XPCOMYq08qNzwNlumDURu8JXg+hMc3bw8upVKgHNQ7Z6po3G7dKTBimE40um3TUK/ksNLT7q7PSiHZ3VTRzB26yZgqhFtia+qNdMsJZWsd7B9rO0UbDikQ/nj3wlY9t+B01QUmz2fjdtie2KdCaDBz4yu9t5KMPujAjRU93xmBqKuuam8FIjbcgwxV2eDjf8lplum8goqyYjplstqSqxlgNWZhLlwbd7Ai+DGhwHLIwaAeGOFMZA7DBrLNcPp/UpSBaz/R0n9ua2qhbOkswNER34xGVn3Ou1ZVaXLexls2QwP501TUGQ+fP3FxKTc85pYf/+vAfb5rv8w/9xQ89XarE7kQXTjTivF8L5YT+bk2Y8gzOMU1uRjtwqRRT8wuOmHWwv+yeE9CfqapkymQvZtNqxLRzFwoJ/T5SezeEyXGTlZqddVq9h8z0ad4ijIwYRLRUhuMZOKUzN877SGZ/7usKfdrt9yMP/oPVVXCizLRidGhSE0TN2JWTHAAdGZSOwZA3Mu9EmQTXGvK/wMWfZAN08SdPDUQbI+aCWWvYelleniEvE7weF1R3llvMct1JMWSu2PC6Sy3ltSDPVm2VZDkj6GEKpkRBwwlp2blas6W7BCWgJBPOoLwRjag/2fnEqZ9sO1kbAHTg4FyQ2WqEnQeus3HPBUUOlvM8BS7QA9HrktqTpukOgmwqr7JiOeUv1wU2xwY14n94CX3kMMqgbD5HOlC1lLphPO+uyB38hzZjtAxT+y8aCIywyepnk4axf/N1b7gf6+qxCnUdtCDAsW5Jqeadm+lGw7o6ePDkonMo1ov8c/ecse3m/o24b+vJ4MHNkWn+6N9/v42OHLQWK9bWS1RrcZUI8URRLC1vsX/XKPkghU+D3hQbGIhunwsXc+qafU5nDU0w5pBz7dx8n+rrc/YLU4zRVZJK0+j+frV3j1PWmbqacQbXZTyPJHKkPX8+p7tIyC79Enw1qlRKaKhdO2fdbiSM+I/FGyoeaz70se/7m8+1HewG4BP/9E771TPDujVXmW4k27xl0IoUy56+Bj4mVAbDWID5haR7I4+3amynsxyCSpTdKGCA5of8ZZy286pbxkP55cpVx08QZaD5QgLny3nf4w33xhMdVM7gRmcbmDg9Ne2UdeCnAu2R0p+vqNp/zVU9YFJpbcqMKlcS2M/f7zo4eenuu5tIbJC2A7oFiCPjJgjIs3ZhXNAoo4JsR5pd1HFRosxJyidsjbEPejru6B5oexFlueP5E2YEP2lC+tidvm00rXTXHo96E3ORESgZUzhl/mHRzB/caGdinoYC25hnr8PzlI2JmTkz9Gbj4dueWf9syqX7D525XLb1BUOfk5oXSESUp6/RMgw2GTrKdD84B/iV3rPpauuXFoIOihW4R40yrdpFEyQOpSJqygQqMZMtS7KghiI/PfUafiaWUtfBmA2BCY0liDr9x24mJR3xApKq0ZIoE1kiA0a7ioiMlNSkUUG27ac34NDBDrGs2Ceyt3/lo+u5D/nn7v24bdd/re0JQWNFEpvGaC8oexIGN29rNiIqEm26mpOZmX4340FmXmg1VvqiBctzR9+Ai9LY2IzOyCg9IyevanXndRfO53TwgYssuPaaKXXuDeei1ddf1XftpbKxto833Dt2tLbOF5LqzTdd0H9/59VdyjJfLLV6VO0YLbSYvtGFFmJfXECnjGgzFm2qtNnPYiWhMy7/z0/9+bp/n3/wL37oibFdc/crY3ZXb0RdrxF4kNAbiKnA+/ZOqxe/uVf/fetbXnfn3mCa8+BgWS+jTDbr6lXqkrR1Fiph/GWg+6marEqzoXRGambGCS4xfmDHjoK7TohjUybjgmCUBLGY04PAlYTSCGjoPenrq7pf/Dj/EELTfCd8Ziig6rrQf8vp0xHyPRHa+baZdIwgbVc68lf7njr17raFVoF/ufvu5kLDeVf3pqVDPJSHBuvL+dxvFBAUzD17SAcGlmU9l7395MG12LX8c+PP2rZ9e9sTQhubyQEY2pPNrrtYTT7yhXfrczM1k1ajQ6Uf/+T3f/7P1mK7/+cf/9hMPNrQ6tJieUs2ii5J15kT8Nq9h/74Sqn5E8qk8BtN70a2wu6iLeVlGUijwrtiaIol3ZSnzCUDZYAEtama1l93unAyoks9ytwYQ/dAR8CHE7rtxRFvuwnW8YMMAWUNUHLieoqm6S6i4yEnWwQc6DApm5U3maU7tBURZjDWsD0tjGUG4DWUqt5y8vSK6wmv3nvoi1Pl5vcOmmxP2WSWqCRTtb0sFI4Z5yjhK4Xpc5mIaI1N0ksquHoUtIfjPaO28BIrrTXNOAGeImQSHn2u6fOADEvBbK/fZFvoHCEDRu9rVOH8eJ+dfYfzntU8dhATsfvdD4hi9UJsxNmPQsPpyqHpxYjVqUqFzwlKdw9v3qxJB1QjkfgvrVTr4OhHav8Zb2vbk8KiDB7cfMaNv/3U256IROz73QdsMzPEBzptKE2PO+FMuuI6vnIwyTiuSzvOXXQ8YavigvNvNJ2pum6lSqfx5/RkYmUyJcVyynWhxd36LlN6QKswzN2o9IDswRWzDnSolKtxNzuyd++07thRWidT0Xf35Fw6V0ip73nzef37/EJGnb+Q1R0pytzRv2H2BeWMHaML7lDC6Zm0ihntDabqXriUVZlU7cLv/cSf72k7AV3yH//uXf/H6xdy/y9pR2Azj5JM1WSU0ElTrNAwxKbet91jTikMWhvaR5S6rr/2qrpkpjWjKyZusiHIOsE5l9qv8f5MTZl28VhTxaK2zj4p0/ZLYwKgy0HnE3VxXb2aVcPGmRflJJTvSMOT7S+6nxt07QzlFpiZn+1mS5CBg0usYhqnC6asg32kz9iyghPFMgTzxlo+Q7bxTW/WDbeoL5gZOOSPgjIL15rg4s2DFVJ64GLFM/cxVmbB8eJ6Q9tDOaFh1l8183loXD/WXWh460RwdNW1Y2dj/KGDsB3nW2UutNxHhYIQZUpaxEzVmTVD7bVopyUbf5QyLKatIYdaZQIcnL8xk+1AuzadM/xvrtZ6HtLsnj/P9DW6gkHlJvb1COddy+yfMu27dB4QiGFZasXG7CQjAdHb44UcHeBQoGfmItF5hybIrQ4hjqh7vjcDLDghwTKVAPE4nUu49OJ5Civ23DVnW3Xzrw4zcyCKpYjH9gTTKPlY1F+OzyKqQU33xHviWHTD/MyWDkyEdQbfpbk7ntmUXTCLZk+8CN99CMEJptUiza+0+LLoTi9WvkAGwlnLXHizA0XtQkvlIZRYKJAY25VXU1PQmTjPVSpRNTTkXMTgYou5O6QryQ0WXd0FtkvOs0r/s7fcUlEs0lDXXDOlvv3KLv33cK6khZzO9ua1ZoLajlHKoLIRfEGg06CZcRAFkzbm5Vd3aav3qNFa1GsR11b/rJlJo4xlPC6+GdOyi+2QRufKdJ/avSuvGnW6eKON1nNeVUbDoYyFPIl94dkCjcfQkBMgvPzKTnXtNU4Z7cLFQV3GovIWSjplI0pGyeXV13Zo+3mlRcQR15kXotfRkaIbgFy8OKiDBGVagnG+aFn40PD2YC6gxvrxHirjGAzvHDreej3W1qautBYppQNcElOjLESfm2Wnt9GpQgGKIPSa808PWntvD/ZNWC7LjMMFoSM2a2BiwFW1t//gBGEFLDtzAp676247Ztptk0wQWWWlFV4uKbNaB+6Uq74yQZ2cX+Oe+VeZBsW563Feq9x5L97+w6WUOlAwUycb89p+dVszm2yMLACVImzWsYKbcKyHTMTSEcudZoyMBmb3eFMBmP+/5Yhj3ZbaiLftCC1rtlcymSLF5vu43S6WY2SnTEnMPTxjy0Fq6AYzh2sY09S8SdXA8ZYmSDsiVOWWZ/Ae0HmgwbxkOJeKeNmeminPUSmnzjJUtrnQp5gImu6ZcKMRYXpVpbwOLWR3qiwTNZiwdJZFmXISMmLUEYTdbSRttfdA3pk6iEmQg6Z8s9BQVIuykJUpMeta5aWObGq9wu+SNRFWkWg09SMDB5787GY+x2HZE7QFK5NNyLAyDp/Jw8G04kGW2SiVEm7LKDIlcKSl7zEIJuE0q3T3R1WdOTviCiLROvzaa06TGpxJkQUYHnYyKRCvNkzWBmUN/CTM9uBAWyw5WRR0gqAUQXN4dIus2faVK336jt0zlLNcYzKUQ/CahMmqYJpv0piU4Tl0FF284pRPbg9iu4MAACAASURBVL7poiqVkub46qpg2nVnjYMqDc1DBmp01Ml4XLnqWBlQtgkZmhuMeyuyPlNX+9XVGafskk553VKoAOh9pq4qZHhMBsc2pbGXX3XOWSpR16JfxbqpSL/iVCnMed5/VWc2SLyKTNdAllqJU/o46NximONc3hE6o4yGEhpll7Av1IWD9nDbXAuUmVRN51KZTIoyglieceOsKDgB3xy/2y4wB9eIKako05ZK3R64wOOEFFkQQBcwXARtpkehwXK0Dlwo6fKT8LUn8yaSGFtnn3GdpY4gfktjOUl+98LfMMsrE6Tg4k2VAT7+nyQQDRYw1FiAhUDAHZxreZN5UcqYYTvKPVecBhPL1b+gK4a2p4cWkuwi6pSi5kx7rcWc2W0TFMTcoMNzYY2YAIVKPTj/SeZRg/PDO3Ep8MNxRdmIAWUCTMXep6FExN0X8jxB+7Ye8GdeM5DwPGNixiXY05crr+xnrPPpmaZZ540T884bhPXT1OKo5bULW6yLhzpyKuyNSkeV/aMDNTtmx5UgrBKbPGviQgFKPu9cGOH+SUFANNp6E4BlstlC2zpgSQ+NQdOk6m3tl+LoT/CdiG4eKrvgok5aEQz1g0V9xrQ1l8oJ9yJ86fKAyg2WtQ8K2L17zg148vP9Khb1LnwobaRNCQEXRAQ4OVMWicfq6tx55wIKV1yULZzuEZRdanrasTJW+Zh6XDadQwgwRkfJ6yPqBRymfAMtCxgZKqrhYSq57NDBgW2q07lsSRXN+qAHweM0LA/BVcwEEucvD6g9O+fVzJwTFO7bM63eMPuMQAVtvmQhf3W6T43QxOdMRX8h4lwBlMRo/6HjGRoqq7pp08b7Q6UU+JjgHJBLMLxfFsykYehbYG9PYwZw3BRYwq4e5btqhUo3EXeg4+Ur0CTV3C4fdFsROM/0/pMPCgFNUb1hSnJtn6wu6Y9Zb1mo2/8SZxc/uqDh2lWmK5/lXLR4azFdXxDMIAtAmYCqd23V2JbXcupYWXgBQcIbVquzLxQc2CZDwVtovbk7xqfFbH+YZUooMHDbs2zvgl1tOpkaynrMVD1Pl6Zjx+FqJnCRbrpZEUdcSgEIrOGjlhe0IZPDR9/R+Yvqf8xm/3HcNU/Pg92NUnAFr5mI5QZ+OCf0TxUX/AUzDZjWk2ZCYIsdMze/SxkxbIl5lNBXEzQuEOEG+aQgsLOiXgZpjvnQICisMoExghxX6Jxw3gN6v2KW0038rS8PqO96YN4JTCgjghNdYgEIBSU46Th4EigtaBWvksBEWE22SmBiwPiE4+6sHctuCUq4eZY/WOHL8Dk8yLyMjjp/Q3eAdlHKVuAOe9cux6IeQtocm/EDISj5X+BCB8O3aMwJcvS2aVpyJaqmCmlVMxN3v+tNF93nYAa2d9+MunTRyXLs2FHR046VDoxiOrPRb6blIojZtcvM4HndZABMYAYBKulJICbFhZ+0K/DqeIsR2UIDMtDnXFb1HtiW2jHiHPvFK/16GjAdDwIG0rHgOEnll4g19DHRrdprZ0dVygRiOiPRtNysFPaFZulAu8F1Jdg/ympgcjACSZicKS0UXtCBhTJBRbEYdy3loZ8hLdHu3TPao6ZmtCM7d8zpTBR4/fURrefhkLAVr8P7GYk4QRt0JGWTXcIsnVqNhJtK+5pQqzk+VwnlHOuKe073PnXqpbYHBaGHnP/28qcWN39mYFtbqMvP6v5EIolPtH3oNjFHDx//snx3CRuBFZd1CPI+gW6EMgRV1lJK3R+0vSQbEIi7Z2RNqIuENCi0jqQuezjLorRSYa28uNOmbEUsqtyOH2QRtCNtwtN2uHfsdeeunazTkQGh5xpmCCDZ21fqnp6mYLpUqGVXlynM8UVNBohnanhGIcm0K/gfZTJQ9io3vLIItk8mcxFdwWgtpXCdSYNpYXg3EB+wCC1KmbUBp1grtG3KSlGzcCLitX77RwPQ8spkX2JMM4SSGB0rMifIWNGyyLKQpsU23VMkEcHrKePWNO87lddQ0nK7jmylbrpnzmsfRknOZE50SSfp1s/0RGIraTIsP9bXsCPux0MQek7ujq9tpayJS5j+xO3cgW5iKqsGBkxnSbThZkNowBsxNLjgOo4i3Q/X1z6TIblyJet24KAUAwfSM2fNNOP93jRjdActFBKqYVpTUd5AyyvAkDqnLOHki7lNOu7k6e5f6bv2hMqafYbG5PU3crplGFTKMTU46A2kg7kb6SSoqwYMDS+ownxaXTGlKv29ZtqRkYWgKcznzg3rFuf+DHWpWG6bNAYfIstBWQ+UacrGxA66FJSeqMUZl4B5Y0OPLAxKMpS1wXndZ5xyI5GGvqaeMVmf3bvm3WnC0P3ABbhgyk/Dw/O6pZfOw7nzOdcGH9qXqWknqzKfT2kbfGiIlNGIlI1uBRoVZMGoLdj/OZkvZEwLsQpeht7bK4Nqxw7nGNB1RaWengUnyszeSZqLkzK6Eldz0nQy8HRBxd8kECV/El4iIeJGB0EXMVyk6Z9Hn9ZgeGUWS3kusHXb8yzR2N4FPmVG99OFvsiCCMtY13MhaB/TaOiLt1kcQRidP7wGQU425q2Tth2zVIuDKi68A2w5ptukXXXPCx2sFhez53jgR+uiACHClqOWX7+FPK0f+0Id0XHL8t4fu9UBF+eD1onzgfNM763F/Gwa5nU2C76olViX4SyvDIdSLL0Htmkvp+DS7xiMpW6YmPdOUpGllDMm/oDWBAdjjqH508vPuAjCUmzVwEQ5wUmOunfIZTSKcoO5MKFsMzU1oEZGPN+TXI48NOquE6zyzeAhES0u3GBwsOLayUN0mssVPd+OK978K4hjoS0hzQm50NL68b1B03OhocgY7w24ze7cOes6l8I/hAIlBCB798y6+gpoKM6ccQIjPTl3oOLqZqZnMmrXTueiWa5E1fBQwb2AZwfKqmIcVeFAO2c8VZrKUtfum3b9WOYKabXLWMsjiJjLJ/XMG2VahNMmuMLMGwQtFJxBPEpeMNC9aLfXbMndXs2cP7Q7ox2anusfqKpM2vkdE59hs5AxbdoIbvbtdd4fuPDCT4YCHrQRD/RTABfRpbjXzZRilHHIvh7bxlftqPE9wWgCBBf0HATEfGJxt/TUSjQZtcKHMAjCCjnzRLbjFTR/uk9KGvKzaj9bOTBRTnkHQpC5ticEYY3oaeZEmewJ3dEjxU934igDlJh7rG2yIsrczfubiajNl9p+qRSBG2PXzEw5HSq0bJG1otZNpiTGMg+UBSCxJgk18TgvpTR4V1HEK1/Q9F1eciLnVWRiLFbqiCmvNIUoGWJWOtM47qQrDHZEsfQcH5QXs7x2ZJSMIsozu7NVq2Nr+/mz3GNsmHIbHZ+7rMli0DmyWEcOdgHnwM2yMLdY6s5qshIdZW2o9ZpExHXWwo0sDdbXH3AMKZM9o6xKlHVe0QRrnKubDhdVLNXwFL88vEb9CgZ+H9j4E4eFTYwVnc7d8fTIdngLUd6hMg2MvPjkYQ6Ep9QJguXy830td838dZcv53Q2ww8ZcqHVWBnHU8oeQEyZSnsmXvi7bgSwEMfCsKxoMiAoz5CAE+6lEGNif5Rph6aOmYWFhC4FjZj2XsyaweA58MYbw3qfSXg6k0+rnWY5ZFWwbyR0hZEbmbDBMC1mWnsxyyaRqGrTOWWyI9SRgyF8mN3TMFmiG2+4rIqmBTk/D7O5qh7GB771nTEVMyUXdM9EorZr1Hb+YtYVryotWC24HTLoIqLWa2SWUqmqW8q5cDGr+k0HDTIqMK6jjAtKMdMzprtKl2SqqmbKWiitJZLOOUHJC+/1vDm3CwtxNTbW+r5SdgmlIzqXKKtRdgzvE8SwJLRGKzbOL8Yq9Dw4USZAUeYiOMgG6lW5sydrye0zVuj5uheA0OnmF3Hl6h2c33FBxPpnTdmA38ogMKiwi6vN9RqmlZe2xyoueh3YnxILSCpMo6GYJT62TyURWgW3zafCA/xAag3vOT38LtpaLqEuHGhqaq52xAuEKqa1l9q4oEWhMhU1M7EZfu75qxlrGXoq4dO+RJnlPgIKdxij0QClWFmH1o99RSBWMDtaY1b9TgnGctuFE5Z3LpUJolw34YZ3fBQ8ZVgJjcB51q3h5rHrxufcCcU2HHApWsVe/Nhgo5mpi85EWDVydz63pbMmfrj+hNL2A/3FlgAFpR/yydDYlioYnQfKAqRHKeuBerZrnQ7PEHIcRRlifj6pcjlnPZiGXDa27bhQ+ycd074sGD0GDaArLiTcFl0EKii5UJCDDhVcYJXRazjD8Dy/FApq8Ds0GHt2OxdbW3fNOP4hCCrQGaS7gszEZWotRvAxbYIDdPRgX8htFd4o5H6Liz0s/CmQwaC8uXknOOlPV11fF2Uu7NSOnM1WdGmL2p8RVJAeBtoauO3uNIP5cC6zWU9fA8v9m950Sf+NMtfCgvF+GZ7Xrcquz0ot5g5cRJfS7FzaDSwqFa/BF4EcHwapzPRh/R4UUyqeqLttxij/QVuidMeUl5BDYDPgK/3gPfrUv/kra1UGoN3xtaetF+6828ZFcI5Zl9PUWeWbXAuNCoSTJEpdYDoICE7rTF+Bu3cuN0D7K4lQ+XwXyrjQVQr7UnIzJs7jCXbX7c73iVotXiAl3wU6xvQh2EcKJKA1KTBzNVw7q+4V1skg0e7ho5oyv8dNkEFeINhFCh6aPj0MsjsVN2vkBV5Nk42hJW2WHcH6hpnXiGJBGj8fyswwmq97593JXjjLcGGr/r/tCZ+xEZoxtKCFrN7fSnmty6T7oaCKzpliwZQ3bNgLXHDO8RrS/nzrq1n15vucGraFE0LrH40pCUyE1WS7BSYG7R5brcU9Xwrb0hc4urtHYALth9J32iXdEpo07aH5+YxrST43m1E7d+b1hVSZoIbuovVFVmvinC+r6ek+lc16AQ8CE8riJJj5G7IjuNumfevvi7tGbhTMkCC2XI6rjLmwj2hRaEy9YS7EQ8NFFSnTjZulfVciJgCDPgUzfJRpHYZQlAzHMEm5Zqb9jgzPqqoJdkraG2VBXbrkZA/27p1Vs7PGwKwU123F5AsyN9evMpl5s21HE4IZO+DSlQFtWa9MMFeqQEdTMK9La8GqMkJkBCsZEyRCXHzRtFBDjwMdDml9EAji+JTRtFD7sXOOkm7GBYHlmM92nt5nBCB4n89fcNYJgfLly85zCMjS6YYaGHHWA3Fsw2TWEFRSYIsALJOJtrSl02dl1cbXDiatL7Y9KAg94ptPtetPmu9KiM5CflZPZ7I9AxPSn3y+7QlBWJ3Pm/53tiplHQL29qarU98JW6zrBjfMdFfuWp1T2YNlNZCBSOshel6ZhaYSp+KWzr64XTFM50H6BVp101ZuNiZqtCExd988e3csB93HfN07L5QdQWaHG7shM0LZHlq+z7d9ZTIEuPNPUemm0aoRSbBsDEoYLSUeVoJRvq9GPuCP28WTK6zzOluXXViSwy2VWb7SVI0lIbJG+8K7jAqsDAY9jOd1xrQ9TcfNlvaba32UKd+4Wam6Vw9Kk1kcLcjM4mqmvZveW5Se8B7G+my173vmtAlb48dSShBWi1is/0cGDjy1qe3pV0pQezHZkEMrQAS1l9IAOJR3cOdMplvQTySoLGAG9sVpXWzQ4LlzI2pkZMHtKKHMizLbQ+bGdk3Z4iqdctZfLKV0ecPVjsxm3GwMOmVgRkbAhA3Os7S/hYWka5J26VLO/a6C1gKlDrKVzw5U3OM/fzGn9pp9Q6dPIllzy1vIEHHH1lojokaNbgX6lhHjLPv668NqMFdSgwPOObx4edCd/AsXV2SkKqbchTbqnWZyMwzXLqCTh0pa1ahrX4+v4x2j864+BW3HrjV/Paby+bRaMBb/e/fOuG3F0KqceX1UdzUpY7AXiXhXL5j1ceM1wq8rungx5+pR0FHErezpPVMm27MmwQl49k5Hf9Igg08mOknFvYsWggyLXWypPRZTfnFtczUorFUZF06LaS3KLCCwzeNNFvBwsWWKaRiwGyTMRJkF2yOdCeb8UGnKWU65/igF5qiKllkEE66Y1eto1evDxTTB9pPOOmkyIix4IHippmECLQoCgoKRJrU/q1YNSMynm2mw/YqzwIi3GcfMueOzfGjf+kzwwScPz1S9wEX59rPp256rI7I9R10Enzj3tN94P3hpio8miFheIPum8ZKyfmZVqpOCoLGs2EzujmeG5Wwo9Wv/8136X16Qbf3VKSebiQu6FreSv4dlu0JM6BNQDqHvRn5BozZjHsj4oTZWiDjTGecChwADniG7zEUarbuJhJmXY0o55LcBR1W60CMgQHBErbiYSEwC1f6+qto9NqPXq4y4lbQk114zo4+DnkMrMTnJQv9CQQv8W+Zm0zrQUMYDZd5MHkYJaXo649rzY1noTsAbF3LaEZZanq+/7ooOzvRy6areZypXIaAinQyCNwR4xaJpa65H1YAR6uJ1CAjIhh7B46XLOee5VF2LWQm8J6QPQXkGweOMEchiEnPWlIPw/uC94tOGqUSHMhv0JykTJPLpxSgHZZgTMIcCE7WaZR3i4DNPb8tUqLA2FL7e9+8tZdUd1zj5kZ/e/0hg4vGJd/y1fJ8La8KqZ04IdPDwTo1C3csWoExSZ6JK7FOFdecodiceZ+kV6uIosZZaKrOg9FNlmQDeyWKbIX10115m6Yq4yUC4wl3LyzpQ6y1fFz1FbdMmyeIay9G2sd/uBGVW6oiYGTKUS0mwtlze2lszglr+bvF24Xy99X3kJm8xyxPS4nHXudZMGqbXUkaJniuxkg9e0kczeGqOgR259ubZ/BykARNRb85PKup1ANVNBoSOHaU12+wXWsJ5FoeXvRq+rAqyLHC1zcTV9E1fPa1vKWaevm1tPsjCtmLorhfkYhxAUInHD3XTJGJ1d5oxjNuGhxcCJ9EiO7BvnzerBUMB0+lWMSZlTrRhGnOSLZbS7rC/188Nqf1m5gvu7Hknkc5UWK273jAtyRcvDeosgjKizJm5PrfUge6aa69xOn6QueBDDyG2bdrU8eOtFyUotCqXTCkHQlxkcZTOPJX1LJsLF5zsxT7M/7nkZJ5Q9oCx2TlTLhnbOa+mp52szZ49M9pVN24yQztZ5wsEy9NT/WrXLuexs2eHXbdalFWQzdi503nuwsUhd+4O1oFp0FQeyudTKh43lYO+cou5Gp6LmPeOxLx8Xg9/n/AetWDKbriS0fvPsys8a6LWMjgBX7/rbpt8QCLMBr5oggy6aLZMF445Hid8r/kUXS7F4NfngZhX/lHmwkuBA5UW6OkGW0nVlIY8R3SvJZjWQ6/jU3tRhqAgSwWUkRQLLMgvRZnSVJm16fIySMy4qNJrdPeP+RvBUIEFFYr7qrD9pXPbMsGYlWq4hTxvCbbNeihI09OhzWeFO87SPvNt8tKU3m/zugiTFyrV6rFSN0McabU8uEsby323HOWMKmje/vTTLZ05M0/fKgGK0DOG7vq6BCaLEBagwK+DghHF/Es41PFBzrEENCxcv0LTkdOZstaikKcGyi9JMwwPnR5ohaXhgmh3JZv4aiWmyypzRquCCzBN7YVtPcobr5nyDLpeZvPOcgP9ZTWYRenF2b4udbDACBdVKnWgEwbLK+3r0ee2Fd94/WU1m+9zu09Q2qDyFnxS4EMymDNdMcmqW87CsYztmlOXLjvb23/NVdfhFq+DToUmOWO/zp93EnsIftCxRG6uKAtds88pm50/n9N/7x5zAgYEfRTcaTfc/oou/ShdMrPcEgxNfqYhgTiWy6bkg6CGOwEH+dfQkMDR0db3GUGqMi3G2rI+u/C2o/d+6ThfZtXLOpxbnz4t/9iFFYM2dH9gouRiIvQQ+Swtjf9OVxCWA4oF/sBErXXmhHj+Ts9FVrHBcZRJaSrvLpkWo7t7ZDIoW0FZGJ45oaxAxJRE6K7d37mTYmZk3I2Usio8O0Pzeppmxos78yXi7I9+rumkHbgLLXmnoDSC7c2zbheeVWmwDAIyDVQSIQEpHXeJpSQSrExUN4MSa83299I259c7V945iVpeJxL9Td1GyFTUVauYlfxRymYYo9tJhEypCXNtkxpJMs8aAtkenjlBJoiceW1zTFGWxSFX4D6TqaHn7vza4jomyaAIK0ECk+4Iy6DUTCdPnGVCpqayamSk9S4aQlhlnEnhKLrL3H3Db2NmxvEFgZcIyiM0iwaC12jEyWmj7KCzEmZ71UpCFYwxG7w3UNIgHxJkOYbMEDs4zqJL5NIlJxMA4za3G2gsr0sPVHJARufcOafMsnffjKpW4tpEDcCP5KLx9+B+IZjjg3k3tM8wf7vOlFlK5aQW4JJQF1mLi2Z+ztjYnN4edTxBaEyiXZi27djhlbQcEbCzDhjcIXPyhsmkDOWKOtOiTOkLWQ4aLohZRVSqwWvgkUJZcmyLhMHo9oHAl/YF2ZE+M5AQAxbRkUTDBVEuI++XkdF5NT+fdrNG6PKhLAz9rUxmJizIXZfgRJkuHs8x1UnpM2mHV9aJOmUPaistsRIPlU6irExB0GNUXoyxabxKtW6vYbe2LiPooG002MW7Tvb5bL/jrAXZ9pVyeDDUx8pMEeVFVEnTcUQlGnT00D/ldMQLQGpmWrHNtk27xnUhirp86FwavQl3ZeVlpqjV6iYbY8/ZzA2Xby/i/u0FR/5gi3cf+dfpnlv2HJWp3ODSDHxUzD0WgV+n2beZp98qAYrQNUN3/bMEJsvAH6BgYFzdOJfG4/XQFaJcQBcwlAtQKggr+SimY4Feg7p5UCKAlf0uVlIgp1IEF7qN1egwuN4EJZZzb+RcwzEEMDQJGFb42D5ZymcyFXXZlCj6MlVtEU+W/MPDJTU1ZYKoVN0bZFhHe3BRm63pTUeablmnWIxrG/iKCRZQhuLdOdDJkPMqXkNBGmzt4UJLowIGBxbUeaNNGRoq6XWQ9gYt1mQiNzuT1p021zBND3UAQeeDVumcKTGhXFUxzq7QrEBT4056ZlOpi6WkPs+ue2w16n5/Y1o1rkGuWZ5P50OmeB/93r8N/fe2bsEJOHXQaTOO+HaPa07SRpNBFzFuCGr79A0ZplQtm7k31YDj0xfQpndR5+uMGg8Pyl5kfJ4dXIfB22uV0bmQroWLev3HiGPx2/HThdgfQBFYXlu4m79p1gxfJ/2ZYtkXCu5orWj7Xah5QUWLUDhAJ8OFrpQNIf0H94bhnisRlp2xFBclO9mdhm8btP81X9sx+cloQWzEUm893V1ZUAIUoRskMFkZv/Gld+h/b9Rayu+O/ZB2hFuX44KFLAgFHQhwZmad5SiAIaD/IGt0BBfwMhkx03ERNPgvijSvBy2slKnBcleuDrj6CtixU9YBglXLWNXr1/WV3axArRbRFvu07wiYKDuEdt3Cgue5BF+TlGldhsaELOMRuMDOvmku9siu1IyzLM33Ie8PnAfycIGwF5OT+8xcHGRjBgaMp0sxpqcON9126IobQMHCHxmRXbvaZxohGBzIFt1j4M6/ODb/qALSnyBjgm1ljR8LLmHk9Ipsj6U1Je0BJnnZhGVMiDXVnPg59Ozi6XlBUCZQ6TYwUXSxkdZa+engRwKTlfOrb/ufcg6FjuhEr7SumRPi6TvusmNMh2Hxjhjzu38ejGIturxt1U0RWJ4mRZkMDBmtJcyk4XrAHbxSrWWJJJtKHDddNqQriZp2ZkWGcJZySzd8V5TJDJCmpsoMzLCOOCs58UwD9i/Osg5NprNJsP2izhZ+jmj9uizDepCxbT6FOMG0MDh/FK0WzUwhN/PE6zG+jJUuDbFsUtTy6YDoLTEaF55FcocxmmwQL7XpCcZxa+6Wk6dzagXMnP4eyaAIoQzd/aJcVHuIv8SjuzHM3BvdOooyh8lo8LIOQY6j0F7wlmO+LH4nszN0x8D4DRoVZTQs1arzrYMuFGQPqJ23UEiqa/dPmdeldBsxN5Sj2TM7dszrckrRdN4kknX3GKjlmTJD+IpMmtIN2oCvmk6U4VzRMb1s0L6UXHOz0dF5dfHioOrrJ5fZglvOisYaaqCv5JZkkMnwyiVOGYdKZnh4IOtkqlDqcrJNTgloKLfg7iPKMsj8xEwJZqC/5LZQ1xsxlU6V3bk4e/dOux0/15iWbLR16/evEncN4IKcXikj1pfx9l+ZLBo0MZZSCx9/+xf6O/m0bYjgRAVoUEiYSV4m5EViKy/d7wYNASUfHUDYnl6hyS6YcX2ht92BdxWmlm362oXJYVWZcgZKQVHlBRnkNVIzF1Z3ym7DdtuAEeCU2IRkLqqNGgEuBVi8PMM1LZbxXCnz4IcFYqo1dnADo4jPM0Rx0bAJoGg9epIzBT9WazlIb8+siD6OtG98/ykI5IEf1wLxck2ZTSWOmsCOghX8LxO3/vS6r5z6CdUDZp++tW7bzbYOH2F7I4HJ6hAmkm0DAwTnnYsplRJ4CYbQw+Vsr+TBNQwoxezdM+3qIc6eG1HXGA+O2bmMvimiwALBAQULWCF0HzTVGKULaudFUMODJq67wIUbfiM0hDA3WFT5vHMM0KlQazJEpwg46AKO0gxNGoZOY24u5U5LhnMrXcwLhZTWosAPRmnr/KwbJKiACdD+FmTStczOplwvEmVaunE+lBb8zmhfFKUDirRq1K1AXQ60KEPDC+7AQu6rgkATZap4wtnvLESz5rU4xxj4yKdIK6X+4Ojh4w+3fQZCWNeyDkecZAXOW06ftnoVmIDcXV+PRWKZU7aS/+Q/W1nR5GsSmKwe0mYs+Li9m8BEbaTMCfHCXXcj7xThbcJcqJliJRDcufPyAl+O2pOjLHvRoM4XXvLwzeShkgQvrfCMS42VHnhLMHXZULSHbAudWww8RMnCFfmy+UDIInARLCfiS4WgWyfJsg6uWNXX+WIpzxGWMie8q4g2Rx1LbpcP60RKmf1ysz2sq6dhzoXf5E6xjBAfgOi2B/tMIVPR1tJU2YhlV1OLlH/+fSnHYgAAIABJREFU/mvr1enX2p4Qtg3xxNC2H+K3Vhw7cQQKzEHaHO7qqQuF4EPftJGXuTuv1mPeUECDbZxYebkHokyIMymDAOMvMgZTJuuClmK9bMNyu1sgKsXfA2YQILZF60dpRjucmmzMhYs53cardFbAUtnBipqe8jpoRoadLEtLVsO29OtS7tC+uvscsiu7ds27fyNzQvtPGZrLxoQNXTQooShdikq2dCWdPTuq9rvZl7g+h3QMEBOTORyEv9hHKj/53XjhGEuZk1Ix0WKix8+f8hmyYVtBbr+c5QaqGy44Aa/fd+iDl8vNTyvT2ssv0k1WlqDAhZd1WhxHLWe4nPJd6LmOQ5ngxK/X4Lb3FIAkzQWUB0B0gW4qx1W2xoIcuhiTCywN/quyU47XNNmFO9XiSeIFI03jncLbk/l5sFj7NV8HLUeBRYR1QiWNhibBTg6VdUg7woMOXuriuiAqAXGCBhnSfvHzVyGvlqbzft2+hIdJr5g+fYvoULYhw3e/JHf0a8yxE0c+pJT6naCt4oJMk3KV6eyhix8cYJumEgt/jsHBoquhwN90MYddOy6QaJ1VZrigO6G4GtcusTt20LThVgdaPzS8EKUaLEety7FoQ2tGFLNcp+0hcHDbnm1LBxDKBFLoyiGPEjjX7t3jBE1XpwecG04zNRhdLRSMwJq+v7+srlxxzgMGFfLyCPaRgg5oaMhHBV0waCP2B3/KtBWji4o6oVCSonVCJ4LS1uBgyWyv3PI6eJxQqQ3f+9SqPDXdrx1eg6D1rySDtiGDEwJCWfqdLtJ83ovxPWuzs1fsDp6P2aezhEwGv0jyDAgRDQhOmr6gQCnVto6g5+h5+idY9wU/CEyobbjqaz+moImCBp7RIXhrMn9MqVZvEtqnRNTT7PC2bcWySTSTh6/WPVblREN0qFGmQ4mZ3yngqbPpwhSkqYB19sesxnefPr2m44UlQNleSGCyvkCH0jYvx7ZU1bT2ogUXd+NBU4mLRrxaM0JQv4g2DAQOMDwjPYsjpHVab/X/Ldu1f4cJW8y0wkLvgnblhtkehKSjpi02yEiOQ1oUuxnRQQtNLx5jmRLsB3QlDeNXgkxM3RjFQXuCFuGhYSdYQItxwcz4yQ5U9HemezzTWZUx5xOmcnrOjwn2nL+doKIwn1DJVMOdd4OAJD/vrFPrdUwgoszEYg6CodFFjjeI/Hyf+sTbv7Cif28bRnMSxF1rdBctrC9j6citax2YKHOxisb6X/Ls4eRnK/5EIukrEpisP6JD2TY8tNLARG30zAnx6r2Hvni11Pxe/afPuKvqK+VQpoT0EomA9l3l62LxZwjiLANjq1bnWqyOJk9GI75OFO5Ma3l28hHTWeOVU7z119m6lc+tlh+b8nXd+I3cFMtCxFgmgzI2vORD2pummY5MJaAU+10b6ijPodY/yDDqy9aQxgTnmbcLN1krMS1Oxwezttue2RjzlqZP3SxZlC3I8KFvyAVxg3HsxJEvK6Um/HtFrqGuG6m+AzeOsJkFPQ2YWlVRukBrqlJOmQFaisVM3woFZ91YjkzY8CWMjAhfnpvDoa2YshDQdZDr7NRUv263pQF4KAGRMWdhIemWS1qcVQ1kO79v77TuDqJhgngNN59Dm3HalGtg5EYZI+7wqoydPNxrne0ldZeRf5vKdCmhhETPzc31uUP6SKsyXyCX22rLyAEOlhnwZVYI6Ik+PPHFnv172xTBCYGZPDXfBFzeCpuMtgYEPBiJsQsvTQ+uBxw6zdwJ8iThmhLlawlWPoEuv+jTjrolFl/ph6+XBxL+NuCYCYiU0df4dTS0Du6BojUm/mDB8pbjTrO8zRfnMcLalWO+44mwIM1i+0Hb5vqUJnuO2oczUbVw08nTHfW7rxUSoGwtJDDZ2PjbjRE0wOqeCy4JeH1gcm8y0W6HTlOQeXBCGgmUjOCrQjoTeKGQgy00HtBZ8Iu5blk2Tq8oZZBYFxdemjYMSwUEDlRagS8LzciBaHbU6DD8mgyIb8mBFq3BjneI8xHN55NuIAQBLEpf1OoLoS7tByzjswMltVB0gi3YzNO2B7MlXYaKm2CroEs8zvoR/PAJwjgPaGVWRrMTBnmZUPs1b7eGiJedu7mjh4+vyI/Kz4Yu6/g58MzTVioaaQ+LhU3FbU+ftjZaYKLMxSyW2HGfyRPJzyb9iSVHf1QCk42PlHm2Bngfex2YqM2WOeHQXB6/GRl14ti+DhOeSQnqJHHbcE05g8/TibLn6r4pvrabKXEyF66zrGW57rHKZF0oI9LwDSuMMHGpxbIl/F8utQq7m7dbsyq8s0abz5lfI77OoSYrq/hLSrwVOxFRbZklv2iYO7/yFmfeEcQFt/0xq/rdp08n1SZg+tR3SRZlEzJ86FtywduEIIsS1JZKhmIYygfh57QRm6KUgUwKh8oSuuxgunUuXR7U7q6824XKM2g/RkaABLoQfpLrbK0e1cZtfJ0kdMW6UNLJDTqZE2QWyFkWpmeUHdm9a0Zdvjqoxsw8G6ecZPbr0oBetkX8a/YZzrWYhUOZIz35l7mtIrtjGWEASjVUnmkTG7PWa2ReKGPknQfnqxjnESUyel6Xo8gAz2r/GuRZlNUMMDdtcAK+PX7ojdlac09Q1w35nHBSUe888m4dBA7kC0IBR1jntn9IIe9YaapWrQopPBvmdeQsi4Zgvj2uM2n4AiZajpxq/fbyyrRC8xKQf3Jy0H7TTsZZScnfbeQvKwVNXFYBQYt20aWymOkIun0TmuxpT5TKBfFE2QTEkruvyx548sx2Pw+bmWMnjuDf2rX8EJqmmwV6E26DDw0FtQdTOagTeOfJpUuDqtGMqD1jxjfEsl1LdxpgRxfwq1f7XV8QPIZrBAUC3Fa/XErqLhlivtCnMumSWWfT9VjZuSOvdSWDg86y0LhQGzPKNihNoe1Z6cClrksoSrdCR1Qf8yAhjxcC2pqaCXh87qw6EKLyEF/HUqDjh5ZHdxA6kNYi67WpgxOCsiiKCVIpC5AmMzB2MScdCc+guLb3ZpIxF9ISEd8kX25X72/L5XoUHQAYHw9lpk5ToEKttXy/+XwgHlzwYAGZigrzWGkLPrj+xLZb1knQNGGeIWlbD9seebokTfDDAzH/rB069h1J6/du+Orpn29b4SZi9pkDV5qNwuhmPoYti5WqDN/9YmqbHv2WhLQo5LFB4I6dpuOS14gyF11kHsgnJBazXd8RurCSHgX6jEjEWQfWxbeBLAPNl8FX5tjYLHud8kSiAdkEbiRHARXMK7CfPBCAdsbZr4TKZUuKDC6g3eDr4EA0S8ft6nBsSufbLb8ju1MzLcncat5vec/PJQ8+lqJej/7JLz/wjz+5xGI9Yc3bN1cDchTlQYqwvkC4e+cWGUmQu/N5bVQwfepG+XxtIIYPvSwlnC0I7sqPnThyHRo1t/u52EistUZoS2ROOGfuPfTpK+XmB3lJhOBdKrysE4Q/A6OYdT5vjQ0yTyMo8rOtVp1JlGVA3BZfX1ZHmUxNjPQhzdYMSdPXcuw3OOMZnZaJwr6uIX8px913X6sw70Syfevh5nfoUoLgtW2FW4ipkxKkrCcj4xKUbBeOnTjymFLqffpLNCBjoVhZhfQb0GGQdiWonZeMyfzZAqwnbizqUWbhIKuC7huAshA3O4NzLGlA8oWMiprMDDIh6GgcHXWyONDPTE87GpZMpq63QROY0f1DZmoo6XAHVw7KO8lktaWTp+18mOnGrmutacnG5OMgcN7y+b6W5TnrJVzecsEJ8e17Dr0yXWleHyR+DXKEpSCAxtaSgJRfuKmkQ/9GkB2w2EjgasMO1apg/fWAJ0kfwj1KYv7AwqQVbdVe5lHMcZb7vXhzN83/WZmHvEts1a4dCTpftD1ezuLtypZZz3YyzYMepVZ+Q/Qoa0g8uef+7O1PPbVtDlhwCdKjtBASvKDE0rQjLW6zBPQgcGglHQtm8lAgcfFSTgtZqUQzN98XGCwEwVuasU60BiujHeEgwIhGnP1CgOAv53DIvRXrDPJx4XDBahjFUtq1uUe5ipfJiPXuptoSZZ0gbvrqqRvw8Evjd88VanY2YBGhR9y5DZ18jfjSkiBl9ZGgRDh6+DjKPEsHKcKK2Sgt3ls2c+LnlXsOfelKpXlEsfJMS6bBlzHgf/OuGA7v8vHDDc38GRX/tGH+HG/hTRhxrgrJZLj732wVunIxbsK40dpkmMY6aYKM6PzHGuErZTRXeXrwZmTq5A1S7ukh8dRe6cARAnHLPWbuTibTmaCTd7f4RaIcOK8ODJRaWnOpBRldNBDRBjna8mwIxLdVtOiydZA7LbqLuCgVmZGqEbKiRBWUySAuXcrp7iWlO3uKLRkXLm5FZoj2ZanzA6Hur79j5ZbzvWTbBCfE2XsPfc+FUvOfI5ZqKZlwR1MVMuEXHSuWfs4TX5BQmob3uRd7pvMgZ1QOBSgR3xA/vwst77rhwRFv522aCcyUNPT7o2DZuM/5lfbZXw7iQVCClaJI7xK3LPvAM6c3lXnfWjN18joJUlbAyPhrEvQKHXHsxJEHlVLHw5bl7ceKuckSvJTDQTmnVE65gYd/+B06aGiIHiAre3TIIOhRZrovAphE0iufENCfxJnzKwKMqWnHGXdk2OnIIZdbGkII+DaD8Hc4cW8W/E4lH0c346z/o9/7dxvy39u2C044X7vzLrvZZKIJpu3gpmiu2NNy3NKa5gpeDWjBdXUZ3DKexK1WewaGWnlpWW5Dz1ty/fviF8QqX7aHG6RxrQpaqyts+8jO0P5wUa1/3WPpyO9c+5VTv9R2EoVQ5r52xzfrtanvCnte8IjFR741eMfX3iynRFgu3A6fLsIwUUsmam3mZAQyHVxU6p+IXDNeI3QhV3qWTkFP3c2YrAuWRRCkjLaPhK0IOLR3idkrHgRREMGDBwKByFBuoU2j4mJbnsV/iIi1A37x6OHjn97IH7YtqznphDtMq+uZe+9+7+WS/T82/A6vMTHLsm9/VrIky4VfbKe+ul+yKQGM3HNWsiRCTyCtxLETRx5WSv1/clbb2UwjA7Z15iSI79xz6MtzteaEzTIpvIXWPzivwWzugybwEigP1dnEX+7gipIMacn9hmaLtSoTQa61tH5sF8P9eOmIyjhYpz87o5RoSVYTLaAtndnWAtp4+lrRkghrwrETR5Ad+CBta7GW2sXgAwOD8GdcCGROkkknAzKAElFAR5GfqakBlUrVXT0Md4BFpiUWtdtanQnuVkts1hlGEpwswmv3HvoPV8vNR/l8HpRBeCsuf85i5oF1ox9RFLiwzZAzq1KtXiGKPEui3pyaBOsJrqvWFuEY+8jV7FYxLw9wuG7Gv+2IXt6ybxcdybqwXTIqkiER1ht/RgWeIfBDSSRCyidGQKtMgOAvwczPO26vepZPSNBB7rUEzbrxzxBSzKo/X+hzdDLM+ZVmDOn235C2aZogrLbIUEUJTrrgX+6+u1hrqvRWCE52pCNH9z916j+t8SkUFmHu2UN/Wa+c/8HwJTYPseTY8cGDT79N3m9ho/LJ428/Z1nNvVskOHn/0cPHH2tb6SZGgpMV8M3xQ6/OVpvX0Rp45wuCDApOSOBqseW8Vl9HscpFsvGAIYC0bNO8X7zME7W8mUDK1x1EJZ9dqchb93/l1Ivrfc6Ezsk/d/iDtfLrG1q0RsRS+35z8PavfqTtCUHYJPz2U2/7w0ol+VPKdNr44YEKKJthfMpM9g0CgwTJMRYBBc3WGcwuaBEtiWpL5aR+TAUENCjzxBOmdbh/gQKT248ePv58wCa3DBKc9JjX7rn7/56q2b/A3WARsLR6mbS2FvNMR4ZlOfz+K5SdUb4Ah2dM+uNW/paTpwc3x9kSuiX/3H33Nev5v6rXp4fW4+TFYsMzkVj2B8QUTdgOHDtx5D1KqceVmfirjF29YsFJWGCifAMKOYt5rPj4/NHDx9/T9ug2QIKTNeaVe+7+Lw1lvbPWtPdVGnaialqOI6wcRHCx6kDMsq2Iymei1n+Tll4hDAhum43yY6pZvq1en+kqgInFhmZUJPVCJJp6WASrgrA0xmeFfiaUDjyS+nVB7cvsOfz7QubjsaOHj3+ubUFh4wcnsxPjj5s3PscfL7EySJq1qxQbrT4dSrnzby5FLPXbQ5Mn/3PbRgRBEARBEASX/PMP7I9EEp+IJoYOWbG+m1dyZhqVqSeatfwfDhyY/Ezbk4IgCIKwSdgQyZPZifGXlVJvor/5HvWiJarKjpG3zLaMrImoP9k5eeon214sCIIgCIKwRVn4X++ajCZHHljPo6sXz36q/9Yv/UrbE4IgCIKwgVjz5MnsxPiXST4UxnokT+qsZ4Zxf27ypPQmCIIgCIKw6Sl8/V89Fsvse99GPw7brudrC2ffmj3wxNm2JwVBEARhnVj15MnsxPh9Sqkn254IwHUTs7wExjybDjPAvFEbbL/5mOC0f+JMlxSYEUk/S6TUbbs++sSp+IpWLgiCIAiCsEbMPz/xgXj/9b+/2c+3XV/4Rvrmz97S9oQgCIIgrCGrkjyZnRj/kFLqd/hjFSbz4BbtPqXHhsXnsWLnJk/K0DxBEARBEDYU8y88+B/ifdc9ulXfFahS0jf9kbjiC4IgCGtOT5MnsxPjemXVZvs6uTqE50tWqhRZTUosy8P3OdG6z9/JTZ68ccMehCAIgiAIW57yyw+3B19bnHrx3B/03/qPD8unWxAEQVgLVpw8mZ0Y/1Gl1J/xx7ZZ8kSDlqOdT5xqf0IQBEEQBGEVmH9h4j3xvusf3+7nVtQogiAIwlqw7OQJkialpu0mTZabBOGJFkpKcINX7n/Szfp4siaxROIjjDLbt1QXr8tNnpQkiiAIgiAIq0Lh62/7ZCyz/yNydttJ3fiYxGCCIAjCqtB18mRmYvw6pdSrymfaGusyyRFE0Sg9uA9KiW0jHbKNIKVLJ0mSBvs92vasb9kQ5UzQfkadKUH2jidOiS+KIAiCIAg9If/8A/sT/TeckbO5OHajci795j+9ZtGFBEEQBKFLukqezE6MI03hpg4keeLhT564+2FZ/zU3efIDbS8QBEEQBEHokO3oabJSaguvPTJw25d/e3MfhSAIgrBR6Ch5EuRronzJk1LTe7w/KLvQBWGJirDHl78db4UVs//dTv+hxA1P1iywHY0Y7clu8UMRBEEQBKFLtsq44fVEWnkEQRCEXrBk8mR2YrwI0UfbEx0Q5GcCCiy50E2ipZvkCVeVcOPXNGukiYYoWVaR63KTJ0VuKwiCIAjCkpS++eOvW9HkPjlTK6daeOXa7IEnzm724xAEQRDWj0WTJzR6mC/Ri3RDfZntPlzR0dcL6UkXdNI+1CGfy02efGhNd14QBEEQhE2FtOn0HmnjEQRBEFZCaPKEEidKkieaHiZPwHdykydvbHtUEARBEIRtjyROVo968dwf9N/6jw9v1eMTBEEQVo/A5MnVBw7pB3thArsWFFlSxTJtOTzBEdY+xD1PaBX8+bDX9YjJ3OTJBzfFCRYEQRAEYU2QxMnqUy+e/VT/rV/6la1+nIIgCEJvaUueTD1wqEkCk7p5KtlB4iBf99aTjS2+PE92dGvQGsRy19fihWJe15JQYcsmWDKmF0qcStNWMUv99MgTp/6o7UlBEARBELYdkjhZO6qFV+7JHnji5HY5XkEQBGHlRPgaZifGH+9RZ47QAXVb/aGcJ0EQBEEQFl58599u+5OwhiT6b/jqtjlYQRAEoSe0KE8u33/Ibm1rcf7PhSe9yKzwqTm26tz/JEgpshIqrC0nSF0T9nzY40GEqVRI4YKJP7nJk4uvRBAEQRCELY2oTtYeu1E5l37zn16z3Y5bEARBWB5u8mTqgfEa8hfLzUkslVDgLTDRtmc3Dsv1OVmuCa7h/tzkyafaHhUEQRAEYcsjiZP1I3XjY1LAEgRBEDrCbduJWt0nTkpN2/1BwoR+gqg3bfenGyA2oZ9OsH1qj8VAooR+CFi30E/Vtt2fpUDChH7CsMP378m2RwRBEARBEIRVpfTtn5qTMywIgiB0gk6ezE6MPydnSxAEQRAEYW0pvvTQP8kpXz8sK5bdrscuCIIgdAcpTw7Qq5ZSW4Q9X2jY7k8QSylTwoAahn46wQrwZSk3bfeHg7Yc+oEHCX4wrYd+MGGHftCWRD9BhB3/bN12f6yQ/VNOAuszbQ8KgiAIgrClicQH3ybv8Poy//zEB7bz8QuCIAidEfEvxRMGQbQ8z/pQ+qOW+7PRQL6GfsKAcWs05JhVB205YcefiXg/8EWhnwDe2/6QIAiCIAiCsJpEk8P/Tk6wIAiCsBRtyRNh3cjJqRcEQRAEQVhbIvHBO+SUC4IgCEsR8z/P206WUpGEiDBcGkxhsZiqg6CWGN7aU2T702TLdqNwCVPRBMG3xycEJdgqljoW3rkTNrGnRKOK254RBEEQBEEQBEEQBGEjEeM38t0SnBbw6CRhwgnyQ8mwJEljmfvZDXx7nYwtJu8XnqDpJK+T7n6csSAIgiAIgiAIgiAI64CjPGE5ib4uFB3Ntkd6TzdKmDC4EqSbVYQty9UpmbCFuqfUqxUJgiAIgiAIndGszX1NTpUgCIKwFOJ5snE4vd1PgCAIgiAIwlrTqM78hZx0QRAEYSm08iQdsWaXY1iaDmllIWUGb8NZrkBjuWoT3uDDV8EfX27bUS/UJiReqZo92v3EqQfbFhIEQRAEYUsD1YMYlq4vA7d9+be38/ELgiAInaGVJ7nJk0NBS8Pzg/t+KJMYoR8OzF7pB8kF/CDHQD9hBI3vhY8I/SyXUsN2fzgW++mGctN2f7oBbUf0g12hHzov8D4R/xNBEARB2J7UK1M/KG+9IAiCIGx8pG1nY/Bb2/0ECIIgCMJ2JHvgibPyxq8ftYVXH9quxy4IgiB0h2UzdcfsxLjNlRUp03bTi5HDaw3f5zJztg0zxF3uPpOhbVh7UZhZLX9dbvJk8IsFQRAEQdjyzL/w4DXxvuskibIOpG58TGIwQRAEoSP8yZMLSqmxTl8clhgIopupOfWQxEea6WS6HYMcxALbp7CkSqdUWNKpmwSMJE4EQRAEQSh944dfsmJ9N2/7E7GGSOJEEARB6IaWtp3c5MndS72We5504mlCIGFCPw0kXsxPENyXhL8OCRP66QVImNAP+ZIsFyRM6KcLPiefVkEQBEEQ0jd/9pZtfxLWkHrx7Ke2zcEKgiAIPaFFeUKgfaftQQM3il3u1BmeNIm2Pdt9m1AvWKr9ZhUo5SZPZtZqY4IgCIIgbHzKLz8cGoMJvaFRmXqi77v/ekJOpyAIgtANgckTcO6+Q/ZyEwmUX+Ev51N7uMAj3YNkBV93Ypk+KyVzHpY7+abE9iFshDOjnps8GW97VBAEQRCEbY8kUFYPjIbO3PL4nVv1+ARBEITVIzR5opgCZblKEO4pkmJJkiC1yXrAj6tivFX44XWQBAmEn9GANYjiRBAEQRCERZEESu9pVqeez7zlr2/fasclCIIgrA2LjioWM9OeMymJE0EQBEEQlkLMTHtLbeG1RyRxIgiCIKyERZUnxNQD419vKPut/sejTFexVPdNialQetGq0w3cp4UN71EpljqKGclJ0Khm1WVrUNCykogSBEEQBKFbii899EwkPniHnLjlI4koQRAEoRd0lDwhrjxwyI6zvpZuzGPDxhoHJRo4yx0BvJqEHUsI0qYjCIIgCMKKkDae7rHrC9+QKUaCIAhCr+gqeaIcH5TPKKX+bdsTDEp4JDtQbtTZ9mOrNFmnk21TQoTvQiJkf5bwNHHNY3c/eSroaUEQBEEQhK5ZePEdn42mxn5IztzSiNpEEARB6DVdJ0+I2YnxIjpw2p6Q5AnW+77RJ07997YnBEEQBEEQVkjpGz/8khXru1nOYzvVwivXZg88cbbtCUEQBEFYIctOnhCLJVHCKLC+l6BxyGGtOjwJwvd6Ldp55uveFgdi7dvDMSUi6v07nzj1WNuTgiAIgiAIPUaSKB6SNBEEQRBWmxUnT4jZifHfVEr9ctsTXRCkWAlLpHRDWLKGj1LuC0jidIqYwQqCIAiCsF4Uvv62T8Yy+z+yHd8Aac8RBEEQ1oqeJU84y1GjqM2XPPmt3OTJD7c9KgiCIAiCsE6UvvljeSuaGtjK579WePVnBw5MfqbtCUEQBEFYRVYlecJZbiKFCJvoE5YQoZHIyx2HvMQkHUmYCIIgCIKwKSh988dft6LJfVvh3ZKEiSAIgrDerHryhDM7MX6fUupJ/tgSyYoWU9caWzbdhQolzDC2k13OTZ4cantUEARBEARhEzH//MQH4v3X//5m2eNmbe5rmVsev7PtCUEQBEFYJ9Y0eRLE1MT4d5StblAbI3kiyhJBEARBELYFCy++82+jqZ3/er2P1bbr+frC6/9elCWCIAjCRmbdkydhzE6Mf0gp9VH4sYYssiiLjECeVEq9Lzd58sxirxcEQRAEQdiOQKUSTQ7/u0h88I5eHT4SJI3SxcebzeqvyVQcQRAEYTOyYZMngiAIgiAIgiAIgiAIG4GIvAuCIAiCIAiCIAiCIAjhSPJEEARBEARBEARBEARhESR5IgiCIAiCIAiCIAiCsAiSPBEEQRAEQRAEQRAEQVgESZ4IgiAIgiAIgiAIgiAsgiRPBEEQBEEQBEEQBEEQFiEW/pQgCIKwUvK/efsdKmK9Syn1oFJqInR1fGy8ZfFnJpVSj2UfefaxttcIgiAIgiAIgrAmWDYP2AVBEISuyT968NNKqQ929Lpaw/s9Hm17WtM038sRlkQp14JfF43MKaXek33k2S+3rUcQBEEQBEEQhJ4gyRNBEIQuyD968GNKqY8u+5z1PnnS9nKlFBIqB7KPPPta2zOCIAiCIAiCIHTNpk2ezE6MX6uUeqjtCaVUbvLkp9seFARBWAb5Rw++Ryn1+KKvrLKESMIkNniyIxVve8mq0r7tuewjz+bk/RcEoRfkn38534aOAAAgAElEQVRgv7Ib7w5aVfb2r/yXtgcFQRCWybETRxC/HOjy1c8fPXx8tu1RQVghGyp5Mjsxfp9S6rNKqbG2J7ukwQ4raoW+djI3efLBtkcFQdjW5B+9/RNKWf+x7RzUm97vsUDFx9rQYPsRrDxZiqHsI89KUCEIgsv8CxPviSaGfzUSH7xjLc5Kvfj67/bf+k+/0PaEIAibDpPgeI/xd8P/B1fjGOYLffr/A/0Lbc+BRsOLiaLRZtvzKwCK3s8ppdAi/TlJzGxf1i15Mjsxjg/fRINtP2qFZzm6pcPkSRB45Y/nJk/+ecBzgiBsUfIffsu1KpdkbS4BXxxbJ3lCvJB95NluqzmCIGxyFl58x2ejqbEf2mhHYdv1fG3h7NuzB5442fakIAhryrETR5AIeVgp9b6g7Varnqo2kai1Pb8arGPypCvMfnzhwoXcP336R/5SOiK2EGuWPJl6YPyiUmqXWiSZUTJ9/ulIyAIhMMG8CnIQqDS9Y4yxBE3QflTZ+Uh4y/6itAIJwtYk/+jBx8ICg45pb5MJp1L3nkp2MfCMtwbx7+1u1hGKrVRTDWc//NxM2BKCIGxeii899MxaKUp6Ta3w6s8OHJj8jHz8BKF3HDtxBIUTeLi9W9nshsjq/L6wXE66v6dSlbbnV4NyydlmKt3d9ubyTtJlMBucdFlYSLu/80RQPF5vWzaMciXhnY9kNWSpNj5frcY/9ZEHv3i67RlhQ7JqyZOpB8avj1rqlbYnVkAnahJapMoSJsmQZEylg2UCuJibPLm7/WFBEDYT+UcPPq+Uus371lDBapNOYN8lrslrlV1wEz1IcHRiNBsEV8s0QpQzpF6pNzAmeST7keenA9YkCMImAZ4kif4bzmy196tRvvx3fd/zt+9se0IQhDaOnTgC1cin6/WY20ITi3mxSbXmFHsS8dVTjczM9ru/D+UKbc9zKhWv+JRMLr5PpZKXuEmzREq5zBMYbB2UFApJFNXqXpxWq3n7kUmX2rYdClt3o+n8vlz1C85bxFLFSNT+tY9/3xf+U9sCwrrR8+TJ7MR4M+gOpMa2E+9he46fktlOmm2jzG5sUkskSZZSsfgQzxRB2GS0TcvpRgnSCxPYsHX0oiWI1CmJLpIrIWQfeXbxL0tBEDYc5Zcf3jYjFMUzRRBcr5HHtIKkA2o1liSoOr9n+sqBL6wwJUWSKSmoXYcrNPLzfe7vEZaU6O8vtq13rZieGXC3NDw0v6bbrtedOCwW46phL6yam8+4v3M1TH7eSTalU957EqJ++XyjEXn/I/f/kyiG15ieJE9mJ8Yhp/y3bU8wtmjyxCU3eXLxFQuCsK7kHz2IAKP9IiPJk8U4k33k2esWeV4QhHWm8PW3fTKW2f+R7fw+pG58TGIwYctz7MSRFbcZS/JkbViD5Im7Dd92/uDo4eMPty0s9IwVJU+uPnDo1aatdGAdZ0kJ+q3E+mzSrM+mGrJNul3gV8AwE9nlGs2GeJoE0omYv+E7lIilrh+aPPla24KCIKwb+U8e+F8qFnnLsrYf1i6zUcxjOdSW04mJbIklcdJLJoJkOo8gbDBK3/jhl6xY383yvnhUC69cmz3wxNm2JwRhE/Hxf3jnjqYd+WfbVruyA96NNU988MRGUIKCe3hY7I6GJ0pofUXWAhPmCcIpFDKh21W6pSbl/p5Otydmpqez7u8DWW8dcdZSxFtn4j1oK2oaI9kmS2C0JDZCmJpy9nVkJB+8wBLYtheP1WpeDNmNwW7Y+eSfgUjEi0kDki1o4TwgE4J6w7KSJ7MT4y8rpd5UYJmDvmh78mStWAjYjzo7rjo7RK48WcFEnk64Ljd5csv1GwvCZiP/6MHeydi7SzgEw/1RuAdJNz4mYdD33hKJ4WXu899kP/zc97c9JwjCmrLw4jv/Npra+a/lrIcjShRhM3HsxBHjwdZOmPojiOVOmlnu65pN759ZJOLFNsViqm1ZkMm0J1I6gSssbHOX2Wx4215g2+O3tSPD7WoTrkbh+5wbDPZjIR+WMA+WQsFLUvVzBU+A8S4lnZS2mPPOedi23WWDFSaB+7nYvvp44ejh4zJtcRl0lTy5+sChn45Z1n+nvyV5sjTSziMI60P+128bVc3mlWW31wSxvZMnmuyHn5PvNEFYB+ZfmHhPvO/6x+Xcd44kUYSNxm986e0/l0pVf7fT3ZLkiSRPVil5EsT7jx4+/ljA4wKj4+TJ7MT4iqq3nUy2oWXCnuc7UFui/SasrYcnTGy2xljAOpY5jSeIz+UmTz4U8LggCKtA/tGDaCd8tWXNvZh+w1t4eOKDr6+b7wqejOE+JUFtN3z/+TZiy0y6LHU++PH59kfMZAVhbdlORrC9pl48+6n+W7/0K1vrqITNQpBPCW+p6evzprlQoiQsSULjdlUH7TW87aVa9a7xfHtLQS0rqoO2lbDpNxxKAuSZ38dyvUiKC17CpGF7cVBfxmsD4skRF9a2Y7NyP09m2GwZmkR06XLOfSwe92JBvv88CUWtNrW699hS04YUS0jxVh2eGBkeDn4fwhJZK0T8UwJYMnkyOzF+X0OpJ90HQpISS9GN1whXjQQlNRaDkiZ83/gRlkN8WIIosmX5bqSXmUgRFYogrD7537jtu1Q8+s11O9XkhbISH5S6uTDzxMgiyYyOCRqp3AkBr5MEiiCsPqI26R2iQhHWgt964l89pZS6Vy2iElgufOwvJ+imPMwng0MqDJ4A4H4kTRZ2jI4G3LSHjP3lXL3K/E0GnMQNV0Z0knQJ4uIlL5nB79F27fRsPaosgUTmuGHJI65I6WMKmaVUHC2qEK7aCTkfK6XJEjQRtr2gkdDFkpek4yOX+bIZds6jUWef+ThrH5NHDx/f9lNmF02ekLdJJ4mPMKVHLwmb2MPbhyixwRMwK1SNdE2e9Qll2L0PEkGSQBGE1SX/ydtav9SClBk8GcD/RZbZBSOoLafKAqHeTbQJJyBpsSLC9p8mAHXX4jSXfeTZXNujgiD0hOJLDz0TiQ/eIWezd0gCReg1x04c+ZhS6qO0Wq4A4AavzaZ3zeXJDN7isty2liD4DXKCGYguLHjJip075/T/g268/ZTLXvtQKuUoY3gbSjLlqWXi4TffmrAWE34uuKHq9LS3f7TPnEuXBt2/BrPeOeTBYFBiphO1xlWjvskNekqfTpJis3P95nXe+eSfB27qGpToCkt8dANPHhWL3vvO94mf81TSOUeRaPC5CODjRw8f/1j7w1ubAK22w+zEeG2x54XlYdqf7s9NnnxKTqEg9Ja2xImwmgzmHz34oewjz35azrIg9JbSt39qLhIfzMpp7S1of5KJPMJKOHbiSHtbsCBsTz567MSRj7Ijv/7o4eNbfuJsoPLk/P2HmmgEi5mEXKLLimepSa0z3mNhipVes5RvSjeEjSrupq2oyirHvvP4i7nJk3LTIQg9Iv/owc8ppd69Ic8nV3zwL8awMchLteWEKVJ6aRhbYZWjZEge3bZV9pfFQFYQeon4m6w+1cIr92QPPHFyqx+n0BuOnTiCeP2DbSuzAy5/rF2De2A02cjaStlTBPT3L64q4O0kYf4g5G9SLHnqkDRTgiw1FpeP053Le2qSpYxMO2m5aTGjNeqOWebdwrfBW2CiUW6dsLiJbZiSpRvC1kF+MYlEsJombCR0zChLuEqFq1u4hwpvNSJfG75shB1/JuO9r1xNEtaOtByqVe9cdDNSmVMoZP7qY9/3NxszJl8hbcmT2YlxOO2kw1ZbYsunWIAe8PWh5lk7TZInUkISG7R08LOtHiSZJfxKOqEbH5ZFkiDLAq1GCUvduPPJU99Z8coEQVD5X7+VX2m8E0JtO2EJBw7/PqTlu/UXWa2JN2H0YgIQsTxTXWnfEYQeUfrmj79uRZP75HyuPtLCIyzGsRNHcEc7uMgiLVCbBb/RTaW8hEJYe06ZT9MxN+g8WdCLG9kWWMKnYdpWwibsdDLlheAGtQvspp6HVbS+BjNRHRubcX8/f2HI2x7bp3jC23ZQWxFPfCTYshcueKHJ2C5nO3PzXuKGr6vR8I61UvXek6CWGZ7QGsp57TxBSZ6wlij+eUinvYQIHQv/7HC418vYrtm258PgZsNJlgjiiSLaf54Q4ud2YMAz4+VtR51s/ujh41smTmyJjmcnxh9fLHEi9JaqrV5eJFckCEKH5B89+GU5V+tGx8GlIAjhLLz4js9GU2OSOFkjoPCRBIpAHDtxBDd3M3JCBKHnDB47cYSrNYaOHj7eeeZng9GiPOlkHDE3Z+3vQv3RjWqkk2X5ji4E7FO3ShEyo+VGtKUOJvMs1SbUybGIiawgrIz8owftnpurks18ZAVTc4Kos+pNkJntasJbcXg5KMgotrvz+fnsI8++p+1RQRA6Rtp11h7brufTN/2RJIC3KZQwCWvZILg6JMXGCHO1hWuS2sGUlQU2Zrevz1Oh0Khibiza319se14tMs6YuHLV+1hbbJ9GA0YOl1n7TYq1+/BjOX9h2P19j1GLVNl+clVMueytb3rGUzykUs4yA6xVKUzBcPmyt/+5nHcOaDtkyKr3o+rFUjt3tBvKhlEoeHoB3j6VZ+oUan9qNLw4qOUcLQFXDvH3Iey4yTyWL8uVQfG4d575KOlE0lvfAPvMLMXlK955pnPX8rmOt/97UL52LBrtzEc/cwUW339uMgxj2kikMfqrR/5+qm0DGxg3edJJ4mQ1CJqUw3MM/Pk4e5wnK5Y76aebRFDYstUAz5iwFqAyuxmh3TfL/lZu8uSH214gCMKS5B89eEAp9Vx3ZyrM0YjhJjl4C1CPEylrTa8TTAwZXSwIy0cSJ+tHbeHVhwZum/zcdj3+7YivCt4C+Xg0m971frl+ErxVYjC70PY8uHKlPXe3gyUAeBJkB098BCRpummz6RY+cpjGFvM2mz27Oxft8GRUYd5LJPFxyBfYuoeHWbuLeX+C2nf06y56r7NZi9Ke3dP6/0GTbZSvFcdm3TeUyOLvSX7eSwAsFLxj2bXL86ShpENY29VVlvgYzHrJjljM2ThvAerE04XvP7XltHxuQ8ZKhyWQiLDzxSf5JMyxhrUokW+MWsQ7Bhw9fHxTxJH6aGYnxu9re6YDljJO7UT9sVTSohN1y1IJE76fNfYPohvlTBhBiZKw42b5F3c/jK3ALyulJHkiCMvj4e5f1f7vVtML/xAad5zqclhZmW07SAnSDQ32Rce/50K+h5fNWvu7CMIWZP75iQ/E+6+Xt3adiPdd/3j4RUHYKvg9TLivA7/JDDI+LTKlSIYpRVoUGwGvC0uYcPhNOd3g8qr+jtHOlRQ8YRJ2w8or/6R64coNfnN+mZma7mSmpuTvkstx1QxTWLA6U4WNOB4YcM4HV+9w09PWY2kG/k435Tz5UKl4xzo64iUweGhCSaodIcqUONsG7afGvCd19p7wxEAi7n02Ll7y9umafY6Y4spVL6mxd880208vUcQTGPPz5HninaP5grcNbi7LExiVMhuDbI6FJ7cyGe995XX/oCQUVzgtFL3fIxH++fIeJw+boHUpn/nvYiCpaVQv8x+e+OKGnTZHZ/rJtmeENWV2YvxDMn1HEJbFg3LaBEHYrMT7r/99efPWl/zzD4zL9J2tx8f/4Z1/0NdX+t+3+3kQhE3GwG9Ofp9t1Dv/19HDxz+0kXZft+2EteyQl0hfDxQanEqIMoNaYwa63F6QAJ9vI8a2sVyHgTA1CcFbh7jXcrzziqydmzy5yXsCBGHt0X4ni9GNOmK12lrq7FuBt/402eO99lYJgitSuBQuscQ3Y4uSJWA/yzWV/eg/S+VWEJaBtOysP83a3Ncytzx+53Y/D1uB5Ri/hrVWEC3jdkMm03TDUm0YvGVld0g7TKAvBWvNCBsHzCkbVQhXOZCqRB9rJHgqC7Wy8NamuTnvdTt3euqOMlOe0HZ4K0ilyhUT3va4FwyHlDP8feDtJGGQDwtvbZqdZYqOXZ4ShKt26IwuMJVRX8ZTGfGRwvxzEtTqxX1a+HsS9PkL8iJZjCAfnenpbNtjSqtbglulgo6jRWHCHu/vwlclbNKUS0hLUQAbwmg2Njsx/oEwPw9KmnBD1l4kUsLMVSlp0q2HSdASfBs8kRIN2fZSBCVMFDOV5YayPNESD36ZCzOUtWTWpyD0CK5JpO+QsDG8PTeatdvXG+aVEpYwofahsNahsGTMUvDEB8+XVI0UMyyJwl8X1Nq00jYjQdimFL5+5P2xzLXy9q8zkfjgHdv6BGwBPvr33//tdLpyI4nqY7FwbwU/QQkTDr9R52aoYeNkl4K3DAUlT3jCpMRu2nlL0eyc135DrT3VmncND0uYcGZnnQRL0/YSLbvHvBv1oNG7KsTstFr1EgNhbU7zxoh1hiUt9uz2tsfbUyrsxn942LvBp5t2njw6d84zs923z2uN4dB7xZMS8URwa5Bte+0p1FLDfUn454Vve2TEa/ehY52d846Jt6/kmNUNXx8Z5XKfl7CkC08EBd0NJ1pGElcDfw+Ch6ZhiamlWtZ460806p3PeWbGS+1RPIHG39dMxktAmSTVzLETR/D/F44ePn6gbaNrBPb2+9dr44IgCD1gUik1ISdSEITNRiSe+zl50wRheTz65P82VFhIB98tC4KwqlwqxtSTl2LT31mI6wxSJB7s9VcrsCSI5SVS7KaTYLGZUMKqO4mkVCpWefeb0smbR9oVPEqp25jp85qrUXCUdy5lnLpctUmYomUpOlGb8Ck33LSVVB9cKRKmdFkKrmoP2/20q5Zhj3WxvbDxxYIgdMyn25InQd8hXG1SawQvy//t0jLxEDVGGLSObr93+BhhUnSEmciGqU1I7VJkr+tPtC3WzqIyyVa4CmW550gQBI0oHgShe46dOPKYUup90ejSpqy8bSTJxrnm5z31B18HmXDyKzgf18pbF3jl/+rUgFnWiy9Ghj3zUq424UoKPpGnz7Q0zOU9VUm57F370+xYgoxkudLg0iVPz75rV/C9ZTbr3Jjy1hN+XrgR60C/py4oFP5/9t4FSrLrLu89p97v6ndPz2g0GkmWbfklDxebOGA8KwQnYAjBGBKIwSTcBet6EcA3NwohxjYGG5HBdsBwL5AEcxPIJRiwBCQEEozBDHYgY1tYxpZG0rzUPd3Tr6rqej/OXdXn7Pr/qmufqa7WzGge/28tecqnT52zz67z2Ps73//7fNUB43uPHJF91Ov2cYeJ312C2oQKIRqOsp/bHWnHlTVfkXIY5qs0riV6/K16/m+VSctvGVZ6kkiwJMjfxpUrYvzKEh8e93BCjv85GhWFBn+fixdnB5+PHpWkXipODHo96ece+nwdZrRUzkjJkPyuYQom4nKQVDQ9LddDX6Xy5Hau/tH1bLp5Sfo8mje/cW/GC5TdHsaHLj6TVIkmURIVDa4fjiuDpMuu4yQ/erHrOBeDY8S8/4GUV/379zezgWrLqFF+5Z+97uMHCJCYHO76V71mOeq6Swf58jgfkDBvk5YlsteZzB/kuoEkSL23f/JnXPLQfjD1iU8pk6JQHABjfU+cPYRJ2GTfVtpjKwHaDxqjUtxdhJW4HLQUx9bmMAx5nvT2/73xKBUePqOVhwrFhFC/k5sHqfs/omOwmxx7E3OcPf4ZLH9gqcA4cHJqiASW57RBkpBQSIGMaY9JHAmLEWYZgylTmNRXxRAwWfhJuPCO4PaYtmMjD+jHUsOEOwFSaH3D39/igpAITJXhBP/YsfWRfTy3LKUuTKA5d25+8HluTibwG5vS5nTK/43zeSEAWFoSVk6yEaTz0PuDRBfPFxJd29v+Zw4FWZ5TA1FEsoylNgbDJTdyHpFAunjJJ1VMWs9emLIeZ4+3jA1lnFvtoUQl2R9ThEz7Pvx4obrR8mu5ohgftspyvsSzct25MX/bnbL0Sw8T6sS09IXXRZ8n/XOtXbWTX5GYtDlalHOgs+Xvx0V90ffe3XUSUa9Petbe+3d/J+tcR8SirtujQiSNMXskmCiEPU1shAnRxonGIKowJUg7ODM5krBFAV8PGKKEqpEwwoTkj7k/cCoWRqTYjG3pJ6MzD4XigOgTI2GEiMF+1BE9yzzmoPegMJIkDJMQJsQkxIfN7PVaYKPx7uuzYYVCoVDcybAZwFZAAORBAPDtuvE+CXvLTlB5YciYREJ8IehtEoOSoNWW528uNzoBpBHo+oZMIA/D02QoFjeA58mzmqREmHGomUO225yQC2GyuSnbYFSvifvNpOVYaehZrdGEVMonDGEQicg+wib7VFhEAs+PVEpILhJXJDOII4elvy4GHiMkDlYui8FuGsoSGuFGg/6gGqUJw9taXebbjG5OBxG/GZjEkmDqtGUbhvhwdqOIfSJic1O2m0rKucO+I6E1Mz1KaC2vCNl0eEnIps0QXxjT5/PzQuYUcJ4tg7zqK3jOrqecXz0bcTw3MONNuNlIMAf2MC8mWUF6rxeU5cSyMBvGrLddQekNhtSduv/7xIvSR5EQr7/2OiKogzZ1SnJM//eTg+9lHlv5ptJbX1IqXK+Snuf9ulGhUChuAnyd4zj/RX+IFwaFn/qCxqwrFAqF4prh1OmTfUPIz2iPKhTXHssNx/m9zbbjXMjcdr37TN0pvOczuwqdrZ//zDc0vvNFvb/97q/9vU+OrHhAuFuvf+2lPqlnvj5J0k3T9pY2RFkyaYLOJJhk25Osy7IdykZ4eLZjDVOesL9s39OyHYXi4BhbutMcdYffBRUfNmUGy2kYLRwLUbJYru1Q75Jx2M/3bOk31xOjZUJ/v/DwmY9d/x0rFLcftGzn5oGW7dwcOHX6ZN+34Jf3NsZWWnOtYEsAIcJKbghT5hOWwNPtogQhpKTIqF5YhkLvj3JFJrqFvCgUTFkOlTce4l+pJmE6zOIhX63AiOAhVQIUMlTZmDZdWUdpCvY3MyN9mM1Kf5w77ysijt9zZeTYnav0M5UZphyJx1etSulMHgognifRQNUSgS/JBahiEgnZH0uJTAnSxpaoPDgnrNXj+N6oyIG+MExWKpel70ol+d3m5naCXTAu2J6iROVJLjdqrDpcde7/n1Ofz7S7EXfQaA9zU+NTEklJf3agGuk2kNLDOe1iMfi7nEdRjFldjJ1bZdleYsa/7hqrdkVValFKlLhO0pQBYR/NFTlXE1SyxKUf/8mR0jv+9Rv/4IMjO5oQI+TJjiWW+GZ5mpDMCDNlNdG/NGJt4+wJ81Wxle2QBCFsniZhBrZhMEQKSRQlTxSK54fye1/pX1i2azCsbGc/Xig3M0bJjOFl1FamDig27KCPSBp1uk7hRz5n6WyFQrEfKHly80DJkxcWYaSJAT0kYiAfbJPGSRE2aTcYMl9FucjyZVluyjToNcIyGhIYNIlNg2wxhqIkQUolKYVIpeXZzjKMnaq/vUpFJr1TRemXK1ek7yKIy73rsF9qs7IqZS8exgzT07INlu0Y0KOEx80hGIkU4x1DQqWFEhh6s6yvSx8dQnxyK4i1pYkszwf63rAdhnzb2pLtsvSnhWjdVZjDzsz4JNVweZiUM7EdQ6VeljjgDZRP0R9lqAwo2B77k+cOSSoH62xty2+8U/HPH1Ny1H/H9u/OSx9FONaF/12n6a+fmJF2dulzMiUkVmtDSJxY3j9H2yijSd41i23g3MF82Q08Tzqb0heJBbmmSNx4GNd6QZsjKFvv4e8sL/JA3LiBWe0r8+5H/+y7H3uLc0Bo2Y5Cobid8C7Hcd6jv+iNgRInCoVCoXg+GEeaKBSKg6FPmvzSkz7xEkneAGXyLYLHK963ZE99nffSqdhv/+X3PPbNk7Z6RHkyCcal7UwKm2rkoG2atD2279XBjqVtb7KvMVR5olA8f5Tf88oVJxU7dF26kooOKjCoUrOV/uwHB031Icw9mfc/puq08EaN99lJTGeDfRR++DN6v1IonidUeXLzQJUnNxbv+cOv+6Fstv6Bg+yUb9nD0m1soBEr3/bbSm3abfk7yyaY1sJ1TCQyy34Yk0zzUqJaFRWDMXnd2oIhLlJlEij7YKmNMaZdXZMyDqbjMKqY5qomfpipO0zKubJewDaguAkMTBm9S4PaONQ7VKwY9RBLT8LUGCsr0s5iAaUjQeRwvS7jlniC6UXSn2kY07bb/vdY/jU9zdInKDNQ7mMMew8vSR9uQr1iVB7+Nqi+8T8fOSIlQDxfqjWqi6TNM4HaZ3tombSzgv11YXjLUqMrW3nnF9dSjodydRcRwZ1N6f/4odG4EpNm4+xRqXhdewqUiSJuQXkSRekPVSPxKem7blCaHoUqulOR6yuKlB6WwXg1/1rqQVVChYwLooipQLa0oL665XXz8X/2B2977KdHDiwEu63dTznMYMf7IEyMr8ik3iY20mScT8hehLVpb9v2ts/2vRtBmCgUimuLwrseXyo/cmIkzjAMXhUSz+wYZj6UZBh3r7Blbe3dBPWl3uiq+7kfWe5jQ2QO49RaIR4wBvR6IbHT7vVvng+OrK9QKBQKxRgYI9hsdjiNhuUWVqBcgYRJ2OR7PZj4z81JCkmtBi+HLst05RlnSI51+HksLQ2F/QwQj0ubV1cLwXaR2mlJ4NkLem2Y7XU6+ZH1nN24WRmDbCC9Z2ban7QeWpRjXV6WIVBlRyasS4eYXOOXVmxtSWnQ/Lz0LX1ann52cfDZDAmY/PIsSniOI574yrq0o1T2J/4bSKCJwoMki9QfRkJnQFiZGOFEUvqNZEwN/ifNprTflCstLso5cvGSEDQZpPSkM9IOE/G7jtSj6WkhCcLiiU2qz+aWfC+fBwnUsYzX4HfDtpM0m4nL2I3XzOXVqd33Y7+y5u36jbiO5zS3pZ2MC3Yxlu1uC6Hgtf1tR3JyPrgY/0VyQkR0S3Isbsbv8wReKnZrIEGyiP3eQVT0rN+msLKebgXkVkLuFZGcv73OFTnf41NyfCRxvDTGryhBj+T9Y4m0O86nKs6pws9+46ny92Tzw7sAACAASURBVD9m/1H2YLf3xhEmkxIYhpTYx3TBKXVkrWLMX4seJdwf/VgYIzyJAoaESdj2FArFrY3Cw2emyo+cOO84zt3WA+myBvIa+JzUMOgzBrQJbjfk/kKCIjaUEz+yaigOahhLIsimWOE90UXb4tHpwsNnRl3RFAqFQqEIwY9//I2zvW5kPYNwD5qhhiIgTZogWpLwk+DkNcww1YCqEYLtMOqAXN6uFGlBPUD/DDdQK8SifEkrz3gqXa5cEUXHXYj4NaazmYw81ztoG49pBhP4ZnNU9UJvE36PJMfhJV9Nwv4kAXCYagaQIIWABGjCJ2TpkExkSzC2pVIinQom5/DqSONY6+ije2Aqy99nLfBvoRKkgd996RCWQ/mzsua335Bczq46R4iI6WkQMNheMhmsw+ERvFlIAA6ZuQakSTyOcwDtcYeyCmQdY+gbhZInC++cBkgl045WN+L82zV/g27UcTqBMiN9RMx/qRmJYIZu1t1dHoxbSZj0QDjE4BFIL5HeTjM4JumkWJrHKgdLAsZ8j34lsSJuEBgjDxnbBv/Gsa4HZTX3TcPYWEHW7wTRx1TTZH/667yvmI198H+87bF3OFfBAfXlCoVCcXOj8PCZY47j/Kz+TNcOhYfPuEqcKBQKhWISnDp90usTJ9ppCsW1Q580+cmzM84Hnh0tvVEcDJ/a6PzQ1AffZGdZA+zSV+MUIkyX2Y/Kw6xh/+swjNrEQboNE3EgDnHSUS5//n4rB1Wb0IfbC9phS+C5GibpI4VCcTAUHj7zT8vvfdWPOZ53ZUjZwZteLIRDNmx7WCQxwe0lJlCycN+MRh93T+O61ySeONheJySKudaqFd7z+ezI1xQKhUKhCMGp0yfPOY5zzP7XfZTq9NUdJf/Rk8uO+pLsBX035ud9VQXLJmamKyPfcfaU/iwE39vYkEdeEiUDpbK8vV5ckHcJJu6YKo8IFApRLJ+dHY1DdnYVD0ZBIuUKTAJiqRH7rlwJyiwQuZzLSX9tb9sVOc2Wv7+dHfk7S5uYMEMFifHjOLIkPij0P2EKDH1Fpov+ca8gpYhpQ/RsyaRlORU+xgPm/CVJc8mh3IdqmSi8V+4+uhEch5Sk0BeGahIuN5HQz5xbGCzz4JsyNSW/5VNPS2mT8SnZ3JD9HUM5Uw9qmmZDVD2zs/45uoaEJPq0VMopp+05zq9utJx4cdaJmJBFlL6Yspw2ynZiKJ1xoARJFKV9sj+sChVHE14oiYJ8rxuk9DhRuU6Y2hSN28fZpvym10L5PFXRCaxL1cvIlhzHY0lOXLbRpL9LHqqWYD9DiT1b/rrtbjeZ/5lv9Cr/1F7Gc1XDWENmkMDYT9nOONSxwbSFwCijlKcQG/27cxUSp2MhM2608WtYmRP70XLYahirUFxHlN/18mq/MnN3D5kJCIewKGMYcTlJixdKWElOGJCPPzZSmOQJ2zGOSClh8FlMjvx5CAMZpfu6wjs/9+cjf1coFM8bahh780ANY68d9pugsx9DVRtqMFnNhJTi2GD8MpyQ6F3CZgbrwHjU2eNhYUxe04gTZolFdUe2wZIUGqMab5X1DSERkhZPFGfPZN+Uz0RQJrRdTuPv0o7j2Peg7SEGvF86K977L77/8uCzKVUhgXPh4tzgcz4vv0mjLv2Yzfm/8eaGTGIHZTF7jHmJQlG2Z6Zx6yC3WAaUgkksy59MSQ19XGgSe/GikDEslTL9xXOAr74ZR83fx5T+NBs4B+qyjXuPrQ0+b5cYjSzlT3v3UW9HnA98RtrWY+wvPpvyFK/JknI57l5drrX4nOx7YOyKdSOpOL6H7Vn8Q2g028PYOYIxMMtyOtVW0F54qYAEiqHEx8N8uhV4ncTSIeNY9IXHz2izOZFItPTaJAD9f8pvf3TkuTBmhK5QKBS3B/rKifKPvXLe6Xpr+pPuCzuFdz5ud61TKBQKhcKCfonO6FKFQnFQ9EmTU2eCyf7IVF5xPVH4ub/n7SVQrqo8GYcw9YfBfgxjrzValtKfsH1XIQXJ2qQgNwDso2lVnigUNwTlR07s663YLhjNFhZDPInKZD/rGs1kJOTvB8U+29n3NhlZqFAorjlUeXLzQJUnzw/jSnTGgeUpMZRbmLKbsJIbYmdH3mqb+N3LLBGBEsHFPKGQH407LleQ3tFEmQNSXqiUmJsdVQwQDZirpmDQurYm7YsF5SJhx0p1RA4RxiaFJwEVBxN0qDbZ3BRVixsYlW5vy7o9xDknoaSIo5QlFyhIXCg+WPpDpcvUtKhGNtYzwT6k7/MoL+L2qPBp49yYmqqPHN+xu+12OjS5LQcRxseOyrqdjrSTfVCDQsSY6jI+en6eqUaiHLob7TBqnjIih/mbVdFfDaQoZQIFVr+0q9GNOB9+KuF0UdZCRUcsA+VFlMao/rEYU9TdP8Ms1UV5uYu5vFF3tNbk+IZMYLE/k7ATBm63S1PanGyjE5QVxRBf7EAt4+EapSFst+FvLzEj12gHapowxc1QgKUp10F/dury+ySZTtRoVda/77cHF84uedLseQPyZJKynArKa/Ih5TXjMAnB0qEk6QWMER5XdhQWhzwOWrajUNxYTESiXA0sozHlNywNauBGPlSSg0ueckJDmvB+vB9PFCOpZPkOHji7McMGllhmJU0UihsLJU9uHih5cjCY6OH9fpnJKSw9ITxM4F3Xvo5BD9HA1RpKAoLlBfiHcH9hpSqT4PwFKVWZmfH3w/IjltFw35zU0yvElHgsYHJebyCtJm0vUTJ+K4mE7LvXkz5sobSkXJbJfCxo08wMo5+lXxbmZfIdi0k7zwWJPamULNupwe8C5MgUSm7m53wigufAxoYIXFnyVEGZ06EF8VYxREq1JsfRQGkML+IU4ocNOccSnxra3ARZk0BCjpmoMv1mpyq/yQw8XWan5Xd7OvBIObQgfcs0JGLtipwPfc+daivq/OvPyvENxfRifNetyWQ/CmKjXfLbRAKD5TdRptSwND2Yvw75joQBY9Z2EFtsoocdECO7y0HcsPzGxB1HUBLP9BtTDuTsiSU25JCTlGPisbbgc8JSnOSSEF2DEiW8VGyV5bck4tmU88qs89E/eetvvcUxZTv7iQO24aCECVGdYH9hxrUtDD0mMYG1eZDQDNZeeWc3qiEmIUwUCsULh8LDZz7iOM5Hyj/xqlmn56xbzV7343lCUiJnYePx0HKqYNWxipsYE1WMZd6ODJBc7s/mecJjsqtNPld4+MxDI0sVCoVCobgKDlKiQ2VDFAGqNUyGqTxJJEbJk2GfiQ4+y/M1nws+Y7LMGF4SJtx3JmMnKAxMlKwTonggoTI7I5MxKiWOwNSUkcLNYDK4ti7qEJrg0kR0Dqaz9YA8oMcKjy8N89VMmt4y/r6XV0T9QoUJFSTbJZkA32PxTXkK/ij33yfV0c+ek/5IpXySh/4vVO9swaeF5E8Kap9y2ScJSGbQUPUwTGxLJdleo+4fS74gfdFANPLRu7ZkHxU5H1pBH/B3oHImibZdWhZl0HSxHrQBihwcKw2Qq1W/P/rz2Z/7ov85moU3C8aQNEAlYUCCxSgvGAtMwqRbkvPSjWKMaMgTqFja8DGhPwoVHYY0MWTI7p/z0vceCIwufFOMH4nnynlGwoTK79i8XBM2dCqy7yiOO4JttDek7wzZ1IVihf3J8X6/nZ/bcb5l0BbL/hUKheKOQuFHPrdhXliUHznxMcdx/t4dcPzTGjusUCgUikkxqdpEoVCEo0+a/Prm1Uk7xQuP2V/4h+c2vvc/3fO8PE/CVCombeZaJPPsBzYFCUt8SIvHr4EqxFY+dNBSHW5r7k8+rZIVheImQvmRE3/s7LS+etAim6rE2eMlYqSMKYsK5HoA95CBSoaSSyhdnGz8ROHhMzrgVShuEmjZzs0DLdvZH06dPtkn3Yv7WZlKD5N2wmV8fB20dIZguY+xDgsrDSKoXIhERi/JMD+WdShETGQt/27KW/qIIzWHpUbz83Lcly/726OygeoWW8KOg/QbKk9aTWnz7IyoByJImNna8n+LJMpvpgooLYFqh0lFRtHB9Bj+lgs4pjpKY0y5DveXgk8L+46lPUy/Mek97TY8PqAKaXdkeS4r459k0v98/jkp3ZibEgUGS39YjmSUMdPTiOnFb/nsBVGbxCLSjnuP++qbUln8PNpQnhSKdafajDj/5i86jkd/u/ioroHKE3Z0FwpoD/nCqUO+koiqEW6jvSNETQSFTrF5X1nSZrwvFCtDiT1UegTreFBuMP2Hfiy9CpKTgvhkqkO8uEUB3j/WKkqUsqMpOy2U9USScl4yyae1LOoio6JhiVJ7VVRLuASdxILc7ja/49fc0V9oApAwaYXE894IsFLHFlXcCiFSxrWy0uUxoRMt5Mh+CBNbZPIL6d2iUCiujsLDZ95gVig/cuKe/nPS+gWWw5jPLZb14M5Dr5Fxccfj/r67DsqKRiOOP1H4sb96w96FCoVCoVBMglOnT/ZnZFuTfCeBkhoDTs69kJF4G0ae8cBrgwQGfTIWF0VASX+UtTV/kpyHSacxkXV2TUGFDMikR2OLGRdMM9idHfkeS25WgtKXw4eli5aW2DbZNrdR2ZHJnfHzKDDqF54nXZSy1BEBvLjg76fZkjZzgl9HeUo+hxKKgDQiebS6JttYXEQJDLxSjGEsPUVI1uxUYI4LH5NI4JVpvE+cPYa+jYZM1Pm7GeLD37f/G19ek3Ngdla2R7PXWk3OIxMBPFuU/lxYkN/nWRBdMZQulSr++vXLMoEmSXf4kOx7ZVXaZIyOOyBzTOlTX2Tw88/4+4hkYw7pvV4wdmTpDON02ztyrjJ6N5aW424GREJ0aBuIH8b2aAjbrYx6kAwRH4gRjk6BVAnID5dl7iEvEIfKcszXm/A5IYfA9vMCMsc9VDokfc9jYnwySZDWlk8Q0TiavjEuxtytZSmzO/pv/89fGxlpKxQKhWIUhYfPnNvLuZYfOfGo4zjfOLLyC4fvDnxcFAqFQqG4Jjh1+uQfO47z1dqbCsXB0SdNPrruky1Ruwed4iZHqf7UP7xm5IktqrgONUra8ve9MOaxKaxLVQkVJDb1hxOi5AhbdxzyB4wvZjuJyCSyF4VCcdOj8PAZqzdK+Z0v/2Unl3jbYAHiz4YQpiYxsP/9E47jvLvw8Jk/HvmLQqFQKBTXEH1TWFNCQbPXeIylDUgDQelCBkal5m091SFuSARDrSZvgIsFfz/1OpUPosxgPDHTaGbn/DfLHl7rs1yGRqXVHXkjnQ9UH0yMuYI0lPl5URoMw3/zvbYm68aQ2pJOiXqijhKRxQVRtczN+uk2NGdlOwpIa4lFUljH79udivQbY3HDSqIKwTpD5UANUcVQ4eNBnbKx6a9DhRAjgM9fFJPYZErUCMbkdWVFSmeKRVEzHDokShAa885C+XP2GT/FJpWQ/qTahCqh8+elHSZdiXHITFyiUufKhpTaZIP0JJYRFafkd7i4LL93Dma86xv+tvuJRa2u6/zC+YjT61adSFAm4oI88ZDyYpJpekhp9LrStn7yiwHTYTqI500FJSkdlLp4qKaIMcUGZTSm9CeWg7oKc2iXahPCKESiByOEIrawgz3o4vhiJiYZ6mwaxg4Z22K+zXIlo9rpMZEIJTwsA2JEcySVcGKtnhe1ER/XAvshTIjsGLJiPySI6YL97LlmiRy+Fj0R2s6QxQqF4vZC4b2f/+6+CkR/VoVCoVDcijh1+uSgVNWQHCRMJkmocYbtMwZotTBZackEOJeViVAlIEcY8xoWZczSnp2gHIblLUy54fIEyjRMJC/LUFi+wgk3iY1KQFzEQZgwFpexxbb9OZjscxqRzckEuAv/jCjeyJ592icUskhwYSQxfUdYRmNIk22k+CwdkknjhUtCcrCU6Mi8X5r0LJKFaNsxN4uoWBBWyYCgIDlRa8jvnojL8ibOjc1NlCMFfZfNCVHB3+qJL4qN5xEk7xgvmy3EDLe25Xvs8ykQOosBWXYJXilX1qWds1OyLkmxYqHu1Nue8zNPOsHstOv0kOzSHZojo8xk2ydEYiAqGN/LdBwSKfQ8aQalKslDUhLV25FzowdShfHC7XWfvCOZ0ashjSYDj5uQ5ZPApNswvriHNB62IzYtfe4ERAoJoSHCBBhK/WEMcuDT0lyRMrseyu1TR4S8a50XYrBf2hTzHMedVCFyEDQZp0Q1CRjhzBjyZD+YZAsqBFEoFAqFQqFQKASnTp/8WKcTHSgraeRpEEaYbGzCi2KmIn+wsCeJxOhEfu/nfOBTUq/LpJfRu1QElEEuFAOD2qmi7LfdlsnY0iGZNNHE1pjAsg2drkxYKyAlDsHvYmbaP1ZGFXe7MEuFciMNrxAasR475k/S2IcJkDHJpExYS1SnBP/WSBQtCQlCT5PnEEt8/72Xd/9twWi2VEphG3aVzbkLvj/ILExUz1+QySZ/axJF7bbfj3GcT0WQMps4pjiMbTe3pY9mpv3zYaooqgsSLTmQKpeW5VjbwXly9LCoW2JR9q38Juvr8C4JyDJGZrfgY5eA4W08OJ/rbdf5+S+OKo6pbKBfByf1g/bSXwR+Jm5iNFrY2eNBEq0xjnr0e7GcXEtDBq4WDqDbkG3FQJLYCJNhkme8CsWQJkORy1Bcc3tWAqk76qnUR6eMexNUO9Ek4pyD354+J06IWW1sRu4PvW5Xo4oVCoVCoVAoFAqFX6aj3aBQTI4+afILFtJEcXuhbxHipcPKTK4hyKklsb+YneS5IbCVCZFbZ9PCYpnHQdUtCoVCoVAoFIqbHSRObGqTSkWUHSyjIYbUJhY0UKaRSslb7XGRwk34qlB5Qv+Mu+7aGHw2ahKjdthtc1beSFdrozHKu8tjvvKCSgQqFO5GdDAVKxuBx0UmzWQYaWcMyUPVqqg7Iuhnk6zDkps2VC9zQ5HDeBMfKD0K2N9FlJk8cP+KrIuU6cur/jqMCy6V5U383Jz8lqur8HKJjpbfzM9K27agFOlBGbQVeNk8+OLlwbKnnj40+HwEnicX0P58Ro7LHOvZZ+ZHljl7Eonm5+R3bQYlNZubotBgLHXfm8SAKUJcf/B39FenHXH6lSb/7os1x+10HbN3NygLYYmMmxXNAj08OFlMBuUpLVxGLMnplkRx02O6DUqCkvO+eqqDdV3UVfF7ESg9jBdKd1u+RxvPnsUfxYHKJJIbTdLZD3pUlVD9gbk3I4U9k0hEX8CObCPG5UmUNkGR4xm/FOyP4jiWD3XQt/2kn1jCdUfvjnvAFSjCmYQM2E85kCEowsgJEhgE168H66SxrINfvmffxMDwttW1lxcN7WOCMqer/3U44lmhUCgUCoVCobiR2G8McRhh4sD7g5N9Gr9mgzIfEiYsWclmR+OCCRq8rq1JOcbSkr3ZhhBZXZV1NzZlst+hAWhBJovG6JPlJtwHjUwZRZzLuiN/n4Kx6Pa27LtckQndvfdcGXxuNEaNM5MgXSowhD0GEsdM5lnWw1IW9vMcCAVzrNNTcvxlkCf1hrSzUMTE2Rv1iby8lnNsmJnFZD/wCnnq6UVpe6Ldiid6/yMa6f33RiPxn97/DY+uWDZzzfDwo990uOe5/6jTjrw5Fu+90us5uwfJ0qxyieSVf57cc1T8cjY2/WPte5r8P88E5Eg86rgoC3ECw1dO+ofIDgKlJcYE1qORKaKFuwggSCyiLAkGp43nfBIxPoVykzZKXDgvRjMMOUIflEhL2sbSn4N6nnRBJkWz/rnmhpTLhBnQmj6ljwvJnGhBzvfmZblGWbZjPre35Rqlzwm3Td+UXqOlZTsKhUKhUCgUCsWdiFOnT36T4zi/rT++4loiGnHaqVT7P/7YG3/3H99MHfvI3/tYX/byU8F/Y/FDH33zozu1xDdyvT5p8h/OBmRFQqfSdxJelHMfc7de/9pLfaWUOe66JYGG4N/jIIRsEcFhoNrClvQTVjqzH5Q6/raLsdHt7sW4kpqwv3dp0BMc935ilKmAsfXX1Cc+NbpQoVAoFArFbYnG2bep/PQmQer+j9xxY7BTp09+qFFP/oD5/6m03a+hG7yVj0ZD3pwDm1titmlMVIn9xP4yhceYyjLdpwuVgDGUdULUFjMz8ka+2cSb5yjG5LFR40kTievsqj8YtyvfO7wkagRTcrMJdUu1ziQZ2Qdjf21gSU48BtNMrEvT2fWgfCabkWVRREbTMLYHlZBJwjl6VMqdzp2TcpgMtldBSs19x1d3/33y7CEnl2198ANv/s13WA7jtsPbP7XelyZsVGr+dfL4sx9unF39y8GJ6dLgNCiTMaku/kKUF6EEJgJFhBvMvT1aXFBJAYVJCgkzrQ251uJzftkO02icjpzDVKHQDHXQtpKowCJQlXSr0uYokn5sypEuDW/RfpvyZD9ob4hiyqhGXBjpOlCeOFD4hKliBqU/JL9o3AvVC2OLd37wd93db9Q58bcQJgQJlaGSk6t/bQgkTHgjMNtLWggV5yrETsVSalPFMpu3yX6azP0xCShqIT6iIVvjeUvCZFyJkkKhUCgUCoVCcT1w6vTJP3Yc56tJmJQrMpEq5ETOXir7E0B3KEVFJmDdnkyeSJisrQlRsrDgEyVhhAnR7SKmdis9st3LKMXJ5WQcbdq5u79gPyRMVtEe+lZUEeV7PCijyWelLIHxwyRj2h1ppylRok/I4QQJDonbJeZmZXvGCyWJthkvld02IZnmCuKFp4O43DWkxGRTSCSCD0gW/iEm7aSFFKJ7UEa0BqJrbnbn9977d373TUONf93I4dyWeMvvn1u6XG0OjFoOBZP+Fx353lQi/9bBIacCI8/Pn/+XzdZOaXclxhPTXyMC4sADKREJSm041WytSOkJS2foxZGYQVRvQAh0MekfSozZRGSyheTwWOIDz6DYFMreUO4SC0gMD+VFJEwIEiYmQWc/yTwsJbICEc5dRA5H4S3TQwlSLyiV8nD8Hr7ngWxK3u0naOXd3rnd4+3/z0ENY22qEQcKC5u6Yi+4xrj1bUqYPvKW5eTG96MKsXmlTBKdHLZq2HJDmqjniUKhUCgUCoXiRuHU6ZP9ScCxvbsr5HesLbApSPaDCNQdhhioIXKYprQkY6Iw8jT7ZiRxJi3rbm3B+BXeHVtBxGwaxq93HxWfEBqZptMy0Tt/3p8opVLyvRrIlRkk8jpDL/b9cX0ChIlRozh7zElJQtG/xcTekpShmqZyWciMbFomwPWgfTS2bbble3Mz0i/0nNkIFCsX4dPSbkf6qpx6Id944F9/029fcu5gfOcfPbfQ6nRXo5HIEJlxdEF+MxczWVOZcPIlP518etu/lh6cKzqd1hXn95/4ka7juoMZfg8TdYeeJpv++e4iQpdEBMmYSEy+14DyxJARxjh293xYEyKFyz3MkTsB2UKli5Mc9eHZbVMiPrJOyJTX6e0wDlmuu0FUcQh5QjJjyDsmUO30WNHBPmpAgQXSxaOpbN4/92nA68Xs7WgFfXf+h373uGPIE4VCoVAoFArFjYa+QFHcWJw6fbL/Gruo3a4wiMe6F37m235jhEy7U9EnTeqt9m5tUjRin1BPglhi3nnTq38xemhW1CH/7ye/p95oVu3yDMVNh8OZyOOmTbvkSRPqh7CSGRvCUmcGiycUtISpNMaBZTtGhcJT3VZmsxdGcRLmc0LYvEvYFyzVYVmOLS1Iy3YUijsP5Xe94s27B93zvmFw8BEnoMrd/+bE3OXCOx8/raeGQqFQKK4VfvyP3lh2nESe6oMDwwsZv0JVwZIUgyzigsPA+OGloK0rK/K2f2ERpUGrMiFtt6WsYHHRL3WgsmNrW8p68vkmPiMCOPAKWUNZzHGUstDTpdVEmUKg+tjYkL9XKva0GvqYdNqwCAhKqDY3c1hX1DlU6myhRGlu2m//0aMSVPPMs+LZ0u3Kb3Xh0nS/wqFTyNeP/5tv++gdrSzZi3ec2d5NnVqtIH0oUD9sN+Sa+cIlOR+KSfHUOAZFSjwo4SnCG+TSmpSsHZ5714A4mUnWnL986kd7Tq8XGXilQI0xpDaBz0cb7YxjP6ZspbMl53WC3iu4dNubWCdQb9A+JIw6YhqQY/MP4bpQfESm4JUS/Nth6VAM0cHwK6HniSnhYdsYLTyknEHZDv1WTMpOBBxBlFHLTDtKRJ0nv/fRVw227+whTGohPh82hMX0mnKeg5IybAN9X8PKhNLoPeN1EuZzEoZJPEhs5UUptI1/HSKY6JsysgWFQnEro/z+V/dHex92Iu637x7GJgaIM7ghV5HtT3MquWl/T/9/yo+cGO4N1F86/sOl/xT+wcLDZz6iJ45CcYvCG32polBcD/QVJ6mUk9+76QbKaGoNmayMK9VZB0lAQ1LjbdLHlXURuBjjV5av0Oy1hwk+o4FLZZ8QaXdk5JyIy3M0kZBnI6N+TdkOTW4XFuSYKjtCtDBeuFj0J1g0X93ZkYlnCTG2S4fkWA0hRfKEpT/djkxWnlsXcuSuw+JnUa74k77yjvwmd98lfVEuy6TwwRc/N/hsSo3qdUxMQWJtldNONtX+4w++5aMnHcUIvu2/nT9Ub3cHzNPLjopp7ief8vv5DfcdHizrYOx2YVMIwqefkt/ETMoXGzJhv7AjJEEK5MiJ4y92Thz/9d0F//WJ806p9HOdUuXcgIlwSShACcOJf7fVHlmHHiWtLSEfEhkp24kmQXgEZStDhrFpuaboc8KyHRPB7MJTZChmGBNjRhwbU1wSMSRMOvBsibPUyJTzoF+GSnySch10WDKE562Jf46hPIpGulGQTVtv/U9DE387RaRQKBSKUJQfOfEGZ6f18cHfM7yVjpKr1wn9Uekvl9/7ql8ebN43EvtE4eEzb9BfT6FQKBSOeJxoqc4dhnSq84unvvm3vvdO74cw9EmTy9XGLmlSTNi9PV4IFItvjx0/5JMIa5v/obdS+kyYAERxnbGXOHFs5EnGUmYSpsYYV+IyidrEgXnqKU1S6gAAIABJREFUJEat/vfkc9zy1YMqYCZB2FbD1DnSdn3rpFDc7Cj96Cv+ldvpvdcpIlZtKAIONyEjl6PaZAMqlFksd0Ie1qXgTQX3B4adihWvLZ9dX9Xy1eWfeBXke9FS4eEzoiVVKBQKxR2DIFVn18/CJM8kYaLKtB1+bkCFYlQVTK6hgWsuZ484NmoTZ3ci72/jChJhWPrThXplqihvyYsF/213Jm0vNUql5G13E2U07cBodWFBlB3cXx5pQnUYwiYS/n48jOyvrMsb/DZikln+ZPqLJrkzKAeq1uR5/uIXSXnN+rq8Ua8EihOTntPHcyhXYp/H0bfxQH1zeTXfTxH66E+/+bfe4ihC8Y8/sTzf6vTWOj3PmUv7fZ4JMUY1I6zHl8Vs+MFFUSrNoVwmhzSdsyX/t29gfJhGIkwR+1unosPYQQRq43zh2yPR9Lfufi5XfqVXi14YnAQ0lY1AVWFUEyyH8WCiSvUHlSxmnBmH6mKoHCaPyGEoOoxyJDot18lQik/I9oyqxWOdEBGiLOkGxxLLStujRWmbLdZ4d39oX2fTX6cNNVACiUSt5zad6r/4b9ZJ/Ah5Ql+OMNLEIOyvJrkmzt8D0qKw0qD4GKIhDDTHtaXp7IcwSUzA6dn6aD9eKfyeKTUKK0VSKBQvLMrvf/UnHcf7m06pJdd0E+7oJDZYUmPy5XkDnMa6OxgA5uz584NtD5Ey2F4JD74ZbDsbH91Hxi2W3/+QN9ie6/6Nwr/63KdG9qlQKG44PDWMVVxHnDp98t19Qt3sgaTJOAwTA/5zxviBOPAU2QtG8sbg7WFSaBbmRYrfasnEJp+XSUytJhNSU6oyNyffoycKE3Z6nnyvWPSXsxyIxAaJoHm06dz52aCv5HlPzxOCUb6plL/+dFEmws8G5TTOrteL9Ofysky+WV5TLPgkFD1Koq704fwC4mFj0r4rV/LdX/yuXxuZ0ymGYTxNpvKZkb81MTlfRnLNAzP++WzSc3Z/H0z2qyAljs7L+WDIkyTGbq84JqU///2LFwefmXjTT+fp41xZfuuHDFmz+EORMysbux9XVn/Y60VlEhmDF0rzkr9OBCk+EfiReJx7grQ0HikkKuKLEKxhrMtyl3ZFrt3B/kB8kDAxJT7cXjRtHwvHQHb0doSgNZ4mbfxOJHxYntNFDDTjh7u1YHt8DwrCJ4w4cWzkiUKhUNypKL/z5R91ep5v5pqzv4W45eF5f15+7ysdx3+QThcePmMfASsUCoXilsWp0yf75Zvv0l/w9oXren/jnX/r9/VlyBi88dGnjr3s6Py5q691a2Fp8f1uLBpxep0vORc31PruWmE26V46932PHb3a5mIdz4tQFZII5Vl8dCkLwvdant0Y1YClM2FlOW1LCct+lBlxi9qk3r16e0b2Y2RSId+rW9QmBJeEKWv4PdNfXcsxKxSKG4vye4MylxT45EbAUCcgG4QSxK2jFIeKQ1M7yHtXGUoQlu1QIUL5m/luLMRaOoPlNahhzDaoWNnCPooj7P5WYEz7K4WHz7xtZD8KhUKhuFXx8efTbmPU6qB0poeykVWk2CyiNCaXg0EjXutWKv724nEasSatn/k6+NAh3zD1wkVRcXhMA4EaJp3CG/NAmUG1ydlnJIHGqDycPSVBNpXJdknk/OkUEjta8iyOGiNcKEk4N4jH5a33xpa8Jb/rsKheLj7n92kCqpIO+ryyk3Bc12l+4M2/yfpfRQje/qn1Gc9zNu5bmHa2g2SaLZSbHF8SBVAXc7dtjO8Wcr7K4YEZKTf76zU537/8nsXB5xK2bX61OsqsT59dtjb0yJScX3+16p/vc1BjJKBeYXTyvcX+NXXCuX/2hLNSbTrPXPmRTsfrxQalKigjcqlCScnLwfa6qDeMoqPH+T1MW2NpuUZdjI1jQbkLS3Xcofk71F9YHsnxmvdBk9gI9tepSd8mgu/Fi3KPGlJnM8QlKsfdqY+WF1KFU/mB3xmd4Fvgbr3+tZe6nnPE/MnCC+wLtrjgFwKTpOZcCxjPkmtRfjP1iU9pDY9CcYNQ/tFXLDqt7mVnGmMQJl+Yhwfki6H1eSRBzfgI96Bh0gXb4755zzKyRsa+sWSoFrKNIOFnyLk8iQcKS4m47UGpUbRc+OHPqKmgQnGDUH/qH+kblJsE6Rf9x9tmDHbq9MnBecWyFQMSCvuBiedNJoT4yGZkIrJThe9DblTC7+yWlviPlpkZxAyvyeOGCTssqdnZ8Sd0aRAcmYw97pjfKwVRvqmkkBaFgpReeJ48D88HpTrO7rsHf3kcKT1EHqRLdUcmuIYcKe9IXxw+JBPB5VUpZ3rg3tXBZ5b2mF+q0ZLncyLYbizaW/+Zf/AbEgOjCIUpz+HfN0o+eTJbHC3Z6aOG0pJmWz7nggl8DWPBYhYJLRhv1RBnvB0QKWl4bjyHUpx7Z+V8qCFONx0Y1569IgQNbS2KKTnnSthfKibnzGdX3lsttbayTOkh+UASpI2ylniQzmP8QPpIHhKStIcSJabiuEEftMtSQuegPCcKXxgSOmbMzShmF74wbtIyTkUpDsmVoXSfrt1Dhd4qg1+t03WWUu5TX/rfH31g5Ash2G3VOJ6Bvohct9GzEyZmaaUjfy/ExuxkH6hT3WJRmzg3kDQxsHEmYeocqm/MYr4gVkdHheL6o/zOly95ze6A/nfxMBhirs3lyht9Gaw1rt0hsiKfGNkWGXr6nHhQnrgwfh0QIhsYhOZRRpQfUZAEbfVvLG4d2yKxkwopRTL3zZ5XKP/Erj/KFwo/8tmXjaynUCgUipsafeKEkbXptJ1omATjYotJmGxuyqQwbTF5LVdk8rp0yF41Sm+WXs9/fm5CrVGryTOQXinbJXkTbUxgG3X4nEApMj8nMcP3QG2yHPip0PMki+O4uCyj9WJexgS1YH+JmEzyPBjUkowhYZLHNnJZ/7daBdESi/c+/cFv+c2vcBRj8T1/cnkum0kOfkxYgji1pv8bzjpyHl2EgmS+KOqP6cIoweKC4PiLZ4X8+vLjojz5i4trg8+zGf8aFG2LMzCndfbMrT+PdtwfEBiLOTFArTbl/JvG8mWYna5CVTGb/2fZPh1Yrv+H1kbrqd2LhdHCLZAcQ4aqwbi1h3ls87JwULECoo8vS5sTQX9FknJdRgtCfPQw2e3CH6UbvBRMLsk11VyR7cZ6UJ6A5IkGBFIbPjRReLCQNKIfC71Q+qqVqOM1N77/sYlVXOp5olAo7hiU/q+X+ndOC+mpGMKD5Z98db+v/knhX3zm32vXKBTXCZ4KTxTXDkGyjuI2QDzR/fMPvPm3Xqe/5Xj0SZNWp7tLmmSf57ZuJ0yl35qYSjtOu/PJ7vnSfw2pA7/z4LqR3vb3/daB+2O3bKdfbmUWhKnSx6GOt5vj4nk7GCzEQhQkB22PYfIoQAnzILFhkuOYFGGKFAMt21Eorg/K73/onzvl1iODjU+BaB4quYFiw0gAWS6ThnKjBAdvqkzMtU1H8TR4asbC0Qslh3USFl4b7RgqA6JPi2kz9x23Px+GVC+mzVwV7Sy883N6b1IorgPqT36Hsic3CdIP/OotfZ/7yT/5mq9xXecP+5+jUDnQr4MRwJPAxPBWduStN5UbOzvypp4pPevrsu9UujPShsqOTHUZHczt5XIoBbD8fQelM602EkWCK2txQUpntrfle9msKAkYk9zt+J/LFRknLB2SY+XxPXtOqmgaQXLQ3IwcB/uoUZc34xubctw79WElaSrReepn/8Fv7LuE4E7Gd/7RcwutTnf18Fxh373QwFgqhbIQqklYLPHqwNPk089IvPRhqD+OLohq4s+flnX+xn1Lu/+ul+T8XavIuXH/giRGlWqiGjE+QVSjZOMoY2vJ+feiaTnuL23JeZ4JSnjunZbrrz8VLlWfcP7s4s8Pcfa9tvSHG4whWdYTwRizA08XKllMCU+vIn+nv4jLoXVOrquB5wlUPc1N6aPkDNJ2qPYO2txDKZVrK7t3hl9Q5FP3tJ/7vg+HSLf3D3f1q16zknDdQ+YbthId27JJQUPZREgpiy1SOOzvLSy/EXG/4/YX1kcsNUqA/rH1o5InCsW1R/lfPjg6OcmABCmjbIdmroYc4bokIki0NEFWBPcKD8vcLLbBWj1GFZOkMfsZcqIGeYLFQw8MW/TxBiTbPL4tLDdlQms1+7p+W7618MOf/Y2R7SsUigOj/uS3j96fFC8I0g/82i09BqPPCdEdMhz1yQMSGDsgRFh+M670hzHDCXihMGbY6k2CUpYq1q3XZXu5LCZegSEsPUpqIByy2AfLfWqBD8t2WY6v0UCbYeCazcEEtu0/f2mO22zKs//oXZuDz89eEPLExM0uzMlzdH1DyJpmW7aRxL4X5ge/RfXdX/t7MttVhOIff2J5fiqfGdTInF8VouHYopAZLMsxJAfX7WIcF4VnBo2OV2s+WcHynCo8OhqYwNebo1Hgz5TkWnv9i46M/L2Py4jczQRlNJ+6ICVAeZTWvARxyC7m03GUqvzlRb9yaacl7cmA7HjN0Xnnsb/6gVq1U8t4aLMpQXfRF5E0S3HkWiJaaz5JyHhibiNKnxmUyneCfmTscRc+LiRaWuijWFAShVuJE8NLx8Y6TGfdiHN08f3dL/yjV1reSh4MWrajUChuW5Tf/2rrYFJxAHjOfy6/76FLhX/52atGuCkUCoXixiKMOFHcGnj31/6evjzdB/qRw9OZ1G7ksPpEPj984yv+zS6jsVGuOn/4pR9s97rtEFO8WxPHD7/TSUWn2n/5bQ9a3io+P+yW7XQ8b0CFjSujuZ6wldyEYWdMdPCNaGcf7YBpTlnUKM4+FCtU1iz+6adHV1AoFBOj/L6H7nM85+zu90xpDHWYBTh005R1Fqy6UWxMY11ew1eg0uA6RlkyFDMs17m3jXKZAp5VLNUxzDxNZFkyRGNblN8YtYtLQ1msOiRlqaBkqBCsHx1aWXBF+sjLxJzij/2V3qsUimsAVZ7cPLhVlSenTp/8QcdxPjjyh6ug05HnU6stz4tM2p6UYwPLgXJZ+V4UST6uO5p6sbIi5QpM2KGSpYLEmlRg3JrFPpaxDU5bcll5ruXzvvzfJAU5u9HC8oxjKg6raY8sBcoEljbgQbq+LqUELAlqBu3f2pJxRAupOYW8KGRygdLFjTg/8KN/67/8jKO4Kv7pX2xOR1130xmJwN0/ykHJSQFqhktrUlZ114I9aPCJQMXxokU555Y3RQWRxNhtCXHGnz3vK0d4frYwgXzoLjENfvySGBbfN+e340tI26mhtCaONJpWRxRMD84LnbQTGMzuoIR7Gik97MIzq3INvnQm76xu/27niZXfHxxUDKqXoXofKkuCPh36bZj0sy2lOHEk7/SC9nWg5OE+XI51mbYTjLOjGBfn3IV2Pvf23QXdntc7+7ZX22vWrwF2OyeMMDGlNomQv4f5gxhiI4VjdjFop/cHCQXDgezH5+SghMk4MmM/5UDctc27JKxfCLOGrVRJoVAcHOUffcUrnUTkc4MNzAQ36uqonHIXJEzoFWIuzbBrdH7UjX0XhhyZwwMH0lA3ju3x/rEJeXPC+K1g4NnFw4VlQEOlP8HgkqVBLRwTb64pPFcMUbSAY2KBaRG1rc2uU/5XL/MKP/5ESMcoFIr9Q7kTxfNDpZLdJU4MWbAfxJAIE4vtnzDpwRskEvGwXAb8W/AVoefH8oqfO3J4ScpeKvAuScQ7+CzPH0OaVKtp/B2Twmkpi9jaFkInGZAZTApiCVMJqT/plJTtGJ+WQrGBZUKYMKK5iojmRMJvfzotY41Z+J+YJJ0+Nrdzzvu+/jF9ho6BiRzeRDqMiQZeAFHB8cqzKNW5b0mybtaCmGCSJ2GESQ9jtpcdHU2HvufQ9MiyPs4ubww+P3RsYeTvXwBJEkcZ+JcdH7hnDDxZKigHeilijXMgQT67ItfS50G23Ff0z9dZlNx8CYQPX5ORA8jE487x+b8fm85//WDZQnrZ+diZ93n9i5/+frG8XI+eKTsHodK6IsRiEr9VqzTqYRRhSTzaw2jhHsbn8emccyjxxl4k8prBDmdSibjruq0/ffOL8Tbz+iDmXYWgGDzT3dFFzh5vQZIO44gNG+HgwNh1nKnrpJhEpRJGmEyCMMKE0DumQnGdkI1/bsi7I+cPoLw6jKVIKEzhPtu0kCfEkGkr2XGsbFQoYcqUIrxEwgid4B45RCRnoEzh9/Kyb9d4l7RDCJNp7HuV7QsesOw3qlCKIGjSgZneT7zKK/yIGskqFArFC4V+uU4+mJfsJ57YkAvTU3bjWMYMGzKgj0igJqlW5VkwNYW3yTFZl34lxPSU/3yh6qVcljZPFYXEiWF7y8v+BJh8PkmQuTn5w9yMTBC3gtjitTU5prvuksmt48rD8fAhefu+E5A0Lv4ejeAFCJ56G5tCwAxeioIEarc5U/K/6Ea8H3rf1z/2IUcRCkOamL8vTF/dCmalJOdiNmGvPkkEY5oVkAhUiqxtyTVh21+bk3dM9jnEunt+lIxZR5zuYcQh78Ak9hLaNJf3z6kvOzwr26jI2OzJTSElHpiRc5uikHMBUfRldwnxcx599Lr7xXvl9NPLg8+FwHuE5/jjGzPOvcdO7S6pQelyd+ZJ5/NrH63WO41sLAhF8IYuUvlMwiQGQmdgKuuRPMHHWqs3UzjRy+W+LbZwRO4VO75PC4xZIq1PfstLrjtpYqCeJwqF4rZB+ZET+hr3BqL8yImPFB4+87Y75oAVimsNvWMpDohTp08+pH13a0G9Ta6OvaSJ4ubFXO61zhtyr91lKA3p8snzlwftdTMws8XLuJeA8Pncmv9TH58SZVcE7MnFSi2yt/h8CJFI69NveekNI00MYr3dsAa8QUWjbc90XvV48TqkFpnEu4QYpzgJK+cJS7oxmKTEJyxGeZII40nWpeeJQqE4OMqPnBDNYh5vHiq+SsON4/5LBcY23tCxlMVIO0nn816ZxPaQhONUR+WLQ5+pGmH5DZcHpUZDChkoZ5wk2mnxKRlSxXDdOvbB/gja7PFeib5wmdjD781Ev6v8yIkfLDx8RvpeoVBMAB0DKA6GViv+GabcUG3ShvcjY3htipNSWSYuMzPlkb8T8Zjsr1IR2T5LY/jIpMrExCd7iMiYmZa34YwRpheK2c/8vLSt27WPrZ89Lz4S0aj/5rtQaOJ7SLyBuuX8BXnL3wraXEACT6cn31tYWMc+5GDXNnxVQTwhb9y3A2VNLNarf/BbfjOk1ldhSJOwGGHClNREMPahgiQMdy+OltqEpfQYnxMHZTtUmxBfsKzrwE9lGmVC56EaeRCqkNJlKb85GnioXNyQdV8Cf5TjUHScRdlOAsY95vOfIl75b94jaUFfuChJPml4k/zZeT+uuQifkwfnRE3zOEqiPr0sx/3Qoq8Om0XE8UsRxfyHZy8NPmdTsu1oMEc20cp9nEeJFm0+NuGLko7HWqdvoNJkL/rVS54bUkYTtUnHR9byUQeDkQ4G4DUsCyNG2DFmf2G+I1yXhEkdE4VMIJ/n98Jikm0I83+xXzJ2kDAZ13c920KFQjERyu96xRu8emdwh3dBnnjB9ThUWsPR3RSIlArkxt1gkEiCo0VJIlpIkrQQPASaIb4jsZCLnuVDpnyG901wJ/QgGSrRMTFzWbtsleayDrxXvOBB67JsiaQLyaEMlvvt3Aq5vSkUirFQ8kQxOd7/J3/7fXuHq/QEoblqyNNggGLB7pXSbIq8vhTE/cZAFgwRLSBE4gk+rASG6CFZw0dnG0QLY4nrdf+ZSvPZZlOOtVyRiRdif51Gw1++vWWPV52ZkT5aXZNyikzKb2ejKdu9G/HEZ58RL4tMGqVNQWlPrY72zO048Vjvh9/7d3/nJ0caoBhRmoQRJkTE8sIoDCyNyWVG59okTGp4uXQPPEaeu+KTIG2QFtuI943jJN6uyDll/FQqVWkDDWOfBfHx2nuXZJ3As46EyQqIlPkpOVfXEet7FCRNLuFfSx6u/lWYtr78bjmHP/4lITbMPJy8wP9aFrLwdcfEm+XPQMCYvjlakGv7zy+sDj6/Ema2nwLZNBOU8CzvSL/Nglx5cksI4Qem8v1yovpvf/29LzgJqWU7CoXi1ke393H9FV84lP75S99f/Km//uE79fgVCoXihsJz9H57CyCZ6C6+542/u3bLH8g1hpbnKCZBzI30Pvame69bes6kCHsHOgQqQZgOQzUJ352Yz919vFCJWkpj+LI1TIXChrfHdOc4tcl+EKaACTO/Nbj6X/vei/rCVqF4Pig/cmLKyScdtwzVCO4b7lzw1okGrlG8GePNpC7KCy94i+RSpUJlBt7ADVVkVnqjy+J498fSGb5lYSyxSdvJ8Z1hyL2CUtKaxYAWBl4e7jcsYxosjaM9jIhLhCQEmUXJ6L9wHB3MKxQKxfXGqdMnPxK3yEnicbn/M0Z4qjhaqrMf7FTlTb1JkNmpyDIqSKheaTZEsVKtJUa2UcjLW2aqScKmDMeO+W++a3VRkDQRAVyrSmdMw8TWJOQUp2R/7Asa7OZRomPMcXMJWdbAMd1/r3AhX3pKFANukD4UC/798Lf/59GH5R2OfuRwvwIjBvVImBHrJKhCYZKFwqRnsUbYgHlppyv7XkTpzzpUGqbMZCovgoeh7WKMaFPFpFACk8Lfp3N2RdQTQSJPAusegdqkhzHdV95/ePD5M+dE6VEOknoyGNPVcaxD/YV1XnbUL7VheVGzK+f+/0Ra0BvuERXKhWD97YZsdzErx/cMzGrnMkioCib8z8JUNx6V+8rxYq758W9+MeThNwdiHc+LhJWqGPIjaYkhdvZ4iXALZh1aAoT5krCkxpS7DJW6cF4T4iUyztOkjX2wlCju2omgvcexdx/jCJMwbKO8KB9M2G4aGk2huEXhVdt/uktwFCxlLw4ICnATTgMkCKODeU8zEcaowXXg8O80uEHAlNSQfIjwZoh1Segw0cbsMmaJE3b23FyZwmPajyQdDwSMy+OexfMoIJ48EDjuLPbNEh6SPOYj45IVCsUEGB3cKxRj8F22PzMdJ5EAYYKSGuN/YvxA+mjBHyURZ8yu+Jg0Gv7zlV4kBImUDKJ8cygfMuk29GPZ2pLyCJb7kFQZtL0Dwh9JODWUF507L94lqaS/vRoSgjJp7BseK3FEN2+V/Gf/VF6eubWafK8Dv5VZeLasbQSTb891fvE7f02JE8AoTWIWcmFSwsSk18yBUMhaSnKcPbHEBkUss7XH33Z2ZBlLcugVehHEwCstsca8wx9FOdDKllxfl5D0czQ4rqdQqlOE38cUIoLXhr4nbV4JCKJSW66paluu7Zehv+5Dm/7kWd/wdQnEzt05uU7+GqTKs/i8EKz/+VW5P3De/xV3i9/Kn58Xkuf+oM33Tgtx9cxWxUlEo90vvvVVN211TCzqul6YusOMw+shJEIYzDqdIYWGfWWbKmR0iY/9RACbYwkzsy3uS2szijqPBdueJNp46oD7VigU4XB32i/f/WMK91mbEWsBy6j44DV8GWRGYCQ7ZL5Ks1RezguWEkxui2THDB7my6g1T1ja1KBKBdug90obPiZmFXiiuDUQJoxMZvsO+e13aVrLmyj7iGoY44Wy2XDK73zZzxbe+8T3OwqFYv9Q7kQxAU6dPjkUcRvmc9Juy/NkuySTqvm50sjOSJiEIZXyCZEr62IeWcjLM4TKk50deR5G09KmSDBHpolsL8TMdnVVPBJ6AfmzhDjhclkmzg/cJwkfTz0tkzSz7Rbk6dWaPH8PL4nnxLPnZNIbC1SndXiXzM3J8UUQW1zDW/mjR/z2vUcTdQbYT3lOHeMcCn1JdHXgN0LSxAaSHCQaDIZULx3ZbhwvvHrYn1GT2Lbl7FGkEKXA64TxvVkYqt6PKOIWSI5EoATp4nvpkPjlNqKDIxinveKY72nyybMSQ9zAMf3xk+JzQsPYLz/i+6yQHIrj78Wq9G0a/bhV88fLOy05jhkc6/96ThQr9Y6sk0/56zwR/D0eiXafeduJm95SRD1PFAqFQvH80XXeqL2oUEwKZU8UE+EHtLtuXihx4kM9TRSToE+afOk7b16lyV70tRBeYkxZToiqKTTW12xjPyoVRvWa1cPKiPYDcyzXQkSeCnnRG7ccl63fnKt4tigUimuExYD130RZC5NrbNcdS3H450N4gxCU1AxF/SZwU0jbpabeus/Mu1w3THU2gzsVk3CC9b0qZMyzeOtB35RtfJ5Pjf49G/I8YvtMmVMxpD1MJGqg74YVNy8a2YdCoVAorglOnT75TSO38YRdNUJ1Ry7bHPk7EaZescGmXNmLNsprup60o1Hzn0WZjDyrGa9MVUsmK8eVz42mARUKolK5eFHe4E/D38QoWS7g7426vMHf9KRcgcjnA8UAeM0yvF5SKTyX8T0lToQ0YcpNAsqFRGJ0PJJO2VUVRFh5jQ1hChEbqDYh6F1SCpQs5bocUwGqilVE6zagFjkcKFLS8DyhXwlVVwn4jnz2vO+p86IFUV99fmVj8Pk1GfEaYQJQDePaJ754cfffr3nJUWnnpj1OvIzEnvNBKdGXHZd9/FGwrT7msvAJSsl4sRvMgb8SKT5JHNNqSa7XhcOSInSlUms89qb70o4j7bwVMHIW2wgPW2mNs+slIp85NzDb4PuUXojJatI2sQlBFQRFFu0kAWNWYa3V0Nwn5Fhs2IHaPazkxqxi6zdnT4QVYZpn/6tCodg3bCapJQwWTakNnxZ5kCsgGjyWrWT8B95Q7G8JBA2jiDPwCjHXPIkIPvi5D0YYk/AxcXEcVCCybYi4YTnSerAOS3zSNJmSh6tHU90pv60ebuouGWOSTTTNNaVSJFoUCsUEUOWJYt/4bbOiITzCyA6SKvQ3sSFsG8Tyim8kmcnIdluI8i0UaAIrXyyVhGCfm/U9Eox/Sh+bW1JSlCXJM+ayOIcym2xOnj/bJZncbW6mhjf/AAAgAElEQVSPllN0aohDxvJiQfZtPFs4ZGg05Tlbr8uzfbvs7+/ff/ev3tHD+T5pUq01B0oTxgLTENaApq2zxdHf6WromnCRkPnVQRFmXFsMyJgoxnE0jJ3GsTaxjemCf1xPPCdRv/QX2UY87zIIGLMfls7Mp2QfbsROuty9OC3tD+KFn0As8Mssfiy7x4eyKVP6s7wBomUoTlyO70ms86qlmd1/H78spXB5tG0OfbRRqfe3WX/0JogcPihGyBOFQqFQKBQKhUKhUFwdU4XGu666wm0MLc9RTALXcesfe9OtS5oYjJAnTLQx6ZRh6TJNGAqmEWVpEnSo8gjbBmG+xxeeZH5D1FVW9QrLaCZTmyCWOWpfTpVJZwwDal8qy5nAMzWylkKhGAtzz6Iag9Izo47gDYRlLRX57M5A/VEK3mbxvpOByqOJt2RMmwmMZofUJlRuJOwqFA8KGtcYpfEGwuODIsWUCfntD9pBs1cm9tQgN55Cm4MUHpcKO6bxjLsRh9z/FAqFQvH80Y8n5kZsapFWC0bhEai9nasrTza3JOkiEZc3y7mcvA035TBMnVlY2B583tiQN+rT0/JGOoJ2sHzGoIcEu9kZRC1DNbK97X8vD3XIwqKUAaxfEfVKFPubm/bXubIuf3/R/ZL0sbkpbWaCjlHDZDKiaGkjGnnpkBx3Kpk7/743PfpjIwd2m8NGmiST9vIbW5oO1SZbUF3ks/YknBrGbDSSHQcqRCJjxim2dhK5kEQfYh2RuxeC5JkHYQzLY1pDSs+r7xGjYxM5/Nercp59+XH5e3lHVMg0tq2j/GYmSMh5cl3K7J5ZFlUIS6lYumSGzs/hN/nK4xLH/QkY0NLCIh6oTJI4vqnh86H+G3/nnlueNDHYPVr6cnBYbAgPEgf8ezFhGUSj8zsQxdHHhF4pLmYHhuRI4PytkKAJOfE3wbZMB20iwcFtkEexldqE+ZWkLes68DEJI1fCYEiT3tWfaQqFYhwMccESGBANXtV/oLgxkAUkAPK4wZNoMB4j9Phgtj+Td+DYbtJ5XEQLe7gXumlw1nMgKEBsOEb6uYVyGBIYURItaLOJREYk3VBZE6OKWY4U9KGH8hu3hn0X2He4vxmvlOnxgwqFQjEKSrMViqvgu5ooHUkmR8tVw/xPxiGfk2dVPCR5pxGU6ExNyYSPiT5tJNqQMFkHqZJO+8+4dkvWjaLNXRApi4sycTQxyDs78pzZ3pJtLMwLWZNMyXPLlAdNFeX4ziKNZ3FRvrexKgRSLChz6nZlfwvzEsu6sSlpLz/5DY/e49xBsJEm0m/y+9HzhKSDreTGlLfsRQtlxpMQJsQ4wqSJfSQtfiz7wQoihZdQljMXvBFniTSxNCPrnl0WT5OX3+WX17CM6Mq2XHeXQNA8BI+Ri1fkmjF+I82ubOPewzODz0zbecMDdw0+m3Kqly/JuuyX+6bl3E+DbGq1/Ov47qIQlY1Wx3Fdt/5bX3fc/gPfwtjtkSFhhuU33g8ZQBiSo4QJxZDPIk7mjZbsMBMb/XtnH+QCX/AabxUqXfIhfiU2UAkCMU2oAe1W0P6ZhH0fV+CLMA8fgjAPFYVCMSECHxIPNwIXrKQhaIcUGlRmkMAA4eGkggcDyY4y1CaUyOF7bhAT7G2AiIDKw6P6A4SPy/usiVKeC1HL0LOFPiaB18uQyW3Ig3vIpyTYnjvMXGMfIF3ImZt7WldZYIVCobiesBEmYWBcMBUkRp1CooUv8VbXRAO9CGUJY4QN6KUyPy9vuBkznErDeyUgVWg6SzVKdVUmk4m4tH9hwSc5GIfMdq5eEeLjyGFps/Eu6Xny0KrX5VlWr8lzOZOSdtYa/nJjHOvser7I/qJR/zh+5tt+444ayL/jzHbIYGIUQ54nIXHA40Bz2SrImOwYBUgJUcXFMeax+yFMGoFyOJW0r0vChDBqmTDih9tjbLEB++rJNeGrqFIJw2xAYrxhRq4NGsbeh7hnxhm/9pi/bapwPv4lMYw9cUR8U/7ikvipHM7542jzLsB13cbvf+P9V+/8Wxj2M0GhUCgUCoVCcZ2hyhPF1XHq9MkPXXUFxQ1HLNZ7+k7p9Xec2f6QRmQr9oPbnTQxiLV6XmwoQpcu2QFbWAT7xWQbeo1s4y1sLu6OfI+o0I8ELzqNGINlNpS780Uv20ylSikgj2OQDRag8uiGpP50LdLZTIjipo51wxQnBqYv9h7XJGoYhUJxFQTqLjeLm4ktEYaX3DS0ZFegNlmCutC4il9BbTnvaYwATmHfdf8thVGg7AJ/din1400tg+0ZuSbvzVTLUCED1YdrPs6GaOXoBcP+WAuOkdHJi3j+sR3sD9OPTVWeKBQKxfWA50V2J66uK/dZoyyhqoQIW25TnlDRQrVJuy3PsGZQtpPL1bFM/h6L4TnkynOG6g4zdGbs791HpVxhuyRvw7e25PmzseEvTyPpp4JtJBOikmzBm+TpIJHn0IKUVbQR4dxE+dChBVHW1Br+cVFtU0Sa0E416fzE1/3O/c4dgEnUJsRBy2EqVVGY5LPyG1Ntsl3xz+2pvL0aJExtYrbN7XYxpw3zrjQKkbUtxO2ifCUMRnFCj5KdppzDh2dFFbINtYwtavmhY1Ke04CHHtUrTNsx/iYs1UlCTZJPi+L6CJQza0F50DNbolKZSiJdqirH8vJ5UWN9Yb3U/uw/fHnIwPP2QyzqOj2Op7sgKyIWu9PRJUHnoi7HlOJw/M6gKqrIKRcsBSvN0XwWf+9y/B5SDjMz5qerY3stHLhR5oeV07Cch5RQ2nJPoKfLkE+LhUtqWUgbhUIxARaCB+hlDBYP4aEaxLC5JD4ov3RRvoJSFs+YqC7aH9ADvw9njw9IcG9ivJubk4ehh5uhG2F5Dba9HgwgMqx3JDlEJhnLTTkP4uS8bZQP8eY7ZCprue+FxRPTVNdsO3V1ozWFQqFQHAylsv8MmirK5C1nMYwNw/o6fBjmyiFrjaKyIxMss+/lFZmMHV4SA8p6XdalP4gDIuViUKKztCQEDU1uE3F55iwuyOSt0/WfL9mMHHM8JusacsXxiabB57uP+O2r1eSZdfSItLlckefy6hXZRi94eJ99ViasfOdxeLH8Yec2x9s/tT7jOs5G4oA+ICRM6ojCTafsJSwGJDbCkElefaIXRojYth1GmNgQRpiMi13mCzMSJgQJk7MB8XE/iA9GDk+l5PiPzBfxPSEi5wJi6dPPrAyWvXxJSoM+vyLr3gWfkmrDH3t+2TEpDaKny7FFIUxK1WZ/WrvzS1+1mHecoyPHdDtDy3YUCoVCoVAoXhDoCxRFON79B1//ldY3b4oXDO/+2t/7/tu599/+6Y2vcR3nD0f+oFAISv/uqxbv2JDYWJQ6QGf4OW4rLYmzRGbIEFaWZy2UTL1rL6PZbI0OHBiXzPeZrZBynzAVig1D5rfYhknsiYMUreJla5gixRjGFlCew2Qhtm0GbduxlEQpFIoDoBKoNKiqoLmqueYpE1uFaiQt16CHNBrXpPBsoUSGig9euryNmfKbOg1XYRLLdlAtQ9mcWYWvu/jGpovjozmsSdZBX7hMytkQSayH+5FrjovHgQhnJ4d9l6DUMe1kio9CoVAorglyudq3WLfjjo6dy2V5M14ooOSkKM+ZSlDuE43IsyyTkWdctyvPkxlEDpsSnV7XPhamirzRZKmOrG+MX59blvKCuVkxgd3clLf2R1HOs7Lir8+0Hapesllp/5NPHxp8np3yj3t6Wvqi1Za2pZLyXM6m5bnWDY4xk5Vn4FYQnZxMtP9i5OBvI3zfn135P2rN1s8Nfp8JFCQdlBAzece2bhgoxnftp5pTC8ZTiZC21VAaY1OCENsoqZnKpUb+ToS1bdw+wsA0nRb6zihOGM/8sqPz1q38z2cuDz4fhzLmbKAWeTFKa1ptOd9pVTGNeOhs0Kerm6I2mUV51P86t9r8xDe/+OoddQcg1vWcyHB0sKAVjKTTOEt2Ovaynkpbli8Eg3KWpIQl9syiRMfE/aZAxGyhbmcGpUHbIfHDa8EkIIKFGcwt6GPSHvIuGSUxslH5+xomTRkQKabvOKeiF8wcJii9sHIehUJxcJgSHMZusRbROJ3j4ToU/4WL12X5iSEahlJw8D0uR6SwZ7bNGkFIjB2Ws5KULaF9wWKvjbYx6YfsMf1PbGAEMvbnDrHcwTpcFwlBQ/WTHEEUg4MBOaRQKCaAp35BiqtiYNQ5VOJiiSUmYULQgyRv8ULZ3JJSghT8TzIZmdwZX5S77tqwfq/TlmdjLifPqnqdbQ5KWnsYQyOemITJuXMyWTStj1gII2c3klieVWm03w28Dy9ekvKHuVk5fsYr53LyDE+n/Wfq0yjbMdv90Ft+8zUjDbhN8I4z2w9l0vGfC0uHIQli0m/oRULChLDFFod5otTq9lQdRvXOT0mZia1tO9gGYYYuHpi+cYQJEUbmjIOtXGhvOxnXbOtbJuUsIkHngQUhR9j7c0FpDz1KqiBPToCMScSl/03KTiop/blRrvWvwdqvf+3dWccZn/RzJ2DX84QTfxIKRhVBk1iOoUl8cE5h1k7gTCPZQRWHjWBpDUVrjhIVzh6We26IgPH/JTnRDvEViVuuhCH/lxBvRZ6g08G+Y5Zt7d0GDWrNvKsVFiOqUCj2B6Pw4E0IpIOJFx4iInhF5zFQ4GWcsfh4xBnli8HrgjAiA28VxvdyUEGyo4B9W97OuPRVoSwEbw2HvFKM4W0JChMet4Uk5ja8FP6O43OLIFJwP/Wq/oDTDbn/KRQKheLawEaYDAEqj1pdJl5Uf7SD50E6Lc+IDFQXqZR94rm17b/VTia7+J6sW/Vkf1V4jCRg5toJFB2FojwDGT+8vCKKlCzIjELefw5ubOLN+tMyiUvEpU2Li/LGvFb3n1szM/IcXd+QSWo8Jt/L5WHGW/Wf53ffJeqWZ87POXcAPrPfQ2wEqolRGsMH44kZW7y+7RN8c1N2/xASBiRdbIRJGOZDvEnMMKWNCWQihPCxYVLDWBtoHkvChDB98OyKnH/Hl2ZG1uvj8ra0aQ4KkfnAx4QEzT2Hph0bbOTW6cArJea67U9964NXN5m5A2EpsFEoFAqFQqFQKBQKRR+FXOPXbteOOGiqjuL2hJImV0e/bGfoZWQJL0VrwZvTJbzRDTM5pueJUZlQYdKmBAPLE5Y3lhtNepswTljWyYH2oXrDvBRlPVcJJUVV1qlBsWLW4LbS2Pd8crSdfawE0nyq3HjcW9h3AW3eDpYvjPFoUSgUV4cXKD1cqk04DAjkci5LZOrw6ODNhNswpTE7eNtHjyJ8z7ssKQBmPx7TbKDocOGP5O3AC4XrZ4MbygLeTFBut4YbNZV15gaOsh6XfiT1EG+SIMlnqA/RX0OJPXNQ2ZgPy/L2UKFQTAKdsyiuEVDWQh+TcaDaZGdH7u9JeIIwtteg0RCVQD4n+6NCplaVsoitiv88Y+Tw8rK8UV9YKA0+e5CBmjKfDsps7rtX0keYmnMBJTr5wAvFxCw7e6KKO/icSsux1qr+RKfTledvMddwPvStH/2OkU64DfDWP3ruP1LZQdVIPMSXcZzPR6slv3E8JueJTXESVsJDxcq1QDNQy6yjBIhpNQT9RkwZE90WwiKVbeDxxWMWRfMeGP+WMLXJVlmUVGmU3MzhN3k8SOe5b85+fCx6YJvKO42df/v6Q3nnxB3rBbsvxHa6Xorl83MpOTtsl0wNDEYmjNiwnBvjjFwdGsViVfqExFz5A+0GdrBzc83T7NbF4ISECWGWprBhHit9bXtDMVjB30PIIRIm3Ib5SNNdPVUViskxuNqyYHYZsxs817wNEACM/aUBKsmKKwEhwntXiHG0S7PXVkBQoMTHjWMbjDBeR3mNC7Nac1/ICivrldF+RjHT/Nb4rJAjYZMpUc3g5mT8XeZhyEKT204I6WIGGBpVrFAcCF5IWbFCcer0yTdM0gl1lOqwLGd9Q6KKMwFxkUkL4b+2JhOsqSmUuKzLRDca9Z8tc7NSFpNKyjNp5bKMYJeWtgafe4gOnpry91mpCKHS7sjfSyVOyDGGD7xLuvBKoV8JjWZnZ6oj69RgYJvP2MuSaIRryorWcPyZ2JiSqVsY81PZIVIojDCZBJW6nBvZMSRI8oBxyJMiEZAEYYQJYfN9ScSknWH+LjbUYWDLSGJiHXHHmYQxZ5b5YQT7Y7kPP29X5Jp+ZYjBrMEaPFSeK1f7NU1qBDsBtGxHoVAoFAqFQqG4uTAReaJQTIp3nNl+t3banQvXdWqfePNL9m8oo9hFrBhz62FdIfHC8mZkG/KJdBppO1RpBJ/5cpdqcJrE0ux1YPIKSqfCdB/7S98hFUo0+C7Lb1gaw3IexiSngzfKNJplak4MfZCwsLJUkFAJ08QL21gEjufB/tRnX6F4njDX9CpuZRRCBIaw7hTeJDBVZiieFyqUfHAzsRi57qLE9BuqU4IyIipa5kHoM8KYccE0qLXc7Fh25F2St2suboBeUBLkdi0yN2ePnBCxxYN2hEUns9RoY7REyQkzolUoFArFgeB5kYjr7n+USLUJwajieGw0GY3lMgQVJBubfsLH6ppdYVIsynOhAQXMTlWeI4cWt3f/LZflediDmmS7LG/R7zu+Ovi8vu4rZ4oFOb6tbZnvHYWxK5N1CnlfQZJGGVEEKZrVmjzbMyglMulEc1CxOJ77753bEL2e967dfrGMOZyrlNRUg9KSLMZH6zAvPTQriTAHBZUUYYqNSWBxiZgIhX0k8zSgek4FSZBsO8t9Ol2ZIM5CQWLaeXlD1CHszw2oVFg+VYE5rIlrPjwnqrPPX5BStyNT2Z1ffsPh5/8j3aHY/WU52a+AUMgHxAaiqJ3DaXtccB7j/k5wESZDLsYr8DRp0GLANaQLyoHwPfvWHGcb20sG36Xiiik9sCAZECZOSJRyPSQJZxNMUDw4xiy+z+SJ3pAkl/HJ/ueuSnYViucHM3GfxkVfxZ3DXGL0+0iH+JxwuSlJaaB2nLcJxpQVIUutBA+wJG6KKM8ZStih9q9skQXTBwVstLVMaNffJGgTiRj2BctrpjEQCAZCHohhl8dXkP25JKnMOgUlTxSKg0HHAAo7XLf3eiboOJao3lJZSAQm1zDWmD4mMzN+2Q1LdUgc0K+kgXKX2RmZyNn2QY8VQ3Y4e8poDEi68PhW1+zlFI2G/6C8CyTJhYuzg8/PnpcShWxGXlpsBAQLo5GjMXmuJRPybCyX5Rk+P++TACwNch3vv4807DaAjTTxMPcJK6nJWl4q2fxM9gPj8eHsiRwOI0wMATHOa8S5CvkzDm1MfOPx/ZclG8KEYEnO3BivGAeeJmEEVJjfzFHEFpsEnSrKpx48snvNlD/05TP2C02xb4z8yhRVlAMihbz3NGYPUyH1/4Z02MbgewpvLklaYPFgCEHCpDP6rBjBEgidlWCfTcx3WJo2izekJEFqwY7CvFn4IjceGSVBSNDQwLEQ0kfGaJaGuLMjaykUirEw+elUk9gsOkiS8LIEMeCs48Zhbk4kEbJ4iJKIwAN64MSVs3iKOHtuemGkijGi2sTfeS8kscubtnlLybbxJkqDq205Vi8gWGhmyxu/V5GHvzuPCMw1v32uhXxWKBQKxfOEhTAhSJhsl2TyOlUUFcDMzCgxT0PWFkiCUklI9enp2sj3SIzMzSEWuCbfY5xxNCKfmwEZs7Ulk79sFsQNDGqfflaiiI0KhVHGs4gf3tgQAqnZlGMxpMmLX7QyWFapyLrVqjxzuxG8GC75k/Z2S7ZVKDT/2rnN8K1/cGHxLigTBv0JxUfYZN9M8MPididBsy2/O8mTDjw/6DFiSBMqXUjcNKH+iEzgTUJMQpjYon6JsD4Mg+lT+6v3YUJkHeaxxxaFPDHtgEdn6UP/27Raa14jjJAnCoVCoVAoFIobgatPjhV3NL76Tu+AmwXve9Ojn73djsn1vJMjCxW3G5Q0uQ7YJU/4srGFkpP59OjbxDokGOmQt43G54PlPtsYIBTgcxIDn7YTsIxVlOHk4/Z90AuFyTpLFuXIZkvYy7AymZmgTVUcH3dN8rKE0iazu7ASJSpW2F1GLVMPaY9CodgnzNuJOfqKyM3Ha/hvIVwqQajW4IVJbxJz0W8xvz1EhYK3VgOlCmpbh9bFvj16niC22IkH22Cb+XfebqgyCdrv4fhd3P+Gbsq417tmG3zZgluTW8TbPKhlXHMv32o5zkvUqF2hUCiuFfoqiXx+tOwlDFSbjAXu782GPGeOHNm0ftMoTqg2uYjSmaNHNwafqUK59Jx4kNx99/ruv7Nz8kxafk7mdaZcxtm1/ZJ12m1fjVCtiUp0akqey/WWtH8eipTt0ui4fH1DVAAs29mpy7bnZ/0+j8dtEtbbB52e93dsB7MfpcS1UJwYhJXnUG3CqVInSP8LKxNKWkpnHChVwr4XBuO9wnaytMmmNiGW1+Wamc7JNhqIc7b15+jZ6yObTlg/70HpAyemlDS5Ttg9w6h2p6q7EZwcVH3TEwXljk5q1C/RuSszSmQ4ewgMGs2aUyWPc6GOnTewbgHMRsmyTnaoXMZ+CuawDTPXIPeSACFiymycPUSKubWWO/ZSHc7LSJSY+V59P3VJCoUiHIas6MGgFSU6ron77bAOBR8buAFuQd4cEJxD5qskV/g9fPaC+4bLmyLJlR0Y0w35iuCGaqKNaTpLw1s6UZO4XfMHlG4e65KAoWMab8/BKh7uR+4sBjQVECYga0zM6u449/m6sSkUCoVigHy+Wtrazg38Caanrk6O1OvyfKo35BkQQVhBseCTC4uBeetesKxlZ0cG48anpNuVB8fcnL09nOiSgGg0/O1tbsk+5rGNeFyeowvz4rFiymcS2NYmSJDDh2RyuoXY4sUFf3llR5YtYd0Lz0kZ0FReyJhG3e+7WOz2Jk9iEff3K9Xmdzl7/EPGlaEQq4i8XZwRj44wH5Nx4LnDIQU/Vxv+uGgqbiddwnxOirlRgmI/sJE7bsgLcxrCmj49bCmNcibslwmgpMkNgJ3dULwg2Hj9a/+59rxCoVAoFHcI+rMF/e/m+O/mw21XKnKr4uFHv+k7b7dj+vU3Hvv/RhYqblX0SRNXiZMbg1i958VZRsMHiAl/4COF5qxNyJao0mgH26BaYwFvYbF4SLFSCaJwIpBrLFjKcPqoda/+oKO6hW7SaygJugvH0jBHaScTnamk/IEvi020cSfkwcvEnjKifhaD46rhTW+953y74zg/NbIRhUJhxfZXf8UPRv5u8FZgG2UylIc1TB0hLtwcSlZCUn0HqpAsy30Q2VuCggTL3engbR1flbB0pjIaFbl3e0Zl4vL+R1UM03TKo99ztrGMipah0iCqUMxn9MAGypXYfpYamXSinbbjHk2NugsqFAqF4kDodKKxTEj8sA3JpKybTjcsa4hyJBrih8kyIZqvGnQ6XIZxcTOOz6JYSabkmbOx4ZdL5AuiqKRChuPvbFbab8xjp6fkEcMknE5HnkmmNKiPp54+tPtvPCoKklxe+iiB5aUdUe3MTpk+QLhFvHd1CcYtCltiTZjaxBbDm8vYy3UnUVXsR6USFs9rQzTEJDYelEXQbz9EQDK0v3H7rdWl/ezP9W3/PJqbyo58Z287up2rp/u0oZwu7cDQdyqrSpMXAP2Sss+UWr03ml1nMAkwhEAEk4AWfm2WpDQssb65hL18hbHAq2AiYsF+WPayhr9zDxlsowJSwpTzINVziA9hZBn3PTdI4UFpDctsmBjKRKKA/GCV0DpKm+bQBxuWPpoa9nQ5PrKCQqEIRaPnfXsmiOr1QEoMRfka8iRt8SVxdjPS5Xu8kIObyBBJgnuCS9KZkWQGdRAVeEJ7uJm4fMaTKNkM9snjyKP+l22axjrmoYu0g6F28LgZ5FP0t+F2GOfMmDIMGkr4YiVoRyHeT+pBjZFCodgfRscFCoWzO7mKfDKZbP9NuVFfPbaY5TksvyEhEo32Rra1uSXlFibK2Nktf5AXByaWeH1d1s3m5JY/VRSyo1KRMoe5WZT2TPvtW16Zwd9lf8PxybI9N7hGkgl5lm2iPOe+e2UbnifPLUO2mDIcZ08SUC4r39tEAlC5kgr2K5idq32H4zi/5NzBsMXw2iKL9wOW1pAw4XIijLiwYQdpNOkk0nuCVJ86vN9yKRk/8fjot1LM2Qkig0za3gexEBLHgMRNxEKYXNmSa2d+Wnxair5vSvlnX6ORwy8UYq2u8/FoxBmQJ7TgMEQXSQTO/xnre6Uhg/LZQKVBlUcMRCaJlCT+jy36uAhygaasGyAoqCBpWQgfjk12OqPt/P/ZexMoSa67zPdGbpWVVZm1L72pJdnyGGOsbi1dUndLcpsZNBgbyws2Hs4whhlm2A2yBh6YeUYsZh7TGLMNnJnhmdl4PoAsGxsYm8GyLKmllm2pNbYx2EZS77UvmVW5Z8Y7WRn/ur/IuLerJHWra7nfOXU6OzMy4saNJeN+9/t/n4JZbQPkyiAGR0V8L2PwNFlAeyhCwW/Pmo2BgionRMokvNyocnBw2CgSnrpFnnC8PvyANSgPCy5C3Et8EK5eSE0CAia4GXokESib4+8iJXTiR1KEaS0JExKmMI/1EKMubfYX9EMAI4JDhAn9T8RPJYMbj81Xhb4w8jDBz2E6q6YwC8Nbq/RRudEiYC79pODg4ODgsGGkkrWQfKQG1Yf4g5QrHPzp34v1jGYXljS5QsKEpArJClGT0FCWRAWRhtqkWNK/W0tBBHAirn97ajX9W7UX656Z1eNCWZ+Ptr3yFVNrr5fhaXJhUvtL9OXa3bd3rzazffY5/ZQdns/Euq+bXv3368+O4VN/WyYf+b56m1LqYy+3ZRm9SDby/npqkRoIkX4L2dEVEBRmHUgYOcs6TFgs6Oej/mwGr6NeKTaISkVBqdKVNPbF0u8cGnRKk6uMVoXMn+7oHnBwcNjKMPyMOlwNePsCyKAAACAASURBVJlMLn/qTvd74uCwQRRO3fmHzu7EWZ5cAp+zf+Tg8NLxmzf3P+i6cUvAeZpsIiR2PXLy2bNHJtZalIeCQmKCOZ+YAD15GrGdexFrPB+sg2k2VLSkQRuWMPspm6F6nWoTxhP3Ggm5VtiEH7Rdv0elywDUJlTay+StB5nKMiZeGZnMdKIhUadgIriHJUWYcaZ/iyhndkHdcqFk0v47ODjY0LpGB+WC7MZNoYyLVxJroNbwCvAEoRJ6OKro8AtQjeyxlK9UeYMLVghfEo/RyJghCSlg6F0SlOt49Dbhwz0n/Pj+QDDL5xskhK234YXiMb1H2reoZy59+Jxw2ZA6ZyCJ7fkqFs+8Qzk4OGwIXrz73a5sx8GG+w4/9LkPPvwda58Wi1rFIbHEVJuEsE6JD5N7qNzo7dWz6B6+VwkSb7qhfsnnzeqVLrRpakorQUaD9JtkUv+2VKt6fc8+P7L2emhIz8RLpDDbRtA3padbb3t5pd1fPdg/Hz/4mW54VfTq3/PCSnv5XK8W/tTqZpXNdkC13nhnVzL+Jy91Vxq0dTDJQzaw7AwUGCPwCjGtjh4sKUPZi1o9v5CEGPxrU7cQhs1ZQbWJxCGrDUQis/0mX5RA/eI8TTYhvFbU5DduO7R2FjOYS57xR9P6NKrxmdznsvo/UoqzgoVpNMtoYaaHJoJ6zRV6HYJcoFcKQV8UWR/SNEMeiSMgeWZLuh1CqnAbJewTCSTut5A1vZD+r3ABEjfYF1l1vaO6IB5TZ0YfPrk/spMODg4hTN818fjFon/brltrzXRfJRYyaDXUH4aICpASPi5uj9rQ8hqjqsEbAetZScYIc0tjWBCnPrZBD5UQ+SM3MJJAbBtrAHkTkeV7QIzQiJbPDAOQpc4GD4lkpUnm8N5rIHFa8czx72/ftnq/7X+Zb9QODg4hLH/5n0ZHtQ5XBX6z8vfZGx969Wbr/eMnjq2dI8UV3LNl3i6l79OM1q3VQHjzZ63SJhRinv7dICkh3iaqw5Q1k2mTEkt5PVAkcUO/FZbi0DdFooYXF3U5wwgiiWlGm0jo308pTaLPSU8GJqMgQRivPDjYHsieOTuk29bAPqH9o6O6HdJm+qOcu9CnerurH//QOx54q9qGuPepxXXvRQt5fZ4M5KIeJLaYYULIhfWIhRcKmrbaPEheKpaWNZlGHxTb+9OBZ8ko/Eps5UeG9x1psonhatQ3GRpNdc1O7wMHh42g4avbWovlJ9dx5XJ4mdBWnxRO3fHDrscdHC6Nwqk73ybXjPvbBH9+/cOXPGAOOx7LpdQ927UPWiUhkTcdrgZcec4WwCq92pv0Cr6vVi20aeBqEkGVMaNLf1eWuKQDopnxvlSbcKSzjPfF+DUNBpuqkUUoTLhuekPKhC2leYMwq12GvH5fJjrmKlj2TxQmq+3H10QpVgPlOgKlzhxMczlZHDMoT2TZ5tGJb9nz6MmvRRrn4OCwhtZ13xKQ+BdiSrXmC6u4CeGlH5TchQxZceGFMmIYySvqlEZ0SmAVUJb4+JonpYi9jPzC95bMJUOqB/+RhByavUI546fQfqpC5AbIbdDMttcyIxPcnHyaz3KfmCzEPgq27b0CZrbxzO8rpf4gsg0HB4c1xBKZ/+5vUqONnYjsgUc2/T0r02OOHzYhmdS/ATRfHRleWv1XIos7wVKdHsP20lC6dHXp38B6w1xL2kQIg6hd+hE5TBPY2TldurAfkcMXLrbHkdddOxNpj+owgU1CfXP2fDvV5/rAAFYxbaj1XD+j+0USdrhfk5M6WWh4wFwytJ3QGrRfSoFiUptsJGa4jkHaeoqTxYKO4X0hhqtXSm1C2FJ3TGoTtZoQFC3FMZUfBe87pckWwirNkfTUIw2l3qhWy/z1dTMfDOZZckPJ+SJrfLzoy0UQB1zHDAYETLxpBDdcBPdoT5FWQg3axvKaAm7UMr4Yw3rpO5LCeOYiPEbEn2UZAxQSSVm0YwH7lQsUgjF0QL5mJlIQvqGKtWjfDup1fNWpghwc7Dh9ZGKlxX8MCiHS7Kg5JGFQCD4YsPy48krjD5uUwDC5BsRBKEGHTGs2uClARhoiJQAfZK23DMIjeD9EyqCdXh8Y4Xl4r0hbh+DdQj3onF7WR5uNyUKDlnVUO2oNW997XbaklL/xJx0Hhx0O329GRyIODlHcr5T6QOe7UuLCUh0bhDAhSFoQkuLTCSEaRkewLqyjgRIfki7xOOKTl9uDTLaHaUHD8Dl5Hv4nuWx7fSsoW5pErDFJyJ4e/O4GqysW9U8TU4hYliTJPGp1X3uDfdUD4bmgZOin/+ztz/7mOx64PtJB2wcDrWGOaW9MiTCJhGmaPYwGyBMhW1LwHemCXwkJk/XKhKqYBEsl1h8yicdIuabPcVsyD1ELtrOAVB2W4hB8X/qLfiZzS3odQfyyI022IDy56fx94HuSxAypKCyaeHBOglBYsXiXyIQtfUDmaJaCZftBLshAgWoNWqjSM4STrXXcOPPBLPJwmu3Uyw6TjAF5IiTGObzHWwJJjnmoV7qDhRbxHgkhWi/MG+KMd8GDhV2065GT5l82BweHFnmyerWUAwJj18RS2LuEZIYYnJJQoQqFbC2vuuDi9hknzJliKk9yIFjm2jchbxxcwqx+MLPWBVNZEkxPeLv1OvxJPSND3xEviztVX/AgQLJjCt9jH8BPRfrOo9KFNy/GK49gvwKCKPauPYrwm9VvZG/83KuUg4NDBIVnXv91L5a6IfKBw1VD77d9ZtM+c33wc9+xejOmv8niUnuQJsaxLSws6oEbDWEZKVwut8mK7u6oqqSFQkEP9NLdmmyfnGyTFT09Wqo5OKB9QmbntDFspaJ/D/fs1vHDQpTYTG7PnRtce717tx6/VwP/Fn7v3DntY5KB/0l/n27TN58bX/33Va+8uPbe1785ji3qQ379tVqdMjnZHsum03q9fX160Ptzd/31tn8+v5QC5XLj4pw2G941pM+jJkgXEiXprvUNXwVUvSTWqfDmWNfDw5nJvyUPn5MXEmsMONJkC+PSZ5LDVcOFoxNm+t/BYYfjwtGJuc4eqJTTLqpqE8ENDB0c7HDXx+aC3yj+zU7vA4eN471/8o5tX1bvPFCuGJynyTbAGn2XSXitipzQxSIcHCOH58pmMpLLyEsu2YeZYFoIMPFGPEi6oMaYxqwwPUNSHpeBEiTYTtEcdKGeW9GzrVTGnA8UJ+NQrFApsoxGFzEjK2+zxOci9on1bfRYKQUM5yTaPhhW1qyvhXNw2IEoNtTa9JRMKsw83RXbcxtm0vqpjgiueaoucB9QPZzFgPojuD94lNXhPuBTjcEIYHlBtQnLc3pwaTPimFVFsjyig0PtGELZDm52/rm2TNTr0/vEbVNxw/V5hqkVn1HLjC+b1koWvy+lYtd1heuLAhSeecNc9sbPDkU+cHDYwSg884YznufmrTYTsgce/cebuX1UnAhyhtheqk0ID8k6ojiZm9d+HrmcvqezDCiJxJtE4BVCtQnRDZVGuku/npwc0NsOEnsUfFDoc8II4/kF3b5Eov3+zLR+L92t29bA+i5ie6NBkk8VyUPZHpSuYshz/rz+3v79bb8VUfe08Hff0IqVrq76pktluhIIPFBOKaVuvJLbGe4zl8DEoBRJr6MasWE9tUloezZDEgOoNtmgT4tTmmwjrJXtTN818eF6Q72XxqcyMFnCA/41ePBnict+EAPyPsmAeZTi0OyVBItEI5cxQGEZG8cO6TjJGAxogn+78KxPQ1ka0FLZL2qtLMr8SdCQVmI7pFwnh+/VcCNPxqL9qaD4z6IRNKIV75XXPvmkY38dHAKcOTrRzMX1hbmEi3HgLl2PqxYgCx4OiAZG7/LiB7kQ4gDkbdxfQhfjCAiMGfiOCMtLw1huA+ZHHn6sScaskRUsvwnFGoNpKWK/Ag+SEGGCvvD68b0adlbKdbg5SlhZJwkvFH+6omLfN7LiZdJRZ7RV2W3laO7gI49FPnBw2IHIn7rzmlgsddod+82F3tf97039nHX8xLFfXPU9oU9JYOzKaGETybIRLC8jfjitf8uaKPdpBB4rCwt62d27dGlNqax/F7pR7mPC6dPDa+/Se6WJ1/GY/n0aHCxF2vb8Gc3L98OvZKmgf5d7gghjkiRdKT0IYFnOFIgZMc1lORCXXVpqD5B/+11/uiOez+99arF/1e6xovuua53SmVoNJBw8TaT8hh4lNFm1eYlcThRW9HmU7dHny0pJPyv1dKc2vEWDjwnhSJNtiLWzd/Thkz+10ztjM+L0kUOP7/Q+cHBoYeqOiX/n21zuWg9e1filn9gcrgi8TFePLWo0Fk896nrdwaGNWCx52nSduL+r9+f79fOb/fS87/BDvxh50+Gq42f//J6f3glH4UM39S+ulvF46qORDx1scOU52xgh6rClMKGadDyod6F6gkkyxALUKfVgxpKTsaGkSyjme9mCgJxkMAUNbKuYFmXpTF8qOp6iouMCFDI0nZ03mLwuhhQyen2LKK+ht7ko2wuY6O4FYUk5IXuuP9X+H41mWacDdc5tkZ1zcNiBWKj5v6Q6Isuv6dE3rPMnu7r23RnMAGSjyToho1YqTKD+CFWviMoudHthnDDuBDSgFWXGFMqIUHPo9em2+Qso9+G9UGRquHcpJuEs4ubKEqRA1RLaD5TwsBN8RI958noF7YHaxMd9ypvV247t7lLmXwSN/Kk7n8kd+PwVlf06OGx2tK4DLxa9LzlcZfiN926ZQ+BF77YvVm1CY1gm0EwjxYbjAUnIodFsuawfkqk24TpyfbqkIZ9vKzaGh/X2enr059Wq/q2iGkbWnUAZUTdKg5ZX9EN3L9QiUiYkqpkWlvK6zSlELTPCOJttb69SNqsrrtm3FqP8IaXUb0YW2Kb4vduG362Ueve9Ty0uVqr11YPclTL3EdUmhCkVx6Y2sZrrvwCEFLTBsx7VJoRNbSJlOdW6ftZim6k2WSiUlz9y13hWOWxreIz4mr5j4rervvqJzh1uGNJsVEfsb4Yy+GBxkhMs4WEZ0CBKeOTtfqyLSTrLGCPUUNpDsmVPUD50HoOOfmybFyMJFnqaCBhJPIB2LoO46TbcH1IYdEwWdTvG4LkgQRfcP+4Hy4BascxDn3fpOw47F189dMiXa433j5Hu8A9x7nBQj02jo+DH00c6Dv1PPBAiPhJo5D5GjxIfNyEP94RQMo3cV+AT4rNEBvcEepOQl/EX69Ft8BaVoW8K1j3QrsP1L2oZaYisWQI5wpuX3P9M+7FKnqDN6A/vLUPLKpMyP/kQzeo7sgceeSDyvoPDDkD+1B2HvVjKla9tQmRf9zdb4tlqrXTnRaCIiN9MjzllR0CPkvHxaGJto6Hv/yuIAI7H9G8jCZGlvCZp+nJt0mRqSk/GxzA5WyyZyUUptWk09e/24ID+jTt3QZM1N7xiau21JAA1Gvp7hWU9cB5DFPHysn7ozgSJQrTAWFrS3yujVCqZaKjf+d6dUb7TiU4/lMtBdmwEjeCZrlTWA9LejJkQMZXUSFxyC/OIH94zos8jU0pPFRHHqWSENDr9oZv6r400wGFbIkSetPCNILJYwXx1hqatlisiC4JCXpFPoWCFfonnYa4qqxiCaSvHBb2MSQbZwfYlgvaNYh0XoRqhSoUEjNgQkMyhTwuNZKm+GQkGaZVmlHxRqymo+n2qU4SUHcMgbwYz6iSmWp6RqbhqfMsTT0auVgeH7Y5/uH1itlT3h+TRbBdNnXEt5hKeytxcrsUytfATmFxW5CGKDWVC6PYmBAWXzVk8Q+gJIuaxvAHyKYz3ii4zCeIH2/FKdePnIfIE8IN7mkd37dA9nm3C23JDYq47BSs0vKUK5Qd2R9pgQ/bGz5p/PBwctjkKz7zB/IDgcHXh17+ZPfD5LZN89IFPv2ntPOrqaqsjavi5I2lBlEt6YJkMlCpUWszNZbEO/aBKj5FSqU3ALC1pImZkRJvH0nslmdSDUxrQColjI3BmZvXglQa0vYE5bmEZMcpdum2Li/r9xbxunxApNJ9t1PUPX39/1HS3hecCP5V0kh4f+vVKURMtrX5MJRsnfuPtHzsSWdEOwb1PLf7UpRQ4DTzzxIKHLMtQckOoVNvHwqZ6uRxgNLJJLQPc/6Gb+l1Z3Q5D5IyIx7wXpwF0uKKoNlT82SMTf+d62WEn4czRif/aIk42usvFL6XNU1cOlx3egYgx2iXhBpAOOxHuvN+82ErEicPmRbUWP/wzn7jn3p16iD50U/+HA3+PFiWyFFlg+0H8TDxHnOxMRJQnLXztUFt9IrwbVRcXoBThxGoGQxZRbCQx27oX8nqqNBjVK3OpTLypwzOEtgKU7u9F0s/ZQBLPWODTkMnTHoUJVv1B0kUJbaPSZQkz3IxBFs8WJjhTTbJQpZpEr0+8VWrYHj/P0G9Ar1r1Jb2fGfr8E/9BOThsc1w8OvGPSg1/jTCUS54R46V6VD123T9ZDpXGSIqNR8UH028gLPF4gxAl2KC5DpbRXaYoYtba0rsklHiDZUxlRR5UL75tqoZS2Wyw7RWLsoYKGKpX5HeAEsEMZnVoVBUobrzv3xVZ/0aQvfEhy444OGwvFJ45Fn3Actg02Gr3ouMnjrXKAp6LfPASQcVHL1Qh4lHSQl9fW6WRTmtlSh1eIssr3fieVrrs3T2/9npuoV1G4zOREuk3TPK5/rrpS+7UN58dwzYW116zRGcuiEEeG9Pj+Xpd/65Jas7qfmer+F53sM+6L6jUKWD/4nGoKuL+vv9wz4PnIo3doWh5o7S6kXtfDhJ70uuk9bxQMCmH8cSXUZ3iUnMc1mA8q7qDwYaUfKGaRPVg4EIfE0Yc9wYmjtMYMDyPh3l6DPQgnrNQi+rrOThattTT0a9kLCB6WAJDzxNKbegZKWp1lvxPYiARkegEkLENiZhJ7DfLmehpIgRRHI5cLBOqoD8ZjTyQ8n594a7bnhh4+IlHIo1xcNhGmK34f0fvn0rw25jFXaubvkXBhXL6yYzafydq5OSihhkqawc9EC0hpnI0eECCT0jIS4WpkSQigve9EBkC/xPeCMrmbXtyvyRjTGIDZDRJoTXShOsiy02fkxC5E3xvgB0eJUxW0Xo7++LHHIVnXl/K3vi57sgHDg7bCK3zvMNt2mEzwa/96FY7Hvcdfuj54yeORd4XkMwgidDVFRWUr4DsEDPYTpgih8+e00LQdFr/xnEdpaKeIKhW9W/KyFB+9V/+9Jy/MLj22kaYSNnN4IAuE0qiHCge169ZaiRkDPd/eVnvd6Wq+6s/pvdFfFgSIEYWQbQkk3p7u+ALMznZf7bTYn4ng2TDvU8t3qOUetBEmph8STaCJUQO91lMYF8sZhZXVCLm3fuR1++2liM57FxEz+L2c/kPlZrqP0c+cNgs+PzpI4e+Z/9jT/6ZOyIO2xFfvvXQi56xrS+6Z5crDe8d4y9hC17aESgO2xkBcZJ2B3nzInvg0d/fok3/AaXURyLvOmwK3Pext/rH3/agewjpwIdu6v94J7F071OLrffeEln46uDhD93U/3q9ZScycbDDWLajAuPYQjBjO4pkCibNUMk9AqNVKT+hSRAnTZkwU4N8rxwoSLpRspJH2ct1vZolZnnNTDmqEKESpg/miaHUH0g6lgNimttmHLKtlEi2QyNd9mgT7aDfo6hhqGiZ5iw0wJSe6UCd0vp6X8p70+5HT/5F5AsODlsUk3dM3FBtqq9L6/lLK6V6vH/sRnkeY7/VrqYaP9BWn/hz7dmJUNULFRiU1nFKTJbHzctn2QsTe2j2Kik9XJb3WabY4H4TeqqoGO4FOUvE8QBrJquRbVD1ovKYgaSqRZZh2hDLlQr4Xt1X3g+8uJKdTmRv/Jx7yHTYViicuqukPEecbGb4fv0DuQOP/tJWbf/xE+ZysBKMYX0fZeCZqEFruazv7yzFsWFqql19ITG+qqPMZs+eeeM3wyVB7e/GkMyzsKDD2oaH82uv5+b0+6mu9vID/Tod5/Tp4bXX2ZxuE1Uh+cDcNtenP784qc1jc726X5ZhAjs40DbeTWFdVK9MTel1DA5q1cT8fLs/CsW0GuwvuhKeF4l7n1p8j1Lqp1aKlbUknwTSbbosMciC6QV9njAVp783/YxSquXP8keRLzk4vABYyZMzRyd+eqHitzLMQwN8hkMwCCKbjJIgfPwnKTEEAmMeg45EMNjwQT8gLSpUUsNoZEYpS0kQPVE4juD4ivYGxaDN9E9hqk4MIy+WEiWC/qAPwwzKduIYQJFIkX0l08K+9bA9pgIJkYXu/MP+h5/4V8rBYYtj8a7b3qWU+ug5S8y4XOfzIEv3ZMxlNHNlX+25NaiDFpKDNyTe9nzbRRh8bEvmIQHD3/LAmZ0eJZ7BM6SzzSEyI7ix+GV9k/VIqKQtKT2BCRPJHCth0qsfKvx8EI1MPxaQzv60fviM/cvxuop5RtXii4EjUBy2CwrPvN78QOWwqbDV7znHTxx7j6hPKhU96O/qWp8EWVhskxJppMeEfgKxDvp8CJiqw9hipvDkspqUYLLOuXPtEp29ezXRQsJnGZHKTMXJBuvLZPTv0IWLWhlAkiPsQdJuf7mkf65i+AnkXMlSQW875vmR9fKZoYg+vwakUSFYRyxoQ1eq8W2//J2f/IpycHDYVrCSJy1M3TGx+uE0BivRW2kbHEeIOiWFwUMvBkElkBL0CpHxBYcq9Dfgsnn8RpAckUSpQQwS5qrmwdhFmN+KZQE9FFjyT+JjAOuQVFISHHipSJByUlcMdC9goMgjkcM2FqBI6QpYE5rL1pt+8dUnn+xRDg5bFGeOTHy52PBf276WcN1hd/qD5xWKIHg9L8IzaJUEHW2o2O68fjCkqISMMFlZXoTBNUp1CI1oPS5Mg+eg/SEfFDSa6hWPHiP0UxEFCbxNQnHHixYfFmkeiQ/ceLw+qFfm9U3U2xVU0MzoB12fRAtu8LG3bTj8aMPIHnjYESgOWxqFU3fZH6YcNg181djSqhOBTX1iAgmPVCrqf7IRXLw4sLrU2Jg2Z11c0uoQ+pEIQaM61CISNZztXVl3i8WiJjNWVtoESxakTCKhyZ983vz4W660f7foXTK3qNUyPd36N3BoULdpcjoXfE//duZyetskVWrwmenva+/rs8+Nrr03Mrzywfvv/tT7I41zcHDYsrD5oK4i7nmviLzpsOlQbPiZU7fe6h7cHLYkvnLroaYQJ5cV05eWdjq8cFwJ4kQFA8/8qTuviXzg4LDJ0TpvHXGydbAdiJMAb42847DpUG94P/8Lf/XmKXdkHBy2Dy6pPGnhuSMTzUxMi8spqU9AWYKqnbWFG5YJXc4WT1ei6+vD54WqWfWShUKEMjxRtYSik5kjjHYOdlG90X6dh6SeyUK2aVEp5ylhZ7l/U+ivUEposG72YRXr6MJMNsuS5O2lUBKQXvbGLz5pa6qDw6bDhaNtdVsJapMuQ4KuWvUlav/HVnrH96kUe8V3BDNKlLSRV4GkzUeyjheUtfiIJPbgu+QXoOhgJNZQW03iL+J7OfP3iFAqjuiJeWOlcVQ2WnLT/k+wPa6Lnch19EDWF+xjSGWT5o21qbxvTSvv9lDq4GWHr5qfzR149Nuv6EYcHC4T8k8fedDz4ve4/twa8JXanzvw+TPbZX9eiPrkUqhU9AOzKZnHhtnZnP6EPznwBczlSmuvxSNleFirUcLb1kqQfEErRJLJ9u9rtkf7izAaeXZWK0+a8HoZG22rYRpN/VtWRznQ7Jz+XrZHlwRVgxSewUHd9hlsgz4nCZQ2rQS+KdxGvaZf/867/9Q9nzs4bAOsS560cPqITr6gZL6GgsE+POSLCp7mspS4DEBmTpNHUblzIMVneZILNj8VKXeZQalLGqwFiRkatApRwvXyLpcJRaIiRjhoa3+Xmeyg1QHLgIaC5auW/i+in5PxKMES8r5E38+Wm2owHfuT6x87+a7ISh0cNgnOHp346Vqj7amkOsrlWH7DGPKhoIwkHtPvFVC+12XxgN17Z7HuxRqJUMkNSYmkhYEJCIoQobIRE1hZBzlbbqMfpTrTMPLrAyES3GNCJAhMYlUW7DBvBkL0mEp5WqBHDOLj15hdRDir2XD9vPfDl8ckdiPIHvi8e8h02NQonLrT/OPtsCnh+/5i7uAjA9vt6FwuAkXAUhwpQ1GIC2bJiufpTff0aKJhelqT7N3dmtwvldq/W5WK/p0hEcF1EMVSmyghSbJrXEcjnz6rD+vwkF7fwkL7e3v36jjhhXm9f038Ni4t6zKhXWPt/a5WGfes93t5mWa7+ndZ/FZyWV0CND+vCaZiMam6u2t3/9qbP/GZyE46OGxDvO+Bt/3rll1nV7q+X/YuEffXLppMpvQxz/O/9LN3/M3CVtr7DZn+JT3v6zXff1XkA4dNifly853zN9/6zlu+9AU3AHHYdPg/tx7yW0lcJDKvJBYf70kMHMm7E+ElwPtnQy1KKHXFNtCB/Kk7fU/578geeOSByIcODlcR+VN3HFbKe8wdg62F7UicBHhYKXVX5F2HTYlSKfnpex94++KH3v7Adj0fHXYAfubjb/0fsVjz+2RPhVwUgrSF+cUWedkmJQcTRXRKyD31R1rJYD/50e9Ze2PXLk2MnglMplPJ+tdGRgp3/MKxT89tht7dkPJEBdHFqkN1QTCNph4oUrowS8uZ5QRmjucxyyzrYLkMPRfZ3Uy8KRgULnGPahT9PR/TtPOYnhYD1/OYnbaZ42agBBEVPMsEWK7EierQTLRh3Mj+KmIlOcxay35xn2mqy3Ke1vr6Ut6P73n05O9FNubg8DLj/NGJb5mv+H8rZzOvjQrOd14bjOmWW0VotghldjmYpPI+1fI67bm+rrL7ofKgk/O0xSQ1WHVI/QHlRqhsJ8v0m/a2fdxfQsk8NI+lCzbvCemoHVVI9QL4UJB40jmhJCCoYlBGyKiBtSW4r5T9pCDDjQAAIABJREFUff9IZLsvBzylKtkDj7jYV4dNgcKpO1pFwF3uaGwteMr/7eyBR9+7XffvF/7qzas3cypFCJqvmmKLGSc8MrwU+VwhqnhsTH++gnScAtNq8PPFIYaYzZ45q72z9kEVcubs4Nrr/dfM4v12LHE8pn+/Bgb0YIwmuPNQlgwMtBUg5bK+ZDm4y2W10iVf0GVA+UBZ0kS5T3+fXpa/xPMwoFWS0pPQv8kriISmamd4oNiKVR67/+5PTSsHh02K+x58222VcuLhpt+ePOtCSlcBaq2h4ForLOtr7bprZ9Zei+G06lBxrRTb1+PYqL6vFEt6vTRt7u3V16Akd2Wz1Z/75e/85L9/uXtvw+SJCvwJLoQ8T/Rn/ZCJS7wwCQWSK6GyFjzLy9u2EplwQAY8RjBokpv2AgYuJCU4VikZrAfCYw4m75j7qSe4DzdQ42nyYGmhFySIlCsxKq0fj2Qs20lgfTJWLIY8VjCgQ78wkWf/YyfNIy8Hh5cBz9x6yJf7gdwLKDxh+g3L2+htNBh84fQKCU59vidxvabxPSFa939Hsak8f3VL9CMh6GkiNye/Zr72PVy8PspdPMPyoXVs5EoMyNwQccNaJF7zyyBPJGp4rmJe1tA27ouPm81aqdFVIk4IT6nvyR545M8iHzg4vAwonLrjHb5Sf+r6emsid+CRbf38c/zEsQNKqacjH1wChQL8PrLrp98IJif1IIjDhyH4mKSS+gGWyTvd6XYpaBq+KotIyuH6Yphk7cu128cBWH+/Hkh1d2tCSEp81Gpb26VG112riRjP07+jS5aUHhkyzM/rdeX69DZqNf17vwDyJBOk9ywXNWGS69W/xcmE3vbySkr2s/a77/6Tl03V6eBwKXzgM9/1mno99lVJnGphD5QgFyf1+6MjOmEr090+z+mZRFLW5gOUCoiU0RGtDp+a0tsYG8sb1zET+C0ND+k2LC5mVCLVfP8H3/jnH7zELl4WbKhsR5Dw1N8qpV4T+cBh0+Nrhw75XQk1c/2JJ0fd0XJ4ufDckYm/Xqw0//Fm6PDnPpOJXXf3xh8SHZTy3txf9n3/qis/WgPX/NNHVe7go44EdnhZkX/6qJlxdNgS2An3jPsOP3Tq+Iljz7QyAyIfOmxqNJte8ic++j1+d3f9g7/+lgddpLHDy473PfD2P1wpJX5QrUZ2R1XPWwn1auxXf+bj9/xqi3yNxdTzH3zTJ667Es1/QcoTFcwgy2v4G6oiZosHAjPUOaTccCZ4GVL7Xd36QEkJTwkzulR/UMlCiX7BkJBTRnuo7qAqn0as8qoIpUsFX6R6JY3JaQnZoIKGancqZFgGJLPkXBdVNsOQ7ZfxvpTlcJadyhSe9rZ+HOry3rL30ZN/rhwcrhDOHZ14zVzF/6qsPUUz1+B85jkZqhbBSVyAUkIW5znO64TJXLwm5JrJJj2VHPDV8KvyysfF6LE2kLdDkcCEnGj1jcXHdemxzEbWzXXhc58qNtw4vT6YwIpJLe6PobQgbo/bEcNY7hNLLblt1kfJvZzKlOG4Um/SMurNA38pd/Cx/k3YMIdthPzTRyaV8sbcMd268Dz1Y9kDj/7HnbK/NI9tQg29vKwVFrmcubTnxcD3oVT0zIXuVJ6sBJL+7m5tRt70qZzW3xsd0bPds3Myy6xnoc9f0L9NlPzPzOhZ61272iVBLFtaXmYJk25Hb68uAyoHpTb5vFaVzEFh0o9yn0ZD9/PevfOr/545M7z2XqGoJeWZtN5epaoHUEMwzfWb3t5fv+fB88rB4Qri/X/55jdUK4m/aW1hCSV3/blycM3o59FKTZ+rrLJIp6IKbo63d0M1cv6ifmSLxTGW7y1HrqOVkr5mUgm9jWpdt2OgP7hmkK61lNffGx3R97lCoUslkv7f/Ps3f/yyTeS+YPJEIX2Hgx8OXGTQnrKk3JAMWMFrKf1ZqprbRLJmFsvQF2G+KgMzvSzHCxxTkDwRLNKnAPvH7+UNpURMEJpFik8WpTrcVyF/OBDk59Uml0X5UDPaniLO3y4DsaMQIsLv3fCEizV2uPxgOpeAXkNSysYxfTg9S78uGjyWPAuhypOZ10wsuA+JHcjALaVGPAa7f5oGkTyoG8p2yD2AtFUDID6CGw5b7lXMD5Yqh+9hGV++bdmej2ue5UOmnPhQ/DDLiwxtChFC/+rql+tcGv4XcgdPHLrkIg4OLxD5pw8/qZR3q+u3rQ5/KnfwxPhO2+v10ncqlTYxwFhgG2RZ2/IXUEaze5c5LGMFkcJCGFC2zzSeJMp90iAa6sGgKebpGQSSLow15pBmYbG97ev267Kds/Bb6e7W2yus6H2VRD96Njz7nBZtxxFPPDigiZRsQMCwFGlyKrv2+vrrdDvmZjWplEY75PHmV77zk+753OGy40f+5/cuVGux/qF+Tdg1GvpaSgSlZbw2pmb0OTw4oNXbJZSnyTnck0HkN0iXaawjBqJVrjEhSNXq/UE/p/K65HUsnif0YOF1NNCvyROSvItLGfWrb3zp19aLIk/OHZ14y2y5+XGOKRgXLDG8UyUOBjTGMZvKWFJRbzCFk7PQy/ABIblAg9muoB0Fi9cIPUioFskEx5hEBP0Z2dOh+GQZ46AfqaahgStji0WRYvN36cbGy9hXUZzQgJekywBIqnkQTEJe0SR3MCB8rnV+KA6XAX976JBPI2d6/yRxPkvEOc/9Gq4NCizojyRkbRPXA3lvEpW9CRIswb9YdvB182uv6fNBRYcn2+aO8KbBq4ZCkOCa9xj7S2ke2VySQ5mo3wqJnZAxLK5zH9e5J98b1D84jFrmzcvjtnuDWObACMr7QT1ztvnh/Xbu4PY1g3R4eZB/+uhvKeX/pOvu7YHcwcd25HPNrz/6hvcpXx3n7K4Jc/N6MDM0WDAssT4qFf2wTq8DW9xxOZhR5gyyLdaXxvDiMZLNat8ReqLMzOjt7ccAq15vf4+DQw6kLlzUngxcpi+YfU9hYJZK6tfnMIvO2fX5+TaJ053RfVEuQWEypPd1Er4Ow8N6INuVag8+Twcmuf/p+//YPZ87vGT82B+/02/AALla18+bSRgxNwMlR6Y7SpaqVeWavganp/U9RK6Z+UVNlr76hsm118+d1s+UPVB8jQaqsVLJXB1+YVJfo1STiB8RjaVJwCwXtAqFfkWDA/peN7+QHf/gd/35VGSjG8CLKm7a++jJT/QkvfnIBw5bEs8fmfBP3XLrpX9pHRwsaJEmrT/zp5sTF592KYE2xN7aX2nT3Vvlr/mT+acP+/mnD3/BsksODlYUTh39r63zp3Ueba3z3v3Z/nYqcdLCzxz97G8oT52JfOCwJfGv/9s/83/2z+9xz+cOLwot0qT153oviko5Mfm+B97m/+wn7tkd+XAdvCjlieDrtx3yJVmH/hqimuB7/ZTRYx1M2RDPE85I0xNk0UyEhdYnyzNJpw8+1kzyoNJDJoNZasSkj3nMOKexjKyBng2cyK5YZtRlcZYoMJGIRyUPub70bQb9STVJwuIjkQkmCGqoVysbSiJaGOv2Xjny+ZP/EPnAwSFAK3Z4oeq3DKRDKjCbYioLjyJRStXx+SDMiPJQa3WjoqZgSIqh2oTXM0sK+wOVxgzK6Vrb8zK+GnrtUkhi5icNz9z4nkfTJN5kEobvsSQH6Tc+2kbbEb87qlTxuMtsG5YNpe3I29wny3UeiiqW9r+qS6nDvZFFtximcwdPOK8Kh0si//Th1oyTM1DfbvDiR3IHHjmx07thvfKdJjwG6k39Q1urorSTz7VB/C5jgW2eJ1X4eVAhIutgKU9Pjy57oU8Ly2uoJjFhekbPTmd79SyzRA03mnqfEnGtIOFMPLctyC/p2fBSVf+eJxGfypl4P5i1z+f197rgC1EsJyPLrra5Rz8fSNmEh35byuv++v3v+2i0oQ4OHfiJ/+97Vk8glt/wWqyiNGZlRas0hoPUrCmoSpJJfW3T8ySO9XWn29thSVsK5z4TtspQrIlChDer3l492M8invj8eT3pKfvC/evr0wouRo/TKymPlLFatX39Dw229/m+I5/d8LX1ksiTFr54c1ux0AM5uETk5kE4dOHz0TRukEW9TF8wwOIBIRjfG/IxwQBL/BJDZT3Y9kqDAyz9vb5gYMJ4X5YU1Wj8SouBYHEOctJYx3LDPECUcgSW3IRKDbDfSUNkMgemJHPYL2yzkCo5EEkL2D+SWwvBILUvGfvS9Y+fvEU5OAS4eMfEn1aa6h0rIDIYm00iM4HzcpfhmreVmLHEh3HGQsb2h3yE9Of0++EdUMiYhIEY7b6uoXp2wUCPzKdcr3k+LFrOBFbzyEKMMqavCu55HgkRulyLeSwJGtsOLqMTeg0BajQ/qoduVPq1lPb8m83uc/LCkDt4wj1oOoTQVpk4bE94/z138LHvdwe3DSFQajUM/OErsh5M5TcFmM9me83pdZTPU6IvkcIzIDv64aGwsKDXHcND9fBwe/BjM4klGFWcy7bbPL+gB4IlGGEycvha+JtIjDOjigeH9MBscUG/X0e5TyYYyI2NLa69d+asLlcYG+UgDl4wZd2OTKYetEE/rJcw2BwdbvdXItn8oV+6+5P/JdIBDjsW73vgbT88v5T5/dVzLYgRJhnKcjISg/QNkfN5z25dXEKy8/Q5TWBkQIhkgnV7uG5pRMuyuC6UwAlJmECMN5mU8XF9LT1/Rj+fjgXRxvOhewZEDvBSInlCTE61y+8qFf3cPD6W/7H3H/v0uibjLzmT6JYvfcE9nG5TLNWaN3/z9gn/H26fiDpLOuwofPnQIf+ZWw75LeJkO+136bm4qlZSbjDVwr8Ztsrgt+pf/unb/dW/U0c+ENlfhx2DwqmjPybngit32bZ/px1xEsZ9hx9yz+fbFPVa7D//m//2bv9H/+f3mhkshx2DH/4f37v4gx/5Pl+IE4cXD99Xv/crn7173THBS1aeCBhhLKoPKjtYArOIWWvTMvRW5MwzQ3iocOeErbxPCT8NZYuW92Vy1qbo4IQ0TWWlrIDbY5dy/1iOJKIcKmTYRzwqVMMUg76j+iXOhB1LJYGIA1hKNQJzzAboEZYJEa3+yCS9E/sfO3kk8qHDtsPzRyb+52Kl+c96UXKzVBXVCAzYsONYVM2hnIxR37IMr3MbyO6KeMNU6td5PpvSv1hSxBjyliJl361LvtfSI8Lk1S9HrwOvizV5MMRmKY5ceGEZjn7N1BxGMeM6DqlCBDR+pZKFztb6xqK3gc+9enSfVpf5oa1kEPvS0HfT425AsUOQf/r2iu+r1E7vh+0Oz1PV3MHHu3Z2L5hx//9+46tjXvNr8mF3d7tEpAD5ejZ7ecffVKxUMfOdCwxf0+lK5DsKBq8KJT6EJGy0MDKijR+nEU/MNJCennJkHWwbwXIDUb1Mw4i2K6Xb05vV7ecyr7y+7T1JhUxvr152dk4vOzykFa99uWj/n4bBZlcaca0Vc0nU0nJaDfYVf+Q33v6xP4iszGHb4d8+eM8PLhfTf8jzKJXU56iclyzPYfrNt75ap2H/3dd3rb2WUraBnC6XyfRo9RjHtzRlTQXXxwoSePr79TqkRGb1NdoxHFzHRUR6U6WyCIXMK66bXnst5z5jwZPY/yyuUcaQc9uzs9lgn/Qj4W4obi5FPl828uTc0YnXLFT8r/I9rpnjCNtgX8YLvGWGPEN8M7FBKwQJrCBBM4SBHr1LSC7I0vRmWLQsy6hUITy4r4xPZRxys2PA1sJ0hw+DoI51sESiJ5D5h8gOEDcjGNxVWE4RvM0zgSVDMcM+tbCAPugP2rcctGcw7f3UvkdP/pZy2DaYvmPiFVVffXOyZCY+1s5LXnNJMzkZCnPBdSAEZV/SJnzTXwx5FAXnM69nbo/3jTLOfTmdeY3yOpAyu31H875f03dRL5eI7Ii/bI7jIimxlt5DTxHW01kIGo8lN7I4030Y19ULPxXWLgmBxM6nP0oBy8oxeY9+0NthmO676XHnjbLNkH/69tO+r67Z6f2wk+AI0Uvj+Ilj71FKfYQLcYDCAUUSkvpqVQ+EpOTG5nOiMACpVJnCEzUrXF7W0cLcHgcxc/Oa3BkPymDOnzf/Vo2iHIYRx0KULKMEZu9ePThi/LCPp4LRwPeBJQgXETm8e1xvj4PTcqm93ywDYEIQHzyWl/VgkeVD4gFw7TVza28xGWkRfirDg5p0SQelF7Nz7X7r7anu/rU3f+Kictg2+Hd/9eaxSiU+mUH5Ta2ur8dzF3QKVDaIDK42ULaDMhuSCyTkSuX26wruCQN9mgQhhoc0gbm83C7toScKidM8Snj6sb5KsD36qpCcJGKoj19YbN9D+hG5TC8VeqWUyvpaS8Sj7qNyb1Mdnigry6kWcWlM5Lls5IlqEyhvXqz6fy6DcnoasLkcAzCdc9GgqshhIM/JW5ISjB+W9+cqZuKD4ByseJ7QcHXRYNTauS/SVloXkMxh79YMPixUunB8Rd8UqlNywYCTpAYtYugtw3bK+Ck02EQH9IN0qaIh9IhZ814JTXS3Px9Ne+/Y/9iTDyiHLQcxfyWXsYyTmOSJnA9clteMzZyZkHOQJCSJ0ZyFwJRTmwoTbmORShdcB0L48FZHbzh6De2a0HXUfnBNeFSEwZxV2W6dwTXhhRybcaNL4fUMfiQGQYjMBz9yiD33obIJqVRIlAQ3Ih8ciZchWYP2t7rrB80PozsNnqfO5A4+vn+n98NWxdJTt7dm1l+90/thJ8IRJxvD8RPHflEpZSxfLBb1wCaTiao1iIVFrZ6IIw6ZB2E9JUsZgxkSJhzEEDK7fA1iSanMsBnKTk4OBNvTA0F6m1QqZlFaYbndH32YfS/Ao4SmuTGDRyNn+BnVfPGi9osYgEKmWNL9IYPCXCiWWT/bTM1oIuWaPdoPIh+oAEaG9YD2+TNt092+bGXvr9/zoJYaOGwZ/PxffPdYuZycpAfQ3KImH0mgcZmpQOV0A9Qap89pE+Y0SMvxcf3cOzvXPr9IMpRK+tm0r1+fl4zvnp3tDc5VjB3gpZKGemoBccaZwBOJZO7IsG7PUl6TGWmsTx7AFxb157t3mX1a6PPE+00yULfx+qP3ChRyA/cdfkhfbK3l1GXE3kdPflIdnfh/Vur+z17O9TpsfkyX/T+r3T6x2s7uuHpwz6Mn3+YO2+bF87dP/PZMtfkT3XH33Ek8+1hOXX/EbC613eD94GCLCjPUB+08tJQKS0/dLr/6hb6bHs/t9D7Z7Fh66vbWhZrd2nvh8FLgiJON477DD/3i8RPHrlVK/Yut0maHy4OlQte5f/vxt66uK5Wqf/uvvvGTn3Vdu3nxaw9/x62+r55sExnJrbob2wkLHfzw5VWeCKbumPiFclP9MktSQgJ9NKErNPvc/reOKd0MZr1jWEmZBBTWJ2IXqt35ORUiLGsRpUe4ZAgMGgaZVIVIiQ5jVJkWYko+VZgspqqE2+CsNkt45BVn++nfQPuDUczQz0kMNIZK7KIm/kM1DH1aZG3LltIMqnPEZyLpef6BLz5pq89weBnxlUOH6rWmv3oG9BkUTDz9eH514xwoBGosvlejkgzvL2HdvFyHgouUCTsswwtdd1ifqLXmqLpa53xXtlIj7iwVbcF+j944r9RAMvI9H0YtHm8y9EKRshzstI/SGi9N2Q5eh6KymtJ4vQ6U+3gruh0hvxWRkzFSGfcmP9hv7z0DTd976YbhOwGeF//d3MHHfmKn98PVRv7UkV/0mw3jzLnDzkPfTU9Ynq4cLoXjJ479USeBQh8QRoravEkEtshhrq8X75t8TFgGNDmlU3h2jS9ElrWBs9P0D5GUHXozUL1i830RzxKWHbDMYR4z//t26wlp8Zlg7DFnunsRSTyKtKCzUATUgzKM66CQYXkRo4+XS1o5I6UVi4g1zmF780u6zaNBuYUXV1/5te/6xLcph6uO933sbV9v1L0bFJRL4yhHW8DxY3lKBefo2LBWOXUH5Wssv2GEOFOwzqLcRxQnVHnsGmd6lD5XeT4nkhxRtkEVCj2Fsr2MFG5fgzmLWk0ScVRnIk+AcknvE0vyqJBjO3g/oseSoAv3v7Dqpabef+zTuqz/SpAnLVw8OnH/hVLz/5b/c5fpf2CK1rUZtVKiT8KAngt+sCGWmxCpWJT4UDCPtf0aFzCI4TLydh/akMdgxVZ+YxjPhdZrG8hKWil9H2kCGzKSxTpk+VzKvIcs0xjG4G4WpRBSQsXjQGKnYS5/VYPBNluHJBn3itc+dlKfkQ5XDN+4/dBcsa7W6jJYnlIKrg+Wkg2DAOA5zHG4cAdc12I1ekNTHecfS3+EM2GpDq9Ltokx3XJ/IDlZp48QluW2JUoZH4dKeFheuIT9vv5w8MPF3UMZTcjHhAatQY1cqNwHZIfHazCOshzEEnty3aHvfSy75seiwnWQfuBVE/JPYflQ3Vf+u5yo4qUgFov/ePbAY7+3dfdgayB/6o7DfrP22E7vB4coHHHy0nD8xLEPK6Xeu95KKKXn4Ecwh0hiDwOUbK+W9puikefnYfA6aFZ6mrYtvgqqw1ckh/KaKvxWhNCZAilDEoQPBY0GCY/2tkNxwSj9iWNf+3J6ffl8m6RhaRDbMw8fF0apNurwhAsGxgMDHOTh2WxJE0EVRFBLTGsZA+TebsZE6+NAE9ulwJBzfqmn5ZPxFx9+55+9STlccdz7wNs/VqvF3qrPKX19rZTb5x2fWVNxsxnq8oo+R+mFUgpIhcKKLsnrw3XJ84ToDUiVrjRIBJTZDCGye3lZb1uuR0Z6l1HukwTpt7gYjfoegLmsLVqYZKd4q7AszkbmErweWX5nAmPZu1KtPvf+9udf/5lvVZe7bIfY9ejJD9SPTpyaLjU/FvnQYcei1vAz37jtkC9kVGscPNwVe/PeR09+yp0VLx7nj068eqWuvtpo+rGqmTd0eIH45mM59cptVsLjiJOXjmaz8btLT932u7Iiz/M+lTv4+Ju38C5tCuSfvv2Tvu+7B3eHS8IRJy8d9x1+6KeOnzi2aPNAcdiZKBS7vutf/tH3+blgkB2L+xd+460f2+NOh5eOn/+L737Ob6prtWopGUrHcdgK8F/zaw9/x+DP3fWZ+SumPBG0UnjmKv5XmazJcIgath/3xLRVf87UDGrMY5h9ZmyxlJRwUrgfqhCqJujb2IiS6msz1qtAm4YwQ18LlrGpYlhWwFl02XbeEtvcEyqVoJmmF7RNL8tUUz5VZELqgPY6uixCfRrwLlfNbZLuCJVmMHYV62M7pCSoy+LcO4SZ+NbxS3heM51U37Xr8yf/V2Rhh9VrqlD3n6k1VELUTDmc4xAwhK6ZUFS2QZllU2vxvJUDy+9TsUKTZW6PJWli7BpSgWF7lstuTTU1g3JAXtsrlnIy2Qxvdb34HksAqUaTjV9/uOCrph+RpnmM9GaCTnC9hmKBqcqCnM7rZfQYti19h3Qc33QxdmzbC9KAQioVSQT753r2zeHKwvPif5w7eOL7XDebkX/6yO/4fv3HjR86OFjQd9NJ80OEw4vC/X/9xn/RbMb+iKk5EmWsLGoTogrlQ8qgMNkIKJ23qUOl3IdS/IH+ZePaOfssST8XJ7X0f99enWIzC+WMbbZb0IQyZQkz4D0oXVgOjGaZXpKG4mNmVrd/z25dtjM3q0sypDShO0OTS90OqnouoNxCEkoGB7Rh7BRKHlje0dWlHxLHRoOSDMjFZ2Z1vyQwwG8dn1hMff6X7v7kXcrBivf+yTu+VqnGX717V/tYPHdaG/MzTpdmrz6rCQLFRhHGyjQCziO+l2VhKZTaFFba3+UNk0/446N6fVR5SdkbFRo0S65jWRrGdgcqJ5bmsQRmZlY/f7IkqBCoV5Ioyek85wRMpZJ7E8/3clkrYebmea3pch4xkVZIyrpmny7luwBT5927dOlgGebSv3Ds094VJ08EX7710NqGWOrBuFJJ4UhiPJG3RA5zkMYyHxlMdlsG6raBUnqd9JuE5abeHQzCapZSlhhOXYxn1kohWCZAz5AeS1mEXCfcO5YrsO+YrCNlFiXsP8uIeIJyYFk1+FnQk4IlHQXD9rgOlhdR8sQyDJ6NsngmWDgVV0ue8o5c89jJUCT2dsbXbju0uFzz+/agXIR+HnKe8HogKUHyJHRuizWGxTCWlYA83nIO8NrgtTZvKeEhhPAgt8C28XomxPOoiGtmgD4nIFUShvK8LgtZw5OO52gquCha/1xzeMWPqbqnSJjgovENfkWhsh4cvxBJwv7ixSTroz8KG02GjPFeaQM76jviZJOg6nmJ/5w7+NiOIQ3yTx+53/fr/1fr7I586OCwYXiFvpuecLK5K4DARPa5y7nmGkgVlu00g4FXDKQMPU8WFvSAh2UyHPwIGHecwCAujWhkGSiNwz+FpUZDIExqdb29iwEpQeKDiSP792kC5tx5Pdjq6W1vm+UKpTL7Qv9us0yBMa6FIML4H92gU4b/4TmdqO/hgaUG4mkk8LsoFfX2ONjkoJYpSTIInUNqSQLHpxv9WcQAUsqEBoP0lXi8+dFf/s5PvlvtINz34Nv+slqJf2cRx/gV1+mSrYWFdp/WERdcq4J8SKHkGt1WD47b3j36vP/K32sB0Otec3btdamkz51JxGn39ZVD61Id5W2zIPK4dSknY9vo/UPflCYeQ6XMbGFBEy3NJhJ0RjTZyXZKCk8aZUIkRuk7kkEZmpCuTOgiQcPrpKeHcenRc1/StVoYGmT8sr7HkKS6/+5PvXzkSQunbrl1dWMcf9CDQwZ0HFtULIMqDq844Ok1DAZtBqg0STWN+dIhtUx0UKVgMEv1C5cdMKhUFMY+DYMZrLKYr6qOQetaO7Es9zVlMK4NER9Um6DNNq8K6SJaNvD4kPAh6SXmnFQRsbsTFg+LNcUAlrWpErriXqMn6T18/WMnv11tIZw/OvGfKk3/PSu1tqU2iTcqPqq++RyQYxzyDzEonDqPyUAwUKcRvC0yAAAgAElEQVSnDVVJ7POQv0mwDl5n9CUqWRRY9OIRotLGiFtsedbObd4fqDyhbw8JQCFpuA0Smbxe44rXdvt9ub5GDpZVF27eIfaHnRf4jqhei9wuLJXjzqy9lEhkj5K4HlJaIG6ohpFYZtZuvccRJ1sBnhd7WnnJH88deOTEVmlzy5dE+fV/7/uNOyIfOjhcBrSui9zBJ25yfXll8euPvmH1R8MUvbuKtZk7y+eAGLWqjplhGdxkoG7p6THHExOVwAckCQKAEaXJlG5TcUX/jnYH/g0sjxBTV7U6s6zVHxcu6t9JIUeKZT2o4gCSA8QxzOBLzPD42CK+p9vDQfQM2kFj0HKwPEmQPRhE0zw2C+8SGYQuQpWwhEHha//RhbXXhRU9KLxwsU0m0fyTg83z6BcqDUaG2woFmuPOo18SOI/6B0r/Jx7zf/v+uz/1h2oL4d4H3v7vypXEj/b3lcZVh+KjCrKNsb5FmLkmg8E5+23XOI41lmU/ikLpOkRwT01p0o/XaBIkB0m7ruB8YCQ2r5+5OUSOU/UREGtC4qmOCOAzZ3VEOL1zxMiYJtOzUDANDmlChCobUZPRkycHQ1neb2geO9Df3i+Sr17o3gSSEWRuL9Ytihsq7Bgn3oV4Zd7HlFK/dcU8T0w48MUveEKgODhcTlQbfrza8N/wpZtv9bPBwHkFg+lQOJO3qnapd8e8c5mE+uO9j558/+VoyukjE79Za6o31Zv+bt9TGRn31izkV58tislhU2Lm6bRKDKbU+KvNcuHNBu+6pPLvyriTaYvA95sHlV95bOmpQ+s22FPeOV/FnvG82Jc8T01fDgPbwqkjP+b7atT3mzd7qnmjr/y9kYUcHF5GxGJJZ878MuFnjn7WEwLFweFyotn0Xtdsev/l5//iu//LxYAEoEFqEzNAA7nSQizuPxeL+V9tNrzP/Ye3Pvj/Xo6m/PxffPe7KuXE2xt+7DXKV3v9plplhThon8Rgv92+dGQ9Dg6tyqyXVXkieP7IxErLOFR1lHpIUxgjWqSqBDPgLEmh4kEUFKayEdVR1sJJXfE3yWJAa1OmNClxCmalber7hKWsRQgyThCzzYxlbqD9okDgTL6tzcuNaDupvLGpDqgKGaQ3RLC6OtpjK3NiypCoSViNwXItgtG5A4ZI2x6mF2F7LMGSJXh82Z8hPxa8llWMo8SCcds8z1jGxdIr0/nQbaEo8wYvm1A1RihJJvL1VWSDfuTH7ENeSzwfRFHE9dKXJG+JGZb9Mwi1VmFL0KHqSDbD852eQSHxGAUd9Uuf+8sW/yApa+O1z2V5XsYMiT3RMDOl9ty0EJay9CGLP+g7nxIZw/mpOsp9PJJpwXfJ0HvN0AmPdYB5Dxrlvamv2Rx1UcQODg5bE303fcHyq+dwJXH8xLEXNygISyAjHysoT7oh0ae0P5vVs8L0YRHYFC1M7/EwKM8F66tWdbkJy4hYykJFx/hYWx0wN0dvE/29SkU/FQwM6DbXgljY+XmtwKB3SX+fXjYZ8nXQbZaY52Uk/ZBcYHlRIqbXsS9Qy3zjWV3iM4jSICacjI/pvhPPCUYgszSDZUcxHFfx12DyEBOX6CHzTZQdDQSlI1Q71Gv6HKCa4cw5rQIgRElEr44Mone5L/TUmQnSjnaN6bY16lQu6I0s5TVx0t8XTW6hLwejsJmSlA/ep5/HwICefPvms/qc279PqzsuTravE5ZlsYyLpTpl+Ouw3OW550fabcc5wH318STK1JzhIC2HCpLJSa0+ohqD0cFyfnG9fSgTskUKm9Qf0naFa1F1lM5kMkFZEvqojmtjvZh1teqP1O5Hqt94TrFkqEN5cuWiitfDc0cmPjpfar6LpSN1gzcBUbUM1E1lJmVLfQcHR1VDWYFp0N9CDwY2NQN5wDIbFWqPedtC/tQt/Z8DuUBzznzwvRwGntzVUISzYeDMAS3LI9gKGodyPCdtmsPAmvtN818SDaIAoa+0ZXwc+kC8UELRtTHzfnMdsgQPSQkLZy0mo6b18maasZRShQ6hLGJZR9gGI1r+lWGZDdihfsYIo/+l5InjahJ2vA4yoWut/W86VEESJYFUB0klx4Kf85xjd5IcCYnpDNsmkcRHJiqIhQAzHLJV9FtMc+U6D6l+cPKXLF49QnaScOR5Nj6hJb+KZGAx+HEBocKoYt4UPPqVsNEmsD8t5rFeX0L5b+tt+J5v4nwcHBwcNj36b3bEydXE8RPHPq6UessLaQJjhDnIzhjKcoRkUKskQj3yeSdmZtqDtz4L+VAq6cEf40eFHCkW9WCTz2P0SyjDnFN8U06fGVp7jwM3RhE/j4FeV0AocEA7OKjbTC+RBkgjlmzIa5YaleH/UsS+0uhSSiSWUW7BWFk+W8/MIPI1GCySSOK+9oCUYImIbCcFoqIWMqWtG78nxruTM5rwevUNk2uvSyXd/kRCr2MZkbsyUCdhslKErRbaPzysCYWZWU2+CUhckQi6/rppvV/BoHwOPiGz8OchGUjIZDYH5DwHSDKmQETIu/TW+eZz+jxLo8/pX2MyXC7CRLUZ4iNxPl+jzyMhIHhtkJzM5hhVHD0mPG9HRjThsJTXKmhTSRr7PlSqA4PXcJx4+19OjA8Pa6KF5yVBgkUIGxNRe0n43tWbmbzusZPfe/NT7gfSwcFha+LMiT7VVAkLlXN10Hx7RvleM97++XV/7s/9ub+t9OctO+Lk6uO+ww/do5Q6uNP7wcHBwcGEq6Y8If7+tnYSj0jpqS4gu1O1mGky7UPUD2TYihYlBWewZSadvVG2GNHyfWlHyNcC66DSwxSpbDKqVR3lFGynlK1wG6aSlU54SvbPrJjg+lgas2JQLlDlQAVGv8GkkwiZ3aKhNYMCSEFVwXOA/eKxPArnw4KhU7leTtrztZwDVEMxPYb7l+dBoW9oPFoexThnHp9QVUfwL8nXhEGVFVoYfUPTXfYRz32W5cjbPHdMSbmqQzElx4qyhmhvB9uzGBkLBlIsN9Fg6Q8juUVFwyqoLBQkLP1h++UQNlS0Daqz7A9KkC7DPSEcqRyozsZ9teeV8EGR9qPkiydaSDXCl6G6NwOvjTK7sIQprtT+pGoe7Yp8xcHBwWErIBZL/VLu4IkPuIO1udBZxpPP6xn3XFabUVJJEY9fWkUZWkdufQ+xSpDyQkPIZoMlCBostZFnRKb1sOyFKgfOhmez7Vn3KhQyNLktYTafSoKp6bayob9Pz9oXUH6zCwa1VMjkC7o/EvHojDnLN7pRjsDZdVHA9KNsJAnlxrkLegY/3UV1Trv9NIntQttmYSzK/hgODEBpUkr1x/CwViiUS3HjMmv7AbUCTW6HUBI1OMhyl/a+UnXhQ73Tj3KRItonRqtcViKeVYcCKIF1XwiO626aAy9ppdVenF/n0c+iSGG8bxplL7Pz+lwdgrFrT0bapNsj55bqKBVj/9PUeGAgKGuBWoPXD9UwFSil5DzgObIEo9yVor5maIQ7Pr4UrCuFZfVrqmJGhvV1IKV41QrLb3TbWOIzPaPLhzKBVw3NmyXtqhM8n3n99/dd+t4TNnvmvaC0OciTFp69feLMYq25T3WUMxQtCS3dhmjQVQRvlw3+DqqjVCdmWEW3pSyEPwWmZBMSOxwnZiyki7zkbpgSSVQHeSCLkNSwRdNyX8VTg2Uq7DZ6kMxZCAPT9+g9k8U6OAiVgT/LZRZQC8I28xhLaQUH6hxMNy0JNEL+kAQpgMCIkwwwrKPXUO6k0Ieqo9TDww1OuoCJUhmM9kPeOTy/gnawbcXQMdbLkuSQ85XnQ5j40K9ZCibknW8ptaI/D4kpWV8oYafOY63ftxGH5eAY8tRaCTFrGqZSoxDZhmV5LTFxSEq2uH8mMketnu/R6yBlIaZYCtZa5JV3FOSDSIN8JuWUzCeBR8JETnRTfLFa7TC9ih8YqKtk0+Ks4+Dg4LC50X/zF6MPGg6bBsdPHHu+VUWgOmTvLKuwgQMQIQxWVjDg6Yn6SXSiUGgPMrMgawiWDNGHQXwPQrHGKE+hnwf9IiTdp6vLUo6BgecFpHPIthmNTN+EXuwryxRmEJ8s/hM1JPO86hW6rIUlKQXsVzogd6Ym9bpYNkHflxL8J6T0pbdXt42lSGPwR3n+rN7X3UFqzMoK/D769aCefiVMeZGBPz1YiOtQEkVPkN3wvjgTxEOHSjYG9bkxiSSjbhzD3oAYIMnAJCMeS/qUCFGS7SGBhkhokFtpDNSlLIS+PjkQa7Mg+kj4SPkJvT/68D2SGTyPeO7vDgidwrLeRrZX9xH9gwrwbJFyuNER3d8VpALl8/q47dqlz3O5ptkXJCeYvMPY730oTTKB6TfcnrRpFqVYPJZlEKNFvK7V9PUzNtYmccogfBh1filsGvJE8OVbD4UaRN8RDoarFp8Fk6El95FECi88IRVInnDgbCM2pB1cL+NhqcCoGIggDsxIEiTwH5OKhmPNfsy+r1iMdMvBbxwHjQP4HskMfo+mq/JdxktX6ua+Zd9Jd1EtFFIGUBWi+H77Axs5ZBtwSztIjPA057apWpJBPckx7j/jbdkOEh6mQbnJ26RzO9LnIQWGxbCYC4lHShkrDsV7k7xDf8mrkAoHK+aY3eTvYuArI+AyJHGEjOE1vJ7aSYGs4HpJaNGzhcc7azDjrYbUY/p9drMswrblQ6QSFg7evu7Okp+oVdufkDGi4gvkSUht0hWSUrWXrYBc6YqSJ80f0j9IDg4ODlsJnlK1vpu/FJ2Kdth0OH7i2OuVUg+94Hb50ScEkgXZrB40MvI1EYol7lWXwkCfHhRyll9mqnsYw5vRg9AZ+G7Q2FXUHSRPTp/REa374RER2q/AEHcFBpwNRKnSGyMc/6q9VfTMfx3vmQkm08CSxBT9UXLoZ3qanD3fjn+V6OEWKvBY6YNZKs0584X2AJ7qFxqSEgMgNpYL7fbNgDgIPa/hWFGBsB+xvefODa7+WwYx15uhQSjGaCBKrgmOG0kJ+vNQFUKfGfFNoXqH0c5UVRRWdJ+PDK0En+ttkDTiubp3t1ZjxAIjYI5RT4O42gVCi7HF9P7p7hbiUBMtg4P6e4zv5flw7kL7fGAaEv1f5uZBusBUNxsoeOhLRBPYcplt09egEJuMELbCQByybze0DgNmoGgZGdHHQcybVQcRVCx1/735TL+K+LYvPOlZ/GIdHBwcNjWe+3y3N/m3fVe8id6hHt8RJw4ODlsV8XjmnY442Tq47/BDn7vv8EPu6dzBwWFHw1P+vZtOeSI4c3TifTOl5vEuw8yz6pgtDnmeiL+BoSRCdZRTkKQRdQBn2W3lJIS0g74QbBuVCPzVEaUBY25Z1sJli4ayCKo8Qm3DfpcNCgR6Z9jKowgmzomPhy1dpcfgqaHYpyzpYEkD2kSvEFHDMFnIVsZFFUDawL5RMZC1rE+aZOmKkOLBlq4k3zVrDuyKqWwi2mYqMEylW2wzU2JWDOeLspzv7BcGxlAlFLp+gpesEaFHEc8NtpPnhpzPvG6597wGeSxkm5zI6rb4lVAAJEKpUNKvoS862yzRxk2D+irSNsPpcP1dy02l/ChBXbTUgzNqSfxNeFDEz+mf93R+08HBwWHLoP/mp6I/eA5bBsdPHPuwUuq9bC/jU+NQjVQw4yxlN3NzevZ6aEjPhotyQ61GrGq1gnh3MHmDpTFMAxkc1OUGkurDRB9RLajVWXKtHqhAoSCpMf0oQ6EfxsxMNLVFIYWHHib0PKH3CsH2y/NGIqkfPOhJIV4PqqP8YXR0cfVflgnlUd5BlQMVJHt2t79HLwt6Upw+rRU3VDmIVwhLmOYXdBnR2KieqS/Dz2IwiOqlgiGX1UqECmKSazX9PZaqNIOnrP3ww5hBqc4SyrjGhqnSCD7P633NZOg9o9/vhvKnHLSJKpX9hoQatVr6o89h8X2ZnNL7yvhe7h+TiiTymZHR/F5vVpeWtPw3BOcv6HPbD06fDCK2qXrZu0dfP+fO6+tqLPB14bKMJ872UsFEL5f2+XAWKiqW5PDa5n7L8EI8dFa3h9IZqj/4PUlzyllK+a4kWiTypiVPBF+6+da1BnIgmImbB3dSEsABWNo2OMLPt6zbRpIQjPg1RQCzPIJjH5ZhrBl9Yj+4XhImJBTkbQ7iEobBu+oY1NYM5SQs2eCytvIUaX/IgNfiJ5MybNtU7qQ6/ClI7niG8g4O2kO+MGhooRYt7+CxDnvg6PelzIff67fEGidC5IJeXkqN2G88V7luEg3NF3T+4VgJ4YPP6xshAA2EgokAUB39JV1Q7PD7ENCLiL4oJDbknGlayulIGpmisElUcl8zlvIaWUXvBo4D7xVyD7GZDdv8XWS/WudW73hT7bu20Mq5xhex8Si10obUYfGgvSqlmnc6U1gHB4etiVg8/R9zB0/8mDt82wM0k2VpDf1DaExJGb8J4m2iOowuZX15fG4bNJm2Nz3dv/aekAyXwkoQi9uDmGXGHc8gspaDaPFZSHdXjGunD0MdniY02E0kJV5ZL8sympB5LIiUwYH2oJd9xME+jVNXVujx0H4gGRqmP4Xev93wmTh/Xg/OpZ8ZGb0AP4xRrI+ki/SdlLSo1RIM3Z7eXt13ywXGFutzR/w/Uik9yKanC0kQGr8WAn+WGKJpGyDFXnm9Lk8pIho5H5QadSMauS+n2//1fxjX20O5ixiqxtCGfpRBXZgkaRZ9GBwd0X1IY1Qa7DIKmxN96XS7rSzPuYjt9cJc1cf3msHsJMkalsbML8CQGW2V9dVQasXytVSXbjNLveTa5rW/sqLbPD5+6euVJBzLj3hesmSNJKhcS/Q5oUcTPZ1wDt9/3+GHfjF6tDYZbv7SF7zhdOzDm72dDg4ODp1Ynoyprz3R9yKC5MNo/qte1bwz5WJX3Z/7c39b8q//lqc8R5xsLwRlPP91p/eDg4PDzkCLOFGb0TD2Unj61kN+U2aDsVwf1AHVgGxi+o3B13EVpoQWLmsraSDj1GUoEalaSoM4sy+z62z7Ys3cZkLUFhXLzD/3z5QcxJlz0+x8J0KlRvGoqocz7hWDIWmo7RZ1AfvW1Ixwgiv2ietGxUOtEf1eSOWATjCVmbAEhoa/LPmqGkqiuD6W7dBMymYuK++y3+Kmzug4/+SU4aJ8nTIoNxSkcrbQKqo72HfS/zQETlvKdrhu9qkoipbRoTj1Q+0Pq2Ha/2HkcChVhxIRHvvgXypTqJzh8asbFFoZSzkawfN5LU4cy7ba3DXoq72vKigPJ5WPk9+jNC3Y15a3SeO1xsvCwcHBYdMjFs/8RO7gY7/rjtT2RmeksYCy+2xg6GhToLD0h6aSa8DM8jKMUdOI76XRrKRoUIExh+jdZArLIoFGyiKYQtLfr9uTSmrFRxlJJKJGsKlwCPYLlSB6n/Q2ivic0bpUpEi5C5UwTFShCoAlPKLiqNf0e6bZ+c73xVB09y6tDOAJ8PwZmrLiWS9Q3DBBiCa3jLelamQeygtJ7GG/sLSkCdVSTw9jatv7OI0SHypaMt1agbBU0Odib/B+F0t5UEpFxQNjkHO59rFi6RYjoZv4Hs12xfz32ed02hBVKDwvczmzEfDFqbbK5IZXTOl9ylPdodcxBCNZiVqmSWwNEdUs8dk1rkvkFoNEIio+WG5GUM0kyphk0pxsRaNZqr+SgXqFEcehEkCLCSyxXooX0bqWkonm2P13f2q1Y7YUedLCuaMTr5kr+18NDQTxuYxzOKji4JXlHcVadN+Z3lHB/X3FQqTIYLhu8bJg6ULd8HthWpfqKOEhTGVCHKjb+8WLrNeUDKM6yB/TwNLmQ2MbRMsAmJG+HACTlKC/iewrvWDYh9x2KkQU+cH2NHhMei2DYemPkJ8MPjfFGtvAtJqqoVxLdRBWsgjLi7gJ2+ak7waZgGSx1CCZIURDuD16AQbFMLZYzqOGhZxkUhPTb0Knc/A2fW9YVpYgyWZIt0lYzn0bSyrHlX1oi6M2SfFSltK09ZKMeizbeNXRFd9Twa87bzI8QOmYar7bHOXn4ODgsPnh1fpveSo6KnTYtjh+4tg9SqkHqygVINEg5MdSQXtjsPyBoA+IxOimEAPLAV0BHhdSvtLC1FS7XGd0VA/yKAIlWVNY1oNJiX8tFvV+DCIxhnGtuZwmVUypOCRSUvBeqcEng6SElAcw3YNRsRwgS2kGQSJiCe1kctBQKHWl3Y7zGBQPoBSEBA23nQ18SjJIL6KXSgXxr1V4VUhCSwrEVRrlRySSxsc0MTODqNt6sL4hlP5MTTGyVn9vcVGfa+IRw2HvXvimLIHQioHgk+XpAzKGGOgpeOAw4rgvINzOX9Bt378PMdZLen0sVxKSZ25ekx3X79cRzo2m7s9JlOLQJ0fOKZbk0CuFBCbJRSHheB2xpIZjItu1awKvZ563ck1Pg+wIJVEh5YoEmZTidKNEjtHdJAvT3fp74QSgZLCvy/jcMoBS6rfuO/zQT8l/thx5IvjaoUPFlYa/euZlDF4ansXAlYNe+mvUTd1gmL1WHQNjGczT64Gql9DMP4mGoFEkcEIGqHjNQZrJh4FN5/smYqZqIDVUxwCfhA/XJ/4fBWNnhUkQDqJLBsKnypl6LGtad49h/zvbRtJFBstpKkhwPRg4rHb7gsV5jlBRYFWkGBQdG9EKGDxizedhx6Ce5IFcv+QBOQZnH5EUklc2BVDNMqYXcpGkhsmgV3WQJ6aoYl5HbEfIwwftENLORmIlLe0wkn7saHyt26COCnHnXDZE/uj3184/fE71jlyL19680Ol0vPqP/5ZsvdldM1P2Dg4ODpsc8UT22tyBR06747QzcfzEsdbodUOxczTbpMcA8ULiTDmAFxUKVR70N6AXhYnkIcGRZNs884PauXNts0wO6jng3oUZd9P+KShuSFSQPOnGwLNI8idQI4Q8SEAckOShSWq2NzoAfh5Rvrt26Vl79u1yoFwYHtLElJBVq8CjDT0uRKHA2OZclsohveyFSb2+Peg7MalNgRCiEolkVBleLxJbXIPyZhjHin45Q4N6QH32bNvrpa9fk2N9WX0uTk7rU50+NOmgfTRA5bFkRPXoqCYrhLy7SKPZrNncOB43jD9WTX8LQV/ofZIIZNVxTHieCzG4AjJxD8xlGWFMj5XTZ9skhxgQqw7/kFjMPPIS8s0Uu92J9byLJnG+0CuFxrvcbxN4fEA4nr7v8EPXcvEt+4D+LU8+uXpX+CIMZR0cHBy2Cp7/0oAauKGu+uRHen9KNW5v/dA54sTBwWHrIRZLf7rvpif+qTt0Oxv3HX5odRRjK+VxcHBw2CKIECdqKytPiDNHJr51ttL8isJMdWhW3yLnTyejM9VUgnjRj1fBWNn5IE6Xk94hT5R1Sly4Cc7wly0KC9+wbCiCVZnfl+XTlpIVdgVLbhhZK/tIb5MefJGxy+H1tf8dQGmJraSj26DuCJVuRJNbQ21TGyhR4hlv8syIWfqWsJXXSNfwPZ6L6ylLqCppshQMy7K/TKUsNu+ZhqG/7Kqs6LLcHvvFs6yDy1A9JMoRfs7SLImo7tx2Zxs629m0tFlWHUpZ4rWBdVM1Juc+mxBKSML7ptQiWx/yoEiy1fV/0Mz7qp5TDg4ODlsMnorV+295OumOm0Mn7v/rN76n0Yh/RK2qH8z+HybMzumfQ1E3rCABpSeDRBsoQZguIj4KjDjmc6NthtsUcWxStGwEjGhlCUV3hvGvWv3wXKD6GBulfwNKf1Duwuc7KUFgMkoS7aQiggoLUd8wKrdU1n3INJpe+HXsCqKin4NKRfxTVIdHCUtV5Jjwe4wqbkApwRIeKlW6A+XMElQ9VIXU4R8iZUIK5Ujz81qRk0AZRzcUOfQ/OX+xrWhIo2yMvjHXXatLakR9tLq+YB1UONEDhwofesusKZegPioWzYlLWZT7dHezHKZ9frF8isqtKag4ulEOw6QbAa8TeomwjEaUWwtI44mjhInHmNePXFf0LSJMJW0KXigsATIlbakOrxSWma2HSiX5xPuPfeZ202LbgjwRfPP2iYeXqs07VcfAhmU9tlICKSmpW7wX2E+0KVhvcJe0MDBSErCRkhSWtUjpT9UyMLOZjErzbX4RNv+TpGEwH/KQwX84aOeIU1Ztaxu/ZoqgZkkKyyrYX3FDn7Msi78y3Cf2nZRe+DQkNZRxdOxeaFBeM/itmHvWHDmct7ErAMk7MT7lOcfzk8uy/dIoliLl6+b+JOEm3ytZyn1CJswgRAo4iHIMUzgB8zXztikLFI8Um9lr01KGJ7toi9XmAw2jw6X5IUJImdFYh3QhKRPHJ9mk99nrHz/57fL/hS/c6GbqHBwctgwGbn3G8svu4KBx/MSxzyml7rpcXcJSnBRKPTKIF56ba5c90K9kI8F3MgDeu3cu8pla9c7QJQ3dllhiAcmTkWFdAnMaXg40eS2WpKxFr/fsOU3+XLNPt4mEjvi30GiXxICt1EjQQHTy5BTKUDBApg/GwlJ7kMzyDsbU7t+n94nkQT7fPm4k0ujT0vRpXBtp5iqkFCoNA9cSynMyIHnKIIKkdKkX3jQXL2oSYe9eTRJMTWnyTso+hod0m8+hzGQcRNf8vN6X3bvb65uZ0euiSfGoxchUPIPmYW48NqaXPXNGR0bv36/7mWUrQjSMjurvXQSJGAcRwXacPjMUfE/vUx4EVDKJyXNca1KaxOuS36NpMH1mBIVlTbqYSsnUJa4lI2jii2duXv8mAgZ4632HH/p45N0A20oe/srHT67emL986FC93PDjkQUcHBwcNgGSCdV4zRNPRu6/MhBxJIqDg8NmRjyZc74mDhvGfYcfer16gX4oDg4ODi83ggj2S2JbKU868ZVDh/zWBDNnmcNy/ugMPpUgNhNLzmqLKqRsUSUQptlw9r5nWZYQJQFn/gnO2lOxYSpdCEWpWhpSNahhuqA0SKAPbULGuGEGn8wWyWWWRZjUQLZSCZOqJVSeQ3UIE1Pwvqhv4lC5pxYAACAASURBVJZjHSrNYDsMCqaqRYVjU0GZ2k9VhSkFRlnOW7aZfcBzX5pXDZVo6c9t0cHyNtvjWa4pGrtS4bJiOLlDJS6RT9swiaNCJsTYHtfhd/yrLGU2ne0QQ1u+Z1M+0TxW7gUNwz610r5u/uIXDEc7ivypO/Y3akvPRz5wcHBwuEpIJHPvzB549E9d/zu8FLwQP5RiUK5DVQkRKuexLCNg6sfgYD7yObERM1tRUqjVso/2tmkuy6QSlsB0oQSECR8SFTs8rGffGflaRXlNFe9L2QpLWagemJrW5qMjWLeUcrCEJAtz0kUk9mR7dd/25aQERu9/qLzDohKQ2X6WdzAlhttg2gwjjF8ZxOguInqXqhiWb7CMa2a23dYUTHX7+nUpC82EqeqRYzIO9ccUTGKvgcqGccCyPZrSlpDgxP66cEGrSUQ5w8SlszCXZcnQvr1cR39kmV3jus1USVH5xHIYSf1hCRDjl1kOw/QrAeOxeUyYpkOli5TUjY/r/VjPGJaYRQrT8PClr2cFNZpCtLGoZeIx//P33/2pDanjtjV5Ijh1izaVNYzbViGDz1D6CAaCTQy9DNUPIXAQmgitQ6NqGAnayBOTn0qXZdBo8kfh+2lDiYm6BGHAfZFtmkigFor4gISCvGS/JSwETDNkphG0wUJ8MCGIpSOyjwVLiZaNdJH2cZ84OGe5iMlTg/tSMhxf1VGqY0p7ImFSs6yDkCVInvDcYjx01XC8axZZJPulx0AM8DHC5jXSbSCmFM6jUEoR1aUWXxvZ2a51iBjVQVKZyBOSW3FuD8vIsbIRkiRMewxt4vdau3zTBkmTThROHf2eei3/J5EPHBwcHF4mxBM9f5A7+PiPuP52uJx4saay1iQcYC7wTRkaWn9Qxehj8Q2Zm9cDrTEM4splXaqysKD9MyRyN1RCAh8N+pXEkXzCNBYZ+HP/qvCtWIYPCCNdpWSjhlhgkhIDfSAJMIiWdJEplOr0kjxhWtB4NPKZJQ8km86h1GgPBvjVYHvT8HFh7O/ktB4M9/dHo59byC+1yTIPg372M2Nqr0VZSyk4bvR0oUcMCYPJi7o/xgMCgvtH/xD689A7JhF4foyMmMu16GvDp89ycLxJnpwHuTIAwkcIGtVR/iWkRBlR09fCm4XlNdyORGtzUpT71AgRKei7wJOG/UISpKengtf6uEpyEgkclpjRr2homPHJ7fOSBA3TfUzEjm2ZFsF5/92fekHP5zuCPBGcvOlW3+bPIGO7lOVzG7EhA8uyZRa6ZFGkyC1tvYF8J0wKBZYyJgwDXcK2f3xtimJWIDzYhIZl8M2fMulzU3+rDuLDRP7Y+shEDikMZNn3ITWDgRDi21SE0HSW+0RigCSIkBFxCwFgM/dNGuQWNkNfrk9ucPQ5IXFAwsfUd6EBPrZNkiBh+B77noScbf+4blmGhKRN4WO6JmxEmKmdfB06by3fMymDQuRl6DXOAQPRJaTf677wpOGqfeFokyhLjkRxcHB42RBP9DrSxOGKYyMkig8/DJqC0tj1hWC9WXLOkL8QxQrBQSq9NmiaydnweuA9MmaZcRflhuogLoQ8oTrC5nNCNca58/3BPhXxuR4s92LQWyxq0kj6oLhCM0697DQUAT0Z3c6FwEiW6pDBQd0vc3Mgo+C3wnhe8VYZQpu7EVvsIRaX+1oMVB+pLt33lbJZ1WMyhC2V6P2ht8dtkEzrDvY7AZKh3tCPg31ZrUi5AA+VgYFSpA30wGG0dQxKkEWY9IpZ6z6Lbw+NbentI3HT/SBoqBKqVHQf0W9FfGtIjNB3hCjCM0jOZ0Zs81jzmTub1euWcVAquX6EOEF/nVZbN1KiY0Kk5n47Y+Kp9szvU7e4eGMHB4cri8tFmggCqbznSBQHB4crDUeaOLyckEGMizd2cHC40vjAP/nLl/R8vqOUJ5344i23+qKcMKXmEDZfBFEgUHliSz4xzfwbJqxXkTFJTLAdln9UN3AM13xHLKUutnbytZSkUM3AdrIMw+T3sJFIW0L8XaiCsKUeEaZjyWPCch9TDC8VBSb1jupQ5xCybpa60AuGiTBVQ/vZTn6ctpQPmZRPbDEjgFfQkXIOW04zq6rHtLwtHYflNezHtfIoi+IoYdiGWj2P2h/wfOeiprhqhfKnxjr70blt6S5bWRJLuiRtp/XWgS+8uPKcFwpHojg4OFxuONLEYTPgVz77T9d+eU0xpib5/UZAD5Js1pzqIbPTLKehUoQKmIVFs++GCfQBqWIGn6qPQqE9Kz+EZBeqNNababfFsrIsieubmW2rXuhlsRteHCwXkbQahWcvpqjQk4blFrWa3l5/f3sZ9j3VOSzBkrhdtVqupPdLUEZ5VBpRzPQ0WVmJpgE1of5oQh3B0h+2ebch0lrKnVTH+eBjfZJ8dPq0LtXp6dXnFMuLsln9vsQSZ3p0e5qhyGh9PfBYVqqIMw7UG2NjZgUTQVVVNvCy4XGgj0tfznzcskG5Ds+j0Dag8mKJjuxXLquvAY4V6QfE8ihZZEMleSi3+rk7//qyPJ/vaPJEwHSe0ODVUB6hLIMwvmczlSTkeybTWmWJh203pP2PyTOlc9sm81V+r27Yj0vBVDYR8l6h+ajBp4Tv0TCWPjMkCaRrSuuUnnQiYehbmy8M25EUIsJSasX9tvnCyKDd5m+TsvSXHLeS4b3O99n+tf5iQ/E595vntrxke+gRYzOrlXOUx6lqiYS2OSebTt1OfxCB6VqzldDZTGxr6xCk7GcT0WUrbwv5u8S9xmufjKbnvBxYNZatLjhjWQcHhxeNeKr/XbkDjzoy1mFTYSPpPDb/hrUoUpR0kHCwle2YcJHRtDDhNEUf29bL98UjQnWYoQ4Hg0H6qpD4qFb1k46YeyoMoum3sowY4f3X6NKMFRAsElHM6GDi3DlNnozAm0RKVYpoewrRwTwOphIRkl98hOzCsaqCDJhFadNgUFLCR0mSCL29urxjBkalw4FnxuSkfq+nV28vl9VtJqEQD4izLEpSWC5DciFcZtImGliSw3IzPpJmc/pYSnlXmKTTpToD/ZrAYD+yZEbIqwSIpCz6hdHU9Ybu5+50m/CZhvfMnj3aW4fGtfv2RUuCGONdBsE00K/7lseVBJkJJDt7Mub+1+vV2yvDJ6jZ8Iq/8sZP9kS+8BKwo8p2bPi2YNDzjdsOnVqu+zdaFnNwcHAIoT8Ve/aGx0++4mr2ShAXuvo7vPDkaw3UlIODg4MZA4e+YqGVHRyuPu47/NCqCcPxE8dOKaXc87mDg8OG4Cn1zfvv/tQNV6K3nPLEgLNHJ946U25+zFZaYoozDiWSWEoobKoDARUMtjKaNfUGvh6K8jWoCxRUGDTpZGkDVSpcN7k9k8qGaoYE01WYWhSQp3FL8kvKEm8rq6AKot4w7ysVMKJUiVn6wqRm4DqoALKV0dgMb7WU0dwXIeXMOioNw1vt7+G1bDrKwUYXNhmfhoxVqWiJm88NOVa2czy0f2iUiVtmv/H4sf9NSiqbYspSYbW2rynL+cl95frkPGIb5GUu5b1576MnPxXZ2CbBwhcPLvrN6iVn6xwcHHYmYl680X/r/3GTZw5bDsdPHHuPUuojl6XdKLFYKuiZfZYmCGzlMMSFi4FKA88ioZIPQ5mN6iiN2bN7PtK2M1Bu7NurVQCLS7rN8shJxQdVF1RmsIFinrqCFB+WXjCyl0oXk1Ln/2fvTqAju8p70e9Tc5WkktRze+q2cYIdDG434JYb3LKIr19wSIAQbshdJJgbuOG+lQST9Esn4QbbJAxNRHCGlZdcyMUkZAViwpCwTMAkbbWxUBtot4dgeHhsG/fgVqtUGko1nreO6mztf9XZuyZVlWr4/9bSslx16gy7qqWqT99Q3oxTwmyFCy4oroec6lI8Z1WykUyqa8LGvDhKWU6NwewQzGDA0pkVGOcsm5LOz6vnEifUpCFbATMbFheL22Nz2U2b1GvkzBl1HvpsDHU8WcpTrtpoZGxKm0io/V0Erwckx3fja2QnjAPOwP7k5BpHPmd5jm163crmso5Rdz0SkCGDDZcRNj2WZVXBkFrvOEzswWPjazjp/nvFjBbwzoP7j9zlubWJGDyp4virrrWdfgamwIe81dQjAj+Y6QIKmhhKxf3pRirrAgAC+jCIsr4ha+dmGCVr6nGhAgPqNvwgqwvWCAiImEoe8Hi66Tb4Ix8DNPjatXDcse39kG2agGT6QF2NqQREPnF+Q2DAFEiRPzZMgSk8HAbWdMET0/Qi3UQlU0mKaSqVfM3gdZQEqTBAA+eE5TDytZEyrHe1gAgGKrGcqWSksDGa5F6HYbSzbrxyHp7TVzU4bnijOH1Rspk5puITkQgE438Tv+bb7+FKUC+o1lxWfuDEySgm2MNClo7gqFX8IJiBHgqhKvvG0gtdiY8o62ch+0Hgh+lzMLlmxw5v/w0BgRscX4y9PbB0BPtuyG2GoJ8JXhOeP5bObN3irgcEKk6dVuslx/SK1Q+9apv4cDEAc37WO5VGrE7QUUEZY9DBPSYeD3ueRKB8CB8nAzDbty9o78fgCa5/yQQZ19mzKjCFk2mwJGXJnU5kmpx0EsYWX1ISxCm+FrGEydRnZ2hQnb/sXyNgHXEfuvKpcqdOewM3KSjNwr42SPf6Q6ZSNnldpn8bdRo9uP+IfrGbjMGTGj1z3bXH5nPiWlE2mjZXpZ+CqdmkLuhiyjzRNavFIEPGcAwU1NyOmScrhg+Qul4bpY05hed+UR4wcO/QBYFE2Ydo/OcTdn9WYODH9AFZFwgyrREKY6BBt1/Dh2yrZB8QuFnbhz4zo9rrwdTPw3QeuucEgxamQJc8ZzzPkOHFg5kna4EEw2vAFIwpCQRpMphChteijinwhnTrZXr9pTX/ngW8foZCvicu//axlqT+tdP5B19mWC0i6mWbrv1P/Q93oh7QaEkPfkAuFLxTALARLX74C4ewkafax4qbmTA8jB+mg577y4+9fbu3hwqOow2WBDPgvQvsO+NmWGyFIE8OgjyBgC7/tzps0okZInJ/2G8mAM09se+IbrwyXh8GHErGQMO1LsGYZPmBOwv9Q7Iw3jYN2SYXXqCCTefOu88hfqaAMcLYfBSDI8FQ3r0mCFS8CP1rIHCjy4TANcRgB/akKWlW6z5vOJ64lgAgrqlssoyNjjHbB88T+4rIDKThYfX8mbJl8HiDbrYIZmjhH1PxWmbPq/PYvNmbwWRiOP+HD+4/ssfwkJZh2maNdn/7wX1yy+9x1DFRz7vme92VZVKN/ACVfOi6v85lE79eZXMi6mL+wOD3h/d+52V8DqnXyQ9Pk9MTu4UQT/MJJ+p5lx7cf2TDBiUw82Qdnrxu35HzmcIN5XvQ9d8QhnIKU6YB/qW+pKO05unCv7IXDGNcZVmLLmtB1PjXfMmUdYCP0/UHMSQ2VD2PWh6H5Pb4d4Sc4Ri6TBYcQ6wbJ1y+D11fDtO2Oe/dq+TzbTqeblth6HWC111SEqXJxtBlNZXTjUmudg7lxy75m45V8p9VOPUI/z4S0NyOGTIl/X5gW10mkgnevT3qu3f3A8duMmzac+YefHnOFjl/v1wvUa/bdO3jht+YRP1jcnrivlQqPC5W/3LuHXW8CjIbMjDRRo7FxfICzBTBv+Yj+Vd3nGSC2RG6PiHrgRkbKXc6D/ZrKZ3uk9F+L3tKvAB9VwaH1HphNgn2epFjl/NwfTjZZQtkccxC5kUto2V1MOvAdrOEMEvlaeiJssNQliPXA3uX6EqKHLmseg5l/xMcLTy6SWVm4FhjzCaJu+uI7zFLnh/o2RKD12jE/R57yGBmVAS2XYIRzosL6vzCkeJzsVZeVZZhklxQ57nWZwfoskoqkdk1Wxp8fmuxsDhw/I6bvvrKlh2gDgyeNMljr762kHUHhpd8CDW8jdF9WDZ9kNX1TcEP5KEaRvJKJR+sNedTfjuSpT8lTUbhewzslAZu3P1iE1xDTw3duZb0XcFeKnCBuB5yCUrLVPTnrAsY4Lnr+oSICs+bZFpD3Bb3oQsQ4fOnCyKIGgJF+NrJa14bOD4aA2sRw+1y+bH5L5ax6YJmwhBwMwWKsKQGX8+6kcOmAI1u1/j8+eD8bSHsPd990Juz20eSD13/mlzmxW/18xoQdatAaPN749c88Od8Aom8qvVGKYcfWiVd3wux+iFUfagfjBU/GPugFAQ/sGLpBY5SxZIG2aMCy32wfKiaxcWoZ1+ibNwxvgmWAQ/TMfD85ehdASOM8UM99u3AUp3ZWbVGcuztWWhmi+VAWOqxuKQ+4GOZiXx+TM8Jehb6ilzkHhsb4sogUPkxMEAmy4RwxHEUymxWYDw0BssuNvQVkbCnTiyGAZHidWOD3lquFRsEy3IkfNz8vHout0EfFl2/n4WSEiAVbAvWUf6F+xiqIQAjYXNc59/JHTd9VfMJaWOxbKdJrvqO+vD1nb0s6yHqdFd/90H+hdYVv+b+B2TccP74vnvz2fkbPRsRUcfwBwcfH9773Z/iM0JU2cH9R1Z/t01OTzjlPQ9V3JiINp5lv/r3D9z73U59Jph50kLPv3bfG0+lCl+WR9D9abskiwMzJfyVMyx0WSWibBoNZgzIUgcsc9BlXZTDDAQ5NSdYQ6YLZnroJv2YsjuQbiKRKVOihHszZh/oMjtM55w1ZDPkDLfrshwwKolZNukq2SbY2BfPwzTtSd6cM+zXVBIl94dlXqZMGDy2fC3qMn1EhdcfWnsNw/EszVqUH1vuz9SItmB4nMzWcrJwNoetN170rWP/4jkQaSW+t/fZQm7xEt19RNReli+6MPrqh+NcdqL1mZyeuFUI8QndTmSWRjCo/spumhaC5pPFv+xHwuov9WEYoWsa+boMpRdymokp8wQbcmKpUcTNGMDGsCsrKnMjAtkt2AxVNgY1ZTasjV8uGwcsyzMwawEzBpZgQosNb85kxgaWr5yCSUAWrBFO7NkCjUVlw1FTs1GcMoRjoOUY4VQqDFurbZNJdTtm1MhpOlj+haN+cToRrseye5z4kFrbpeUobKtKg/C6h+PF7bEkKgivgcWSch51/pg5c1pOzYHpTPh6wHHN2LC4Hlg2Jl8bOE7YNPIapxqVve7ed3D/kTsbOpk2Y/CkTZ597bUHTy/bf1J+NL/hQyhGF/ADtdzENNWklg/OuvuRbjKKgFKNLJwoHttveFxOE10wXXdQE3TBcw/DjpcMURcZBMkZ1sg0HUYep6TkCL4vGG5Hcn+mD/UYLdMsi7a8pfxxJWU7mm1xWlBpQAH2oVk6w+FK+6Zo1tbE9PoqP3dR9noxjXZeCxQZgic5w+toc8R3cNe3jn3ccwJUl8R3rzlbyC9t5aoRtY9lhdKj1z4W4ZITtcbk9MTtQojb5M7rGZ+KAYOs2ycD+1ech14dWJqBARYdY8kD9Gk5A0GQkDueVzftRZSV0chxyAI+7GJgAKfDRCM4BUZ9AB4ZLh7HdJ6GyShr5Tojwyp4gkEZWQ4kVsfpql4cGATZub0YEDgLJTc7tqsylJISJXhne+bMkGe/xl42JZN+ij9+0zgVCAJoBQgY+Pze1wwGoCx4d42TfrCMRgZ3jL16AI4wxsANBst0SgJr8FqU5WT4eCxjG4C+N6ZgoI4pqCKEuOPg/iO3ax7S0Rg82QDPvubaXzyftu8WZR/4TMEO3YhVU+AARfzej/imhrFhQ3aELsjh/dFQmS5wg0yNQ+VxTD1W8Mcjtu+Sx/OX9LVQjzRdn1xSDDKYlhk/tOvGSmMGBgYJlmGHuqampoyWoOGcdAGKauu9aq3nibopa9ivbn+m80SmnieaU9ZeRzl5rjhiG1/P+JxsCltv3fXAg1/w7ISaYv74qx7PZ5NXcDWJms/nH3hx5FUPbePSErVXpYwUHcxykL1OcHyvDDKIsp4UOFIYP+xjtst6YRAEG3meOaPOI+9mWFywQ314xw/F2PzW7/c2ysUP4efOqeu+CPp94DbycwQGBkxZPSuQIRLRBBIWFlUPj1hUZTDgh/MXIKtl29biGmDvkmFoEos9XXDtZOYIZgCZxkBjVkXOzRwZGNCP+sWsEQxoSdi/BgNXpgAZkkEhDKiYzqMZZONaPAY2xC0ZQd1FGSYm7HmyAZwPdbsgZuCMPq7lwyMR6TkBlWvYw6Rthvd+90p5rORDY3+Ty5z7H71/1USt4w9u+vfhvQ+y1xDRBnI/1K1+sGOPFKKmuebg/iMnemU5mXnSYf7z2muTizl7CM9K91d7DLZEYYOUIbNB9iYxZRSYsgR0/U1M032QrleILstDlGXI6DIJMDvH1CulJINCjhzGddOUHwnDGFvdenv+x7B2uuk3mJmBJSlpuAC5jS7Lw0PTC6XkeTCcJ5LnbCp7QTWdk8s0pjusyZwxZRRpnpJV8nmRjx8KWQs/NfMg6/87SPLE9bty6VMbNnufqJsEQjtf6zZrJqIONzk94aRnDFcb42oqUcDSGZxgoisdwb4kgYB6U4R/wccxtQOaXinYR8PnU+eB5ySvBa8DS0HOno3D7eoad7iZKqXHU/eXTGWpo7xDN/lFlGX42O4bW1xPU1aF7EMjVteruP1IXGWp2PAmGftvmM5DByf24Npqe+PghxFcF83tWPqUhdHJ27bqe5SkUur1gCOaJdPrUvc6aoL5g/uPjDRrZ52GwZMO5pT3nE7Zd+OHeflhN22qlQC6pp+msp16mIILBUNAZG28Mm4L35tGAFeDaVO2JjBT0j/EcGxdwEAXdCq/PryWAPYSKXiPYQpS6a5bV8rjOT9dsMkUMDH0WNE1Hq4lSKIbsY0wiFUwxHN0DX0DhtdUsKz/yY4oy3G6yfzxV38nl5l7Vb+vA5HDHxh6buRVD7EBM1GXm5yeuEUI8emSq5BvROsIFghD2QoGVLA3BvZhKelFYWj4qrat/QMynk8QmrZiWYsOBl1kU1dRVjIkzxkbsg4OqnPHniBJCFL5IfgjAxs4dGDLFnUM7ENz/rzaRyyW81wHNqvF8cPYt0aW65j6uJjIEp4w9BQxNZqtpkIJzBocmx0fqn5+Er7Wkm6wyXSMKt55cP+Ruypv0htYttPByst7nrxu3/GFbOGafl8X6h9DAeuHl337GHtrdKnhvd95NZ75+QevStsF+HMRUQ/zWf6CP7ztsvie+5/l80zUO9wPiWsfFCenJ+4TQozzKaY+MnVw/5Eb+vEJZ+ZJF/v+2LXJhYw9ZMpsQLpMAxPMpPBrtsFpLqZsBczo8GuC8Ti+18JUCfg246aQGJIcjOT566b8lNM1YsU1wuhiQJfxIUpTJWTaoikjB9dLV9rk02QZiQpjknVPp12S3aJ2koM77LL/ljOdc9UJOoZpQXnNOeEayk0Hgtb8lTMP9myqHylOiU8+ffapgp3VTXEn6krB8AXXx6/51rf47BH1r8npCad8dVfdC1BH9gqWshTcrI+SiTEG2Gg17+4DG9ueOweNZiGj4/QZ9dZMTrfBc5hfUPutJTOjHrrRzXiecpywKGvgqoPZH36fWi/MwKhWqmOCJV3yPLHRbKNMJTf1WE6pTKUgZL0ES8Zby2k72mlQzx7cf2S359Y+xOBJD/nRdfuenM8ULpNXpOsrgqNfjR/Oq3xYNt1fS8mJZJruU42uFElAoEUYgi2mII+prEUdQ32Pa2Tq+1Llss3BEXlww3maer3I8yvpHwIXYmEgDM45556ormypXLXnteSTr+H8kdyF87jhkO/pn5w5dplnI+o7xWDK6acKdp7BFOoKq5kloe3jDJYQUSWT0xNOs8yrdZssL6uSmliscklNPUzTXKr1xjA5e1YFT4bcCTSmcbrYjwQn08jeKrWUHJmCHLKXSwYm2+im8QjDJCNTIAIDHxnoMSJLqUw9a6o5A0EnH5RgxYdUwEcXrDGVWmHwC9elGa8d2SNmOL5a2sRgiQGDJz3smeuu/fMX0/ZvClNDUk3GhCj7cB7QfBjOaYIyoiyTABuHWmuP02drYL8SzGqRgYGSD/iG3h6hst4YlVTL/kAY5Mlq7i8/J3keuiCDqKFfDDa5xdi55mlYpevvgn1CsnAePs06G4M5GFTSXEpI0+dFGPqq4PltDvs+seuBY7/t2SGRxvz3XvnDXHb2J733ELWf3z88O/Lqh7dw6YloPSanJ24XQty2nn2YRiJLy/DhO2bocyKzNzDDxASzTFIrcjStCnyYRiMj2Vx16xZ909OzMM4ZG6PqAj4YgAmF9ZkUSPZCwawLU2PY2fOq78vmTd7Gr6aAFzaPNV1jrao1JhYV+rDI2zFQVNp7RhuYuePg/iO3ew5CHux50sN2f/vB39otxG/hFf5g7NozC1l7W7+vDbXeIEtwaJ2GX/m9l+Iekg+99rW5zOkp284xO4VayrIChUB4xy/H93zrn7jSRNRM7ofUtQ+qk9MTznul+0zZKUTNZFnilBDiFR+48WvnuLD1Y+YJicevvfbMYh4CKoaMFHkzZkEYEllKRhzLjQqQwpAxvOx05TUlvTMM/VZKMh7c/wbgHEyZILpsC9xvELM1NH1cRFmmjmRal2rTdpCpPAo/NVbrsYJjrNOaNQgZ1shUqhPSfGR1zn0gYC1c9SDHBlP7MaBC67UaKAlt++34NdN/xsUkok6gC6hgJsECZCaE3b4apjIaE1kaY5r8ohujjLJQkoPZDAizYpJuX5QYlAvhfjGbBj+e4vQbmSGCmS74JtiURaMby2zK3EAym2R0RE3pqdZXpQSk15dMVmpsok0jnIblew7uP5Jo1wF7HYMnpPXUdfvunssWfhFHgckmr7YhuGLooap6XBjKbPKww7ymXMQ04thElhLlsCGpIdhREsxwt8FfD7rrKNfoqGWkCxohU88Tea0FWENd+ZEoCxTJ86wWBCoX81tiOGT9/SUPHPtVz51EHWS15CfzIkt+qIQvuOnHo686cRFXhYi60YenbvqosMWhao1IGx1d26iVlfDaIyOR+oI4Q51xawAAIABJREFUUrVgDcLgSTisghlD2EOlzrHROrOzxYBHJKKOgb1isJ8MkoGZAPQ5qTbuGelGWNfgzw7uP3Lrui+aKmLwhOry9Gv23ZvI2DfKLBIGT3o3eLI57Ju6/NvH+nIMGfUmpyltIb/0jXzmHIMqPc4JkvgDQ6/hmGAi6geT0xN3CiHeKy+VwZOeDp4wSLKBGDyhpnn82mvPJnP2VlEeKHEjF7pRuaLsQzs+Tn6LP/swUS6sGTMsDAGWkvHDhnIf3f0YDMHmuNiUNqSZHYznqbnbcxwpawjsmEp4dOeGjXurXfdw0Hf6J2eO7fTskKjPzD903Yfz2YX32vn5GJ/77mD5BrL+0Ojk8DXf/oN+XwsiIp3J6QlnYooTWHmjWG2SqqbGWFbx3WAoVEcZCjBN9KlWDrMAY42HsBlqHcGOWgIttq3egctrrQU2x026021KmvLipAs45yxMCFprTGvY1iSTKZZChUK5rzh9cQ7uP3LCsCltEAZPqC2euu7av8zb4pblvFj9KVRtIo6AgIEpmFFtEg7GJnyGDAvMgJGRDVN/lKAhWKOD+8WsEFNmiox9BA0jkE3ThKplrAwGrUzMb/3lrgeO/Y7nTiKq2fzxfV/MZ869ybYzVf7VUTP5QzuOjLzyO6/johIRNd/k9MQtQohbZW8VDIik0yqbpJ6xxqagirQCARwUCdc+AjifV8ETvw/eXEOAQo7eFWr8bklfFey9koLMGbmtgCCNKUAjM1McwRCMIh5c8pxPmYedoNbB/Ufu8txDHY3BE+oYz77m2l/MFKzDC1n7MqeURzZrzRpG4SJdVgUyBR+Q3ARjJzFDRkeuSlaILoOm/HZT+ZBuWxyLVVj9ZWSJoYD1RMAnPrX7gWOHPQ8morZzslfs3NJ78rm5Ua5+Zf7A6JwvEPvn+DUz7664IRERbahb/+ktt1500fk9Qoh3CGhc6/fr3nE7zVnVGOHBwZTnfgye1BMwKdnHCuwjUn0fctxxPUGgeqnxyfaX5uZiR+/8r/98Z8sORhuGwRPqak9dd+1fZG3rDdmCfUE6b6/+JNX9KO/k4EnE78uGfOKFoGV/9bJvP/gbnhMjop6UfGj/ewuF7JtEIX11Ib8wUrCzXZnVEghsmhO+8MM+X/DLnFhDRNTfPvjN128RQrxeCPG6WGzlUiHEOC5IFwVPHnYnHq1+cWINiW4PnsyNj73WEmJE/v/I1MxXPRsRERERUVMtP/4Lb8D9xa78It+DERFRT+vo4Mnc+NhvW0L830KIl+DtKcgAiMKf8pcNTTwtYaWEJb7rF+JXRqZm2HmfiIiIqIKFE+Pv8gXjv+IPbz5g3qo6O7f0g3xm7lihkPlAfM/Rk1xzIiLqVh0VPEmMj33EGbOVt8VasZxfk8TcQPBEt68nhRA/zWAKERER9buFh2/43UBk529a/vBFrV6K/MrpLwxc9W9v9dxBRETUwTY8eOIGTH4Pb8Mz0sRO6ianluDIWOxrYQtxzmeJsa1Hjz3Z1IsjIiIi6lCLj7zuQ4HYJRs66jmfnj068LJ/HffcQURE1GE2LHiSGB+bE9CvBLU7eJIrbRD6tyNTM+/y7ISIiIioB6R+8NbHrcDAFZ12Jbnlkx8efMV/vN9zBxERUQdoa/AkMT62SwjxdLWYyAYHT+S3T45MzVzu2RkRERFRl0meOHBJcOCSRy0rEO/0M88tP/+ZwVd88xbPHURERBuobcGTxPhYoVIsJAPnEbLUZgsQ2RgKFG/Pw7YZOH3sf9KoReibMlgMpJwYmZq5Zt07JiIiImqzbgqalGMQhYiIOknLgyeVynNQBwdPVs/NL6z/Z/PRmUnPA4iIiIg6UKeW59Qru/j0u4f2TH2qu86aiIh6TcuCJ4nxsVuFEJ+Q/5+GOhkZn4jpRul0IDndxxLC3nH/MV9XnDQRERH1JWdyTnBg9+FeunbbziWjP/HZYc8dREREbdKS4ElifCwrhAjgbb0QPBEqu4VNZYmIiKjjpH709vluLNGpVXbpmUNDV9/3se44WyIi6iVNDZ6cvX7fS0I+6wnPHb0XPHHkRqZmgp6NiYiIiNps4eEb9gUHds/0w7rbuaUfRK+4+0rPHURERC3UtOBJYnzMqUX9tUxBvz/sTSJjJs3oUdJKKTfKgzGeUNk5j0zNdEcEiIiIiHrS4iM33hWIXfSOfnt2I5ffxfdgRETUNk0JnmBT2H4LnrjeNjI183nPrUREREQt1CtNYRuVWXxqV3zP0ZPdefZERNRN1t381B1BXHWaTo/73OyBsc/wlU9ERETtstrfpI8DJ47Q4GXPLjw8/ibPHURERE22rsyT09fvc/JMrEYzSDBLBTM6TGOL69kfZrqELO8xarHi7i9S++PYSJaIiIhabuWJW1ozLrFL5ZZPfnjwFf/x/n5fByIiap2GM0+cjBN7dXovgV9ze78QERERtQQDJ16B2CV/sPjI6z7kuYOIiKhJGgqeuKU6DJzoMYBCRERELeGU6nBl9ZwACkt4iIioVeou25kbH1t2er2K1ZHDxccG6iitMVnOq/PAEcYpOL+o5jimBrXVSnTy8L3fc2/Ztppmt+XwPP2rX9bbNx+d+QfPhkREREQNSP3wl5+z/OGLuHaVsYksERG1Ql2ZJ4nxsYdk4IQqywv7sxU3ICIiIqrR0mM338PASW2cJrLdcJ5ERNRdag6eJMbHfkkIscdzBxklxsf0aTFERERENVp8ZOKd/si213O9ase+MERE1Gw1l+3oAgGybCdVULcNmupa6mAqk5G3N+EQa+fuSMP5x+rYuWla0JJ7oj6fs8Aiv+P+YwHPg4mIiIhqwEBAY+zc0g+iV9x9ZTeeOxERdZ6aMk/cBrHUANsS/rMH9n2Ca0dERET1YuCkcVZg4IqFE+Pv6tbzJyKizlI1eJIYH7uPk3XWJy/Erd18/kRERNR+S4/9zN1c9vUJDl76yW4+fyIi6hxVy3Z05Tq1MpW1LLplLfWW+NRTtoPTdFLuA6MQKvJrJve0mD0yNdPQaGgiIiLqL8kTBy5h49PmsPPp56Mv/ceLe+FaiIho41T8MM9ynaayEuNjzEAhIiKiqhg4aR5nStHCiQO/0CvXQ0REG8MYPHE/6K+mZ9jwVQ8n20R+oYiv+FWvlYK9+lULP3w5GS7Ol5NtIr/qkbLtta91Yu8TIiIiqmjh4Rt+t9L9VL/g4GX/zGUjIqL1qBTC4Af9FnB7yBARERFpBQd2H9bdTuuz8PDE/8slJCKiRmmDJ4nxsU95bqRmGedKEhERkc7iIzfepbmZmiA4sOs9XEciImqUNniSs+1fw/+34KsZApa1+lWvAb+1+oWW8/bal6m8xmlcmykr98nb9tqXvL98G3lb1LLWvpohMT72BF+xREREVC4Qu+gdnhupaRicIiKiRnmCJ7MHxn6Hq9lyL+nx6yMiIqI6LT7yug9xzVqLwSkiImqUJ3hiC3uSq9l6LI0iIiIiFIhd8gdckNZbODH+rl6/RiIiar6S4Mnc+NhuWaKTLthrX9Ukc/baVy1kmU2zmcprdBN/MgX1hVOBsJxnrV4JNDp5CLnr+mueO4iIiKgvJU8cGOMz3x7BwUs/2Q/XSUREzVUSPCnY4gTXl4iIiKi9gtEL7+aSExERda6ysh17mM9V+5w9sO9sv1wrERERmVn+8EXGO6nplh67+R6uKhER1SMgt509sO8Gv2GaDJao6LaIB3S3moXdEpocTMWpZfpOyi31icLEnZi/sQk4PsPDcA1ysmQJtsWJPGHTTlymdYPl2up5EBEREfWVhYdv+N3gwG4+6W3kj2x7fd9cLBERNcVa5kleiK9xSYmIiIjaKxDZ+ZtcciIios6mynZsEeFz1X6J8bGH+u2aiYiISGHJzsZYfOSn/6Ifr5uIiBqzVrZTXrJTTzVMuoZSlrx23/ptTaINlujomM6zWlmO7jZhKEHSb+lZ6z2eDYiIiIiopQKxi39DCMGsHyIiqslq5sn58bH/w+UiIiIiaq/FR268i0tORETU+VaDJz4h3tZIUkeqYK9+OdkY8svEab4qv+rh9IiVX9XY8FWNk2Eiv1DOVl8Z2179qoWTbSK/dCqdW2J8bJfnRiIiIup5/uiON/NZJiIi6nyy50mUz9WG+kwfXzsREVHfsqxAnM/+xnEmHfXrtRMRUX18XK+OcHW/LwARERFRu/lDo/+Vi05ERLUI4DZYohIylJ/oylgWoaZm0FD/U6mkpxLD7rRMm664pTkROIcQfJ+Ha4ppDlhLQ1zdGiRy6raRgP5x8m7PLURERETUUr7g8Cu5wkREVAtfYnzsl7hSRERERO21cGL8XVxyIiKi7uCU7byNzxURERFRe1m+4Gu55ERERN3BKdsZlWdqKtVBuE3KLWcxlep0CkOlzRp/les2TdBBujWIQUeZHJQG1bI/IiIi6m2+4NBVfIqJiIi6g4/NSomIiIiIiIiIzDhth4iIiGgDsFkpERFR9wjgpBfdxJhKqlWf4BSbaqUxpok2y3BOhTrODdVSjqQ7Xt79bwgeXu06Vh/n7iJkqBdK4bq4/509MHbp5qMzT3s2JiIiIiIiIqINxcyTzvGWfl8AIiIiIiIiok7E4AkRERERERERUQWBdMFeKFhiyLyJmb4oRamlxEUKG0pcYlCig2VArYLHy7ilRKbymwycD5YGVasqimrWZWRqZtJzIxERERERERFtOGaeEBEREW0AO59+nutORETUHQKWT5wXhWLmyUCdjVgLnluar94mtjpyF/U+XLc9NpSN6TYgIiIiqoFdWDlj+cMXca2IiIg6n0/Y4gU+T0RERETtVcguPMYlJyIi6g4+nxBf4XNFRERE1F62nfs+l5yIiKg7+LYcPXY46rOE82W5TWBrLUaRj0NOWYv8cipc5FejnFId+VUPG76chzpfeFstnIa35U1vnVId+dUoXJeUba9+ERERUX+x7cLn+JQTERF1BzaM7QCWXXM8h4iIiHpEfM/Rk3wuN1YhO/+9fr5+IiKqHYMnHcAnxOP9vgZERERE7ca+M0REVKuAabtMQSVDhKA0RzdtJl3w3laLHJSrBKA8JgO3h6zGymNSmvNstNBmBa4v4qt9LzgpCMubcImizllZ4oOeBxMRERFRSxUKmQ9whYmIqBYy82SKq7VxRqZmPt+v105ERNTP8itnv8YXwMZh6RQREdVKBk/ewRUjIiIiaq9Cful/c8mJiIg6n2W7JTKJ8THbVJ6ShzKa8ukz5bCEJ1xHiUuz4TmvFIr/HTCUFDV6zliWo5sGhFOG8O6yxyVGpmZGPQ8mIiKivrDyxC1sHL8BnKyfgavuubnvLpyIiBqCDWP5i3tjvKcfL5qIiIhoI+VzC3/MJ4CIiGqFwZP/w1VrP/Y7ISIi6m+55ef+st/XYCPE99w/3X9XTUREjVor2xFu6U49+5HVJ5qKFY9qJS4opym5EasTa+TxKj++FktwPqZynno0WPpjj0zNcFw0ERFRn2PpTnvZuaUfRK+4+8p+umYiIlqf8g/u/MXdXr/cTxdLRERE1AmyK2feySeCiIjqUR48+e1qj13O22tfTsJGrUkbTraJ/Mo7WSueLRQLvvBxTsZJM7JOhJttIr+crBj51Sgn20R+1YolO0RERCRWS3dOfpgL0T7xPUdn+uVaiYioOUqCJyNTM3dyXdvmyT65TiIiIqpi8BX/8f7KW1Cz5FdOf4GLSURE9dL12+CH+jYYmZq5vOcvkoiIiGqWT88e5Wq13sBV//bWXr9GIiJqPk/wxPlQX6l8Jea31r50nIfKL5Qp2OorX/wykeU5tZTo4H4b5fepr0alCvbaVw1yfC0TERERGnjZv45zQVqrkJ3/Xi9fHxERtY42XOC3xILnRmqakamZIFeTiIiIyvHDfWvFrvzSq3r5+oiIqHW0wZOd9x+Le26kZmHWCREREWnxw33rMDBFRETrEajw2BNCiD1itRRHlaJUK6XBap4lKM2JwB0hz6MaF6pjug3Ca7IL6o6UpW6P1rFv3FbuQfdoZp0QERFRJU7vE39484EKm1ADGJgiIqL10GaeiOKH/Gs8N9J6neYKEhERUSXsfdJ8ueXnv9xr10RERO1lDJ643ue5hRo2MjWzk6tHRERE1WSXnjlUZROqw+ArvvlmrhcREa1HxeDJyNTMnU6wPu+kkLpfGdte+9JN1UEDfmvtS07YqTRlp1WW8/bq1yJ82W55jV02Qchyy22w5KbeiT7Zgr36hfK2eLtnQyIiIiKNoavv+5ht55Lee6hemcWnruOiERHRelUMngj26GiW1OajM//QG5dCRERE7RD9ic8Oc6HXx2kSG99zdKabr4GIiDpD1eCJwy8sZk2sw8jUTKxrT56IiIg2DMt31odNYomIqFks266tFGX2wL4zBSG2BWHazrJbghPz6+bKlMJqHbk5lsGYpuakYZuwYZt20l1HFbtHpmaerbwJERERkV7qB2993AoMXKG9k4wil9+18W8ciYioZ9SUeeLYfPTYdktN4aXa/C0DJ0RERLQe0SvuvpILWJ/s0tNsEEtERE1Vc+aJlBgfq/gAU6aILsskB8cOWK3744A8Nma34LExmwRPI6Q5J7x4771FqYIt/EKc3Hb/sV2eO4mIiIgasPLELRXfg1FRLnXq3sGXf/0mLgcRETVTzZkn0sjUjClmQC6fEGkGToiIiKiZMotP8b1FFXZu6QcMnBARUSvUHTxx7fbcQpK9/f5jEa4GERERNVN8z9GTDKCYOYETljgREVGr1F22Iz37mn0vHw5Yj3juqMGiWyczaOi4Wq30B8+4HU1kF3LqiEMB/fGca/IJYV/wrWONBqSIiIiIqkqeOHBJaPAy9lQDDJwQEVGrNfxBf9cDxx5lBoriFyLPwAkRERG1GjNQSjFwQkRE7dBw5gmq1kS2XA9mnqRGpmZinluJiIiIWqjfm8jmV85+beCqe2723EFERNRkTQmeiGIApVBhAE1VpoCJ6fZ66II1SzBiZ8AQxKnRl0emZjgOj4iIiDZEvwZQcssnPzz4iv94v+cOIiKiFmhamcnI1Iyzr9OeO3rb9QycEBER0UaKXH6XVcjOf6+fngSnbImBEyIiaqemZZ5IifGxXxJCfM5zRxWmDBPT7fVoQeaJ7QaLiIiIiDrCwonxdwUHL/1kLz8bdn5lIfrSz8U9dxAREbVY04MnUmJ8LCuECHjuqNMyBDlibpBjEW7DgEgKbo82WIoDuxCGXbBMh4iIiDpW6kdvn7esQM8FGLJLzxwauvq+j3nuICIiaoOWBU9EMYByqxDiE5476tBBwRNmmxAREVFX6KUsFDuffj760n+82HMHERFRG7U0eCIlxsceEkLs8dxRgw4Jnji9Tb7l2ZiIiIiogy09dvM9/si213frc5RZfPI18T33T3vuICIiarO2BE+kxPjYE0KIl8j/NwQqSuTg/LLut9E6e5/IEceh+numvG9kauZOz61EREREXWT58Td/1xccfmW3nHF28el3D+2Z+pTnDiIiog3S1uCJJDNROjh48raRqZnPe24lIiIi6mKdnIli27lkdunk/xXfc3TGcycREdEG25DgiTQ3PvbLBVv8g3MeHRA8OT0yNbPTcysRERFRj3F6ogQGLv54JzSWza+c/drAVffc7LmDiIiog2xo8AQlxsc+IoQ45JyT584GYNAlYBl3eVoIMTYyNfOs5x4iIiKiPrD4yOs+5I9e8BvtDKTk07NH89n5X4nvOXrScycREVEH6pjgSbnE+Nh9QogDjQZTDMGThBDir0emZn7f8wAiIiKiPpc8ceASny/0QX90x5ubGUwpZOe/l0+f/2v2MSEiom7VscETHXf08bgQYlQIcbWzSbpg++WmYZ+Vd799OF2wv2kJ8Y/b7j/2pGZXRERERFSjhRMHfl1Yvglna8sXfrnpUXYh/aiwC0dsIb7GrBIiIuolXRU8ISIiIiIiIiJqNx9XnIiIiIiIiIjIjMETIiIiIiIiIqIKGDwhIiIiIiIiIqqAwRMiIiIiIiIiogoYPCEiIiIiIiIiqoDBEyIiIiIiIiKiChg8ISIiIiIiIiKqgMETIiIiIiIiIqIKGDwhIiIiIiIiIqqAwRMiIiIiIiIiogoYPCEiIiIiIiIiqoDBEyIiIiIiIiKiChg8ISIiIiIiIiKqIGC+i4iI1iv5kWveLXzWzwoh3mjclW2r7y0L73lYCPFlIcR98UPH7/M8joiIiIiI2sKy8U07ERE1LHl4724hxO1CiHeIQkHtxlclyc8cPNGZd44RP3T8Ts19RERERETUAgyeEBGtQ/Lw3j1udsiumvaSzRf/G/R77lpVgJ/JPgikrGS9j/OvBmU+Ez90/BbPfoiIiIiIqGkYPCEiakDy8N4vVyzFMWl+8AS9M37o+F2efRIRERER0boweEJEVKPk4b0jQohnhBDDDa9Za4MnErNRiIiIiIiaiMETIqIqKgZNMnn1fQgCGzLY4YgEPQ9rKXlsy/pK/AOPvInPLxERERHR+nRt8CQxPnar58ai745MzXzLcysRUQOSh/c+U7GfSScHT9SxWc5DRE2TfOg1v6ndl+X/SnzP0ZOe24mIGjQ5PXFDvY88uP8IJxRSS3R08CQxPvYpIcRbhBAjnjvr96QtxF+NTs38abuvg4i6T/LwXmdqzm1VT7w7gifSaPzQ8YRneyKiMouP/PRf+ILx63zB4Vd67qxTfuXs1wq5pS8O7Zn6FNeZqP/cce/NP2/b1kuEEJcODi6/Qggx7izC+bmhtbUYiS+t/tfnL7R1fXI5/wNCiCknwzgQyP+IgReqpKOCJ4nxsS8JIZqSYp6Hy/LrJ3+mnL/GjkzNfN5zDxH1teThvfofjDn4hR4w9htprTycg7nnSSV/Fj903JS5R0R9ygmWBGIX/0Y7rr6Qnf9ePnP+j4eunvqy504i6jpudoj8Gm/F+S8sDqx9PzS45Lk/n1fvifzND8A4wRUnqHIfgyv9bcODJ7MHxv5FCPvn/JY+wtGoGoInKCeEeDsDKUT9LfnRa35BWOKfhTD80OiN4Mmq+KHjhoskon6x9NjP3O2P7PjFjbxcO59+Ppv68Vvje47OeO4koo4yOT3h/JHbaUj/xkxGZbaGQtmWn+YGB08q+YoQ4q6D+48wGNwHNiR4khgfe60Q4mjettfevG9w8AQ9OTI1c7nnViLqacmPXvOwsMQritdo+KHRQ8ET1zXxQ8dPeG4lop6VPHFgLDhwydctKxDvtGvMr5z+wsBV//ZWzx1E1HaT0xO3uxUBV+uOzeCJnnsezwkh/u7M2eFP/ulbvvisdkPqSm0NnsyOj/2OsMWkLpiRgvGcUZ9mAwPoNiAMgz9F2t13AAI0unNwZNz18AmR23L0WJsbFRDRRjCW6dTC3F9EL50r3hwOaO82kr1V8Gd2vfvQse3fif/eQ+wFRdTjFk6Mvys4eOknu+EqnbKe2JVfepXnDiJqickHXvdmIcStwrIP1Lr/lZXw2veRSNpzf7OtpOB40dqPN59UQZfhuDfosrQUXfseg0DBYM6zrclKOqTOLZwxbLVa+nMnM1S6W1uCJ06mSd4W98v/1wUuOi144ggVt0+MTM2MejYkop6wrsCJ6IHgiVjd39/HDz30q567iKjrdVPQpByDKEStMTk94fQ+czJLhoUNH4qs2t8SMXgC51Zb8MRzaul08GPvn/jGhz33UMdqefAkMT5WMOfA10eW4pgCH3glGQjGhDXBmHSV+zVOjEzNXOO9mYi6UfLwXmeK15z6ydHgjyn4WSLwZ0kGfumGmhDkyLrBk6ApTGwgS43yhpIjVfrzcPzQ8T36nRBRN0r96O3znVieU6/c8vOfGXzFN2/prrMm6hwfPfpf/kcgkPsDIcQu56QyWSi5Cbam5GYuMbj2/ejIouf+cul08ZzC4ernk4JAStQNpKysYAAD9oEBIU2gKJtT79GysC6xaMpzXCPYb74Af6yvr3zIKe+5/eD+I3d57qGO0bLgybkD+x4NWNZVnjvWYYODJ9L1I1Mz3/LcSkRdQwVO8CdH3wdPnG2/H3//iZd59kFEXWXpsZvv8Ue2vb7XnrXM4lO74nuOnvTcQUQlJqcndjslIrlc4I3y9kBAvS9h8KQjgydrnLXz+8T9Pl/+12+/6Z7HPRvQhmlJ8OTs9ftWdxqqLyhRVYcETxynR6ZmdnpuJaKuUFqqw+CJ2tY5hsUAClGXSp44cElo8LKebk6YXzn7tYGr7rnZcwdRn3Mn4dwps0scOQgMMHjSXcETyV075+f6reyXsvGaGjxJjI99Sgjxa547nBcjHCfY5Mk6UgqOEYVjrLgfbiI1BElq6aEijUzNcNQnUZfx9DippwdJvf1NdOQ+8PHNmOKTgZ9eoToDLF6fiR86zhR5oi6y+MhP/0UgdvFv9MtzFrn8Lr4Ho743OT3h/K7+dC3rkM1CkCCjvo8NrHi2FavBjGIwIgw9PEwTdpILqq+Izw1KDA4ue/bZLufnhtaOtGl0oa3HzuXUe7BAAN6bQYBlfiG2+l/swZJcUAGTaEQ9J7reK/m8/92Hrv/mpzx3UMs1LXiSGB9z/oVEPXe4ejF44nrbyNTM5z23ElHH8QROBIMnFbwzfug4626JukDqB2993AoMXNFvz1V26ek3D109xb/EUl+pJ2CCGDxpj3YET8qO8U72SWmfpgRPamkK28PBE8fUyNTMDZ5biahjJA/vPSGEuNpzPgyeVDIaP3Q8UeF+ItpgK0/c0vqxiR0st3zyw4Ov+I/383VIvWxyesJp6H7f6nScBjF40h4bEDxZ260Q4k0H9x+5z/MAapp1B0+c/iZBCEpgeCKVh2AGNCrJaI6JHxdwH35NoCUPj9fdb6IZQ1xRtU4IebwMS8xvnpoZ8WxERBsu+aE9/1MEfH/V0Hlk4Rcf9huRAY9Ggx3Nhj1N/FXOKQVBoGjlIFD80HHTj0Ai2mD9HjiR2AcxTTbtAAAgAElEQVSFetEd9968dWAgdbcQYhwDH2kYi2sKUMjxuxZ0hMQgCe5vGfqH6Eb5osXFWNVjp1KR1f9Go/qgzPnzagDYUFztI+j2ZMG+I8Em9GMp5NV7ogIEMEoCGxqzs+o8N29OejeogW2rY2ez6j0kBp6qkespYE3xNeDzqfd/EGh5WAhxw8H9R/gHsCar8g67MtkYllYjLcOzxdIlIuogyQ/v2SSE3VjghJyMHf7iJeowTmNYBk4UZ7KQU7rkuYOoC93+jZ/94Ae+/gY7X/CddQInfA6pAU6m9dzk9IQ9OT1xKxeweRoeAZEYH+Mv7XK2iDoBlM1TMzHPfUS0MWx7liu/LsPJw3vfFD90nH0FiDpAP0zUaYTT88UJoESvuPvK7jt76neT0xNO9rpTXryrYA/0+3JQc31icnriE+7Enj3MRlmfhsp2ZOBk0a1bGfDry3baYQlqZ/A8cnBdOfdb7HmCJTem0cfrkBphAIVowyUP73VG9r23aedRR7mLkRxtjGU29Y4f1sGf5c3uK1WwRfz3H2L5DlEHYMZJZSzhoW5Srfmrru+ISR7KU+oZkdvo4wowktfnUz+Wlpcjnm1jMX0JTzXY28OGT5mFvPp+yT0evg3avEnf5wR7ochzHhnWj1GWo5NFhfHJi4vF8qhB7Btj6X9EY8lTzl1z07GRob9JXeepwSazDaq7bIcZJzWJJsbHnuiC8yTqdc0LnPS55EeuOdnva0C00Rg4qc4p4Vl85EZ+KKCONjk9cZdTUlEpcELUQp92S3r4s7JOdQVPzly/r/ZwJL3kiev2TfX9KhBtkOQdL68ezqd6XJz8vZ96LVeMaGMwcFK7QOyidyw8PP6mbjlf6h+T0xPPuEGTd/Bppw7wDjeI8oxbOkZV1Fy2kxgfOyWE2OG5o0bpgjpOWDMyuNr9AqbfZGuYmqObyIOlOjZ0nw4Y9iHPyXQ+Ndo9MjXD2mSiNkoe3rtbCPF0yREzMOot1GC7J5y8I8tucF/1/KzAEiAcLWyalCPPH48RaLDcp5a1MEzv4fQdovZzenk4PT249PWJXH4Xf17Rhpucntjt9jMZllNwHAMDqbXvcXqKrkRnPqn6oFSbiCNgYk0GRhLj8Wohp83UMmkmBRN7otG0534sPUkuqPKVRscILy+p0qC8Xdz3QEzN7cAyohIwbUeWAeWgbMmG+0Mw6efMWRVXCAbVe0F5/lj6hNNxsjl1++hI5b/pYRkU7gPLcjZt8j4XpvKpBs27fVGeWe+OepXhXXqpxPjYresJnPQ5vviI2u9prnlrJA/vvaEXr4uoUy0+8roPMXDSGGbr0EZygiZulonznmSYTwZ1Aed1+rSbjbKbT5hXTZkns9jnRJPRUYtMDdkiEjZ7NWWF6OiyTQRkrKxA6km0hi6xy+72eArRxrJQciNTMw12lySiemizTtolB9kagQYnwecguwUzS2QmiCkzpRrI7qsrQ0bAY93HMfuEqH0YAFgfO7f0A07goXb66NEbbxRC3Ktr7tmoucSg9pGmbAaZuRCN6hu1YuNUzP44fz6+9n3BfduxZYs322EVZGnomqSeO6f2NTSksl6wqWm1jBWT02dUJoj8nLZ9mxoik8mqj13ZKtk3uBYD0Ni2luarMqMmgI12NWvRLAU3w8UHx8PXBr4ellMqyykWTXm2jcF6+/3w2TsA2clFEwf3H7mvZRfVZaq+C0+Mj7HPyfoFEuNjH+n2iyDqEsw6aTFmnxC1BwMn6+dk7bD/CbWD85f6jx690fk3ey8XnHrIETcTpe/f+zkMxe5FifGxT23A9OFe9XtCiN/v90UgaqXkh67e3HAfEKrHEf5uIGotZ2JMIHYRV7kJggOXfok/s6hV3PIG/uGGep0TRHEu8dJ+7olSsWxHjiWuVnJjKpdpNtkoNgjHWMRSHEhFx9KfdTZ8rVsyVzx2DD7DueVHLN8haqHkh/Y8L4R94doRTIEULGGRPx5WIE0xavhnmoEU3JBh3820nlKbWs99BdJSI4br1mDpDlFrMeukuQrZ+e/FrvzSq3rpmmhjudNJnsF+Jti8M5tVf6MuFIq/d7GMZnlZNQWNxfTlNY2S5RmhoHpvs7SkSmS2bZtf+95U9iGtrKhmtpGIama7uKgav4bh9qC37KMENkDF0hi5HqGQuu38eXVueM7ozJni8g/H1RriD09TOZB8rkxNVs/NqrKjkWHVpLdaOVZiXp3zyLBaT3w9BN3nBRvDlrw2NCU39cLSpeXlsOd88PUXCas18vn161HGeTJ2H9x/JOG5p8cZy3YS42PLnhtpvZzynV1cRaJWgcAJtVTy8F7WvxK1SOqHv/wc17a5fMHhVyZPHLikl66JNo4z2tWJO7ARLPUp53U/5/476CuVynainluoGZ5h6ihR8yU/tOd/clnbaryPrpWobZwP+KHBy1iv0wLBgUse5YddWo/J6Ym7hBDv4CISrdrlTpT6zMH9R27phyXRlu28cP2+QgA+4IfqSBdPFbCER92uK/dptnShuaU6cm+4p3omAWXgfMrW8H0jUzN3eh5ARA1LHt7r/WHWKbBkRv5gzMJtQSijqTZNx1TKgz/Lq/xsqkka0m7Dmjh78XivjP/eQ8c99xFRw1iu01qZxaeui+85OtPL10jNNzk94Xww/PTajm3D71mYtJLPq9/nBbv4fXpFlVIMDlYvx5CTYHAiDspiaUZKlddE3TIaLIExsW11nvNJVYqDJR461Sbl4PX7oTQmkRzQHkNOrsHJL5ZVfW6JLAOqZTqOjqmMKANTekIhfSnS0lIx18CCQqEAlEphiQ+WB505W5wWhBOC5mFdcFsfrEEsVnxeZRmOMEwQWo9MRq1HLa+fMu88uP/IXZ5be4jnXfqLB/a9RNjMjGixT/T01RFRv+jpX5BE7ZY8cWCMi95aocHLvt3L10fN5fQ1cf+y/mkuLVFVn3b+vdxx781be3WpPMGTXEH80LMVNV1ifOy1XFWi5kge3ssxlBvj5f140UStEhy45Otc3NZj7xOqxeT0xH1uXxMiqkO+4D9729ff8KNeXDNPLnbUb1UcIZGC1PCImxqOaSo48WYhj2nkxhKWVZij6r23aDkvp9jot6inVKfaBCE8jwrlNxWZtnUmBFlCHB3RBK+IqAGZ/EfXforgvzuctmMqd5Gw7AW3rVZGY9oH/lzRTeapZ78Izz0F6ZSmCUH1yFQp1UGGn5tE1DjLCsS5fK0XjF74gBDi4l6/TmrM5PSE8weZL1V8MHyuwckoWGIRiahSlvRysaQGS3VW0qrMJgxlIViqMjhQeQpPMKjeBwwHq5RYQKlRHqYC+f3qeLoyGtN0GSzVwfKhJbekBN8SyX2tHjsH73+gA9HZF4s//gJwPsGQOrZuElDJ5UH50alTI2vf79iu4l/zC6o0Ru4vEFDHq2XKjSylKu6jOIXHVF5kmmQ0NLjiOWd8DeBrB50+M+JeU31DbmRJEB4DS5Tw/HEq0OJicT2GhtQcmWBQX8KE4kOr13q5m7XVU6U8Je/eE+NjT3i2oJawzTEiIqqb/VKu2cZIHt57az9eN1GzLT/+5u9yUdvD8ofZkJe0JqcnElUDJ0RUj0+7QZSeUP6nz5fwpdA+p67fd7JfrpWIehaDJ0RN4IzS5Tq2z9JjP3N3v1wrVTc5PXGn+wGP05iIWsD59+X8O+v2tV2btuP24Ljfs0WZRSjFGTSUz+gsw+NMZTdStW0xdLVkOJ96Sm2ykFcWhFT0lLvvqOYcRA3TfWq55pGpGf0dRFST5OG9e0TBfmhtW82/xboVIP3S1+TqupybghrQlPK0Ek7PwVzaiKHcp1qZE4gfOl55AyKqaOHhG343OLD7cKVtqPkil9/Fn1197iNTN20qFMSsqDCtBctrIuHitBMsUwkG4PerVfkP7EtLkbXvB6AkJw3HwLKJwcFlz/1h9xwqefFcMQZkwfls2ZzUPmIFpuZEIrBv97EvnNq0dtMFO1QJTCaL02jU2q2sFPd3fk6VyEQi6v4hKF3SlYCcPaviVyMjqlwEj5GYV+UwmUzx/dS2rfOefVUiS1KwlCoJZT1RWIt8Xv2oKFmjKnByDT4XuutOpSLabbGsSpZpzc6qCs9QWO1raFCtVzVnX1TrjGtX8trWlILhFCUbSsFw3gyWr8nzX1xUk5wCwdyW/zXx9VnPzrsAfio40o0X0O0S42O7+n0NiNaJzWKJqKsFYhe9n88gUXs5fwWXgRMiap9CwX/uj/799fd245IHDN8b1ZNtgnSZF5jFgo1mcVvcJujejFkeUcMfhatlm9SSQSMzTkzbYr9EXQNavI4V+CsunlrIsmaEEDs9ByeiWt1Sf7ZJlRbVmHWBWSgBww+cerQ740QKwnFrWa9mZPAQUU3YKHZjLD128z0DV91zcz9eez9zxg/LKTqYbZKCDIxCQf2+HxjwNg7V/UW+nGzS6RiOL7n7UtkmL76orxDaClkAMoNkqyFrBGFT1q1bas/CiET1zUmlUFCfWXNuVmV/XLBTZaTIZqcX7NTvFzN55s+pH31bthSvsTSzQT3O1HxVOnV6FB6n3sNcsPP82veY3SEzTrABrA1v+ZaX1PHwOcHzWFosXsv27Qtrt5leG5htcs7NHBmOq0wRzGjBBq7ptDdDeDO8HvD8l5ZUw9uS161cD3j+YlF9Bg2ev1yvaFS9bvMF9ToLwbam5yeTKYYYBr1ZMTe6pXKjB/cfqa8D7gZafXUy+2FD7ejjaydqBv782mDJw3tv6OsFIFqHhYfHmT23QfyRba/vywvvY5PTE7dz/DBRR5lz/112BRna+3e+hoiIqEEMnhA1yB/a9L+4dkSt507SuY1LTdRxbnP/fXa81YaxifGxyt2NDHJuLlXA0qd319O0tZXkeWYhFcvUBFbHVLZjIq8brxkb22JFwFBgdZu/HZmaeZdhd0RUQfLw3uaMP0tBmmXUmyJZkxVIbY3UVAlZtALHNjVwrUceftit/cxq8s9gzKW1rKn4oeMMoBA1YOWJW3pmhGM3yi4+/e6hPVOf6vd16GWT0xM3lPd2lOUNupKccsvQ5DXmlt2UNFmtUvZSEygzyRfU99gstB6yVCIUUu9LsGEnlg/JhquirIzp7NmR1f9u26Y+0y6nVFkI8vvUcSz3T/PpFVWeMzS05HmMKCs52TRaLH3BcqZNm1T5h9+fX/v+HDRMTaeL17plsyqdwY+m8/PqurdqmsouQJPYkvOE5yQHpUSBgDoP2QAYm+NefJFqo/PjF1Sz3QsvUOVDkmxaK8qay2IJz8Kiev1td5+LDDR1nT2nymUGB/Fxav1jseLzim/ddKVPoqw5sTw2NvnNZNT9AWiWHDX8O8jni68vfP5Mis1q7Zt+f/zeju2H0uQxEtSg/8aFI6IuNsInj4i6kS8Y/xU+cb1rcnriBIdiEHUT6xsfmbrpsU49YQZPOoM+jEtE1B2u5vNEVL/kiQNjXLaN5Q9vPtDP19/LbvvGG2z+fiLqSi9zm8l2nEBifEybqohlJgOGUhVTuY5kKtVJa8pasDRmyHA8HdPMjDTUxgTc40QbHHIRquF08pAHpVsW0xoSUQuVlpZUPk64jjIbE1OpTk4zsQen+DSjVAf5NXFxLOWBn7ciVMMPRvlY3C+u54q+szwRVebzhd5TcQMiqtvk9ITThPlLQ4PmR8pyHSyVCIX0v8vCEe9UkkZLdXByCpbI4BQUWS7j2LnT29s2CyUbJZNdoMxk2Z2SEgqp0gycdrICJTVYIoJlOcPD3lKbYEAdDycSYWnMtm3F0phCXv++Cyfe+HzqumUJjK60RpSXHcXUOW+pMoloaEiVKOE+Eoni8bZvV49fghItPPslKNMaiKnn3u8vnv+mUc8kmVVYqpOYVy/IkeHi84JlVYNQGnMWSpe2b/O2AsEpN/G4ehyWY2Wz6v1d1H2OFxbU9ZlgKY5cZ3zNmUqwTORrPhYzlO3A67Z8UpEbQHnzwf1Hvux53AZxXvVv6ZSTISIiIuoXvuDQVXyyiZpncnriPidwwiUl6hlfcsvvOoKPteqdITE+dmu/rwEREVE/8QWHX8knfOMlTxy4pN/XoBe4f6Ue7/d1IOpBV3dKGU/ANEkGy0xqKeGpR1hTzoOlOlgC46+Sam+6F48hS3j8muPWwlR+lIJ1wek9ctpOUP+wEsvuPvyWeJsQ4k7PBkRUH1OpTgYm4YSgvEaW+Bn+ndcFR2nh9wFNGY1Pc5uoYeqPrgSoFlhyg5U6GUijNJXwyMeazq3ZZUdERG1kWT7nPdjHuObd6Y5v3nxFOJR9XIji73YsO6jGVKqDcOLNykqxfCMSaaxsR075EeVlOwBLdVJuuQhOMkng9JgtqsQlA2UasizEJJFQ02EKtvp+5w61P8vyTvoJBvVrm8mokhQ5nSgGJSQ40WYuoUpHLtipjicnu6TPq0k6mzapkhosO8IykuefL060uegi7zQbUfZcYTlMMFS8vkBAXadtq/dEOAlnOK6Oja8ZeezNm1UpC15rYl5dqyzxEavPj3dfZ8/qpwzpyn1yOXy/pn//iiVB4XCm5L+V4NvTaHTFs2Utk6ZwYo+csmOaapTOqPfk+LzGYsVyJCztcgMolx7cf+QZz0HbxFCgTxvgJVx0IiIiovayrMBPccm70+3f+Nn35Qu+Pw2HevHqiLrLyURE/CgRPPX4kj+YyovoSkEMZBfdIIilAlN2ISQGwv6FSwZ8uZcMidHLN+VELOgN1hk8PTk98b6D+49sSNIBgycdoiBEuCtOlIjIa8pzCxFRl2Dvme5029ff8KOCbV3e7+tAtBFmTocWp8+H/NmCvZqi4wuuhRV21nI6S+n80OPpvPj+nCXEydU9CCtXzMS5dDS0+NYr/YPRgKHJrBCfmJyeuOXg/iN7PPe0WGCwhjKcRkt1TCVB1VQr1clAWn7I8pbLiLJSG12ZUC3k6ZtOPVpSagS313G8mNrHkOdOIqqf6ecHlupk4Yex3B7/3eL9QUMpiw7uo56fO2lIg8VyGJxiI0tjTKU6WCa0DI8brPbnuDpKSLH0p9E1IiIiWqfJ6YnE0JAYrrYXnCoTDqvftcmFYknGcFyVD2SgZAB/g+MEkHy++HsQyybOzQ7Btup34+ZNC2vfy3IdLEOZT6oyhoHYCtyuynJWVornFIXrwFIdhGUaZ84UW1pu3+6d1CLKJrRgWYRcF7FaelF83zQ0qEozFhfV33rzME3nwgvVcVIp7/sOC6YJ7YRSHSyxGh1ZdPer3mtkc+q924tnVTnPBTDFZmTEW1pSgH3kCuq5ikXVc4llQFIopLIfolG1jxdfVM8xTueR140lTum0+t7vV+uFz89zz21e/e/FF8+u3YalOiXXUlDrLCcYnTunzgfLjuQUqSK15rryL3T69Oja/42Oqn8TsszHef3Opnzis/9fPpsLB+U/lMECvE+14T2iBd/LoIofplpafnjfiO8tc8V/P88LMfjxx4rbBCyR/Zkd+cLenUvhsmlVTh+UxMH9R9rav5WZJ0REtF73cQWJqFuxcW936ZTGkUT94HMnt/z48afmL3QvNegPt7fPXa5gB7/6gk989YUhYWVy+bf/hOW/YGgtaDPs/Dw4uP9IExoX1obBEyIiWi8GT4iIqKUmpyd2O/0OuMpErfXsXEB89om8iOzY7hznwk5Z7nzB9n/mh/bq5IPX7Awv/ZfLFlfTt9yA6jUH9x9p+UjjdQVPZJmMaRoNTpvBELF8HD4saEq11wgZtjWdRz2w/CblnmctJUd2yRW2LfhFRMV+G9VHE1YrMzFN4zFN76lmRd9FXzuZxm8oxdFtW8s560p18gX996E6fg0YpvHEDx1n8ISIiFpmcnriTUKIL+H+Uyk1yQSnlsjpHmJ10op+uogs18GSiBCU58ipOqvfp1UZjSxlsW1oDxD2lp6U0005wY8tWNaC5T7VmEp/tmxJeh65uKiuQ1eyIsrKT+Ta4Botp9T7ku3b1DGe/7Eq+5ClJbt2qfPB4/34hU1r318I5TfPPLPVPXdVNjJ7Xp1zNKKeH3zu5b5NU2AWEmpazQBMAMrni+9p8PWC05ASCfU9vhXMwlSj+WRxG3zOUvDaicXU844TkHLD3vdep06r6pOLL4JynlG1bzmRZ8cOfTkWKtjqvWV6OVhyzavnAKVNO3YUJzz9eCEiPvpo8fz9Eb8oLBfP34aScQvG8QTi6vnJJdXzVoAP1KHR4vrbebXOPthfdslbdlXcxn1+htVrPDenjjGT9A3MnBgRVw7aczduzTsvwIdu+8YbDt5x01c/7tlZExnesRMRdQ1+cCciIupRk9MTt5cHToioeRbSAfHH398iPv3cYNet6uOL1uifP+kTJ2b92Xzemvzw1E1/7dmoiQLY1BX64ggf/IXV9LfWapkeWYjS4SgZXQPXLIT0MIfDlGXSTKkCroE6ni7jBJvSQp8kgX+PzbnXEoBzN+WlLMH6t7XbDVGvyOX/QQT8t1W9Gl22CSoYSqgb/RlULWsEmZrAVlNP1ogpu4WIiKhDTU5PfFkI8UY8uwU3g2IIshlSKfykoX43mhpkStgstTSTRWUMRCJqHwG3AWgmq44xOKj/y3kmo94HnJstfii9YOfc2m1DQ0uex4jVLAdoVOo2Bt22Vd8k1od93OGcZBPR8+dVY9GtsI9zs6r5aiyqrjUG2StLy8X1wCaky9AM1udTWSqYKSHJpqir2/rVOkcggwSzWrDZrnThBWq9nnteZaxs26au5ZTb7DQKzWAx48gPDVWxkWy64HOvSWU2ZDLqvWI0pvYXi6nXADYtzWV97rmpa92yWWWYnD+v9h0Jq9eoXDvMBto0qs8GeuGUuu4Ldp5396ueP2xCjGu+davKWIm7r7UXIOtHNt390HcG0tlCKCxE8fj+kLo+2/1cjNkmOFC4sKheG4EBlanjh0++2QV3G3g7nUup5ycImSW+qPe9c/acug4LPqfn5tW/H184KKbOiuDUWSEOvSr/65PTE1cc3H/kBs/OmoDvpomoq8Xf//CP+AxuqIf7+NqJiKhFJqcnTpQHToioOR49HV25YyYmcnk73EtLevjRIfE3/zl8zQf+7eee8NzZBGwYS0RE63E7V4+IiJrJGUHqtCbhohI139+fzmVWMlakV5f2dEbE//TRXDyV+7mlP3nDvw54NlgHa+7AvrW8mjyUzvhrSFVPa9LcdSU5jey7VvXst95zWCvngcvEyzNdq65sB9fK9LiRqRn9HURUUfLwXk9ar0c657mp+A/VTcAzlbXkIEGxAN8HNGVAhn/bJc1j6ynnqfa4FNyvSXVsOk2D2vih44aLJqKq/8SfuMX7Roo2ROTyu/izrEPoAidY3oGlNuu1sKA+V5nKaHI59fs+EPCWlmBzWSzxQbrmpAhLhqJRbGpafG+SXFDlHfEhVd7h96v3JVi6JBvaYhnO81D2sn2HKvUIBtTv9pKyDrfECEuU8nksKYL+GNBAd9Om4joODKi1eOZZVU5y6e4XPdcvYJ1xjbGsBZvqYsPepaViKdEQlE/ha8QP5UA+aIh70i1xCYXU/djAtgD9GWbnVJkMfi6UDXQvvEDfwDUP+wiH1Xu2ZLK4dvPz6jnbskWV+9hQHIKlRLLpLJbtDA6q0hlUOu+g+D+2ryA+9lixlMuGz6YWvAf2RVRpVs4tucmvQMNj/Ey7Xf0zza+o15Ef3rNa7nvnTFKdZ2iT+ne3ckZfkhZx9433h0fhNQfHSJ9S5V0htwzIFyxe002bMonPvekrqqPxOhk+LRARdRVmPxAREXU5d+QoM06Imuzxc5G0DJz0k2+cD41sufNmfWOiBjB4QkRdL37oeMvnupPWV3Q3EhER1csNnBBRk33pqdjSV05ZPdXbpB7LmUI4/ic/Y0hBr09Jz5MUZKQPQEa6KY/RVH6i04xSHVlGgxNxcL/LMLkmBpNy5CSfoOEcTNN2gvJbeFjAsI8M5EbpJgThWtVSwkNEdcrknFzGQeN0nLChxVPWTdfUVOGsKpmE02C8WVdy04zHaSaCrcLyGvlzPWK4/lrk3DXC6T7ObZb13xvfKRERUVG1wEkSymsCbumLqVyhHlgiYzI7q/5av92d8vLCaTUjE6er4MQb/F6Wz8wn1XVEocQHzwPLb+bnixNMIlH1ex3LV5ILqoxhYUGVW4wMF9fmmWe2rt2GE2/8lipV+TGU6tjwWVA3bQcV8qp0BM8JJ8ysnc+I2kcmq97bZGByjSxBOnVKre2OHapkI5NR65nLqzdtsjwoEMQ1Usc2ld/suuScew5q3Z49uWXt+02bVHnU1i3qPLDEKhzJu+ej3h9GwqrEJQBvm2Zh8tHmTcUJMuGweg3kcmpjXE9ZqrPKLVfCCTtzCfUaWFxQrx05LeiTP8rm0lZ+9UnBaboir57s7LI6j1Cw7L2ec01b1LlnZqG8CEri80lV9haIb4bbi+vhh/fhBSiJx4/CoW3quZclQ34ok88mYMIOvCfF68ovFv8t5aDU3ikjsoXwD/35z9kLv/WvhjfPtWHmCRH1COsmPpPtFf+DE+c76XyIiKj7MOOEqDWcwEkqk+eAGDAwefO6ft4weEJEPSH+hw9/m89kO1n/1D/XSkRErcDACVFrMHBitp4ASsmCDppSwA0ybvlJqAmlJ6aSGxStcpyA4W5TuY5kytaXPZGjVR4vDKU6JizVIWqRgrhPRPw31LXzoOkngAaWw8g0QmxnbprYU01pS/QqGwMso8HpZ3i7TMvEyTz4MzZUw+9Vea1wjPj7T/ySZzsiIqIa1RM4wdIFLFOoh22r39Fpt1zENB0nC6UlgzDFRbjlFFthMsrKiir7wIk9OJlGGo6r+5eWVPkHnpss1Snur3h+IZjUgpNkIlD2gZNbFheL3++GyTanTquBI8spdQzThJkXzxVLXLBs54VTqsRncEgdOxBQJRJBd1oOPi4xr56zUFBdy8KCWoPNbplMIHEFsf8AACAASURBVKDOLQulOoWCer+WSavvbXf5z89hSZQ6RjartsWpTbL8Bicg7YQyoRfPqVKVwQH1GpATdgSUyfj9au2x5ObCC9XaxofUPuR6zM+r6980iuuFrw11zgvu8fIF9XrB50++hfzc2chiPhYZDLnDiiy3ZCZ3Xr1ugztUiQy+E8zNqdeof8A9Hkx/lLeJsik9+B4Y92G7752DI+r5wf2FNqt1zkFZjl9O1oG3rPayKokqQFmOjdOA3Pf1wbg6XiapSrCCg8W1HfnrX7AT7/li3R/Kvf+qiYi6VPy2Ryb43LVFsgPOgYiIutRtX38DM06IWsAJnMwWrMYijH1m6OM3191ElsETIuo1+oHx1Ey7uZpERNQIBk6IWoOBk/rYBdu/7c/ekKjnQQHTpBmTDGyvK9fJ29jJ2Xu/ialUp57JNLrzqeXcTI+rpVyHiDqO88F+rtaTspeKqYPWQJXJNsJU4lLLzwl8n6jZvqQtvK3ftNrPI8PPsbU0yijEyjM1BNqhE/paWVG2eFv8jkdrXl8iIiJpcnoiMeRm6Wcyxd+7oVC2+vpA6cLoSLH0QDe9xHHunJqosmWLSpRcXlblNWpaC5TARFTq/7lz6vPnzp3eX3lBKD05c0YdLwdlLyXlPhqhkCoXwf3lckOejbF8ZXZWndumUVXmsGO7utYXXhhe/e/Coipd2LlDXcdzz6tpKHNzqkxm61ZV1pF31+jJp7ev3YZVxhfsVOUiT8NUn0t3FafYvHhueO22+aQq9ZiFaTx+S73XGIgW1z+dhilFUC6ztKTOMxRWaydLupaX1PObhrIenDK0fbt6nTz3fLGMKRZVax+NqddANqP2cQ5KeEZhzeXrDsuSClCudX5OPW5oSJXl5HPe92w4cQnPH0u2NrkThfDfzOkzxfKbz5+1VpaCYtByX9NpKIEJuSUwFryPzSdUKYudVe8LfYNqnS33CfcNqjKi/Ly6Dium1jwEU3Hyy+paZJlPdlHdFtys1iufhGlO8ALLLxTPzx9S7899g+p1lHtRvd6DI2p/mfniddtReLHm1OvFN6SuxZfNiRUhhl/7d2+881u/+pVbRQ2YeUJEPSV+6HiC2Sct5Ld+qmevjYiIWsYJnDhtP7jCRM3lBE6S+UKEy9qYR+bt99b6wEAt2Sb1ZH9gRkeVv7WK+ZzaYhi6vWZt/fEW3aay2Ni2WiaM6dwWoUFtvY1yiaizxQ8dH0ke3mtOC4bZ9la4joaxOsvwF7MAxKNDuF/NzxjM7MDHVfk5VgKbwEZryJxZOzdDo1k8Nv5ctNzzC/rn44eOP+7ZHxERUQV/9O+v/4FtR4ZjMfXXZ11D1RKQbZLOqN9x4XAxOwCzTVIp9RdpbLCJBga8mSB4DiVNYocynm0dGXebOWhOakED14Afs9zV73nZoPbFF1WWykUXza59v7Kizj8WgywU9/zwmjDbJJ3WN6uV2Rb4OMwOuWCn+huTXE9RlkFxgduIFDNI4pA9gcfeuUNlAcwvFLuUyuamYrWBK2Q2QEPVKFxryl0jbHKLz8/ZF+HcdqpKixX3ud+5A26DJr6nzqrzxyyhkJvFMTqqsm2W4XUUDkOWLr498qvnVWZPYUNjzDYJBuE1AOck31b5fer+559XzXj90IB3IKves624WTl4Dl8450svCBGx/H6Rg4aq0QvV/uTWPvh0jtv64D2rBZ/DC27GRiCrMjdsaNRaWFRNgy14DxmI4rUWLxazV/BxBciGDgzH1r6X75NteJ+K/7KDsK2dUecnj+0LqtdOIK62zZ1TPzds+Dww8PGb7aXfuUf/wwNU+alFRNS1jvKpay4nKNVL10NERK33R//++i/Ytngpl5qouf73U6PziYIIc1mb4yf+6uer/oGQwRMi6knxQ8fH+cw21Vd66FqIiKgNJqcnbrVt8RauNVFzOYGT8wWLZXBN9EIqd0W1vQWqldasbmTVXiZTy/4kLNXJQYpQEI4H1TUi6qaRY+NX3TnUotFSnTx8b8N5BOpoLlvPGhHROmRyvyps8XfFf6QQK8Z/hAFNDBkaS4lAlbIe3FeoyrYIj2sqndHBbesp1THChlpYSgTXspQV8Q8++ibTHoiIiMpNTk/sEUJ8wnOHq1qj2Ll5VRozOJD23I8CUOawdasqScESik2jC57HYdPZbfC42Vl17DA0rJxPFtP/t29TJSILC2pbLJPxQWmF371982ZVWoOWU1h+oxp55nLF38WqwW3puiUXVHNPAecxOFhcr0RCX86UzqjjLS6qbbCp7tDgsnt96v7EvCq9uBBKf0IhLHEpvq8YHVXXMTqsrvvUaZXEGo2o5/XM2WJJTSyqbsPyqKEhdfuz0PB20G00K8uMxGrZi3ofd8nFqjxqAdYrFCxugyUw8jaxWqKkzv+pZ7atfW8X1DqOjBSv60dPqqa6m+C6z8+q4+1yG+kKaCqbXlGxj82b1esTS5QKcLyFZHH9/2k+dj7h821yKmIy0HAVG8JmoWFswG3aKnzqvWdoGF47AKpyhM8tgUnPQfPZuHpcPg3/hv3q34ldwJu977Ox8Wsho/aB5y/cl6IPS4Y8e3Jvx4awweI+0udVKVVwCMqB4Bg++L4wV9x+9C9+Pj33m/9izObxXg0RUY+I/+Ejf++8L+DzuU5+8bKuPn8iImqryekJ5xPyQ1x1oub64lw2fT7n28RlbY2cLUI3ffbnP2jaOYMnRNTT4h94xDvzj+rxlfhtj36fK0ZERHXwzvclonVxAifJvG3MiqDm+PZ58YemHVlzB/ZpM2CwjAZLZ6pN26lFyt1h1FA6k4QpPPGAdxtT6VDOUEaTcm+P1lFasx5yOhGuFa6h4bLFyNSM4R4iWo/k4b17xHJW/QUsVke5C6QLiiCUsqTdFNVwwPOQVaZpOjorkO4aMexPwrKdNDyuWgnPPKQ8D9fwe9ftfh7/w0f4c4moRVaeuEX7HozaL3L5XfxZ1yST0xM1va7lRJRIRD/ZxmR5qVi6ENNMz6lkaUmVGwwMpCpsWTp5Bye3ZLPF9wFDMHVmbk6VBESj6veynIziWFos7gMnyZw6Nbr2/c6dKtZ0blZNhAmHiu9BgkFV2oBlJjjxxgfTfRLJqHu/OodL4dhoLqFKREZHVLLuD5/Ysfrfl15+eu22DEw9wvKhk89tWft+aKj4vKyk1LYDg+o5Pj+r1gsn2mQy3tLn+P/P3pvAyXGV596nuqv3dXaNpJFkyRs2xguXkBAuoABOgIBxAiSBSzCXey9ZSODykTiBYGOCIQbdQBa+m5B8MUm+JAQCdmx/EAIXcAKKCUTYYAO2tVrSjGbr6X3vru/XXVX9Pj1VpZmWR9Isz5+fmVItp845tZ9+n/dJyTHGz7gFkFXZ7j3hsNQHHYvQCacF8ie/3+zbkydFAtQEdx/sLzwHMOlCw3LCweODjj21KpwDIM3au3uu+zebA1nZsDgWIfY+DhwK1GtNo1tIG7550R0HXWUMlNRYUux2RY5DYFT2bYDjDcq2feGAtR2UhRKZhMi4miDtacO7s896B0YnnWZJ6qEnpYwWSJB0y53HgO/p+rz0kR7xeJc1bKcp6ReU9eCJZEt8zDpbfWAtviap/c033njvf1le/Apv9IQQsvFJ3nroYeVTf8NDORgcOCGEEDIIBw7uz7LDCFlbOgMnlUY7yG69cHwvb7zBbWccPCGEbAmSt3+vM3p8lEd7tWhjG6OehBBC1gMHDu6/txPbyINByNrBgZOLx0v/+pV3Lt+5Z3w4yl5clDNdbPmMl+ONl6uMl1zHxk2qg3jtD4Lk+/btJtcpgY4mtkJ9BsVN2uS1C8brEnLhSN7xvX35u27IDvRy53I9d7HlOl7yHC+pjr0+LkepTl+ac5cysD6DuO3EBnLmuTn53kcWHHMJIYQQFw4c3H+LUuom5xJvbLmO7Sijuq45El7v5ZTjJtcpFkUSEI+L28kZdHaJokuNKVVJJtxzyleqIgmo18ChJGTWL5cXCdD4eE65kYCMa4mE89vX75evAGzr6IhTvoHSkji4zjTq8v4QBAmMLddB6UkmI3IgzQcSn6y0JQPuNjHr+MzOyitTHOQ3eNzCIenbouXOkx6S47S4IMenDa4/6JIUsJxubGmU6rrjiKQjnRZJRwDOk927nK8r8wtS5yPHxAln95SsW7WOcQAcdhrQpiqcAyjNGhuT4zM3Zx63XbtEslIBiQ9KkYbScl6eOm0ezyocv3JZpm1Xpk8cDpdrqhH1WbJxWw6jR0Gy4pfz0w9OOM0FOR/8MbMf9SE5vhrIwA1wnanPSfu0YtWxPw2kOohX2a1y3VFP1W45tu+uAlL4tiW1Meqyrgbf9P6o9HMT5Eg9CRLIjzScRkcfkBfZsp3QkMjY/r1Yf7dS6j1YR5c3c0II2bwkbz2U5uE9K29O3nro3rOtQAghhNhYzjp3s0MIWTs6Ayf5poqyS9cXHDwhhGw5krce8ggn2fL8QfLWQ5/c6p1ACCFkIOisQ8gawoGT9cPeP7/5YayMXoOwGje5ydmoWZFWQY8hmJVK85L1eGG76eguMpxuPTzmu3GuUp0KyH285Ectq57+VdSHX3CEXBw6Ayj5u25YWTnn97jB2eB9swzZyNHRpwrz3dx0MAu4m1RHgcuO130aM6GjnMcOd2x4yIuEN3PghBBCyCAMmiC2BW4mtmsMSnUMQ5ajVMeNdkuD7WQa3WNQYoEuNbiOG31ynoRzhRNPibtMKCTfuOgchO434ZA5H+UkIXCHQVcWBW2x5UNTU4uOOqiurEWkEsGg7Ds0YZady8vyUlneDXToi+2TcggXM9Iv42Nm/+u6yD+OH5d0aOGwzC9C2faxqEKb0GUIz4HFRenccNg8D+og29m5PdObRklNIiFlTFuuRfh2FI5I3yYTIh/K5aQ/ylada7C/YED6xZbkdPCDvOjIsfHe9PCQKcXBcxGdgLaNy3mUSIi0Z2TY7Nu5eTkfxsdM+ddd34zUK5qvd1L5QyJPCaTNOrfKIt3yh6Xv0Y0GpTPtirm+PwjyqRa8F4LTbXBc5F2uwDtrIwdSqhE5dxp5kSgFLAegvu9+TY6fUQbJDdTJdvJp5bAskSWhC48eAamUJeFpl+S4hybF2arPWQje8Q2rv6qLct8JxMIq01TXYje4vkETQshWwIpAcRcrby04cEIIIWQgmCCWkLWlM3BSrrecCXLIReVnPvXqq+z96xhtUoSoirhHVAWSWCGx60qUBtyfHXFSh5G0OgxjraYMG9h1XzJXTF/jdBtfXYLX1UScEELWB50cKPkPXPsDFfBf6VohSCalAnBXqFkj1xjREfd43sGvAqpk/hrSNwKP4XtekSXWfKMoI/Qa7s8reWzQqrN7tEmHS5K3HjrumEsIIYR4cODg/usGTRCrukGUEHliWT2Uy5KAEqNQgsG2cqPRMCMaAgH5BTkQkEiDRBwiMTV52mZz8sv4ULro2Hc06kxEu5xTp4a7c9ySlKplESkjw/KL+dKS+Yv5Doik8EHC2FpInuFzC/LLv51QdW5e6j46gslJJbqjWpNpu32RiEQoRCPy/oBvIdMzkgoOk6faSWezOYlWwAgS5MnD23r/unTfXPfvsePSF+EwRMAU3ROqLllJeNttOUfCIalPPi9JSzESpN0234+2T8pvYbmcRChUK9IviaT0R7Vm9vnUTlGd5SFBbR36ExPbYsLbkFW/U9OS0HcoJdEYuZzUuQZtjcfMepRK0hcfOhKpVxvmwIkPEpxiZEktYx5XjCrxByHqpybnvi8ubfGnzGOIURyaH95pDQPmS/83lsxzLTAK4VdQN4w2aUEUip6ACBErEWsLIqQN2J+hST/7MBmtFYWij60QCdMJhinIvv1Wu30QxdJYlAggPyS/bUGi2V6fwru+Xc9DhdDfKqWuU4w8IYQQpZK/88gzOtEXW60rOpE3HDghhBByDnyHnUbI2nBvtt4bOCHrj6VmvSfd4eAJIYSYAwkd2crQFumLB5k0lxBCyLlw4OD+1QRiE0JWQWfgpNBqc+Bkg6AtveC553wDtGU+KJd5OglozwUv+U0Tw4Gsv4E1kNNguZi4tgXzB5HtYHmj//JNfswQsg7I33XD15RSL+zWBGQyrrKcJibcAolP2ENGs5bA/aNPXoQe9pZMSMV69bkheesh/mJIyDqgevgWfoSuE8KXfpLvYKvAynOyolwHJTLpVNF1vv0IsyUmTwdMNNuGxzImiXXDlnyobr5298uxCYlKbVnRAkhr0umSY7lallw1EDTnY2LRsTFp95kzUh7KQmx5ELajVkPZi7xroGynXjPrPDIsdfP5pW5LS3IcQpD4NZ2U9W3JU6kkEgyUw5QqUg98HRm32lWBJLKYJBb3Fw7JtN13uG4TpqsVKa/R8MF2Zt80mjIvHhOJSCgk0ydOy29ko2lTwoKJbTEJLkqKhoakX4JB6cdjT5lyHd0nx2fvJXO9aUzY24Dykpa058C39Gat0bR0aC6GAstkO3ZHt2pSTwNO+PA2kWDZkhsso1EUaZoPUuzqYyLLaWTkvAxYch+U6rRRIpMSSZcBYwAanhCWDKhdkH1rMZHOoLzGCDiTZrRKkBwXtkMwUa7PSrCrJ0GCNS3SLJQgafC+3Jg1ZV9w+anguKR0SlX3ve3YW37344w8IYSQZSRvPfSiTi4Qx4KNzb9YMh0OnBBCCBmYc81zQghx8uF/98nACVn3ZCtP/pqibIcQQtzp5ALpSlt86hOuK2wkdG08eeuhF/JQE0IIeRpw8J2QNaAzcNKsc+BkI9GsF67oVPdpHTRbrlO/wFIdxEuqg5KaujW/z93CUZKTgqUJCsEQU9BDkrOSVKcCdYvAuvoK2xFCLi7JOx59q1Lqrfm7bujkRHmTozLoYoPT6CPfgLuPLZ+BkEsV8rgVr7RODWVCLsuV2p98//e+5phLCCGEDMCBg/uzg6wfBCccBGUhhsvbOP4QH9ClDJTOLC6aYfcTE1IlTZPQ/7k5kWYkEhLyH4+L00i5YspPohGRICALiyKjGR0RSUCxaG6HTjkz4FazfbvIAyYnsX7923coFEVW0ID2JRMib6hWTZlCCxxoKiBfmRiXfdTqUmdbWlKpybqJuPRnC+RKKF2anZMyJiZMGUMuL/WMx0XKHI6IHMaWCXXbWAhay2V/vqb019iouOKcOSN9V62aEhA8Zii5icflGJ+ZE+nFyIhZXhlkROWynEfDw3L8RlIi+xi3+u4YyKt0cBvKFWTdyhmRb6BEbPs2c98zs1KfzJJMN0FKZLsW3buUb7YDuu4L6ApFZW14b0THGx/IeRpF83w1QCauR6TdNZCv+PvK8DvK0uCbvQVSHB9KZ2zJTR6kOmmR6iiQ3GiNs0vX+5x0gFZNyvDhOIK1bx9+K6M8vs/1B6Q4VhlNkC2h/Ka+JLIkDcq2XXg0eN+uT4M7VtiSAzlaQAghxEHy1kO3KKVu8RxEWV/QfpgQQsiacODg/s7zL8XeJOTp0Rk4KTXaul+n+GOjwsETQggZABhEuVkp9bl11HcPWrlaCCGEkLXkbvYmIU8Pe+CE3bixeVpuOytRATlPZAU5Twlsc8KwLspybPmNl3RmvVA3nF2Ks7ykTekHH3JfQAhZ1+TvuuEdSqmPqpyE2qoUhCfmajDfPVP4OXJCKfXq5K2HHuYZQsjGg2476we67bhz17++uKNL6Go52iBXQEmN7fjiA8cRHdxhUJ6D8ho30J0kBRKfQkHm+3xm6D7KJyIRef622hLOb8DusM75olkeOqAkQC6DkhrU/Y+NieTEBmUaNXBu0QOy80jYlJ+gBGZiHCUWsq4t7zDrbM7vkxyVpIxIVGQ0J06M9KbjlvQFJUdIsSj76Nt3VmRFwaDZX9WqSDDqDekvlFjtnlqQepwc7f4dSkudNU06Efs8lRI5SDRq9v+pU8O9eTt3imzi8NHx3nQ4CI49ljwI23rixGhvOpmS44r7th2QymWRvRRhOhaWvkUHoFRayrPlOvGIrFsBN6TxsUL3718+pVeytVavc31W5EkzL32kJ+WYtKsiV/KBBEbzmdvVYTskDE4yTXSpsSQnKC9vgvsNOvbocTkH/JaExfD4dr0QoPxGH5L7AErbGyA7st10mll3iWC7Iv2CDkGBRMRRlh4FV6BwUE2En/dGjn4RQsjTJHnroY8ppTr/qdxt1/y81mrfrpS68jz16x3JWw+9zzGXEEIIWUMOHNz/PqV8SfYpIedOZ+Ak3zQi7MKNj6Fa2zl4Qggha0jq/d/7lFLqU1hi/rZrXqeU8VOqrX5UKfWMVeyt89NWJ5qkk+z1k8xfQggh5CJwOzudkHOHAyebi1rzqevP6+DJSlIdJOZfed2V5DqDuOmUQSYUgX2vRVCSaz1dZhFCtgbJ93/v00qpT/NwE0II2QjY7joavF2j7KVcFumILbfwQvMQp9XruvVXZA7xmITMF0BakkhACL4l10EJELrxFEFyg840O7ZnHPOD4K6ioxQJ3GNs15kOS9m4VQd5sS+AK0sApDo+aLjPqqvX/lBmgp8RsbgpMWiBnMnvk3IPHxEpSywmcoS8JQ+qlKX96H7TJ9WZj/emJ7eJ9OWpU6ZrEbr/7BgTN6FjT0mdfZD/dHTEdDNpt6QhoaC0e35R2lKuyrEPBsz5tbp8nmYy4CAEfRcD1x/7WD32wx1Sz0k5Zj7or6WSHKt61twO+zsNMqIJkGidOi0OTvMLUv+RtLl+BeRaqaQ57xNPlFtGKNgbOGlXQAbU+0aWnTezIOEBRxsDHW38Zp0DMTnHUXJTA4lLaJs4GbWL5rnRBilPYESOe2Oh0Jv2ReScaZfNOmtROU5GWdqB8wdBA7kMSoLaFZArWfXol+rIcgO+5QMgV7LRExFYF67LlPRtbUbOZ9vtKLxDZGP1EyJH6zgSlVLhCab6JYQQQgghhHQ5cHD/O+iuQ8i50xk4addgRI9sCprN4pX6IEldnw412I8d6FGHJE7RVUSerMQgJQwSpUIIIYQQQshWoNn0f9Rupq63XFvsFm2ymJFff0eG5Zdsr9ATOyEpRkHgdAKSpFYqEjEQiVjRGJDEM4+JZlPF3nQ6BYlKG/KL+uQ28xfnbE5+fV9YkCgHrEezJd/ABSuiY9s2iUoYHpK2noBojFZL9tdqa1bd5ZfzUkl+Gd+9W37hxn4MWpEsoZD82p+DhLLYs2WMspk0I0jabfnKOT0jkQiX7j3Tm67XJGoilwtDGc7kuMefGutNjwxJlMOJp+TXevt4Y6RIAxLNBuCcSkFUS8ZqV8AvyzOQwHZ4SM6HdEqm7UiVOESjnJqWtjbgPJnanu1N20mNQyE5JgsL0veZrJwbwaCcD/WG9HowZJ7DAUhg+yc/bDWbhtJVUFeqKnXyBUHwoZv9gRERSCMvETD+iER3aEGrH8GJxA9RKn6ICkHs7fS4XEdtSBireYwBtKz66xBh4hVt0h8hc/b4DIw2wSgUO0EtlucWeWNWTvocaeatdrXkPPKH5Now8H4DCWFVwDnWpQ/LOdButVQ86K+evWWEEEIIIYSQLcGBg/uZY4uQc+RPfthqVBst5hTdpFSMQJuDJ4QQQgghhGxxDhzcf10nCGKr9wMh54I1cBJg521e/Fp0ST+fUh0Eg5JCVmYe3Rkdc8HwSlCLwYl29YqQkCbusZ0blAYRQgghhJANwnfUWaQ6hYJIYzCBq02fVMeDKiQIDYdNSQBKZLyo1eWb1JbtzMxIEs+dOxd70yjFQblIIiYyhVLZXCcNEp+SLpIVlHLoUL9duxYc+1hclOkoyHLicUnOqQdMiUGpJPvwQT9XqyIfsJO9dutvSYZGh6W/fVAfDSRRSdjfSSvB6eWXzsi6kMbmzKz0XTgk8odcXuoxOmoez9lZ2U73uyd+HRuR+i1ZUps2yGWWylLuVVdM96afPLKtN71jmympeQqSsyai0iZs6+GjY475LYgJGBuV41qrYgJakbjYiWTHx+S8DcPxw3UR7K9mw9zn//5Btd2uNgKdf2mQkBQTtGoxqUfLTnwKH4shSIxah0sJE8K2cqZcqd2AaxQS0YbGRHrWzIm0SbMy+uJ2PpDI6Ak551qQuNZWB6HEB+uD8hxfXMoYhDbKclA6Y31/ayB3MurS9xrUXzWlDN2eH4KkuiBnMmog94H92acXJq1tQt+qZkspfzvDyBNCCCGEEEK2MAcO7v8kjz8hg/Mnj9da7WqD39RbgJA/naEmixBCCCGEkK3Nm7Z6B5D1i99vHPb5jG44iU9TB2PRxiRU1mg2fc9ptU0P63rDv+NCNaQzcNKst9bA9oRsBHRf/PCqBk8weA+H1QY5UVaSB61GGoPruK1bgeURmN+0Yo7azs27BKFu9ZbTFahvHwO4E519qbU/r0oRQgghhBBynjlwcH92NXtwk+p0Mcw33ga40pRBphEDZx5bqqPAbSYWE2cRL+p1KXtuznRSmZxccl0bpTizs+K6spgRWUTTkpSkkiJRWAD5DTrF4H5OnRq25kmXxWOaY3m3Hmnpr2zW3He+IFKCvXvme9PVqnuqjJAl9ykUpD937xJnHpSQoCOP7UCDjj6jIGXBtg6lpQ/yINupVM26JlMg2TDAJQXqeWYurpYzPCLlthek7588MtGbjkXrR/3+9r/7NOPzt7/0C3/tKGSN+c17b35zq6W9otnyPyegN3epZW5K+RxKpuSrd89Upje9mDHbevfRUqtuKH9H+qGBm4uqiuwDJSd9UhsbcISp50EuA9+HvgDIfSqmDCg4AW5C83nZ9WmRrwXS4BTTsM4TcOlBsRzKcgIjsp2v3rLaIX2EEhgv5x03WiBh8sfkPNNcXG7MlZzBPH39WZTyUErkT5rnfO2MXKPotoPTjaxco+Edw45y9YRcP+1qXR17y+++l5EnhBBCCCGEbEGsJLEpHntyPtF8RjEcbH5R19u/ftdN905frM7+8Kvvubsz7rF8/vu//LIrDEP7w19QYwAAIABJREFUFZ/PuKXd1pKODZfRGThp1Jp+FeSn9FaDR5wQQgghhJCtyXd43MlaEw61Hvf72m+5/aWf/8ZG6NzbXvKFx5VSb7f+6/Kuz/3Mf6/U9NuXy4B6AydkS9I3eOIle/F7rBOwoml0bTClly1VQbkMSmPcHG+Wr+NGHRQwEVjeqx9s7iWWwXa7rRP0qEIdwqCCLv3RhOXYX8EVpD+EEEIIIYSsNQcO7n9ftSLh8+FIzbGHFkga/H4X2YESm4pCQd6+h4fcnXfm5yXIZWws51her8unSTAokpR4TOpm18nvk3frWk1C8VGqMjGRdV3H77ecPDQJ90c5zOGj473pkydHZDvdsLaX7dApJxiUPjr+1KjMt+Q3ftjfiRNSLoJlB3RzGr9JlrIiq1gAx5tYVOQituwInXvaILkJB2XdSEQkG0olelOVstlfhZK0b98ls73pJw6LU87ll545oZR6x7ue99V7HQ3aoBz4mc/9mVLqz+zav+fzr/ylv3pS/4N6oxRUlnuNr2nJWlrSn4bPw4EGvgVbBVP64gMJiQbfh4YuZaATTq1qbqe1UXQD36Djcn0Z8M3uM8xrpiffWSadwelWTmR0PkuW0wR5iz+2sqtOKy9l2DKac6WxKHIzlNxoEZEMYX/YsqLQtrTrHtGxx5bqmJU2y/DFpS/qIIkyLIckRp4QQgghhBCy9bidx5ycK6Fg88lIuLn/w6++5/RW6MTs8N1ve9VzVbBQrqly6XH15Sc+2mjWPJLVkE1HOOjvJr7h4AkhhBBCCCFbiAMH92+aCAFyQXlEKfWidz3vq1n1vK3T8b/60MKjSqmr7X9HY1eoV13/J4FCpaZy1cPqW0f+oKVqVUp5NjHPTPm6uXL0CspNVpDFqGWylp5TzIDKE1uqgiFo6DoT8pCy2JIhrEPBxR2nQwnmx1za5ZzjxN5fFCVMLpKc7nyXEtEcCKU6q3EWIoQQQggh5Dxxk1om1ckXTDlIMi4h+rl8tDetafDNEJDQ91bb/GZEqc7cnMgHxsdFnuMm1UFaLfldN7PkLgM6YznoxOPyDo31HId9oFRnFupku9SUyrL8EnC/ScTEUSQQEEnA8LAZxt9oSj3RWWh0VOq5HaQxC4vOHKSjIyIJKJVEChECB51FyxUnkRBpzfw8OuWIPGJuQSQ3sbB5XFttkX/EouBOgk6jDemDPdAHc5bEaniopHTdeMsdNz7wF45GbAFe8LnHZw1D9XRc20DicrrUOS471fWX/n73IshlH1BHTn+ht7xdkfNIgauMzyrDKMlx9YE7Dn5u1mdEema73jSh3OCwHHdMYNsCyYk+bJbdzsh2XtIaA6Q9qmHuT0+DUxVIeHSQzhjgCuQm1UFpkNGSa0pzcdVB0P3HE7/0bcuS5fhrcv216yKna4PDkQF9YMt5jKYsD+0S6d2Db/jbdylGnhBCCCGEELJ1OHBw/3EebrISfr/x0Id++h9/bIXVNjWdgZNaqz0e9J39A98mlf5p9bp9r+/+67Pfemu9ZTRW7+VLNgR6xCOSYjW4JTv1SozqBi5dTdLZiEuURsJlnlqWdNZO5uqWyFWdJVFu1KNsN9xWdZunlkWbYMQNIYQQQggh55ndbsUnE0XHPK/Eryvh88v7LUZVlCFBra6bb+sYxYJJYHHfrZZ8vEYj5vpLS/KLdDpd7k1jQtVISH593jUlCWHbVnmRiPxCfuKE/MocDst2ZYhOGbbzS8Lre7MFRhAQbYKJZH0+O0GtbDg3JwktgxBtglEtNSuBbuGMRM3EIhI9UIG66ZBottYwtxsdln4Jh2W7RUg0e/KUJM1sNHwqHq3/9cde9w+/qLY4r//SySPb45FuxMl0USIUpsbluGnW12wLvn8PTS92/16y44PBq0ZT6jtHP1I/ufiDoA+iQtp20lKI1mhl5HzXopDMFaI47EgWny7bVRdhO4jiCI1JtFNtLu+YZ0CdmxilglEjIWdKF38w4Lrc47NXtYtmdI0GA1AY+eQVeWJHgmjYbwWJ1GnjmAP2UdW8Bv0QsWI05drQE3Lut3JyfWCSXpu61W+xgHamt71jLUIIIYQQcgHgDyjkwnLg4P4su5y4EY9W3/KRm+/dktKc5fzcF08c0zRtj2PBOXD93t8IXr9XqWz+vtrXT/1TaC3KJBeWF4wb77B3yMETQgghhBBCNjkHDu7v/GSe4nEmCAdN+ukMnLQNY49Xnstz5cpL3hC68pI3qJnZr6n7H/3Ti9I2cm585nUP/L29oV5bRaJWLyrWthHYrk+FMkBxXhKXlcCEsSjhwcCblU5+lOqsVH0vWVIFGm5XCeU5mCQWYcJYQgghhBByvqlWg0+pZfKNc8ZweX8FSQomQ0VisapjHjIzM9T71yTUc2ZGpBLjE6ZMYW5WEmU2GhKKPzEhwTUojVnKSlLZRKJm/ZXklz6fhPbPQVJWTCSbWTL3Wa9BckyQyywuSp0KBZErJVNmuwO6rNtsSH9FIXFvJiP7DljSJlvi1G0HJMcdHZL6T03N9KaPHjPzm7ZAUvTUKenbjvQnHGn+z7tede/HFOnx0/cfOdVot3d0/p2vi5QqW5Vz8fun5HxIhcyUJrtByhPQJXlpKibnwKk5K5Gxdr3au+PDqlK8z5hZ+FrvABkga/GBlAWTzvqsBK2NgshNArCPFtS5uSTnRjBlnTNw2TYysBxlL3KKKqeQRSkDP/Zhfyiv6Vvfksz40lJPvHs0MXEt9J0Wtdq6KHJCTB6LdWtXRC7Xk/BAwthWSa6vBiS89cG3vD9u1Q/a5wv6O+MEi9ge91YSQgg5L+Tfd80LlaFGVdt4JTwBrDu89kWla9Xke7/7AHufEELIWvGBr/7kSGesgB1K4rH6Ax977T+8cst3xDLeeSj7sD1wciGIxF+l/ejE69SR6T9qzi/9gN/k65QfSbffgDXjgSKEkPNA/q4bblFKdf57oQJLtl5oGiSvktA7478pn1/l73iW+U8cmg/4/1gpdXfyt79ziMeLEELIQBjqGDtsaxMKtmY+/vq/377V+8GNzsCJUupal0XnnX3bf03ft12pbx79zWa7UuK3+Trj/p+/74tYIx2lOmWQlqzGaSbiIvNBB55zlQRhPXTYzM3dJwIxOyXYLjaAHAYlNSvJaLxcgcKYNdj6i1IelAb5FSFks5H/0PWvVT7tIz0XgwyEJg9LqGLPvB9vJYlV5A9rtt6mlHpb/q4b7Dl/qZqt/yv5nkcWHesSQjYGhrukl5C1pJPrJBx2jzqpgvtNuWqGya/GYWcB5CnttvlAGx/P9ebNL0hqlWBQQvt94KaTiJvSgzZISyYnl3rTubxIcRpNeXsOBhpWuSJlqVbF9QPddvx+WWd8XNpVKJplnwKnmVRKQvtjUQn5LxZFJpPLmc/zyW3S1n4XmwTMB9lA0/xgOb0gddu5XeRF+YLIJvJFOSa7dpr9kc/L8quuON2bRoegSgVkEZaEasnaLp2o7vz46/9eNiQ9fubzx55qto2pzr+vnhrrzf/6k9JdL9onY05N+EHsqYwpTzsC66IUZKIq59RT4NgTtmQ5z4L9nc6/T6+1s2r29J2qVZbtNJSyWNIe3Eer3nAs76Cn5fqpL5nSl2BU3Hb8IRinAaeZVk7q6YuY11UTpC7ottNuyPWl1cHrFh10rKoaZblODKg/yoBsqY4CB6AAOgSBTEhBv+B8LWReB82ivIdr8Kz1gcORDq5G7YZZhj8l1/vOSvHLahkc3SKEkHMk/75r/rsK+T8hW7sPrp4n3qTa6k353722s9svJX/nkRt5HAkhhLjwsHMW2QrEI/V7f/81n72ZB9udG+99cjqs+yddF14EQr602jX1EVUt3d2cW/o+v9MvMt/7H/e/dHkNeFAIIWRA8nfdcK8q1m9aN/1mqJfm77rBHlZ/c/LWQ590rEMIIWSrsptHfmvh01T9j37h07TFPQudgZNauz0ZXoeagO2jb9W3jyr13SP/sxOX4Za3lZxndgda/+a2h77Bk6iHO4yXlMVew33pYFKdenswyZBsJ9MBj81s+dCgbkKD4Faym6zJWX+G7BKyUcjfdcPx3kuoW+4S1BmiVGcRJDwj9nwJe+wjJ6GaKgXvPXZ4IoSLGg2Z1kq9sM2783dee7dS2keS73n4Nx3lE0II2TIcOLj/a5221mryzAmFJMw/DC4v9nS1KqHzKEnBMlot+Z6Lx+G5ZYFSnQiUMb8A6iHLsafVlmdnOiXOGqmkSAWiEadDUDgsMoEauN806jI9Pi7SGHQISsTNsitlaVMwCLICeLOfXwD5UMtv7VvWxf7y+eW9fhicfEpl83l+xWXiiLOwIHKEAkh1htIimzhtuQxhfwegbwMgXTpjuQ9Fws0/+6Nf+PT/UMSTN37l9JOJUGCy02PRkPv7GLzdqe9OL/Smr5oQqdeo5XQTD8gAzOGcHPcqvCNG/ODCY+1zAeUw6OLaNI/rZbsP+DLZvzXml77dXahZchgN5CY+kKSg5ARdbIyqec2jdAYlPiiBCUAZtouNnhDZWAvkMCi58Q/JddJCBx2rPHTEseVAZhnY04BVJ5TktKrgqhOT+vtTUj/bnccPx9UHdWtm5B7TAClVcNiU1NVPZ7p/H/6tLz7PUSdGnhBCyMrk33P1ojLUcN9gxrrH+I38ndf+htL9jEQhhJCtywt57LcOH3/9py+ofngj0hk4MQzj0o1S9XDsddpU7HXq5Cn+HnahmEoFHvHaFcOACCHEg/ztz/xC/t1XG92Bk43L3R1JT/63rno+jzMh6wuD/1s3/9uMHDi4nwPnWwRdN/6DAycrs9EGTpCpnR9W6cAuZwgWWXN++MsPXOdVZl/kySCuM8pDqlKBMgIYDQShSLabDspzAucoqYHkwCro4YSzklwnOMAQklcf4WPXbW+4HToEuTkIEUIuLvkPXbevE3mpwrpSNXhO1SDLtx2F0oTs4pB1vO8GOAQRK0WrvLiE+faB0S19kiCrvByEXA7DujEIOy1CnaPWPSam/2v+d699PPneR6507JMQQshm5E12m1CqsxL9khSQB/jkmTQxkXWUsrAoMhRdl3WDQdn3+Fi+N12vm8+tREJC58tlkbyiw8zoqGw3MzPU/ZtOl3vz2oZsl0rBfHDyQUmNLUEag/ocPzHSmw6F5Hl/yZ55R1vn5sVNKByWdYdSIsM4Bk44sZjZp9PT8luM7YjTrXNSpE8tqLNfM/txbFzK1XXZ38xsUg0lKzd/+KZ77nVUkvTRsSMeS8ccAyc1kIVML4oj0+XDcj4fyYrUowUyk5IlI5kak/MBZTsh+FC9Zrc49nz5hye7fw2Q3Fw1KmUcz0sZ14FM6NDMLwbHje+r09m/6c3TI/I+WTslBozoKuMLmtMGfneCXK65JPtDmUxgwqoTvOuiQ02jINcu4gMZkC3XQWceLM8fcX8f1i2pTbso14aeRHmOHCuUGtnOOq0SyItgf+hkhB/wtszpP00EDzgqg/VyzCGEkC1M/r3PfExF9as2Zw8YV+R/91mGCurXJ289RPcFQgjZpBw4uP8WHtvNz1+8+W/4K+wq6AycKKWuXfcVXQ36VWr3xIfUidnfXv913WDomtZ88M33/cbZak3ZDiGEWOTfc7Wh2sYmHTjp4ztdxyBCCCGblbt5ZDcxmjZz20u+wIGTVbCpBk6AzgCK7g80HQvIObP06/e5Zw8G+iJPgqu4BFuY0deSydRhXsRD7lNbwU2n4eE6s5KsJeAh1UH5kFedevvA7MYu21U8pDoIznWTJeF22F8tj3YTQi4c+Q9c+1ylaQ+pqHXPrEJoYVBCDw2Q0WgVKxwQk4Sj5Rfeu/Igo7HddlBag9pB3E53sc+LwrwyPDOxDJT7LFn7STnCIm/K33VDNnnrobRjH4QQQjYsBw7u3/N06p7LizMFOt60wfFldk4eHROWo008LmHyGsTDFwpSXiAgEp6i5TBTLGIydtlu27al3vRTJ0UCY1iPOJQRRUA6EwBZC0p1Dh8dh3aZofvo4uMmz+mQzcVhP+Z2jbo8i/0+eJcHKQ5+GwQC5nvF4pLIC3ZuF8nQydPSn0Gof9Pq80JRnuGGEfzWx1772R9xVJQ4+NV/W3i0Uq9fbc9fAqeYSyZNOUwLvvOyFVk+HheJyOXD4hL1gzmRrD1nz0T3bw7KxciECjgkHjw87ajfjrScW9+blfN9FKQsQZD++C2HnL2pmPX3f+mPzvxhY7F6vPsCiw4zChyANEvC4wvL8saCyF5QDtOG7+L6vHmO6hG5RjV4L9aHpf7osKP1fb+b0z6Y54u7GzA05+Wa8Fn7bJalb4OwXSAl95W+PB7WfjS/DHM0K05HMLVMxvTslPqwYwUXGHlCCNnS5D9w7Z8rQz20Rfsg1Ukm65hLCCFkI0NZ5iYlFGrdwYGT1dEZODGUunotylrPjCTfGtiT+AkPv1+yGpIhX+Frt9x/62rW1Rb+83N7L84eQRUrUoARu8S5FrIGeCVzPV/UIWpkLRK/ph98iOF3hFxA8u+++pRKhXZ092jgL0dwKULiLNfM0Bg9BgEreEPtj1ixyhsKu67bl3Q2CMGBdrJajDbBMjLuvvtayBojxwS2WK69P00bS773kQVFCLlgVJ58Iwcv1wmRy/5607yDHTi4v3teYbJUBKMxViKzJL+4hyDxaywqv+QWS+azKB53Tx45D8lVh4fl1+65OXP+5KT84m4ncu2WW5RfwyMQIRKNyvPObbtcXqI7wiF5piaTkvTTMMxn4glIEttsy3My4McHupCwIlZKEAliR5V0yBflubx9m/yKPj1rJh+9fO9sbx4mlMUjVa3LMzpold1q+VQyUX3VR26+535HpYgDlOos5iSB8AgkFrUpV+S8rjVkOg7RFmV4F0zFZH7bet8qV+X8zEIUSgQiQU5DEti9I+b5UK7J/iJBWffwvES3oKlKKmyedznYX1g3z5dc7XH18Jk/7c3XIHrZjt7ACJIGJFQNpCWKo5mR6yS0zYyIalelnlpUzn0N3jcbeelnfJf1x6xrAiJh8J27XQEjBD9Ey4R0R1mYBNYHbVF+eMdtOceRDEjy23f3sxLJ5n/tPvebpQuMPCGEbEm6AydtYwePvoVhzOc/dP2zHfMJIefzwuN/6+a/zQHtiTcnqWR1JwdOVsdmzXGyEqnQFeoVl925wlpkOYMMnCgOnhBCtiIcOPHk2xxAIYSQDc2bePg2F//3G/5e+/Cr7zm91fthNWzVgRMbXU+pm57xx475xJ0XjakrXBecBX016hZQw/RFl1etUB2U6uDYfaEp/0rqTz8asmKF+EQ8ksReCKkO4qXUsZPq+qGemDAXq495HZm1kZDzT/7Wq84YhjFh70izQxEx2RTeyDDMMA8Jp6xrt08ik4CkrFAeJtdScXMdAxLGag24EaAUZxFCoBNWOGfCkfjVqqfcWLQKlGfXL+yRQBzvm+a6385/8LqR5LsfzjjWJYQQsm45cHD/dZ26VSrmcyQSccpbBmV4qLDiFrZcJ5NJ9uahzAbJF0Q2Mbkt61geCok8oN2WZ2cGEq2Wy+ZzMJGQZ2Q2J7KDSlmed9WKPKNrkOR1bDTX/bsHksROzwxBPUSmEYO2nJw239ZTCXkfKMP+grpIDAxDnq+2DAilOgkoIx6TYzU7K/34R7/wGY+vDbKct3976RGl1LNUV8Uh3VauyfEbUXIenbQSv46lJOnpUNIp6+mggbzmW8dEevWcS8zXyW+dnJN9ROU9bhjKGAWZif1t/Sgkn70UpDMTkKy2BPUfsuZPF+Xcn4VkqCet+XtH7lTHcrf15vstSVAdpDWYXNYH76xtkNTUzpiSOj0pdaufkToHob98IXk/9SdFeta2PnZbBalzqybXV2hSvoBrM1K23rYSxoJUxx+WfTSyIi/yRyGhrSVXasD+NGiTnWj2+UOtt9z3c/c9oQaEkSeEkC1D4d1XfcNoy8AJ8cBQi+4LCCFrSueFjv+tj/82B1/jBbp54MDJ6nnTV6efsAdOiMm+1PvZEx50Bk4e+Ll//Av3pWeHgyeEkC1B/neufme7YTyPR3t15H/veiayJISQjUWKx2tzwIGT1dMZODEM47KNUt8LCQdQnFyW3P/b5zpw0kFbeoG47bgZSayGCoStR7y0LEDTGuHXPeQ3yCB18pIXla0F0VXIegZty2ppwa8afo92022HkPND/kPXD6l8TWQoaZDG2Nc8ZufGrN0QWqgiIH3JmWGEBspzNA/XnAi421ge/SoPIc1xWI5OOIhVjz7nnjCsi3XGfaPsyKJPMoR1xlU79dRUMfk7jySWb08IWRsqT7yBg5TrhMjlf7Oh38Hu+tcXf0Ap7T2dab8lEcnmRI6QThUd26yGalXC5AvgfmPLXlTXFccM3Q+H5dmysCD7DkfkOYr1KBTN8PlEXFxI7LJUVw4E7h2AvU4RHG/qDXkeYiDRxLg43mSzUnYsZsowWm057K2mTOcL8p4wuU3aarfx2PGx3rxqXd4NRoelLdhH1YopK1jMiPyhWHGX4f7ZL/4dvwdWyeu/dPLItpHE3tWuX4V3urDl5oIyHMwycf0eCVT+5tGZ3vR2kNRMjZuSk387Ist/bN9kb3oBnH7mCnJuXDpuSsRyZZHcaPDVi3KeWAAcqOrm+XfZkEi7Hl+Sczyqy3Wwd0iuwft/8Kvdv3httBvSFxq8Q6Ijj896z2yCg5AfXIHQeaddkHWaICXSrNdWf1yuKV8cnHJAElXLSB+Fhs1rBYxylAF1boMDkubmmAnzDGveNdt/5a0HX/uyT6inASNPCCFbAIP5O84FQ8XzH7j2zzdexQkhZKthDpyQjQ0HTlZPZ+CkbRirHjjZyrz8yo+riB5xH43cIjx3z++/7ukOnCgOnhBCNjv5D13/PR7kp4Gh3pK/89qRDVt/QgghZAMwlKzu5HFaHRw4GZz9lx6IjkSuaKx1uesdv8/f6gycfPmmyz6zFlXtiw9ve8hevOQwNquRt9QhdCZohc6gA03Io4y6yzo4LwjbudVNrVKuY+PWFq/9IW59VME2DySEIoSsBbnbrvl5rdl6ZrcovARR1pK3niMjIOXJgUNB1MOlxnLN0WpQFtwrDHAb0yDkUNlhhsOwP5QG4Y0Y69wrD2ZWYLs4hP+iVGfRagu0z9PdZw5+lMD+UGphQDUnIWRVULVDnj4HDu6/1+9UaKoEyF68JDxFkOLYrjm2W49a5tiDspw6SFVseU25LNttc3HS6QIOND7r4biwIBKEeEzC/Ws12YdhyO+99YbZ2KEhCPEHl55ySeqRWRKZTLUq5TWbZhmxuOyv1ZZ9RMLyfEX3m6mdZiBrG+oT0ME5JCjvBEePjUtbrDqHArJ8xzaRWzRbvv0feNn9tCNeBW/4cr9U58Ssea7tnhDXlpMge7GlNR1mwaGlZcm1x9GpBe7JKOd57l6R4pQqch0sWrKcqYRIwk7NiVzraE7294LLdjgahw40UXC/qYNEO+SX6esmzd+yUHL9owmRF337pLhHfXtacv9HLanNT171G4Fy5bj6xx/e2RdBYcB7cast17zRNt8tdXACQurQVp8uNyF08vGnrL6pyjXaXJJrV4f+16PoWmmW11wswHKQ/kRkXR0k79UF87ryaT6VjF3WvHb72177+Vddeq+j8ucII08IIZsWrdn6Ox7dtSH/oev+v83QDkII2YTcxIO6cfH5jXd84GX30ylpFXQGTlqGYsTJ0yAa2aN+4fo/Uz5/YFNHoYyO3qrWeuBEcfCEELJZyX/o+q/z4K4hhnp5/rev2r1p2kMIIZuAAwf37+Fx3LhomnHvbS/+/B9s9X5YDRw4WVteesXHAjfsfP1malKXWHi8cfnOA+oZQ9tvXuuBkw56E6QlXu43A6hePAm6lI1SHTfZy/J1bOqwrnue6rUl6FHPBvRd2KWefmyTxzAVSpcIIWtD/oPXDStD/bgCRU1fCvU+B5q6c5+ghvG8eDNWWOMQZAzvc8KB+RAGahTNSmlB2EkIFJQQ1qhQXmM5/Wjg7qPANcdYlNBPLQF3xlTAUbc+0GVoPOpY3GXeKjvm/37n/x3LCSGEXCw8Pw78EO6PUh1bsqK6UQ+OzfqkOl6UK+DI4Wtb27k8T5cxc0YkFJOTS92/gYA8DwtFCcsPh2R+LCbPuMyS+ayq1USKFI/JvhMJkQSgE47fJ/2Rt/ZTA5eeHZMgNUJXEvit+dT0cPfvzu1LvXk12MfSksigWi3Zbjhl1j8OMiFdbxbes/+fb1ZkRd7+7aVHJobdXXVQrmODUp08OMXgura8Zue4u8N3ASQwdXB2mc+BXMySi2AZD5+Y602nQL6CMqDrdo52/57OS1n7RqWMVFi2K4PDzGOWHKnelBfcq8akTTvA0abYkDKGwuZ7YaYgUr7vdMu6Wo2P3qka1Y9Xs5Uz3Y2b6GJjTTfnRWKG78UBkPNo+C0MEp5m1mxjICZ1Q1lPA45Pn0OOJWnywRhCA2ROfnDArOYrSvf52ttGP+CrRluB8UjwNedj4EQx8oQQsikx1HEe2LXHMLRo/o5rXrDZ2kUIIRuYa3nwNibv2f/Pyc3YrrWmM3DiU+pZm6tV64tnbf+t8Av2fUzp/uDKI6DrkB2jv6o6Ayedml05knzNF2+67LPnq5a6V7SJW4LX5VSsqAlMslpsYTSGbKApjN4w1/FK9oqxGG57jp9jKMxqEr+utA7u2j9AvyDYPrfIGkLIuZO/87pLlWEkugVgUtaSh7RzxPqVCJPI4mXpdY2OuURpZOGZMwqJZiG6QwtY5eH9IwOj7kG4cdYgKqRllR2DcjFJbE1G4/uiTOpWu/DGE3ZJKKuWRZ6gsb4VvdJNjttWD3rcmgkhhFxA7vjyy69st8xffjHaYiV0XZ53ul5ZYW18LECyV58B883n1lJWniFjo5JIcnpmuDe9fTLTmy4UzfWDEHkSDMizB6NNSqUIrGPWf2hIommWshKFEoJIkOHuiPXsAAAgAElEQVQhSTaJkSC5grnvSFgiQRYWpIxkqgrz5df1WLRm1UfeL4IQSRqJyLvGyLAck3jMLC9j1TOgtyXLJ/HkjV85/aRhGJeq7nkm59z4cEI2sd5XjkGS2H2Tcs7NQXRHEiIz3CJO2vC+dvXUmGN5hz3bhhzzDkNy1ut2jzuWd/j+KYlkCVgR0M++ZFtvXhXMAwoQ/fGMEUiobEWQPDwj19Gj89DulJyrI5BQ9fGMeR1g1ASOAUQD5jXzkss+GsxW6+rQqXfX6s1KqG1FhRgQ9awn5Fo00PAAIlLqEKkSso5VPefulOzDaHCok2Ed1za8nweG5Br1RQIqafyyiqqUGrb6ZSIWftlnX7bnnxw7WUP081k4IYRccAzjSXb6+SV/+zWvSd7xvX/YzG0k5MJA6S45d4y29r/ZfRuPgN7+b3f85ANzm61da807D2UftgdOyIXlhp0f7Oryjs38XmUm81RkPXV/zJeqhAJviYSNfhX5hRg4URw8IYRsJvK3XTPRF7lBzg+t9mcYfUIIIRcXw9BexEOwsdA04+gdP/nA/7PV+2ElOgMnlKRdfF563V3dgZPHZo6q7574YKNerwQuRqX8fn97NHGjLxDqKscdgzkXauBEnXXwxEM7g7PtIBuUuqxGUuMmdymD3Ce6FhlqAVtKtJq6uUl1BsVLrmNz9qWEkHMmFnhczUFYYFzu8UYFE2CBRCdtJb2rech2EAhPNJrmfUXDRLSYPHa+7D4/ZYWMesmIMGQRZ0d153YJWVcbAokSSpDsQnD5LNYNpD/Yd5goN2WtE5H95e+6IZ289RBk1yOEEHIhQalOpSL3eLeEryhrGUoXHcs7ZDKmPABlKD5wPyiV5HmRTsu+A7q5fjwmEhhkKC3PFkxWm8+bdU6nRJ6j67Lv6WmRXqCS1JbfjI7KzNFhkecs5eQX6bk5kTzs3CnSCqWZ7dq+TRK/FkEapGnSbkw0az+iFzMiUeqT44MEqdHAbLzmhne+/P59ipwVHDgZB5mGFzNWAtdY0P27PgjvMzMZOU8mLTnJ3JJcD177a6B0BGQm9rHfNeaUAHVYyErZ21NSdrFsXiunoD6jCTmnnr19RMqAJK9PZEw5zOXDcl5Dpg11HCRKz94psqMTVh8979IdvXkHj0z3ppNReU/Fz/SvH5vp/i03g2pk5H3dDr5hfEj9YPqPy8eLj0f1iAwlGH0XqUzbch0dZETNCtwrDJTtyGSgFalNpN8YmtxxmbIVR8Wa8915ezzyigs1cKLOOnhCCCEbD/enFzkfdF5uaJFJyNOBqh1yjhw4uP+T7LuNhc/Xdk+iQXow4mRj8Iztb4s+AwZdlgoPq0fnDlYyjSe0hlEPD9qIRCCdn4z+SHQseWNvbOJkoRxyrLiMzsDJPa/Y+3nHgvMIB08IIZuC/F03fIxH8oKyewu1lRBC1htv4hHZOGia8Ze3veQLC1u9H84GB042LkOJ65SW2RYZsUYWtKiEkASsyJ8rIVrmkTmJ+LrEtDse2HnqYgycdNCbEOuDjjheP4ZgNLsVtd4nswH1jRpEfbMaqY5dNK65mv0N4s6D/WFnIa6ALGklSY5ahdsOUmt79TQhZEDe3l09AWGbBQnv0wIgQ0EJS9YKb0YHGsjG3hcPiffLkFVeGTKNl9yzjvdN27IbdM1BKQ44BPXJi2zZUQjq6XfP72JLisx6WutXYB/YF1BnA++V0B+a7ciD2w37OwNWtyRvPcRfPwk5Z/gOQM6Nej2ggkG5r6NUp9Ewny8tcMfxkurk8iJxGR7OO5YjAV32VyiIxMV2tMHHJcpz/H55lhmGBtuZUoIsuPRMTspHFe5jbEzq1mo536+PnRiF/YlkIJmswXZSp5AlDzrxlMgj6lDnZFy2a7Zl/vj4grUPaezcosgxAkHZdzYvz/OPvuaztzgqTXp0Bk6qtWZ34CQccv9tH51wfPD+M4nOOy7smnC643Q4MWsqj3dPpHvzHjspjjjotoNSHeT71vq47qk5cZoagvfJExk5h6+yJDW5M+KaMxWUdp9clHWv3Cnn9iVWHxwGt52gz+c6/a9HZ3rTP77HNHf6/knJUxzRpU3fODHbm06F5P30qlEzoPu74GT0zWnpo+smRFo3EpFAkWeMS59/6fCp7t9YWMr1wzdyVJd2n8iLRMl2581UxMkybNV5MhZ++edefskX1EXA/c2bEEIIWZm72UeEEHJh+eCDN76VXb5xGBkqT231PjgbjDghg3AxB04UB08IIZuB/F03MPqBEELI1sBQH+GR3hhEI/XvfuTV95za6v3gBQdOyCBc7IET1U1q7eJ8o5Y54ngY7/SogHYmAmHfKznotCC+D/eH7j3ofmOvj1KdCoSnR8H1ArerW9sFPdqKuPWHe6CWN7ZcZ6V+69D2WkAIWTXGYqWn/dZAtmPAfaDPFQdji9NWSGUBMn+3QOKC8po6ZhK3/qI8LwmhpjVYF+U3ustFn4acWH2ON7Cura5JQX3QVQfum1rMJeN8UcIeVQDu7xDiqaHjEMqDbGlSFOZZ9cy/++p3JT/42AHH/gghq4CyHTI4mmY4dAolcIqJxUz3GpcngYNUsuSYV6uJK0YuL+XqIFXpk/hYUpwAuPQgKC9CmZD9+GyAXMYw5JlUqcgzVdPkmVqrmXXKF2T5+JjIkqpVmZ9dcriaWvU3+2h2TiQ30bDUs1qTMnbtFInE4aPj5roRcCQCN54y1Hl8tKh+75X/yIEBD5YPnHjJdWx8HlJlN2w3mw7xqHveUVuuUwZZ854RSb1xel7kNw2QDGXB8SVgncTZgjhG7RwX74JCSepRhw/YY5bs5rl7J2V5U/aBUp0ZkPCMpc3zdaEq73RTIA2KB9EJSO4As1nzOn/mrvHevK8+LmN6+B2uwfR/TJsyteft3tab9w2Q/mC/TCXl2v63p0QG9Kwxs58fAknUMDjvTBel70ZA2vPEkilFvDxt3u4i4cBP/N1Lpr6qLjKMPCGEEHLuNIzb2HuEEHJh+NCDNw6zqzcGwUD7mVu9D7xgxAkZhPUycKI4eEII2ejkb7/mNTyIF5F22/ELKCGEkPOEZtzJrl3/+DXVeP9P3f/YVu8HNzhwQgZhPQ2cqNVaFaOMJoTZcf1OeQpOt1aIRsUQIXS0wUh1NwkPRr03VqGpWY1c52y4SYeW19+Nsy81iaxQBiFkBaKB/6JBqGOffGUUwnXnUQ4DocX2DaUCbgAQgquhxAdlLXb4Mg5BF6AeOD8AwdN2eCiGpzZguyBsGMega5d7BWZ/Lzcci7u0zbINDMkE15y+UgNQJx3qEbTW4v2KEEIuKgG9+Utu+w8E5BmQzZmh/emUu8POShRLInOIRKTcYkHmo/zGlv7UqhKKXyoHXctIJiRE35bieH0u7N4tzr7lijzPa3XzWVUuyTNyKC3yo4UFqFta9of9UamYUocEuOr4QJYUD8r8KrTr0r2mZOHxJ0VuofnAqdOa/uPXf1o2Ij1+/VuZ7+p+3zX2vxsgP/ZytFmJkiXRiYE8p+3hZrqYk3fBZsvc9wS49Sxk5TxCd5h0Qhyh+sq23hG9JEVhcK4JwzpDcaec7LFTImsJwro70iIta1vvdM+/dHtv3neOi0QmX5f32yi801WstpZAzhSD5VdPiTsOugLVWuZp/O9QtxftEQnPU7ButiplT8SkfUdzZp+ORkVeFISP/WNZuS4Dfrl2p5JxtS0W+qn1NHCiGHlCCNkE3MSDeHHJ337Nz27l9hNCCCE2gWCLEScudAZOlFLXOJcQ4qQzcPKZn9rzRceCi4xn5AlGjWC0SREWxK1RI/wtEpeHYGgGy7MHm+rwi24E9tGXaBUKt6NTcN24SyLa5TSs/WAC24DmjKBZjt0W3MdK0SZeZCGxbQJCZ85tjJUQ0qOTCDXpkXAVozsguENVIYLETp4K17k2Ar8I1CBKpQU3tSoWaIHJXDFyw4c3Q+svRsKk4AcqzLcHHvxqsWq1CcqKQvvwPjYrZRtW9IqGbR6R0X+Vl18KDIiA0UZg33byWIyQweZHA/9ZKfVZRQgZEPdfRwlx48DB/XtcZncJQrLWYND6JdeAyGlwKPD75QZeb8hzK2hFr4wMF3rzqlV5vk5OLjn2qyAKJRqFJJ0xifhQmpznDdjf0pKZnBMTzWJiWKTVhIhJq7wyJLY9fmKkNx0OSXnlkqwTjcC+s2YkQUCXZ+NSTp796URVyijLds2W2Y8jQxKhMLcI6lVD60SdMNfJMjpSHYw4sRkk2mQBIhRGIRoj5pIQNglJVJEUzNddokVG0zHHPLUsIawB368nraiKZ02NObZRy+7wU5CMdmbJvMZOLUmbpqBNT0KS2FRFksOmE+Y5Ote3ndR5BiJrcg25DkoN89q+GvpqH9TnX46d6U1PQlTMrrh5nfwAIkyOwfQ4rPvorNwf8Lv/R3dNdP/+2wmJkLkU6rx3SK6fo1a/XD6c+Jn1OHCiGHlCCCFkDbiFnUgIIeed97GL1zexSP2+rd4Hy2GOEzIInYGTf3rVZfes107j4AkhhJCnS4o9SAgh5503sYvXNx997T9QSgxw4IQMwnofOOmguyVkVcsiwCsuUh0vcHnTcE8C29ufhwTGfW6/XMcNbAuoZHqynJR+9u29qGA7oNzgCvVB0ue4b0KIN/l3X/1fuxKcMMhXYiCdKUES1STMRzmPfR2fARlNVsJ1DbiZYKLV3o1qXJKI9YHlodRm2AoZnZaQXxV0qU+HKtTfLqMOIc2NOmwHOwf5kFa2QpKHIKwV67ZN6q9hf+FN1K4TJrAtg74oI/1FCBkAqnbI06BUkpD5GMhkGg3zmZLNSWj82GjOdUfBgEeycYtwWKQ48wsyTp5MyHPEThhbLMrzxB+R+vhAmdFsyj/alpRoKC0ShNnZtCwH2dHkNpEE5POmvOHyfSI1ePLIhKNc1ZUlyf5KZZFsbJ/MdP8eOy5yCx2SxVcq8lweHZXntc9ap9wSOdDUDrNuPs34Q0V6rGbgpALvOfbnFsqrmi05JijVcQOlNba8ZTko1WlYZgMBkFm3YX+YBNarPEwka5MrgRy6LeXFIvIedul2U2ZWB2lNEBK4tmC7SBDNA+y6i9zMB++N1+we701//fB0b7pqtetrT5ySckEa/pwdo1Jn+O4NWOukStK3EeiXpbK8/xUhWe0wtPU/TpvJZitNWZ4Iy/LHrOX7hhI/u94HThQjTwghGxnNMF7OA0gIIYSQi83tL/3823kQTBhxQgahM3DypZsu+9xG6DTPhLGEELLeabfUcxjTRQjZuDD0hKyOAwf3v4NdtX5h1InAgRMyCBtp4KSDHlzBSaeDSzLiLrYsR9dWLsONWttd1qN7yHlWAtuyFubqYZco+YBHm9za7SWJIoSsDdpI+FgnGXifbCQN8hSv6w4ddOxVQL6CTjhaCOKNg3AzjDgzxBsLEtao4bpusr1huEsV667rGiVwILAdgCoQYp2F6THILI/rxFzGyLFucx6uP1intFV2FfrNS65ECCHkfOAYPAkG3SU3tjQmHqs5li3HS/rjhpf0x6YBjjgtQ56R1bI8h6JReV5HIuY0yoGiMWlTIg7yViCZNGU+J0+Kw85QugLTIgN6CtapVkT+kDHEaaS3vwTILWBcM1+Q94pw2HwO4lPd72ur217yBUadWAMnxXKtO3ASBFlIMOjyLtI5B8JOSQri5ojjhZe0xguU69igVCcHMqB8Rc6NJEhSZvPmO1QVZDbbQcoTCUn72rCOLS1Dqc7DJ+Z605eNi3zt0ZnF3vSPRLd1/zZAXlSGd9rHfniyN/2SK6eknhnTxabvvK7Ke96JJXHYevYl23rTX7HKG43JO2YiLO+KLfj+ff4ukQyFoF2zOfN6HN8u0qDZvHltx0PBl3zppsv+j9pAOM8aQgghhBBCyHpiN4/G+kTTaNWvGHFCBqQzcPKpG3dtqIETxcETQsgG54U8gIQQQgi5WLz3xV94zVbvfA6ckEHYqAMnannOEy+ZjZcrTsOK1MGIdCwDlbztPucdc52QV0i9ByUrNCgG+0DpD0QO9U3bUfde7fCiaCUy9nLKacG0W98FPNqH/eK+BiFkVZRdQpZzEKaM7jgYq5gAaY8lcTHQaSYKbjXo3pMDeVDNCpmMSuikhtc8SmAw7NTeTx3uICg1gvuUhuGsS9a+US6EDkILUDd094lY5UEWdAPum1pa6mk0YD7qFe2Q0BrUGR2OUOJDCBkA5jwhK3Pg4P499kqrkdnYch6/v+1YthyvMmymZ4Z609GoPCfrNXkGJJNmGfiancuJdGF0JN+brlbleZdZilntgOf2Ki6J45ZDTiwuz55sTmQFmay7rLRZluenvZtUUvYdjbrLdqo1edZWKuYzM5s396f7DPwc2JJ0Bk5KllSnQzxqHuNGw71rFnMiFx5JuR8rN1qY7sHjG+tcwHoGAnKOpEAG5If3uDbUY8hqaw3KGEpKmx47vdCb3jciUrFs0bxmpvPSF7gPdLwZA2ca+z0T5T67JuQaDUzL/h47Od+bvnpKXKV67QOnI3TsmV4UCY9teIXuPk/A8msnh3vT3z2T6U0noH6jVh8tWjKocCjw4k/duOsrjgptEBh5QgghhBBCyPrlFh6b9UkyWX3+Vm4/I07IIHQHTl46tWEHThQHTwghhBBCCFnXcPBknXLg5s89tFXbzoETMgibYeBELZftVNAdBqKh/B5yl1rTXD8CK9cNLAMcezzKcNsOo8UxbM4lKbKn9AfdbwaR6+B2ttzHzUmnQ3OF8DHnHOf8bFPKSDvWJIScFfsaRCkLavZQWoI3EHSjKZjT2jBIZ3IgQ8H7Dsh5VM0K742DPCcL0hmU6qC7j+10AzIhA+RHWgT2gTcLu40g5elz90H3nibeOK3tyuDcA1IdVZVQTA0liiPg3mPfiN1uwuosrkaEEELWgl6yWC+ZTb0OclOfec/2q5VlO5mlRG86GDCfB/G4SAnQxaZcln2Mj2d704uLphxhaEjC+X0+eQ6h4w3SbpnPlJFheQZmQXKTzcp2CZDXjE+Y7h0L87HePD/sb3RI3HbmF2Sdyy6dlXZnzDo3W/L8smVEqivhkfeARl3eJSa3me0OBBJK19ufcTRqi7B84CQUcrrmoAQGQanOEshWEpajCzrslOF9LRpx7sMLlNb4VnhH8aonYkuRvFjIgsPT7FJv+qrtcg5ju+ZyptvM9XsmevO+c1zOzx/MyvX1nEtknXzRfM9sg9tOBVxzhuPSt08siDvW0WlTUoMOSOg2hK/Op+GYPP+Sye7fBw9Py3bwLRwAeU4I2pdGlyGjM1agv+j/ffHOB9UmwONNmBBCCCGEEEKIG3e+/L7Xucze9DDihAzCZho46aDXcWQOFmCkCEZe4DqpoHPsBUeumpD1SYfymtavmBr8rIrRIUEYACzAL6gRl5HDDISpDEF9MELELgMDUNwSvC6fb/dNxGPdoM+9j7zKtsFok/bKPwoQQrywoz4w+SpEoRglGY3XdIi2wAiKhDU6DqPxakSShKkqRI3A/bKXjLYpF7EB17a2KFEoBtwLtYg1Sj8KkR0QFaIwwdoSRMDY0R9+jFKBOvugTQ2IrLGjWiDCRGESXIicMSDxq1aGfSetdTAyZU5+mVBDZ/9FhhDiDiYFJMSLGiQsDYVcEqVDkthBScTlWRUIOMuoQmLYdLrUm240dJg2n0UYbbKwKMkxIxF5xjXq8tzyW3VuteT5NTEhv7jn8hIJUizKcya7ZJYxPiaRLqGwPLMwKW06Je07fER+wZ+YMLddnJXIGx0S7LZaUsb4mCS8XczEzXV192Somx2vgROMqiiWzSghjNbwSvaKyVVt6pDgfpBoE2SlaJMONWs/oaDuWLZaZhbNc2MSksGOgpQAE/Qjk8Pm+oenF3tzn7lTkrpiEtv5rFx3p6wIl+t2jffmnZyXayYEkSC1lpSxd7uZ2PVrT5zqzXvR5Tt705jE95mQBNbum31D8d68CETq1Otyz9iVkuu1avVtOBT4ic00cKIYeUIIIYQQQsj65MDB/a/moVl/6Lrxrq3WZq+BE0Lc6Ayc/N1Lpr7qsmhDw8ETQgghhBBC1idMFrsOuePGB/7XVmrvOw9lP8mBE7JaNuvAiVqmpvH0Vl9JhoKgtCYH4eyo8LHXWazLDqO6c7nqj4h3BXMytiH8FWVHCX319UdJjZ0HN+hYy2QJ6j8cdO5jviaVHwtBEp0B6kMIOQs5MxzXgBuBBlo4lAb2JVfFhKq2fAZkNioMcpgI3JzykrCul9kattNSkMx1ESQwkKDVsCQ6GkiNNLzHhmB/oy5JbhMgkYHQViMnddNCUH+3kFGQ52B5Wr9mEvZj1RWH2+Geplor3KgJIYScKzd5SXW8KBZNKQQmfsWEsijxQfn47JypN5iAZLBDaUmEifhB4jI2ZiamnJ0VvUI4IvvAZK5jo5LE0k4kW5oVyUMwIDKO8XGR5aSSIl2w6zk7L5KbHdulztGoPA/bhjyrKhV57lbK5nM5GpZ6lqvyrE4kpIzpGWmX3+/yTN3kvPNQtjOA96bVttKW6zTgIy7glXDehSDIaEplOQ6xFZK25grynpdKRBzLl7OSXKcKyf7DIfd1Ua5js5okt3Z5l253T6aM/fXEnCSgxQSzboyAdOZFw3J9zGbMa2lfWuQ3X4cksM/dLeViAt2vPn6y+/eGHSIp+tap+d709rhI0O3P8KFI6CWfeunmHDhRjDwhhBBCCCGEkNURDjfu3Cpd9c5D2c7I0d2OBYS40B04uXHX/3Eu2Ty4D6MRQgghhJDzDBPGErLR+PBN9/7OFjpoS445hLiwFQZOOugB1O3AJEpuUhA6VIMQ8JAlr8mC4008oLluhxQsZxqMEEclCzrsoEuFvRt0uemTCUFUow4hgkmr8JaHrKflke0+6iJXqhhnl+og2BfYpkFkRISQs2BJ47QY3ExqkAE/DOPDeNkNgRhv3pLdTELG9yaUMS9hoH0uPTGrbJT4VCTEEyU8ClbR7HsP3Df7dIvotoPZ4u17CMqLQC6joXJmxEVsiFZo2Bdz0L5h2G4CQl7temBfYB/WKNshhJDzgWH4lAY3eFuSo5bJchC3+V6yHZQE2XKdRkPWrYHbTjxegfmyjq5bz2JNnjO2LEZBOH+HfEGkF7umTKeRbE6kBEtL8uxZXASHj6jUs2CVEQrKM7del3oeOS4Sg23j4pTTaMrDuGa5/mwbF1lSuSptQrlSKintLpbOLh3ZTLzzUDZ7Ls05VxebQsmU6CRi0sco1ckW5LxOJ5wuPV5SHbvc5WXbDkB+D2celOrMLcn5MA7OM26gVCdflHe2Yk3O4e0jCatNcm6lPep/3W5x1rGlRFi3XRNDvemj05netO2wo7ouPOb5noiIzGYHSI7mwNHn6JLI5dIh8zrOlqQdzxwTGdujltPPrkT0VVth4ERRtkMIIYQQQsj64yPfePElPCzrC79P/e1WaOc7D2Xf0RmPcCwgZBmdgZMHXrnvfseCTQoHTwghhBBCCFl/3Mxjsr7w+1vv2CJN/ahjDiHL2GoDJx10jORugUTGp9xDmNzmpsFKBx10MHIcAtF75g+Y4TsHK4yCHAYj21t25LiHi82wS6Q6UoGy6tBwNNNwc8JBBx4cbYp4RKM1rfhElBR5DVPVPSRDhJBVMG6FbZ6BEOVtEMpZlRBJDSU3mDVds5xnwIHGqIITzoQzNLTLnLVPvGfAvclARWRcQjENq2jNh444UO4COPpE0abM79hHn/YRXXhAdmRkzXZp6LqDbkMu9zxzP+C2Y0uhhmEfWXDsQekSIYSQNaFQjN7UeVdOp0QyEI9VVl30woKE5Y+O5h3LvSgUJbQf9z09IzKA7ZMiD6hUzPXHx2AfIOE5eVIcRSYnRQliS4mCAXneTIDDTrMlz5ZYVNod0M31UdZjgKvOrh1St3JZnltTMD9fMJ/Ls/NSRhse3IePiVQCMxx84o1/J1Yjm5S3PbSY6yROCA4ou7Gx5ToVeAeLhN1dZxCU1LgRDZ39Q68F7zkoxfEq10uu44aXVGcxZ74LjqTc3xU1OHlsqQ6CUp3DILm5FCQ3j52UUy4dNvtgx1gKtlvsTY+CnOmbR2d608+cNK/BR2dk3Z3gzFOqyrvns8F5Z2bRvKZ3T4hUJ2fJoHSf9qN/+9KpbzoatclhwlhCCCGEkIsCf0AhZ8FQz/ZeSMja87aHFv5TJ10ku5acjc7AyZ/++PiWGzhR3vEQhBBCCCGEkItF21Axdv76IR6p37sFmvktxxxCgK08cNJB7zOUgR9AvBxhAuhuYznyoPtNzCOWpdJyut9k6u6/uFQw7Arm111cerwkPG7EsbFQRga0QQGIKitZkepuUp4OS1D/JDjr6FaIFtZtGOpW9HAyIoQMSMEKM0RJSgVst/CaR53dLMh8IuY12CfVScCNYAncbVAyY1+6eBtD1xxw3lF1cOGx64FSI9Qc4j0UY4XtkNcWtC8EN7IyzIf+0JJW2YsSkmnA/UjDNmFbClBe3Np3DqQ6WM8qCjMJIYSsBSiZkZu2+7tzPi+ygmTS3C6VkudMAVx6/D6570ej8oxrWTKZ4SGRzqCrTrvl/j5sy/CrNXTYkXXHQYpzelqcQUZHTIePTEbqNjUlsoKZGVm3WBTphS0ZisWk7k8c2dabHklLu4eGpA/rDalfOGQ+l2MRea61oH3RmDwDl7Jm/QKB1q86Gr+J+KVvzP9KuSb9MTqA/KYJ7n+633fWdb2wMxlo7qeZKsO7FEqK7PqVwc3GS0aDZC0nnHQ87Fi2HMyygPVbzX7caFjOinXoN5TqlOFd9uqpMUcJ/370TG/6EpAUHV4U6dwV4IpTb5h9hw6zQzFpdwz6czYjZYxYMqD/OGbubzQaftlnX7Znyw6cKEaeEEIIIYQQQsjZueume6fPusIGxzDaH+cpQLywBk7+yWPxlkGv4S+U0Oo6/AQZgSG2YtOZVLXANRsAACAASURBVLbQkHnj8IsmJkPti/qwGIHEsEWITAlDJMsSRIUMW4lpMYErjv7NwS+oPlgQ9dt/ZV4D6jYcdB9DivkNR7lRiEJpQhn4423Iqv8o9EUb1o0MkKCIEHIW7MSvfriGMQs2eO1j8liF17x18WqY9BSiNPqiVzC6zZ6/BIlmsVzMUK1DFIqdGwwj2nJQN5htNKQMLW/VCUPvFiEqxoty07E/rS9EEOpWhuk0RMPY92H86SUVgeWwHSGEkDXFTqzafQQEG65F29EmiAZRKol42bG8Q2ZJkliGQ2bZ0ahEE4ZCsr+dOxddt2s2zGdfPC7PzkoF6wzJ1NvwHt0yt8Nok+PH5Vd2jLHxuUTcVKvynIpAPTUfJKs9Jb/mj45IHzQafqvO8gyPROSZegQSxmLZm5V3Hsq+OhYNqc5/y8EIklJZjjGuq/ud31JFWDcO69bgnSEEEQ/lSs1R7ny21JseS7ur2Oz6FSs1xzK17NXFALeS1USc2HhFw6yEV7Jau65DSYlc8erb2YxEbk0Mm9fd5eMSVYI9PxqWayJbkvO5ZEWe3ABRLMGA9H0gIO+W4ZAc78W8ec34fb6f58CJiYfIhhBCCCGEnFeMNvuXkA2AHmgf3eTH6R7HHEI6gyy6/4Vfufnyf2FfmDiHCQkhhBBCCCEXjQMH97+Ivb9+8Pva/7xZ2/bOQ9m0YyYh1sDJX/3EDg6cADpGuKOUBROZorQHVDQ92Q1GsmNQXRBinFBqYydg9ZL11DH5o3LKZCDiSo32SX9kPkpjsF02AY/4K+wPexrXxNGmIdi37lIeluWH5agC6G8rIWQg7KSseBMCqYvKQ5JUlMDgVW0nh8VLOIqpqgEIa+wlVB0X+YqGCaAhCVifrMiW2iRBUuSRVE2bwzBr614Bif4U/mg9CUnLcs52ax7yRCzDCMM6kDBWS1lhoHAvNUoS6qy53P8IIYQ8LfbYG3tJdfqABK3lSsi6ZcO7MDwDIxF5RkQhYWo47JQ9LGUlGWUo1ILtZN2SYe6vVBapQTAo0owmJGJNpkRKkEqakoxpSAwbAxlNMiHPwMUMJMU8MmHuIyD1mZiQJJflikgXhoeljIVFeU4GdHPbeEL6pViS5/munZne9NETo+oPf/4zv6w2Lw+vtmXVhvS5u4hGqYZljIFSnYWsyMpG03HHNgqkKij38ZLquDE25F4uvqI04CMy6CI18mJuSeo/7rGflcgX5dxHuY4NSnWOzcj5d8nksGPdM9ifCSlrLCX9hTKmPduG1HK8ZFUHj850/07FI6+45xV7OXCyDEaeEEIIIYQQsr7Yw+NBLhC72dEEsQZOPs9OccLBE0IIIYQQQtYXlO2Q8847vpX5WfYyQThwcnZ0jOTOgXFDGULOJyEkPhR0lhf0nV2e06GBGhZrftAj1HuxJusGQeNiFxGHNLcoezH6JDfyj5zlBlRCX26Q3KBwBsuLWPseC7nXcwbcNNDUw273ErgQJaHOWQ93IkLIYBiWTEZDqU7/Bd2b1NDdpgIaP/uGgmWgo00RwqVRlmNtZ5ypuO7DgHuhAjmMFjDXMYoS0qzhujG4mYxDWKcdajoHN2q86eENHOqvVVvONiMRWBf7ANuSNcOotVGQKGEZ0yVFCDkXKN0lawS40USjq3Bis0CpTrFo3uNDIXk+DaWdLj6q63QjYf6JuLk/lBeVS+JkslSQZ1kkKutMT5tyhPHxXG+eAU+XPmeehjyr9u2d7/7NF+SZ9BS46iRi0v5aTV7AG00po2lNhyPS1nJJPnKaLalzKr76/txozOdKf2U7uCiQ3KiutMn5jTKScspNllOvN6zt5Rzxkuq4Oe/EXRx/ng41kBotgHvPjrGUo9RyRc7PKHzcoVFqoSTXjJebjlv7ArqHJNyiAq6QblKdDkuW+00EnHJG4Zh89+R8b3rfqLN9mC0C62NLinw+7cfuecXehxwbkh7Oq4IQQgghhBByMXkhe3994Pe3ZzZr2wxDrTwaQrYEnYGTTzx/ggMnK8DBE0IIIYQQQghxwa+3v+Kcu/H5rw9Oj/F4E8WBk4HQMX/3aFhikrxGVcogv4lashZU5MQ9IpLGVpCnVDCOCFZtQ1i6rpkL0K2mCDuHSDOVgJBzzQqLRakOgnPDULjd1jpUrQ31xCTNdRdZEkp1sAwM0s1BpekTRshg9K7WGOgJaxIiqSCa0lgEdxiQqqicNR8lMvMixelz8tGd9xBtGPZdB2kMOPNoASjDKkJbAEccTbbT8EYGEh4jb0lntkE9Z8GNB2SEChU6dpXxhhWFm9MiuCuMSQi0qqOsyEXyA6GtKuxx4yeEnBXDxQ2QkHOhUpEHnu2ms7CY7M2LRlGOIM+4uTkJ7U+nzWfKwoJILPx+ebaMjoijTTgkz9SZM+Yb7OTkUm9e25BnTjot+ysURM7TaJrr5HIY/ADv7z65Plog4WlYEp5MRrYbGS45lnco1+QZnYg63YTaHk5Ac9AHut6+37HhJiCdiL5neSvcpDqDUqiY50ZsFfIbW6pzPgmCPMVNqoOgVAcJ6lJPfQCXnkpNrrt0IuJYvpCT97hoUPbdhvQZPtif7dKDbj3Zglxfz5o6+3jYXKbQmz6dN6+Z0Wj4ZZ992R4OnKwSRp4QQgghhBBCiDs/cJ278Xk7j/fWxho4+aet3g+DwMETQgghhBBCCHHhg6+477vOuYRsbDhwcm7oEQ/HmwrKUEBokgX9SSRibluAdVG+gpHxaOJQt8JUR0FGE8E0xhDBVQAXCp9LVVHC4/dw4bEdbdCBJ4Pt0N3rEbKmdWh/0COcDeU3tpSoBpHuOoQeoqQIuoUQMij2NT0LMhtUkCQkBFJLQyhmGaQ99qVZqMN2cDMJu4dwqpwV/ouWZXB/0HJQ3piEKauKtW+QA2lRqLTbjQ6cfIxTEpqswQ3QCECoc8tFJ4i3LpTqoCzpDMiAUI5kOwQtujsL9fUBIYSQC44t1UFSKbmnB/SmY7la5nRjg/KbxYw4sczOpV3XSaXMZ0MVpENFcK7ZNpHtTefz8jxsW1KcbF4kCPsume1NLyyI7CiVlPYtZWPdv1M7M715J8FtJ5kQ+U0EHIB8fnk2lsrmsx3lTBo4Fo0Ob34XOTsVgc/jvcN2ikFpTQkcYWLwfrSQFVembSNyzpwLKENxk7oMisen7kAk4+Gzrl4FyXg4JP2F9UeXnmbL/EgcAfkN1vPMoshrsD8XLZnP/8/eeYBJdlV3/t7Kuarz9ESJYGzWC6NB6p4sBrAwIKEZgsELtsFhHYA1iBEiySCCCRbCa7DNfvYaDE4LBo2QSCYIpNFAYzMzmGQQChN7OlfOVXe/qvdunX/1ezXdPdM9XeH8vq81Ty/c9N6979W9538ORj1K5SjdLMiENg5S//nhaSMKz6aY0XecDseef/qVLccsFWGWhL94GYZhGIZhGIZheoQ3fC9+Dd/r3qQ2cfK3+zfwxMklsvZeehiGYRiGYRgb2GEswzDrgFKHuNl7D544uXxcGK0mBVKWMEhqSiA/2egnY5W4KakJg8V52Ub2spiZgnFdHjQrHolyH7rOLmgEEi/QdV64Dp0ll03T/hJ8o6BUJ+S0S3lRBCCTedAfuaF+QUhDmnZX1SYv+nQ8gPVjT/sMc+louUgfdPgMjBrYvXKw3w/zxrpP4z6MJJMn89+mQahgXhcFb/IplMPAwAiRdUTELCtOXScx7hlQxkHLSK9VdB+JAyrKgHR7YEScPjA/BRNchbKjAqQXMfKUKI9qOs5GjAzDMKuKgheOtP9WTCSDje1ohGQmxaLxnkmnSTLQ30+RcjDCDspWPKbEJQ8Ragb6ST6A6DyMNIz3JMpsBlrIXlDuo+s4NW0fASWfpxflZpDonD4zUP/3sVMUWSQYIKnsXJzaRUGUHqeL3ltej/FuTCbpHT40RNITjNjTjUiH3G/360fBbx+7SDjBFlLmwVjIsm855OAbxG+m3Uqqg7KXcPDikXwKEDHQrh6tKMGPXrd7+c8ASnUQjKYzGA1YjiMLSTq3lfRpwCaNLcMkp0tnqY0yOeoTT900IJSUz/jf1/YdtyTArAj+4mUYhmEYhmEYhukdrud73TvwxMnq0TRNhr5Qk2CFgk5N+2DpNeayzlmitUYcViZj4MxQW33ArqYFYrQ2KdtPtjcYBUuYScivAIvFOjz2ADg1RAuSLGQy5LXOJ6HvRbQ2QQuSMlqQmNsRm/aplzNHeXsgjQHLmQzDXJRiVXdi6LAtLkCv1dg1TasKMQuDBg5OaGERhFUIbckBqxsCrdVCMLyig1adtp01iqgPCrQ9D+fopDEPHLQllBOtTPT4hunGqa4KLHUk1huSUyljNUQO0UqPmqayyRbWewzDMMwl0sLaBEFrk3iCVv5jUcOCor/f3qpRwUuwCBYWiYRhldjXl7VcIxZZlgwOkiVLNmtc5/XS+8TpoO0CWLIsLNDKeTBolM/jpffoI4+NNLbReez5yb7G9kC/Ub65ObIwKRSoHmht8pQnTza2Uyk6P5Mx3rsVB1jUJ8jioVTsbsuTVsyBs1Y7Swm0juiLWI+vlEKJ7r22PClX6APE5aT7g9Ym6KBWW70UwGmrw2n9PbccVmJtIsDSIxSwt4Sxa8NWYHvaaxfImmQW7sO2EbI8wXJoh8BSyh0ffkbsRItsmRXClicMwzAMwzAMwzAM00XwxMnqYy/QYhiGYRiGYdYY9nvGMAzDrD48cbI2uNBKuwgBpof89mbYuYq9Y1dNAUzm0dFsHD4QIqYzWhcYIqXBRCsDTmDDbmseKZDZhEEaM2ojuakxb5r2t3LO2g/OcTNQP501Wn4lQM6E2dk5x0W5DzYVSo1yLcrEMMwy0OPGIDhABcewKk8mnBJlNCh30Z1zCNLATr8Acp6sjYQHTH6bJD7g2KxJ7mPmrWAAkWmQ/rghDSyzPgeHGpTnQPkVtIHU0iYckGGsl5gGWqvC0CSjxgEFUiMJ46ZYKAqGYRhm/dBSnWUB43sBnLJu2jRvubqVVOfMGRKbb9kyV/9Xy3dqnD3X39jeunW2sT0wSO+48+cMuQE6anWABLVUIklrJkvSn1jMeC/nilT2oX6SMcQT1m/yel3mSBahHcamc5Tu0ADJoNzuVhrg7mYpmclqSHUQO+ewKNXBn0nlMt0TOwe13lZOW20kPsshDhImLCc61W0l19Gcn6U+0xeiNPJFQ7LWqj3tn2Ahgn5P078X4ZoPPyN2svVh5lKxn21gGIZhGIZhGIZhGKaTuOauHTxxslbw5AnDMAzDMAzDMAzDdDY8cbLGuDBIBQZjyINJEka8SYFsRYd498EUDFrDbw7Yz81o+UyqYu9LOAyWSDnIPG+eHwEpT8LmeI1gU6Qbq/FTCNIAC/cmKY7HlOJgdBy05keDviSUQ0fZQakOynNAodRUP4ZhVobKOwpSlr2iCrIRiKojgxDFpozhY2BTS3sWICoBSOskjlMo7dHXgTRIOVAOA4MFSnvSRj4SJT4YbcfdpBOk7Zh5DmojUS44TfIiGYb0tPQHpDpN0+Zg5apgPJIDYEqbKph1gmgGMKZhoB+GYRjm8lmIk7ygL7a0JCeXo/dTLm+8AxwOGqejEZK1jIzELdcLiEaTTtOH+OjoQmO7UqGXx+CgtUwosUDZSz5P6c0vUMSbITMNt5veo8NDqcY2RrzxQHrzpvxm4waSRCzMk/xhZJj2p9K0fxTOP33OiN4TC9O7M5+jd6fL1d2ynRRIizGKjY4eI5YhSZmap3s10h9ubOfyxneOjp6zXPTzg58ruJ3J0zdRzG2V+xQg+qHXQx830ZC9NGYp7CRF9TLZuGpo1Z4bByOWc8UltM0y4YmTK4C9OIxhGIZhGIZZW9jvGcMwDHP58MTJFcLeNIRhGIZhVkDq5L4/4PZimOWTPLl/KzdXe6Cqhf/q9TZgGKZj4YmTK4grghETYAUkCRbsuC6CkWIKprTHA+ZLJUgD5S7DYMKud6NVe6pE1zlA7zJsE0EnW1l6pQYj6zjM8k1DFJ/NUI98U1gJS1Ii5qWdaGnvh3qXbVaPclVsT9oegTplWbbDMJdO0JsXQbdXxCGyDWrr8hj+C6PYgLzG7IJNIkLs6EGM0kPXqYQpv4F9sg80h2hrWoT0UqCVXJRWnRiZckoc/7SsKAD6yqT9dSIO+7UkqCmiD0p4cNCDVpiDKEO6/BghyI+RgCA/hmGWhRTq+dxS7UL7fYsF/AXLvovh9dL5fn/eciZKbpxOy+E64bARbaZQsD+hXMb98G1ccJv/0jvQ66N3ztwcSZDCEZJeaHkRfnsHg1T2Rx4baWz3xUh2VCo5zfJQnTCiz8OPbGhsu530HRAKUxt5zP2JNMmdBmIUbcf2B0EXEQ56vy+EePriGtlJdfIFupc+iGgTCvgs54oVSlK0xKfVdXMJuu8DS0QCcjqtvxlruMGnBPw0Ezbqm6b8kFZ5Z3NG+VGqMxun52gwFrRcg+WoQAQht9u+35VAdp5I5xanyxMnVxj7p4xhGIZhVoR8MrcXwzAMw3QE/IO78+GJk3WAJ08YhulcSpL9NrUJSogtvd4GDLMSlJDP4gZrG2zWoBmmq/km396OhidO1glXAszJAy57GYoDzM+LYO+k1TUYmQcJgSQII8+EzP+ZAtN4F+QRgXJMwzk6lwAkhnIfjMLjB8snvVdV6TjmPejBOSSIimO2AaqEQO3TFGEHg/vMmhGJBqH+cy3aKObm9zXDXCrlhPC4AxWhQAoj+0E6g7Id7LwoyzH7KcpvcABBSY3ECDO6f7eKNJMDmQzYhipzQJE47KA8Zx4kMFiXsMNaHpQJobmnF+qty4F1BmtwFaU0ZLlFew2Y5qoJuDDVLA2S0rFdMAyzbKSU4XaUi/QiSlVn2q3aXi/q5zH8iP0zg5F1dNQcLcMRdUkDRpyj9OYXKEpKf78RjaZQpHWJYpGkFLOzdG4wBJFPonkzX4pOMjgA0Xj6qGznJ/vhHCO/6eloY18gAJHjoH94PfROnTcj6zzxCRQ9Ryl6Z6HEByPoeOHdGAomzfqTHCOZIhlKt3+d37Uj9olbjsc/bjlgA0p1kKCNzGY5YFQclOrgfk0ruYwd6Rw9k34vpVsuUbq5EjwDPuP7B+vnAulPNGQvS0ICfmsbuFrIhxD9WehoIdWZWaD+M9RHsrdoyF9ThT+DJ07WD7Y8YRiGYS4bKR2tppEYhrFBSufV1r3MeqBU9QI3PMMw7U5t4uQvrus/zjdq/WiaHEPfpeCbpsn5KhpQDJmrpTN5OnnAi1YjYJkB/oe04YgXLEhiLvs53ihYZnjNabq5or3j12ILaxk9cZ0u25czXaH9FbBO6TdXlrNle+sctKZZgDLpYsDEvXBDO6MjXbRqGRYMw6wEmZOu2vKQjMLMfwW9OmMnBOsPsFjTFicqAdYrMBhKtMCAvtuYekbP1wWw3MjStoKOLnU5wIGZROs3KLNaoFUUOWQMok3WJpgfOm0NQL21xUkE2gic50pYhWk6Jwf7p8xVPBxWsY3yFSEd3qcIhmGWDfcZZrmUwFGr203vqjw4aPV56X2BFid2LCTIiaW2NqljWqSglQc6gd20aZ5OVdb1Vx84ic3m6MM/kSCLFBdYwJRKxrtqM6Q7M0tWKJieAmuZJz1xqv5vOk1WCecvRBrb0QhZr2zePNfYfvQx+tKm3zOQ7tXTje2fPUrOarsV/XtF2v8EWzO8HntLFrv9Szl4FfXnyPheibWwFPGCdYe9+1Yi0iKNVsRTxvdRLEzPYizsb3G2lVbOZb1ua1vUpDp/cV0/W5ysM9aRj1k3JveO38GtzzDLY3Lv+FNUlnXqDMMwzOUhhfo6NyHTind97Xk3tjjU6Zzim94xsI+TNoEnT9qIihAv7PU2YJjlUhHiTdxY7YNNtHaGYS5Crc/wX3v8MczFUEo+5yKHOxletO0MeOKkjXA5YOE2CdKTMJi4o0U5OnY9lTVM7zb7wfEUpBGCNFAS5DPtrnJgOt7Kd6IXbLRSZiIhW0smIabzWH7ar+U1fSDVQXE+Wr6jc6p0RadF12XBl9EAOIQVYEkfNDNMgan+MFQKZUejkMZMUf2ipVIMw7Rif+qcQ/Q/sdwsz0EnsQkyYxYgd5Ho7NTsgnLQXg6jUiBP2QSOy7Tz1CIObjAmBMhMVIJER5jmpU3SoaS9k1gJaTSGJnv/1rUBDvZbNZgqDo5mYzBAYtni1F4KnInr85ukTX2UhvSzARDDMJ2LEuJL7Vb4YonG2GyWxvdYlBxJolSnCS1xaeFcti9GaaD0JRQyJAgSrisU6T3kB/lQMmmV/nihPFNTJKMZHiZpkNtN75aimfajjw819g0MkIzB6wHnniFyAqvJ5amNgn7KO52h9gpC/RT85gn4jXdiOESO0FMZOjcSIulPpeLcYcm8C/jwM2Iff+13Zv/OYyOXWSkVDCjSSl+j27PFuTOmhGUI5CutksoX6HvEY+N0tQjOZ7EX2EmDkBbZtUTLdWbj1KcGY6FWp1vKj1IdBORDPHHSZrgcUqSrSix9l5k1p1RRKxPaMUwPU1FqK0eXbBNGPYKjhjDMSuE+0y5Etj/I8gWmJZWq2NfqGMOsITxx0oawbIdhmI6kUpUevnPtgRxw1ZfoUif3/UGvtwXDLAfuK8wy+DY3ErPWKCm/yI3clvDESZviqgrxaL6inibqMeKpkHEwRR8GU/QcmFpFTckJSnUwgk4GzNJHIWJFwpTfeOBcBSswc2RBJyLw8yhsE5FnumAv/UGTMG1pPgSm5bM5Oo5ynhCUKWfKblCd4wBrrzNZyjsEZVvQZcLroB4og8K2w3IwDHNxaqH1p3NK9ItFUh3UCOIYMweRa0AOo8wOKUGmImBckdgvkzA4ablLDiVAYDqaBo2fF6JxmWOTRGlNpIWMxg3naCkRhu4CSaGIQ9mCGDWnaq2HDwayWTJNRk1kk5TIjLwjMT/QMCqXrBhH5EEhxMcEwzAXRQnxbH7jMxfD4y41Qr+UXfRuyWbJSNnjoXHa5aL3YKlsjOX4mskXSMrikPD9CnKYYtF4d/h8lG4gQO/ORDIA+/OW63T0nPrxYAmO00fw9DRFIhkaStX/HRlOQT3sowk9BtKeYMBI2++nPMolejdu3kjRe06fGWhslyrUjk6zDZxRarcChMmMROidevY8RQDqNrxu5ytqP10uVq2FJD0jfZGA5bhYHOXUhuXIWoZaSFjs8HnpXmXN77CAn759VkOKhCTS9LxHISKP3o91ml6gug730X6MHKTL3yKaEE+ctDG1+xTv9UZgGIZhLoN+b7WuJne493MzMszSSOneach2+K89/toS/vHErDl37Yjx78D2gidO2pyasckDvd4I7cTs/vHber0NGGYpZvePH1jiFOYKIv1uYylRuvzc7gyzNNLh3szNxCzBNy9+mLmS3Pq5Q7/bxQ3+vy17mPWAJ046ANfGoxO3n987/naxSHJj9VtskAeTeK1USYPFPFqDx8BMPAHXacO6NOzbDLIenwMi3oDle9w0pcd0K2Bp72sKTEHn9JuWimmQyGwJ2Lt7SdnUD6P4oLQJnTuXwDZyyJQ5zRVoH1raQ/V0IIzG+X6nfNugEB+wFIxhGOo3Sry/pqqrq29q3a0IgxBsKpCZSNTLQceT2iIZZTsY5aZib1MpUsbgpOAyCRHERAjSQHPWhGlmjBauQfifHAx6IB8SpgxSeaDsTpTiQH4JkNz4zHqHQMqDwOCkMPQY1ktrF7GNMG+Hc3XtYxmGYZjHdQsEgvkVNYbbbbwDZmZJbjI0mGhsVyr238A6yk6wRX4+kAl5vfSuKjfSo/dltUrvCJQJxWIkAVFmVKDZOZJrbNs629g+PxlrbF991YylPI8+NtzYdoNs6cy5/sb2E65uqJ+E00nlmJ4x2iaZIgkG1unChXBje7AvKxzOai1c8d9aCtEF3LUj9vpbjsf/uFVNWkl1cnl6Hvw+6zdGGX6ktZLqIPFUrv5/sfDK1mFQrrNWoFQH0ftRqjMQtZcf2UUOYqlO52E/ejLrRq6iwtz6DHNxqko8o3FC1VG+6MkMwzAM02Ec3n3/43zP2odqxfGyLq8iR5xaP3jipIPgyROGYTqOKhjHVcuOthWs9yKpk/v+b6+3AcNcjNTJ/Xdd5DBzhVHVws+4zZle564dsat6vQ3WCZ446TDqptba+roA5unzIDnBSDkK3ALHtYUcmCGhRVK8RRozpin6AMpvwNQvD5bhAxDqZtIsH0bEScF1ENxHjEDaKR01B6zaJ3PgaRxM+9OQiJYxhaEMC1AnjATkgJonzTSGIEpRFqzhsy2iEPULG3suhmEsaHVJv8chZNYphBfO8MGccAo6Xl8Ls059OnY/jN4TAEUKyFaUOa5IjAIWhkEBovA0yWH0PpAIyjTIbGB/kyTILKeMQmXnIcIOlnMAyqHHbAhjpqDMEssB45Hot0kDZTt+VOrA4Cs9tYg7vyMYhrFHOl/axk5Kew6lKj/opDqXy/QxixF27ECpDqLlMotxu62GnFreUmN4CNKDNColo0wo93E66RlPpUnygGXS0XQGBzKNfY9DVJ1ImNLLZCiNC9NGmRRI5oMQ3UdRciKbJQlIOEwHSmaZoxHKY3qGpCXDQyTDmJu3l610IbWbYwktNBundhuEiDguVysnDwYVkO2gxAcj4XjBB4KW6ywnuk8R5Nce18VtAfIFiOBUou1YCymOpgR5LKSoTBhBx25fq/aaS1AaA9F6vXjipAO5+NPGrAvx63d2paaSYVaDyf3jv4fJVOedLWZFmPVAOpz93PAM0xp2FtteSCG+1uttwCyP2+45+Jtd3lRsfXLl4ImTDqU+9Rc3LSHc4NQwBNYWCXCC6AarD5c544tOT4tgvYKWJZPo+NDcdNr7bxRJcOwah+0+s0wZyCPgxutoOwcWMnrRdxAcRmahTmEX1hWvM7b74ToIAS+giZrKqeuNviNTkC7G3S8rq+WMQ4hXD7znHQAAIABJREFUCiG62as3w1wyqirerxcZZmuWEI87xIYtYEkBCUsMoJ+BFTV0HputWi8E56sKxkV0OivNMU2FYVA4T6sKcgOtdskUrWzpEjVZrIAlnALvYXIjpaEuGI7UxAVKS4Zh1SdkYylSY8q8DixyJFjWKKxTBlYxy9Be2jpvGJy4acuaTTx3xTBM5xLe/uDH2rXwxaIxvnrAUWs6Q+NwLErWEQtxWvnuixn7laLxPZ+nd4Tfb+8QNpUyVsl9frJULBToHTe/QG75+vtSVKasYRE5t0Cr7Js2zlPC0t7Syuc1PtzPztCc+1ZwGFssuS3nirq1gpFPIEDtEotSeWbnNzS2w+G5xvbPfk779Ut/ZJgsYTxuatt8nuq9cVRH85UvF0J80lKRLqEWtviW4/Ga75NtWCO0nkDcS1h8eNHCxGPvV35yLtnYHh2I1P+NBskiBK1GfF5KYylrE3RWi9fhtqYK30wSvvmwfmhZkkxT/4nYWK+0ai/T2kTwxElnU38q3A6Z6/WGaCeqzSIEhmGAkhJs2dBGODZ5C4tLkzq57w96uU0YphWpk/sPtTjEMHZ822Yfs26o53V727PvkzWHJ046nPrkicshft7rDcEwDMOsHDXgLloukq63WfYxDFPT7HyAW4FZAQ9wYzHrwB3c6GsCT5x0AbLmbGlq3/jt+ap4F1YHDewCYBk+l7ea3vnB4SpsCrRKB6VNYxulLlsCDsvxGtPgPTZmymE8YFKFx1FShBb42ip9FqRDISgc+kAcASev82b5AnAuOsH1Qrs4oUxaooPxvLF+KCmag/T6QQfkcYh/GHxg4jcEwzANpvaN/26qLP6m0XfNwWLTTjK7lSMgLZkBozocyFCeEtQmnCCtA1NNdKiKg1PDeTaMKxIHLxg3mpzDBs1ywPiHWr7mc8G8VDuVHQDDtCyZsypIT0bpOhU3z+kn82cJ1zXpJ1vJebSMKQkO+aKGCbjzJSPCjtDTvmbvkZBhepj0fz7H+hHFrCvtPFbdeezAM4UQ9+O+aoXGZoezarlmOczNk/wmEqH3ZLlkvDtQ1jM52dfYHh1dsE09Y0qJUJaeBiex/gBKbuj9MztnyBvcbqqH00XbLthOJend5/NbHdsWC/SOD4Yov0CAjCPnZkl6ocxfCqUitee2bSQZiifo3DPnYo3t4f707/3Zi+7uet+EtxyPX5GxCp2yLiUDakfiKaP/aGe3F4EnTrqE+lM68uDEu3u9IdqNihKv6PU2YJjFFJX4S8tOhmEYhulCDu++/5t8X9uLXMHdE9Zjd+2I8QLI6sETJ10ER9tpX3jQYphFVJTwWHbWV5DcF4/XyFxxUif3fZxbnWEI7hPth6qWHu71NmBWRrHcUxHl3mDZw6wUnjjpMhq23TW5TQns7apgCXgOpDpbg2QWd9aMEDEK5ulnIWoEylDmQZ6i5Tcxr1UiI+qW47SNFlwLZhoQCKPpeFXZS2p01BuU1mAkHDQzxEg+jSg8MI0RhTqh7CjigVjzpnbJ7aB986ANSoG1IUb6QSv+dFGJ0t7xmzYfnbhXMAxjdkXVFDUrYUpcMnGvM7zZ7EBnKb6+GASJC0hOmjSFZhQehdbPCuQrMEA0RfIZMtPOgr9UNwxIIRqEUPqjskbaEnR9TRKZCAxeGDUnZspuPHAczF2bpDooNdLDGBrg4sCJkdBgjGzar9PD9py2+IltQjq8rxJCvNpygGF6FLNPMG2EEtUfdMT9UDQ2o1RHR+MRiyLyLMVAP0TKSTcigAifzxjXMcpNLEaynvPnad5gI0h4HA6jTH6I0hMK2ceiOHVqkKpl1qtYoveX0wG/I/opjQ0bSJ77+OkBo2wRkhflICqQA76/s1lac/F6IHKLz2ivqWmSMD32+FBjGyP5bN1MdU0klpRndA137Yj9+S3H468vFMqN6Dtem2g1iymVjO8ct5u+V4rwvYKRchZSFKUQI9qsFakMPaPhoPFNk8mRzCvot12ja0mlelF1E0+cdCFsedLGZMvqc73eBgyjOb93/GyrxsiccVr2MWuPjLCBHMMwnYsU4p/59jEr5Y2fe9HRXmk0jr5zyfDESZfSmDyRUqR6rfLtTrEqlp7eZZgeoaTUplY1rdgvcDFrjNwRrhiOdu3/Uif3fZjvAcMIkTy57/ZW/YT/1u8vvP3Bf+2Ax/P7lj3MulIqOff00h34y12DvFKyMnjipItp/DgvK/GtXEXcqP9/g5eMUlB+kixZzZMWQG9SBvOlGbDqBrWLKJoW8SGcGoCF4wJ4L3CDGXnRjIaRBZN0lNEgKIc5b0qJ+jz2MqEBkA/Fm+RF5j6QLaFjBQzekYJgnSHT4qtSBbN8uC4GEh+U/uDauZY0Te4ff/7oAxNftFSQYXqMXEX3UTL93Bo0xqlkTRanu1vYbdswKM+TKNEx5TOoWBEgT2z2PgT/owsEkhvRD+aeU2ROjHIeGTXKpxbIJFjiWFiBwoEMUvjNNOIwsGLUoCxtN9VFy3kwog9IfyTKgDJQJohepiP5yFnKW9ZkRFu8NY1URLRAOjyvZ800w9RkBO63cDMwl8gRIdXT7S5diVQHSaWCjf8Lh0nqOj0drf8r4bU2NEhyGYzCk897YX+h6foakSitaiSTJHUZHKT8gkHjnGKRXoIoI0IZkMtFkhu/16h3OkPv3BDIbDC6T6VM77gEROzxeI30nCCDCocpv0Lefv1y65ZZy75ewOt19dU9KBTpPng99m2Ecp1Ge7eIpGMn1Wn6XrP/mbckCn6PokxaS3WQVlIdHUlH1GVH9I2FZR6IBprOdTocu/9m3whPnHQxjSd5y9GJm3q9MdqRbEkc6fU2YJjH94xP9XwjtCM+b2SpNWOGYephUf12/YP/1vevQ+DvwDbkts8f/EYv1feuHbF4zaLCcoBpYE6cfJtbpLuxnwZk2oayUvbL6AzTQ+Qranip2lYKzot7MGXWBY4wwvQ6LF9rU1TlXCcU8/Du+3kVuw0plxwHeq3ONSmKFOI6ywGGJ056iCZ7qxBIXdIQdaYK8/NpiBSjo964wDprwEHzMSiNCbkp7URRR82hfZCdGPVTGmVlNbsqwckJyGNTgK7DqD8xU66DZmDb4FysK0YA0tF9+mBfGiRDaO1ut30B5AUjPsovX6H0/E5KD+VKFbOwgx4p5q7f+caBb33nQ4JhepCze8dvRHVeDjqyjo5V66OVWbfHOVwWwtsUgsu2wRSMR9KU4qg8dMAkDXQSJDwKBkCpxwXMIw76vSjNeyoM72XKdTA6DqqBVNwmjxp5Mw3UC8IYKvp8lMYkea+Xps2rSoAkxw9p4OCLukSMSKRD9WDeuWVGh3Z4OOoO09sY8jWmzVDV8kS335Nsht4LgSBJblCqg1Srxvtzw/CC5ViNSgWip0BEnkrFuG54mCQ+iSRJg4aHaP/UVIzKZ0bCyebs1wmLRXqfV6q0PTBgvOPOnieZ0IYNVObZOVKT6rItTkNHMPK46V2GEp5QiN7niQRJPWZmDcmG21URb7734DXvv+nICUvBu5iP7hz8j1uOx2sWKE31Xg2pzVLXY2SbXJ7uTyhgleLMg+RGS2uM60pwjvEcbRqi56gM0ulYmORmxRL8ALZyDUt1ege2POkElLqz15uA6V0yZXXPciqf/7mrxeuWWRO2uo2vpeX8MUwvs9x+wn9X9k862B8Tc1nkc65v9mILms5Q+ywHepM+dg7bWzRZnlSUeLRYUU+obfvhd8g8OFFFB65mGG9RbeFbcQhWTdHP7Aa/sf9cDqw44EJc3CzCgm3MLFMGzs1A3PBzWdoe9tFJk6bDV3QuOwNWIeBnUfRDmfUZsEjd5NQ1Cs6PCrj6rKxpNbUhJDICq+RYJs1Zs40GLEcYpjcoVYQDXK82WZjNmwNLRI9XzrrXajoZNiUMLAo6ve6ZLR3GoiPWPlgd09YkMNaIODjvK1ut5hplFIsGRRzo0Olsrmw9By1F0KnrArWSDMPQbq6iSPTQjdPmAdifgfzw7aAtCsGiTz4pUFuyCYhlkDq5/+Hw9geevJxzGaabSJ7c930p7VfVmfUlsv2B051yC9LpwHGl5A5Rd9xJCtUSWH9o56uIAwI+oAUGWljMzYUb27FY1pJGLkfWK4kEbQ8NUZDOYtEoRxmcs0YjZN2CFjAjI3FLHjOztPLv99F7NBSi8qTSZMmincfGIvTee/iRkcb2k59IbtLmF6h+0TCd7/MVm/6t8dhp+tr2ucExqpe2i/DurlRlS4fp3Y7pA0XecjxebxA7axG0FHHACXbnLocyOG21szZB0NoE8fuoz2zyRS3HWxgsC4/b6hz3rh0xXrTrQZosT9xS/FOvN0i78vCusd507830NKf2jH2n19ugXZEbffbu6e2QrifZ7GWY7u8n0v00y06GWfFzpD5l2cm0Bbfefeive/lOmBMIvRZO+/s8cdK7NE2ebDw6cXuvN0i7ki2z8QnTe6SKYnwllVYVZ9Gyk1kTlHRYl2EuQurkXnaayfQU/My3MyrfSaV9x6988c8tO5m2IF9w/UGv34m7dsS2CyEOWQ50J68268v0KFIt0qP/ZGysvgMFJBvALP08SG20pXwALFKb5Clgqr7Zb5W4XMjTuSiHCcN6ZrlKaXjMJNBJ7GYw4T8Dsp0tsP+UuR+lQU6YNoqBLicH9loh0yQ+ASZ6WbBqRyt4qEpDirMApvgeMK+PQxuVID88J2Bu492JusUnBx6Y+C3BMD3A5L7x5+bK6su1mkKXb3JsnTOlMVpZM/TLFRWKkrCvyTEs2mKCpEaZ10ocIAotZDSI6TxWoTwHnctifih3iZkDJhxXKfTETYOTRHmRnZ0rOmgLQ94ZqzPXJukQaiPxHYBSIpTzFM30wPGt/M2NljyWIvz0b9hUgmG6k9T3n9XCAJxZb1S1eHfkmqMv6qQbceexA2vyPKFkJmQ6lU0myVFmNErSGZS4oEQnnfGb15GUYvPG+cb23AKpWxR817s9xrtvYYEkFk+4etpSxsX8/NERMw+SAKEsaW6OJD4jI+Sstlym91oiYZQ5FC7CdVhvml9DmVPKrKMTAj44nGr8zw7e/V1LQXuQW47HazfFoofJF+g7x+dd0drLkmRyxj10wY87r2d186g9MnftiMUse5megx3GdhAVJX6z19uA6R30xMlKmPmhk3+cXwm2esyZm5X9pU7ue2n3Nw7D1H2d7L6UPsJ/V+hPOjgCErNqJFP+h7g1DcwJhm6LsPdqnjhhNJbJk4Bb/ohbp32Z2z/+zF5vA6b7mdw7/hS+ze2L42kBq2fC5SBdn+71tmN6AymdX+db3b50krNYYFmR55grT6UiXLceObSZm97grh2xT5g+Qb5lOdhZfKtWj1p9OrwezCpisWnyOcRB5ZYPQ5jrJgv2IJjM95tm7iUw+w4FaT5mGkzVHwczcmnG5AmCSX2qhEIhq1l+jbS5idbraYg8MQLyIoxcEzPLiTNFmBsGmIDsxAXThN0yw2SCUXpQBnTBrHcYZAAFOBdlSU4JkUNAzlMw2xQDh/QZuqX7FwU1YpiuI15UP0E5YAE8mWAgGR0VLF1uIbPBDp2BSDggr5Fa7ocG0cPgxT0B10F0LN0LMYoP9kzZJMUBSY0eDPJQZpTfoOTGA/lpSQ1IIFGK1CTVwfT0mO2HcjZJiuC6Pmg7HLT0+GzuUv1+sm1eIcmT+7d26A8XhlkWtWdcSqePW4tZZWp+T25ulSTKaLSExestWc6rkcnQED40mLAc9/sLln01zpyFaDQ+esfpNHJZenEXi/Q+GRpINrbx9XPufH/931ZSHYyU099H0X3cLuNl5HTSe8rnozKjDAjbIJ2meheKRnvFHFQPjE7kAllOPEHXud1GnqMbFhr7pKwbJXyfg2M2c9eOWH3B95bj8cd9Xtc2ywm1ReEEycJaRcixI5Gh+x0NXjzyzkqYiWeElHLqkwc2bli1RJmuwjIvMPLgxM/5Frc3C9fv3NfrbcB0N2V16ROEpaSLnca2MVI6ftrrbcB0N/yMtzmq/EgnFvvw7vu/adnJtA2qKvr5bthz147YVaYlSrtbT93zqWdtkjxxwlwMy+QJ0xE8wLeJ6VZ+MjZWvZyqJf7L2cLDK9MeSF9tZZ5vBtONGM+2ZKuTNkYJ9clebwNmbbj1yKE5btrW3LUjdtCcRGk3nyivNuU5By1HGGYRFtmOqFueq0SipBqekr2gSSmCROd01tge8kJEHLAMH4D9JUXbZTMNVOpgZB6MsFOq0klXh4zEMSLODIS5wZkglBJFTZ1PFGQ0CTDzR/mNH/xN6khEgRbRfzAPF2iJlNkGWZAMQOAdEYM8mqREkF7etCIcgcgbpyGaUG7v+As2Hp34gmCYLiPoNjoTmp44BfZ56gcbzahaKCdMTQkxqE+PgxEKJgiSoMZ+tCVegOsgAo3CaDRm35R5iIiDchmvvUxGaukLRtXBW4g6Sbyuzyi0WgAz7D6qiJyHMkN7NKQ/WCeUA4GkqOkclD81Bmsl5P5IWQhl++5YLlLI2sr8JUt/GKZdMZ5tDrLTzkS2H31XBxf/lBDCVv5QKtGwrBrf3PayHZS7LMXUFAVOGejPNLZRGqMZHSUpC0bxQWNSh4PydruMdwtKjubmQo1tj7dFOc0ulkpb5TSibv1FfTCVpsg7c1DmSMiIpnN+iiIB9feROy+Hg97FoxtI2jQ1ZUiJslmaIy2XG+9Utj5ZBqYPkbofkVuOi5rz5qaw7pksSXJcbnquvW56TuykOtML6ca2B66LhWzns99w144YhwBnVoyt5YnHKW+z7GTaikRR3cd3hOk2zuwdvyyrE+YKcLX1g3nFyJr1SS0aCcN0D3WrE8lWJ8ya8k5u3vbmf37q17OdXP4rTW0Cw7T6qM2wXS2E+Ps1KkIt3at1XjxxwlwqtquHow9M/J/Ja6/7mOUA01ac3Tv+3s1HJ97Gd4XpBib3jT9XXYavE6SUdRXdgTLLd9YCh7R9b6wUKZ0PsfNrppuQ0nGKb2h7o1RlspPLf3j3/Z+489iBj1sOMG1DpeLw1yLv/NnBu8/yXVkZd+2IPS6EeJX5V+d//ft8n6qq51SFuEYIUVt0uaqF9dUph5TzUsqHhBTf8zid935szxDLqJhVp+VHsBNkKAsQBQYt0bWJOgZrWAB9Ci4hoxxmwDQZn4dzIxB5R4HJK0ptpk1z9gCYpEfh55GE7/AEWJ8XzIg8p7KULiQr8hCxZxCkRno3SnUw+o8L2gLbZcaMtuMEKRJKclBJgNa9KD2QZvvHi3TCZoiyYTbnW4UQPHnCdAV+h/zynE2ULLEoQtV8HmqrrOdW8kpkHpWe2HBeSJDGNA1ITZFuzES89lFzVMXebFj3UQHRdqSL8lMwhsqiNXINRsppltFQZVWeogDIpGF+LSFSkEjTcQUyG4k6QfO6pjxCYN6dhDxioGdCKaKWRzpWd7YjdXLvH4a3H/1rywGG6TBqz7JYnXlFZk1RXbUwWCjQuN8qQo5mIU5yGJ+Xxn2Un3i9xgeq00nvkJERkqwUi/SO6O8nA4sLF+rRZkQkTC9ojOJz9iypWTZvnm9sR6NGGlg2pehd5XEXbfe73Eb5KmV4r4F7gGCIrsukqcyxCJVPv4IrVUpjbp4sKz1u+wh2WbPN+/qo/i4XtddAX13adIYXB1aHv7iuv6YF+4z5twSxix9mmFXAVrYjjKiWGctOpu2IX7+Tva8zHU/8+p3vW806ZE45LfuYy8dxQ9ReQH+pSNdf8W1hugJ+ljuCDvd3omELpw7g7V+86aW93gYM0420XCYZ8Mg/KCvxqdr2NDhlRSsTPadaRkenVbTuoElX8DkrJhuWGbQvCxYWmEUYSqgXhtESBv0iuiA++0aw0pgzV2FHYXV6MkfnotUL+oN0mOVHq5ENfjo3Dj8jUlB+7fwW/BqJfIWuG4XV8PM5cAILFY94rOlOwWq5hyx5rud5VqbTuVCovlkscrg6B/08BpYnbrBi090jDmPUZtOJbG1waHLwis5ccdpYW5OVaCVOwPjRtA1Om0XWPB+dTIOVigSLFJGiwUKZ44Psg0p5IQ9w/Coxb485GOLAA9dJsEIRbrCAMbdlhFbfFOYxCn5bZ2hVTqGlSr957Wa/u+kmrQKpk3u/Ft5+9DmrmijDXEGSJ/bcLdnqhLly1Pye1KU72lKkFWgp0hdLtzjr4kxO9jWOj4zEG9vpDFmsbNhg7EcLEvSOFY3ZW8Voaxm0mkFLmEyGnII2WcMMG1YtySQ5g0WyWaq3y0nvrLk4lSroN9pu8yhZyFyYjixOqk4kSu/GQbextlwqU5/X9a/x6GPDevPTbH3CMN1HS8uTgQcm/sGyk2lLfnDd5YV2ZZj15Gc7xy7ti24JlPKsrpUEs0Y4n80ty3QyUro4vGVHUH20G2pR83ti2cm0Jbd/+UYO7sAwXUbLyROmcygpJc/sHT/Et4zpNM7uHX9qtqzsl44uE3Xa7+YHYhUZWDspVOrk/pxlJ8N0APzsdhRv6vUGYK4s1ap8ATc5w3QXUl3EBPvc3vHjhYq4JgjWqGdBZuIyZS2gemmyT6vYW8w3nDtOF6xpiUVOYlG2os8Og1bHAdM/OTDRD8DPpnlt0g+F6wfHsOgQNlmiMmkHrq1s7hxQ5lwFJQbG/iloK/Ad2+TwFutdhDS8phSgAvcH1AEiAXV1mCV8+n98t1VRGaYtOb93XAmQrNk5pK6RhucdhoSG42fchzK7J94ArptQD4jzAKZ+UCXIUEWiQ1WQw8gQXahSRoKyDIZfA+DsNQ7XRazXIRL1h+hIFgdX3QZhe2evTbIkTE+3B0qYcFBHp7M4yKCz3VxVOH6tPy8injUMw1p5TXj7UfYbwXQMqZN7/0gI51/yHesMwtu/1TXfSHceO3BECHGz5cAlUCjQB7PXu3yDzdlZkLiYLavgezoSoXnFhQWSywwOkrGpzhvlR8kUnet20/s1HCQHremM3ywDrb1UwWHsyHCqsY0OYcvgYHZ2LmimS5KhYpHe1f39VP4ZyEc7ynWBjCiTpXc/5lEuGdsf+fXP8Pc5w3QJF7U82XR0YodlJ9O2rJX8gWHWgql9499Z+4aVLGlbLSJunzFDs1Z/Dv4RynQYtWd2LfsE/63uX1fxeh4tOodb7z7UVVGeGKaXuejkCdNZ5MoiWJNB8G1jOoGKEuNrXczUWR+PcR1E8sS+hV5vA6YzSJ7YO8m3qpOofrKbanN49/2PW3YybUs+7/p9vjsM0x1cVLZT4/y+8VSpqhrusyFohCiZ5uVRMC0vQ3Jp+B/8BdNnRoiIg609BqbAqDNoRa5lLbiU7IcTIiD3mYHIND5TM4NyoOm8VZ6zOG29F2U2WKcylDMGMiAttSnC8QJsD8C5xRbtnzXbuSmyCMh60P7PD+0/m6+Ka7/372weyLQ1J55xncL+6Df7WBwi7KTheR+AyC9OiKqVMi19Ue4DakARckvRtydp/A9EypEoh3HbaH9QGoNyHoeNHAbGB4VpoIwG89Ohg6bJe7+IQn4wxjTJbxbMcoRBk4g9HaPtYPQeXe0A7MvAgIR1CkJDzpIZteM5EaWeFLxC40qV5TtMW2PIddhSqpMIb3+g676L7jx2oBbiJWo5cBnEE8bnfixKhszzC+HGtscNEeUkvauCQUPiMj1NxfH76Z2Uy9F7q1BAaUy26frFZHMUDQ4lOqMbjAg5p85QJKDBAZL1LCzQdZs305z8wjxFA6qa78ZEmtSooyNU72KR3pleL9U7nTbe4T4ffRs4IaJPJExy4fl5kjbl8q7Ch1/y2TWUvjJM+3D47kPjqiqfXqk6bgoEiheEEfmq0WkCgdznav++ef/XvtZpt23J2HouhzhUqoqvWg4wbcsPx8aKv/zd73r4DjHtyMM7x87xjeksqlds4kRo+Q5PnjBti+KJE6Y9eL0OWcy0P6oqvW+65+A/fPDmI6/k28V0C3d89fk3KSXfqZTcgZOk8QRNYHo8eiK1SUn/h7X/vP+B54jz52kSdHQ08SMh1Kfecv1XP9CuTbSkSfvwtyY6bkao18lXlPv03vE39no7MO1HTVaWLqmNV7JglYyX/Z50GKmT+/JdVSGma+BnswNRle92Y7U4ZHHnUSy4XnHrkUObe70dmM7lLffefMNb77v5sTd//mZV+6tWHZ+vTZysYoX+mxDy/e/71g3qD//x5eo1//Sy4nu+8dzXWM5aR5aU7dR4dNd4paJUfaIFZSsajDpThkgRXofVLF/UrVmMc+bBRB/TQBkNynn0L6AclCHVQhrklCjnMf5VYOM+D7b9m/105Tkw7bf7xRUAGQ0Gr8AIH1ptgNbwTSb8LdZwsb2yZiIRMPfHOmG9QWHQiMJTS+up3+XoO0x78cPrxhoPLvaPgvm8Y98YAXclBexr0DETZnSsiJvOxTHKb44fI2MJIVGS4oZtUz6jPDZSl8XSGZC+NKLthCEtkO0oGGOkH84xtY/KCflhT23hpqVJMqTzAPmNxIbB/MwxS0H0L4zo05Qq1tW8Tj7dL9TTQ+KKo6rfiFzz0LOvfMYMY0/yxJ4jQjpWJcIJc+WIbH/QOnh2CW//0k2NwRylNppsllQigYD9vN/MLElthgYTluNTU3R8ZISOZzKUdiplbGMETPx5MTISb2yfPjPQ2N5iSmpOn+lv7Nu2dRbOHWxsOx30DuvrMyQ6Hg9JZ+ZBktPXR9KZfN7b2MaV8UjYkAolU7RCnkyT0XYVovTEoiQr0g/TfJyiAgmQMHlc9F7O5Ck9LXka7MuKP73xHv4+ZzqG2+45uKNScXytqkTdRCQFUrcB6GupNPW1q6+aaWxPThqWJSh/y2SpL44M07iSzVHaLqdxfiiEka+i7/7AC4/8yXq2nf1X+iL8bvFHlp1M2/NfO8esM10Ms078aIyfx47kaUFrbOUrgXQ8K3Vy30t6vfmZ9iB5cv9Wnjhh2g2nU72Xb0rn8dYvvHC619uAaX+vgsE6AAAgAElEQVT++NMv+eJr/unXVDrj+Z6eOFlvCnnn7a//9IvVGz/3oofXqyjLmjwZfWDi/1h2Mm1PbSH6kV3jSb5TzHrz2J7xH1fXceqkUvWszwRAF6CkdK5XLZQQn7HsZJh1QZ3idu9AVPVH3Vy9O2647+2WnUz7o+TQ7V++6a/5TjHtyGv++dd+8Oq/e6VKpn3Pa9cbVCnLJ7353pvVW++7OfuOr9w4bDlhDVmWbKfG5P7xqqoKeR5Mv7WFdwwiO1SaLMPtZTmNaDRwLhajVXQbnUsZTo6BuT6aCy6AybyWw6CVfK7FT6lma3fjukLFvo2CEPSiUqUy63LkQNcTAvkNRhnCH5QxsnZqRNtxQZlL0F5ZKFMM5Ab6fnpAXuSQ4hNbjk682lIBhrkCnN47/oa5fPUusWgcgGA7QpqPMEalCsM40A8nn8qgtM543t2Qrg+uQ4nftueSaaGKQ2QaXYYQym8oD1Wy7//S7LwK5ECyxblNaSxlrAsywibJkB7TsL+nQbYTgwFprkDb5vlL1aN+Dgw4tQhB6ybZWUQ3m90z7U/q5N68EtLLt6oTkdsi2x843c01vPPYAfvB/SKkUhS5JgzRYZbiwgVafMbv9oFBQzLkcZOMZiFO7w6/j6K3+bx0TjwZtKTlgIh60QiVTZv+14jFDDN+v5+kSBiZ58IFihB09VUkA5KS3u2JJLVBI29408zPU3qRKOVTKjnN+pFsJ+Cn+qWzJNWJhOhd7HYZeaczcDxS2PH+m46csBSEYdaBt3/ppvuUEi+4ME1RojaNGpKayQu0b3goBc8+PeNe6NsoByyXjW/Lcom+MT0g4RkeonX+qSnKZ2Qk2XS9kS4dHxygciQSgdwHbj4CWrq1Y1mWJ8IIy/Mqy06mI0gX1avO7R3/Rb5bzHqgJ06YDmS9JDuLSJ7YO2nZyTBX6NnjiZPOpdsnTkzeYNnDdASZjPs43ylmvbn1yKHb3vbFm2rr7y/o1JuhlPC/6chB9Zb7bv6O5eAqs+zJk6EHJj5p2cl0DMmi+gnfLeZKc+La69rGz0lu3sM+V1aIEsJZXxJc7z8hNiRP7Lmnk9qO6XySJ/bUvns2tEUf4L8V/6lquSe+ew7vvv/PLTuZjuF1//JS/jZh1o3X/OPLiqm05/3dcgcqZTleiwJ0+5dvvN5ycJVYtmxHmFF3UmXVmHCJmlFesrA22eclm7e5PKWNpvRpU38yCubpGHknB2bkGGFGy4AwskYKtCwYpScPZdLJYTANN8ha0B48C2b+hSpFrmnUAyz7yyCjQQmSThrlRRi5p0liAOmhRGnQjLiRh30JMLvHNFDaozdbteHT/50j8DBXhh+MjanaY+iBZ7xQtn8udddFaV0KnneMwoMzvrqfpEAKh/0B+0zYLcXouGF+qDCajg7phUMh6oe8Ttv9yqyLxOg42NExPThHackdDJwyCpKbBJk9ooRH6NMxP8wjDVIkDFOm2xzlh9igEK0LQ4jJsaBSTw201XghpXxpePuD/2o5wDCrTM1ZsVKKfe50MJFrjvbM9867vvY8hdF0qqaUPJ0maUokYo3GczkoBTJPaY1PibKdDETh8IPEpWqmgT9Fhoco8sbsHJrok2n/ufNGdB6M0jEzQ+eOji40tjHiUDqN0YeMcoRC2ca+PETHSSZJATAHEp2YGaWnUqHHa/Pm+cb26dMUISiVpXoHTOlSoUgv3YF+I2+HFLn33XRlJAcMIwynxX84Oxf8K90YsQhI4CASTqFkPK/onsLnsUrfxSJXFBtHoL9Oxur/Opx0QiRE+WFfyuSoz3hcRj7FMvWZvhj1V6HoukSSrhseMsa6TMZz5oMHj2y1FPQyWbbliTCi7txo2cl0FD/giCfMFeDH42Pl9XQQy1w+7TZxIgyfTp9Jnty3zXKAYVaR2jPGEydMJyGleh3fsM6lqoT/tf/8a7PdWj+mvbjtnoOnS0XnX3X7balW5ZbDnzuk3vqFF45YDl4GK7I8qXFqD/341ivHuOqLFg8esNiIgsNHbU2RgVVodDqbKNqXSVu6zMLxEViFnS/iqjZdpxdccTEWLU+QODialWb98LqkjQNbUbe4of+bzRtphMFJLNYVLWcwDTynWNVWNpQGFK2pTFmYANSL5E1WMar5OqdDlJ5w7Ls0vc4wq8j5veNnS0pt0ikqsO1CJ8rwuDcMNvxNz7X9OCBtrNGwN2OfccAYVIs+FXpKSfkGsrIp87A5sKBD1XILh7FovKGt3vrQc7SyO1XIgnVVTkTgOjiuxMXzU9Df0dlrUyNgOfRYh45t7coD1jT1c353yHK8bZCOqyLbH+ToJ8yakDyxx37wYTqJb0aueehAL92xpRzHFgr02ef1Fi3HV3rueXDguhEsPTSZDDlcRWsLdBrp9xsvNDc4mvWBc9kyrDg7JFlraouVZIqMNfDnzEKc8r56G81JnDkzAHkbeabAgasTnNVefdVMY/vRxyiYh9NpvD/7+3KNfWGwXomDI9oLU+S49glXG+WYmyWLHJ+f6l37tHE61H13PPe+mwTDrBE1vyA65UqF+qLLRd+Ffngup2bC5vNOzptz4BQZn+FggJzHFkvUd6fNNBxgoYb9Cy3MyiX6VtV9E/vw2bP9jW2vlz6IsRx9McPyBK3jMhnfoXfe8IUjq9GqK7I8EYZc5JxlJ9NRVKrCfWrPODtgZFad83vHf4oTJ+1G+qdu+1lTpgnnC2PtHdpZVR+37GOYVYAnTrqDXps4MUlY9jAdRaUqb3zHv934Hr5rzGpz+O5D47/zif/Rs++3Utlx9+1fvvE+y4FLYMWTJxuPTmy27GQ6jmJFbTi1Z+wC3zlmtTi9d/y+klK/0P4N6mjviYE2oDrsdrZ7GflHLrPa8DPFdDjP5BvY+VQq8m23Hjn0vl5vB2b1OPy5Fx1cSPjXPApNu1Otyhfc/qWbHrncYq5YtlPjpBlBQ1uz+0ECMwAOY6dyaIpObDCdIMYLKFOh42GwZkcHkumSPpeuQyexXigHOpsMmYvNKBnA/ALgMBElMNriH5eqUe2DchhsR+0IF51VFuHnGjqSDaAjXTCZ95uZ56Gu6CTW77KXBPWZ8iiUMKFkah7M9fu9jpqjzvObj060raUA0xnUJk7SRfWCnPksOtA5M0hnSlX7Z79k9g+c1ahAP2lyHA1p6O6KErmQC2U9lJ5+8p1RJaLbyMRYaQ+zIAGUOC5iZXDg0Nmg/1Z0uBpEDRLUTEtqUDqEOrymwZAGJ5Ux0pDQnxX0c4nX9ZNJpdIOaNFJNuYdgjxyFSEjUoiXkGlzuxO55iG2JmIuG5446SKkeGdk+0N39GLVP/jgs+rPMTpmtGNunuQkA/0pmzOWplCgj3Wv13jPxBMkSYlFyUFtHpxAovPHSNiQAszPk9l+FV5lJTDhD4fJwaTDlNfMzFB+28C0v1ym61CagGb85yejluNRcJrpAUmAx03bZ03nl+gQc36e5EP+AMkH8jlwDjtg1PXCFDjBHSS5j9dDkodTZwZFKFj487te/FkOQ81cFofvPvSBXM79pkrVeM6L0DfcDupsVXC+GvBbpXoR6BvT0zR+YJ+ZB7ncLz6Z1ucfO2U4UQ4GKN1hcPacy5EjZ+T8BaOPagew9TzmKY9tW6nPo/QnnTLGm0iUytbfR+Pc1HTs3J8dvPuSjUFWbHkiDP8kX7XsZDqSshIbz+4dZykWc8noiZNOacFKgn9rX5RD/fZu1NsU/tHLXC78DHUXvTpxYiD/wbKL6UjSGe/rb/nsiz/Md4+5VPTECTdgM9WK3HTrkUNnLQeWySVNnlz10MQNlp1Mx1KbQHl419gc30FmpZzaM/6lTpo40VQcXv6x1ApnLXixEp30lzyxm+8nc0kYz05nPe/8d9G/n/RyT3jTvq//hmUn07HUJlDe9sUXvpnvILNS3nTPwXfzxElrLmcC5ZJkO8IIeVszvKvb/mCEHT+Y6OP+GEbA0JnD1M08SHjQnN8H1uxxqxVR0+wPnpsDK/moacFegH0okYHAFE0RgsIuLYEhsyYfHMeWgyILrQLA/FCOgOveGF3EIa1pJ0vg/RjyDrjtpTguMw0sTwBkUCWI051fFM3E75KzT/z2RBuH2GDaiUd3jc9kK2qwaNP/UW4WhuhSKDHDWMb9HtNzPshe/CCnQxkeouU62J9R4hMDictMHiRrHocYHIsb/2OWWbXyJQvXSQ+MOHqQcbW4DqPpzJE5rjLLB8UUym8v8ZFYbV0+OFel4Vz0UoLjlF3UImh7CeWX+8NV9QTPJU2qtwORa461uBkMY4Un3boPHgOWjrojjB8Oje1ylV62paLxIsH3k8tF7xmPhyQpKIGRZhSNIkTVcUDkGkwDo/AEg0bEmip8m2JEHJTi2DE9E23sDYfIRL9apbJVqvRydDnLsN9hyRtJJkhKkCvS+9ztNOqCMgYFkodkkq7zeii/bN5tOTccpG8DjHYioe0SSb/w+0pfv+vFn32OpZAMY8Otdx/6WD7v+n2MmqP7YxGkcJkMyekGB0kaMwWyHLfbeC4r0E8wKpXfR3noSFSiPlZAJBxT1pcHqZ+W1ohFv6dDIfqxHw4Z48O5cxTZC8cVrF80ShK4ZMoYYwYHkrCPomCVijQ+DPSnP3l4zzd+S6yAS/5Ijrrl0y07mY4mV1aDk/vG83wXmaXQEydLnNbWSIfkH06L6OSJE2H+GE6e3LfNcoBh8Dk5uW8bT5wwXcwhvrndRS7vfvY7/u3Gz/d6OzBL88bPvuhYbeKEm2rZ/OadDz1rRdHZLvlDeetDEz+y7GQ6HqWEd3L/eJXvJNOKR3aNFzt94qTGwk9D9stNvcqIqzsqriqPp07ue4llP8PUrNhqz4aqcKjrLkRKx2t7vQ1qHN59/xHLTqbjqVbFTX/ylRsf5jvJtOKP/vFl88Wic1eLw0xrvnHnsQOxlkcXccmynRqP7Rn/l7l89WVBiOLgge0kyF0wEs6wz9g+k6XjUTDtR3MgJGta56DMBiPlpMHNYVNEHjPvTAVN++ncqNu+/DoaUAnaCKN3oFkjrmH7zDTSFassQSyKIoIyhqYoIea/GGGnAOmhLAKlRPoULLML0ohQEA6xAFIpLataAHnENf/x7/zjkmni1J7x2pMnM/CcZOG51E+5C57JUR+Y40Kf78MoUGbUGIzMA4dbSgAzZp/3gmQFH1qUAblsJHkD+5JC6vK7YC4ZDTCSaKZs8zxgAB48AcqswhjSy7hAokwojzpDkPug/lBXEiuIg16oxeRH2SxguWmQom0djed/DlWEFG0fonj5yI9Ernnof3VKaZm1J3liz18IoV7HTd2dsGSHuPPYgU8IIX6rVAK5ibtkOa8VraLmpNJk+h4OZSxXY8QLjKzh95NR8wxIbWJ9RhoLC5QuGoUODpLZ/bnz/Y3tEYjUocnmSA4UCUN0jgWSIOSy1B46ks9VV81Q/cC0H6N69A+QJCC+YOwvQ5SeAMgHRkbije3TZ2idaWTYqIuWFNQo5OmVGwjQ+zyVoo/1nCl1GB4021uq7J++4PNUUIYRQvze37+iXK5I58gQRZXRMjwBUaBQjuaFiFL4PG/aON/Y1jK7U2dJOhPw0vMegOhSEvpuIkX56IhWXohaJZtkffAhDZ+qGzYYfenx0+RRYmQIolw1jRvgYsNv5IOyHeTCFM2TFAr07fyRl39mWe+QyzLRvvqhiZdbdjJdw893javJfeO/wHeUObt3/KmP7xmvTQ101cdpYc5vNx3Sm0jlXMIRY4f9VV+XPLGLLQyYOonju35ceybY2Wq3/onv8ZNOHN59/6ssO5nuQMnA73/y1/nbhWnw6r97papNnHCLXB7v+cZzf7ycBC5b3x50y7hlJ9M1ZMrip+f2jn+O72jvcmbv+Ovn8qorZXrpH7fyEttbyJf2L39JsrOo+bZgP049Tu0ZkFL8Uq+3QzcTuebYtb3eBjacsu5iuoXaBMqtdx+6iW9o7/LGz77o4G9//BU8kbZ6/NJ773/u2FKpXZZsR/P968YaiaBcBqUxYZCkxE1T+lbHIdhEk+m+adnfFKEGrd1xP0bfCJppZ232CbBqFy3kMGjNnwUreX+TZAhM9M1NrB9GEAI1U1N7YRvovSgjyoIEAeVDTqh32SYACMqcUP4w5ENv5Ma/GN0HibgduSd+eyJgOcB0Naf3jk8WK2JDrY6JIkpu6NnBEUSr7+YgApQX5DJu7EsYgsoGnNlF1YtdlC58llNFKlGrSGAF2H/VzrRylMtSBCGKTd6+H0gvZG7WUYEsDiPXNFUABxGzjynoz03rBb4WiwdaXoON4cABsmq7rcxzZNm+TiLgFOoVfZbd3YZ0uK6KbH+Qf0z0EDXHsKpaZuuj7icZ3fHtaK83wmLu+OrzhxyO6rTe7fdTZBeUp4TDVvnNpYJynyJIBiJhmsP2+QqW1MtliIjjsv84OHuWZDtDpjRheoZkQv19VI9g0H7OHMunwQghKBmanqFzvR4qUyhcsBx/0hOmGtsoLwqFqK6zc8b5gwMkKYpG7Nv+1CmS+3h9xg+PYsE+klG1Kr/9Fy//zG5LIkxX885/e8GnKlX5ylodPW56PvG5xMg6xZLx/Py3XzzX2PdfPxttbFcgQlVfJNfYDgQN+R1OF2CkHA/0jUyW5GaxGKWho9uUSvQMD4K8KJul9CogH4qbEqMnXt0Yxpqe/dOnqZ+4oQ3CZh8NhUhuh3nPzpKUD6NfbTTlSod333/RhdVViazgloJnvbqcYkX5fzI2xve5h/jP68aUnjjpZs5+N3zRQbLbkWPBFrMq3UXtR3TyxJ5P9Xq/7hWSJ/Z8hCdOegPpcD2t19vAjnf8yhdnbHYzXUYq6931e594RZnva+/wmn96WVFPnDCrz53HDnzzYomuiuVJjR9cZ/1hjTtwlkZbSpRhchkXW3HOuQD/ox2tooNUWLytLaA2iMOBAXOVfB5WY3GBGMsZhqXxuHk+nithldnOUkTUrUJM55dgNVKFlW50XDkNK9zoVLZspoGOOYOgMKjAz50kWL0MmSvj6FzWAY2PvxLRWa3DrBfWaQHaKwZlcznEh7Y9NHFYMF3J9PXjrzqdrn5cLLIaKeNYgf0Onktt3YW+SUPQD9CyC51E2yWMfR+dLw/As6jzwzEjD+e26ufYD2oOnjfvSVVEudoYQWQErDvQqgwdtNpYdCi0MIG6SjT/Mi1c0LpForNXLGiTNYlZyxA4lM1AecD6pukGmCZ5KgXnolncq2iVrEfgVeouJ3li9wWl1Eivt0OvEN3xbZZftuDOYweeKYS4f/FRXN3FFVm36dCxWKQVZHT2qhRdJyU6eTRuQaFI7yevlxzGIuk0GTHr/HD1d26erGI2gPPVc+es76rhYXII6fNRfmhhkgbnq5s3kyPMRx8bNvKGL4LhQbIKQeeXk1O0Ur1xg5Enrurnc1RvdEAZBosbnU06TavspRJ6uweL2K1zje25eSPveJIccA72k8WKD5x+5vKeHe+/6cgJwXQlt3/ppl92Oqs/qD87ZeqLZ8+TA9RwgKydihVwGGs6edVWGWKRNVMuT9sFGBP6omRB0nj+BshqJJ0mB8iVKqgswPIsaTqPjUFahTyOOzSWhMJWyzQHRGZYiNP4EYuRZUm+QH0wHMqZdaK+5nLiLwUqJ45vSdMiL5P2iA+9+HMt3yt2v14uCUfLLJhuI15Qb/zxzjGe5e5CJvePzxYr4uM9V+8ToRZame5G/pKvF6sdSRzfpZIn97GZc5dRu6e1e8sTJ72DdLj29HobXIzDu++/6Aoq011kMu7jb/zsix7i29p9vOW+F/5boeD8Qa+3w5Xi8N0vss4amaza5EnUI2+27GS6llJZOL9/7Zg6s3f8IN/lzqcWTefs3nFVqYqBXqx/Jdubs79qvHfdGKlq+aHkiV3sA6VLSBzf9ZPaPe31dug1ItsfPNbrbbAMXt32JWRWjWLJuft1//JS9ZZ7bx7lVu0O3nTkoKqUHb/S6+1wJVFV4XvrF15ouxCzarKdGj8cG1MoBekDb69oLKOtz1vJbNAZagTs7rVFPMphcnAd7keHlS6b30Uo8o+C7MAFspy46dgRHU1iPbCcGLNDFwlbtgQnB1vIGNCy32eegw5lIyBzQEkN+M4RXvM6LCc60kWnuSj9iZlynyIUIgPbbmgX1DzUyudzOkr//bsTZBfJdBSP7BpP5ioKFWsibT7EKNtpeh7gXOwzUfMpKNj7e2t6/lACpyV5ERvZnFikMkHnsDqfODqohZNRaoRDHVgWipA5QFQiVbH5lwxTRAWOYdEJrEpDxeyGTpTq4MCDg53H3J4B08R+kOLMQ+AbPzjmNZ3jNjmXLdsPQgrswmRAy4Sg7FUh5AaXUM8nZ3u9TG31mn+EdSbsFLZ3cTicrw1vP/qXvd4Oy+HOYwfs3lh1slmyQAwE7B2tahbiJIdxOuF9Z/67HOezeTCl13IdNJ1H0CHk1q2zjW3tUHXbtlnLNTUuXCAn6HmQB1x1FbmBKRSsn62pNLVFFJxmplIkTfB4jHc0Oq5EiiB5iEVJBjQ5aZSpDxzbZnPUFihHQAe7DofxfTM1Q9KhrZtIzpQE551DgySnePz0gAj4S9/48Es++2xLIZmO4LbPH/z7Usn5m+jIeM58TlC6hcen5qiPPhkcrZ46a6yN+tz0gbhhQ6KxPTtHzxdKXHKmJC0ao2fSA2nMzlJ+2Ce8ICfzmU6PF+LUjwIBktmhjHBokMqUSBoyGpSm4cf3QpwkfhtHSZKXyRj5uN30PY3SQDc4pcY+6HJVzfI2vs8Th3ffT5ooXc/FOy6HmEd+YDXTYzqDfKXq/vmucXV+7/i7+JZ1Dqf2jL24NuFZmzjp9baoUZy3mWXtYnjihKhZLCSO75q2HGDamprlEE+c9C48cbIi7uigsjKrRDbnftatRw6p2790k+0KOtOevO9bN/Tf8tkXq9rECd+idSV657EDazt5svnoxJstO5meIVsRtz+ya7wnInd0OievHatO59W/9no7LGb2rDWMYTciI+ykyoYhwxfK3ndYDzHtRPLknncavk3EVr4xvYmUjo/2ehushMO7739n55SWWW3yBdeF2z5/8EfcsO3Pn37zhmNKiblOr0cXcXJxVVZVtlNjat/42/NV8W6xKJJM0yyN+d3ubTLbp8NlMMkJgGxAR43Jo/UO/AbwNMlJrOegtAaj0fic9rIcfQ7KAPDcKrRdCuVDZpndLX6foKU9ynIwH90ETbIDSAOlEgVIQzfXMEgb5grQnmDyj01UNf8HZUQBkB3g/UtDBfQmSptyVSVCbpn4pe981zJbx6wvj+wa/5kU4sm6EAstpDH6+fLDM5Aq0bm4vwSdRj8zCUgXu+sAdNL5IvRB8/nBfumFPFDqNoeStSWe95YRgrCyWg5o1nn46fNC9Lltr1NZqqzU5QCJj46ks7jiCqLiSF1WjMyDAyC0c1OkHzNtmaEyKBgHJOrwICKR1hEqqLN8VV9FSdmTTnKXi3S4ropsf5B9orQRLNFhNBxhZ+XceezAJ4QQv7X4QoxM4zMjcoDZeku0aXyNYDBnSSsUJNmLy2Wv5dXRey5MUQC00Q0LlvNaoc36RV1mQzKG+QUyqE2DrAWlPykzsgZKjc6dp4g+GC0EI5TMm7KJLRtJOjM9Q/Wugi4YpQKhoJHG8DDJEs6cJTdzZYiecjXIi3RUIK+HviPSOZIcYTSUeJLuScTMbz5BcqDhgZRwuqoffO/z771NMG3Fbfcc/Egq7X2tLtMGiCS1APdQR5UpwPM5AlGi/BB1CqPmFIvGdhDkMmcgSg9KdVAmM7rBeM5Pn6FnVT/L9evc9mvmKOFxOo1zwiGKjqMj24i6TM1e7ndhyiifltMsJp+j+mEkLS0vxDLgeFQu23/+es3xD8eV2pj4tgNfaXrfrKrlSY2RByfeY9nJ9Bzpkor++zOuU4/sGmdP723AqT3jHzpx7XUqWao+ue0Lu86kF7pbzlKzOlFSOI1ZIf5r9aeqpccTx3clLQ3IrAu1e1G7J63uF//1zh9bnVwah3ff/6pOLDezulTKjje9+fM3qzuPHdjOTbv+vOXem294/adfrAoF52vbvay9ynvvv+GtWPVVnzwR9VVkcbtlJ9OTzBaq10/suE49umvsI/wEXHnO7x1/wU/GxtR8oXpLr9X9Usmedq1Nwu3Ci6L2U/iMDSqcOL5TJU/sPG09xlwJam1fuwe1e8ENztSIXPPQ67ghLpm/79ByM6vPiZoj4TuPHbiK2/bKc+uRQ5t/++OvULmc6yu9VvfOQ74Xi7zqsh3NI7vGFUbLwK/1kI4Ig5bqymrCLxZZtuvIGihTCWCECcgEI4NoPA57yU0Q5AF2dqApjBAC+1F+gxF7kqaZPEp8UJ7TQknQlLa+FOU5XlQEQF1zkLbeRFUCnhvx2NWQoqsMgvxhFiKYYNQjjKSiZRGoGAArRdGPEZdUva3fs/HoBE+urTFn946/cK6g7tG5hOD+5aBvYBSoQZCf6GcY1R+gWGlKL160/hbH5w8j9oBSpxFhR0DfxPJghCccH9yQXtk8H/sJ5p2FumLAKOyDOipYAqV3fUpsMSPvNA1eEP1G6rSh/gpCWzVF6QGpjdR9wgmRdHJwHPodTm8r83wZgcmdIkh4cnSdDME5uhy1AWvIJdSzejc88eUipTgTueY77GfjCpA8set7SqkdXV9RZkVI6fwoT55cHheLvKPB6Bfa5H4xc3NkpSlN8/hwiCJyYKQLZH6eruvvtxr3tco7nSZJSqFgvOMiEBGnWCS5bRBM9KdAEoTyG/1RUKmgzIbyTqVIGpODiD1Os67RCKWVTJI0CCP6YJnm583IIX6SRFTKEH2zQOf29aHEwChTMkF5FEp0rkNSG+WLVM6Q35Bn+P10H0IhKnMiQZGFkqlAJRLJXfVnB+8+K5g15U1HDm3KZDyPOZxVt/E80f3L5OmZw29WD0hq9PpCmT0AACAASURBVDOcztC5gQDd4xxIWVIZiB5l9k18RpAQyHm8PkovYUbIGRggyU06TXnrvlijH87J5+gZdZuSszhE2ylDP++L0fM+OGAdE1Ig8amALA6jWdnJCBHsizpiVitSacrP6zHa+63P/Goj4zWxPBF13wfiVy07mZ4nU1Zvf3jnmHpsz/hXe70t1oKze8f/9PvXjSmcOGFWTqFLI+/wxMnloZTYwpYoa4u2NOGJE8YOnjhZFTjyDtNEuSqd8/HAmd/5xCvUW7/wwqdz66w+f/KVm576+596uUqkvGfLVem+0vkzl8effuuGRlCcNZs8GX1wgs2QmJYsFKrPOX7tderxPePs/XsVOLVn/KGaPCdVVG/p+Mq0CWd+0mUqga32qw3MymlMohwfLyRP7mdLlMuk5gg2cXxn0pg0EVs6ujLMmuFwsE+A1YAj7zAXI5dzn3zDv75Yvfneg/ycrAK3f/mm295y7wtVqSj5904no9T7dOnXTLYjjFXwp84VVP1hCcN3uw48gab4TrBPAmt3kQezez3T4wCzfbCSb4oCg6qdmFtH8qB9HriuYm+RSCb/UJ4BkDaUIBNMW8uKoJhNEgTMO1nCNqD9WkqEUXwiIA1CCYUP0tNnBJpkFRDBpMV0mdvMPF20Lw+2J6adMCODtJIfVaFtMXqKRkdfkbKexVNHH5z4meUkpiU/HBsr5ivKjc8GKEAafQbvWdFG0iZaSN3wucUbi2mg3CduPg+YH0aRioMkpUlGZ/6LRcCnBeVmMxDFS/ftjE0EKLGoD+JQF4L20tG7UMqnM3/izkTNPaFlf31TR8WBCDsK+qtEvRzK2kwtogyhDg/yxn6SIvPeRrQcbCTIW6bxXJAXmemp3yDTZWb1kdLFcoIVkjyx5yNKlfkHMbMsojsmrB8RzCVxx1ef//pq1fFhUR+7IJKe3zBRbyXVQYogHfG0kOgshY560UpWi1F6dAQNUTfzT1tSRrN9r5ckCJMXKKLIls0UAXbWlB3ZyQQWUwVpT8KUEAQh4kg6TfKIIsgYfCCZmZk1yr9pI0XbmZsla1CMKOIHGYZuD5REnYcoKSGQIvX3pRrbU2akEozK4vVSe44MU7Qg1NvPzJKsyuWu1CKWfOHdv3rfjZZGYS7Ku7/+vH9VQr74sVMUwcntpvYf7DcizKDLiRxIXbJ5kmkNDdJ9TZpyK4zk5IHoOKkMXYcDpu5WG4YpLZTIYbQqlLikUka/QpmNx035+f3U17C/6sg1ov5MGd+fGMUnBdIfNzz7LmgjPS6USvQM49iEz3seJE9z87qvUQSeCxf6qH6Q3tYtFIHr/KRxzsZRiviVL1C6bzej7qzpUuTmoxM/jo+NCZvfZAzThFLCmS6rnz68c6wWBveBzUcnrucWsufUnvEvJYrqV9GPDrNGbf2fUbH1aZ0fcEXuDNaelhZTp8xqUJsESBwff60QclY63NdymGN7jHDDpf8QQg3ansAwNkiHZ491L3OpvONXvvjn7/jKjR/mBmSWolqVL3j7l26qf3C6nNXffucNX/j4Epf0LLceOXRbKu15/8bRVAsvmkwnc+exA7HDu++Pr6nlieY/rxtDH6INJ6NRN33LZ2Hl1d3CMmPA9F6pV7fFIuey+GPSb2PlkKcJr6ZVZnTsmoc09KSPq8WMuB9Wr0s2TlQd0HFgIbjJCSc6qfRDXbTlCTrjVPYL4E3OMnXbYXs2OQuFNsD20kngijz4omyyJCjAbJiuS6pFfpgGOrbVs3bo/BOfxPovPUfd2uYftz008UrR40zvH39LRYj3zuboKUBHx9gn0KJDP2pNzzXMcnuc1n5SQ3dBvNf4DOCEKPa1eRvnsUgMni80zNDlw/6MONBxLfSZPtPB8RxYo7haOIb22li61DFPwefTA33q6r3pqlDmlDu0s+40CtsQjVeaGgkqoPsKthUOCpgeOHBuFBpNi6Atms5dVD+2OlkfpJTHI9d85xm9WPfFJE/sZAewzKVSjO6Y8HLrrS53HjvwTCHE/auZaAmsUdBhbBVWrR2wcqwdtC4skFUJOmfFlWMknTYsNlywAu4DaxNcZd6wgVaR0cntgGlxUipTfpNg0YFWI2gRsG2LYb1y9hzlEQxR3ugoM5fH9jDe3egcM5kii5VUmh7xpzx5srH9yGMj9X8lfGCUyvRDaWiQrHByWcpPr9ajNYDTCdblcB/m4uQg0wX7/WabZmH1veag1ulQ6WCg9OsfPHj3faLHOfy5F92cynr/+aotsw3Tp4UFas9yhe5VqQjWGx7jvuBvnzJYRGzeRM/+D3+6qbH9tKeeMe51jp6dC1MkM49GyUIJ09POlWdnqa9h7ujIWJdN1K1QnOa/1E+q8BmKzo0XFsj6q1qlug4NpS3l9Pmg74KDWrQqSySNdgyAdUsZnn2/n+qqrVsE9JVgkK7DuuKznwKrsYF+w5JFjy9ikYVPIJB77237vv72KyKC9zploVhR/OJjVkRN8hMvqFcUd469QkqhfE75+c1HJw72Sis+umf80wuF6ktHW/0oZq4Ijz8Ucly1O9G5jf38SHmtrQwZe2qTBYnj4/U3tpTyhJDuQ71ikVKzMBGqdLdS6hrLQYZZATxxsjYc3n3/N+88dqAbq8asMZWqDCXTnnvfet/NQjjUjMup3vqu5977t73S7rfdc/A3CgXXR6tVGcnmfZbjTLcia9LsKzN58pTvTPh+cN0YawyYS0YpIXNldfP3nnFd/TkKumU86pI7R49O/LRbWrXmI6hQEf+WLqv6FDPLctqHUtlbdbsKHTmLpQYkT5y0AfVJBFV8PHF8vPYCTkmH80OR7Q91VdSL5Ik9dyhVeYMQqsu8LTPrhRTiDDf+mlIzn1hYx/yZTqcqh8pV+Te//6mX/42oWwmUvvHhl3z22d12X//4/730wXTOs7e2HfRxsJwepW66dkVkOzUe2TX+01Sp+gsCLN/RCSRKCdB3YgF+QGqTfjTsR1P7UAsJgpYEoOwAHZm2Uhr4zJ8c6IwSzfnBaqnJca0+v6+Fc1m0uq9A++Od0BKenI2MyFJOkCPouqJ0A5QSzZIbaC/tbBebsJXMwYPpmfmhhASlVgGUREHeOj2UWJShrg57JYStQ9HavwG3jAdd8j1bj058SHQIk/vHn1eqiI8miuoJjTaA50E7ay0q+2cA7zE+Rx4b58R4T/pAIjILDlzRmbA+O9QkDbLvay64Tj/b2G9xDgglcnaOrDz2XbhJdoTjg5YBpbFsLaRB+ByhjE73V6fAvm0ddzZfG2+W1+jEseFykGHIxku2gMECHLyKGL2IVRqcZeHA2HAOC1I3lPLhWKIdP/+PaEl4BL/l2x45K6Xr/0WueaijnKcmT+z5qFLll7H/EmatiO74bou3ArNafPDos2rWcPWoYQ6HzYdm84vGchiZX6B5U3TmiCb1AT85OA0G85Y0kEIBZC9NzmMNc363h8qTzdC5/gCZ63vAAeX0DEkWNo4aFqXnJ6lsWpJTTw8sCorgdFVLE0bA8eZCnMz8N4zE4Toqk5ZvzEAZNgyTT7U8nIvym02mfOPRx4Yb+8IhakOUP8QTVOaEKUf45aecb+xLZaic5ydJwhQK4j2htjtntg06CB0aJMei1SrItkGy4TKfo0g0L1xO9c9Sqtff8dz7pkWHcOuRQ5tLRefHAsHiC3SJk9C2RZB6uZzG85XFZxVkIdh2oxvgfpvnYxvOgKTm6m3kyHRqiu6V7qNukNagVMwLz0NfH90r3X/m5igPJzpqBUkXSsg2jhrP3+kz9JoPwfPn9aD8hvbPguPh/gFDioPOcdEBtB8kcpFQlk4yx5sLUySn64tRnbTsr35q09hkbKOMMATpoqNclPBMmg5jsQ1xHBOGxd6VW5F84rcnnnLy2usuPuoyzCWSLalYtqTuzO8cu1NodxRKnPc45b9se2jijevdrqf2jH+oWBU3p8vqiZWqElE3fw92GvGZsIhtynRMqWVECsUTJx2C+v/svQeUHNd95nurqvNM92RgkEGKVqREgAEYgiRAiJIt+8lPlK2wttdHko/W3n3eY0leSF5btmVpZetZwlmn3ed12DW1+2w/S7ZErZNkWwIBIs2AASQVbJEiiUCEydMznUO909N1537dde8EYEKH74czB40KN/eg+vb/+3/9rlv42Zmn9v2sbK8lrMvCCnylUTZUKhslwi2+wxXudt9JQtYE5285rmvPx+7/xq7Pnnwzn8/JmlAsWT8mhPVjH/gf1fSFgUA52xHN/1PAKf/x0R/50lc2etR/5atvPzQzE/3FdDb0YLFkhx278mG6uskUq8mZQUiVdQ3n7ovYH5nIlpndm6w5lS/hUwV3qyi4Pz951z0/D9/xVyJuilHbuhwLiG9UNjS3nxz++M2258J9+3/LFWKwWBZ350vuzrIQC9m1Cl7UhClyiDQHcxcc0b2teSbL/ZGE7xhpHuY3Keo2VDzylrBGXWE/Y9v238f3nPqvq9Gp2fP3/Wy5XP5BIcRtQpRuEfA7jJCNoOvOM7RHXT8+XdHyt0tnycZRLNqRuVSo8t5++wcf+XFRhsim3u70dx3HHS6V7G9bwh393Du//D9utqG/9Lf/50OFgrO3XLL2lUr2PtcVu+S5asSDI5Ip5i0hy+Po6cO71022I3ny7nvchCcFQIcWbAZKPdIoy/HuQycZlIvMLeH4gi4+GA2fhk+1cYgIkNIelPWUNeH89dfIyH6UM2BfMbIoD6+xzdJdpFTCa/VSCF2b50r6dqJ0SSfZQHlOL5SbhfqK0KasZmMApRkmKQ46LUmmYBB7QL8xCYPUAWXLw+iogvEcOMfo1iKvwb7i+hsEZ5RRcHGRaw3dl9AtybQeopotSpTRJGCca4xUvLHTGEfNE4cxxEtwHOV7CdcDyrGw7DCMbdIrAzedIgYZFyLlQygpQrkWysI6axyc/OfRWDdTXHzto2wHy9A5UdVfL5tqw7VYBtwm7A5XbHmNF5Iri+iC4A50x0J9kWaNokuPhZFI+HsRzX3KCwtenXdwDUAd93a45deZVg4hhDQ2lhW5P7H38VOcpvXjE197uxuP32B0pfwAbJD1oGwnCs4a0pEjHlch9Zalf8LQSYImJ9WXBJat7ktAefm82gdGByDpQoNymMHNSlYxMaEcUzo61H25XPWpoKdH1VEoqAe9yUklX4nG1H3dXWmvDSDNhb5OzygZw9ysarPcXEBXoICtytgBUqPnX9y88LrXc/WZnlbtGdysJAizc6oOlF6gq4p0C7JhXkNhda0DMi8LXvd7TkYvvKTa05NQriwoFykW1HOMlINcvKycjBCUYKH0IubJtLAf6MoyNqnmcgvMcalYLcPC5/qk2kjp7lJtRgLQjrnZqsQFXWeSs0r2EoS+9vQoJ5kXXqyuu107lKvO1WvqfYKOSui+JF12sjk1T+hQ89LLA6r94Owk++rCJ4Y5WAP9fWo9o/zmmtcmlLIEoE+4vrDsLpjvbKba1u3bVV9N0hlsv3w/1jregJsQjFER3h/Yfh0p2CxD6aBsk3T5ERrZjhDisP8T7Bpz1xPn+EBPCGlKyilLlAMB/dNhA8GNE0JI82LPceNk/bGd8uvarc+EELJCHtR8J772RBzrxWxJJckkhJBm4epI3Np2Z+OaE7g/3lXJO0yHHUJIU9J91zDdmjaAT7zl7/756OnDleSxuxqucYQQ0iCsu2xH8uSd97jo9oIuIygrQPIaiYjJHSarsWXBsPz8MtxApOSkA0LqCxrJigB3HKwPTTiwbpQdFQ3jn/AkGXnoRxLuS8AXy9hV6XKC0ieUbKCcAp1N5BUpuBaVBAmQiEyANEH2uwD9QClVCuQR6E4kr6gJfYL6gtDOAoxz0Pb3G8uoUX3APzIaaRa6KCE1SwfKiGkckGqmT2cfA2VgubhecFxioBFJerqkblhISRh7dCrCNYxyMfk+iNW819T5CEpZ4ISU6KCsrKBxvhJ1zjqyCJTk1OS/NtQtZUwYrItJ/1F2pZu2boP0KW9wq+qCxS8lQdhmlNmh1E02I7qjJLq2emGSKEFLg9AJ5DxuChrlzacF742aRpvw2oFyH+yU1RUQosMW5bdFDQUQQkhjY9vBP0vsPf0TnKaN4+jpw5r/ZRdnbq76/w7KO2IGJx2UuASDRd95ZGxMyRi6utJwX/X/zExGyQ5CIb8kp0I6rUL08ZkuGq22L5tVEotIWCUIvXCxb+E1ygZ27x6b//tlkBeEQcqCcoreXtXmgCdNKJXVMwM6reBrlKdks9Xy0tDXnTuUEwu6msyBS0qflGFAn8fGlBwBZRM4XtjXDk8Og84uWEcIZDIFcCSS44H3lUuq3Gtjqs2v/b5rC68zmbDXHlXuHEgsUCISA0elVNobG2h7f7+SsoyN6/djpWwK5Ue33qJMgVAqNQFOOONT4BQDMrSFvsLDbM04O6jF9mTuIIHBNx46P73wklprEW/MHXDHwXWNz9npLMi/FqqBtbxTrSOUvcj3hgBpXDyh1vLcnH5OcN0ODCi5y0yymoBX5yIl6sYfpX/XrlXlWyVYO67hs0F/v5Jj4brU9Q9lQiaZoJbq+jqx7rIdyaaY/SO+g4QQ0gRkLjnCsg3i7g2EGyeEkGaGGycNwUfafQAIIcTEhm2e7Dg5/OWAI/xbQ4QQ0gRcOJnQh8htFA915qvfW/CHP/zhT/P92E5kN//v23iOHDj22+0+BoQQYmLDZDuSfxnaN98AdL9AaQbu7ki3mSDEJ0UhpB6lIxgyJd10DIYWNRIEHA0py+mEMHmU6mA7UNIgg5ZQIhM1yCPyhmgh2S1sJzrNYJC/yW1GHcP+6SUnsjysAyU8KPtAiYiUsKBsomjoU41Vr3d5wSCfChjWAKbBtKSrEczDlGFAsWzZFVQ/4BpAOdkklCf7iPIp1JmgWw1KPWYK1YtwbmqMWOA4Rq4FvPJqpF0Yrgb3BQwOOnLtY9twHnDtYJtkGbZhjaMDjW7EayR0OPhAT8jvFlSC9qRRIgeNxmQecU9+k4Nrsf+4HEpC3w4pM8PfQWHD7wTsa6Wtm95UFAnIKF7zpgKnJlxsC7IbXMs1dlWGPW3pjlWj/1IzUf6JTt8thBDSDFiW83zXncOv5mQ1BkdPH+6uPFLVNyaZVP/PJMCZR0pRHGdpCWpNGYk533kkl1OyAwuCPcsl6RyiQHccC/4b3bZVyQNQhiElIigliMeVXCEP8qJYVLl3ZDwpBEowro8qWUh3lypjFlxztmyZmf8b5UXJWTUWAUf/fbJ0XYmCgwjKElA+1A2OL0FP+nL5inKuiYRR2gRukh1KAhOG9o1PVNuHY9Hfp+Ysm1FjtyCdmZdQpL3zjvY8glKPGU8O0gdORr296FCj+oqyFdeTPHXD81ga2mbb/msrdMarY4qSqQCUewXmdesmJUOZmlFRvtu99fUKjDNKeYog24mAY8245wDU16PeRx0xdIlRbcL1JV2ecOzzIJnq6QE3GpC7yPcPyohyIDHDNYDrZGamOiepNMi1QG43ODgD5ak5xvmWHyUG+tW16J6Vz6FrjmqfdOcZBfleLKraNjWl5qGjU7VfgmsZ3/vdXYv/3snn1dgWS/h7YH59HTc8pa8fHQHr1ze6DYQQciOMPtsYeVm5cUIIaWa4cdJYHDlwrOLJ/zvtPg6EEFLHYxseeVLhn/fvK6VL7sJGDibTTMO3rHKPNIohA5poBlH3TbX8FhmTR9qGIqKahKS4j47fjIcwAS1GvXgvY4aIFV0URP1xmbgWd7ewnSlDElh5PfY1AVEhmCQVy+vykl5OaCIt6sH7ZPLbOCTNxG/wMWoiDuVNeZlIsX/4rT4m9MQoB4xGkFET+EU8Rs5gBMlsQZXuWP4kt1hGpyHZrhzHDIwhRvVg3lCoTsS8z9cYBYFzjWvKsfxrP2RIloprFdcDRl7ISzDhL0Y+uYZEvzJhKkb14HsGk9JmahIgC6/N+qirLMwfLq9UTVhSFVOS25poJe9vfB/h+xITBWP/dNEw3YakyCFDVI8su3L6tgdm5UF1AUabdMAgZLyyoQ0WRpvgIsfJl+WlasNsrB9MlEtbNk6CSQghN4PtRHcn9jx+gYPYeNQnj8Wki5jUUwd+e4vRFqkUfFvckdHcqZidVdEkcYh0kchEtaIukiICURpzczG4Rv3/mclW29fTrb6FzuVUm8NhfyJQAVEvV66qSAOse3BQBezMJFX7O72+YnLMsQlM9qq+qS+U1DPDq1/lJVSFZKiz0KcIRMVcv6bKkwk783lVbiYD36JDwtXOTjUPGMmyeXO1jJcvqb5uHVSJOVMpFY3Q062iRS5erl4fhPHugWgSTDKK3OIl433hxU2qvs2qvouvqHbUJAvtra6Na2OQyBXmrxOiKjBKQyYtxbkMwlxihEm8A6OP1DqRkUERWOOYkLQMCYITEJU07kVKYbQMJj19CeahC+6TkSC4jnD9bYVIq9k5eP90VscIIz5mZ9X8BSECaNOAaod8TySTaiy2bFFrHN/PcixEXXSHTGqcgWiZHZAQ18RVb16wPnyPjkMiYExAm/WiytIZ1b9CQb1/Nm9WETBZiJbBhNGL8MmGeOB+7fCI4ztICCFNQhoyj6833DghhDQrFbkON04amp4mbjshhKw2jzXMQ3df2GaCKkJIU3Ll6eCGNLv8U3EmxuQPf/jTtD+U6zQ2lO8QQkgN5xtCtiP5ztC+QrFUkw9SFCG0XcowUJJiSvyKEhDZR0wCieFeKGVBKYSUbOjkNPXtCNckHJVtV/flNPIjUScJwPCbgPcPXeJbUScz6QaJi+xLjUQBIitRrtAD90kZDd5XKuvvS8B9uaJ/bFHqgnIKTLArq8mjhAn6jzIonSxJGKQe2A6U5eAyl3VjsmGUk6CMBsfAsf1tQJmNTgoiYE2Z5F845iiUknXX5MCFC2IGOUwO2iHXK8rYsJU4Pw4ULtUimbJ+DLEMnbgLz9fIfSz9+0fKrUxJijOG9kspVa0USZ1HqRgqavI1iZ+rf+Mw41SiFAyTBS9MG1z7ffeqUMAavRImavZkOzVJYsOwqmA9uDmQ9oRrZTvW27vc0hZXN/yEENLw2E6Mcp0moV6+sywM/z2hVCUer0oWApBoFqU1U9OL5/Pq6VJSHkzMiQkmO0Bu0RFT8oexsWo7ojElt8CkrCjbuXCxf+H1rp3jvnaMjav6UiC/gYwEC0lEt25R8oKLl/qgnZiwswjH/dKmqyAzMUko0plqOxJxdb8Lc3Lple6F1wP9ahxzWfUxrKurem8R5BjJWRVpi4lrS0X/9/E9varcuVnVtjFI7lvzzObNFSYN3bVLjffly70Lr7MgC+tcSLQKz5ggz9kJc4ZyGNtLooqJXLPQ//5+JT3BxLudsKbkY+1sSs37QF8KzqsOolxJrtftW9Vzo22X4PXCS3EBZFNbPCkVJsHNZFTd0ShK1tRc9fZW7ysU1Ljherh8Ra0Hx1ZPxLfeMjr/98QkyH2Sqtx4XNXX1aWkWShdynpJlqNR9f5DOV1np7pPi0GyhmO7ZBkGxuB3xcBAdS6mZ9TvHZQfpVIR8Ym3/r3lX+kbyOvOjmzM17eEELIKpFMd6zOMCVtw44QQ0qzYdvAUN06ahyMHjvH/G0JI2yPqvkRvCHrC1js4M4SQZmTq20H1NcQaUn7v4t/GEUJII5PYe/Z+TlDT8ZF2HwBCCGko2Y7kO0P7ptIFdz5+KKwJ3UeXDpReoMMJRsRLiQSeRykBSnVQpiB3ljCcH8F22PCBSR5HGQd+nEKZxgw406DEQL5Ka5xMRJ08paZ9rr/uSI1riV6ilNZIYCAaSsSgzTmNbAqlDVgUjifKG6QEC9cf1jEFep5EQN9O2W90QEHpFoJyi7h3Q9ogL9IMRU3zcdyE4T6dYMMkN4sH9G2WEhaT4xK2uRPKSGnWjGm947igW5CUWKG8CJZqjbYuaPvXBrYT1wau56hGroTrpWSoD+MtZBno8IRLDhRmNcfLmvHANgdhAssG+ZpsX0CzHG59KFWr20PQTUeCGqwc3IeT4s2F++54yY24TLJNCGlKuu96Uv+fHml4jp4+XMmB0lXfzkzGcwAByU0uq6QE6JQzMaHC//v6qlIClL10d6trg+Doc+2aki5IR5vJSSUB6u1VDiGFgnpqCAZVGSj76Oqqyg1yIO8owOtucI8pw0PD2Jhqv2S35xIj5mUt6suN2Vk1BtvABUWC7cdnjUBQ/SOXq/YlFlUyInQt2bRpeuE1uvskPVcWlDOh/GbbVnVfKq1cSQb6lYzkwoWqXAklIp0g0yhD2ZNTSk6xeVNV6pDNqfp6e5T8ASUgibiScuTy1b4WCuo+6S4zXx88dO/arsZzzHPZmQH3pc39swuvUQIzk1R9jXmSrSS4zkRBMpXNq3Vkw4cilG5JB6orV9Ua7u9Xa+faddXXLnDWkX3ENWfBOOehbryvM16Vd8Wi6tgrV9S6dtHts0OtGSkZ2r5Nybwug3vR5k2zvmsrhD1JU7wT5V9qQNHZ6hLI0NBNR76/cV5x+6G/T62NMDjeSPkM3heG+UloHLjWmAtHDhzb3ZAuDa87O8Ls3oSQpuXqN2Nr0/RbgsKNlB0myOQPf/jTjD+2Hf6U7/caaRqOHDjWzdkihLQpj4hGlO1I7nryHL+ZIIQ0JZnrlsjnQoYYphunfH+IC4IQ0qQ4k4m9pz/B2Wt6bmn3ASCEtB9HDhz7NdGosh3Jpfv2f3Y0W/6o/LeM+I/VSERU+9HJA8P/I7qwfNiaQQmFIdB+AZQBoKsMOsJIZxOMuEfXFtyxCkBfsGwpb0ApC7YT5QMBjXQEpRQFgwtMjROOd70DjcN2lgyuP/I+lKSEDHXrnIpCFvZPXWsZXFlQviHLw3C8WZBvmOY7vNBmdazGmQfu64YbpRwG1xlKS9AhCMdOrlcsF6VP5RWtP3BnwnmHa4pLSc8MUhad/ATlYbj+cA3USIK8RgVgAFBS6vq1rgAAIABJREFUg+uyDOMl60G3najBOQklcrKvMYMjDratE67RzUXEIN/DMcIxl9WEDH2qrK/XDXnhrzEYEBlxaNq6RuskmDj3g10lV5Qp1yGENCXddz/FL8VahKOnD1e+gX2f7I10xenpVuH3JZB0oPOGjtlZJTcpltQywfKScI0uXN9U3+ioCpZBiYuOipuGpKNDyUnSaXV8bLzaV5RuZDNK9hEBtxNEXlMsqf/GHXQZCqrXaZDRSPebAkhuoiDh6e1RcgscIykzSYPEJwWOMOjo0weuMuPjSna01XPyeeUVJQvBcQ5Cm6eSSuqxySsP5T5jUC660cyCO1FnZ3Xs5kBGEwiouezqUnMSCil5Rz4f8voP9zmq7tmUOm5bqrySJ8e67dbRhWNpWANJcAiKxlR9XQnV/u9+b7BaHzjUhEAqZkM7uruU9OXKtapkq1zWPwxuGlBzMjWl2hHyxry3F2Vl6r5IRLUTnXWuevV1dqrzKPEpgyYeZULS0WZySq0t/EWO5RXAJQldp0LhapvRnQnf2/j+T6VUmwcHF3+/ovwLnYPkukSnKZTe4XspEsZ1VK07AHJBXMMycbZ+xhqEHaeGPxZ2rEIjt5EQQkx856xPGn5DWO/pKnPjhBDSrNiBjt2cvNbhyIFj76+kj2j3cSCEtA0Lv+8aevOkwu0jI4xTJ4Q0LZde9ieXWxG3hUQpUfmqhzke+MMf/jTfj+1Efp+2xK0H858QQtqID8uuNrRsBzl31z2uToLQBbKKPES7o4RCXoE9RbkFuoFgKJIM/w8apCxhg7OLlIPgaZREoDQB2z9d8LcZQdlLziCbkEdR8lDjAgPXmuQNujbgGGU0Eh1sj2lFoSwipZE2aZrgaz+WIac7At/HF0r6+2okIl5fUDqDbUbnGjRMkW5NeYMUCcvDEAGpMnFAbmJyYsJ2OJoBwfWH7jd4Kb6W81MjSzKsB6xbSmNw3HDsUbIW0bjtmJyAUI41B/ZXsi/Y9loZEc47rD+vPJOrE/6uQGkPyo7kHBYN8raYwUlKgu9nk+vU9v0ZEbCqoYGWt6hcWPwW6uJETcdF+QMdghBCmhIrMNl917k+Tl5r8puPP3SrJdzvoTRBIp0yxLxTh5IY6CQ80q1HzEtSsr7z80BY/lyqKmNAp48AOP1kc+p7V3RJmZhQbQqGqtdnM0oQLp1MxLyUQEk9urtBLhIseHUoeQHKOKSESdRJEyQ4LiijQSIRFXSf9q5Blxsp5RHgUCPqpESTU9UvblA+gc47KIEpFtRxnbwBjzkgT9m6RckqcAW8fHFg/m+UyBRArvTqV12DMVCSlFS62laU3EyCZKWnR62jNIyddIQpg+SrA5xmUE4yOqbGX0qCYlE17zOzai12wnF0ecnm1JhLuYgLY5RIqLlCx6WODlWelMmUoG1btignnBdf2rTwGiU8cl0mEuh+o+q+el05OH3fq66rfnlOTCmQMPX1KsnXK1eUV8uttygZk3SuQmeeLYPK2Wp6Rs0PyrhyOUy0UGUr9A8lRcGgXmSS9Ry7UDYXBOlPHtycpHOXmHdfqkZ9Dwzog+NQJhTXSAAR+T76jf/jfy8McsNHnkg2RayP+Q4SQkgTcGE4IizbuK9ohBsnhJBmhhsnrc0vPPD1F4UlPt3u40AIaR+aJvKkwgv37r+cKrjbTMk98dtuTKwpX2Ji0XRB3+9EEL9Fr/6dgggNjJRwNIkrBSSSxKSZRf9G+6LlYfJYiSlBLUY5yLGpHRd9uVnNN+2YRBWjKrB/YYxC8dqkiz4Qy4gegOADkYCLsa/xILZDXS/rDtVE2egjOjDZqUwcipEBOBbhmgSg6ho5trrog3pCMK8LkUhwDUb64NLAxLZu3d/14Nj1wsTmSr5La94bGU1CWVGXiDXqLapZGDjHWnqcO7w5nCvqz2NnQtAomVg4gNFJRf06CujWviF8J2uKLnL8a820k4zrSxd1lDVEXXVo6nj10IywZGdyMIE4QZFqS8rv7iyKQMm/dU8IIU1A991Pa55kSCty9PTh80KIO/LwbXIIv02Gb8ZnZpWVP0ZsSCYn1TfnnZ3q2/VQCCIJvG/DZ+fUt96YOPX6dUwSq74ltyASQka7zM6pb+IdSA6ZTqu+9Paqdia9xKiJhIrc6OhQ7UQwCkUmES0U1X/rGNGBiSm7u1SkQc6LcMHoAkwKimAUx4zXznBYjRtGGsgxFPMJYVVUQQ8kIpURLlh3PK76HYtB9Aok4cx5kT/5gjo2m1TRA6GQelCNQPJbGYkzuFlFtIyNq/VQLGCkgZqT69er0QHbtqn7pqfVOstA0lz82Lt9++T83zMQDWRDZBReOz2txnbzAKy1sWrdQUxsC5FKr1xR7d+1Q0VezHgRGzJJrqiLkJmYVF+e3bprbOF1yUt/d+2aKjcQVHXjmsKEsDKqCiO/MCoLI5jwvSSjNPDzkO59uxjyPY3rFt/Po2MqP+DWLZMLry9e7J//W0YWiboksFFIzjw7p+ZbRltFouo+7Hc2C+/tnjm4RvMBqsoHjhw49oj8h+nzQkNy25nh7QHL+FmSEEIamhefTSyredYDnWVunBBCmhUn0PEeTl77cOTAsT3tPgaEkNYEN05Es22eVHjDuZGmazMhhFQopi1x7VLn4mOxKyRK24tMEMsf/vCnWRPE/kV8z8kv+n63kZZG2ngSQkgLcby+K00l20GeuOue+YZjMkcMqcfElFIKgXKLIvS7aBoC7zjKKkIGKU4U2+GVjeH+BUxQCdoMlA9hPfIr54ghUashP+bCcZMcKG+Q1EhpCUqNsI5uaPOsZsBQQtIBBWcMUqO8dxyv1ZUrFklWK1+i3AdlGhFM/AqRWDoFFcqZcJ1gMlCZ+LQmiawhEasx+61HwHBeNwS4W4iSFXzvogoNFSByOFCKhFVj/3DNyPnEslDShpKaiCbb8JwhGXEAJWRQn2wHjgvmUEWpGI55aWG9+9sgFpOb4UB7h6OahMYC3ot4rYD3PK79rEbWI+oS71bej9v3pRcSyFYvVoNR+lcqtJUQQpoJywpMdd/1RC8nrT05evpwxZL6peV2vuhJWAKBou9chTkIxe+EpLM6UDaCyWMxQWskrP7flUluTfIilNcEsX2W/0Ht8mWV2gflJCj1wGSguv5holyUyUjZThQkD2lIsIuJbTFh55QnW0F5USym+hrv1EsvXn55ANpcTbiJYzsHCUf7+5QkCqVS8lkpBMk9MbFoFBLiJuKY9Ld6/ZVrqqxtMG5lSHgbAjmSTCCMkpUsSHXyedX+ApTR781VCY719SoZx6VL6ldZV7eSi3TF1Vq8NlqVnERBfhSBtoVhzeUgyfDFS9U1s2mTksigbOzqdeXU2IXJgr2+OI7+88dAvyqvXFb9su3q2sA5wTUu5WhiXvai5njbtimvbSgNUvVduNSvrt2qZFP5vOqrbfs/eaHk6+pVSEareZ+MjqIMb9p3XszLmNQ1g4PTXhtU/7DfJuT8oNRNtynctFEcAxH7R30HCSGkCbg8EhOu5X8C48YJIaRZsYRd5MZJe3PkwLGXK/kB2n0cCCEtgdZiv2k3T3adGv5Sb8j+hu8EIYQ0AZfOdtXsZpffG/VvzRNCSJPQffdTQc4V8fIDfKXtB4IQ0tQcOXBst679TSvbkfzL0L6pVNGdj9XBMP8aWYR8DV1F6QyCMhpLc0kcCp7M66UJckdK50oj6mQOWAVKJGT4v0meo5NmCJCklA0yDpQSoDxFDgc65QRhALB/Obixw7txpoD3wbUwJz2gjZGyDux/FGU2cF+N6wps98mli21bjrOQu3BeLweyDWOr6x+eLhnmSnZLJ8kRi8hyyl7lGGiG42VyoMlp3F+wbdg/7EutrM1/bcAwLpamDDzfYZDc4DXSUWnK8J5CsB1FTX2m/qF0KY/vj4Vj+rWPzcD3h+69pmubry/ecceb+Nvunhbl9yeKLhPEEkKalJ67zxt+Y5N25RNfe/uc61rzVh2JxNyyR2F8QiVWR1lIKqUiMztinowBAjgL4PQTBCnOtWtKEoAfeXTyAHSgCQbV05dJErQUY+PKRUQ6n0RjqlyUzrwEcpnNIOUYG6vKjtChBh8n0TkEA1qDXjtRToLyFBtkHwWQtWSgvJIng+nsUNKTLYNq3LDNXV1KhjE5VZWAoLsMzgnelwD3npInM5GuO6JO4hMF2dEMSKKkpKYIbjXo7oMOQpOTSioV8BxYsNxYVPX1latKChIBd5gijOMtu6tOOCjdikb98rD5dnSr94GURxWKegchlJCl02pdyuvj4NKD9aE8RboeCZC9XQcJTBRcbFIp/d63fJ+MgSMOut+g7G1qSjkEOeA+JOcY3zv4nopEVF8QKcNCJ6psNgT3qX7j2pbOOum0WgMoE1oKT77zyscP/8N23aVNn3z1NWdHekK2tfzfZIQQ0kBc+laP6wYqwlN/4kX+8Ic//Gn0n0Cgk846xMcnf+BvlsiOTgghjYlp40S0wuZJhdtHRgKmb6kJIaRRqfzeesPjI3YgEH8PPyPyhz/8abYfx4n9Pp11iIlPve2v+XROCGkqLEv84WLtbXrZDvKk58Aj6hxVpCOPyQEEXWDQnUPuyOAYoQzFtGEjQ/eDOt1PnZPHUk4y6EaDjj0oO6iVrfiqqwlTxF0mB67JavQpQY2ERNTJNGzvHygVQZ2DST4kwdtiNZIiCCeEa9ARRY6XUyPTgLnEjsNL2S8cN3RMceHikMaBBbuBUhCUpGhUGjWgZAjbnzRpezxQNpZGRxiDVEpenzJoijrhRqxbtgllXnhfxuDSIw93oDsTTCDOXwgWYLLgn0vM5h1y9P2W7Ssb3LNwXHA9o+uUDKUNQB0mOZMuKUlpGXIflAQ5Qro2ueKup84tXJZ8+t7/p1RM/ztfBYQQ0oDYTuRM153DBzg3ZCmOnj68+MPNCpEOOiFwwYl1qLD8iQnlVNLbq6QQlqX7X1yB0ovt2yd85ytkMlUnkmhULzVAULYz0F91rrlwUbmT7No5vvA6nUE3GlX2pctV2dHOHao9KHnIgPMOOvZISYrOHaieUkmVd+26arOUdfT2KBnR1IySZqArSwEkM7t2VPuFkpVkUgUioYwrlVL9LrvVMsqGaUL3okhYzX3Gc9aJgbwI5UzoONTZoVxzrnqynO3blbzo+nUlG0O3lv4+1ebL4A4z6EmsJidV27ZuVeWNjanygiC92jQw4+tfHqRnkxNqvDZvVtdevFjNyb1rl1o76DSDEpdNm9R9Vz35Gjr6YBsuXOyD+9R8Jz35UzAIn13hvYZuQuhslQTZlO2977Zvn/T1ucLsnFpTOhco3ftoUTzJkwtP4vjeN0l/JDqHHaQlIk8kdz15btHOEkJIo4AbJxUSe8/8X7YT+yoniBDS6Fh26EVunJAV0MPBIoQ0Abcs1cSW2jwRVQvj230HCSGkgeiLWG/QtabrzjM/aDvh53wnCCGkQbDswHT3Xedexfkgy+XIgWPTQoi9HDBCSAPzFc9ufVFaSrYjuXjf/jdM591vyn/LEP1aFw69DABlNFLqYHLQQElNtqSXbOjuC+iVEDX36dQbKNlA2QQim49SF5PjCBax8BquzWtkRNUysC/VG0wZex2D/EEGCGJkHjqZmKRUeL08rJMDibqxxfIK3o3oeoSyJccw3/IStEQpG+RfeY2MCWVJcxqJTD1SkmLa4TStW2yzfGkb5iFf466kjsv1Y5IfYZsszfsKJUwoDUrpFja6+/jOVNGoyuaRY46yGCzDNbzWOeRg00JQCB7Xycaijv73QI3DEdS9KWq/adep4UU3SKafvGvKLRe6fScIIWQDsSy72H33eb0tAyFL8Kmv/9DPxaKZ31n8KkUaHHZQliOpceDRnK9nclJJKHp7k77zSLGonvYCgaLvPMpQouDkEYRrZ2eVHEE614TBtcVx1NPzK1dUcE5/v5Iu5HLVduTBESefU22TTjOizoFGSi+ujyoJ0wCUK91XBDi/VIjHlWRoOlktL96p+teVQOcaNQboXiRlFiixQKkEurIEgurJXtYzMQnSoLS677ZbRqFt6hopK0LHFXRfGhtX7QwF1Zh3dVf7EgHpCUqicE4GQTpzfVTJSHZ6EqUZaA/W1w8OOpm0apMcrytXeheOoeyou0vJhC5dUpIa6fSzA6RGV650+87P1zGo2ixlZigbQ4lPp8G9x/XWrXSwEfOOPmoNI5NTIJcDqdeo59SDMiF0wRoEB6dRcAPatGnaVwcyPg7OXP2Lv59RytfXp9qGUqNP/+DycjSZPqs0NTtPDX+rN2x9qBX7RghpXjZFrY8ttXFSofuuJ3ssO7j4/xqEELKOcOOE3Cy/+tDf/a4Q4gMcSEJII7HcjRPRqpsnFbafHP5dbqAQQhqF6sbJyOeW25z5DRTL9n/dRQghGwA3TshqcOTAsUeEEJ/nYBJCGoGAU35gJc1oSdkO8uK9+7+YLJTfJQxSGGGQ6giQIJSFPhTfUNyC/CEAegaUm+QNGgSdbAflFrjThfIblCzIok0ShYjBHcbRSBdMch+dBCkNB1HKgn3CsQvY8n69ow/eGNRIbsT8OMrz+v7NGtyVdHKfkqZPok6KI2UytfIvvM8v6UBCBicgHE90tyloykDwLK5hXF+W8MtasN8FQ0ZzeU2HQZKCn+ixmXJsogZJlMmdSDreWDCXNb+aUDa2hAwI5VGGImpkVY7tP29yQ0I5nByPDkN78L6+iP31W04Nv8XX2GUw/cSeguuWAzdyLyGErAY99zzLhPxkVTl6+nBlE+V9N1JmwZPUBDVyGjEfoq/C+fv6Fg/nLxTUf68WONNMTKow/80gH8hmqw4zU1OxhWORqJIxSOeXCrGYOh7ynFYcW8lG0KmkRnICkqF8ripbmUsp+crWLcq1BJ1WCgUlOZFymJ4uJbOJgENQLqfaeR0cdjpRtuPJgLYMqjFE1xJ0KkGZ02XPIWgbSEvyUN/oGDjJDCgJxbXR6rx1gxQJSc4omZYFkhM5zqk5NUa7wY0mkw3Da9UOOd8oU7l2VY3FIMhesH8oeRr31loBZFWBgBqjgRpHGyWZ2bzgaKP6kc2p9qNs5xWQ9vR4UiOUBqFrE8phslnV5t27x+b/RpkK1jE1rY6jHF/2qwQf7hxwUYpG1BrHcUH5TUdHzvtbzWsZ1jvKh9AdSvalr1+tkdlZJU1DaVA+r+ZVJysynU+loh/5xFv/7rd9NyxCy0aeSG49M/zurrD9j74ThBCyDvSG7G/c6MaJ8L7tZQQKIWSj4MYJWQuOHDj2fkagEEI2kM+vdONEtEPkieSFe/c/liyUD8l/Y6QBfnOOiSLlNbqIEFH/rTwUIhNIZgxJZHVJT8UikRC68whauAe8i7K6Agz9w9c1iTKhoQE4XhNNoolcwE95QUN9st94HsfCFDmDY+BqzncYkurW7BJ6l2AUBPYJk7mGMHms93e0JgpHXYtRHI4mggLbicMWNGxhyuZjdAu+XXFnOAcFYuSFjJbRjVv9cWyGjLAwJTfG1xjtI/uI/cNya8fAH31jmuua5KuaKKLltNMYBbVEQt+a6K+a19V/FA0RQpWIqa6Q9bVdp4bf5jt5A0yf21NwRYkRKISQdaPnnucMTx6ErA7LjUBxXfU0USxWXweDN/69gkxuqUtsKeqSW64k0SyC3/J3et+6BwIq8gSTWBZLKnJhsyZRJiZcxYgPjDzBpKY1Hw48MInq5VfUfb29abhGtaPTixhIp8Nwrep/TULfmIpYGfUSeXbEVDunplTEAEbZ9PaqaISJiZjXPzWvOYjoKBTVfX3Q5mi4Gklg2erpE/uahkStobAa/1zWn4wXE67e4kVriPmIItXXYFBFLsh6MBIpCv0OQJRGsaR+nXbFq4lkr1xVkSI9PRm4VrUjGlFjOzdXrceGBK7TMLYORL3s2D4h6rl8WSWf3Q7nr19X66G7W42tTO6by6kx2gVRPamUqhsjS4Tr/68jnVHrCNdzEJL44nzLZ+54XJWLn4NC+P7XrHdE087Pexu4K8bwsa31uO3M8IM9Yfuf2qW/hJCNZTU3Tip033M+aAmHESiEkHWBGydkPWAECiFknbnhjRPRTpsnFW45NfxWbqAQQtaanpD9jdXcOJFUN1Ao4SGErC3cOCHrCTdQCCHrgWWLL93MxoloJ9kOcun+/R++ki7/ljxkL/GIgJIAlO2YkmLK61FKYZJNGCL+ayQEujowoWV+iTmskT9Am1AuItuK1+JrTIaaBs2DbCcm/6yRWEA7LI0Mw9T/OAw6JunE9ZrTSIZMc4lzKBPN2pb+vA0N1cmfQoYtxzy0ByVdMhitDG3Pa9pe3w55SUSTtLa+Dlwb2OK4p/lJwSAWDdIYRCeJMl2Lx8teozGpK46hLmmwMMhvEFvo17s8atesW33S3dISfcG6cc3pEuIKSCZcqknGa4nukPWnu04N/2tfBavI9Lk7Cq5gEllCyOrDjROyUVQkPNlseEHCEwG5AiKTP+oSQy7G7GzHwtm4J5tAMLQfk7mi1EbKh6amVVko/TExNl6VBOVB/oBymdlZJWno61OJPKXEZTkShXQaZTTZ+b8xIS7KZcbGlWTIAQnI1i0qyatMVJpIZFXVUJ8NyWNjHeoameizUFD1dXer8zj2KG2SCYBDIdXXOZAGIVlIzCsT9oZA/pFKqfFEuU8ZpDNlT1qCiX2xzTgWCCbblevBBZlKNKr6euGCShLb0anWlExuG4+rY+m0mqtYh2pTGZK1SikVzmUur+7DxLWbN/vlXwjK0eIJtRYxEfNMsrrOuxL6OYtDklhcRzX1eBI5TAyLfUrEVRn4WdFxqvM5Dgmgcf0tmQwakvx6fbqpiBOJ4WNga7Pj5PBvb47av9COfSeErB29YevDa71xIuYjUJ5hBAohZFWp/E7hxgnZSCofbCzLPcpJIISsMquycSLadfOkwu5Tw5/lBgohZLXoj9j/YcfJ4d9ZrwGd30CxAjPz2bP4wx/+8OcmfixhFSu/U3y/aAhZZz5++GsftSz3ZznuhJDVwBLiZ1Zr40S0q2wHuXjf/jdcz5a/KQ/VyCak245GbiIWcQORcp6MQZOC9wUNcpiIvMhgF5I3lC3rzqHEB7QGeN9y5BsSk9uJdKzBcoO2XjaBx2VQWQr7jO43UAe65pjkT5KAYWxR6iGb5MB9QZTAGFySZPNw3NAJB+UiGLgmx8Y0Dyj/ymiO4zGcdhyvmobCNbLfAcOl2KbZon/94e5q2jBXNbIx+dKwngzLdmFesUum95rO/cokD0MHJJOkS45zCY6VDTI03fug0rb+sH37zlPD3/IVvg7MPHnXtXIpt3kj6iaEND+WHZzpvvvpbk4laSSOnj78oBDi2GJNQvlAd5eSutQ404RB2gNyF53bjomr4IgyOFh1tLGsxSUK9WXL49GIak8qrdrZDxKEbBYkJwXpCKOedDo7lZwJ5RsZkLLMzVXL2LVTOaqkQNZTAnefREKNHXL5clW2MzCg+lHrYqPaHwqrYFg5FyZnFym7EnXuKWFvrvIgQxkHR6JecIHBx0k5Bp2dypVlDJyT+vtV+69dU8c7Oqv1JeKq/yhlcUCuFQcnGXS6kbIWfMZEWRK66RRBPiQvjyfUXHZ2oKuMunZqWjn59HRXy8YxRJcbKZmqEAAZU9wbG5z3Ihg4RiNKajQ6qsZg27bJ+b8vXVJzuWOH38VHzK8/cNMBaVNP95zXZlUfSrNMSJldR0w/9giORzYX8vpqVdyOPvrJH/ibVY1ma9vIE0nlA889T54zfKwihJDFufOJc9ZGbZxU6LrryUE7EN2w+gkhzQs3TkijcuTAsceEEHs5QYSQGyEQKB9c7Y0Twc0TBTdQCCErpVF+b3Tdee52Jxj/b74ThBBiwA5Ev82NE9LIHDlw7Hzli2tOEiFkJTh2edMnv/9vH1+LQWt72U495++5x5XSAp0jDDqcpJZwPsGRNUk2EJSA6NxvUPaChRdR1uFdgp/ogjVyklpnEFWf6ysXA6NMEiUpBwmg8xBcgI4+jsYxBV2DTI49Eai8WPL3NYyyFzhvUrXIS7BPYYOjjc79BqcP+1cr8fGPR43kyCDHEkscxttw51MfxKZuwLEwLKOaNskxzxkcnkzuPgtqM2iQKTAPx06OP449yplyS8jNNKZI8+jccUTdGpV9xfnJGNohX9q2EK89O6Kbog1l9vz97y7mp7/QaO0ihDQWlc3WxN4z/47TQpqFo6cPG/6nv0E8d5SZWSWJQEcRROdig1y52qv+Ba2scWvROORIN5sK27ZOQhnq8eKiJ33ZsV2dn55RbUapMkqXpGwFZT3YuFAYnWmU/AYdU4rFqsQDZUImmRM6FUkZCUo9tm5VYzE1jXIrJcVJJqv96u1VEqaXXx5YeL1799jCa5TXSAkIOt5kc+C0AvKVmRk1l7t2js//ncup/qMsZG5OXZvLqvJ6e9U6uX692g6zlEWVgS48EjnGYn49gDxs88zCa5RKTU9Xy9sO6wFJgTsRrpMtg9Xxz0NZs7NqzkpFNXZYt27dXr+u9tx7YCymQV60aWDGdx/K6dANKRhSY54A9x5ZN67h5CxKmPRysyMHjq3p8zkjT+rYc+6cFbKtku8EIYTM58cRxUbcOKkQ33Pyi06oZ7cr+Id/+Id/9H8Coe73cOOENBtr/YGIENL8rMfvCW6eaLh9ZCTQEbAWN8cmhLQdkYA19n1nRhrakSKx5/ELvfu+xYdMQoiPQKh3d2WT1XeCkCbA+2B0gXNFCKnjwnptsFK2swjfu3f/Nybz5cMmyY3B4GRB1hExOLigXMGg4FkobzmSIZ38pATzWjDUgY4pUoZR1kgihE+Sol5LCYVJJmSS4sgysL4Qlov1wWuUB8m1a6EsydXLO6LQGSnJMMk4lsLk2oKLwNFIUrKGOUPJjU4ShdXl0D0GjmMZuvWF5YbgvMlJRpZRI58yjFeNPErKWrBP2DbLPw8Q0qUHAAAgAElEQVSISR6G4PtAOhHhfQWjhgn64vjf01HN+wHb0Re2j992ZvhBX2ENzNS5NxZdt+w0U5sJIWsDN1VJq3D09OFHhBDvM3UHZQ7BYMF3HsmBK0gYnHlGR5U0ASUI+WJVvhFaolxR55iic+cpl9Vb0rbh+RWkHOPjVVnI4OCU0IGSoa1blJSjXKqWjW4vHZ1533kx7/ii5CTYL9l+dLwZ6Ac5Bshkrl5T4xUIVPtagjoSXUr6MzmhpBfRmGpTX29VEmSUuhjqi0SrbY6A4w/eh9KfzZtnfdegbAfHHl1skNFR5djT7TkAoZNMKq0kKZs36b+Lv3ixf/7vnZ50SCyyFmudd6oONPFO1b+xcTU/cgzry5DOR+h6hFy9ppcMZTxHpViHX3IkFll/iM7Zaqn3xgr5/GpaES8FI08W4VVnht+8OWK/0XwFIaQdGIzab2q2jZMKPfc8F7Dt8KjvBCGkbbDsUJIbJ6SV8D4ofYCTSkjb84H13DgRjDxZPs/cs29+oIoY2YBRAJrHkrIm0kIsErGiSxiLCUuLhiiNvKEeXbmIo0kAit++ZzARraEO+QU+ng8bvsHXRdFg9AHuO4ZhWw8jZ3QRBroIGrHIGOnqwLoxckEXoYDDiX2tLcOfUNU0hlgevpbzrWvDYuXhjqg8XjTMD7YzpFk8OU0EhqibB120iC6CRtQlNquJhvFOZE2hWJo+CUPk1nLGC6NXct57Gt/PuHb2toATV/Lpe/9bsZD8Gd8JQkhL4wRi3+m689zrOcukFTl6+nAl/EAfkrEEMsKgXNZ/jxwKqW/t5TfnFcLe8TIEdWYhmWgXJEDN54O+azCyYTN8w4/fvs/NqcgMGTmDyVBzUG4eEqMOQIRM0YuQCQRMafuXZnyiGvWCSV2xvOkZlfg14Kg4487OjNdnFdERiagIE+wfRmwsJIqFvmIUB0YrFIrwOl8d0xyMxTZIUDs+qeavJkrcqf6jr08lqMWokmAI+wSRHmOqvKgX9WJKXirHUNRFi8zNVfsVi6l1Viiq9kcjKlJnqegpHM8I3BcIqPbLJL3YztnZjoXXmDS4q0tF3OiS3GJ9nZDgFRMr4/O+7MvEpFovfX36xMM6MMFw3Tj3HDlwTB/as4YE1rvCZuWOcyPWd4b2FYpFjhkh7UDQsUqV/Eet0NXE3jP/Nnn+gc8U8+Mv+04SQlqSYKjvPcxvQloZ74OTtepOPISQhmYjE0jrt1uJltedHQl2Be0XdOcIIa1DImQ/3yobJ5JqItnvMHSfkDag8l7nxglpF7wPUs9wwglpeZ7ZaOctynZugAv37fvR0az7l6Y7pSwis4wksTqZhgCpA86OKYEmyhRkwtQaKYi1fNmHTgZRj06ygfehfEVXh1jGedNx0726a3FnsKgpTycBEnUJVfOaHEZYB8qccroGGaQzCMpadPWZrjVdWpNI1qszZJCymGRhEpREpUv6+3TtqJk/PGGQK8kgVgwuxZ0LPI7yoqJMdGxo83JkQPISKePqj9gPbz85/BXfhS3E9BN3jpbLmYFW7iMh7YhlBbM99zwb5eSTduTo6cOV3Ad/kskoqUc0mtOPhCcNyRfU08ZcSskOMLklSm1QCiFBuUKppK5FaQmWd7Og1CWTVX3tSqQWXkupURTkMvhaWOr56MoVlfSzMw6yD0+KE4thclIlaylB/wJBNS79ngxmAiQrKI1ZCSjZcEFitSDxEUK85CWEHdQkgxV1sqscSKxkQltMZlssqPmzHfV0mZpTspaeXiVrKRSqbZIynPnyYAzxMbRmfiarYxOD9RmB16mU+jWO0jJ5TQrW6tysals4ouYBk/tKiU5yVrVz21Z9gleTLEcHypL6b3COlyLptd223P/0a9//t7+6xOVrDiNPboBdp0b+6p4nz1mYM4QQ0vzseeKc1eobJxW6735qUyDY/eu+E4SQpsUJJP6RGyeknTly4FjFhaeHi4CQ1sKxy5saYeNEMOfJzXHnEyPWt/ftS6dKLh9WCGliOhwrd/u5kUg7zWFi75lfTp5/4I+K+THmQSGkyQmEBnZXpHmcR9LuyDwon/7622ZdITrbfTwIaXJmPvUDf9PdSF2gbGcVuHD/vo9OZtzPypIW5A+GwBSTTEMnoUBJThZkEygdCaEsx5tPk1qhRtKhaZNOgiHqHHuwaPkaJUW1kiGoDwp3bP99pnaivAYlSNIpBscCl3Otw4y/zTqZSn37axxhvDJMc4boxtE070vJkkzyleVIlOT6KcHA4NoI2no5j5S+4DGcSwdGCR2oZLewDp3MSxgkSuiCk4dyC4bxkvWY1jWCciwb2t8dER/bdXLkc74b2oipc3tm3HI20c5jQEgzYlmBUs++b/KLMEI0HD19+NeEEJ/wn9GDUgmkoyPjO5acVfsynTElx7Ad9eyCbibSMSWbUxILdFQJh5WjCrr0oOvPUszNRX3lFUCWhA/wKLMx1SHbH4+r/l2+rCQ+KCfZuXN84bV02ZmYUGO0bZuSiIyOKekPOvnI58y5lJKWoLsKzo9uTpALF/sX/rUd6nZAiiMlSFgHyrLQ3efaNdXmKDjkZDPVuUKJ1o7tE7721DM6Wt0PiMVQqqP63dmpji/V1zEYTwfWH943M1Ody02blDlNLqfWGa6/2Rr3nqrUK7hC1yYsI76E9AcpFMBJKh/43U+89e8+5Ltog6FsZxWofPCq2Jnapk/BhJCGw7aFuOOJEavdN04q9NxzvisQ6qGMh5AmIhDq+iI3Tggxc+TAsV+jjIeQpqSvETdOBDdPVpeKnXFn0LrSSn0ipBXpCFqvvHFkhLudQEXG07v/nzkmhDQBgfDA7sTe4fdwrghZnIqMh248hDQNl3/x0D9Yv3joH/TZbBsAynbWgMv373/9eLb8rYLJcQSokcCgzMSTLxTKeqmOSZYT0MgtdO4kYhHZigRdSwrQuOASMiGUyBQMdcgSTLIdkzuRSWaygMH1RxcUtJw26+Qwy5GI4FeBUqKUM0hPEJRHyXaEDH3GMoqGshdkLSjzgn+UYV51UiK81rQWcd3q1h9S0zaoT5d72dRvXDM6uRneh1I3KWHqC1tv2H5y+Nu+CskCM0/tGy4Vkvs4IoQ0FrYTHeu+++lNnBZCVs7R04cfFkJ82XQjSlyCQSVTQLcWnWvOTFLJcyJh5WgTDoHUwfI/F6XBMSXWodxhdLIddPRBh6AIyC0CIK3Iei48EZAGjY4qeUdXl5J0mGQhV672em1Q5aKjCso+UG6RSldlOy48nKHUBV1nrl5VgUGWN0aBgLqxv0+N98SkkgH19fnnoVxSz3+vgIPQjh1KRoNOTPLTSDKpjqEUqbtbyU3QtSkPfQ15ciwci3QGnXfU2KbSSnaUyzk1fRbz46KuRSejIMiq5jzpUrms+oqyo2vX1HgODk4tvJbrYWZGraPNm5Ubz0pAtydcG6WSajPKo6RbVQ4ka4Y1984jB4496jvaYDDccw2ofDDbLoT13L79+WypHFz3BhBCfIQdkXvt2fZKCnujdN05sj95/oFdxdx1JpMlpEEIhDe9N7Hn5Bc4H4TcGN4HM+vo6cOVxA9dHEZCGoKZIweONVRS2MUwBUSQVeCNI8OhTRHrXRxLQjaWzVH7F7hxsjIqzh29+79r2U7HWDO1m5BWw7Kjs5X3IjdOCFkdvA9qH+FwErLhfLKZNk4EZTvrx9P33FPKl/ybVY5B/iB1LSaXG5Qu4GupWChrjtWjU1agI4zJXQUlPLJux3Bf0aBrkde7NZIc9bpgaH8YCk9pND8ovykaxkjWrRs3Ue8WBK/LmmOITk6C95kkRYjWmQYdhOBakyMROtPIlyHDuCDYL3kJrpHllLFQ7xLnRV375bSGDZKbGomSZpyLhnUUsK3ym0ZGHF/lZEUkn37gvmL++kmOGiHrSyDU/6HE3tO/y2EnZG04evrwwhMEuqtYlulJrQrKVAoF9ZgRA3nH5LSSmUhXFZT1mNA6lbjqQeg6yG9CYfVkiPINiXS+EfOJ8uH5HSQWKEkZn1DGe9GI59hTVP3r7lJ1aNtZcfDz+o3tqXXYUbIdlH1IJ5/t21W6C5TfbNmsZCij46q8wc1VB5kaZyF4qr1+XcmusGwpJ0GHHRznFEilciBVQelW2RtH29GvFyl9qrZIjb90xUH3G5QU4ZzowLWKkiGUaemQ8h1RtxbRBQrLkA5HHTElK9NJ0BZDrjWnboy8XERNh+/DPFkb9p475wxGrXdzeAlZHwYi9o9w42R1SOx9/FQ1CqXzUiv0h5BGZyHahBsnhKwp3gc4RqEQsn58slk3TgQjTzaGf9m/L5UuufPbtfiNuS5aBI91OItHXSARR78mMfGmLmEqJjU1RcXo91b1mKJeJHgaP+ViHa7htdwDhv3imvowWsaFO2UfsX8lQ4SFbpgxqgTHC48HoCGyuDQmL8UIC0zECvXIooOG9piiO5Z0zDZEaRQ0ZZvK0rUTwbbVrCPflbX1mcB2Opiw2LsRxz5oWdnbz41EDUWRm4S5UAhZWwKhzfdXNiw5zISsLyvJhYLJSW1HPcRMz6hoE4zSGPMiLwYGVJJOU4La1UBGkGCC1+vXVddKkBh166CKfsCoglKp+mTuOPikrcAohvFx1e/t26sJWvE8fo7AqApdMt4sRGBEDBEYs3MqSW8smvHaqZ5Ir0Ai2k0DagyuXcOkudWy43EVCYORN5jsNQRJW4tFNW8ySS8mQy1CstcOSASMyISvGA2EzM2px1iM/NFFFyFFuBYjUkztuFlSkPQY65icVOPY27sw/k2V28QEI082gNcMj3QMROw3tF3HCVljKu8rbpysLTIXihPs/qfq1hl/+MOf1fipRHZVo024cULIRuB9sDvMwSdk1XlnK2ycCLrtbBzSkef5oX3npwvuHe06DoSsBl1B+8lbzwzfzcFcP7ruHHlrpbKp4deVXFHgRjwhN0EgvGV3ZWOSY0jIxnLkwLHHPEeeyt+HOB2E3DiW7T535MCxN7XSEFK20yA8ffe+cr7s+kQSJskDyhyicFHG03WgLCTv6qU6KMmQx51a+YO2jJDh+EK58LpokG9I+QnKi1BShDIMLAMHSJZRIz0BDUkIx04j58katCKmMV/4h2bcRN146mQtmAw1B/oblL2YZDK+NszLiwzzoEk8jGCbTeO87PbUIfuYgf6FDbIjnRzLMCXatVMhKCxx51MjTaubbBWSTx/4uWJ+9HfafRwIWSlOaOA3uvae+TgHjpDG49PHfqDPLVvjKDOZ85KkdkKCVAQTsaKMRCZujURUkk6UWGDS0lFICBsIVB96QPpglErk80qmYXnyG9tWbcD2zEGyV+wLJiIdHU14x1QHB0HiU1ufuiboSVlWmlhUykzCYSWRQXmUCw+1mAhXJ0mZSSpZTyqlru1OKCmOLK+jQx1DqQu2w8SYl7gWxxYTytaAH0bk2OiOQdJdUZeQeBPIviSZjFoP0ah/LIQhaatpHa0GFWmTZZV7f+GBr0+tasENAL8tbBD2PjFiD0btltqZI2QtqSRg5sZJY1BJatm7/wXLCfaca/exIGQ52E78UuU9w40TQhqXXz78tYlfeeirleeMD3CaCFk2H/iPB//RasWNE0HZTmOx69Twc7uEsF64d//xiVz5YLuPByE6+sL28dvODD+oOUU2mK47z+2rtGBy5PascCFTHCFkHksEyz37v0MXMEKaiCMHjj0ihHjk6OnDjwoh3sG5I0TL8SMHjrX88zllOw3Mt/ftS6ZL7kIaapPLiw6UW9TIOwxuOytBJ2vBslCKkwWNhU7Kgs42+SX6VI/c+XMNkg6nRqrjr1snUxHLkDxhPwLwjyK0XyfFKddIbtRr7LfJhWfhvEHmZJTquOb21LdpKYkOrj/TXEkJlalp+A8sQpaN1wbt2nXUGbBm3zAykhCkKai48hSyV+nKQ4hHMLyFLjqEtAA+Vx6D9GIpdE4zok7O43hOPpaFcguVFx8lJzpWKs3ANgUD1TrRjcYEyn0mJquSE3T6wTaXwemns1O13/KeApMgKXJAdoSSmjI8RPb3V+spFNT5yUlVRiymnIywL1c9R55oTMlzYiDRQocdlNEs5XiDzjvhsJJp5aF9oeDSkiDVF61zzQLJWdW2RHzxtiG4zpIgc9LVsQQt4aKzXCjbaWBePzKSuPvJc1bIsQwfVQlpfYKWcPc/dc7ixklzUUl+2Tf0ghUMb/pQu48FaW+C4f4/rLwXuHFCSGvgfVC8hdNJiLilnTZOBGU7zcGbRkbmtwafvWefW2akEGkTKoEnPSHrDRVnKs5581LJhyKE+N3k00N/UMiN/3S7jwdpHwKh3q933TnyFk45Ia3HkQPHXvZceSoyhWOcYtJmHPacqdoOynaajIv37b99LFd+DiUiJhnGcs8jKEMxibILhrolJocdjGR0vHos1JigLMTgRrMUJhmNjqDBBabGjQbuC3idMcllLI2cCcszufEUDdIZKWWpOQ/3mabSrZEHWV4Z6qDO5aYeXZuXI/OS15vccUwSMnlUHtkcsd+489TwN30VkKZn5ql9/1TMjz/EmSStSiDY8y9ddz35Wk4wIe3D0dOH3y+E+JMb7vAKpD/oQFMGuQw69uiYnVPSjBKU0d2lpB7j4yrIV8phrl1XgQWDm5XbDrZjZlaVvZSsZSWgow/KaLCd3d1pr//FJUtG6YxjV8cL5SvLcdjRge5F2E58faOYHJxWQjpTlU0FQS4UhPFC9yJ0hNLwAS8HUNvCyJMmo/KBcqcQ1oX79r3rWsb9YruPB2ktNkWsd+06NfJXnNbWRX4Tz00U0mpw04SQ9gWSyt7cJgohjUnbb5pIuHnSpOw6NfKXu7xNlNEsN1FIczMQsX9016nhL3Ea2wfYRPl6MT/+5nYfD9K8cNOEECLhJgppMbhpUgdlOy1CRc4znnOfkzlRUCphcr9B95TiCmQaumuWcompJ+xFoC3lGrRY3VICshyJj05eZHJ+QdAVR45RCPQ5OjceEzpJjqiXF2naiYdqJTDarggXyrO8axxocxEaanIckixnXmuyTmvaj9RIomwhBsKU55Aq3EQhzUYg2PPdrruefA0njhBiYrFNlHRaOeHEYks74ayEcrn6QGbb6sErk1H1RaPLr290VMl24nHljhMFZxpESkCKRfUdfWdneuH1Um5BOmmNmJfHq77kwdEmomlHoaDqDgaVPEUngUHJTb6gJDzogLQCWUsN10HyZDuq/Yl4dTxMMiGTS5KUXuG4rMbamQG3na7EvCMRN00MMPKkRZBynkpvnrl7X7nkukt8jCVkYwgKS9z51AjXJ6mh686ReQlP8umhPyzkRv8NR4c0KsHwwJcSe4d/lBNECFkKiERhYlnS8ASc8juOHDj2vzlTZhh50sJ8e/++mVTBTWBgQ00EhibZKUY2BAwfb4uaqBZM/hmGSqya+/yJVnGLBxPR6iI+6tssC8ckpBhZY0JebkraioThooLuGkMyVF2UBiZR1SWUnS8DI1Jqu+kDu4plB6EdBa9w2zDOxmgY1982JGRIzCtfYrmybTHHSr92eKRDELIMkufvf08he/kvOFakUQiGt344sff073BCCCE3ytHThyuhCBWnnq4bLWN6pnPhNSZ7RdJe5EKsQx+VoEsMawITw2ayGBGhokbGJ6C8Pn95Y+OquwP9M77zFUbHqtdsGlDnTdEyGL0S8qI3goaEsQWIZMGEqblc9ThGf0xMxhde9/WqyBNEFzG0nP6tBIyGwagdydS0WgOYoBePY5SNnBNDRMvMlas9d/znH/3SBV9FxAcjT1qY1w+PzL+TX7h3/2MTufKhdh8PsjF0B+2nbj0zfBeHn6yExJ6TXxBCfCF5/oFdxfz4d91yJsQBJOuNZUfzgVD/qxN7HudDJSHkpjly4FjFrmZey3H09OFHhRDv4KiSDeIrRw4ce5iDvzK4edIG3HZm+MHbhBCV5LLjOfeLpmgCQlaLgGWJ3rDFJLDkpvE+tIbFfF6Uu58o5se5EUfWnECwj/lMCCFrivzgulheFEJWG9sWP/crD/3973FgbwzKdtqUb+7bl8wUXRWbJiPyNFIeoVfLmG4TQbwRk8vCrk1es+y0SV3rJCkljeSkRpYErwPW4jIanUylvh1BlLu4mvb4i51Hp46qkedAQ/OGbLUL/cO2YR2G+cHro15jc5r+i7rktzhGMlEsHgvZQgu2vztkTb/m7EiP7jpCVovk0/e9t5i//meuWzSsSkJuDEpzCCEbhSfpOV8x1axvAkowZkHSEQ4pyYkpgasOTMoaCuqTlhaL1eSpgUDJd65CARLCohxEgpKi5KxSbcdAfoNlSzkSfjSNQZ9QXoMyIfkQbJIfmSQwUuKCshcEpTg93Slos14epAXyE0xOqY9dvb36tq4hlS+i9niRT+QmYORJm3L7yMj8b50L9+376HjO/azhszUhS+LYQvSH7f+4+9Twb3K0yHqQ2HuqkgtlPh8Ko1HIzcIoE0JII+B9sN0tqhspHxZC/BYnhtwkHzly4NhvcxBXD26etDm7To18bpcQn6uMwvND+85P59072n1MyPKIB+3nbzsz/GoOF9lIuu584m4xH41y//3FwvRX3VKSSYnJklh2ZyEQ6n1zYu/JkxwtQkij4X3gnf/Qy9woZIUwl8kaQtkO0SKdeuQ5B4LjXY20ByNXTBISlMNIZ5oSFIYSGJNUxaBwWSACmpoiFGJppDYmlxsMTjT1RfVDvTbJb5bCJFdaaDu8xjHCvpZhHHXOQShRwnYuR4IkiTmWiAWsiVedGe73nSSkgZh5+t7fKOXGfsF185T1kBqCka1/nNh7llbYhJCm4zPHv/9VrhCPhYKF7Uu1PTlblaQk4npJymqTzYYXSoxEli8fQpaSCSEo2wmHqzKaOLj/CGuJh9plMDGhZDaRiJLqoOuPbfvrQcebgKPOx+Mp37UmaiQ+PXrXnzoqspwHjxw49rLvDFlVuHlCFuXifftvn82753KuuyBm5OYJ9kO9btXNkw7HysZD1r5dp4af850kpMFJPj30R4XslQ9yntoXbpgQQlqNo6cP7xFCPKrLjyK4edIumycVT+SHjxw49pjvDFkzuHlCls3l+/e/fq7gnksV3YXMS9w8Ua9bafOk07GyndwwIS1GZSOlmBv7KdctMCKlxeGGCSGkXdBtpHDzRPMwvEIadPPkgrdhct53E1kXuHlCbpjv7Ns3miq5A6Lug3fNJgnsWhRhrclXpvtqHH3gGsxvHbb9ZZj2L3DjQ24kmK41bTTIzYosVFjjQGNop+0/XVMHUtBsIOG46DZwRN1GSh4uki+xPpM7UcyxRl83MrLZVzghLUjy/P3vKean/8QtJWOc3+bHsmOVHCYfpVMOIaSdOXr68G4vV4ovR0ouF1p4bVnqaTAUWoF7DFAuq4dL3ERYysVmFpx34uB+s5IND7nRIgybLa6rnnCxr0tRLqk+JedUO9E5CB10ZJsL4F4URPcizbUm8nmVirRuTr4ihPgwJTmNATdPyKrwvXv3/1WyWH44XxI2N0+aY/MkaFluV9j6wi2nhv+Vr0BC2oyZp+5+spi7fifnvXlwQgPP207HWxN7Hr/Q7mNBCCE60LWHmydL00CbJ3TJaVC4eULWhO/du//pyXx5DzdPGmvzpCtkf++2M8O3+QoghCyQfPq+95ZKqf9cLkxs5ag0Dk6gZ9IOdH6K0SWEELJyPnP8+3vLZfH7Qljv4eaJng3cPPl8oRD8+V889A+TvjOkoeDmCVkXnh/a92y2LN4oP8xnTdlJPXDDwLSZITdPCoaicH8Cy5NVh/AglJE17FAENZs1JrBsmY/ElBMF844EYbMp792HZeG4LZUrpXK+O2g//yraCRNyUySfPvChUin9MW6mrC9OoGfKDnR+kpslhBCy+ngSn0pkyodk4bghkstV85hgjo/lIMvQ5QOpkIUIGCQSzvuOmSiV1OaJY3sP2LA5MZNUGx9dCZVrZHpG5SOJef3KQL4WvHapDRoBeVGCIVV3ohNym5g3TCr/r/02pTjNBzdPyIbw4r37fm+2KP5ttuQGdPVz82TlmydRxyrEgtaXbz01/F5fJYSQVSN5/oFd5VL2T8qFyQddN7/ENiZZLk5o8Jhth381sffkSQ4aIYSsP5879dBPVTZUXNd9IzdPVm3z5BkhxCOU4bQG3DwhDcOL9+3/QqogHs6WysEgfBwpwKaDbv9Bl8+jHtMGhMQkjYlp5DDoZmO6TydB0m3g1N+naxPuLsn+hR0rH3Gss7edGT7ku5EQsu4kn77//nI596lyYfxB1y1yQ2URLCvg2sH+x2w79AeJvaf+wnwlIYSQjcbLm/KwEOJQqaTkMI6jf+qem4vO/93ZmfGdE3WbJyvZMKkpIwtlRBYvI5OJLLxe6UbQckmlovLKJ8bGOi//lx//wjvXpCKy4XDzhDQ0l+/f/450UfxWtuzuyBXdgO7XdCtvnkQcuxBzxMshR3xsx8nhR30XEUIamorkp1zO/my5MHVb2S203aZKILTpeduO/FdKbwghpHX4zccfeshxyg94myp3YMfaZPPkGc8e+rEjB4495jtLWhZunpCmpSL9KbjW2wtld2vBFaFy2W3KzZOQbRUjjvVK0HL/5tYzI//e1zhCSEtS3VgpPCzKuTuKxcmeZuxjINA7JezwM7YdfJQbJIQQQj71Tz/4dmFZD8Wimb2VaJX6AWmizZPjlc0RbpAQhJsnpKW5cN/+N5bK7k+XhPVDlX7mSu4O2xJuruSGMAcJbmygRFOXf9wxbIJIx5uQI3KlsrDDjnVJVB15vmIJ8d93nhr+lq8wQghZhMoGi5jXkBceFqK0TZQL/eVyLl4up7X5om4W244VbTs8K+zguBDOK5YdOGMJ6zo3RgghhKwWXrLays+DXpHy75rNlkxG5SOJRnPLrt1w33Hv78fg75eZtJWsBG6erDLTh4buF0Lc7cYb68MAACAASURBVL35K98kvqbyubpSS6bsdutqixpsU9J1ERKWJXIhy6psmVZ+C3zXO/yosMTVvuNn/8xXACGEEEIIIYQQQggha8TsMw/uF677RssO3CGEFbec6C2WHeiwrEDJCnTsu5la3WJqxHWLjlsuptxS5iUh3Fm3XHxGWGI8fsdxpjYhhBBCCCGEkAaCgSfLZOrQ0EEhxPuFEHeWhXi1cMV8MiRHHzOiJWNIDLrcwBNRVYBosYS/DK9tFeHJBS8y7ZHu42fpAEkIIYQQQgghhBBCjCTPHxyy7cAPW3Zkrx3s2mU54debrm0k3FLucrkw85xbzj5dLhf/OrHnxFnOMiGEEEIIIYSsPQw8AaYPDe0SQvyKl7LoVrBJEaZR8od7bAx5zTwaYlTqPWFGLSG+KoT1a30nzr7ku5gQQgghhBBCCCGEtBzJ8wd32nbgZyyn434n3HewHWa4lJs44ZZSJ8vl4h8k9py46LuAEEIIIYQQQsgN0baBJ54lzu8JIe5YTvyIaZSaPfAEKXrHLVu4tisuWZb4/U0nhv9v34WEEEIIIYQQQgghpGmYfebQw7bT8dN2uPc+ywokOHMK1y0my7nJU+VS6g9p4UMIIYQQQgghN0ZbBJ5AJpP3CSECvguWgWmUWjHwBIk5NUlfTgghfpl2PYQQQgghhBBCCCGNSTWTSehTTnjgIcsJb+c0rZyKZU8pN/b1cjn/q8yMQgghhBBCCCFL05KBJ16gyeeFEAdvJDZEF8QRsvTFzOqiNYQQ8YD/+pKm3Gp9vkPzRG1/GevNXEnfuM5qQMr3hBDvZyAKIYQQQgghhBBCyMawEGgSHXwns5msDZWsKKXMtS8zEIUQQgghhBBC9LRM4Mn0oaHPCCGO3GhGE4SBJ4olAk8Qt+SK030nzt7vu5gQQgghhBBCCCGErBpzz775153o1n/PQJONoRqIcuW/dL7pGx9vx/4TQgghhBBCSD1NG3gCWU0O+U7eJAw8Uawg8KRm3GwhRi1hvafvxNnjvgsJIYQQQgghhBBCyLKpZDVxgvHPOuGB93LUGo9S9tpflorp/8BsKIQQQgghhJB2pakCT7xgk0eFEHt8Jz1yZX1/dPETMU3wBLlxMoaxj9rWtBDih2nJQwghhBBCCCGEELI8qsEmXf/LCfcd5JA1D6XcxIlSYeYnGYRCCCGEEEIIaSeaIvBk+tDQY8vNbMLAk41jkcAT/Oc1IcRQ9/GzF3wXEkIIIYQQQgghhLQ5qW++7YtOZPBd7T4OrUAlE0rH7V99d7uPAyGEEEIIIaT1adjAk9EH9v9SwRWfdoWwdLYuJhh4snEsM/Bkgbzr/tmmE8M/4TtBCCGEEEIIIYQQ0kbMPvPgxwKx7R+3rECC8956uG4xWUxf/vX4HY99tt3HghBCCCGEENKaNFzgyfShoReEEK/CY3lDQIOOvOFSXYyJKSCCLE1GE8mjG+MKoaXHOSOEeB2zoBBCCCGEEEIIIaRdoJVOe0IrHkIIIYQQQkgr0hCBJ9OHhnYJIb5TiQXxnWTgSUOyyoEnErfkip/sO3H2T31nCCGEEEIIIYQQQlqA2WcOPRyI7fg8s5u0N9UsKJfeF7/j+KPtPhaEEEIIIYSQ5mdDA0+mDw29Vwjx55V2+E4CDDxpPNYo8KRiv1MtS1j/s+/E2ff5LiCEEEIIIYQQQghpQminQ3TQhocQQgghhBDSCmxI4Ekl4CRbdv/crQs4We9AEFNAiy5QIm8Yp5Dlv3a10LXPFFgT0jRD14/VIqtpW2Rt6vvv3cfPftB3lBBCCCGEEEIIIaQJmHv2zb8eiO38Jc4VWYpi+uJvdL7pGx9f4jJCCCGEEEIIaTjWNfAEM5xkNIELDDypq1PTvjYMPJEwAIUQQgghhBBCCCFNw+z5Qx8Mdt7yR5wxslIKqRd/KX7Hic9w4AghhBBCCCHNwroEnkwdGtothHheCBGQx0qaegNrGMSxEtIaG5mYwUcmo+lHhegK+qILMDGxGsEkJd+RKo7vyArLNXTDMHRaTOPpVP2YXFtYP9l34uyf+i4ghBBCCCGEEEIIaQBmnzn0cCC24/O01CE3Q9WC59L74nccf5QDSQghhBBCCGl01jzwZOrQ0DUhxOb64ww8UTDwRGEaT2ybLUTREtar+06cfcl3ISGEEEIIIYQQQsgGkDx/cGcwsvlrVqDjtRx/slq4xdQ/F7LXfyCx58RFDiohhBBCCCGkUbHXql3Th4b+ePrQkKsLOiHkZigLESgJ98XpQ0MvcCAJIYQQQgghhBCy0cw9+5ZHQp23XmDQCVltKmuqsrYqa4yDSwghhBBCCGlUVj3jyfShoV1CiBfQVkeHLuNJpuw7NE/nSlJmrBErzeahu9507fr3RdM4IUROM/6mTC+rgS7TiymjS0ozoLYXNhUQ4n0DJ4b/p+8CQgghhBBCCCGEkDUkef7gULBj59doq0PWg4r9TiF1sZL95CwHnBBCCCGEENJIrGrGk+lDQ18WQry8VNAJIatJUYjPjz6wf4yDSgghhBBCCCGEkPVi7rm3/XGo89YzDDoh60VlrVXW3Nyzb/kyB50QQgghhBDSSKxaxpPpQ0NpIUTUd8KALusGM56sD7qxF02c8WQBV7hBSzzUf2L4mO9iQgghhBBCCCGEkFUgef7gzmB02ynLCW/neJKNwi3lLhcyr9yX2HPiIieBEEIIIYQQstHcdODJ9KGh9woh/j/fiTVGF7QgFglcmNMELqxlQIumulUJPCn5jlTJaCqMGvLZOFaDRMCsHY92Hz/7zlbtHCGEEEIIIYQQQjaG2fOHPhjsvOWPOPykUSjMvfRv4nuO/zEnhBBCCCGEELKRGEITlodnrbPuQSeELMHD04eGri5+CSGEEEIIIYQQQsjymXv2LY8w6IQ0GpU1WVmbnBhCCCGEEELIRnLDGU+mDw29IIR4le/EOsGMJ7Uw44mWYvfxs0HdCUIIIYQQQgghhJDlkv7OO5+wg113ccBIo1IuzDwZe92X7+YEEUIIIYQQQjaCGwo8mT40NCWE6MZjplIaJcShqOlnYA0DMFKaQJCONQx0aQQymjGuEN3YQJdKo27pPn72gu8MIYQQQgghhBBCyBJk/uXHLllOePviVxGy8bil3OXoa/58B6eCEEIIIYQQst6sOPBk+tBQoRKzUX/cVAoDTxQMPNkwKg072H387MmNbgghhBBCCCGEEEKag+T5gzuDHTufs6xAglNGmgXXLSYLqYtvTOw5cZGTRgghhBBCCFkvDGYsekxBJ4Q0OJXIl8cnDg0d5EQRQgghhBBCCCFkKRh0QpqVypqtrN3KGuYkEkIIIYQQQtaLZWc8mTi4P+MKERFrnCmkHUlrsqNUsDRhQabsIfmyv4yQrb+2ZJhzXTNMZaykvgaCtjuEEEIIIYQQQghZEtrrkGaHtjuEEEIIIYSQ9UQT2uBn4uDQtAw6IaSJqUTGvMQJJIQQQgghhBBCiAkGnZBWoLKGK2uZk0kIIYQQQghZD5bMeDJxcOgZIdw34bGi5pbwKmS7SOoKFkIkAjdfti6rSMxpjAwduraJNWxfxlBfVFOfMTuK74gQIUM2Fn0J1SiQ9STnZWmxbJHddHw4us7VE0IIIYQQQgghpMFJfeuHjzvhPlr1kpahlJs40fGGvz7EGSWEEEIIIYSsJYtmPJk4OPQn9UEnhDQ7bllERg/uf5kTSQghhBBCCCGEEMncs295hEEnpNWorOnK2ubEEkIIIYQQQtYSY+DJ9KGh+4Vw3+87QUgL4Lpi1/jB/f+Lc0kIIYQQQgghhJDZZw49HIhtf1/bDwRpSSpru7LGObuEEEIIIYSQtcJotTN6cH8mZFkR34l5+xXfIWFy2jEcXnd0bXYNJjABg2XMStDZ2eisbDYCaTlTz0rsknRlmO7XXbvY9ctFX6p5zelsgxzL2t19/OwF3wlCCCGEEEIIIYS0DZnn//WMZQUSnHHSqrhuMRn9vv+3ixNMCCGEEEIIWQu0GU/GD+7/W+EKbdAJIS3GWU4oIYQQQgghhBDSvqS++bYvMuiEtDqVNV5Z65xoQgghhBBCyFrgCzwZPzh0a9kVP8TRJm3C4PShoc9wsgkhhBBCCCGEkPajYj/iRAbfxakn7UBlrdNyhxBCCCGEELIWBOrLtCzxj47RrKTKWjnGrIYlS8l3pIq+zdqDq0Kj2OroWMl45ldhTlZybVFjhyMM9kf+I4vjaMrwOCKE+EXfUUIIIYQQQgghhLQ0Tqj3lznDpJ3w1vyjnHRCCCGEEPL/s3cnUHKd5Z3/n1t79VJd2i15kzEcDPFYjSBxx4DaDQZjg8FkwmFISKwkzkwyJzOYiScaQ8A2BIiSnuBsMyQxf+QTZhL+kNhAMJjNamGadk6QJdv/wRkWb8KyZLW6urq6a6/7P7dUbbX0Pm+pb3dVdS3fzzk6IW+Vb937vreqq2499fyARjqj48nM6MguceUlzDB6TCg1OnI3iw4AAAAAQO+YOzR6cyA89GqWHL3EO+e9c59FBwAAANBIZxSeVEQ+w+yiR/0SCw8AAAAAQO8IRtf/FsuNXsS5DwAAAKDRzig8CYq8xEuIWfzXTNmKa/zzIlm0f36UKq76r1nKrv6vEVzlXyN48TnaP03J1f8VXNf41whepI72zw9t3paxd/HU6MgtxigAAAAAAOg66UO7Ruh2gl7lnfvec4ATAAAAAECjvFh4khoduZdZRY/7nV6fAAAAAAAAekEgEKHjA3oazwEAAAAAjbS048nVzCx63KW9PgEAAAAAAPSCYGTdlSw0ehnPAQAAAACN5Li1iJTU6IiRRmKLT4n4iD6xbUOLo9HGPAPNzv3pAjklKifmM6aorKxV0Mda55V98PiJS8pYTgLtHEiV9PsmQ+Z9fXh/cmLqrtVsAAAAAAAAtK+5w1dfGe7fPsUSodcV55985+COift6fR4AAAAArF6140lqdOQW5hKoupFpAAAAAACgezlO8L0sL+A9F0JvZBoAAAAANEKotg31y3Y/nU1sbNvIKt0xtK4WWB6fzU1UfrqbaEINOF/8nAN9AWOoqqR0bpHl798OYwQAAAAAAHQNJxA+j9UEeC4AAAAAaJzFr+75sh04ZYB5AAAAAACgeznB+CUsL8BzAQAAAEDjWHpGAD0rxNIDAAAAANC9nFD/y1heoPpceDXTAAAAAKARFr9kj2rbypT1yJJGROKsNpWlbIlTWW1cjCevxABFLVk2C5Y5qhgjzY0SskUarZbt+MrGiLcPxlBVI9ZE242IZU1ssso5EzRGAAAAAABAN3OcUIIFBqrPBWYBAAAAQEMsdjyJM53AKdO7Rm5lKgAAAAAAAAAAAAAAODeidgAAAAAAAAAAAAAAALAi1X6KuYrruo40LwdGsdoHa0R8i40tVkfTZ4nPsUUBdRrb8RWUOCK/0TcFZY5skUGW3fAlbtn22ZITU+PGIAAAAAAAAAAAAAAAMFQ7njgiGeMWAAAAAAAAAAAAAAAAoA6idgAAAAAAANAzKsXZ77PaAM8FAAAAAI1TjdpxHHlcXPn5s7fa34h8E4uKPtxxMmUzLsYz0MS502i70cxd8LPtBW3n6sT4rLFUO+4UAAAAAAAAAAAAAADtaDFq52FWB6g6zDQAAAAAANC9KsW5x1legOcCAAAAgMZZLDz5EnMKVH2PaQAAAAAAoHu5leJDLC/AcwEAAABA4ziueyoGJTU6siAi8XacWy2qJRrQY1raM72lccyZOEU7bD/37QXKaSSFs2Zp64GHe3V6AAAAAADoGbkf7VauEgC9JfbSfVwHAwAAANAQgSUb+WemFL0s4MocJwAAAAAAAN2vnDv+VZYZvYznAAAAAIBGWlp48j+ZWfQyxyFyCgAAAACAXlApzf8jC41exnMAAAAAQCO9GLUjp+J2ZkQkea7tFypmN9KIJfpGi8nx9CmZOHllu1InVme1Sq7+eCHHfLyC5b4R5b7N5Gc+Wy1nWb9Yk9YvY5mLuOXxzjVFyYmpc9wDAAAAAAB0i+y/vudZJxi9gAVFr3HL+SPxl//dhSw8AAAAgEYJnLWdTzGz6FETLDwAAAAAAL2jnD9+H8uNXsS5DwAAAKDRzuh4Iqe6nix4TSPEZweLsqUjSLABHUG0TijN6oLS7mzznKsYQ9LvswtKq+dZ61gy4GOflf+8yraJczze9uTE1NPGHQAAAAAAQNfK/vC9s44TSrDC6BWuW0rHX/bZIRYcAAAAQCOd3fHE8wFjBOhuExSdAAAAAADQe8rZ5/6CZUcv4ZwHAAAA0AxGxxM51fXkqIicR8eT9mObZzqenGbbhOXxSsmJqbBxAwAAAAAA6AnZJ971AyfUfxmrjW7nluafiF/2+Vew0AAAAAAaLWTZ3oiIPKUVmNj4LTBRagCsBQN+ih+04gLxWdCgKfko+PDElV4yjSjCsW2jP2gMWc1b5shvocpqaWuiFb+I5RxQ/vO6tMebLrhfShqjAAAAAACgVxRzx34tMvCS77Hg6HbeuR5nlQEAAAA0gVIeIVKLHfm0cQPQXX586fce/resKQAAAAAAvSsxfGCqtPAs8SPoat457p3rrDIAAACAZlCjdhalRkd+JCKXGjc0gNZ0Q2lI4Vu3dzxphHbpeKLx0/FklYjYAQAAAAAAL1r4wTv/JRAeejUzgm5TKc5+v+8V976GhQUAAADQLHULT+RU8UmxTiTPOS1Yihz6WlzkUDZGRHyk00jZMk/tUkzSCFrRzmoLdtrY9lpnHwAAAAAAgKrsD9876zihBLOBbuG6pXT8ZZ8dYkEBAAAANJPSl8PwUu8zijEKdK73U3QCAAAAAADOVpx/5lpjEOhgnNMAAAAAWuGchSe1L+h3GTcAnenTyYmpu1g7AAAAAABwtsTwgali5snfNG4AOpB3LnvnNGsHAAAAoNnOGbWz6PjolbsLZfmMrEH8ipIAI7ZdKFSUO1u2EbdtpMVs+xwJtHb/ssq5EG9xlFDWMhfxxsyFV3RyszEKAAAAAACwxNyh0ZvDA5f8DXOCTuUVnQwOT9zNAgIAAABoheVE7VRtnnh4XyQov2bcAHQGik4AAAAAAMCyeF/Y0/kEnYqiEwAAAACttuzCE1ksPgnINcYNQHuj6AQAAAAAAPhC8Qk6EUUnAAAAANbCsqN2lkqNjlwsIk96//3icNmynWCTolrmtewcEYlZ4nOCxkjvsq1VvmIMiW35GhR9s2zaHi9zD96fnJi6yxgFAAAAAABYhvShXSORgZd8j7lCuytkfvLzieEDUywUAAAAgFZbUeHJotToyIJXgyB1ihkoPGk/trXqssIT7z/ZlZyYesi4BQAAAAAAwIf0oV0XhePnf9cJRi9g3tBu3HJurph97vLE8IFnWBwAAAAAa2FVhSdyqvjkEREZLvjcTlApG7DUjPiStRSkxBux8Ta2oBy3UkdSFbMELIWUKpNcxdzuqW2Y9y1Y7htR7uuXtm3bdkuum9t44OG4cQMAAAAAAMAqLPzgnf8SCA+9mjlEu6gUZ7/f94p7X8OCAAAAAFhLlhKE5UtOTL3KizNhFdEmJig6AQAAAAAAzeB9wV9aePYvmFy0A+9cpOgEAAAAQDtYdceTRdO7Ri5xxf2/FZGQcaOCjieNRceTarTOe5ITU58z7ggAAAAAANBA1eid/osec5xQgnlFq7luKV2cf+bfEK0DAAAAoF00rPBk0fSuK79cEXnb4v8fVooZxFIo0deA4hBls1XaprViBjELGurKW7YRbUCxRbfwsyYr9HxyYmprr88zAAAAAABorfnH3/L5YOy8X2Ta0Srl3PNf6L/8a+9iwgEAAAC0E0vvi5XbcODhGwLivMQRybHSaDKvpOXfUXQCAAAAAADWglcAUMj85GKvAwULgGbyzjHvXKPoBAAAAEA7anjHk6Wmd438cdCRW40b6HjSU5rU8WQiOTF1tTEKAAAAAACwBjKPvuFjob6LPsDco9FKC898fOCKb3+QiQUAAADQrppaeLIoNTryIxG51LhhmbTiDlthh59ikpLl2EOWeKB2ph23dsz1jlsrELFNRcR2g0LZ7KltGyN22drxBUTyQcd55cYDUz+x3hkAAAAAAGCNzD9+/f3B2ObrmH+sVjl3/Kv9l99/PRMJAAAAoN21pPBkUWp0ZEFE4sYN50Dhyblpx60ds9Q57nYuPMlVXDfkOC+l4AQAAAAAALS79KFdF4VjWx5wQv2XsVjwyy3NP1HMHbs2MXzgGSYPAAAAQCdoaeGJnCo+uVhEfuCnAIXCk3PTjls7Zqlz3G1aeOL95+9JTkx9zrgFAAAAAACgjVGAAj8oOAEAAADQqVpeeLJoJQUoq5FRqioGgssvntCKX8RnAYw5Un8bnWaupB/hYGj5x7e4TgERNxSQX9984OF9xp0AAAAAAAA6CAUoqIeCEwAAAACdbs0KT5ZKjY78SEQuNW5oIApPmq8RhSdZ182HRH5m04GHf2zcCAAAAAAA0MEoQMFSFJwAAAAA6BZtUXiyKDU6creI/IZxQwNQeNJ8qyw8+XFyYuqlxigAAAAAAEAXmn/8LZ8Pxs77Rda295Rzz3+h//KvvavX5wEAAABA92irwpNFqdGRd4vIZ1oVw3M2rcjEVhyi3bfe/ZvFT2HNvHJfT7/l/k3k7cje5MTUba1+YAAAAAAAgHYwd3j0xlDfhfc4TijBgnQv1y2lSwvP3jS4Y+K+Xp8LAAAAAN2nLQtPlkqNjtwrIjcaNzSRVkxiKyTR7lvv/s3SYYUnXozOG5MTU08btwAAAAAAAPSozKPX7Av1XXAT6989SgtH7hm44pu7e30eAAAAAHS3ti88WZQaHblYRLxfBAwbN66hBUsRR59SxKEVh0idApGscv+45b7NouxC1Qp2IyUiNyQnph4ybgEAAAAAAMCL0od2XRQMD/1tMLphF7PSecr56QPl4uyvJIYPPNPrcwEAAACgN3RM4clS7VSEQuFJXRSbAAAAAAAArAJFKJ2BYhMAAAAAvawjC0/OVovjeYd3PMaNTUbhiWFCRG4iRgcAAAAAAKDxvDieYPy8dzpOKMH0rh3XLaXL2efvJUYHAAAAALqk8GSp1OjI60Rkn4hcatx4lkbEyJQs81dUhuOB5hWNFCrmA0aa+HhLeF1N7kxOTN1l3AIAAAAAAICmSR/aNRKKbviLQHjo1cxy81WKs98v5ad/JzF8YKrbjxUAAAAA/Oi6wpOz1StEofBkRSg0AQAAAAAAaENzh0ZvDoT6dgdjW17L+qxeOXfsu5XSwr7B4Ym7O/1YAAAAAKCZur7w5Gyp0ZGLReRDIvJLZVfixh0oPFmqJCLfFZHfT05MPWTcCgAAAAAAgLaVPrTrokAg/F+D0c03OsHoBayUnVvOHynnj99XqRT/ODF84BnrHQEAAAAAhp4rPLE5vuvKT4or7y07sjHutCSiZkVshS6h1e+z18nkH0Tko8mJqaeNWwEAAAAAANDxThWjhP6DE+x/XTC6YVcvrmg5P33ALc8/VKmU/ooiEwAAAABYPQpPziE1OvJuEfltEdkhIsn6926+VRaeZEXkX0Xka8mJqduMWwEAAAAAANCzTkX1xK8NhAYvd0L9l3XyPLil+SfKhZkn3ErxK0TlAAAAAEBzUXiySqnRkdeJyGtE5EYR8VqWbmhmgYpWeOKI5IKOk6oVlXxPRA4lJ6Y+Z9wRAAAAAAAAWKH0oV0jjhPY5TihVzrB+CVOINQfCA+9upXzWSnOft+tlObdcvZJ1y39H9etHEgMH5gy7ggAAAAAaBkKTwAAAAAAAAAAAAAAALAiAaYNAAAAAAAAAAAAAAAAK0HhCQAAAAAAAAAAAAAAAFaEwhMAAAAAAAAAAAAAAACsCIUnAAAAAAAAAAAAAAAAWBEKTwAAAAAAAAAAAAAAALAiFJ4AAAAAAAAAAAAAAABgRSg8AQAAAAAAAAAAAAAAwIpQeAIAAAAAAAAAAAAAAIAVofAEAAAAAAAAAAAAAAAAK0LhCQAAAAAAAAAAAAAAAFaEwhMAAAAAAAAAAAAAAACsCIUnAAAAAAAAAAAAAAAAWBEKTwAAAAAAAAAAAAAAALAiIaYNAAAA3Sa9d+fVtUPaXvu3aFhEkubhus7p/ymz4sihU/+PUxGRp2r/PIcSew6mjP8cAAAAAAAAAIAe5biuy9oDAACgraX37twuFfdNtcKRHSLua1/c30ADmvjZ3hM7jjF0Doe94hQR2V8rUjlU/+4AAAAAAAAAAHQ2Ck8AAADQFtJ7d3pFJbtF5OpTxSVnqVSMoar2Kjw5l6dF5D7vX2LPwf3nuC8AAAAAAAAAAG2PwhMAAAC0VLV7iciNInKLiFzctMculo0hCQeNoboqynvlgKUYJVc0hqyPFzSKZRYLUu5K7Dn4lHF/AAAAAAAAAADaFIUnAAAAaJr03p3JWheT5haZaDqr8ETjFaPsqxWjpJTbAQAAAAAAAABYcxSeAAAAoGFqhSZ31IpNhs653YJSHOKJKAUbWmGHJxY2hrrK0uN2nC+KI3sSH3r0XzlrAQAAAAAAAADtgMITAAAArEp67847ah1Nzl1ocjYKT87NftyzXjcUOqIAAAAAAAAAANYShScNlBod8drHv1NERkVknYi83PtKQEQGRCTUoEcqiUim9r8P1/7vfSLyL8mJqYeMewMAADRYeu/O7bUImNFVb5nCk3Nb/nFPeAVAiT0HDxn3BQAAaLD0oV0jjjiXO4HQDhFnMBAevNArRHYCsS1OMHpBIx7NLeePuJXcMe9/V4pzj4u4c26ldNgV9/HE8IEp4z8AAACwuP2Bt9344nsMkZeJ61zi/e/+/oVpR2T70ojoQLBSEZHhFf3Iqvm8HyKdfe3nqdo/9f+/9aoH93NeAGg2Ck+WKTU64v2K1/ujtENEkmu1H2XLcgUdY2ipVO0PzNdE5FPJiamnjXsAAADUkd67c7hWbLLDfq+aUsUYqgoFjKGuV7bMY9JLgQAAIABJREFURbDpc+G939ud2HOQCwsAAMC3uUOjNzuB8OsC4cHLA+GhV3fSDFaKs9/3ilTcSvGhweGJu407AACAjjA+OTZc+z5u8f9ur/1LLuv6VAvNZfqNBxscmDfGbMpl/TpRMGi5rtQaT9e+W0zVCl1e/L+3XvUgP3oCYKDwZInp0ZFfElf2BB15mYjEjTu0gRUWntTjdVB5XETuSU5M3VXnfgAAoMek977qEnHlPnHkChEfbzYoPDlt7QpPljpcK0LhogAAAHjR3OHRGwPB+C8HwutGGtWhpN15HVQqxZmpSjn7vwZ3TNzH2QAAQPN9YuLNP+ulBLiuvEHE3S7iXCQil0cixcFumf4uLTxZrYklnVe8a1JPUbACdLeeLTxJjY7cXXblbSLulrNvCzorr+JotiYUnthkReQBr107HVIAAOgt6T981Z+JI//pzIOm8GRF2qPwZKkv1opQUsYtAACgK6UP7booEAj9h2Bkwy84of7LWGWTW5p/olyY/sdKpfRXieEDzxh3AAAAZxifHLu61olkuNaFxBrHXCgYUcFVkYglWrgDUXjSEIuFKofK5cBje17/rW91wTEBPaUnCk9mRkd2OSL/j4hcatyoyFbMOYkHmleMUjZGTgkaI3Z5ZZ9DlgIaP0UqhSXnR0Bk1hHnDzYcmBo37ggAADpaLUpnf8uza3OWiwwx/aKEL/mSee9oyBhqmILyrs72XruZ+7E8s7UCFH7pCwBAl/FicgLhxK8Eoxt2sbYrV85PH6gU039LXA8AoJfU4m2WFpWsOtIml4saY55YLG+Mdapc1jzGWLx5xzebNgtdhhLLL3SZn9dDH2zFQOGwco2tAXL5iLqRWLRgjC1xuNZBpfrv1qseJGYaaBNdWXgyPTryu+LKh5Z+ceKn2ILCk9MKlvMjcmrbpVpEz83GHQAAQEdI7915i4h8cs32lcKTNVbdv79N7HnkV9tkhwAAgE9eoUkwuv63AuGhVzN3zVMpzn6/nD/5KQpRAACdanxybHu1qMR1xmodSi4+41AcyzWMVaLwpPF6vPBkOZ6u/cBuf604hYgfoAW6ovAkNTri/XH0fq053IgoGgpPTjtH4cnZvJbtNyQnph4ybgEAAG0lvXfnPhG5ac33icKTNbZk/1x5VFy5OnHbIzNtsnMAAECRPrRrJBga+HAwtvk681a0Sjl3/KvlUuYjieEDU0w6AKAdvFhYInJj7f/qXW1d9fsdCk9WgcKTlWli4Ykqf/rx5kTcSRE5ICL/7wfHvv4j7f4A/OnYwpPU6Mi7ReQzXk2IcWMb0Apg/BR8yJlfA7yooBSYeKI+CmO0IhW/21gG70H2JiembmvkRgEAwMql9+5M1ir9a21StfcEzSu2VVnel4j2vqRg+ZAbaZMijqJSeBL2U0rsU0nJ+S0rY56QnhUsQWW8VPk/4sjrEx84dNK4DQAArAmvq0kovu12Jxi9gBVoP245f6SUfe5OuqEAAJrtDw+86RoR9xdEHC9S72cWHy4U0q+ZFIrmD3siYb24oJ3NpAbUvVuXzBhjfuXz5hxFo6ufo6xSjOKJKwUpuZytAMOyH1qRkI+ComJJv5ZWVM4XT188a4w1hGWfyxVzPBi0XPNqjsNzc/2PO477hTve/BViqoFl6qjCk+ldV/5eWeTj4kowon0Z0UYoPDmD94BfTE5MvdO4BQAAtER6785DZi6v9p6AwpMV65rCk8XjcChAAQBgDc0dvvr3Qn0XfNBxQgnWoXO4bildWjjyscEd+/+o1+cCALAy45Njw7WuJTeefS2nZCkYoPBk5Sg8WTKunC/Sm4Un9c65w7Uf9u0jwgc4U9sXnjz12iv39AXlDnEltnScwpMztXnhyVLeg/+X5MTUXcYtAACg4epH6mjvCSg8WbGuKzxZ5DyQ+OChtxj3AwAADTd3ePTGUGzbn9PZpDtUO6HknvtPgzsm+KUsAOAM45NjySWRODdaY3HOQuHJmSg8WcJSxKHdl8KTc/N7zrluYLYW3XNfpSL37nn9t4iyRs9p28KT1OiIl6d1qXHDORQtxxN2zBepdpdVjiVuOY6c8qVNTPvCxifl65OqBn2FkhKR4eTE1NPGLQAAYFXSe3fursUS2uWVixJR/YOnLznLh+KY/uG1abT9sO2DVsQhdQo2mqWgvPuKNLF4xZ87E3sO3tEuOwMAQLdIH9p1UTA89LfB6IZdLGr3KuenD5SLs7+SGD7wTK/PBQD0kiUFJt6/dzTr0ItF/XpOsWCO9/XnjLF68nmzKCIaLRhjnkLBvO4SiSjXZ7z3QHP9xphUf4tkft81MLBgjPWCkzOD6lGuXzdnjHWTUsm8FhYKKdfMxF68MjvXZ4wNJeaNMamei2aRSTymP0/CYeV6qsXicTiOfMUrSBFx/4GCFHSztio8SY2OvFtE/m41P7Wl8OS0Dig8WerTyYmpm41RAADgS3rvzu0icmhZv5Sh8OQ0Ck+Wy/v1xtWJPQdpJQoAwCrNHRq9OdR/4X8nSqe3VKN45p/93cHhibt7fS4AoNuMT44tFphYOs82D4Un3YnCk9M6ufDkbEuO5Yu1yB6646ErtEXhSWp0xPug9RvGDStA4clpHVZ4sujHyYmplxqjAADgnOrH6igoPDmNwhO/JhJ7Dl7djjsGAEC7m3/8LZ8Pxs77RRYK5dzxr/Zffv/1PT8RANBhxifHvB/97K79u7gd9p7Ck+5E4clpXVp4onn6VHcUuevWqx58SrkdaFtrWnhyYteVT1Zc2b74/4cthRLaaLas73c8qN1bpODjOLWvF/StigQthSCasmUf/GzDD9sxRxrweNqW/W7VsoSLG8sGRF65bmKKF1UAAM4h/bHhnxNxvymhoP5ptFmKlg9JYf1DlVrc0erCjnZXVuYo2IA5yuoXeSRuXhDyaSyx5+D+zplgAADWhhenE4oM/WUgsuFtLAHORgwPALSvO79x/Q2u69zsus4bBwfnjUoJW8GHVqwhPgso5ufjxpijfjtjLybR9m8hGzXGpM6X8n5kMuaX/X6LRrLZmDEWj+vHpzl5Um8mN5jQ9yMcMgsJikX9ekk4bLm+0mKVsnmtqGIpwDhHkcOyTE+bc7phQ9oYaybXNY9ZqmulX4e0FTytlnZ+iuUctb0OBALK9b/6RS2ztWIUrzsK1+HQttak8CQ1OvKjQsW99OxxCk8ay3bMHVF4cnqjFKAAAFBH+mPDfyXi/vvqPUL6B62mofCk8Tqv8MTzxcSegzcaowAAoFpwEo5tecAJ9V/GbOBc3NL8E8XcsWspQAGAtTE+OeZ19tydnutXu8kmBs3CDK2wQ+p84UzhyblpX+xrX+rbUHhyJgpPGks7P8VyjtpeB1ZQeGJzD8UoaCctLTzxCk5EpFpwklGqDvotRSP6aPeYV+bCNh8ly3qVlGFb1I7l4UR5uHaSFZFXJCemnu6y5QcAYEXSe3cmReRQu7R0PUNzixyWT4kiVAs7pE6xTKtp7/XaPTLy1Dx7Vxu2J257ZMa4HQCAHpV94l0/oOAEK+EVoMQv+/wrmDwAaJ7xybFhEbnFT2Sx9iWyLXLGj7JSROAJBi3XMDrs8SoV/bpGIKBcA/EKYxb0L/Y1fX3ml/3NZItOcZVvMitlc8wzrxyfdjnIs2H98iN1bLE82jwnhzLGWD35vHlNLxq1XP+zyGTMQqoBS8GUKHFLNlqxk6eknOd+j1tjOwf8FPho8ykrmFOLe2oxPYf0m4HmaUnhSWp0xKu0Gl06RuHJaRSe+PJ8cmJqa0fsKQAATZL+6BVXSST03badXwpPVk57r9cZhSeL3pW47ZEvGPcBAKCHzD9+/f3B2ObrWHOsVjl3/Kv9l99/PRMJAKszPjm23etkUis0GVrpxig8WRkKT85E4clpFJ6cqUGFJ2fzYnruqnVGIV0CTdXUwpMTu67cE3KcPzRuoPDkDBSerMh9yYmpd3bUHgMA0ADpj15xh1Tc2yWmf0BpCxSerJz2Xq+zCk88H0/c9sgHjfsBANDlMo++4WOhvos+wDqj0UoLz3x84Ipv8/4KAJZpfHLsxlqRyWgj54zCk5Wh8ORMFJ6cRuHJmZpUeKKZqHVFuU+5DVixphSepEZHvJbvP/C+XjBubLK8eeG7KmopwtBo2/Dz30v1j4ypaJnriI8vE8qWbQSVbdgKTFx170RCyjZsGjFHDeDtxHuSE1Ofa/UDAwCwFtJ7d3rV6e+zPnTBkgMaMfN8m6po+aClFX3Y9q1Z7ytsRTER/UOjBM0PqVba/NuOI2R5vGbR9k3qzL9GWz+xztEXE3sO3miMAgDQhdKHdl0U7r/oMccJmeH3QIO4bildnH/6usTwdyaZUwA4bXxyLFkrMql2M5mf17+W6u/PGmPSgGKS2XS/MeYZSswbY34Vi+aX04WC/jnednyNMD1tvsXZsCFtjPmVzUbV/yIezxtjNloRQHpOL0RYv275RRyNsDBvFphI9bs7c5/7+xaMMbEUjVi5+jUorShGK8qo3teyjUjYvJ527HjSGPOEw/p1QW3+bUVQ2aw5d8WSft91ydUXk2jFUdo+SJ2ikfXrl/+c0B5P/K53Yy12RfGKUVJrtRPofA0vPNFidVpJK4gQCk/O2jf9hg4sPFlE/A4AoOul9+7cd87cYQpPzo3CkzPZ5l+jrZ/UnaOJxJ6DVxujAAB0EWJ10GrE7wDodbXYnDts10goPGk8Ck9WhsKTM2nzT+HJmdaw8ERzj/daSzwP/ND/Qq1ArcvJkz2QjIP2c15qdMR7Nf53dD8BAHSjZRWdAO1nNL13536KTwAA3Sh9aNdIuP+iB4KxzeY3MUATeYVO2R++d7Y4/8y1ieEDU8w1gG73R995wxsCQfdXuS4CAC3lvebeND45tviYE7VClP0sA2wa0vEkNTpyb1lEb6Vt2b7WoaMRCpbH89NVRFOybNdPlxC/tO4mtnkz7ymSs7Q8iQf1bfixoGzbsmsSt/3Stzl+nJyYemkrHxAAgGbq2aKTktJdI6T/sqG5+6H8SsPWrUTrCGLvBtIcSle6qma+H9Me88zHo/MJAKCrZB69Zl+o7wK+/MKaKy0cuWfgim/uZiUAdJM/PHDNNbWOJq9dPKxQSPls3iZmUgO+dsRPdwat40I8njPG6jk5M2jcqnWe8Jw8qdfTVpTLHRs3+uh4YumiIY5yPcHixAl93wYHzU4v0ajZnUMa1GHFj+eP6R1BtO/StmzW000KStcbT1HpfOOn6412XlS30aefX7Y59UPrThMKKieX+Ds32kVF6d4SsByf7XVDe31YyOpdnPri5nrbtttnOceDQXOeQyFL12QThSgwmK9MPqVGR2ZERH/1BFrv0tToiPdKfklyYupp5h8A0MnSH93xDxIJ/gKLiA7ndT65L7HnoF6oDgBAB8k+8a4fhPouuIw1QzvwCqCyT7zryvhln38FCwKgUy2NztG+mAYAtKVREXlwSUcUonmw8sITonXQxrxz8qnU6Mj7kxNTd7FQAIBOlP7ojg+JuBSdoFu8I713512JPQdvYUUBAJ3Ii9aJDLzke06on/VDW3FC/ZflfrTbLWR+8vNE7wDoBOOTY8laocn7WDAA6BpnR/N4hSi33HrVg3o7H3SlFUXtpEZHvAvGn1w61oiIGy1aRurEy7SzonIsYctxZJTYGrFE1Ngif6LKfbtJumQed5+l+Pms+KOJ5MQUrd0BAB0l/bHha0Xcr9XdZ1vci0aLQhFL+XDO0k4xrrf2VBUsLXAjXfLLJdt8tsP7Mb9zn1NapcZ8rLV/v5bYc3BfMx8AAIBGmzt89e+F+7fvZWLR7orzT+0Z3LH/j1goAO1mfHLMiwXzfiQ6VG/XKhX9c3WxqP+GulIxP+vaomgWFszYGk+fJVqkHWixGZGwft1mfl6Pkdm8edYY07YrlpgPm1wuot4SixWMsUymzxjzRJX7esLLj/pQ5fP6dQ1bXIx2bkQi+n1PntTnTptnm2PHzKfBUEI/Dy1XoHzFA2nPq0DAtmXdiWkz6ig5NG+MSYOisVKz5jwnh/Tz0/b6EFaeK1p8lVheN/xE3DSTLW5pYcF8ztvmSDvHPbGoeR4FlPidBpitdUOhWUCX05+NdaRGR+4Wkd+w3wNoK6Op0ZEfJSemXsqyAAA6Qfrjw+tF3M+zWOhSn0nv3bk/secgbTcBAB0h8+g1+8L9229itdAJvAKpzKPXvHLgim/uZsEArKXxybGra11NRlkIAOh5XrXVJ8cnxxabWkzUClH29/rEdBtfhSep0ZH9vFFAB7o0NTpyNDkxtZXFAwC0PVf+t4gMslDoYt5niu0sMACg3c0//pbPh/ou+EUWCp0k1HfBTZnHrt028G8eeDMLB6BV/ss//MLFhUL4nu0XHx8+V1cTAEDP82oNHqzF8szWOmLdRSxP51t21M6x1185VXblSqlGmRg3S6SJrcWzSjvzoOXh/ET7tLu8ctztEqlj7pnerV/qxAOFVrlWBWV+pP65mEpOTK0zRgEAaBPpvTu9XyZ+hvXwyRYvo71hLFruGzbb857aRsAY8sXyfsUay6O9b2qX97d5s0VpVdRHLfvp47s18d8e+e/G7QAAtIn5x6+/PxjbfB3rgU5Vzh3/av/l91/PAgJolvHJseHal4X1f6zs+vhM6yifib3XtLL+2bzimuP5nB5LMTCw+niMkzPm74TWr5szxuopKrEZC1k9tiauRNHYImD8cJV588ym9UgcW3zHcmWzZiSI+IyLsZ0DQSUyJpXuN8akznGUSuY1oaAlbsRxKsaYX1oUkC0GqFm0fai3H4WCee0nErFcJ7KYnzejaxz120aRkBKTY4vwscUGHTueNMa2bNbrGmaVc8a23YDlHOjrM5+vWhyOp7+/tXE9fhQK+rnRiNeeZfK6odxy61UPHmrVA6Jx9FfqsywtOgE6WNKL3WEBAQBtjKIT9Irx9Cde9RJWGwDQjub/v7f+PUUn6HTeOewVULGQABppfHJs9/jkWGp8csz7RvYROuQDABrM+7vyyIcfuMG9/YG3Ze74+ls/wgR3jnN2PEmNjtwtIr9h3LBMWcv2Y8ovN80Ru7myvt2oZSN1umAYtC37/Z3pgrJ/fdqvbtdAwbImq+0Ws4IOJC2Vqa1J0JFnt37n4YvaYqcAAKhJf3THp0XcXzfmw/Z3NGT+GsN3dw2N5X2Cuu3VdgOpR9uPLupsJ1nLrwTi+q8KWqpg/qqkKmL+umWVvpjYc/DGtT9gAABOyzx6zT4vqoQpQbcoLRy5Z+CKb+5mQQGsxPjkmNcy4A4ReV+jJ3Aha3Y/sHUSiMX0zhgLCzFjrK8vZ4x5cnm9q0hU6dpg62qhdQJoYReA+iydZcoVczwY1I/PRusIYus+4YfW/cUzr3SJ0C4TiWXfyiX9etV5580YY57njpqN8kOWOQpH9ONel9S7qWi0biMRy3aPHjW7dnjO22Iey+yc2bXDtm/lsjlvnnxBf570xZffoUPrDHRqP+aNMdtzTTOTGlBG9eMTy+tDPG52JRHLmthed2yeP2au1Xlb9A4rjaB1adFez6ROJxtt/rXONGKZo8HBBWPME1Y61jTIn3p/k4jkaV/6q29NanTkltUUnQDtqOzKhcdef+UDLA4AoF2k9+5MqkUnQHd7R3rvzmHWGADQLjKPvuFjFJ2g23jntHdus7AAlmt8cmz7+OTY/lpXk5lmFJ0AALAC3t+jGe/vU+3v1HYmsb1Yf7aYGh25WEQ+adwAdIGiK28+/vorP7j5Ow/zwRsA0A7uYBXQo7xzn64nAIA1lz60ayQy8JIPsBLoRqG+iz6QPrTry4nhA1MsMADN+OSY96OAfSKyQ7kZAIB240XyPDk+Oebt1mERueXWqx7czyqtLWvUTmp0xOuPo/fT8SGjRM54BpoUO6NF3EgDYm4asV19CyLzlm1rc9TMOJuici6ELS3ts8o+x5X9rSevHEvUx3E0aK23JyemnjZGAQBoofTena4aZSM+Y3KaqWK2XpRA3eZ5a6+ktCnVIoq6Sd7SylJ5n1cVM9tkWjXvHL0ksefgU8YoAAAtlP3X9zzrBKMXMOfoVm45Nxd/+d8nWGAAiz6+/03Xuq7zaRE5X+pEMWhssTWxqBljYYtTCYeUz6+O5XOnD/PzZryGp79fj+DJK8dSLOq/2R4YMGMltP9eqvNpzoVfL5wYMv4LxzJHGzekjTGbXNaMspFqtIhln5XHfO7oemPMs02JsylY5tMWU5TLmft3csaMFZHqPpvbGBzQY2H8xH8cP27OvSeZNM8BsRxLalaPhikUzGtTmzfNGmONksmYX/UOWOYobYnriSvnRrmsXw+ynkerpEVdSZ3nhJ/1zmbN1w3bdm1RVeGweQ5MT+tvvSJRfd8GldeYRjj+gn4+a+ed9TVbOT6bclm/ZuwqkWCumGNSJ3pNm/9Mpu/F/+047vOO4/7mh6/56j8Zd0TTqa/2qdGRRxpRdAJ0AO+XHltZKADAWknv3UneOnrdbrr+AADW0vzj198fjG2m6ARdzQnGBr1zvf/y+69npYHeNT45dnU+H/7sqWIT/cs+AAA6les657mu8+U7vv5WCQQqGcdxf/tDb/zaZ1nQ1jBKjlKjI+8WEbLW0SvOS42O3M1qAwDWEIUn6HVE7QAA1szc4at/LxjbfB0rgF7gneveOc9iA73FKzYZnxx7anxyzPv5/oOLHU4AAOhqjjPgSuBvP/Kt692PfOv65/7gW2+hALvJjKidRkXsdAJbDFBcaRduS2+xbSOs3N8WI1O2tD4PWmJuVsu2z1q0jx9+t1uwHLcm4mMucpY28Nr0L9kukTsAgDVRjdlpOttDKH8cbbTYGtt/HzJqm9EqlvdB6huh9kLcDgBgTRCxg17jlvNH4i//uwtZeKC7jU+OeT8uvk9ELl7ugWaV+JVKRf9839+vx3Q0y2xaj/8YSswbYzYvWKImNJuU+AmxRN9sskXcWGI6NKWSGb3iCYW0azHt4cQJPUJk40ZzPp47us4Y82zbasbyNIItCiozZ8ap2Pb5qGWf16/PGGOeBeX5sy6p31dz9Hn98bRoEqnO3UljTIuL8cTjZszUyZlBY6z6eGaKSZUWP2V7nqTn+owxz3zGXJctW+aMMbHEutiidrSYI88JJeZmKKFH2YRC5oE7lqiXfF7fDz9xZbb5j0bMCB7r6612blhed7S4JakTuaTRzi/t3JJqvJY+RxFlXWdSeiSV7flTKJjnYkSZt3Pwvg/efetVD+6vfzf4dcbq1Do/6Gcf0N28N+GvYo0BAK2U3rvzaiYcqPK6ntzFVAAAWinz6Bv/PNR3IUUn6CleodXc4Td8dnDHt9/LygPdZXxybHvtOvcOlhYAACuvKPPB8ckx7/bDtSKUQ7Y7Y/nOLgu6iblDjxpOjY68Ljkx9RAnAACghSg8AU4h6hMA0HKhvgt/h1lHLwr3X/TLIkLhCdAFxifHkiKyT0TewXoCAOCbV6z5yMcevNb77x4IBNxfum3062ZLISzLi4UntW4nZn+aJikpMSshH3EqBUsb8YiPNuK2CBg/GrGNRkTqaPNZ1LtANWSfG8FPfI623ra1tiT+qPMROfOM/3O6ngAAWqxFhSf630xV1mx5WBXXWyQ2TU5pkRhr4lvVnOW4Yy0+bk1ZeRMjlixIy/ujtqG8Z5VT7wm3G+MAADRR5tFr9oX6aHaC3uU9Bwau+OZuTgGgM41Pjt0hIrefa+fn580G97bYhng8b4zZLMybkQuevn4zdiGnRJB4Yj4ez0+kjo0tFkSLqyiX9YihTRst21glW6SOn0iJTEaPN+lX1qRQ0KN9bFEhx48njbHNm1PGmFQjZ8xzLpk090HqRJY4yvTnc2ZMi2dw0Dw3YtGCMVbdtwX9XNRo0StSZ1yLBdGiXqR63Oa6btygR87YvkbToqOs57gibDkObT6rlOdJyfI80eZCqjEr5uvG88f0Obrwgmlj7IUTejzN+dv0GoGNSgyWLXJmbs48F2Mx/Tyay5jH4dmiPCdskTP5nHkOiGVdbFFVfX3m81W77CZ11kSTt0RVzS+Y44GA7bXLvK+nXDLPGT/75gkGLQe5SoFAdbte9cn0Jybe7M3mp24b/cZvN+XButjSM/vf9vpkoOfxS1sAAIC1Mcq8AwBaKRg/751MOHpZ7TlA4QnQQe785vW/2t+X/TOvDoN1AwCgmZzf+sTEm38rHC7O1qJ47mO6z61aeJIaHXm3V3TY5vsKNF1qdOTe5MQUF58AAK3Cl+0AAAAtNndo9ObwwCX6zyuBHuE4ocTc4V23De448AnWHGhfd37z+svcivMlV5yXiZi/FAcAAE3lFXveOz455j3GYRG58darHnyKKdctdjzx1SpmXsky6ddafdfhJ1ZHY4tZscn7iGrJKMc32MR4GvPRTtEeUTsOT0g5lrjeLa1pIuYu+Fa29IHyc7r4PRfP0qLIAwAAVkn7m9mA+D6J6q0eW85PrE7JbENZFVIuylUs922HSB2boHIcNrZYHuX9bVWkAW8Ytce07bN2jtpijgAAaJJAOPErzC0gEggNvUVEKDwB2tD45NhdIvK+fj09Zdm0WJ1CQf/8G4ks/7NZ1BJBofETqdMItvgWW4yMOObnZS1axrN164wxZlO0RGyEw8p+KDEmUo2tMSM9IhE9lmJgYMEY8+SUiBpbhIgWk+MZGrLEryjCIfP4KhX9GsHsrH6Cb95sRsZUyvocabLKvMnpKA3DvBId5Se2RixRR/19+jxrETB+DQ6a8UXaPnhSKfP4tmzR90GbC7F8XzlvidHq79Of81pEyvp1+nmrsUXqpGYHjDFPcsh8rtiiqgYGzNfK40qckVgidWwi2vNdRBIJ8/HEEo1VLOrX7uLK83huTl8/P0IhfY6089n2OmeNbGoA7TW+r0+P/FFZXm/V12bTDhF5slaE8qe3XvXgLcY9etziFf2f6/WJAGr0d5QAAAAAAKDX50bKAAAgAElEQVQrBKMbdrGSAM8FoN2MT455UfD7idIBAKDtvW98cux9Xg1drQuK9/e75zkzu648P1N2j2gTMeCjc4TWBUVW332ibdg6cQS1X22uAa0TSlTpgtJOsso5E7ecL1nl+OINOL4FZR9CQfnTzRMPU6UGAGi69N6d5h+is1neg6idIwp6RbpELN1DlL+v0i7vH7R908bE0tmkUbJKtXvcrKy38tONZS0UlF8ENKILijZvUn/uEnsOdscHBwBAW6vF7PwNqwScUsw8+ZuDwxN3Mx3A2rjzG9dvikYLd4k4v3T2Dth+dd7OcjmzA0Ispnc/aJaTJ/U0vfXr9Q4PfmSVDg9xS0eXF07o9UObNpqdNAoF/bqNrTuDH88/v864t+3yytbzzH2T6iUoy7WNVTpyZL26Aa0LRp/SCUKqHR76jbEZpcOHZ9tW/fjmMub9XUuXFj/nka0bxLFjg8bYBRfo3Tz8sHXocJUOD5s36cdh666RyZjdcLQuIVKne5K23hs26J0xSiXzOZGaNddJLJ1UpLrey5/T48fNuVu/3uyY4snMm3Mhlg4rpZI+n/m82YlILF2qbJ1sbF2OVst19XPfz+tATnmtFJ8dsGxzpOWIFAr6fbXOK1rHFKnzfO3rM9fE1j1JRO4RkVtuverB5bfF6TLeM/e6Xj14QONWZEQZBgCgGWb5JRMAAEDrOIHw65hu4LTac4LCE6DF7vzG9W8vl4P/25VAf1QNsQAAAPUcy0bFdV0ploISDbiSjDSnSM6Hm7x/45NjPdsFxSs8eZsxCvSwisgrWX8AQIscEpFRJhsAAKA1nEBkM1MNnMZzAmit27/+1i9VKs4NIgH1V9sAAHSzXCkgz6Uj8sOZ0MzTC46bdYKBdEmSyz3kYmZpB5JT3XUCjtLRudpowOyE4p7VRTzkSLkvEsxujDiyOeyEtg5I7GXrV13A4v3Q9MHxyTHptS4oXuHJa/xE6ti0OlIno0SkiM94ID8aEalTsLTKj1i2XVD6nUUs7e9bHaujTb/fqddidbTtSoNidTR9yj54D2eMAADQHOd+w2l5n6CyReoU9Tff6rZtf3O1bYT1dpENoe2HNtYoeUv7Wi0aJqe3DJWYcl+/kTrK+z9ZsDzegPnhyT/l8RohaDlu+3k0YYwDANAETjDKl+zAEjwngOYbnxwbFpH7ROTiwYHVPVwup38OjEb1z7TpOfNS91DCjB7wFJSYAdun8HBY/5xaLpufBW1REyemzbiRcFj5zOjFcayfM8Y880rkhS0KZTZtRrJ4+vvMCJfZtB5tkcuZcxS3rIkWqWNji9Q5dsz8LnbLFn/fXSYSy4+J0M4XqUZTmNebBgf0yIxMxozYKJf1M+n88/VjyWb1OdU4jnksWy2ROrb4qnVJMyJFO5c9RSUCxvPCcTPiads2PeolmTTPOZuKZT9KFfN51RfXn5d+Ilkilo4R8bi5Hy+8YD6HpXqO6s9Bbb1t8S35vDkeDJrnltR5/jz77AZj7MILp40xqROro6lU9PO5opznJ07ocxQKmccnlqgd27U7P9FfNloU17p1+t+IaLRgjGmvwQsFR57NOfknUsG5n2TdoYorL75wVnJL56hUffBA3Jw3qb5HNc+56v3D5nMwGDXHTm3DfJ4o1yyDOZGBI6WyHCnVrtYvOVUrtef8QFAyl8Qc5+WDbv8rt+nnuBbjE40Wl3ZBufrWqx48ZNypi+grAfQ2nhcAgFbx3mi+g9kGpOdaTwIA1objhPRvtIAe5Tgh/ZtYAKs2Pjl2i4h8kpkEAHSbTDEk+58OZh9NlUL5QvmMiovgYCwq4pqVMR0sU5aBx+Zdecyryzl6ZkHR1pgzvWtLccP2Qb0IqsbrgvJIrQvK+2+96sG7jHt0Ab5gBwAAWDvel+23M/+AdHW1PwCgfTih/p9jOYDTnFD/ZUwH0Djjk2PJWncTYnUBAF1heiEoP00Ppb+djkbKrhNbPKb88ZNmy5MedDTnbvjc0yGp5E53p0nEggtXrpfQay8pai2cPjk+OeYVph6udUEx2wF1KOfE63/uuaDjbG317vuJkdHklf++3ja0x7PcVcJa2/keZYu+ySrz2YiYo5IljijU4jVJTkxxEgAAWiK9d6f+x28ltBgT8RmJU7BUZmsxPpa/22qETyPYIm5stOgbm5Le4tJ3VM5y+ZlnP8qW47CNr/bxGmddYs/Bnsg6BQCsrdyPdlvewAC9K/bSfVwHA1apFqezv/aLZlU2G9OGJRLRP+sGg5bP+Ktki4nQ4ldyOf0H60VLfI4WyRKzxAAVS+bnbS3ypB4txidkaW42N6c3eOrrM6MtgkHLZ+gG0CJ/tLgfscTI2PYtk9HjgfzErGgxEZ4FJdIjYolFOjFtHt+WzXosxQuWGBItsuTii08YYzY/fW69esv5luibp57aZIxt3KjHjUyf1Oc5HjOfx4ODeuxJPG6ud06ZY0/MEp0yPW1G+/T3m9sVS4SV7fVFi07xpFLmuO2y4IYN+twtKBFKthit1Ozyc8mSQ/rrRkmJRbLFLT17RInluUCP5bE5ftx8+d+8WY998iNtee0qFszXP1vsWskS2aTN3fTJQTmSCch3Uu78dMF98cGDyjXEQlp/fQn363/vnJC5z6W0fr5ULF9QR9aZ54Zb1s/nYNR8TSvO688Tm4Cyz8Eh/XWgNGMeixM4NfehgBR2DFQWXrttITkUK51xjjsiC8Fg5do73vyVh4wNdBjzLAEAAEArfZG4HfS4CYpOAAAAAHSi8cmx3SLyGRYPANCpfjoXk68+3zf9fDGwobzgFTtVC9z0ihesSKkike+nA5Hvp08VnARdt/jqASm/akMlFgm6faVy4Du//9UbpK8v/1sfGP36X3XqLFN4AgAAsLbuovAEPe6+Xp8AAAAAAJ1lfHJsn4jcxLIBADrRP78QzD7y0w1OUV6MzjHbvqBpSq4bfnhOwg/POdWeJ9GA5G7YLLGXxuVTH9//5k85jvz9baNff0+nrYAzs+vKI5mye75xi9fuSe+8IwGlfbo50lwZS4udRsS9FJX+UObIKRFlLjqVFp8Tt+UR+aDFHHmUbmliNiw6RTsVbfE7+qPp5+i85Tw6/6GHtbsDANAU6T/YMSfhoNkncC3Y4mz8xNag/diidoLau6zWSuw5yPsuAEDLELUDmIjaAZZnfHIsWYvT2XGu/2BOiT0ZtESeZC0RG5q4JXajEbQooEikYIxJnbgX7VgKRf33z3195rGELTEYhYJ+TeLEtHkpZdvWGWPML9fVPytr0TCbN/mL0pjLmE0EQkH9uEMhc55TKfPc8myy7McJJZKlL66va58l8ufkjHnc69fpESkvnDDjRoYSZvyEVM8v/bg1zz6rfyceCJpv7WJK7I3UiXI6enSdMTY0pM9FLGaet1KNajHjfS7Z/oIxVn28583Hi8f1fU5a5i6lRDZFLM8f7csxLfZGqs81/Vu6WMzctvYcljqRTbms+Vpge33YuMFcq5MnzWOWOtE+gYD5/LG9lmixVv39ZgyX57mj5lpL9bXHjHI6edJ8/nnWr9fjp7TzfNMm/bkWi5nP4+csMVPbtp2UbDEon/1BfP65hcqLE+kq50Ywos+RFuVeSutzFIjr51clZ+5zKG7+3ajtnTFSfcwFcxvaOW4THtLPo0DcctyK4gl9TRzlO/VyRn8tCSgxQFXRsIQcKV6zqVy58vyMNzmH5+fjb7r9TffrLyhtRn9GAwAAoJU+JSK3MuPoQX/KogMAAABoZ+OTY8O1To0Xs1AAgE5RKLvy9VQld/SZvlplYUWvukBbKbkS/trxoHzt+JCEHXnFawfcn374azcUAoHKW+5481ceaufVovAEAABgjSV+//B/Te/dSeEJetFdrDoAAACAdlQrOPE6nJgtHAAAaFP/MlspPDJfXmw7YrazQscouhJ58FhBHjwm4XAo8O0jc28vXzBYflO7FqBUo3a8ZBHjFq/9ixI54wlaIk78yFviVzRRpTWNTTP3uVmatc/NnAstlsfS9Uhsy+dnXUvKsdiidmznlp/HS05M0WIUANBS6b07bxGRT67qMfNm28u6QkrrWD/RKyWzZWVVxTIeMlsyWvmJ+2t1PFAjHi9r2YaPto5trWA5FyNn1L3/aWLPwVuM+wAA0ERE7QAmonaAM41Pju0Wkc8YNygqFf3pEwi075+buTn9B++Dg3pchaZU0j/fh0JlY8wmlzPjFWwxJjblsrkfweDy90EsEUPxuB6NUC6b10zSc3r0TWJQj1bSYoq0iCKpRv6Y55ctDueIEvXi2XKeGelhizSyxnQo8UW2iBRtjl44YUYiVSnHJ9UYEvNc7O/Xz42nnjajSWwRNzba+Ww7lzNKjJZYolq09fPMz5sxJIMD+rraXkuCYXP/Ao55bnmeUeJbIhHzv/ecv82Mi/FUyuaxTM/oMTK27woXsuY1r/O3pYwxm7KyD55oVL/Glk6b593srP5c27jRjPZxxTyXpU4cUXLI3IYtamdgQI+o0Shfj1adfc49nwnL545EFnIVMU5S1/K9qaNcBw7EzPPTU5oz97msROdUWR4vusWs4yzn9NejoOU6q6Ncdy5YIn8i682/d7ljeiyZTUzZZ9s2ouvMc852vTh/1Hxdre6zEgUUCJvrtKOvPPuadZk7//jar6/u+4QGM/cUAAAALZfYc9Dr/PA0M49eQdEJAAAAgHbiFZyMT465yy06AQBgrf3z0XjhDx+Ly74nQ6IVnaA7HV4IDv3l4cCfJP74uvK7PvfWtoky10sSa7Jm0VBVv1LMpdeZ2fnpPuFHu3Q20TqCxC3HbNvnhbK5jb6gft+iUvIWtmzXxs8+h7VhbaxOZxJNQTkOT8THNmznltYJxXZfAADWRKH8H0Xcr5zx0H7+nkfrvrUzFZVfNyjv86y0jilVtvEmsVSOt/XjWd7TqWzdQ7T36rE1SNIsKedRxLIfL97X+Y/GbQAAAACwBvx0ODlb2tI9JKR03fDzC/dmsnXz8GN6elC995bN5q/An3s+aYx5Nm4wuwMULV00bONa94/ZtL4mcUs3FW0+bB1IZmfjxlgsrn9m1zpgSPWcMX8RPzendxhIDpnnzFNPbTLGPIGg/nhBxzwXf2rpbOJq1xm8Dh0LZleY/n5z32wqZb3rg22OTp7U11CTTJr7USjq120KeX1c60Jz9Kh+3p53nnmOV7ddMM/RktKRRyzdW0Jh23lkDFX56UBy8UUnjLFCXj/nnn5mozEm1S40ZgefTRv1udC6CHmiMfNcLCkdcjyxqNlJI2ROcdX0Sf31aMP6OWMsGjXnvrofJXPjtvNT62xSpXS4Wb/e7DjkmUmZrwOezJz52hPvMzu6eI2UD0xX5n+YcftFKi8uZsB2wpTNc9xTXDDnIxI256JKuf4X26jPfWFanyNX6dZdTpsdjjyhhNmp59T9zXMjaLkmXlG6ddu+Fo5s1p/zWqeXoKWrdzFlHkvAco3UtlbljPk3qaR0eZFaVxhXJPC1Y/KfB//shv98xaDzhe/+2pfeZdyxhfSjBQAAQMslPnT4/vRHd3xGxP01Zh9d7IHEBw/9TxYYAAAAwFpaTcEJAACt5hWcfPapYilbKIcC0fDyK7TQEx6dc39x8M9ucH824X7327v/6XVrccx6KRkAAADWROJDh3/d+2EFs48uNZf44OG3sLgAAAAA1gqROgCATuIVnPzND4ulv/m/OfGKTlg81PPwicpr+8evd8c+87Zv1blbU9Q9OQf8tAD3qaDEnkRs/W1azE/EjY0tosaPkI9N+I3V0eiNgXRmYyeReAP2wU+kjl/E6gAAOsgbpOL+oLq7zYxOCfv56++DLRpGa0NoidmTYIvro2370az3JpY2i6K8R7beV2uTmdXepdWJ9rFt2w9tXbXjkOp9dxljAAAAANACzehwYotcsMUoNIvr6p+h80q0SMwSOaMpWiJLBgbMKIAqJZpi00Z9jnI5M+pjcNCMKfCULXEcmqGEvo35eT3+Q5s7LVLn1P6ZcxeJ6p/DAwFzLqQaIWJuY3bWjNfwZDLm+PbtLxhjnqPPrzPGPAtZ81jO33bSGBNLfIvnhRNmhIstaue5o2aMz4Ayb1KNTlGua3iXq0JmpIft8VKz5nMtEtbXZG5OPwc2KDEyoZA5b56iEqnjqVTMayOFvDnmcc1TX07O6M0r4jH9WIpFc9uVir5+WvRNUIkD82y1RAm9cMKMVBno118HFrL664YWIxMMmmNiibk5/3z9vE0M6vuhnRuzs+ZceNavM8+vlOW+rhKpI9XzyzyWcsV8fZE6z8GzL0MWK478/XOhhVRZ+qQvGIr0LbmvEi9TOqm/3obP02NkzC2IlGb019Bgv3J8Of381O7rcbTrvdpYnf1wlevO4aT+/NH2L7LBPJerj6fE5FR3b515Hol+Coi7YMYAVSwxOW7OvG+Vcr0+nNCPr5A2X7uq9x84de4+kpc3JD/1C+7wYOWe/b98327jjk2gryYAAADWTOJDjz4hAeftrAC6iiM3J/YcPMSiAgAAAGilO79x/fvpcAIA6BTVgpPjscxfH49JtegEWIVDc4GbBv74OvfN+97+u82eRwpPAAAA2lDiQ49+WRzn/awNusQfJP7bI59mMQEAAAC0ildwcvsDb3MrlcCfMOkAgHa3tOBkuuIorTaAlZt8oTi+7q63Zt762bdf3qxprHbRyVpaYTciLkaL1BGfsTplpfV5sImRLH5idfKW42tErMtqo4e0eZM6c+fn8RoRqwMAAOpLfPjRu9J7d3q9EG+ve8cVcufNdoNOv94O0xdf8S2NeE+hv+fxtW3bexvtvZ7lrtZt+OHn/Z/WijKujEmd+CM/SnprSDWmqLjkvgH5p8Ttj33IuA8AAAAANMH45NiwiOzv75ehxa0XCuZn3UjE/EzsmyVyYV3SjDuYPqm399+wfs4Y85xQ4k02bkwbY56FBSW7w/sYVzZb9ts+Q8diZtv/Eyf07z23bp0xxmzCltiTY8fM4ytZol6s0T4+RCJ6tIi2f6WSvlYaW/TK9LQ+d+vXmXEO523R1/W554aMsbmMHrmw9Tx9TZ49ssEYm5nRY2Q2bTLPW6lGHZnn0Y+f3GKMieUSwbateqzIk09tMsY8l1x8whh74YQ5F57ZtBnpMX1Sn6Ogo1/X6I+b534+r69rnyVeZn7enNNIVD/ntIiuhXn9OZy3xPUEguZEb9miv5Y8e8SMYeqLm+e9J95nzoVUz3NzP04o8Tuedco5LpbXOi0OR6qxT+b1rZMz+uMNDpoxOZ5ySX890cTj5rra5t4Wr7U+bF57s/2def7YmdE3hbLIvdNObj4c9DJSBpwlr9N5SwRMRImAcSzXZMspPZLFLZr7HBgwz+XqtpUnd2BAjyMqz+pr4vSZ53lEi/D2trFgrolYYnyKGf2+4Q3mHJXT+r6pL17e/efMuQtGzPcUUp0Pc99KL+iv7+GkuW+ewqy53m5c3zcp6a8xgUFzXQK1tS6L9H9nRh57xd+84+APfvOLrzbuuEr6GQgAAIC2kNhz8I703p3SrOIToKlOFZ3cwCQDAAAAaLbFghMR0b+hBgCgjSwWnKTLlZiIGwuG9SIMoNF+mnN3Jv/i7YWfHXDf843dX/6HRm3eLBkDAABAW/GKT0SE2B10loD8JUUnAAAAAJptfHIsOT45dkhEHqHoBADQ7ryCk88dd3L3HHflVNEJ0HoVV8KTR/Nf2P7nb/1Rox7cmdl15REROd+4xadmRs5o9Eezdz7XzJb0rQyFzK0ULS12wpaW6pmyef8BS4RPI+KI/ND2rd7+9aLkxBSTAQBoO+m9O98pIv/oe7/KeitR9Q1VqMV1yQt6y0l1PyINqPq3xcVoj9dMWctxx/VWjU2jvQ+1vQe1vB+2RAzdWSuYAgCgreR+tNvyBw3oXbGX7lPf0AGd4KPfuu4J15WXL+5qX5/ebj+bNdvfx+N5Y6wuJVYnr0T4eKJRPa5Co+2bJ5Mxv4vctGnWGPOrrERYeCoV8zN3Lm/GIngGB8woAE+haM7HzIwee1IqmfuRGNTXpL9Pj0Yolsx9fuEFM8LHc8EF08aYJ5cz539hwRzzBENmrIGrnBdSjTLRjyWvzOngoD6fWkzO0JC+3elpPR5j21bznLGdn7bYEy0axhZ9k7DEnmhsc5dX4oump/XzKBpVokIc/e1evE+/FqNd7tDisqTO8+eZZ8212rY1ZYxVH69ibsMWyZLLmeeL5+hxc/6jStRL7RGNkU2bzNgbz4Ll9SiXNZ/bobB+jW3jBn3bxaL5fLUdtxarE7Y8nqMcn1Rfj8zHW5g3j0Oqr0fmfYMh/fE2btCfrzklnuns50OhHJB9Tw/NTucq5gJ6r8NK9E14qM8Yq97XGBFxF/TXh9KC/pwPKNdabTEyFSXWJRTXz09b9E0gbM6RY7kO6Vi+s3YC5vPHtXSKqWTM+Sjn9LkIJfTXUO1asqtdT7VE7biW+HO3YM6np1IwnxMhJV7IU87btm2Ou5bvByq1F8BwIJB/7abAa77y3i89btzJB3N1AAAA0JYSew7eKyI7WR20uTGKTgAAAAA00/jk2L6PfPM6d2nRCQAA7cgrOPnrn6yb/ZMnk3Ky4qhFJ8BaKlYq0f3HSo+9cd/b/2Q1u0HhCQAAQAdJ7DnotQ5eJyJPs25oM97PqC5J7Dm4n4UBAAAA0Azjk2O7xyfHvJ/n3sQEAwDaGQUn6DRT06X3/8xf3fDPK93tak8bvSGMv9iakN5iuyExMtoWGtH/UYvU8ZSUvlq2SB1Lao3ElRZAZWW70sRIHZtWR+rozYK89mXmfNjOo0YwH60x5xEAAK2W2HPQ69W5Pf2RK74lIm948eFtcTHaH8F699co7RQlpLcx9MW2b0qrx4awHbPlPas1dma5bNttdaSOlbJ/SgvJKtt6zxe9N1WHE3c+NmzcBgAAAAANMD455n3e8IrcV/TFnS3OwY+ZWTPqY6DfbOPvV8gS56DF6mjxE5716/RoC830SX0bm5XHs8abWKIYZtNmJMSWzXrcyNycuW1b9EogqM9RULn/BksMhs1C1oyKGBxcMMbEEsdRKptjUuecS88pcQ7KXHgGBszzK5XSIxdsc5cvmMeXyejbWFgw7yvVaCVzPubm9G2kZs2IqPOVuB+pzpEZB1GlROWsW2fuQ3V8yFzvo88njTFPPGbOp+fYcTOeyRaVZIuOGlRiop5WopI8A3Ez6mPbtpPGmFjinTwXXWhGR81p55Y3z2FzG0HLc0q7r1QjY8z5/8lTm40xqcaQ6OdiMmmu1Q9/vMUYk+prmvl4Jy1xUhdffMIY81SUWKR8Tv8TskGJBzr+gh49VbEc31z69LlfdEW+nCrmswMbohKQobPTYQppPZLKiZhRNMWUOW9ii19RYmg8kSF97jQV/dSQgBKrk5/R9y1iia0p55XXxaD+98S17EcwrB+jRou+0aJsxDL3VeZhS6CoP0/MVy47V7vWbokjyp/Uo7/Cg+bf3FP7bG4joIx5KjPmtp/JOz976V+/4wc//vdffIVx4znQ8QQAAKBDJT786BvFcd7G+mFNBeUTFJ0AAAAAaIbxybHk+OTYIRF5ZKVFJwAAtIJXcPKPM8X8/5ouSLrsmlUPQIc4nnMv2/Y/3nHU7946M7uuPOIVHBq31KF1BLF1/oi2uJuHTVbZQa0riU26ZP73/z97dwIlyVWeCfuLzMg9K2uv3tRSa8VoV7MzGNRmAAEGCWPAy2A0Hs5gfs/YGC9tDEISm2jRGP5jj40ZG8RvPIyNQQ0CsdqSWAqxlSRLiEUt9b7VXllZuWfEf25Ut9Td3/uVOtVV1bW8zznywbeiI2/ciIzMiLzxvU7BqJqCtFv9BY2zVRGkApbNGMsuRzUwdtaxBXZ1pJ1CL1333MtiKEREtKwUt22+X8qNK2Cfs3jm+GkzZndLAj/tIzXwJEsKz7aGzEoc8zCXugr65qTb6B8CvsNE0FjIPFRCmdJP2EQ65+Fat676fEjEu7xwwwP40RIiIqIlqLrzeuPDmWj1Sl9wG++D0ZK0fXDLR0XkD+ejb9WqfmQ5ndZVB+ZLeUZXfcjmqqptvszM4KfLczn8VP2pajTwNSoaT4mW1/cDOjpwHyYm9JPamYy67px9vRq+Np8p6X5s2jSi2pxDh7pVm7Nu3YRqGx3TFTAkqvSi74MkEvjpeauiRK2m+xzz8LKTRb1fa8ZYnGtsNzIxiSs5dHfpJ9+dn+9cq9qedsFh1ebU6/qYsaq/7N3Xp9okOmb0e6Va0et1cnn9Ph4f08eWk0rh46te18etpdCp++agn+NGjYpBMVDRJZ3GY5TN4vauTr2vWkb1nXhcH7f79uFqLE1QJUSM48s6D1hZA42GPnat90+5ou9j1ar63zszoGqRc945w6ptcgpXfOrpKao2C9qOSiMmf/OQX682ghM6E4DfbiUq6oPb/YI+dkNUJURwZeKgot8PTqIPb3eo7/XB9TqxtH4PBhWjb1Y1jw792dg0qqYExn3nGLgP7HfqcYvWPaPHwy/oPjgtowqNn9fLh8bv0/URfRz5GX0szwkcGyhBROaomoJOSKiSikTjDI6B4/55KuaVRt66Ax9AAH4VIiIiIlpWCluHrizefNnvSiD/wD1Hi+DGwg3/8R4ONBERERERzbejsTr3cWCJiGgpcxNO/teD8XqlESRjXoBnwBAtY7UgzPf/7XXTpzr5hBNPiIiIiFaIwo0PfkJEPlG86bJvSSi/zP1KC+DnIt4LWOWEiIiIiIjmm4vVEZG7RQRX8yQiIloCjp9wIsIJJ7SyucknG//uugP73rLjSRN0nlLUznxAsTNW5Ayi//XRDVIty1cdlM5JgPI47W73jJFFk2sni2aFwCMh0s2oHSIiWuaK2zZvEpH7FzQDu4VLwUpclzw0LWR8Dlp3u+sNwDpi89C3hYK2WeZlPKek3LiucPODd6u/EELQzJkAACAASURBVBERLSOM2iHSGLVDS8F8xuqcqmYTxwn4Pi5dPz6hH/bt6Z5Wbe0qlXBEQD5fVm2HD3epNidjxHF44PeEQoeO6LAUp3EkS72GrzGTKT12VoxJX6+OJGhXFcTWpFM6WsEZHsZj5yd0n9vZr1ZkSb4DR+E26vp58KQRATMxoaN2UOSJMz6O44G8mL5PMDmp1ytRLAjerykQh5IA4ybRcavH3wPRMhId+ziCAsUJdXXjiJuxUf3+CUJ93DsdebxPUP9QbFTUbpw3urp0TAfaf845Z5/6szwjo/i2XnFax3+csxGvt9nU42kdA2Ujtmb9uinVhuKynP5+/N4+eFDHXZ1tjAWKgypO6W2WOd5rM+D4qoL3n5MF0Wu9vToCptqKyT/8PF4vNfVkExQN42d1HyLGvVO/oPdLcxSfj+IglsdL4uPTA7/JixEZUx/G+88Dy1rb52XV8LTN6nOrrPdVLI/70ZzU+9DvwhFYYkQaheBzNKzrfR31rar7luzRx3LUNyMWCUYrGfFHumdH25PgOAfH52w/9Psn1Y373NmsP/DYm2+/Uv3h+K6qFiIiIiJa9gpbh3a7697its1Xi8hd3KN0Gv5rYevQbRxAIiIiIiKab0djde5e0IcmiIiIToObcPL/7UqWi03JtpoNVjihVWmsIVc867bXfOuH19/+Qmv78ZQqIiIiIloRCluH7i5sHXIToP8r9yi1yU048TjphIiIiIiIFsL2wS1uwsl9nHRCRERLkZtw8vGd6fJfP5IUN+mEO4lWu19U5Jdf+k/XfdwahihqpxaEMGonBcrmzJfppi6R0+EvblVH3YNZ89GLJojJ8UE5ntWgYkT7ZNqI9mmB8Ywv4Hh2MWqHiIhWqOK2zdeLyCeXzNYZZROlCsrMZhOqaXZZUILQSaPifsZHfBOXG4SxOtZ3ZLQt1rKWCtiWjLHdqKxjQ5fQjeSMdWCscEJERCsWo3aINEbt0GLbPrhlwa5LWy1wDefuJceNayUgNOJGPO/U14EELfxWmynj3zKbYPlCh47fkTm2D8VVdHedetTOfNiztw+upadHb0saxF1IdGmNtw9ttxVNkkyC+wwuXaGq7x0MGFEhlaqOc8hkcASMZXpaxzwkk3i7g0Afi/WG7q9TLOIYEh+MUU8PPgbGxvXxItF46KgP38fjuXt3v2pLp/GypTK+VxGCqJyuTjzO/X06AsY6D4yN6bgsifah7t90CRe1WDugX0+MCJ6ZMt4nVXDM6S2elc6A+0RGVFgMRAY5ZTDONSNKKJnQx0sErDru42VLM/p9IlGElX7P93bj99qjuwdU29oBfNx2dOg4FcvwCD4/DPSfuF9n6nH52EPZ2nQzUBsTT+rxdGLg/l2rrGNMonUYETWNKT1GVuRMLK1fL96JP09CI2ZFwG+vMKalXcZ91saUjqRK9OLzDorJiZYHEUMoMshpgdeLJfCxHxqR8rEO/T5ujuDjFkUlSUrvJ5ljv9bH9XEeNPQ5Klr1Oh1fJVEUEFjeiGevF/UxZ0nknhiLX+kKLvn8b+x4+ORFGbVDREREtIocnVBw29EJKB/lk2V0HE44ISIiIiKiBbN9cEvX0VidKzjKRES01LgJJ399X7JerreSXkpPOiGiWUPTsR0ictHJw4Gn/RERERHRiuYmGBS2DrmbfleJyAPc26uWe6TjKkbqEBERERHRQto+uOVtrgAHJ50QEdFS4yacbPt+pn7r9+PiJp1wBxHNbbIlF77007/2qZMXiiqeWJE6JSMiJd9GRIplsWN1kJkF3D4Uq1O3yubg5nnpB2JstqCXw8WQRHAhIsx4ubYsZKwOERHRalbYOnS/iFzphqD4vis+K4n4r5/ycFhlGo2ShVIDZf6saJh8G9d4oLRkZEaXI7W+l3hJYz628T0ZAsuGJVwu17O2D5TlNCXBOPvGdmhfEJHrC1uHJtVfiIiIiIiI5snRKifuuvOcxRjTwIjJiYu+9iwbMRi+j691k0m9DksDxKEkEuCaOGrX165ORx60G1Eak1M4qgDF6ljbnc3iKJN27N/fo5Y+5+xR1WaxYnl6QSyPMzGhYw02rB9XbU4sjseuBmIQhkcLqk2iY0MfA8MjeOz7enFMRAXErFRruk2M/ZfJ4OiObAbff0B3Qg4e6lJtEh2L+Nivgf5NTum4C2fTphHVZnlk51r4lwvOH1Ztu3bjYyOd1tFFM0ZMTr0O7qO446iojyMUcxS9XgqPUbGoi2NYUTRBoO8frV+HI3ympnTfnGpF75OOAj42qjV9jG88a0K1OcVpfH6og2MAvR8kOg/r7XNSYOz2H+xVbU53p45ImZrSY+zUjP2az+nxmJk58dhwv8/eOVWvT/4snhQ5ccJJzMfrjRv3IWsgIsWKU7HiesKaPu/H8nifoFidFojqifoRx9sCo3bi+NhvTOhzWqIPx1eJMXYoVgfF4USr6MDHfghiZ1ooujzaPL19oaePZTEidWZXro9zvx9/RrSjOY23Ow72dwz0wWmM6WNOjCinVgV/RsBj1Li3f/J4/qAUe4OIvOn4Njy6RERERLTqFN71wOvcNhe3bXYTUXYs1o1BWjTuLsZ1ha1Dd3PIiYiIiIhooR2tcvIRDjQRES0lxyacTLcCN9kEz1QiojmFYZA6+x/e/q97/9tfPv4gKyeeEBEREdEJjlZB2SSzk1CuF5GPikgnR2nZ+kBh69A7V/sgEBERERHR4ljsKidERESnghNOiObXVH3Xa49foTfxwufsd9XHFnucUYyPFS1TA2VerHig5QgMRQQNRxOUBRJYLE0ksUTiaaw+oziilrHsQkXtWH3r+9b3me1DRER0kuK2ze5ptZsen4RixMi0FZPTxKUCpanLb5qROsuR8R0ExhcljbniIEpIco+P0XsKW4duVH8nIiJa5ao7rzc+hIlWr/QFt/E+GM2bhahyYsXIdHXqEvPWsugSDMWYnAmhEQ8UgMvleBw0tgnFfDixGBgkQ7OJy/CjmKJRI7amq0vHNqB/7+ze3a/anERSLx+08Pb19+P9ffiw7p8VFYJig6x9UqvheyP1ur63YUXt1Gt6nHt79LhJFCWkx0KiOCL9nkildVSF01XA60YRTzMzOAYDRcPMVPBYoPelMwD2VaWsx81ptfT7x9q+dAq3o+MOrVei21W4vVrR/Ws08LIooqbRxMvmc+DeTxRbo9v3HOhWbU5fl45fqYLIJ4mii/AYoZii7m58vCTB+9LZtVfH6vgxPRbOeefquKWpoo5Vchqgb07huLiemVpM/tcD0mw0A7zhCdyMWFE76IBuodhxtyg6wbvxX6tjsFDEjRj9aJRwZFpM8DnN79dROQ0QGeQkQLSPFakTWDEyYB0hmAMg0WkHtwuIAgqm8XZ7OR05Y8XWhEa8DNKa0TFOUdfA61nqI0X4l1hKny/9go7fceoHcWQWikDyjPvLjSM65sv4CJTkAH4uNTnd8bXDv/d31wgrnhARERHRqSpsHfro0eonbhLKdeLJ/5ZQcMguLS4vLEvMu6mwdehDHHkiIiIiIjoTtg9ucVVOruDgExHRUnBswkmz3vSj38RjetICEZ2eSu3Ic46tgBNPiIiIiKhtha1DO0TE/SfFmy8bkCD8lARyDUdyEcXky+LJnxVufPDhVbPNRERERES05Gwf3HK1iNzFPUNEREtBuSHysR/EnphwQkQLJmg1ujb9/V98YPebP/AXZ+zNhmJ16kY5nZUUq4OAoYigGBgUTyNRLpleVrfMwmtozzTIB0oZEwWTRp+R+YjUqYCxcDJg3dZ4EhER0akr3Pigq3/58mP/oLht86ajkTxvetKV+MYXCNRex+UppYE/+4+LnXmCUeJSUm18LZ6XdeCyo5Kecx33uHEtbB26W/2FiIiIiIjoDNg+uMU9kHDtQr5yMmFcgwFWVEjYxl3xRhNflyV83Q8rcmZsTJe5X7NmUrU5nofL/g8P69iMjg5c3j+f11EaTrmiY0+yGRyBgIyO6Rgap68XRwSUSvr1YnF8zX7okI6UWL8exwasW2eNnWqCfXCmSziqoAH2YaEDxzZUqzpGoRWA+xfudwoQveKsGdDbUqvjcUaRJZUaXm9HXh+fs/3Tg2TFLR0Zxv1Ys0ZHMUwV8Xjm8zqWOZ3RsTBiRAk5pWkdNZHO4O2LNfXx1d+n+ytRrJI+5iTarzr+w3qvoYgbibZbv48PD+vzgNPbq/tXNuKIymV8Purp0e/B3k59fDoD4JjbZcRX+Ql9zDlT03rdlcM4dsOKD1u/Vm/3oSN4jMYndHvTiCOanHpi/9WCUL4yNd2caQR+POH7sZMidPReOtoO7jl6INLFOXmdxzRK+twaoihxN84ZvL9rIH4lbvZDv3+svnnG7+wtEImD1jvbEd2PoKj/fbRol35Pzb6g3gMeih2X9iLXYx34fIS0aroP0TqMMULbHUMfPmJExxtxRIlefYyLsa+aRtySFX1Tn9BxSZ7R53hWv7c94x53/eC4anNi6aSUW4evEs7yIiIiIqL5Vtg6tFtErj/6n5uI4q7s33b0/z+HA35Kpo7GGt12dDyJiIiIiIiWjO2DW9wDBy5aB//qQUREtEiOn3DC376JFl+9NX2JLLU3XxLM4rFUjOoomXmojjIDqnmkjfVa1UpQBZJ2Kn9Im9U42l336eqwNnyBoPG0xKxFWdyEiIjojChsHZo8WgHlpmOvf7QqynVHJ6PoDPAp8HRRpzF7vYKfQoGMGdttmY91nFjZZI+bYMJJJkREREREtBxs+/aL/0Qk9qHjuxoYT7ijKiFOva6fZI7F8FPI2Qy+5kNP1VvVQzyzPrhWLuunf53Ogt6WSgVfp+bz+pq2VMJPgGcyelmnt08/sRzizZOghW9+1+v6SeuZEp4r1AGqfIQhXu/ICF5Hf7+uaGDTT3sPD+P1+gm84Zm0rj5RqeJr9jUDupKARNVbplXb8RUUjofGo9CBn0T3Y/jYQMdtCVSTcPKg6kZ3lz4u5lIA64jH8XjWqrhaDKrgExpVU8bG9TqsKkLnbBxVbc6efX2qLZUGlQTctvh6Ww4d0tWCnM5OXJ1h7VpdEWT//h7VJlG1Enwc7XxsQLWlk/r4FKO6iVVFaM8ePRbOxGRetXkePs+hZVE1HWdkLKfanFxaV7JptfSx7HR24ffEvoP6/Z3P6PVKVG1J93mgX79X6y1PvlSaqUw3w4x4MT+WfKJPHqimHBZxdahEQb/ngyref2ELj10ip9/zdeP1mjW87nSffq81Z/R7eLYfen/7RuWP5rQ+v0frCPT7x8/r97AYVT48q7KJBVQPgW0LKJbR3z/a1TL2n5/V722rcnYTVJtxEuAYsH7fbpSM/QoqrwTGvIpYUp+f66DyjkTbhz+rXMUTEdkonPVFRERERGfC0QkWHz363+Men5AS835bgvCZK2znuKgcV4Z6ByeYEBERERHRcrR9cMv9IjH98AAREdEicRNOPnMgXik2w0zQCvBMCSJaVBd9evufceIJERERES0Z1oSUY4rbNl8pIsf/9yK10JnhJpXsPlpq+v7C1qG7eVQREREREdFKsX1wi7v+uo87lIiIzpTjJ5yIhJxwQrSEVFuHn+fXgzDeTsTNUjEfkTqW3DzEyMxH9A0qejMfW10G5ZecDNhu3XJmtDWejNQhIiJasQpbh+4/OrmjLUcrqWySVgBqHrqyhy1d71Pkp4WbH3xItRIREREREa0i2we3uNjUG49tMYqtsSJ1ymVc9j+bxeXh22GkSkD1un4Gt17Hl4f5HC5/Pw2icjqMmBUUp2LFADWbOg5HomgePXaVCo4I2LB+XLVZyycTugS/44N9WK/hvq1ZgyN1UKQHiqdxpkG8TMKI1IkZOzsGxrSd7RMjysT6OSKX15EXrSKOJonHcJ93PqojWXI5vV6nWATHQFnvUyedwduHYnUmR/R+ctatxfEKe/fr6JoCiGZyNvRPqLZde/UYSxSvpZoifb06TsiKk0qByBgrLqZcxe/5ZEIvXwPnDGd8vKDaxDjucnkcI4PeVz/52QbV5mxYh99rMXB8Tczo91T0epP69axjvMuII1oDYrT2H9DHhTMyqsfT6e3S67aisToLJy5baYTyD4/FGjPNICHSPGHCSVDB49yCvyOjNpHmpI7E8Y0YmbCl31PRmuN6nFH8jhgRN05tQn+mpNZ2qTYnKOnzRmDE8iR68Xu+Marji6womqCsx9lD0TJu+8Cycy2/UDwQLxPC48IdRzg+B42H342PcQERPCgSSaxIHYPfgedYWcdirFMfu7VD+tzsBHX92ZHegKPG6ntwPFrraGxQufNIJ35HExERERGtIEcrqTDehoiIiIiIqA3bB7fcvYQqTRIR0SriJpz8465KK6g1414hq2cAENHSEUoXJ54QEREREREREREREdHjtg9u6To6eR9VhyQiIlowx084cYV7ONJES1/QKq33QxGvAkrNyALH2SyUmrEtIEVG6rgCjWTRwmfAQvUCjxATaoiIiIiIiIiIiIhWu+2DW64TkdutCBjf15ESlnYidcbGcdn53h4dBRAx4leQZFKXkkcRJHO1d+R1FEOlgqMtMhkdd9Bq4VyRohHV0tmp40a6OvE2Nxq4EMC6tbq0/uQUjlwYHdURItZYNFv42JgG0TBr1+qIDqenW+/XPUYkS6uFt68V6F81MhkddeDMzOCognPO0dEB1rGYBFFAqRSOlJia0lEHYvw+UwaRSBLFrOjomwBss3PgEI7juOC8w6qtXsPPpE9N6f0nc8S9ILv39qvW3m4dHyLR/sZxDui9jaJsJDr29bGYMM5RnUY80DjYV4k4Xsf4JD6Oerr1+aGrU7eJEeOTN2J59h/E+7UBzicb10+qNscH7+NUCr9PRkfxsT8OYrSSSb1ep97Q+y9aPqXPw4mTzs2VhieferTZqDaiN31ckseNVRWPUSypxzPi62PDiiZBGkUdDeTEMzguxkvq15MQj0XciPGJGxE1CHo9P48/k4JpfOx7bcwDaIHx943onHYidax94sX1Md4uFKuD4neceAofR6h/qE2MuCVp6eN+Ls0i2FctfD6Kp/BnRwje8/EsPjYkAfps8Hv0eUCiCSez/fMS6RIeRSIiIiIiIiIiIiIiWlW2D275qIj8Ifc6EREtlpMmnOBf04loyePEEyIiIiIiIiIiIiKiVW774Jb7ReSK1T4ORES0ODjhhGjlSMU6H/Q9T8KMp0vNLFe6eMysFNhGUGVpVci1ESWEi/fgQLVSC5cnyi9QdBF+NUYGEREREREREREREZ2q7YNbXJbDbpdEcfw/aSdSZ3oax8V0dOCIDcSM1GlDtYrL+6fTOiLAipFpR62OfydFUTuHDnWrNuess8ZUmxiROChWxOnIgdL8Ll6mrNfRBSJ8omV9HbNixXGg6A7n7LN1bA3aDmdsTLdnjZicfF6PZ9SPhI4wmJnR2+HEjOO5WtXxA0UQGSRRvIke/74efIzHjDHyQIxMwdi+fQf0MXPRBYdUW7TeE9++jzt8RK8jDSJPnKmiHgunr0+/N48cwa/ng4iakTF8fujvxWM3AeJsAhAtEy1b1n2++GkHVZvzyKNrVZuzYa2OqNkLxt7pyOJ9hfbrzsd07JC1bCvA29ffh9+vtaquKzA+juNbYjH9egP9ep86aeM9aK0bsY6vZuOJbaw0RD71WK3VKtfdmypx8tZ7nfr1ghlj7HN6LJxWDWyLHopIqlsfo3U8RBIG+L3dmtLRSkFDvx8iFf2ZFPWjX0eeNcF6JYrJ0ceM9XoxI0bG79DnutYkfj2UGmRF+FhjhOJzYnndh4UUWDE5VuQM+O3bM+Kdwro+9j1j7KWJ++Gj5VN4jEIjmims6X5YkTrgdCRBBbx3XJeN41aas8ddM17Lgt4TEREREREREREREdFKt31wy9Uichd3NBERLbRjE06a9WgW1wI9tk5EZ0IucdYPOPGEiIiIiIiIiIiIiGiV2T645W0i8hHudyIiV0HC+7mE4bR43t6ObD0qnxSLhz/wJBw++r+//KHrbt+/2EN149dfebGE3tOO/r89Yeg9I0y2sq0gdokrwhKGkgta3lnqHy4hlWYon9j1xISTpdxXInpqvFjmH72JFz7HnSQ3nO4Y4uI9IrpozqylPIsNRca0GxeD1mGx1l0B68gYyzZBjaNAN80pGdPrRn0QYxoi+vfROoyOZIzlF1Pd6NvAt7/PiZZEREREREREK0x15/X4RgDRKpa+4DbeB1uFtg9u+aiI/OEZ2/JQH3YoxsQpgygNJ5fVJf6teKCZGR3dkctVVFu7hkdw3Ajavt7eomqTNiN/jhzpUm1Os4l/iWmCeJKzN46rNmfvvh7Vlkzg8Vy3bkK1Ofv363WsW6djTCSKbdBjhP69s2EDfr3JKR2PUZzGkQTnbRpRbRJF7ei4pMNHdNyFGJEllnNA7JAYx2IqheMLDh3W+7unG8dg1I0YplEQaXTWerxPjhzpUG1Obx96TTwWaL/qllmHh3XfLGsGcOTM6Kg+BsSTmXgsGE8kgh95Ej4Wi4UPf+g1t39CLbeK/MWXX73GE3lRODuB5apksnm2iPxSKHLCAE4YkTqVuq5jsMk4l4yNP7FfK41Q/u++cqtRa8YDEE+C4mIiTX3uQTEtER8f+zDuBaxXjOiU0Pj9MJbQy0oUT6KjgJJr9HvYaYzgzwPU50QXfp8EDRCnAn4rlijuRZ/nonVUdaRKohe/XljXY+cljbE3ImC8LI7DO10tI4YpnsPfHxZTUMJ9Q/s66nNBf0bUDuNzdtzYr6i9NoHPoekN+nPX6rMY78GgWpdU3BsdeeuOfvzuICIiIiIiIiIiIiKiFWf74Ja7ReRF3LNEtNx4ngx5En7X88JviMi9f/Pb/4xnFNEJPvDKLx4RkX85lVF5xx3XXhUE3pYg9J7VasWe3WzEzlMLPYnjJ5ywwgnRytfly063kXNOPLGqXaCqG9ZZw1pHAkyK8T293vmCKltYFTpQBRI9j2uWtd1oHe2q6y6Lnuc0C44daBJzHiqG9nW760jiVUB1YzZeEm2fAVV/EWOMrGOAiIiIiIiIiIiIaKV5379fc0DC1PqTNyudMZ5uBVqgMkk8bt1BN3j6Hu70NL773dM9rdosI0YFkv7+KdVmqYMn+51kUj9dns/hcYNjZFTLqNX0k8liVMZYswY/9WytIx7Xr+l5+ClrVKFj52MDqs3Zt69XtUWv5+vXsyq6VKv6SfRkEh9Hu/f2qbZo+YTeJ3Fj+/bswX1GrD4nfN2ut3jWxCSuGjA6pit05LK66oAYFWeKRVzRJQCVRpx0Uq87k9HVgmbhiieVsj6+pmf0/nPOP/eIavvFzrWqzbnogsOqTUTuGR0r3BeLhV/6wCu/+G/qr7TgbnnVF+4Tkfvmep0//tyv/feZcurZQRB7XtCSi4+1V5oi/7S73KzVW370E+pxFU1ioNqI19LHpxOCSiixPD72rSofrWlddSMGKkFE/QC/H4a+7oPjd+B+1Kr69TyjqoV15kgO6M+w0PidPRbqzxlYBWWOyh+ovTWFq4HFQLWS5uSMaptdLx6jdrSKuB+oIshia4zh6iGo0oiX0eMmcxwbqFpMai2unGMJ6/o4QJVNIi3dj1heHxdO3arUU2vI+mziu/JkE0+IiIiIiIiIiIiIiGh52z64xf1qsVvClP5Vi4hoESX8YDyZbN4hIjf9yfPv2s2xX34+/NrPf1xEPn6s479/76j7VftbInLJ82Lf9h8buat8qLQr0bBmxRHRihGPea17fvdLfyKceEJEREREREREREREtHJtH9yySUR2cRcT0SL7gojs6CpUv3Hrdbcf4OCvPMdPODm2cb1dz3b/ZU/e2P0TP5EjE3fVDkw+FG/Wq/x9mmiF6M/6Q8e2JHpjV4wyREkjZqUdVlQLir6xomHmA4pUAT0w+5YC/34uKGLIGotpsKxEJeFUk8wYy+bQwob5GGa0fVmjD3FQosoSb6N3oAsRFKnjlMA/mI9IJCIiIiIiIiIiIqKlaPvglqtF5K5jXbMidYrTOhakkMcl9KeK6vdE8UB0jhhRKBJVdtcRAVakzvAwLtIyMKDjc9qJ1LG0Wvj30PEJXd7f6vPhI7osfj6P70Wj8XQGwLZYxQOOGGOUTunxnwGxKc65m0ZUW0dOl/x3Egldmt/p6dFl+BtNPJ7lsi7l39eHx3M9iIuRKLamoNosfb26bxJFGulIiBQYN2dsTL9POjpwbM3IiF7W6e7S8RHDozjiJpfW79dWgOM/clm9rESRJfq4qzfwMbAJHANR/0CEVU/3E+cHz5PheCz8hnjhB/7k+Xc9rBamFed1X929bqra+HGlFaw7edvWgvgWiX6jO0tyhTemLjrubZv241IvD8neyW82isV9vgTB7AELfqcNKvh8JAn9eeLEQD/CGfx+jXXp96vxU6PUD+HIMy+p+9E0+pzswe95SerzZcuIN/F7dJ+Dcfx67cTWhEZcjzT09vldOjpM5ojg8UHsTJjQ22z1zYIig6J1gxgZL47Poe1I9Oqxb1tcj6fTAjE58Rr+DAzqOr4qam/p9tA4BlAsTwhisZzU2Tj27vJE6beO/W+8N4mIiIiIiIiIiIiIaNk6edIJEdHp8jwZi8eDTyYTrVtvfMmdeKYKrVhuwsmRcu3+WisYSMZO/wd8J5ndLBdkNydk/RNt65L75T/2f76+d3Jn3Gu08C/0RHTGnZtofen2139x57F+cOIJEREREREREREREdEKsn1wy/Ui8knuUyI6Da7szm2pZOvv3/vyOx7iQK5ex084WYxByHVcLM97+sXJ5x3XVpp+RH6077aZ8fKRdDMAZbOIaNE9PVv7H8e/ZjTxJGPVC1pAKPrG0gRRQFacSjusNczHuq1YHaSjjWVxcRuROhijZJvbgeJzrO2wYnVOVzurbbcLKFYHxSoRERERERERERERLVdPZdJJoaOkEBUAIQAAIABJREFU2ixWvMxCicXxPVwUkVKu4HL7vq/vrFsxQPEYfj203a0WfuI/m9HrnpjApfm7usqqLVp+Ui+fSeFy+2dvHFVtEpXb1/3LZHB8wZ49uoR+Oo1fr2zE9fT0qCYRPJzSbOn79UkjUqdaxfs1BvaVFfs0PKzjj6LXBLE6VjxQra7bpw/rGBonl8GRFxUwdn5cx0FEr9fQr9fXg4+XdBq/3tiYjsLYtx/tKHEpJ5Vspv7xj/z6596m/kir0u/8+4GBWqP5/Xgstml9/sRzx8ESju7YOIDfax74VbYFftt0hg6OqbaL+86V515w8wkH9KMHPtV8ZPrHzWbQVB8IAYgQESPWpTWuz+9eFp93rAgYFAUU8/HrVcf064kRA5Pqx5FitWEdwWMtGxrj3AQxPr6xfZLS5y5LPGksC9ahj4q5BSUdl+QZ1XdQ1Bga47mgKBoPRCI5wbTuW2CMvTXOQVV/DsaNaJ+wiT87/A593m9N4c+O0D/18aifdMxd0BH7yqd/+4t7Tnht9a+IiIiIiIiIiIhWJHzjj4hopdg+uOUmEbmRO5SInkzCb+1NJRs3f+g1Oz7xJIvSKnNswkkQhpskehBc/4C/FJy/4U3+f+r9H4//1n3oyN3ynT3/Mj1Vm+7gMUu0cBJxr3z/m7/4ipNfgBNPiIiIiIiIiIiIiIiWOU46IaK5xP3w0WSiedP/++p//fQci9EqdvKEk+Vm3Zqr5XVrro4mnYxOluTw2N0ydGhHpVqbweUliOgpeVa3/An6d9HEk5oRN5ICJWjmSwW8ZsZ4PbBo+7V32gASWRbUNIi4ESOCxyp4Mx+zDVGsDu5Ze8OPopLEiDRCx4VE5bZUE4zOcUpoYYO1DiIiIiIiIiIiIqLl4v13vezWMEz+6bHuWrEbiy5s4/6rEZHS16ujACy5nC5z365Dh7rhv1gHxvTQIRwpMbBGxygMH8EP4DcauiS+s2bNpGqz4mImJrOqzenoqIG2GdUmUWyNLtk/PILL+5+7aUS1OeMTehvrNfz8cxzEy4yN6X/vTE+rFI1IoVPv74Sv1+s0G/j4ymb0GI2P4+1OgMgmFOPkTBTxPunr1uO/ceMh1eY8tmtAtbVARJGzd78+buPxsNJZqHz41mt33KD+SHSctw9NupPL3Uemy1egcSmCuJHJqj4nOg/vx+eHzlRStZ1jxPIk/Lhq68zh88D+4SnV5vxs3H12XCHr+654fNJJWP1Ca9fwt2MuV+r4ZUMQ1RIzIllQpE60fEZvX2Max5skjG1pgXFuTuhzhpPsBOcYfHqQxrixDhD3EuBTqPn7NBIav/UK2D4rtsaC4mViXXg80XA0izgiKg6OuWgdWbBfx3A8YQJE4ljjFlR0pI5YETw1vGxrRn9+Rf2b1Ps7Bn6Td+J5MHbG/oslZ8foaTnvC19/446/VQuw4gkRERERLWfFbZs3SSu4UES2iIi7y3K5uxYVkUukoi9mBFycRKzJqImTLjo8+YV7WfHkIXeNLeJ9092TKtzwwPfUvyUiIiIiIloEs5NO5E851kSUSTceSKebv/qh627fv+oHg57UsQkn0QyNVWBN7xvia3rfEG1opfaYPHrk0/XS9GE9s4CIoE7fe+SH1++4Dv1NOPGEiIiIiJaq4s2XvcgLw5eHgfcCkfAqySXBVP5FFspF0XT5UJ45+8Lh29z/Lb7ncj1JxU1QiXl3Hb2Av7uwdeh+HmxERERERDSfXLzO8ZVOiGh18bywEvfD9/799f/nFu56OlWrbcIJkkmdJ5ee/e5o0skjY1PSqt8ZTk0NStAKjKfTiFa3hOeV9r1lx0VzDUI08cSK1CkbkSVZ64nQNlixOkgSLLvY8UDWWPjGy6E+WzJGnZ0Z8Jq5BYyGQRE18xFFgyJ1LGlj3FCrFcuDIoMc9VMQERERnXHFW67qFglfJyLXisgrHu+PK3GZTpwY+zeuS+hGekBJQInuvqgm+KXC6UipprY1VXndgsTi1x7dNled5Ym/1FuuL98QkS+IJ/+38M4Hxk6/A0RERPSkjDhgIqLlaPvgFjcR/sZ2YnWqFXztU67qB757unVcTLtGjeiUAPyuNzCA4xJGRjtVm5NM6iqXsRg+z3fkddxBYESWrFs3odqcqaKOxGk08V3nZEKXxU8m1TVjpFpNqDaJ4nN0yf54HK9jYADvq+mS7vP+/T2qzens1CX7c1m9HU6phJ8LmZrS1+fr1uL9io5bK2onncb9aDX1jysHRvW4OWet19FFTnFaxxoUS/h9cvZZ+tgoFvW/dy5+2gHV5uzZ06faKhU9bjI7qUS1TRQzkvRb45lUY+uHfu32v1cLEM3hDV/bs3aiUh9K+/F1aKlLNvarNuc7j+jj+erz16s2iW6P4WrDe8d1bNqjYL1ixIKsqepzVLTeEo5OSYOonMuN7TtQLIskrvU6ctEtPGnUviejU19uNkBWmGdFsqC4HrAdEkXq4HMaWoffpc/jTn1Cx70kswXV5sRTajOOrly/XmsKj2csoz+rmiDSJXq9pF7WCRr6M8yr67bZlei+zf4D1SJhWX+eRO1g/K0YIBSp4zRH9HGb6MfjHIIoITGOF7is60dKfx40S/ieuGdc28YSen/7Wfy5FjR0P+IgxsmXsPzs2Myz1R/UckREREREi6B402WXSBjeIKG8WkKZvTOTXcVfR0N5iYi8REL56+J7jz5gkoy7O3I7ROSjrJBCRERERESW7YNbrheRjxh/JqIVJuEHu1Op5mu3XbtjiPuW2nVswkktCKIJJ2k+qj2nROp5csk5L4puWtYau+XRw/+7Wa+W+Js6rVq/Uqi9/J+vveOnT7b9c75JrMom81EZQ68BTlIyLVRlE6cOZjtZYzE/r6eaIok2XhJVgFnIMVoo7fS4nao5FrSviYiIaH4Ut212N0JvEpFzohWiLz1N0CZGWTmrsskYnvUtvWh5POPeNAWepujEM8ThDHbjKY+wgdu9mYZ7lO9N7r/in18829iRcI9//I2I/B0roxARERER0dFJJ588NhC1mr7OSaXw09TpDLjGMdqroAqKGJUqUB+cVgs/sZzP69ezoMomTgb0Y2QUV8yQUF9jWmkKXZ36KXKns6Cf7M5mdB8s6TR+qrumH6iPNOq6fWAAV+1A2ydRpRfd50oZ76tkUm9LaNyxHxnFT+A3Wvq6GB0vYhxfsTi+X9/TobfDmSnr6/OnXXhItTmjo/gJ9WlQ3aS7Cz/xf+BQl2qzjvGEcdwmQOWbw0fwcdvZWX3Q98PfeM/L7nhY/ZHoFPzuPQf7S5XGD1phuKkjlZBjR1o2hc8DFnQX6z8Ojqo25+I1uKpSX07fp8vr2OrIzin9nq8a9xAzcbyOTrCNo1aFDlAZo3KssrG3Uc5d957ohNyo75I9Y7e1WtVp9aIeqNDhGVUmYkalClRpolnE56Owqj/nrcofqJJKBNzLTIA+OEFFv57fgSs+tYwKHajaSLwbf560jO1GY4T6JkaVljDAx5EJjJFVraQF9omfw2Mf78Rj1xjT30Hi4Fh2YsbYNcf1OhpGZaBkj64SVj8wfsL//7x1ydf887V3fEstCOhvLkRERERET8HUuy97l9cK/kgKKXyFSU/VBhF5v/uv+P6oMsq0iPcx8WMfKGwdMu46EhERERHRSrR9cMvVx086IaKVxY8HI6l08/pbr91xJ3ctPVVuwkmjFQ6GYXhBy5jkQO1LJM+V9X03RDMRwsZP5ODEPzeDepW/tdOK5SadfPNNd+w41e3jm4GIiIiInpLiuy97vQThTRKET5c2K5fRaekQCf9URP60uG2zW88eEbm+sHXobg4rEREREdHKtX1wyyYRuYu7mGhliXlSz2Qab7n1uttv466l03H8hBMO5MLyEpfIhoHZSihB7fsyFv5bsxW0+Ls7rQhezAtesM6/7KtvbK/iljfxwufsP/oUpYIideQpxOqcrgroRwJXphEflENyymAdVnyOXnJhf0ipG7MNk8a2LGY/5qMP7RxHeMn2xt96vQw4ZlD5LKfrnnvxH4iIiFa54i1X/pmIvFNECjKFyzdK1rjGSoH2pi4xG0Gf59YXQOubQlmXN5S8LuXbNqO0p/igf+O4tKT04FKbcFtKbYxzMyiJeB8v3PDAH6u/ERERkVQeeSP4kkG0umUu/EfwJZSWmqOTTnYthW5Vq/p6JhbD10nJJLguM4yO4SgU38frRpE4jQa4TnL3vuu6TH0uh8vOl8s6DsIpFnVZ/L6+ompzRkb0tnR1lVWbMzyCY1bWrtHrTvh4PK2IGhSBlARRL87uPb2qLZXCcQLr102oNsvwSCf8Szqt113I4zHatadPtUm0D/X1crOhYxEcz8NjlErp8Wi18GlxZkbfU+jpwceR7+vtc3bve6JIbCFX+6ePvv5f/4taiKhNbx+adDlQ7oGkK07lX9aMqJCxaXw8gzte8uikPgc7lwzoSCpnHKx7Yz8+P3zrsYOqbWNen4Odizbg88M3f7ZPta01om+60rp9dxHH8pzXpaNJnKFDs+nY1cpnw7GJH82eRJL4M8nP6HOJ0wRjFEvgdSAohmZ2xfhzNGjo48CKkUmsAfvKuK9rnG6lAbbPB1EvMkdsUAh+1w0auB8xvajEjLGH93UNQQnHBcby+jhqjE2rNpkj0qg5qT8HQyPKPWZE8DRRrI6xT9B4+EFrZuKP7sQ75klw5hURERERzan47ks/LBn/zdFkE1rq8iLh24vvvfzts/30/pKTUIiIiIiIlrftg1vcr3j3czcSLX/pZOtwLld71oeuu30/dyedrnYnnNDCS2de523IvE6qwZTMlP6uUa1P4dkBREvQhox3/8/++51XPdWeceIJERERESnFd1/2VgmCD0so+HECWiaOTkJJ+lMiclNh69BHueeIiIiIiJYdN+kEPGpMRMuC55U8Cd5xw4u/+tfcYTQfOOFk6UvHOiXf/efRpJOw/u3g4ORXw2YY4JJMREvAZV3eXw2+6Yt/cDo98ZthGLPiaZK4uS0tEN8iRsQJinpxMiCSxVIL8DqsWB2kYawDSaI6PW1KgLGwoNghaXOMLChWp53Xs5ZFkToWa8l2opKs10PHV6uNfU1ERLTSFd9/xYUi3g4RuVhS7jrouGuhKihZmMTXSqFRvtGrgNgZvKj7gqSaYH1Ep4hLL0ovKI9sxdYkjXKK6DV9vN1Q1li2jMtWwn4Y4ykTYFs6dXnEY38RkY8Ut23+iIg8ICLXF7YO8YlJIiIiIqIlbvvgFneNds6Z6OVUMafanM6Cjh8IWuBaRkSODOPIhTUDk6otnwfXjNE9Y3wPd3pa9y+RwFE0pZIuf4/aZuHXW7tWx8vs3YcjHkJwGWfFEWVA5IxEsTq63YrU2fnYgGqTaF/pOIBsBlxLisi5m0ZUm2VyClfgz6T16zXq+Lo4HgPbYuQzgCvzSCKh71WMTeD4grPW6+giZ98BfYwmwdhLlCqhj/PpEr4Or9Zy4sdbo9lM44pt1+7QuSFET8Hv3zvaI6F8q1KvX3Lyv54o4XPouet6VFsL/ObmTKJ7dyIyAGJuLurBMWE/Hdbnd+dZm9aotimjz/qd5n6DxOfQwZ2n/vbaYMTkPHhEn9/7QASJROcH1Dt3TtPt53Ue+5y6JnZ+/zXSbI7Lj/be2qg1Qf6bWweKTkngc6gHInhiafDv3Xl4FMe9+AW9XwPwW7FTH9HnUD+DP0c9454xitVpFUEsjFsHuic7+xfVEjOWRdE3libYvmgdYBubZXzcJsHrJTr1d5WIcRyhe9FeXO/rqB8V/ZlrCcF65Wi0UsKP1Z4/ELvqy7/9xZ+qBdqEe0pEREREq0bxfVf8voQy+9SN8Z2XVhT3NMx9xW2b3TbdXNg6dBN3LxERERHR0rN9cIurWHgtdw3R8pJMtv7qI7/+udN6apzoeMcmnIQiasIJLR++3yPPPe+DiUMzNZmp3BEcmB7knVg6ozYW/B//9C13PHO++sCJJ0RERESrVPF9V3xWQvl17v9V7cbits03Hq2CcnVh6xB+LIWIiIiIiBbV9sEt14vIH3LUiZYHz5NaKtV41S2/+sVvcJfRfOGEk5Url3lV7KLMq6TW3CkHJj7ZbIYBf7OnRePHvNYL1vqX3/lf7nh4Pl/Tm3jhc/a3Qtmg/hLF4aimBTVtlHbqWOyOLBElMB5WjMxyVAcxN/MRXTQfuu65d3UedEREtOIV333ZGmkGP5Yg3CDdIIoGRNNFUJnFOi49a1QlRpUQRcD3gYiulmt+ObWjfUD/0DbPsW5pgI4kjevAGng9K1LH6se4LtUYGmPkpcBDEQnQJnP0WW/fLyQRf3nhHfc9ppYlIiJaASqPvBF/sBKtYpkL/9H4MkxnyvbBLVe6KoUnv3zQOvVdZUWyzIfxCR2vkEriiJtcFpeBL83oa6J8Hpfbt4yMdKq/9PTgOIHhYb3sunU6WsGp1XBUQamkIwkyRmxNNquv7SzW600VdWRMOqWu4SKFQkm1SXSJr68R9+zpVW0SpbzqZRNx/HqWDhDtM2NE0aCYnGJJHxfO+rU4AuHgkYJqu+i8I6rN2bUHxyKhd1W1jq+hk6DPnifjuWz98luvu/2A+iPRU/T2oUmXAXX30aq1ythUWbX1dupzhqVcwefsWgO350HcSNm4L9iZ08s6Abi/Va7ic+gkiODJoBgaETlQ1PFvznm9+vxQruHtyyT1uneO4GezEsbvmJ1pfa6bMrYv7etzTL01JQ8e3l4pNWdO+LDxjMhvFPdiRd80ZvSyTqJLx8A0x/HnSWqtjiULqng8vawei6gdHAONoj6WZ/+gz7dOPAc+J4w4InSfO6jgfeLF8Tq8lN5XVt9aYJxRVE8krj9zZ1eC73MjYYCX1VsdZcU9/j8vLXifGXzTF35LLTMPwGgRERER0UpzwoQTIttFIvJo8Zar3F29Xym8474fm0sSEREtS/A2HBHRkrF9cMuxHxuJaAlLJps/SCVbr9l27Y6D3E80X55swgmtXMl4p7z4wm3RpJP79vxleW/5sVOfSUR0CjoS3vCB3/vCmoUcK048ISIiIlrBiu+4+BzxvO9ywgm1yT0W8qPiLVftczc7Cu+4Dz8KSERERERE88394KjLcxDRkuAmnHz0dZ97DvcGzSdOOKHjXXXO27NXHZ2Asq++hxNQ6LQUfG9sc7c8/4u/8YVfLPRIRhNPrMri7QCpMDLXuqugnI4VqaOXFJluotZo8FTbmVAB5XsyqET9HFZSrA5iVKOCWmA848Z41sCxJUZCgFGZX3TBKCIiouWn+I6LHwib4eXiGZ+NqByib5T5Q6uwyhgWdWndCPjcNWNkOkBJRqNvXtLoR16vIywZ5RQboHNiROKMGeWfO3RZTkHbMZeE/sLiVYy+obFLgz7MBX3fPHG9G10l7eL7r3xYYt4LOAGFiIiIiGjhbB/cctuxHx0rFX0tksnoEu5nQk83jrNpB4rVGR/XsQgyR5wNUpzGv8+tW4sjE5BUClwrRzER+tpzfAK/XrmsrwU7OvQ2O5NTOurAqZT19V21Aq4D3T3xuu6b0983pdo2bRpRbc7BQ92qLZXCURo5Y5/sO6jvrHd24HsEZbB9SR/HF4QhuHY1ooCsSJ0Oox/5nH5fHQERPolk63t/+drPP1/9geg0vPlbh/sarWCwqyNzIVpL3PghrVzT78FeweejfcP6/NffmVdtTncBrwPxjNiaH+7CcVfPOlcXWvjhvmHV5vRm9Wdgj2qZ1WdEmaDfrR8CY+FcACJn1uR1vJozA8be6QbLHyzh8/6RCj4f7TtpeT/z37LnZ0QmK/9YH6s/csIHSxzEA9WN2Jq4EVMUA/daA/B7rFM7rG8J+gU9blE/DuNxToLjK5bSn5dOvIBrZwTgh93WNB7nFohFT63Tn1NO7RDusx/o46sJInWcOIhbakzi6KJ4Vq9XjGilhrF9nrGvEp2z+yUuYe153cH/86U3fOETaqEFgvcaERERES1bxXde8rdhPfg97kGaRxeLJ+PFD1716cKf3/dGDiwRES1bxs05IqIzbfvglutF5E3cEURLCyec0EI4NuEkDEM44YToeF2ZNya7MiK1xr+19pfv0TMTiI4Tl1jjws4XbL33N9/2kcUeF2/ihc/ZLyKw9Lp1KY7n152+Cnpq081oNmb0taMJbiz4qARGm/Ra52+M0Gw89FCqUwYLZ62F27CQ+2ShoOooMkeFFKTrnntXdrkZIiJakabefdmLvWbrSxLKiY8FdOmnBCLoc76lZ41H4noGvIBZ45EMnkUvU3o2eAhm1ktUqQx8FDf0k0yzr2fMpY6BdRfxUwmSN9aRNNoRMB4hmIXveGljvWicre22Ks4AZqUXNM7Wao8fT0+eW3jXA99XyxARES1xlV/8NvgCRLS6ZS76J/ClkBbTtm+/+DwR79HjXzIOKjlMTuEn1Ls68dO0C6Va1U/0Tpf0k95iVNxwSiX91HM6ja9bRkfxdqcz+hrMGovpkn4quyM/o9qsvklUpQU/SY6gdZRKetycegNfH6Lb3GsGiqrNmZzUr+fkcroiQSvAb/lWU7cXp/H9hHVr8X5F+3DX7n7V5lTr+t5BXw/eJ9ZxVK3oJ8bHxvW+dkoVPP7IhrVF8bxwx40vufM14M9ET9nv/PuBgb6u3NcXIlKnCu5LOemUPsdYVUmsUImrNulqJd9/7JBqc9aDyh/OxgFdaeJ7j+J1PO/8daptdAqfg4en8XnjggFdxWmqjCuNeODXXqs6Si6hz11Oqa7Pfxd26+pJzs8n8Lk86+t9dV63/gx8ZO/fN382c59aGH1uOEEDHxseuA/pGxVkYuBeZrOk7/WKUY0ler2sPg8H03gdTaMqjAdutcbz+LMqlgfbYlTqqY3j4yjVoz9TAtAHJwTjHNR1m8xRrQTGdxjLhictm/SztbM7nvuh+37nj25QCy8SfZQQERER0bJTvOWqL3uN1iu452hRhHJv8X1X/KzwrgeezgEnIiIiIjpd3t0cQqKlIZNqDN300i8/g7uD5pObcNJsBd8LwvA8DiydrgvPfrN/XigyNfMT+d7+jzWDMODv/atYKtFdv6j/N//n4Ote/vEzPQo8EImIiIiWseItVz1DJPwR9yEtulB+qfjeK0Lx5BWFdz3wFe4AIiIiIqL2bfv2iz8t4m3k0BGdWUk/GM9l65ffet3tB7graL5wwgktpM7cJXLN0/7KD5qTMrh3e2WqNoHLzdCK1Ju9Orhg4NW/8c1rL/zsUtk+78gvP/tQ0vPWqr8YUS9ixL20s+xCqhvlZpKgNE0NlZd3M4PaiJFpZx11Y9kkWHY5mo/ta+c4qlj72gg6QuuwMGqHiIiWg+INl94ureC6J+1qFpc3lCIoLdiLSxOimBxzvVYEDIrxqeny0RHwvSI0lvVyRj9QzE1el3Sc7Qcuewi3xfqWUNbr0FtxdBXG9xizf8gY2CfW/psAyzrdYPlhXLrUXLdEY3Jn4R33v1K1ExERLTGM2iHSGLVz5mwf3HK9iHzyVDvQaumS+BLFyOiYFStypmRE4uTzFdVWqeBrgEzGuL4A6iBOxUkm9fVouYxfL5s99deTEB/OM2DdlQruWz5nlPeP6WvMMMT7pAxiXXLGdqRSeiyidczoPk8W8f6rVvG2JBP6OjqXx9vXaOjr38A45mo1vayz8axx1bZrL47aCcF18UAfvh4dHdPHeNQP0OcU2OZo3f34PVGrJSq+3zr3vS+/A2ePED0Fv3vPwf6ujuw3UKTOniM6wuWcNTqGxtlnxL2g2Bq0Xok+O/S5Kw4iVsSInHGOlHWMzLPO1fE7zkxFLytRvJa+b1YxYk+Qx6bwe/iFF25QbZbDY9PwL9mUPofeu3dYtTkdYFnnl/o7VRuMuHa3G3197nJ+tG9EtZXqeIyyIM7m2Rv7Zd/w16r3Hvx8vBkGjy8QGuMcgvuvKH7HiWX051q8gD+TLPVhHZsWM8bC6ke8E3weVPH2NcGx6GdB/I57n1T1smLE+NSN48jP6mWNryXiG/Hu1VEdwxTznhiLeCLT7O9+q3dh5zm/fuerL9ihFj7D8FYRERER0ZJVvOWqbpmu7xQJe7iXaEkI5RXFD1zprh7PLfzF/fpOIxER0ZKhb64SEZ0J2we3dLUz6YSI5l8sFrzqllft+BKHluaLm3BSa7TubYVynp4aQrTwNg68LL1x4GXR6/zo0Q9PP1L8WQeHfXnzYrFgTeHXYonUM1qbCtnXLcUJJ8dw4gkRERHRMjIbrSM/4o8mtAQVXB2W4i1Xvr7wjvuXTIlHIiIiIqIl6jbuGKIzw/PCT934kjuv5/DTfDl+wgkHlZaKZ57/xx3PdBVrxvfLzw5/qnqg+IguyUFLkh+LBxu7XyaJzK/Eas1WuKmQfc1SnnByjDfxwufsb4YhrEPkGyWAVjoU9zIfkUEltGJXum+x84gWmbHZ0gCl9NJtxPLMR7SPFZW05tvfZ4lRIiJacorvv/ItIvKxqF9FUP7PNz6+CriEoIzpUsrSa5RIRLEu3cZ6rc/iEVAy11oHiskxSi9ak3DCST1GXkGXoYwY5Q1hqcYG6JuTAev2cVlIKem+iREn5HXoUpYRuGpj7Kfx60kBrNsoZWkaAcdR3v9Y4aYH36raiYiIzrDKL34Lf3EgWsUyF/0f40skLZTtg1veJiIfWcgBbjbx9VO9Aa4BXMn+DPhePw8mp/JwJfmcfr14HJ+iPc+4BgMOHerWjSKybt2EarNigKZL+He5dErHROTAdjgHQT+sn1vyOXy91tExo9rGJ/CD6406vo4rgm2J4UVlwzoQ04F3iQT4glRGR3Oqbc2Ajg1wamD8JybwPYl6HV+zFzr0vYq8ESXk+9H++2ksJi94x4u+zkqdNC/+4Ifj3Z7n3R2PeZcv5ogWS/rYL4BIEGc/iDc5a0DHwszlJyAC5sI1+jznHBzHMSQpcO9tXQ8+p92/R8fcWOfQuvEj5JWHtakBAAAgAElEQVRn9am2/9ivt8M5v0+Px89HwDnRxaA19GeBRGnd+nO33tT3+ZyL+3E9nFJNfx6UGngd3Wn9eW7dkh068sRnYE2qkveHmsPyXb85os/PTRCJ5PgoYgj8zhsx7i2i2BrP6rRxH7g5qT8bEzm9XicAY4fidyLGtnjo3i5Yr9MC97Pj6H6xW7ai7zn78USzK/+rvsQ3R/9/IhYLzu/Ov/5r1174ObXwEqXf5URERES05BQ/cOUHRWQr9wwtB2Egv1e86bKzCzc9+EruMCIiIiKiJ2wf3LJpoSedEJHmefKcv7j66z9QfyB6Ch6fcOIt7oQTotOVkrQ0ms/3u+X58vTzO2Ry5gfys9Hbq/VmBc/eoAXVmd3QSOXemEh6rpC0+NVma1lOODmGE0+IiIiIlrjiB678jITyG9xPtJyEgbyieONlDxRufvAK7jgiIiIiosct+TLpRCtLePuNL/nKr3Gn0nzghBNaabpyz5bn5p79+KST4fHPNX8++m1ptJqcQ7AA+tPnVbqyr8qUGj3HVv54SZR4LNb6pd7cG5bjhJNjoqgdV0VN/WUOdVBuJmnVODJUQMRJxiingyJq0qCyjUTFxfE6WqjPxush+l8fe72laz6iaOZjHfOhnePFotdg77+ue+61/kRERLSoiu+/4l8klNep10yAcoMzukRfJIdL+kFGqUCZBuvuWcCJ8KOgXHEfLrkrLV3GMILibLLGWKDtk+hLj2qSqjFGKOrIGnu0/9z3FRB/5GWM67w66Af6wuOk8evB7R7IqqZIYIwzKCMpx0cGed5PCu996FK1DBER0RlQ+cVvWp+WRKtW5qLPgC+ytBBu/sYrbg6C2LuPXzWKU1mOggAfRqUZfH2RTunrtakiXra/T8dESBRn06Pa1q/DCSrTJb3uZALHCVgRPGhfzczg69RKRa+ju7uk2pyJSRxHVOjQ14fJJLiGc5fFLXDtKiKP7lqj2vI5HEUTtPQ+LHTqOA8xInWcXFavO5HAH73JpB7/Mhg3iaKg9PEi0bbo/o0fHU/PC8u+Hzzr5pd++WG1EFGb3j406bJR7h6eKMGHawLwG9aAESOD7q/sGsaxLuev0+c5Z+fBMdV2wfpe1dauwLjHFjOiU04X2o52t+VhIz7n4rP6VZulWtPno+/sOqTanKf3FlSbkwfRN/cfwp9JDXAMOOd36nOrb4z9z0GkEV5SpGJE/lwxoOOSJqsnnm+L5R/I/uI3S5Nj+9WHVYhiaFyfO/Bnowey3jxj++pT+jPXSYH3VWNaf15aYsY9WSvLKQT7KijjzyS/+8Qh8r14Y03mhTITXJbIyolxTj3HHS+e59UHsqlrP/fyTV9VK11mjLvYRERERHSmFd916V2Sjl/NHUHLWhheUrzh0oc4+YSIiIiIVrP3fPPlfUEQfzcPAqKF58fDz7znmjt+i0NNp+vYhBP3Gz0Hk1ajQvbZcnH22fkLrnhikspPdn6s8bOxoUapZswuXYXi8XiwJnFFU7yrkp73eL2PRBjExBqklTTh5BhOPCEiIiJagoo3XPopaQVXixizsImWEzf55N2Xfq3wnodexv1GRERERKtREMQ+yx1PtOCmEonW81nlhE4XJ5wQ2S654PcSl1wgiZ1HnqjoUgsmZWrq31uHZh6oV6WCS56sAMlYspbOb/RS/kVJL/XC4zco5nmiy94AfsxrrsmlX7WSJpwc44dzxI2YdMUocyVoUQf9hGLFuuTjxsrbEDdK5CBlEO2TnYc+LCQURzQf47bYkTqWdmN1ENYMJSKi5aK4bfP1kk/+TtTd4TLudV6Xnw0ruiyk46FIFqcrpZpOiEg5YSWqxQbKU0b9a+rvKx6Kp3G6Qd9GjLFAyzqdIArIiiOygO+QeitmeVkwp9t6vQ69XsfrBn224o9QR9C/d45YYweuh6xjzih9KZ1gHRm4fS8tbtt8U2Hr0E3qL0RERIsFfX4SES2w7YNbrsvnBVazrFTwd/hMRkeIWFBUS3cXjnWxjI/r6AAUhSJR5II+mc7MgOsCd9nZhUvlJ3y9bisCxtLdpa9dmk30y4NIsajHuasTl+b3Qd+cgwd15AWowB9B0Td9fXjhvh4dl+BMTOnIheFhvZ+cs87CcRXi6X21fu2EapMoFkn/TuiBfy/R5SHeFnAJLWPj+FlvtOaUEX/UaOD9etLNirtueumXf0UtQtSGJ5twMtCtz7ftOgQiRHJJfZ9vLklwj+YQiF5x1oFokuEJ/BnRzvY1jPtVCSPKBL3nz+7vVG2W0Unc5/WduM+lsv5M2W+MUV+HPk89w4j7GZ3Wnz3OL8aLqu2iHnzODtFgiMjuoj42nmFEBu0Bx9HzL9ig2pzBRw+qNomqmeh7qug8Lkb0UPmECJ+kSPyaeEfhmsyLQITPaOn7Ug32TkxV9zSONIa7WkEr+uKAomwiRuxTfUqPv5/B30GaFX0MSIiPz2MfJ5l4bro7MRAUUhflEqlz/anqupOXTA3k9HcKp1Qz7gMfE4vV12dTr7n9lefdqf62QoC740RERER0phS3bd4kIp/kDqAV6sbits33F7YO7eAOJiIiIqJV5DbubKKFE/OCV7/7JV+5g0NMTxUrnBAtrL78c6SQfaGakfKdPYfV6zbDMYkn90X/u958pB7zwmgWSrNV9WrhaP3k5TOp5EkzTGLxntR5wXSyEs0oCr2elEhvNFvr7J4rJOHpiSOxJyYynjBTa6qqJ7q0bRVMODnGD9ycV2NqlWc82oqXxvAa3EGjmsyqIqCYhxiLzgurH+0AXTbHAm1fu9s4H9VNkKZxbPhgylvFqFgzH9VK0LrnY701sF4iIqIz7P4TXr7DeOJhWs+g9hL6aYeIVQVjEjxBlzZmfefBOozvCVa7lwL9K+OnmWQGtIOnOeZsR9VGcsZ4omWdHr3dZgUZVHEmZYyn1WcAVYqJ+oHWXTG2wzo2wDiH1vdK49jwxsBxZL1eT7SO24vbNncXtg5Nqr8TEREtOPy5SkS0UD5w90s/KJLoTCbxd3Wrskmjoa9dWgH+rt5OdZOpoq6i4fT06Ce125Hw8fZNT+sqGtHrdeunzo1LSbOKSTyur83CEI9RT7d+MnxyUj/h7qxbhyuCoG3p78fj1mrhfiC79vSBVrd9+mnvQgE8vR29Hh6jFKjesmcvfoq/Dsa5kMev1wz0ss7AwKhqi4MKOc7wmK5SkEjqbXYmQcUap693+kAsJpe/40VfH1d/JDoFbsJJrdb8TihyyfFLp1PtPbcfgOoMMePeD6pA0q6z16jf7017jujbL+es6VJtzk/2jag255KNuuqGVdnE8jBYN1qvs394SrV1o3uTbvtApRHnYlApZOowPlVsTOr9vW8Mr/eXzsLn7HPBMbDzEH69ZAwfG6j924/pSiPOf9q0RrU9vG9YtTkZH++r7+45oto6U/r7h3Nxn65O8x/D+thyvn9Q72vnyjW6clhvRlddEVkvTx849pa85oRyJt/YuV/9g6vPXQ/fVN/fr/vRmdCfPc6eIp5g0gJfTsYrau5LJH3SOHueV0/HY7/z76+56J/VwiuUficRERER0RlR3LbZPQWnv8UTrTyu4gksNU5EREREtFLccs9LzxeRrdyhRPMvn61/951bvv4CDi09FcdXONE/KxMRPXVuwsnabOq6z7/i3K+stmHkxBMiIiKiJaC4bfN1IvIm7gtaJV5U3Lb5+sLWIZYcJyIiIqIVKwzlr7l3ieZfd6Hy1g+/9vMf49BSuxipQ0QLZTVPODnGj7loIxCbMpc4WN6aEaiXtFWMzJkMKPddNpZtJyYHlccRY/vqRiRL0oh7Qes2uiwVo3x61tfrtl6vDl4vCbajXShSx4ILNc0PFKujt3iWXtJmVKckIiJafOOV28DHuXhG1E4IPhs98N1hdmGwYqcLlKicxmV0pQXKJluxNXVdWnJ2HarFBTGrpkgBzI+uGeu1om+s8UC6VJXGWcOgzKL1fVNXMHb1G1VTpGH0GXzn9KxxRkq41KMkcJ9DUMLTqxl9Q9E+YsQlZY1lTxzPTxZvuPTrhfc+dFAtR0RERES0zN3yrZc80/PkmifbipkZHd/i5HIV1dbGlYGps6AjZyy1WhL+Zaqo++wbcSpmhA+IxEkkwbXFHFB8kRUlhC49GyBaJupaqK+TnEpFX6d6Hr5OrdX0GBWn9b93BvpxVFK1qpefnNDrnUtPjz6OjgzjmIFsWo9ntab74Jx9Fo6P2PnYgGrLZvB+jcX02JXBGDsDfbNjFPOkkki0Nt38si/hPAkiw1wTTtqN1UGsWJ3TVSrj+3T5rHEfC0CxOmUjqnlTb0G1OQdGdPRNA0TLOJM1vO4EOBFPTutzlHPWgC4IPT2Dx6Ju/Pi6C8TcPOe8daotWkdTb4sVqXPIiODp79Ln1tEqvk+30YgNyif151JofPofmdSf55eerc/Bzl0/36/axPg93Joz8OODOkrt+eesVW3Od43IH3TMbCzgz+3v7dUxQM7l/fp4vhfEODk9Gf095mAJH3O9aTzOv5jQkYgXdZ2Y7ON5UkmnEq/8zH/eeJdaeJVhxRMiIiKiM6x446W3hiEjdmj18ZrBJ0XkZdz1RES0ePCNaSKiBcDqfkTzKBaThz7wyi9cxjGldsw14YSI6HRwwonGiSdEREREZ1or/FPuA1qNwnrw0uKfX/yCwgcf/g4PACIiIiJaKT74rZe8TkK5hDuUaH74fvDx9738jrdwOOlUccIJES0UTjixtVOAfE5WFE0KlE4SIxIHrwG3G5WT2oJKCDkVsC2guxFru1EkjjXYDV05qW3zEatz2n0A2yxG7JDMMf6naj62OLMExo2IiFa34rbNb5OOlHhFXC4SRa84Xh8orzsCYmGcOC5rC7+cVHDMSghK4HrGZ7xYUS2o9LJViXRav565bAKXQhRUNtQqn9oAryfRFxzVJHnj9dr5dpIwvgCWQZ8tge5zaHy38RJgO6weJ4wx8vE6JAnWYvQDSsX+p4hw4gkRERERrRi+33znqW5LIoGvASandMn+rk4cybJQSjM4yiGT0X0uTeNlregbFPlTq+qS+M5MGbejfhQ6cAl9FIkDrlDndM45OmagXAHX5m5b6vq6qjyDryW7u/RYOKOjeuw6u/D2WcdGpaLjHDry+P5DDFyz55N42aqxry44T8cr/PwRHG3hxfTr+aAtk2188H0vv+Md6g9EwB/8cLzbj8fuQhNOGkbsccK6R7NAZkB8Ts6IzgmM+4LI2BS+L9hs6e1e09Oh2pxREN8S9Q/EkHR1ZFXbnH0G9xHbiShKp3QfonZjHd15fH5GfrJfR7UkjfVuAJE6Em23/px5wQXrVZtz324cI1Os63u4WeM+XQXsV3RsSZSWjtdxycZu1bZnHEcJ1Vr6vP8DMG7O1ZtwBM9esO7JKu7zmhzef49N6WO0L6s/6yTah/r+5K5J/HmZiOvPXImigJ7Y374ntb5s6trPXrPpa2pBmh0jDgMRERHRGfU2Dj+taoG8XkTesNqHgYiIiIhWhu2DW65HP3gSUfuy2cb1t153+6c4dPRk3IQTEblHRBjHRETzihNOTh0nnhARERGdIcVtm692D01x/Gm1K9542Z8Xbn7wg6t9HIiIiIhoRbiJu5Ho9OVy9Wdsu3bHEIeS5sIJJ0S0UDjhpH1+MwxjfptxIyjmxorUKaGFXYk2UN5Gt9jrSOEKR7BvYkTl1EFZJycDtgUvaVcRR3E9aL1ijEW7GmBbysZgJIxOo/gjC9on1nacbqROuyabum9OB4gTWNwCakRERCcp17fKsSqMBVxSU4ZxmUwYGaMrOs6q6tKLkYT+bIRfmtx3nl5Q3rCmyz9GWsYXtarVQaATlM+0ol5iRjvabCuOqFOXi4ygTfSNbxBjVdVkfmnNgv0nxvgfwX0OQeSPZ+3rXlxyUkDEU2jEDnm9xnanQLuxDniM5qOxv8ZF4au/ERERzTt8z4CIaD4crXbS1sMFySS66HDtoBR8CK4X3KVPoNvjcfTlW6Te0NcR0euByJ/enmnVJlHMir5+XbduQrXNBUXwZLP6+sTJ53C8jHj6nN4wtm9ioqDaEsbYo1geS6uJr/k80LdyDV937t7Tq9okipXQ/SvP4HVkM8Z2T+oojISPrxsnpvR1f1cHuM51/Sjj12u29LHY261jEZzhMRD1EXoS88JmoaO6adu1Ow6ovxMd9fahyS4RuduPx065wtRCRuqMgviOPiOSxYrVQQp5434O0Gks6xuRMUhflz43Wyan8bk5BL9XOvtARMrlG/tVmwWvVWRjrz6/O4cm9GfY/gm9n6J1gH31yJiOhXE6K3XVJtH5Up9Dh83Xw+N8CMQlTTX0Z4Ez09Cf25cYx9b5xhh9a9dh1bbOiCg6O68/T34KonOcXUb7AFj3Q0fw9wfwM3TkuWevUW3f24Ojiy4A43xeN/jscRE+xx0vyXi8takz+7qvvvrC29WCNCfjjjcRERERLbhAXsRBJorwvUBEREREKwGjVIlOw7FJJ7dedzsnnRB0bMIJI82IaL5xwsnp48QTIiIiojOgeNNlr3UF0Tj2RLNc9FRh69DdHA4iIvr/2bsTKLmys07w3419yciI3LVXlcsbGGNZYLIWSSXhBRu72jbF0AxDt5nuHhrwHLDVZlgOYAMHDD3VMjDQ0M0w2A1zMGBjl80BMwaqXC7LFDSyMHa3u6hdKkmZyiW2jD3izbkvU1Wq/P5fVoYyU5WZ8f+dU8c+N55e3Hffy7fFe9+fiGgnuvfMyXfwh1Ci6xeNBF0+dEIWPnBCRFslKtJ4+Wjue/jAycbFos4FLRAL4yWMaBhUAbxu1Lyx4lf6gebRMUo1gUlNiT4iYPpdCitWpx9ovRgpMjAmJw+iZbZS3VonuNncvjaqcIOXm4iI6Hq4VvctwbXRMynjeeAsLl8rS7qcogwb06JYHglfJVJNclmXdAwVdXndwDgxcXGjhCf4OpnUZRpNVt+sOJtRUGL0oi7rGUr0MUYNMPZWP1pGieY2LsspYBYwdsgPZw2URx7BJTXNsdujx9+hbUvWOBFFYwRigEI1UB50YWXbikf+9cpNJCIioq1jHM6IiDbBmtVOlpbwewdZI0am3dbXKMWSLhnvTYyXVJsFRer0K5XSkThX5vKqzRvO4WuR/LC+NqtW9fWJF03jMYqA1IxOBzT6gqMgjmikgCMQZmYKqi2cB4g62rsHRwSUyzq24eW36kgD758e07EBYvS51cbLt1QD178ism/vgmp74kkcbRGL6OvXel1vh974uF5/Eibh6nnUujge6OD+58bOiSxFIr2bf+YNfz6nJqSBtpkPnNSN+znopy0rvqrT1du4rBGrs15WbA2Kb7FYkTrtju5z3Iiz7hnLFwHz7qdvy9PjfTxSWtLHmaCH+5ZN43thL92nY8xaRmxNIq73dV3j+9IJvG0g7Q64dxfuK/X+3Xv1TZOq7aFHL6o2CZPVdf8eeOSCagv7bMSGv27/uGqzopLiYB75JbzdpsH24i3W9P3laguvk1Fjvf79M1dUW72D55FL6Xl89Zp/H49Eu4fyme/6i7e/7E/UhHRd9F8SEREREW29QPCdLKJB1Qumue6JiIiIaCe698zJE4yPJLo+fOiEEFY4IaKtcvWBk8/ygZNNxwdPiIiIiF4Eva68Dj/bTkRERERbB7/BR0S0QWtWOyEijA+d0Grfdt8/3fSqgxP38YETItpszknt1pHcv+ADJ1vHh5IEVuRJtY/4HKNqjglF5cSM6BvUD9SHfjVBlI0YcT1W37YSWi+4KN2NlwLr26okH0cDakDrWoz1jaKIxBg3IiKi7caNpZ4QkUPPdmtBlxoMFXRJwFA/x7smLjcIo29A9Eroii6P7JK6xGIoAU4UJKyzqJoswZwu1eis+fYTszdqnE1VjegbMO9gCY+nGwMlRuu4jKsUjfYJUB7Zmke2j2fIrbGb1etV8n2OUQH0uYHH6AWilV6mWoiIiIiItrl7z5z0b+W//YV6mUgY5/UGFBkzlNXRA/3qN/JnvfqJ+7G0O/i6pRvosfAaNX1NlMnga+t0Wrdb8UCZLF5XuSEcL4MMD+sYn/PndeyDhJE/eOxRFNDTxjwadRz9sBAMqzZLLqe3L/AzTqhcwfcqUil9LaivqpdFIz1xLjjy06//DB86oWcrnLzq4MRrqjW9LSZAzEfYbkUnA+kU/jvphxVns1H9xtb0w4rVQVCkjlcCUUDlul5P3rARkTJT1vegGkaczT4Qy5NO4vXXM+aB4spQpI537qlZ1faySVys+iuX5lWb9y2ZPaqtDeJwvJpxr/arXzuv2t7wyoOqzZtZqKg2c5/dwPf0nlrU8/imW/RyeH8N+jaeBfcEw4gbfG+xC34DPnpIxwt5SWNdzZT0sXFyn44MCqctLx+3I841Mon42z76xkN/pSaiTYXXGhERERFtNXz1QkRERERERDsJq50QXYeIC976U6//zCMcu8HGSB0i2irPPnDyJj5wcqOs+eAJqjJhSfRZEaStH2pCL5Sa/QD/PNQzHueKgv4lt7AyxhJ4aisLlkPWqLwCZgHbPPTCcb/rpB/Vrp64YK1AA5gFXNeWeJ/rDw0da6MQEdGLptZe3wV1Cb89IHHwBoJxHiQ5/KYBqqQRLOm2UEa/VeCyui1U0m+ShZrgKf8MaPPzRsd5qxKH8TaGoGVpoTOQNSrLgPMpZ70hswiW26ryMmzMYw7MI2ksX1r3TVr4jYnAON90BT2mATpR99Na5e3QWxpNY5xT4PLDqqRCRES0JfBxjohoA9SDJ6iqSL8VRVCFlGjUOCfvw0Yrm3gXL42otkxG99drNcE1QFgRRPcDXH6FSiX95rs3PlZWbY0GvrZbWMyqtqxVQWYTDhVPPjmh2rJD+NqnWMJvjC8U8XIjnRq+9kSLkh/Gy53J6HbrNkOjia9p63V9jVks6+XL5xr/1wfvvu/P1Ac0MPwDJ0u15hkR+brVyzyU0X/H7bZxnwGYL+nKGt5Yfv1/U/3qgvsuUXRva5uwxjMex/uSPKjIEjXux/XAWHgjYL02jX6MDOt19dVncHGkW8dwZadiVR9nLoKqK2IsS2DsACdSejnEuJdpVVg5NKWPo178ol7Gr56/otq8Vx3UxxlLvoGP0RHQ54vzugqKF+hJpd3B6+8RYx6v2Tuq2r58eUG1eTlj7MbBdjS/qiJP4KSeTsTf9qm33frXamLaUnitERERERERERERERGR6d4zJ9/hf8+xPicibTjb/LMPfefHf1h9QAOBFU6IaKtcfeDko288yAdOXiR88ISIiIiIiIiIiIiIqH+q2gkR2dKpzuO/8l0fe6s5Ae1afOCEiLYKHzjZPtZ88KRulENKgHI6KMpmLc2OnncazdiX4wPljKwYmX77gaDvsyqLg0lDMV2VydRP5E/VyNqxxmOjrO9D0T7WtFZ8TgdsX/2UHut3idH0RbAdegXVQkREtMlWHwetSBbj+AojS6wTEBCpE6rodjeqyxWGSqAksPF1KJYn1NRle2VIl+ENFUHkDCh7uTxfEPXiJcD0KH7Hn9PVcLtLg2VBJxVirEMjlieY0+U+w1mPgvEwzlckBr6vhscCReqEGrokprPiE8d0eeQQOiG2tkVkG5eeJSIiIiKy3HvmpL+FeBf6uJ84m1YLXzO4iD7Pjopxk7oPC4s5OHEirq8NhoZwJMFIQS9frYaXY3KyqNq8+XkdjTAygkvzR8BYeE+fH1Ntll5XX6OMjeLrwKIRcVMs6u/LGbE1k1NV1TZ3Rcf9SHipi5dvfETP48ocnsfLXjqj2ryFBT3OnS6+BkNxRJkMuBfg4xVa4J6EiOzdo9d3PL68zTkXzP3S3ffdqiagXW2tB06SSbzfQKwIGMSK1Fk0YlZyWX2/I2bcg6oZ99gy6P7RJrBia1BESj/6GU8LikTq11xR7+e8p2cWVdvX79P7YFljXc2WllTba2+eUm3el57U+9D/PqP3Z97rbsHzKFf1vcxeFx+36w28bx0d0tvuI3Ml1eY9flFH1CTQvUK/vo37dOi28zPG38nRW/aqts89elG1hd9n/C4cB/E5SWP9FYz9w7V/EhEn9WQ89pY/fvOBz6kJ6UWh1zAREREREREREREREa2F1U6I+pCI905wvAbHWg+cEBFtxNUHTn7/9XzgZLvhgydERERERERERDQQAlSpi4jo+vBHdKJ1isV6P/lzb/70Vzleux8fOCGireKcq6cTfOBkOwsfPGlZpZpUyzIUZ2PFrFjzyKPS5wY0646ARr9AoG/h9ODGgjPqpKPYmgSuTiQVo/R5uo8yVwtGjs8IGCMrtgb1AyzGmvNArGnRNpM2prUkwBhZ25HVj36gWJ0eHnoiIqKttzpipqXLGodQfIv/0WRJl2R0MSNOxSinKDlQstAoyShjadUkDRzromKEroqDfnTwwTgAx203r0tWhtMa54UuDZ6xHtflU0NGRI20wXpZ1GO/3BHQjyguweqM9SoRMEZtPA9B8UAgOieUBetawHboF6OKl8/VcLsM63mIFdczC8p1jmy8NCsRERER0Y1075mTh33MTrOJz7OTSXCubkgk1j/tZsgN4euqeHz9/Wg09bVWoaAjDSS8nNHTLrfrayIrUmcOxPJ46bS+jmu39Hy9KBjnLojf8aamcLxCqayjaKpVfD1TXNT9mJzAUULJFL7WajT0vAt5vP4efQxHP0xN6e+cn8FxS7Govj7vdnUfJFyWsmoL570wpNqSie7nf+7Nn/6g+oB2let54MSKSKnWdISVFevSBfegouC3J29kWMeYWFotvX+RLYzUsWw0UsdrgmVJJvC+eStdmtf7jb1jeP8+XlBNEoB1vZa9o3rej16cV23eNxyYUG1tdE/QR54V8fHuAogNOnxoUrV556/g40wSRNE0u7gfL9k3qtoeeOSCavNOvPyAavPmS/o+3Tfs1fMVY5u5dUTv8720EfZVvV4AACAASURBVOXUaulj8aG8PrZ6jWu2W//ASTIRe+sfvOHg/WpC2lb0VkJERERERERERERERJZ3GO1EdA0fhxCNdu/hmOxup84WPykibx/0cSCizcUHTnYePnhCRERERERERERERLR+jNkhWodYrPcj73/jn13hWO1Op84WPyAi7x/0cSCizRWIq6WS8bfxgZOdJ3zwxIpkMaqWQ5sRhWJBsTUloyw7SKcJoXnMt/ACZsDjOOjfi10dvi9GNTHpgXLtKObIy1nlzDcIxdNIGEekmgQUWV/TIhj/UTRjw5UmHvyJJB7QwhaNERER0XUpPb88bmCcEDgjFw5FBgZzddUWTmscz2HsjBFnIylQIhFF2XhlXRI1hOIFje9zeV26NJjH5YddAZ+FBCA+xxmRRs46l02CZRzH60rqulyk5HApWAFlTr2gpMfOJcHYyxqRRogRn4P65+yMSdUUQmNqDJGg87Qu2C6IiIiIiLape8+cvNnH7EifkTr9qlZ1JMTQkC6JL2Hpen39ZEX4GJeYMjOrcw2mJnEUwEhBxwlYoiC+xZuYKKm2mRndBy+VxssSBdE8E+N6vt7T58dU29KMjmHwEnE99t7kpI6tyQ/jyAU0njNXcMTN/n14nDMZfX3YC8A1lb8crYPrMt9e09fLmRQez1pDT5vL6T54Fy/p5ZNwfT+3TuKx7pd/6e77fltNRDveqbNFHzf2pa1aDhSr0zZ+jItb8dIblACxIt4SiAHysqDP/ShV8D29fA5EX/cJRaT0q9HU94RS6J7ZGqxYHaQG7rH1G3OE+vfSffpYYLG2rUdmF1Wb99qbceRZP8ZA7MyJUXzsmFnQx6RbCzj65qFHL6o2b/om3ee4EZNz//84r9qO7NcRRd7fXcDPG+4b0veir/0p3DnXKKQSb/vomw7+lZqQdgT9V0dERERERERERLQr6R8piYj6xJgdonVIJLpv5jjtPqfOFh+4+vAdEdFmeO6Bk0N84GSH44MnRERERERERERERETrwwdPiF5AKtn5zQ/efd+ltaeineTU2aLf932CK42INktEIo3hdJwPnOwisVYviCWMGBlQwT2EYm7yRsmhplECPAm+s4jKr/uyWnE9rfV9lkpX98OqIo4SWSpGifrAeFMGLYo1zlaMT0lXkpIYKB/oDYNOd0FUj6wR12NNj2SscvRA3ZhvP7E6CNouZI11tVVxRERERNdlVWScyxonJk1cLldS4Plh61A3osvlhq6AmJu9uKSwdEA/ruAyoGKdp2VBn1GEj1fXJTxR/E7ImIVD5zzoJE2MrEWvDZbbOHcTdA5iRAlZ8TIONY8Z6w8B57zLM1Yty2bBOhw1vm/KKO+KxsPaNtC2aMQnEhERERFtR0EQefZNfwdP4PuLybH0M30/UTtWPBCK1Wm39Xy9ZlNfPw0N4WuAZhPPIxbTY+ccvp5BcTGyqjz/VeUKjrs4dHBetRVLOJJgcRFf+8zP6+nTGTyeFdCPZEJf50q4/vR4eo89qSMM9kyWVZuEMST4wrjZ0u17JnFUUq2h15UVq5Qfxuu7uuSX283+wrd/6ofUh7Rj3egqJ00QT7wZcTGWypKOz8ll9d+wrBGpU6zofXYhp48Fln4jdfrpcxf8ThtF93LWgGJrZhfx/mFyRO8r+4VidcpVfI+t2sT74X1jOqKmaEQaFfoY/8M3Tao26TOO6NDUiGrzHr+4oNpesm9UtXlJEImTS+soG2+/EXM0W9RxcY8v6ggfr5DUx+LiEl4n3zCB49i+cmX5XCPiXPvAUPqeP7371k+riWhHw1s8ERERERERERERERE9694vfOtJ+6luIvJi0d5PciB2h1NnizeLyDn/XMSgjwURbRwfONn9YlEnPevFyK5RzSPSx8l1P6fhhQR+O3a+pfthvfgJ3kkNgQf6pKcfqg6VwEzGjeoc1kuzXTD5FeNtzokkXm7rZdP1quOvk5axwtPgMaRCH1VCiugt33B7wdD3WTrg8XWrUoz5hUALzJeIiOiGmFz11sNl/WZEaI/xdkRDP83vrEojxtP14lqqSaqgzb9J1tAnSG7K6JtlFiyjda4BzpsCY1I3hN9KCHSXxUX02wAh/XXL5vQbJJIxxjkN5g2WI2SV3suBt1NQtRm/fEW9rhw66RWjGousMf4IeHMjhKryjILlkLDEoWoyq94QEREREW0zlaXMPd1rbvwW8vht76EsfqN6o+bm8BvL4+O4CsZGVar4zWm03Bcv4Tey9+3Vb2979bqe9+SEsRxGJZTz58dU2969unKLWFVh4vgaZ2oSv+3d6eprl2wGr+t4TM8bVUyR5So6qs07tF+PXa2Gr7UOgmklrACjr5dnruB+9MBF96NP4Df7UYFRb+9k5Us/+21/+jvqA9px3v3w/Pe7IPhPElZQMu4rbRFU3aQO7oN56ZT+2+6XVSmkHxlQDaIfqCqJrFGZpJ8+W/PYqH4rm8yX9H3Bsfz67y3CysZGZROLVdnkUVBp5KVGpZGvnr+i2rxCSm8D+yfwM1uPXtRVuLxxUCXn4cdxatk37NXHwK9cwvM9kM+qNm+poe97ftNNU6rNuzSvj9E3TeHKJqVVFXkiItVIxL3h3P/8DQ+riWlX0XtvIiIiIiIiIiKiXQnf1CciWo8gcHdyoIhskUjvA+aHtGO8++H5/+iC4Ae5xohoI64+cPKf7pzkAycDgg+eEBERERERERERERG9gF5PDq89BdHgSsS7F97/xj/7FDeBne1//5u5LziROwZ9HIjo+vGBk8EVizpn1P+2XwLJ9VGSO26UcCp19NcmjGmzfTweUzdiZIZBnxdAhI+lbpW5Ui3LUJyNVVG93wie9RqK6mVeq9MLIDcoblQpWwIV1fuJ5fEWwfgPx/E8YqCEljVuo8a4VcE2l7ciCYiIiLZaZVUpQ+NcQ+q4lKig47yVYzejS1kuT6+PgyhSx3M5cFKw2FBNIeMYDePwjMWWDFiWui5VHGrhdofGw4o0sjIOwSzMmsKovGvXWH9J44SsBqY3tg03DPo8r0tkeoFxfuTQusJfJ1IBffOGwHKXQKSOGONpbHNERERERNvJvWdOnijgivmaEQ2DlMs4qmB4WMfZ5PP4eqZS1aX5oxFwru8vtTL4Oq4LYmRGR3DkTLOprwF6KHt+DSgGv9EE1zjLlWZUmzcJInGeuTii2rzxsSXVtrCgx807eBBHFVy6pOddreK4CxQxlM3isX/ksT2qzRsr6PU9MqK3C6/VxmOXSurr5WwaX691wTrMZPF14GJRj1062Xq/aqQd5V33X7wUBIHaIMe3KPqm0wU7gvCHS30PYzMidSwB2GVbt34sNXBvyoooQmNXa+o26TOKxlKs6n1PYUjHnfULjZusMXabsSz9aLf1/aaWsc2hWJ2acU/2VQcnVJvlbx+/DD+5xYgpehTE2bxiAsfZtNp6m+saK2Uki9d3FmyjMwu6D94YiAH6+ydWLZ9zzfF08h0ff8vNn1ET00DQWxQREREREREREREREV3rBEeDCItFu3P/5zs/+f/AD2lH+P4vzF5AD50QEb0gPnBCK/jgCRERERERERERERHR2vjgCZEhEe/ehz+hncA/dOKCYD9XFhH1hQ+c0CqxbiCRjlF6x6iGJC1Qfztt1E6qdvS0ElZa19NX2njaSVAavGX02YyXAcYSeNoqiMlJGTFAiyCeRsJq7brPRWMsjKGTWVD6PGJMnNGVECVjjEXbGDvUZ0s2queB+hv2w4jgQdudMQtJgvEfB9uFhNXo9XwlTBPQ8yAiInrRJFc9/wvKiIbAecnygQ2UGAWlOkPWMR4ceF0KnFSIEeFinGuIcYyG0y/iEr8B6nNd9zcU06UlQ2nV4vP7VFOoZIwdmDxo4364MhgjK2txXpc57VsNLLexfM7MrgTzQPP1Crh0s6DzYeN8TPJgpYBytERERFsmAMctIqL1OaxOZVvguiyMVzCuLwAUqWNxRoRPbkhHslgWFnPwk1RS9zmT0TEFXhJMe+AAjqexvq/T1td8Q0PgmspfCtatcdb79KCHr4k6Xf19VqTOk0/iGAU0+hFjnSCNBr6mSoPx9FxEz/v8BR0HIWGUEN4G2m19TTo0hK/D02l9nfrYE5OqTUCf/8M9f/Jv1ES0I5w6W3xgKJ0IHzrJZnB0FGJF3yzV9N+xNV8UqWOpgvl6Q2DeTeM+QxLEikgYqaLnbfX5SlHHdnkThaxqs6Cxq4I+rAXddglQhtkmxeogxs+VWyaXxevEgsZ0ZFjHxUif2+3Mgo5586ZG9fHu5ZM4Jsfa8sdT+jhRXNL7Zm8JRO0cMWKAEnG87cfj+hiRSurt05svP3ecCURqyVj0LZ/7jlc8qCakgYa3NCIiIiIiIiIiIiIiknvPnPS/HOU5EkRaPNE9oxppRzh1tvhhEbmLa4uI1uPqAyf/5Vv384ETgvjgCRERERERERERERGRTVU7IaJlsWjvtzgUO8+ps8X3iMi7Bn0ciGhdyolY9G4+cEIvJBZ10gNV1kNWJEs+posANXt4WlR5W4yYG6sqO5pzwqjhZMXZFEDZ8X7ielrG8sH660aMjFHlSsbBWEgY+aOazLgYa10hcWPsEKu6P2q35mqsVhkByx3bhL5FjXmA1brGeiUiItpi9VXlEK0TISPWRUCsixkBYx2lc6B0ojEpzPWzgDKNoQooHzwJold8N8D5pnTx8pkxRSjOZhgsswfKnFrcLC5hDM9aI0afjWbZC0p+lvS6FmN9OxRRtBY9CwlSxjzQ+vPfmddlQGHNV9+8pEs6O+PcjYiIiIhoGzmButJPpI4pwOfDtbou8R8Y07bBtUE6ja8jMml9Tu6lUnh6ZLE4pFqTSXAzO/w+PN+lQC/fUk23STjOOk5AwvgcPR7DeXAd6H/TGNbxGBcvjag2L2tE0Qzn9LXg/IIeC+/Rx6ZUWyKOx2hqqqzaJNwG9LXW6Kjugzc3D64l/eV5TH/nUE5vL151SV+fHzqwoNq8x58aD/83Fus1fu27//j31AS0rZ06W/QP031oK/rYaOttbv0hNMvaHb2Nokgdb66o48rGC/jv0oIiVaxon34idfoxMdJfn9GtlLbxI2TCum+2QbOLeuy9yT6XZaPKVbzft2J1ELQNPHEJ7/9u2Ysjz5DLYPv0xnO4bxN5vX2hyCDv5j34GIZY2zP6uzrz+KVn/3/MufbebOodn3jrS/5MTUgEsOIJEREREREREREREZHtZvMTogGWSbbv5/rfkR4Y9AEgIhsfOKHrxQdPiIiIiIiIiIhoQOCqXEREL4APnhABsVj3U7qVtrMf/ruF34tFI3muJCICSgeH0t/DB07oesW6gV2Ru4SrE0kNlDnfa5SHT+pqcKaEESOD4nNQdI7XtvJXwPRWXA8y38TzTaD8FiMGZsh4zMeKe0EVyruo0a+rtm5fwl2DMUdi3Hqx+pYGyz2R1G1ruVTX21HaqHKP1vciWGZv2BjnIph+0thuiYiItlqwKkrGgdLIIX34WgbyDB04XobqusxpCJ2cWP1IgPicqlFWGsXkGN8XXK6rNjGWJQDnhCEjGsbFwTyquESzs+adBScnk7gcJsxVnDVOqI1zOngCjsbe97kB1qu1ri1pPW9zWwTrxAuKugy1G9clmsVKcrqoS14TEREREW0zd21Zdxy+NshkwLXBJrAidapVfQ6fTOLrp5ECjg5AGg1dxt/LDenls6KLaksp1eYtVvS1WTqD53Hxoo5GmJwsqTYJL8PhlYsEPd3eaetrKu/Wl1xRbeWKHmPv6Qu6b14uq8eo2dTX1RJGk+B+dEB7Ko3Xa21J/5jT6eox9vIr6+8/3PMnv6U+pG3rXQ9cPNpud793z1gOdhFF3EgY2YTvuyBjebzN9KPV0n/H8Rjel/QTq9Ns4W0/mdB/VyiCZDtpgkijuSK+v7J/Yv3PGdXqeuwljE3T98eMn3SlsoSPM7nsxsbUWn/xmN7P9ave0MvdT6SOt1jWUWjpuN62vHHj7+TL5/Wx49bx9a8/4yddc4yuiSmqRiLujf/56NTfiBTUdETrhbd4IiIiIiIiIiIiIiIiIiAa6z2qW2k763S6H+YKIqJrXPPACdHGxardIGW8RCnjKfy4Wj81Imqo9Id/Og5UzDAmlSGjf8jEJlSwqKNHwozZ9oy3VWNO/wOwyKGqseDo4dKc8aapA69DW5VNLGjqlNFptF5buinUQ+Ppx0MPkbTAfENgua3KJlY/UHMJDbLweT4iItp66siW1W8WhZr4aX4BLwkE87ryhOdAVYtQCUxvVfO4AiqTWOdd4LhtcaPGcrf0mxsSx8vh4kY/QDfcHH7rInDg+8JKKOBcAVVB8fMo6/F0e4zxnNFvQYRARTjBXYPLB0+wvIxx4jQPxmMCv4UnxpslrmN1EEBvzqTweiUiIiIi2g7uPXPyxFZ2o14HF3f+Lem0Plefmx9WbRJWR9Hn2Zk0uIbzRRln8ZvThYK+Rpmbw5UEolF93TI+VlZtXiqpr5O8S5f1Hdi9exdVm4T34PF1TqGgl7FSwdVR2h09j1LJuF6DF1siLqLvMHdBFZTw+0AllIUF/H1jo7hKAZpHrYmvoXMZvb1Yel3c5+G8rrAya2wDmVhbEonuQ+oD2rZOnS2+Y2o0d+ta/eunsslWqtT1fiO7CRVIUGWTnSoBKlj0U9nEgiqbWBIxPJ4x697UBtWb+ljnFXLGfSxgrqSPdV4moZe7B9I/vIixfCPDeh+P2rxiRR+/vG88OKHa+jG7UIFTP1NedZxxrjmeTr7j42+5+TNqYqINwHsFIiIiIiIiIiKiXSYwXiAiIiKiPrmAP1juLB8Y9AEgGnh84IS2GB88ISIiIiIiIiIiIiLCDsNWogH3i2/91B8O+hjsFKfOFn3lptcM+jgQDSw+cEI3SCwfc7iezxrqMA4FtYkUjdyTdFqXc6vA+eL4FatifBtXPpIWeKNl3IiiSUdAu/GITqWj5+uhWViMNBuJgu9sGbE1k6DUfRcss7dgrRNQFh+ORVhZX7fHjG0g0Ud5Niv6BsURNY2q7jFQ8lCMmCL8bURERDfA6uP0jHFKZpzzSE6XgHQF3Raq4YgUeOiu6HKmy98HTkxSxvdZSqD0b8I4TwDnDw5FA3kTuJSy1MFyg3OmcN4ZY6DBOY/FgXON4AIumeyME8AgrtsdOA9anli1mPGQMFJHjPG4jMuOihWLBPoczOPtGY2RuQ0QEREREW0DQRAZdW7r7iKiSB1LPo/P1eMxcO1jmJws4Q8AK/pmfiGn2mZmdXSOrDGPfF5fMzSM2KHqEr4W2TNVVG3lMr4+7IFInGIZRyDcesuMapMwekhHHeWH8fpbLGZV28EDC6rNO39hVLV5wzkdfZNO4KiJSBRdIIos1fR1O4pmkvB3ST2PcSMGqNuN/HfVSNtWrxecet720s8PWP63GBC9a8XWLDX09pU17h/NFauqzdszpvcxN5oVhdJPrMtWcv2twi0xPIT3t/1oGBHjqaTevqyxryzh/XCnq39EHDOib9B4Xp7HsTXW9jkPYnzG8vj7KnXc5xqIE9o3ro893leevqLa9hfUsacajUS+7XNvfMUZNTHRFtB/uURERERERERERERERESAc4J/kaXt6m6uGaKBEj5w8n8f38MHTuiG4oMnRERERERERERERETYCdhKNMAiLvgK1//O8J6/L75z0MeAaIDwgRN6UYUPnqAYEwkrreP2HIioaeuKRaF9aVw6uwgianJGhfMOKPuFol7WcqWpv69hVEhMgJJyaaMcurHYgqfGiqBvXhJ8ZxpXJJMOiNVp66bleaAS5yIyBL7PUjcif5AFI/8oDtZh1uiDA3WuemCZV6ZWLV4GzNuKIyIiItpyq+NFRoyD/JJxtoEOYXVj2rTxrDE6RlvT1nWpR2nosr8hfchd1gTfl8ellKUCSk4mjZPFOTCtNwzG1Fg8KYPls4Dz2BDIgnRWPE0LryuHTlCtGCC0baSMaUeM8qegBG4AYo7CvqH15w3rZXRWdBSaxzD+PiIioq1hHMeJiAzO9XoSGBc54D6ypVRW5e9D+WEcZdJq6euZahXHDIyOllXb7GxetckaMSsJEOHSaOpzfW9sdP3FLtByLPdDX0+iKJvl78NjhFjRPmgdzhhjZGk09AXlASM+5+nzY6rtiacmVJuXzeBY2XkQ1xOAyCAJY/vBtVYYh6KvG8tlfB0+MaFjT9ptfI3pRJ5WjbQtRZzcBXNEgMD43ceK1UGsWB1kvDAEWrdOHdwD8dKgz1asiwXFveSy+G+tHyjmSPpcJ/1oGz/2xuN4X7BRKFLHMgeibLxxI86mH4tlPW8rUsdixeogBydxPF21prejpTo+Rnz9/ucdZ8qBcyd/9ZtHzqoJiW4gVjwhIiIiIiIiIiIiIiKidQoe4UjtGIcHfQCIdjE+cELbCh88ISIiIiIiIiIiIiIiItp97uI6JdpdApFK4NwJPnBC282aD54YVbalDCJ4cCE3kRGj1nrBiHtBUKxLEZXp9vON4/mieBljUlh0FReXsiut92OvEUd0CSxjU1cgDEXBLMZWl/BfYUXf1MDCTCTxPBAjsQlG6ogRfYMig0KgfRis07VcquvlToA+eLoQIhER0SZrrTou1XDpTPMkBDGO8cbpGIxIkTnjZAOdOIFzlVDWKL+JYmCMkqECzv9kyDh1nddlKEOoz/3E8kh4sqCaZMGYB+gyXA5Z40TbgTFF4ybGiSjqr1fE6zUAcT0OjZvYJ/xBRZcjdRO4nGwwq8fOGedjRERERETbRh+ROhYrUqdYwlEThbyOPRkdxTERSGBcCLaM6JRSScdzjozoc32LFZMzPq5jgLxaTX9fMqmvTyS8943bmyAKaHERRx1ks3rsEkl8PfrYE1Oqzbv1lhnVdvHSiGqTMB5Ij938vI7OkXA58DpBsTqveNkl1eZVKnjeS0v6WrcbwdejxZKOFmm3cN9+/Xv+6A9UI207//wvnvru/RPrj5Sar+DY3H6iTFBkycjwxqNQNkOzjf/mUdROp4tvgsTQj3FGrM5cUe/HxYgYajZx3yLG922VrYrUESNGZiijx82yGZE6FrSNWkd+vWdehiJx5sDfg3fTFI7aQePRe/69xZJz7uSHvqnwJTUh0TZg3L0nIiIiIiIiIiIiIhp4Nw/6ABAREdGLig+c0I7AB0+IiIiIiIiIiGhAWO8uEhGZbrI+ICIiItpCfOCEdpTwwROrmnbL4Q8m0rgdqRv5K+k+Smo3QSW9NmjzisYNhOGE/r6YURCpCkpoLTXxfHPW4AEVVA7dz8OIjNnbR8zNwupy/WH0Df4+yygYoyVj/aHFtip+lUA0k4cWL2nE8iBG18TatFCkUb3PMSIiIto0q883xnWZ4eWDFT7pCRq6BKezomisWBd00Jww+oEO9Is4vkVq+rwkhCJ4jBK/MMZnSZfkNOcreLkDdALix66qxzMUB/2wxhnNAwxxyIrPAeMfGNuAA+d/5kmycV7vUD9A03JHVMvyPPL6HwRGpJED55uyqEuREhERERFtFz7CJJfDMTmbAUXqbArj/L3ZwNcz+/cvqDYLitWxInXOn8eh5gcPzqs2FL/jXXhmVLV5hw7NqbaxcXCd5CNxntGxBhMTeOwjKALVX261dRzHUk3H/XiFgr5errfw2E+AWB4Jo2/A9ZNhbl7HRHjJhL5GrNZxnyfG9HYej+t/TztHpxe8uZ/ObkaUCYos2S4KOR0nZbEidayflDod/beCInUsySTeP1hQjE8/39evIohhssYzMGKnUYxMPy7O4ePMyBDuR6OlI9b62T77DYbOpvW+FbWtU0lETpw+Ujh3vTMgejGw4gkREREREb34XolvMhMRERERERFR/yJOFjlsRDsKHzihHS188KQGXs70EvrlxVADPK1mFPOQilHtoqUfDpYUfoAQvawqBzKgcQ2o+kfFKpkBnmPLGQ+l1Y0Fb4B5D6MyIX4v0sc8skZ1FNRny5DRD/QyrfFSsCRAZZJLdfwkuPFgqICvk7IxFsNgudFL2rJGFRNQyMZcf0RERFstaETaznWeOyPqGVUf2uAA5o/8WXAy1cHTWm+6oaopsqjfBgiBymEOnKuEQNWOEPo+1Ob7Bs41nHWyaFVNqeplcaiSioQnaqopFAfzLhnrqgDmgUr3yfLdH2hWvxXncmC+YlReMSqbCFiMEJhFYJwfuTH8BolUdHUTWEklfDNIz/vZlwmtvhMRERERvYh8tZPFIn6LfKSg3zjvV72Or5/qDX0dEIno82kvP6wrZkxNFVXbWnxll9WqVXxTfO9e/Vt2t4svOsbH1z9G4HIhZFXdaDR0/xYW9XJ4E6Af8Ti+Hp2cqKg2r93S1zkJo28LoALJvj34bf3FBT2tNzWpp69U8bR7jXk//cyIaivk9HWn16jrbS4Ww8tHO0PEuYcroHpsLosrT1RrelrZhEoVMwv4b2pqNKfaJNz/6fs56ZTePjcL2vdYtyis9qWGvldUiBv3UYBmC++Pkglw48bv94fwvmCrWNVNEGfd8wLQ9inGNrpvXFfbWstWbjNbgA+c0K6AzwaJBtz88envHfQxICKiLWc8AUFERERERETbyOe4MoiIiGgL+AdOXnv6SKHAh05oN8CPyhHRvoEfASIiIqIbrHLu+HfkDj/4Jxx3IiLaMuiVVqIBFgR8Hp6I+vcTn3773g/efd8lDt325pz7b4M+BkTbFCuc0K4Uq/eC+HDCKHtkXIyXdZUrq4K77AVl2b0miOtB8S1eG/TDinWZNEqwo8mNSaXS1t8XMXJdJq0sGqBmlaPvA4oMCvsHxm62iac9YKyTBlqLeramQhJPbFW0T4M+d4zlQ+pgG5Jw+8TtU2Bd1YxS8s2e4PqZREREmyWbbEg2/lzdyCIuLWlm1jVAuVsjlkeG9DHXc+AwCJqWp0UH9KzxDDOIyAvnXdInkc6Y1o3okslmPdMW6JtXwWVKEdS3UxvwbAAAIABJREFUEIjPceCcIoRiijK6FHMInVAb3ydFY1oUD1Q1ltmIWsSRP8ZWMI/LMcPxN8bIpcE2czUSKexKMKk+JyIi2iSVc8d+IBLDJd2JBlbQ/hpX/to6nWgskzau1zZBMonnnU4b598AirmJGpciFh8ptFqzuf6ZdDrWtOiaw89bX880m+A60I9RCl/nzM/rW7i5YR13IUZ0kdE1yWbx2D/2xJRqGynomCOv3dbj0eno9eQdOjSn2rx/emyPaotHwb0Af9mfw9tRAkxfquJ4p7GC3gasQYrFu7eLCF8a2OY++qZDXz51dv2xW/1E6jSa+O8yldTX/UMZvM1ZtioiBUX4SJ/fN1/Cf/Nj+Y1F30St+3+GeExPb/xkhm/9GKzlQ/pd5lpdjz+K1PHminp/NF7AUWoWNB7djt4nShi9pvfZlrYRdV6q1lUb6DMfOKFdTR8BiMj/3PJqjgIREW2V4l23vccd5/ASXcsdSK3/7gYRERERbRLwqwwREe0mPi7sLq5RohcVHzihgeAfdHuSq5ro+QKRW1QjEREREW2pQNy3coSJiGjruJdxcImUPt6DJiJaEbg3cSh2jAcGfQCIXkT+gZPXnj5SKPChExoEsUhEFkuoPLavDG6UPkdxKBGj9HkL1TLyZaPA5A1jWmTIiAdC8/WGwAczqGR8WB1eTztsjMWsMQ+0JBnQBzGifcLvBCXR00a1Jz2lSNBDrfZyjyd0aS68JDjyx0oSMpJ9pAxiboxhlrmWnnbc2Abm+9iOCmCMV+xTLURERJuk0Qu+Jz7nMvH4c+UdAyMWxo3iUsMwasc66BrHfgHHUiv6Bp2EWPE0DpwnhO3g+8ToGlTHY2TVDA3AyYkzhsiKhpEFsIzWOsnpeZhjhKKEJKybrJokCda1GONhrWtcdVmCvO6HM8qOmtvXGCitWjK+sALGYyUyyMUcOOMjIiLaPIHIQQ4nEfWrF0S+kky274T/LMDXIjDX1BCJ4GkrFVWeH8bhSBjRAK4DjL4tLOLIsdHRsmprtnDB9FZLx1LMzeH5Zodw9E0hr+NsKpW0avPGx6qqLTSix+7ipVHVtjwPvXyzs3nV5mUyum8S3oPX35dMgOsyP84L+jrp1pfoPnhBgK+1UIxPo67HPuyHcd04lNXfubCo++aVKzoOBW9FIuPjS+DijrYp/+DJ+ze7ayhSx5LdougcS7OF/y6tSB1remSjkTqWah3vK9NJ3OdOW/e53jb2Ayl978dafzEj8ic/pPcP/cqk8bIgVj/6gW4XRtB9N8OVRXzsmRjRMW8SjtHzjmFl5+Tk6SOFs2pCol0M71mICAfLERERbYLAyV6OI9EqqZiLRGLfqNqJiIg2yfJxRv9oSDTIer3OP3IDeEHFbd4/ohsuEIcfxqJt5/SRwgOnzhafEpGbuHaItlz4wMmvvW6UD5zQQIpJTx7nqid6vq7IsGokIiLaJEEgBY4l0fMF6WgvEkm+Qn1ARES0SQJxGfDiIxEREfUp6LmXc8x2lA9vRdUTInpWyTn5Vj5wQoMu1grkKatiEUhCWW4HlftQ9IqEpQhVU2gClDO/0gAz9qWrkvq2wGwTzzhm1KlAKTdJ1OjL/Fkl5oG8EdWSBDWc5o3i4QeMsuUtMKZWpBF6YaeKVpQxnuH0XT1914jrGQWl8mvG91mRTWj4F40xAkMhRqVHiePhlEt13T9QgT+Ujjm5dHT6Z/c+9DBPxoiIaNMlnAzJvHtesJvLG+UmwfE5lAYHQuO8JDBi/VCsTlDSpTrDacGJoTPOYQQcc0No8hRq9HVOQXnQGmgzInXC/qHxiOHvczByEI9zsIjLn7oJfSJqRuqg5fOqoFpxRvdheR5gnIeN7agNpvX9Q2VYrXnUwbTejC7/bNVjDtB2dDU2KgjCeqflc8dvHz784BfVhERERBsUiSQYtUO0WtAzToTpqkS8/RkR+TE0IO0OLtkfj+vrqkYTXxukkvj6worVWa/Fko7qESNSJwSieawYmSZYlv37F1SbrBEjg6RS+PtqdX2t5ZVKOponhmKH/Lpq6+uqA0afr8zhCB7UvwCMm/fSW2dUW7WKIzouXsbvQOaHdeTPgQPzqs17/IlJ1Sbm7zNGn2+ZVW2PPD6l2iQ8pvayP/eXbxn/mTf8+Zz6kLajXwmC5x48sX5m2i2SCf33vpZ+psd/UzjWxdIG92IKfUbZJEFkDN7r92d4EyJ1LMWKvn9UyOH9YiGn9++bYa6Ij63jBT16yfi6touSiJw4faRwTn1CNIAYtUNk6IrchT8hIiK6fheOTv+C9awF0SBzmczw8sPGwetFhA+eEBHRpqqcO/YDLorz2IkGmXPus9wAiOg63SYif8rB2/5OHykU3/v3xf8iIv9y0MeCaJPwgRMiIHLgoYd/WTcTUSDCUu9ERLTpeoH8Mz/P4DKfPiHC3GtgMxER0QYE4l7P8SOi6/QkB45ICwL3BtVI21cQfIBrh2jDqiLy2tNHCgU+dEKkhRVPIkZptbIRe5IDZcut6uQxo2bXUzVd8u5AGk+7APoxBPoga8QDpUCdq7pRchwtCkgGWmnX8/UqoCNDfdaXmW3oeeSMyucotmbEiNTBS40rvjuU4RPG8qgmuF1IGMGjmkJjIK5HdJXGUBYsYMUoqz9prCwUdbQX9cGXN6z3pB3IHvUBERHRBgUit1w9jo5ee5AEkS6hBjjoeiVQjtmIdXEVEN8iuLquG8fzQCcKQUUfW8N57MdlMqXUVE0Cjs+hFOhcRpcRDb/PiM8RULrUjB0qG2M0qsfDGf2Ap01G1+C0Ep7AqSaYOSg4/zIo4uVwBeMkEo1dEWxbft4t/X3WvM3IphE9rV8+d2vq2UFxLjatpiEiItog56Kvtg/ARIMrd/jzv8XVv7b33XH/k7/4uTfBaWo1cP7uIwLyVdVmReqYUISLW/9+bKSg+yBrxL0MDekIBGd8X7Olr4nSRuxQuazjC8SI/EkaYzQzg6NoJif1POJxfN3SAn1+/MkJ1eaNjeEohmRCX2OicbPUG+B6yN/7TuPlri7p7StrrL8AXeD7y+i0vkbMDYFrc3+/fUnPe3hIx/1IGDMVkUhETqgPaNv60DePPPHuh+d/0wXBDyb6jKLZKl0jtyZq/O62Xv3O9wqIX5kA0SvSZ6ROo4nvjSRATI6l1cLzQEvYb8QQspUpTChWZ66Ij1XjhY1XKkTjjyJ1LKtih1jhhGgdwjvNESf4L5togPV6Is8cnX43twEiItpM3d5zkau9dgzfwSEaYC6SOFg+d/x2bgNERLSZXCTJqqZESlBXTQQ5ka+idqJB1uvJa372s9+On96hbek3psd+yL96w7VDtG4lVjghWr/w8bdOEFRbXVGPj0XAC5ASvgSpn6WbRG+l+qd4jScL86DSBKps4iVBtYsl423VvWnc6RKoQJIA85XwSUE97Tx+CFiG9UuwoVwMzxuZbeKnsNGSWE9qopdKJ4wKMnN1PA9UIWXIGKM6qDYCVmkoYjxkeR5UvRkyxm0RjRGeVCLGOkFVeaxt7upYRJ38L/58TE1ARER0HWaPT/94Oi4yu3IszgfXHO6tyibgHObqQWq1YB6/JWVV6AjAwdEZVS0EHIsdOHcIlY0TJ1Rdo67fvlqeOehzFZzweEk8RgE4b3JW9ZBh/OYZ7HPcmAeoCiNx8O/DdmPsimDsskbf6n2sk5RxQjYHnn0yyvSZVWHqermdtXygFF4QceKm4v71omcfynIi/0ZEvqgmJiIiug7lc8d+KhJd/9uNRIMi6LWe5spen3i8PYcm7MTAdUtYCSWl2hIJfD4di+nzaQkrSujzcutyptHUlTEiTl8vyBoVOlotfd2RSuE+ZzL62rNU1m+yL08LrjmM72u39TKH88jifrRa+kbw7GxatXkTExXVNjWp2yRcJ/q6RcJx1t/3hFE1JZvRfU6D6iNep42vGw/sW1BtT58fU20SFvzE22IUbAfRPN7mmi09/sPD4BpVRC5czIf/m8s0f1xE/p2agLatRCL6IyLyuxvt32IZ70tGhvG+AIkYiQn9QBUz+q2WYVU32ahUUv9NeTVwLyyT1vtECdcXnsd2UKri/Xt+SB8DxZjeWlezi3q9To7gacHtvxAaf2taUMmmdO6p2X/71+98+R+qT4jItFLxxM1aExANtEBeNehDQEREmyiQH7x2Zs1KVF8BEQ2i8MGY4Ln/XPQotwMiItosTiL3PO84w//4H/9bfvUu6PwjdzTr9sAO6SfRDdVsx76LI76znD5S+LCIfGTQx4HI8GyFEz50QtS/8MGTqMinOHZEWldkeO749En1ARER0XXoOjl07b+ql6z6ckQDJhN93mt4LpJ4efnc8UPcDIiIaDO4aOowB5KINqjIASTSWu3oAdVI297pI4XvE5GnuKaInsVIHaJNEL5lG4vI/dmY+6nVs0MRN7L8oMq6NYzy8ChRpYorvMHK4AWjjDiK1BEjtqZqTHsAxPWkInhaq+J7EZSjt/rc1ZMufycY6MDIlxnV1RSlasTIHMzo5bNUjDFC62+2gae1flKLg+VrG/UiJ0CU03wTT2tVtEersGOM/bXzHoq7Xx8XVj4hIqKNmTk2/WtXk+quJt/EO+656LiWcSJkNAcgysSB6JyQccBzujqyiBW1g+J6QPReCNSnDFX0iVNgfJ1rgw+GQB/CiY3vK+nSpcaplEjW+KCu+4xih0IgCjJI4GmdcZ4NTwDRcoTTgvU9hEuzmsCJU4Aigzy8KOJQ3qK1HYHldp1AXDaVU+0SvF9E/rX6B0RERH2onDt+2kVx7ALRoHMifzXoY9AH+CNUJqtjAzZLPK6vA67M5VWbNzFeUm3drj7XX4tz+nom28fypYwooWQSXFP5y1TYP90Hr9fT1xFixAkVCjj+Iwj0PObmcbzGTYdgspJcvFRQbbfcfEW1WR5/YhJ+Ejfils4/M6raXnILLl4fjeqx8Gav6G2mXMExGGhdXb6sLtVC4yPPjfNPf+bu/+Pn3/zpf68mou3uhE+Lut4+9hOpU2/g/UM6tf57GB3jhzQrqqUfxUpdTV3Ibd35oxWrs9NYkToWND2K1PHG8nj/jFi3IREwrT+AnuDDJkSbIzy7m3zw4b/meBJhzW7wSvgBERFRH3pOvmf11PVn0I02ogHzCn3jIeTib1JtRERE/XKRt3LMiLDc4c//FvyAlPfdcT+jdogMvZ77XvwJbWenjxSeFJF3ciXRgGKFE6It8OyvHc5JhQNMpLV7ErlwdPqX1AdERETrNHts+tZuT8bQ1L1WrKkaiQZIJB+Dry25SPxA5dyxH1AfEBERrVPl3PHvcJHkyzleRFrQa19QjfRCPvcCnxMNpKDnXv0zf3H3XVz7O8/pI4VPisj/OujjQAOFD5wQbaFnQ2ziTv6xK3LHtV/VNMqnL4CIk70gnkbCkw49rVdE1eN0iSOzuQj6sFY/roCS6GNW9A0o6dfQ/3x5Hqi0uIhcAmM3BEqLexXwfYKrtcuU0ecK+L4EqNQe9q2OF2YIlOyvok4YMUw5YywWjXU1nFBNEoFrW6QM+oHid7wa2rZ8O5iHtb2M6n68S0R+XE1IRES0Du1APnZtesnoNZE4rhaNSKxjRurAOBUJD/6qSUb6LNWJZq0OgSsa4PsyIA9R7JiVAJyvOJTfJ+GJhWqSOi7NakbDAIERI+iqeN4CpjfjgcB4ujzIQ5TwhFo1hdCYjoGx8NB59jyeb2CMswPL54zzIxntox/GNiBpvXzBSBg6hWfuIv7NOb6JS0RE1+v7OXJEhqCLs0RoLb46wLp+XO909I3ZmBGn0g8UqWNB0TJricd1zIoFxbdMThh9M/rRbesxsqJ9olFwzeEvi6u6eqI1Ro2mvuQYH1tSbd6TT06oNm84p/u3tKT74F2e1WMUGDHz2Sy+Hg1A92o1HP+Ry4GJ/f0IMM75Yb0cEq5XHVkyOYFjMOYXnh+zkkx2f5wPZ+1Mp48UPnzqbPFmEXl/PwswV8Tb3HhBR6TEYno77FfXiNpBMT6JhL734CXjuB8oVmexjGO7+okYahnR14mYcd+lD42m3mc32rrNK4CIm361wbIsVvAYTY7ofYnFmhZtX2jb8uZLuB9j+eetK0bqEN0A1+7d7uOAE5n2FO+67aj1IRER0VoaXTlsfdyrRHdHsCvR9SrE2stZ7vo/F0neWT53/BDHloiIroeLpr4NHV/4H//jf4EE0nuMO5a+8ccqIkOzGX0z/oR2gtNHCh8QkZ/lyqJdiBVOiG6gZx88GX/w4X/PgSda04fX+pCIiAi5cHT6ftD8rF5x4285EO1kLpvGr6yscCK/rRqJiIheQPncsY+tPQXRYHMifznoY3Ad+IMV0Rp+9JPv/Kj9KW13Kw+fMHaHdoslPnBCdOO5a8u7PXb7dKsTBM++dRt3uAxeBPw+0kMltv08QCSLtwTKeoNKTaEMqH41ZJQLnwdxKssdVC1SMKJaUPn0eSMuBkwaGgGxM8ZQSMcosVduqSYZN/q8BCpojYM+yBpROyh25oIxLVgl8N97Cy28fGkwk6IxLYpFApvQmt+HhnlvWs9XjJgjWV7ul05+/mG+EUJEROt2/ui0P0163gGnsSpyZs/tlZ7EYPCNHUVTAgd/K5YnYbSjLEHj69CBOzBKgzp00PUqus/BMC5/KvP6RMjt0aVPQ3O4TDDqhnF6ax78g4j+B24f7kdwua7ajERFcTk9nqE8KH9qnGfLDPg+axtAUUm+e2DbcCCiMmSdfIG4RpnAY7Q6LsndmhL3zWNqstWGXv3/gS8hIiKyVf/x22oigXFAIiKeX12fX3zgTc87KU4kdMSDVyzp6IBCHkeWLBb1tN5IQU8fBPr83Ws0dIxMOo2vkyyVin4ePJXGUZ6XL+sYmWxWX8N5oyMV1ebNzQ+rtmYTXx/u37eg2sSIz0klcT+QCxdGQavIvn2Lqs1rtXXBUuv7LlzQ1zmZDN5eCnk8Ro8+sUe1vfyll1Sb98ijetpl+k/9JTfPqjYJ12tBtaVSuM/5PIy2KP/EXZ/VGwftKKfOFk+IyJovUe1Ul+bLsOd7x/T+qGdE+1jxOakk3n9tVMfoRyyKjwfrZf2m64wbZ0YzVK7i48/wJkT+rAMjdYheRM/bM8UicoErg8jWFXnA/JCIiGiVS8emP7v6oROk247jqz2i3W5vAt/1WaVy7vhfqEYiIiLDcrUTPnRCZAl6rX8yPqIX9kWOEZFp+N99/J7fsT6kneH0kYL/DeSWlR/wiXYKRuoQbQPPe/Ak6uQPuFKIbN1ADszeNf0GcwIiIqJrdAJ5/XrGo1WNGeUviHa5kfW9EeSiqTeVzx0/pD4gIiICItH0PbqViK4Kgu6XORjX7cEd2m+iG2KpHvtXHOmd7/SRwpP+B3wR+YdBHwva9vjACdE28ryoHe+pO6df8I1bNAGKw/HmG2hqLI3KdBvVu62q813j61C7FetyMKNLVKF/782iEvW+PB6IhkkYtaiseaCYIt2yMm/dZZkzyqRbMUUtMPmUEe2D4mwyxnyLRkxREmwzUWOMKqD8Pah8H0Lrz6uD0mFWhNKoEVPkV4kTuTL5+Ycn1YdERETXuHhs+u9rHTmCxqS16sQikg5k72tw4Qc3ZbysewXErFgnZEs4ZkWy6Ed/fGxEsTrOil4xTpwCcCwW43zFoXkY5xqB0Q+XBeMBzmGWZ4Lb0bwdHDdf0x+UIB5LqqZQTccOhd8H+ufy+PuCIpjHqC79HM7D+D5BpVn7iOUJ550C41wGY+HnkX9+Kezod06paSxBr3Umd/jBO42PiYiIQr5Klosk3sTRILIFveZ35g5//uPmBGS698zJwyLyJevzq3pdfe4cieJrn60yv5CDcx4eBteS/sWJtr7usOJ6Ll0aUW179+J4GsvSkr7WNS7LpFrF8QzpjI65Scbxtc/cvI4SisfxOonGcHsMtFfK+Jovlcb9QFpNcE3lL9mH9PJlMjj+aH4ORzahIqztlt4+vZtumlNtKDbKO/+MjuXxksmOZFPtBz70P33spPqQdqRTZ4sfEJH374a11zZicuLgnhdtvmJFH38KOX0sWCdG6hBtQ2pvGnWiwyOJ6FmByMTc8ekf44gQEZFl5tj0S1s9/NAJ0qv7Jxuj+Jd6ol0q8sr+bi64SOKOyrljfIOdiIhM5XPH7uBDJ0RrC4Jugw+dXL/33XG//4HrqZ3af6IbYakRP/Gjn3zn6zjYu8PpIwX/4MlrB30caNtghROibQw9ePI1rjCitfUC+YU1JyAiooHWDuRv+13+TjOuzsuIdjO3P47L/KzFRX91jU+JiGjguf846CNA9IKCzuc5SBv2yR3ef6It12zGfp+jvHv4H/hPHyn48jn3DfpY0IuGD5wQ7QAqamf2+PS7Oj35sIQ/muDadl1QjaoEyoJ7h1CJcxG5UNczucmISEHTWlEoC0Z0Coq+wVOKtEF18QYq9+7L6+EuC6rYlQLRORJWo8fzRq0onkaMdVI1qvkZVeoFVb/PJVRTCMYGgSYxxkKMqKNh4/vaPT3zeET/ezHGwquA8cgZgxEx1mv1msifXFz+5qYv/O3taiIiIhpol49N/0azF/yQH4O8caJQQgfHPT0ZeYUuOSmLurRuaByU8zXiTcyDP4iRCUDXlj9QLWYdZOPbRCZAn6/gMsGCnsMZMk6EwHKE3avpkzpnZPUFKNvRipFBJ01ijEcaR99IzVhXaV3eGsX9hMC24QrG97WNFYuijoyvg1FJ4bMgYOxG8UldMPvc+o7+bwfV5+sR9Jq/kjv8+fde1z8mIqJdq3Lu2IdcJPkermGitQW95g/mDn/+t9aciNZ075mTJ0Tk/nCaAJwLS3jXXTW1WvhcPZEwrg22SLWagTNOpfS1WS8A12X+/mtHXyctLuL57jMieOoNfc2QTus+9Oupp8bhvwjAuuqBNgkTScF1kr/MGdXX7GjcvCefHlNthWEcXVSqgGtlH7WT1tsGis7xkglw8zvsn57HzCyOYXJgu81k9L+35uuVSs9Vtkyn26d++Z998kNqItrRTp0t+sixB5rNTh4tRzKp72v0qw1+pIvH9X7Ha4F7bAnjftzsIg58mBzBkVI7TWUJ749yWb2PWarre0oS7nf0vnmzzJdqak5jeXzsuAYjdYh2ELX3nXzw4Y84J3qvTkTPU2nLbReOTt/NUSEiomu1AvnB6xmQ2jP+tMzxHIwGgvs6nNG+Hv5HxfK544e4pRAR0bVcJPFvOSBEL4wPnWzc++64/4GdvgxEN0KzEfsgB3r3Wal+UhAnvzToY0FbihVOiHYg+Ohhqydfq7WDVzn1WMqyPUn9gVV9otzG7cgiqIAhYcUM3W69HGsUQpEW+BlnCC69f6RZtUgT/Hsvjip/+O8Dr4rWjLdV81anAatCx0VQFWbEmO+CMc5joCpM0awgo5qk2MDTGkMnGTDOFfyQpQyBhyy7oAqK2C/pSiGhP0FVVwRvAsvzWDVGESd/7B/wVhMSEdFAevLO6ZlG97lXpoqomkRYEU6fS5VbPWkUEy41suokJ4ffikNQwQ3P4W6EBzI1rW5ahqrYWdNaH9TBWUFCj0UIVcyYwW+Hweoovhd5PXbBIn4ry1nnhaiUGjjvCqVBP4rGSesSGAsPVWkxhlPyoNPGRhAkwPrz80btS8YYocomft7gfMrN4eW+WpHFvSJbFQk28krRp0XkNaqViIgGUuXc8TMuEk/bdwSIyOv12l/mQGwaHzfxdlTZxHKjK5tUKlnV5uVyS6rNm53VxQus3wcmxkuqLZ3G12uNBriRbFQ3QX3whvO60ohXLqdV2/g4Xr5sVs+j1QLXVGtUhUF9jsVwpZF0Uq/v6hK4zvX3vo2qIumMvlmOqs14pTIe50RS9y8axde0uZxevmYDj5Hl0MG5az9J3nvm5Iffd8f932dMTjvYb9w2/hOnzhZ/2Vc/ufb6vNnS21wy0d92ZFU3QazqJkg/lU2M2yv2PZotYlafBff0UGUTS7+VTYoVsA/t6HtYssY4o+omq+cbiKvGIu5Nv31s6otqYiLa9uAeOerkU6qRiJReIMnzd04zG5eIiOTC0enfaXSDyY2MROWyFfZGtLu4sVQyWHlg+Hr+c5H4N/pIBW4WRERUPnf0pyUSv30jxxX+x/8G5T+R3scGfqexeT68WxaEaIu96yf/9O3v5iDvTqePFIqnjxR89M7ISoUKouviHziJRiJ3/O5de3J86IRo54I/bhx46OGfjEbMd2OJ6Bq1bnD00vHpb+eYEBENtlo3+FcbHYDa+YjPCOc5GO1qkZckJYg4XY6mX5HEe8rnjt3BrYWIaHD56DUXSf4cNwGi9Rk+/NDPc6g2x/vuuP+Tu2E5iG6EVjt6Lwd6d1t5AKXgo1H8e1WDPh60fnzghGh3Metb5ePyX9uB+xb1gS8J19WlnXpGOdOqrqoVSoFKWTHQ5o2Bl3+tuJihuC4v5ZXA9CmjXDhYPNmLSqf7GCCj3hYqc9VGMzb65u3P6O+8YJR2L4BYHaNrchOYrxjrdXW0zFWLIIJnxJi2akQMocruqM1qv2zEF0yl8PI1urp/6SjumxWt1AWDOh6OvfPlNTf+AwoREe1Ij90+XQ5PqlYdaurguCFhyopuv3oc7ZRiQSx7TTldEHEYMkptIoFxfuRAJE7QMA6CZX1S51D8jp+HcQLo0LmCtRxFXVJYQHRO+H1tfE4gIFbHoXga0evu2XkX9bLA5fAaoB8oW1CWSwxCIzrBL7hUU21hP0B916CklzmcNm30A2yLZk6iEfkIy4tby+3jlm5O+AXS9VWvg5PIH/nn5jdjXkREtPM4cWe42ojWqdfmjzmbbzlu5waqLenrBS+T1TE3VqSOpdfT1557JhdVm6XbxdcArTa+jut29fdNTuKCCaUyjg2anNDTz8wUVJtXq+lYiVod983Sauk+d8G4eWNj+jruwkUcJbRnDx7nuflh1YbGba2ikiWeAAAgAElEQVR+SKCv4xJxfNGHIniGhsC1uV8nJRzpcWVOR2zEY93UqY/f8w+n7/k441J3udNHCuf8c46nzhYPr0Tw4I1+hXHb7IbH2SD99qEL7m/VG/jvZyiD/36QBRBxI0ZsTb2B7wktVPT+aP8EXjUdFDntfyvM6WizVlvfM+uD34Gf+N279pzbyEyIaHsxzkbC/MbfVI1EZAhi88dvexx/RkREu9lTd37LmUY3yG3WIrbmrEdxiXaHYCyj745cr0hsf+Xccf7oSEQ0gCrnjn3WHwe47onWq/d7HKpN9yu7bHmItky7HfnGH/3EO/mb04DwD6CsVEDxETz/MOjjQc/jt4cRv32sPKhERLuI+eDJ5Oce/nDUSVV9QESG4Jb547f9Lv6MiIh2owtHp3+p2pbbN3PROs9EJQgi+BUFoh3OvW6oG77StJn/udjtlXNHP8Rtg4hocJTPHf1pcfE3bPoxhf/xv136n5NeI3f4If7gu8ned8f9D6y8sU1E69Boxn7gx+57x7/gWA2OlQiew6ePFHz9kI8M+ngMuI/47WBleygO+mAQ7VYusGpZLf+Y8mC9Exxb3Z4GZbavoNLivoxaH/WociAuRozK56ALobaxOKgS/DN1PDHqxlgKNPq3kvFiyxAon47K6ssaYxcDYzdp9ONSQ887jxZkjcifGqiwN2qUkl8AUTt7jL6VjZUyAaIDmqAcmaVhTFvB1cskDraBKdAH74oR44Mif1YnAYwm3L0Hv/Dwj6oJiYhoV3nm6PTXLTaD/3Z1mcBhVPYax8YFcGwcvubkJvnKdi8+0cAHqavQoQp/nQToIG8Apx/LUHSKNd9ho1wxisQB50yhInj2xjoBBBGHIXSukATLIfZJXQCWxdWNUqJoHmjc1hCA8zQXNzYFeB5vjIUxC3iCtGQsn5FSFIBYRWdESbrvHq9JOrF5FU+u7UfQvnP48OdZ/YSIaJcrnzt2h3PxL3A9E61f0Gt9Yvi1D30Hh2zz/exnv/1Xe73ID6+ecTLZVN/VNiJnslkco4A06jieIZ7Q108oNsWbn8cFO7NZfVM1ldLL4dXrOvKnVNJt3sRERbVJGFujxyMe18vhxWL42hNFD6HYIcuVORw1kU7hfgwN6biKShXHAKXANlAs4mmLZb0c3stunVFtC4t4/XU7+KKvUNB9tjzx9Jj6JBXH14fJJG5fApFGq7fFoWxr3wfvvu+SmpAGwqmzxXeIyIdfKIZnNRRlI+EtIX0fBDRtuWZL/00kE8aNlG2s1cHHjkQM72NegH848/tOHyl8cu3JiGi3WHNPceChh4+rRiJa00IreN+Fo9Nfv9Y0RES081XawVe2aiGaX7OeNCDawaZislUPnUh4Yyn2V+Vzxw+pD4iIaFfx+3uuUaI+OXcvh2yrBH+0O5eLaOvU6vGvcXgHl38I4ZoYHlZB2Z0+ck2cDh86IRogL/ijRiIq+rFaIlpTubV1P0YSEdGL75Hbpxud3gufR21Er2a86kW0Q7lvyulX/jaVSzkXYT4wEdEuVjl31zN+f891TNSHoPMoq8Jtnfe/8c+/4FxwdrcuH9FW6PXc8Hs/ds/jHNzBthLD830rMTy3iMjnBn1Mdji//m5ZidP5PsbpEA2mNaN2ZLmM/LvLreDXr21DhZasmJWLRpwNqpSe0dX1QijWJW6UVD+Qxr8BoQiXyyCexgMFxyWnK8SFOj3cjwToRskoOX4gAyYWkfM1PdIHjWmfAtMaSTsSxbOQQlz/gzoYNzGihEogNsCr6Qpjy/MAVcaMVQIjcRZROfvwYSndN68ItqO2sXzWPDKgHc9BZCgujckHH06rD4iIaEe7cHT6mVY32Ld6GdBhfgid8PjjK4gmWZ1aM3SwJxOvrImAY7wXgOO2M45rAr4vnAeoVuysEwgUQzdqnCBZqvqkAMW0hP0AOYmBtXx10Dc/jwI4uTTmEVR030IpfQ7ijIihoJ9arrgb4nJguZfw9yHOOEc2I3/QtYBxTicZcPLmtUD/QKyS+5fqz2ZrBJ1Hc4cffNmN+TIiIrpRKueOfVFc/DYOOFF/gqD1M8OHH/p5DtvWuffMSR8b8Ymd0l8rXmYIRNSUy/jWZj6v41tSKR3V43U6+FqkuqTnXS7jKKED+xZUmze/OKzaAuN+fTyhr/kWF3FBxpfcMqva+vXo41PqXxzYh3+H7Xb1daeEsUg6mmdqqqTaJBxnfL1WKulxHsrhdTU/r6fN5/V2ISA+56oKWIfRKL7GbHei537tn//xa9UHNNBOnS3evBLFc9d6xqHR1H/bqST+e9gulur6bzBm/HC3zeN6PrcSpfOk+oSIBhLek11j/0MP/0Y86vDZBRHZAknNHZ9mxSAiol3k6Tunv4weOtkK1fMR6bZi+kqUaAdy35LrLj9tcwP+c9GXhj9OEhHRrrH80Enstht2LOF//G+3/Bd0F/nQydZ73x33+xgB/DQAEZlq9fjh9/zxd37a+pwGk3+I4fSRwomVSig+judXuSlsK7+6EqPjVtYTHzohometq0R8MiofVY1E9IJ6gUzOHZ9+giNFRLTz+YdOat3g1TdyQSoz8T5LihBtT8FLkjc2OsrFbuPDJ0REu0P5S0f/ZPmhEyLqX+9THLQb5lcGZDmJNlV1KfG2937sng9xVAlZieN5z8pDDv5BlJOM5Lnh/HifvLoOVtYHLt9ERAPvBaN2rnr6zulObyWFpguqqKVxxTxpgMrbElZm1yXv2kZfIqBs+axRUh1F6nhO9DyyoES9VwGlwUeTxrTGe8hd0A2wGGvOGwyRGWeDomGsp4r00q20gw86xjpBKTfW96GxCKfXXTZjgFDfcmiA/DZgbHOxiO5I1FgpKN5JwnFWTdIBffP2Pz/26fGRz/3NrWoiIiLaEZ66c/rPy63gzb6vw8ajIEVwTjBuHOPRUeZKAx9Qbr271RUXqCMQiqhxS8Zv+yCyLoRifHCXfSafapJSn9+H4nrixrSouWh8X0oNTwjFEYkxznClWPFFKFPRzwKdpxkxkHC+1jxAUzgPFOVknZQb3yd1cOI0Ymzk1kkWOjG8dtJXpsTdPqImuRGCXvsTw6996DtelC8nIqIN8w+duEj8nRxJouuTe8394ISRtsK9Z04WfHLL9czaiqJB8SvJPp7nXgJRNl42W1dtm+H8hTE4l1RKx2B4E+O6SMylS/i6YaSgo33EiPexLn2euTiq2g4emFdta1lYzKlPR0cqqs176ulx1bZvL/6tNh7HY3QBjOkBo8/z8zp2yCtXdPTN1ATu85X5IdU2UsDF8IullGqTcFn0dePePfhP4/LlwrP/P5Ho/cwvvu0+Vmiivpw6WzwhIh9YbyzPfAnvS8byOHZro0pLTTiHfFb/XW4X86Xa2YiT3//dE/v4QBgR9U2fvRrijk8REm3ASxbvuu0xDiAR0c5z7UMnL4bqU9aTGUQ7g3tNZmvubK+D/7EyfFOeiIh2HD50QrQx/gFcDuGN87477i8yDoLo+rVakZ/7yT99+09zCKkfp48UHrgay7NSEeWWlX2xfrKNkNLKeN1ydQw/cnLfN/GhEyK6XuuueOI9evt0LwgCVwFv2E6m8G8iVTCt19IPvsqE8VYwqubRNR5dRi+JilG5o93T85WwSoueNg364JXRG55+Lz2kn1SvG32+0sDtaEStqjB58JsUqirjlYwSHVXwwLy13DWwXnPGy7EdY5zRssSNCiR6Sv/0OmrFL916BTAeetSWzVpvQwNTxrY/C6qm5BNu9uYvPDylPiAiom3p8rHpP2z15Luu7Zs+miwrtfR+H51/ePsy+thRBP9eVgpS3PI2/YZRMK/fmjAOo3YVDFSBxDhfgQtunHgFqKyZB46Zzjhwo6Fz1nzRxB6oCBIY5za41Rgjy7CuChMsghMs/30jetrQgn5jDy1HCFV6KePvs6q0wHnYJQtVU6gCvvPqueLXpcXdht9avJFY+YSIaGfhQydEGxcE3ZuGDz/4NIfyxrn3zMmbRaTvyO16Hb/5HgT6OiCT0deGlkYDn7+jKiH9mpnJq3+Ry+lrVG9xEVcS2L9/QbVZrszp7/OGsvo7IxF8PbO4qKt5jI+XVZuE1UP0tF4iqec9UqiqNu+pp3TFk9yw7q8YVUK8MqgqMpzH87h0WVdjCacf0ttMtYa3jdER/c5AwuibVX1nZkb3Y3QUV5lYWNDbhovIr33oOz/+I+oDouv03v+6eEsg8k5x7l0RJ9+43rks1fDfWiweU21eMg7ur/RhdhHvSxLG9xWG9P7BUq6G+4H/EYm4/1dE/vA/H516xJiUiGhD8B7LkIrKQ/WOHMOfEtELqbeDySfvnJ7hwydERNvfpWPTf9fuyTdvh44uPRMPsvvb+q4j0Tbnvs7fGQ/Wfzdki7hI7J2Vc0f/Mnf4oTdwmyEi2t7KXzr6CReJvQO/gkJE6xJ0/mr48EN86OQGe98d9z9575mTHxGRdw3UghNtonI19cPv/dg9wodPaLN86JtH/AOBp1f+e9aps0Wf9fQOETmx8t9Nu2DQnxKRB1b+++TpIwWc70VEtEX6evDkwEMPH/+n276FV/5EG+AfPnni9unSLV98GD+qT/8/e28CZ1dR5v0/de7ey+016WwkAXRUdDRByM3SASMKCkQSEWXUV0ed93XGEcUx4ILIMioqcXRc3nFm/h/H0RlnxgWiLCr/wQxkgY5KoqKorFk7S6/3dt/9nno/dTqBpJ/f06ShO3277/P9fECse7pO1VN1qs5S9fspiqJMOfs7Uw9VLC2tlpY4vDNkTp+PdxMpStWyOOLk3qZ80cnTmPAFmV2dDzYu2bqc/aYoiqJUBW6RoPHCF2hrKMrzw5L3bg3hlPElXXiiKM8Pt/jk6u++6cwvvfn7l2oolcni6KKMbx79B/KX24446+1XWrKvIKKFZG0KHXcq8Ih+bo3Z6xHtIqJfEtF2XViiKEq1MS6rHccTK1K/yJTtK0enC+LdFBPUpXJllkSNEbyRF1nfSKLnkjVMG7BZ6ROk3cNAxt0KO20qOAsCTjRUJ8ikV4Q2MED0Hcn4k6DALhxKIBQBWRDnBcAKgAIVd36sJ+j751AwXJlB32hAFXFyijke6BBoJxrDgge1q9CsYr81oI4lEDcS7KdGdc+B5vsenHrteUVRFOUEBs5f/hgRnbkPzD0kWLeRMJ/3CXZ689H8irOl3qN5tC/N21g4/8xRYJ4Rb5BwMbBFjTgJshSyWSy5K2GQ5Q9ICgjz+lkwDwdFQx6OFPgqsiRUjwDJigbcsNg8uJF1WSNbHmRlQ7I3oG3g68IlOyJoqyPVA+QbnC/N62KaBRsgYO0Y5HEYyM96RN6b2vJVtfDkGLbyROOSLWeydEVRFGVKSe/s/I3xwi/TVlCU54kt36sqb1PLxu1rNhHRZaMLUShge5NY7Plb3/QPcGuYeIzf65PwGCiVIxQSnkUAxSJ+jqhU8DPRILKRaeS2MI66epy+b18rS1uwAFv4IEujoWFeBkeljJ99GkH56urA8xARHehuZmmSbU0ohBvFA/HP5/CznYeLDN10BzO43p7hB0tllt4zZEE/XyjYKmVAObzjYhEO+9//zCU/uoIdpCiKoihKVSLcjsic8UDXOej7vaIo46Z54PzlpYHzl88ECTdFUZQZwcD5y/vdopNqrEvPzrjegSnTBu/0aHWpnRyPCZ2R3nVeP0tXFEVRpozMrtWP66ITRZkYVO2kKri61gOgKBNBuey96WN3XvagBlNRFEVRpgfjXnjiqA/Rz1mioijPBbdE/ckDnalLNHqKoihTi1sM6BYFVnMz5PMJYU+RolQXNgW2AlYRxnjNmV3n59K7zluoXUdRFGXqcONw5lev6nOLArUZFGUCsOV7k0vu36OhnFo2rNz8FBH9ay3HQFEmikrFpD7yo3U9GlBFURRFqX7GbbVzjMOrU85A5WmdvMOClDwXg5NB6uuOIWDVEhWk1hsE+fscsIYJCctukFo7SApoxMp2MO80VysMENxlkMI8tQry6b1Agl2yAujO8Vg46kD8E0LhCiAgksVNi1COAaAOL9nWoOQIKC8F1kwsKWBBgsfugGCjAE4XkAR16c/jPGLA9ikK0ihQyvepLeZ9adG2rg+xHxVFUZRJZW9nal2uYm8fLT9bEuYTPOq7eZclUQbMdSTM0QMFPPuMtr0LnT3gW996cNpFae6Gj0+BI4B7LCkPAvOoFeY1yuIoGZS5kIcF8TfoZoXkQFsg02daQEM5Yrx+AX3gBg7EIgCcD97wjHU+FDrJ4gbc9JgmLG9tUT3c8XMTLI2O4DUjVrgPHX0T770kQfSSOnZY9eK/qXHJlh9MowIriqLMCNK7Vq805G3T1lSUiaNxyX3ghlSZCjZuX7PYbTab6FNLdjbRqPDcMUl0d3P38I6OAZbmGBjkNkCO1pYMS0OWQY6W5iGW5sgM1bO0xoZhljZeslks3jg8zO16kP0OBTYx3OooneblHYt8gT8DhwVbnt4B/AxWn+DPgm2tOEYHDydZWjjEnzsdySSuN7LmKZV5PRzNTbxdn3hyNkujoL9ks5FIZfENr737CPtRURRFUZSqQHh7/Ox4hr6jTagoE0dvwb/6sRWpRzWkiqIop47dq1Jf6M37bNFJNeOn6/RlslLV2BdGs9OrhbzvZ3Z16o5URVGUU0h6V+cnddGJokw0lW9pSKuHo6onf1/rcVCUicIS1RVLocM33nPJOg2qoiiKolQnz3nhSfv9Xe8wHuFlrYqiPCfSJf8Fv122rKDRUxRFmXweX5H6Q3/B/5vpFmr7WNSQCfGtU4pSBXivqCubcBhvtatqQu9I71z1G+1DiqIok096V+e9hkI3aagVZeKw5A80Ltn6Tg1pdbFh5earaz0GijLRlMre7Z/86dqvaWAVRVEUpfp4zlY7joOrU/87W6Z/cv9dL1jO7BOsTMLAKifCkwJQMrJeoTHU4ZGk/eHCyZetCfy9I1PEZ0Q5Nwq2NZ6w/AfZA9VhNUXqQ1ZH+HTUGsM/lH2e7ixgEPWgLjxlbDwQ55zQsKj9Dgl9C6ncO+pAmVFbU2C3hMuB7HMqwjUEDqVB0KYUrAA78WDXJ1qi5qULtnb9jh2sKIqiPG+6z0vlrU9Pa+TmuBIsxbASLAnDPg2BMV64TSAwrYnHIiu75CKfZr0ox9JFb0ChLsgb0A5iiWbTwG/27BBe/2Ia8AlthhfQlPF8Tm3cEscOCOdLnvz5JAy4TwhAcjjSTSvoA5Ivo03juqCbWbFsoG/AMtAYN+ugDUULpTjvLwHH3ZN575ldIWNwg0wDLNkBIvOK5JL790zXOiiKolQz6V2r+w2ZZm0kRZlYLPk3JJdsvVnDWn1s3L7GLT75YjUVrFDAL5hjMfws+Hzp6eH2LQHgscOC99MU2LqA519nzdPP17y3t3P7FhLqHYtxGxpHOsPzdUQi/Pm1sR4LPg4Nc1vTnh5steNbXO+O2dyOqOLj57JyGaf39PJzNtbjfY/FIn+Ua23FsT8i1KW1lccjHOJxcwxn+XO/VI9y6cT0cNh/8otX/OAMdqCiKIqiKFMGnsVPkjlbuv45EqJubT5FmVh8n6g3b3+7e1Xq3zS0iqIoE8fh81LvPNCZsscvOpmOpHd7VBqKnfyqCkU5BYTWNpen86ITCt59m2ZDtDuzq/N97EdFURTlOZPZtfryzK7zrC46UZTJwH9CF51ULxtWbv6Sc3mt9TgoykRTLnunf+A/ryh88qdrz9LgKoqiKEp18LwWntDIhs/zWaKiKBPCQNG+7Y/Ll+Fl+oqiKMq4eGpV6uGyT9+cKVHr/XV4Wn/gV2YWZk6YbEdMkFWZjnhfc1YQ2k0VRVGeP+mdnbcRme9rKBVlsjAf1dBWPWq5oyiTgLUULZe8317/k7W3aHwVRVEUZep5XlY7xzi0OnVP3revZT+4XS2CQl8JyJY3CbLlZX4oDaHEMVbStMT4LwOCpn0d+IyDJPhJsFMhwaoFC8oRJYRMkkCH/0ge5xIH/jKSPdBhIQ9kn4OPhEqI0MqGxmirMohps2ADhOxsiuDvHQUhvQ3kXQT5jkUW9OeI0H6oD+AjiRJC3+852lYhz1Bb1Lxs4bau37KDFEVRlGfl4WXLyqWKDUlzYwLMYQMFPo47hsD4ToEzDL/XCHn42AxQ85WsfQRnQGqIGGp8SdGGW/PPFD6LDzbCPAMtY4T7I2QZI9rygPuSkT8AeYPYB4eicoAkGqt+zVy2lw7nWVJAE69fcEpwHyNa3/SDeDRyOeeRTFjKCMD6hsB9bABq7jrh2GHhBgm1Vb3QGXtAxz3GO9qLpi4CAj7tcYaWL1LrHUVRlPGT3nXeQrL2V8aoyomiTBaW/J8ll2y9QANc/WzcvmYTEV1WzQUdGGxgac1NeD9cX38jS4tG8DOHMfyZylFfzy1cDh9uYmmORAI8J7l39jn+vFUo4OcZZAGDyjAW2dzJ2+fMnTPI0nbvbWFpjvY2XjYKrIT4+RYs6GdpwbF9vP3oqLL2aAaH4iwtKHMHb+9iET9jxgQR1qEh/lgYj4NnZffOJMT7RrJxmKU5+vqwZVM2Gzmal9/9hctvm8cOUBRFUaqWm//79e3FYniNb72Uu+3wfbPCldWvmLP6Bvgc6Ght4XNmOAwmu2BO4ccePNic9kK2xxjb7Xl2r2fsz42xv/vsG374E3awMm7wG/Zx0rGl68K9namCby2/q1AU5XlT8S0dztuHSytSu858oGupRlRRFOXk2L0q9YW+vP83MzVcmUeipnVVoWzJziClCWW6YVY3WFsXifJXhjMC90bWWe98uXHJ1g9q51QURTk50rs6P0nk3UTGSOtGFUV5nhiyBV10Mq34c7c2oNaDoCiTRaXizb36u2+y8UTp7Z9d+8N/10AriqJMLTf89NLZvm/W+dZcYH2zzPdpMV+0GKJi8dS+1vZ9k3T/ENEZR5OudP+65b4L2bGO7oNNe8Nh/+chr3LXres3fYMdoJzAhCieBIE/L/XeoaL9+uh0Se0C4Rmw49IpYwB1lBjanSnsWHaEwY7jPmEnMyoHUgMhQR2FhA2oOSEWGSEdrSUOgbJRoI7CksgKW2n7hK3TCxL8jPuFndM4FVMnKIKUQLV9oT+izeVCF5B3Q0vHA6T+lQUFSQq7rFFbSW0NNpEHDIIg1Yc9vz5ML52/tev37EdFURTlaf64IpUrlu0J23iE4Z0KYHwHw3hAR5zPl0EePAu4s4iC8Z3/kIzgfKV7qcTRe5DoHJ9aFmZGyiwpVUSEdKD+YYFySwAvsqz8Iahu2AzfEWUahbIBxRMr3MOYhJAHkN6zIVw24bbJycqxJAlR6QVgBQUSgzqNVD9wj2Vz4O8puMliSSRVW2pXcL6Ad8xiSTMSaw8ml26dWxuVVRRFee5kdq1+3D7zEk9RlEnD3phcsvUmje/04YZ7Lv1UpWKuG11gSVUEkc1ipYq6Ov5sJ3GkB6uKzGrnCh0Shw7xPDo68N8PD+MyZzI83RMev4RXxtTRMcDS9uxtY2mO04BSyJ69rSzNsWhhD0sbOb6dpYU8/AzWAnZkR6P8GZUCNQ+sVtLSwtU/8vkYSyNB/YWC3d5c1SWdwbvI00CtxPdxozQ38XxJeMbsG6hjaSMH84aNhvGz8nCel40EpZ1ZbUPbPn3xHZ3sB0VRFGXC+fidl72m4pv3V8reeb6lQNorIyhrtYF5LTOE57XTFx9haY7ubq4exhe0jDCc5XNjx2x8v5LN4TKHQzzvhoan58BfEQXW/ps2rNz8FDuwBhE+d4+fufd3/eOeValrCxWrLxcUZRIp+9YbLNIjlc7UXQu3dl2qsVYURTmRfZ2pq/oL9svoZcdMpHjQo9LcmI1ECrVSZaWKMGubnRUNfjKbaRgzJ71rtdWPPIqiKJjMrs73WTJfgz8qijKxWP+3yaXb9H5kmnHThXd+4pM/WXulb+nMWo+Fokwm1vdWffzOy2w44r/q5ovuuE+DrSiKMjFsuH39Z8ul0JWlsreIggUf5UC1pIZ5BRF90f2zcfsa2rev1W1mLYTC/o5I2P/ULWt/eE+thWZC9WsWbus684kVqUrFWrwMVlGUCWOoaC/54/JURdVPFEVRnuGPy1P5QsXiZdIzmL6dcTMnFWiu6OIT5ZRhXpEg2xKpjUUnJ2BuTO/s/EsyXiq55P497GdFUZQaJL2zs9st0NO2V5RThAldrKGennheZa1fCf2u1uOgKKeCcsn7n+vuXqvqJ4qiKM+BDbe/cXkuH/7nbC76MvfXdfGik9XWUD4L1lKsXPJWl0veT6/+7uUUT5SdCnuPF/K/EfLsF2666M7DY+cwvZkwq51jHD4v9aWyT0/7nx8Q5L6RgndzDK9XqYAsJEsWZJMT5AGOL4J8SZDuq0MFHkP+HtWkjDJ29Rak9ZG0YL8gMY+sYSQl+RxXBRKRld35+ZBNwVjUg/Gp4vN8SYhFDtjQOBoE65sBINkvqM5Ts/DJMgvUEMOgbA7gogCteoLzCbYG6PqMApn7qEe/mLul61z2g6IoSo3w1KrUf/QX/CuPry26J4jypAADhuGCMF82CvcErSDz3cNgMghca/j4HgHldcSF84228Eu+oEItZ2J5ZTtQZmkSpkGY/MGNkxXmYgkDJl4r2AOZceQtlgOHbnwAK0LRYgjdp0lz/BDuYKYZ3CD1FliSlLcYCwHYJsLNjRl1j2X+V3vFGoMbsGaw30ou2frO2o6Boii1THpn59+TMR/QTqAopxBrv5xcuvWDGvLpy8bta75ERJPehplMPUtzNDZymfuJ4OBBLn1Pwrt2R1s7txiKRsDLV/dOfABb0SSCj2AnEo/hPAbSPB5S2Txg2+9oSvLYIcl/R3Mzt6JJJPAzezaHrW8OHmxkaacvxjZAxoDnUWf1C+otAT4xUF8fLluyCdelVOKPiP2C1U5dgrffUBZb6iQb8HNxJMzrPTTM82ioL77r8+tu/4HdnVoAACAASURBVCb7QVEURQm44Z5LzqpUvM93H0pegiIyfy63qOk+mGRpjtmzMiyNgnGfj+UxYd6WrAHLZf7eslziaY4osOCZPSvN0iiwEcR16ejgx6MyUFBmnkd7G4xFZmg4/t2QZ6/729ffcYj9Oo2ZUMUTx+z7u64+vDr12rKls9iPiqJMCkWfzvn98mW2MWzeP39rl0obK4pSM+zrTJ01ULS/LvmWv9moMdKPhSgxK+rHk0V856soE0hgsWNMDaqdjMa8I7Or8y2WzKuTS7ZsZz8riqLMUNK7zltI1v81GYPfBiqKMjlY/3fJpdt00ck0Z8PKzVdv3L5mHREtqvVYKMqpYmg4+i9Xf+/yzybi5aW3rP1htwZeUZRa5yM/XDcvFqt8ouKT21BVhyUVlEmisVzy3lMmes+1m9a5TbG9kXDlrz518R3fm+4Bn/CFJ47ZW7pe2r065QQ+av4jkKKcKqxPlC7ar+ZWpDa+4IEuvBRdURRlBvHo8tT+obI/T9v0GbofiHiLXlMueyF/Uu7xFIWOWew0h+Pi9sAawxLFiOy29M5VP08u3bas1uOhKMrMJ71z1Q4iM6K4qXOBopxaTOj1GvEZw6uI6MlaD4KinEoqFa9jaDh6YMPtb/zJxvW36XiqKErNce2m9ecUiqFvF4qhF7vXWW2RrHaCKsD61FYshr7rFqGEQjbnhfyvfPriOz4yHesy4VY7x+g+L/XeoaL9epar2AQ0gc8h0rEtMa7x1pvH5Zbk6IeA78lcIJ3u6CvwvHNAhpwEyxkSrICSgqVOBpTNUQ/qkhdihIoH1NcDIsCqhQQ1+qxgJVQAJ0R2P464sPyoDKoNVPwDUJEl6yIhC2hhIJVNslBqj/Og5oVjB4HUPSoDjWHXg5JPti82Rc1PF2/reh07UFEUZZqze1Xq1oGi3XCsFlFhLC+A8Vmat8GUK1rWZcD4ToGsLUuC4zgJ80kGWMLRGHMEmmcaI4ZiHT61Lj5Rws8Kk6OpA8Hj2Y6AvIdi4O9JONZlDdrEgFgEoDLzPx9ByMMiizvhhtM0AYsbCgLNkpD9TgDKWiibWJchYIuE2omCmyGWRKjOJHRQEpahg741ku6TSXpk3zKL/aScgMrfK4oyI0nv6ryeLN2srasoU4ShG5NLtt6k4Z85/O29r7/eWrq5rg5blvjAknxoCNumJJPctqZasBY/E0nWMAjJamd4iPulJ4B9CwXvz3k5hNfLNHsWtxNw9PQiCX0uwe/Yf6CVpXXMxvkeOcLzdcyd28/SslksPDk0hNPr6ng8Ghrwh8Z8nlvUpNPYJqdXsM9pbuQWQ5UK78uOBQv6WNqePe0szZHJ8rZ21AG7pUIRPegStbWeWO9IpLLmU6+/43/YgYqiKDOI6+5e+6cDg4mflEohtoGzOcnvQbJZ/I60UOJjawXcqzjiUfB+U0D45EnzgMWNY393M0vzQjiTZAOvnzQnDefwPBMN87oUyzwWjpZmML9afL7BND7f7Fkn3tMZj770yQvu/hA7sErhd1sTxNz7u/4xHja/ni6BUJSZxmDRXvSbZcvs3s6UfvhQFGVG4Gx1fnvuMv/4RScKp3DIo0I+ju+2FeX5cnELf6unjOYD6Z2d+cyu1W9ivyiKokxD0rtWr3Tjmi46UZSpxP5cF53MPK6/4Md/S0R/qPU4KMpUUSqFNn/8zsueunbT+vnaCIqizCSu//Hajo/ecdl/X3P7elsshH+NFp0o0wPr09Ubbltvr9m0PvfxOy+7vtoLPamGTadt7XpFNER8KZCiKKcEt1Kwr2C/9MjyZWX3wVajrijKdOV3qWWF3oL9bRkLdCmj6PtVzFgTOvntY4pyEpgLmnzbGOZb4BREzFr7vfTOVQfTu1ard7+iKNMSN365cYys3UaBrZiiKFODHVQ7v5mLF/JX1XoMFGUqqfhm0WAmtu+D373i99oQiqJMdz5+1xuuu3bT+lw+Hz5YKXsXaIPOHKxP8WLRu9ktQrl207o9TsmmGis3aVY7xzi0OvWCvG8fHZ2OpO4liXlkLRIVbF2aojgd2aEMgzRHc4yvxxkUyiaBrIR6hDw6BAn2PnA8spwhQVVdUmWXrHYQAwX8zcqA9pPOlxbijGrdAmLv6Mnzcjg7AYTUrsjqiKeMIOVRBH0xKZQDhU6KUVZYnoUcDJBFUVA2XjR2vpBHpTO279APRoqiTBsOdKb2lawdc+eJFdai5IBdiDC8Q1eXBBiDaQwbOgSaL0mw5MNHyvOMB+6F/OMqYhKW2pYelSSUytwIblhA3Eby4FGy0rFCskH2gi1YvhHd3PCUo/miSVciKZxPyMOis4IkEupnhTnegHuKkR9YCoxFkDe6p6vHHXc8MYKWSGdEiF7NpSyVk47qz5NLt+sHI0VRpg3pnSt3EJlztcUUpQow3qrkki3btSlmLhu3r1lHRLc/nwoWCvx1Xyz2/MUKUb7jzftAdwtLc8wDNjISw8MJ+AuyVCmX8BvfRII/nEUiwFrVWQQA+5YgbyCt7xnkuYqtfdIZbE8DXhEE9A/wep++qIelOfbubWNpFNSb1zEzjNs15PGCnL74CEtzPPHkbJYW5AH2wLS2cPsdRyOw/BlIYzupg4caWZrjjNN5PHp7sDVTHMSCRjnThjx7500X3bmWHaQoilKlXLNp/YJsNrojXwzNbUNWL4G9DJ+THOEwH7PRvOE4dISPw60twyzNkcvieQaNw/V1BZbmKAJrH8dhUA5PsO9DcxiyzaPg/gG/U0VzpjQX79vHbfZiMX7/QUIsKLDr4faJkm3hwGAdhUP2mpsuunMj+3GKwCWdQDq2dD0W88z/rZYKK0otU/Ep8ujyZXb3qmUHtSMoilLNHFyd+u7uVcvssy06UWRsztBwN35hoyjjZk0zfpuqnCTm3PTOVXbkQ66iKEr1kt7Vea8br3TRiaJUC+bLuuhk5rNh5eZNRPT3tR4HRakGKr659BM/XussDW7RBlEUpZrZcNsb1733W28t9Q0k9rpFJ9pYtUm5Ym697u619vqfXHpnNQRg0heeOOZs6frriDF/ZD8oijIlFCrU8UddgKIoShWypzN15++WLbMF316h7fP8yT0ZplIuhpd8K8pJ4r2ltUCG8LJ/ZZwcW4CyarNGTlGUaiK9s/PvgwUn1r5aG0ZRqgWnmLb1g9octcGGlZuvJqJf1XocFKVayGUjH33/d96sC1AURak6PvyDN37CLTjpT8dvL/uEZUGUmsP3zSXBApQfr3184/Y1UyZbPelWO8fzyPJl+ULZBr7ASJk9geTCiagtxtMP5fA3FJBtwJwEX2MzUMBHF0HWjYIqe4hnGzAEFHKQTYujPszrR4HNCk/PoMARUQOQ4UcWAyTUz1EHhifJAgao+0NleBrDHghZw0j9cS5ov0GpfsJ+3DLIu06I/RCQmHckQMXzQrtGgL1CQjifZO3TAqyjkAUTCTZTfYKsfusoS6OwoQMLtnapqoCiKFOGW3AyVLSXHDt/DoyLHp8KAiJgbHaUwPgsjfslMHeApJF0MJ+QYCPogzI40PQqWcg1CGVGWeNRn6jl7IxvgN6wDbMkIsEC0KB6S40i3WygqghZIBsfI9jIUFZoLWRRA/pWgOSHh+qCLIpcmYd5OQyYn4NjhfncoPO1cknHII9BcMMp3HgZqd4NvC4290w9vDWNFXs6Mv9TJoivJJdu+4AGU1GUqSK9c9WXiegqbQBFqToGk0u3qc9hjfG5LRe0GLJ9x2rthYR7+JOkt49L0TvaWjMsbTIpFPCL9ViMP88MDGKLlOYmLjvvyOdiLK0I7HAcyUZuB9DXh+X2ffBY5igBGf7GxjxLo+BxmbffkSO4fosEyf5ymZ9PskuQZPgPdDexNCmPpiSvS1SwCIhGcPq+bj50zetIszQK4s+thxJ1vF9Q0Na4XdvaeLsePITbtb0dW1DEotzmYffe9hP+f0N94Ut/d/kPPsQOVBRFOUVsuH3953K5yLXHzlbx+VheBPMGBe/P8cTmW/4esS6B7eYQSTBvOA4fxvcgaJ7pA7Zyjhe/EO+bf3J3O0urr8Nlnj17kKXlcnGWNhYHDvJ5dPYsfF/S18frsmghnuMly5+hDL+3STbxuFFgdYTv6bq7W9x95P5IpPLKz1zyo0PsgEmE98pJpDFszvaEj0OKokwdZUvznlqVso+uWNarzaAoyqnkmMLJ8YtOlInn8G/rPQoZ/tZLUcbAnBUnXXQy6Vx11ILn5zO8noqiVBluwcmIpY4uOlGUqsR4F2vD1B4fWX1vPxl6U63HQVGqkaHh2NX/51tvtdfd/YaPagMpinIqcQtO/vo7b7bHLzpRlGfDr5j5hXz44DWb1u/7+F1v6HiWwyeMU6p4QiMfmD58JOdvrAO7MXNo666gMiEd2yzsFkYrbAxKDFQieN7SDum48Cp+AC+uggjFgHnn+EbagCawEbYgHCupeaBNwVEQexpZRMTS+tAO3WDjND+WBHUakO1IOgiSVD8hGW6yToAYU6Dogo7GZU6XcL1Rv60T+qekTBIG5ZBiVAc2D5R8fHBe6APHSIRNz5kPdM1iPyiKokwQu1cteyBTouWSGhgaQyWFqcYImCQENamykEdrlOeRBoobQdnwJhtRlQyB1E2k+RkpqTiagZLGkTyeT1z9Ih0Valo0ahU0iLMFZRMRzmdAPAPQjYw0sSGSYLJz9PLdSQ4LYgeSRo6VbgqAmoq4hAfFTsjXDvF8g7zR4aCdgjyEPgMR+r5B8S9bMklD9s1t7Cdl0vlFcun2czXMiqJMFkcXup2jAVaUKsaYG5NLtt2kTVS7bNy+5kYiuuH5BsCvgHv94LkYP9SWivxhRHp+Cof580w0ipUqJCUOY/jzZLGIy4bUQ6RyDA/z3caO+vocS/OFd6d79+JnIUmZ5GQ5fITvmnY0NuCdzD7YzV7xeTs5wiGsQIJ2xEv1RqQH8c7wXBE/n0dCvE2kHfEW7LRPp/H5YlFcv2yelwPl62isx+8OwmHeF43Q5wbTI/2rvq5468b1t+lHYEVRJo1rNq3/TD4X/lgigedXNDcWgTIXBXMjV9GgQAmKK3ccEtRKIhE+VlaE+SQEyuZIxHldQiGeLwX3FXjcjwPFtLygrobUQ3DJiBoa8If9xgZ+/7B/fwtLI6FNpPZrasIqXOkMv49pb8PKYelMPUuj4J6Oz/1trUPf2rDqZ+9kP0ww/MyTzMKtXV9oiXv3nurzKopy8uTKtv3hc5fZPyxfVjpyXupMDZ2iKBPFEytSRx5etsy6RSca1FNL6VCIcoP1/O5XUQD28lb8dKdMNuekd650Cii/S+9avUijrSjKROEWnLjxRRedKErV8yNddKJsWLnZLTz5Yc0HQlGqmOFs9Jq/+vcr7dXfu3yHtpOiKBPJh3/wxu1X/ccV1i060cAqE8g7Nm57td247dXvmsyg4iXEk8wZ27pes3tV6slsyS7WHqMo1UupQuGST491r05VwobePev+rm9pcymKMl66O1MvypTtw0V/au47lGcY/kPERJbE/HC0cMoXHyvTB3N5a9GGDNDTU04hLyFbeSq9c+VhMqH1ySVbtmvwFUUZL8ECNltxH0Nma/AUZTpgH0kufeAybSqFRhafrNu4fc1TTmRDA6Io1UuhGDn3+p9c6gRXHwt5/sobXnv3EW0uRVHGyzWb1i8Yzka6QsbOI8KqJYoyQXxj47ZXf5GI1mxY9bOdEx3UU261czwPL1tWzFfs0/o39cB+xxEF6WnB1iUGjnXMjvP0vVmcRxOQ7JdkgSSyQDkHWdlQYOPDkgKGwD5TyZIAxW5YOCE4NKAJyMOj2DsGgB1RSehLQpGhVKMkXR8H5RgS6ofsEiiIPz8e2TA4GpDsvKsLS3Gq+vjYAiifZBMh2RGBLMQ4I1uepPDJqB+0HwlWVf3HWUc4C6Jk1Pz36du6XssOVBRFGcWh1am/yPv0T5bIDAs2NFk00AmSbGFhrJwL5ngS5vkWYE9DgV0cL0dEOJ+QBbQBROMqBfMPS6KY8EyBc8BWQFKMRlvktazIVrxwOWRQ/JG/HQX+eyyJ0uCGJ5C1ZUkyvJkCDMoExDg4X6NwMwX6gBHahPJcDjigCUg1IssgEhpROB280aPgJoQliZR5/Ui4t4Eejo7BE9vQXNxk7WlSL1emkAIZc4vugFYU5WTI7Fr9Jmsr/+ZmJg2Yokwb0sml27EHh1KzbNy+ptm9mju+/qUSeD4J5O/xs9nzZWCwAebQ3MSl+TNDWO69sWGYpUn09CbhL/V1WP4+keAWLkcEO5vmFl6O/n5cZk94Sd3ezqXu9x9oZWmOjtmDLE0im+Oy+o5kI49zXz+2QMhlcd8oAduFxYvx2ogMkOzv68Nla23DFgED/fz4cgW8T3DfRYD9QEfHAEtz7NnbztKC42fzNkE2BY5CnsciKEcdfz7PZPCL9Rywc5jdflzfMjYbDtuLb77ojvvYgYqiKKP48A/euD49HP9OuewFPmMdszLsGGSF50jU8TFUskeLxfg4R8L4PH9eH0sjwcpu9z5sOVMH7HCCdFBmI8y5gxlclwoocyyC64ds05C9WgA/NGDOHD4vPbVnFkujoP34nNQn3mvgcsQTvC6S1Y7EwUPN7JdCgb9zjkYq279w+W2r2A/PA946p5CX7dgRjUg9SlGUqsO3lgYK/mt2nnOu3dOZ6tYWUhQF0d2ZuvepVSmb8+mfrfzZXZlC+h+oC5H1hNUTSq1iVjfqopPqJUbW3njUhufntR4MRVEw6Z0rN7txwtrK93TRiaJMKwpkQi/XJlNGs2HlZvelYyn7QVGU6sWaunLJ+5+P33mZ/fAP3vgFbSlFURBXf+/yr7zrG2+3fYN1tx1bdKIop5piKbTyUz+7KP3pzRctm6hT8+Utp5iWmPnTw3n7sPYmRZleFCs057EVKRsi8uMRet/c+7v+UZtQUWqXfZ2ps9Jl++tSmUJNMf1uPR3o+2V9qG1pxrq3IrUeC4WI/jRO9ix38eqa8GnAOemdK5xw5WHPC/9145It36/1gChKLZPetXql9cu3G6N2OooybTHhVyeXbNmtDaggNqzcvGvj9jXOi/9fwM+KolQxQ8Oxv3nvt/7sbyKRyv66RCn1+XW379f2UpTaJbDTGY79Il8MdVjL1UMUZYpotJa6Pr35oluvW/PTa59vEabUaucYBzpTl6TL9s6CsO8W2csA55WA0VLyxxgAcvTjySMrlE3aEwoU+ymB1ZBEZXd0/JAgn16PyjyOY0lQax+PNYykzJ/lqkABCbDsSaof6qZS+9UJ9UPuTKhvkdAHSFBakuyIsqDPCaejEGhrCmSuWBIJRYO2PMj2wTErjhurAmKULoFEgYawOfDCB3fMx78qijIT2d+Zui1XofXHV20QDLgtyKZFGFcpsLlhSdRb4Pk6YmBOkvKQ5vPxALINQG4vRji4D1ieSWNzBt1UCGN8QohFARzrqJ9lqWPRKPnfejwp2TyOP8LEcF0ItKEFVnEUvH8H6UK24k0ImMMsmJ+D8+FqyxY1iEEuFwk7BgV6iiwpAFw/MM3VBeRh0A3dWNSFiGaFiS7Ccs3KdMHckVy6/Q3aXIpSO6R3rvo2kf92bXJFme6Ym5NLt9+gzag8Gzfec8lXKr55f1SQkk8kCiwN2aY4Ghu55Uy1IFn7FAWbgWQjt9qJx3ksJMplnG84fPIvD/btw1Y7s4BdwuEj2EqoFdgAOerref0kpNghQiH83Igshg4fwfnGojhGDY08/lIeLzjjEEuTrIsaGni+FNgz8bzb27hFkaMpieOM2L0bW/vE4vwaLAL7Aoc3yuLBeLYQjVY+/7k3bPokO1hRlBnLjfdc8ue+733Vkn16Yo5G8BiKxssisEwbSedjz0tfjNe3/f6Pc1kaBd8E+TvVlmSOpTnq6rntHfp26xjKYAHOKJg7hrPY2qy5GZejVORlLoFYONrBXJzN4rIhCx8K5lcuSHPm6YdZGoFx37FnD55PIkIfaATzaEMDtreT6t3Tw9/zWmHv6bwTrZV+tWHl5iXsoHGAS3SKmbe16y6/M/WZQsV+vBrKoyjKc2OobOc9smyZ9bxggdMtC7Z26TWtKDOQvZ2pDw0W7a3xkPipXpkmFHo96m9spJZWfhOu1AgNHtGFjRVrSa/naY1dO/jQCvd0m/a88HtUBUVRZiaZXavf5PvlrxGpuomizASM8b6aXLpNF50oJ8WNF9511Q33XLKIiNZqxBRlemJ9Eyvkw9e/6xtvvz4WKacbGoov27j+tr3anIoy8/jID9fNy+UjDzY15U4bcaLnCxIUpQp5xcbta1xnPX3Dys1PPZfi4eU7U8CCrV3XNUfNT7WXKcr0x/eDHfofc4tQHl+RyjoLDm1WRZneuOv40eXL9u8651zbm/f/ruxb/Ug9Q8g8FabhHN4Jp9QAa5NOb06v55lD0vfL33OLUAYfWvFIetfqRbUeEEWZ7rjrOL1zxS/cde2ub110oigzA2OcWtm2q7Q5lfFw04V3vcEY2qFBU5TpT6EUTvb21+151zfebj/4X1fcrU2qKDODv/nB5T/4q3+/0qaH4vtL5dBp2qzKNOXJjdvXrHsuRa8Kq53jeXJV6pGhon0x+2EUUqmllTTIygTZmJCgqC4cSpI9UAXEFdnTOATF90D5fDTIMsjRBiwM+gRZdqRcT0JMG5FPgSsHyFvK1wgS+sjOBpWBAosa/ktEsLjxBTuBMIj/YcE2oBXE01EG5RgW2qQ+ws+HrGwcacFiaBawKiggT51AwoklES/BCMPC+TzQVqidHP2gDziaQeyGjsaoPmL2v+CBrgXsAEVRqpZDq1P3lC29pjvns8FAsrhBY6U0wNeBsZIEuziQFNAgzAfILq5JmNcw/O9pjLl/CIzPaH4moX5CtpQH+ZIw7+Ij5fkgflzsZi0p2nh93lhQtiCPJBDKE461Q1x6NgD0GckaxiL7HNCmQR5CjJBtkGQZZBpA/UgIqjAHUhG0YkOEJQUMCzFClktCnJEvo80I+YLrxFzZVLLxkFBAZSYx8nFLrXgUZTrhrHSsVSsdRZmJGEO/TC594BxtXOW5snH7ml1uR+qz/bkkGS/JskeAjU+xiOXvEwluAWMtPp8xwvMTkHwvFPHjSSzG5f0lhobq4C+ofpLsfG8f3pwxp2OApe3fj61hELNnp0GqswfC9UP2OUMZ3CYLFvSxNMcTT/I1q1Z4SzC7nVvUGGC/4+g+xGX8HfPm8DpKNhH5HG/vgmBb0whslUYKyFJoaAjbKJSEchCo4+KFvSyNgr7B6z2Q5jYMjvZWbO0Tj/G+2NNb76yOivF4+WOfu2zT37EDFEWpWq67e+1flkuhv0skSonRZSyV8dy470AzS3M01nGblWIFj12JGLf8RjYtNIYlWC7P0wvCfUJLE7a+QbS3YXXtoSEWIqrwzw4jZRZs9tIZPuY2C2UrgPpFIvi+BFnFSXiE8+gf4Pcgzc3YJidf4HOgo7GB1yWXx/NaOATeRQfwmKJ7Nwriye95hodG7jWi0co3b1n7w3exA8aAR3yKOX1b10ueWJHaO1y2+nFaUWYYwyU7/1fnHLXiCdHPz3hgxzJtY0WpPg6tTn25bOn9Ft2hKDOWI7uiZtYSsrFYTtu9BtBFJ7WFtSNWPMZQkcj7XnLpNv2YrShVSHrXqhvJ+h+zlvAXJUVRpj266ESZCJz3/sbta5z8uarbKcoMwrcmms1FvnDVf17xhZBn07FY+f2fu2zTt7WNFaX6+MTda68olUP/YH1qUyFhZaZSLIb+/GN3XEbjWXxSdQtPHGc80HXa4ytSPdmybWM/Kooy7QmseHw611l2OJWVhjD94owHdpyrLasoU8fuVal/S5fs21qiuuaglnGLT+Ysq9iwKWpHmMF465pKvi46qUlGPmb7bxt8aMXbRhahhL6eXLr1g7UeF0WZSnSxiaLUDsbQHl10okwgS4jILT5p0qAqysyj4ptkNhf51vu/8+ZveSGbicfKV31+3e3/qk2tKFPHR3607nWFQuib0UilQxebKLXCeBefVJ3VzvE8viJ1JFex7cgWRPowJonKIOVzZGVDgp2NoOxOSaRzH9i6sCTRGiYHzicd31vA8j1CMSA4B2c/wDMJA+sVCmLEc0kA+Xwao01QTEERAlCIQNLIsSjjQG2fZ45sGCiwSmJJAXGQR1HIIwnsHCR7Gg9nQTFwPimeQG0fWjnQGJY/zcDapygEY1hIj6A+A5IIxM51oY6496sFW7uWsIMVRZlw9nSmvjlcpndWjrsWwdAVMAQGYslqB40PUr7SPNMEPr1IFjcSaAyU7N+QRR4ax0mwmyPsZEKzkG2KUJcBYY5HcwEJlkYgKUBQLKQGcAORK1s6LZX3I+HiCYW3YI4w4O+DY4dABWmMyRsB5lfpfOJNXRSkHxFkE1uFdRh9XLaSEjwWDlsAZQZFCAD9MwDcDFmuwjuSN6i3zQuxP9q9vPVNJb9FF50oJ2KMdYtQVAlFUU4R6Z2r/o2ocoW1BtzxKIoyEzm66ETVKZQJZeP2Nc3PZfFJNssl6h11dViC/WTpH+C2MBRY4ONnH/7k4ywCsDXJeMgLcvTIVkeSnZfYs6ed/bJwYQ9Lc+zezY9dtAgfK3HwYAv7JQ9sAxyLFx9haRRY15z87UZmiPeNpiSX/A+OzXC7BApk+fkztCe9/AYUBYuH5iZuA+To7uYxamnB/Sibw30DWSMkBWsfz+Pvbg4d4fY7joXzuTUTBbYGvByz2rEtxVN7TtybHQrZ4Zbm7Ls/ffEd32UHK4oy4Xzsjjf8WbEU/pq15unBxgP2XI5eMJZIlltSHod6+Vz6wtMPszTH7n1cuyEObOUcc+YMsjQKbL74+CXZt+SAPVpTMx4ro0I5enp4/aQ5IgZsySiwp+Pp/QN4Tqqr41Z2khXhrHYco8E0t6JBlmkj8Lr0D/C/d8ybiy3yhod5XSIRPreScG8T517VDwAAIABJREFUHB/mbSjNgeEwn9ficfj+/KYNKzffyFJH58dSqogzH+ia9eiKVG64bPkdj6IoMw73jTFfoVc8tiIVjM4xjx4Pe3Tx3C1df9TWVpSJ4dEVqSfSJf90adGIojj2dsW9RStsJeRJBsjKdEQXnSgSIx+/R5RQaGSR3n1kQu9MLtmyW/gTRVHGQXrX6kVkK1+11l76zF/pvZii1BAZXXSiTAYbVm4e2Lh9zWJVPlGU2qFSMfXFYvi/rtm0/r8MUS4cqXz6M5f86NPaBRRl4vjMfRe+lyzd2tPb2Eikr9EU5Sg3OKvHDSs3f3OsgFS14skx9nWmMhVLJyyDOpznK3AceJ0SfqcTE3c9syQqg1VKjjrhw50HCpKXFkDhLAiJugibrGEeYMNsQAFVUFDz4Gui5DykHdkoXwoWGfA8MmBHPQU75XkeUv0k0MZiSa1EqgvqBmjHuXCouLO/IJQDVJtmC7vne8Eua7AROkDqRj74QVKFqRN2naPSDaHgC20iKedYY0rJqP34oq07NrIfFUUR2duZWkeWvlHy6YQtIJICkzT8ofErIYwDGaSKJRxbEiYaNMYMCmWWptc2MJH2FcHA4+YqMPaguc4RA2UjQVmrVygzON24xneS5h+QRMF8AE5IeNA+Xrlq1jlp35TKI0e1gAct4Xw2ixvWoHgAJZWAejCJCY1th/EPBsUUydKRcANIgZQaS4ITmCsHKLMZxrGw4JoKjkeyZFGhzOC+yQpt7V2UrPjzwryAivIsGGP3GBP5cOOSLd8f+0hFUY4nvWv1SrKl/7DWLNTAKEpNk2k6+4FkrQdBmVw+9P3LO+fP69tysicZGOS7jSnYvct30wo7XscF2rnrqK/nShpS2RrAsRTs0sXPWwhr+XPVwUN4vc7cOf0sbSJAu6YpUBXBO+L7+vlO9CGglkFjKK9kMvyckrLM/gOtLK1YxI+RjY24b/SBHf+nzcPKH4eP8Pb2BclWaVd3Qz0vx+zZeNf6XqAO4CiXed84XVCQeeLJ2SwtFsXvJIZyWG2mpYn354E0vk6SoH59gzzGjrkd6e+GQ/5VN110J5ZHUBQF8vE7L5uTL4S/nc+HX3P873Nmp9Hh1C9cg/kCf3daEMbQjnas4pSIc4WOgqAEVSzy9Hqg8OHYe6CZpZGgbiKpecydw8fyPXvxuIrG5uB8EfDeU0BSQgmFeB6NDVmWRoHCFJ8Dk8IcKHHwEI8dUgmRyOd4OzkWLMCKJ0hBToqFdH9ULuN+h4iB+z/pfmXkXtG+7ro19/yU/XgUXNsqY8HWrka0+ERRlNohX/Ej+RzdeviV594aMoYaI+aJmEeXLdzW9bB2A0U5kSdXpe5JF+1rjy3waxIsYxTl2Tjyi6R3wuITZVriXZT0/XmhkLhSSFHGwFpaaG3pe4MPLXc2AUUi757k0u1r5b9QlNolvXPlvxH5V1hLx31l0LFXUWoXo4tOlFPCF9/0g60bt6853b0O0IgrSu1SKZs3V8qhN3/0R5eR8agnFPL/8lOvv+MH2iUUhfPROy57W7EY/qpfoWb3qVyy+VIUZTTmJ7fcd2Hbx86/B66cmTZXki4+URTlGBVraaBozyCi33SffS5FPWObIvS1Mx7YcZUGSalF9nWmPpOv0IcyJV+t6ZQJ5+nFJ1AfRal2ji460bZTJoSRj+n+pYMPLQ++pBtjdhvj3dq4ZNvXNMJKLZLZteqvra1c6xZoaQdQFOVEdNGJcmrZsHLzU7r4RFGUY1if2su+9323CKW9PVBt+FciutGNFRokpRbZcPv6VL4Q/qew5798pPq60ERRniu+b7YS0Vnoz6eF1c7x7F6VGi77VDeApNrHsBBpALLjoqI6iAmS4Kcx1NoLXJ1ItFOpEzxjLKjMsFRoQFQoM7K4cdQD6wCeIpMRZOelPNDhTUIs0kBKXrLwkexzULVBUgDOGVtQIPsJCux6WBKVQZs6ckKZUTIqg5R3EthMjMUQiHM7sikgop4COKE7J+hH6HogwSYCOQxQYEnAkgJaQR09z2Sjhv5u3tau69mPijID2NeZekOuYv8lW6YTNFAbwPXnyIG5o4QGGHfNC7YnaByW3D+Qy4pUNmk+R0jjX0yY75CrTgWMOyTMmVKMIsK4j+4fkFUcBWM2P1aaT6R6Z0G7ClnAOdDRAsbQQdDWjsUrs9aj8ol/IDVfAncOA8os+QjaBJ9IjdCPrGBnY0D9SFiDYXNCHmi+w1mQBXmbpPAgW8Tnszl+PtMg5IHicdwNlnl9Y8FPGqzDrCiTgDG015jQ53QhijJTGbHPKX/FWnu2NrKiKGOQaTr7QV10okwJG7evWTyRi08qFf6MQ4LMvURvL74cDJCNb2zIszRHJMJl4CX6+vD5WluxZQJiPPUeGsIWKYUCf45LJrEkfrHI7RlIsCM6JNgDSdY36EVBpcLTSLAjymSwXUwuz+tHwSM3b9emJC5bOs0fVxcLFjdSjPr6uB1APIFtIiplXG9kj9HSwmNPgi1PepDXgwJ7DJ4vBfbLvB/lgWWGoyHBbTMSCXw9NDTgOA8O8n1qpVL4rki08pe3rrt9H/tRUWYA125aP98SbSwWQm/0rXl6IAt5/PpzDOf5WAeGz4AosKchYRweGub5Ourq8HWcA7YsmWF+DTuawJwpjSUSDcCaJxbHZRsc4PNdWxu2uBkawvVGc2OrkEc+h8fQCLA3GwBlc5TBfN7SjMf39raTv09ANnYUfN/knaa5CdsqjceKUEKaG6NR3IYnS2YI1y8WPa6PG/Oxj59/z2dHH8NbuMpZtK2r3i0+cdfldCu7oiinhlLFumn7E48uX/YJd8JISBeiKNObvZ2pD+Yr9pOjF5ooyqnkiW11ZvHyvA2HivwOWqk6dNGJMhVYS6dZW/nq4EPLv0q6EEWZAThFE9/3309kX6ztqSjKyWF7ms7umqXBUqaKo8onLUTkVA3wCgVFUWqeTDZ2CWVp73u++bYgFIl48dfxWPn/bFx/e1etx0aZnly7af05pbL3uWIhvLrsmwhRjKIRvEBEUZQJwNpbbrnvwu997Px7Hj8+s2mpJeQWn+SWL+sfLtlm9qOiKMooji1Eeeicc0cWohhjG6Lm3hDR1Qu3df2W/YGiTDF7O1N3FCv0mmLFxpFqh6JMFU89GDeLl5MuPqlydNGJUi2MXoji3m8aE/rX5NJtao+oVCXpnau+Yq3/ZiI7W1tIUZTx4hZcJpd2qfWWMuVsWLl54KjyiS4+URTlpMjloy/P5aMPfuj7lweHh0L2j5Fw+cZb1v7oPzSCSjVy/U8ufaPvex/2K7Syb8DpFOhrMEU51ViibxPRyuNPO+2sdo7n0RXLerJlajs+rVFYSjPMlXegJD4Fkvb8WwpSMnfkkWS8oMDuCXL7QEk+YAh40Qino2ZgUSPZm0SF80kWJwgk7y/507QJtg0lkIdUZmRTJIRTtEBA9UbWETSGrQGyI8oIeSRBmyD7CQpsg1hSAM+BqA6UgQK7Cl4OIfQiEVDxIZAvjREj0KximQdLvNOBPw/AOTgvMZZEMeF8iLajNgyeoT3G0D/Mvr+LSUMpymSytzO1fqhsvxE21IymJcH9A84z0rVWRBemwHgs3aTxFl2wUhkka58BMD5I9YsJA9IAsEhBljokOMYIRUbVC0D2ZkfyKGc8bw+DeZ8EazoS5kHUhxwN4HyOPLg/kiz5jq/4grMLFAvloLXM6GNPSAbtSvV4ErRgfjXIV46EBnR5AE9E04DPJwYa9bsMCFxgtQOOlTqSUG8zxPOW4oysh+wVjSWKe1hnUVGqEGPMQ8aEvqGqKMqpJrNr9RXWlj6qtjmKokwEuuhEqUZu/u/Xt1f80FNk6QS9dANsPiiw7+AWAchaZrwUBbuR6DjscyaCcpk/g0mvNaTH4nCYv6TpH2hgaRRI+WNpfYQktx+LcQuE7oN4L+5pC3pZmqMHWB2Nx05AwhfsegaB/UB9Pe9bFFgxcPuIIrBhoMA+B/eXIz08/vPnDbI0R28PFtEPh3k/Twg2GKhvSBZRBw7gtmoAdhytLRmWRoG1Es+jUOR9mYL+wvuno2P2AEuTfO2P9PD+QoHdVSXrheibxvhfu+nCu37HDlCUSeRv733dnxCZ9+7Z3/K+ctljA0dEUDZpbx1maZZf7gE5YOuSzePFLLPa8fWaBrZWVrjWojH+/o8CWx1+TpwD/pY2ZzYum2Qh15TkMZLsWzIZPlchKxsK5nhcvwSwD0NzKwVjGh6Hj/TwNbVxKZ7A8icCxvygHEI/QvcKpRIeh9F9kzS+54G9k6O3D81rfSzNcfBgC0uj4N6Ll2/haT0szXGgm+cxb24/S6PAmo6X2ZB963Vr7nl6kSKexacJL3xgR/sTq1KPZIoqe6soyvPDt7SQLN3S3Zm6hUYWCdlwiA5FPbpx7v1d/6jhVSaCfZ2pNxQq9LV02S6ojFpQhxarKUq1su+hGC042y3q5C9LlKnDXpEsUtzwJwBFqWLcR39ry2cPPpQasechKpIxDxsT+Wzjki3f07ZTJoKRRSblq8j6KUuk46SiKBOKW0SZXPrgKzWqSrXxydf82H1haLjhnku7ydIcbSBFUZ4rlqiuUqH3EXnvu+7utUEunmcPeR79f4b8f7/xwrsf0eAqE8FHfrhuXrns3dzUnL+YiOaOZDmyuKFcxoscFEWZSsz1RDQzFp44ztjW9ZKnVizrGizTMvajoijKc8S31hTLNKdI9PVHly/7+rFcyj7lYhHzQJjoA2rTo4zFEytS3/eJXpUt27bRh41edKIo0xG3+GT2WWFqACvjlSngrckyhXTRiTL9CRYFBItRit8dfCh1XH28Pxjj/f9q06M8G+mdq26y1n8Lkf+iZzlUURTleWOMd1dy6QOXaiSVauamC++ce+M9l/zSWqMqX4qiTBjWmo5Kha4jCl33iR8fXYxiaLhvIP54LFK54QuX37ZJo62MxY33XNKZTsdvLBTD51V8OiqzMaL40dSMlYQURakuLNFLNm5fs27Dys3BmD+trXaOZ/eq1LcHi/bt0n7xMqhnUwSvjssCqfUIV6UJkKxa2qI8b2Qb4IgjrXwnhQM+TCaApLoEks+nMST040AePg/KQIJqvFQ04XSUALv7S1jJCLafJwhMCWr0BJqEBoX2Swhtgqx2Boq4XZGCFkgKCCOtJqHfof7paABlywl9APUtEiSjJHuGotBWyAqjgDqM0CaZcdRPKkdOqB9aaRcR2hrnECijMOojZCMeHQ4bc8f8rV3/mx2gzGieWJX6br1HL/OJ/sRaOuGq7S2ADiONJcIcIVnDgMtHHrNB1lEw5o8FGI7EaxuNA8Kh4rzWJ4yt4wHZ2UhOLSh20vws4YFGyQrzTEucH9wr2PKEhXKg+TwmHctSjsKzEMfQKJgkXFLDogq1zx8lISz0ZzTRQHsawmUzYkfi8QxAc4rUt9CkRIK3HGi/AJS15Jcl9A0xb4TLosEQrWusWGPQZaooM52iMeZhotCdyaXbbtDWri3cAhOiyqXW2peRqpgoijIFGBP6TnLp9rdp7JXpwsbta9wHgcuqubglwZYnItjy+EDi3wMy9xS8o+bH9vdzOXtHLo/eIspS94ihIW7rEhasB+LAUocECf05c7D8fS+w1HG0AVudUhnXrxtYw0gWN8iWwrHoNG75s28/r4ejvoHXOy/km8vjdGSx0dKcY2mOdIbbYFBgxcCtLV70wm6W5nj8yQ6WZtALjCDO+DF9Vju3Ycplcf2QnYNkSxEK4XIg64feAW6JFOQNjnUkQB/NAssFChaf8DxaW3NHQsbeazz6+s0X3XEfO0CZ0Xz0R5e9rlwJfSAzHHtVpWxO8Gs58/QjsOr9/byPliv8enCUinx8d0Sj/FrBVwlRGVxrC+bjMf/hP8xnaY6Xn7WXpeVyeNw5eKiRpTmamviCG1Q2RzLJx7oeYD82Aq55PMHnJRQ3Cix4eDmKRTyf+DgLamnhZe7v5xY+QR4+btdZs/gYKsUzHuf1i8fxvCZZ5A2meV+sA5ZBJNj6JRK8TUmwDCJhTqmvx+eT2hWN+xlgb+doa+VWQOgehsawjqqry2/9yOr/Xk3Cd9hpyaJtXf9r76pU90DRXjNT6qQoyvTAWjLFCnUUyf7Fo8uX/cWxQruFabGQKSVC5uFIiP594dauL2iTTk+cRU65Yj9RsnTWQMmyO4249NFbUWqAod0hKmYaad6L+U2qMsl0hMleGAxJ/KlGUWqDqLPqIQqsej55fI0N0V4yoS3GhDapZc/0Jb1r9Uqylb+21j+HyP5JrcdDUZTqwZjwzbroUZlubFi5ed3G7Wu+REQf1MZTFOWU4ptZFTJXUoWu/Pidz6x/GxiMlyIR/4lwqHJnKGS/+Pl1t+/XhpmeXLNp/YJy2bumVPZeFfLsi61/vCrvyH9WyvijtaIo057Oz2254IyPrL73iRmz8MRx2raua01nautg0f5Q2KyrKIpySilUbKRQsUuJaOmRV567kY5TkQkbUwp7tC9kaHPF0pcWbev6jbbO1LCvM3VWxdK7yj79WdHaOcWKfsRVlPFQ7PNo784knXZ2xopLn5UJxbw4Tv45UXFlu6LUOpboNLLlt1pbfuvgQ6NdWU2PMd4jRN5mMt43kku27K71eE0V6V2rF5H1303kr7HWfwmRba/NSCiKMp3wvNibdVGjMl3ZsHLz1Ru3r3mKiL6ojagoylRT8U2kUgi9iMj9Qx9+77evDErUUDeyuz8Utr8Pef6DnqGffvrSH/6nNtjUct2dl13pW3pdxfeWV8rmRQOZ45UqnlFIqI9L6gyKosxg3k1En5gxVjvH4z4gDhbsw6XjPnwgxfdkFH8XQZYESKndURBWuCB5fp4ygiRp34Ck3QWQRQCyOqBAnoglBUjK84g4WLI0LAQJSfM7kNJSQvjUi/JuiWGFgZIgw4+U7itC/8ep2IJHaj+hGBDUX0hoV8l2AzhKiDYYksXGEIizcOi47ByESw1eP8iChMawtaoDBcwL9UZlkywsyqBsNOJTycBHyn0AZAHTPM9QU4RyEc88Zoh2hDy6be79XXezA5Ux2bMq9VKf6P+UfLok6tn2sm+S/qgP43kwPiCLLwquNd5aReFYqQ+g61gaj6QxNArGS+k6aQEWIj0FdEW4a5slBaCcJQusAVAOaU4LC+dDYzYaM0iwwCLBQo6njICykMYuCTRmg2E1ANkADYG40RiWZ8g2COcg29Ch+TUkRKkCckfz1/xlg9ZIHnKo0FKny4FjG8ANCAUVYUkB6MZiSDi2Gcva2iHeGQ26WXTUg/MJ8ZSW5xgwFtjiiWneqxqtvxgEX1GUCcIUDdFhS96vjPF+Scb7aXLJlu0a3fHh1EoM2aW+X3m9If8Vlmg2kcV63IqiKNMCUzRe9E90waIyE/j8lle/mgzde3xVPI8/i4igBxrz/L8z9PVjqfzWFqywiWTq6xIFlkaBTD2Wuh8PhQJ/bowItif9wMokEsUxyg7zfB2JOv7xNgqsZRyHj2B7hXlzB1nagW4eNxJscrJ5LM2PLBdIsEzomI3br3+AS/nP6RhgaSPnwzFC1htHhFjMmc1thxx5kLdkfTMfWG888eRsluZobMB9EVk/DAziOA8Ca4SXvegAS3Nkhnk8KWhvbsPUUI/LJtk57Ad9JipYR81qH2Zpvg/GjOCa5/2FgveF/FpJAgsSY+zhgYG64XDI/304XPmR8eiujetv434nyphsuP2Np/kVs7Zc8d7g+94Li+XQ3ErlREucjln8Ok4L/bYo2HmFQ3z8yoJx1REBViFSn5s7R7i2Qd5SXzwCLGpOX9TD0hyHDvFrioR5NCLY1ki2YjEwPrS08GuKhPmnt5fXg4JFXDyeFLQJLzOyH6NgPuHj3569eO9IgzD+xaK8fvE4PranB8e5tY1b4lhcPeof4PFICBZyyYYsSwsA9zcHD3FrOgrsenhbIas/Ghm/WNrRv2ApkhVhg1DmCrAiRPY7ju5uboeH+iGNcT92lPs2rNz8Knz1T3MWbO363QIi75HlywqFsr7YUhRleuL7lsq+SZR9+6dE5P55T2b5MhoGH6cjnrFkqBzxTJ9naDji0Z3G2L2Ltu7YyA6e5uzrTL3fDfUVa8+3ZJK5in1BpUKR4xcbSgs+moIP+MKPiqJMCPt3NJl5K4atZyr4SU55XniXNpX99pljl6ko1Yl1nwQWEFUWWFu5hCx9kqumHMMMGaIBMt6T1lLa87wfE3mHZ+JO+Myu1VcQ+bOtpRVE/kKy/umWqJnI8jc5R7Gj/ldRFGX6Yoaazu7CX8QVZRpy7eqf/ezWbRecYa19QttPUZTpirVmdjYffJA9nYhe7/7jXd94O4U8/oE1FLK5kGcHo5HyQ+57dCjkbzWe3blx/e1d7OBpzsfuuGyptfRS3/dWuK1W4bD/cveN2vdp8bGaHTzho/4zC+VQ7BRFUU6C890hM/ql9Use3BF7dPmyfcNlO5/9qCiKMoMo+daUiSK5iu04WqsPuH8dfuW5twIRBmoSpBxChkoemaeXM3oeZYoVyrEDR+GRTftk8BLUEaWYYPmtb6m+6FPrM79Yr1ixbGsC0kpAKiHuM0YJVVBRlCll3wP1pmNpwcYSBXThKs+VK5MlP054ibuiKFOEbbBEDWQrCyhYOFy5xP2vvFBFwvQYome28BnTY615Vn9zY7wBa3281eaE4+x8ss/Y2FiiuNraKIqinCzeH5vOfvBFGi5lpnHNqnuf/NyWC1qNsbuIaKE2sKIoMxmn4FEqe4l8MXTx0Wq+zf3r3f/yNmpu5Goqw4IiBZFJG2Of/oNouPK4MTRY8T0s33Lsr4z/mLXeC9gPR2luzv7+2H/61px1LL1c8iJ+xbx49PG5PC9f+GlFgxN/83QxiaIop4CN29e8akZa7Yzm8RWp//GtPX90egbIy1OwSpIlQTsPR1b44InsB7LC+SRrEWR7gvJ1FLmiEkXYp9wRJHX4LJAIaBTk/ZFdj2TV4wv725A8v5QHcIkQ7RmkdkWqRUWQRmPE2QPnrIDYk2C9IXSXccV5CLQTCfGU7JbGY7GBjyRqFcqcB8UrCzFCthRC9aBlBgmWOCAUAU0RUEGBfqEztoAFG31CR6oXyowO90F/IcGgQbqGUf+U8hCygOPfnATO+HAe54LGNJAUMAjUW0joz0KTUGIcSyglK5ok6M/I6oVGFvmwNKl+Eo2gL0pZSH0RzUvS+ICssaQyx0C+jjQoBxZcw+3H/3pskPUQXnwk22uhqkjjewG0N/r7AN58ATkw/4DuEoDGfclqRyoHcrOR5n4pbxRSD+QrlUM43dM0vbBMDY3HSfChYjTxB+UA0OcsiPHIDzgdFJksqog7FrRJADinJN9oUIOjtKAcuCMZFKSEIfuWJp88QZtRURRFURRFmSTCdzWd/cClGl1lpnPjPZf8sqEhe/YpreYE2PUgq51EHEvo+z5/nGpsxBL1xggPfYDx2AP19eE9W0b4KJwE5SsWscB7JILrHQZWDJI1zJwOblfR28stgyiwZMHnKxT4m4KWFl4PCqwD+Eu9vj787T5Rh8/X3MTzjgh2RFK7DgxyAb+hDI6zD/ptSbIV8XA5TgOWRo8+0cHSHK3NfD/gwACO0ZwO3ucosM3gdUF2FxT0L1wXtMjBE67XaIznHQIWJBT0fZze3sb74mNP4hi1JHmMJFuRcomPAyTYguzZx+0nxgLZYCG7C0cdsNGS2qRc5teU40gfvzbngms4KEeZl0N4/UeDaWyf09zE4ywRBrGg4LriFi4tLTjfNDg2IrRrSwu3XnE89gQf6xadxu1iHN0H+XxSEmL/ohd2szRHLsdjly/ga6qlGZf5yadmsbRmMA6Q0K4Wvg0lGgLjAAXXGh9DJeubgyBGkiVLWGgrNH5JZW4C1zYFNkU8pgsW4HZF16BkOYNiT8LcaMFcQMG1zRexSddwWZg7pPiPh+Fh3hcly0EUo8E0H19IuLcZxYdwrWYYZz7Q9aru81LvHSrar9dCfRVFURRFUaqBwUfDlGtrolmLuKe0cpKcESH//LpAIQqtSVEURVEURVEmh1Ao+v7GJdu+puFVaoEbL7zrlRu3r7mRiG7QBlcURVEURVGeA801oXhyjD2rUi/tL9jflI8uS40KO17LICZot/hYFMHuVmFDNtxBLJ1T2tWNFoRJO5ZR2UjYkDselYl6YadwCS9uhGoXCVDnAJCM1DlojHojxRnU1mORBCoFRaFN0uB8SWGnvZAFFUCMkMoBCUoHkjoAEO0I4DkQDYN8HUJzwxj1gl3rJLR3SWgTpKIRlA/s4he6HOpGknABPtjVG5UZtJN0LAntLZUD5SBkSzmUsaCsMAz6p4SQrbgqug4UMCfESGhuXHHhWFQOqcyoz5HQZ+rwQlRKA8maZmFAQiohFOx44OUQQiSqO6H5QBofUHPHhfohtS0SVExAKALQNYH+noRxjoQyS2ol4NCRdPCDVG+khoNbj0jYjAFVh1A9JJrBtUpjqO+g+Rx0iwDJXguptEhxRopikrIWCAV1pNLWoC1tYN4IyIIV84I6ih0WggSuTQPaOkAK9HgA8ZAUVqTGMk3PrAs3y+srlfnPKiyjKIqiKIqiTCDGmJIxsTXJpVu2aVyVWmPj9jXriOj2U1HtoSG+61lSUKgTdukikIoGBSoY4BlznBw5wnd7NwHFDRJUN3I5vOM8GsVqHkitJJvlu5hJeD/mSCR47PJ5riTgiMe4CsPuPW0sjcbY7b148RGW9pSwizwGlDEkdYDWVhznMNi5XgHqNhSo3uAyo3SkXhGUL8/LlxXadeFpPSzN0dPDlW+GhnCbtAE1AvjeNOifeIc62s2O+haN0a71QKEjEsV5oLpEBTWPUhG/8kB9QzqfX+FlPniEx9jx4hceZGkUXJu8zOEwL4NjCCgJkKDkgJRNHMNZ0GeE2Le3Y2WMIz1YbQmB1H4kFZozTj8HGx8wAAAgAElEQVTM0khQ9unt4WpBjp5+nC4pUiGQGwDqyySMAwFgTokKShz8SKeOwtWJKFDfwWNaHPTzUAjlLI/Z6H12Ng/6ixAjaYBYvBCPR0h1A80bJKh2NSbBGBWMAyd/nUjj7axZWF1jMF3H0nJZ/M54/nyuhCL1fdRfKFB64epHFTDukNB+6JsBBdc2V1KhMcZLBGo/ElRd0DgwYTwzfv1IqO7MZOG2rt++4hc7vLqwwfo8iqIoiqIoyqRwqCtpSuWomsqeJPbihqIuOlEURVEURTm1GOP1Np29I6qLTpRaZcPKzZuI6HT3XUc7gaIoiqIoijIOmmvSJ/4lO3bUNce8newHRVEURVEUZdLo3pHwMv18VbpyHPUe2fUNJZuweDuDoiiKoiiKMil4XmhL09ld7RpdpdbZsHLzUxtWbm4mol/VeiwURVEURVGUk6emrHZGc2B16q8yJft/R6cPAQl2yTJDWrlTBHGNCNpJCSDLToLlCJZOIsoCuXZBsV+U/Uc2CMKh0CanQZCSR8eSEA9kz0CCDYZkI5MQ9gYj+wjBBUMENRXINqAexAPVgwKLDZwJz0HGgKOt0ILC6WD5UD1oDAseZPUhNCu0X5GsJsrjaCuhaDCgUp8TkqFFijQOoP4SFAP8QRhcD47+cXRSqcygSWAaCeOAZEvWJ5QNtSGyngrAWVAMnFOy9Bgs8UzwkfL1ipIlxbUwKJto2yUkgy4A+xaN0Y/QuI/iRsI1IY07UoxQOSRrM3RdCUOz1AUgyIKOxphnEC1RFH3cZypCjLJosBTsj7DYHVEjsL4pCPmi2JMwh1WkTieAbMzQfRAJ8cdHyu16LKaxFkunvXzYJ7IenHxImKzyQs5C34c2NyApSAbtFxDHfQZSAOWT8kU3LIsi5HdyeVdFURRFURRlcvG82FXJpdu+qmFWlBPZuH3NjUR0A/sBkE5ja4Vk4zBLI8EOJRSSHhBPHrEcSWxXMR4KBb4/wAjS/D6whMBHEvX2YosU9A5x/jxuG0CCDQYJFiKSJUFjI7dXKArWRXWJAksL8gaWEJINxqHD3CqkuYmXwZHJ8Hwdc+dycR7JuiidwX0jHDp5W4NSmT/LJ+I4FpJdArIeam7BIv0RYPey7wC3faDAKgnXOwysRerrsQVMTIhdTy+PndQ32tv4tZbP4T4HLWcCCwpu35HP8diPlQdCsvQYBLYgbS28DBTYPvH6OR57grerZLNigb1TcxL3gawQOw+8vEb5OhoaeR9FFlMUXA88X8cBcL3Om42tUPoHuZ2KYwEYv/YL/RnZ8pTBuOqIx/l14ujp42NrWwuek+rreIykl4ho7HK0gD4j9f2iYDPV0sLHwLJg64LmH8mOqCDYmKGxQBpLBgf5dTKc5XMMBdcabpM5c/iYjeZWGuPaRp8kZrXzfB19/bytigUc+3IZx27BAt5vDwPrPQrmRh67/n58PdQ38NhLSGOzNPc3N+Fx6mQpFnG/LVfw+eoST49f9+Eo1gjztnT9w4se3GFCNJnGRoqiKIqiKMrxFPoNPXZfg2ctePtRo5jXNFR00YmiKIqiKMqpxZApeaHEYl10oiiYDSs3u4Una+CPiqIoiqIoivIMT9X0wpNjvODBrlA8ZJ5kPyiKoiiKoiiTxuP3J7zsMF8tX2vYtzSWKh2iMJCiKIqiKIoyCRgTerTplT+PJpds2a3xVRSZDSs3/4/bhE1Eeq0oiqIoiqIoEk/VtNXOaPauSn1usGivRTY5CSAvT4LVAQkS8wkk905jaOyBw5GMPwny90XBegAcKhZDqjcqBhYpk60KokAPCcWeBAsRZOlCY1guoGQhC3isIw7+QFq9hbKQ7Gkk2yCUt9SuSWBvMix4ZuBUoqYIP2Mv8nIQ7FQkpPNlQfkaQRloDOsHZHHSKJStv/j/2HsT6Lqu8773O+cOuBfAvRg4irOmvNYjaceCBFKxWI9p+xInHtombaO0WW1eV1wrDuIMbWI7Tl4bh/XUpE37+lr7dTVpY2dw4zgv8QD5iSAFKrFoO07S2LJFiuIEEvMFcMfz1jkAJYrf/3/FQwIkhv9vLS0vb2zss/e399kXPHef7+fr4qvhezimB+gx2DeFTMeBFCdkaUDVEVPfzADlTNI/cK8hlRfrB9NozaLKZC3Og7k2ooiyRG/miowMzzpBdi+ybOm9jfYpFDcj+z6xt1BtDdpb2f4ATCgJoAkro8AR1Rj7/EfqlZgZ0AZTRKG+ZXHX6NpAxWyvRMYSSz4zXRHV0LH4I9jnD+oz0g4Z2WNIs/DzMmYe9JnNH/tsRPSSdYQ+D9ickG7APsdNdG6PbMe9s9dWdnVZkKIusgjmfZ/ZRhAwpQ7azNlNj/pXAb9vS0G6O2et1+J0i0IIIYQQYuUIw/wvlA8cuy59iBDieY4cO/wRM3sXCkmDpHvPAlVIWljKd6RUqVTwv7G6urDGIg0zM17bUCIqIcTsLO4bUqFYoo/w6ofZ2U5XttgG/rfn/IKPXV8vTsFfrfq6HUS5wECKobPnsEoDjXv79glXFjM17WMf0w3mNQMUJDFjl8uuzJKYep1DvYmfM3zH3eddmUXgWUC8XshcFYCm6MJ53LctW7zKpFbz/bVEq4Tvwc5Or3Po7vZxM6IBitm2zffj6WfwvO7YPu3KKhWc4bWv16tJYk6f8W3nyBpHepPJSXyvMe7cN+Z+8s1vbXVlMTu2+fElfX7W9zn0t0PC5n6/b5wf8zqjmCK5B7uBIoXpW3bu9KoQdl/mwH1pRJ9T6vJr2ci+Y0RVVQD7uCWaIt+PFlC0xZSJousS0JgxpdHmzX5ev03uhx5yPaSiYfsR2v9idgAd0cysH0dMqduvI6SWSdqYwfdgDuintm7xsTDyGTE97deFJRo0vJejz2i0LqyNLubSJb9fzhOl0e7dl11ZWs6Be4WND8Xo0iU8J+i+tETP5OdqDpTF1Ov482fbNq8eWiBKo0KH30tugh/Gd+kGZffI6E/1dQQvySIxlhBCCCGEWBHmzgf2zcdKFhn4V+U6JfjuckuHToQQQgghbi3Pq3V06ESIG2FocPgRqXeEEEIIIQTgaXwEcgOz8+joX+w0C7/5wMA3puutezZ6PIQQQgghbhVPPdYZ3nGgbl3d+M2B9ULrh3sblmvp73AhhBBCiFtIEGS/2fOq0XsVcyFujli9c+TY4fj135NmtlfhFEIIIYQQ8d+IUu204cyhgXdOVKOP8RpmDZKuHakwmCIFpeaPKYD09ew1YDSPSL9jbdJ7IS0L0kEYUWyQ4UE9jZF4sD7nQaalBglGFfTNSOyYIgBcLiELftBCDRMdByhK6AX6FiNzQjUKIGslUyv0keshFQ27XpOMG12zTK5XBeNjawCtOSNWgxzRUqChgCEvtutKrtT3v8DWEbnVUik9UDyYJocUw3EXUSFRkyANjbVZAxkwcFC0WJfMFVpHDLRPgWEslpOxoHXuS5baAOMGBpK2jXSCBYZiH1MlsUB7K9OxoVLw64vlpNPILDJP+obCDIoS8NUwrA2wBBKQCgh99hjRWrF7lal2kEbGlyyClFRIiWQknka0YshOY23GDZqAn5dGPudR3GKmyVjArQaD1NEf2Z6/NhNZdE2+WuZVQo3EpUC1E4B5WrwoWOSGOx1VcRtBh6/7AtXOywvWuh+nNRRCCCGEECtHGBbeWT4w8qsKsRDLy5Fjh99nZiufQYioTBBMp1Iqeb1CNoP/Ec20NROTWIVxvfT1eC1CTAPoaWIujvW4si6itujqxC9wjI35eBQ7sdqiCNQ+TLVz6vRmVxazd88lV8YYu+THVwHaG0ue6eEYFQu+fzvuwPqC089scmWWxNRrBgod4GF7SmUT0jMYUTQg/YQlegUfjzJYy5Y8P8L3yTPP9rqyLZvxWqwu4Hdkenr8NRtEjzE943Uj+TyOZ7OB5xXRB/Q0MbMzPnZjQLFi7Z6xgfuqQfq2dy9e42fO9LuyBaIJ6+7012NPSZk+Zw+415gaJgSSh0IBz8kCWQObN3vtyZmzeI13g3hacgjYFdlMxa/xmC2b/HwzWQVTK6G9ddcOryCx5G9Fv++z71JPEc3UHUBJFRLVzjy4t2OKQMU1O+vvqZj+fn+9eh2vObY/nDnr94dM6J+nxtx150VXdnkca2RmpnGfSyU/vp4er8syoluyZI362BWL+DMQ6em6u/H1UkHiiRRrbN0uSz9SMAb+prBE6ebvickp/PcO0x9VKoX4/v6Tn3/9H76G3DYiZtfR0X/78idOBB2ZwN8JQgghhBBiRaiOB/bsiZ6gFebwX+Zrkbf3tnToRAghhBDiVhOOh5nOfTp0IsTKMDQ4HB88OWBm/lsLIYQQQgixUfh9a/MSuriK73h8tNCTD/6rYiKEEEIIces4N9oVTF7EJ+fXDDtzFv1IT6vV29Lf3UIIIYQQt5AgyP2/va9+YlN5/2OnFHchVo6hweGTQ4PD8SvTn1aYhRBCCCE2JP8uHrRUOyk4fXDgpZPV6Gv1q3ISdZAU8yjdPkpnb22UF3WQRQg0u1Tuf4B+39ooCZCugmkU0Dcn5HIUFI8Q5doidZmKA1RNQCqNqTpuA+kLWNtzRCeAipE2xdrFDrTBxo20Gw2wLozMtRE9EINkh7JOEGemCkExYtoG1jW4RkGREQUW2wPROIzoiMqkLosnmm/SBFRuMZjaogQaZ30DIaKxZ6DqbM3Bm4pcEycVxNdjWhESIhgjBtKvoD2R9c1InLtJH5Byy8hYWJhR/Nl6yZHBIIUV+uyxRAfligwnaYyv59s1sm/4kkXYvoH2Z/aZi0rh/kLWp5Exkqx7sB+zKHBEcRODLGasbgvUNbI2SBOWAzch082xzyoUOxCKhGuL9z200AyjOuhFG+Z8mkwKcmBZshhdEb1RrrkngjeWms1tEWlYCCGEEEKsBIEF9SBTvFcHToS49Rw5dvghMxu+ngvPz/s0/BmiuKmCtPqWpOz3KobLl/HLC5s2eSUBUr3E9Pb6dmNyWa+mOH8eKxe2b/c6lfFxr72xRJcw7cosUSb4Jw25nO+DEc2HJQoDn8y9StQddVDe24tVAC3yoGFsDMcfsW/fmCudnsHp/Wdm8BrYuQNrdRAs/ujZRjYHCuPYVf2cdBa97seSNY6VF1u3TrqyqWmshpme8vcJ0odYG/XNzh3+epW5DldmiYIHJy86dcqrlZhCpBuoNFqkz+MTXksRs22r1zksVPH4+vt8Xab/KJewjqNa8/NaJ4+gpsCcWPLM398Te3fh9Tk25tf51CzWxWzb7PcuIxqYqWk8r51ArzU9g+sWiWZqAcQIKXysjXKr0fBtnD2H9+HNm/3ec/4CnteesldBGZlDtM/FBGA918CY212vu+S1XZ1FXPfZs3jPjsDW09nl58+IYmjXTv/ZE3PmWfxZtW2rX1+o3ZgOoGcqdePxRUSPVgBKt2eIBm337suuzMhnN5pr849qEzZv8nuGJWo5P39GtDPseh3g/imDv1XWIZ8eGhx+i5HvSARhz8jo1/eYhU89MPDlyVrrAK4lhBBCCCGWm6cfLWQ2vyRn5S3+H56rjlJo0f/e1WhlWvpbWwghhBDiFhKGuZHygdFDirkQt4ehweFH4+/vjhw7fNLMXqlpEEIIIYRY93zkygCV8eQGOXNo4CVTtejrC+jVXfImeid5I5u9MZ4Fb5ezt69RVgRcE2cPMdJncLguNeiN7JhZELs8GEcMijN72bhJOo2qZ8mcsD6jt+dZZgxQlb4BTpqAb4az7AB10jaCDBu2nUGBI/E0En+WXQNdj2WqYGsDjRtlf2Ft58F9Zm2yxQSgPmrX2pzsQ/1DJ5RjZkAGBF+yCLu3UaadGpgnSzJV+NZ9ySK95IIoQwfaz4ys8aR/oB8kRHBv9b+9CMqiYSRLBAlRKtj6Al02/E6PWQN1jsSD9hlcjzRL9yNUjNaWkf2P7QOkCSuCIGXRoNtkCkF7TAusLSNjQdltjGQJMXL/sExeaF7RWrY22WlQN7pJG7gFfE+gvymM/A0CihJIN+DaYPs7mqt478p1Rnb3/pkoaF2VT6aTLA5/yBzfPO1YAHcnu9kygQWv646ae+AtI4QQQgghVoggCOthpviDpf2PfVIxFmJ1cOTY4YfN7L+wzkxM+jeI+3rxW8hNki0hk2H/OLs+ZmZwlolGE/+TDvVvmrSR5g3nNOO7eLHXlRnJopGWSsVncujqwhki5uZ8XUveRPfzyrIfLMz7jAuFon8bvh2ojUYTv4meyYB/3yfZTXz5HMkIUl3wT3zrJNNIkWRC6e/zGQbYOkIZJeZIJpVKBWeFKYA38Ddt9ms55hKYv5gdd/gsCs8+izM2oPWcAzGOmZjGmRW2gv6xDCtozW3ZhO+/mVkco+5uv+5mSUaQbNbfl5ZkF/L3Sj6PMyjUar4fLANJNoPHPVPx9cMA960JMhTdc9dFVxYzB/aBxf75uSp24vH1lHH8/+qp7a4sG+I+50F2p5DEorcHZ904e95nOWqlMGFv3eLXYczEhI+FJX3267y/H79AhzItWZIRxMe0Xsf3/Dkwvu5u//tGMqkk/QDpullGlwDsR+MTeO/yrfL+1Rt4Tirkfs13+Djn8369GPncZp/9lQqO8/btN/f5yjIwRSD2RvbLcgnPCcs+hj6XCiSjS63mx50FGd6M78NfGhocfui5Ou7H4rrYdXT0z1964kRQzodPKWJCCCGEELeG+lxgf3msHEwv4HSst41yaK1/UG7o0IkQQgghxK0lCHNf7Xn1n+R16ESI1cXQ4PDH4+98zOwrmhohhBBCiHXJ+64elD+eKVJx7/HRe04fHHjp5Vr0Zy322q8QQgghhFhWnj2Zs4ud5cXsJ/wg/S0heEMpau6Nu9HU39ZCCCGEELeIxSwnncpyIsQqZmhwOH5NeP+LZT8RQgghhBBrjk8vaRafQ6qdZeQb9993crIeJe5KlEqGZDKyHqKrqPlsOlA/YSRtEa7J1RZdIC++L1kEpf1n6htSDLUGDKQFYb/ONBFImcBiP0m0Dbg2BulUqqAP1mYsqDZTPKCmQRcS0Py16weCVUXrCOkZjOgVWIxwKYZpItAaYOsWt4ABzSawfoBb2wo+81VCHVRm10NaipgOMCdIr2Ekzt3kpmqA+9IS/ZErojoidJ+w/pEQGTKZZFBhG90Vqo1r8vsKQZaXoS2GNcvK0f2DVC+WpG1zRXQcoGoCUsawNYfWPtKrsbrG1gCuStcoUmPNogWack7I5SwAv9EkEUUaJrZXkibg3xVM18NUR+geRBogBrseuRwE7c1GPk9IVdv00rqVSj51ZQA2qohs/AFyxS3+xJVcKQrKgbW+r7sZhS22RQkhhBBCiBUgCPNf63nV6CsUWyHWFh987G981cxebm2UCYjJKa/SiCl1+38HIj0NY34eKyWKRa/MoJBU+bMVr2IoFLzOw5KU9uABYPwcq+o1A0i9EnP5Mo5RLu/bXpjH70x0l3wa/hmi/+jtxTHK57xeZqHq0/gb0XEgBZMRXQKDrRemokEUCn4clmhIfBvdJTyvSMuTlNd8OdMRjU94RQPTTzSA4saIAqZRx3XTaBtY3QxQp+y4A6sq8Go2e/r0FlfGNDJ1oFb6jrvPuzJL1oC/L5PyOR9TprgZJ5qVvj6/H6H1EtNR8BqLFlF8dXXhtYj0JBfH8NpHeqDOor/fY6Zm8L7YDep3AI2TJfe8X+NG1CIRWUflsr+vZmZwPLu6fN+MaGSaIG4xdwCd1Le+vdWVWRsFD9ovy0Rbg2IRc+6C1+fce/cFVxYzNe2VMRWgYIrZ1O8VXzHPnu1zZXfdiTVM9bqf1zPP+t+PuWP7tCuzZH/29w9Sy8RUyTpCIB2YEU1RDnxOtWNhwa87ppvLAeVPrer3qJhNm/CcjI31uLItW6ZcWTuQTqiUQgHIuPYzKZdtbXv/mz7zggWD7zBxQ9z7+In92wrhy7NIdCWEEEIIIVaEi1/P2qmvluOnG7fub7C/2dNqvrXTdOhECCGEEOLWEVic5aT7kA6dCLE2ec+DX3yFBfY2TZ8QQgghxNolk2n9q2sPnZgOniw/e0ZG/+zAn5wI+wrhF9fb2IQQQgghViuNObOnRrqDsXP47Y5lY0fOoh8utVrbyCsSQgghhBBiRQjCjj/q+c4/zZcPPDaiCAuxdnnPoS/+9nse/GL8qvenNY1CCCGEEGuLMIxGPvDmz/ws6rRUOyvMX9x/30KtYUluI6pAcCWLgAzzMDW/EdVESL4OmUM+AUKZqGiqPjOXVYi+hWS0hyoMlt4fNZ0l7YKs+pQ0fbMk/q6IgrQSSI1hbRQiaM34Et5n1l+mG0EgzZERPYOROUSql5h5EKM02g0jygukuzCivCDWDSujhsm8lsh9wtYiGjdbG02wBnBNfJ/EdIP4gy4koLXBtFigagJat+x6aciT+xWtUVKV6qRAE0amFawiXNYOtO76yQ1bxZnmIGCqE5DChccIN1IEG9UMWXRoP0Jr2dqs5y5wD86S6/maS4DqeRKkOohRliwY9nkHukzbAOHkA8GXg/erL1kE7QNG9jS2NhBs70qj11oAfTAyFqTfMTKOuwfnomzY8L+A/oixNjdQ4aqI/O3uZqsEcrgKIYQQQoiVI8hMhJnigfL+x04pykKsL44cO7zfzB6NbSDxwGogJb4RfUsCUBVMzXS6MiNaF8b4uFcdxHR3e2VCPo/7hpQEM7NeMRDT34fT7V+40OvKtm7F+oKAaEiQTmhmFqsYUBLRuTk8J/39OJ7T036M5bJXvViix/DxZDAFTz7ntQb1ho+9tVHDhGDcvT1YpVEF2iCmzCgUsP4DwRQwUyCeHR14zTGVBlqLzxI9Rl+/18UY0QaxcZdKfr47O31ZTAMofJLrAc1UrY7rzkz7NZ4HiqmYQhHHDmmYtm/DeqCxS3h/aID+bdqE75MLF7xCaedOfL3JSbynzc+jteiKEnbtGndlU0RJFRJdGWp7ctKvz5htW/BavDDmx50DGqCYHqDzevYsjv3e3VizMgW0Lt3dXuFjRF10edzrSmLu2jvmymKaICny+fO4z9kcHjfapyJcFerRmG6OadqQ+ot9JiF9C3kEnOozNy3oM5rtt+gz+iJQ2Vii6/H3Sczp05tdGdJlxZRL/nOtWMRrbmYW39tIp1Yo4uux+V5Y8PtDfx/+XMtk8H7ZhqmhwWH/B8oSfkWJZeWvP36i8MyhgXdN1qKPWOq5E0IIIYQQN8JTxzqDjv7I9r1kNoJPI9Pw1wrWOhDXJ09EhBBCCCHEihBmir9YPnD85xRdIdYnQ4PDJ+Pv+I8cO/w+M3uvplkIIYQQYlWzv13n/BEusezsPjr60ZefOBGUcuF5RVcIIYQQ4tZQHQ/sfx0tBegNoeshKAcWvaOrvnjoRAghhBBC3CqCsONrvd95MtChEyE2BkODw/HBk77A7OuaciGEEEKIVcn3DQ0OP92uY1Lt3GJOHxx46WQ9+mqtGT136KeTpHZHaeoDoC8wooQAWecTGmTOiTkAA+rihD5cj4E0JEUWC9Bnlt6/TgZeAEFi2iHQtQSUIghpA4yoLUBRAimG9dPogdAaMqKDMKIsYUoj0rT1gjgzHQcCKUiMaDcspbamBuqydtP0makf0BowEjum9kEqjQKp2yBZlUhIIcj2AsKWUCE/6Ab9Q/e7ES2PkdR9VEOSAtA1Spo9kdwmVLOCPnvJdkTtH2BpUC0SKmXzx/YYdG+yviFNG9PTML0Wgql2WBNZsC+yzyQUD7ZemiAWRrRibI2Dy1mODYSQSm1GYocWR5H0A8bIlfB2jXzOo7VlbP8Dv2/J/eDrGvhs3DcwHZmBnJV2jVIn5s2lerOX5HkWQgghhBArQmBhI8x23SOtjhAblyPHDj9kZsPLHYAG0K9kszh1PWMWpMXv7sZqknR9w8k1s1n/sG+S6DEKHVgzEGb8v5fTqIuYtibHYkd0DogzZza5UqYmYUqPO+7Aig0Emj9LNAhe6cE0Mki1UySKhzmgObJEV+FVR7mcn2tLFEO+z0xd1NmJ57XUjWOKePrpLaA0jvOUK2Prdrbix7d5E1ZEIZ1UAgh/Po/X3CTQqRQLOBblElZeoL3g7Hnct51kzbWa/qFjnmiRZoFaCSlWYhaAUiemVvPxr4M+WBJ/vwaapO6mfqzjeOaZflfW0+u1Ikl5Ce+L5y96xUmR6I8KIHYdZJ9D92XM6Wf8HrN1K9bIINXYOaBEsmR8eB1VwZxkwB5s7PsPM9uy2fev1cJzFYZ+32D3CdvLkR6tQnRsO3f6tZ8J8YPdFi62U894bc3OHVgzVavheQ3JNRFI83XuHFaNpfk8uXgR7w9bt+KxIM6TPWb7dt9GDSiRrM18pwHdP0Tp9sNDg8Mfd6XXgFerWDH2jIx+/RUnTmS2FMMhRVkIIYQQ4tbx9Gg5GDtdjh9gkH/eLWp1mn+3YDp0IoQQQghxa8lkiv++9zu/nNOhEyE2NkODw48ODQ7H38B+dKPHQgghhBBiFXBdh05MB09uH3uPjv6b7/zTJ4KefPjURo2BEEIIIcStZv5caKcf7w1mZ7pecOWgO7To7V31ZltLpRBCCCGEWG7CsONrfYtanX+m4AohrjA0OPxIrN8xs68oKEIIIYQQt4XrPnRiUu2sHv7svvsatVb0gjxMKJU/S/uPUo+xd3mRcobBVDTAXkApkU6P13zbJLs/PCFFdQJABWBE5+BLFiFNw7T/oCgBFbN2WRtgCdC6qG2mJCAhgsqmKrlgjiwCEGarkgt2gQtOkTUHqi71zxVZH/LFEE0HrmlWJOsWKWOYQoRpitC2i+JmQBNhRIdjZH0aWYt50K4RPRDrG6hKYfPHmkBLBhQloKkiU0JBU8U0OS0wcJbQDLeA+8yux+4fVEqqwjlkc8LaQDFF7RoZHwhbAlmKsB+sDaa7Qpob1kYJBGQCfE5Zm3EjUCyMxJP1jV0PdJnqlshQzD/obiAAACAASURBVCeAxHo7I/u+L1mEfXaALZSOG8UOxc3axAjdKJlrbvg7769E2e/vjBrlOtoKhBBCCCHEChEE2Ykw03lAGU6EEC/G+z/3Nw+2WuEfRVHwgjcIymWshLhZLl0uwxaQLqRSwTqVrk6gYiAamjpJuJkDSpzz57EigPxTPpU6oF73qfxzOfzUi2lWkB5oORi75BUdMRF40FDsxH1myplvA73MNqLjGBvzqqN8Ho+ZTIktLPj5DsjayIF4MjUJU6cg3VIdKEFi5kHfkraBBqa7C2tP7tju1xyKcUxPj9dgxIxPeP3H3t2+XSP3CbteuYSv1wQqk0ol78qsjcanCFRHU0QRhRQ1jYbvQ8zMNN5j+vq9zmZ83KuZYrIZf6Og/sZ0FvG8PnvOa0EKedxGg6zFO/eNuTKk3Er6B/qB1nJMXy/+LEDqqDrZu6Dmiyi35ub8XsnaLnWDzwIyPiPqlGoVr0WkertAFDDFgm/XknWO73kE+jwZG8N7cwe5HlK9TUx0ubKYTNavWyP3MfvsQZ9VhQKeEwbSYIVAzWTJ/u7nqkB0bGzPzoD7dW4O7wNIJbQcXNHvBIH9vZ996I//e5om8ajELedlJ05kNxfCn6BfnAghhBBCiGUl/rtr5mRpKOov3hVYxv9rTQghhBBCLDuBhY1stvSO3lf/ab8OnQghrof3vuGzI+9/02e6w7D1bgVMCCGEEGJlCQIbSHvoxJTxZHXyzQcGvnS52vou9KavP+e0SCd42xtld7A2bwXnwQ8a5DVk9GY+W0soI0W7fiBQLNCb1+2ogNfn2VvyKOuDkbeyu1Dn4tON4HrsjXMWC9I9CAo/micjb7hbm4wZiBxpG2WDYFMVgh+w7A7stXpwuVRxY5dD99Riff8LJEmLFUmM0Poil4PrvAH6kECK0VyBooQ6uF8j0jDaM4zca7gmz86AMlXgmnTYEJbpBcV/muyhaWAZn+ZAjEhVuoeitlHsE0BxN/h9azNuFCOWVQldj2WjypEjsKg6ypIUM0NuQnQP5skGOA3aYMNrkTnJg19Ac20kdi2w7q1Nlg80heh+j6mBfcfIm0FZ0DcjGVbI8OjfKwi0rxrZ/3zJIixLSwb8xpW/bfo6wi/edXz0dVf/bObkobc3G5XfiKIWfnVBCCGEEELcFJls57+XUkcIcbMcOXY4Tvn+Q6s5kJNTIDNGFr8B3tmF31i+fLnkyvr7wVv5yfPXNP8Sx6DMA7t2XXZl7Zif73A/LRbTvV2OYBlPtmyecmWnTm92ZTF791xyZTFz8z4rRZG8Ef/MGZ9xZs9uHCP0pr0lMfJvrheLeA2gTBUsc04amk3ct/MXcJxRtoT+PpwVZmLKZy+ozPp1YUmGCPxgcO9uP1cs28X0tL/XWDakSsXPtSXP5Hw/2PM/xiTIblLo8HGzZA34LBOdJIMMypBjyRj9munu8plUYs6BbCW7dvnsFTEXLuCMT7Waf1S2eROO85lz/j6J2Q4yCY2P+7jF7Njh+zc2hvuWI1mHtm7x+wOjBjJPjV/2aytm2zbc7unT/a5s716/li3JXuXnxEgmja1b8fXOgQxYGfD71iYWp077fX8rmCdL7jW/d+Vy+Hpd5HOto8Ovc/R5ya5nyXdb/ubctWvclTFmZv0eZW2yYiHSfCalBmTaicAzbmvz2Z8m8wpg6uy5vld+6K2/c0MvCPjdVNx27jk++tqBLz8R9OTDpzQbQgghhBDLRykfnn/1l58Irj10ElPaf/STvd/5ZC7+QkQhF0IIIYRYPsJMx9f6XvOVQIdOhBDLwdDg8MPx+wRm9hUFVAghhBBiWfjS0OBw740eOjEdPFnd3HN89J5X/+kTQWcumNzosRBCCCGEuBmKWau88k9OBN/x+OgdL9ZM/IVI/MVI/AWJ+6EQQgghhLhugjA7mcmV9/W86sQrFDUhxHIyNDg8OTQ4vN/MDsRv5yq4QgghhBA3zA8PDQ4/dLPhk2pnjXD64MBLp+rRV6IIW1JQCn2SbR+mrjeiA2AqGqRzQCn/rY0iAClqFkC71ia1PoJdD1wO2SDaXo+1jUAaDKaaYKDwAxtEAlIgMI0J6wYsx03ANWdEfdNBjrhlwVrESdE4KEZwHEQxhBNRxXoT3AjSyzAlFWsbVUfjYIBfp32zRJ/jf6NA6iLdEusbux9AE+YT8S3VJW2jsdTYxPqqVJXEFGSkOgQpUsgSp6TZb0mX4ToAYUsAl6P3MNpLjOw9pCrumytZaoM0gj6rkILJ2miDKix4AFSV9ZlBQgqBa5yMj/UD1UZl1qZvKHQoFpb02RXRukhzZEQ1ViRrH/1NAIoSQNcSWot6pVZ/Pty/d2T0hg+RTP7pqyeiVh3nwBRCCCGEEI7AwkaYK91T3v/YDb8tJ4QQafjAF777gVYr+OOurnmcs38ZmKv4tP9Mk4OogN+3NkqCNIyPYwVFf/+0K0tDo4Gf6mWJNgiBVCgxxU4/7hxpd2YGqxGa4OFiR77uymIyGfzk+dmzXlexeTNWLlSrPh61GnrqbFYDdWN6er0OZQpoWowoLy5c9AomSxQPuM/d3XOu7Omnt7iymFIJK4Ymp33/St1+/mJ6yv564+N4Ddxxh9epGNFYMIUFUkpMTOD1ks3hJ/ZoLJfHcRuVOX+9mHvuvOjKJqdxG0hT1Gzip1t1oICxJEY+pvkcXuM9vX5OCkB5Ym0UUeg+2U6UMxcu+vmzREvltTNTJEZofJs34TU+P4djhNbX2bNeh2NEddTbg1VCzzzj9TQxDTCHu4nS6OxZ/JgRtXHHdhxnpDFjqjGk8LFkf/BtFIs+FpYo2/1+m0E6sHgtkn0YMT6B9zR0n8RcHPPri6mEzgMd0fbteE4uXsRzsnXrzeWGuHQJfz5v3nxzn89GlHwxmzb52DGlUU95bqrVsjt/6sEv4MCkBH/yiVXHnpHRr8fzdebQwPdM1qJPg+9thBBCCCHEEmFotqUj/Ol9I6O/fLMx6X31n/ZNn3xwb6s5d1IHUIQQQgghOEEQNjLZ7h+IFYa0khBCrAA/97o/PB5/f3zk2OFYw/NfFGMhhBBCCE4mE/3qTx78wjtphRvAH50Sq5pdR0f/58tOnAj6O4J3kZeJhRBCCCE2LPGBk63F4D2v/pMnguU4dHKF+G3d+ABKNld+R/yFiqsghBBCCLHByWRL7+r9zpM5HToRQtxOhgaHPz40OBw/Of9hTYQQQgghxAsJA3sql21uff8bP7Osh05Mqp21z6mD9/3kpWr0QZT8iqW/ZyDNA1LqGFEgtEiCf9IEqY1B6gekabE2ehOmlUDglnFM2QEgdKqLqW+YXgF1GRTRukynwnQVYAnAMRuZEyNjZG0gxcMcqQyyeCWgYrbmsmBS6DpCASUXzIExG1HcWLIWXZHlQN+MzOEMiRGomoC6gebaSOzQPBlRhRjRyJCqdB2heUGKDkYe/L4laxG3gUKKlDrWZl7TgFpAe7C12bsCsBjZXoKaroN12A7UBuszUqSwb+nJ8OCaYfoWpIgysh+x/S8C8QjIfUmagBPbQW6gNBogpo5CLaAya6OqyoAx4pr4viJdg2omI2sDqfeMxIhdL57q+L/+jvAn9hwd/ZCrsALMnDz09mZj9jeiqKUMgkIIIYTY0GSyXb9ePnD8/9jocRBCrE6OHDv8cTP7oVvduTpQ1DCNDOPyZZ+ef9Omm0/NX6/7vlmStcr/O/zyOE7jv42oBxYWOlzZxESnK4spFL2KYX4eKzM6O31dS3QOXi2SCX1ZTAdRiyDFCZo/S/Q5XrMyW/FlMTvuGHdllqgffCLVeh19w4PVMH09XptiSTy9MsMSPZCP6YULXlUR081UO0AFdMd2vBaDwPe5UMCxZyqnM2e8HmMnUZbUwPgujmGlxLYtXj8Rc/6iv9d6gRKpHdNTXqUVEL0JWs+VWbyO9u31epqYeXCvzS/4WBi5t5lO5fw5vDa2A90Lmz+kd4q5BPa0OlFVZbN+HW0hOhWml9kGVFXsyecCuLeZaudZouvpA0ojpAyK2bsHzytSwyws4Djv2zfmyphOhY1lYtLXB4+AE9BcId2ZLWbScGUxxYJf+2y9MPVNV5ffp7q68P3aAvs70w4ZuE+MzMmmzWhtxVo4v1cyZVCthu/XNJqiNG1cUdaFYet73vuGz/6+q7BM+IiLNcXekRO/Er/R29MRfk4zJ4QQQoiNSF9H+IX9TzwR3KpDJzHxm7zxG73KgCKEEEKIjUp84KTvNV8NdOhECLGaGRocfngpA8onNFFCCCGE2IiEYetj73/TZ4KVPHQSg49JiTXHnSOjb4z7/O2DA388VW29QTMohBBCiPVOfz784l3HR193O4e5lEr+k0kGlPrsb0TW1N/XQgghhFjXZLLdynAihFhzxAdQzOzh25UBRQghhBDiNvCJpb+BbglS7axTvvnAwKPT9dZr0ehAlvsEZCrIk5w4qA2cUAkrLIwoGpguoQjqzqNOtOmHT8yFx2xtUvmTS0JYGwiSwcmyoBGkKWCkmT9WztpooIASnY0fxdL1SBsI9io5UtSgcRiZb/T7rK6RRGysLpi+1G0gBQVb+2QocAKQgoRUtVlyE+dRZTJXTJHC1DdIA4OUIEa0JyyeoNkEtg4QKPxMGYT6ZiRdXZV0jmlWkNKIVIVrjtVloUDqFLA86fVQmRGdlJE5JCGifcZtgELyWYV+39rEDkwJVAaxttPEk5WTJmDf2DXZmkN7ARsfL/c/aKBgEK6ozXrywR/tHRl9M651e9EBFCGEEEKsV3TgRAixnliuAyhRhJ9KNBq+PJdDT81WlvEJr8phaf8vjnnFxlaithgf98qMpO1+rF+5WZg+ohvoFbJZrNq5fNnHIqbR9PoIphJCLCx4RYe10csg1c72bTjO9IsDQL2OlQtnnvXX6+/Hagum/OkGaou5Oa96MbIG5ipeQ2OJcsa3G3Pxkl9fXZ04nhMTXm2B9EmLffPrxZK14XVQhQK+X6tAN2KJnslfcxOJc7HDazCCED/5ZPM6N+fL8x147VeBqqVGxtEgsbsTaF3m5/G85nJ+fEbGwlRcRTDfWaJvaTT988aYnlLFlZ0957UpMX19fm2wWBQLeN3OzvqxhBk8r5Ng3Vry97avv3vXZVfGOHNmE/zJLtLGhQt+f+gFyiBL5qrLlVWreB3tJYqoSsWPm2lyLMLzipibx/sR2p9zOXKfkHsCPeculXCf0fdBefbZn2J/Z6B42vMxvaUHTq7gdxuxLrjn+OhDtpgB5XMT1dbrNatCCCGEWOus5gMnV3hhBpSZ34ispb+3hRBCCLGm0YETIcR6RBlQhBBCCLHeCEL7naHB4bfermHpQfg6586R0TfcqQMoQgghhFjD9K0CpU5adABFCCGEEGsdHTgRQmwEdABFCCGEEGud+MDJz7/us7ftwMkVpNrZYDxzaOCRCwutDyPFCUoXlAaUrt+IvsCIeoOpdlDbTEtBDAFQSUAuR2H6AQQaSx4oBmJqy3Afoq6hebY2WhEUU9Ruu/IsGCNSghiJZ53EgjQBFRugC7QNME1tKYHFiBQklqTVwj9AcWaA24QCupZQA9dj7aI2kBrDlkn7xEB9RnquGJQYrUVij9ploFgY0b0wXQxb+2gsaM8wsnfFlIDfp0IWI9qHQRfaApqg90+atlndFgh0B5kUthZRMdKBGRkLuRwlBKIbtr/7mvy+zJB7sA46jcZsbeKMYONGywt0IYGNJQ9+0CQxirU6vfngkd1HRz/qfrgG0QEUIYQQQqwVdOBECLGRiQ+gLCx0wAMoBaJXQNRqXimRz2P9xHIwM+MVCJboALxqgoFS9nd0eN2FtdHZIPXQxCTuG1P+pGHsktcD1Yj6gellZma8omHTpllXZkThshwahbk5rCzp7FxwZfU6fqyA+mZJjLxiKEP0HzvumHBlMc+e7Xdl5bLvm9FnXvh6nV24jfPnvQ6lXsfj6+31bbB1z5RNuayfw3zel8XMEm0QYmHe7wMxhaLfC/JE/1Gp+PVpRO3TIsqZFlCWdHb6PlibOLO1gahW8bjR/hCBvsUUi35eT53a7MpiurrxPlWZ9ZqVUgnXnZvz91VnF45Rq4X7jJRU7L6s1vz1YupA97Jt2/WrvxhMj1Yq+30R3Q8xU9N+L+8pp7vXSt3+emw/YiCFXBji/RbNVbnk+2BtvlfMZPy9eekyjidqYtMmrx9LS72B18vSXN0WpQ4D91SsW3YfHf3IbrOPPH1w4D2Xqq1fZgcThBBCCCFuB/HZlP6O8Cf2HB390HqagCsZUKaffPBgqzn7B1Gr7p+OCSGEEELcJoIgbGRy5R9Y+ptFCCE2LFcyoPzS8Jv+WRQFv6aVIIQQQojVRmD2T4cGh//jqusXeyNfbAxOHxx46VQ9+kqtGcEzZeytZ/SGMzsNlubta1YXZUeZR51oA7pejnSaZSkooEZwVXi0rZayz2jcVdIGeoucXQ9lPzASo7Sg0IGuJXSAH7A+50BdI2/8s7r+rKhZBXW4TQYLtGTmSRssnrg2Bt2DbN2yzAogRDAWSdug0yybhK+5CAodW3Mgacdi/8AY0R5lZM2g+4HVNXKvsT0mTV1SjNcXKEogbaD5RuuFNc1iNEMmC+1/+Lw23kPhmMk4ElAxboLC4o8Aw4Nr2cg+Z6QNUJSAwsziCW6HhDq4KVifGWg9+zPci6BMQiwWrBxc7rm45cOgWc4Fr9wzMvp1V2kdMn3ywb2txuxXdABFCCGEELcTHTgRQoj2HDl2OD6I8l/aVrpO2BvgvT04u8bCgn9bv9CB38Bn2TXQm+HLkWnk3DmfkSJm+/YpVxaQbBcI1F9r02dUv1jAMarM+XjGbAZvoy8skCwTINtIrYaf6HR3++wHRjIgzJPMGLOzvh9791x2ZZaMD2fiaDb9k+ByGa85xpkzPuPJli14Tup1P5Y5Evt8B86sgO6JM2c2ubKYXbt8PFDGIUuya7iihA5wX9VIRopLl/2ai+nv9VkUyOXgGujunndlMWNj+LHR5s0+/ufP47pd3X585ZKPsbXJjJEBWY5KXbjPIfy2EWfMQM8KjWStOUv2nQbI/mLkuWypjO/LbjAWlKHFkixOna4spq/X95mtxS5wPSPZfrIkG04JrBl0v8c0mng9Fws+s8zFi3gN7Nw57sqeeQbfl7t3+/uSMT/v97mYBZI5p6/Xr112v7LMRWlAGcW6On3src3aR7C1sVD1+2XzqmxG2Uz0k+9/02eOuEqrBDwTYsOw9OVONj6AMlGLvlprkZ1UCCGEEGIF2GgHTq5Q3v/YqfhZSvx/p778mj9rNeZf6ioJIYQQQqwQQZibCrPdr1z6m0QIIQRhaHD442b28SPHDu83s0djswCuKYQQQgix/ARmc5ls683vf+MfPLbaw6uDJyIh/rJnz1IShL+4/76p2XqEj7QJIYQQQiwD3blg6q8/fqJXsTTredUTL4v/d/rJ+/9Hsz77DldBCCGEEGKZCLPFrwdh4W/pwIkQQqRjaHD4ZPzywJFjh/eZ2e+Z2SsVQiGEEEKsFIHZN8Ow9fAvvOmzI2slyFLtCMq3Hhj44mS9dRj9HKXQZ0qDLuQeIIoTVncBNO5LFmH6CKbYQDD9RxVkSSJdxroX0oUG6VsLNAGKFq8HXAwtckGkMTGm8QFF1kZ7guIBpjoBaUGyKG5tdC85kKMnQ6KElB55Eos6qGtkLEhBYkn6MlCZzCvSDhnR+JCqZNS4z6TLsB9Im2Jk/oysDbS0jMyfkbGEZK7Q2mDjI9OKL0hIYzJhl0PDRnFrC2gcTB8tB7++WE5+gNY53DPIfYX28Xb9AJeziAQpTcI8tubSrH2kpzESD6TUMTI+cjkK6gb7DET3iZF5BUUJaD9isSDFVm1G1lsIP3fnyOgb3Q/Fc0w/+cAHWo3Kz0RRC+fHFEIIIYRISSbX/VvlA4//HcVNCCGWhyPHDscvUsTZUL53VYc08v9An5rBmoiestdEMOaI1qWz02sbGGfPeX0Le1C0444JV5ZAFEOIZ8+C68X6iB1eH4HiFnMa6F527wK/n6iVcJzBYzOoljGiWUGalkVwLPIdXtNRqXiVQ0yGaCIaDf94gqmEmBYJUakUQSnWkDClx44dfm1MTDKtldfhxExP+7nq7/cKppinn97iymL27RtzZUxbg/QfEVlzC1WcPyAH9CtTU/i+3LvnkiurAp2HtVGFzM76tqsLuG/9/XgvuXDBxyOdksX3IaZYvP59B61lS/YHr7jZvs2rw4zopGImJ33/dpH9gVGp+DbYXnLHdr/2a6RvMzP4Xms2/Lpj406z3164gN817ANrY5Koi7ZuIf0AIDWdJfH0Gp9cHq/xcjfeH9C42T48DT5fkRroOvi0mT08NDg8eSO/fDvBu4IQZnbX8dG/Ef/v6UMD7x6vtv4N+D5NCCGEEOJFCUOzUjb4sZ1HT/yaovXilA8c/zkz+7mZk4fe3mxU/q+oVfdPmoQQQgghXoQgCJthtvTu8oGRj7WvKYQQIi1LXwa9xRYPoTxiZh9WEIUQQghxE7x/aHD4fWs5gDp4Il6UPUdHP7TH7EOnDw68dLoefbnWivDRMSGEEEKIq8hngoVixg7sPDr6l4pLekr7j37SzOL/bOrLr/l6szH3kjU2BCGEEELcBoIwP5XJdr9SOh0hhLg1DA0Of8TMPnLk2OH9ZvZonDxEoRdCCCHEdRCndnnL0ODwo+shWFLtiBviqQcGnhyvtfZf/bssvT9T3KDauCbWdCA9gLXRCSC9Amq3Hag6awNpg5BeyNpoDZD6oUnu2TouhhRAu0ZUGKCobZ9RMbkcVFCQqlAlZESJQ8IM+8HGlwd1jSg9wNJKYNogtO8GZHwtUBfFLaZIJgXpMdj9yu6fm4VcjgO6kSGBRvcJGwcJEdTckCagYggUJSA9l5E1Q6rCvcvI2mV9zoM2WF1WjvrB6qI9hs0JqJqAbgnQhcV+uJJF0L6B7gcGWy9pbhP0WZD0A0wgqWp1tjhSwD4z0Wc00+egzwgWi/588NV7Hz8h3/UKMP3kA7/eqE//03U3MCGEEELcNJls55/3vOqJlyqSQghxe/mFz3/35s7Ohc+b2U39uxjpHHK5uitLS7Xq243p6PBtX7yIdQlMgVBr+Hed88vQ5yjCT4WC4PofmrSQ/zzJ0uofbjAdx6VLXhWyHegu2oEUQzvuwDqOVtP3+ew5rwSJ6equuTLWRqmM1SRsrlD8L10uubKYLZvB2iAamXPn8frKZv28NsE4Yso9XvkzftnrLmKKnThGm/q9Hii11gWMkY2vUPRxLnSgbx749ZDyZ9s2Pw7WBlPtsLWP9EeMixfx2bveXq8yqdX8nhFTmfOKlG1b01lHTp/e7Mr2AO2QkX0R7YlG7gdLFE9drqzU7WMfM3YJ3z9oLbJ+nAHqr127rl9dZMka9fsJU+3Mz/k109mFx8dIs/8xxid87JjiC81Vms+NFeYrZvbQWtTptAPf0UK8CHcfHz1wt5mdOnTf0OUF+xV2GEIIIYQQG4P4cNjmjvCn9o2MflBTvnKUDxz/UTP70VjD02hU/lPUqvmnXkIIIYTYMMQ6nUy2LJ2OEEKsIn7+9X8Yf7OZvLR55NjhOGX+ezU/QgghhFgPOp126OCJuCn2Hj1xZK/ZkdMHB15WbUWPzjXMH7ETQgghxLqllA9mujLBwb0jo1/TLN86rtHw/HmzMffXN8jQhRBCCJG8nd1xMcx23SedjhBCrG6Wvlx6nzQ8QgghxIZlaim7ycn1HgCpdsSyc+rgwH+dqUd//0r6/QZZYw2QzYhk94eAjP9t20DFpAnLocpEm4G0G0Z0KEzfUgN1rc1YEKzPiAzQTxjRKDDlAtJEGJkX0gTUSqDfN6JTMdJnUJSAlBdMuwGmeqkfrohqjsDlFuuDxpGaxMj40q4jBBqHkXGj/lpKdQeuyecVXbIO2jVyH5OqdC2iYlRm5N5OEwvWP9Y3MlWwPuqbkTizeDINE6JK2kC3FQkRLUdtoDJrsw+jrY61kQeV0f2XFhbONE2nWV+gKAHtfzFV8BmNPp/tmr0nDAPryQe/uW9k9AdcRXHbSLKg1Kd+M4paOC+qEEIIIdY82Vz5PyxlQBNCCLFGOXLs8MfN7IduRe+RNqPVYk+bPPk8Vjwg1UFMB6jfIv9EXVjw70X39HgVhyU6Dq/BYG2gMVuiIcH6CKRdmJ3FqhakOoqAYiWmSvpcq/o+byHqogZQF2WzWMmykly67JOt9pK5Qv2bnOp2ZUndDBZod3d7rcvCgtd8xBQKXp/D5o9pXfr7p10ZUucYUcAYUXrUG74sKa/5NVoF6yJm5w6scro0Du5B/5gvIZPxP9i0CYy5jSYnl/dz1c00MmOgb4nyx98/fb2zroyB1qG10dnMzvq56uz0fbBkrnz8iwWvcTKyD6SFrdECuGY262NvidrH31csnjMzXgMUU6n4+6qnx99/RpRNDDa+7m6/b8zNYa0VeFy/2A8Qo8vjPhaWrHOs4LlZUOwNx/8TZvbIetPptMPfSULcJHtHRv+Bmf2DM4cGXjLfiEanG4bvQCGEEEKsKTpzQaUrG9y36+jon2vmVh/XZEH5erMx+5KNHhMhhBBiPRCEHdOZbOkVym4ihBDrg6HB4YfN7OEjxw4/ZGa/pywoQgghxLohPkn4lqHB4Uc34pTq4IlYMZa+lEqONn774MBvTtVaf5e9aS6EEEKI1UkmNOvLhb9z9/HRt2qK1g49r3ripXYlC0pt6jcjI698CSGEEGJVEli2mcl1/ydlNxFCiPXL0pdSvUeOHe41s4/cqiwoQgghhFheMhn7TJyUYSNlN0FItSNuKacPDrys0oxGZusRzolFQJoIpkjJ4exlUD/gW12E6SqQzoFUpToHBNMotMD9iWvGaaf8T5CGwUgsjCghWN00kOHBcnY9n/CQ10fjYKDfb9cGqs/qMlAbDNQ2WeJ03aI2UOyNaHXyYG7CuQAAIABJREFU5II1UJeB+mBtVE5M4YJATbBYMNC9nWZ8DNSutVnPCBJ+uI7yZGLRXsD6liZ2TBE1BzZAdr00sQDDSGAxQhsmKEpA38j7xKCLsFO7qD5TFzXAYFgsWJyXQwWEmrii4urKBePFTPCgspusH6a+fN9oszFz30aPgxBCCLGaCTPFU2Gm67XKbiKEEBuTI8cO71/KgrJ3ft5rIopFrxhoC9CF1Or4ycZsxesO+vuwpoDpbJgSAoH0Cs0mbpcpS1j/VgNM6zK/4Oe1p1xxZUaURkWglmlXboF/+HP2bL8ri+ku4fWFlDidnVi7MXbJJ/BpkvnL5ny7MZuBBuYy0awwZcxKwRQbEVBYQYVP/KL201tc2fZteC0zvQlaG1WgnrLkvvL7QLkHz3Wjju/BMOOfXFZmvaYlpq8fq1rqdR8jpMNJ+gfWInqOae3un3G/ZjrJHloA5ZVK0ZVZG10ZbsPvczGzMzh2HQV/T2zZjFVcSJ8zPYPjuXPHuCtjpNHkpAXpktD9vtqZXop9YFYJw9ab3vuGz46suUGsEHgXEmKF2DMy+mdXUgeeOnTf0MSCfbDOJIhCCCGEuKXkLLBNheDHdx8d/Ygiv/7oedWJgXhQ008+eLDZmPlsFC34f+0JIYQQ4pazmN2k593lAyMfU/SFEGJjMzQ4fNLM9sVB+MUvvvlIFNlPbPSYCCGEEKuJMIj+7fve+Af/XJPiUcYTsSr4xv33nZysR69kJ6HgG/gpj6ugt+1ZRgNUl/WDZStZAG/8k5fWLQ+ylST9A/cnO9WJwOcu+Vv1aNysLiMH2mBdRuUgbAmg2cVy8IMW6XQGBIRdjwGaoNlDUBYaS7KK+IuytQGWAFyHdlWWAteGK+FtIEjXaOxQhpS09xqCNAFh7bJ+sPgjwPTRU5woAwa7HgjbYhvgekb2niZaMKTPOdQJkh3FSNYNVhct/QxZSQ3WZ1eCx2Ft7kFUztYAogs1QPZmIxmDQNgS0FjYGgDNUtD9t9g27siVsfTmgq/c+/iJ/a6CWPdMP/nArzfrMz8iFY8QQghx68lkez7X86rRNyr0Qggh2rGk4omzoLy2TbWbhr3dj+jqwhkNENMzOENEd6fPUhBmwAMT8mZ/TC5Xd2ULVZxJoFjw2QhiOjp8G7VazpXF5PO+7nIwO4tjj/pWJxlr4ENgklUk7ThQ/EslP38xZ874bCosQ8SePZdcWczCgp/Dy5fxOtq502dyuDjms67E9PbgjA3oWeZsBWeO6OuddWVG7p809wnj1OnN8Ce7wLgzICuJkSw0bBwsa1EU+Tk8f963G1PsxOtrYd7fVyyb0e5dl11ZWi5e7HW/0dmJ94EKmO/ublx3OeZ1jKzRDNgD2fWmpvx9uXUrtrxUqz72RvaYGZLxpACyKuWy7BuQm4f1o7QMmVcQ9TqO0ZXPlMCibwRh9D3vff1n/9JVEs9BPqGEuLVc+bLrzKGBl8w1o6OVWtSnKRBCCCFWjmLWKn2Z8P6lbGRig1I+cPxHzSz+b1HFU5+WikcIIYRYQcJM51iY7XqNVDpCCCGul6HB4fibxIds8RDKQ0uHUPC3lkIIIYRYJqKZTND8wZ9/wx/+viJ6fejgiVhV7Do6+uex+i7u0zOHBt4yVYs+VW9GegNXCCGEWAZyWWuWssFP7D46+lHFU1zLcyqekw/ubTVmn2g15710WAghhBCpCcJcNZPr+Yfl/Ud/S9ETQghxMwwNDj8aJ26wxUMoj5jZhxVQIYQQYjmJfvpnXvu5X1ZI0yPVjlgTnDo48G9ma9GP16PouaRndbJ0cWIuDGkC6k1iOoB2AWlTjOgVSFVKFjTC1BZ5ULdB6jJ1RxqQdsOSefGN51CuOqKrIF2mGhm2DhCoF0wXw8iBfrA+p1WZQEBVnDAPrzkG6wKKM4sxqJqA1hery8aCYCclkUKpShpOEyOkjTISD3T/WZu5RtUbKfuMmmZ1Uf9a4P6zNioa0ARs18i+SKrS/TbN/scATVAVF9mmIGzcqH9sj0E6KNI1ej2kdEMKpvjXuzL2q3cdP/FO90MhXoTpk4fe0axN/T9RVPc5R4UQQghBCYJsM5Mr/evygeP/ktURQgghloN3//b3791xx8SPm9m7bqY5pHDJ5bBGYXyi5Mpi+vtmXBljatprIgodXuUQ05HH/bDAPxthzFUK8CedXQuuLI1qZ24Ot1sD8bRkjL6NLNFVLCz4f4oXiDLo4kWcBKenx2s6mLqDcfac1+fkyZxs3jTtypjmg6ktKnNetRORB2dI69JTxhqgc+dwov0ArKNsFl9w8ya8xi+PexXQJlIX0Wr6Z3oxz571sY/ZvduraObn/XpZxLc9PY3rMi1Sb6/XmxSLeC3WyLzmgRqLrY05MJZyCa/bypzXHC227d9pR3NtyZrxbTeJBigH9gFL9Ey+H62Wj721UR2dP+/X6PbtE67MyP4wNYX3o23bplzZSlKr4f0P7RvNJo4zU0c1gC28ShRrKfe6T5jZI0tZxsQNgmdeiFXG3pHRnzCz+D97+uDAf5uuRz9Av80TQgghNjjxYZNSLvijfSOjb97osRA3x9Kb2cnb2dNPPvCLzfrUT0cR+BeeEEIIIRKy+b5PlQ+Mvl3REEIIcav40Ft/J9a3xdlPHjly7HCcDeXjZva9mgAhhBCiLV8ys7fosMnyoYMnYs2xb2T0B80s/s++cf99J6cb0SvBS+ZCCCHEhiLO/tOTtSf2HT9xn2ZerARLb2wnb23rEIoQQgjxPJlc3+d7XjX6BoVECCHE7Wbpy7O32KKKZ9/SIZTXamKEEEKIhK8sHTZ5WuFYfqTaEeuGbzww8NRkrXVXmkMowEiQQG8LUJ/pOFATLEkLK0d2BTY+VJfB2kAgHYS10VJkQJCQfsfIuNmcsOsxPQkCtU26BpU6RjQrLPYdpNMVNHACUt8glY2ReBoZN6uLxgKK2pajKWF1Gah/bC2i68EbkNUloLgZKyfX84njFgHTittNtDWuKAEV51HDbdYMgnQDDpHtJagfy6H4YtdLA+haArpdO9ANQRQ3Ru4fNm60nlldth9diUdPPnzq3uOj97gKQtwipp8c+GSzPvN9OoQihBBiI5HJ9TzR86ondOBXCCHEmuDIscP7lw6hvJL1N4r8A4ggQE+g0sF0KvW6/ydkJ1F3jE96jUlSv9PXZ7qeNMzMdsLapW6vG7EIPOQxswtEfZPv8E8MmXYDsbCAlRJhiB8sIY0FU6Rculx2ZUn9gleL1MkjgN4eP5ZU8TSzCTDfLEYXx3yce3uwagdpPmLOnPE6m127xl2ZtVHf3LHN61AuXvJ9i9m+zSdXQKqrRcj6uuB1V6zPSE2SzTZdWQJZzxWglKoSnQpTbrXAWgyJTgWBlE+WRAiv/UzGl2/d6mNvRFPE7pM0oH3V2iiGmErrekH6HWuzLy4ARQ3rQwWohLo6vaosgSiNlgO0pzEtz1XEh00eHhocPul+IpYVvCsIsQa59/jo3Vd6/Y377/vqVCN6efPm/y4WQgghVh3lXPjNe46P3quZEauBq3UCi4dQpr4vilr+qYYQQgixxsnkej/f86oTymwihBBizbH0ZVt8+OS6DqEIIYQQaxwdNrkN6OCJWJfc+/iJV1wZlw6hCCGEWOvE2VTK2fDLdx0ffbUmU6xmrj6EMvXkA7/Uqk/8lA6hCCGEWMvosIkQQoj1xjWHUKTjEUIIsV740tJhE2l0bhNS7YgNxdMHB35jthb93Xq0mC+MaQ2YzgFpFFjdLuDNSKNYYRRAu4wa6RwphlqXKjmww7qBthTSxLKA5iQN7NfZN2RoLGDIbcvRiT+S2A6OD+mMFq+Hr4jmkM0fWqJIm8LqMpBWhPXNSP0sCgZRp8yRzhVIGwvgpkDtGlkDTIVCukHvQQTpcjrA9VifkU6K9TlN38jlYDwZqA/WZj2T6hDWdhpQTDPI4UP252vXfRgE1pMP/vu+kdG/5yoLscaYfnLwnzfr0x+MIpLzUwghhFglBEG2mcn1/O7VhymFEEKIjcCRY4d7lw6hfO9yDrfVxM9GQqDBmJzyihUj+paYMaBZ2bJlypVZG5VJLof1K6sBpL7ZvGnalVmiXvGxiGm2/AOrHduxboTpMZpN/7Q8k2FPtD1M/3HpEp7vXbsuuzLWBvo+gilSxie8nsaIGmYBqFdiCqRtxMxsFyiNlVLzroypQs6e63NlMVu3+HVw/jxeAz09vs+lEtYRoTUXUy75PufzXsFkidoH32vZrL/XqkD1stiGX7ddXUTrQmi1/N7DlFSI2VmvlrE2mimmg0oD0iIxLU/aeKwGKhWvbGLjGB/Ha7G/3639T5vZIzpssjrAd78Q65R9I6M/YGbxf3b60MCPT1SjI7UWkawJIYQQt5hcGDRLueBje0dG363Yi/VE+cCxj5lZ/J9Nnzz0jlaj8mut5sxmTbIQQojVQBAUqplc+T1Ln1dCCCHEhmRocDg+jfAWe/4QyiNm9l6tBiGEEKuMj5rZ+5Y+t8QqQgdPxIZlz9HRD+8x+3A8/tMHB142W4+eqDQjf9xOCCGEWEG6MsF8Vy74+3tHRn9HcRYbgfL+o79lZvF/Nn3ywb1Ra+GTzfrEazT5QgghbiVhpvtSmCm9pXzgsREFXgghhHghS1/mvW/pv/ggysNm9pE4eYKrLIQQQqwkQTSXyUQf+8Cbf/9nFOfVjVQ7QgC+cf99X51qRC9v4uxmLyCN4gGYFRKKpJF54OlgqpAauJfZ9UgTsD7pmuWYPgL0I5+iLoOlpUG6JNZnEE6qLkIaDAMqDNYHa6PxQf1Aio6YOliDedJwRMqRmgepZRgkRHCN0x+QNlg30BolIYKqlg7UQJyWDgWftEGaSAe+nOVB4/R+IMUspggUZ7SWrc16RoBhLBtoDtGeaEQTZuReA0W0HMWtHeheQX3IhGalbHjqf3t8dJ/7oRAbnOkn7/8PzdrUj0RWJ3e2EEIIceNkcv1fCMKOf1ze/9gphVEIIYS4MX7xi28aKBRqv2xmr722gdnZTtdmd/ecK2M0m/ifgkxDsrDgNR2FQs2VGVFYWKL/8MqYixfx+Zps1j/oAdqHBKSUMKKVqNWwSiMA6pswxLFgMUozJxFJDn/xoldesEeZ24HGh4/PFSXkgJKFaYCWA6Qy6ejAGhmmjorAw1q0Po2sAcbUNNb1VCq+7d6y1+GwvnV14booFtYmHmkYu+TvK7Zukf6Iwr4YQWsmRd2JSayCqtfxXrKVaL4Q8/N4fygWr39toP2SxTPNfrRaaDQyI2bB+376uz73+VXbSeFQxhMhAPc+fuIVV0q/9cB9/3amYT+60Ix0vwghhLghCtmgUcrYr991/MQ7FUEhOOUDj/9TM4v/W1LyzP5aqzkrJY8QQogbIyhUs1LoCCGEEMvKv/wbfzRqZg+ZlDxCCCGWFyl01jj6Il2IF2HpS8Lki8JYybPQtN+fabT2NfDBQSGEEMIyYWDd2eCpfGjft3dk9GuKiBDpuVrJEzP15fs+36pPHW5F4JUOIYQQYolsvu9PgrDwNmU1EUIIIVaea5U8v/D57/7bURR8KIqCexV+IYQQL0L8b7aHhwaHH21fTawVpNoR4iZ4+uDAe2br0S8uNCOXfwxpLKrLcFgF2CcSoLqDeCJI8YqB9BOWUm3BlDgLwGPBvo1C4c+TyjVUeZlAJ/5YhjcwPBpPnOANjzuNTiWN3snIHJIwW5b8AB3sAkWLbYPuoT5Yyvlm406jKWLrFt6boCgBNwHrg2EkoKGgLrC6aUH7H4pxO5B+ivWZFMMfsG6gPoNfT8jxIDVKWfsPdx0/8WPuJ0KIZWX6yQcPtpqzv9lszOxWZIUQYmOTyXZfCjOdH1BWEyGEEGJ1cVU2lPg/79hAD0SB7mK5GJ8owZaQ0oNpeTIZ378gwE+bKpWiK7M2ipPrZSWVGSxGuawfY6lUcWVpYWqfy+NecbJ5E1Ma+Ti3Wrjd7m4c+wA8BZwGiiJLXjbzsTCiqGnhqrZ5sx9Lve5/P2Z8HPejs9PriNicnDvX58qKnVid01msurKYfN7XZyqavt5ZV5aWatWrhDo6sEarRmKXz/k+Lwfj4149ZW20W4jpGRy7cunmY4dge9o0UDmlGccNEPuIPhL/p6wm6xP0/acQ4jrZNzL6QTP74JXa33pg4Asz9ehwPUJ/NQshhFhP5AKLOnPBH+8bGX2zJlaIW0v5wGMjZrbnykWnnnzgl5r1maGoRQTKQggh1g1hkGll8r2/Wz4w+jbNqhBCCLF6uTYbypFjh/ctfeH4vZo2IYTYMHxpKavJ05ry9Y8yngixQsRanmrL/ud0vXXnlbf02dv67OV5Vh+B2liOzCYsIwU+H4mpk5O9qM8MlqEDJZRgB+MzYCwBSydBimsgBQkZ3rKA4o+ygaQFZZMwkmGFrSN2cjELJgVm+DCeUiLwTbCqsH9sbZFhw/XF2kCZMdDvt7seqQ5hH9Moy1GDVEalqKwdaeKM6qYFtQ2WVgJat0ZixNair+ljlAkCK+WCb+VDe4v0OUKsXqZPPrg3alX/b2l5hBBi/SB9jhBCCLH+OHLs8ENLB1FeeVsHh94hZQ+YU9BqgnaT52b+n6nZbNOVpWVm1mcuiGmCfvT24KwKly7hTA4oQ8f5C72uLGb7Np/EgMViagb3eTkyZqwUtRrJrgEygrB49vbOubJs1mcwSQvL/JEJ/fpiGTA6Ovw4VpJZklkGxROV3Q6a5FFTJrOS3xR55uZ9tp8cyfKSI+trAby/VSjgzDIpONVoZH/kp7/rc5+/2YbE2oN9byiEuEn2jIz+mZnddaWV+CDKbDM6NlOLcL46IYQQq47uXDDVmbF/vHfkxG9rdoRYGyx9Kfn6K5194UGUOn46IIQQYlWRzfX9ryAs/kj5wNGjmhkhhBBifTI0OPyome2/Mrgjxw4/vJQdZa+mXAgh1gzxc7j3DQ0Of1xTJnTwRIhbxNJBlOeOuJ46eN/bKk37zzqIIoQQq4eu5KBJ8I/2joz+jqZFiPUBOYjyn1v1qYd0EEUIIVYHOmgihBBCiKUvLZ/74lIHUYQQYlWigyaCItWOEKuEUwcHvr/Wsl+ZqUd3NZfuS5SAjiklCsBBsUAqI1WIEV0IMFUkEFsFJE0bBVJ5AVVOSQf4aqm6gtnPyFCw/oPMVZrugWY5+HKprpcH8TSyjvLInROPm3wG3ex0s1jQtY8GTuoiWFUyrTB2pKpFqG/xNUEbGRLnBggomqe0LMf9CoaxCG46FagbV18vDM2KmWC6K5tkNPmUqyyE2BDoIIoQQtx6dNBECCGEEGm52YMoc3MFVxbT2bngylYLrZZ/QBaG4IGXmc3P4/EViyszvosXsWqnVJp3ZcVi1ZW1A+k/Gg38Hn13t9fWVCpeQRLT1eX7xkijrbFEHe/npVb144gppIhHvY7Hnct5dUoaBQxT3NTqWMHT3zfjytA82fKoWiAXiN4pzPjYx5RLfm2kUQlVKvie6urC9xTSXbH1slr2nalp3+eecuXaIh00EdcN3rGEELecpbfrn3vDPlbzVFv26bl6dGc9QqJJIYQQaciEZuVs+O1Cxr5nKQuVEEJcyYjyuiuRiA+iWFT/F436zA9FrXn8FEUIIcR1EwaZVpjrezQIO/7R0p4rhBBCCJEakBHloaWDKK9VNIUQYtn40tJBk0cVUpEWHTwRYpWy9KXo3Vf37lsHB/7HTC36/oVmpHtXCCFehEImaHRlg2P3HB/VAwghxHWz9KXoP1n6L2H6ycF/3mpUfr7ZnNmkSAohRHuCsFjL5kqfKB94/J+0rSiEEEIIcRMsfSn60JUWjhw7vG/pIMoPKa5CCHF9hGH0+2EYvee9r//sXypk4maRakeINcypg/e9ba5uvzbXirYiVQixYFCnB7J0MFUIU5YgmNID6YFqyI2RaHJ8XSM2jgbb10AxyyVTB/E0okhh40PXSwDXRPoda6NLSgNqGgwjgY4FgNRFMfU0XSZ1UTzS6FvA0mp3OahkyZM2fBJDOKVtQdPK+pwDsbBkjfpGSFW4nllddm+jtQG6QEH3jjHNEdE+sT7HsYt/VswEk53Z4B/tPjr6u66SEEIsI9NPHjoURbX3t+oT0vMIITY82dymvwrC4j+WNkcIIYQQq42b1fPcDJNT3fC3e3tmXRljDqg+Oonmg3HpUtn9ZPPmaVeWllYTP6ibX/B9ZoqbS5d935L+bbr+/o1d6nFlWzZPubJ2XBzzbWzdgttIozRiyp880L3ksuipM6cOVEC5nG83plr1dZly5vJ4yZXFbOr3qh1GGq0Vmj+7gTlcCZiOCOmdGBOTeB/o68X7AKrPFEroPrkOPdCppT3x94YGhyddRSFuEmVNEGINs3fkxKfM7FNXj+BbDwx8ar4R/a3ZZoQ/YYQQYh1QzAT1zlzwu3eNjP4dzacQ4laz9OXq666+7PSTg+9qNud+stWY3KkJEUKsVzKZnvEwW/xtZTMRQgghxFoA6HnirCiPmFl8IAV/4y2EEOuAILD4dMsngyD610ODw3+lORW3Ah08EWKdcdfx0bddO6KnHhgYnm1E31VrRfhopBBCrGLyGWuVsuFj+dB+bElDJoQQq47ygWMfNbOPXt2v6Sfv/4+txvxbm82pfs2YEGKtsajMKX/Ggvy7lzRkQgghhBBrmqHB4aeXDp48cmUcR44dfmjpIIoUPUKItcwnwtB+6+de94ef1SyK24VUO0JsQE4fHHhZvWW/OtNoPVhvXmVdQdnxyBaBtDysOqkKy9Hvx+TYBUFxi/g/argYwpQeCKZIaSJXCGmbVIVKnCyJRRoVTRqdCuqvJXPiihKQaofGCNRlkCbgmmGhYLqXGpsAAIoHux65HLx/SBO07SIIapVVBuRRJ9qsowIYOKvL4oy4NvbxIZPuTPD1jkzw9/aMjH4d/IoQQqxZpk8+uNei+r9o1Gd/IGrNdmkmhRCrBR0yEUIIIYR4njSHUZgGY4ZoOjryXnFSLFZd2XJRA0qWPFGyMBqNjPtJNtt0ZYx6A78Dz7QgCKYomp7x/7TuBNqbdn1GWiT21WknmSukrmEqIfQgOK3+CGlgmAIG6VuY6oWBlDh9vRVXZkmc02mDrpvIP5+OGZ/AeqD+/ptXSq1iPhFncxoaHH50PQ9SrD108EQI8RxxZpRqMxqoNKPn5YNkiyDfWcPqpCosR79vOnjyAnTw5IWgJlgo2IEIHTx5HraOVuLgSUcmqOXD4PFcaD+2d2T0a66CEEJsEKaefOD/bDXn/6E0PUKIW0EQdleyue7fsCD3SzpkIoQQQghxfRw5dnj/UqaUt1yt6dHBkxdHB0+ubdyV6ODJ9bAxD55MmdnvmdlHhgaHT7qfCrHKwLu9EGJDcvfx0cPXjvvUwft+cq5uQ3OtaGsrxZfzQghxhTAIrJCxiWI2+MCeo6MfVmCEEOKF9Bw4/rNm9rNXF06fPPSOqLXwnmZ97hVRa9Y/KRRCiBchCPKtTK7nm0HY8e+WdGBCCCGEEOIGWfrS9+Grf/vIscO9ZvYjZvYPzezliq0Q4ib4SpzFZCmTyaQCKdYiyngihLghnnpg4NGFRjQw14xecCw5Aw54s20GJVwgCRTQIWBaHyRmSMiDHzRJ51gmDng9V7JU15WkpwCyWjRQJ0g82VhIE5YHbeBz4OkzdCBYZow0GUiWA7A0UsF+HcXeyLy2yFpEWWgYLJMNiifoQts+Xy9dmWChlA8ezQb27p1HR//i5loTQghxLc9lR6mPKzuKEOI5wlz/s5lM4Q8tyP2ispgIIYQQQtxe/tWX3viaXK7+g0vZUfbeaGemZ3yminIpXaaK1czCQgfsXaGAs4qsFDeb0YXBMp50dPiMIKWueVeWEKyO73AvX/ZZRQoFPw5LMvjgjDNheP1jQVlashn8+6USzrxys9BMKn0zriwlp5aymHxcWUzEekMHT4QQy8bpgwMva5p9uNqIBuea0XO53tg2gw5KsEMLpBjWZ4cIdPDkeUgTOnhyg7BfR7E3Mq9r7eBJdyZY6MgGJ6TJEUKI28/0yQf3WlT/l83mwnfrQIoQ65vnDphY9hPlA0eParqFEEIIIdYOS7qeh6/3QIoOntwadPDkxdHBk+dJcfDkygGTR4cGh3/P/VSIdYgOngghbglPPTDwqWoUvXGuEZWaS1+Coy++2Zfe7GBAHpy2aJB9DZWmvR4qZn/74T+7zDrAYQvWD3BegMIOfKDDCGnaRb9v5DCDkUMVC2SA7OAJmiwWT9QE+PUENhZEnTSC4szWC6rLQHGzJM64EVTMxoemCsXNrjnokg3NiplguhAGf5wJ7Rd0wEQIIdYecYaUqFV9a6sxd2fUmpOyR4g1QBDkWmGu55thmP//lMFECCGEEGL9s3Qg5aGlQymvvJEBV6t5V2bJ35b+yWA+z560rgytFn5oyQ4ioEMHfb3Xf+BmZqbLlcWUuudcWQJ7wH+ToAMtlvJQSxThp7hoXpeDVhPP1fSsj2lvD5mTCLeB4lyv48cUuVzdlaVpNy21Wtb9Ror75CtLB0x+TxlMxEZHB0+EELeVZw4NfF+taT9Xa0Z/rdKMiuR8Av1iXwdPrqpL2kCHEXTw5MXZSAdPOjPBfD4T/GU+Yx/YfXT0d11lIYQQ647pJw8dMmv80GKWlMs78V85QoiVJJPtHQ8yxUeDIPdhZS8RQgghhBCII8cOv2XpUErbLCk6ePI8Onhy4+jgyfNcc5/ELwM8unS4RNlLhCDo4IkQYtVy6uB9b6u3gncuNKKBWmQdSIujgydX1SVtoMMIOnjy4qyngyfxwi2GwXwutL+KD5fsHTnx266OEEIIscSVQymtVu21rfrU3VFUQx+3QogXIQjyrSBbOh+GHY/rcIkQQgghhFhujhw7fOVAykPVah5mSkEHFHTw5BrYA/6bRAdPrgHEeXUdPAn+3AJ7LDAb/pnX/vH/cJWEEC+KDp4IIdYszxwc+JX9jFiqAAAFcElEQVS5pr19oRntXGhGzx1JZV/gs8MPaUAHDNiX/exgBjp4wg45IMjlYN+MHGrJs8qg7gI64dCGHBgf6kNaWJ9b4HOMxZ6BlkwOHGpK2gbXY31ja45UT8W1666QDWoZC57NBtEf3HX8xDtv/gpCCCEEZvrJwXe1WvXvtVZ1f7Mx0QcrCbFByGT7JizsOBmGuU+XDxz7qOZdCCGEEEKsBo4cO7xvKVPKlf9otpQrsAMi1WqHKysWF1zZcoH6wQ6pIBZI9hdGoaNGfnJzNJv44EkmBA+vyeGJqWl/4COmp1xxZZNT/sBOTCeYq/kFP6esXSOHaNIcoIm5fLnkynJ5PO5yN+gHiVEKTjWb4VGz4FGz6Is/9eAXvnWzDQohrr1NwRdoQgixHnjm0MC7mpF9d70VvabetL6ZBjsSe/2gAwM6ePJCdPDkeZbr4EkuCKKOrM1kzb6dz9p/23v0xK+4SkIIIcQqYfrJg3/HrPn6JGNKY25f1KrgV5iEWOUEYVf9/2/v7nqjKMMwjl/3M7N1waYWMBqDlmoMvoHQ+NJQsaZ4YNTE4BGfwG/AgSd+AdMzz4xfwDMPjJyQoKEtKca2IHhgUFrwBYMI0cq2uzPzmFlmQ7czI61tpbT/X7LZ7L3Py+z2ZNJc+9wW3HfVueq4WfhpV98ov3oDAADAhjA8NtQtaf+CYMprRYEPETz5zwietPsfgidfZe1wptLnowMnbuRGAFhTBE8AbGppO584sSPzsR+sS9ujxIdRwX1fS1FggOBJO4Inty0leFINXKPi/PWK2fkw8F/sGjk9nJsAAMAGk7bz8Yrfkm+84eP641H0xzYrvcsBVl96UokFHRfNwgkpOE6oBAAAAMj78OShQ/V6x4C/FVJ5TrKnRfBkSQietFtB8OSSpDMyP5EFSr7MTQCwLhA8AYAluPRK/55Eei9J/EAsPRF53T8f+ebdWaPgPjFVUi5UFl5ZzhrLDT8UKVqiLHeytSit0Qx95CdE+VJT0X5le5aNLSqXjS37Kor2K1O0drjodbVi9cD0t5Ndqzh9btInPaPj53MTAQDAv/pz6tVd8vHhJGkcluKdSqIHae+DMrfa3oS/S8FPaesbyX3T1TcyUjIcAAAAwCoZHhtKgym9cexelLQvezyWrh4Ey/uV4Ozsllyts7OWq5UpC56sVcCkzNxcyXVUV34dtVo1V1vLMNAamJE0fbO2ZVLeT5jpwgevHzt1L30AAHkETwBgjfx44OWPvGxv7NUTeb8j8traKDlRheDJnfcsG1tULhtb9lUU7ddSDSwKpSgM7Epgmgmls87p457R8XO5wQAA4K5qBVWkeE+SJE/6pP6UyVeT+K/uxDdK7hCwHoXh9uteVjPX8b1z7oIUnJMFn3XtPznDHwwAAAC4tw2PDfWmQZWs3U931u4nfd5H8OTO1lnw5Ex64ErW5uZG1upm+ujAiencSAAbGsETAFiHLh/sfzfxGoylnXGiNCWuRuwfiWXNM+3m4qSy+KoJnrSP7XCWnvUXh6YodPZLs+406aRfzfxlWtoAAIDF0hZAUvKCl3/YJ9GB9G2f1HebfPM/n2lLoNwktHHBAzedBfOt0Ej6nrnwlMl+k+wKLW0AAAAArFR2wkp3Fl7pzZZLwyuan+94yEvPLN6C4ElOKzCiLDSSms4eoqUNgOUieAIAm9jPB/t7vPRO2TeQeL1tVnzwivdyuWJaL8iCuAVrmHRa0tXbL9tMPjoyPppbFAAAYAOZ/fbN5yX/bPEn8jvk45dy5ZWy4GvJrhWvYt917j12NlcGAAAAgE1swcksTVEULui67rdJ1qfmiY3RaqZaplqBkPb9mntefH/w+A+5GQBwt0n6B6/CmE3D09t7AAAAAElFTkSuQmCC'; + +export default logo; diff --git a/src/base/presentation/assets/images/windows-logo.png b/src/base/presentation/assets/images/windows-logo.png new file mode 100644 index 0000000..7bd4c71 Binary files /dev/null and b/src/base/presentation/assets/images/windows-logo.png differ diff --git a/src/base/presentation/assets/styles/ag-grid-theme-builder.css b/src/base/presentation/assets/styles/ag-grid-theme-builder.css new file mode 100644 index 0000000..1382336 --- /dev/null +++ b/src/base/presentation/assets/styles/ag-grid-theme-builder.css @@ -0,0 +1,5044 @@ +/* + * This file is a theme downloaded from the AG Grid Theme Builder for AG Grid 32.0.2. + * + * See installation docs at https://www.ag-grid.com/javascript-data-grid/applying-theme-builder-styling-grid/ + */ + +@import url('https://fonts.googleapis.com/css2?family=IBM%20Plex%20Sans:wght@400;700&display=swap'); + +.ag-root-wrapper, +.ag-measurement-container, +.ag-apply-theme-variables { + --ag-background-color: var(--ag-inherited-background-color, #fff); + --ag-foreground-color: var(--ag-inherited-foreground-color, #181d1f); + --ag-text-color: var(--ag-inherited-text-color, var(--ag-foreground-color)); + --ag-accent-color: var(--ag-inherited-accent-color, #7a41a1); + --ag-invalid-color: var(--ag-inherited-invalid-color, #e02525); + --ag-border-color: var(--ag-inherited-border-color, color-mix(in srgb, transparent, var(--ag-foreground-color) 15%)); + --ag-wrapper-border: var(--ag-inherited-wrapper-border, solid 1px var(--ag-border-color)); + --ag-row-border: var(--ag-inherited-row-border, solid 1px var(--ag-border-color)); + --ag-color-scheme: var(--ag-inherited-color-scheme, light); + --ag-header-row-border: var(--ag-inherited-header-row-border, var(--ag-row-border)); + --ag-footer-row-border: var(--ag-inherited-footer-row-border, var(--ag-row-border)); + --ag-column-border: var(--ag-inherited-column-border, solid 1px transparent); + --ag-header-column-border: var(--ag-inherited-header-column-border, none); + --ag-header-column-border-height: var(--ag-inherited-header-column-border-height, 100%); + --ag-pinned-column-border: var(--ag-inherited-pinned-column-border, solid 1px var(--ag-border-color)); + --ag-pinned-row-border: var(--ag-inherited-pinned-row-border, solid 1px var(--ag-border-color)); + --ag-side-panel-border: var(--ag-inherited-side-panel-border, solid 1px var(--ag-border-color)); + --ag-font-family: var(--ag-inherited-font-family, 'IBM Plex Sans'); + --ag-chrome-background-color: var( + --ag-inherited-chrome-background-color, + color-mix(in srgb, transparent, var(--ag-foreground-color) 2%) + ); + --ag-header-background-color: var(--ag-inherited-header-background-color, var(--ag-chrome-background-color)); + --ag-header-font-family: var(--ag-inherited-header-font-family, inherit); + --ag-header-font-weight: var(--ag-inherited-header-font-weight, 700); + --ag-header-font-size: var(--ag-inherited-header-font-size, 13px); + --ag-header-text-color: var(--ag-inherited-header-text-color, #181d1fa8); + --ag-header-cell-hover-background-color: var(--ag-inherited-header-cell-hover-background-color, transparent); + --ag-header-cell-hover-background-transition-duration: var( + --ag-inherited-header-cell-hover-background-transition-duration, + 0.2s + ); + --ag-cell-text-color: var(--ag-inherited-cell-text-color, var(--ag-text-color)); + --ag-subtle-text-color: var( + --ag-inherited-subtle-text-color, + color-mix(in srgb, transparent, var(--ag-text-color) 50%) + ); + --ag-range-selection-border-style: var(--ag-inherited-range-selection-border-style, solid); + --ag-range-selection-border-color: var(--ag-inherited-range-selection-border-color, var(--ag-accent-color)); + --ag-range-selection-background-color: var( + --ag-inherited-range-selection-background-color, + color-mix(in srgb, transparent, var(--ag-accent-color) 20%) + ); + --ag-range-selection-chart-background-color: var(--ag-inherited-range-selection-chart-background-color, #0058ff1a); + --ag-range-selection-chart-category-background-color: var( + --ag-inherited-range-selection-chart-category-background-color, + #00ff841a + ); + --ag-range-selection-highlight-color: var( + --ag-inherited-range-selection-highlight-color, + color-mix(in srgb, transparent, var(--ag-accent-color) 50%) + ); + --ag-row-hover-color: var( + --ag-inherited-row-hover-color, + color-mix(in srgb, transparent, var(--ag-accent-color) 12%) + ); + --ag-column-hover-color: var( + --ag-inherited-column-hover-color, + color-mix(in srgb, transparent, var(--ag-accent-color) 5%) + ); + --ag-selected-row-background-color: var( + --ag-inherited-selected-row-background-color, + color-mix(in srgb, transparent, var(--ag-accent-color) 8%) + ); + --ag-modal-overlay-background-color: var( + --ag-inherited-modal-overlay-background-color, + color-mix(in srgb, transparent, var(--ag-background-color) 66%) + ); + --ag-odd-row-background-color: var(--ag-inherited-odd-row-background-color, var(--ag-background-color)); + --ag-border-radius: var(--ag-inherited-border-radius, 4px); + --ag-wrapper-border-radius: var(--ag-inherited-wrapper-border-radius, 8px); + --ag-cell-horizontal-padding: var( + --ag-inherited-cell-horizontal-padding, + calc(var(--ag-grid-size) * 2 * var(--ag-cell-horizontal-padding-scale)) + ); + --ag-cell-widget-spacing: var(--ag-inherited-cell-widget-spacing, calc(var(--ag-grid-size) * 1.5)); + --ag-cell-horizontal-padding-scale: var(--ag-inherited-cell-horizontal-padding-scale, 1); + --ag-row-group-indent-size: var( + --ag-inherited-row-group-indent-size, + calc(var(--ag-cell-widget-spacing) + var(--ag-icon-size)) + ); + --ag-value-change-delta-up-color: var(--ag-inherited-value-change-delta-up-color, #43a047); + --ag-value-change-delta-down-color: var(--ag-inherited-value-change-delta-down-color, #e53935); + --ag-value-change-value-highlight-background-color: var( + --ag-inherited-value-change-value-highlight-background-color, + #16a08580 + ); + --ag-grid-size: var(--ag-inherited-grid-size, 8px); + --ag-font-size: var(--ag-inherited-font-size, 13px); + --ag-row-height: var( + --ag-inherited-row-height, + calc( + max(var(--ag-icon-size), var(--ag-font-size)) + var(--ag-grid-size) * 3.5 * var(--ag-row-vertical-padding-scale) + ) + ); + --ag-row-vertical-padding-scale: var(--ag-inherited-row-vertical-padding-scale, 0.5); + --ag-header-height: var( + --ag-inherited-header-height, + calc( + max(var(--ag-icon-size), var(--ag-font-size)) + var(--ag-grid-size) * 4.25 * + var(--ag-header-vertical-padding-scale) + ) + ); + --ag-header-vertical-padding-scale: var(--ag-inherited-header-vertical-padding-scale, 1); + --ag-popup-shadow: var(--ag-inherited-popup-shadow, 0 0 16px 0 #00000026); + --ag-dropdown-shadow: var(--ag-inherited-dropdown-shadow, 0 1px 4px 1px #babfc766); + --ag-drag-ghost-background-color: var(--ag-inherited-drag-ghost-background-color, var(--ag-background-color)); + --ag-drag-ghost-border: var(--ag-inherited-drag-ghost-border, solid 1px var(--ag-border-color)); + --ag-drag-ghost-shadow: var(--ag-inherited-drag-ghost-shadow, var(--ag-popup-shadow)); + --ag-focus-shadow: var( + --ag-inherited-focus-shadow, + 0 0 0 3px color-mix(in srgb, transparent, var(--ag-accent-color) 50%) + ); + --ag-side-bar-panel-width: var(--ag-inherited-side-bar-panel-width, 250px); + --ag-side-button-selected-border: var(--ag-inherited-side-button-selected-border, solid 1px var(--ag-border-color)); + --ag-side-button-selected-background-color: var( + --ag-inherited-side-button-selected-background-color, + var(--ag-background-color) + ); + --ag-side-bar-background-color: var(--ag-inherited-side-bar-background-color, var(--ag-chrome-background-color)); + --ag-header-column-resize-handle-display: var(--ag-inherited-header-column-resize-handle-display, block); + --ag-header-column-resize-handle-height: var(--ag-inherited-header-column-resize-handle-height, 30%); + --ag-header-column-resize-handle-width: var(--ag-inherited-header-column-resize-handle-width, 2px); + --ag-header-column-resize-handle-color: var(--ag-inherited-header-column-resize-handle-color, var(--ag-border-color)); + --ag-widget-container-horizontal-padding: var( + --ag-inherited-widget-container-horizontal-padding, + calc(var(--ag-grid-size) * 1.5) + ); + --ag-widget-container-vertical-padding: var( + --ag-inherited-widget-container-vertical-padding, + calc(var(--ag-grid-size) * 1.5) + ); + --ag-widget-horizontal-spacing: var(--ag-inherited-widget-horizontal-spacing, calc(var(--ag-grid-size) * 1.5)); + --ag-widget-vertical-spacing: var(--ag-inherited-widget-vertical-spacing, var(--ag-grid-size)); + --ag-list-item-height: var( + --ag-inherited-list-item-height, + calc(var(--ag-icon-size) + var(--ag-widget-vertical-spacing)) + ); + --ag-icon-size: var(--ag-inherited-icon-size, 16px); + --ag-toggle-button-width: var(--ag-inherited-toggle-button-width, 28px); + --ag-toggle-button-height: var(--ag-inherited-toggle-button-height, 18px); + --ag-toggle-button-border-width: var(--ag-inherited-toggle-button-border-width, 2px); + --ag-toggle-button-on-border-color: var(--ag-inherited-toggle-button-on-border-color, var(--ag-accent-color)); + --ag-toggle-button-on-background-color: var(--ag-inherited-toggle-button-on-background-color, var(--ag-accent-color)); + --ag-toggle-button-off-border-color: var( + --ag-inherited-toggle-button-off-border-color, + color-mix(in srgb, var(--ag-background-color), var(--ag-foreground-color) 30%) + ); + --ag-toggle-button-off-background-color: var( + --ag-inherited-toggle-button-off-background-color, + color-mix(in srgb, var(--ag-background-color), var(--ag-foreground-color) 30%) + ); + --ag-toggle-button-switch-border-color: var( + --ag-inherited-toggle-button-switch-border-color, + var(--ag-toggle-button-off-border-color) + ); + --ag-toggle-button-switch-background-color: var( + --ag-inherited-toggle-button-switch-background-color, + var(--ag-background-color) + ); + --ag-checkbox-border-width: var(--ag-inherited-checkbox-border-width, 1px); + --ag-checkbox-border-radius: var(--ag-inherited-checkbox-border-radius, var(--ag-border-radius)); + --ag-checkbox-unchecked-background-color: var( + --ag-inherited-checkbox-unchecked-background-color, + var(--ag-background-color) + ); + --ag-checkbox-unchecked-border-color: var( + --ag-inherited-checkbox-unchecked-border-color, + color-mix(in srgb, var(--ag-background-color), var(--ag-foreground-color) 30%) + ); + --ag-checkbox-checked-background-color: var(--ag-inherited-checkbox-checked-background-color, var(--ag-accent-color)); + --ag-checkbox-checked-border-color: var(--ag-inherited-checkbox-checked-border-color, var(--ag-accent-color)); + --ag-checkbox-checked-shape-image: var( + --ag-inherited-checkbox-checked-shape-image, + url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20width%3D%2210%22%20height%3D%227%22%20fill%3D%22none%22%3E%3Cpath%20stroke%3D%22%23000%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke-width%3D%221.75%22%20d%3D%22M1%203.5%203.5%206l5-5%22%2F%3E%3C%2Fsvg%3E') + ); + --ag-checkbox-checked-shape-color: var(--ag-inherited-checkbox-checked-shape-color, var(--ag-background-color)); + --ag-checkbox-indeterminate-background-color: var( + --ag-inherited-checkbox-indeterminate-background-color, + color-mix(in srgb, var(--ag-background-color), var(--ag-foreground-color) 30%) + ); + --ag-checkbox-indeterminate-border-color: var( + --ag-inherited-checkbox-indeterminate-border-color, + color-mix(in srgb, var(--ag-background-color), var(--ag-foreground-color) 30%) + ); + --ag-checkbox-indeterminate-shape-image: var( + --ag-inherited-checkbox-indeterminate-shape-image, + url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20width%3D%2210%22%20height%3D%222%22%20fill%3D%22none%22%3E%3Crect%20width%3D%2210%22%20height%3D%222%22%20fill%3D%22%23000%22%20rx%3D%221%22%2F%3E%3C%2Fsvg%3E') + ); + --ag-checkbox-indeterminate-shape-color: var( + --ag-inherited-checkbox-indeterminate-shape-color, + var(--ag-background-color) + ); + --ag-radio-checked-shape-image: var( + --ag-inherited-radio-checked-shape-image, + url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20width%3D%226%22%20height%3D%226%22%20fill%3D%22none%22%3E%3Ccircle%20cx%3D%223%22%20cy%3D%223%22%20r%3D%223%22%20fill%3D%22%23000%22%2F%3E%3C%2Fsvg%3E') + ); + --ag-menu-border: var( + --ag-inherited-menu-border, + solid 1px color-mix(in srgb, transparent, var(--ag-foreground-color) 20%) + ); + --ag-menu-background-color: var( + --ag-inherited-menu-background-color, + color-mix(in srgb, var(--ag-background-color), var(--ag-foreground-color) 3%) + ); + --ag-menu-text-color: var( + --ag-inherited-menu-text-color, + color-mix(in srgb, var(--ag-background-color), var(--ag-foreground-color) 95%) + ); + --ag-menu-shadow: var(--ag-inherited-menu-shadow, var(--ag-popup-shadow)); + --ag-menu-separator-color: var(--ag-inherited-menu-separator-color, var(--ag-border-color)); + --ag-set-filter-indent-size: var(--ag-inherited-set-filter-indent-size, var(--ag-icon-size)); + --ag-chart-menu-panel-width: var(--ag-inherited-chart-menu-panel-width, 260px); + --ag-chart-menu-label-color: var( + --ag-inherited-chart-menu-label-color, + color-mix(in srgb, transparent, var(--ag-foreground-color) 80%) + ); + --ag-icon-button-hover-color: var( + --ag-inherited-icon-button-hover-color, + color-mix(in srgb, transparent, var(--ag-foreground-color) 10%) + ); + --ag-dialog-shadow: var(--ag-inherited-dialog-shadow, var(--ag-popup-shadow)); + --ag-dialog-border: var( + --ag-inherited-dialog-border, + solid 1px color-mix(in srgb, transparent, var(--ag-foreground-color) 20%) + ); + --ag-panel-background-color: var(--ag-inherited-panel-background-color, var(--ag-background-color)); + --ag-panel-title-bar-background-color: var( + --ag-inherited-panel-title-bar-background-color, + var(--ag-header-background-color) + ); + --ag-panel-title-bar-border: var(--ag-inherited-panel-title-bar-border, solid 1px var(--ag-border-color)); + --ag-column-select-indent-size: var(--ag-inherited-column-select-indent-size, var(--ag-icon-size)); + --ag-tool-panel-separator-border: var(--ag-inherited-tool-panel-separator-border, solid 1px var(--ag-border-color)); + --ag-tooltip-background-color: var(--ag-inherited-tooltip-background-color, var(--ag-chrome-background-color)); + --ag-tooltip-text-color: var(--ag-inherited-tooltip-text-color, var(--ag-text-color)); + --ag-tooltip-border: var(--ag-inherited-tooltip-border, solid 1px var(--ag-border-color)); + --ag-column-drop-cell-background-color: var( + --ag-inherited-column-drop-cell-background-color, + color-mix(in srgb, transparent, var(--ag-foreground-color) 7%) + ); + --ag-column-drop-cell-border: var( + --ag-inherited-column-drop-cell-border, + solid 1px color-mix(in srgb, transparent, var(--ag-foreground-color) 13%) + ); + --ag-select-cell-background-color: var( + --ag-inherited-select-cell-background-color, + color-mix(in srgb, transparent, var(--ag-foreground-color) 7%) + ); + --ag-select-cell-border: var( + --ag-inherited-select-cell-border, + solid 1px color-mix(in srgb, transparent, var(--ag-foreground-color) 13%) + ); + --ag-advanced-filter-builder-button-bar-border: var( + --ag-inherited-advanced-filter-builder-button-bar-border, + solid 1px var(--ag-border-color) + ); + --ag-advanced-filter-builder-indent-size: var( + --ag-inherited-advanced-filter-builder-indent-size, + calc(var(--ag-grid-size) * 2 + var(--ag-icon-size)) + ); + --ag-advanced-filter-builder-join-pill-color: var(--ag-inherited-advanced-filter-builder-join-pill-color, #f08e8d); + --ag-advanced-filter-builder-column-pill-color: var( + --ag-inherited-advanced-filter-builder-column-pill-color, + #a6e194 + ); + --ag-advanced-filter-builder-option-pill-color: var( + --ag-inherited-advanced-filter-builder-option-pill-color, + #f3c08b + ); + --ag-advanced-filter-builder-value-pill-color: var(--ag-inherited-advanced-filter-builder-value-pill-color, #85c0e4); + --ag-filter-tool-panel-group-indent: var(--ag-inherited-filter-tool-panel-group-indent, var(--ag-grid-size)); + --ag-icon-button-hover-background-color: var( + --ag-inherited-icon-button-hover-background-color, + color-mix(in srgb, transparent, var(--ag-foreground-color) 10%) + ); + --ag-row-loading-skeleton-effect-color: var(--ag-inherited-row-loading-skeleton-effect-color, rgba(66, 66, 66, 0.2)); + --ag-tab-bar-background-color: var( + --ag-inherited-tab-bar-background-color, + color-mix(in srgb, transparent, var(--ag-foreground-color) 5%) + ); + --ag-tab-bar-horizontal-padding: var(--ag-inherited-tab-bar-horizontal-padding, 0); + --ag-tab-bar-top-padding: var(--ag-inherited-tab-bar-top-padding, 0); + --ag-tab-background-color: var(--ag-inherited-tab-background-color, transparent); + --ag-tab-text-color: var(--ag-inherited-tab-text-color, color-mix(in srgb, transparent, var(--ag-text-color) 70%)); + --ag-tab-horizontal-padding: var(--ag-inherited-tab-horizontal-padding, calc(var(--ag-grid-size))); + --ag-tab-top-padding: var(--ag-inherited-tab-top-padding, calc(var(--ag-grid-size))); + --ag-tab-bottom-padding: var(--ag-inherited-tab-bottom-padding, calc(var(--ag-grid-size))); + --ag-tab-spacing: var(--ag-inherited-tab-spacing, 0); + --ag-tab-hover-background-color: var(--ag-inherited-tab-hover-background-color, var(--ag-tab-background-color)); + --ag-tab-hover-text-color: var(--ag-inherited-tab-hover-text-color, var(--ag-text-color)); + --ag-tab-selected-background-color: var(--ag-inherited-tab-selected-background-color, var(--ag-background-color)); + --ag-tab-selected-text-color: var(--ag-inherited-tab-selected-text-color, var(--ag-text-color)); + --ag-tab-selected-border-width: var(--ag-inherited-tab-selected-border-width, 1px); + --ag-tab-selected-border-color: var(--ag-inherited-tab-selected-border-color, var(--ag-border-color)); + --ag-tab-selected-underline-color: var(--ag-inherited-tab-selected-underline-color, transparent); + --ag-tab-selected-underline-width: var(--ag-inherited-tab-selected-underline-width, 0); + --ag-tab-selected-underline-transition-duration: var(--ag-inherited-tab-selected-underline-transition-duration, 0); + --ag-tab-bar-border: var(--ag-inherited-tab-bar-border, solid 1px var(--ag-border-color)); + --ag-input-background-color: var(--ag-inherited-input-background-color, var(--ag-background-color)); + --ag-input-border: var(--ag-inherited-input-border, solid 1px var(--ag-border-color)); + --ag-input-border-radius: var(--ag-inherited-input-border-radius, var(--ag-border-radius)); + --ag-input-text-color: var(--ag-inherited-input-text-color, var(--ag-text-color)); + --ag-input-padding-start: var(--ag-inherited-input-padding-start, var(--ag-grid-size)); + --ag-input-height: var( + --ag-inherited-input-height, + calc(max(var(--ag-icon-size), var(--ag-font-size)) + var(--ag-grid-size) * 2) + ); + --ag-input-focus-background-color: var(--ag-inherited-input-focus-background-color, var(--ag-input-background-color)); + --ag-input-focus-border: var(--ag-inherited-input-focus-border, solid 1px var(--ag-accent-color)); + --ag-input-focus-shadow: var(--ag-inherited-input-focus-shadow, var(--ag-focus-shadow)); + --ag-input-focus-text-color: var(--ag-inherited-input-focus-text-color, var(--ag-input-text-color)); + --ag-input-disabled-background-color: var( + --ag-inherited-input-disabled-background-color, + color-mix(in srgb, var(--ag-background-color), var(--ag-foreground-color) 6%) + ); + --ag-input-disabled-border: var(--ag-inherited-input-disabled-border, var(--ag-input-border)); + --ag-input-disabled-text-color: var( + --ag-inherited-input-disabled-text-color, + color-mix(in srgb, transparent, var(--ag-text-color) 50%) + ); + --ag-input-invalid-background-color: var( + --ag-inherited-input-invalid-background-color, + var(--ag-input-background-color) + ); + --ag-input-invalid-border: var(--ag-inherited-input-invalid-border, solid 1px var(--ag-invalid-color)); + --ag-input-invalid-text-color: var(--ag-inherited-input-invalid-text-color, var(--ag-input-text-color)); +} +:has(> .ag-root-wrapper) { + --ag-inherited-background-color: var(--ag-background-color); + --ag-inherited-foreground-color: var(--ag-foreground-color); + --ag-inherited-text-color: var(--ag-text-color); + --ag-inherited-accent-color: var(--ag-accent-color); + --ag-inherited-invalid-color: var(--ag-invalid-color); + --ag-inherited-border-color: var(--ag-border-color); + --ag-inherited-wrapper-border: var(--ag-wrapper-border); + --ag-inherited-row-border: var(--ag-row-border); + --ag-inherited-color-scheme: var(--ag-color-scheme); + --ag-inherited-header-row-border: var(--ag-header-row-border); + --ag-inherited-footer-row-border: var(--ag-footer-row-border); + --ag-inherited-column-border: var(--ag-column-border); + --ag-inherited-header-column-border: var(--ag-header-column-border); + --ag-inherited-header-column-border-height: var(--ag-header-column-border-height); + --ag-inherited-pinned-column-border: var(--ag-pinned-column-border); + --ag-inherited-pinned-row-border: var(--ag-pinned-row-border); + --ag-inherited-side-panel-border: var(--ag-side-panel-border); + --ag-inherited-font-family: var(--ag-font-family); + --ag-inherited-chrome-background-color: var(--ag-chrome-background-color); + --ag-inherited-header-background-color: var(--ag-header-background-color); + --ag-inherited-header-font-family: var(--ag-header-font-family); + --ag-inherited-header-font-weight: var(--ag-header-font-weight); + --ag-inherited-header-font-size: var(--ag-header-font-size); + --ag-inherited-header-text-color: var(--ag-header-text-color); + --ag-inherited-header-cell-hover-background-color: var(--ag-header-cell-hover-background-color); + --ag-inherited-header-cell-hover-background-transition-duration: var( + --ag-header-cell-hover-background-transition-duration + ); + --ag-inherited-cell-text-color: var(--ag-cell-text-color); + --ag-inherited-subtle-text-color: var(--ag-subtle-text-color); + --ag-inherited-range-selection-border-style: var(--ag-range-selection-border-style); + --ag-inherited-range-selection-border-color: var(--ag-range-selection-border-color); + --ag-inherited-range-selection-background-color: var(--ag-range-selection-background-color); + --ag-inherited-range-selection-chart-background-color: var(--ag-range-selection-chart-background-color); + --ag-inherited-range-selection-chart-category-background-color: var( + --ag-range-selection-chart-category-background-color + ); + --ag-inherited-range-selection-highlight-color: var(--ag-range-selection-highlight-color); + --ag-inherited-row-hover-color: var(--ag-row-hover-color); + --ag-inherited-column-hover-color: var(--ag-column-hover-color); + --ag-inherited-selected-row-background-color: var(--ag-selected-row-background-color); + --ag-inherited-modal-overlay-background-color: var(--ag-modal-overlay-background-color); + --ag-inherited-odd-row-background-color: var(--ag-odd-row-background-color); + --ag-inherited-border-radius: var(--ag-border-radius); + --ag-inherited-wrapper-border-radius: var(--ag-wrapper-border-radius); + --ag-inherited-cell-horizontal-padding: var(--ag-cell-horizontal-padding); + --ag-inherited-cell-widget-spacing: var(--ag-cell-widget-spacing); + --ag-inherited-cell-horizontal-padding-scale: var(--ag-cell-horizontal-padding-scale); + --ag-inherited-row-group-indent-size: var(--ag-row-group-indent-size); + --ag-inherited-value-change-delta-up-color: var(--ag-value-change-delta-up-color); + --ag-inherited-value-change-delta-down-color: var(--ag-value-change-delta-down-color); + --ag-inherited-value-change-value-highlight-background-color: var(--ag-value-change-value-highlight-background-color); + --ag-inherited-grid-size: var(--ag-grid-size); + --ag-inherited-font-size: var(--ag-font-size); + --ag-inherited-row-height: var(--ag-row-height); + --ag-inherited-row-vertical-padding-scale: var(--ag-row-vertical-padding-scale); + --ag-inherited-header-height: var(--ag-header-height); + --ag-inherited-header-vertical-padding-scale: var(--ag-header-vertical-padding-scale); + --ag-inherited-popup-shadow: var(--ag-popup-shadow); + --ag-inherited-dropdown-shadow: var(--ag-dropdown-shadow); + --ag-inherited-drag-ghost-background-color: var(--ag-drag-ghost-background-color); + --ag-inherited-drag-ghost-border: var(--ag-drag-ghost-border); + --ag-inherited-drag-ghost-shadow: var(--ag-drag-ghost-shadow); + --ag-inherited-focus-shadow: var(--ag-focus-shadow); + --ag-inherited-side-bar-panel-width: var(--ag-side-bar-panel-width); + --ag-inherited-side-button-selected-border: var(--ag-side-button-selected-border); + --ag-inherited-side-button-selected-background-color: var(--ag-side-button-selected-background-color); + --ag-inherited-side-bar-background-color: var(--ag-side-bar-background-color); + --ag-inherited-header-column-resize-handle-display: var(--ag-header-column-resize-handle-display); + --ag-inherited-header-column-resize-handle-height: var(--ag-header-column-resize-handle-height); + --ag-inherited-header-column-resize-handle-width: var(--ag-header-column-resize-handle-width); + --ag-inherited-header-column-resize-handle-color: var(--ag-header-column-resize-handle-color); + --ag-inherited-widget-container-horizontal-padding: var(--ag-widget-container-horizontal-padding); + --ag-inherited-widget-container-vertical-padding: var(--ag-widget-container-vertical-padding); + --ag-inherited-widget-horizontal-spacing: var(--ag-widget-horizontal-spacing); + --ag-inherited-widget-vertical-spacing: var(--ag-widget-vertical-spacing); + --ag-inherited-list-item-height: var(--ag-list-item-height); + --ag-inherited-icon-size: var(--ag-icon-size); + --ag-inherited-toggle-button-width: var(--ag-toggle-button-width); + --ag-inherited-toggle-button-height: var(--ag-toggle-button-height); + --ag-inherited-toggle-button-border-width: var(--ag-toggle-button-border-width); + --ag-inherited-toggle-button-on-border-color: var(--ag-toggle-button-on-border-color); + --ag-inherited-toggle-button-on-background-color: var(--ag-toggle-button-on-background-color); + --ag-inherited-toggle-button-off-border-color: var(--ag-toggle-button-off-border-color); + --ag-inherited-toggle-button-off-background-color: var(--ag-toggle-button-off-background-color); + --ag-inherited-toggle-button-switch-border-color: var(--ag-toggle-button-switch-border-color); + --ag-inherited-toggle-button-switch-background-color: var(--ag-toggle-button-switch-background-color); + --ag-inherited-checkbox-border-width: var(--ag-checkbox-border-width); + --ag-inherited-checkbox-border-radius: var(--ag-checkbox-border-radius); + --ag-inherited-checkbox-unchecked-background-color: var(--ag-checkbox-unchecked-background-color); + --ag-inherited-checkbox-unchecked-border-color: var(--ag-checkbox-unchecked-border-color); + --ag-inherited-checkbox-checked-background-color: var(--ag-checkbox-checked-background-color); + --ag-inherited-checkbox-checked-border-color: var(--ag-checkbox-checked-border-color); + --ag-inherited-checkbox-checked-shape-image: var(--ag-checkbox-checked-shape-image); + --ag-inherited-checkbox-checked-shape-color: var(--ag-checkbox-checked-shape-color); + --ag-inherited-checkbox-indeterminate-background-color: var(--ag-checkbox-indeterminate-background-color); + --ag-inherited-checkbox-indeterminate-border-color: var(--ag-checkbox-indeterminate-border-color); + --ag-inherited-checkbox-indeterminate-shape-image: var(--ag-checkbox-indeterminate-shape-image); + --ag-inherited-checkbox-indeterminate-shape-color: var(--ag-checkbox-indeterminate-shape-color); + --ag-inherited-radio-checked-shape-image: var(--ag-radio-checked-shape-image); + --ag-inherited-menu-border: var(--ag-menu-border); + --ag-inherited-menu-background-color: var(--ag-menu-background-color); + --ag-inherited-menu-text-color: var(--ag-menu-text-color); + --ag-inherited-menu-shadow: var(--ag-menu-shadow); + --ag-inherited-menu-separator-color: var(--ag-menu-separator-color); + --ag-inherited-set-filter-indent-size: var(--ag-set-filter-indent-size); + --ag-inherited-chart-menu-panel-width: var(--ag-chart-menu-panel-width); + --ag-inherited-chart-menu-label-color: var(--ag-chart-menu-label-color); + --ag-inherited-icon-button-hover-color: var(--ag-icon-button-hover-color); + --ag-inherited-dialog-shadow: var(--ag-dialog-shadow); + --ag-inherited-dialog-border: var(--ag-dialog-border); + --ag-inherited-panel-background-color: var(--ag-panel-background-color); + --ag-inherited-panel-title-bar-background-color: var(--ag-panel-title-bar-background-color); + --ag-inherited-panel-title-bar-border: var(--ag-panel-title-bar-border); + --ag-inherited-column-select-indent-size: var(--ag-column-select-indent-size); + --ag-inherited-tool-panel-separator-border: var(--ag-tool-panel-separator-border); + --ag-inherited-tooltip-background-color: var(--ag-tooltip-background-color); + --ag-inherited-tooltip-text-color: var(--ag-tooltip-text-color); + --ag-inherited-tooltip-border: var(--ag-tooltip-border); + --ag-inherited-column-drop-cell-background-color: var(--ag-column-drop-cell-background-color); + --ag-inherited-column-drop-cell-border: var(--ag-column-drop-cell-border); + --ag-inherited-select-cell-background-color: var(--ag-select-cell-background-color); + --ag-inherited-select-cell-border: var(--ag-select-cell-border); + --ag-inherited-advanced-filter-builder-button-bar-border: var(--ag-advanced-filter-builder-button-bar-border); + --ag-inherited-advanced-filter-builder-indent-size: var(--ag-advanced-filter-builder-indent-size); + --ag-inherited-advanced-filter-builder-join-pill-color: var(--ag-advanced-filter-builder-join-pill-color); + --ag-inherited-advanced-filter-builder-column-pill-color: var(--ag-advanced-filter-builder-column-pill-color); + --ag-inherited-advanced-filter-builder-option-pill-color: var(--ag-advanced-filter-builder-option-pill-color); + --ag-inherited-advanced-filter-builder-value-pill-color: var(--ag-advanced-filter-builder-value-pill-color); + --ag-inherited-filter-tool-panel-group-indent: var(--ag-filter-tool-panel-group-indent); + --ag-inherited-icon-button-hover-background-color: var(--ag-icon-button-hover-background-color); + --ag-inherited-row-loading-skeleton-effect-color: var(--ag-row-loading-skeleton-effect-color); + --ag-inherited-tab-bar-background-color: var(--ag-tab-bar-background-color); + --ag-inherited-tab-bar-horizontal-padding: var(--ag-tab-bar-horizontal-padding); + --ag-inherited-tab-bar-top-padding: var(--ag-tab-bar-top-padding); + --ag-inherited-tab-background-color: var(--ag-tab-background-color); + --ag-inherited-tab-text-color: var(--ag-tab-text-color); + --ag-inherited-tab-horizontal-padding: var(--ag-tab-horizontal-padding); + --ag-inherited-tab-top-padding: var(--ag-tab-top-padding); + --ag-inherited-tab-bottom-padding: var(--ag-tab-bottom-padding); + --ag-inherited-tab-spacing: var(--ag-tab-spacing); + --ag-inherited-tab-hover-background-color: var(--ag-tab-hover-background-color); + --ag-inherited-tab-hover-text-color: var(--ag-tab-hover-text-color); + --ag-inherited-tab-selected-background-color: var(--ag-tab-selected-background-color); + --ag-inherited-tab-selected-text-color: var(--ag-tab-selected-text-color); + --ag-inherited-tab-selected-border-width: var(--ag-tab-selected-border-width); + --ag-inherited-tab-selected-border-color: var(--ag-tab-selected-border-color); + --ag-inherited-tab-selected-underline-color: var(--ag-tab-selected-underline-color); + --ag-inherited-tab-selected-underline-width: var(--ag-tab-selected-underline-width); + --ag-inherited-tab-selected-underline-transition-duration: var(--ag-tab-selected-underline-transition-duration); + --ag-inherited-tab-bar-border: var(--ag-tab-bar-border); + --ag-inherited-input-background-color: var(--ag-input-background-color); + --ag-inherited-input-border: var(--ag-input-border); + --ag-inherited-input-border-radius: var(--ag-input-border-radius); + --ag-inherited-input-text-color: var(--ag-input-text-color); + --ag-inherited-input-padding-start: var(--ag-input-padding-start); + --ag-inherited-input-height: var(--ag-input-height); + --ag-inherited-input-focus-background-color: var(--ag-input-focus-background-color); + --ag-inherited-input-focus-border: var(--ag-input-focus-border); + --ag-inherited-input-focus-shadow: var(--ag-input-focus-shadow); + --ag-inherited-input-focus-text-color: var(--ag-input-focus-text-color); + --ag-inherited-input-disabled-background-color: var(--ag-input-disabled-background-color); + --ag-inherited-input-disabled-border: var(--ag-input-disabled-border); + --ag-inherited-input-disabled-text-color: var(--ag-input-disabled-text-color); + --ag-inherited-input-invalid-background-color: var(--ag-input-invalid-background-color); + --ag-inherited-input-invalid-border: var(--ag-input-invalid-border); + --ag-inherited-input-invalid-text-color: var(--ag-input-invalid-text-color); +} + +/* Part core/part */ +:where([class^='ag-']), +:where([class^='ag-']):after, +:where([class^='ag-']):before, +:where([class^='ag-']):focus, +:where([class^='ag-']):focus-within { + box-sizing: border-box; + outline: none; +} +:where([class^='ag-']):where(button), +:where([class^='ag-']):where(input), +:where([class^='ag-']):where(textarea) { + background: none; + border: none; + color: inherit; + cursor: pointer; + font-family: inherit; + font-size: inherit; + line-height: inherit; + margin: 0; + padding: 0; +} +:where([class^='ag-']):where(button) { + font-weight: inherit; +} +:where([class^='ag-'])::-ms-clear { + display: none; +} +ag-grid, +ag-grid-angular, +ag-grid-aurelia, +ag-grid-ng2, +ag-grid-polymer { + display: block; +} +.ag-aria-description-container { + border: 0; + z-index: 9999; + clip: rect(1px, 1px, 1px, 1px); + height: 1px; + overflow: hidden; + padding: 0; + position: absolute; + white-space: nowrap; + width: 1px; +} +.ag-hidden { + display: none !important; +} +.ag-invisible { + visibility: hidden !important; +} +.ag-unselectable { + -webkit-user-select: none; + -moz-user-select: none; + user-select: none; +} +.ag-selectable { + -webkit-user-select: text; + -moz-user-select: text; + user-select: text; +} +.ag-tabs-header { + display: flex; +} +.ag-tab { + cursor: pointer; + position: relative; +} +.ag-tab-guard { + display: block; + height: 0; + position: absolute; + width: 0; +} +.ag-virtual-list-viewport .ag-tab-guard { + position: sticky; +} +.ag-tab-guard-top { + top: 1px; +} +.ag-tab-guard-bottom { + bottom: 1px; +} +.ag-shake-left-to-right { + animation-direction: alternate; + animation-duration: 0.2s; + animation-iteration-count: infinite; + animation-name: ag-shake-left-to-right; +} +@keyframes ag-shake-left-to-right { + 0% { + padding-left: 6px; + padding-right: 2px; + } + to { + padding-left: 2px; + padding-right: 6px; + } +} +.ag-watermark { + bottom: 20px; + color: #9b9b9b; + opacity: 0.7; + position: absolute; + right: 25px; + transition: opacity 1s ease-out 3s; +} +.ag-watermark:before { + background-image: url(data:image/svg+xml;base64,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); + background-repeat: no-repeat; + background-size: 170px 40px; + content: ''; + display: block; + height: 40px; + width: 170px; +} +.ag-watermark-text { + font-family: Impact, sans-serif; + font-size: 19px; + font-weight: 700; + opacity: 0.5; +} +.ag-ltr .ag-watermark-text { + padding-left: 0.7rem; +} +.ag-rtl .ag-watermark-text { + padding-right: 0.7rem; +} +.ag-root-wrapper-body { + display: flex; + flex-direction: row; +} +.ag-root-wrapper-body.ag-layout-normal { + flex: 1 1 auto; + height: 0; + min-height: 0; +} +.ag-root { + display: flex; + flex-direction: column; + position: relative; +} +.ag-root.ag-layout-auto-height, +.ag-root.ag-layout-normal { + flex: 1 1 auto; + overflow: hidden; + width: 0; +} +.ag-root.ag-layout-normal { + height: 100%; +} +.ag-body-horizontal-scroll-viewport, +.ag-body-vertical-scroll-viewport, +.ag-body-viewport, +.ag-center-cols-viewport, +.ag-floating-bottom-viewport, +.ag-floating-top-viewport, +.ag-header-viewport, +.ag-sticky-bottom-viewport, +.ag-sticky-top-viewport, +.ag-virtual-list-viewport { + flex: 1 1 auto; + height: 100%; + min-width: 0; + overflow: hidden; + position: relative; +} +.ag-body-viewport, +.ag-center-cols-viewport { + -ms-overflow-style: none !important; + scrollbar-width: none !important; +} +.ag-body-viewport::-webkit-scrollbar, +.ag-center-cols-viewport::-webkit-scrollbar { + display: none !important; +} +.ag-body-viewport { + display: flex; + -webkit-overflow-scrolling: touch; +} +.ag-body-viewport.ag-layout-normal { + overflow-y: auto; +} +.ag-center-cols-viewport { + min-height: 100%; + overflow-x: auto; + width: 100%; +} +.ag-body-horizontal-scroll-viewport { + overflow-x: scroll; +} +.ag-body-vertical-scroll-viewport { + overflow-y: scroll; +} +.ag-virtual-list-viewport { + overflow: auto; + width: 100%; +} +.ag-body-container, +.ag-body-horizontal-scroll-container, +.ag-body-vertical-scroll-container, +.ag-center-cols-container, +.ag-floating-bottom-container, +.ag-floating-bottom-full-width-container, +.ag-floating-top-container, +.ag-full-width-container, +.ag-header-container, +.ag-pinned-left-cols-container, +.ag-pinned-right-cols-container, +.ag-sticky-bottom-container, +.ag-sticky-top-container, +.ag-virtual-list-container { + position: relative; +} +.ag-floating-bottom-container, +.ag-floating-top-container, +.ag-header-container, +.ag-sticky-bottom-container, +.ag-sticky-top-container { + height: 100%; + white-space: nowrap; +} +.ag-center-cols-container, +.ag-pinned-right-cols-container { + display: block; +} +.ag-body-horizontal-scroll-container { + height: 100%; +} +.ag-body-vertical-scroll-container { + width: 100%; +} +.ag-floating-bottom-full-width-container, +.ag-floating-top-full-width-container, +.ag-full-width-container, +.ag-sticky-bottom-full-width-container, +.ag-sticky-top-full-width-container { + pointer-events: none; + position: absolute; + top: 0; +} +.ag-ltr .ag-floating-bottom-full-width-container, +.ag-ltr .ag-floating-top-full-width-container, +.ag-ltr .ag-full-width-container, +.ag-ltr .ag-sticky-bottom-full-width-container, +.ag-ltr .ag-sticky-top-full-width-container { + left: 0; +} +.ag-rtl .ag-floating-bottom-full-width-container, +.ag-rtl .ag-floating-top-full-width-container, +.ag-rtl .ag-full-width-container, +.ag-rtl .ag-sticky-bottom-full-width-container, +.ag-rtl .ag-sticky-top-full-width-container { + right: 0; +} +.ag-full-width-container { + width: 100%; +} +.ag-floating-bottom-full-width-container, +.ag-floating-top-full-width-container { + display: inline-block; + height: 100%; + overflow: hidden; + width: 100%; +} +.ag-virtual-list-container { + overflow: hidden; +} +.ag-body { + display: flex; + flex: 1 1 auto; + flex-direction: row !important; + min-height: 0; + position: relative; +} +.ag-body-horizontal-scroll, +.ag-body-vertical-scroll { + display: flex; + min-height: 0; + min-width: 0; + position: relative; +} +.ag-body-horizontal-scroll.ag-scrollbar-invisible, +.ag-body-vertical-scroll.ag-scrollbar-invisible { + bottom: 0; + position: absolute; +} +.ag-body-horizontal-scroll.ag-scrollbar-invisible.ag-apple-scrollbar, +.ag-body-vertical-scroll.ag-scrollbar-invisible.ag-apple-scrollbar { + opacity: 0; + transition: opacity 0.4s; + visibility: hidden; +} +.ag-body-horizontal-scroll.ag-scrollbar-invisible.ag-apple-scrollbar.ag-scrollbar-active, +.ag-body-horizontal-scroll.ag-scrollbar-invisible.ag-apple-scrollbar.ag-scrollbar-scrolling, +.ag-body-vertical-scroll.ag-scrollbar-invisible.ag-apple-scrollbar.ag-scrollbar-active, +.ag-body-vertical-scroll.ag-scrollbar-invisible.ag-apple-scrollbar.ag-scrollbar-scrolling { + opacity: 1; + visibility: visible; +} +.ag-body-horizontal-scroll { + width: 100%; +} +.ag-body-horizontal-scroll.ag-scrollbar-invisible { + left: 0; + right: 0; +} +.ag-body-vertical-scroll { + height: 100%; +} +.ag-body-vertical-scroll.ag-scrollbar-invisible { + top: 0; + z-index: 10; +} +.ag-ltr .ag-body-vertical-scroll.ag-scrollbar-invisible { + right: 0; +} +.ag-rtl .ag-body-vertical-scroll.ag-scrollbar-invisible { + left: 0; +} +.ag-force-vertical-scroll { + overflow-y: scroll !important; +} +.ag-horizontal-left-spacer, +.ag-horizontal-right-spacer { + height: 100%; + min-width: 0; + overflow-x: scroll; +} +.ag-horizontal-left-spacer.ag-scroller-corner, +.ag-horizontal-right-spacer.ag-scroller-corner { + overflow-x: hidden; +} +.ag-ltr .ag-column-moving .ag-cell { + transition: left 0.2s; +} +.ag-rtl .ag-column-moving .ag-cell { + transition: right 0.2s; +} +.ag-ltr .ag-column-moving .ag-header-cell { + transition: left 0.2s; +} +.ag-rtl .ag-column-moving .ag-header-cell { + transition: right 0.2s; +} +.ag-ltr .ag-column-moving .ag-header-group-cell { + transition: + left 0.2s, + width 0.2s; +} +.ag-rtl .ag-column-moving .ag-header-group-cell { + transition: + right 0.2s, + width 0.2s; +} +.ag-row-animation .ag-row { + transition: + transform 0.4s, + top 0.4s, + opacity 0.2s; +} +.ag-row-animation .ag-row.ag-after-created { + transition: + transform 0.4s, + top 0.4s, + height 0.4s, + opacity 0.2s; +} +.ag-row-no-animation .ag-row { + transition: none; +} +.ag-row-loading { + align-items: center; + display: flex; +} +.ag-row-position-absolute { + position: absolute; +} +.ag-row-position-relative { + position: relative; +} +.ag-full-width-row { + overflow: hidden; + pointer-events: all; +} +.ag-row-inline-editing { + z-index: 1; +} +.ag-row-dragging { + z-index: 2; +} +.ag-stub-cell { + align-items: center; + display: flex; +} +.ag-cell { + display: inline-block; + height: 100%; + position: absolute; + white-space: nowrap; +} +.ag-cell-value { + flex: 1 1 auto; +} +.ag-cell-value, +.ag-group-value { + overflow: hidden; + text-overflow: ellipsis; +} +.ag-cell-wrap-text { + white-space: normal; + word-break: break-word; +} +.ag-sparkline-wrapper { + height: 100%; + left: 0; + position: absolute; + top: 0; + width: 100%; +} +.ag-full-width-row .ag-cell-wrapper.ag-row-group { + align-items: center; + height: 100%; +} +.ag-cell .ag-icon { + display: inline-block; + vertical-align: middle; +} +.ag-popup-child { + top: 0; + z-index: 5; +} +.ag-popup-editor { + position: absolute; + -webkit-user-select: none; + -moz-user-select: none; + user-select: none; +} +.ag-large-text-input { + display: block; +} +.ag-floating-top { + border-bottom: var(--ag-pinned-row-border); + display: flex; + overflow: hidden; + position: relative; + white-space: nowrap; + width: 100%; +} +.ag-pinned-left-floating-top, +.ag-pinned-right-floating-top { + display: inline-block; + min-width: 0; + overflow: hidden; + position: relative; +} +.ag-floating-bottom { + border-top: var(--ag-pinned-row-border); + display: flex; + overflow: hidden; + position: relative; + white-space: nowrap; + width: 100%; +} +.ag-pinned-left-floating-bottom, +.ag-pinned-right-floating-bottom { + display: inline-block; + min-width: 0; + overflow: hidden; + position: relative; +} +.ag-sticky-bottom, +.ag-sticky-top { + background-color: var(--ag-background-color); + display: flex; + position: absolute; + width: 100%; +} +.ag-pinned-left-sticky-top, +.ag-pinned-right-sticky-top { + height: 100%; + overflow: hidden; + position: relative; +} +.ag-sticky-bottom-full-width-container, +.ag-sticky-top-full-width-container { + height: 100%; + overflow: hidden; + width: 100%; +} +.ag-value-slide-out { + opacity: 1; +} +.ag-ltr .ag-value-slide-out { + margin-right: 5px; + transition: + opacity 3s, + margin-right 3s; +} +.ag-rtl .ag-value-slide-out { + margin-left: 5px; + transition: + opacity 3s, + margin-left 3s; +} +:is(.ag-ltr, .ag-rtl) .ag-value-slide-out { + transition-timing-function: linear; +} +.ag-value-slide-out-end { + opacity: 0; +} +.ag-ltr .ag-value-slide-out-end { + margin-right: 10px; +} +.ag-rtl .ag-value-slide-out-end { + margin-left: 10px; +} +.ag-opacity-zero { + opacity: 0 !important; +} +.ag-tool-panel-wrapper { + cursor: default; + display: flex; + overflow-x: hidden; + overflow-y: auto; + -webkit-user-select: none; + -moz-user-select: none; + user-select: none; +} +.ag-select-agg-func-item { + align-items: center; + display: flex; + flex-direction: row; + flex-wrap: nowrap; + height: 100%; + position: relative; +} +.ag-select-agg-func-item > * { + flex: none; +} +.ag-select-agg-func-item { + flex: 1 1 auto; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} +.ag-tool-panel-horizontal-resize { + cursor: ew-resize; + height: 100%; + position: absolute; + top: 0; + width: 5px; + z-index: 1; +} +.ag-details-row { + width: 100%; +} +.ag-details-row-fixed-height { + height: 100%; +} +.ag-details-grid { + width: 100%; +} +.ag-details-grid-fixed-height { + height: 100%; +} +.ag-cell-label-container { + align-items: center; + display: flex; + flex-direction: row-reverse; + height: 100%; + justify-content: space-between; + width: 100%; +} +.ag-right-aligned-header .ag-cell-label-container { + flex-direction: row; +} +.ag-right-aligned-header .ag-header-cell-text { + text-align: end; +} +.ag-column-group-icons { + display: block; +} +.ag-column-group-icons > * { + cursor: pointer; +} +.ag-pill-select { + display: flex; + flex-direction: column; +} +.ag-pill-select .ag-column-drop-list { + padding: 0; +} +.ag-pill-select .ag-select { + padding-top: var(--ag-grid-size); +} +.ag-pill-select .ag-picker-field-wrapper { + background-color: transparent; + border: 0; +} +.ag-pill-select .ag-picker-field-display { + cursor: pointer; +} +.ag-ltr { + direction: ltr; +} +.ag-ltr .ag-body, +.ag-ltr .ag-body-horizontal-scroll, +.ag-ltr .ag-body-viewport, +.ag-ltr .ag-floating-bottom, +.ag-ltr .ag-floating-top, +.ag-ltr .ag-header, +.ag-ltr .ag-sticky-bottom, +.ag-ltr .ag-sticky-top { + flex-direction: row; +} +.ag-rtl { + direction: rtl; +} +.ag-rtl .ag-body, +.ag-rtl .ag-body-horizontal-scroll, +.ag-rtl .ag-body-viewport, +.ag-rtl .ag-floating-bottom, +.ag-rtl .ag-floating-top, +.ag-rtl .ag-header, +.ag-rtl .ag-sticky-bottom, +.ag-rtl .ag-sticky-top { + flex-direction: row-reverse; +} +.ag-rtl .ag-icon-contracted, +.ag-rtl .ag-icon-expanded, +.ag-rtl .ag-icon-tree-closed { + display: block; + transform: rotate(180deg); +} +.ag-measurement-container { + overflow: hidden; + visibility: hidden; + width: 0; +} +.ag-measurement-container div { + position: absolute; +} +.ag-group { + position: relative; + width: 100%; +} +.ag-group-title-bar { + align-items: center; + display: flex; + padding: var(--ag-grid-size); +} +.ag-group-title { + display: inline; + min-width: 0; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} +.ag-group-title-bar .ag-group-title { + cursor: default; +} +.ag-group-toolbar { + align-items: center; + display: flex; + padding: var(--ag-grid-size); +} +.ag-group-container { + display: flex; +} +.ag-disabled .ag-group-container { + pointer-events: none; +} +.ag-disabled-group-container, +.ag-disabled-group-title-bar { + opacity: 0.5; +} +.ag-group-container-horizontal { + flex-direction: row; + flex-wrap: wrap; +} +.ag-group-container-vertical { + flex-direction: column; +} +.ag-group-title-bar-icon { + cursor: pointer; + flex: none; +} +.ag-ltr .ag-group-title-bar-icon { + margin-right: var(--ag-grid-size); +} +.ag-rtl .ag-group-title-bar-icon { + margin-left: var(--ag-grid-size); +} +.ag-group-item-alignment-stretch .ag-group-item { + align-items: stretch; +} +.ag-group-item-alignment-start .ag-group-item { + align-items: flex-start; +} +.ag-group-item-alignment-end .ag-group-item { + align-items: flex-end; +} +.ag-popup-child:not(.ag-tooltip-custom) { + box-shadow: var(--ag-popup-shadow); +} +.ag-rtl { + text-align: right; +} +.ag-ltr .ag-pivot-leaf-group { + margin-left: min( + var(--ag-row-group-indent-size), + calc(var(--ag-row-group-indent-size) * var(--ag-indentation-level)) + ); +} +.ag-rtl .ag-pivot-leaf-group { + margin-right: min( + var(--ag-row-group-indent-size), + calc(var(--ag-row-group-indent-size) * var(--ag-indentation-level)) + ); +} +.ag-ltr .ag-row-group-leaf-indent { + margin-left: calc(var(--ag-cell-widget-spacing) + var(--ag-icon-size)); +} +.ag-rtl .ag-row-group-leaf-indent { + margin-right: calc(var(--ag-cell-widget-spacing) + var(--ag-icon-size)); +} +.ag-value-change-delta { + padding: 0 2px; +} +.ag-value-change-delta-up { + color: var(--ag-value-change-delta-up-color); +} +.ag-value-change-delta-down { + color: var(--ag-value-change-delta-down-color); +} +.ag-value-change-value { + background-color: transparent; + border-radius: 1px; + padding-left: 1px; + padding-right: 1px; + transition: background-color 1s; +} +.ag-value-change-value-highlight { + background-color: var(--ag-value-change-value-highlight-background-color); + transition: background-color 0.1s; +} +.ag-cell-data-changed { + background-color: var(--ag-value-change-value-highlight-background-color) !important; +} +.ag-cell-data-changed-animation { + background-color: transparent; +} +.ag-cell-highlight { + background-color: var(--ag-range-selection-highlight-color) !important; +} +.ag-row { + background-color: var(--ag-background-color); + border-bottom: var(--ag-row-border); + color: var(--ag-cell-text-color); + height: var(--ag-row-height); + white-space: nowrap; + width: 100%; + --ag-internal-content-line-height: min(calc(var(--ag-row-height) - 1px), var(--ag-line-height, 1000px)); +} +.ag-sticky-bottom:after { + border-top: var(--ag-row-border); + content: ''; + height: 1px; + position: absolute; + top: 0; + width: 100%; +} +.ag-ltr .ag-sticky-bottom:after { + left: 0; +} +.ag-rtl .ag-sticky-bottom:after { + right: 0; +} +.ag-group-contracted, +.ag-group-expanded { + cursor: pointer; +} +.ag-cell, +.ag-full-width-row .ag-cell-wrapper.ag-row-group { + border: 1px solid transparent; + line-height: var(--ag-internal-content-line-height); +} +.ag-ltr .ag-cell { + border-right: var(--ag-column-border); +} +.ag-rtl .ag-cell { + border-left: var(--ag-column-border); +} +.ag-cell-wrapper { + align-items: center; + display: flex; +} +.ag-ltr .ag-cell-wrapper { + padding-left: calc(var(--ag-indentation-level) * var(--ag-row-group-indent-size)); +} +.ag-rtl .ag-cell-wrapper { + padding-right: calc(var(--ag-indentation-level) * var(--ag-row-group-indent-size)); +} +.ag-cell-wrapper.ag-row-group { + align-items: flex-start; +} +.ag-cell-wrapper > :not(.ag-cell-value):not(.ag-group-value) { + align-items: center; + display: flex; + height: var(--ag-internal-content-line-height); +} +.ag-ltr .ag-row > .ag-cell-wrapper.ag-row-group { + padding-left: calc(var(--ag-cell-horizontal-padding) + var(--ag-row-group-indent-size) * var(--ag-indentation-level)); +} +.ag-rtl .ag-row > .ag-cell-wrapper.ag-row-group { + padding-right: calc( + var(--ag-cell-horizontal-padding) + var(--ag-row-group-indent-size) * var(--ag-indentation-level) + ); +} +.ag-ltr .ag-group-contracted, +.ag-ltr .ag-group-expanded, +.ag-ltr .ag-row-drag, +.ag-ltr .ag-selection-checkbox { + margin-right: var(--ag-cell-widget-spacing); +} +.ag-rtl .ag-group-contracted, +.ag-rtl .ag-group-expanded, +.ag-rtl .ag-row-drag, +.ag-rtl .ag-selection-checkbox { + margin-left: var(--ag-cell-widget-spacing); +} +.ag-ltr .ag-group-child-count { + margin-left: 3px; +} +.ag-rtl .ag-group-child-count { + margin-right: 3px; +} +.ag-row-highlight-above:after, +.ag-row-highlight-below:after { + background-color: var(--ag-range-selection-border-color); + content: ''; + height: 1px; + position: absolute; + width: calc(100% - 1px); +} +.ag-ltr .ag-row-highlight-above:after, +.ag-ltr .ag-row-highlight-below:after { + left: 1px; +} +.ag-rtl .ag-row-highlight-above:after, +.ag-rtl .ag-row-highlight-below:after { + right: 1px; +} +.ag-row-highlight-above:after { + top: -1px; +} +.ag-row-highlight-above.ag-row-first:after { + top: 0; +} +.ag-row-highlight-below:after { + bottom: 0; +} +.ag-row-odd { + background-color: var(--ag-odd-row-background-color); +} +.ag-row-selected:before { + background-color: var(--ag-selected-row-background-color); + content: ''; + display: block; + inset: 0; + pointer-events: none; + position: absolute; +} +.ag-row-hover.ag-full-width-row.ag-row-group:before, +.ag-row-hover:not(.ag-full-width-row):before { + background-color: var(--ag-row-hover-color); + content: ''; + display: block; + inset: 0; + pointer-events: none; + position: absolute; +} +.ag-row-hover.ag-row-selected:before { + background-color: var(--ag-row-hover-color); + background-image: linear-gradient(var(--ag-selected-row-background-color), var(--ag-selected-row-background-color)); +} +.ag-row-hover.ag-full-width-row.ag-row-group > * { + position: relative; +} +.ag-column-hover { + background-color: var(--ag-column-hover-color); +} +.ag-ltr .ag-right-aligned-cell { + text-align: right; +} +.ag-rtl .ag-right-aligned-cell { + text-align: left; +} +.ag-right-aligned-cell .ag-cell-value, +.ag-right-aligned-cell .ag-group-value { + margin-left: auto; +} +.ag-cell, +.ag-full-width-row .ag-cell-wrapper.ag-row-group { + -webkit-font-smoothing: subpixel-antialiased; +} +.ag-ltr .ag-cell, +.ag-ltr .ag-full-width-row .ag-cell-wrapper.ag-row-group { + padding-left: calc( + var(--ag-cell-horizontal-padding) - 1px + var(--ag-row-group-indent-size) * var(--ag-indentation-level) + ); + padding-right: calc(var(--ag-cell-horizontal-padding) - 1px); +} +.ag-rtl .ag-cell, +.ag-rtl .ag-full-width-row .ag-cell-wrapper.ag-row-group { + padding-left: calc(var(--ag-cell-horizontal-padding) - 1px); + padding-right: calc( + var(--ag-cell-horizontal-padding) - 1px + var(--ag-row-group-indent-size) * var(--ag-indentation-level) + ); +} +.ag-row > .ag-cell-wrapper { + padding-left: calc(var(--ag-cell-horizontal-padding) - 1px); + padding-right: calc(var(--ag-cell-horizontal-padding) - 1px); +} +.ag-row-dragging { + cursor: move; + opacity: 0.5; +} +.ag-details-row { + background-color: var(--ag-background-color); + padding: calc(var(--ag-grid-size) * 3.5); +} +.ag-layout-auto-height .ag-center-cols-container, +.ag-layout-auto-height .ag-center-cols-viewport, +.ag-layout-print .ag-center-cols-container, +.ag-layout-print .ag-center-cols-viewport { + min-height: 150px; +} +.ag-overlay-loading-wrapper { + background-color: var(--ag-modal-overlay-background-color); +} +.ag-overlay-no-rows-wrapper.ag-layout-auto-height { + padding-top: 60px; +} +.ag-skeleton-container { + align-content: center; + height: 100%; + width: 100%; +} +.ag-skeleton-effect { + animation: ag-skeleton-loading 1.5s ease-in-out 0.5s infinite; + background-color: var(--ag-row-loading-skeleton-effect-color); + border-radius: 0.25rem; + height: 1em; + width: 100%; +} +.ag-ltr .ag-right-aligned-cell .ag-skeleton-effect { + margin-left: auto; +} +.ag-rtl .ag-right-aligned-cell .ag-skeleton-effect { + margin-right: auto; +} +@keyframes ag-skeleton-loading { + 0% { + opacity: 1; + } + 50% { + opacity: 0.4; + } + to { + opacity: 1; + } +} +.ag-loading { + align-items: center; + display: flex; + height: 100%; +} +.ag-ltr .ag-loading { + padding-left: var(--ag-cell-horizontal-padding); +} +.ag-rtl .ag-loading { + padding-right: var(--ag-cell-horizontal-padding); +} +.ag-ltr .ag-loading-icon { + padding-right: var(--ag-cell-widget-spacing); +} +.ag-rtl .ag-loading-icon { + padding-left: var(--ag-cell-widget-spacing); +} +.ag-icon-loading { + animation-duration: 1s; + animation-iteration-count: infinite; + animation-name: spin; + animation-timing-function: linear; +} +@keyframes spin { + 0% { + transform: rotate(0deg); + } + to { + transform: rotate(1turn); + } +} +.ag-details-row { + padding: calc(var(--ag-grid-size) * 3.75); +} +.ag-body-viewport:not(.ag-has-focus) .ag-cell-range-single-cell:not(.ag-cell-inline-editing), +.ag-cell-range-selected:not(.ag-cell-focus) { + background-color: var(--ag-range-selection-background-color); +} +.ag-cell-range-chart:is( + .ag-cell-range-selected:not(.ag-cell-focus), + .ag-body-viewport:not(.ag-has-focus) .ag-cell-range-single-cell:not(.ag-cell-inline-editing) + ) { + background-color: var(--ag-range-selection-chart-background-color) !important; +} +.ag-cell-range-chart.ag-cell-range-chart-category:is( + .ag-cell-range-selected:not(.ag-cell-focus), + .ag-body-viewport:not(.ag-has-focus) .ag-cell-range-single-cell:not(.ag-cell-inline-editing) + ) { + background-color: var(--ag-range-selection-chart-category-background-color) !important; +} +.ag-cell-range-selected-1:not(.ag-cell-focus), +.ag-root:not(.ag-context-menu-open) + .ag-body-viewport:not(.ag-has-focus) + .ag-cell-range-selected-1:not(.ag-cell-inline-editing) { + background-color: var(--ag-range-selection-background-color); +} +.ag-cell-range-selected-2:not(.ag-cell-focus) { + background-image: linear-gradient( + var(--ag-range-selection-background-color), + var(--ag-range-selection-background-color) + ); +} +.ag-cell-range-selected-3:not(.ag-cell-focus) { + background-image: linear-gradient( + var(--ag-range-selection-background-color), + var(--ag-range-selection-background-color) + ), + linear-gradient(var(--ag-range-selection-background-color), var(--ag-range-selection-background-color)); +} +.ag-cell-range-selected-4:not(.ag-cell-focus) { + background-image: linear-gradient( + var(--ag-range-selection-background-color), + var(--ag-range-selection-background-color) + ), + linear-gradient(var(--ag-range-selection-background-color), var(--ag-range-selection-background-color)), + linear-gradient(var(--ag-range-selection-background-color), var(--ag-range-selection-background-color)); +} +.ag-cell.ag-cell-range-selected.ag-cell-range-top:not(.ag-cell-range-single-cell) { + border-top-color: var(--ag-range-selection-border-color); + border-top-style: var(--ag-range-selection-border-style); +} +.ag-cell.ag-cell-range-selected.ag-cell-range-right:not(.ag-cell-range-single-cell) { + border-right-color: var(--ag-range-selection-border-color); + border-right-style: var(--ag-range-selection-border-style); +} +.ag-cell.ag-cell-range-selected.ag-cell-range-bottom:not(.ag-cell-range-single-cell) { + border-bottom-color: var(--ag-range-selection-border-color); + border-bottom-style: var(--ag-range-selection-border-style); +} +.ag-cell.ag-cell-range-selected.ag-cell-range-left:not(.ag-cell-range-single-cell) { + border-left-color: var(--ag-range-selection-border-color); + border-left-style: var(--ag-range-selection-border-style); +} +.ag-ltr .ag-cell-focus:not(.ag-cell-range-selected):focus-within, +.ag-ltr .ag-cell-range-single-cell, +.ag-ltr .ag-cell-range-single-cell.ag-cell-range-handle, +.ag-ltr .ag-context-menu-open .ag-cell-focus:not(.ag-cell-range-selected), +.ag-ltr .ag-full-width-row.ag-row-focus:focus .ag-cell-wrapper.ag-row-group, +.ag-rtl .ag-cell-focus:not(.ag-cell-range-selected):focus-within, +.ag-rtl .ag-cell-range-single-cell, +.ag-rtl .ag-cell-range-single-cell.ag-cell-range-handle, +.ag-rtl .ag-context-menu-open .ag-cell-focus:not(.ag-cell-range-selected), +.ag-rtl .ag-full-width-row.ag-row-focus:focus .ag-cell-wrapper.ag-row-group { + border: 1px solid; + border-color: var(--ag-range-selection-border-color); + border-style: var(--ag-range-selection-border-style); + outline: initial; +} +.ag-cell.ag-selection-fill-top, +.ag-cell.ag-selection-fill-top.ag-cell-range-selected { + border-top: 1px dashed; + border-top-color: var(--ag-range-selection-border-color); +} +.ag-ltr .ag-cell.ag-selection-fill-right, +.ag-ltr .ag-cell.ag-selection-fill-right.ag-cell-range-selected { + border-right: 1px dashed var(--ag-range-selection-border-color) !important; +} +.ag-rtl .ag-cell.ag-selection-fill-right, +.ag-rtl .ag-cell.ag-selection-fill-right.ag-cell-range-selected { + border-left: 1px dashed var(--ag-range-selection-border-color) !important; +} +.ag-cell.ag-selection-fill-bottom, +.ag-cell.ag-selection-fill-bottom.ag-cell-range-selected { + border-bottom: 1px dashed; + border-bottom-color: var(--ag-range-selection-border-color); +} +.ag-ltr .ag-cell.ag-selection-fill-left, +.ag-ltr .ag-cell.ag-selection-fill-left.ag-cell-range-selected { + border-left: 1px dashed var(--ag-range-selection-border-color) !important; +} +.ag-rtl .ag-cell.ag-selection-fill-left, +.ag-rtl .ag-cell.ag-selection-fill-left.ag-cell-range-selected { + border-right: 1px dashed var(--ag-range-selection-border-color) !important; +} +.ag-fill-handle, +.ag-range-handle { + background-color: var(--ag-range-selection-border-color); + bottom: -1px; + height: 6px; + position: absolute; + width: 6px; +} +.ag-ltr .ag-fill-handle, +.ag-ltr .ag-range-handle { + right: -1px; +} +.ag-rtl .ag-fill-handle, +.ag-rtl .ag-range-handle { + left: -1px; +} +.ag-fill-handle { + cursor: cell; +} +.ag-ltr .ag-range-handle { + cursor: nwse-resize; +} +.ag-rtl .ag-range-handle { + cursor: nesw-resize; +} +.ag-input-wrapper, +.ag-picker-field-wrapper { + align-items: center; + display: flex; + flex: 1 1 auto; + line-height: normal; + position: relative; +} +.ag-input-field { + align-items: center; + display: flex; + flex-direction: row; +} +.ag-input-field-input { + flex: 1 1 auto; +} +.ag-floating-filter-input .ag-input-field-input[type='date'] { + width: 1px; +} +.ag-input-field-input { + min-width: 0; + width: 100%; +} +.ag-column-select-header-filter-wrapper .ag-input-wrapper:before, +.ag-filter-filter .ag-input-wrapper:before, +.ag-filter-toolpanel-search .ag-input-wrapper:before, +.ag-mini-filter .ag-input-wrapper:before { + background-color: currentColor; + content: ''; + display: block; + height: 12px; + -webkit-mask-image: url('data:image/svg+xml;charset=utf-8;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxMiIgaGVpZ2h0PSIxMiIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjMDAwIiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiIHN0cm9rZS13aWR0aD0iMS41Ij48cGF0aCBkPSJNNS4zIDlhMy43IDMuNyAwIDEgMCAwLTcuNSAzLjcgMy43IDAgMCAwIDAgNy41Wk0xMC41IDEwLjUgOC4zIDguMiIvPjwvc3ZnPg=='); + mask-image: url('data:image/svg+xml;charset=utf-8;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxMiIgaGVpZ2h0PSIxMiIgZmlsbD0ibm9uZSIgc3Ryb2tlPSIjMDAwIiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiIHN0cm9rZS13aWR0aD0iMS41Ij48cGF0aCBkPSJNNS4zIDlhMy43IDMuNyAwIDEgMCAwLTcuNSAzLjcgMy43IDAgMCAwIDAgNy41Wk0xMC41IDEwLjUgOC4zIDguMiIvPjwvc3ZnPg=='); + -webkit-mask-position: center; + mask-position: center; + -webkit-mask-repeat: no-repeat; + mask-repeat: no-repeat; + opacity: 50%; + position: absolute; + width: 12px; +} +.ag-ltr .ag-column-select-header-filter-wrapper .ag-input-wrapper:before, +.ag-ltr .ag-filter-filter .ag-input-wrapper:before, +.ag-ltr .ag-filter-toolpanel-search .ag-input-wrapper:before, +.ag-ltr .ag-mini-filter .ag-input-wrapper:before { + margin-left: var(--ag-grid-size); +} +.ag-rtl .ag-column-select-header-filter-wrapper .ag-input-wrapper:before, +.ag-rtl .ag-filter-filter .ag-input-wrapper:before, +.ag-rtl .ag-filter-toolpanel-search .ag-input-wrapper:before, +.ag-rtl .ag-mini-filter .ag-input-wrapper:before { + margin-right: var(--ag-grid-size); +} +.ag-ltr .ag-column-select-header-filter-wrapper input.ag-number-field-input, +.ag-ltr .ag-column-select-header-filter-wrapper input.ag-text-field-input, +.ag-ltr .ag-filter-filter input.ag-number-field-input, +.ag-ltr .ag-filter-filter input.ag-text-field-input, +.ag-ltr .ag-filter-toolpanel-search input.ag-number-field-input, +.ag-ltr .ag-filter-toolpanel-search input.ag-text-field-input, +.ag-ltr .ag-mini-filter input.ag-number-field-input, +.ag-ltr .ag-mini-filter input.ag-text-field-input { + padding-left: 26px; +} +.ag-rtl .ag-column-select-header-filter-wrapper input.ag-number-field-input, +.ag-rtl .ag-column-select-header-filter-wrapper input.ag-text-field-input, +.ag-rtl .ag-filter-filter input.ag-number-field-input, +.ag-rtl .ag-filter-filter input.ag-text-field-input, +.ag-rtl .ag-filter-toolpanel-search input.ag-number-field-input, +.ag-rtl .ag-filter-toolpanel-search input.ag-text-field-input, +.ag-rtl .ag-mini-filter input.ag-number-field-input, +.ag-rtl .ag-mini-filter input.ag-text-field-input { + padding-right: 26px; +} +.ag-advanced-filter-header { + align-items: center; + background-color: var(--ag-header-background-color); + border-bottom: var(--ag-header-row-border); + display: flex; + padding-left: var(--ag-cell-horizontal-padding); + padding-right: var(--ag-cell-horizontal-padding); + position: relative; +} +.ag-advanced-filter { + align-items: center; + display: flex; + width: 100%; +} +.ag-advanced-filter-apply-button, +.ag-advanced-filter-builder-button { + line-height: normal; + white-space: nowrap; +} +.ag-ltr .ag-advanced-filter-apply-button, +.ag-ltr .ag-advanced-filter-builder-button { + margin-left: calc(var(--ag-grid-size) * 2); +} +.ag-rtl .ag-advanced-filter-apply-button, +.ag-rtl .ag-advanced-filter-builder-button { + margin-right: calc(var(--ag-grid-size) * 2); +} +.ag-advanced-filter-builder-button { + align-items: center; + background-color: unset; + border: 0; + display: flex; + font-size: var(--ag-font-size); + font-weight: 600; + padding: var(--ag-grid-size); +} +.ag-advanced-filter-builder-button:hover:not(:disabled) { + background-color: var(--ag-row-hover-color); +} +.ag-advanced-filter-builder-button:not(:disabled) { + cursor: pointer; +} +.ag-ltr .ag-advanced-filter-builder-button-label { + margin-left: var(--ag-grid-size); +} +.ag-rtl .ag-advanced-filter-builder-button-label { + margin-right: var(--ag-grid-size); +} +.ag-advanced-filter-builder { + background-color: var(--ag-chrome-background-color); + display: flex; + flex-direction: column; + -webkit-user-select: none; + -moz-user-select: none; + user-select: none; + width: 100%; +} +.ag-advanced-filter-builder-list { + flex: 1; + overflow: auto; +} +.ag-advanced-filter-builder-button-panel { + border-top: var(--ag-advanced-filter-builder-button-bar-border); + display: flex; + justify-content: flex-end; + padding: var(--ag-widget-container-vertical-padding) var(--ag-widget-container-horizontal-padding); +} +.ag-ltr .ag-advanced-filter-builder .ag-advanced-filter-builder-button-panel .ag-advanced-filter-builder-apply-button, +.ag-ltr .ag-advanced-filter-builder .ag-advanced-filter-builder-button-panel .ag-advanced-filter-builder-cancel-button { + margin-left: calc(var(--ag-grid-size) * 2); +} +.ag-rtl .ag-advanced-filter-builder .ag-advanced-filter-builder-button-panel .ag-advanced-filter-builder-apply-button, +.ag-rtl .ag-advanced-filter-builder .ag-advanced-filter-builder-button-panel .ag-advanced-filter-builder-cancel-button { + margin-right: calc(var(--ag-grid-size) * 2); +} +.ag-advanced-filter-builder-item-wrapper { + align-items: center; + display: flex; + flex: 1 1 auto; + justify-content: space-between; + overflow: hidden; +} +.ag-ltr .ag-advanced-filter-builder-item-wrapper { + padding-left: calc(var(--ag-icon-size) / 2); + padding-right: var(--ag-icon-size); +} +.ag-rtl .ag-advanced-filter-builder-item-wrapper { + padding-left: var(--ag-icon-size); + padding-right: calc(var(--ag-icon-size) / 2); +} +.ag-virtual-list-viewport .ag-advanced-filter-builder-item-wrapper .ag-tab-guard { + position: absolute; +} +.ag-advanced-filter-builder-item-tree-lines > * { + width: var(--ag-advanced-filter-builder-indent-size); +} +.ag-advanced-filter-builder-item-tree-lines .ag-advanced-filter-builder-item-tree-line-root { + width: var(--ag-icon-size); +} +.ag-advanced-filter-builder-item-tree-lines .ag-advanced-filter-builder-item-tree-line-root:before { + height: 50%; + top: 50%; +} +.ag-advanced-filter-builder-item-tree-line-horizontal, +.ag-advanced-filter-builder-item-tree-line-vertical, +.ag-advanced-filter-builder-item-tree-line-vertical-bottom, +.ag-advanced-filter-builder-item-tree-line-vertical-top { + align-items: center; + display: flex; + height: 100%; + position: relative; +} +.ag-advanced-filter-builder-item-tree-line-horizontal:after, +.ag-advanced-filter-builder-item-tree-line-horizontal:before, +.ag-advanced-filter-builder-item-tree-line-vertical-bottom:after, +.ag-advanced-filter-builder-item-tree-line-vertical-bottom:before, +.ag-advanced-filter-builder-item-tree-line-vertical-top:after, +.ag-advanced-filter-builder-item-tree-line-vertical-top:before, +.ag-advanced-filter-builder-item-tree-line-vertical:after, +.ag-advanced-filter-builder-item-tree-line-vertical:before { + content: ''; + height: 100%; + position: absolute; +} +.ag-advanced-filter-builder-item-tree-line-horizontal:after { + border-bottom: 1px solid var(--ag-border-color); + height: 50%; + top: 0; + width: calc(var(--ag-advanced-filter-builder-indent-size) - var(--ag-icon-size)); +} +.ag-ltr .ag-advanced-filter-builder-item-tree-line-horizontal:after { + left: calc(var(--ag-icon-size) / 2); +} +.ag-rtl .ag-advanced-filter-builder-item-tree-line-horizontal:after { + right: calc(var(--ag-icon-size) / 2); +} +.ag-advanced-filter-builder-item-tree-line-vertical:before { + top: 0; + width: calc(var(--ag-advanced-filter-builder-indent-size) - var(--ag-icon-size) / 2); +} +.ag-ltr .ag-advanced-filter-builder-item-tree-line-vertical:before { + border-left: 1px solid var(--ag-border-color); + left: calc(var(--ag-icon-size) / 2); +} +.ag-rtl .ag-advanced-filter-builder-item-tree-line-vertical:before { + border-right: 1px solid var(--ag-border-color); + right: calc(var(--ag-icon-size) / 2); +} +.ag-advanced-filter-builder-item-tree-line-vertical-top:before { + height: 50%; + top: 0; + width: calc(var(--ag-advanced-filter-builder-indent-size) - var(--ag-icon-size) / 2); +} +.ag-ltr .ag-advanced-filter-builder-item-tree-line-vertical-top:before { + border-left: 1px solid var(--ag-border-color); + left: calc(var(--ag-icon-size) / 2); +} +.ag-rtl .ag-advanced-filter-builder-item-tree-line-vertical-top:before { + border-right: 1px solid var(--ag-border-color); + right: calc(var(--ag-icon-size) / 2); +} +.ag-advanced-filter-builder-item-tree-line-vertical-bottom:before { + height: calc(50% - var(--ag-icon-size) * 1.5 / 2); + top: calc(50% + var(--ag-icon-size) * 1.5 / 2); + width: calc(var(--ag-icon-size) / 2); +} +.ag-ltr .ag-advanced-filter-builder-item-tree-line-vertical-bottom:before { + border-left: 1px solid var(--ag-border-color); + left: calc(var(--ag-icon-size) / 2); +} +.ag-rtl .ag-advanced-filter-builder-item-tree-line-vertical-bottom:before { + border-right: 1px solid var(--ag-border-color); + right: calc(var(--ag-icon-size) / 2); +} +.ag-advanced-filter-builder-item-condition { + padding-bottom: var(--ag-grid-size); + padding-top: var(--ag-grid-size); +} +.ag-advanced-filter-builder-item, +.ag-advanced-filter-builder-item-buttons, +.ag-advanced-filter-builder-item-condition, +.ag-advanced-filter-builder-item-tree-lines, +.ag-advanced-filter-builder-pill, +.ag-advanced-filter-builder-pill-wrapper { + align-items: center; + display: flex; + height: 100%; +} +.ag-advanced-filter-builder-pill-wrapper { + margin: 0 var(--ag-grid-size); +} +.ag-advanced-filter-builder-pill { + border-radius: var(--ag-border-radius); + min-height: calc(100% - var(--ag-grid-size) * 3); + min-width: calc(var(--ag-grid-size) * 2); + padding: var(--ag-grid-size) calc(var(--ag-grid-size) * 2); + position: relative; +} +.ag-ltr .ag-advanced-filter-builder-pill .ag-picker-field-display { + margin-right: var(--ag-grid-size); +} +.ag-rtl .ag-advanced-filter-builder-pill .ag-picker-field-display { + margin-left: var(--ag-grid-size); +} +.ag-advanced-filter-builder-pill .ag-advanced-filter-builder-value-number { + font-family: monospace; + font-weight: 700; +} +.ag-advanced-filter-builder-pill .ag-advanced-filter-builder-value-empty { + color: var(--ag-subtle-text-color); +} +.ag-advanced-filter-builder-item-button:focus-visible, +.ag-advanced-filter-builder-pill:focus-visible { + shadow: var(--ag-focus-shadow); +} +.ag-advanced-filter-builder-pill-display { + font-weight: 500; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} +.ag-advanced-filter-builder-join-pill { + background-color: var(--ag-advanced-filter-builder-join-pill-color); + cursor: pointer; +} +.ag-advanced-filter-builder-column-pill { + background-color: var(--ag-advanced-filter-builder-column-pill-color); + cursor: pointer; +} +.ag-advanced-filter-builder-option-pill { + background-color: var(--ag-advanced-filter-builder-option-pill-color); + cursor: pointer; +} +.ag-advanced-filter-builder-value-pill { + background-color: var(--ag-advanced-filter-builder-value-pill-color); + cursor: text; + max-width: 140px; +} +.ag-advanced-filter-builder-value-pill .ag-advanced-filter-builder-pill-display { + display: block; +} +.ag-advanced-filter-builder-item-buttons > * { + margin: 0 calc(var(--ag-grid-size) * 0.5); +} +.ag-advanced-filter-builder-item-button { + color: var(--ag-subtle-text-color); + cursor: pointer; + position: relative; +} +.ag-advanced-filter-builder-item-button-disabled { + cursor: default; + opacity: 0.5; +} +.ag-advanced-filter-builder-virtual-list-container { + top: var(--ag-grid-size); +} +.ag-advanced-filter-builder-virtual-list-item { + cursor: default; + display: flex; + height: var(--ag-list-item-height); +} +.ag-advanced-filter-builder-virtual-list-item:hover { + background-color: var(--ag-row-hover-color); +} +.ag-advanced-filter-builder-virtual-list-item:hover .ag-advanced-filter-builder-item-button { + opacity: 100%; +} +.ag-advanced-filter-builder-validation .ag-advanced-filter-builder-invalid, +.ag-advanced-filter-builder-virtual-list-item-highlight .ag-advanced-filter-builder-item-button:focus-visible { + opacity: 100%; +} +.ag-advanced-filter-builder-invalid { + color: var(--ag-invalid-color); + cursor: default; + margin: 0 var(--ag-grid-size); +} +.ag-cell-inline-editing { + border-radius: var(--ag-border-radius); + padding: 0; + z-index: 1; +} +.ag-cell-inline-editing .ag-cell-edit-wrapper, +.ag-cell-inline-editing .ag-cell-editor, +.ag-cell-inline-editing .ag-cell-editor .ag-wrapper, +.ag-cell-inline-editing .ag-cell-editor input, +.ag-cell-inline-editing .ag-cell-wrapper { + height: 100%; + line-height: normal; + width: 100%; +} +.ag-autocomplete-list-popup, +.ag-popup-editor .ag-large-text { + background-color: var(--ag-background-color); + border-radius: var(--ag-border-radius); + box-shadow: var(--ag-dropdown-shadow); + padding: 0; +} +.ag-large-text-input { + height: auto; + padding: var(--ag-cell-horizontal-padding); +} +.ag-rtl .ag-large-text-input textarea { + resize: none; +} +.ag-checkbox-edit { + padding-left: var(--ag-cell-horizontal-padding); + padding-right: var(--ag-cell-horizontal-padding); +} +.ag-chart { + height: 100%; + width: 100%; +} +.ag-chart, +.ag-chart-components-wrapper { + display: flex; + overflow: hidden; + position: relative; +} +.ag-chart-components-wrapper { + flex: 1 1 auto; +} +.ag-chart-canvas-wrapper { + flex: 1 1 auto; + overflow: hidden; + position: relative; +} +.ag-chart-menu { + display: flex; + flex-direction: column; + position: absolute; + top: 16px; +} +.ag-ltr .ag-chart-menu { + right: 20px; +} +.ag-rtl .ag-chart-menu { + left: 20px; +} +.ag-chart-docked-container { + min-width: var(--ag-chart-menu-panel-width); + position: relative; +} +.ag-chart-menu-hidden ~ .ag-chart-docked-container { + display: none; +} +.ag-chart-tabbed-menu { + display: flex; + flex-direction: column; + height: 100%; + overflow: hidden; + width: 100%; +} +.ag-chart-tabbed-menu-header { + cursor: default; + flex: none; + -webkit-user-select: none; + -moz-user-select: none; + user-select: none; +} +.ag-chart-tabbed-menu-body { + align-items: stretch; + display: flex; + flex: 1 1 auto; + overflow: hidden; +} +.ag-chart-tab { + overflow: hidden; + overflow-y: auto; + width: 100%; +} +.ag-chart-settings { + overflow-x: hidden; +} +.ag-chart-settings-wrapper { + display: flex; + flex-direction: column; + height: 100%; + overflow: hidden; + position: relative; + width: 100%; +} +.ag-chart-settings-nav-bar { + align-items: center; + display: flex; + height: 30px; + padding: 0 10px; + -webkit-user-select: none; + -moz-user-select: none; + user-select: none; + width: 100%; +} +.ag-chart-settings-card-selector { + align-items: center; + display: flex; + flex: 1 1 auto; + height: 100%; + justify-content: space-around; + padding: 0 10px; +} +.ag-chart-settings-card-item { + background-color: var(--ag-foreground-color); + border-radius: 4px; + cursor: pointer; + height: 10px; + height: 8px; + position: relative; + width: 10px; + width: 8px; +} +.ag-chart-settings-card-item.ag-not-selected { + opacity: 0.2; +} +.ag-chart-settings-card-item:before { + background-color: transparent; + content: ' '; + display: block; + height: 20px; + left: 50%; + margin-left: -10px; + margin-top: -10px; + position: absolute; + top: 50%; + width: 20px; +} +.ag-chart-settings-card-item.ag-selected { + background-color: var(--ag-accent-color); +} +.ag-chart-settings-next, +.ag-chart-settings-prev { + flex: none; + position: relative; +} +.ag-chart-settings-next:focus-within, +.ag-chart-settings-prev:focus-within { + border-radius: 1px; + box-shadow: var(--ag-focus-shadow); +} +.ag-chart-settings-next-button, +.ag-chart-settings-prev-button { + cursor: pointer; + height: 100%; + left: 0; + opacity: 0; + position: absolute; + top: 0; + width: 100%; +} +.ag-chart-settings-mini-charts-container { + flex: 1 1 auto; + overflow-x: hidden; + overflow-y: auto; + position: relative; +} +.ag-chart-settings-mini-wrapper { + display: flex; + flex-direction: column; + left: 0; + min-height: 100%; + overflow: hidden; + position: absolute; + top: 0; + width: 100%; +} +.ag-chart-settings-mini-wrapper.ag-animating { + transition: left 0.3s; + transition-timing-function: ease-in-out; +} +.ag-chart-mini-thumbnail { + cursor: pointer; +} +.ag-chart-mini-thumbnail-canvas { + display: block; +} +.ag-chart-advanced-settings-wrapper, +.ag-chart-data-wrapper, +.ag-chart-format-wrapper { + display: flex; + flex-direction: column; + padding-bottom: 16px; + position: relative; + -webkit-user-select: none; + -moz-user-select: none; + user-select: none; +} +.ag-chart-advanced-settings-wrapper, +.ag-chart-data-wrapper { + height: 100%; + overflow-y: auto; +} +.ag-chart-advanced-settings { + background-color: var(--ag-chrome-background-color); +} +.ag-chart-advanced-settings, +.ag-chart-advanced-settings-wrapper { + width: 100%; +} +.ag-chart-advanced-settings-wrapper { + padding-bottom: 0; +} +.ag-chart-advanced-settings-section, +.ag-chart-data-section, +.ag-chart-format-section { + display: flex; + margin: 0; +} +.ag-chart-advanced-settings-section { + border-bottom: 1px solid var(--ag-border-color); +} +.ag-chart-empty-text { + align-items: center; + background-color: var(--ag-background-color); + display: flex; + height: 100%; + justify-content: center; + top: 0; + width: 100%; +} +.ag-chart .ag-chart-menu { + display: none; +} +.ag-chart-menu-hidden:hover .ag-chart-menu { + display: block; +} +.ag-chart .ag-chart-menu-wrapper .ag-chart-menu { + display: flex; + flex-direction: row; + gap: 20px; + top: 8px; + width: auto; +} +.ag-ltr .ag-chart .ag-chart-menu-wrapper .ag-chart-menu { + justify-content: right; + right: calc(var(--ag-cell-horizontal-padding) + var(--ag-grid-size) - 4px); +} +.ag-rtl .ag-chart .ag-chart-menu-wrapper .ag-chart-menu { + justify-content: left; + left: calc(var(--ag-cell-horizontal-padding) + var(--ag-grid-size) - 4px); +} +.ag-charts-font-size-color { + align-self: stretch; + display: flex; + justify-content: space-between; +} +.ag-charts-data-group-item { + position: relative; +} +.ag-charts-data-group-item:not(:last-child) { + margin-bottom: var(--ag-grid-size); +} +.ag-chart-menu { + background: var(--ag-background-color); +} +.ag-chart-menu, +.ag-chart-menu-icon { + border-radius: var(--ag-border-radius); +} +.ag-chart-menu-icon { + cursor: pointer; + margin: 2px 0; + opacity: 0.5; + opacity: 0.8; +} +.ag-chart-menu-icon:hover { + opacity: 1; +} +.ag-chart-menu-toolbar-button { + background-color: unset; + border: 0; + border-radius: 1px; + padding: 0 2px; +} +.ag-chart-mini-thumbnail { + border: 1px solid var(--ag-border-color); + border-radius: 5px; +} +.ag-chart-mini-thumbnail.ag-selected { + border-color: var(--ag-accent-color); + border-width: 2px; +} +.ag-chart-mini-thumbnail:focus-visible { + border-color: var(--ag-accent-color); + box-shadow: var(--ag-focus-shadow); +} +.ag-chart-data-column-drag-handle { + margin-left: var(--ag-grid-size); +} +.ag-charts-data-group-title-bar, +.ag-charts-format-top-level-group-title-bar, +.ag-charts-settings-group-title-bar { + position: relative; +} +.ag-charts-advanced-settings-top-level-group-title-bar { + background-color: unset; + position: relative; +} +.ag-charts-advanced-settings-top-level-group-title-bar:focus-visible, +.ag-charts-data-group-title-bar:focus-visible, +.ag-charts-format-top-level-group-title-bar:focus-visible, +.ag-charts-settings-group-title-bar:focus-visible { + box-shadow: inset var(--ag-focus-shadow); +} +.ag-charts-data-group-container { + padding: calc(var(--ag-widget-container-vertical-padding) * 0.5) var(--ag-widget-container-horizontal-padding); +} +.ag-charts-data-group-container + .ag-charts-data-group-item:not(.ag-charts-format-sub-level-group):not(.ag-pill-select):not(.ag-select) { + height: var(--ag-list-item-height); +} +.ag-charts-data-group-container .ag-charts-data-group-item.ag-picker-field { + margin-top: var(--ag-grid-size); +} +.ag-charts-advanced-settings-top-level-group-container, +.ag-charts-format-top-level-group-container { + margin-left: calc(var(--ag-grid-size) * 2); + padding: var(--ag-grid-size); +} +.ag-charts-advanced-settings-top-level-group-item, +.ag-charts-format-top-level-group-item { + margin: var(--ag-grid-size) 0; +} +.ag-charts-format-sub-level-group-container { + display: flex; + flex-direction: column; + gap: var(--ag-widget-vertical-spacing); + padding: var(--ag-widget-container-vertical-padding) var(--ag-widget-container-horizontal-padding); +} +.ag-charts-settings-group-container { + display: grid; + grid-template-columns: 60px 1fr 60px 1fr 60px; + padding: var(--ag-grid-size); + row-gap: 8px; +} +.ag-charts-settings-group-container .ag-chart-mini-thumbnail:nth-child(3n + 1) { + grid-column: 1; +} +.ag-charts-settings-group-container .ag-chart-mini-thumbnail:nth-child(3n + 2) { + grid-column: 3; +} +.ag-charts-settings-group-container .ag-chart-mini-thumbnail:nth-child(3n + 3) { + grid-column: 5; +} +.ag-chart-data-section, +.ag-chart-format-section { + display: flex; + margin: 0; +} +.ag-chart-menu-panel { + background-color: var(--ag-chrome-background-color); +} +.ag-ltr .ag-chart-menu-panel { + border-left: 1px solid var(--ag-border-color); +} +.ag-rtl .ag-chart-menu-panel { + border-right: 1px solid var(--ag-border-color); +} +.ag-chart-tabbed-menu-body { + position: relative; +} +.ag-chart-tabbed-menu-body:after { + background: linear-gradient(var(--ag-background-color), transparent); + content: ''; + display: block; + height: 16px; + left: 0; + position: absolute; + right: 0; + top: 0; +} +.ag-charts-data-group-title-bar, +.ag-charts-format-top-level-group-title-bar, +.ag-charts-settings-group-container, +.ag-charts-settings-group-title-bar { + border-top: none; + font-weight: 500; + padding: 0 calc(var(--ag-grid-size) * 1.5); +} +.ag-chart-settings-nav-bar { + border-top: 1px solid var(--ag-border-color); +} +.ag-charts-format-sub-level-group-title-bar { + background: none; + font-weight: 500; +} +.ag-chart-data-section .ag-label:not(.ag-group-title-bar), +.ag-chart-format-section .ag-label:not(.ag-group-title-bar) { + color: var(--ag-chart-menu-label-color); +} +.ag-chart-data-section .ag-label-align-top .ag-label, +.ag-chart-format-section .ag-label-align-top .ag-label { + margin-bottom: var(--ag-widget-vertical-spacing); + margin-top: calc(var(--ag-widget-vertical-spacing) * 0.5); +} +.ag-chart-data-section .ag-slider.ag-label-align-top .ag-label, +.ag-chart-format-section .ag-slider.ag-label-align-top .ag-label { + margin-bottom: 0; +} +.ag-chart-data-section label, +.ag-chart-format-section label { + display: inline-block; +} +.ag-chart-data-wrapper, +.ag-chart-format-wrapper, +.ag-charts-data-group-container, +.ag-charts-data-group-title-bar, +.ag-charts-format-sub-level-group, +.ag-charts-format-sub-level-group-container, +.ag-charts-format-sub-level-group-container > *, +.ag-charts-format-sub-level-group-item:last-child, +.ag-charts-format-sub-level-group-title-bar, +.ag-charts-format-top-level-group, +.ag-charts-format-top-level-group .ag-charts-format-top-level-group-container, +.ag-charts-format-top-level-group-item, +.ag-charts-format-top-level-group-title-bar, +.ag-charts-settings-group-container, +.ag-charts-settings-group-title-bar { + margin: 0; + padding: 0; +} +.ag-charts-data-group, +.ag-charts-format-top-level-group { + border-top: 1px solid var(--ag-border-color); +} +.ag-charts-data-group-title-bar, +.ag-charts-format-top-level-group-title-bar, +.ag-charts-settings-group-title-bar { + padding: var(--ag-widget-container-vertical-padding) var(--ag-widget-container-horizontal-padding); +} +.ag-charts-data-group .ag-charts-data-group-container, +.ag-charts-format-top-level-group .ag-charts-format-top-level-group-container, +.ag-charts-settings-group .ag-charts-settings-group-container { + padding: 0 var(--ag-widget-container-horizontal-padding); +} +.ag-charts-format-sub-level-group-title-bar { + padding: var(--ag-widget-vertical-spacing) 0; +} +.ag-charts-format-sub-level-group-container { + padding-bottom: var(--ag-widget-container-vertical-padding); + padding-top: var(--ag-widget-vertical-spacing); +} +.ag-charts-format-sub-level-group-container > *, +.ag-charts-format-sub-level-no-header-group-container > *, +.ag-charts-format-top-level-group-container > * { + margin-bottom: var(--ag-widget-vertical-spacing); +} +.ag-chart-advanced-settings-section, +.ag-chart-settings-mini-wrapper, +.ag-charts-data-group-item { + padding-bottom: var(--ag-widget-container-vertical-padding); +} +.ag-chart-advanced-settings-section { + padding-top: var(--ag-widget-container-vertical-padding); +} +.ag-charts-advanced-settings-top-level-group .ag-charts-advanced-settings-top-level-group-container, +.ag-charts-advanced-settings-top-level-group .ag-charts-advanced-settings-top-level-group-title-bar { + padding: 0 var(--ag-widget-container-horizontal-padding); +} +.ag-charts-advanced-settings-top-level-group-container { + margin: 0; +} +.ag-charts-advanced-settings-top-level-group-item { + margin-bottom: 0; + margin-top: calc(var(--ag-widget-vertical-spacing) * 2); +} +.ag-chart-menu { + --ag-icon-size: 20px; + background-color: color-mix(in srgb, transparent, var(--ag-background-color) 30%); + padding: 4px 2px; +} +.ag-chart-settings-card-item.ag-not-selected:hover { + opacity: 0.35; +} +.ag-column-drop { + align-items: center; + display: inline-flex; + overflow: auto; + position: relative; + width: 100%; +} +.ag-column-drop-cell, +.ag-column-drop-list { + align-items: center; + display: flex; +} +.ag-column-drop-cell { + gap: var(--ag-grid-size); + position: relative; +} +.ag-column-drop-cell-text { + flex: 1 1 auto; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} +.ag-column-drop-vertical { + align-items: stretch; + display: flex; + flex-direction: column; + overflow: hidden; +} +.ag-column-drop-vertical-title-bar { + align-items: center; + display: flex; + flex: none; +} +.ag-column-drop-vertical-list { + align-items: stretch; + flex-direction: column; + flex-grow: 1; + overflow-x: auto; + position: relative; +} +.ag-column-drop-vertical-list > * { + flex: none; +} +.ag-column-drop-empty .ag-column-drop-vertical-list { + overflow: hidden; +} +.ag-column-drop-vertical-empty-message { + display: block; +} +.ag-column-drop.ag-column-drop-horizontal { + overflow: hidden; + white-space: nowrap; +} +.ag-column-drop-cell-button { + cursor: pointer; +} +.ag-column-drop-wrapper { + display: flex; +} +.ag-column-drop-horizontal-half-width { + display: inline-block; + width: 50% !important; +} +.ag-column-drop-cell { + background: var(--ag-column-drop-cell-background-color); + border: var(--ag-column-drop-cell-border); + border-radius: 500px; + padding: calc(var(--ag-grid-size) * 0.5); +} +.ag-ltr .ag-column-drop-cell { + padding-left: calc(var(--ag-grid-size) * 0.75); +} +.ag-rtl .ag-column-drop-cell { + padding-right: calc(var(--ag-grid-size) * 0.75); +} +.ag-column-drop-cell:focus-visible { + box-shadow: var(--ag-focus-shadow); +} +.ag-column-drop-cell-button { + min-width: calc(var(--ag-grid-size) * 4); +} +.ag-column-drop-cell-ghost { + opacity: 0.5; +} +.ag-column-drop-horizontal { + gap: var(--ag-cell-widget-spacing); + height: var(--ag-header-height); +} +.ag-ltr .ag-column-drop-horizontal { + padding-left: var(--ag-cell-horizontal-padding); +} +.ag-rtl .ag-column-drop-horizontal { + padding-right: var(--ag-cell-horizontal-padding); +} +.ag-column-drop-horizontal-list { + gap: var(--ag-cell-widget-spacing); +} +.ag-column-drop-vertical-list { + padding-bottom: var(--ag-grid-size); + padding-left: var(--ag-grid-size); + padding-right: var(--ag-grid-size); +} +.ag-column-drop-vertical-cell { + margin-top: var(--ag-grid-size); +} +.ag-ltr .ag-column-drop-vertical-icon { + margin-right: var(--ag-widget-horizontal-spacing); +} +.ag-rtl .ag-column-drop-vertical-icon { + margin-left: var(--ag-widget-horizontal-spacing); +} +.ag-column-drop-vertical-empty-message { + bottom: 0; + left: 0; + margin-top: var(--ag-grid-size); + overflow: hidden; + position: absolute; + right: 0; + top: 0; +} +.ag-select-agg-func-popup { + background: var(--ag-background-color); + border: 1px solid var(--ag-border-color); + border-radius: var(--ag-border-radius); + box-shadow: var(--ag-dropdown-shadow); + height: calc(var(--ag-grid-size) * 5 * 3.5); + padding: 0; + position: absolute; +} +.ag-select-agg-func-virtual-list-item { + cursor: default; +} +.ag-ltr .ag-select-agg-func-virtual-list-item { + padding-left: calc(var(--ag-grid-size) * 2); +} +.ag-rtl .ag-select-agg-func-virtual-list-item { + padding-right: calc(var(--ag-grid-size) * 2); +} +.ag-select-agg-func-virtual-list-item:hover { + background-color: var(--ag-selected-row-background-color); +} +.ag-select-agg-func-virtual-list-item:focus-visible { + shadow: var(--ag-focus-shadow); +} +.ag-sort-indicator-container { + display: contents; +} +.ag-ltr .ag-sort-indicator-icon { + padding-left: var(--ag-grid-size); +} +.ag-rtl .ag-sort-indicator-icon { + padding-right: var(--ag-grid-size); +} +.ag-column-drop-horizontal { + background-color: var(--ag-header-background-color); + border-bottom: var(--ag-header-row-border); +} +.ag-ltr .ag-column-drop-horizontal-half-width:not(:last-child) { + border-right: var(--ag-column-border); +} +.ag-rtl .ag-column-drop-horizontal-half-width:not(:last-child) { + border-left: var(--ag-column-border); +} +.ag-column-drop-cell-button { + min-width: 0; + opacity: 0.75; +} +.ag-column-drop-cell-button:hover { + opacity: 1; +} +.ag-column-drop-vertical { + min-height: 75px; +} +.ag-column-drop-vertical-title-bar { + padding: var(--ag-widget-container-vertical-padding) calc(var(--ag-grid-size) * 2) 0; +} +.ag-column-drop-vertical-empty-message { + align-items: center; + border: 1px dashed; + border-color: var(--ag-border-color); + display: flex; + justify-content: center; + margin: calc(var(--ag-grid-size) * 1.5) calc(var(--ag-grid-size) * 2); + padding: calc(var(--ag-grid-size) * 2); +} +.ag-column-select { + display: flex; + flex: 3 1 0px; + flex-direction: column; + overflow: hidden; + position: relative; +} +.ag-column-select-header { + flex: none; + height: var(--ag-header-height); + padding-left: var(--ag-widget-container-horizontal-padding); + padding-right: var(--ag-widget-container-horizontal-padding); +} +.ag-column-select-column, +.ag-column-select-column-group, +.ag-column-select-header { + align-items: center; + display: flex; + gap: var(--ag-widget-horizontal-spacing); + position: relative; +} +.ag-column-select-column, +.ag-column-select-column-group { + height: 100%; +} +.ag-column-select-virtual-list-item:focus-visible { + box-shadow: inset var(--ag-focus-shadow); +} +.ag-column-select-header-icon { + border-radius: var(--ag-border-radius); + cursor: pointer; + height: var(--ag-icon-size); + position: relative; + width: var(--ag-icon-size); +} +.ag-column-select-header-icon:focus-visible { + box-shadow: var(--ag-focus-shadow); +} +.ag-column-select-header-filter-wrapper { + flex: 1 1 auto; +} +.ag-column-select-header-filter { + width: 100%; +} +.ag-column-select-list { + flex: 1 1 0px; + overflow: hidden; +} +.ag-ltr .ag-column-select-column, +.ag-ltr .ag-column-select-column-group { + padding-left: calc(var(--ag-indentation-level) * var(--ag-column-select-indent-size)); +} +.ag-rtl .ag-column-select-column, +.ag-rtl .ag-column-select-column-group { + padding-right: calc(var(--ag-indentation-level) * var(--ag-column-select-indent-size)); +} +.ag-ltr .ag-column-select-add-group-indent { + margin-left: calc(var(--ag-icon-size) + var(--ag-grid-size) * 1.5); +} +.ag-rtl .ag-column-select-add-group-indent { + margin-right: calc(var(--ag-icon-size) + var(--ag-grid-size) * 1.5); +} +.ag-column-select-column-group:not(:last-child), +.ag-column-select-column:not(:last-child) { + margin-bottom: var(--ag-widget-vertical-spacing); +} +.ag-column-select-column-group-readonly, +.ag-column-select-column-readonly { + opacity: 0.5; + pointer-events: none; +} +.ag-column-select-virtual-list-viewport { + padding: calc(var(--ag-widget-container-vertical-padding) * 0.5) 0; +} +.ag-column-select-virtual-list-item { + padding: 0 var(--ag-widget-container-horizontal-padding); +} +.ag-column-select-column-label { + flex: 1 1 auto; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} +.ag-column-select-checkbox { + display: flex; +} +.ag-set-filter { + --ag-indentation-level: 0; +} +.ag-set-filter-item { + align-items: center; + display: flex; + height: 100%; +} +.ag-set-filter-item-checkbox { + display: flex; + height: 100%; + width: 100%; +} +.ag-set-filter-group-icons { + display: block; +} +.ag-set-filter-group-icons > * { + cursor: pointer; +} +.ag-filter-body-wrapper { + display: flex; + flex-direction: column; +} +.ag-filter-filter { + flex: 1 1 0px; +} +.ag-filter-condition { + display: flex; + justify-content: center; +} +.ag-floating-filter-body { + display: flex; + flex: 1 1 auto; + height: 100%; + position: relative; +} +.ag-floating-filter-full-body { + align-items: center; + display: flex; + flex: 1 1 auto; + height: 100%; + overflow: hidden; + width: 100%; +} +.ag-floating-filter-full-body > div { + flex: 1 1 auto; +} +.ag-floating-filter-input { + align-items: center; + display: flex; + width: 100%; +} +.ag-floating-filter-input > * { + flex: 1 1 auto; +} +.ag-floating-filter-button { + display: flex; + flex: none; +} +.ag-set-floating-filter-input input[disabled] { + pointer-events: none; +} +.ag-floating-filter-button-button { + -webkit-appearance: none; + -moz-appearance: none; + appearance: none; + background: transparent; + border: none; + height: var(--ag-icon-size); + width: var(--ag-icon-size); +} +.ag-filter-loading { + height: 100%; + padding: var(--ag-widget-container-vertical-padding) var(--ag-widget-container-horizontal-padding); + position: absolute; + width: 100%; + z-index: 1; +} +.ag-column-panel { + display: flex; + flex: 1 1 auto; + flex-direction: column; + overflow: hidden; +} +.ag-pivot-mode-panel { + display: flex; + height: var(--ag-header-height); +} +.ag-pivot-mode-select { + align-items: center; + display: flex; +} +.ag-ltr .ag-pivot-mode-select { + margin-left: var(--ag-widget-container-horizontal-padding); +} +.ag-rtl .ag-pivot-mode-select { + margin-right: var(--ag-widget-container-horizontal-padding); +} +.ag-column-panel-column-select { + border-bottom: var(--ag-tool-panel-separator-border); + border-top: var(--ag-tool-panel-separator-border); +} +:where(.ag-column-panel) .ag-column-drop-vertical { + flex: 1 1 0px; + min-height: 50px; +} +:where(.ag-column-panel) .ag-column-drop-vertical:where(:not(.ag-last-column-drop)) { + border-bottom: var(--ag-tool-panel-separator-border); +} +.ag-dnd-ghost { + align-items: center; + background-color: var(--ag-drag-ghost-background-color); + border: var(--ag-drag-ghost-border); + border-radius: var(--ag-border-radius); + box-shadow: var(--ag-drag-ghost-shadow); + color: var(--ag-text-color); + cursor: move; + font-weight: 500; + gap: var(--ag-cell-widget-spacing); + height: var(--ag-header-height) !important; + max-width: 200px; + padding-left: var(--ag-cell-horizontal-padding); + padding-right: var(--ag-cell-horizontal-padding); + position: absolute; + text-overflow: ellipsis; + transform: translateY(calc(var(--ag-grid-size) * 2)); + z-index: 9999; +} +.ag-dnd-ghost, +.ag-header { + display: flex; + overflow: hidden; + white-space: nowrap; +} +.ag-header { + background-color: var(--ag-header-background-color); + border-bottom: var(--ag-header-row-border); + color: var(--ag-header-text-color); + font-family: var(--ag-header-font-family); + font-size: var(--ag-header-font-size); + font-weight: var(--ag-header-font-weight); + width: 100%; +} +.ag-header-row { + height: var(--ag-header-height); + position: absolute; +} +.ag-header-row:not(:first-child) .ag-header-cell:not(.ag-header-span-height.ag-header-span-total), +.ag-header-row:not(:first-child) .ag-header-group-cell.ag-header-group-cell-with-group { + border-top: var(--ag-header-row-border); +} +.ag-header-row:not(.ag-header-row-column-group) { + overflow: hidden; +} +.ag-header.ag-header-allow-overflow .ag-header-row { + overflow: visible; +} +.ag-header-cell, +.ag-header-group-cell { + align-items: center; + display: inline-flex; + gap: var(--ag-cell-widget-spacing); + height: 100%; + padding: 0 var(--ag-cell-horizontal-padding); + position: absolute; +} +:is(.ag-header-cell:not(.ag-floating-filter), .ag-header-group-cell):before { + background-color: transparent; + content: ''; + inset: 0; + position: absolute; + transition: background-color var(--ag-header-cell-hover-background-transition-duration); +} +.ag-header-cell-moving:is(.ag-header-cell:not(.ag-floating-filter), .ag-header-group-cell):before, +:is(.ag-header-cell:not(.ag-floating-filter), .ag-header-group-cell):hover:before { + background-color: var(--ag-header-cell-hover-background-color); +} +:where(.ag-header-cell:not(.ag-floating-filter) *, .ag-header-group-cell *) { + position: relative; + z-index: 1; +} +.ag-header-cell-filter-button, +.ag-header-cell.ag-header-active .ag-header-cell-menu-button { + opacity: 1; +} +.ag-header-cell-menu-button:not(.ag-header-menu-always-show) { + opacity: 0; + transition: opacity 0.2s; +} +.ag-header-cell-label, +.ag-header-group-cell-label { + align-items: center; + align-self: stretch; + display: flex; + flex: 1 1 auto; + gap: var(--ag-grid-size); +} +.ag-header-cell-label { + overflow: hidden; + text-overflow: ellipsis; +} +.ag-header-group-cell-label.ag-sticky-label { + flex: none; + max-width: 100%; + position: sticky; +} +.ag-ltr .ag-header-group-cell-label.ag-sticky-label { + left: var(--ag-cell-horizontal-padding); +} +.ag-rtl .ag-header-group-cell-label.ag-sticky-label { + right: var(--ag-cell-horizontal-padding); +} +.ag-header-group-text { + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} +.ag-header-cell-text { + overflow: hidden; + text-overflow: ellipsis; + word-break: break-word; +} +.ag-header-cell:not(.ag-header-cell-auto-height) .ag-header-cell-comp-wrapper { + align-items: center; + display: flex; + height: 100%; +} +.ag-header-cell-comp-wrapper { + width: 100%; +} +.ag-header-cell-wrap-text .ag-header-cell-comp-wrapper { + white-space: normal; +} +.ag-right-aligned-header .ag-header-cell-label { + flex-direction: row-reverse; +} +.ag-floating-filter-button-button, +.ag-header-cell-filter-button, +.ag-header-cell-menu-button, +.ag-header-cell-sortable .ag-header-cell-label, +.ag-header-expand-icon, +.ag-panel-title-bar-button, +.ag-side-button-button { + cursor: pointer; +} +.ag-advanced-filter-header-cell:focus-visible, +.ag-header-cell:focus-visible, +.ag-header-group-cell:focus-visible { + box-shadow: inset var(--ag-focus-shadow); +} +.ag-header-cell:after, +.ag-header-group-cell:not(.ag-header-span-height.ag-header-group-cell-no-group):after { + content: ''; + height: var(--ag-header-column-border-height); + position: absolute; + top: calc(50% - var(--ag-header-column-border-height) * 0.5); + z-index: 1; +} +.ag-ltr .ag-header-cell:after, +.ag-ltr .ag-header-group-cell:not(.ag-header-span-height.ag-header-group-cell-no-group):after { + border-right: var(--ag-header-column-border); + right: 0; +} +.ag-rtl .ag-header-cell:after, +.ag-rtl .ag-header-group-cell:not(.ag-header-span-height.ag-header-group-cell-no-group):after { + border-left: var(--ag-header-column-border); + left: 0; +} +.ag-header-cell-resize { + align-items: center; + cursor: ew-resize; + display: flex; + height: 100%; + position: absolute; + top: 0; + width: 8px; + z-index: 2; +} +.ag-ltr .ag-header-cell-resize { + right: -4px; +} +.ag-rtl .ag-header-cell-resize { + left: -4px; +} +.ag-header-cell-resize:after { + background-color: var(--ag-header-column-resize-handle-color); + content: ''; + display: var(--ag-header-column-resize-handle-display); + height: var(--ag-header-column-resize-handle-height); + position: absolute; + top: calc(50% - var(--ag-header-column-resize-handle-height) * 0.5); + width: var(--ag-header-column-resize-handle-width); + z-index: 1; +} +.ag-ltr .ag-header-cell-resize:after { + left: calc(50% - var(--ag-header-column-resize-handle-width)); +} +.ag-rtl .ag-header-cell-resize:after { + right: calc(50% - var(--ag-header-column-resize-handle-width)); +} +.ag-header-cell.ag-header-span-height .ag-header-cell-resize:after { + height: calc(100% - var(--ag-grid-size) * 4); + top: calc(var(--ag-grid-size) * 2); +} +.ag-header-group-cell-no-group.ag-header-span-height .ag-header-cell-resize { + display: none; +} +.ag-menu { + background-color: var(--ag-menu-background-color); + border: var(--ag-menu-border); + border-radius: var(--ag-border-radius); + box-shadow: var(--ag-menu-shadow); + color: var(--ag-menu-text-color); + max-height: 100%; + overflow-y: auto; + position: absolute; + -webkit-user-select: none; + -moz-user-select: none; + user-select: none; +} +.ag-menu-list { + cursor: default; + display: table; + padding: var(--ag-grid-size) 0; + width: 100%; +} +.ag-menu-option, +.ag-menu-separator { + display: table-row; +} +.ag-menu-option-part, +.ag-menu-separator-part { + display: table-cell; + vertical-align: middle; +} +.ag-menu-option-text { + white-space: nowrap; +} +.ag-menu-option-custom { + display: contents; +} +.ag-compact-menu-option { + display: flex; + flex-wrap: nowrap; + width: 100%; +} +.ag-compact-menu-option-text { + flex: 1 1 auto; + white-space: nowrap; +} +.ag-menu-separator { + height: calc(var(--ag-grid-size) * 2 + 1px); +} +.ag-menu-separator-part:after { + border-top: 1px solid var(--ag-menu-separator-color); + content: ''; + display: block; +} +.ag-compact-menu-option-active, +.ag-menu-option-active { + background-color: var(--ag-row-hover-color); +} +.ag-compact-menu-option-part, +.ag-menu-option-part { + line-height: var(--ag-icon-size); + padding: calc(var(--ag-grid-size) + 2px) 0; +} +.ag-compact-menu-option-disabled, +.ag-menu-option-disabled { + cursor: not-allowed; + opacity: 0.5; +} +.ag-compact-menu-option-icon, +.ag-menu-option-icon { + width: var(--ag-icon-size); +} +.ag-ltr .ag-compact-menu-option-icon, +.ag-ltr .ag-menu-option-icon { + padding-left: calc(var(--ag-grid-size) * 2); +} +.ag-rtl .ag-compact-menu-option-icon, +.ag-rtl .ag-menu-option-icon { + padding-right: calc(var(--ag-grid-size) * 2); +} +.ag-compact-menu-option-text, +.ag-menu-option-text { + padding-left: calc(var(--ag-grid-size) * 2); + padding-right: calc(var(--ag-grid-size) * 2); +} +.ag-ltr .ag-compact-menu-option-shortcut, +.ag-ltr .ag-menu-option-shortcut { + padding-right: var(--ag-grid-size); +} +.ag-rtl .ag-compact-menu-option-shortcut, +.ag-rtl .ag-menu-option-shortcut { + padding-left: var(--ag-grid-size); +} +.ag-ltr .ag-compact-menu-option-popup-pointer, +.ag-ltr .ag-menu-option-popup-pointer { + padding-right: var(--ag-grid-size); +} +.ag-rtl .ag-compact-menu-option-popup-pointer, +.ag-rtl .ag-menu-option-popup-pointer { + padding-left: var(--ag-grid-size); +} +.ag-menu-column-select-wrapper { + height: 265px; + overflow: auto; +} +.ag-menu-column-select-wrapper .ag-column-select { + height: 100%; +} +.ag-menu.ag-tabs { + min-width: 290px; +} +.ag-filter-separator { + border-top: 1px solid var(--menu-separator-color); +} +.ag-filter-select .ag-picker-field-wrapper { + width: 0; +} +.ag-filter-condition-operator { + height: 17px; +} +.ag-ltr .ag-filter-condition-operator-or { + margin-left: calc(var(--ag-grid-size) * 2); +} +.ag-rtl .ag-filter-condition-operator-or { + margin-right: calc(var(--ag-grid-size) * 2); +} +.ag-set-filter-select-all { + padding-top: var(--ag-widget-container-vertical-padding); +} +.ag-filter-no-matches, +.ag-set-filter-list { + height: calc(var(--ag-list-item-height) * 6); +} +.ag-filter-no-matches { + padding: var(--ag-widget-container-vertical-padding) var(--ag-widget-container-horizontal-padding); +} +.ag-set-filter-tree-list { + height: calc(var(--ag-list-item-height) * 10); +} +.ag-set-filter-filter { + margin-left: var(--ag-widget-container-horizontal-padding); + margin-right: var(--ag-widget-container-horizontal-padding); + margin-top: var(--ag-widget-container-vertical-padding); +} +.ag-filter-to { + margin-top: var(--ag-widget-vertical-spacing); +} +.ag-mini-filter { + margin: var(--ag-widget-container-vertical-padding) var(--ag-widget-container-horizontal-padding); +} +.ag-ltr .ag-set-filter-item { + padding-left: calc( + var(--ag-widget-container-horizontal-padding) + var(--ag-indentation-level) * var(--ag-set-filter-indent-size) + ); +} +.ag-rtl .ag-set-filter-item { + padding-right: calc( + var(--ag-widget-container-horizontal-padding) + var(--ag-indentation-level) * var(--ag-set-filter-indent-size) + ); +} +.ag-ltr .ag-set-filter-add-group-indent { + margin-left: calc(var(--ag-icon-size) + var(--ag-widget-container-horizontal-padding)); +} +.ag-rtl .ag-set-filter-add-group-indent { + margin-right: calc(var(--ag-icon-size) + var(--ag-widget-container-horizontal-padding)); +} +.ag-ltr .ag-set-filter-group-icons { + margin-right: var(--ag-widget-container-horizontal-padding); +} +.ag-rtl .ag-set-filter-group-icons { + margin-left: var(--ag-widget-container-horizontal-padding); +} +.ag-filter-menu .ag-set-filter-list { + min-width: 200px; +} +.ag-filter-virtual-list-item:focus-visible { + box-shadow: inset var(--ag-focus-shadow); +} +.ag-filter-apply-panel { + display: flex; + justify-content: flex-end; + overflow: hidden; + padding: var(--ag-widget-vertical-spacing) var(--ag-widget-container-horizontal-padding) + var(--ag-widget-container-vertical-padding); +} +.ag-filter-apply-panel-button { + line-height: 1.5; +} +.ag-ltr .ag-filter-apply-panel-button { + margin-left: calc(var(--ag-grid-size) * 2); +} +.ag-rtl .ag-filter-apply-panel-button { + margin-right: calc(var(--ag-grid-size) * 2); +} +.ag-simple-filter-body-wrapper { + display: flex; + flex-direction: column; + gap: var(--ag-widget-vertical-spacing); + min-height: calc( + var(--ag-list-item-height) + var(--ag-widget-container-vertical-padding) + var(--ag-widget-vertical-spacing) + ); + overflow-y: auto; + padding: var(--ag-widget-container-vertical-padding) var(--ag-widget-container-horizontal-padding); +} +.ag-simple-filter-body-wrapper .ag-resizer-wrapper { + margin: 0; +} +.ag-multi-filter-menu-item { + margin: var(--ag-grid-size) 0; +} +.ag-multi-filter-group-title-bar { + background-color: transparent; + color: var(--ag-header-text-color); + font-weight: 500; + padding: calc(var(--ag-grid-size) * 1.5) var(--ag-grid-size); +} +.ag-multi-filter-group-title-bar:focus-visible { + box-shadow: var(--ag-focus-shadow); +} +.ag-group-filter-field-select-wrapper { + display: flex; + flex-direction: column; + gap: var(--ag-widget-vertical-spacing); + padding: var(--ag-widget-container-vertical-padding) var(--ag-widget-container-horizontal-padding); +} +.ag-menu-option .ag-icon { + opacity: 65%; +} +.ag-menu-option { + cursor: pointer; + font-weight: 500; +} +.ag-ltr .ag-menu-option-popup-pointer .ag-icon { + text-align: right; +} +.ag-rtl .ag-menu-option-popup-pointer .ag-icon { + text-align: left; +} +.ag-panel { + background-color: var(--ag-panel-background-color); + display: flex; + flex-direction: column; + overflow: hidden; + position: relative; +} +.ag-dialog { + border: var(--ag-dialog-border); + border-radius: var(--ag-border-radius); + box-shadow: var(--ag-dialog-shadow); + position: absolute; +} +.ag-panel-title-bar { + align-items: center; + background-color: var(--ag-panel-title-bar-background-color); + border-bottom: var(--ag-panel-title-bar-border); + color: var(--ag-header-text-color); + cursor: default; + display: flex; + flex: none; + height: var(--ag-header-height); + padding: var(--ag-grid-size) var(--ag-cell-horizontal-padding); +} +.ag-ltr .ag-panel-title-bar-button { + margin-left: calc(var(--ag-grid-size) * 2); + margin-right: var(--ag-grid-size); +} +.ag-rtl .ag-panel-title-bar-button { + margin-left: var(--ag-grid-size); + margin-right: calc(var(--ag-grid-size) * 2); +} +.ag-panel-title-bar-title { + color: var(--ag-header-text-color); + flex: 1 1 auto; + font-weight: 500; +} +.ag-panel-title-bar-buttons { + display: flex; +} +.ag-panel-title-bar-button { + cursor: pointer; +} +.ag-panel-content-wrapper { + display: flex; + flex: 1 1 auto; + overflow: hidden; + position: relative; +} +.ag-resizer { + pointer-events: none; + position: absolute; + -webkit-user-select: none; + -moz-user-select: none; + user-select: none; + z-index: 1; +} +.ag-resizer.ag-resizer-topLeft { + height: 5px; + left: 0; + top: 0; + width: 5px; +} +.ag-ltr .ag-resizer.ag-resizer-topLeft { + cursor: nwse-resize; +} +.ag-rtl .ag-resizer.ag-resizer-topLeft { + cursor: nesw-resize; +} +.ag-resizer.ag-resizer-top { + cursor: ns-resize; + height: 5px; + left: 5px; + right: 5px; + top: 0; +} +.ag-resizer.ag-resizer-topRight { + height: 5px; + right: 0; + top: 0; + width: 5px; +} +.ag-ltr .ag-resizer.ag-resizer-topRight { + cursor: nesw-resize; +} +.ag-rtl .ag-resizer.ag-resizer-topRight { + cursor: nwse-resize; +} +.ag-resizer.ag-resizer-right { + bottom: 5px; + cursor: ew-resize; + right: 0; + top: 5px; + width: 5px; +} +.ag-resizer.ag-resizer-bottomRight { + bottom: 0; + height: 5px; + right: 0; + width: 5px; +} +.ag-ltr .ag-resizer.ag-resizer-bottomRight { + cursor: nwse-resize; +} +.ag-rtl .ag-resizer.ag-resizer-bottomRight { + cursor: nesw-resize; +} +.ag-resizer.ag-resizer-bottom { + bottom: 0; + cursor: ns-resize; + height: 5px; + left: 5px; + right: 5px; +} +.ag-resizer.ag-resizer-bottomLeft { + bottom: 0; + height: 5px; + left: 0; + width: 5px; +} +.ag-ltr .ag-resizer.ag-resizer-bottomLeft { + cursor: nesw-resize; +} +.ag-rtl .ag-resizer.ag-resizer-bottomLeft { + cursor: nwse-resize; +} +.ag-resizer.ag-resizer-left { + bottom: 5px; + cursor: ew-resize; + left: 0; + top: 5px; + width: 5px; +} +.ag-dragging-fill-handle .ag-dialog, +.ag-dragging-range-handle .ag-dialog { + opacity: 0.7; + pointer-events: none; +} +.ag-pinned-left-header, +.ag-pinned-right-header { + display: inline-block; + overflow: hidden; + position: relative; +} +.ag-body-horizontal-scroll:not(.ag-scrollbar-invisible) .ag-horizontal-left-spacer:not(.ag-scroller-corner) { + border-right: var(--ag-pinned-column-border); +} +.ag-body-horizontal-scroll:not(.ag-scrollbar-invisible) .ag-horizontal-right-spacer:not(.ag-scroller-corner), +.ag-pinned-right-header { + border-left: var(--ag-pinned-column-border); +} +.ag-pinned-left-header { + border-right: var(--ag-pinned-column-border); +} +.ag-cell.ag-cell-first-right-pinned:not(.ag-cell-range-left):not(.ag-cell-range-single-cell) { + border-left: var(--ag-pinned-column-border); +} +.ag-cell.ag-cell-last-left-pinned:not(.ag-cell-range-right):not(.ag-cell-range-single-cell) { + border-right: var(--ag-pinned-column-border); +} +.ag-pinned-left-header .ag-header-cell-resize:after { + left: calc(50% - var(--ag-header-column-resize-handle-width)); +} +.ag-pinned-right-header .ag-header-cell-resize:after { + left: 50%; +} +.ag-pinned-left-header, +.ag-pinned-right-header { + height: 100%; +} +.ag-pinned-left-header .ag-header-cell-resize { + right: -4px; +} +.ag-pinned-right-header .ag-header-cell-resize { + left: -4px; +} +.ag-layout-print.ag-body { + display: block; + height: unset; +} +.ag-layout-print.ag-root-wrapper { + display: inline-block; +} +.ag-layout-print .ag-body-horizontal-scroll, +.ag-layout-print .ag-body-vertical-scroll { + display: none; +} +.ag-layout-print.ag-force-vertical-scroll { + overflow-y: visible !important; +} +@media print { + .ag-root-wrapper.ag-layout-print { + display: table; + } + .ag-root-wrapper.ag-layout-print .ag-body-horizontal-scroll-viewport, + .ag-root-wrapper.ag-layout-print .ag-body-viewport, + .ag-root-wrapper.ag-layout-print .ag-center-cols-container, + .ag-root-wrapper.ag-layout-print .ag-center-cols-viewport, + .ag-root-wrapper.ag-layout-print .ag-root, + .ag-root-wrapper.ag-layout-print .ag-root-wrapper-body, + .ag-root-wrapper.ag-layout-print .ag-virtual-list-viewport { + display: block !important; + height: auto !important; + overflow: hidden !important; + } + .ag-root-wrapper.ag-layout-print .ag-cell, + .ag-root-wrapper.ag-layout-print .ag-row { + -moz-column-break-inside: avoid; + break-inside: avoid; + } +} +.ag-select { + align-items: center; + display: flex; + flex-direction: row; +} +.ag-select .ag-picker-field-wrapper { + cursor: default; +} +.ag-ltr .ag-select .ag-picker-field-wrapper { + padding-left: calc(var(--ag-cell-horizontal-padding) / 2); + padding-right: var(--ag-grid-size); +} +.ag-rtl .ag-select .ag-picker-field-wrapper { + padding-left: var(--ag-grid-size); + padding-right: calc(var(--ag-cell-horizontal-padding) / 2); +} +.ag-select.ag-disabled .ag-picker-field-wrapper:focus { + box-shadow: none; +} +.ag-select:not(.ag-cell-editor, .ag-label-align-top) { + min-height: var(--ag-list-item-height); +} +.ag-select .ag-picker-field-display { + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} +.ag-select .ag-picker-field-icon { + align-items: center; + display: flex; +} +.ag-select.ag-disabled { + opacity: 0.5; +} +.ag-rich-select { + cursor: default; + height: 100%; +} +.ag-rich-select-value { + align-items: center; + background-color: var(--ag-input-background-color); + display: flex; + height: 100%; + padding: var(--ag-grid-size); +} +.ag-rich-select-value .ag-picker-field-display { + overflow: hidden; + text-overflow: ellipsis; +} +.ag-rich-select-value .ag-picker-field-display.ag-display-as-placeholder { + opacity: 0.5; +} +.ag-rich-select-list { + background-color: var(--ag-input-background-color); + border: var(--ag-input-border); + border-radius: var(--ag-input-border-radius); + box-shadow: var(--ag-dropdown-shadow); + height: auto; + position: relative; + width: 100%; +} +.ag-rich-select-list .ag-loading-text { + padding: var(--ag-widget-container-vertical-padding) var(--ag-widget-container-horizontal-padding); +} +.ag-rich-select-row { + align-items: center; + display: flex; + flex: 1 1 auto; + height: 100%; + overflow: hidden; + padding: 0 var(--ag-grid-size); + white-space: nowrap; +} +.ag-rich-select-row-selected { + background-color: var(--ag-selected-row-background-color); +} +.ag-rich-select-row-highlighted, +.ag-rich-select-row:hover { + background-image: linear-gradient(var(--ag-row-hover-color), var(--ag-row-hover-color)); +} +.ag-rich-select-row-text-highlight { + font-weight: 700; +} +.ag-rich-select-field-input { + flex: 1 1 auto; +} +.ag-ltr .ag-rich-select-field-input { + left: var(--ag-grid-size); +} +.ag-rtl .ag-rich-select-field-input { + right: var(--ag-grid-size); +} +.ag-rich-select-field-input .ag-input-field-input { + border: none !important; + box-shadow: none !important; + padding: 0 !important; + text-overflow: ellipsis; +} +.ag-rich-select-field-input .ag-input-field-input::-moz-placeholder { + opacity: 0.8; +} +.ag-rich-select-field-input .ag-input-field-input::placeholder { + opacity: 0.8; +} +.ag-popup-editor .ag-rich-select-value { + height: var(--ag-row-height); + min-width: 200px; +} +.ag-rich-select-virtual-list-item { + cursor: default; + height: var(--ag-list-item-height); +} +.ag-pill-container { + display: flex; + flex-wrap: nowrap; + gap: 0.25rem; +} +.ag-pill { + align-items: center; + background: var(--ag-select-cell-background-color); + border: var(--ag-select-cell-border); + border-radius: var(--ag-border-radius); + display: flex; + padding: 0 0.25rem; + white-space: nowrap; +} +.ag-pill:focus-visible { + box-shadow: var(--ag-focus-shadow); +} +.ag-pill .ag-pill-button { + border: none; + padding: 0; +} +.ag-ltr .ag-pill .ag-pill-button { + margin-left: var(--ag-grid-size); +} +.ag-rtl .ag-pill .ag-pill-button { + margin-right: var(--ag-grid-size); +} +.ag-pill .ag-pill-button:hover { + color: var(--ag-accent-color); + cursor: pointer; +} +.ag-root-wrapper { + cursor: default; + display: flex; + flex-direction: column; + line-height: normal; + overflow: hidden; + position: relative; + white-space: normal; + -webkit-font-smoothing: antialiased; + background-color: var(--ag-background-color); + border: var(--ag-wrapper-border); + border-radius: var(--ag-wrapper-border-radius); + color: var(--ag-text-color); + color-scheme: var(--ag-color-scheme); + font-family: var(--ag-font-family); + font-size: var(--ag-font-size); +} +.ag-root-wrapper.ag-layout-normal { + height: 100%; +} +.ag-popup, +.ag-root-wrapper { + --ag-indentation-level: 0; +} +.ag-ltr .ag-side-bar-left .ag-tool-panel-horizontal-resize { + right: -3px; +} +.ag-ltr .ag-side-bar-right .ag-tool-panel-horizontal-resize, +.ag-rtl .ag-side-bar-left .ag-tool-panel-horizontal-resize { + left: -3px; +} +.ag-rtl .ag-side-bar-right .ag-tool-panel-horizontal-resize { + right: -3px; +} +.ag-tool-panel-wrapper { + width: var(--ag-side-bar-panel-width); +} +.ag-side-bar { + background-color: var(--ag-side-bar-background-color); + display: flex; + flex-direction: row-reverse; + position: relative; +} +.ag-side-bar-left { + flex-direction: row; + order: -1; +} +.ag-side-buttons { + position: relative; + width: calc(var(--ag-icon-size) + var(--ag-grid-size) * 2); +} +.ag-side-button.ag-selected { + background-color: var(--ag-side-button-selected-background-color); + border-bottom: var(--ag-side-button-selected-border); +} +.ag-side-button.ag-selected:not(:first-of-type) { + border-top: var(--ag-side-button-selected-border); +} +.ag-side-button-button { + align-items: center; + display: flex; + flex-direction: column; + gap: var(--ag-grid-size); + padding: calc(var(--ag-grid-size) * 3) 0; + position: relative; + white-space: nowrap; + width: 100%; +} +.ag-side-button-button:focus { + box-shadow: none; +} +.ag-side-button-button:focus-visible { + box-shadow: inset var(--ag-focus-shadow); +} +.ag-side-button-label { + writing-mode: vertical-lr; +} +@media (max-resolution: 1.5x) { + .ag-side-button-label { + font-family: 'Segoe UI', var(--ag-font-family); + } + .ag-ltr .ag-side-button-label { + transform: rotate(0.05deg); + } + .ag-rtl .ag-side-button-label { + transform: rotate(-0.05deg); + } +} +.ag-ltr .ag-side-bar-left, +.ag-rtl .ag-side-bar-right { + border-right: var(--ag-side-panel-border); +} +.ag-ltr .ag-side-bar-left .ag-tool-panel-wrapper, +.ag-ltr .ag-side-bar-right, +.ag-rtl .ag-side-bar-left, +.ag-rtl .ag-side-bar-right .ag-tool-panel-wrapper { + border-left: var(--ag-side-panel-border); +} +.ag-ltr .ag-side-bar-right .ag-tool-panel-wrapper, +.ag-rtl .ag-side-bar-left .ag-tool-panel-wrapper { + border-right: var(--ag-side-panel-border); +} +.ag-ltr .ag-chart-menu-panel { + border-left: var(--ag-side-panel-border); +} +.ag-rtl .ag-chart-menu-panel { + border-right: var(--ag-side-panel-border); +} +.ag-button { + border-radius: 0; +} +.ag-standard-button { + -moz-appearance: none; + appearance: none; + -webkit-appearance: none; + background-color: var(--ag-background-color); + border: var(--ag-input-border); + border-radius: var(--ag-border-radius); + cursor: pointer; + font-family: inherit; + padding: var(--ag-grid-size) calc(var(--ag-grid-size) * 2); +} +.ag-standard-button:hover { + background-color: var(--ag-row-hover-color); +} +.ag-standard-button:active { + border-color: var(--ag-accent-color); +} +.ag-standard-button:disabled { + background-color: var(--ag-input-disabled-background-color); + border: var(--ag-input-disabled-border); + color: var(--ag-input-disabled-text-color); +} +:where(input[class^='ag-'][type='button'], button[class^='ag-']):focus-visible { + box-shadow: var(--ag-focus-shadow); +} +.ag-checkbox-input-wrapper, +.ag-radio-button-input-wrapper { + background-color: var(--ag-checkbox-unchecked-background-color); + border: solid var(--ag-checkbox-border-width) var(--ag-checkbox-unchecked-border-color); + flex: none; + height: var(--ag-icon-size); + position: relative; + width: var(--ag-icon-size); +} +.ag-checkbox-input-wrapper input, +.ag-radio-button-input-wrapper input { + -webkit-appearance: none; + -moz-appearance: none; + appearance: none; + height: 100%; + opacity: 0; + width: 100%; +} +.ag-checkbox-input-wrapper:after, +.ag-radio-button-input-wrapper:after { + content: ''; + display: block; + inset: 0; + -webkit-mask-position: center; + mask-position: center; + -webkit-mask-repeat: no-repeat; + mask-repeat: no-repeat; + pointer-events: none; + position: absolute; +} +.ag-checkbox-input-wrapper.ag-checked, +.ag-radio-button-input-wrapper.ag-checked { + background-color: var(--ag-checkbox-checked-background-color); + border-color: var(--ag-checkbox-checked-border-color); +} +.ag-checkbox-input-wrapper.ag-checked:after, +.ag-radio-button-input-wrapper.ag-checked:after { + background-color: var(--ag-checkbox-checked-shape-color); +} +.ag-checkbox-input-wrapper:active, +.ag-checkbox-input-wrapper:focus-within, +.ag-radio-button-input-wrapper:active, +.ag-radio-button-input-wrapper:focus-within { + box-shadow: var(--ag-focus-shadow); +} +.ag-checkbox-input-wrapper.ag-disabled, +.ag-radio-button-input-wrapper.ag-disabled { + filter: grayscale(); + opacity: 0.5; +} +.ag-checkbox-input-wrapper { + border-radius: var(--ag-checkbox-border-radius); +} +.ag-checkbox-input-wrapper.ag-checked:after { + -webkit-mask-image: var(--ag-checkbox-checked-shape-image); + mask-image: var(--ag-checkbox-checked-shape-image); +} +.ag-checkbox-input-wrapper.ag-indeterminate { + background-color: var(--ag-checkbox-indeterminate-background-color); + border-color: var(--ag-checkbox-indeterminate-border-color); +} +.ag-checkbox-input-wrapper.ag-indeterminate:after { + background-color: var(--ag-checkbox-indeterminate-shape-color); + -webkit-mask-image: var(--ag-checkbox-indeterminate-shape-image); + mask-image: var(--ag-checkbox-indeterminate-shape-image); +} +.ag-radio-button-input-wrapper { + border-radius: 100%; +} +.ag-radio-button-input-wrapper.ag-checked:after { + -webkit-mask-image: var(--ag-radio-checked-shape-image); + mask-image: var(--ag-radio-checked-shape-image); +} +.ag-drag-handle { + color: varXXX(--ag-icon-font-color); + cursor: grab; +} +.ag-list-item, +.ag-virtual-list-item { + height: var(--ag-list-item-height); +} +.ag-virtual-list-item { + position: absolute; + width: 100%; +} +.ag-select-list { + background-color: var(--ag-background-color); + border: var(--ag-input-border); + border-radius: var(--ag-border-radius); + box-shadow: var(--ag-dropdown-shadow); + overflow-x: hidden; + overflow-y: auto; +} +.ag-list-item { + align-items: center; + display: flex; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} +.ag-list-item.ag-active-item { + background-color: var(--ag-row-hover-color); +} +.ag-select-list-item { + cursor: default; + -webkit-user-select: none; + -moz-user-select: none; + user-select: none; +} +.ag-ltr .ag-select-list-item { + padding-left: calc(var(--ag-cell-horizontal-padding) / 2); +} +.ag-rtl .ag-select-list-item { + padding-right: calc(var(--ag-cell-horizontal-padding) / 2); +} +.ag-select-list-item span { + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} +.ag-list-item-hovered:after { + background-color: var(--ag-range-selection-border-color); + content: ''; + height: 1px; + left: 0; + position: absolute; + right: 0; +} +.ag-item-highlight-top:after { + top: 0; +} +.ag-item-highlight-bottom:after { + bottom: 0; +} +.ag-range-field { + align-items: center; + display: flex; +} +.ag-range-field .ag-input-wrapper { + height: 100%; +} +input[class^='ag-'][type='range'] { + -webkit-appearance: none; + background: none; + height: 100%; + overflow: visible; + padding: 0; + width: 100%; +} +input[class^='ag-'][type='range']::-webkit-slider-runnable-track { + background-color: var(--ag-border-color); + border-radius: 1.5px; + height: 3px; + margin: 0; + padding: 0; + width: 100%; +} +input[class^='ag-'][type='range']::-moz-range-track { + background-color: var(--ag-border-color); + border-radius: 1.5px; + height: 3px; + margin: 0; + padding: 0; + width: 100%; +} +input[class^='ag-'][type='range']::-webkit-slider-thumb { + -webkit-appearance: none; + background-color: var(--ag-background-color); + border: 1px solid var(--ag-border-color); + border-radius: 100%; + height: var(--ag-icon-size); + margin: 0; + padding: 0; + transform: translateY(calc(var(--ag-icon-size) * -0.5 + 1.5px)); + width: var(--ag-icon-size); +} +input[class^='ag-'][type='range']::-moz-ag-range-thumb { + -webkit-appearance: none; + background-color: var(--ag-background-color); + border: 1px solid var(--ag-border-color); + border-radius: 100%; + height: var(--ag-icon-size); + margin: 0; + padding: 0; + transform: translateY(calc(var(--ag-icon-size) * -0.5 + 1.5px)); + width: var(--ag-icon-size); +} +input[class^='ag-'][type='range']:focus::-webkit-slider-thumb { + border-color: var(--ag-accent-color); + box-shadow: var(--ag-focus-shadow); +} +input[class^='ag-'][type='range']:focus::-moz-ag-range-thumb { + border-color: var(--ag-accent-color); + box-shadow: var(--ag-focus-shadow); +} +input[class^='ag-'][type='range']:active::-webkit-slider-runnable-track { + background-color: var(--ag-accent-color); +} +input[class^='ag-'][type='range']:active::-moz-ag-range-track { + background-color: var(--ag-accent-color); +} +input[class^='ag-'][type='range']:disabled { + opacity: 0.5; +} +.ag-toggle-button { + flex: none; + min-width: unset; + width: unset; +} +.ag-toggle-button-input-wrapper { + background-color: var(--ag-toggle-button-off-background-color); + border: solid var(--ag-toggle-button-border-width) var(--ag-toggle-button-off-border-color); + border-radius: calc(var(--ag-toggle-button-height) * 0.5); + flex: none; + height: var(--ag-toggle-button-height); + max-width: var(--ag-toggle-button-width); + min-width: var(--ag-toggle-button-width); + position: relative; +} +.ag-toggle-button-input-wrapper input { + -webkit-appearance: none; + -moz-appearance: none; + appearance: none; + height: 100%; + opacity: 0; + width: 100%; +} +.ag-toggle-button-input-wrapper:before { + background-color: var(--ag-toggle-button-switch-background-color); + border: var(--ag-toggle-button-border-width) solid var(--ag-toggle-button-switch-border-color); + border-radius: 100%; + content: ''; + display: block; + height: var(--ag-toggle-button-height); + pointer-events: none; + position: absolute; + top: calc(0px - var(--ag-toggle-button-border-width)); + width: var(--ag-toggle-button-height); +} +.ag-ltr .ag-toggle-button-input-wrapper:before { + left: calc(0px - var(--ag-toggle-button-border-width)); + transition: left 0.1s; +} +.ag-rtl .ag-toggle-button-input-wrapper:before { + right: calc(0px - var(--ag-toggle-button-border-width)); + transition: right 0.1s; +} +.ag-toggle-button-input-wrapper.ag-checked { + background-color: var(--ag-toggle-button-on-background-color); +} +.ag-toggle-button-input-wrapper.ag-checked, +.ag-toggle-button-input-wrapper.ag-checked:before { + border-color: var(--ag-toggle-button-on-border-color); +} +.ag-ltr .ag-toggle-button-input-wrapper.ag-checked:before { + left: calc(100% - var(--ag-toggle-button-height) + var(--ag-toggle-button-border-width)); +} +.ag-rtl .ag-toggle-button-input-wrapper.ag-checked:before { + right: calc(100% - var(--ag-toggle-button-height) + var(--ag-toggle-button-border-width)); +} +.ag-toggle-button-input-wrapper:focus-within { + box-shadow: var(--ag-focus-shadow); +} +.ag-toggle-button-input-wrapper.ag-disabled { + opacity: 0.5; +} +.ag-autocomplete { + align-items: center; + display: flex; + width: 100%; +} +.ag-autocomplete > * { + flex: 1 1 auto; +} +.ag-autocomplete-list-popup { + position: absolute; + -webkit-user-select: none; + -moz-user-select: none; + user-select: none; +} +.ag-autocomplete-list { + height: calc(var(--ag-row-height) * 6.5); + min-width: 200px; + position: relative; + width: 100%; +} +.ag-autocomplete-virtual-list-item { + cursor: default; + display: flex; + height: var(--ag-list-item-height); +} +.ag-autocomplete-virtual-list-item:focus-visible:after { + content: none; +} +.ag-autocomplete-virtual-list-item:hover { + background-color: var(--ag-row-hover-color); +} +.ag-autocomplete-row { + align-items: center; + display: flex; + flex: 1 1 auto; + overflow: hidden; +} +.ag-autocomplete-row-label { + margin: 0 var(--ag-widget-container-horizontal-padding); + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} +.ag-autocomplete-row-selected { + background-color: var(--ag-selected-row-background-color); +} +.ag-tooltip { + background-color: var(--ag-tooltip-background-color); + border: var(--ag-tooltip-border); + border-radius: var(--ag-border-radius); + color: var(--ag-tooltip-text-color); + padding: var(--ag-widget-container-vertical-padding) var(--ag-widget-container-horizontal-padding); + white-space: normal; +} +.ag-tooltip, +.ag-tooltip-custom { + position: absolute; + z-index: 99999; +} +.ag-tooltip-custom:not(.ag-tooltip-interactive), +.ag-tooltip:not(.ag-tooltip-interactive) { + pointer-events: none; +} +.ag-tooltip-custom.ag-tooltip-animate, +.ag-tooltip.ag-tooltip-animate { + transition: opacity 1s; +} +.ag-tooltip-custom.ag-tooltip-animate.ag-tooltip-hiding, +.ag-tooltip.ag-tooltip-animate.ag-tooltip-hiding { + opacity: 0; +} +.ag-angle-select { + align-items: center; + display: flex; +} +.ag-angle-select-wrapper { + display: flex; +} +.ag-angle-select-parent-circle { + display: block; + position: relative; +} +.ag-angle-select-child-circle { + position: absolute; +} +.ag-slider-wrapper { + display: flex; +} +.ag-picker-field-display, +.ag-slider-wrapper .ag-input-field { + flex: 1 1 auto; +} +.ag-picker-field { + align-items: center; + display: flex; +} +.ag-picker-field-icon { + border: 0; + cursor: pointer; + display: flex; + margin: 0; + padding: 0; +} +.ag-color-panel { + display: flex; + flex-direction: column; + text-align: center; + width: 100%; +} +.ag-spectrum-color { + cursor: default; + flex: 1 1 auto; + overflow: visible; + position: relative; +} +.ag-spectrum-fill { + inset: 0; + position: absolute; +} +.ag-spectrum-val { + cursor: pointer; +} +.ag-spectrum-dragger { + cursor: pointer; + pointer-events: none; + position: absolute; +} +.ag-spectrum-alpha, +.ag-spectrum-hue { + cursor: default; +} +.ag-spectrum-hue-background { + background: linear-gradient(270deg, red 3%, #ff0 17%, #0f0 33%, #0ff 50%, #00f 67%, #f0f 83%, red); + height: 100%; + width: 100%; +} +.ag-spectrum-alpha-background { + background: + linear-gradient(to right, var(--ag-internal-spectrum-alpha-color-from), var(--ag-internal-spectrum-alpha-color-to)), + url('data:image/svg+xml;utf8,') + 0 0 /4px 4px; + height: 100%; + width: 100%; +} +.ag-spectrum-tool { + cursor: pointer; + position: relative; +} +.ag-spectrum-slider { + pointer-events: none; + position: absolute; +} +.ag-spectrum-alpha .ag-spectrum-slider { + background: linear-gradient( + to bottom, + var(--ag-internal-spectrum-alpha-color), + var(--ag-internal-spectrum-alpha-color) + ) + var(--ag-background-color); +} +.ag-recent-colors { + display: flex; + gap: 6px; + margin-top: 10px; +} +.ag-recent-color { + cursor: pointer; +} +.ag-angle-select[disabled] { + opacity: 0.5; + pointer-events: none; +} +.ag-ltr .ag-angle-select-field, +.ag-ltr .ag-slider-field { + margin-right: calc(var(--ag-grid-size) * 2); +} +.ag-rtl .ag-angle-select-field, +.ag-rtl .ag-slider-field { + margin-left: calc(var(--ag-grid-size) * 2); +} +.ag-angle-select-parent-circle { + background-color: var(--ag-background-color); + border: 1px solid; + border-color: var(--ag-border-color); + border-radius: 12px; + height: 24px; + width: 24px; +} +.ag-angle-select-child-circle { + background-color: var(--ag-foreground-color); + border-radius: 3px; + height: 6px; + left: 12px; + margin-left: -3px; + margin-top: -4px; + top: 4px; + width: 6px; +} +.ag-picker-field-wrapper { + background-color: var(--ag-background-color); + border: var(--ag-input-border); + border-radius: 5px; + min-height: max(var(--ag-list-item-height), calc(var(--ag-grid-size) * 4)); + overflow: hidden; +} +.ag-picker-field-wrapper:disabled { + opacity: 0.5; +} +.ag-picker-field-wrapper.ag-picker-has-focus, +.ag-picker-field-wrapper:focus-within { + border: var(--ag-input-focus-border); + box-shadow: var(--ag-focus-shadow); +} +.ag-picker-field-button { + background-color: var(--ag-background-color); +} +.ag-dialog.ag-color-dialog { + border-radius: 5px; +} +.ag-color-picker .ag-picker-field-wrapper { + padding-left: var(--ag-grid-size); + padding-right: var(--ag-grid-size); +} +.ag-color-picker .ag-picker-field-display { + align-items: center; + display: flex; + flex-direction: row; + min-height: var(--ag-list-item-height); +} +.ag-ltr .ag-color-picker-color, +.ag-ltr .ag-color-picker-value { + margin-right: var(--ag-grid-size); +} +.ag-rtl .ag-color-picker-color, +.ag-rtl .ag-color-picker-value { + margin-left: var(--ag-grid-size); +} +.ag-color-panel { + padding: var(--ag-grid-size); +} +.ag-spectrum-tools { + padding-bottom: 0; + padding-left: 0; + padding-right: 0; +} +.ag-spectrum-tool { + height: 12px; +} +.ag-spectrum-alpha-background, +.ag-spectrum-hue-background { + border-radius: 12px; +} +.ag-spectrum-slider { + border: 3px solid #f8f8f8; + border-radius: 18px; + height: 18px; + margin-top: -15px; + width: 18px; +} +.ag-recent-colors { + margin-bottom: 2px; + margin-left: var(--ag-grid-size); + margin-right: var(--ag-grid-size); +} +.ag-color-input-color, +.ag-color-picker-color, +.ag-recent-color { + border-radius: 4px; +} +.ag-recent-color { + border: 1px solid var(--ag-border-color); +} +.ag-spectrum-sat { + background-image: linear-gradient(90deg, #fff, hsla(20, 42%, 65%, 0)); +} +.ag-spectrum-val { + background-image: linear-gradient(0deg, #000, hsla(20, 42%, 65%, 0)); +} +.ag-spectrum-dragger { + background: #000; + border: 3px solid #fff; + border-radius: 18px; + box-shadow: 0 0 2px 0 rgba(0, 0, 0, 0.24); + height: 18px; + width: 18px; +} +.ag-spectrum-alpha-background, +.ag-spectrum-hue-background { + border-radius: 2px; +} +.ag-spectrum-tool { + border-radius: 2px; + height: 11px; + margin-bottom: 10px; +} +.ag-spectrum-slider { + border: 2px solid #fff; + border-radius: 13px; + box-shadow: 0 1px 4px 0 rgba(0, 0, 0, 0.37); + height: 13px; + margin-top: -12px; + width: 13px; +} +.ag-recent-color:focus-visible:not(:disabled):not([readonly]), +.ag-spectrum-color:focus-visible:not(:disabled):not([readonly]), +.ag-spectrum-slider:focus-visible:not(:disabled):not([readonly]) { + box-shadow: var(--ag-focus-shadow); +} +.ag-ltr .ag-color-input input.ag-input-field-input[class^='ag-'][type='text'] { + padding-left: calc(var(--ag-icon-size) + var(--ag-grid-size) * 2); +} +.ag-rtl .ag-color-input input.ag-input-field-input[class^='ag-'][type='text'] { + padding-right: calc(var(--ag-icon-size) + var(--ag-grid-size) * 2); +} +.ag-color-input .ag-color-input-color { + position: absolute; +} +.ag-ltr .ag-color-input .ag-color-input-color { + margin-left: var(--ag-grid-size); +} +.ag-rtl .ag-color-input .ag-color-input-color { + margin-right: var(--ag-grid-size); +} +.ag-color-input-color, +.ag-color-picker-color { + border: 1px solid var(--ag-border-color); + border-radius: 2px; + height: var(--ag-icon-size); + width: var(--ag-icon-size); +} +.ag-pill-select .ag-picker-field-display { + color: var(--ag-chart-menu-label-color); + font-weight: 500; +} +.ag-pill-select .ag-picker-field-icon .ag-icon { + color: var(--ag-chart-menu-label-color); +} +.ag-filter-toolpanel { + flex: 1 1 0px; + min-width: 0; +} +.ag-filter-toolpanel-header { + position: relative; +} +.ag-filter-toolpanel-header, +.ag-filter-toolpanel-header > *, +.ag-filter-toolpanel-search, +.ag-filter-toolpanel-search > * { + align-items: center; + display: flex; +} +.ag-filter-toolpanel-header { + height: calc(var(--ag-grid-size) * 6); +} +.ag-filter-toolpanel-header:focus-visible { + border-radius: var(--ag-border-radius); + box-shadow: inset var(--ag-focus-shadow); +} +.ag-filter-toolpanel-header, +.ag-filter-toolpanel-search { + padding: 0 var(--ag-grid-size); +} +.ag-filter-toolpanel-group:not(.ag-has-filter) > .ag-group-title-bar .ag-filter-toolpanel-group-instance-header-icon { + display: none; +} +.ag-filter-toolpanel-group-level-0-header { + height: calc(var(--ag-grid-size) * 8); +} +.ag-filter-toolpanel-group-item { + margin-bottom: calc(var(--ag-grid-size) * 0.5); + margin-top: calc(var(--ag-grid-size) * 0.5); +} +.ag-filter-toolpanel-search { + margin-bottom: var(--ag-grid-size); + margin-top: var(--ag-widget-container-vertical-padding); +} +.ag-filter-toolpanel-search-input { + flex-grow: 1; + height: calc(var(--ag-grid-size) * 4); +} +.ag-ltr .ag-filter-toolpanel-group-title-bar-icon { + margin-right: var(--ag-grid-size); +} +.ag-rtl .ag-filter-toolpanel-group-title-bar-icon { + margin-left: var(--ag-grid-size); +} +.ag-filter-toolpanel-expand { + cursor: pointer; +} +.ag-ltr .ag-filter-toolpanel-expand { + margin-right: var(--ag-grid-size); +} +.ag-rtl .ag-filter-toolpanel-expand { + margin-left: var(--ag-grid-size); +} +.ag-ltr .ag-filter-toolpanel-group-title-bar, +.ag-ltr .ag-filter-toolpanel-instance-header { + padding-left: calc(var(--ag-grid-size) + var(--ag-filter-tool-panel-group-indent) * var(--ag-indentation-level)); +} +.ag-rtl .ag-filter-toolpanel-group-title-bar, +.ag-rtl .ag-filter-toolpanel-instance-header { + padding-right: calc(var(--ag-grid-size) + var(--ag-filter-tool-panel-group-indent) * var(--ag-indentation-level)); +} +.ag-ltr .ag-filter-toolpanel-instance-body { + margin-left: var(--ag-filter-tool-panel-group-indent); +} +.ag-rtl .ag-filter-toolpanel-instance-body { + margin-right: var(--ag-filter-tool-panel-group-indent); +} +.ag-ltr .ag-filter-toolpanel-instance-header.ag-filter-toolpanel-group-level-1-header { + padding-left: var(--ag-grid-size); +} +.ag-rtl .ag-filter-toolpanel-instance-header.ag-filter-toolpanel-group-level-1-header { + padding-right: var(--ag-grid-size); +} +.ag-ltr .ag-filter-toolpanel-group-instance-header-icon, +.ag-ltr .ag-filter-toolpanel-instance-header-icon { + margin-left: var(--ag-grid-size); +} +.ag-rtl .ag-filter-toolpanel-group-instance-header-icon, +.ag-rtl .ag-filter-toolpanel-instance-header-icon { + margin-right: var(--ag-grid-size); +} +.ag-filter-toolpanel-instance-filter { + background-color: var(--ag-chrome-background-color); +} +.ag-filter-toolpanel-group-level-0 { + border-top: none; +} +.ag-filter-toolpanel-header { + height: auto; + padding-bottom: var(--ag-grid-size); + padding-top: var(--ag-grid-size); +} +.ag-filter-toolpanel-group-item { + margin: 0; +} +.ag-filter-toolpanel-header, +.ag-filter-toolpanel-search { + color: var(--ag-header-text-color); + font-weight: 500; +} +.ag-paging-panel { + align-items: center; + border-top: var(--ag-footer-row-border); + display: flex; + gap: calc(var(--ag-grid-size) * 4); + height: max(var(--ag-row-height), 22px); + justify-content: flex-end; + padding: 0 var(--ag-cell-horizontal-padding); +} +.ag-paging-page-size .ag-wrapper { + min-width: 50px; +} +.ag-paging-page-summary-panel { + align-items: center; + display: flex; + gap: var(--ag-cell-widget-spacing); +} +.ag-disabled .ag-paging-page-summary-panel { + pointer-events: none; +} +.ag-paging-button { + cursor: pointer; + position: relative; +} +.ag-paging-button:focus-visible { + box-shadow: var(--ag-focus-shadow); +} +.ag-paging-button.ag-disabled { + cursor: default; + opacity: 0.5; +} +.ag-paging-number, +.ag-paging-row-summary-panel-number { + font-weight: 500; +} +.ag-status-bar { + border-top: var(--ag-footer-row-border); + display: flex; + justify-content: space-between; + line-height: 1.5; + overflow: hidden; + padding-left: calc(var(--ag-grid-size) * 4); + padding-right: calc(var(--ag-grid-size) * 4); +} +.ag-status-panel { + display: inline-flex; +} +.ag-status-name-value { + white-space: nowrap; +} +.ag-status-bar-center, +.ag-status-bar-left, +.ag-status-bar-right { + display: inline-flex; +} +.ag-status-bar-center { + text-align: center; +} +.ag-status-name-value { + margin-left: var(--ag-grid-size); + margin-right: var(--ag-grid-size); + padding-bottom: var(--ag-widget-container-vertical-padding); + padding-top: var(--ag-widget-container-vertical-padding); +} +.ag-status-name-value-value { + font-weight: 500; +} +.ag-overlay { + inset: 0; + pointer-events: none; + position: absolute; + z-index: 2; +} +.ag-overlay-panel, +.ag-overlay-wrapper { + display: flex; + height: 100%; + width: 100%; +} +.ag-overlay-wrapper { + align-items: center; + flex: none; + justify-content: center; + text-align: center; +} +.ag-overlay-loading-wrapper { + pointer-events: all; +} +.ag-overlay-loading-center { + background: var(--ag-background-color); + border: 1px solid var(--ag-border-color); + border-radius: var(--ag-border-radius); + box-shadow: var(--ag-popup-shadow); + padding: var(--ag-grid-size); +} +.ag-icon { + display: block; + height: var(--ag-icon-size); + position: relative; + -webkit-user-select: none; + -moz-user-select: none; + user-select: none; + width: var(--ag-icon-size); +} +.ag-column-select-column-group-readonly .ag-icon, +.ag-disabled .ag-icon, +[disabled] .ag-icon { + opacity: 0.5; +} +.ag-icon-grip { + opacity: 0.7; +} +.ag-column-select-column-readonly .ag-icon-grip, +.ag-column-select-column-readonly.ag-icon-grip { + opacity: 0.35; +} +:is( + .ag-header-cell-menu-button, + .ag-header-cell-filter-button, + .ag-panel-title-bar-button, + .ag-header-expand-icon, + .ag-column-group-icons, + .ag-set-filter-group-icons, + .ag-group-expanded .ag-icon, + .ag-group-contracted .ag-icon, + .ag-chart-settings-prev, + .ag-chart-settings-next, + .ag-group-title-bar-icon, + .ag-column-select-header-icon, + .ag-floating-filter-button-button, + .ag-filter-toolpanel-expand, + .ag-panel-title-bar-button-icon, + .ag-chart-menu-icon + ):hover { + background-color: var(--ag-icon-button-hover-color); + border-radius: 1px; + box-shadow: 0 0 0 4px var(--ag-icon-button-hover-color); +} +.ag-filter-active { + --ag-icon-button-hover-color: color-mix(in srgb, transparent, var(--ag-accent-color) 28%); + background-color: color-mix(in srgb, transparent, var(--ag-accent-color) 14%); + border-radius: 1px; + box-shadow: 0 0 0 4px color-mix(in srgb, transparent, var(--ag-accent-color) 14%); + position: relative; +} +.ag-filter-active:after { + background-color: var(--ag-accent-color); + border-radius: 50%; + content: ''; + height: 6px; + position: absolute; + top: -1px; + width: 6px; +} +.ag-ltr .ag-filter-active:after { + right: -1px; +} +.ag-rtl .ag-filter-active:after { + left: -1px; +} +.ag-filter-active .ag-icon-filter { + clip-path: path('M8,0C8,4.415 11.585,8 16,8L16,16L0,16L0,0L8,0Z'); +} +.ag-label-align-right .ag-label { + order: 1; +} +.ag-label-align-right > * { + flex: none; +} +.ag-label-align-top { + align-items: flex-start; + flex-direction: column; +} +.ag-label-align-top > * { + align-self: stretch; +} +.ag-label-ellipsis { + flex: 1; + overflow: hidden; + text-overflow: ellipsis; + white-space: nowrap; +} +.ag-label { + white-space: nowrap; +} +.ag-ltr .ag-label { + margin-right: var(--ag-grid-size); +} +.ag-rtl .ag-label { + margin-left: var(--ag-grid-size); +} +.ag-label-align-top .ag-label { + margin-bottom: calc(var(--ag-grid-size) * 0.5); +} +.ag-ltr .ag-label-align-right .ag-label { + margin-left: var(--ag-grid-size); +} +.ag-rtl .ag-label-align-right .ag-label { + margin-right: var(--ag-grid-size); +} + +/* Part iconSet/quartzRegular */ +.ag-icon::before { + content: ''; + display: block; + width: var(--ag-icon-size); + height: var(--ag-icon-size); + background-color: currentColor; + mask-size: contain; +} +.ag-icon-aggregation::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-aggregation%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22M18%207V4H6l6%208-6%208h12v-3%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-arrows::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-arrows%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpolyline%20points%3D%225%209%202%2012%205%2015%22%2F%3E%3Cpolyline%20points%3D%229%205%2012%202%2015%205%22%2F%3E%3Cpolyline%20points%3D%2215%2019%2012%2022%209%2019%22%2F%3E%3Cpolyline%20points%3D%2219%209%2022%2012%2019%2015%22%2F%3E%3Cline%20x1%3D%222%22%20x2%3D%2222%22%20y1%3D%2212%22%20y2%3D%2212%22%2F%3E%3Cline%20x1%3D%2212%22%20x2%3D%2212%22%20y1%3D%222%22%20y2%3D%2222%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-asc::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-asc%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22m5%2012%207-7%207%207%22%2F%3E%3Cpath%20d%3D%22M12%2019V5%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-cancel::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-cancel%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Ccircle%20cx%3D%2212%22%20cy%3D%2212%22%20r%3D%2210%22%2F%3E%3Cpath%20d%3D%22m15%209-6%206%22%2F%3E%3Cpath%20d%3D%22m9%209%206%206%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-chart::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-chart%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cline%20x1%3D%2218%22%20x2%3D%2218%22%20y1%3D%2220%22%20y2%3D%2210%22%2F%3E%3Cline%20x1%3D%2212%22%20x2%3D%2212%22%20y1%3D%2220%22%20y2%3D%224%22%2F%3E%3Cline%20x1%3D%226%22%20x2%3D%226%22%20y1%3D%2220%22%20y2%3D%2214%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-color-picker::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-color-picker%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22m19%2011-8-8-8.6%208.6a2%202%200%200%200%200%202.8l5.2%205.2c.8.8%202%20.8%202.8%200L19%2011Z%22%2F%3E%3Cpath%20d%3D%22m5%202%205%205%22%2F%3E%3Cpath%20d%3D%22M2%2013h15%22%2F%3E%3Cpath%20d%3D%22M22%2020a2%202%200%201%201-4%200c0-1.6%201.7-2.4%202-4%20.3%201.6%202%202.4%202%204Z%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-columns::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-columns%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22M9%203H5a2%202%200%200%200-2%202v4m6-6h10a2%202%200%200%201%202%202v4M9%203v18m0%200h10a2%202%200%200%200%202-2V9M9%2021H5a2%202%200%200%201-2-2V9m0%200h18%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-contracted::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-contracted%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22m9%2018%206-6-6-6%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-copy::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-copy%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Crect%20width%3D%2214%22%20height%3D%2214%22%20x%3D%228%22%20y%3D%228%22%20rx%3D%222%22%20ry%3D%222%22%2F%3E%3Cpath%20d%3D%22M4%2016c-1.1%200-2-.9-2-2V4c0-1.1.9-2%202-2h10c1.1%200%202%20.9%202%202%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-cross::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-cross%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22M18%206%206%2018%22%2F%3E%3Cpath%20d%3D%22m6%206%2012%2012%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-csv::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-csv%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22M14.5%202H6a2%202%200%200%200-2%202v16a2%202%200%200%200%202%202h12a2%202%200%200%200%202-2V7.5L14.5%202z%22%2F%3E%3Cpolyline%20points%3D%2214%202%2014%208%2020%208%22%2F%3E%3Cpath%20d%3D%22M8%2013h2%22%2F%3E%3Cpath%20d%3D%22M8%2017h2%22%2F%3E%3Cpath%20d%3D%22M14%2013h2%22%2F%3E%3Cpath%20d%3D%22M14%2017h2%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-cut::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-cut%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Ccircle%20cx%3D%226%22%20cy%3D%226%22%20r%3D%223%22%2F%3E%3Cpath%20d%3D%22M8.12%208.12%2012%2012%22%2F%3E%3Cpath%20d%3D%22M20%204%208.12%2015.88%22%2F%3E%3Ccircle%20cx%3D%226%22%20cy%3D%2218%22%20r%3D%223%22%2F%3E%3Cpath%20d%3D%22M14.8%2014.8%2020%2020%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-desc::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-desc%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22M12%205v14%22%2F%3E%3Cpath%20d%3D%22m19%2012-7%207-7-7%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-down::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-down%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22M12%205v14%22%2F%3E%3Cpath%20d%3D%22m19%2012-7%207-7-7%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-excel::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-excel%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22M14.5%202H6a2%202%200%200%200-2%202v16a2%202%200%200%200%202%202h12a2%202%200%200%200%202-2V7.5L14.5%202z%22%2F%3E%3Cpolyline%20points%3D%2214%202%2014%208%2020%208%22%2F%3E%3Cpath%20d%3D%22M8%2013h2%22%2F%3E%3Cpath%20d%3D%22M8%2017h2%22%2F%3E%3Cpath%20d%3D%22M14%2013h2%22%2F%3E%3Cpath%20d%3D%22M14%2017h2%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-expanded::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-expanded%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22m15%2018-6-6%206-6%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-eye-slash::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-eye-slash%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22M9.88%209.88a3%203%200%201%200%204.24%204.24%22%2F%3E%3Cpath%20d%3D%22M10.73%205.08A10.43%2010.43%200%200%201%2012%205c7%200%2010%207%2010%207a13.16%2013.16%200%200%201-1.67%202.68%22%2F%3E%3Cpath%20d%3D%22M6.61%206.61A13.526%2013.526%200%200%200%202%2012s3%207%2010%207a9.74%209.74%200%200%200%205.39-1.61%22%2F%3E%3Cline%20x1%3D%222%22%20x2%3D%2222%22%20y1%3D%222%22%20y2%3D%2222%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-eye::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-eye%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22M2%2012s3-7%2010-7%2010%207%2010%207-3%207-10%207-10-7-10-7Z%22%2F%3E%3Ccircle%20cx%3D%2212%22%20cy%3D%2212%22%20r%3D%223%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-filter::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-filter%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22M3%206h18%22%2F%3E%3Cpath%20d%3D%22M7%2012h10%22%2F%3E%3Cpath%20d%3D%22M10%2018h4%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-first::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-first%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22m17%2018-6-6%206-6%22%2F%3E%3Cpath%20d%3D%22M7%206v12%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-group::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-group%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22M16%2012H3%22%2F%3E%3Cpath%20d%3D%22M16%2018H3%22%2F%3E%3Cpath%20d%3D%22M10%206H3%22%2F%3E%3Cpath%20d%3D%22M21%2018V8a2%202%200%200%200-2-2h-5%22%2F%3E%3Cpath%20d%3D%22m16%208-2-2%202-2%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-last::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-last%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22m7%2018%206-6-6-6%22%2F%3E%3Cpath%20d%3D%22M17%206v12%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-left::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-left%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22m12%2019-7-7%207-7%22%2F%3E%3Cpath%20d%3D%22M19%2012H5%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-linked::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-linked%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22M9%2017H7A5%205%200%200%201%207%207h2%22%2F%3E%3Cpath%20d%3D%22M15%207h2a5%205%200%201%201%200%2010h-2%22%2F%3E%3Cline%20x1%3D%228%22%20x2%3D%2216%22%20y1%3D%2212%22%20y2%3D%2212%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-loading::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-loading%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cline%20x1%3D%2212%22%20x2%3D%2212%22%20y1%3D%222%22%20y2%3D%226%22%2F%3E%3Cline%20x1%3D%2212%22%20x2%3D%2212%22%20y1%3D%2218%22%20y2%3D%2222%22%2F%3E%3Cline%20x1%3D%224.93%22%20x2%3D%227.76%22%20y1%3D%224.93%22%20y2%3D%227.76%22%2F%3E%3Cline%20x1%3D%2216.24%22%20x2%3D%2219.07%22%20y1%3D%2216.24%22%20y2%3D%2219.07%22%2F%3E%3Cline%20x1%3D%222%22%20x2%3D%226%22%20y1%3D%2212%22%20y2%3D%2212%22%2F%3E%3Cline%20x1%3D%2218%22%20x2%3D%2222%22%20y1%3D%2212%22%20y2%3D%2212%22%2F%3E%3Cline%20x1%3D%224.93%22%20x2%3D%227.76%22%20y1%3D%2219.07%22%20y2%3D%2216.24%22%2F%3E%3Cline%20x1%3D%2216.24%22%20x2%3D%2219.07%22%20y1%3D%227.76%22%20y2%3D%224.93%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-maximize::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-maximize%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpolyline%20points%3D%2215%203%2021%203%2021%209%22%2F%3E%3Cpolyline%20points%3D%229%2021%203%2021%203%2015%22%2F%3E%3Cline%20x1%3D%2221%22%20x2%3D%2214%22%20y1%3D%223%22%20y2%3D%2210%22%2F%3E%3Cline%20x1%3D%223%22%20x2%3D%2210%22%20y1%3D%2221%22%20y2%3D%2214%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-menu::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-menu%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cline%20x1%3D%224%22%20x2%3D%2220%22%20y1%3D%2212%22%20y2%3D%2212%22%2F%3E%3Cline%20x1%3D%224%22%20x2%3D%2220%22%20y1%3D%226%22%20y2%3D%226%22%2F%3E%3Cline%20x1%3D%224%22%20x2%3D%2220%22%20y1%3D%2218%22%20y2%3D%2218%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-menu-alt::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-menu-alt%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Ccircle%20cx%3D%2212%22%20cy%3D%225%22%20r%3D%220.75%22%20fill%3D%22%23D9D9D9%22%2F%3E%3Ccircle%20cx%3D%2212%22%20cy%3D%2212%22%20r%3D%220.75%22%20fill%3D%22%23D9D9D9%22%2F%3E%3Ccircle%20cx%3D%2212%22%20cy%3D%2219%22%20r%3D%220.75%22%20fill%3D%22%23D9D9D9%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-minimize::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-minimize%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpolyline%20points%3D%224%2014%2010%2014%2010%2020%22%2F%3E%3Cpolyline%20points%3D%2220%2010%2014%2010%2014%204%22%2F%3E%3Cline%20x1%3D%2214%22%20x2%3D%2221%22%20y1%3D%2210%22%20y2%3D%223%22%2F%3E%3Cline%20x1%3D%223%22%20x2%3D%2210%22%20y1%3D%2221%22%20y2%3D%2214%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-minus::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-minus%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Ccircle%20cx%3D%2212%22%20cy%3D%2212%22%20r%3D%2210%22%2F%3E%3Cpath%20d%3D%22M8%2012h8%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-next::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-next%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22m9%2018%206-6-6-6%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-none::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-none%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22m7%2015%205%205%205-5%22%2F%3E%3Cpath%20d%3D%22m7%209%205-5%205%205%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-not-allowed::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-not-allowed%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Ccircle%20cx%3D%2212%22%20cy%3D%2212%22%20r%3D%2210%22%2F%3E%3Cpath%20d%3D%22m4.9%204.9%2014.2%2014.2%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-paste::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-paste%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22M15%202H9a1%201%200%200%200-1%201v2c0%20.6.4%201%201%201h6c.6%200%201-.4%201-1V3c0-.6-.4-1-1-1Z%22%2F%3E%3Cpath%20d%3D%22M8%204H6a2%202%200%200%200-2%202v14a2%202%200%200%200%202%202h12a2%202%200%200%200%202-2M16%204h2a2%202%200%200%201%202%202v2M11%2014h10%22%2F%3E%3Cpath%20d%3D%22m17%2010%204%204-4%204%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-pin::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-pin%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cline%20x1%3D%2212%22%20x2%3D%2212%22%20y1%3D%2217%22%20y2%3D%2222%22%2F%3E%3Cpath%20d%3D%22M5%2017h14v-1.76a2%202%200%200%200-1.11-1.79l-1.78-.9A2%202%200%200%201%2015%2010.76V6h1a2%202%200%200%200%200-4H8a2%202%200%200%200%200%204h1v4.76a2%202%200%200%201-1.11%201.79l-1.78.9A2%202%200%200%200%205%2015.24Z%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-pivot::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-pivot%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22M15%203v18%22%2F%3E%3Crect%20width%3D%2218%22%20height%3D%2218%22%20x%3D%223%22%20y%3D%223%22%20rx%3D%222%22%2F%3E%3Cpath%20d%3D%22M21%209H3%22%2F%3E%3Cpath%20d%3D%22M21%2015H3%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-plus::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-plus%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Ccircle%20cx%3D%2212%22%20cy%3D%2212%22%20r%3D%2210%22%2F%3E%3Cpath%20d%3D%22M8%2012h8%22%2F%3E%3Cpath%20d%3D%22M12%208v8%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-previous::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-previous%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22m15%2018-6-6%206-6%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-right::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-right%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22M5%2012h14%22%2F%3E%3Cpath%20d%3D%22m12%205%207%207-7%207%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-save::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-save%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22M12%2017V3%22%2F%3E%3Cpath%20d%3D%22m6%2011%206%206%206-6%22%2F%3E%3Cpath%20d%3D%22M19%2021H5%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-small-down::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-small-down%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22m6%209%206%206%206-6%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-small-left::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-small-left%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22m15%2018-6-6%206-6%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-small-right::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-small-right%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22m9%2018%206-6-6-6%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-small-up::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-small-up%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22m18%2015-6-6-6%206%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-tick::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-tick%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22M20%206%209%2017l-5-5%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-tree-closed::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-tree-closed%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22m9%2018%206-6-6-6%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-tree-indeterminate::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-tree-indeterminate%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22M5%2012h14%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-tree-open::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-tree-open%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22m6%209%206%206%206-6%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-unlinked::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-unlinked%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22M9%2017H7A5%205%200%200%201%207%207%22%2F%3E%3Cpath%20d%3D%22M15%207h2a5%205%200%200%201%204%208%22%2F%3E%3Cline%20x1%3D%228%22%20x2%3D%2212%22%20y1%3D%2212%22%20y2%3D%2212%22%2F%3E%3Cline%20x1%3D%222%22%20x2%3D%2222%22%20y1%3D%222%22%20y2%3D%2222%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-up::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-up%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22m5%2012%207-7%207%207%22%2F%3E%3Cpath%20d%3D%22M12%2019V5%22%2F%3E%3C%2Fsvg%3E'); +} +.ag-icon-grip::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-grip%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Ccircle%20cx%3D%225%22%20cy%3D%228%22%20r%3D%220.5%22%2F%3E%3Ccircle%20cx%3D%2212%22%20cy%3D%228%22%20r%3D%220.5%22%2F%3E%3Ccircle%20cx%3D%2219%22%20cy%3D%228%22%20r%3D%220.5%22%2F%3E%3Ccircle%20cx%3D%225%22%20cy%3D%2216%22%20r%3D%220.5%22%2F%3E%3Ccircle%20cx%3D%2212%22%20cy%3D%2216%22%20r%3D%220.5%22%2F%3E%3Ccircle%20cx%3D%2219%22%20cy%3D%2216%22%20r%3D%220.5%22%2F%3E%3Cg%20stroke%3D%22none%22%20fill%3D%22currentColor%22%3E%3Ccircle%20cx%3D%225%22%20cy%3D%228%22%20r%3D%221%22%2F%3E%3Ccircle%20cx%3D%2212%22%20cy%3D%228%22%20r%3D%221%22%2F%3E%3Ccircle%20cx%3D%2219%22%20cy%3D%228%22%20r%3D%221%22%2F%3E%3Ccircle%20cx%3D%225%22%20cy%3D%2216%22%20r%3D%221%22%2F%3E%3Ccircle%20cx%3D%2212%22%20cy%3D%2216%22%20r%3D%221%22%2F%3E%3Ccircle%20cx%3D%2219%22%20cy%3D%2216%22%20r%3D%221%22%2F%3E%3C%2Fg%3E%3C%2Fsvg%3E'); +} +.ag-icon-settings::before { + mask-image: url('data:image/svg+xml,%3Csvg%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F2000%2Fsvg%22%20class%3D%22ag-icon%20ag-icon-settings%22%20fill%3D%22none%22%20stroke-linecap%3D%22round%22%20stroke-linejoin%3D%22round%22%20stroke%3D%22black%22%20stroke-width%3D%221.5%22%20viewBox%3D%220%200%2024%2024%22%3E%3Cstyle%3E*%20%7B%20vector-effect%3A%20non-scaling-stroke%3B%20%7D%3C%2Fstyle%3E%3Cpath%20d%3D%22M20%207h-9%22%2F%3E%3Cpath%20d%3D%22M14%2017H5%22%2F%3E%3Ccircle%20cx%3D%2217%22%20cy%3D%2217%22%20r%3D%223%22%2F%3E%3Ccircle%20cx%3D%227%22%20cy%3D%227%22%20r%3D%223%22%2F%3E%3C%2Fsvg%3E'); +} + +/* Part tabStyle/quartz */ +.ag-tabs-header { + background-color: var(--ag-tab-bar-background-color); + border-bottom: var(--ag-tab-bar-border); + gap: var(--ag-tab-spacing); + padding: var(--ag-tab-bar-top-padding) var(--ag-tab-bar-horizontal-padding) 0; +} +.ag-tabs-header-wrapper { + display: flex; +} +.ag-tabs-header-wrapper .ag-tabs-header { + flex: 1; +} +.ag-tabs-close-button-wrapper { + border: 0; + padding: var(--ag-grid-size); +} +.ag-ltr .ag-tabs-close-button-wrapper { + border-right: 1px solid var(--ag-border-color); +} +.ag-rtl .ag-tabs-close-button-wrapper { + border-left: 1px solid var(--ag-border-color); +} +.ag-tabs-close-button { + background-color: unset; + border: 0; + cursor: pointer; + padding: 0; +} +.ag-tab { + align-items: center; + background-color: var(--ag-tab-background-color); + border-left: var(--ag-tab-selected-border-width) solid transparent; + border-right: var(--ag-tab-selected-border-width) solid transparent; + color: var(--ag-tab-text-color); + display: flex; + flex: 1; + justify-content: center; + padding: var(--ag-tab-top-padding) var(--ag-tab-horizontal-padding) var(--ag-tab-bottom-padding); + position: relative; +} +.ag-tab:hover { + background-color: var(--ag-tab-hover-background-color); + color: var(--ag-tab-hover-text-color); +} +.ag-tab.ag-tab-selected { + background-color: var(--ag-tab-selected-background-color); + color: var(--ag-tab-selected-text-color); +} +.ag-ltr .ag-tab.ag-tab-selected:not(:first-of-type) { + border-left-color: var(--ag-tab-selected-border-color); +} +.ag-ltr .ag-tab.ag-tab-selected:not(:last-of-type), +.ag-rtl .ag-tab.ag-tab-selected:not(:first-of-type) { + border-right-color: var(--ag-tab-selected-border-color); +} +.ag-rtl .ag-tab.ag-tab-selected:not(:last-of-type) { + border-left-color: var(--ag-tab-selected-border-color); +} +.ag-tab:after { + background-color: var(--ag-tab-selected-underline-color); + bottom: 0; + content: ''; + display: block; + height: var(--ag-tab-selected-underline-width); + left: 0; + opacity: 0; + position: absolute; + right: 0; + transition: opacity var(--ag-tab-selected-underline-transition-duration); +} +.ag-tab.ag-tab-selected:after { + opacity: 1; +} +.ag-tab:focus-visible { + box-shadow: inset var(--ag-focus-shadow); +} + +/* Part inputStyle/bordered */ +:where(input[class^='ag-'][type='number']:not(.ag-number-field-input-stepper)) { + -moz-appearance: textfield; +} +:where(input[class^='ag-'][type='number']:not(.ag-number-field-input-stepper))::-webkit-inner-spin-button, +:where(input[class^='ag-'][type='number']:not(.ag-number-field-input-stepper))::-webkit-outer-spin-button { + -webkit-appearance: none; + margin: 0; +} +:where( + input[class^='ag-']:not([type]), + input[class^='ag-'][type='text'], + input[class^='ag-'][type='number'], + input[class^='ag-'][type='tel'], + input[class^='ag-'][type='date'], + input[class^='ag-'][type='datetime-local'], + textarea[class^='ag-'] + ) { + background-color: var(--ag-input-background-color); + border: var(--ag-input-border); + border-radius: var(--ag-input-border-radius); + color: var(--ag-input-text-color); + min-height: var(--ag-input-height); +} +.ag-ltr + :where( + input[class^='ag-']:not([type]), + input[class^='ag-'][type='text'], + input[class^='ag-'][type='number'], + input[class^='ag-'][type='tel'], + input[class^='ag-'][type='date'], + input[class^='ag-'][type='datetime-local'], + textarea[class^='ag-'] + ) { + padding-left: var(--ag-input-padding-start); +} +.ag-rtl + :where( + input[class^='ag-']:not([type]), + input[class^='ag-'][type='text'], + input[class^='ag-'][type='number'], + input[class^='ag-'][type='tel'], + input[class^='ag-'][type='date'], + input[class^='ag-'][type='datetime-local'], + textarea[class^='ag-'] + ) { + padding-right: var(--ag-input-padding-start); +} +:where( + input[class^='ag-']:not([type]), + input[class^='ag-'][type='text'], + input[class^='ag-'][type='number'], + input[class^='ag-'][type='tel'], + input[class^='ag-'][type='date'], + input[class^='ag-'][type='datetime-local'], + textarea[class^='ag-'] + ):where(:disabled) { + background-color: var(--ag-input-disabled-background-color); + border: var(--ag-input-disabled-border); + color: var(--ag-input-disabled-text-color); +} +:where( + input[class^='ag-']:not([type]), + input[class^='ag-'][type='text'], + input[class^='ag-'][type='number'], + input[class^='ag-'][type='tel'], + input[class^='ag-'][type='date'], + input[class^='ag-'][type='datetime-local'], + textarea[class^='ag-'] + ):where(:focus) { + background-color: var(--ag-input-focus-background-color); + border: var(--ag-input-focus-border); + box-shadow: var(--ag-input-focus-shadow); + color: var(--ag-input-focus-text-color); +} +:where( + input[class^='ag-']:not([type]), + input[class^='ag-'][type='text'], + input[class^='ag-'][type='number'], + input[class^='ag-'][type='tel'], + input[class^='ag-'][type='date'], + input[class^='ag-'][type='datetime-local'], + textarea[class^='ag-'] + ):where(:invalid) { + background-color: var(--ag-input-invalid-background-color); + border: var(--ag-input-invalid-border); + color: var(--ag-input-invalid-text-color); +} +:where( + input[class^='ag-']:not([type]), + input[class^='ag-'][type='text'], + input[class^='ag-'][type='number'], + input[class^='ag-'][type='tel'], + input[class^='ag-'][type='date'], + input[class^='ag-'][type='datetime-local'], + textarea[class^='ag-'] + ):where(.invalid) { + background-color: var(--ag-input-invalid-background-color); + border: var(--ag-input-invalid-border); + color: var(--ag-input-invalid-text-color); +} diff --git a/src/base/presentation/assets/styles/main.less b/src/base/presentation/assets/styles/main.less new file mode 100644 index 0000000..9feb35d --- /dev/null +++ b/src/base/presentation/assets/styles/main.less @@ -0,0 +1,72 @@ +@tailwind base; +@tailwind components; +@tailwind utilities; + +@import url('./ag-grid-theme-builder.css'); +@import url('../fonts/fonts.less'); + +* { + font-family: Urbanist, sans-serif; +} + +html { + -webkit-text-size-adjust: 100%; + scroll-behavior: smooth; +} + +body { + margin: 0; +} + +label { + font-size: 15px !important; +} + +.ant-modal-title, +.color-primary, +label { + color: #623c7c !important; +} + +.bg-warning { + background-color: #d4940d; +} + +.bg-turqoise { + background-color: #c2edf0; +} + +.bg-softpurple { + background-color: #d5c7f0; +} + +.bg-softcyan { + background-color: #c4dcf0; +} + +.bg-secondary { + background-color: #78cbbb; +} + +.force-px-2 { + .ant-input-number-input { + padding: 2px 4px !important; + } + padding: 2px 4px !important; +} + +.bg-primary { + background-color: #7a41a1 !important; +} + +.bg-waiting { + background-color: #6c5dd0; +} + +.bg-refunded { + background-color: #d7a29a; +} + +a { + text-decoration: none !important; +} diff --git a/src/base/presentation/assets/themes/index.ts b/src/base/presentation/assets/themes/index.ts new file mode 100644 index 0000000..ccc3d42 --- /dev/null +++ b/src/base/presentation/assets/themes/index.ts @@ -0,0 +1,3 @@ +import { LIGHT } from './light-theme'; + +export const APP_THEME = { LIGHT }; diff --git a/src/base/presentation/assets/themes/light-theme.ts b/src/base/presentation/assets/themes/light-theme.ts new file mode 100644 index 0000000..b4c362e --- /dev/null +++ b/src/base/presentation/assets/themes/light-theme.ts @@ -0,0 +1,43 @@ +import { ThemeConfig } from 'antd'; + +const globalInputConfig = { + borderRadius: 16, + colorBgContainer: '#f0e6f6', + colorBorder: '#f0e6f6', + addonBg: '#f0e6f6', + paddingInline: 18, +}; + +export const LIGHT: ThemeConfig = { + token: { + colorPrimary: '#7a41a1', + // colorPrimary: '#934ac0', + fontFamily: `Urbanist, sans-serif`, + wireframe: true, + colorFillSecondary: '#f0e6f6', + fontSize: 14, + }, + components: { + Menu: { + algorithm: true, + motionDurationSlow: '0s', + motionDurationMid: '0s', + }, + Card: { + borderRadiusLG: 9, + }, + Select: { + borderRadius: 168, + colorText: '#722ED1', + }, + Input: globalInputConfig, + InputNumber: globalInputConfig, + DatePicker: globalInputConfig, + Table: { + borderRadius: 16, + borderColor: '#ddd', + headerColor: '#7a41a1', + colorText: '#666666', + }, + }, +}; diff --git a/src/base/presentation/hooks/app-module/app-module.entity.ts b/src/base/presentation/hooks/app-module/app-module.entity.ts new file mode 100644 index 0000000..6fcca51 --- /dev/null +++ b/src/base/presentation/hooks/app-module/app-module.entity.ts @@ -0,0 +1,93 @@ +import { ReactNode, RefObject } from 'react'; +import { RecoilState } from 'recoil'; +import { BaseEntity, DataServicesConstructorEntity } from '@pos/base/domain/entities'; +import { IBaseDataServicesRepository, IBaseTransformerRepository } from '@pos/base/domain/repositories'; + +import { FormInstance } from 'antd'; +import { AgGridReact } from 'ag-grid-react'; +import { RefreshServerSideParams } from 'ag-grid-community'; + +export interface ModuleConfigEntity { + webUrl: string; + moduleKey: string; + tabTitle: string; + dataServicesTransformer?: IBaseTransformerRepository; + dataServicesConfig: DataServicesConstructorEntity; + moduleType: 'single_page' | 'multiple_page'; + moduleCategory: 'default' | 'transaction'; + singlePageFormType?: 'modal' | 'drawer'; + singlePageDetailType?: 'modal' | 'drawer'; + + // state definition + metaIndexDataAtomState: RecoilState; + selectedIndexDataAtomState: RecoilState; + filterIndexDataAtomState: RecoilState; + + // access control state definition + privilegeAtomState: RecoilState; +} + +export interface ModuleProviderProps { + configuration: ModuleConfigEntity; + children?: ReactNode; +} + +export interface SinglePageFormConfigEntity { + open: boolean; + dataId?: string; + data?: any; + type: 'create' | 'edit' | 'duplicate' | string; +} + +export interface SinglePageDetailConfigEntity { + open: boolean; + dataId?: string; + data?: any; +} + +export interface UseAppModuleHookEntity { + webUrl?: string; + moduleKey: string; + moduleType: 'single_page' | 'multiple_page'; + moduleCategory: 'default' | 'transaction'; + + dataServices: IBaseDataServicesRepository; + dataServicesConfig: DataServicesConstructorEntity; + transformer?: IBaseTransformerRepository; + + privilege: any; + + metaData: any; + setMetaData(payload: any): void; + filterData: any; + setFilterData(payload: any): void; + selectedData: any; + setSelectedData(payload: any): void; + + formControl: FormInstance; + formControlDetail: FormInstance; + formControlFilter: FormInstance; + + singlePageFormType?: 'modal' | 'drawer'; + singlePageFormConfig: SinglePageFormConfigEntity; + setSinglePageFormConfig(value: SinglePageFormConfigEntity): void; + + singlePageDetailType?: 'modal' | 'drawer'; + singlePageDetailConfig: SinglePageDetailConfigEntity; + setSinglePageDetailConfig(value: SinglePageDetailConfigEntity): void; + + createAnotherData: boolean; + setCreateAnotherData(value: boolean): void; + + loadingGetDataDetail: boolean; + setLoadingGetDataDetail(value: boolean): void; + + loadingGetDataForm: boolean; + setLoadingGetDataForm(value: boolean): void; + + indexGridRef: RefObject; + handleRefreshIndexTable(params?: RefreshServerSideParams): void; + + gridConfiguration?: any; + setGridConfiguration?(payload: any): void; +} diff --git a/src/base/presentation/hooks/app-module/app-module.hook.tsx b/src/base/presentation/hooks/app-module/app-module.hook.tsx new file mode 100644 index 0000000..b555287 --- /dev/null +++ b/src/base/presentation/hooks/app-module/app-module.hook.tsx @@ -0,0 +1,8 @@ +import React from 'react'; +import { UseAppModuleHookEntity } from './app-module.entity'; +import { BaseEntity } from '@pos/base/domain/entities'; +import { ModuleProviderContext } from './app-module.provider'; + +export function useAppModule() { + return React.useContext>(ModuleProviderContext); +} diff --git a/src/base/presentation/hooks/app-module/app-module.provider.tsx b/src/base/presentation/hooks/app-module/app-module.provider.tsx new file mode 100644 index 0000000..b41c168 --- /dev/null +++ b/src/base/presentation/hooks/app-module/app-module.provider.tsx @@ -0,0 +1,157 @@ +import React, { useRef, useState, useEffect } from 'react'; +import { makeCommonDataServices, makeCommonTransformer } from '@pos/base/domain/factories'; +import { IBaseTransformerRepository } from '@pos/base/domain/repositories'; +import { + ModuleProviderProps, + SinglePageDetailConfigEntity, + SinglePageFormConfigEntity, + UseAppModuleHookEntity, +} from './app-module.entity'; +import { BaseEntity } from '@pos/base/domain/entities'; +// import { useNavigate } from 'react-router-dom'; +import { useRecoilState } from 'recoil'; + +import { Form } from 'antd'; +import { AgGridReact } from 'ag-grid-react'; +import { RefreshServerSideParams } from 'ag-grid-community'; +import { StoragePrivilege, StorageUserData } from '@pos/base/data/local-data-services'; +import { capitalizeEachWord } from '@pos/base/infrastructure/helpers'; +import { defaultAppPrivilege } from '@pos/base/infrastructure/constants'; + +const commonTransformer: IBaseTransformerRepository = makeCommonTransformer(); +export const ModuleProviderContext = React.createContext>(null as any); + +export function ModuleProvider(props: ModuleProviderProps) { + const { configuration, children } = props; + const { + webUrl, + moduleKey, + tabTitle, + dataServicesTransformer, + dataServicesConfig, + + moduleCategory, + moduleType, + + metaIndexDataAtomState, + selectedIndexDataAtomState, + filterIndexDataAtomState, + + privilegeAtomState, + singlePageFormType, + singlePageDetailType, + } = configuration; + + // const navigate = useNavigate(); + + const [formControl] = Form.useForm(); + const [formControlDetail] = Form.useForm(); + const [formControlFilter] = Form.useForm(); + + const [privilege, setPrivilege] = useRecoilState(privilegeAtomState); + + const [metaData, setMetaData] = useRecoilState(metaIndexDataAtomState); + const [filterData, setFilterData] = useRecoilState(filterIndexDataAtomState); + const [selectedData, setSelectedData] = useRecoilState(selectedIndexDataAtomState); + + const [createAnotherData, setCreateAnotherData] = useState(false); + const [loadingGetDataDetail, setLoadingGetDataDetail] = useState(false); + const [loadingGetDataForm, setLoadingGetDataForm] = useState(false); + + const [gridConfiguration, setGridConfiguration] = useState(); + + const [singlePageDetailConfig, setSinglePageDetailConfig] = useState({ + open: false, + dataId: undefined, + }); + const [singlePageFormConfig, setSinglePageFormConfig] = useState({ + open: false, + dataId: undefined, + type: 'create', + }); + + const dataServices = makeCommonDataServices({ + ...dataServicesConfig, + moduleKey: 'ADMIN_PAGE.' + moduleKey, + }); // use makeCommonDataServices at react-base + const transformer: IBaseTransformerRepository = (dataServicesTransformer as any) ?? commonTransformer; + + const indexGridRef = useRef(null); + + async function handleRefreshIndexTable({ route = [], purge = true }: RefreshServerSideParams = {}) { + indexGridRef?.current?.api.refreshServerSide({ route, purge }); + } + + const ModuleProviderValue: UseAppModuleHookEntity = { + webUrl: webUrl, + moduleKey: 'ADMIN_PAGE.' + moduleKey, + moduleType: moduleType, + moduleCategory: moduleCategory, + + dataServices: dataServices, + dataServicesConfig: dataServicesConfig, + privilege: privilege, + transformer: transformer, + + metaData: metaData, + setMetaData: setMetaData, + filterData: filterData, + setFilterData: setFilterData, + selectedData: selectedData, + setSelectedData: setSelectedData, + + formControl: formControl, + formControlDetail: formControlDetail, + formControlFilter: formControlFilter, + + singlePageFormType: singlePageFormType, + singlePageFormConfig: singlePageFormConfig, + setSinglePageFormConfig: setSinglePageFormConfig, + + singlePageDetailType: singlePageDetailType, + singlePageDetailConfig: singlePageDetailConfig, + setSinglePageDetailConfig: setSinglePageDetailConfig, + + createAnotherData: createAnotherData, + setCreateAnotherData: setCreateAnotherData, + + loadingGetDataDetail: loadingGetDataDetail, + setLoadingGetDataDetail: setLoadingGetDataDetail, + loadingGetDataForm: loadingGetDataForm, + setLoadingGetDataForm: setLoadingGetDataForm, + + indexGridRef: indexGridRef, + handleRefreshIndexTable, + + gridConfiguration, + setGridConfiguration, + }; + + async function setupPrivilege() { + const moduleKey = configuration.moduleKey; + const storePrivilege = await StoragePrivilege.get(); + const user = await StorageUserData.get(); + let appPrivilege = storePrivilege?.[moduleKey?.split('.')?.[0]]; + if (user?.role === 'superadmin') appPrivilege = defaultAppPrivilege; + setPrivilege(appPrivilege); + } + + useEffect(() => { + if (Object.keys(privilege ?? {}).length === 0) { + setupPrivilege(); + } else { + // TODO => UNCOMMENT CODE BELLOW IF PRIVILEGE MODULE IS READY + // const allowView = privilege?.access_right?.view; + // if (!allowView) navigate('/403', { replace: true }); + } + }, [privilege]); + + useEffect(() => { + if (tabTitle) document.title = `POS - ${capitalizeEachWord(tabTitle)}`; + return () => { + document.title = 'POS'; + }; + }, [tabTitle]); + + return {children}; +} diff --git a/src/base/presentation/hooks/app-module/index.ts b/src/base/presentation/hooks/app-module/index.ts new file mode 100644 index 0000000..301c8ae --- /dev/null +++ b/src/base/presentation/hooks/app-module/index.ts @@ -0,0 +1,3 @@ +export * from './app-module.entity'; +export * from './app-module.hook'; +export * from './app-module.provider'; diff --git a/src/base/presentation/hooks/index.ts b/src/base/presentation/hooks/index.ts new file mode 100644 index 0000000..94bad8d --- /dev/null +++ b/src/base/presentation/hooks/index.ts @@ -0,0 +1 @@ +export * from './app-module'; diff --git a/src/base/presentation/providers/index.ts b/src/base/presentation/providers/index.ts new file mode 100644 index 0000000..6084ef7 --- /dev/null +++ b/src/base/presentation/providers/index.ts @@ -0,0 +1 @@ +export * from './recoil-debug-observer/recoil-debug-observer'; diff --git a/src/base/presentation/providers/recoil-debug-observer/recoil-debug-observer.tsx b/src/base/presentation/providers/recoil-debug-observer/recoil-debug-observer.tsx new file mode 100644 index 0000000..e94fb44 --- /dev/null +++ b/src/base/presentation/providers/recoil-debug-observer/recoil-debug-observer.tsx @@ -0,0 +1,21 @@ +import { APP_MODE } from '@pos/base/infrastructure/constants'; +import { ReactNode, useEffect } from 'react'; +import { useRecoilSnapshot } from 'recoil'; + +export function DebugObserver(): ReactNode { + const snapshot = useRecoilSnapshot(); + useEffect(() => { + if (APP_MODE === 'development') { + console.debug( + '%c' + 'The following atoms were modified:', + 'color:yellow; font-weight:bold; text-transform: uppercase;', + ); + for (const node of snapshot.getNodes_UNSTABLE({ isModified: true })) { + console.debug('%c' + node.key, 'color:white; background-color:blue', snapshot.getLoadable(node)); + } + console.debug('%c' + '----------------------------------------', 'color:white'); + } + }, [snapshot]); + + return null; +} diff --git a/src/base/presentation/states/account.state.ts b/src/base/presentation/states/account.state.ts new file mode 100644 index 0000000..bb8802e --- /dev/null +++ b/src/base/presentation/states/account.state.ts @@ -0,0 +1,16 @@ +import { selector } from 'recoil'; +import { StorageActiveAccount, StorageUserData } from '@pos/base'; + +export const ActiveAccountIDState = selector({ + key: 'active_account_id_state', + get: async () => { + return await StorageActiveAccount.get(); + }, +}); + +export const UserDataState = selector({ + key: 'user_data_state', + get: async () => { + return await StorageUserData.get(); + }, +}); diff --git a/src/base/presentation/states/config.state.ts b/src/base/presentation/states/config.state.ts new file mode 100644 index 0000000..cef049c --- /dev/null +++ b/src/base/presentation/states/config.state.ts @@ -0,0 +1,11 @@ +import { atom } from 'recoil'; + +export const ActiveMenuState = atom({ + key: 'active_menu_state', + default: '', +}); + +export const CollapsedSidebarMenuState = atom({ + key: 'collapsed_sidebar_menu_state', + default: false, +}); diff --git a/src/base/presentation/states/index.ts b/src/base/presentation/states/index.ts new file mode 100644 index 0000000..d6f65ba --- /dev/null +++ b/src/base/presentation/states/index.ts @@ -0,0 +1,2 @@ +export * from './account.state'; +export * from './config.state'; diff --git a/tsconfig.app.json b/tsconfig.app.json index f0a2350..44ffe90 100644 --- a/tsconfig.app.json +++ b/tsconfig.app.json @@ -17,8 +17,15 @@ /* Linting */ "strict": true, "noUnusedLocals": true, - "noUnusedParameters": true, - "noFallthroughCasesInSwitch": true + "noUnusedParameters": false, + "noFallthroughCasesInSwitch": true, + + /* Aliases */ + "paths": { + "@pos/*": ["./src/*"], + "@pos/base/*": ["./src/base/*"], + "@pos/assets/*": ["./src/base/presentation/assets/*"] + } }, "include": ["src"] } diff --git a/vite.config.ts b/vite.config.ts index 861b04b..c7be0b4 100644 --- a/vite.config.ts +++ b/vite.config.ts @@ -1,7 +1,15 @@ -import { defineConfig } from 'vite' -import react from '@vitejs/plugin-react-swc' +import { defineConfig } from 'vite'; +import react from '@vitejs/plugin-react-swc'; +import path from 'path'; // https://vitejs.dev/config/ export default defineConfig({ plugins: [react()], -}) + resolve: { + alias: { + '@pos/assets': path.resolve(__dirname, './src/base/presentation/assets'), + '@pos/base': path.resolve(__dirname, './src/base'), + '@pos': path.resolve(__dirname, './src/'), + }, + }, +});