From cb42648d76a6e6475ce484dce33ff93f633eb66a Mon Sep 17 00:00:00 2001 From: David Grayston Date: Fri, 20 Sep 2019 19:00:09 +0100 Subject: [PATCH 01/47] SDK-604: Add Sandbox Client --- index.js | 11 ++ src/request/request.builder.js | 20 ++- src/sandbox/client.builder.js | 45 +++++++ src/sandbox/client.js | 34 +++++ src/sandbox/index.js | 11 ++ .../request/attribute/anchor.builder.js | 35 ++++++ .../profile/request/attribute/anchor.js | 43 +++++++ .../request/attribute/attribute.builder.js | 46 +++++++ .../profile/request/attribute/attribute.js | 43 +++++++ .../derivation/age.verification.builder.js | 41 +++++++ .../attribute/derivation/age.verification.js | 27 ++++ src/sandbox/profile/request/token.builder.js | 116 ++++++++++++++++++ src/sandbox/profile/request/token.js | 17 +++ src/sandbox/profile/response/token.js | 13 ++ 14 files changed, 496 insertions(+), 6 deletions(-) create mode 100644 src/sandbox/client.builder.js create mode 100644 src/sandbox/client.js create mode 100644 src/sandbox/index.js create mode 100644 src/sandbox/profile/request/attribute/anchor.builder.js create mode 100644 src/sandbox/profile/request/attribute/anchor.js create mode 100644 src/sandbox/profile/request/attribute/attribute.builder.js create mode 100644 src/sandbox/profile/request/attribute/attribute.js create mode 100644 src/sandbox/profile/request/attribute/derivation/age.verification.builder.js create mode 100644 src/sandbox/profile/request/attribute/derivation/age.verification.js create mode 100644 src/sandbox/profile/request/token.builder.js create mode 100644 src/sandbox/profile/request/token.js create mode 100644 src/sandbox/profile/response/token.js diff --git a/index.js b/index.js index cb7ec206..6b54f421 100644 --- a/index.js +++ b/index.js @@ -5,6 +5,13 @@ const { AmlAddress, AmlProfile } = require('./src/aml_type'); const { RequestBuilder } = require('./src/request/request.builder'); const { Payload } = require('./src/request/payload'); +const { + SandboxClientBuilder, + SandboxAttributeBuilder, + SandboxAnchorBuilder, + TokenRequestBuilder, +} = require('./src/sandbox'); + const { DynamicScenarioBuilder, DynamicPolicyBuilder, @@ -32,4 +39,8 @@ module.exports = { SourceConstraintBuilder, RequestBuilder, Payload, + SandboxClientBuilder, + SandboxAttributeBuilder, + SandboxAnchorBuilder, + TokenRequestBuilder, }; diff --git a/src/request/request.builder.js b/src/request/request.builder.js index ef043bb7..c7de5730 100644 --- a/src/request/request.builder.js +++ b/src/request/request.builder.js @@ -55,23 +55,31 @@ class RequestBuilder { } /** - * @param {string} pem + * @param {Buffer} pem * * @returns {RequestBuilder} */ - withPemString(pem) { + withPem(pem) { this.pem = pem; return this; } + /** + * @param {string} pemString + * + * @returns {RequestBuilder} + */ + withPemString(pemString) { + return this.withPem(Buffer.from(pemString, 'utf8')); + } + /** * @param {string} filePath * * @returns {RequestBuilder} */ withPemFilePath(filePath) { - this.pem = fs.readFileSync(filePath, 'utf8'); - return this; + return this.withPem(fs.readFileSync(filePath, 'utf8')); } /** @@ -150,14 +158,14 @@ class RequestBuilder { } /** - * @returns {SignedRequest} + * @returns {YotiRequest} */ build() { if (!this.baseUrl) { throw new Error('Base URL must be specified'); } if (!this.pem) { - throw new Error('PEM file path or string must be provided'); + throw new Error('PEM Buffer, string or file path must be provided'); } // Merge provided query params with nonce and timestamp. diff --git a/src/sandbox/client.builder.js b/src/sandbox/client.builder.js new file mode 100644 index 00000000..d06245c3 --- /dev/null +++ b/src/sandbox/client.builder.js @@ -0,0 +1,45 @@ + +const { SandboxClient } = require('./client'); +const fs = require('fs'); + +/** + * @class SandboxClientBuilder + */ +class SandboxClientBuilder { + constructor() { + this.sdkId = null; + this.pem = null; + this.sandboxUrl = null; + } + + forApplication(sdkId) { + this.sdkId = sdkId; + return this; + } + + withPem(pem) { + this.pem = pem; + return this; + } + + withPemString(pemString) { + return this.withPem(Buffer.from(pemString, 'utf8')); + } + + withPemFile(pemFile) { + return this.withPem(fs.readFileSync(pemFile, 'utf8')); + } + + withSandboxUrl(sandboxUrl) { + this.sandboxUrl = sandboxUrl; + return this; + } + + build() { + return new SandboxClient(this.sdkId, this.pem, this.sandboxUrl); + } +} + +module.exports = { + SandboxClientBuilder, +}; diff --git a/src/sandbox/client.js b/src/sandbox/client.js new file mode 100644 index 00000000..ec5b27a7 --- /dev/null +++ b/src/sandbox/client.js @@ -0,0 +1,34 @@ + +const { RequestBuilder } = require('../request/request.builder'); +const { TokenResponse } = require('./profile/response/token'); +const { Payload } = require('../request/payload'); + +/** + * @class SandboxClient + */ +class SandboxClient { + constructor(sdkId, pem, sandboxUrl) { + this.sdkId = sdkId; + this.pem = pem; + this.sandboxUrl = sandboxUrl; + this.endpoint = `/apps/${sdkId}/tokens`; + } + + async setupSharingProfile(tokenRequest) { + const response = await (new RequestBuilder()) + .withBaseUrl(this.sandboxUrl) + .withEndpoint(this.endpoint) + .withPem(this.pem) + .withPayload(new Payload(tokenRequest)) + .withPost() + .build() + .execute(); + + const tokenResponse = new TokenResponse(response.getParsedResponse()); + return tokenResponse.getToken(); + } +} + +module.exports = { + SandboxClient, +}; diff --git a/src/sandbox/index.js b/src/sandbox/index.js new file mode 100644 index 00000000..c51f684e --- /dev/null +++ b/src/sandbox/index.js @@ -0,0 +1,11 @@ +const { SandboxClientBuilder } = require('./client.builder'); +const { SandboxAttributeBuilder } = require('./profile/request/attribute/attribute.builder'); +const { SandboxAnchorBuilder } = require('./profile/request/attribute/anchor.builder'); +const { TokenRequestBuilder } = require('./profile/request/token.builder'); + +module.exports = { + SandboxClientBuilder, + SandboxAttributeBuilder, + SandboxAnchorBuilder, + TokenRequestBuilder, +}; diff --git a/src/sandbox/profile/request/attribute/anchor.builder.js b/src/sandbox/profile/request/attribute/anchor.builder.js new file mode 100644 index 00000000..b0e48913 --- /dev/null +++ b/src/sandbox/profile/request/attribute/anchor.builder.js @@ -0,0 +1,35 @@ +const { SandboxAnchor } = require('./anchor'); + +class SandboxAnchorBuilder { + constructor() { + this.anchors = []; + } + + withType(type) { + this.type = type; + return this; + } + + withValue(value) { + this.value = value; + return this; + } + + withSubType(subType) { + this.subType = subType; + return this; + } + + withTimestamp(timestamp) { + this.timestamp = timestamp; + return this; + } + + build() { + return new SandboxAnchor(this.type, this.value, this.subType, this.timestamp); + } +} + +module.exports = { + SandboxAnchorBuilder, +}; diff --git a/src/sandbox/profile/request/attribute/anchor.js b/src/sandbox/profile/request/attribute/anchor.js new file mode 100644 index 00000000..4969b032 --- /dev/null +++ b/src/sandbox/profile/request/attribute/anchor.js @@ -0,0 +1,43 @@ +class SandboxAnchor { + constructor(name, value, derivation, optional, anchors = []) { + this.name = name; + this.value = value; + this.derivation = derivation; + this.optional = optional; + this.anchors = anchors; + } + + getName() { + return this.name; + } + + getValue() { + return this.value; + } + + getDerivation() { + return this.derivation; + } + + getOptional() { + return this.optional; + } + + getAnchors() { + return this.anchors; + } + + toJSON() { + return { + name: this.name, + value: this.value, + derivation: this.derivation, + optional: this.optional, + anchors: this.anchors, + }; + } +} + +module.exports = { + SandboxAnchor, +}; diff --git a/src/sandbox/profile/request/attribute/attribute.builder.js b/src/sandbox/profile/request/attribute/attribute.builder.js new file mode 100644 index 00000000..ac28a878 --- /dev/null +++ b/src/sandbox/profile/request/attribute/attribute.builder.js @@ -0,0 +1,46 @@ +const { SandboxAttribute } = require('./attribute'); + +class SandboxAttributeBuilder { + constructor() { + this.anchors = []; + } + + withName(name) { + this.name = name; + return this; + } + + withValue(value) { + this.value = value; + return this; + } + + withDerivation(derivation) { + this.derivation = derivation; + return this; + } + + withOptional(optional) { + this.optional = optional; + return this; + } + + withAnchors(anchors) { + this.anchors = anchors; + return this; + } + + build() { + return new SandboxAttribute( + this.name, + this.value, + this.derivation, + this.optional, + this.anchors + ); + } +} + +module.exports = { + SandboxAttributeBuilder, +}; diff --git a/src/sandbox/profile/request/attribute/attribute.js b/src/sandbox/profile/request/attribute/attribute.js new file mode 100644 index 00000000..c65daa38 --- /dev/null +++ b/src/sandbox/profile/request/attribute/attribute.js @@ -0,0 +1,43 @@ +class SandboxAttribute { + constructor(name, value, derivation, optional, anchors = []) { + this.name = name; + this.value = value; + this.derivation = derivation; + this.optional = optional; + this.anchors = anchors; + } + + getName() { + return this.name; + } + + getValue() { + return this.value; + } + + getDerivation() { + return this.derivation; + } + + getOptional() { + return this.optional; + } + + getAnchors() { + return this.anchors; + } + + toJSON() { + return { + name: this.name, + value: this.value, + derivation: this.derivation, + optional: this.optional, + anchors: this.anchors, + }; + } +} + +module.exports = { + SandboxAttribute, +}; diff --git a/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js b/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js new file mode 100644 index 00000000..cc86b368 --- /dev/null +++ b/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js @@ -0,0 +1,41 @@ +const { SandboxAgeVerification } = require('./age.verification'); +const Validation = require('../../../../../yoti_common/validation'); +const constants = require('../../../../../yoti_common/constants'); + +class SandboxAgeVerificationBuilder { + withDateOfBirth(value) { + Validation.notNull(value, 'dateOfBirth'); + this.dateOfBirth = value; + return this; + } + + withAgeOver(value) { + Validation.isInteger(value); + return this.withDerivation(constants.ATTR_AGE_OVER + value); + } + + withAgeUnder(value) { + Validation.isInteger(value); + return this.withDerivation(constants.ATTR_AGE_UNDER + value); + } + + withDerivation(value) { + Validation.notNull(value, 'derivation'); + this.derivation = value; + return this; + } + + withAnchors(anchors) { + Validation.notNull(anchors, 'anchors'); + this.anchors = anchors; + return this; + } + + build() { + return new SandboxAgeVerification(this.dateOfBirth, this.derivation, this.anchors); + } +} + +module.exports = { + SandboxAgeVerificationBuilder, +}; diff --git a/src/sandbox/profile/request/attribute/derivation/age.verification.js b/src/sandbox/profile/request/attribute/derivation/age.verification.js new file mode 100644 index 00000000..09de1110 --- /dev/null +++ b/src/sandbox/profile/request/attribute/derivation/age.verification.js @@ -0,0 +1,27 @@ +const { SandboxAttributeBuilder } = require('../attribute.builder'); +const Validation = require('../../../../../yoti_common/validation'); +const constants = require('../../../../../yoti_common/constants'); + +class SandboxAgeVerification { + constructor(dateOfBirth, supportedAgeDerivation, anchors) { + Validation.notNull(dateOfBirth, 'dateOfBirth'); + Validation.notNull(supportedAgeDerivation, 'derivation'); + + this.dateOfBirth = dateOfBirth; + this.supportedAgeDerivation = supportedAgeDerivation; + this.anchors = anchors; + } + + toAttribute() { + return new SandboxAttributeBuilder() + .withName(constants.ATTR_DATE_OF_BIRTH) + .withValue(this.dateOfBirth) + .withDerivation(this.supportedAgeDerivation) + .withAnchors(this.anchors) + .build(); + } +} + +module.exports = { + SandboxAgeVerification, +}; diff --git a/src/sandbox/profile/request/token.builder.js b/src/sandbox/profile/request/token.builder.js new file mode 100644 index 00000000..69cdc514 --- /dev/null +++ b/src/sandbox/profile/request/token.builder.js @@ -0,0 +1,116 @@ +const { TokenRequest } = require('./token'); +const { SandboxAttributeBuilder } = require('./attribute/attribute.builder'); +const constants = require('../../../yoti_common/constants'); + +const createAttribute = ( + name, + value, + anchors = [] +) => new SandboxAttributeBuilder() + .withName(name) + .withValue(value) + .withAnchors(anchors) + .build(); + +class TokenRequestBuilder { + constructor() { + this.attributes = {}; + } + + withRememberMeId(value) { + this.rememberMeId = value; + return this; + } + + withAttribute(sandboxAttribute) { + const key = sandboxAttribute.getDerivation() != null ? + sandboxAttribute.getDerivation() : sandboxAttribute.getName(); + this.attributes[key] = sandboxAttribute; + return this; + } + + withGivenNames(value, anchors = []) { + const sandboxAttribute = createAttribute(constants.ATTR_GIVEN_NAMES, value, anchors); + return this.withAttribute(sandboxAttribute); + } + + withFamilyName(value, anchors = []) { + const sandboxAttribute = createAttribute(constants.ATTR_FAMILY_NAME, value, anchors); + return this.withAttribute(sandboxAttribute); + } + + withFullName(value, anchors = []) { + const sandboxAttribute = createAttribute(constants.ATTR_FULL_NAME, value, anchors); + return this.withAttribute(sandboxAttribute); + } + + withDateOfBirth(value, anchors = []) { + const sandboxAttribute = createAttribute(constants.ATTR_DATE_OF_BIRTH, value, anchors); + return this.withAttribute(sandboxAttribute); + } + + withAgeVerification(sandboxAgeVerification) { + return this.withAttribute(sandboxAgeVerification.toAttribute()); + } + + withGender(value, anchors = []) { + const sandboxAttribute = createAttribute(constants.ATTR_GENDER, value, anchors); + return this.withAttribute(sandboxAttribute); + } + + withPhoneNumber(value, anchors = []) { + const sandboxAttribute = createAttribute(constants.ATTR_PHONE_NUMBER, value, anchors); + return this.withAttribute(sandboxAttribute); + } + + withNationality(value, anchors = []) { + const sandboxAttribute = createAttribute(constants.ATTR_NATIONALITY, value, anchors); + return this.withAttribute(sandboxAttribute); + } + + withPostalAddress(value, anchors = []) { + const sandboxAttribute = createAttribute(constants.ATTR_POSTAL_ADDRESS, value, anchors); + return this.withAttribute(sandboxAttribute); + } + + withStructuredPostalAddress(value, anchors = []) { + const sandboxAttribute = this + .createAttribute(constants.ATTR_STRUCTURED_POSTAL_ADDRESS, value, anchors); + return this.withAttribute(sandboxAttribute); + } + + withSelfie(value, anchors = []) { + return this.withBase64Selfie(value, anchors); + } + + withBase64Selfie(value, anchors = []) { + const sandboxAttribute = createAttribute(constants.ATTR_SELFIE, value, anchors); + return this.withAttribute(sandboxAttribute); + } + + withEmailAddress(value, anchors = []) { + const sandboxAttribute = createAttribute(constants.ATTR_EMAIL_ADDRESS, value, anchors); + return this.withAttribute(sandboxAttribute); + } + + withDocumentDetails(value, anchors = []) { + const sandboxAttribute = new SandboxAttributeBuilder() + .withName(constants.ATTR_DOCUMENT_DETAILS) + .withValue(value) + .withOptional(true) + .withAnchors(anchors) + .build(); + return this.withAttribute(sandboxAttribute); + } + + build() { + return new TokenRequest( + this.rememberMeId, + Object.keys(this.attributes).map(k => this.attributes[k]) + ); + } +} + +module.exports = { + TokenRequestBuilder, +}; diff --git a/src/sandbox/profile/request/token.js b/src/sandbox/profile/request/token.js new file mode 100644 index 00000000..c4b08b81 --- /dev/null +++ b/src/sandbox/profile/request/token.js @@ -0,0 +1,17 @@ +class TokenRequest { + constructor(rememberMeId, sandboxAttributes) { + this.rememberMeId = rememberMeId; + this.sandboxAttributes = sandboxAttributes; + } + + toJSON() { + return { + remember_me_id: this.rememberMeId, + profile_attributes: this.sandboxAttributes, + }; + } +} + +module.exports = { + TokenRequest, +}; diff --git a/src/sandbox/profile/response/token.js b/src/sandbox/profile/response/token.js new file mode 100644 index 00000000..b7d3625b --- /dev/null +++ b/src/sandbox/profile/response/token.js @@ -0,0 +1,13 @@ +class TokenResponse { + constructor(responseData) { + this.token = responseData.token; + } + + getToken() { + return this.token; + } +} + +module.exports = { + TokenResponse, +}; From 6fb6405b6bff560ab46de150ef45a48bc0f60508 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Mon, 23 Sep 2019 12:14:17 +0100 Subject: [PATCH 02/47] SDK-604: Support older Node versions --- src/request/request.builder.js | 17 ++++--------- src/sandbox/client.builder.js | 37 ++++++++++++++++++++++++++-- src/sandbox/client.js | 44 +++++++++++++++++++++++++++------- 3 files changed, 75 insertions(+), 23 deletions(-) diff --git a/src/request/request.builder.js b/src/request/request.builder.js index c7de5730..ee355230 100644 --- a/src/request/request.builder.js +++ b/src/request/request.builder.js @@ -55,31 +55,22 @@ class RequestBuilder { } /** - * @param {Buffer} pem + * @param {string} pem * * @returns {RequestBuilder} */ - withPem(pem) { + withPemString(pem) { this.pem = pem; return this; } - /** - * @param {string} pemString - * - * @returns {RequestBuilder} - */ - withPemString(pemString) { - return this.withPem(Buffer.from(pemString, 'utf8')); - } - /** * @param {string} filePath * * @returns {RequestBuilder} */ withPemFilePath(filePath) { - return this.withPem(fs.readFileSync(filePath, 'utf8')); + return this.withPemString(fs.readFileSync(filePath, 'utf8')); } /** @@ -165,7 +156,7 @@ class RequestBuilder { throw new Error('Base URL must be specified'); } if (!this.pem) { - throw new Error('PEM Buffer, string or file path must be provided'); + throw new Error('PEM file path or string must be provided'); } // Merge provided query params with nonce and timestamp. diff --git a/src/sandbox/client.builder.js b/src/sandbox/client.builder.js index d06245c3..866c4e5a 100644 --- a/src/sandbox/client.builder.js +++ b/src/sandbox/client.builder.js @@ -1,40 +1,73 @@ const { SandboxClient } = require('./client'); +const Validation = require('../yoti_common/validation'); const fs = require('fs'); /** * @class SandboxClientBuilder */ class SandboxClientBuilder { + /** + * Setup default property values. + */ constructor() { this.sdkId = null; this.pem = null; this.sandboxUrl = null; } + /** + * @param {string} sdkId + */ forApplication(sdkId) { this.sdkId = sdkId; return this; } + /** + * @param {Buffer} pem + * + * @returns {SandboxClientBuilder} + */ withPem(pem) { + Validation.instanceOf(pem, Buffer, 'pem'); this.pem = pem; return this; } + /** + * @param {string} pemString + * + * @returns {SandboxClientBuilder} + */ withPemString(pemString) { + Validation.isString(pemString, 'pemString'); return this.withPem(Buffer.from(pemString, 'utf8')); } - withPemFile(pemFile) { - return this.withPem(fs.readFileSync(pemFile, 'utf8')); + /** + * @param {string} filePath + * + * @returns {SandboxClientBuilder} + */ + withPemFilePath(filePath) { + Validation.isString(filePath, 'filePath'); + return this.withPem(fs.readFileSync(filePath, 'utf8')); } + /** + * @param {string} sandboxUrl + * + * @returns {SandboxClientBuilder} + */ withSandboxUrl(sandboxUrl) { this.sandboxUrl = sandboxUrl; return this; } + /** + * @returns {SandboxClient} + */ build() { return new SandboxClient(this.sdkId, this.pem, this.sandboxUrl); } diff --git a/src/sandbox/client.js b/src/sandbox/client.js index ec5b27a7..e4611afe 100644 --- a/src/sandbox/client.js +++ b/src/sandbox/client.js @@ -2,30 +2,58 @@ const { RequestBuilder } = require('../request/request.builder'); const { TokenResponse } = require('./profile/response/token'); const { Payload } = require('../request/payload'); +const Validation = require('../yoti_common/validation'); /** * @class SandboxClient */ class SandboxClient { + /** + * @param {string} sdkId + * @param {Buffer} pem + * @param {string} sandboxUrl + */ constructor(sdkId, pem, sandboxUrl) { + Validation.isString(sdkId, 'sdkId'); this.sdkId = sdkId; + this.endpoint = `/apps/${sdkId}/tokens`; + + Validation.instanceOf(pem, Buffer, 'pem'); this.pem = pem; + + Validation.isString(sandboxUrl, 'sandboxUrl'); this.sandboxUrl = sandboxUrl; - this.endpoint = `/apps/${sdkId}/tokens`; } - async setupSharingProfile(tokenRequest) { - const response = await (new RequestBuilder()) + /** + * @param {TokenRequest} tokenRequest + * + * @returns {Promise} + */ + setupSharingProfile(tokenRequest) { + const request = (new RequestBuilder()) .withBaseUrl(this.sandboxUrl) .withEndpoint(this.endpoint) - .withPem(this.pem) + .withPemString(this.pem) .withPayload(new Payload(tokenRequest)) .withPost() - .build() - .execute(); + .build(); - const tokenResponse = new TokenResponse(response.getParsedResponse()); - return tokenResponse.getToken(); + return new Promise((resolve, reject) => { + request.execute() + .then((response) => { + try { + return resolve(new TokenResponse(response.getParsedResponse())); + } catch (err) { + console.log(`Error getting response data: ${err}`); + return reject(err); + } + }) + .catch((err) => { + console.log(`Error retrieving requested data: ${err}`); + return reject(err); + }); + }); } } From ecf101f5c9651e73dd399840b84506edb48a57ca Mon Sep 17 00:00:00 2001 From: David Grayston Date: Mon, 23 Sep 2019 17:08:30 +0100 Subject: [PATCH 03/47] SDK-604: Add method documentation and correct SandboxAnchor implementation --- src/client/index.js | 34 ++++++ .../request/attribute/anchor.builder.js | 21 ++++ .../profile/request/attribute/anchor.js | 56 +++++---- .../request/attribute/attribute.builder.js | 24 ++++ .../profile/request/attribute/attribute.js | 28 +++++ .../derivation/age.verification.builder.js | 21 +++- .../attribute/derivation/age.verification.js | 18 ++- src/sandbox/profile/request/token.builder.js | 107 ++++++++++++++++++ src/sandbox/profile/request/token.js | 10 ++ src/sandbox/profile/response/token.js | 10 ++ 10 files changed, 307 insertions(+), 22 deletions(-) diff --git a/src/client/index.js b/src/client/index.js index a780a087..9dc0ac4a 100644 --- a/src/client/index.js +++ b/src/client/index.js @@ -5,6 +5,12 @@ const profileService = require('../profile_service'); const amlService = require('../aml_service'); const dynamicSharingService = require('../dynamic_sharing_service'); +/** + * Decrypt the provided connect token. + * + * @param {string} encryptedConnectToken + * @param {string} pem + */ function decryptToken(encryptedConnectToken, pem) { const privateKey = new NodeRSA(pem, 'pkcs1', { encryptionScheme: 'pkcs1' }); let decryptedToken; @@ -16,12 +22,32 @@ function decryptToken(encryptedConnectToken, pem) { return decryptedToken; } +/** + * @class YotiClient + */ module.exports.YotiClient = class YotiClient { + /** + * @param {string} applicationId + * @param {string} pem + */ constructor(applicationId, pem) { this.applicationId = applicationId; this.pem = pem; } + /** + * Get the activity details for a token. Amongst others contains the user profile with + * the user's attributes you have selected in your application configuration. + * + * Note: encrypted tokens should only be used once. You should not invoke this method + * multiple times with the same token. + * + * @param {string} encryptedConnectToken + * Encrypted Yoti token (can be only decrypted with your application's private key). + * Note that this token must only be used once. + * + * @returns {Promise} Resolving ActivityDetails instance holding the user's attributes + */ getActivityDetails(encryptedConnectToken) { let decryptedToken; try { @@ -32,6 +58,14 @@ module.exports.YotiClient = class YotiClient { return profileService.getReceipt(decryptedToken, this.pem, this.applicationId); } + /** + * Request an AML check for the given profile. + * + * @param amlProfile + * Details of the profile to search for when performing the AML check + * + * @returns {Promise} resolving AmlResult with the results of the check + */ performAmlCheck(amlProfile) { return amlService.performAmlCheck(amlProfile, this.pem, this.applicationId); } diff --git a/src/sandbox/profile/request/attribute/anchor.builder.js b/src/sandbox/profile/request/attribute/anchor.builder.js index b0e48913..4dd9c817 100644 --- a/src/sandbox/profile/request/attribute/anchor.builder.js +++ b/src/sandbox/profile/request/attribute/anchor.builder.js @@ -1,30 +1,51 @@ const { SandboxAnchor } = require('./anchor'); +/** + * @class SandboxAnchorBuilder + */ class SandboxAnchorBuilder { + /** + * Setup initial property values. + */ constructor() { this.anchors = []; } + /** + * @param {string} type + */ withType(type) { this.type = type; return this; } + /** + * @param {string} value + */ withValue(value) { this.value = value; return this; } + /** + * @param {string} subType + */ withSubType(subType) { this.subType = subType; return this; } + /** + * @param {DateTime} timestamp + */ withTimestamp(timestamp) { this.timestamp = timestamp; return this; } + /** + * @returns SandboxAnchor + */ build() { return new SandboxAnchor(this.type, this.value, this.subType, this.timestamp); } diff --git a/src/sandbox/profile/request/attribute/anchor.js b/src/sandbox/profile/request/attribute/anchor.js index 4969b032..3d8a2882 100644 --- a/src/sandbox/profile/request/attribute/anchor.js +++ b/src/sandbox/profile/request/attribute/anchor.js @@ -1,39 +1,57 @@ +/** + * @class SandboxAnchor + */ class SandboxAnchor { - constructor(name, value, derivation, optional, anchors = []) { - this.name = name; + /** + * @param {string} type + * @param {string} value + * @param {*} subType + * @param {DateTime} timestamp + */ + constructor(type, value, subType, timestamp) { + this.type = type; this.value = value; - this.derivation = derivation; - this.optional = optional; - this.anchors = anchors; + this.subType = subType; + this.timestamp = timestamp; } - getName() { - return this.name; + /** + * @returns {string} + */ + getType() { + return this.type; } + /** + * @returns {string} + */ getValue() { return this.value; } - getDerivation() { - return this.derivation; + /** + * @returns {*} + */ + getSubType() { + return this.subType; } - getOptional() { - return this.optional; - } - - getAnchors() { - return this.anchors; + /** + * @returns {DateTime} + */ + getTimestamp() { + return this.timestamp; } + /** + * @returns {Object} data for JSON.stringify() + */ toJSON() { return { - name: this.name, + type: this.type, value: this.value, - derivation: this.derivation, - optional: this.optional, - anchors: this.anchors, + sub_type: this.subType, + timestamp: this.timestamp, }; } } diff --git a/src/sandbox/profile/request/attribute/attribute.builder.js b/src/sandbox/profile/request/attribute/attribute.builder.js index ac28a878..081fab04 100644 --- a/src/sandbox/profile/request/attribute/attribute.builder.js +++ b/src/sandbox/profile/request/attribute/attribute.builder.js @@ -1,35 +1,59 @@ const { SandboxAttribute } = require('./attribute'); +/** + * @class SandboxAttributeBuilder + */ class SandboxAttributeBuilder { + /** + * Set initial property values. + */ constructor() { this.anchors = []; } + /** + * @param {string} name + */ withName(name) { this.name = name; return this; } + /** + * @param {string} value + */ withValue(value) { this.value = value; return this; } + /** + * @param {*} derivation + */ withDerivation(derivation) { this.derivation = derivation; return this; } + /** + * @param {boolean} optional + */ withOptional(optional) { this.optional = optional; return this; } + /** + * @param {SandboxAnchors[]} anchors + */ withAnchors(anchors) { this.anchors = anchors; return this; } + /** + * @returns {SandboxAttribute} + */ build() { return new SandboxAttribute( this.name, diff --git a/src/sandbox/profile/request/attribute/attribute.js b/src/sandbox/profile/request/attribute/attribute.js index c65daa38..869f0b79 100644 --- a/src/sandbox/profile/request/attribute/attribute.js +++ b/src/sandbox/profile/request/attribute/attribute.js @@ -1,4 +1,14 @@ +/** + * @class SandboxAttribute + */ class SandboxAttribute { + /** + * @param {string} name + * @param {string} value + * @param {*} derivation + * @param {boolean} optional + * @param {SandboxAnchor[]} anchors + */ constructor(name, value, derivation, optional, anchors = []) { this.name = name; this.value = value; @@ -7,26 +17,44 @@ class SandboxAttribute { this.anchors = anchors; } + /** + * @returns {string} + */ getName() { return this.name; } + /** + * @returns {string} + */ getValue() { return this.value; } + /** + * @returns {*} + */ getDerivation() { return this.derivation; } + /** + * @returns {boolean} + */ getOptional() { return this.optional; } + /** + * @returns {SandboxAnchor[]} + */ getAnchors() { return this.anchors; } + /** + * @returns {Object} data for JSON.stringify() + */ toJSON() { return { name: this.name, diff --git a/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js b/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js index cc86b368..c27af8ef 100644 --- a/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js +++ b/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js @@ -1,32 +1,51 @@ const { SandboxAgeVerification } = require('./age.verification'); +const { SandboxAnchor } = require('../anchor'); const Validation = require('../../../../../yoti_common/validation'); const constants = require('../../../../../yoti_common/constants'); +/** + * @class SandboxAgeVerificationBuilder + */ class SandboxAgeVerificationBuilder { + /** + * @param {DateTime} value + */ withDateOfBirth(value) { Validation.notNull(value, 'dateOfBirth'); this.dateOfBirth = value; return this; } + /** + * @param {integer} value + */ withAgeOver(value) { Validation.isInteger(value); return this.withDerivation(constants.ATTR_AGE_OVER + value); } + /** + * @param {integer} value + */ withAgeUnder(value) { Validation.isInteger(value); return this.withDerivation(constants.ATTR_AGE_UNDER + value); } + /** + * @param {*} value + */ withDerivation(value) { Validation.notNull(value, 'derivation'); this.derivation = value; return this; } + /** + * @param {SandboxAnchor[]} value + */ withAnchors(anchors) { - Validation.notNull(anchors, 'anchors'); + Validation.isArrayOfType(anchors, SandboxAnchor, 'anchors'); this.anchors = anchors; return this; } diff --git a/src/sandbox/profile/request/attribute/derivation/age.verification.js b/src/sandbox/profile/request/attribute/derivation/age.verification.js index 09de1110..47d49dca 100644 --- a/src/sandbox/profile/request/attribute/derivation/age.verification.js +++ b/src/sandbox/profile/request/attribute/derivation/age.verification.js @@ -1,17 +1,31 @@ const { SandboxAttributeBuilder } = require('../attribute.builder'); +const { SandboxAnchor } = require('../anchor'); const Validation = require('../../../../../yoti_common/validation'); const constants = require('../../../../../yoti_common/constants'); +/** + * @class SandboxAgeVerification + */ class SandboxAgeVerification { + /** + * @param {DateTime} dateOfBirth + * @param {*} supportedAgeDerivation + * @param {SandboxAnchor[]} anchors + */ constructor(dateOfBirth, supportedAgeDerivation, anchors) { Validation.notNull(dateOfBirth, 'dateOfBirth'); - Validation.notNull(supportedAgeDerivation, 'derivation'); - this.dateOfBirth = dateOfBirth; + + Validation.notNull(supportedAgeDerivation, 'derivation'); this.supportedAgeDerivation = supportedAgeDerivation; + + Validation.isArrayOfType(anchors, SandboxAnchor); this.anchors = anchors; } + /** + * @returns {SandboxAttribute} + */ toAttribute() { return new SandboxAttributeBuilder() .withName(constants.ATTR_DATE_OF_BIRTH) diff --git a/src/sandbox/profile/request/token.builder.js b/src/sandbox/profile/request/token.builder.js index 69cdc514..df98ab63 100644 --- a/src/sandbox/profile/request/token.builder.js +++ b/src/sandbox/profile/request/token.builder.js @@ -2,6 +2,11 @@ const { TokenRequest } = require('./token'); const { SandboxAttributeBuilder } = require('./attribute/attribute.builder'); const constants = require('../../../yoti_common/constants'); +/** + * @param {string} name + * @param {string} value + * @param {SandboxAnchor[]} anchors + */ const createAttribute = ( name, value, @@ -12,16 +17,32 @@ const createAttribute = ( .withAnchors(anchors) .build(); +/** + * @class TokenRequestBuilder + */ class TokenRequestBuilder { + /** + * Set initial property values. + */ constructor() { this.attributes = {}; } + /** + * @param {string} value + * + * @returns {TokenRequestBuilder} + */ withRememberMeId(value) { this.rememberMeId = value; return this; } + /** + * @param {SandboxAttribute} value + * + * @returns {TokenRequestBuilder} + */ withAttribute(sandboxAttribute) { const key = sandboxAttribute.getDerivation() != null ? sandboxAttribute.getDerivation() : sandboxAttribute.getName(); @@ -29,70 +50,153 @@ class TokenRequestBuilder { return this; } + /** + * @param {string} value + * @param {SandboxAnchor[]} + * + * @returns {TokenRequestBuilder} + */ withGivenNames(value, anchors = []) { const sandboxAttribute = createAttribute(constants.ATTR_GIVEN_NAMES, value, anchors); return this.withAttribute(sandboxAttribute); } + /** + * @param {string} value + * @param {SandboxAnchor[]} + * + * @returns {TokenRequestBuilder} + */ withFamilyName(value, anchors = []) { const sandboxAttribute = createAttribute(constants.ATTR_FAMILY_NAME, value, anchors); return this.withAttribute(sandboxAttribute); } + /** + * @param {string} value + * @param {SandboxAnchor[]} + * + * @returns {TokenRequestBuilder} + */ withFullName(value, anchors = []) { const sandboxAttribute = createAttribute(constants.ATTR_FULL_NAME, value, anchors); return this.withAttribute(sandboxAttribute); } + /** + * @param {string} value + * @param {SandboxAnchor[]} + * + * @returns {TokenRequestBuilder} + */ withDateOfBirth(value, anchors = []) { const sandboxAttribute = createAttribute(constants.ATTR_DATE_OF_BIRTH, value, anchors); return this.withAttribute(sandboxAttribute); } + /** + * @param {SandboxAgeVerification} sandboxAgeVerification + * + * @returns {TokenRequestBuilder} + */ withAgeVerification(sandboxAgeVerification) { return this.withAttribute(sandboxAgeVerification.toAttribute()); } + /** + * @param {string} value + * @param {SandboxAnchor[]} + * + * @returns {TokenRequestBuilder} + */ withGender(value, anchors = []) { const sandboxAttribute = createAttribute(constants.ATTR_GENDER, value, anchors); return this.withAttribute(sandboxAttribute); } + /** + * @param {string} value + * @param {SandboxAnchor[]} + * + * @returns {TokenRequestBuilder} + */ withPhoneNumber(value, anchors = []) { const sandboxAttribute = createAttribute(constants.ATTR_PHONE_NUMBER, value, anchors); return this.withAttribute(sandboxAttribute); } + /** + * @param {string} value + * @param {SandboxAnchor[]} + * + * @returns {TokenRequestBuilder} + */ withNationality(value, anchors = []) { const sandboxAttribute = createAttribute(constants.ATTR_NATIONALITY, value, anchors); return this.withAttribute(sandboxAttribute); } + /** + * @param {string} value + * @param {SandboxAnchor[]} + * + * @returns {TokenRequestBuilder} + */ withPostalAddress(value, anchors = []) { const sandboxAttribute = createAttribute(constants.ATTR_POSTAL_ADDRESS, value, anchors); return this.withAttribute(sandboxAttribute); } + /** + * @param {string} value + * @param {SandboxAnchor[]} + * + * @returns {TokenRequestBuilder} + */ withStructuredPostalAddress(value, anchors = []) { const sandboxAttribute = this .createAttribute(constants.ATTR_STRUCTURED_POSTAL_ADDRESS, value, anchors); return this.withAttribute(sandboxAttribute); } + /** + * @param {string} value + * @param {SandboxAnchor[]} + * + * @returns {TokenRequestBuilder} + */ withSelfie(value, anchors = []) { return this.withBase64Selfie(value, anchors); } + /** + * @param {string} value + * @param {SandboxAnchor[]} + * + * @returns {TokenRequestBuilder} + */ withBase64Selfie(value, anchors = []) { const sandboxAttribute = createAttribute(constants.ATTR_SELFIE, value, anchors); return this.withAttribute(sandboxAttribute); } + /** + * @param {string} value + * @param {SandboxAnchor[]} + * + * @returns {TokenRequestBuilder} + */ withEmailAddress(value, anchors = []) { const sandboxAttribute = createAttribute(constants.ATTR_EMAIL_ADDRESS, value, anchors); return this.withAttribute(sandboxAttribute); } + /** + * @param {string} value + * @param {SandboxAnchor[]} + * + * @returns {TokenRequestBuilder} + */ withDocumentDetails(value, anchors = []) { const sandboxAttribute = new SandboxAttributeBuilder() .withName(constants.ATTR_DOCUMENT_DETAILS) @@ -103,6 +207,9 @@ class TokenRequestBuilder { return this.withAttribute(sandboxAttribute); } + /** + * @returns {TokenRequest} + */ build() { return new TokenRequest( this.rememberMeId, diff --git a/src/sandbox/profile/request/token.js b/src/sandbox/profile/request/token.js index c4b08b81..af84bce1 100644 --- a/src/sandbox/profile/request/token.js +++ b/src/sandbox/profile/request/token.js @@ -1,9 +1,19 @@ +/** + * @class TokenRequest + */ class TokenRequest { + /** + * @param {string} rememberMeId + * @param {SandboxAttribute[]} sandboxAttributes + */ constructor(rememberMeId, sandboxAttributes) { this.rememberMeId = rememberMeId; this.sandboxAttributes = sandboxAttributes; } + /** + * @returns {Object} data for JSON.stringify() + */ toJSON() { return { remember_me_id: this.rememberMeId, diff --git a/src/sandbox/profile/response/token.js b/src/sandbox/profile/response/token.js index b7d3625b..d5dd6232 100644 --- a/src/sandbox/profile/response/token.js +++ b/src/sandbox/profile/response/token.js @@ -1,8 +1,18 @@ +/** + * @class TokenResponse + */ class TokenResponse { + /** + * @param {Object} responseData + */ constructor(responseData) { this.token = responseData.token; } + /** + * @returns {string} + * Encrypted Yoti token (can be only decrypted with your application's private key) + */ getToken() { return this.token; } From 74159d10e2b52a011467f746fc6e78b8dff152a1 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Mon, 23 Sep 2019 18:33:47 +0100 Subject: [PATCH 04/47] SDK-604: Remove unneeded builder method --- src/sandbox/client.builder.js | 18 ++++-------------- src/sandbox/client.js | 4 ++-- 2 files changed, 6 insertions(+), 16 deletions(-) diff --git a/src/sandbox/client.builder.js b/src/sandbox/client.builder.js index 866c4e5a..4e9c3250 100644 --- a/src/sandbox/client.builder.js +++ b/src/sandbox/client.builder.js @@ -25,26 +25,16 @@ class SandboxClientBuilder { } /** - * @param {Buffer} pem + * @param {string} pemString * * @returns {SandboxClientBuilder} */ - withPem(pem) { - Validation.instanceOf(pem, Buffer, 'pem'); + withPemString(pem) { + Validation.isString(pem, 'pem'); this.pem = pem; return this; } - /** - * @param {string} pemString - * - * @returns {SandboxClientBuilder} - */ - withPemString(pemString) { - Validation.isString(pemString, 'pemString'); - return this.withPem(Buffer.from(pemString, 'utf8')); - } - /** * @param {string} filePath * @@ -52,7 +42,7 @@ class SandboxClientBuilder { */ withPemFilePath(filePath) { Validation.isString(filePath, 'filePath'); - return this.withPem(fs.readFileSync(filePath, 'utf8')); + return this.withPemString(fs.readFileSync(filePath, 'utf8')); } /** diff --git a/src/sandbox/client.js b/src/sandbox/client.js index e4611afe..caf12d00 100644 --- a/src/sandbox/client.js +++ b/src/sandbox/client.js @@ -10,7 +10,7 @@ const Validation = require('../yoti_common/validation'); class SandboxClient { /** * @param {string} sdkId - * @param {Buffer} pem + * @param {string} pem * @param {string} sandboxUrl */ constructor(sdkId, pem, sandboxUrl) { @@ -18,7 +18,7 @@ class SandboxClient { this.sdkId = sdkId; this.endpoint = `/apps/${sdkId}/tokens`; - Validation.instanceOf(pem, Buffer, 'pem'); + Validation.isString(pem, 'pem'); this.pem = pem; Validation.isString(sandboxUrl, 'sandboxUrl'); From 380d9a81bc1f06e5c5934c03a535a50fbe3c2bfa Mon Sep 17 00:00:00 2001 From: David Grayston Date: Tue, 24 Sep 2019 12:58:36 +0100 Subject: [PATCH 05/47] SDK-604: Encode selfies and export SandboxAgeVerificationBuilder --- index.js | 2 ++ src/sandbox/index.js | 2 ++ .../profile/request/attribute/derivation/age.verification.js | 2 +- src/sandbox/profile/request/token.builder.js | 2 +- 4 files changed, 6 insertions(+), 2 deletions(-) diff --git a/index.js b/index.js index 6b54f421..d8aa8423 100644 --- a/index.js +++ b/index.js @@ -8,6 +8,7 @@ const { Payload } = require('./src/request/payload'); const { SandboxClientBuilder, SandboxAttributeBuilder, + SandboxAgeVerificationBuilder, SandboxAnchorBuilder, TokenRequestBuilder, } = require('./src/sandbox'); @@ -41,6 +42,7 @@ module.exports = { Payload, SandboxClientBuilder, SandboxAttributeBuilder, + SandboxAgeVerificationBuilder, SandboxAnchorBuilder, TokenRequestBuilder, }; diff --git a/src/sandbox/index.js b/src/sandbox/index.js index c51f684e..5e7eff26 100644 --- a/src/sandbox/index.js +++ b/src/sandbox/index.js @@ -1,11 +1,13 @@ const { SandboxClientBuilder } = require('./client.builder'); const { SandboxAttributeBuilder } = require('./profile/request/attribute/attribute.builder'); +const { SandboxAgeVerificationBuilder } = require('./profile/request/attribute/derivation/age.verification.builder'); const { SandboxAnchorBuilder } = require('./profile/request/attribute/anchor.builder'); const { TokenRequestBuilder } = require('./profile/request/token.builder'); module.exports = { SandboxClientBuilder, SandboxAttributeBuilder, + SandboxAgeVerificationBuilder, SandboxAnchorBuilder, TokenRequestBuilder, }; diff --git a/src/sandbox/profile/request/attribute/derivation/age.verification.js b/src/sandbox/profile/request/attribute/derivation/age.verification.js index 47d49dca..5f802e79 100644 --- a/src/sandbox/profile/request/attribute/derivation/age.verification.js +++ b/src/sandbox/profile/request/attribute/derivation/age.verification.js @@ -12,7 +12,7 @@ class SandboxAgeVerification { * @param {*} supportedAgeDerivation * @param {SandboxAnchor[]} anchors */ - constructor(dateOfBirth, supportedAgeDerivation, anchors) { + constructor(dateOfBirth, supportedAgeDerivation, anchors = []) { Validation.notNull(dateOfBirth, 'dateOfBirth'); this.dateOfBirth = dateOfBirth; diff --git a/src/sandbox/profile/request/token.builder.js b/src/sandbox/profile/request/token.builder.js index df98ab63..efb04a51 100644 --- a/src/sandbox/profile/request/token.builder.js +++ b/src/sandbox/profile/request/token.builder.js @@ -166,7 +166,7 @@ class TokenRequestBuilder { * @returns {TokenRequestBuilder} */ withSelfie(value, anchors = []) { - return this.withBase64Selfie(value, anchors); + return this.withBase64Selfie(Buffer.from(value).toString('base64'), anchors); } /** From 1306ad31074962e876e57ed969ea57a267fd2544 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Tue, 24 Sep 2019 18:47:39 +0100 Subject: [PATCH 06/47] SDK-604: Fix withStructuredPostalAddress builder method --- src/sandbox/profile/request/token.builder.js | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/src/sandbox/profile/request/token.builder.js b/src/sandbox/profile/request/token.builder.js index efb04a51..5987a86c 100644 --- a/src/sandbox/profile/request/token.builder.js +++ b/src/sandbox/profile/request/token.builder.js @@ -154,8 +154,11 @@ class TokenRequestBuilder { * @returns {TokenRequestBuilder} */ withStructuredPostalAddress(value, anchors = []) { - const sandboxAttribute = this - .createAttribute(constants.ATTR_STRUCTURED_POSTAL_ADDRESS, value, anchors); + const sandboxAttribute = createAttribute( + constants.ATTR_STRUCTURED_POSTAL_ADDRESS, + value, + anchors + ); return this.withAttribute(sandboxAttribute); } From 42f225b34f36a1a354a1fb47b332d819ffaa59e0 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Wed, 25 Sep 2019 17:46:22 +0100 Subject: [PATCH 07/47] SDK-604: Add test coverage for SandboxClient --- src/sandbox/client.builder.js | 10 +++---- src/sandbox/client.js | 10 +++---- tests/sandbox/client.spec.js | 53 +++++++++++++++++++++++++++++++++++ 3 files changed, 63 insertions(+), 10 deletions(-) create mode 100644 tests/sandbox/client.spec.js diff --git a/src/sandbox/client.builder.js b/src/sandbox/client.builder.js index 4e9c3250..385bb42e 100644 --- a/src/sandbox/client.builder.js +++ b/src/sandbox/client.builder.js @@ -11,16 +11,16 @@ class SandboxClientBuilder { * Setup default property values. */ constructor() { - this.sdkId = null; + this.appId = null; this.pem = null; this.sandboxUrl = null; } /** - * @param {string} sdkId + * @param {string} appId */ - forApplication(sdkId) { - this.sdkId = sdkId; + forApplication(appId) { + this.appId = appId; return this; } @@ -59,7 +59,7 @@ class SandboxClientBuilder { * @returns {SandboxClient} */ build() { - return new SandboxClient(this.sdkId, this.pem, this.sandboxUrl); + return new SandboxClient(this.appId, this.pem, this.sandboxUrl); } } diff --git a/src/sandbox/client.js b/src/sandbox/client.js index caf12d00..4fbc1b99 100644 --- a/src/sandbox/client.js +++ b/src/sandbox/client.js @@ -9,14 +9,14 @@ const Validation = require('../yoti_common/validation'); */ class SandboxClient { /** - * @param {string} sdkId + * @param {string} appId * @param {string} pem * @param {string} sandboxUrl */ - constructor(sdkId, pem, sandboxUrl) { - Validation.isString(sdkId, 'sdkId'); - this.sdkId = sdkId; - this.endpoint = `/apps/${sdkId}/tokens`; + constructor(appId, pem, sandboxUrl) { + Validation.isString(appId, 'appId'); + this.appId = appId; + this.endpoint = `/apps/${appId}/tokens`; Validation.isString(pem, 'pem'); this.pem = pem; diff --git a/tests/sandbox/client.spec.js b/tests/sandbox/client.spec.js new file mode 100644 index 00000000..546922d1 --- /dev/null +++ b/tests/sandbox/client.spec.js @@ -0,0 +1,53 @@ +const nock = require('nock'); +const fs = require('fs'); +const { SandboxClientBuilder, TokenRequestBuilder } = require('../..'); + +const SOME_APP_ID = 'someAppId'; +const SOME_SANDBOX_URL = 'https://somesandbox.yoti.com/api/v1'; +const SOME_PEM = fs.readFileSync('./tests/sample-data/keys/node-sdk-test.pem', 'utf8'); +const SOME_TOKEN_REQUEST = new TokenRequestBuilder().build(); +const SOME_TOKEN = 'someToken'; + +describe('SandboxClient', () => { + afterEach((done) => { + nock.cleanAll(); + done(); + }); + describe('#constructor', () => { + it('should throw for missing app ID', () => { + expect(() => new SandboxClientBuilder().build()) + .toThrow(new TypeError('appId must be a string')); + }); + it('should throw for missing key', () => { + expect(() => new SandboxClientBuilder().forApplication(SOME_APP_ID).build()) + .toThrow(new TypeError('pem must be a string')); + }); + }); + describe('#setupSharingProfile', () => { + beforeEach((done) => { + nock(SOME_SANDBOX_URL) + .post( + new RegExp(`^/api/v1/apps/${SOME_APP_ID}/tokens`), + JSON.stringify(SOME_TOKEN_REQUEST) + ) + .reply(200, { + token: SOME_TOKEN, + }); + done(); + }); + it('should return token from sandbox', (done) => { + const sandboxClient = new SandboxClientBuilder() + .forApplication(SOME_APP_ID) + .withPemString(SOME_PEM) + .withSandboxUrl(SOME_SANDBOX_URL) + .build(); + + sandboxClient.setupSharingProfile(SOME_TOKEN_REQUEST) + .then((response) => { + expect(response.getToken()).toBe(SOME_TOKEN); + done(); + }) + .catch(done); + }); + }); +}); From e8c73915f78e079cebec130efe88b2fb9f057ec8 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Wed, 25 Sep 2019 18:25:08 +0100 Subject: [PATCH 08/47] SDK-604: Add test coverage for invalid responses --- src/sandbox/profile/response/token.js | 6 ++ tests/sandbox/client.spec.js | 95 ++++++++++++++++++++++----- 2 files changed, 83 insertions(+), 18 deletions(-) diff --git a/src/sandbox/profile/response/token.js b/src/sandbox/profile/response/token.js index d5dd6232..d75a5043 100644 --- a/src/sandbox/profile/response/token.js +++ b/src/sandbox/profile/response/token.js @@ -1,3 +1,5 @@ +const Validation = require('../../../yoti_common/validation'); + /** * @class TokenResponse */ @@ -6,6 +8,10 @@ class TokenResponse { * @param {Object} responseData */ constructor(responseData) { + if (!(responseData instanceof Object)) { + throw new Error(`${this.constructor.name} responseData should be an object`); + } + Validation.isString(responseData.token, 'responseData.token'); this.token = responseData.token; } diff --git a/tests/sandbox/client.spec.js b/tests/sandbox/client.spec.js index 546922d1..85f177c8 100644 --- a/tests/sandbox/client.spec.js +++ b/tests/sandbox/client.spec.js @@ -1,17 +1,32 @@ const nock = require('nock'); const fs = require('fs'); const { SandboxClientBuilder, TokenRequestBuilder } = require('../..'); +const { SandboxClient } = require('../../src/sandbox/client'); const SOME_APP_ID = 'someAppId'; const SOME_SANDBOX_URL = 'https://somesandbox.yoti.com/api/v1'; -const SOME_PEM = fs.readFileSync('./tests/sample-data/keys/node-sdk-test.pem', 'utf8'); +const SOME_ENDPOINT_PATTERN = new RegExp(`^/api/v1/apps/${SOME_APP_ID}/tokens`); +const SOME_PEM_FILE_PATH = './tests/sample-data/keys/node-sdk-test.pem'; +const SOME_PEM_STRING = fs.readFileSync(SOME_PEM_FILE_PATH, 'utf8'); const SOME_TOKEN_REQUEST = new TokenRequestBuilder().build(); const SOME_TOKEN = 'someToken'; describe('SandboxClient', () => { - afterEach((done) => { - nock.cleanAll(); - done(); + it('should build with pem string', () => { + const sandboxClient = new SandboxClientBuilder() + .forApplication(SOME_APP_ID) + .withPemString(SOME_PEM_STRING) + .withSandboxUrl(SOME_SANDBOX_URL) + .build(); + expect(sandboxClient).toBeInstanceOf(SandboxClient); + }); + it('should build with pem file path', () => { + const sandboxClient = new SandboxClientBuilder() + .forApplication(SOME_APP_ID) + .withPemFilePath(SOME_PEM_FILE_PATH) + .withSandboxUrl(SOME_SANDBOX_URL) + .build(); + expect(sandboxClient).toBeInstanceOf(SandboxClient); }); describe('#constructor', () => { it('should throw for missing app ID', () => { @@ -24,23 +39,20 @@ describe('SandboxClient', () => { }); }); describe('#setupSharingProfile', () => { - beforeEach((done) => { - nock(SOME_SANDBOX_URL) - .post( - new RegExp(`^/api/v1/apps/${SOME_APP_ID}/tokens`), - JSON.stringify(SOME_TOKEN_REQUEST) - ) - .reply(200, { - token: SOME_TOKEN, - }); + const sandboxClient = new SandboxClientBuilder() + .forApplication(SOME_APP_ID) + .withPemString(SOME_PEM_STRING) + .withSandboxUrl(SOME_SANDBOX_URL) + .build(); + + afterEach((done) => { + nock.cleanAll(); done(); }); it('should return token from sandbox', (done) => { - const sandboxClient = new SandboxClientBuilder() - .forApplication(SOME_APP_ID) - .withPemString(SOME_PEM) - .withSandboxUrl(SOME_SANDBOX_URL) - .build(); + nock(SOME_SANDBOX_URL) + .post(SOME_ENDPOINT_PATTERN, JSON.stringify(SOME_TOKEN_REQUEST)) + .reply(200, { token: SOME_TOKEN }); sandboxClient.setupSharingProfile(SOME_TOKEN_REQUEST) .then((response) => { @@ -49,5 +61,52 @@ describe('SandboxClient', () => { }) .catch(done); }); + it('should throw error when invalid response is returned', (done) => { + nock(SOME_SANDBOX_URL) + .post(SOME_ENDPOINT_PATTERN, JSON.stringify(SOME_TOKEN_REQUEST)) + .reply(200, '""'); + + sandboxClient + .setupSharingProfile(SOME_TOKEN_REQUEST) + .catch((err) => { + expect(err.message).toBe('TokenResponse responseData should be an object'); + done(); + }); + }); + it('should throw error when response has no token', (done) => { + nock(SOME_SANDBOX_URL) + .post(SOME_ENDPOINT_PATTERN, JSON.stringify(SOME_TOKEN_REQUEST)) + .reply(200, '{}'); + + sandboxClient + .setupSharingProfile(SOME_TOKEN_REQUEST) + .catch((err) => { + expect(err.message).toBe('responseData.token must be a string'); + done(); + }); + }); + [ + { + error: 'Bad Request', + status: 400, + }, + { + error: 'Internal Server Error', + status: 500, + }, + ].forEach((invalidResponse) => { + it(`should throw error when response is ${invalidResponse.status}`, (done) => { + nock(SOME_SANDBOX_URL) + .post(SOME_ENDPOINT_PATTERN, JSON.stringify(SOME_TOKEN_REQUEST)) + .reply(invalidResponse.status, '{}'); + + sandboxClient + .setupSharingProfile(SOME_TOKEN_REQUEST) + .catch((err) => { + expect(err.message).toBe(invalidResponse.error); + done(); + }); + }); + }); }); }); From 1d8426720a8f88d5cf06870850fbb8e096389314 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Wed, 25 Sep 2019 19:14:32 +0100 Subject: [PATCH 09/47] SDK-604: Add test coverage for TokenRequest --- src/sandbox/profile/request/token.builder.js | 3 + tests/sandbox/request/token.spec.js | 185 +++++++++++++++++++ 2 files changed, 188 insertions(+) create mode 100644 tests/sandbox/request/token.spec.js diff --git a/src/sandbox/profile/request/token.builder.js b/src/sandbox/profile/request/token.builder.js index 5987a86c..1fcd7a42 100644 --- a/src/sandbox/profile/request/token.builder.js +++ b/src/sandbox/profile/request/token.builder.js @@ -1,6 +1,8 @@ const { TokenRequest } = require('./token'); const { SandboxAttributeBuilder } = require('./attribute/attribute.builder'); +const { SandboxAgeVerification } = require('./attribute/derivation/age.verification'); const constants = require('../../../yoti_common/constants'); +const Validation = require('../../../yoti_common/validation'); /** * @param {string} name @@ -100,6 +102,7 @@ class TokenRequestBuilder { * @returns {TokenRequestBuilder} */ withAgeVerification(sandboxAgeVerification) { + Validation.instanceOf(sandboxAgeVerification, SandboxAgeVerification, 'sandboxAgeVerification'); return this.withAttribute(sandboxAgeVerification.toAttribute()); } diff --git a/tests/sandbox/request/token.spec.js b/tests/sandbox/request/token.spec.js new file mode 100644 index 00000000..d500d164 --- /dev/null +++ b/tests/sandbox/request/token.spec.js @@ -0,0 +1,185 @@ +const { + TokenRequestBuilder, + SandboxAgeVerificationBuilder, + SandboxAnchorBuilder, +} = require('../../..'); + +const SOME_REMEMEBER_ME_ID = 'someRememberMeId'; +const SOME_VALUE = 'someStringValue'; +const SOME_ANCHOR = new SandboxAnchorBuilder() + .withType('someAnchorType') + .build(); + +describe('TokenRequest', () => { + it('should build with remember me ID', () => { + const tokenRequest = new TokenRequestBuilder() + .withRememberMeId(SOME_REMEMEBER_ME_ID) + .build(); + + const expectedData = { + remember_me_id: SOME_REMEMEBER_ME_ID, + profile_attributes: [], + }; + + expect(JSON.stringify(tokenRequest)) + .toBe(JSON.stringify(expectedData)); + }); + it('should build with family name', () => { + const tokenRequest = new TokenRequestBuilder() + .withFamilyName(SOME_VALUE, [SOME_ANCHOR]) + .build(); + + expect(tokenRequest).toContainAttribute('family_name', SOME_VALUE, [SOME_ANCHOR]); + }); + it('should build with email address', () => { + const tokenRequest = new TokenRequestBuilder() + .withEmailAddress(SOME_VALUE, [SOME_ANCHOR]) + .build(); + + expect(tokenRequest).toContainAttribute('email_address', SOME_VALUE, [SOME_ANCHOR]); + }); + it('should build with full name', () => { + const tokenRequest = new TokenRequestBuilder() + .withFullName(SOME_VALUE, [SOME_ANCHOR]) + .build(); + + expect(tokenRequest).toContainAttribute('full_name', SOME_VALUE, [SOME_ANCHOR]); + }); + it('should build with date of birth', () => { + const tokenRequest = new TokenRequestBuilder() + .withDateOfBirth(SOME_VALUE, [SOME_ANCHOR]) + .build(); + + expect(tokenRequest).toContainAttribute('date_of_birth', SOME_VALUE, [SOME_ANCHOR]); + }); + it('should build with gender', () => { + const tokenRequest = new TokenRequestBuilder() + .withGender(SOME_VALUE, [SOME_ANCHOR]) + .build(); + + expect(tokenRequest).toContainAttribute('gender', SOME_VALUE, [SOME_ANCHOR]); + }); + it('should build with given names', () => { + const tokenRequest = new TokenRequestBuilder() + .withGivenNames(SOME_VALUE, [SOME_ANCHOR]) + .build(); + + expect(tokenRequest).toContainAttribute('given_names', SOME_VALUE, [SOME_ANCHOR]); + }); + it('should build with nationality', () => { + const tokenRequest = new TokenRequestBuilder() + .withNationality(SOME_VALUE, [SOME_ANCHOR]) + .build(); + + expect(tokenRequest).toContainAttribute('nationality', SOME_VALUE, [SOME_ANCHOR]); + }); + it('should build with phone number', () => { + const tokenRequest = new TokenRequestBuilder() + .withPhoneNumber(SOME_VALUE, [SOME_ANCHOR]) + .build(); + + expect(tokenRequest).toContainAttribute('phone_number', SOME_VALUE, [SOME_ANCHOR]); + }); + it('should build with postal address', () => { + const tokenRequest = new TokenRequestBuilder() + .withPostalAddress(SOME_VALUE, [SOME_ANCHOR]) + .build(); + + expect(tokenRequest).toContainAttribute('postal_address', SOME_VALUE, [SOME_ANCHOR]); + }); + it('should build with selfie', () => { + const tokenRequest = new TokenRequestBuilder() + .withSelfie(SOME_VALUE, [SOME_ANCHOR]) + .build(); + + expect(tokenRequest).toContainAttribute( + 'selfie', + Buffer.from(SOME_VALUE, [SOME_ANCHOR]).toString('base64'), + [SOME_ANCHOR] + ); + }); + it('should build with base64 encoded selfie', () => { + const tokenRequest = new TokenRequestBuilder() + .withBase64Selfie(SOME_VALUE, [SOME_ANCHOR]) + .build(); + + expect(tokenRequest).toContainAttribute('selfie', SOME_VALUE, [SOME_ANCHOR]); + }); + it('should build with structured postal address', () => { + const tokenRequest = new TokenRequestBuilder() + .withStructuredPostalAddress(SOME_VALUE, [SOME_ANCHOR]) + .build(); + + expect(tokenRequest).toContainAttribute('structured_postal_address', SOME_VALUE, [SOME_ANCHOR]); + }); + it('should build with Document Details', () => { + const tokenRequest = new TokenRequestBuilder() + .withDocumentDetails(SOME_VALUE, [SOME_ANCHOR]) + .build(); + + const expectedData = { + profile_attributes: [ + { + name: 'document_details', + value: SOME_VALUE, + optional: true, + anchors: [SOME_ANCHOR], + }, + ], + }; + + expect(JSON.stringify(tokenRequest)) + .toBe(JSON.stringify(expectedData)); + }); + it('should build with age verification', () => { + const ageVerification = new SandboxAgeVerificationBuilder() + .withDateOfBirth(SOME_VALUE) + .withAgeOver(18) + .build(); + + const tokenRequest = new TokenRequestBuilder() + .withAgeVerification(ageVerification) + .build(); + + const expectedData = { + profile_attributes: [ + { + name: 'date_of_birth', + value: SOME_VALUE, + derivation: 'age_over:18', + anchors: [], + }, + ], + }; + + expect(JSON.stringify(tokenRequest)) + .toBe(JSON.stringify(expectedData)); + }); +}); + +expect.extend({ + /** + * @param {TokenRequest} receivedTokenRequest + * @param {string} name + * @param {string} value + */ + toContainAttribute(receivedTokenRequest, name, value, anchors) { + const expectedData = { + profile_attributes: [ + { + name, + value, + anchors, + }, + ], + }; + expect(JSON.stringify(receivedTokenRequest)) + .toBe(JSON.stringify(expectedData)); + + return { + message: () => + `TokenRequest contains '${name}' attribute with value '${value}'`, + pass: true, + }; + }, +}); From b59cbff9f55ace25a555b403e992856fbf5d9a81 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Thu, 26 Sep 2019 12:17:28 +0100 Subject: [PATCH 10/47] SDK-604: Add test coverage for SandboxAttribute --- .../request/attribute/attribute.builder.js | 7 -- .../profile/request/attribute/attribute.js | 41 +++++++++--- .../derivation/age.verification.builder.js | 4 +- .../attribute/derivation/age.verification.js | 8 ++- src/sandbox/profile/request/token.builder.js | 28 ++++---- .../request/attribute/attribute.spec.js | 67 +++++++++++++++++++ tests/sandbox/request/token.spec.js | 1 - 7 files changed, 121 insertions(+), 35 deletions(-) create mode 100644 tests/sandbox/request/attribute/attribute.spec.js diff --git a/src/sandbox/profile/request/attribute/attribute.builder.js b/src/sandbox/profile/request/attribute/attribute.builder.js index 081fab04..6fa02e00 100644 --- a/src/sandbox/profile/request/attribute/attribute.builder.js +++ b/src/sandbox/profile/request/attribute/attribute.builder.js @@ -4,13 +4,6 @@ const { SandboxAttribute } = require('./attribute'); * @class SandboxAttributeBuilder */ class SandboxAttributeBuilder { - /** - * Set initial property values. - */ - constructor() { - this.anchors = []; - } - /** * @param {string} name */ diff --git a/src/sandbox/profile/request/attribute/attribute.js b/src/sandbox/profile/request/attribute/attribute.js index 869f0b79..d783510d 100644 --- a/src/sandbox/profile/request/attribute/attribute.js +++ b/src/sandbox/profile/request/attribute/attribute.js @@ -1,3 +1,6 @@ +const Validation = require('../../../../yoti_common/validation'); +const { SandboxAnchor } = require('./anchor'); + /** * @class SandboxAttribute */ @@ -5,15 +8,30 @@ class SandboxAttribute { /** * @param {string} name * @param {string} value - * @param {*} derivation + * @param {string} derivation * @param {boolean} optional * @param {SandboxAnchor[]} anchors */ - constructor(name, value, derivation, optional, anchors = []) { + constructor(name, value, derivation = null, optional = null, anchors = null) { + Validation.isString(name, 'name'); this.name = name; + + Validation.isString(value, 'value'); this.value = value; + + if (derivation !== null) { + Validation.isString(derivation, 'derivation'); + } this.derivation = derivation; + + if (optional !== null) { + Validation.isBoolean(optional, 'optional'); + } this.optional = optional; + + if (anchors !== null) { + Validation.isArrayOfType(anchors, SandboxAnchor, 'anchors'); + } this.anchors = anchors; } @@ -56,13 +74,20 @@ class SandboxAttribute { * @returns {Object} data for JSON.stringify() */ toJSON() { - return { - name: this.name, - value: this.value, - derivation: this.derivation, - optional: this.optional, - anchors: this.anchors, + const json = { + name: this.getName(), + value: this.getValue(), }; + if (this.getDerivation() !== null) { + json.derivation = this.getDerivation(); + } + if (this.getOptional() !== null) { + json.optional = this.getOptional(); + } + if (this.getAnchors() !== null) { + json.anchors = this.getAnchors(); + } + return json; } } diff --git a/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js b/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js index c27af8ef..b5c3c476 100644 --- a/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js +++ b/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js @@ -33,10 +33,10 @@ class SandboxAgeVerificationBuilder { } /** - * @param {*} value + * @param {string} value */ withDerivation(value) { - Validation.notNull(value, 'derivation'); + Validation.isString(value, 'derivation'); this.derivation = value; return this; } diff --git a/src/sandbox/profile/request/attribute/derivation/age.verification.js b/src/sandbox/profile/request/attribute/derivation/age.verification.js index 5f802e79..0c302630 100644 --- a/src/sandbox/profile/request/attribute/derivation/age.verification.js +++ b/src/sandbox/profile/request/attribute/derivation/age.verification.js @@ -9,17 +9,19 @@ const constants = require('../../../../../yoti_common/constants'); class SandboxAgeVerification { /** * @param {DateTime} dateOfBirth - * @param {*} supportedAgeDerivation + * @param {string} supportedAgeDerivation * @param {SandboxAnchor[]} anchors */ - constructor(dateOfBirth, supportedAgeDerivation, anchors = []) { + constructor(dateOfBirth, supportedAgeDerivation, anchors = null) { Validation.notNull(dateOfBirth, 'dateOfBirth'); this.dateOfBirth = dateOfBirth; Validation.notNull(supportedAgeDerivation, 'derivation'); this.supportedAgeDerivation = supportedAgeDerivation; - Validation.isArrayOfType(anchors, SandboxAnchor); + if (anchors !== null) { + Validation.isArrayOfType(anchors, SandboxAnchor); + } this.anchors = anchors; } diff --git a/src/sandbox/profile/request/token.builder.js b/src/sandbox/profile/request/token.builder.js index 1fcd7a42..9aef3a93 100644 --- a/src/sandbox/profile/request/token.builder.js +++ b/src/sandbox/profile/request/token.builder.js @@ -12,7 +12,7 @@ const Validation = require('../../../yoti_common/validation'); const createAttribute = ( name, value, - anchors = [] + anchors ) => new SandboxAttributeBuilder() .withName(name) .withValue(value) @@ -58,7 +58,7 @@ class TokenRequestBuilder { * * @returns {TokenRequestBuilder} */ - withGivenNames(value, anchors = []) { + withGivenNames(value, anchors = null) { const sandboxAttribute = createAttribute(constants.ATTR_GIVEN_NAMES, value, anchors); return this.withAttribute(sandboxAttribute); } @@ -69,7 +69,7 @@ class TokenRequestBuilder { * * @returns {TokenRequestBuilder} */ - withFamilyName(value, anchors = []) { + withFamilyName(value, anchors = null) { const sandboxAttribute = createAttribute(constants.ATTR_FAMILY_NAME, value, anchors); return this.withAttribute(sandboxAttribute); } @@ -80,7 +80,7 @@ class TokenRequestBuilder { * * @returns {TokenRequestBuilder} */ - withFullName(value, anchors = []) { + withFullName(value, anchors = null) { const sandboxAttribute = createAttribute(constants.ATTR_FULL_NAME, value, anchors); return this.withAttribute(sandboxAttribute); } @@ -91,7 +91,7 @@ class TokenRequestBuilder { * * @returns {TokenRequestBuilder} */ - withDateOfBirth(value, anchors = []) { + withDateOfBirth(value, anchors = null) { const sandboxAttribute = createAttribute(constants.ATTR_DATE_OF_BIRTH, value, anchors); return this.withAttribute(sandboxAttribute); } @@ -112,7 +112,7 @@ class TokenRequestBuilder { * * @returns {TokenRequestBuilder} */ - withGender(value, anchors = []) { + withGender(value, anchors = null) { const sandboxAttribute = createAttribute(constants.ATTR_GENDER, value, anchors); return this.withAttribute(sandboxAttribute); } @@ -123,7 +123,7 @@ class TokenRequestBuilder { * * @returns {TokenRequestBuilder} */ - withPhoneNumber(value, anchors = []) { + withPhoneNumber(value, anchors = null) { const sandboxAttribute = createAttribute(constants.ATTR_PHONE_NUMBER, value, anchors); return this.withAttribute(sandboxAttribute); } @@ -134,7 +134,7 @@ class TokenRequestBuilder { * * @returns {TokenRequestBuilder} */ - withNationality(value, anchors = []) { + withNationality(value, anchors = null) { const sandboxAttribute = createAttribute(constants.ATTR_NATIONALITY, value, anchors); return this.withAttribute(sandboxAttribute); } @@ -145,7 +145,7 @@ class TokenRequestBuilder { * * @returns {TokenRequestBuilder} */ - withPostalAddress(value, anchors = []) { + withPostalAddress(value, anchors = null) { const sandboxAttribute = createAttribute(constants.ATTR_POSTAL_ADDRESS, value, anchors); return this.withAttribute(sandboxAttribute); } @@ -156,7 +156,7 @@ class TokenRequestBuilder { * * @returns {TokenRequestBuilder} */ - withStructuredPostalAddress(value, anchors = []) { + withStructuredPostalAddress(value, anchors = null) { const sandboxAttribute = createAttribute( constants.ATTR_STRUCTURED_POSTAL_ADDRESS, value, @@ -171,7 +171,7 @@ class TokenRequestBuilder { * * @returns {TokenRequestBuilder} */ - withSelfie(value, anchors = []) { + withSelfie(value, anchors = null) { return this.withBase64Selfie(Buffer.from(value).toString('base64'), anchors); } @@ -181,7 +181,7 @@ class TokenRequestBuilder { * * @returns {TokenRequestBuilder} */ - withBase64Selfie(value, anchors = []) { + withBase64Selfie(value, anchors = null) { const sandboxAttribute = createAttribute(constants.ATTR_SELFIE, value, anchors); return this.withAttribute(sandboxAttribute); } @@ -192,7 +192,7 @@ class TokenRequestBuilder { * * @returns {TokenRequestBuilder} */ - withEmailAddress(value, anchors = []) { + withEmailAddress(value, anchors = null) { const sandboxAttribute = createAttribute(constants.ATTR_EMAIL_ADDRESS, value, anchors); return this.withAttribute(sandboxAttribute); } @@ -203,7 +203,7 @@ class TokenRequestBuilder { * * @returns {TokenRequestBuilder} */ - withDocumentDetails(value, anchors = []) { + withDocumentDetails(value, anchors = null) { const sandboxAttribute = new SandboxAttributeBuilder() .withName(constants.ATTR_DOCUMENT_DETAILS) .withValue(value) diff --git a/tests/sandbox/request/attribute/attribute.spec.js b/tests/sandbox/request/attribute/attribute.spec.js new file mode 100644 index 00000000..5d65895c --- /dev/null +++ b/tests/sandbox/request/attribute/attribute.spec.js @@ -0,0 +1,67 @@ +const { + SandboxAttributeBuilder, + SandboxAnchorBuilder, +} = require('../../../..'); + +const SOME_NAME = 'someName'; +const SOME_VALUE = 'someValue'; +const SOME_DERIVATION = 'someDerivation'; +const SOME_ANCHOR_TYPE = 'someAnchorType'; +const SOME_ANCHOR_VALUE = 'someAnchorValue'; + +describe('SandboxAttribute', () => { + it('should build with required properties', () => { + const sandboxAttribute = new SandboxAttributeBuilder() + .withName(SOME_NAME) + .withValue(SOME_VALUE) + .build(); + + const expectedData = { + name: SOME_NAME, + value: SOME_VALUE, + }; + + expect(JSON.stringify(sandboxAttribute)) + .toBe(JSON.stringify(expectedData)); + }); + it('should build with derivation', () => { + const sandboxAttribute = new SandboxAttributeBuilder() + .withName(SOME_NAME) + .withValue(SOME_VALUE) + .withDerivation(SOME_DERIVATION) + .build(); + + const expectedData = { + name: SOME_NAME, + value: SOME_VALUE, + derivation: SOME_DERIVATION, + }; + + expect(JSON.stringify(sandboxAttribute)) + .toBe(JSON.stringify(expectedData)); + }); + it('should build with anchors', () => { + const sandboxAnchor = new SandboxAnchorBuilder() + .withType(SOME_ANCHOR_TYPE) + .withValue(SOME_ANCHOR_VALUE) + .build(); + + const sandboxAttribute = new SandboxAttributeBuilder() + .withName(SOME_NAME) + .withValue(SOME_VALUE) + .withAnchors([sandboxAnchor]) + .build(); + + const expectedData = { + name: SOME_NAME, + value: SOME_VALUE, + anchors: [{ + type: SOME_ANCHOR_TYPE, + value: SOME_ANCHOR_VALUE, + }], + }; + + expect(JSON.stringify(sandboxAttribute)) + .toBe(JSON.stringify(expectedData)); + }); +}); diff --git a/tests/sandbox/request/token.spec.js b/tests/sandbox/request/token.spec.js index d500d164..2da1ea53 100644 --- a/tests/sandbox/request/token.spec.js +++ b/tests/sandbox/request/token.spec.js @@ -147,7 +147,6 @@ describe('TokenRequest', () => { name: 'date_of_birth', value: SOME_VALUE, derivation: 'age_over:18', - anchors: [], }, ], }; From a3044d4ff96c4ebeccc68f47426636f70eacfe91 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Thu, 26 Sep 2019 14:06:01 +0100 Subject: [PATCH 11/47] SDK-604: Test TokenRequestBuilder without anchors --- tests/sandbox/request/token.spec.js | 102 +++++++++++++++++++++++++++- 1 file changed, 100 insertions(+), 2 deletions(-) diff --git a/tests/sandbox/request/token.spec.js b/tests/sandbox/request/token.spec.js index 2da1ea53..9a9abce5 100644 --- a/tests/sandbox/request/token.spec.js +++ b/tests/sandbox/request/token.spec.js @@ -25,6 +25,13 @@ describe('TokenRequest', () => { .toBe(JSON.stringify(expectedData)); }); it('should build with family name', () => { + const tokenRequest = new TokenRequestBuilder() + .withFamilyName(SOME_VALUE) + .build(); + + expect(tokenRequest).toContainAttribute('family_name', SOME_VALUE); + }); + it('should build with family name with anchors', () => { const tokenRequest = new TokenRequestBuilder() .withFamilyName(SOME_VALUE, [SOME_ANCHOR]) .build(); @@ -32,6 +39,13 @@ describe('TokenRequest', () => { expect(tokenRequest).toContainAttribute('family_name', SOME_VALUE, [SOME_ANCHOR]); }); it('should build with email address', () => { + const tokenRequest = new TokenRequestBuilder() + .withEmailAddress(SOME_VALUE) + .build(); + + expect(tokenRequest).toContainAttribute('email_address', SOME_VALUE); + }); + it('should build with email address with anchors', () => { const tokenRequest = new TokenRequestBuilder() .withEmailAddress(SOME_VALUE, [SOME_ANCHOR]) .build(); @@ -39,6 +53,13 @@ describe('TokenRequest', () => { expect(tokenRequest).toContainAttribute('email_address', SOME_VALUE, [SOME_ANCHOR]); }); it('should build with full name', () => { + const tokenRequest = new TokenRequestBuilder() + .withFullName(SOME_VALUE) + .build(); + + expect(tokenRequest).toContainAttribute('full_name', SOME_VALUE); + }); + it('should build with full name with anchors', () => { const tokenRequest = new TokenRequestBuilder() .withFullName(SOME_VALUE, [SOME_ANCHOR]) .build(); @@ -46,6 +67,13 @@ describe('TokenRequest', () => { expect(tokenRequest).toContainAttribute('full_name', SOME_VALUE, [SOME_ANCHOR]); }); it('should build with date of birth', () => { + const tokenRequest = new TokenRequestBuilder() + .withDateOfBirth(SOME_VALUE) + .build(); + + expect(tokenRequest).toContainAttribute('date_of_birth', SOME_VALUE); + }); + it('should build with date of birth with anchors', () => { const tokenRequest = new TokenRequestBuilder() .withDateOfBirth(SOME_VALUE, [SOME_ANCHOR]) .build(); @@ -53,6 +81,13 @@ describe('TokenRequest', () => { expect(tokenRequest).toContainAttribute('date_of_birth', SOME_VALUE, [SOME_ANCHOR]); }); it('should build with gender', () => { + const tokenRequest = new TokenRequestBuilder() + .withGender(SOME_VALUE) + .build(); + + expect(tokenRequest).toContainAttribute('gender', SOME_VALUE); + }); + it('should build with gender with anchors', () => { const tokenRequest = new TokenRequestBuilder() .withGender(SOME_VALUE, [SOME_ANCHOR]) .build(); @@ -60,6 +95,13 @@ describe('TokenRequest', () => { expect(tokenRequest).toContainAttribute('gender', SOME_VALUE, [SOME_ANCHOR]); }); it('should build with given names', () => { + const tokenRequest = new TokenRequestBuilder() + .withGivenNames(SOME_VALUE) + .build(); + + expect(tokenRequest).toContainAttribute('given_names', SOME_VALUE); + }); + it('should build with given names with anchors', () => { const tokenRequest = new TokenRequestBuilder() .withGivenNames(SOME_VALUE, [SOME_ANCHOR]) .build(); @@ -67,6 +109,13 @@ describe('TokenRequest', () => { expect(tokenRequest).toContainAttribute('given_names', SOME_VALUE, [SOME_ANCHOR]); }); it('should build with nationality', () => { + const tokenRequest = new TokenRequestBuilder() + .withNationality(SOME_VALUE) + .build(); + + expect(tokenRequest).toContainAttribute('nationality', SOME_VALUE); + }); + it('should build with nationality with anchors', () => { const tokenRequest = new TokenRequestBuilder() .withNationality(SOME_VALUE, [SOME_ANCHOR]) .build(); @@ -74,6 +123,13 @@ describe('TokenRequest', () => { expect(tokenRequest).toContainAttribute('nationality', SOME_VALUE, [SOME_ANCHOR]); }); it('should build with phone number', () => { + const tokenRequest = new TokenRequestBuilder() + .withPhoneNumber(SOME_VALUE) + .build(); + + expect(tokenRequest).toContainAttribute('phone_number', SOME_VALUE); + }); + it('should build with phone number with anchors', () => { const tokenRequest = new TokenRequestBuilder() .withPhoneNumber(SOME_VALUE, [SOME_ANCHOR]) .build(); @@ -81,6 +137,13 @@ describe('TokenRequest', () => { expect(tokenRequest).toContainAttribute('phone_number', SOME_VALUE, [SOME_ANCHOR]); }); it('should build with postal address', () => { + const tokenRequest = new TokenRequestBuilder() + .withPostalAddress(SOME_VALUE) + .build(); + + expect(tokenRequest).toContainAttribute('postal_address', SOME_VALUE); + }); + it('should build with postal address with anchors', () => { const tokenRequest = new TokenRequestBuilder() .withPostalAddress(SOME_VALUE, [SOME_ANCHOR]) .build(); @@ -88,6 +151,16 @@ describe('TokenRequest', () => { expect(tokenRequest).toContainAttribute('postal_address', SOME_VALUE, [SOME_ANCHOR]); }); it('should build with selfie', () => { + const tokenRequest = new TokenRequestBuilder() + .withSelfie(SOME_VALUE) + .build(); + + expect(tokenRequest).toContainAttribute( + 'selfie', + Buffer.from(SOME_VALUE).toString('base64') + ); + }); + it('should build with selfie with anchors', () => { const tokenRequest = new TokenRequestBuilder() .withSelfie(SOME_VALUE, [SOME_ANCHOR]) .build(); @@ -100,12 +173,19 @@ describe('TokenRequest', () => { }); it('should build with base64 encoded selfie', () => { const tokenRequest = new TokenRequestBuilder() - .withBase64Selfie(SOME_VALUE, [SOME_ANCHOR]) + .withBase64Selfie(SOME_VALUE) .build(); - expect(tokenRequest).toContainAttribute('selfie', SOME_VALUE, [SOME_ANCHOR]); + expect(tokenRequest).toContainAttribute('selfie', SOME_VALUE); }); it('should build with structured postal address', () => { + const tokenRequest = new TokenRequestBuilder() + .withStructuredPostalAddress(SOME_VALUE) + .build(); + + expect(tokenRequest).toContainAttribute('structured_postal_address', SOME_VALUE); + }); + it('should build with structured postal address with anchors', () => { const tokenRequest = new TokenRequestBuilder() .withStructuredPostalAddress(SOME_VALUE, [SOME_ANCHOR]) .build(); @@ -113,6 +193,24 @@ describe('TokenRequest', () => { expect(tokenRequest).toContainAttribute('structured_postal_address', SOME_VALUE, [SOME_ANCHOR]); }); it('should build with Document Details', () => { + const tokenRequest = new TokenRequestBuilder() + .withDocumentDetails(SOME_VALUE) + .build(); + + const expectedData = { + profile_attributes: [ + { + name: 'document_details', + value: SOME_VALUE, + optional: true, + }, + ], + }; + + expect(JSON.stringify(tokenRequest)) + .toBe(JSON.stringify(expectedData)); + }); + it('should build with Document Details with anchors', () => { const tokenRequest = new TokenRequestBuilder() .withDocumentDetails(SOME_VALUE, [SOME_ANCHOR]) .build(); From 0388bc3e6046c1eb122dd9706fc4ce733c7f996a Mon Sep 17 00:00:00 2001 From: David Grayston Date: Thu, 26 Sep 2019 15:14:28 +0100 Subject: [PATCH 12/47] SDK-604: Ensure attributes are not optional by default --- .../profile/request/attribute/anchor.js | 8 +- .../request/attribute/attribute.builder.js | 9 + .../profile/request/attribute/attribute.js | 16 +- .../sandbox/request/attribute/anchor.spec.js | 29 +++ .../request/attribute/attribute.spec.js | 19 ++ .../derivation/age.verification.spec.js | 75 ++++++ tests/sandbox/request/token.spec.js | 223 ++++++++++++------ 7 files changed, 290 insertions(+), 89 deletions(-) create mode 100644 tests/sandbox/request/attribute/anchor.spec.js create mode 100644 tests/sandbox/request/attribute/derivation/age.verification.spec.js diff --git a/src/sandbox/profile/request/attribute/anchor.js b/src/sandbox/profile/request/attribute/anchor.js index 3d8a2882..db26fc8a 100644 --- a/src/sandbox/profile/request/attribute/anchor.js +++ b/src/sandbox/profile/request/attribute/anchor.js @@ -48,10 +48,10 @@ class SandboxAnchor { */ toJSON() { return { - type: this.type, - value: this.value, - sub_type: this.subType, - timestamp: this.timestamp, + type: this.getType(), + value: this.getValue(), + sub_type: this.getSubType(), + timestamp: this.getTimestamp(), }; } } diff --git a/src/sandbox/profile/request/attribute/attribute.builder.js b/src/sandbox/profile/request/attribute/attribute.builder.js index 6fa02e00..52939e5a 100644 --- a/src/sandbox/profile/request/attribute/attribute.builder.js +++ b/src/sandbox/profile/request/attribute/attribute.builder.js @@ -4,6 +4,15 @@ const { SandboxAttribute } = require('./attribute'); * @class SandboxAttributeBuilder */ class SandboxAttributeBuilder { + /** + * Setup initial property values. + */ + constructor() { + this.optional = false; + this.derivation = null; + this.anchors = null; + } + /** * @param {string} name */ diff --git a/src/sandbox/profile/request/attribute/attribute.js b/src/sandbox/profile/request/attribute/attribute.js index d783510d..5a789179 100644 --- a/src/sandbox/profile/request/attribute/attribute.js +++ b/src/sandbox/profile/request/attribute/attribute.js @@ -12,23 +12,21 @@ class SandboxAttribute { * @param {boolean} optional * @param {SandboxAnchor[]} anchors */ - constructor(name, value, derivation = null, optional = null, anchors = null) { + constructor(name, value, derivation, optional, anchors) { Validation.isString(name, 'name'); this.name = name; Validation.isString(value, 'value'); this.value = value; + Validation.isBoolean(optional, 'optional'); + this.optional = optional; + if (derivation !== null) { Validation.isString(derivation, 'derivation'); } this.derivation = derivation; - if (optional !== null) { - Validation.isBoolean(optional, 'optional'); - } - this.optional = optional; - if (anchors !== null) { Validation.isArrayOfType(anchors, SandboxAnchor, 'anchors'); } @@ -77,13 +75,13 @@ class SandboxAttribute { const json = { name: this.getName(), value: this.getValue(), + optional: this.getOptional(), }; + if (this.getDerivation() !== null) { json.derivation = this.getDerivation(); } - if (this.getOptional() !== null) { - json.optional = this.getOptional(); - } + if (this.getAnchors() !== null) { json.anchors = this.getAnchors(); } diff --git a/tests/sandbox/request/attribute/anchor.spec.js b/tests/sandbox/request/attribute/anchor.spec.js new file mode 100644 index 00000000..3f8f6ddc --- /dev/null +++ b/tests/sandbox/request/attribute/anchor.spec.js @@ -0,0 +1,29 @@ +const { + SandboxAnchorBuilder, +} = require('../../../..'); + +const SOME_ANCHOR_TYPE = 'someAnchorType'; +const SOME_ANCHOR_SUB_TYPE = 'someAnchorSubType'; +const SOME_ANCHOR_VALUE = 'someAnchorValue'; +const SOME_TIMESTAMP = '1569503646050000'; + +describe('SandboxAnchor', () => { + it('should build with all properties', () => { + const sandboxAnchor = new SandboxAnchorBuilder() + .withType(SOME_ANCHOR_TYPE) + .withValue(SOME_ANCHOR_VALUE) + .withTimestamp(SOME_TIMESTAMP) + .withSubType(SOME_ANCHOR_SUB_TYPE) + .build(); + + const expectedData = { + type: SOME_ANCHOR_TYPE, + value: SOME_ANCHOR_VALUE, + sub_type: SOME_ANCHOR_SUB_TYPE, + timestamp: SOME_TIMESTAMP, + }; + + expect(JSON.stringify(sandboxAnchor)) + .toBe(JSON.stringify(expectedData)); + }); +}); diff --git a/tests/sandbox/request/attribute/attribute.spec.js b/tests/sandbox/request/attribute/attribute.spec.js index 5d65895c..2141dbba 100644 --- a/tests/sandbox/request/attribute/attribute.spec.js +++ b/tests/sandbox/request/attribute/attribute.spec.js @@ -19,6 +19,7 @@ describe('SandboxAttribute', () => { const expectedData = { name: SOME_NAME, value: SOME_VALUE, + optional: false, }; expect(JSON.stringify(sandboxAttribute)) @@ -34,6 +35,7 @@ describe('SandboxAttribute', () => { const expectedData = { name: SOME_NAME, value: SOME_VALUE, + optional: false, derivation: SOME_DERIVATION, }; @@ -55,12 +57,29 @@ describe('SandboxAttribute', () => { const expectedData = { name: SOME_NAME, value: SOME_VALUE, + optional: false, anchors: [{ type: SOME_ANCHOR_TYPE, value: SOME_ANCHOR_VALUE, }], }; + expect(JSON.stringify(sandboxAttribute)) + .toBe(JSON.stringify(expectedData)); + }); + it('should build with optional true', () => { + const sandboxAttribute = new SandboxAttributeBuilder() + .withName(SOME_NAME) + .withValue(SOME_VALUE) + .withOptional(true) + .build(); + + const expectedData = { + name: SOME_NAME, + value: SOME_VALUE, + optional: true, + }; + expect(JSON.stringify(sandboxAttribute)) .toBe(JSON.stringify(expectedData)); }); diff --git a/tests/sandbox/request/attribute/derivation/age.verification.spec.js b/tests/sandbox/request/attribute/derivation/age.verification.spec.js new file mode 100644 index 00000000..d22d3e2c --- /dev/null +++ b/tests/sandbox/request/attribute/derivation/age.verification.spec.js @@ -0,0 +1,75 @@ +const { + SandboxAgeVerificationBuilder, + SandboxAnchorBuilder, +} = require('../../../../..'); + +const SOME_DATE_OF_BIRTH = '1989-01-02'; +const SOME_AGE_VALUE = 18; +const SOME_AGE_OVER_DERIVATION_VALUE = `age_over:${SOME_AGE_VALUE}`; +const SOME_AGE_UNDER_DERIVATION_VALUE = `age_under:${SOME_AGE_VALUE}`; +const SOME_ANCHOR_TYPE = 'someAnchorType'; +const SOME_ANCHOR_VALUE = 'someAnchorValue'; + +describe('SandboxAgeVerification', () => { + it('should build age over attribute', () => { + const sandboxAttribute = new SandboxAgeVerificationBuilder() + .withDateOfBirth(SOME_DATE_OF_BIRTH) + .withAgeOver(SOME_AGE_VALUE) + .build() + .toAttribute(); + + const expectedData = { + name: 'date_of_birth', + value: SOME_DATE_OF_BIRTH, + optional: false, + derivation: SOME_AGE_OVER_DERIVATION_VALUE, + }; + + expect(JSON.stringify(sandboxAttribute)) + .toBe(JSON.stringify(expectedData)); + }); + it('should build age under attribute', () => { + const sandboxAttribute = new SandboxAgeVerificationBuilder() + .withDateOfBirth(SOME_DATE_OF_BIRTH) + .withAgeUnder(SOME_AGE_VALUE) + .build() + .toAttribute(); + + const expectedData = { + name: 'date_of_birth', + value: SOME_DATE_OF_BIRTH, + optional: false, + derivation: SOME_AGE_UNDER_DERIVATION_VALUE, + }; + + expect(JSON.stringify(sandboxAttribute)) + .toBe(JSON.stringify(expectedData)); + }); + it('should build with anchors', () => { + const sandboxAnchor = new SandboxAnchorBuilder() + .withType(SOME_ANCHOR_TYPE) + .withValue(SOME_ANCHOR_VALUE) + .build(); + + const sandboxAttribute = new SandboxAgeVerificationBuilder() + .withDateOfBirth(SOME_DATE_OF_BIRTH) + .withAgeOver(SOME_AGE_VALUE) + .withAnchors([sandboxAnchor]) + .build() + .toAttribute(); + + const expectedData = { + name: 'date_of_birth', + value: SOME_DATE_OF_BIRTH, + optional: false, + derivation: SOME_AGE_OVER_DERIVATION_VALUE, + anchors: [{ + type: SOME_ANCHOR_TYPE, + value: SOME_ANCHOR_VALUE, + }], + }; + + expect(JSON.stringify(sandboxAttribute)) + .toBe(JSON.stringify(expectedData)); + }); +}); diff --git a/tests/sandbox/request/token.spec.js b/tests/sandbox/request/token.spec.js index 9a9abce5..893dc209 100644 --- a/tests/sandbox/request/token.spec.js +++ b/tests/sandbox/request/token.spec.js @@ -29,205 +29,287 @@ describe('TokenRequest', () => { .withFamilyName(SOME_VALUE) .build(); - expect(tokenRequest).toContainAttribute('family_name', SOME_VALUE); + expect(tokenRequest).toContainAttribute({ + name: 'family_name', + value: SOME_VALUE, + optional: false, + }); }); it('should build with family name with anchors', () => { const tokenRequest = new TokenRequestBuilder() .withFamilyName(SOME_VALUE, [SOME_ANCHOR]) .build(); - expect(tokenRequest).toContainAttribute('family_name', SOME_VALUE, [SOME_ANCHOR]); + expect(tokenRequest).toContainAttribute({ + name: 'family_name', + value: SOME_VALUE, + optional: false, + anchors: [SOME_ANCHOR], + }); }); it('should build with email address', () => { const tokenRequest = new TokenRequestBuilder() .withEmailAddress(SOME_VALUE) .build(); - expect(tokenRequest).toContainAttribute('email_address', SOME_VALUE); + expect(tokenRequest).toContainAttribute({ + name: 'email_address', + value: SOME_VALUE, + optional: false, + }); }); it('should build with email address with anchors', () => { const tokenRequest = new TokenRequestBuilder() .withEmailAddress(SOME_VALUE, [SOME_ANCHOR]) .build(); - expect(tokenRequest).toContainAttribute('email_address', SOME_VALUE, [SOME_ANCHOR]); + expect(tokenRequest).toContainAttribute({ + name: 'email_address', + value: SOME_VALUE, + optional: false, + anchors: [SOME_ANCHOR], + }); }); it('should build with full name', () => { const tokenRequest = new TokenRequestBuilder() .withFullName(SOME_VALUE) .build(); - expect(tokenRequest).toContainAttribute('full_name', SOME_VALUE); + expect(tokenRequest).toContainAttribute({ + name: 'full_name', + value: SOME_VALUE, + optional: false, + }); }); it('should build with full name with anchors', () => { const tokenRequest = new TokenRequestBuilder() .withFullName(SOME_VALUE, [SOME_ANCHOR]) .build(); - expect(tokenRequest).toContainAttribute('full_name', SOME_VALUE, [SOME_ANCHOR]); + expect(tokenRequest).toContainAttribute({ + name: 'full_name', + value: SOME_VALUE, + optional: false, + anchors: [SOME_ANCHOR], + }); }); it('should build with date of birth', () => { const tokenRequest = new TokenRequestBuilder() .withDateOfBirth(SOME_VALUE) .build(); - expect(tokenRequest).toContainAttribute('date_of_birth', SOME_VALUE); + expect(tokenRequest).toContainAttribute({ + name: 'date_of_birth', + value: SOME_VALUE, + optional: false, + }); }); it('should build with date of birth with anchors', () => { const tokenRequest = new TokenRequestBuilder() .withDateOfBirth(SOME_VALUE, [SOME_ANCHOR]) .build(); - expect(tokenRequest).toContainAttribute('date_of_birth', SOME_VALUE, [SOME_ANCHOR]); + expect(tokenRequest).toContainAttribute({ + name: 'date_of_birth', + value: SOME_VALUE, + optional: false, + anchors: [SOME_ANCHOR], + }); }); it('should build with gender', () => { const tokenRequest = new TokenRequestBuilder() .withGender(SOME_VALUE) .build(); - expect(tokenRequest).toContainAttribute('gender', SOME_VALUE); + expect(tokenRequest).toContainAttribute({ + name: 'gender', + value: SOME_VALUE, + optional: false, + }); }); it('should build with gender with anchors', () => { const tokenRequest = new TokenRequestBuilder() .withGender(SOME_VALUE, [SOME_ANCHOR]) .build(); - expect(tokenRequest).toContainAttribute('gender', SOME_VALUE, [SOME_ANCHOR]); + expect(tokenRequest).toContainAttribute({ + name: 'gender', + value: SOME_VALUE, + optional: false, + anchors: [SOME_ANCHOR], + }); }); it('should build with given names', () => { const tokenRequest = new TokenRequestBuilder() .withGivenNames(SOME_VALUE) .build(); - expect(tokenRequest).toContainAttribute('given_names', SOME_VALUE); + expect(tokenRequest).toContainAttribute({ + name: 'given_names', + value: SOME_VALUE, + optional: false, + }); }); it('should build with given names with anchors', () => { const tokenRequest = new TokenRequestBuilder() .withGivenNames(SOME_VALUE, [SOME_ANCHOR]) .build(); - expect(tokenRequest).toContainAttribute('given_names', SOME_VALUE, [SOME_ANCHOR]); + expect(tokenRequest).toContainAttribute({ + name: 'given_names', + value: SOME_VALUE, + optional: false, + anchors: [SOME_ANCHOR], + }); }); it('should build with nationality', () => { const tokenRequest = new TokenRequestBuilder() .withNationality(SOME_VALUE) .build(); - expect(tokenRequest).toContainAttribute('nationality', SOME_VALUE); + expect(tokenRequest).toContainAttribute({ + name: 'nationality', + value: SOME_VALUE, + optional: false, + }); }); it('should build with nationality with anchors', () => { const tokenRequest = new TokenRequestBuilder() .withNationality(SOME_VALUE, [SOME_ANCHOR]) .build(); - expect(tokenRequest).toContainAttribute('nationality', SOME_VALUE, [SOME_ANCHOR]); + expect(tokenRequest).toContainAttribute({ + name: 'nationality', + value: SOME_VALUE, + optional: false, + anchors: [SOME_ANCHOR], + }); }); it('should build with phone number', () => { const tokenRequest = new TokenRequestBuilder() .withPhoneNumber(SOME_VALUE) .build(); - expect(tokenRequest).toContainAttribute('phone_number', SOME_VALUE); + expect(tokenRequest).toContainAttribute({ + name: 'phone_number', + value: SOME_VALUE, + optional: false, + }); }); it('should build with phone number with anchors', () => { const tokenRequest = new TokenRequestBuilder() .withPhoneNumber(SOME_VALUE, [SOME_ANCHOR]) .build(); - expect(tokenRequest).toContainAttribute('phone_number', SOME_VALUE, [SOME_ANCHOR]); + expect(tokenRequest).toContainAttribute({ + name: 'phone_number', + value: SOME_VALUE, + optional: false, + anchors: [SOME_ANCHOR], + }); }); it('should build with postal address', () => { const tokenRequest = new TokenRequestBuilder() .withPostalAddress(SOME_VALUE) .build(); - expect(tokenRequest).toContainAttribute('postal_address', SOME_VALUE); + expect(tokenRequest).toContainAttribute({ + name: 'postal_address', + value: SOME_VALUE, + optional: false, + }); }); it('should build with postal address with anchors', () => { const tokenRequest = new TokenRequestBuilder() .withPostalAddress(SOME_VALUE, [SOME_ANCHOR]) .build(); - expect(tokenRequest).toContainAttribute('postal_address', SOME_VALUE, [SOME_ANCHOR]); + expect(tokenRequest).toContainAttribute({ + name: 'postal_address', + value: SOME_VALUE, + optional: false, + anchors: [SOME_ANCHOR], + }); }); it('should build with selfie', () => { const tokenRequest = new TokenRequestBuilder() .withSelfie(SOME_VALUE) .build(); - expect(tokenRequest).toContainAttribute( - 'selfie', - Buffer.from(SOME_VALUE).toString('base64') - ); + expect(tokenRequest).toContainAttribute({ + name: 'selfie', + value: Buffer.from(SOME_VALUE).toString('base64'), + optional: false, + }); }); it('should build with selfie with anchors', () => { const tokenRequest = new TokenRequestBuilder() .withSelfie(SOME_VALUE, [SOME_ANCHOR]) .build(); - expect(tokenRequest).toContainAttribute( - 'selfie', - Buffer.from(SOME_VALUE, [SOME_ANCHOR]).toString('base64'), - [SOME_ANCHOR] - ); + expect(tokenRequest).toContainAttribute({ + name: 'selfie', + value: Buffer.from(SOME_VALUE, [SOME_ANCHOR]).toString('base64'), + optional: false, + anchors: [SOME_ANCHOR], + }); }); it('should build with base64 encoded selfie', () => { const tokenRequest = new TokenRequestBuilder() .withBase64Selfie(SOME_VALUE) .build(); - expect(tokenRequest).toContainAttribute('selfie', SOME_VALUE); + expect(tokenRequest).toContainAttribute({ + name: 'selfie', + value: SOME_VALUE, + optional: false, + }); }); it('should build with structured postal address', () => { const tokenRequest = new TokenRequestBuilder() .withStructuredPostalAddress(SOME_VALUE) .build(); - expect(tokenRequest).toContainAttribute('structured_postal_address', SOME_VALUE); + expect(tokenRequest).toContainAttribute({ + name: 'structured_postal_address', + value: SOME_VALUE, + optional: false, + }); }); it('should build with structured postal address with anchors', () => { const tokenRequest = new TokenRequestBuilder() .withStructuredPostalAddress(SOME_VALUE, [SOME_ANCHOR]) .build(); - expect(tokenRequest).toContainAttribute('structured_postal_address', SOME_VALUE, [SOME_ANCHOR]); + expect(tokenRequest).toContainAttribute({ + name: 'structured_postal_address', + value: SOME_VALUE, + optional: false, + anchors: [SOME_ANCHOR], + }); }); it('should build with Document Details', () => { const tokenRequest = new TokenRequestBuilder() .withDocumentDetails(SOME_VALUE) .build(); - const expectedData = { - profile_attributes: [ - { - name: 'document_details', - value: SOME_VALUE, - optional: true, - }, - ], - }; - - expect(JSON.stringify(tokenRequest)) - .toBe(JSON.stringify(expectedData)); + expect(tokenRequest).toContainAttribute({ + name: 'document_details', + value: SOME_VALUE, + optional: true, + }); }); it('should build with Document Details with anchors', () => { const tokenRequest = new TokenRequestBuilder() .withDocumentDetails(SOME_VALUE, [SOME_ANCHOR]) .build(); - const expectedData = { - profile_attributes: [ - { - name: 'document_details', - value: SOME_VALUE, - optional: true, - anchors: [SOME_ANCHOR], - }, - ], - }; - - expect(JSON.stringify(tokenRequest)) - .toBe(JSON.stringify(expectedData)); + expect(tokenRequest).toContainAttribute({ + name: 'document_details', + value: SOME_VALUE, + optional: true, + anchors: [SOME_ANCHOR], + }); }); it('should build with age verification', () => { const ageVerification = new SandboxAgeVerificationBuilder() @@ -239,18 +321,12 @@ describe('TokenRequest', () => { .withAgeVerification(ageVerification) .build(); - const expectedData = { - profile_attributes: [ - { - name: 'date_of_birth', - value: SOME_VALUE, - derivation: 'age_over:18', - }, - ], - }; - - expect(JSON.stringify(tokenRequest)) - .toBe(JSON.stringify(expectedData)); + expect(tokenRequest).toContainAttribute({ + name: 'date_of_birth', + value: SOME_VALUE, + optional: false, + derivation: 'age_over:18', + }); }); }); @@ -260,22 +336,17 @@ expect.extend({ * @param {string} name * @param {string} value */ - toContainAttribute(receivedTokenRequest, name, value, anchors) { + toContainAttribute(receivedTokenRequest, expectedAttribute) { const expectedData = { - profile_attributes: [ - { - name, - value, - anchors, - }, - ], + profile_attributes: [expectedAttribute], }; + expect(JSON.stringify(receivedTokenRequest)) .toBe(JSON.stringify(expectedData)); return { message: () => - `TokenRequest contains '${name}' attribute with value '${value}'`, + 'TokenRequest contains expected attribute', pass: true, }; }, From 804d587c11b8c38974221449addf6b405de1625f Mon Sep 17 00:00:00 2001 From: David Grayston Date: Thu, 26 Sep 2019 17:28:36 +0100 Subject: [PATCH 13/47] SDK-604: Use YotiDate for sandbox date of birth --- index.js | 2 ++ src/data_type/date.js | 29 ++++++++++++++++--- .../derivation/age.verification.builder.js | 5 ++-- .../attribute/derivation/age.verification.js | 7 +++-- src/sandbox/profile/request/token.builder.js | 10 +++++-- .../derivation/age.verification.spec.js | 10 ++++--- tests/sandbox/request/token.spec.js | 15 ++++++---- 7 files changed, 57 insertions(+), 21 deletions(-) diff --git a/index.js b/index.js index d8aa8423..ba9c2576 100644 --- a/index.js +++ b/index.js @@ -4,6 +4,7 @@ const Client = require('./src/client').YotiClient; const { AmlAddress, AmlProfile } = require('./src/aml_type'); const { RequestBuilder } = require('./src/request/request.builder'); const { Payload } = require('./src/request/payload'); +const { YotiDate } = require('./src/data_type/date'); const { SandboxClientBuilder, @@ -45,4 +46,5 @@ module.exports = { SandboxAgeVerificationBuilder, SandboxAnchorBuilder, TokenRequestBuilder, + YotiDate, }; diff --git a/src/data_type/date.js b/src/data_type/date.js index 72159e5b..64d6ff0e 100644 --- a/src/data_type/date.js +++ b/src/data_type/date.js @@ -1,3 +1,5 @@ +const Validation = require('../yoti_common/validation'); + /** * Formats date part padded with leading zeros. * @@ -37,6 +39,7 @@ class YotiDate extends Date { * @param {number} timestamp */ constructor(timestamp) { + Validation.isNumber(timestamp); super(Math.round(timestamp / 1000)); this.microseconds = timestamp % 1000000; } @@ -67,16 +70,34 @@ class YotiDate extends Date { } /** - * Returns ISO 8601 UTC timestamp with microseconds. + * Returns ISO 8601 UTC date. * * @returns {string} - * Timestamp in format `{YYYY}-{DD}-{MM}T{HH}:{MM}:{SS}.{mmmmmm}Z` + * Date in format `{YYYY}-{DD}-{MM}` */ - getMicrosecondTimestamp() { + toISODateString() { const year = formatDatePart(this.getUTCFullYear(), 4); const month = formatDatePart(this.getUTCMonth() + 1, 2); const day = formatDatePart(this.getUTCDate(), 2); - return `${year}-${month}-${day}T${this.getMicrosecondTime()}Z`; + return `${year}-${month}-${day}`; + } + + /** + * @param {string} dateString + */ + static fromDateString(dateString) { + Validation.isString(dateString, 'dateString'); + return new YotiDate(Date.parse(dateString) * 1000); + } + + /** + * Returns ISO 8601 UTC timestamp with microseconds. + * + * @returns {string} + * Timestamp in format `{YYYY}-{DD}-{MM}T{HH}:{MM}:{SS}.{mmmmmm}Z` + */ + getMicrosecondTimestamp() { + return `${this.toISODateString()}T${this.getMicrosecondTime()}Z`; } } diff --git a/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js b/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js index b5c3c476..5e62e381 100644 --- a/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js +++ b/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js @@ -1,5 +1,6 @@ const { SandboxAgeVerification } = require('./age.verification'); const { SandboxAnchor } = require('../anchor'); +const { YotiDate } = require('../../../../../data_type/date'); const Validation = require('../../../../../yoti_common/validation'); const constants = require('../../../../../yoti_common/constants'); @@ -8,10 +9,10 @@ const constants = require('../../../../../yoti_common/constants'); */ class SandboxAgeVerificationBuilder { /** - * @param {DateTime} value + * @param {YotiDate} value */ withDateOfBirth(value) { - Validation.notNull(value, 'dateOfBirth'); + Validation.instanceOf(value, YotiDate, 'value'); this.dateOfBirth = value; return this; } diff --git a/src/sandbox/profile/request/attribute/derivation/age.verification.js b/src/sandbox/profile/request/attribute/derivation/age.verification.js index 0c302630..1515040c 100644 --- a/src/sandbox/profile/request/attribute/derivation/age.verification.js +++ b/src/sandbox/profile/request/attribute/derivation/age.verification.js @@ -1,5 +1,6 @@ const { SandboxAttributeBuilder } = require('../attribute.builder'); const { SandboxAnchor } = require('../anchor'); +const { YotiDate } = require('../../../../../data_type/date'); const Validation = require('../../../../../yoti_common/validation'); const constants = require('../../../../../yoti_common/constants'); @@ -8,13 +9,13 @@ const constants = require('../../../../../yoti_common/constants'); */ class SandboxAgeVerification { /** - * @param {DateTime} dateOfBirth + * @param {YotiDate} dateOfBirth * @param {string} supportedAgeDerivation * @param {SandboxAnchor[]} anchors */ constructor(dateOfBirth, supportedAgeDerivation, anchors = null) { - Validation.notNull(dateOfBirth, 'dateOfBirth'); - this.dateOfBirth = dateOfBirth; + Validation.instanceOf(dateOfBirth, YotiDate, 'dateOfBirth'); + this.dateOfBirth = dateOfBirth.toISODateString(); Validation.notNull(supportedAgeDerivation, 'derivation'); this.supportedAgeDerivation = supportedAgeDerivation; diff --git a/src/sandbox/profile/request/token.builder.js b/src/sandbox/profile/request/token.builder.js index 9aef3a93..bf621ef7 100644 --- a/src/sandbox/profile/request/token.builder.js +++ b/src/sandbox/profile/request/token.builder.js @@ -1,6 +1,7 @@ const { TokenRequest } = require('./token'); const { SandboxAttributeBuilder } = require('./attribute/attribute.builder'); const { SandboxAgeVerification } = require('./attribute/derivation/age.verification'); +const { YotiDate } = require('../../../data_type/date'); const constants = require('../../../yoti_common/constants'); const Validation = require('../../../yoti_common/validation'); @@ -86,13 +87,18 @@ class TokenRequestBuilder { } /** - * @param {string} value + * @param {YotiDate} value * @param {SandboxAnchor[]} * * @returns {TokenRequestBuilder} */ withDateOfBirth(value, anchors = null) { - const sandboxAttribute = createAttribute(constants.ATTR_DATE_OF_BIRTH, value, anchors); + Validation.instanceOf(value, YotiDate, 'value'); + const sandboxAttribute = createAttribute( + constants.ATTR_DATE_OF_BIRTH, + value.toISODateString(), + anchors + ); return this.withAttribute(sandboxAttribute); } diff --git a/tests/sandbox/request/attribute/derivation/age.verification.spec.js b/tests/sandbox/request/attribute/derivation/age.verification.spec.js index d22d3e2c..93e66dd0 100644 --- a/tests/sandbox/request/attribute/derivation/age.verification.spec.js +++ b/tests/sandbox/request/attribute/derivation/age.verification.spec.js @@ -1,9 +1,11 @@ const { SandboxAgeVerificationBuilder, SandboxAnchorBuilder, + YotiDate, } = require('../../../../..'); -const SOME_DATE_OF_BIRTH = '1989-01-02'; +const SOME_DATE_OF_BIRTH_STRING = '1989-01-02'; +const SOME_DATE_OF_BIRTH = YotiDate.fromDateString(SOME_DATE_OF_BIRTH_STRING); const SOME_AGE_VALUE = 18; const SOME_AGE_OVER_DERIVATION_VALUE = `age_over:${SOME_AGE_VALUE}`; const SOME_AGE_UNDER_DERIVATION_VALUE = `age_under:${SOME_AGE_VALUE}`; @@ -20,7 +22,7 @@ describe('SandboxAgeVerification', () => { const expectedData = { name: 'date_of_birth', - value: SOME_DATE_OF_BIRTH, + value: SOME_DATE_OF_BIRTH_STRING, optional: false, derivation: SOME_AGE_OVER_DERIVATION_VALUE, }; @@ -37,7 +39,7 @@ describe('SandboxAgeVerification', () => { const expectedData = { name: 'date_of_birth', - value: SOME_DATE_OF_BIRTH, + value: SOME_DATE_OF_BIRTH_STRING, optional: false, derivation: SOME_AGE_UNDER_DERIVATION_VALUE, }; @@ -60,7 +62,7 @@ describe('SandboxAgeVerification', () => { const expectedData = { name: 'date_of_birth', - value: SOME_DATE_OF_BIRTH, + value: SOME_DATE_OF_BIRTH_STRING, optional: false, derivation: SOME_AGE_OVER_DERIVATION_VALUE, anchors: [{ diff --git a/tests/sandbox/request/token.spec.js b/tests/sandbox/request/token.spec.js index 893dc209..6a45d3d6 100644 --- a/tests/sandbox/request/token.spec.js +++ b/tests/sandbox/request/token.spec.js @@ -2,6 +2,7 @@ const { TokenRequestBuilder, SandboxAgeVerificationBuilder, SandboxAnchorBuilder, + YotiDate, } = require('../../..'); const SOME_REMEMEBER_ME_ID = 'someRememberMeId'; @@ -9,6 +10,8 @@ const SOME_VALUE = 'someStringValue'; const SOME_ANCHOR = new SandboxAnchorBuilder() .withType('someAnchorType') .build(); +const SOME_DATE_OF_BIRTH_STRING = '1989-01-02'; +const SOME_DATE_OF_BIRTH = YotiDate.fromDateString(SOME_DATE_OF_BIRTH_STRING); describe('TokenRequest', () => { it('should build with remember me ID', () => { @@ -95,23 +98,23 @@ describe('TokenRequest', () => { }); it('should build with date of birth', () => { const tokenRequest = new TokenRequestBuilder() - .withDateOfBirth(SOME_VALUE) + .withDateOfBirth(SOME_DATE_OF_BIRTH) .build(); expect(tokenRequest).toContainAttribute({ name: 'date_of_birth', - value: SOME_VALUE, + value: SOME_DATE_OF_BIRTH_STRING, optional: false, }); }); it('should build with date of birth with anchors', () => { const tokenRequest = new TokenRequestBuilder() - .withDateOfBirth(SOME_VALUE, [SOME_ANCHOR]) + .withDateOfBirth(SOME_DATE_OF_BIRTH, [SOME_ANCHOR]) .build(); expect(tokenRequest).toContainAttribute({ name: 'date_of_birth', - value: SOME_VALUE, + value: SOME_DATE_OF_BIRTH_STRING, optional: false, anchors: [SOME_ANCHOR], }); @@ -313,7 +316,7 @@ describe('TokenRequest', () => { }); it('should build with age verification', () => { const ageVerification = new SandboxAgeVerificationBuilder() - .withDateOfBirth(SOME_VALUE) + .withDateOfBirth(SOME_DATE_OF_BIRTH) .withAgeOver(18) .build(); @@ -323,7 +326,7 @@ describe('TokenRequest', () => { expect(tokenRequest).toContainAttribute({ name: 'date_of_birth', - value: SOME_VALUE, + value: SOME_DATE_OF_BIRTH_STRING, optional: false, derivation: 'age_over:18', }); From 297c3c2ff0e9b299c5d9f9bf26466c2fa7501973 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Thu, 26 Sep 2019 17:39:17 +0100 Subject: [PATCH 14/47] SDK-604: Allow sandbox date of birth to be provided as string --- .../request/attribute/anchor.builder.js | 10 +++++++- .../request/attribute/attribute.builder.js | 12 +++++++++- .../derivation/age.verification.builder.js | 23 +++++++++++++++++++ src/sandbox/profile/request/token.builder.js | 14 +++++++++++ .../derivation/age.verification.spec.js | 17 ++++++++++++++ tests/sandbox/request/token.spec.js | 23 +++++++++++++++++++ 6 files changed, 97 insertions(+), 2 deletions(-) diff --git a/src/sandbox/profile/request/attribute/anchor.builder.js b/src/sandbox/profile/request/attribute/anchor.builder.js index 4dd9c817..21ddfa47 100644 --- a/src/sandbox/profile/request/attribute/anchor.builder.js +++ b/src/sandbox/profile/request/attribute/anchor.builder.js @@ -13,6 +13,8 @@ class SandboxAnchorBuilder { /** * @param {string} type + * + * @returns {SandboxAnchorBuilder} */ withType(type) { this.type = type; @@ -21,6 +23,8 @@ class SandboxAnchorBuilder { /** * @param {string} value + * + * @returns {SandboxAnchorBuilder} */ withValue(value) { this.value = value; @@ -29,6 +33,8 @@ class SandboxAnchorBuilder { /** * @param {string} subType + * + * @returns {SandboxAnchorBuilder} */ withSubType(subType) { this.subType = subType; @@ -37,6 +43,8 @@ class SandboxAnchorBuilder { /** * @param {DateTime} timestamp + * + * @returns {SandboxAnchorBuilder} */ withTimestamp(timestamp) { this.timestamp = timestamp; @@ -44,7 +52,7 @@ class SandboxAnchorBuilder { } /** - * @returns SandboxAnchor + * @returns {SandboxAnchor} */ build() { return new SandboxAnchor(this.type, this.value, this.subType, this.timestamp); diff --git a/src/sandbox/profile/request/attribute/attribute.builder.js b/src/sandbox/profile/request/attribute/attribute.builder.js index 52939e5a..05a46351 100644 --- a/src/sandbox/profile/request/attribute/attribute.builder.js +++ b/src/sandbox/profile/request/attribute/attribute.builder.js @@ -15,6 +15,8 @@ class SandboxAttributeBuilder { /** * @param {string} name + * + * @returns {SandboxAttributeBuilder} */ withName(name) { this.name = name; @@ -23,6 +25,8 @@ class SandboxAttributeBuilder { /** * @param {string} value + * + * @returns {SandboxAttributeBuilder} */ withValue(value) { this.value = value; @@ -30,7 +34,9 @@ class SandboxAttributeBuilder { } /** - * @param {*} derivation + * @param {string} derivation + * + * @returns {SandboxAttributeBuilder} */ withDerivation(derivation) { this.derivation = derivation; @@ -39,6 +45,8 @@ class SandboxAttributeBuilder { /** * @param {boolean} optional + * + * @returns {SandboxAttributeBuilder} */ withOptional(optional) { this.optional = optional; @@ -47,6 +55,8 @@ class SandboxAttributeBuilder { /** * @param {SandboxAnchors[]} anchors + * + * @returns {SandboxAttributeBuilder} */ withAnchors(anchors) { this.anchors = anchors; diff --git a/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js b/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js index 5e62e381..9372ba0e 100644 --- a/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js +++ b/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js @@ -10,6 +10,8 @@ const constants = require('../../../../../yoti_common/constants'); class SandboxAgeVerificationBuilder { /** * @param {YotiDate} value + * + * @returns {SandboxAgeVerificationBuilder} */ withDateOfBirth(value) { Validation.instanceOf(value, YotiDate, 'value'); @@ -17,8 +19,20 @@ class SandboxAgeVerificationBuilder { return this; } + /** + * @param {string} value + * + * @returns {SandboxAgeVerificationBuilder} + */ + withDateOfBirthString(value) { + Validation.isString(value, 'value'); + return this.withDateOfBirth(YotiDate.fromDateString(value)); + } + /** * @param {integer} value + * + * @returns {SandboxAgeVerificationBuilder} */ withAgeOver(value) { Validation.isInteger(value); @@ -27,6 +41,8 @@ class SandboxAgeVerificationBuilder { /** * @param {integer} value + * + * @returns {SandboxAgeVerificationBuilder} */ withAgeUnder(value) { Validation.isInteger(value); @@ -35,6 +51,8 @@ class SandboxAgeVerificationBuilder { /** * @param {string} value + * + * @returns {SandboxAgeVerificationBuilder} */ withDerivation(value) { Validation.isString(value, 'derivation'); @@ -44,6 +62,8 @@ class SandboxAgeVerificationBuilder { /** * @param {SandboxAnchor[]} value + * + * @returns {SandboxAgeVerificationBuilder} */ withAnchors(anchors) { Validation.isArrayOfType(anchors, SandboxAnchor, 'anchors'); @@ -51,6 +71,9 @@ class SandboxAgeVerificationBuilder { return this; } + /** + * @returns {SandboxAgeVerification} + */ build() { return new SandboxAgeVerification(this.dateOfBirth, this.derivation, this.anchors); } diff --git a/src/sandbox/profile/request/token.builder.js b/src/sandbox/profile/request/token.builder.js index bf621ef7..99ce9f81 100644 --- a/src/sandbox/profile/request/token.builder.js +++ b/src/sandbox/profile/request/token.builder.js @@ -102,6 +102,20 @@ class TokenRequestBuilder { return this.withAttribute(sandboxAttribute); } + /** + * @param {string} value + * @param {SandboxAnchor[]} + * + * @returns {TokenRequestBuilder} + */ + withDateOfBirthString(value, anchors = null) { + Validation.isString(value, 'value'); + return this.withDateOfBirth( + YotiDate.fromDateString(value), + anchors + ); + } + /** * @param {SandboxAgeVerification} sandboxAgeVerification * diff --git a/tests/sandbox/request/attribute/derivation/age.verification.spec.js b/tests/sandbox/request/attribute/derivation/age.verification.spec.js index 93e66dd0..8e2d749f 100644 --- a/tests/sandbox/request/attribute/derivation/age.verification.spec.js +++ b/tests/sandbox/request/attribute/derivation/age.verification.spec.js @@ -30,6 +30,23 @@ describe('SandboxAgeVerification', () => { expect(JSON.stringify(sandboxAttribute)) .toBe(JSON.stringify(expectedData)); }); + it('should build age over attribute with date of birth string', () => { + const sandboxAttribute = new SandboxAgeVerificationBuilder() + .withDateOfBirthString(SOME_DATE_OF_BIRTH_STRING) + .withAgeOver(SOME_AGE_VALUE) + .build() + .toAttribute(); + + const expectedData = { + name: 'date_of_birth', + value: SOME_DATE_OF_BIRTH_STRING, + optional: false, + derivation: SOME_AGE_OVER_DERIVATION_VALUE, + }; + + expect(JSON.stringify(sandboxAttribute)) + .toBe(JSON.stringify(expectedData)); + }); it('should build age under attribute', () => { const sandboxAttribute = new SandboxAgeVerificationBuilder() .withDateOfBirth(SOME_DATE_OF_BIRTH) diff --git a/tests/sandbox/request/token.spec.js b/tests/sandbox/request/token.spec.js index 6a45d3d6..e21ef084 100644 --- a/tests/sandbox/request/token.spec.js +++ b/tests/sandbox/request/token.spec.js @@ -119,6 +119,29 @@ describe('TokenRequest', () => { anchors: [SOME_ANCHOR], }); }); + it('should build with date of birth string', () => { + const tokenRequest = new TokenRequestBuilder() + .withDateOfBirthString(SOME_DATE_OF_BIRTH_STRING) + .build(); + + expect(tokenRequest).toContainAttribute({ + name: 'date_of_birth', + value: SOME_DATE_OF_BIRTH_STRING, + optional: false, + }); + }); + it('should build with date of birth with anchors string', () => { + const tokenRequest = new TokenRequestBuilder() + .withDateOfBirthString(SOME_DATE_OF_BIRTH_STRING, [SOME_ANCHOR]) + .build(); + + expect(tokenRequest).toContainAttribute({ + name: 'date_of_birth', + value: SOME_DATE_OF_BIRTH_STRING, + optional: false, + anchors: [SOME_ANCHOR], + }); + }); it('should build with gender', () => { const tokenRequest = new TokenRequestBuilder() .withGender(SOME_VALUE) From 1dd11aaf06c0c6a9067b7056b3e33985fb3e4e69 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Thu, 26 Sep 2019 17:56:36 +0100 Subject: [PATCH 15/47] SDK-604: Validate date strings --- src/data_type/date.js | 8 +++++++- .../request/attribute/derivation/age.verification.spec.js | 8 ++++++++ 2 files changed, 15 insertions(+), 1 deletion(-) diff --git a/src/data_type/date.js b/src/data_type/date.js index 64d6ff0e..d85c931e 100644 --- a/src/data_type/date.js +++ b/src/data_type/date.js @@ -87,7 +87,13 @@ class YotiDate extends Date { */ static fromDateString(dateString) { Validation.isString(dateString, 'dateString'); - return new YotiDate(Date.parse(dateString) * 1000); + + const milliseconds = Date.parse(dateString); + if (Number.isNaN(milliseconds)) { + throw new TypeError(`${dateString} is not a valid date string`); + } + + return new YotiDate(milliseconds * 1000); } /** diff --git a/tests/sandbox/request/attribute/derivation/age.verification.spec.js b/tests/sandbox/request/attribute/derivation/age.verification.spec.js index 8e2d749f..b0104fad 100644 --- a/tests/sandbox/request/attribute/derivation/age.verification.spec.js +++ b/tests/sandbox/request/attribute/derivation/age.verification.spec.js @@ -30,6 +30,14 @@ describe('SandboxAgeVerification', () => { expect(JSON.stringify(sandboxAttribute)) .toBe(JSON.stringify(expectedData)); }); + it('should error for bad date of birth', () => { + expect(() => { + new SandboxAgeVerificationBuilder() + .withDateOfBirthString('2011-15-35') + .withAgeOver(SOME_AGE_VALUE) + .build(); + }).toThrow(new TypeError('2011-15-35 is not a valid date string')); + }); it('should build age over attribute with date of birth string', () => { const sandboxAttribute = new SandboxAgeVerificationBuilder() .withDateOfBirthString(SOME_DATE_OF_BIRTH_STRING) From 1e148d1e46bcc9b9405338bcd1f83544e899260a Mon Sep 17 00:00:00 2001 From: David Grayston Date: Thu, 26 Sep 2019 18:01:41 +0100 Subject: [PATCH 16/47] SDK-604: Correct exception message tests --- tests/data_type/age.verification.spec.js | 2 +- tests/data_type/signed.timestamp.spec.js | 2 +- .../location.constraint.extension.builder.spec.js | 12 ++++++------ .../transactional.flow.extension.builder.spec.js | 2 +- tests/dynamic_sharing_service/index.spec.js | 2 +- .../policy/dynamic.policy.builder.spec.js | 7 ++++--- tests/request/request.builder.spec.js | 8 ++++---- tests/request/request.spec.js | 8 ++++---- 8 files changed, 22 insertions(+), 21 deletions(-) diff --git a/tests/data_type/age.verification.spec.js b/tests/data_type/age.verification.spec.js index 7ded816a..70c5cf10 100644 --- a/tests/data_type/age.verification.spec.js +++ b/tests/data_type/age.verification.spec.js @@ -22,7 +22,7 @@ describe('AgeVerification', () => { value: 'true', }); expect(() => new AgeVerification(attribute)) - .toThrow(TypeError, `'attribute.name' value '${name}' does not match format '${EXPECTED_PATTERN}'`); + .toThrow(new TypeError(`'attribute.name' value '${name}' does not match format '${EXPECTED_PATTERN}'`)); }); }); }); diff --git a/tests/data_type/signed.timestamp.spec.js b/tests/data_type/signed.timestamp.spec.js index a41ce723..cfdf4442 100644 --- a/tests/data_type/signed.timestamp.spec.js +++ b/tests/data_type/signed.timestamp.spec.js @@ -7,7 +7,7 @@ describe('YotiSignedTimeStamp', () => { describe('#constructor()', () => { it('should only accept YotiDate as timestamp', () => { expect(() => new YotiSignedTimeStamp(0, new Date())) - .toThrow(TypeError, 'timestamp must be instance of YotiDate'); + .toThrow(new TypeError('timestamp must be instance of YotiDate')); }); }); describe('#getVersion()', () => { diff --git a/tests/dynamic_sharing_service/extension/location.constraint.extension.builder.spec.js b/tests/dynamic_sharing_service/extension/location.constraint.extension.builder.spec.js index c02ef5b2..cc114fe6 100644 --- a/tests/dynamic_sharing_service/extension/location.constraint.extension.builder.spec.js +++ b/tests/dynamic_sharing_service/extension/location.constraint.extension.builder.spec.js @@ -12,37 +12,37 @@ describe('LocationConstraintExtensionBuilder', () => { it('should fail for latitude too low', () => { const builder = new LocationConstraintExtensionBuilder() .withLatitude(-91); - expect(() => builder.build()).toThrow(RangeError, "'latitude' value '-91' is less than '-90'"); + expect(() => builder.build()).toThrow(new RangeError("'latitude' value '-91' is less than '-90'")); }); it('should fail for latitude too high', () => { const builder = new LocationConstraintExtensionBuilder() .withLatitude(91); - expect(() => builder.build()).toThrow(RangeError, "'latitude' value '91' is greater than '90'"); + expect(() => builder.build()).toThrow(new RangeError("'latitude' value '91' is greater than '90'")); }); it('should fail for longitude too low', () => { const builder = new LocationConstraintExtensionBuilder() .withLongitude(-181); - expect(() => builder.build()).toThrow(RangeError, "'longitude' value '-181' is less than '-180'"); + expect(() => builder.build()).toThrow(new RangeError("'longitude' value '-181' is less than '-180'")); }); it('should fail for longitude too high', () => { const builder = new LocationConstraintExtensionBuilder() .withLongitude(181); - expect(() => builder.build()).toThrow(RangeError, "'longitude' value '181' is greater than '180'"); + expect(() => builder.build()).toThrow(new RangeError("'longitude' value '181' is greater than '180'")); }); it('should fail for radius less than zero', () => { const builder = new LocationConstraintExtensionBuilder() .withRadius(-1); - expect(() => builder.build()).toThrow(RangeError, "'radius' value '-1' is less than '0'"); + expect(() => builder.build()).toThrow(new RangeError("'radius' value '-1' is less than '0'")); }); it('should fail for uncertainty less than zero', () => { const builder = new LocationConstraintExtensionBuilder() .withMaxUncertainty(-1); - expect(() => builder.build()).toThrow(RangeError, "'maxUncertainty' value '-1' is less than '0'"); + expect(() => builder.build()).toThrow(new RangeError("'maxUncertainty' value '-1' is less than '0'")); }); it('should build constraint with given values', () => { diff --git a/tests/dynamic_sharing_service/extension/transactional.flow.extension.builder.spec.js b/tests/dynamic_sharing_service/extension/transactional.flow.extension.builder.spec.js index bfd40aa8..63065f33 100644 --- a/tests/dynamic_sharing_service/extension/transactional.flow.extension.builder.spec.js +++ b/tests/dynamic_sharing_service/extension/transactional.flow.extension.builder.spec.js @@ -6,7 +6,7 @@ const TRANSACTIONAL_FLOW = 'TRANSACTIONAL_FLOW'; describe('TransactionalFlowExtensionBuilder', () => { it('should fail for null content', () => { const builder = new TransactionalFlowExtensionBuilder(); - expect(() => builder.withContent(null)).toThrow(TypeError, 'content cannot be null'); + expect(() => builder.withContent(null)).toThrow(new TypeError('content cannot be null')); }); it('should build with content', () => { diff --git a/tests/dynamic_sharing_service/index.spec.js b/tests/dynamic_sharing_service/index.spec.js index 8e7614d2..6364fe9d 100644 --- a/tests/dynamic_sharing_service/index.spec.js +++ b/tests/dynamic_sharing_service/index.spec.js @@ -49,7 +49,7 @@ describe('createShareUrl', () => { describe('when a DynamicScenario is not provided', () => { it('should throw error', () => { expect(() => createShareUrl('invalid scenario', privateKeyFile, APP_ID)) - .toThrow(TypeError, 'dynamicScenario must be instance of DynamicScenario'); + .toThrow(new TypeError('dynamicScenario must be instance of DynamicScenario')); }); }); diff --git a/tests/dynamic_sharing_service/policy/dynamic.policy.builder.spec.js b/tests/dynamic_sharing_service/policy/dynamic.policy.builder.spec.js index d8fd4511..ff713d14 100644 --- a/tests/dynamic_sharing_service/policy/dynamic.policy.builder.spec.js +++ b/tests/dynamic_sharing_service/policy/dynamic.policy.builder.spec.js @@ -142,7 +142,8 @@ describe('DynamicPolicyBuilder', () => { it('should fail when invalid attribute objects are used', () => { const builder = new DynamicPolicyBuilder(); - expect(() => builder.withWantedAttribute('invalid attribute')).toThrow(TypeError, 'wantedAttribute must be instance of WantedAttribute'); + expect(() => builder.withWantedAttribute('invalid attribute')) + .toThrow(new TypeError('wantedAttribute must be instance of WantedAttribute')); }); it('should build with age derived attributes', () => { @@ -175,7 +176,7 @@ describe('DynamicPolicyBuilder', () => { new DynamicPolicyBuilder() .withDateOfBirth() .withAgeOver('18'); - }).toThrow(TypeError, 'age must be an integer'); + }).toThrow(new TypeError('age must be an integer')); }); it('should only allow integers for age under', () => { @@ -183,7 +184,7 @@ describe('DynamicPolicyBuilder', () => { new DynamicPolicyBuilder() .withDateOfBirth() .withAgeOver('30'); - }).toThrow(TypeError, 'age must be an integer'); + }).toThrow(new TypeError('age must be an integer')); }); it('should overwrite identical age verification to ensure it only exists once', () => { diff --git a/tests/request/request.builder.spec.js b/tests/request/request.builder.spec.js index a6803ed3..e30c7057 100644 --- a/tests/request/request.builder.spec.js +++ b/tests/request/request.builder.spec.js @@ -87,7 +87,7 @@ describe('RequestBuilder', () => { new RequestBuilder() .withBaseUrl(API_BASE_URL) .build(); - }).toThrow(Error, 'PEM file path or string must be provided'); + }).toThrow(new Error('PEM file path or string must be provided')); }); it('should require a base url', () => { @@ -95,7 +95,7 @@ describe('RequestBuilder', () => { new RequestBuilder() .withPemFilePath(PEM_FILE_PATH) .build(); - }).toThrow(Error, 'Base URL must be specified'); + }).toThrow(new Error('Base URL must be specified')); }); it('should build with valid headers', (done) => { @@ -182,7 +182,7 @@ describe('RequestBuilder', () => { .withHeader('Custom-1', 'valid header') .withHeader('Custom-2', ['invalid header']) .build(); - }).toThrow(TypeError, "'Custom-2' header must be a string"); + }).toThrow(new TypeError("'Custom-2' header must be a string")); }); it('should only accept string header name', () => { @@ -194,7 +194,7 @@ describe('RequestBuilder', () => { .withHeader('Valid-Name', 'value') .withHeader(['Invalid-Name'], 'value') .build(); - }).toThrow(TypeError, 'Header name must be a string'); + }).toThrow(new TypeError('Header name must be a string')); }); }); }); diff --git a/tests/request/request.spec.js b/tests/request/request.spec.js index 939f32fd..2a811ea4 100644 --- a/tests/request/request.spec.js +++ b/tests/request/request.spec.js @@ -51,19 +51,19 @@ describe('YotiRequest', () => { describe('When provided non-string URL', () => { it('should throw TypeError', () => { expect(() => new YotiRequest(SOME_METHOD, ['invalid'], SOME_HEADERS, SOME_PAYLOAD)) - .toThrow(TypeError, 'url must be a string'); + .toThrow(new TypeError('url must be a string')); }); }); describe('When provided invalid payload', () => { it('should throw TypeError', () => { expect(() => new YotiRequest(SOME_METHOD, SOME_URL, SOME_HEADERS, ['invalid'])) - .toThrow(TypeError, 'payload must be instance of Payload'); + .toThrow(new TypeError('payload must be instance of Payload')); }); }); describe('When provided invalid method', () => { it('should throw Error', () => { expect(() => new YotiRequest('INVALID', SOME_URL, SOME_HEADERS, SOME_PAYLOAD)) - .toThrow(Error, 'HTTP method INVALID is not supported'); + .toThrow(new Error('HTTP method INVALID is not supported')); }); }); describe('When provided invalid headers', () => { @@ -74,7 +74,7 @@ describe('YotiRequest', () => { }, }; expect(() => new YotiRequest(SOME_METHOD, SOME_URL, invalidHeader, SOME_PAYLOAD)) - .toThrow(TypeError, 'all values in headers must be a string'); + .toThrow(new TypeError('all values in headers must be a string')); }); }); }); From a06c676b08d2af0d178a7545f1578625aff49a65 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Fri, 27 Sep 2019 11:32:14 +0100 Subject: [PATCH 17/47] SDK-604: Observe the console log using spyOn --- tests/sandbox/client.spec.js | 25 +++++++++++++++++++++++-- 1 file changed, 23 insertions(+), 2 deletions(-) diff --git a/tests/sandbox/client.spec.js b/tests/sandbox/client.spec.js index 85f177c8..587af8b9 100644 --- a/tests/sandbox/client.spec.js +++ b/tests/sandbox/client.spec.js @@ -45,10 +45,23 @@ describe('SandboxClient', () => { .withSandboxUrl(SOME_SANDBOX_URL) .build(); + /** + * Observe the console log. + */ + let consoleLog; + beforeEach(() => { + consoleLog = jest.spyOn(global.console, 'log'); + }); + + /** + * Clean up and restore mocks. + */ afterEach((done) => { nock.cleanAll(); done(); + consoleLog.mockRestore(); }); + it('should return token from sandbox', (done) => { nock(SOME_SANDBOX_URL) .post(SOME_ENDPOINT_PATTERN, JSON.stringify(SOME_TOKEN_REQUEST)) @@ -69,7 +82,10 @@ describe('SandboxClient', () => { sandboxClient .setupSharingProfile(SOME_TOKEN_REQUEST) .catch((err) => { - expect(err.message).toBe('TokenResponse responseData should be an object'); + const expectedMessage = 'TokenResponse responseData should be an object'; + expect(err.message).toBe(expectedMessage); + expect(consoleLog) + .toHaveBeenCalledWith(`Error getting response data: Error: ${expectedMessage}`); done(); }); }); @@ -81,7 +97,10 @@ describe('SandboxClient', () => { sandboxClient .setupSharingProfile(SOME_TOKEN_REQUEST) .catch((err) => { - expect(err.message).toBe('responseData.token must be a string'); + const expectedMessage = 'responseData.token must be a string'; + expect(err.message).toBe(expectedMessage); + expect(consoleLog) + .toHaveBeenCalledWith(`Error getting response data: TypeError: ${expectedMessage}`); done(); }); }); @@ -104,6 +123,8 @@ describe('SandboxClient', () => { .setupSharingProfile(SOME_TOKEN_REQUEST) .catch((err) => { expect(err.message).toBe(invalidResponse.error); + expect(consoleLog) + .toHaveBeenCalledWith(`Error getting data from Connect API: ${invalidResponse.error}`); done(); }); }); From 059d22865c7a4804dd1022c5b5dffbb23dffc3cb Mon Sep 17 00:00:00 2001 From: David Grayston Date: Fri, 27 Sep 2019 15:49:29 +0100 Subject: [PATCH 18/47] SDK-604: Remove unneeded constructor --- src/sandbox/client.builder.js | 9 --------- 1 file changed, 9 deletions(-) diff --git a/src/sandbox/client.builder.js b/src/sandbox/client.builder.js index 385bb42e..16d6303e 100644 --- a/src/sandbox/client.builder.js +++ b/src/sandbox/client.builder.js @@ -7,15 +7,6 @@ const fs = require('fs'); * @class SandboxClientBuilder */ class SandboxClientBuilder { - /** - * Setup default property values. - */ - constructor() { - this.appId = null; - this.pem = null; - this.sandboxUrl = null; - } - /** * @param {string} appId */ From 8a847934601f21cc4cc9dc4a39e0093976613386 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Mon, 30 Sep 2019 16:18:55 +0100 Subject: [PATCH 19/47] SDK-604: Remove unused property --- src/sandbox/profile/request/attribute/anchor.builder.js | 7 ------- 1 file changed, 7 deletions(-) diff --git a/src/sandbox/profile/request/attribute/anchor.builder.js b/src/sandbox/profile/request/attribute/anchor.builder.js index 21ddfa47..1200f2f9 100644 --- a/src/sandbox/profile/request/attribute/anchor.builder.js +++ b/src/sandbox/profile/request/attribute/anchor.builder.js @@ -4,13 +4,6 @@ const { SandboxAnchor } = require('./anchor'); * @class SandboxAnchorBuilder */ class SandboxAnchorBuilder { - /** - * Setup initial property values. - */ - constructor() { - this.anchors = []; - } - /** * @param {string} type * From d527b2429ab85ec6169461c44a1fbdd82e42d8a3 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Mon, 30 Sep 2019 16:28:27 +0100 Subject: [PATCH 20/47] SDK-604: Export one class per file --- src/sandbox/client.builder.js | 6 ++---- src/sandbox/client.js | 6 ++---- src/sandbox/index.js | 10 +++++----- .../profile/request/attribute/anchor.builder.js | 6 ++---- src/sandbox/profile/request/attribute/anchor.js | 4 +--- .../profile/request/attribute/attribute.builder.js | 6 ++---- src/sandbox/profile/request/attribute/attribute.js | 6 ++---- .../attribute/derivation/age.verification.builder.js | 8 +++----- .../request/attribute/derivation/age.verification.js | 8 +++----- src/sandbox/profile/request/token.builder.js | 10 ++++------ src/sandbox/profile/request/token.js | 4 +--- src/sandbox/profile/response/token.js | 4 +--- tests/sandbox/client.spec.js | 2 +- 13 files changed, 29 insertions(+), 51 deletions(-) diff --git a/src/sandbox/client.builder.js b/src/sandbox/client.builder.js index 16d6303e..175dca28 100644 --- a/src/sandbox/client.builder.js +++ b/src/sandbox/client.builder.js @@ -1,5 +1,5 @@ -const { SandboxClient } = require('./client'); +const SandboxClient = require('./client'); const Validation = require('../yoti_common/validation'); const fs = require('fs'); @@ -54,6 +54,4 @@ class SandboxClientBuilder { } } -module.exports = { - SandboxClientBuilder, -}; +module.exports = SandboxClientBuilder; diff --git a/src/sandbox/client.js b/src/sandbox/client.js index 4fbc1b99..f8f35085 100644 --- a/src/sandbox/client.js +++ b/src/sandbox/client.js @@ -1,6 +1,6 @@ const { RequestBuilder } = require('../request/request.builder'); -const { TokenResponse } = require('./profile/response/token'); +const TokenResponse = require('./profile/response/token'); const { Payload } = require('../request/payload'); const Validation = require('../yoti_common/validation'); @@ -57,6 +57,4 @@ class SandboxClient { } } -module.exports = { - SandboxClient, -}; +module.exports = SandboxClient; diff --git a/src/sandbox/index.js b/src/sandbox/index.js index 5e7eff26..a91613de 100644 --- a/src/sandbox/index.js +++ b/src/sandbox/index.js @@ -1,8 +1,8 @@ -const { SandboxClientBuilder } = require('./client.builder'); -const { SandboxAttributeBuilder } = require('./profile/request/attribute/attribute.builder'); -const { SandboxAgeVerificationBuilder } = require('./profile/request/attribute/derivation/age.verification.builder'); -const { SandboxAnchorBuilder } = require('./profile/request/attribute/anchor.builder'); -const { TokenRequestBuilder } = require('./profile/request/token.builder'); +const SandboxClientBuilder = require('./client.builder'); +const SandboxAttributeBuilder = require('./profile/request/attribute/attribute.builder'); +const SandboxAgeVerificationBuilder = require('./profile/request/attribute/derivation/age.verification.builder'); +const SandboxAnchorBuilder = require('./profile/request/attribute/anchor.builder'); +const TokenRequestBuilder = require('./profile/request/token.builder'); module.exports = { SandboxClientBuilder, diff --git a/src/sandbox/profile/request/attribute/anchor.builder.js b/src/sandbox/profile/request/attribute/anchor.builder.js index 1200f2f9..204c840c 100644 --- a/src/sandbox/profile/request/attribute/anchor.builder.js +++ b/src/sandbox/profile/request/attribute/anchor.builder.js @@ -1,4 +1,4 @@ -const { SandboxAnchor } = require('./anchor'); +const SandboxAnchor = require('./anchor'); /** * @class SandboxAnchorBuilder @@ -52,6 +52,4 @@ class SandboxAnchorBuilder { } } -module.exports = { - SandboxAnchorBuilder, -}; +module.exports = SandboxAnchorBuilder; diff --git a/src/sandbox/profile/request/attribute/anchor.js b/src/sandbox/profile/request/attribute/anchor.js index db26fc8a..33c40380 100644 --- a/src/sandbox/profile/request/attribute/anchor.js +++ b/src/sandbox/profile/request/attribute/anchor.js @@ -56,6 +56,4 @@ class SandboxAnchor { } } -module.exports = { - SandboxAnchor, -}; +module.exports = SandboxAnchor; diff --git a/src/sandbox/profile/request/attribute/attribute.builder.js b/src/sandbox/profile/request/attribute/attribute.builder.js index 05a46351..31fb3b7d 100644 --- a/src/sandbox/profile/request/attribute/attribute.builder.js +++ b/src/sandbox/profile/request/attribute/attribute.builder.js @@ -1,4 +1,4 @@ -const { SandboxAttribute } = require('./attribute'); +const SandboxAttribute = require('./attribute'); /** * @class SandboxAttributeBuilder @@ -77,6 +77,4 @@ class SandboxAttributeBuilder { } } -module.exports = { - SandboxAttributeBuilder, -}; +module.exports = SandboxAttributeBuilder; diff --git a/src/sandbox/profile/request/attribute/attribute.js b/src/sandbox/profile/request/attribute/attribute.js index 5a789179..e26d9de3 100644 --- a/src/sandbox/profile/request/attribute/attribute.js +++ b/src/sandbox/profile/request/attribute/attribute.js @@ -1,5 +1,5 @@ const Validation = require('../../../../yoti_common/validation'); -const { SandboxAnchor } = require('./anchor'); +const SandboxAnchor = require('./anchor'); /** * @class SandboxAttribute @@ -89,6 +89,4 @@ class SandboxAttribute { } } -module.exports = { - SandboxAttribute, -}; +module.exports = SandboxAttribute; diff --git a/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js b/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js index 9372ba0e..af616701 100644 --- a/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js +++ b/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js @@ -1,5 +1,5 @@ -const { SandboxAgeVerification } = require('./age.verification'); -const { SandboxAnchor } = require('../anchor'); +const SandboxAgeVerification = require('./age.verification'); +const SandboxAnchor = require('../anchor'); const { YotiDate } = require('../../../../../data_type/date'); const Validation = require('../../../../../yoti_common/validation'); const constants = require('../../../../../yoti_common/constants'); @@ -79,6 +79,4 @@ class SandboxAgeVerificationBuilder { } } -module.exports = { - SandboxAgeVerificationBuilder, -}; +module.exports = SandboxAgeVerificationBuilder; diff --git a/src/sandbox/profile/request/attribute/derivation/age.verification.js b/src/sandbox/profile/request/attribute/derivation/age.verification.js index 1515040c..f5f8557e 100644 --- a/src/sandbox/profile/request/attribute/derivation/age.verification.js +++ b/src/sandbox/profile/request/attribute/derivation/age.verification.js @@ -1,5 +1,5 @@ -const { SandboxAttributeBuilder } = require('../attribute.builder'); -const { SandboxAnchor } = require('../anchor'); +const SandboxAttributeBuilder = require('../attribute.builder'); +const SandboxAnchor = require('../anchor'); const { YotiDate } = require('../../../../../data_type/date'); const Validation = require('../../../../../yoti_common/validation'); const constants = require('../../../../../yoti_common/constants'); @@ -39,6 +39,4 @@ class SandboxAgeVerification { } } -module.exports = { - SandboxAgeVerification, -}; +module.exports = SandboxAgeVerification; diff --git a/src/sandbox/profile/request/token.builder.js b/src/sandbox/profile/request/token.builder.js index 99ce9f81..7f465d6e 100644 --- a/src/sandbox/profile/request/token.builder.js +++ b/src/sandbox/profile/request/token.builder.js @@ -1,6 +1,6 @@ -const { TokenRequest } = require('./token'); -const { SandboxAttributeBuilder } = require('./attribute/attribute.builder'); -const { SandboxAgeVerification } = require('./attribute/derivation/age.verification'); +const TokenRequest = require('./token'); +const SandboxAttributeBuilder = require('./attribute/attribute.builder'); +const SandboxAgeVerification = require('./attribute/derivation/age.verification'); const { YotiDate } = require('../../../data_type/date'); const constants = require('../../../yoti_common/constants'); const Validation = require('../../../yoti_common/validation'); @@ -244,6 +244,4 @@ class TokenRequestBuilder { } } -module.exports = { - TokenRequestBuilder, -}; +module.exports = TokenRequestBuilder; diff --git a/src/sandbox/profile/request/token.js b/src/sandbox/profile/request/token.js index af84bce1..75751c56 100644 --- a/src/sandbox/profile/request/token.js +++ b/src/sandbox/profile/request/token.js @@ -22,6 +22,4 @@ class TokenRequest { } } -module.exports = { - TokenRequest, -}; +module.exports = TokenRequest; diff --git a/src/sandbox/profile/response/token.js b/src/sandbox/profile/response/token.js index d75a5043..2262d702 100644 --- a/src/sandbox/profile/response/token.js +++ b/src/sandbox/profile/response/token.js @@ -24,6 +24,4 @@ class TokenResponse { } } -module.exports = { - TokenResponse, -}; +module.exports = TokenResponse; diff --git a/tests/sandbox/client.spec.js b/tests/sandbox/client.spec.js index 587af8b9..08e6cb79 100644 --- a/tests/sandbox/client.spec.js +++ b/tests/sandbox/client.spec.js @@ -1,7 +1,7 @@ const nock = require('nock'); const fs = require('fs'); const { SandboxClientBuilder, TokenRequestBuilder } = require('../..'); -const { SandboxClient } = require('../../src/sandbox/client'); +const SandboxClient = require('../../src/sandbox/client'); const SOME_APP_ID = 'someAppId'; const SOME_SANDBOX_URL = 'https://somesandbox.yoti.com/api/v1'; From 02b6fa959b4ed2337159e05c10864cc4e865f01b Mon Sep 17 00:00:00 2001 From: David Grayston Date: Mon, 30 Sep 2019 16:30:36 +0100 Subject: [PATCH 21/47] SDK-604: Correct JSDoc --- src/sandbox/profile/request/attribute/anchor.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/sandbox/profile/request/attribute/anchor.js b/src/sandbox/profile/request/attribute/anchor.js index 33c40380..7d44b231 100644 --- a/src/sandbox/profile/request/attribute/anchor.js +++ b/src/sandbox/profile/request/attribute/anchor.js @@ -5,7 +5,7 @@ class SandboxAnchor { /** * @param {string} type * @param {string} value - * @param {*} subType + * @param {string} subType * @param {DateTime} timestamp */ constructor(type, value, subType, timestamp) { From 078de8eda5a88b54bd28da5146627592c182b86f Mon Sep 17 00:00:00 2001 From: David Grayston Date: Tue, 1 Oct 2019 11:43:23 +0100 Subject: [PATCH 22/47] SDK-604: Move sandbox out of src --- index.js | 13 ------------- {src/sandbox => sandbox}/client.builder.js | 2 +- {src/sandbox => sandbox}/client.js | 6 +++--- {src/sandbox => sandbox}/index.js | 0 .../profile/request/attribute/anchor.builder.js | 0 .../profile/request/attribute/anchor.js | 0 .../profile/request/attribute/attribute.builder.js | 0 .../profile/request/attribute/attribute.js | 2 +- .../derivation/age.verification.builder.js | 6 +++--- .../attribute/derivation/age.verification.js | 6 +++--- .../profile/request/token.builder.js | 6 +++--- {src/sandbox => sandbox}/profile/request/token.js | 0 {src/sandbox => sandbox}/profile/response/token.js | 2 +- tests/sandbox/client.spec.js | 4 ++-- tests/sandbox/request/attribute/anchor.spec.js | 2 +- tests/sandbox/request/attribute/attribute.spec.js | 2 +- .../attribute/derivation/age.verification.spec.js | 3 +++ tests/sandbox/request/token.spec.js | 3 +++ 18 files changed, 25 insertions(+), 32 deletions(-) rename {src/sandbox => sandbox}/client.builder.js (94%) rename {src/sandbox => sandbox}/client.js (88%) rename {src/sandbox => sandbox}/index.js (100%) rename {src/sandbox => sandbox}/profile/request/attribute/anchor.builder.js (100%) rename {src/sandbox => sandbox}/profile/request/attribute/anchor.js (100%) rename {src/sandbox => sandbox}/profile/request/attribute/attribute.builder.js (100%) rename {src/sandbox => sandbox}/profile/request/attribute/attribute.js (95%) rename {src/sandbox => sandbox}/profile/request/attribute/derivation/age.verification.builder.js (89%) rename {src/sandbox => sandbox}/profile/request/attribute/derivation/age.verification.js (83%) rename {src/sandbox => sandbox}/profile/request/token.builder.js (96%) rename {src/sandbox => sandbox}/profile/request/token.js (100%) rename {src/sandbox => sandbox}/profile/response/token.js (89%) diff --git a/index.js b/index.js index ba9c2576..86b4a735 100644 --- a/index.js +++ b/index.js @@ -6,14 +6,6 @@ const { RequestBuilder } = require('./src/request/request.builder'); const { Payload } = require('./src/request/payload'); const { YotiDate } = require('./src/data_type/date'); -const { - SandboxClientBuilder, - SandboxAttributeBuilder, - SandboxAgeVerificationBuilder, - SandboxAnchorBuilder, - TokenRequestBuilder, -} = require('./src/sandbox'); - const { DynamicScenarioBuilder, DynamicPolicyBuilder, @@ -41,10 +33,5 @@ module.exports = { SourceConstraintBuilder, RequestBuilder, Payload, - SandboxClientBuilder, - SandboxAttributeBuilder, - SandboxAgeVerificationBuilder, - SandboxAnchorBuilder, - TokenRequestBuilder, YotiDate, }; diff --git a/src/sandbox/client.builder.js b/sandbox/client.builder.js similarity index 94% rename from src/sandbox/client.builder.js rename to sandbox/client.builder.js index 175dca28..9fef5c17 100644 --- a/src/sandbox/client.builder.js +++ b/sandbox/client.builder.js @@ -1,6 +1,6 @@ const SandboxClient = require('./client'); -const Validation = require('../yoti_common/validation'); +const Validation = require('../src/yoti_common/validation'); const fs = require('fs'); /** diff --git a/src/sandbox/client.js b/sandbox/client.js similarity index 88% rename from src/sandbox/client.js rename to sandbox/client.js index f8f35085..ccf2233d 100644 --- a/src/sandbox/client.js +++ b/sandbox/client.js @@ -1,8 +1,8 @@ -const { RequestBuilder } = require('../request/request.builder'); +const { RequestBuilder } = require('../src/request/request.builder'); const TokenResponse = require('./profile/response/token'); -const { Payload } = require('../request/payload'); -const Validation = require('../yoti_common/validation'); +const { Payload } = require('../src/request/payload'); +const Validation = require('../src/yoti_common/validation'); /** * @class SandboxClient diff --git a/src/sandbox/index.js b/sandbox/index.js similarity index 100% rename from src/sandbox/index.js rename to sandbox/index.js diff --git a/src/sandbox/profile/request/attribute/anchor.builder.js b/sandbox/profile/request/attribute/anchor.builder.js similarity index 100% rename from src/sandbox/profile/request/attribute/anchor.builder.js rename to sandbox/profile/request/attribute/anchor.builder.js diff --git a/src/sandbox/profile/request/attribute/anchor.js b/sandbox/profile/request/attribute/anchor.js similarity index 100% rename from src/sandbox/profile/request/attribute/anchor.js rename to sandbox/profile/request/attribute/anchor.js diff --git a/src/sandbox/profile/request/attribute/attribute.builder.js b/sandbox/profile/request/attribute/attribute.builder.js similarity index 100% rename from src/sandbox/profile/request/attribute/attribute.builder.js rename to sandbox/profile/request/attribute/attribute.builder.js diff --git a/src/sandbox/profile/request/attribute/attribute.js b/sandbox/profile/request/attribute/attribute.js similarity index 95% rename from src/sandbox/profile/request/attribute/attribute.js rename to sandbox/profile/request/attribute/attribute.js index e26d9de3..affbe7d6 100644 --- a/src/sandbox/profile/request/attribute/attribute.js +++ b/sandbox/profile/request/attribute/attribute.js @@ -1,4 +1,4 @@ -const Validation = require('../../../../yoti_common/validation'); +const Validation = require('../../../../src/yoti_common/validation'); const SandboxAnchor = require('./anchor'); /** diff --git a/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js b/sandbox/profile/request/attribute/derivation/age.verification.builder.js similarity index 89% rename from src/sandbox/profile/request/attribute/derivation/age.verification.builder.js rename to sandbox/profile/request/attribute/derivation/age.verification.builder.js index af616701..9e10854a 100644 --- a/src/sandbox/profile/request/attribute/derivation/age.verification.builder.js +++ b/sandbox/profile/request/attribute/derivation/age.verification.builder.js @@ -1,8 +1,8 @@ const SandboxAgeVerification = require('./age.verification'); const SandboxAnchor = require('../anchor'); -const { YotiDate } = require('../../../../../data_type/date'); -const Validation = require('../../../../../yoti_common/validation'); -const constants = require('../../../../../yoti_common/constants'); +const { YotiDate } = require('../../../../../src/data_type/date'); +const Validation = require('../../../../../src/yoti_common/validation'); +const constants = require('../../../../../src/yoti_common/constants'); /** * @class SandboxAgeVerificationBuilder diff --git a/src/sandbox/profile/request/attribute/derivation/age.verification.js b/sandbox/profile/request/attribute/derivation/age.verification.js similarity index 83% rename from src/sandbox/profile/request/attribute/derivation/age.verification.js rename to sandbox/profile/request/attribute/derivation/age.verification.js index f5f8557e..a5f48274 100644 --- a/src/sandbox/profile/request/attribute/derivation/age.verification.js +++ b/sandbox/profile/request/attribute/derivation/age.verification.js @@ -1,8 +1,8 @@ const SandboxAttributeBuilder = require('../attribute.builder'); const SandboxAnchor = require('../anchor'); -const { YotiDate } = require('../../../../../data_type/date'); -const Validation = require('../../../../../yoti_common/validation'); -const constants = require('../../../../../yoti_common/constants'); +const { YotiDate } = require('../../../../../src/data_type/date'); +const Validation = require('../../../../../src/yoti_common/validation'); +const constants = require('../../../../../src/yoti_common/constants'); /** * @class SandboxAgeVerification diff --git a/src/sandbox/profile/request/token.builder.js b/sandbox/profile/request/token.builder.js similarity index 96% rename from src/sandbox/profile/request/token.builder.js rename to sandbox/profile/request/token.builder.js index 7f465d6e..b23f4764 100644 --- a/src/sandbox/profile/request/token.builder.js +++ b/sandbox/profile/request/token.builder.js @@ -1,9 +1,9 @@ const TokenRequest = require('./token'); const SandboxAttributeBuilder = require('./attribute/attribute.builder'); const SandboxAgeVerification = require('./attribute/derivation/age.verification'); -const { YotiDate } = require('../../../data_type/date'); -const constants = require('../../../yoti_common/constants'); -const Validation = require('../../../yoti_common/validation'); +const { YotiDate } = require('../../../src/data_type/date'); +const constants = require('../../../src/yoti_common/constants'); +const Validation = require('../../../src/yoti_common/validation'); /** * @param {string} name diff --git a/src/sandbox/profile/request/token.js b/sandbox/profile/request/token.js similarity index 100% rename from src/sandbox/profile/request/token.js rename to sandbox/profile/request/token.js diff --git a/src/sandbox/profile/response/token.js b/sandbox/profile/response/token.js similarity index 89% rename from src/sandbox/profile/response/token.js rename to sandbox/profile/response/token.js index 2262d702..a3a56412 100644 --- a/src/sandbox/profile/response/token.js +++ b/sandbox/profile/response/token.js @@ -1,4 +1,4 @@ -const Validation = require('../../../yoti_common/validation'); +const Validation = require('../../../src/yoti_common/validation'); /** * @class TokenResponse diff --git a/tests/sandbox/client.spec.js b/tests/sandbox/client.spec.js index 08e6cb79..d74a5938 100644 --- a/tests/sandbox/client.spec.js +++ b/tests/sandbox/client.spec.js @@ -1,7 +1,7 @@ const nock = require('nock'); const fs = require('fs'); -const { SandboxClientBuilder, TokenRequestBuilder } = require('../..'); -const SandboxClient = require('../../src/sandbox/client'); +const { SandboxClientBuilder, TokenRequestBuilder } = require('../../sandbox'); +const SandboxClient = require('../../sandbox/client'); const SOME_APP_ID = 'someAppId'; const SOME_SANDBOX_URL = 'https://somesandbox.yoti.com/api/v1'; diff --git a/tests/sandbox/request/attribute/anchor.spec.js b/tests/sandbox/request/attribute/anchor.spec.js index 3f8f6ddc..8b3eed0d 100644 --- a/tests/sandbox/request/attribute/anchor.spec.js +++ b/tests/sandbox/request/attribute/anchor.spec.js @@ -1,6 +1,6 @@ const { SandboxAnchorBuilder, -} = require('../../../..'); +} = require('../../../../sandbox'); const SOME_ANCHOR_TYPE = 'someAnchorType'; const SOME_ANCHOR_SUB_TYPE = 'someAnchorSubType'; diff --git a/tests/sandbox/request/attribute/attribute.spec.js b/tests/sandbox/request/attribute/attribute.spec.js index 2141dbba..99d06b26 100644 --- a/tests/sandbox/request/attribute/attribute.spec.js +++ b/tests/sandbox/request/attribute/attribute.spec.js @@ -1,7 +1,7 @@ const { SandboxAttributeBuilder, SandboxAnchorBuilder, -} = require('../../../..'); +} = require('../../../../sandbox'); const SOME_NAME = 'someName'; const SOME_VALUE = 'someValue'; diff --git a/tests/sandbox/request/attribute/derivation/age.verification.spec.js b/tests/sandbox/request/attribute/derivation/age.verification.spec.js index b0104fad..0b0d6095 100644 --- a/tests/sandbox/request/attribute/derivation/age.verification.spec.js +++ b/tests/sandbox/request/attribute/derivation/age.verification.spec.js @@ -1,6 +1,9 @@ const { SandboxAgeVerificationBuilder, SandboxAnchorBuilder, +} = require('../../../../../sandbox'); + +const { YotiDate, } = require('../../../../..'); diff --git a/tests/sandbox/request/token.spec.js b/tests/sandbox/request/token.spec.js index e21ef084..e3753214 100644 --- a/tests/sandbox/request/token.spec.js +++ b/tests/sandbox/request/token.spec.js @@ -2,6 +2,9 @@ const { TokenRequestBuilder, SandboxAgeVerificationBuilder, SandboxAnchorBuilder, +} = require('../../../sandbox'); + +const { YotiDate, } = require('../../..'); From 06c85b5b7f3c1b8100af6ce90051cbd82901262b Mon Sep 17 00:00:00 2001 From: David Grayston Date: Tue, 1 Oct 2019 11:45:14 +0100 Subject: [PATCH 23/47] SDK-604: Lint sandbox directory --- package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/package.json b/package.json index fec1134e..245bd559 100644 --- a/package.json +++ b/package.json @@ -12,7 +12,7 @@ "node": ">=8.0.0" }, "scripts": { - "lint": "node_modules/.bin/eslint *.js './src/**/*.js' './tests/**/*.spec.js' config/*.js", + "lint": "node_modules/.bin/eslint *.js './src/**/*.js' './tests/**/*.spec.js' config/*.js './sandbox/**/*.js'", "unit-test": "node_modules/.bin/jest", "test": "npm run lint && npm run unit-test" }, From f1c5f3582d8609fb3b69baf63901c276025071ae Mon Sep 17 00:00:00 2001 From: David Grayston Date: Tue, 1 Oct 2019 11:46:44 +0100 Subject: [PATCH 24/47] SDK-604: Collect coverage for sandbox directory --- package.json | 1 + 1 file changed, 1 insertion(+) diff --git a/package.json b/package.json index 245bd559..fb6a436b 100644 --- a/package.json +++ b/package.json @@ -27,6 +27,7 @@ "collectCoverageFrom": [ "./*.js", "./src/**/*.js", + "./sandbox/**/*.js", "!**/node_modules/**", "!**/vendor/**" ], From d8f3a6fbd9edb989181ad101bbacd0ef5e750f87 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Fri, 4 Oct 2019 10:52:00 +0100 Subject: [PATCH 25/47] SDK-1208: Move X-Yoti-Auth-Key header out of request builder --- src/profile_service/index.js | 4 +- src/request/index.js | 13 ++- src/request/request.builder.js | 10 ++- tests/client/index.spec.js | 22 ++++- tests/request/request.builder.spec.js | 118 +++++++++++++------------- 5 files changed, 101 insertions(+), 66 deletions(-) diff --git a/src/profile_service/index.js b/src/profile_service/index.js index af5b65e9..7b2ade99 100644 --- a/src/profile_service/index.js +++ b/src/profile_service/index.js @@ -9,7 +9,9 @@ module.exports.getReceipt = (token, pem, appId) => { 'GET', `/profile/${token}`, pem, - appId + appId, + null, + { 'X-Yoti-Auth-Key': yotiCommon.getAuthKeyFromPem(pem) } ); return new Promise((resolve, reject) => { diff --git a/src/request/index.js b/src/request/index.js index bb9b8df8..0ccf5ce3 100644 --- a/src/request/index.js +++ b/src/request/index.js @@ -11,7 +11,14 @@ const { RequestBuilder } = require('./request.builder'); * * @returns {SignedRequest} */ -module.exports.buildConnectApiRequest = (httpMethod, endpoint, pem, appId, payload) => { +module.exports.buildConnectApiRequest = ( + httpMethod, + endpoint, + pem, + appId, + payload, + headers +) => { const requestBuilder = new RequestBuilder() .withBaseUrl(config.yoti.connectApi) .withPemString(pem) @@ -19,6 +26,10 @@ module.exports.buildConnectApiRequest = (httpMethod, endpoint, pem, appId, paylo .withQueryParam('appId', appId) .withMethod(httpMethod); + if (headers) { + Object.keys(headers).forEach(name => requestBuilder.withHeader(name, headers[name])); + } + if (payload) { requestBuilder.withPayload(payload); } diff --git a/src/request/request.builder.js b/src/request/request.builder.js index ee355230..fecd6cde 100644 --- a/src/request/request.builder.js +++ b/src/request/request.builder.js @@ -138,14 +138,18 @@ class RequestBuilder { * @param {*} messageSignature */ getDefaultHeaders(messageSignature) { - return { - 'X-Yoti-Auth-Key': yotiCommon.getAuthKeyFromPem(this.pem), + const defaultHeaders = { 'X-Yoti-Auth-Digest': messageSignature, 'X-Yoti-SDK': SDK_IDENTIFIER, 'X-Yoti-SDK-Version': `${SDK_IDENTIFIER}-${yotiPackage.version}`, - 'Content-Type': 'application/json', Accept: 'application/json', }; + + if (this.payload) { + defaultHeaders['Content-Type'] = 'application/json'; + } + + return defaultHeaders; } /** diff --git a/tests/client/index.spec.js b/tests/client/index.spec.js index 1e12eb84..a6d2054c 100644 --- a/tests/client/index.spec.js +++ b/tests/client/index.spec.js @@ -11,6 +11,13 @@ const ShareUrlResult = require('../../src/dynamic_sharing_service/share.url.resu const privateKeyFile = fs.readFileSync('./tests/sample-data/keys/node-sdk-test.pem', 'utf8'); const yotiClient = new yoti.Client('stub-app-id', privateKeyFile); +const CONTENT_TYPE_HEADER_NAME = 'Content-Type'; +const CONTENT_TYPE_JSON = 'application/json'; +const DIGEST_KEY_HEADER_NAME = 'X-Yoti-Auth-Digest'; +const DIGEST_KEY_PATTERN = /^[a-zA-Z0-9/+=]{344}$/; +const AUTH_KEY_HEADER_NAME = 'X-Yoti-Auth-Key'; +const AUTH_KEY_PATTERN = /^[a-zA-Z0-9/+]{392}$/; + describe('yotiClient', () => { const encryptedYotiToken = 'c31Db4y6ClxSWy26xDpa9LEX3ZTUuR-rKaAhjQWnmKilR20IshkysR5Y3Hh3R6hanOyxcu7fl5vbjikkGZZb3_iH6NjxmBXuGY_Fr23AhrHvGL9WMg4EtemVvr6VI2f_5H_PDhDpYUvv-YpEM0f_SReoVxGIc8VGfj1gukuhPyNJ9hs55-SDdUjN77JiA6FPcYZxEIaqQE_yT_c3Y4V72Jnq3RHbG0vL6SefSfY_fFsnx_HeddsJc10qJYCwAkdGzVzbJH2DQ2Swp821Gwyj9eNK54S6HvpIg7LclID7BtymG6z7cTNp3fXX7mgKYoQlh_DHmPmaiqyj398w424RBg=='; const decryptedToken = 'i79CctmY-22ad195c-d166-49a2-af16-8f356788c9dd-be094d26-19b5-450d-afce-070101760f0b'; @@ -33,10 +40,11 @@ describe('yotiClient', () => { beforeEach((done) => { nock(`${config.yoti.connectApi}`) .get(profileEndpointPattern) + .matchHeader(DIGEST_KEY_HEADER_NAME, DIGEST_KEY_PATTERN) + .matchHeader(AUTH_KEY_HEADER_NAME, AUTH_KEY_PATTERN) .reply(200, responseContent); done(); }); - it('should fetch and decrypt the profile', (done) => { yotiClient.getActivityDetails(encryptedYotiToken) .then((activityDetails) => { @@ -80,6 +88,8 @@ describe('yotiClient', () => { beforeEach((done) => { nock(`${config.yoti.connectApi}`) .get(profileEndpointPattern) + .matchHeader(AUTH_KEY_HEADER_NAME, AUTH_KEY_PATTERN) + .matchHeader(DIGEST_KEY_HEADER_NAME, DIGEST_KEY_PATTERN) .reply(200, responseContentNull); done(); }); @@ -109,6 +119,8 @@ describe('yotiClient', () => { beforeEach((done) => { nock(`${config.yoti.connectApi}`) .get(profileEndpointPattern) + .matchHeader(AUTH_KEY_HEADER_NAME, AUTH_KEY_PATTERN) + .matchHeader(DIGEST_KEY_HEADER_NAME, DIGEST_KEY_PATTERN) .reply(200, responseContentEmptyObj); done(); }); @@ -138,6 +150,8 @@ describe('yotiClient', () => { beforeEach((done) => { nock(`${config.yoti.connectApi}`) .get(profileEndpointPattern) + .matchHeader(AUTH_KEY_HEADER_NAME, AUTH_KEY_PATTERN) + .matchHeader(DIGEST_KEY_HEADER_NAME, DIGEST_KEY_PATTERN) .reply(200, responseContentNonExistent); done(); }); @@ -171,6 +185,8 @@ describe('yotiClient', () => { beforeEach((done) => { nock(`${config.yoti.connectApi}`) .post(new RegExp('^/api/v1/aml-check?.*appId=stub-app-id&nonce=.*?×tamp=.*?'), amlPayload.getPayloadJSON()) + .matchHeader(DIGEST_KEY_HEADER_NAME, DIGEST_KEY_PATTERN) + .matchHeader(CONTENT_TYPE_HEADER_NAME, CONTENT_TYPE_JSON) .reply(200, amlCheckResult); done(); @@ -198,7 +214,9 @@ describe('yotiClient', () => { const SHARE_URL_RESULT = './tests/sample-data/responses/share-url-result.json'; beforeEach((done) => { nock(`${config.yoti.connectApi}`) - .post(new RegExp('^/api/v1/qrcodes/apps/')) + .post(new RegExp('^/api/v1/qrcodes/apps/'), JSON.stringify(dynamicScenario)) + .matchHeader(DIGEST_KEY_HEADER_NAME, DIGEST_KEY_PATTERN) + .matchHeader(CONTENT_TYPE_HEADER_NAME, CONTENT_TYPE_JSON) .reply(200, fs.readFileSync(SHARE_URL_RESULT)); done(); }); diff --git a/tests/request/request.builder.spec.js b/tests/request/request.builder.spec.js index e30c7057..89585d58 100644 --- a/tests/request/request.builder.spec.js +++ b/tests/request/request.builder.spec.js @@ -1,54 +1,22 @@ const nock = require('nock'); const fs = require('fs'); -const { YotiRequest } = require('../../src/request/request'); -const { RequestBuilder } = require('../../'); +const { RequestBuilder, Payload } = require('../../'); const yotiPackage = require('../../package.json'); const PEM_FILE_PATH = './tests/sample-data/keys/node-sdk-test.pem'; const PEM_STRING = fs.readFileSync(PEM_FILE_PATH, 'utf8'); const API_BASE_URL = 'https://api.example.com'; const API_ENDPOINT = '/some-endpoint'; - -/** - * Assert that the signed request was built correctly. - * - * @param {Request} request - */ -const assertExpectedRequest = (request, done) => { - expect(request).toBeInstanceOf(YotiRequest); - - // Check that auth headers are present. - request.execute() - .then((response) => { - const sentHeaders = response.getParsedResponse().headers; - - const expectedHeaders = { - 'X-Yoti-SDK': 'Node', - 'X-Yoti-SDK-Version': `Node-${yotiPackage.version}`, - 'Content-Type': 'application/json', - Accept: 'application/json', - }; - - Object.keys(expectedHeaders).forEach((header) => { - const sentHeader = sentHeaders[header.toLowerCase()]; - expect(sentHeader).toBe(expectedHeaders[header], header); - }); - - const expectedMatchHeaders = { - 'X-Yoti-Auth-Key': new RegExp('^[a-zA-Z0-9/+]{392}$'), - 'X-Yoti-Auth-Digest': new RegExp('^[a-zA-Z0-9/+=]{344}$'), - }; - - Object.keys(expectedMatchHeaders).forEach((header) => { - const sentHeader = sentHeaders[header.toLowerCase()]; - expect(sentHeader).toMatch(expectedMatchHeaders[header], header); - }); - - done(); - }) - .catch(done); +const CONTENT_TYPE_HEADER_NAME = 'Content-Type'; +const CONTENT_TYPE_JSON = 'application/json'; +const DEFAULT_HEADERS = { + 'X-Yoti-SDK': 'Node', + 'X-Yoti-SDK-Version': `Node-${yotiPackage.version}`, + Accept: CONTENT_TYPE_JSON, + 'X-Yoti-Auth-Digest': new RegExp('^[a-zA-Z0-9/+=]{344}$'), }; +const SOME_PAYLOAD = new Payload({ some: 'data' }); describe('RequestBuilder', () => { beforeEach((done) => { @@ -60,7 +28,7 @@ describe('RequestBuilder', () => { done(); }); describe('#build', () => { - it('should build a Request with pem string', (done) => { + it('should build a Request with pem string', () => { const request = new RequestBuilder() .withBaseUrl(API_BASE_URL) .withPemString(PEM_STRING) @@ -68,10 +36,11 @@ describe('RequestBuilder', () => { .withGet() .build(); - assertExpectedRequest(request, done); + expect(request).toHaveHeaders(DEFAULT_HEADERS); + expect(request.getHeaders()[CONTENT_TYPE_HEADER_NAME]).toBeUndefined(); }); - it('should build a Request with pem file path', (done) => { + it('should build a Request with pem file path', () => { const request = new RequestBuilder() .withBaseUrl(API_BASE_URL) .withPemFilePath(PEM_FILE_PATH) @@ -79,7 +48,7 @@ describe('RequestBuilder', () => { .withGet() .build(); - assertExpectedRequest(request, done); + expect(request).toHaveHeaders(DEFAULT_HEADERS); }); it('should require a PEM string or file', () => { @@ -98,7 +67,7 @@ describe('RequestBuilder', () => { }).toThrow(new Error('Base URL must be specified')); }); - it('should build with valid headers', (done) => { + it('should build with valid headers', () => { const request = new RequestBuilder() .withBaseUrl(API_BASE_URL) .withPemFilePath(PEM_FILE_PATH) @@ -108,15 +77,11 @@ describe('RequestBuilder', () => { .withGet() .build(); - request - .execute() - .then((response) => { - const headers = response.getParsedResponse().headers; - expect(headers['custom-1']).toBe('value 1'); - expect(headers['custom-2']).toBe('value 2'); - done(); - }) - .catch(done); + expect(request).toHaveHeaders(DEFAULT_HEADERS); + expect(request).toHaveHeaders({ + 'Custom-1': 'value 1', + 'Custom-2': 'value 2', + }); }); }); describe('#withEndpoint', () => { @@ -124,7 +89,7 @@ describe('RequestBuilder', () => { `///${API_ENDPOINT}`, API_ENDPOINT.replace(/^\/+/, ''), ].forEach((endpoint) => { - it(`should ensure "${endpoint}" has one leading slash`, (done) => { + it(`should ensure "${endpoint}" has one leading slash`, () => { const request = new RequestBuilder() .withBaseUrl(`${API_BASE_URL}`) .withPemFilePath(PEM_FILE_PATH) @@ -132,12 +97,12 @@ describe('RequestBuilder', () => { .withGet() .build(); - assertExpectedRequest(request, done); + expect(request).toHaveHeaders(DEFAULT_HEADERS); }); }); }); describe('#withBaseUrl', () => { - it('should remove trailing slashes', (done) => { + it('should remove trailing slashes', () => { const request = new RequestBuilder() .withBaseUrl(`${API_BASE_URL}///`) .withPemFilePath(PEM_FILE_PATH) @@ -145,7 +110,22 @@ describe('RequestBuilder', () => { .withGet() .build(); - assertExpectedRequest(request, done); + expect(request).toHaveHeaders(DEFAULT_HEADERS); + }); + }); + describe('#withPayload', () => { + it('should set the provided payload', () => { + const request = new RequestBuilder() + .withBaseUrl(API_BASE_URL) + .withPemFilePath(PEM_FILE_PATH) + .withEndpoint(API_ENDPOINT) + .withPayload(SOME_PAYLOAD) + .withPost() + .build(); + + expect(request.getPayload()).toStrictEqual(SOME_PAYLOAD); + expect(request).toHaveHeaders(DEFAULT_HEADERS); + expect(request.getHeaders()[CONTENT_TYPE_HEADER_NAME]).toBe(CONTENT_TYPE_JSON); }); }); describe('#withGet', () => { @@ -198,3 +178,23 @@ describe('RequestBuilder', () => { }); }); }); + +expect.extend({ + toHaveHeaders(request, expectedHeaders) { + Object.keys(expectedHeaders).forEach((header) => { + const headerValue = request.getHeaders()[header]; + const expectedHeaderValue = expectedHeaders[header]; + + if (expectedHeaderValue instanceof RegExp) { + expect(headerValue).toMatch(expectedHeaderValue); + } else { + expect(headerValue).toBe(expectedHeaderValue); + } + }); + return { + message: () => + 'Request contains expected headers', + pass: true, + }; + }, +}); From 2d78b0c5671af5c6ec9a11f2102d1b92a7bcab9e Mon Sep 17 00:00:00 2001 From: David Grayston Date: Tue, 8 Oct 2019 17:04:06 +0100 Subject: [PATCH 26/47] SDK-1236: Update supported Node version in package.json --- package.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/package.json b/package.json index fb6a436b..b86e530b 100644 --- a/package.json +++ b/package.json @@ -9,7 +9,7 @@ "url": "https://github.com/getyoti/yoti-node-sdk.git" }, "engines": { - "node": ">=8.0.0" + "node": ">=6" }, "scripts": { "lint": "node_modules/.bin/eslint *.js './src/**/*.js' './tests/**/*.spec.js' config/*.js './sandbox/**/*.js'", From 14cc1f83c5e974656cf96542bfd269fba215f2dd Mon Sep 17 00:00:00 2001 From: David Grayston Date: Thu, 10 Oct 2019 14:21:15 +0100 Subject: [PATCH 27/47] SDK-1239: Add Coveralls to Travis CI --- .travis.yml | 8 +++++++- README.md | 1 + package-lock.json | 40 ++++++++++++++++++++++++++++++++++++++++ package.json | 8 +++++--- 4 files changed, 53 insertions(+), 4 deletions(-) diff --git a/.travis.yml b/.travis.yml index 811442c0..ea51c391 100644 --- a/.travis.yml +++ b/.travis.yml @@ -55,4 +55,10 @@ jobs: - cd ./examples/profile - npm update - npm run lint - + - stage: Coverage + name: Coveralls + if: type = pull_request OR branch = master + node_js: "10" + install: npm install + script: + - npm run coveralls diff --git a/README.md b/README.md index 724a3779..1ade3ed3 100755 --- a/README.md +++ b/README.md @@ -1,6 +1,7 @@ # Yoti NodeJS SDK [![Build Status](https://travis-ci.com/getyoti/yoti-node-sdk.svg?branch=master)](https://travis-ci.com/getyoti/yoti-node-sdk) +[![Coverage Status](https://coveralls.io/repos/github/getyoti/yoti-node-sdk/badge.svg?branch=master)](https://coveralls.io/github/getyoti/yoti-node-sdk?branch=master) Welcome to the Yoti NodeJS SDK. This repo contains the tools and step by step instructions you need to quickly integrate your NodeJS back-end with Yoti so that your users can share their identity details with your application in a secure and trusted way. diff --git a/package-lock.json b/package-lock.json index 94d57d8d..0a18262a 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1319,6 +1319,28 @@ } } }, + "coveralls": { + "version": "3.0.6", + "resolved": "https://registry.npmjs.org/coveralls/-/coveralls-3.0.6.tgz", + "integrity": "sha512-Pgh4v3gCI4T/9VijVrm8Ym5v0OgjvGLKj3zTUwkvsCiwqae/p6VLzpsFNjQS2i6ewV7ef+DjFJ5TSKxYt/mCrA==", + "dev": true, + "requires": { + "growl": "~> 1.10.0", + "js-yaml": "^3.13.1", + "lcov-parse": "^0.0.10", + "log-driver": "^1.2.7", + "minimist": "^1.2.0", + "request": "^2.86.0" + }, + "dependencies": { + "minimist": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.0.tgz", + "integrity": "sha1-o1AIsg9BOD7sH7kU9M1d95omQoQ=", + "dev": true + } + } + }, "cross-spawn": { "version": "5.1.0", "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-5.1.0.tgz", @@ -2842,6 +2864,12 @@ "integrity": "sha512-IItsdsea19BoLC7ELy13q1iJFNmd7ofZH5+X/pJr90/nRoPEX0DJo1dHDbgtYWOhJhcCgMDTOw84RZ72q6lB+Q==", "dev": true }, + "growl": { + "version": "1.10.5", + "resolved": "https://registry.npmjs.org/growl/-/growl-1.10.5.tgz", + "integrity": "sha512-qBr4OuELkhPenW6goKVXiv47US3clb3/IbuWF9KNKEijAy9oeHxU9IgzjvJhHkUzhaj7rOUD7+YGWqUjLp5oSA==", + "dev": true + }, "growly": { "version": "1.3.0", "resolved": "https://registry.npmjs.org/growly/-/growly-1.3.0.tgz", @@ -4443,6 +4471,12 @@ "invert-kv": "^1.0.0" } }, + "lcov-parse": { + "version": "0.0.10", + "resolved": "https://registry.npmjs.org/lcov-parse/-/lcov-parse-0.0.10.tgz", + "integrity": "sha1-GwuP+ayceIklBYK3C3ExXZ2m2aM=", + "dev": true + }, "left-pad": { "version": "1.3.0", "resolved": "https://registry.npmjs.org/left-pad/-/left-pad-1.3.0.tgz", @@ -4499,6 +4533,12 @@ "integrity": "sha1-7dFMgk4sycHgsKG0K7UhBRakJDg=", "dev": true }, + "log-driver": { + "version": "1.2.7", + "resolved": "https://registry.npmjs.org/log-driver/-/log-driver-1.2.7.tgz", + "integrity": "sha512-U7KCmLdqsGHBLeWqYlFA0V0Sl6P08EE1ZrmA9cxjUE0WVqT9qnyVDPz1kzpFEP0jdJuFnasWIfSd7fsaNXkpbg==", + "dev": true + }, "long": { "version": "3.2.0", "resolved": "https://registry.npmjs.org/long/-/long-3.2.0.tgz", diff --git a/package.json b/package.json index b86e530b..79abb726 100644 --- a/package.json +++ b/package.json @@ -12,9 +12,10 @@ "node": ">=6" }, "scripts": { - "lint": "node_modules/.bin/eslint *.js './src/**/*.js' './tests/**/*.spec.js' config/*.js './sandbox/**/*.js'", - "unit-test": "node_modules/.bin/jest", - "test": "npm run lint && npm run unit-test" + "lint": "eslint *.js './src/**/*.js' './tests/**/*.spec.js' config/*.js './sandbox/**/*.js'", + "unit-test": "jest", + "test": "npm run lint && npm run unit-test", + "coveralls": "npm run unit-test && cat ./coverage/lcov.info | coveralls" }, "husky": { "hooks": { @@ -43,6 +44,7 @@ "uuid": "^3.3.2" }, "devDependencies": { + "coveralls": "^3.0.6", "eslint": "^4.19.1", "eslint-config-airbnb-base": "^12.1.0", "eslint-plugin-import": "^2.18.2", From 7319a9c04f0a090fbdd2e7ccf4e21679c46a6931 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Thu, 10 Oct 2019 15:34:07 +0100 Subject: [PATCH 28/47] SDK-1239: Add test coverage for AML check response errors --- tests/aml_service/index.spec.js | 40 +++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/tests/aml_service/index.spec.js b/tests/aml_service/index.spec.js index c2845d9a..3f4d670b 100644 --- a/tests/aml_service/index.spec.js +++ b/tests/aml_service/index.spec.js @@ -37,6 +37,20 @@ describe('amlService', () => { expect(amlResult.isOnFraudList).toBe(false); expect(amlResult.isOnWatchList).toBe(false); + const expectedData = { + on_pep_list: true, + on_fraud_list: false, + on_watch_list: false, + }; + + const data = amlResult.getData(); + + expect(data.on_pep_list).toBe(expectedData.on_pep_list); + expect(data.on_fraud_list).toBe(expectedData.on_fraud_list); + expect(data.on_watch_list).toBe(expectedData.on_watch_list); + + expect(amlResult.toString()).toStrictEqual(JSON.stringify(expectedData)); + done(); }) .catch(done); @@ -64,5 +78,31 @@ describe('amlService', () => { .catch(done); }); }); + + describe('with an invalid JSON response', () => { + beforeEach((done) => { + nock(`${config.yoti.connectApi}`) + .post(new RegExp('^/api/v1/aml-check?'), amlPayload.getPayloadJSON()) + .reply(200, ''); + + done(); + }); + + it('should return response data error', (done) => { + amlService.performAmlCheck(amlProfile, privateKeyFile, 'stub-app-id') + .catch((err) => { + expect(err.message).toBe('Result Data should be an object'); + done(); + }) + .catch(done); + }); + }); + + describe('with an empty profile', () => { + it('should return PAYLOAD_VALIDATION error', () => { + expect(() => amlService.performAmlCheck('', privateKeyFile, 'stub-app-id')) + .toThrow(new Error('Error - AmlProfile should be an object of Type/AmlProfile')); + }); + }); }); }); From 3d56ed1aa4740263353b1d06bd305a301a8803b6 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Thu, 10 Oct 2019 16:23:13 +0100 Subject: [PATCH 29/47] SDK-1239: Fix country code validation --- src/aml_type/aml.address.js | 9 +++-- src/yoti_common/validation.js | 12 ++++++ tests/aml_service/aml.address.spec.js | 54 +++++++++++++++++++++++++++ 3 files changed, 71 insertions(+), 4 deletions(-) create mode 100644 tests/aml_service/aml.address.spec.js diff --git a/src/aml_type/aml.address.js b/src/aml_type/aml.address.js index 16804095..9aaae23a 100644 --- a/src/aml_type/aml.address.js +++ b/src/aml_type/aml.address.js @@ -1,6 +1,7 @@ 'use strict'; const constants = require('../yoti_common/constants'); +const Validation = require('../yoti_common/validation'); module.exports.AmlAddress = class AmlAddress { constructor(countryCode, postcode) { @@ -14,7 +15,7 @@ module.exports.AmlAddress = class AmlAddress { * @param countryCode */ setCountryCode(countryCode) { - this.validateCountryCode(); + Validation.notNullOrEmpty(countryCode, 'countryCode'); this.countryCode = countryCode; } @@ -52,11 +53,11 @@ module.exports.AmlAddress = class AmlAddress { /** * @param countryCode + * + * @deprecated 3.0.0 - replaced by Validation.notNullOrEmpty() */ validateCountryCode() { - if (this.countryCode === '') { - throw new Error('CountryCode cannot be empty'); - } + Validation.notNullOrEmpty(this.countryCode, 'countryCode'); } /** diff --git a/src/yoti_common/validation.js b/src/yoti_common/validation.js index 0874d27f..5f6a5010 100644 --- a/src/yoti_common/validation.js +++ b/src/yoti_common/validation.js @@ -199,4 +199,16 @@ module.exports = class Validation { this.notLessThan(value, minLimit, name); this.notGreaterThan(value, maxLimit, name); } + + /** + * @param {*} value + * @param {string} name + * + * @throws {TypeError} + */ + static notNullOrEmpty(value, name) { + if (value === undefined || value == null || value.length <= 0) { + throw TypeError(`${name} cannot be null or empty`); + } + } }; diff --git a/tests/aml_service/aml.address.spec.js b/tests/aml_service/aml.address.spec.js new file mode 100644 index 00000000..c09a90ae --- /dev/null +++ b/tests/aml_service/aml.address.spec.js @@ -0,0 +1,54 @@ +const { AmlAddress } = require('../../'); + +const SOME_COUNTRY_CODE = 'GBR'; +const SOME_POSTCODE = 'BN2 1TW'; +const SOME_AML_ADDRESS = new AmlAddress(SOME_COUNTRY_CODE, SOME_POSTCODE); +const SOME_DATA = { + post_code: SOME_POSTCODE, + country: SOME_COUNTRY_CODE, +}; + +describe('AmlAddress', () => { + describe('#getCountryCode()', () => { + it(`should return ${SOME_COUNTRY_CODE}`, () => { + expect(SOME_AML_ADDRESS.getCountryCode()).toBe(SOME_COUNTRY_CODE); + }); + }); + + describe('#getPostcode()', () => { + it(`should return ${SOME_POSTCODE}`, () => { + expect(SOME_AML_ADDRESS.getPostcode()).toBe(SOME_POSTCODE); + }); + }); + + describe('#getData()', () => { + it('should return object', () => { + expect(SOME_AML_ADDRESS.getData()).toStrictEqual(SOME_DATA); + }); + }); + + describe('#toString()', () => { + it('should return JSON string', () => { + expect(SOME_AML_ADDRESS.toString()).toStrictEqual(JSON.stringify(SOME_DATA)); + }); + }); + + describe('#setCountryCode()', () => { + it('should throw error when empty country code is provided', () => { + [null, '', undefined].forEach((emptyCountryCode) => { + expect(() => SOME_AML_ADDRESS.setCountryCode(emptyCountryCode)) + .toThrow(new Error('countryCode cannot be null or empty')); + }); + }); + }); + + describe('#validateCountryCode()', () => { + it('should throw error when empty country code is provided', () => { + [null, '', undefined].forEach((emptyCountryCode) => { + SOME_AML_ADDRESS.countryCode = emptyCountryCode; + expect(() => SOME_AML_ADDRESS.validateCountryCode()) + .toThrow(new Error('countryCode cannot be null or empty')); + }); + }); + }); +}); From 994476c42227cc4592a572004d37b20f66a9093f Mon Sep 17 00:00:00 2001 From: David Grayston Date: Thu, 10 Oct 2019 16:59:44 +0100 Subject: [PATCH 30/47] SDK-1239: Add AmlProfile test coverage --- src/aml_type/aml.address.js | 2 +- tests/aml_service/aml.profile.spec.js | 56 +++++++++++++++++++++++++++ 2 files changed, 57 insertions(+), 1 deletion(-) create mode 100644 tests/aml_service/aml.profile.spec.js diff --git a/src/aml_type/aml.address.js b/src/aml_type/aml.address.js index 9aaae23a..a0b4e33e 100644 --- a/src/aml_type/aml.address.js +++ b/src/aml_type/aml.address.js @@ -54,7 +54,7 @@ module.exports.AmlAddress = class AmlAddress { /** * @param countryCode * - * @deprecated 3.0.0 - replaced by Validation.notNullOrEmpty() + * @deprecated Replaced by Validation.notNullOrEmpty() */ validateCountryCode() { Validation.notNullOrEmpty(this.countryCode, 'countryCode'); diff --git a/tests/aml_service/aml.profile.spec.js b/tests/aml_service/aml.profile.spec.js new file mode 100644 index 00000000..94a0a6c7 --- /dev/null +++ b/tests/aml_service/aml.profile.spec.js @@ -0,0 +1,56 @@ +const { AmlAddress, AmlProfile } = require('../..'); + +const SOME_COUNTRY_CODE = 'GBR'; +const SOME_POSTCODE = 'BN2 1TW'; +const SOME_AML_ADDRESS = new AmlAddress(SOME_COUNTRY_CODE, SOME_POSTCODE); +const SOME_GIVEN_NAMES = 'some given names'; +const SOME_FAMILY_NAME = 'some family name'; +const SOME_SSN = '1234'; + +const SOME_AML_PROFILE = new AmlProfile( + SOME_GIVEN_NAMES, + SOME_FAMILY_NAME, + SOME_AML_ADDRESS, + SOME_SSN +); + +const SOME_DATA = { + given_names: SOME_GIVEN_NAMES, + family_name: SOME_FAMILY_NAME, + ssn: SOME_SSN, + address: SOME_AML_ADDRESS.getData(), +}; + +describe('AmlProfile', () => { + describe('#getGivenNames()', () => { + it('should return given names', () => { + expect(SOME_AML_PROFILE.getGivenNames()).toBe(SOME_GIVEN_NAMES); + }); + }); + describe('#getFamilyName()', () => { + it('should return family name', () => { + expect(SOME_AML_PROFILE.getFamilyName()).toBe(SOME_FAMILY_NAME); + }); + }); + describe('#getSsn()', () => { + it('should return SSN', () => { + expect(SOME_AML_PROFILE.getSsn()).toBe(SOME_SSN); + }); + }); + describe('#getAmlAddress()', () => { + it('should return address', () => { + expect(SOME_AML_PROFILE.getAmlAddress()).toStrictEqual(SOME_AML_ADDRESS); + }); + }); + describe('#validateAmlAddress()', () => { + it('should throw error for empty address', () => { + expect(() => SOME_AML_PROFILE.setAmlAddress('')) + .toThrow(new Error('AmlAddress should be an object of Type/AmlAddress')); + }); + }); + describe('#toString()', () => { + it('should return AML profile data as JSON string', () => { + expect(SOME_AML_PROFILE.toString()).toBe(JSON.stringify(SOME_DATA)); + }); + }); +}); From b53d53ebe237f7d77873a0956748756f2640bdbf Mon Sep 17 00:00:00 2001 From: David Grayston Date: Mon, 14 Oct 2019 10:30:53 +0100 Subject: [PATCH 31/47] SDK-1239: Move tests into correct directory --- tests/aml_service/index.spec.js | 2 +- tests/{aml_service => aml_type}/aml.address.spec.js | 0 tests/{aml_service => aml_type}/aml.profile.spec.js | 0 3 files changed, 1 insertion(+), 1 deletion(-) rename tests/{aml_service => aml_type}/aml.address.spec.js (100%) rename tests/{aml_service => aml_type}/aml.profile.spec.js (100%) diff --git a/tests/aml_service/index.spec.js b/tests/aml_service/index.spec.js index 3f4d670b..2f29fdd3 100644 --- a/tests/aml_service/index.spec.js +++ b/tests/aml_service/index.spec.js @@ -99,7 +99,7 @@ describe('amlService', () => { }); describe('with an empty profile', () => { - it('should return PAYLOAD_VALIDATION error', () => { + it('should throw validation error', () => { expect(() => amlService.performAmlCheck('', privateKeyFile, 'stub-app-id')) .toThrow(new Error('Error - AmlProfile should be an object of Type/AmlProfile')); }); diff --git a/tests/aml_service/aml.address.spec.js b/tests/aml_type/aml.address.spec.js similarity index 100% rename from tests/aml_service/aml.address.spec.js rename to tests/aml_type/aml.address.spec.js diff --git a/tests/aml_service/aml.profile.spec.js b/tests/aml_type/aml.profile.spec.js similarity index 100% rename from tests/aml_service/aml.profile.spec.js rename to tests/aml_type/aml.profile.spec.js From 9f07899dfb66bb2b0df365ce3093815cf496ec15 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Tue, 5 Nov 2019 15:44:43 +0000 Subject: [PATCH 32/47] SDK-1270: Add derivation to payload only when specified --- package-lock.json | 26 +++++------ package.json | 2 +- .../policy/wanted.attribute.js | 11 +++-- .../dynamic.scenario.builder.spec.js | 2 - .../policy/dynamic.policy.builder.spec.js | 44 +++++++++---------- .../policy/wanted.attribute.builder.spec.js | 16 +++++-- 6 files changed, 56 insertions(+), 45 deletions(-) diff --git a/package-lock.json b/package-lock.json index 0b86d979..9e7d6efd 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1228,9 +1228,9 @@ } }, "commander": { - "version": "2.20.0", - "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.0.tgz", - "integrity": "sha512-7j2y+40w61zy6YC2iRNpUe/NwhNyoXrYpHMrSunaMG64nRnaf96zO/KMQR4OyN/UnE5KLyEBnKHd4aG3rskjpQ==", + "version": "2.20.3", + "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz", + "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==", "dev": true, "optional": true }, @@ -1320,9 +1320,9 @@ } }, "coveralls": { - "version": "3.0.6", - "resolved": "https://registry.npmjs.org/coveralls/-/coveralls-3.0.6.tgz", - "integrity": "sha512-Pgh4v3gCI4T/9VijVrm8Ym5v0OgjvGLKj3zTUwkvsCiwqae/p6VLzpsFNjQS2i6ewV7ef+DjFJ5TSKxYt/mCrA==", + "version": "3.0.7", + "resolved": "https://registry.npmjs.org/coveralls/-/coveralls-3.0.7.tgz", + "integrity": "sha512-mUuH2MFOYB2oBaA4D4Ykqi9LaEYpMMlsiOMJOrv358yAjP6enPIk55fod2fNJ8AvwoYXStWQls37rA+s5e7boA==", "dev": true, "requires": { "growl": "~> 1.10.0", @@ -2877,9 +2877,9 @@ "dev": true }, "handlebars": { - "version": "4.3.1", - "resolved": "https://registry.npmjs.org/handlebars/-/handlebars-4.3.1.tgz", - "integrity": "sha512-c0HoNHzDiHpBt4Kqe99N8tdLPKAnGCQ73gYMPWtAYM4PwGnf7xl8PBUHJqh9ijlzt2uQKaSRxbXRt+rZ7M2/kA==", + "version": "4.5.1", + "resolved": "https://registry.npmjs.org/handlebars/-/handlebars-4.5.1.tgz", + "integrity": "sha512-C29UoFzHe9yM61lOsIlCE5/mQVGrnIOrOq7maQl76L7tYPCgC1og0Ajt6uWnX4ZTxBPnjw+CUvawphwCfJgUnA==", "dev": true, "requires": { "neo-async": "^2.6.0", @@ -6435,13 +6435,13 @@ "dev": true }, "uglify-js": { - "version": "3.6.0", - "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.6.0.tgz", - "integrity": "sha512-W+jrUHJr3DXKhrsS7NUVxn3zqMOFn0hL/Ei6v0anCIMoKC93TjcflTagwIHLW7SfMFfiQuktQyFVCFHGUE0+yg==", + "version": "3.6.7", + "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.6.7.tgz", + "integrity": "sha512-4sXQDzmdnoXiO+xvmTzQsfIiwrjUCSA95rSP4SEd8tDb51W2TiDOlL76Hl+Kw0Ie42PSItCW8/t6pBNCF2R48A==", "dev": true, "optional": true, "requires": { - "commander": "~2.20.0", + "commander": "~2.20.3", "source-map": "~0.6.1" } }, diff --git a/package.json b/package.json index 45224b06..2c7f5b17 100644 --- a/package.json +++ b/package.json @@ -44,7 +44,7 @@ "uuid": "^3.3.2" }, "devDependencies": { - "coveralls": "^3.0.6", + "coveralls": "^3.0.7", "eslint": "^4.19.1", "eslint-config-airbnb-base": "^12.1.0", "eslint-plugin-import": "^2.18.2", diff --git a/src/dynamic_sharing_service/policy/wanted.attribute.js b/src/dynamic_sharing_service/policy/wanted.attribute.js index a0b86a0a..a3c02ea1 100644 --- a/src/dynamic_sharing_service/policy/wanted.attribute.js +++ b/src/dynamic_sharing_service/policy/wanted.attribute.js @@ -15,11 +15,13 @@ module.exports = class WantedAttribute { * @param {boolean} acceptSelfAsserted * @param {Constraints} constraints */ - constructor(name, derivation = '', acceptSelfAsserted = null, constraints = null) { + constructor(name, derivation = null, acceptSelfAsserted = null, constraints = null) { Validation.isString(name, 'name'); this.name = name; - Validation.isString(derivation, 'derivation'); + if (derivation !== null) { + Validation.isString(derivation, 'derivation'); + } this.derivation = derivation; if (acceptSelfAsserted !== null) { @@ -80,10 +82,13 @@ module.exports = class WantedAttribute { toJSON() { const json = { name: this.getName(), - derivation: this.getDerivation(), optional: false, }; + if (this.getDerivation() !== null) { + json.derivation = this.getDerivation(); + } + if (this.getConstraints() instanceof Constraints) { json.constraints = this.getConstraints(); } diff --git a/tests/dynamic_sharing_service/dynamic.scenario.builder.spec.js b/tests/dynamic_sharing_service/dynamic.scenario.builder.spec.js index bd9eaa32..8e32a459 100644 --- a/tests/dynamic_sharing_service/dynamic.scenario.builder.spec.js +++ b/tests/dynamic_sharing_service/dynamic.scenario.builder.spec.js @@ -41,12 +41,10 @@ describe('DynamicScenarioBuilder', () => { wanted: [ { name: 'full_name', - derivation: '', optional: false, }, { name: 'given_names', - derivation: '', optional: false, }, ], diff --git a/tests/dynamic_sharing_service/policy/dynamic.policy.builder.spec.js b/tests/dynamic_sharing_service/policy/dynamic.policy.builder.spec.js index ff713d14..3cdd5c07 100644 --- a/tests/dynamic_sharing_service/policy/dynamic.policy.builder.spec.js +++ b/tests/dynamic_sharing_service/policy/dynamic.policy.builder.spec.js @@ -64,19 +64,19 @@ describe('DynamicPolicyBuilder', () => { .build(); const expectedWantedAttributeData = [ - { name: 'family_name', derivation: '', optional: false }, - { name: 'given_names', derivation: '', optional: false }, - { name: 'full_name', derivation: '', optional: false }, - { name: 'date_of_birth', derivation: '', optional: false }, - { name: 'gender', derivation: '', optional: false }, - { name: 'postal_address', derivation: '', optional: false }, - { name: 'structured_postal_address', derivation: '', optional: false }, - { name: 'nationality', derivation: '', optional: false }, - { name: 'phone_number', derivation: '', optional: false }, - { name: 'selfie', derivation: '', optional: false }, - { name: 'email_address', derivation: '', optional: false }, - { name: 'document_details', derivation: '', optional: false }, - { name: 'document_images', derivation: '', optional: false }, + { name: 'family_name', optional: false }, + { name: 'given_names', optional: false }, + { name: 'full_name', optional: false }, + { name: 'date_of_birth', optional: false }, + { name: 'gender', optional: false }, + { name: 'postal_address', optional: false }, + { name: 'structured_postal_address', optional: false }, + { name: 'nationality', optional: false }, + { name: 'phone_number', optional: false }, + { name: 'selfie', optional: false }, + { name: 'email_address', optional: false }, + { name: 'document_details', optional: false }, + { name: 'document_images', optional: false }, ]; expectDynamicPolicyAttributes(dynamicPolicy, expectedWantedAttributeData); @@ -96,8 +96,8 @@ describe('DynamicPolicyBuilder', () => { .build(); const expectedWantedAttributeData = [ - { name: 'family_name', derivation: '', optional: false }, - { name: 'given_names', derivation: '', optional: false }, + { name: 'family_name', optional: false }, + { name: 'given_names', optional: false }, ]; expectDynamicPolicyAttributes(dynamicPolicy, expectedWantedAttributeData); @@ -126,8 +126,8 @@ describe('DynamicPolicyBuilder', () => { const expectedWantedAttributeData = [ - { name: 'family_name', derivation: '', optional: false }, - { name: 'given_names', derivation: '', optional: false }, + { name: 'family_name', optional: false }, + { name: 'given_names', optional: false }, ]; expectDynamicPolicyAttributes(dynamicPolicy, expectedWantedAttributeData); @@ -155,10 +155,10 @@ describe('DynamicPolicyBuilder', () => { .build(); const expectedWantedAttributeData = [ - { name: 'date_of_birth', derivation: '', optional: false }, - { name: 'date_of_birth', derivation: 'age_over:18', optional: false }, - { name: 'date_of_birth', derivation: 'age_under:30', optional: false }, - { name: 'date_of_birth', derivation: 'age_under:40', optional: false }, + { name: 'date_of_birth', optional: false }, + { name: 'date_of_birth', optional: false, derivation: 'age_over:18' }, + { name: 'date_of_birth', optional: false, derivation: 'age_under:30' }, + { name: 'date_of_birth', optional: false, derivation: 'age_under:40' }, ]; expectDynamicPolicyAttributes(dynamicPolicy, expectedWantedAttributeData); @@ -194,7 +194,7 @@ describe('DynamicPolicyBuilder', () => { .build(); const expectedWantedAttributeData = [ - { name: 'date_of_birth', derivation: 'age_under:30', optional: false }, + { name: 'date_of_birth', optional: false, derivation: 'age_under:30' }, ]; expectDynamicPolicyAttributes(dynamicPolicy, expectedWantedAttributeData); diff --git a/tests/dynamic_sharing_service/policy/wanted.attribute.builder.spec.js b/tests/dynamic_sharing_service/policy/wanted.attribute.builder.spec.js index 5e9d9db3..c7992689 100644 --- a/tests/dynamic_sharing_service/policy/wanted.attribute.builder.spec.js +++ b/tests/dynamic_sharing_service/policy/wanted.attribute.builder.spec.js @@ -13,8 +13,8 @@ describe('WantedAttributeBuilder', () => { const expectedJson = JSON.stringify({ name: TEST_NAME, - derivation: TEST_DERIVATION, optional: false, + derivation: TEST_DERIVATION, }); expect(wantedAttribute).toBeInstanceOf(WantedAttribute); @@ -36,7 +36,6 @@ describe('WantedAttributeBuilder', () => { const expectedJson = JSON.stringify({ name: TEST_NAME, - derivation: '', optional: false, accept_self_asserted: true, }); @@ -55,7 +54,6 @@ describe('WantedAttributeBuilder', () => { const expectedJson = JSON.stringify({ name: TEST_NAME, - derivation: '', optional: false, accept_self_asserted: false, }); @@ -64,6 +62,17 @@ describe('WantedAttributeBuilder', () => { expect(JSON.stringify(wantedAttribute)).toBe(expectedJson); }); + it('should throw error when provided derivation is not a string', () => { + [false, [], 0, 1, {}].forEach((nonStringValue) => { + expect(() => { + new WantedAttributeBuilder() + .withName(TEST_NAME) + .withDerivation(nonStringValue) + .build(); + }).toThrow(new TypeError('derivation must be a string')); + }); + }); + it('should build a wanted attribute with constraints', () => { const sourceConstraint = new SourceConstraintBuilder() .withPassport() @@ -80,7 +89,6 @@ describe('WantedAttributeBuilder', () => { const expectedJson = JSON.stringify({ name: TEST_NAME, - derivation: '', optional: false, constraints: [ { From 9f82f4e4348e8823ac7af68399bd1830734ff1a3 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Mon, 18 Nov 2019 10:25:46 +0000 Subject: [PATCH 33/47] Update packages: handlebars, uglify-js --- package-lock.json | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/package-lock.json b/package-lock.json index 9e7d6efd..b20f03e5 100644 --- a/package-lock.json +++ b/package-lock.json @@ -2877,9 +2877,9 @@ "dev": true }, "handlebars": { - "version": "4.5.1", - "resolved": "https://registry.npmjs.org/handlebars/-/handlebars-4.5.1.tgz", - "integrity": "sha512-C29UoFzHe9yM61lOsIlCE5/mQVGrnIOrOq7maQl76L7tYPCgC1og0Ajt6uWnX4ZTxBPnjw+CUvawphwCfJgUnA==", + "version": "4.5.3", + "resolved": "https://registry.npmjs.org/handlebars/-/handlebars-4.5.3.tgz", + "integrity": "sha512-3yPecJoJHK/4c6aZhSvxOyG4vJKDshV36VHp0iVCDVh7o9w2vwi3NSnL2MMPj3YdduqaBcu7cGbggJQM0br9xA==", "dev": true, "requires": { "neo-async": "^2.6.0", @@ -6435,9 +6435,9 @@ "dev": true }, "uglify-js": { - "version": "3.6.7", - "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.6.7.tgz", - "integrity": "sha512-4sXQDzmdnoXiO+xvmTzQsfIiwrjUCSA95rSP4SEd8tDb51W2TiDOlL76Hl+Kw0Ie42PSItCW8/t6pBNCF2R48A==", + "version": "3.6.9", + "resolved": "https://registry.npmjs.org/uglify-js/-/uglify-js-3.6.9.tgz", + "integrity": "sha512-pcnnhaoG6RtrvHJ1dFncAe8Od6Nuy30oaJ82ts6//sGSXOP5UjBMEthiProjXmMNHOfd93sqlkztifFMcb+4yw==", "dev": true, "optional": true, "requires": { From 27f8112014329658485da206d819026ce83721df Mon Sep 17 00:00:00 2001 From: David Grayston Date: Thu, 21 Nov 2019 17:01:07 +0000 Subject: [PATCH 34/47] SDK-1279: Prevent empty wanted attribute name --- .../policy/wanted.attribute.js | 1 + .../policy/wanted.attribute.builder.spec.js | 18 ++++++++++++++++++ 2 files changed, 19 insertions(+) diff --git a/src/dynamic_sharing_service/policy/wanted.attribute.js b/src/dynamic_sharing_service/policy/wanted.attribute.js index a3c02ea1..4e746825 100644 --- a/src/dynamic_sharing_service/policy/wanted.attribute.js +++ b/src/dynamic_sharing_service/policy/wanted.attribute.js @@ -17,6 +17,7 @@ module.exports = class WantedAttribute { */ constructor(name, derivation = null, acceptSelfAsserted = null, constraints = null) { Validation.isString(name, 'name'); + Validation.notNullOrEmpty(name, 'name'); this.name = name; if (derivation !== null) { diff --git a/tests/dynamic_sharing_service/policy/wanted.attribute.builder.spec.js b/tests/dynamic_sharing_service/policy/wanted.attribute.builder.spec.js index c7992689..0c26b4b6 100644 --- a/tests/dynamic_sharing_service/policy/wanted.attribute.builder.spec.js +++ b/tests/dynamic_sharing_service/policy/wanted.attribute.builder.spec.js @@ -23,6 +23,24 @@ describe('WantedAttributeBuilder', () => { expect(wantedAttribute.getDerivation()).toBe(TEST_DERIVATION); }); + it('should throw error when name is an empty string', () => { + expect(() => { + new WantedAttributeBuilder() + .withName('') + .build(); + }).toThrow(new TypeError('name cannot be null or empty')); + }); + + it('should throw error when name is a non-string value', () => { + [null, []].forEach((nonStringValue) => { + expect(() => { + new WantedAttributeBuilder() + .withName(nonStringValue) + .build(); + }).toThrow(new TypeError('name must be a string')); + }); + }); + it('should build a wanted attribute with accept self asserted', () => { const wantedAttributeDefault = new WantedAttributeBuilder() .withName(TEST_NAME) From 21674b598ea36da227d7f50d832c463215a96b72 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Thu, 21 Nov 2019 16:16:56 +0000 Subject: [PATCH 35/47] SDK-1277: Add headers getter to response object --- src/request/request.handler.js | 3 ++- src/request/response.js | 11 ++++++++- tests/request/request.handler.spec.js | 35 +++++++++++++++++++++++++++ tests/request/response.spec.js | 21 +++++++++++++++- 4 files changed, 67 insertions(+), 3 deletions(-) diff --git a/src/request/request.handler.js b/src/request/request.handler.js index 6dd43b63..eabca329 100644 --- a/src/request/request.handler.js +++ b/src/request/request.handler.js @@ -44,7 +44,8 @@ module.exports.execute = (yotiRequest, buffer = false) => new Promise((resolve, parsedResponse, response.statusCode, receipt, - body + body, + response.headers )); }) .catch((err) => { diff --git a/src/request/response.js b/src/request/response.js index 027aedca..eec3f7a6 100644 --- a/src/request/response.js +++ b/src/request/response.js @@ -9,12 +9,14 @@ class YotiResponse { * @param {int} statusCode * @param {Object|null} receipt * @param {Buffer|string|null} body + * @param {Array|null} headers */ - constructor(parsedResponse, statusCode, receipt = null, body = null) { + constructor(parsedResponse, statusCode, receipt = null, body = null, headers = null) { this.parsedResponse = parsedResponse; this.statusCode = statusCode; this.receipt = receipt; this.body = body; + this.headers = headers; } /** @@ -44,6 +46,13 @@ class YotiResponse { getStatusCode() { return this.statusCode; } + + /** + * @returns {Object.} Response headers + */ + getHeaders() { + return this.headers; + } } module.exports = { diff --git a/tests/request/request.handler.spec.js b/tests/request/request.handler.spec.js index 176c6868..89a4f318 100644 --- a/tests/request/request.handler.spec.js +++ b/tests/request/request.handler.spec.js @@ -10,6 +10,7 @@ const SOME_ENDPOINT_REG_EXP = new RegExp(`^${SOME_ENDPOINT}`); const SOME_PEM_STRING = fs.readFileSync('./tests/sample-data/keys/node-sdk-test.pem', 'utf8'); const ALLOWED_METHODS = ['POST', 'PUT', 'PATCH', 'GET', 'DELETE']; const SOME_JSON_DATA = { some: 'json' }; +const SOME_HEADERS = { 'Some-Header': 'some value' }; const SOME_JSON_DATA_STRING = JSON.stringify(SOME_JSON_DATA); const SOME_JSON_RECEIPT_DATA = { receipt: 'some receipt' }; const SOME_JSON_RECEIPT_DATA_STRING = JSON.stringify(SOME_JSON_RECEIPT_DATA); @@ -121,6 +122,23 @@ describe('yotiRequest', () => { .catch(done); }); }); + describe('when headers are returned', () => { + beforeEach((done) => { + nock(SOME_BASE_URL) + .get(SOME_ENDPOINT_REG_EXP) + .reply(200, SOME_JSON_DATA_STRING, SOME_HEADERS); + done(); + }); + it('should return YotiResponse with headers', (done) => { + yotiRequestHandler + .execute(SOME_REQUEST, true) + .then((response) => { + expect(response).toHaveHeaders(SOME_HEADERS); + done(); + }) + .catch(done); + }); + }); [ 'application/octet-stream', 'application/pdf', @@ -174,3 +192,20 @@ describe('yotiRequest', () => { }); }); }); + +expect.extend({ + toHaveHeaders(response, expectedHeaders) { + Object.keys(expectedHeaders).forEach((header) => { + // Note: Response header names are lowercased by superagent. + const headerValue = response.getHeaders()[header.toLowerCase()]; + const expectedHeaderValue = expectedHeaders[header]; + + expect(headerValue).toBe(expectedHeaderValue); + }); + return { + message: () => + 'Response contains expected headers', + pass: true, + }; + }, +}); diff --git a/tests/request/response.spec.js b/tests/request/response.spec.js index f3aa18ce..522fa1fa 100644 --- a/tests/request/response.spec.js +++ b/tests/request/response.spec.js @@ -3,11 +3,16 @@ const { YotiResponse } = require('../../src/request/response'); const SOME_BODY = '{"some":"response"}'; const SOME_RECEIPT = { some: 'receipt' }; const SOME_PARSED_RESPONSE = JSON.parse(SOME_BODY); +const SOME_HEADERS = { + 'Some-Header': 'some value', + 'Some-Other-Header': 'some other value', +}; const SOME_RESPONSE = new YotiResponse( SOME_PARSED_RESPONSE, 200, SOME_RECEIPT, - SOME_BODY + SOME_BODY, + SOME_HEADERS ); describe('YotiResponse', () => { @@ -31,6 +36,11 @@ describe('YotiResponse', () => { expect(SOME_RESPONSE.getStatusCode()).toBe(200); }); }); + describe('#getHeaders', () => { + it('should return the response headers', () => { + expect(SOME_RESPONSE.getHeaders()).toEqual(SOME_HEADERS); + }); + }); describe('#constructor', () => { it('should not require receipt', () => { const SOME_RESPONSE_WITHOUT_RECEIPT = new YotiResponse( @@ -47,5 +57,14 @@ describe('YotiResponse', () => { ); expect(SOME_RESPONSE_WITHOUT_BODY.getBody()).toBeNull(); }); + it('should not require headers', () => { + const SOME_RESPONSE_WITHOUT_HEADERS = new YotiResponse( + SOME_PARSED_RESPONSE, + 200, + SOME_RECEIPT, + SOME_BODY + ); + expect(SOME_RESPONSE_WITHOUT_HEADERS.getHeaders()).toBeNull(); + }); }); }); From 502bd603719131062eaf1b0120b72069fcbaa1b3 Mon Sep 17 00:00:00 2001 From: Alex Burt Date: Wed, 16 Oct 2019 15:39:53 +0100 Subject: [PATCH 36/47] SDK-1231: Add new protobuf files for third party attributes and extra data --- .../sharepubapi_v1/DataEntry.proto | 25 +++++++++++++++++++ .../sharepubapi_v1/ExtraData.proto | 17 +++++++++++++ .../sharepubapi_v1/IssuingAttributes.proto | 20 +++++++++++++++ .../sharepubapi_v1/ThirdPartyAttribute.proto | 18 +++++++++++++ 4 files changed, 80 insertions(+) create mode 100644 src/protobuf/share-public-api/sharepubapi_v1/DataEntry.proto create mode 100644 src/protobuf/share-public-api/sharepubapi_v1/ExtraData.proto create mode 100644 src/protobuf/share-public-api/sharepubapi_v1/IssuingAttributes.proto create mode 100644 src/protobuf/share-public-api/sharepubapi_v1/ThirdPartyAttribute.proto diff --git a/src/protobuf/share-public-api/sharepubapi_v1/DataEntry.proto b/src/protobuf/share-public-api/sharepubapi_v1/DataEntry.proto new file mode 100644 index 00000000..5493514e --- /dev/null +++ b/src/protobuf/share-public-api/sharepubapi_v1/DataEntry.proto @@ -0,0 +1,25 @@ +syntax = "proto3"; + +package sharepubapi_v1; + +option java_package = "com.yoti.api.client.spi.remote.proto"; +option java_outer_classname = "DataEntryProto"; +option go_package = "yotiprotoshare"; +option php_namespace = "Yoti\\Sharepubapi"; +option php_metadata_namespace = "Yoti\\Sharepubapi\\GPBMetadata"; +option csharp_namespace = "Yoti.Auth.ProtoBuf.Share"; +option ruby_package = "Yoti.Protobuf.Sharepubapi"; + +message DataEntry { + enum Type { + UNDEFINED = 0; + INVOICE = 1; + PAYMENT_TRANSACTION = 2; + LOCATION = 3; + TRANSACTION = 4; + AGE_VERIFICATION_SECRET = 5; + THIRD_PARTY_ATTRIBUTE = 6; + } + Type type = 1; + bytes value = 2; +} diff --git a/src/protobuf/share-public-api/sharepubapi_v1/ExtraData.proto b/src/protobuf/share-public-api/sharepubapi_v1/ExtraData.proto new file mode 100644 index 00000000..c62a495e --- /dev/null +++ b/src/protobuf/share-public-api/sharepubapi_v1/ExtraData.proto @@ -0,0 +1,17 @@ +syntax = "proto3"; + +package sharepubapi_v1; + +import "DataEntry.proto"; + +option java_package = "com.yoti.api.client.spi.remote.proto"; +option java_outer_classname = "ExtraDataProto"; +option go_package = "yotiprotoshare"; +option php_namespace = "Yoti\\Sharepubapi"; +option php_metadata_namespace = "Yoti\\Sharepubapi\\GPBMetadata"; +option csharp_namespace = "Yoti.Auth.ProtoBuf.Share"; +option ruby_package = "Yoti.Protobuf.Sharepubapi"; + +message ExtraData { + repeated DataEntry list = 1; +} diff --git a/src/protobuf/share-public-api/sharepubapi_v1/IssuingAttributes.proto b/src/protobuf/share-public-api/sharepubapi_v1/IssuingAttributes.proto new file mode 100644 index 00000000..f173235f --- /dev/null +++ b/src/protobuf/share-public-api/sharepubapi_v1/IssuingAttributes.proto @@ -0,0 +1,20 @@ +syntax = "proto3"; + +package sharepubapi_v1; + +option java_package = "com.yoti.api.client.spi.remote.proto"; +option java_outer_classname = "IssuingAttributesProto"; +option go_package = "yotiprotoshare"; +option php_namespace = "Yoti\\Sharepubapi"; +option php_metadata_namespace = "Yoti\\Sharepubapi\\GPBMetadata"; +option csharp_namespace = "Yoti.Auth.ProtoBuf.Share"; +option ruby_package = "Yoti.Protobuf.Sharepubapi"; + +message IssuingAttributes { + string expiry_date = 1; + repeated Definition definitions = 2; + } + +message Definition { + string name = 1; +} diff --git a/src/protobuf/share-public-api/sharepubapi_v1/ThirdPartyAttribute.proto b/src/protobuf/share-public-api/sharepubapi_v1/ThirdPartyAttribute.proto new file mode 100644 index 00000000..af0f4bab --- /dev/null +++ b/src/protobuf/share-public-api/sharepubapi_v1/ThirdPartyAttribute.proto @@ -0,0 +1,18 @@ +syntax = "proto3"; + +package sharepubapi_v1; + +import "IssuingAttributes.proto"; + +option java_package = "com.yoti.api.client.spi.remote.proto"; +option java_outer_classname = "ThirdPartyAttributeProto"; +option go_package = "yotiprotoshare"; +option php_namespace = "Yoti\\Sharepubapi"; +option php_metadata_namespace = "Yoti\\Sharepubapi\\GPBMetadata"; +option csharp_namespace = "Yoti.Auth.ProtoBuf.Share"; +option ruby_package = "Yoti.Protobuf.Sharepubapi"; + +message ThirdPartyAttribute { + bytes issuance_token = 1; + IssuingAttributes issuing_attributes = 2; +} From 3997d703805a1f9dcc1acb65b3034197d809a240 Mon Sep 17 00:00:00 2001 From: Alex Burt Date: Wed, 16 Oct 2019 18:05:29 +0100 Subject: [PATCH 37/47] SDK-1231: Add support for credential issuance details --- config/protobuf.js | 11 ++ src/data_type/attribute.issuance.details.js | 33 ++++++ src/profile_service/activity.details.js | 12 ++- src/profile_service/extra.data.js | 28 +++++ src/profile_service/index.js | 4 +- src/proto-root/init.js | 18 +++- src/proto-root/proto.share.extra-data.js | 7 ++ .../proto.share.third-party-attribute.js | 8 ++ src/yoti_common/data.entry.converter.js | 26 +++++ src/yoti_common/extra.data.converter.js | 28 +++++ src/yoti_common/index.js | 13 +++ .../third.party.attribute.converter.js | 44 ++++++++ tests/client/index.spec.js | 4 + tests/profile_service/extra.data.spec.js | 28 +++++ .../fixtures/extra_data/valid_extra_data.txt | 1 + .../valid_third_party_attribute.txt | 1 + tests/sample-data/payloads/payload.json | 18 +++- .../yoti_common/data.entry.converter.spec.js | 27 +++++ .../yoti_common/extra.data.converter.spec.js | 40 +++++++ .../third.party.attribute.converter.spec.js | 102 ++++++++++++++++++ 20 files changed, 448 insertions(+), 5 deletions(-) create mode 100644 src/data_type/attribute.issuance.details.js create mode 100644 src/profile_service/extra.data.js create mode 100644 src/proto-root/proto.share.extra-data.js create mode 100644 src/proto-root/proto.share.third-party-attribute.js create mode 100644 src/yoti_common/data.entry.converter.js create mode 100644 src/yoti_common/extra.data.converter.js create mode 100644 src/yoti_common/third.party.attribute.converter.js create mode 100644 tests/profile_service/extra.data.spec.js create mode 100644 tests/sample-data/fixtures/extra_data/valid_extra_data.txt create mode 100644 tests/sample-data/fixtures/extra_data/valid_third_party_attribute.txt create mode 100644 tests/yoti_common/data.entry.converter.spec.js create mode 100644 tests/yoti_common/extra.data.converter.spec.js create mode 100644 tests/yoti_common/third.party.attribute.converter.spec.js diff --git a/config/protobuf.js b/config/protobuf.js index 26ae6019..d7c49d7e 100644 --- a/config/protobuf.js +++ b/config/protobuf.js @@ -13,6 +13,12 @@ const PROTO_BUFF_COMMON_API_PATH = path.resolve(`${PROTO_BUFF_PATH}/common-publi const CORE_ENCRYPTED_DATA_PROTO_BUFF_PATH = path.resolve(`${PROTO_BUFF_COMMON_API_PATH}/EncryptedData.proto`); const CORE_SIGNED_TIMESTAMP_PROTO__BUFF_PATH = path.resolve(`${PROTO_BUFF_COMMON_API_PATH}/SignedTimeStamp.proto`); +const PROTO_BUFF_SHARE_API_PATH = path.resolve(`${PROTO_BUFF_PATH}/share-public-api/sharepubapi_v1`); +const CORE_EXTRA_DATA_PROTO_BUFF_PATH = path.resolve(`${PROTO_BUFF_SHARE_API_PATH}/ExtraData.proto`); +const CORE_DATA_ENTRY_PROTO_BUFF_PATH = path.resolve(`${PROTO_BUFF_SHARE_API_PATH}/DataEntry.proto`); +const CORE_THIRD_PARTY_ATTRIBUTE_PROTO_BUFF_PATH = path.resolve(`${PROTO_BUFF_SHARE_API_PATH}/ThirdPartyAttribute.proto`); +const CORE_ISSUING_ATTRIBUTES_PROTO_BUFF_PATH = path.resolve(`${PROTO_BUFF_SHARE_API_PATH}/IssuingAttributes.proto`); + module.exports = { PROTO_BUFF_PATH, PROTO_BUFF_ATTRIBUTE_API_PATH, @@ -20,4 +26,9 @@ module.exports = { PROTO_BUFF_COMMON_API_PATH, CORE_ENCRYPTED_DATA_PROTO_BUFF_PATH, CORE_SIGNED_TIMESTAMP_PROTO__BUFF_PATH, + PROTO_BUFF_SHARE_API_PATH, + CORE_EXTRA_DATA_PROTO_BUFF_PATH, + CORE_DATA_ENTRY_PROTO_BUFF_PATH, + CORE_THIRD_PARTY_ATTRIBUTE_PROTO_BUFF_PATH, + CORE_ISSUING_ATTRIBUTES_PROTO_BUFF_PATH, }; diff --git a/src/data_type/attribute.issuance.details.js b/src/data_type/attribute.issuance.details.js new file mode 100644 index 00000000..86e23218 --- /dev/null +++ b/src/data_type/attribute.issuance.details.js @@ -0,0 +1,33 @@ +'use strict'; + +const Validation = require('../yoti_common/validation'); + +class AttributeIssuanceDetails { + constructor(token, expiryDate, issuingAttributes) { + Validation.isString(token, 'token'); + + this.token = token; + this.expiryDate = expiryDate; + + if (!issuingAttributes) { + this.issuingAttributes = []; + } else { + Validation.hasOnlyStringValues(issuingAttributes, 'issuingAttributes'); + this.issuingAttributes = issuingAttributes; + } + } + + getToken() { + return this.token; + } + + getExpiryDate() { + return this.expiryDate; + } + + getIssuingAttributes() { + return this.issuingAttributes; + } +} + +module.exports = AttributeIssuanceDetails; diff --git a/src/profile_service/activity.details.js b/src/profile_service/activity.details.js index 3d14b1a6..e320c8fc 100644 --- a/src/profile_service/activity.details.js +++ b/src/profile_service/activity.details.js @@ -35,11 +35,12 @@ class ActivityDetails { * @param {array} decryptedApplicationProfile * Decrypted application profile data. */ - constructor(parsedResponse, decryptedProfile, decryptedApplicationProfile) { + constructor(parsedResponse, decryptedProfile, decryptedApplicationProfile, extraData) { this.parsedResponse = parsedResponse; this.decryptedProfile = decryptedProfile; this.receipt = parsedResponse.receipt; this.profile = parseProfile(decryptedProfile); + this.extraData = extraData; // This is the new profile attribute this.extendedProfile = new Profile(this.profile.extendedProfile); @@ -154,6 +155,15 @@ class ActivityDetails { getTimestamp() { return new Date(this.receipt.timestamp); } + + /** + * Extra data associated with the receipt + * + * @returns {ExtraData} + */ + getExtraData() { + return this.extraData; + } } module.exports = { diff --git a/src/profile_service/extra.data.js b/src/profile_service/extra.data.js new file mode 100644 index 00000000..1a0af7e6 --- /dev/null +++ b/src/profile_service/extra.data.js @@ -0,0 +1,28 @@ +'use strict'; + +const AttributeIssuanceDetails = require('../data_type/attribute.issuance.details'); + +function getAttributeIssuanceDetails(parsedDataEntries) { + const filtered = parsedDataEntries.filter(i => i instanceof AttributeIssuanceDetails); + if (filtered.length > 0) { + return filtered[0]; + } + + return undefined; +} + +class ExtraData { + /** + * + * @param {Object} attributeIssuanceDetails + */ + constructor(dataEntries = []) { + this.attributeIssuanceDetails = getAttributeIssuanceDetails(dataEntries); + } + + getAttributeIssuanceDetails() { + return this.attributeIssuanceDetails; + } +} + +module.exports = ExtraData; diff --git a/src/profile_service/index.js b/src/profile_service/index.js index 7b2ade99..c0222bdf 100644 --- a/src/profile_service/index.js +++ b/src/profile_service/index.js @@ -22,10 +22,12 @@ module.exports.getReceipt = (token, pem, appId) => { const parsedResponse = response.getParsedResponse(); const decryptedProfile = yotiCommon.decryptCurrentUserReceipt(receipt, pem); const decryptedApplicationProfile = yotiCommon.decryptApplicationProfile(receipt, pem); + const extraData = yotiCommon.parseExtraData(receipt.extra_data_content); return resolve(new ActivityDetails( parsedResponse, decryptedProfile, - decryptedApplicationProfile + decryptedApplicationProfile, + extraData )); } catch (err) { console.log(`Error getting response data: ${err.message}`); diff --git a/src/proto-root/init.js b/src/proto-root/init.js index 518f251c..8354a1b1 100644 --- a/src/proto-root/init.js +++ b/src/proto-root/init.js @@ -5,6 +5,9 @@ const attributeList = require('./proto.attribute.list'); const commonEncryptedData = require('./proto.common.encrypted-data'); const signedTimeStamp = require('./proto.signed.timestamp'); +const extraData = require('./proto.share.extra-data'); +const thirdPartyAttribute = require('./proto.share.third-party-attribute'); + const ProtoBuf = require('protobufjs'); const serverConfig = require('../../config/protobuf'); @@ -16,10 +19,20 @@ function initProtoBufBuilder() { const encryptedData = serverConfig.CORE_ENCRYPTED_DATA_PROTO_BUFF_PATH; const signedTimeStampStructure = serverConfig.CORE_SIGNED_TIMESTAMP_PROTO__BUFF_PATH; + const extraDataStructure = serverConfig.CORE_EXTRA_DATA_PROTO_BUFF_PATH; + const dataEntryStructure = serverConfig.CORE_DATA_ENTRY_PROTO_BUFF_PATH; + const issuingAttributesStructure = serverConfig.CORE_ISSUING_ATTRIBUTES_PROTO_BUFF_PATH; + const thirdPartyAttributeStructure = serverConfig.CORE_THIRD_PARTY_ATTRIBUTE_PROTO_BUFF_PATH; + ProtoBuf.loadProtoFile(attributeListPath, builder); ProtoBuf.loadProtoFile(encryptedData, builder); ProtoBuf.loadProtoFile(signedTimeStampStructure, builder); + ProtoBuf.loadProtoFile(extraDataStructure, builder); + ProtoBuf.loadProtoFile(dataEntryStructure, builder); + ProtoBuf.loadProtoFile(thirdPartyAttributeStructure, builder); + ProtoBuf.loadProtoFile(issuingAttributesStructure, builder); + return { builder: builder.build(), }; @@ -32,8 +45,9 @@ function buildProtoBufObject() { utils, attributeList, commonEncryptedData, - signedTimeStamp - + signedTimeStamp, + extraData, + thirdPartyAttribute ); } diff --git a/src/proto-root/proto.share.extra-data.js b/src/proto-root/proto.share.extra-data.js new file mode 100644 index 00000000..11d911a7 --- /dev/null +++ b/src/proto-root/proto.share.extra-data.js @@ -0,0 +1,7 @@ +'use strict'; + +module.exports = { + decodeExtraData(binaryData) { + return this.builder.sharepubapi_v1.ExtraData.decode(binaryData); + }, +}; diff --git a/src/proto-root/proto.share.third-party-attribute.js b/src/proto-root/proto.share.third-party-attribute.js new file mode 100644 index 00000000..edb32e3a --- /dev/null +++ b/src/proto-root/proto.share.third-party-attribute.js @@ -0,0 +1,8 @@ +'use strict'; + +module.exports = { + decodeThirdPartyAttribute(binaryData) { + return this.builder.sharepubapi_v1.ThirdPartyAttribute.decode(binaryData); + }, +}; + diff --git a/src/yoti_common/data.entry.converter.js b/src/yoti_common/data.entry.converter.js new file mode 100644 index 00000000..0cdd02a1 --- /dev/null +++ b/src/yoti_common/data.entry.converter.js @@ -0,0 +1,26 @@ +'use strict'; + +const ThirdPartyAttributeConverter = require('./third.party.attribute.converter'); + +const DATA_ENTRY_THIRD_PARTY_ATTRIBUTE = 6; + +class DataEntryConverter { + static convertValue(type, value) { + if (!value) { + console.log('No value supplied by data entry, skipping'); + return undefined; + } + + switch (type) { + case DATA_ENTRY_THIRD_PARTY_ATTRIBUTE: + return ThirdPartyAttributeConverter + .convertThirdPartyAttribute(value); + default: + console.log("Skipping data entry, as it's currently unsupported by the SDK"); + return undefined; + } + } +} + +module.exports = DataEntryConverter; + diff --git a/src/yoti_common/extra.data.converter.js b/src/yoti_common/extra.data.converter.js new file mode 100644 index 00000000..3639fb4e --- /dev/null +++ b/src/yoti_common/extra.data.converter.js @@ -0,0 +1,28 @@ +'use strict'; + +const protoRoot = require('../proto-root'); +const DataEntryConverter = require('./data.entry.converter'); +const ExtraData = require('../profile_service/extra.data'); + +const protoInst = protoRoot.initializeProtoBufObjects(); + +class ExtraDataConverter { + static convertExtraData(extraDataBytes) { + let extraDataProto; + try { + extraDataProto = protoInst.decodeExtraData(extraDataBytes); + } catch (err) { + console.log(`Failed to parse extra data: ${err}`); + return new ExtraData(); + } + + const dataEntries = extraDataProto.list; + const parsed = dataEntries.map(entry => DataEntryConverter + .convertValue(entry.type, entry.value)) + .filter(i => i !== undefined); + + return new ExtraData(parsed); + } +} + +module.exports = ExtraDataConverter; diff --git a/src/yoti_common/index.js b/src/yoti_common/index.js index 395ce740..b390d8a1 100644 --- a/src/yoti_common/index.js +++ b/src/yoti_common/index.js @@ -6,6 +6,9 @@ const forge = require('node-forge'); const protoRoot = require('../proto-root').initializeProtoBufObjects(); const Buffer = require('safe-buffer').Buffer; +const ExtraData = require('../profile_service/extra.data'); +const ExtraDataConverter = require('./extra.data.converter'); + // Request methods that can include payload data. const methodsThatIncludePayload = ['POST', 'PUT', 'PATCH']; @@ -83,3 +86,13 @@ module.exports.decryptApplicationProfile = (receipt, pem) => this.decryptProfile receipt.wrapped_receipt_key, pem ); + +module.exports.parseExtraData = (extraDataContent) => { + const extraDataNotEmpty = extraDataContent && Object.keys(extraDataContent).length > 0; + + if (extraDataNotEmpty) { + return ExtraDataConverter.convertExtraData(extraDataContent); + } + + return new ExtraData(undefined); +}; diff --git a/src/yoti_common/third.party.attribute.converter.js b/src/yoti_common/third.party.attribute.converter.js new file mode 100644 index 00000000..158190d7 --- /dev/null +++ b/src/yoti_common/third.party.attribute.converter.js @@ -0,0 +1,44 @@ +'use strict'; + +const protoRoot = require('../proto-root'); + +const protoInst = protoRoot.initializeProtoBufObjects(); + +const { YotiDate } = require('../data_type/date'); +const AttributeIssuanceDetails = require('../data_type/attribute.issuance.details'); + +class ThirdPartyAttributeConverter { + static convertThirdPartyAttribute(protoBytes) { + let thirdPartyProto; + try { + thirdPartyProto = protoInst.decodeThirdPartyAttribute(protoBytes); + } catch (err) { + console.log(`Failed to load ThirdPartyAttribute: ${err}`); + return undefined; + } + + const token = thirdPartyProto.issuanceToken.toString('utf8'); + if (!token || token === '') { + console.log('Failed to retrieve token from ThirdPartyAttribute'); + return undefined; + } + + const issuingAttributes = thirdPartyProto.issuingAttributes; + let expiryDate; + let attributes; + + if (issuingAttributes) { + try { + const tmpExpiryDate = issuingAttributes.expiryDate; + expiryDate = YotiDate.fromDateString(tmpExpiryDate); + } catch (err) { + console.log(`Failed to retrieve/parse expiryDate from ThirdPartyAttribute: ${err}`); + } + attributes = issuingAttributes.definitions.map(a => a.name); + } + + return new AttributeIssuanceDetails(token, expiryDate, attributes); + } +} + +module.exports = ThirdPartyAttributeConverter; diff --git a/tests/client/index.spec.js b/tests/client/index.spec.js index a6d2054c..27d7912f 100644 --- a/tests/client/index.spec.js +++ b/tests/client/index.spec.js @@ -51,6 +51,7 @@ describe('yotiClient', () => { const profile = activityDetails.getUserProfile(); const extendedProfile = activityDetails.getProfile(); const applicationProfile = activityDetails.getApplicationProfile(); + const extraData = activityDetails.getExtraData(); const outcome = activityDetails.getOutcome(); expect(activityDetails.getUserId()).toBe(rememberMeId); @@ -76,6 +77,9 @@ describe('yotiClient', () => { expect(applicationProfile.getLogo().getValue().getBase64Content()).toBe('data:image/jpeg;base64,'); expect(applicationProfile.getReceiptBgColor().getValue()).toBe('#ffffff'); + expect(extraData).not.toBe(undefined); + expect(extraData.getAttributeIssuanceDetails()).not.toBe(undefined); + done(); }) .catch(done); diff --git a/tests/profile_service/extra.data.spec.js b/tests/profile_service/extra.data.spec.js new file mode 100644 index 00000000..a8a567bc --- /dev/null +++ b/tests/profile_service/extra.data.spec.js @@ -0,0 +1,28 @@ +'use strict'; + +const AttributeIssuanceDetails = require('../../src/data_type/attribute.issuance.details'); +const ExtraData = require('../../src/profile_service/extra.data'); + +describe('ExtraData', () => { + describe('#getAttributeIssuanceDetails', () => { + it('should return the first attribute issuance details', () => { + const dataEntries = [ + new AttributeIssuanceDetails('someFirstToken'), + new AttributeIssuanceDetails('someSecondToken'), + ]; + + const extraData = new ExtraData(dataEntries); + + const attributeIssuanceDetails = extraData.getAttributeIssuanceDetails(); + expect(attributeIssuanceDetails.getToken()).toEqual('someFirstToken'); + }); + + it('should return undefined when there are no ThirdPartyAttributes', () => { + const extraData = new ExtraData([]); + + const attributeIssuanceDetails = extraData.getAttributeIssuanceDetails(); + expect(attributeIssuanceDetails).toBe(undefined); + }); + }); +}); + diff --git a/tests/sample-data/fixtures/extra_data/valid_extra_data.txt b/tests/sample-data/fixtures/extra_data/valid_extra_data.txt new file mode 100644 index 00000000..25d50e1e --- /dev/null +++ b/tests/sample-data/fixtures/extra_data/valid_extra_data.txt @@ -0,0 +1 @@ +CmMIBhJfChFzb21lSXNzdWFuY2VUb2tlbhJKChgyMDE5LTEwLTE1VDIyOjA0OjA1LjEyM1oSEwoRY29tLnRoaXJkcGFydHkuaWQSGQoXY29tLnRoaXJkcGFydHkub3RoZXJfaWQ= \ No newline at end of file diff --git a/tests/sample-data/fixtures/extra_data/valid_third_party_attribute.txt b/tests/sample-data/fixtures/extra_data/valid_third_party_attribute.txt new file mode 100644 index 00000000..b8fd354f --- /dev/null +++ b/tests/sample-data/fixtures/extra_data/valid_third_party_attribute.txt @@ -0,0 +1 @@ +ChFzb21lSXNzdWFuY2VUb2tlbhIvChgyMDE5LTEwLTE1VDIyOjA0OjA1LjEyM1oSEwoRY29tLnRoaXJkcGFydHkuaWQ= \ No newline at end of file diff --git a/tests/sample-data/payloads/payload.json b/tests/sample-data/payloads/payload.json index 8110c73c..7cc55b2d 100644 --- a/tests/sample-data/payloads/payload.json +++ b/tests/sample-data/payloads/payload.json @@ -1 +1,17 @@ -{"session_data":"i79CctmY-22ad195c-d166-49a2-af16-8f356788c9dd","receipt":{"receipt_id":"9HNJDX5bEIN5TqBm0OGzVIc1LaAmbzfx6eIrwNdwpHvKeQmgPujyogC+r7hJCVPl","other_party_profile_content":"ChAc3eEiqqy3R+unfX0bmAlPEuC/CU256SaZeIxVFXCjKAlLhMBJn/3V8OICfyx4NdjZjkUXTAOWa5d/6CwGBzRH+q7lAHW1oyJWN6uiopsiHEsp54j1rPIEdlaeMSEGjsLHiPAWa8AQmYBKkJDF2GSM/tOUPCbGE4nXyAwJt+RiAakC13kkQV4Li9opOGxGlVG7GS1L5NO1oqGQr8r7cRu8rUwRQfw07FuMUZ5NMPw3FXnCa5WwjSELWLA3FQeGahVJkDlhCKDkBd71KVK6kZY4MIBnNtLjWgq9JYdzQm1Y2OupMHbP4HRZ+S3f0OE1TFQxEqu2Pw4Urh2ax4Url2NXhcefLDG6B5NoKoQfC974ZLYNvrKn/uav5gzcDiscnaoNAdp6TjMbDSLiWg054Mk1Y+lHR3tHz4Ty6YUglUhaOn1mg6IK3F0nRXF+uGogDutrbmp74UIYs3l89qCB0RS3TjBLTyOUbhv6vzT2QAyhigs8k8+HqWA98Kvr7XQwuthheuN+OWPxYM/mv0YY6mxJKe4cTPXzFF4xJkN7cJPCCQPT+qMTl6dGEQeCOcBHZhI9LMdnvwx/C02MymugVDwk3q1Dh/OJuVKBtvDfa+S7d4NUINml/5ljtxXS1FYTFmjJuLJe228U1KRQu+PMxJ7dvpGGeOyPj8+hTyTA6SSov2nUdw4gCZ+7tImmetguxFlowQl3Vyoccp/JhpbMageZ8J28mv78BP5LWpuq1JgrMxvzl0qMrn+H848c6OUfU+Pj3Nad+bj3dgVwzNd0kXpqGWKKMv9d/50tkpq8DsnDLvSvz2dYdmztTL4M029k9UqF8iqvjxRYJsP4EBjae94qLpCHR1x03SKur2PZ3KJB/gGbdb/QJ59dsuzRrDSJhqp4/mNnQAGfxpz1KamZSFp1HlthbVPnjE6cM2uWfGRCe+UP/vGfcFNfSjiZQvEdPYTPIZlXDs+ahhGjYwhuRdJdbhBlVYa0FccVT/QoNZv2AY8ZEAjvO3nExAsqEzDmZcinXcH4TEIi0k3XF6TbXhN3Xc+nOVe/o6J6fDzjbVsaBw/hC8BKKdtW02AT3FiXxmJl3HYbjMiaJxqAT9ZOezmic7hVRp3dm0biauqOQEs9UWVMMNTc9KLPHkJ7abfzHuGYRmTYgJCcVuZZPUbwIYKDnIA2v0A305il9OVae1jqIvpj8IAOOOZScr62wwLe+2OvZx5jQ5HqD60CS1InIRZmbG3lhEeJP9GG5cLqpGkxyETeFo3O75K0jsd2hjgfcim5ewxO3zDj75ezsFC30WhGKAvs+cNdA7o6nl+3S2D3BbZOgd1/qid4S7SQ0uHmnvTltoSZLG5wcachhzT9Y0GcXAvuTR2zGawBCljQICbPCJX78uiKxvH/vA3IYl70uxO4DPmICPrTS4A7bdiXWZRylBQ3aCuvIM67t2z/HKAtcEW7gM0oX068HrbCPJE90/eyqHVNxhAL7z1wkAA+InWnpB2AtzH9xKfjCjCAteheop/J0pVDFr3ReJwLAN8Oyybj6TLWU1PtF5bs4AnBEr3KuzZ2LKobCnu/NLc1BvHHebU/YWT0OqYoJVcMDCAoR9uT/Xu8wzbgnC4mYq+RExWYDiAx7dUzb0i3DddeWOCWFf+z56aMLtIV5Csspx6Qq6Ca8CEVw0DDpBKe+imwXyAFWd7rLl8yqGIiNJFqiNk7SA1EPazsKito/G6p3Lfmn0HRnpq88zH7CNbP2iJLKW3o/MTgTZz5u8vaLABnX8oOi0DbruulEjqXkjnAiWyEjB3vna3f1SSE8J7s8Wvl+dPlIh9OtSLN6obJcAC1JmeAI33E5IxfNziZJyHn1S27+4de7Mv2q6FEXbNALL6SsJoZ1RxKp8051xU7RPkkGrZGiaj9l+m1NxxEGXQds0/QAPvFHqJ9eyLZhsX3DqjoziV9PwVrzX+KXpzrB0t+q+w0KvJ7yLHzBLj8Y4DXANsdhJ6l0Xrd6eOLuAAA4TghL8WjirjbzWIRbUcncceI0PHBJCQ676jY8IbAjY0jEfwct0iQMJIT0S5p4PpQm8pCiPM7JBxxTWlzb6brRwtB03Q05uMDBI47/R5StejukC2F2kh12DrzNEvw6qDbSbTdOxvrDBPhH52c/myrcNzBual3mRoIw3qpPUq2Lt2os5+FC2WhXY/39FvSFhDQNNLXMHtr4LDYYU4soO3nQcZjeEHFhFLAP0fuzCz/TYzBA8z/Di09M64kbu9SZRa5zi9GOgap93HKkJ/u0BihbetoHAlsBn62tAUSrbFfjXC+jju3t+fOfpgCvxuYBMh7xcdBp1u13gdyMWAwHhKyYFOVU6S6KuDaUe1mehyCv6hJTHlASlGzBPzDqTVhy+lJtPp29no9A4c0IWaTR7K1kup7dw1xenxdxNvXVWSZaAG2mnydMAKU0skwCd+uWeG9kYIPY1d/uiTezKx3rzhMYVHlpO/JRQqZ7z7wxA1YEgzFWX0+OwNkfdTDFRWHa2fu3doY8sr1MwS+bYJQDcOtTHYTs5ZyynzWXfQHMsHOLTRdeb8bMwmiScqEpJR6NN9TwmZuIQW5JeghGxgh2iH2jxlkWc69N3bC64tAXuOMBUlJo7C7NemueNVc4BdovTii8rk7lqW9qtzIKJrWkZUIXHcqMUlkV60fSmxYsByxJqTaxqn9xDgUjFOWRnLFyyIeuA6EEIBA5lyRbA+hayr7WnXAPVRHLGdP7cUgMB4U+RjMCZM+pW1T7EF/wViWzAxhIN+jpevSwMVjaCHnnYmTHZuAAo4UgVFhfDmPqvUf2LfkgwXbhRA7LA1zGRV8fiziN+ei8UvsSjMtmCJXjN2ilcGfJN8rPl+YFqcMoCVWeHgCdH5vljSnIRWo/rUloSqc/wFAlg2E0lEyRRF/nizMGAExW0vXDFvBKviXF3VHPAXqXSTzfw6mo/gubIkyU/vCVTw8mOaCCpebTpz+MpDlb6vqby8GamqcfLt6VEm6z4d8kikMhcWTn1TEsXXkLBan7RjTcB4bS4/dw0JNaqV82IDcXmxE7qM5tod7XgvEsdGGvYUpwImQSeacM3NpWyl/K0QkBRbms9QCQZNXKkGVolfDhBsqYun784KoW4lPOIiDCHALMix4lIm4hq83WQc2EhZJ6GPJlAvOqyZ3w0ohk8bnN0sgEwPXipMbU0ONLwImOxtsQyZNkfxVHp0OvD2dnYeQvqECLax1ezzDL+Ifh6h/S26dl86drTeKo1aICBE447F+7cGof5/G3Lpf8aj64KfmWqtRJ77Nz6b7NCbfez8RrRrmmajIBapyL0GgxHSo99DtzQ1iBcu6Gwn3we0gQyfeoNrtQVQtnjDPwtrxIoi6WiNjtHsQ042qZOUqUVBwYaqEal1WTRKFNKtXwIyyhYe30rHG4ua4GlEoIm7fb+AYEMuDSwlc152EJRoOGI8wSc3DozFm1pWyMGO+fhOBoNFIGAi7/sFTFA3HuIIheoskwaWX9SK/vELbjv0JJ5zq3iOASODKQQGG5KBqeQJKRAYASCK/NrVSTbglGrkcuWvJle+9vxT44cGm6ZOwwi0cLNCmk7ynh+aD7ToxyYU/nKbiwdnK+8y2deS+ro01hNDV2NxfjrTkt/gWiPiKzJj2QCwxbJrlAFBj5+v2pU9Lmzo+WzX14QqnA3jfyebOfJ6qSGVu1GV6ZgYvTdTtRggsHTdHf5jrJUG8zCoqHAaJ2c4WyF4trJSs2GFA2o4MtmVSqrBrSpCB8qe4KLMIbZsE7JUdiWDzePsuCC+38GRFflT4kyHzd7hx7iLg29XYRXvMO869/W24ieNn/JkjAcToO+dd5lm5T/bqf1CV9OmoCPzgRs/nUUfrN8Cpz4Wt97BgcGust90gAL0njCfU9LMCArOd53bsF2KYnVPFbl+9eCtOSzbUYX04QDXCEMDMChAVOjlKnoDxCBUQhnd1hGENFQWBwuMnCgwJ4zi4V8kkKvAlJdkj59CK+yI5hiWQbm1JpELkHhPmoKO9WfOzKxk5if+Q/3XOxvZVzTVSBcLTQeNCRApgf89hU77dF3CAZgaCvpBW/bHPDo/ZWIoXvZOaZyPOqF01UAA6d9tqpTV1XYH/Nw2WriBm/1uuUtutZYPBvaTRETvsVwK/yC9NqEhX4G4I+brmJs5rca5ApNj8QG2Ypwkv67WKVuGocQZTBAjIq2iPAs4KTTbDflzPNdABegetmEoXe1myiV/3HnAvnhV3bdKpTfoKftg/oecqiSX6DGpHsO7oz26HDuMUpxMREr1EkIZxYzQcmrBIU6CSqs+gHU93qmFxa0dZrVWuFYo7bdZ6NO6wz805zNbdUTC2OjlGTz0xd73OsGiznXnJD6tmVTPdrm4fjoFj/wu9SVgMpqVUffMzawX3I4PTthVnRthLzT4IRD9YTfwm7XFUgoZ+iOuQRHQGglvSpo1h0waT26t6FDpmEV/mmzQ5gTMZ93NAwjIxvtb/8j3ILQN0rPvcwQpbLSNynmslPI9+xBrtevw+1ParrYAmeCxLP0AEukmMD6NtvjCy8RJhG7ixL73ab3tb/57UY+nJv63grGf1QMiYaaU2JuBRpI8cGrlgNDOLfHlMyqzyh6zTDFencJuh/WaOIpCqs+9Sl+1Lt1offbsvSEExDAEeDfl13oXv6L0IVv6ExLpWjpMwNZQy3Og8LDvUyUOhdycWeCPfG7alttuSWDlmu7tks3Ose5hfFWxJVAjTRgVi5Vr5hUstah+q8icJitHlBPyRObmj0uAvC2A/+yk/nJKwq/IjrfiVdGbSE7Cu7s7ohno9Md/z0RuDawbG6MYDebeiHWCyctkJS+z2J5wYQXnu3HMAH4oOnE+VELM0uJqOshq75HmPPbsABiCl4TzKww7Nl2BtOGOeZpoeSemwdUe9LscnweBpd/3JaHjJWF5LKkGVl5TmBW3jKiiCZ4DFiBQNfYpexb7D9ciB6ncNWyY0t8QwHmWJjXp7Xny3l1P/rTlynq7GYhPB7WbQqSUTNqZDhfHF0KFml8FdTr/0RH8L7Ie+psXlvFnKBIFWoDrUbH1TfqDoRWFfj4K3JGsWizy5ikksf6P9/8HOz/1Jl2sEIhoGu8FU7yherwah4p9zs0S/TMHPKE+m8VaIUKz6m7MW7A0ItCQvxvC7Ex6mCeI2t+oMWHETY+hzSIOjs76h15ReShG4ZfkAK6cugQYvbUxfSRKIqOgw0cMQtzdYUSkpKnx+Y8hDktDHexHs4y8GXHTUAmJJz6AUEXCp/jXdRBn0vD9Y2xwm7AyuKJ+R+A5fGt6/Xm/uUCcwCzwoFpAnXNPwk4LKsVIJsDzfjmk8OTtRm6Qfku/3pwH5ecQR2kIxz59I8RjZ9KEriGaRuqQdUoU7Hep3eBQzA7+QMRaNIpWyTk/Ry3vsdBcQqLGD/N8/hthaopeBFN+7qQMbX3uC+ZYBtwPevalDbPAWj0EyTqWKEVOdGsIRlEJfoXBORD79MyZGwXKoiUFb5dS5XCUZ4YW3uSzTzKQRnbusyUA+f1zSEw5tNDQn5jFIV38YFNP7eusEFDM73szkHM6F16dvchVkFG+gGKIlhKTcfXCmeSD5TyywOGstSMm3I5jxcfO3B5JpcnpRnZig0cccXRigVCp7YjFOlq6XVZ1XL+bK4rh0FcfUUD27Dntnh4ECgbBNTBVaL4WfzNotszvFL7gm04xbxDGslGg2RrgXWoI/8jB8FpU9fqx7AgwvER5qNrtAKbVshm4OyQi8OnT0Wrk8hhm+c9/RejW5/m91zNg48YdDL6b11X5uZLj4n5+dKgs8o1YiJpI+UmxvOMdGRFkHkVjj79H4ROApAOiUgQxGFmjrkNtsZJYf6Wv7w5nljyvniCqAVLUto4VfCAZZ5EavmTVuYZ4uQtZ0wCLpMT5jXMqwufcsLjVxoTmEGxHLeI7UeUbNQzMfMeSO4upxmZSjdX66dpbdLPtrdBOWIT+7mreOtPnPadSUlJice5qvvUyPTftU7cOdSmRJ9RwY3Zg10UchGO4oKUl98cqiCbyoE4Ix7o8dipA4soPreao1mRpaRBcsEyLndMczHxA0e5L58bp9Je71o2K8jOjBXwpPRYEoF+hO/h4hdGa7zWb/7VqguUr1T9GFn1LZgz9PclTr1apF5KOfEjWy+SkDx6cAN2ItQtwuxSSb6KhFNX6LXaRAs18kVqeb6cOGdWTD/uXDltvzyVWHS3K4nQdaUmyyBifPaYt+n+T+kBcPCnnFXEQ9yMg1NjIkwq9xtX+ncvLUJCVq9Gl5ELgOYMGUI4pKkkK9J3yCqZ0yRxvabNCD+Fm/rLqe6R4u1hGzB+v295RwfDG8xrhHqRB8SFJyAEt5ZAp6xd5cY5so7g56zUy+FKGopVnnW+uLKALJfGbdQT9ZqAAqCX/MAADGkLHjVg6ogIDvaA/iw0gfLWOlqrN6VvTQQ3l2smd4iboI65/yYnVrfkj+2d0EMOTeA1Zfq7tS+pap/GVdF1hkwkQDdNg2LB5Xz0FStcV3abb9pTVKNIHWUS7d4NKYYtN5EDKZi4RLTSMwIbe42oddkThpKZU9W8eP4JYF8aIlPXbE0Z/eLKoofEj/DmiG/IHktzY+nRfhDGGygq/kKrw7NPAKi7YFhQInmFa/BTxWDnl8DJlXN92vXumJMT/7FiUMIsIuKA5ZPlYya8CXIT+8w4DBMbiuEUUwm6hP4XRzBIGGU6+IaXGCi+0vmbE/pZ30ThqQIKfLlhd4BlPJR2NsetLVahh+HIALsotAuuSvFf5NSaUUUhwsrK5VSn6A1S3I9WbYfLpiFI/Cxo+qUQW9fuvgyFVj95RiQP3hf4QqTAieAEWnRDmGlFNxbhkDiuWsJKvFxg9pT23iJWQNX6ywBu5jGFjXp+IbMathRLY8+VdZxtuVwOgAt9kVlQoqobt8SoFKGT3pqzBYhD75rDPP59HftQKCxuag1oPWRT5WZhBpIcNnBG0IKxeQ6Otp79vDKGP8LHswo2aIK9byaV/vXxuOnztT3/bP0D1jdW6BFskjCVmAHpR0MDfFYNcm3PQ1a6fsFJTQDKn63lFWzFqfAn29uSngjcWb8y8sBin5nT04yn3kjcJ+b2z8ZQgB9L1gtlkpbD21URZmt665jAfaamH0N0kiG8IV4UrTBl2MFP2+t9YShAMhBFL1j9l7kDXBMeUyMx8/9dC71WvtnqNK4iIHz1SV9zUJv44EPVP6DbemKo4RCX5jvI+soYcxpMdwQYGHuirN1VR2SpRzl6HrT/HtQ1tXNFtulVGFCVQ7iOA6MwcLPlrV8dalrH5+C/I7vC42qlmPA8wwt+CAuzcfwccYpwh3bh/CQQOPZe2Txdk6iRZ0bgUsOg6Vz9Frf+1BrxXTszKY3hSY5j7Juv4vsqqjW0MUFccX1kwIwu0a9TZnYG9y3LVl1BGHQdUE9+qOr+EL05VEfIJbgH1aOqbIas4jnZNswfWbwXIoGw67qqkQ5ORjwM7aUHhedyfcFxKv2ws7KKHG6HVxRxiu3NRhh+nPOK4xhu1rV+FwrJq+U9RSDyOUgXrToKHRRQC9U8yQ12A4gH++tGqXXvnrYOC9CDONWjz9hK4rlfTs19ZLE/VPOiUv3DCQqPCD5WigXSgJ1mt1FCGzWeKioKPZ84zM3xcB3KVl7cFH9aaVGqzTTJRNzBBZ+dXkofvTJ4B0xTfTdct5bqLoBX/aUdovdS9kY6czaAOiQmBmqRKweOQTHOiRl+6y5W633lfYfH2vSQ1P0E3F2xStJnWI50/deeuFksLeeHEBu+p1Hf0HLyaftcLzDPOhF4GzP7sH6ptln4NaOqyuPQUyKAxh64RBxr94QS6cAC2Uo42RXkpehBoQiT07kYVSeO5mkoLosEvvnoFoizFs5RCK8EG7KJO99qdX+F8WgwEIvwEOPGxquI1O1CtDrqMNqKZH/i5VBo62QqGhhISKj4Mgv0R6nqN3hahHA2DbKQxSmHgcJ2r2hqMlBKo5hNnlbBXij6aWGJvynMMGH2zwSLQp4Sqagq2Y/h0Bxf+Koj5t26XbwbV6sslv04zhSdyPlVp4DtLNp5ENBgVAQVAa4yrzMRM69IrX/der0TEt2Bl+abuW8Ap/BvmLgL4rRekARGJb1y9jLXPNLSqWy4HhpR+l4+H6dET9kYLD0c4oC31kQKE7uOspaursICPwCwIAu/8T1w8KTtpNNBtsa/IfKzjj6lzLt7IOZbalmkg0eGHCJj3HiF++P0ENsd0PnqosNajOiaKxxSN0/pa4V7bbrD6+o0lUKJ2VGt/wcOyU3Tjm6OXQHS7EazcXiAUeqB1KPVPf5JfWvUzeKiAEzNEPsmzohT3SIdUhL6GXQMJPPlv5xo6O9FDh1RqnoF8ajRQWZzBBBfClVf9eT30n2BUEDi0RyFHbygDmzgxOl47UPqxw8f9IKMnMK3IN9MhPzpdEC0zA6e0nkp5Lh68SYF9WpTmrvWujoRBlADpM/EAxPyDIpN8RBX9sxATYI8lo4EAqn0XeGyZ2cs2br9+cNNaFEZKdTNrHQtfRhfuxBtKs+nHkveOLewykUsi0RUQLn4/5UM4jqLVlpc2ClQ6GREjyY88AlgiGF62TZT/CYZCkmVWPWRlqNUDIAVSF2Zj8qqWbju/Z51MVuQDe/aL1AhkQyE3z81j+5JJeaavrlZ1oFPJjkzhATmam06QMvIaLgrb1bWoyOXvE/jN7DaWCEes4rcxMLprz59HyA19CsdF/SukmSeF6Iv+igIG42hWLELb7ZbYfQuWeFN8py77INUburpUbOoFtmEHT2m8jqyWIsY5IHeDPTn0si0TNcsy/pQzozMTWW+TTGyxB7YCgp3MtkQBVbtvhOj/AUcVYXRyuQPa/O/g6THbFP4ZgOaE7cT87L6tI1qYOxUjApsg7uZ+F9udXp50f2WMXUN67zBFZNadGtjTs+/9sQBqtoCECBiSw70PKb25sN9rgFX7FMqxodi+w7TSZQS6BcHqJU/PRs76EeeHgM917O3qHL+lTF7I0ezbHlm85hFNHqHr01U1YIxAkdiR/MMlSUJ7l/o+okL15VTBFwXH5qd2bi2ZiledqzjVgUEy0Gzs+/I9nExyR82hBsU7/eH2+liqatD6fTkDaI8VhtqxX/aoMHTKjEMA04/i6SuhAWVH5mfDL2Jws7vCDCaKTphr6XTv/ycoaQztEVwYrMucoyJALgInv1DLnjSnoOAdwipF0SVUyOqyR0rcsOBSaXtIe3V+/fyYsvhoE/k+rKtqsHUIY02s/kQn4Xp5em/Wb4LuwvD5gyaqv4yumgnYHi8EVhRfnZtyiogdHKsjkcY8ctXdE3uOD/pRVgi3xqPBgOWcHC5mzrqsDrliVWUZoUALL7LzPg21yIVLjqKf6sApYE5wCm4sdfpoGk9WjlgjWoBJuhw7+I6Rl7aqEUtt0lGgJblp9gcX2eeD49Rg8perx5wqzhWP2s7gpmTMNds9+QI4VKIzhaYOslB2z90vRk2W/9Z5kEermAEj+d6tyB25Q60PJSoxE32UESQJfNNJg/Y5634r+ZU6X/4Dpk6QYBuKmTh/kfbDcMqXlAUF0ph1zUxolTKAvVTfqhTzyV5sw67/3SHsxuagSNfOzxnDcf20k0utjQhDXZoQpssAVDrweHfvTCFbFbQcvCLBUj5WCPR1pDuxM8tKJ1js5dhr1c2ZyGZpRD1RdMBCIJS+aOFJjtfYb2G/wp/k+4nUf727/54SjOKlBR4MWeSJL8BPh0H8E2/w2TkonRbwVisPJGlA/SMuGlHt91khxIRoGKX4tShzeZfW/CfdVyxEcZ4+qQfkqK6Ezs/GhEpW5tZPDqOAOW12C5CBzY075Uh8xj380eSXrpNx+yATboeqRfHNJfQt27M3HZ0nhS0uWTW16k5nx13hRFDoW+BhpuPRACs2xHkHlpbDITLvJ0UraPk+Z5ZGZBlRtLVsgLWQDStnvcqn7WEfmxFH/vC6lek3jpZ12RetIOEi3cYvLgmCN0lPPcNYtYvq+ArbcwBMzkxkwzUaxxndezdR+t64omyWLMlzi0FL/Dk5Hseop28IGSMeSaMsxVMU/cOjj4QWzuzKzuZCwuqulcVMOBnpQfuXwQE16/L0VQRWFY38DI+8tL8y2Dxo3ffRJTYO3tumHwRa25Owggcqz6qv1LqgB6p2Vm0u1KbHB+2c1huIxJ8N53/dGmAP/yBaxgUN5BwbASDsluD7BMqv+uIYAooUSCFU+NhmKQlQE/uAy4eLkgRysqQdtAHbA6/GtgVtZWrkz0RAjnkNA+rSE/aPAJtRT2I3yZUhd+XmgqQ0zc6eJbma1xiCOREOUnwishPkxAodEJiprVua1vLjxLNtgKzRJJNJOeNa0/oYMmcGFieSWiUGSIsGswlzZuFSNi7+WGzYS1Ei614W6YEeTEpo+DhvtDzHqSlWhjoAayefmk9Iji6MdXWlZCNr/CyCpbE1Tg7b4Vyx+wrgxOOSh40MYc9Da70iqmtBj1ALw/N++GgndyG30H1L8ChvKk1kLcVi6UsBqwARwiwhctlI1QkPR/QkE+Fq/XlkyXlmuO0vPSydfuYFojEns2u1mAnJgGHzwc8EAUKImkKV4HPAxZTuwMYL1GEsae4uATv3qqZCY4ccLMw6EGzrvlFjE+4ZtPXbh5cQZL/oS5zcLbL0zvQWJVfGQvcQ9I3ErHhP8766V9umQrEZt3EdhkKtozDLtro2hwwi4sywcU2yOpLciMnT0kdp036oJ2eiHT79cidAHmg8bMiPPtzmheHOyPhNcGJBh8eBJvfX1+ur79cQcZNPyHtIxr6PyhxxbOirCSsmULL3hWc/qNnRLSUZRdmupM3HB8W9GA15xNrWbAO59Nq7s4ccjekthBJrynvUQ12b/cMB8Y91sN/93WQ7h35uNmdyDxjAOExCjsgpX8/dFtqdRgI73yNjyDrKgNKbDsGx8m1wVze4cXjOkKrMSR73KywDI77CxuicT4HMW9jmd1ejaBd9CD82QrMwz4bt3vh32yEI7Lvj6QKaC/fGTf49Zq3L9O6j+38ySGK3K6X/wdiELWtN8QoNYU9jcGpNjqAE5ySH+f52jx8Y8rnQjZxVWsuYcJzMUK0+2un17xRzj2BKyQylw4Vfvv+QGPhzwwWg80w+YGjib9jXvvPtVO380Jqn1P4w5NBuuAdrh4mWl2bp+JTmBvyNmgBKzhiur24dcYVomYwnvoxs0usa6Sfm6BKKOTHPhYZ6/ZDha/bJh0kFyVRwyJUG1sAN6mcsYfldKLhJoL9dAnB8DF8jygtDhL87VjIFCJ+kd4kkJNCHwHlsPAqa4hG3Nlmm7ADhaptWbO/PpPZADrikLXBiu0+kJjIgMHv7BVYpOf6/snZzRP1lOyE0DqMAzdeDsvKpdn6oQgyZvw2sLMzZAG9hhMy4Koqr+sRxk1L7CfARzFq7Vx9UfA+ys0HiJhODyw8jFru37oFEuWyowDEB7Zt/CbjJII3JTgztzvjKJrPEIONnNOVHDaqm2+7AIQTaYo8txheG0tOlJrWGxc2xxosG2U+zDCCAS7olGePkj+HbcW/oZs4MfHYVmgYKu98GfXbSgjtZH4ENgcpHn0J6ugUvwxA/OuQ4jeaV0nqNFIYruhybU5AqOl2PYrnruUhs7uKVz6TZUuyyqf/KAhUI5X+ZWNNZNYXksZB0+A7ip9aByLZxDtvAa+fUjmL+msVDpKBkdsDHPQ8vVEp27+27zUvXTkfLDx/m8QJYIO9QtJ4TK+Q2pRjpjQ3V5WpJUufwto4V0wcLIYDv9QLGJlSfRbDlnOrXm5j8mmE+jjQEQH1DT2N2Ax6EJSDAJl7VgcDqYA05fOQHlIW6Byzi+MHe6jbiKTNBB7d2Tj2ubUbRQksbZH0RrDNbn42u6nAnFPH3x5RGd5D9SF6W8gB1fQS0RRo5ntQ2CYGYVDgXJg7lv5Eyj56heIDi5CAzNfBlstJm2k4RAfYAm41ZKbshlT/S/NT4oLWSz2Jh406H344shSazRZ0wY5oJLVENTRp1IpoANIwsjCd+7a8EFQ1nyIXnD6qBPv5sgqxCMVZTM628kBdK3gtVBpYL5H6HT6peDWpMUqxldqDfifu1oOfpZmsMTh9g6Ecnk5dSSoQoKwXnH+OxyVGYQW+zG0nNTV/1ny8L1HQCsDaS5I2eL4rERPZ204wTpK+nxt5aGTfiRoqhqoiPyaraAgoEEF8O1HpokC7qnP3q5FxjwCC6Qx7x3YnD9XRnZNipuoQlSIf7p4tc1nCgZ1eaSgJTQ1OvqlWsNuoRK9MxyNq847s9ZgZSzDOt34c4O1pamupEalcqo02ZA5vCvivyuPjZws91DR0bdt1c5caJOdT0WLRDOl/Y1x0jj38EXWPmtwp/KNA7cguJFFpeQhF0E4Tv+j/d6TxpTmxmGA6fKTHM9Q0XkKJ/VZUW3IyNh31jOGJUT6N4a/Fi9A9wtPHvDDVyJe1wkUDoTrLiDsX0/LdOG9ijXYtvUNakS/KBS94gsG/ZDob0QRdwUzEclJdMfabs0hH+WoI/gu+e9wL/JWGChpPYD0Hhq3QOBxjcVJ+en8RClKuV2OhHZUj56COkfSVhJZw9RK71SL8H8Af5D1cw8Ro2rRTO8/hk5XVTg1RIh2YH/zS2TlsApleha/YCa696ZNgXrLN5CrchbsgCwn6Hpizw//RvvFdf5kfS1PPmn5xsTvGyZNdxw07w3rVANC76LYVmLkJ6rVJ35JYDTyfm1ZEIRc6OgpunkKBeSirGCKn1b2p2+jW8iHi7ax+mrvh74BCoALH0ArTHEVxKLPjK0Nq9BnvDyvkImnysRkSRv3byZpKLJgEjuUI0ZO6X/aHCplMRa3KDaGbo06PDkuL1LWBD9boZAHPXaHdDX0sHK1uyxa8LZR5XfIWiyVW7u7oTCCkfGWJwK7dxdd6x5MempTZm4eL33ZYvJqedl3sPbdWBbHik+JsN0lIXyHGvP/tWrHULmRkXuVnoT2ljb6ZOYaxhfJBTAgTxJl4IBK0fGDmV42sRhTbSbwO7kCKUXuVGthj4sZ2OKxnbzMLWWdD6birbB+hlSsQlDc9JoeaT46IlmSg1afRmm77AdigCg664aom0+TwNgjVsXxMerpUORc2TekkH6acX85pRACXK+Ni3hZr0uhv5/29X8NbHr554mX7QUhvOT/IJAA9BLSeuBa6WlI+9pV6e4s0Dd4r+qOcGgsW+Nv8WqBjcjr3VbuZZgXt7TO9PqyLh5N989bHYv6I8PSudss/C3C25YpfmIEBJ6G4ipKYKaor874hqAhJ9P66pe///xNJYjThzkyq6602z8xNwzEox8ew+xie0l7qBs5wMcr3aVplTNE2xZ95ZSiuKeS6zxFuY3KxReTD/tcuP4hLpWhOfdgIFpl+xXBVAzmmCXt0+XH7u750XNEt2T+fbQW+imZ2ZCZzkt80xCxgZKxQ5HOVUW+WW5FSV5DJvTycIXjM/9LLQciXGawbp2Q3eCLFZVE6WEcmV0RNb1u7jcUyTDRFbaPLkOrBBZOJctFOTYH927Fp8yg3oXZuEvtm8Fkoyc3tGOv/awt836MFOZh7Q3XlhRtUCad/sWKE3TDquaIUsxsSU3t2Vv8iNJlpj8oQlFY60yc6GWdR9o0mnTopHyfPH1LqRYQaAYLV2LkJ5i6WkIShUvBBc7a/Zo86BegsK5t0HEgoWF3cSi9vtkv6wrMC2x5AT8ucXyWBxQZcPvCLWoetYTV1/mP+ikLtoTvNEvMy/bMWpTssL1lnMP/ryoxx34Es7tcbvit2o4eUDgJbi3jja94rYx3BtmMjGn40EBVu4SejJIpZZla/ngQXpKyuLzgF5bhcwNczXyJfXSFUHLgUhEUfLmtFL5F+M5smFqg59ia06tcvJimOwq5FTHMLLSn+Zl8Cl2LWzgk9rypASFKoWEW2JlDG0G3vAWmUnNsTzW6DKFRnDq5/hpx7IHMgxd+I5qwBtppibPtNj2rZsGIzFwHekpvdHkuzXZ9ZEp7ONCzZT5fgKtN2rSzpsaSKvDHamNk0ou5spKokFlTe3cYbpGBBTsrZCLXGBI53EVLNQ+0XJvFQ6qvi7cAWsFc14qRJlw6Wh4oyS8nXGhi0RuCVUaytIHM9Rq2QLEjxigUTs5TBcauKfGYbY8L1QfjL3hP/gELUl5dm7BgnMD0SWTQYdHP8qNkA3tfQxvLtaxvdoVha/EzHVILlD3DFSd3i+Uop39q+mXBZdVh3NhnO+CnTEYu12Tb+8Ey7noqDRWRruhgmnCBOIhp9f7tTf5PP/AZdg0BBOH94iP9BgerYc7gUX93rYG4Cg34aYkQhIxRHdggJlBWUC/5/ymjOsA9kEYYBARvMj7Hb/rL/QdBmHs5eR+/M62tVAQRNzyDwpGB/KUyiFuMhJhhLDG6gs9PKdbzb+yp+ZvsAl5qIc5VEpWy9H0tY1tpDm/fOCLI25XVfBtR42Yue1cwleVWbgf1bWODUyuN2d4a04c4K1t7fApUxO2ElYASzGHZZ35KmIMRr5z1lKYdBsdDmfwh/ILHiXTwEyO7VVRGBtF0uinPGsVwY2/0/C/joxFrja/hvI/FU25luqUsDzjnJH2/6fxRyVZAofNO7x+6DDfgw1+6TXQHY5Xes+SS/q92RXc7NgWQLr3FK3Ej3nDCgj1XMwUWbiRUOeVYfwiOUPjd07G7V4bJ6AmGUMCSkWk3tbI9AdEyvKUF5Kj4UEIq01hdnN9cUckqAfGKceaZ/yBSXgmODTawscGigu8x47mO98+LGXVp9AP6F21YXdXgp7MFX+ItrpTQb7SP9aDfR2aS1uYnlMLXX347XNd2wgXwBRzf9TmCya0H3cRURcM/le8ayQUWTZDJuhr/gsubozrFpY3mQ7uW/HWndsqSGN71+X7AjAq4mttUmwgeVgfzz3L6rupndjgPQV7I/oVajJaUPliglHuCf+9/foWgSjLqZmZ99k9qxrhfjqvR3h1deQ57RbwyacF4yUqp9DeGKwXIWwNrH5abI3Zd6vdAy5xovjnGo9ilgKxrgQUVYREwYVOCkhEEyqcuKrXT6BoALCHf18iYopzXLQIA246f+Nfmm3YwGe+uRY4pod1wKN0BgED0Ebt09ZPCgPDaz6EBF7BeBVNIkXUMYShX051ZlD+eqbhSZjaD4I49lSBKaWQt4aL21ePjpIlt61YTNvAkRiSuCRzjNw/kUV6yA2ZaAbmbNmw1sWMld/e4u2MkC3Oa0/8N71TRKikDQmvwTfzpua+WNm1WWPtxi0uVu1uWHD5oeR1k0M6EZ1pfKoCfFWjddt+pEHBdv6J2U93J5fNWGBnKbKBnpnWHeNMVrGrmJnQ81gcD0MKYHMYxcuN20RaqyuFkA5Xwc/mUHhvXVSjXbd75H5ZCQ4BMQb9zGOuWY2i8CmyRrOh0FqEpwcZmYyMHahHkLsrE8K2JMVmEj8flH4RbWsVMCkhNFyNxJhAQz1RA4+Arche8MrRS8k4WQzGv9jYlo+hMFKYFgWrhvfQNIq2QzCpdymhiJca+Uj4nxp9YRl3/D8nCt0msG3EoU82xplW1AKiO03eEOuU/APR5+wvEbDZ3ijc7z0dGsGn4jTrZllYVe5s8201NCdjHIAPp2/1ftVyT8xW4OKOoGXYFWKkIbcTv3ewbiuUffmlqcXUDAiL5blKrAZ/7KLX9hwZJrRRWSCb+hvOCPRaldgb9aD/7KO0B8T19+Rz8xx+cqKj8SLbSYFVFEjKp0DPmPK8XxqszchRRgERcV89quXNMhmmifhELPv6ZqS4llHsR4lD9Awz48tEJWGKtYH8Ku44VPp+n4SKTkNh+CtYGc0y0+15BHUsQVCeUo9H3F4xfFucJERIrr7u2/DK+7FQfluv7fIGu56H7Rpz6gi2xQnAcg9H4dTmxqubNEHrJv81CoEXiFNnpiRGaLpC6+MvL0oqdDF/WfL4g9jsE9aKaXdRQM4IoNXn7jcYqXfA1/w2IIT57cK0MtccbkaIKa1dRSTQClcZAVhviDW50zimFTL9C79RN3UobS52g9x+lu81OOydJ5xktMFjoo+HGySJECqJhIVtpA2nIblg6WLFL050ByGgopagp/3uefJqYnrzsvaaj/gMbt5aeEl1Uswh9y7rY2tZKtZUc7kwikj28FZZOls5e4Amz6OmgKAfwyCjsxK4jbDJrZMuQ5osE95G4vCKG62UVHNpT7p6HljArF4wTsNSPyLHby1XBQqlnXwS+deWVs88t9lSQeW1z+fOhT110+DoscEc4gdA0C8cFLa6SSjJ29VBpXjazSag9RWU7rgIa4utObLgQReZxmkckGUvDbpqso0SheCgxsF7aK1UJ72XchDMEbXlTBz/pNUgmE8hlqvbkfBSSCnnrPbDNk294g1J4Cdgd8lBe06GdPHxHd4ZgiJIiLqu2cZ0YMFNRcUb5Bvh3Bz8v3o2eX3pSymou9v0bsOX0NQva7AKP6WcM+XaFkgEwALNCxWCxopKFn1U1V7Pl8+LzqztY1IKG4gAhr9WA6npk1dgosxlwdoqa/fjkGyqFNP/xy2WrmzHrGSEZKZo5FzvUvfiFfOcjKRf0KOyu7fIwUiArhhtszHai5jUG3jArJD5fvE50Tz8dTvFWaHDJQReWQOTpP4peTJcWcTI+hTqZvE/n0NViqu/0DAS/9LVYtc2iRUQCtjAHdAU6Lw+Ul9tQP9OErJQc/N+ydljEYVdiw/eWYeB+P4gRMLBY0Qsm8EtEee7zJD/lpOPVGUK1HOq8SHv5UK/h+TjWeCItmwumDkmv2skjflrfQSDTbmSUk7C7C763hl677OQWaN+2W55VR3YFUJkf7CuH+f+dyfHbpfLNKBA8ZaCKmZGfWxxVqar3Y5snFyzsfdlRG3IHOg69tcwG1ouNx5G2pxgRXc7/ve+eumkmkayhk9j7l5SiJph3aAdXPPGdcNQqn7M7Ww2M+GKiAQZLDt69aPRfiCcYqRn8EsskhQkQ0qOlauC+7Y5+0qJAWLt/xBYfG7BQg94A9D1dwj6AyF3yQjCzWup/JuC6XeZYT/Y30dR3Wq192tNd4mruuWRWyY5eh2SHvL8mcca/DoNXEwtao30uW6ohZsv59zbSklSz3FoQ3TKIn2fapkpHoe3NYsw8eRijwwaWIfuOaHN85eWqgf40bRYOKn/gfgEWrS73p4dhYgmwZYXWkr4v5H/W2JUlIThOe4OGmxUG3id6QAC59ksFzEO29jyKA0Gm+l9qzSJQ8H/nt50wwD9cpJjnVTltDSDrOFaPGmkY82fDNOO8LyscaLn4646ZErdvgFnJVxMzCrWnGWg+hFhPFY81Gza4iVvEwqa7frOM5nBBoIDHqqKAoXYXmnmoj06x67m21ilzOcYmzt5+95mzokjF1hoc0SWeIx4zG/m0ImFEwFZQFf7vQ3P9fhKYw92+pFyHVk7TFgQ0iRPMkIz83qVjXvh4jF+craJxFk1KMGSx4x2Erby/c+VY1WIZXPaeCT89cwuY3dBKV4atSIE9EHtf/coMuvugRvgFvlm1ApLl7grXf9IHuIXeRZdbHf/c8G67TjxFST7BdDYpFBdw2xO9uJSaG+uIN+1xV7mZUh73wt0AzFKlSk9iNyVpQoxMZYAWJlsxYWPZiciCNu2VAKfz4qlK/yjCB/RKMPZgmzUPqSjP85w5inlQvpPLqAiap8+/2nEhJaWCEsLGaXFk4se+Vf+fjxHvOnEd/uLkahHjvB2oOc4MzZBDrYBFe2kvoyIHhOscWHAk5ppQczLu9moZkrr/eXHMoC6aDTVDQ7QA9or8/4S9lSrbIG0rkWhMiN0zHiuM9ULuXhU77lIe9JDv5U1jdglArcLVet7Mu2SAVV3SjyeQ+stuvSY9MYSzPW3tdGB83S+Rq18c1rPaFx0OXSs48H7MZyQ+ZJz1HbyUax+fTjzAndCgXj5BFWp4aURr8eVRDGh/aJN2eINepq6T0FxzM+r3o3rZo6jB+5Pno9/E55Ek/RBIT945UR533Yj7ifalyVNNyuEqqDSyVnsQVmkVgGikDpZn5Nrrur9PZehelgiHHJOiNsff5H1koZ0t8ZKe8eFQrKsPgVo6IVbLZshnCF3k+F0a27NyAvfmKqm8+WSw6Xz1SwUwVRBecAvJ+CQe4OfjtjxGw4LAKoWBp4wALbbwW6+/+6ErmNvDk9/K34ot05sLT0TmURPr6xzJpHPKJCWeJYmzdv6+Ylpc/cbDydk9ihUQottQ/RHCPDdcAdlN3K4r9e6kwAzmul8dojbDwHgzZDKBQdu8RWJhuUL2L9Gap7OS0Afp09+r8sLc/Fo2rHBzumUQS68Sn7WdkBUVl7FohsNK73PeXWWsy3HdNoEtYq6VtEBWFxxNpnKo+ZuRulxGWCbCbHkcEigF7apBC9glcNCVTZ0ALp1yKlatIafVKpvwtYqjngl0xsifWqv6ZPVfEJMRz2yUJKyP0V4aPCQjhffqz/VRa0dZTxtWvuhGqLOF/SvWHRxbB1GlrVkTH9iRx00y5RlFpFkiOG+7B40170ZiWvmqnEPAYdBnf3CEGkyS6Z9S3mIfrf6nMiaR4MG5oMKYK85H7gbBUzXad0K37AfT9nTisvozBB2UD1XMHlQiMlK9BmnhsoyyMYnqoCPDyRwxdDZhdS886OaOJecYBLNC80amddgFbxVNwpD/sm8PyFewZ5dYa7wkzFOn+8HTXNtpitK3nxjVMBmxXMp/c6okAEEjnU3lAd1cLndd8QQ4wB6Z1a9JslJ/wgWBksfY1MVyRNAq5fixGUvEs0hk0/b7l7+y6OHVgByYzlHIWfx407u65c0nVs45ak4VpSEkaZG556xGfNHaJoxVTq6DsnsVqg6ltL3GjZdBhhIaI5J0KfICUpS77GvNk/N/yD40gMyJZT3x3P7SEBYirjDYHE8q1jPajqNfX8iG6ag1ZGHJCA2gQdxg+e981cp4dbVDBHVTK5RmnAfz0RgXZm/Oxd6cwDlKWq7rcrGWGiM4yZwz9swKA6GNk5XWSVDgeAIvoLOc9kyscxqs0yfj5Oc3PD1BpQhnw4OsnRbVl7zkMrNH7l/lzPvBWdzjW8nK74eczDi2I3MwL4UT+3HywXlx16srw6sWGLn1kXyB0Fu+hG/vMfWbSJMSufvLjOwnqx3Npkfu7Afl3OMWqkyDDm8z6BpsoG/+hpMcKuVys6A8U/IsHhXKB0t6u3X889Mi5XZ0rVPIv+cCfrx2Zjxp+ssaNAsS9N7D0g7s/G57g6MVDWzo+fyOTlOxsxOyejl52xIPK8861DtJTVLCOgtZegmfx3XR4UmuSmo7hc5cbnWdaMYYSnL80/NKytAQ60ZVsD4jlTk5LAsGtajnjwP2GY/ez5qycN+km423MgFbXqGPT7fZCxx9ujIXkHxTl2Mwq+K9w3tGCkbt9z63QY5vCrDbJfVB57ljhaxkHWhW6bu115B9gs7+BWPFAM4vmP/iiPUCfgESYdvlZYjMJpTqqAagVurVcupQpeuQ1XIE99BQVKCIBYx0t2D8SU+1U7JXKHRDL/rvytI7KJ50JNZRvBpAHOEmYQd3i5YzSW9dUIEisMFI9FNEMsViV0oHknpv8SbXVTVzpBpWMrFg98VjSX+8dhJ+yfYt1a1VNhxOSYEWY8bUdvqkfeoHhVlTLhB0QcC/Mw4eylXM09XAwJivZVOmYP7A9nv2br/Q+5KXMvSWKVBECCMGhmVoRb3quAB8H1MQQfW//q1tmlAEtPRRthPkGqyFIEtoE8wRrNmVoArfwbzgK73Cf2Vhej2gLpJK0la7TXtLMAhU9qrQL2/fn+/sZ6JkkAkfGGY3vkw6PhMmJ+GIvam3X1nRFuwBVN5RzHkeJ+GMGrjNhRoIiYks5fZ0UrE5O8i5/pCPp267e7VKOzqwvqTdVZnKPJAkWheaKVoMaQZ8RpvfHZIZix/3ORqxYwlPYAMsRCX8SurZY+OaBYw7LaGoHqkx+QaBXf35zuoZzTf44hh2Y+Nxab7jwkDhaWrFEh5q1dSEyAHyuLU4PW7JXLo2dz+RzmvlxDqyiFpHlt9WedBj/1wq2tQSRoENSC4Vfgt0yPN4h+3trIviI1xr7yzCfRKRwGe3l/KAaMR5tFADSodoa3UXlWMuRc4XSe3KvRgt/pIBiaixikkVo6SHxokcot6ynilINqvz3LAORBke+j89jby0ReGFALRGaKElgsHEMKtgeFyUzHhhvIuZIT2bljumg4RK3NNaqCi+4pZ0pFAzAOFUkEGRcQAd9n+VLgkrV6N1vU1CDYJVXnBWwd/GUNXPgmaJ1aimTg4GP8bXHdY3FHNqnhzmslCJ0br6qEPS86z19s6tlMU4gd91iGshkcQq2ONNsaMR+sfG1cFNA0FTHHZ6LquwWKIsUh4lL88Drutxr7y2z81au6mryuga/39jA8zkp9mHc6DvDlOuhhuSDcUxKYzHFyzeKcmVgWWJ6C93yzRnYouObQhhx26Ai1CvsGboLWFGQgqBCaqRmrvfSmUSNO5eQ5hP8VRJJdufCDJdXR4bV/aIMtrrb0tDb0ZcNn9mWtF8p6w7JvFWp0Wy2K0ounzWTPnv26clbnEmeJj6Wb9NXCyet40b0PtDqJxlI29trCLlCFJSkfTVn1oftMIWo7M7/A+pWyKjw3IwbGtuYvAcdD6ZJ8fwC9vESK6ya5v1/hXcurwR+6vpT52uELe/c/mrxN9IBmEtynX+ooMcML8ag84HDgvkJDb1j/ozSptl+6wdkWSvMdyMZ7+AFMpG5Gg8cs4nLk2tRpEhRexlhU7HDlG/4htaestDbXMtEEnfReoqri9wT2g0fJX+6IHZ9pgsLZRsPgBW4tx1RGuMj7J7Yj8H6pxbxF90fSqhhcaPUwSQCS+H+punBnWLw5WonOJDbJTNgVFBnRosTXRlK1UDKN9pPqwfMECVuVuANDDbHR0T737bRAbY/UBVXTEk/BFkcfreauhrTJSUBXdSVE0xZIn0e+qEPVqLDSr25b5FGDQLh5/LuWeQx4E7p6IsvXnbnPT65sMmx8EFXDFi3wfk+8mgWw5YX1D0O1+j6NmypHrL1hZ16p/8dvlOWNNPqmBjeYbfzo9ouRVMDeT24FzZljDs/4FZJVohar9ztwKNckF/9/F8tbRStyg0ZPchkeff4Tgid/jN3BK4TETkfo/uwSibtD1iZEHpzt4QTA7vmdrtxLxxQAjisCs4FayQ8oScaJ3ZzeC5xGSpEGN4gCcEM4XS1eWdpUSjSE4xe4awYVYUpgbC/77tnwQNaqI081FAgkYM69YMAsI2D5ZnMl2pgV+ifxx38JtQLIjGxQXiQBJl8qZtMpTk+foOaPnMky3TRBjqxrvEPT/wsc4S2koXihV1DkyoUeH29u19Dip5BU46UjipM7wrBgze+wpCKzwCVKN95hy1Rg39qotoQg0RSwMCBmyd8b6Cio7t8oCKdECzCknyqHN4beQN6Cnm0b/NU8qM2aWNODQJyCXKvfdAXVGqyJUF1qVGZpyKK5RXaiapjliarKKGrZJKhKdJOtto1dIF/6QU36n3ALGAtlzL5IjjPeowiXamVwMndM7NfdZa2/t6klO6QS1Hk8GFnNc2YPkUOZIcyvYa9U6CRRdPECvvDVRVWO/LQ4LHci8YUp++4oQVLSsPiCJPXF1lbqJKZtnl8m3A40SpUZEKrr93RTjUppCGN3PdA/LYFgzvdcIUXldiw3uHxgAZ1agrxGacWcmYYWVwYhofzZJhEBRHVZdFAYB++eCkptgk6dtpwCQO/q5TIzDP//UPdWX2f5U8jgYtNQ8i+/0EwN6TkPI4gQxgxTc5PRv6euErcppHs8cwj2RjWZYnaCzQAZCJu/7cKNyegwnXRUKgZPRZomghCHJ7RDN3mdd3JYkcFAeHRYqOCcviEZz00VlC7jZbQLr6LyLWFCK9lBQdjN7KLwsB/BHQ+mdAnemf0cdNmdn6pCSQyUwL473w8fJaz/twfP/C6NWEwDO9g6IEt1oQ7ETc0QciP7B7ffI71ISKwaM0qjD7n9KgLx4z8ySbW7kKhxA00huSiRBTCMPPUDAx1yvjV4aV7mXccFb5eYgJwcGUpfMOnOdPQq/mULWgA32WZ6IfejZdADcwGDoEEKSBBHwvD9GJ5ZJfh/8G8HCEkJQtu8n4cP131esK7/9YpNA+sZGjqCS/qvd4Geer6nn5PTNvIRp4vAARJfaxAx81U8i78LXIqWWNWEpQc7VuOgIBfjvW0wz3MCK1P50cBfLbzNG81weaY1WrcKDl9xvLQWpYfByXbSE/9qXDK7CDZiLG0dkl9sexgnZu9VJaAp5vP82MVJ1tuWKwOmqbhHHksvFwlEfdJcPrIAKAtscd7UUcls5RgJ8Ctjlq0qj5qtk1bkWWX+dcb/wx36N48qNvQPdpnVn8H3dGJFY3MCMgD+YAzoiVDmabzcsQsKUtZxZ0cyccUcskV9KlKF9Xy991DflrJjNqlL4SEYWNoi/3SuW/2rqrHJz90d8wsraN84dQBVKjdUNRjSPOTlTv4Tf8K2Q74+1x5rVUL8BDdqTb6OyPeLAcpBN1TIOr0f5zCwBuSmTYOcK08PRKTfXUXTpCJgZbA7y+lhrutNcDysdicdoOdbL71dkiGgXVmbCg8HdVoCr3/ugZ++NNqO20e+lDc20VtDXav3r0rij38clV5nyJNmhvX9D2bP3/DaQrDbLGEOYipLqsbMBYtD5ynN3hu9tXtfmIIo7nOKIYJdPCm75y85dZ9URN/OjZcE0PebD+Zy3Kqzo1M4MZmyQsXCSR7eFQSHDB2EvmNNMcrXcsnYChBwRSiHFkTFIjldO54P7f6wEt+95NKWTkQJSgGe7mtdO+cq7byLczlx572lX1NI1iWLWUhafoVN9UN5J9iAUDqGJWCmFFgtdJKhjYQe3AkLYh2fmiPHfTklIbn9MxEknuDKNH54f8fpSL97iLE9FnUJx96qslXWEg9jYo9jkXsOKxmPXXArxj3Fbf/CZ1XLqjHMMt9128oWiQRUCLG99SWHkJALWzbp2DA6I42cb1pIGHzcFQrIbSG03ySEJ4x6NX6kAPkUkMpIx/w/zyjYCoPDGcsPFAIgDAZepYAPs3sQ+5Fjy4V6c5Qkoy5ZSj0CwIoO2IyQg4j+z8A/zKtSTc91uOZCgSl0YDJji5WJj4m+ZPaq4ajscM9cK8N4SfDRDnUDuX2gWdcWfTUmb9zAM59ANE1YVb1GjcgF+1CSggYEjSJY5ueUIzc95RuFwrlgagI9U13zsGEIjUmvzDvLM4YIg4aFyA+Y8xbumKA4QMyxpb4PB/go5Q/0eXR3RzEzeLAe7IHcMrBVhcJHyS2p/k6D9fqHQzHZBCjam0xmTNM9NmJeFeEVl4G0JIsZP6k79l0awJc620TgG1AK0m7MH+qDj0dhsWs2kjBP/5hArLDyfck+TZnJUnqhR69NXXHMq5Pa/rsaCfVnUbhxdg6SIFbqEV2KdVLpRYkHaxPdsGJKNyHaQ5CjqLJdzAwElcWdD8lXTjghlxN3wlCG2AMx9WXzo2SBfqiaHJcwDb1YoGK8aLEOcIICa/MBhSvtAA//z42fApugDo4cuZ3qNS1w/R3Ionxm/xrrlwyFLb6f78Zu996QQdzJ9ExFDAPmg4z17MAkRQNerE+W3jXTcXDScW9maBKzAfS2IpnNEzfen3QwxmDYSISwSujahmrLL+odVe0VSX1Y+upNLx6XNlpUfaEbRLMJnMSEtdyqTWwn+v1Hc7mNV0qWacprsdYcgIMil95krSo75qt9rF3a6r1Aq7oMqF1GRrwq108U83T+2iWGKrXCkGwiGbM5ka/6vZXpFH19MOaMbIQQYzsdmH3SJ8yQg1XUo55YwNT3ddUJlvG/Gl3MVyjiK54XIwp5QR7Dogvynh7lAfaNW8rzlB75LBGcXPpqwB3TgQrytrK6VCcC5oifboWpFLvnMpl0k7Ld0pd2WAcK6xI+er0k0gFRvNdmSJbm9cGDKSz4aM/FV8NGjJEIMJcWqiHRtVJtPL9fUFecvf4LHqtiPn8MJqX7S0FLumj5kifhfzTTh5SJR8s0pz4VOtkU71v28wfyWSfvn7urZrnvQ9SgN2689jVdwjg+GqaDNc+XVsCPgVZRLNJuVQea0KMfsnp6nLcEvmaM4SUuFafHnMMi3fDXcJwOWxc8BzfWfrAh3spYZEJWsggs5KUDAsw/lF4IXF10Hc3ynSqy1jsPbYS6Cupp7qsJ8+9guJHsZXCZeQUjnLhp/g+iHYrsq7/va2ds3mopenkWJ5degkP/4u+du3Fc+qSgKL68hrjnG3ukUAH9lOcfKo/9qDCetgSjS1WO8bKd+yMVWe51Iows+WMYE723WN3OCbtMdrCx2M1MUoESquQ62shc/o9c8oxJw0IwvGSEi0zMUJV3MFX5sTAH0dGtJS+gC6r+8WjNK3X94w6k7zINuYsywsvI70JqlMoyeDJSh4J4eHz1J5bmLBQ8PKEaGYlJ7ggKyiYW/k7IRfS6rDjSWJ/nqX3aa6iIJs8+MLdzwbsxnqkA81ztk7SDCU6wRKTtrjxeqre9J2sPcH/V+i4IIytARN8XDFSgMkGkcC7vm35GRgksgvy54+p0S49J6g4QoowQs/d32KGqxvXGWSdHQSqB1JFbFja5u6RCkGq++6CcOjjz0p3xSvX1ZfJciZCuj7llntRwJ4laWQUuDkXEj9YAt4i7SrGX/DeErcZT9feeo3A0knpiIVvI+AlR7XwaKGjybQkKbo7wCK28CUC/x+9kBC6a4Y9LMGZjrfCZBzq/xzhybmrZWw/GKBfQOKdroREMvAHSAbLmDwct9FO6BlfFKg2Sc1j23r+akpgcfa15rE7pivqwM3sTy//BcQ2qG9/hq1lM9CjZz/bZJCOk1SaIT4g5yDcDXSgkgONI9xPBgE/T17V3+QltlbvxRAo5VEmbuvydWS9Ds5pBMsxZe6vKvwgLYlzEBorVV+4Wf6I5doEfMg3WD+NtC2aPJaotWo+uBMgtHmXaJyn/tgGWoHkTltBpD6T5J5G76lVUn6tV/i5e0YDxd8RoBU5bwVAqe4wKR2Uy8jfL76vbHxX1K6kM9hxBj/I6CPwycCxAJG+uIsSIohpf2qBRTg35JgSJr0vLrVIVoBliyZmwoXNbP5LenBZZhDlAJIXEBQqj1QxtKyNq2+OR4W5NyenTdcTd5RjT2pcRobH5QbdhUKS8Pww8XVqap7X812QQQcEsXH0qrr+GQwm0MGqtpDera4AaEVjmwJwWPHttpDXlAXxbVEB0Ng4Ip3D8QznUQB+bTsPyU+E4mGtNitDF+BgbzmXlhTODMrh8lINl+4DdZZ3pjoZadiL5flHARC9JMFfsgOML5A62a5eNVVjJO53tmz9iDBvK60YKbdNM075qajeBHFFT/F/vJ5S71cUI0S3rHO8R0jdNZLBxeALoQAT+4143LRfN2w22Gkg1yIrobItoeS+NVRSwjC8R6elWx3OjKW9Bd+fDYyMvtvnGqSR0NHwykzaJN8jT9Ndijh+fspqS1Hguf/jx1XqH4ZyXmDxRMrSjKpkF5N2xsnt/hSMiz+0okD/Xpi8rGI0OuS0LaECsCjVzCf5EkRpDkU+SM3h5bVPGLetLGY5Ca4tEy45X7/ayD03XXIWt7BjNvBRANsf6D4DigUWOZJz0hvp55CkP9ndry64ZOgeITPSuijnyeIImEmA3kVFJRaFTPiD2EQqRvsz1VzcK5BkYP9g5LO8zh8OzsvApZOnRmEX3VlOk0R2MWtSM8uAcvtPFARnVzrtRxzN62uwylo3Q7l2rVw1fwUT08y+zEcUQXAnz+K69nUNF9riJJKtYxhzxaEUpqp46pflWTM4+dVdgmMXfJlUYyv2RJqlXzxjyw2QGKzxg8mDOQ5G3JYynHQieMsl+ec2QYhALwY+3H08I9tt74B4faxbRrRy/3Y+u7ArK3fIzTRoBESw7a0InFpEplXrJpNtlinXKD2WU4NdI04NQ7bD8ZQs1Tvne0fHYZ5sFjhhKj9aF4kQWvbdviPR2k0ziOaCgMRI0m/A5psBPOOFI4RB3/iLUt8e97RquXFHiylJmcmV3SSf6UMQYrpR0jIAD4gNbRJ+xkK8SLnEU8AfB1cPggz+22Oxn2o9bV0DdsnB/2S1h1i92DiGPkB/Xcd3REvax1n1N8lgG/Nh2LSJg7rtem5BMjTfP9y6bRCerdoF8zBkePcovjCl3OTSzf7kptETg+KXiSy5DTNFCvblVBS6cNR/pf1wIeqFIUQGrNcjcNfxUmivAYbYLfPdWl9JhprEX4tARecsjmJkDIKN6kiWdDegYl9L3QJJDxYEcFOm2Htw1TpWDYVVNBhVU+961tcChNQoVMFzKSqp9IuYYSHGhk/df0Z+ikE5fwok4ksu0kHPVrtwi5lanyTpKOriiiZok/wmeMestr96WCnV5S/xCaISPM2IDFeKMJqFYQb+f2Cq6kWbGl7+3WzcRzlJ9XRIW1fVxX1AkFMMYC1qr3x3+K2pp0ugbeevx+iXXWZyY8TEhmx3G+xtJJT4CC31LjpnMGXFPU+aoE77QX4PDblBapNurdPFqukH/uTIrLV0kfmDQ26SrrMuxfwiRracCBBD8KW4IkpDy4Gk75v/5Hb+S8dLtNNXXCIdzTmwpGamM60W48WvFnDyGZNKQDl2Vt8pBmRfs/RCo+uiEPJ0yJUBGSNT+d6O7jal0+vD6KCNxwL/ILKO2M8cEdVesZ62dS40J3w9cL7j1P4AGVmplH500Z88u+6CiAA8CNhGz+w+WezUKLnhyINq93NDQ3Ei3BBzSAzQLiL0hdMNB35pBq4s+ySudx+suDlkFVW7KiNbGZe+pa7eTlqWBFtwtmwpmqNb5ea1BWguZek8HFyjs8PEbtz0pXSfEdqEMo3j7A1OXt240cZzKlOz7waI2XmDnJByp5CPCkN3Ok7ga8140EPYYhOsVaNHT0WngVUN543PIDZmFze6N2yYtuPMczKPgkHyXTMrxKI4m4zR0lEZv8JvukRUFfTirXjrP+CUfk4o8HgR+5THZLCTszrg3ExMLOn8cBu/XFWSp5UXgsbjdrgT9G39PWc6pqQNvmSpo3zoZeMeOEbzxuYAZTTkdu3M+0hWt5yBUY4lNDfqvIhzyf2EO8La71HeMKxxfKjJFBJtiS8SESGIlBR3yDT2H/7H7s5qanFGZiSsfoJ0D3OwQBFMGagdSQw/hUrEeTLmOWgMnVH19VAa1rFbQVV5QkDn24ShWIYeqOVCZzrLfLIuw7OS0MC534R2NTEZRX8jMZUpFEfhd/Abd/KtKNUw2oRAG4LGqp5RxjJsNh1ZX+RhEjRaVsDB9uJ/7gCWle1SYBEb2a+76p/Dp2JqUvlmdAHrIxntJBCiPm7VFVPz3gwvEaD0QmsReEDEAXnQ5o7Qq1+48DKw42ep4Ci5gzvrOelcghGDL77hO7HcukUeO+LLSYZS/ZJBK6fo2pbeNo9oEYuWYVZ3we1tsDpnbkZutOL6z5e4lr32BN9JTd0jmEY5Wrp/Iu51ZyNP4CH4HMefMXmvbfGpGwTBGcAIJMBY6zsKwQKILfAnxkGOeOEkwA0SiHbYy2wOhzIM5ugZLw8DU8splHkepLcuD1Jn9HDpZvEdf1z3x8xCAprE1Xx6OoWc4bd4JpoYye2IDyqpWcVyDmghU9zMInUZBjv3gwBzjkUQa3BYybnlYx4WO2DsQb1eQCxuwHJAwTwHGSMuDvrRWkx6t17ClFT/CIJ6o0vlTeJvQNCP0Wn/FAoO7lxx/ufPRgF2zZv9ELXlM51KAJjJXywmFMpZ4deimPNhBUmsDm2mPcK6Qstd47A5Devanyx8BUrWQabPJ5DwQ/tPGnI2sgEB+zjJeqEqORS3zRQMJwiNgmzRcbgdQZigMPgSPywDeSScw8uUZXFK2gfgkQB2vyJAp7gFi2MFtoSVDlL4pEQdvxx215jVehvgNmxbr13jtJqKOG8dXGIG3sUdU6YUaVjmGsmb0XS7vO9kM6tSs2C+R0WDWlDiztPGI5ZQglkW24LL/lYOTNO4o8n/oMLn6ewxlD38OLVy2jO2SCRkIaV2Qk7J60/0eH+oZ6XOpuaMLxFt/C6HxKg7Bv+J1w6KbA3KhHENn8WSJ1oM0R3NwW+9boAVHut1hZ2WOgZPS/YgOU57Yx28mHpDyIAdpPGurCE8YBkSzHBfJY5i1ibmfd7ssslyzzJpGm6LpOTOzL34N/oH4t+YIDis4Mf49g4DXDpBLb/Vqf/SPqK+0Pqkcjtc482bgF1xmPZ9L4DnQe83hcg89tItQ2swqcCqBgvWNwZPR7vvanryNqJyacudsPgJsRPi9zFLxxOvUbqnm6iPC6FUcBj+yU508iAmAqZlHC1rzjSTb4xNyD77mQzntQBhkLj8F9z2FpXGqdu0eLPyzaeD9dR/ZHOIMscgVhCQWgk5PsduwhOUwAXZlxTEP5hRCxzB8nXktXY4VKcXoOJNyb9ZTKUwDOdHGLxFywNmTNM/AZdgBypcm6TQChIuEDUnxQFsAkiC2vnKiPu8Lt1cZJPr/KVnS7HenXfe06ixD9Lc1tlYyabyqNUQ1TYpvR/q8oMO/PmZWuc+W1SX+ccmq+1f1NFYn2WeK4Rv0HD7FHnh3ppMSvhfOX1Z2cq+6pMPECSW9Dsoz1Q0um//sZd8xlPKyy/lIU+bT3owR7AEl+nMS87Pk7GnVDPmS4aSCYl1WDCtM/L9AWc6IyVievUcLvNa6fjoGkY7JkpRmAQhG5G2SZEFlr9/dHL68jPHmoHG5BtAarxXNGJcZyX2Mo7Ht7W3mtrZFgxoWIos0RTFbtat8spiiYOVwkzTsZRGVHFW8n5NGZPELiXv0HZ/QyFN1dx2FeFlermyS8xNDIuXAJ61Z3KAPW4q7rd389BZjLuvMIymLfGhgVKAyF++e2FxYiiFjGCiY7Do/spaplY44+iG8WmumIQh+z2nYcVuOnqAcLCDxqHEZXb1GGboI85awqRtIcGJCFDe/PgUCJkqPi+/YxaOcUjyt9WA9Jko48nM+uBKTmtaiEv4SYhOw2z+xu2nanPc2pJTLg+qMNKAn5wPHpyMLhOt5ZfL1yyagi+UBPwXPp6g2RcaFW4a4AlBWTeSaYWHC2eJ6VDWozsj6xSYaYy7HihDnib6HZchNJ+lZPQ6Re5Cbg7Vz9D82pPZTVj/uTansktBmtkHznQ1a7PZclF1m2ewTpw4pNJgm9C6sblzBEqJDHoq48RscBzdY11hVA+nXgcJHpXviS60/lAyGY6ANduk6KxTatoBf7DrZ6kSlIKPkvBkg5Imxyi9hx/kddEI/0vSPh8mFSdcb+kXWnlipae546IMg/rI4E1QExbFhG6f8ztF2U+2qDSN3dqy7s+Ep2XXXfl0x7qhuie3y7PdljfG1mMf0wYwemsUKU7HP1fcuxhkP5zyJ5pYIaGKte/OUUXYZp2Cg6KUxwbVp2eq4A0zLoaj7PeXW4QeDHUbCu5/ZC55k4qd7wqu6Uk8yyXYE4X9oSiEzNIUhgsPBUuWKjEr3g3SS45QC1Lb6eFm+KdMulbqAHfrYL03enhIkA4LU4xPtuqvNvtXT3gbuQ4u/ycK/90Uwp5nqWxyT1YZFr6LPQLogL99fiR5+6OhTTUCe3wi0ayDRxt+WhrJDwcQs3Y7PXJkb5Usqpu3PR/jz3DD79Wn2VPKYSYgXgzPy2mXK5UaJYdmJoXyrwlt7qBNq0+6Na1KmfHwwgk1OeU+NGQIMvrx1lNH1un/SoAzq5rixT7pqVzm1bYsK0L85yPwZ2QBdXG0Zns6o2WEIrx5iAgKeJOb5IqtiFnPKgBWEK2wycptyUDOX1jHcTCZ8PwzjtKHmjh8+V8URF1xiiETvLm+PcpEN+gLxAj9FXJg1MS2bORfVplnAHKEmnXGQTRHlhFTviSVKYoQJojr7DgIlESVbN0z0eoMgk8CmmamUNaZZ3g+X6wHrpSz3ncb5b+Z+9ARG8fWxRoyc3agmE4YrkUgfAVYhxxJoFb6TAD+yp+I7/i6dmU5r1EsDzUC1Pi0Vz6eDE0INR30XL08XfoHWme/f9CweZx+R05K6b4+74P9XAMXZSOTJLmxidtqUnjQiZwhs/fiv1VS9mBwknLeJ5nQ9nu7imxxR1eDJDi2VgiTgkUlZr/ih3yt5LHiTpO9h2H4IS0MRp/D4DlG6sFbdZKQXdN4pvA5RZlgm/VSREonr9x5XV8TY2OJRcnLKVxB2Zs1BbHSpcySdEdR1s624cmHJufU3DQWda3blkq8Sz91jJ//kktC93H2gA+HGgPNLyPlM0hD4KP9BiMDFxXEqHgqcvWJKqpMeH/+Z7n9HLkO5unVBFpwRFbQmV7qqLX9X3sGxZEcZO9rwGxoZ0J8hKbqZzCCD7wb7MMOWAKk9ZMK24BxvFk3lwr++kOKhZeWwUvU2QM1/yDgXGG6J3hS9QDQPh1VRaI2tfZ+2CwbW1LNXEtjleQRMdhWI0RjIj2XIZLtgA8bQNGUQ+k0UIQQsOovxPHH5+nc2NiSMExNBrH7fqboKN98xfiZHH+StXIPyF6r51I7Wq2Z+awEEuHlsO38YzL6/DEtZDEFvLkKoIObUsBXpmPSPlg6GSWFwLBDdyIOucNElj9dstA6L89FbZaqozqEu8vYvAYRx2/xXzlTatN4BM911XpcM7gjfMLBSalLawyQBKBj4ktmUtc01x6v934q6/A/dI1Htt7CVXTdPTh0C7QlJlCKJH/qh7c/LsgS82Yh9EzgsaSt7wpVQznPSJrI3qtctpZbZBRMEi1Zq9T1zJv0e6ukl6ckbIEouEADbroe18ugWFUbKQJfYXGLIqs3axKh1ghLhhyWcUX5BcvNZ4B6H5MOM2VON5xzxZaKZXNBbdYlnq6YJon/Zzlin4djKZOl4gcakU7z+HAXKSIlnV83t2U1s72n6igGWX3CZRO8+Ao0cv4YqHvmB+U+FA2BCXfkbqYgOpYlWcQQcje6yZToyYLw9zGHBGYCkA2IWLzCAFqYpRoOcX/vVODjpwmlVYUnr3FXJajqCqCqEbS5yUBszLAmFY8QEkjGq4fUqVYPgFolw5o4tMQRgUHFtXkKiE6M1TifYDfmFYpDl4pwS/85XWJXiONEFYlCFPuxYJcMnfidm5JNNA2DLDVw04xYZQh2XsX9lUIC6beEBE5KNiLsrHbys8iM6QZnlYnzjHu2N4DBn+9ohunIXGYJAxlc25Ri8tZvr1hEN8nhD2Sm/Aap4SteFI08J7A31vvyBriqhUv9Taivzy2vVRMHj0frRynxZzu51TRzziRmbV0cR2kz3QNSqA/0mn/y+2iIM3Af7pBRVJBCUB3h/WGRL761MIJbSicWo9aBhjS0acm5ZX2l0QHKFhb13HUwJ2b7WAi83njVCWQoL74VC3JTiip/X5odHKsJyDn+bbrlmmxqNnnfvTe08MIIx+iIE6FJWrSknm7Ru+yJGFOieHW26R4h1cqG7gTz9n0GJs3EJ/XoxeGGEdtQ1LMO1yfLgrIfsnKpqyfPIh/M9muNX7ipbFuE2v/nWJKlB+ijyMJHKJ1pg2QI1zLS6EanKLaVWXYk7CZWj3So9oS6rm2KNCDYJfHLDmZYfSy/u/Ga93aXCz9WwvSguKl72w3Rwy6xsRADgIaLbKD9cXGF5cpAOz1Ic4iWTo2suaNyurYvah1K8i7qI6JpJpuYF27wBcP30Wn+bE3Vl79UZ/t8gxxjjvihxrrY0sBebOsZDg+GM2pyzPkAwKQ8wGkvqHdOfzE2ipEZoCKb+biihc6ZO7CmzypFdx+1wLC8xRiaVM9JTR/zOFLmnJJXV9HhF8VnbXSERFY3wp2YMP+saU4gggo/5LppJnA7OdfJBAEOY/yhJbkoDkNZ5QlOBkozHf53PtlOA4Lx4EovCOdc7Z5HOBiTl3AlKSSlAyvpDfS5g0UQWcgG8OCIcehbjdrL80S7Am273326OA4C7gF+UL14tFuX7I5GNTMxiJp03A/2gdIhlip2f6Njo28E0gSpMuteUidoqAyStoqg2K+Va+WvLl6XRTknRwKHHIVXY6V2bvJJIgbN5NLgVUoAfINiZ4zCInsEbZWmT0XNcAJKdfN27dgsViggeSEN92jW3Knh5LoaQsSOkL6lJnfRc6lLADlcgY8g7jvCo95t+SQ9ORJ+Za21NZAvXNTgYFHfYkzDpb5QOJATU7bkIuR/OmrC+1LI6mY+UBk2TZHqB8q7WdWOIJcRuO5W+gu/UwtwlFKIZopzZL9qE/TiYaRD6LVGlxKNWUWTO0aWiEWIi/ORPcOL3kImq+AARbFwUIkggNSMch2NH7JbXVGe/2Rp5F6Q4QNeWyg0uISar3zR2aHYu2iVIZOHTg3ov6ZUR8/U8ISGes+nmQtjg0+sAF9hMwL9gA0fdtVSpr+FzLaU9pYW4IqBttO2wwwthwViwu4/88ewSmCf2yzKraiqT/nprXtzNidRj33Eu60FBIPX6zISt0jSQmoK9eAM9qv6Fa3kSYXrm7g1MCWZc580IfuLr17aMhdPutGluZbNE6vsVU92hNT7iZpJxQ3qw2bd8xwNKo97pABF9vo6KC1D3PTQ9RvNmkXTod0qyWyFQj7b2O9AxgXKZC23KxhWS8p7OkEmNtccBeXiBYEopQKVBPFbeyUwwoG0NGnqehkd+oWUJAngxGY4usN30v/J4TKvQGrCkwR2+sLiUAs8+EFbDMlsYBNQ5mnIUS4Ft5eMNN6AAu/gHm8xBB7Vl4U09kaqVwVf8LeP7NjorTjAkxNWsaXoSFQHh9i8i2hy9F9mJfLp28RYeHwRi3nXH4DzqavPtdaJWh543rrJlcA0W5LtoPWFWTY2XJfO2dT6hIR5eQQPpn0VO6eEhiRTI0vW1loxGuHzFGvxtIMjHaV8TpPtO5GI93p/+Lr2kqbXWQPY024p/mTK7ZMkI/rwRDDbGq7aQqtqhVE/cGlhM2o4QkvSrQIjpIi701AGuZZDuzsy+jZLu/SeIpLaeKW1SPaPCxB9OGnxIerRFSaLYCzBZsortO/X6utnlUrwyOij5dy0zxDYJJ1TsT9CmrPav5MvrohYsvd1gB84B+9Od8gzd7QvEC3kauIxg5WGWnhWbHOCplzoncyXi1gsJA+To3XQGuM0XnjKnjGDVwabi+zQVXn10mj0rxI2zbnZnIPAPFseXUTlaUsPMdVuYAORQdzT70LPN02JvgPwETQYbIIQnuKqBMCz6E9Kv2LDM3kVZryMy7DZnHFq8E+mRSbxeoqF9q+20wLqD+iPDNazNyYjg9jq/8g8VPPEyovXYdEcfHGnn7kq/YvSHMjNssclPDKk0ZHHJv1L3iOgMJuh250zSq1ormSUj7xWWLOV9QYp61So0DRfQ3L+SqLVyqW8XwhQ6VfCPLJ0LcczDBeFJ6K/XH5wCDWtRMlQP/Vo/YQ3U4Ei1CNtlIOQI+pEP5wxIdiZE/ZiO/9kINgDajmL1SGXpGjpR0mDclCVJTGSaDjE9/syUOyeQSMMUoJ7if5S0+ICq1+dqfHgC8ouPjeK8uDqHBmAgPZoev/E60EmzzkWo1rNFH9xDFkprlqm+OGQQL/OPUVZkATElZHJYkW5SFxWD53s2U/Rc7fU/yNOWpiX9ovVUz1tBC9WYjQLk8A7PxVH0s1DmnrYKyr+PNDIrYrU3DKWxrff/OqgdYR8aeKlBDU26zzZ7cUusHoDVjH5CD9LNo0kKx11uPAwBHrk6jK880Tw7yPdWrAPaFb2F/TJfh9944cc0nvEGKMBYQ3ewTiHiQmjmqsC0FYUAVaEAIYUs2KLADQPd9GMPVgMLfDoItjHs1lGNwvW2B7+IHc1sN82Nnm+5S9cQ6d8+PDE/jH9wnc7CD8Jzo/q/NyTm7Cu1hLaoRx70+/lQOjeYCddNEMaWOXNoMnF1hLapdaov+DK+/RctCesreAvxnn6uHUieCvMvC/lzztwVjijmnqprdDATGIyUtF8CxEOkvBz1HknVFy2dveSWIRFpxF+4n5tHVvaCCZeVvERKV82SyckGVuV4fAcDoz0kHdCYQDnvL96xEILGUcJsMOlCl26x4nzGtNBOTkxv5R6ZtLChWkqw4C9B/3BrbgNO7Fd88VRjWApbd/v+H5qZTvSgyJWWUyG4xznAc/Df/u55LYL750ej/XOsP2R0Dmg8Bp2bo1LITsqomK8wX97dVVzvSQ8jN5V3n9YhK7U4hkjlNtFDrXFBKZ4TSNGEQdppG1hNVJdUcpVrEk+zfgRl63NV5WWUj56Uahu0m30U7mxiFh83Nj6O8bOHAQ2bOO0a2VTMl4S+OYEPfRIz1G8pYSsstrtskC22hrl0y/QePc68uGVftV+GCwNE8JQA42Bk6DuaPMDxQGCw9x/izuYn/qf4AvtblsXiV5tXhBAyjcjn1ajqUqU7MBnmZnB0kPHeXGwtxZfFw89z93TPZfdRKDA64miE/JO2E45nCfeT6KyatlAJ5E1Ou5IBWiT8KGwl9nwjzzOPFK2OAPPmzQOUEi8eAp3RGRZhHqwbGzOW2NENeRTLgaaIKLEjJCVhEAcXKNXy7gxs/tbOFSEwB6blmUyAaDhzIrzMRAI3KQ9sYeH21XPOMns+NX0j4LBmZge9FvjBLRhkuniFot5yjmw3gSHjK9HGz4p5Mqd2k8+4trqeXItNgelNo4G8/junPMmHO+V9UKSYxf6fJXLi2MKhGP96U4rSdRHMReVMwqwQXbROiJQ9BaJqFyKBxXrkxfMYT9W8iaWMeN8Dq/2Q1NRO3P6bywhID/tUVAm5JkbqYHxPvjypwQ+F6fmwR55dtvBE+PFGm0lemGzUz1QHkBfGcOUDxVYku/tQSrjGJTF04Ho5YleVibPxBDDz5wriIq52s6VZgz3ouF0fbE1EIzRLlvceWoVxqRgRWQ3qOqdNYsZN4iP6b4AXpAzoHlAYhlYzpoifXjU+OvBagKgnOi009eJk1BbSuvCaOZ7lzaEYdSd8ft1YxP/XCFQCltrNS13JokUlY4d71E/ugxe7aYSHZW8UU79uS+FK2p79v6l0IF/L5N/OPRwd5uCcx0/MGjd2wn4FYsnaQUKAAtuSvy71C1NBLNPmj+cwzrSI8bwTBvnJSncKmz+J/J+p2e05Eog5cWfTJW1DURnpnYaOx9Dtv3Hx/fyj3ztdyUfN0HCW9xVgT5wkUgwQLaxA0xPFIOSlDM1Ms3Yp56tUP5uwVxypV1LcsSuJK7rFR3Uz5vmf3sZzVIyaIDp5tjaGG7F6JuRn60qCUy2gdPPiOptylUAf/yi177s3TDow/dMGr2plpHasZivDyersN8sGk90zdBCxpEXjWOkfDA4e33lpssa9PPssbhQOh737qARpswsmoSXWOkGkca5SA7gAoK5Ry36xSbq1XetxuFEql2rWo2XZQQn1ya/cY3CD/8bdXrf9TIF3DT82fcaWz30sO1pa6DThtK3Jm/rLbwIUllxH60mCMeLC7PczMo6LwwVjMyfY4klQOB1aTSZr2fwEm3jaDzU1wXQ9nOiyBATCgYer8VrNCmEa68ILXeaRGWIrEuXD4PzU/l7PXnHPP56unnnLShXJTf8je1NXeVSjchRY08qpZ9fUXWJ9lE+TKIIJBEi7tEzP6qpitvp8rSL6gDo8p3gOt4V+Tkku6epywxbFLY01DYrkqe2pqZMnkdpFwN1GhryigWkAhTX7S/fJzVNV8IuSolyqflj0HlDfoN3pbGEhDzm6TTTjis6QB42H5fGo8ItgGUO4jWtaE9Trsn9OxVxMt0++iZezYlzepJBidE+GiTDcplBaRlqgxI0OHYKk5VmgNvaMC+K+8RlpEb+wmdesmfhz+fcfc6ldNuF/RZBfR9l1eUcMRji+XIGRxrhVAENeLojb4wGamZ8AFtzK01eynNItmlYe4/bAse3iwdzgmPGyLmw/x0UyGP8yQK25yxYvdo/d+vfnm3MwsPm8BV5ctQ8bEntHZSFtgIosV5U6zo9+maNJV4cQAluE/LMz+iBvPmbzI942CJCab8gCSer5eVCRqMl/DBeqyudlclDBYGogE2U2iWjuTE9pyXP1RfxzzctDiV947hFMUswJyCjQcm0562Jv/Ib7xL72/gXPxQfSzb2JudbDJvbURO3Aztk8+ef2CEmlPBjRSLnBhIM+Euexkbn+v4B7CB4IcRDa3ZczmUUS6SL6DPhE/6nR8iFxnh6lkdbwIJTjJ9cu7LKJoz/SWmCLREIh0QxbI6E8vyMofriYxUXNnNaxqYr0+5KFSFPd5Ee2/ULUQbd/akxwqXBGBt//LN9Je9szcA8exN6d6cqvE7rSB9qQQgBQRzngs3tig/ZksKSDxF2dy6I2aD1v0d9Kc1av2h6TiUklQpy71T+1pLAiE0T8V3RT6lmMZ6nOqSpOa5GRvZ92bMfQrXZeVKUJSjeh+AIgXdWcTOK2kW14Y/NYZKKaCttcnLsdZ8INpVK1Hsh7RgyERzjit1tKblDNG/znsFvMQzWJjOwPkJR0osQ3IvRlluvX/fdYIQU+wWgQfM4TgUbwLs2ZE/OBPbeaSzhsE4PPvpsRkX2JiaoR37gILm8AmBHNdQNKQ7Jc6Tt72fzn+U5yo2xo4YWM2B5zZ6MvPkJVJuyUJ3LTyAsFlqLKvsKXzQnlbI5skh3reOBtlstAOIzVYpouf86Wyki3+WJRROaPlPGk//YgipfEmBQXmO6S9DNYJ9xdUcChSe073lmzzBHkiO+ejZQXO4jPNSp66phJbjG3dhZPXQQaN7WptFtp00fgrNcWmVmeeDaD9yqFOLb1QZBd0ghFBUGKvGgiDMyVUI5NqvYhybQwX9AhmtVsfBD6O+FuXBrpsTD+nprCHYvgGuw2mvbn8J3vFKS4qTXpcaX030nn8BqwcF+/suU4qqExQ+sKNMCGfMlPvOWM8aB852YlFlY5fSMUh/DeNZvMTZAWQ6U41XT6syJtqA59hpBr501U+t4nsQ+kIW9vmmL2OHN9isPVTLFjWiktMGhVdl5agST5lnfnn0jYgrKIPVP4CxmP4NPTykzQLywa8vHI35OS+jIMM0Axus3hVkY+ggYEjATHiU3WPUSoYswb6EpBK63nPig8GJnL9XCs5Q5k0PUA0jyZafX4fFFaIdNtEjr7lx9zSoci6kSjrEMG0svTiQCKqeNpAllOpC0SnSQnZ3UpocvInKi45FJESOSFhEoDXhXoIjrORf6Y/cD8TlvkVaEtdSJVZrFThNG3UqUBhm69aJ/2K5XrW2ektCYD3CwtaMFKd/KN16v3HB/MNEiCGoop5/UKvcPKapB6SMur6Wn7zeCMWImjZ9dFBPbTQckpV8lDOlu6dcI8SpRqj3VXkavzIiXqBrnVpetB15noLGvhFGWQuyAMDTkPY0+u7G2H9rxmhQytI+QOxjMq91zzDYFA1B7r3+H9uuJ67twhndimAbtL+rVbQystMKgr5u19JGVqHijcZeSJd9GpQLRSbhhWO1qzWaANXvCZGiZ37TgkQXgo7Dw/mU4GUXwCP6GayA2rP3I8N5sYQXJeNNRfhqBXWsA0eV6l5zcbXwyusr/BKApfXug4MLupvZ3MxOG0ZrCh8F6ypELAazs4WqrsC6Xyn4uoq3DLN44ba423Yyk+r8wnYprPrpZV1wuKAoY1b5AiyQ9iN1xnKWW7m5tRu54SDNCLr67HMuZYYSPeXCwyQDZfHgb5Uey0BP0o+eJBEglO8H5XqMjkRXi1gh+11w4NiADuFuB2vNOtYUdt2BmJI9h34hl3VRQ1whncsAdl7dY447576I8DjcsZDQirz1mqwwpPaqgR3Ocu9jUEVfBJaYR0DKc4sE1WwQsWitmH2iA+vDxejxS0bcIMH65H1Xp2i9QZtCNN2vqyoajVyLXZ0iPhbUESPObUNMr1Oq77YLjKUp9OqQc5lfDE4qyxzkQaJwnKl/RV/co7eMi1UniXBOARtSI1kLi+M4ArYhFyMtqNBValoSV3g3Srom7ninCfCrURYhPJJzE5yKS6FZz8qcNmDMg4lxifKWt2+TOLAcFRlCAnR6RQtpa5kfwhLeEQRTc5o2aA8Tznpbqoif8VFGbe51/Lg+VCD1NEmsTgutROhRyYqxiDT7HfuTL54MSnPPhFc81rrD7IYBL5FW5YY3gLUH6YPh2EneLFe1bmS9RsdlTO3eZ0u7MGw4xIAlMlSktOkzO0k51yYYQg2uch9SJzkbln5AbzfJGZ7eUs/r9m60mP0iMdQ4b0IdqpDguyKFj7IJA6xkg/jTizBvQfQFhLuKgB7si6vxTjBKx6jNmIdTkQyXfiZjf2WGi11+HbsTdDpMrQIMR9detSVVzCf5oYuZMUGh3RFtuLpeLkmz4ykq53mQVQUCAI4AJA4ji4w9R2mbjin827vGjoi/MGW/CPZjFgtNob5EhEsSRAuSfV7IXlHqSkTTLwHYKvy1j5DcImlcVVMNx7yot4yHHzDg81pr+6HAX3LHD/IzXsM6LbyNcbFfcmkC/i3Zb5V5dZTDx5Z+qNltlg8/t1gJrNjQ+Vxj63kijohQ4WBo5yZ3e03Gd+dr9458Rfx6gJYW8msxmNiu+CceaBH8IAbm3bnh8kMPWTy8C8CSQb6XL+WqGIwBD4N5E7afkEuaHtvuwfIXgzBf/wOh8Q4Rkke7RfQLrS8msx0g5gWp1Hwo86pKSImNu52pxIWsxdXFuPy5DwHrm6OFG0Mvms1/VqdKDJY977DKJk9t0oC57vlAGndoXoscE4CGi2deN279SUuzlMw7z1+avDVG4Btp77bTnLnSVpcyNUCj0pdVG3Ixy71FM0uSHUzGbQw55fKrCm+f/zzDGVPSS9gUfE71x2+etEmTEEqoFXNGpHHUa8eOMbisy1m4YKZgWq8/Tt7FuJtzXk86szU1k/8kFuk0LsNZJOsznXYOWQhtOFyUlsf3ekT1n13l/xpDXWeMXySoUY2zstRialfysVZn+CEkBR3WT//TAgWjYtfX2X1YGLUAIrR2mH7+kAguaLLls+QeST0oBKJ42eIVwYNo73JODEGywHkj13zLNSB7hpNJV/qu3kTmKQTAaUqsjKk4nDKonfhw1EE8BpG82c6Dkc6riMWwSUsX/ilxU4b0EFWlkrON8P2kLEGUTfwLxgaQZhgFXbNC/pAOmwNND9wWG8d55rLdeF7c7hRVgO+vgf4YpMHaXYhIkHUefadYje5IiKQpRdlFfQbwxKzt+aLRZHGmrpAkN0ZwPOPmkF4qnEa/0rDYh3OdKtbLKA0t8ZIG4qCiS9GOrTJOuLnkCoAj90ljVKldLLFwnqL+OHI/KspVVs8aH1ASAip1Ea7T4gmc8cLW0hGCiRcQKGSDPitE1FMryndEWIl9i6+0ujCTtXjF1bgHHWubVtMTvER8rwqvPfOIdU6pQsNYZdRFoYPBFpkRLomVBbOhfnI8PfbWd8IV6FWJhuoiwSi6JZ9PpLtXQCxgXuqJ8Uintj+b4qx7zkwOSaOSkzUMo2JOiCMqjpOLSnm8HVdhve6AQ/6qCfZLeGeN43OTa2MYV5uPt1LNSKWSDRof971wEAXgKi6euRMTGA2WBeNCTX9aXAE9vnkvkybISE/94qU4H2jklK89R/4PK7ZcThiTXzpXOrlQ5p+IS/C2KSoFTzBho0CUwPMMvsvzJhJQbAafAceiZ2XRkK3vuROme6xFVRRDzjt9mMz2+w2whsJ/coQi+cCsKBn4uH3pz0pxyVVz6TtoktJVaivurXafaYxoDdSbBPbKvly3jinvjQZDfq9by/A5zTMqirBj2Y/mYMJI/uuzzNeaPf1WyIWseCJwF1Fh6LjPrf2jp32nF8LxcLpagpvzD/pLy1YoRaI7D0fidTi4iIE/RbEjQS3haEuJJSP9VDidm8JQ50Do6Hhkynp/LJok+OLZicI0+gBqBbRgS9g+zMBIMCX7OpHi2KyXnOmigatRqR1qPJaOofmXAOI3ty5NeKaJlVvaVw0ugzrwPSnxu1kZuvMrGvy0yyUF+frEwq6HfOawQDPF/7vor/lM7QUPI9XKPXlXJoH30oBaVsguxJ9Ro4fRR1nXGTi8jQMYPUGpBD++XyWRvHGwIdy3mgNh26er8C1LPgfpiagrEw92s/RbLQxATNTJQMBQEoayvzvJgyfeyVgAblcE8qT2sL+TSp3RcsJoZVksbLoSnjaN/xqVwdXfvGt+5ksJNUy0O8bjEuUIkDvtgi7yNpnhCO/+Gj1Fxlzx8BQELPiM4AziSY/r6UFoiS4+HgVMzUTrM/AGVijDomP0yo1hA1cuWnhjId5J/EWulbnl5r6pddjJL9he4/Z6i3G0oLroEM4O867jVvbVFADuGEtEpZ9LoSkXKsHsH1RttPpgMOvuOkP+vie9+lQqhPlEhS7lcqyq9NxlAyTZIGvXTT7l2LW8VEaMjuxhF3d5DPTcZbOJHQDGPX/VsZUUeTzzBrB0S9+m3AaU91AS3kCyGvWMjrqpqFMdb7ldqfXhvW7aw/YEeu0mTE2wF2ZX1p5PlCi4SKWpVQIsyis/0ukx/9sALsfDUnZ+wCJEIfE1uv+uvOnmxhDc2wkWgWVvu4UmKujQepemptDCpR0xbQFxKGfiQoZy8zmHNQxHXYu44AUvpeKXAVsjZ0OB9A5LixyRgCd+0cWcC/erqfheybWKJyywcYWcmFgStHJRoelxRjjOs3MbCYBP96rVRUv06V+03eShstr0hOsnLosQ4VSvHofWotv0N5Xco1p8ktmmI8EiPf/HVKgSCMFkmTz4mNqotw2yn3JOYzjPpWCXYIK05CpDcaCbgfN7+MWphGxrUgkB0k86ev7+Ba4pRHgVET8PaUJR0AwPO5Hygrvyor03xyZMxvs91KvsZiLLhSf7RsPNyV0FoZ9q//oNpklR8s1yO+zcHoJPY1eM5WHYj/R0j8d3x7804m4kRjziOKqTa9wet2WPZ/Hp2KPyUlHzQXOFhUxmEJxNouSXCShBTTHGrfmlg8YGHgryOXtGVIUb0tKW7v6txAz03o+f3aGU9x9THlR9Ciqkm9InmfIkNdlNG/h/AuWp027laFpmbLfDTfWDUbJ6iqwM65fwsJ3LY+n/zJLuknlyT8k06DoTy4ZXWZYb4mu7Z3UiciM4gG7unVI2yaKhj0gTin7CtuCyoqkLAIR0Q3w2+xmwg6hYYXByT4mUlCe/2PUkdevzJS09VcrN3+KpOBTkyaNb6I7ZDMgJdb68xGuHCRPm1WtjNShHIZNAVJZe0LZu6+roFggw9+/aCcqGhvQLzJzSgTurlLZnYPFyBMG/G6i3TwSIGiRsd6VWNNIfoUpxO1CLal/2VXVXtl8/4mEme/qxv+PVWR1+pyfDeZjwhVP33KUPA96AMCxCriYcedbld4RB7kh17FFAGL6ptej/lbAyu9Es09fuFMy+DdeFuYB3yUVy4P5BpaGsSz3MwqzdxPVKv3v0y+q6TBz4tJHPuCAhQomxVa0NSeQoa7KERap4rY1xEGDrryEL/5dBNA8aBE/pCgOuZfrN00ouqg6nY37zqKuyhD/0EQFdKmzvRegriGKhwUhnMB3ovigUZVQgs0izotEzqE73B1i3rvl/oustVweENCHkjh38J2KOCuBlAjrO6tzoWa1rIZuB7N8YOJfrLFuKnh2qUEaR/pqIF0qy7rJqa/LA3WCfZlaYgr4kfcLodVyPO7spxGpBkvD/kkyKxhJAf8rXKszVwJfgTUWLkH6K+RSyEHlwNPBWVk4du5DSLF72G6nGanYy7cMKggf7mM6lZ1d14S/zRHu6Vx6K5ND13m3etPdRPb05/iO5KVNTu0us3aDNamX4NJF34oOY2lbZrLuGhkvVwlweAyUJvG7G3Yhmz4PAHlEAS72tiCiFuF/m+WFX5pGuc6p3K2KtO68Zp2KPw8RsNo03lZOLHMwIvH1CW34NBFkoB4PrwNLBgU6K+h8khBXRrGvGYM5PZipj9WPt+l1kl9j3fSTOTqSIO6TimiiQCNj9Y7gV18Exf7sTgx6ipPXlAiXNRAhATfoEwzi8LkWs3+gGvnRwEGJgYNE/kdmAE4ee5OkNAsfHRZvOlFL3V9KPW5bEYBNe2NlOXcYlRuaDz/zgeQy0hWOpRdBLXTMFoChjQ2wHdt9R6eV+EVOU4h2Guojdt/JNowx/tXW2VrO+/jSUvOWtXI1PRTs0TGFoEJIoyL5qDOgXrzDGkVoqpS2xSGfBCCNsTa6GbYkFmdVpSc9YKbK2hBDzOZkqH2GYC3Qor4TYhZyGP1KpyncHE55YzUVdPBtmHkOkp+OuZ7HVt/ehuYHGBr7p6dJ9tN1mrCApJaVuBOAgdjtmAXYbihEvg3npghQ9zbn9O5TOeRNGAYrJ40O06F/OTZnaNhbXgLpor7R7j0fthlHIHDP+IG0wmNlcppISEDC9u+L/JESi+58DAbylR/qWnyTrRV3P4tUfT3tH2EpnBwu4/237hETpJeEpLufj+Z89ri9f2+BLBuSytXXdrBbIDDXJXzjHYV4z3wfJqj5QNuQIC38AJcWul2czXAVWQKjOiiL9TJySzE/wgURAPDVenlkHnPeSOreYvHYzU8bOjHyETLIC4nLau45CH06KRuc3qQdHGYgXXIvB8gybEHczhnUZAY/NX6snODyavrphft3KEtknQhgIFBpFTRXR18xABI1+woxt9p9GcDCSUTvnWiDss46UV+sBBS4+TlhJU5ey7VO2CZ7a2HtmILL6fGT/WM10HArJiqvRrI05z13ioJFqHhb448hgVKmz3yXhyt85UhK5fcojOQDPj42iImYsPaGPk7AUab5KpoHYeSwWtn/5R73t0WaUwvBRM5UG2cqznVD4KJ5vdwvB+dUsL/+D4txgTcKpW4uXDQXqljO+tM0tP7x8v2YuG3BagqIkHPBfrvdgERph+/cQCkiTTQEItbNEGzto8kLPWOHvxk7NuervP2em4LUZgi1cp2opgnuYUcHFOYoMt4/Xo/Wq5l8sD0zouZKDEsLdPO85usuRKPReaujpcl3Ak5rpH78uf2g5o33rR5i0W2AtnDKNIY2K0n2V4nSphQmU+TkfyeUXvaKPhzj3PHI02gg0uaunBVGvBk6SiCAHHTIEHYURv2Ua/HRcUkOBmDkwhbqF4X8kUP9tFVKHLk6iFDl2nSVi3SafZLQrAN0mBA5hT/XXCnfTwTn5JceYu9RzPlbhyVUocCX4nxR1HiRegCSVvlWGfJqm6qulom7K9fKldsxnsmec6OYKGfXZOYlRoGPiQX3JOmzCCt/Lj4pw0fesNRrLRhPVH/zLpp3dRjZ168B+j127jv4cAHwIpEFcGDd61rBkGXq4/wLlNTYnLJNILK2hJ9QndLkbXNaBPNJlF9vXSezCPkD6/22GALcnV05S1PG5ZPDqd07V5ZHo7Z8yI7ujOwDVdLGp6A01NH106uZBnLwJl1172CbGfecLxLr2lufQPwtTI+6YzsvXfRuHWsg5LE1sr7G/yhw4zgOiKjIadD1As4SfQowx/+eZMFEYHoIrCMHQECNcWFOuN9c4bTVs/M8avib74xy3j+m/DYYeeSdzU4a2NhAV1l33WBkjn/AvuRTAHd/GDFUKWv7ahTJUzg94F5QjaHWJqrQUvREoxkDOmnXOYwUCs0egOWn2HJrWzJ3FEisesRqMEfXlbw9+hIcfTofgOKffUcKHEwXD7XphSnhTG6VXBLpRpW6zjcMVKD5jvQRXstnC35fum8zuC9ySea5curoo6YtxByev21H2H6WToYeK7MzXzbsXCYIdKjbFfZBYEufRxThL3VJQGPsdZSwkPC53uHPtqwwEPZ7UtYnoZhniZ7BJFwSl7DK/RU5VgL3N95Xjoh83f8rvqXEgm1TFbfBib+tCV0fvzMAWHsnlu74+99roxF8f58mOeFHt6EK8yel7wF48shHB0cM/CDHDpvVEfda6NylRLmP+QmTvMPeHjTLV6OSwaeoMXdx+2glmz7Qi1QVcBWMO0jwDjyaZnkpiPF0UxX/jzivl8IYp2CHRACnLd81VBWoEX4LgNUt+FRYH5wrXnGm6tkuzQ+ACD/L2TcYgCTJkGDBsFaPUoI4VSyHqZKtbDeMiy/FHLdjExJZEFrKaUwF+TBjx9FCKskMNoUdo8NkBnoRK3QdqBsJmcnjZ2c+J8wPiwA0C6IrH5F3DwAvx61UTIfADmuy7yyc8CVzNMPGvg38qdtQGLkvRVsZLEIUUSbkp4bOTnumWOMpZ2imSm4V/EjOne5eMf4t0i32pkNN+Qs2i1R8q+TGuOayM9H0xxW8WqMClHzwa7cZmXR4SZX5SJk7Tl6sTQPPFuC4l5SUMUjFeLKxvPwbLPje1q0jHcbf3EeDMzN/UhSc/Scvthg9r/3dgm0SmMrteHgyTbCquyJcMBvo7T5OiC8p/EWo4APvyyYJuvxL17zURwtV9SNsrQ2lVdegiisX0NxeHQ5+DbfjYHVHsnEvga0J1DsCYn9cJ8mTBqN/cx3K9FI8hvQwbBs0fz1S70UJ7hEMWjzjWb2c2wK4EgxQaVfescn2qqWGACcI11QYjQH3G2k5rchG85hHZfkaJcCsPs5S1SHAX9HtaJU3MQ5984OFd9qdRQi+lIYFstitWDeoHor4xZsHl9xydkRtcsDD+V9l+nzWjoP37WgK870pnOwDxlHE431ylbJYRsMqMevwWgXmLJQ5x57wAJA9zU0RyHLIBAbg2LwUkzMeT2GiFMID1UggnqCRu7k3SMrEHGknfjqdx1qxo+gPgun314kO6PU7PH0mTLFfMNYtkPwKLl+Ags5OQERr6n2mef+ekg7Ec4KkvhwDuaPDU9tc/XJWOaQ1O5kcIIf2zNQi8aVlitUc5k2mowyu/UdCrDfXG/lgdHC+J8PSIva3Il1rvbMTJ5TzduB1cZMslVjJClkfB244VllF4di3r31PG/vM0dgeFHfcyDfEVpfjbdidJY2ocCMIb7S9nQ0cU+4seLTi/dMj+Bqa9bb810DHcXu7R5YwDw8FRXxNVtBMdOOvUHUteDRQwOX2YixNDQpg/BJFzxfZSypDiJecR8LWpRful+ImIHPvRSe+S1jtJTZQRQzlmYnRup9JH1ElCedvYt8XBDrLXF+X/bc4RjR18jPVOqXNbhPVbJrKcr4w8zxWfN1UZZkDWF5pcYDY8bhHYQ8V6zyCDeF3O7j7sAxEvhmsM6Ee7/j6mjJ5EuSENpd2oSDQZzjGhNrs3Bn8xNH/YPZo4gH8fAWGoeMth2hGmDTDozmPYycJ0maK9fgVX1EF4ljIzS6joBLy80A1PRsu0U/1Wal8xW4ucQ0ZJuvRB0SMDMNHO7RebKhEzxxmEGl/fx2LwZJ0pTC++mKPxCtpvL16h3uReoOlRLkagbC685K8PRamEhWUEBTDxRx4gNOwxFloZI/Mi4EU3XM7yFvOxRoIbb4tSuASxiLXqQVrqw8eGU39i7enChyOr88oo7AzK/btsNW5IaBhgInDscS1YcoWU/TDyVuTI3nQWPQqTzpWBqUbtACguEUkiMz+We6oZmpZ+gNL2viEqgfUebNACKNoHHFzseuCner6VeZF6lAenSgeRpLoEIw/BCvJQMzlw56ngRy45yBsEBdNzQSt/qNKAE2kgtq6eGAJyHtO9Do8x9UyoJmY2zkwHsqWmdslLDtqkmlC3PC26SCSyiKzFehA/gqmfG8x8afvqymxWdMyo03eIELSONLd46G5bfydjfCaaC8VstvelwyexEVFRd1dzsvimac4Wn26ALtp/pu8AXXaFLagiZGNBfohNn5C5h5C03yC4iYAKiF7CWdup6CXsnWXSytkKbKJjGSlaOQPUKC16nXWqsJ+XQK7rvzOqNaNeLHsJhDBafiPtvfJ2dpFMlp2uYbKcPTNCwWaajgboubGLgsImwQBOEbhXK4jLGksnUtL71q/PkSCBjvmAsgoOmgqfbUjG8fQjZkr+AtPtd8gWIXWj6FoyijX0szv+Wx4oUx9Y+i/NyRl09Wq2WvcFTVDfOgYnXleX9PLp3zi7YmJluNwPXpgB3cfecp5Yq62Cu1pRn4Mi/3jTPZ3I0+jmav4ypFfzTSustHcNeEwePS64DyvmpxI9boZTqRDO6I9eM/Uhm8Vk0+bFRtY73oZHp7S1R1dTLAhnnIQ2ajTE9KSn3KW+uhCQsNorSTg689R7ncMFyWU9pZ0Kn/j7VRg+QXDHDtXn1QyxdyUm1wA0jy5GWuNbg7EkPRcemVMWr52pgw55zB3qYtvEap8ys6fn826FsjwnwGjesb2iBslMnRJ88ujNWQF4VxMl7EpYd3LR+jQYVQHsrxXavM01i2jBf9p1keaJ9rtymKaJ5llw5w1arfehZVfhOCjkLl7T8IgEbIvmKp48Mih4dBYJ1gBzqFNfSSqLUHs2QlGbgMKAJ8CjipypQoOIDkrBDokhGqr8ouWA48sMeueRlhEM0OKJjpxQp0QACfNa/Zw0YJcD0qRmUOfB28Dzysb5GEHqa2PpfIxpYL1qee1GA/3t0R4fJ1lvfErRWQaJw3fgFJ1bocxvYrl2y+A3S0/C1uZdEHjZqtj5bRzOrmNwV0oxoNZUVSU6dAu3H7qruJhC6sXMvMjvr9gRl1x43n4w4SxFbNVLxiLjPmEVi6XQ7i1GtkMl/+z36dq4bt6thIwocWZ9N9y7dRpU5kfKRA2mbURccLqIJu+djnmDcwoOAbKeYrPgUvk3xuQdDPnkFrMSHoCmlTXgXQmn64QJ5mXefWEZssDQ+r3RaYxLn6uOCo54mHqn0PbMZK/o5JHSacgnFEGHB8amJ4Islhb2p8qschKfqAlRM94/WWOnDQiLBB2Lz//8NpN4aET48xY0b5PE9/UX7jCYe5wjeCM2qSDPA5JXRJ4swNcTfGRLFBbwfbUdxsSpx2N9y1fV8zWdMoIgPne/4CDXUx9EOgE7Ulvf99uFFlK15ES/gXhDjpnHbBifNaTD0VMDRgj3R8rGBIols+YN6K4+sj0UWULehMDRA8KhGaEW+WroNbZ8l+MwzX4BbgaPA66nKXJG8ACVjJlYt7FIIr9KhFwRmCXdgZ71IaJLt/LaYkjQxugi8iqm/g6a+3T3FxzUMcPpNPWsq/9Soc7Ln61N0YtmiQJfVvLxpsHIJ/Nn5qq8Vd80G/EGzGnT90rxof/vFu2ERKY/atCgWKv56wFx2qO7Y6rCKrjX4BjDQGeIo4GEF28xcuQixUGiBcRsT1qrnpoc28feO26aDrk788wl/wCrnOK44h2U6ufF7fyO3yBSVzmxXWmxn8SRxqW4WCcde7PhAbRvx3MYqAzcI0mxIlo7JLUQIMKDaH44rD/ZouZpWK62RfX8b38zYtrJGlcDl0lGHo11CnodAazACZX+cal2L9XZHW3FiXRds10azRfrkaEi7OcXj0ed5x19EsurPVAaMNvwTQnSktkBRa5BW2Okmr9lJVyGfEWGi358Mtv4LZq7yfoPl3iaUQun5dtec6gYrIl2++GlaDIqTBVYhtjVuLI9TYbwYmzWcgDGjN6qQ7TmaduMMIDXrcRiGAO8u188Tkr/CsZYMr66B2bYOWgsRpoDWPlfuwpqfiEiyabLer9BJyjnhh1/0S5w7L2Oyg670qPmT+bt407jxJRHSSJhvKGhcOYUKZ9DHxkmnV8P5rp027jv5EGp7gSI6pId+c9BaU7KGpVUzr7wa04ITgmfhR50mf/VPvPOSXi/gIng/ojPOWkV/IvtnDe8XJJloRtyju/UNWpETsBAeBPhfcVS7PpsIP4DxA+qhyif7c8wq5DvwLBx47OON7uN5FqQgzb3tx0jKlEWo4VoVw4o6RYTWlgRnbtNg6Ekx6L/Q+y017J99UgFLShNSfLIPqehLeWfEFkRgxk6LH9DiICJQcGrK5PdG0RKS2twUzm5gaslZ7ymD62QITCqmhnxDeYnN8zBS49d5BBmRD5P+AbHh2QHQdzuApGsCxPYYV1CH5YR1Bd1tFFX8hIW3ul+1YcMxqADCbZt8TXs19NL5ZuwKb7mNe3K7mT6w0qHJpxcu7YxguZJDRYXJLxNX4xtWX1Ju/bEkH1W+4H56tUacBAaFleA36z0OUjYPIPhYTe/gwyp8edodD3HLqDjlT7ZYU928JgWE6BCp5NUH3JI5hvWFcf2w1216T5WzI/Bgg1vFmAEyIQopSUYGdf1EWFnkLIxEYmKXVlswH4bBIcqB8tKFVrJ0va4zkffAhA82894CIKZaQLgUJiZLRYxTYW1Zd3+jGfPpWBcIXie+SEO/cOge+9ATw8jSDab9HsJe7UnTZo8My1KXvfUSu5AW292hHn9Rd2Oz5p3+f/GSoumd91BDVV0eqd2PTxi45lDGIOgigEL3aQl6yQOFM5pV8jiBhl28k8/oyEing2yxB4OANz41zrSXw2OnIIECpuOO/b0iuCXiDzHWSr3ysmjUJgyuhB3A5W2F5xM/NNJJc8qzZfLA4zhLVMWHUuEHFopuiCtHZmcC5ajQkE6g7su0o9Peg2Cw9Qf41XPxYsmvA4RlnWQuOZTSfeu+Lfm8+vsgcnSi13LsuhizL5Wr9smXjZbWiO+lhEzrTWRIdolfAlxEyWwp213Z8HUyZgkvYdORRKf9JqtNEfJe6vfLV2U+LHVnG4w8878FgvmK4M+roJJsEVP9+xj0231xu8bgIYwKJ6wReMrlBVS/9oJ+v/ErfPrPJtkZ0uGOrfU5Mz0TRw8mLHXff+hmQFWZgZkkhuGyjNVISTqOHAS67aPyGXezSef/nainwAemSgQ7/+AiHhFKYoVxX3WfCCqA65ngirKMz9LGOButoPKs6RUppXMSsZluvVSt6X4RccubGm2vawFKbFXktajySNY5vBOq12IWr1Z6zQu/Fd+fgOuFyjIYyteewLXlQ9KdlBTfdG0WAldd7U/g18TVHDW6RsHs7aPyMgSjJ3Mz+kytZqJOwC9O/vYMOc0ta4Zj1+jDzrX6woeOaQCzLZIwxPrajkyTUzgcTNeN66iVemWIYY2OTGglFL5aQlEzKcYIJcUmkDAMX0QYE6sVi0v0/RCWx1hlbB7p05uMEW+5vJ/PId4+DHxrGwt8n1PE06NE1kQLU08T+3mC1Rqz65HpVuhz4AqUZU71XozVt5GOdwNSYol16tzMuC3IeVOLxISRJGauSJgZQ86ULz/AAJBe2tuW0UMIjfK1tu9n/azAUGmT28RZCymItuUXyZiLMS69cHb8wdMaXE4wVTSeJ6f5SBaebGlK7Hc1PbEHGGF0+AELjWt6q0DmWCOeeAhVV5A1fADewDuWw2blJrovYNCYzq6EEN0T/XyyY0gqVGp9jMhD/PmU8FnMx2JEA6NUr9lDOEhq6SLx5CwB45IK8F3qTbXAo4FqQjerowsGNnEyyr0g4gSV1ydq32hDM68jYG7Z/p5HRB1nhBhGRnv2n9wG5minYBK9qPPUvDhCkYWgA5rzr1B/uVfLaMoeFXbyCu/dBdvbOfQXIlDdZAtrqUapqfjIZ+Viw+kA1K22TvOZePp/6ljKOO8A4H7A04TvvV57gCP/3s8vz0bjzYNSOh+ssgJc9hNGd+n/w8WJuxnPfZ+JWBNMnSyQB+qTKOW+whRt48OsuSmj14R2uVowgahmMHr3gbdaPxrTmrPPGsbxzXkaA//kAw2QWhz+o0fwTEKkEh6XKoNAchXJfMrGXUH8y/B4R3Ue2XD/jmub49KFspEbhlW7GyaOMyWjjSFa2UqwV2pLU5VfVVEhbrwXke9ObQHKVudKQxuNLyrhLEx5WUxD+GHN2suJ/VdNL8l44aHlcNvp0XDfalh+44mY5FR882H01FU01bU8i7fVMfdQK2muOMQM2hpHj1V3C56tY+W/GxxtQjprcMSkCtLPEF56QRWNvAH1CSewXqTlw8ENZzk85TLmVPtihh+0n2qx/CcI6hGFUdraJI74do9ZEex6qMp4l1argUAp7puFJaeU75V0ZqQKnJX2gYspgApPPquZLrHlecDl/GJ4LYTYAtdm7kwuFskKjPNaaMJbpJm8zJfMtnIgmkjglub/JWCgXJ6fygEwCJdcVsfIs6prTNJYbHdKy3IzWW6TLD5MCtPyTq3QkhKxLImw/OHmxBeFZFzXHl1MZR0ShBfRr8LLgpaBaFls/HJv9bYEysyNcAH2WcvXbAALeG4e5Tpeghd7cGKCaKirbJXutDighafbAqj/rrOwBb7zt22AZPk6mmJgxYNO/zjM7le2vHVIyGbxiLRlmU40AuJGV3KYR3yrPhfr3vo+piOHizjV4yG0b4QQ/2565+NaJUF+qX20y9jDxg4GPt3JT8BoqQXTkPLPal8Ta36OkeyP8IBIUatE2nWb3flizeTqt/1H2SxzU9g5nIcDugwpvUIKHetduOhN6CbkunXMTP7ouIfytA25w7CPgV+iUumpG39oD6EeX7ZvUiUySLL9W6NBZR0yMZvGJ3bYrWXv0PL8ak44foDdeJ+IfN9pTK8QBM25ae5BD2fNI4jN55gaPcjzVwWoqR0mItjSi9XGWERAKqFJTxgrGA0/rGTlcyRDb11TkScQqUl6XbuOCVTdeAYD8N/oks0Kyj2HF7dJ5LS703JNpo457twxFG1B5EumDWsmIgs0HJlmH0TxndR4q0afK3gomhPPG938mFJOSmHgu5rWJof5wj4usr7+GI0dtSMfZp8e2r/4pWIE+X4zZlBihYA9h53j9ts/1Capwa2VD/xkQKlhaoE3K+4lsLANr7OquiHT5+7FSVfDlDwINgNJZHeXh7X1M4XGCrKGkyiwXOTm2Nm1VFtF/DCCUh/UdgpOMSoHqlGplLzJYLcHStJ8NZonJd09lC1WXZ++ZcMTyBGnpKml6cU4x9DUKBDvN5qvS2dfLs5PO+XvB573jfE8SKrcAGrc13LMUV9XDvHAJvZpV3cMrc9mFOPepRlh11mMx83y9r8fe3Axl+Uelr88EeJ0OyH7rHmYPPXni44xP6a5BrZESK0pukOS7MMJWOdmNcg7FC5MP04m/uSmhmjy0VulWnB6JKEMxitflEVThJc8pvQcMG+FiJcETEgeNnhuvj3u1se0+9AVDp+xHOSsBOXu7AFVvNWRQZ+roVNZvj+otJbm2Um7gE0kqE89Pyu1f20TNHMt51sm54e1G+7mYxivj37EdfHx+k+l/Fu9//I8nE1Pv+TE29C0tzQu3d3OBJ7W2d+CDtVNk7bt2sMVx7MqpvZ2Lbm/Ctx5gkN/dw6b63P+Waf7imI/i3VzP7uhvdmgjSbw6Zy3sOyIN8IWWX3BiyVi0nDFLItkqQ8TDpAHAtAQ4Y3e2dwAMxj0GDO9ow7+17OYNSyzzXH49hByuNwpdxa+Awq5UA/p1FDJiHpnjbDhyNHWNcrmAN2meSPoHL1qAInY0LFN5qRAB1jmpkDb5qsNNacVOumPckACwMDh+/8N8eJMdACEL/i4z0gw2QT8j9EE+iN0afN653T6qGCGJe2Cq9H9rX3q0NuHIpSCaXDHTj74roMc5pcU+XzSsY0TRcongmrlKNlS4j13PidLqe59C0q1J0Ugs+wzzGnpyotGKY1yT3vilssi8VnmvWSrNjPBzaU27VQV+rQeUcMeVrxOK5PJgnnainy1Xuz39vsLf2y+IyUn/9zr8pPFwP/OvlMecbYl1etY/PpCJaLx3jVPMbGfobw2jG80iRsvXc1PZlrWJvo9moMKidfkHiOf5ZYovtJQjsL8QNx60ZRQcFs+PDEK6fCEcMCXeaKeeoe/XS4w+8XeYl+sy+hVNSNDqF3fQGSrswIa08AH+MNhSgTCcEa2RWyaJ8tchIm6qCk1+BkHG3YaBewMUMo9jftDOEvON+NUQtUwCQ4h8axPqjzPk74+H/cbH1jEMl6ZS73NFDUePGz4CTu7jNGLNyunZ56bCNDshdQBwvVLWsfI2vMqaVjKrn2IfpYCQnfYIBjj+IZ8fKSqh823Q+5HPC0Pr4x6YdjqCOxG++CJT+AglwvgN92keviiUDPUU6mVVczcNwMCRpaPHmdXiU6v9dHW4OD1rm7hfpoaqJvbjICV0IVSnvTURh5X5XWxpzhx7QlBmJax1CCNPpou7Go8RVV+GFLyZj/cmp/OdR1FASzb/kJWY0exIljHaKg2IOkB/Eadei3Cyf4LS2jxUR8etWIuWnhLbASJCIHAWYd+uG3TOtXfy6+e3cMve8tOmiGBUeWVpZn9XI1xa863MzR+vZA+9FXaqPjYPN4rB+9dPufZQ550BWZczDlJXSiiAqfhcWmUeiUoUJJRKl4qM7cq0ExosIo2jyVkEqgReHfoues3gNgSW9dzz8yt4/npK0fOGpQUTsZIlo7dfWSJyG8IRrJ6aLftSpki8fEp+uOM/cEI0mlgJ0O8GW5zZCOjgKpZtBMfa8A+dxsL4sb0Vs9mdzm0olfIeyeANhDDsAI5SMFPRJiBqPhIG+Wj/ii4+l2kSoQmF4ynUFlvuzuQNBJpjxAM9N5l2qL0t5flaHA6eMaB+bxTHmLy8NxYuI8aT8luEhXRA74vkGLdXcS7hmIQHDLB8odEJh+wEH41vtYlgUEEGMOhHe1x5zMCHapIuMtNW8tIkUJ5kXC4VMAb+XPDqZv0cEBrTV4hk06St0M5JeITQOdGXOKjOTJf/OXkei2IYQUvG4zziduTsKVFCXNTH6VyTL9YJy2qgpE/vu7WEqU3lyON6vM6IUcnZDGT2mnG7v2Xmb5dzvTEb5zRzkYrbmy9SasfbrxvQ/RiZdIDzlQXeqzpO1roarByk94VoPl15VSwjf+oflsI5qDb5radoubr+5JVNRJV2hjeesJZFHVBcaFG4qQ0QrxY7G4VowtmK4CIG5m29MBneITJrA8yKIerm3vL1uNTVBpmj1Le400/zXDRfM+OXqxbKeEtTwO1I8+aYB2HoL5qlKhKjXB5MzjKs3NSzdJQqmBFb3+zyU7qR5aSfkqoJwXjbblm3dQCorwOgiGna6ZvP3nsO4JH6iVhucaPOXSnOfd2qpCTY7RoGqWAB1mhiMJOB3tbcG1n1ZGp2EGlO6GZaBEVWbulDNG+zuUnc4uRKZxf/pd4zNkf50lts0uC3dR6AVc8zOcZTh8TnmefXsot+Qwobt3XqVsG5CrwSqE3/GdUmjpN4jnqyQrXgGAf9CDgZp32g/hpd9g2b+3hrJPJg8w+zzUNWkI18Ba2oPvW7PAHNfSElknr4VzoHWo+S5Gke3UgEeZcT18mKUDXVB7KOkiJcRIuzwsRmMAEC3wU45+o1JN50g8YwYdEjrmOqL1RpBOKiC7+HvNXQ6TN3yDT/RbrcywCqryF9NdNhCjm6lwnMXYMySaqoZw9yFYj/PgA8eorvuvsqMW22eblacwPzORbMB6UXU4UiZEoPCCr+ijffBo0Cn3vMDm/SDn08YhlnFM5M+0i+iTgfmjGcPRVp/boew53zRbKbB08l7vy83VRpfi+KX+O4dOzEXWp3v1oZ+FGatRV0XRgrZIcc1LkEQcWB/7AN86OjRIA7am20jkH/CjCKP+r52WL1t4K+dXnsWC+3107FGi/lDQGZi1l3vdfTs8zGBRPlpg7E5ZOuBWU3bBFYVox9gVBkAnlvI68AEkn9SrmBvu7EYwTN91ONeDbKNmG8f8CbGyg1hK8bJ785e0Glu5o8vRn8gP4wgd0b+htylR96Id4I2Z8wWlB+ebvuUQcCDGO94yz+M0eXmUfgdIeOrz9pvcOQ/jszsmlc5rwAi29cQqB120kRGy1UNNBA+vEc5hXMSwnWIkB9OzfaH2GrC4bGrPIT+q3+i8MgDXfUZcEBISs8Gygo8btYjeRC8fG5fC/HJFS+uFeTDKA2Avj3z+2lO2z2tWrl/xSMlRzRLPp/VY287KEBXDvej4yllQXPKeFGouUUFrgwS5vNMU0xLTeHiU+8OlhzD+iX0SZvj3oG/fjW9Wc1LaI7suzULlwu2hX755ABPS5L4kAmZxTOaN8jqb0TuIOWooACtsLnLZCp62iT/wK1YeOp1/QgrsHbYo5ooq/1IPhBGkCiVFnrxZ3/axMN0o0YdLumDGUfDjXOj3Un4JzflYviSTbLHL5Oe1UY60d29332itstMxGZ5ymYzdAV9lA07wmSRRsbBynx9tqaz6YrzvLLWLhLwtcTB00lEBXvTcTGIFF0Zr6bpRsbw5MYeOtFhx9+K+NBRjX2POVJWu4mbuUKH9V6UneUIjTDx5bru6Yj3s4yS1muSx9l4M5TClSDL/hzqElH5GPcz5W61oZvtbhQNpXmz20bULQqhvhAk01u+t5gXSh9toue2lUnA8KL5rh/EBsb/Ssk26nKmZKKgcYMjzWiNLK32sRUAZszRunZS7kJgxJ4xZHlj6rlUhZyvz3Iv/SpD7Aggcr8V1YnEIjTHqdeanJlIAsm9JQYT94OI0SCbU3l30f3s3b2UNcFzPVhC4QqEO+vmj5sFor/t0nnBuRjwsz/+HvNzUpktI43Q3L4XfayIlSPQ+Dpo23sWkNf9oDRcozRWnY8YhKPR35oXoSx278K9HXT2GR4fBJVq5KXhGl7zN2ri55f08Ui+9CMKWpg1xHv1fnMjn4hOt7UgneRlN13Mj/YKJegMk6QVSU06P27P5Jx6FzjwCS1XWii+OURmQNN5+Qn1dSmuNwHT9rIrBzOf7BPSsHXHG7dlhCGfDKkV8XPjEkj/aOME3e92yHVG2RXpThwg//md/Mlwd7EJYCP1+kGkTQjV/rrXIwYe1q5gtvuXmV1RM1v9AG8oFBFNDRYKgCNy6P1HZJnucFrpmbXEbrPiQLgaGXMiCjSDpzP9vyA/i/Zm6Cw/RjmCkmtDRINF/IdLBZAiBIP0ExiasYYY2sIYkNMdGrdBmNdEICPW1tsLIXs2Vs+m1D8VDuIlY2qzKFc2rWLoovf9zuz5jUHSLlBieE94eP2AQHJvo1C5SDaOsw4jahM5kJT+fb2yLyxAYg/XBXDddlfq0bTeks9OJM7MQtVG+48MG+wzrHDKfPoS33YP2w5z2UNHUYkMr8ofWV3TcbNGcBmDT2pA6PZGdWJcs38Q2X2JxYLQdcQhwZHXL9eqSPS6+XFVsev+4emdPVSoWhamvCfDcldVqXdo21fvFAjrW5mZOeVXhrXJilUUewxJmun0CEsNxPjdxQQ3b1Z3CrVUrYwY4q3Ka6aaZ5tP5Ejnl3ee7ITlOgRHK1+Xea3Pbe65Hj5bGqD3dUlA016rQuxI4a9K9RQfRf68biG2yygcm/BDh2FPSpZukkipqR0/0M/epoqbR5vTr2o7s5+fHrb+2WF/b7djiNY4dAx0sNHg13D+xJryjaPqnlgIqGg1RE7KLFYiOiD5IWUwVOe/nh8josejBYdE4hyYVT78S7WhCdsufJXQoUEL1lgNoKOue3YqycTqdCuf0l2+7HHDkU0/Q9ig8ASifKqWQH59offhpX/XYPC3h+YRPVfMGN7gYD5JZKIn+lmA0XZ6R/YiBamlPY77xb8ShQLD8xfz64d/VUbAqzGXFSOdQCYjyWhtDCsPycrm4cvaxO378T8gMcMpnmPl+2Rj4LunaRs5XK24QgpfNqkRB61l+KclmN0ZqiJKDmvyOw294b6LABNhaPn2Lu7aIm90Zch48atBOe40MvUULpaqPwavjJw9eoGigp/fiLyc6kBQAKWcOMaVDOQ5MJsSxuSEUYFxbhwuH5gEAEk9uLuME+kMwd3iTEnv3p+05S/c2DNhok9qpBH465gXlLLelDiPwuPJ9m8EMxbvJV/nOUf0VU3PNxuaIHjm3DEPi3Epzjw0URIcFNm45wgJCzL8PewWnEo6TuYP8xLYgCfOmUvBmkZWaGB0qJcIv3pcNz+FWsx1ZSLI0EdCEe9F2Yun8tGWpPkj9Bq1DOwW+vDogaSgoeSyLipK9FKZQnoBbNnrWqMj+qRNGJW/0pB3gZxhG9DxEyHSyVT2Zdfp12oHmo4SkzugbupMw6RpG2OMCuZ8xw4EhGpi/xY25tZTidjL1itBZpojutMi3l1leL0r3a4eJksvQaNdp9jsYuPJyJJ+JeVu/TsfMxQv4PnWi1k0E/dbU0K/lKfpxlb18Ao6H/mCkSAgLjHkC2oxVIxEgetyl7GKANH871zkNd8JlJwaOBv63eeM6WNo9VgoNlj/Gpg08izNlWg24I/n3AGh4sQbBR6L2m/PXcpqe2cbSaFvkbwijyIEyIjMdveKneO1wFyXJsEZFy3NvNVv5wPVvwU34qW4UXBhdbevxq0o/6nRTJW+Mo1UZhCJkbX7SqTVQzOB/F686ou5wkSMtIv/YWNsA8/x3DgVwWrnGxW/z4QWrPJP4TRZAedNV+yqfKwexqlc0FHz4y9e3DAmn9IfPZjM4iyWHU8lOMHi0KboPlKQSbaj3z2ZroSHOVblLpbDzZ+TIkGPlRbv9qbSwVD5E3bjb3iXfBf+XyJyNmh0KkhnUEUJaizKDLuDI0oFer20FINsdCgY6ycD0aHOkFeBl44dTXxmwQXg+RVL+mnndzyBMgBz3xjGEB1/a3RfZ7QxtT73A/9OCScK9+hTtR8vTOAHxIGX6hrKDo++ITjyUG3EEFsm21zO+gMfGRWnKoaRnVTe9A4SHr/dlo6D9hEjb8dpiS34m4Ss+MKn6cM/iu/9g9qGqr4NGS1DrzLbap4jPQjdKrJ3F50uNYFcDhW7V2li2YMQdNET5+aqOdoXZAGW3Lp31Y7prY1Z4iF2CM3BEttJ/6OgE4j++ehX0Keb3asMFw3PwdSqGFHGMtXtuOdH7yYHSfbar2B+juDU4FnI498shCg2FzIYVKYrwvJYtT7oT4hUToieByzIsyd7trxqh6jelLcVhUXlwVXBzZU6gwrSWWQBhbfSww08Ch6p3mnBaJMSHswciccOYymUrrfH+WsH7sQuEvkANexRQpSpXACdeqYYH735+yDopI6wd1yaH1Nj6sGY+++Ra/nRyGni5RqT8EbnznbpXXNgfZGrlcjCII9EwT7xa0aiWBfgA5ahPHBWMQT5GvNY9QblFyVE6cj9iVKqPLvmEmAr74I4AhgGU/0sHKqqvAJSse0sYEFt2Aa+YBluDb3v6fQ0cB1VuCEKkv9473vUdjgXiLJ1trQWJ5cPh7RtsuBfAhsufbxnh1UYhFpnzExN5CQRMBjLlvWO7azZ5/rRCRGeoP0yU8c3TaWk3iHFfY0+fxDXkRV68GnMek4Z4b0KxV+gB0SvCIsFHONCjFFy/iDSDaH681iLuSilEiSDuIrKGiSLQE0aMqOSCDQtkfDnvdkhwCceBrqcEakbNFwxtFivytOUqORioqGtm+cgJxcjmkVfGG87GLZ+C4AsrePevmTXDuyzkooWi4IMxd0tjT07BKMevgwt25nO+E1pycl89o8kzxfkmSbWqbL1JYiEitcQZPwiSrgz3+OOBm+Dib44WgeH8co7AT0yNRfzoASEvGk6ZPkwki1MCmgK18WTE5iBKaZXqNkkEhLdh0UWbXfz230ZWodl6GWG4mmPfqeSO2l1Us3zBBHRtC8RGOGnBFQ/YWKM5RBNfNQk067kQbgwgUUyOPpFZPsb8ZSNH2FVaYu5o0QrWBatGqoUFp4/hQxblyq/bUCSfW1OTFc1xBF12Fq4CAf+U6Bu+cta6sDS6fTefouJ3Ox9J1VjLfjoso7a/U2drX48/nAmS1J2bOWIUC1jSztgLrAXeZqXah7spM2o+eqdYh1ShayA8Siin4k4Qa77WC5JhFw1PIapuxECt4Hgn1X8XMNaNcYT80rsRRsl1WbFQrGj6w0euWHtm4sUPwdl04Tf2bD5IDIubgpuOgaQml4Oc5jSi7Rti8N7epWCQK6RSPIIUcs3LmpVrjS64g7WlKKzTC9oqMq+B8FqXGMxQ3eq3zSS2j2UbrB3cQcoWNF50T/fTacaXdWAOF76ZNpb0KsIsCq3jGQCsGTYh3JvH6Ud2qRGkJnXiNxRSVmlW/TF0urY0k3EOCKlpS2ccUeoRUpZ/jvWfbkh9aC9VpSlEwW9SaSXLhdhywpHoMn/Kitb121r2d7nPwEg/Yi2C0T26amZOxzhFNvV5SfaIZ8oQiWRgEm+4XBRLWraC/shNkk2aoabLijESAcA+L+y9cyN0bgjf1pS/lVqq7QvQwHPebESWK1jtTebMxNejFPD/TKoBkQLfeH2LCx15CpUlaeb+Wdh6omVCwj6Kc8XxnWphiq8UafuD13MuNjrlXg2RrAWEY5vr4SFKNItbfEe6ARlu2tPPbjvMyUgCz/30wimWp2MhUIUiXtJIwWBmfWBqZ7fGQt5jfThzuNp5abftJi0uLe3rPpKwjXCNv0hV0lCG940lChvyeHaQGWD9h4U4GMUe4wA1QwS3z9A5nktvYufDSr880I84WhnVcSdk+Dt6L07c7wgFnFAmWKkprXHUi6fOIh3WwnbkBCOoh8gVOWOQ3G2YpbR+rEmyhPKtaBH2oRy82hwW/LdNuoDbFf/VjA4F/QTcO1fI9yzuCLjqV5jOEinYVm14JWXjWEGNNtr8FWTcpyq+nQ+ia4GviwrlZqrUn3N1kQQO0YmfOKayuHDBJ4/2IzD3rVxE4xJZI47D4s6bAv40jd23yhCGPLE80SzdVtcE7AGLtsbMgLUm0Uy7JJWacl4LLdZQc2cWMfDuI36BlHeOSbxB02uL1sZXQhOgPu5j/Dv74lYvpndXy0+p8Fv+ManbxHzD/G9W/gAGjtoa/G1sueukqmKgMcWdhtGWApt7lMkshpVRZMhQ5c/PIOccm4Mbces0hqtKkMpuoJqcR15p7h6Zv9ssNSasnm5Nv8LePMNfaQ7tjoYk7yX10IlSja/OWPILAOhX5LI8QFqcWPGvdMXet5O4nSY/w5H8bDQm522S1sUssEngB7rfvIDJLrsBhOGUoAXENbuL8cAFZRyzvwRfcwdNTwcZGArMZBfU67zIXTVgeiIu2s2UlEeir0phNAs7FObSw5gvh4OKNVj2EM5VFJVK2Dw6wR93Yfk5dNULOZspMxlcjkwBwlxbh1bgZpOc2hPTyclnfAG+0Q72MtTAAu5uaDPwqtXwrq8p4aiuzj4i1LTYv0WDCcmC+Kwh+9X7Q5QHdmNr+lsZrbFHphwbV3Dy66zqfBSueQpfB92ju/glqjAhf0Ljl1DUe9ZL+Nt7TzbA7ULG/bEBhSDLyggCdw6Y1SxI7pwHTf1+QVoegDgFHIl1QwBR3my6TUVFYHWPwVJlWttgGxu3RIwbghTt6JjRaOhVczYLCVCuXgQCQI0E+2a4hS8bqTl3+2y9dNjZZsCrB4oNDv+6rKYb2/GbFS3RV+iX1JLuwNqa4M5FpUZTIQkWUk2U4dmyDpYi8ae1VqxRR4F7JKig6thiw8FDrq1cQYNz9GRQxk3PQHTP0hLPy7yFMyDKiHSptfxQLKP0u50KgbA4G9FcYLuIQm8xWRX2r/zDaNKYrtvOa91SduZjuqTjdapZimf3kbfn4/WdJf5pyM29aMzfXAwwAIgcOxbbB+Srd4gfZkVSMuvqf0COZ/BOADltmSTFLN3sBPtVKV0NGgmBYQ/UQgAv4nelu0zDWrNGp2SUlpi/aME7fIsT8b18iB3JAkIPNx9Ktft8LiTXNz+Oa77g4mgDvW264rtJfYane+Q+paM2VrtqTgdAitA4D2cYVI2SbCt7VUMLD5bNPaqo46BH7yNEX0ghjPS6D8wv8By7ZNqaxEwThaZPXsq7VKEiSDDXgBV2Dmct78jnPo2ksP17Nvwia0nQdH9QemkAFF9nYUZBForl1AV+t3NSN+bCIf7qO6lbJRZy5X8UkRnu8Gp3v2WjAg5u9i8XbVBfoGU2UjY6fznkbcANUVzPum4RmpXzA7RpeyQ+N8o8xzHnS+kAmLF/fOHzs8AiP7y43cTMUVaqv7NF/40QHl3e3dGMZlFlAUZBtdQokm2/+W7DkE3/wZEux6f4rDroUkrCw1pa0tjpgvpuexxz3XsSDDnXwEpQ6Edl7Q8ghbd/mygmDMlzhij+MWyFs7PySgTIMBMHx1Gw00/TIKa7nFCL/c1T8lXwR52jR2TSSZX16E+pBREsB0OYPX85Sw4P4Vn5V3swqjfA+NafoumudheHVJdpJ8aGrsEZEJRVJ0HiF8sfhpLJ2xZKilH6grA9U3Qxh1cCRSz6ceW5yAtZg0D3xxO5120PqmkXTFH35Ujw2nEGNWkb1iZqHpHBViZfEUQdBIwQF7Nmihfu+rLUYJje7CG1LMCT/tL5Zu8MuuFUiph6zY4J1wqtCiUYQEwPu8JBokPLrCFFhSqusH6u7CB9QmfLuOi7zVzagvELpPBaXSXsEA46fzaAJukSlYert1cymDFqge1TSr1KPAlPKI+m9yZjQLr3k8yIHXQ0US2D8Cv326NmVdevLTux/Xajq5W7B5BQbB4J83ULBxTvcdJthZIExGGywYAoCiENrgmnnkTSPn4ScR6rO23bpKPCoHHc2ILW2v0pUjU8UdckywZ8H+abinXASv5mfh24Sflz8q9Vcio/Z6ftleXsDFQZwFXMatmj6MMlH4XYn7uWCCaLhEes58Fr/UG7Bhan9vMHGW0X5jwylxCOPP6Df2o6wC2d/OqXqg+rOQSADU3soxv2Jo7B3+IcaKF+BWMERK93dUtZYjnBqnOsa4ZLlxc2cZHynfFPOkt+EBU+xQBD3QGOAFZJ2L1HQjgOV7oadUi8AmNDjXAhrA1JvbMDvgUr+NnoUhZlzKJoEEbrFxxDrcelGA+EkQgr+opuQ4eyqLKTCW4GhJC5gfDfwyd6P2GivQWdKfWjSlIu0OGNGyKCAcW90XtbVkrpnh7wKp5C15WOzunObo07e9fE6DC1ZDgWR2F4siCp5/zQJyfoqMDISrbrXIVK3lDozWggGJj5C0Mnpr85eWhhwBpzQN2A8pra2Yy45CpJgxIUjeu6QwgskzceKJOCIE0zNdnwHo5HLSAV8riS+0b+Hpv7KpUj13oLvoHPJt7A4lTPsZMhHM/duJyudVjl83/8o4P48lqMPM9y9uGK+bpYO2Xvz8AW6idrRHoOIRF+76UKP0hozf+FSB+qOJF5CBBXD3CVgMrv6HBt2sDPTldoPRGvMM1jAvyVvuDXu1yjxwffu8jc08IbHiNmHfSCmkpIgkaAOe/fXluR6nFo+yr1TrTQca7RrG71BopiV4lM3HRffe7xz2Ou67UPygZE1KdW3zlg9WhOO1UcFbJ7forlmyiuX7VxVfteZk+HBKtPuajXnMToqBuHb78l5fogQ9m6KYFrEiUwAFAQ5r8Q1qBKSbhb2mCq6zUHJuibA18R7sK6YZIlMbs+btq66tDoYZaUvlcUkkVrZB5L+Ea62CacmSYzPv4aVh0435mhi+Jax8pFZbQQIPW1jB3xe3/NlW2tq1eHlt12/kJU/kGZjB9mzc1FvKJMrzybD36Y0G8rW9j58KutqArQCdIFZ7dpK5BelxIkmcb33FdbqX2xpaEyx2gJdv+sFpyXZTto1ZNFuM13YnxWekc/EHqJmxStUd0DeHu4sVZh+Zu24g+iinC8Xi8+fHp4fX0lSIqlvSVxKtpw+7AsYrAfdyxGWvpVe6avwXvwIOgNwzltbk9MhAJiaHdTSI7w+0sGppQIqCPasM8ZdkJbICrc0wFoCfDJKUw4C0EZmzij3pRz3HQX+Q/oAeW8Eurn7nMDR2ghiCzRUFcc+Lyb8V66PMzGGwIyMz1a6pyxjvLOxLdVwzyVuK0X6MB5lEkb9IdrlKREzT6rK8FxDsQWZWIVvhiCuZkA3i3M0kI3d61ixBn85P2QClGDjoMtbdExJzFQaDbN41m+1GjzEwEDsO5PZUfCIg2mF2oZYrQO7wMDJx8bXwq/AanGTL3Ee3S7fVwE08NmRCjsLTsGivnejz8ex8C6WuRqnJRBDHumlw+3AX2bRFrSB8UUEoayrWp36YAfb9fxw8tFleTJBgPCcve6rV64CUZrF1HcW6mzwBd29VvVQyKjmAJksxl7RZUGn65F3b0e/EI70Rgv29m6f10zid3K1cG05JtRPA74VKj0vfFsEvIQETvMnEFhabJubZ2CG5JqCnUUy46wnxTx38wY6OLOaRn65uzGJ4s7OZ6YDyJaDdT7GEtYYMx1L8mJXsBdnax/kyEFvUGaoG+5HharcfOfn/tyCKOyCEmn4tvODcOtZVeZ7lzIdrCHIkm4JDdmcEWQMLpDIJK2KH1E4BA7JpeDOUMzMkk8YNMLKfpON4NiOJMc1uBNpwHiTm5+ni9HdxB88sS//qOwTiQXWonW8I8LpwWpMVpz1pn9oVyzjGrCHIzF1AARuwQomaD/SRZysAdDazCoQ1HnB3EJP6l2wh+kqpJWJEDB5FT8izNkw5nvtoJXLwFpoArooaREfKCP2xpmdBMsb9ZJD+kpGfV68sWEMGFLveBQIdeg0hPYPi6PUTVL6hjppi6cb1as1H4iybwzrCNUeepPKvifxKbl+RumABsQ7FkR3tI2w8khYm+Sc7vgaKtH+PmBAy6V8xeVeX7GUiq40AYDKDFvF4WA10oQZtpIGZYUTagb17WKNpxi0RWPSGDVELt83jdzWR1ongsD887hvNeIhI7tKOG4rKKXI04aCop+GG6ywC82iM4Z+WY4LG+4X7baL6g7IaV+aY+xmEPrIl/YUkJkRnSdWc2yE+nlloMq83LBGU99sV/tiUtPpTOXSijQd9THSSs1kj7E9dYxyZBoyKlj4KJuqkZFkRTUCGoBOpCWV5wUPn5WbJR1JSeaXDlonq+jMD1cLd4JI7oLoqaR3USaWpXlgaYbPc6mHrhxu+y/zmEVFmoAOOLz2XKop6XKqCPTBpiqhjK2E9Y8V6A7cGnU/H3fkmwejjzVp5d57PbMcq9RsX01A9lTuP2y4O9fd+W96kbQZ2r0fxoQlM3OZTPau4uFlWkDMSrqdYrx8yOIY50rncWPHJYTsym0iQlI31oCK22MW7s9Fb+EjZF9Lw89+7zfz64dOzDdPpLk4ldVrDsY93DPWKB8i8x24BGZyYDIXKAP8C/PETSfD6pLaU6AQBd0kCoRXpD6mz/NDjAWSrVqnxY/wis1ARcCDKz/nofi6PGLhSdBgCZ2+7wQH1nvib69+ulljUd2GbCGCTMUoeiOtWQflB7TQnBFU2FDUNBagP0kzPGbuXtOuXShzWrtok8Trb8aMPgfWPwlO+mq/4reqUl/o6ElcBrQJFgUs1mUpGlKDyAxRIyi88TeJOirqS2rbAf+tKnNeDSkd/aUZp9qFtW0PVeF8GGQJyINcYKLNMI7EnG1gQMWOsniF8hIPdN8YctrMrfXhLEp/Xb9YKWYv8PD7WFZCHeigY+uhdid5m+mAx6UZUziSCLZ/oCWQwoDAGPntA/CEMPUjlBEwtFZsKzbMR/wWSfYwvW9FjPBJbO94viQ6V6CXpMx/VUgbVw8Fq/BSaAYDb55gbMC+78OUdX5lIAS88eODdXH7k1kZZZxA1lRw80dKxPWXjVfsOniU7tw/IIs9c/iLtVgkzvlUHUyYgHvzyvrl8xgOtUMnlSs+TIk9o5kSMRLFtPqRwhfa2YiOZHriitW9GT0jHAT5P5UfjW5QkP6M7fYDZsrjOVI7p9kH0HzlyDQWm6/vK8p9fBvBswJahsoP0clgLsb+zNc+cqdJ5mFti5ADz/mOgMqxM8Ps1C4h1EsAPIF+QxBJVwoxOeEVRV4+HHY5bpbsCMRoClY7IZJuvCdRIpwttN4VT4wMi1pk8qD2cgrQ5YTfDwA9jmoKfCmMo3f+qGmYNtVlMV703X6QD32sme/0MJuWXfIL9YN0uJ4ajzJzvuA828xsJknVnQZhxslYuBLsb7fwroffKYnkTGi64JEXv46ywXyRFOY5Jo9pn8xAZ8BohMy+JjSlcXnY3aFpDmD1AfjXa9xk/RI7lT/eWT6vCf29joPANQszQRf9sbf7VioFtM+SgfATbJIePzCF7o1PvJip0+fyAIeqPUDyLWqoV+gB+8gPC8aRrz4jySVIzvBFsaru59KaXCrTEHp7Caua3I8XQDN0ma0kI2xk9qLqVBk24NeeVUDjvYeAL9m2wVXmEWfY0E/utSOjK734m55BrarsHcmRU+1V+p0La0Nz2kDIpxtLCOh16ntvd4eOz64wkrZvyNUDqSqo4LluvIADz6KVBY6JuGM/TQLCfHcEDJHFfVfBg6/KCFgZT/0Hgupj56mtcV2Hjp/IwdWu6p8wbt1sasVBe92abd1KzI5EYlpMOUdePrZmV7xRlJJKgOv9KDYpTUUrSsad/qbTkPflu80jlQlncUgdvEkYcuwOyTCULgukiWAc3NFKn9Rdh1xyXnktYV7JPUI0T3CKvMCvnRtcQtJ7tyCzUGMC/ShGEX9i4dY7vjEGdIQ3NpGP7e4DLRaXsbSiAEVMXvBTwO69voUUjYJ+6Cjr96QrGmqVn3fi++1W+IWG2EcVSh0ZrgqgpkGBcyPOdzxJ7FP2fGk1QyUWH//KtamdxbXQH/jg+ts5mGQwviQLSxVjGf+SwJYu0wuBQHP5l25Q2LoUz9lcLMLNEAOp9SDmpfEjYLwFanC8d/ZmeHD6MoYCEi9hVPtxRJk1ExV5Aw2tZElqewb1Aa/H696PZXxyOr/ZiJVhF4gGda/RoN2C/6tpFndhtH3Qwa/EtofVNMMwsVos8vw9+oItUU+AHDvc1Lem7+fcY/tw1WgwPitVLWoOO3n/v9V60ei3ckf9wYeJ+EXYU0IVZ5qlR0wRjUmZH4kDvlNXsFqs0MrPCW9eUSgD3VYMjJ7FRep3XP/cQEVUfohEsv70sfhzZgdeqlDe905YIOD+ocPn9EVZ4Gn5cCZT+KdxEbb5orruEsJh3GgsDmD2ERxx6M8DrN3HPSvbXdYJcJJIAzaS6j/whgVU9v/BopiwHut5SzNOlgXEIKHwZX7r9ebcyZH6Mq9MaUbxdUWZvtVqYXomPIzbQ71iPLzBHl8GNgF+Il+tVfVzLSA9xbUJzxAdY0qqZhesykHhzA9kyp0TAkDE9fjPvq/Ym+QH/24E6za92Y3MOJZHWztU04U+zLsJDVEqrGyQOz1tErHzjIgbRg+R0ohrJ5d7flbK13ofCTBcuGR7xqeilfSShNhWHIwa5V++0D0V+CQciUmuIuWtnKkOrcileFFHefXQX+QN3hoO4wglbMMJrTD/xPi07M4C68MnF+hg2X3pmCHvaYnJ6dtkgIRPTl3gvkBtNHOj5IK5UBufhj24Ff6vp7P7QlPimqttC2SqqYL7p+P9z+dji3xdpFCAXvV9PQIHDdsYVGKuJMUHRgPfHMSb6AdR3U18B0brVTWqJoHA3rlCLeK7XOqIkEajQtvmT/NHqIllZIVGwI1/u/CplGFwnOyXp26S03L+qIN1dYncns789xgP44T4VrTewqtq5EGtClxsvkk2HXpCkVmfXTjxzlPHERSbnC1Xqy/xqX+JUcuXGD96OG1qOo1qybcMbDq8GCR1wjJJciAoOeknuetdctD0ZP3B6Y82Qf7avcAAuEYGISKa+q7L+lS2efXcxrMjNBIf7Xq+ez+oScH4B/6z/M+1N/DeU7OVFjovxvrP2SOm/tifgJeicdXox85wxfQWrQIxwpe2+5z2y7Ncrp57xFBBZJf+OF19L8d2jL0V7xoYGiMQgdWpCD6NPlLpvrWcS+DhRULxaK3SiaiP1XfrNkfevUD9Yfr5x8tEm81A//MLPyb4SNAeb5nCGN8il+KknzsgQM+xS08MN/p4B7v8lX6G4a6CF7XXTdjSDeJuFJNXBv16QN0+KSq1JFxEdKzNsIa4PQ6kE+iz/6fYvz9d7nybV3gotnUJ/apf6tykxMrXDZKWRssUzjrSt2tQ+NGk1H5jFgKMiMrsItIdD3fKTsMux6Bwk6x+5QRvtH7czUauEtr0HoNC8D5d5uxxgv7pQmkmCocSCH9Ls66VcgMIQ0Vh7AgqwTohJKPwbpvAvihM4FRaTuqPvt05odvkyocv5fY8ZTNOQVXFwh3hcnFuK9uSaK75ReKXi6/cMU7zem/6rMdLpNRZIAYpV44IdUFoBYKK9gOPuqovqVwHLe9wbYKMxeAzx3RpXVX3lKklWdkzDDHP7T0bQeeIflPru1rPUgYBlGYbKCB3hJ9jTbQsFJtNsyWubFSo85RHncVYJOr8vDd51z6YE8FZwSxyNQC4bZQoX0k6Ph/Hd8a6Q90VJDT51HSRcp5HIhdOUmUT7agJZK6mPOI1S0Y8AdfH+yL19qHHEdqQjEjBR3jBO9+bdlTbxsFgE3nrZsvQnT2bDmE+gt3eVn4J9kAGslhHb+m0BSIFxLLXYvjcUBKSXBZk4zzUXQYOG6sdXIc7916gGrZCHaKqfjnKvcjTur0xDB5yyJS08anei6ZPU4A2/NNlpciWiXJjQPv9DsXW6DDXi7Ox+FonAu5489qR3FgnI7lgvwcy2obI8yqWgRppjNiki9ojGp6C5TGOBJSx5fUtDCEhdPBg5W9ZUNV9u6UoKDkIrBXf275BOtY8Y3SkmPuMVpooOpjL8tFLDobKz4Fm8uy6UURCST7wC0jGcNNQJUPix4nyWa9wDYExf+Imh+u3FQHUobbI3XFqoyhCzfNeZQGTNKyf1f7AUGFruRV2go2jV8aALNG/m/z1gW93ThL1ZUUdf3o/OEd89YfecIXj1cG5jHVb2Hk3ESf4Ggn908hm1rkpcui0PwF1wwdZO87U1q632n4jaA4/Yz4j7cbUOpGIoEk4jrnhrWquu+aEB8WFzkLKD/pta0TI3O86GMtizEzuD3CVRpiIM+mmB1eYrdw9W9Pu+Li7HZsTcVagQPcOzIR1n6a+f6mQ/emXKXicFdv1jBuQtiCLhk6eU07jlmeXfUO4JEPtjA4+kSxKEbuFR/5JvwuO7hNDpPqiMXnk1F6wFj7CheVjPVFTsq51WFFm3GgpavRGTeHjl1iAk6WtQb5bohQteO84tJ5okB7sBfgHiar3nH6ZPIbv9YGRceOvydQN1OdOb5UIhY1/aat88q+mJ24uTm1rHwl/p+0Pgv5kDsXsyIMsptRQCZ52vVvQainzr+uvkNQ9wXLkq+29pUUzjsbUqx+je7DPCH9+Y+mKxfONNyHhHz815j4MmVD+ftMCtRcKzHHlitJ2KRFcwgUo7DvVabbyoUGZW7R7M9g+GcW86n9dKEuac04vEcrDcxZ8mZM6sFFbGqzZC17aRtJmig0/rDs6Y+bNRmMOD/1G091KJS0250b83O/N4Qgtz6HkHNr0f3VReADzWPbOVnp2WMB8Kr7AHn2r0dbMkhYUeNJ7yXwIINdvewMJI2bGxSHe2a9jhZqDyqFoyP7E05EO8TT37FCHWZZk2BBls6/ByvBPbKc0GhVN1tiAdTYlozT1K/r/h9bv4mCQgB3LrZA5B4zoHBgeWV83DRFxhZUiHRZrAOhHHO50K9sW9Gi+NnH9IFHWD5tkK6GRK85GBavYMklg1Tq8BJg9Ugd0rxJjNdpHsJJAV1l1Dra0mZ4PiTjldereo4zA3+iyh2j7fJoaXL4nHyiTGwWEhxoTF3h90ijNgVzs7oIWCVRkP/6j/uMabsQcn9XKQXK0EuOihA2xHgYVZKsTH5SJWUuI7WIWGv86XEFLO/+enVVarUWBSOMfNGlPDYhgxm7qBii188U/IbRIpB49LawQsb6EJD++reqhejg/jIcZzDJhouFvJDfnbDn9pd4IurWtGeGXsamS7M7+PuxENW/LQKmo1k9qSl3WwcRVmJQo1HuwFzgc1ZWXMJ0XOvMn+/6ykSs25L4wpmZ5mLAv4b1hX6TvDFPPWdYp9AmR1pMraDPOgpOJY6BUkHbkxHvLbICarXkrWCB+GfxZ+eb7s39FXE0gLohHBHsXQmqxS3XezcYzZ5OkcAh+sAHsju1GNFDeZI/XZrCfvIn3zS+75p3ygCB8N11Q3k0jhaVFHdqq5nofkvLTutbWtJ7zIMr/mlk5U0NaJCxDWoP6/JEpm7oEGLoaRqzbfwcN7YX8aZUdSFHO+by6u3AcFpGu8zuHnrVtuvW7v8pP1d0y8tBioDLJT6miIlxLl8suqy3sVRhy05BVy6xs+ZCn2WhdZtQbgCOeZCTTIRvCiyYNvPRa/Pad9KX5gH+Oa4/yyueM4DsEP0DWarDVZWnUE5lHdBLxVE+zdkkSXkxQf+hvRtTOoK6oTIKl8nmYa/890/YKxGOFbV2AEJSE1Yal1EkSJnnct/tYfvn4DKj0lWG3KU/Fc9bvHpo2gcbqH5FpiHygHzZO78fMp6EBc5T2KaVMmy9Yuec/Wv5cev3k4+/kN2GhK6uB1smpQI16VaTvqNghaT/E0FMJ0K6h86j2tSLchDAUKq/dSkAKyxf2XgxDyHYeU+uWrtkFCBNCA2vqCG3nuIf5rYcVMiCYt61G++1bqygGyHD3UOYo9Cf6UiXIOfSf9iZA0Dzewx3gYMAlTgpQCl3aaETVws6KTpllfE0gmk8Mvif35VJSHXBF5fYYJiYcyG1+ijh3c4SIfYBCBsbKaepmHlon2PMYadQQxy8hJ1Yc0GpD8Pp+/QKEnZGUSM2+W0inzi1MwpdMKhpzWaiNWANZz61vn5abhsW9zkfzwjRzcGqWHcesXiQ9RJpIkMAALe2UjdNN6O9mPklkcJ/LF56F4NjwtFABxMgFXn+X8zSRT6vlaSoC5+6bZ+XI8p/GWmpMeo9e3y6d2aUvOuk/JsfSVVSJVkgcHIGpb6jy7lIF8AuPwr4LVm5rCNNixjOKxQbs9xxLBj8lVVubAf8ePzz5g1oZL7l3SFyEFB+m9Wb+1/70Ic5vR6B5p+1bT0fYdy5hHnvyy06XKO48pOf4JGboksqNV6EQw/qBTMJbdlhFrT6wxPHb5jrTSjUHekKKZdrDPcWu9zMS05WPqvA20BjyiY/Zs9X844XfXIQEaDfM4oMY6sy4vIA5vso5TdjTOifE9WGzSjpV96OOcQIOeLIQvCXqCs+2n0gugVHoq+h7ZOSZJr1tG3vpSPJbtXKKfa8hWs6h4dILna04kT2aLmJekU1djyp9rh7lBulgtVx0+C3Morw1kFWeSqhcGgs+cxsKuhjYvS53Qz+UeDUq0USJpmnJNyxr4wGMCXQg6wlPRgGsrKBq8q5DX3JVzrcAgpy0UyzBPMzDfnvOB+vHpEFNzmtAbo62G+AKW5GL/oROW/xe/6041/uFnQvt468vCIKWlc3vrXEJWSDj0vmjDWfaS7W4LQX3LI5AC/97DGMELFS/5xsKXRUJShhX3HcIaJPtOrYJRd7BwMTBNWEIwY5aXIzMR6zMZI4XxPo5bQh+oX4fxQ7qMUBM5my55kqW3rU+IHdVLh0LjNC+Av/9FmPUNM820sJCRLDRopdLMirR6ZftUpPI6NC1WXZqzdF1lKQPTbSSwFzPJHhWPAaNuXTJeMCcMlaXKaqYRc3QNfnwJe4/S4ery2t8vhVMt3hFjzyvIN3Dmcl+6mFln9aSA0rlK7UnvAF6S6PdsYEgboaA9oUIk1G4OZaBUOwQcmoJZCHRk4I3x8Yykh+uedXcraWsFEXaebXWy9R+s+QZio6XefOH9MvWedTifMSwfCCU5RTo8WIYk2PhrUEL1wEFNF95a/A69LPKgNNRdETNv7sNF9KiPSb0xgRnAjrAj8PIyjyjQkUhCB3/N0weBrpbUE3ac1TCzPmjE6r9xR7LthqoUD3NmYtdYEFoC/XcpxIk7uJWbQEum28St3+Urx4ReC/ly037acCLV9zGYRXUwoT3s0nycIEeFBcCrvWNhTUFqrJiHjBmttq+23yENFXKxHvo5Nu8oi9dkYiaYM2jfgaxaB7SiVUMFgQPdVEpWtt+GCgzS4gXiBqjRu2Mi7vEuPSrwHfFIP2QNRT/zqEpHMZlrw+yjAi41BJ0EvwoPEstqya/reh4LJH6MEzIGqTgekKngo7cASafrnNTIK6DA86gOLJ7T/jZs2EDdY7I0L2X3Gprx53NPEWeci5+qnKx++FQD+NqRZobYrzAAeUaWIDZRl+X3xdRuxCWayTUDsDNtkshgy6Ps9s5O6b1yEfya+NupHRVMMZcxSJVNT4IPgjbokWg4/OW+Dhet6sx1cTzFLgaxRSEb4WxQqXcKIwsydZJy3zK8kbbeNY6mP6hluW9Q/lc9WwKrMwweQuNUHJOJlnULyUfZeZ5ZW8e2Nof8XIW+LUHWLt5HlklG+B0B6fu7ZdJvSEzyDfWXB4H+iFiJtolhsxWwCPXICEEgg+nH8pcEXznJAlFEit2MlAYEB+mLHPghRGyqbCRMrU3R+dyqZPevr/jfxNemqkfimQLisaxYGkDyuRIn/5xIpe+AHxDJkfjlN3PKdBz24U2ze77z2C7C1Lw8d6kIMc8fPFt74+2ahCWQ/9n51dUZ2Y82S5hGlmm1hKqDRVL3Win7IeXCsk09vx+ArOscQPLCGdUQd0QXJ78LcpFPeUHYpiD8I386YxX7g5Kp1tuIr8RjTQ5sw09vVcySkkOAUnxMb/+YGzsJDWdweSia6l+RxgYmyzgjmJ+d8/0YqhKX95PVpFUhx1rlW/vh1NIUWulC/f53S2NFYqaSGLsa7bX+iOeKzFLg5a+0uWJEAkGigatxNGVteC8EJ65/Ux+OI07OiPOZOkLSFX6RmD1F0Kk8jjlNbHMz17IAlP5DFlpwbszWAS/K734KTSH3sQn9XtqYnPtGrITSAhFBEii/CzGN5MYpId+vXg2umkWWuINUZqWw5HLuiFlN+b0XJCk/lKZ0mZ3fxc9oOSt8ujOQ8C4cnWEBSv1vAyj+kWRgQEfDtU1u3E3ifgqHk7RFBUKzgKMQZaeyvLzYh1CszhCp9lXLCGWJUnHFv6vpdTETfBcbuudxfzjAQJXfCPkL9N5ojJSIhcV263seFQ0jpdIISMxJ6m15F9JgTtmYbGzJyu2zJ/mPeCzLjWY4bmpUvRgu+f3vo4OMZYP4hmu5BGVJoMnZ8ccQLL7FB7gU1UXG5qhzlQbRW1NAM3hOjuYPWfYbVB8eT1/vaBZcxwps7ajISwz2YCUGHEhyFIaSsHXw8ZgQ9ByLo3mzMS5NJ3twk31wCF5G1wamTjWspgS8vWGe8VYufJLB2aVOztYHVqy9WBlDvEC+idbUgzJWzxoNe7Ku6Iw0A7Z6B8M4nrIAhUJwW1g1ehxZmbYSd+Gf8Nd+TLzRGwC8mer3gcJRIlHiWzKKj+CuMFApNsZ1Cz6XZp46bi02UypeNJKmPo4JE5bvA67SZ6j/+80w4NzQZPgifqdOCk6jcVeFVmsXK7vs7IwUt4XN0VKojyt4Kwqm/Bsv9+PzG7qiUEP8V7k5CQ3Eo+wxKsI1QYI1ebtq5xT2xoMysi7F4pFzI38zqjEHtt2kuuVjMmAFImX7y50PryxA2jzxDhNJtwIDeZexIF+Yh7WIEzLmfGP3O5gES5nW6gwA7tUJ+oFMMS3+5drcSTTx7yAem6HfI6TUAwq3LpfCUURL+SfTLsL7Yx0amBvc7t3zJp9vlSIR6LjDxvZwfks1WPCRZPhyrs6/jFB6H2ZU4r4TgZjoALR7KZbo1dk3a2w43vOqZcUaLhxuXauRAIkNanFA+yDN+iQ+Pyi0LxT6O+h2FxLq4C9ap0BByp+J915k1mF1iqK8niO7TQPzupIeNeJdHaidImSy88jERHQBoIM9XuIYhzlvCy+VgRtNWiz1sU8uF19WtGKI145VTr9kszA67Pd25anVaTvqnA7rGsVkZIyxxUgtNxrRiMFRxQfIxT9ZI47gKDxmd305XOYrcVCaUse6by+3GSJX94gzPg0j/y/XeARp+XetqjCjsZfgZSqS9pXzINpuj3QBq0NCX5vVD+3T2U94HU3Q/1u4H6MHMudkGan+ra9Aeuwi7n7M82zyDx9Gt2hJhR/EwZTh9Qec0OniobfeLPfYpILP0bM5eF4qrRllqPnPlcM5ISNFhhh9dtcoDshthFs+7qQU+rleb5cMPuZGW2rL9CPIEVgmEtV4b5img9oCI/ssR2FduToIoNrEveVta7rNeAC+Uc7mg7AddxtfwfAMcZwLW+aw1Vi9+wbN/hmyQNE5L63AJO2fzYOkP+ITQ7a0hoKqUqqSTkqAlrJXawBbIQPC73hmcVnh2D4JrQlb9s3G9veOC0QSVTnM1RX02FFFhnScUOFV5gya9Y9gFtwNzxcEbM7kF+HTysZKeTeE69zXrvMPWeDyMM5hGuBefdaunlrLYp+w4+QoYMu1KP/sUWX+mvDmdZTUpFz8FHZufmOleoWltIYLBomXr77VQzq0PSmsPQ5ngI20YPli33rizRddLK0yDgqhrV5nCfqg4syu4RslTLcJiNYakVKlDR6XOUz/zvziN9rFh0d3AsiFIuOfoaSb6gDBj4vjp32m+XrSI+p5NRA0C2hAEEfznO+WtEVWX6Knn5VCM/ZwGftPiPLvJz8R8n9wR/NfJxM1+UiXJsw+GIXl8lr+aEPwKe4aycrYJw0WRCy30d5p6Rzz+9whWTXXTF+meXsAHXo2ApJtVHZglHJJ2a2KIGGe2wbuip18CtMYy9QeuEuHKIP6Y3Kp9XcacRBhHJzwn8qk9ISc/NXs/f7v0NqlSEEPsMl4F1I8qIdokxtrZ3GsTxw6Fzp97AonFu5dkSab5aVCwsS7Wy6zlSwIJVWXdZ4mFeyphSwv0/hITM7sa86kYsipF6oXKo9Z2A3JZmIigJkF4LIJMXELZl5iWhjDh9jSKCIEJQJrzN8No4iVOsa0ndzU1G6ZwSvapIkFDzk6tdQNyKmFxvENAhZxx1ndTg1ng3o7C/IQDyJfH3nXwBIXgAl0sDU+aVGZ1rJiFP+YP/cRwU9lT6hT10moAlMdftCPomjgIjev7gZqQoFuzxBVSrG7JfmQq63eiNagfEyESH6WIVCVVXR08kParzNVIrzVeJaqmhwlscKnxiJyCva7wWlbjoM6GEsJ1zV6H3raCO1ShhqNEqSJsMHp+5YGCHJ08EC0w4dLOkHkVLy5UtH8XRwsDb0XGghgcyOfkGHayuiflmiQEgJ4/ckwHvPIbP+CDjROZidzhgSSbeu9ajqrItPtW2wBD39LxTkJOlpz5Yyqe3cEUKL1e2Le9vvwNvL7irJeclo8A5ANLtnIuFnA8ipdOAQmHsA3849/z0P8kHVDPi/1iGPQl9AS7rjv4fvTu9GiZl0eumQRuSMgmPJW1h+RT6i4cYMTrypKJx+WhN0TUQZldXbDn5WxDeWlvoE7A2+CV08LQw6WgxiCKdV0tVae54k1cgX5GynCDiZebP/zgGGAVLWJmGu+Ts9XOQrEccdrsHaX1Y3F+xFQJye9L5jlj9FVNHEPmEU6lFFJbHlyFzZTti0t6l567KtrDqzFifTORCo0a2JmpZKj7Mzhj/Q1h1Pw2hb/om9mz9mhbGXkPpkBa0qYqOLiMFT9HkWCNVvj4DrqsDpSNioeyreA2GwCNi29PwQ9Nr7oh98ybmlFKtZvyPiV439ERku7lbMv5H56EX6yDx6aidaDtHEKASWZ+M/IVW613IxwSkyjBTVYgyh6lr7mnPaVSOI6E4lLiu6kEq7Fph2YTunzx7+js2gfBVy3wQPNxRwakH0YJV+l6NTqEufCn1YIkHtctX2dSC2bZ7vI53DbHrhZDa9GvpiF325FmlDTyLNm+Vjq2FEhhGIL17CrOLZYHuwHvNZqt33GWm+OWM8yQfTTbZga8DAcBxqwvibhCRwX0essqq7xYt20AIuysbZjIvnbh90HZjPcpH5wXdtYG0C+5DSdvLQY2WQLBjGI7i30KyfXM+yAJO2vD19laEEym8uPJli/zBIRH7guZ7UIjvnlJlAwPXWdcv53BSkaORzSsiiNT5HGfCURNzyxYSMrJokGpbYSlixyE6mdsfajGngR0ghkAXDgTgMu0NwUaroY9N23zq66FCnLAIALmsYf6zr1wzpL9HIB329ZZngDBhxT4uEMBUqoZ8Af9yj0/8oeZvi6WCseycg7JZ9opIYM9k0g1fGYOkTvnBzdJcmuWl6y2WiUkv+4yxTHLreTAL+1XHs6ZrJhYEAte05AbEpJ9cMwZ6hdOPIasXyp1R1A2SJmGixDvvB1dN62kKMDeu9PtcZ+47Euv03LKKrddcQCwTvq6+u02EU0TG3z4afYQJ5VWQOd0c/kh4uiCBAB7kPfhYpHa9koF4xvSrGnCvCd6IW2Wi4S6xopAgHDnEho4Zyfb4/PHXTRe+ZddCxbPMnOzyzFxWVCi4iHUuv8KIlVC9v34RgqZ6TV7KYwqLuqtRVsdH/nVPVNW6Twyy1E8Spm5/GCLDCmzWCO38eCbXxtqHMxqQccorUJPXsDgePCVpzglSnfaQzFj46lNFWqnuyAXi8YlJ1bhyYYzu13DujBhwyA9bxBmxnbVNOmPuMjy0OS/fTJxlw0bAPPhsixLpARkaS6TSDJaOFz+jrNKvNZmvZOfYKoOEW156Q+qq2u246FY4Yc4KlEslxIk1G9P/iQHY0Pog0wUmXQRK/ViYL5wECS0grC2eqrVpdzs8Q70zWkMmXZlV6gIR44xjeJ18ny/YeCzPRBcduBKv7wSNv7D4frrb2mKHUjWHeOsYSf9k4SbMoObf3+DjyBI9+eFXy59v8/vaZH+IX52DWClekRCec7hKhgZa3fKX9s6qry/fHkWNKB4tHEcQiiN2fNzaap8SbVQOyZENheeYYWxcvJeP235/d0+WDtMavXuZ38O5H/t0p6W/l7IuWJj1hjGmbH+LeLi5hQT0u22YTgWDGrsXhLv9agCBxB7LU9ccgBJXzIQKmd6vax9+NSTuo/2/kewi0oZKP2x0H2vNU5+ScUHk0LisCxmEZpSzKvwvQ92Q5pZHWtjF0xpVTj7qGQDgH+rxZOG+Hq+i5UZAkOmZ6qWoWDTULK8M9zlenP/oO++zPJoJYJhDjLz9jtYC7brtCusazPMAJC+0Y1OmZKuv4eUSmgzVawPn4R+Q7IcIbxz0Z8i0Kz1kGhpJWBeWkZ9IxIMhVaWAqjYeM9sXAQksXOuW5LREZHImzY44ExiX73ycUW3DLN7GytfNNrWS+8QgtcoBPK8HQCHs76fwkoACdenoumKbuFcGRHYg5oVnR3EEButxiumP9fKtb+KZoXkkVpHrXdoGhfM+h5yS3A2T90SkQP2c/TwZfuRFpmoV5AKIVx2704c/SQej7NtZomaidwxNbCPCPS/ik49z2I5EnOzlnn89HqlHr7IdU9d8bUhakdaEfin369vcFA/PkoLyVChhP1Vunol8YputQNMHh99v5yaVtKqVWe5ECbY5g+eFvJz1vbXla2NrWQQ2D3XhshtZy5K4OCJnsKZqn0Vv5ugovTti8/vnOGouorjedI9izNQr86YkqWHA3OEesxQwSg5jRrVU9PJt0r3pabLI1whebqnSf111KV/5hQEoz/FhggQzlXpspstuUxi8TBV0DtFzcxi5qwgehYRDX2HK7ziszxqUrkYFimLLl8qqYO5AHJd/BZFU0pDhWRw3q5rpcDyFQnzp+zUI2D2ika4pemuhEb+f1xfFDekI8rzjxuOjE+eWvU+knc96jJ4ll2iUkci/L8nWzZKLc/Mkf15/9MjvFltDBDlBbqiPK8X2c7m3JMCT6/i+eMDfzutG71kp0/SF45Wn2Di9E8j6C60CP4RgHv+hj8JJH+hX1rrjH9x5Uz7NgvvOXTgfYR9pa1M4YaD0jpxtXGMeAB4tANyK8rUmnPvsf4L8JomjlwDR2A4dqDu+Xfo3DCgIn4VIL2wSYoBRlNPmrf0RjCGlg8O7dBmyadFKnSXk5lnJhVICJmUm2n47xvLOBbfniXXPJQ4797WhYqO19OFaHezN78zxrUmaudP6tEjEtxoiJhYAHea12/+AvynfZi8Yyt2ehekR/IppO04mYziT5212SwEvp3Lc76M7XlGX16xBrnJ7uEYN6EgHoDNmihzxwIa7IlvaxUSGp6Ar+geHnVRUNdBcGdrBfHCmGa18zgwosf8PMjNyDSyzndKDNITOrKnPiaQyggxGPOut0ZxuD7nUKbpPZ9tpspeL8LqYSTReheNgRifLWY8UzAS/WiDoHQmMjuCfP0XuQc0gwBz1argJlyfZOweqAuDlX67btrUWaa9bGDrNgXQmoQkldSFHa7VlR4TJLN5m54iHA5bUB0nA6KtLMeX6cbbrctHwbWtIPQ52Yx93fRyXJbbngRwqYrm8BU9aFaOjbhgctsEo7PAyiscgtTqwWvoCAQmklgJhOaOxvBWseZk1ov7NSH1BavtAoQlN6pigbQkHksDjh7TAmLj7ycoisH8gt0t70xNpTHCVUoeIPb2Jp4dmRm5RZ5wG+UdczJ3bBRFXQtXRGfL1Mxt/fM3rxhLCHBkoB+s58a1+nzo+1cGvOlQRqLU3h8HZbM724yTxbSR0klP7fnmHrFn2yV1UvQjpRZ+mQsJCot1cEmUu67ZO4F92n2EUMCToS0SxG1e5JOyKO4mG35EQC7fwssruvHOvccDv7DAb3UMu5tVIAC1bkVVzC1m7XG7ueDSLq8QvSBJuCVEYVik0hwL9HhDlL7vcyHj0c8lyMdWFWrYvVxXuyTba0ZUUEXJM8D9lUymSNc8nQUBo7hf7TDv1RhHq0xdOdql/X2qu7SGHm7ZZjLhuCC8vlut/biYV0UvRxRcbC4jyUhhOoPoKWBifGSmDiZ5+ztsYBhImJD3fWJy76n4Zk2iPc6jfJLGohrSQqmY9MPG4HYlMFh+pL7AXYEUNz/bRvi0mg8fOufE8ArU0icC6FcbjFCqYjw/CJLlcqKMZj4Nx/TDlyrotpV8CMdldbpmQnp65/1n0tg7utYvA7u2HaD/PKii2Fk13+HWTH9YubdHqkLqcYxgoMLPbBv/DU4oJdf/a3rPOVCQ20Xe917iVQsFKqpHFvZMgt4W7s8lRacux7PWW1LHH6+ET4eQI65otoi5wCP5hBw41Y9f2KHPJdl0vUy0MxbyNxKwu591W1IsCY89MliuPxNHOFWuWsnn+OTGH7WPQ3BvXjz2/ErnK/HxSo0iHH3meIYfBURtXoFpHINrpcq6lh+7W0J0iQ9DC73G6iE3e7D+miwog97KOLtgeUXA2yDbx4GJkOm6uBpKAv9rYFFu54qJqcr5Z6hbUvX/Mpqd+iaL1V2eQi68KJBjrHOke86DOO9lah6YynzUSexFUm4o+pjyonTi+MaAnOQVEyuBt5KfHlF1YYruKSssGIjnVJbPfkypf42AZ84h2uWrAbyIKlT7meZyhs0j0V7+d7vDgBMd1KHsqfWhzB6NCshKjJufEA5Qhyqp2J8a/QxrGMCfyhCXFz7xuxfpvYO+Sx+f2nw+jlw1ND0/AZh0Mn75EdD16nGZedujZSXkTFcxqDezXPQd2g76wE+6vd1C4Qh+M+b3HlKFeeeOt8RbtMrL66nMUJR+PJwVTX8lQEnMpOoDSKKb9bILMclIfHs47n2mOORNkSqiuiSK8mHYDgqbv0SDv4HT4bUGsJa9Rjy5fa8d6RDd0/6ix+mEfmjtXR/WyIX7tmOqT4UaeVkbXA/2szzwrOYJ6htODQ6gR3/0ywRXpOzqQOXfT3YOLNPPeqWSp0AkLcaCMGdYaysVb+kR+YIkXkZBSirumALhlJileoAo2GEEZ6jrUKQeP0bN9+Ty9TD/WcVvGImkLzYD5J+8QNwRkethiftmxqlmU76kHa5e1UCVxOszM+M4MjRssQ3XzwX/SKeT1Vp64cvXmn9BsmFAe+/XdcIZle4z5j03Gd/YhoXzlFPRUgR26xetm2JvkUD00GMUF40tbFWC1yGPrHDH1WkGUu03BWbcn2XJQj4a1vWaNlKUNUi2LcFajM3wpT691JFbaOvvGBQus2yNIt6RnwgDCIqHkQ0120Q0VASLJdosYh5i0y67uUQtriAGAZH0iyWbXnRNBqOLU8JuB3LQO1N7/ZHoeviIo4N4Ty23b155wv4PhbPTkS0vNFMA+7Z91ht69lcfkgcu6+vV+3EjG5/WA6FXSoq488Y6Yys9L5iObUb7+f6O6jJrhMlpFsIx7RXrG8prd7YOo9Qb9zWA6oP1FEyFAgMCP2OYRNo23UD+Z17rdGowBDe+Dlu5RtLPjMjw1M2qCHN/LKXruIbXp0PDcC3locdvK96Rk8nMeCb5NiGVPVR40kmc/fd1Zc081AqlK5FgWZraimxZsLLR8dhZOzKb2kU5acQfRht5yPXWHr3mXtBcs9IK28rVt6Yl8qVeXr3e2iiWsiMY1yLGoaVDKbob0IUpwRzqcmwI9Tuw8H1sK8z7DRuO8S2OiJ1y7eSZogoumqqx6V1m/B8Zhz8QYLSirbjMKGmb/+iHDaXU+9tvubxsYuL9sck1onEaHDT81YVtciXaq3Uvm1cRhPMV43HUepdzccx9KobDlDEguMsRtfObCfm8H2Id27LctrfcbYGjkRTTQcQFlywY+sYBHA0MVeGQlhazMU6mfLC/w7PrH7E0XkF/1c9H70yxwiL85Pm1jpCLHX9vnONWwEVRunMKH5Zwe9umww82VNOYfItX5K2ycQof0o+GFVqZQyJRu1U3V3RMSw9jPml3Ds9mP8RODLRYpRj7tL4uYdBhpxGpwpZo0zcz3n2GkdKIWtp7ccgjnsXSTCqgTjKlniUPvpHnMLGNkaehiGnzzYN3VJv7hESOddmobkguzAeeiqbcuNr1DKS+WvtXMRo86Q2YEmVSZAJ/s81NZFS0GKaH/yWvRjb5m7ZaT4fgWC8eIC69CkAm3lOpRv72ImektmwAl2PS3lr2w7FpftzGSP6vZ7nl5tGFddPdVMJIWySY5aWVs7Wzt9WG4r/WFHOz7O5C0xxdRIxqYT6/w56bx/fKKGNK4mDrxGBmrcVgU2fbkWSZV2y/VFri5ANaigW8CsYoWt5GZrZumlDXaS0j2/0s9xs/YTkJ92XJ7+IF2PGuCRlbUSR1+H84JUVDfyTHxgEnLiD8Vxf4qiXKLgpct7wmvv7mzCw4uolpXxKA9ls1sntirvq3UzTJqjzvbGPSmcUQISIuPehfOrwN/HTBpIP2zNDQRkN04oMuOSF3DRONlVAmfmgB5UmCwOxwZDxi1JaaeZQJ2Hj4gXI6jCyLyH3hwNOl1AFr2771eWWSk26s9h/UPWL8jte9jj2IBgt15+8cg/TE9rzm4IfDtrY/BAYwBcXuwefvl6XttlgTUG3GquixeUwRPYWW9hpj6jT3XANCT6Qj8wKGQDiPcNqVB2hd1MdipMfvjm1ksoNY1OnsT46jZbQRv+4QwITAhD2R36fVAlVvc4a4ZZHPHwaKeQWIDWyZqjUm3rJHBo510SXImR+RYJGnNQjXGauDs358WshBxkgppJ1gh62q4/ISUgOs+/vjHitftoA5Urfp66ipzXqzRalRIbJ6e1DB8ocd5i4gV8ugz/HthvPMI5WACdyw0K84a3B27ZE2tgMyH4Abl6M5X8vSryciUIeXMybH3z4wNVPJjhz7I6fbrG+CF7oJK0Se8FtCbjC8B/1JzF+Gx2oDk3siU5wvDNChwwkUHRXfS6tzBnoJSR3WNB599/UnJAstgBRAkFUmDg7JB58TQj2NFUVFP2RiUSDAV7DH5ITSsyW0gi7YaLj6dnyYd+bUrChRuRuGYcssfiJiG4Ck+S4+hRdKjH39OclqyJK0MscFCP42DlIg8YjHMOQS9dBpYPkohb9HaolMsaUQ2MqitN7dCPutVxqMgIdDlx4xhV04PkQftqi5fXpahSIk3Y79/npwRjjVrUEvBaT0p1rcscmBRo2fVqECBLf4TeA31rWGYn0jec5S3Smp24JJA5Ebgt+bLz7hqecXcYSqVWzhUIw7WqxvZYtwq7ZRUvcqfodVKQyVDfRXLSuFVkaWKMFUFz2P73d8Yg793+BxpneLJyF3WhdSwAMbI8d3ojqBZ0GXpWBXegry80/k26+Hr2OV5IbUoXwzdmgXEK6mDoM/+6hgWr4kx4Pp7yw9j3uN9iyrK9iISuhXrT9Z1PnpY266T/zcPj71nRvWmJu1ya7QLVT1pkQPhysFJE9IwOs88Cl1BgsaO39PprhsT7z9e9ePD18IsikCtOIrUrzuYOsTakBsSViOByESmGzJoMprhUXjXDbVsGfz9CCvJO2E9abcDijEYQMRXlM7x/KqtiWPez3HcPd9QKZ6/c3JSwiT8DnGYrYW8DT77wGEuX0n5NZcE9YCF5aW3+Ksn1tSpebFt+BgPhqp1A4mGNVIvvHdZ6yzdifgJjjgZj2CYlNjNhloB67U/akWA/HVrOfgfNGu42WOA5uFFDB0B0hdETAoZlx/NKFyCI2nQN1gaGksuZEtG+U7RhwtJ/J1gilq5gTkdyRRHULe49SYuO6boUMmcXecUlaJqjPzVAe6q8nrZv/j+98JJz5UVNwBFrmItgA+2JPg1TbDrnPugcsOQ8NQQ4hzD6LoziHzgRTXIozthwnUegSus9Dwje7CWONKAUi2X3+rj3B5EddD56ModT0vxav//tGU+VIYn4Lyokh8ptkeaDghhjVRxkxR7/Nlzv8aB2ndGFnTPThcONlewmlFr6Hx4yJs3zNZV4tQ4oClQZuDt1LQpFvdby9Ezqu/whPZdo/eb9OhcWOk+2y+x15bLLXR6DZO7xKqIE4pwZknp6T4AAhqvDZDpuATWS6jW/bMeg7XGb9V117LK1VFIzG0HEkJwrySUrFdM9FpMNwsVOMO+wfRpna8ih0j0x8MUaYfO+yS/ubrwOmeeE8Ri5lg3dV68P+XyGj5odJm4YLvkuYC43sqq/d9/Ps8t9HDjK8WAI0b5R+kE87vuQsjv32/5H6zxf8I//zuoBkaQVVeeyLMJ3hhirq2rbJWYjN6eK9r3zAvnmLsZruUK71Qk0gf3QPgTfd9L1Z35aZKmf5/V8HGBrAylHKDPqCMy1x+eawPOoeMKDxLSWR95c01EpAlkdsspof0uZIyeY5rMfXyz+GbSaEa3m70RirhssqRMvVmsXisPQ39d9YY32cTduil65I7FKfMC2AiojmbCyLkxe4WdFWnrxfKb8OymJqzfD3+gZuwRzFMoKnBeRdGfFZLktE0Lb6rGy6ruBLEoFzEuhQSHoADYT9k/D8rKmpYG7K7CdvAD3PnbhayyECP2yLBFyRsyr90p1duzl3avm5K+H7sKJsFtgO2D7JaqPMR08cyKl0l9BMdj9OvDp33w7oKqpaSuNuXUPxVzg39KdEfoA34bcmNllOLKkyLG7OIfxYfAd2ryas/YfLoiNoLKP8kGEWD6XaiNT0Ul0etn4g3qNhlg44UiyXKu2acbK8tWdhRr6zSxw4OpXoggIQAMajP7Ho4Ivgg4DOd12MexC33QE0fyBgzmCXxDlCc4SdXFk5fLBTwoSRbNxIu07tZKT4ntvbBiEcF+FtTBITOheAM4eqwDKziDfVZ/laoARsm/k8XkRRV6XUgmJjS9dQvc3+FUJubhdxQMEgDz5MvZOWU6vxRY5HniWZ1lhrBMBBt8sFTm19Sjt3KXK1wiM4b6Mb5WIxK4JGOWMYnHtVYZIo+KDl0i9q2r+ZrPn8v9myRkvnkG503vZnx0gBnRSHY6Hd1fb4t7X5VxTuCkGicBel/f8fsKgcKNXM3rMKRoPSpNg03fHOZ8Hz8RoR5IPiLrA8zwJgPGi1m03tKa6RA27kx8DEv+4yihKh7/wRH3y5evBJXSZiyQeqmuVE2hGy21DYiud2u5/F2QxmsHQorScjr4B0m9b3d0SwEMtKLoQJUouzQ1GMo/Fr4/EqKWnEJoT8y/fetiTrNms1EzwA/4c3Ex/PiSbWPJCyXAtmgPOIhG7479iTaVNVksOJRwCtFD7WQHBjt2AzECWm1h3dKo08ehp8t++EAkdVV7FxAXxakdPCerOk5+QSbc/tP7dDCaAQIPzK7DNuYiSvWE484STxrcKnyCF4CIIYpHCipMaXvSAQsBymZuTkm8PWL3oXWDW5ZpL6/14mKnR5hSLjhhxM0p8uQoaC0JqN2nS0Lv985FLeK1S+Gj63oLQVc7KlSBOVxwsh96j/TjwEak2SGzaMPts3DZWbIDBCdkSvcjSV3pFRg4NIh5ii9fAOCXPxdYQX9y1ytga/GTl5/CF4/z699LEhgc1G6S2Y0NjKYrH88ArDgww71OIkfUm8sX23hj9++zZX0g/kwj+c0xn55+IN9r+ni+hNc2Rwm+q+KG7Pp8yuPPNjRUTWScid8pe0US3zXKP9Q0wY5xl2oOJks4i2ykVDvbToFQ8T/jEfcEbio+29aMpQdnwYjZksmrm5dxaDLghADxeOcZd3iG9eDhOtpLPDdBFHc60PLhmigtGNLcFAASZzFsIfccWFIkwCqDKzzIETXd0Eh1FarU0KCzZr1BHodE9eSfn3Rssqk2ezgZwGKbmVKnCUGeRlffE8yUogFjmVjrNEaI+ullp/mK1XhKkiefa9unBO8SUELOkYhwMmMacWZ1/lAsOdplZk80dnwvbm7tps+LHHxGeLUCPqQmyo1L8fWjSKUeMXxyoqvmJLrb2MUG5gO4JxJ65gA2O+v/7HqL2Xj1GNNjJxcDJpf4JhKXN0HHhp/ecAWI0iir6HVjXULOY1mgspSh++zFcWmB/Se7tPlBvGL8aI1b0J0BFZKL/FKB7BuhMc+tf4cQBlS9l+erAj0GmK+QrcnOlwU9vhdoRidgdgWcvBKPMrs4KTO1tZlf7A1ZgCCtGzIYwOGM0iyiiBvn7Ex1C+xWYJlr9rvpAQvi+gMRUvmJImhxWA5nm8GUevSEgychK/C8i34cuNF5aeyCOh3GUM3IOIFk5hxlrQdhdbv97B4+XXcYXrMlZSjxd41Mt9+hb1bSYZ4mF37tRp2VnqSLqz8OTajTcWZA1ZTWvNB7dFlAx+4JfKD3EtaCTIcLmoVbbbiVlPpc1y3hulnTb/nlbgr4V7Qs+/rig0Po0OAvJuQ8q9hC+KlrkaeM8uey5OaAtUVBEhnlBQtlmjrj6wQw7pSxqQmjdlNeR8wggzjWj8NUpZ0eR1CdvILqIns5KrSmR7ONPZO38CaN/aBUdIEGo2vzQ2LsqNSwNyk8K68cQlks4Zz2YhbRCjEF1S4bfRNaR2LE/JEVZdIuJDYV7olJZWztL0zQHK8VkGfFK7+3iMYZwBBwIots8EovWxeuZ6B1dFZtnB5W8/4dInYNikBwq08CGDlK2MM0cRBzaCiQ1M6bal7BXwgqBDo9YKBDSbIzLgsIORFt/gpZUOqTGkGeuRtZwDkz4jQ+A1DxOXSrOElj90kkaS48NbN10NkaN8zYkYalfjhc3QzXzXNuHUBFt/6c70+slAGDS7WXv9JWLroc74QVIJg/qO/F1CwX8nJYTDwSn1qmgMkZR74WIcktnAeEkjWaFA1ataYpz2BfapRIkGwNd7QQrNnosw2a1hPAkbVtxWQz026i6NKsUfgw7RrBg98SbMgrOZeBe7RN8xt2SGgKzCXKq32Z/dYu5yFvRIXapRlmXVAgtQTZ2KMl8TskQfJAYZyviIiGt3HESQzXexa1zaxThrxrWmMXGyj0nSHPbJkGvep4Bf6QgegWDvA/dQmas7mOXWq/YUZ+RM6rML3dP+ive5gOE9HklysBJNxPx79wqKj/gqXPBMmaYjynZZBZqdNQZ3WaxeoxL1MNiNLZGdv0kn6H5TRU3cuL73kCHYWOellf8kXffGUudIHtRxUvjUKKgn4BauKD8IWny7plprocaCVm6NuAnKw/VJ4r8q+txqS0TYwe4QmGFMY5w1i/1TB+8oIzcq9qb0+pOQ9M4tfHi6I+9sw/jDEoGqMXuyPkDu14zf4TJ3l36Hg8293ZTJ+7zS9M5dPyGoifNPO3MTBAaiD+p0N6uiFaAGLCYMgAKyvBwZqMMhgm4lyjIoXpw/seSdRxlqCKlEfKeJ44IO6jI6yHY7hJzXu+hx5ZGF3na4pamaOPlFHCqr3RXJDVKajx//WDrqj5vfBc8nGIXgICovvi4qDORJO9fLEHAG1s3R1KjwsJDqv938McBlzOHi9Gm6mFuwo750HwzN6hB20NyxaXYAjFHxi3S+eo9wtlDt36fYS4LlcIYJ5vNTBwoMpNIPr7K9pMh/3aj6RSgudFrb5BhqPC8Pbng4EtFagE6LjN3BOz0GCk2Lyag+NMPDVCr+dETTjUwlJzPyrc8mXoNpJ6CpqKLckKq9BReUjCqOTZJOnGr26eZu+9vHPwHHH1mohbu1ZhZXWdAb5A/idbRBC1q3/b/+lsRLf5cedRD9JyLYFlPtsecq0khhzpAL+QumIqhSI5pZ7F4LhYGL4eWdybvMgb92+hUvfc515xQD4pB5ZqafQTJTD+VhTr0QyDKO09/spw3IEZOut6ePIRpgvLozTdslqHSu8Wpyj9z6nJrxVQyDXKaHRWIJp7OdOtjlwMPE11dECIN54NiALl4bxKPoNbtIHwC9/85jQpcgJD2K/k337EDsnSpxINoLeOd2a0udznkOEuRjmeKAidR3NbqcfxMeYuute0c4nok4QR4gojLXNgwHvpbnW2p0d+fWJhrSN0pQ18YSWpIsg39I7yPJt/vKUzpXbyDi4WFBN9Z62omcr/akPvclezDlDCSFqs4mfJ5WtU7bq5ClSgDiUJOF3Qxehdqogj7GXTorwvUKIbH3ZUn/O7nihrwOmPyF0kbb2dJtd+FURtY3x+c3Me8QwUNr/Vc09PH5Teu6IEVERN/bZ+mk6PAzq2ScgNH27z78g/1ilYdqgpUOACQWMliamnD7B+ssQGofbXnzXzvjRGpmHlXW3CbbwG3WF4wcxzjIar0J4r8QihpZytBu9M16fksLyYR0eEAIc8gS1KgVm6xTQv1ryICmnYQA+xzNCF+K9pyKBY0Zw4qLzWiqpFN0HRNSoyMSLmJqfXX08/iL+lJIfiOAdfhO+Mzf+0YDrzuzNHxFtkBKLxeqTOWCneJ4XBS3E1e95t3xpgd/cmnN9v0OBwfV3637NcNO49hTl5jnoHk8Q9nDX4T7w6dmv96zyxRHGyJw2e0hHzbP86TdMymyweMbzDmzMvqRJQRBl9DDvNsRO0BqI6/+mHX6nsDPeA2Bqt4i5c4MYq0IjjkcTkyoJD6oQi2o46iTnh6KZc8h0MSu94d2/9d+HVeOzubB2EbisMCXC7t8VVKNTXEPr1RW8u/T19wd4tPmLJwMZz91N9+TLHYWchW54gmTQ1gHZYOMeYCYsSxsm4u1I4XSD6SEnZtQoK1NQyqrBzgc4hPxaTS4+3zeL/nZqCmRwordYhsgfcwVd7zaiOCIqmMY/Q0jDl6hpjaC5IM3UfC1xaqnFXNFeRMhzcWcmHIndgOKHEmU83f4M/iNelXbe9kQV4hrZ+VjOVOlgBhO+edrMvdvnW5hLv0tYu7yUeTjaxGxbFuRdxGIzhvpfiTh9Hse0tnyhbtU6X2DDynkH2sh6PlcfEdWML+y8+vdSM7ZvawyOHYiNNm7ukOQRGwwZQ+LDN2kvvkCG0e1kCHrrgkJtxKFvAZ4AwodpK84mvYW6Y4deePvJnleRWc/C1P8TtHUKnQw6ob8TdbL9Cj6eoe1IpbhdHjxZeMhZ/+cldhHSUb7ulnYZgcfqaLtvgt5u9D71WLnwFaC6Yj3Tf+k4BATn07Ig+wJ2qZC4moGdvJQ69SAR9dVeYljygcp1XB86MSr8gA53SEY03vkfh+xkteJ2pocG9Q7PeWuuHQV9rE6i80x6cvGUIQL3z7xjzy258ptENjWmyLdTUBp3y/7zk8TUzrS8u3mbpINaY5naaTWc+wp94jrshY5NIk8754Kjl1pqLWgIre3lf0UYjl8eiUl0JXF4W7u1EB2PlObaW5omYUovvTsJyNOOWvLNmf6ammKqyxTwg5oUvI61LWuJJj1gI31CIdAnRhFzat80B9iwGeHESCvBsv81CS2pY/3dqi1Pq4ulCQaYJg1M6uQeSrRBGRGZSy4Qyi9F4GHpKBXnU3FD6oTLKw/zDrVLor+Xl5fOp1FCDVp0oxaOllDyMBuHu2lKykCOO4uHp86M64NDrqCTGesEhHdCjabsh2izl/f0nmcMzbHZmGltBoFhz6zSATccYuer4bvhzQeY6VfSNstqBf9kkZfyjlC4i68wSWmDVtKLPCWicc9grYJTAV3C+M5GxbvFeZMOzagF8JniR08lPX/TTma/GKkkFTyKnyTm06Qg7jcGPjfq85ID8WRixDFOu8g1awTZGU+XR4w02mZbFTT1Pd6Qajg0yG8n5BzN3SAeMXpyt+mFDfefj5Iy0GJAXQrk7VYIUFYCqgfYs3Oka5MNhtfFp/SW5hyjEWMLTIMJqTU+FGyUa2IvDZRXWj8fou5P8NTUjs9HaeaxRbI65krtePjquGtu822yoXwxHYBCnjmremn7WRQS/Zm2LFN6KWkIOxHyTdg6ZHGzYo3dsYS1flNxmqaZ8rd6BlI2ODGNVzzv643ifD/aWVRkJUhC6grMQcWm421LtHm5iXuSX02+tMYasvmRzEsefXDbHbuRyV+oVFTY7jreCKcsxReNxJgpF/ht7ZL20SJzGdo1qks7SEHft9SyVywgcYPSBqx4kGltuxoOBqNMEgWt0hTEt7ZGMEbnfBw6d7dmd+JKe46DAGEvbNoaUma6Wrfh7p0BD3FxhH9u9WsEXnOcrFWgC9FWDJ0pPj+Kuq3Ib7TNsDnx/cUppu/aMchmwlwIs9bpLV0UDSofjFbO0/tEeM5V0vCu6OE7VXQi8qeP8bk4AkW+Q4wxku1Y9T+sX17tBmvmZxCfdLANGWadRuc6scZltMnDEuqNGvQC2SPBc0c5l2UPYmo2i3TdZaQDSDD0pPHrpRwnfM0GdqenMAL4J8YN9576cPNznkeBe78pJALPddB7iTB7tyVlcrLBHXsbJlrhCU6msu51rfd9SgDJ0i/I0gUHs4uOdvmTEKvCY5ecOzFSaEoOtIYh4zQcF+8kUcF0pWDkIqF3vaJMGgOtSiIvcYTWof4wqez37ndo4kqTAwqsfo/cVPkVW+hj1Gr2uGbbDm7onB8Rc4Go3C2aVYQO/KTc+qSkTeC2ZgLdMJOqgKZik0fVzibz6zts/V4k32Kfdr4fO0nGb+gF5KhmVDVbCR/2wyOtWH8PkR21FEFSfOJaexi9GSFSnBpLMsbAe3KjPs0KJ3ZChgnuixutuAqI4aUIgO5GBopO6Z/qC24Wi+AsQNDaNss9ojYwS3K3NIyZtt/QTefxWhvxHbwN9I/Mf//Ycs2Uj5pq4vTjGLf6XLTiJ84g3IKPpxPS353rKBClSk/xp9lZHuJfzcAFgFc9NNKOw9KyJaZXMR+r+e6wM3U7HqW207+rcVwyMY/yg1FUTBDA7Nj1uEQvOcQe7MF3U+jXB32zMc6c8Yo4phgbtz/Jjp+0gC+uLDsrwa//cKkUrQbDNIa7Os3dFM+mbPTrEeaKPCcpDdSxGsjTIXqat/JunChphmVoClVqIVKHsRDD5jLt20pu+FwCI353mgVQ8DmL8TNzWk1hazGea6UWfZ4gcqcAC1AJ7+vInKdPDVmb75MG/oSqJEtCZGl5yeXp3FFhXPOUKWuZ3XJOaRADIedIbqh8wGW/vNxw6Xuy9kZ6mBdE+MvWlUPSuRWVSbGoq126Q1qHnZHeyiXZauKIYBwlaKloeDaXbBGAI4NrkGFMkqp56aePhAMkc0YAHDLPyzLHQlnQNtjrJV9fV6Xb+9nc/bixjk2XEpdckhovAimtKn3TGsh0yjz3UHCTEeM8Glffe/0p1uAjQ9bbCPzktxV9DZTjURUz9M5DecPmEm4iqZFIstpPY4bpl1dbc+J5NeZP/Sxt8+vxJg8sIxYevvZWNeSfydlFoqt8R4HOlphk1Fr1FTx31Xspz0i44NAzshVZlgcaPXKIJ7gmrEnPIaNKs9jZlRSiT6eQLtBtAboHBWGyTuThbSNpDhJBs7U+tgYfl/4Wfw1mtWTqOz+zgA6KBbYAqlQHB4K39wVs5JZcSPLdZfzuo6ObXpM2mYgwftFbWRHjk2n6eufpG+nNkAQA0ZNpt6p7vKnDdUjOBOmHSHOElaNZ2hQk7UMDqzX1FRCPLWZsT+uWk745GIpcBqASPGfzW8PTIS+xtkop4FQmSkd1NiVPg84ORogAI5VfoEuV1p8KTzKi7i6KypqmJtsPsLnQ95iQiAQ99ScUVKQhFUw4qVyytukfz4nSQ4ePJXKwGGPtG4mnE4361tlaTAACZrD4xDp7czTdjBoVk+VHl/t8J/1L5517dN/3bUcnqkBXDPtdxA8eWS3/jMVKJyoQMqhMbEGIeb1rEnD+Mx5W8tJggx3UJMhPtnqJhHeu8os8TJyPJRbLMfv7BoCp3L8LOYWiA3BG0ldFXMrJqyKe0abG0eF/9ZN27SJKiWDzvTsT0tWfdx/igR6ojVJRWlGCN/GRaqQT/ZQoGfELqkDbOBsNG6wKPIn9SXojvohvNHt+i45FcWZ1NFB/iRutlpqw+dlGFHNnXDoVNgF6A/p3S+WzqKmeoHm4AYGbFArxzpdMWNtQX1kojL+1UQzD2IptAQgIuA1/5p8uevHlWxfPOFomnC/nWGWdl3ALMdGHjl5rwuUvI+UUd5cx6i8muWTFQ/ksNkhucluUSS7mnLXRQjmoFmfoNCbf34qvXWkLm7zDW/Mmwbo4Wy2+XsK3CvtSWTLFDYfSRyKam2zaQlOZvP1NWztk/xeWztaEnRd+uuU3WjYvRA7sL4THr/h1k/ioYoEP4JXqwzTZcXq2EE7PkCh7bUratqlLVhpMDIxbpoJynewp93clJUmEyWQvqixKlYS3SH1raKl4eAqen5WU5g/ZNs4bbK02y9XXvRChfE7h2w39b7xdzv1taqsfMMrGOUGOSnoUuv10mp4/RpZ0op41azBKwJlztBVbDt1CcQHu94n6oyVv1Bv7mOvHK2eZOPZRurhPt3SLama7FGR1QxyKJBj9lyfgT4N/w4wPWjLfcFyqCJDI5MoVedjn9K9wW9MjAGl7lWgQTdlUpfI0U258pjnQLb4QaTsaMjGfgwqES57o3t6vnxVLgGJ4p/dOMnGGN0rmvFHQGHkcF6Iee4ZOHsj2LaAOf2CqFIMEanDCcVDuVlH1YGeSR7du46dGPEMgLZqZ6BN58RQzj/VTuaQ2U7vQztqyCdyuiS7UfrI1wLogqXMDu0wGcfeR7816TgPYRmjnfZKs5RGPfZhZnEHGU6NpqHVUc8ikI9h/zby/TUfqw5Y+uSxy6BaVSWruj2t4e91ZYTYGNqiRRtenQJJcK6IEmPST2ICJgfIfwmNwjSYs+mCNEjeNnj2/tHChflIL7zUBjGa8BuQJvec69pEWBpI+auW1khTzJ/yMdNm6NHQFHbhR7ujP90dRHDG4wlhhZ+jG0WFu6NWbzE8ub5OAasm8LV/UZVXKGzfO0YWrLexAU6mhQqxowwV1pzV62MCv8rIJf3FeaX89daQETqynoBCsM174xJnudgGFoUgrRJWr/z2WjyjtWUGttkHulQ2hCs1gzyVe4/KnNNRiZjyLnLX3M8f1C5PYiFywdFY9TSZu5SKkOHDBajKeRbqkQnq/2UAMcQy+Jps2gOMWgmfmPG0SN8AcUPssmM3+/4vjHsqZ8YrkawOV8vrYJohEvQ0kYUCSpX584XNjn2Sx1o4LNJ+7imGsko+p1FPKzg6GWOfxh/64oLhuMx7CjqZI7bdmGXvimTYfIpM8Kfeke4GjiDPMka+TBLMugGIqu6ho06u8iHVWqwXq/yyLUYsb16LQPWHJPJ1f9gWBTP+sMJjjPO5b21j95kzQ1vsREzD8IcCTp8g/oQohjNS5I5uKPls85BLyruMUdQcgd+RpjcEQe160xL7ovCgOmngP04PWd6aycuitlt6QgRHSRCoS7Bl2GP5Ary3CyTbfDdKbgwJfVDy+oqjczaY+rhuNy2n5gXrUVaFS+h35ySkEPa7C6HiN5RvfTIFLnyR84FzSbuadPOiP97h12N891uEWDgspQ3Eo+e/BrmW/BW/zonUbETaJ8s42C0HQltUaZqjNmiZhLHpkeho5B35/UvABAJDokfz24nc98gpfg9HhAwDXoV+xRxoy/pNDQZewy47EtJagsT2EwihW1eNY8f98dfMVNtN1wYpSD29mYMv+rVNO9calJCJR3eeo3t1iBUvJv73MFrU2ST9wt77DW2+ZtINgTZhzqOJWhaLmyFD1UFIfZtn+fILEUkW1X4Ww0awIU66kM4s6N4ZHPZC5W1THof7EjuAjFSUqGrHFsmmpjYnma7KA2FhUsJ4ujh2fh0WwrbopgUgoRMYMP8y4uCu/4z4Fnf9RSO7RZnOn8R6R7dYjt71PkrD6wPaQ0A+Orfme2xJ/XZ4i/Jn1xuqIv+WOF5wxZb6UX/5Yh+aHoVyB+Co4TjheBO8kig3XnG9ob8RKkVIifFhbNUJHc1lGvprdHB9M1A8l1WiBYfvRoLhuGy0dmro7eBoo5jd0oBV0RrDMBTLkKfU/voBXWbP/fzWj2aEvMgiRQliDfXrbbdKbnhYFrdR3DcOpixyFNEoWqejMHFH9KJyMP3Wg1opQhH2CCkyAvUlYFLdi1PfbFh/g+kvkvQDsL9t51bEwL1Z9SE0e9hOZMBGlji8We+2p+eIAGJpcvG19Mb3hgl5P3k/Af6fLFQ/o+gsAbUqOTedCY/LZYpttLgxtkGmPuiNqQkrW9Q7D7BXF92Fpl7CEtl0s7BsiaMo4OHeP5O8vw8Edvj7NoG2ouRckgR0ictOgdoBW+3XFahSJ6qc77oY5S/8mK54BST5mo/5t3lG523uUWO4Q/uasuzukQi619WXSdNzrotTxn+QadVC3cESu7bxJ29cTluhzOX/1KlGdf0KhY7ItXplbEVXGgQSsiXHUDqieCjt/7t59W11ZUBXowqvLCq5Y67Y2qJslsdVrZf0weZsKsGSXicCv83HW/qvxIbFogO3xBDLXEvlSCd1csCf1MPmdaelzA0Qw9caO92wPHdjxYF4S+xgMDJ2nEVTv58D9Tvv7QXro2fzW+MRpZPVA7uGDeIuzNBDOaZeW9KxEFNupaTz/44lsS/kW+gIU0SEvvEUXuXIYO1CGO82jZdonYxWjJw3/ieco/6Nw9th+0v+b380XYAwI1s80I0nonIztASGE/+hMbb3mg4sc5r1cOS2awph3kcEfV8K/ASHXO7rPe1AG5o/jTZf/2aeOP8dXpImUh/W+SOtkjRx+NzNdagYfFcHDG+O14Fux/PqqJ52CmIEuj3+cqbavkHWiZlt/e6isU9WEgWU+Q+kooBdx80DKYYiEgBTUe9+qaa44gGfZ3LrPWCRP+3VZUNqg/YGmPHLft1cRghqTWYjrY1JtN2TYfYE0hJnHghNMd9qo7BYGn4rP7JTqoCeyIxwtgBvaKD4fO4LARY1fnO0jIhSBE+8ggMvD5BQI8Lz4zeoaTAvtWC4HqKbz44DTD0x59rGy3X18kEjosLnJ6PyKojDEu9Vozx4M8qdmeWwsPn8KGJ3wuqxNX8CGDqKYUbPDAPQPYXWtVOuw2kH0ouw9mAOb+/3yQx5ZgwdhRxkUouxijpiamlscu/VzJllKKT2hJQ7mJIislRBCQdx0F5wI7yqkqpXwy9ikfg05/MrKtB7LNa1IBfDaeCNmwwMNtcA+ihA3+kzgI9Uuwjm+onWXLT+AJsx/kqc/9Jzs/KkT0kmmCVBsQM/rPEVlU/4NI42Y0nnGBwvPWGwKSz1q8yuA2fxdQIOnbXMddjcdKPsW2WDb/btSMirnRLxkF14QPa9PTBUjteF0Ynyd3iinunwH4OQ8lkSeZKxeXbKxmh4IdOYqUrlNlxihOUV8Z0++mmseFAHooGCWguKVz1nU7fv1DYzUnnhFKcKjT086X2I4aFDKa6VbGWc0Q/+HTCZg3lllo083HkfzAizmjiVy6MIUmSxsk+/Zt3TMhduOa43xbJN/Q03WAM24WHSMKegFqSOQwCOmEuFZBUK4F4xP2fIT6NU3VXIudVgVPZmLgNcG0LeA3Edk+0/de5QFpFwUAO3+/u0B2QRHLyXU8CUxLfgG/3D1/WUNYxHYiprNuD6anaf+Sb1MzRpX6IC6EQH1sHBo4ievJRJEcx6TC++JYtMRC4uw3W+yRn1ljgueEZuWqy4VSt4X94XNsekFJBYKEUUBhIjvRMm+XOynC2BoyKOon/H+KovBReEeevojSEYjrVuKSAuhGHVvL4F2j3cywt5a/lkzpsysKJkRwnVR4jZH8oz5m7F3UPPOvOP02eIMdwfL18Ks5x0Z+NzxGFjbh4NQWgOSuOxIhAYkRJMuvp/Gg7A5nx5mu+NxH7xyQwahji5oJhBSBDQDd5/NbUHgb3qzL1hOSvDE/e9dxGP4skEDQp+/OmtZvz60ZKmFY8YPvVZJHUavRW3sGmLWLIQQNyhIMZjE1X5dN5/gHulo74pC691bDVz+4QpHrCxAHM7Nv70cC28RjceBBQLaonm0vXW2cn1uRlI/HaSnwhKrMOVBLsw+kQr6lsFmbI4rT5HiKnf3C5v8G73lfMI+Ecj4xQWqGAKIFqP9Hg3WoIHeU1zkaqA4kyOYz3WT2kgl2/BiPhwaC+VX2BsfTd71pjn7ZdeFdNEjASxb4VAxII2WBV3U5ne7muts6ZyzQkYt0i0+3HtzzlAA7i5TlZLqZGWW7xzNgm1/9Zu9sNuB8NqXEWu8y0OHVaCfeo0k1TTiSb+KFSTUhgMWf/RHxduDhuhlIlxRW8dp8oWHMYiVKD4LQGw71mn/RUUx8uwOoYNQSC4jypDx4RHjr+8Qae6tX/VeP4XzQVLeXjSpfReDSXKgHmpKyAyDoBzH7t2n4jyHyOImI7bl34Dfk4tDsb3P1vWlSshbFw36uI9ZN2f/caVJxLSPuT2kQPy4ywUEgf9+Ka0M7+FNzy6oWZDu3QGjK1y2wkkREAD+xr6AoOJuK+KbVjtPCwy5dInsp5a5XMJbFrD8lannOs0brL0drMafyJYGw5cgIsC76LwwG8U3JF/J4gwS3fFjRAoKeOz1JSQFhPW98LJvgwevzh9iB48Yr8gIq7IY5gQJb3DU9J6H7C5mReLnqIrjh+TBKVVOEBHSdxdh/OqgHVwX4ID5KR6c3Ch+B3GkOPpIwb+QsLg9mgXleRPVQxE9t0ASjR3olZYSYwwoVs4GxlZO5O4N8KWkOfrD6PNc/p1x0ZN4TedrRbkK12/5qkTiNNEwQ4To0PMqZQJhNkMh2h1z10UMSqvwroNIrcPDUKUbTiiirXNhOl9E/y4CC+L8xqI9YpApr8Ld1JDwCyiNr2ev5rrlUe/thHQHRSshD3ZvIv/hiQBrpsbszYnWGDg8CHneUZvYP2wjB9AzkNS2gkpfQNpGzob3lQSsiP+HalTHc3M6CVVwinllm5lNOnbfdFdkBhFox6MSjKDTGh6Eei7fArAw1uIjCtPFpENfxod5AXGT4Wy11IwniXU8aLaXNC4qYMKHu3CQLRHDzTWXPu/tkAgdZY27gwbrDXZPvK2Xyzgejn7aflG+tqUAku5bAD1oFSG7duy3OLAEyW4J2k0gDMicz9AAtx50bD3qXiXpqRy89ylZRIymS7PXh5pkn8pAsixNT+53ax3F0X4ifR7tzYdOaZaET9C/ji2eEWvbJaVAPPszUI0WoS3vbEdpdpbL8VvUdrVUNeBCzhFKGrIrQYyeYwub0UByerLvKkHzrVjSz2OEHlejO3FmUczepCB0e211ovdADPFAi6nC+oH775YURSYcmtMH73/FOrb4YBy94jS2k69bzlF3F35mYqwtOeoA60/uPBN5YJASRqmNpQA2EdMvK6AaK9/075Vj+WF1FcWZCqC8Z3DwuRt0aWUhA3EgNLSSgbJ3I0zXZjKyybpbnwwlUUKf2ifg6YC4BQPeY4n2YxwundYme3rWXZozo/ujVuf5RUTZN1CehiOLoybDWqBePu/lHMfCpbsbBs2Lympp920Eswj3dzm4P8yGxxtZmNCjRsTw/xqEyzA9tpoPRXtzDHSyRQJvIuG368h81Loqpdnf9dZy7ZR3E1hvtQ0T8fGGioDaPyvpgvIz+4AGFqJyCIyAGk9ZYFxYJgr+QBCGRVey9ok2Ih+2vdl5I3RQDKAGaG9IIPEMwMJp1BRMutHfjMT4mFPNzp65l7DprIGfo7aFkLPC3sO5nmSZlxP4wIJAeMvc9ZQmhrFzJNd31eQNNDjLwyXPnwQh7USaiI9BQzL1sxQuGrFoTnb3WKh6CzzGtSVG50hlbUfeP1TsW3cXKyJUXOZSUDrBjbatnFyCOdC/zpd0h0BzP5OwYreAvfBd/6auoeV+0Trk2SeDkBQPFB2tDCDOujqGz5kNaTDfInoakfcrqhb5uRhtxAjwjb7zn3H9UQMvO9o6yPCabY9yuGHsSuasUCrtCaLY3+qzqjPg4fXNMoXIo93Tt8GTxwwtIXWSnmZBNY+29CgGbxBZPZpwCVQdsDBkJQwsfMJz1MH0Yei8bvqc3df8vrLZMOp8t44w6p17K7VYA5BGmPEtK/28MFhXQ9E/+sUiEYA/6Wqp1sMevgk7pIsAr+34dtAZw/xaCj15O8ZI6hfzc56EzooIGj/uGdo4zQ16YxVk1+6bu6upPa7CWTJAWPwSpI6WXU5p0/NBUrbzJp8Q+9NMEAJF4vb6ZtKBiwNkPvlzLpGM4leLmB1A8ejpoORwtHoIAEWgkcxsIL1OD45Bpovw9mhpmuOnqu9d69DI8S78+PmC0McRL43s0zRWOm9c0i5VlvI8ldYubBWpZPUrYopGrS9wJt8BT7zNEHc1gG25DvBow/kD4PGcY8fsvu3WSn7mKjEuMNTFRdiczecCiCQYSJ0bWkUdftZBMF+uPnhDAkAKmlkr3BlSvLwSGeCFEQPvDqRnTBCq9Ha8Hyg5/MHoEcUArO+3ZAVwfxkIpUCLaTSLdrSj/KBcqSOoim7i8ALS816m1Rx1mBpXHUxTP2lVoSf8VbFKl+8MNUmYPuUsLeTeNctZV/88PeEJzHszYszGUxy50YpLSmYhu6Dz9ghj4nT0cxh2nDh9L6+bAfQVZsu5IkMau04ztwMAUvR7VIX2hPsrMbgQvKmk2kI6uQW31MeGosJKFDlNIqEHKjudsjCk5+fHLh5umNVU4RuxZpIvcdYOydJAOICkrKWZ5ulijzyntefWhibNAe8GCqrQYN5DnsahuNb13cwAGgOIwFikv1olzMAx2iAJP4zKjkQcfgnOlIcQsFCydD7zmKANg55eiPRX4pfe++JGNaHvIzYP1DwRvcDTpOfxlRs0nS2UZqPTxHPKiZpV+6ZFytO8fjmxlsiqLULpsZZIx5HVZyqseIEgHt54Lzs1qkmDUB1vKjYnlrqf2Kj5WMskTWlgdEvp28O8Q3oRhJ2sbhB5Sinv5bSWNPM26espHOiF/a6W21D2rpv9rlxswU1muK4tA9W1AYaZvd3rNWQcZIiBH8mFMXTXAdjzgMTy4xttCfUalarzSsdJNpv5a+qIcX4QEdv9Yejq2dnCurQXql1Ld4V6tMGNhmH34eRuJ/+pZGVGND+uL+m2Zf5VaK9qIN/tlNPjAsc7ViWf8KX+/y72MOibRx/NsInT2uQlyKf9VKpUBfYggJQG8u0MRxz0ts6EPyU1tlDnYAIoEqqN0pq0+yKIzGTUjfg6diV6WpUmigqAdxGM6eD/Gsw1xvp4Ud62pv7qrCMwnlRt1Ay+YGz4HY+ZGbxDcRre0IxpzDgaLTtsa7BhKacsid6Ly+R169ZS4AxZNtBC/GBEF1OCUgbGr/w/z3IkRaHjzAlhznB8+hZ6IhXG0/TBK54DDx5JHrFg3wzdCQfmbOzMB6vcysrAXfDttPCsegAxN0u2bG8KWiyJNAdtmso3RVJ6QWghfmjePLyxUN0n3KkaLGEbS73WnF3+x7dD3xvy9f3IswlqMUSd8dC2q9f9FvIga1cy1xTMdO7p3x5DKhFNdLRFM3ksKO6Z4yvJP8s96eSMa5CeYHte+odJT0vPvBOGzaTdn7rLjyDRUi1U6rg1NQEXRj8IDH+GpgccL+cQzQqQb6YG0gDYnwReTwxMQG03wKXU7TMvPtFSHF1/irR6ihKjjWy/MNJdlZaG5q2ffUNJ3VqIqoSmX9rYg6qLO4I/n604I6eoGdP5uBvym9mpqJkyoG9HW5eueCjqnW5jdcCuv5r4Wx6aYXOU58zKqVNxRJl4RFsYUPoO2fNkcJQOb46j4pEzrs+70lAo7uQ+/rkfMgqnvK0GdwpnzLUxFWTSxii3vLymx9tXNfQ6xWRD73KwSbrPqt3bLlRGtmyltuxmtiZK8M1EEaFpjLtW1okFc9+iAnmYCh2ZQs58mTUWMYO8kz1iFAoKAarfprD4BLo2/FLC8oHCdtj/XVO5zCUKVTfb3GDKndRmmK3xKwgsD4rtoy7FcJTXM4iYZRCSLX+HjnQPs5zfIruntUDF53KiLm6ThvGTWNpKt7PhGagTVvblJ4hn58W2VZQ2KnS26bExxmeFhVfghaywEPPyzugIpZ2sYRm98kzPePyFH6CqUo9Bz97BTO7k5cV2ja/k2onAQ1RDgjVpCIZjMXG6TM5W4CUd7KkgeIHx4p0txIDQp/kluTVpDNfh6rKTKRSQj+UiDRtm7Z2Zn9rsx8lL3l+TGYlD7T2cY3xp1A50LJA0Cjw3NHTVCPzCdm57Qu+cSt6upMNKSaCtNShhBBpZ+aQlkJigrSfcQ+vaQLtd4m30xnNnGjL96x3zfgbHHgdcaOO3BvvTomPvUkSv3C1WbFVM5nXPmvtgJ4whtkN4WyfGLhUhDK4pJ3a9q+yKr/9SXpFvdQlwlQSeu5j/FHyRZNXQV+7ca8JneaXyqOOQg3Y/oKCyAoTTNV5jpkJVEqXXkFzcxFDzY3yi9AvqOL5uv6x47Wdhglifvsmtxm2Z/VsLlnlYxyCnUwWzppgHdEXkChkTnx6KkJe5nTmjgmsbgdpi8iwCnafrgSLilwXN3wl3OWipkBbCts3ep1tx7+FwGHh+iFFy0bubZixUK7hATCo7uqBDZiwEW0+vubxJdh7aCgq5T8Bpk888LxwNOKC/TVfiUZ47eYm/zUHLWfMn7ybNafDO6FBftl7MHBNuhx8Tc1/1TDr98u+gvBGSyUgjH7/zq1RHjUiwxeT51hJsNG0Z9r+IQhebRjLDaIuMyKbaMvsJINPo2+3TAXJpUXX62+09b36GH+w7c4sFc8N+8fKJ3nrHI+vrI+8/OKkM4RUam8bSAKiF3avXmD112P1q+Dd44MBvaT2cfqVcPSWyKddlhQK5maaK1lqNvHxLXLw61/zrFTOBRjFhTBF4+fE0XtbzPeYpori3MCb/Px5B1qOmNNqZTinaFd+25ahaqIuh2mIbYvIIv8Zo0BzaI8kaclwuDpoOkCX5dnCudOz8Jc14am6nXKZR7Wv4h7RaChPs4vWIvKfMXPBZ5PkUiySnd9v8ng5FNv9UEthTTXnGM8XZ+jARbk/gRRy4NtCI/L+FmPNtHSSRgtFmwi+D8TceIv/TfN9m3yEgLD6mQQzeh7ERtlh924tNexZqiIXZVifwBVgyRHWEPKYlXCqfc7aIQabW657jceZIc6fAEb4dlVEShGaRYW6UMczcFVWx+mPBs+LIQTy8I1Ti/JNfVkbNXwuXiqJVS77YzJ6bEDM+qW+E7LKIcfxJEyD2REcazfabvmUxrHbCpPcidJWF3cUcurnJPO2FCCgdUfIV2cKbe/gDYe9owY/38Tho4OILE1c3W3PlLTMhF/BHbTsF5HangwZ8o66r9u/6zMAWn35YfwWZEw4GYo3yazKiumFgQJcgKCa0DlX9JGgHFE7dMiGko/qN/LDtInF/rVA4WkfbSaF8MfWVZXJnldTpBDDPFHuP8aI9NuS2A5ZQc+EoblN4HULWuDfcZhXacEn3gDy5xXMMYpaihWtSpR8TQD+nnbII5eLjjhHrHgcvAk63DV/+P2AeBxDQdc3f97L1GCXuaSDb4ecyXzNoPyJ1y8rsn2OJTH6+ZIVTjj1TNY9l8rPjlgAIjdcsrdqoxqcwJVUuuTFQGJhQA7HJ9gQydPoLse9G6DWy/jiwmZ2r4/wyVo/oTezqo4k0kgyvCt/XOTDFRYuthP/7ClYmf/eTSN5nA5kUf0Krh6o35oA41FvFcNwtVQVcdk5WTTDm7I21i3ts4FXRU9bAzIQ6j7PmcBiUnsMP0VYMgMCVDUWEusuDA1bXmpPe6dp3KZSshl185mClM2y9oPQD7FWqwYlMrZI44fqIL5l6lIdFNKiC53l4oTn6RnuFmQIDIkE3ZweFg0ytVWN2PbYSR/qhOTojZQQWJz6OGeqbeHi3/MCNmV3+sdnZaYBbb3D/94QBPaBNZtkXg7YW3qlVUq5/8at61dGIylQSsolwpHYrQSk2afXOaiX2PdC5CFHt4z9CTFb9jkxzj3+AfxtBLFLf8cGUxTKLXY6yUFxjCZsjnzR0uLTa/beuEj2fvIrBlRTB844z6YC8ECgoLfqgqS31QTEFaCQrPvbQfSRx+dwBRm8y3r9fQspeYAJ4h1yq0jOqrMFkOm8d2RsYLz7QUEjG+Urw7HYuCyl6aGWTD8L0SrDhI5fqHPHJFD+ypAK61L3NzmqVg2AitPWYHx71Ko+mTkz5ke2e+xv5IWaOPJUOyw4oyP6Ouh1OfXrpyS8XhcIYcXQNiI45lmMyx4VQ5Gbo7BGeSP4mT8dYo3cNajbKFs7+F2gw6YWHhT8kmfvIm6aTvx78ioOeZnFDkp2Oww1ejFZe78v4eAMSKsCRzMFQ7sHJ+XBW+aTDED+IADdFDmHZf7G6RHK7LwsoCPRZqtFzQr3sgGeIu4ODBO4/cmiCIaSGK9k7wQU1Bj8UAKTzvp5y5cFn+n1TZdnrorRKO6srKgurci+qe272HcJtTvvbf43ijd+k4pfxHMi9qYKN6FmFKcEXXRWcDi+icosj0aPUdCAUGpQPbLMb3+6P6KnxGpy7KLf7bLAzvX5Q/ffpJCrZd/gFly1ZEL63+DUQuP1xMDaHJamdtzOr5EuZAKlhoa8w/8Lf/vN+1vOPfQnjcTIRKUD7zCls1Ei4RMouQDQFr9KWXJB3vFqYkA98U4Y8Bh34I9Cxb3CFvgpkS6oqAek2mCqoPnyC+ApPnJV4PNocyPy0eszuKicf9FcP6JYnussOwkQRpneaOTxNkRVnzM4NL7M+iORajrKE245TH7yhX5npY1L8EaLhhR4PQsPy00d2+Z3VkOORIKtl/P87lNqDr6bceLewbJPY5ya/+DKnYFbRxTwCPRFmVrfwsls7DuhodhCjzzeLH1JxSc3urw5ge1CS+0OLj2mhqTyAxvVVANwdgyNFVRd/eXK5R25Qi6fOXH4OjsKiR4ERFxL5UhcnzndeAYdWYD1/+ljLwCNVF6OOtMlOEn9ePMwQJXngEyLwppg5KvVSSXg/iEKSe+XqK3DwHCdTbcJSOJtCdvlA5wB2GmVDNb5XvHpL4rKksRSMx7RjhXINAdsiGQwcMxCVDQ/X4CCtXnoUtLhyyjUxj9b+rkRBwOd/7+g6Ig5lktXoE7WmN6/zhpsKgq3iI/8Gwv9Z4b/Fyf//xVtUlHPXaDkX0VmRuOeYmYuC+8oicOTQpMXgxCF/sc7Fw5bko9M0/ruERXlLnjWGQu9AELXa+caS6NO/xJzhUX3Z/48GUhmXPgsdHwHfMnb4RuppFohHBpJ2d+WAFe7hLWhRSAa7f+1DXAiFQB4i0MFnK3O3wz4bdAjkWN+faKuYraGUdirtuLEIxKxOdYCNgRkAJRPVlSot9lODKrLKIQ2wLizBe8+9oP3YGSYpkmY13lggxjXksNVVaPF395z7/6gVRzrQ4Z5qY8SusHbtVl7V9LB00KJ8/D04xTSNncdRTMfCqynmPBU4pDhXtFnGq6LDOx6qRHA4pDeuQFqnupSrDFVrT4ol01g9dGcEh8FT+PDOy1f6/PLubtoLeifM/mb1eavbN5m12yTHk32HqvlGBxR0vFimrCsMwvXHXXMNHEE2QYKahAJaHRb30+o9PNYm8ucrfS++LU8dJnOK6yqoW/W9A8eJfUUwWmwb29PrbF6bDUZMMgzz5Lk2cYmDy4f6L8r+HZ822Vve0prmX8oWqorM1OSI4oLbfG/2wSmuOffUgnOHQmv4Rg6TG/Cjkk47AeIhZLmgsEB1cTM7Pgf4JIuBx8xeMhuyJti2vOlq2N8+kFEpcJW8LQt95MncvVgmZbEGRmeLf7r9YOeihZYnKssOatKHaYflbEG+b9y/pYvXegtfYkBwGoS0GB4Tbb2qEQLCBN1aPVx1GPUxpFETYIVfirHiSPTMf3rgx02TUlNDnApQgBpVydt4Fwwz9XFdcBtvgwr5H3y0OW7WBgqeFvE6SmDHXIbSC0hLdwCWAjDRcqZEr+G4bxiJIsp++EyGnTS8oKIuWcp/RbTQKbCG/Df8a34IHiEpuCJPulkniv1H7BA41xf2G0bhgBp8qa0uLUatXohKiFaSJeh1Q2xn2rFrgo5PWLuR9bkkM0Ag5ko3ZxColVOmsSXfDZb6ty5aGAq4pfb38XaQ1rH33Vod964CL03XBc0kPgVicY7MipCPLe4jn3ofYvXpdWR7B/qvq6s5IC604bda2nK5mpXRWqOnwKz6PPR2M+u8c4HlhLjbx8ffCSDYpwFUqLjKLhgw44qF0DxKJ5Ntir7QNT7GDOmQalGaQ31/m4OSTzCskWOT0D8LQlJ8A9r3Vm5QKdkiRst+Rxu+nKb1jcxACPpKdheUkEyfTLdmavNoSK8yOF4RP9qXfq2O7gMfh43t6NK09mPkyJNpUkcY0htdlqrFf/6Zo6RjXkotNxZyyjoEcL9GhqFKp8jBxtrDVNkGL5wjqc7us331jfcTowOmVy9bpQKdVUKDyZic8cZPWxAVgBmJg+aHagOXbkh0AEnemJQ8PflnXwJlOB+D/EUKsy3I4JdNxIujRImPLSASGzr4UaMhZHziu56yZ7wSKkHrc2eNKtHfJ3M+oVl97ZxqICCQNU9xkjByPLJl/LKKvsA6nq0Ob+0Q4VRO8QJ3vczIGuPSazOiFgcMNnyv9UrmDBQZzsBn7lhZbv/5lYilOYE1mRznkMELI+G+nrBoQK1q+nSmge5j5OSFTgJMH4CKAtz0SDYaIioQIzohLjYLKDEpipXx11ue1hBYsggtMPgeNeSkQemDuKTrEBMJv3Py9NqT77ZJzvyZ9SsObUP4dhnp9zcE65tElotbBJQcDxo5fsnEfh6KaTFQiu+J4qTQr07yiFI0T+IxABDOLUWbK25N20FbjweC96YJaJbyDPgWjlewqET0xcgQH4EcUnEeCLEyJ+QIn/Ap43tMezmLM3KAjUARBBsI36aXmblPfHA6CM7DEOjJZTPp5RMY8RRQkorTgWJaGf6qHFSCytcHoCy6e/g/sgo2+yOymznLQsea4eP9OBaDqaHa+d7fzmgYvhgfZpTyRtYSuDOBLZvSa3mMCwVrTxMxj19cUDvZSOimbTn+GAD9jrx0jyHIFiSSQiq9GrLFT1DbKWqUE8gu9QHAXh2c+ty5d/v19Ak9nryUUPXkFklTbnHwgERGnzPKPPA9zZLzO5zhCSVQXbSrZUB23g1gyb2dzv1dQifIZlvXlWQIpEpPOengFBnrUzZPK81wgHbsE0GiywC/GtE+vlPbv9FO/c74+vR2dQjalSQernzfYTyJ1AOGXdi0dpaUn6kbeDqtM/af+KobgXIl9QNHVIi6p3Dc9aVqoifoM2na440QiCjlFnsdwYolJsEo+w5NkGEx+YnmzoZLzQg7zAov5apKOVSSsbPhZ9QqSfTFmJYrTQu7zwqAVgMpV5e+9ERWy5CP2VjYdR6BAT5sSGbBLNrYapBn6w/DwrTSeCnL0BFCHBm3XVSKK91csePblGfQBCukJQf+PZEYuRrguusgvjq/uiEFto7Ya6kIq1vL7eJqIhgCHkwuV18wWG8STRPd+cx8bkELqrjdoXtNHEgn1T2xbs53PUfRoqzQG06iaj645UuGCnv9o3XP3U3Hh1lIrZhyt+ntTOcqxE6fgSQFhlKFS/rMQq/rNTOql7QQSeqGE5mr3VdaHNmDG4qkv+KCLUhmexUCPP9pESoD02AYh4hsYZSIvJKluD0L4MwFk67h0ugUaIHLCioGNZkgYRiGL0LjmdDJDaSlwPbaSI3t9kNiRvcZpujaR8x5UvYUQ0zpdw1FMSpSGY7UoBJUdsbExwKus7hAbsWgwYMtn9eeD7vpUyFpDl80pzZERsAbRUcdFhjwR4ftlr59eJ1XFXmAkJHa56MCc/nKprWaxHL3GDbgf1OR671ngPHb+JOBqriI605dYRwqYxgjjzQvH7MSga2RkeoJXIyXmocNqDSNde5m+JLTuOrsw3NfxxMzgywFeJvpy2A2aaE1ymJ2xMV6qaGxWwTR3kBeb08pQFB+6raJlPukb9vD6yOP+APu0FEcq1acYGQcUpblbS7M1q/rEVPfaIXRGyet+crsuwh7Ro76cEuw3PiPmozcAV5gK/deJknB5KQF48RtdvhjmyNCDhvmBgcBo7aeGQRxHRA3xd83+caRSJKRwWuEop4l4FkoCdSMNlbdSRg/PqCqFGgRaHB4x7WV7/1diJyXo5oPZ88AqxGLI1TITRZWXgg3Nq/Lp8uBRgxKLnHU1VUgW/6W06R48xEYZlR2ILEf5kBBUb6+h7W4/4IyYu2sVT2Q+BqQNM1Ng4t0gNcLm++rkOo5G+SntnAcoMA9rtsOFBTD2UPam+uh8ufVjSwTUFstzn/o0YzSc4M48WExQiyD2ShoNPj4IsSitz1mG1+dDV2XjQzvKsYWPItQd9CWA7rv7Kc8vqbVXoRzbMQzPSya7cfj8L99eJec531Wm9KLUC93Dp9Qn9bp4zcXHto9eC08raSMpkW2RqUKgqDGAza64iZYVVrvNp0MJWQivExEUeTPmFFdAiyz2oJlkC3/C/g3bqeGHJa1VC+GfWvGlAuoDfEe9v6xQuXa5vU0HUt/lDRtwkgheuQTQHoqWYUniYcF3JGkpaZ7yeoffdwWgjDGAfASeclGp473NbtH7wZmLFX8Hfdi0N1tgBVeaQIglwPn3pMGjpy4TpAHun/ocqbsav6KqhISJqmRoSqLJZ9G3M1qyBjJ/CAPVC38cwZd3iWF41suGE3gOphef6iXYWlRJT2nCwYP33qE2b6+QzmV/LRjw8mJv8m1Y1GtbVchflqnxOVeiAws6OjKx4D1SO25hD7jGNIRwTd9oRVkSJuQQI3HqmnxeKH4Wig2UULgNamMekUBGkI4U8KQCyL/esPPS4y5GlZXnzT7w2EE8eAsAx1WZtKKu89rKyrAr/fEKtN5xd7HCSJ2mZaciC+TH2N/4OPCgZjTd5k22q2qzAuXylrfj1cRy/zSWv+5xHJwOyv4CIh0D/yUfuew9HniAS9vQ+ACtF2dgMmkWN0S0rjynoNPgg3oiMecETOoPOGnaT9Q4GtJvi3Qe8+E3sEdj3xCfV3NwgcVBhseH+RKsv5X5vrQicWK6T0S153ZZPGnaiqFH671Spn3nuNJHtlGxC3lLKbxi2PiDIYH4nZVMwoDCvWZIhcYmWER7SjJjgSYCtkhA/u+ndUNGLMntZdYBCjkFPTS+pqRLGmlAmhvmrTsNrsbD0Jo/G+UXeuzIfTce/EYhJi3Daz61wYv7MAeX64875WXiHYJ/AGPFvQWCFkH0r52w7BsFqhroAj1ry8QN5E7OKOzYHJiKnhqKb+LGrMuuYjmsTdULJELgmERRMSCrXOAj/b5e1KcbH/wjthLVZAWcJTHjZtAEUJCA+KkON8kIp5a4u+CseGxa1qjwwSUUS0xPzwh0UK2MOGE3EK+XjOIMPqRlha0hst4HOLHjxG1WrBWLFAXCSYYSooNIJ1CR94sC46TokOOFKMRfbWOcIA/luiQfLgbZ9gAe42nJFD1GynAMpVcNb7z/Z8dp9rXy/IoDMSYhWxSIiMC716Wg30jxSYUvvNN0+lE0YwiBFz6/jSOzqaE1iFuUAjTnOf6tWQNvn4um8JBJjiHNN2zmuSz83FOoKJPLHpAOZc30Wf3PBl2rYoNV1KT8fEiXJ1tX5RJaYw959sKgmdt1l3t5C96SCj3wsvK34K+0KzjcOpa3wszSewGactEphhCTGytQWJpY0uC05tLmZqt4PEyy5OlVFHNcVdyfl8NIhf6RXFrXKAHNUJykx03wFL3Y+FXINIyih7b+2fKjGJO4b28PQ4QgauBedYHU3jHmC56xLkfYt5+PovdOdmaQsK9RittLL6q+WSXQNRSl6NKSGczncwOLWiaLV80Y78tcGyRR+DJ/vXkWkSvtzl2i1LQ+9XbTjJx3mkNnrh7KpcEYhonqLtectR+yiQHsKKA3jvjNeSk2aF2lH10XAwcHrP9SwDGmiMv6V5RoS9tELHKaK+n7igjlO+HEQa20NNVATrpAUIBYd2vyVk8NsXJJqCDTuaB7CpXVO8Cq7wylNV2rwK08bWDjd7V7rK9AlZbvAAdUPprxb8mbHmVEKpaPECrYTkaErwy/QfwY4Dr4zCWgsPqSV/eti2QyeiGp9CtpUnTACCNOCi1N63YXsdgu5a/GcIycThTa30MGKCnLdjVKGYcds/lcxuNeN8c14g2rzZYGcteEbRV1t9E7zG9M7yYfVW3JOpOA5Hgbu2HyJIlOY4amIJDKigG4qlcU2ewTO4ghywci4zahQupTXFinDBjq/ycVJ7CEamT0qebpwWnhpCJL75wW6MK4t88KGHofAulShGvRy6/Os8Z+46KAO1fQwBh5cJWwFSrS9lE9L96atATC5p2Ypyf3drF6wZ44BFnXXKm4ZhS1B6SRgmzykpIJweRhteRbRxT86pwpUBsPggl6OfPaGeeD3DSchpg5SfMHy9kOFDmUeqmySC3F0xZEN5lRbneyWL1wTTnTE8qLnV5KS0qqxlC3tAREdLPW5xlASDYIVYO/ZCt2GLUUsIJFp6OiroZ2Rr/iWM7k0faMgWRrRVzp3f3p8fzXTCsMLcEreu979UxkaX/t6L4azElv8S1Ers/yNCIwX0vLZ5A6KHxEqLF9loZxgi4mvCHaJ+/HM6dzm5OG0WTyOXDXPttGXaxBpS5mFRGc+5s42EcZTQ+jBUtB0J+OHueQ+jS6A9pXlC15bb3V9+g1ROIBvq1lOTCM0+Cy0UIxBSy0BHjDgGgeF80YZfbuMuY/f/QLUMUQ/rgQtvDKtafbDyCxpCzG3U1OFG5Ri2TRtYXrBXJwRspVgg/wMe/mkcTlA/LDXjve6GGUqiARTcrMp9Wj1qGxxLs7kNryxPjQYio39X6f0dgLIKlxQyfALyp3k5rQszXoLHSYZZt10hHt2vBKPnZIX5dhCYyi90aSHEgKcLFNj43dS3zix3awmvS2ht8S/y77URr9hp+S4X4ldW+I8xad2mRyzwvS2GwW1yPLRcR5h7qco9dkDwkGHCx0XNQEOQIPu4sUCnfGzsXMQcTlD5twFpsYJ0leIfiJup9G6Pwa357DSvLD38UEmWW7nRYa0tIBx8u66iTKZV6kiH4dCYPVLjKqVZNiYqxNUgSU/aKhuNQ88tKephKtKiKGF2OXZXdQvR5+vNJJsDEngs4FMov0Z/dxyiLjmMdQLK9/SaahIJV/rcvoWnwjHj9mtZp+IAuCxWvA3jkoK3Il6yFes1N7mVFdZHfFCrCRVdZVcYh0wTGlGuPidWiqu0jBSSj81QLTQgKoUIW5L29y1XzOlgdSZOg9joLndKIXRpT2jdp0oSKKmUajCyBOrobFCP0eIxLhD5/jCnuThoRC2F5WiyBikFvFtlUI0cMgiJVOPoP5Rqu4z8n1w11t/BuhdL9gbAh8xZZpIyiDx25EGdPsV0J9nKEqNCvND4CDK8jYcMMBjJB/IP1xKvmQVFY9YBm21/Qw86cqG0VgrNQuagOey/I+CyVCzohAk0RvoyAZ9gN3RAfP11m82SCvlcaSDCMZBxXbR23XkWshXHdVB68PyEIsIP/uvZTQoqLdy2NMwcPUxjlidFoKhCNGGzbarfjmjkvoyAi7iWJar/g6cXyA5p1EPU8AMXeoyvZVdXbWJSq6XnpWS40yd1IIgHHN97jqSnBo9zQUA2JfL4bCuxpPNupC7DJ4Wd06TnXmQfjiqYF4moT3+SSjRLjZBmVB8U1FAAbi6epmlgDDANm+Ik1eGH/Z1hVgOGcWZQoBvQmTJT+gZVR/EoebaZpXt14Hfp12JQj+C7Wg6PpoKImethO7Nx80CTiQ5nr5KuLCSSmrRfC0TC2fs3q/mawe5gMgEh38wAdcdiXBJikcGWhSv9m0fOHDisvd4SNdN8zD5JGfGE5bApXpvKRq1RWC96vHrUSX7Dm4S4/ZyrGGaXoU1/6po8EMI/gyapjGL4Gp25mwGphaKZLrfOxn71jBq7/tSAEPVK3K+ChPq+i4cjdjAxi3HoYodf+yyEMJOylSknS3ZMmMv1A2/vWvNEK1s+Mzp33ygV+R8W7INWAMxfpuKw1QZnIvfPfH/woUQ2J4ez+nHPD2FUzSOnLENnjyW/DEixXvZATXo7Mtc0gSdFPMNC6cLmN22SVXlUU7OIBw3fVBRF9IEpiLj6k8Ss/Bsji5sGLHmsDEVOLhjFfGpyTtBZbfeIMi8MVV5dZqOjhcaBPpI0aIpyieT2Eykmho/EAfk81BWfDsJ8UeEI+OEpdugCCKJxsNWKQikN/WgXzeNgIZT0mfF6pcMWIJbmOAyf6xAi1JC3Do1eo1AkgTD02GLz+bXJfcojA77dspVDoHsERhtaUcOpA5XPddl9xDxj3Wdw4oqzs7RuywK86/Q86uDiD/x1yNxeSUqOj8Bynrtj4p32fqmty/XC35gCUccegeG4Mzj6u6FzEf3/pJr52s/ClOg52YBtW8DTlIxt9jPjPzhRE43Zu/kM8n6XEUgrGYxtFEa64Kqj/ErAtU1/tTxB5jx0bKsJcDMpkF2fvms7QAEFfz0JE5jaPu3E79br4p70kJkpFS8XA0cBMHZydwJzGPao40nIYxe6t9GrjqiMktlev/9LF3rhLCabAIXC/M7wzd1w3jtuDM5QHcirKrvqe3WNsERo3RXzk64ion6IDev/sU9xus+cLYq8CUGMM4nULOALnB8DFxUnZ1QSOlHFlmLY5zMfVyY5A9AiB10K92yHYCyXNNL2qTeAWnYuE+i7WkV5QwkDSgotjTuxRIWEruxiQ0vkI6G/dBDO8u2R1/2Bf7ds7pa/T5A7PXj6KLVGtGksiaPFLUhtS33k2oWFUijpLfMgNapiWdd4tZcjWKyv+LxmZ4M+7zVcgVUegnxc/1LTzYUtKBR2qcoe++IfPtagPCB8c1zd245XqFGuB+g9VhGFsXHVK/ZYRUE//+Y7gkSX71BmmNYHL3TQrZ6pLT92gY/pyNNLVOaWrntLB71v8H/Dm/bI+UbbpLi6qXSknMQbjpE8A3dCrctIpz+XLZfB2h3A/lfCa95I8ckg8FNG2FhYxabv2ihty+2a6+0rpLPG0MGl1yhZhOuT3Ny+CKS33AI0auLMb/HFoDfarvon1bYBBZ/Enp/P/p2qvLtc7Xd5eqTOlAsCtsWHISxcdHNydFBMeKIy7NtiZzCttGzDiANozCpUrb1HM/ePPMtPA59snVP33zgA5NrQJCl3yIq7ummjUopDpm51sBqx4E6xaZUF9Qej82bkkyBvhJkWmg4rMTL5VlQb2HPM90SgNxcmevuEChlwBgn1gyi6vb6rAKFBgFFJNxxQaRDW19kKHT2u4E/BzkCOTHFDvfqnG2PiSP2BpwKV8ScnzoXx3wDp3SaMsgLPjyGf9A9F+YVzbHZnA9pOCklumLX4EYWSDltm+A4GS2cCp93SN4T0124BFBiKgdrsiqN/SHHSWGd0MCI0cWFZso21oODncuBJ8mgEs1S9dP+eiXRxk3PtlkZr1aThPXdaOuay15ktOpoUnDGe7+AQGXX4vbRERa8AHgJOosJMtlqweIrRFKL8gU/4nkYQhZY5rCi5nXmj74nsGtL/FZiOFEEJSNjtIqrQK5sYjtzUAUztus77nP8ALsZw8QIO2sLMAIhqthyZms+CueqA8URM2ui/F1WX6+cQaYtmxtetl7C6X5qWKXwx8A2WbdKVzYzKEnW210h7guOIfy8MNVg5UpdKFKGqVHlErLiNhsC+9SdhkQ2/YKjUQOA8sz3VnttbploLsUBmQ7VCzL2BtI+2NpVDzMlpkE1md470e7BFf8xnzA/IWa8K0uuaBTSgGClLBGtNR4zTqenvGWFHPuJIk+HvVnGu72XtX8BOeNX7vA0kw6d/1rMTdwHzcMRC3F0AsPB42mxSJATzXbM1DuS6WrVDri8P7fMAd2KtmkEDJ0j0PUwBb1gzqZPEgjDxhHXYBMBMrW4JDi08bpGODwi/R/6MF2vC7Z9nVDnrWNj/tgH4/t5X2cEBSDsOn2hdbfnFJmBKaRboE2wgrCKbxmWRvCOU5sI5C8WHglHV2QOvmV6kfwa2OBF/HobIpPAynTFB97EnBpN8aRTgfVZhTIsJVIlDbD5SFcjwuiBm8UQslvh1BFosHCI5iaNldmeNP39jJ/8X4Y0gQr7LQrhfse7dhzKQ/Re5c1HpGiBoaSxAGzee7IMLbgclZKUy6yadVFR5cGjtCLESYDjGbnNncbI9ccHfs5VAcs+N5hczZC1TbQusWYwNZLh/D6TFs8CPtWLux3irdJhzgv8rrE/+IqmJgsVanE/AdD/yMkJZCf+lk/rJRNxc7Xw/AQqoyCsiPqgVUu1JitHvA/0lrRkKCSFSurmao8gnDE0InvvRr5LV2lSDh05weHPoVwa5ZNU0GxLeagr9kUPWhP1blH1e9Gu0KuV8WquUv6dgJbtfXDN5xdp679hfOKFaejdJVYEYx+V4uARuSVVIJGh4rwJeFvvJuR5ZR97N+CZemk7eAtiNegbkHiupCDfCVKhXt9XdpSdprf3HsY6Kwo7h/AthMsYp12o9nYIxcLFFUfF68YiF+67mLUg1uEA7s93Bxsg84Km9ONKmRKOoARCe4OUT4DvBzqHK8N32o9z/+zcCBV7fCLDnBTwozPSDWUEPIuQDR94PKd6lkG/Abe9uyVfsSOY7K9Q3fGcnUX7ithr09oOSpTk+sgCpNAfqQaiFKs/bt4ypGgPLEe0irt31qseTIszxFzU6Z6i4eTmlP8OFpLm362UeKwVvYVrcQlp4zIhNBKkF5Ror8npwyJlqhFIgLrpWajHy0W3pXizBtHmql50ip7Z1b5nKJZK7IZNJvltWcTUMS+Dnc6SntOL6OnT/HO7zMhGZOs6lCEMcs86ttZ5xfTj9Uwmqe3L64u5pZLooOL/2Oybni0Cnv4drvCbPNoTRhkZfCGYTqB1ywTwPzYe0Hi+34TxK5401F+/6czonwrH57Ye/E7XW3jbYIHOsek6Fwh+W//NLSKkwE3wmU09usD57CTIhxNtZDqjFGGPtcOM0/gUBaP6WGkskbr8ANwttYsebhYo/kKtuVgFw4CvqQ7VK3mcWrzToMzGs/Ij2msOmjZTfYBIaTBXkMCSDOCGg7wNTGTOZVnSCesKTKsNve8VKwU8vHoupjqGYmINusACOAXaAZFOzcor/gki6dxWLIQ8AAG+qwXnyj8jg7lJDipT8rgVhWPzuEyBFB41ILHxSG9WzwMH2pgdg8sgBxY05/+YI6lDZBcTaPUIWpVYWWLhuebXOrCDKoGqeJk1T9Js3l27vkw0HL15QuyX3xV9EtJyS7xeZLbGqBRL7GdlgRQb90pHoFJ6p1v7CFKy5VvJfNnwHQuQypFhhcXFlApzGoReNKHSBKmLgIdruCzeQT2Ieys7rpRKoa36kvSXlFGMbYWr7PxTIpjeB0/6pSOyIkAATg1bNgHqtivf/9dCoym/jNeBG6hlhFto0IpmSA0HITt+HAEfLIdWB61ZxOd8/68l9iSbM7EYQ5CCc5F1I0YGn8lZmoq5la07dtXZfvPngfwYfTMbROGeZl4TzAFoi/PrfUjMYq8xwjlQH/QkdCeWo1LHU/Lfo1tDTZnA3acXz6LVwD1XyhniF2zjfhIpYl1wbqtHri7jDZjcwTYONWwDLnKa8ZP6C8/Bb/Ra5+VIUvmhKT5rTb218xQwe+SQwUdUwybLDh5XI4WqfUofEttYNqhoT296mLhQgNq+mlGKSJmAgBhEJ3XJWr/RwaaX+/0V7TSWNbZqneB1P18EmGEimpnJCzAs2otMAiukOgDtfdEDpBpwjz+LEt/2jYF9jNV+iUi7uUAZkT+R5E+tkuNRRXE04Wg5S+xYy5Q/gl0LvYBBwnZtLghrNDjxWtkfZwdcR3gBGuvUhR1CGbstwy98Yfg2fYBC9gU2Y3Sv86zDMfB5Oq2nLg1ue+/4HxJcAZRnr2M+Sf0wS7vk28f490pLcNX76FoUp7KiDUHFIcFFUwq/MIh6HlCRZjpxzJM3f4MvoG8OoII0JRV3m1fq7W6+vWbgrSxO6p5fMsSIBwbqqZx0C9cWpZdnmY1J1jnyHoTodA3unOBq3uFqxAire6V90CMIDeouoLFAP5Q91ScuuzYSeC2jOgcqa339zcUiwNKIbq1I6xVz5qh+rO0bKB7Q16Tpc86Lb5UzqsgvCgw4lbd2kdJNPhpFTWSkWHDykeXhtIsgYVTu7Twc7jLJpNkmXMzAdrHfwqrk+OpYqcjm3IwJLpg3M2wAnus676AldNYXzhkc9ueLsVc2qJw8DBOG0byhz2wsVT7IV1cHrAKB/USRZqF+C5MyzHn0poRRrATRy4+Oxth6c5hqkAFZpaKHjva7xvSbi4Kme804gjzqs7bUx7eqVOEkt3Gw8bgAJgeOMhhIS4OYtETjIsYO9jyT43fZ+D1sb/iH8uP6mhvYF27oPDxmNHdbE/riWc2Q9sON3JJf/zfJmhqjocoBkV+mnH535sVql65mVWIuwDt4q7dw0lvn84dt3xCx0j6KP3fP2+4Ntf5uumS9iHa+wKmFjhpjvjI1NmFFPYA0JrhgCol8ahw5oZ2yMP6Bsh/lTVYmpB8J8yetFTWeooQPAtPbVKTEPKVir6wmGP5e2X+VeXhL5tT7ZC+tWfeizWUOb1Q8xLcRJ1OzklxwB7pZwWsp2qkbMD9VJsbxq0McFI2Cvxg79yUu+ay/gvRW+6NXuXme92nImjflJSKpn1nyRBTL0wRgc3IB11foSfwPPxYFZEAe7YfbiOqCRR621CaEWCLs8AhzRobglMg64yn836OhwVuNOZ3q1Qc7UdB7n0svus7SULInJl+oPnrYzBESAlO9DPBG6LW9dfQE73zIagdAPxCdNTSDcvhiKTcl1QTnHz/mPTshKn8ItgVp3MA0+4hZScb78BZt7NclRoAhK9HjlJGSOjnP/bCLcbdaJKIZOntRrK2BZJclixYKqwz8Xc7OVBALjqHxmdIJTlIw2fkxSgZAf5qOLlJfRZ087Mv/lGuIzaeUaQ90rn+k3ORl90kcwcZj/OJmIi1qVuW+JIRpI+iDYO5oE/6dIGKyQVmw+FSLYhEEkVzZjexCJ4gtXo35BnGTIquH4gvqnBt4t9z48h6sc00ICcP2isBpcpeRsYtBVvA9OD/G07f/WjWwzez/mInjDkh4RQVvT1WjuiTjo/7KGY6jDg/lYTls2eBqQcL9VzHAv0ONFYqf8uXije9b0GUkrknULjACkJw9ecrHS4PkH0oOSGk+CHgSqT+82NS8/AOa7U9TsOcgpHXSTFpQGZEKWIx5N3YyxR6wRsG8GtfW4R6XWCilUpIu8RdYwhUTPwOl4XaOZq01cdB6kN7XEJ//U37i5YmWYaogDSVGKAzXtyW+YMAhnAGmiK3sbDflgg8jzzxZi6jM/zWo80b80xY6IQ0IbtZSES92pqvQT1STHMWtsjBJB/PUGahEjrjF37BaoyVV0+oxVnTkU0/Bp70X3oEpreoPzaQZbVp3cvQKM+6wmriGXbv4SEr87rash2QRM68bRTcT+RIPAECC0xfnNKwe6U661qFcYoa3oJDuYWEo8YMHvlHoW0M8rZAsXI08D+I18OiYCjngHftOJYeG+dgR127pJN0GBMANAhdqu8VQlAopbMtwGSOc+AlfBTGvf6S11kRJciOrmUvZ8FY8jUIEQOlPCjTFlHWik7bcFOO5igsT17MgaES0SMSd+0IyNnO2G6uY39loIgf281F6OwDi+vEHJYRGJ9+vnihZDBZ+fBeYTQ96vy6sn3/crq4n9kw2qGy9dcsQC3RsLxIYIZ/O2vbJ9YOwc+tXHhzv0UF04tXH0AaZd0zJK58QH5WcOO50Xsm/ZYpoGBu7RghotD5YBhHBmCihrNSlsEfO8/SdXaIppunDqoJR1WnWImK5gCJD7KI9gCSV5zrZLUVI77gnUd5LCgWdPilfZLl8qtF7hrPUiZ04x5a/KMyr0O6pr2yZLT2bfP6lmAwGk/V5KtGnZNuOq/MtH7vLYynC4wfzGhxnvcefPbb2AfeUvC4TOKPrr20hc4l0Js9N3VifcLjTCx5xmamJ/kBka2KkuToJHJBWMkTKaZWcRyDn8W2noIxGZSzm9JSmwyXycje0Z/LgabThtj3gCNoiB0AJUVeLeD7pb19VcG4LeInWB5zjwUEKkxEnIr4zmc+fu20Va8noVlnepaaB6MTg/YZUH1CnPDglO6by1jSazbBBUUzLc5RCBnKc0x/uUSEX34AWXVVnoQxZjJBCzdocTePxKtX1Yz04/WzSR+BLVD75SZT5c22Ai0Ft7fS6F1yR3WygFp9R719sMIQBZ8SF9LMM3aKPA7Hj91efVlUVJYNJz+VkCetGjnaKi/RdkgGavR6O7MULvyoe6G8w3nmhZ8Mw2j/qj0sd/dvq7gjo1S9Th0JuzHG+hBmqeio4mbjUnrxQVDLJDL5Q6AixYcZeH+9J58dhsf3x/7dEO+fe16r4Wv585ZM80Tuob/hWSj+xownaetn+niAUso39fEi6yU5CKvuaZqZB76tMC48MNVimVz029SNBWA30gH2X/8vfkOC9K+fMtn5u17gJfuRonoT5cZtQPoZV3nbMeIfulLgMCmRTNLL/8dVywP2C1WILZoPMQUF/Y69KbDb+vgmY+5vLutKQigl+7AXuTU6ACuCf7dBP8+i+Vi0uGjzl/nAsJWzjWF+ySvrGV8pgJJk3CBQd9Pewp24DSbmy3Fnb5NQmsaurTwFCan5IunWOygtoCtaFxEfs+LLv8KH4Xl6590PzlN7m0iqirvZXkse29M7jHg56+wmjBlCI6BauMQ0mnI9/EGhGv8oTWZCanJxwvvRh1CUlvMgO+1VmSCh8USNHQIM+TJ6FcZBEsl7NuDaeKbUdD1q8NqsO6tDCxuFYmwBGIssuRN1FwcBmDRR4Y5zBUemlfLtTTH3DvOTk5e5+9tQrNWtRsho6bq9zcpqbD/BIUEzpsOlACnBrtrY/jHeG59mGVV2pjTTooHu2+SSEasVA918wOik2Wlw/9Roxp1nfYyRaqDdtWIvOBFViXcHV4dp4Tqo0hb2oXFUuqGyZYvpkC/rmXoC04IfpvtRyvxdH9Lx1vG9TQ8MYeZEUfECYiu2NhqwvtfhCMKEtulJDiVT+QlmS0TsUmJ75nuov1I4Yb58OqByhW0h3sNiHGCZq3VsSlMRhD88L/J1AOrYXS/viei2MzTrjAug6g6xZPHpZ6np0ZG3DyIZ/pxtLU2IrtYmOGGKf5jSDMdV04l9zR2I/jo3Y+qhmasG860hP8JJm41kxS844N3m2dGkedytEqwoKc3t2iGyg5XRhR+3T8gNBUAC84v1hAvfa9SOH9yiVcntwlur/axnsikC4wDn/w2P7NGnxH4qB1VQ9tZZ+6E/NkuN9o0A6hvPIXi/S7npL6opIoGogsDQwdtqgCf6x/B5i9x2AeX3w6qwBgkb63K/G9rwWcAi+m9OAwB2gc7EbdJOE7ONTcnY1suidfOLidumpaqTbdWTCMJLFFg2av5d4lV00RE8U4g1fFyJ+NvjvtUpgpHrAiflWbjnSv/q7hhU60hirfYR0FkFjNOH4NNmJkpnMyKf/ox0hMMYflQRuMf1CVTYr94lNiZ4ggFCCqkvqmUUNRk0YEcIJPByZdMwALKwCGAnQm0Z15eGGVzSqVPA8fOHQm+9AVU4iyx6aZ/9zU0LrbGFEEXX4eFQL78mn+B9mQaYjZD5RbFiGMG1zLNl9ljURmYViYWt5btyXMja7O70uQIS8QsVadP6RSckAs4MSZQH+8XDQIyB7EpunQ6vvj6pgPTMi8KRo6eSq5JcptNzfbcH1l6+JHUaR1RPkdgaGtUtKbAK/9Zb8WdPZ0FBWaKiNuPKsHEXSH0/ilDqkl6dIJCXMzemA0me3Ber8u9h6fBLgWUIFeOeKsZYPlA4m+sHAaAS45DtyP5JlHrPk58SL4nH7xezr5RYPwP8I54QYcdt3re+gMGnqjCbJvPcWZumyyyTDbnZ7N2TA861OIETbZPFB+tNOBJnXb18lb6Owv1Q3r4SzHWk7r8gj4nXMEs3+GCVO2a4YcgA8IHceX5jZXjsHKFwpAN7hEvgjQNK+JMRuG7qNLAyP9EEWuQFaVoU1+l6QbU9cfjbXWvJtVFrZg2EO2xM7O+Q7vDkY/8gLI0spSWS3JQZAMCM+uhdxRDQK1uK2+9XwX3DiHt3t5u6CwJuO6gN97TCbSj7Exqbtq1AhxuNYY9Kos3vKWfcm3lNcqOu+AHOSH2jz2Adu5vffYky7e0iI7N4lBBjjwgdkxRGybLKylYVyQO+n6Rs9ljxaCk9z/hpKYHsERpyx5/gLeEG5LhdiFncGz2U9nMHparqMuPYi98gOnJImOn0qua8kAy0zimD368K+w3wmV4TcJ33kLft+93eNcXGatRrKcXVCo9FmYzmfUW5Z/PRs0AIvURxnN4zRQ9nItwNK+OgAPCEbhgfCPV+9ViI/cGQt+n65r9A6/Ebt4zBDWq4d7KXuAdE41KPyMmtM/ra3Q5zOOa6hZZ8P6bfndKfxOj5dT3pYbTqzBoakOdsvmLS7l76BrnbASm0cno1bSVL9AMwl5vIpCjGrEcepTEJMytjuljxNBDsPOU9UkDbrZ/dJPJ6SzJTNDIdZuxMxY8rNqJyqMqaKPNLzgbhAB8p/Mv9rDvUUM9IMsSHDB0l0s8EfLCTZg2+7wAyaQL5oIRugj8wBuubS84+Vtg7I5ioTeh02hBhQKWO9e1pxXkxYFEwm3wgqmnOAWAJThGpJnm2PsJKyl70WmbiNfTHiFVqWGFq523p0cF8rnTj5+wdAP14nsFlP2cy6bH1mzo0TKJAC4UGx8ZOeKLmVvQ2GCS8rf0TQ7wA+CWCcKr6dE4pcsAFsvDjn6tToxqnd5PQKD2q8aZDabcXpRU8y3osnuhgffNZTGJnHlJT9eJMaAtrqheh8BQx+iTnkxLKJLssjWKov6Ke8oO+auAgIPkVM44I/6ALEd46QrtqgdS+mGu4bXe7/aXgYbqJTqWqqYh7duk2GMbyMAS1F7+1bQpyvsgBw3IfPwRWHvdiN2a1fDAW6AUz2XQqcQ8Z1MMfctkXUr2EtT2ApS5Zv5Ki0cmOt/YUf/VdWJlAZ0aTsZAESwFjMqyevSktFdLAlrJIAMhfuvDlXQ2qcWffPbQgK5RXS9zRSLEiogmHhlVXiKKGWIhVgKEkI1LIW3UTYduq2Dn1JsUoaqr/CzcG4k7vhMstLclQF/KVFHrLm30OH41TbuH9zTFA74xZCjouSFwmBYAoaPQR8n+qBtNXM1dgYS5qTR+MgnmZHVBg8NPjrMii4XbdHOYwh6eF0W4evPIaXa8CZsscr7D4wDe4wZINVWX+VQ5HfwddRcL+fYzoBMByJp7TgfaXg5qTJ9sMiUvqHrvn7CU3cwK1Stklrl1bmjCabnBY7d8ZVi3dLmRAqHHNKdiCv4gEGHmGmfNtb97lMv5Iaa8qCEZ+VLd31Hl/X+xCywwAmndcZor927gBZfD87QIm3pyiHxqVxMBwAtbsuLQ84mpIlfnWi/x+tOEVRzHbpyTgbHtfWX5W4PdnhpnQs9WFgkwNxORAr7i/ePwh5W8pUmwyo3S84ntSEeCH3yPYkxnsOxnPxX8mZkpxUq1j5N5zInMiQpqE+F2pMn6OrERXQDR1MAa0kpaoAhf51nEDkZn92okKwgHk5aQ0fkrOf2xSZ5s0HXb3QcUvg24nGH/8jMJwcOpfOQJe3RSzThVKBxEtHXuJUCz/PFRHR3NBTpOORjow0VDmPv0gtzgCinFvaUEi7KkCiFA95KeT6qy9YuP0dlGhmOZEoRo5Zx8V7zt+Dr1/EiAkPXop1R4O37coeQKujFQArpBeNIrpQnDE47Lfsze29CUl2ewLN6Mfhoi14K7X8cFkVAjstdB8bSqEsZqb8iJ8lp/UNUCjHjiFVcxv6XC0/CgZhQa6utJkzMk5BzpSmpFqIbyIM7yblIVbrxrWfSuW8Imslqm14VccN5Fbh3zgJHjA5W81RmbSBmAD3Hy+g1f3aSOmXxtMD6GBPm5jgc6v8xkQtnbIMckvWrs2iWafFLV+AQNzIqOYSsWH/3uYWAXrBXSJP3yEuscWI0qwAv9UWVMNBpBk+6hfEvYz4W8o1YHj9LZn5qoXiV8WA4sxmZmEjtd4EkBabcRdrdLfZUnGKLfN57tcRCTVFa6tZlA0WeJDDkaYG9ZOQIhq4Li5G9l/i/iN6SD/JLpv3iYcwUOKEeozqRueNSQHjp6O2nT3vNydUw4ITvfVhbpPrNiktHznHiJXrJAKQvGp23Y0q9oxymL7zC+tj7BAlkLuLWNouJ3QYy88E42mPXcOuv/CGQl8eDaEeVfyPNUnkLkAQ6FTFJWmblVsRovZbYHt90P6FZsb8dpZSdahZImwrRCAOtwMKouMQnjgwMobAyDd8Ifl/mwpIJ5WfgKOOBE7rALpo8zPlh/9cA31JKjmCpooxxA7KghoZk3m89SG7FBL/8zo0sa8Npu0UclPzogS/REVJkQQQI6NPe6Mea3O5qEjLcM+B2E3HG9t3jSkuZasedpg5nFlKwAa0yY5ENYfVy+JoQpfKc1pR9q84SAp3XmHfpZ+d2PQQ2itaElH7yEKgN3jBbqoQ7z2otHKaeWNaVIn3SRjzQn8oU8ycdMRApRkUwqZa2AQS36AEZHIcl2AkzAAarcanW94ASgNaR7xGesuuRPJZ1TEJw16lcO0uLJf+S2ugn/zkVoeV6bHv0ZpreHbH+AW58mWXmlBOKdTi7d9xAjVE4MxYTCpAHULyCoXunMZk+QCRf7N9oVjIW1kS1VTK8FPL8c2A00llqT0bLk0pzqSDUN0zWnv8Vu5lhkJgAqqCh38Ic6YWVPvA7lR7kj2kd8OIjVd5ub9FzLyLI5a/5NckUV+kR8+8JVlJz80hMvvcHMVArPiubdw//vwXVrSyvV5vJvwFmNEI/720aXK70YIHuOTCnojB+pzrZVBIxh/X1C/l+0c0KeuDTYb+J0XfBsl0FemMPriik7BGhOYVbT0/o+KUGmg8bZ2oXw3g4OR2BntnCYB0M2Z/oeeOIHgdzTrNlHT7b0e8TZQsrec2zXEVu5757OrraMbVlF8IysA9xNtWevSiRHn9vKJ7+4IDuhR/i+llEfBm07G0Wz5yW066ZfGHC3qq6v9+4++kx7wTfxDTYZCp1mK/X7Yz5QTPOhxFtgrdZOYRjdeRtCosmxadNMC+eTWF71qn+d2yckobK4KqOWTNY/0wpPBzTMFrF9p5IYqUVIydX0WdNwZmP9p+6PSttKUNEiXakuLeZYiZ7DqvlH8qSYgLUJnxjhvt/vGgVmOPNz4p5B3s+Ex56raWXaHbgjLsPw9Z/S19DXGNTpIXVCjP64O9U9Cd7qkSKHnoaK5tKytCLgtpSQj4Wo9dMZiE2i+yuCRAE0ONpGsM625upGdbaTMa/iYBu2S4KMMx1m79bKfwPJbP4iQFEeq+OsPn7rs3r0AlqlEf4vmP+en7Ky2Lh0yzMCmkbczp2KFGfhRXhgPtS/bdSLplve2TD9FTG/ttfsZaOqQh5xG82QppXpaRCvszL4Qvfb/l+e+4blE2XYkN8bP8gAKolZgXSOIO3LrkZC+l7U9ztoX/2k7wHGu7NtotKTvMgpvsLxuPDRG+O3/iC8D5aZohgaOlOv06ON52jmxLiiAcUnbh/VXJI9DEucPuIqsBnSiuFJn1QtyITmLGjp5is6PRpDq1+AWIrWl/BEE0ppXxWLoECx3o+ZLfRIKKhgFbor3DF9DssQcKdjH4CBmG3o7wsLrv1oGyU17sNW3KPTwNzDD9jcUEKHBx/lPfEzIMkuysH3jZIG+SKakPj4O/r36ET63YSWrlMGkerKzXmUHB4foReGpGbDOgRoMX/6M0h1629WtYfnRkVMXa3mcWfD4xY1068hVk7LdY6d/jRyr1eKQIZ6U27T+rFocP6Z1kjVa53WOiYkOFmXsZdAzqukfrtyBxffW9SxbhoYNesqQ4IZ3TTUSRl8lsfO387ysS6seThvMn5tXEyZIgdLwYAKL3HxSYyN9o/IT6IxVlbqTHommUHe2SarBE0SO2C6o2MZsCz6MxOPryPXAOFY1A9V3zjNVdnvHywGnsCidZM4PTA7R5HKDYc/TtwGpNzOKBCYOOMM2U+LvPkqVa5KFuLhNy347SR8VRKIgNxbkCOZQOF0+/XfThiH+vvEEJc36YrnpnkT/GUU2QMN5uRIkEtGg3w5+8fEPgqazyiacxKzp1KerWNMAwTLWRN5w23vH+zly61HOK/aDOV7OVzuNdO8uJdgxQPQs3qsYJgjT3dX2NAMt74LdZCeANtiFbj+T19aqkvc/pirX1dEZHmaoNFLGtW/RPPbXR+zpy2gKD0muqh5rXXOMmZyIC9ffsrIQAIeIwRhNmpSRmd/UFLC0jw9WkoOJ2phU6ZmtHnel+cpHF4h8DTETQxdyowH8OioBpehQCEnIt38QWUT/NVDJm/0ZmqzewdeO4hn78mg6jC7KasLmIp4KstOeUYvEGrxTF3h1bTNAu04Asf7lpubpEqjxdcFKlnVBf3ieim0WtssFvhm15dey1crERhUB5h8axo++iB5ymMbaWFv6DgbZAgYeU/2tdAZ5e4N9I2UVzwyChBM9eU88DNLABy0rXaIsIDipLhad+LQVr2x6wpi+vgZ7DXxriHEb/ti1MMfMJLOOXGgIWa0ZQBdMhGux9KyG80uayHJhDVYcg3KJplgRm72UqTIfRTU9zMGr0PQsaZiHAthtSRESSpOTSe0WZIcn5fYFai5oAKtBAVj4+Uu+oXZFTfjvUX4zhy7GAqDXSA6yDoZKWfZIi/C9vkKil6gSnFTL+SVdVA3pVarsdGtOUIr/qFigg82spalNEtffEloQ9VhJ9M42n6jvaTFACTtGEWM/Rcz7tVADSKAzOxbKJGLKGGY5X3x/g6DW2lSs2Hpslbda5WmBO+zDpLqG0teh++Ahuu8KA0QZ6V996lf+D+llvz8KXXiNcgw7Jx0JTX0aMAnBKIB2qpMf7fEE52ReQ55fdAerxfozuQ23ntx18YXHSPwfnCB0MqqedrEZKZYIWFmxqL1CeB2oWE2DpBs6mM92CVna9rT01EMRlUBGxv19yoppZVJcJGiY4La6u9ZwM3dYoc7ro5FM6JhgT8zPdy8CyDlBUVPA/hTkNvixFP+Vdb/HdIwO+xgzvC8xcV68qHqV2TFoFX/Sruq7lNESUjvlzEYIt/OExjjmYxSugN3mJjkQlb2lgzpSa+qSKuSDo3TFgP0YwADEWjZTkWiGJwbk1P7E5O+Zqj3TnIoQIlEUsofvsnTmsYNyNaS/SprGz/ZDLNgu6et4f3NtXBn86yKBkOK1OR+j8id6EqYzlsQxG6oWh6UUVRDCNzjioB/ykxCclpB+cBr//5Sl81qY20C0Pyqeg/GqQcw29F02LCaC1kHiMY+cY9l/PBQK4zgWJ4MqUhszKuWBgiQI7mud8QEUk2ZAX7CO9r03JWfT0S7R4jQuC8UGY6cYY9jl+opuJ5RWRTNbNyR67/46y3wkhfzHSaPPZawXFOZS45f6n5SXg9ApcigWCGlSexfj4/Ezk3uRTAgTOk5qzHYIT1Ib7LEYZ+KTT12QDZpatwD7fuPd54RpRX3QGrT2i0IV8EU+hyW3GGBR7ZfGddkn0a15+t1B9sEm+m0ez0rmom1S9/4DZru+aSzmBNuSpn7Jrp9h6Z/uy0NGpVXzE8HpihFLk709Uh9iHJoeloc1eBJR8zy9g7Bx6tMn/VImzMjLFVcnxXvlUPita5WDsXk1MrcLIYh3oPvAEiiDPCxVeHIqD/jhJ74y6V1O0f7ncVRjPMZmIHWCw2P/vv5Sfv6LEIXicf37Dxh/1gP9NQYQMol2YOZjiImjcJwlXu5HSH0L6t3GI6sK9lQZLibHY1V0WIZCGePq43z12ART0daA99XOmTCrxuXi0ZOsNVRcAj3McucdrRHKLVx7s+WtmvgHD3fCF4bcz0cPqrTKwpeS00fqNDHAm43KZSObYk67fc92a9hw7Vr2fWrWnMXDY9O3fQejzGlFuRpmev0NWhfTA0wu+bYBp9Yf+VpNrzvF3nBF/qRoaBsKJV1yStvnpt7SkDgVcwS/98ZzEq+3oQwB03q5IL0B6/l50hcLokz8E9D360mOm7EE1LDUSDXWDspvZNk30/WkQIsCXmeD7SvMa0AbGI++TOXFHm90jnzLXYn5JIbJlTmlePZPw9wzktvehNlWaCUbeabsR0Y/WVKAnlvoXUZ+C9Z3sz1U/cNCTVZL1WMWdsHm2iwxQdw9fQI+XqtyGfzZkyCvlju6KQViKMfcYZMA49Gm3OJpY6Kt9HtQjgFWqts00m3Z0OHJ8gl6AFpq7iizePxFTwS6PCcctVX0yV1fslMD7KbeoQ1l6MHb2ueFuP5az/IjX/eryZfhKFidpARC2UZ58qYZuYBVfxNVsdkBbQOT7r+ulEg/hTn0u/oVQyqrG4bmILiTdFRKU8pV2TeeOkbBw7BD2SCfdDQxcjzpGYbbjiH3Tp4lQn8fJm5lhp1IPuPuiORA7amZ0A3eUNHsb7EA+IQVXMXfytb5iICePH8fCRVxur4XkN1endK0aEpTYJuuw6E0eWfM1ea0KI2v573yjFdeR6s1w1AwP3F0JuecbiB+F2Qhb1nRsvqlcRsmt6THZlGNunzwO48Zb/u+1XF3Uazrz+IN99EUs4F02nfXTFL07Uf0+M7DULmHKUTGr9iHbta3yD/rX0TR/Tx2cp96FkhdItybuXO3T4QQYoCX0g9yhJ7nI5cw2Wqy1vti6pwMj5/+Ku/+LacN1/xf6aIsYOiYA8oBx5GJpaoqQe3ZsYG74O1h5FMxwkgnn0LyhJwJ3piJMFd/UFfIfXPgEbBhKV1GTIUTqjjFIbAk7caSsent9QJLSLwaXLN7ZkLLXReAMBLFmYzRp8GLUo+aMbMfTUIbizpchQ16iqF5sbiM2KyD1yV3MUS37zrdHzGbWxKCVDfqF7c8TZU/M/tFUXoQfwaKWMBNgUn/0//TlGIZMv3jkaK9Mhy9+tNk1wYxTiSAiCFU4NM/fmaGk5oO2nMCC+y029BuZWYd3SQnTH2ki+cWdQMY1TRbwH0IN4XaUwZvXGO15UjDzZPsKY0SeP/wazW4q8s5wU3Qet07bYYO6258vV0HjqyqBoaTwavFlRUe+ibGQlCBzifB2eMcOkAVKAB6NEBfoPDQQOPGK5GLMQokPT0UpGqEiUrQK+TJWbb44F8Q8aPefmF4Hi2MCIt5J0xgSmiN9avbgBBOMR+Nc/qljwBViElDOu99VMM2on7QvIVLuIWQYHZZ7XLWlFnc10vzDmSJj19GXgmEVmxQUA1mPwCBEdae+25D6PnByzxhLOvVGLZDezWqFEp4jQAzCosO/X6XP8AgSFUl9jo4nFgxCSqYpgnckAn6Holeil0JAgxUnZkFZWFt0hYQCoQFbo5GAe6YzZO/13vIpWCbon3UO3mYMp5Ws3m5C+eo1uF7fEnTn/daftTey+QEr0kMBsbXzQCmYrXwIYk7ZlX3COwMHvRIOGmzZhAgzu9NJV8Agq/BcVedUS7BTCyCOuQp+BuFaVEvmD9HVrYNwHTpu424mA/MkngQPntt5YdpnAE3aySHToF47pXDh0zVmNQZGAZw1sXYcKKiqdA1yxVPlf3TYB9UV/kOq7nGs+Pw9Awudw8aSYRqaWilRf4sSGRfgnJ3aLmaTgSYnehWngl0IB14F9DP3Ov1RiSEwqxut08tT4wHRqtGC7xA4Fpkms42bqsDEaVe/K5vGxPw/1htaW1gqXG6HENh4ryOmu198S/+6FFJ5aJ27g3zdmB4MqqHEGAKi0SRL3Q3XYHBAPfkLWxRoEHzjmbXR0OtpkqoRgjXiYJvkVfY1rHJzvfDguayMVwW5uekMqMKtglTG9oC98z4OpFpXcTFhEUs3pvUJuZbgmUcFZCIOmQIcYMP245WU12+E+/wE/qY57tlAOUR3SNkEam6TMnKqAUEeiuNjILRsMymCkScXcENMYSV4rRN9Uf6yi0Z/xRtC3zwHfAuj72GHI1Y4MLwITXAdzhR0B19IuAtBW3jSO+5ty+Mnktk4mRJZsvtDAnBBhEDcBpI6X5p8PIuHIXhjqAT35U/VnDOi+lhcbR7twq3qT+8e9c6vy4mAi3cHxZbfr0dWIlcAdwJkfCmtEzBJPKaAi17RceUHYbeS636vhNfn1dPjVHtFVbJCZioj9b8i62PdL1PXf4xjCJ55DZ6JmKTgCjy6bR8eKI7PLqZNI5LAofMVMS1xksqyeP5SCqL4iRFompG+61sSOrsBQaubPMJVcheUCBdLzKiSo4FTucBWGGaXStbIjhAOGJawSC8R6tuuEtpDcap3kNljhQtZ0Fd32nwXs8di2u0QJzZrQMfU2kX/rLxz7ol11zXlYHpbvaGqXp5A0FN3oD6Ga06So7SUhEAi+BxqGb8SUWx/awm37yKGYn6vlyIg7hnGw7KNWyBDGw++hFIJMyjpLZ1aJeIgpALzfPcQXAj/R4bmkceyAGF1GJ6y/4zOgahmlXBIDfxyMOmpdjK+yYFGiNf+DwuBLTUv3RUpBVZdg1c0zSLiegRHBOxhn/Z50cyjeCQaxpZBdafUTtasgYnq4xluRfDFRdkOy30URaTmiYnmzWR8zcvoBZk4Z+7UJ9vLLKHHIBsvnKl6Wn1NwguHSXFZ8I577Qr0NJ/fbsqQZUo+mbe5fWOZfUm9GZb2OuSc+wukHbPVg0kUzZvj4B4DeM/IFbkmv18DI2iC6x55d4GqMtrU5qcS3hPSqlEK4NPycLCZRbWaCWqMbsCQSFaX2tsG8HyDdsf1+CelOrodPF2Zz7KMLGKt/v2R5NIpMrxAaC6I5hkc1MGCPKvz9H5/KjxfALeqcTOAVs28CIvYAmKCZG1PdqNgBBE7eVmTOIvh3wzwPp07VfR00fsn2tm59+5VOF2FNoVBdEU7zGJFECJqbaQW1JFXGLvIlaONjHgUZeMDis63wKZBZfee0+bFGwqzKJeew/oxNYZ9oWea1C/Z1KguIiij1xYpzp10D2kdczc6F/rcPNt47UjF+unE7gSmOFTm9iwznluc0gpfBZ2eAiOshGQhnA0xGJqP4pSvZ8see8v4W/VNFLjkRuhQHnZlV19ldoCml1YPiNais83u7I3kqI3tLsndPwILze7EJHmVSqiJP4XTliZ6eq5qIIbp0XFoFchSFB1NvImapJ/zInARN3ZXSsmREVGDBwCPGYqhqViKLS0xWUewlMq4MbOgXpOjDkIodfMNdg9+C5vK9Y+VlohGCM8F8zkVXKHhoL1oSDyVF62OlBDsOO23Cxqtmn6eXtHR88Q5UfMLCR2OoCfviYe2yMRyUslYCVhAY2qgtdjQRz7oT2aJMAjt9zme7T9R0pI5Ydbhpnx+PNbhjBLV+/dVmF3R32qxL7vJNOe2HYHFyTtTfH29vqOMaR8s+QrIQczDaJJNAPNVlQUt7pyjXNhzB5vmtNovG3JjYmFRoGBt8oFg5xzSOLr3yZP9IOXwOMHitaWoR/VumLu/TANs+jEHjpYJLMfR9ywEhaFGE/eGQYH8ZzXoxU3iVdOdhwYmmERgpvVBASKhuiK0xx/5JvO6t30M8dx3AkKLus2SJOlkXtzpjRvyQVX0veuXICTlYYbNYQfBNjTl1oJQjpgKZkQQJ54fdNVOKw5Ii3/taYKBw3Bq391ngAQCft0S3Pqj8dFJkK5M++5dypmAp+/Ud61XqL7vHBGfBpNyPmmg/ZCrLxGUjV3FXPjbEqlUvL0/IHgqnoWkSj2qJOHUOBeEwYNQOwejBca/grU7ISUCJLbecXec2AKjiNYYTf/tXVDPOL3vXNS4JbxbALaQ0L2LttyTiUjACeZebEjM+He0i140nG+UWoYcXPB71+MXuTXc52N9+048mXKsi5qlLJ4W5h9LX2AjI3N9iMrn/hJ38zJCH2Vg+R5+QoO1V9b/jQWtXidn1wTpMlyLUOckrxFb4p6bhXBXiQWannW2JrItZpUKGhMLq9KiDnQBwv5KKS66fg8TVxByz33r5Eg8tigsBCbuT7cjwQwtnmOaqhQcdPknM80QvaSgTZnjUIgnPjQ+jpVz/pox+psUYtJKNeYecJGosbhlMuro9RSr4CTAPBdpehH1wPGScU1oWplzyOWIq92y3CTsa82AtHsOK3sk1R/7NBEc2s7BFgrYKBwz72w5/rmajgdOOTqBZ7STONvP3YD40RfoMcJqgbuVTVsldCCQbXZK7kxzKqTBjFFldx/nfEVPqdO7ZczPIE4iEcuy1DqMrarkLgKwtkneMJo62l8B+PsJoPApaIOocXxI90X9u1BeEcrTL0SqE/KH23DMRurRryhmSaGvTLqglBMcDWy6kE4zY23wAvGD1gQwVP67JCMVLNn5EcW6uppzvdGNTGvSmMlHSQTaFHAJhDBwklVVWA+0aSTQCK4WbvAd+v80XJOC6RLzZZmcaW0GJMUueOKmzZqMKWXMi3Npig/IaXgY4HHYJzCzsKEFL5OQZ4enZ7OliwdE4U8VfifiTtYHMTlJLjCng79/OdrwbDRZhJQCak0sNL3C69zJZCu8xHBCtNmrG6RqrqKU6IgLkog6O1qhK3I1cYBojG0IOnYglcxrsRjaRK4Qn/tH19UkpzS1e48ZrjzjVk0TOs4trjaaoyLnQu0mOa5xxMiQdbq7XG+rjCrWfiKCRgd4sPp6mkq5mjInBrFWaH3ZqM8QOsQDlDkNQBfMickCFtw493H5qqHhSTQB6kaymbb/GSvbWUkMDOs098crONnT1M9mMjFi8KyNQhET6XqS/0c9dFz1ikotZqOY233sLIyc5qHynCJTQoQGPBAb8QW2kUEY5HZsX+HYpzr8ix5f9AbcVPOjZZiTs+Zn30w6jU3u1vsVnQlB+YIzc7K0SJ6SxsFfDm9WQEMFAg8283yyulMv1BMN2C8u5VphRNZ4VbA+bzfB9shgNcSuG/0RK+Nw/QdV8pUn1zx1LcKkSNMIkjrcr/htuDelRNtwAZWl5QCpqZDM1rM0hpWqJ3EhFeGhQ9DGbmh+43G4zqw0Qpg4kUzcI0ZYKdAnVlzzMXJwUATJBtNz9n0TOOSPpVoQwTZSkC0F0zxfWUpcTBXA/sQdVjNnwXYWtOjlqKHtblLd/4R1Ycchn6A8clUFEskbW/xiwzbcjw7bIjsknglbX5JjHEn3f6kGA2JxdFrPZqeIfNMhdVZgCdC56I8IXnbJCSldtDv/eoO/O4VlYOX1NiLPLL3zb5+s8hfBuNLfIXVhPp2TTtxdgmS67u88BYCl+fZ7NpogW7v3jljHVoG7JkWIZbBovhU03hDmKsaBetCuikt0lPq+e7IcE6o5AwPZC4RtGHViDTQLXDWwDnAQkaG2XUgnfuKkFlYp/uC/kleoRAQieO/Q6j+O/OJElXewmdErGdYcthtj5CA7W0lfRoXFYb3C4retNbXlRpFbunwkT+UlZb6CjFbqihfo3rSQCCC0hkCXFqYVbBXsgjVFNfxa7R7JQEQvN/FTLBaFB57xLlJmz9qIeQZfqlLV5dBDb+GWIT9OtgSP2fwKbwA0x+6YLXZdWCvGBQdQWk3YP0a0iwmt6gyYH8K2pkg3SIAOvtD/vSMEuskzZemBK3ChtzmQFJgLwg6eu4tRtEU3/kSybI4c6t0H216ZFwpsnhI1hTChD8HMFgx567gouEQJiMiTd2Ro/9OojOzrFdIlgxCj0m0ir9YZOI5+VKBC6xgivY8rEgBU1cRSO56Ev4CuwsTShQcPBzudOTPs1Ercd25+nyPGrTzAuxc9rASjSCPkVeRMEJx+gKVOm3A25x8+SKR3HUHPyANcUWewgFuRCRgNfeq50FOE6ZkokGXcsteYSL+yphZrRi3YdtX6fg7EBGr9b1Dy5vjaqirIYC6aHNnZp/sL+u64STyASi0ZMM3pEeRJUfaA+mQ/hh6H47pMkqJaiNMAzThR99pvYU6wtKKyWK1rgJYbMwO0KOB6f7KdZL5HSk4iwZYn/swl88qd/8nyq6F0xwatC6lOm5us0Zf8NnTW81IxN5GQONztZ7jbkBLSnSxhvZuthJUP7GUD09zbcmqwuhFr6lMwsV0b4trW/HGGYPJ5kthzmnD1Fs32d2S2y4GMqcvA2McEc8hANmxqhp0VBqqSonNAHw2wN/XhoxrX0qauzIHlGTolbugS3wmT2qnlPkMbaWvWWVXE1YQc6a59bp8/eMY1xMN6Vq6rhR1sP+dzv2Zi0CbpwC64WiPwqo/XuI1MJOnZZv38dDLZoPbQ/oUvZYlRvOwOIogXTaoiqJScWj7OlqpPCSntMLGY8c6lYGOZM3/LMBobPMDTJo++FP6Gt3qu3EEkfJGygYFIfiLRITqeRmw9+SHxTUrxVqMtwK+Q2z+NhEkBFVBcrHKGtG5D/r90pNCPf2l6uMPrlCaQEk4GFu+McDMUJMVL+wK82mOzJenvw25M8/Vn1t188vp0xWzmCAku6mA31YPfhiH68zDR4NjX7Q9il85d6dCS22/LCP+2HBbCO+Zh4jNxmoWZ3BxbtOHzwT4HTXc+PQeNROCyzIY218gSzo6SKK+rqT9C3XQVMCBTFo/bzNf75OXRO5hHB53aQ+CSYuuCYYvFF7hQCQmvvg9Hz61TpiACvRwj5lkU/5tNzOgAWczKDo083T9vXZjzkwfSxu+sfwHs2JZJIyZ+ZxgZLRcFKYyxbgPnc0SZX0+iC+tGEVKZQzaqGQ1Bm52fRoj+J/OdzDhh3lftBIUt6ZE+gJUw/Rmm+O9fNDvA2z0HAPmqLfl64kDOCsvv3h6RKa45LKr+Mri33LFi/Kvc+jmQB3SqIOmp19Ki7he8bIvC9NwwjfP2ju3q7je3t0an2+KHHM0YUbfGHgLsIvFiRoiskzi1Yra+3QoOKpktgE8lhIQ+qS8DTml3a6cNinmYNsZ7rIAJ2RUYHq+OUNtqskLRWV8rxSOrUDXAApYt7nnA3dYr4ITxldS0wiN/Ii87cAIfmKqDtkKBj1wuQh6KcgsMUiVygcajHqEvFUPI0zAXLHI/qiDtgQiUe/lfkenXQ5n0oVetCJUO5lH5KTBTftd1XnIo28GpXNu4ZltlDItOVs2L4SzkgGjNJ1N/2eFy0pot6IUPwuNzhIdukGxmMt3QEh6t/GsamcD8khxSbKkc7kjJ27pIqkZabpf6Ts1tsFTzRMEG0nAPLGcVt8NzHEzLmcXZQALqyDefUDSFFi6VwxRKfyHof5tijYtNV9272oMBwWsuOJq1YOdcnFcgpZc6Gl6kOg/uBO/enhPpREXsDGGb1vJce06Dbx6M0T3L4tzSOurySt8KTeghENsqC//yUvzfCfGMwLSth/C6hJPQ9ZXKWltfrxwV3O0RtcUwSegef8iCh+PYmZJS95AIOGfcOrbDggc2MpJTSShuQjly9oJA6gihauI4UxEaY5N3zjIdaB7qsjPj4sjQ7FEPMqrOyefIJb8xtAQJK3OcPJ1IC8KKWRYrx12QNs28irnfCmetxfLIDITkjAIdDq2lHZVcNFSn2R9+4ChHzUYdTGl0gHCcKhxQs8k6tRcNGyt/71EjIjIm638BmxUEPPgDOtdTD1OLOQr8roQ9IbAs5A5zhwr2vbUwX0dtumw8ODTdl6Ac7qDAdgWHaCN5ben1SohA0o6/WcTAmWQrnbjFO7pS7L/ZG9dC+9ysFNa1WzKrMRyGb+CCRAgsBHqyuFDDohEsA847YQxs2wdgd2v8dwwJ3G+KWIIt6toe2S7h6sjsNB6uLmx1uAFk53NBT25ue9bpYpKAAmc83a9yrjnQpYrgN6FG4ruVvRA5VJ0KgxduBZfh/ICUsmkJy3wqmsLB2r/CWTjpN4tYzNz0GDtFwuz+wcG1l6ss1+4kLo3yGwlE1NaqML9ailvCdTd/SLe/+puT/RkKn2LMhtVsiT7CDTuIGhJRiTMvSZL8fcC0QAUvh0XGVacdifkfi6QhXqUGvynga7Pr4AVCoGFgeRMumaqhANypzKKFA0XaomaYCXIaannHtC64zLa2juFg0dSo4exosnE4J3s62RVzNs/hRBTv2JsP3o3zNmGKDTAxGs6o7COpJKSnRDHmRhXW1sZ68GQhjlBPQBGyReLFYSvBzzSgWa9Cos0zSJ5cnKmUP8EBe3IXW6IRF7knqiUnDzBOepak0/eqFFaJeHyNh3hYE0iWWgfJSMcvpSvsb4n9CDbRIH8mQmFzf79D1jdLfQAm2k0h3TLmBDPx6l3D9s08WmH7Ya9pAU//F2o22+2uW56oSvFqMdqHHdaeLIIswcbKCvTQX5xKxX37yZtzV8k5+i5m4x2ED8+0reWeNZjq76ROeRn6nr6uhy+FjPEaY67yvgHwJ6k//arrPYWoY9H6jSj6QUyLUcTrWoBhio8Q9UP2ehCQ3R+yCFO+qf65Tt2EHPSXdNUZdCxKZ9ytL9DxZagcaTuN4rLsQMkznfGsRy++VkS5FY3FEpq0FOR7TRn/v+lPei7yuworPOQGq54rnhKxPx57o9LXmW1PHqTN2Bu858UrlTnYWXLwFKQQX7dw+KDllYLWqSlmjc1SAheEzghT2L30eHKY+wNZCxE2tjehwaSUhvla7CA/v0Aqy6lK4leKs7VvtKuBKDYkmQzUefXl+a5iDzpgYp2fPyXy3L9WwP8JaHzaZRf3ffJdnwMW6DCGEwXL1DHS+7WOEFlQKJ4UdMiajll4mcg1HvdsRiS+v5e+3x67EWwRo7+Vhdf63Vbm/gEeSbWqqmYTrrh/7Um5O8+sBIML1M87l5wj4Fc1VbHhepJBZTXCtUpGqgo/I67PY5i6alaHRSnJepBJkYRj5A7qJZ8o0K9t01ltg6y6JA3NGcCnOUY2K2s63ruX3tpI5vgwEnEedc5z65RM63wfpx4SWTod0lYIE9adcaxrs+HNb8T5rNVgtzh/AGnEX4TVQy7EL/UIcKeXszAdPzw1UQkE1FZilzAaoi0O2sPHmU7h67WdPtpK+jcBVO2XKEuKPooUN7UDn3IS2Nf9m3jXx1KY/4QYS1KY3NFz4osJ4+nvLYsUtbc2yFHP5w0AAI71PuPTEI6A4ChQcW2RHk35Ne0CpMHsHXIOa0xJ2TAAbjvdnCCc4s4Zrz+34JDGZu4veM9XvnGIHphMmCXMpXS7AtZw9Yfw8u4D/wm0bH0x+aNX9Q8HOBP6N1KnwG46dgVQKeYyRkGEZEupo4cPsTP/NhLGP6XJtv2JcMH65RBJBy80uHG9zl4RHZ3SsC3+SA4PaUYN0CFVED4Pf7RzHXBoGBndkF5rA7JE4VwsFmDB1uIZs7hpC9s9uJAB9FM/yzQpJLivuzvDWY6nDQjPLtjVebSsap7PE7ypekXSKlZnlK+6Bdi3uIGLPRZaBoaIad4+Q26R0TWmWFZknCAFhYASdhsOE7KchmC5Ma3PdsNo59vji+N3OeG+tzRSu6dz4vayMN07dIjRy0RjW8JjprryxCYUzfi0lu3bc4KSzbc69Dk6slNRS0WdiYXGnYREZcs/gNChJBvesDAgbiU2oZqdB86jKKsoauNeFLusx7WiO7X69Jd/ugf8QwY5YmAxGlJAUfbSypO1lnS/iLjdcVlfSAk2RjKvhnvKL4zKiY53jJk92ateVSs+EaPPWbBSuA35rTFS2NVD0r3TuKKKaZCxcE8ilsJHG6kx/iVrDiKjce/aXPOt6JXepfKni1eOiPRiCm02Ot2LHVaocLBgaDkHbxjHfAqlRUfmb3QRqaahSR4//nLrS7JHnX+WNze1VcLW6GQ6vcCfx94OaApsXKz8ogK5+GS8V13CuQjdaVqpYh/yoIo1yaurKNOTj0UD42JzCrSQB8yF/pNiFtFOX0NRj52KGTVV0JjjJQXaVIdIRSrIrYDfLJGoa8X53CZApsiERUx8gEAUujjL0p4vjr0D/3qoZ3Lb403uZfZ2+gpP79FWyUTcrM99O64PqGWmeMdv5kaIetHwEDq/y7lIeuE5uqyyZ5M6hzB9sOt5+sd/6UaPOvMeO84zmvzR7rlVqN6UXvVexyb6y74O5loQvU3LaD+4l1m1QU1Y8s5+dhN3kAqyrKQfWavDuDcv9wBTZxe6dHVU5pNEzR8KI/xl//5WV6M22PIxH7m5vXQ8ltmk1DEOFdCZbPmI0LowwbOzLWKUJpIy5ncgiVwJY38AckiHGnswwAIscamTkiwBMbMEmas6WwOl0UEWC9R0Kx2UPg9cYNfX1HHNvYu2S30oCQevhWrTxFVhtzhkkljdse20Z2BSl2B89kaWch2xaygCZ2VlBdhFfvSGndb6LHkbo9U8iK5HnECG+bxXZ3NACsJ2HHaC+yr5ZCS2eSVwdnVSmbus27JCFfl5d4SYieiuPoYuKv2QVgmc9TZF0on66/vNsU5KkenVBTLC4Glv92dMCBNr5Zre7JqLM2ypepooiIYwPA5rzFtahZe8EaLGNR43/6vvPdKR77pC/yxvTHWyqCXxwCfdUCGWjTeyp5JKWQXGfzHS99ww6gmRP5/M329ESsujKHMndpq+GS4isK0Md4W3H8w3vToC73RrYdORI1ppVPLQumCVyksSJHyWgnLhkakvQJ7ZXrrmnuk1wZ5PZEE3acLGsuC3GrCqbwaRwHHLCof+zZzzANGD4n+R0Nk0U4L/c2VFkZpgL5gNywLhBxQMJ4PmLVUPOgDB0L5de85YZgnJlMSudMIj5lbS9BGbdinJLXOepa6i+Vy8insVUF5t5mRvecz1ARRYPpQ87fP0LB0mndZVooLIt32qb2dR5whdmF7COyPcIxEl95wFKvqCSNQHY/8Tnk4D0/8evrlUNV/F17ka/+UKI6N7HGbNsK1KfEM3J/4HTd/soH+CuDje9avUw84cjh42kutmKtp+7ZUbUJt2h8HXc9vyJUD+oXuVzxmWNNngEWB8Ynf4on21txDYB+MbJcQwHkmptoExMtHguqP/1ztPETsDObNNbIVYkq7TXgqme+SraqHOWws5pydKgMPc0W2uePOyBMOoiPitVRWh9YMp7npd9VH36+7uS6DdB/zcg6uo7vp4BxYU9sa4+66M3QWrI5sN/mId2av9NKKS+93TR3WaK+gNbBv9CjiEAMMMUKngu1N8DHd2glYIUnRFD0ofQL+pcz6ecfBmSvApqS5lcScCAOINFUeK0OOOU1NNDNEcUIac/f6Qha5uhdVqS+fOGUUkf3Z1Ef/80DLGWjekSSDi0NvaEq+SxETsLU3uXo/bshpJB+FRU0xGvPnd7OwQXE0LOLbYiVtjQg/PaM+8K5J/OSYHkvC7roFgF2iRNhzqG/PcLG2QVAJE5/E1+5M5cNv1H5h+nzYXw18qXCEZrdLjel9q2h0/SLrSthtXfo8WIC+SG2iLyXqkEjUYojn0eqMKSyUV1UOVThxv6B0z1n9smH9CvHJig1SPaIpcbSC7jPwU+I4NiL7w4FY+Pr5DvQr+R0Aek5bhjwCYFhcgpFF3rOp3hWpwWyP8bssi6dttZaqOvsOyU1TD6jbVlm78o1pinFwWT/qHWo3tscm033zObcoUlnX2NlrVBRGZ1xwlHcbf7uErKl/HSySfPTFFU7x6FhXJkZs9V8kcYmz0JY1NScqISXfPzCfvxuDBOOGCKH3ann7p9tYVQgGHdc3yCbQQOHT9JUf+hbcGTocGWUTtDOAR4P0UPxJLy+CvRoDtgjNEpQVF8ocqDIL8RxKWuuEwAnek3ImiTPtsyTylDx2UTCxhr9jYUZ2s+walTnOQHa903tMvNpD3th41ChRIlZCbUWH7RY3iFEGpQphMNYr2OxzjOlDHtvrtBBcNEvS53h6PtQrkTgXQxKyrtq4KQOodazvEMkpGmNSjOBi7O1IqTWrEbkpj7vmTcbp+F7AlySyaFQZphPJ6UQM6kIahbtxW37O+z6DYBEx5jAWx6iZvfHFmXzo3mzXIy0aY5okzazta/OyP2D4iRshpuomyBFxrna+Em7lLtcQXtoa8VoBp4EuK+Q5DrTd7StFkXpX15ceUQtu+Xx6rygKrLQ/aPwg6sRTg1fgRf2puy9+udl7yxYC7jKyIs0/NPZazOVvG72Ex+3fA6S7rw7H/B1yrCBkssEMD/u8JxEAFhXoHe2XQRxULPGAtSeSF1GBRxZ2iGsrEnp5SIbOqjj9hU899Y0mfghGI1Po1sq9D3Iv6PDUcr4Fw3dNE4mmtbpOvfYzJN9AOzeLX9IsK+Y0SCwT7bGsy8B6bIDlZXC7QUD5zTG1IWJH0hXM0LbZzdy4eDnHEtCONPVfp1eicoIve9MSyYhXazjs/cyPFXZafiLJaMMV+cdW9m1FbuxrzYRm6gkY6gh2YRBmC6ktwAEYMfvmifdAYRRKfuUZgjmz6n+yR6xydxrDyqvt7k59GFBQEkJwUwCx4o+YtgbLR2A9DSX/6Z+gx9UXcvAveykb70ALokrG3F/K+UAd3WvaIWjSu14lRrm2xm5po7NBsSWAg8wJcbBe2xov/Hj/pfovW3/IRBnZAbysg+DXanz4aolwlrGOwKKCr8CqEcjA7vhYEF3l6/4+vnQ/IRHfbyM2IJKDNLqCVEflXIW0DBjKfwR5IAo4LBIpLnmd/iJjg2f1EQHP5eckGr4yjFENRpS0nxemE1uHzch0n7jlDAiBDOZA2dU23rOLKTe6o2fK4Az9jFIpEgUNhk4k7txEzLbsGlzJ1S0U5ea9KhK+BKEfhyYQ/GAbzr4jnyI9vf42bx06AVt1+wvmvC5/MNeTq21QKmYSAHti95uCa1J7fOVhXQn7X9MmU3fg/mnsfIbTxIbThDvZzKxTUlNfHXWcKSrctVI5BSwm6u3OENqpLUaPmt5Zu82gwc9HSfRmKDpoQrbpysnaDBskGGgPjLW28ts2Ip3q/JcG6KTn5f6+tL6lnEKnMOwh8QyoVUQGrAx/BbS5RY0Ss5Wy7T62k5g6v4cn39W7/tSUFa0/TuAbDfoegpGeE8pku/KgcxQHfH+C89mHeraQzmJD+qTZWQR0ofqOhc9hOCDuSBQDVM+qtxkP4eg9DGLVlHJ99vVewrpkjVDvV5BS/skgRz6POvxV9s8b11VfcsnsnUnNLVoeKLHEXo/U4A9zi9pARfE+82Ns6ZpDU5TaZBl/zUxwcYOL/huRVog1Lj8V0OctNSV+a9+qMMheztt3Z8CytVSt/+YLC3pVtUFfBxUsTtHDVwIBBAQRr1u9RocNXrLpgKkFxf/PkN9nxsfmgQ+6/ZtCQhe9F0FHeXZ2llUJpNYFshivFv312fmPIyCczj/M00J45hOUdwlfOFElMSsZJWsVIJW1Unl7GhoWjTfUyuEmTzYXuDlBZuylR5cOgkloS2Pfstbof3IgcQOMrkcJ3pX3gXbgsV+ZjCl0YaxD/c5VyisyGQHQGHpBvM+WAPCiTcr8daW4hoKLDR1Nu+6scDpHUA9px+Wgnz38DWCuZNfeuNeeujsbfbb0k2HoSjJD01Jaq8rjlIAPcvwu58yrT2WI4P+u++fASTmwKLVFALbmtuGF1hmhOW1vH2syP7Ghn+wLFk3dcRuWUDF3ZNJf/QiZQkrDQsqZKUEk7wrb5CUMTH2/8t/83MWTyjWYYBYNu0uzxlvmkXitPaplOBGHnNNEzP3yKX77FkIzdNjtak6Xu7CLm5Odt/KMnB283N3iY+a/2AToh6bBnCchHL+zwehWLph7n/tw3kLhWg2dY5qJNBV7GqyT+r0hxF15YSRr2attM9FqRFIP3+jHKdC6Hdiy5F3hOkpnxvoHXW1zzFqLXJ5XSEfHTFvmx9K1pi0EJ5IvMB4IL+ovm+yEA5kC2oJNO6vQSEwHVUpagSoC2pXULjpOT7O+wLpW4EUKGY71iqUgKjIBajsWEpG7lvaoQT+T2xuQ846lvhz+7dLo4lBhRs3Jbk4T/DCh5Gw5ZdS2eEzPdxaM/6yrj9ba3qyJVM6moS7t/GtB0AR38FCMXgzEUjBZBcoYGECn3sImNjXupMO8rkysIITG6GJLNq0AenWLbNbexxyvquVGWPJY8cQLeGJ5Qt76rXdIicXmdE+KWjf+pCKPfk2lt49RzuwqZU+l/8k7uTWfsZECpw3ZEPtR5CbrT8XD89/ngKUJka9tajk3Hz326gt27OZ72hqAPgTTn6RIDI1IprqW/SlMMHQZlIjqK10quCZww4d9WccxTLWvpzH2BANcSrPNEbIzuf4l8u7CLsbgsYqLk83qecX5Ycg0mjXuSlU4GAIsZsvPYHQcy+jn2XfbPyYmz+PUH2+VLYC/EHTHjwTbwvIYNwDTwMji5wKoDhx6rMt4cVu6pSW0GsyS8K/y1ZpGtZr+V7rDYxoUKJYD5EfJin8O9v8G0lbzn7uSBZThibLIBQCcdKoVkJaCraBKBWyAOxNDqbWNbGyWFlcjw2+tPIKGkQMDKsgOx1ojqqb7r5dbV0wK+exsunkDW6zuxNuwBZFYh/L4FJCUBtQR4zsmCRz3iFb0OgjZ+JlC+eLp7PfbsO3cVVwlcJ6B6G88uchD1tFuxceJw/p/0zyKBSG9QAtKEO9Jrnbq4nJiorg1Z/wT3jrVJRusOgLJ//6weN+RC11EGK5K3Y9J56nXxHMjHwBjRWoUtpQtHIXLIrgxPqdQyVymRszdx5FSFpm8hAFPKgqy1awSp+ax2DGu7aAIUzK60zxw7lt54R152RyD0V/AfabW8o1DSglnlXC6vVPCBgTwP8eCy7MGbONSYWdicNYFrdJP49k3LHtVZEouLdScqp0k5NOXtVLmPVKg+tAsH5N88szeoX+Z7kf+SVmQK65Aypzy/NMUyx3uZDBPj9d1LrLqRUSxLssFXzVo3UC5a3YgoNMlafMntnImrgu3lcChL6PRcOhx/T3rhTaDfXd5nG9q0PI2hT+pekNXJ2e0J21iLRxuumvU6ljB31e5+rvzFCc4tnZjvRbbKguPtHm5dvSW6rxIM/r8jUmVcqZ9ehxhRVHMr/20v2Hu5IEEaAvMj15FFzVNayEEIoqZlz3yVofhvumm2bPcYflbW0QNTpsRKn6fsCWN8vQ7z0Le7+K6F0VlH3jiqoNPpOj/cOaroprhXWhK/Puacy9wleJvM6jVoWAGFnOS+Zh7HI1vbhFDA2DyYT1nARbVPlPcWaiqYilVql9TMzb/iCLvAFnzp0BoWXkTIX0hSe9gozOfafauJiEsJqEXcWRs6oNF+UY94UgKLMypRf18T8iuLgn4FChEH0zDRbxQNn17QLB9TK5Bkr7pcP6MrUeKekz6NU7uJof2RAXZ+D4NhaLWGzZ5h+Mz3Yh5PuaTRosrek9CXkFd0PgyljGgQ5TH0sFTEFdgaebR8b6CV7teVb1REVDcOb6yqqSq/AOjKgzUQ+NLiy11tkrLJzD0SjqNwohThty48IB4PPEAG3GJ91DmUNO3qpu9udjjyoCWR9Cpcl7Rn+jxQkMln5IdovjfUuUL9UACB244BIH4LiWeXuStIUXBCoHJ70S/OOQDtoH62bwhg1YTId4WgcZzZtrIXIY+v0WbUsSZ6j8BQPEr7xsmX462mYMGw1XqwbQY3tTaSxyQ66SZMJjOBY9XdOu+dRUTrIpGlPCfyjV5DqEh3I0wlaKLVdMGpE1K3+T/MWK41cZrGg+13GLUoj+BiPGHTub5wR1EKdEXycK7fstdB160FUhSsuWcO5fdfFWrf+oUmy5kj2pEoCPkAkcavEU7nPUDmUVqFCDnQ7Pg0OMm60s5CvZP+jH5nsY/fzvf8pBwrivNs2emEggB493n3z3XjvNNNsoKRdqtfLlNyz4Gdv3CXK7sHVW3RZbkRfUvG4sANjAyurAQ7sAxPpTXk8GFRPt/K6ktdqHrpgwrwQvMNns8X7jWtI/eGWRwai/12ONutvzGWz6E/S1tYRMRl7K0ilgFCuzlW2dpMrBFHsXIOxi/fDYCUZKFrxQlnUSBwnY0m/BC4pIuutwrBjxPgOBM/2qBAqF8/2Fvgc3bLXImGEjpuUKxcVWSlrc+rvoSYBKPluAASFyHbMSfOuUHo/vv1N2EI6jKn15PWTEiP5amK17AKhLjdBA3/vkOVbEeI1w9r+ENfBJKp9uUjmTVg9Uf7SQV7/9C4Q7Ly1O6z0zxtegAklrbrjeVmQiBZI3IbZZNtGBXFCV6jTdkYPyYxrB7gmeG4rltC4lh4KGjxWwtDXRI3m8qcuzZuAiBBHyCphfgSbOwx48MZZ+630y6PZnB0cFrFdLDgVayuZd4SVO0dd1Y68pFl485tcRNCoUApRagcUxWp2oT1dyXZEX0vVSilcAuyliTLlJPNb/l9kD87bfAobSIFsDVvyn17XgiSgiOFp+t7UHs52IwhGDeg9LvRQpIXVTPRRVUucn9Fl7b1aVn9Mf06ekAIZv80elqS1LSHrL+1kuEaN14lGmYHfVrZlc5Y46MPNwUTwhq4wlKWGwivP1cHjHtiS6Lji3wbP4/j1N11GfxWUqKqzHsnBUEYSJWPtG7D1tBVLsXTYeXBcDi7zJlGRwT1AqAxk6NguabUDViGs+HHYe1Cd8ScixNFd8tRwXci1kDW7JdPBtYs8XSJU5Zuey1XH3dP9WFQ84A+K2xvmeqEsCENc9b4kAqZKU55bcxTpL/I9EOVZnmqnRRTuQHkyUbqn/cZ+ba9epOYCefIuG5xWnNHGvkAs6YehguLvSh6l7ERQ2Gw2nqra5bE3p75bmnVL2qqH8vFuxoPmVQchYxnaAPXrttT6ILw6ObRKD/vE5QyTN53hgxohpMXd3F5wlM0SBhJWBG0Gg8DueWPRcNs9hTWYlKDwA/nQY18R0sSpiTVqXocFUVQEyAIqD110xLD3F4dvhVsGagGz5AMF07YAJ6rHGcB149Hrmb1xcU4ypCiJZ57+ozyOaXc4LoDaITMt971YQ7Sej8jn8829vNyM3vvBH/PerhYyBELn31lUFP79QouTgfzB3wGXEnDXKfTt60EUoCBrISS5PENae9iMzb44bWJxFldi4bieDoaKYW2py3SrcX657hzewebQsp61tRb0sXwhDQEahukOJyzWrayE4DULAPqJilh/k9rh1GT4XZdW6xqPWqfAwV0YcWCEp6ewLpzGsvArKVjycuvuLeRd9e3ld/xcuTEVtioPqj/xqDfsxS8VNN1NNgCkC3NSCW6gK8HmhZXpQuGyRFAvbP1SEZED4gRpYcJ56MFMDsunfxtuK50GapMXhVbITKQecAJpLpFMPCZvs0RzsHWXbJn7AmDDIWPVuiiJm+jBm70WZkCPbfASPL3Vzu4QFDIUYeqODpWWWAzIJzmM5G0vDX4PHEp3genCmNfYPhClM301OkoOHfZ3H1WhGkLWf7lXzQeP52aDWebcMySDNpPVq4HjjRz+po/JrMVC1XKVihCoCm3Xo0r0WY+5yleAYZjskqm+de1SxAEwePHc1K81SApAagaLg3ygjRff9Ms7qgZMiXErIpS56afui7wOjZj4ATKf+diRtCaR1OnuGlJ8tyxzpWCHnwd/X002jld3MnHB18Nkp6GwIvVVHi6QXqyJwEhMmAcn2Zx7Uc9xRfLwcn9IV1A4tHkBE3Eog/YAjLoGTyx8D0c4sE0qlUqkpafX3EXx7GU3LRS0nWvlai/giN3ou/8id/kQVsjfUhdQbZSQANosXG6aT0BdkWlC/KzeWgLEp3G4kwnGjfEjmz0FK0e0nRKoEZPSSBlP+U9WZwL6V0ynTLPtL7+CH7SGwoDz6TqvCfbI7DUBpPWgR5B0PzOdMpL9v+pyPvnikrO+y2rJKh3jAuFKAqOg4Wnhh14T1AE/yVkY+ne2c5a39tjpiA7GQfwURngUNkau9UGrcc94rS5ljRavRtFsaxAoRsav6MUEs3h9xnSIirjtVzt4tOQhLjUPy5IABRsT6TDyw0PsWtfai1rju2MECg+946KmuTwWLl4ZDgvIhE3c52TgScbSi6EQaDPRg4ZF7wXJSKP1YMLXfGlqWU2NHSMI687fbbPDKonjDDJCLdfFYu9f2/foZGDZo24qMkipbxrTqVQf7Vv1PxLkDQlxnW0A+OFBZj/vqHMgvtoyKWHtJGR9Fp1B3xfXD8OVRM4fdrNjsU4cHeNknq6QTXeP528I0Viw1PEc0IU1bCOCs1kNd/mkFzRmaQ9xUgtwbpNHOIp1JiBKFSBj4bKbnA948Uad1eVtFPBgrzQ0wz32SeB0J/WRDeAkrizFg0eOJD3xOtSbZfszLMvrckqUk07kDa0lqFHCQ3OtRu+x5jYAW+6c+iALZPno7uFyWJWpQFNhSGEMsvSTTK/J+qe5L8sVaO7KI5WXK7scRKs34H3eIxL2jX7Nh5sn/u41O683rUflYLr2/crURYq81Td5Yf5TuH0LSVAF2lEEiCRsqo4P3BGVdpJvK1UPjvY/DrgATTph0YDlC5pfXMDtQPC8Y44XV1G2TA/9tQYUTreMDgy1irMWpGaX17hr4eZ1iPrYzsPTsVL139eQ6/FwT7WuWXQpY9ESrJ2+7uXiFSxWLD5jPd281u/nseavuo7J2zUih9PJD/lBNvRwXKkJU6ZTV6MSxBOSqcxDYbdZ2wnbKrkk/ZVIVlne4mHW8M6/dFGLnQPMN+0gfKt6CGBVxOiH8kkC5MjQQo0Awvphf+sbQMig14c9QIR6qcivBeZmvXASH5tnidgH9pJUjYB70nNXxiT/aJj0iD2Lfh2OIq/UvPl1LsYqGJaRRHQwnCznxM8+rOGCfb+As1KaFZR0UrMseostSDFgwwzHm3/f7n/aICx4Lnlza+aNV1bfX/liTPgtPU67jTZJTaxL5jBLJHGoeODMzqe5UhhyJa5pOiscq0/aJWxLmqakSBmyaRwQHM7AMYsovuyBgVoJ8/rV/eX6zELeHGr4qpGQs9z8/zyuD/LFtK4/NpNZQXzjIUgHgXpX0aZAyvqI7HUsDsXeeTW5aKS5zNMd92k8lFzGHQKospQk8pL5Eyd+peNcXPak23S60Og8AGuTu8MLeDelx6En+kMES60LoJWfgsi1EFu0BJRjIW9IrTjoiM7xEWzMq/FcaWncm9TWooBxgOYkBHf8bIfSFDinocCeEJLIfhnfRRDFK8/267QS+aetElvBPTmPjORBE2nkdaHRhvFf0zsQpY1s5RxrpYN0xVhgOhy6P5+ViGbPyBF4kYE3C8LHz6aZfOmz+Dp8WCIVvWHcXyv60/dUsi+yTe7a724Na+uSheW0ZV+5DeYjr69qz8tmy7rG4t6xlXXAOgjW0Oqj/8cRJXOT5N/dpHzJIa25NoP3r+XA3nvH9sludGYmv88MFn76QG4jXEoIRkBlLRlLmtX7xZbdapW1WwdcSkuAPlOlBiItqqDKmKUTel7djujLw4bomN8L6+i/KG5LTBZkZouZiI2a6xRrhy+f5JAwsFCGL1TaBT+rbgWXS4+RnryFqe6D941gty6DDTk/7fW7HeYqIX2wlK3a+NsL1gc1R1YcUpjwEvuokEQ6rCjvU4pUkjzwOU/fNVhGX5dfvzJzrcqz1EhQZMPAzc8tubULpQOWY0YhocakEQY57R6V9ThTuFiU7+qjLQziJe4B7Xum96fC6YPi0eE1G8aaBwahCXaKFDVqBIRh45indoWZ2amHC8OMiyhM3i1ssVlmp7ZWp65DGgnHEydLjrLs9i6iKUEA/ECPCUbj2wVHcGzaQCy62Inw5suhaXsHBBxtEIW14hBMOzr3em5e8/ynAmfWIXEPbmctoA9SO3eFheDYOC/teZsmDpuvZTy+NGX6XUQdL1ayNIdKGa+dyTCT3CQPro7MPGlmMMkaVTrr0omgpth5WBrtjPKuz1rlvYKMBLItS0L/5JnXnnsoShRs3s18uk6/IbuJkwI47azfXHXXjIL7Z4Qp7lglruhvK9yX6YozCiWVClkje9xMT/NVplzaivdr6HmEpLrpbgsbnkuH3Iq5GHdglQd8kXlAjph/3e5kL9XFPwyCj+TOjl+jInfDLL/melToBEmkrzrN00mWEyFG6bX53u1Gdi1ttJ7/MIzj2bxKZarRRLoHWpHOgeY8JWKaR5S7GY8pLBLuVh53IPvSBSDY2p1PZEWxhJoXNCCEh2ZzZM7BprDZQe3uTf+BmhTT/pzJ5qhuc2sH9h+wb1GeY9xKHHcBEhvrRSqyaU3IMpMwPnrA+ZlPodNyVv17j76Omwbi31cCcnCQmKyf+7FqjHyuJSDVbOPfIjmEjqCsKZqA3+YQNF9EVqPtyTiLQ8Mc232zDV9RIdbPZLAl903pzhjRA1VUjfZ93I82IgyZG9XpItgYs5ItJMP5mZRc2pKBdabd0CU/LI/DW3GCf6dEB53usVEkvyxWi2PhptPIYNxynO47P/O2yyjFlA/KthxtkqdlSVq4i44pCz0DxdXfsLkLgaQwFcCYqidE1gdAOi4ZR2lus8OuR0L7mdKCY78BuB9oWC4f77yDlihdldT47+wuS9L29NJ6pN83HYC1Unc7gHlLyf0pDnNH5bG/JqIyTl/nVLIGIHL3LNUQiXTSbrGWhtPfj3Sct8bi81ACwuy2L1lSR24AikC1HoN6pOHpH8jtOs3EawdPtuV7hZTS6bdmFlZj8hcG6tAFlJlG0Ov175CrQtXVG+gu9azAgZXwU+AkBzSsxmo9pjCHp12p4HI5rsns2bCccy/GVu2egSE/pHSi17OK/5kE+gvRy9OMym5wH0X5MTOhsakjxKym7DREGk/ILOTqdKQ+2zwoKdcxvgcHvyBJDoeikXpiLH44g6ZwvzyMlCDUAmKhQq9KcUlcFce/voRkmbm8e3QlTQNTzKbZdsVUTaMCbB7eVcXvzjz1EactWwm5Fqjof9snM75Aa0NhseoYpY99vHOIeCT2MxAIXxOIVYC32xgEpzpoCxz++IoBxoooDwzrMOZV5ijAuItlNTxCtyyLeYK9DvEN1zhVeDVODRNslQj8bgRxAnlyPsCRl2I+0FkmLZ1luIW7vPZw808v1kbngqLFIA52aaph1FJoMFNQ8PAvNrUIBw6KbDTu+WNzmR7nB5VaHX76QhUOYJvwVp7opUyixBF1a8M1PiVyvTCMPAU1R0oI3b711B443Ds+1w4X+nAJD1sWMM4H/0q/Ov4iauuMR84Zcj+kJxfubQ+Ljypzi4eZAcfdwapJB7ZIz/XCttskDb6fNxPmMdoXqReIpdQsLcVuJEGEi1MVE6HX8pP1MRMS0m3JiPoIs6zULBeAOc2w6gIrOYA8iWVmvATMvWwgmnARRoEmV2c0ggo8o5X4tlEDlrUdK8R1/uZWt1dcXwWf052loE3X9cSsJ2HjMiKU4KdW02OGN0V+BBMtM8n9vE526SJOAkY+ErVogycYKj7pC+mHL+1/0kGVit2kaoUwXYNWOLTQc8AwTJ0nQpq3nvw6tH7Ig+1OaQGkr4Kp+MwdJTJHZjgrzoNALQHC7KgNAyjGecSv6GTIh5wE1rcJ0Y/G5GPIcFugjh6lIEtuU4d0k3Rozz/RGAxhysN4KVaQjLSyF2oaRzKB5SjsbMu1lKg1XDbNwSiDrRYd2uYhEvxYXkLbsk+LkyjF/TCnQ/iAHvmSPmxyB+Uc0IEX6IgOzTeHYxkcgO6AXJTCVJUPiaAlAy0fkpB7Le754miEmaJ3HQ/00KGwkO5Bs+avDNpOgsS1vPGPAeZfCF2AN5kh/OqfofJ4hRLPoGAzCCc5ixeS8bcJhWQjDb3zg/WK4NC/vklbGs7vX0UDTUldsu/qcGZCZ10ZWvF5qe0ZELiZ0weC2laFFcdCx2TqbEAbtK26FbYEEvWG9HUS2Kdnnugo0HTTlVin4Bq33LYPFD3p48SgQspr7s7SGrdzuKHV6EarboO2QcGLYt5xgbBGBjBC9rewgpSuQBPH+RiHBnihOvNkxcEmElYUZVlhw9fcNzmNCLQAJayiXzeUXlTUTqr4Kp1Kq8jMrVaZK6QZsM/h/d8a+KjuIMNvSp4oZzaWcbpfpWHnIjMCrydmo4LXFSpDWjpfhNtwn7LRhV2wRJtZSHeiGjSCA+xBYD3o4/eHXN+NCVPxnYqDbiTSmmNXQxLVGcmufgUaWYYYTKVWz6zyALQV2QQ5s/rsTocuSdkn2z/9/Pls1mvNRESn2lpCHJvvZBX0GolCqkrF3NaW4xWrMtilWe3wzUHAlTjVBpDNx7X8f0JjmBelsn6q9E9IKPK9h8bm8kSt5kabqx6pulqIb6edxT5tu4pZyrw2DZUNnu2+AXaKb3cUUNvOTANpfWaNGCw/eGkrpzD3M4KeNG1VjFtZaftvCyuYNySDJ7fONTSUH6VF7HO8GH/zflrk4ZXVVpq/XvgcFzvGCyonCm7vPojk3ORKqvpcYQMC2Ps40RHcOIlXDS8kf3z5Sev+8LjRM+CzuvHdXtiJUxbT2yJLoFlCFKcOQuU9yED4N+PBLegJa4I4V6vo2/CnFiIcrnZu6oAgJYuNq8q4/g7nSqHuDs9JJ0rBjDxgM1CyTWel2hz6d/GYUh+ndGT5ENzGqHX9YDsZ0/ggG3TnVep7sUy72ZxwCSurRV4qMjcGbN8Eea7UmHd5LyZyFyUlTd+k8ErFluKKl8ylFSMHeQ0wzDl+o343+lbUXRtg0ICDVHBJCG0B8RMwVyRT1tuNRCcFc+6qg2gicadp+ggMeKycYeQPMIMxHgBpgb4rlMLrWAvFibDMwtq6TZK4GYhx0twvEr+mvdKEyiCn3fboMhx/Wh3npKrG0G20fd7gZA2hyqr5jXuL7l+FMZSfPKEUH2Jgi0HiPljQXSjmH4UN3mq8tD9YqrtdbMCl+zVjshUc8LO2JSjgFt2lRJjaxeBNjCapqHir04xuEcp9YZsX6O+7TiuyumtglbBld1LEdxCRJDK7pnlOI54bnsbTtTzdz/7w+6uUInFvTX3sXwxP9wGhVQOr9cKV8PTEC2TQC0i/BhNW+ksIUHLz1N+/jjhrvhdLcOi3i6QmPs2ilxo5bO9hpj5p+dcRoTWGVe74sdgNxPy2jpYwzZpLTRTZlvKjCzvVkPpKS989UWT1Aqj+yA5tmFW5V+OBEjU91b0AlBGHQMrxdHZaQUF7gc3B4N0jZUdj7cai3R49/JiCXVKuD+WnsffUCrzI8MuYJ+Pmt1T0bPVbCvcHKB1ZDyLWrWFc+u2GXvN1UrBzYGGN/uE0zU0v27tdAuMhKl76nqWBx80RbISW57PkWk8jBqCHytFKR6yxNMe5i7iU9SVZxnl8rUwCUTYFiMUX1VmCo06WeBtGfJO/aJ3MEnzNwjNPyzsnaJzjNoITjt9TfkP0gL/FCh9HXJshbTykZz+rkgPCtOBPduQOK1RiAlB+jQ/d8jj47cfPKCRGq2lDL8bzs5FxVeQia11gh4BGk2QCOhZy/d+Ytgqnw0E4HMV+dHuMfVFjLSlIaK5L1BNqwul5xxiy4pgZJuHmNMd2DIa78hKWBtsQ8nYJkVlzPbJzk6d1gg8cC6esJkRF9trWf7hoTz2u2LjcHq9GKg14LmfSfcB8P0CFIu3cVErK81IlaohBClZNsb6uVrsEfCFuBHH2vAzNVSWAtDokjXQ2/FWGoSJGikWm9Qr1W2fyHGyVLetuyhDaLilhxSF9sHVuJwWNvhBkV6E2S9vnQJuEsfVSxPCYlyMyLt+SV9o3Y9UCihI7BXOYn0RsjHqUinefTBmmk2D3cm4B5jXHmoEYKWCrAOjUeupRY1O+nksN5emljq1JnfWml7LiFX5hUPOTLa+Xc90Brhe3YNtdTGjKhldISCUiKRpZcY69nAg8xSSYGlaCx4OXI9fDUi3ieBVkJ+1q+TdQjm/o+izwa/xo2UJrHDWMdZcATP+r7p613p+PqhqK10eA08854aBUUeIOBvm8AymczHW0y9wqOnqGgZAfO26ufBIxW7QXawQHZa+MtrCHqffKuE24BEooKrpHO2QSC7UB0e1snCVkLByKqph4+3s8zZtQQY5hxxrT/GKAiIXEx5GRVmbSmIF/p2bxMSjRlrYxcznFTTuU0P/BdpYeMmJb8KcGbHwEiWUgiIeYFhafiG7wmrGmISummICqYIfcosAYDV1Dcc9oSvz1mQFqbEn+ID+q/QtR391HzX/AjL0Y3jkIrkp+ipJN/rtHfEkaI6/WiTObBNUqVEYkmBxiA8jXQxcZ4mtWHqAGXazR6kBDOInY/C1NG5rGBJ+KxhmWhgHCwzPmF3XDJwG4Q5/7R+wem9rUZ2kwujz+Tu6TdshMtux2J/VwrDFRzcQrDjPpXInxtAVfvWC6O3hH5CCtPAJor1rGnJK/TK6saH4SIdfDcx+2BBrttlefmHG3pVdiSIzb6Y6agVOty+iuo5WC/we5wbTcaj5m9vXvmMlbbt1PIEyoh2GzNwlYUDInNgWLqKH5A39gsMj2b+j0k2Hb+ufyZFS4T6emKJt0bi5HmFMuDRGOFgDe4/vANpyhIIusHYlbonc7gIELrxJM69/2XjO6sneQ/OJ6onJkJ/jzWP3NavOmjXxwgP9fzDuKgm6JpugHhqBdzQWdt8xY6ucOtEmgpxY9LWnUKBHF5tWIEacSE1JEVowzDLJUut2VMEtcirshMombcnXQQKMpk2xlpcoqRER5M4twVbNmWHtpyKcmwfneLT31B6kOsqBEvbpKuvw6iyNypfJ95Pq+2ihjUSP2pIhMo9D6n8xWFJhyve2xmW8sIz8sO0bDQMIs661RAcV/7K0K73WmdScGiRKEPXMVxVNsU5JeebO+Fu+vygq8bZTEQW2HmgoJRDqTw7CxyPEZGYaZKDgVYYM2FfWJgN6ByOL+11dKA6m4LxThoisqj3vka22zgJRDU0Wo3v+rR82xQh6wYjd4jw4tbSp7dQz6KcDVxN6K4HNg1VhbdaOMhxI/CJAg/lqTcI96BYgYpQC7xI3H4+5ZpRr6IT3tC0CbMuHMcrJIwirwbbKDQ9pqSAMvyXSHIAVM6V8HXF6HZMnWJrKObz+U38i5WKE6mDg410fJaOhqsv0ifYWHHxLicr63afJHE2vlEit9Uc7CdDHAcGSWXV1EWgJ5/1Ik3imLPPa7Xbq8UeP9qEcwWNpvAAw6Unnvm6fY37dSHAFNegOY5tH4uL/QoBMGwVsrsnl5L7/6BxOnORgUe8cingNfHvyKs5m5s/julXAlj4gqaXurtJbJgdgjh/Zg+cQzs/6HXxf7qVWKLCCDgnD8KFyiKlyz7XUsd3QdQaovvIS07+sFxdYzHwcdpgWTkQ5p/PPayDIXI2D6GTcVSmi/arkQn0jn9YEdJ7RQNau2iRMiuFI+4BucrBzamxfdVOAZwf/PkPBvqGM9683VeZQALPfVz1ma4sfeCurv81E81A9xKZwrnjZy35wD3+dj+UFeOj1PrX2jHyoDJjtfnq9PyYMAcMP2F9scxzvGp6N0SeiUZ7kBN+pSbNDHDkQuHnB0x4La+vvlfDqfOmvd5VkufSUqtpQN4lqo9spab+Qi1jWgCjRpaFfsF63fIagIAgnAKeWq2vW6v4yLJRrZv57iOJv8plKzxSCHHyNnWRvmsHFiDmiCdSbJ3jL8prFzqCh2yHXTCbdo97litNAmf4Y1pQr4X83p655g1WPYVa1yZ1WrFMVPNeAIC2AuoSru/gQX8Nrys2anXG2VnD3U6NiANpm4Etz9OKw+0lGgCqXr8goncXuOY7TdjBIF84uH0t4ztVlso53IVE04+4K7MoQbJY55p5hXiXdtPiDDWwAGligb9fg0l1tWjbh6b9gyVQ+X6lYc8S8tKECtYrzJQJzCN/azd8NH7EFi22YuqP6IGMkqzPe4kk3vBC4Uo54Rv66JvyoQosRScHD2nEx2MKvhoNdYrtztQxn+xGN8mInE/fmD61YFqY78LTptUwhLBHpk9Y0NObSsZiNM1nDlo4UAmWhrh9Ehw2sFaYgP1RD4DRc7dBVS1BNr/e+/BPpstvkCNcpV2q/MU75ZhAoIWgQ1S49Bj3C72MIslXgaRkIjbkNQgF9vorCH7U9gQFJG5hEWWu3CZoQ4nsDIZpW5dptYqA51OIhcTYEVNPQtXoBr0wftQEqYca9Ply48CR4zxLCfZzBF8kcfGJplxQPG7HbBHFLLsAEPDdjguzmDnjNDKpf0w7Swpa+nCLVOa1jbxLzgbsnGC6IHyqp1UvpBESwP/ToeSRrcviAS1ihSEnMj+FtrDlAeJ585lEIHg6F9orLXtcRJqLRG4M1iSiJz+Kc6jNXG6f1iL/PHf99sayrnmDnu7G3FBUafuAQlgBLrYVAPSItt01e13YWR28o68Y2FrZfz7MYY/ipx5PRysfBSsX1oCuW+h1kMfxlpTmB/i7gwQ4C+FPkWbGU08kN+yKbPKzoW1fxYkCb199mkNcqfaGPqrQ3mjCTb7OTYvwZzgyEiwW3/IDF8JkVOkDBEwZK4GALLwg3OqMM2SCXqtwsfHPODHhKWTNmCIdTHb2BpHT29eFvasVNanU4ogFbSeGX5hbyJwEFmWuMiV2ALowYZYf5CxX/kIhsInlRq75Ai70NPS0Kbgu5IFQhjOY/BRIPq77fYU6w8Z5IK11gnC9+U49eT/qqRzXzb0bwWUgGsOaa+qhJRIeyvOuUjAJXHufA8K7X0xBPKYev52q8bl6Y51vJq2OQ80JTOgUAT/GI1qBXEb2+OLV/0XTRZib9Jkco7oU76RdnS8KTQnIvt3IQvTZyHYuzTEiu7WO9lBcwGzUhL/GwCneXQz0WLLdEe+z2B1qc+sY2uYMZHAkOCo3HknCLG/KF0H7U9dmELASwmmXU6vLEU7M+vmfjkudHDwn+qoaZY4JfPVeyvV7eT8kTXU2MoDZq2REporsNibBIQXOkXyeAX4EqsMUI5bhOYQ2QbUrrAlnO2DDlD0yrYv0m4R9gUd6usAb6ZqRbuBDfzTTeGlDgyxiUUbzpHpdH7gB9vxpu9nIXAyAMaHKBn7T+f7NIytrVQrl1GGZjzrZqMdmOlum6FtogAK3qtRzC6i8gWgbRe8de/w+/VPUqVrQgQLT+kz0ZXvLxX5my7Phji/1TKvLj1fVZpzJ92pmFM4SXBPDmHG4HjU9g+AsY/ihRI35MxBbBejKsKQ+rfberBRAfQc69nehXAgM8nKGGHUl1iQZGsqbaV1wj/P80LNMYirjNZJl/yDUTyF8S/lBrzAPzyB0j2HOzBX9i+8B6LhFu+lJtAo0fHEpK/ZTwilQePGLnXITea5ObSwEpLl7Ri9cSnF5HKC7TqGG3pqyu6arOMgcYsemUrvOIo0pDQa28wndo7jlwycVh+qhXNEOdrhtNKagLeJ/jQNe50iVBQtJxUxa7HVvyc/ZVj9d8XmqXe2/ZFbq4nuxaBYpVzGAlN06Nx7PvY8XOKtzM9ZUHfNnDKMjcvvQwPVqpNq4qagflbg0vtHfXqw8HM6ghC6A1n9hFdMcNNFadBXsVdBRM9WXgb0sc7c3besAtH0VW2SouS4sw8hi0ddjcbmIy3Nvu4CYllCE4S+uko7hjfhiYrwvAdfxCNK0S3YAoVh8qBdHJRw/pZGu6tFbTxTPpyUdaeb8MwX6ElWHTQmAqxSZmg6xRNNZR6uU8NZ1btAhUd3O41YpOfP1B8JMXSclP1N6T6D6sae4SiFvVns+h5GjaXgevDbH6RPFvwUDWHC9wRvDopIYDPxvDPvbdRpOqiw8U3bH8oCbNC7vvLvKR6J7dryZJQfcuN9vg2g3xYs2nDeABW+yWczLRg3UvO2PG+usqcHDW2ck28jjm3CRTPxJxUfSx8S63rmrgvGjGhxeYZ2ALwpdzzGw+EZCZRloLvKWBCveyWg4RFlgyqwYBaiW1VSlqGShI4txY151nr7x6aZVhau165iuQmWT+3TNC495WZw1SNgPoIcYn+zeTI1Dpx9zxgiFo06sMPoKdwUjfXFc+SNbKJIh6a8FrqgzMuO8OVtZ8h3OW2UItjcCDpfOtWLgTP6KNO4/GDxNpVs4gRnSv8sxG1XbxOL2RC+1PllV+Iw9ZbKT0cKajI7KT6or2L32uT9AQBmmoEV3R32k4uax4/doezimSXVIkzBcijGxsOqJ5OD6OhwFgieDcozGkZiZeKvBk2u/CI3Nwpl8A+69pta6e3ypXYyRElTNWfh/rcuGanvnluinXbjklZ70Mr7fhSGEnfiPgf48Cqw/wTdbE4/TO+HZBPNeZ+Y+LsfwJdaK+WF7WLTlvdfC3lklL9zwpW6l3g8y1MNJlNBfjmx1rPKsrg+grxqpM/R2T5tNGeS8ORCrWz4ynDPOUom1NmHwQffmL0zqc0fg8QfxaNdYR+ZGyqcKfpZa9RTTPOzz+esFyV2cF/pCguCU3CU2TKrY9cB/DBgfRslcu4Thg8EHeMJn0LtgKisKs5yM4Ae7i7Bfu8BY4YQwjXmdwEV7n7lo1h+eJZNcarm6TsqAJNDlDcORpAZdetWeXwO+p8tntv8585EoFhMtru5nJcrX1Diq2q4H94D0bMYPbIlJqtmgJtHZckHSK7oawxguq7LBOg2Oninczceo8BEMBaKU7fe9c7OSX4WMR0+VGA182m5cBUjmQO1plqiILkCQMlZuvliVTz993rTbaUwA2CFOTTK0S9yR2HtuMvdXEfUsXb0T4zlIs3oJAFaTkt+4SSftdNSAry05PZ3sEZA0PUKxiTy7qtCXvl2ogHKmnFxcunzyMx04Q2SsMXvb3jO9T6gliv94SWQ7kSYpHhl27mGmJQHJIgYMOHSTf32DTx8WzaR6J0iVaG0gVzzXcejVT388SR7A2dHIHiY77X7G+QJiq+fckBsvYdhUs1AZhJH2RohhhGS3jUISGOF3ogiqJXO4i50Rl1+St/9hdrbJMCYgU6yJ2nXU3nio4o+u7CKr9S4FMzYBJ12APORI+Nc+TAyqICya0VrlK96RawGWAsmb7w78bmFaXm1kl/Cslcdz0fqRYS1gW9WmOKTcMvMMVe0mhKs9NzNT0YU4g26NhC8U0iPTwqkI335np2ixcflpY7qM/1kWbG+J06bVWrIno4+x+8TVQqUz/+CYO76NaYWGA8FNKlIu3qsXH/6Hk1w8cHB4xUtqpjSHNaEmgovcOW8VQCj8vKckJ6SFWZ7k7os7iEBF5gZm79nFCjm7sb+akDbWofXC7mE3FdwriAkDDXwkKHlb5DUFZyPe6MM/N1nP0KO6ODz2hWVQiaCZf310fHeXfULkRk+pVENcX54YDvMOFiMsXJNcXQ+42KWsELJ5h+uBNxraOJV9G+vKMUM+RZs0Nn3cpeKEFXvxqdFKkYONV+BePXekOdlqTQ74sStcII7uTYGU/LPomEXWlGu1jBqlhTljyy+urJJ6ljdV6e3MjBHpZgYbCypaEAEZ92o9sY58gbyyQgjHzV8bs2aWpysJ8M23+eoxWp5C7BsqyAWAWleNTG9OlVgO+QPkunqswZ+fcu+Pn8Wy5WonRJcs+4gEdnLjLtIU6Ew+kpf6cdpiATsuRqaUqWpistlgVCLXjRsWWWmmrexXlmnCGOR0wwNZ4HbniLq3CzJg2XqanJrQ+jcMDsr95rR+hTlX4vGyL5njjc7vX0zgr8RdS/M1Fm9CJvOf0wIMs0OwHsy/CEH61U4MVkMJYHiIYeMdPV3xxbtHcgEGloi+ASgyybbLnl2W2xnb3PNKhx3eT71C+N4m1TKCtE2eiCJqFa/UDpdFpVqjXVU0PJCt3R0yuhxmao92MOaeS1Ymb8xlI/Rh/O66gZbBVroM1qYWPBA2oE21IfZWknMjZG0xIFjktE+bp5+i1cBgTvwYHBu66F52BtTT0/ksi5rwhEOe4DTs/JL2dIVI5ShwnpEB4G9i5sL/1l2u+0hVdxj71ZUk+AU1zdf5A+xgS11yEm+twnb6Eikllj5cNva+Qwavwn7cRCvFryt0b1+0h3dFFnapN2HvFlcEjEL6O5/iIS8B8BcVGjVWP2Kp9mJ3U/pZ4W45a+JTQ3iHmDmOoWwuakPnlOrdgC6j/LP0AoLYkcvJYc/Eipy4ENP4iERq2qMj+y0rJAG3c6UD226TAnU+tqbTScRVL4jTW3p1uxZ3lnX0P9RVl86hV+PF0l5o6XqjpBCO2vb9Wp/zEaweR+B1Q+Q0nHYRcJLBg3xRoGxATc8u7Bjo/B9DYmdUz1yDS4H6xKQnq9Kzd+7l9q/iwFSR5WzBC5N5ZaLsEsxaDL0tTeuHvXOOK1lTcb2/9KPL4lg5+pT4Eo6n815TaEkL9hSWnupB/3gZ0AweunfbS2R0ghv065OrHzg5gXI/rOm+4n+qQZELln5dIaAohhq059cHnnWRPmXcgxZGypcGiVosSS0Kd6lfWYRlir2O2R5zJt+ZBciiwKPhS/b/cPjGwMR+Q6A6+J5ArUD2/Xt4fmmOZi9lROhJyfLZcBtElJaukPFy0l+z8TCnaCIdwkgdLh/oQL/06fZvTVJ/waj5RqTnEZuWVbMt9aqCOrQtz/bRptWZSAcTN0BWdVrRA51H7ymQ/Oo8i+hpqdxETHngXcZ6BvjwLqDd56QDtLipyDiDs2lndyqE4Kw10eAmZc+bZ1LuxQoSsvCKqf9iCW1mtAsQ49seCTBLbIrkhew8zWVRQbDJmLC6UCK6YoRnsvqfa5STw0dujvkFmv3V8kyamEQO1G5Z8KGbVDBRi4fQTMKKRKark3AXc0xAE25jDi/T6Gwu24bIJxPIgKLGN5c0JN4e5D9HkfE31LoNmnGSLj5jZGZ+G4aDC/LrzoVKB8quegxqPTM9k4+WpeFGo/a+l492FU9V5PEu9KiE38oVsQX3tcjO714A0BstZ1YXIhcTHf7Ikd9PhdL3fMHqGWRdreIs1WTTl4i5Iuh9F/2SHTwheawezZaNPAoGBlIJZXurBvgZBVEu0Y6q/CLxhoS4ad8nA6KbWUfbxGfhyFP7FPzNrSGpmzwXtAf7biufOLkF1B+O09TfJKwE+Di1Wu/DcQwWTvRZM0XR4x5K/9II1xE6AeCZkLxcP/HGvpEiCZ48Xz86OQRwA7WAqQ0AR/7Kv9AJo4dNLoErllm46/wsl2HsgKtGhdXDHOuQLArtMkL1uCgXJLOWAxNGyQqcsXK+1TrMz6tFx5NOFOv1iVeBSxdAxd5MkUSOuJLkNXhd42gVXaP+lRbcnwaUHa5vFumAGFCK3Dg+4hj1RvJxt+U+O2IXcci1YOh//KzDRQd22M61sm+i2DlxpeZKnWaHeuY+eEbqLDQ+UqWtyFKhLvdV3XVCqmp9HH+tuz2upGcVqMcp0l21OQbLN5z2JCBs372BODVOClmuTqHfxgYfx9LKGDaQn9MahbIj2jGMRs81NGcCbS4bhKKQ0YLdqRQnyTNRFiORhjCODxcEqSh2x2HxnGRN+zBPtzSx9RvVvXAfa2tRWR07NZA2+e3uc/P92uH7JIBBk2++fsou1sbNPjo7mtO6IBG1xtXF9e1VHNPIrqaH8dVaEs5LnbDQN/5+jEOwwqUPXjTpjkPuKSA/3PSAkfnKXHh3GPF1TWdKdQkiTStVW7yHasAS0HciwJcoN7f7L45m3G1Z8nKboGrrVtr/SIIaw1/oD8ITA2yy2ECfVadZse/coVPbFBFUejAAsdVbBReEWNpsBPpe4bmDKB9TqqWTq1P3FyZYBj7o068htQDPdg9KAJlfbOTAqLdNqjo0x6pF1vmzBhLQJ6FW0aAhpAFrfbjm2bu0T6Nfy6V417G/js1eb2ilg1pUKReP3bVZ2FtNzrjKHs7M0EdqMx2VhHHpbsgLz0f7eu759LKg+JkXgVAPeD2Xo77yNTfC0sj6UJVobyMD/3g+hN4V/YwsNFqcD1JYj8IMBgW8hVZS0upJykJGKJJ2WUAsu76DpOB4H/tNDiIkStE/ssidnLekb+5MBqlAifTt/vEGzQb13HQUKcpHCs7WlW+aIw6hBCmjWKpNtKLEgoh+/RgVoqK3ym+wBN0x+7F0jgNMZ9Fr2yAivGb2KjiXfxnU6mtF1R/v4YzWGIHyf1g1phbRPswOhQel8wPYtQ4Mw7D2/xc7W6Jd/wbapO2j1IvqoPz5c2dNDTfFZ6rCSLbeLUO0X3Ewq/2FOgOwNBqEAFprFLr7thvmeO3o2YHiI/ocUhAHCtUBq9NKBFRM0ck0mviTBtoG8KYmgjCMtIytcl1fxV9a1wOH+ssdm8dT9Ov/Pz7JMdwVYUd4e1htpK+t0K8+NxuxzR7eSc87WdLoiJ2Su1CGmU69yCu5xVYwo0OhZHu4c71Znvhr6BD3Oj5SHysgWcmBNGkQ76n+Gh39lN3mwqcQiV+dctuUEYd2cVlthDeHejo8ve51iF3bAbxtgf1YPeNwGO9mSeKrm/kc/deSX+X7YaZriOeE5siBO5LTuPWxuXRFmYuKMmEA9IEqN/SgG9ev24Ii208EFqwP2MvN8UnG1qUh7AxEXtmwQ4pPK6cYQuy9grvWoEeZAG6ffIatzGwihpdrZpXi9TWdKO3sCPfk1bc0YHOPmUCjNLi7OOCb4zHlP+OL8EtlPkfuqPaCuub9S0xreuUUB43dD2tZbo7IiRELO8BAtHbyiHgAKQUSJeN/3RTCekTYfuQ5mkCUDZgJ0b0FSv2ESPYQT1kwReEIqUp2GdFtD/fISqadr9j5DgOJEYOlLac9VtmjHN+m4vWo+8JFBu1y7WsVgSZJgiMDYXfZ2SLSYl73PFfGGiBevKLrU7ko+etYQQk0iCpg7GrqqFTDuPDNn77SRjxo6vYo+yerlUxgF3bzs1ryq+Ix2QGMkGINfjw3hwKV00jrz6mQOZ+lFVHXdSOzzbcl18s8H7I4on7Wv2fH4yxQTu7RioEL/g9MqekaTzqWZPSTZTR9fLha+FxKVYISgNVBw41K132i71DIBNRzcEZvGYCfZ3U+HHm19UlkoRbCK8NS/eIwvOq3VDhfXkCVBKSD/U4ig3+evgHKG1emz+OR5qhk2et6yY5OdCr6QGa0nO7dMABBdfjgDxFXgqu7ob+VoOwTZjLOLwSbOX1YM9Vf9oMSithmjwlJiDXAWhGXlF62ouQbHs32iDBFgkahKAhhHOxIiWSburQUcN/KNeWApjTftXXSBi8NR5Al8Dz/iw9eTWnavgQYhnhuFTtUIbTEk/NDVVbiXbhDDmeGXP0VZrtnGovGmEluuMKEoZVNczY+kBs+bd3+ASEi7Z+ex526GxmXaM1/pGtmv6kphKM8go4yEGNEUBObx1H89vxwXzpYqDJx5uiulAvFiQD5wJSOcQpF/H+QMHEzOIGUrEQstvbDEzVsuVHl5+mN7M0u9jxhsqP8zTzMOM4ZuDRvHQXbOm7K3cfbr6gKPP4oXONbNgQ/VygZ3jKP2TpDVnx+IlpxvBzJdJVCaNDBmHHY2WzuNcHPr3vVeevFK0NlJYAg/buHcGofDcLOZYjns4dDxsvQQTIyca4JTylZWigZ0JpkS3pLr526cGKQIY7Ouzxq77uDdQSn3Lf2yYtMvZF/zzF+RGACpoDr8MSTqyQbejF841BRUFTfLbybxqS1NAVWz11UhSaAvo0PiFB+pu5FNRlPS6oBswnFEXdPG7ZvqpWv+O2aQYU1lptD5TMXG5KEa724S1cu/m74N7k0KPCB0ihtrYNCda1t3indSeyK0rWX84F5kB2uX0Xma0dn/jZmHWpBiR17+AIN5p8elhTDr4T/6QGaJ5kbl+hnTHqe5pZfWqzi+u9HYhBUsEtMXnslxA13zrSjuSh403XvxhOM+WoFLlc4yFFctZg2jcoTxuewulerC0FlFMR41svVsd+T++BtCprJnq8QYD3ryERJINPeBtLxkcWw6Nk1ga27+cY39kRoTVW+Fdzd7ZQcJCsKJ31uIXWZ3ctvC1gD9dcxIeYttIk/FrUXIxzQWKwlSViT4MnW9//c9WPoxLjp4DUHPW3y6P/Dlw4HQkbkmbbNDWAp870w5+Ns9zCULF7d+kyTDSn42bJtTZ5vKJGiJcSY9iywL76m2BVkBLS0pL6Xoq95APpheskUx2qHWE4sYIdxOwQXtS7Rep+oxI+ZGp7qK8C5uyZB7uunRra76UaEH/0/OyOhYVoi6XIXHo9JRsa0Yh5M6NeWhQtm83rSgzav2UDpZflVR7RpLhfBIrLZOn4TtiaPPzIonCQWeDThUNwUQSlSQ7ono0sbTkxUJj01j6TO8Y+WFESYpJyd2M3tYIwy6NFVcGbmwvVtEbPS3GCZv2khWqJQv2JtW49S9C1nfhqUG2Teq6KcbylrM7BJITUMb63u2fdndd4IDtesQex1OjasIZh1m5GOT/pXm/SP+8foZPT78EGivl/id71MTvw9D4oQvs3CA7TXjRELV54rHlhEjYZtxAQmauJhVKt6ljcBje8P6tuP5/A2Yg2WfO8JXzlHqsVlhornPbbowhQd4nMTEDrUoJ6z/k5qPTKwMLOdUm3NdXLQ8teBsOKu3sim7C+H/7HSxRR2x8Qs3cROV8NoJ19N8XiyxMRoq6u5be4sZPfqcvFbchf5ItuigFbeW/uwVs+7vsd9aPL6/qLP25V678GI2CDEItLUMS5ZHfik4RNBdai1uo1lMaBxWVwB8eVx9PAGFi1lVm24HR9/p2ifJbkn2JraVtkzFWhYIjhdKV67TT5MReVG37xJIZvDo7nRxfgSllcWhQ4eHsf6Q6+mzsGbAb6Mn/Io3iXFfZUl+YPL/1E6AuecbO72EnmQ+55CYbOBciqv2BXNuqVTdAMj7HL+dceo7huH9Eq/p8LSguon1zrFRMEd652RF01tHD21+MZ8wh95rVP8ae8CKLNeQh9iEEQMXq9WWxY44XfOEAHamW9itmjT8Sv03M06q0hqJx6nLKTV8Eg7Nliu/OWxxlZq9DulwF19MnpCTveBybIuQyaCQAmTXPPgrWKLk6/I0k8gQN5Sz2WHUmPhlz6A+3eJWd8h5K+1tu44qkokl6T5DcKXlezLgMcTYkk5wSxpbTnZ7GnZtc7YFuSbvrAflVm12pLS0I2Y6qMx7cyFLYffVAWKU1qv78Mw+uh6ZJJDZxIBOvPzzDEbvm7tomiDjZmSNsaiLBe6Saqm1U7goQs8f4qO6BJ4xbFqJRQztdkxURrOFqDaf+i7+ruPKvNxghfSvW68Vdl7f30vuFr1j6BLvEyazd6Z4SEHCWuOS2HaK30JPdA4E4K6bhnxkY1NVZm41qhAK5sV3bgqbsQvRMRYtTmyJK8B3Rbh7Vtomohd+Y4ZH8MJ2TisGq4uXAbV9buKpKgYOiMqwalEivjbHhqFzRP6qPLD1e/gzVtaLvCRLtXMh+RtsVALBW0pbKG5JmKen+XxfGpG/TRgjAKbSrCV2rMOXtLzNAPBOUIUfYzKtWoH+ejGgH8gTJZn9GYDzKqxwyUS0Ly+XRpcIlO/PMBaiU4Xvh+ZYUFi4x5+oluAlXmX7dE1GCaCAdcXAGIcCNoD4K+Pcvm3Q8oDYFMXkNeI5jZ+QZBy9w2JUIPI6oF92+aCoXSKEGJeEzgFvzBFnSeUmUVcIGli+afwFeIF4CQKg6D/iGpNiv6q5pb2yE4xsiMkDjjxwCt4oUMDILDZO4E56JD4WPHTH8DklAXkKpKphsm3ZXkS7jqlGd5sHhMuK5vv6wvHNlXzcp+FSMC21tAY2ohC4j4ykOqLUFZwOxUzH8Y5zeAYKPMD2OjipJ5O7sEBXVNNzihK+Zd3XRv0OpdlUzBV/hmGHlOH6nItoGiana6EkPbiSMIURo9vvfKZmTVLi9CPSXlBr6t0M+L99Z9cKNNyvu6rtpnh0Zwu7kv1NUV9EyLSTNL9x2+yHVZ+gcnUELBDQJCRyivfFvJQqSqBzjy/i94n1lbdsgdaCDUuo0JQ9rhzolwCpqEc4kRirEFmf6Iojhrgz117E5I45roZtQlcWlwzIgDKVBGXnreJJG2bKXwGqxvS6xxAX+rke2HTtd25aH3EI/VAmLn6zoAD3UNuPQh4Qt2RRS41eamtLJfVHP0hKHQDxUhMnXwyDJG5h8/rgHWZew0nyRa7fxh9dw5NN/3duzrHt2aDWs4TeOGlN8Jz2GLrZ7wDwg+rP+nbvl03Dt2xChdpv5GSdD//2fZnoXQq2iSGOWevaIwN2w6Np+k4Jm/s3PTclWcVK93h4emYHGFHSQQreNE951YXw1eCkCUKUaFeUn8PlAXOtCUZ8O8MLVtoRsoRIbfLLn6TPqaKifVkXLrFOYBjjihb9bJSzbT1mUJ2rnLU6oTXN/9kXIH7oy1wDkrjvK/VgEKRNB9XSHNmyeCF+MrnRyWNawDqHWQN9XbUsr/aWmwjqWCUPV4ymjXgPjCjdQwqCauHMBKpZcsKWlTaHIJoTdyOF4dSOhboe1aZqfmUqWtkfAB8T0/uZ0+YqN/csXTKS1DugclP/8Axxqw0y7qu/y5A9n1esTq4PQRLGjZxYRZu2PGKl0DsL7VrwrkfnR8CuNuCPJ9JgrEyMwnzriD4t53mFOncmegXe0C3JuBLhZHcpwSMgU9TmPN2vAWP++Kd5NeXu4zaC5Uau8br4V7Stdory0iHusSmbihySp46GYue7t3d4CHNBeyBAJG+pSmHI0jHVZfps4/9z6GB6JgqcfGndo6QKwengb8BfdQ31UO/hdrvKWxU0ufiod/dD3mVDOCa0vNkoTxDwxMkIGP7+bR6PW0q5UuvlI3ffVCi0LVLIzpvT+xoLKg1eTHW/aA4g4CeDPzVjBGREec4mgfvp33DBa8k62/LL1ZQ37Tz71Zo3gBk7NgNOd9U5PBNhIfY50es25UAVFaWf+X3iyv1bnW/rh9vVt9mcQ6VSMZdv0Sn3WoL/jvvC822fWgH6xqskC93d/qM3Y1iLKAW8JLgQUrhWZi2aBRe/Mrjp9DqC8u7GcLKp3l/igocT210+yaAycjMVqTuox1hAhczLkNfWfxvH4diYYBnpvLuQOCsg9erzz0mN+gKC5ZKjOA5wSkCrHsTiZYIIczDYyxlyU5ax4zyFno7B7TvdKXoyAtGzvgwkBGqxHEKz91qWO8WjnUqSZMnpnVTVdEN2vo3/K+buu6aqr73P+ldi6EojDpujNskMAI8srwoTdqMq8Q07xZcWVXD6rZWKD5Fdzto6Rl5oAH7TDL1RH4ySdO+fQo5/cDIOwgydwcg4kRAGzR/lpRSq1+AoMzNrinM3mClGCT2NwbtUhWFy/HgStOMfu/Akg1YyKDbyrAXeJeAPRQesJGQllGXH5B8WtxlyD6rcUie9O9Ucz7EHKStf+R8dqCdkG7qGbkSSY4G8uz4F4fWsv3aV1XdFHIGU8a8wLHHg83R5GpmquwAxYXDuwELnCkKEXSOUbgT7kjygWnEf7jyYtre/IanYDoUGZ+6W3v65ELKTqlXM7dZsDYdJGLBOAMrpBnmwdvBiJwHxicZo81OivsyNUZgxgq6yozDGEE2xx5ObsHoZf4ZUTs6yJO64mfXcRH+wsRNJoQu1ycY9TwPs5xNYPSlp2FHepqr8kbA/RLpnlkc6qixJi7e1yNUrKF3mKJCamrQ/JD+QiZi34dHi1paFTW4fTQdCkNibASNkwu87f2QrvQ1E0OoEp2f5fmQbV0rgmvhqn/t/bafWCm+iyUJNdheU9ci0nb4Bbh7N+f+Z6PAu40HPXyzjhZh+jwT7L5/qrOPHhZQyKmBNZw2qSMnmeA0AnvGNasxM027yV0N1BhKH5GRzPO1t7cwqTUj+mbRsPa2wTSQzPfLtdHkYkDjhU8E/wRMiXYpBN3a58PksAQ+nbnKKOzIwLGjJaEZuEyTg5z16dd7+oN2rBYkjdYRDLH2FHZzrOWuM1/FenbZbg1zy2/dGhyA0mwM0Z66QYPf44Hwfzn7UmBaBEIcrn3UKJ8rShJh8Zj6R0jMLSJwX0cMAA3Mfvlk8OgNJXV80q/q6/3SxHlhY9r4XBu0uY0mL3yQyRkla982z+UR/D1VCvoSi1i8dlI3IofmN2FOg1Eo41WbEM5fEp0RlwBcsgTvNSDYT6Pc5d9XGg7BvhsMLNB/uqnD8ArZLdO2tYULyOy/iNPbNaGNg/ITtIXhyeqZBBDZSl5hKfQ2VjyVj2XxoNconYYGBljsH1vvQNZKCIvxCTmG5kRpgLKJqpB31nd4wspJzrOJ2pZXfHUOJRNCQ+J0P7utl5/JedxOAIRhOoTpLodkAiLW7t6iAMCmzgZszS0nOMeeUpJO2hWVSYWod5y26f8vaqBkqQu3Cr8yVRPdbwFsBwEwomKcEDhjC62BfV1TDMS4JltFGuGcLVeIsmnOFy4MMHJlAdFnKpFc7Q2yfHOJ3kIVvCzw+mHFVu51fE/HNJ/AZJCJjsOtnbKG3ALNmZRgznMoKfilO153dkXHT55MG3HArdcVrq+H80ke2zmELBEh5UGbs67uwYirOkN1QIqb3Tgw//tBFPf+0YeYyOxsppXr1cNAd/pj+7xvgA1IFsuxu36qPXmdExYdaVIsYzb5Xf6jDTZsfBE99lCWW6T8slhdsZ6UlQmCV3MOrt62KXtVoA7Hnm6bVVcn+RF4vLMsfdJC0GvHwf+AgqiIPmAwbwfyWXdgoYYmQs1CYufzJhzqNa8oF8Sc0r0L3S9F/SObiWjXdjherKkWrNDt4K55oL1U8QjXe4sNKxo66y2PUwUqcb/gkWlxvwD+G3vlWZ847g6EF6rVrfghR9w+stonnm0+5RkmtojVv+pQLhdOgTGySqJXBJl+0odpTI9daNlt22SlJcBQkcj25TGSoixZNPdrNXAh+eKRpuWeP0kBIgoK2GwypsIzqV4QINiJAZt1U6+X8ZiiXOVPRzX4obq8CZ0dLr0EjPC5Bf4IRbZp7kksmCmSXUTguuxTZiJID+h0x0cxTPKcZSu56fpWwriVwQdOmCysg1iEj2lrJNeTRq5w6+OXP9U49W+UbH3CJli9J6XpEMRqblJbulXrTB7gzXteI9VsNI7xmtpEl6f/tVLRI0vwpKJk38pnaCs1XpznDBVo6EVCQ68eYkGQxaOo1l/kxbPJgv87EXBQ3hQMLdW93a9qT+gsuGYpHjt0WvluhAxKiAoIL9LRJPFiyMyt4lcbmTkdfwi/UiAq8rVWTtj2pwvfS96Od20RbdTtI1px3hm+ZenR+waiJiW3aibqs3kHaWy/ac9L7dyOpbOB2Vkqdaze05d9g7SKudO6ZseIqQYECkARLc6AQ2cGKhnPzKn73z1z4Yeq6Tj06V1IkaxYQ1MkEKp41mPCCLf5icFYgjqPCS2nuX4FPUqgwM2W4HpSK2Dx3cuBvBTa1roFR+P3dtb98D8g921LZ3QD3n+MSUSIAnq1orEp4KhkcSo/x7jGQ6fjNzrd57t8V/I9UF4+m53ccsC2M+l/fdwIugwjFjmh46l+QLaABOqvbb3IY1sy3HBe9/p+Ubq2CGedIUoMlVDfc6DIzNpMkUouo4jEprx5uzcLi4/WFBx+cuHl6tua1pByWaQyn/ERLD8sdeqrqNpMqCHgPjPsDSrUbpg3SrRV0OohY2mqQSqakipd+Lx8K07eVCS476AnME7cu9yHSclsZpU6kVaxnvFXvOKKrYLdUvOkZNili6ojOomsdrTCAewhQmASq0jkdEORvPFp1325mMKfa9yOWRsFiiHLqWZf1Kj4xusyHhzZ+umDoPvhFvHaBBBGSe1Gj8XdgTX0MPhPKUO2GA41lMtKSg9577GLgTzNKkjgOTYxgWn8C+mvXTsdNHrm9gXvcaCuxWN169Thq7gNQ+GhvjQPHZcwc6vOfSNCtuoMseHye8IGGkxSUrEWg1q8uyvA/lcrcKJJVun9ml67+SLQMhdt7md+u4s8SYWl6hYtt8yJdDQDeUY4nA7VyHwJDrsP8Afs/zdDJbpOqrW4DxJ/5TuVXMCVJ3zdZaX4HsL0bNhsskPdQtWDStw+Uai4V1Ll+Z+R+DYrJco78nGQXd/V2CcpU0bLchoU5UhgHofYwXUclEwEDj3NCvFSvSlCORVxlMiJw1iKGiQHbvnz5tNxFyCic7fyc89iqN7d/jFic8m8fmWOOh5FgubtP8GVzcn5iFEyGSfi4tyuWGKm2BUzQnXatJeh9LYaoPvRj3tqsqdyBzYoUlRCRCNUvpvMsyDnjaZ927mMPv5rTFNSiDIQltOpFV6CqA52MFM9ps3FBw4dHX9wVaqlghsa1HZe7Ok3OZ2yAqKESjE8mRs11uWaDTwFGxEuVpkeOnlqxYmYvWDAjPSda08twD8i96pF1q8ev0P7q0CzZEI1jYyiccfo/DR9NPXJ5i0JE7/saGKakkSXBQ13Kn7xq+N4aMgBp0mXqHp0pI5cuUnwOZ/7ScT47ZuLiezr2cyFjjRzb03pafdmvlRfJ8yRdyZWmuJvirRZPgo+vy0XnvRcb7ITlaEfQvmwNF8Y7+78NDYpyzvRS3U3NjNciTOEQacBPEn+FlPvZkzTxHoDdfItO9HS3iJ5gU3fZUfSTMQ44Cu9qHIIHxfbBmvORoqAf2Npk1OtmmQ0XkutYXgmga5kWXaxRZWswbe8vfRAr+xNLUyTUjzRq74k6mz7LW3J4AnuLLg2dbLqbXI1FBgdpVrueNXhpAbPxy40wKObBBRDBMVkCWcORRhvDforcfHB+bucH0DEFiCACt9V19D/jfiIdqQotDB1ElSQrQpG+yoKVELJIt2J0T4cf2tYthcX6kI/UMTGVYSV7UDMLhHJN1wtVw5gJG6y68Ugs+D6R3BmAZyNPa0t7s00GqWYE4p7NWbegLurPHNJPIhuV6/JHdpdpylewLqK7j8QYDhLhNJC8QUBmQvaL/QLWhufw/QhGRUYlQNzbLW++KFkdft0xCWdTod809F1wXbqCflwYJYeztrnqenCO+nLNDF4sFWYA2NNxM4UYIinvf5ogmptt+yNL6QcRgr8lJvdCoFdzCkoSp3JE7CSH3Amwc7IsxZ5BpGWqMq7RkLZxxbe1nDxl0z9nHtxnMe3Zd+yqBWCYOQTyMkmzhj+26/a3lW8LNiMucPe6qlC2b7Y4JYQO2YM7ONzLzXRawcb39KiY4SJ6WQ3i/11/JA2ECkqfX4RPY6ykCQpnVDVZAYiP8ADL0C/x3KPoWA8FzSG6zTJ1irR94pVYonJX8wDEz82I03oELA30gge/L+kXXlaNFXCgEScY1fuAkNnwhB+CAgEkHAsQRTQpyordsN21kyWtxiss7hPa3R/FgBvSbwr07w/l/ZHMWJf1IapzVtqOkctg0PZVTmyOfYiR/U2G83eayjbIR5nKjbIRjG3kWqo/LrqWYS5xgPvgIsNHS6WwObOodyMD7gF4MfxdjOsyOmvtVt2GrHu+LVol9tbWFaSkr93tgB4/MrJAdBeiF+mtr+5RpPUfh/nldimlN6U4iAwKJzS+LGGsWgEG33aA8105XDEpjGHBAApzerj5Go9rgyPgMxk4FgeEvfe4FDFGlivL4RePIZfOOzYqI2OY0vOTNP1R1CWKGdxbQ3n0zdX9ieobIjMBtQrzg7Ep21dPFue1Oc1DtSM41CFoC6lw5D4Uk6HLzZsnrgo4HPHIji7ULc7Akx2wOiZWkg5FKCGCPqzxMfGAB1AeL4wCJrqVMfMedus1s1V7NpWNG5JxmiDRt5O2VKTTTDAYA4+yeSQjaBvxctkv3BwaPkpAKP3IEC+/azuzyYFBEquMtO7wBwsIIDq7/CIkrsevhC9lKlNoFdtYEij5An+zsmCFtA43JyqtthZzVT5MoMlXxNYwACN5Ie0KOUEhoLaAFsLbiZaXy9GZeF4uczOUbFWzGfBp5wPf6yBTwDJmIOSAntMYfVAPvEH6+dQu3t3JE1zxmpb/wnHRPbMDJpqmXKcShFIi53rrjRrGK4CFdGaPyFK9H4hXVzqzVqL07XpiQSkbejaPNUigaR0Ptce5NtzrEgQVbE1PC068+w+5VpTDFJcov/9PAsptBEkGbIFz+rhHu/ir3iYzSF9JCmU06Bc2ocqbYVOocsTK2/LlrrT1KSyZIyzeREfoSVc8orO57WahJ6+1b2tcgcEscgQbok5gr+F/6ND3QcsJsrYXxQmlmlgSLwFkqE3I7f91dWXEIO/3sJ1I6vyKpcBThxdYHV3CCFYUI9gpY+jZRXIXEacRbZiCuwPa3TniqpzxcJ+4jV6D7/Hxz2PGG7YrrW3+n29dE4jNmoY9nJj54eeTRrXV9ckykPuibFXHRf+iFMdR+QPaWYnLTFPrgSS3Guk1KaM51djjMGUbKNvwyHwHYDsyHHElr7MtXpBJU9xVgvCY0bUl5xr6Vg7MMnELv3xpRhM+oComhr31vOrMJZf7IjasmW1Tl6RqsecCD9W5PzykttF6/QwDUWh6Od/14U/8C1pq7FRfCvWxt7b7+bIh5ZHAbQT6qDouxAc5pXtniP3cDzxUeU7cNrjQ20LIeSn+DZg1PrZXCH/j3jYobVwdMh4LaQOY0ifIU0ROcbWIsmZONxhs3JHI2XKSQxyuf3afSj4Gvo5zKmKQCqlHCL2oyMJyEE+uL79lMUn1AbbNP2MB60dshIDaIH4ZReQeeNrWrKWkU8HezjWduGkWaf3R7itPy0sYgJnmy9qrEyhNFQps/SB8ItpJU41BiKgZEOZkFuoLtQihb/v53ZH2JE+03jpZY88v5vvBB3ppPDtwhqbYcZmIN4X+VQl3p3ea1wOZj2cXKwFWxwtqdv/B0MAD4kyCYueq8rR/yLbJZAuMKWdmVnviygWrPnLnmElUnlvDdWLbrhNSGcFAU2axZV1lwaV138UmTMss1KLJKWdAGjmRDF+IzOIp/4oq+Rg/HI/wMYkeUMkq8lfUMp925vbk4+C/6IjHOhGKd6pmXbA0ihf2QP97NhC2zgXxl/JGooH1LAXajo2SoTan/tTbucjomx4JtD3Jlh7iT+38Yg0ga5DX68L/0TtgIfXlWCi2yrQ4/3oZfu/I0Udc20UO+Oza9QT/jO9Nj9e2qTeeKK02kl2SZXhN2JKoyAYPtoxVSbE5IAGxr3qxBTKRVHCLHYpfi1sdr+vRoqDPi99RPA/2NPBDkODuqnsxMKFEHnx9jNlPXJBJLG8zYB6CJbG467OBXuv9kClzTAO3EiVC0F3h8DGS5MWE5EylM9rlfMnxIpjZ4fbn5dXl2FhMiQ8d+oWDbUpQ+nHPVACqZpQA+bO4L6zSlCO/FMT08etaWCOnu96YBnc3pcNS90EJdkqAJBbOaa5mwraqdTxbhUAkwwuT+fV2LcYIKXlsqSxKDnqZUnPosrKcplikaVwuVVZBlzuh0WfrlER8bMzhTsb6YHOAHmQ+hPmBJtSVMxZzXIUy4H2i18t2x2ZlfUUi/qG39hcMupoIoBgpwjFilXMoXjg28tB6L5Iay4PrH/toADVpo7xQAH7U6zc5lTPz4pWPQ0q94xI3qCT5A4Fy5BAoOqZNfu2jJwti5C9folbxgrJ2VUVHs+9vBjGyQhRWMWneyHzcmEEDF5Ut5boHPWmZQoNRGXSvpTrblVxOgzGKU/6q8SXwE+1sp1+dklZFkvjayhCcXqYkwDhHhAUtjA+s3y9XuID7MWchtLJgGhFfisYwPj+1it8nVEdpz0PXFjY860boIUDND0ioITesWyX2bL2TjRLWSoxdk2M5ZRNsLBummX7dvqLcAqo95TBafoF8/IAIQHDQhkj3ept6CFiT/MpPjIAQANsWktbwE8u2PjSwSMjEVxAON4GEY+WAH7Aso6JqG9zzTN7Xh9o9i7U+IKcjNIw2GUW3GqoSSbyoTGrGarYdUR5OFHIPWpyEp7Lik890AfdkyYGCVWITwvJ+Nr47/KPecOU+lkcfIrAsOf6P2euhnDAhXLv0dRFXJDr9IrzRlXaYaImv2qMcAIEDOUjt7wgkEZ6ywX75uTn7T1B+jM0rl8k5zQMj/m2V87tCD1v8rhn0N4BNxuZp47m2hlNb4FMFQ5KVHoIAkq5WQPsnVEsaCkyjYS/3wZuPk9+LzQb2FPahZ+RLh4T60pA+X5WjRI8R898/PIziLL8wWz8FDh0XfzKMmqIEcz2BWkCCpwAQUJc+CCtXGtS0JG7RihrxDS1QE/DezacpELIV2LYXMEnFY+PVg3hBXG756D667Cxjsv4TdRYf5ojqvD/y3eXkDcSJ4mB+ZrlBf72zRB7AycGGBrppzJ1CYwXdc2LTcqIa1g5ak7dZGnPzW6DSgBx9izQnmJctCSy+pbzLLA2NOhOkQwR+0nGpg1USqP1IiLyFjnRF6T3sOleJSZ7qFXs16/9fb65H/4HalOKHqu3gVi08tSR2zJXTtZUHdbYJ4E4P/wE2/oiXOEwpvsnf4AXWpomlczj87uUQoDsQPVsVlfk9AEFeY00cdSklHGlUZuYjlxoGAQ7cW7lZrUvAvbtGjeP6baOgwjMRPDwOx4gJ6LkKXWAI4QYAgVgdAAtq8IP2dOJ2S/xm+tjEXJugCmC0w6uD+Y8nEGoBOTUo51zUaISqhl5vML8OsxmielC7MaarUpGkDypOw+FKw3Dk5AzqqHP/6AUupoo+SrbrbxEsB2NaXVUtpXY9Lq41KMAy+6dv1zaPI3jCdCbggvbnTPewn9lRJ0PTHP9vfHafyTSyZP8zPy+tteCyb4JAnUpeJZ/jwf/Ez0ht1ZOC5tODa/Vw79bbENPwTs1dCpwjMcMypbxJWipeFfR5vlKNctJRg/nOgk1sQDewiJW01P62tar8i56Nv+10NhbAqoeGh21Pgz8yAD99U8sAbet1hgCQNj3mcGEJd9U/OQD3fwtKNK+gRw5/o4R1DnlQzlzZi+SpNWAGUYLkomffFT1p8Eg5vtiwF36Z6p8cuSksqAfou3PiuZsgusnkeOHl2sMYu3eN3oftpin6pIooiu5ELggbvSd7J3oDtbIWGWg6pPgzHkOLQARrNWTj3/c3guQ4MGVRjieHNaoSl/ih5QA40tSH6fjyAlYWBhvCZ06rC2MYe6bIF1fIPgF1JLOXhk8YW7wz3H945ErEVKhptI71xT+I2/fych+AnmDrZMzSwdbuAEzTCYmgbe8vWCt0CPYYPOeWLtGqZ7gsntduAM0sPzt+vJhbu/zNd8pyRFpBpqZcqOc/8qiQTIpa1DAIQ0Isgbk1dqy0myaxxp3AIFGdUdO2f/4Fe7U245XwF3tl2muVggMuIZwPs+rNmACsIEnFLv03zQMIaO1Ny1mUUIG+1vBtMJ1rHzeRiO0JX6rRi5bzu4i6714HtPCpL+rjLuHop19YDAxIm1zIH9USXxm01CuWZO00piuaRKZkfc2TRQP/+ouGLyOZzwfHcbBD3mLEVM4NmAlPA4w7TQ3xynILekJ0z6oCFE8YBzrnWphHlB5IArBymy0yhY+MN9AUe/0UGAb3wdZrilSLHsvNRgGK1u7kLLVzMRmUW2txOBJa27I6VgdKnmwqGgyykbMvlVMt1u9x8m9xhXtihvYjhqJHJA7kvwpx027zaZF263FYIGo1h6OAADnIt41ZEqQJIry2hjaY+pTPY3Uxf5mxH9AeuDy2QyIi8jo+Y2SFOnY2Gfu8WSNJIU8VOcKtkd/NGd5PzfS13HoAI6EQTcrM25sjdL2TgEQm24F5xfb5iwS5zduXXtvTt3OedAKYIt1UqD3QJ5R+H0gKjzzpo92NX1k4Gs0D89QcVPDFFuU8HfRT6fyDattb03YRE7sRsdmsog88xw2s5XnhI2JlP8IuiJeTFeAD+PNkMcIPi2IKtkfL313Qj7m2P25x9vVFJIY4RjpqbRXmjcMaxHX5oVqblzQnYTSsDAG37u1tZd4DvdUz73sI4hXOvBgzwM9wtbpRcBUkCD7sZSZwE1KAHOYMorUIJrJ9UhJq5nr+0gf/XVKJ/PFBRvECXUaEi7dv2n9k9eHDhe+Ek7PhIeZNKvhezVGxcFCXJ9TX14MEBlF8xD0OKfwTri0FPZdJ8qkImINc1XzPGx0N90bGet683ZSg3J5iG8VRHV4/+QT8evrYW8b5SepipuEgwD4WuLkTEBpmkU/1zgu5J9ieK/1Fs/AQ2511yqbpfnLUc30mbz6NB6ixd2zJGow+kIeCgsuRocgvdu5FaIqNXnoLLRWvRBSwKEshZD5fQxT7wP5AjMcEbyhIf1d3U6i9lnWes/rfGQ5GOGxudvqI8zeP2a6zsXlYgwhDITeBbpc4lZB6+MxQwztYBDfLN5ESRzJw56QjZ6bElSkPP7bAFl2RmIt51B9+7yY5h0RQ1Lplze0fCf/Ii4rIag1WnSQxv80iKMVG5aYjktIOBHeXPxM68rn6HfHEs/5tMqv3C3ZApWBqL2/hckqLrwsljvtYDI38qyq4nQ9dWgGSYVmBHRW2Mh1wKz/aE5fHmToPyzToBUXKjj9xM34RwqwmgobjQXfPKUHlDMiq2+W72yg0df5AB/bYIs4m022+ajZeF7c60OdlfZag9OE0rR/A/2t1DtpZYeZ6NB8jDMx51Tpf+3scEcM9SeNQWx9McRCtGCgj2iXwMeh6Gsluy50v7amGTg5wRtWgFM1cfvohu4HQQJMfrDZXgvngwy2FiC4yzfVzVXLjxzDCukx0sK+Cwl2o12Cc5vmsGflw0K4GVYL7f0tcMvsVfps2JOOqKNbQnbyp6b+QdTI+Tmb+BN5rbHqWqLbAo9AjPltqFIjt/HL/okIZC9m59xVynMBEhQLeA7p8c72o2BKUbJ5eyHfz0bElTnagxAqjyUpGUUruibbD79X9n7rgLyfe8OBPLnWB+SHrVgNsIcx5vQQS6uAGzRcmJaUY9/IwgqwxmsgYcsECF8GBW6jrtDuZtiJM4fvxkBoLYmzby15HrmsrH8hsIjztkgRGr0HTbcV8+jMCIyfPeM+9MN8upEFxmU66fRIkWD++y+uR+LbevXl+nFiaPoC3S/yYK4lPjnhcVi19Y4tG7MPs6yS7eIwXWFFfc2msLUpsj+viVYQI8m3WWuFJE9olZRqfHEGUof7C3JyAf/w9UkKocqJBypClAS+gH4CxYLAFdzY+ZH5276tCr1WSuErxEi9D+QbnbRYFQZgPvsuD2Yaczg4H/Xd1QaCzFHTscT5jzawaCTkeBBDP2S8+tHnhdeoda3TQRwjd6F8ANeK81PFx/YEBVBjAvRueGnCa4rWYA/LAju9MYhAlyBtz27KaUcJ3tfESERbnXD5Edm9KFtL4oU53qZj0+1QR1CFtL3dcmW36AogRXBDFdG6xrgQe33IPXdt9RPQO4UP3Z6tlbEHraFImucxiQe3Am0qIuBpRnL8Fc7hXh7sPnEv227+WTkTBlYT+bjXSJi9ikMjPl73b7vszzIYwIZqQHYvWDJoI6tXWbW/HneCFc+5Z7FGZyOL8z9oB/sGswuglMhfb7Rt6rggzK1gZsNXfCaPSt/IFPhqGkJSwElr/lz3U3LEcBkznzgWNlU1JedUCEZLtM+2I3P9slyHD88dXkPi2+ZAkybziw96B1XMkCea5JjUtwztpYZPbrkN9Aft/BBtUGkmJs4d5q90Rqu8lNljjMbnBOxmvR4iai5OwY/AOCJqUOjQT+P7ROP6zJVl6CrHPhkwx5DaTshsoQ6QqKS1aLulCZ4n6hJNHaoue56rQPmz+h4LUc6dYMtNJLuoC62EPMCslLWJYrNNU1rxk8txM0fU5Nd6mPbLOoKzDOXXuLYMUIJOHZ/jRVeUspajdXn5+rG+XlaSyLTW9fixf3NvUwS/5ReY5yf3WVpkLtmprKZ+2QbrgdvN+JyHNdqHJ2fPV3wXgmHxwEu4n1By3lC5maF80SW76/BX1p532Jop+p9Cp8UtBNNwI3h2ZAEZz+MzdxzS6/KNbMgjcpdrUi3bV3bvAv+rSmyD2Uj3LgOSLUEAbWPPqFNEyRzkdeO8Npxq4xsXHgOzmukVWBb9wgVs3GxN3otoylhNZLjxxnBRU+CHNMWNFbZvFmZS0/EHzhSpjWXC0pqpR4z9x7wasJGUMwS5pXQZ+6i0Pf3yNhmh6qyx+3o428h4lvWPF4bDLFGqcFKsp8ybnYqlR5VC5hTw6+Qn+R7UWKio0C6JIKwiUVKUA3zIeEls3UZaooQeIwNmScRyOclv7KF/4GNnaYLuIbwvJSh92q2ENOd7mvqNMfNEDkk48lFjD6Iizaw9pY0rJXB+manp2NeOkQ6yXL0fk8PLxVf5Tr1oVGWKP6sxMm699igWsf87SsNOf59J4KLCfYMfUXq4So2djp3frD0A+VxTseSUiuOekOJw1Z/G3RBkhEsR5A5szsV2UzneDjQT6nZByDnumM39A54LcCRIbHPGWgOECIp3kSBuyXUch1Dde7vlCFaHZMYQcKjjltpdoM+hAtSUSup8zfNEiqj5u3tChfnrH4DWN2BPLnu6PqVk/ijcRhiNRQRPRtS+mGpbFBjX7CQlzlT/JPdj6N7Me0FtCuHlq/lZAGT8HaFIhjXso8mbshXqecgtvai27UwVrVy3N5rv0h1z1HukJPtjhLaiUPKPLQ4KeoxKXNLs2FkDn1VFNmAWC56JYBWinrh/OBVmto/u0XSB5jPO7e1xlPQo+Le0zoe+Nfhi9bofBdrBJjyOJcTyE3T3c02AdR2HZGqDf0QN+3WMgqKly9hctNtoNiI+0/EMyKDGoOolf3pEc4oQA5kWPxeIm4/Ognk5CJr2hHpP7UnqdARjOV+WRvU5/wgUKpexoOVXWVRJqFo8gqtRC85JCVtd8HU7W2BiCIdG+0pNrVEs2MI7k6pzW9+Zfa7IOSrKuoNCsnx7OV2X7iTfxVTHhEOz27M76rHnaltXzezo0d/Opt7QEULxmSBfIHUzBVrc3SNtLn9OCvVyGymxjOBLp3yVFHytme7I7ouuWmo4enHEQeo0JYv8zfWVUNuZotRjZCPWMFl8oEwC2hfGgyAPH3CucmA7Py9HwgHdHN52LcIgRelrTwsOHtnJ5xaQuTE6qevj/nJUqzl0RomU24nWACJGjrzKT1FH9V9o/ijoUs+Xu0Yav/x2rKnF8909vp87m58zVbBhTfb1C7mcVBLliQzpaE184ddoDTdS3/fnxVQ294CxJKD3HJ6eOMfa2hnT9jnzMoHa9ThFAx+dvOpb3p0vUe/vO0bq+hzwi106eFPHkijo++pQqCqm3yUDQGhw8KLoukJzvCqArAmlrXdRlI2HMUAPGYrd+gzy6XOA0Mck6TOkmB23Yn9cTDgtIMbPAZluoLvDFm6FsNsWM9dkOCCnhbfkqXL0czSmlw2BvV+QdHKP2QPtdCSx85LBzSfBH683fvYd8rDtunnCxSoRUsVYdHI39wjX4gZ9aYAuJIgm1uyyRCoFFLbmvCr+ZrZ1MG+iImKLgZkBraseyXEAkSTcNX7+fKxufrOfFtt8Zh1/kMJw1FXSgCQrRxzcaISJoZ+MoSBHH3qipAzQhlovjhBN1aueoHA5GxRxfAKlZCkMlihRuJeeh1NDfs0IZeczBGfkOQPCYkakEG0weNNrAE+zKW5HBp93jVBIshM1JPOtJTYU5YX8AzprlJAPaQjF5sPpbCjwQBIqR7DLTZT9TxebT4rHWp2XXUdsMv7lsgWS2jm7RWkOT/KhgDCqheq53hlvfCvx5wuzJH7yRQfRcL5TX7dUjTqQZTz9JKLOvFlEpgf0SLOZHu51YVPoLuDLCzsFSkB6kq6Q4P4so3SqKagSdqgNH0xfqo8dC6ifxKta2s5Lzwcp9jQPpIwdLry30Z1FnW7UdgR4tP/WL0HGO+U1QcDQL9HBr+COwa3BOJl2T8Tq/ekxqDdek/G0c7PfzyVd0QdIMh8bCmvH0Zaym8lwPa/0L5/ZjlANBJC/8xnH/O+HmzrlfrcCiDdyWtqhJYSukxk9JyuzMx8jRVp0CA7PbNIbatu9oM2642xMuW85CMq+AAs62GYFPAVfkqdSXpCfRCAmVF+/rm1k0dpSLmyRABoxh++ihpK7KYUv7yYZRXC/8TcuOvCX7cdUifCV4AKr1PrZp+dh8eYT5yzI+U7zhFCKOXIcQke6x2xZJ4BzLwbLqyeUpINheeKqt7Us4QgpaMMqo6cB4uuf8onmtreFc9CRHKHwJRHAq9m7b+6ZZG7ykR11g2l4Kbogw1S8M8mHzIAQWdcgC0bbn1VYCcpNacPyfaTZv+ueim+zNxNSp5mxdhyo1eSA6JID7G2HijsESslSeDgQ1IozBg1XYnmqhaAzRS1R88vsZ+woCDFQt2d5fWiRCbhPyJ3J9xOm0mZ8TOHWH+rkRR+0bh44dJRfT73rctkTJRq4/R17KIx8jlNIppOPWANGrqv/WuF3d36nYgDyHnjWiiuLkul+CHO+TPlfTMfoIdhE9bWBOQgm3t30lInUsgY/F05WGzoc+uMsxH65F/rv2EKTJD4mMna9OkO2YQEOl+IDNrZnJxmZ666VZCZeefFGPG5IJEiMMiWqiUziXh3LaVlp7rZCfz7lYkfe1iYLOoW6xPKqlfD//02bgRcg2vdU6d1XVWdR5xMFYaj8j7c+CyAUV291TH6zZxpZINcdrf0UFan3rDTZsndgM0SqhppE8owqaKg6/rlWMzb7sUGG3qSnYy2+l6da2JmHzh+E2Z8W2cHDqql5yZ8+ZIapGcYLEtAvLDX2JFDMYGNVGltPWvvG+e/8IKQc05VH/9KeTRns3GIxBHkkZX+IjSJvsqOkeFJleTBTZ9Hd9dX7rWMT0aA6ob/EAsMxLW3v30nrKzAyOlXPgpOVHxgzv/e5nwJwPgH0i8HNr2g1LCbJ3/5ZhaAJE5naWGZ/DSVFYiAtI1VkRBKwYn/Ggx0IAmtDuMlWWWRx9EhJMS28zC4YoQZXAJ6WELR/uCg0gjGJ3pK3HGVfMprhdk1nZNy8XrgP3mDsaSXvUMc/oooWIL5eafs7RBra5+ztMq/qZaaKYQoBi9XZIoNIFBBO3+l6wOy4J5Wp3UpiqVYaaRvzjiLm1BmI4Mrq7qZ4ffOzMYXDTQSrQmKGyCVeWjvDSROXenqPK1YsksW4nhWHdPQTTE1gGPc/UHdR5gK2DvJZqbX/ogcT1mKaYTo+1cDxjqoGj/FzcxIcKlHt/HJBRBqmfPstXJTaHq6J84WrjrwrT5kCCV7mpl0tQ4BdpKswfMt4OssKLMnMvb1SLqTQ16dBmNi5DyR+CS/C08HfICQHSc2X144bzAMXxABK1c3ANmYWDbpB+fgIcVNhBn2JRucE5/hkut2gxUpjouDX+YZ6Qeh2gm1CBfoWPQ27GUkPlsI/uqHCpOQIoKJADW6FLl8fDTaZ1ytiXo76hlwnzunEX/Behi3nSlA2e+AsrvUJvEiyFOAWB60aWqMBz4RQHVzvyQVc3P5EcrtIjcpis1GoAQ7t4WJEC1wuIF29iY7FVdGxkRklxFv6SOFP1TXtPZ/qz56XC5wC2yx+uowqBwfuFr/ipaMprQc3+2YlNfhQ9lL4WK+KC6iBSKua5pyTTkoQEsh2egGoqRkz0lg9qWyfmtf5vv4iG1INWPoa82VH5njl78gYMnJKhOphXLe5craH2rzM/Y10ajZ4Hub9EVPhmcHID4pfihYSHHoP5oFFxmXf4k/5RrM58kbMffpSQNxYkDP4MBodA0ydvJ11zb4XaU7i9yVVxGHl7GYm4JSjeWeDNcOELwYJZJsm7NyzHXrnvbyum6oRF9PlkW92vCTF9OK1AdHHeaSOrS1nGSXPTw62kW2rwFxlQDa7H4lpWI7hKPk89HJQkYUfMJSX4vzfYRVtLTscD2jR6xw9NiHrMEQoLpXtyrOOPJ468VlOLImIWW0MftYELhCPgh5imuUEJVNXITtUC+d6zWBIEMbYBT0AJEPrWf/+xoO0eaX3Uicy+Zc6fha7nvYCXSbb386WwHp4TtdbiMhBYAresLD8/A63khL7gZHyN48ZIcWm5IOHP6BbQJQLF/DtOaMOuy6q8uwCJXBy4RuZjAH2uoDfu63POxGCUU6L0kS3UIi+7uqhK5QAMiMXdjsbpJf1h0otK3kLhqpZPWEPRJFs43BYJ5LDrfBYNXImT1e/lRypFSX4AzOnoXzDYdf5o0ewxO7Bk05BIgoERszEUMC7BrZzygwPEF0LZvsIIVe1DvLKSOs+bGx9U6D5LeCBURgjdXMmJ31oppk6feqHisyIT9j8zzfIpT/JBfHM2/0WRq5FBOmiGrQ95HIa89f0PQcw3z5vvGPfD8O2kAkwyRuTG5ntCrPQjLwJwEr4HDNHjWZRXu1sAXGAOKqtdKAtxFPJOnVaSBk6S8o9vdQwN00NmP1Sfp8fZbYSYBUUi60UaV6zfoviOZd+DdR0MIFj5PONXCIKiA+41NBkuyKFQX4UIPgYDE/ekDaQ/KQ5rs17nk3ChLO7ww/6YkBO4Qrrud5KoK2g6CvZ7PCCIL2A1gqRVZ59SYnyYfWWUNnO0WW7OWle0/5lR8h20MkIQngrQ+E3JkT9buf2UdWjaGXpW9aYSJZz3UjNZ8x1RD8pf2IcQVeXMM2tSGKJr5v8q4UAAWXE1KtNRBpVFF1o9IbUCry0DL+k4xYSWTzjOVfdIBwHv3RdtUvfqXMGgVIGoFG9ePdQCt2K9Mp3QE4rXwP896kfX8FcXxIFVLd7w2hvckQVFTHJpjqTYpi6NczEETGzJJ6uoencE6f+XrzBiOg3LJHyH8AVgFk95cQQuCZc/AIGV7V1pPDmqCRog5bKi4qJVqOvbbR9UxHR2bexyWj896ZCfmfuzeBsrqmknmUjPvGkjojbDgtFcN65m7xfFrbt5puFsEmDZAn6I3YfQImacKeY2cdNteA6Tv1tcCLTS9e8jcYCK9PT0n1Sy7m2DvKTClAILGqMUjiuLRdqMTAROg0lT/vAbvmTnIAVG7Fowa2Ir3hI+xl/m97ngyyemnEh/QvyyB36rYWHTe3UU42+caI5vgFkofoSAtTs3mpDoYzoVLGCuhe8nxA3P6RqRo4wl0wQrhMu2uFW77/r+96vejv5NHMJBnLjSMpzyXRurmcFqIn6DbK6OhEePYUzl8LLTQWIsKSA8jACmdN6ZcpR79IC2STXOV3F+xYBFcA0DkekuIWESwHHeV2tchXT8VJCx8YlALcQ2C8qdOBOr9eEdyCyK1TtAhFgT39M7sNgXummqqVC6MJOFMEXcgAqrh/5RMKsfRpBBB1ZtNr+z1/0sU/PcDM3HhM5ATutB6OidYM/dAIJ8pDZsnqNCFeS8kKWlys/8fsVotxkqtdWuGcFF8wA/KAJOD+NTqEo8mVIYZ8yZjrbl31tCdFiu4k3XhPEFuMHyg5u2qbXe/bBu85tTyUxiXb/jJwA4yn2fKaSX75FhTJ3eqDU3Z9JLBjON/vKgSKxAIGZoWR2Um/d3821LkmbD4vzl9ymfXSeeSxzHxJurxBtyNWN2aHvvk2VTLIcmgOX0aZKpP6VHz86kUnu0ePBmcHeUFjHMlwhSjXlUAHutj0eKIlqNgWh2jRIYcEl4DrXkEzPHcg1NInvM/5JgiNxKdUmYgIWGGaZEQNEIvU80yPPoIkagZeb7F6H881wsOaj48vSeYjMIYJBdbxmo39Eao4uveTYceaGenbXwtBvTGKUsFTrqBLyh7HSxxlzuDQnGyEJzavYbnvEh22Nl75qqmgCuAsD2IULm8K+WMLhqUiBR4EVhRMjE1YH5ILYVm0vm58b54+rb1sWqOZbc9EqB5x3qhwi0taNcXJPyneNYUbocmP6XNVAk+awSA1Vwck9cUKr3Vvux7fBGgE5YxvEqjiOieX2qzwPUoUP9kOz9xiNljfIPXIvyQ7yyNWiZbI24GY6/P+BOoN1u2jf4rUeR4vSw3M5CZTjBxhKtEUsr0AEEyXI/t0tWViZLOYhdfUJ4bPH+BHCqCbGGIyAEnTLQZY5UBEqsMTDN7WGIQEBrtHr2g+RTyUJTLiXqkg7pI69dRr1s+LWpeuJQnNWzgiAli+XVwmjVB/HWCpWXN8zfp/ZcHpQ3q/zp4W5gmL8wotE29CRl/DEFs3m8Y63s497E34mJQm+trpbWPUy8vFJoIow/MOJBH5Gz46wOYWWOjt/3e4RVUZCtRttLmQROFmektQU4cCiCA4DJucPqU0uBd1LN1GzGhzlQ3vzwnU3Ww7oRjO5TfNGAt763LS95/dlQhHJruoLJVfBF43g9+KHRq21VHZKvze2eBPCdXRUD9U4T3KOGHZiJXbEIwva9oRzhVC5vVo/FQn1U75GZbgaMV41OSc3D3qVjMEUF5h5leg0JXcthk7qIfo38ctRY7Nl2TsJWeTWIbvzDBv//8yLWF4mFciw7P3ieJdLnmjtPcevdStEoX9Q8D4s9VAMZo0o/SDc2Zi+Hy7gtMaStKhHSWq9MquF6yU6Jw2DRHp5BfhY8emMwilt5WAuGyq045xhcYwXhA9Z5W9QCdbGYMnxMJf09+Ym3GMf//O0lNFzulAQ+dMsJvPZ7/MZH2qn34jwjbCvULdS6dsQgXZRU+nxOJHGRLQHEvdHY+jLuaOAhpieiSC/Yn9bcYK4IQthMHWlY+AbBTx66oDI7eOfI9HQHW25YBc+AwwEYAKfmnGfxPAdXZBwac2uOApkOKgvKdBphTPQR48gh/A0UnLrRHAb1LiGYsUmh45nWYRpbHCk3p9mBS44vFSUsqp7OXETOSxIg82BbHYcetLFGelZs/486ffjclf0e2ZqVBvQqYqd8odV2czHu1KZIpxCOOr4K8A3Wfy4TKuMiaYKeMdWLBx2jb0ATuLlVWtsHq8HXJT+lakBtHUgGkF5bPdMR/Oi6NPHM4M4OchYK/oSE01Aio2Q1gkpNm2UVx4/a6Jef0zsH2BfUO2tBJNu5UtGPOLVi1y/B5XgJDEYCKwU5S2/jeRElxqKRhoMlraYJGleyS9IF5d78SCkSlQ5zllz4H1dHHpTNLYUv0/Yc7/iYKMx/aQ+w4hipOkwqRt3FN3Ntp64D0Na6aPp+lX1hjrzoU6nTpUI0K7nUMMwiJkxcChpIr3xzBArjSLs7z5hHQecNDKM5cnEBktKHV/LB2gwKRLp2uXHHsmnOa0dZ6KxXzueYw/rKFYAoqxK9suqtt2J7TrAqLLzOEpI2hZw+Xj7dYlHy0uw9orbv5I7Wrp/4hU2f4Eoe4pqxMuouEvpRbxUuA7llUKGI3NQI8oQ6pC73RRkOWCNseQZXGDSZeu+d5ByI7vio1Bkqg+OUXZhVqfw7ke2Yg5l2OARyoBH9oKr4hvq5hxUlU1z5q4Y7xHT8C8cDtc3nGuoUyQcGxM64ZDTyzdgHsz70M2wi7WRSKnPLCaeZQdoJn3sBsjWTYOogj5GqUSWmGNWIbttd+Qx6jFjQO8S5R+VR9TfsXmc5eCaWGRP6uyliw+0QW20zyjcv3HDk/VDAfrgmpjhHtZnrMQ/v+I6BTHgmqlbG/RgmMooqKnfNRYXDCdlzRmCCTG7vzGkkmDzHFraFMZzHxh4idP9FtQPdC/P18I3mAZfRFw3roGp0j8CZnojrznx9qSUjIWFVgA8WG8qnMrRn09bel/eLjc7It0viUskEiuSpK9oEElwwznCe8AJNt4Snj9opWljPSCuePtoLY6y0Pdq0ILGuWN/fo6SYdyYvYgHlDS9KGC9xa6X3vbBsAEbvIuMcaA34nM79Lx78/BfVxdLu0sFkmlCZjnJ0pRNIr9dTnxxd0TM4p0Pz5OvYb4lirMkihueTw5BkAcjHYqZXOYmk80/zjV7cibyHU4dOYDjJ2qbm8eVu/tIegUZCwlUi2fVFhOaiRmi0Mg8C301RxVc9V2n7YsO9UiLMthTu12yetlx3Dcx/3R1+xwsTHqy3EyQKGj60JaJMuF18NU1GdXDQEECi109Hxe020w1wrBBk0v1DOMWRq0DUD+Wc5PxQS7IVBSZlmAcA3IJmi5V7+ZN2obfHM7M/AA1bOtg+775m3c2UWA8u1U1VbANgDX+HJHz48t/VE+E2JArEngA919m/5wltnwCXbOx/u7d+gQRP5NAuPNu0HMnknLiNXvFxYQqpgm1AcnBhaNluqjtB818dNTSDqhmtWG7uucjw+SkhRL5SN4fcQcMIAAyri93A4dZMiV5TAawjsBJWi0Y/BwoNcrxr+HkF66PIpUx2z91YOjkIokuRcDDdoM4T9hR69ZBYFeh7yhZ6TJnPNhtsORyWp4wztZRbLw3E8i+O/QEd8mVTTHKGXS1+NtxsV5pA/4oVQTuysFY1zHY+bvCJ+Thz1MGCELiweHpjS0rQO1/TdoncuXCRUEi4W+1lpkKJyItNrAIT+5lJuXnx2uXOOLNCi7t2OLaG5h1XbJOF5NXAaNlhbGUHaAljI5u9JAevbU6j6oLSJ1jWcmHe7JdxA+9RCMRUmKhdAjO3ZaghtIP13MMI+GNgCTosLfv7EPggZ9svF3c9WsnL4/sax30LlDl3qnFS1rTjwpB/Gk01vv/FYdCh6lLDSONbap+CVTke+1VYsJH0V/uyAdYZTAWuFduWjCnIFFvdp9AbNpg4HPpVLVP9roNDphv56GVrmHTzzkxfipQTDRiRqvNmIvyszKws6w+WHvOAieKIRdSkK9a5jjuXZ+GgIT32AIyipO1XBIZe+NkqwRl6iRyxAfEGkj2uiUQAFRvNnlcXMO9DV68qSez+yJR9Pu7m6FJn1EdIS4qb42nNtSv/kSxOZ44jkBOfekMZdunCXNfVXD1a1MSh2iUZl0+ndBj5uQI5uxVxJTCw1wt46F4RqIcCv4mXfTiF4VNESmMUQPNrsBVpGFjNJnkBIpuvl1chdbQCUMQ/WvbIyJuKlj0uKG0Woc1oQtDLhP7xnweySvc1wReeaJHXSuXA8JZ4tfmqYH5gcegklqga9Yu6KmMXCRFbQvJOkh1PZTuYKYUBPdKtD5fZ2yweUw/EFcQrlFbNjTzJVDnu3M5lynSsC7c7qN58+Xg8ooTPsbVffnAs7IFTBB08+fT+u3p1uG3fpSzDo1jUiUhEUeXme2chTxVwETQQBd24mpkav+9j/Yl+TxAXXpgRuscO4IP1BFsjYF7HEx9YA4WrjwRSGBwG+QWIbal/2fBx4QhQ5rRiAaD0esxH0fNtnI0hvL8X4KGtvlLokkJIKoct3MzJCnd2FdLjVsKTM7SMcAZlD0vbLaQRH4InwghpSmfS9woTZOHv55t6dkhgcUaIE7yUIhXv1W0Ifpj/K0tvHVa2xi26UXao/7SXQn8JXPqqQa+w19+mAMGumimqBuTgc7DPY21ShtHNB9PyOjHgkubGed418bPNnYuPR3jmDuIjaVznDvxFvOEvuPlWpl65BMFKrRo6/bdu2yk+mXhz9YNM/92CEDYGOo/bYB+ohPjOqIps0NQkfANIEEkFGvM0l3FnCm7AM+/o2IElaNyUofZJzIuq0q6Y40i20p6aPsXPyjaYCnCPHh/yG6VufDOuXaNImdFQM5r17bhiV33K9OMqxfkvXgyCNt8LfZ1c/5OtJYhCPN/sH6jAFxN3im5p8FT3BCDkamoTk7RaJeoGry6Q8td/KX6DsSj1STA0Nfjx6QwCf/BYSy9k4oiJeuCj03gIrYHJ0TEXI2H2Nd4dLhltH1mW+5YwfPn/F8j1WYyzMVzSi7Nu+/bXFbXTUliI76MDiPlabgCQDReC8Vlmk270cfdJdeyOjzN9ICkS4xGOdYU+a5q9LN5iW0vBu2nFrYqNDzcp1MVddRbg+L9yvqx7tzOjj54iBSC5j7wa+S/O/BiIhvw7m6KPe+/qLAcrzSNKwEsfS3SaBDN9gh16cPpN61I253cVW7sqG+ATrBLOJV6tVFvggPLLUH6KixrTNVbT9CEqfn1XCn617xJmP6zWvLG9lNlaJqCQrDPat2KXFsGRurcGFL0JZ0B1srnHX02fHz7MjomK0gkohc3X31Vne/GyOXVDhiqaDK0HUUysZBPdz4F5iQDD6XT6UDb1daZwJBjlOcTQiqFKvj1FBmcrp0A8MdulnoR6FTCMho3RY+JYuFnBXY9LDuAAR2wzxqfxG1+mwfu3xs70aCUtODtyvEGuh596yPjCKyEN3Q2cFP+cK5DKD0h2ubm99nIXsquflZfvAxi6dHRLnAV/E5S+tJE7m33TNHnJCDnHim5ZrM2k3opyWU9zVCs96Mazvpe0ZU/RzWkENuq0btoBRSJJbEe86vzJfzw2YIW1VVdZ22jK0GDOi5cbu9Vl2rzgQZrla3VChMht5rqTdN/aSuh//PAbmXZs50QK+N2oW4jM86AShuWPKExSQapZ/s6u4A4+CayZMl6CsozF8UC1tzVejETmahmMgd9d1duJrNf+0HmZWHqJUMxPcIT/MkTyVP7r4ukSPKu77D9TzYY/MwLu9XcrqJWLsL1Dy3Ni9kcoI10gpzqaEBGQsOdC1NyINKC0nSsGwwtNZPx8fVg+aMTYoXquBt6z5GAczhDuBceX29WSuDgPqVhyy8rj4+kR4pAhy8IgMjBk38bHd2r5GXunAjtOVH2T9AUy5LcYZHg/R39MZxBGbTkb7qJRQFhKZI47LahOs5RNniQJcxNtF0+bktRzr2JrgBBlneYg5JBn/H5xaSK1tLeb6RFzbizF0a8Bj464N+0FBLzCCUVCvoALWyo3NHEEzA39un3M7LC8Jj1WjIKesw71jhTUGgOK4xJMEq/Jr1RNDA2N2Ht/DoNPHwxZ1yOF8IzlAlIg3usa1z5OIYjU6F6wQhNLgGGUuvLxxnivROONq1c4rqxAKVSplKko/Ka9DNb1cAmZqWefK12TRVrUKvcaAtFmqmlT6ERd63G0pM2WyVAoMGpUgl44NzpBIyZzE9ZGNk7TbyDr1QxVt/bvRXLX96HB72B05oqyfidA8mtm4JAXUixotqrbcwGloEvdRrwSs4EVxYl+iO7rDLhu566UNfPlmIG7vTpD/0N66tQrB7PUNMO9I5CK8pQk0W+21IiqKQnsLCpYl1qXhSMk/tbfNlOCDI/1GOdq+Y3rqLck9c4G88/o+UDXyDqROLq/9cuRwnDcMUUxKVFt0QdvYsOdIlkDmyJ4U1TDFguy8dTH65+55sWfHqJKDwjsjPa/mLUyak0MDUsY8FsGRNOev0uNBPm8fyX/bMZFILHGZnV8b/LxBmz2X1r2OzUKBFNxCta2L3FVMPlJQ5e1KXoDRPY+tE4yyvmJH1ifMifWR/qgK5HwS4J1JEFZ0LU7ubTWq1fwpaQnc3RRds7G7w2+vi0QL/xXTYq4WjGljZN0YPma9IY27TeBgOCBscwRkMjpE2BSYurE8JzZ4g1KEt6CcGEDF7BiosktJPaRvyCYyUh4iEedKYfXYKN0EDCvKOuzBtroxC7yWvsgHW5zVGqL0p0gMNSl0w9cITsBuu58C8HP20J+iFSXXkKc7v/ZlQr5cfYsv/Epqy8B3sYDs9DsKtue1WiBIEvq292icR8ALf1q892azNaNGlZTPrJKUXTfNvmUHZm6VQMTdyX2NUD4w8r4OGwEtWd0sdnLOawiuWcBvHHzuh4+uYCXRvUFFwJlNfbuWcshCOkhWlkQ6QDRQb/TwKY3wcQgSafmXcCI+0pWqRAWIQ/u2dlyfSh54zQsLi3JyXWm3fWYw0HfD3nwcMQuo9eOuT55qObWCo1Dq4b6i26cOLO40H2UybpMTMRxayh/vHRsmvZWYSUbd0XN2v70K0vRMk9ADAS1H40bJD1ef7EkcudX8Wm65FyRKS1M4Mc1ABLJhcMMXXpNnOMEKFonZ3+eqwd/4vwIx4e7AxHvqzFi5UHfcMek4CH0UV7nCcOWjpo7Nx+QtVCSOFSCn2ReWZOeF9aSlniLfIn/XOEdqb3NALhiI1MwWz6G+WEIpCGVNFuv3yIzFLGYKWBcr9Dw8LHQa6+YV6T3x/d2KYuuC4I/sP2W0mVx6WY1TN/JtcsEEORHPps8e6cNBzP677Uw2J8pdRvcRazSU+Bh9dgDANggKF90VHuOGeoeQrlJQcksBjL3ficrWu8tkM4wMycKRqdAVdHURoOHFUmhagBGD5qodoUN4oJXTVA+p7JVvquQzoGZZZvpDFGtYd+nOIbAjO0zEiqlQ1KFM7+jb2qhStZoZNqrKZJoZlIdjjt/ZMbb+mm2mbPdkpTTZGhAyz0tfnlopXzz7utMhvHBpQO7v/nb3zFJWnX6EzDVzEiNUnGbsi51Ypnqic5tpWKXE8A0fr2OgmWJ0XI+c5nRWNinAnr2Q6NyHlS7zuqjIFQsKuykaTFZJrhWcbDztDxUXEIi06A3PpYpwNKQ0oOmWDjsdnYaQKTaXur83EDe8lXbpxnLmWxr9Z/0yOr26j3lGYSGXzb9v8hzeH/chMny+k0h/rF3XSDopkOWJhayNFyB+HgnEtyhjKBU/UnRCo8bYJD0Gf+JQOmwavddbU9fel2zpWNcrNcJqCOhqI8EU5AKhy3IWi8Q7ZTMiL3B26Siz4/v/vNDuWWVlZjoMsSKcFJYupDDJfzb4vj0KR6bqjDfrYUvWGfGSTXGFqf5ioT94GIS1QHdtl0/Vz4QVJXJ+k9wMSrnAStwiXLpuWodRAZE5eiua2px7PMe/qlqP463nNwOAq34ECzgIoC8PxyvkhmplyxUUgCkNusw1HipKsxLpV+OieG2vDGk5mLgFM7IsARVYal0yoscc7EcxDPhLjF8Qj0yTPegEThjYnJrQIeDXgaw3rOeyMIj8JKhkCa6RB2vHYYsfQ+smM+zppTOxxtDShGKRjkk8fIFmWAObHYSypnnSNmMe9ZhoMFjoG9iFl4Bzt5kP+XzFbpVyTSO/8E5+kCB34b3IlF2pT2Xl5S7vxie7DTpwT4s6IZWHh5bUnjJdSvu9Tsm2jKl3UDZefvhjQZDWSOqpSYP5YFU3+5WYaMtr6IJJPr8n3jvA0I88aaeMHJWLFrrmfYIypw1i8PX/fu6SMV5Y4uFZw1d6GT50wN+26yHGsM+EJ4fJzJoSaSO5zjAi3ZFIGiQziozfq2Fg/gaGZCpvIcVCnGJlR+H/UFys8efXUqtoat3Z3vmBXhHJbG26kfC9mVtY7/0K3J2CMwwYtlohx2UE/bHUBAE5Qvnh3uIX3TJS4VD5/P1BT69raDG+VVsUhab/AntG1FFNC33HYLEaJgH9IK7A8+S6KOOLEtuBkIpEv+LDZNUDbfb6rBkDtY7JAEaYJ5/X4CcVjDBTNmvrbQqGPCAZ4PtEPH32/+RQUY5UnpMOyTlM6hTx5egWU0KhHxNrOgAnXti32VpKVN+N1HPSopAU+RVf4tXxk9BsZjpOJM1NlJP9FZgRCeKV9zXxNoCVxJYO7XehE0aTizQBkTIcjfnRIXb0tY4IK0dvg3QAUxkyZ2ewArR7Hh/73qRtGqzPcCtn/P0vPtvsjJx4pdziAc4D6bkrJH8T8DBvkriGOb6l15E06ELrixH3gh03Kai+RpklQp11P/UI7cFeoaLr51dr0RPSPdm5ZvFT9TpHUlye6cA4QF0B6L1/nITunGrJYmuIm36VmyeVBrv49XI/Y8EVkAOOFh0qBMUQvEqyLuhoUXVbQo20iKSr1p4n1dxpO1fQil8rdNjUhGT9y2qyaGW/iThCRtYEmHEgAaTCwaRtiGHjcklvC4Pop0fLD8s1AuvC/gErYbzTODkBulf24m8uc3rDGUMkiBBTlVzKUBCvDN+PC29dRrW4c8O/0nJD6P46VIIVkSDGY6jvqoVoBDzbz7zQfbEfWkFwZncHpBZOZYQNRWpHA1nYJcitVumC4dqBpuk1+P182MVolGrzO6heb6UDw9MaAo3go99N1R5FMrkKPL5NtHCT47uAH4MLYQzuJnNzJCQl/lP2F5AR+2Jp1LWouWGvKBIDk10n8JcGMwYg2V0LTLADMHeKLXpn+QrAutXE53sIKxHLaQOGRz0BFzgTWWjSlADMpRl9GppSFooaK/hHQexjwEgYsfcOz6+RzySghpJhmk/NUoTAaEK+GgvDrmx41lpl1itvOB6L/AhWQLpjO8yCtf7tceEfWz4rA69wjc01nUuNZYTgWGs8KdmIHY42+L7LI3LzWBan/+XrCTBpigQmqdnTmhdGcvympPGa196JnsyfLbCgyqmjT1V5k3rZblFdW2jn6TvJjMUvTieYfXcxqtbCjysus7xMfX6YQH72uDMajlQeMFE4OPzypMrfYqGmvwQt2K848u8D3ZGl2gRfS9FQiLyxx/PdNsh6haSQbdJHpWRZqbDBtjVGT5pjlZtJjYuqDXGslQhlYcqH2PpQaFWAoVWRRqy3pJ+RsRZBTIo9qIAc9bYFAi/fwKVxVX1AgddRT92RMFtJtQbv61Q3ALb8Hx0wLLlOywWHWiBgj9nuyWeCR0qhYrABx48yILTVMYj+BsUdtlAIytIBc3G37M5hqeROF1nmTVItE0oveKVqwlrNzO0hcsyGXIjRFGpJWxNSiRyDoV9pwfZ2s2VvVPF95tuy0rcjSVXCQatgKBBlIv1K+juOO51iakOK2ARULFQx+FDS9B1zQikf+q3QwwkMgjmvHYH8+i0kO79OGafTak9rexX8UQtCni+Ezc1WnLnVYBo/nUv5CrPoU4wmDJry4OX9mTm6CfG/G8FG8H16NMSLsfG2B0bx74L6WSjwracAiGqHCsLq8zIXDG2dmEdP15BoRVWBVAePwrD8AmV6OXc74HhiI9Qc1xlRRXxSGzR3LOSpVjhlX1EfKxoRwTkLQSdNamMvjoQr+7RZ/tnLDVDQ0IckiwSV1i+FMwblvW1SUWpO8IQqcz6qQM2/r68PJ8A+YAZzzSMfkP0uNvd9KQpnWZmsk1Ks8o5DEpBKGWuN6YRWiZBid+ieVhWy+M+l7OTbj6qTi5F4UjP9BD1wSa04m20KiaxvttXY4H2hEj0POLKFSK5klm1L2ytrdaBUxfUhrAzeZx3CGssKpMC6L+bP2pdqrTrHr+O4je6p+0p3lvv+KUwlmn6c+vetajA+nGL1vkefYhjwe5pSkXeyv0o4Tqj2NVdxxXOYj1q5ERJ4/j6T8bJR1952AMQpDVD3QvZAElksAFYVgDodZjcKdR4hk85N0WHRJtGCakwek0aoZpZi+uRQRK1FMxh/LTMrj8ePE8YdwmdQNV2yAig5dKkzxaDP8cxzSKlHCe0Rs++6ahKa9IVLju8EH7IOWgAKWZY8hOh4Qb5Cyn8W/9BC1HU6vMuqY7sk1bg6T/KiVNNJNuZ6FQ0cAWivnMPFPFfgZ6nUy8eCsMo4ix4M5i6WdEAL1qntl57n4RzUuX9J8oOhJafVe+m/cfcGn2l3Pyik0mJMnG+HHkb6OcISQWlrKlKDvDT65WnWh9FQV3H/DeXoHiEs5LUVgetBjkT8g8IujN/qQM7pnso6ha73VRu0kV1m2yNhPX7Or6YOstxBLM5YqZaavkXbpu3iH+DOVKHcfz5sXeDmRA8IhkMbEt/qv++fIWj8THYiMJ2n4+X5w9nJLJf1ZyPISwBJnmhw2y2JFE4fJ/MarnOHQcDEEh9R5QkHlW5FkjYJ3Q4mmYtaLw4tnPJ8PpnAT1m/Kt5FOK5JdzXAHkj+TW4AWgVKQL2o7OytIshgA1/56B4ZzAF/1MTNO3ebbWzqp8919/r/t4lmGVhVCZca6VvB5El/P7gkACG3B7iVJT6/mS/au6Z9JF0sm9bcYirAMkz4qm6B19Ycf/bFHlvNOAx+Ttr53dypG+dmIlR/WunMugx+szNDKzEEhzPlQ6gmCxHLdadCfOiEL5IiUpSnHgO5Q31vK/NVnaEpLW2XrD8xqq5fY9eLVW+VhHDzXKPI8hnUn9I3rZ48V1ilginr98L5sF6vom3qGV+2eCSxsKM0UQZzb6k93rNt9JakGsNP1VoPT11Ie+dqceQ1MVyN6T6XP9oxaYJRHxhEUJ92lHHlWR+hjiBuapAidsENpN+SA8uSxkyqVC7dE/VpaNvXXvTiuvWTpuZYMFIDMQn4JIV7Sc9E8FA/fTzowpHDQsALQMOIweFv0F2IivLahNndpxjI1n8B0F8mYKmB1M89Wg+vLa+LYqnBcGeZtUgQm46Kel+dJplXzpQ86srskMjcBPDCRhfda2wCh70k5G+aVhBvmD6SWIFmgg+nX/JbG+h9imj233aNWeKai+d1R4Vi0tTHRFrbi2GwtgQNmWDfXeBOeoliqFwm3wAaWlk0kkVZAX7jZMRxvjMtscH9bRkV8G03+OSQU2Bwb7aW63oedTEa7XMxsZg29lZIH7PqqTbOIY9jdCFtFhcbzRXN3s0j2jWJRR/3H3C+Jyd1eIT3z2ZdSsEC2AVI+HZgTaCN5Jvj7Rhk8BTn3cuOVr3EcKc4tz0SlW4i++8vSjzxm3grwCzULKxN4KIh1iPAd+rRXVI2UeDhxjRblb456/9FxGoNznz4gb4HlM2lCthXj0gU3ivquykbEqvpWIbXVqIl+qhWnT8wPZ3j/y7um1LgnU9wdkWF0b3YPqnI1/TXJGy4VS8868M6ER6aGhTTS8Um/Dirc+XU920qYW6Ky5a+iFyz9lrh6KEEDzInXq6x89VpwTP7Uk8CZqzjHKx4Q/Q7c7iqSXWYnqsQ0Z9/5/pnO3MIBadP7AKdUyMlrE73FoAZSxOomoX3aUP6sSnCqBJWfx3cxOuWtnBPfGun5iaHQjFxuO6DF4LfRYWUhAAz3wU5KiRFcnAorLyqfur512YykdnvLCNzdYFX05hAJWgjTXUl6N5ToYqoyrktvTHb2gY8cLlNWtmOo6zoN6kZ1rNA+BdIqGMfRrB7uubtRra21f0F9JGxvwaP6Dw1zThjtkpwETuHCMW722WUOuKcLmHuEjg3Q9Y35fAeCU+v7AqHp08to9oJ/4sg6Kr+vTuLgZJRju3tc70pT4BG6mU1JHYQW6AOJC1kRh3db96qSR6pXcpWETSSfimA/SvB9Qoyk0PY28gAvcKmE77qnvstXRUtHtwWmNTObNcwBIeu0LkawoZI2LvPCbL/NT2GcwPv+xqDmfR8nkUF56V0F+nfG8JcFR4U0fMYnvHa/hd8zOoo5F4cGdr1yJTjO27+r6gaVHSL+bTQOkeInZo7assDMnhMGiTIPL7X1MU9Enr9MXzVsHZlkbubhDRLArTdFzDIL5r8bXYIotAhZyV5PwN38D7ZiPxdavL3GR32FtyjHxy0R4xYvRSMzGmQFqJa2tJ0tSJ7CtT3t0wmu/cnnx6TOnppabv8112K8XihqkB0FfZa5jhVXysOHI7YFgIh5NO5JYEU7jFawdPPxpGtCQPTXB4dAkPaTKImF+utQnVdTpelQXoEt7PaO/XSVhJ4ayIsDLg19RrdYX8eaHF6bw32vTgjTq8WM14fQRTJjUf6ouO/7JC4Mq9gMBXyVhbdZVHNMZC+SIoxpvk4iyvdmBUt1ZpiLjj3UVEZaLOs8rAgTFLN6q+yw8/aXnE3LhVM4mFnuhlJSbiUBfV91LEhB4GCGS+oBFxJXbUYEEfjjxll+qHHYRSYjFFLZvRVC+BCOB4nVKXm53MC+lV2Qdby0/DDZEcBiCnCmdiszRlCxG3HMzif3Pm3YyNZy6Wl0eyK/J3V9+bg3d7pHYAHPxVQkKFl7UMqTtEQILKL6eFLWZRVGfyj4in6qjrDqScR10qt657v3vTWZ/sL6xRY1ViFgWAPa9zDl2D40A1GfkyMr+jsJtoOlCvrpYbtsHVD5qFrDPn3FlImmRaY7kkfPLYHJsz/DtxvMaywY7oPDSBHBZUMsAFO9RcLtZyiKl4JyDzV6iuK2FzaVQOSTG04NL8ndhoELxKyQesWxxd9phUmSkbS6nkwGrtiNxLVE1GIqMolUHTlA7XpFGhNpWgtshmu2OLiPoNLkIUshDsN3c6jQpEtubocqB5MirFdGdUlApXRsPv9GJP4v0LArXXG8zGfZilmrw9w3GoRSXWngQDGHPuLBtScCxK6THCnEhMz4Ln4vUc+NEEhG97Gvus0u0B3jgR8REFr/3nilgNAvgkVP9HFQbnucEzO7cdmnwB+WJBIqM4mFNubwnJ2R54RlKLjIajWYxTHvERpJKxaAARYFNEi2zWYzzim56SzModMPsrTnmV/Eo1RyYttcGB5SDAN5IAntaMghZ437iKsNb+ALPrh1EnB59VR+cEk/zkmymkAaYi9+dKedykCAOOxmrHDeEsgZbz45KsIiB+qrjoeBX9zLtBqbxWvYmujj7SpM8paCptqxDgBIVaou5qlbBcUme8IM1GuhLOsTJQvZC+j0CHXym/W8m/Vi7HXpxUNV6YMKzWZtp+i911UciZM6sQuinYX62o0+glfzjLPZVQMPxJFK/sK8jTR4WD8jRE3DvZ0yBILbd96MmyS0Mu77B8wpncEp26bMvlvorqz1FmViwtfVAfzBz2FnmaYYOEYNl9Wc5NG27zTdhpjV3+g8kNGyZTDUmwSHJYBvIUsXDxf+jDHiFmbPciv0M3BaAtzsNdfOaQUnRaoNgoXvKJclohwY5IryUd3V4C7U8pZeL3J45yeOBiXltbdFg3HcFj9Phm0EoQuNBGA3JdRIAUFf8fKIkUCJph/DoxVycOy7XhIcGbIGKzTs07+wHVYF+3mP51/NsKJsRjOJXRmOFMgy6tnI3LQNCVUcCE4Al7h5MpksBdyHJ2yq86ca0oZvRfSqjEBAyICzt0J2xx8tgrayx6V9/NtKfSDSR5vHHuDcaog2yo6mF9tJhgA4lBKJ+4mM+N6mrie9Dt/JwBILW/yRVQzH9heBc/68/ul96K7eXu8GqliZEEriLp1CtABITh1dDD1+oNIHIJ5b6+VbA/hgTZF9pCFBauVC8Yt6dtUUMPPxIAqiTYedOfudlRtJqPyonec7sGz+4+3DgMAAwMRJ8OohiBl2axNv8inJ4GCDhs96gt2ixxh7ksqAe8TLH9RMzclJeaU/QilpO3Nhr0shQB+tqcxr5tuMDB98rQRuHAViFITfjl+kdnDxwoVXhb7UHm98Zx31E6RAep/ykjKNLXnEpXP1MYIKQYMXEL6LxoR2dkIFsa9Rx6ymTaqx8wVJDhFQrNs45ZgDs7So/hJIu8PLzeUfitVxXdMLI/G8oNN8pAGLOnLKNNlfq9XjeNGtAWHhUi7bsp+QBPUhY39VJITfEx1/3Mdq1x4eRxe/lIjkdl2dCHQWpSclM4ZfrzTxGSHVPe5XEYgdxYKe3g6E8i9q6ohxYV8LbtsTVf1pwNHZfVllGBUVGXbGCdEpYd5ksj2kdB2yU4UgOSvYoBBW0KkyyPiPsdpu9Y2Cnb3ZZ1NO4Err5TcWjcv0xbRnH7OAIZO7Hm4fbyzHS9n/RmXAHGEWACtKKTStQMIsyl7/v6ZW5Znfv35KPcbqICARmGVuSFdfz81q0nqXJ0OvmDTvbACxxbJYWc5lH2O26Bxowvd0GkoPJgbVe5nn6mFHmkmevAaMvMRAT8J9DjZyULQSjC77bYfoKnN8LDXvK7Zn1mjAce19FTTtO5MqSbYjfmuMXyuSAqJTijtNEF+eyl0ZO4LeEMPD0Ox29NDSpoAmB7xI3mJ3N/XRy2UHDGmJW4Qcx+aIl4lkN/QD7qfj4fMJku5WeqAccdAIiFwRbDbDAdd6QNdTBB6Z+5xvMVdVWqvBkexl48YX2iQ8taVrhTSyviXNV4E/lvRorV60FAmJNjRMy5uIeLJJ1OblT3SG+qpWGPznQqkDGunL1HOISHiUpB2I6W5I5PsRHKdSQp06HFQD2k1dMN5EqLStpqPoOgb/Yn6tiKQxVUg642Ju1acyq386zcHsQpaY6h0Ed1h4eE0qWGWTFrVQZZNbT0+nivv5/50aHVFRGA2AzsPeS7rSWmbsMBBYpaswlgmjcyrb+CaCfm7N8WvmK68ValcScOKj16RZQcN/x/dYq1R23OxlP1UextrOoIKAnorO3kxIiL6f9qG2wgx/gFXYzxtnUePm4x2IVyXZfp/KBYyQklZc+ubZ5rEUhk5Lnm9hXaYw6E4DNeOXSlvzDEkdCcTVGBqH8CijMmEdonbo2dLP++ul3NW/ucWDPTlHYm7Ook4ViqZ0F6X5Vxgvs0z15kzJmEwiaTINhpqQ3YtCo2E0tEoMtNd8mn0UuZmi78TA+97pfbiKq5bHCtB9Nb+eug/BVx7CM1p8fl2knQUnyS2YGE8lw9Mw6LBgiL7S9iYnmxf1v8IIrFg7y1+Q21TU2uLo5duRQf7HTVkY3v6bWWhslXYjPMwaISK7hfOCGIO4uqkeoTQgFp+dQ9t+PsA6CODlYOxt2zMOHSn7Zrf9EcN85YmnhgMLFUTesHW2HRj3OW/HZVXhQWUTb0Kln/uyuFDtj/IwzWIpkGwCexYnRXLv1QeHwQj83SiuUgUQKXcdPkLASWuwSfhV8bzHsurCqVvyyGjUtVAlvHUCT/Z/onNZJ7eUPJTWI1b5bpPb3y1VXohA5+xSbh0ClEMV6Bop7XM8kyIsxRM2wC8uikCbOFIdHuQjnureXMOWWhCWOzlU1e3MotNbeztlNoPXDoYMokrNUJDjAB0l4MuY69qRe6Wk5n90/etzyDBBXwEnDgYv9OBc703OW9GMaNXtZSJQztApK5KV3DAShPBJGZeNtrPsU/kgEs3UKtjAGEv3mnJAWq2gD4vjDCTE2nkP55bJUfV/uCay0ntYswiFDOuk4qO0LFN+lyJWLUFnAi2EGhqFU4vUmI+QWAO12JmjW+lT40j4OlefNp639n1AyrF6JkUSg9mPKti3/sZ2l4sN5TieA9E6i6RB5XDG7eKSeRuJuBk2RatOy1aWtTdvJ57uy0EcywDKeZnIt+NMIb4MpJzghW0oGc0VS95mQcj9keYFZduEQOmExamwCS/z2xvUUSFfJr5Dtqn8ZaqoZwrbX4H3AYbYAl05gKYgwoikSenHzRqSutBvJ1YUKQdgy/sv6YkQTwVhs5voCX8dm9uxn/P8mwPmt4rMOj/h21UaEAH9mh22aP2f+s4qTFDuco5nXi89/kVX02eygXAwIAXyr/I/HakHp1tapayV+xYLKyLLZ9mLe+G+YT+NwX8tv5v+pKJsDZX5scJdvz3dycvTDNxZGrQ/EPV6lkWPxMXvmeqpn3LG6IZmbmspJnsSHyW6Y22QPkHgq9Z3Hjc9DLATGjm7Ws3Tblc0HKITRn3AvCbWjmXqMs/KkQySD3rHEm+i1ZVLJU4AgZgkTCB+SDO0qkZpiac9WwLtlHXYXBngruJ7s0xextlJkLFxM9i/TRNGKch7Wl/P2ELkoidawWmZ8e0ydGfwYn6DEz1pI4YrbzAXxQ62vew6BXpVhn+gbynYCBG6+OZqzyag3eIZ5wLBcDg4kCNiLryE/5MLBo4CJznmsRC94gZPm+M+spng9G+JMcG4zC6NQy5oJfUxXhUoY1V3D60KC7V4RRiW/uMJNdJSoJSC+kBjS+yW+t6LqVw9XAC1ZyuWnZM+HyHcyr8Ff8jvasmW/BmCyAZGUahyE/DjPn7m6MIs0nP+dYQqpqibJTJfo9wxa6HGnhsQ0G0EO2tbJu8vvVs3zBa5/Tg9VAnMYa54+EMFxxZK+FLgVy0YQSpjhMcLkGq9R8XZtMIrRHZjDeNv9T9dDUDnkPzx1gwMjjojFz+DC4sUYfYltNkjWzeL/sgyiY3f/bPKSa4LMkb/Zh0665P7LoWVADUu0hzLOLWpaGnfF34oBJXzgXV95SzqXw+HS/aAXzLNAUs/wAUSAb9pUzoT+7eG4x3cM5x5VVjTaOstnPhCZ31wmglBAFuqmxAsfLgSO2OYOd8BDDWVdoETBZMSRCxSmClx5+EJUGr122s/BvkJDsKz3gLhBSfOHumkMX8rtnpM5bS00qdr4YJxvKpRshGor+WdeRAfXNiNqcaamivBdR90hOUYxQt5ccU7CWric1dZ9Jcdqt5X9/M2X1t/Ezbeg0BBGsBi1MmCE7Rri1gJ2R9Nan8fB08z1ommxR0HVHcIcTfiaHMFIcpcakDbxNuKfoLsIEzeH+/yRGx/2an+BD2cemZM6bLM+/KGo73CAuAxU0hpvQdkBMdUao+RylZP0RNWMFUTu/u5ZUKyUHBAnEW4Uny8ThWLdc0IzlZHuvT/gMlahP/YSt5OUZoBTAYeAY9tYpmzVKPniV2W8r168Qks2b7nXlw2bRDJFTpq2yAp6Jp96UwiBfjzpSUP2HLjvLPytEfPdGcaC6wUDsiWTv+KR9/f8LLPNIEN9wwXIyZcbh+7X7a4FHvE3s207O9P5pNIOaoNlRBo7sRW43ZdAfd3HG0Hem7wUiTlYBbbtXH7eLCi5h3kA7RIlXMvmVW81+ZkGhmCb4FSFitzfJorn1auYeMzaVnWHxpCVrht4DTmDfNswnhxz0dFzbBIp8LJyjj6MKN51Jkx6+b4Vja3m68UnbkOvrMJ3IutNp9pDlAfNJKbNglIxxjj8qoFMhVFmlrROmPLW0roq6h7leuC/IxfA8OfKHQVHLtdarxI/XjCVDNP11PgBZ5gNsCUp38m31WP5tW2YwprLa0wSsGXjVmHqSQXXCqMI5KGrNenW9VZEkJM9u0WfeLVW3UGvvXj25lOSPAVTcmK426E701PsHUQBBgXTXAhPv20eRXPMN2N6AS0qeU3cHl/98hnnpVsuqcHSsijAcShigIk87alPU8Ib3YTerM8Cnofw/4lu2WzID9GteyOZTNN1dwRludvvHLqAtWUAjVMf9mh6K2Vk+ocxv7aMHqwU4OPkg8ILZPtAJ630I9qXP5VRG09238uHafCdjQxJkVEH2GO2BGq6qnEa+ebYh1/TNIdPHs6cts+8SKW4EczdSSyOpXNFwBayLrwtXZryaCOwk9XnyeuYQVXpfvOnfURnPliRj8We/rIhXjXSxzxihfqhGrpmtARDlVgFHjJORtTYnqrIEAy5aj8di+jY7mkoIm1A8avwomnDtjZeVrhYT0+ocSNAKVo2xPBDSelR+4kL3L2ZDsSdVYxzA23P2FHIzCuPq6xpWVZFVq7oCjzVwPZ4Gr67vOI6dT5jhJvgnajBoZvqyRTZQw9IiA8+oxsfNJ/jNgE4Az6kuNz722poHU8tQ98TUcIECr5ubiqqoNhG//WnK8flLsRPue3dYChu9q0U89F2xNbfUdnbQRf377PSA2I70MGzUaupLqcqwXFz6n8coLe8/D2tYT/0cnYaO8CzgHaC8tX2v6xn6XaQPnxj2Wy8PKxUOBcrqTRZueMbBlgQwl0xGJWrnXm/4p721bHTnJXMQaSFQp1jRIQZcVETIJaAFotZaaHAhuEM3SZm9nHhcEskr4MU8Bg/GmShdnEWiAzCx4hoVvInHRYLuhpq8W3uiiBspW8PvnBfzUT/ceefUCSLyN9mem3wmKszSgKUPPMwbudn8aScg8JtKz/iPsatGphUxdouW+QJak/AhuDetubkbkddvHbGovBFeFsESce6T8+w0+eP3FMPCdO8pUH+43Ltq2zEs33IHmRb7beeNqM7Yi0siWNJ/IITlwurtKscSHC1u5OlA+4YO/HqJJFQmnkengyrdiDw4UoWJHhWSgKqW0YpvaQr0YAi7QcOdfvGvVgV1EkT/r1wBaSfVN/jOWjEhLIh5D9uq475P53js/8g8+LK6yia+pkw4vVFCoOBtKu9jH2Zpwq1dKRU+KEX9aLY544q/+ukhQdcZdCMgE+FHk3wnJEMEmIMN+8jQ8P9tC51wIU0E2eX4WTfCuONBLjHYvOf0aZApzzQ0aAI28vRoGpFg9UTEKy0rbHT+UvyGDAwwEf9Y2wAgDF3Q9RQpVRm7qX4NLPeMIkeYFKjlEa/jdv+SP2oSmLAYoF9Dvtq+8/yxlY3sAIIWB0C9yRsNKjTKENAi+Tc8Lqp639hsI5G3Z4EpphYLbic6z0nyJevHN8UOvlh9MLTh+hAHDl8lj11LO3jfpywgeSuTn9dMsmpzLGpCVJdX6JATYZ1BQaf0EdCyV9HRAWNYsM0CR6UZZCOAdgjPvFY2PIrwz264AwaUMjk++Fntm8jT2xtchweC5RnM65+Osh7dlmw24BGqxSoAcsqCvk5wS/XFV8iJRb85POQHb4yJ6AWuIwxdPSWbaW0dtzYySJZus0zQo16chtB8uiLJiASKu0aiCshkphj8jTDGyhykfdT0Yh/SwiFqBBkrzqhVbg6WTmU8JA6owXSL00ypW4ud9MiLBpo8ZIDqUbKgpmgSYgvHI+NcK/EACjNPowzRyRpqJ5RR/zUwht6bFtzl6Uksk2/HduHCEUBEICbnD1IyHGZsD+Vo15mjNDeJfC0RbaKVJgAmfX23olIIQjaX+UXmFt0fZAurZApRetMt2HrNQAy8aGSnf2GnfYNWw6Qp6BjwYcxGTG1+/5YKMV34yuImPLePAK+NOnT+Abo4EKVU3QQDx812MUd3owzBTFbEXeVn50XYkx0sOqwIo4p5Gw/tlXQuHVBcU0trLR6ZMZPWi8AJuEbeLWvMuNevYfbn+g59tK06ks8ZajgusyE5bW3a+4S6y7cjzDDmWhxyPZWbig/zOA06ddrSW+RdKoQeaNFHPb6DKXq4ZVXYwt044MevBlqN/sA05qrrZy7d/0UVmZu2wyJ95V9ZkBj0l7CrSDR8K9pi7mSQg3LR2Dag1kQFvNzhsUl+st8WpcVwbfOorY83TLiBhVFowKMrjW1+Yvt6mLUSmsqj34miX2Ldckc36iN9uzsPmtqgaN2vs3EqTnERg5GvRCULZFqFXfnEs3rwCuyYyYMFrrKa9Fy6Rpmd81qB/PgxTySg9vqOYc766E28Zagnjg+ESk2W0aNLz2XtxjHM8ZL8DocYjYUQJdyzHto/VXw+K3tLkEAxwzzX6vb/AALAML+4ct00BBRGf0CM/Rc3d4Nrio1jbm9stWDBilteH5XqkjpLFafw4GJ8l4VdZ6WHiAiBP5ApzsfUAnvEJ44Cd4MVqUq/FAYWYJwW9SNvH3VSMv5kYTggiSOl2mAEL86zUZOvMlNwFPJPjVfyacBSjsaXzJUBrDWhBAbFG4reSG+Qg9kaEsMKCHhgzxkWBKVoYr8g5/sOP/anzgwHC+10P9GFR4VIhIYJiRzkCnBhIabe3etCZRUddlrdgegLOYPE8y6f4/fwoP31ByPGs+XFExGkktbnsT+pHUUPPU2uZPaPaMBrTvYI7QTmtBV3fxA0vGTr96SxpxQgB82z5mbNCy89T4sX3vqb98r+nYssY9txBaQnSNJqz2ILqh3sStX4TRHFger2J+Z+YOXnpt6oYHXK3RmdumAPzzqcxfrTt8YTBjpuYwteezB3X8/x0h/vKp/XeGsRWsmtsno1eRz2RXZl8SA0ncspf79aTBBmErL82RhwUjXNSUPooTUzyrS8XV3UnzK/XyPmA3yq18hoizW0eWYb+hOtRwvaaCSL/ljUw1/cLPOiwQFCNU7N6fBYyaXgFMFWEKgB2ZmNuLcoT8HWNNPNfNtkeQv7MWc8qijXqXZXGbasafNp4Q7DwJAiKuQ9w+e3wQvLKkrb/qK5Y89/Kr8IS1UByfzXTv5xJcKGVBVgbGEpN4bPcrrhG1DACnxKoXAwEoZyAy7ILXAjpDGNExfP0Iibg3LZOXX7LYpwwvABXb7zjAGYO4fjHVvZEvInrDbCcbpS/QDpZSsDw2CuQl8FvROJhEoT7d4/t4sI4I5JiXLsJJZBXuP2FZzanOQwnHV4mC1W8ZOJkPEsS+0Om/WJOemKzUOWDFbD8ZYBrBXN9sBPZXPPW9ux2TJp4lWTnFyY5xSKXnpt6BAp0mJ2YXvZDEsSnO76LmveXb2nRVErDJ30D9YWpTgs+Dmn74KU+zpLcbDgrXFH0MOvT/ew/s00cGLSvNR3JI2WdCnbSb6uKGduY7KKu0bdhw6+6iHxz68jZWtxNkWLXrUorIU7jQzz36mJm/5TRXJ1ew9Bp6tRXsUBwVvpm9QJH77vH1G2YueIqJ15m6oP4rYDzkmatGrpcZX1dQN69fqN2HxEbfE6EBBN0BCpPNsD/F3Corg2D4H3uzDavGn/AgfKMGNktnv/DokUzHPoHyd0yz7CvemB8zIjHk9z1MEeC4/7J6A2Tn19+rSnhm6TpdPOS9NEqTlFR5C/NQmQ3D/6ewiYniBhfmgDDg+7VuYcHlHOV/F2qI1yrYyAN2DGZoE5IdNpq8iGY4J8tnCBzcu/5k6CN2bxiVsv5hFKzIN+y1ZV201aSAHGKAbzKQQjFnQslCSXNWQvjn8796EOvSACrw6l12cpUxAKHLd5y5kSvZmgBMx2TQ1ZtODWVI5TvaJqnqUazBa5eHT4R5I7W+WqzY4OkFHEJWu7H51fXAwmrhupFHy1LC3tTCTrB5ZlFP1ziOeVaqp8eVyLY7WBLWYk07BnDiUek8hNtqV3pQs/w9sBb60RPvF8hksw0+sCU6CTdzGNHCsMNkBXZRfTr1CpbPnurXIqcn8+DgxvAwDnKOJdbaLjLeUE9bHyGpO0AqVxuqOmzfpkWiZ9eH4d5TFUbQYYQmQa0aeKFhVRs1AHuOJnc9PiPL+p8AQ9KOaeoHiDcwuKjjcgDMhEiztF6k5s2iIU7GiqwLCPUMjQtQjsLr0Br3T3Mw7eY7Cb3J+TLIiPTYIjjLoHlD9vhoTjzqyp1dAjR88i1pcSTfpcrBGHkiBXIdYuwIGWReFscUmRIFn6mog09hlRxrW8mP77uXqQ+AxN0/Z43u/qkhLz1/5NM77q7krmBL2LRPMilJRVxBo6zmEHGAfbkK6rF3pD2qJKAsKhoS1otIiRn+bHRr/cYsGIQBBwMLRwXC/M2nWFZXfxbeBLCzfrMl3kQEAk5ju5jb7sqYbJOal1UHPccpXOqVNgR1/HmMeYQL6Ec8lMiFuXrTioIGQPs927qlFWm06zSBkTc1fXQFh6LWm2qFkqDkjs2+lWiUoRPTl5pa7ovIpUgd1/gyLlQBWfEr6X0YLrrCZGo6OSQs5pMUoBHo70Wz3ZJcJkj3hWg51UL4R69Hbuk+2pgXGWvmR0PBXjOyY1/5kqlayApWytCgg69aM7IzQQdG6SdoEHTxZKUwKW9MyEyO2iZ/4raPgHdCS644GyDw54BT4gtO3rKAfPOwFmSTUr/NMBKg1rNoLcbn2jSnVB4CmK+u/pQWcLTAx4oq6VamWUjXi36RQBEPD2pxarnEbnyQaRzjflBx+JJ1IUkiE17u7j92prr7aFWHU9L95DGLSXPf1IrAXG0SEaWY2ZZK78EjYYNYH8dQi7zTrmnYIq6adXHksODITt1absYL0TO5JEbatEQwZM9NLCB9AgmpRkRi/R/XUfv+dKj0E4w2wJYghU9oHbWrNhi3HwoNNzUivmIR9DA2IWzEMqlzqY+PNdnuidZK37JXGL2URLUach+RwFtEF2SfXCDwR0TUAM8tP6iPm/t+DGoQIxVUl1eIbE6T/rUlUzKAxQ6kKGomwDXD57BnHLC8PVPnI1NM+4bxNzL3tPxP/LQ4mlgVG3cEuLH8tazluLSRi4h6JdT/LPpPm5LMAng7TQ/1ahNTVPJMGD1KgwUuzibE8XZms+/2ucgBEEG+TCFwv9Q04B0B1EZVWgL6Khw+ZOLVgVONhthwyNVvhPO5FJEky75oAnhnLrvzayRvc97ha3DscZQsIymlJXOINQO+6KSqYroajcXTpvWLIFYB0E9VZgQUOUFp8FsCIv2DEIcyh0gAZJUfWQJ0MX7lIkFYkYyj2bdULAbmyVmNSn6LD9h8MZPKtG9dh8Ts6RpbrN6se6wmiH6YByjnkznXq1l/j3xUKqsJCTbtGEP8gtNBjOJOtmgcZcGSd8bB+zr1dEgvWfJD0hhHHp8vO4EUK/pwlN9aip+SG6gmGCf6DRM8KMXtzKICKWEkvNHRuZEBmm3sgUitmyJfU5lZo80mV61jLU2gJKs5Q6gFPvksGf7GxwRexqxKWB0j4SW7GVmcIV+crRzrX3kWyUBh61gTze4JhI5cLciOsB+dHMusS6070yCAYzu0UrIMfOpQLxn1wEc265TpcSq2R/p290ML63udv/++TF2VUpOMg8YIVMvPyaUXAEfNsxHkSFqCea+AUln0KAqlE+N7J+ssNbhpe47ofoGP78NjH9dcxwtw9v7TDxaCiGwaoOy1IrWXNqhiyL9sTNmq7hOdk4CWQckAMelVWOof8Cgyn9uon/wNLvMda5iZTAnHftxxON6Gnld5nynj5yEdCpmIiWOc26CPRHxxu//qqoBib0PUu18dNsbzKy0HTf6Cnhtdl1EtV8qnuABG+8Prwf9TG3JRvRYuqeO6GETIYOM4kzyLKfj9S7gAYoCiX5rjD4y6jpPagNDZfvaarP/EaHIm+NAcDKSxiQ+sVPRV1Ka9Wen/J64BV8nu1CmB+E03mIY944OPx3HxVj1FEdVRC2uymahwYa3ibRckTkyYtGa09oTrEt6nN3s+gS2WkNc72FxJb/PJZ95tIS8Z0aLZpF1brv6iyuGjczi6e+aGCWumNNdF+FkJ1wtQ3WgIuTGBGN+cS0VkGUr/6g6avtdx4O1qLs466CMuThvZFQTE4lZD9B5Cs/GCH5vXNtHL7jL4uLze9lFKMuMtytsBrhMre12gqRSe209owbH/68mXg+qtGQrN6kMSOw4NtQevh+f3qyj+qZ46BXg2Ig+j1vaGJpE2ceKDXSIbvKN2beK8dZFHCRgSZq7DaW42y12BbX776xtWGVSSGtGCI9lSy1WX+FWFJGwLq3cE54kDd00MOCnjRDWsianksTmIFF4Ldkmk8dKsXYaD/1QDl5qa19b8jU8HuwfIAfq/72BzkidAJXpdPphXowZXApLDA/CNjhcgkH028u7NCqrix5UYwKsYpdd8weNgN8qgRpRKbxy+PyqWv5OZsXvlaxPF16BtePsgpCbgodRHsbd4ARRe/p8dhDCtIz06nRvopY7C8ExcOsRo8xE2euuyDkTVWL1OtZtFoxjQmMDxeXQen0dtakgnFW5xijRH6XcmHI9bPpAFHZiYj/Y4D6HxBicxs6nPDraOrVyIpQFWgS4K2MLAGVkTEQDqzP+ORhNYOYzre/wxkxAkM09Rk2apZskhM1OXgrlmot7SWXjrk7KAgGu2r/1fK6KRcAPsjOairtvwi4OjfK+Bo9wpmCtNghXQTZzefiDf0sqgtpvxrV4ksYnbNUyNH45VzikNJGj/fUBOmvj8UOztyG40kKApsXDfOboc+KETO+GUz6MgFYdKv5MjyjB/Z+rSXO1vISenD3dM/7nAl1/zLT/HnbJwqF+CkqYIXhoHhxKR/hO2gsmTJ71v9AZH45v2qNxsocVmY12YUmjzb+nmkoST0RTR2pUpC/31BQcqvziUW+7SF/Wysgn5rQaYH5d/ESnjna+6Sj+k0FbeWxowr5E/kDCMKi8qZzi8eHnlsO1UWhq95PicsxuW8xrov93RgiW2luAtV8xeDQQ4edfxtACYiVeS99flc+7fof2uhO3iGxgeFM6inqGggpY2hjn0dIvmuGa8keXOgBUI78Gk38WCHf2wKPNt3uJwFZsI+OX6ogq2KfoAxRme3wnj2c4Uk2bQsoAni+m0ORDPX3BBWBLp2PmKrSiKC+WoL48Ec70ipz0yKBf/E2seEmRvbf65ddIv12DlramxK5c1jNAqMKcGqd7SlKHMCPI1gcL8qDTWed28VjMKSRkAidOPMCSEngh7pRxa5C530EFvTkasFRc7BMHCT2psI501YMfzmlRvVj6tNaK/mVj61PipftqwwEBvShRawQ5Rjc9jYJnCIR2KAWHjGZcgxCnJ1+3Xv3k/iheXyP/y0jidKxJVV43IR7VaCzHxWQYvwGm7BS239UPGHuVEdQWqKYYOKdGbsz6BEPkLQtpSmLkC/WEL3mCQLH5Cyj6RJfBjva/oTmDDh2rVj+DvYwBw6ylMuH+xGBFVX9S6Ya8oed6qp8uTV+W22PzbhJsvLjepc+ZLNTr+PNvhw3HUtxNYLUNvuHLM3iz2w9Upba7bQqs5v/W1b23foOxKzNoQC/iuVv/bKAQ+5iqGUbehEJWNoBibVDdvJE10cFjJbXLCW7cysu7+zeNOlvV5GN7ImXWrsU0Ctmo3lwiWw40FF9vpUTBoieMeZ1WEHsUIVt0HdmQ18OZafIwbVDNVCwT95s/QV+xTabm0Xo9/nNILVO15noH99Pai+Db4KmhVNAFrUBz2OJ5ViXDC2kxbobP6Rf2x7lMXlNqNZ/6oq47PZPNS/cHkU4Nj6LGNLIU3Us0FRwxwTKs6fgPN+OllZDkYjqYRzjLeVYJXwrv4+v2QZmawDbAzzh6ZHM5iS7+657FY/HhzzqPSWZ0Mdlj9MHAJIv3iRPA/+uqTyyR6BVfHnLV3FKqn+1uTI9htgYJJnm1i9PqDW+q6RCWczqtgdweRHx+riUrngdWB8KaaxKjHtSc7f8V9RWKwLH5hY2al4XHgmCslVDNd2BTobfbgzx6KM/OSZMlVkHLRxDD2RV9zLBMkeClHrRVnBnM7ElNndl7oVC7/AX2YycDprMt5gmMhDpss4Zkclhie39FhagvkhFEelVjNUp+ISKq94psGrEUpP51EWK7JfLzEe+130jK2RSJ+up1Q8i/coSXM3lINju/ilLD9gtLYl3gk2naP0rrAbqnnOvUoNaJD8dV7G5JaerOE+c/D9CgJZcWYS1g7ZXUm6kmqwOYWu249gVpFRWaDGrHCcTTG73uygxWh3jP3wbdjfpcEEBOtVmOCRJ2i14A9J7WkwOLN86kAsllNVF1HEXGokpD9F12U4X2FZeJssDatEprXE7Uao+V/HeRfx6Y/BRDJM41O0HNEwlVQARGAXGIZIotWvPbheOhD7TSaDKC1fpIy8Uks3okYxdH7DwGviBhqwolEW15Y/7qgbhvX9Ch62QWrQHz7SUBzPFi/Qyd2D5qXLTOPsjd8fmKiZzSi/pyBPraANBrQEn4+dGJPY7RjUnAeA30uyTis2F64Ct83qbkG/yZRlL9pLwNOU5vPfAEt26TLxn5QCaUbrmh7+ZTyiGBnTlCHt7OuMoTegm1B1h9VHLtM7kWsRNh+MV2f/qScHF5iZxpKzbE7DQpUU4U8q6BHBgTP5lw/7yPkfvhXTHdAJbPz4AWV7VGNupU5cDykcSGGf31XIY3DWvAyj2pVf2sR7N06Kz4OpfH/8BJA/FtobO+u56CzWeuWrwpf+sPQ0kOKRaKIAzUmD72kwRvErkQe1Y7QIZkYzgopOotebNbfqe45DTEnkopcqgrXmC7BDxKGMOCaHGlrJrZnMiWxLwlwGGI21pBd2C7D6ngSBpu46AtJ1fixzKQ0XIYpyjwTsXKad9Q88ma/OigmiShdZ4LLNYl1hsJGzyEgYZkc6Ze1CD0gNdHMnh979Yj7I3fnnogkh4dx1TTG1SXmc9KA3tR8oie0Z7b+kgDEEoCIgkIx+Yap69FMQ48ZsicJrD75OhFv/yc2DFA88JOsK1Pwem1Oeo4A6ttNGACzf/tzQicJfo3rTU7QcSjihS9NTiS7eqJGGpfTN+/3DlVwBTc9oYThwd7aI3SxCsVegSZonIweMmBpzdVC3mw1snL9IlbxQtYGHfXK3o64NX+VZsJ/PcW4gfcs88+yaTmJ0c68OPQ+Dn8jm1VNsjp7kRMaYe94DpOwMtbnCeAOpn66darsmQCerxyB6tKqzcmzBAO78qSlxdAKthPLeQDAZ9qrUKAXsIvSU6WH3mqX97tO0GASVSIC0iaN1IttcVkHzXf/0xcuwyu0hGFEGYsuA+cHIH9Lv+nX0gelREI4Y8kFl0lV34ZLQ0bv95ODSZM6nup1wbTkKEFfaLjQ7YCWCd4cd8kU2ghsXpPrjfQGu+Zwb8Y1J1/+Bj9iiKsmpQ8v5it4pGM+9uVF1nWCov04vhx2se+cMCtN+72do3nQxfHUCSYu9XCzCQx4pXzBl/ESl6vwXOwJR1zF31atXOy3/spudHDkRLeUK7eGK1MEYlzYF7d2srcZtyZWZbcpxgLxxWvKRs9EUguf/yxC6b6aW3fY7mnO9EqNSV6uFeyJdTC0G9K2pl1G2owTZbsI7kZp+FqoUr4NdKu9DQM+6NubX6DeFct9dX36b7vLuKEx89vURi2N8U7+Ce6aEIyV7AFjx0D1lReN2YlSSVb8Ema68BTrV0aNP9VBFW6bzXBM3Yo8sCt5hHvqYvQXky4zLJFloSn81D+AHEw7yiM0EG8gi6kYHYAHqkzikz7baFTiNjv+nQfXs8jjpD6Nm7CRXpOo8Hkfnhch/0NQ8d169EyLMDaW/575gwJr4CftcBM2vXxjXz5SNmqKcd713pp409F5nbYLyW1dbqK/9PJ1hC75AViA42sRSwuVLXyTKadkB93QhLAVo3xlmFTd5mC5t7njbc9mKtHv7H1l0Pt84+XUJYHk1DlabH7lr894LGi2T2WRAks/JqGUs4YWjGBX6TfenjtXmKJqu2CBOWhbS3/uY2+Z8ZeVSppXe7FF4z4hr2FNF+WZRiri28mdULUNfIk0hNjj+yrhDsdyI1rNgi+V9UKZxXVj3h8E57ynbXUVIjwUH8yKi9wNRrNsa7hbXWmLqqyKF+3/kwfnO7ZdASgEVzwrNr8lbEyzMWa4d/DsIj228rGWzDY8+RvA8A6gZnTL/zTb5Zzt+ATmJe2NITcES/O7MfmJ1fO8YhNdpcpK1yfX4EAUnig030oEwRfe2bOSpSOsr8EADX5VE9Il4cREjStiHJYYb+mLlM86rUQStRnUmtVGY95ggcPlUkM0lnhZsIJKey3z5yYewK6kqI1MHi6BXiLT5zA14OvBlTEspjubK3TgNR8lthnXNjyxn6vFpoZfHtQ2i2X4YoqRWJkm3mY8c5ThecrrCs/XzkcKBbDu0dVs+JyXpxLv5apScf736pfge4hGoQhZwRaqHh8xz0CoNmsoWpzgaIBpwRJ3Zzo4vPdk7KZ36w2opT/tQwMFdyt//dcptm3//h76L5zIeRDsgkDPsVXqICjC69XHPN5PmTcEYBZbZSKHh3Wzbp4KXJytcgQHhIXYggrmCcuuzMOl29J2dKeofMo8lMMstpZdcWjNxU4S2eTyljkxqaeSUltHkCFsltGUUByMvqXb6eohpdIqRx6IdhRns89CTPYBrstk6LbobKKQMOdWE01nEN6vfpmgvGlRCBv9B4FbZS5n7uvNou0gq5fVQnOQSy4gI0CXvp5mzQsxrm3l8BbQiyMmNLQyk1Ili9MUUtGIo1nIEc0zypYzjN2qRuSyPFKPU06TLeBfbKIh5YDk9GpkWskASMZJjIm5TnwlCcMIgfOdx0npvJzdjul3jvoSDvIMJabKfcZL3Gj90TsnDDIA5Sm6vNwlAHEglWyE8PSlM2fdoSd2J0t2OO8JWV1sxWfe3hAAvYp6YmB3Pb5GiY+ETbvYiwywMqLD+zCTB0t1o4Qz6h1PYzPOHAVNa2ftAkMHWYDpH6V8B1pbHdpYSJkJzwcCNJdaqwExRL3BJzs2bX9j5aYS0a5cC3Q90ayBrpdkVzye58WdsxavvZQInWwULxb9nHwP6abJROrzcewcGB0V5cFzIJOtm0YWQfouJkwiO3FzVGnLgMfeYIV3x4CBuTrSPYYKUjIIBY2TUQ7UgyiqyLzQ7FcG3ud7qZvPUcJuId2aPwz7IPUnpb/t+yYiWyMliNjxs2bHVCamVOVJNWWLdvh3B/QaSnCblBVsZKZNHrAmKe3BKrjsYfzv4JisW5obRwVgrSU/G1LcEcEVTwA+ABMqZqHj+ZKELkl+WNSHMV16/qawt30/CBYct5SAAZQPEpY7k2cYbdFY60GsDXs1HJVuip6oa2mNaJ8k23BD5yYdg51wlsmuK33luDTNPoYYWAK/lRcUrajkK4HGOxGoBScktCjo7ueKA1XkeIiIqMjWlF6TUGh3IdfHN4G2oodRFnYmOZbfDg3nHwltQ0XjMzfc5TONc9q0k2s0KwOof0Xhdvkuw/LkjYCKfIMexetkToPgporIBw1Vf4KR0vOQf1SucbvoALXJ3+2ANLdk/WVu7pAf/DQHXz40sAGQKn8oDRWvvm1C9kmwsvRv56ralzsHyzFiTVIesO2JAefJp3lgwHVAriKd4myLYFYcXjaW2JQAC/VgGrhmKAk6CcVQZiPFvDQGmQ9bYfxGBIPT2bzel2/+79gssHLEhwuLnsJq6jGDT2HzyvnaFYzq8O7GOK4TTu7rtWyDfcg0lmFof/8ryfIFdMgSli1kEd/0efmaWHzGUGpivLT+Le26Zxii4UvhwVYaO8bbmp9eAGoyEPVUmzQHRnrGmbeS8bc6pkTBEk+risg6/9RJ1Svd6IyF0Ep0Ji+DzIvRcmH4ntznt0Rm4MtqrEec5b6FSvZSyk6rU9RiYuIYyRizxAJTUSmWgZD1tVaDB3BwPBE0illGl2eqi4fP219/E25VVh4yl8zhXYdmpkBKHK2F6GPU4ebI1iHb2rY7yYJ4ATS0pKtUyRHK2DRTrRNovfB5mJpyMTp0KPMoz79+vhrFvmX2dDVRFzqX6FFHeLpgYyC2TXThuU8rYFpa5TP8UmjPskAN7gwjY9qV7t8QWMoFLGw71ub+XsqtKMiRkxrHlKfhO7ZD9i1ZlVei94cOc4aep5NSRMiUce4kk3S3VcwAciagOOfLx7Ohiv5y563ya/fHYOzuB/gI/XSguSotQP2da/FlNDUQFk1NpjN5lBe/MDkZQeputiJV1IC1ST4IlacOmHSduoAcvBiQL4a2khdJfXeOi/iCbJKGFwoCX/72snG75WstRSsETuqbbSqZAnv5cRBz9j/6qwpJldXqryBAtEmfnA1/5d076uQj0mntGbRsS83FD4Zp5ZRYhf9xcaI2K20VtIaElnXDuvQMWkIa/rX/SUt8/gC6ANdPOfPsi5FJtpmhKFjQN0cx8J5O3YhpLjzmQyQH7RG5k7f63xebwsvsccld+O/XpTMeUr7gFElrqwkXsRIayQnRCd6b+1rxYOUepHgx9BXhvvaEstz8kkram4x9TqxWHRenkKijrWkss+syZP0/1iTmdBRiyJPTTPoogQsPdMKMVbFK8pzUdrSvxYD4U9qIUKZ7cxWUPm4Dsu6trWNadivnj1aKnxbPTlJ9lsmYxIzwL/83RqUD5LTZIZuJ7t8jNmhHaed+H4acXx/PUIU/lahyUDfhp2Dt1xd2jlbSYniOtPP57ioDCLKjsOLuPi8UobLmdEC0Rj2DIsUlE3HdiBXcnyRCaLn6G7239JPAvmhMI876mnu9kVBQEjHzQ7rNom8lsVZuMOCEqCPF/CT5aUsYeM3/Pw6ylBDVrQrkFt2q/pDROxlLHFBiRm7ZiNqaKMQU792UV1U304c9/z+o3S/3nv2ZX+FL1FNhJ8eIro88TJ2BICBahil0kzyULuo/z/NMNmqxFl8w63rhfqU46x/MCj2MUsZypDZArgWHMh8vkDlNXQy95WjHtXZTNzAUFvUCQIvfx75HxT/iKfdP+ZVRA0GYCXze2jpF+ZrwYUOTo7C2jIhhb9XT2ZYXZBRidoCPLymkWfEQ93iZsKP1teFFywyfJlOft65CtW5QhwrDNy+NYAvaBmbfzFTMMqNrWY94vGOTE92VJ96klNfiiMQa35IvaMTd9zDI27fzyI89dMhMuxJioV0F07rAhoYLLrjVoi4eWQxJHV9rQ2n7P9lYH7cXr+3N/pIl/azS27gSZzLQdqYYeJxIlA9B8v8qzn+tuDg9t6O2Gp7+rx4B8p3MsuQSEDY+34ZjZLy264X7ewwm/qwJ+ZIJDjNAiBDhrgPC9iH7R8TGcMYtrOLzy3vHLVDTCl5I5Nxe/DoyqfGFWJlIqzytbMb7qHX5dsA2hl8fNMwj7nAveSBJqrxorzNz6I5Kcu+Fs+982PfiPEWRoFviB3pzIB/eccRBsaZuhGC6xVvUZS6nMjs7uLzzjAsML+ZIjWo+pSxEOfvKAOyRGohyUo2/SYUer9/h1TbCBrjp098EC0yebwvWgPKZuUOlDOYTupo6rjUwICBlATlHllhR4iQnHYffAt/d62r9jBGrZWU6U698rmGzvW5127+RRiyP1kUSQKM17J7eeay900E6RfuMRB8ZQ3RVx8M/d1OS43nO/tY2yz/JiWCRi+FmRNpkrbdF+ZQCmJadIVT2GfBdtHDr2BtwvsQH6hhgIl6L9v9wJdH2p5Kx31DEgKC0jzYZ2gyJzRhXGdiq5fFGADtbWR6lWb1h+O78Zy5lB/ev29D9Fz+n6y+NZhuenGVj89jJF/NlEKKVcNeyrCq+2Hq7L/1H2ao9Eqp2+Mcd55zoua9dsWlZQC+B9X/TuGBhf/osZ8Fpw5cVYAT5Sx9ieyHvP5GFAaV/qedIl7rQh5KWMoZtHnryWdYhbefGjiBl0JpoJzbZZfPXTe+eQWcukb1EnNj6xRN5gJC7zRCouwgS9Mun+eHqwFi87ZRLYJCnSQczqr50fztZfJg40DpYNjfgIs0/rA/O8Xc3smu0F2roM3sVvzILIBeaGKRvqvpg4a7XPHe3oXxRty38ZeN2gxGr1jqul48jPKhx9FAmta0plt3FgDH1u5yP4QbsE0exWqtdyHo7NH1HGlb420Rz600qkPquMUm3Mm/bjiY52Hmtyy7BVU0bGMRDzDPBtBzo5fioS+SOCfsn00O75vR5lnFUTrT3Ke9B5j7b41sTss9hUQmahE50d9x1PZJKGdSEnnxqjPsrlNGNrsIDdmTDqfK+apwV59CpJVdUv0j+iDudGcP/2pFrWS+NzWcfFs1/nzz/e2sUqRoC8zPl0AbQC2HdRbLh2wMZWn5FC10YPEZLBbn90Pqh+lRWLrKgoXJfXr5jmkYxQKMiS8+6Dm1LjeCSj8mo1Wio1+Z1x0fNdkE2JIis0iebR2+lYFTs8D57NVFDZrxD8tgCyhP23wRnj7M6yHlu6bKcqStPWT8Vn0m7wJ9ciH+egfiJv+kCWGSQ+Yv2jaV8mXLUuIZxiJf8CTi1lzFXaHqgY4DHn1VhMYSNKxCRXfh2khu83gj5BArc3qDvWhRzxPJHbq3E/rZToEMDqkcZyqY53/mDkMyYWONdoFMPTd6UdNZzSAv6F8FN1Paj93/TEzLAINT4ck5jQ/jPMt4Ip1bAeWPGdWcuw8MPvICnx9v3KCLCpphQsSFnBqmsCUPrGll9xltSGBPhyMX9C0ZYcfw/kpHfnIeR2pnBSfIqSNlH+Pj1fi8p1+KYCOlsK7yDSh7PVYWQbpbWJi6xC86oW0xLlbMPHEGNQii3p6AKp0UtZaSZPylBIa7dYDqI3AfloRABOkAcWLaELbtRxok7LGDVRn24SaI705pXxYBE4R3gtl3nus7udHyIYUMVOaqawXxwlgLhoZCZ9GSdGMX2XJVMvIh1X6uO6mYSzfitdPWvIzziGBS1XFKn8b9f83BuHmphIDECE2MmrWn1dUv4AlwRmAYwXW5HkjGZ1kadqJNH+UKKGbfVV0lVAXoV10TTmSFQ04bmY1lxqUvwV726qKKgaNAUndK0FJbjr3OqL0FtqEbBW15PeakHDt6iFq9PN021QAOV6ktykgfJvWN426Vjs8YiHjdbi+xbtKuiA+YNSrhf/W2hsVsFBzbI8qLEFdrZWgQ5qcDz68bLlMdiRlDDm8e1ZuJUOd79/FMTNY7Plx+DILKWCQ/mBSXO9BcI9VbX5EmY8aEoa0UtJB+M4hdq9W7jYEXSkFl5GRUMaHlsfnuy9rWMYilSIeMFGkgydSjfTq8XW/DzBiSIoY8kinxpEmJC0kpSfanYdB2pdVIk+mSYA0+K07ipXIIOW1+X6mBT0ky7K12zn6mvEvJQvtJGDSmICpNztjvNH7tZrMM2UCkr87CT4jID/C1mtyDw1HU0mJnVfYPBz1M8h+h8aql5057tI0bgokpNckiRdwi6FUdfOAJ7ahCZkM+RxfuWyo+63cIEXOIoZxm3jeR5DBY8jzDft2YpzzBe1RACk3UhUUBM8BFeYYnwF/i3ElXyeAErrYL3M7/0LcOH9Axs+0cdwUijWSBtyRPLU/fOUx+dOObFjPqEKWVHMBhTfo0y18jtip6a+iUJsnbB+o43C3YB30BNwrpkws20zhHFn94RwIh9xDlWpagt4gt9eAqERLmKbr5ZwAFiJxDigmmg/SyntuUhZiwMick0ky8SGaBHxmXiD6qkjcviIBXJInq0YblhMHMdV6i4RX40bXmFlZvyJfHLPyxVwJUclAqGmUXfJ2INefj0Ww7tCUoF6adWQI52r0CQwwnhNQ/43OQrQR3zKRUOPzW/OW5wfAnZg3bxGlmAQPvmMt4CHYyJMINVUB1RKZzBCL6+NPqtIlvT8VvswmaekBdwI+YuTpJnA6u/1zHmG8F1Gk+QnR+UZwisI6ahf+IF31Iglvt4FnFd8Im7vCmU2PDKtFnW2dysEg/4X9IeygvbldwqkYkVsA88GfqCRP0vP2M+7rpPD3Nec07WRCdQ/D5nroUzBKdJuCTXJgoWKzOdigPPq1TFTRz5lPPP5uWjEevACy46tgLndUn9UitbP2K0PeyeI1Ng0OmgyIm542+lvX4TlFXgZ9DThLwy2I1zVTYLAUYEUVIPnYJ+R9ZRqT6YeuvBJDGWbNYwblZT7/BlKPaobEPI7sy35ZgGsT8p+ZfgP0ttMYMVAgv1rIapbjaIQSYqPuo1TotDfWoJ8Icz8sOfJJAyuuJqPjixk7dqFuw9Cjbo6BgM03XxEbMLN0DQqED6qRQnS+wtHp97zFRzEV6FvpeqUgtKBmw78NmR5YF4V273DEMXS9ipXK3AeAB7NGlarFzIwWwhcn21I0hF7IaQ2OCRliMpMLKgSF6h0dpfjfwmvQwvAz1JNldh3M94FByWyA2CmkeyEEzy/9WElk3HeheCF+MyftbAXJhmxUnYCOXKO+7jCMQ4G4l1EgxqhFn93hA8eyMXWYTbxdCCGgzLACo5I/tuYfsfKj39ss9fdVqAxxBzjrw47QT0uidLgBWwWIj+fy689L8ypdXIKMzCiwDGZ31Hy10MWMJSSXqsN+NrArla8gS2q7CQcE3rM5iwnpFHA6A1AqMlLpEalJRjJbdywyHvTzIMKbX2voA8uWg46r+M0wOs4F7mNo+Jq/1/7KhPXHGMqL0eU1zVMmOBY2ldi62s1wVYXCGRvR52q0Gme5N3nvaFiwBE46dFbhehM2P0x2zxRBnKZnGsiYFnDTo2S3EoOGvaFGSt/N2qE7Vmit4QcCYrnFQBZw1vXF5jn0wbJj6TRgBmlT3+YsUBbB1jEByIOWYXeF4T2q14WYwadVqTxpjVh7lJNS5u0A==","profile_content":"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","other_party_extra_data_content":null,"extra_data_content":null,"wrapped_receipt_key":"UqAI7cCcSFZ3NHWqEoXW3YfCXMxmvUBeN+JC2mQ/EVFvCjJ1DUVSzDP87bKtbZqKLqkj8oD0rQvMkS7VcYrUZ8aW6cTh+anX11LJLrP3ZYjr5QRQc5RHkOa+c3cFJV8ZwXzwJPkZny3BlHpEuAUhjcxywAcOPX4PULzO4zPrrkWq0cOtASVRqT+6CpR03RItL3yEY0CFa3RoYgrfkMsE8f8glft0GVVleVs85bAhiPmkfNQY0YZ/Ba12Ofph/S+4qB8ydfk96gpp+amb/Wfbd4gvs2DUCVpHu7U+937JEcEi6NJ08A5ufuWXoBxVKwVN1Tz7PNYDeSLhko77AIrJhg==","policy_uri":"lNVPUiMEAf9oUBc56Tn_mZcbp4eOyXOd6mPTO_uYe8kKtZEgQFRekJrparpy8WHR","personal_key":"t7es00YGJZgU2Wxoo3OqcJAdI8BSgKA134G1NGBK5xY=","remember_me_id":"Hig2yAT79cWvseSuXcIuCLa5lNkAPy70rxetUaeHlTJGmiwc/g1MWdYWYrexWvPU","parent_remember_me_id":"f5RjVQMyoKOvO/hkv43Ik+t6d6mGfP2tdrNijH4k4qafTG0FSNUgQIvd2Z3Nx1j8","sharing_outcome":"SUCCESS","timestamp":"2016-07-19T08:55:38Z"}} \ No newline at end of file +{ + "session_data": "i79CctmY-22ad195c-d166-49a2-af16-8f356788c9dd", + "receipt": { + "receipt_id": "9HNJDX5bEIN5TqBm0OGzVIc1LaAmbzfx6eIrwNdwpHvKeQmgPujyogC+r7hJCVPl", + "other_party_profile_content": "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", + "profile_content": "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", + "other_party_extra_data_content": null, + "extra_data_content": "CmMIBhJfChFzb21lSXNzdWFuY2VUb2tlbhJKChgyMDE5LTEwLTE1VDIyOjA0OjA1LjEyM1oSEwoRY29tLnRoaXJkcGFydHkuaWQSGQoXY29tLnRoaXJkcGFydHkub3RoZXJfaWQ=", + "wrapped_receipt_key": "UqAI7cCcSFZ3NHWqEoXW3YfCXMxmvUBeN+JC2mQ/EVFvCjJ1DUVSzDP87bKtbZqKLqkj8oD0rQvMkS7VcYrUZ8aW6cTh+anX11LJLrP3ZYjr5QRQc5RHkOa+c3cFJV8ZwXzwJPkZny3BlHpEuAUhjcxywAcOPX4PULzO4zPrrkWq0cOtASVRqT+6CpR03RItL3yEY0CFa3RoYgrfkMsE8f8glft0GVVleVs85bAhiPmkfNQY0YZ/Ba12Ofph/S+4qB8ydfk96gpp+amb/Wfbd4gvs2DUCVpHu7U+937JEcEi6NJ08A5ufuWXoBxVKwVN1Tz7PNYDeSLhko77AIrJhg==", + "policy_uri": "lNVPUiMEAf9oUBc56Tn_mZcbp4eOyXOd6mPTO_uYe8kKtZEgQFRekJrparpy8WHR", + "personal_key": "t7es00YGJZgU2Wxoo3OqcJAdI8BSgKA134G1NGBK5xY=", + "remember_me_id": "Hig2yAT79cWvseSuXcIuCLa5lNkAPy70rxetUaeHlTJGmiwc/g1MWdYWYrexWvPU", + "parent_remember_me_id": "f5RjVQMyoKOvO/hkv43Ik+t6d6mGfP2tdrNijH4k4qafTG0FSNUgQIvd2Z3Nx1j8", + "sharing_outcome": "SUCCESS", + "timestamp": "2016-07-19T08:55:38Z" + } +} \ No newline at end of file diff --git a/tests/yoti_common/data.entry.converter.spec.js b/tests/yoti_common/data.entry.converter.spec.js new file mode 100644 index 00000000..59932ea3 --- /dev/null +++ b/tests/yoti_common/data.entry.converter.spec.js @@ -0,0 +1,27 @@ +'use strict'; + +const protoRoot = require('../../src/proto-root'); +const DataEntryConverter = require('../../src/yoti_common/data.entry.converter'); + +const protoInst = protoRoot.initializeProtoBufObjects(); + +describe('DataEntryConverter', () => { + describe('#convertValue', () => { + it('should return undefined if no value supplied', () => { + const dataEntryProto = protoInst.builder.sharepubapi_v1.DataEntry.encode({ + type: 6, + }); + + const dataEntry = DataEntryConverter.convertValue(dataEntryProto.type, dataEntryProto.value); + + expect(dataEntry).toBe(undefined); + }); + + it('should return undefined if unknown type', () => { + const dataEntry = DataEntryConverter.convertValue(-1, 'someValue'); + + expect(dataEntry).toBe(undefined); + }); + }); +}); + diff --git a/tests/yoti_common/extra.data.converter.spec.js b/tests/yoti_common/extra.data.converter.spec.js new file mode 100644 index 00000000..d4629708 --- /dev/null +++ b/tests/yoti_common/extra.data.converter.spec.js @@ -0,0 +1,40 @@ +'use strict'; + +const fs = require('fs'); +const ExtraDataConverter = require('../../src/yoti_common/extra.data.converter'); +const ExtraData = require('../../src/profile_service/extra.data'); +const { YotiDate } = require('../../src/data_type/date'); + +const sampleExtraData = fs.readFileSync('./tests/sample-data/fixtures/extra_data/valid_extra_data.txt', 'utf8'); + +describe('ExtraDataConverter', () => { + describe('#convertExtraData', () => { + it('should parse valid extra data', () => { + const extraData = ExtraDataConverter.convertExtraData(sampleExtraData); + + expect(extraData).not.toBe(undefined); + expect(extraData).toBeInstanceOf(ExtraData); + + const attributeIssuanceDetails = extraData.getAttributeIssuanceDetails(); + + expect(attributeIssuanceDetails).not.toBe(undefined); + expect(attributeIssuanceDetails.getToken()).toEqual('someIssuanceToken'); + expect(attributeIssuanceDetails.getExpiryDate()).toBeInstanceOf(YotiDate); + expect(attributeIssuanceDetails.getIssuingAttributes().length).toEqual(2); + expect(attributeIssuanceDetails.getIssuingAttributes()[0]).toEqual('com.thirdparty.id'); + expect(attributeIssuanceDetails.getIssuingAttributes()[1]).toEqual('com.thirdparty.other_id'); + + // TODO: Requires 3.7.3 Fix + // expect(attributeIssuanceDetails.getExpiryDate() + // .getMicrosecondTimestamp()).toBe('2019-10-15T22:04:05.123000Z'); + }); + + it('should return an instance of ExtraData even when failing to parse', () => { + const extraData = ExtraDataConverter.convertExtraData(Buffer.from('someRandomData', 'utf-8')); + + expect(extraData).toBeInstanceOf(ExtraData); + expect(extraData.getAttributeIssuanceDetails()).toBe(undefined); + }); + }); +}); + diff --git a/tests/yoti_common/third.party.attribute.converter.spec.js b/tests/yoti_common/third.party.attribute.converter.spec.js new file mode 100644 index 00000000..6138590f --- /dev/null +++ b/tests/yoti_common/third.party.attribute.converter.spec.js @@ -0,0 +1,102 @@ +'use strict'; + +const fs = require('fs'); +const protoRoot = require('../../src/proto-root'); +const ThirdPartyAttributeConverter = require('../../src/yoti_common/third.party.attribute.converter'); +const AttributeIssuanceDetails = require('../../src/data_type/attribute.issuance.details'); + +const protoInst = protoRoot.initializeProtoBufObjects(); +const sampleThirdPartyAttribute = fs.readFileSync('./tests/sample-data/fixtures/extra_data/valid_third_party_attribute.txt', 'utf8'); + +function createTestThirdPartyAttribute(token, issuingAttributes) { + return protoInst.builder.sharepubapi_v1.ThirdPartyAttribute.encode({ + issuanceToken: token ? Buffer.from(token, 'utf-8') : undefined, + issuingAttributes, + }); +} + +describe('ThirdPartyAttributeConverter', () => { + describe('#convertThirdPartyAttribute', () => { + it('should parse valid third party attribute', () => { + const thirdPartyAttribute = ThirdPartyAttributeConverter + .convertThirdPartyAttribute(sampleThirdPartyAttribute); + + expect(thirdPartyAttribute).toBeInstanceOf(AttributeIssuanceDetails); + expect(thirdPartyAttribute.getToken()).toEqual('someIssuanceToken'); + + // TODO: Requires fix from 3.7.3 + // expect(thirdPartyAttribute.getExpiryDate() + // .getMicrosecondTimestamp()).toBe('2019-10-15T22:04:05.123000Z'); + + expect(thirdPartyAttribute.getIssuingAttributes().length).toEqual(1); + expect(thirdPartyAttribute.getIssuingAttributes()[0]).toEqual('com.thirdparty.id'); + }); + + it('should return undefined for invalid third party attribute protobuf', () => { + const thirdPartyAttribute = ThirdPartyAttributeConverter.convertThirdPartyAttribute(Buffer.from('someValue', 'utf-8')); + expect(thirdPartyAttribute).toBe(undefined); + }); + + it('should return undefined for missing token', () => { + const thirdPartyProto = createTestThirdPartyAttribute(undefined, undefined); + const thirdPartyAttribute = ThirdPartyAttributeConverter + .convertThirdPartyAttribute(thirdPartyProto); + expect(thirdPartyAttribute).toBe(undefined); + }); + + it('should return undefined for empty token', () => { + const thirdPartyProto = createTestThirdPartyAttribute('', undefined); + const thirdPartyAttribute = ThirdPartyAttributeConverter + .convertThirdPartyAttribute(thirdPartyProto); + expect(thirdPartyAttribute).toBe(undefined); + }); + + it('should parse when issuing attributes is missing', () => { + const thirdPartyProto = createTestThirdPartyAttribute('someToken', undefined); + const thirdPartyAttribute = ThirdPartyAttributeConverter + .convertThirdPartyAttribute(thirdPartyProto); + + expect(thirdPartyAttribute).not.toBe(undefined); + expect(thirdPartyAttribute).toBeInstanceOf(AttributeIssuanceDetails); + expect(thirdPartyAttribute.getToken()).toEqual('someToken'); + expect(thirdPartyAttribute.getExpiryDate()).toBe(undefined); + expect(thirdPartyAttribute.getIssuingAttributes().length).toEqual(0); + }); + + it('should parse with invalid date', () => { + const thirdPartyProto = createTestThirdPartyAttribute('someToken', { + expiryDate: '2019-13-2', + definitions: [ + { + name: 'com.thirdparty.id', + }, + ], + }); + const thirdPartyAttribute = ThirdPartyAttributeConverter + .convertThirdPartyAttribute(thirdPartyProto); + + expect(thirdPartyAttribute).not.toBe(undefined); + expect(thirdPartyAttribute).toBeInstanceOf(AttributeIssuanceDetails); + expect(thirdPartyAttribute.getExpiryDate()).toBe(undefined); + expect(thirdPartyAttribute.getIssuingAttributes().length).toEqual(1); + expect(thirdPartyAttribute.getIssuingAttributes()[0]).toEqual('com.thirdparty.id'); + }); + + it('should parse multiple attribute definitions', () => { + const thirdPartyProto = createTestThirdPartyAttribute('someToken', { + expiryDate: '2019-13-2', + definitions: [ + { + name: 'com.thirdparty.id', + }, + ], + }); + const thirdPartyAttribute = ThirdPartyAttributeConverter + .convertThirdPartyAttribute(thirdPartyProto); + + expect(thirdPartyAttribute).not.toBe(undefined); + expect(thirdPartyAttribute).toBeInstanceOf(AttributeIssuanceDetails); + }); + }); +}); + From 24b3c724e69fa721443709be79c23d54d24c8427 Mon Sep 17 00:00:00 2001 From: Alex Burt Date: Tue, 22 Oct 2019 12:45:45 +0100 Subject: [PATCH 38/47] SDK-1231: Add tests for dates in attribute issuance details --- tests/yoti_common/extra.data.converter.spec.js | 5 ++--- .../third.party.attribute.converter.spec.js | 15 +++++++++++---- 2 files changed, 13 insertions(+), 7 deletions(-) diff --git a/tests/yoti_common/extra.data.converter.spec.js b/tests/yoti_common/extra.data.converter.spec.js index d4629708..81973ea8 100644 --- a/tests/yoti_common/extra.data.converter.spec.js +++ b/tests/yoti_common/extra.data.converter.spec.js @@ -24,9 +24,8 @@ describe('ExtraDataConverter', () => { expect(attributeIssuanceDetails.getIssuingAttributes()[0]).toEqual('com.thirdparty.id'); expect(attributeIssuanceDetails.getIssuingAttributes()[1]).toEqual('com.thirdparty.other_id'); - // TODO: Requires 3.7.3 Fix - // expect(attributeIssuanceDetails.getExpiryDate() - // .getMicrosecondTimestamp()).toBe('2019-10-15T22:04:05.123000Z'); + expect(attributeIssuanceDetails.getExpiryDate() + .getMicrosecondTimestamp()).toBe('2019-10-15T22:04:05.123000Z'); }); it('should return an instance of ExtraData even when failing to parse', () => { diff --git a/tests/yoti_common/third.party.attribute.converter.spec.js b/tests/yoti_common/third.party.attribute.converter.spec.js index 6138590f..5fc14d9d 100644 --- a/tests/yoti_common/third.party.attribute.converter.spec.js +++ b/tests/yoti_common/third.party.attribute.converter.spec.js @@ -24,9 +24,8 @@ describe('ThirdPartyAttributeConverter', () => { expect(thirdPartyAttribute).toBeInstanceOf(AttributeIssuanceDetails); expect(thirdPartyAttribute.getToken()).toEqual('someIssuanceToken'); - // TODO: Requires fix from 3.7.3 - // expect(thirdPartyAttribute.getExpiryDate() - // .getMicrosecondTimestamp()).toBe('2019-10-15T22:04:05.123000Z'); + expect(thirdPartyAttribute.getExpiryDate() + .getMicrosecondTimestamp()).toBe('2019-10-15T22:04:05.123000Z'); expect(thirdPartyAttribute.getIssuingAttributes().length).toEqual(1); expect(thirdPartyAttribute.getIssuingAttributes()[0]).toEqual('com.thirdparty.id'); @@ -84,11 +83,14 @@ describe('ThirdPartyAttributeConverter', () => { it('should parse multiple attribute definitions', () => { const thirdPartyProto = createTestThirdPartyAttribute('someToken', { - expiryDate: '2019-13-2', + expiryDate: '2019-12-02T12:00:00.000Z', definitions: [ { name: 'com.thirdparty.id', }, + { + name: 'com.otherthirdparty.id', + }, ], }); const thirdPartyAttribute = ThirdPartyAttributeConverter @@ -96,6 +98,11 @@ describe('ThirdPartyAttributeConverter', () => { expect(thirdPartyAttribute).not.toBe(undefined); expect(thirdPartyAttribute).toBeInstanceOf(AttributeIssuanceDetails); + + const definitions = thirdPartyAttribute.getIssuingAttributes(); + expect(definitions.length).toEqual(2); + expect(definitions[0]).toEqual('com.thirdparty.id'); + expect(definitions[1]).toEqual('com.otherthirdparty.id'); }); }); }); From 8f311b4638177093a71d9218f434fddfaa95e388 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Wed, 13 Nov 2019 11:37:26 +0000 Subject: [PATCH 39/47] SDK-1231: Decrypt extra data --- src/profile_service/index.js | 2 +- src/yoti_common/index.js | 129 ++++++++++++++++++------ tests/sample-data/payloads/payload.json | 2 +- 3 files changed, 100 insertions(+), 33 deletions(-) diff --git a/src/profile_service/index.js b/src/profile_service/index.js index c0222bdf..9142a289 100644 --- a/src/profile_service/index.js +++ b/src/profile_service/index.js @@ -22,7 +22,7 @@ module.exports.getReceipt = (token, pem, appId) => { const parsedResponse = response.getParsedResponse(); const decryptedProfile = yotiCommon.decryptCurrentUserReceipt(receipt, pem); const decryptedApplicationProfile = yotiCommon.decryptApplicationProfile(receipt, pem); - const extraData = yotiCommon.parseExtraData(receipt.extra_data_content); + const extraData = yotiCommon.parseExtraData(receipt, pem); return resolve(new ActivityDetails( parsedResponse, decryptedProfile, diff --git a/src/yoti_common/index.js b/src/yoti_common/index.js index b390d8a1..1182b536 100644 --- a/src/yoti_common/index.js +++ b/src/yoti_common/index.js @@ -12,30 +12,58 @@ const ExtraDataConverter = require('./extra.data.converter'); // Request methods that can include payload data. const methodsThatIncludePayload = ['POST', 'PUT', 'PATCH']; -function decipherProfile(cipherText, key, iv) { - const decipher = forge.cipher.createDecipher('AES-CBC', key); - const data = forge.util.createBuffer(); +/** + * Decrypt wrapped key using provided pem key. + * + * @param {string} wrappedKey + * @param {string} pem + * + * @returns {string} + */ +function unwrapKey(wrappedKey, pem) { + const wrappedKeyBuffer = Buffer.from(wrappedKey, 'base64'); + const privateKey = new NodeRSA(pem, 'pkcs1', { encryptionScheme: 'pkcs1' }); + const unwrappedKey = privateKey.decrypt(wrappedKeyBuffer, 'base64'); + return forge.util.decode64(unwrappedKey); +} - data.putBytes(cipherText); +/** + * Decrypt encrypted data using provided wrapped key. + * + * @param {string} encryptedData + * @param {string} wrappedReceiptKey + * @param {string} pem + * + * @returns {Buffer} + */ +function decryptEncryptedData(encryptedData, wrappedReceiptKey, pem) { + const decodedData = protoRoot.decodeEncryptedData(Buffer.from(encryptedData, 'base64')); + + const iv = forge.util.decode64(decodedData.iv); + const cipherText = forge.util.decode64(decodedData.cipherText); + + const data = forge.util + .createBuffer() + .putBytes(cipherText); + + const decipher = forge.cipher + .createDecipher( + 'AES-CBC', + unwrapKey(wrappedReceiptKey, pem) + ); decipher.start({ iv }); decipher.update(data); decipher.finish(); - const cipherTextAsBytes = decipher.output.getBytes(); - - const attributeList = protoRoot.decodeAttributeList(Buffer.from(forge.util.encode64(cipherTextAsBytes), 'base64')); - return attributeList; -} - -function unwrapKey(wrappedKey, pem) { - const wrappedKeyBuffer = Buffer.from(wrappedKey, 'base64'); - const privateKey = new NodeRSA(pem, 'pkcs1', { encryptionScheme: 'pkcs1' }); - const unwrappedKey = privateKey.decrypt(wrappedKeyBuffer, 'base64'); - - return unwrappedKey; + return Buffer.from(decipher.output.getBytes(), 'binary'); } +/** + * @param {string} httpMethod + * + * @returns {boolean} + */ module.exports.requestCanSendPayload = (httpMethod) => { // Check if the request method can send payload data if (methodsThatIncludePayload.indexOf(httpMethod) === -1) { @@ -45,12 +73,23 @@ module.exports.requestCanSendPayload = (httpMethod) => { return true; }; -module.exports.getRSASignatureForMessage = (message, pem) => { - const sign = crypto.createSign('RSA-SHA256'); - sign.update(message); - return sign.sign(pem).toString('base64'); -}; - +/** + * @param {string} message + * @param {string} pem + * + * @returns {string} + */ +module.exports.getRSASignatureForMessage = (message, pem) => crypto + .createSign('RSA-SHA256') + .update(message) + .sign(pem) + .toString('base64'); + +/** + * @param {string} pem + * + * @returns {string} + */ module.exports.getAuthKeyFromPem = (pem) => { const privateKey = forge.pki.privateKeyFromPem(pem); const publicKey = forge.pki.setRsaPublicKey(privateKey.n, privateKey.e); @@ -60,38 +99,66 @@ module.exports.getAuthKeyFromPem = (pem) => { return p12b64; }; +/** + * @param {string} profileContent + * @param {string} wrappedReceiptKey + * @param {string} pem + * + * @returns {Object[]} + */ module.exports.decryptProfileContent = (profileContent, wrappedReceiptKey, pem) => { const receiptNotEmpty = profileContent && Object.keys(profileContent).length > 0; if (receiptNotEmpty) { - const unwrappedKey = unwrapKey(wrappedReceiptKey, pem); - const decodedData = protoRoot.decodeEncryptedData(Buffer.from(profileContent, 'base64')); - const iv = forge.util.decode64(decodedData.iv); - const cipherText = forge.util.decode64(decodedData.cipherText); - - return decipherProfile(cipherText, forge.util.decode64(unwrappedKey), iv); + const decryptedProfileData = decryptEncryptedData(profileContent, wrappedReceiptKey, pem); + return protoRoot.decodeAttributeList(decryptedProfileData); } console.log('Receipt data is empty'); return []; }; +/** + * @param {Object} receipt + * @param {string} pem + * + * @returns {Object[]} + */ module.exports.decryptCurrentUserReceipt = (receipt, pem) => this.decryptProfileContent( receipt.other_party_profile_content, receipt.wrapped_receipt_key, pem ); +/** + * @param {Object} receipt + * @param {string} pem + * + * @returns {Object[]} + */ module.exports.decryptApplicationProfile = (receipt, pem) => this.decryptProfileContent( receipt.profile_content, receipt.wrapped_receipt_key, pem ); -module.exports.parseExtraData = (extraDataContent) => { - const extraDataNotEmpty = extraDataContent && Object.keys(extraDataContent).length > 0; +/** + * @param {Object} receipt + * @param {string} pem + * + * @returns {ExtraData} + */ +module.exports.parseExtraData = (receipt, pem) => { + const extraDataNotEmpty = receipt.extra_data_content + && Object.keys(receipt.extra_data_content).length > 0; if (extraDataNotEmpty) { - return ExtraDataConverter.convertExtraData(extraDataContent); + const decryptedExtraData = decryptEncryptedData( + receipt.extra_data_content, + receipt.wrapped_receipt_key, + pem + ); + + return ExtraDataConverter.convertExtraData(decryptedExtraData.toString()); } return new ExtraData(undefined); diff --git a/tests/sample-data/payloads/payload.json b/tests/sample-data/payloads/payload.json index 7cc55b2d..8d37ebec 100644 --- a/tests/sample-data/payloads/payload.json +++ b/tests/sample-data/payloads/payload.json @@ -5,7 +5,7 @@ "other_party_profile_content": "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", "profile_content": "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", "other_party_extra_data_content": null, - "extra_data_content": "CmMIBhJfChFzb21lSXNzdWFuY2VUb2tlbhJKChgyMDE5LTEwLTE1VDIyOjA0OjA1LjEyM1oSEwoRY29tLnRoaXJkcGFydHkuaWQSGQoXY29tLnRoaXJkcGFydHkub3RoZXJfaWQ=", + "extra_data_content": "ChDogwpQ0Zx7J6D4dmRDCRlYEpABRMvWdFcXAkRVJS2mal2z3+P+lXJhBzNUWrYeBmt1LfKufsb1d4hCgXbqMFDXwOWnRzznmCy7YtYb2IIda6TVJRo++UL8ZuYy9nLJmgQQppXQERPIUy30oFwPV1VLMSkSi5ZHBF2YQmBkRrzRJZ8MN7vbOipsLiYceOKvvcsQADMdL2QFTVZuMa9Z/Trd/fLC", "wrapped_receipt_key": "UqAI7cCcSFZ3NHWqEoXW3YfCXMxmvUBeN+JC2mQ/EVFvCjJ1DUVSzDP87bKtbZqKLqkj8oD0rQvMkS7VcYrUZ8aW6cTh+anX11LJLrP3ZYjr5QRQc5RHkOa+c3cFJV8ZwXzwJPkZny3BlHpEuAUhjcxywAcOPX4PULzO4zPrrkWq0cOtASVRqT+6CpR03RItL3yEY0CFa3RoYgrfkMsE8f8glft0GVVleVs85bAhiPmkfNQY0YZ/Ba12Ofph/S+4qB8ydfk96gpp+amb/Wfbd4gvs2DUCVpHu7U+937JEcEi6NJ08A5ufuWXoBxVKwVN1Tz7PNYDeSLhko77AIrJhg==", "policy_uri": "lNVPUiMEAf9oUBc56Tn_mZcbp4eOyXOd6mPTO_uYe8kKtZEgQFRekJrparpy8WHR", "personal_key": "t7es00YGJZgU2Wxoo3OqcJAdI8BSgKA134G1NGBK5xY=", From 0a95c42badfe87f8b6b5fa21fd0826bb7400d462 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Wed, 13 Nov 2019 11:55:13 +0000 Subject: [PATCH 40/47] SDK-1231: Base64 encode issuance token --- src/yoti_common/third.party.attribute.converter.js | 2 +- tests/yoti_common/extra.data.converter.spec.js | 2 +- tests/yoti_common/third.party.attribute.converter.spec.js | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/yoti_common/third.party.attribute.converter.js b/src/yoti_common/third.party.attribute.converter.js index 158190d7..2680a1ba 100644 --- a/src/yoti_common/third.party.attribute.converter.js +++ b/src/yoti_common/third.party.attribute.converter.js @@ -17,7 +17,7 @@ class ThirdPartyAttributeConverter { return undefined; } - const token = thirdPartyProto.issuanceToken.toString('utf8'); + const token = thirdPartyProto.issuanceToken.toString('base64'); if (!token || token === '') { console.log('Failed to retrieve token from ThirdPartyAttribute'); return undefined; diff --git a/tests/yoti_common/extra.data.converter.spec.js b/tests/yoti_common/extra.data.converter.spec.js index 81973ea8..10c53d51 100644 --- a/tests/yoti_common/extra.data.converter.spec.js +++ b/tests/yoti_common/extra.data.converter.spec.js @@ -18,7 +18,7 @@ describe('ExtraDataConverter', () => { const attributeIssuanceDetails = extraData.getAttributeIssuanceDetails(); expect(attributeIssuanceDetails).not.toBe(undefined); - expect(attributeIssuanceDetails.getToken()).toEqual('someIssuanceToken'); + expect(attributeIssuanceDetails.getToken()).toEqual('c29tZUlzc3VhbmNlVG9rZW4='); expect(attributeIssuanceDetails.getExpiryDate()).toBeInstanceOf(YotiDate); expect(attributeIssuanceDetails.getIssuingAttributes().length).toEqual(2); expect(attributeIssuanceDetails.getIssuingAttributes()[0]).toEqual('com.thirdparty.id'); diff --git a/tests/yoti_common/third.party.attribute.converter.spec.js b/tests/yoti_common/third.party.attribute.converter.spec.js index 5fc14d9d..20d9e955 100644 --- a/tests/yoti_common/third.party.attribute.converter.spec.js +++ b/tests/yoti_common/third.party.attribute.converter.spec.js @@ -22,7 +22,7 @@ describe('ThirdPartyAttributeConverter', () => { .convertThirdPartyAttribute(sampleThirdPartyAttribute); expect(thirdPartyAttribute).toBeInstanceOf(AttributeIssuanceDetails); - expect(thirdPartyAttribute.getToken()).toEqual('someIssuanceToken'); + expect(thirdPartyAttribute.getToken()).toEqual('c29tZUlzc3VhbmNlVG9rZW4='); expect(thirdPartyAttribute.getExpiryDate() .getMicrosecondTimestamp()).toBe('2019-10-15T22:04:05.123000Z'); @@ -57,7 +57,7 @@ describe('ThirdPartyAttributeConverter', () => { expect(thirdPartyAttribute).not.toBe(undefined); expect(thirdPartyAttribute).toBeInstanceOf(AttributeIssuanceDetails); - expect(thirdPartyAttribute.getToken()).toEqual('someToken'); + expect(thirdPartyAttribute.getToken()).toEqual('c29tZVRva2Vu'); expect(thirdPartyAttribute.getExpiryDate()).toBe(undefined); expect(thirdPartyAttribute.getIssuingAttributes().length).toEqual(0); }); From e6c237409cd09f07aa94c75304250e0849076283 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Wed, 13 Nov 2019 12:36:57 +0000 Subject: [PATCH 41/47] SDK-1231: Add JSDocs and validation --- src/data_type/attribute.issuance.details.js | 20 ++++++++++++-------- src/profile_service/activity.details.js | 8 ++++++++ src/profile_service/extra.data.js | 9 +++++++-- 3 files changed, 27 insertions(+), 10 deletions(-) diff --git a/src/data_type/attribute.issuance.details.js b/src/data_type/attribute.issuance.details.js index 86e23218..dd911b98 100644 --- a/src/data_type/attribute.issuance.details.js +++ b/src/data_type/attribute.issuance.details.js @@ -3,18 +3,22 @@ const Validation = require('../yoti_common/validation'); class AttributeIssuanceDetails { - constructor(token, expiryDate, issuingAttributes) { + /** + * @param {string} token + * @param {Date|undefined} expiryDate + * @param {string[]} issuingAttributes + */ + constructor(token, expiryDate, issuingAttributes = []) { Validation.isString(token, 'token'); - this.token = token; - this.expiryDate = expiryDate; - if (!issuingAttributes) { - this.issuingAttributes = []; - } else { - Validation.hasOnlyStringValues(issuingAttributes, 'issuingAttributes'); - this.issuingAttributes = issuingAttributes; + if (expiryDate !== undefined) { + Validation.instanceOf(expiryDate, Date, 'expiryDate'); } + this.expiryDate = expiryDate; + + Validation.hasOnlyStringValues(issuingAttributes, 'issuingAttributes'); + this.issuingAttributes = issuingAttributes; } getToken() { diff --git a/src/profile_service/activity.details.js b/src/profile_service/activity.details.js index e320c8fc..7e4fbd60 100644 --- a/src/profile_service/activity.details.js +++ b/src/profile_service/activity.details.js @@ -3,6 +3,8 @@ const { Age } = require('../yoti_common/age'); const { Profile } = require('./profile'); const { ApplicationProfile } = require('./application.profile'); +const ExtraData = require('./extra.data'); +const Validation = require('../yoti_common/validation'); /** * Processes profile array data into object. @@ -34,12 +36,18 @@ class ActivityDetails { * Decrypted user profile data. * @param {array} decryptedApplicationProfile * Decrypted application profile data. + * @param {ExtraData} extraData + * Decrypted and converted extra data. */ constructor(parsedResponse, decryptedProfile, decryptedApplicationProfile, extraData) { this.parsedResponse = parsedResponse; this.decryptedProfile = decryptedProfile; this.receipt = parsedResponse.receipt; this.profile = parseProfile(decryptedProfile); + + if (extraData !== undefined) { + Validation.instanceOf(extraData, ExtraData, 'extraData'); + } this.extraData = extraData; // This is the new profile attribute diff --git a/src/profile_service/extra.data.js b/src/profile_service/extra.data.js index 1a0af7e6..f9bd4e36 100644 --- a/src/profile_service/extra.data.js +++ b/src/profile_service/extra.data.js @@ -2,6 +2,9 @@ const AttributeIssuanceDetails = require('../data_type/attribute.issuance.details'); +/** + * @param {Object[]} parsedDataEntries + */ function getAttributeIssuanceDetails(parsedDataEntries) { const filtered = parsedDataEntries.filter(i => i instanceof AttributeIssuanceDetails); if (filtered.length > 0) { @@ -13,13 +16,15 @@ function getAttributeIssuanceDetails(parsedDataEntries) { class ExtraData { /** - * - * @param {Object} attributeIssuanceDetails + * @param {Object[]} attributeIssuanceDetails */ constructor(dataEntries = []) { this.attributeIssuanceDetails = getAttributeIssuanceDetails(dataEntries); } + /** + * @returns {AttributeIssuanceDetails} + */ getAttributeIssuanceDetails() { return this.attributeIssuanceDetails; } From 2b6a7203bdb969d11b381aea627b0458b8e67b8d Mon Sep 17 00:00:00 2001 From: David Grayston Date: Wed, 13 Nov 2019 18:37:01 +0000 Subject: [PATCH 42/47] SDK-1231: Remove unneeded extra data conversion to string --- src/yoti_common/index.js | 2 +- tests/sample-data/payloads/payload.json | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/yoti_common/index.js b/src/yoti_common/index.js index 1182b536..8541b713 100644 --- a/src/yoti_common/index.js +++ b/src/yoti_common/index.js @@ -158,7 +158,7 @@ module.exports.parseExtraData = (receipt, pem) => { pem ); - return ExtraDataConverter.convertExtraData(decryptedExtraData.toString()); + return ExtraDataConverter.convertExtraData(decryptedExtraData); } return new ExtraData(undefined); diff --git a/tests/sample-data/payloads/payload.json b/tests/sample-data/payloads/payload.json index 8d37ebec..93540101 100644 --- a/tests/sample-data/payloads/payload.json +++ b/tests/sample-data/payloads/payload.json @@ -5,7 +5,7 @@ "other_party_profile_content": "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", "profile_content": "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", "other_party_extra_data_content": null, - "extra_data_content": "ChDogwpQ0Zx7J6D4dmRDCRlYEpABRMvWdFcXAkRVJS2mal2z3+P+lXJhBzNUWrYeBmt1LfKufsb1d4hCgXbqMFDXwOWnRzznmCy7YtYb2IIda6TVJRo++UL8ZuYy9nLJmgQQppXQERPIUy30oFwPV1VLMSkSi5ZHBF2YQmBkRrzRJZ8MN7vbOipsLiYceOKvvcsQADMdL2QFTVZuMa9Z/Trd/fLC", + "extra_data_content": "ChCZK1k2WpNVdi58yu9MvXz5EnDxrDl1CUfUBDCSy/u6uI2+X7/tTrosHXWxu4ksN8qfVU2zdPE9FrEVNYKs7bbwdf3oOQ81q8+yF9Zv7szCUrYflY6WCwKBRJluYEApxXdjcHdvlhmzCXrgMeAV6qHj0n9qWrWXZytx+LT0mLHQPxeU", "wrapped_receipt_key": "UqAI7cCcSFZ3NHWqEoXW3YfCXMxmvUBeN+JC2mQ/EVFvCjJ1DUVSzDP87bKtbZqKLqkj8oD0rQvMkS7VcYrUZ8aW6cTh+anX11LJLrP3ZYjr5QRQc5RHkOa+c3cFJV8ZwXzwJPkZny3BlHpEuAUhjcxywAcOPX4PULzO4zPrrkWq0cOtASVRqT+6CpR03RItL3yEY0CFa3RoYgrfkMsE8f8glft0GVVleVs85bAhiPmkfNQY0YZ/Ba12Ofph/S+4qB8ydfk96gpp+amb/Wfbd4gvs2DUCVpHu7U+937JEcEi6NJ08A5ufuWXoBxVKwVN1Tz7PNYDeSLhko77AIrJhg==", "policy_uri": "lNVPUiMEAf9oUBc56Tn_mZcbp4eOyXOd6mPTO_uYe8kKtZEgQFRekJrparpy8WHR", "personal_key": "t7es00YGJZgU2Wxoo3OqcJAdI8BSgKA134G1NGBK5xY=", From 6b2d8e7212ddc782c6ac1e09186394503808cc36 Mon Sep 17 00:00:00 2001 From: Alex Burt Date: Thu, 31 Oct 2019 15:33:46 +0000 Subject: [PATCH 43/47] SDK-1262: Add support for third party attribute extension --- ...third.party.attribute.extension.builder.js | 37 ++++++ ...third.party.attribute.extension.content.js | 30 +++++ ....party.attribute.extension.builder.spec.js | 107 ++++++++++++++++++ 3 files changed, 174 insertions(+) create mode 100644 src/dynamic_sharing_service/extension/third.party.attribute.extension.builder.js create mode 100644 src/dynamic_sharing_service/extension/third.party.attribute.extension.content.js create mode 100644 tests/dynamic_sharing_service/extension/third.party.attribute.extension.builder.spec.js diff --git a/src/dynamic_sharing_service/extension/third.party.attribute.extension.builder.js b/src/dynamic_sharing_service/extension/third.party.attribute.extension.builder.js new file mode 100644 index 00000000..53f9151b --- /dev/null +++ b/src/dynamic_sharing_service/extension/third.party.attribute.extension.builder.js @@ -0,0 +1,37 @@ +'use strict'; + +const Extension = require('./extension'); +const ThirdPartyAttributeExtensionContent = require('./third.party.attribute.extension.content'); + +const THIRD_PARTY_ATTRIBUTE_EXTENSION_TYPE = 'THIRD_PARTY_ATTRIBUTE'; + +class ThirdPartyAttributeExtensionBuilder { + constructor() { + this.definitions = []; + } + + withExpiryDate(expiryDate) { + this.expiryDate = expiryDate; + return this; + } + + withDefinition(definition) { + this.definitions.push(definition); + return this; + } + + withDefinitions(definitions) { + this.definitions = definitions; + return this; + } + + build() { + const content = new ThirdPartyAttributeExtensionContent( + this.expiryDate, + this.definitions + ); + return new Extension(THIRD_PARTY_ATTRIBUTE_EXTENSION_TYPE, content); + } +} + +module.exports = ThirdPartyAttributeExtensionBuilder; diff --git a/src/dynamic_sharing_service/extension/third.party.attribute.extension.content.js b/src/dynamic_sharing_service/extension/third.party.attribute.extension.content.js new file mode 100644 index 00000000..7bc7e169 --- /dev/null +++ b/src/dynamic_sharing_service/extension/third.party.attribute.extension.content.js @@ -0,0 +1,30 @@ +'use strict'; + +const Validation = require('../../yoti_common/validation'); + +class ThirdPartyAttributeExtensionContent { + constructor(expiryDate, definitions) { + Validation.instanceOf(expiryDate, Date, 'expiryDate'); + Validation.hasOnlyStringValues(definitions, 'definitions'); + + this.expiryDate = expiryDate; + this.definitions = definitions; + } + + getExpiryDate() { + return this.expiryDate; + } + + getDefinitions() { + return this.definitions; + } + + toJSON() { + return { + expiry_date: this.expiryDate.toISOString(), + definitions: this.definitions.map(i => ({ name: i })), + }; + } +} + +module.exports = ThirdPartyAttributeExtensionContent; diff --git a/tests/dynamic_sharing_service/extension/third.party.attribute.extension.builder.spec.js b/tests/dynamic_sharing_service/extension/third.party.attribute.extension.builder.spec.js new file mode 100644 index 00000000..ecba2ad4 --- /dev/null +++ b/tests/dynamic_sharing_service/extension/third.party.attribute.extension.builder.spec.js @@ -0,0 +1,107 @@ +'use strict'; + +const ThirdPartyAttributeExtensionBuilder = require('../../../src/dynamic_sharing_service/extension/third.party.attribute.extension.builder'); +const ThirdPartyAttributeExtensionContent = require('../../../src/dynamic_sharing_service/extension/third.party.attribute.extension.content'); +const Extension = require('../../../src/dynamic_sharing_service/extension/extension'); + +describe('ThirdPartyAttributeExtensionBuilder', () => { + it('should fail for expiryDate wrong type', () => { + const builder = new ThirdPartyAttributeExtensionBuilder() + .withExpiryDate('some_invalid_date'); + + expect(() => builder.build()).toThrow(new TypeError('expiryDate must be instance of Date')); + }); + + it('should fail for undefined expiryDate', () => { + const builder = new ThirdPartyAttributeExtensionBuilder() + .withExpiryDate(undefined); + + expect(() => builder.build()).toThrow(new TypeError('expiryDate must be instance of Date')); + }); + + it('should fail for undefined definitions', () => { + const builder = new ThirdPartyAttributeExtensionBuilder() + .withExpiryDate(new Date()) + .withDefinitions(undefined); + + expect(() => builder.build()).toThrow(new TypeError('undefined must be instance of Object')); + }); + + it('should fail for array of non-string definitions', () => { + const builder = new ThirdPartyAttributeExtensionBuilder() + .withExpiryDate(new Date()) + .withDefinitions([1, 2, 3]); + + expect(() => builder.build()).toThrow(new TypeError('all values in definitions must be a string')); + }); + + describe('#addDefinition', () => { + it('should add a definition to the list of definitions already there', () => { + const thirdPartyAttributeExtension = new ThirdPartyAttributeExtensionBuilder() + .withExpiryDate(new Date()) + .withDefinitions(['definition_already_there']) + .withDefinition('new_definition') + .build(); + + expect(thirdPartyAttributeExtension.content.getDefinitions().length).toEqual(2); + expect(thirdPartyAttributeExtension.content.getDefinitions()[0]).toEqual('definition_already_there'); + expect(thirdPartyAttributeExtension.content.getDefinitions()[1]).toEqual('new_definition'); + }); + }); + + describe('#addDefinitions', () => { + it('should overwrite any definitions already in the list', () => { + const thirdPartyAttributeExtension = new ThirdPartyAttributeExtensionBuilder() + .withExpiryDate(new Date()) + .withDefinition('new_definition') + .withDefinitions(['definition_already_there']) + .build(); + + expect(thirdPartyAttributeExtension.content.getDefinitions().length).toEqual(1); + expect(thirdPartyAttributeExtension.content.getDefinitions()[0]).toEqual('definition_already_there'); + }); + }); + + it('should build successfully', () => { + const date = new Date(); + + const builder = new ThirdPartyAttributeExtensionBuilder() + .withExpiryDate(date) + .withDefinitions(['some_definition', 'some_other_definition']); + + const thirdPartyAttributeExtension = builder.build(); + + expect(thirdPartyAttributeExtension).toBeInstanceOf(Extension); + expect(thirdPartyAttributeExtension.content) + .toBeInstanceOf(ThirdPartyAttributeExtensionContent); + + expect(date.toISOString()) + .toEqual(thirdPartyAttributeExtension.content.getExpiryDate().toISOString()); + + expect(thirdPartyAttributeExtension.content.getDefinitions().length).toEqual(2); + expect(thirdPartyAttributeExtension.content.getDefinitions()[0]).toEqual('some_definition'); + expect(thirdPartyAttributeExtension.content.getDefinitions()[1]).toEqual('some_other_definition'); + }); + + it('should should convert to JSON correctly', () => { + const date = new Date(); + const builder = new ThirdPartyAttributeExtensionBuilder() + .withExpiryDate(date) + .withDefinitions(['some_definition', 'some_other_definition']); + + const thirdPartyAttributeExtension = builder.build(); + const expectedJson = { + type: 'THIRD_PARTY_ATTRIBUTE', + content: { + expiry_date: date.toISOString(), + definitions: [ + { name: 'some_definition' }, + { name: 'some_other_definition' }, + ], + }, + }; + + expect(JSON.stringify(expectedJson)).toEqual(JSON.stringify(thirdPartyAttributeExtension)); + }); +}); + From 3daab9b7639d5dc3b37ca226a68e2fb2e21e5c4d Mon Sep 17 00:00:00 2001 From: Alex Burt Date: Fri, 1 Nov 2019 12:17:50 +0000 Subject: [PATCH 44/47] SDK-1262: Update ThirdPartyAttributeExtension to use new class AttributeDefinition rather than a list of strings --- .../attribute.definition.js | 23 ++++++++ ...third.party.attribute.extension.builder.js | 5 ++ ...third.party.attribute.extension.content.js | 7 +-- src/dynamic_sharing_service/index.js | 2 + ....party.attribute.extension.builder.spec.js | 53 +++++++++++-------- 5 files changed, 61 insertions(+), 29 deletions(-) create mode 100644 src/dynamic_sharing_service/attribute.definition.js diff --git a/src/dynamic_sharing_service/attribute.definition.js b/src/dynamic_sharing_service/attribute.definition.js new file mode 100644 index 00000000..6ac60093 --- /dev/null +++ b/src/dynamic_sharing_service/attribute.definition.js @@ -0,0 +1,23 @@ +'use strict'; + +const Validation = require('../yoti_common/validation'); + +class AttributeDefinition { + constructor(name) { + Validation.isString(name, 'name'); + + this.name = name; + } + + getName() { + return this.name; + } + + toJSON() { + return { + name: this.name, + }; + } +} + +module.exports = AttributeDefinition; diff --git a/src/dynamic_sharing_service/extension/third.party.attribute.extension.builder.js b/src/dynamic_sharing_service/extension/third.party.attribute.extension.builder.js index 53f9151b..a0311141 100644 --- a/src/dynamic_sharing_service/extension/third.party.attribute.extension.builder.js +++ b/src/dynamic_sharing_service/extension/third.party.attribute.extension.builder.js @@ -2,6 +2,8 @@ const Extension = require('./extension'); const ThirdPartyAttributeExtensionContent = require('./third.party.attribute.extension.content'); +const AttributeDefinition = require('../attribute.definition'); +const Validation = require('../../yoti_common/validation'); const THIRD_PARTY_ATTRIBUTE_EXTENSION_TYPE = 'THIRD_PARTY_ATTRIBUTE'; @@ -11,16 +13,19 @@ class ThirdPartyAttributeExtensionBuilder { } withExpiryDate(expiryDate) { + Validation.instanceOf(expiryDate, Date, 'expiryDate'); this.expiryDate = expiryDate; return this; } withDefinition(definition) { + Validation.instanceOf(definition, AttributeDefinition, 'definition'); this.definitions.push(definition); return this; } withDefinitions(definitions) { + Validation.isArrayOfType(definitions, AttributeDefinition, 'definitions'); this.definitions = definitions; return this; } diff --git a/src/dynamic_sharing_service/extension/third.party.attribute.extension.content.js b/src/dynamic_sharing_service/extension/third.party.attribute.extension.content.js index 7bc7e169..4958c335 100644 --- a/src/dynamic_sharing_service/extension/third.party.attribute.extension.content.js +++ b/src/dynamic_sharing_service/extension/third.party.attribute.extension.content.js @@ -1,12 +1,7 @@ 'use strict'; -const Validation = require('../../yoti_common/validation'); - class ThirdPartyAttributeExtensionContent { constructor(expiryDate, definitions) { - Validation.instanceOf(expiryDate, Date, 'expiryDate'); - Validation.hasOnlyStringValues(definitions, 'definitions'); - this.expiryDate = expiryDate; this.definitions = definitions; } @@ -22,7 +17,7 @@ class ThirdPartyAttributeExtensionContent { toJSON() { return { expiry_date: this.expiryDate.toISOString(), - definitions: this.definitions.map(i => ({ name: i })), + definitions: this.definitions, }; } } diff --git a/src/dynamic_sharing_service/index.js b/src/dynamic_sharing_service/index.js index 8014993b..5de4423c 100644 --- a/src/dynamic_sharing_service/index.js +++ b/src/dynamic_sharing_service/index.js @@ -10,6 +10,7 @@ const WantedAttributeBuilder = require('./policy/wanted.attribute.builder'); const ExtensionBuilder = require('./extension/extension.builder'); const LocationConstraintExtensionBuilder = require('./extension/location.constraint.extension.builder'); const TransactionalFlowExtensionBuilder = require('./extension/transactional.flow.extension.builder'); +const ThirdPartyAttributeExtensionBuilder = require('./extension/third.party.attribute.extension.builder'); const WantedAnchorBuilder = require('./policy/wanted.anchor.builder'); const ConstraintsBuilder = require('./policy/constraints.builder'); const SourceConstraintBuilder = require('./policy/source.constraint.builder'); @@ -63,6 +64,7 @@ module.exports = { ExtensionBuilder, LocationConstraintExtensionBuilder, TransactionalFlowExtensionBuilder, + ThirdPartyAttributeExtensionBuilder, WantedAnchorBuilder, ConstraintsBuilder, SourceConstraintBuilder, diff --git a/tests/dynamic_sharing_service/extension/third.party.attribute.extension.builder.spec.js b/tests/dynamic_sharing_service/extension/third.party.attribute.extension.builder.spec.js index ecba2ad4..52f0a6de 100644 --- a/tests/dynamic_sharing_service/extension/third.party.attribute.extension.builder.spec.js +++ b/tests/dynamic_sharing_service/extension/third.party.attribute.extension.builder.spec.js @@ -2,50 +2,51 @@ const ThirdPartyAttributeExtensionBuilder = require('../../../src/dynamic_sharing_service/extension/third.party.attribute.extension.builder'); const ThirdPartyAttributeExtensionContent = require('../../../src/dynamic_sharing_service/extension/third.party.attribute.extension.content'); +const AttributeDefinition = require('../../../src/dynamic_sharing_service/attribute.definition'); const Extension = require('../../../src/dynamic_sharing_service/extension/extension'); describe('ThirdPartyAttributeExtensionBuilder', () => { it('should fail for expiryDate wrong type', () => { - const builder = new ThirdPartyAttributeExtensionBuilder() - .withExpiryDate('some_invalid_date'); + const builder = new ThirdPartyAttributeExtensionBuilder(); - expect(() => builder.build()).toThrow(new TypeError('expiryDate must be instance of Date')); + expect(() => builder.withExpiryDate('some_invalid_date')).toThrow(new TypeError('expiryDate must be instance of Date')); }); it('should fail for undefined expiryDate', () => { - const builder = new ThirdPartyAttributeExtensionBuilder() - .withExpiryDate(undefined); + const builder = new ThirdPartyAttributeExtensionBuilder(); - expect(() => builder.build()).toThrow(new TypeError('expiryDate must be instance of Date')); + expect(() => builder.withExpiryDate(undefined)).toThrow(new TypeError('expiryDate must be instance of Date')); }); it('should fail for undefined definitions', () => { const builder = new ThirdPartyAttributeExtensionBuilder() - .withExpiryDate(new Date()) - .withDefinitions(undefined); + .withExpiryDate(new Date()); - expect(() => builder.build()).toThrow(new TypeError('undefined must be instance of Object')); + expect(() => builder.withDefinitions(undefined)).toThrow(new TypeError('definitions must be an array')); }); it('should fail for array of non-string definitions', () => { const builder = new ThirdPartyAttributeExtensionBuilder() - .withExpiryDate(new Date()) - .withDefinitions([1, 2, 3]); + .withExpiryDate(new Date()); - expect(() => builder.build()).toThrow(new TypeError('all values in definitions must be a string')); + expect(() => builder.withDefinitions([1, 2, 3])).toThrow(new TypeError('definitions must be instance of AttributeDefinition')); }); describe('#addDefinition', () => { it('should add a definition to the list of definitions already there', () => { const thirdPartyAttributeExtension = new ThirdPartyAttributeExtensionBuilder() .withExpiryDate(new Date()) - .withDefinitions(['definition_already_there']) - .withDefinition('new_definition') + .withDefinitions([new AttributeDefinition('definition_already_there')]) + .withDefinition(new AttributeDefinition('new_definition')) .build(); expect(thirdPartyAttributeExtension.content.getDefinitions().length).toEqual(2); - expect(thirdPartyAttributeExtension.content.getDefinitions()[0]).toEqual('definition_already_there'); - expect(thirdPartyAttributeExtension.content.getDefinitions()[1]).toEqual('new_definition'); + expect(thirdPartyAttributeExtension.content.getDefinitions()[0]) + .toBeInstanceOf(AttributeDefinition); + expect(thirdPartyAttributeExtension.content.getDefinitions()[1]) + .toBeInstanceOf(AttributeDefinition); + expect(thirdPartyAttributeExtension.content.getDefinitions()[0].getName()).toEqual('definition_already_there'); + expect(thirdPartyAttributeExtension.content.getDefinitions()[1].getName()).toEqual('new_definition'); }); }); @@ -53,12 +54,12 @@ describe('ThirdPartyAttributeExtensionBuilder', () => { it('should overwrite any definitions already in the list', () => { const thirdPartyAttributeExtension = new ThirdPartyAttributeExtensionBuilder() .withExpiryDate(new Date()) - .withDefinition('new_definition') - .withDefinitions(['definition_already_there']) + .withDefinition(new AttributeDefinition('new_definition')) + .withDefinitions([new AttributeDefinition('definition_already_there')]) .build(); expect(thirdPartyAttributeExtension.content.getDefinitions().length).toEqual(1); - expect(thirdPartyAttributeExtension.content.getDefinitions()[0]).toEqual('definition_already_there'); + expect(thirdPartyAttributeExtension.content.getDefinitions()[0].getName()).toEqual('definition_already_there'); }); }); @@ -67,7 +68,10 @@ describe('ThirdPartyAttributeExtensionBuilder', () => { const builder = new ThirdPartyAttributeExtensionBuilder() .withExpiryDate(date) - .withDefinitions(['some_definition', 'some_other_definition']); + .withDefinitions([ + new AttributeDefinition('some_definition'), + new AttributeDefinition('some_other_definition'), + ]); const thirdPartyAttributeExtension = builder.build(); @@ -79,15 +83,18 @@ describe('ThirdPartyAttributeExtensionBuilder', () => { .toEqual(thirdPartyAttributeExtension.content.getExpiryDate().toISOString()); expect(thirdPartyAttributeExtension.content.getDefinitions().length).toEqual(2); - expect(thirdPartyAttributeExtension.content.getDefinitions()[0]).toEqual('some_definition'); - expect(thirdPartyAttributeExtension.content.getDefinitions()[1]).toEqual('some_other_definition'); + expect(thirdPartyAttributeExtension.content.getDefinitions()[0].getName()).toEqual('some_definition'); + expect(thirdPartyAttributeExtension.content.getDefinitions()[1].getName()).toEqual('some_other_definition'); }); it('should should convert to JSON correctly', () => { const date = new Date(); const builder = new ThirdPartyAttributeExtensionBuilder() .withExpiryDate(date) - .withDefinitions(['some_definition', 'some_other_definition']); + .withDefinitions([ + new AttributeDefinition('some_definition'), + new AttributeDefinition('some_other_definition'), + ]); const thirdPartyAttributeExtension = builder.build(); const expectedJson = { From 2e1989ff3ff304bbbf0f1c35689a7c55b5287327 Mon Sep 17 00:00:00 2001 From: Alex Burt Date: Fri, 1 Nov 2019 15:42:04 +0000 Subject: [PATCH 45/47] SDK-1262: Change third party attribute extension builder to accept strings for definitions, and then build the definition with the value supplied --- .../attribute.definition.js | 0 src/data_type/attribute.issuance.details.js | 3 ++- ...third.party.attribute.extension.builder.js | 10 ++++----- .../third.party.attribute.converter.js | 3 ++- ....party.attribute.extension.builder.spec.js | 22 +++++++++---------- .../yoti_common/extra.data.converter.spec.js | 4 ++-- .../third.party.attribute.converter.spec.js | 8 +++---- 7 files changed, 26 insertions(+), 24 deletions(-) rename src/{dynamic_sharing_service => data_type}/attribute.definition.js (100%) diff --git a/src/dynamic_sharing_service/attribute.definition.js b/src/data_type/attribute.definition.js similarity index 100% rename from src/dynamic_sharing_service/attribute.definition.js rename to src/data_type/attribute.definition.js diff --git a/src/data_type/attribute.issuance.details.js b/src/data_type/attribute.issuance.details.js index dd911b98..4902431f 100644 --- a/src/data_type/attribute.issuance.details.js +++ b/src/data_type/attribute.issuance.details.js @@ -1,6 +1,7 @@ 'use strict'; const Validation = require('../yoti_common/validation'); +const AttributeDefinition = require('./attribute.definition'); class AttributeIssuanceDetails { /** @@ -17,7 +18,7 @@ class AttributeIssuanceDetails { } this.expiryDate = expiryDate; - Validation.hasOnlyStringValues(issuingAttributes, 'issuingAttributes'); + Validation.isArrayOfType(issuingAttributes, AttributeDefinition, 'issuingAttributes'); this.issuingAttributes = issuingAttributes; } diff --git a/src/dynamic_sharing_service/extension/third.party.attribute.extension.builder.js b/src/dynamic_sharing_service/extension/third.party.attribute.extension.builder.js index a0311141..c4c7947c 100644 --- a/src/dynamic_sharing_service/extension/third.party.attribute.extension.builder.js +++ b/src/dynamic_sharing_service/extension/third.party.attribute.extension.builder.js @@ -2,7 +2,7 @@ const Extension = require('./extension'); const ThirdPartyAttributeExtensionContent = require('./third.party.attribute.extension.content'); -const AttributeDefinition = require('../attribute.definition'); +const AttributeDefinition = require('../../data_type/attribute.definition'); const Validation = require('../../yoti_common/validation'); const THIRD_PARTY_ATTRIBUTE_EXTENSION_TYPE = 'THIRD_PARTY_ATTRIBUTE'; @@ -19,14 +19,14 @@ class ThirdPartyAttributeExtensionBuilder { } withDefinition(definition) { - Validation.instanceOf(definition, AttributeDefinition, 'definition'); - this.definitions.push(definition); + Validation.isString(definition, 'definition'); + this.definitions.push(new AttributeDefinition(definition)); return this; } withDefinitions(definitions) { - Validation.isArrayOfType(definitions, AttributeDefinition, 'definitions'); - this.definitions = definitions; + Validation.hasOnlyStringValues(definitions, 'definitions'); + this.definitions = definitions.map(def => new AttributeDefinition(def)); return this; } diff --git a/src/yoti_common/third.party.attribute.converter.js b/src/yoti_common/third.party.attribute.converter.js index 2680a1ba..7073c561 100644 --- a/src/yoti_common/third.party.attribute.converter.js +++ b/src/yoti_common/third.party.attribute.converter.js @@ -6,6 +6,7 @@ const protoInst = protoRoot.initializeProtoBufObjects(); const { YotiDate } = require('../data_type/date'); const AttributeIssuanceDetails = require('../data_type/attribute.issuance.details'); +const AttributeDefinition = require('../data_type/attribute.definition'); class ThirdPartyAttributeConverter { static convertThirdPartyAttribute(protoBytes) { @@ -34,7 +35,7 @@ class ThirdPartyAttributeConverter { } catch (err) { console.log(`Failed to retrieve/parse expiryDate from ThirdPartyAttribute: ${err}`); } - attributes = issuingAttributes.definitions.map(a => a.name); + attributes = issuingAttributes.definitions.map(a => new AttributeDefinition(a.name)); } return new AttributeIssuanceDetails(token, expiryDate, attributes); diff --git a/tests/dynamic_sharing_service/extension/third.party.attribute.extension.builder.spec.js b/tests/dynamic_sharing_service/extension/third.party.attribute.extension.builder.spec.js index 52f0a6de..61075060 100644 --- a/tests/dynamic_sharing_service/extension/third.party.attribute.extension.builder.spec.js +++ b/tests/dynamic_sharing_service/extension/third.party.attribute.extension.builder.spec.js @@ -2,7 +2,7 @@ const ThirdPartyAttributeExtensionBuilder = require('../../../src/dynamic_sharing_service/extension/third.party.attribute.extension.builder'); const ThirdPartyAttributeExtensionContent = require('../../../src/dynamic_sharing_service/extension/third.party.attribute.extension.content'); -const AttributeDefinition = require('../../../src/dynamic_sharing_service/attribute.definition'); +const AttributeDefinition = require('../../../src/data_type/attribute.definition'); const Extension = require('../../../src/dynamic_sharing_service/extension/extension'); describe('ThirdPartyAttributeExtensionBuilder', () => { @@ -22,22 +22,22 @@ describe('ThirdPartyAttributeExtensionBuilder', () => { const builder = new ThirdPartyAttributeExtensionBuilder() .withExpiryDate(new Date()); - expect(() => builder.withDefinitions(undefined)).toThrow(new TypeError('definitions must be an array')); + expect(() => builder.withDefinitions(undefined)).toThrow(new TypeError('undefined must be instance of Object')); }); it('should fail for array of non-string definitions', () => { const builder = new ThirdPartyAttributeExtensionBuilder() .withExpiryDate(new Date()); - expect(() => builder.withDefinitions([1, 2, 3])).toThrow(new TypeError('definitions must be instance of AttributeDefinition')); + expect(() => builder.withDefinitions([1, 2, 3])).toThrow(new TypeError('all values in definitions must be a string')); }); describe('#addDefinition', () => { it('should add a definition to the list of definitions already there', () => { const thirdPartyAttributeExtension = new ThirdPartyAttributeExtensionBuilder() .withExpiryDate(new Date()) - .withDefinitions([new AttributeDefinition('definition_already_there')]) - .withDefinition(new AttributeDefinition('new_definition')) + .withDefinitions(['definition_already_there']) + .withDefinition('new_definition') .build(); expect(thirdPartyAttributeExtension.content.getDefinitions().length).toEqual(2); @@ -54,8 +54,8 @@ describe('ThirdPartyAttributeExtensionBuilder', () => { it('should overwrite any definitions already in the list', () => { const thirdPartyAttributeExtension = new ThirdPartyAttributeExtensionBuilder() .withExpiryDate(new Date()) - .withDefinition(new AttributeDefinition('new_definition')) - .withDefinitions([new AttributeDefinition('definition_already_there')]) + .withDefinition('new_definition') + .withDefinitions(['definition_already_there']) .build(); expect(thirdPartyAttributeExtension.content.getDefinitions().length).toEqual(1); @@ -69,8 +69,8 @@ describe('ThirdPartyAttributeExtensionBuilder', () => { const builder = new ThirdPartyAttributeExtensionBuilder() .withExpiryDate(date) .withDefinitions([ - new AttributeDefinition('some_definition'), - new AttributeDefinition('some_other_definition'), + 'some_definition', + 'some_other_definition', ]); const thirdPartyAttributeExtension = builder.build(); @@ -92,8 +92,8 @@ describe('ThirdPartyAttributeExtensionBuilder', () => { const builder = new ThirdPartyAttributeExtensionBuilder() .withExpiryDate(date) .withDefinitions([ - new AttributeDefinition('some_definition'), - new AttributeDefinition('some_other_definition'), + 'some_definition', + 'some_other_definition', ]); const thirdPartyAttributeExtension = builder.build(); diff --git a/tests/yoti_common/extra.data.converter.spec.js b/tests/yoti_common/extra.data.converter.spec.js index 10c53d51..14e85aac 100644 --- a/tests/yoti_common/extra.data.converter.spec.js +++ b/tests/yoti_common/extra.data.converter.spec.js @@ -21,8 +21,8 @@ describe('ExtraDataConverter', () => { expect(attributeIssuanceDetails.getToken()).toEqual('c29tZUlzc3VhbmNlVG9rZW4='); expect(attributeIssuanceDetails.getExpiryDate()).toBeInstanceOf(YotiDate); expect(attributeIssuanceDetails.getIssuingAttributes().length).toEqual(2); - expect(attributeIssuanceDetails.getIssuingAttributes()[0]).toEqual('com.thirdparty.id'); - expect(attributeIssuanceDetails.getIssuingAttributes()[1]).toEqual('com.thirdparty.other_id'); + expect(attributeIssuanceDetails.getIssuingAttributes()[0].getName()).toEqual('com.thirdparty.id'); + expect(attributeIssuanceDetails.getIssuingAttributes()[1].getName()).toEqual('com.thirdparty.other_id'); expect(attributeIssuanceDetails.getExpiryDate() .getMicrosecondTimestamp()).toBe('2019-10-15T22:04:05.123000Z'); diff --git a/tests/yoti_common/third.party.attribute.converter.spec.js b/tests/yoti_common/third.party.attribute.converter.spec.js index 20d9e955..bc2411f5 100644 --- a/tests/yoti_common/third.party.attribute.converter.spec.js +++ b/tests/yoti_common/third.party.attribute.converter.spec.js @@ -28,7 +28,7 @@ describe('ThirdPartyAttributeConverter', () => { .getMicrosecondTimestamp()).toBe('2019-10-15T22:04:05.123000Z'); expect(thirdPartyAttribute.getIssuingAttributes().length).toEqual(1); - expect(thirdPartyAttribute.getIssuingAttributes()[0]).toEqual('com.thirdparty.id'); + expect(thirdPartyAttribute.getIssuingAttributes()[0].getName()).toEqual('com.thirdparty.id'); }); it('should return undefined for invalid third party attribute protobuf', () => { @@ -78,7 +78,7 @@ describe('ThirdPartyAttributeConverter', () => { expect(thirdPartyAttribute).toBeInstanceOf(AttributeIssuanceDetails); expect(thirdPartyAttribute.getExpiryDate()).toBe(undefined); expect(thirdPartyAttribute.getIssuingAttributes().length).toEqual(1); - expect(thirdPartyAttribute.getIssuingAttributes()[0]).toEqual('com.thirdparty.id'); + expect(thirdPartyAttribute.getIssuingAttributes()[0].getName()).toEqual('com.thirdparty.id'); }); it('should parse multiple attribute definitions', () => { @@ -101,8 +101,8 @@ describe('ThirdPartyAttributeConverter', () => { const definitions = thirdPartyAttribute.getIssuingAttributes(); expect(definitions.length).toEqual(2); - expect(definitions[0]).toEqual('com.thirdparty.id'); - expect(definitions[1]).toEqual('com.otherthirdparty.id'); + expect(definitions[0].getName()).toEqual('com.thirdparty.id'); + expect(definitions[1].getName()).toEqual('com.otherthirdparty.id'); }); }); }); From 2f166cd3778e02ffdd9cab92967bf005fbdc529f Mon Sep 17 00:00:00 2001 From: David Grayston Date: Fri, 15 Nov 2019 18:23:04 +0000 Subject: [PATCH 46/47] SDK-1262: Export ThirdPartyAttributeExtensionBuilder --- index.js | 2 ++ .../extension/third.party.attribute.extension.builder.spec.js | 2 +- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/index.js b/index.js index 86b4a735..b8e382e0 100644 --- a/index.js +++ b/index.js @@ -12,6 +12,7 @@ const { WantedAttributeBuilder, ExtensionBuilder, LocationConstraintExtensionBuilder, + ThirdPartyAttributeExtensionBuilder, TransactionalFlowExtensionBuilder, WantedAnchorBuilder, ConstraintsBuilder, @@ -27,6 +28,7 @@ module.exports = { WantedAttributeBuilder, ExtensionBuilder, LocationConstraintExtensionBuilder, + ThirdPartyAttributeExtensionBuilder, TransactionalFlowExtensionBuilder, WantedAnchorBuilder, ConstraintsBuilder, diff --git a/tests/dynamic_sharing_service/extension/third.party.attribute.extension.builder.spec.js b/tests/dynamic_sharing_service/extension/third.party.attribute.extension.builder.spec.js index 61075060..f98721e5 100644 --- a/tests/dynamic_sharing_service/extension/third.party.attribute.extension.builder.spec.js +++ b/tests/dynamic_sharing_service/extension/third.party.attribute.extension.builder.spec.js @@ -1,6 +1,6 @@ 'use strict'; -const ThirdPartyAttributeExtensionBuilder = require('../../../src/dynamic_sharing_service/extension/third.party.attribute.extension.builder'); +const { ThirdPartyAttributeExtensionBuilder } = require('../../../'); const ThirdPartyAttributeExtensionContent = require('../../../src/dynamic_sharing_service/extension/third.party.attribute.extension.content'); const AttributeDefinition = require('../../../src/data_type/attribute.definition'); const Extension = require('../../../src/dynamic_sharing_service/extension/extension'); From cbb1410450b3b3dbdbded5470361a4684ed580c5 Mon Sep 17 00:00:00 2001 From: David Grayston Date: Wed, 4 Dec 2019 16:54:39 +0000 Subject: [PATCH 47/47] Prepare release 3.8.0 --- package-lock.json | 2 +- package.json | 2 +- sonar-project.properties | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/package-lock.json b/package-lock.json index b20f03e5..9caaca2b 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,6 +1,6 @@ { "name": "yoti", - "version": "3.7.3", + "version": "3.8.0", "lockfileVersion": 1, "requires": true, "dependencies": { diff --git a/package.json b/package.json index 2c7f5b17..9ddd3398 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "yoti", - "version": "3.7.3", + "version": "3.8.0", "description": "Yoti NodeJS SDK for back-end integration", "author": "Yoti LTD (https://www.yoti.com/developers)", "license": "MIT", diff --git a/sonar-project.properties b/sonar-project.properties index 2feff701..00453521 100644 --- a/sonar-project.properties +++ b/sonar-project.properties @@ -1,6 +1,6 @@ sonar.projectKey = yoti-web-sdk:node sonar.projectName = node-sdk -sonar.projectVersion = 3.7.3 +sonar.projectVersion = 3.8.0 sonar.exclusions=tests/**,examples/**,node_modules/**,coverage/** sonar.javascript.lcov.reportPaths=coverage/lcov.info sonar.verbose = true \ No newline at end of file