diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 656f42e3..de181ca9 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -13,7 +13,7 @@ jobs: - name: Setup Node.js uses: actions/setup-node@v4 with: - node-version: 20 + node-version: 24 - name: Install Dependencies run: npm i diff --git a/.github/workflows/tag-and-publish.yml b/.github/workflows/tag-and-publish.yml index 8db826ea..e6db9741 100644 --- a/.github/workflows/tag-and-publish.yml +++ b/.github/workflows/tag-and-publish.yml @@ -2,14 +2,72 @@ name: Tag, Release, & Publish permissions: contents: write + id-token: write on: push: branches: - master + - ci/npm-trusted-publishing jobs: + verify-trusted-publishing: + if: github.ref == 'refs/heads/ci/npm-trusted-publishing' + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + + - uses: actions/setup-node@v4 + with: + node-version: 24 + registry-url: https://registry.npmjs.org + + - name: Check npm version + run: npm --version + + - name: Exchange OIDC token with npm + run: | + node --input-type=module <<'NODE' + const audience = "npm:registry.npmjs.org"; + const packageName = "ordercloud-javascript-sdk"; + const requestUrl = process.env.ACTIONS_ID_TOKEN_REQUEST_URL; + const requestToken = process.env.ACTIONS_ID_TOKEN_REQUEST_TOKEN; + if (!requestUrl || !requestToken) { + throw new Error("GitHub did not provide an OIDC token request endpoint."); + } + + const separator = requestUrl.includes("?") ? "&" : "?"; + const identityResponse = await fetch( + `${requestUrl}${separator}audience=${encodeURIComponent(audience)}`, + { headers: { Authorization: `bearer ${requestToken}` } } + ); + if (!identityResponse.ok) { + throw new Error(`GitHub OIDC request failed (${identityResponse.status}).`); + } + const { value: identityToken } = await identityResponse.json(); + if (!identityToken) { + throw new Error("GitHub OIDC response did not include an identity token."); + } + console.log(`::add-mask::${identityToken}`); + + const exchangeResponse = await fetch( + `https://registry.npmjs.org/-/npm/v1/oidc/token/exchange/package/${encodeURIComponent(packageName)}`, + { method: "POST", headers: { Authorization: `Bearer ${identityToken}` } } + ); + const body = await exchangeResponse.json().catch(() => ({})); + if (body.token) console.log(`::add-mask::${body.token}`); + if (!exchangeResponse.ok || !body.token) { + const detail = { ...body }; + delete detail.token; + throw new Error( + `npm rejected the trusted publisher (${exchangeResponse.status}): ${JSON.stringify(detail)}` + ); + } + console.log(`Trusted publishing accepted. Publish token expires ${body.expires ?? "unknown"}.`); + NODE + build: + if: github.ref == 'refs/heads/master' runs-on: windows-latest # ubuntu throws error on build steps: - uses: actions/checkout@v4 @@ -17,7 +75,7 @@ jobs: - name: Setup Node.js uses: actions/setup-node@v4 with: - node-version: 20 + node-version: 24 registry-url: https://registry.npmjs.org - name: Install Dependencies @@ -105,6 +163,4 @@ jobs: - name: Publish to npm if: steps.autotagger.outputs.tagname != '' - env: - NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} run: npm publish --access public diff --git a/CHANGELOG.md b/CHANGELOG.md index ec4e3f42..4faea15c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,12 @@ All notable changes to the ordercloud-javascript-sdk will be documented in this The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +# [14.0.0] - 2026-10-15 +- Breaking: `customRoles` is a property of the auth options object on `Auth.Login`, `Auth.ElevatedLogin`, `Auth.ClientCredentials`, and `Auth.Anonymous`, instead of its own argument. Custom roles with no standard roles are sent as the scope string. That case previously sent the literal text `undefined`. +- Breaking: a nested model is one type parameter constrained to that model, instead of one parameter per nested `xp`. `Order` is unchanged. `Order` and `OrderWorksheet` are not. See the migration guide. +- Breaking: axios is no longer a peer dependency. Requests use the platform `fetch`. `requestOptions.cancelToken` is now `requestOptions.signal`. `axiosAdapter` and axios interceptors are replaced by `Configuration.Set({ fetch, onRequest, onResponse })`. See the migration guide. +- Docs "Defined in" links are written on a single build. `src/Configuration.ts` matches the TypeScript filename casing. + # [13.0.0] - 2026-09-25 - Bring SDK up to date with API v1.0.470. Breaking: `ApiClient.ClientSecret` and `SecurityProfile.IsExternalRoleGroup` are removed. Buyer product `PriceSchedule` is now `BuyerPriceSchedule`. - Update dev dependencies, including TypeScript 5.9 and TypeDoc 0.28. TypeDoc 0.28 requires the missing-exports plugin to be listed explicitly. diff --git a/MIGRATION_GUIDE.md b/MIGRATION_GUIDE.md index 7b696dde..586092a3 100644 --- a/MIGRATION_GUIDE.md +++ b/MIGRATION_GUIDE.md @@ -2,6 +2,69 @@ The objective of this guide is to document the breaking changes and updates required to migrate from one major version to the next. +## version 13.x.x to version 14.x.x +* `customRoles` is no longer a positional argument on `Auth.Login`, `Auth.ElevatedLogin`, `Auth.ClientCredentials`, or `Auth.Anonymous`. Pass it on the request options object, along with `signal`, `requestType`, and (for `Anonymous`) `anonuserid`. + + Before: + ```typescript + Auth.Login(username, password, clientID, scope, customRoles, requestOptions) + Auth.Anonymous(clientID, scope, customRoles, { anonuserid }) + ``` + + After: + ```typescript + Auth.Login(username, password, clientID, scope, { ...requestOptions, customRoles }) + Auth.Anonymous(clientID, scope, { anonuserid, customRoles }) + ``` + +* Axios is no longer a peer dependency. The SDK sends requests with the platform `fetch`. Remove `axios` from your app if you installed it only for the SDK. + +* `requestOptions.cancelToken` is now `requestOptions.signal`, an `AbortSignal`. A cancelled call rejects with `CancellationError`. `isCancellation(error)` identifies it. It is not an `OrderCloudError`. + + Before: + ```typescript + import axios from 'axios' + const source = axios.CancelToken.source() + Products.List({}, { cancelToken: source.token }) + source.cancel() + ``` + + After: + ```typescript + import { isCancellation } from 'ordercloud-javascript-sdk' + const controller = new AbortController() + Products.List({}, { signal: controller.signal }).catch(error => { + if (isCancellation(error)) { + return + } + throw error + }) + controller.abort() + ``` + +* `SdkConfiguration.axiosAdapter` is removed. Pass `fetch` to use your own HTTP implementation. Global axios interceptors no longer see SDK calls. Use `onRequest` and `onResponse` on `Configuration.Set`. + +* `OrderCloudError` still exposes `status`, `statusText`, `errorCode`, `errors`, `response`, and `isOrderCloudError`. `error.request` is no longer an axios `XMLHttpRequest` or Node `ClientRequest`. It is `{ url, method }`. + +* Nested models are no longer described by hoisting each nested `xp` onto the parent. A model's own `xp` stays the first parameter. Each nested model that previously contributed `xp` parameters is now one parameter constrained to that model. + + Before: + ```typescript + interface MyOrder extends Order {} + type Worksheet = OrderWorksheet + ``` + + After: + ```typescript + interface MyOrderUser extends OrderUser {} + interface MyAddress extends Address {} + interface MyOrder extends Order {} + interface MyLineItem extends LineItem {} + type Worksheet = OrderWorksheet + ``` + + `Order` still types only the order `xp`. `Category` is unchanged. `ListPageWithFacets` is unchanged. Its second parameter is now a `ListFacet`, so facet `xp` is declared as `ListPageWithFacets>`. + ## version 11.x.x to version 12.x.x * The `URL` and `SharedKey` properties have been removed from the `MessageSender` model, and `DeliveryConfigID` is now required. Configuration must be provided via a `DeliveryConfig` (managed through the new `DeliveryConfigurations` service) using either a `MailchimpConfig` or `MessageSenderConfig` delivery target. See the [updated Message Senders KB article](https://ordercloud.io/knowledge-base/message-senders#configuration-options) for more details. diff --git a/README.md b/README.md index 078c9c7b..0c9e6812 100644 --- a/README.md +++ b/README.md @@ -38,11 +38,7 @@ The OrderCloud SDK for Javascript is a modern client library for building soluti ## Requirements -[Axios](https://www.npmjs.com/package/axios) is a peer dependency of the OrderCloudSDK. - -> Note: Peer dependencies are not installed automatically. They must be installed separately. - -Why isn't axios a dependency of OrderCloud SDK? Since axios is a fairly popular http library and may already exist as a dependency in your project it is considered best practice to have it defined as a peer dependency. This way, there isn't a potential for two versions of axios to be installed which could result in weird bugs, not to mention a bloated javascript bundle. +The SDK sends HTTP with the platform [`fetch`](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) implementation. It runs in browsers and Node versions that provide global `fetch`. No HTTP library is installed with the SDK. ## ⚙️ Installation @@ -103,6 +99,13 @@ Auth.Login(username, password, clientID, scope) Tokens.SetAccessToken(token) }) .catch(err => console.log(err)); + +// Custom roles are optional and belong on the request options object. +// ElevatedLogin, ClientCredentials, and Anonymous use the same shape. +// Anonymous also accepts anonuserid on that object. +Auth.Login(username, password, clientID, scope, { + customRoles: ['InventoryAdmin'], +}) ``` ## 🔍 Filtering @@ -234,10 +237,12 @@ Products.Get('my-product') // https://ordercloud-api.github.io/ordercloud-javascript-sdk/classes/orderclouderror console.log(error.message); console.log(JSON.stringify(error.errors, null, 4)); - } else if (error.request) { - // the request was made but no response received - // `error.request` is an instance of XMLHttpRequest in the browser and an instance of http.ClientRequest in node.js - console.log(error.request); + } else if (error.isCancellation) { + // the caller aborted the request + console.log(error.message); + } else if (error.isTimeout) { + // the request exceeded timeoutInMilliseconds + console.log(error.message); } else { // Something happened in setting up the request that triggered an Error console.log('Error', error.message); @@ -245,62 +250,49 @@ Products.Get('my-product') }) ``` -## Interceptors +## Request and response hooks -You can use [axios interceptors](https://github.com/axios/axios#interceptors) to intercept a request before it goes out to the API or to intercept a response before it gets handled by the SDK. This enables you to log, rewrite, or even retry calls. - -The SDK does not use a custom axios instance, so you can set up your interceptors right off of axios. +`Configuration.Set` accepts `onRequest` and `onResponse`. Use them to log, rewrite, or retry a call. `onRequest` returns the request that will be sent. `onResponse` runs before the SDK returns data or throws `OrderCloudError`. ```javascript -// Add a request interceptor -axios.interceptors.request.use(function (config) { - // Do something before request is sent - return config; - }, function (error) { - // Do something with request error - return Promise.reject(error); - }); - -// Add a response interceptor -axios.interceptors.response.use(function (response) { - // Any status code that lie within the range of 2xx cause this function to trigger - // Do something with response data - return response; - }, function (error) { - // Any status codes that falls outside the range of 2xx cause this function to trigger - // Do something with response error - return Promise.reject(error); - }); +import { Configuration } from 'ordercloud-javascript-sdk'; + +Configuration.Set({ + onRequest(request) { + console.log(request.method, request.url) + return request + }, + onResponse(response) { + console.log(response.status) + return response + }, +}) ``` ## Cancelling Requests -In addition to `requestOptions.accessToken` the sdk provides `requestOptions.cancelToken` which enables [axios request cancellation](https://github.com/axios/axios#cancellation). This option is useful for cleaning up outstanding requests when changes in your user experience no longer require the data requested. For instance, you could use the cancel token to clean up outstanding requests [when your react component unmounts](https://reactjs.org/docs/hooks-effect.html#effects-with-cleanup). +`requestOptions.signal` accepts an [AbortSignal](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal). Use it to drop a request when the result is no longer needed, for instance [when a react component unmounts](https://reactjs.org/docs/hooks-effect.html#effects-with-cleanup). ```javascript -import axios from 'axios'; -import { Products } from 'ordercloud-javascript-sdk'; +import { Products, isCancellation } from 'ordercloud-javascript-sdk'; -const signal = axios.CancelToken.source(); +const controller = new AbortController(); -Products.List({search: 'Tennis balls'}, {cancelToken: signal.token}) +Products.List({search: 'Tennis balls'}, {signal: controller.signal}) .catch(ex => { - if (axios.isCancel(ex)) { + if (isCancellation(ex)) { console.log(ex) // 'This request was cancelled!' } else { console.log(ex) // Normal ordercloud exception } }) -// Oops! I don't want to resolve this request anymore -signal.cancel('This request was cancelled!') +controller.abort() ``` -## Axios Adapters - -Adapters in Axios allow for custom handling of requests, which opens up possibilities for advanced functionalities such as caching, request mocking, and the option to switch HTTP APIs (for instance, from XHR to Fetch). You can use community created adapters, or create one yourself (just make sure it adheres to the [axios adapter interface](https://github.com/axios/axios/blob/v1.x/lib/adapters/README.md)) +## Custom fetch -Like all other sdk level options, Axios adapters can be defined with the Configuration service +Pass a `fetch` function to the Configuration service to mock, cache, or reroute HTTP. The default is the platform global `fetch`. ```typescript import { Configuration } from 'ordercloud-javascript-sdk'; @@ -308,7 +300,7 @@ import { Configuration } from 'ordercloud-javascript-sdk'; Configuration.Set({ baseApiUrl: 'https://sandboxapi.ordercloud.io', timeoutInMilliseconds: 20 * 1000, - axiosAdapter: myAdapter + fetch: myFetch }) ``` @@ -428,7 +420,26 @@ Categories.List('mock-catalog-id') }) ``` -This is nicer and especially preferable for models like `Order` which have many nested models each with their own `xp` fields that must be defined at the top level. For example: `Order`. Declaring those 3 xp types once on a custom `MyOrder` interface is far cleaner than declaring them on every call to `Orders.Get` or `Orders.List`. +A model's own `xp` is still the first type parameter, so `Category` and `Order` keep working. Nested models are passed as the extended type, not as a separate `xp` parameter for each nested field: + +```typescript +interface MyOrderXp { + ErpId?: string; +} + +interface MyOrderUser extends OrderUser<{ Department?: string }> {} +interface MyAddress extends Address<{ Dock?: string }> {} +interface MyOrder extends Order {} + +interface MyLineItemXp { + GiftWrap?: boolean; +} +interface MyLineItem extends LineItem {} + +type Worksheet = OrderWorksheet +``` + +`Order` does not compile: the second parameter is the user model, not that user's `xp`. `OrderWorksheet` does not compile: the first parameter is `TOrder extends Order`. ### Typescript utilities diff --git a/codegen/handlebars-extensions.ts b/codegen/handlebars-extensions.ts index 020fa0ca..c1be5519 100644 --- a/codegen/handlebars-extensions.ts +++ b/codegen/handlebars-extensions.ts @@ -20,8 +20,14 @@ function handlebarsExt(Handlebars) { Handlebars.registerHelper( 'commaSeparateWithDefaultAny', - (types: string[]) => { - return types.map(t => `${t} = any`).join(', ') + (types: { name: string; constraint?: string }[]) => { + return types + .map(t => + t.constraint + ? `${t.name} extends ${t.constraint} = ${t.constraint}` + : `${t.name} = any` + ) + .join(', ') } ) } diff --git a/codegen/hooks.ts b/codegen/hooks.ts index 391c0bef..0ea2011f 100644 --- a/codegen/hooks.ts +++ b/codegen/hooks.ts @@ -16,12 +16,12 @@ const filterResources: FilterResourcesHook = function(resource) { const postFormatModel: PostFormatModelHook = function(model, models) { // add model.typeParams and prop.typeParams - inspectModelForTypeParams(models, model, model) + inspectModelForTypeParams(models, model) // add model.hasTypeParams and prop.hasTypeParams model['hasTypeParams'] = Boolean(model['typeParams'].length) model.properties.forEach(prop => { - prop['hasTypeParams'] = Boolean(prop['typeParams'].length) + prop['hasTypeParams'] = Boolean(prop['modelTypeParam']) }) // add prop.typescriptType to props on model @@ -198,91 +198,95 @@ function findTypeForModelProps(prop: Param, model: Model) { return enumString } - const typeParams = prop['hasTypeParams'] - ? `<${prop['typeParams'].join(',')}>` - : '' + if (prop['modelTypeParam']) { + return prop.isArray ? `${prop['modelTypeParam']}[]` : prop['modelTypeParam'] + } + const jsType = javascriptTypes[prop.type] || prop.type if (prop.isArray) { - return prop.isCustomType ? `${prop.type + typeParams}[]` : `${jsType}[]` + return prop.isCustomType ? `${prop.type}[]` : `${jsType}[]` } if (!prop.hasRequiredFields && prop.isCustomType) { - return prop.type + typeParams + return prop.type } return jsType } -function inspectModelForTypeParams( - allModels: Model[], - rootModel: Model, - inspectModel: Model, - rootProp?: Param, - parentProp?: Param -) { - if (!inspectModel['typeParams']) { - inspectModel['typeParams'] = [] +/** + * Own xp stays the first parameter and defaults to any. + * Each direct custom-type property that today contributes nested xp + * becomes one parameter constrained to that model. Nested xp names + * are not hoisted onto the parent. + */ +function inspectModelForTypeParams(allModels: Model[], model: Model) { + const typeParams: { name: string; constraint?: string }[] = [] + const usedNames = new Set() + + if (model.properties.some(prop => prop.isXp)) { + const ownXpName = `T${model.name}Xp` + typeParams.push({ name: ownXpName }) + usedNames.add(ownXpName) } - inspectModel.properties.forEach(prop => { - if (!prop['typeParams']) { - prop['typeParams'] = [] - } - if (prop.isXp) { - if (!rootProp) { - // first level of properties, only the xp for that resource will exist - // move it to front for convention where first xp is always that resource's xp - const typeParam = `T${inspectModel.name}Xp` - rootModel['typeParams'].unshift(typeParam) - prop['typeParams'].unshift(typeParam) - } else { - let typeParam = parentProp - ? `T${parentProp.name}Xp` - : `T${rootProp.name}Xp` - if (typeParam === 'TItemsXp') { - typeParam = `T${rootProp.type}Xp` - rootModel['typeParams'].unshift(typeParam) - rootProp['typeParams'].unshift(typeParam) - } else { - rootModel['typeParams'].push(typeParam) - rootProp['typeParams'].push(typeParam) - } - } + + model.properties.forEach(prop => { + prop['modelTypeParam'] = undefined + if (!prop.isCustomType || prop.isXp) { + return } - if (prop.isCustomType) { - const toInspect = allModels.find(model => { - return model.name === prop.type || model.type === prop.type - }) - if (!toInspect) { - throw new Error(`Unable to find next model to inspect for ${prop.type}`) - } - if (!rootProp && !parentProp) { - inspectModelForTypeParams(allModels, rootModel, toInspect, prop) - } else if (rootProp && !parentProp) { - inspectModelForTypeParams( - allModels, - rootModel, - toInspect, - rootProp, - prop - ) - } + if (!customTypeContributesXp(allModels, prop.type)) { + return } + const name = modelTypeParamName(prop, usedNames) + usedNames.add(name) + typeParams.push({ name, constraint: prop.type }) + prop['modelTypeParam'] = name }) - // This is a little hacky but basically we want the first type parameter to be the type for the xp of the model - // for example ShipEstimate otherwise, the xp type would be at the end of the list - // lke so: ShipEstimate - if ( - rootProp && - rootProp['typeParams'] && - rootProp['typeParams'].length > 1 && - rootProp['typeParams'].includes(`T${rootProp.name}Xp`) - ) { - const toMoveIndex = rootProp['typeParams'].findIndex( - p => p === `T${rootProp.name}Xp` - ) - const toMove = rootProp['typeParams'].splice(toMoveIndex, 1) - rootProp['typeParams'].unshift(toMove[0]) + model['typeParams'] = typeParams +} + +function modelTypeParamName(prop: Param, usedNames: Set): string { + // Arrays take the element type name (LineItems -> TLineItem). + // Other properties take the property name (FromUser -> TFromUser) + // so two Address fields stay distinct. + const preferred = prop.isArray ? `T${prop.type}` : `T${prop.name}` + if (!usedNames.has(preferred)) { + return preferred + } + const byProperty = `T${prop.name}` + if (!usedNames.has(byProperty)) { + return byProperty + } + return `T${prop.name}_${prop.type}` +} + +function customTypeContributesXp( + allModels: Model[], + typeName: string, + depth = 0 +): boolean { + const model = allModels.find( + candidate => candidate.name === typeName || candidate.type === typeName + ) + if (!model) { + throw new Error(`Unable to find next model to inspect for ${typeName}`) + } + for (const prop of model.properties) { + if (prop.isXp) { + return true + } + // Match the previous hoist depth: xp on this model, and xp on its + // direct custom-type children. Do not walk further. + if ( + depth < 1 && + prop.isCustomType && + customTypeContributesXp(allModels, prop.type, depth + 1) + ) { + return true + } } + return false } diff --git a/codegen/templates/api/Auth.ts b/codegen/templates/api/Auth.ts index d2bfac4e..9a85b5e7 100644 --- a/codegen/templates/api/Auth.ts +++ b/codegen/templates/api/Auth.ts @@ -1,20 +1,72 @@ /* eslint-disable no-var */ -import axios, { CancelToken } from 'axios' import { AccessToken } from '../models/AccessToken' import Configuration from '../Configuration' import { ApiRole } from '../models/ApiRole' import paramsSerializer from '../utils/paramsSerializer' import { RequiredDeep } from '../models/RequiredDeep' import OrderCloudError from '../utils/OrderCloudError' +import http from '../utils/HttpClient' + +/** + * @ignore + * not part of public api, don't include in generated docs + * + * Standard roles, then a space, then custom roles. Omitted when both lists are empty. + */ +function resolveAuthScope( + scope?: ApiRole[], + customRoles?: string[] +): string | undefined { + if (scope && !Array.isArray(scope)) { + throw new Error('scope must be a string array') + } + if (customRoles != null && !Array.isArray(customRoles)) { + throw new Error('custom roles must be defined as a string array') + } + + if (scope?.length && customRoles?.length) { + return `${scope.join(' ')} ${customRoles.join(' ')}` + } + if (scope?.length) { + return scope.join(' ') + } + if (customRoles?.length) { + return customRoles.join(' ') + } + return undefined +} + +interface AuthRequestOptions { + customRoles?: string[] + anonuserid?: string + signal?: AbortSignal + requestType?: string +} + +async function postToken( + body: { [key: string]: any }, + requestOptions: AuthRequestOptions = {} +): Promise { + const configuration = Configuration.Get() + try { + return await http.formPost( + `${configuration.baseApiUrl}/oauth/token`, + paramsSerializer.serialize(body), + { + signal: requestOptions.signal, + requestType: requestOptions.requestType, + } + ) + } catch (e) { + if (e.response) { + throw new OrderCloudError(e) + } + throw e + } +} class Auth { constructor() { - if (typeof axios === 'undefined') { - throw new Error( - 'Ordercloud is missing required peer dependency axios. This must be installed and loaded before the OrderCloud SDK' - ) - } - /** * @ignore * not part of public api, don't include in generated docs @@ -33,8 +85,8 @@ class Auth { * @param password of the user logging in * @param client_id of the application the user is logging into * @param scope optional roles being requested, if omitted will return all assigned roles - * @param customRoles optional custom roles being requested - string array - * @param requestOptions.cancelToken Provide an [axios cancelToken](https://github.com/axios/axios#cancellation) that can be used to cancel the request. + * @param requestOptions.customRoles optional custom roles being requested - string array + * @param requestOptions.signal Provide an [AbortSignal](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) that can be used to cancel the request. * @param requestOptions.requestType Provide a value that can be used to identify the type of request. Useful for error logs. */ public async Login( @@ -42,56 +94,17 @@ class Auth { password: string, clientID: string, scope?: ApiRole[], - customRoles?: string[], - requestOptions: { - cancelToken?: CancelToken - requestType?: string - } = {} + requestOptions: AuthRequestOptions = {} ): Promise> { - if (scope && !Array.isArray(scope)) { - throw new Error('scope must be a string array') - } - if (customRoles != null && !Array.isArray(customRoles)) { - throw new Error('custom roles must be defined as a string array') - } - - let _scope: string | undefined - if (scope?.length && !customRoles?.length) { - _scope = scope.join(' ') - } else if (!scope?.length && customRoles?.length) { - _scope += ` ${customRoles.join(' ')}` - } else if (scope?.length && customRoles?.length) { - _scope = `${scope.join(' ')} ${customRoles.join(' ')}` - } - + const { customRoles } = requestOptions const body = { grant_type: 'password', username, password, client_id: clientID, - scope: _scope, + scope: resolveAuthScope(scope, customRoles), } - const configuration = Configuration.Get() - const response = await axios - .post( - `${configuration.baseApiUrl}/oauth/token`, - paramsSerializer.serialize(body), - { - headers: { - 'Content-Type': 'application/x-www-form-urlencoded', - Accept: 'application/json', - }, - adapter: configuration.axiosAdapter, - ...requestOptions, - } - ) - .catch(e => { - if (e.response) { - throw new OrderCloudError(e) - } - throw e - }) - return response.data + return await postToken(body, requestOptions) } /** @@ -102,10 +115,10 @@ class Auth { * @param password of the user logging in * @param clientID of the application the user is logging into * @param scope roles being requested - space delimited string or array - * @param customRoles optional custom roles being requested - string array + * @param requestOptions.customRoles optional custom roles being requested - string array * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body. * @param reportProgress flag to report request and response progress. - * @param requestOptions.cancelToken Provide an [axios cancelToken](https://github.com/axios/axios#cancellation) that can be used to cancel the request. + * @param requestOptions.signal Provide an [AbortSignal](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) that can be used to cancel the request. * @param requestOptions.requestType Provide a value that can be used to identify the type of request. Useful for error logs. */ public async ElevatedLogin( @@ -114,57 +127,18 @@ class Auth { password: string, clientID: string, scope?: ApiRole[], - customRoles?: string[], - requestOptions: { - cancelToken?: CancelToken - requestType?: string - } = {} + requestOptions: AuthRequestOptions = {} ): Promise> { - if (scope && !Array.isArray(scope)) { - throw new Error('scope must be a string array') - } - if (customRoles != null && !Array.isArray(customRoles)) { - throw new Error('custom roles must be defined as a string array') - } - - let _scope: string | undefined - if (scope?.length && !customRoles?.length) { - _scope = scope.join(' ') - } else if (!scope?.length && customRoles?.length) { - _scope += ` ${customRoles.join(' ')}` - } else if (scope?.length && customRoles?.length) { - _scope = `${scope.join(' ')} ${customRoles.join(' ')}` - } - + const { customRoles } = requestOptions const body = { grant_type: 'password', - scope: _scope, + scope: resolveAuthScope(scope, customRoles), client_id: clientID, username, password, client_secret: clientSecret, } - const configuration = Configuration.Get() - const response = await axios - .post( - `${configuration.baseApiUrl}/oauth/token`, - paramsSerializer.serialize(body), - { - headers: { - 'Content-Type': 'application/x-www-form-urlencoded', - Accept: 'application/json', - }, - adapter: configuration.axiosAdapter, - ...requestOptions, - } - ) - .catch(e => { - if (e.response) { - throw new OrderCloudError(e) - } - throw e - }) - return response.data + return await postToken(body, requestOptions) } /** @@ -173,65 +147,26 @@ class Auth { * @param clientSecret of the application * @param clientID of the application the user is logging into * @param scope roles being requested - space delimited string or array - * @param customRoles optional custom roles being requested - string array + * @param requestOptions.customRoles optional custom roles being requested - string array * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body. * @param reportProgress flag to report request and response progress. - * @param requestOptions.cancelToken Provide an [axios cancelToken](https://github.com/axios/axios#cancellation) that can be used to cancel the request. + * @param requestOptions.signal Provide an [AbortSignal](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) that can be used to cancel the request. * @param requestOptions.requestType Provide a value that can be used to identify the type of request. Useful for error logs. */ public async ClientCredentials( clientSecret: string, clientID: string, scope?: ApiRole[], - customRoles?: string[], - requestOptions: { - cancelToken?: CancelToken - requestType?: string - } = {} + requestOptions: AuthRequestOptions = {} ): Promise> { - if (scope && !Array.isArray(scope)) { - throw new Error('scope must be a string array') - } - if (customRoles != null && !Array.isArray(customRoles)) { - throw new Error('custom roles must be defined as a string array') - } - - let _scope: string | undefined - if (scope?.length && !customRoles?.length) { - _scope = scope.join(' ') - } else if (!scope?.length && customRoles?.length) { - _scope += ` ${customRoles.join(' ')}` - } else if (scope?.length && customRoles?.length) { - _scope = `${scope.join(' ')} ${customRoles.join(' ')}` - } - + const { customRoles } = requestOptions const body = { grant_type: 'client_credentials', - scope: _scope, + scope: resolveAuthScope(scope, customRoles), client_id: clientID, client_secret: clientSecret, } - const configuration = Configuration.Get() - const response = await axios - .post( - `${configuration.baseApiUrl}/oauth/token`, - paramsSerializer.serialize(body), - { - headers: { - 'Content-Type': 'application/x-www-form-urlencoded', - Accept: 'application/json', - }, - adapter: configuration.axiosAdapter, - ...requestOptions, - } - ) - .catch(e => { - if (e.response) { - throw new OrderCloudError(e) - } - throw e - }) - return response.data + return await postToken(body, requestOptions) } /** @@ -239,43 +174,20 @@ class Auth { * * @param refreshToken of the application * @param clientID of the application the user is logging into - * @param requestOptions.cancelToken Provide an [axios cancelToken](https://github.com/axios/axios#cancellation) that can be used to cancel the request. + * @param requestOptions.signal Provide an [AbortSignal](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) that can be used to cancel the request. * @param requestOptions.requestType Provide a value that can be used to identify the type of request. Useful for error logs. */ public async RefreshToken( refreshToken: string, clientID: string, - requestOptions: { - cancelToken?: CancelToken - requestType?: string - } = {} + requestOptions: AuthRequestOptions = {} ): Promise> { const body = { grant_type: 'refresh_token', client_id: clientID, refresh_token: refreshToken, } - const configuration = Configuration.Get() - const response = await axios - .post( - `${configuration.baseApiUrl}/oauth/token`, - paramsSerializer.serialize(body), - { - headers: { - 'Content-Type': 'application/x-www-form-urlencoded', - Accept: 'application/json', - }, - adapter: configuration.axiosAdapter, - ...requestOptions, - } - ) - .catch(e => { - if (e.response) { - throw new OrderCloudError(e) - } - throw e - }) - return response.data + return await postToken(body, requestOptions) } /** @@ -283,67 +195,26 @@ class Auth { * * @param clientID of the application the user is logging into * @param scope roles being requested - space delimited string or array - * @param customRoles optional custom roles being requested - string array + * @param requestOptions.customRoles optional custom roles being requested - string array * @param requestOptions.anonuserid Provide an externally generated id to track this user session, used specifically for the tracking events feature for integrating with Send and Discover - * @param requestOptions.cancelToken Provide an [axios cancelToken](https://github.com/axios/axios#cancellation) that can be used to cancel the request. + * @param requestOptions.signal Provide an [AbortSignal](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) that can be used to cancel the request. * @param requestOptions.requestType Provide a value that can be used to identify the type of request. Useful for error logs. */ public async Anonymous( clientID: string, scope?: ApiRole[], - customRoles?: string[], - requestOptions: { - anonuserid?: string - cancelToken?: CancelToken - requestType?: string - } = {} + requestOptions: AuthRequestOptions = {} ): Promise> { - if (scope && !Array.isArray(scope)) { - throw new Error('scope must be a string array') - } - if (customRoles != null && !Array.isArray(customRoles)) { - throw new Error('custom roles must be defined as a string array') - } - - let _scope: string | undefined - if (scope?.length && !customRoles?.length) { - _scope = scope.join(' ') - } else if (!scope?.length && customRoles?.length) { - _scope += ` ${customRoles.join(' ')}` - } else if (scope?.length && customRoles?.length) { - _scope = `${scope.join(' ')} ${customRoles.join(' ')}` - } - + const { customRoles, anonuserid } = requestOptions const body = { grant_type: 'client_credentials', client_id: clientID, - scope: _scope, + scope: resolveAuthScope(scope, customRoles), } - if (requestOptions.anonuserid) { - body['anonuserid'] = requestOptions.anonuserid - delete requestOptions['anonuserid'] + if (anonuserid) { + body['anonuserid'] = anonuserid } - const configuration = Configuration.Get() - const response = await axios - .post( - `${configuration.baseApiUrl}/oauth/token`, - paramsSerializer.serialize(body), - { - headers: { - 'Content-Type': 'application/x-www-form-urlencoded', - Accept: 'application/json', - }, - adapter: configuration.axiosAdapter, - ...requestOptions, - } - ) - .catch(e => { - if (e.response) { - throw new OrderCloudError(e) - } - throw e - }) - return response.data + return await postToken(body, requestOptions) } } diff --git a/codegen/templates/api/Certs.ts b/codegen/templates/api/Certs.ts index 57d9754f..d7f9b866 100644 --- a/codegen/templates/api/Certs.ts +++ b/codegen/templates/api/Certs.ts @@ -21,7 +21,7 @@ class Certs { * * @param ID ID of the public key. * @param requestOptions.accessToken Provide an alternative token to the one stored in the sdk instance (useful for impersonation). - * @param requestOptions.cancelToken Provide an [axios cancelToken](https://github.com/axios/axios#cancellation) that can be used to cancel the request. + * @param requestOptions.signal Provide an [AbortSignal](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) that can be used to cancel the request. * @param requestOptions.requestType Provide a value that can be used to identify the type of request. Useful for error logs. */ public async GetPublicKey( diff --git a/codegen/templates/api/UserInfo.ts b/codegen/templates/api/UserInfo.ts index a32a226b..9f71585b 100644 --- a/codegen/templates/api/UserInfo.ts +++ b/codegen/templates/api/UserInfo.ts @@ -19,7 +19,7 @@ class UserInfo { * Get the identity token for an OrderCloud user. Used for Discover 2 integration. * * @param requestOptions.accessToken Provide an alternative token to the one stored in the sdk instance (useful for impersonation). - * @param requestOptions.cancelToken Provide an [axios cancelToken](https://github.com/axios/axios#cancellation) that can be used to cancel the request. + * @param requestOptions.signal Provide an [AbortSignal](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) that can be used to cancel the request. * @param requestOptions.requestType Provide a value that can be used to identify the type of request. Useful for error logs. */ public async GetToken( diff --git a/codegen/templates/api/_RESOURCE_.ts.hbs b/codegen/templates/api/_RESOURCE_.ts.hbs index 35690ec2..ead56932 100644 --- a/codegen/templates/api/_RESOURCE_.ts.hbs +++ b/codegen/templates/api/_RESOURCE_.ts.hbs @@ -27,7 +27,7 @@ class {{resource.id}} { * {{#allParams}} * @param {{#if isQueryParam}}listOptions.{{name}} {{description}}{{else}}{{name}} {{description}}{{#if isBodyParam}}{{#if hasRequiredFields}}Required fields: {{commaSeparate requiredFields}}{{/if}}{{/if}}{{/if}}{{/allParams}} * @param requestOptions.accessToken Provide an alternative token to the one stored in the sdk instance (useful for impersonation). - * @param requestOptions.cancelToken Provide an [axios cancelToken](https://github.com/axios/axios#cancellation) that can be used to cancel the request. + * @param requestOptions.signal Provide an [AbortSignal](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) that can be used to cancel the request. * @param requestOptions.requestType Provide a value that can be used to identify the type of request. Useful for error logs. */ public async {{name}}{{#if hasReturnType}}{{#if isList}}{{else}}{{/if}}{{/if}}({{#allParams}}{{#unless isQueryParam}}{{#if isBodyParam}}{{#if ../isPatch}}{{name}}: PartialDeep<{{typescriptType}}>, {{else}}{{name}}: {{typescriptType}},{{/if}}{{else}}{{name}}: {{typescriptType}}, {{/if}}{{/unless}}{{/allParams}}{{#if hasQueryParams}}listOptions: { {{#queryParams}}{{name}}?: {{typescriptType}}{{#unless @last}}, {{/unless}}{{/queryParams}} } = {}, {{/if}}requestOptions: RequestOptions = {} ): Promise<{{#if hasReturnType}}RequiredDeep<{{#if isList}}{{#if isFacetList}}ListPageWithFacets{{else}}ListPage{{/if}}{{else}}T{{returnType}}{{/if}}>{{else}}void{{/if}}>{ diff --git a/codegen/templates/index.ts b/codegen/templates/index.ts index 0c9dd8fa..d1e7b572 100644 --- a/codegen/templates/index.ts +++ b/codegen/templates/index.ts @@ -2,5 +2,10 @@ import Configuration from './Configuration' export { Configuration } import OrderCloudError from './utils/OrderCloudError' export { OrderCloudError } +export { + CancellationError, + isCancellation, + TimeoutError, +} from './utils/CancellationError' export * from './api/index' export * from './models/index' diff --git a/codegen/templates/models/ListPageWithFacets.ts b/codegen/templates/models/ListPageWithFacets.ts index 008e6624..6749bfc6 100644 --- a/codegen/templates/models/ListPageWithFacets.ts +++ b/codegen/templates/models/ListPageWithFacets.ts @@ -1,9 +1,14 @@ +import { ListFacet } from './ListFacet' import { MetaWithFacets } from './MetaWithFacets' /** * @typeParam TItem represents the type for each item in the list + * @typeParam TListFacet represents the facet model, including that facet's xp */ -export interface ListPageWithFacets { +export interface ListPageWithFacets< + TItem, + TListFacet extends ListFacet = ListFacet +> { Items?: TItem[] - Meta?: MetaWithFacets + Meta?: MetaWithFacets } diff --git a/codegen/templates/models/OrderReturnCalculatePayload.ts b/codegen/templates/models/OrderReturnCalculatePayload.ts index 32e918d3..8b7348e8 100644 --- a/codegen/templates/models/OrderReturnCalculatePayload.ts +++ b/codegen/templates/models/OrderReturnCalculatePayload.ts @@ -2,39 +2,9 @@ import { OrderReturn } from './OrderReturn' import { OrderWorksheet } from './OrderWorksheet' export interface OrderReturnCalculatePayload< - TOrderReturnXp = any, - TFromUserXp = any, - TBillingAddressXp = any, - TOrderXp = any, - TProductXp = any, - TVariantXp = any, - TShippingAddressXp = any, - TShipFromAddressXp = any, - TLineItemsXp = any, - TOrderPromotionsXp = any, - TShipEstimatesXp = any, - TShipEstimateResponseXp = any, - TOrderCalculateResponseXp = any, - TOrderSubmitResponseXp = any, - TOrderSubmitForApprovalResponseXp = any, - TOrderApprovedResponseXp = any + TOrderReturn extends OrderReturn = OrderReturn, + TOrderWorksheet extends OrderWorksheet = OrderWorksheet > { - OrderReturn?: OrderReturn - OrderWorksheet?: OrderWorksheet< - TFromUserXp, - TBillingAddressXp, - TOrderXp, - TProductXp, - TVariantXp, - TShippingAddressXp, - TShipFromAddressXp, - TLineItemsXp, - TOrderPromotionsXp, - TShipEstimatesXp, - TShipEstimateResponseXp, - TOrderCalculateResponseXp, - TOrderSubmitResponseXp, - TOrderSubmitForApprovalResponseXp, - TOrderApprovedResponseXp - > + OrderReturn?: TOrderReturn + OrderWorksheet?: TOrderWorksheet } diff --git a/codegen/templates/models/RequestOptions.ts b/codegen/templates/models/RequestOptions.ts index 0f4e8264..064004a4 100644 --- a/codegen/templates/models/RequestOptions.ts +++ b/codegen/templates/models/RequestOptions.ts @@ -1,5 +1,3 @@ -import { CancelToken } from 'axios' - export interface RequestOptions { /** * Alternative token to the one stored in the sdk instance (useful for impersonation). @@ -7,9 +5,9 @@ export interface RequestOptions { accessToken?: string /** - * [Axios cancelToken](https://github.com/axios/axios#cancellation) that can be used to cancel the request. + * [AbortSignal](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) that can be used to cancel the request. */ - cancelToken?: CancelToken + signal?: AbortSignal /** * Identify the type of request. Useful for error logs. diff --git a/codegen/templates/models/SdkConfiguration.ts b/codegen/templates/models/SdkConfiguration.ts index 78b8c67a..e5f32192 100644 --- a/codegen/templates/models/SdkConfiguration.ts +++ b/codegen/templates/models/SdkConfiguration.ts @@ -1,4 +1,22 @@ -import { AxiosAdapter } from 'axios' +export interface SdkHttpRequest { + url: string + method: string + headers: Record + body?: string + signal?: AbortSignal + /** + * Caller-supplied label from `requestOptions.requestType`. Not sent on the wire. + */ + requestType?: string +} + +export interface SdkHttpResponse { + data: any + status: number + statusText: string + headers: Headers + request: { url: string; method: string } +} export interface SdkConfiguration { /** @@ -28,14 +46,29 @@ export interface SdkConfiguration { /** * specifies the number of milliseconds before the request times out. * If the request takes longer than `timeoutInMilliseconds`, the request will be aborted. - * Default timeout is 10,000 milliseconds or 10 seconds + * Default timeout is 60,000 milliseconds or 60 seconds */ timeoutInMilliseconds?: number /** - * provide a custom axios adapter to handle dispatching request/responses + * Optional fetch implementation. Defaults to the platform global `fetch`. + * Use this to mock, cache, or reroute HTTP. + */ + fetch?: (input: string, init?: RequestInit) => Promise + + /** + * Runs before a request is sent. Return the request that should be sent. + */ + onRequest?: ( + request: SdkHttpRequest + ) => SdkHttpRequest | Promise + + /** + * Runs after a response is received and before the SDK returns data or throws. */ - axiosAdapter?: AxiosAdapter + onResponse?: ( + response: SdkHttpResponse + ) => SdkHttpResponse | Promise cookieOptions?: CookieOptions } diff --git a/codegen/templates/utils/CancellationError.ts b/codegen/templates/utils/CancellationError.ts new file mode 100644 index 00000000..22ce212c --- /dev/null +++ b/codegen/templates/utils/CancellationError.ts @@ -0,0 +1,33 @@ +/** + * Thrown when a caller aborts a request through `requestOptions.signal`. + * This is not an OrderCloud API error. + */ +export class CancellationError extends Error { + isCancellation = true as const + + constructor(message = 'This request was cancelled') { + super(message) + this.name = 'CancellationError' + } +} + +export function isCancellation(error: unknown): error is CancellationError { + return ( + !!error && + typeof error === 'object' && + (error as { isCancellation?: boolean }).isCancellation === true + ) +} + +/** + * Thrown when a request exceeds `timeoutInMilliseconds`. + * This is not an OrderCloud API error. + */ +export class TimeoutError extends Error { + isTimeout = true as const + + constructor(message = 'This request timed out') { + super(message) + this.name = 'TimeoutError' + } +} diff --git a/codegen/templates/utils/HttpClient.ts b/codegen/templates/utils/HttpClient.ts index 170c1888..340c3e24 100644 --- a/codegen/templates/utils/HttpClient.ts +++ b/codegen/templates/utils/HttpClient.ts @@ -1,133 +1,260 @@ -import axios, { AxiosRequestConfig } from 'axios' import tokenService from '../api/Tokens' import Configuration from '../Configuration' +import { SdkHttpRequest, SdkHttpResponse } from '../models/SdkConfiguration' import paramsSerializer from './paramsSerializer' +import { CancellationError, TimeoutError } from './CancellationError' /** * @ignore * not part of public api, don't include in generated docs */ -interface OcRequestConfig extends AxiosRequestConfig { +interface OcRequestConfig { + data?: unknown + params?: { [key: string]: any } impersonating?: boolean accessToken?: string + signal?: AbortSignal + requestType?: string } + class HttpClient { constructor() { - if (typeof axios === 'undefined') { - throw new Error( - 'Missing required peer dependency axios. This must be installed and loaded before the OrderCloud SDK' - ) - } - this.get = this.get.bind(this) this.put = this.put.bind(this) this.post = this.post.bind(this) this.patch = this.patch.bind(this) this.delete = this.delete.bind(this) + this.formPost = this.formPost.bind(this) this._resolveToken = this._resolveToken.bind(this) this._buildRequestConfig = this._buildRequestConfig.bind(this) - this._addTokenToConfig = this._addTokenToConfig.bind(this) } public get = async (path: string, config?: OcRequestConfig): Promise => { - return await this.makeApiCall('get', path, config) + return await this.makeApiCall('GET', path, config) } public post = async ( path: string, config?: OcRequestConfig ): Promise => { - return await this.makeApiCall('post', path, config) + return await this.makeApiCall('POST', path, config) } public put = async (path: string, config?: OcRequestConfig): Promise => { - return await this.makeApiCall('put', path, config) + return await this.makeApiCall('PUT', path, config) } public patch = async ( path: string, config?: OcRequestConfig ): Promise => { - return await this.makeApiCall('patch', path, config) + return await this.makeApiCall('PATCH', path, config) } - public delete = async (path: string, config: OcRequestConfig) => { - return await this.makeApiCall('delete', path, config) + public delete = async (path: string, config?: OcRequestConfig) => { + return await this.makeApiCall('DELETE', path, config) + } + + /** + * @ignore + * not part of public api, don't include in generated docs + */ + public formPost = async ( + url: string, + body: string, + options: { signal?: AbortSignal; requestType?: string } = {} + ): Promise => { + return await this.send({ + url, + method: 'POST', + headers: { + 'Content-Type': 'application/x-www-form-urlencoded', + Accept: 'application/json', + }, + body, + signal: options.signal, + requestType: options.requestType, + }) } private async makeApiCall( - verb: 'get' | 'put' | 'post' | 'patch' | 'delete', - path, - config + verb: 'GET' | 'PUT' | 'POST' | 'PATCH' | 'DELETE', + path: string, + config?: OcRequestConfig ) { const requestConfig = await this._buildRequestConfig(config) + const sdkConfig = Configuration.Get() // oauth endpoints unlike the rest don't have /{apiVersion}/ appended to them const baseApiUrl = path.includes('oauth/') - ? `${Configuration.Get().baseApiUrl}/${path}` - : `${Configuration.Get().baseApiUrl}/${ - Configuration.Get().apiVersion - }${path}` - if (verb === 'put' || verb === 'post' || verb === 'patch') { - const requestBody = requestConfig.data - delete requestConfig.data - const response = await axios[verb as string]( - baseApiUrl, - requestBody, - requestConfig + ? `${sdkConfig.baseApiUrl}/${path}` + : `${sdkConfig.baseApiUrl}/${sdkConfig.apiVersion}${path}` + const query = requestConfig.params + ? paramsSerializer.serialize(requestConfig.params) + : '' + const url = query ? `${baseApiUrl}?${query}` : baseApiUrl + const hasBody = verb === 'PUT' || verb === 'POST' || verb === 'PATCH' + const body = + hasBody && requestConfig.data !== undefined + ? JSON.stringify(requestConfig.data) + : undefined + return await this.send({ + url, + method: verb, + headers: requestConfig.headers, + body, + signal: requestConfig.signal, + requestType: requestConfig.requestType, + }) + } + + private async send(request: SdkHttpRequest): Promise { + const sdkConfig = Configuration.Get() + if (sdkConfig.onRequest) { + request = await sdkConfig.onRequest(request) + } + + const fetchImpl = sdkConfig.fetch ?? globalThis.fetch + if (typeof fetchImpl !== 'function') { + throw new Error( + 'OrderCloud SDK requires a fetch implementation. Provide one with Configuration.Set({ fetch }) or run on a platform that provides global fetch.' ) - return response.data - } else { - const response = await axios[verb as string](baseApiUrl, requestConfig) - return response.data } + + const timeoutMs = sdkConfig.timeoutInMilliseconds ?? 60 * 1000 + const timeoutSignal = createTimeoutSignal(timeoutMs) + const signal = request.signal + ? anySignal([request.signal, timeoutSignal]) + : timeoutSignal + const init: RequestInit = { + method: request.method, + headers: request.headers, + signal, + } + if (request.body !== undefined) { + init.body = request.body + } + + let response: Response + try { + response = await fetchImpl(request.url, init) + } catch (error) { + if (request.signal?.aborted) { + throw new CancellationError() + } + if (timeoutSignal.aborted) { + throw new TimeoutError() + } + throw error + } + + const data = await readBody(response) + let transport: SdkHttpResponse = { + data, + status: response.status, + statusText: response.statusText, + headers: response.headers, + request: { url: request.url, method: request.method }, + } + if (sdkConfig.onResponse) { + transport = await sdkConfig.onResponse(transport) + } + if (transport.status < 200 || transport.status >= 300) { + const error: any = new Error(transport.statusText) + error.response = { + data: transport.data, + status: transport.status, + statusText: transport.statusText, + headers: transport.headers, + } + error.request = transport.request + throw error + } + return transport.data } // sets the token on every outgoing request, will attempt to // refresh the token if the token is expired and there is a refresh token set - private async _addTokenToConfig( - config: OcRequestConfig - ): Promise { + private async _buildRequestConfig( + config: OcRequestConfig = {} + ): Promise<{ + headers: Record + data?: unknown + params?: { [key: string]: any } + signal?: AbortSignal + requestType?: string + }> { const token = this._resolveToken(config) const validToken = await tokenService.GetValidToken(token) - if (!config.headers) { - config.headers = {} + return { + headers: { + 'Content-Type': 'application/json', + Authorization: `Bearer ${validToken}`, + }, + data: config.data, + params: config.params, + signal: config.signal, + requestType: config.requestType, } - config.headers.Authorization = `Bearer ${validToken}` - return config } private _resolveToken(config: OcRequestConfig): string { - let token - if (config['accessToken']) { - token = config['accessToken'] - } else if (config['impersonating']) { - token = tokenService.GetImpersonationToken() - } else { - token = tokenService.GetAccessToken() + if (config.accessToken) { + return config.accessToken } + if (config.impersonating) { + return tokenService.GetImpersonationToken() + } + return tokenService.GetAccessToken() + } +} - // remove these custom parameters that axios doesn't understand - // we were storing on the axios config for simplicity - delete config['accessToken'] - delete config['impersonating'] - return token +function createTimeoutSignal(timeoutMs: number): AbortSignal { + if ( + typeof AbortSignal !== 'undefined' && + typeof AbortSignal.timeout === 'function' + ) { + return AbortSignal.timeout(timeoutMs) } + const controller = new AbortController() + setTimeout(() => { + controller.abort() + }, timeoutMs) + return controller.signal +} - private _buildRequestConfig( - config?: OcRequestConfig - ): Promise { - const sdkConfig = Configuration.Get() - const requestConfig: OcRequestConfig = { - ...config, - paramsSerializer, - adapter: sdkConfig.axiosAdapter, - timeout: sdkConfig.timeoutInMilliseconds, - headers: { - 'Content-Type': 'application/json', - }, +function anySignal(signals: AbortSignal[]): AbortSignal { + if ( + typeof AbortSignal !== 'undefined' && + typeof AbortSignal.any === 'function' + ) { + return AbortSignal.any(signals) + } + const controller = new AbortController() + const abort = () => { + if (!controller.signal.aborted) { + controller.abort() } - return this._addTokenToConfig(requestConfig) + } + for (const signal of signals) { + if (signal.aborted) { + abort() + break + } + signal.addEventListener('abort', abort) + } + return controller.signal +} + +async function readBody(response: Response): Promise { + const text = await response.text() + if (!text) { + return undefined + } + try { + return JSON.parse(text) + } catch (e) { + return text } } diff --git a/codegen/templates/utils/OrderCloudError.ts b/codegen/templates/utils/OrderCloudError.ts index b5b48203..914ee579 100644 --- a/codegen/templates/utils/OrderCloudError.ts +++ b/codegen/templates/utils/OrderCloudError.ts @@ -43,7 +43,7 @@ function safeParseErrors(ex): ApiError[] { return value.Errors } if (typeof value === 'string') { - // axios sometimes returns a string, so we must deserialize it ourselves + // the body is sometimes a string, so we must deserialize it ourselves if (value && value.charCodeAt(0) === 65279) { // there seems to be a BOM character at the beginning // of this string that causes json parsing to fail diff --git a/docs/assets/navigation.js b/docs/assets/navigation.js index c5a9a389..9b3c7109 100644 --- a/docs/assets/navigation.js +++ b/docs/assets/navigation.js @@ -1 +1 @@ -window.navigationData = "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" \ No newline at end of file +window.navigationData = "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" \ No newline at end of file diff --git a/docs/assets/search.js b/docs/assets/search.js index e1cd110a..80fcc795 100644 --- a/docs/assets/search.js +++ b/docs/assets/search.js @@ -1 +1 @@ -window.searchData = "eJzMvW1z3TaW7/tdrLepnk6600/vHMVOXCfu6EhOMuempqYobkjiNTfJJrlla07d734LfARIYK3/AkDPvOl2tAH8fwCBhccF/N9Xbf2pe/WP3//vq49FdXr1j2++elVlZ/XqH69uVVdf2lx1r756dWnLV/94da5Pl1J1/7b88oen/ly++upVXmZdp7pX/3j16v/7ak7p62/+tqT1+nRq1RBkTmuKYqS1hHGk+tWrJmtV1VtYq9Q3f/yzoYWLXGUdr7PG8SletyrrFa6az+Gjlb9XpZIon+bwiZRfd13xWJ11bCFDZsaMpvlBCQAeVRLNn4pOIFqOoZOorqUuqOoaILMiRrPcZH3+hBM0U/Bo3bvsWVDnuzF0EtWQ+q71o2u7bUzPRYVZVDPgsWZ1p4TaVisv4QZ2ry+wsggDYGr3DAJ7izBwZm4PgNo6RJ01eHt52Ooh+ry52QPgNgchYA3PHgC2Ph79XcP/pVPtD219adj2uIY8vOlvpARt38hOVOPfEshaP0+BNf8thaz9oxQ6HNgTeZkunWqFvRJECJioLZDARvH6iJHaAkisFEZgfyFx89FA9gdK2J4gM7olEtlRngExpFsEiSXFCOLakeZJ2Iqchh6qOV/GvAdZ9gRGPdieJzDlwVY81jyGWcZooxhoD+NNTaiV8Srfquf649DAP9QfVSWp4e0QVbfsfo4az4MavEBb59X9pSrr/ONg6PK8vmBWboK4DHEHE7fEDSKyTFtTXJcF1ykugQ41bbYKaNpW/mDTttHFTRuofafylrYzToJujhbPwZvYDQFuYkHt7y4vaOfuRLnX8WVdO0gm/jojUPKvc3dpmrKIKqRuSiJxOTGd5AYF7CQRVfGneVR9wu/CddMbcbSbhnTB2YoDQThJgWjGDyEl6ZZY8RTs0GWjDw9dMGVxTRz0E9ZFbsCykUcHLJBukEWSL7O7WOyhStPWz1l5qzc9SRIj3LEDlq0QOmYxMxI+bNmpC0YuAAEwaNgRCMYNAAHX8ezk0b4H0GaN/04ctv+AOm/udvK4xQP0WXOzk4ctjlvdauiXnsz7pX+SN+tvv16PUuR11fXtJe/rFtG5ssOzWdT4PntS1dXLub6QZmXRzYzQMaqjXb1u1UlVfZGVmHo+xMqtWDEUb0r1nPXq9FP9WFQQgZpilFOMGHVcNYXarXpoVfc0LHZAou0YoZ8iCLXN1vPdpTqV6qeiUu96daY+9SbkkV2lSwrrLLfZCe0unQRwhwlSsF2mkwLuNP0U+wrAf40v8MHlHzr2A4d92NgPGvYhUxzmcuiLRt0QyU1bny55HwrUjNFTctEjQ4sBGxMyesxo0BIEx4GAIrYIsBOXrQAAHLvvL8LZff4EVNz42IJAR8aMJjMmtiTB0TCgKG904pk3QBFsATRMmva/7+LuLvdd3hZNX9QVNtbZxTi+C3RLSrrEfTbjukgPkbDLhKnALtRDJexSKSq7Ar0Ax7aMUMdWlJeA41pmFsIrxEvgMS1AHfjwL4HHswB1boTwEnLoCdBlRwovQYedAGW+T3wJO0QEaLN940vQ4SG38q4hs43r+OYrbrmRjTaovUY21aBWGtNA5W0zqlkGtEhSbwhxp8oSrqGD9rDV3S3R4jggoxBiD6JMQYAV8BmA66ylPqz+Obbxn043bX2u9ZgCUbrKTqfGiMBlb8iBT7tpypdFnapFhryO05hxoghA0Vid66zMLyVt+Va53AgdpTrYz3HsqMeLmPgQ6X6IVIyR4hnmVT0BQVlU6fRvshdmXreVb5YYydQ/tFnVZTnc0iyQ3oocw8R2hysB3BnyesJaOJ+LSlQLRwZRLRwJEtXCaaVRUAunxcUktdBSl9ZCCyR1LZR1PcuCa5Le503XF2d9gPGpaJqieoQQ1BSpWyPFMNDDxFUWGyQySqLq/6j6RHX/B9X/3J5U+1vdfuyeFJ7jWsf6ZMSKpJA0v0fVp2l7eqj8piwei/tSCYc6erispqjJRjyaB9k+tTHmqpBCffoMuHizRojWln+BZCXPTVZWWXSqwqp9V5RlUT1Orp649v0YL1viRZO8beuzPqmPMzy09fkyxohWF1m+QT2R7RvUJXZnEE9jecajnVM/Ja4CcweXpg5MJ0aEzW86NpKsBTKT91UYnLpzWqJqpzUT1bo7Vaq815/+veqf6hNW2t0QS3/38xIrjqJ/nffFs0IXMa461WdDjHyMEakeYP061Se1fXeqD2mBnerTtr+7y/25AD/CHDRG79esLE7ocsfzGlioaS+V9VlZP9IFPAY5cr3c0kAXjiby0DVzWxNeNed0gYUCU1ewWIDoQrvxLgLRTjzGMi5eBBONyxgHcEkOLrjAQs4ucGTclNakQKe1tCKz+2FLgvsfiCZ2YmgvLzsrhJBs66eMZ1s9U1GJDlbtsYJOVnFc/CTMxMAnYrQqO/A0ReHBJ68ZYBjE56sQjmD7qWkOsJ7SQ197qESWczOAUY91W5CHm9dABw9iTBV4GDPzRwxkLF3JUIbRRgYzlrZkOANpozXNQSGtZhCPrFE6qMIaJsQmbJwOuMAGytCxgxuLBB7eMKr8AMeSxYc4gC7ce+8QxB03QCMc6OyYAoc6AJl0sLNDCx3uMGzAgMdCEQx5GGV+0GMJ48MeQDfIcIQMfQCWCDsbPvwBuGJsbMQQaE9mDYJUS7cc/fuhQ59FABz1DMDEpuPlvizy/6VeME297zjE+DjEkKpbRVlXD8Xjpc24/XUzXGTRMv3jTgntIq2s+NdaZdpdlLZd1F1/raqePgpphDq0Bm9kwHpsZCF4+L5VxsfvvDo/gN+q4yN4VB2zlW4OmZ3kibimtoFAGxqryw1Gt8LoaBRTBsdXLgjhyIrnYYdWWwp4bMVrc4OrrTQ6usKUw9qBfHzlpLEMb6tORX+dtfQe5xrqUMO7kQENr5GFYMO7VcYNL6/OG96tOm54UXWswrk5ZFWOJ2IM7xYCNLy8Lmd4t8Ko4cWUQcPrghAaXp6HNbxbCtjw8tqc4d1Ko4YXUw5rB3LD66QxDe/3qiyeVftijY6pmuGOcKQ5JhQxy+zJY6iRpnhgey1jYk03xQRbcRkTbT4pIMySymgYo0rhgPZVxsOZNgoItXIyIsbgUUCg7WN5LMNTdMP10GTLn8Mcal4sEdCiLPDBRsRWxe0Gp8ybClsZtw6YMtSzORlEPRtLw5gnGwC0SJwmZ4RsUdTuIKrYqM4BIBvTsSys2bMJYEvH6XLGzZZF7RmiGlLfxeM4F4lpTN9UfdG/3L1U+VNbV8V/cUvFzvBHGlm/IGZw3RmkDRHyHArBNRklncqlw5zcAyjZmyFYwvs5haPoostwIDywDIETwyxjvqZxDCF/JAhhXFM5gPJd9ayqvm5fblVe0ytxLGsxp9UuaR1APL9GEIXaGYkcyBjdjGbOA1sS9EwgC6oBH+dUklL+oPpYs/6o+uNs+g+qjzHoj6o/xprPXLHfdwY89AvHdjom5BF8cd3No+qP6mtGtqiOZqQ7qJf5QfVpuphH1R/dv+h3XeI6F/3Ky1E9i0EX11AO7VOGyWCsvR6miMdZ7NG9OsJmj37Wh1jtlS3Wbq+Qx1lumzYJ6DGMcfZ7IDzKgs98UTZ8JjzIig+Maez4QHq0JR/d5+Ns+ehJf5Q1twhjG8+hFn1Y8Io06MPi12H2fDyoG27Ox5O6R1jzhSyy7I6zjpowzjhqvqNs40QXZRonvoMsoyZMYxg159F2UdNGmkWNeZhVNPkim8zhNjF2fDa/Cn7MyEwHW6x2IOBLlS9G+wi+wTKGs91P0Y/hiiu3xWAfyjdUvwSQj1M6yUmnniUcMV8SOIJN9wmUbwcPN6eQnG7Tp4RDbrqUI1hnix0O2a0pHEYX16DN7iQBpbWR27Z1O56fIbsSI9ih27ZbHXC31sxF6DmVvTZ8VAXRp8+H7MWxIyKIMndGYq+NHpNA1JmTEntx8LAEog3cJrXXF9wq5WEwG9jbun2s+15V2DuTruBHNjivHtbwnLnzcNyqTl+l2nWf6vb03cuvqi0einwwTtf1ifpGfshWp9lMad6/PBtp5mOaaXPQt4UaR9/Dn8KQx0QuayIpGe9Udfq5Uh+Ks5rLOgizU9WprlRfnFWzppOaNEkl0Kjpv7zZiIex7nAXMdWWjFBHNtmtDNZSzSz4eyjuZdad9qPq0cdZ3QRmMb87N6rt6mqqDtygxBX8yIL36mFfwJm70OO8fhb4ZK+Ehx08+XngQZSEhx5M+WGwQZWEhDmC60cBT+NKWLiBnh8GHfBJaJiBnx8GHAAyLJZhqfJWnYepKNnAjWCHGpKtDmhAzFwEG46dNm4wAH3eUOz0cQMB6DOGYScOGgRAmTMEO2nUAADabMPficMNHlDnGvpOHG3gbm27YffqcfT7efPMOCPswh7bxF1iaDvfZsrX2IHHoTwgkpeicB7e+LhhcAsEkgBmyEkisEUgieCxGA9TwMsxMB1nLp1AqM3EGZAXXvwwkpdeYCrWnDtpYJsOUvCG3YmBW3eQgzXxTgzYzqMUy/MEZ/Z5Ah9SwFsFFJ/dGU27HUYEGtER/thOySeIdkyuDIabYC+NwAwLiDhj58VBDZ6AhW/YXhq8cQt42AbuxYEbOU3jbEj8mZZt0C/SfEwtYcuZcxQ+gnIxCAZQEo5fs7bISD9TCud5iZ2KCjcpFo7cmkAckCMuRSTyyJWxhX65EeyoLzdRRRfcxHdI+YGdhEUl7B94gtDP96j69N+OHQm7SOCBMM6AXTngx5HdPCAhC/1cmuqY77VraWFFtmtoKUsOHgJZWOLRD0IR+gEHmPRfEB2MWSzScRjAEGGoxTdOSLhCP5eGOuZrxfdsBluqcjOH1MjLrUuYIwfRtgg2el7hQ4fNG1V4vMwqs0PSjTI8FmWV6YHKRhYbobCazFBgIwqOASDV13lbdx17BMNBkA0x6zlmNA3XbW0Q0P4K08XfhHRhyJ+GZKmYrmpDAfZRvKrkdcwtQ8gTmS4iy7zWeVaSTkJTiENNqyEBGtYJO9ismoq4UaVVeZNqquIGFVGFOnCHvqjLZkgYw26Kg2ad1uOMuimImnReEZua7MRlUxGGgzXlpjpsyGlNzmCakqi55BXl9Vo8gN9TmAbyPZXp9yrWLOa5auaXlK7rUu/xFHX1rnou+tH7gRW/yoY0prdp8iWNwkyDK4P3KshwLwhInfZrjOaa7xBnudFg450gp7xe/gyL50OUPIMOF3P66wFT0YcfSQY3tGGUmOiLj0y7OgkD7WriETRvqp50QmOQ1BQ9OVfABzyq5Y6Ed5f7Lm+LRoTU2ZFSMoxvg+khaRDN+DZYMUZPyRVMFM3yvcrLooqsSqcxkaPq0nxRKGqh5ytB4y30dC2kxEJPd0CmsdCjfqCFHkmSW2jrxVCRhbZeCk1koT00qIX2IMVbaA9XwAc8tlUJLfR8xWUiC71nEFnoPU0iC73nCiaKZqEntrMwNqclVXADO1zOGW9d10saMU38ZgFOk7tFwBZFbwygVSWdiNZN04P8oPrA7uNR9cn7Dv1A52jOMIBmCZxCU9RZreqJeioXh/SDHNUXjGznWkSyBI/SHc+lkisshmy3ho5TbVQOKo4hY9Wqk151z4fnAWDhIVK2RIpjkHX0w6WjiXr5jTrYlW4IUvSj/A64IY5vefs1hyXbsacktzlm2WGt1ggfqdw0bf2c3ZeK3QG0AJZo8PYfzTFcfnSnyhJnGO/2W6LE6QOX5ZnagpvxWF3+GryNMn7nHaMNPZFsidddny8xItWhd0It9WW4E6/uGvCgHK4hTzyRqP0lanXOOTFeF51z4hQ1kxgEBbOl/FY7vmCqZCyCk/0OoIAbKiEqIUYyXVlPMqsn6kuWYbJAf40Qpz0PlbkTaab8PGAupjhpCKTqCZQblcOqU9hoRXPQLhA3h+0JODZDZxhkM3hOSxJCEU8AXeBqyotua6W1p8lDoC2eZhPJbfFEJcSI0+UOgMyC6NkPRglfl5weoYhfmRwv+Jes2I23+adZsxvUA1ftBo7k63YDUcgq2oCTdh3NzSIvpKPW0qZnAkSrLdOTAInWW3YE4IrLjiJ6zeVWPRZdT17iOou3a9AYPeuyRO5etlXbug8RvZqN4niuP6pBHrFb7RC8n4OH6zLH5GY98IQcrYOb5fEpiXirPDwtIDHKwzsCaWyy1g4xgBohrf1zkqD73U6c+N3u8REAkckbL/xPZPG2+qDB2zJE27sPbVZ1D6p9XdXDLf5D/w2A9FO8rKqHq/vrKZ6IxD442nXZo9KXhXJTZTPgkefsHUro0U0rL6Gn7l368OF7jIE9g+9igI/iSxigk8t+GtERZoyLO8awR0GPNCDqzGl9lzx4aB/Xx87u+1BkR/hxqutr/b+qUm0cX56XUzpHkPJTzj0VPv1ECNih1R4AHmah+sGtWuyWgDO56k8Anav6xHCaneHPjarena7rqlL0qrUd8MjO0KGEdYabvIR2hi59uDPEGNjO0MUAd4YYA93puACwTgdTZzodlzzY6WD6nNF0AaBGEyNgjKYLADSaXn2r4eth9K3qLy05DTeDxTb64ewEmeet2FW2xGEzbeYnyOzsxSGjA+heZ1WuSpF2PkdJol+fG87g7AnWSEkYWLO7J4CNLqA/OXOIAE5LnDQE4m+Am3xYn5n++xjA6T/CwXQ8OwCw2wGUuU5nJ412OaD2dOiMfK7HDZEZMVPRvCmLx+K+VJNdJpdC3FRqSiEzUkhBx3bOOxq4awbUuY55J452y4j25f5cyOpoN0cJ1N8NCth6ED0QOJ2QE9XWgzSnk+RUNf0qzeumKV+gwyoWgo4lOrHCUiDDobCBUMQQSDz4iRz2BA14ooc6gYOcyOFN0MAmdkgTNpiJHMYEDWC8mm/r9hO9rWWKPiyh41SBgYp8iBI1OAkYlqQZkMQMRdIOQlIMPyAicQdhIiXsJ+CTlVuWxAzI+cYtguSMI00ADQlDBoO04ndFWUJXgu3078eY+N4+QPO2rc/Mu787joe2PoOv/AIE+B1pOxD5FWk0z616aFX3JG4a7RgvYeu4Vef6WUmHtO0QK92o9lY1KkN7kHYOHKeJTJUCJknULX1BLbJTfeL2KLovcIOSuiVoEFR9DBqp15T8HHUWnMJGKkLT4qAJsVcTeOnZVBW88Uy+WDr8uH1pnUFwPfN+1OacT08wYQRfu8cmGk4W2bQD5AGmA04YweQAJIEGQ04W0dAIpEE6ASeMpEvws5iN5yZ74Yaoc5AjG4mlgTWMhTx0fcHWhFcYMN3h7F7Gnet0IfRWzFga1iTYCLAZwHRDSmFESFsKtCGy9THjwykyaxO2JLg6wWlyRs4WRQ2bQ9UyIG2Rq7v8SZ0u9OXLdsBDjcleCTQpdl6CDYtDHzcvEAPfrB0MeOMWMAxhv2tV9jGIptG/3E/R03Axjd2BAjZ5SJ1r+A55tPlD+qwRcADApgAiYEY3LgBwXIPrB9fK0aUhRZ20jaTgFoB94GONpVMNNZi7fAU2SjcE2jBRCrZxujHgBirh4C/QoHDw+zNIKkclfZvlip4PmOG+QNU0hES1cspIeC++Uxd04gAB0IfvCARdOEAANUpTXtQeaW2sKZrislZIq/O95E4e7yQBfbaP3MnDXaRb3dHQgab3JZp3QMuObtSB7Tm6KQe24hTuWS4CkXMEx/LD4G6xPDCKf/nHKaLgNgmeBS8KkU2jFPn7AHfC+K2AnD5mToMsaQI3tL28zK0LIeHu9NkzoDf7QOqXpikL+jSGg8CIlYJC3PaEt7hwDGC3Gtaj0qrS1id8NpRjGHe051oAU4xb2t0aLZYDG1gEjSninQn36kl7oNFvX/gFRq/9pOUvrYqyJ1EdBI7BHb4f6o7wBQZ+4XuinjxGDs7i9kVlTNAAJWJvVEYDmu2o/VEZEWbGYvZIhTwvFXXDN8kzRo3m2TTy8QzUu0q/ycJed+oMf3AT9wjCLdyRwYgG7qORtG+ciG3ePhy4deMsQOP20QjaNs7DN20fDt6ySRpnQ4Iq85dpMkHtJGpJxNKVLIow2njDDG6NiZZGHBTSoSnDA5qEMDsQsSxgyeILA4AuvDSwQxAvDgA01/WJ22zZceRTnHgC2AiHWt5ocxtoY5NMCncE8W3PNPJ3Kr+0Ra8dGB8K+pDKNuiRBt+phZn9XY5Cjb+bAe4CUA62I3BzwN2BjAOqlhSRqHqibHQH4cbBugmUgOks3AhglyFhwDoOP46s+0DJOBPu5kENOUrBmHM3BGjUJQwRbUhs4Aku28zrRxlmB81b5jiiI/Sxxt4th9r7fdbCTb6HRGD1YRrA8HtoBLYfpuFMrAcFtbIwB2toPSCwrYVJeKPmQcHtGszCmjYPCmzdKBLLkAB+u0uYQ42GJQKaigU+2EDYqrhZ4JR5Y2Ar4yYAU2YucnKqg7c4sQSM6bGlQYMDaMqy/Kj6VPnlTJwtjBo2RJV71cYhjT5ow+qz5tTWho0op8uZTlsWNZiIqqyCaeVUNWzyJ9Ye/rw/8ZZjdCnWnv64SzFK9KEO5enrOBqrE2OOwwy/H9p5LQJgxzUAB3daqxreYfGKP3MPEOx0a/T9AVKd7ypXXbyb5BUl+R11U+Z32gPF5pZbkOkhCtnMkmJiuuxVH+yuGS1J0T+qPk25c930Kol20Zzaz+yDbxvRGn7tjdXe1S8Bxq56RROxg4UVAB4osHqSWjaopqln3ABlFUUHJ5yaJKNaM10+A62Y8ZhOlA3bDALQVye3QQ8eGuy14FGCnaOIAYODQTJ2gDiQjtzBIenTBRxonfQSSWsmxMZ2tA4cuM+FCPhu0IGA94gwA9wzeXDEvRNEBnRUDh5BnwVR8F2IAwLvTWCGiDYk3/nwc1lm3nysDDsR6ItyqNmnNEHz78tpsPklmXAzLORiTB4JBZo+IRHbyEkmuLELqbhGT0KhjZ9n8jY2bq1xG/aLNa9FLKBdDZkKHle5KfCBFUoia9orSVibpkgEjXnFCGjFFAM3gnFDoEMYlEJkRFaMIOtBcUjMxooRYi82FD5DgbbbL2YgQo1DGsMQYxTSGIQYY5DAEAQbgRQGILzxJ2n4EY0+RYMPb+z+hj66D07bPvSxo23YYxu8Swxt9NtMhTd8J4Wg8YMkgAFwkgiMAEjCGQInBmoMQAbWIDghYKMAUvCGwYmBGweQgzUQTgzYSPgpXIYCabNfxDCEGIR4QxBqAOIbfmiDZ5S/u7yQHudO+fspUjQDZmyCjEyscQkzKqTqUNaCuq217+c40QSoOQs0Y7HmK8xskarCuq2lY2q2y1zqBzx+aOtLg3z2NfCXMKAbNZklNfIVa1K3HGLbyrPARnbLIra2KIsOh63Gk2T6rRfZqjzMiZnmLZbMRvMUoLHeYgitNsZhf7OQJqax7E+Wts2hJn7LJbX1PAlo9LcgQuuPcUS3NU2VtqX5ugq0Un2xDiK0b0jTLcT0CGk6g5h+IIFpDbaqKQxquC1NYqAibJNX/1Y91x8Hg/Ch/qiYpe0dSjvE1pagn2MnoRIYy3A76VX/pSrr/ONgJMetehnKZYg+mMcleiiXaRbZDzQGiDSEP6j+dZ6rrhtSw9R0c8yGSP0UicvvlBfC1+Wkqr7oX4QUxRQtIUcTVBzFqUldIudGtV1dDfvZUhozbjKi6QlCIcv0AGEyiuGhMiHD8FpZGoLxrkh5HRkvi0xZR0aSkIYzsqRtOzNNQPOZcZK2oIkntBFNTOnb0cgV0JRGoqSt6S7E9ndpbf9dmO3vUtv+u0Db3yW3/XcRtr87xPbfBdn+Lt72W8OhNss/FtXjm2dm7cEOeOQ80aGETRQ3eQmdKbr04akixsDOFV0M8GQRY6Bniy4AbLqIqTPzRZc8OGHE9LkZowsAnTJiBMzszAUATs+8+mbDh3YQvszOQdCOQYKdguAdggQ7A8E7Asl3AhLtAMSu/Iet+Eev9Aeu8Kde2U+zoh+/kh+6gh+9ch+4Yp94pT7JCj27Mq8DvKseagZEBzna7C4auNEdyP1NnBvL2qqPqkeHsQ7tbaFyuT28F5N2YHF9V0i3FddjhXRWEf2BuCuIX4+1ZWUT0JgNEvnGCKv2Om/rrmMPB22UsyEWfDyIpHhfszZ/Uj7XsLmP6tsCurUUmz5xmz0xmzzyzZ1kmzqRmznUJs5v6v6prj9SRT4HOdLkWxqY1V/IQw2/rQnbfk6XNf+2LtwDcLp0J2CLYv0Ap8gYYlsStMWcJmeabFHUOnGqjGmwRUHr4NA0G+a/N++qU5GT/h5LmCObpi2Ctc0VPrSRbFThVsIqM5V2owvWWlb15iIQbS7Bmt/+Zf2oTfGmbev1eG1R9ap9yHJLeg4lr0Ff//GbP6/fM+szgdDVaQzP5XHJg0d2+FE/viDRVvqf+RgpFuC96rrsUSR/XqIEiJsf+KeiGm5IvFX9pa2uszK/lPZ7bE4ab7TIKjCn++77GP2rsqiGWxyLE1BC/iLwQN6qh0t1en22BlwhmO2QUHYGh2AIqPltp3p1p6qTat/W7WPd96rSAzkdYFiO/q4+vdBZABOJ/O5zeulYri5rklzBogUFFPPPlfpQnNVN1nWf6vYUUsi+JCKL+LosVNVzDQsnucqHBKEmhhWRB3wTPhl/Xel9ZNWs6R6ajYAqTvOHVnAA3F+925NqR/sz3lOuwqo4kUxkNZ+vT+9S4lxlRqqywqYKjOkE02Zh7hO/SBaGOEnx6ynFL4M+xkmfgXZO9/BsLI/wpsxDsyZ6RAYQs3Ndnxs9jYu1O/t0/nsNj4cnieVxlNkxpseXiRS2B89EhPHxZSDW+gjhY8wPmYVo+4NnJM4A+XKRwAKRWUBM0Pcq1xU61gLtkvnvNUBunCT2Z19gx5gfTxZSWB84CxHGx4Mfa3tk6DGmh8pAtOWBsxFneDx5SGB3qAwgZufucn8u+viRzz6d/17D4+FJYnkcZXaM6fFlIoXtwTMRYXx8GYi1PkL4GPNDZiHa/uAZiTNAvlwksEBkFkQm6G29vFOXyhq5kvwfYpi8aGltlLNQDzZX/qwltVySrKUwYv5sJbNn4iwlMW1MxtJZOUn2Ehk8f95S2j4mY1Iz+H/qyxGm0Jns/xxz6MdLbhLdBXy8WSSymNo0irKYyDwS2UtpIuVZS2UmuQwmNZWibKYzl0QeE5tMLoMxZvPHrPtOqVQbilKV/5lGlaQ91MZ6v8aXNbl0ARxpgaUFcIBBpjN/lH0OyvgR5hrI/mHWW1oIxxhzugQOtO1A9hOY+kQ7KFKV/9Gm/sD9F/HX+G8x9Qfu3qQqgONM/UF7P0kzfqCpP3TnKFUhHGrqj9t3isi+19RPRXFdl6XKx2fJnot+OIysHTubwF0qSbKRxnxNWb+o1taN6GSsGPSqWAIUo5784Kyo0Ok6vKZxaKan2pubal88y4On+rEfVx/F/WLfM6RRxgy4JMn+T22UHut6bKOUdiypGyXdpRzSKOEsp2yUnnwmb5RBPaX5PNetOhf6byGtkEwnkdeVZGTD84SP3OkySzc6A/IQOv4KyoIZKW02Ojvl47PyS5U9Z0WZ3Zdq+jDvvk/8aS6rxPSVitNh38ls3zfZS1lnp/dZQ2doDRfZPheXNMwHaqN79TBHF7g6GXnkoDDHJi+UwI2Jh/qn+jReTDTbbBlUpT4NvYYZPR5K5MC2RZJ7qQFAenI4L/EJcXTUbI2aCGbuWgNgTmvURDC2o0oA0rhikb6UNufXg8lyI4WkaBGfcSQ76mMuayDBZJ2RwjFoxsGUeMqHus3WxA4DNteTkkC/1JcvDr7Z80iej6esu1fqMHsAru8dla30TTamsR7QTBM10GObZsJGeXxzPK4hfvEmeFzj+5LNDliJlOVgt8a0DqmzNcFDwcOKngBPWuJ3T0WjL7AdL5gTQnZT5HyJnADIMREWUhkptGsKQWjmdPtOZW3+pKf57IzbChq72788tG3d9gXqXmVzdPRhNSuXXqZzUUWDnYvqODrjzuZwPD0JfxwSOYQvFi0tVVOMV/OEUjXFeBPPkVR3Km8Vt7bKwnVLKokYxx7x9lIGN4YpiVYnkbL8vrtUp2Cq+zFyWp6XuHY5XEGcvk2O9yFHIB1FM/zzTpWleV2znGz815JMEsrrrO0Hxjdl8ViMK+znWne7ctI8a3vNqaakGjOptLTgLhMBKdlQkrHdZC/2mxBStGZNIDFZ/Lc94pv2WVk/BrbbfIqdsuVeZ716rNsi1OTmS/ykVHXXXyuNEIpVd30+JpCUq1Wnor/O2lMo15BArhNIyfW9Kotn1b5c19VD8Xhph3lXIOJpSiu30kpJaz1gNyIHslrP2Y3AaUmrvFXaPtWhFbEwUkhL1qvH8dsM267BeEsy6jn1WPhd9Txk/OVW5XVwkynmVNoxlcMJf83aIuNuqAVBn5e0kvAuQ4GwolzGASnL0GYaX+sYlvjkHa/FN77gUc8ppWGt8yx4dlGOkVOW3Xs1Ftq8qiBmOquhqIz4SbnGWd59qQI/6IS3JJP2a06UUTOOkfCI2cZENw/5AsnyNXpiqmnYFs61JpCUbB36haKtY7/UbOvwL5RtHf8lZhvWKIZmui7lh1IOyxVDWy2stFLyRlmUQ+zIbk/kTdVHtJDdjohakjuUOv7zE3s5h9MnYz6IdDtijMPdDhmPYY6EPIgqrsee2Q7psyPWjha6xCtHE9m8/RkK1hnxk3I1Kg9mmuIm5qlORfU4Pe8WgTYkk63JJKU0dn7DVngnTCOdpOu8Ds4UjKn5HI+Ay+DWfdPEZNNaQqJeY1pNOLjXmJgjIRNSGW4HgVP36dmnbkwj7Qx+R3d9rf9XVe5Hs8OR87yc0pU9pw3l4+dGVe9O13VVqTx0MbFuVFWc8imNlKVsnNoMZTPOZR5KBl52ASBKbrAIY533QaeDgwGDsS3zvB2aGSmmY4/59um/epLvfeCXTvqNv9jXTbA3vwdOPx43iJOQHkoYPmtYAZPPHOajA2Ftej43kLJV37RFru7yJ3UKPxjV6DS6OY20dNulklDC7UrJF6AMXUpzwyZeSZuY32a5Cq6OYxIPQxIHlGcc1nFEYfN+Eyvp7N9muzRNWYT0eBafkUp6xuC5lomYesa1dmjBtW6Kn7Le3an80hb9y01bPxTB9rmbUmmmVNIS6sXIBKdrx1XNw87YLsOBQLo5elImbQYCeXTUY1h+DlzyWpDqtOtdK9lkRWJWGBbIyZYcsKqwXYYN/sDWKmzSb71dgg1E3K7AHsWYgC8x29g9RjrXzL3sIf41y0Agju1ApvH8fBzZ/ZxGUr5Yt6QZ8RjPJJMyAWBStg9tln8sqseY45n9lEb6s5mx3/WY7xnxHZN/v5VlPNMY2EYXrvE8Y9pW+pu6f6rrj4FF9mmKnbLU/r15V530EkgY0uemGKNHMll+sHXbzyFonjXgl/SB3ajKPWCN/CXzf91DhXi/gmQyY+REk9sjAVscVkoikc/rjkjs8SomwvxdaTCBtyvCJ5yN79kCZuE8l8DPdUsk9HJFWEQ+rnsesYcryBSOcwyJ4KS5n0p61pwnDPdr3VLGebUKSFGfVh+gyKNVwAX6s/qwJN6sEqrY75n+O+J+rHsmmRcrRCPwYXXwCD1YASKZ/+oOSe69CjDJfFd3THLPVZ4p3G91ixfntQqQFh2+hLmDmyOn4wn1od2ixXjQApRC/9kdXYD3LEIV4Du7Rwv0nEX45H6ze7wwr9lAOsxnFoEUeMzyrCJ/2S2d2FtWyiPwlSXZpJ6yACfuJ7sjk3nJ8ixCH9ktT4CHLM4k84/1oAV4x8KEETOWMM9YmAz0i3VTSbxiJUSYT6yXSeARi1PB/rAeLJk3LM4F+8J6uGSesDBXiB+smzDYCxZmjbAaB9iKQP9XN1+M92s4cewnj/V8DSdPxHsIpdB7iUQN8V2S8kYBHkIU0wPLPV0ldGHrSiFerjDVfDwtZH3Q9nJNuEIo9L+luRIzAWdwPTzo2VsJi8Tv1osl9rrFCYU+tx7EEI/bIMZ4vrRssK+tG0zmaQtThfnZuhEjvGylvFGAyYik/rV7qhDv2iCyEN9aHjfYs5bPg9yvdosb5lULkAl9andcAR61AVSofyWHJ/KxDOCU+llyvEG+liB3+PdO/aUTfOPDvm7C7/qFvmj0/n+s56yINgHlgXShI/1Aj1meTeIvu4WSessCNGJf2R1TkKcsQhbiJ7unC/WSDSYMW26L9pCFeXH/WA+jzDsW5opBOoomZE4e5BUr5QJ9Ykk2iUeskC9wXhTqDQvRCXxhHVxCT1ieKMQPdssV6gWL0AX5wO4Bgz1gAUaJ/+uOTOr9KuUJWZSyoBKuR8FeuTsgiU+uhAPzyPXiCPxxJVRib1wvYJgvLsQq9sR1QAb54QJ0IV64O7xQH1wZXzRbUq4A79s9W6DvLc4XxXUYD+TRR1Lh3nw4W5wzVLi/rYwwGi4hl9zTdgsW5mfLk8V9yyO+YfC3S/zNgrxrvUxS31qeT+JZu8WS+tXyNCKv2i2O2KfWyfPNH//+16+//WZBeluUvWpv2np1qu1fGotkDSJ3p93KWXtBb+v2se57NThn6gDTW7heEih2YsifK/Wh0Il33ae6PYkQ3XFTA65bGPPL4TJIb/zjQK/rc1OqPpx0m8BxqPM72qGkm/jHgZpPsc8T91BoIq0vkwHHW/KxlVuW/H9bNmPrmyz5L5/N1Pn6chmJJj8GlTg9+zrPVSMlx9P7chkJahR4eokzYi4z3KpzMcBIyIkE4lFvsrYvsvLn+/9X5f33SvkHfruQ8eK36l+XolUnQH0fNF5+vWfmTXVq6sJwddvK74MmkJ+G5Lz4JmDAPTbf/M3eDr8u68vpTdvW7aI6pfZvm98dYmu63369Zievq65vL3kPpnllR3BnZgvrmUop/eN1fVKY8hA8H4PH63YCUf9EFlQsupDvd1WMnoS5/rOaokVxtOpfF2XMWkn1NXCkZtfUVQd+ZCN0lGrXZ/0F/MZL2ASKH9RnsHjH8P0YXqpsXqqle/Su+1B/VJVrOcL4mbQKVmayIdJ/9miiV5sI7vyYpL62+bkpWtX9Z4HJWsGDRVv10KruSZDdbYxg6SGB/9R9B6RrBZeIeirMd1lX5IzyEOaQqrOmLK4/I7gnf6eTOg2nBZz6y694nl7nffHs/kJ2alfZHNKTgxXNJ1WW9afXZelfhd1J6hhZWTJrroD0We8lQpJzyGCpS1+/bpryBVK79HU2BQ4VvM70etN9UUFfMc+qfAkdLGmObCgxakjDy3yvlnkGonaygoeKzsdb33xu9EYlqD2fZFVmrGAEbfrHmWDWQwWtlhinMUao9NuiUjdtgbWVh6JSzRQ4VPCHwSGiVyddp67RVvo4x9I1LI9ssRbCT6p67J/EDOUcLQnETaseis9iiGaOFgrx7ntEszjFSPTq/FNxLvqbaRUKUuzVudSRGtXWU6QYAD2B/Q4y0MMRj7rt72Ms9HwhC1a8860rUcU8S/6knlUpUS2nCKHC/9T/B+hVY7hQmZ8/VarFyrPWQaMK86Ytan2QEVFr1rChcv/7oh0D+xdxM/nXFDFVU7lVJ3Vuxru/QMPcLlFirfIqPpSDTLycoiQSvxmPowQwNOM5lAiUuz5re3Qc0OnAkUOAXzpl3F2GqF46VVgxQqV/zcqLcOD1rKMkGXV9dl7cvdUbQgkkNrM3jemR0T8J5m1jBMLcLunNd31zJndg8434/eZv1ckZu0cK1Ocmq16g/ORj2Kj8aOvUAllawgXJ6HZ73So9QGOldLPNl7BBcm+LtuuhInzQIWMK0Nv3rhp0n0sl/lMGZqPM4nJx81R7p82rSjOFCpK46/22e5XoesZo0xKtUv3XgMgcLkLmG1Dmm1AZrx1eFWgjTCX+/xR86v9VSJJ3GPj1hD6htQYSG32y7W3SnY0/3xgNal+b774ryrKoHgXyRXe/xImW1z4sjVS/WyNFAiwHbUUfYDlgm+ITaASxeqCwXbN/rPPpyIJbff0dr8/fq4fsUi7+gr6MbZK+Oo3R5oPeZPYM7NBVxr08ss7IC6PZjcyfvyPdCjE9KS81z1zfX8q+GL4NJjxPXM9mvHCM8WCTPqGAybdm+HBZbZ1+VMXjE9ZCBn+6pzl8nCy1aumSZZcrMdnfhLn9lCa3vxUnSWY/TcHDRX1Dkq0aOS5xylg2dn7lxik2/yjZ2lv2FL+/ELN5K+Vpu3LYrTxduBn9QizfXdyq0puLrNDp9KHWT1lsr133GNmN+unU1/oZi2Jz3zpleoORvAYZhKLNNIs17MJWL8MuLIIx7MFWL/dT+EjZua8XKHdrlBjx0Wkc1e3m0KGSVV29nOuLvP3NEVM1waZBK1zTRFatYRSpTkPV8i8Zb1SnSEP9YhaNUYC5kkkZ5poWiTENa6/rSp+B0kN28AtMA9t8jHiZPIfCQSDjF2Pj3nW6nqOmpOh05Y40JO+zz8X5cv6hzSq9W6rbyfm2Lt1X2mwAzmPcxzFuPsRtp7hJcMJAYhGKSic2n0gWFskYuZ0ipykTGygQJRJiPGH4pPKP9SVsVDCeUJ1SSDkyINFAU0HCxVkNwzkkvNzGOVXyUnNjScrMDRZXYrfjmUlpVz8dtUzU0XsmKbYkNUNxCDinJ8zy5j6YYMoyR2Yq2m6Rc37bE6lg/Crb0KEJEYZuLY08sx7mI0DWw0gI59ceH1slQcYg+Fdez7ehyRoH3Pi8TcRhYyJTFClIWow1TKYcZoN2gsRXG7ceb7duCn4QOwL+RYVVxSFzNb3NOycBlcImfymqmwtNXvkwMKgquoDwiomBgNXUhSKptF6YTRW2/YhsHt4HbLsBn7Ep6a33jMoE6R3zZufr5dXh/bw4sckRk5c6LwFhIfsrjP7L76oHt6uB8bvATNRn771luxT1MQ/6bjILks6HviOQUtW/S4YpOlZRPVK7gduUp0e+i+qR3Q00oQN3rXbq0K4VIIzmNjJ/fpO0FWIsEC+lf2MOne1E9WWRyKkzQN43bt9KkkN3p4zVEP7r0qrvyvp+fMbVKWkHkTTr4dmAoq7u+ta3Pe9I/CpfInZzRE8GN/S+KeKzattC+xFUfVZUxLqbi6aeYudzbLpmeZF2xf5Bby0y5W6EOaDgt6kLS97MAFP0Q1Cy2Hcsc7kPPuV8mbthzEL/7lKd3OZ+/CWFd5yRErd5NeGEGXJTBzHhtJjbeJsahNmmk/Z9czNx8uPSyRMH/k0F7rA/LeI2xWb6hBHeJb2vkvTKyTYMXk3HmFTp7Fcr9F/ZgopaKvEp0+skqPC4nSdRHrf0Ekgz58Dc6sgxMAJgX5mmt22ROrULmrJquRNHa9g+F76+bgwYQDK94xuFsi9+7w3axs94MS9vdiMprg9zMzkaU6RysbtT2q+/C5qyErkTRyvRPhf0zux8Tk3MM23Q/muNnwRrfgJVXkDzg6fJSmjetBOTtGvEUBC7enr2lIcf0ozg5oT4AZxmCXPxMFQQBw9aajpXQFvCVW86TQCYP0KU7OgWLb5nIyTY1EMT9o9Jl6SZISmRuG+wuCRNjhXthHc1n3AVM39P5i+2SxRyGrNQfbbf7zKwF+V8BRBBn6vaXo30V4OkaKc1hyLguYYJe93XXKK0DxsiiFg5sTcbIvzmVPS+k9x7VbWGDpckvej2mrwrHSJK2EDUqQ6RoTzr9mKsex0i6fWx2+vRjnaIGOUhtNdjXYMgSZ+Dn0OP9PLDxLyufi452t8PF3Q6/fkE/Z5/iCDRraI+gIiMxxFwr0N5A3qEdr35dasN03XW+o3nGkSw/Ju1p6e6PPnXuV1JX+VLNL5tG+QExAfPJW9eefKaN1AY6ZK22nCvxMuzHdNWG+ubAGH2dii3PHZFFAhBdFdbYa7H4sWmm36nV6X+eTnfE1PDrXwzRp6ek6rmyFFA3hspnQT0zX+gJGEWt3qcZXSK7WzW90WX+47PWwEk7p7MVsc2VXDHw6SV11dbkautDqFd0Q1TZq/e8Kuk0MBJ/5qucOY/4kZ8M0sZ/GCkKJbLqHyRPaYhwneRpAzRbA0RrsVuJXY1bngo+btWZR+9cmsQ6brtEBNNd1qybaY4RKYMZl/dm9oa0cFv1U9mlChxWa6T5JdelnaoAuvQkPBdJv3KXZboG5uPCQgRjJihKO6GNL84TqPMoUTHxsoXdoa6T/xquCIWm6zaGaBAPmTOGyZJhj7zXy+Jy19f2lZVOVPPbfl8jRMrz45sHPKnNU6sPNG5OYS5Tg6T7H6udBsXCXd11WXcdAWSf599xkybTXDOPgsMHAtRVEEQRZUQghx1ONT50QckSx6ecSvzB2lQ8dXw+rczHACDSb+fo8VC3Cp9zi3v1SmkErRL7IR1QTfINxUztLE5dHtUVYqPosWHmyWl8t0UKRbgl05dX86XMtM7ryHf5KKfl58TSPhZiBG7g4IbufskHQMP791K5u/JNr6te0uQ/W/mipTXZbm8e3ydVfp0Fqhdlstrx3lWdWPEcBBkWdC+zgldE2TvkQIus3LIw5dZYRD8dF18mRUijGY3Mn/vKu2tWxNbn7aaETxCtKNOFO80u/s5dIzkzRgclGzm0OGSzNgEvScMkRrzhlaZMenIioNO7ExdHaVbo4SLY/ei7QkE96IhGPS9aHt54F40RFbPeN+29Zm8vXKvrue7D2195i+wRCH8l7O51ZnL2VBZ/+VsblnmcjZU1n85m1uWuZwNlvVdzuZRJS9ng0QblXsv+nGINiqHpvKk6K9ZW2RVL9B9HmPES5MDVOwyOo/MblBKXdZlBcCHpUTrtxJjBwoLW0h3Zkvx/ZlDzCysaXPGJTf9lGLcbibFDdlnIv9hevVYty/e+mtp5VNouu4ykszI1BJEBqWMnLueWSpEDWMS99UtK3myVjECxIKNpcGt0jAyblNiKRBWZJ+4o03QngVRjikvpBeO1y3lhffDgZ1SBgi5fgppckM42BMGlv+1UPotv8mQFO4LvjwYz4XSr/rlZtw0OFOfFgDTrDHlKJt6PxhLD8LwW6LeYE0L6A5GKF9leirKE9UZGFK5Dst2BaQc3xcYemBnQAp6W4mhQ7cKMvmfiq73vtJkq5RF19PvMnFiROdj6HC9DylBzc9tGXZuzkl5uyBDhO6Dtsm7GiPbC21CCbshuqQCuoAtNDOMk+nPw7kkCIwvrI8B8YbFITDr7wQRmH8Ypis8Syx+iDlKgLirviPu5r6w0uNB9IcPdD/3ZiSqJbhhBO0BxYE6BDcN3kGA3uJzcMjV1xtYciod+RQeL1LBt4BdWqGP4eHBv0YaZ18Gh3f3RXCs2qHvmq76Hy/ExUDbMJITT8X/Uu6hsCtNfY/nR+XfrNnBet3j9K++u9/c0vnwb/ImOFT+TXVqas8bym5xtcaIk/6QtY+q1/sc58w7UHQi9EPMbohJDx79KHbFqj8W6udh3O7ukc0AeJU61eescE8bdgleLYF9WTEZPYJN5l7PdshNQWPEvC8/u+To954hwS47q65w+5E4JI3gMaIqv7Sw5BxYJmjXxe5cd9+TJs4MIejsgBu4HGnj929t0H3rhdMVWtrk3Wed9wIuF8p8/dZpiss0fg/Oprj7a6VVPQzTr8k8RzZJYksGK6Rs0WCjRfXFrATxnSwR7pswMp5J9kaEmma7JNyfnBlfOsJJWtscm/s2u3Fl3fX58Av0veLnvV4SaOZLg1gFT7qWHuNVGuhQGudLKnYjjfYgDXEeTeG+Gei5Geq0KfDXTOeqGeWlGeGgKfPNDHXLFHhkss6YawDGsjrCCRr9EpurJDvLOvyiWyNUceItq5cEsqxCkBCGcHnzu3+v9EXhJ29NNn/Hv3N2cZq6XWJXY0B3Liw0j1BegEI5UVyIkHI3wb2QIlohIlS4r2PaC40Bw4Wq+wdMaAwYLjQsbKHfaQ0cLqifdMLUppDhUpfO2e/slcaAUUK9Z8jiFCPHLB5B2y6UxbPSR3d8c1k7hGSSNcYb15A8lX2X9NVp+lu/RPPlzQL3rp3p86aeOrkXV0vwGFG3lXfpkQ0AkfKNqV1i5GjaK+eqLMAnnYII1nbnC9DRVK8yHeN+jEFnaualpD/4DjL7ten7V0Dxdf0TFs/HKE+X6JzP6y8CaR3hFC08OM0+q3Z4bw1WP02x1DPlnQAiDNKSYh9UExT6j33vGWM4RJ/GwFGC/yt7+OjcunAqfpxCR0m+z4oyfyrOeEbPRow46fGpmjtVefbo3PJjrG6OFYVwp7I2f3pXParOt8bohOiGeIURLxKjOska2JD9wMZldRSET7z8oh/ybKJ93w5/JJG72ofeb96pcdvLnByzFC2/v4gVnH73u1BvNKf/Ynynw25Mgi9L4pK/aYu69bj82iLNGjJUatgKf1uUnh2Jrd4Q/GEOHiWKlCK/qc+JeabAlgo1+6XvtJp/ptef9qHSneX2pI0d5nbgy8/ykQRJxOeQMv25sSdBYFbefAzIuhsJ4aps3susrACC2cqZ696Mq4WyOTCdmeDLnByS7A0GPlFX4anT4O5KdhZzGOlxP+8lTc6EoevAdtg+m6ranLE+tnizRIgUluU5TW7JS7ncwvytXLA4ci2XBwK+l4uA2dVqcuppBkhxOG2fIHcyzWb0jVSJp60dkuyL1pDonWqfi1xRZ9Ic2t0Yiz2X5kMwv9+bsnjUx5tv2vpc+8bNu0ApfGTciXLOMnten3BZ1vrc+TBucBpbH4COmJXl/RwxFsTbufkA6A4OF7709XCZnET70tfZFCdS/jqrruvzfeG+X96jn2dVvkSKBfA8++uTpp7+hUWZGahHG5mKwghzQPrZVA+Jmv4MvJ+KA7GnKnww2OEKGORtUeleW9QaH4pKd9spGuQPqlKtPqGia6bXoc/D8ThH1vWU9vALA/LfhIEQMfdihCHdeA/cIkjMCVwYyT0m8BAQIwJcsFfnn4pz0d+o1usb4dPv1bnUcRvV0r4RIpy7uu2/k3Qkwwt4ddvfJ+hJ5vf3flLPynlxmYdhfomvnOJFYvh2Bz3q5AYhLEpcNuDR5a4dgKWpVUCPNrscCIvPM/TQdjBP2RO3hVt1Uuehn5ba73aJmch4ryhDGQWhlFPMtCg3qtWrVeFEjWovXYrPNdyiKRx0DJdophlv/NKpd1WvHscxjIDh0qnCihgJ8mtWXsLGg886ZsrBoHs53KNOrItTgtYEdzADdy9V7j+Usw0jP5YzxvPYaVfqy8mc0bWNstfbDHhP914699kcN0Azh4+T1SHGsNdPWfUoIeheKr0CWPQv+RI1Fcz3qlSeo+MczGmJKoaxKl7b1m4bqH8QVDGPp+SazBXpGDly+KZm+kfvRHlVUPqf9AyZkplOETAi5yVUgIR+6e3SAVnphoCivOw+K2FK1p8TW5FNwgIDYhB78vTMeRnbIdK64DnSxl3wNujM6STvEN6BMB9QosfxPnmreD/3+iTIaZ7HOAk2YQQ7P1mnqBMizpSvtDMh+27CDpzcfNIhPHXXjTDeM9GrM1V5QQTardENsPqdRcvrMebr08nT4TjV9RAzm6LEi/9TKbF6NceJlCc3xz3y/NY4Ki+RTSGnF6iL6nGYkIq0p4jcWX0cZLo++1bltc81yIcyRW2HqGlgin6YrAg5plgpEIiLwD3y3GXguLT/CRefNPOACyqtf7+73Pd1n7mXxpzyemWsW2PFI3yQ66cR968LOYWZZSCJqKSip2rzP1/6xzrE+NRTxFQgw5mA6WKDk9sHzg0yHDqozYgJQOar4yUlYl0gn6REvG+E+ADmCEmEZXnnDjUKxMfVF/kItJmjJhuGUqe63AzswS6p9PCAnGQcNhN0S8Q4kM19/jjI5kb/1CCS6ok/LiCB0c/zvc6FlXR+1y9jrqUXg4R8ngEk4ecxQKSfx0BJ8XkalUvKYgoeKUq+BeRR5h8CQuV/qYree3jPrX6pip4+tIeKTy8k4NLPS4Q4Yc/qv1OTWvz3y5kLL8N56XGstMw0XPqucPgCDH+8xZs+esLFmRHRfNiPQNRliaxvac0vTC6sSaSJ0bBfnRsJiwHGBegAiG6OGA/ibl5+faKJMbJmM9MumP6l4/VXwbLxpevr8+tL//SjyojLjjZpX+VDvOzSPz0N8cgqZmCDGMM2agjH8xQxFIQ6ILzVZo8F83J3+iolSKybQwqkzKrz7jTuuXlvUrEC4BVosKuq+0/3ZZT7RK+sCO7M2Kwe4WIK9J89nqOrXSQZgFWg50a1XV1lvRqC3ap/XVTn/JaeoIJWShyZpxLnD8/7ckG209u6dHvV0CxD3HaKmwQnDCQWwV0LhpNKPtPsCCb0C+Q+vp0u65Hn4o6qfBt9QcVjAQhnPK8+54knkBcqJxI1g4ZUgML8IWFtsIKGfBkLLOVnMoP6Ly3DuJgLzARYd/re3qLXN5E/FL6FUy9UN8VuxthpkAIKJ6o8LHtZ5a06D3tiToD1Z9w+evKySYpsmAaVb+8l64iLHHdiZdZx9zciouqhv8lOp6J69J6C3Uurh74ZI9FLaQCAbzqwEyXH/24hu1osZzC9/o3bMKKzMcRF+M50kYvwd9CRcywPiGSmFYrknW9hTPSsSwb17tyUQ2UZDXnr3OyksAorgUvr3/pEwd6U6ln7uviHm04cNUVjxpsohP7Rdy2wB0D/k7xpDxX/MeuePF7CbumnrHuiPIVRYZ9td2mSBh6TkzXN0KZoWz7iKfflR8Eaqf/mQDs19tLAlYzoEn9pTr6Lozdyuke8LKEDJf9Z98VDkQ+leuNbp9kIV0Ycer2GlR9W6a6z6s3nXEGZHpYd86xSc4RA4XnX8/VzVpS+G/822vOGZ2bECZSfdjEGt7APbZZ/9Bww3RBMexmDV1i/RsMhnA2FcfRwhUt7QNirgJ8UdmbGe+rnXPRmxfd0QT6owdGn2sQPwnJ+jvFQHIk0BsE/ArFn60rzituq3bLSssxHdwgjH5qRZu9QcOtjNyiAEIKMx+cY7TxMVVEXQsvLOhITIqA7oVEEnYrJIe1aGAi/96tbnfF9BWVl/ZoJENC70SjuHT2nNrGZ5xcjjCd9pZw3cJoVZDJ1fh3Zm5OYw9QMFH6qWozHXP7GgCF3wCFIZl0ZbsH17ywYPwvqQ133Xd9mjb4WydPhbBO+up8jdUskdw5NYt+qaNaVN1nXffIMHXbiXdaVzRohSlh/48oz0XMKXzpm2QUQ/lA3RQ4p9lNIiZRZYSjnp/ROTwHOTrFOTgHOTXFOTWJnpignJqnzUpzTkthZKc5JSeycFOaUBDsjJXBCCnM+SuJ0FOpsFOtkFOBcFONUJHQminEiEjoPxToNBTgLRTkJSZ2DErjJhLnHJHCLCXOHSeAGE+b+EuH2InN3iXJzkbq3JHFrCXVniXFjEbqvJHBbCXNXSeCmEuaeksQtJdQdJYEbSpj7SQK3kzB3kyRuJqHuJcFuJRJ3kjg3ErH7SJTbiNRdJMJNROYeEuYWAruDMG4g88/zQ9yU1hxGcM5HMiS2kg8YGi9ZIIZZ/BTVppivSUwgD4wGbG10VAAIj73vHJBs9zuGMW5txI3DuVXn2n3rtRuhncPHyULGwVbGjYRD3NXIgCowBZFsfz5kl7LHTK2Z+tVpjCkwvDO/F4W839kDwd/uDMoLsh6fV9+xE6ccuRIJCt4M4QV5HAXiczqPg99fyr4YagqMMI+Iz2bUKJhb1V/ayrft5IRozShR4nrA9qMqHp/gFjwM2J7mKNHi/muoveLM3dMC8d/kOf+ULOe/FSdhxj9NMaKk6bGXpQkMwfZirk5Cj8wpVf073j1wdmpJDTNSA5xvZanhlx9XuboBlx8pyaFDf5+1Hy/kh1pVh+78PEdIIuw74EmKk0c8EQD9G1rUehIXWdDe08Z7NfpksUfM1RCAGdYURDJagoYoZrqiIcrMHDREsVSBD8aIcU3fkoNaPyOI9Y+WrKB/BMT5/nEnDvaPgDjfP+7Ewf4REef6x7021D8y0nT/aGkC/eNezDYLXf82y92+18uPKXpGMymuYcxMlN30zLctmec5YKCQ70tYIuQ3YAT+vbnJfFVsI9JkZM3aCzk/M9HlmCEkPkXedeVdglfcmrIFKe8094Jct+kR3Bbdjecq6fk3wdqdfqWETWp8zITkHpA8Iu+V28PL1jgrwqfLIeEqlN+K/mkoQTJPa6iEBbVJFCwyAziw8La6UDE6Za0CrXPfTvzwi6BBXtpWVbl7M29N6ypfw3nYRyTZoMsQoMZaZNI/ZdXjxdfiDIFyDRciQxz1NVW4E747kf1npc+1bsMkOc7qTJQ9xbrD9X2hIZxEuRz+mkCaOZjqVkfOoxIA5hd9nxVl/lScifuHNkEE/h7eJ0hdSXKPkG5JPflRQy1yio4/iVfNr7M+K2uP05CZ6LxYno8RiI8zU4qMkSUlStwuoDtVlr4SGn8TdGseUiMdGnWC8bEO71lcX+t+R79MR1seIngSI8Slz9ojKj/e7nuMMrq60wsTLN/0PsjkAw+sWMQC+6ZPMlJydhWOeKdvQIysUjNoN6SVmWmlxvUtIaKI5GpiABa9mchSATuKAVBMd8pSIT1rIFYEUTSMw6iOtZ9AGgMIenvW13GfMOrpaDN7u2vex9eBADv3ghCIibb1YTtMS7PXWTjEsbssIHm4wGOL2LCHaDYNExiZS6ZHM0WRbosWc6/XOaSINTufkNckQB3iNmjK8ZUzbXRstctDunGVmyt0TBUECtW+6LGUEG0MHvBJrbFTuk8LDUzcRPigBIXBBiRuGsFghMDxNnRixr8Phjdw6qpdX8L8nbsuct/3916+65VnbuGlxb0F/LZuH+u+V9XsEjtcGPRdfXKviWBR8Q8xR71VlfqUla/zXHWd955gifzV7LLbjklnQ9L03btoyWCZ8dwfFpOJC3GjWFr4X1W7XDXhe28zJifPRvrkM52R2aIcrkX8rCO2HNTbKP+pPg2zscW5EW+U/qhfpFEy8tGNkiiZdI1SmAm4UUbDixulMCdhjVKeLbhRcvyyRgmBehvl4Gf6umna+lkJekl3NMkGhY6alfw0klC6yoxUgJLy5JXxR4lDnD1UDkH0viAI49GPCkagTYdp4wqvWRNJAUg3gu9Vrj+WtBHsoh3WCNxKQY1gn9c0jcCDGNIIYERBI/DgSRsBjCZrBB66gEZAAdKN4O5yfy76XtwK9vEOawYeqaB24MhumobggwxpCTikoCn4AKVtAYeTNQYfX0BrIBHB5vC2budqGtoyXEkc30i8qnHtxVkeiZuOHz2qFUnQQxqUHzu4bUmQA5uZnzqmxTHgeOP7P/UlRQN0JvNFGqFfObohussmfWMkshDbIEVZCGyUBH5MwxShhzdOgj6ygXIZCGukP2bdd0pVgSsL0lS/eBMmQZK2aG9BHtvA6QymbO/SDCZo/nTmUlkDacbSGAc6bwltBZC9KNMRuB4jTfW/y3QkXM0RF+QXMR0J14JSZTCd6Ui0kpQqY0lNR7p1qIjseU3HTfZS1pnzvj9XuPTHo8yEZWejZnSfv9VwklSmn+flGCeBPPmmG4HAv+smwXhTPRdtjZ2CsziUFTEBCNzv2Bg62v0YLR5iCsucQHdgCI6eQyA/5z/Vj+9O4+N2MpQ6H1xynuao8TC3Ki+aQlxDWiNaPITedMWOD1gQenNXcDRgD+G1jPqiAV37r1uViVbwfRGPGBqRWtLRjzfH0QMcGlM4hpFiYsMUGlEwEpHiwYMNmlA2npBCzuEjIbs1mQMhU9TJmTRtvdz4L06HdD2eh9OvCXwYzZQYL8YZycfsG870mewKgduscjuSL0kNFwe0UzAfb595/RvU58HD3+e4u8hU6nPfZI+KdNklhHx3UKwKDeULzyV9V/wXkHw3hpJLDDfxe+8KWUWGa/jpa0JYGZ0dT7u0ZJopHCSzrZ70zRd2CLzKilK8ephD+3PA33fBthLXRRt8e+GFgZazlUbbEC9OtaatKtuuMDmqhbkk2bbGy/KtbisMtj9QmmyJTmm+TbJXqbxXeozvVtW/CMbHeV+4L1U2UrrK5lA+5gHHJzE/20c4IRpSc2jO/ZCSJO57WJXup0AhAtf1ucmqF98wYRXJx4DkSIES0i86TaMgTko/6JQvQUPE3pyzwnNce5VRU6AQgbdF2/V+h7VV5EEHZE4aU0L8hwn+Ivo1U6zV6DdMo1qOlkJKSwtFFJb/YiZLZA4VIkE9AGiKsO/+YTK64O5UrxsPqqjLsFP9aYwSJP5UV7zcFChEgLqkZVXo5lBBEuQ8yhBZw4XIfFDtudN+Lg1g13odOFsDhwjSHhCrFuDgQMn4nLNXAdIre5O02eP/XKkPxVmtDir/uij3krw7JD4iuC4L733xRNpX+RCPMKueLEj7IoqB7ptkAFSVoRjYKsRiWN+9UdW703VdVcr9/oMVQDDuO50K7ZKTle9OzV1ee+5N2KeuH0KfYhanpptjerJq0fuXaO/6rO09rmIuhKbpdAzKEwyTvvRPdVv81+idRDgpuyDMuKyvMoRznZXl3UuVj15TvXpsV7cpkCrPyrJ7qfLhipg1CfVMLRVicOPPpHlw8Iz/wRsHMYLfpZvDYDy7MZRL19fnN21bt3i9zYdISkeKrrrwF4gt9G1FxIU31S81iG9kDKDQ9hmBGXZCrsv6cnrdFMI2MeyA5Dpu1hRpWsaw3Sc0YMNeXxrD9Utbvhk8WJ2DOYf2pS3VEkEm7O0difMXrnCCERF5/sCbNnL+wJmBsPMHfg7k/IEI5HPR9UX16FuDIkimmJeOmDpIUGTDI3vzv1FVccqXqAlgVptAu/ATUKtpAFz1JXADzK3qmrrqeLNpQQ0Q7Ro1CMbbbGGmOaDg2hnd004bi7Lkr4ZO+rxEBbK85MMD82Pf63Fuf+l8VwkQOE99r4e8/aUj7wkQAf1SPWX6ce3TUEy+8xgE1GVOYCgs8mSRDIyaeRE47MSLgfBWUVnbsULjlXVs8P/ZQ0Zjr3G1iQ8UgZ0tD1ZxCkcy4kbgWJ/FdwBl+EFwpDLrFPUM9Zrc1X3WKfb56ZHLJ1aUJf1OsCk3BubeCBYIesalPklqKEqJXtdnPcLg8pevwUJEiJv/TRHu4n9SRC8bz84DjJBeLs7WoIFi11mVqxISy9egoWL1uSmVZ911q2aEDZXzb15txZi9K1ZqPrUNaJ3WoIFiywlyQK0zwgbIvVWexblV5UFRq3Bk4m19JnczTZW2PvMbmqycd95gK9GTBEQEyhBzmTIp9EOb9Zei58zR4xosQITNRSj9uw6txEUXWYX1htwvzQmwBHof7rKEDJGajtJ6z4SYYtNx2YjOfXkkGxxOLA9jx40p9AnJRtDHd1P4yE5+lr2uPZtPe8W8JtxAaLFhwsPJzIFCBC73y928fAkagYOL73I/HAHipeZgASIfss/A5+mzz+Ff5kONdhl9HdlhfADKK6Kw3Du2RtrEhu024d1EZXY+8ErMAQT7dvpy/NtpRIGlO16o365xiNwsxIw7xe3F9zaSS3/6r/ZCPo8kACDGDy5pbhyBiRbVI3Frs1e8qB65C5shCHZ+ZYtj8yxOFJsw2MqCiQMkz0wgHOLIRIKTZjofWxXphByCXoPxrnqoWWkd6CjDsaQdYjwG+thavBLIavJG3FPE6kTtFjnCJdst8qUN7Ra5MhC4W+TlgHaLBCD4rogXSbgrIoX7rW4/dk/Kc5iApvpkxA3C8VZQcr3ZFRCvosBWhFcA3opw5sU7Ls5zpXzbx36WzoiXAAPcEfHzSHZEJGDEKNUNwo1aCeFdhbzOyvxSZr3iTOY2YFKb6UwcNpq7PERYTTcJbDZRFJnddEMFGE4RHm85CS7QdBJA/qrKGs9dSIEDm1L0pNSdtl6jBSaq+yzEGXEPjMSKw0jz0tvPz6ptixOxau2hmtfjaiOBFGDzslXQd5sXslJ+PL7D88FgPR4M8iH7HFQoffY5ZXkIel4PkLTrhdGIvteDwnW+lPTOpC3ry16KJUQKrz9Hipz33waTmn+ST0E6pbG3IEGEM7k+v5U+86vzoORkD09E/+0Ur814URiXvn7dNKW/VW31L32dTRFihK+z6ro+3xduxyiXst7gXmJESVO94laU7QNZuenQQFkQNn2jOh0emKJEidOPFTrFgWcJMfE3ZfFY3Jfqzedm2FrCGdQUU5kxo1A+N8V4zNvn+ufEWGKR3n8YwtuiUjet7xS2Q/2hqFTTkkewIeEf9Eu/et1TV3x683ND8DjH1M0A2JOUofykqsf+KYilnKMmg7lp1UPxOQimmaPGwBB7BxttbruAl+rV+afiXPQ3052HsHKvzqWO2KiWvqwJB7mr2/47uPcZbgqq2/4+tvuZJyR4sc8zkOjin6V/Us/KP7r2qJdTpBgAr3uMQ5c+NgvJ/fypIg/cbBRrHTy6kG/aom6p8zcb1WYNHyP7vy+Zvs7qJah5/WuKnLKJ3aqTOjfjM3UCw98u0VJY/RViKBc5RFmwW0xSiBvVkqfNaJZGtfwhNBZpcG6VjEcG39YEQ5FfOmX4zKHql04VVqwYhF+z8hIwMHzW0ZKNCokZ/EaXm7m7pHYz9lvVqIx2a9kHw+futLFxpMrcuOhi9q7SLLfzeC8G9FJc1sj0TYA0kKO4+0vrr1njz5KtCGaD2kgQ3JqeCGNOm5ui+JlzXpg9eb4Vxs6fA8LsoZKdMnakBJBmDpTshJHjJLwsezp9q4udUeeF+UO+W2XwsC8tTYwFTT1uDMiIaEvyocZtwDi36Ot2jhEsjRxpNoXhg8207BAELNvB8McV8E32MtwD+z1mEJsxeHGKMom36uFSnZjlWlO2HSIgK7a0MHPoy5REjnzRYsSwxBTixiQ7EU8PyR5GtYMJNhOwM6GO5EUnQze5CD0f6sfgx0g4AHBW1A+CnhjFgMABTcjpUQxA0t0HnyQVoEDdf+CpUgzDCCqsIINFH/uuNLUDsnjyw65ecY9xgs8YuYMLZ0/QcIE4uYIPHhKfpmHJwDM1LBz3mYDZrTM8/qGskZ1Oh6ukns14a7yXT+ngRcNNiQVDFQ+gdOwiOj0wGZlenRk4HST5JHlJVNSfDLThC/pbaXRFnxefl31h6X+tEaKEBZVsFZfWqw3ArirpM1TvVf9Un+5UqXJySdERFq9cjsj+iuZTml6d0D90ZipEMbgySJVHUxZ6gepS+r+JEUbQRV36x7qoHocUiJxv0r6qp3j1HI/KqwHvrXTnrKiK6nFtcwKYdo69Nr8gpH2xD2sTxvPN3IjBFyHp6WRSBD6l7M1bxGllmgw+tSxFGyLBp5dpyIBTzEG4/PgL4ARHYAAgX/XZUZg3RnJfEVpJdNzYn83gw7QMHXioVgwmONXKEEpPt4pRicUoBo1bn0JQPFUdM+3H2fMII57McseY6wNsdBrDnNIaR5pg2O6CxvZgCxtrVlPZ0ggDmtxqpjCV0fYxxChClvClykeD5QdYgqS1gXayuAFcib3HlcviWbUvYyhiLr9FOE0RRxRuRu8E2RUweT4o1WNKdmKQR0Xck0pbQexVJVaYv/ZF8vQRK4es18seQGIl/e9O2GLMUxOcDPkS0kaKfwyJlYM+WMyXol9F2ggBDyNBgmD5sc8j8WLeF5K2UvQjSawQ9U7SRop9KgkWY15L8ugiDybxCL43k7ai5LNJrAz73tBGDntyiJUlLzK2FfnLizkxYoQCPT/kEth1lvygfAmBd5vk49eORIFXrjewQUcpN6LAKUpMEL7gwwUwH/zjr2PHgfBdPRdRPsdOibQctIXrxMDSmNGiIeTrbS6m8TDdQ90uh10SlhM4NfVzJYLReydvur44B9QivVOjpripcIy7GmEMO04qeeMEvrhgzBsn12TCy8g053Pn759b2iEEsyDts61Ob7OiVKfXfa89KpzN2CEwOnyr08MQOVsju3O6yYS3fxnWeebn1i7uL+CiGb1Aph/aKWYUSp1/rC/99xe/T4aTY4x2ujBOGSjEJ230O6Wfnita94jIjfFJ2/tOtWvEGJD3+qbSqlP5Rc8Fvr806vopc295unDO+grTJfrp0qh8ih4JVZwv5znwa/fTIR4eHXOuL9TLISBKUekEdaFkea9ar3OXk2aMnM+RaRcvEVBI2Ywx05XNPy9n1Ra5tApXY7REFfiuUXmRlcsHktJ0Y/zlGyXC+qVpwhr4RUeMa+CuPuZWde4ZgxVAsHhJvLe2T5J/mdTmDJiaO0TZ6TkkSs0gHaLsLNIn6v1qxEOzrnAHfEPZI7NOeOlSn1+fXvWTiP9y+5NM+kK8GCkSRquU7FVbBsGuYC++jc/pJ8mSu39Rx0zsil3Nmal8Qt7Td7YMfd6OEblu1anor7P25GsYhlQ+BM6z9kS2B1qQeE/HFuNe1GGEmJV8SwtZx+fk6AtxbDngJhxGDvha4d/IPKPJ62AeAozkXaOqk35dIh9GjYBsN8XIxhjh0h/arOoy/6lPS7W3A4cJvjQeW2gKjYGCBNwLs1byxLLsPnGHKTUKjdAyQgkMLGf3tqmCJtBEDjdOO3HUTgHy2mS9+axnl6TN2iFo86XWeLEYZOPbifMND5AcT+H6TqP4pNshFnkQRYpAvN1JU3Avd+Ig5IEYHwR/HgYHYOzTThsxVYAsabV2orwBc0tatqwtcvVdq7KPTuXlV9x2fXfRB4GGmECSV/dD8GYK7snNCumbJ6JysUKUO8pWi/VE4eXuMkFRdll8QZqr6LiwESkAYFcf7/Indbq49/6tACJ/6fJlvpEYS/dquIuzW+MQWVqIKfkPmfMSPJ9yn/kvvoNEya58L8r34oiop+fcy1GdJiTU/VzdeQ6IuOS6uuqoYyKQ6PvsM2sBbN1z9hmzA6x0UUmliyqNtO/Ij0OTXq5AxIg77Rx63JV2kORqldyzn73sYOXu5xgR0req69si79VJ+HHbJWKab6yb0pvKPeDaq+uWpKrIYteSwz1tAtFuCh8h+0unri9nfXqieFbCUr/oja85bpqC94z59trUcM8jZPes9emSe8p6+CnFmVszKe7E7Uzk39K+uww3NbfddVbdqdK9bmwplmU3x8mzqhvjhMlf+vpt3X7KPLsPluylrx+WsEFy3FqdKQet1TFy6iG7lL1VcXxG11Qeow3mr5uikdYXgZi/Mq4/f+MYaXqt0hYF1ippOSBr4Xl5Vz2rqq9bjxEzNYyQYVLdOL3jlbr7OWCg0M0Ykhdq5oBBQv6xjSHCjGpIAXI8Y2jwIxlSZiwuQGdMMFxo7jHfX8q+GFohKzl3lGczSpD4uCKvfSpY0dYMGiSmp4v6VXPyuWdLU08W9fPm/IPPgPSPqnh84huA1nyagwaL+S+M34kxF8QDYr/hOfsUnbPfihOYsU9TyDCpRuX+o0KWVKNy5lwQLfVr1hZZ1WNqz2PgKEHfENWQIQen28Qdw9LXXVc8el1zd4Eky5EvjPndpHo1PHvDN12DmJpWQoOrLYJwfIWgDAGFEMOfU8jrsbvwK3RDlBTi+uwFcS+gR1+fveAuBKQQHHX8Ouuzsn6EqvourOCQzxiVzK07+at8/DOf5X1WIiqeBwaufxSM6zPUJXGV0i6Q7FhM13nfnnCnfDV68dOPT+zJQ+YZW2WgZFlBZvi8lUQG0rwo2R9tJfmeySlIVpyhU+EXVNwREi6zEALg4osnT0mWZEg6+UKNDHW44f3k20LmAYcL30/kbnIoFr/Mw4GBiz9CNMFqDAkoXaORYiIrNzQgvJ4jQwsustRlhKwIkTzoOpEQi189IqnANSUpFLvSRENh608yqJ+Krvc6ygJUZaGvX6V8Z4Ow4N5+TyTr+REYYMWLAkLXwYRQ/PkFnsyc/aXFEy3eUYzyJT0ZKLTQRwHiy38yMMmiIMUnXiqUY7ILiBwftqwoB2MXGzkwbAlSDsYuTHJg2HJlABiziMlyIUubQixgwZPEQpdBZVjg4ihFJlkylcGBE9c9kmQS6wEhJ7Rvqh4cLA4h8SmsbCCzJh4yghkzEbMQ5QLBl6G8IGTRv6uei97vmO4PnshfixEAfLiIHPmATuciKLtX2RQzGQr/ejXLBD5lHQAH1tYtkKSu8hDwoH+LIRvy8yCg9dxiSGynE4JsvpJVwCMXAKPW/g5a9ku34scBQme1fGD44S0YSLb6GLvwmHjNMX65EVtpxPdHfWxBp9GkmMIFURdhyFooCydbBt1gBayAcutoAcWTsDxkS542hXy1k11TFCx0bpYTpWucLIpgeXODIl3ZZFBkcwGLJWA2wMDAoxqLQzakYRD4k4EeCvCoIAwiWkm1SOSLqAxK4AKlBRWzNsngCZclLayQFUlgaUi+GLlbHQpchwTgBEuQOyrp6iOAI1h43OFI1xyRVb2I0pGuNCI48CLjnka2vsjBiJYWbRj5qiIDI15QtHjC1hIZJHAibIFIZsF7eccU+G2We+4XM37Hp7qk7VrTAoaMI1jEGMRQg8cdpOj7ouKqj6F5LiqoupCSzPDGkEOGNKQUWRsNIb4GkjL/3txkpHmypJqMt0dbOUclHw+uEqJjgETV3EgMqOcTW1gFMKWQGkCLobvepqpol3sn7/pW0ySb0p+CJFyBs5IEF94WUv9627CJoxfbOGO10S/L4fi6XmGD7BaHgq0d2RCCJSNWXrpStCEJWiDioAQA8WJcO7bkoJbMCJLm3JbjLbpDzNVyyeeWdoEER+HJB5fcCSNPLu25vfWXf3TJgwE/uwTDvPmcl5eTshqT58IDJ5Ea41utibr+AMS6yS4dbV02HM0cIVJYh5jHvk9Z9SiC6F6qfNoazpfI6YC+V6VibK4f6LRElgNtmuf4soMHY/wxUWdqJAZ0oxOXvwOtPy29KCKoIyydZ4Twpa+Hu34QzUtfZ1PYQLnrrLquz/eF+zmfjV6eVfkSOFTQdz3dRoq8j44T4bc2TC1wL4OWfFMWj8V9qd58boZVMEhZTZGUGSkUADmGYInDhw5o4bdFpXsE7+TU1HwoKm396akpLfeDqlSrR4a6JlGTYlP3cY6k6xU7NxYAkOuBXgJ+JVCAcNOqh8JzL5gfoZljBSJ4RyKmIj3mYAR6dR6fAFEtNYWx9Hp1Hh//UC07eeHl7+q2/w4xxMOrVnXb30dY4vk5Lcr7z9ScX9Ni/f5oWWJ2YKpx8wJahN6nMnWAjSla6qYt6tZ7HZOl1axBA8XmvSZpPZ33lxLV1Vt10g/uFDW5SGgCtEuMSGO4Sg9lIJIupxhppG/8b8LSBI1qL11M8Q83kIGd7nD7WFx/+0unjNepAM1LpworQqDwr1l5kY1vnnWMFIMb75KCqUYvJuwEnPMU1rV+Gwyfu9D3SDjTRW6S2HH7jy+PQYUIy+N8aTD4uxTcGOBtCgSG83uz0xEdQLJchCYHznCGBAkDqM7eKf5WsF2Dy0SdBYeaICOcoBgvXV+fX1/6px9VdlItO0jZqlzlQwrZpX96GlLAxi9mpkC0wSjGsT1PScTD/Zh1T/9L0WOfHc5T1j19VMAoCAD4paWHrjvxC/U8Di3srJY/P6u2LZhGOAcSrDv5n1NwJsq+prDjjbTatrrIZjsQrKK93JdF7qtV8494UWale43eSulqDOUhX4g8Eu6vbwsQDY5L/mPhNrm2wEeq7FkJzwRmI0HNXTgJt9m2BYgRG5e877lOW4B8mtMhYVbMW/XQqu5pqMcd9UirMyBeYcd43rP4/tTHZtjRR/HduSBRbtVZvyUdBNMuccNw7A8wpDWEdcOsv6dY4t+lx63yW4DBC/0OWWytH5L3diwOWbpPgeSo3QWHIrvBgIjSewx7VWCbAZL1jMUdgtRQHJFi9hv2isiWAyKM7Trs9QUbDxBG29YtXt5KB48udH7Dw6GM7Xkg8uS2x16Z3/lARLHNj726YP9DjOHfAmE4mF0QMYh/I4QBYfZCEBD38HyvSwwKIRlkU8ShCu+LoBD+rRG3OrM7gsjOGyRoUc8bJJFFzu7L+JXprRlE3LfwsdckFzgQKWKPZq/GbdMggtROzV6R3axBJOH9mr2+bMsGgblVWYf21+0cNkaO3SRy6WL7RDIA71YRBUDvFgUAEBtGLAe3Z4TgkNtGewJ+5wgR5TeP9srg/hEiD2wh7fXRXSQEwL2RtNck9pI8MvbMeHhI++ehwngmlWYIwerZcNfvh/qj8hTeLtnpeuB+iuLLkwXsEdcTM1WKxMcoKcTbMZTvXU2X+BSFfFrTK25+z7vTx/GY48XfbrZhBN+0KX5Vra89ONO9yhp9tJdsDjton/znQi9vZU3vNoYeAB0rW2LFIdxnnXrdFJ7dAzeAjpM1BbWBgMrnZeH1XnaLjzGIARAsXdcfC0UYCo/+EK1eosVB9MVZ1Zf+XfW+KMuiU3ldnQQwU/SiOtvRxVBWk1NZmz+9qx5V521xdhDBEmNTePYzXEnqtkbtj21J/Z4EvedYgVM1X8JHyX5fnzP3TVlO1dMcPEr0TXVqas/SiFNWrREihX1P8Xlkydf3QNG7+tK6n7l1inZzcKko0TzwyjWFxBvLj33vHDMR6V49jXGgDM7ovul3nWceJxOKoFyiBUIQha1LBC9wI3T6AxCMluwYBJHN2MMQUk76SIQcVGCQdmxS2+TGsetTftFrGTdt/VC43V03QaQ157b2tpl9ulPptzXdYGxm0TqoU5UaPWFi/lbhkGOqPiR4k3Xdp7o9+V0NndLNFC2fo0VByL5t6Fcl6it9RtIbOMlJSTp19rykPye+vt2OEATVTT83489J8cib5Tgu/k45MRBzvJMhQg55BiEF00SC2K1I30Dwumna+jkrbz33HOxDSeY1YyzfGokn7ats+gu5UOLAJzGK6pGsCBRKUT3y1QDFYTbnfSTIFj0OISuFJPn2945uUaaDRGWJfSSfMrebhIvr3+jlZR9De4FOQ+Ao7pVmnzyx3kxK2gamOr159nbL04+4OblT7XORK3rsbKZ61Y0xgBHzTOqTLnpvX2srFj3doe6FrCJ7Kpo3XV+cPdsw5u94wXnIt2mRzdwE834ffduWOumw71X/VJ9Q4W6KqS9eOw8xY1GMMHqz3D0+3XM8FY2a/lJM0eIgxnIQyJ+XCOHCnqa+06MauVvGV1d1GXOaOgxeZ+nTFc50kRMWO2hmZx4X/9caQyztK9ab7KWsM+fJWkcwiVsQdYuML2nkHhkXvXcN5Lloa/+8zUehrHjRGMOZi+uyvpxe03uZXqDh6EWuU0C2NqVov9Xtx+5JuW8mpJk+GVFDYHzVkjrc7gonW9y967P+0vlOb3rTHxZ5uyEueZTTmRGgG2FtuE1jdiWYNWdhLnmulOfUPwFiRIuH+KV6yvRt3qfhiO139Ym1kDbNZY4/nLm9H+PHY/E9no0B9nyMw8Hd0F/7zZdslen1cs0rnZg+QEEeflqwApazLCF29YoRuq47IDv5GCpMQp9Xmq4k8zeMVUufVzoZwcNFdZgGleyWwGGCxo3YvKBx93UKQaSiYNdtc6KIUkTy1EKApcFO/xmhsWq4z65YQt0SMEzoQw1Xir6OrRKLGFKEi1xEMX5os/xjUT3+83K+R0qzn8JXc/gwWX9Xskox3Qe16Dr9TE2Y5t8l4/muv1aV78DUNs3B5OZzeDof1CRJ28F/kkMSW1abwoofi3Cy/NTQlgWnhZzsMBpHNYfxd6TgfGk5JNgsgcMF50kv0Lft571oH0cB6GvySWO2ynZT0HCxX6pivIYXE7xUxXjtbpTodPc+Jvm8BA4XpM3ZqgWYNGbRYlzq8qmNv8pMGpAWP3qcsHyLENNI//Shzaqu6L/PXrwV0JSdp3anfox3GuOFYvjNiinK2BNawrv9shGht11YGX99M0WY2raTcNe1ccHZt7GyDybYajDX6phvYydvryEjH2zNBbuOHIACLaf7QayCb1Tu1G9ULpjmamf1nxtVfVCf3S18Tm70a68bPVD5TDRyjeXdax2uSx/PM3tKb5Gb7lYfTzFTJcYL+g+ebdWYk2W0VFGpjupRTDEdlu1QCDmu9AILjHy+ZE2df7aEEvHaviV92uoRSf9Mu7CtCjXgtsYLuTunjQjRE1ECxPx4FeDmxoSAdm0pfMs0i0K7hpJLeHqfJXGq37GT3Rq+n/0HNpZfo3dk7ZS4JjUh+SQ6zshaUh1kZ2lJti2biliLpgWH4fv7rP148X53U3IYvp/n4AlEvQeb/ML0mSZWnOxYTEm+X6GF/C3JVGHa005i26qmKS5zgtMVEG9r4BjArSAaFOxzEzFKoHn4zwvDTAHFJTOtOKQqEx1YzKBXASIANtWxOhXVI7UNYwcRjnlfdzfZiwYgJsoOgel2p64ZI5/nyN4cW7nwbQFlpXaEhRnul/BRsm+qk8/B3CmrqhPpYQ7KeqvVXpGuTIgYMdbcy3HDTkSQ9Nt3qvKu+6C0t5PYa9I9hUeMaJ9sl+EOLGyzbz7rvXO5wtho1RwbyjdkIs0IULV2WMzh52kTGa/v8WftaTDorH0IUjBNJIhVeS/39KFv43fJiQHf1YS79LirCS1AX6eh3amrR3obcCd8P8YC9gMBBObxvr068nIfIkz1XDtRttsCBN8Ol0VUuft8zU7ywQgeI1qfr+tzk1Uv6OfVW//5GCXy22pxor06lblmCsiicrEyOu3nzH2hxF5sDR0u+VM2Tcfxmltm06Q8uv7+U32Wilfqcyrxui8eipy8jNGhb8SKRpjG+physwSOEGzr/3c8fn+57+serWnNHK1bo4VDDDvH8j6im6Kl6SQ+1EIb1tdpLJhnOLzTo8bCbhnfWIK5O8sTNPUIY3eLvmCwAVzi/7oprqkbcUiSpuDvxpHhwHchUFyyixDiAP3LTBJCZsVJhvimVM96TOb3HafQ1BSb8SWXIRFvVZAw3HMVQgy76/IcRqB47F6MOpUgA/NdhkWxXKjLsGTyvG3dqYNmln/NwxOadIOgoyT1iACkYOcIJqdBrgkIH+ClEIYGOiwgjBLfhTBYUSXHPRpgGF+lBwezUzDBIa9WnYr+Omt9J1s8iV/lQ8Q8a8mTLY4cRK2s+WgEa2o4kndv0UdB7yySwvZ3nx64d2qPv6UZQBpp8SPGCcq/WDs+mHGdVf4daFtxfi8jzypmH5oRZxelTFlsQYoW9FVPU4eshHTy/gGtKcCMWGkJn6EzBUiLtkveVYWHKkEJDQGiT23sEkMKf2QL/AKGFPQZtmJWYb1U+evTuah8l09bAfDCIpbydgmyy+0Woz8f/g8+/4jzU15yVmq8m9xCxpBTX2AJkDYH6yeAc7H5BoKPvlEEPrpL0Ft0w94Tqz2ESl+Ia7KykhyhA3fUPADQVhoFsS3i66zPytp9wdz6s2DcN0bw58pM8Sof/4PJzMxI5kI91q17AmD8njYfa5J4RkZMv+jwu0B1+C+57LYA31X66pq6fblVed26Bzv7YIL+1Y7oz6BL4aqY/9gOf2Syu81L0OEoHwpwNIpE2BY85Qm2/owXNJsrM0UwNzOjPxfkzML4XeCmQV83uE0TumHQBOXzQnXZZpgj8rT2pMJ8hffge2mgE/fImkU6XLoy32Z6qzr3bSf7UHix/lN9mmMKkr6q1KdmjebOowPek8vJQ9l7KZoVQNANEbsj+yT5xwJsTq+DHnWHkEuWvz0IEp6ue3gZAeBcT9c+vIwYsbkffvQt0TjUlf4nuUIDycK5jc2fbwbqkCJnoD4xs1n8UmXPWVFm96WaXbtd0o5geBMZVn8lqY6PQnrz5WIO6Wy98nynSyNYBezppGQdk38pb+0NmGU8quN5PWfGuydoyMxh6R1ASo48IrAq8QcDKBFmZXCVQVYFKaE356xwbs+tEmoKIk/8bVaU6vRT/VhUr/tePzvGfJ6HIYKe6VTZGiFAuGi73meJDDkdjLRClAhXAwI/vT58hbQYfeIqotVoGb6EtEhwAY0vXjACcxh58tSobBVgB2GIhC6sO+U9K79X0+XWKfqoPCn8VLsfmTakpiDyxD+o9tzpOwsb1rz0Omi2BpWL6d8qtp5dOuYkCyXh3hNYEyf2A4iZBbkwGLAeyNzevVmJQy7tZlcB/RbKUGLMFClAGRBDgv2ypIj/8xoSzDem1imX32nPEEcw2Z4GsR7rSxtakHXxi+foJEGwuFnMxHUD008pRpRmUtygciYKa7CWEtJcGTn3d7FUiO/AJT6vGPIaRsggKZ9NsFRIi8AI6KPCP6ri8YmtS8Px4Kc5aLCY/134nRjzEjwg9hues0/ROfutOIEZ+zSFDJPy3c5ly5AXczES7k7CSp/oIvaJOywX0oaWMLgt02PLX5qTb6rnTHgYl1+WSGSmVmzg4OiN730EN4Z5ZJR+KAGFmW+SWyb1OMx8n1xmRBXDOL77z8+qbYuTe2lhGyZhH2anCXZmKyyZJ9+NTMbPghVy2uKDd+WYZB4h6iaGnRh78QIgyFwTstNE7gmRyfpWiilpcrUYkPdfqLBTZa5RAMS8PgY7LdqPwC1lVv3f1P1TXX90aU0/CRrv6lniNAtmgqYrib9/m+l8p0nUQ92qm7bW7wRMT32zwvdDpGaM1C6RggDoXRtLFtiv4cRATxlbVuIZIwTw1lKSgK6xDAKyW2Wpw/tUrDA579lo8vMeRo716LEEMQ8eRpLw2LHEOA8dRgb4ZuFfCWoSMU3A47ZjpU+56TDJTz/f1hfPCxmW0KfxP9o5NCrpsP+DIiE4/I73BHhyV+0UlIQf0/N1lqq9x7Sex5AiKbOw/r15V53UZ5fY9BNeRJ6mZqZzRTWzmcW3nP1UVI++cZIl0uuQ5OhoL/XNH//+16+//cYYtuvO9Cf1rNbmoZPs/s34hSybXYpNoW3fNrXxr8KUxqf1RrevXYLmj0HpWoVsp6p/EqV5XZ/Pqs2VI+vmT6I0XQ9DjUkav4hSfFuUvWq3RTn9VZSS4T+1PwIyJusKItJ4r7oue1T6rUDVvq3bx7rv1wNG2zfBRlEoTjjFP9WnYdG5ei76bPIh4ih8ccIpBs+esaoqpBxc4SPVv1e5fk4AVt+Ej1S/u9yfi75Xp7f18gAnSkLETUj1f+rLkvqPWfedUpX0g8mSO5Zd+rllyR3EHgubmE6ME60/JbC1984w4SrzswjTAR8gm+4YIQSObsf4RZTiaKaKdnOT/pio/aM8XecQxvhFlOJN1vZFVn6vVLNJ0fhFnOKLoyyXvwtTG/xqnektv8hS9KwgTqnav4pSnu/idhSm+ZMozTuVtfmTtdo/prj+EJCeI+PrD7L06rZ30U1/lqW18am3rvaa0nUEEWlYZ2cdxbD7XZS6HpsNLfF9/aw2t5uP6TtCiBT+vdnP6caUjV/IFP9kTF7Gq6GMRYbhMYP7Us9e5t/wxM5FRadoBhAluxyl8Ka7hhAnTKaJJzcvezuTW37Ek1ufgnenaPwOJ3oxtrSNtC79E5rEdxd9W8d8NtpFtgkhS9ifoDAhy1CQpLuQuNALUSuNX0UJetOCk7nO2t6RiP4znsTgVOlimX8SJKVdIAvnp11/hJNTrbOFDX+HExm2AS6bO96MxMzf8UTn9wKdfOuvcILLRS7OBNdf0QTtbZMpe6603QFhmaIbrmxxpjz/hib2Znw876XKn9q6Kv7L98mc4WAR7ZYyZtYFbf6MJrksF+nvpPc3s9KVtCsYKjEYl2Es4UrZ+BVN8N25UW1XV0PZ+YvDFQyWqPJWnYejJc6kjZ/xJO2lQXe6mzB44tM5GCMFt4AjnFhk9Fkm05+CoElTHbW4ix6dFpxJjb+gCb1XjjTew8NWa/7vwrEDoMnqp33ena7rqlK5sxbZAeBkdRu8Vf2lddYc82dRkt7EZMnwptUVDJWYJuku1vknOCk9M7/Ln9TJMyS2A+DJDj6B13U5PdTnTnobSJj82yxX7lIwfxcmSqQnTYqvBe6AAplzvbkrz4O/DycWIVOGk7tT+aUt+pebtn4o3FVuGwRPuixVy83xHKFggWlV1Jns/BucmHVG2UhI/12QiHkboCc9KwictPsuRqeEJ2iQlKdfDZ5QmhG5hAWJjhdFUCszuzDSxKlExYmRiz37QCHJcynDiQ7XVLhSG3+AkzFXHZ3JWQHQZMmSlJfguPP8UHsS0z9JkvJBwTzTWR1XOvNPaFLD4ZYid7aO5TdXYv/x1atiOBbzj//76lm1ne48//Hqmz/86Q9/f/XVq4dClafu1T9+fzUfN9PnN4YjGKc6vwz//I8p2K8qH2ZF//h9DP1vf3z11e9//Oqv3/7h67//6T/+46vf58jDD8Mf5jTWvwwRv3711e9ff/XXP/7hj3/71or49S7i11bEb1599fs3X/3pr3/429//YkX8ZhfxGyvin1599fufvvrzH//wlz9/bUX80y7in6yIf3711e9//upPf//DH//2Zyvin3cR/2xF/PbVV79/+9W33/zh2z/aqN/uIn5rRfzLq69+/4tL8S+7iH+xIv711Ve//9WVx7/uIv7Vivi3V1/9/revvv36DxvBv+3i/c2K9/dXX/3+d036529twb/vIv7d/v66Onz9Rx31L7bk1/uq8/Wm7gyV52sH7teO2mNXn691pfj6G2fN29egr+0q9PX/z9e95caxw0AA3dBFMHxL+9/YhUUZ8FQX+3eEMIld0w8dUbIpfPIMkXynSHzKnzxzJN9BkpgiKM8oyXeWZAyTPNMk33GSMU/yDJR8J0rWFA15hkq+UyV7DMczV/IdLD3BMvYL1mey9DtZKuPV5ZkshQuTTr9gJZem72CpTb9gfQZLv4OlP1kR/y/zX+n3n30GS7+DpTGFQ5/B0u9gaU7h0Gew9DtY+pMVCfZvfgZLv4OlY7D0GSz9DpaOwdJnsPQ7WHaCleTfbM9c2Xeu7FyxioXSnsGy72DZeMuzZ7AMbnrzXY/c9r6DZeONz57Bsu9g2RgsewbLvoNlY7DsGSz7DpbVFA57Bsu+g2U/WZHFfsHPYNl3sGwMlj2DZd/B8hOsTf5efwbLv4Pl54L1YcHyZ7D8O1g+BsufwfLvYPkYLH8Gy+GB6icrKuyx0ckz1XeyfLwX+jNZ/p0s/wmLKv2Ln9Hy72j5T1rU6B9+Zsu/s+U/cVGnf/gZLv8Ol+/py+TPcPl3uOInLxrsL45nuuI7XSHTNzGe4YrvcIUOj5TxzFZ8ZyvOY1bSf/MzXPEdrvDpChDPbAU8sP/ERYv+xeSZ/TtckdMlIJ7Ziu9sRU1PtPGMVnxHK060FrsExDNa8R2t2NMlIJ7Riu9o5We6BOQzWfmdrJTpW5zPZOV3slLH16NntPI7WmlTovOZrPxOVo7Jymey8jtZGVM48hmshLfBc9Xa7Bec5IXwO1n5ExajN4h8Riu/o5U/YTF6oc5ntPI7WvmTFqMX23xmK7+zVSdb9GJbz3DVd7jqJy9GL7b1TFd9p6vOYzy9YNYzXvUdrzp3xWQ/7Xrmq77zVT59F+uZr/rOV8X0Xaxnvuo7X5XTd7Ge8SqYcDjxog+2ReYcvuNVa/wPP9NV3+mqPf6Hn+Gq73Ctz/QfXs9sre9sLZkmddYzWus7WutEa/2X/k8/9f2Hn9Fa39FaNl311jNZ6ztZy6er3noma30na8U0NfQM1voO1vrJim36/30ma30na41P8usZrAWzWWu62i4yofUdrLWnW/F6Bmt9B2ufYH3Yf3g/k7W/k7XPLZHOie5ntPZ3tPb4KL+fydrfydrjo/x+Jmt/J2uP74j7maz9nax9nuTpVNx+Zmt/Z2vn+B9+Rmt/R2vX+B9+Rmt/R2uv8T/8jNaGydLxOX6T6VKcL/2Mc3EfNmMKU6YfGafjPmTS9AOzph+dp2vJtOkH5k0/Z36LTsr1GP55mDv9jLfGHsI/DtOnn/Hu2EP4x2EG9TPeIHsI/zhMon5qnIH9kGnUD8yjftb8iyczqR+YSv385Mid/+jJbOoHcnfm3nlw2Ez9Y6pexuDQyXrI3ZmA96D/ejZfjxP2ZxLe6QOZsDl7nLQ/E/FOn2+EzdvjxP2ZjOfBZVP3OHd/5uOdvtsJm77H+fszJ++bPcwKm8LHOfwzLx8U+IRN4+M8/pmbD/oCIWwqH+by5UzPB32HEDKbLzCdLzq+ZgqZ0BeY0ZczSx/0LUTIpL7ArL6cmfqgLyJCJvYFZvblzNYHfRcRMrkvMLsvZ8Y+6ESKkAl+gRl+ObP2QedDhEzyC8zyy5m5Dx5fMtEvMNMvZ/aeXznJXL/AZL+cCfzg6Sfz/QIT/nIm8ZOnn8z5C0z6y5nHT55+Mu0vMO8vZy4/uVWSqX+BuX858/nJ40um/wXm/+XM6SePLyEAAQOQRgCmPEIUQIAB5Ezt8zsPgQABCZAzu5/80k8wQEAD5MzwJ7/0ExAQEAE5s/y5+E+PpA9UQM5Mf/L0EhgQkAE5k/31YT99QgMCNiBnvr/4Eg3CAwI+IGfOn9/4iRAIEIGcWf/iV36CBAJKIGfmv/gTJ4ECASmQM/lfPPvECgSwQM78f/EHF8IFAl4ghwCKaaMQMBAQAzkKUEX/OMkeoIEcByhGYULUQIANpN2AzlgKkQMBOpAY32aF6IEAH0iML7RC/EAAECTGd1ohhCBgCBLjsh8hiCCgCHJkYNEJWyGQICAJcnSATzIJwQQBTZCY77mEEwQ8QY4R8LcVIgoCpCCHCdhskxBTEEAFOVCw+DWLuIIALMjBAj5hJcQWBHBBDhjwOxbhBQFfkGMG/JJJhEGAGKSNgS6LIsggoAxy4GDxpw3iDALQIMcO+OSXEGoQsAY5fLD4FZtogwA3SI6UJcQbBMBBatQsIeIgQA5S85sGMQcBdJDjCPyiQdRBgB3kSMJw0SDwICAPcjRhuGgQfBDQB6lxuYcQfxAACKlxxYcQghAwCDmsQC8axCAEEEIOLAwXDeIQAhAhLRH8okEsQgAjZM0TLIQjBDxC1jzBQkRCgCTkKAO/aBCTEEAJOdAwXDSISwjAhBxsGC4axCYEcEJaJ/jsFgEKAaGQNU4jCyEKAaOQ4w6Lv6ATphBwCjn2sPg7CqEKAauQNc4oC9EKAa6QIxCLv98TsBAQCzkIsfj7PTELAbSQWS2EsIWAW8gMF0LkQoAuZLYLIXghoBey5+c8whcCfiF7XpdLBEOAMGTPS3MJYggohuxpwbcQxhBwDNnjsm8hkiFAGfoZ134roQwFytDPuPxbCWUoUIYem1j05USJZShYhn7GReBKKEOBMvQzrgNXQhkKlKGfcfmbEspQoAw9NkFDq4QyFChDZ8pQQhkKlKEzZSihDAXK0EMTLLRKIEMBMnSGDCWQoQAZOkOGEshQgAyV8T6rxDEUHEOPS2z6gKfEMRQcQ2UENCWMocAYKiOgKWEMBcZQGQFNiWIoKIbKnDqCGAqIoTKnjhiGgmGojBc7JYSh2I6g88WO9SNgQ8IhiU2fTpX1JDyaEuZ+KdqWALnT8RarrDMBWxN0vMUqa07A7gQdb7HK+hOwQUHHW6yyFgXsUdDxFqusSwHbFHS6xSrrU8BGBZ1Tx1oVgC7U5tQRuVCQC7X5FkvgQgEu9EDEpm8FSuBCAS7U5lsscQsFt9DjEJu6hxK3UHALPRCx6dyvErhQgAttuKBvBUrkQkEutJsYKNspkQsFudAjEZs+1iuRCwW50CMRm8qFErlQkAs9ErGpXCiRCwW5UO9bLYU3JXahYBfqvVqFypsSvFDAC714QflBCV8o8IV6T+XxDBK/UPAL9V4wzENIAEMBMNR7OTpPIREMBcHQIxLy4TEkhKFAGOq9Co/nkCCGAmKod1MNDyJhDAXG0OirIE8igQwFyNDo6yBPIpEMBcnQ6Mc+nkRiGQqWoQcnRHgSiWYoaIYenhDhSSSeoeAZGj2tzJNIRENBNLQbI4QnkZCGAmno7Y7gSSSmoWAaepBChCeRqIaCamj0olCeROIaCq6hRypEeBIJbSjQhh6qEOVJJLahYBua3fjMk0hwQwE39GiF8O4pJbyhwBvavME7qJQAhwJwaAMH76JSQhwKxKGHLIR3QykxDgXj0GMWwluTlCCHAnLoQQvhLUZKlENBOfSwhShPInEOBefQAxfC20mUSIeCdOihC+EtJUqsQ8E69OCFGH+nIdqhoB169EKMP18S7lDgDj18IcabxIl3KHiHHsAQo/POSsRDQTz0EIYYXR+gxDwUzEOPYghvNVHCHgrsoYcxhLduKHEPBffQ4xhidPZXCXwowIceyeBP+QQ+FOBD1yhuSuBDAT50jV1kSuBDAT50jdSrxD0U3EPXSL1K2EOBPfQwBl2foUQ9FNRDV6ePXwOIeyi4hx7HGH51JHvAHtr9Gc5vZsQ9FNxDu0nD+c2MyIeCfOiRDHF+MyP0oUAfeihDnN/MiH0o2IcezBC+MFuJfijoh+75JZnoh4J+6O5tI/gViPiHgn/oAQ3ha6uVCIiCgOjcwqFEQBQEROcuDiUCoiAgOjdyKCEQBQLRuZdDCYEoEIjN3RxGCMSAQGzu5jBCIAYEYnM3hxEBMRAQO6QhfFW8EQMxMBCb2zmMGIiBgdjczmHEQAwMxOZ2DiMGYmAgNhuIEQMxMBCbDcSIgRgYiH3GeUEjCGKAIDZvu2QEQQwQxBpBeEOCEQYxYBCTeS8TwiAGDGLdzjH89SR4wCA2b8JkhEEMGMTmfZiMMIgBg9hxDb4c3oiDGDiIzQ5ixEEMHMSk77r0HdSIhBhIiMm4ts+IhBhIiOkIcEYkxEBCTEeAMwIhBhBiRzb4gmAjEmIgIXZoQ4K+9hixEAMLMZ0vesRCDCzEdM4esRADC7HZQoxYiIGFmM776hALMbAQ07Eh1wiGGGCI9bZNQd8YjXCI4dZNNr5qGNu8CXdvOr4x7KJEoof7Nx3eEN7GZGwPp8cmTuP2YEa3cYLkHd+gjGZsJyfcyunwhvA2KGPbOeF+Tsc3hPdBGdvTCTd1svnCx7Z1wn2demOnYI0oxrZ2wr2dbL7usd2dgEPMpzXNRjDEAEOsMYQ3cRnBEAMMscYQ3sVlBEMMMMR8fNU1QiEGFGJNIcNtj1CIAYWYj3unGIEQAwixhhBmmUYYxIBBrBkk6LuyEQYxYBBrBuFtZEYYxIBBrBkk5T9f/yILCpAAAoNYzFc/giAGCGIxX/0IgRgQiB3R4BcvAiAGAGIx7nthhD8M+MNi3PrCCH4Y4Ic1fiS/dBP8MMAPi7GJzQh9GNCHHcmgTVxG4MMAPizm+y5hDwP2sG7moFseEvQwQA9r9Ehjf56Yh4F5WI67cRoRDwPxsBw35DTiHQbeYTnfdIl2GGiH5XzTJdZhYB2W8waKRDoMpMPyZQ9FtokixC6nFfVGkMMAOSzHHTqNEIcBcVjOeykS4DAADmvgoNd7whsGvGHNG0nn5YzwhgFvWPNGUmQywhsGvGE1TuwZwQ0D3LDGjeQPDAQ3DHDDGjeSPzAQ3DDADWvc4K2vRnDDADescYP3vhrBDQPcsMaN4vdcghsGuGGNG0UnmI3ghgFu2NEK4Q2sRnjDgDes+zqKP3UT4DAADuvODt7CaoQ4DIjDjllI8SAT5DBADmvkKJ5EwhwGzGHHLaR4Egl0GECHNXQUTyKBDgPosCMXUjyJhDoMqMOaOhZPIqEOA+qwpo7Fk0iow4A6rKlj8SQS6jCgDmvqWDyJhDoMqMOaOhZPIqEOA+qwPT8DEuowoA5r6uBtOkaow4A6rKlj8SAT6jCgDjt2IbzTxgh2GGCHHb2QxYNMuMOAO2x3DnmQCXgYgIcdwZDNg0zIw4A8vLs+Nt/2l6CHA3p4931svn0vYQ8H9vBmD74w1Al8OMCHN3zwlaFO4MMBPvxIhvCloU7ow4E+/FiG8LWhTvDDAT/8aIbwxaFO+MOBP/x4hvDVoU4AxAFA/DPPxjgREAcB8U8HkSbZiYE4GIgf1FC+vNSJgjgoiB/U4HLrBEEcEMQbQfjyVCcM4sAg3udQ8OWpThzEwUG820H48lQnEuIgId77WvHlqU4sxMFC/NiG8uWpTjDEAUP86Iby5alOOMSBQ/zohvLlqU44xIFD/PiG8uWpTkDEAURcO4g8yYREHEjE+7gKvjzVCYo4oIh3dwhfnupERRxUxA9yKF+e6kRFHFTED3PQPYKcqIiDivhhDuWrW524iIOL+IEOFf5lJjLiICN+qEOFrqNwYiMONuIHO5SvbnWiIw464gc7lK9udaIjDjrirSN8dasTH3HwEbfOIQ8yERIHIfE+4oKvbnUiJA5C4t0xolSInBiJg5G4jZt7OzESByPxQx46HC1AjMTBSNz6aAIeZGIkDkbiBz10OGKAKImDkvhRD+WLY50wiQOT+HEP5YtjnUCJ4zkYhz6UL451dhYGHobRp2HwxbHOzsPAAzH6RAzlQWaHYuCpGAc/1HiQ2ckYj6Mxzp2Z77nu9HQMSOKsJc4OyMATMvqIDL5tu7NDMvCUjHtMBg8yOygDT8roozL49u3ODsvA0zIOfyjfwt3ZiRngJd5eYjzIREwcxMQPgajxIBMzcTAT7w2wjAeZqImDmngfocFXeDpxEwc38RhXKzhxEwc38RiXaDlREwc18RiXaDlREwc18cMgdO7diZo4qInPW2A5URMHNfF5CywnauKgJj5ugeXETBzMxNtM+NJaJ2rioCZ+GITfCImaOKiJ57jtnxM1cVAT7x4RNnnvRE0c1MQPgyhfF+zETRzcxPusDb4puRM5cZATz3FltBM6caAT7xM3aHYInTjQiR8L4d8bQicOdOLHQnjwCZ040InXeFyQEzhxgBOvOXmETRzYxGtOHmETBzbxPn2D71HuhE0c2MSrs8ffJAibOLCJ17ge2gmaOKCJHwNRvqDbCZo4oIn3cRx8QbcTNHFAE5/P5HBCJg5k4t0PwpcVOyETBzLxuSPECZg4gIkf/1C+utQJmDiAic9HdDjhEgcu8fmUDidY4oAlvjp//JZPsMQBS7z3wuIrHJ1giQOW+HxkhxMqcaASn0/tcAIlDlDia9zy1AmTODCJH/VQvsbQCZM4MIn3+R3820OUxEFJ/KDHkH6CJA5I4t0PMlx/CJM4MInv+ZGPIIkDkviOl+sPQRIHJPHuB5l+giR/gCQ+d4Q4IRIHIvG9Xq4/hEgciMT3fPclQOIAJPHpBNJXryBAEgAkcbyDXn+C8EgAj8TRDn7aH8GRAByJ3heLX3+C4EgAjkR3hfDrTxAcCcCRONbB90sPYiMBNhKHOuhcZBAZCZCR+NQ8lRhERgJkJD7jupkgMBIAI3Gcg294HsRFAlwkDnPwDc+DsEgAi4SMG44HUZEAFQmZNxwPgiIBKBKNInyZchAUCUCRaBThy5SDoEgAioSMUy9BSCSAROIIB98yPIiIBIhI9GndbLVeEA8J8JBoD+GnTQTxkAAPifYQvlI5iIcEeEgc3qB38CAaEqAhcXCDNsUGsZAAC4m2kOD5JxYSYCGh47qtIBISICEx75UVREICJCTmo7yDOEiAg4SO61SDKEiAgkQf6E2jTwwkwECiDYSvEQ9iIAEGEjpu/hxEQAIEJGzc/DmIfwT4R7R/8JNGgvhHgH+EjWukg+hHgH5E6wdfYh5EPwL0I/qkD/73k+yBfsTBDP7kQOwjwD5iPugjiHwEyEe0fCS/cxD5CJCPaPmg4SHuEeAeYeNrbxD1CFCPOIjBf/fEPALMI9o8+Ar1IOYRYB7h40YIQcQjQDziAAb/3RPvCPCO8NHdgmhHgHbErB1BtCNAO6K1gx+RE0Q7ArQjWjv4auEg2hGgHeFz9oh1BFhHzEeDB5GOwMPBY2xDD3Y6OB4P3s7BlzoHOyIczwhv5xieWdlB4XhSeMz3XHZUOJ4VHmM/cLDTwh/HhY89mUHPC4f0xdiTGezIcDwzPMb9KYOdGo7Hhsf8tsHODceDw2NcpR/s6HBQjjhuoVn/+f4Xjuelk+wBdMTcHBKEOQKYI+bmkCDMEcAcMTeHBGGOAOaIuTkkCHMEMEc0c/AF9kGYI4A5IufkEeQIQI7obbDoEr4gyhGgHJHjHghBlCNAOSKnfaCDIEcAckR95gU7QZgjgDmi+qrHn/YIdARAR5TOi1WCUEcAdUSNHZlBqCOAOqJeOjKDUEcAdURTB2+vCEIdAdQR3SFCLx6EOgKoI7o/hClhEOgIgI5o6ODNHUGgIwA6ortDeE9oEOoIoI5o6ig+VUWoI4A6Ys1XP0IdAdQRa37fINARAB0xQ0cQ6AiAjljzMx+BjgDoiDU/8xHmCGCOaObgjTVBmCOAOaI3vyr+zEegIwA6Ys3PfAQ6AqAj1jjNHAQ6AqAj9oi8QZgjgDlij1sPBVGOAOWIPW49FAQ5ApAjGjmGSTKCHAHIETNyBEGOAOSIPa5rCUIcAcQRe1zXEgQ4AoAj9riuJQhwBABH7HFdSxDeCOCN2OO6liC8EcAb+ZnWtSSxjQTbyIMVynvJkuhGgm7kZ1xdkEQ3EnQjP+PqgiS2kWAb+RnXtSSRjQTZyE/fcOncZBLaSKCN/IxrC5LQRgJt5GeUtSSwkQAb+Rn3WksCGwmwkQcqaOyTuEaCa6SMF7wkrJHAGinjqpYkrJHAGnmYgsaeoEYCaqSMT3pJSCOBNFLGbSaTgEYCaGSDBk0tAY0E0Mju8Sj6nJlENBJEI2VcTJVENBJEI2VcTJXEMxI8I2W8zybRjATNSJ1jRzQjQTNS59gRzUjQjNT5ckcsI8EyUufLHbGMBMvI3uuKnwCbRDMSNCO7r4P+5olmJGhGHp7gv3miGQmakYcn+G+eaEaCZmRrBl9IlEQzEjQjdZzVS6IZCZqR3c/Be46TeEaCZ6TN2SOakaAZ2d0cvGU5iWckeEbafNUjmpGgGWnzVY9oRoJmZPdy8IbpJJ6R4BnZvRy8YTqJaCSIRrZo8IbpJKKRIBrZorHiv/z8C/zzJIBAGmkjpyUhjQTSSB85LQlpJJBGNmnwduskpJFAGunj620S0kggjewmDt6tnQQ1ElAjj1Lw41STqEaCaqSPlptENRJUI1s1eLN4EtVIUI30cWY5iWkkmEa2afBe8ySqkaAaeZiCH6mahDUSWCNj3GkyCWsksEY2a/BW9ySskcAaGeNLbhLUSECNbNTgnfJJWCOBNbJPMKenqiZxjQTXyAMVyg9wSiIbCbKRMb9uENlIkI2M+XWDyEaCbGTMrxtENhJkI2N+3SCykSAbmfNzH3GNBNfInO+9xDUSXCNzfN0grJHAGjkfYJ6ENRJYI+cDzJOwRgJr5HyAeRLUSECN7N6NTVfwJ2GNBNbIuXcjiWokqEbmHDuiGgmqkTk/9BHWSGCNrPmaR1AjATWyxt11k5BGAmlkk8amc6JJSCOBNHLe9CoJaSSQRtYIuUlAIwE0skbITcIZCZyRNXJaEs5I4Iys+XZLOCOBM7JGyE2CGQmYkTVCbhLKSKCMbMrYdEY2CWUkUEbOlJGEMhIoI9cIuUkoI4Eyco2Qm4QyEigj17hwKgllJFBGrnHhVBLKSKCMXOPCqSSQkQAZucZFe0kYI4Exshlj08UbSSAjATJyzW8ZBDISICP3/JZBICMBMnKP3UJJICMBMnKPy6aSQEYCZOQel00lYYwExsg9EloSxkhgjNwjoSVhjATGyO7U2Hw6mkBGAmTknu+0BDISICP3PLFHICMBMnLu00gCGQmQUd2nwXdAKmIZBZZRc59GEckokIya+zSKSEaBZFT3afD9k4pYRoFl1GfMXhHLKLCM+ozZKyIZBZJRhyaM795UxDIKLKPaMj509UURzSjQjPqMfFtEMwo0oz7jctEimlGgGSXjctEimlGgGXVP8CArd4poRoFmlIxXvSKcUcAZJeNVrwhnFHBGNWewZUdFOKOAM+r4BA8u4YwCzigZF60UwYwCzCjpTU3pP56kDjCjGjM+9J28CGcUcEbJeLctwhkFnFE63m2LcEYBZ5SOd9sinFHAGaVz7ghnFHBG6Zw7whkFnFE6X/EIZhRgRmlvH8l+8wQzCjCjdM4dwYwCzKhuzdj0bye5A8wo7dzRt+oimFGAGXV0wj701bAIZxRwRnVzBt8qrghnFHBG9fEdfKu4IqBRABp1fML4VnFFQKMANOoIhfGt4oqQRgFp1DEK41vFFUGNAtSoYxTGt4orghoFqFHHKIxvFVcENQpQo45RGN8qrghqFKBGHaQwvtdbEdUoUI3qRg1+knER1yhwjWrX4CcZF5GNAtmoAxXG93orIhsFslGHKozv9VbENgpsow5VGN/rrYhtFNhGtW3wvd6K4EYBbtTRClPa5luENwp4o3ycXC6CGwW4UT5OLhfBjQLcKB9n+YrQRgFt1NywUUQ2CmSj5oaNIrJRIBsV4+K9Iq5R4Bo1u0YR1yhwjTpMYXzdcxHXKHCNmjelKsIaBaxR86ZURVCjADVq3pSqCGoUoEb1Keb0yZugRgFq1LwpVRHUKECNmjelKoIaBahRfZQHffImqFGAGpVz7ghqFKBG5Zw7ohoFqlG9JxV98iaqUaAadZjClD95E9cocI3KcTFLEdcocI3qU8v5xhpFXKPANepAhSl/hCOyUSAblfMbL5GNAtmonN94iWwUyEbV/MZLZKNANqrm2RYiGwWyUaUvj69ENgpko2p+9yCyUSAb1bLB9/UsYhsFtlHV91v+0EJ0o0A3qsZZ5iK6UaAb1c0a9O2H6EaBblSNuwIV0Y0C3ajWDfr2Q3SjQDfqYIUpneMuohsFulGzbhTRjQLdqFk3iuhGgW7UrBtFdKNAN2rWjSK6UaAbNetGEd0o0I2adaOIbhToRs26UUQ3CnSjDlaY0jnuIrpRoBs160YR3SjQjdrzVY/oRoFu1B6XERTRjQLdqMMVxnfSLeIbBb5Ru5/16ArQIsJRIBx1yMKMbSdThDgKiKO6U8Pkv9R/+MdJ+IA46oiFmdK/nqQPhKN6Lyq+DW4R4ygwjmrjMP8v6t/yggIkf6AcddjCLNgqoCLOUeAc67CF8W1wF3GOBc6xDlyY1X/h/5Y6FHimcIF0rEMXxrfBXcQ6FljHOnRhtv+L/FcWUOCZwgXWsQ5emNOX1UW0Y4F2rD6rfPoZPIO4wDtWewff0nQR71jgHau9w/VnWY0K/gueSVzgHasP7ODnTy4iHgvEY7V4uP30en8c/wXPJC4wj3UQw9z/i/hXBgWIeixQjyUyd5sv4h4L3GMdyDCnD1GLyMcC+ViHMqbfArGPBfax2j6G3wLRjwX6sQ5nTL8F4h8L/GNJvv0WSBJBQFa3c0y/BZJEMJDVBuL8ikQMZIGBLNlvvwWSRFCQdVhj+i0QB1ngIOvAxvRbIBKyQEKW6stvgVjIAgtZvU3V8FsgGrJAQ5b2NZHOQS7iIQs8ZGm8/BaIiCwQkdUiMv0WSBLBRJbW22+BJBFUZLWKTL8FkkRQkdUbVk2/BZJEUJHVKuL83khUZIGKrFaR4bdAVGSBiqw+1nz4LRAVWaAiq1Vk+C0QFVmgIqtVZPgtEBVZoCKrWz2G3wJRkQUqslpFnM6GL6IiC1Rk2dvdmajIAhVZ9nZ3JiqyQEWWvd2diYosUJHlb3dnoiILVGT5292ZqMgCFVmtIkFxaxEVWaAiy9/uzkRFFqjI8re7M1GRBSqy/O3uTFRkgYosf7s7ExdZ4CLL3+7OREYWyMg61GHBn1SJjSywkeVvd2eiIwt0ZMXb3Zn4yAIfWfF2dyZCskBIVrzdnYmRLDCSFW93Z2IkC4xk9ZZWfBfhRZRkgZKsVpKgs8WLOMkCJ1kHPiyYdCwCJQugZHX3R8R/Yf/2FihAgghUsqKDyB8TCZYswJJ19GP8EZAgApes4x/Dj4B4yQIvWQdAph8BEZMFYrJ6e6vgz2jETBaYybpmwr9KRE0WqMk6CDIFmajJAjVZ2TlkE8eLsMkCNlnZMeS3ZsImC9hkNZvwXTUXYZMFbLL6MI/kF0QCJwvgZDWc8L0dF6GTBXSyjoUY399wETxZgCer5GX+g/DJAj5ZzSdJ+WIRPlnAJ+t4iPE9BhcBlAWAshpQ+HnoiwDKAkBZDSj8PPRFAGUBoKwjIsa3a1uEUBYQyqpOIo8yQZQFiLKOihjfsGsRRlnAKKuP9uBbZi0CKQsgZTWk8PPQF4GUBZCyjowY37ZpEUpZQCmrKYWfh74IpizAlHV0xPh56ItwygJOWcdHjO9hswioLACVdYTE+Hnoi5DKAlJZx0iMn4e+CKosQJV1lMT4eeiLsMoCVlnNKnxvgkVYZQGrrOMkxjcXWARWFsDK6rYR3t6/CK0soJV1rMR4e/8iuLIAV1bjyqKkvAiuLMCV1biy6IqARXBlAa6sxpVFWXMRXVmgK6t1ZVEdW8RXFvjKal9ZdI+MRYBlAbCsBpZFgWkRYFkALKuBZfNbGwGWBcCyGlg2Xc60CLAsAJbdwMLbrDcBlg3AshtYeMfrJsCyAVh2Awtv29wEWDYAy25g4d1/mwDLBmDZDSy8iWwTYNkALLuBhfcibQIsG4BlN7BsmsRNgGUDsOwGlk2TuAmwbACW3dtjfWgSNwGWDcCyj5c4b2nZBFg2AMvuphLeXLAJsGwAlt1HovNV4psAywZg2cdLnC+z2QRYNgDLPl7iH55EAiwbgGVLb5rAk0iAZQOw7OMl/uFJJMCyAVj28RL/8CQSYNkALPt4iX94EgmwbACWfbzEhSeRAMsGYNm9Z5bwJBJg2QAs+3iJC08iAZYNwLK70UR4EgmwbACWfbzE+TE+mwDLBmDZx0ucbzC8CbBsAJbdJ4EITyIBlg3Aso+XuPAkEmDZACz7eIkLTyIBlg3AsnsHLeFJJMCyAVj28RLnq8Q3AZYNwLKPlzhfbLwJsGwAln28xPmyz02AZQOw7OMlzpddbgIsG4Bl96kgypNIgGUDsOzjJa48iQRYNgDLPl7ifPnbJsCyAVj28RLnq6g2AZYNwLKPl7jyJBJg2QAs+3iJ84VImwDLBmDZx0vceBIJsGwAln28xI0nkQDLBmDZfUKI8SQSYNkALPt4iRtPIgGWDcCye0Mt40kkwLIBWPbxEjeeRAIsG4BlHy9x40kkwLIBWPbxEjeeRAIsG4BlHy9x40kkwLIBWPbxEudncm8CLBuAZXfrCZ+M2wRYNgDLPl7izpNIgGUDsOzjJc6PR94EWDYAyz5e4vyU3U2AZQOw7OMlzk+53ARYNgDLPl7ifDX9JsCyAVh2b67Fj6ncBFg2AMvuU0P4OZObAMsGYNndiML3l9xEWDYIyz5g4vyoxk2EZYOw7N5hix/VuImwbBCWfcDE+WmrmwjLBmHZR0w8eBIJsWwgln3ExLnxbEIsG4hlHzHx4EkkxLKBWHafIRI8iYRYNhDLPmLiwZNIiGUDsexDJs6PvNvEWDYYyz5k4vwkiU2MZYOx7EMmzk9S2MRYNhjL7k23kieRGMsGY9l9ZDo/PWwTY9lgLLvbU/ixo5sYywZj2YdMPHkSibFsMJZ9yMT5IVSbGMsGY9mHTDx5EomxbDCWfcjE+TlOmxjLBmPZvQEXP3x0E2PZYCz7kIknTyIxlg3Gsg+ZePIkEmPZYCz7kIkXTyIxlg3Gsg+ZOD8BdRNj2WAs+5CJ81NFNjGWDcay+wD14kkkxrLBWHafK8KPxtjEWDYYy+6GFX6+wybGssFY9iETL55EYiwbjGUfMnG+1f4mxrLBWPYhE+fGsomxbDCW3cbCeWATY9lgLPsay/BDJEkEY9nXWIYfIkkiGMu+xsJ/iMRYNhjLvsbCv87EWDYYy77Gwr/OxFg2GMtuY+E8sImxbDCW3cbCeWATY9lgLLuNZeABYiwbjGW3sQw8QIxlg7HsNpaBB4ixbDCWfY2FJ5EYywZj2ddYeBKJsWwwFvlcZKFRvKPfJf5++FtDZiK4o48agjV0VoI7+qihWMNmKLijjxqGNXy2gjv6qOFYI2YuuKOPGoE1chaDO/qokVjj3LO5Rt/RR43CGmuGhzv6qLGwxp7t4Y4+amBOL8HQpN9RrCGY06swQ9YJw/z98LeGzghxRx81MKfXYoasE4z5++FvDZ8p4o4+amBOW2S4RtzRRw3MaaMMB4k7+qiBOW2X4SZxRx81MKeXZoacEpv5++FvjT3LxB191MCcXqAZckqE5u+HvzVk9ok7+qiBOb1MM+SUOM3fD39r2KwUd/RRA3PaWMOh4o4+amBO22u4VdzRRw3MaZMN54o7+qiBOW214WJxRx81MKcXboacErn5++FvjT27xR191MCcXr4Zckr85u+HvzVk1os7+qiBOW3E4Que7uijBub0Os6QdQI5fz/8reGzg9zRRw3MaWsOp5A7+qiBOW3Q4RpyRx81MKdtOhxE7uijBub0ss6QdeI6fz/8rbFnFrmjjxqY04s7Q9aJ7vz98LeGzDhyRx81MKeXeIasE+P5++FvDZuJ5I4+amBOL/QMOSXS8/fD3xoxQ8kdfdTAnDb3cCu5o48amNMWH84ld/RRA3N60WfIKVGfvx/+1tgzmtzRRw3M6aWfIafEfv5++FtDZjq5o48amNMLQENOiQD9/fC3hs2AckcfNTCnl4GGnBIH+vvhb42YGeWOPmpgThuDuKTc0UcNzGl7EMeUO/qogTm9JDTklJjQ3w9/a+yZVO7oowbm9MLQkFMiQ38//K0hM6zc0UcNzOnloSGnxIf+fvhbw2ZeuaOPGpjTi0RDTokS/f3wt0bMyHJHHzUwp01FfN32HX3UwJy2FnGruaOPGpjTC0ZD1okY/f3wt8aexeaOPmpgTi8bDVknbvT3w98aMrvNHX3UwJxePBqyTvTo74e/NWzWmzv6qIE5vYQ0ZJ0Y0t8Pf2vEbDh39FEDc9qQxBnnjj5qYE7bkrjk3NFHDczp5aQhp8ST/n74W2PPnnNHHzUwpxeVhpwSVfr74W8NmVXnjj5qYE4vLQ05Jbb098PfGjbbzh191MCcNjDx9pE7+qiBOW1j4h0kd/RRA3PazMTPiLyjjxqY0wNHvmhH0x191MCcHjtyfljjHX3UwJz2ifb8wMU7+qiBOe390vihh3cUa2zMaR8Jww8uvKOPGpjT40jODw+8o48amNNDSc4PALyjjxqY06NJvoecEn/6++FvjZPTPeSUENTfD39rnJzuIadEof5++Fvj5HQPOSUQ9ffD3xonp3vIKbGovx/+1jg53UNOCUf9/bBryMEl56fH3FGoIehRcnDJ+REud/RRQ7DGT+iCn6NyRx81FGv0tvb0ciqMowQ5Srr/h23Td8ceFRwrxPmP8C+LMIwSxCg5shQf/mURhlGCGCVHluLDvyzCMEoQo+TIUnz4l0UYRglilBxZik/QnyiJqCBFyXGl4Ocl3FGsgRQlx5VioChhFCVIUSIdUbYDwB18lMCEHlaKQaKESZSgRMlhpeBHJ9zRRw0M6WGl4Kcn3NFHDQzpYaXgByjc0UcNDKnU24+UZRQhSo4qBT+G4Y4+amBGjyqF+H9e/7IW1mApRYiSo0oh8V/sf5+9oQaDKEGIkqNKIck22byjjxqY0qNKIcW+b4yhBBlKjinFzxbJpAKLKCKUaEd0k/O+7+CjBCb0gFLo5z/Pf16PHwVLKBqUHFAKpRdzJlCCAiWHk0KVbdh5Rx81MKCHk0KN/itYPNGf5GBSqNMKLJyoT3IoKZRehJk9CdqTHEgKTVqBBRPlSQ4jhdZ/lv9cHjVYNFGe5DBSKI0mcydBd5KDSKGbVmDJRHWSPrqG74R7Rx81MJmHkOJnN2Hyr2DJRHOSA0hh8rOlstujBksmmpMcQAqjG1zd0UcNzOYBpDCjX3VGToLkJMePwmi8GTgJgpMcPQqj8WbcJMhNcuwojMabYZMgNsmRozB63WXUJEhNctwobNEfJZMmQWmSw0ZhNN3MmQSdSQ4ahdNkMmUSVCY5ZBQuP1uNl+HNlCmToDLJIaMYpEqYMgkqkxwyikGqhCmToDLJIaMYpEqYMgkqkxwyikGqhCmToDLJIaMYpEqYMgkqkxwyCi+2mdwdfdTAiB4yCqfXX2ZMgsYkEW93AWZMgsYk0RmlKWfCJChMcrgogqac+ZKgL8nBohicS5gvCfqSHCyKwbmE+ZKgL8nBohicS5gvCfqSpLx9Y5kvCfqSHCyKwcqE+ZKgL8nBogg+ryLMlwR9SQ4WxWBlwnxJ0JfkYFHw3eru6KMGZvRgUcQwr8J8SdCXJDulm9+fmS8J+pL0pm986747+qiBOT1YFHznuTv6qIE5PVgUKfTmxnhJkJek5O2VgPGSIC9JvT6EMl4S5CUpe3v0YrwkyEtyrChS+Y+DpRR1SQ4VRfInL4ZLgrgkR4oih0dZhkuCuCRHiiJjqMFCirgkR4oih/dehkuCuCTVIa2hBgsp4pKsz9uFkOGSIC7JkaLgu+vd0UcNTOmRouAb7N3RRw1M6bK3OQ2GS4K4JEeKgu/Td0cfNTCmR4qCb9V3Rx81MKdHioLv1ndHHzUwp0eKgm/Yd0cfNTCnR4qC79l3Rx81MKdHioJv23dHHzUwp0eKgu/cd0exBuKSHCkKvnnfHX3UwJweKQreW3ZHHzUwp0eKYmiaEIZLgrgk29+u6gyXBHFJjhTFsDBWGC4J4pIcKYphUYkwXBLEJTlSFAPoCsMlQVySI0UxgK4wXBLEJTlSFAPoCsMlQVzSI0UxgK4yXFLEJT1SFAPoKsMlRVzSxqUBdJXhkiIu6aGiGEBXmS4p6pIeLIoBdJX5kqIvafvScI9S5kuKvqTtSwMKK/MlRV/S9iXeT3hHHzUKa5ycbv0vPv/gSKg7+CixsMSJ6TZ621cGTIrApA1MgwkrAyZFYNIGJt5aeEcfNTCm8vZwqkyYFIVJ5e3hVJkwKQqTtjANNq1MmBSFSVuYBptWJkyKwqQtTOPPlMUUhUlbmMafKYspEpM2MY0/U5ZTJCbto36GfgdlxKRITKqf8Qy6O4glUJi0z/uhvq3MlxR9SfvAH3oS3R18lMCMNjANaw6UEZMiMWkT096U25QZk6Ix6QGjHNYcKDMmRWPSQ0b5EXas3R191MCMXmXiL7bKlElRmfQq05Bz5kyKzqTtTFPOmTQpSpMeOMqhF1eZNSlak9rbfJQybVLUJj10lMPyB2XapKhNevAoP85/t8ybFL1JDx/lZ3gEYuKkKE5qndPheszESVGc1PL1/8JyiuakB5DyM1zTmTkpmpMeQMrP8N1n5qRoTmpvXK8MnRTRSRudpu8cYydFdtJmp+k7x+BJEZ70wtPwnWP0pEhPeumJO54yfFLEJ218mr5zTJ8U9Um9czo83jJ/UvQnPZyU8uE5ZQKlKFDaAjU8VjKAUgQoPZqUQ6u2MoBSBChtgBqmb5UBlCJA6dGkHBbZKAMoRYDSo0njj5QBlCJA6dGkFDrZqMyfFP1JDyalDE/ZzJ8U/Unj5VyrO/qogSk9nJQyXJGZQCkKlMZrSplBKRqUHlJKGa7qTKEUFUqjY1p0dl+ZQikqlB5SyqFzXZlCKSqUZsd0eLplCqWoUNoKNV3VmUIpKpS2Qg3GqUyhFBVKDyml8qdshlCKCKVHlHJooFeGUIoIpfkGpcoQShGhtBFqurkwhFJEKM03zleGUIoIpUeUUoerGEMoRYTSfON8ZQiliFB6SCl1eChkCqWoUNoKNSwJUKZQigqlrVDDkgBlCqWoUNoKNSwJUKZQigqlrVDT14UxlCJD6UGlHDZYUOZQig6l7VB0WYEyhVJUKK3X13ymUIoKpa1QdFmBMoNSNChtg6LLCpQJlKJA6eqEDjcnJlCKAqUtUMPSBGUCpShQ2gI1LE1QJlCKAqUtUMPSBGUCpShQul4fS5lAKQqUtkANSxOUCZSiQOnhpNThZs0ESlGg9HBSDtt3KBMoRYHS1VfS4WbNBEpRoLQFavrWM4FSFCjdn7dvPRMoRYHSFqhhca0ygVIUKN2vU6ZMoBQFSnff8IeHFyZQigKlh5Ny6D1RJlCKAqX7dWafCZSiQOnhpDQuUMoESlGgdL9ORzGBUhQo3a/TUUygFAVKDyelDU8NTKAUBco+n/lhzhhAGQKUfd6WnRgDKEOAss9bTI0BlCFA2edtZt8YQBkClH3eLqfGAMoQoOxoUhp/iDIGUIYAZZ+OKTuQ9A4+SiSWOFdT43dKY/5k6E92NCl/Vv2yfwYJqaE/2adDWnQe2pg/GfqTHUxKo10wxvjJkJ/sWFL+LPxlJVhGUZ/sUFI6nw03pk+G+mSHknLYpcaYPhnqkx1KymHtrzF9MtQnO5SUTqcrjOGTIT7ZkaQcnvON4ZMhPtkrPhnDJ0N8siNJ6UGnGozhkyE+2ZGkHN4VjOGTIT7ZoaQcNroxpk+G+mTd3zRdwpg/GfqTdX/TMNlpDKAMAcq0Y8qfoowBlCFAmXZM+VODMYAyBChrgBo23DEGUIYAZQ1Qw9O+MYAyBCg7mpTD074xgDIEKGuAmm4tDKAMAcqOJmUMtxYGUIYAZd3qNEwjGQMoQ4Cyo0kZHEuMAZQhQJm9TUUZAyhDgLJud+KLZo35k6E/2e13Gp5emD8Z+pPZ21SUMX8y9Cdrf4rg/xWWUuQna36K5CVYSFGfrPUpavjFspCiPpm9KakxfTLUJzuUlEFbfYzhkyE+mXdGN/+vMHwyxCdrfOKrkI3Zk6E9WdsTX4VsjJ4M6cmOI2V+eAmWUJQn676nYSGzMXkylCfrzqdhIbMxeTKUJ2t5GhYyG6MnQ3qy7n0aFjIboydDerLjSJl8VYIxejKkJ2t6+gkHq8HoyZCeLN4k3xg9GdKTNT3xQ+Pv6KMGprR7n6YrGLMnQ3uy7n2avvfMngztydqe+PHzd/RRA3Pa3U/TDY7Zk6E9WdsTP8X+jj5qYE67A2q6szB7MrQn6w6o8ffCcor2ZN0BNf1emD0Z2pO1PU0PlcyeDO3Jrj0NWWf2ZGhP1vaUfJrRGD4Z4pM1Pg27nxnDJ0N8ssYnLujG7MnQnixzFmNj9GRIT5adUr5WxBg9GdKTNT0Ne7AZoydDerLjSDm0QRijJ0N6snp9LGX0ZEhPdhwph1YKY/RkSE92G6CGby2jJ0N6snq9mjJ6MqQnO46UxSd/jdGTIT1Zd0BN33xGT4b0ZJUvT2LMngztyepNSI3Zk6E92aGkHLpTjOmToT5Z69PwpWX8ZMhP1vxUrBXfGD4Z4pNdfOKLXozhkyE+2dK37yzDJ0N8siNJObTZGMMnQ3yy1RkdrsYMnwzxyVa8rBQxhk+G+GSNT8NvhUUU6cmanqZvG6MnQ3qypqehYcgYPRnSk6398j9hCUV4soan6X/C4MkQnmzLy6oZY/BkCE92FCmH1idj8GQIT9bwVMMrHIMnQ3iyhqf1+fm/qD7+LyyjCE92FCkXWxRujJ0M2cmanYamJWPsZMhOdgwpF+diY+xkyE52DCn5WWV39FEDM9rsNDQtGWMnQ3byZqehacmZOzm6kx9EyqFpyZk7ObqTH0TKoWnJmTs5upMfRMqhacmZOzm6k3/8ZfWxM3dydCdvdxqalpy5k6M7ebvT5u/FzuDJEZ7888ajzuDJEZ7888ajzuTJUZ788zYP5UyeHOXJ5a3h2Rk9OdKTNz0NO3s6sydHe/K2p2FnT2f25GhP3p1Pw5OHM3tytCdvexo6wZzZk6M9edvTsMzDGT454pM3Pg3LPJzhkyM+eePTMAHtDJ8c8cm782lYouEMnxzxyeXtHd8ZPjnikzc+DUs0nOGTIz65yssSDWf45IhPrm/v+M7wyRGfvPFp2D3WGT454pM3Pm0K187sydGevDfYm74uzJ4c7ckPJE2bizizJ0d78ranoVHQmT052pMfSMqhocyZPTnak7c9DZvYOrMnR3vyA0k1NJQ5sydHe/IDSTXsH+vMnhztyQ8k1bB/rDN7crQnP5JUH7ZtoTN6cqQnP45Uw+6xzujJkZ78OFIN7VPO6MmRnvxAUg3tU87sydGe/EhSDa1PzvDJEZ/8SFINRxk6wydHfPIjSTVsIOsMnxzxyW/r03BBZvrkqE/ub5LvTJ8c9cld334ejJ8c+ckPJtWwGa4zf3L0Jz+aVMNmuM4AyhGg/GhSDX06zgDKEaD8aFINO9k6AyhHgPKjSTUcy+gMoBwByo8m1dAg4wygHAHKjybVcCyjM4ByBCg/mlQyfOcYQDkClB9NKhnuDAygHAHKjybV0NziDKAcAcqPJtVwLKMzgHIEKD+aVENXiTOAcgQob4AaVjU5AyhHgPJ4mdl35k+O/uTtT3QeyJk+OeqTv+qTM31y1Cc/lFRDW4ozfXLUJ8/XiynTJ0d98qtP/AfK8MkRn/xIUg2dLc7wyRGfvPFpmBZzhk+O+OT5tsDUGT454pMfSiodnhuYPjnqk7c+DQjmjJ8c+cnzpY3UmT456pMfSqqffZfJczrDJ0d88nzrInWGT4745EeSauhecIZPjvjk9bY3uTN8csQnP5I0LZZ1hk+O+OTVV9LhrsDwyRGfvPGJLz92Zk+O9uTVIR1uLMyeHO3J25748mNn9uRoT141Lx12Rk+O9ORNT3zpsDN5cpQnr/321MHoyZGe/NITnwx3hk+O+OSrdzfZfLqC4ZMjPvnqK+lwt2f45IhPfiSpbHgqZfjkiE/enU8DGDvDJ0d88u58Gs4kcIZPjvjkvffe9L1n/OTIT95779EzCZzhkyM+ee+8R88kcEZPjvTk3fXEzyRwZk+O9uT7bc8IZ/bkaE9+m56YtTiTJ0d58tvyNMzJMXlylCfvTffomQTO3MnRnfxuuUef4Jg6OaqTd7sTPZPAmTo5qpP3dnv0TAJn5uRoTr7fFug7MydHc/Lb6kSjycTJUZy8t9qjZxI48yZHb4reaI+eJxBMmwK1KT5vL/TBtClQm+LztjQ/mDYFalPcLif6LBwMmwKxKbrJiZ4nEIyaAqkpeo89ep5AMGgKhKboHfboeQLBmCmQmaKZiZ4nEAyZApEpGpn4eQLBjCnQmOIaE0tmMGEKFKa4wkSTyXwp0JdC3taQBvOlQF+Kg0U1tEUG86VAXwrpm7rSG2EwXwr0pThYVMMp78F8KdCX4mBRGX89CuZLgb4UB4tqaJ4L5kuBvhQHi2o45T2YLwX6UhwsGna0C8ZLgbwUvbEe3dEuGC4F4lLcbfXojnbBbCnQluJAURl/KQlmS4G2FNoZ5W8UwWwp0JZCXzPKbCnQlkI7oxxCguFSIC7F3VmPe38wXArEpThSVEM/YjBcCsSlOFJUPnzvGS4F4lIcKSof4sEyirYUB4pq2LskmC0F2lL0xnrD0oVgthRoS9G25MOvhdlSoC1F25LTKY1gtBRIS9G0xGdFgtlSoC2Fve34HMyWAm0p2paGrshgthRoS9G25PQuzWQpUJaiZWnoRQwmS38+/K2x5s6oYLAUCEth+6XNNBgsBcJSHCWqoSUyGCwFwlIcJaqhJTIYLAXCUhwlMje68iEYLAXCUvjMn8FYKZCVollpaMwMxkqBrBTNSkNjZjBWCmSlaFYKo982pkqBqhStSkGfqJkpBZpS+NtGZcFMKdCUok0p+GWDkVIgKUX3NA0TkMFIKZCUokkp6KxdMFEKFKVoUQo+Ox1MlAJFKXo7Pd41FwyUAkEpGpRiuPQwUAoEpYhO6PCdZ6AUCEpxeKiSr5EOJkqBohQHiHTR/tJgpBRIStGkNGwlHoyUAkkpmpSGxrtgpBRISnF8qIbGu2CkFEhK8XqkUzBTCjSlaFMaGu+CmVKgKUUf6TRMVgUzpUBTiny91zNTCjSlyLdWkWCmFGhKkTnfEpgoBYpSHB+q5PPkwUgpkJQi3/rsg5lSoClFdkqH1z9mSoGmFG1KyZ85GCkFklIcH6osXoJlFEUpWpTo0vVgnhToSdGelMNFkHlSoCfF0aEazusJBkqBoBTdzDSs7AkGSoGgFIeHamhUCyZKgaIUx4dqaDILRkqBpBS1XhwmmCkFmlK0KdXw6MNMKdCU4gBR1fDexUwp0JTiAFENZ/4EM6VAU4reTY9LcjBSCiSlOD40/kgZKQWSUqy3bUmDkVIgKcV62wsiGCkFklKsjulw+WGkFEhKsTqmnLSDoVIgKsUxoho6moKxUiArxeqYDpcP5kqBrhQHiaZltMFcKdCVYndMh0sQk6VAWYrXzfSCyVKgLMWBohqOUQpmS4G2FIeKajhGKZguBepS7NcbPvOlQF+Kw0U1dDUFE6ZAYYrb1cT7s4IJU6AwxQGj6VbLiCmQmGLvl1stM6ZAY8pDRjUcKpVMmRKVKQ8Z1eITUMmUKVGZ8pBRLb55bjJlSlSm/HRKc/h3kJQmMlN+3h5Lk0FTIjTl5y2lyagpkZry87KzTjJrSrSm/NTLquJk2pSoTXnsqBabCUuGTYnYlMeOatG1LMm0KVGbUjqjw3+EeVOiN+XBo9rUJJJxUyI3ZXPT5hewZNyUyE3Z3DS0VSXjpkRuystNnAOScVMiN2Vz09CalYybErkpm5uGtqpk3JTITXnbmfjzYDJuSuSm7Ham4XDgZN6U6E3Z7UzDmppk4pQoTqlvi0aTkVMiOWWTE/++MXBKBKdscBq+b8ybEr0p25um7xvzpkRvyj7JaVg1kMybEr0pNV6+s4ybErkpNV/eq5NxUyI3ZXPT0NqVjJsSuSn15Uy8ZNyUyE15uYlHgwUUsSl7E71h0WkybErEpmxsGk6RS4ZNidiUjU1Dc1gybUrUpmxtGprDknFTIjdltzINzWHJuCmRm/LY0Rqaw5JxUyI35dGjNTSHJQOnRHDKC07UM5N5U6I3ZXcyDZ6ZDJwSwSkbnAbPTAZOieCUF5yGx0kGTonglA1O3DOTeVOiN2U3MnHPTMZNidyU/ralTjJwSgSnbHAaPDMZOCWCUzY48UsH46ZEbsrmpsEzk3lTojelv+z0mAycEsEp/W3b3GTglAhO2eA0eGYycUoUp+wmpsEzk4lTojjlFSc+b5OMnBLJKS85DY9PjJwSySm7iYlLYjJySiSnvOTEJDEZOCWCU97jm7gkJgOnRHDKBicuicm8KdGbsjuYBklMBk6J4JRHjwZJTOZNid6U7U2DJCbzpkRvyj68iUtiMm5K5KZMeZHEZNyUyE3Z3DRIYjJuSuSmTHuRxGTclMhNeexokMRk2pSoTXm3z+OSmEybErUpW5sGSUzmTYnelNebuCQm86ZEb8pXb0rmTYnelAeP1tCPnsybEr0p25v4nYlxUyI3ZXV3CN8kNpk3JXpTls7XL+ZNid6UB4/WcDBpMm9K9KY8eLSGzvpk3pToTdkNTFO+mDclelNWP44O7zvMmxK9KXv3PL7HdTJuSuSmrLde0GTclMhNWW+7lCTjpkRuyvW2E2kybkrkplwy70eYTJsStSnXy67OybQpUZtyvezqnAybErEpu39p2JI5GTYlYlM2Ng1bMifDpkRsyu5fGrZkToZNidiU3b80bMmcDJsSsSnX63WUYVMiNuXq6+jwSs2wKRGbcr+GlGFTIjblkaP1GZ46GDYlYlMeOVofPvvErCnRmnL3pZS3DCazpkRrygNHS/jMEaOmRGrK40ZLhispo6ZEasrjRmvYPyIZNSVSU76e25SMmhKpKV/PbUpmTYnWlPttY7Jk2JSITdUNTcPVoxg2FWJTdUvTcPUohk2F2FTd0jRcPYphUyE2Vbc0DVePYthUiE31enBTMWwqxKb6dE75k0cxbCrEprp9Tfx3W0ybCrWpDh2t4SDgYtpUqE31ebuaFvOmQm+qo0dLOCQWA6dCcKqjR2s4xLcYOBWCUx0+WsM+J8XEqVCc6vDRdA0qJk6F4lSHj9awV0oxcSoUp5K+nPKXuGLiVChOdfho8TPbioFTITjV0aOlfJ60GDgVglNJvf5XWEwRnOro0fhfYSlFb6qDR0v5O1wxbyr0prpnN9HHuWLcVMhN1Uc3DTeGYuBUCE51+GgNm5QUE6dCcSq1Fy0qJk6F4lSHj9awwUgxcSoUp9KXHfKLiVOhOJV2SPnbUzFxKhSnOnw0QU0xcSoUp9IO6XANY+RUSE7Vu+cNuzcUQ6dCdKojSGvY2aMYOhWiU/XJTcMXjplToTmVva2CKmZOheZUB5DWsDtIMXMqNKd6bXEqZk6F5lRtTsrdqpg5FZpTHUCaks7IqZCc6gDSGrbeLGZOheZUB5CW8UnwYuZUaE51AGkZnwQvZk6F5lQHkJbRSfBi5FRITtWb5w3Tg8XMqdCcqo9umr74DJ0K0amOIE3rDouhUyE61d08b7hLMnQqRKfyt21KirFTITtVs9Ow1KUYOxWyU/nbC1Qxdyp0p+rN84YVbsXcqdCdyt/mooq5U6E7VXRMh3scc6dCd6p42xOimDsVulPF2465xdyp0J3qKNL4tWXwVAhP1ac3DVcxJk+F8lSHkcarGJOnQnmq40jjVYzRUyE9VfTVdHhuYPRUSE/12utUzJ4K7anibWeyYvZUaE+VHdPh2YPhUyE+VcrYA1KMngrpqW6nE+erYvRUSE+VHdLh6YXRUyE91YGkZdO/g6UU7amyUzpckJk9FdpTHUhaPiSd2VOhPdWBJPsBUv+3FNPB7KnQnupA0hra94vZU6E9VdvT+DNlKUV7qvq8/UyZPhXqUx1KGn+mTJ8K9akOJo0/U+ZPhf5U7U/OZxqL+VOhP9XBJPPhJYz5U6E/1cEkSfnP179IvAIxfyr0pzqYNDV6F/OnQn+qo0maZ5v8eNZgOUWAquqcDi+2DKAKAaqOJs0/U5ZTBKg6mjT+TBlAFQJU9R5608+UCVShQNXxpPFnygiqkKBqdU6HBxhmUIUGVes1p8ygCg2q1mtOmUEVGlSt15wygyo0qFqvOWUGVWhQtTqnw5MDM6hCg6r1mlNmUIUGVfs1p8ygCg2q9mtOmUEVGlTt15wyhCpEqGqE8uEJhiFUIULVfs0pU6hChar9mlOmUIUKVfs1p0yhChWq9mtOmUIVKlTtzunwLMUUqlChar/mlClUoUKtz1tOF1OohQq1Pm85XUyhFirU+rzldDGFWqhQ69M55VNSiynUQoVan7ecLqZQCxVqfd5yuphCLVSo9XnL6WIKtVCh1uctp4sp1EKFWp/OKZ9eW0yhFirU6i32+IvpYgi1EKFWI1TwleWLIdRChFp9itPQp7gYQi1EqNUIFUJfKhdDqIUItRqhgj+eLoZQCxFqNULxKbrFDGqhQa02qOBPdIsh1EKEWo1QwZ9gFkOohQi1GqGC37EXQ6iFCLUaoYLfoRZTqIUKteTtarqYQi1UqKWvV1PGUAsZaunr1ZQx1EKGWvp6NWUMtZChlnZM+QqYxRhqIUOtZqgYrsiMoRYy1NLO6XAFYg610KFWdz4N042LOdRCh1oHlQboXIyhFjLUaoZK/oK8GEMtZKh1TGkln15bjKEWMtRqhko+27gYQy1kqHVQaSVvkFnMoRY61DqotIbNYhZzqIUOtdqhki9xWMyhFjrUOqi0hjPJF3OohQ612qGSP9At5lALHWp179OUDwZRCyFqNURN+WAQtRCiVkPUmA+WU4So1RA15oPlFCFqNURN+WAStVCilstbPphELZSo5Z3T4TLGJGqhRK1ufxo2u19MohZK1PLOKT3HYDGIWghRy7u3hM/zLQZRCyFqHVVaxa+EzKEWOtRqhxpOblzMoRY61DqotIpNii+mUAsVarVCOdvXfDGDWmhQK97anBczqIUGtQ4oraLdiosR1EKCWpeg2CbWiwHUQoBaDVDDGpzFAGohQK3DSatsqMHyiQK1WqCKnluyGEAtBKh1NCmC7ce9GD8t5KfV/DTs3rMYPy3kpxWdTt6quBg/LeSndSxpVfEfBgso6tPKz8t8+mL6tFCf1utOe4v500J/WgeT1nCY+GL+tNCfVr5tELWYPy30p9X+xC8aTJ8W6tM6lDT/RFlEUZ9W61MNV2GmTwv1aR1KWsM2RIvp00J9Wq1PwzZEi+nTQn1arU/DFkKL6dNCfVqtT8PGO4vp00J9Wq1Pa3gXZfq0UJ/WoaQ1HIy+mD4t1KfV+jQcjL6YPi3Up1VvC6MW06eF+rQOJa3hcPXF9GmhPq3ufhoOV19Mnxbq06rO6fD+xvRpoT6t1qfhYPTF9GmhPq1DSWvYsWYxfVqoT+tQ0hp2rFlMnxbq01qv01BMnxbq01qv01BMnxbq02p9Gna9WUyfFurTWv52HWP6tFCf1qGktZ2t3F0Mnxbi0zqStIZNSRbDp4X4tI4krWEvj8XwaSE+rcanYS+PxfBpIT6tboDai64UWwyfFuLT2h3TzWswfFqIT6vxabrNMXxaiE/rSNIe9gNZDJ8W4tPqc5x4E9Vi9rTQntaBpD1sKbKYPS20p3UgaZyVY/a00J5Wb7bHtyVZjJ4W0tM6jrSHNuPF6GkhPa3jSPszvJkzelpIT6sboMaEsZQiPe3Py5L9zeRpozztw0j7wycINpOnjfK0Px1SPkGwmTxtlKd9GGl/+GZ7m8nTRnnat/+JvxJvJk8b5WkfRtpD1+Jm8rRRnvZhpD2cWb2ZPG2Up/3pmPJ7/mbytFGe9mGkLXwybDN52ihP+zjSHs693oyeNtLTPo60hU+GbUZPG+lpH0faQ1/aZvS0kZ62vC3a34yeNtLTPo60h760zehpIz3t3nGP7sq2mTxtlKd9GGkPp29vJk8b5WnLy/4mm8HTRnjafbrTsJPGZvC0EZ62dEj5U8Nm8LQRnnZvt/dhR7Ftxk4b2WlrR5Q/d2zGThvZaWtHlD/qb8ZOG9lpH0PaMnztGTttZKd9DGkPx4hvxk4b2WkfQ9pDb9xm7LSRnXZ3Pw2THpux00Z22seQ9nD69mbstJGd9kGkrfxuvZk7bXSnfRBp63CbZO600Z32QaStw22SudNGd9p9wNOHt3Bu5k4b3WmbvDx5bOZOG91pm77drpk7bXSnfRBpvF0zd9roTrv7n/g3n6nTRnXah5D20Ni2mTptVKdt+ZYwpk4b1WkfQpp/KyylqE7bOqXDVYyp00Z12r3l3vByvZk6bVSn3eo0vFxvpk4b1Wm3OvGX2s3QaSM67SNIW/mL4GbotBGdtvfFlL+fb4ZOG9FpNzoNL6SbqdNGddqHkLZ9hhospqhOu9Vpihhjp43stC87DRd1xk4b2WkfRdrDQZubwdNGeNr+GlNGTxvpacdrTBk9baSnHW8xZfS0kZ52vMaU4dNGfNpHkvbQ/bQZPm3Ep30kadvwiM3waSM+7canKepMnzbq0z6YtIeutM38aaM/7YNJe2h/2syfNvrTjvX2lWP+tNGf9tGkPbQubQZQGwFq59tc1GYAtRGg9itAbQZQGwFqH03aQ/PSZgC1EaB2vhn+ZgC1EaB2H/U0dIJuRlAbCWr35nvDgfWbEdRGgtrZOR2e9xlBbSSofTyJH3q/GUBtBKjdW+/RQ+8346eN/LRzz4feb6ZPG/VpH0raw3Gwm+nTRn3aJS+NtZvp00Z92tVv+MwmN7Onjfa0y17OItvMnjba0772xM4A20yeNsrT7nOelO0guJk7bXSnXb1ejz4YM3XaqE6799xTdjr5Zua00Zx2ve0TtZk5bTSnfbfco/Fm4rRRnHZvuKdsZcdm3rTRm/Z62xNyM2/a6E2799sztqRiM23aqE27t9sbGq0306aN2rTX2zb6m2nTRm3avd+e8Ulnpk0btWn3dntG482saaM17d5sz2i8mTRtlKbdW+0ZjTdzpo3OtFdvYUav3UyZNirTvtvs0X0cN0Omjci0d7ff03QzYtpITLsPdHKaTAZMG4FpNzBNDxdMmDYK025hGg7y3kyYNgrTfhWmzYRpozDt40V76CbejJg2EtM+XmTu/0X8K3v8O1g8kZh277E3PfQxYtpITPt40Wg7jJg2EJN+DhgNtnNHv2v8/fC3hsyTRXf0UUOwhs6TRXf0UUOxhs22c0cfNQxr+Gw7d/RRw7HGy/F4d/RRI7BG55ROjN7RR43EGjU5xB17VCissKbTTu/Yo8LCCiejvCv6jj5qYEalV+jRbfzvKNYQzOjBIjqReMceFTCh8rKJyR191MCEti7xfuY7+qiBCRWfp6rv6KMGJrR9iU9V39FHDUzo0aJhqvqOPmpgQuVlUvSOPmpgRhuYpqsPAaa/H/7W2G9XH0JMfz+8NZqYfPiZEmL6++FvjZeUEmD6++FvhfMSzzuR7+ijBqb0aNFwf7ujjxqY0gtMdKLojj5qYEqPFm3eAXxHHzUwpQ1MvOP1jj5qYEq13q4/BJj+fvhb46SUd4ne0UcNTKm+LCm5o48amFL7zO86dxRrGKa099fjx17c0UcNzKnp28+UANPfD39rnKspb3m9o48amNPjRTvo8+AdfdTAnDYx8XbVO/qogTltYuK9pnf0UQNzerxo817TO/qogTltYuK9pnf0UQNz+kZMd/RRA3P6Rkx3FGs45vSFmO7gowTG9I2Y7uijBsa0iYkfOHhHHzUwpm/EdEcfNTCmb8R0Rx81MKZvxHRHHzUwpm/EdEcfNTCmTUwx3BoIMf398LfGa0wJMf398NZ4I6Y7ijUCY/pCTHfwUQJj+kZMd/RRA2PaxMSP77mjjxoY03iNKSGmvx/+1niNKSGmvx/+1niNKSGmvx/+1niNKSGmvx/+1uiYDnd9Qkx/P/yt8RpTQkx/P7w1jhcNG2PeUayRGNPjRTuHuy0hpr8f/tbQmYfu6KMG5rT32KMtnnfwUQJjelucWHvmHXyUwJQ2ME1vDASY/n74WyOnTqs79qiAGW1eYu2Zd+xRAROaL3P4d/RRAxPa/U20PfMOPkpgQI8W0fbMO4YVCuPZzU28PfOOPmpgPLu5ibdn3tFHDYxnNzfR9sw7+CiB8WxfYu2Zd+xRAdPZnU20LfIOPkpgOHtbPd7dcEcfNTCe9XoJJcj098PfGuvt1kaQ6e+HvzX2vOnIHX3UwIQeNRomn+8o1liY0aNGw2KjO/qogRldOq8EuaOPGpjR40Y7h5ceQk1/P/yt4W9PtYSa/n74WyPeHjmINf398LfGeXHiOzHc0UcNzOnBIwvWQXMHHyUwpkePNt/M4Y4+amBMjx9tvpnDHX3UwJgeQNo5vL8Rc/r74W+NvtMPc0hEnf5++FvjxJRv9nFHHzUwprtjOszdEHf6++FvjRPTHJ7AiDv9/fC3xolpDU8+xJ3+fvhb48S0hq8ccae/H/7WOO/3NcwzEHf6++FvjZPTGuYZiDv9/fC3xslpDfMMxJ3+ftg1pN2JbyBwR6GGoDtJu1PxnApzJ0F3ko/OHfN39FFDsYa9PDYIcydBd5LeVW+43QpzJ0F3ku5tKv6dE+ZOgu4kvave+PMgORV0J+mznehzrTB3EnQn6c6mWsNPlKRUUJ7kMNL8EyUpFZQn6c4m3r17R7EGypN0Z9Oi7Rp39FEDU9r2xJez3dFHDUzpgaTc7KDhO/gogSE9jsT7Ee/gowRmVN7em4TJk6A8ieS8kuyOPmpgRluehvceYfIkKE/S8jSIjzB5EpQnOYy0f/atZ78VFlKEJ2l44ttL3FGsgfAk3du02G6Jd/BRAjOqbz4qTJ4E5Um6tYnvUHFHHzUwpOpv3xUmT4LyJIeRpqAzeBKEJ2l44htl3NFHDQypvoaUwZMgPEnDE99s444+amBIu7OJb5RxRx81MKX2eZnWEwZPgvAk9pZS5k6C7iT2mlLmToLuJO1OfM+PO/qogSk9iJRGpwmEsZMgO8kxpDR+QWfqJKhOcghpkjxh6iSoTnIIKY2+PAlDJ0F0kiNIaXRKT5g5CZqTtDkFPXvsjj5qYES92+3pxoB3FGugOckRpHT+OioMnQTRSY4gTVcfZk6C5iS9l9505WDmJGhO4n2350QrzJwEzUl6Mz3nswTCzEnQnOQAUjpf1iXMnATNSdqc+OLaO/qogSn1NS+uvaOPGhjTNifnMx7CzEnQnCQ6psNDKTMnQXOSI0gZw0MpQydBdJIjSBnD14WhkyA6yRGkjOHrwtBJEJ2kT3WaLukMnQTRSY4gVZAVy3fsUQFT2nvqDbQhjJwEyUmOH2XQc8Pu6KMGprTJaU3pYClFcpJ4Ww4ljJwEyUmOH+1NjUWYOAmKk3RTUwq9DjJwEgQnaXCaXhUYOAmCk+TrtZSJk6A4yfGj/NmMgf1XWERRnOTwUUbyEiyjCE5y/CijeL4YOQmSk+TrlZShkyA6Sb5eSRk6CaKTZN/w2dr6O/gogRFtdEqlJZg6CaqTdFNT8ls1QydBdJIjSPmzyQYrwRKK5iTd1MQPSr+jjxqY0EYnflD6HX3UwIh2WxM/KP2OPmpgRruxiR+UfkcfNTCjB5Ey+dJUYe4k6E5yECmTe6IwdxJ0J+nmpunOxNxJ0J1k9XWUTxwLcydBd5Il4/ESd/BRAlN6DKmCv3oxdRJUJzmElFLspNE7+qiBKT2ElDI8czB1ElQn6QYnfmThHX3UwJS2OvFtDu/oowam9BhSCr92MHUSVCc5hDT/SFlIUZ2kz3IK/ibK0EkQnaTRaXP8EoZOgugk3eg03WUZOgmik3Sr03RvYugkiE7y1ux0Rx81MKWNTnuYxmLoJIhOsuPteZKhkyA6yc6350mGToLoJEeQyqcaLKaITtLNTtPzJEMnQXSS3k9veBhk5iRoTvr5vDwMKjMnRXPSz1tMlZmTojnpR+eHQWXkpEhO+rH5YVCZOCmKk3785WFQmTgpipMePsqi3dR39FEjsEa+fGmViZOiOOmn5odBZeSkSE56/GiaQFJGTorkpH2ME3+gVCZOiuKk8pkfKJWBkyI4aZ/ixB8olXmTojdpe9PwQKnMmxS9ScVeHiiVgZMiOKn4ywOlMnFSFCdtcRoeKJWJk6I4afc6DQ+UysRJUZxU6uWBUpk4KYqTynq5OSkTJ0Vx0hYnvhXwHX3UwJQePxq/94ycFMlJDyBNzy7KzEnRnLS7nfiWxHf0UQNzes2JT4UpMydFc9LuduLbGt/RRw3MaW+nx3emuKOPGpjTt1Oc7uijBuZU317wlaGTIjqpvuaUoZMiOmmj0+bKogydFNFJjyBND1HK0EkRnbS7nYaHKGXqpKhO2tvpDZNyytRJUZ30ENL0IKZMnRTVSe1lB907+qiBOe1uJz6xp4ydFNlJLednOWXqpKhO2tvpTc9yjJ0U2Untbe2zMndSdCe97sSf5Rg7KbKTNjsNz3JMnRTVSVudpmc5pk6K6qStTtM1nbGTIjupv+xhckcfNTCj/rKHyR191MCMNjsNz4NMnRTVST1fnuUYOimikzY6Dc9yzJwUzUl9vTzLMXJSJCftI5ymZzlGTorkpH2I0/Qsx8hJkZw05O1ZjpGTIjlpn+I0PcsxclIkJ21ymp7lGDkpkpMePxqf5Rg5KZKTxsv2uXf0UQND2lvpbb66VRk6KaKTxtsiE2XopIhOegRpvHYwdFJEJz2CJB9+FsIdfhTBoObn7QLE2EmRnfRtL707+qiBQe3DnIQvDVPmTorupAeR5MNPZbjDjyKY1Hw5J+eOPmpgUrvXafyhsqQiPemlp+H1mtGTIj3pcST58LMd7vCjCEb17qc3PBIye1K0J80bVT7hqUyfFPVJb8vT8CzG+EmRn/Rg0vQsxvhJkZ+0XjbNv6OPGpjUer3tM39S9CetN8VX5k+K/qQHk+Tz4ROvygBKEaD0aNLUb6kMoBQBSo8mTf2WygBKEaD0aJJ8PsOLOhMoRYHSw0llQ1CZQCkKlB5Oks9neMtmBKVIUHpAST6f4RWZIZQiQukhJfl8hndCxlCKDKXrZYvSO/qogWFdL1uU3tFHDQxrMxTbGvSOPSpgUnubPbY16B17VMCc9jZ7dGvQO/gogTHtffamFzFGUIoEpb3THtvW8449KmBGe6e9afKECZSiQOkVKLbZlTJ/UvQnbX9i23resUcFDGfrE9vW8449KmA0t0/bet6xRwUM5n7bvkyZPCnKk+6ctvW8Y48KGM1d07aed+xRAZPZ6sS25LxjjwqYyzan6b7G0EkRnazRaXidNYZOhuhkjU50S847+CghWEKnLTnv2KOCYgWbtuS8Y48KhhV82pLzjj0qOFaIaUvOO/aoEFghxy057+CjRGKJmrbkvGOPCoUV1rQl5x17VFhY4W1liTFqMqQmk3tf52+PxrDJEJtMXpaWGMMmQ2wy6bs6P8fqDj+KYDpbm4ZFHca0yVCb7NCRfPhhWHf4UQQj2tzEb6nGtMlQm+zQkXyEv+cY4yZDbjLplyV+otYdfhTBoB48qqRTk8a4yZCb7NhRZfESLKioTXboqBbf4c+YNhlqk3WD09BRaEybDLXJ9AaVv14Y4yZDbjK1l/YkY9xkyE2m/vqNYd5k6E2m/bLEDxm7w48iGFW9UeXvBsbEyVCcTG9U+buBMXIyJCfTfl3ix3Pd4UcRDKv2iz0/n+sOP4pgXK2vq8onsoypk6E6mfX7Ej+h6w4/imBgrQPLj9e6w48iGFjraSgdLiQMngzhyawTq8NXh8mToTyZdWJ1SCyzJ0N7Mntbp28MnwzxyRqfhtc/Y/hkiE/W+DRdBxg+GeKT2R5fIY3Zk6E9mX/GV0hj9GRIT3YcabrfMXkylCfzt0X6xuTJUJ7sNjyxV0hj7mToTubdgc8rsHyiOpm/Cb4xdjJkJ2t2oi+hxtTJUJ2s1Ym+hBpDJ0N0sm50oi+hxszJ0JyszYm+hBoTJ0Nxshan4SXUmDgZipO1ONGXUGPeZOhN1t5EX0KNaZOhNtmho2m/VWPaZKhN1g1O9EXWmDUZWpPF2wy+MWsytCbrBqfpRZZZk6E1WVvT8CLLqMmQmizW/CLLoMkQmuxCEz8S8A4/imA+LzTR7whjJkNmsmYm/jbMkMkQmaybm/jbMCMmQ2Kybm0a3oYZMBkCkzUw8bdhxkuGvGR3Kz0ab4ZLhrhkR4rGt2GGS4a4ZBeX+OGKd/hRBMPZuDScQGAMlwxxyS4u6fAgy3DJEJes7jPo8CDLdMlQl6z6GdSGB1nmS4a+ZNXPoPw0wDv8KII5rX4GteFBlgmToTBZ9TMoPwDvDj+KYFgPF0374xgTJkNhsitMHGWMCZOhMFl1XPkpenf4UQTjerio+EnCd/RRA+N6uCiLw64xYTIUJrvCxI/zu8NYBIXJjhbl4runGQMmQ2Cyg0W56DMg0yVDXbJ1kzrcXBgvGfKSrZvU4VrEfMn+r+3blt1Wdmv/ZT3vSrFvaDJ/cL4hldolS7QnjzUlhZK87J3Kv5/ipUEARMuQU+clSzW9M3jrCxpjYEDyS6FdTkt6/7r1n3cgcqjOjFF2ev1+0EimIEmmMFNGDtTSsaCRTEGSTKFdDvd6A7r1n3cgcqS23YtklkYzBUkzhZkzqiWzNJYpSJYpdK4+xDSWKUiWKXTLiqr3Ulr/eQcix+nMG+WsF94HjWoKkmoK3SttSdDIpiDJptC9jEw1silIsiks3noV38Sg0U1B0k1hKXPKlTVZI5yCJJxCt4xSvbnU+s87EDlKF86pklDXKKcgKac480c56yYTUaOcoqSc4kI5dUE9t0SNc4qSc4oL51TJyUeNdYqSdYoziRRSUqsEosY7Rck7xWZZTivNlKJGPUVJPcVmWU6jPkKixj5FyT7F5lXPnKjRT1HST7F5pXyOGgEVJQEVm1fK56hRUFFSULF5RY5GjYKKkoKK7hU5GjUGKkoGKi7lTo2+kkWNgoqSgooveztFjYGKkoGKM52UvV6aHDUGKkoGKs5sUq4YBEeNgIqSgIpuHah6ZBg1CipKCiquFFTUI7KoUVBRUlDxpcde1BioKBmo6NY1VY+nosZBRclBRbccqSqdhKLGQkXJQkW/BKmVVkJRo6GipKGif6UtjRoNFSUNFVcaqtJLKGo0VJQ0VPSv8lJRo6GipKGijy/cw6LGQkXJQsWVhao08YkaCxUlCxX9K8le1EioKEmoOBNKtU4eUeOgouSg4swnVTp5RI2BipKBikvVU8XuPGoEVJQEVFys9iqW2FHjn6Lkn2JwLzp5RI1+ipJ+iiv9VGmuFDX6KUr6KS5mexXfwKixT1GyTzHEF+1AokY+RUk+xfBKrh817ilK7inORFKb9PRQ1LinKLmnGJaDf6XbVNTIpyjJp7iQT3qQGTXuKUruKYZlTU2VeEijn6Kkn2Jc1tRKy6qoMVBRMlAxLmmqSs+qqHFQUXJQMa5jtbLPaCRUlCRUjMvhv9KWKGo8VJQ8VIyvTlVRY6KiZKLiwkTV4iqNiYqSiYpxCQFSZb/TyKgoyagY19Fa2as0PipKPirGJQaotJ6JGiUVJSUV4zJeK00PosZKRclKxYWVqi0CGisVJSsV0zJcoTKBNWIqSmIqLt57XeUgoVFTUVJTMS0FpUnLy0SNmYqSmYopvooiNG4qSm4qLtZ7ao/ZqDFTUTJTcaaZdPO+qPFSUfJScWaZclKtVKPGS0XJS8WZZvKtWggaNWIqSmIqpiVBVfuo2giVvFRcOj1VKtOixkxFyUzFlwVQUeOmouSmIizrKejJ9qjRU1HSU3GtgKrtMRpBFSVBFWE5/UNlj9E4qig5qgivNNFRY6miZKkivDI6iRpLFSVLFeFVR52okVRRklQR1uW0sl9qLFWULFVcWapKk5CosVRRslRxZakqXUKixlJFyVLFlaWqtAmJGksVJUsVV5aq0ickaixVlCxVXFmqrPMpUWOpomSp4spS5UoeQWOpomSp4loIVWkVEjWaKkqaKuZXZhJRo6mipKni4sRXKQyNGksVJUsVc/tq3mgsVZQsVVw6QDWVvidRo6mipKniSlNVGp9EjaaKkqaKixdfLTTTaKooaaq40FSukuDViKooiarYvvI5ixpPFSVPFVeeqtLFJWo8VZQ8VWxfLq0aTRUlTRXbJVattIKJGk8VJU8V25djVSOqoiSq4kw6tY1qhh41mipKmirOpFPb6IRq1HiqKHmqOLNOratEEhpRFSVRFbuXUYBGVUVJVcWVqqq0pIkaVRUlVRW718uqxlVFyVXF7vWyqpFVUZJVcWaeapZFUSOroiSr4sw8tU4t2Y0aVxUlVxW75VCVKzueRlZFSVbFlazKlR1PI6uiJKtityyrbeVkptFVUdJVqVmW1Vb/NEnjq5Lkq9JLX76k8VVJ8lWpeWUfmTS+Kkm+KjUvFFVJo6uSpKtS86oSOmlsVZJsVVrZqkpTmKSxVUmyValZVtVW3zSTRlclSVelmXuqNLhJGluVJFuVFraqwiMmja1Kkq1KSzeoCo+YNLYqSbYqzdRTpU1g0siqJMmqtJRLVdTnSSOrkiSr0sw8dRXzgaSRVUmSVWkpl6qYDySNrEqSrEpruVRt3mpsVZJsVVrZqkrLn6SxVUmyVWlmnrpKOUzSyKokyao0M0+d05PmSSOrkiSrkntFqyaNq0qSq0orV1VpHJQ0ripJriqtXFWl60/SuKokuarkl4NVpe1P0siqJMmqtJJVlWY5SSOrkiSr0mLRV2nDljSyKkmyKq01U62+3yWNrUqSrUoz85QnOyYlrkoaWZUkWZWWxlAV0V3SyKokyarkX6UBkkZWJUlWpbVgqtP37qTRVUnSVcl3r9Yzja5Kkq5Ki0lfV1lGNLoqSboqzdxTRduVNLYqSbYqzcxTRduVNK4qSa4qLRZ9rW7RlzSuKkmuKs3EU63YMWlcVZJcVVoLpSqm8Ukjq5Ikq9LMPNUqJpNGViVJVqXwcpxqXFWSXFWamadaZ92kkVXkjwWje8FmJo2rSpKrSvFVA7OkUVVJUlUpuhdEZNKYqiSZqhRfaVWSRlQlSVSllaiq+NcnjahKkqhKS38ovaFk0niqJHmqNJNOteBQo6mSpKlShHpPuKSRVEmSVGkmnNqsi1yTxlElyVGl+MpWKmkUVZIUVYovbaWSRlElSVGl9MpWKmkUVZIUVUovD1MaQ5UkQ5XSy8OUxlAlyVCl9CpHlTSKKkmKKqVl3+8qhxiNo0qSo0rpVY4qaSxVkixVSq/S/0njqZLkqdLMOrmKPixpRFWSRFWaaafqSUhjqpJkqtJSQhUqMYzGVCXJVKWlgkrXICSNqEqSqEoz6+RCJXLQiKokiaq0FFHVbkMbppKmSvBKo5o0lipJliotLFWoHD80kipJkiotJFXtUbRBKjmqtHBUtaO2xlElyVGlpZKq4jmWNI4qSY4qQVvvjZI0hipJhiotDFXQVeFJI6iSJKjSTDbVbkOjp5Kkp9JMNUHWyOmkcVNJclNp4aaC7iWZNGoqSWoq5YXr10oFk8ZLJclLpRxf5D6TRkslSUullZaqNEZJGi2VJC2Vluqp6o1oQ1TSUmmpngqVHV+jpZKkpdJCS1UU8kmjpZKkpdJCSwVdEJY0VipJViq1zav70EipJEmpNDNM1RVMI6WSJKXSas5XaSyQNFYqSVYqreVTFUf/pNFSSdJSaaWlKnb8SaOlkqSlUvuq0C9ptFSStFRqX+lSk8ZKJclKpfaVlWTSWKkkWak0c0y5rawgGi2VJC2VVo++Sgik0VJJ0lKpe+XOmzRaKklaKnVLVqrSFyBpvFSSvFSaOaZcm/8aLZUkLZW6V+3MksZKJclKpZWVqhg4J42VSpKVSi87RSWNlUqSlUoLKwVqB+aksVJJslKpW05RKrGVNE4qSU4qvewTlTRKKklKKs30Upu1+rqk8VFJ8lGw8FGuYkQNGh8Fko+ChY+KmvcEaGwUSDYKmlfGvKCxUSDZKJi5pTZ77ZuAxkaBZKNgZaO0+n7QuCiQXBTMvFLrdUkaaFQUSCoKZlqpzaGCoQxQkEwUNMsAVRvdgcZEgWSiYGWiNKsC0HgokDwUNMvwzPpNKOMTJA0FCw01lV3Ef2u9mCWg8VAgeShwr8h90HgokDwULL59ruJPDhoRBZKIgoWIqlSzgUZEgSSiwL1STIPGQ4HkocC9qkMFjYYCSUOBe2VDARoNBZKGgsW2z1U8zkHjoUDyUOBeEaag8VAgeShwrwhT0GgokDQU+FdiVNBYKJAsFPhXjCloJBRIEgr8K4Mp0DgokBwULL59tUGmcVAgOShYCqb0ZjGgMVAgGSjwL8epxkCBZKBg6RJV6QgCGgMFkoGChYGqdAQBjYECyUDB0iWq0hEENAIKJAEFCwFV6QgCGgEFkoCCmU2qSLdB459A8k8QXq6nGgEFkoCCsK6neqYSNAoKJAUFKwWlHfRBI6BAElCwElCqygE0/gkk/wQzl5T1tgSgsU8g2SeYqSTnKlb+oNFPIOknWH36KmuHRj+BpJ9g5pKcq9jwg8Y/geSfILyqlQaNfwLJP8FMJrUVbyHQ+CeQ/BMs/JMuTwSNfgJJP8HMJdXkiaDRTyDpJ5ippIoGDjTyCST5BDOVVFM4gsY+gWSfYOaSnKs0NgCNfwLJP0FcB6qebACNgQLJQEFcd339UAsaBQWSgoKlV1Ql2wAaBQWSgoL4wiMFNAIKJAEF6YVHCmj8E0j+CWYyqZbzAI1/Ask/QXq552v8E0j+CdIrPh80/gkk/wTpFZ8PGv0Ekn6Cl/QTaPQTSPoJXtJPoNFPIOknmLmkmiQANPoJJP0EaV1P9ZQHaPwTSP4JFv7JucoRXSOgQBJQAMs5v2L3DRoFBZKCgoWCchWvbtA4KJAcFCzFUq7i1Q0aCwWShYKlWMpV3KlBo6FA0lCw0FCuYgoNGg8FkoeCmVWqtYMHjYgCSUQBLMtqxVgaNCYKJBMFCxPlKsbSoFFRIKkoWMulKsYvoJFRIMkogHXAVhZ4jY0CyUbBzC3VLApAo6NA0lGQ1/FamX4aIwWSkYKFkXIVh2vQKCmQlBQs1VKu4nANGisFkpWCpVrKVRyuQaOlQNJSsNBSruJwDRotBZKWgrwM2IrDNWi8FEheChZeylUcrkEjpkASU7A0jnIVf1PQmCmQzBQszJSr2GGCRk2BpKZgKZhyFStL0LgpkNwULJ2jXMXKEjRyCiQ5BQs55SpWlqCRUyDJKVjIKVexsgSNnAJJTsFMNLVB1SuBRk2BpKZgcfZzFTdM0LgpkNwULM5+FdM00LgpkNwULM5+ruKoCRo5BZKcgsXbz1WcLEFjp0CyU9Auw7XiIAkaPQWSnoKlaqp2tNHoKZD0FCz0lKv4P4JGT4Gkp6BbR2tl8mn8FEh+Crp1tFYmn0ZQgSSoYCGoXMV4ETSCCiRBBd0yXiuGhaAxVCAZKuiW9bVirgcaRwWSo4KlcspVnOBAY6lAslSwVE65WBn1Gk0FkqaCpXJKn3waTQWSpsoLTaULhrJGUmVJUuVm0U9VIJShmiVLlWfKyelJiayRVFmSVHmmnCp6+KyRVFmSVHnmnLxeD5s1lipLlirPlFNFWZc1kipLkirPjFOFVM4aR5UlR5VnxqmiB8kaR5UlR5VnyinqQytrJFWWJFWeKadYG1rK6MySpMoz41SJmbPGUWXJUeWZcIq6aCFrFFWWFFWe6aZK3UjWCKosCao8s00Vr+as8VNZ8lN5JpsqxsRZo6eypKfyzDW1laGlsVNZslN5pprayhzRyKksyak8E01t7XVqo1NSU3nmmbrKZNeYqSyZqTzTTJVykawRU1kSU3lmmbrKANd4qSx5qbxUR4XK+9R4qSx5qbwUR4XKC9V4qSx5qTyTTC5WRpfGS2XJS+WlNipWhpdGTGVJTOXFyC9Wli6NmMqSmMpLN6lYe6faGJXEVF6aSaXKCNOIqSyJqbyURqXKENOIqSyJqby0kgL3j9j+W4IsMbRhKompvHSS0p2zs0ZMZUlM5aWPVCXMzxoxlSUxlWeSydeGqcZLZclL5Zlm8rU9RWOmsmSm8swz+dqmolFTWVJTeSaafO3TatxUltxUnnkmX7Hxyxo1lSU1lWeeyafKUNeoqSypqTzTTB5qz6INU8lM5Zlm8tXxoQ1TyUzlmWbyUFk+NGYqS2YqzzyTh1n6laT0K2vUVJbUVJ55Jl/xNM8aNZUlNZVnosnnyvvQuKksuak8E00+VyIXjZvKkpvKM8/kc2WMadRUltRUnmkmX/EBzxozlSUzlWeWyddCKI2YypKYyvGFNVrWeKkseak8s0y+tmNrxFSWxFSeaSZfSUtnjZnKkpnKM83ku8rw0JipLJmpPNNMvqsMD42ZypKZyjPN5LvKlNOYqSyZqTzTTL6rDDGNmcqSmcozzRSayhKkMVNZMlN5pplCxcA7a8xUlsxUnmmmUKmcyxozlSUzlZfCqNpBVCOmsiSm8kwyhYoJeNZ4qSx5qTxzTMFX3odGS2VJS+WZYgq+8j40VipLVirPDFPwlTGmkVJZklJ5KY3ylTGmcVLlj//5j7+Gy49+fPSn/3M59T//+vf/+I+/Dsdjf3v0p7/+8d9//XNY/ty1zT/my/317//9l3fO/fXv//0///jLex+mX//zj3LB5e/lSvO/TZdeMG/j9fQ8Po7X87k/PobrZbj8GB6H6Re9mIO0XWzqU2S9wv3+z8f1e8/AUtNuYBOHuPz/T4TV+qvt7M9wv5/7H/2ZvZou0FfTNeurmeg2O6xy35ndd3njUy+rN2G/HO7DkWE7z7DhXcTTc9x9tQQdBW3Nn+36vDzY5598l7c3Ohkr25Aew4+eP2Zkj9mVT9+G9ZcP5W8e1hfspjax668E5Vcuf5us1dZhEwtKB+sv38A6vLwr/7/edalMloLs/fIRp1/lXuYOqMuvhB978nFYf8Xy/5EQb9Jgrr+s7+h06k+38fp55e8psPdkHGCn0zCNgcN5ON3ux+utv1PQlq4YrgXzDc63JwdXBHqH6yubrNCMoGN/Z3eXIpsB5eU6cOb7nCAP9/vw7TL/CwVPiYKDcXlZIPlbdASofOuuew/v387Dnd1faMm8aLt1yHbtW48+nPgjsw8EEd+neTBNoDMC+0xsZMZttprfweN6PIyP4fLovy1rVv+jvzzE3eeGLV3xfwe+e4rsGLxxXzh9XI/rjsnXWXaz5jfxOVz4tkX2F++99Zk/h4s+UumEKqvgxIa8D6sM2EQHbCgD1jq2PofL896P38br88Zvmm7dDd60dVlhuMpdA73rWO76jQ82ofMbJh8tOLxh416LkMq9Znqv6w7TdcbPd/7GN3BHnnzuRW9DOX95/urH+/FwuY6nfuSYDf1W6wIwb4zG93k+X//GS/Dtjy3XftvqE65iZeGZzv9l04+4hZdfwboNz/dy+TXfC18p2LbUml/cDHd/3m7nQSKyFdS6xs+I99vh1/Tnz/7xcT3xr5E7GqJ1xpk4wfanr4fh3J8Oj0f/eXuwT9HRyN835uE3wf489r24yZYOmck10Yx2vfWXR/9TxKXAHtp6MJnwxv7+/PI5MLzO00/T+XIe6cIbN3rvz2f5xVnUa10kz+cyfKb5N8FSUEgUNODS41LGMLeErz4Y189PGfknx6KIEt66yUq8zMkSkndQwmA803nncSb6Law2voD5bq4/+nEcTid+FusCPUN2YPw+l+vl1+f1yUZ4IKGA9SRXcOpHr8xWMOsOcxuO50HGrsCOy63xUxaoSkDc0ZDFWydiARXBWucYWBmAKRhXiw2Wb62Onrjn+oG34BiYJw8ct33aeBJASGWfbuk+DWWffvMzLcD3/jj2/L5D21H8XPCNSx3iz8j8q9EFxLs3v9UCeBz7w6Mf+/vternzELsDBm+MZm9DP45XtnwGT95A7jBT4MyT6nv/iy2ddKt0AREn1/o1qMBT/tS12XiV8Xru+fBlQRdYF6nb8KMf7zID19B1yptzcLfb+Ree39nAiiybtS7T0Tyubudf94/hdhsuLNKESNeCUBID3kXr+Lqdfz0OPzmmZ5gRMa2T7LY/ALJ9zRrW3G7j9cfhPFy+8nRNR5docwZ2RRuffNxAw9ZmbzycEjS+PHc+sqimpK0a85zckPmSSp46FdRJYvY26n5VpftT27Vl1XvvzfKFlI6itmxSbRmhbTlRtH4NY9oSU7Wh/I9LgrHFvEfOEX/h3zAjmVv8W4d/68rf2gYzl+a1bH2wx+HxFHulY3ulNbu3Aj5+3fja1dA8z9zSd811WUOkGZhh+kjG4dR3ZV1x3vmmPLDufGIjuyzajXtnzgyXb3O+gM+aqV0xnYUY5WLKuHElvo7m+Ol2fxzGx3NkoXzb0ku11jfM5yL5Wuud4tK7/Desf4/rf9P6tsoAzmWSlexjeWIcpa6ctFO5BOBQxtdTIv9mW/nXH778Uyj/VPZb35aQsezFvlw9lKuHcqYI5UiBtEBI5UehDEIuCelUNjZYLzE161kH3vpPqZxMMLefwvouMMc/GWwuP8olUos/yv+mAEKzXgIKowVlTYFCb0BhI6DcGJR7hoIMZfWAEvZNmtXlh8Ovt+Lk8qS5HMNyoTRyAczWc8h8ZuhPczZkxwalzCIHa6S7YpYzrQLLzjnWQOTJZy3biaM3TqXn44NNJhIfQpnkuTEuKs/Hx3Uc/rVkny+n23XgD9q2nk134zd5Pq5zcMSP5+xTlBnmYoupizK8vC/JMx+C/ZJfr+Pfh1EwzzTp4nDn98H4yX4chvPhy7mfAmbOUDHCso1l5WiQzkudcaX9OVzvh9Ph9pBJy+BZGG3cfP71HPsv5+sXipUdjdNifBPqeL18HXjsTBOqzvw6J8DH9D75zTl2c8agDLG0u2MHumCbDV8O58PlKGILJl2IRvbsy+HeH26D2DtdEwL7oLYHncBOw323CGV21EgeWciwaRNsI/BL//U69rfxOlH0Y/9fz55HuLPtAU1u2AK2L8P5LI9cLGvps+0sswIpTGzXsPWpe+vGVC6yYwMbw/m5QYsJ+3p93B/j4Xbvxx+CK8iUNXNgnDRfnpeTPHWxM5wxR7ng6Dk2aOhq5qNxwsyIx8PjcL5+qwBzZi8ZP/gMLIJctoT5Eks4nxz+QsWFkSVdr/PoP/m1MmOOMdZy8NarnnDv/BFYGivZVuEF7Dxc9oCBLHMlJJtLluy4t3HgSx4Elqwv8aGLGXMZwbhwrReYSeja8Ejsjbzz2fibIDMrZ3wTxvVgwVNO9mRjastZuOveefz788v9OA63WbAmvx9NQHVbotc6yAT/B45NYigZwtY8nX/1o7LIgmdz2HjmWwLysT8Nj6OIysCz7dlIVM6A2kYIgR1/rZveBDcfpjkWe1brfo9YYs0CuuAHFLZEY351w+XDhtwj6rmmAr83MZUBT5Gbpgz4N8aPpFvY6yxHQudjiVFCOQK6gEkpPAC71OLxHeObXA6oLhfRm8MTpWubkllxLaoeN/1jmcQ+BtzZy0SZ+waUX2888ryEfhn7w3c+kgJbR98FvB8/+pNMt0a6BwZrSLJg7rRAkNgd+jfGDx+OFAZzKdnI0ix4ylAMdCi6MhTfmDgL6PJzJrr5jkE5pa4pmSRrCDmjKpIJAPZSk+0THQ/n4/N8eLCvHVmSoSSZnC1qOE6c/K/LcVLsSIkZP+GzeNcYkR+ngxI73PhIdvJYtuBoXDoWvJ2M2TU0b++DMf8woV0/vwwXIehl79NvVFpZWToirC2plGAkg6Y97uN6PvWj5G/AZ7bblbUtGjO/E7LMeYNnJwB8gmhUY0/CQzbUuIgJp7AtXzahzXOtPw/fhi9zzKeweKFLdMYVIZ5R/oMX0SNhSuF2JRHbGfdvxF41SwI6U+iy+TRGdeKGXXkpLUXHRLZRRrgevvgKxAJ4Y0z9+hQHwOIY6xI0Q8pjHMsAYHo+AB40NvE75toTzsxkXqHmi4vzNz3VYbxt3EYLorJVdfQTZvyEZtz+23UcRH6RviZ8+mxe/Qvm7m4jpWw7jMgao7xkRRYiBRaWmFfpBaky5Jj0MGTrIrFgvsx1MD49GPXaBXl/+qCqQxeSLX4ocGJyMPVdQI1HaLfMBgbJKJ5L2bxWzNd8fSJnjEkwCgCPRznM2sQqOIzB4LEf+eJLiw0csgLZKAc4fgzn0/6LMUV9sL498anopHfRGDwfhwcnRSKTWxZy0HnrTc36pumUPUnSpIqAnL2sc1KRzE0ddogYYQubSt4tFTrWJayNapEGcQ0KLBsMqgqjPnfksd+YpgxjwZU1pLqeRGjIqs88ntNxtnUoGd8I4OCQpTKqe9Z/5QJyNpA8XhvzTa4r4g7XYWq/6zZpTLmfxjoIp38dj70iAmNpfuuYuX7eDhexkrVsS2hLttY3KHxPxpPWCr9TRfGQdUsCG9VmE+y5fwjVB9kZYhnV0XjmXGio0+FxYOsEq2QLKK1JHbI0JTvh2nb70PjxIypFAv7a/pZwWGZUeBT9x9yqavkF0biOz8+giIRpNYprt3DEOt8ul/740FaXlq/w1nWPAu5XhZaW/LjWPCRm0ClCf4ySuGpY6j6gshNTUBG1J8kogzvOF3oeH0JDSgYMJsKcNTy7Xh69rIgNtC5ijSqsSB9PQSTThF40ZpY3LIWrZVqKYNRSHK/X70N/ve3OU8AC59DhYp2ts/j+eb2fxEMH9tDvISmP3LLYwfxpBSvbJKZ7w+UhWs9n1/vjOFWq8AQWU8hHPJEmrGyG7UrW9BZeqRJ0sjRxtKYdEFWGZuxzWY93iCYqkalsbzszmsdAAVUOYpT9KWlr1xhFqbuwtmUCG3PuZoIZRVDKBMd4RPdGBcoitGdL2oaH4WPZt5b/lgW1qFZLTr4EioUbwPJNPGWj0K8gY7U9CvQaZC63Yvr1R8EJBQcl21imFEpsEQo9EFMRhJaDeSz3FwsgTpdUZksqHAXSDFiMDyVpsFY8Tyq8ormLKw4kFN8V7V4hR6DYRkCJCnMZTrkUJObCuOSEmrvyvzG6LSzfVSEIHU0PWWUtC9rGlLOpwcJxY5w44+mEo6M83Hr4MALOTNlcUFqzG2kptHFZmKFLIpPNPV5L/gbashdyzTv5LGA9osxgax6Un5GY5PF9sMd4uNwPx135GWcI38GVhjD8u3T0u7wzhna4vVwhHT3dmHNTOnhlWNEchbWwZ7nCPhz2BMuorluhiHiB3x35aOaAcgepT35HM3/BWEO4B9/DRgr7zpJXGbk+kSGWjHWrC+KPwzgcRJhOJ0IwasMq+gpWLhetyTLEqgVp9FAVjZVDG6oM0oCh4RaNtQDJPlTXK/DAjSp/m43SMq8EBVQJ3KhKwpVwozFS/MfnOPaXI8+gMw4dE0sOt2+HagzvtqKyooTwLhrHy1QH/DnJvj/6g8JVZkb0JAylEqabgsNfJTnmE1Z0g9FPQd7Hj8P5KW4ksxvBXCMKOILDX+ialUrhyNyxyn4jcx3nrtKFpTysse+MN0y5penv87ougDOndqw04gy8k6Fn5vmQ8vZObPcr01WBZh+2QjCP4zAZg5LTEir2QldJFyYcNg6DXO/wwL7mWGwXmnUYXMdLs9auM7KGK9hUvSVUwawuscE8nZFgnnAXjYPEZVVhuExZyeUZd81kCmBgwOg2FrZLlEnbvPFJl+2La7x4dS6ewzxsB0ccR5hQD+VGXNy89FAVhgy+67ACq9neDk79hvg44C/MiTpctXzA82bGxWLbaRL+zShGmF7FqT9OEbx47Zm99oT3bh/Mp/48VVVLOxLqoeGjUZUy4fU/++Nz58hIU4LO6LEzoV36fjepE5vUqNhD64JoVDpP+HOh9u7ZE3t2W6R1WgLCz+Gxmxssp4OslDXzsn54zhyQ7461+VZnmxXQfDSgBpet8dX2E+d12imsgPFn0duio1P/9fA8P3SBh2c6/cIDulACGJeNoXK5ynU205mEbDsSiCk6nHXPW3CXA/Mghlpm9T4oqreW/q7YTMEpCkw6ZoaK4tO1Smleot56P//1PFweglcG5oXjjaKEFbDIGoWUF1gCAEPDgFwIoPDelcpT7zBe80ZjovUmdhGha+iR2G/lCNGoxz/1X4dLf9eOXk1mnqHGBNGplwQiLRov8VIJyJb/ln2oOIGVF1XYu7J0bIZvKw7m4dHXCCXPGByX/yeP+w6WfeP5CkXRBRkrPPDUEcqxAj9tKDngUKYzirRiySKiHiCWT57KRXFPSCXOSyUJmQogKr1TCRFSqauGIlJCJzUodldQKsShlHZCSclCSR1DESVASd9DucNcDm+5vNVcqqhzecBcRnouONlowbGMDy1fShVIVgFSQdOM/ZiJsLE6Z8XTLZdIXmMdlzjqtqNpGXUY5OBgw/FTcumAw76kx8tfkAeHkrKGZIyp5wd4pfRi1DsWhxlPchR+l6VlGkbb0bvgiaIdT/WfVsdLgqU/Oa3YMdKVBJOPLRp3GitpCdZ+rDIy+p170ySdHfOKtG5zK5oiu2S+psZqvxVPZx6onM5alrgA/pZ5oMR5MBZRLdCTbfvlcR1/jf3xKvJmHVPcvzMV5SzxtIAhIlllNDpYMFWOhEsx3kDTOBLyfcBYF7+AaRwJq2Z8Zx3+DUfCo7l3cNXaJA9kfUjW89QK+EI8Sp0OsXKrLPkOeUtjYpddsMLy0ANAMPqTVnD3LA/dP6xK2Ap4ZQpTN51gdDzBK+yNzhMTQ76zIiikEdnjjAX/K1SNNKJeIuGtGMpAGtGkajD6vOzB97CUNDJqkwrscoqqbND0qPDOyEKfVX6mpMeX997sArf3im7YQfidF1qjy6j1eLJmd2fE6e709+hYVqxE9SWYN597y0UUk++GnTrfGQEqyUeH6VvR1IpWeQ10Twz2qGpKNP7aC9QyS2Nae2hwPOGowOqqMfXq0NDKgcPzLFELY3YEcwsJ9deQzKOS3NcqbhU2IjQls1Wwmiemgq/QhrSiFUW/jdGuoVzlcRi/Cd/VzBKaWNnsonm4qgt2Ypk8JBvdlnDwaDvty8neoaTKBaRJ8CDoQjmnu4AHyIglUxH/NRZOzwFWF6C1mMsbUZAx04S5Dodl3L7ZsmubtxQSmCV54PEOPODXB79xicbXqHkTMMYrOFQLG8vyCqY+7TOzy4zGovWCuQsLM/NliFbOjMLxccmMI6L1XL/i8aQ9BFZmZXT22LCWjCy/O7bIWdMCK6JY3pi7I8oCXdqSo9a5uOLz9YnuQdi3JxtVWAi5X5JY/rx556VODJWsJc/M3ybiJI1G/dLp+nngfUaAVQeETYVglAWJDDLzHQ1GsmM61kvLMmATz5dUo/PGsLY/9z8mqm9iT9gDU9MI4/wrWHttAHt5gKtx3rpBIbkKRoquVHj3P2+zd5bcMRhHgEakscMUdca1GeUjwXjs3lWX8wCDOdwZabH+8zBw1QerDWyxtVOLdUsNuiy6zT3eKAPoL9NA4isHc95CEb8D42TsL6eTUFu7hh4rfWo2xtt28NacIIEZv4aS9HUJt/GMpE8oZ39vPYn1OwbLNYGl9qwfdAaajC+UqJb5BFkN3TbEj/F6Wb0y2eLMXBpRaGaUsvaXH8N43aeumdy2xcaDLaZVOoy4OpQvNKijafBv0WNsY11QpKt9DkwV5rZhb3yFE6CsuQz0a2QcT5uFr9+Yrk3qZUwdrVfcjwAaKCdj5p6Aif5PNFWK0quVS7LBfk594L6xF9MySr415p1mNF5YylyhnVGd2N8fw+e0ncyn+OFxOvwS52FgR24wfpAVVvPhT8zLpBRkGCts5iDky/X0i88eZgtpNE2YoXb1biywM6ZqCpI2ApkHhTFHXPB2ck3mB5WMGb8ZTTrKZFYyCai1Stbx9/N4fp56JnyQCSXK/Hijar7/Odwfw+XblJ3hs4T5Flm3h583vvmyoMHYA6b/eRuUNjpMHu3xfO+tAxlR5X6e2DHKbWdujKqi287NmHZH5U2HKhZkZr1HzWww1nDO99ff/8nj1cTCF7fldYwaiv7no7+c+pPG82TWnyMZw/Wvh6NIj7RMS9was25Ln7E5QNeajTmeILXKeL/2gm9k768zBn1f+/5xfRx4J2HmN9cl28rydTg/ZnM4Ni8is/1ujAqFBUu2eqCpaTAqm77OajgRgSbmHez8NuS3gY4qT6zUDEb6++sw3ve9N7kFGypusNjetVspPrqXg9G76et1/HZ9PPpLxb/D0b1icyTLxrAF4W+H+/3vK+elA1VzWds4IKKmxQuUU7Q6xSuW7Z7u3ck6rWbXalFUMQ1ceg4ymhV8Ha+fmminoSyst+ZWCZqUGlK2zls92Sc81XGjY/7IaOzkk3H/mYDlJtsxZ/bO6DBakOT90TUFy2Z8MlbkfOsv/TgFptNBYt+RgSVkHDo2Y+cM1+Vt78PjqZHYZNc+95dvvAdDYtk/h4XyEU81HbpzbG1DgjGYZBe/jf3X4Se/OO9ujTEBNkXpkDvxqBAMxkKdcvGVfeJ9XGjpq9Ux9RtnmWmF6nq76F6y/LfIYiNq/5b/FjUe2uQgi4A7A7IJmJ8jfj5l2UbNKr6k8k+YxSiXCA0eTsqP8j8OhV8Ipf4BjW2xaRuyG7FICmN5iFSSc6k8diqUScImOOUNpCJlSyUVhb5LqYR1WLAFZaKBxx/lTaIItdBsUMScUMYrlP5QUCZNLreaS1IiF6YklzvM5UlzoWeyMYb41j8Ox6kNwU6pHmgJDja9y0ZvlwlXWdPpoScYdcQzlNpeuWEqYtt6/q1/7DV3jrUrNuY8ClKNx2bHdvNk1UV8jp3ljCHWt/6h2FU6WmcXjH6xG5RMTjAd9xtYihaQt/Q0r9YPzSLRUZ1ZMDpKfZubVmqqQupKEoxGWt/6x28lhbRoNhirV771j+G0ZEmVSUvGSTaer2fAW3UZYD0PbJH2hPh568f79TI/s4JK+wcYi68n1BdCSt40xbzfPnYySipDA/s7VKWTzGvOfEuabpI8nLXb7YQ0Db6/r+P3+0cvIgHmk2Z+SkWFyQpV7CNEcUh3VBgSjCTPBlXRLFI2NxoPOBpoZQ5TPiIaj6IL/J5VczTLFo2GthPY88t5OIpetsKUzYo19l/H/v6hzFmqnDfqySbpzF7qSOsdzN9jSmXLoeeoWt5q7DVh3fojx6Fu6sa6xAXncppaGx13JyRHpfLRyAZMkDU5J6UprF0lBd5ObknF59GYDJsxFVGko6k1a+chArYPeugJ2xvFZ9/6x97WnlbM4pksG5uCfOsfU1/ffS1noA+cjWVAM5qiU6SBcRGUxZJUSMaWrd/6h7rWO2rwFIwyu6mDwVOwxB1z5uuMnmdapxamXPDYqSVZzy2/iawyawuxOoC9gcoHIhWVbdmMbKyF+DjcP8TSnJnZBWATj+AxTYMV9GBMLX88HpxsYTWpEROn1tKVCU8h1Jj9djLmHSespTGxpKVb1pWz3RIGERNJCQvetq6PJTXsI3qhJGPxjCizZao0h9X0W+HdVnnnNn8OFAhgHsN5zIP4iGQUdttBQa3DAeSwJtSFwv85THW4UDIxDnMcLhSvBYdtbB2uEi46TMOhWCHClh3DLj8oD01k4qHCBO8PUBuAyQwHERV22D8IbfAc1nW6jG8y49UwX+FalCq16MHdomtFh2+3K2JU32zeDujO7zCHhCSdd+X+vNsssZGd8GjCsaWdPHYm8mnLSW3+FSigwsJLbCrs0V/Y41fw6K/hI47XiL4ZcfMNRnt1zEb5hG4/CfslYO2ux1Jdv/HFKOP24DdxmS3aGE7/3G1qHVMxtMYcTTmQ7vEyM6ZORsO+6gE3szawyeh9uB1G+xlR6bmZmRAtGQ3s2ClX6ceVM1stjSsvQ1WWYNa1IBmlmQqo2ORoLmdrc2aUTGjwiiSf9oDCWd4YO/CxayhBRWadJpLxyMNQ9zxKZg0arPKMYeqINFy+LSGK8G9hd4mrvLVMb5j4y885DcLvk80MoxCQgInRQPNnW5MxYzEkhVVGAe1LhBKGxkh3vequlRmRbu0ILRGlYzqTMxiFFhJT0rctMzpureuiQBXfjGYpsQdfNsqUdtjKh6NNn7B+qDE2G5EXkJIo5zyTeBiphgl2MrQTuUB65EtG5T6mF9lRhVUZBzSgB/RfcFu0gPuyR9NusK6g5eLkPbGxzUy7wSiy01D5qKEWuMFvM924evKMLL9hpoc38uICsFKIw8Rf8Gf3Kpdlts5vn3nrRhxxqd5MzYxlLC8T11R7HPyma7VuNRxamba0oRp6XTbG07uKr+QwIs0Pdlh51Rh139s5Xn4XpiHGjizWJDjBnRaKq4gZAq0QbUuo3Rprp4b74bIGflxhyyr5jCTbcFc6uCdWY+6MrP9wV7qYM1cDJNBdwvpFiHiKwvOKx73fWug83K+X+0E2UmVrKMon01Z/gUUyzhoH3a+3frYqEyQi4yStIfd9jtSO5+vztNPjJ9b13hlzr8P9dhjFugXsa2KizzssctnM861F4MNdFKeyfhJGPma4q0rxxFuiWh9ctwFk1Wqddf969J/n4XN43Ppx/kQ8ecPuD4v/IiYkOiwT8ChBCcZU8nTp8XAR1QKMN2sx59Mai8B3nTRb1gsrb1XZRp3WDHgdH194TwnPdMKYgolbl6tifeb91rTFWHk7X/NxHfvHc+TZA9oq21tLrRnc1JpXGCJRXrcxRrPfD1+/M6fdzNp1RCM/McMoR3Dmpg3GSSaSwM4xNwUwtpH5LnWNrItYMEYN32X5FxMOW5tTnw+Xb09ZT8N0w1b17Plwf0weFj84FrNbbjEn1sCWCbO9tQl/LzdmkwQdyzyWwLfFiM83GPKBkR6cr/j8/MKXrMxN0ow2lxPWvPoptYd0u0vGKrgJ73k7SWvhzI666APoANO6eOrzzVbDb+SCz/3Xx+1wmvjSHVuaWbljMqYd543hcn0MX4fj/mSTWckKGOXIy2azSrjHyaWELUbUsN03xiyLJg1p2T4Nxu2jIO1eYMcKpzrzwy5wsgMllf7hXuq2VNVmgYn+lk3ApHihK3zE42Q0kljlhs79D97vPLF6Y4fHM6y2dV27Zeqxbv3Ny05l9uMgGCoW/Vm7NEpE4R/JQqH03rdXhDMt8zUHYzapAG4b7/O8SzsEViJv1L6pPcMdFQqFwgW1ZZVpy9LSFrIJWaI2oAi5/I8LtYL8EXZAdX5zakUhcsbevhmJroyeJ1s5bIvDqcVOV3g/viFFp+8NA+1UTrtYI+vXGONiDnw4jtf7fc9cRyqh6PDY1RgL0/EiQi7TMrd7MBqpFTQld9CyYgUw5m0nwPvzy640K7N9HU1wnbVbxoS7B2WtohJSvNbOF/L7UwFkGYZlQ13+W9a4EvWUAd5i4hVboeB5ukT3WDCFsT3yk0gxYulvwQnlf4O9PkI5n4cyp7BvfCzXimUziOXGUsmCIrmRCiuL1v9pc6YtIpdyNIGSusawAwrJjxkKKOYHaIINZV5D0f/nchu5cAy57Ee53EYuT5ELn47rQzZv7mX+7YXlgZbJZCNb+WpCO1r1FYw87wy4qPGF4poa2UUj/zKjzT07JnON/S16WqgZjdwAAeVFeZ7OZaTMkzXqn2Axg8zP3STtt4KWTQbDHNwf0P4K5Qhbe+p1XpRVJpS6RFReJKzyKBMNCvUJRmHS9BzSeVlkEVioi3vdG+hy7Ho6OPIbL3yB6s9nuRnRoKe8QGvz0QlYK0HwNIy29h5dwZQaBE+DvWjei++P43H6v3P1lv6FPPUOiPDGU19F9OhphtNa/LogqS1XPa1+sXYvm/H0TmCesvzRfBK5P4rh0NoRSNwl3X9jqc5N1sM4gUflNW9kTCMQNNA36naXb//YjSYqlkvGtOOENRfV8/nNkipv3NYM9UN2d2iZODC/sUprykvx+amW2sj6Tci7A4OnqxoYq0QmJPX4wRSh1pTFcH8oTa89rdux9nqfsWQGG1iCK6AELrQoA0TniK3NBLYH8x49FX1CARrWn0ajBAZvTXxIqmA3pqMnqJvMCNIMpctvrKoT0t/D40MxmWACYmt/6AXz125xBmZ7Z19Sdu7cPPojo6Td+OSyOWNZqD3uUk20d1sYLRQwir1V8OoEp1UDRmmFegEBSyM9ayJzg31FsXt6Do5GwyiCLcBoyGHNbxOwfWjk6fnX2upzhdT2Msa2loJubA9jpGUm/KV4R2xqZE+z32kp39mv8nRri0aBGUUUaDT48Bgm2FevKdkhIOmGVk7NyejutkLSMiGBTldZI3szg4rCHoFKFwFzsoqjCkQ6640FgwuiUizkqY43GW1qJjRuTS50NCQ1X7qvl6RiBvsd6xXdnjJkVl69opVxVIsRjEQ/waq+AaraNDqmENiXSygV58U3gjHVyoK1yC68fTIq/s7Xo9CXtMyyK2MdRItURIPG1WANnuerVDodMfsTq0Z6QRTqUuZlYtVqLkgiM0St7tHIHQNJby0HX7H3CWu67XX4ihvrAe96/H59Pk7PvbKxo4ZhvjG6XO69fGmuzTilrn/34/Fw76eKgEH0AO2ACQ+MVO3kcHv8GD5FLRZzjDeeBBFqL0BomQuNVSr4efh5vF7uU3/S4Ud/et7648dBtLagC7NvjETs5+Hn8Pn8/DYeJu/vSu/kxJJUzpjk59AKKNNmGfmpFbTQvOK80rGmlI1Rvvd5+Km2hmRy/62LtjN6gnDJgqMnlYBrmtWY4bP/t2oyONIYtMOCr8Z4tCrQLzLDkUZ6HWoKGuPRcr1CNb1II7/OY3GJ8QS0oms5xkgjiw47aDTGo8+GrCQcIw3/Oo/UjvH8U7D1zF6kUWCHDSUa4wGogOtpvkjXtA4L+hrjgWgF/206KdKwq0MzzsZ4SFovowxGGs90qONrjHv5ims5kEca7HQoJ2+MR53alWrvi4ZCHXqjWXVztauJa9CJjBZojVGHz6/xKuiMNM7CXuquse537EICmc5pVI42xqOSQFZWI7pBd6i/bIxB2IavHO8jrVnuUJXTvLcJVA/kkUnUGmOoL1DFDdOlArU7jTELW6DlwTxSkWuHgvbGmMDbYKuH80hVRx0K5Rujp225wquTeqS+7B3q4RujIEy5hICnywFKIRpjj6kVXj8RRyoN6lAR0Rj7eK7YhrNnpKF9F3EZMFb88wsJZLoMYG17Y6x1+Nw3mG2ZoYD10PXZL2sIR2Jpc/Nk2TncBzoGMvpUeoyRrLLRFVvjOvmNM0m7ebIs4PNZp9Iiq2UqwIxTPhuVEOwaUg7csn4VGWd7NurzVvD7ZLDNNb9M4h8TMgDGShcGXHnlrN9bxmUkGzO07BLKcZN1pLDm0hjozh5Z7yQQ2OwxSuJfX+h2+HW+Hrho3tGYzIOxik+/TnFnVh8o0DfXGt3HXl9HeZ5I23FOxa/vX0akpVj7L2tjRwZ46f+eq+kxTNU/ODOdz0Zn7NcX0j+4Zx/8D2be9TLZGvYvx29gLXmNBm6vrqJ+bCakMVa48YtMx6FVZlGZiJEtKH8yQdhF9G8S2Df5g1G7FEX0x4nxrz0IU04YJVH1i+gPwgp5jPLr/TUWIfbL7xLofGmNTN7vrqQOssQG2R8sAORCk4P61FS19kzkWq1Rw/XbS6kPBeyh/nQsLFd6OewCTfu15hzU6yupj5TZI1kjYv1CWLhZeSZyrdacKPnNpb5ex6L8rFyVLqn2eNp8VfWt0tC7MXYZtFz01/X5u8elqhHzKfC9K38c7l/6/jcrDRXctUYy8X95I+qnYD0zjaLsP7yP11Oa+jS0RtXX//JGtBfSsfSMkS179z7UCzt24T8NCcSF1SuxfjhWEmp3pdfLWcsEydnY0urFVX63krXMBSH/8fZjXMSmFtIsLPnTPfyt9atlfFf+41Hyv1m6Wublko3G6n98D/q7B/bu/z/dwm9CX+YxZZTw//E96K8hs9fwp+HJG8vU1KqKXrP908371Qo1tbxhF/mDbUmBbVnlWmv0xdNQhZNyYM5a7R/sGS/4p6l1wK0aNNL+Uq2xHvfdK6t7CEuJWEl844V/EyjQ2D/9yUf8/ZXVR+YVNn8QO3KVFhUwR5RSWfs1cOC9nohmxja738aohlPQf1uDE2l2sUM7r+ZPgttCdB3H/lCNMJjl0h+dAsVl1KUosFzmn8QxlD4a+88JeawMbXoENFav/fZS6lhm+Qerrme5knQWbFmvxowsWLuZ5xp9x8kFeDkCq+jPxprgz76IY/moYZuAWSbwYH43rWdUCdq+ZawCb810/eNQKcIANr7NvOuuuSywQMU6HSeTVdl1oWFtQr3Rx+1zuEx6sEkNdzg+JgZE2mtQe2BvXloX2KrMjJklWYf4glkEi1WtHWveaY2AObaCyrr+GRu0fA4XXRjHvNCwpMkZjf0maw22NNHTTjYmk3mfiIYZkAZjrknyiInxiA5JSoeW7d5tv9A0HoVBWNPlfCm2d2jB6wLq5rA432F1vkPhrwvofRFLra2LyNGj5bhLaFGfuq3wGX+hbwZ02y9kF4sFqsvFpMB1pTeed8ROEH9h9wSP9qloROA9mrd7FDD7zYpw66tc7sAHNEcPaFmNz+sj2upFNJJPW6vttP3CJohYbQdlxfSAXZxhM3U1csKXL18ZE8y8ZKwq+kv/t9ZTdorwyHBNxo1/R5exSURV5K2xxOXS/6y6U9HjXzLqDie8qfJP9jNijaZanC+tUctCjaKUO23ZnRq/DIP8Jfvh0D0jGWUQFPJ2HaRNFt0oASc2FCmHB+MmfHl+9uNwVHXvObB9ybZ3XI+TIP/00R9OMpxhneON5QKCBuUZcpqYLn6ZrVHyL4CVVgBtZtGIMcidzEiH0/F6ufTCm4kZs7e4pLfGkJMBazkDlixtjekOhjr299tUF8BhWWxnJAAZrPA/oCWOuDBbZU0cWDlMUoVhRIWhsSsoQ19bROxfSdcw709j5n2pH1ciVTbNojE1tqAJsUbDbPuw2wkYVWxKhbtrMutfah1Vsr49UPa9LetVW/bWtgQzbYkB2iLFbcte25ZzOto/OuzR6zIaHeV2cz3Bv3X4N1S9tRj5tBi94G24dmshjfFE887Dl8QkGzesOq0zKrEZ3HD5euWQdHZ2xr2FKTL4th/ptm8c2L/Rd3RMCdkZVaEMVZ2FTF2Imk3fGHOwi9Hzananiak6Fr93RqKPw6o3zjR63VaaaEzHrle49D+PvfTtpK8EW1A7MBZJLMgf/Vyh97obRmK6EG8UtL28wO78xFQa3mhws/l3VzrZtiw72qLL0yZc7jZ/2Yi/8G/W2mxyI7fheB6UhiIsIDDSci/9yZk3plF1xlRNfDGgchyj8mtBG0al/6oLTHpnFCdqnXOoUZHDsmGH7nIOO7T7ZuvHZdQGzxdUu7J2TJTaWQNChieKLFk2yXhwW8nzW39QA7aOhsWuM5LmhJHn+zbdEMqC0pauDm05b6ABeltKXNqSXW1LFIYmyq7b3AjfWZmoWE3srKwzo9U7U1HA8fFP6RujUpQq0F7tLazLlrVWTgPXhwArpDZmjjXxHH8fNOdvTKwp6jWOSUVdRsEkwRzEW03suTGVaGRcKPBvdr/Mtqa3P9/v976WXeDtAS1tprvI6rnf2cNWnQ4/xFGvluJW5a3NbymscoSj1VwRq7mMRRI7bNVOMtJFsotY0GUsxt5d5KVlXaRa3Q6bXzbGBLcmluJziCoF3wkj6lpIhk/L4FujgsUgLePXoJo66xn4bV0hvyQVJLxztntLuccvSU/B75xThAUidU3BTLW1wGoB3M87mpjpsB1rE98YUC9nHC0SxCN8886xyjTXaIkgRhyN0VxNuUyl9pZuNXiGc42R8SXXqeFTVQTyOo3RMoTg65W4NELAzsquMTZ+WeBn4MfH9XTvz/t4v0vMPcOa35uRb+dhim2fZ06+JkaUvjXc56bT7BDBvP4SMlNgrKMh0rDX8ssusaDknfTHDl4N9hILJUke5I0Nc7mSevcslHxrts6Y+i0zRx2SAXnnk6p7IU1Xtu8kVH6/C9LT8DtHNdv+R88a73+5N3c+Gsj/0Tt/Z8+jEf5bk+vX5bgvQe0SC2SNqjoE/Bivl+FfO77T02GekEXLxrqLGV6qWTpgC6DR6nmG+vs6fr9/9Nz7t2N14Fv5e7c1Jyq+Mb5BP9iGtC7CVIjR3eL6fHy7VroX0xjEJZTtgXWDotA8KZIY7Wj9Amt/leP18jgMl6VClslMWGsUbz2prLCnw+Pw5XDvd6isCCMaLeUK6mPyR9rfKDtbGknt698X+YkSyzM7rGNHdYULWPkfYFOElL8BuhBhvwTXld4O3m2NGkvnBu+x0T32kvABNRWxpI98jKjRMAbBOythZtPdor1Na9xeJ7z78C+ByQhqtLNpjfYSS5tH/g2AdU7E5gAuIF8F2DnJYTMz32xKGNuIuh3Gx3A4r94l+3ZjwMgSX1pjOKu/7op/6nvmZzf1WmQ5XdtgXdGuX/5vf3xIzMgIZ6vsYIL8te8kHVhBrrHSRhMbtJkNjoQLbS7Lq8MOqWAsxy3XUTY5YPnMFmVORsFhQZ76u937h1S5tJlRIKidavL2CNYvWeQTl/7vefyplEtgDiaA64qxiZa4ynM8c3RmM4I6tmyULQn0H/2Iwpup5wK7FMutZ9RwZKPoZLvUXeztrFutM3JdDE5RsHQ00PPOuDvdDo/jB4MhR8WyJq7jpHQ9KWbI65cFFOOs/3sk25GT3Bprl7UIJYao6sMNA90SsSt2UReGghyKqAAVpAEbG5UND/eiULasWOiKWPzYY5nQsdx8KhRSQhtpbMlUNrxUXPdTmUIJuyAV8QGUnRWK7BPlWlA4LCh5FyivBXuMQwnfoOgaoCumxkX8hPLuXPZuFGTmssOjVCIbg/F5PKxWkSxmpnKGaDyNr2Cfw2xjIqqTmE7Odnab8dZ+2co9MmE6jlJjh6MFe9cQx1GDTG801tmwdA8tRz0xvbE8ioMKPLqDGKnPGU9zvnTMU9uoeS1oitulc0yxat1rJjw0oeRDkfIRxiPDjPd1vH7KgxswQXqZ2MbeKDOq5mbJ75e60xtD/Bn5lT2ac0xlaw12HscPrTEpq8Uwh8CP48d1Z9fl6SnJekKcsdYmHfzIxU5cb2DJYjr+Rai5v/kUocHWPjn193/nfS69FxgWTVa8MbVLb3dloczsHFv2VGzOZ+zOtVyFVHbxN0B7Ebzz5aRxIkel/QiMRYMrqtKQwLEu2sayIQanLMWsRPiN51Y7BpD7Cxh+GNUJt8Pjg89x1iHEWMhzOzzvQnjGCusSltN5I5O3Jp4/D+wkGGgCrQXrKrlbMTqqvPYYgvpkFJ+skANfbbvI8lTmmGLfdcjTb5pKTO2zeV9YIBVGj4qhsa15Yw5ZZtzHeLjcD3t6h9aAeffeq1QO6syiwmhfdOvHo/jWmSVJo1Glcvu4Xrj+gnV5dWUddD7jCQjzWg3qH8BYqH8b+6/DTz4Rge1qxkViHI48d8j8GbGPq4sl5vfOGqdP0F/G/vCdf3S6Olq7p21YotkWizCwR7gzcrUz7Odh/P5kq0bbsNoYLDSLbZlYYN0ltgvsKokbprQt+TQfMVUDmIEHo23UfLk1NXziCZRMmU+XsGIdrKekCfp+/OhPT94wBViNcUC5qwtbLhKzu2CMq+nFJGvA9gmszwCkAJ2Rs2MXES2FyDEylTOfz9aYjgErayrNhuC60FhPbONwHUUBbGKbJ755F0lOfsu/Y51jSXz4YD0/7fvF58RIcBRbAQoOYMtvYpowWg+AsiseW0pYVZwz6m9KsL2cUWvIniG/dbP66SDQ94Qrf4vFqc66YcmLzId35cN0HdtdjSJetQvBL45L91lv7FxhPOJ0rA7VG0WtBlsXzidTtZuVcPi9jwq7BnW+b62sgbyG+llb9ob+8PWL9Y4MFZzCPluPmDvw/ZpHg6EuoVjSevTUr6B1yKCkcodN7Jv31ptd09yOdrD25vQVQRMvnHY+RHo9W0+0FFd511SFh1X8zXtr/Nfh/BDe457VTBhrF0prDs5pOkZQ43gIWGUXMaefUFoLuH24zRkAQzLvsbwG6+0SxtUJw9dk9JFT+3XSvF4CrGUopYeulB6WSBRLy9vSW6MtAVJb5hl2lms3VgvbxOcW6xORCckd/q1UQbgWOfe2wb9tIhRzuLo8szKmqPQSowqrdobh7ptv0K2xw662jTV1wsC1jEyk+rkOR1ZjTaTQC6itH6h+rsOvaNXrsNYv7Ezb0Jb03hs97AueYgjkGmob4b01I7IiqnIq19Au7d5bD8wbZk1RReXVqUWRstHU5zZeJ3FAf7o/vzyuD66Wm/yNGVVkDo8+r/fD6cR3+6mHFEEL5lPthDb2n1JeN/WOYnhv3N2uaK5pWMRgPh2tWHqE7Bp6fPXBSm0UVEmLu4ZRd8G9+cSn4b6ri8902ruEVROAeazO2JEOLzOIz+SYy48r6214ZzgtwSQW84gLsHFlbG+nwfJ9jKo30tbX0+hxgPhFhSbumY1dewzPMbk9GKvXtDbZ0HXxnspwE+ZdrC1UNlBll6SSeFSRNNZQ6fnlPByFVc3UFZW9TuPq+mR3FmhOMxvtJlSrLVbAGjY/qHLIdwnrPqDkNnwTtqwQavmMc6TcxeHHYThPakc2xZl4Ekog5qjRku2Flcuch0nFvvq28hwLcyxDHV4qygnXFVWFD+gMFYwRUrn85/P8GHbbdmJaRVeiWhdQwQstJlmK2sN7dK/yxjqxchczyyf4GWZAmbD6BhJKgo0HjLE/3OUyxyyOgzHwG/vjcBvExtSyfFRrXODH/tT3n3ITZiqN8AbUp27UklgrHEcs1NBBANditGnzwRimbheexzC/MLAL41xF35IOz1GhQQWuMX4VF77tdeyJrRpuK7LHs0q3CRQbzE8a182x/zr2949/7kSDyTEKxhhTrHAlONvXnkyNSVl09tZt6psSLV7E75OMDUxW5N3z0+FmdGKhUFqD7cQcJ3xjfqXPy+nwKSdEYHeIor0G+dXGb1uI9QG+TZkhNvw8lS5H4/Fh7D8Pw2W4fCvKFkneJiawNTKtS7DPQ5vIQhvrG51wKmLZQMe9taZzPYbMw1OMdhaAvAU3nOa2oL+UW3T0Fq1L64J5qz437U741hcZPm/9eL9e5gGvAAcKbNvSF2D1TOZpOiUZvSYWvOpcp1G3NXO7QGqJAk/VPMl4pF8cRfiD0oOGeQHeyZATi/+dUVq+AqmmZKybQDDmQVbAnfagYRb+waga1xwTwTHXhpLA9tF4bC+YSpkF6yJhbH5T4Gp1FqxjlFH7M0vNi+78y35p8LTDQDQeSQXoKwW+owp8b6Rmxv5+fY5HfiolONYvvo8mElv/nVH/Mfb3xzhM2S3dEJlx8ljT54y15UvhtHxxXcsqDIwGIAuW0ku2Y46uzshkjf3E+fzoSwtL/mVpDslIqK7uPeJgmVgll0MHZCwEcLBxELmcbrdyA2/0PBj7H9fv/TwHRMMEatBgTE0sYNOb2QPSdaUIknM5JWej5cdk480ln3TsRmOacmcGnlll1JbpDUYj8/H6FB68vBAArCeo57nvf94mYavYsIG5LftSLOijUdV6P5yn4maum2nYHEVuyyhuniAV9RYTRGGpTCyEknfGsGiCvz8OIxdOs5Ld4FESZhQR3Q+f/X3g3wqYEVI01i3dD/ezVmSXOybdMibiJzRtQckd02gZx/f98EOEB3SXXL9I2dhLydH635KaLsnDFqnycmbHHNe2EpV0ENaBYumsw5UJ51T5UYqLMFeFowV94QMWZxW5WCjZnlAqTbEQFxnbWOqXUC6XSk1RKsc51J+lEuEgQZuKPikVmhNKKgSKKhgKvwql+AoKiQ7lbUBZlaEILqEkV6AQxLnkGnKxo8tlTOcCmAshmUv1VDZKRqZxoBU90aLqaMzMLVhqzRPrNGBM2cxwOrHDOg6Ub7MOxo1BKSMOnQEwwYuZzzKIikQvlMRkBNSclw9Sck5olQ9gO3JMD/LleTmdK4/T0nV7M8y2LgsT+C/hQ0wtMrOxTheRxKdju5R1DV2hlJHA3DHtz6jWa/GOyvaVr1Kuxfsa2z+u1omJzSYa88V3gPUyMKqkjMYgboJ7WVXFuyfah8yuUoUOZyuzMQFp1VmZNZCwf2CtOIt8AzDWBkxQukTc09g7vbFAvlSLMrs+pKhQK4P7iP1FvK4Go3RRNJoeqag7BaanWdNolLpP0NWyKpobiMYzogTcjVWa84/moLaWjqKKbKOBIAUT85F31HwbTVl6WXNK+/1NSJWNmNxjCdpyEZjlN1b3SrUwb21pH0RqRRkJk0PRtSVj5RYBrb2JhsIbX+7p+yJVUkgM17AmlsFovXDvD+PxQ2YKprZM7E0at3EE6y+nXXeWyI4xzljMs2HKMjjaw6s15v4WtOHyrb/LF5hZR7itn2OwzkwOPTkuyW/e0JOsD0aLMQH88XjcdHCWrzXmABdwpfCMzyTjzNyV5GZWLo0uEC5bA8P++BzF0ZpVshk9hmec4fHrNl6/DmKsNyx3GsxjnSHWFGUsexeMrj0CWxQLsf47CTlma3WcABcyIjLtsc2Zz0a7JQmtiIlo6SUeXRrryj8bavanzWJTateYf3g0+lsvsMS3k71uJhAvKQOjAGwvf22pUMu1RnnJgoN2l8/dCKaHpGgksPegYiyQbwUll+CzNXbdoyvDgVaNYdzaWE9m8yWkCp+e9f3mxmY0j5y7sP7oZfUsUzKgy1U0spwT6IuOXY59PmNZ5IT5mhGiZ13z9jj+GI7q7p2ZVVrEJEk0EqDC2YklSM2P/KiS5FRzYaw4meEew3S65xlhZgNmHu6Put0Om/MYShq1V/f+8UJxAPS5rR/58UpukCmidZl7/E5rQKWaRvpzNu+qCQM6imcegdMaP1nbaBlMGk6CUbyxQtbMQ1jxekkyY3LYKHxer/G4qjcd6U0bAT8GFkh7KilP1j3zY7hN8ejnrlMkazYRrYOcwMk9Hdiebj3VUUBxip9szymkdTMXkEJ8wZqLRGMJKcXUmpc3zC08GoXSFFU1mgbmGI4S32hs6UvxxVugZJq3dnB9MS0zlZ87LCt0YNTTCmgRLACjK9GtN6FxPWy1zFjxTQgo67n9Y7h99MO3D67/YVbrDq1Pw+ZjUDJ4Lm/s19bmF2kJX8pAPBi75013dO4v37jvTQKm5cWCvbA5EmBfsLyxI1iQiI2bvS+CeQ/GNurFj5/rnunHxwJEb7UyK5jHsT/IeumWdtYwyioK3n5BYRPKnBgkcLwyhNnjtsaiArWjgad14Whd7LOVBSiY+9idzp0OkNK1shUMePcGIv080xbwBuh0hBNfh7UStaYeqodMYCu9URhXOV5OnT7YCv82mtZkYvoM7JHt65RAFfJg1pjNKh2YCy9EySZrdWAmjNdYi63hnhmYGw0zMGo7KhV2LL+yWX5YaegXASGzlUnYXwTeGJIEWuSF2GaGPdsdWqa6rmTafXojkJgueLwKB13H+qu+ETNOaLvC1Y7VkHTWpMjHcPtb2VVZWUjGMvzNxWVrgIslTSiG835zacPelmCUBc53NJzkpsrqRNApK2weAFsVfLPp7wBvCG8NTRXAKCycdEm7FBnrXGzsN36/jg+FJGAOfkY3lgKlUwR0glj9nguiIAgiTWB1Rr+bRRErEutMVm1NJN36o1iS2ZJn5Wdu/X6JAmCSNYz+MGLzHvN1Vife6ULD4Xz8OIyH42Pq5rUXcnes67VVGz0jc9d4ph5Dv2YfSxtqD9Ycwa0/7rl712S2/b3xyV7S7a5hzuHRShVIcwhP/SUBO1Ak9M1CwZePWIoIqHLL1mPHdF0lcKNuMkXyNkU1b4IqJQiRxsFd0UZNQ/9N7N1nEJehzh1FE+caa27g1l9O+ubvmsxmqVGsKxBro6dlDtlG33mBLVp7tswuDBWYWITok5W74Zfh45Vah22ONdkq0xDQypCkZilYdd1YQ+upLxrPaFErImsqZhIGy5YQiWmP3ZYhQA/JrttUqFgqXUIun4wtSqdGbMJpk2kW0U3IGzvD7Du7Jdbpx2GVe+fwVxGe+gZTHI1/53qShMisRja9hfXof4pyKRbYGc057o+x7x+Ov1pWeI5+WlYXkQXSc0hWWYH+VN4qypwbiHGWl+aOiy65kL3JekysiKMCPeO0RfnqG6zUttq6M7EUX5mYHVb3Bzdc9Q+h/gg+WWNzHVlPjzILY6wiT8YiycqlxJJK6Qbsy56tQjVxiVE0znO8IGwVh78HK3MynpovbgaY2ZrtktjKNkAtrVAr0lhDZXIBxe7aNcwAM1kjTIq6L01hNWlbGQP2lHN/MGbG/nPC5wptGju0VsKUgIpPSQPQzYXKWvJCcZXPSJ3D0NejMVbra85WHasg7az7yPN47Htha9VRmZzrMNeOBo6+wTZszWbOt1VHBdzbrTyzov1sGTfY4rWTNS+7Yq6ZIKHcoIajgMtXtp4EJbbyhaknENYRNkYLo3KBXRmCazrW7sWqW17xRJ8/iuXQN8ZhTyIHW08stC3Jm/ULEhwJZ3Oyphc1ha6nlcXQbUv+e0+pfQ6a6EAeqTHaLnDgfUVHpK1FOiSFGmMBPdUX7yW7gboBZjy1ZKOJ6h58/3Zo1X+H+cAmGxNCNXl0oOWT2W2z7A9wlZumh3TMGTbGmtbJgJCzQLT6wJoK+3U5YnkWm6bMGQCtmZI1b/vrctxPfaZexuLjZKV5C+buXmnNscegJVmT+RR3HmAcnEYUSMwmq35tsp5cypQ4Kl0EN7dXa4JmQZ3qlbjpGmv6iPnuZE2a/LocFxXS8eNw+SYbnTDDdGtSGSFP/bl/SEhmdGjVkfy6HEXVEn8HNC+42edaQ5Nfl6NiX+0aZktudRYhaMordU3DbMOtO88GqrxU19Auut6cTPh1OarOq8x/A5PP6Y1Vii6DHJre6LYBG+svHofxW/+Y+hV8HmYUGrSz+klr79DH4eeeBetYVGobRI/DT4UAY3yacdF79OPnXTODb1n2oEXDlQZnPRj78jymuoN9dYDjtX+25W6Sv16fj+HyOQkl71NPasmFsyUqGIeRqoybnJYZw/wm1o7zZzosYwL+cT1eP2+Hyy+RGmGVJh3KWpJRvLOTQwI70/jCp7hoPCjNgP+Unznxsmnjoj5jadxey2wtW2NVzQxX7Q/rGta4IRkzeDOolvlpO6bONwZKe2OSQK2d8ta6yhghPa63gcVvbcMIM2OR7H6ZYTr2zqgrmmF2TEnL1GttQKt246l4Rp37jXNU9gHKWdu1Rm3zYzwcv0+lUlLC7xp6+vLJSAkyPP6J6STOmDLIRm9UDqzE/5RIwxbAjXXWUPT98s2KksC6Aa6Y+y7qkyk8Wx2Ne8vWQY2rjBhN5oyZ4xntaz8eLtf5wLLzuvWUyonGTJd8dx1ViXuH7RkcmgFba7ufFzT/3WVau8jmqfEDEUStNH7qGU9ngLEkhKBi2ws+EehG2xqVes/Lx2EyuDj143gdv1xPv/gyTAOrFivbO9ShYgsQ35S/+SZtOmY8NBnXjedleOyyu5nJLNDVxWG63gEGVNEYsz0v5+vx+1whrbDP1NKzlEcXe5lsDH2fk9jueLj3uoKD7pfWGlzRWb5jHLnDTmjoseOxE7gH45b3HM/9XMPEA1lqwuBa6xvYWduyIsxgHBJTNePn83yYSoRUQzrGI2Jbde+Medbnva9QXInRClh16NJG2pamMj5gziwY4/DdUathjYCSUcelZ0Qc6+4BRrNfxKr597AOH2CsnEFUkRhmKszNLgNV9C60SOQURbuLxczMRdTMoCTH4Sx1GY2oM5673NaeDhXyEbWHqCXwCXlAMEoqK0lVOuAzVrJn6xr1KplKlTf4mhr7zBRZ+kCLj1o0ZcJuPA6V5bG4WLmEG0KO2+vcJBcogtlolU2QgX5iYNSFzPd8+XrlL5jmflGslY2efJotW6AJj7ZwDy26qGccpxkFMthpz7WbexWuDM3W3RTtz1H24cHI8GMsNbnqKlI7XrwKRsHUPptOrZnwWX025mlrWXSqK8KuU40xl7aBHo7j9X5XqBG6nXYtMtbGvBq6WrI9j3V4ac1rHe9rxsQ+0XhgfN5HGfBmprqxFt78OJwHKaXitgXo2IcuerZX9uNwfvIjO8tSoAuey1gdFVGhBcZK0fkiumlmisx+HwPStJkgYmvdsEVGxqqY+cL8QEwtsF02mkQrfjaZtdvAPm8OcK5FjKnBeOZaL6Pok1lkhB8b1fjeYymCN9Kf67UwuS/iA2bsZiw7XCHP/Y/+XE637JWx6NMay6yoassf51hbMWuZcenPJiXlrmF5WKPU5Ec/fhHpXLaEG5fcH0P/9+F81q3xgPm+WK3IV0itSyEAU9pgVBCMKb8fw30Q9QvAyvKDUar3d//l43r9Lr4D894yKm5XJM3ol2m3jFEbhZODjtVpGDNUK57YpanfwKYbMtYvFUhlo6aSIax6bYwf9+eNL9Esb411P24LKjGh5jG+Qm9P51Hl67ezAd6Txx0Gm8o49JR1AXsIBez5GFAyETfv4tLG0qFxqEsoH0tbi2sc6IDhL2x/QyfdjPeSUZmMbq9uC6c7PMV0+F621pcdNg5rcPdssHVus7W+2pyXsR2nC/gL/VGw2Mm7bqta3pqb4i/UWflyL34jvrEhlw94Porb7r61SA1bMgbVWogXt30OTc4jxsrY8Mqjna/fmqQnbFqPleEe+3L5zRsHjKmFn7dlqPJJz7Yw44yakQZh4R+ocV/e9F9GlyXEVKYp1X1hKXhjXDp/3m4HXhvXUiLR5a23l/nxKwQlM78Bo+3Wv7gvRmJdtxzOZ2/xbfvPf/x1G25zIvavf/+P//yf//l/Esn/qQ=="; \ No newline at end of file +window.searchData = "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"; \ No newline at end of file diff --git a/docs/classes/CancellationError.html b/docs/classes/CancellationError.html new file mode 100644 index 00000000..9dff797e --- /dev/null +++ b/docs/classes/CancellationError.html @@ -0,0 +1,86 @@ +CancellationError | ordercloud-javascript-sdk
+
ordercloud-javascript-sdk + +
    +
    +
    Preparing search index...
    +
    +
    +
    + +

    Class CancellationError

    +
    +

    Thrown when a caller aborts a request through requestOptions.signal. +This is not an OrderCloud API error.

    +
    +
    +

    Hierarchy

    +
      +
    • Error +
        +
      • CancellationError
    +
    +
    +
    +
    Index
     +
    +
    + +
    constructor +
    +
    + +
    isCancellation +
    +
    + +
    +
    + +
      +
    • + +
      +
      +

      Parameters

      +
        +
      • message: string = 'This request was cancelled'
      +

      Returns CancellationError

    +
    + +
    +
    + +
    isCancellation: true = ...
    +
    +
    +
    +
    +

    Settings

     +
    +
    Member Visibility +
      +
      • +
    +
    +
    +

    On This Page

     +
    +
    Constructors +
    +
    Properties +
    +
    +
    +
    diff --git a/docs/classes/OrderCloudError.html b/docs/classes/OrderCloudError.html index 22372d6d..953b1fa7 100644 --- a/docs/classes/OrderCloudError.html +++ b/docs/classes/OrderCloudError.html @@ -10,7 +10,7 @@

    Class OrderCloudError

    -
    +

    Hierarchy

    • Error diff --git a/docs/classes/Resources.Addresses.html b/docs/classes/Resources.Addresses.html index 879c57ab..ff21cc19 100644 --- a/docs/classes/Resources.Addresses.html +++ b/docs/classes/Resources.Addresses.html @@ -81,12 +81,12 @@
      Optional

      Alternative token to the one stored in the sdk instance (useful for impersonation).

    • -
      OptionalcancelToken?: CancelToken
      -

      Axios cancelToken that can be used to cancel the request.

      -
      • -
    • OptionalrequestType?: string

      Identify the type of request. Useful for error logs.

      +
      • +
    • +
      Optionalsignal?: AbortSignal
      +

      AbortSignal that can be used to cancel the request.

    Returns Promise<RequiredDeep<TAddress>>

    @@ -49,7 +49,7 @@
    • - +

      Parameters

      @@ -63,19 +63,19 @@

      Parameters

    • OptionalcustomRoles: string[]

      optional custom roles being requested - string array

      • -
    • requestOptions: { anonuserid?: string; cancelToken?: CancelToken; requestType?: string } = {} +
    • requestOptions: { anonuserid?: string; requestType?: string; signal?: AbortSignal } = {}
      • Optionalanonuserid?: string

        Provide an externally generated id to track this user session, used specifically for the tracking events feature for integrating with Send and Discover

      • -
        OptionalcancelToken?: CancelToken
        -

        Provide an axios cancelToken that can be used to cancel the request.

        -
        • -
      • OptionalrequestType?: string

        Provide a value that can be used to identify the type of request. Useful for error logs.

        +
        • +
      • +
        Optionalsignal?: AbortSignal
        +

        Provide an AbortSignal that can be used to cancel the request.

    Returns Promise<RequiredObjectDeep<AccessToken>>

    @@ -83,12 +83,12 @@

    Returns PromiseDescription

    allow users to browse your catalog without signing in - must have anonymous template user set in dashboard

    +
  • Defined in api/Auth.ts:232
    • - +

      Parameters

      @@ -105,15 +105,15 @@

      Parameters

    • OptionalcustomRoles: string[]

      optional custom roles being requested - string array

      • -
    • requestOptions: { cancelToken?: CancelToken; requestType?: string } = {} +
    • requestOptions: { requestType?: string; signal?: AbortSignal } = {}
      • -
        OptionalcancelToken?: CancelToken
        -

        Provide an axios cancelToken that can be used to cancel the request.

        -
        • -
      • OptionalrequestType?: string

        Provide a value that can be used to identify the type of request. Useful for error logs.

        +
        • +
      • +
        Optionalsignal?: AbortSignal
        +

        Provide an AbortSignal that can be used to cancel the request.

    Returns Promise<RequiredObjectDeep<AccessToken>>

    @@ -121,12 +121,12 @@

    Returns PromiseDescription

    this workflow is best suited for a backend system

    +
  • Defined in api/Auth.ts:163
    • - +

      Parameters

      @@ -149,15 +149,15 @@

      Parameters

    • OptionalcustomRoles: string[]

      optional custom roles being requested - string array

      • -
    • requestOptions: { cancelToken?: CancelToken; requestType?: string } = {} +
    • requestOptions: { requestType?: string; signal?: AbortSignal } = {}
      • -
        OptionalcancelToken?: CancelToken
        -

        Provide an axios cancelToken that can be used to cancel the request.

        -
        • -
      • OptionalrequestType?: string

        Provide a value that can be used to identify the type of request. Useful for error logs.

        +
        • +
      • +
        Optionalsignal?: AbortSignal
        +

        Provide an AbortSignal that can be used to cancel the request.

    Returns Promise<RequiredObjectDeep<AccessToken>>

    @@ -165,12 +165,12 @@

    Returns PromiseDescription

    similar to login except client secret is also required, adding another level of security

    +
  • Defined in api/Auth.ts:112
    • - +

      Parameters

      @@ -188,15 +188,15 @@

      Parameters

    • OptionalcustomRoles: string[]

      optional custom roles being requested - string array

      • -
    • requestOptions: { cancelToken?: CancelToken; requestType?: string } = {} +
    • requestOptions: { requestType?: string; signal?: AbortSignal } = {}
      • -
        OptionalcancelToken?: CancelToken
        -

        Provide an axios cancelToken that can be used to cancel the request.

        -
        • -
      • OptionalrequestType?: string

        Provide a value that can be used to identify the type of request. Useful for error logs.

        +
        • +
      • +
        Optionalsignal?: AbortSignal
        +

        Provide an AbortSignal that can be used to cancel the request.

    Returns Promise<RequiredObjectDeep<AccessToken>>

    @@ -204,12 +204,12 @@

    Returns PromiseDescription

    this workflow is most appropriate for client apps where user is a human, ie a registered user

    +
  • Defined in api/Auth.ts:61
    • - +

      Parameters

      @@ -220,15 +220,15 @@

      Parameters

    • clientID: string

      of the application the user is logging into

      • -
    • requestOptions: { cancelToken?: CancelToken; requestType?: string } = {} +
    • requestOptions: { requestType?: string; signal?: AbortSignal } = {}
      • -
        OptionalcancelToken?: CancelToken
        -

        Provide an axios cancelToken that can be used to cancel the request.

        -
        • -
      • OptionalrequestType?: string

        Provide a value that can be used to identify the type of request. Useful for error logs.

        +
        • +
      • +
        Optionalsignal?: AbortSignal
        +

        Provide an AbortSignal that can be used to cancel the request.

    Returns Promise<RequiredObjectDeep<AccessToken>>

    @@ -236,7 +236,7 @@

    Returns PromiseDescription

    extend your users' session by getting a new access token with a refresh token. refresh tokens must be enabled in the dashboard

    +
  • Defined in api/Auth.ts:206
    • diff --git a/docs/classes/Resources.BundleLineItems.html b/docs/classes/Resources.BundleLineItems.html index 54c1e8cf..5f02d822 100644 --- a/docs/classes/Resources.BundleLineItems.html +++ b/docs/classes/Resources.BundleLineItems.html @@ -78,12 +78,12 @@
    Optional

    Alternative token to the one stored in the sdk instance (useful for impersonation).

  • -
    OptionalcancelToken?: CancelToken
    -

    Axios cancelToken that can be used to cancel the request.

    -
    • -
  • OptionalrequestType?: string

    Identify the type of request. Useful for error logs.

    +
    • +
  • +
    Optionalsignal?: AbortSignal
    +

    AbortSignal that can be used to cancel the request.

    • Returns Promise<RequiredDeep<TLineItem>>

  • -
    OptionalcancelToken?: CancelToken
    -

    Axios cancelToken that can be used to cancel the request.

    -
    • -
  • OptionalrequestType?: string

    Identify the type of request. Useful for error logs.

    +
    • +
  • +
    Optionalsignal?: AbortSignal
    +

    AbortSignal that can be used to cancel the request.

    • Returns Promise<void>