diff --git a/.github/workflows/manual_push_trigger.yml b/.github/workflows/manual_push_trigger.yml new file mode 100644 index 00000000..ac7b3669 --- /dev/null +++ b/.github/workflows/manual_push_trigger.yml @@ -0,0 +1,77 @@ +name: Manual trigger for maven install + +on: workflow_dispatch + +jobs: + build: + + runs-on: ubuntu-latest + env: + NAMESPACE: ${{ secrets.dev_namespace_docker_hub }} + SERVICE_NAME: card-print + SERVICE_LOCATION: ./ + + steps: + - uses: actions/checkout@v2 + - name: Set up JDK 11 + uses: actions/setup-java@v1 + with: + ref: ${{ github.ref }} + java-version: 11 + server-id: ossrh # Value of the distributionManagement/repository/id field of the pom.xml + settings-path: ${{ github.workspace }} # location for the settings.xml file + - name: Setup branch and env + run: | + # Strip git ref prefix from version + echo "BRANCH_NAME=$(echo ${{ github.ref }} | sed -e 's,.*/\(.*\),\1,')" >> $GITHUB_ENV + echo "GPG_TTY=$(tty)" >> $GITHUB_ENV + + - name: Setup branch and GPG public key + run: | + # Strip git ref prefix from version + echo ${{ env.BRANCH_NAME }} + echo ${{ env.GPG_TTY }} + sudo apt-get --yes install gnupg2 +# gpg2 --import ./.github/keys/mosipgpgkey_pub.gpg +# gpg2 --quiet --batch --passphrase=${{secrets.gpg_secret}} --allow-secret-key-import --import ./.github/keys/mosipgpgkey_sec.gpg + + - uses: actions/cache@v1 + with: + path: ~/.m2/repository + key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }} + restore-keys: | + ${{ runner.os }}-maven-${{ env.BRANCH_NAME }} + + - name: Setup the settings file for ossrh server + run: echo " ossrh ${{secrets.ossrh_user}} ${{secrets.ossrh_secret}} ossrh true gpg2 ${{secrets.gpg_secret}} allow-snapshots true snapshots-repo https://oss.sonatype.org/content/repositories/snapshots false true releases-repo https://oss.sonatype.org/service/local/staging/deploy/maven2 true false sonar . https://sonarcloud.io false " > $GITHUB_WORKSPACE/settings.xml + + + - name: Build with Maven + run: | + cd ./ + mvn clean install -U -s $GITHUB_WORKSPACE/settings.xml -DskipTests -Dgpg.skip=true --file pom.xml + + - name: Removing target jars + run: | + rm -rf $(find -name '*.jar' ! -executable -type f) + + - name: Build image + run: | + cd "./${{env.SERVICE_LOCATION}}" + docker build . --file Dockerfile --tag ${{ env.SERVICE_NAME }} + + - name: Log into registry + run: echo "${{ secrets.release_docker_hub }}" | docker login -u ${{ secrets.actor_docker_hub }} --password-stdin + + - name: Push image + run: | + IMAGE_ID=$NAMESPACE/$SERVICE_NAME + + # Change all uppercase to lowercase + IMAGE_ID=$(echo $IMAGE_ID | tr '[A-Z]' '[a-z]') + echo "push version ${{steps.getPomVersion.outputs.info}}" + VERSION=$BRANCH_NAME + echo IMAGE_ID=$IMAGE_ID + echo VERSION=$VERSION + docker tag $SERVICE_NAME $IMAGE_ID:$VERSION + docker push $IMAGE_ID:$VERSION diff --git a/pom.xml b/pom.xml index 3a2e1b3b..af7bbed4 100644 --- a/pom.xml +++ b/pom.xml @@ -5,12 +5,12 @@ org.springframework.boot spring-boot-starter-parent - 2.0.9.RELEASE + 2.0.2.RELEASE io.mosip.print print - 1.2.0-SNAPSHOT + 1.1.5.2 print @@ -33,19 +33,24 @@ 1.4.197 2.9.8 2.9.2 - 1.2.0-SNAPSHOT - 1.2.0-SNAPSHOT 2.0.7 2.28.2 **/constant/**,**/config/**,**/cache/**,**/dto/**,**/model/**,**/exception/**,**/repository/**,**/security/**,**/*Config.java,**/*Application.java,**/*Handler.java **/dto/**,**/config/**,**/api/** 1.4.2 2.8.4 - 1.2.0-SNAPSHOT + 1.1.5.2 7.1.0 2.0.0 5.5.13 - + 3.6.1 + 3.7 + 2.6 + 1.11 + 1.66 + 3.8.1 + 3.3.3 + 42.2.2 @@ -57,10 +62,39 @@ org.springframework.boot spring-boot-starter-security --> + + + org.springframework.boot spring-boot-starter-web + + org.springframework.boot + spring-boot-starter-actuator + + + org.springframework.cloud + spring-cloud-starter-config + 2.0.2.RELEASE + + + com.googlecode.json-simple + json-simple + 1.1.1 + + + com.google.code.gson + gson + org.json json 20190722 - - - io.mosip.kernel - kernel-logger-logback - 1.2.0-SNAPSHOT - - - io.mosip.kernel - kernel-idvalidator-uin - 1.0.6 + + org.slf4j + slf4j-api + 1.7.25 - io.mosip.kernel - kernel-idvalidator-rid - 1.0.6 + net.logstash.logback + logstash-logback-encoder + 6.4 - - io.mosip.kernel - kernel-auth-adapter - 1.0.6 - - - org.springframework.boot - spring-boot-starter-security - - - - - io.mosip.kernel - kernel-idvalidator-vid - 1.0.6 - joda-time joda-time @@ -161,40 +161,10 @@ json-simple 1.1.1 - - io.mosip.kernel - kernel-pdfgenerator-itext - 1.0.6 - - - io.mosip.kernel - kernel-qrcodegenerator-zxing - 1.0.6 - - - io.mosip.kernel - kernel-cbeffutil-api - 1.1.0 - - - io.mosip.kernel - kernel-bioapi-provider - 1.0.8 - - - io.mosip.kernel - kernel-biometrics-api - 1.2.0-SNAPSHOT - com.google.code.gson gson - - io.mosip.kernel - kernel-templatemanager-velocity - 1.0.6 - org.apache.velocity velocity @@ -204,15 +174,47 @@ org.apache.velocity velocity-tools 2.0 + + + dom4j + dom4j + + + + + commons-io + commons-io + ${commons-io} + + + org.apache.commons + commons-lang3 + ${commons-lang3} + + + org.bouncycastle + bcprov-jdk15on + ${bouncycastle.version} + + + commons-codec + commons-codec + ${commons-codec} javax.xml.bind jaxb-api + 2.3.1 - org.w3c - dom - 2.3.0-jaxb-1.0.6 + javax.activation + activation + 1.1 + + + org.glassfish.jaxb + jaxb-runtime + 2.3.1 io.springfox @@ -224,8 +226,65 @@ springfox-swagger2 ${swagger.version} + + com.itextpdf + itext7-core + ${itextcore.version} + pom + + + com.itextpdf + html2pdf + ${itexthtml2pdf.version} + + + com.itextpdf + itextpdf + ${itext.version} + + + com.itextpdf.tool + xmlworker + ${itext.version} + + + com.google.zxing + javase + ${google.zxing.version} + + + org.apache.httpcomponents + httpclient + 4.5.8 + + + com.auth0 + java-jwt + ${jwt.version} + + + org.mockito + mockito-core + 2.22.0 + test + + + io.mosip.kernel + kernel-websubclient-api + ${kernel.websub.version} + + + io.mosip.kernel + kernel-dataaccess-hibernate + 1.1.5.3 + + + org.postgresql + postgresql + ${postgresql.version} + - + diff --git a/src/main/java/io/mosip/print/PrintPDFApplication.java b/src/main/java/io/mosip/print/PrintPDFApplication.java index 7ff2d830..cff04af4 100644 --- a/src/main/java/io/mosip/print/PrintPDFApplication.java +++ b/src/main/java/io/mosip/print/PrintPDFApplication.java @@ -2,14 +2,22 @@ import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration; +import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration; +import org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration; +import org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Primary; import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler; -import io.mosip.kernel.cbeffutil.impl.CbeffImpl; -import io.mosip.kernel.core.cbeffutil.spi.CbeffUtil; +import io.mosip.print.service.impl.CbeffImpl; +import io.mosip.print.spi.CbeffUtil; -@SpringBootApplication + + +@SpringBootApplication(exclude = { SecurityAutoConfiguration.class, DataSourceAutoConfiguration.class, + HibernateJpaAutoConfiguration.class, + CacheAutoConfiguration.class }) public class PrintPDFApplication { @Bean diff --git a/src/main/java/io/mosip/print/constant/ApiName.java b/src/main/java/io/mosip/print/constant/ApiName.java index d0166963..13c9c477 100644 --- a/src/main/java/io/mosip/print/constant/ApiName.java +++ b/src/main/java/io/mosip/print/constant/ApiName.java @@ -94,6 +94,7 @@ public enum ApiName { DEVICEVALIDATEHISTORY, + DECRYPTPINBASSED, CREATEDATASHARE, PDFSIGN, NGINXDMZURL, diff --git a/src/main/java/io/mosip/print/constant/CbeffConstant.java b/src/main/java/io/mosip/print/constant/CbeffConstant.java new file mode 100644 index 00000000..53499a83 --- /dev/null +++ b/src/main/java/io/mosip/print/constant/CbeffConstant.java @@ -0,0 +1,36 @@ +/** + * + */ +package io.mosip.print.constant; + +/** + * @author Ramadurai Pandian + * + * A Constant Class to hold all the default identifier values + */ +public class CbeffConstant { + + public static final long FORMAT_OWNER = 257; + + // Format Type + + public static final long FORMAT_TYPE_IRIS = 9; + + public static final long FORMAT_TYPE_FACE = 8; + + public static final long FORMAT_TYPE_FINGER = 7; + + public static final long FORMAT_TYPE_FINGER_MINUTIAE = 2; + + // Format Identifier + + public static final int FINGER_FORMAT_IDENTIFIER = 0x46495200; + + public static final int IRIS_FORMAT_IDENTIFIER = 0x49495200; + + public static final int FACE_FORMAT_IDENTIFIER = 0x46495200; + + // TODO Actual face identifier waiting for Face ISO image + // public static final int FACE_FORMAT_IDENTIFIER = 0x46414300; + +} diff --git a/src/main/java/io/mosip/print/constant/DateUtilConstants.java b/src/main/java/io/mosip/print/constant/DateUtilConstants.java new file mode 100644 index 00000000..df023ce6 --- /dev/null +++ b/src/main/java/io/mosip/print/constant/DateUtilConstants.java @@ -0,0 +1,31 @@ +package io.mosip.print.constant; + +public enum DateUtilConstants { + ILLEGALARGUMENT_ERROR_CODE("KER-UTL-101", "Invalid Argument Found"), + NULL_ARGUMENT_ERROR_CODE("KER-UTL-102", "Null Argument Found"), + PARSE_EXCEPTION_ERROR_CODE("KER-UTL-103", "Parsing error occours"); + + /** Error code. */ + public final String errorCode; + /** Exception Message */ + public final String exceptionMessage; + + /** + * @param errorCode source Error code to use when no localized code is + * available + * @param exceptionMessage source exception message to use when no localized + * message is available. + */ + DateUtilConstants(final String errorCode, final String exceptionMessage) { + this.errorCode = errorCode; + this.exceptionMessage = exceptionMessage; + } + + public String getErrorCode() { + return errorCode; + } + + public String getEexceptionMessage() { + return exceptionMessage; + } +} diff --git a/src/main/java/io/mosip/print/constant/HubMode.java b/src/main/java/io/mosip/print/constant/HubMode.java new file mode 100644 index 00000000..403ba65f --- /dev/null +++ b/src/main/java/io/mosip/print/constant/HubMode.java @@ -0,0 +1,42 @@ +package io.mosip.print.constant; + +/** + * This {@link Enum} comprises of Hub mods used in this api. + * {@link #REGISTER},{@link #UNREGISTER},{@link #PUBLISH},{@link #SUBSCRIBE},{@link #UNSUBSCRIBE} + * + * @author Urvil Joshi + * + */ +public enum HubMode { + + /** + * Register mode + */ + REGISTER("register"), + /** + * Unregister mode + */ + UNREGISTER("unregister"), + /** + * Publish mode + */ + PUBLISH("publish"), + /** + * Subscribe mode + */ + SUBSCRIBE("subscribe"), + /** + * Unsubscribe mode + */ + UNSUBSCRIBE("unsubscribe"); + + private final String hubModeValue; + + private HubMode(String hubModeValue) { + this.hubModeValue = hubModeValue; + } + + public String gethubModeValue() { + return this.hubModeValue; + } +} diff --git a/src/main/java/io/mosip/print/constant/PDFGeneratorExceptionCodeConstant.java b/src/main/java/io/mosip/print/constant/PDFGeneratorExceptionCodeConstant.java new file mode 100644 index 00000000..fb468237 --- /dev/null +++ b/src/main/java/io/mosip/print/constant/PDFGeneratorExceptionCodeConstant.java @@ -0,0 +1,55 @@ +package io.mosip.print.constant; + +/** + * Exception code constants for this module + * + * @author Uday Kumar + * + * @since 1.0.0 + */ + +public enum PDFGeneratorExceptionCodeConstant { + PDF_EXCEPTION("KER-PDG-001", "Pdf generation failed"), + OWNER_PASSWORD_NULL_EMPTY_EXCEPTION("KER-PDG-002", "Owner Password is null or Empty or not in properties"), + INPUTSTREAM_NULL_EMPTY_EXCEPTION("KER-PDG-003", "InputStream is null or Empty or not in properties"); + + /** + * This variable holds the error code. + */ + private String errorCode; + + /** + * This variable holds the error message. + */ + private String errorMessage; + + /** + * Constructor for UINErrorConstants Enum. + * + * @param errorCode the error code. + * @param errorMessage the error message. + */ + PDFGeneratorExceptionCodeConstant(String errorCode, String errorMessage) { + this.errorCode = errorCode; + this.errorMessage = errorMessage; + } + + /** + * Getter for errorCode. + * + * @return the error code. + */ + public String getErrorCode() { + return errorCode; + } + + /** + * Getter for errorMessage. + * + * @return the error message. + */ + public String getErrorMessage() { + return errorMessage; + } + +} diff --git a/src/main/java/io/mosip/print/constant/PrintTransactionStatus.java b/src/main/java/io/mosip/print/constant/PrintTransactionStatus.java new file mode 100644 index 00000000..1ee3411a --- /dev/null +++ b/src/main/java/io/mosip/print/constant/PrintTransactionStatus.java @@ -0,0 +1,9 @@ +package io.mosip.print.constant; + +public enum PrintTransactionStatus { + QUEUED, + SENT_FOR_PRINTING, + PRINTED, + ERROR, + SAVED_IN_LOCAL +} diff --git a/src/main/java/io/mosip/print/constant/QrVersion.java b/src/main/java/io/mosip/print/constant/QrVersion.java new file mode 100644 index 00000000..c5dda143 --- /dev/null +++ b/src/main/java/io/mosip/print/constant/QrVersion.java @@ -0,0 +1,215 @@ +package io.mosip.print.constant; + +/** + * QrCode Version and Module mapping contains {@link #V25} {@link #V26} + * {@link #V27} {@link #V28} {@link #V29} {@link #V30} {@link #V31} {@link #V32} + * {@link #V33} {@link #V34} {@link #V35} {@link #V36} {@link #V37} {@link #V38} + * {@link #V39} {@link #V40} + * + * @author Urvil Joshi + * + * @since 1.0.0 + */ +public enum QrVersion { + + /** + * Version 1 + */ + V1(1, 58), + /** + * Version 2 + */ + V2(2, 66), + /** + * Version 3 + */ + V3(3, 74), + /** + * Version 4 + */ + V4(4, 82), + /** + * Version 5 + */ + V5(5, 90), + /** + * Version 6 + */ + V6(6, 98), + /** + * Version 7 + */ + V7(7, 106), + /** + * Version 8 + */ + V8(8, 114), + /** + * Version 9 + */ + V9(9, 122), + /** + * Version 10 + */ + V10(10, 130), + /** + * Version 11 + */ + V11(11, 138), + /** + * Version 12 + */ + V12(12, 146), + /** + * Version 13 + */ + V13(13, 154), + /** + * Version 14 + */ + V14(14, 162), + /** + * Version 15 + */ + V15(15, 170), + /** + * Version 16 + */ + V16(16, 178), + /** + * Version 17 + */ + V17(17, 186), + /** + * Version 18 + */ + V18(18, 194), + /** + * Version 19 + */ + V19(19, 202), + /** + * Version 20 + */ + V20(20, 210), + /** + * Version 21 + */ + V21(21, 218), + /** + * Version 22 + */ + V22(22, 226), + /** + * Version 23 + */ + V23(23, 234), + /** + * Version 24 + */ + V24(24, 242), + /** + * Version 25 + */ + V25(25, 250), + /** + * Version 26 + */ + V26(26, 258), + /** + * Version 27 + */ + V27(27, 266), + /** + * Version 28 + */ + V28(28, 274), + /** + * Version 29 + */ + V29(29, 282), + /** + * Version 30 + */ + V30(30, 290), + /** + * Version 31 + */ + V31(31, 298), + /** + * Version 32 + */ + V32(32, 306), + /** + * Version 33 + */ + V33(33, 314), + /** + * Version 34 + */ + V34(34, 322), + /** + * Version 35 + */ + V35(35, 330), + /** + * Version 36 + */ + V36(36, 338), + /** + * Version 37 + */ + V37(37, 346), + /** + * Version 38 + */ + V38(38, 354), + /** + * Version 39 + */ + V39(39, 362), + /** + * Version 40 + */ + V40(40, 370); + + /** + * No of Version + */ + private final int version; + + /** + * No of Modules + */ + private final int size; + + /** + * Constructor for {@link QrVersion} + * + * @param version version of QR code + * @param size no of Modules + */ + private QrVersion(final int version, final int size) { + this.version = version; + this.size = size; + } + + /** + * Getter for No of Modules + * + * @return {@link #size} + */ + public int getSize() { + return size; + } + + /** + * Getter for version + * + * @return {@link #version} + */ + public int getVersion() { + return version; + } + +} diff --git a/src/main/java/io/mosip/print/constant/QrcodeConstants.java b/src/main/java/io/mosip/print/constant/QrcodeConstants.java new file mode 100644 index 00000000..0f81dadd --- /dev/null +++ b/src/main/java/io/mosip/print/constant/QrcodeConstants.java @@ -0,0 +1,23 @@ +package io.mosip.print.constant; + +/** + * Constant class for QR code Generator + * + * @author Urvil Joshi + * + * @since 1.0.0 + */ +public class QrcodeConstants { + + /** + * Constructor for this class + */ + private QrcodeConstants() { + + } + + /** + * File Format for QR code Image + */ + public static final String FILE_FORMAT = "png"; +} diff --git a/src/main/java/io/mosip/print/constant/QrcodeExceptionConstants.java b/src/main/java/io/mosip/print/constant/QrcodeExceptionConstants.java new file mode 100644 index 00000000..c806e67c --- /dev/null +++ b/src/main/java/io/mosip/print/constant/QrcodeExceptionConstants.java @@ -0,0 +1,55 @@ +package io.mosip.print.constant; + +/** + * Exception constants for QR Code generator + * + * @author Urvil Joshi + * + * @since 1.0.0 + */ +public enum QrcodeExceptionConstants { + + QRCODE_GENERATION_EXCEPTION("KER-QRG-001", "exception occured while writing QR code "), + INVALID_INPUT_DATA_NULL("KER-QRG-002", "data can't be null"), + INVALID_INPUT_DATA_EMPTY("KER-QRG-003", "data can't be empty"), + INVALID_INPUT_VERSION("KER-QRG-004", "version can't be null"); + + /** + * Constant {@link Enum} errorCode + */ + private final String errorCode; + + /** + * Getter for errorMessage + * + * @return get errorMessage value + */ + public String getErrorMessage() { + return errorMessage; + } + + /** + * Constant {@link Enum} errorMessage + */ + private final String errorMessage; + + /** + * Constructor for this class + * + * @param errorCode {@link #errorCode} + * @param errorMessage {@link #errorMessage} + */ + private QrcodeExceptionConstants(final String errorCode, final String errorMessage) { + this.errorCode = errorCode; + this.errorMessage = errorMessage; + } + + /** + * Getter for errorCode + * + * @return get errorCode value + */ + public String getErrorCode() { + return errorCode; + } +} diff --git a/src/main/java/io/mosip/print/constant/TemplateManagerConstant.java b/src/main/java/io/mosip/print/constant/TemplateManagerConstant.java new file mode 100644 index 00000000..e8df4b28 --- /dev/null +++ b/src/main/java/io/mosip/print/constant/TemplateManagerConstant.java @@ -0,0 +1,37 @@ +package io.mosip.print.constant; + +/** + * constants for NullPointerException Messages + * + * @author Abhishek Kumar + * @since 10-10-2018 + * @version 1.0.0 + */ +public enum TemplateManagerConstant { + WRITER_NULL("Writer cannot be null"), TEMPLATE_VALUES_NULL("Values cannot be null, it requires process template"), + TEMPLATE_INPUT_STREAM_NULL("Template cannot be null"), ENCODING_TYPE_NULL("Encoding type cannot be null"), + TEMPATE_NAME_NULL("Template name cannot be null"); + + /** + * This variable contains the message + */ + private String message; + + /** + * Constructor for setting message + * + * @param message + */ + TemplateManagerConstant(String message) { + this.message = message; + } + + /** + * Getter for getting the message + * + * @return message + */ + public String getMessage() { + return message; + } +} diff --git a/src/main/java/io/mosip/print/constant/TemplateManagerExceptionCodeConstant.java b/src/main/java/io/mosip/print/constant/TemplateManagerExceptionCodeConstant.java new file mode 100644 index 00000000..5247faa3 --- /dev/null +++ b/src/main/java/io/mosip/print/constant/TemplateManagerExceptionCodeConstant.java @@ -0,0 +1,54 @@ +package io.mosip.print.constant; + +/** + * exception constants for template manager + * + * @author Abhishek Kumar + * @since 08-10-2018 + * @version 1.0.0 + */ +public enum TemplateManagerExceptionCodeConstant { + TEMPLATE_NOT_FOUND("KER-TEM-004", "Template resource not found"), + TEMPLATE_PARSING("KER-TEM-003", "Exception occured during template processing"), + TEMPLATE_INVALID_REFERENCE("KER-TEM-001", "Reference method in template could not be invoked"); + + /** + * This variable holds the error code. + */ + private String errorCode; + + /** + * This variable holds the error message. + */ + private String errorMessage; + + /** + * Constructor for MosipTemplateManagerExceptionCodeConstants Enum. + * + * @param errorCode the error code. + * @param errorMessage the error message. + */ + TemplateManagerExceptionCodeConstant(String errorCode, String errorMessage) { + this.errorCode = errorCode; + this.errorMessage = errorMessage; + } + + /** + * Getter for errorCode. + * + * @return the error code. + */ + public String getErrorCode() { + return errorCode; + } + + /** + * Getter for errorMessage. + * + * @return the error message. + */ + public String getErrorMessage() { + return errorMessage; + } + +} diff --git a/src/main/java/io/mosip/print/constant/UINCardConstant.java b/src/main/java/io/mosip/print/constant/UINCardConstant.java new file mode 100644 index 00000000..fe341626 --- /dev/null +++ b/src/main/java/io/mosip/print/constant/UINCardConstant.java @@ -0,0 +1,52 @@ +package io.mosip.print.constant; + +/** + * The Class UINCardConstant. + * + * @author M1048358 Alok + */ +public class UINCardConstant { + + /** + * Instantiates a new UIN card constant. + */ + private UINCardConstant() { + } + + /** The Constant FULLNAME. */ + public static final String NAME = "name"; + + /** The Constant PHONENUMBER. */ + public static final String PHONE = "phone"; + + /** The Constant EMAILID. */ + public static final String EMAIL = "email"; + + /** The Constant DATEOFBIRTH. */ + public static final String DATEOFBIRTH = "dob"; + + /** The Constant GENDER. */ + public static final String GENDER = "gender"; + + /** The Constant ADDRESSLINE1. */ + public static final String ADDRESSLINE1 = "addressLine1"; + + /** The Constant ADDRESSLINE2_ENG. */ + public static final String ADDRESSLINE2 = "addressLine2"; + + /** The Constant ADDRESSLINE3_ENG. */ + public static final String ADDRESSLINE3 = "addressLine3"; + + /** The Constant REGION. */ + public static final String REGION = "region"; + + /** The Constant PROVINCE. */ + public static final String PROVINCE = "province"; + + /** The Constant CITY. */ + public static final String CITY = "city"; + + /** The Constant POSTALCODE. */ + public static final String POSTALCODE = "postalCode"; + +} diff --git a/src/main/java/io/mosip/print/constant/WebSubClientConstants.java b/src/main/java/io/mosip/print/constant/WebSubClientConstants.java new file mode 100644 index 00000000..129ae995 --- /dev/null +++ b/src/main/java/io/mosip/print/constant/WebSubClientConstants.java @@ -0,0 +1,21 @@ +package io.mosip.print.constant; + +/** + * This class consist constants for this api. + * + * @author Urvil Joshi + * + */ +public class WebSubClientConstants { + + private WebSubClientConstants() { + } + + public static final String HUB_TOPIC = "hub.topic"; + public static final String HUB_MODE = "hub.mode"; + public static final String HUB_CALLBACK = "hub.callback"; + public static final String HUB_SECRET = "hub.secret"; + public static final String HUB_LEASE_SECONDS = "hub.lease_seconds"; + public static final String HUB_CHALLENGE = "hub.challenge"; + public static final String HUB_AUTHENTICATED_CONTENT_HEADER = "x-hub-signature"; +} diff --git a/src/main/java/io/mosip/print/constant/WebSubClientErrorCode.java b/src/main/java/io/mosip/print/constant/WebSubClientErrorCode.java new file mode 100644 index 00000000..a58e6332 --- /dev/null +++ b/src/main/java/io/mosip/print/constant/WebSubClientErrorCode.java @@ -0,0 +1,71 @@ +package io.mosip.print.constant; + +/** + * This {@link Enum} consist error codes for this api. + * + * @author Urvil Joshi + * + */ +public enum WebSubClientErrorCode { + + REGISTER_ERROR("KER-WSC-101", "Error occured while registering topic to hub :- "), + + UNREGISTER_ERROR("KER-WSC-102", "Error occured while unregistering topic to hub :- "), + + PUBLISH_ERROR("KER-WSC-103", "Error occured while publishing topic to hub :- "), + + NOTIFY_UPDATE_ERROR("KER-WSC-104", "Error occured while notify update topic to hub :- "), + + SUBSCRIBE_ERROR("KER-WSC-105", "Error occured while subscribing at hub :- "), + + AUTHENTTICATED_CONTENT_VERIFICATION_HEADER_ERROR("KER-WSC-106", "Error occured while verifing authenticated content :- header for signature is empty or null"), + + AUTHENTTICATED_CONTENT_ANNOTATION_SECRET_ERROR("KER-WSC-107", "Error occured while verifing authenticated content :- secret parameter for annotation preauthenticatecontent is empty"), + + AUTHENTTICATED_CONTENT_ERROR("KER-WSC-108", "Error occured while verifing authenticated content :- content signature is not maching"), + + IO_ERROR("KER-WSC-109", "IO error occurred :- "), + + INSTANCE_ERROR("KER-WSC-110","Error occured while verifing authenticated content :- Request should be HttpServletRequesttype"), + + INPUT_VERIFICATION_ERROR("KER-WSC-111","Error occured while verifingInput :- ") + ; + /** + * The error code + */ + private final String errorCode; + /** + * The error message + */ + private final String errorMessage; + + /** + * Constructor to set error code and message + * + * @param errorCode the error code + * @param errorMessage the error message + */ + private WebSubClientErrorCode(final String errorCode, final String errorMessage) { + this.errorCode = errorCode; + this.errorMessage = errorMessage; + } + + /** + * Function to get error code + * + * @return {@link #errorCode} + */ + public String getErrorCode() { + return errorCode; + } + + /** + * Function to get the error message + * + * @return {@link #errorMessage}r + */ + public String getErrorMessage() { + return errorMessage; + } + +} diff --git a/src/main/java/io/mosip/print/controller/Print.java b/src/main/java/io/mosip/print/controller/Print.java index 0fd3452d..d9265281 100644 --- a/src/main/java/io/mosip/print/controller/Print.java +++ b/src/main/java/io/mosip/print/controller/Print.java @@ -1,15 +1,8 @@ package io.mosip.print.controller; -import java.io.ByteArrayInputStream; -import java.io.IOException; -import java.nio.charset.Charset; -import java.util.HashMap; -import java.util.Map; - -import org.json.JSONObject; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; -import org.springframework.core.io.InputStreamResource; +import org.springframework.http.HttpStatus; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.annotation.PostMapping; @@ -17,11 +10,9 @@ import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; -import io.mosip.kernel.core.util.CryptoUtil; import io.mosip.kernel.websub.api.annotation.PreAuthenticateContentAndVerifyIntent; import io.mosip.print.exception.RegPrintAppException; import io.mosip.print.model.EventModel; -import io.mosip.print.model.MOSIPMessage; import io.mosip.print.service.PrintService; @RestController @@ -30,21 +21,12 @@ public class Print { /** The printservice. */ @Autowired - private PrintService> printService; + private PrintService printService; @Value("${mosip.event.topic}") private String topic; - @PostMapping(value = "/enqueue", consumes = "application/json") - @PreAuthenticateContentAndVerifyIntent(secret = "Kslk30SNF2AChs2", callback = "/print/enqueue", topic = "http://mosip.io/print/pdf") - public void printPost(@RequestBody MOSIPMessage message) { - System.out.println(message.getTopic()); - // TODO: Validate the MOSIPmessage - // TODO:Call the print service with the map that we received from MOSIPMessage - // printService.print() - } - /** * Gets the file. * @@ -53,40 +35,14 @@ public void printPost(@RequestBody MOSIPMessage message) { * @param errors the errors * @param printRequest the print request DTO * @return the file - * @throws IOException + * @throws Exception * @throws RegPrintAppException the reg print app exception */ @PostMapping(path = "/callback/notifyPrint", consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE) - @PreAuthenticateContentAndVerifyIntent(secret = "Kslk30SNF2AChs2", callback = "/v1/print/print/callback/notifyPrint", topic = "${mosip.event.topic}") - public ResponseEntity handleSubscribeEvent(@RequestBody EventModel eventModel) throws IOException { - String credential = eventModel.getEvent().getData().get("credential").toString(); - byte[] str1 = CryptoUtil.decodeBase64(credential); - String decodedCrdential = new String(str1, Charset.forName("UTF-8")); - JSONObject jsonObject = new JSONObject(decodedCrdential); - Map proofMap = new HashMap(); - proofMap = (Map) eventModel.getEvent().getData().get("proof"); - String sign = proofMap.get("signature").toString(); - byte[] pdfbytes = printService.getDocuments(decodedCrdential, eventModel.getEvent().getTransactionId(), - getSignature(sign, credential), "UIN", false) - .get("uinPdf"); - InputStreamResource resource = new InputStreamResource(new ByteArrayInputStream(pdfbytes)); - /* - * File pdfFile = new File( - * "/media/lenovo/872da60f-3c16-4cfb-b900-0f63cbe7f3a9/opt/projects/mosip/MajorBug/print/uin.pdf" - * ); OutputStream os = new FileOutputStream(pdfFile); os.write(pdfbytes); - * os.close(); - */ - return ResponseEntity.ok().contentType(MediaType.parseMediaType("application/pdf")) - .header("Content-Disposition", "attachment; filename=\"" + "uinCard" + ".pdf\"") - .body((Object) resource); - - } - - private String getSignature(String sign, String crdential) { - String signHeader = sign.split("\\.")[0]; - String signData = sign.split("\\.")[2]; - String signature = signHeader + "." + crdential + "." + signData; - return signature; + @PreAuthenticateContentAndVerifyIntent(secret = "${mosip.event.secret}", callback = "/v1/cardprint/print/callback/notifyPrint", topic = "${mosip.event.topic}") + public ResponseEntity handleSubscribeEvent(@RequestBody EventModel eventModel) throws Exception { + printService.generateCard(eventModel); + return new ResponseEntity<>("successfully printed", HttpStatus.OK); } } diff --git a/src/main/java/io/mosip/registration/print/core/http/RequestWrapper.java b/src/main/java/io/mosip/print/core/http/RequestWrapper.java similarity index 86% rename from src/main/java/io/mosip/registration/print/core/http/RequestWrapper.java rename to src/main/java/io/mosip/print/core/http/RequestWrapper.java index 40eab404..758f6190 100644 --- a/src/main/java/io/mosip/registration/print/core/http/RequestWrapper.java +++ b/src/main/java/io/mosip/print/core/http/RequestWrapper.java @@ -1,24 +1,24 @@ -package io.mosip.registration.print.core.http; - -import java.time.LocalDateTime; - -import javax.validation.Valid; -import javax.validation.constraints.NotNull; - -import com.fasterxml.jackson.annotation.JsonFormat; - -import lombok.Data; - -@Data -public class RequestWrapper { - private String id; - private String version; - @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'") - private LocalDateTime requesttime; - - private Object metadata; - - @NotNull - @Valid - private T request; -} +package io.mosip.print.core.http; + +import java.time.LocalDateTime; + +import javax.validation.Valid; +import javax.validation.constraints.NotNull; + +import com.fasterxml.jackson.annotation.JsonFormat; + +import lombok.Data; + +@Data +public class RequestWrapper { + private String id; + private String version; + @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'") + private LocalDateTime requesttime; + + private Object metadata; + + @NotNull + @Valid + private T request; +} diff --git a/src/main/java/io/mosip/registration/print/core/http/ResponseWrapper.java b/src/main/java/io/mosip/print/core/http/ResponseWrapper.java similarity index 89% rename from src/main/java/io/mosip/registration/print/core/http/ResponseWrapper.java rename to src/main/java/io/mosip/print/core/http/ResponseWrapper.java index fb08a4d1..25601a67 100644 --- a/src/main/java/io/mosip/registration/print/core/http/ResponseWrapper.java +++ b/src/main/java/io/mosip/print/core/http/ResponseWrapper.java @@ -1,30 +1,30 @@ -package io.mosip.registration.print.core.http; - -import java.time.LocalDateTime; -import java.time.ZoneId; -import java.util.ArrayList; -import java.util.List; - -import javax.validation.Valid; -import javax.validation.constraints.NotNull; - -import com.fasterxml.jackson.annotation.JsonFormat; - -import io.mosip.print.dto.ErrorDTO; -import lombok.Data; - +package io.mosip.print.core.http; + +import java.time.LocalDateTime; +import java.time.ZoneId; +import java.util.ArrayList; +import java.util.List; + +import javax.validation.Valid; +import javax.validation.constraints.NotNull; + +import com.fasterxml.jackson.annotation.JsonFormat; + +import io.mosip.print.dto.ErrorDTO; +import lombok.Data; + @Data -public class ResponseWrapper { - private String id; - private String version; - String str; - @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'") - private LocalDateTime responsetime = LocalDateTime.now(ZoneId.of("UTC")); - private Object metadata; - @NotNull - @Valid - private T response; - - private List errors = new ArrayList<>(); - -} +public class ResponseWrapper { + private String id; + private String version; + String str; + @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'") + private LocalDateTime responsetime = LocalDateTime.now(ZoneId.of("UTC")); + private Object metadata; + @NotNull + @Valid + private T response; + + private List errors = new ArrayList<>(); + +} diff --git a/src/main/java/io/mosip/print/dto/BaseRequestDTO.java b/src/main/java/io/mosip/print/dto/BaseRequestDTO.java new file mode 100644 index 00000000..68cd98a3 --- /dev/null +++ b/src/main/java/io/mosip/print/dto/BaseRequestDTO.java @@ -0,0 +1,16 @@ +package io.mosip.print.dto; + +import lombok.Data; +import lombok.Getter; +import lombok.Setter; + +@Data +@Getter +@Setter +public class BaseRequestDTO { + public String id; + public Metadata metadata; + public T request; + public String requesttime; + public String version; +} diff --git a/src/main/java/io/mosip/print/dto/BaseResponseDTO.java b/src/main/java/io/mosip/print/dto/BaseResponseDTO.java new file mode 100644 index 00000000..6f95592f --- /dev/null +++ b/src/main/java/io/mosip/print/dto/BaseResponseDTO.java @@ -0,0 +1,36 @@ +package io.mosip.print.dto; + +import lombok.Data; +import lombok.Getter; +import lombok.Setter; + +import java.util.Arrays; +import java.util.List; + +@Data +@Getter +@Setter +public class BaseResponseDTO { + + String id; + String version; + String responsetime; + String metadata; + T response; + Errors[] errors; + public Errors[] getErrors() { + if(errors != null) { + return Arrays.copyOf(errors, errors.length); + }else { + return null; + } + } + + public void setErrors(List errorsList) { + if (errorsList != null) { + errors = new Errors[errorsList.size()]; + for (int i = 0; i < errorsList.size(); i++) + errors[i] = errorsList.get(i); + } + } +} diff --git a/src/main/java/io/mosip/print/dto/CredentialRequestDto.java b/src/main/java/io/mosip/print/dto/CredentialRequestDto.java new file mode 100644 index 00000000..da7b3879 --- /dev/null +++ b/src/main/java/io/mosip/print/dto/CredentialRequestDto.java @@ -0,0 +1,32 @@ +package io.mosip.print.dto; + +import java.util.List; +import java.util.Map; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@AllArgsConstructor +@NoArgsConstructor +public class CredentialRequestDto { + + private String id; + + private String credentialType; + + private boolean encrypt; + + private String issuer; + + private String encryptionKey; + + private String recepiant; + + private String user; + + private List sharableAttributes; + + private Map additionalData; +} diff --git a/src/main/java/io/mosip/print/dto/CredentialResponseDto.java b/src/main/java/io/mosip/print/dto/CredentialResponseDto.java new file mode 100644 index 00000000..6a4a199d --- /dev/null +++ b/src/main/java/io/mosip/print/dto/CredentialResponseDto.java @@ -0,0 +1,14 @@ +package io.mosip.print.dto; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class CredentialResponseDto { + + private String id; + private String requestId; +} diff --git a/src/main/java/io/mosip/print/dto/CryptoWithPinRequestDto.java b/src/main/java/io/mosip/print/dto/CryptoWithPinRequestDto.java new file mode 100644 index 00000000..01b0e2ca --- /dev/null +++ b/src/main/java/io/mosip/print/dto/CryptoWithPinRequestDto.java @@ -0,0 +1,40 @@ +/* + * + * + * + * + */ +package io.mosip.print.dto; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +/** + * Crypto-With-Pin-Request model + * + * @author Mahammed Taheer + * + * @since 1.1.2 + */ +@Data +@AllArgsConstructor +@NoArgsConstructor +@ApiModel(description = "Model representing a Crypto-With-Pin-Service Request") +public class CryptoWithPinRequestDto { + + /** + * Data in String to encrypt/decrypt + */ + + @ApiModelProperty(notes = "Data in String to encrypt/decrypt", required = true) + private String data; + + /** + * Pin to be used for encrypt/decrypt + */ + @ApiModelProperty(notes = " Pin to be used for encrypt/decrypt", required = true, example = "A1234") + private String userPin; +} diff --git a/src/main/java/io/mosip/print/dto/CryptoWithPinResponseDto.java b/src/main/java/io/mosip/print/dto/CryptoWithPinResponseDto.java new file mode 100644 index 00000000..46f5d0d8 --- /dev/null +++ b/src/main/java/io/mosip/print/dto/CryptoWithPinResponseDto.java @@ -0,0 +1,32 @@ +/* + * + * + * + * + */ +package io.mosip.print.dto; + +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +/** + * Crypto-With-Pin-Response model + * + * @author Mahammed Taheer + * + * @since 1.1.2 + */ +@Data +@AllArgsConstructor +@NoArgsConstructor +@ApiModel(description = "Model representing a Crypto-With-Pin-Response Response") +public class CryptoWithPinResponseDto { + /** + * Data Encrypted/Decrypted in String + */ + @ApiModelProperty(notes = "Data encrypted/decrypted in String") + private String data; +} diff --git a/src/main/java/io/mosip/print/dto/DataShare.java b/src/main/java/io/mosip/print/dto/DataShare.java new file mode 100644 index 00000000..fcf78733 --- /dev/null +++ b/src/main/java/io/mosip/print/dto/DataShare.java @@ -0,0 +1,36 @@ +package io.mosip.print.dto; + +import lombok.Data; + + + +/** + * Instantiates a new data share. + */ + +/** + * Instantiates a new data share. + */ +@Data +public class DataShare { + + + /** The url. */ + private String url; + + /** The valid for in minutes. */ + private int validForInMinutes; + + /** The transactions allowed. */ + private int transactionsAllowed; + + /** The policy id. */ + private String policyId; + + /** The subscriber id. */ + private String subscriberId; + + /** The signature. */ + private String signature; + +} diff --git a/src/main/java/io/mosip/print/dto/DataShareResponseDto.java b/src/main/java/io/mosip/print/dto/DataShareResponseDto.java new file mode 100644 index 00000000..9f727569 --- /dev/null +++ b/src/main/java/io/mosip/print/dto/DataShareResponseDto.java @@ -0,0 +1,19 @@ +package io.mosip.print.dto; + +import java.util.List; + +import lombok.Data; +import lombok.EqualsAndHashCode; + +@Data +@EqualsAndHashCode(callSuper = true) +public class DataShareResponseDto extends BaseRestResponseDTO { + + private static final long serialVersionUID = 1L; + + + private DataShare dataShare; + + + private List errors; +} diff --git a/src/main/java/io/mosip/print/dto/Errors.java b/src/main/java/io/mosip/print/dto/Errors.java index b3fd2909..cce68093 100644 --- a/src/main/java/io/mosip/print/dto/Errors.java +++ b/src/main/java/io/mosip/print/dto/Errors.java @@ -1,12 +1,12 @@ package io.mosip.print.dto; -import lombok.Data; -import lombok.Getter; -import lombok.Setter; +import lombok.*; @Data @Getter @Setter +@AllArgsConstructor +@NoArgsConstructor public class Errors { String errorCode; String message; diff --git a/src/main/java/io/mosip/print/dto/IdResponseDTO1.java b/src/main/java/io/mosip/print/dto/IdResponseDTO1.java index d5e7de80..e79b397c 100644 --- a/src/main/java/io/mosip/print/dto/IdResponseDTO1.java +++ b/src/main/java/io/mosip/print/dto/IdResponseDTO1.java @@ -1,6 +1,6 @@ package io.mosip.print.dto; -import io.mosip.kernel.core.http.ResponseWrapper; +import io.mosip.print.core.http.ResponseWrapper; import lombok.Data; import lombok.EqualsAndHashCode; diff --git a/src/main/java/io/mosip/print/dto/MQResponseDto.java b/src/main/java/io/mosip/print/dto/MQResponseDto.java new file mode 100644 index 00000000..759602c4 --- /dev/null +++ b/src/main/java/io/mosip/print/dto/MQResponseDto.java @@ -0,0 +1,15 @@ +package io.mosip.print.dto; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.Getter; +import lombok.Setter; + +@Data +@Getter +@Setter +@AllArgsConstructor +public class MQResponseDto { + private String id; + private PrintStatusRequestDto data; +} diff --git a/src/main/java/io/mosip/print/dto/PrintMQData.java b/src/main/java/io/mosip/print/dto/PrintMQData.java new file mode 100644 index 00000000..9b0d55e2 --- /dev/null +++ b/src/main/java/io/mosip/print/dto/PrintMQData.java @@ -0,0 +1,13 @@ +package io.mosip.print.dto; + +import lombok.AllArgsConstructor; +import lombok.Data; + +@Data +@AllArgsConstructor +public class PrintMQData { + private String id; + private String refId; + private String printId; + private String data; +} diff --git a/src/main/java/io/mosip/print/dto/PrintMQDetails.java b/src/main/java/io/mosip/print/dto/PrintMQDetails.java new file mode 100644 index 00000000..0ef2655d --- /dev/null +++ b/src/main/java/io/mosip/print/dto/PrintMQDetails.java @@ -0,0 +1,19 @@ +package io.mosip.print.dto; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class PrintMQDetails { + private String name; + private String brokerUrl; + private String inboundQueueName; + private String outboundQueueName; + private String cardOutboundQueueName; + private String userName; + private String password; + private String typeOfQueue; +} diff --git a/src/main/java/io/mosip/print/dto/PrintStatusRequestDto.java b/src/main/java/io/mosip/print/dto/PrintStatusRequestDto.java new file mode 100644 index 00000000..9ef3db38 --- /dev/null +++ b/src/main/java/io/mosip/print/dto/PrintStatusRequestDto.java @@ -0,0 +1,16 @@ +package io.mosip.print.dto; + +import io.mosip.print.constant.PrintTransactionStatus; +import lombok.Data; +import lombok.Getter; + +import java.time.LocalDateTime; + +@Data +@Getter +public class PrintStatusRequestDto { + private String id; + private PrintTransactionStatus printStatus; + private String statusComments; + private String processedTime; +} diff --git a/src/main/java/io/mosip/print/dto/SignatureCertificate.java b/src/main/java/io/mosip/print/dto/SignatureCertificate.java new file mode 100644 index 00000000..2960200c --- /dev/null +++ b/src/main/java/io/mosip/print/dto/SignatureCertificate.java @@ -0,0 +1,68 @@ +package io.mosip.print.dto; + +import java.security.PrivateKey; +import java.security.cert.X509Certificate; +import java.time.LocalDateTime; + +import com.fasterxml.jackson.annotation.JsonFormat; +import com.fasterxml.jackson.annotation.JsonIgnore; + +import io.mosip.print.model.CertificateEntry; +import io.swagger.annotations.ApiModel; +import io.swagger.annotations.ApiModelProperty; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +/** + * Response class for Signature + * + * @author Urvil Joshi + * @since 1.0.0 + * + */ +@Data +@AllArgsConstructor +@NoArgsConstructor +@ApiModel(description = "Class representing a Signature Response") +public class SignatureCertificate { + + /** + * The string alias + */ + @JsonIgnore + private String alias; + + /** + * Field for public key + */ + @ApiModelProperty(notes = "Public key in BASE64 encoding format", required = true) + private CertificateEntry certificateEntry; + + /** + * Key creation time + */ + @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'") + @ApiModelProperty(notes = "Timestamp of issuance of public key", required = true) + private LocalDateTime issuedAt; + + /** + * Key expiry time + */ + @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'") + @ApiModelProperty(notes = "Timestamp of expiry of public key", required = true) + private LocalDateTime expiryAt; + + /** + * The string keystore provider name + */ + private String providerName; + + + @Override + public String toString() { + return "SignatureCertificate [alias=" + alias + ", certificateEntry=" + certificateEntry + ", issuedAt=" + + issuedAt + ", expiryAt=" + expiryAt + "]"; + } + +} diff --git a/src/main/java/io/mosip/print/entity/MspCardEntity.java b/src/main/java/io/mosip/print/entity/MspCardEntity.java new file mode 100644 index 00000000..197e8f29 --- /dev/null +++ b/src/main/java/io/mosip/print/entity/MspCardEntity.java @@ -0,0 +1,84 @@ +package io.mosip.print.entity; + +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; +import org.springframework.stereotype.Component; + +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Table; +import java.io.Serializable; +import java.time.LocalDateTime; +import java.util.Date; + +/** + * The persistent class Processed RegPrc print List database table. + * + * @author Thamaraikannan + * @since 1.0.0 + */ + +@Component +@Entity +@NoArgsConstructor +@Getter +@Setter +@Table(name = "msp_card", schema = "print") +public class MspCardEntity implements Serializable { + /** + * The Id. + */ + @Id + @Column(name = "id") + private String id; + + /** + * The Json Data. + */ + @Column(name = "json_data") + private String jsonData; + + /** + * The Province. + */ + @Column(name = "province") + private String province; + + @Column(name = "city") + private String city; + + @Column(name = "zone") + private String zone; + + @Column(name = "agegroup") + private Integer ageGroup; + + @Column(name = "introducer") + private String introducer; + + @Column(name = "resident") + private String resident; + + @Column(name = "registration_center_id") + private String registrationCenterId; + + @Column(name = "registration_date") + private LocalDateTime registrationDate; + + @Column(name = "download_date") + private LocalDateTime downloadDate; + + @Column(name = "request_id") + private String requestId; + + @Column(name = "status") + private Integer status; + + @Column(name = "request_id1") + private String requestId1; + + @Column(name = "birthdate") + private Date birthDate; +} diff --git a/src/main/java/io/mosip/print/exception/AccessDeniedException.java b/src/main/java/io/mosip/print/exception/AccessDeniedException.java index b56b738f..5ec74f50 100644 --- a/src/main/java/io/mosip/print/exception/AccessDeniedException.java +++ b/src/main/java/io/mosip/print/exception/AccessDeniedException.java @@ -1,6 +1,5 @@ package io.mosip.print.exception; -import io.mosip.kernel.core.exception.BaseUncheckedException; public class AccessDeniedException extends BaseUncheckedException { diff --git a/src/main/java/io/mosip/print/exception/ApiNotAccessibleException.java b/src/main/java/io/mosip/print/exception/ApiNotAccessibleException.java new file mode 100644 index 00000000..702c707a --- /dev/null +++ b/src/main/java/io/mosip/print/exception/ApiNotAccessibleException.java @@ -0,0 +1,32 @@ +package io.mosip.print.exception; + + + +public class ApiNotAccessibleException extends BaseCheckedException { + + /** + * + */ + private static final long serialVersionUID = 1L; + + public ApiNotAccessibleException() { + super(PlatformErrorMessages.API_NOT_ACCESSIBLE_EXCEPTION.getCode(), + PlatformErrorMessages.API_NOT_ACCESSIBLE_EXCEPTION.getMessage()); + } + + public ApiNotAccessibleException(String message) { + super(PlatformErrorMessages.API_NOT_ACCESSIBLE_EXCEPTION.getCode(), + message); + } + + public ApiNotAccessibleException(Throwable e) { + super(PlatformErrorMessages.API_NOT_ACCESSIBLE_EXCEPTION.getCode(), + PlatformErrorMessages.API_NOT_ACCESSIBLE_EXCEPTION.getMessage(), e); + } + + public ApiNotAccessibleException(String errorMessage, Throwable t) { + super(PlatformErrorMessages.API_NOT_ACCESSIBLE_EXCEPTION.getCode(), errorMessage, t); + } + + +} diff --git a/src/main/java/io/mosip/print/exception/ApisResourceAccessException.java b/src/main/java/io/mosip/print/exception/ApisResourceAccessException.java index 4f22cc2a..753b5df0 100644 --- a/src/main/java/io/mosip/print/exception/ApisResourceAccessException.java +++ b/src/main/java/io/mosip/print/exception/ApisResourceAccessException.java @@ -1,6 +1,5 @@ package io.mosip.print.exception; -import io.mosip.kernel.core.exception.BaseCheckedException; /** * The Class ApisResourceAccessException. diff --git a/src/main/java/io/mosip/print/exception/BaseCheckedException.java b/src/main/java/io/mosip/print/exception/BaseCheckedException.java new file mode 100644 index 00000000..7a4fa78f --- /dev/null +++ b/src/main/java/io/mosip/print/exception/BaseCheckedException.java @@ -0,0 +1,144 @@ +package io.mosip.print.exception; + +import java.util.ArrayList; +import java.util.List; + + +/** + * This is the base class for all MOSIP checked exceptions. + * + * The class and its subclasses are a form that indicates conditions that a + * reasonable application might want to catch. + * + *

+ * The class {@code BaseCheckedException} and any subclasses that are not also + * subclasses of {@link BaseUncheckedException} are checked exceptions. + * Checked exceptions need to be declared in a method or constructor's + * {@code throws} clause if they can be thrown by the execution of the method or + * constructor and propagate outside the method or constructor boundary. + * + * @author Shashank Agrawal + * @since 1.0 + * + */ +public class BaseCheckedException extends Exception { + + /** + * + */ + private static final long serialVersionUID = -924722202100630614L; + + private final List infoItems = new ArrayList<>(); + + /** + * Constructs a new checked exception + */ + public BaseCheckedException() { + super(); + } + + /** + * Constructs a new checked exception with errorMessage + * + * @param errorMessage the detail message. + */ + public BaseCheckedException(String errorMessage) { + super(errorMessage); + } + + /** + * Constructs a new checked exception with the specified detail message and + * error code. + * + * @param errorCode the error code + * @param errorMessage the detail message. + */ + public BaseCheckedException(String errorCode, String errorMessage) { + super(errorCode + " --> " + errorMessage); + addInfo(errorCode, errorMessage); + } + + /** + * Constructs a new checked exception with the specified detail message and + * error code and specified cause. + * + * @param errorCode the error code + * @param errorMessage the detail message. + * @param rootCause the specified cause + * + */ + public BaseCheckedException(String errorCode, String errorMessage, Throwable rootCause) { + super(errorCode + " --> " + errorMessage, rootCause); + addInfo(errorCode, errorMessage); + if (rootCause instanceof BaseCheckedException) { + BaseCheckedException bce = (BaseCheckedException) rootCause; + infoItems.addAll(bce.infoItems); + } + } + + /** + * This method add error code and error message. + * + * @param errorCode the error code + * @param errorText the detail message. + * + * @return the current instance of BaseCheckedException + */ + public BaseCheckedException addInfo(String errorCode, String errorText) { + this.infoItems.add(new InfoItem(errorCode, errorText)); + return this; + } + + /* + * Returns a String object that can be used to get the exception message. + * + * @see java.lang.Throwable#getMessage() + */ + @Override + public String getMessage() { + return ExceptionUtils.buildMessage(super.getMessage(), getCause()); + } + + /** + * Returns the list of exception codes. + * + * @return list of exception codes + */ + public List getCodes() { + List codes = new ArrayList<>(); + for (int i = this.infoItems.size() - 1; i >= 0; i--) + codes.add(this.infoItems.get(i).errorCode); + return codes; + } + + /** + * Returns the list of exception messages. + * + * @return list of exception messages + */ + public List getErrorTexts() { + List errorTexts = new ArrayList<>(); + for (int i = this.infoItems.size() - 1; i >= 0; i--) + errorTexts.add(this.infoItems.get(i).errorText); + return errorTexts; + } + + /** + * Return the last error code. + * + * @return the last error code + */ + public String getErrorCode() { + return infoItems.get(0).errorCode; + } + + /** + * Return the last exception message. + * + * @return the last exception message + */ + public String getErrorText() { + return infoItems.get(0).errorText; + } + +} \ No newline at end of file diff --git a/src/main/java/io/mosip/print/exception/BaseUncheckedException.java b/src/main/java/io/mosip/print/exception/BaseUncheckedException.java new file mode 100644 index 00000000..89f68de6 --- /dev/null +++ b/src/main/java/io/mosip/print/exception/BaseUncheckedException.java @@ -0,0 +1,149 @@ +package io.mosip.print.exception; + +import java.util.ArrayList; +import java.util.List; + + +/** + * This is the base class for all MOSIP unchecked exceptions. + * + * {@code BaseUncheckedException} is the superclass of those exceptions that can + * be thrown during the normal operation of the Java Virtual Machine. + * + *

+ * {@code RuntimeException} and its subclasses are unchecked + * exceptions. Unchecked exceptions do not need to be declared in + * a method or constructor's {@code throws} clause if they can be thrown by the + * execution of the method or constructor and propagate outside the method or + * constructor boundary. + * + * @author Shashank Agrawal Compile-Time Checking of Exceptions + * @since 1.0 + */ +public class BaseUncheckedException extends RuntimeException { + + /** + * + */ + private static final long serialVersionUID = -875003872780128394L; + public static final String EMPTY_SPACE = " "; + private final List infoItems = new ArrayList<>(); + + /** + * Constructs a new unchecked exception + */ + public BaseUncheckedException() { + super(); + } + + /** + * Constructs a new checked exception with errorMessage + * + * @param errorMessage the detail message. + */ + public BaseUncheckedException(String errorMessage) { + super(errorMessage); + } + + /** + * Constructs a new unchecked exception with the specified detail message and + * error code. + * + * @param errorMessage the detail message. + * @param errorCode the error code. + * + */ + public BaseUncheckedException(String errorCode, String errorMessage) { + super(errorCode + " --> " + errorMessage); + addInfo(errorCode, errorMessage); + } + + /** + * Constructs a new unchecked exception with the specified detail message and + * error code and error cause. + * + * + * @param errorCode the error code + * @param errorMessage the detail message. + * @param rootCause the specified cause + */ + public BaseUncheckedException(String errorCode, String errorMessage, Throwable rootCause) { + super(errorCode + " --> " + errorMessage, rootCause); + addInfo(errorCode, errorMessage); + if (rootCause instanceof BaseUncheckedException) { + BaseUncheckedException bue = (BaseUncheckedException) rootCause; + infoItems.addAll(bue.infoItems); + } + } + + /* + * Returns a String object that can be used to get the exception message. + * + * @see java.lang.Throwable#getMessage() + */ + @Override + public String getMessage() { + return ExceptionUtils.buildMessage(super.getMessage(), getCause()); + } + + /** + * This method add the information of error code and error message. + * + * @param errorCode the error code + * @param errorText the detail message. + * @return the instance of current BaseCheckedException + */ + public BaseUncheckedException addInfo(String errorCode, String errorText) { + this.infoItems.add(new InfoItem(errorCode, errorText)); + return this; + } + + /** + * Returns the list of error codes. + * + * @return the list of error codes + */ + public List getCodes() { + List codes = new ArrayList<>(); + + for (int i = this.infoItems.size() - 1; i >= 0; i--) { + codes.add(this.infoItems.get(i).errorCode); + } + + return codes; + } + + /** + * Returns the list of exception messages. + * + * @return the list of exception messages + */ + public List getErrorTexts() { + List errorTexts = new ArrayList<>(); + + for (int i = this.infoItems.size() - 1; i >= 0; i--) { + errorTexts.add(this.infoItems.get(i).errorText); + } + + return errorTexts; + } + + /** + * Return the last error code. + * + * @return the last error code + */ + public String getErrorCode() { + return infoItems.get(0).errorCode; + } + + /** + * Return the last exception message. + * + * @return the last exception message + */ + public String getErrorText() { + return infoItems.get(0).errorText; + } + +} diff --git a/src/main/java/io/mosip/print/exception/BiometricException.java b/src/main/java/io/mosip/print/exception/BiometricException.java new file mode 100644 index 00000000..84041eea --- /dev/null +++ b/src/main/java/io/mosip/print/exception/BiometricException.java @@ -0,0 +1,37 @@ +package io.mosip.print.exception; + + +/** + * The Class BiometricException. + * + * @author Sanjay Murali + */ +public class BiometricException extends BaseCheckedException { + + /** The Constant serialVersionUID. */ + private static final long serialVersionUID = -9125558120446752522L; + + /** + * Instantiates a new biometric exception. + * + * @param errorCode the error code + * @param errorMessage the error message + * @param rootCause the root cause + */ + public BiometricException(String errorCode, String errorMessage, Throwable rootCause) { + super(errorCode, errorMessage, rootCause); + + } + + /** + * Instantiates a new biometric exception. + * + * @param errorCode the error code + * @param errorMessage the error message + */ + public BiometricException(String errorCode, String errorMessage) { + super(errorCode, errorMessage); + + } + +} diff --git a/src/main/java/io/mosip/print/exception/BiometricTagMatchException.java b/src/main/java/io/mosip/print/exception/BiometricTagMatchException.java index 67a6f8aa..1e2b8ed3 100644 --- a/src/main/java/io/mosip/print/exception/BiometricTagMatchException.java +++ b/src/main/java/io/mosip/print/exception/BiometricTagMatchException.java @@ -1,6 +1,5 @@ package io.mosip.print.exception; -import io.mosip.kernel.core.exception.BaseUncheckedException; public class BiometricTagMatchException extends BaseUncheckedException { diff --git a/src/main/java/io/mosip/print/exception/CbeffException.java b/src/main/java/io/mosip/print/exception/CbeffException.java new file mode 100644 index 00000000..c85a5d78 --- /dev/null +++ b/src/main/java/io/mosip/print/exception/CbeffException.java @@ -0,0 +1,19 @@ +/** + * + */ +package io.mosip.print.exception; + +/** + * @author Ramadurai Pandian + * + * A Custom exception class + */ +public class CbeffException extends Exception { + + private static final long serialVersionUID = 9190616446912282298L; + + public CbeffException(String message) { + super(message); + } + +} diff --git a/src/main/java/io/mosip/print/exception/CryptoManagerException.java b/src/main/java/io/mosip/print/exception/CryptoManagerException.java new file mode 100644 index 00000000..1401d075 --- /dev/null +++ b/src/main/java/io/mosip/print/exception/CryptoManagerException.java @@ -0,0 +1,39 @@ +package io.mosip.print.exception; + + +public class CryptoManagerException extends BaseUncheckedException { + + /** The Constant serialVersionUID. */ + private static final long serialVersionUID = 1L; + + /** + * Instantiates a new access denied exception. + */ + public CryptoManagerException() { + super(); + + } + + /** + * Instantiates a new access denied exception. + * + * @param message the message + */ + public CryptoManagerException(String message) { + super(PlatformErrorMessages.PRT_AUT_ACCESS_DENIED.getCode(), message); + } + + public CryptoManagerException(String message, String message1) { + super(PlatformErrorMessages.PRT_AUT_ACCESS_DENIED.getCode(), message); + } + + /** + * Instantiates a new access denied exception. + * + * @param message the message + * @param cause the cause + */ + public CryptoManagerException(String message, String message1, Throwable cause) { + super(PlatformErrorMessages.PRT_AUT_ACCESS_DENIED.getCode(), message, cause); + } +} diff --git a/src/main/java/io/mosip/print/exception/DataShareException.java b/src/main/java/io/mosip/print/exception/DataShareException.java new file mode 100644 index 00000000..499226a8 --- /dev/null +++ b/src/main/java/io/mosip/print/exception/DataShareException.java @@ -0,0 +1,30 @@ +package io.mosip.print.exception; + + +public class DataShareException extends BaseCheckedException { + + /** + * + */ + private static final long serialVersionUID = 1L; + + public DataShareException() { + super(PlatformErrorMessages.DATASHARE_EXCEPTION.getCode(), + PlatformErrorMessages.DATASHARE_EXCEPTION.getMessage()); + } + + public DataShareException(String message) { + super(PlatformErrorMessages.DATASHARE_EXCEPTION.getCode(), + message); + } + + public DataShareException(Throwable e) { + super(PlatformErrorMessages.DATASHARE_EXCEPTION.getCode(), + PlatformErrorMessages.DATASHARE_EXCEPTION.getMessage(), e); + } + + public DataShareException(String errorMessage, Throwable t) { + super(PlatformErrorMessages.DATASHARE_EXCEPTION.getCode(), errorMessage, t); + } + +} diff --git a/src/main/java/io/mosip/print/exception/DigitalSignatureException.java b/src/main/java/io/mosip/print/exception/DigitalSignatureException.java index ae279095..4ee7d357 100644 --- a/src/main/java/io/mosip/print/exception/DigitalSignatureException.java +++ b/src/main/java/io/mosip/print/exception/DigitalSignatureException.java @@ -1,6 +1,5 @@ package io.mosip.print.exception; -import io.mosip.kernel.core.exception.BaseUncheckedException; public class DigitalSignatureException extends BaseUncheckedException { diff --git a/src/main/java/io/mosip/print/exception/ExceptionUtils.java b/src/main/java/io/mosip/print/exception/ExceptionUtils.java new file mode 100644 index 00000000..d77d6938 --- /dev/null +++ b/src/main/java/io/mosip/print/exception/ExceptionUtils.java @@ -0,0 +1,81 @@ +package io.mosip.print.exception; + +import java.io.PrintWriter; +import java.io.StringWriter; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.fasterxml.jackson.databind.JsonNode; + +/** + * This utils contains exception utilities. + * + * @author Shashank Agrawal + * @author Ritesh Sinha + * @since 1.0.0 + * + */ +public final class ExceptionUtils { + + private static final Logger logger = LoggerFactory.getLogger(ExceptionUtils.class); + + private ExceptionUtils() { + + } + + /** + * Returns an String object that can be used after building the exception stack + * trace. + * + * @param message the exception message + * @param cause the cause + * @return the exception stack + */ + public static String buildMessage(String message, Throwable cause) { + if (cause != null) { + StringBuilder sb = new StringBuilder(); + if (message != null) { + sb.append(message).append("; "); + } + sb.append("\n"); + sb.append("nested exception is ").append(cause); + return sb.toString(); + } else { + return message; + } + } + + /** + * This method returns the stack trace + * + * @param throwable the exception to be added to the list of exception + * @return the stack trace + */ + public static String getStackTrace(Throwable throwable) { + StringWriter sw = new StringWriter(); + PrintWriter pw = new PrintWriter(sw, true); + throwable.printStackTrace(pw); + return sw.getBuffer().toString(); + } + + + /** + * This method provide jsonvalue based on propname mention. + * + * @param node the jsonnode. + * @param propName the property name. + * @return the property value. + */ + private static String getJsonValue(JsonNode node, String propName) { + if (node.get(propName) != null) { + return node.get(propName).asText(); + } + return null; + } + + public static void logRootCause(Throwable exception) { + logger.error("Exception Root Cause: {} ", exception.getMessage()); + logger.debug("Exception Root Cause:", exception); + } +} diff --git a/src/main/java/io/mosip/print/exception/FieldNotFoundException.java b/src/main/java/io/mosip/print/exception/FieldNotFoundException.java index 17ee9d4c..254d0fb8 100644 --- a/src/main/java/io/mosip/print/exception/FieldNotFoundException.java +++ b/src/main/java/io/mosip/print/exception/FieldNotFoundException.java @@ -1,6 +1,5 @@ package io.mosip.print.exception; -import io.mosip.kernel.core.exception.BaseUncheckedException; /** * The Class FieldNotFoundException. diff --git a/src/main/java/io/mosip/print/exception/IdRepoAppException.java b/src/main/java/io/mosip/print/exception/IdRepoAppException.java index 523f15da..dbf0550e 100644 --- a/src/main/java/io/mosip/print/exception/IdRepoAppException.java +++ b/src/main/java/io/mosip/print/exception/IdRepoAppException.java @@ -1,6 +1,5 @@ package io.mosip.print.exception; -import io.mosip.kernel.core.exception.BaseUncheckedException; public class IdRepoAppException extends BaseUncheckedException { diff --git a/src/main/java/io/mosip/print/exception/IdentityNotFoundException.java b/src/main/java/io/mosip/print/exception/IdentityNotFoundException.java index 90be38f0..e10ab0cf 100644 --- a/src/main/java/io/mosip/print/exception/IdentityNotFoundException.java +++ b/src/main/java/io/mosip/print/exception/IdentityNotFoundException.java @@ -1,6 +1,5 @@ package io.mosip.print.exception; -import io.mosip.kernel.core.exception.BaseUncheckedException; /** * The Class IdentityNotFoundException. diff --git a/src/main/java/io/mosip/print/exception/IllegalArgumentException.java b/src/main/java/io/mosip/print/exception/IllegalArgumentException.java new file mode 100644 index 00000000..7da4c963 --- /dev/null +++ b/src/main/java/io/mosip/print/exception/IllegalArgumentException.java @@ -0,0 +1,27 @@ +package io.mosip.print.exception; + +/** + * Base class for all preconditions violation exceptions. + * + * @author Ritesh Sinha + * @author Sidhant Agarwal + * @author Sagar Mahapatra + * @author Ravi Balaji + * @author Priya Soni + * @since 1.0.0 + */ +public class IllegalArgumentException extends BaseUncheckedException { + /** Serializable version Id. */ + private static final long serialVersionUID = 924722202110630628L; + + public IllegalArgumentException(String errorCode, String errorMessage) { + super(errorCode, errorMessage); + + } + + public IllegalArgumentException(String errorCode, String errorMessage, Throwable cause) { + super(errorCode, errorMessage, cause); + + } + +} diff --git a/src/main/java/io/mosip/print/exception/InfoItem.java b/src/main/java/io/mosip/print/exception/InfoItem.java new file mode 100644 index 00000000..ef2422ca --- /dev/null +++ b/src/main/java/io/mosip/print/exception/InfoItem.java @@ -0,0 +1,31 @@ +package io.mosip.print.exception; + +import java.io.Serializable; + +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +/** + * This class is the entity class for the BaseUncheckedException and + * BaseCheckedException class. + * + * @author Shashank Agrawal + * @since 1.0 + */ +@AllArgsConstructor +@NoArgsConstructor +class InfoItem implements Serializable { + + private static final long serialVersionUID = -779695043380592601L; + + @Getter + @Setter + public String errorCode = null; + + @Getter + @Setter + public String errorText = null; + +} diff --git a/src/main/java/io/mosip/print/exception/InstantanceCreationException.java b/src/main/java/io/mosip/print/exception/InstantanceCreationException.java index 0ffe3572..8fa8f0f7 100644 --- a/src/main/java/io/mosip/print/exception/InstantanceCreationException.java +++ b/src/main/java/io/mosip/print/exception/InstantanceCreationException.java @@ -1,6 +1,5 @@ package io.mosip.print.exception; -import io.mosip.kernel.core.exception.BaseUncheckedException; /** * The Class InstantanceCreationException. diff --git a/src/main/java/io/mosip/print/exception/InvalidInputException.java b/src/main/java/io/mosip/print/exception/InvalidInputException.java new file mode 100644 index 00000000..a45f4d06 --- /dev/null +++ b/src/main/java/io/mosip/print/exception/InvalidInputException.java @@ -0,0 +1,28 @@ +package io.mosip.print.exception; + + +/** + * Class which covers the range of exception which occurs when invalid input + * + * @author Urvil Joshi + * + * @since 1.0.0 + */ +public class InvalidInputException extends BaseUncheckedException { + + /** + * Unique id for serialization + */ + private static final long serialVersionUID = -5350213197226295789L; + + /** + * Constructor with errorCode, and errorMessage + * + * @param errorCode The error code for this exception + * @param errorMessage The error message for this exception + */ + public InvalidInputException(String errorCode, String errorMessage) { + super(errorCode, errorMessage); + } + +} diff --git a/src/main/java/io/mosip/print/exception/InvalidTokenException.java b/src/main/java/io/mosip/print/exception/InvalidTokenException.java index 475ec267..c7daa880 100644 --- a/src/main/java/io/mosip/print/exception/InvalidTokenException.java +++ b/src/main/java/io/mosip/print/exception/InvalidTokenException.java @@ -1,6 +1,5 @@ package io.mosip.print.exception; -import io.mosip.kernel.core.exception.BaseUncheckedException; public class InvalidTokenException extends BaseUncheckedException { diff --git a/src/main/java/io/mosip/print/exception/NullPointerException.java b/src/main/java/io/mosip/print/exception/NullPointerException.java new file mode 100644 index 00000000..d45e87b8 --- /dev/null +++ b/src/main/java/io/mosip/print/exception/NullPointerException.java @@ -0,0 +1,37 @@ +package io.mosip.print.exception; + +/** + * Exception to be thrown when a null argument found. + * + * @author Urvil Joshi + * @author Ritesh Sinha + * @author Sagar Mahapatra + * @author Priya Soni + * @since 1.0.0 + */ +public class NullPointerException extends BaseUncheckedException { + + /** Serializable version Id. */ + private static final long serialVersionUID = 784321102100630614L; + + /** + * Constructor with errorCode, and rootCause + * + * @param errorCode The error code for this exception + * @param errorMessage The error message for this exception + */ + public NullPointerException(String errorCode, String errorMessage) { + super(errorCode, errorMessage); + } + + /** + * @param arg0 Error Code Corresponds to Particular Exception + * @param arg1 Message providing the specific context of the error. + * @param arg2 Cause of exception + */ + public NullPointerException(String arg0, String arg1, Throwable arg2) { + super(arg0, arg1, arg2); + + } + +} diff --git a/src/main/java/io/mosip/print/exception/PDFGeneratorException.java b/src/main/java/io/mosip/print/exception/PDFGeneratorException.java new file mode 100644 index 00000000..08ef7f27 --- /dev/null +++ b/src/main/java/io/mosip/print/exception/PDFGeneratorException.java @@ -0,0 +1,35 @@ +package io.mosip.print.exception; + +/** + * + * + * @author M1046571 + * @since 1.0.0 + * + */ + +public class PDFGeneratorException extends BaseUncheckedException { + + private static final long serialVersionUID = -6138841548758442351L; + + /** + * Constructor for PDFGeneratorGenericException + * + * @param errorCode The errorcode + * @param errorMessage The errormessage + * @param cause The cause + */ + public PDFGeneratorException(String errorCode, String errorMessage, Throwable cause) { + super(errorCode, errorMessage, cause); + } + + /** + * Constructor for PDFGeneratorGenericException + * + * @param errorCode The errorcode + * @param errorMessage The errormessage + */ + public PDFGeneratorException(String errorCode, String errorMessage) { + super(errorCode, errorMessage); + } +} diff --git a/src/main/java/io/mosip/print/exception/PDFSignatureException.java b/src/main/java/io/mosip/print/exception/PDFSignatureException.java index 35b8261d..06cbd888 100644 --- a/src/main/java/io/mosip/print/exception/PDFSignatureException.java +++ b/src/main/java/io/mosip/print/exception/PDFSignatureException.java @@ -1,6 +1,5 @@ package io.mosip.print.exception; -import io.mosip.kernel.core.exception.BaseUncheckedException; public class PDFSignatureException extends BaseUncheckedException{ diff --git a/src/main/java/io/mosip/print/exception/ParseException.java b/src/main/java/io/mosip/print/exception/ParseException.java new file mode 100644 index 00000000..c38d0e0e --- /dev/null +++ b/src/main/java/io/mosip/print/exception/ParseException.java @@ -0,0 +1,22 @@ +package io.mosip.print.exception; + +/** + * Signals that an error has been reached unexpectedly while parsing. + * + * @author Bal Vikash Sharma + * @since 1.0.0 + */ +public class ParseException extends BaseUncheckedException { + private static final long serialVersionUID = 924722202110630628L; + + public ParseException(String errorCode, String errorMessage) { + super(errorCode, errorMessage); + + } + + public ParseException(String errorCode, String errorMessage, Throwable cause) { + super(errorCode, errorMessage, cause); + + } + +} diff --git a/src/main/java/io/mosip/print/exception/ParsingException.java b/src/main/java/io/mosip/print/exception/ParsingException.java index 758d5c62..4ec1ca66 100644 --- a/src/main/java/io/mosip/print/exception/ParsingException.java +++ b/src/main/java/io/mosip/print/exception/ParsingException.java @@ -1,6 +1,5 @@ package io.mosip.print.exception; -import io.mosip.kernel.core.exception.BaseUncheckedException; /** * The Class ParsingException. diff --git a/src/main/java/io/mosip/print/exception/PlatformErrorMessages.java b/src/main/java/io/mosip/print/exception/PlatformErrorMessages.java index 7fbb0d7e..530bebe7 100644 --- a/src/main/java/io/mosip/print/exception/PlatformErrorMessages.java +++ b/src/main/java/io/mosip/print/exception/PlatformErrorMessages.java @@ -65,9 +65,14 @@ public enum PlatformErrorMessages { PRT_PIS_IDENTITY_NOT_FOUND(PlatformConstants.PRT_PRINT_PREFIX + "002", "Unable to Find Identity Field in ID JSON"), /** Access denied for the token present. */ - PRT_AUT_ACCESS_DENIED(PlatformConstants.PRT_PRINT_PREFIX + "02", "Access Denied For Role - %s"); + PRT_AUT_ACCESS_DENIED(PlatformConstants.PRT_PRINT_PREFIX + "02", "Access Denied For Role - %s"), + DATASHARE_EXCEPTION(PlatformConstants.PRT_PRINT_PREFIX + "025", "Data share api failure"), + API_NOT_ACCESSIBLE_EXCEPTION(PlatformConstants.PRT_PRINT_PREFIX + "026", "Api not accessible failure"), + CERTIFICATE_THUMBPRINT_ERROR(PlatformConstants.PRT_PRINT_PREFIX + "026", "certificate thumbprint failure"), + PRT_INVALID_KEY_EXCEPTION(PlatformConstants.PRT_PRINT_PREFIX + "027", "invalid key"); + /** The error message. */ private final String errorMessage; diff --git a/src/main/java/io/mosip/print/exception/QrcodeGenerationException.java b/src/main/java/io/mosip/print/exception/QrcodeGenerationException.java new file mode 100644 index 00000000..43d41e80 --- /dev/null +++ b/src/main/java/io/mosip/print/exception/QrcodeGenerationException.java @@ -0,0 +1,29 @@ +package io.mosip.print.exception; + +/** + * A base class which covers the range of exceptions which may occur when + * encoding a QRcode using the Writer framework. + * + * @author Urvil Joshi + * + * @since 1.0.0 + */ +public class QrcodeGenerationException extends BaseCheckedException { + + /** + * Unique id for serialization + */ + private static final long serialVersionUID = 473719335574042491L; + + /** + * Constructor with errorCode, errorMessage, and rootCause + * + * @param errorCode The error code for this exception + * @param errorMessage The error message for this exception + * @param rootCause Cause of this exception + */ + public QrcodeGenerationException(String errorCode, String errorMessage, Throwable rootCause) { + super(errorCode, errorMessage, rootCause); + } + +} diff --git a/src/main/java/io/mosip/print/exception/RegPrintAppException.java b/src/main/java/io/mosip/print/exception/RegPrintAppException.java index f174dfb2..4bd20d90 100644 --- a/src/main/java/io/mosip/print/exception/RegPrintAppException.java +++ b/src/main/java/io/mosip/print/exception/RegPrintAppException.java @@ -1,6 +1,5 @@ package io.mosip.print.exception; -import io.mosip.kernel.core.exception.BaseCheckedException; /** * The Class RegPrintAppException. diff --git a/src/main/java/io/mosip/print/exception/RegStatusAppException.java b/src/main/java/io/mosip/print/exception/RegStatusAppException.java index e4e4731d..265a7303 100644 --- a/src/main/java/io/mosip/print/exception/RegStatusAppException.java +++ b/src/main/java/io/mosip/print/exception/RegStatusAppException.java @@ -1,7 +1,5 @@ package io.mosip.print.exception; -import io.mosip.kernel.core.exception.BaseCheckedException; -import io.mosip.print.exception.PlatformErrorMessages; /** * The Class RegStatusAppException. diff --git a/src/main/java/io/mosip/print/exception/TemplateMethodInvocationException.java b/src/main/java/io/mosip/print/exception/TemplateMethodInvocationException.java new file mode 100644 index 00000000..74aa4564 --- /dev/null +++ b/src/main/java/io/mosip/print/exception/TemplateMethodInvocationException.java @@ -0,0 +1,37 @@ +package io.mosip.print.exception; + + +/** + * TemplateMethodInvocationException when reference method in template could not + * be invoked. + * + * @author Abhishek Kumar + * @version 1.0.0 + * @since 2018-10-1 + */ +public class TemplateMethodInvocationException extends BaseUncheckedException { + + private static final long serialVersionUID = 6360842063626691912L; + + /** + * Constructor for set error code and message + * + * @param errorCode the error code + * @param errorMessage the error message + */ + public TemplateMethodInvocationException(String errorCode, String errorMessage) { + super(errorCode, errorMessage); + } + + /** + * Constructor for setting error code, message and cause + * + * @param errorCode the error code + * @param errorMessage the error message + * @param rootCause the specified cause + */ + public TemplateMethodInvocationException(String errorCode, String errorMessage, Throwable rootCause) { + super(errorCode, errorMessage, rootCause); + } + +} diff --git a/src/main/java/io/mosip/print/exception/TemplateParsingException.java b/src/main/java/io/mosip/print/exception/TemplateParsingException.java new file mode 100644 index 00000000..0974704e --- /dev/null +++ b/src/main/java/io/mosip/print/exception/TemplateParsingException.java @@ -0,0 +1,40 @@ +package io.mosip.print.exception; + + +/** + * this exception thrown when a resource of any type has a syntax or other error + * which prevents it from being parsed.
+ * When this resource is thrown, a best effort will be made to have useful + * information in the exception's message. For complete information, consult the + * runtime log. + * + * @author Abhishek Kumar + * @version 1.0.0 + * @since 2018-10-4 + */ +public class TemplateParsingException extends BaseUncheckedException { + + private static final long serialVersionUID = 1368132089641129425L; + + /** + * Constructor for set error code and message + * + * @param errorCode the error code + * @param errorMessage the error message + */ + public TemplateParsingException(String errorCode, String errorMessage) { + super(errorCode, errorMessage); + } + + /** + * Constructor for setting error code, message and cause + * + * @param errorCode the error code + * @param errorMessage the error message + * @param rootCause the specified cause + */ + public TemplateParsingException(String errorCode, String errorMessage, Throwable rootCause) { + super(errorCode, errorMessage, rootCause); + } + +} diff --git a/src/main/java/io/mosip/print/exception/TemplateProcessingFailureException.java b/src/main/java/io/mosip/print/exception/TemplateProcessingFailureException.java index 904cd5ec..37524871 100644 --- a/src/main/java/io/mosip/print/exception/TemplateProcessingFailureException.java +++ b/src/main/java/io/mosip/print/exception/TemplateProcessingFailureException.java @@ -1,6 +1,5 @@ package io.mosip.print.exception; -import io.mosip.kernel.core.exception.BaseUncheckedException; /** * The Class TemplateProcessingFailureException. diff --git a/src/main/java/io/mosip/print/exception/TemplateResourceNotFoundException.java b/src/main/java/io/mosip/print/exception/TemplateResourceNotFoundException.java new file mode 100644 index 00000000..2e112c09 --- /dev/null +++ b/src/main/java/io/mosip/print/exception/TemplateResourceNotFoundException.java @@ -0,0 +1,38 @@ +package io.mosip.print.exception; + + +/** + * this exception thrown when a resource of any type isn't found by the template + * manager.
+ * When this exception is thrown, a best effort will be made to have useful + * information in the exception's message. For complete information, consult the + * runtime log. + * + * @author Abhishek Kumar + * @version 1.0.0 + * @since 2018-10-1 + */ +public class TemplateResourceNotFoundException extends BaseUncheckedException { + + private static final long serialVersionUID = 3070414901455295210L; + + /** + * Constructor for set error code and message + * + * @param errorCode the error code + * @param errorMessage the error message + */ + public TemplateResourceNotFoundException(String errorCode, String errorMessage) { + super(errorCode, errorMessage); + } + + /** + * @param errorCode the error code + * @param errorMessage the error message + * @param rootCause cause of the error + */ + public TemplateResourceNotFoundException(String errorCode, String errorMessage, Throwable rootCause) { + super(errorCode, errorMessage, rootCause); + } + +} diff --git a/src/main/java/io/mosip/print/exception/TokenGenerationFailedException.java b/src/main/java/io/mosip/print/exception/TokenGenerationFailedException.java index 495a1834..6a626632 100644 --- a/src/main/java/io/mosip/print/exception/TokenGenerationFailedException.java +++ b/src/main/java/io/mosip/print/exception/TokenGenerationFailedException.java @@ -1,7 +1,5 @@ package io.mosip.print.exception; -import io.mosip.kernel.core.exception.BaseUncheckedException; - public class TokenGenerationFailedException extends BaseUncheckedException { /** The Constant serialVersionUID. */ diff --git a/src/main/java/io/mosip/print/exception/UINNotFoundInDatabase.java b/src/main/java/io/mosip/print/exception/UINNotFoundInDatabase.java index 94176b1a..abc1b138 100644 --- a/src/main/java/io/mosip/print/exception/UINNotFoundInDatabase.java +++ b/src/main/java/io/mosip/print/exception/UINNotFoundInDatabase.java @@ -1,6 +1,5 @@ package io.mosip.print.exception; -import io.mosip.kernel.core.exception.BaseUncheckedException; public class UINNotFoundInDatabase extends BaseUncheckedException{ diff --git a/src/main/java/io/mosip/print/exception/VidCreationException.java b/src/main/java/io/mosip/print/exception/VidCreationException.java index 6ac61a2c..636d19b1 100644 --- a/src/main/java/io/mosip/print/exception/VidCreationException.java +++ b/src/main/java/io/mosip/print/exception/VidCreationException.java @@ -1,6 +1,5 @@ package io.mosip.print.exception; -import io.mosip.kernel.core.exception.BaseCheckedException; public class VidCreationException extends BaseCheckedException { diff --git a/src/main/java/io/mosip/print/exception/WebSubClientException.java b/src/main/java/io/mosip/print/exception/WebSubClientException.java new file mode 100644 index 00000000..3eba6323 --- /dev/null +++ b/src/main/java/io/mosip/print/exception/WebSubClientException.java @@ -0,0 +1,35 @@ +package io.mosip.print.exception; + +/** + * This class act as a generic exception for this api. + * + * @author Urvil Joshi + * + */ +public class WebSubClientException extends BaseUncheckedException { + + /** + * Generated serial version id + */ + private static final long serialVersionUID = 8621530697947108810L; + + /** + * Constructor the initialize Handler exception + * + * @param errorCode The errorcode for this exception + * @param errorMessage The error message for this exception + */ + public WebSubClientException(String errorCode, String errorMessage) { + super(errorCode, errorMessage); + } + + /** + * @param errorCode The errorcode for this exception + * @param errorMessage The error message for this exception + * @param rootCause cause of the error occoured + */ + public WebSubClientException(String errorCode, String errorMessage, Throwable rootCause) { + super(errorCode, errorMessage, rootCause); + } + +} diff --git a/src/main/java/io/mosip/print/idrepo/dto/IdResponseDTO1.java b/src/main/java/io/mosip/print/idrepo/dto/IdResponseDTO1.java index f256ca6f..363c7be0 100644 --- a/src/main/java/io/mosip/print/idrepo/dto/IdResponseDTO1.java +++ b/src/main/java/io/mosip/print/idrepo/dto/IdResponseDTO1.java @@ -1,6 +1,6 @@ package io.mosip.print.idrepo.dto; -import io.mosip.registration.print.core.http.ResponseWrapper; +import io.mosip.print.core.http.ResponseWrapper; import lombok.Data; import lombok.EqualsAndHashCode; diff --git a/src/main/java/io/mosip/print/init/SetupPrint.java b/src/main/java/io/mosip/print/init/SetupPrint.java index 8e8b6ec3..23ef6fbf 100644 --- a/src/main/java/io/mosip/print/init/SetupPrint.java +++ b/src/main/java/io/mosip/print/init/SetupPrint.java @@ -2,6 +2,7 @@ import java.util.Date; +import org.slf4j.Logger; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; import org.springframework.boot.context.event.ApplicationReadyEvent; @@ -9,7 +10,6 @@ import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler; import org.springframework.stereotype.Component; -import io.mosip.kernel.core.logger.spi.Logger; import io.mosip.print.constant.LoggerFileConstant; import io.mosip.print.logger.PrintLogger; import io.mosip.print.util.WebSubSubscriptionHelper; @@ -18,12 +18,12 @@ public class SetupPrint implements ApplicationListener { - private static Logger logger = PrintLogger.getLogger(SetupPrint.class); + private Logger logger = PrintLogger.getLogger(SetupPrint.class); @Autowired private ThreadPoolTaskScheduler taskScheduler; - @Value("${mosip.event.delay :60000}") + @Value("${mosip.event.delay}") private int taskSubsctiptionDelay; @Autowired diff --git a/src/main/java/io/mosip/print/logger/PrintLogger.java b/src/main/java/io/mosip/print/logger/PrintLogger.java index 2038d22e..fc23281a 100644 --- a/src/main/java/io/mosip/print/logger/PrintLogger.java +++ b/src/main/java/io/mosip/print/logger/PrintLogger.java @@ -1,8 +1,7 @@ package io.mosip.print.logger; -import io.mosip.kernel.core.logger.spi.Logger; -import io.mosip.kernel.logger.logback.appender.RollingFileAppender; -import io.mosip.kernel.logger.logback.factory.Logfactory; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; /** @@ -11,25 +10,6 @@ */ public final class PrintLogger { - /** The mosip rolling file appender. */ - private static RollingFileAppender mosipRollingFileAppender; - - static { - mosipRollingFileAppender = new RollingFileAppender(); - mosipRollingFileAppender.setAppend(true); - mosipRollingFileAppender.setAppenderName("fileappender"); - mosipRollingFileAppender.setFileName("/home/logs/print.log"); - mosipRollingFileAppender.setFileNamePattern("/home/logs/print-%d{yyyy-MM-dd}-%i.log"); - mosipRollingFileAppender.setImmediateFlush(true); - mosipRollingFileAppender.setMaxFileSize("1mb"); - mosipRollingFileAppender.setMaxHistory(3); - mosipRollingFileAppender.setPrudent(false); - mosipRollingFileAppender.setTotalCap("10mb"); - } - - /** - * Instantiates a new reg processor logger. - */ private PrintLogger() { } @@ -40,6 +20,6 @@ private PrintLogger() { * @return the logger */ public static Logger getLogger(Class clazz) { - return Logfactory.getDefaultRollingFileLogger(mosipRollingFileAppender, clazz); + return LoggerFactory.getLogger(clazz); } } diff --git a/src/main/java/io/mosip/print/model/CertificateEntry.java b/src/main/java/io/mosip/print/model/CertificateEntry.java new file mode 100644 index 00000000..b5613559 --- /dev/null +++ b/src/main/java/io/mosip/print/model/CertificateEntry.java @@ -0,0 +1,31 @@ +package io.mosip.print.model; + +import java.util.Arrays; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +/** + * Certificate Key Entry from SoftHsm + * + * @author Urvil Joshi + * + * @param Certificate Type + * @param

PrivateKey Type + */ +@Data +@NoArgsConstructor +@AllArgsConstructor +public class CertificateEntry { + + private C[] chain; + + private P privateKey; + + @Override + public String toString() { + return "CertificateEntry [chain=" + Arrays.toString(chain) + ", privateKey=" + privateKey + "]"; + } + +} diff --git a/src/main/java/io/mosip/print/model/CompositeScore.java b/src/main/java/io/mosip/print/model/CompositeScore.java new file mode 100644 index 00000000..08f119cc --- /dev/null +++ b/src/main/java/io/mosip/print/model/CompositeScore.java @@ -0,0 +1,14 @@ +package io.mosip.print.model; + +import lombok.Data; + +/** Added for backward compatibility 0.7 */ +@Data +public class CompositeScore { + + private float scaledScore; + private long internalScore; + private Score[] individualScores; + private KeyValuePair[] analyticsInfo; + +} diff --git a/src/main/java/io/mosip/print/model/KeyValuePair.java b/src/main/java/io/mosip/print/model/KeyValuePair.java new file mode 100644 index 00000000..b187cb3c --- /dev/null +++ b/src/main/java/io/mosip/print/model/KeyValuePair.java @@ -0,0 +1,14 @@ +package io.mosip.print.model; + +import lombok.Data; + +/** + * The Class KeyValuePair. + * + * @author Sanjay Murali + */ +@Data +public class KeyValuePair { + private String key; + private String value; +} diff --git a/src/main/java/io/mosip/print/model/MatchDecision.java b/src/main/java/io/mosip/print/model/MatchDecision.java new file mode 100644 index 00000000..296127c4 --- /dev/null +++ b/src/main/java/io/mosip/print/model/MatchDecision.java @@ -0,0 +1,18 @@ +package io.mosip.print.model; + +import lombok.Data; + +/** + * The Class Score. + * + * @author Manoj SP + */ +@Data +public class MatchDecision { + + /** The match - true or false indicates matchers decision. */ + private boolean match; + + /** The analytics info - detailed breakdown and other information. */ + private KeyValuePair[] analyticsInfo; +} diff --git a/src/main/java/io/mosip/print/model/PrintcardMCE.java b/src/main/java/io/mosip/print/model/PrintcardMCE.java new file mode 100644 index 00000000..f7db5f7f --- /dev/null +++ b/src/main/java/io/mosip/print/model/PrintcardMCE.java @@ -0,0 +1,58 @@ +package io.mosip.print.model; + + +import lombok.Getter; +import lombok.Setter; + +import javax.persistence.Column; +import javax.persistence.Entity; +import javax.persistence.Id; +import javax.persistence.Table; +import java.sql.Timestamp; +import java.util.Date; + +@Entity +@Table(name = "msp_card") +@Getter +@Setter +public class PrintcardMCE { + + @Id + @Column(name = "id") + private String id; + + @Column(name = "json_data ") + private String name; + @Column(name = "province") + private String province; + @Column(name = "city") + private String city; + @Column(name = "zone") + private String zone; + @Column(name = "zip") + private String zip; + @Column(name = "download_date") + private Date downloadDate; + @Column(name = "request_id") + private String requestId; + @Column(name = "registration_date") + private Timestamp registrationDate; + @Column(name = "registration_center_id") + private String registrationCenterId; + @Column(name = "status") + private int status; + @Column(name = "request_id1") + private String requestId1; + @Column(name = "resident") + private String resident; + @Column(name = "introducer") + private String introducer; + @Column(name = "birthdate") + private Date birthdate; + + public PrintcardMCE() { + + } + + +} diff --git a/src/main/java/io/mosip/print/model/QualityScore.java b/src/main/java/io/mosip/print/model/QualityScore.java new file mode 100644 index 00000000..ab9dec08 --- /dev/null +++ b/src/main/java/io/mosip/print/model/QualityScore.java @@ -0,0 +1,21 @@ +package io.mosip.print.model; + +import lombok.Data; + +/** + * The Class QualityScore. + * + * @author Sanjay Murali + */ +@Data +public class QualityScore { + + /** The score - 0 - 100 score that represents quality as a percentage */ + private float score; + + /** Added for backward compatibility 0.7 */ + private long internalScore; + + /** The analytics info - detailed breakdown and other information */ + private KeyValuePair[] analyticsInfo; +} \ No newline at end of file diff --git a/src/main/java/io/mosip/print/model/Rectangle.java b/src/main/java/io/mosip/print/model/Rectangle.java new file mode 100644 index 00000000..b176df7a --- /dev/null +++ b/src/main/java/io/mosip/print/model/Rectangle.java @@ -0,0 +1,37 @@ +package io.mosip.print.model; + +import lombok.Data; + +/** + * Rectangle model for pdf generator + * + * @author Urvil Joshi + * + */ +@Data +public class Rectangle { + + public Rectangle(float llx, float lly, float urx, float ury) { + this.llx = llx; + this.lly = lly; + this.urx = urx; + this.ury = ury; + } + /** + * The lower left x value of rectangle. + */ + private float llx; + /** + * The lower left y value of rectangle. + */ + private float lly; + /** + * The upper right x value of rectangle. + */ + private float urx; + /** + * The upper right y value of rectangle. + */ + private float ury; + +} \ No newline at end of file diff --git a/src/main/java/io/mosip/print/model/Response.java b/src/main/java/io/mosip/print/model/Response.java new file mode 100644 index 00000000..ceef8b27 --- /dev/null +++ b/src/main/java/io/mosip/print/model/Response.java @@ -0,0 +1,22 @@ +package io.mosip.print.model; + +import lombok.Data; + +/** + * The Class Response. + * + * @author Manoj SP + * @param the generic type + */ +@Data +public class Response { + + /** The status code. */ + private Integer statusCode; + + /** The status message. */ + private String statusMessage; + + /** The response. */ + private T response; +} diff --git a/src/main/java/io/mosip/print/model/Score.java b/src/main/java/io/mosip/print/model/Score.java new file mode 100644 index 00000000..ca57602d --- /dev/null +++ b/src/main/java/io/mosip/print/model/Score.java @@ -0,0 +1,13 @@ +package io.mosip.print.model; + +import lombok.Data; + +/** Added for backward compatibility 0.7 */ +@Data +public class Score { + + private float scaleScore; + private long internalScore; + private KeyValuePair[] analyticsInfo; + +} diff --git a/src/main/java/io/mosip/print/repository/MspCardRepository.java b/src/main/java/io/mosip/print/repository/MspCardRepository.java new file mode 100644 index 00000000..883da03a --- /dev/null +++ b/src/main/java/io/mosip/print/repository/MspCardRepository.java @@ -0,0 +1,10 @@ +package io.mosip.print.repository; + +import io.mosip.kernel.core.dataaccess.spi.repository.BaseRepository; +import io.mosip.print.entity.MspCardEntity; +import org.springframework.stereotype.Repository; + +@Repository("mspCardRepository") +public interface MspCardRepository extends BaseRepository { + +} diff --git a/src/main/java/io/mosip/print/service/CbeffContainerI.java b/src/main/java/io/mosip/print/service/CbeffContainerI.java new file mode 100644 index 00000000..d1b1aac5 --- /dev/null +++ b/src/main/java/io/mosip/print/service/CbeffContainerI.java @@ -0,0 +1,22 @@ +/** + * + */ +package io.mosip.print.service; + +import java.util.List; + +/** + * @author Ramadurai Pandian + * + * Container Interface to be used for create and update + * + */ +public abstract class CbeffContainerI { + + public abstract U createBIRType(List bir) throws Exception; + + public abstract U updateBIRType(List bir, byte[] fileBytes) throws Exception; + + public abstract boolean validateXML(byte[] fileBytes, byte[] xsdBytes) throws Exception; + +} diff --git a/src/main/java/io/mosip/print/service/PrintDBService.java b/src/main/java/io/mosip/print/service/PrintDBService.java new file mode 100644 index 00000000..0671b7c4 --- /dev/null +++ b/src/main/java/io/mosip/print/service/PrintDBService.java @@ -0,0 +1,54 @@ +package io.mosip.print.service; + +import io.mosip.kernel.core.logger.spi.Logger; +import io.mosip.print.constant.LoggerFileConstant; +import io.mosip.print.logger.PrintLogger; +import io.mosip.print.model.PrintcardMCE; +import org.springframework.stereotype.Repository; + +import javax.persistence.EntityManager; +import javax.persistence.PersistenceContext; +import javax.transaction.Transactional; + +@Repository +@Transactional +public class PrintDBService { + @PersistenceContext + private EntityManager entityManager; + + public synchronized void savePrintdata(PrintcardMCE obj) { + try { + long taskStart = System.currentTimeMillis(); + PrintcardMCE card = new PrintcardMCE(); + card.setId(obj.getId()); + card.setName(obj.getName()); +// card.setProvince(obj.getProvince()); +// card.setCity(obj.getCity()); +// card.setZip(obj.getZip()); +// card.setZone(obj.getZone()); + card.setRequestId(obj.getRequestId()); +// card.setRequestId1(obj.getRequestId1()); +// card.setDownloadDate(new Date()); +// card.setRegistrationDate(obj.getRegistrationDate()); +// card.setRegistrationCenterId(obj.getRegistrationCenterId()); +// card.setResident(obj.getResident()); +// card.setIntroducer(obj.getIntroducer()); +// card.setRid(obj.getRid()); + +// card.setId(obj.getId()); +// card.setBirthdate(obj.getBirthdate()); + entityManager.persist(card); + + } catch (Exception e) { + + } + } + + + ; + + // Map getDocuments(String credentialSubject, String sign, + // String cardType, + // boolean isPasswordProtected); + +} diff --git a/src/main/java/io/mosip/print/service/PrintRepository.java b/src/main/java/io/mosip/print/service/PrintRepository.java new file mode 100644 index 00000000..f2088f06 --- /dev/null +++ b/src/main/java/io/mosip/print/service/PrintRepository.java @@ -0,0 +1,25 @@ +package io.mosip.print.service; + +import io.mosip.print.model.PrintcardMCE; +import org.springframework.data.jpa.repository.Modifying; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.CrudRepository; +import org.springframework.data.repository.query.Param; +import org.springframework.stereotype.Repository; + +@Repository +public interface PrintRepository extends CrudRepository { + @Query("SELECT max(p.id) FROM PrintcardMCE p") + public Integer sno(); + @Query("SELECT count(p.id) FROM PrintcardMCE p where p.requestId= ?1 ") + public Integer countById(@Param("requestId") String printid) ; + + @Query("SELECT count(p.id) FROM PrintcardMCE p where p.requestId1= ?1 ") + public Integer countByRequestId1(@Param("requestId1") String rid) ; + + @Query("SELECT p.id FROM PrintcardMCE p where p.requestId1= ?1 ") + public Integer findIdByRequestId1(@Param("requestId1") String rid); + @Modifying + @Query("update PrintcardMCE p set p.status=?3 where p.requestId1= ?1 and p.status=?2 ") + public Integer updateExistingId(@Param("requestId1") String rid,@Param("status") int status,@Param("status") int newstatus); +} diff --git a/src/main/java/io/mosip/print/service/PrintService.java b/src/main/java/io/mosip/print/service/PrintService.java index f83c0edf..a39a1977 100644 --- a/src/main/java/io/mosip/print/service/PrintService.java +++ b/src/main/java/io/mosip/print/service/PrintService.java @@ -1,22 +1,18 @@ package io.mosip.print.service; -public interface PrintService { +import io.mosip.print.model.EventModel; + +public interface PrintService { /** - * Gets the documents. - * - * @param type - * the type - * @param idValue - * the id value - * @param cardType - * the card type - * @param isPasswordProtected - * the is password protected - * @return the documents + * Get the card + * + * + * @param eventModel + * @return + * @throws Exception */ - public T getDocuments(String credentialSubject, String requestId, String sign, String cardType, - boolean isPasswordProtected); + public void generateCard(EventModel eventModel) throws Exception; // Map getDocuments(String credentialSubject, String sign, // String cardType, diff --git a/src/main/java/io/mosip/print/service/impl/BioApiImpl.java b/src/main/java/io/mosip/print/service/impl/BioApiImpl.java new file mode 100644 index 00000000..6208245f --- /dev/null +++ b/src/main/java/io/mosip/print/service/impl/BioApiImpl.java @@ -0,0 +1,131 @@ +package io.mosip.print.service.impl; + +import java.security.SecureRandom; +import java.util.Arrays; +import java.util.Comparator; +import java.util.Objects; +import java.util.Optional; + +import org.springframework.stereotype.Component; + +import io.mosip.kernel.core.bioapi.model.CompositeScore; +import io.mosip.kernel.core.bioapi.model.KeyValuePair; +import io.mosip.kernel.core.bioapi.model.QualityScore; +import io.mosip.kernel.core.bioapi.model.Score; +import io.mosip.kernel.core.cbeffutil.entity.BDBInfo; +import io.mosip.kernel.core.cbeffutil.entity.BIR; +import io.mosip.kernel.core.cbeffutil.jaxbclasses.QualityType; +import io.mosip.print.spi.IBioApi; + + + +/** + * The Class BioApiImpl. + * + * @author Sanjay Murali + * @author Manoj SP + * + */ +@Component +public class BioApiImpl implements IBioApi { + + /* + * (non-Javadoc) + * + * @see + * io.mosip.kernel.core.bioapi.spi.IBioApi#checkQuality(io.mosip.kernel.core. + * bioapi.model.BIR, io.mosip.kernel.core.bioapi.model.KeyValuePair[]) + */ + @Override + public QualityScore checkQuality(BIR sample, KeyValuePair[] flags) { + QualityScore qualityScore = new QualityScore(); + int major = Optional.ofNullable(sample.getBdbInfo()).map(BDBInfo::getQuality).map(QualityType::getScore) + .orElse(0L).intValue(); + qualityScore.setInternalScore(major); + return qualityScore; + } + + /* + * (non-Javadoc) + * + * @see + * io.mosip.kernel.core.bioapi.spi.IBioApi#match(io.mosip.kernel.core.bioapi. + * model.BIR, io.mosip.kernel.core.bioapi.model.BIR[], + * io.mosip.kernel.core.bioapi.model.KeyValuePair[]) + */ + @Override + public Score[] match(BIR sample, BIR[] gallery, KeyValuePair[] flags) { + Score matchingScore[] = new Score[gallery.length]; + int count = 0; + for (BIR recordedValue : gallery) { + matchingScore[count] = new Score(); + if (Objects.nonNull(recordedValue) && Objects.nonNull(recordedValue.getBdb()) + && recordedValue.getBdb().length != 0 && Arrays.equals(recordedValue.getBdb(), sample.getBdb())) { + matchingScore[count].setInternalScore(90); + matchingScore[count].setScaleScore(90); + } else { + int randomNumebr = new SecureRandom().nextInt(50); + matchingScore[count].setInternalScore(randomNumebr); + matchingScore[count].setScaleScore(randomNumebr); + } + count++; + } + return matchingScore; + } + + /* + * (non-Javadoc) + * + * @see + * io.mosip.kernel.core.bioapi.spi.IBioApi#compositeMatch(io.mosip.kernel.core. + * bioapi.model.BIR[], io.mosip.kernel.core.bioapi.model.BIR[], + * io.mosip.kernel.core.bioapi.model.KeyValuePair[]) + */ + + @Override + public CompositeScore compositeMatch(BIR[] sampleList, BIR[] recordList, KeyValuePair[] flags) { + Score matchingScore[] = new Score[sampleList.length]; + int count = 0; + for (BIR sampleValue : sampleList) { + Score[] match = match(sampleValue, recordList, flags); + Optional max = Arrays.stream(match).max(Comparator.comparing(Score::getInternalScore)); + if (max.isPresent()) { + matchingScore[count] = max.get(); + count++; + } + } + double sum = Arrays.stream(matchingScore).mapToDouble(Score::getInternalScore).sum(); + CompositeScore compositeScore = new CompositeScore(); + compositeScore.setIndividualScores(matchingScore); + long compositeMatchScore = (long) (sum / matchingScore.length); + compositeScore.setInternalScore(compositeMatchScore); + compositeScore.setScaledScore(compositeMatchScore); + return compositeScore; + } + + /* + * (non-Javadoc) + * + * @see + * io.mosip.kernel.core.bioapi.spi.IBioApi#extractTemplate(io.mosip.kernel.core. + * bioapi.model.BIR, io.mosip.kernel.core.bioapi.model.KeyValuePair[]) + */ + @Override + public BIR extractTemplate(BIR sample, KeyValuePair[] flags) { + return sample; + } + + /* + * (non-Javadoc) + * + * @see + * io.mosip.kernel.core.bioapi.spi.IBioApi#segment(io.mosip.kernel.core.bioapi. + * model.BIR, io.mosip.kernel.core.bioapi.model.KeyValuePair[]) + */ + @Override + public BIR[] segment(BIR sample, KeyValuePair[] flags) { + BIR[] bir = new BIR[1]; + bir[0] = sample; + return bir; + } +} \ No newline at end of file diff --git a/src/main/java/io/mosip/print/service/impl/CbeffContainerImpl.java b/src/main/java/io/mosip/print/service/impl/CbeffContainerImpl.java new file mode 100644 index 00000000..f020714c --- /dev/null +++ b/src/main/java/io/mosip/print/service/impl/CbeffContainerImpl.java @@ -0,0 +1,95 @@ +/** + * + */ +package io.mosip.print.service.impl; + +import java.util.ArrayList; +import java.util.List; + +import io.mosip.kernel.core.cbeffutil.common.CbeffValidator; +import io.mosip.kernel.core.cbeffutil.common.CbeffXSDValidator; +import io.mosip.kernel.core.cbeffutil.entity.BIR; +import io.mosip.kernel.core.cbeffutil.jaxbclasses.BIRInfoType; +import io.mosip.kernel.core.cbeffutil.jaxbclasses.BIRType; +import io.mosip.print.service.CbeffContainerI; + +/** + * @author Ramadurai Pandian + * + * A Container Class where the BIR is created and updated + * + */ +public class CbeffContainerImpl extends CbeffContainerI { + + private BIRType birType; + + /** + * Method where the initialization of BIR happens + * + * @param birList List of BIR data + * @return BIRType data with all images + */ + @Override + public BIRType createBIRType(List birList) { + load(); + List birTypeList = new ArrayList<>(); + if (birList != null && birList.size() > 0) { + for (BIR bir : birList) { + birTypeList.add(bir.toBIRType(bir)); + } + } + birType.setBir(birTypeList); + return birType; + } + + private void load() { + // Creating first version of Cbeff + birType = new BIRType(); + // Initial Version +// VersionType versionType = new VersionType(); +// versionType.setMajor(1); +// versionType.setMinor(1); +// VersionType cbeffVersion = new VersionType(); +// cbeffVersion.setMajor(1); +// cbeffVersion.setMinor(1); +// birType.setVersion(versionType); +// birType.setCBEFFVersion(cbeffVersion); + BIRInfoType birInfo = new BIRInfoType(); + birInfo.setIntegrity(false); + birType.setBIRInfo(birInfo); + } + + /** + * Method to the update of BIR + * + * @param birList List of BIR data + * + * @param fileBytes Cbeff XML data as bytes + * + * @return birType BIR data with all images + */ + @Override + public BIRType updateBIRType(List birList, byte[] fileBytes) throws Exception { + BIRType birType = CbeffValidator.getBIRFromXML(fileBytes); + // birType.getVersion().setMajor(birType.getVersion().getMajor() + 1); + // birType.getCBEFFVersion().setMajor(birType.getCBEFFVersion().getMajor()); + for (BIR bir : birList) { + birType.getBIR().add(bir.toBIRType(bir)); + } + return birType; + } + + /** + * Method to the validate the BIR + * + * @param xmlBytes Cbeff XML data as bytes array + * + * @param xsdBytes Cbeff XSD data as bytes array + * + * @return boolean of validated XML against XSD + */ + @Override + public boolean validateXML(byte[] xmlBytes, byte[] xsdBytes) throws Exception { + return CbeffXSDValidator.validateXML(xsdBytes, xmlBytes); + } +} diff --git a/src/main/java/io/mosip/print/service/impl/CbeffImpl.java b/src/main/java/io/mosip/print/service/impl/CbeffImpl.java new file mode 100644 index 00000000..0296dd86 --- /dev/null +++ b/src/main/java/io/mosip/print/service/impl/CbeffImpl.java @@ -0,0 +1,207 @@ +package io.mosip.print.service.impl; + +import java.io.IOException; +import java.io.InputStream; +import java.net.URL; +import java.util.List; +import java.util.Map; + +import javax.annotation.PostConstruct; + +import org.apache.commons.io.IOUtils; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Component; + +import io.mosip.kernel.core.cbeffutil.common.CbeffValidator; +import io.mosip.kernel.core.cbeffutil.entity.BIR; +import io.mosip.kernel.core.cbeffutil.jaxbclasses.BIRType; +import io.mosip.print.spi.CbeffUtil; + +/** + * This class is used to create,update, validate and search Cbeff data. + * + * @author Ramadurai Pandian + */ +@Component +public class CbeffImpl implements CbeffUtil { + + /* + * XSD storage path from config server + */ + + /** The config server file storage URL. */ + @Value("${mosip.kernel.xsdstorage-uri}") + private String configServerFileStorageURL; + + /* + * XSD file name + */ + + /** The schema name. */ + @Value("${mosip.kernel.xsdfile}") + private String schemaName; + + /** The xsd. */ + private byte[] xsd; + + /** + * Load XSD. + * + * @throws IOException Signals that an I/O exception has occurred. + */ + @PostConstruct + public void loadXSD() throws IOException { + try (InputStream xsdBytes = new URL(configServerFileStorageURL + schemaName).openStream()) { + xsd = IOUtils.toByteArray(xsdBytes); + } + } + + /** + * Method used for creating Cbeff XML. + * + * @param birList pass List of BIR for creating Cbeff data + * @return return byte array of XML data + * @throws Exception exception + */ + @Override + public byte[] createXML(List birList) throws Exception { + CbeffContainerImpl cbeffContainer = new CbeffContainerImpl(); + BIRType bir = cbeffContainer.createBIRType(birList); + return CbeffValidator.createXMLBytes(bir, xsd); + } + + /** + * Method used for creating Cbeff XML with xsd. + * + * @param birList pass List of BIR for creating Cbeff data + * @param xsd byte array of XSD data + * @return return byte array of XML data + * @throws Exception Exception + */ + + @Override + public byte[] createXML(List birList, byte[] xsd) throws Exception { + CbeffContainerImpl cbeffContainer = new CbeffContainerImpl(); + BIRType bir = cbeffContainer.createBIRType(birList); + return CbeffValidator.createXMLBytes(bir, xsd); + } + + /** + * Method used for updating Cbeff XML. + * + * @param birList pass List of BIR for creating Cbeff data + * @param fileBytes the file bytes + * @return return byte array of XML data + * @throws Exception Exception + */ + @Override + public byte[] updateXML(List birList, byte[] fileBytes) throws Exception { + CbeffContainerImpl cbeffContainer = new CbeffContainerImpl(); + BIRType bir = cbeffContainer.updateBIRType(birList, fileBytes); + return CbeffValidator.createXMLBytes(bir, xsd); + } + + /** + * Method used for validating XML against XSD. + * + * @param xmlBytes byte array of XML data + * @param xsdBytes byte array of XSD data + * @return boolean if data is valid or not + * @throws Exception Exception + */ + @Override + public boolean validateXML(byte[] xmlBytes, byte[] xsdBytes) throws Exception { + CbeffContainerImpl cbeffContainer = new CbeffContainerImpl(); + return cbeffContainer.validateXML(xmlBytes, xsdBytes); + } + + /* + * (non-Javadoc) + * + * @see io.mosip.kernel.core.cbeffutil.spi.CbeffUtil#validateXML(byte[]) + */ + @Override + public boolean validateXML(byte[] xmlBytes) throws Exception { + return validateXML(xmlBytes, xsd); + } + + /** + * Method used for validating XML against XSD. + * + * @param fileBytes byte array of XML data + * @param type to be searched + * @param subType to be searched + * @return bdbMap Map of type and String of encoded biometric data + * @throws Exception Exception + */ + @Override + public Map getBDBBasedOnType(byte[] fileBytes, String type, String subType) throws Exception { + BIRType bir = CbeffValidator.getBIRFromXML(fileBytes); + return CbeffValidator.getBDBBasedOnTypeAndSubType(bir, type, subType); + } + + /** + * Method used for getting list of BIR from XML bytes. + * + * @param xmlBytes byte array of XML data + * @return List of BIR data extracted from XML + * @throws Exception Exception + */ + @Override + public List getBIRDataFromXML(byte[] xmlBytes) throws Exception { + BIRType bir = CbeffValidator.getBIRFromXML(xmlBytes); + return bir.getBIR(); + } + + /** + * Method used for getting Map of BIR from XML bytes with type and subType. + * + * @param xmlBytes byte array of XML data + * @param type type + * @param subType subType + * @return bdbMap Map of BIR data extracted from XML + * @throws Exception Exception + */ + @Override + public Map getAllBDBData(byte[] xmlBytes, String type, String subType) throws Exception { + BIRType bir = CbeffValidator.getBIRFromXML(xmlBytes); + return CbeffValidator.getAllBDBData(bir, type, subType); + } + + /* + * (non-Javadoc) + * + * @see + * io.mosip.kernel.core.cbeffutil.spi.CbeffUtil#convertBIRTypeToBIR(java.util. + * List) + */ + @Override + public List convertBIRTypeToBIR(List birType) { + return CbeffValidator.convertBIRTypeToBIR(birType); + } + + /* + * (non-Javadoc) + * + * @see + * io.mosip.kernel.core.cbeffutil.spi.CbeffUtil#getBIRDataFromXMLType(byte[], + * java.lang.String) + */ + @Override + public List getBIRDataFromXMLType(byte[] xmlBytes, String type) throws Exception { + return CbeffValidator.getBIRDataFromXMLType(xmlBytes, type); + } + + //TODO for testing, will be removed later +// public static void main(String arg[]) throws Exception +// { +// Map test= new CbeffImpl().getBDBBasedOnType(readCreatedXML(),"Iris",null); +// System.out.println(test.size()); +// +// } +// +// private static byte[] readCreatedXML() throws IOException { +// byte[] fileContent = Files.readAllBytes(Paths.get("C:\\Users\\M1046464\\Downloads\\cbeff1.xml")); +// return fileContent; +// } +} diff --git a/src/main/java/io/mosip/print/service/impl/PDFGeneratorImpl.java b/src/main/java/io/mosip/print/service/impl/PDFGeneratorImpl.java new file mode 100644 index 00000000..5b6dca41 --- /dev/null +++ b/src/main/java/io/mosip/print/service/impl/PDFGeneratorImpl.java @@ -0,0 +1,328 @@ +package io.mosip.print.service.impl; + +import java.awt.image.BufferedImage; +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.net.URL; +import java.security.GeneralSecurityException; +import java.security.PrivateKey; +import java.security.Provider; +import java.security.cert.X509Certificate; +import java.util.ArrayList; +import java.util.List; + +import javax.imageio.ImageIO; + +import org.slf4j.Logger; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Component; + +import com.itextpdf.html2pdf.ConverterProperties; +import com.itextpdf.html2pdf.HtmlConverter; +import com.itextpdf.html2pdf.css.media.MediaDeviceDescription; +import com.itextpdf.html2pdf.css.media.MediaType; +import com.itextpdf.html2pdf.css.util.CssUtils; +import com.itextpdf.html2pdf.resolver.font.DefaultFontProvider; +import com.itextpdf.io.image.ImageDataFactory; +import com.itextpdf.kernel.geom.PageSize; +import com.itextpdf.kernel.pdf.PdfDocument; +import com.itextpdf.kernel.pdf.PdfWriter; +import com.itextpdf.layout.Document; +import com.itextpdf.layout.element.Image; +import com.itextpdf.text.DocumentException; +import com.itextpdf.text.Rectangle; +import com.itextpdf.text.pdf.PdfCopy; +import com.itextpdf.text.pdf.PdfReader; +import com.itextpdf.text.pdf.PdfSignatureAppearance; +import com.itextpdf.text.pdf.PdfStamper; +import com.itextpdf.text.pdf.security.BouncyCastleDigest; +import com.itextpdf.text.pdf.security.CertificateUtil; +import com.itextpdf.text.pdf.security.CrlClient; +import com.itextpdf.text.pdf.security.CrlClientOnline; +import com.itextpdf.text.pdf.security.ExternalDigest; +import com.itextpdf.text.pdf.security.ExternalSignature; +import com.itextpdf.text.pdf.security.MakeSignature; +import com.itextpdf.text.pdf.security.MakeSignature.CryptoStandard; +import com.itextpdf.text.pdf.security.OcspClient; +import com.itextpdf.text.pdf.security.OcspClientBouncyCastle; +import com.itextpdf.text.pdf.security.PrivateKeySignature; +import com.itextpdf.text.pdf.security.TSAClient; +import com.itextpdf.text.pdf.security.TSAClientBouncyCastle; + +import io.mosip.print.constant.PDFGeneratorExceptionCodeConstant; +import io.mosip.print.exception.PDFGeneratorException; +import io.mosip.print.logger.PrintLogger; +import io.mosip.print.model.CertificateEntry; +import io.mosip.print.spi.PDFGenerator; +import io.mosip.print.util.EmptyCheckUtils; + +/** + * The PdfGeneratorImpl is the class you will use most when converting processed + * Template to PDF. It contains a series of methods that accept processed + * Template as a {@link String}, {@link File}, or {@link InputStream}, and + * convert it to PDF in the form of an {@link OutputStream}, {@link File} + * + * @author Urvil Joshi + * @author Uday Kumar + * @author Neha + * + * @since 1.0.0 + * + */ +@Component +public class PDFGeneratorImpl implements PDFGenerator { + private static final Logger LOGGER = PrintLogger.getLogger(PDFGeneratorImpl.class); + + private static final String SHA256 = "SHA256"; + + private static final String OUTPUT_FILE_EXTENSION = ".pdf"; + + @Value("${mosip.kernel.pdf_owner_password}") + private String pdfOwnerPassword; + + /* + * (non-Javadoc) + * + * @see io.mosip.kernel.core.pdfgenerator.spi.PDFGenerator#generate(java.io. + * InputStream) + */ + @Override + public OutputStream generate(InputStream is) throws IOException { + isValidInputStream(is); + OutputStream os = new ByteArrayOutputStream(); + try { + HtmlConverter.convertToPdf(is, os); + } catch (Exception e) { + throw new PDFGeneratorException(PDFGeneratorExceptionCodeConstant.PDF_EXCEPTION.getErrorCode(), + e.getMessage()); + } + return os; + } + + /* + * (non-Javadoc) + * + * @see + * io.mosip.kernel.core.pdfgenerator.spi.PDFGenerator#generate(java.lang.String) + */ + @Override + public OutputStream generate(String template) throws IOException { + OutputStream os = new ByteArrayOutputStream(); + try { + HtmlConverter.convertToPdf(template, os); + } catch (Exception e) { + throw new PDFGeneratorException(PDFGeneratorExceptionCodeConstant.PDF_EXCEPTION.getErrorCode(), + PDFGeneratorExceptionCodeConstant.PDF_EXCEPTION.getErrorMessage(), e); + } + return os; + } + + /* + * (non-Javadoc) + * + * @see + * io.mosip.kernel.core.pdfgenerator.spi.PDFGenerator#generate(java.lang.String, + * java.lang.String, java.lang.String) + */ + @Override + public void generate(String templatePath, String outpuFilePath, String outputFileName) throws IOException { + File outputFile = new File(outpuFilePath + outputFileName + OUTPUT_FILE_EXTENSION); + try { + HtmlConverter.convertToPdf(new File(templatePath), outputFile); + } catch (Exception e) { + throw new PDFGeneratorException(PDFGeneratorExceptionCodeConstant.PDF_EXCEPTION.getErrorCode(), + PDFGeneratorExceptionCodeConstant.PDF_EXCEPTION.getErrorMessage(), e); + } + + } + + /* + * (non-Javadoc) + * + * @see io.mosip.kernel.core.pdfgenerator.spi.PDFGenerator#generate(java.io. + * InputStream, java.lang.String) + */ + @Override + public OutputStream generate(InputStream is, String resourceLoc) throws IOException { + isValidInputStream(is); + OutputStream os = new ByteArrayOutputStream(); + PdfWriter pdfWriter = new PdfWriter(os); + PdfDocument pdfDoc = new PdfDocument(pdfWriter); + ConverterProperties converterProperties = new ConverterProperties(); + pdfDoc.setTagged(); + PageSize pageSize = PageSize.A4.rotate(); + pdfDoc.setDefaultPageSize(pageSize); + float screenWidth = CssUtils.parseAbsoluteLength("" + pageSize.getWidth()); + MediaDeviceDescription mediaDescription = new MediaDeviceDescription(MediaType.SCREEN); + mediaDescription.setWidth(screenWidth); + DefaultFontProvider dfp = new DefaultFontProvider(true, true, false); + converterProperties.setMediaDeviceDescription(mediaDescription); + converterProperties.setFontProvider(dfp); + converterProperties.setBaseUri(resourceLoc); + converterProperties.setCreateAcroForm(true); + try { + HtmlConverter.convertToPdf(is, pdfDoc, converterProperties); + } catch (Exception e) { + throw new PDFGeneratorException(PDFGeneratorExceptionCodeConstant.PDF_EXCEPTION.getErrorCode(), + e.getMessage()); + } + return os; + } + + /* + * (non-Javadoc) + * + * @see io.mosip.kernel.core.pdfgenerator.spi.PDFGenerator#asPDF(java.util.List) + */ + @Override + public byte[] asPDF(List bufferedImages) throws IOException { + byte[] scannedPdfFile = null; + + try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) { + + PdfWriter pdfWriter = new PdfWriter(byteArrayOutputStream); + Document document = new Document(new PdfDocument(pdfWriter)); + + for (BufferedImage bufferedImage : bufferedImages) { + Image image = new Image(ImageDataFactory.create(getImageBytesFromBufferedImage(bufferedImage))); + image.scaleToFit(600, 750); + document.add(image); + } + + document.close(); + pdfWriter.close(); + scannedPdfFile = byteArrayOutputStream.toByteArray(); + } catch (IOException e) { + throw new PDFGeneratorException(PDFGeneratorExceptionCodeConstant.PDF_EXCEPTION.getErrorCode(), + e.getMessage()); + } + return scannedPdfFile; + } + + private byte[] getImageBytesFromBufferedImage(BufferedImage bufferedImage) throws IOException { + byte[] imageInByte; + + ByteArrayOutputStream imagebyteArray = new ByteArrayOutputStream(); + ImageIO.write(bufferedImage, "jpg", imagebyteArray); + imagebyteArray.flush(); + imageInByte = imagebyteArray.toByteArray(); + imagebyteArray.close(); + + return imageInByte; + } + + /* + * (non-Javadoc) + * + * @see + * io.mosip.kernel.core.pdfgenerator.spi.PDFGenerator#mergePDF(java.util.List) + */ + @Override + public byte[] mergePDF(List pdfFiles) throws IOException { + try (ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) { + com.itextpdf.text.Document document = new com.itextpdf.text.Document(); + PdfCopy pdfCopy = new PdfCopy(document, byteArrayOutputStream); + document.open(); + for (URL file : pdfFiles) { + PdfReader reader = new PdfReader(file); + pdfCopy.addDocument(reader); + pdfCopy.freeReader(reader); + reader.close(); + } + document.close(); + return byteArrayOutputStream.toByteArray(); + } catch (IOException | DocumentException e) { + throw new PDFGeneratorException(PDFGeneratorExceptionCodeConstant.PDF_EXCEPTION.getErrorCode(), + e.getMessage()); + } + } + + @Override + public OutputStream signAndEncryptPDF(byte[] pdf, io.mosip.print.model.Rectangle rectangle, + String reason, int pageNumber, Provider provider, + CertificateEntry certificateEntry, String password) + throws IOException, GeneralSecurityException { + OutputStream outputStream = new ByteArrayOutputStream(); + PdfReader pdfReader = null; + PdfStamper pdfStamper = null; + try { + pdfReader = new PdfReader(pdf); + pdfStamper = PdfStamper.createSignature(pdfReader, outputStream, '\0'); + + if (password != null && !password.trim().isEmpty()) { + pdfStamper.setEncryption(password.getBytes(), pdfOwnerPassword.getBytes(), + com.itextpdf.text.pdf.PdfWriter.ALLOW_PRINTING, + com.itextpdf.text.pdf.PdfWriter.ENCRYPTION_AES_256); + } + PdfSignatureAppearance signAppearance = pdfStamper.getSignatureAppearance(); + + signAppearance.setReason(reason); + // comment next line to have an invisible signature + signAppearance.setVisibleSignature( + new Rectangle(rectangle.getLlx(), rectangle.getLly(), rectangle.getUrx(), rectangle.getUry()), + pageNumber, null); + + OcspClient ocspClient = new OcspClientBouncyCastle(null); + TSAClient tsaClient = null; + for (X509Certificate certificate : certificateEntry.getChain()) { + String tsaUrl = CertificateUtil.getTSAURL(certificate); + if (tsaUrl != null) { + tsaClient = new TSAClientBouncyCastle(tsaUrl); + break; + } + signAppearance.setCertificate(certificate); + } + + List crlList = new ArrayList<>(); + crlList.add(new CrlClientOnline(certificateEntry.getChain())); + + ExternalSignature pks = new PrivateKeySignature(certificateEntry.getPrivateKey(), "SHA256", + provider.getName()); + ExternalDigest digest = new BouncyCastleDigest(); + + // Sign the document using the detached mode, CMS or CAdES equivalent. + MakeSignature.signDetached(signAppearance, digest, pks, certificateEntry.getChain(), crlList, ocspClient, + tsaClient, 0, CryptoStandard.CMS); + + pdfStamper.close(); + + } catch (DocumentException e) { + throw new PDFGeneratorException(PDFGeneratorExceptionCodeConstant.PDF_EXCEPTION.getErrorCode(), + e.getMessage(), e); + } finally { + outputStream.close(); + if (pdfStamper != null) { + closeQuietly(pdfStamper); + } + if (pdfReader != null) { + pdfReader.close(); + } + } + return outputStream; + } + + /* + + */ + + // Quietly close the pdfStamper. + private void closeQuietly(final PdfStamper pdfStamper) throws IOException { + try { + pdfStamper.close(); + } catch (DocumentException e) { + throw new PDFGeneratorException(PDFGeneratorExceptionCodeConstant.PDF_EXCEPTION.getErrorCode(), + e.getMessage(), e); + } + } + + private void isValidInputStream(InputStream dataInputStream) { + if (EmptyCheckUtils.isNullEmpty(dataInputStream)) { + throw new PDFGeneratorException( + PDFGeneratorExceptionCodeConstant.INPUTSTREAM_NULL_EMPTY_EXCEPTION.getErrorCode(), + PDFGeneratorExceptionCodeConstant.INPUTSTREAM_NULL_EMPTY_EXCEPTION.getErrorMessage()); + } + } +} diff --git a/src/main/java/io/mosip/print/service/impl/PrintCardImpl.java b/src/main/java/io/mosip/print/service/impl/PrintCardImpl.java new file mode 100644 index 00000000..887c98d3 --- /dev/null +++ b/src/main/java/io/mosip/print/service/impl/PrintCardImpl.java @@ -0,0 +1,43 @@ +package io.mosip.print.service.impl; + +import io.mosip.print.service.PrintRepository; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import javax.transaction.Transactional; + +@Service +@Transactional +public class PrintCardImpl implements PrintImpl { + @Autowired + PrintRepository printRepository; + @Override + public Integer sno() { + return printRepository.sno(); + } + @Override + public Integer countById(String printId) { + return printRepository.countById(printId); + } + @Override + public Integer countByRequestId1(String printId) { + return printRepository.countByRequestId1(printId); + } + @Override + public Integer findIdByRequestId1(String id) { + return printRepository.findIdByRequestId1(id); + } + + @Override + public Integer updateExistingId(String id,int status,int newstatus) { + return printRepository.updateExistingId(id,status,newstatus); + } +} + + + + + + + + diff --git a/src/main/java/io/mosip/print/service/impl/PrintImpl.java b/src/main/java/io/mosip/print/service/impl/PrintImpl.java new file mode 100644 index 00000000..64fc3bc3 --- /dev/null +++ b/src/main/java/io/mosip/print/service/impl/PrintImpl.java @@ -0,0 +1,22 @@ +package io.mosip.print.service.impl; + +import org.springframework.stereotype.Service; + +@Service +public interface PrintImpl { + + public Integer sno(); + + public Integer countById(String printId) ; + public Integer countByRequestId1(String printId); + public Integer findIdByRequestId1(String rid) ; + public Integer updateExistingId(String rid,int status,int newstatus) ; +} + + + + + + + + diff --git a/src/main/java/io/mosip/print/service/impl/PrintRestClientServiceImpl.java b/src/main/java/io/mosip/print/service/impl/PrintRestClientServiceImpl.java index b7fb798b..f945bd22 100644 --- a/src/main/java/io/mosip/print/service/impl/PrintRestClientServiceImpl.java +++ b/src/main/java/io/mosip/print/service/impl/PrintRestClientServiceImpl.java @@ -2,6 +2,7 @@ import java.util.List; +import org.slf4j.Logger; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.core.env.Environment; import org.springframework.http.MediaType; @@ -10,11 +11,10 @@ import org.springframework.web.util.UriComponents; import org.springframework.web.util.UriComponentsBuilder; -import io.mosip.kernel.core.exception.ExceptionUtils; -import io.mosip.kernel.core.logger.spi.Logger; import io.mosip.print.constant.ApiName; import io.mosip.print.constant.LoggerFileConstant; import io.mosip.print.exception.ApisResourceAccessException; +import io.mosip.print.exception.ExceptionUtils; import io.mosip.print.exception.PlatformErrorMessages; import io.mosip.print.logger.PrintLogger; import io.mosip.print.service.PrintRestClientService; @@ -29,8 +29,7 @@ public class PrintRestClientServiceImpl implements PrintRestClientService { /** The logger. */ - private static Logger regProcLogger = PrintLogger - .getLogger(PrintRestClientServiceImpl.class); + Logger printLogger = PrintLogger.getLogger(PrintRestClientServiceImpl.class); /** The rest api client. */ @Autowired @@ -52,7 +51,7 @@ public class PrintRestClientServiceImpl implements PrintRestClientService pathsegments, String queryParamName, String queryParamValue, Class responseType) throws ApisResourceAccessException { - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "RegistrationProcessorRestClientServiceImpl::getApi()::entry"); Object obj = null; String apiHostIpPort = env.getProperty(apiName.name()); @@ -84,12 +83,12 @@ public Object getApi(ApiName apiName, List pathsegments, String queryPar try { uriComponents = builder.build(false).encode(); - regProcLogger.debug(uriComponents.toUri().toString(), "URI", "", ""); + printLogger.debug(uriComponents.toUri().toString(), "URI", "", ""); obj = restApiClient.getApi(uriComponents.toUri(), responseType); } catch (Exception e) { e.printStackTrace(); - regProcLogger.error(LoggerFileConstant.SESSIONID.toString(), + printLogger.error(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.REGISTRATIONID.toString(), "", e.getMessage() + ExceptionUtils.getStackTrace(e)); @@ -98,7 +97,7 @@ public Object getApi(ApiName apiName, List pathsegments, String queryPar } } - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "RegistrationProcessorRestClientServiceImpl::getApi()::exit"); return obj; } @@ -106,7 +105,7 @@ public Object getApi(ApiName apiName, List pathsegments, String queryPar @Override public Object getApi(ApiName apiName, List pathsegments, List queryParamName, List queryParamValue, Class responseType) throws ApisResourceAccessException { - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "RegistrationProcessorRestClientServiceImpl::getApi()::entry"); Object obj = null; String apiHostIpPort = env.getProperty(apiName.name()); @@ -135,12 +134,12 @@ public Object getApi(ApiName apiName, List pathsegments, List qu try { uriComponents = builder.build(false).encode(); - regProcLogger.debug(uriComponents.toUri().toString(), "URI", "", ""); + printLogger.debug(uriComponents.toUri().toString(), "URI", "", ""); obj = restApiClient.getApi(uriComponents.toUri(), responseType); } catch (Exception e) { e.printStackTrace(); - regProcLogger.error(LoggerFileConstant.SESSIONID.toString(), + printLogger.error(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.REGISTRATIONID.toString(), "", e.getMessage() + ExceptionUtils.getStackTrace(e)); @@ -149,14 +148,14 @@ public Object getApi(ApiName apiName, List pathsegments, List qu } } - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "RegistrationProcessorRestClientServiceImpl::getApi()::exit"); return obj; } public Object postApi(ApiName apiName, String queryParamName, String queryParamValue, Object requestedData, Class responseType, MediaType mediaType) throws ApisResourceAccessException { - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "RegistrationProcessorRestClientServiceImpl::postApi()::entry"); Object obj = null; @@ -179,7 +178,7 @@ public Object postApi(ApiName apiName, String queryParamName, String queryParamV obj = restApiClient.postApi(builder.toUriString(), mediaType, requestedData, responseType); } catch (Exception e) { - regProcLogger.error(LoggerFileConstant.SESSIONID.toString(), + printLogger.error(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.REGISTRATIONID.toString(), "", e.getMessage() + ExceptionUtils.getStackTrace(e)); @@ -188,7 +187,7 @@ public Object postApi(ApiName apiName, String queryParamName, String queryParamV } } - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "RegistrationProcessorRestClientServiceImpl::postApi()::exit"); return obj; } @@ -220,7 +219,7 @@ public Object postApi(ApiName apiName, String queryParamName, String queryParamV public Object postApi(ApiName apiName, List pathsegments, String queryParamName, String queryParamValue, Object requestedData, Class responseType) throws ApisResourceAccessException { - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "RegistrationProcessorRestClientServiceImpl::postApi()::entry"); Object obj = null; String apiHostIpPort = env.getProperty(apiName.name()); @@ -250,7 +249,7 @@ public Object postApi(ApiName apiName, List pathsegments, String queryPa obj = restApiClient.postApi(builder.toUriString(), null, requestedData, responseType); } catch (Exception e) { - regProcLogger.error(LoggerFileConstant.SESSIONID.toString(), + printLogger.error(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.REGISTRATIONID.toString(), "", e.getMessage() + ExceptionUtils.getStackTrace(e)); @@ -259,7 +258,7 @@ public Object postApi(ApiName apiName, List pathsegments, String queryPa } } - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "RegistrationProcessorRestClientServiceImpl::postApi()::exit"); return obj; } @@ -268,7 +267,7 @@ public Object postApi(ApiName apiName, List pathsegments, String queryPa public Object postApi(ApiName apiName, MediaType mediaType, List pathsegments, List queryParamName, List queryParamValue, Object requestedData, Class responseType) throws ApisResourceAccessException { - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "RegistrationProcessorRestClientServiceImpl::postApi()::entry"); Object obj = null; String apiHostIpPort = env.getProperty(apiName.name()); @@ -296,7 +295,7 @@ public Object postApi(ApiName apiName, MediaType mediaType, List pathseg obj = restApiClient.postApi(builder.toUriString(), mediaType, requestedData, responseType); } catch (Exception e) { - regProcLogger.error(LoggerFileConstant.SESSIONID.toString(), + printLogger.error(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.REGISTRATIONID.toString(), "", e.getMessage() + ExceptionUtils.getStackTrace(e)); @@ -305,7 +304,7 @@ public Object postApi(ApiName apiName, MediaType mediaType, List pathseg } } - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "RegistrationProcessorRestClientServiceImpl::postApi()::exit"); return obj; } @@ -321,7 +320,7 @@ public Object postApi(ApiName apiName, MediaType mediaType, List pathseg public Object patchApi(ApiName apiName, List pathsegments, String queryParamName, String queryParamValue, Object requestedData, Class responseType) throws ApisResourceAccessException { - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "RegistrationProcessorRestClientServiceImpl::postApi()::entry"); Object obj = null; String apiHostIpPort = env.getProperty(apiName.name()); @@ -351,7 +350,7 @@ public Object patchApi(ApiName apiName, List pathsegments, String queryP obj = restApiClient.patchApi(builder.toUriString(), requestedData, responseType); } catch (Exception e) { - regProcLogger.error(LoggerFileConstant.SESSIONID.toString(), + printLogger.error(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.REGISTRATIONID.toString(), "", e.getMessage() + ExceptionUtils.getStackTrace(e)); @@ -360,7 +359,7 @@ public Object patchApi(ApiName apiName, List pathsegments, String queryP } } - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "RegistrationProcessorRestClientServiceImpl::postApi()::exit"); return obj; } @@ -376,7 +375,7 @@ public Object patchApi(ApiName apiName, List pathsegments, String queryP public Object putApi(ApiName apiName, List pathsegments, String queryParamName, String queryParamValue, Object requestedData, Class responseType, MediaType mediaType) throws ApisResourceAccessException { - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "RegistrationProcessorRestClientServiceImpl::putApi()::entry"); Object obj = null; String apiHostIpPort = env.getProperty(apiName.name()); @@ -406,7 +405,7 @@ public Object putApi(ApiName apiName, List pathsegments, String queryPar obj = restApiClient.putApi(builder.toUriString(), requestedData, responseType, mediaType); } catch (Exception e) { - regProcLogger.error(LoggerFileConstant.SESSIONID.toString(), + printLogger.error(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.REGISTRATIONID.toString(), "", e.getMessage() + ExceptionUtils.getStackTrace(e)); @@ -414,7 +413,7 @@ public Object putApi(ApiName apiName, List pathsegments, String queryPar PlatformErrorMessages.PRT_RCT_UNKNOWN_RESOURCE_EXCEPTION.getMessage(), e); } } - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "RegistrationProcessorRestClientServiceImpl::putApi()::exit"); return obj; } diff --git a/src/main/java/io/mosip/print/service/impl/PrintServiceImpl.java b/src/main/java/io/mosip/print/service/impl/PrintServiceImpl.java index 951d9a10..96992ddd 100644 --- a/src/main/java/io/mosip/print/service/impl/PrintServiceImpl.java +++ b/src/main/java/io/mosip/print/service/impl/PrintServiceImpl.java @@ -1,89 +1,57 @@ package io.mosip.print.service.impl; -import java.io.ByteArrayInputStream; -import java.io.DataInputStream; -import java.io.File; -import java.io.IOException; -import java.io.InputStream; -import java.sql.Timestamp; -import java.time.LocalDateTime; -import java.time.format.DateTimeFormatter; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Base64; -import java.util.HashMap; -import java.util.Iterator; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.UUID; - -import org.joda.time.DateTime; -import org.json.simple.JSONArray; -import org.json.simple.JSONObject; -import org.json.simple.parser.JSONParser; -import org.json.simple.parser.ParseException; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.beans.factory.annotation.Value; -import org.springframework.core.env.Environment; -import org.springframework.http.HttpHeaders; -import org.springframework.stereotype.Service; - import com.fasterxml.jackson.core.JsonParseException; import com.fasterxml.jackson.databind.JsonMappingException; +import com.fasterxml.jackson.databind.ObjectMapper; import com.google.gson.Gson; import com.google.gson.GsonBuilder; - -import io.mosip.kernel.core.cbeffutil.spi.CbeffUtil; -import io.mosip.kernel.core.exception.ExceptionUtils; -import io.mosip.kernel.core.logger.spi.Logger; -import io.mosip.kernel.core.pdfgenerator.exception.PDFGeneratorException; -import io.mosip.kernel.core.qrcodegenerator.exception.QrcodeGenerationException; -import io.mosip.kernel.core.qrcodegenerator.spi.QrCodeGenerator; -import io.mosip.kernel.core.util.CryptoUtil; -import io.mosip.kernel.core.util.DateUtils; import io.mosip.kernel.core.websub.spi.PublisherClient; -import io.mosip.kernel.pdfgenerator.itext.constant.PDFGeneratorExceptionCodeConstant; -import io.mosip.kernel.qrcode.generator.zxing.constant.QrVersion; -import io.mosip.print.constant.ApiName; -import io.mosip.print.constant.CardType; -import io.mosip.print.constant.EventId; -import io.mosip.print.constant.EventName; -import io.mosip.print.constant.EventType; -import io.mosip.print.constant.IdType; -import io.mosip.print.constant.LoggerFileConstant; -import io.mosip.print.constant.ModuleName; -import io.mosip.print.constant.PlatformSuccessMessages; -import io.mosip.print.constant.UinCardType; -import io.mosip.print.dto.JsonValue; -import io.mosip.print.dto.VidRequestDto; -import io.mosip.print.dto.VidResponseDTO; -import io.mosip.print.exception.ApisResourceAccessException; -import io.mosip.print.exception.IdRepoAppException; -import io.mosip.print.exception.IdentityNotFoundException; -import io.mosip.print.exception.PDFSignatureException; -import io.mosip.print.exception.ParsingException; -import io.mosip.print.exception.PlatformErrorMessages; -import io.mosip.print.exception.TemplateProcessingFailureException; -import io.mosip.print.exception.UINNotFoundInDatabase; -import io.mosip.print.exception.VidCreationException; +import io.mosip.print.constant.*; +import io.mosip.print.core.http.RequestWrapper; +import io.mosip.print.dto.*; +import io.mosip.print.entity.MspCardEntity; +import io.mosip.print.exception.*; import io.mosip.print.idrepo.dto.IdResponseDTO1; import io.mosip.print.logger.LogDescription; import io.mosip.print.logger.PrintLogger; import io.mosip.print.model.CredentialStatusEvent; +import io.mosip.print.model.EventModel; import io.mosip.print.model.StatusEvent; +import io.mosip.print.repository.MspCardRepository; import io.mosip.print.service.PrintRestClientService; import io.mosip.print.service.PrintService; import io.mosip.print.service.UinCardGenerator; -import io.mosip.print.util.AuditLogRequestBuilder; -import io.mosip.print.util.CbeffToBiometricUtil; -import io.mosip.print.util.DigitalSignatureUtility; -import io.mosip.print.util.JsonUtil; -import io.mosip.print.util.TemplateGenerator; -import io.mosip.print.util.Utilities; -import io.mosip.print.util.WebSubSubscriptionHelper; -import io.mosip.registration.print.core.http.RequestWrapper; +import io.mosip.print.spi.CbeffUtil; +import io.mosip.print.spi.QrCodeGenerator; +import io.mosip.print.util.*; +import org.apache.commons.codec.binary.Base64; +import org.joda.time.DateTime; +import org.json.simple.JSONArray; +import org.json.simple.JSONObject; +import org.json.simple.parser.JSONParser; +import org.json.simple.parser.ParseException; +import org.slf4j.Logger; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Qualifier; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.core.env.Environment; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.stereotype.Service; + +import javax.crypto.BadPaddingException; +import javax.crypto.IllegalBlockSizeException; +import java.io.*; +import java.net.URI; +import java.security.InvalidAlgorithmParameterException; +import java.security.InvalidKeyException; +import java.security.NoSuchAlgorithmException; +import java.security.spec.InvalidKeySpecException; +import java.sql.Timestamp; +import java.time.LocalDateTime; +import java.time.format.DateTimeFormatter; +import java.util.*; @Service public class PrintServiceImpl implements PrintService{ @@ -93,6 +61,15 @@ public class PrintServiceImpl implements PrintService{ @Autowired private WebSubSubscriptionHelper webSubSubscriptionHelper; + @Autowired + CryptoUtil cryptoUtil; + + @Autowired + private RestApiClient restApiClient; + + @Autowired + private CryptoCoreUtil cryptoCoreUtil; + /** The Constant FILE_SEPARATOR. */ public static final String FILE_SEPARATOR = File.separator; @@ -107,16 +84,6 @@ public class PrintServiceImpl implements PrintService{ @Value("${mosip.secondary-language}") private String secondaryLang; - /** The un masked length. */ - @Value("${registration.processor.unMaskedUin.length}") - private int unMaskedLength; - - /** The uin length. */ - @Value("${mosip.kernel.uin.length}") - private int uinLength; - - @Value("${mosip.print.uin.header.length}") - private int headerLength; /** The Constant UIN_CARD_TEMPLATE. */ private static final String UIN_CARD_TEMPLATE = "RPR_UIN_CARD_TEMPLATE"; @@ -141,8 +108,8 @@ public class PrintServiceImpl implements PrintService{ /** The Constant UINCARDPASSWORD. */ private static final String UINCARDPASSWORD = "mosip.registration.processor.print.service.uincard.password"; - /** The reg proc logger. */ - private static Logger printLogger = PrintLogger.getLogger(PrintServiceImpl.class); + /** The print logger. */ + Logger printLogger = PrintLogger.getLogger(PrintServiceImpl.class); /** The core audit request builder. */ @Autowired @@ -164,10 +131,6 @@ public class PrintServiceImpl implements PrintService{ @Autowired private PrintRestClientService restClientService; - /** The registration status service. */ - // @Autowired - // RegistrationStatusService registrationStatusService; /** The qr code generator. */ @Autowired @@ -203,6 +166,80 @@ public class PrintServiceImpl implements PrintService{ @Autowired private PublisherClient pb; + @Value("${mosip.datashare.partner.id}") + private String partnerId; + + @Value("${mosip.datashare.policy.id}") + private String policyId; + + @Autowired + @Qualifier("mspCardRepository") + MspCardRepository mspCardRepository; + + @Autowired + ObjectMapper mapper; + + public void generateCard(EventModel eventModel) throws Exception { + Map byteMap = new HashMap<>(); + String decodedCrdential = null; + String credential = null; + if (eventModel.getEvent().getDataShareUri() == null || eventModel.getEvent().getDataShareUri().isEmpty()) { + credential = eventModel.getEvent().getData().get("credential").toString(); + } else { + String dataShareUrl = eventModel.getEvent().getDataShareUri(); + URI dataShareUri = URI.create(dataShareUrl); + credential = restApiClient.getApi(dataShareUri, String.class); + } + + String ecryptionPin = eventModel.getEvent().getData().get("protectionKey").toString(); + decodedCrdential = cryptoCoreUtil.decrypt(credential); + + Map proofMap = new HashMap(); + proofMap = (Map) eventModel.getEvent().getData().get("proof"); + String sign = proofMap.get("signature").toString(); + Map attributes = getDocuments(decodedCrdential, + eventModel.getEvent().getData().get("credentialType").toString(), ecryptionPin, + eventModel.getEvent().getTransactionId(), getSignature(sign, credential), "UIN", false, eventModel.getEvent().getId(), + eventModel.getEvent().getData().get("registrationId").toString(), eventModel.getEvent().getData().get("vid").toString()); + + + String printid = (String) eventModel.getEvent().getId(); + + org.json.simple.JSONObject obj = new org.json.simple.JSONObject(); + obj.put("photo",attributes.get(APPLICANT_PHOTO)); + obj.put("qrCode",attributes.get(QRCODE)); + obj.put("address", ((attributes.get("address") != null && !attributes.get("address").equals("")) ? attributes.get("address").toString() : "N/A")); + obj.put("locality", ((attributes.get("locality") != null && !attributes.get("locality").equals("")) ? attributes.get("locality").toString() : "N/A")); + obj.put("city", ((attributes.get("city") != null && !attributes.get("city").equals("")) ? attributes.get("city").toString() : "N/A")); + obj.put("state", ((attributes.get("state") != null && !attributes.get("state").equals("")) ? attributes.get("state").toString() : "N/A")); + obj.put("postalCode", ((attributes.get("postalCode") != null && !attributes.get("postalCode").equals("")) ? attributes.get("postalCode").toString() : "N/A")); + obj.put("gender", ((attributes.get("gender") != null && !attributes.get("gender").equals("")) ? attributes.get("gender").toString() : "N/A")); + obj.put("fullName", ((attributes.get("fullName") != null && !attributes.get("fullName").equals("")) ? attributes.get("fullName").toString() : "N/A")); + obj.put("dateOfBirth", ((attributes.get("dateOfBirth") != null && !attributes.get("dateOfBirth").equals("")) ? attributes.get("dateOfBirth").toString() : "N/A")); + obj.put("phone", ((attributes.get("phone") != null && !attributes.get("phone").equals("")) ? attributes.get("phone").toString() : "N/A")); + obj.put("vid", ((attributes.get("VID") != null && !attributes.get("VID").equals("")) ? attributes.get("VID").toString() : "N/A")); + obj.put("UIN", ((attributes.get("UIN") != null && !attributes.get("UIN").equals("")) ? attributes.get("UIN").toString() : "N/A")); + obj.put("email", ((attributes.get("email") != null && !attributes.get("email").equals("")) ? attributes.get("email").toString() : "N/A")); + + String woenc = obj.toJSONString(); + + MspCardEntity mspCardEntity = new MspCardEntity(); + mspCardEntity.setJsonData(woenc); + mspCardEntity.setRequestId(printid); + mspCardEntity.setStatus(90); + UUID uuid=UUID.randomUUID(); + mspCardEntity.setId(uuid.toString()); + mspCardRepository.create(mspCardEntity); + + } + + private String getSignature(String sign, String crdential) { + String signHeader = sign.split("\\.")[0]; + String signData = sign.split("\\.")[2]; + String signature = signHeader + "." + crdential + "." + signData; + return signature; + } + /* * (non-Javadoc) @@ -212,72 +249,60 @@ public class PrintServiceImpl implements PrintService{ * java.lang.String, java.lang.String, boolean) */ - @Override @SuppressWarnings("rawtypes") - public Map getDocuments(String credential, String requestId, String sign, String cardType, - boolean isPasswordProtected) { - printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.REGISTRATIONID.toString(), "", + private Map getDocuments(String credential, String credentialType, String encryptionPin, + String requestId, String sign, + String cardType, + boolean isPasswordProtected, String refId, String registrationId, String vid) { + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.REGISTRATIONID.toString(), "PrintServiceImpl::getDocuments()::entry"); + String credentialSubject; Map byteMap = new HashMap<>(); String uin = null; LogDescription description = new LogDescription(); - String vid = null; + String password = null; String individualBio = null; Map attributes = new LinkedHashMap<>(); boolean isTransactionSuccessful = false; IdResponseDTO1 response = null; String template = UIN_CARD_TEMPLATE; + byte[] pdfbytes = null; try { + credentialSubject = getCrdentialSubject(credential); org.json.JSONObject credentialSubjectJson = new org.json.JSONObject(credentialSubject); - individualBio = credentialSubjectJson.getString("individualBiometrics"); + org.json.JSONObject decryptedJson = decryptAttribute(credentialSubjectJson, encryptionPin, credential); + individualBio = decryptedJson.getString("biometrics"); String individualBiometric = new String(individualBio); - uin = credentialSubjectJson.getString("UIN"); + uin = decryptedJson.getString("UIN"); + if (isPasswordProtected) { + password = getPassword(uin); + } + boolean isPhotoSet = setApplicantPhoto(individualBiometric, attributes); if (!isPhotoSet) { printLogger.debug(LoggerFileConstant.SESSIONID.toString(), - LoggerFileConstant.REGISTRATIONID.toString(), uin, + LoggerFileConstant.REGISTRATIONID.toString(), uin + PlatformErrorMessages.PRT_PRT_APPLICANT_PHOTO_NOT_SET.name()); } - setTemplateAttributes(credentialSubject, attributes); + setTemplateAttributes(decryptedJson.toString(), attributes); attributes.put(IdType.UIN.toString(), uin); + attributes.put(IdType.VID.toString(), vid); - byte[] textFileByte = createTextFile(credentialSubject); + byte[] textFileByte = createTextFile(decryptedJson.toString()); byteMap.put(UIN_TEXT_FILE, textFileByte); - boolean isQRcodeSet = setQrCode(credentialSubject, attributes); + boolean isQRcodeSet = setQrCode(decryptedJson.toString(), attributes); if (!isQRcodeSet) { printLogger.debug(LoggerFileConstant.SESSIONID.toString(), - LoggerFileConstant.REGISTRATIONID.toString(), uin, + LoggerFileConstant.REGISTRATIONID.toString(), uin + PlatformErrorMessages.PRT_PRT_QRCODE_NOT_SET.name()); } - template = setTemplateForMaskedUIN(cardType, uin, vid, attributes, template); - - // getting template and placing original valuespng - InputStream uinArtifact = templateGenerator.getTemplate(template, attributes, primaryLang); - if (uinArtifact == null) { - printLogger.error(LoggerFileConstant.SESSIONID.toString(), - LoggerFileConstant.REGISTRATIONID.toString(), "UIN", - PlatformErrorMessages.PRT_TEM_PROCESSING_FAILURE.name()); - throw new TemplateProcessingFailureException( - PlatformErrorMessages.PRT_TEM_PROCESSING_FAILURE.getCode()); - } - - String password = null; - if (isPasswordProtected) { - password = getPassword(uin); - } - - // generating pdf - byte[] pdfbytes = uinCardGenerator.generateUinCard(uinArtifact, UinCardType.PDF, password); - byteMap.put(UIN_CARD_PDF, pdfbytes); - byte[] uinbyte = attributes.get("UIN").toString().getBytes(); - byteMap.put("UIN", uinbyte); - printStatusUpdate(requestId); + printStatusUpdate(requestId, credentialType, uin, refId, registrationId); isTransactionSuccessful = true; } catch (VidCreationException e) { @@ -381,21 +406,7 @@ public Map getDocuments(String credential, String requestId, Str printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.REGISTRATIONID.toString(), "", "PrintServiceImpl::getDocuments()::exit"); - return byteMap; - } - - private String setTemplateForMaskedUIN(String cardType, String uin, String vid, Map attributes, - String template) throws ApisResourceAccessException, VidCreationException, IOException { - if (cardType.equalsIgnoreCase(CardType.MASKED_UIN.toString())) { - template = MASKED_UIN_CARD_TEMPLATE; - if (vid == null) { - vid = getVid(uin); - } - attributes.put(IdType.VID.toString(), vid); - String maskedUin = maskString(uin, uinLength - unMaskedLength, '*'); - attributes.put(IdType.UIN.toString(), maskedUin); - } - return template; + return attributes; } /** @@ -484,21 +495,22 @@ private byte[] createTextFile(String jsonString) throws IOException { /** * Sets the qr code. * - * @param textFileByte - * the text file byte - * @param attributes - * the attributes + * @param qrString the text file byte + * @param attributes the attributes * @return true, if successful + * @throws QrcodeGenerationException the qrcode + * generation + * exception + * @throws IOException Signals that an + * I/O exception has + * occurred. * @throws QrcodeGenerationException - * the qrcode generation exception - * @throws IOException - * Signals that an I/O exception has occurred. */ private boolean setQrCode(String qrString, Map attributes) - throws QrcodeGenerationException, IOException { + throws QrcodeGenerationException, IOException, QrcodeGenerationException { boolean isQRCodeSet = false; JSONObject qrJsonObj = JsonUtil.objectMapperReadValue(qrString, JSONObject.class); - qrJsonObj.remove("individualBiometrics"); + qrJsonObj.remove("biometrics"); // String digitalSignaturedQrData = // digitalSignatureUtility.getDigitalSignature(qrString); // JSONObject textFileJson = new JSONObject(); @@ -507,7 +519,7 @@ private boolean setQrCode(String qrString, Map attributes) // String printTextFileString = gson.toJson(textFileJson); byte[] qrCodeBytes = qrCodeGenerator.generateQrCode(qrJsonObj.toString(), QrVersion.V30); if (qrCodeBytes != null) { - String imageString = CryptoUtil.encodeBase64String(qrCodeBytes); + String imageString = Base64.encodeBase64String(qrCodeBytes); attributes.put(QRCODE, "data:image/png;base64," + imageString); isQRCodeSet = true; } @@ -515,10 +527,19 @@ private boolean setQrCode(String qrString, Map attributes) return isQRCodeSet; } + private byte[] generateQrCode(String qrString) + throws QrcodeGenerationException, IOException, QrcodeGenerationException { + JSONObject qrJsonObj = JsonUtil.objectMapperReadValue(qrString, JSONObject.class); + qrJsonObj.remove("biometrics"); + byte[] qrCodeBytes = qrCodeGenerator.generateQrCode(qrJsonObj.toString(), QrVersion.V30); + + return qrCodeBytes; + } + /** * Sets the applicant photo. * - * @param response + * @param individualBio * the response * @param attributes * the attributes @@ -547,7 +568,7 @@ private boolean setApplicantPhoto(String individualBio, Map attr * DatatypeConverter.printBase64Binary(IOUtils.toByteArray(dis)); */ - String data = Base64.getEncoder().encodeToString(extractFaceImageData(photoByte)); + String data = java.util.Base64.getEncoder().encodeToString(extractFaceImageData(photoByte)); attributes.put(APPLICANT_PHOTO, "data:image/png;base64," + data); isPhotoSet = true; } @@ -558,7 +579,7 @@ private boolean setApplicantPhoto(String individualBio, Map attr /** * Gets the artifacts. * - * @param idJsonString the id json string + * @param jsonString the id json string * @param attribute the attribute * @return the artifacts * @throws IOException Signals that an I/O exception has occurred. @@ -819,14 +840,15 @@ private String getCrdentialSubject(String crdential) { return credentialSubject; } - private void printStatusUpdate(String requestId) { + private void printStatusUpdate(String requestId, String credentialType, String uin, String printRefId, String registrationId) + throws DataShareException, ApiNotAccessibleException, IOException, Exception { CredentialStatusEvent creEvent = new CredentialStatusEvent(); LocalDateTime currentDtime = DateUtils.getUTCCurrentDateTime(); StatusEvent sEvent = new StatusEvent(); sEvent.setId(UUID.randomUUID().toString()); sEvent.setRequestId(requestId); sEvent.setStatus("printing"); - sEvent.setUrl(null); + sEvent.setUrl(""); sEvent.setTimestamp(Timestamp.valueOf(currentDtime).toString()); creEvent.setPublishedOn(new DateTime().toString()); creEvent.setPublisher("PRINT_SERVICE"); @@ -834,6 +856,46 @@ private void printStatusUpdate(String requestId) { creEvent.setEvent(sEvent); webSubSubscriptionHelper.printStatusUpdateEvent(topic, creEvent); } + + public org.json.JSONObject decryptAttribute(org.json.JSONObject data, String encryptionPin, String credential) { + + org.json.JSONObject jsonObj = new org.json.JSONObject(credential); + + String strq = null; + org.json.JSONArray jsonArray = (org.json.JSONArray) jsonObj.get("protectedAttributes"); + if (!jsonArray.isEmpty()) { + for (Object str : jsonArray) { + + CryptoWithPinRequestDto cryptoWithPinRequestDto = new CryptoWithPinRequestDto(); + CryptoWithPinResponseDto cryptoWithPinResponseDto = new CryptoWithPinResponseDto(); + + cryptoWithPinRequestDto.setUserPin(encryptionPin); + cryptoWithPinRequestDto.setData(data.getString(str.toString())); + /* + * response = (ResponseWrapper) + * restClientService.postApi(ApiName.DECRYPTPINBASSED, "", "", request, + * ResponseWrapper.class); + * + * decryptResponseDto = + * JsonUtil.readValue(JsonUtil.writeValueAsString(response.getResponse()), + * DecryptResponseDto.class); + */ + try { + cryptoWithPinResponseDto = cryptoUtil.decryptWithPin(cryptoWithPinRequestDto); + } catch (InvalidKeyException | NoSuchAlgorithmException | InvalidKeySpecException + | InvalidAlgorithmParameterException | IllegalBlockSizeException | BadPaddingException e) { + printLogger.error(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.REGISTRATIONID.toString(), + null, "Error while decrypting the data" + ExceptionUtils.getStackTrace(e)); + throw new CryptoManagerException(PlatformErrorMessages.PRT_INVALID_KEY_EXCEPTION.getCode(), + PlatformErrorMessages.PRT_INVALID_KEY_EXCEPTION.getMessage(), e); + } + data.put((String) str, cryptoWithPinResponseDto.getData()); + + } + + } + return data; + } } diff --git a/src/main/java/io/mosip/print/service/impl/QrcodeGeneratorImpl.java b/src/main/java/io/mosip/print/service/impl/QrcodeGeneratorImpl.java new file mode 100644 index 00000000..fc3a6f52 --- /dev/null +++ b/src/main/java/io/mosip/print/service/impl/QrcodeGeneratorImpl.java @@ -0,0 +1,84 @@ +package io.mosip.print.service.impl; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.util.Arrays; +import java.util.EnumMap; +import java.util.Map; + +import org.springframework.stereotype.Component; + +import com.google.zxing.BarcodeFormat; +import com.google.zxing.EncodeHintType; +import com.google.zxing.WriterException; +import com.google.zxing.client.j2se.MatrixToImageWriter; +import com.google.zxing.common.BitMatrix; +import com.google.zxing.qrcode.QRCodeWriter; +import com.google.zxing.qrcode.decoder.ErrorCorrectionLevel; + +import io.mosip.print.constant.QrVersion; +import io.mosip.print.constant.QrcodeConstants; +import io.mosip.print.constant.QrcodeExceptionConstants; +import io.mosip.print.exception.QrcodeGenerationException; +import io.mosip.print.spi.QrCodeGenerator; +import io.mosip.print.util.QrcodegeneratorUtils; + +/** + * Class which provides functionality to generate QR Code + * + * @author Urvil Joshi + * + * @since 1.0.0 + */ +@Component +public class QrcodeGeneratorImpl implements QrCodeGenerator { + + /** + * {@link QRCodeWriter} instance + */ + private static QRCodeWriter qrCodeWriter; + /** + * Configurations for QrCode Generator + */ + private static Map configMap; + + static { + qrCodeWriter = new QRCodeWriter(); + configMap = new EnumMap<>(EncodeHintType.class); + configMap.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.L); + } + + /* + * (non-Javadoc) + * + * @see io.mosip.kernel.qrcode.generator.zxing.QrCode#generateQrCode(java.lang. + * String, io.mosip.kernel.qrcode.generator.zxing.constant.QrVersion) + */ + @Override + public byte[] generateQrCode(String data, QrVersion version) throws QrcodeGenerationException, IOException { + QrcodegeneratorUtils.verifyInput(data, version); + configMap.put(EncodeHintType.QR_VERSION, version.getVersion()); + BitMatrix byteMatrix = null; + try { + byteMatrix = qrCodeWriter.encode(data, BarcodeFormat.QR_CODE, version.getSize(), version.getSize(), + configMap); + } catch (WriterException | IllegalArgumentException exception) { + throw new QrcodeGenerationException(QrcodeExceptionConstants.QRCODE_GENERATION_EXCEPTION.getErrorCode(), + QrcodeExceptionConstants.QRCODE_GENERATION_EXCEPTION.getErrorMessage() + exception.getMessage(), + exception); + } + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + MatrixToImageWriter.writeToStream(byteMatrix, QrcodeConstants.FILE_FORMAT, outputStream); + return outputStream.toByteArray(); + + } + + @Override + public byte[] generateQrCodeFromBinaryData(String data, QrVersion version) + throws QrcodeGenerationException, IOException { + QrcodegeneratorUtils.verifyInput(data, version); + StringBuilder stringBuilder = new StringBuilder(); + Arrays.stream(data.split("(?<=\\G.{8})")).forEach(s -> stringBuilder.append((char) Integer.parseInt(s, 2))); + return generateQrCode(stringBuilder.toString(), version); + } +} diff --git a/src/main/java/io/mosip/print/service/impl/TemplateManagerBuilderImpl.java b/src/main/java/io/mosip/print/service/impl/TemplateManagerBuilderImpl.java new file mode 100644 index 00000000..938ff030 --- /dev/null +++ b/src/main/java/io/mosip/print/service/impl/TemplateManagerBuilderImpl.java @@ -0,0 +1,99 @@ +package io.mosip.print.service.impl; + +import java.nio.charset.StandardCharsets; +import java.util.Properties; + +import org.apache.velocity.app.VelocityEngine; +import org.apache.velocity.runtime.RuntimeConstants; +import org.apache.velocity.runtime.log.NullLogChute; +import org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader; +import org.apache.velocity.runtime.resource.loader.FileResourceLoader; +import org.springframework.stereotype.Component; + +import io.mosip.print.spi.TemplateManager; +import io.mosip.print.spi.TemplateManagerBuilder; +import lombok.Getter; + +@Getter +@Component +public class TemplateManagerBuilderImpl implements TemplateManagerBuilder { + + private String resourceLoader = "classpath"; + private String templatePath = "."; + private boolean cache = Boolean.TRUE; + private String defaultEncoding = StandardCharsets.UTF_8.name(); + + /* + * (non-Javadoc) + * + * @see io.mosip.kernel.core.templatemanager.spi.TemplateManagerBuilder# + * resourceLoader(java.lang.String) + */ + @Override + public TemplateManagerBuilder resourceLoader(String resourceLoader) { + this.resourceLoader = resourceLoader; + return this; + } + + /* + * (non-Javadoc) + * + * @see + * io.mosip.kernel.core.templatemanager.spi.TemplateManagerBuilder#resourcePath( + * java.lang.String) + */ + @Override + public TemplateManagerBuilder resourcePath(String templatePath) { + this.templatePath = templatePath; + return this; + } + + /* + * (non-Javadoc) + * + * @see + * io.mosip.kernel.core.templatemanager.spi.TemplateManagerBuilder#enableCache( + * boolean) + */ + @Override + public TemplateManagerBuilder enableCache(boolean cache) { + this.cache = cache; + return this; + } + + /* + * (non-Javadoc) + * + * @see + * io.mosip.kernel.core.templatemanager.spi.TemplateManagerBuilder#encodingType( + * java.lang.String) + */ + @Override + public TemplateManagerBuilder encodingType(String defaultEncoding) { + this.defaultEncoding = defaultEncoding; + return this; + } + + /* + * (non-Javadoc) + * + * @see io.mosip.kernel.core.templatemanager.spi.TemplateManagerBuilder#build() + */ + @Override + public TemplateManager build() { + final Properties properties = new Properties(); + properties.put(RuntimeConstants.INPUT_ENCODING, defaultEncoding); + properties.put(RuntimeConstants.OUTPUT_ENCODING, defaultEncoding); + properties.put(RuntimeConstants.ENCODING_DEFAULT, defaultEncoding); + properties.put(RuntimeConstants.RESOURCE_LOADER, resourceLoader); + properties.put(RuntimeConstants.FILE_RESOURCE_LOADER_PATH, templatePath); + properties.put(RuntimeConstants.FILE_RESOURCE_LOADER_CACHE, cache); + properties.put(RuntimeConstants.RUNTIME_LOG_LOGSYSTEM_CLASS, NullLogChute.class.getName()); + properties.put("classpath.resource.loader.class", ClasspathResourceLoader.class.getName()); + properties.put("file.resource.loader.class", FileResourceLoader.class.getName()); + VelocityEngine engine = new VelocityEngine(properties); + engine.init(); + return new TemplateManagerImpl(engine); + } + +} diff --git a/src/main/java/io/mosip/print/service/impl/TemplateManagerImpl.java b/src/main/java/io/mosip/print/service/impl/TemplateManagerImpl.java new file mode 100644 index 00000000..098b0482 --- /dev/null +++ b/src/main/java/io/mosip/print/service/impl/TemplateManagerImpl.java @@ -0,0 +1,130 @@ +package io.mosip.print.service.impl; + +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.io.StringWriter; +import java.io.Writer; +import java.nio.charset.StandardCharsets; +import java.util.Map; +import java.util.Objects; + +import org.apache.velocity.Template; +import org.apache.velocity.VelocityContext; +import org.apache.velocity.app.VelocityEngine; +import org.apache.velocity.exception.MethodInvocationException; +import org.apache.velocity.exception.ParseErrorException; +import org.apache.velocity.exception.ResourceNotFoundException; + +import io.mosip.print.constant.TemplateManagerConstant; +import io.mosip.print.constant.TemplateManagerExceptionCodeConstant; +import io.mosip.print.exception.TemplateMethodInvocationException; +import io.mosip.print.exception.TemplateParsingException; +import io.mosip.print.exception.TemplateResourceNotFoundException; +import io.mosip.print.spi.TemplateManager; +import io.mosip.print.util.TemplateManagerUtil; + +/** + * Implementation of {@link TemplateManager} which uses Velocity Template + * Engine, TemplateManagerImpl will merge the template with values. + * + * @author Abhishek Kumar + * @version 1.0.0 + * @since 01-10-2018 + */ +public class TemplateManagerImpl implements TemplateManager { + private static final String DEFAULT_ENCODING_TYPE = StandardCharsets.UTF_8.name(); + private VelocityEngine velocityEngine; + + public TemplateManagerImpl(VelocityEngine engine) { + this.velocityEngine = engine; + } + + /* + * (non-Javadoc) + * + * @see io.mosip.kernel.core.templatemanager.spi.TemplateManager#merge(java.io. + * InputStream, java.util.Map) + */ + @Override + public InputStream merge(InputStream is, Map values) throws IOException { + StringWriter writer = new StringWriter(); + // logging tag name + String logTag = "templateManager-mergeTemplate"; + Objects.requireNonNull(is, TemplateManagerConstant.TEMPLATE_INPUT_STREAM_NULL.getMessage()); + Objects.requireNonNull(values, TemplateManagerConstant.TEMPLATE_VALUES_NULL.getMessage()); + VelocityContext context = TemplateManagerUtil.bindInputToContext(values); + try { + boolean isMerged = false; + if (context != null) { + isMerged = velocityEngine.evaluate(context, writer, logTag, new InputStreamReader(is)); + if (isMerged) + return new ByteArrayInputStream(writer.toString().getBytes()); + } + } catch (ResourceNotFoundException e) { + throw new TemplateResourceNotFoundException( + TemplateManagerExceptionCodeConstant.TEMPLATE_NOT_FOUND.getErrorCode(), + TemplateManagerExceptionCodeConstant.TEMPLATE_NOT_FOUND.getErrorMessage(), e); + } catch (ParseErrorException e) { + throw new TemplateParsingException(TemplateManagerExceptionCodeConstant.TEMPLATE_PARSING.getErrorCode(), + TemplateManagerExceptionCodeConstant.TEMPLATE_PARSING.getErrorMessage(), e); + } catch (MethodInvocationException e) { + throw new TemplateMethodInvocationException( + TemplateManagerExceptionCodeConstant.TEMPLATE_INVALID_REFERENCE.getErrorCode(), + TemplateManagerExceptionCodeConstant.TEMPLATE_INVALID_REFERENCE.getErrorMessage(), e); + } + return null; + } + + /* + * (non-Javadoc) + * + * @see + * io.mosip.kernel.core.templatemanager.spi.TemplateManager#merge(java.lang. + * String, java.io.Writer, java.util.Map) + */ + @Override + public boolean merge(String templateName, final Writer writer, Map values) throws IOException { + return merge(templateName, writer, values, DEFAULT_ENCODING_TYPE); + } + + /* + * (non-Javadoc) + * + * @see + * io.mosip.kernel.core.templatemanager.spi.TemplateManager#merge(java.lang. + * String, java.io.Writer, java.util.Map, java.lang.String) + */ + @Override + public boolean merge(String templateName, Writer writer, Map values, final String encodingType) + throws IOException { + boolean isMerged = false; + Template template = null; + VelocityContext context = null; + // Null Checks + Objects.requireNonNull(templateName, TemplateManagerConstant.TEMPATE_NAME_NULL.getMessage()); + Objects.requireNonNull(writer, TemplateManagerConstant.WRITER_NULL.getMessage()); + Objects.requireNonNull(encodingType, TemplateManagerConstant.ENCODING_TYPE_NULL.getMessage()); + Objects.requireNonNull(values, TemplateManagerConstant.TEMPLATE_VALUES_NULL.getMessage()); + try { + template = velocityEngine.getTemplate(templateName, encodingType); + // create context by using provided map of values + context = TemplateManagerUtil.bindInputToContext(values); + template.merge(context, writer); + isMerged = true; + } catch (ResourceNotFoundException e) { + throw new TemplateResourceNotFoundException( + TemplateManagerExceptionCodeConstant.TEMPLATE_NOT_FOUND.getErrorCode(), + TemplateManagerExceptionCodeConstant.TEMPLATE_NOT_FOUND.getErrorMessage(), e); + } catch (ParseErrorException e) { + throw new TemplateParsingException(TemplateManagerExceptionCodeConstant.TEMPLATE_PARSING.getErrorCode(), + TemplateManagerExceptionCodeConstant.TEMPLATE_PARSING.getErrorMessage(), e); + } catch (MethodInvocationException e) { + throw new TemplateMethodInvocationException( + TemplateManagerExceptionCodeConstant.TEMPLATE_INVALID_REFERENCE.getErrorCode(), + TemplateManagerExceptionCodeConstant.TEMPLATE_INVALID_REFERENCE.getErrorMessage(), e); + } + return isMerged; + } +} diff --git a/src/main/java/io/mosip/print/service/impl/UinCardGeneratorImpl.java b/src/main/java/io/mosip/print/service/impl/UinCardGeneratorImpl.java index c819e4a9..98a51403 100644 --- a/src/main/java/io/mosip/print/service/impl/UinCardGeneratorImpl.java +++ b/src/main/java/io/mosip/print/service/impl/UinCardGeneratorImpl.java @@ -6,7 +6,9 @@ import java.time.LocalDateTime; import java.time.format.DateTimeFormatter; +import org.apache.commons.codec.binary.Base64; import org.apache.commons.lang3.exception.ExceptionUtils; +import org.slf4j.Logger; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; import org.springframework.core.env.Environment; @@ -15,27 +17,25 @@ import com.fasterxml.jackson.databind.ObjectMapper; -import io.mosip.kernel.core.logger.spi.Logger; -import io.mosip.kernel.core.pdfgenerator.exception.PDFGeneratorException; -import io.mosip.kernel.core.pdfgenerator.spi.PDFGenerator; -import io.mosip.kernel.core.util.CryptoUtil; -import io.mosip.kernel.core.util.DateUtils; -import io.mosip.kernel.pdfgenerator.itext.constant.PDFGeneratorExceptionCodeConstant; import io.mosip.print.constant.ApiName; import io.mosip.print.constant.LoggerFileConstant; +import io.mosip.print.constant.PDFGeneratorExceptionCodeConstant; import io.mosip.print.constant.UinCardType; +import io.mosip.print.core.http.RequestWrapper; +import io.mosip.print.core.http.ResponseWrapper; import io.mosip.print.dto.ErrorDTO; import io.mosip.print.dto.PDFSignatureRequestDto; import io.mosip.print.dto.SignatureResponseDto; import io.mosip.print.exception.ApisResourceAccessException; +import io.mosip.print.exception.PDFGeneratorException; import io.mosip.print.exception.PDFSignatureException; import io.mosip.print.exception.PlatformErrorMessages; import io.mosip.print.logger.PrintLogger; import io.mosip.print.service.PrintRestClientService; import io.mosip.print.service.UinCardGenerator; +import io.mosip.print.spi.PDFGenerator; +import io.mosip.print.util.DateUtils; import io.mosip.print.util.RestApiClient; -import io.mosip.registration.print.core.http.RequestWrapper; -import io.mosip.registration.print.core.http.ResponseWrapper; /** * The Class UinCardGeneratorImpl. @@ -49,30 +49,28 @@ public class UinCardGeneratorImpl implements UinCardGenerator { @Autowired private PDFGenerator pdfGenerator; - /** The reg proc logger. */ - private static Logger regProcLogger = PrintLogger.getLogger(UinCardGeneratorImpl.class); + /** The print logger. */ + private Logger printLogger = PrintLogger.getLogger(UinCardGeneratorImpl.class); private static final String DATETIME_PATTERN = "mosip.print.datetime.pattern"; - @Value("${mosip.registration.processor.print.service.uincard.lowerleftx}") + @Value("${mosip.print.service.uincard.lowerleftx}") private int lowerLeftX; - @Value("${mosip.registration.processor.print.service.uincard.lowerlefty}") + @Value("${mosip.print.service.uincard.lowerlefty}") private int lowerLeftY; - @Value("${mosip.registration.processor.print.service.uincard.upperrightx}") + @Value("${mosip.print.service.uincard.upperrightx}") private int upperRightX; - @Value("${mosip.registration.processor.print.service.uincard.upperrighty}") + @Value("${mosip.print.service.uincard.upperrighty}") private int upperRightY; - @Value("${mosip.registration.processor.print.service.uincard.signature.reason}") + @Value("${mosip.print.service.uincard.signature.reason}") private String reason; - - @Autowired private PrintRestClientService restClientService; @@ -90,7 +88,7 @@ public class UinCardGeneratorImpl implements UinCardGenerator { @Override public byte[] generateUinCard(InputStream in, UinCardType type, String password) throws ApisResourceAccessException { - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "UinCardGeneratorImpl::generateUinCard()::entry"); byte[] pdfSignatured=null; ByteArrayOutputStream out = null; @@ -100,7 +98,7 @@ public byte[] generateUinCard(InputStream in, UinCardType type, String password) upperRightY, reason, 1, password); request.setApplicationId("KERNEL"); request.setReferenceId("SIGN"); - request.setData(CryptoUtil.encodeBase64String(out.toByteArray())); + request.setData(Base64.encodeBase64String(out.toByteArray())); DateTimeFormatter format = DateTimeFormatter.ofPattern(env.getProperty(DATETIME_PATTERN)); LocalDateTime localdatetime = LocalDateTime .parse(DateUtils.getUTCCurrentDateTimeString(env.getProperty(DATETIME_PATTERN)), format); @@ -124,10 +122,10 @@ public byte[] generateUinCard(InputStream in, UinCardType type, String password) signatureResponseDto = mapper.readValue(mapper.writeValueAsString(responseWrapper.getResponse()), SignatureResponseDto.class); - pdfSignatured = CryptoUtil.decodeBase64(signatureResponseDto.getData()); + pdfSignatured = Base64.decodeBase64(signatureResponseDto.getData()); } catch (IOException | PDFGeneratorException e) { - regProcLogger.error(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.REGISTRATIONID.toString(), + printLogger.error(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.REGISTRATIONID.toString(), "", PlatformErrorMessages.PRT_PRT_PDF_NOT_GENERATED.name() + e.getMessage() + ExceptionUtils.getStackTrace(e)); throw new PDFGeneratorException(PDFGeneratorExceptionCodeConstant.PDF_EXCEPTION.getErrorCode(), @@ -135,13 +133,13 @@ public byte[] generateUinCard(InputStream in, UinCardType type, String password) } catch (ApisResourceAccessException e) { e.printStackTrace(); - regProcLogger.error(LoggerFileConstant.SESSIONID.toString(), + printLogger.error(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.REGISTRATIONID.toString(), "", PlatformErrorMessages.PRT_PRT_PDF_SIGNATURE_EXCEPTION.name() + e.getMessage() + ExceptionUtils.getStackTrace(e)); throw new PDFSignatureException( e.getMessage() + ExceptionUtils.getStackTrace(e)); } - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "UinCardGeneratorImpl::generateUinCard()::exit"); return pdfSignatured; diff --git a/src/main/java/io/mosip/print/spi/CbeffUtil.java b/src/main/java/io/mosip/print/spi/CbeffUtil.java new file mode 100644 index 00000000..259ac755 --- /dev/null +++ b/src/main/java/io/mosip/print/spi/CbeffUtil.java @@ -0,0 +1,41 @@ +/** + * + */ +package io.mosip.print.spi; + +import java.util.List; +import java.util.Map; + +import io.mosip.kernel.core.cbeffutil.entity.BIR; +import io.mosip.kernel.core.cbeffutil.jaxbclasses.BIRType; + + +/** + * @author Ramadurai Pandian + * + * Interface for Cbeff Interface + * + */ +public interface CbeffUtil { + + public byte[] createXML(List cbeffPack) throws Exception; + + public byte[] updateXML(List cbeffPackList, byte[] fileBytes) throws Exception; + + public boolean validateXML(byte[] xmlBytes, byte[] xsdBytes) throws Exception; + + public boolean validateXML(byte[] xmlBytes) throws Exception; + + public Map getBDBBasedOnType(byte[] fileBytes, String type, String subType) throws Exception; + + public List getBIRDataFromXML(byte[] xmlBytes) throws Exception; + + public Map getAllBDBData(byte[] xmlBytes, String type, String subType) throws Exception; + + public byte[] createXML(List birList, byte[] xsd) throws Exception; + + public List convertBIRTypeToBIR(List birType); + + public List getBIRDataFromXMLType(byte[] xmlBytes, String type) throws Exception; + +} diff --git a/src/main/java/io/mosip/print/spi/IBioApi.java b/src/main/java/io/mosip/print/spi/IBioApi.java new file mode 100644 index 00000000..5edea7c8 --- /dev/null +++ b/src/main/java/io/mosip/print/spi/IBioApi.java @@ -0,0 +1,58 @@ +package io.mosip.print.spi; + +import io.mosip.kernel.core.bioapi.model.CompositeScore; +import io.mosip.kernel.core.bioapi.model.KeyValuePair; +import io.mosip.kernel.core.bioapi.model.QualityScore; +import io.mosip.kernel.core.bioapi.model.Score; +import io.mosip.kernel.core.cbeffutil.entity.BIR; + +/** + * The Interface IBioApi. + * + * @author Sanjay Murali + * @author Manoj SP + * + */ +public interface IBioApi { + + /** + * It checks the quality of the provided biometric image and render the + * respective quality score. + * + * @param sample the sample + * @param flags the flags + * @return the response + */ + QualityScore checkQuality(BIR sample, KeyValuePair[] flags); + + /** + * It compares the biometrics and provide the respective matching scores. + * + * @param sample the sample + * @param gallery the gallery + * @param flags the flags + * @return the response + */ + Score[] match(BIR sample, BIR[] gallery, KeyValuePair[] flags); + + /** + * Extract template. + * + * @param sample the sample + * @param flags the flags + * @return the response + */ + BIR extractTemplate(BIR sample, KeyValuePair[] flags); + + /** + * It segment the single biometric image into multiple biometric images. Eg: + * Split the thumb slab into multiple fingers + * + * @param sample the sample + * @param flags the flags + * @return the response + */ + BIR[] segment(BIR sample, KeyValuePair[] flags); + + CompositeScore compositeMatch(BIR[] sampleList, BIR[] recordList, KeyValuePair[] flags); +} diff --git a/src/main/java/io/mosip/print/spi/PDFGenerator.java b/src/main/java/io/mosip/print/spi/PDFGenerator.java new file mode 100644 index 00000000..b3c67f3b --- /dev/null +++ b/src/main/java/io/mosip/print/spi/PDFGenerator.java @@ -0,0 +1,108 @@ +package io.mosip.print.spi; + +import java.awt.image.BufferedImage; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.net.URL; +import java.security.GeneralSecurityException; +import java.security.PrivateKey; +import java.security.Provider; +import java.security.cert.X509Certificate; +import java.util.List; + +import io.mosip.print.model.CertificateEntry; +import io.mosip.print.model.Rectangle; + +/** + * This interface is has specifications for PDF generation from different types. + * + * The user of this interface will have basic functionalities related to PDF. + * + * @author Urvil Joshi + * @author Uday Kumar + * @author Neha + * + * @since 1.0.0 + */ +public interface PDFGenerator { + /** + * Converts HTML obtained from an {@link InputStream} to a PDF written to an + * {@link OutputStream}. + * + * @param htmlStream the processedTemplate in the form of a {@link InputStream} + * @throws IOException Signals that an I/O exception has occurred. + * @return outpustStream PDF Output Stream (PDF stream) + */ + public OutputStream generate(InputStream htmlStream) throws IOException; + + /** + * This method will convert process Template as String to outpustStream + * + * @param template the processedTemplate in the form of a {@link String} + * @return OutputStream PDF Output Stream (PDF stream) + * @throws IOException Signals that an I/O exception has occurred. + */ + public OutputStream generate(String template) throws IOException; + + /** + * This method will take input as template file and convert template to PDF and + * save to the given path with given fileName. + * + * @param templatePath the processedTemplate in the form of a {@link String} + * @param outputFilePath Output File Path + * @param outputFileName Output File Name + * @throws IOException Signals that an I/O exception has occurred. + */ + public void generate(String templatePath, String outputFilePath, String outputFileName) throws IOException; + + /** + * This method will convert InputStream to OutputStream. + * + * @param dataStream the processedTemplate in the form of a + * {@link InputStream}. + * @param resourceLoc resourceLoction {@link String}. + * @throws IOException Signals that an I/O exception has occurred. + * @return outpustStream PDF Output Stream (PDF stream). + */ + public OutputStream generate(InputStream dataStream, String resourceLoc) throws IOException; + + /** + * This method will convert BufferedImage list to Byte Array. + * + * @param bufferedImages the input image to convert as PDF. + * @return array comprising PDF. + * @throws IOException Signals that an I/O exception has occurred. + */ + public byte[] asPDF(List bufferedImages) throws IOException; + + /** + * This method will merge all the PDF files. + * + * @param pdfLists the URL list of PDF files. + * @return the byte array comprising merged file. + * @throws IOException Signals that an I/O exception has occurred. + */ + public byte[] mergePDF(List pdfLists) throws IOException; + + /** + * Signs a PDF and protect it with password + * + * @param pdf byte array of pdf. + * @param rectangle {@link Rectangle} class to enclose signing + * @param reason reason of signing. + * @param pageNumber page number of rectangle. + * @param provider {@link Provider}. + * @param certificateEntry {@link CertificateEntry} class for certificate and + * private key as Input; + * @param password password for protecting pdf. + * @return {@link OutputStream} of signed PDF. + * @throws IOException Signals that an I/O exception has occurred. + * @throws GeneralSecurityException Signals general security exception while + * signing. + */ + OutputStream signAndEncryptPDF(byte[] pdf, Rectangle rectangle, String reason, int pageNumber, Provider provider, + CertificateEntry certificateEntry, String password) + throws IOException, GeneralSecurityException; + +} diff --git a/src/main/java/io/mosip/print/spi/QrCodeGenerator.java b/src/main/java/io/mosip/print/spi/QrCodeGenerator.java new file mode 100644 index 00000000..72e2b6d9 --- /dev/null +++ b/src/main/java/io/mosip/print/spi/QrCodeGenerator.java @@ -0,0 +1,44 @@ +package io.mosip.print.spi; + +import java.io.IOException; + +import io.mosip.print.exception.QrcodeGenerationException; + +/** + * Interface for QR-Code-Generation + * + * @author Urvil Joshi + * + * @since 1.0.0 + * + * @param the type of QR-Version + */ + +public interface QrCodeGenerator { + + /** + * Method to generate QR Code + * + * @param data data to encode in the QR code + * @param version QR Code version + * @return array of byte containing QR Code in PNG format + * @throws QrcodeGenerationException exceptions which may occur when encoding a + * QRcode using the Writer framework. + * @throws IOException exceptions which may occur when write to + * the byte stream fail + */ + byte[] generateQrCode(String data, T version) throws QrcodeGenerationException, IOException; + + /** + * Method to generate QR Code + * + * @param data binary data to encode in the QR code + * @param version QR Code version + * @return array of byte containing QR Code in PNG format + * @throws QrcodeGenerationException exceptions which may occur when encoding a + * QRcode using the Writer framework. + * @throws IOException exceptions which may occur when write to + * the byte stream fail + */ + byte[] generateQrCodeFromBinaryData(String data, T version) throws QrcodeGenerationException, IOException; +} \ No newline at end of file diff --git a/src/main/java/io/mosip/print/spi/TemplateManager.java b/src/main/java/io/mosip/print/spi/TemplateManager.java new file mode 100644 index 00000000..cd0412a5 --- /dev/null +++ b/src/main/java/io/mosip/print/spi/TemplateManager.java @@ -0,0 +1,54 @@ +package io.mosip.print.spi; + +import java.io.IOException; +import java.io.InputStream; +import java.io.Writer; +import java.util.Map; + +/** + * TemplateManager which will merge the template and values together. + * + * @author Abhishek Kumar + * @since 2018-10-01 + * @version 1.0.0 + */ +public interface TemplateManager { + /** + * Method to merge template , where template content will be pass as inputSteam + * + * @param template the {@link InputStream} is template content . + * @param values as Map<String,Object > where key will be placeholder + * name and Object is the actual value for the placeholder + * @return template merged template content as {@link InputStream} + * @throws IOException if an I/O exception occurs during writing to the writer + * + */ + public InputStream merge(InputStream template, Map values) throws IOException; + + /** + * Merges a template and puts the rendered stream into the writer. The default + * encoding that template manager uses to read template files is UTF-8 + * + * @param templateName name of template to be used in merge + * @param writer output writer for rendered template + * @param values as Map<String,Object > where key is placeholder + * name and Object is Placeholder value + * @return boolean true if successfully, false otherwise. + * @throws IOException if an I/O exception occurs during writing to the writer + */ + public boolean merge(String templateName, Writer writer, Map values) throws IOException; + + /** + * Method to merge template using provided encoding type + * + * @param templateName name of the template to be used in merge + * @param writer output writer for render template + * @param values as Map<String,Object > where key is placeholder + * name and Object is value for the placeholder + * @param encodingType as String like UTF-8,UTF-16 etc. + * @return boolean true if successfully, false otherwise + * @throws IOException if an I/O exception occurs during writing to the writer + */ + public boolean merge(String templateName, Writer writer, Map values, final String encodingType) + throws IOException; +} diff --git a/src/main/java/io/mosip/print/spi/TemplateManagerBuilder.java b/src/main/java/io/mosip/print/spi/TemplateManagerBuilder.java new file mode 100644 index 00000000..1d38ea3d --- /dev/null +++ b/src/main/java/io/mosip/print/spi/TemplateManagerBuilder.java @@ -0,0 +1,52 @@ +package io.mosip.print.spi; + +/** + * TemplateManagerBuilder will build the {@link TemplateManager} with the + * configuration either custom or default. + * + * @author Abhishek Kumar + * @version 1.0.0 + * @since 22-11-2018 + * + */ +public interface TemplateManagerBuilder { + /** + * Method for overriding the resourceLoader, default is classPath + * + * @param resourceLoader the resourceLoader will specify from where to load + * templates ,default value is classPath + * @return {@link TemplateManagerBuilder} + */ + TemplateManagerBuilder resourceLoader(String resourceLoader); + + /** + * Method for overriding the template location + * + * @param templatePath as String , template location + * @return {@link TemplateManagerBuilder} + */ + TemplateManagerBuilder resourcePath(String templatePath); + + /** + * Method to disable or enable cache + * + * @param cache cache template in memory , default is true + * @return {@link TemplateManagerBuilder} + */ + TemplateManagerBuilder enableCache(boolean cache); + + /** + * Method for setting up encoding type + * + * @param defaultEncoding template encoding type, default is UTF-8 + * @return {@link TemplateManagerBuilder} + */ + TemplateManagerBuilder encodingType(String defaultEncoding); + + /** + * Method to build the {@link TemplateManager} with required configuration + * + * @return {@link TemplateManager} + */ + TemplateManager build(); +} diff --git a/src/main/java/io/mosip/print/util/AuditLogRequestBuilder.java b/src/main/java/io/mosip/print/util/AuditLogRequestBuilder.java index 0dfc9d4c..48e1f23b 100644 --- a/src/main/java/io/mosip/print/util/AuditLogRequestBuilder.java +++ b/src/main/java/io/mosip/print/util/AuditLogRequestBuilder.java @@ -9,16 +9,15 @@ import org.springframework.core.env.Environment; import org.springframework.stereotype.Component; -import io.mosip.kernel.core.util.DateUtils; import io.mosip.print.constant.ApiName; import io.mosip.print.constant.AuditLogConstant; import io.mosip.print.constant.LoggerFileConstant; +import io.mosip.print.core.http.RequestWrapper; +import io.mosip.print.core.http.ResponseWrapper; import io.mosip.print.dto.AuditRequestDto; import io.mosip.print.dto.AuditResponseDto; import io.mosip.print.exception.ApisResourceAccessException; import io.mosip.print.service.PrintRestClientService; -import io.mosip.registration.print.core.http.RequestWrapper; -import io.mosip.registration.print.core.http.ResponseWrapper; /** * The Class AuditRequestBuilder. @@ -29,7 +28,7 @@ public class AuditLogRequestBuilder { /** The logger. */ - private final Logger regProcLogger = LoggerFactory.getLogger(AuditLogRequestBuilder.class); + private final Logger printLogger = LoggerFactory.getLogger(AuditLogRequestBuilder.class); /** The registration processor rest service. */ @Autowired @@ -60,7 +59,7 @@ public class AuditLogRequestBuilder { @SuppressWarnings("unchecked") public ResponseWrapper createAuditRequestBuilder(String description, String eventId, String eventName, String eventType, String registrationId, ApiName apiname) { - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.REGISTRATIONID.toString(), + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.REGISTRATIONID.toString(), registrationId, "AuditLogRequestBuilder:: createAuditRequestBuilder(String description, String eventId, String eventName, String eventType,\r\n" + " String registrationId, ApiName apiname)::entry"); @@ -97,10 +96,10 @@ public ResponseWrapper createAuditRequestBuilder(String descri "", requestWrapper, ResponseWrapper.class); } catch (ApisResourceAccessException arae) { - regProcLogger.error(arae.getMessage()); + printLogger.error(arae.getMessage()); } - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.REGISTRATIONID.toString(), + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.REGISTRATIONID.toString(), registrationId, "AuditLogRequestBuilder:: createAuditRequestBuilder(String description, String eventId, String eventName, String eventType,\r\n" + " String registrationId, ApiName apiname)::exit"); @@ -111,7 +110,7 @@ public ResponseWrapper createAuditRequestBuilder(String descri @SuppressWarnings("unchecked") public ResponseWrapper createAuditRequestBuilder(String description, String eventId, String eventName, String eventType, String moduleId, String moduleName, String registrationId) { - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.REGISTRATIONID.toString(), + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.REGISTRATIONID.toString(), registrationId, "AuditLogRequestBuilder:: createAuditRequestBuilder(String description, String eventId, String eventName, String eventType,String moduleId,String moduleName,\r\n" + " String registrationId)::entry"); @@ -152,10 +151,10 @@ public ResponseWrapper createAuditRequestBuilder(String descri } catch (ApisResourceAccessException arae) { - regProcLogger.error(arae.getMessage()); + printLogger.error(arae.getMessage()); } - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.REGISTRATIONID.toString(), + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.REGISTRATIONID.toString(), registrationId, "AuditLogRequestBuilder:: createAuditRequestBuilder(String description, String eventId, String eventName, String eventType,String moduleId,String moduleName,\r\n" + " String registrationId)::exit"); diff --git a/src/main/java/io/mosip/print/util/CbeffToBiometricUtil.java b/src/main/java/io/mosip/print/util/CbeffToBiometricUtil.java index 08994012..e17c4134 100644 --- a/src/main/java/io/mosip/print/util/CbeffToBiometricUtil.java +++ b/src/main/java/io/mosip/print/util/CbeffToBiometricUtil.java @@ -5,21 +5,21 @@ import java.util.ArrayList; import java.util.List; -import io.mosip.kernel.bioapi.impl.BioApiImpl; -import io.mosip.kernel.cbeffutil.impl.CbeffImpl; -import io.mosip.kernel.core.bioapi.exception.BiometricException; -import io.mosip.kernel.core.bioapi.model.KeyValuePair; -import io.mosip.kernel.core.bioapi.spi.IBioApi; +import org.apache.commons.codec.binary.Base64; +import org.slf4j.Logger; + import io.mosip.kernel.core.cbeffutil.entity.BIR; import io.mosip.kernel.core.cbeffutil.jaxbclasses.BIRType; import io.mosip.kernel.core.cbeffutil.jaxbclasses.SingleType; -import io.mosip.kernel.core.cbeffutil.spi.CbeffUtil; -import io.mosip.kernel.core.logger.spi.Logger; -import io.mosip.kernel.core.util.CryptoUtil; import io.mosip.print.constant.LoggerFileConstant; +import io.mosip.print.exception.BiometricException; import io.mosip.print.exception.BiometricTagMatchException; import io.mosip.print.exception.PlatformErrorMessages; import io.mosip.print.logger.PrintLogger; +import io.mosip.print.service.impl.BioApiImpl; +import io.mosip.print.service.impl.CbeffImpl; +import io.mosip.print.spi.CbeffUtil; +import io.mosip.print.spi.IBioApi; /** * The Class CbeffToBiometricUtil. @@ -29,8 +29,8 @@ */ public class CbeffToBiometricUtil { - /** The reg proc logger. */ - private static Logger regProcLogger = PrintLogger.getLogger(CbeffToBiometricUtil.class); + /** The print logger. */ + Logger printLogger = PrintLogger.getLogger(CbeffToBiometricUtil.class); /** The cbeffutil. */ private CbeffUtil cbeffutil=new CbeffImpl(); @@ -40,8 +40,7 @@ public class CbeffToBiometricUtil { /** * Instantiates a new cbeff to biometric util. * - * @param cbeffutil - * the cbeffutil + * @param cbeffutil the cbeffutil */ public CbeffToBiometricUtil(CbeffUtil cbeffutil) { this.cbeffutil = cbeffutil; @@ -69,7 +68,7 @@ public CbeffToBiometricUtil() { * the exception */ public byte[] getImageBytes(String cbeffFileString, String type, List subType) throws Exception { - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "CbeffToBiometricUtil::getImageBytes()::entry"); byte[] photoBytes = null; @@ -77,7 +76,7 @@ public byte[] getImageBytes(String cbeffFileString, String type, List su List bIRTypeList = getBIRTypeList(cbeffFileString); photoBytes = getPhotoByTypeAndSubType(bIRTypeList, type, subType); } - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "CbeffToBiometricUtil::getImageBytes()::exit"); return photoBytes; @@ -158,7 +157,7 @@ private boolean isSingleType(String type, List singleTypeList) { */ public InputStream mergeCbeff(String cbeffFile1, String cbeffFile2) throws Exception { byte[] mergedCbeffByte = null; - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "CbeffToBiometricUtil::mergeCbeff()::entry"); /* @@ -176,7 +175,7 @@ public InputStream mergeCbeff(String cbeffFile1, String cbeffFile2) throws Excep file1BirTypeList.addAll(file2BirTypeList); mergedCbeffByte = cbeffutil.createXML(convertBIRTYPEtoBIR(file1BirTypeList)); // } - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "CbeffToBiometricUtil::mergeCbeff()::exit"); return new ByteArrayInputStream(mergedCbeffByte); @@ -261,7 +260,7 @@ private boolean isBiometricTypeSame(List file1BirTypeList, List types) throws Exception { List extractedType = new ArrayList<>(); - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "CbeffToBiometricUtil::extractCbeffWithTypes()::entry"); byte[] newCbeffByte = null; @@ -279,7 +278,7 @@ public InputStream extractCbeffWithTypes(String cbeffFile, List types) t } else { return null; } - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "CbeffToBiometricUtil::extractCbeffWithTypes()::exit"); return new ByteArrayInputStream(newCbeffByte); @@ -308,7 +307,7 @@ public List convertBIRTYPEtoBIR(List listOfBIR) { */ public List getBIRTypeList(String cbeffFileString) throws Exception { - return cbeffutil.getBIRDataFromXML(CryptoUtil.decodeBase64(cbeffFileString)); + return cbeffutil.getBIRDataFromXML(Base64.decodeBase64(cbeffFileString)); } /** * Gets the BIR type list. @@ -328,8 +327,9 @@ public List getBIRDataFromXML(byte[] xmlBytes) throws Exception { * @return the biometric record * @throws BiometricException */ - public BIR extractTemplate(BIR sample, KeyValuePair[] flags) throws BiometricException { - return bioAPi.extractTemplate(sample, flags).getResponse(); + public BIR extractTemplate(BIR sample, io.mosip.kernel.core.bioapi.model.KeyValuePair[] flags) + throws BiometricException { + return bioAPi.extractTemplate(sample, flags); } } diff --git a/src/main/java/io/mosip/print/util/CryptoCoreUtil.java b/src/main/java/io/mosip/print/util/CryptoCoreUtil.java new file mode 100644 index 00000000..d8ae50f2 --- /dev/null +++ b/src/main/java/io/mosip/print/util/CryptoCoreUtil.java @@ -0,0 +1,211 @@ +package io.mosip.print.util; + +import static java.util.Arrays.copyOfRange; + +import java.io.IOException; +import java.io.InputStream; +import java.math.BigInteger; +import java.security.InvalidAlgorithmParameterException; +import java.security.InvalidKeyException; +import java.security.KeyStore; +import java.security.KeyStore.PasswordProtection; +import java.security.KeyStore.PrivateKeyEntry; +import java.security.KeyStore.ProtectionParameter; +import java.security.KeyStoreException; +import java.security.NoSuchAlgorithmException; +import java.security.PrivateKey; +import java.security.UnrecoverableEntryException; +import java.security.cert.Certificate; +import java.security.cert.CertificateException; +import java.security.interfaces.RSAPrivateKey; +import java.security.spec.MGF1ParameterSpec; +import java.util.Arrays; + +import javax.crypto.BadPaddingException; +import javax.crypto.Cipher; +import javax.crypto.IllegalBlockSizeException; +import javax.crypto.NoSuchPaddingException; +import javax.crypto.SecretKey; +import javax.crypto.spec.GCMParameterSpec; +import javax.crypto.spec.OAEPParameterSpec; +import javax.crypto.spec.PSource.PSpecified; +import javax.crypto.spec.SecretKeySpec; + +import org.apache.commons.codec.digest.DigestUtils; +import org.bouncycastle.crypto.InvalidCipherTextException; +import org.bouncycastle.crypto.digests.SHA256Digest; +import org.bouncycastle.crypto.encodings.OAEPEncoding; +import org.bouncycastle.crypto.engines.RSAEngine; +import org.bouncycastle.crypto.params.RSAKeyParameters; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Component; + +import io.mosip.print.exception.CryptoManagerException; +import io.mosip.print.exception.PlatformErrorMessages; + +@Component +public class CryptoCoreUtil { + + private final static String RSA_ECB_OAEP_PADDING = "RSA/ECB/OAEPWITHSHA-256ANDMGF1PADDING"; + + private final static int THUMBPRINT_LENGTH = 32; + + @Value("${mosip.print.prependThumbprint:false}") + private boolean isThumbprint; + + public String decrypt(String data) throws Exception { + PrivateKeyEntry privateKeyEntry = loadP12(); + byte[] dataBytes = org.apache.commons.codec.binary.Base64.decodeBase64(data); + byte[] data1 = decryptData(dataBytes, privateKeyEntry); + String strData = new String(data1); + return strData; + } + + public PrivateKeyEntry loadP12() throws KeyStoreException, NoSuchAlgorithmException, CertificateException, + IOException, UnrecoverableEntryException { + KeyStore mosipKeyStore = KeyStore.getInstance("PKCS12"); + InputStream in = getClass().getClassLoader().getResourceAsStream("partner.p12"); + mosipKeyStore.load(in, "qwerty@123".toCharArray()); + ProtectionParameter password = new PasswordProtection("qwerty@123".toCharArray()); + PrivateKeyEntry privateKeyEntry = (PrivateKeyEntry) mosipKeyStore.getEntry("partner", password); + return privateKeyEntry; + } + + public byte[] decryptData(byte[] requestData, PrivateKeyEntry privateKey) throws Exception { + String keySplitter = "#KEY_SPLITTER#"; + SecretKey symmetricKey = null; + byte[] encryptedData = null; + byte[] encryptedSymmetricKey = null; + final int cipherKeyandDataLength = requestData.length; + final int keySplitterLength = keySplitter.length(); + + int keyDemiliterIndex = getSplitterIndex(requestData, 0, keySplitter); + byte[] encryptedKey = copyOfRange(requestData, 0, keyDemiliterIndex); + byte[] decryptedSymmetricKey = null; + try { + encryptedData = copyOfRange(requestData, keyDemiliterIndex + keySplitterLength, cipherKeyandDataLength); + // byte[] dataThumbprint = Arrays.copyOfRange(encryptedKey, 0, + // THUMBPRINT_LENGTH); + if (isThumbprint) { + encryptedSymmetricKey = Arrays.copyOfRange(encryptedKey, THUMBPRINT_LENGTH, encryptedKey.length); + decryptedSymmetricKey = asymmetricDecrypt(privateKey.getPrivateKey(), + ((RSAPrivateKey) privateKey.getPrivateKey()).getModulus(), encryptedSymmetricKey); + } else { + decryptedSymmetricKey = asymmetricDecrypt(privateKey.getPrivateKey(), + ((RSAPrivateKey) privateKey.getPrivateKey()).getModulus(), + encryptedKey); + } + // byte[] certThumbprint = + // getCertificateThumbprint(privateKey.getCertificate()); + + /* + * if (!Arrays.equals(dataThumbprint, certThumbprint)) { throw new + * Exception("Error in generating Certificate Thumbprint."); } + */ + + symmetricKey = new SecretKeySpec(decryptedSymmetricKey, 0, decryptedSymmetricKey.length, "AES"); + return symmetricDecrypt(symmetricKey, encryptedData, null); + } catch (Exception e) { + e.printStackTrace(); + } + throw new Exception("Not able to decrypt the data."); + } + + private static int getSplitterIndex(byte[] encryptedData, int keyDemiliterIndex, String keySplitter) { + final byte keySplitterFirstByte = keySplitter.getBytes()[0]; + final int keySplitterLength = keySplitter.length(); + for (byte data : encryptedData) { + if (data == keySplitterFirstByte) { + final String keySplit = new String( + copyOfRange(encryptedData, keyDemiliterIndex, keyDemiliterIndex + keySplitterLength)); + if (keySplitter.equals(keySplit)) { + break; + } + } + keyDemiliterIndex++; + } + return keyDemiliterIndex; + } + + /** + * + * @param privateKey + * @param keyModulus + * @param data + * @return + * @throws IllegalBlockSizeException + * @throws BadPaddingException + * @throws NoSuchAlgorithmException + * @throws NoSuchPaddingException + * @throws InvalidAlgorithmParameterException + * @throws InvalidKeyException + */ + private static byte[] asymmetricDecrypt(PrivateKey privateKey, BigInteger keyModulus, byte[] data) + throws IllegalBlockSizeException, BadPaddingException, NoSuchAlgorithmException, NoSuchPaddingException, + InvalidAlgorithmParameterException, InvalidKeyException { + + Cipher cipher; + try { + cipher = Cipher.getInstance(RSA_ECB_OAEP_PADDING); + OAEPParameterSpec oaepParams = new OAEPParameterSpec("SHA-256", "MGF1", MGF1ParameterSpec.SHA256, + PSpecified.DEFAULT); + cipher.init(Cipher.DECRYPT_MODE, privateKey, oaepParams); + return cipher.doFinal(data); + } catch (java.security.NoSuchAlgorithmException e) { + throw new NoSuchAlgorithmException(e); + } catch (NoSuchPaddingException e) { + throw new NoSuchPaddingException(e.getMessage()); + } catch (java.security.InvalidKeyException e) { + throw new InvalidKeyException(e); + } catch (InvalidAlgorithmParameterException e) { + throw new InvalidAlgorithmParameterException(e); + } + } + + /** + * + * @param paddedPlainText + * @param privateKey + * @return + * @throws InvalidCipherTextException + * @throws InvalidKeyException + */ + private static byte[] unpadOAEPPadding(byte[] paddedPlainText, BigInteger keyModulus) + throws InvalidCipherTextException { + + OAEPEncoding encode = new OAEPEncoding(new RSAEngine(), new SHA256Digest()); + BigInteger exponent = new BigInteger("1"); + RSAKeyParameters keyParams = new RSAKeyParameters(false, keyModulus, exponent); + encode.init(false, keyParams); + return encode.processBlock(paddedPlainText, 0, paddedPlainText.length); + } + + private static byte[] symmetricDecrypt(SecretKey key, byte[] data, byte[] aad) { + byte[] output = null; + try { + Cipher cipher = Cipher.getInstance("AES/GCM/PKCS5Padding"); + byte[] randomIV = Arrays.copyOfRange(data, data.length - cipher.getBlockSize(), data.length); + SecretKeySpec keySpec = new SecretKeySpec(key.getEncoded(), "AES"); + GCMParameterSpec gcmParameterSpec = new GCMParameterSpec(128, randomIV); + + cipher.init(Cipher.DECRYPT_MODE, keySpec, gcmParameterSpec); + if (aad != null && aad.length != 0) { + cipher.updateAAD(aad); + } + output = cipher.doFinal(Arrays.copyOf(data, data.length - cipher.getBlockSize())); + } catch (Exception e) { + + } + return output; + } + + public static byte[] getCertificateThumbprint(Certificate cert) { + try { + return DigestUtils.sha256(cert.getEncoded()); + } catch (java.security.cert.CertificateEncodingException e) { + + throw new CryptoManagerException(PlatformErrorMessages.CERTIFICATE_THUMBPRINT_ERROR.getCode(), + PlatformErrorMessages.CERTIFICATE_THUMBPRINT_ERROR.getMessage(), e); + } + } +} diff --git a/src/main/java/io/mosip/print/util/CryptoUtil.java b/src/main/java/io/mosip/print/util/CryptoUtil.java new file mode 100644 index 00000000..3ee586a0 --- /dev/null +++ b/src/main/java/io/mosip/print/util/CryptoUtil.java @@ -0,0 +1,225 @@ +package io.mosip.print.util; + +import java.security.InvalidAlgorithmParameterException; +import java.security.InvalidKeyException; +import java.security.NoSuchAlgorithmException; +import java.security.spec.InvalidKeySpecException; +import java.util.Arrays; + +import javax.crypto.BadPaddingException; +import javax.crypto.Cipher; +import javax.crypto.IllegalBlockSizeException; +import javax.crypto.NoSuchPaddingException; +import javax.crypto.SecretKey; +import javax.crypto.SecretKeyFactory; +import javax.crypto.spec.GCMParameterSpec; +import javax.crypto.spec.PBEKeySpec; +import javax.crypto.spec.SecretKeySpec; +import javax.xml.bind.DatatypeConverter; + +import io.mosip.print.exception.ParseException; +import org.apache.commons.codec.binary.Base64; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Component; + +import io.mosip.print.dto.CryptoWithPinRequestDto; +import io.mosip.print.dto.CryptoWithPinResponseDto; +import io.mosip.print.exception.CryptoManagerException; +import io.mosip.print.exception.PlatformErrorMessages; + +@Component +public class CryptoUtil { + + private static final int GCM_NONCE_LENGTH = 12; + + private static final int PBE_SALT_LENGTH = 32; + + private static final String AES_KEY_TYPE = "AES"; + + + @Value("${mosip.kernel.crypto.hash-symmetric-key-length:256}") + private int symmetricKeyLength; + + @Value("${mosip.kernel.crypto.hash-iteration:100000}") + private int iterations; + + @Value("${mosip.kernel.crypto.hash-algorithm-name:PBKDF2WithHmacSHA512}") + private String passwordAlgorithm; + + + /* + * public static void main(String[] args) throws NoSuchAlgorithmException, + * InvalidKeySpecException, InvalidKeyException, + * InvalidAlgorithmParameterException, IllegalBlockSizeException, + * BadPaddingException { CryptoUtil cu = new CryptoUtil(); + * CryptoWithPinRequestDto cp = new CryptoWithPinRequestDto(); cp.setData( + * "sH0LIHnUee6wGni1stdDrO2GS_MzjwchlO6-0rmWbrduPwO4BE95xEyCDnRzy3joKz_l4UNRa64t15jWcT3dW2vI3w" + * ); cp.setUserPin("abc123"); CryptoWithPinResponseDto result = + * cu.decryptWithPin(cp); System.out.println("result: " + result); } + */ + public CryptoWithPinResponseDto decryptWithPin(CryptoWithPinRequestDto requestDto) + throws NoSuchAlgorithmException, InvalidKeySpecException, InvalidKeyException, + InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException { + + String dataToDec = requestDto.getData(); + String userPin = requestDto.getUserPin(); + + byte[] decodedEncryptedData = Base64.decodeBase64(dataToDec); + byte[] pbeSalt = Arrays.copyOfRange(decodedEncryptedData, 0, PBE_SALT_LENGTH); + byte[] gcmNonce = Arrays.copyOfRange(decodedEncryptedData, PBE_SALT_LENGTH, PBE_SALT_LENGTH + GCM_NONCE_LENGTH); + byte[] encryptedData = Arrays.copyOfRange(decodedEncryptedData, PBE_SALT_LENGTH + GCM_NONCE_LENGTH, + decodedEncryptedData.length); + + SecretKey derivedKey = getDerivedKey(userPin, pbeSalt); + byte[] decryptedData = symmetricDecrypt(derivedKey, encryptedData, gcmNonce, pbeSalt); + CryptoWithPinResponseDto responseDto = new CryptoWithPinResponseDto(); + responseDto.setData(new String(decryptedData)); + return responseDto; + } + + + + private byte[] symmetricDecrypt(SecretKey key, byte[] data, byte[] iv, byte[] aad) throws InvalidKeyException, + InvalidAlgorithmParameterException, IllegalBlockSizeException, BadPaddingException { + if (iv == null) { + return symmetricDecrypt(key, data, aad); + } + Cipher cipher = null; + try { + cipher = Cipher.getInstance("AES/GCM/PKCS5Padding"); + } catch (NoSuchAlgorithmException | NoSuchPaddingException e) { + throw new CryptoManagerException(PlatformErrorMessages.PRT_INVALID_KEY_EXCEPTION.getCode(), + PlatformErrorMessages.PRT_INVALID_KEY_EXCEPTION.getMessage(), e); + } + + + SecretKeySpec keySpec = new SecretKeySpec(key.getEncoded(), "AES"); + GCMParameterSpec gcmParameterSpec = new GCMParameterSpec(128, iv); + cipher.init(Cipher.DECRYPT_MODE, keySpec, gcmParameterSpec); + if (aad != null) { + cipher.updateAAD(aad); + } + return cipher.doFinal(data); + } + + private static byte[] symmetricDecrypt(SecretKey key, byte[] data, byte[] aad) { + byte[] output = null; + try { + Cipher cipher = Cipher.getInstance("AES/GCM/PKCS5Padding"); + byte[] randomIV = Arrays.copyOfRange(data, data.length - cipher.getBlockSize(), data.length); + SecretKeySpec keySpec = new SecretKeySpec(key.getEncoded(), "AES"); + GCMParameterSpec gcmParameterSpec = new GCMParameterSpec(128, randomIV); + + cipher.init(Cipher.DECRYPT_MODE, keySpec, gcmParameterSpec); + if (aad != null && aad.length != 0) { + cipher.updateAAD(aad); + } + output = cipher.doFinal(Arrays.copyOf(data, data.length - cipher.getBlockSize())); + } catch (Exception e) { + throw new CryptoManagerException(PlatformErrorMessages.PRT_INVALID_KEY_EXCEPTION.getCode(), + PlatformErrorMessages.PRT_INVALID_KEY_EXCEPTION.getMessage(), e); + } + return output; + } + private SecretKey getDerivedKey(String userPin, byte[] salt) + throws NoSuchAlgorithmException, InvalidKeySpecException { + String derivedKeyHex = hash(userPin.getBytes(), salt); + byte[] derivedKey = hexDecode(derivedKeyHex); + return new SecretKeySpec(derivedKey, AES_KEY_TYPE); + } + + private String hash(byte[] data, byte[] salt) { + SecretKeyFactory secretKeyFactory; + char[] convertedData = new String(data).toCharArray(); + PBEKeySpec pbeKeySpec = new PBEKeySpec(convertedData, salt, iterations, symmetricKeyLength); + SecretKey key = null; + try { + secretKeyFactory = SecretKeyFactory.getInstance(passwordAlgorithm); + key = secretKeyFactory.generateSecret(pbeKeySpec); + } catch (NoSuchAlgorithmException | InvalidKeySpecException e) { + throw new CryptoManagerException(PlatformErrorMessages.PRT_INVALID_KEY_EXCEPTION.getCode(), + PlatformErrorMessages.PRT_INVALID_KEY_EXCEPTION.getMessage(), e); + } + + return DatatypeConverter.printHexBinary(key.getEncoded()); + } + + private byte[] hexDecode(String hexData) { + + char[] hexDataCharArr = hexData.toCharArray(); + int dataLength = hexDataCharArr.length; + + if ((dataLength & 0x01) != 0) { + throw new ParseException(hexData, hexData); + } + + byte[] decodedBytes = new byte[dataLength >> 1]; + + for (int i = 0, j = 0; j < dataLength; i++) { + int f = Character.digit(hexDataCharArr[j], 16) << 4; + j++; + f = f | Character.digit(hexDataCharArr[j], 16); + j++; + decodedBytes[i] = (byte) (f & 0xFF); + } + return decodedBytes; + } + /* + * public SignatureResponseDto signPDF(PDFSignatureRequestDto request) { + * SignatureCertificate signatureCertificate = + * keymanagerService.getSignatureCertificate( request.getApplicationId(), + * Optional.of(request.getReferenceId()), request.getTimeStamp()); Rectangle + * rectangle = new Rectangle(request.getLowerLeftX(), request.getLowerLeftY(), + * request.getUpperRightX(), request.getUpperRightY()); OutputStream + * outputStream; try { String providerName = + * signatureCertificate.getProviderName(); outputStream = + * pdfGenerator.signAndEncryptPDF(Base64.decodeBase64(request.getData()), + * rectangle, request.getReason(), request.getPageNumber(), + * Security.getProvider(providerName), + * signatureCertificate.getCertificateEntry(), request.getPassword()); } catch + * (IOException | GeneralSecurityException e) { throw new + * CryptoManagerException(PlatformErrorMessages.PRT_PDF_SIGN_EXCEPTION.getCode() + * , PlatformErrorMessages.PRT_PDF_SIGN_EXCEPTION.getMessage(), e); } + * SignatureResponseDto signatureResponseDto = new SignatureResponseDto(); + * signatureResponseDto + * .setData(Base64.encodeBase64URLSafeString(((ByteArrayOutputStream) + * outputStream).toByteArray())); return signatureResponseDto; } + * + * public SignatureCertificate getSignatureCertificate(String applicationId, + * Optional referenceId, String timestamp) { return + * getSigningCertificate(applicationId, referenceId, timestamp, true); } + * + * private SignatureCertificate getSigningCertificate(String applicationId, + * Optional referenceId, String timestamp, boolean isPrivateRequired) { + * String alias = null; List currentKeyAlias = null; Map> keyAliasMap = null; LocalDateTime generationDateTime = null; + * LocalDateTime expiryDateTime = null; CertificateEntry certificateEntry = null; LocalDateTime localDateTimeStamp = + * DateUtils.getUTCCurrentDateTime(); if (!referenceId.isPresent() || + * referenceId.get().trim().isEmpty()) { + * + * keyAliasMap = dbHelper.getKeyAliases(applicationId, KeymanagerConstant.EMPTY, + * localDateTimeStamp); } else { keyAliasMap = + * dbHelper.getKeyAliases(applicationId, referenceId.get(), localDateTimeStamp); + * } currentKeyAlias = keyAliasMap.get(KeymanagerConstant.CURRENTKEYALIAS); if + * (currentKeyAlias.size() > 1) { + * + * throw new + * NoUniqueAliasException(KeymanagerErrorConstant.NO_UNIQUE_ALIAS.getErrorCode() + * , KeymanagerErrorConstant.NO_UNIQUE_ALIAS.getErrorMessage()); } else if + * (currentKeyAlias.size() == 1) { + * + * KeyAlias fetchedKeyAlias = currentKeyAlias.get(0); alias = + * fetchedKeyAlias.getAlias(); certificateEntry = getCertificateEntry(alias, + * isPrivateRequired); generationDateTime = + * fetchedKeyAlias.getKeyGenerationTime(); expiryDateTime = + * fetchedKeyAlias.getKeyExpiryTime(); } else if (currentKeyAlias.isEmpty()) { + * throw new + * NoUniqueAliasException(KeymanagerErrorConstant.NO_UNIQUE_ALIAS.getErrorCode() + * , KeymanagerErrorConstant.NO_UNIQUE_ALIAS.getErrorMessage()); } String + * providerName = keyStore.getKeystoreProviderName(); return new + * SignatureCertificate(alias, certificateEntry, generationDateTime, + * expiryDateTime, providerName); } + */ + +} diff --git a/src/main/java/io/mosip/print/util/DateUtils.java b/src/main/java/io/mosip/print/util/DateUtils.java new file mode 100644 index 00000000..a5ea0a16 --- /dev/null +++ b/src/main/java/io/mosip/print/util/DateUtils.java @@ -0,0 +1,886 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package io.mosip.print.util; + +import java.text.DateFormat; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.time.Clock; +import java.time.LocalDateTime; +import java.time.OffsetDateTime; +import java.time.ZoneId; +import java.time.ZoneOffset; +import java.time.ZonedDateTime; +import java.time.format.DateTimeFormatter; +import java.util.Calendar; +import java.util.Date; +import java.util.Locale; +import java.util.Objects; +import java.util.TimeZone; + +import io.mosip.print.exception.NullPointerException; +import org.apache.commons.lang3.time.DateFormatUtils; + +import io.mosip.print.constant.DateUtilConstants; +import io.mosip.print.exception.IllegalArgumentException; + +/** + * Utilities for Date Time operations. + * + * Provide Date and Time utility for usage across the application to manipulate + * dates or calendars + * + * @author Ravi C Balaji + * @author Bal Vikash Sharma + * @since 1.0.0 + */ +public final class DateUtils { + + /** + * Default UTC TimeZone. + */ + private static final TimeZone UTC_TIME_ZONE = TimeZone.getTimeZone("UTC"); + /** + * Default UTC ZoneId. + */ + private static final ZoneId UTC_ZONE_ID = ZoneId.of("UTC"); + /** + * Default UTC pattern. + */ + private static final String UTC_DATETIME_PATTERN = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"; + + private DateUtils() { + + } + + /** + *

+ * Adds a number of days to a date returning a new Date object. + *

+ * + * @param date the date, not null + * @param days the number of days to add, may be negative + * @return the new Date with the number of days added + * @throws io.mosip.kernel.core.exception.IllegalArgumentException if the date + * is null + */ + public static Date addDays(final Date date, final int days) { + try { + return org.apache.commons.lang3.time.DateUtils.addDays(date, days); + } catch (java.lang.IllegalArgumentException e) { + throw new IllegalArgumentException(DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getErrorCode(), + DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getEexceptionMessage(), e.getCause()); + } + } + + // ----------------------------------------------------------------------- + /** + *

+ * Adds a number of hours to a date returning a new Date object. + *

+ * + * @param date the date, not null + * @param hours the hours to add, may be negative + * @return the new Date with the hours added + * @throws io.mosip.kernel.core.exception.IllegalArgumentException if the date + * is null + */ + public static Date addHours(final Date date, final int hours) { + try { + return org.apache.commons.lang3.time.DateUtils.addHours(date, hours); + } catch (java.lang.IllegalArgumentException e) { + throw new IllegalArgumentException(DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getErrorCode(), + DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getEexceptionMessage(), e.getCause()); + } + } + + // ----------------------------------------------------------------------- + /** + *

+ * Adds a number of minutes to a date returning a new Date object. + *

+ * + * @param date the date, not null + * @param minutes the minutes to add, may be negative + * @return the new Date with the minutes added + * @throws io.mosip.kernel.core.exception.IllegalArgumentException if the date + * is null + */ + public static Date addMinutes(final Date date, final int minutes) { + try { + return org.apache.commons.lang3.time.DateUtils.addMinutes(date, minutes); + } catch (java.lang.IllegalArgumentException e) { + throw new IllegalArgumentException(DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getErrorCode(), + DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getEexceptionMessage(), e.getCause()); + } + } + + // ----------------------------------------------------------------------- + /** + *

+ * Adds a number of seconds to a date returning a new Date object. + *

+ * + * @param date the date, not null + * @param seconds the seconds to add, may be negative + * @return the new Date with the seconds added + * @throws io.mosip.kernel.core.exception.IllegalArgumentException if the date + * is null + */ + public static Date addSeconds(final Date date, final int seconds) { + try { + return org.apache.commons.lang3.time.DateUtils.addSeconds(date, seconds); + } catch (java.lang.IllegalArgumentException e) { + throw new IllegalArgumentException(DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getErrorCode(), + DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getEexceptionMessage(), e.getCause()); + } + } + + // ----------------------------------------------------------------------- + /** + *

+ * Formats a date/time into a specific pattern. + *

+ * + * @param date the date to format, not null + * @param pattern the pattern to use to format the date, not null + * @return the formatted date + * @throws io.mosip.kernel.core.exception.IllegalArgumentException if the + * date/pattern + * is null + */ + public static String formatDate(final Date date, final String pattern) { + try { + return DateFormatUtils.format(date, pattern, null, null); + } catch (java.lang.IllegalArgumentException | NullPointerException e) { + throw new IllegalArgumentException(DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getErrorCode(), + DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getEexceptionMessage(), e.getCause()); + } + } + + // ----------------------------------------------------------------------- + /** + *

+ * Formats a date/time into a specific pattern in a time zone. + *

+ * + * @param date the date to format, not null + * @param pattern the pattern to use to format the date, not null + * @param timeZone the time zone to use, may be null + * @return the formatted date + * @throws io.mosip.kernel.core.exception.IllegalArgumentException if the + * date/pattern/timeZone + * is null + */ + public static String formatDate(final Date date, final String pattern, final TimeZone timeZone) { + try { + return DateFormatUtils.format(date, pattern, timeZone, null); + } catch (java.lang.IllegalArgumentException | NullPointerException e) { + throw new IllegalArgumentException(DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getErrorCode(), + DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getEexceptionMessage(), e.getCause()); + } + } + + // ----------------------------------------------------------------------- + /** + *

+ * Formats a date/time into a specific pattern in a time zone and locale. + *

+ * + * @param date, the date to format, not null + * @param pattern, the pattern to use to format the date, not null + * @param timeZone, the time zone to use, may be null + * @param locale, the locale to use, may be null + * @return the formatted date + * @throws io.mosip.kernel.core.exception.IllegalArgumentException if the + * date/pattern/timeZone + * is null + */ + public static String formatDate(final Date date, final String pattern, final TimeZone timeZone, + final Locale locale) { + try { + return DateFormatUtils.format(date, pattern, timeZone, locale); + } catch (java.lang.IllegalArgumentException | NullPointerException e) { + throw new IllegalArgumentException(DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getErrorCode(), + DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getEexceptionMessage(), e.getCause()); + } + } + + // ----------------------------------------------------------------------- + /** + * Formats a calendar into a specific pattern. + * + * @param calendar, the calendar to format, not null + * @param pattern, the pattern to use to format the calendar, not null + * @return the formatted calendar + * @throws io.mosip.kernel.core.exception.IllegalArgumentException if the + * calendar/pattern + * is null + */ + public static String formatCalendar(final Calendar calendar, final String pattern) { + try { + return DateFormatUtils.format(calendar, pattern, null, null); + } catch (java.lang.IllegalArgumentException | NullPointerException e) { + throw new IllegalArgumentException(DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getErrorCode(), + DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getEexceptionMessage(), e.getCause()); + } + } + + // ----------------------------------------------------------------------- + /** + * Formats a calendar into a specific pattern in a time zone. + * + * @param calendar, the calendar to format, not null + * @param pattern, the pattern to use to format the calendar, not null + * @param timeZone, the time zone to use, may be null + * @return the formatted calendar + * @throws io.mosip.kernel.core.exception.IllegalArgumentException if the + * calendar/pattern/timeZone + * is null + */ + public static String formatCalendar(final Calendar calendar, final String pattern, final TimeZone timeZone) { + try { + return DateFormatUtils.format(calendar, pattern, timeZone, null); + } catch (java.lang.IllegalArgumentException | NullPointerException e) { + throw new IllegalArgumentException(DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getErrorCode(), + DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getEexceptionMessage(), e.getCause()); + } + } + + // ----------------------------------------------------------------------- + /** + * Formats a calendar into a specific pattern in a time zone and locale. + * + * @param calendar, the calendar to format, not null + * @param pattern, the pattern to use to format the calendar, not null + * @param locale, the locale to use, may be null + * @return the formatted calendar + * @throws io.mosip.kernel.core.exception.IllegalArgumentException if the + * calendar/pattern/locale + * is null + */ + public static String formatCalendar(final Calendar calendar, final String pattern, final Locale locale) { + try { + return DateFormatUtils.format(calendar, pattern, null, locale); + } catch (java.lang.IllegalArgumentException | NullPointerException e) { + throw new IllegalArgumentException(DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getErrorCode(), + DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getEexceptionMessage(), e.getCause()); + } + } + + // ----------------------------------------------------------------------- + /** + * Formats a calendar into a specific pattern in a time zone and locale. + * + * @param calendar, the calendar to format, not null + * @param pattern, the pattern to use to format the calendar, not null + * @param timeZone, the time zone to use, may be null + * @param locale, the locale to use, may be null + * @return the formatted calendar + * @throws io.mosip.kernel.core.exception.IllegalArgumentException if the + * calendar/pattern/timeZone + * is null + */ + public static String formatCalendar(final Calendar calendar, final String pattern, final TimeZone timeZone, + final Locale locale) { + try { + return DateFormatUtils.format(calendar, pattern, timeZone, locale); + } catch (java.lang.IllegalArgumentException | NullPointerException e) { + throw new IllegalArgumentException(DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getErrorCode(), + DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getEexceptionMessage(), e.getCause()); + } + } + + // --------------------------------------------------------------------------------------------------------------------------- + /** + * Tests if this date is after the specified date. + * + * @param d1 a Date by which we will compare + * + * @param d2 a Date with which we want to compare + * + * @return true if and only if the instant represented by d1 + * Date object is strictly later than the instant represented + * by d2; false otherwise. + * + * @throws io.mosip.kernel.core.exception.IllegalArgumentException if the + * d1 + * , + * d2 + * is null + * + * @see io.mosip.kernel.core.exception.IllegalArgumentException + * + * @see java.util.Date + */ + public static boolean after(Date d1, Date d2) { + try { + return d1.after(d2); + } catch (Exception e) { + throw new IllegalArgumentException(DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getErrorCode(), + DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getEexceptionMessage(), e.getCause()); + } + } + + /** + * Tests if this date is before the specified date. + * + * @param d1 a Date by which we will compare + * @param d2 a Date with which we want to compare + * + * @return true if and only if the instant of time represented by d1 + * Date object is strictly earlier than the instant represented + * by d2; false otherwise. + * + * @throws io.mosip.kernel.core.exception.IllegalArgumentException if the + * d1 + * , + * d2 + * is null + * + * @see io.mosip.kernel.core.exception.IllegalArgumentException + * + * @see java.util.Date + */ + public static boolean before(Date d1, Date d2) { + try { + return d1.before(d2); + } catch (Exception e) { + throw new IllegalArgumentException(DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getErrorCode(), + DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getEexceptionMessage(), e.getCause()); + } + } + + /** + * Checks if two date objects are on the same day ignoring time.
+ * 28 Mar 2002 13:45 and 28 Mar 2002 06:01 would return true.
+ * 28 Mar 2002 13:45 and 12 Mar 2002 13:45 would return false. + * + * @param d1 a Date by which we will compare + * + * @param d2 a Date with which we want to compare + * + * @return true if they represent the same day + * + * @throws io.mosip.kernel.core.exception.IllegalArgumentException if the + * d1 + * , + * d2 + * is null + * + * @see io.mosip.kernel.core.exception.IllegalArgumentException + * + * @see java.util.Date + * + */ + public static boolean isSameDay(Date d1, Date d2) { + try { + return org.apache.commons.lang3.time.DateUtils.isSameDay(d1, d2); + } catch (Exception e) { + throw new IllegalArgumentException(DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getErrorCode(), + DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getEexceptionMessage(), e.getCause()); + } + } + + /** + * Checks if two date objects represent the same instant in time.
+ * This method compares the long millisecond time of the two objects. + * + * @param d1 a Date by which we will compare + * + * @param d2 a Date with which we want compare + * + * @return true if they represent the same millisecond instant + * + * @throws io.mosip.kernel.core.exception.IllegalArgumentException if the + * d1 + * , + * d2 + * is null + * + * @see io.mosip.kernel.core.exception.IllegalArgumentException + * + * @see java.util.Date + */ + public static boolean isSameInstant(Date d1, Date d2) { + try { + return org.apache.commons.lang3.time.DateUtils.isSameInstant(d1, d2); + } catch (Exception e) { + throw new IllegalArgumentException(DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getErrorCode(), + DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getEexceptionMessage(), e.getCause()); + } + } + + // --------------------------------------------------------------------------------------------- + /** + * Tests if this java.time.LocalDateTime is after the specified + * java.time.LocalDateTime. + * + * @param d1 a LocalDateTime which is going to be compared + * + * @param d2 a LocalDateTime by which we will compare + * + * @return true if and only if the instant represented by d1 + * LocalDateTime object is strictly later than the instant + * represented by d2; false otherwise. + * + * @throws io.mosip.kernel.core.exception.IllegalArgumentException if the + * d1 + * , + * d2 + * is null + * + * @see io.mosip.kernel.core.exception.IllegalArgumentException + * + * @see java.time.LocalDateTime + */ + public static boolean after(LocalDateTime d1, LocalDateTime d2) { + try { + return d1.isAfter(d2); + } catch (Exception e) { + throw new IllegalArgumentException(DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getErrorCode(), + DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getEexceptionMessage(), e.getCause()); + } + } + + /** + * Tests if this LocalDateTime is before the specified LocalDateTime. + * + * @param d1 a LocalDateTime which is going to be compared + * + * @param d2 a LocalDateTime by which we will compare + * + * @return true if and only if the instant of time represented by d1 + * LocalDateTime object is strictly earlier than the instant + * represented by d2; false otherwise. + * + * @throws io.mosip.kernel.core.exception.IllegalArgumentException if the + * d1 + * , + * d2 + * is null + * + * @see io.mosip.kernel.core.exception.IllegalArgumentException + * + * @see java.time.LocalDateTime + */ + public static boolean before(LocalDateTime d1, LocalDateTime d2) { + try { + return d1.isBefore(d2); + } catch (Exception e) { + throw new IllegalArgumentException(DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getErrorCode(), + DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getEexceptionMessage(), e.getCause()); + } + } + + /** + * Checks if two java.time.LocalDateTime objects are on the same day ignoring + * time.
+ * 28 Mar 2002 13:45 and 28 Mar 2002 06:01 would return true.
+ * 28 Mar 2002 13:45 and 12 Mar 2002 13:45 would return false. + * + * @param d1 a LocalDateTime which is going to be compared + * @param d2 a LocalDateTime by which we will compare + * + * @return true if they represent the same day + * + * @throws io.mosip.kernel.core.exception.IllegalArgumentException if the + * d1 + * , + * d2 + * is null + * + * @see io.mosip.kernel.core.exception.IllegalArgumentException + * + * @see java.time.LocalDateTime + */ + public static boolean isSameDay(LocalDateTime d1, LocalDateTime d2) { + try { + return d1.toLocalDate().isEqual(d2.toLocalDate()); + } catch (Exception e) { + throw new IllegalArgumentException(DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getErrorCode(), + DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getEexceptionMessage(), e.getCause()); + } + } + + /** + * Checks if two java.time.LocalDateTime objects represent the same instant in + * time.
+ * This method compares the long millisecond time of the two objects. + * + * @param d1 a LocalDateTime which is going to be compared + * + * @param d2 a LocalDateTime by which we will compare + * + * @return true if they represent the same millisecond instant + * + * @throws io.mosip.kernel.core.exception.IllegalArgumentException if the + * d1 + * , + * d2 + * is null + * + * @see io.mosip.kernel.core.exception.IllegalArgumentException + * + * @see java.time.LocalDateTime + */ + public static boolean isSameInstant(LocalDateTime d1, LocalDateTime d2) { + try { + return d1.isEqual(d2); + } catch (Exception e) { + throw new IllegalArgumentException(DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getErrorCode(), + DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getEexceptionMessage(), e.getCause()); + } + } + // --------------------------------------------------------------------------------------------------------------------------- + + /** + * Converts java.time.LocalDateTime to UTC string in default ISO pattern - + * yyyy-MM-dd'T'HH:mm:ss.SSS'Z'. + * + * @param localDateTime java.time.LocalDateTime + * + * @return a date String + */ + + public static String toISOString(LocalDateTime localDateTime) { + ZonedDateTime zonedtime = localDateTime.atZone(ZoneId.systemDefault()); + ZonedDateTime converted = zonedtime.withZoneSameInstant(ZoneOffset.UTC); + return converted.toString(); + } + + /** + * Converts java.util.Date to UTC string in default ISO pattern - + * yyyy-MM-dd'T'HH:mm:ss.SSS'Z'. + * + * @param date java.util.Date + * + * @return a date String + */ + public static String toISOString(Date date) { + DateFormat df = new SimpleDateFormat(UTC_DATETIME_PATTERN); + df.setTimeZone(UTC_TIME_ZONE); + return df.format(date); + } + + /** + * Formats java.time.LocalDateTime to UTC string in default ISO pattern - + * yyyy-MM-dd'T'HH:mm:ss.SSS'Z' ignoring zone offset. + * + * @param localDateTime java.time.LocalDateTime + * + * @return a date String + */ + + public static String formatToISOString(LocalDateTime localDateTime) { + return localDateTime.format(DateTimeFormatter.ofPattern(UTC_DATETIME_PATTERN)); + } + + /** + * Provides current UTC java.time.LocalDateTime. + * + * @return LocalDateTime + * + * @see java.time.LocalDateTime + */ + public static LocalDateTime getUTCCurrentDateTime() { + return ZonedDateTime.now(ZoneOffset.UTC).toLocalDateTime(); + } + + /** + * Provides UTC Current DateTime string in default ISO pattern. + * + * Obtains the current date-time from the system clock in the default time-zone. + *

+ * This will query the {@link Clock#systemDefaultZone() system clock} in the + * default time-zone to obtain the current date-time. The offset will be + * calculated from the time-zone in the clock. + *

+ * Using this method will prevent the ability to use an alternate clock for + * testing because the clock is hard-coded. + * + * @return the current date-time using the system clock, not null + * + * @return a date String + */ + public static String getUTCCurrentDateTimeString() { + return OffsetDateTime.now().toInstant().toString(); + } + + /** + * Provides UTC Current DateTime string in given pattern. + * + * @param pattern is of type String + * + * @return date String + */ + public static String getUTCCurrentDateTimeString(String pattern) { + return ZonedDateTime.now(ZoneOffset.UTC).format(DateTimeFormatter.ofPattern(pattern)); + } + + /** + * Provides current DateTime string with system zone offset and in default ISO + * pattern - yyyy-MM-dd'T'HH:mm:ss.SSSXXX. + * + * @return a date String + */ + public static String getCurrentDateTimeString() { + return OffsetDateTime.now().toString(); + } + + /** + * Converts UTC string to java.time.LocalDateTime ignoring zone offset. + * + * @param utcDateTime is of type String + * + * @return a LocalDateTime + * + * @throws java.time.format.DateTimeParseException if not able to parse the + * utcDateTime string for the + * pattern. + * + * + * @see java.time.LocalDateTime + */ + public static LocalDateTime convertUTCToLocalDateTime(String utcDateTime) { + return ZonedDateTime.parse(utcDateTime).toLocalDateTime(); + } + + /** + * Parses UTC string to java.time.LocalDateTime adjusted for system time zone. + * + * @param utcDateTime is of type String + * + * @return a LocalDateTime + * + * + * @see java.time.LocalDateTime + */ + public static LocalDateTime parseUTCToLocalDateTime(String utcDateTime) { + OffsetDateTime odt = OffsetDateTime.parse(utcDateTime); + return odt.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime(); + } + + /** + * Parses UTC string of pattern yyyy-MM-dd'T'HH:mm:ss.SSS or + * yyyy-MM-dd'T'HH:mm:ss.SSS'Z' to java.time.LocalDateTime. + * + * @param dateTime is of type String + * + * @return a LocalDateTime + * + * @throws java.time.format.DateTimeParseException if not able to parse the + * utcDateTime string for the + * pattern + * + * @see java.time.LocalDateTime + */ + public static LocalDateTime parseToLocalDateTime(String dateTime) { + try { + return LocalDateTime.parse(dateTime, DateTimeFormatter.ofPattern(UTC_DATETIME_PATTERN)); + } catch (Exception e) { + return LocalDateTime.parse(dateTime); + } + + } + + /** + * Parses UTC string of given pattern to java.time.LocalDateTime. + * + * @param utcDateTime is of type String + * + * @param pattern is of type String + * + * @return LocalDateTime + * + * @throws io.mosip.kernel.core.exception.ParseException if not able to parse + * the utcDateTime string + * for the pattern. + * + * @see io.mosip.kernel.core.exception.ParseException + * + * @see java.time.LocalDateTime + */ + public static LocalDateTime parseUTCToLocalDateTime(String utcDateTime, String pattern) { + SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern); + simpleDateFormat.setTimeZone(UTC_TIME_ZONE); + try { + return simpleDateFormat.parse(utcDateTime).toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime(); + } catch (ParseException e) { + throw new io.mosip.print.exception.ParseException( + DateUtilConstants.PARSE_EXCEPTION_ERROR_CODE.getErrorCode(), + DateUtilConstants.PARSE_EXCEPTION_ERROR_CODE.getEexceptionMessage(), e); + } + + } + + /** + * Parses Date to java.time.LocalDateTime adjusted for system time zone. + * + * @param date is of type String + * + * @return a LocalDateTime + * + * + * @see java.time.LocalDateTime + */ + public static LocalDateTime parseDateToLocalDateTime(Date date) { + return date.toInstant().atZone(ZoneId.systemDefault()).toLocalDateTime(); + } + + /** + * Parses given UTC string of ISO pattern yyyy-MM-dd'T'HH:mm:ss.SSS'Z' to + * java.util.Date. + * + * @param utcDateTime is of type String + * + * @return a Date + * + * @throws io.mosip.kernel.core.exception.ParseException if not able to parse + * the + * utcDateTime + * string in given Default + * utcDateTime pattern - + * yyyy-MM-dd'T'HH:mm:ss.SSS'Z'. + * + * @see io.mosip.kernel.core.exception.ParseException + */ + public static Date parseUTCToDate(String utcDateTime) { + SimpleDateFormat simpleDateFormat = new SimpleDateFormat(UTC_DATETIME_PATTERN); + simpleDateFormat.setTimeZone(UTC_TIME_ZONE); + try { + return simpleDateFormat.parse(utcDateTime); + } catch (ParseException e) { + throw new io.mosip.print.exception.ParseException( + DateUtilConstants.PARSE_EXCEPTION_ERROR_CODE.getErrorCode(), + DateUtilConstants.PARSE_EXCEPTION_ERROR_CODE.getEexceptionMessage(), e); + } + + } + + /** + * Parses UTC string of given pattern to java.util.Date. + * + * @param utcDateTime is of type String + * + * @param pattern is of type String + * + * @return a Date + * + * @throws io.mosip.kernel.core.exception.ParseException if not able to parse + * the dateTime string in + * given string pattern. + * + * @see io.mosip.kernel.core.exception.ParseException + */ + public static Date parseUTCToDate(String utcDateTime, String pattern) { + SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern); + simpleDateFormat.setTimeZone(UTC_TIME_ZONE); + try { + return simpleDateFormat.parse(utcDateTime); + } catch (ParseException e) { + throw new io.mosip.print.exception.ParseException( + DateUtilConstants.PARSE_EXCEPTION_ERROR_CODE.getErrorCode(), + DateUtilConstants.PARSE_EXCEPTION_ERROR_CODE.getEexceptionMessage(), e); + } + } + + /** + * Parses date string of given pattern and TimeZone to java.util.Date. + * + * @param dateTime is of type String + * + * @param pattern is of type String + * + * @param timeZone is of type java.util.TimeZone + * + * @return a Date + * + * @throws io.mosip.kernel.core.exception.ParseException if not able to parse + * the dateTime string in + * given string pattern. + * + * @see io.mosip.kernel.core.exception.ParseException + * + * @see java.util.TimeZone + */ + public static Date parseToDate(String dateTime, String pattern, TimeZone timeZone) { + SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern); + simpleDateFormat.setTimeZone(timeZone); + try { + return simpleDateFormat.parse(dateTime); + } catch (ParseException e) { + throw new io.mosip.print.exception.ParseException( + DateUtilConstants.PARSE_EXCEPTION_ERROR_CODE.getErrorCode(), + DateUtilConstants.PARSE_EXCEPTION_ERROR_CODE.getEexceptionMessage(), e); + } + } + + /** + * Parses date string of given pattern to java.util.Date. + * + * @param dateString The date string. + * @param pattern The date format pattern which should respect the + * SimpleDateFormat rules. + * @return The parsed date object. + * @throws io.mosip.kernel.core.exception.ParseException If the given date + * string or its + * actual date is + * invalid based on + * the given date + * format pattern. + * @throws io.mosip.kernel.core.exception.NullPointerException If + * dateString + * or + * dateFormat + * is null. + * @see SimpleDateFormat + */ + public static Date parseToDate(String dateString, String pattern) { + if (Objects.isNull(dateString) || Objects.isNull(pattern)) { + throw new NullPointerException( + DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getErrorCode(), + DateUtilConstants.ILLEGALARGUMENT_ERROR_CODE.getEexceptionMessage(), + new java.lang.NullPointerException("dateString or dateFormat is null")); + } + try { + + SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern); + simpleDateFormat.setLenient(false); // Don't automatically convert invalid date. + return simpleDateFormat.parse(dateString); + + } catch (Exception e) { + throw new io.mosip.print.exception.ParseException( + DateUtilConstants.PARSE_EXCEPTION_ERROR_CODE.getErrorCode(), + DateUtilConstants.PARSE_EXCEPTION_ERROR_CODE.getEexceptionMessage(), e.getCause()); + } + } + + /** + * This method to convert “java.util.Date” time stamp to UTC date string + * + * @param date The java.util.Date. + * @return return UTC DateTime format string. + * + */ + public static String getUTCTimeFromDate(Date date) { + SimpleDateFormat dateFormatter = new SimpleDateFormat(UTC_DATETIME_PATTERN); + dateFormatter.setTimeZone(TimeZone.getTimeZone(UTC_ZONE_ID)); + return dateFormatter.format(date); + } + +} \ No newline at end of file diff --git a/src/main/java/io/mosip/print/util/DigitalSignatureUtility.java b/src/main/java/io/mosip/print/util/DigitalSignatureUtility.java index 7162195c..f21f86dc 100644 --- a/src/main/java/io/mosip/print/util/DigitalSignatureUtility.java +++ b/src/main/java/io/mosip/print/util/DigitalSignatureUtility.java @@ -4,24 +4,23 @@ import java.time.LocalDateTime; import java.time.format.DateTimeFormatter; +import org.slf4j.Logger; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.core.env.Environment; import org.springframework.stereotype.Component; import com.fasterxml.jackson.databind.ObjectMapper; -import io.mosip.kernel.core.logger.spi.Logger; -import io.mosip.kernel.core.util.DateUtils; import io.mosip.print.constant.ApiName; import io.mosip.print.constant.LoggerFileConstant; +import io.mosip.print.core.http.RequestWrapper; +import io.mosip.print.core.http.ResponseWrapper; import io.mosip.print.dto.SignRequestDto; import io.mosip.print.dto.SignResponseDto; import io.mosip.print.exception.ApisResourceAccessException; import io.mosip.print.exception.DigitalSignatureException; import io.mosip.print.logger.PrintLogger; import io.mosip.print.service.PrintRestClientService; -import io.mosip.registration.print.core.http.RequestWrapper; -import io.mosip.registration.print.core.http.ResponseWrapper; @Component public class DigitalSignatureUtility { @@ -29,8 +28,8 @@ public class DigitalSignatureUtility { @Autowired private PrintRestClientService printRestService; - /** The reg proc logger. */ - private static Logger regProcLogger = PrintLogger.getLogger(DigitalSignatureUtility.class); + /** The print logger. */ + Logger printLogger = PrintLogger.getLogger(DigitalSignatureUtility.class); @Autowired private Environment env; @@ -43,7 +42,7 @@ public class DigitalSignatureUtility { private static final String REG_PROC_APPLICATION_VERSION = "mosip.registration.processor.application.version"; public String getDigitalSignature(String data) { - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "DigitalSignatureUtility::getDigitalSignature()::entry"); SignRequestDto dto=new SignRequestDto(); @@ -64,19 +63,19 @@ public String getDigitalSignature(String data) { if (response.getErrors() != null && response.getErrors().size() > 0) { response.getErrors().stream().forEach(r -> { - regProcLogger.error(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.UIN.toString(), "", + printLogger.error(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.UIN.toString(), "", "DigitalSignatureUtility::getDigitalSignature():: error with error message " + r.getMessage()); }); } SignResponseDto signResponseDto = mapper.readValue(mapper.writeValueAsString(response.getResponse()), SignResponseDto.class); - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "DigitalSignatureUtility::getDigitalSignature()::exit"); return signResponseDto.getSignature(); } catch (ApisResourceAccessException | IOException e) { - regProcLogger.error(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.UIN.toString(), "", + printLogger.error(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.UIN.toString(), "", "DigitalSignatureUtility::getDigitalSignature():: error with error message " + e.getMessage()); throw new DigitalSignatureException(e.getMessage(), e); } diff --git a/src/main/java/io/mosip/print/util/EmptyCheckUtils.java b/src/main/java/io/mosip/print/util/EmptyCheckUtils.java new file mode 100644 index 00000000..d837f2a9 --- /dev/null +++ b/src/main/java/io/mosip/print/util/EmptyCheckUtils.java @@ -0,0 +1,63 @@ +package io.mosip.print.util; + +import java.util.Collection; +import java.util.Map; + +/** + * This class is used to avoid NPE: NullPointerException easily. + * + * @author Bal Vikash Sharma + * @since 1.0.0 + */ +public final class EmptyCheckUtils { + + private EmptyCheckUtils() { + super(); + } + + /** + * This method used to check if given obj is null. + * + * @param obj is of any java.lang.Object type. + * @return true if obj is null. + */ + public static boolean isNullEmpty(Object obj) { + return obj == null; + } + + /** + * This method is used to check if the given str is null or an + * empty string. + * + * @param str id of type java.lang.String + * @return true if given str is null or length of it is Zero after + * trim. + */ + public static boolean isNullEmpty(String str) { + return str == null || str.trim().length() == 0; + } + + /** + * This method is used to check given collection is null or is + * Empty. + * + * @param collection is of type java.util.Collection. + * @return true if given collection is null or does not contains + * any element inside it. + */ + public static boolean isNullEmpty(Collection collection) { + return collection == null || collection.isEmpty(); + } + + /** + * This method is used to check given map is null or is Empty. + * + * @param map is of type java.util.Map + * @return true if given map is null or does not contains any key, + * values pairs inside it. + */ + public static boolean isNullEmpty(Map map) { + return map == null || map.isEmpty(); + } + +} diff --git a/src/main/java/io/mosip/print/util/Helpers.java b/src/main/java/io/mosip/print/util/Helpers.java new file mode 100644 index 00000000..79787214 --- /dev/null +++ b/src/main/java/io/mosip/print/util/Helpers.java @@ -0,0 +1,23 @@ +package io.mosip.print.util; + +import org.apache.commons.io.IOUtils; + +import java.io.IOException; +import java.io.InputStream; +import java.io.StringWriter; +import java.net.URISyntaxException; + +public class Helpers { + + public static String readFileFromResources(String filename) throws URISyntaxException, IOException { + InputStream inputStream = Helpers.class.getClassLoader().getResourceAsStream(filename); + StringWriter writer = new StringWriter(); + IOUtils.copy(inputStream, writer, "UTF-8"); + return writer.toString(); + } + + public static InputStream readStreamFromResources(String filename) { + InputStream inputStream = Helpers.class.getClassLoader().getResourceAsStream(filename); + return inputStream; + } +} diff --git a/src/main/java/io/mosip/print/util/JsonUtil.java b/src/main/java/io/mosip/print/util/JsonUtil.java index 06997158..66491075 100644 --- a/src/main/java/io/mosip/print/util/JsonUtil.java +++ b/src/main/java/io/mosip/print/util/JsonUtil.java @@ -40,6 +40,7 @@ public class JsonUtil { /** The Constant VALUE. */ private static final String VALUE = "value"; + private static ObjectMapper objectMapper = new ObjectMapper(); /** * Instantiates a new json util. */ @@ -120,6 +121,26 @@ public static JSONArray getJSONArray(JSONObject jsonObject, Object key) { } + public static String writeValueAsString(Object obj) throws IOException { + return objectMapper.writeValueAsString(obj); + } + + /** + * Object mapper read value. This method maps the jsonString to particular type + * + * @param the generic type + * @param jsonString the json string + * @param clazz the clazz + * @return the t + * @throws JsonParseException the json parse exception + * @throws JsonMappingException the json mapping exception + * @throws IOException Signals that an I/O exception has occurred. + */ + @SuppressWarnings("unchecked") + public static T readValue(String jsonString, Class clazz) throws IOException { + return (T) objectMapper.readValue(jsonString, clazz); + } + /** * Gets the JSON value. * diff --git a/src/main/java/io/mosip/print/util/PrintExceptionHandler.java b/src/main/java/io/mosip/print/util/PrintExceptionHandler.java index 8a407eed..3424751b 100644 --- a/src/main/java/io/mosip/print/util/PrintExceptionHandler.java +++ b/src/main/java/io/mosip/print/util/PrintExceptionHandler.java @@ -4,9 +4,9 @@ import java.util.Objects; import java.util.stream.Collectors; +import org.slf4j.Logger; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.core.env.Environment; -import org.springframework.dao.DataIntegrityViolationException; import org.springframework.http.MediaType; import org.springframework.http.ResponseEntity; import org.springframework.web.bind.MethodArgumentNotValidException; @@ -17,16 +17,14 @@ import com.fasterxml.jackson.databind.JsonMappingException; import com.fasterxml.jackson.databind.exc.InvalidFormatException; -import io.mosip.kernel.core.exception.BaseCheckedException; -import io.mosip.kernel.core.exception.BaseUncheckedException; -import io.mosip.kernel.core.logger.spi.Logger; -import io.mosip.kernel.core.pdfgenerator.exception.PDFGeneratorException; -import io.mosip.kernel.core.util.DateUtils; import io.mosip.print.controller.Print; import io.mosip.print.dto.ErrorDTO; import io.mosip.print.dto.PrintResponse; import io.mosip.print.exception.AccessDeniedException; +import io.mosip.print.exception.BaseCheckedException; +import io.mosip.print.exception.BaseUncheckedException; import io.mosip.print.exception.InvalidTokenException; +import io.mosip.print.exception.PDFGeneratorException; import io.mosip.print.exception.PDFSignatureException; import io.mosip.print.exception.PlatformErrorMessages; import io.mosip.print.exception.RegPrintAppException; @@ -43,20 +41,20 @@ public class PrintExceptionHandler { /** The Constant REG_PACKET_GENERATOR_SERVICE_ID. */ - private static final String REG_PRINT_SERVICE_ID = "mosip.registration.processor.print.service.id"; + private static final String REG_PRINT_SERVICE_ID = "mosip.print.service.id"; /** The Constant REG_PACKET_GENERATOR_APPLICATION_VERSION. */ - private static final String REG_PRINT_SERVICE_VERSION = "mosip.registration.processor.application.version"; + private static final String REG_PRINT_SERVICE_VERSION = "mosip.print.application.version"; /** The Constant DATETIME_PATTERN. */ - private static final String DATETIME_PATTERN = "mosip.registration.processor.datetime.pattern"; + private static final String DATETIME_PATTERN = "mosip.print.datetime.pattern"; /** The env. */ @Autowired private Environment env; /** The reg proc logger. */ - private static Logger regProcLogger = PrintLogger.getLogger(PrintExceptionHandler.class); + private Logger printLogger = PrintLogger.getLogger(PrintExceptionHandler.class); /** * Reg print app exception. @@ -122,10 +120,6 @@ public ResponseEntity badRequest(MethodArgumentNotValidException return buildPrintApiExceptionResponse((Exception) ex); } - @ExceptionHandler(DataIntegrityViolationException.class) - public ResponseEntity dataExceptionHandler(final DataIntegrityViolationException e) { - return buildPrintApiExceptionResponse((Exception) e); - } @ExceptionHandler(AccessDeniedException.class) public ResponseEntity accessDenied(AccessDeniedException e) { diff --git a/src/main/java/io/mosip/print/util/PrintInstializer.java b/src/main/java/io/mosip/print/util/PrintInstializer.java index ac572b6b..07b65992 100644 --- a/src/main/java/io/mosip/print/util/PrintInstializer.java +++ b/src/main/java/io/mosip/print/util/PrintInstializer.java @@ -3,24 +3,23 @@ import java.time.Duration; import java.time.Instant; +import org.slf4j.Logger; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; -import org.springframework.context.ApplicationEvent; +import org.springframework.boot.context.event.ApplicationReadyEvent; import org.springframework.context.ApplicationListener; import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler; import org.springframework.stereotype.Component; -import io.mosip.kernel.core.logger.spi.Logger; +import io.mosip.print.constant.LoggerFileConstant; import io.mosip.print.logger.PrintLogger; @Component -public class PrintInstializer implements ApplicationListener{ - - +public class PrintInstializer implements ApplicationListener { @Value("${retry-count:3}") private int retryCount; - @Value("${resubscription-delay-secs:7200}") // Default is 60 * 60 * 2 = 2 hours + @Value("${print-websub-resubscription-delay-secs:0}") private int reSubscriptionDelaySecs; @Autowired @@ -33,23 +32,29 @@ public class PrintInstializer implements ApplicationListener{ private static final String ONAPPLICATIONEVENT = "onApplicationEvent"; /** The Constant ID_REPO_SERVICE_IMPL. */ - private static final String CREDENTIALINSTIALIZER = "CredentialInstializer"; + private static final String PRINTINSTIALIZER = "PrintInstializer"; - private static final Logger LOGGER = PrintLogger.getLogger(PrintInstializer.class); + private Logger logger = PrintLogger.getLogger(PrintInstializer.class); - @Override - public void onApplicationEvent(ApplicationEvent event) { - // TODO Auto-generated method stub - LOGGER.info("NotifyPrint", CREDENTIALINSTIALIZER, ONAPPLICATIONEVENT, + public void onApplicationEvent(ApplicationReadyEvent event) { + if (reSubscriptionDelaySecs > 0) { + logger.info(LoggerFileConstant.SESSIONID.toString(), PRINTINSTIALIZER, ONAPPLICATIONEVENT, "Work around for web-sub notification issue after some time."); scheduleRetrySubscriptions(); - + } + else { + logger.info(LoggerFileConstant.SESSIONID.toString(), PRINTINSTIALIZER, ONAPPLICATIONEVENT, + + "Scheduling for re-subscription is Disabled as the re-subsctription delay value is: " + + reSubscriptionDelaySecs); + + } } private void scheduleRetrySubscriptions() { - LOGGER.info("NotifyPrint", CREDENTIALINSTIALIZER, ONAPPLICATIONEVENT, + logger.info(LoggerFileConstant.SESSIONID.toString(), PRINTINSTIALIZER, ONAPPLICATIONEVENT, "Scheduling re-subscription every " + reSubscriptionDelaySecs + " seconds"); @@ -59,7 +64,7 @@ private void scheduleRetrySubscriptions() { private void retrySubscriptions() { // Call Init Subscriptions for the count until no error in the subscription - for (int i = 0; i < retryCount; i++) { + for (int i = 0; i <= retryCount; i++) { if (initSubsriptions()) { return; } @@ -68,18 +73,16 @@ private void retrySubscriptions() { private boolean initSubsriptions() { try { - LOGGER.info("NotifyPrint", CREDENTIALINSTIALIZER, ONAPPLICATIONEVENT, + logger.info(LoggerFileConstant.SESSIONID.toString(), PRINTINSTIALIZER, ONAPPLICATIONEVENT, "Initializing subscribptions.."); webSubSubscriptionHelper.initSubsriptions(); return true; } catch (Exception e) { - LOGGER.error("NotifyPrint", CREDENTIALINSTIALIZER, ONAPPLICATIONEVENT, - "Initializing subscribptions failed: " + e.getMessage()); + logger.error(LoggerFileConstant.SESSIONID.toString(), PRINTINSTIALIZER, ONAPPLICATIONEVENT, + "Initializing subscribptions failed: "); return false; } } } - - diff --git a/src/main/java/io/mosip/print/util/QrcodegeneratorUtils.java b/src/main/java/io/mosip/print/util/QrcodegeneratorUtils.java new file mode 100644 index 00000000..0cf41840 --- /dev/null +++ b/src/main/java/io/mosip/print/util/QrcodegeneratorUtils.java @@ -0,0 +1,41 @@ +package io.mosip.print.util; + +import io.mosip.print.constant.QrVersion; +import io.mosip.print.constant.QrcodeExceptionConstants; +import io.mosip.print.exception.InvalidInputException; +import io.mosip.print.exception.NullPointerException; + +/** + * Utils class for QR code generator + * + * @author Urvil Joshi + * + * @since 1.0.0 + */ +public class QrcodegeneratorUtils { + /** + * Constructor for this class + */ + private QrcodegeneratorUtils() { + + } + + /** + * Verify the input send by user + * + * @param data data send by user + * @param version {@link QrVersion} send by user + */ + public static void verifyInput(String data, QrVersion version) { + if (data == null) { + throw new NullPointerException(QrcodeExceptionConstants.INVALID_INPUT_DATA_NULL.getErrorCode(), + QrcodeExceptionConstants.INVALID_INPUT_DATA_NULL.getErrorMessage()); + } else if (data.trim().isEmpty()) { + throw new InvalidInputException(QrcodeExceptionConstants.INVALID_INPUT_DATA_EMPTY.getErrorCode(), + QrcodeExceptionConstants.INVALID_INPUT_DATA_EMPTY.getErrorMessage()); + } else if (version == null) { + throw new NullPointerException(QrcodeExceptionConstants.INVALID_INPUT_VERSION.getErrorCode(), + QrcodeExceptionConstants.INVALID_INPUT_VERSION.getErrorMessage()); + } + } +} diff --git a/src/main/java/io/mosip/print/util/RestApiClient.java b/src/main/java/io/mosip/print/util/RestApiClient.java index 45e57417..6f0f0e27 100644 --- a/src/main/java/io/mosip/print/util/RestApiClient.java +++ b/src/main/java/io/mosip/print/util/RestApiClient.java @@ -11,6 +11,7 @@ import javax.net.ssl.SSLContext; +import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.exception.ExceptionUtils; import org.apache.http.Header; import org.apache.http.HttpResponse; @@ -23,6 +24,7 @@ import org.apache.http.impl.client.HttpClients; import org.apache.http.ssl.TrustStrategy; import org.apache.http.util.EntityUtils; +import org.slf4j.Logger; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.web.client.RestTemplateBuilder; import org.springframework.core.env.Environment; @@ -39,10 +41,6 @@ import com.google.gson.Gson; -import io.mosip.kernel.core.logger.spi.Logger; -import io.mosip.kernel.core.util.DateUtils; -import io.mosip.kernel.core.util.StringUtils; -import io.mosip.kernel.core.util.TokenHandlerUtil; import io.mosip.print.constant.LoggerFileConstant; import io.mosip.print.dto.Metadata; import io.mosip.print.dto.PasswordRequest; @@ -60,7 +58,7 @@ public class RestApiClient { /** The logger. */ - private final Logger logger = PrintLogger.getLogger(RestApiClient.class); + private Logger logger = PrintLogger.getLogger(RestApiClient.class); /** The builder. */ @Autowired diff --git a/src/main/java/io/mosip/print/util/TemplateGenerator.java b/src/main/java/io/mosip/print/util/TemplateGenerator.java index ae754195..e6e40d48 100644 --- a/src/main/java/io/mosip/print/util/TemplateGenerator.java +++ b/src/main/java/io/mosip/print/util/TemplateGenerator.java @@ -15,26 +15,26 @@ import org.apache.velocity.runtime.log.NullLogChute; import org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader; import org.apache.velocity.runtime.resource.loader.FileResourceLoader; +import org.slf4j.Logger; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import com.fasterxml.jackson.databind.ObjectMapper; -import io.mosip.kernel.core.logger.spi.Logger; import io.mosip.kernel.core.templatemanager.exception.TemplateMethodInvocationException; import io.mosip.kernel.core.templatemanager.exception.TemplateParsingException; import io.mosip.kernel.core.templatemanager.exception.TemplateResourceNotFoundException; -import io.mosip.kernel.core.templatemanager.spi.TemplateManager; -import io.mosip.kernel.templatemanager.velocity.impl.TemplateManagerImpl; import io.mosip.print.constant.ApiName; import io.mosip.print.constant.LoggerFileConstant; +import io.mosip.print.core.http.ResponseWrapper; import io.mosip.print.dto.TemplateResponseDto; import io.mosip.print.exception.ApisResourceAccessException; import io.mosip.print.exception.PlatformErrorMessages; import io.mosip.print.exception.TemplateProcessingFailureException; import io.mosip.print.logger.PrintLogger; import io.mosip.print.service.PrintRestClientService; -import io.mosip.registration.print.core.http.ResponseWrapper; +import io.mosip.print.service.impl.TemplateManagerImpl; +import io.mosip.print.spi.TemplateManager; /** * The Class TemplateGenerator. @@ -45,7 +45,7 @@ public class TemplateGenerator { /** The reg proc logger. */ - private static Logger regProcLogger = PrintLogger.getLogger(TemplateGenerator.class); + private static Logger printLogger = PrintLogger.getLogger(TemplateGenerator.class); /** The resource loader. */ private String resourceLoader = "classpath"; @@ -86,7 +86,7 @@ public InputStream getTemplate(String templateTypeCode, Map attr ResponseWrapper responseWrapper; TemplateResponseDto template; - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "TemplateGenerator::getTemplate()::entry"); try { @@ -105,12 +105,12 @@ public InputStream getTemplate(String templateTypeCode, Map attr template.getTemplates().iterator().next().getFileText().getBytes()); fileTextStream = getTemplateManager().merge(stream, attributes); } - regProcLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", + printLogger.debug(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.USERID.toString(), "", "TemplateGenerator::getTemplate()::exit"); return fileTextStream; } catch (TemplateResourceNotFoundException | TemplateParsingException | TemplateMethodInvocationException e) { - regProcLogger.error(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.REGISTRATIONID.toString(), + printLogger.error(LoggerFileConstant.SESSIONID.toString(), LoggerFileConstant.REGISTRATIONID.toString(), null, PlatformErrorMessages.PRT_TEM_PROCESSING_FAILURE.name() + e.getMessage() + ExceptionUtils.getStackTrace(e)); throw new TemplateProcessingFailureException(PlatformErrorMessages.PRT_TEM_PROCESSING_FAILURE.getCode()); diff --git a/src/main/java/io/mosip/print/util/TemplateManagerUtil.java b/src/main/java/io/mosip/print/util/TemplateManagerUtil.java new file mode 100644 index 00000000..e9ccda82 --- /dev/null +++ b/src/main/java/io/mosip/print/util/TemplateManagerUtil.java @@ -0,0 +1,34 @@ +package io.mosip.print.util; + +import java.util.Map; + +import org.apache.velocity.VelocityContext; + +/** + * TemplateManagerUtil contain Utility methods + * + * @author Abhishek Kumar + * @version 1.0.0 + * @since 01-10-2018 + */ +public class TemplateManagerUtil { + + private TemplateManagerUtil() { + } + + /** + * Method to bind the map of values into VelocityContext + * + * @param input as Map<String,Object> where key will be placeholder name + * and Object is the actual value for the placeholder + * @return VelocityContext + */ + public static VelocityContext bindInputToContext(Map input) { + VelocityContext context = null; + if (input != null && !input.isEmpty()) { + context = new VelocityContext(input); + } + + return context; + } +} diff --git a/src/main/java/io/mosip/print/util/TokenHandlerUtil.java b/src/main/java/io/mosip/print/util/TokenHandlerUtil.java new file mode 100644 index 00000000..d9999f6b --- /dev/null +++ b/src/main/java/io/mosip/print/util/TokenHandlerUtil.java @@ -0,0 +1,67 @@ +package io.mosip.print.util; + +import java.time.LocalDateTime; +import java.util.Map; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import com.auth0.jwt.JWT; +import com.auth0.jwt.exceptions.JWTDecodeException; +import com.auth0.jwt.interfaces.Claim; +import com.auth0.jwt.interfaces.DecodedJWT; + +import io.mosip.print.exception.ExceptionUtils; + +/** + * + * @author Srinivasan + * + */ + +public class TokenHandlerUtil { + private static Logger LOGGER= LoggerFactory.getLogger(TokenHandlerUtil.class); + + private TokenHandlerUtil() { + + } + + /** + * Validates the token offline based on the Oauth2 standards. + * + * @param accessToken + * - Bearer token + * @param issuerUrl + * - issuer URL to be read from the properties, + * @param clientId + * - client Id to be read from the properties + * @return Boolean + */ + public static boolean isValidBearerToken(String accessToken, String issuerUrl, String clientId) { + + try { + DecodedJWT decodedJWT = JWT.decode(accessToken); + Map claims = decodedJWT.getClaims(); + LocalDateTime expiryTime = DateUtils + .convertUTCToLocalDateTime(DateUtils.getUTCTimeFromDate(decodedJWT.getExpiresAt())); + + if (!decodedJWT.getIssuer().equals(issuerUrl)) { + return false; + } else if (!DateUtils.before(DateUtils.getUTCCurrentDateTime(), expiryTime)) { + return false; + } else if (!claims.get("clientId").asString().equals(clientId)) { + return false; + } else { + return true; + } + } catch (JWTDecodeException e) { + LOGGER.error("JWT DECODE EXCEPTION ::" .concat(e.getMessage()).concat(ExceptionUtils.getStackTrace(e))); + return false; + } catch (Exception e) { + LOGGER.error(e.getMessage().concat(ExceptionUtils.getStackTrace(e))); + return false; + } + + } + +} diff --git a/src/main/java/io/mosip/print/util/Utilities.java b/src/main/java/io/mosip/print/util/Utilities.java index 9d9c6b12..eba562b6 100644 --- a/src/main/java/io/mosip/print/util/Utilities.java +++ b/src/main/java/io/mosip/print/util/Utilities.java @@ -1,12 +1,18 @@ package io.mosip.print.util; import java.io.IOException; +import java.io.InputStream; +import java.net.MalformedURLException; +import java.net.URL; +import java.nio.charset.StandardCharsets; import java.util.ArrayList; import java.util.LinkedHashMap; import java.util.List; +import org.apache.commons.io.IOUtils; import org.json.simple.JSONObject; import org.json.simple.parser.JSONParser; +import org.slf4j.Logger; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; import org.springframework.stereotype.Component; @@ -14,13 +20,12 @@ import com.fasterxml.jackson.databind.ObjectMapper; -import io.mosip.kernel.core.exception.ExceptionUtils; -import io.mosip.kernel.core.logger.spi.Logger; import io.mosip.print.constant.ApiName; import io.mosip.print.constant.LoggerFileConstant; import io.mosip.print.constant.MappingJsonConstants; import io.mosip.print.dto.ErrorDTO; import io.mosip.print.exception.ApisResourceAccessException; +import io.mosip.print.exception.ExceptionUtils; import io.mosip.print.exception.IdRepoAppException; import io.mosip.print.exception.PlatformErrorMessages; import io.mosip.print.idrepo.dto.IdResponseDTO1; @@ -40,8 +45,9 @@ */ @Data public class Utilities { - /** The reg proc logger. */ - private static Logger printLogger = PrintLogger.getLogger(Utilities.class); + /** The print logger. */ + private Logger printLogger = PrintLogger.getLogger(Utilities.class); + private static final String sourceStr = "source"; /** The Constant UIN. */ @@ -89,15 +95,6 @@ public class Utilities { private String mappingJsonString = null; - /** - * Gets the json. - * - * @param configServerFileStorageURL - * the config server file storage URL - * @param uri - * the uri - * @return the json - */ public static String getJson(String configServerFileStorageURL, String uri) { RestTemplate restTemplate = new RestTemplate(); return restTemplate.getForObject(configServerFileStorageURL + uri, String.class); diff --git a/src/main/java/io/mosip/print/util/WebSubSubscriptionHelper.java b/src/main/java/io/mosip/print/util/WebSubSubscriptionHelper.java index 9e69ef9f..ee71e62e 100644 --- a/src/main/java/io/mosip/print/util/WebSubSubscriptionHelper.java +++ b/src/main/java/io/mosip/print/util/WebSubSubscriptionHelper.java @@ -1,12 +1,12 @@ package io.mosip.print.util; +import org.slf4j.Logger; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Value; import org.springframework.http.HttpHeaders; import org.springframework.http.MediaType; import org.springframework.stereotype.Component; -import io.mosip.kernel.core.logger.spi.Logger; import io.mosip.kernel.core.websub.spi.PublisherClient; import io.mosip.kernel.core.websub.spi.SubscriptionClient; import io.mosip.kernel.websub.api.exception.WebSubClientException; @@ -36,7 +36,7 @@ public class WebSubSubscriptionHelper { private String topic; @Autowired - private PublisherClient pb; + private PublisherClient pb; /** The Constant BIOMETRICS. */ private static final String WEBSUBSUBSCRIPTIONHEPLER = "WebSubSubscriptionHelper"; @@ -44,11 +44,12 @@ public class WebSubSubscriptionHelper { /** The Constant ID_REPO_SERVICE_IMPL. */ private static final String INITSUBSCRIPTION = "initSubsriptions"; - private static final Logger LOGGER = PrintLogger.getLogger(WebSubSubscriptionHelper.class); + private Logger LOGGER = PrintLogger.getLogger(WebSubSubscriptionHelper.class); public void initSubsriptions() { LOGGER.info(LoggerFileConstant.SESSIONID.toString(), WEBSUBSUBSCRIPTIONHEPLER, INITSUBSCRIPTION, "Initializing subscribptions.."); + registerTopic(topic); subscribeForPrintServiceEvents(); } @@ -72,11 +73,10 @@ public void printStatusUpdateEvent(String topic, CredentialStatusEvent credentia registerTopic(topic); pb.publishUpdate(topic, credentialStatusEvent, MediaType.APPLICATION_JSON_UTF8_VALUE, headers, webSubHubUrl + "/publish"); - } catch (WebSubClientException e) { - LOGGER.info(LoggerFileConstant.SESSIONID.toString(), WEBSUBSUBSCRIPTIONHEPLER, INITSUBSCRIPTION, - "websub publish update error"); - } - + } catch (WebSubClientException e) { + LOGGER.info(LoggerFileConstant.SESSIONID.toString(), WEBSUBSUBSCRIPTIONHEPLER, INITSUBSCRIPTION, + "websub publish update error"); + } } private void registerTopic(String topic) { diff --git a/src/main/resources/application-local.properties b/src/main/resources/application-local.properties index 6a6ecacb..b349658b 100644 --- a/src/main/resources/application-local.properties +++ b/src/main/resources/application-local.properties @@ -1,109 +1,16 @@ mosip.event.hubURL=http://localhost:9191/websub -mosip.partner.id=792112 +mosip.partner.id=partner-msp +mosip.datashare.partner.id=mpartner-default-resident +mosip.datashare.policy.id=mpolicy-default-resident +mosip.event.callBackUrl=http://localhost:8089/v1/print/print/callback/notifyPrint mosip.event.topic=${mosip.partner.id}/CREDENTIAL_ISSUED -mosip.event.secret=test -server.port=8099 csrf.disabled=true -//JSONObject event for birth -{ -"birthID": "", -"date" : "" -"name": {"name of the child"}, -"gender": "", -"guardian": "vid/rid/uin", -"guardianName": {"name of the guardian"}, -"phoneNumber": "phone number", -"email": "email id", -"address": {"address"} -} - -//JSONObject for birthresponse -{ -"birthID": "", -"token": "" -} - -//JSONObject for death -{ -"token": "token", -"deathID": "", -"date" : "" -} - -//JSONObject for namechange -{ -"token": "token", -"nameChangeID": "", -"date": " restClientService; + + /** The id response. */ + private IdResponseDTO1 idResponse = new IdResponseDTO1(); + + /** The response. */ + private ResponseDTO response = new ResponseDTO(); + + /** The template generator. */ + @Mock + private TemplateGenerator templateGenerator; + + /** The uin card generator. */ + @Mock + private UinCardGenerator uinCardGenerator; + + /** The utility. */ + @Mock + private Utilities utility; + + @Mock + private QrCodeGenerator qrCodeGenerator; + + @Mock + private CryptoCoreUtil cryptoCoreUtil; + + @Mock + private CryptoUtil cryptoUtil; + + @Mock + private CbeffUtil cbeffutil; + + private ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + + private EventModel eventModel; + + private String decryptedJson = "json"; + + @Before + public void setUp() throws Exception { + + when(env.getProperty("mosip.print.datetime.pattern")).thenReturn("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"); + byte[] qrcode = "QRCODE GENERATED".getBytes(); + Mockito.when(qrCodeGenerator.generateQrCode(any(), any())).thenReturn(qrcode); + ClassLoader classLoader = getClass().getClassLoader(); + File printTextFile = new File(classLoader.getResource("printTextFileJson.json").getFile()); + File mappingFile = new File(classLoader.getResource("RegistrationProcessorIdentity.json").getFile()); + File credentialFile = new File(classLoader.getResource("credential.json").getFile()); + + String mappingFileJson = FileUtils.readFileToString(mappingFile, StandardCharsets.UTF_8); + String printTextFileJson = FileUtils.readFileToString(printTextFile, StandardCharsets.UTF_8); + String credentialFileJson = FileUtils.readFileToString(credentialFile, StandardCharsets.UTF_8); + /* + * JSONObject crednetialJson = new JSONObject(credentialFileJson); String + * credential = crednetialJson.getString("credential"); String protectionKey = + * crednetialJson.getString("protectionKey"); Event event = new Event(); + * event.setDataShareUri(null); event.setData(data); eventModel.setEvent(event); + */ + eventModel = JsonUtil.readValue(credentialFileJson, EventModel.class); + // PowerMockito.when(Utilities.class, "getJson", "", any()).thenReturn(value); + + Mockito.when(utility.getConfigServerFileStorageURL()).thenReturn("configUrl"); + Mockito.when(utility.getGetRegProcessorIdentityJson()).thenReturn(mappingFileJson); + Mockito.when(utility.getRegistrationProcessorPrintTextFile()).thenReturn(printTextFileJson); + Mockito.when(cryptoCoreUtil.decrypt(any())).thenReturn(decryptedJson); + + } + + @Test + @Ignore + public void testQrcodegeneration() throws Exception { + // JSONObject jsonObject = new JSONObject(decryptedJson1); + // Mockito.when(printServiceImpl.decryptAttribute(any(), any(), + // any())).thenReturn(jsonObject); + printServiceImpl.generateCard(eventModel); + } + +} diff --git a/src/test/java/io/mosip/print/test/service/impl/QrcodeGeneratorTest.java b/src/test/java/io/mosip/print/test/service/impl/QrcodeGeneratorTest.java new file mode 100644 index 00000000..4ed7536d --- /dev/null +++ b/src/test/java/io/mosip/print/test/service/impl/QrcodeGeneratorTest.java @@ -0,0 +1,76 @@ +package io.mosip.print.test.service.impl; + +import static org.hamcrest.CoreMatchers.isA; +import static org.junit.Assert.assertThat; + +import org.junit.Test; +import org.junit.runner.RunWith; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.context.junit4.SpringRunner; + +import io.mosip.print.constant.QrVersion; +import io.mosip.print.exception.QrcodeGenerationException; +import io.mosip.print.service.impl.QrcodeGeneratorImpl; +import io.mosip.print.spi.QrCodeGenerator; +import io.mosip.print.test.TestBootApplication; + + + +@SpringBootTest(classes = TestBootApplication.class) +@RunWith(SpringRunner.class) +public class QrcodeGeneratorTest { + + + private QrCodeGenerator qrCodeGeneratorImpl = new QrcodeGeneratorImpl(); + + private static final String binaryData="01001000011000010111000001110000011110010010000001000101011000010111001101110100011001010111001000100001"; + + @Test + public void testGenerateQrCode() throws Exception { + assertThat(qrCodeGeneratorImpl.generateQrCode("data", QrVersion.V25), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCode("data", QrVersion.V26), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCode("data", QrVersion.V27), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCode("data", QrVersion.V28), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCode("data", QrVersion.V29), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCode("data", QrVersion.V30), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCode("data", QrVersion.V31), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCode("data", QrVersion.V32), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCode("data", QrVersion.V33), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCode("data", QrVersion.V34), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCode("data", QrVersion.V35), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCode("data", QrVersion.V36), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCode("data", QrVersion.V37), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCode("data", QrVersion.V38), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCode("data", QrVersion.V39), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCode("data", QrVersion.V40), isA(byte[].class)); + } + + @Test + public void testGenerateQrCodeWithBinaryData() throws Exception { + assertThat(qrCodeGeneratorImpl.generateQrCodeFromBinaryData(binaryData, QrVersion.V25), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCodeFromBinaryData(binaryData, QrVersion.V26), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCodeFromBinaryData(binaryData, QrVersion.V27), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCodeFromBinaryData(binaryData, QrVersion.V28), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCodeFromBinaryData(binaryData, QrVersion.V29), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCodeFromBinaryData(binaryData, QrVersion.V30), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCodeFromBinaryData(binaryData, QrVersion.V31), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCodeFromBinaryData(binaryData, QrVersion.V32), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCodeFromBinaryData(binaryData, QrVersion.V33), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCodeFromBinaryData(binaryData, QrVersion.V34), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCodeFromBinaryData(binaryData, QrVersion.V35), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCodeFromBinaryData(binaryData, QrVersion.V36), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCodeFromBinaryData(binaryData, QrVersion.V37), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCodeFromBinaryData(binaryData, QrVersion.V38), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCodeFromBinaryData(binaryData, QrVersion.V39), isA(byte[].class)); + assertThat(qrCodeGeneratorImpl.generateQrCodeFromBinaryData(binaryData, QrVersion.V40), isA(byte[].class)); + } + + + @Test(expected = QrcodeGenerationException.class) + public void testGenerateQrcodeGenerationException() throws Exception { + qrCodeGeneratorImpl.generateQrCode( + "sSsaVRzwQRH6Eoh5hhcacmnvkYL2KDtwYOgnRNclaEfccdrtMXfg563x3zMNdRcWwd7TLWM2NZlzWeWc6aG8HfKB5Us2PijzMvjwxnkOfUPTasPOHWFyEbILRIPXUoK4b9GUIPChJKPeZNGeBXQAyj5BmHmw6GfKQqLYHMuDd6n5McrOuoT8I3YJvVfqcnntOfm7AegL8UOEdRxzQjq7JKvNoc9wknRxWhDwEBgFNsiRpMntJGiyGxZxg8CGL5B0NnvzUUJZdemF2au76Fj9A37kWYJLwfolsFxtglUIzO5KqW4gfSMvdsG0V9b4NsOZDvSarYOllUAAwcnouItYvFy1gb0UapCIagqkLmh26M5v6E0PYzPwa3SbcxJ1gHe6H8MJXmMBwJVbT0N0sP6yQIjG4GqlkNsGcaRDOWv6C35V3JSbfxHF7TIFbkENzWQUSH7U3doQlWfR08uwzEstk1Vc9XirRkGUZ05hMNvfzm82JjiTCSovBld10dxM8rMa6Mz5nw3YrbjjWlmgBOVwAtGA8UOfTsrWQ2pLlt7xyeotn4TNtjTGIw5nClO67SxxDRLNtqReY7VbljHzmUm9GUFiqIr8l7B4J4v807elPn6VPYJpcBJ98VEMwwLkPLIlywA2578NvZj5UsGURjMeTdtR6FnMYSso5DD2dI9tLgRXYekAod19sqvXe7m5GS85bsBqaIyappDgAoMIvxJWEHcscxflRV6uRYhsTQNNT2aegXDQh6xeX0aWZysuaHgqxxGo4rE0ya8t5xhZsUlcplhqcSe8zZ8cCBLTnVdgmeTxQhtBAUeJiRdYyzFXkQgDxRzy90RLMrno3siUrRcR9PvppBvfrKXLYpwfzKsOjzhHL8uJXV4n7NixhbWk3ZjEobsiiyYDE52DLL2hrfLBi33VY9kPsEiOgMr1TvBejTeU5VwgbXup6s4J49FmksmZPgSViJ8EzKw1sHG57qB1pcnedWWlljBPkrALPlPVvwh6tcgHtesxh7JUsllJAIEKZTBc5Lc7lAjrFHotiMqlRrjpTIYEqp89kItvGjiKXBAjaFvfYquEW0HhvqhZW5v0CP3SLpduwJ3cn0Xu0qHxpo0zCi5x7itpsJ5jNFKjoqA34FMSIxXD0EC5GcsQ0A7dUjxGYBC1TazUfzbpIVGX4k9AZUFquaXe8ptNVg7Vpc3I7ANNtvYlWp046btHBb64VU9FaxPdVA1Uo3jK9PxcZk7adsF5voS8wt4BgEzogKPNIj6J5ehB0n5SQC6PZ", + QrVersion.V25); + } + +} diff --git a/src/test/java/io/mosip/print/test/util/UinCardGeneratorImplTest.java b/src/test/java/io/mosip/print/test/util/UinCardGeneratorImplTest.java new file mode 100644 index 00000000..e3ba6af1 --- /dev/null +++ b/src/test/java/io/mosip/print/test/util/UinCardGeneratorImplTest.java @@ -0,0 +1,160 @@ +package io.mosip.print.test.util; + +import static org.junit.Assert.assertTrue; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.when; + +import java.io.ByteArrayOutputStream; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.util.ArrayList; +import java.util.List; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.core.env.Environment; +import org.springframework.http.MediaType; +import org.springframework.test.context.junit4.SpringRunner; +import org.springframework.test.util.ReflectionTestUtils; + +import io.mosip.print.constant.UinCardType; +import io.mosip.print.core.http.ResponseWrapper; +import io.mosip.print.dto.ErrorDTO; +import io.mosip.print.dto.SignatureResponseDto; +import io.mosip.print.exception.ApisResourceAccessException; +import io.mosip.print.exception.PDFGeneratorException; +import io.mosip.print.exception.PDFSignatureException; +import io.mosip.print.service.PrintRestClientService; +import io.mosip.print.service.impl.UinCardGeneratorImpl; +import io.mosip.print.spi.PDFGenerator; +import io.mosip.print.test.TestBootApplication; + +@SpringBootTest(classes = TestBootApplication.class) +@RunWith(SpringRunner.class) +public class UinCardGeneratorImplTest { + + @Mock + private PDFGenerator pdfGenerator; + + @InjectMocks + private UinCardGeneratorImpl cardGeneratorImpl; + + @Mock + private Environment env; + + @Mock + private PrintRestClientService restClientService; + + @Before + public void setUp() { + when(env.getProperty("mosip.print.datetime.pattern")) + .thenReturn("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"); + ReflectionTestUtils.setField(cardGeneratorImpl, "lowerLeftX", 73); + ReflectionTestUtils.setField(cardGeneratorImpl, "lowerLeftY", 100); + ReflectionTestUtils.setField(cardGeneratorImpl, "upperRightX", 300); + ReflectionTestUtils.setField(cardGeneratorImpl, "upperRightY", 300); + ReflectionTestUtils.setField(cardGeneratorImpl, "reason", "signing"); + + } + + @Test + public void testCardGenerationSuccess() throws IOException, ApisResourceAccessException { + ClassLoader classLoader = getClass().getClassLoader(); + String inputFile = classLoader.getResource("csshtml.html").getFile(); + InputStream is = new FileInputStream(inputFile); + + byte[] buffer = new byte[8192]; + int bytesRead; + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + while ((bytesRead = is.read(buffer)) != -1) { + outputStream.write(buffer, 0, bytesRead); + } + + Mockito.when(pdfGenerator.generate(is)).thenReturn(outputStream); + ResponseWrapper responseWrapper = new ResponseWrapper<>(); + SignatureResponseDto signatureResponseDto = new SignatureResponseDto(); + signatureResponseDto.setData(buffer.toString()); + responseWrapper.setResponse(signatureResponseDto); + Mockito.when(restClientService.postApi(any(), any(), any(), any(), any(), any(MediaType.class))) + .thenReturn(responseWrapper); + byte[] bos = (byte[]) cardGeneratorImpl.generateUinCard(is, UinCardType.PDF, null); + + String outputPath = System.getProperty("user.dir"); + String fileSepetator = System.getProperty("file.separator"); + File OutPutPdfFile = new File(outputPath + fileSepetator + "csshtml.pdf"); + FileOutputStream op = new FileOutputStream(OutPutPdfFile); + op.write(bos); + op.flush(); + assertTrue(OutPutPdfFile.exists()); + if (op != null) { + op.close(); + } + OutPutPdfFile.delete(); + } + + @Test(expected = PDFGeneratorException.class) + public void testPdfGeneratorException() throws IOException, ApisResourceAccessException { + ClassLoader classLoader = getClass().getClassLoader(); + String inputFileName = classLoader.getResource("emptyFile.html").getFile(); + File inputFile = new File(inputFileName); + InputStream inputStream = new FileInputStream(inputFile); + PDFGeneratorException e = new PDFGeneratorException(null, null); + Mockito.doThrow(e).when(pdfGenerator).generate(inputStream); + cardGeneratorImpl.generateUinCard(inputStream, UinCardType.PDF, null); + } + + @Test(expected = PDFSignatureException.class) + public void testPDFSignatureException() throws IOException, ApisResourceAccessException { + ClassLoader classLoader = getClass().getClassLoader(); + String inputFile = classLoader.getResource("csshtml.html").getFile(); + InputStream is = new FileInputStream(inputFile); + + byte[] buffer = new byte[8192]; + int bytesRead; + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + while ((bytesRead = is.read(buffer)) != -1) { + outputStream.write(buffer, 0, bytesRead); + } + ApisResourceAccessException e = new ApisResourceAccessException(null, null); + Mockito.doThrow(e).when(restClientService).postApi(any(), any(), any(), any(), any(), any(MediaType.class)); + + Mockito.when(pdfGenerator.generate(is)).thenReturn(outputStream); + + cardGeneratorImpl.generateUinCard(is, UinCardType.PDF, null); + } + + @Test(expected = PDFSignatureException.class) + public void testCardGenerationFailure() throws IOException, ApisResourceAccessException { + ClassLoader classLoader = getClass().getClassLoader(); + String inputFile = classLoader.getResource("csshtml.html").getFile(); + InputStream is = new FileInputStream(inputFile); + + byte[] buffer = new byte[8192]; + int bytesRead; + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + while ((bytesRead = is.read(buffer)) != -1) { + outputStream.write(buffer, 0, bytesRead); + } + + Mockito.when(pdfGenerator.generate(is)).thenReturn(outputStream); + ResponseWrapper responseWrapper = new ResponseWrapper<>(); + List errors = new ArrayList(); + ErrorDTO error = new ErrorDTO(); + error.setErrorCode("KER-001"); + error.setMessage("error in digital signature"); + errors.add(error); + responseWrapper.setErrors(errors); + + Mockito.when(restClientService.postApi(any(), any(), any(), any(), any(), any(MediaType.class))) + .thenReturn(responseWrapper); + cardGeneratorImpl.generateUinCard(is, UinCardType.PDF, null); + } +} diff --git a/src/test/resources/RegistrationProcessorIdentity.json b/src/test/resources/RegistrationProcessorIdentity.json new file mode 100644 index 00000000..5b58531f --- /dev/null +++ b/src/test/resources/RegistrationProcessorIdentity.json @@ -0,0 +1,76 @@ +{ + "identity": { + "name": { + "value": "fullName", + "isMandatory" : true + }, + "gender": { + "value": "gender", + "isMandatory" : true + }, + "dob": { + "value": "dateOfBirth", + "isMandatory" : true + }, + "parentOrGuardianRID": { + "value" : "parentOrGuardianRID" + }, + "parentOrGuardianUIN": { + "value" : "parentOrGuardianUIN" + }, + "parentOrGuardianName": { + "value" : "parentOrGuardianName" + }, + "poa": { + "value" : "proofOfAddress" + }, + "poi": { + "value" : "proofOfIdentity" + }, + "por": { + "value" : "proofOfRelationship" + }, + "pob": { + "value" : "proofOfDateOfBirth" + }, + "individualBiometrics": { + "value" : "individualBiometrics" + }, + "age": { + "value" : "age" + }, + "address": { + "value" : "addressLine1,addressLine2,addressLine3" + }, + "region": { + "value" : "region" + }, + "province": { + "value" : "province" + }, + "postalCode": { + "value" : "postalCode" + }, + "phone": { + "value" : "phone" + }, + "email": { + "value" : "email" + }, + "localAdministrativeAuthority": { + "value" : "localAdministrativeAuthority" + }, + "idschemaversion": { + "value" : "IDSchemaVersion" + }, + "cnienumber": { + "value" : "CNIENumber" + }, + "city": { + "value" : "city" + }, + "parentOrGuardianBiometrics": { + "value" : "parentOrGuardianBiometrics" + } + } +} \ No newline at end of file diff --git a/src/test/resources/credential.json b/src/test/resources/credential.json new file mode 100644 index 00000000..b4ac355d --- /dev/null +++ b/src/test/resources/credential.json @@ -0,0 +1,23 @@ +{ + "publisher": "CREDENTIAL_SERVICE", + "topic": "mpartner-default-print/CREDENTIAL_ISSUED", + "publishedOn": "2021-01-07T16:34:08.216Z", + "event": { + "id": "b59516f2-979d-432e-b9c5-94ebd5be56fc", + "transactionId": "230ce206-7a9a-45d6-9505-fb0392e42abd", + "type": { + "namespace": "mosip", + "name": "mosip" + }, + "timestamp": "2021-01-07T16:34:08.216Z", + "dataShareUri": null, + "data": { + "credential": "8k5bOKVDYs9H5JK3BgmnpkGGe9cpo2vni94U1zoqvB0yQKw43iiwAODMo9Fcg7Ys6EOQ1P2ThhnnaYI8BgHNxGdStuTpH4i3MQGF0eEw1B_9opG8oTG2J4JzbY1Lxhua3N9YrzCcamj9vdTbbRirGEcm0miBE1HTuYZeloUhZ-IKEOF-nYfiV0SIjswKP938aTszixFBMLUQcy9_18VSFpo6AymdwbztDiog23ngbp6dJJFf2vywquW6MFnxlX_YuFseGNot3TQhSqq_zDZydpnPsiqM6BUreg5NXrFZlrgLVmRwPcaabDQNvyevQA9OMKAqKQqTyNn4Rx1OY9nssng-VUBlMP5PmfMB_OdmywPDPFdMMvTdHs3OrIjSuf2SI0tFWV9TUExJVFRFUiPILtxE8WwjvwHAXrrMB_5ahD09fFCoOTytK5HMIgQEN0O3lKDaVlzZ9Wf1iVpXzI_-rB8LHg1ELRVI9PqrmTTxfdt927T-kyvfZoc_0j_BHWeBkDn3WVGgu337eVd3ySkOixQKxdIVATl4F8UZr9epWTDFgkWqYhF92SXFqJ0EnvanwpFOqp-86G7CWnkfb7Of5WGmU_fMOun7iNJA9xLEmy1m2LgrEVLMCZSg_XL8t_LdpmmtmX6qUfdTsdac3CJd9-gHvUKjKirbmU9kssMTU70pTL3bFu81eCBsnH_8ovq5q499IXigfMUstT_gTyovyQWTEBtiQo1SiOgtDdk-PN5Hz1uwbLkN2bTV88YI7l324qADaajpny5q-ZTY6z99kiNT73hIxmEmOU_HgkzCFDAFy_Ot2zUMS6uuwT1fsgcDiqsPf5g1Xw6659MUmg1YDOUDvYGNYIggXUc40CstUQdELBwRZRI3daNG8_6xkjYI_C47A-V2tIsFm2FhYt83q5X3t6m_VCy5ErQeX42zXKqyt9Q0kFofF9znqKzDKoaEqudVceoGzfQGXGiVMWXngAici9YU5kKiCc1JsQapoSAti4JAaUdIW30TgVS6ORoYbz66TSyt91yrNTXxXV5Kha5wU4ZCQIDD8-4ZYExug_zRUOBrQxNVaSHItX5XvkeuyoZhoedzJ_Of3pGGEhuswkMEl-NopVfIq1Nqd0AzxRw5U2caHoIc4L9N_Eo2l6kceU_zfK4od3obFpgNFsCjwC7xVd7t82W5y4VVvJYPd4IyMsdENIFlr-9Iuz_-9y2NuOQ5ekB3mFXIuB44GmZUPXk-mWfZw8EG547700VtikB_E-rlWOshomNsCaD9wrLolccl79Wd-NFvPnuSjWOBlMuBIKje_OgSBdZ4ApJMqRyeZDm6H0Df8jsU2wZ6QeKE2GN65F4_JCuRMMb0mqXVCQ-3ePTbGSXzObwan-99S-auranyruT9OK0Ku7nQ7X22vzB2HD9Vg0mDMdUFnIK7hHS0ZIs9E6P8sQNz8mMzkc80c9jEBchHAcfnr0fccGDT8WwnRT_D23GTAgeD9InbeYM6LBSFqp3V_PabXmcEi1usJt4VU0i5oZfz1DROHeVEJbsCjsE4xFOlnyToOIS1kij__jtw69NLNBqKycWbKmKCXbVXSCgvKJdrC-sif0rD-grp2X9sdTzu53lI4Meyq8yX4c3nyoxPCRYnxdKSDIb1RSOgDs4DrZ5xUSO1FLaedp4h0u6MnPgUN5V8zfCMBgresgxWBMFUf9NY3osQFiLvzaswTKD0nQjlmU5vLcSiZgF8YlaDh7JPJ13bGm_xQjwTtwz-2DeekLBt0ZAmrLz-iLZW_wDdOe-wM4tSKro1k6dGKE6jePLqT2lEz6HXDUINUR-A_oTPi0pFW8p5F8lIyGJp0TWw2jQo3TpEyDxLLr89e38IxLs7tZqfYgEqNMwCgMFuMn1T1e2sokZx8ni6sKv1ldFfuHjUprp_ULFbfemKG4CNszoB4tj2Q43i86c7V9mejjsze6juZlu7DVHQqfvzHwXAARZbcjZVs__545m3MsyHbmxDguL1P48sKVKwfgJ9V2eYEd5NuNxrZapcFuE9EP5xJdiHdxe1SVhlg9n1VxWpVYe8fIeEuXCjgP9gyrQXR7QEzAJb3gw53GPu1FU_Kop0ExEqgkQZZvLhDBk5LFLohp697P6zI8YQNcyH54xGzNqdpZMrPE7-ZvGexKEXFLhlQRL2pGy3og11V3oxWFQgX0DCMEY7spP2E2PahVVeDycCvQJ79I7Opy2zbXtjNoqx5hoxpjFdXvigfvy04bna8il2qrkD5-La1Pf3XlKgGnrQi3hsLTm0UpShvM9uoER5SvtvApO4zn4lV2SZrLQogq7_Q4N8cROo0b44FYjYDu91Xv-Nhf1Ob-6rCXMpTTqm1ZEypJClf6QiQ-QH5GcivMS0gkSdoGxZWbq0YApaJYPJzuG1sLVtiJ38MitSRzIltxNUzk6Ng7JquDoWt0ve2NqNXAEojuj0svfS0v0IicuD6YfHRWUQwL5ob-tutw14MklzYEKdbE4hvrIeqz4nTd02C0_HNZdnWHLoTcRJEovuylrCOwIkZtquRvujKZIy8R-YSFlj1Nb6dEAKFf97Lw-NIkIipQbvQmDoRb6YMYrF18XvS_YSO0RLrEJ_va39YusnLnPK8tiDE8Pu3Wj_IHVBNcOe2F3Lpzx5RhFq4aQgNTy6Ig1LYqr-Vwrn7Qk5FHWfAdpUuMiGivFtj01MYH3ps_6dkvXb0t952lj82ZWXt0CAeWMnnXFureMOFz28mlQsCBat8BpzQrYC0_-1drHXkUexpFpZbXXLbwSGX_9Ws3ZK3yl8KFjDCeTIPAvC478Bt0jx4zIsXDqYuwV6-UiOtfjfU1iAdZXFVl3SS_fwLWyss6VKNyTzMqY5f92dRgAgqGIzOqV5wiIude3brWYcImhLsb76h1q1S78y9atqu7J7CJ1UE3Q9OgdnQQaVRALIK74JBvN8i0GyTV4_SkJ6E_seCwdSuVZ5D4BadFdRtR9e7QcUAIrHPn88fROUIMRopz39Kj-bLVK87rylFSYr3DQGTWQPFEvDhb8lKDSx_JPzs1tTHV6qyZHTmOOhJSKpT8oDi98Hj9UAB-ViBLfkCbWmRu-vrGkwQwQp3fn-Vl_19yQBPmrHtw8XZnODRTTtCyh_ne_KY-Iu43fQlr7MTgRwlQJObqX8FiPu3-dqX55NT4xdR8ACChLHy2RxHMrCkUrQ0_yYdzdM7Qe7lDhuNPZ9N-LxR7UjZXfkFZIjPVDmTuqvy2aATDgMcpb10UTDpqMuswBQurCDXHaSgK-G_L9DYxnu5Dl49Qw1KoL6RBc2hjtH5o1TaiKwDsGmMkU_9dbQXO6Wnz2XQ0hLintTYLT7puB0KjKiJpxWiXt9rx2uXEKNSdQ4wRdgypkVDWFRECMTMrFgsPhUdMxd1rtf9cO_zg5bAkdWIOiNqrlujZ5iQWZfTAAieiVRkBUnhQzO9PVYc1FAvD5ppBmDf1TlIyvmbdssYwMgBSH1Bkeo1n2coLnNk40uO7FwnpBZ5SWG8GRaiN4gq7l7yupcvuJQ25qlJuafpNq6EnNAJOqU4irZ0xlzAtzAatrW-upjVnBfqK1u4JTa8XyasZYlzBVezPwwj6yQTTvbnBffOHI84NB167AdopNv-K1vCTPZSzMPns-2pJZ7m9yqyTx_k8UngEPh4pzO43o-W9JC3SxcecOUJ3YRSm8Z9tw9omBd8PdU4V4RJATdgwK1ic97jNrCCtabZ0NZZJfIHcRDsULJuTa-hiQzW2SrCoB7XEzntFkhElVOUKFWWO6SHnL__FAlK61ALprnOvvkdeylmZjGuhub4g1jcRPo-cAz4xd1m44hNu7jpJTKeFOvU2FQHfycOMewuADdYNLgiYppoptQg4sPdY-VBggyWmbAtUmEZ4tOb2QJ0srTaOG8JfGmsW0WyyIR3eY-V4_G1HwgwTjvBjb77aXlMGBHGMNk2dqzY3D8NN6GWx-07XEVt8M8iCEF7QsL7OXisym1orazFQ6Gm7KiCtkw7keDdTEGbSD8icMqXjwzFAxWLHAmSKumkCvZQhfMNwyxuye65hNLjjt41ewsQGBhS3cfTBPMDQ4xMN5VfiBz_cjkAwKH5c5vMWapZ1r8VIT6YcSwh7u7wPUPj0VP4wKGrgA-6fAeXwGQCEtMntZDGW4SjQzBqNnDv7pHS8wIbjYepQ3I0uC7jhWlFWhLOLQvFJKGx0zuLYLVR7rAd3Z0sYbK4UqCYn_zHpCwn-u1DRy4oef-dJEDhvuYGb5Vdi1Xl1zI02_Gx_wnXICutt5XXoZwpH5-TjrP9SCJeFZPowdAcy2Ppb1g4pS1V9koUaRCm2ozlL6TLJfqsOoRiSGn6GnigVT9FcWmPb0i0CJC4GQOr971Rh8-yIOyeQK-zxWSYQy-11JWo0xKJQrGOwKKPRtpUFOR8dVqSEwoti2i4hEUQeddJ4xsurleHCbmXoFbb3mSgACCI0EyGiFEWpXTNWotoG0qFThCw2ZT5dPurtoL1cK8ItAd42FFqVjdC_K-IB_p7LD-uVmE8rg_9c5p1jlMZNSlq94QJwbVdl5Z-igxLHulGtPfjluBIBorx-2pzbj3m8_7GI7gudENVGVimGoSpFVXG8CeECIJv8A3KlHNjf2inVaNnGKDd3E5yZIZcmY4SY1zjfVRkAYn0j2Iwd8geBdXASpWLpYoC_h2twImnJnsEkf1nFdjHrd8HLP7TBhPorsdTyKQJvZAdt0SbBiRMsU652F1tKbcge4mi_BViLAiF677WZSm_2Jq4VOso6lmlo9DguOn4YqTYp6FAPSDEmG3r0gwJBAMgz_fFPA6Xbn3Z1pcxkW1i8pEpAH9bCTL7ZktjLLfP29e7dztb8Nbh0DXL6xmRiP59VYXLw3Wr9ZFvF6UD60nzItCxricvzyMFqbeppdzVf8O0ps50_MdUbCr4K2FhDgL_-caHRNcSLk9VqDFAnVjh8qZz2HZoGDV85slsI2vSUsJtC4pO5X3Ot_pZlGhZ7nhbNvZy7XUNa5D7zMKEajhvGxL8SUigla9JyiB-1ZY8V16wOROum75wqTdRKQQQN_Rg1WTHbKTmE3ZWZl202OxdjXvwDCS4hvDaj8q8vX1_lF_8Li3vumFNlld3W2tSECg6asmocE-wZTEJBDqbtkwCs7LL1UKMZGW2vmK9BT0btoKbdUVVz8-Kcbjh0ZObTMOVlRBpjjCXfqxZBLH7-ZkRjJaDFzeJRD2lm4OmubqSnOUBTjAFZAQhDqyKLdZvwX5gANwiT5MwOiUtu237YXJhkyq9EYlQ9fC9ivb7T0j2et30BjY_dMWqW2rcA-JY4HOp6b_P8zD4J0pIOyLWQTJcSnTg6O4LIxq50H0ndq6pQDyZZbFsehf4krfuOTxDEt3d5-PS4GaVVOpoxGGteptD9KKm_a4e6UKTQzOebfIlcUiGEHbYMAhrtxBGq-mK7SHnyKFBriTUWJ87fu2J9vXDjj-MLsRCq4Pibw4ltxEqD3of_xMYRlKI6YoWmumsDyKiEf9iMfPzS5ms9zvjq_cZ2NNP_G7uu0R4k_eZe_GpNnT0EvlKNsYmTQVtc1lmR2R77SC-UejmHpfctIMRRaXJ0450YGUeOdrZLZcMEJTjUw4Ulm8cLFsHIRPWUH7LTdQB3mq7pyxAwcHx10qyPsMYJADn6pi3FkqhMf0-EFAHjeZ3HND3ASyAOxqFUHQGGymdOuEcwPehCxdi3V8NV5dGsoC0ICd_142attsp2V2U6F8AtgUP48y9_zgzF9vS4727OhJRz5nqdxAS4wbd5Pm0W9lVmzl5hKVYJufs-hGf2bPDBs28ZGo8UdsTNg_RINmEjdswlm9VaekC4hIOC2GK4UzJS5I5sheVpRRviM9-ds-ciK1kOmnBWvpUhYxGi_KBKrKimY1_76FMURpWZH1QWhLwN6d4u20O1vZko1-x_VD7hOrCrQxqNQGpGhLjwHWwEWCR8vWYFubVJ0ufmEYzhjS7S3mcnA0STtLNzvai2OJ8tBqJO8lgaVG2im-ucntoVPvr6ZwI4tDjvwCLYINcisVi6DsnwxrRgvEppb2hE8yy-m87HiDcd8WJQsIcytlnCT9n_r8_cCL46-adIHqm0wqnlKzBjtTrv2ka2reAAUAxX-THWsk_MTB9GFNLrOv4M_XoocqRk_9cfx1RSi-h7CYTMwJPteRoJsB2IfyMK4Y7jgnW8ZrWEHxIbLw6jRF02cWc-dIau37Mntmrp7E8VMn-T4IS6B8Kq8Ec53SCp9eHrrGLeiahF4ib0of1XM-RZfe5p4QxZJOMyj8IKKfjZyqkNLI5t0oyxpfqVB6jMuWOMkWl559uYQomccZ_QVkQ9vQdA1vacUp4bNXOkSbtoyywTKqCdWOnvTYJnItiW3S8X0MjzQEuaX1eAnzOYGsZvpS_k00-FlqI-u4_bYsj2upOwX6yqKlhuhU7ln_DYch3ia_PkkH4kINZPYwF1mUY8kdBVTsKWUJr7Th1Y3sOuxtnYmE4TOZ1AlmC3YrLg7qdUIQ5OchDDsszcEr4fWWHnYOf2aTfBhAnt-LXogidd6hbaKWdvXp5j4IXtLcuBnqJvDfrNZuR_R4rDSzMUiSyoMa1yT_rcueTfbpbWfu6JqGE8tns4ZjoittOz_hIxvx1YwnT_ftTwdGZ6B1ob3ADx6YiPibnUAWlSnmMyegZCviL616FOVIPgoPgGJorty8k-jvL8xu-vHNn0gTab6S7tUWXZz1bJx1vt27AicLUF3zC9vUqjZqVDBpuvs-RwhhuaE6hAhJ_bfXrssSb-VPc-XCTL-zPJels3pq4-ptypTHwTz8ToeKhea1t-oWbAxhIJB15oqEt_L5y0J-TSutIx3SNmArnHrQgMEv8ZnrgyfyxYtwLVtFJhCPRI7cQduTZgzrLOTceamkDT7Wqjem3MXOx_vM_HpLEFdhzlz-ZO0i38hrTMY0KBM6M3ycic-8TyjkRkSHVOn4vJCJyX_dTvQnFkQ2r4yieXg1Leu8KPTHYnWHfRtKO0KEyaLFbtFwyjsN8pUwUWtl33VnabJUHiVIECnjhkGkX5A23Ni6KYg3v14mM4--Xsbh45cgv1gGlCfBt3wOzAS8emDcHsSJzgWOqnFamt0a7_4EZ8z61GZzLBYLOyes-uxC_NvHUuyBLNnoXSbF5dCHc7Eoc8cQQyMgNxDYs7PuW0VawAqqX0w5G-KMToCWPWym2KLekAuSR_-m68nTk0HSxbBvaLno03d-LVYX_6W__fSWU3XhkWM3hB54H8imOwS90GrEIb_VWsy_Lqrz4nGIV6GUI2ipg3ygaAocBFv3bGL0kSnSRdaK-gvV0xQEgeaoAVNw2nkZiGXjr7uFaEP1_J42C7rY5RFZiuZDJVXMgwkUKebrllaeVJBpKRUB25d6vzsCW985m36Oi9ES-r4rLY30_Dx04RGtOQX-FRlCzkWehG5xTSzycq1G5EyMioZn5UH3G4Y840sY-hfMBR3V2GbXnj9jHq5jxyFsxk9MWpKQZUnYUAbvUWXIe1z8N6cB6V_k-yfdEtfC86nmJX6ohYfovnnj4wSS9krlZsNd8jSamjnNmn90eqO7MThqvJDu8TR5GvCAXH8MCj3zXnE6ikB2O5F7Qt3G_krRZwtthPuQsA5juMnJFCH0LPeAUfvvHslaNZO09IT0CD8rwTJG5BO1B1Izv3vO3nQbdmpuFVYD4GJYv3odlggvchAtnWoHn046kQ51GZK8IRtHMP5ZFyFrBlKpGvjsXSm2ylHyplFXpSZ8r1qZ1knaduSUeCriHulxRz-RvdnFWFU8xHLxBIqitr40DtnNINwgXKfD3npZ7hOcLnqP3Bf-GabKG6djKjwb4WWQbsCblT_blwlDzFKcCt51nSZXZoc9k4BjYKFWsDL3uw9oeT7dmYaJdsGVeutmcbFpux8cOSQKb2cjH06sva_e_2djj2icd-k8RK9fOHRdEp8min-P3JSiAj80qWIVu0RNoW6NdbrDSrrhy-91C_LIC__FTjJlKwYxuP4LmDgOeRaKIlafz0bRsHrRCmyLcbAe_4c454iLaLHBoVW-nD-ukDIVtg3PLeVa-6m840P42r9j7p7RbEVm5wwjedSc70_aONkp-ecpVE_UCbuHqHXlV64XNFLSovP-Bxnni2r19S0SdAl0JVHydQpKxi8dLef5cTxtEvyFM1Aw4m1-w1zyspdQ1LM0zW0KLxhMTJ1Yivzp3YYtFvJJt6d2_lFYrC73bFDyIRonHUd0K0upjVdv_uflFRTVHY_jaY3U3LpAD4S5Gwm_3bfIXqjWX7qmXxpxcVIJtizYtv66LPKb-Jt-b1cTREaij4BvbkQZhtjlvYJYhPaBEXJK0X3Cn25IJ9hFYt-PKaWi4BoPJDdWdr0K9MatuX_he6FGiO30XQM9SUWQoQicxljpgy2CdWU_NrMnDannwBxK5GCeG0PpdbVxuMW0p5hgNs3lXm1xKObv67vjv8kpbTCKxxRvcgT-HPA74McLvuhtzXTun6gHKONLdLXhFjKItE8RXpNqIZiwWFz8xDXGv_aH0meAvEOJojuT0jgHg3pkG7AS9Rh_PZMgwVwREAuAwiUPAsRk8aSmkOYzHnNm7vXxOuYlEJ-TFU7Au5A6WdGOqsP8yEbnJH8cTnO50IMkFrgy28x8mswv2kpLSDo_3lgPdUOJRGF5DEZeLAoYygUmgS50-HBdGmhQpRiKnKO_5KFHPIW85Eq0oz3PHLV-3IZYdxO7FFoAZ-pqzVKREU_d1qjxVZ_Ya1n3yXmoLxBr6TNzxnBAhmCwdy5qswHHIzGmld7_zbKMJKE3t4K7n4cFwCYFcLIeZFIsv3WOBk0mpbu95kIGTjN5sJ5oZVhIJBhq29QxUjlLrZAVNZSuS93nv9Bdt31X0BqjzH1pleWIKQZQsZpji7DeU3vu4cqeESHbiYTm2jbhbdiUBNLoABr84T7IMK-XnNx-9bC7_SqDDrSs0URFFbkNyWxXOXUeiX3lEhtgL3fyX6NhFV7W20I4N3eLT3LXslGp11wNaBOFHZ58zITa5tuGwjkU_QDH4wPnsqZgxI3wMHGZ-p5s2ac-51Zpif3QVJFSookKZiqN9l8Oyd9_3cGQruReOsyCW9IAeVgsDrJGo-MLkvkBdVmxXIHUi-kLHf5s-NAl6-6aqaGpd03-OcK7KafIg0RqQbyfQjXHHdbE7kydub5TfJapVx1l8X8Z1K6AEScw90ytyPtOlGzHZaAWCR2zv4yOI9OhBqoSNqPo1pAdel3ROZnU-OcKFbGnlZsmqiV2MgcQVpdtoYA3YMkCAX0AR4qdNjWS5kK-4Jb6S_HfvKvYMsJDjDlcpG4OkcxPt5b6JThxT3KaKIQKFHhpDa4MaiK0kFR8BWMopnsVYePP2yITxmuH0-HNctiQITfdVTbzJyklKlQEI2M4lvz7pEM35h6Voo5SyYw_4evRfNr_M2ioU5-uadwADrPUBwvoECsfdtqWtQpjGmcYVAzorsWllJgm1T00oF5hUFjX8m-Bw9fdy8IV8defxFkQCQ09pQN0_LrL71AZ3eWEa_hfGdcuAwp5tXJW1a5jJv23h3xBbS-uTKHOxfJtU348whJVuMOxS1en7e1UmqrHB23igBmsn3V4F7gnuIzTdHcIGL4N3YFDc3pP0mMtdI1R8qvHzp2_5_ne-TWuXcT1k0hkIOzH8EO5m6nQbosURrIrvOyphNaC3Zjj9mjRWHJrpuuAespLNJhK9qm63OAFRE05XG04gWb63zVn9IZcmaZV8KwlZZaDBXtVOyKD1P6iDw0VwT-YMMHXFoz0xuj7Tv0AmJpLpCLtYgQB5leMKJmibbliWthNS3KN0YAtVHO25qp8HXDCw-j5aseksSUVr8k396UsMRRhGOJrMoYLLYZN4VXCKSU1XpQexcLa_yyw73yboCoKoJOqGN9xJ8u1Lmq5RAVdJdcty_Bss_84XHLJqh_kx8isFtDCP8vBgRf8kl6TUivA2hrQhZ3CNMHWdRpCwH5ljWAcSLoehHfDOp83tWJ6GSMRuXEqATmqDtJz4w6IBhrpcmlrcqOiINMHYLaho-54apibxN58mO9h_2ZVtXfJ8o2OQOcgOQJA5WfpH5kIqVB4k6xXMmArUIlPZyQ8kxmYj6EFv8fSZj-kR4zs9cnb5Dx9XF_5sXSffnmyOaUILvdlfklQsmWuVbMV_KIR0OngIdNA0sWNXPX4CiS6mBui1YNGXv0-NJxkUXgaOVDx9-nMTxcG7FBUUw5sqaRjRxz-PUvay3fGeai_IzQi5l-LfDx1d13Ox5dG13F9cCFKWteCkkVWki1Ik6yAjaPWPFkfdaIdzh3YC4KH4Kp65fAcKH5_AQfm6MwfAZi6fIPlghUUXDlCVYRxCFhNUgi0W1O2dUDGqCdciVnnJA7LsJ17bJxFUiM_uCzI8eHEZqr-KDgsy9ZxfKlwbgWsWnTfvN2IEGz4f9cJ45Ntj1GX2CWhZ_M_G_RMQwltdVaMqlTqT8eHo3lFxPzCzLNylAB1CWWofRwoqg_qwKPIh_C5KwJtHXpEdbDx6gWewGf27sIwSlxezBEEKJSjBPhCFRNbsmaOfD2_I312sn4x6OS8L-UU4DZHpqBlI2BkgWy_K2u2VWIvUwxxCs-2HUtpCbg08i35N0qONe2Ru-WCuTnGLzn9Wg_RqOeJbXQbmBiuXH-19t_Yb1wCR9R-irFAJtMx9sQUTlMJI4trLrVYnIjJ-f80RfPjK-AuuHMH4DBKulYfaoyxKexwwOyakDm00jVGqo2BXE0v5ukQq7ANmYzawnGueAjyoCDzEKP4kfvNuy-bu0SFWcDQsA67iNL124Tx-7BylI7HpeTr5naakzckwPkh4bWZElgBSriDriauZNUJdsNblSZf2XYuVrsUn5Oi4q7kwvAgcOjhkHAm6L43iuM9FWijWbAHCdo1prROgDy_F2r-G1z9fdFHWYfem1YSZNEid9VtRrRL38PgXukxGRn_a6IMzDZQ8FTGjobj6yiTiS7YffXrIH973zMShznn39wy0ullD2ZC8O89bG5mqI_1M58cvZdZ0RfJsD14b4Ny35ikHxJ8Kt7a6TOWE7QrmOFRnU3z9D0M_eibLCEslRWgS9nnB8O7kDJYgkvVglFoiKAz7lpAAlxmFTLxnKXa84Ttdz3UWU5xxis4mrIMWVyVbXW9wRsV3ti6u6F1LDs4IMzt7wOAFVRu3vztNLdVC2dpdLIhpEd3mw8sI9Vp82WIoqJe5HgvckuXnj047IhFQop8It5_RCxHdq3JdJDGzwYp760wit0mWFzx7e6EypgYZNq5-uqTc1yYQchlvUFWkhqZhpSCRMDWIb6A9-7uSZuoAmIX-dkFwfpv6oodzRakdFn73xvxsJ5Qp71ncuURdz7GKGcwUYCoCaUnUtrlmFbK9PxebBrVotUKgmx44HPNqFBEkZj8VIsZIC53gFbUshrbAjkC2FKOFYpoz4KIXELhO9PoWItJz5PDWNIPDfgTVj7hbKEKzlvnedieOm2IiAtYZSAYprvhWXENGGuPOEUaXxlnse-5E729o5EkSYFdMWvREsus_1QrCWAgC30oh7uHeWEcyCBQPhLkCmOj8sGTnoTVqb7DlQxMmYnqj-ShWS3q9hmsbc5DzgqrAIbdGINt4NERHk4w_YaGiMjw_VK-8fSBTcu0-eyGmtkDnl7FHCSE5E2FOyeERRrEYh9vUgC9XzF6t2hjQp9lLOWIYyx0zp9mLbrFDQcorhjjB_J22_E0tNkum0zU4LMiNrEYoVOk4jqi6uBzk51IvHmOZHBXS-Z3vGTOJbC-1BHX_wILkMyyWzkiFlENopLl0f5jZ0Tc0V9xoZF9_8UR8NW-Pre5c98Xdni_qmY6bwrIo65WTc0laVtfRRyDtMAvIG8d8a9u80KWCVJN44oTKME4uO0o94oEZKIVrm6Cgbq-7zOpymgNcIDanBzfigcyx-kSmekNeUhrLDRXnGJDIiMzu0IiDHQwT_8a6lNQOcerWgp8IGGwI-qy5a-7vhUV6MHKqYpJC7erD971G79f0qDQrhFFZiL3suhKpASpphJJ-5INrzj1jhyHaya1EEDhb6cEz3jqFY5Nce-wr6EwhXtU_V5bEuE7G3Z5H1PCT1HThWXC_6sknyFal2eTfGFZ0yUN4VBlyAJUsQoaB-FTEf9Q_Bsv_D8NtIcUp76DpMqiH4N-Fw62aM2bfeIBVN28dI9hklQSun1Pbw-fOSMp5AFO6z3xlSA1myRv1V9AWgpPC7pTPfKNvOzX0Adf5jzZcwGbVFYkUjcusNY2e_Q7Z6evYcBrIebNqUaEJpk703wTF08IJ2KDykR8Izlrlr8jOLoq8GQfo24MB0pqHq0Nq91VxJEUCZ3vayqX1I_zmytYfBFaJAyQFergp6brl2rFp10YnUaqh6wHn8H94i3yYQUOmVfNU9sseljjukS4OCf1kKOrjsLbgxmoYYHqxOmHrD2I2KnD39BNlltKKexFqgGZZnKJwSLfDQGEJFfQj2U1xKyIzJE0IOktkNXfwi33W15D2CyoIPkaYLbPoTsgOKvWEw5mILQSWsln6N57E9eEQL6zhJ5sj1Jweow6cB93S1tDyTgxsHlZZ9yBFqYtovbCeIJZJ5vMoeMuM7prT7BlfggePTM388FS0-AJ3CdE5sa2y8-k6XxcjAQoKg2LvlCDRa6V6nacQL15CO6iRnZaMwNnE_WOkJrBIdnuXNKC21AD7Pz_PpziVxTkcMdzby0d08Akep1UwuEcQBw21UufY12dgRE7EdwKVrLxL01LRlN90yvbsNUjhIdQtHY_-h1QNg-vfGBWkvfkZeJiW6vyD6tbtIiyvIRnqjK0aVbWwClfAfa_k8oVixthJI1YnPkJnUzoUcXfql17D4NSuOiKUusEybaQb6QQ0xrdoRNu3lYvroOzPz6x07PNAHSiF9uS7so372QQ8uWxxR-NH8BA4Maz7hQQPM2ifF9z-sYfThWY1Bmtb2RLWTekG8GXXX8T20WqmKrJxGa-mGZvNeRc5_mW4PBY9YObOKTTPc4mMjpdespSE9ZR590jHtoq87Bt8wnxyrvpeuT5L2U0rWUsxiLYeEukf2v5sKVbIOmFq9a5kPVRE0z5MCqZ4QkQ79N2QjvyuUSx2EWeQ3RHBfNeaF53-TpIDPIw6SNhzSa_V982EJ0X2JhM85kEZkNDmDNXalM8Sbn9G45Hodnj4BD7DMF9c-yVfrAurrCVw6h53dusUGZWnI5N372-bAHZirHEK-XQ_24r1U5IYLCFhU_-nMmuzymLjQNzWQKJjCOm25eG8w_ClogTtQUMB1LZ7mpu_mnhp_25MZqttsv_H5bm57t5_wt12YE42dHFvo5UQpVGqrmop-yevWg4fUCu6yui7Z3Rlx8U7U822MHOWgHZpQdEZPQx0z7S4rvP29Ogli_9PYRxJtL1869oi0nXftXLCHlYnD9bYqpPZMZyOGs8q3_9zxwafID9hIuluXwJ9l8Irai4gvn3u47hwf1KkZjnFCwC8MXrPLjXiEMrKzHly8PojE8HBqW8qqzh4KUcSF-jbcQjPbf5ptYkbFQfyFA0ZiJPTuKbr8yFFq_m7MkK3McsFySQ9BK9Hu4cwpMLcdrqUcF7tjMvbR_nHibOdlVpSaSn3aivNP22HoqsF7FJ2IellnvXwjFJTNmEgB4CoDutPeFSkuw_dOrfaaUPDFA24EY_BuWbzylRyLHKt-p7YcVCXe-znfwcRRxgzDbtDpXzwuhl2dxFZIraFqOPsVxfTk5Cyt_m72_kQWrqNOso_kRk8YXAMniGZ6kMDZVJaxpxp3J7hLRsYUNwiTrqtmc0GGmuxLYxGYtUAKyyNIQhxoLOo7DTcldefYb2dimqdnnnXiZ2u81OoZO3tVkr-RsC9m4FOwyLbco_8vDNWQSPQ2klYMepXIHOwUrewNmE-sPZZEXOGv1XKbW5LubRNnmwFFl0oRvZwMskuc8bIJgVKINu_nLZv6G4AXGRvQNVBlM_g9a91m5c41CMFQCMkH4W8zj9X1U1bhWr06icN0-_IAiPK_32odaGkJ9IgkCyx4bXoxV4yYVsIRfM7GmregXXkNY6YdhngyqZo-88mCPFkaQVIy8AKLSX957flV1WHOTb1vDMi9HKpyOKmphKqfYzX4tCunBm0FRF_oQYPzNkxmOIVfQDUMe2-av3ORG6g5UPGRZjotsqsZpAcY2Fef-uFL5md80Rw3uV6RHwK19spGE_yNANDgW11scXZGlBNeIa3z2dHFenlWzvh7Hmkk4XDiMJ8J-eoMsLQBKqdVMDvHaDkl-_6EanKHyyX_LdVlDHu49hcMK7bcWLhdbtM3aUa3b5-jB2ST4fuKL9tSOwki4AYmo__0AU_etRtAvScX9bkC8RkrKPe5FlsqchwDUgMLIrCVf3_uhsVG65FHlrufozN-0QOZ64RKG9_bXoq2y-y6N8hEreO2slE9R6oHKAzI6imVM1w1H_j60WovYlOFwZsF9_47X4pgICWgq_u4b7FQKROy6DUVq7xtQs-5BjlW5aTrBdAyMLyq8AwQORHkh_iw6pK1o0eNYnme_OV3_vZ1KYTfObATmsrodLidJV4ot066MR3Vm99fe4w61IHUYmn6yNOn9CZvKZ6f0S0Zxo27hdqO6x4VhQtjSKH7TjB2aUUQD5Vq1QKFGYc-FJjCQsjTdwMCwkeiRkExEKP9W5hsy6TXO4IkQOOgBPUCTCevRhRk4V7MVUuKaLoE6CCfvsiqA9LpOgYheBNyKe2JYtTRyzwastaJ1b0KQxBhfgZUAZQhsU78ngVcMaloGathymtsbDHvD19-T3Xiu1kaTbkbLpQm0i2qQzQun9xitKn_RCOqPt9mKR5z1VMolxuWz8xpKLZpDEiMN1JJKH6DUtb9uSt8Xe6OklaRMXEMa-3SWsIFSqAauFhJnrpu2fSzElUCgJvO38cvhMXQJVo4WLKCZtqfniJ-a7j9MDm-g3xA0VxdTVfGFI9xF9x0kK7Yo0VF1fKsEsTqtTEDVlOqCDiuuAN9TsXeKGIPIYr0HzjpYfsUBJS5GNql6_zlwVIMKBxV3ABCSfYM9c8SzQCRoJ2NR7J81jXpISZNRBg5SMa_MIAbt8qCrDrpbkFmVffedc9I2aidHtcv6QT8_XJoUgwUoD3xDXNAoI3aGxoYacKpl4nRGyC3nne_EPecRc5qRZCuOYW_psVISwLkRQGVMvRqkcfXadZbxDj34Y3eceyiMOxkFTHOOx2cGm8YUx0WL5-fPYRdawEdAOty-W5I0oFeK_h5OAa3Z3zgqZhOry1Btj1bQwz82DWEocFXBmxRN-7pgohlCFsoZXWSnji7y5EDQLOpZihaO8ruM7OMjonhSq3LjbgkP5WtjtSHZ50fpss7KtxrlF-yBx1sXhPV8paXmxaOoyCW4iHIzAPguHuP7ZQBpRbxOF5dWL1w6ODkIyBm8jZrQzLPr8Jx5wgzH4LajVHiEFB7tgvesuEIGHjiPyf3l1NzPl0vUt3C5DYBps3YpA46XBFuOD7abzTfttu8EEictiTngMVVV7SoWKuBI0eabemAaX56Ux6yYagUOu47dKjHol8iLOb57kYMKYVYjHmtj7rQgZD26WnUJ828OwEhAvcND-HZ8ZXzWo3ktsTWw_6o7kTYmyPfQDK1ODJZ6v6uPi16x6T77yhO-C3CiNGZuO0elrX50iLHd-c2tSbIKt7QYr3owqFj_xGSeLbCtfCTQbL83CpBpChhsKBQqbegc25cMH7VH6-3k0-CI7TmAArJKL1Itf-exupAkxP07xBmcbq_arnYcfVeb5-RpPq1Sh4nrFWYV_VvXdbU-kYWlmEZOEIMPraQuYVLsAeDMVJ48Qmnp5mc51660q6z8HQuWCu0CTu_0u7aDFUNytECiKeKr9xCdDqB3Nh3SpfFk7exkrDBpLgofkNkKaXwHzLjZc924uAVuNpzJXXoyaD1M-Ybxf_pCifJR-Fl5h0V1aiabK-JfXZXC0ZE1thso9RN6Bnf2DqcrOAa1BB46qdmlz2cgwWSbJ2KUl0WTDHX3XoGP4BVoQrGxf0TGOvMsfwTex8wy-K9u9KRU8rHIuqt1qblbUmswBoMqUjae6oX3wjh_9ufmANmNPDIsyhWGBGoUkR-sZD52EMe7r_9c9LHDSXa1yY2uX2hjKOSWJiXuT2-CgQtcg6iU-KyLDu_aXD69x2wwhpJ1W9MtBvgcHz1kdH9XnUSPBOEqOnCjrQNCy3cFEUiOi9zmpxdReJnbHtZBRen_KoKga3jKQ4AxYvBVpEoMkqf2QefHgysFtlYKXwHY53o6uG3fPiExumQbhNxlyInjf_QkwRggteAEa5WiycuUK3zJLvGPnsQ4GQqe7Ze-tNZjCzeIfqGIfm1pF1tMYko1Jn_IX13rt1YLUbDXbnbXEqUMeTADE1oxy8xr5O6g09AZkCchi--9jvwjs6t_WHlvI0WJGPkPyMWT0L4Hov5bfwkSIzZVmKRs9sDJKCCNm9wewKguaYIXbq-eIDMqdFaIRIgKGWbQUGDysEuGK4kSLJzqnrxhkzLVygWgFiswzS9Dul_pLXM05ixrEw4d3DXoj852eMlLT0m42hS3IAYiob4ZHOGc-8ch5RK3ITS7A96ND8Ikd3HGBqm8fxUgsH1juro9V1sMAy5VgY-dbTqM-SS-z1cLTTVvTzLPK4ExAhFwvSCmjzQo9kGM64fv6JL7m7zb-HrUM-SdenULwepF1bP7ggNJb8RkHHCc6TpGlSVD_9pkEUZo_tltbKGQObfJwW82R-ZK8gSJAnS5TWwdpEtOSsEWDdZ2u1ZteCjbcCGak4Ha88GZ6GBSbIHgdfqLEdw975gVZL3Ixn51dFKcm6zsRcV-ZA9vid1RedRPPc_Fg7EAd6lM_EbzgOYBkdKAQsK0ipj0vQ8VYhoxPkUceZiutARlI_Bym-Yh8hLEEE7Ca_0KWUJv9ULJYsFq2ODG1FYq_gfKxUhfBa7wNMrX2n_5Z0fs_9OG7NdWQrYd85i65loT0jzgLCK72nZffXi1cebrrNFPxFOkwIa5VIsPlHfJ7hUFzUunN7F4NiFH_6gO0G952QZU-Rt2e3oLHHsO4__6wmhgkoCn1GZDv6LqPieA00SoFcPMrctP_XEmhw41drUZi2UCuAiQLyio1ElCkZgXjowdHT4dKqZeVFzKGEX6gMgKxy-KIAGFPrHeQztGbHz4ZCsm0f-HBpfmyJAS4mPo3fxJ3O5W6oXFaC_47sdj7nlu-LI8htzNdl6KFmHVB-DV-4Ot5N1vhFHOUpvEuVRoqm3P0S5q8Vmuq5Ybm-QvlCb3WkVB-QZMd1IzzAL36peQ1zWseHN4DB3vi0JbV9UV48aR4VgC9vDlk1uF3LCCb0qgOQ-WvqwR_eeAFhRggw9O3IhQZJks_zFH5fUuW6nxTkoqtg8Tkiw1ntrVunkQQZ_JQ-Hu0SmwjT2VK9-23jLk_g6mpht7yuaDghdu1sGjJB8gCH-QOjoqoRffZsQYEiCd2ZI8HKIrFbA9P-0UXJcX1bXCpHeJYvHEVIE7dk4bVjxRA1fTSmjhMscdSyyWYXndimZBzGq-lvHSiuc1_1g-3_I8mGciW1-MXVJXlBTRNM_7TUAqrzMTGm1_s7RL1vgthUYihsO8oHcuOokObdEJWGGgBm0b68yHTbzBmk2OlDm-QUSW2z1lo28EppIpE4K2ZvaHQoRbOyLvXSSoUQm1KvlSJqhf_3yp3_ZN1zVPk12bMzlY_XNKVR9pDYfpAqaa7P_29OjBPph0LUCmlPa_YNvNlwRwVOzIHhOjzk0yhEhLyYpt8gdaSGOV9_wmL3nzpw_hiHSSPzUhwNI8_JvFI7yGuc-pVMVQcfq3Hgl_90l-E_92S61d2Bs_lfrQEc3pSEthBP1JDnCK8zrEZWsTlh0fHHOgtl2mezqnYK1K8zZzcuSl9MMyhBLnTPfTGsI8mF8WuP3LNNgFGAFMJ8KpL_3HvaDq3n12-O5IJyE2gAnRp2JCgIFKjvTLkRNr6nb9qFnLr4y-xBQ9xjtAMGoZOAnzd7LwW2FJh4z_uNB4DflWWFkrzoJg_UzXENt_cfD7WdQ8toKCHQUY5YvtfZ1WwHhMzWqWfnUZqQzlEL9rO1e4TISKUOvlIDYv0R6XI410gNk-megzhVpwPHw8EfbUcFElxKWWu0Ty4RykZViiZWRtgD0Kh_Cp8ReW-UkViGgQd5rT9e5pOcC3RjbtBkZMyd2U8jx9R6-SWn7WxJykEX6p2EdjlErZ7xF-NJFUG6m6QZ2zdKB-lSqDYRub0Xa8rlkPVzLYRejruYZ4q-DEwcV8kvY1eIyP9GXAiJxXE48m0NtEkBKFwHntqNs0sE2f1zHLPhFMumS6OIRjXYWrCdusxmBW1X4--XnWedM5sMPTKOvM3RoC4RuQUz0neswm69IX2xQjLRIyzgk1QLVFv9GArIjaVNMA00s6vwT_GJC7t60p8J74-LvsQDR1Grx_SXLAC-3F3N5M7IzkntwjA4cAOHkBUza3vpVvqCclj-gyz68xkqMIQ4egcaEmDeUUY7Phli6bEZlTREw7JCppat2PmK5noGafCFy1Fanzt4WGeRasQpdaVypcOXOtsTzY71txnhOmD3qvzk4GX4XHm0ebLYbqBg4Rr9x9zBy4PufpsCPN2Hh90ZPB4TNO0soTGqrT7Yky_8kOTBLCAbVm8sOhCE6wcoGE27a8-chbGu3uqVLQEKmnebxbcqPYrV6C7aoVw_4BcFBErJnvOtTPMuOymiS_SH1vxO0EG6HsQtvi0Fbw2YYP1td_wULk_pGvmKcMn_J7OIosK38-oBWlMvMoFZa4UZeLt1BaOFxMcX10saNv0148qI3Jc4ZgxWTB1HwfDXZoB1778ka_UoHxq76tjoB6dkSBd-tlfTO0KMM4R4TVki2f9Tg4mARmyxxjgLMVS2JZtrpwdDbE_Tn40glUs4_olKVt6pEvcAW7GWT667COZwT-d1l8Lvb_CjM62gs6GgaSoO4VLAynH36r7hHcKqy2yM0c_L_KXh_csfHScefTP262Yjt7dGouwigTcICtsaWF2wr5rprKGHbkwYKaTUgEl1t8MWgntAirUSZZEyYiOUZh0oWQ6ysKK45a9av9bBV87qLs5QDJHZBit_i46z1FrXRa_ENmdZs9AQOGRRdtgLk3Iow5l1FtPrf8npVDEIeDaTtM_kngArls9Em_sNfpUv6wC5vmUd11tAfitrfWkc2uYi-EvtDziSnOJ93x7VNfLcILMRNhOTHrROQqKMnx0btuXK38VO6mPL7jwhut51-VOT_u59htjoBcms-QImlMDt1mP0ISdIKfFpywboH9mBA-HCCS_dcjaNOW1L0qyQyTpxfpJihyGYDeL8dj7m64K7CWPS0qho_IUGUup__lrSBrTTjO9IP1VM8Idrgw-sZPtSY9UyKSap_krA_l2Jx-1FIPSjzHut9urbfO9ai6RLckfILcOcmWBJ_vsUr9a8Qg-UT0UjurIUGxMas44wq3SG83uV0i4k21tz9QYTevEHOObCIJo4y2XAwmDAcLWBZuVq1RIqpXv-x-4tzY1rpIKR-0tiZg6fLIPVB14R2Yl9zYtro8BcJDaBXhnVcTEUVhAcy2rls7F1ntrbxiICXnsPDRedEl0YdKYp9JlxBagwNC7mbX9tknjXZ8D_j4JZNTiAyS04pLdSzLpcSvqIsrWd2wdQltg_t6AgNg7I7690QaZnIk-TmuKypxSgW6Wd34oEMgeJLBch3zDd-UluVRZHTQcVvwX3W3JR27CuElWpbQuIZ7sl3OYz8OqL7NSkc5hw8HnEvdJVq3MyERCkf3hZ_1INYv0kCicE6gWHjOBmv5KdCNkwQvGqHc6GlYfU1-BpTjqJAq_wW8urnzTcZgfgMf8-bNYG0zkhIPFBcPgeuXxenYGSGbvMwVcxLvF4N2bSKZvX_0v9wJk1gSpM0-k02ild6sKIrSL2uTWGsAEnS9HXlrQqJjm48LINTS3WbdkDtlo0JwjBx5PwWfFAcTvQoIcYCtb1k3DOdqnjjSykceAV7mlmpMI1yYdHcR6kbuTcOkD1-3Ei_UReGssfY64RIX9FQYhqUoxdEepk6LrxDh8nBjb1cbHwgXoC3s0mjAM4zfmnuBJT5rlgdeq2vPUsOTmmbyYHqZDhWdmqrF0ncnWxE5-ALTnM_D3PDyXbXebypck2DUG_oq8O7FCkbCLzmBVscPdr1oepyFGA9RYNCtcpz6McTljtAMQsBzeMwfJq5rV-53YsBmdjAmPYhfOqdd98Huhva9qrir97eGbRsNK5I9vOdprrcQXXotOSVhskOpPFFL0KbZvl4KHwrHsRpEK98Fvxb7WVXvUdywf7mPREURxyoY-KtirRsdwm_A7ygOSjolshehP_L1a7cujNcLQSbt5iqJV6iuHWMurkgu1p2-gu5dacuzQaBOj0TKAkNwygb9XbhFx5tA5_xPlhatacFjVFAJMhZy1Lh1ZVMb5vEcVvJwrUP4FUWZ2418K7dCuuyB3J-VfSiIpB13F0xKkN475LBb0n-cmxqwzg5wo4uJ4v1wYX4tx-iNOO5qnfU8Ps6dZIu0SzXdP1kTfA8q--xrME_WQr0Q-Qm21YAPzc34eny4RmdsbKRMdkfibNw3naU4edvR26gZR9IKYDxzNpDe6YSngXZXXcpsO1W99vgVXqAnHKyP2EpmCvUMLQK47zWo_NAd3g2JWqltl8u_rOkyEgJMXUK_QtbOem7tEf_OTvRjnG4gjQUu-TU5b5edrucfLOn3EUASwRQMdVRzqkKa8zY5U66oXTy5twGqi3kiqqDPw3nhMQO_Yqcapm5dv1IIB-fDO9cuM6WLTOTuC2LxZcEZpkz2VDZkmnGHUK7hl0CB6wo1DNtiRcALr4o73ieebLh4wgVreUvLEVqZQBJHrcB7UgMSgnDOskIeA3MamdmM3ibR92_qBOOUu2Y6ESn7ESAyT5zVUaC41Qeb4VH8U29PrwrhmGajwe2Cpke7ZWuI8wM6tCVr7r1J7hbeq_yeJ5FOtx0oz_4nDnFltm-rKVhbyIIdzuwLGgqgqjoyemrZES4D5vgLowSQT6cXMFRAuJK09zo_dvp1lYpXpqdGHlqtagcwwTcYFXJ5-Kr6z9ALHgo5CnZJwZQgJWBPXGnFTn11UVFdAL-DqBZL6BDeDxo8c2PL9psX-7krGLkbbwCDAQDQNP-KgKgWy2Ts-aDsL-icDxBH_MqAdnMvnjUnTa9b1X8bKzBrTlYcKSzWfD14I5A-4mZjWJZ3_ZyxGNZ7ElewT9x4I3VXoE8Vi9dHiUC1DgIBdcDXap8KcnyC2986nPaP3FAXEf3F4Md5BqhdmHWz_z1wo5AJD_cOjWZSAxLvWdMzVWue-5MBUofBTAvlaSfLd1dQIdISVu_nFCKbqUyUQu2eUgtqBMXNNzkxulXvajFHBvk6EudfQmPKggnxoUHbHfFUbPl3OHRX-1d63xbQcL8TleU12AV-Apd_bwACzRmboJoJBNoA7UZROdgzt1PSsTf-x56c7875Qdx2rYvxmplqhp8eI3XZ-oWqgyYnZP4YatectX0lNCOru_fP5aEFVFAPaTzD0OhhJF1s3E-cWdCj60rjnwSQw4FQl8nCqt8qAVan7-iC0EVnUZn8xvwyS5OgTiAtbXBgrtI2okGyc4ZEPB5z3L3skSf9pdU4i7K99h8cXMXBhEEmclH9YWTGMwUpCz8K1v3u4MGHWRQxtO3dvqeEKOps_YW_nBuoblGWCzEBpoCA-vxz4QlpTr65fCp7l4whhpJsROEL9q33AU-zqIqbLFKtyygO4rfmzaqzycLFHkokfCyxx3kfrw8_4qehKwJvj3eY_QR4SlRj21ujilkIdOmVWXRHDnuxnWQMNkYqdW478ZkkD5m8QaMFFa2t-PQy60jXgI0zk8_GKU8Kg2OBmq4wqO9MJDnpzMR6P5VoxYtwHqbO9rVqcRpdswl_g3u-vKVy_JbYth7bQwvyMeieMnwYzAtMq0XNMB2Yo4Ffclw8AzTa-pKyJ0SKlry-PE-1CQVHSIGx6QY_FixKJlQ3GoLEt30VzQGjEUTnIZMcdcSHebRgcKuDeMuPPgXzW2ybV-dVs7KsNQN0v20VifvwFI0y8t9uxAV6rwO3Wug-6DReOrHFIQ77_nSMd0K7FhqdyWSUzbMZN2GZ4IMXGKsmrHIVNa-AqAYbLrJ67c4Zj_D1GxSSqk9EnTWBFEE3k9QgqDjwVmBcqzc6OcTa9Gmkd3A32uAJjMy4DYzzdJbSLZJVndWGytu4kTqn1G64YTHq9-zTMJhoC-SLsxgqfJfLkxBz5jVvJMGxog-EBUOTumH4U9QYppfwqMiirlVuKEWyKfEHwx0c9AsbAGw4E8B7QM3m_KukKI9ARCBs8evrRJ9G3qfBJS7GHauPURFAM44Z-LBl_J2wfg_BAAdISsYt_APw8nfTwSF_jvG8tGI5fqtXTqd4Dv-XX8P7TuYRpMETTcnZVMKIE0QS9WwkNI5oRhseeV9TpgWiZwK2NGh2h8sLJtEiTjoILJ5HTAJ4bOM0lAXVwimxetBJsXYlF_dXVwFOm0oe2jdTSzUIqe1_3zvnY4fuxXOL6xOo-YT8MAGUwLZUstiS--Zv5ulFPE0ndyDg1f7OsTnKWwkZG-mmMkhgoETffexXq0Edu8pBwJ1pOsn4CRx361-nal6-HTcKk0f34wd0I9JG__mBq09XvzPSJ_aF0JMhqBVGQUPfAh-7Lq0bK0Wt55sOGW0LIfcgcSqiQKcyxg_Wmx47Za_zxo2QSr0La__3HXwrRFzfCWiNnr4NDBXT2vfhiffC5hnwLv2wE4c30TGP_csH_wEWXQSqQ_13fMDQTs2TQXmzxAPt2gcPf_bi4XWTf40ZPOLA9BKWEXkEY0peoPF-VjZinEjsRmlwNesieIVm06C27Kt2G46UZ7b88tky0FAo-AEdojgd6Z5iRZdSUIeJZ13aWNGny3rxuOSeLpumiVx9-rQ8fIwOEiH6MmXHM6dfiU46Hsk0RuTGHjiEpPvAqLmT7LwevJtMvdWL7vrrLavF8E8EdrB-KL-4di366sPpyAT6wgXOjuyI8uxPQj746VTfCsUiukPN93Cso57XSdAQs3AiOn8qAkiDoCMfaMWMgExoxVfy53Nug2Cf_Ug271Aq_XerDvqMTIG4YV8IDb_v9dX08wQwQwr-PYf0PEubnSPss_Kw1Beyp504u2584akaR111Isbg35R_kbL7RCm3qOiRUoSuScbt1DsDpxdBO0oJ5UWxTd63aD9vMSQivSX94vlg5GJTIeWOUDQPxFvaHpg3NBdlHWnVkZLKBt6Ks-6suqtWFJ84GG5WpCul5A54WXf3i9tx-hT3OLpNXR6xkv-lDfsm9d8jC2E8LzBbNk-wygNSyokNIqVtkevRmszjougiXsRfYOnMPNHAFQspIE4av6hb9oI3RVqUO5qRW4UI3WUSdIn6KCotL3UBiwfan-teYrhYL8XWbQvBBNbR0K6YRQhwiqUEzGAZ70OtCQo-x1rfPtQrpVY6Pz-DN-C0xOZB1urttVTV6H9uiGgLjmUdEdYBaHcCyqp7BMLiTX1Z5FaSj_-JBWQzd_DZp-GL9pHv_hSuede6CskOVzqm-hSFNe_iJyeQT2t_7sWLfCHNopdUbeS2Yv4_R8x0Ki66TWqmz_-nZoN-6HX9W59zrMLf7q0a0ctj_f7BLLdneZ1Kv1pfOlra8udoSKP9pY87dBb1LaUfhNiRIoQQXEIiikwYFwgq2mZObH0JxPwmNUTDoWruhS6GBrmV6obq0jKemz8hW8mWt_kB7BqA8zLlKl_hYSkj_qbE2tP3nBFbvvEoAXekbk-Q9EFNMtEylcfO8c8tkZpEtKSmEqXGWu-bXRbFhkm1k9JEUoIy8lxwe3pn8tiPKx9X0f3FEODcZviKQv-WG2TID0z9jh3VmF1woSps_WSATB5smQgp6fhU_mjiTCF03XCmzLbGBt5cVvM37qB0H3B6BIZ4hPMxbZVG09_By6qF5UAIbNZq2oAlx8nLHvwmU44WepBs2dDvl0ItfyRsGYF9CrRvz5dNamdIWz2uHSbr64IeGsBJRzl-NIAljyBELpTP-sr_FtL-Y74QxtBSFbEn-zfIEC_fM_Vtz8YtGrX8tN_7XVzyvWYb7dmRcwmX2pKIpDKeVDgonbgpuZ5HuyRl_IARAxzTbBAY40Ek2m5m1VOxqXdPTBU493ADbXFXLDLc06rqUV9-HsHALxayy2jbAGFIZ2fwxNxVWASZ0gQXIplI12QD_41UsL7gPVbXM8zZ0vHkUugYSluZJvtj6oE9hjDscPbZLDPljbnR-BIOmx4yNpknXMF2buHwwFzG18xAZwNX19fM9uNVSf_aHRp9-GKhkdigj3uuRUReAK68IeWn6kGT8zBAMtWcVwtC7c9AT3v07zzZLwXOVfZsPdMSAz8qiGdspDe84lYIWhGamgtGOiJUEcMHrNyxgOJvVO6cEGRRe3dqqxWWf_FfYWSd9FdhvYz_4Jrh-Mg2PH3HSWotpWVvKQyf1G9WtFcoevAklrgWgO0WqbnggvWdUypIn8W1f8lZOK97X1nmmN62FO-8zZkj1CR6UD5LKg-QbsZEhDDrBOSaea6ayi-EuYPBRKK_ZkLFa9Gf_Ikp4NK_OjO1CNDyeVAo8dAy0X0wHzCi1Vr1kWpna0yAMS7PwswJ0yZYNUlfELPl6DNJO-3JC5_hbIcrBTwTY-l3vYf-7hCop7zfQkhf6WNFe3akdK1qjMMhfjq8_p57NrXy0RzKJMwEjsZ-9_e2QO__RJxqROCv-SX2Kh9VIKU1dubw7amZRZvhVg-om_qPf1TA30Jx8xFUC63In6k9SZnfxzyVMHlf6aBwH61NEjOKUzN0SsTp5EWYHKb1T92KXURkfW8fxyGksNc2LoIdr2C02ATAuQgoAkJvnDxcKy2DsMONWP1TNu-cKGI_7LLY4P1nySylFu7U1-7EWxv2d5JqGGYytfmpkml7YoEdbTlS7BJawspHRnWJRtx08q7jmJGmxXGHH1oE2YPVwjEJ3Tos5IRUJs2TGVBn497sYOW0BSq0B3dGq0h7mZLPaX-6tePu3eVCtZaB3GOXK7IuOqpgm6l1Yt6zWKAysQ_33DUxHYLifV3U8VPJgVUw6Oi2GCAumsD9G6qddMI-Xq-ZxqQXwtzJM4DTSeGhC8Sl1V3ghuJL1CCWi9qKi3qJLY776rKTwUqCqCRYK-OIe5lWHXMCyp75ln37dUdnB81nYLE3bHSdI55YBb378Safns1aw7qhvazQ41qnfZp6WidqJSFIlpHT-mfs7Oj-nhyPtQ11Nn1of-0YWPVZwbuC-TB03VKp3Q5X0m1FrnxLNulnRCuDLfwem0uqzUHGWHCQ19MW6skQaojhAHpdDRlpEneh_Gmztg470HD3bfwDyX_V-DO-ESX8jSZLO87f7fVPzdsDjANiZyqBdzEVXKsrl1gCMN64YQoq0QrZHNiZIfTsLTdonKHuvtFRqJFhqHYbum6fReQheV1MOXu2Zqa8lFx9BbfsXrrw3T751RwpzH2kSibVHkz3dcYmEL0kUqAOf64KcDj5Kuq3IdTGaBJa8tyNaeUpJpMY-mh099fZ-etcnymve-Zn7wI7hGp6yG2QRtaqkigojE_4C3_Ct8SKwo7wJ29uiwbBaiaRdbdf4eS3PEVu0GEjMR974h9EnsL_sB6sn5VNzbthDvzMhRN5aZo54gAbgSJ_eLEMcsFmeh0VYvwHJUJHJ21cRiF0TtmYAEHCgp7iWIB2T-KNtw6M968htKewPtdrxV1YhVIWcxZ_2OCNoY8wXD5y6hdg_k0Hwx5AodcatdpSbjccP6VJyrHlSpbU_yNqWqZPSQi0yjPY_n4DYSlfsea0u6xtc_LUSHi04DD5LWDwb--cFTW7-1s4k_pv_2AlzUHHtALL2UJAbSlfFxzn78CeIB3BoKjfJmGbS9E1YbfFPgxTWgS6qFaER8UoqKtzx-vjm8SjqcYzGRe_KbINj6MVhNp4POVhvMr878hnG3TKjQJMTftpnTeylR7qNOIsOKpaotXPLe94tPPV5SmqN0jZojOzpNYuNVXDCeR33uaviwc_kQWiRk7P_hOozWF8qCduA-9N-aPYl1IuZ15fh33ZPp2JkaO8QeTB7jxLOMi3I6skDg809_IE4nlRSx_LDx0VA_7kn9SPOPV3PoqJMdJO0CHEQZQCY86Tv-QDEAQgdhk1T4bqV5B1gwIvIRo_HNV3XHQQazAwMmskv3tBi_ZsallN-9bDG6uK3abz1t-jubSK7a6Y-XU382YXW-a7nJTzzeKLEPb9SZY0dZy-1fPQwDoXonryEN6vodGNu13bA8v6tU3NpXSTCu-mAPdvLJA8eJezU-iIBbUfCKFn-z_IvqTqGdR7AmtFJv7mhw7yOtiBF83fcdfffs6O4ZE3Sz2KwWzfHIYPvR6oJ9KFj2GTuKwPl3dWeCx_TlpNXSXuE_7wrXf3FBK4HFVnqioODzT1attN5AwdAJiyUoLcYmNfiGBHPNU7rGEmM4xgKdaxCUlWpGgBovhWzzX1VsDyBptCi7aScYAK0w3MVBX4slN-x-l31iR8T3ybFnelclr_H4NN9Shg2F7Jxg1SjgD5VrejfX8l9g3ehzRuUBgA7JXMSLoIGzbIby5f5hrUqmF8Fnbw4MXYg1p9Nw8pm3-8QsSQ-11kdibQVbdyL2IIAjm6CPVcj-tD6jbsfuLTDY425Tu5BsYPwGLN0smhlU9oRqNU14I8Xwy6I12gl5bSSEDB6N9VPY_ZGySIv0ZyRtvmXm--Uy-EKt5lNZGsf2l_O6NYuLq19IDmnl2k-FoGh91NvGUq3FJtuNsdjjFWvpCx7bgauj9SfPqXfR_Orw5ioZhZf-3VsoybOTPiohvjI04nrpvVaoonNoSJ0-Qt7hSr4KgmG5aIzFXrbhjkgl0INb2sOdYwriBAl2g0kJhnHyse8GRxqYofzfBnv9y0JVlofxcuTDEl91ZdWP7Uf4QSsUBqiDPWYb5oFDrRhvume__0aNNqtxcg32WngoEikOUudsQKw8hEDKEAtNshFxXyycUTvtsFM9qFgFKMGxfjOEz0KQJVp-NbgsH8GWNGRuD8OSZXdy2rjgxCqu64B8-7eL4UqMTgdB_OmUhUXPH9kGCH4z8GAsDFQw0NGHKx1N2KThvmEgAVimGrjUlVlAwgw35OIJX02s3fhu-9HAUEsFwkxBpgI1cWfNdTisEsxWminV8RDdd3EcdAeqDbOYQH6DC4NgW1QIDt96E7TfxNFbCF17r4ycHzfJrSSnZC6qWRAkAT8hWo1MaQBuYNlaBZ8K6XiObQ68-O3F5WMZ46ZrF6zJzNl39hiorVb5u-a8dVSVIn6893eUFSSAzlbkfvdxYbx1PFLbPtsuN6kcni7trB3nh49uTeX8BQiXpzHwbgu9HXuSULSkcG5HLHoyaXbMRekEkwXkuyXeCe25Y9y7LVxIUw1yNF7PCCwrWawVoRzKWdWCRFeygrfotdqR5n4yzXoG99-zxOhNaoh9DrXxF5apxb1EgWFMR8yW4AqVs9V4ocQ38RWjQC6y06bEURNb1pFkXPJwsiiMJu5gGn9ta2cfxStnVNx89QNMn8ghOAjSsp5L98phHDMbvaeM8bYOe6ITWZp77tA5l-yxXQ7yYCjKYwjWNpuo9s_lRdzqkFVuTUaRRxwyEQxSo3yqKd1U3hssBLy_OiXq_uavjcHqEYRIk73cWXlubkoSlB8yShc_MztqLgT61cbXiV1pfwv9qHSelNdnoyuHY--1hn2hf2PRASj60Ylwwcq1ewaR3mgxTZ6T3-O-E2zhYVDWMp0m-2mVPqSfBJwFNgJW8GfrvbinO0lVSmf00-1_vIO18hIHZGLpWdPm5FJRl3k7bSE31KPiTswO2jjOJDxQ4ir-cY1sscVLDTXQ2T5m8A0SeA423RRnqwHbqmIf03QbrtVPx9ElNyEqsaJXUaYBVR8pzgQMGdxgK5VOwScCSbdA1WVlyyRV488hP4h-eiuP4-jWBQt3MvizBq4WrugxkOwuSlfAvDoVUaGyuG4_tnWTohmhXoDn5CvrkKS8DPEpPxiKOlZwgVNmn4sHTz56Hi-3djAOVqzIU7sVYicGTmVP0faaK1qMJ33yV0SwdnXFa9zNRkbJ299wB6ruoA4MTCiNDRnf3AmQd_XBrmCpyxrbwON7MwXcaNlQ0serpGb1icdtBn_L8mxB_bY33CEFQbQShrcZfjOjKpEcas7k3kDyyTZL9CdzTcGWj1nkmJIGauYQ4IIJqIUz_AKGXiKo0EJMfoUs0GJTZERGZXVHND_qRPitL1SELKRRtqy7VAdsqmFn9RokNbxzNqW7_rgnGkT0hsvPEKU14loKa5_h3v01m2xdMMnVqqRgtInfE7ENXONks5lZLssfOB9b0AIZ6VUcLNDlnmUjhJu8_Au9A_TA-8mWuo6y80-HKq85p1v1fkeN8O9XzmZntIFPUEYnhSyGFJmeD4e1tjOZNW1vyyJk7CTy-PbRYVpbqQ9BfC0KaWzy8vtzXT-P0d3wKWf7H0iB_X7EXAN4w9zlv5PJJqVMn67mqWAIEp9DMbTwj5yv_eJ_646y1xG1VCmFyJzKaD0wH0ckHFG-y7QyFGMwIJCdnxOUe9rSbdcnTo_lnckTrsb26XXIhU7OvYyqLyhn-QEBfIEnfFy-jsXvzYNYhkdbypRtzBgSfiuA5m5YhM9Uc5ykXq_AbFbtN73PTIIN4cv9umjug5PYRvKylfcPI0vnrbUwvHU3nZHT3zOyHIUz6tZ7Z0gepdc4EsXprGM1nht_OND4SvLsj3O27yRbGxb_R9eE_w5bq1_xlZgEvSJF5NSJ8cqawkou-9g6XQrQET6Gj9d0gjOVZV6ymeSwDh8Tay66nROjs0o-rHFgjxoocJ9Bgrenf4VNt28yiRgK4npKwZFbpvUwmESDNnVZ8dQfAvXtsBOb6Q7wbStqXy1WAIGr6Zf-yR8mjqrt7Yta6fpknTdeRsVAvm1zbMz9bjrP9M3Nes26knh78lxZOFOk7VPHvmdRXtbEv_MQxtPQ6zD8hH0xh5ydHxSfYxKudy49fMmrtNRT1WweEqsvktaC6GpFxyG1walm6nisj3Jcz-AAIM7dQvEmgi6IM3ISSVfdnYKPFbtaaQAlv_3O2K0O2fVQZq03jTLwoGw1c2-n1MpRbvn-PiCnhYyugb6xYVhWgtukuRtkeJlcESVildYLSoaO3u0EoHFmXPkJxuslPLuYabun4zXvaHYo1z_2XxCKFeBTRlQD3H9m-tFz8jbN2SUI19mDGFQ4OgpBT6f9nQhfE550Cu6XmCpfb2LJ9CQFytXqsyvebdFiGUJQleqlYRn6fQuDfCimshM4oTuPaypyZNNGDzbiYUNe6nzM0Q_eabxTb_opaKciMGV_EfXRvFJuDtOT7w00sT9ae-x0pyL926PPOVgzzXXJb24-2XTUqqJBClEcb6bK0lRvt5JAuNE2dh_Dh1vQT9_Ien8SbJk4fvrMUe-GWfBRLtxTzlAhwdiifyeFIBmXU3eDfxiTbfw8YqI90T_ydS9JrZnOoTJFxClUMfokeDwtxg9TFr6bOLbDfx5ZEdUSg2NkllcuWkeC-8LLOTeAncvAdmejSHk18HsRIBDKkB4gSaIvy_NKw78adi1K7SQGsvgwh0j3roJve0X0TJuaB1ZTNL-SEsu7aStE3ofg6sZ9wLzSEsdO--8Wj-On4-ugO1q3cuZK_fqZcAlHw7roAFP0At99Wx6C0nvxnMW_-ljmaoT0F5QLwNuFk6hBGbtHxynthbEh_Y_i_Yy-ynZV6a2FKNWhvCN78jefvyqmWoQbrXxyDEAM7XAtA6ria_db0ioJwbozJMKdYNH6YQQbCF0sxEW59bT47ZHhFPUz_6kk0aOkhLcrGu2ENCTTi-xikzANH3N8oZMqCWiGiw07sRksWFjvAuFNIwnZu-kp2liUDkz6BDDUxMcq9W9sMSzrSnoxYmSPcjftmwK2NwJ46-dk0aOkcC4lFawVuGqmH1gmeJe4SHTRcc20FM-m_5y-dykeClWKUGtj7XOIy0IGJOBBzJFJeWLc908lYtcJWhDDfv-m-9ZX-NX_NuEz0nJqFz9xTgFwwKJdt_MciyKjLqygfUMaDsvSAItHKl2I-jOicjdSs_pjjnzup_Y8QW4AMUW79ONXApRGep1x-83-e2ANMaHcvB2Gp90CfoMv32iPB3UDriCmqUEoS1qqsPTaOI-P52-iLmbEb4ny4ewGZABJKJolQ0C0hjPFt-UYPJUDzfp2v7zv5P7cCkYSmQVVILSQK7CF98GszFQCqpy3-ihXUAwrHqB6uWYp9unGhkF-uKb36BVSiU0J1OlTT7ZuUePBFon4COmDIgDyINCBSABIUP513MAjWDQlWMN8sD_2RSmQPnaE-UOzZ2ySqQCRYgdOwtFr1-otyqnEnLssFqkZhvWLZi9Zm8PuDad7KclCeNmy9rek5pHj6qsypRQiwtwI-xfiILNtHtpCePRLc7nG1WFjwvPm-L3TWKijIEgZTxeXgqJlyUOMPSQaYeqJIXIg3F57IH4ydcKAviy0XKqOYSPGYfU-bQVA3xyLtPZfH5o7wY0zqq0VO8af00fv5ps1yPMXRDC8j9I8NxH6rMo5LlFJZN5m4H_5xJgCTY5n9GzDfpJ7c_ZBIn--6ZR4Z1LS0nv-ienQCKMdbUWsdrp7ZC02cMGjn6RX6RZTW01dk8ghGJhXThMAyZc49qENCGRqDlae02lcyvcYEIfSr9pascms0x5kpY06rYJWhj6Yvg9eHkS4Gz5iP_B0S5vkou0tYTlIamU2ShnoquGjhBzPov2UkuOSwswRo0KxeiqM5uiMr-bOBnXI0FWmvf1ZTb02a2VWUVGZUVoS3UySuZZl9-DQJly05dFYCRgp0rvyWqZXQREOtM5TZu-k6UmRwtVACXaalCXJJVFt7Vq-sf9tchjkfegTNoZQt4MbkBI58kNHXfH4QFVQMnhDBYLTGl6X29zoomA2wh2rOi7XGebZa758UMIeaAZSzdRPn9vWkvce6kG8mJX-9RS2P6ep-6A-BoJTazSMvzgBOg_ulEcqaL3XNR6v74ydk-jAmos5lAP4JE0GzKfqOKjW-5g19x4DE5Al7dPXv_LDsg_VU8Hs7uAuAw9cIcN8iY3UFmFVODupHCd02hSqClIS587LXpsrymmjGXkz9xQFkyxSWUzx1zNRiCsLX8GSiTpWfa5LlH-ylKk1tb_5QcQwwY7Ne3mVXB-jd2NgtBAkJLbUHYOtcC1KAe8a7ay2mKH_MQr3n0mj3UuYAykfZ84oUkKqJMoafRpz9b0RRdsotRVSDXO8n39eUWcD8qbnaToIngmP9cwH8_3q4-wvIi6uQaEwzbMU3G8_AoFnEzMcrFJSNLvP7Oz-dkOLz1dxZ4xTwFK3bRIlR8X5d1tb0evPFCXsH7BmPoDrBbIGs8G-p7F58nlcIPTUzKMr98D6hDUPPWVcSzHzjslwfwq8p5JNeG9Pl0dRAuUbclfSN6SetmqZw8AUKAXnDxULp44c-FRHwYxSPOdn90UW9q3ZUNvtKWB4tLp4NdZLPXrQiivjhLQOlsWwqIqpJAj3jKNe7RqQWz7uUSYKPan6dQHHEH75_pS5sTfZafxKtOigA8t3Zg6mfcL6fudYDZ5qyA5CZkbN7xy2bxiLLJU4L_33PyrY47t3q8BO6DcWQI-f1wphafu-Ltx-6el16QgVyRW-kZlwq52WMUCwwNM1cJV6cvS_hPaDvguzzaMBhl3l8naFGCM3oWdZurEtnSZpwjjbCiLO-3CtEuKkw6xz5zzraL9PrMgPPhQCRcfu6CYKXrlApTCwdpNxdzCJBEYMb3EpuyoocGaRPyp51miXN0_KsAGrX1ezf7JoolOuc_rnN-1PrDnHa8ZSmxJhJvTnmS8G810H109U3suz9q335P1aOU-d5gj0Hd0a4MXkF7t-t6K3QtlMvbu6ysZV7YSRsXAM8XuLZ0ZEkcA5Tdg3dV5__yqQljvJQct7hmbgukBYh2PzoNJ1dA285mwRG9aloMPKLVuZjg-Jvr-PyijtdZE-mGfpXE2rRvW_emWsWyA3ZxpjEhRywsaQII-P6L8-NAAKOrYSPBZ1_EPIoMQqRdHRYS0tOsEsDDNar1wbcNvYXk6HDF5NhZafGXuCnoog6JXVXeu4zVYqZioILJeZKzNd7HW1gIK7GIyd4fkl0FAJVpjyoQpXZ__hbJ74YRoybIKoTV6wBFqnHydVPc6GTX3lDk1cMdlzvkTd0fqFiBKtl6Eys9G3G3TWORcpwjF6Xg9OdLCnuZQ3EvqZRfr88ZQHdY6Slvx86v53e_mDeKD48qGkwhJFTVsW4XKXI7_XAIVpJse4XaZCg--4dLEtJrj_HYyoBnI3kU5EmLmo8jUrz3JkbGJpcK8LX4SpPp5A_kp4ZFUmAiweQ7HiWENgFFQQu-UPG3oNgdHtqOk1rhoX6iS-2pQonMeTpVu-da9Q6IcxcyKgbaOEmusDHzjPz6a9THctoIuX58_i2ybp8RVkq5-8XayEXldDDKF4X_L9WwfTyJuE9iV1vBH3mfrL7z4cK21FsWSEdqVoJNFR0BsXbY8BBb3yKGogCR8yiXHf1Ii_ssXCgvNG1rdabG--tPHt5SIYEA4l0oxdKbFour9gi6FWpKNq-gzFHEnmMHtGjQnU4g5xJJZ-hIu_xoMx_Rrnte-K_R9aBdvMqbhNgzk6xe5KzTYnCfr_Q5WknyN8y7j4DrXdCwKQCVlOqwhUbsZ4OMNfS6FIxAJJJnbsjgBwbTUhmqfoZl8lLF7H-UxT5z_tfmtlYHKJrOf5Shb-dtdShJyvOGAFZQdk3Azy4LsmWAfBH-aaybzOrwRVfCWjua7ZCZ37j58wGck7rxnsEFo8uIIqzAltQHYeXq8eAuRVu6Rf4RE968wLGZi3LlS37frcmkdQgPTk6P0DMSHNbdFy74Y8xclHNv7BDsH3rfTAssJAINV3HWQp69t8GmmtbQT5fdi-CWffcrefPTZfE-iT6PU_buhVEnN-0XLOY-z81sOMtrpWtRrLQWM9PTxxBlQvTpJ4ofIEB4yfqxWymRkQ0AisAVZ2mV2yEspKNzSFJc4cU3zRz2mfialY134ctoliylz7iJw_d5JMJeg9GLUGyc5htvk2Tfa5mz9kLw1h5DvX1HRDdDTQFanpJu6CJSDf7DnwTGfKcsTpB5Nk1BlQ43LUMiMC8hTqYnsKEmua4tgp1a4J4vbEAjlmYyu-7eiDtVI2G6uzivT3E69b8qt0J3N5wpXNEc34AWVkwvdgf9mWOlGupy-Wzs6o-U3qWOh-SNH1baw72PBoNCvlA9tlDCPoznQJGfqQVS7UpPHsP0L6uj1dUU0_aWaHpkoz8N9_d2hLizXJJETPlsIaL5In5WMfSvBQPx46TAAWYpRN5rR8HKYfY8luN8MM8tJjjxFFJyvVJ7v5scf0zBRWHyhd7xNYsyuoyam_-s3priRhwWXRx353d4NX3WlUN5G9VLWi0Yv6o60ynk06MyOh8ll3u8kM8FKP5tk1LKPFMhvNdYx-9mQ3Ix3A9MTb3M8qACqq_wP8D1AjFBE2IIUNn4e6Y5mocIAbO3dCQTk-4rGs5kGVnexXOujUdm3Q_OkVWPdS2Ax92P18P39bneIcz7JEJ2KHvsVm6Sa0YsObTpyomrzcxDLU5MrwId8Kk-E6CUZxktCADtlvUFY_G3Pdo3Y-3oTMmPBaOAJ8Hqn7KKV41QDGjWhb57XNPv_tLHv9NwAcz1snByeOBynswYWgeT-Ves7YA7QfDrAYCJNn2P5_HN0X2JkRvx7ztlUmGx-RTKWAs_TTf077R35s__teGSqssy_MDGhMwaxA6tTlJ5l69LuvngDGk-Vmuqo2GHadz7z0mfD9xHTR5ly_UV_iEM7JyVHBmtx0DtE0VndEQnolHCcgc2ede39zRwSpV_xQxJtQ9gDfQptR_mggz7m02Ijqi0bYN-kR25bNLLK9Omx2ZeDBQx-JO622KkPl75YuKe9wPHLkXTYUwGQkuHVLwuRNQ45z9LqSMOC60XseSYxEmrq6TFqz6CbJk2HdLU5oB68869NaKUgtuNPEfSLEk5HczAbzxZXBDo2H_9z4A36mL-mou8U-_KG-dC8z_A5n17po7mZJX1qv2zNsAHGRxqNeWM3dBaH-mrLMZdOhIhnf7TLlzjF02foMxr5ZBlCt4_zPavs_IxZDPLwjtAMU7NS9dG4XBLuBkTKGnwGVPB6vnaDIQPn5RsJh3Ep7ZQk7SJP5yloLMmM18C8nzkAK2iqhCJl7tQrKFVOC-8cnum-3LlHb8M8hm_pslcfmmKd7BkBRz0uRGV0cALxtmOaV7wPSnHZRdQRFdJmwWnRrhS2NuH42WpnDjA648dwCrZGxzOOK2B6EdjktPiHXMttSPLLR2aAUlRrKNOk4cNDucDbwRlWn4tezxKhjd11DR_-oIjBYEuZU3pN9ZbeClBc6duvV44VeA0GjlG1wHGNL4T-xx8lfMM-io3kqu5CFs3x5KH2X8ZhZvPewdRBCAxc56UvtAnbHG1W5KpSwGb8WpUHM1dy7ZHZZDkthQyREWpQcgkaWAUrlUmtvWyZ3ZJjPxYlTAxxvNEtrvMnLnSppJOWtnl0EWFSlEbgXBZP-pW_3RKX2_6YOzT_nhV_paNh5vqUjSLBccqtrn-K1i9INVDrxgcrAu0oFXDvUyA4K8PnwgE3mwed8DL8VyB0oIPJpbS0OU2kcbFmTcSA35-X1GSFUtODtc7QE2cX0fJc093DDPeHJ0QCLykxvxKuZD4XbfmxF4n76GxHVljIEN2nlcXjwkg3O8WD2S_MoBQFH0Vcsgrsmt7aRC4jTxdHWdSBzsturgIAK2-QRIlUduIbPSvL7FTD9fxZOAIUPUq1K44sVWNnVOlVFMYD5y3_VFkS1l1iVcVoUg-bQXfyjEp6Htztddm63x30v99AhwZDudGUPsvFy1FLFa7xr5Bd4D_5v7fnHCfOh5uNAkkmtG-vsrYxXyZ8sHIvtTEXnc_MXJomdNVBo9M4cgoP4U39pT3aVFvgcG9vptmqbvte_npyixX6NrKuxGdh4kJw0QyH6NtDWUzgM3-sTobkgwI1W0jzZ413rwUZYk4E9EfDari7XubZUht99VRkofJwVRg_5OpcTycVsKW3i_502I9FKIPmgNQ0Vf9jqPR724sdRtuLrbLrzocvyJt3ZEFzQUDsAMpxCNCBewVbkuxBLVXuMQ2vEfePngul8s61oi-ioc2o3Jllb0w619f-nHsy1yUz4meWid8eTd8nuTJ2GCYGxzh-NRGbQI3qx2LycmZmMxA3RzfmRq2J_4bTgbkwC1bf_yE66aBWWZvat58NiwD1kPrZvJflviaskXJZa1cxHkeJQ4qxrEbJ9nibaMQwIatE1mo_0qKDbE43W-usBa5fXEYU-3LU-JYz73dkgooAJ-tg1HS8uMU49o4lJja1N4w69r1TOAIZh3cc5tQtED-oaJNjdfKf6LM2J6WiFTK2DhmYl4whucdOI8fEzImRpVn0SXQjytKSFl-yvqviGzLyCvP3BlUE8ts8bJSk7UowQmwcAS6MfqxvmicXhoMJXiAttv-_cjAGxVqXKx7qM2w9q70bvgklm662jRxbzvfyRkSEGCmglb7NElSOv_Z9okedZKE5lHnQIrThagMbZOyPBCLTvbVHEGlhmQmMEKWpdR2RCyx0RfH0smB2hQbEFHYDDJ7b6MNJdRvxG8SViXIsOepumWi55uwCTpcldtS4JpCZI-omQXQVfUAbzVmkgkkaEcllEmj1CBqcPgV6bSD7JM-SR2gn6elG-3w2GMwXYvadfPAhSxTpHwyBURCn72wye93l8Nd2JA7vZDATo6Q2wtqlclav8H5JJZNNEmKmsnTXz_KwBA8Wha9OYtJ3do1G6w74Lp5qG_srReLLFZBSua-ptRR-lDvqQ_MJoPr3C8NmweeBbPQYdzyvh_5nVFn8FI5bNfUNy-xRKGnCOTQD8LHghC6_9YqrpgLydRFdF7LK9ivsyHbTouYjC-Pb86nF-5eKezI3Tjqa5z3Qy1D0HBkmYDl6whx26sFvwXtGuKCFsohLuaLkg6l8HZrBcEVhyLHQhgJv4vOsGZqMQqackSiPgSuFBn5SRmeanJtZatXZL6tkq9cPMPnZYrpu-fw4dt7i08yuKNdsysq14j81WIr0a7ZWOQXA4nRjGVVNQ1ho8sJOAS5O5kLT86xST11dTOPHzBI2-SfciQv6oxR1-fV30O4EpQc79S9Nqlgdh3gT3e62st6RDQGcWkuAFnTpY7yNEqCzEB_XE4j_URzv9ZunhwMaoivSo2w7CupXt5izeBFbq7wMqJK_xnkw4H3aJIat3FXR02CJ04joqCLQ3KWEAGEjtCRGcEzEmQ8HYQRniSgxtlM3gN_sX-Y8A-VVWXpeCsxEvAGIgANLKYMcRPhZg9uQfj0RRcECWnK9ieDdWsc2Qq-aiiOouVR_vZofk1y-i6JIhSD0qmHJjahI3bH2fMgXVk_iwRcTq47gRNhkIrN9PdjgeCW4ikTYsgfuN7lJ6hKgxq0t6cZIUwjID1LCmDEpT4LwLyCA4xOXEUh1Q2CIYakc2RS0692xhPJywdreU5dgwXxg2yBck-TzMxiAKweqFLVLna23BfI1nlrKSKSpNI7GEjdzEyVedRWVJeYSHpIaAg02hYMxUMngKywpA-030Qg_z8XupLG0r75b6CN7mqEZ8QkJ4Sx_sxIQz9HWekGAfG8DlRTtng9Ew6_KSccAOjJGu6wcsxQcCev9t-qqbtNWW_L6x3RO155kQ2NK9fAmAv8_hjEiwCuT9feSk6KcfXjjZOG8rSN8mvkBOye3nZcujHX9915QX-GyKB4d2svPbNHO8GufK17YxbVKIQK_8AEFUvdLZZDywNbTWyo2SgxJzKfLwxIw8HqY7Xbt6Sz8BjwVxmttNGR6dwHiMGgyhbBdRap3fFziRCunzmEIPH2DecNT3IxVt_zuI9zTGJPuOktGqHtSlTyD55GEpZCOganhnCcWPCVfpkHLE00f0ERnL1NizZWn3khP44c2N1tFiWNcYAQkK5lBL8-c2AeS7OU7qQRoZdWqwgTEphBR-tGKsDwnv5pIUevGTXHrSuNhySnbs2mhOhFOLKYL6NaObdPCvfr96WO_BW0gkzE7iET87OXs-FHzL11OKEHLUd_QyLDm_MdI5viNrQeD4Ewgh8CqLBlPKK6LRk7ZQ3uFqeHQZ4v-fIfbK6L277FVlKccTEl4Tgb9ENeGdiC205vBKoN9_LEjQq3PIfj3DmhBoGizxQ0sWMxwHbQDMP3X_1ZhxuVJ_D1RkQJgPmqZGRPGynQgZNmza1VOoOQMAc2ccF238k-cU1ssQA8V5tnrBLEs_xzUKBEo7BOeDoCtBYAuYq8B76FXTZ_KoBoQpLrMm5ms1_FlnxgOgkTyJbma3SnjvQ5OzyjQHVMeX4V_OAeEkh_V4Y99EksxxoDKbP8fYPSr5Rko4dPYUzJA6M_oYGa23N4FpUOzhgTQjwZ_EueFwOnmThUkT0b-mmWMuo2h-QwdSQ5y8geNOQ0NERJKjNiJ2z-BTGAMGS6Cc4Hkr3z3_tCq2F69mpj_AoWCKUeiYjn3WYxbeQWeA5R6kuVP5XzqyXpoBetHbXktubZtgPuoJh2uwW6jxiB4uuXOxMho4oAtJhz6x1LalwNPnhSEjs-1TZCFEd7WRdOAUfdh7RDFYxc01fNV2FCC5j65_qcRVBkAeNDtgpDw5ixPE2JlVdqvCI82_U8CjwkqAQqiQWyG56voND_m6Hr1w0-KrStqwgZhXIKGTey_OyY2RXy7rkGOYYUjI31z_sOWSBrw-UyLv7FcLVXg1uVVtIOsMoYenUVdCgTUb55honD-Aesdt_gftJ_o_5FMru3i8eaToXUxsR8DTKu_UN87cKcwqXnsZ-z1VEebGrbHUL7J92dLBv6IXtdfyIxtQ1tAtxwIkupvvdZrmvraaoWoZkh-N6bRMziidSlCWE8j5mjLN7W9x0epvCgO8Mr0PBzdHyffZ2gN81vyC89Z7QCT_G2hRawtJD8C98ZMi5bJJdKwMAj4eNwYOGohYfbiilrCEOWTxy2JteLsqX1K1R_zZlf-B94E6NLzJTiajdo7T119IFDiG7ItCzZ94O7L-mAwzlhTMyzbEx4OKPxiB3syri1BGWnf6_JwD1KyOLlwsYPX4dab78PhyVFVm8-OD1EWcBsSUBLIz0A0N5GAYf1bYmkOrgKiM8rutNvsvNI37PwExWJPL2hYgp-cKlF-XYcPq4Gzzb5EbfPhNC7D2_6n_l8DrZptnUBv-mmWrH3KvaHyQOdIeRMtAkIV6E_SbW5h_vTuGrxUL0XKOt-DiSaeLk3p8qgrDWDef3svaMZWQTxB_usM1ctjebakF_3X8nItvyuppwdCsgE8dM67EUf0vWpXEWeZPlP5jxfOAB6yH7ETi23w-pE9zzzFhZIYco3GGFJJ5vbUSDvs6tG7ux4I11qbVYhoEz0iJVENeNImtv5NMj9MlUnD7f3yBZ_qv3l9fpK8yS0GvQc_mxJQNR2P-_DAJWSO3LQzugguAyoCSZs_g2xzOGuj7rUiH27N2ZFZUSv4Mr4ia3c5klXVdi6Hs19UKSYZ8KDciryFGZjgaQ8gdJrsZAv4SmXgPwfwoVeknmcA29p2dZaQNxxRxyXj-f-Ot_yKL5UsTXu3eNQY-CSNOgsSxachSaEoJd7vTz8CfSCX0MOdnd144M-ahwiT_6KMG6Euxh-Cd2Joh-q5jMInDC6NFAS2x2wqe_5GIIU6Rkv-ZuOk77f2jqbbMnoe_p3fK78BXmLfOU4LjXUjY5Ymqv-g_PjKrvyedKPA1gbufOkd06PzuHI6EnuDe8b_9D6Ryi-o1oJIYNTtUUdrSo3iG9piX7gKUtBqb5MPszSAPDhMv3EvbYDVpwGagaG4qzoTHi8YoHCX_m2kmtqOPBEssvuH75qoOgYnkmMeg0ehlM7ywlDIKqQd4LFJNQpHIxZUtQJTx9oLnuGv1GAyAeBa11bcrxwQK4LOUTbLALQWRt4KrYC4yXR_5W8LB4Q9-wdkG5f4J0PfFyt-AoMG7sUB3fQ2oQz8VnllvsdNjFMo-mE9ycs6U-u5FIa2MnlslvpGZiSCtj7WdConRk-9SaK3itNP8wkrVgZ3D_jn3VezEoqZw2fmqE_t8nu31E8Qb_n_V3M4OoZvmcngQwRQ8RzKgshmh74hkmHPT9LZtEvCrBf-4h10qzo7UcCdfhtJEb29gsQ04CKM3ONVwsYdUNdg-cfn2EAkHtlSR-c4saTJDA6Ch4fK7SZtjQ4XrANoSmpbYIfr6SVDgTYebVKtw_KASrChwyx_8sIDM8cqgEFRlVxBfjW37pQiF4zjOW-PNJOmsIXnJRJC2IYHKXicvwhholNQUJAlc36_HGdA422CCZzJShQjzOSPM5YMiapN69x24to6_dt7lk6oP9yuW9neNQo3fN6coroI0DHKym5wwACIysq3dfuF_8VQwRDvDfWPgB7P-EKtUYsFxu2g247qIb-7KeI8zY_S58ZIYlWslP4BXRpRuSGis8l3pHYo2EK74ozmynJiP_N3gSLqvS82bQBrLsDk4CvJRFrG5UXRab-8UMZVeYoqdCxXMFLciVrv7dgqNWBtzs0FNqbmQYz1C-AB73onYxvzWBtOfRvndituc5au5AAuG9SsrjAlWr_w1UHKvc_5k_CFqvfkcjYO4kIAN0wzX2MzM9-43vBl1QIpn9ep4Rt9dBq1cwA-H5OH0dIXO33yMfm12_4gLlJ5xrwz9R22D1YZLRQgYUEi8vPw3GB58yIyfjGzz0q7-a-CMkmaLUNr_u1ucqdoUtqz1Je-PFlfxhCTQdP4sKFKFHRLMoXHoXHbMJDMLFtoGBLu7tlsaTL6jdaWFLC_FO7wUloY-WxeUtWs4E3pa4GccF1QW98X7nGBF-XaB2fU1r7439verbsO0RlYyzGXvSwbgo1nMouZJzT2a-4Tx9bWm-QDzzoK1ccZkSbp6xjpoM_IfTTy9q3RMCYw6n-bLDu7GRs5TJ6I2M7hJvkzeNqcCcrQ1O4KRZQUIubZnkJjLAvSei5WwC-93HENyYi0DkGFfxgKr1HOEAKT1CtBEJbE6bUs0-xg17wCNv2zKwjjjn7-qQiwNyb7j0yIvz44haUVtJzCPbaEcHwt05aF13TqQEu-6Z0zOs7yXFDBfp0sKFtQJSPGEXTRw4PzBzytmk-wGvm8DiuBvyHbsMvEdAJ3F0Vq8BAuoPWGSdnvKNidZbjjJo0zyxDlGE2w8-G7wLbuWhZ32vlMYvbTSXX_IBrx4WV6hxRK7ZBd9RpjDiw-IyC1sWlUi5yJYDdXx8XzeBb1VPcuwTWpS1BEe8Ns9woZvgkyxdqac6LG_eCQjbld0V68t_SsvcMxbgP1qefjFm4UN5K_s1159BMBNRFTB2nUh25A6n6VzuT38OAtFJszGjWfXtVqbuOWLBWFdZNDIA59lIUYnsBDxZJwqfwGqq959Ijt_HiCJBzZsCptRHYpp8w-zUHwmTd5-SEx44_jSpYHn5q7TVza45ikV4wbgyYJM5R2h8nkEIbGJc7xfpw0dSTWfIl2MA0nK2PLRj6LEm2zTzRVi5NOzfdS0pq2Xdl9scnb6ConS1MpEUqTYLrVeUwJGT7bkCCeSzkZgGqFgqeG5DbXFZT6gZwhJIkHdsUA78u3-bsqw7DSHyWO29qAdremQ_GU1sMXVSTZd4u1sagoqoh8-mtxoKzBqs8LwJliRPQIG2gIENAPlg-Yab6zzRxmkA2orOlTLavWcrhOcEjI6sRQzfrWuLHiK2FiwZtFPq3W7T3JeqcIAaoFfXv7SZVLHph08WqPAuqNLh2dXzBJfk_MxAo5yFMZ7DycRA8Tn2kwIbWUwP70g7AdqE9vkOBMVYHbCRPJPzBaFqaCr_1Eb-X8wEdw5hRGpgIepVpsCFF0eOPiFQ-tkVx09gOGxrE_rZBvCbDBGuIh6J8i2Q4r5d33CejJR_ya-jUWzgTcADAHtEgZ-ZH9N0mhCZsig2Tk74T94kbK2nxuiTQ3Qr_addAK46LlDEGr3B8bHwYusODZBSUNLYUaM2qwV2Do3MzkPomdbh5yefp4lUGdZNIKjf36fy9m8p5lfHaBgrNzemQ03Me50KOw96vvJGrNjd12RJiKHwCao3yWvyFVoUbFMzCRc4VOKVi9ayAycqAvuidgfAq4oG89sx1vPyhhGPLtSVuc-Vplpj-JnU830sgYAyXJwvWMWqs050eBTlhJcrAJzbq4sum6ZSPNDzEAH45Wk-T7IhlscxTZ4czNB_a8G-SNeFW-xxNjGcS4ugWwmaU_RDHmVEwlCwja2wXAoLa3dShLTBt1XIfBR8sX_jB9llJYFNLoGBD6_IaOfmWVJx215MHAubyjHRjbDtTw_oX0rxwDynIHOc3KVQsDqZOXE5tGOhuaNI3Lb-uWz-gzNlT5P293_nfndCBXu24dExL2QPHNLTDnQROmCb_wIjb76p6qXVZ7Rv0EjCmR-_1IrdFXw0QH4JWiE1K-YwEbuaC1mFfearMYC8oBBUOuItvD7u0aNpHt6nZbIprRJamGWs0DQnH5pCkXHtA1k6TtfVCFW0rbGDUAFXUJfI8V_Ld0YCzQ-6dP9xcyDvmIGaPshkN72SshCFDUFf34LBG8pKp_gvEvCatxo6yY7g8HreRAwJ82iuM2HV2FhZiHMmkfMhCCkHHkisZhd6haRuEXM5fT2K4LaZoE0fmtGiaBpljxyx0utNPckCZezLSZpkk_6unx2rCSQZ0Bp91WB0ytOr1ziHVLW7V1DpFoUELldcHqpEqsOr58IGjY1ZXifGwmMasdzzSdnDRjTrw3ZitrjX0PKpgaH-lsgrwGuzKjLZAY2zV7asU0aOpVsuSOhks_BOx3onEPjF7-MK-HKyMPHYD5_C9Wdw5u0KEF7TK3iykZd3ztCyRjAuFP4gs4K4R6_NIiV3snatPnmGuwRWgvKb3bjfzoc-6pA6JHXe_ZZFCz_EGteXm_bAeoLwozbN293TrfPQJ-cW55utziHU9OZ4hVDCVz8BmFrSmhcSiP90rcFk4L5KWQk0WhHQf8769OITLCOD1EHzhBO5wFi-TIZ-YwFJz91O9G42gpjoMSfVoiMUe8daMirNkUFXSK7siHvb5ndzb7CTgcVmR6U7HqmvqPhaEr4O0seL-p8QUqf8JnyTIg5JJ-4ycKMs3jTAM3wV20FayOp1AJg1Xsh4eJJ67IPb_q35YJybEvUEjsYzBmsp-wL50i3t9_DdSliYDl6i8o4DvO3cz6P28HzRwk8drhedQfn4c7HmaYwGDE_ULYwWGlILXpCVMSsGIPpz67NJdBX8EB_LCsb3Qjy2Ey0OsNNKGoRJzDAAKMSWqv_Or02GM3aExDvtIUppdMbbI8yV24E14cymThpsrSFhyUJzB97jomcd6gBgFZguyHJRkVgTh1f6bZ02NLTs4r8VQDma-DUUH1Xz5wL12pro6ZdXSFfhubgqJnJYfr_2UAIHT8EHcV_Jt9EkIVFlhsa1SY217B0nX8EefGnPoq2AePeizgFYVPvcIv8a7-N_SS-zDCXi4NOBcJ5VJjGSlae-sNNuTj5ZBxRieQd0frp_YMZValaIE4LkOEkdq4p41EJwn9djj-73kF4b_cmkKA6pKiaP9OKs_uiom_a118BlOXoE0Mr1fj7E20nEiVunW5zjPigsx3HdcLp6icmWpsNiKYTYktuNCWviwTmw7zdOchP2G0zmdkc9KwKEuXfvhdNIp182-zws9N5hjARQTJyOJHSTJ4oVct6oVR-GdiKppjZR7GzuzZtPLZcR3b9NI0lgZSklEsDAytFJ7jpX8qz5_ka1WQsRaAcudZkis_nt2DIfSaOHdmIm2aP6zrmaJL9xMUK621NuUW9ikCdcC7NvedzZZf_A1Xmpau7b-rROXucXtJJO7T3hJ0_l-FgOEh-vCS1tmPaRNpDMGwBuznZ1UdvDpEgd5ATY9jFrE1-bTVFf2qvultXvNJoSiA-X9_18qYjRQHwSYj-6Je-vIDRuQTKfImzqmKFYmRlzGEXwGE2SilhMLG25TLXziIthmJT3AGIlmKsc7Rhl9-WX3EjAI1-7cdhuFenHRlfyFSNyllICI-qoxtFptEP9S5YBs4ARnAabt01j_XB8-QS3uAnVrH4EymfKBoaiBfNnE3gn7va7uZO_Pmatdgzh-kVKchfAB55Z6GotFBdeAHdCTt60JylvJIBXjeb-3kSJwYRtk5ukGKNwuAJNNttySMu9kCw09ktlG91CtWarDylxmuPFnLOjqk-3wSZz8thxeL9-A3lcQK9-luiXJaXlYXbmz0x9Ulj8gXE842iWQDwAQXQCI22I3LNS34e1lROHI4Afb2HTt3618OLhzLx_gYzkhqKQhDsZEtJNrm21eQKIz7JVpzS8_crOf00B6pHFCUvALGsOPzU-I1l3kMCydMOtvDBc7ifPME5hKDWtpBqz1Cc1WwILG9a5dH0tjDTthA1_BlYdh7ysQXQIuojylp0dYnQrYVdR__uFY6Nr4R1j5-2LSIz2dYmu-JsJwXsuxBxu0lBU9aPpdTxACiWgskjxBF0KSJBUBc3ByWu6y3WcDPH54meetXIwvSt5ZBEb53HDxmhad80VJE10hscXHY7j-t8IakC472RfvleWT83juJvlzNWoF7Va8bUO167bQXYrPtxlI2P3k4wFu2c4y4FLAhYjoqpK0Ziiynj6VjzxUuisbZ9y-5Vb50i7uciCfOs7u5FRuQ6FLC6G8JlfmndPWGfB3Uk3Rk_t3YtF8iIF4CbqbCdqA6BVsHup3Ts1Ss6nvqZT2QDwht4g3JOq13tr126ldYPx4DDS2E947-5078dyW98cKOHCWB-PYvmgH3MBgsJU48S0F4wadP1nT55O0WD9QD4TaEqKDQsvAdiaAvFQpWe8pgxGsLw3cBq4frd2c-BiMKY9h5qQ5Potn-TIHqdRhp7l8Uwr9xJ8Xa0NewL_SvfO5YYpx_kXaLnAP8ICTMr4kFnZN6_AFV-k5_JtP1fSHq1qzhsd_jbFy-xyhGTAt8WsoSpOwdqJ4HR7Vney6F92hK2NCQqnQvwgFd2DJ8kC1IBXL1ZABdQVJr6X7LMzuOnA8AI7S8Zvucs9EzSKA4DeoM3okwuBuFdBxlgDUa5VyPYWXAvA1tTKbmOVpZsHAYM1Lx0UUcueCdjonVpkBfvIi0-Fd1vhV0Cid41SbLY4wuQt_cf1xVhICezcmDxoU56HPN4pfZVTlUFOe-a69c09ZwkS4WAkyQj9Txqn2NqK8qL4P_EiS2npGCiDA1cqpFZyh45SDQVqBjCF68l8-F6Rbh_nohDvOhAdpNljdDs4e6VHrIeOBEbDgswAkBPkDZQgoFC73z6zjP8Tggwya5-pfg1jLS9e9YzBP1b63LzrzJkfDXHotCcVBPjZX0FCCLPY8CBNXw3jTi8_VoKSiOebjF70ChFjYl3sinmIQxq_4Iz8EPMyhG3fsc7B8cladUdutAd9JdMVKvsbL1dMykYECnRavt-73aXSQeA0b00Bjn6ABcLanMA-n3xnfZO4__7n_76qRl97Rhg9nBzPLigs9ZJ3pP06_BJ64XqgKQ87MAXIKkyDwcpDkGt6ziPeS_45EBWOzEZ-MFl__lFASWmAvhBO9yMJsVH1oYBz_mAfOoJiJOz_A8Y8EemxhcJO3tnVlyF-DRB76OK9HkGPr2vCpHqr_qhqy-S5yWp-RKHPiONIXEk7ur3dqcYGumUIwNWYEJlRkLq9UlhkOCucwFAqJeswPsxAIhsUe8dH9YEZWuFC8bU-1ez_zBaQCXtNfuDlhaB1K5M-nJL1HKEzoWdKm538kQhlcoReDDWUrJp9sBAvnIGma7iGFV6kFLTQBRF_xVh-iH5Ppk7_i9BJiMH9j1Ft-VD6WHGAaIG0UfDltT0Y24GVzRPSBMh-GK7cRnK23HM0R0eZIYTxl7SzkhnliXnXAjovkGsusTlP9FOVBGfYy2Y_V8IeCr6df9zQOU9o-eg3b41mfAK8g5yeSbbx7gnwDSP43BNm5J6VoVpSXNGyK7bnhLREsrdOAZIP-ikAdOBnW4zPvUsiKITDz1ZhDeU__FwEYCzPL4C-RPMGAfXN9UPw2q6HXGFKu8-qo2yEk1O61iTtNmycMEBG-m8RjjW0rfFsnxHYPc8mH3f1ifqIv154rjiL01eUr3Cc5xsRPfAwf4MXtZUsfAOy7GW-eThlWGIGodkbMX8esSdxJyMzRIC6Q5QbyzbLEVnmpIM334pLJ46XrM3zfERQZsGCzJYgqcuMLtkPMVLDcVexOIf2jstU-MBIi0OVSeX0HzftlFlC3iB4HyYEOSfgf0L9MKa6hmsBnMED-bZhEXoF_1ZSEbAOfypHb46UzppsPtbRWPoKyMl56F_PqSXcxl0SC4uszhlHbavTlHT8gcYrgS7Q2Cp1te7tWOL5gO2_esOOIez_TMz6MgHWpfxwWG_Rm6E09SPhfc4V6Y3vqPV5J0ru2_oru5nYth2hS2M2g6kD0qJSDc1aKT8lbyRZtQoyTnjo9m7ncmuicR0tuKXh6kD-Povtf_uigq-u2wSuXvTVOaAclNJInY-dorMchv3q6rGT4cIZ8_wPNmUlrN3UR_xoqZfHTVn1yiurn_UfSSq7fTxF2486lgtJXpret11V-mad2kQtx14UeKJvaFaJkgfRD8lKO9gysUDPY4F3bC3Xtm2DyBKWx8hmvdR1JqnL7qTGMvTY7xmpgpa7h9rHcGHvxd0bjWDxU773qWiizHMrKhZQ9xwAGQrzKLYHb4OnnsflqcvjLAJWLsDYMF9h-MKpnE7jWArmO3MhWXE5iRwRZNbgs5Z1qXO4e-fNySbz5MrooOVlmBAnZtIZlbrqzJiacVrFj77ReqApov0Eix9Ft3rMjy1gMsvaUm8ixNxIqATZX6Eh2yUBKh2Si75uvYm9n9D2jTNtlXSNuxsd_wHBTaqsNdgLilwLatl_Be8BoyydIl0dLKzl2XWlCJZPYDL2aeR4Q_pmkBT89WiMHk-dJjxZYG8a7usG040NApNNs1xGsUmeZLYSUoT1796lZN0lKre5djAuEoRaFgBoKWslg8BPn5-Vka1MNTEYZiQwyckOn4QMaYiggmvUlcme0dh713cIrJGxCeRUwY-pLNdUVebN6jOR9ZBm65qxErbU9LYvk0IrucssiF27ZdUjdD3Hz9ttPZwP82xWELi9n7MkizQhQQpgYdzWGvH8S-A0u2JbgoACYj8surVJyxo4c7_28qXVU8_7EEMom-1DRtQpsbRbxB9I4OKrltOgKOObX_uydUm78q-LxSwkaPJ-81z9D8mrWE3hF1v2j6DReYYZpyQYAInvX2qL549TplWV9j2hFmZI4DtQQh2UGUp2HSAJasPQ5TdYxUboTW43XL0LT62noTt4EmLmn6b77RMWtRb8NCFCJ2oFSFkeAXxdH7j-h-kY4bOuZK75Mp42NgQXApPxQzzLe46knkxqo3LpcWrt3dAX2yWvk7g3oNZySvfKLeophTOUFYBRihmsd2XpZ6smyF99QiVmK1egWm6fZpUlAWTQnz1oEP1ozGsdVz5wnfteytUHXOPLkGycJvO1d9mcqEWSJy5AWWl7VZSBIeJskfX05EOa3P_QsYD-NUZ-3KbBv6k15-MPi91BLtgVj1kPir_ca0s6FAEMn7sUCMYTM4O6iEEBjA7_6O1hI6nglUTC9XwVUP9xM7cAJ9yEYgJZnTJgnZinHxReVY6Au_07zKDSxLdSL8CCqMhqjNTV3kJ_-rRl1BNgl-5SalKkPRjD_xmYdExkCycMUbT5SATCxEMyFqNpC7LruWVnxS75A1sTr-zut6XKWUp27KA-l6NFROE63ljjzokalGEhiXhVLPpTrVaNHW8KCiBVh3ZnuwNNONv5MXEgLVXskME7bBtAMHWSQ_1WCiA5q9__MA6JNmihwmFCFY-CmsqRCJXlRDlJin96BjIOdGMS680FImhdhzcrUOTeJGaWyf5iAYdedbRTP0UUcc9Rd3hqKnZV1OOjNhJ8rVyrXkukv6VscxPFqjJHdZUGDXgGuu7b7RhAKioHmzRnubSTnsspTZvTv45z92Q19QqS6VAjXpmoQQbFLH2utEllLiTGa-5PMF4L4ntGwcmsLhzpJd2QRVQ_aso50oDudv6TBRAQghb32jgc0pjTCyk3kXNyJUkGIBbPrnv8LpilUdzZkV2RceR6-VNyy5xfatQ6TpSi92zLC5C203g-aOxjzf0TMy1yYmVtX8n6lhS9xZrO4nTGk8Y4GPP3fXSPXvAdYjw5SrbHfstp5gMerCUCCpZcVlmuqiiB1kq_nHbkKi8STNPxwcIz9yXtityHk5hSSyUj140TaptoMnKZjluZmL3tVcWJkwu2ZV_nyrPJ578tDkhYJ1DA-kpWc3T15kZR-mrHkkSOdlzqCKhqn4vK3lLIxXKXthKpSNj9088cJJf1dPI6om30ltyqHgdxJXzfIJXFvZ6DHfeMAnY8dCm6UzyO0S8Tq_k3Yy03U1ipChLGRTNW1xFLPxG65HSzLvQ8HBFM_fpwzqVoHZ1nL14p4dhCEF3DirVJ4fg9K3MpnLzh3t6toJfLrecVj63tGM1aT4QHRgW-noYZhIcPkt7grreT_Yxu-thLjLTt1CG7DcP6upRUWA3aeWCJ_mBa1SaflQdOlmQf4W_PJy3A432aMllmtAbcp5NA596XLN8xl43FZsRjTbZBmBy886SvsrxH-G26-6b5zp701Y2YatDkHykr2QBEdlHve3GY0gBc5NdstjPVf-T5HRZhXt9mGJnYn9ViQCpuuiLHGcBZbGWbXn22UKOXhko68Vue3vsyFQNw90gt2PJcSvP8OBI-F8DqRCBkY7wqVSdXvRJ5Qj4YvD3cO9d6UhL9d2H07ABoWdlI8q6FIFMqcbR_I1s-UilXSRc1Hf5qNzU4Kk7xhBKwyaFdpRkl5TnR70fy7H8ltucd-FwI_7xJBhfx-8JCSfss1_im5XaZwI9A_crVjOyADgx3XMTQ-U7A7C1BVeXB2G_DuzNtRDl4vzlJLe1hz-J1KceUYDlo8yCaGe7HH0TCrBIBsbcVK1uCKpV3zzFGY8hnS14EadtEXjs3T9U8OM5jJ2c5SoqYQ0BmYAqDycdqffaqKwWvOHQQpP9oBZbJTzK8VegTNwPetjZ6HkKS-K0EjAWh52ndU7efT84dcVWakxOJfKF2jB1ZXrdXoRbh1OqULKizGZxkBew_jETv-RmavyNYDoqngtF5Z2utzMia-26pMgwd19RKzzTPxxl4Q2MHRAbvYRyYSVkEIK7KWBiKRvIgdrknHcHawKJYzEYaYKwcWTPLU7dUCUWkb3GmnN22u2KgdV5xXmYmK8x9tYq8r525UORdeNLQGXFtPS46O51I06mmZ8t6sUiMgvawAvs8qCwnlAipgEo9aRDQAMBLTkS11OUTVuKr2SAfaXfH82Wu1WE5k1VgV3eAQw7tB6_MjJqpUGJft874AeVbqOkipXhDrbVPt4VmtB5xi54aJmZdX3TWSA4g4spj0FiytA2ZvZ0UN2wBwL1kJy8OmkC7_GCIK0zZN54BTeFn0Mjh1lG3VXPxPAib3T8xc61rWlLiuUXlA8rNx6J658IOonl8rRGpvij_frS9kDasRm_umaly1W7M60a38kYyC4QE8LrhttcQRuT1H-Yo7u7pXs2LwWuqQcy_SkLpp9i2y_AZk6ULfoQ5ItQymlnvLTHCBvZUa50P7ipOQA89bol2DNBxnZF2LeOLwnEL9FMHn11pZtA6hKJPi1feAVcqi-6LiR00mU1DJmT2LnONKcjYuOce7GVhBHNi6GZx6sOj2pMpGQBN4cGwDcnydQMLwR49kyEpOulkc4J5IrRxAOsohdhv-lm85i-NOPj64J53kAdOULqQcDbA8pM5Pj1aGJDIA1lweVkgczg2aPETQa5jfAuHCEI3mb7MXFJ8TBNGJoUx68aLlNY44GJDgsuxX6SQxxTNA46q2ImHpwYM-IY8WnCSxFudWM6NMmH3iqFoebloDTuQBKwEm7PR_2yGqAWq-anlPK2GWoe1-XARSxdJORHmUovyBapCOnX9SEwgS8n1zbVuFdgx2sZCJKpjDqk3ap1B-nrWNAv0jNygy82LkmvFt6XWhcNk3C23KDe5-vfbaVAoKA3318RlPw50GfmNakMlfCM8BXLNo-0VpOmy0JOVt1Ul9MC71LSdFzt1w-IyccoN0AuVOtSyxM_ne7oaUgVjyxEhAsXknx1z4WT4avzEv7ZrvffhwDsTmr0SDYCc_x-7TrpQuaid2kosgN0rtZpDQfeWUTNUfVCdtPEv62Fdk_VVzI2f7vDKPg_LlYaOY7hNS3yQ9-ablo17q4P4g3YXrrQgoXyYd0ayuMPUDE_E-q7QG1MtOlN2QPAV538m0aSEp-wnoeiyxmwx_sqGhC1VGHbKrVqeLgnF53gVGe7d4ILbn9A38y1MNSIiyxB1ABnV2V_te83GlFFMt0ixevuMYfr1fmyA2Y4y4QjlFOQ94s5bMO93JofPgvyy28fkg7WEApfuYhN5cUa65qbwTeZRS4VbicYmC79SKS0saq-m89ShwHVpOntzOLlzvM7-60W5MCIX-EzKwJUvUDAUs2rjsSdzbdDCLC3AEqRA3yny7OKnc-rCIsUYcyEn9GXMhqGXjcNC4OSGsF9wJ097R9TuZ0lCb9Cel_72O--yUB7uySoQ-m-FXtuiDSUrsU92KNORZNWlPEjpN3RpMT92QTxi_7Yc4FPs2njqSy5MMQwofCp9cYNn3hWF-ODqZ3e4DspSdfGfHktbVmhOJ67Vi4kz3z_r6PzduFxQSS_d4wDYq5MW2Tou_kEk-VBepgVjnVzxZUdtn1NSpxLcLsNVaKqtxZuLhcZ83NCAQGgfh9XtZaGry2KE8-ZADVc8-854IskfXr-4fFj7_Srefx_qAjKYsmx1YMZ60bjDX4WjL19MPKgG3R3Sk4io4Ylr6m09gLb6ggi5UhnQffBxjBOrdbIVNieziGlTp1mQpt3ZQwK0ILTOvylDn2EilFJt76fRl-kSObs5oxSMyoO8KWdhPfKru9ywdag00g2ZujrxgxR4uDKevt2S7prKa3UOHXrT_fDgw1cwDbFUU1zOsytgs0qogUZiNznPyniOkvSDZGiGQ6My0Vl47oydFvrdNpH-LB-rh7J4fXu9ssf7JkSiuXkBFj5spmZahMyUtGa6FyoSHhOi71G-HFCeM1L61ZGgYONxsNwD7TWnVVTDZKe7WyhBhEscfHIFWBzcYGDaKE3pGVBm5KKhFsA1oj4TvK1HjAZqGhkR1Zn39_7czBJ2F3wt0i7udUrFCuTz3KzXeCXxV-nCoSg_p9yJnmXvVkDPfKIFmNuwDV27hfNXCoMpfclxNoOpDkhIj2CEFOKfPRlqkuRKrpwmRY6XBYdhWvdPn6rsAgmUOZg9Ta9zFqAI8IP3vtsHsTIm8FPzV-Hu374IvtqoFBJEXN3qySrNI2IS7SvUCxZtJ6zPAsTqYbuNoR4q3wAbcRiHM0ld5cCWLVS4SGKABQ4B8R0K2R3fPToUtNUpfmrTys1QPY4FVrLR3lyE0vqcTwxN6lWmjA3j92O59aq-BDWzRJ5RAZR1svUPnIqv7NAogp4rkd28_Ioxx383ZsGPvqKx2zhG6GaaLGKuZAMiNrlwzmO_CXNclYNOlO-vFn_5Fy6xKDjFwNcbbLz-OtdoRPZQAJD42SO6K9bB4QP6TS1a3xDj0MUFsEwk4d5QNvjg-G7ZkCgftD9xROe_W8IYES8Hqi9BbNH74Zd9_S9Laykk9ux4XIw0dHPQFWkYusjdpgoHwQQa_QhCOLvHSoZf52LHtV6VGnpWqkG8IZMePq-S1SKGqgNOwuEFXi13s8-AU0mVaC7wOJ2FvvoqKgLnMbWdctXe3Mlag077eVX9vJa2FjGa6NtnHUwivSeV6q2TSUOuVQFdHm8sMkxL0pWbWcCxs9OXEWUV9lhpSM_J7_OjuSV3BMYrlL_ljYuA1hXbPTqz8rCO_XT5XLQNyefreS-J7q3E-M70BG3Zcr1YEwgfKxaPP6msl5hCCJyG9gfKK2iSaQHLfRWKXfxHkTcMwdF_H3TclSs5vNcFSUaVpBUJI48sTVMsKjm5IDiXPH_QMu8GnSQl3g95qqvMYvgnv9o2NTWMBAJ6wSYmLGv-OFNGaatS83IpQNcj5l3sAvdAVOYqxrV10fDlRPCGERFc8ySG2G8AAJOzMWqOgNAB3sI6xIcofDYW0VrBBL3czCuqo4BD_LLC0_7qutBiQULYMlmef8FLeZ33xCUPL7nMuRlU0U-LQqv7FY7h6mE3OXoziEEImXLqHI2AJ5iRZ89wHNMHGR4mRUdVjbPeGXAnYQfi1eY6MyfuYwruokw0fT0MfDbZ-UzHze_WXvfX_Dd3V_NeVBfmjhZnnhjmGS0rn6CvQD25Af9rJaC9yu3VOdJpIcDBNueSZUGsm2mdDPRIoZnGkUmzJDg9jHTCu6pRVnSdPGUcYu6pzHkx6R8a-FItCGNwMXYrpsg1Ro4ezkGZtgxdWD0M5nxDSQm-sskZqbolaHDear4D-sLHNt-LqhZLMC7TE0viaulp_gCxfVHmAUEdnFOtQkWo3XU7Kff7Y_rdK9rWOab6ZC5XxQVd-tW89X6rALXhSJ5fQU3tC2KHDAeLBX7e7Q_vBCCziKZFK1NCLmh8zuydeEnfRRxLE-sDlLsN0l_Jcuws6wzcachX3KtFM4QffY9HE9V4dx8xNmLkwYdm903RIoWK7BSjeZCx9dK3-3cwVqxiLY--D-wIiglik0k49PvXqw9xOuZt6sd_ITW23FHDgA2FmhLUIzmzkaV8F0otis73OFqLfux-OCp7F19UCg7eQ6x51kyD3EDkECeOiKFJrMgFU-ll9GI09LBWmEgteKlCHkAjMM_L7gH2pHfsGIcazMpQAAgyLAlvTFTLidTgXFgvFtLrSD8BF7D7molU72H4Td7C_E0tiJLdYV0v4R11k-3Q9j2xXY6USPUxyWODFdee5l9TFraYKH24YaI1cFqKDW6skU1kO1pthhAVQlQCHXEHi9dBbsJjsEk4FR4FOwU1s4X8DQdfx4JlS8SMCkeDwJBlMedXoMjjJZQyvPDZ87Ycc6wsGz5IYA5qvEBl60WYiafPxbKbRAezfEBGECccvIgeu3f0JRNrhE5Mz4Y_Bfg2SBTK2ZIRfYD_w9Oi9yBBWa-woy6EBb_LEihqFMNNe9YzAM5h86DN7R9Nd_xJiYQewAk4TVPFLv3MSe5CpC_EO6nHOwamsxCelksPyiGTKK_AaXC_niRF86tnMlQfzmC2VmHqKO-Orz-SFFmNT5q70V-GbOzZk2ji-1xl8gxpO1rpVR_G_iZrTXxTbF9HRQAkCciZ39E_O0dY5SdQIEP9Je3s0tTlNgnOYwmur2Iuulwk7BsPqb9XN6GXbsyLdXXRwd3GGQmyo0lgv0h0djsRoIP4TtdT0_e89pxfmaicv5070Xl-QxJpDNXY2CbYy8rxZLhTDN1zEj9UAf8EmfieJS2qj-YKjDIg_6MDE9kIOmzBrKfU7nm6DZ6W_RvivWWRst1ZghU7aR-2J1wn4NlzibFL1jFukJdH9uopeAgPC6feu_DiNo6czYfzde0fJ20PRnFBTbNP2avtHHQGMg3ARQi2GvMH4KPKSQLUxO12WywDQ9moDpmmupGzlBIgUiQFcWJ7W5jWycJH8o1kC8f93VnXZvYPLd537lqo0rCWYlcrX_xXNkYVzBJ3Av-rO1THXd_fcnJTFKoAM_yp7uNSWNoWeZfUV_ijEGa421guED4ASNQgo-RjdVzTF3dRCdNlRcgazPkVKiDBF7q39v9H8zZSOS9iJtyDzdPF5U-YOC6b7wjW1YErSJpr6jzDxZG-UhG1Nxs594akxomf3HRk-3EvMCJn1qZ9NrEY6whQhBgdx2ojwr537SMlpin69AYW1Rm_QR9P8HQQy6VMkwgOFYY39WUU78jWKZk1yChbVHgWZXV5p14KHdN75IP8McO_9KkViFy79AIHKLtdRPoXLJqT1uwKlu3W-I1g5mfCK3epDs_IUX46M5J84SXrmORHW6VZU1CzFCUobMO8p80pXOWLiUf8ld9-e6PXgyw5d-G457vgNZvK3Yi1fVailLVMIZVqQ5TGzz3KqpPBeZpQG_6OTkAYqBV1ICh1SZNEf9xd_vSe25TKC63SX2un4THd7sYQH8FqCNrr0lqOKW5FBknRWIL6HaY6rJNIoelrNWxq2EwWuePNreZVyeWNXz55SVnqiytqIvnZXX6PyFIKX7qbqqhvfY2sPivcf2zqAcgaxx7jlFzKgqOpqPtA7OMlWOyd2BdqMCPMTCGPmkvNpz1JsF8SWdj25R2yMZGS-7mbbMDYHsUgP-aC_Y4XuNuXi5qdfL8U2rIBU1kN2AI4Vg5MjilhIA0847XWX5A4_G9BHGxvHm_oOcAvV-2MuLnhmLZgABdL0hjTm9wbxWBzqBmCH_XV5La08smTdiNJVaxMradW3vE90zO7ljNHWZ76cTm2jphCCur2bVty8GNT21qrDsPVevA08XIsxbrseR71pgqhF7EWoZl-52T9jFuWUiYz6zhMSaFQfFkFkUbNJ6e6EqhyesQ6u1Tqt2IY9Jw5kiaNZ6hVZkm8qnJbrUAhk_sHYV0uSryx2jt3-UE4eQlb02tnNP6vZXsuQr68JHVRiLF_Cjz9w-JJM0gkxPc6QQNscWAnG5KZMRf_2gb1P-Pn8mzR-Nbtl58XASNLPcCo2IDcyLCSUqdFsrKGF1IlCoLCcEBOp9zejv5JSVhwaFfmdapE7Wx0BMKcdVlodzKyJL65bwRb2GXgK1cKu1-sKQKbPCzRnK9CC_KzRhC6bA7nNwCyD4abS02764WLcRNWFlujpQjiLBOjVC54puWfb_XrEs-KndaBQiXX4MsLBHr82WhN6PgUZ74N9sMjj_nhlNnYBu1sa5OFATyCAvRpDTWxyShuOPHR42zkWx0xi218xvWFhiZ-e64dYYXeCFx0FzY-qCrMCrtPhLn8uBW61eC4QmMaUoGtpFDZjuNfVBNOHTj5-1CnudR8obAKHozRELJLFq5n3DqAtPpAK7SORUoQot-4LWyD6aUwhpoC2FC-D9MdFpfhX_b2paXCEw3PR0MRY6QoShqCnEyredZIv6-XdWz9DVtb5cHWfYz-kTs57KblXDQC_0MeF2BhZbfQBZzNaqlcARab1WSt4zKKyVooZhGYq2da1solJ54duyvZbEwDYxzYmzLbTJIMoFwyOSmFW-Hn-gXQAJRlCyEBVrleLTnl3_VSymCtp1_cSMYMatShzRU6ICFwAGlm6mo675t4LI-CDAUsUbEIcKpCfxB8iGCwN6z2JrkaSLTOkuQCaAuAu8Y01cnIJsXXSk0MgJRfcfdEePTUWeC-uJwuNoGa0KgSYlLKVT2XvnTadICqHA_jnMIo1OV05tDwMpjwcWSqzuDUiGpTIVbzcT7dyl6UZjgTFh_DETeukw5NtIrI_evMRDsSUnf4YxzYvltOdbqb4syMAWrrAy_IChD44KtMURzisaMZru-0wcmpoHeenirAxMggrYOMytaNm07KiLXT6KWkJpFfHCLNN8hNlP3Tr6WPubO4Z6XMy-ePRNP8f4pLpTqARw66GeRSpuxC0jCx6Qan9wIfgb5UJQJxvA9LIwlD9qLzR-2nHKtJPRj28SCxpenS0fTdKHI6gUEdFmmBkw43kvAjc_jt0i7K50747j_NO6ECT9zqWk4XppZIbQtsHgnKkd-tn-DFiolk0xjxHX9S4-ZNncWbM7PtccmF_evqKshZUE4EXM97p5qfC1Di6-RlhBlmG3tsrmMoGdsObT7EEeI0dhPQLuYyH7yichjwUDqzTI3NAwOA71xL3-yv3ObUF-AtdNEB1R2RQrFj9vEjLSsevE4cGAPs6OZ4XHAAi67yvkMFPWhZGQwDNqyWankZNAn5cBUh-lYA9oknTfvJbT_c7t4jMIRRtMbpcYRcsxToOCYdhurgpdwQx7_ZaLHWsnwIDulPtmrLoOclo2FSG_pPFXGiGcEAonrDcOGBqveL3UoGwi7OOwGGyPnqQqpZI30IAObvp_O-kEtwQ7jMWFiOjPqRsofZSQ42MQFW-yzfLOKLsCk5T7T0eUJbCAVysGeVC8f6Txe1WcappVw0_v9i0zdphpz8hiLWCm7x-gEvEX_VPCxCCmkNmOvzv_SdH5fk8k3dtgbPzwSPWjYylrKo2LLXm-uAJ_4skuXdmDIvfWYokK-lUdK_d45_o2vaGyO5d6Mw9ByJMz1CX4WIV-vuYc_2baiQ_cKM-32vh83XAmDNG6zrlrvXXbH7Bigv7-W8VdPTM2w3InV5Onh2tXzQRaxbUpNfKz0W2WSNiKYwZAzVRWe5o9sWvOWlhPRDiHBX920SEpnW6NObXKZhZusfjJZZsiRNJ9927gJL0xa2ZguG5daXAY3GKNaso1ZSJaOeeEP0ytT5IO5HS5fYqaO_z4Kr9bmE_g5F5u0c8pgiR27qkxMlJaU24Z4XXxrGta5gexmjZH586f03zMDtUFhknwEdNs0fzQWMFx1kN8S1enQEMkv3XjtM0R-9mPLBBpyQOXuGaAgM1OAfXxThPU4uHeT13QNVcqmJ-VGAmE9elISn8FuZ3A1kl07-vS8Yxl-HmL8cMla3n1CuxNxLOaiWB4rwFLMEhm4wkzK-MiOxIK9eifbX8QYH9iOrBIUNkIknqqsXGhhIWwbMwmGHg1Hi9QqsAkNexVfctTJM2gVYtMeoAzkKjM7hdI6aW9do0vDB_yEejsaEWclOSsX91uvd0LvT-YtR5q4lizhPDqyZlpjinJPJ7dXUxscFH9EetsYEXQEMGnOPvJsLcUaxm2EqywAmsk1oaYssIASgkFrRjYYZVZGGcixOJMaTpuel81nW6gwPuaZgK9McbhVFt9901iH5x8LKevp7SZzlIvgO-XAi4ETDt983wRZ6_BdTIhyGLvs_XLL17H75o29xylaijrXrDcyLLlnWM-fMMnNd4jt84a5zNTf1Uda-QNYgnzkLA1DW8JRtW7KyhbheuIo15J2IiLkAiWRs_fagsavGdi2PHPhtrHyexzHj_QR8107yBXLB1XyPR00ueOBUvJrBliacC6IyeHtB83GSzP6r7htvgy_kJoAnbvUgFLCk3Yjnwl68pQUcL1s4WLYt6vdlbAbSZBR9QuC0Qt99DHPu8AYgObxIkBACHTFH5OPozTMpujf6NWL_GbTzAeEES0TxXbIrXdKokVAZMgVI68f4aT3heO3ZT1J7e2U6j3BtEsAk6ZJRtW8kyRkM1w4g0e0Xjeubpx0j87piuHRV8gPeUNox7cjV2KTTro7rgj5M_r3P7OeVlger98jl-IvyFV-pyUw5VvzJ0esnsOEboa0lWkpPhUQHpFH8zMW_ZFq0MP1QTLNbLUr6WPzGfsH1YOhUNCje7cZhpfJS_AD_vRo4yE2U6QV5ZTmWVUlUyqD_AJ1ozVVuk7KJDZouzzhkzbq3-9B4pZcgZY9xs-Jup_1Tl2jG9Df8dokQMEqRwqgQ9DYI87bHuPGKJKeSGTcJpdRajkWJDs67bzOK5eJU8XoTLT6edheYH6W9jabwn6t18m9fQGvVbRNHrGsxkOmN-eULRL_FjVqu5OHopmvIvDIb1E39wk_gqGJ91CN0o0fo9CxGYjRnRr610iO-1f3pxqjAD89pqy733U2XY8odySl-qoKsB1NBGzLOoxoQs1qJQeVbXsKFt1dnX1Ye4CFKpu_nK9qU0g4RRkD9fW2VDWf4erDIx7BN9EExPGagt0EhGSylbjdDdKmKciYCAFX5AJOlPc2mMPEkwsoHvE9Pz-a57JCp2j4gOHGG98b8RWLx-U36NCG4F-zjvyNUMun4H_YDYwJ1DFnxh_81SF1uMEGrqrWz4GsySgqJxEG5juozHBdFgj97B-lU_gItmgj9Oe7_jloi3kSqosCuCwW8jmIur-cl4LMuRbOd273zbcBw27OQbJIWQ65HJ7tnekWl2p1uN_S-xJC8aVWj63OXo7xfTC-f86NvDdXUr1Kznq8nOaOXRW6uNodf4Uf4QWVYfDACvLqVPTf_Qz3flLJE9fbwdRFebJcZ4L6WSKEvs-DSS2UX18WaGPGAzLMt_MeXDqDsDDxICoa-5jAQMSRwwCo26wnqpu7Iac7wdQZXRzhgSNdESUH2wZj1rcq2XLzuhrhuhDWs668SFMSXJAkRXEhVY8KVV9ptmLjRgJBj7EMWO28yu1QuSDar95sALvzYyGxj7m3paX6qB_Ni7Z79t_W_zHui2YwxhTIcc-r-HIIcKMv57QKgBIrc_vYCdy6H5gUrO7v8VfyfrcISG5Tm1HDH-S8opB06Df4DX_m_xw1-KnrdrS1jmsCpEL88FeDOtsEZinXP_w3ms8HKB9rvc7esB8ljn8aDFmWEuEsFIoyx-7B-CLF38TmUEPPuZRukhQGqsjAIJtr6JFuUV_pZmrkqQAaV2_o5itjbXZJIWQvrXDmtleFWvunjGuDDY4DQyfR_3I18gyn_RxswoOrG-nBDC8J4PAP4KkgcTelTozTZk9bIBUMA3Lr9PTRF5zDTF2-P2sC7T1wHTwAN4Nqwn1GNti_6bCnQWJ0yS08jEtIGAN7dWZy_oFByhSdTmENojCUubC4ie-TKKbfikN1nLl4Ij3kofmawnSe96fEBS1Dp3FfCSoGS-5ZhXzAeVXBoS9TjxSioM01HsoHqYZYgFBIcY3sne7ddKNN-IHu9bm9f-LL0hXDok5i-T4_XkUJm4BE_MD3CvDfCgrqrfcsrUiZxV4oLzI8XdeKCCB3MKug9fKzZyaTtclf7LGLGV3xKvhBvA69Qg0V3K5CdaPIQcolKXC7jnA90xl5TFoGjXQa9nMswOJHraLesSRZvE1Svp1HRX0vEZTm6BhaeK08wlXiaT6A_baQZGtWMHwnxBvnkFS5QWn8GedUZVKbM8NX7som0pQ_3reyrYG9-o1kjmziJahb6P5AagN9Vo28xV8Do4Ve3piu85JywHETJCT83lXz097MmVTKzPwKTIApesbnuipuqcmTZyG2fk-gVRvOV3s_WqzL934jud-YyptXoTfiMVxbE91dtOl9QVGt3JpSB4gZ-i17X2LN67EwZ4tffuqD7Q8G0OLV-EgMAfHP2Xs1u0xugysA1PFzxdl-ApzmyrEk_oYd6Np6KBFHygrw_Oete67zivWoppfLbRWeFBv2tiS_Y3ozQcBCww1knozEvjPMuPhrK0Kf8QoIwyyD2W7xi7Ducixt95YGV-_CyuhyiQWircwI6BTqlVQnKSnZUvegs99o2kEBzxup93QH3BULTT5nTwZs4N-_2afRdZuicyupwg8X2YRdfvUmN1mJQnJySRc5zN0iLMRybGsMRayVuVN_6cNG0p2HniBjvrNdU6dgpVYLZH7hTZyYc5ajUbIT15hSz793YaVC_vYAsG2_4_ti7dj9Cop3-qus_vBUoh3MzDDFeHQC-eCxsOrSvZHcItrUecXsIlTMeSmkr0Q-xYcfr8i8aBvavHvcTBSEkwXS-7UenWY7tPDjoApbQzSoRKla8hDjN8gKb80DjsUC-STg6skjIts0hcdcmbhAUR1M_WvPZROEBywUbwzleTQnn0tXxLT9nZRTwSoMyKc_cDQAj2VHQP3ud_q9aEm0h92ahQuXKfq0Ymg_TFOkMKE1v2RS3WkfMaJq2ohYRg-xmr7GIeKJefk8c7RkNidmV9vZCtJMKfp5KK44vva_gYk8MlfK8LQTw8skn3vmtEp8MCuiBD66T8Tg-pj3CTQk4eCEuiCmh3wYt5aCWLLBIQYy0wYh23-qF6naSLWHHRXKSKEZcrHjmYgE3e8cMMLBikbcdKcgFPQ63R1PQ_5EVAzL9bLLXOfX2IFRdIt88lmTgPVCsoSIXcOubBmIVSkfXkoCIUzVb7vDATAcFEQurLZLXek86gFhnPGz588br5J8NcEqlkdurTsaFIe--zq-xii2X6ah-xUO8Ubv4D09SU3XUQObo1zf5GTlg_9_yh5tRIMcyJotDoDLbbd03qasC5G6K9OGQPnouoRDuMUj8wQA-__0XjdmrH98rYYKCeKEXkJoQEHtWERt0xwxeyIf6Df5yZcrYEfCtgYs2qxzx_NZuU8RjllxLNogglOcj4LJnGkflDaaYW-BgeQAunLHIUtkI9yZQjYznNXMvSpKkCG0nLYiTZKqUNU3EQHxMHOR5etMv3LCjuynpWZ5hlWcr420q_IF-1cRcdf1dsphjGO5dCOojtN6jZgrnDoOV9hm-OtOd3Z9snZJtXhPap1-hLo7GZlG9Iwi40VL9xTce49i6iLThilw_B4HXDGjMcxfMmZrmSH6Xod4MRyC5FQFiwETLQ_quK-5tRM-pea5UOId8_hCv7onL3NrdT1HvyAaxGLICKfyHS7faxudwJEoSWqfa717etdm40_cJnFReeC6skj2MVyrtVygw-OFaV5hHaBUMeX1iNv-30xdOA9Pwd-REBSqiZDCQclvmJdrJA3SuZ1L_sxKpd8e5QVjYYl4bnZaDFyXcN6uwwRdQiW4S0-EBFh7plXSoGRWfZjvvPDvX3NWVFGv-xE23jUK4kq33szN_5no0uRubMpeF2H0ncifrITTtE_MnTy36q-f0mApGsI867PjIwMjTg1wBWo8mOxZnF7UfI_sRIUXnwxiwCM7CqwbfRedqOtYhmS9yvqXu9EGnbrIawALbazteYsJoUHsE-pfgOknQmkXafPVmTESrZdCpfSAqg6FzUtGOrhWO3jJnlrQuYwNQZ91swzy1ddA_QyTEagUuWbxc28RY0Sez_LWaTgpSIl_In9VMzm9DMSWF2OVDHTaxfNGztLOk25n2A7CjaVfKM13hOcTZ2lYDobHTzrTlysiKga62fhL8Fdq7vuxGUiv_E1qxjKxfbI5MdsymmRikx4LMCaeKjC5qv2lMnhkSVt7VvptEyzUwqVlBsPfCPOSZyzg_5EqbHZ32Qb4CtYxOCEZx7dEXs4yt5k0UTK8_ArwcT5RYZk_JVlX1j-AgFEOQbpXfZDcFRuv80GRAniN2zJEgonQluwAQjaLMbXTtpRv0Lwt49iasxP95ZoUPt85EnSXUswjgT0o0fKT6ejh2G6tdMRuKH5BFe4reYqhQs6HSMnsVpcC-V0F0gst9B-oJe-g8FbfT9sS_kI5K4LVE8iUWMcrMcnHbmy2jieX1Z32oaQ3fUvTDRT7WcA11CjVgs8hhNrdPDillxQ3RsIZEdKp946woJOhA1sjOio0jA7u-OWaiSF72LMFKi17G6YhSlQEglPUAjZZ6prZ1vEziaEIzblny2jdW0dVapODvJlwN6HTYiF73dEGNbq8NoGX_pGZt6HyROXB5-5UkPfvvOsg25NRRi3PhdwJydnWKLwv9by9hiDgYNrtvjT97obl2eoksacAeZ5jt8Edwhe-bP_2k_tun_x25T54r70pTnAVUYfCTfm40-fuzVSBA3wP96NpO000wvLnqb_mi-Bk1Z3oviegDRWlJZiV7VIdzfUuwqAjDDB5Y6gIM81ggrK7rAiH4n9X2szVy2X4NqXGZi6U5F0kXynX90zIhby4-qHN0axLSs-9r4uddfSnaJVdoqFhLJ2AjOXbAqn6FNrA2a5dafdVLG-sOzYwtl4eBSv6oWKUxQshznEKVPaZ8D9zeB3XWz_QoqKkR4T66Ray-nF9-6mrs8QY0fQj90bW9XyKpKCINZs5r18wJW1RTocTd8C8s31wH2jv3J13-U_gJfiucT2hnhW7ogQY7yRpCrcd3Nb339KxVT9aNVFU9hwcrBkf7CTeqSKYZWGtUKfaU_yqRUT-b8Xhzmaj3hCU-BR5WEWnROECifFUBadoezYQhKNmeaDLFrlgxWh4kDXbuh0AH3jRUxpN8Fz_HVCTIEJUCqlPkzPWwEnmqC9XpI6rKVdcVyay8p47oYo_lYl3uu8-Tyz_kdKGZ_HQAwK2KXpzCEO5uM_eqzWxr7O_gBD2BlJHsNDZP-go2UMUcLim1c99jyg0dNJt-HsqDBvZh9Y4lSJdnjDXbahvb2UU07OwwXvdIPWuKYu19r-B6u_aIhhr6glT4SIfHx8pmwsFMTgYWPJzt4nI-r85PPv9B4K6kvuk21TqDvQIZtkUoYfgsHhob-z1bLe8i5jXG5A3-Dpiu1VDU-fwTar4PlV8_M9RKqa2w42rv6KX_rsOD7eiVYeuIN8QzFfDWu7Bvd_ZhHNJGGWGwEjnoOqiDgqYi5G9dgQ--rDt40crxXOWBYCKI_1T9PMsQSZJIrbf4Om2tEmeRfQPmlXlMk3KDyI8IAqwHjJPDX9afoVOhpMdV-pvUu-251mFEA0B-w0oKn1PhWmodjqzvhRvRabyy4BYQlbdGil-nU1jjlN4h-lslkGTRvMjdDpV4Qm9zc3t7201waU7gkS5yvEr38YftIrweplbGsnMNz8ie3wk6YZszAwJW5ON5FQNUE2S6JGIweThnal1zP3JU7903kDVdD1nfP7f8PO3spNKYgNwtC7-Ay8c7cFHFyGpQ3ydJpxwmgP3wFaobP5nhby8XsAZTGmrHTitwqziaegJxqARUTzbt8AKciL2E2ftsSazxH7YtomJSEJYXncAbF-Tma3OlOcGVEeof8x4h474oDV22MhMthjvYVtr7faHKlz9q4jc-v3O6GpLwsFxETDSMeBTqYk3JI4kGmCnfZcva2bD_IniycdSQV1dADeh16QMweAq46YisiBHvvppWZdREFARczRZrS4EOSN6u_UwWJdaPTgujM5XLbZiZ4TynGMqzIr6xQDzNxamnKs9l0v9-ui4jVXelWmNzgOcwRVWU6zq3q22IoZmFVaSvHDhNRyGx0iRbSe2CJKrNYfcloevt05Sqeo2n7fkpib0h6kg1Nfq3QICbdEa1--R6nhokHzhFimYlPkaNP8loLzepsfHsf3RFsnSXUgNUOZkWFPF6us-WM2UwM-MZu-MPpvv_P-2cwyCX_eBbjg-Cz8qwyGGyZQLXACx_lA-VJCBf07uFsvB_sSK0xhMdAF64UvJonxLKnAl-LHzyJM4I-lNpakOxnKwmJ0A57mBVKrgCp3FYGbjkzi5JUgkfY-c9AffnBpoe2J0lcKzmq0j_gLSTXiADyU2ymjsLl4N4LpessjLmk0HE0modHLa79IvtQz2F7ZdAQIf28SG8tmj_8Ie5qQVjBQePdQsspgzIUjdQavOp9DuWp63VEptbWG-NPAw0kyhFN8UbSuVUONyZC4h3hAjl_to4h6O8SvXQqdXIN3CNIIdXF9SgR4oGVJuzSHTJuIJUNFLQRsfNx4ZI7TKTPaHb0Lj4LEEobUqi__YjQ3RwcLjyvvb85qhBT8j1mGLbbtdKmPWb9T7XowEaxCOq6_4GpAOoX8huD1E3e5TmTSNxoLW6a1id01-aFrgRwjK81hI5YWqKwpqaYzo3jqGAokzrpXEBdowjpZhdTqf30c6-5KIO_LO750rgM0kOVjbarOj5J8rBeOH1e5zJ3Jf6zlIbvadj_JewSruLrCMiB7lssq9gL1X_orw4WsYilLPDdC9nj0EokMQei9oFQraSAXDLWBnpD_newTHkYHoicGy2r5TDug2b9ALleYaMXiuediIy9jOh_8gAgv0uSrP4tOFcu710qVlkPU7EYOcvPh7FuBGd8ZF8c5Qs8v5CM3jb46hMngh16T8xEHTvV53v850KAA5NOnE0GhVIkVOIfqlix3OltX8YddVSTROomzF6mG0Sqcz4m6Pd_QBvjvMM7EZh4kc0t3ct8adXiM0vKS9-uTzPJdIVU0Ehb6Hg_vt_YZ60-vdi6kDyMSAaTSXcXNB9KXrm9mf0hwvNBdCGOWzWUvOBLWUcR8GpW8i92pKaC9JBT5AecN-6Qr8ZZW7UcjwSPiP6VaX6Gn6tabLMeTwvLzJHWQeoxVZgzx6BjMrZJ90BnL-RexDhRREtyexPTObTYOjWETKrfFkOyDchDO5EuYk9OYnBEEX-9Ip0HQp2JwKeRjVCVoWGYFvXn_0tve-CaXaUd9Wcs97uXS_9DVKUDVzNk9YnYU2inewrnhxepSofrLY37FiqnEFFEUPWLjUQj3-hDDwDAdmj9t0S6QWqb0NCQgfqLxoD1PMmef59JvbEJVoV-QtF6Vdrebw4P3nHibgp9m36mSYuW9pGCahZCfbwVfHD5YQpVotv_awWEznS4ofOReWvn5rLq0OpS1VMrB_k-DjFQomWHKPnZu3qEBgJMcCb3Q1X2JKqDiEOxR9acCtsr79KXTmezl09Z4wyKgrWqkfcV-eFuWPBm1SjVfh-8BJeSyjcp9ce00W0MBdLBsHGlJX8imwTCoabhM-rWRCUtpwr4WuwUHaOfh4WesBQGdwqG3dWv0l3N-0ND91CQcE_D-LB9pJ3ItgQSiTnkAZ_t2bNQaoroZbLq5i1YTcOXep82Vh3fwtICU1NibE-s53OCeXjIk8mqmL2eKSQ5-KVNR2yL3L_a4I-HTWbD6xzgygyNJl49-WFio_yRcNudcEQMJNo83DjIPfXILoISIR74zU8x-Bmv8TTL2UJsb3p5nKILLBEqwY18CyeQ4CFSA6o5WlyD5iY5MfXLv_5pnYJAYzDBFtFlFuhVQgwctx_rnbdy0ggBpe9dCQTmsDw8qfbSuorLWOInZ3NIDonlekf64OI6cysBr7-Ec3xqzhFPH_S76a164CTW7cppw-8gD1J82A9zwOEDMSz8qB7cZo9y1-Mu0wn-85XoNYj1iYsQwEYTs6ATxbCTJIhPIF3jrQ4HK2VVBBgDQJeA8VGwZFMaUpcABJ9LDxWsFJoocHX8GrJmxbkKHpAMHnFwstW14ZqVRAUTCq2uusHmkXR6n8lj1H1hQ17bVHEE4Qn-xXDzEbItOwuvW9tAAcdA4f8s1xSDJYHX5HT4nsrnrkV9xH8LeXKX5HS98cV-h15Ga5wjdAXy2nRYZlVkr5rjuL930jqd_k9Awi4YeN7_Flr8uX_RMitiLrrzW_R8ImaKZ6wB-RGDslHJe-eLERA6z3KTaH2bn0UX0j-0ylcLlBu07h_gIpxIonSsdVSJd3DNgmNxN72EgN9jxnFBnjIP3-9WjeXFnWs0z1oTD-6Qw1c7ZMRfYIsYbiJl_nXKOjrObNKU2y5aJC5kCcfaHWz2p0kQNJePomyngfrPAvTd6G_riSW0RV3l8Iv761h0b9DfKOQTm8OoVSBWz0lXF6bZJPO6Qy9ksx0Kg89iuHt-uHLJHqp2VPOh1S723fNfNSfni0ynrQmD4yT6Norv43mVSCYkg6aT4chrN8qJ1VHU_O6q-K3m7oAf-nAoODsitbK_4khNIO1zXrhzvN-bnfBxlU0-X7iGeLHwLBhZF6YpxszlHnjJa3kLgU1ytEtQRWAeU7kiwcWQ9EDKNkVoFTIaQGELMkY0BkK8GK4m1EBRpg9q-0JdQjAM_R5R-sjOZQATAPmPZXua_e5yVkPm8uDXPEWkn5Mo52Hdx2pxL8C1qrkVCnk-Cqpzi7I7zjqTmplrzPeSlbbpI9YBkhQjVOrIbojr1H74AY1n3Gdx9otYyq8QapU4f0W6Q6VXNUNJRqjGLLIsLq1ivY-n9zS-64su6MwTvTv7oqMuoyl0aFGjZtoZWSiI67sKdsQuG1IsYmLhhCJfFicLS07-p0TE-e_VXpIRYhxtqwZgOvnpGO79dzHvmAblboOiQnYqSYIJFS70PJlnVHYdBi_wp5HbkSno7eIewX1bBuqvNh61Iy8X6SLSywCkfpuXMafwZhA2VHsBOkR2qbMVYciPifWoZnwqKN-UwX8c6-dByg2kApmtIwg9jSe-nMHyUV78-AgmY28kHjT-cvUVsE2GWKGXs7rC5-JU5ndszbM5zVycv_gXWDUimdUcfPAtfb_pi942TS-Cl7eS1cm8gBIfAfDfFaDKy71tFiMHK_vXM0DIfD3kJH9OnZ4dIJftCP7xnb1M5HrFyL5UJFqJBL1WBmF55a2oNJtV9f9tBuNy19XjKTWj_4c72UKnmwlrIhxr71uOXEX92tiuEWW1h1tNPqRk8vrEoGiI7biYtbcT-B3R4X6jTAObUgYzwu3zuQNy-AN6Z6938eU8QXbE6lsDPDZSV_yRox6hC2fRjzOk31pXlc-sT10MyER8zm4v78edWBXXBmw7MqO_j-ocaUz7Ev_6HIKNwtGBZL7_8bmiF1257ChwrE4bxu3EsknfnWIQqKM_Rd0-90yfAR2zZ5-1WGeAX_kCUkOOfQ5ld-511b4fMacm76y_A5twEUcaPLo5xDtmeaBvMfTn9BK5WEmxs5_YFVxvTL-jHAv_Feqeo3rFikwcjJWMfJ_W6I1_B50e8M_8Y4hntcAHzL4bB40qg5UA7mVVKSodaqPA3ZMQ5mjtG6JNrhdPhQTEiXEJhsf2MYfNBAnlZVOLhgqRuy_FdLJKlUZzXM3WotNFB1FqrbbkGw6ZNYNSv-HrluFIKv7_QGtOZMrJLm6HYujWtwzpfTBXBqxnTEq_djqZ4-0vtdpK-3vVWR9flSg-i6mqfTZQ0F9xmRUmzOmhNaJmIs9TZXX7PwLV55NIcC276P8kXN8-NDSWkx51cYLwv38B-ahWRYRXqZvyP89TekOIAFbrLk0mbEDrJT68gzUtAxGCnbVtHs2uyQY5UWHomkg7B-KcUA3R3SjDYYa1tk23zFySAaLYYos1mUUaLYt3zfM9ZyiJa_6Farv39-wvTfK16pRnxv5WqRrrjHdgw5XU46TV9QWL_Y9Kqv7YrLYx6w9ZIoVHgsWAQarH3dH7iWtEod3hvKwDjl8OAislIUcOsCeaEhDHAO4UC9vSYHJOLsS3-5RdeqMgJS8M6c67Neo6cDkg47XxFnBU_a4Aq-8GsfihYyLBQNP6kLO2-Kevnyz4mcwBe4MsHdjCHZgMRulvsEaleASg7TpWo76M34rkH6aYqJrHTGyVqQBaiIe2Dzacx0ROm59V_9S9tkZDQ0ywm9Xjt6uKS9Agl3oAhUhg4mOEMhGgtGP_dfA_HNvu3ZB2OQGnAoIGXNmSxffdkun0o2Sf855qQE7_HZw9CWY8x1OfcTOcOnzehDOL8KQaRntr0meW9fAFpE8uzNzz9N-4LY8o88TQ1ZWUaLysXrru9186pS4hIXSIWJhddY3y3iGpLn8VZnUNmGvYyHfblYKLzmB-Mvu2qPlBQpEK3zyW_4WegFR9Vg0CB4NWxH-2eYYx1mP-6-4GogLY1cu2ez50zsaxtlF72qYKKGjF5APOT0V52nZ6thXZB9MDY9nVE5i6OWL7PM5EUl1a3_Ix8YjnvUI3h94fSuDF6N9BBXrxPuxB_1PsM3OomVeM1DWlD0R2ZoS0nql9XXZlFDPqzcpw-kxi7wnjRa_y9pLFpvil3XVhOuCHr1UH_dI-H96_lBBeloN3kBcwEj32FTZEb3ldFV48X9cfFlZzYxtfzWTTVXB-4SCehPuOeW0domYEI1CEdxZNkvS7gqQvtfNCosKQjFJzHYF58Ubf-m9rk7CsUH8FndylTEV637uUKVtWMEAv8YB6QQi9ZNoGQlW8hYP8UpkByzVMUSL5ClHo9qUDJUVt4V81hoSz7Q1aMfLGZVV3NvirS1Vm09KNN55t7BBf01sHoGolZe3hwmorV2jTn7ta51sDHPPILXusFZfk6FmkwIEUQhFmX03DT4mLM4aqcagVUCqtGMRCmVVZvyyeOzcSYPmpH_yLiMPVbL-7RtV8pJooEYfTt3KMXyUfJRA_RWZz1yu1fh-lWdnHvZbV44GYIE5Nk4c3F1ndg-IWnrDb7BkYz9XJEXTy1Nujnyk80x5fGyWJBi2DWaYzvM-EVcO0Y8Kk3tZaOIHPxe0p6zWauGFpRH5LshGlgftNAD3kgsH417Csk3lvK-gvtNpi-H69ZP4A9Sl9FbAkzCDjAIK7Bi4AC492aHIjZ2YsDT5kwiPwo409lP-_otTIYvi-BxbFSLP_SK2gOkGQt0_ZBI6O629w4buJUy1ghoZJYJja082ZCui2bkO8O9DJ4PFEtNaDGfBfBR9PYDVIkLox1ZzAck1gaA04DVNumjKnmhMdod_lhfAnNGbZfTrIj_sBwgaRPRH5T_7J6XITeUyD1qCdbFW4wsYVkq7_XJtvkZP1AyF0nKEqAJZvtt8Hbt5UWIBimNXYB9v1UmUYs4ZlStRVSCfKCNeD1DpARb1gIK8FyFF11kRwhCDGs_ofQSpGyWUm1DtCqaDUh7oYaL67oVcYT4X6XdC7oPSNhne_F3A5DM7xtSm0CooFYT-knGOJ5AM5yfDPy2Xef5VaEPDC9uhhU9_L_e4znVSKdQ6HJRV-RBVmWlKSBOwQYOaiFACMmAgTmx8JIeStRU4OXU46px3zfK_BkNxE4bhIbCisInNPUfRFyrPk1SP0KM1NzQsc6OvJlVOFDD3q4qNXLn2fyQpc498Gdeifm4edXaPKRSow6k0KkqfRlEEHsVfSm0MYQRz0uHsnHKfQlScUlH2G9NzOb4ViigzbgEUn-RX9vSae31We3Q1w6ICpCCoyMjOW_k5nSD4Ldg_YRRBob9CmSZpNnw4IyRRvASZ0bguzWeZupu3N0pNXoLec7EYD8n6Y0veFbGuR4pd_xOg55xXaPl0BU3J8V0L97hOqaIDdKBNL1QDpR8Q2qw9RqqYULjAqDdf5oLomu-8DcnqhmNF2kIq2C4gY-iAlW9DevvATWB4hjNpZcCT0z2GIfe0XCXgnlLM9KIwPktdxrMm2PdcyUo5AvuxJMIx7FiRt1SvakIx_198z4PH7O_A3o0xjQkytPTyrsiFyv7GK9VT7OjvP2UEnPOTLgfzbJmA8rNK4l6O9Z525Kg5P6FRgbQP6RR3b8bexAIvbkIfiGc8XDrXiyrEIiAamA6_TUjxn5rWPsX7DfWYOfay_4fePitJqaYZMh9m1Ks604MqdP5FnwAMw6GxQRirVkbWWLx48KsakPnyPX6CUMc0CqDAD78MgdGSxEiBX591PqffK7QZVPc6IW3uJG-8lTZI56K0D4cAkJ_xj4yTT2kUKzH9O_lqLiGi-Qg9je7YlXGlAVatH-QsRhAW5r41Z_f-FVBpIGogWSabw7qx_TZS2TvewUbJfrNSCcny08q1ETdXjTFP_Hicj7WphGamT0KirhuOtoYImv6kOs1cE3OkGcj8t5l5XCm4Od9diB5M20gQIKqmAKN5QUjtMCVBAlWyWYf5VvTTROPqNY0_NTGh4VAYmY3yil0QEvlPAuGIeZdFDxCRjAdUGUEEAEqWgLYBkOwcp0teUwm_z2pM3dBwkQp-WCEP80Uu1u3QCVIuLZaxaBQYJvuUA8MO9bkxrsIlFGYsaSR3TQLpWmxHj2K4JwugAnbrKx-rG-GesJ3TW9zstm94Ud3n4RodqHe1sueEcDOArubwvn8CqgxbU3lPLBNnrhcBOtdZtulBIagsNiSCVsmkoCo0K6HlOXFxKW9qMz6j6Sy4Umx--M01J8Uylj38ZbgY4c17fVSEgQtn1rDn9nfBnSn5XKzLMbtla3NjiSAoEdkwvcoN68Gy_moCFk-wdh4oOEjA6JuBKKnysRYUB17QeMsxuD-QyulEiYSF-R6u8a7x1rM_iZPKPnbH2hk7I7VTt36EIvcHLYDhtdYba7P4CNfVzAROBtN-yn6rOgZzW5XQ6tmVM_m_UrjUZmQ_cPevUn8TFrpv8hPi7R1HXLG5gmaLit9HS7rkYJRBeLfKNTg5lsJK7VTP8SKXFztFOyWrS7xcHgBS1_03mQpXEJB1NmL2NoqybmoyanyvhorkjO3ymhSWHHYW6TCNbIz3qJJuEuQzt02pygD-aho3squa1RklKfkX6wLxWBK8oUyVQRmTn86Ijrim3aY6crhjeYpOECZIobjNbOYLArF-iOWIG7QslXKF7T_Y6p5PqNuW9xrDIuLvonkksrApzXNNm4HDdy3LAWPQn6GndLV6mqGYxVYRI4IS1ldtUZADglmiVHTKcmAeTkizcgzaMPOMzYks-1fKdvq_QQ3Frshk5ee5sP5cASxg6W_4WO-lKMbDrpaho1RqYBtlOsRCmJ4NbeYd1CTRoTvwOReeNQY_cI7XqSg-J1u0NYLPjt2jQ5VefiFG94-P8FsDHdNacVZb7JF6PSgi9W2yajEBEiuCiHyhVhgTk4gWg2GW7VckD8LS-6NaaNRONcsfDl8LrDpyvQZ_t5ILnEje669UE4y1da5W6_i7QfBROvJjZvfpMv6S8gE2R6phcMAxyDc7eNnZDRyLkDvL5lR3veLs2xz83Bk8fiP2mJNpqalNwi2xGS6R129eQSqmR00OB6blXpLMNbu4L4OkM-IB5YbDyf9L1AvRjfOuMhkgh-YwIU-FETDX_Myha92jh4aBiYmolzNfSJGXHgjllrZqT-Z2WmCRIr5Nre5Sz1nShNnMX6yr16KRVDnmdnWlZ8qbzyN7qaIoddqcHMBzvSTzafXGr6V-RIlJ6UJBpa1nqrgpBK5ZjuMz-N4S643u7o2JDnHis_BefZigVceJLK3H7lB5LSSPPGupphndAHbkC_OvotQ-J9o6ipB6L6Asv6pJHcoxBbhdRBXUpXyHMezk703whioKe7Sm7TZUz7nKlI3IpEE1Ns5sMP7OUrOSLqxm0CzFloAPLHbzegXvdzEFCw5hVYJVmlC_8QtBcWH45zX-80K8wOnEW_gcAOj3_hTcDcpGbrJS9pkTk3iL5WGGWmw4d0_-nlUv6_T5EMLuqzLNw6mmVpmz88AB5lFRANs-U6Uyf_I8pwRv2dNHoRUBUlOtaaD6cD9ODe_BTVnfeMZl8Kq_hTF9i3Tp-C6ek96aAAw1AXkTdvMDiVmMSWrmUuWY2TAja0LHiethNxOV-fDnnfpxZ6LOXMeS3wVzQCe0RwB7Z5INl8CTNSg3eOf3EQme6tQ-wVYh4XqDe1aQbKwCl-Wb9_F3DP31F6rzSnPYu0ljeRF_jt7C9Pz_xVSB8p8vz8esjwoS-3ZCVx7sp2Tl4pA4JuWQztG9Z_Mmyf8LEmCDBl-zdNWh3wZ8rLJlgK3dDP3Z-si-ZkwJWHMnkqlvDsyFxhwA1br0uHLbJTs_i1YEvH3Z2mHhdIXCpBU27SctcxorTjVoaRiSPCmOn_v3jnhNhaKWCWQVb8jsCq3by8g_7ogkPw1NPz5ANfvPGeg9CSx_GqVeNibZtlZmzS6ECLXVlj8WKV1ZoPDzi7tlREgyDx7QuwkUu3pnn3Lg4fa0B8NXv-mhAM1Ilglxq0YQzi2SwmlSoWpHFo6lP3KIUEIrTVxYmMfyohTqOBBZ7Ue7KBiRmiJQBolFofv3Zr3pJTme6ugQwIlpJrPg5LVP0fIOGttm4EmGoWEJ5Pf5jQpl5F2tGvYLhbQ8Dd_3TAVBFuJwBaI_iivaJhn7RXTGMa4Z-l56TuCZAQmfCWnJ8nxr4M6F3PGbD20PmvlVNiYKrkImQgNZMaliw6ifmvo0_KUi0JvWSImF2gCvlmurXgGbk0KYfNNu3WgAnYvqx5N0zcONTbgGYM5DqvkJZjrcKJ6Ad2EvMdO4_jWQDIgBZctgqE04-hCK4yET5B6E9-bQOBFHnEqzR5vk3xfaQtweUj30QhZulH2MRnqsUCzgZAM0urckXmF72t0NG6fh0KSqkUHOE6bLdePog8mSm3_UohlceS6ZjbkzC_pSJpx8RMelhL-c00aKpytT5vsoUthoh26mqbmqsRmHhhqMhU93d0E7jYak2Wkv1_d-H-93Xv0La5Nk8kNw-ER8pJ_-FsWxpqp-xz6b8dj5mzoAU-cCFX1nt3fb07zMoaOsYlDr6IhKL_U6ZLO6aN9rJpSnJov5cu5CmXg5plumA1wqP8-9icSp_k6eLs1BMENf_obu5A4vOgFz3w-m_rlG3zhWeVUTl9niOrGOFcMTS8T1MOmKMnvJewRT8E5HJ_V4QWw9YG_7zZij3iOAeXrjroanezh7hTEYmoyP8YR0aKNghtat73vAOkbz0hEKplRoJiVYc5hVq3Mg35yOX9-SvJdSYkQ-TnMrL5eAToin5Dq4cdAG4n9qQqRO517s7RQ_eLmqDUNbEIhmjpQv-tLCpAV-FAKtFkbYWD-4W4cBCF8rFrLpADZDlxFEmhdO7h0iFiLSPeWq0KTOUNw0Lyv_F4vsx0p3vBEK6AO2aTehDCBvSLTc35dGEsRbfrlacUnl-5YrAul7YfRSWdBgW89EmFy4joHBuNfXUz6gLAiHrZUHuPqmvynUofJRan6ghBU-yLxhP9BgHHZk4wASUOjHwgu_jJ5JiVAXzblFvpldvAq7r14RFX4ezUJ8YR3v2Z3FG5e-j_hv8N-n0CToeWrvBUi3aKCIYN3o5Dr7xWwHhFk-DledyH6imQwN7l6sO5E97S6KhuarH6JRBESb1WA8IFFB1zDu8AdmYfDtqGXJJz8wbmMm53j0frSAGp9-UqzmT4t62mwtlvSBqHL3xw_lgim2R306WErcZiFPU1o8SXh1mAX1b7eA9b7Pl1CwRcRgS8zBgGeOtSGGDyMPHY12aiXJprXMjOpWOpQJ_eGxuZXjM5TzbrjKy1RTzQmI5oHKjmi1u7w0xqxWCWkZBhwLQoyiFNvJBhe7m0Dodi0XFLBmsDs4B4lQQyVfFzk4HCgMvoGTT3UVkhieSpIWXLfcELPpvlnIQKbvXTfbkzVHw_h3uaWFQ8bdqAmoNroFXSXWAXczJ-U2qn4fdP_nBLrK56He9E3yO4lQb1icV7utYR9GUYxDJJEIzv54PQowrKFzHnhaSJSKbdUoMAOGyMxyGH7oH-rABjHG1DEZ1I70VvRt9d6YOwsPXqWJQsjO1PIM5DFy_U1E7f5DdL_s0QJo22Q8FTZ2j8YxLAfYb-cNXvibrCO5nTsWRoI-H5f4rhDo6p0xhpufoURmbKuQIIOjTuLaHlRKHwOW7U8oltCwWhWXIB6AEkddZHdjVI6aT_YiIWOOeaWxCANQNSwhmYNKi3OwKR9qY0Z6ftIhXERKqUX5ceUlHs3m9_uOoC5Yn8aVuAI6hxfSGMF6GVW7JfESWHEzdlp82CAOrKpudixIlPY1CvRQ7F2IiiMgAJRwtIr4utfcgUzNov8jLUMEHrqzZbOjtL13ijrr2GNIovVKACuohMf19t_0Dlg8XgxPOm0tk6dKppgjZAPZtjkJHrM_y_aCq1cnwI9fRN-ZhOQsicndUS1aHl_Jq_XG1UwfwsRe1t1VrBzrMPQTLMhuWjfiDCG9aGXE0Tjy4xKLo4uS0Cw5jZ4C3o9hM8xW_2Z-ApYLIsaqWH277h_L7GSOOq4ViwUa0c5qE8yg7D9F4-bwU_3-lfuMNiwPUF3LjncGWA97rJ2LzxcaM7L-R0Gxw505PgMaOhVTVWfKzqvwQo1b0F02lWEoM5r8USnSwCDgQ9X40T-jDAQPsMepKJ9O142Y9NZPiDhSAj6FQ4HJLtVN_uVkThN8xhb0GWjZV-SafaFZseaLreryTMzlh8LWYJYVpOndaexSWTImYqs3dSI7Hl1mfksmHy-KaxmMlItOWUFChCUaZZjUaO83SICy0dWldGzQ0oXdULSjol0OaFxStCAodWxEMqN-7-aJyR1EHpgO8_iHEilG7aFNOTE739Mn2hx_9R1z0SQNtlqoCpsc38buxr5igMXaDtd-t1eq_YlL_l4Uk9DeFf-otctq56LvuNp094jJVLFfoRO2N5JAV4ews3oe6iFQYVDn8IvaUOC59tOTw0EbJVyEICyCEF5raOznQSo5YqPjgQ20bj1NcrqesYrdi4h4b7b5wxdILQWqMOCsyBqw4zmw7J_H3j11LZK0qzN2wjcq96_ZZZRs0POq5GnDTuJTFscOAbHu1JjZDUwtPewxXtJ3rTVcr-YR3rPXpWEuU5FYG08NQTAiKECb0_UE4BxxjOVFODD5SROPON4CYe10mohYClYUeNSMpgNjOv5QYT2DM7EH-DsRRil8US1qM_F0TcUS1RVlxw56XBMzdQauoXSFsnIdn1e-vd2yaSTxTYniBp9P9UR5oNnf1I8LLW2LDcd7ir3NzDI4uKUr7_kYwDgUSszIiSlbrGPxhdatD2Mnl2kTkXt-tN6mLwQ4J1IcJtm0JiZyqzP7f6LD_C0I9NP-O84HuYcxPzz_DBmhtdVdpbJsiOdpWcEcOpxjqXxF4JeU8rk9AbCPnBOvas4m-KJ4FFNLWzXFkLKDUvopyo-_0ltW8-MV7jGE-repPvijqYaxsp2ym13AGUabmq-WrN9rem4fOJAJj1WFelda92PUHRR-jS3eMqmrsnt5WGR80QjOnKfpjmchbuzxUi5ai1XjvmKZxA_4neq9uyGwfV_kBtpAn4wA0HZm3eqLHvNnBYCgZEowSW5CPeh_yiXhaFbgD6oNjr7XLNtHWaNcasjYMzQKgmBzzcfO3LKo_s3bmD-1amzBTSEKNvdeHrNegw5h6LeWSLxLrko-r_9VKuGkncTZLpcM9s_VMT_QeAAHa7yqfPxhO5ErITWZ3L8IeYq_I40_mRziysnXnW6S8SR7vPdMlfzmDdgpFPHk_yPv1c25HWQPkdzjUZewMAUbiJNyJ0c8TJJrqcZoi8jY3p0V34JlVIcnyOc8PBemuuArn3DOHdUBk3UaB8xewaS2vSfjU-7qx6kk_VgSkXG-CAYgUjGaMVrcGH2Fz9odWVu6gLdqmgOu_Odv8JfpcNmhWxvEm5lDxMU1P9hmtHWkBShlv7YsMYzK5TQ7Xr4DCUkVYj74NW06vH-Asl7b9Ev7b3AcDKGKhmS6XmOjnl1rXDOX-Erz0LMeAmKlXiN2WCQ_yQH7UoFJixe6h3RFWqBnvjJj08g2YVO4NOeTkDxmkOFEV3sJUluYXLCwI0vJzn6gPPuyhFYk2_xvg5sSUznxeRfKmN84rf20LdhgloXTE44HC-IYVT2Uzze5dNRFDolfnJRFm_aIaHgPIO42r2NcbUYu6JrOjVDcTkE2-68Se4r5gNikTrTcwyRZPxzmjcx3YznH_9ulkuYKlReH1lHMeItHp4X6688z_hlBXwUFRgidkLLBI215BMAOUBk5j6bHIuOsjE510vpH__eVAa_oUHa_D-X8kVbRbE-Oteyxozv2mAJDE4rNDAOE9aydVkR4KIRc0YNhQ2BCQtUZLm30z0s-u8j3_9yuqaT2PGv8ScT9hLhyjTeBjWSQYsJfSRVCx-gykVrff8m-WObvMwCxFVegVZ6M3UjyU46k8zpS4yrC8F_t32C_6RjNwHC4u3kC8_d3QBkSrjESo5-eR_wiNyTs4WKXnraE3Bl7nUj9O91KD9Z3iBESFuzPM7rnzg0QDJRxoSOOy4BOgjb_k7IQf24D_mWaysqgyWK-JBYfOIbe29v1F5ca1-xKaJHUPOUL1cOKD3gPDSs9lDm7kkiwhrc9KI3BXX-7mt0C1LX66MX0prB_uBNbhgJnCGwNlWVarqJ4Whp-0fDdYqyz1Hjw0F1mHV7JTB49BTYrTZiTt0sdPR2AnAltZxEJzye9DyIYtUSpjq4I5Mti_MDJTlM140K6Ls47zerDv267Ey-eN0i01UNG6-QumGSoxqHoSLgJpWssbkOYlSH1o9pLl2DC5yyGxBuuRwZ5g0IlFqnnGqwj8obx_RSYmMlAzcnyxb50nvvs8W4NzL4IR8Env6PLSuz0ve54-Z5dSNmnlKUONyMLZZpsKQW8pMzUeixaHN7_KE8pRvmM_03akT6fl6xqyitiGRCJsv6iGaNO7Lj6bTkew5ebCZr2X-b4Gkpvt7J8e-Xe99e7SkwGuYfQfVAv6we3Ql07i4sutuirTZViyTlLV5zmjv07gDzdtACExk5E10J4PoyamfyzhxNexukTA3KuOxUqb98hVDmKiVK_DRk0IM86XvkDzFlXU3jM1cAgi3L7kc4qcq74R2Ifjv1KKQmTLOpWic0kjUIPXIg7vMQmbiifv0C-bR-zoeyQH-2CiM5llw-vPvRM2gdFwB8DT3JxjjzQfXsfkrCG3tD7WuAfNHsCp62duVDhMgojSmdzN3DcKBxvORmADy6zx-sj5MxsAUQvzBBYvtwRng8eXgZJQV246r5sJPmOUdCsPJ1RoSvFsCfBjL8Elgknt16fmP7cvzT0rJtK677E40xGnUMs5c2oGt7CO88ADD5BF4eJpAO1Q9fFdIAbstKUH-WrWcLbRvOawuglWFBciVHA_VQFatSi3k2EefXnbhJN99Th9DTu4YzJrkvUYx9pWQI3-pzf9Cht5Hqsxkm4HrTpJiJAAPTMMhLkwm85B0v7bKgzKjdS1v526vaU7jaulgBqJ4SETfEb2qgHdkpxg5ONg74415pODvKrmDPn-p2XDRM_y4CqXDLV5MG6RtZUEHAStgVstWG5oa28iYKwzKybPT5bTZpbK6S7aeCxcve22LZmrcjVXr1cKtdzZFWAY48sYjN_GkjSNxb82QhX_KUgs_5AbRxwGDVpZHzY4Od96v5A7qAzDCRUnrfLNmTRclQK8sHfQnnBjgJuV2_MX0DlX-K9_wqEm5Mu6gG18WPQQpNPd4w5Ai_w8X6AfaDCzic62Li7H_THD4dI_vefhBt1Xo2RlhusG1qA6aPp5GEvjGxrOJsmiU-ukGhto29EB0UR7JLmg2rhR6_htHlpeyvDHCgbacSWntmvH1Y7n17X0ow3z0MeWaHpeMPOakce0o3BpicMk67le_TjZ79w8J1lYeaCPNgpBy6hgsFdYN9MuFSl7EcEuYBlZoVGrTiE7wkbv0KubRZD0xfBl3oSHrEgh0i3ACP05X8MWsmuPkx-BwenoB6dmFeO_SfLWBvoVogJyEhrR9T5pJnojMF0gA5FNOzfVP9NPdtxzmUohM8r5OVaACsYWFtfOfhjUwE3k77WHfJUfQIx-BbyQJcyyvqCnxBad2UNN5s3AZTOhTEYh7M5Y9iOgwJkV55hmiIj7jhJgnfDSlP0-K-jVcg-USU1HWBaJjMQ3P3Lvd7bLP2g2G5oJm6kOq1KNyt08Dynm9IQ5ADcMke0nXCfQeXMuC-SGQfY170XdoVcMMDrvOicTHZoW_QCXW5xVvcqgOJl02GS5UjVFugYkb-1qEPxpZTAn7ilLYmxUa4CGzh2_CY1TUEoeMV4xaNiox90qvc_EhYfpJK2caQS1sdnrzS7T4MWohJwUC-y2pFbMF5GGPcBn4oSdFXQftl6HCVdYlRUDeW_aDwPKhRQaQgwDGnljVSUHjXguTPwBK4G5rDf_fC8R9neEg41OWGHXnhPMelITGmyNfput1qRu6Edg3vGB1QhowEU5YG3POwR3Aw_sh0fsRTn1dURnv389rhHSn5Q3sxPKP4N6LwS0eMVVei2HyZyyGszhJWA8tkCIKPYSVZvjWXWNPiozhzE-33PECU-IZbjQ_wwIYnuYgBb1iRZtV9LYLZue-bJCBd0KThshDa9gvNCYc9sO_A2A23JDV8tkXCbH8rv7BOZLSQZaLIaqBnQXylFEzs1iTtAzydoKIL9mC5FxU8EAKtEmQ3JDtO16_t7BR7IFBqkyYBYZYPJ6uaSRy2wl6YzeaOgco3c0tyje-MYW0qH1AfYIY6Ja9Bl4JBpVBWUM_vux2qOHquZ15otiA3F2438pMfq-18whdjPgcv2aGiUXKtwLtBrjlOZl06B420ETV0ZI77os8rpVadeOelIwjVFhVmlMbDun5IpEgXJJF38MniTOFpwDtgN57mX0jZX0gZnP6OQ8HeO1ntxGEScfgV9CKKCVESnJBqEhR7msHbnXKGB1hBhhiFMdA4XuDwdZMnrGKDPjA-lqJlPCb4wEqOtvvLFCeLN1HfTVIX89aO-5qStg0NqSksSbX6OHbN1M8rkDDWEL4lIrj91osIlt0345o5LOg-3h2R977kVIvJwd5N8UPo57I9a6ScMjX5q4nDEfHuvDR-f5VKzETWjq5SmLQwNdSCTR0wAub2P8qKZpyKaSr7o3vsjZTH0DPX1y4GlSUuYhCELgStC8RKsj6az7wZZe4AWaIlAXKBCFijdgB4cWcNIXae0zxa1hAEy0yqTBXEo-uI7swYZChC85ASdfAuStgJV-ToxyjQ6UjazZq5hlMBkHWeTGo1MzP68M7SmfWzyVbXruiYqztWkDcipPnGDTgjwd6InUAQxJuVc0JzJm32OT60gxAjvYy6RShGk5YRSEBxaGRhUxCqy1SDrDq1x264R1kHfO-naJ0uLwSP1E6oJW_H8g1r4HR0dZLBtGRmBqt2EWvScutXjaosPgyprsXXX2x3Bn6yREYhLWn8UpBgQsaBm68ovrjUovbBBrEH549eQy75__9sh6sAEDzRa7qkP35X_up3AtB69LtqxCQVGY1YBBmx4u3YiEHArgLmNRHTXoBMY9XC97Fv7S_IX8vS-O95gClcOqj7HsnXDMoqIgaGVcsZ1qWZSPktD55p8GySkp52454Q4x4uDMgs9xvY7nZFc7MynbD9orBsMKK7gGLvaniGj8nuxILLqmBnsh-6dtSKN2Qs0iIFEGfSwmtYtyvUq5kNsC4-ln33u9MILPF1aleQ_pngM3sJHVknlTRUOyV-XsrDCCEvnpMDGvvi0MHMoBZYrx3lZWa5LBZi9S_kjV_DxNFOqfv6IaiwpSPVOqFcKbMdDSnZjjgX_AEn46OhCqsFg8Mr7QtnVvtHX7FGBtR5yO8xeRh4uARHMU6pODKMyU8pl_YjTTgB14HcZ1NGNTSGnIkV8Xb9zYQ1InP6FRzkY-Vn-aS3QrmDzLLx2OwzH3QwG6pcuj5uKaxmYZcTpruk1lW0pzrTIMwaGW5qC9i5GTHzp_lq82XfyiCLocIh0FHIW-u0xZGU6vrXPX6P2py-vRiY9D-k1Mn1LTfzDoxnCD4S_4tSx55v_Zdisrlrxysn1USQ2xZGR0XuZ1XI0E-VsIq9n9lgzlYdrBt1DIjI81CuXKCcZpgFAcThUxk5mbvUufLa9BzhyUGrbSibWIUd62AiZeoWBphamBOwcdTY7YgNumvfGrrVQ01kSvTATheLJIIox_FU7z32d1q-XM0Udmm5w_hwib_VaiyKlUv1m8muZhfo4QZ7GUjJ77MuDRf7VmDFJh-J__nms-s0efhuvwS2y82SChE2Uo26bfSSgcY4K912i9RSjxu7VIhZGwgQilq7tNwMdWh4GeRaZCFzCBO3S8mUfE5wJXKBViMQr1attTRGp0uGNgJT0BwP-qYZmLxCE-Rigal52eFt9Z4N9y0LtSW_-2ql8qZfI0V6pS4Bo17UrPd_otmAuA8WMRR-OODByv-erbu956tc7Ep8E3R2JB1akjKvhH87sluQilT1yG4OyMwYEgrkGULWajS0I6eu0BoOcGCbKsiV2dxVTMEmlCwYsPuxy1D_Qa1Yqpxv6arv26Xf5vp4JUSyNsvbIKhg2UbOw-Jf8Nm-yiQvmElzwN-9Kt_UOzjDdlzM-WYYqdMSb8JKbXkkCeSIwXRWWulfQ-J5u_f93J0DwYrvj-XljJVg60BZeLI3f2J9NFUfDSQoSUS5_KI2CyIPN4BcGiWk69TjYf1nVCHhXn0BXtvrSw1WesUY9CD1w4QDeSLFP7EQY634zbZD12eWDQMdM9kLZEgbxZfUs50-TVQZ4ZO5bl8eNrRV5-XQ1ym836-2o9c7GhTIHL8BtQSkl-B7U7CUN3T5tvPUecKrZJ-WrlZqsq01PPtECdBg8T6CpeykGhzTTc6GdKJM-h_tuapfhrpWwhdRSxDeZurz-AvJ2pBX8jASm7y2rVz7KLzJWUZIt09sN6ofiQ7qeTl4hM2erg9gQK-URzIZQf3fC84ATNOSUFwy9PaEZdkLz04HyOQFHQGeOxD1bMStj-LHOupq3CkBs9MX-2vyNW4onpSuqomOLCk9SWipKbUQVxQESF8o9_MSJY94lXS5fgEpm64z_B2qFLSzfLRtusiS1Q-gwdVMLk5CXo_tQZVl9bUpWg1GwNCBHZ6zcfB1GHqtHI_vJQA1-YbnwIix2_-Y0cIRNOHQAjLrXQrRacIbtqeUkio7VJNsuosa6r1XFP89sELGZ1RTNk1TEjZEl5ABdQ3uaYZvp_mSi6sEfdEeM_PrCcbK6uVK9zPhi6CQxJeAL9Pa7GZEyWszGdaft801PMBjuiVocx63LEkTTBlzVFP409MIWtBw7aqnnh8WGu6NveZ2ToV2ccfvvpHvBsDg9WcvCevzCyfh2KcFfUaXang4gKxnV3rleKWaR5NJ8X3wAswLI5RYSkLwpz37wNeaSc6CwLVrpPujPrbyAk6eDWwNwbiht4DMM4OVSgnDKWn8NdwMKHmkvSRiv4tdrXYOqHaaDbx1sITX_pLk-Jwq22Juxdv4fZFponvb7timcsKiGPs2sUSrnkU9BhoJCYiuyGUXh4chkWSy15nD021lTDrV4Tft8k5vgHtEAAm6OHPSvVHFl_8CeRaIuDLYwLEWSIebLtEW211u6J8vV2L1iQKVRFCPPGNk4sFgWjkpE6QiUdICZEixhs0jBj2VmC3y88DFgcNF9S-fehK-urMZoJyLAsqVSZS4pp1iFT1xhZ0Fv83lUwBxZmYraNv0s1UNojWLCNZjpPxNsIXRNlJwaRjo8p5OmDcCiaVzcSJXN5Il6-Ky1HgasSJOnQXuIDFrrglVUQ0E1j_H333nuKjYTSqfMWNuf0pmgobw5_6zYJTxKIpUni7CxvZwNpfpXHTE1m2Y46BupiUHaGLxYEh1saPHEwsCdxzpE9rAfdtMvF0GRCIr_8ahIY4xHqjI5JWpThB1Lk_UsTJcTrdc9YFxc6w4f0RfZnFzBNKtcum72ZeCAdpn3uNmHtrrqSEkpaQRVXNSdKc4S3bZhyZBGtF2noDSaaGipZEFVMJHa0S48qpcBmfSmPjC5mQwYZeeSova3e_ToEmRhUafEriEGp8ngWCmEEFXrwk_e17iRlP0LT9UcwxiuyKCAi6fu4aMO58e73H_Igtdo6E4UUf6-iqlxJ2KuL6flzEbmHpU1VUgdQYF7EBIWwYLElOdOYVsrwExkTPa_1FJieNvy189cW1ILW6c2A32UionUuSb1TpB5YoeA9s1K5THsFuziaYNUE5LQpBtavsKb5oOwfv2obm73wdz2Srzz7wg8WGtmtFLhc1ZC8UWlsfM_y7dGbLzx--fF5S0s2mIIMRDHNNm6S5Mas5WGU4K_GqatQuYSizQLEldIbukyfSpzDsr2TawZZ49Qcdaru80X7zPg1gg5nA6sPcYnV5Vw9M8-G_1_lhzXibxda39-YmIJ3iRpGpTh2YIHei6qQvHMN4gqHRqcuFF03N6vMbQq_zq4dCfKH8dHS0cErgIehK5-JncnBLbcwGUGQqBO8QsU5ZEeoxPWL93PK45uh_b0qMSZWuylMb3BGmkh5TdptQfBDZ_hqQdGkFGt3rmedpbbSkPN84Eg1ENLFI_MEub1tOprS98xAdVpn7J0ozuuSuA6eZKJBK3LbbvONQQ1zkH1jdRIm8epiMJhcJhXTmDhHIdvgQLdhHJghb0j60imVE07ycOGXsiUFpYKQrj9JDh_AlL1jQgkRTQtYuRIECnJBzXmOqCDxiNRqhZLGZZHTA3sfTZ5iWRi72krswg3wDB9fCtaxIZNkMGGGFA1NnnP2bgeCOKjOUBxJ6jd1VxKEPbvRLJy4RqZIT1FVzNQZgFDYCaAU03-1lMIi1QLp0Qxjh-9irODOZVKvnxP2E30BlikXM-rJzLdo0BSZc2L2NHtMOJ52GgAVPzK-yKXQZDBHkunh10C28NFUPtZ1D-VLY5BBhtP2eDYCZo7UA24pn-xLisWemrg7IArwyyOOhhN5SFKQ-gPEXB-gR8pOFkfvNGkbGvyrv5uE_1NswVG4c79j_VL_AtIF-p7PtKYUKBdDOuLuELQ0ymPfHkyT7X-CK-7TUhYJEJHS99j9P0yY433YYO_mmQx4pbe3DcfAHIxvWGxQRyLgM4jCsWD0WtScJK1Hkuat0x-PN9IvTT0h4HbnV-PoO5Lh82hiRvgetz3j4xojaSnuqlkorAkI75AiQ0UkgGt5OESvZylPoUSy6WUrrtDoLT2yJpG4vBpIDmwZlwarF4t-0scKhkJHiH9VWZSgtSEC8Q4zz-Ayen6EO3KlL-g0Qnm2dLg3DBN9fJfhGKbHp5kMO4qhS47Tv7I2ppAGbVoI0FAry7yAqDHoD27GLxcwjPZ3R5cVL1SjtJme1egO_cnW0FJk0DvidGvyFlhPgm_FkTx8k6vgpFJamNP2u6Cl5x3Dwn6NflGFv2Vu8tAUetUiGK4jSG69bFTlbVn2UrPEVPN4Kv6h6K4vG5PZgkgmlIFcXVA4IBWqzyr9WmduXYSaYIjg-cpbdFnDq_tNnltJeVI8xnhUElwX-fG9Ua0dEXwoyQ2LjhSp7joSAszF_RCjdcT0nY3YL1rOLHJpSzBeTa_LNSTnk9T2qZbKd2llbjnRT8lpi2-sOlfuWMQHlJpE3DJ1NbAndrfuvoAAufU2_teSRzq5EbslzS-0KP7osLyGLhLlM5U3sDJmGKEYj-LBlmI-rNxuEo9kjvDOaO7YIpGHOBJAD7DfpRRPd71J-pnarkuOjb1LEMhungCU5vASQc1bEkogMTiLYk_-eFCsZQGVbJqlXmTJoH0ny60ebV8vsu7HX58eJ0kRlzcqmCrpW_rQ_KTUz8cIOgDkfiWi_1-o1SGvQUD8fvjF169siBr3AbLLS3TzVZDsgQQBEWR-dGzqv15KUZud_8ZvhJWyIdGiFp0XJw9iIbHngMG1dKcFgxYKArs5-cA0vrarZmZ6JaWDmKYgDia-0NjrA31Y5mWpbcjrKSrHZmTAda40iJsLXc1HZvLrcvAqHgbrXaBH9kQV2Ya8jCLloMRoKcN4U4nCbW_VKukTaIa-u4lwrf3Qxq_vDFFhMrxz_kagODPeJHMt7zUj1jvswaRpiUclNyi0QcMqJW2BePmC8T0vqZTcngruOYJNrXcDoln122byVeSoBdEKpZk-LKjV83wY7YqBNyHcQd2rtTfrZFwpkbn89M6PyniiN1jfbGh8THRWC849vIh4kXGhmwe1HWtIzZGl-VDyO5fvBlqsqsuV4q4ebUkwq23EFNbMQcTJ5_ZeG4Fx_Z0SKSLJtEugVHSSPMHTE8HXZ6MtjB_bCW_vP59Vt1NYlfMpKGImkCbZTHfJrJS0wIljM4xY_tp8ngn0imfcDv0DQHBfyPLNRiz6oO25Db4y-eBSbpOAYkFtVJ7ZgMzN3T6w3eZ7DFy6-SGxK855zeOaWyFpaBMTMCGpcQOIrRxzNquJaPokqjBHEKIPx3fiUJ6lT1xiER3b2hjXrr8NPpb0Tf2j0o-e9ER2KSOG3ghV3AlMdi5RIl_oYKQtNtm7LcPzU_N-DBRU0uupvQ4lRib3J35pCDU8pmhMALxRov-qDW_dSpaMEoJQYz_V3-HdwqMqc17sB3OuiqWQAbH-M-P_GNVaoqkquXeX4cJDRx2FPQFDgw7UP0I_SAWHEpmYFMfvm7rAK7cyC02y0phoioElijWid0pSgbNizBQwXO0HFsu7ibIUeGkFAZ9vNjfKWk6C-7al0WH0GpjOkub4sF4hCONqnGwbtwlxk64-XW4kpHKLGfV6PPYkDvXUqzEHqhkZBIoQzEMD8WMpdYk7Ld1-LQ7Rg9bZQr2PPNIpBH2fnrlGu6uEE41cYCZy63PnT_ZBQXa4ZNRQjYjEiLBRe1mAkJyeOl5QUZaUkUwNN2N1B90-wPmOwx5qnaroxG_mkJY4phx500Z36FgyRIegj66JmXzjmwwm-VVQGaBcCfJ-A3kogW3nGgSSh0mVErGdvziFlKK0SEpyn3asUyyWD4VU80gHIXPtlsZCqxNtq3iwV1fFilGbXnQ2SZ2_acYu6FIMEZztwZg45nYBfxnAKvd8MuOK55WwxNJmoUyvsGZASijWEKz_bAjnXew_cwYSVTBdIkK-Bt9ShCuJ7k1hAWecGVxcPum3SLB8NzmrLsQZsfOSVc6J_Z7VbcRIyhmkfgdgSUmz4ndOdo7hJVdyNM6dIOuRbw1OiiVdHSaTM4aWUFwbrWLMuZrduswHRgz80Lh0pAOT-X4UyzyJuHIFCUEHrTvXj0cIPdFhDTlGNvG9w9G6rXiKwT5VwykeDlfb922rw-m4Oio70B9UieMBrETh8vQCxH00aRNMMREDH0he2yz_lgrngr0tXuVYCHxcKNon7Tzh777R3XmJDdv6NtKpbzKJN1hZL3flOvkapeEVBMu3-82qgGn62e9vJ_YVBjqlT4GQ-c5zNVbpFJCUHPh7_dYbjmS8_mJswzS9MOP4l5UJmENxccl9HtoWd0aPAv30A6FHZbXtcJ0Y2RFQwXPIVKZqvjLSpmZaWmAdiIZzHin4PLYzaIrCaTOYHgd30lHL5F7RNkAvSgfyydfUIKPG2E63XuVtfISjvKz4JA-1UUCIfkZlrjmObkZZmU9NbRMmNaAps8pUaNK0kdeTg8Cen8oG4QQE3JRBUVmf0c2EA3zBmms3pn47ddORGBLDXoSTx6DG9CEj6ptNkKwqdXORF0wKvCCasmy75kgKjYUsPmWcT7iI3a4qq7FdTKHZAJtu69ms6MFmFnk6jphyvIUMfZ_Zcr3eDhpppW_F6sf1vQNM3Jk2oq60o4kzgREaLg2ayBh-DfJrECQnl7XpAiLbU88Ul4qqwA1dhxIxKPclCQkZ7LA6nabki5PDcX5OVoa7Ed1KwkM_rbn64qsfCN_kmsQesprh-0lUBaIGV23PVdVt9avCU8wn-qQ8L2ADKkET4b6pRECO2MBhr5R397qBELARDUf9EOjDaiMR6qJ2TjbAEvTF9ERLY2RGEesHOFXg857KIqY4oyZwef-BE1lgxFm5kgU0x1CsfbIGgXgjjg9HogmIbw1hEDgoVPyXFzYyPvpXK_i4RqiSpyzpcVbUatApvNXzWBRZ-v_ivAmg0-qumKtYYVkfT6ZUT0VD0JQ5ZSa6X7BZ04eVXpB3IELslK9zUFiQXEw12xDuejYT94OAXasL-5aQ1ZaSraIpWE9N_c-YRRXmlErAxS5z0DIw0thoc7-daw3pn3ns0fbsgRo148eFr_h9rD1n01R92gOPytEPcLZiLoESiQ-Gbts9qTfvsPmFT3yBsPbU8cXBKFnfLCewPOTiRrbEiPKzMNpbcwvUpnomm5cn1GrdCH00araVxHZLQx8wSt6uzkoe-a91x4WYwgh_VhdkffGg7_3I0md3D3kZ4ZT5FTYncSYF5vgdGIfcWrr55mrFOudtfkZWh2ab_2AJSI_bQbtfuRBFY7dYeRo_ix6HfiI4z-2T27CRvAaYiB-WoCUNmPB2mw5-I1baZVD5V0FacWyIOiCBiqiFgUYdZkMmv8GI9Mt_HyP9uIqwC_K1FoyUihRqV5m3VARwf8loGtM3SHOQ9SMqi_JUEl6Rww_BF4eyqBK8WsQIOBGEpYT6ORmbaP95S9Ntx-dmVlRLg-EZes0vwnQgAEF3fl1OyinWIy5eupj45jZP9fmEZxmQ7ioBRgvqUMBqabEr125N20PY6yC-yDaIyL6cgxyfxn077jiu5e6-ibIt1mtgGT5bQGj8HRbIkT8vQPRrPDpqElaTEmH7t9d9fsgUci9GpQfAQN1i-TKfoS6PHFRmj2sfbFD2SoRpXZ5Pvt8EcoC5--aig3OYqK5TsF1BhlYc5-3GeJpbymvzqfMUhYx2x3EI71tFXj_ubFqBIjeWtWPXXE7qi23PTcgdtimBzlVCO2PG-Drjc-TMbmTJW4vWpTlHkoax7PLTWAUMQOWztSAhlra8zDUpvvKv4OgBTRqy1exJbZ1BKsdhwpznVpp5Y5FCoHDQFyNmsgZpiVDRN-w4ReJTrEOD7i55k8MEmlkgr-oesnQJipGSffFSqeXno7fQxus1iHUJ0jVxgf0ok4kJh_i2I8ALBdm1XHG1v-bsPHcgzmw4i_WhjQ5W5yJl8p1mBmi9d1DC__y1HT3x8eS8o1BAbkfUBo6SSo8GCfeOdjDi1noh7CZRH7cZzPX2O4N_CQAHNe0cRm2HutXPUdnp6BdAp1Oli3ZDtNz3UZ37f8JEaBMfUAmORR0y9mInOKmqYjbqtjxwLzXsx7ivIDYMmGcIfQlbgZwXt7SMzjgCBsIaLr26p1lhyoPBwZq8SgxwqErbswB5_039uWE1r39EEcgrhP29irvfBRynRQO3rn4phdl_mb36bhQUV1np_pIQ2xWsXv76c3WO8VxkbRcOtdCnyLLTTt7HrQ4X6Qy7Lboap_7J9wzHRiJh0gKjW8VEjocMKQZAKgA76egscNTLTKe6_pknua4DzSxPULFb1AKMcdfSr4G3KrK1Yb6f0To1J6JoHG-rw6kIb1da2Xn0PttlU6JdwtFu4j_HBlgjN-fqSMb-OYXkayUe55wW71A89Bcscq_YhK1uWvTCpOjtOd8w_-4GpG5JYitm5PcnpbII7Rfod9Pm8zwZFbfYn-DufK5Tv1TRKc6Ao8iAdtXA2Ww00BSVqKL0oIRfRyGG4jL72lFKLUt3NnHtm_Wi8J23TWi9JxD3hjChQPMeANkom7_3ThKMpJHybKR7qbp9gjGG7HeRKylumw_VfrDArHpXpYAS7z1KUlj49GIMv6ORMg5eLWhYCGzEQX9ahO507i-f9Glb9BjhxL6owmjErsGSov0Bow2QztdfiBQgeg2HJhPxccC5gpGvxVFsuxx4twSI4uF2Ed6aJrH8VBpUQuZR9vENsH2Y3B1UO4r6vNCvxzdl7FFajC4uWPDe-zfgY5Gk8rwW-Liin9ScXUmmHJkZQhI5BCnH69aJEpG8_RKuPu5YlVxo4dgyAxv6mHG8m0-130HOo3VQVDuHI-uxui6O9UhFKJAnEFvDPBbY1ONSLD42OaemWlFEGM-2_ZpeZAet6i3WgBAS0YvviQuasutTDcGV0YyPVh_JOcv8HIf7kWwSESNgUctfk5LwUYZkXsg-_fTAvLKWBXgbCgQ-SzE2esYmJViEwCp8efqCeASBjrq8ZkJZneAdDX59L8pw_c4PBLyjDdcsbM97tfYwm9p78n0KbELXtNayWGuns2ZRwTKK4Y2MvhPE887Zhc4rwXCvIKpjw40qpbu6TOQ7Qk37WjF22r4P_u6zIrSs15S_SwDBlv4TsHRd6w21UhhcfYeJ5RMMZSoQdViYuvCHOQn_qN1HBxwZJiTlvPmPdD9sh1lvE3w_MpZFM96fArUpJnggnZXqBqtc7xdmjsZl0mEm_ENFHkIjW51xjpiPd2kL1T0y3jEh3aK-opc7LZLSs7HfY-XNaIskEw4UUc83syl5GqF7Su1MdYRksrptdp3uQUCU4eC9jwLVsw0jthSo2WjsLa42Cx72ZJkyvrs2j5puQ2-RmvA7DpIfbqo9uCMddhX06a7_ZLhyoLoe-9JxpmTE7vUbyhwIXc5JX1Ef6hfIKFkl2URt612QOCS1JZQiWq0Ee23s2VEbPGnVVmTf0njbFIKpwjAjYTL_EunkMloEn_slFMaYnMZhPucAx1fCdsb4mgobSnjnX0ILyeKovMAliRyl4hKGW2Rv1VSzgQsSlXY3g5fvOWJuZaoggNxUw2RHtAeStTVIkyFVJybTbVXRs2OXO76Lg2XlJYBPVkfj2tpory5nrD8_AnPgwkWJjziufprDe7kBobAJmWith-wEOUaMo4duIHN_pIbeN-J_f8szHvT5mSYKfSvWxD8jhi1kOEv2Q0LhkSDt5I1Pvnbo1-DvoNJDbo-FFXnJg_N11vZMTP4jXuByT9rQGEmIFwBCjeUTStYBZjRMpnGSoUsyyTHMJ0o8dTxCShqZsQwrOtrFzSHry_Vu9RoNUuvAKOlA0YUeGXJ4SfDlzbnjy8ghrMPwlx3HnReDah13Td9bVM-iOll8HHlBGN7pbEZUEH6BV2sFOdYgNu_SXePFui28rbFquAV3GQ7OnVpE-mC5uHKheQvp6wfFdlPE2XqgzTCV5AJltXVVsUEV0yZtZlGKmH3AH9lcXUF_8J_x7XolQjrJxeDXw-Asyb-RBEbnrqRPIcPqQaU5CIs4T1UiIFYaAJF9NgjM3Mf_AEPgHLXWBcKZZcfbYXfcPt8oelrD98TFEOa076oyP34ne5Q_njv3NIvD0jvpMMYw_jcLX_BrlgCbK55npqn05EzaDF6bWuRnYxm8RyhIVLesN_oUacm5Ah_uWneBpyM7NwACvEbw-KiAUvXyrgH91ChBkOyXFAVzk6U-VTPDMKZ9399pgjHX3_zkTuBmS5juhGHNbaMVBrK2DrUlW5WGncv5LB5XZDEjr3825g4aW3jTcQ2KzqWcX8xTJCwPOhKeOhR7BaYxrXEs2eqPlOWK7vEA-oMR-n8RMKnRENYI6G_NhRCQxpyanPP2Sz3_H9msmyKvbQ_y0nsXmJSzk8MBdM5qRaAcFBp62mwcXtsVD3BAPglNs1brJDGMyPe3eHYyhqvtRHnX0T1q7sUgLfu5cia5jIl73Z63Oc31niFHukY5Nh3PrxBz19bjgBzQGQsJlTqAOwHpM824FvXbV-ffeN_Jf03GqRRUMkRg3zsGb1RWf7y0q6cxp8tzelhSEMml7Tnz3DVSfh_13jfMFzv-BRCttUj2FBT3EzOupAVgD9h09hGzpUxh3C1CHsLkoUZmGKfTCPOc4RLnNxJUfI3O6E56Umi1FjmY0sgiVmexnjkTqg1rIYxk8NmuerMzUuYGrOsMw7LqSgxAtL4l2eCOIMOgrr2rB4IOibSgFIN5jbBYrAcDPbpNdv-4g0x_xJqmE1bc9PMu_YW8_guPmnL3JA-YI1nOKtSn3YbkV9f4oOjimKvgo_n0XuBstgHpwe6RYAtq2vIpzAyAeAuZ1Zabled1d4GmTmK9cxe2iJziTw1KlaaeU2hM9ZXAJJ5jqjq-bXS82tmnVOifqrb6fBel2QGnUmESvLqKgdQo2TR8adjqyz7THZrhGpyEfn2uagMHc_YVGOfgys4jBtWlIU2nrzmWIzdDfnW81UxF9j8pj1fAAsV1nLIictgxie2GNgT2pdP-BRBFsK4zNKgvD9Ed7pTiRJmipmS2xhkTT7V9WhUauKy8_FSyqggpLjXOYCtKViKRok13_W3vH7d8-iF-E0DIEHsxw1Nm07HJEaXhbdQUKkRukeJpFwoy801Cflj6Nuq8xJu_fo1y9fXEkW3WKxCoq_zz5-Tk19W4o3pX1H3odewc4LheT4YDNksPK-x-tmvyeRlcGigWhg8MxSYskuQB7GcD07DtAh27VZcn2imFmod_vsGwWgcp9jRy2pza6qWuAILCWHtutgfYK4OsRlBtu0KD2c9v39v3STrCOsqqF6UZfSx3EXn9Yrv1Gk64OCj_rSRYeAaX5Zhlmn39yvuqZrYd9MIWP4Fs3QNOo6S4QzyER-po53vzyfCsdvOW0cvPzdgM1GCnQ922lGQFkdDU6RRDNuFStxKExRYnLC3R_meIedvVWNzl_nvQYquSpbfdsx5165NKZHtWkBdNAKsokSOV1JWbZZy1JFfh6iTX4knmaUAlIf3blr7TsjX0DbLK6XHIZOxkOz7I6wdP1NbL9x90NIWph7siGyngHN8z3tZmbIXbEQ1kFvY7ksUCPT7r3zeepNnc_2i4hp2S64Vt-b0Ii7aKiDEjmqSgwIdyTGINatih4fEVSL9QNS39wTG27GFW2MEfmGz0oHb04qCB2K7G_mSxBr1X_Pv2pxmWWzjr9Fo5LWHkc6pzbX7m2CJHDILwQsjDi8jH0CoJXa8UByyx3l64Li3MlF71kJ28JFfnWlserv2dMhAqKykl1BI78sJ3vBY7xYFXOuHtAugpTBI_kdPokqY4TXr9jdkdyZxBfzVMGKOwYEcsjcySViaZk2J7f_8JUQqWByS5vMxwU18t83IWg31vOH8HLdAnmLwWtNl0mZqMsYDxrJNveJtoh8KtDFt8vTn4Ta1Y4-wZTFQFwkIFQ4pNS-p6H7jxtrRw9sF4TlODQXnOwn57rQcRzpBKx2PxFE0puFf72SLEPMARGbWXYiU0ul8udcvFRZaYD3aqKfKQqxIki9EXxTDB7z9BShvBs9gRdDzEiN82MtJ8fsPZTDkNtQgFL9vE-lc7efP78YGHl0YpCf3LxDVIZYQb05usA5KETN5qMIoBB1hzx9lDYMbOQ8EdvKVFnX3HmS4dOVcjM5mP1ayP-YK8pmEph5xntd3bdtcHibPXw8yWhj2JlDptK4_rQ7GDDEfOyl98-n6UPZSufII9ck5OWhViyH0f7BQgDCKPcACYMDs0DKm_WcNWsKXlQ0jrkbmdYsCG91ZSeJhV1wP_XmbLhA5GgfoUSGqRd7ci1Hj0oaPKysqDzapWtsktx00SwJ86GaODAD5T3EayfbhKfcc40renUqHHY3Djv8rfcR71A2Wr4AENuSYiqnZRtS4P3iVI2uaCZ6QzuDIlUKgKWc-WGldZlBqk9WJnmxJ4Q9GLu7VxzqzzC2wXwdCEgur0AkuBjGsRe6xunCEGd_IzT-x54cGJ9lmGy7TtjIfwj2mC3C_aLIktQrYo0n1eUho5iIeyCuMWTa6_gqaoXDPahIRtZNw6oRhJR8qOm8nTEfqkcRPYmmjwQ0zVDPPsdX_bTiXPgb62pD4I7oeBq0ghV_zXtpLGWn7ibDQGaHGMvniP40JuzBvSYhfOfc6RKmPG6aZpMMcOff3y4ll_KoOBAURzQhypiT5jCLah9uIAuPVE_lpX3SvOAos3CjYrVVfQ4yyoJXO6xAw0XiS8Ra7AqFHRroF-ZmQ5z1j6jQuuexjyPzr-R4J4IQ67R3yeyqGB9kvvCmnIobYmnLLTIhh-yaUZN7w6cmYsBWN2jIK9U3KdrelxMj7vqqZ5MPw56Sa5hC6tW-dw8OTXraPaY5S0E-n7VQnUzGgPy0hhtLQHMoXt7RbIpmEXrpzn8NbojWwMofr6LV5N9L5ubqh-4knP0yxC5nKpmYcGoT0gtXUr17LY4qRs8gxaqQFRPfSr8ArXB5XfEB5Zc_OT4QdxT1z-Vcd7Wns-ovLuS8sWhH8oyPw17vDUv35b7B69wNFoBPgBD2mlcm4MPOuO5gBfRcZwaDYBR4Hq9_VENJtqBljdHk0AIMc0sUAq8peE5Cj9d-C51arWMfBhUPg-9o8cy2_xrp3SCpJtiekdQYU8EBxJCAo05iQAU5EY0ACTURSuWKtDCDvnL6aPqLrsW6_WuWBLaZEGsn-aa70CHNy3fnBlc_UFZ248IxByVFLD9_sensR2S6_rpQEUy2SvhifzQ5bgTrd_7TSE1gsOIZ0RCmuXIUArISnKbQKmtDSIPyypLmVXn8GnnEYvvcKSinU1hW9YMLaVgZUO13FTtjJzoPCN_A5efB1K4aCyn235td9tcj7wM_hLFqk2ZkILR492oDc-L8qsq8LOY-UWOzVf45FcWgYmQ7wrbqeC4J6ZGVdMgn7syrWaKiSlbGaBrGJsr3QjFowEsAKgfTfsPBLXV4ULQeZstBmLUMqj5Xbt0dWrPM-mNrgQAeQcojnovqKQCfFbYKDpP7zrwqyT5nuJph682U_6cxSp68QrO33dlG2FSDCZ2caU0-8Em4vyk_1krNJd7aI2BFYp3IuDFCVTnTIE2NTn9cSPPZ9FPFfTAI-_3p1-YcCZVL0SIyAHpt6UwXP0XoQ6rg2lGNckqtD5Fd26OHpYcHdcB0QCR0O1cWn26XmmfoxcA5xr8G4K6Fkppv1AoKl0JJMWTO0648fVVclalSqy_p_caRGfe_PKmkbJLiPjGi3DvmerNBoXwaA9jmgMBRVNybPf-A4we2r5FP5ORJLNDbB1MeEEQw43tBS_Fm8-c2KWe1NMGYuJFp1L8sZskjlmgWjtbPIExXLOtur4nkHAvI5ne0bMD2u_cbRM75OHRAQ6_X7yEXvl6yNkUY0OzAr5Iwmjleks_Nh4RP6iMxXeNkeSfkhb3wxRGRxeL_c0NbclxuZfLDNfqrF74d36icNpVWl4S-yCfG3lE6KmJ6JeI9C7VdHD_qD1ktZCGQrAAZKpKcug4Unq0YTVp_ZHbBbQxxCwMPo7Q8Ng6A1vW7r0B2tXCPN2Qm4G1Pndl_zk-sQZ8GcfGnVsaIEHELJqFI9ImdghXmXLgRs_IZ2n2AjUl8JdRTo5OS7iJA1Q5PTfiz8onm8aRJUiKLZ9V4R222-2n3pzMX86rCAeqNFsJLk5NAYFRf0ZuNQ2Ssx2VxwhSdYoroaqUzIxI2lkTRLli-ZFYvbVApw21qpS46Nszh7JIlgj-VtQ0ER-HYLP5vYDP9xCBRk0f8Fm2sfGyfq8mkjobCRD94NosZ8MplhE4CPtM0trZXGaT4UxWOIWIBmCkHiEu8UEOywj9ZPJIKMmtULAjvZHH2u-OzZnZzPYXjVmpCBj28aYksImNcIHlbm9IiiRor0vYof8FOLIC0Ru6_ejR96IH5s4KyizHLWbvJ6a9roXIYib7HJAc-PYkoB6QQBUFzDhT9nB_HRfVCYD3ODJQHL8dI5KySeJ3fwRhG0_AvpOmmJ-vpBffVokTwLBr5Nm6wlDe-Ciu9YB158_PA9UX76VK2Ts7NxZvHZNon97ulGTcVIxMRvdrc9TF3hAxsv1LUdJwyWqs4uRf_KDZaNJ5O1ZXMB1CR57UYB_zsdV3LZMj6wB-0SjUauwx-CF0ztZAJORm23GJ6jlOV7TU_dqm28dhSMe164i5G0VES8G98WhMurwJdR1bjVEN4GvW6ieA8tTsbYhMliEqwHaBskfLmWqZHeV2Haj6SlWhAwZC-w79_8FWre0rRi5QSHrk6HVwRB7poDt8ucUhYDgmnhJJqCZ68IfCvUWmiNFyjZcmNlsfmLRTgxa_d_jIs74gmPhTGc_KywS84lnJr1HJB7-STfsuPWYdsOO2gU0UMd2PXNGQiGYE_4Sd_x2ZsTBSyRSHpGgnS8STrVYzrdLvwIZmQ-cR4eqUr72qKcwqm7S4Gbaf821HvVIcWRfsVNcnypdoHaj6h-oIhbucs3Ayid75a9BqwXyTj8ZYCZEIH_WYfA1PD9p3-HqPYVG5RcGxNP2Brzl34FYbCymBwc9PHkPuq3UDLT5T0jhe2cU9Z2Z5bqspLUOt5UuvpeF7HyZ8122bRKC_mR72ftn1pXcyqTO_drxbDAlcpz-xNKEejdIaeyb-j8a9Z8J-FQuBMJvdkXV3qY8S1iWKLXjjF-FITb_OUTEzSOznAbHQ6cY9pE-q_1EpNm66FCfIYY8Tzty431LCd425pOTrtFWNysoEsmB8Z6_V_pXeazDeW9CBVCPOVJGIA0d9L1J4U5qYmS3S4tvt0FzTqvWjAOQAIC2lIv3rMduSlkrgeehx8Y78cxqucwspVfWuQilRYD18RlEGzbCjQZQIzG8PszOxIWbnsY3cWM24BY2MDm-fk3k3OempbLl_ajaRdijq5JG3vCiW70wggCHel-JyZwBZkpg74wauvqPtrh7mfFItMa4dYShMa9QWE0-mi1Bf8k_Tsy-1ZYIqLKqT5AvMkXKNtlXDGXeBFqbWLx1BDT7unG3qcM_J5HRKtI8T5hzfMVunfokQRh-M6nAKjf_ArhpgkeTS2QLAUO8nRgSfOehPEGsfS0eP3UJdcYFdQyVog1kze4VqYEZOp_GSAHAA5tH4vhs0lpk1RJlf0iFByN2gwfhRg8hLEVXKGcJroii75BZfD4hpko9vx5129qsqJG9BmKY5H7xDJuD-re_X38ZF6CXK5seG5rlN03Z_9E5z1eEUrCh8FNsZlJ8W22-rlhi894z51SLewRaUMyFEAfBjPbC_797KY9Vu4WZVOQ6fzjoWJL1Q9OxqDWU_2QXvBzvfwb6fKzJjHc9jYomolruKykFP1cV8RU-jV7KjkbjjsmXRt0wH-Mbmc9qAn0tvykRe6c6qOtA1Cm-z72H7P9Clc8ksSHURcc4Rwr71CRtudRWCxuS9NlVqlzjyi8GV56oBNlv71vPauoY-xTbIEmglI_MiZG3IPxGTBoitzo5DbUywLKV5EQ7X5c1WiL_D6aQN77jo9Lv3AGQL_f1cKcddnnhxdwf0LSpXf6JOwcsV_fH-Tn2eS8T7vg7vqtIJnpf41TcNX5_FYMXfkadiOnNPqCfOC7KDlIkmaLfbCTPqV0JyUCm7vKI6XO9Il0Jh5RdyubymnXpa88NK8EjK-tRtvdWOotd3MO6P7jMTTWEwaD0sfk1QHsnPMNGmPbWWTPjW5E317S_JakJcmtuC91EbMzkpwU9fZ0TqHm9X8R1nCpuAA-K2bT_vF2Wm-1KsJq_gRUTdzLD-3kjlQbGQIr2WMHDHp6rqZIeHi2kdr4NGFBnb2vXi1_OeYmCY8aE3A2FmstqM-rg0hXVVojrC8MydpK2SGmk7G-r8lWja6nVj2eKhZmLUQwjYD3TuAyvCREsiW3a3XEPTLKYRn1Mm257VCxXVswXNbrZz6e1kLtPU3eoTL3ZHy4-QeX3Jp97-83HA-t0e-ftRiXhDrADM6GWXopta6XWZHeQ3NXPqBgSB6292OUrsUWd-Jp4bfJ7mWc6Ur9mTjMZG9j2ARHZHKiiTYtHdy69l9e7qoUUcsS_uHVsIJ2xZXsKe5QZ9-HwymTa5oy3NO8PKBjv8mN-GnWn7jXZTFTWhpvq6hjIe0sIQJhbshbT5NF4cQ-e7rKiL0Nphc6_lgNHKKq189HA6Ng7jekZd0nqDiCJm-ey1XKs7RuSRg2gwEzWvMggi7WIazku0VfRd6d-PEKcaLDnxN-t4o6MTU_wRZo-3B_FWyDUvTi4ScltU7N7T5wt7tI_tKgwekrzH4hBCSj-Xyy8O25gac9nVwKPMbUcvuErKhJSxIYmqGFfFleoCiIJnvQRIEUKqI9h7aNp36TlmokaIyKeVT5rMLoNfaq2NzUWp7WLHLbCxOPttrV66wUzpdqZov-Ls-3UxSbvWc2ZYZ2tkBSuuT7pXgeT4C_n8VQdN7RQbYKs_Up0ywXpEbnI-FoZqWrKEGPm7QllwCGFwzRNgH0W0C_acsqEcJH5kDMqM3yWT4FKjg4cR78Vz6sx9LGU7_jwqyaxvx4GNc6Gl-rYNvNVLj4lHibLByx7cFAWFFbTn1rAK0r9E-k1ZL8brGM2pzU8jNzGZwIme4YP32eKrAk9wdKZ3tKw9DerLre7oE7XMejLvvHzSAWWQByq7uzqPfAILhuJu538Eokm7_NtEBHf23yJCTOHo3xPJENFkhjB_pqloG2NK5AEuWoAYxcQQ9_PsqzpbqclIVCxSPLuTrDSb60zmm5qHBpW86vv0UxSXgXKrVaozNPZRQ_frAnhKHddu-I7vJhq3lZPlUYMpQa5S5YkLxRsgKVa9VFtPZUFtqTzljQog2Jqq6wIAKs49G6OncblfT_gtAyoks5UEghCO0Q1E7YRGEQofmTZrYwOl-Plf6sRQ-HeDpnQzvn43Bw2JeHaWUv9IS1pHwgFM4kUc0Nm8BHhq-3knaPMAD29G0gxvAV1nQuGB-gjH5D2S7QNRS6ZsWFsZZZZXrVwYkl5BRY_AsfjYjkc45KtUtUFccOo4OojS6UEGeGZ7B8H6KICZjN0NrLKXZYbD6_wKvKtOZzRk-6GWVDoFUhtCTUdNPcoFxe_l7UkPStAQPR2JdwCH2GstkCIIuMNRzaqpvgshjBIADvQMwo44VXIKr4tA5wPyAZmOn5DEhPgjVtbhrOtebb5PFdSsnjckzwRScwITwlWBOVBFbZCKIdUYMAIPUbifombK_K2KycYvBwHqX7pf-BCRLg_73xVySud_qPxllUs1ujSxDSNeFObht-kXx3-2tWfZvamBwxX4869j5FCgyiABFjyE7cy9zyARrBPphH6d6BaSR5kIUzM8VnP06_VpdkH57YLPtr2je5lWqFEA0K2--ilCfKRLqM7My9TS3aPHacPJlbWnaWtJiLgY4pn5ZFeCkg0bIeTEdbYGwNbd8ObmAozAxxA3aT7-aIu0dfli6DxXAjUEyw6oa22KV7UsCCUuOQDv-mcc17xlTVI7_BSWgtzgahx4Yxg0_r8__01z8OEZYmvlpbWJdaFcNpAVjKfGQEl66mWLYpTPgedplBg5PmJbNtjKEE7W7_TwuFnfhpJYKXFnH6pE-Px0Z8Y4x4mLHregGc7n9bd9j5a1A77KMzHse7X-NKonU0U6kHaoVw_Hv6D756sOADdQwga4g_NdVfol2T-UZYnHwr3WbQ5eCcjPJkDN-NR28wgu_YzpaTD-A_Dp07LQm_tN24dz3ZRyWiqP6r4mGUkY8XadaUEHaqLEoE__RgshxL19f9VKDB9JBaJQcyIOm1Posuq6bvwZylUn_-9HEsbk40bdVXAwqVIxZFvjmkTsjMsIMtSbTz2j9FfxC1_2c1xDACCIPqDbd66ODxpXhr506zMilDc_NOilBsyray1B3K8Mn-SSHUZ1z_xy_PxD5Q8oy2jEWDoU5xFvosnONVqixUWliU18Rz5zDbzrwVNhmmzsD3-odfkYrrfaJW86xYonlXe7_D79--f4bgvzD760UraZNRGSr0YUWFukk2izaK0fsno6Qiu5tVnBEgl-TQKLYTUDv_xGoN-e8pzNtG1ZHMr9NagqpbjAHBijE-LtRpZMA5gjCzaX9aqR-ABYguQlPTyWFL917xDVH6qT2_iZ3Uuj-gG3KN_HLEpliTVP6o5hPeZaprOLHr0mJECpbOAaF5L6KpO2C7kMfZ_Zw2ypuptldfpq6tYjT48JFGULf1hTiCm9S98uDAmcDwOjTRUQfe_kP46kIXUphuG7WRjfAUYX-mbouQIw_It6qIDR2a0ZNvm5AOVvvXPQDi5oMMO2bInPGm1xUGyU3ScVTEb4OkjHuIe3id7ljaymZi-A5Bd6Jap5vgV5YszGuaeJjS1R32reGb-9TvzI_Slsx_jQFtZnFgjCFCpeMaUu3h_IoqiWLL0OnNRW8iGJKcoEPCuXHJaPuHXBJUrqbdJk4ID8N6sP2DywCKzA0vEUk93eWiVQqe8OJ68rcwriCxsfd3c0-7zCnr5uKXMuFCLrOxA638qAvFwUTGYxD0vTOBWLDaKYhZeieGlSfBT2LhawcaB-JbnWbjyqK1yMLCswVbb2NWLt15NXXUdYsPINBvc9VO5lbTlOAdP8kXTwLLjJ1YDSavzFTTZCA-ZsdCJTTL-q7dka_Mh0dDf3AOCed_9awfkUCAH3Yieee2jdvBPTpSP-Jt0cqOPJeNgrD-jdkSrjy4RvEX0DASqT_VKRRPYAxawEmvl0_07k1WS-n121kCTejmFEHpogtamCBEmU9tEoRX0JbW8ud_-EiRgOyiqoGeX9mFB_o9zstfcgPqYWNgtyHQ1JzvJVt_x4O1UeleDZoIHE1xomECPpXLofa4DSDrpSkQO8ru6RYdjO_0BUfcwH4SAa20VHzJOhMgTnS_iBBQPRfdxX4z-lJ-aeEvVjsLXbiRPQ_fhOa7mZvD3EFtLbqte3131TDUo97ZNCqSGAbDtzb7QvnE-DBwjmqoTJN_VDHl36KyT6Y81xmS3RL44yT4AqKg1WpcDxd1m4OITaC94XwvWAafB8Y5sdaOiir0F-rlbZVrcHPe9eNCv8rpSeWUwGFPEEwdycdDRCWJmbcy_4KoJHzqmmW12DDzpNc_Z0SW6KPiHiFUWZLetE9b_owDcv6XcI9UlpD2xMR49WLrz7jrYeIyg4pTnoBMRxGd-dS9q6hmt2sW5dNF_bRr4DNrvzUVifvUJBJg8aeiMXbjkw7DdUjSQQMEY1eHlrEAPnmSLTg43wUojG02rdLmueduuFU9s3qQAOXMG294G_OFrw7P2EBM3sLPm-rH5hdONed51__i5fSh6Q6na_IvPTUmqDzNYTdDLZto-_-PwrzGW2_3kfhv0Kp9FIm6H9bzBqKeCVwfJjfzNKCYuLyz-NHFQTin0dyomRRhpnlYzGeGK8eRBY8uh1Oy3jDoOy40glOFGydpy7sY-YHiGnHtTyeSM3_nWU5tzSfw0mZ5_y1vir4iU1h68KeMN0TdqWaBc6vH5dn33gP3xGNB6WXLX_nyGLF7jwDGLmxGTkQsnNjxe9fTFH05d8miyXekdO3ryWgjoNvnmnlfxzIyjcKqDmqamai_d1EHzM8sNj37U-46Ao2tpcSzW3SYZ4IKAVsmLLCX-iL55uPKJ7a2amKIuvA7JQhZBsGREjnPPaIY4fRd-Z2NWGxpwAVrydaVcvvABw9K1apwEFHhCtcKDDbHNdqkzp1455NaDXNA3o_n43o9MM_5MrIejun2xOchdwrKmM4GZFNuN4lyZmB9otCFTW7kRrjhDGKwat5_z1Dy-BUfKLVzCext-JlsCev641nCyLyakNjQKBq5Dtxne_unWs39nzdoVvKhcGKZBLG4r83tZ63XzfX21m9KjSaSq75MzF5wf3Msldge3CIDazgTUOqeqPchkapTKP6RFZfqQov7X4kaNUovLWghZSA3GEZpt77fYCguGIhoxe4DezFdin9LTp8IQh2Z7I0Ko0jkwwcKkZwa8NBr70qgUbDLBv4-wf7y6ZrOL4_A8c5yr6heEe8VUnca3UUCrepjKV3RmVFrD4ZPWuldmOV-kFrCsed91llk7q_sxQtzpFox5JA26NROEWqQlNM0NXsQxSx8zI_nrRTBOL0179ePq97vK1N-BOQcEzLHNJ_O0m93YHSwc80uGD8W8aBPY9fvOLErr6EVvlWKLCL47n95gVCMvMuQV5Yf-JGFVDmEbz7mYaPX3a2Iud6h5ZttTZMOb7fmk9fXEyMK70rngvCwf_8JoZvOMU44KklSSvx7V6XzQVLNtuq2WHcV46dPbJrJZsqmtefiUCInqMxi0hgUOv9XGUdG8OX5oNcD72CD3zON8glUy_Env8iPeNLq4hoX4yw-TfgR7mbSR5BUPPwEsuzSa4o1q__MzgzlGfVaBZxPQi5Gh4SYOIuKaxD-llrU2-maprnlSnIKbF2qy6gvtkUqCwMZ8XCPSasnPL660WmRBCRZBLjHzsYCpSYloTNqf6vVcI_cAxsZdQlSwNtN3SSvGcL0U0zKyGdtr18HJpdqXL0OybJR0CSLcMDKKnAhCeYtPLS54nC2q5jwAeLH1aLAG707dl8gBewVZPdmT1XQwOP2kJbEejTuOj76bRur3Rq4gzjhdTSVVh8lHsXolU4fjTUB0MEEbyMaeulHcdKHcm3ND4Z6Hr4lSdGqT-mYsrUUzXmnSi3lkk3Rl6Yzu3_EntYyq2-Pi31Ioecw6epPHshhxP_LJifzyVs3KKpKxr_FbCG1ApJ-p6zry7qz1GWEg-LXCBy-2YTjBYpXfb2G0yfUWaVi2gpEoxbgCKNnFkSWuAPJRGYTn9fSrWJrEHplxTYkWBL0wcNC-HouQDZa6h4UeMjZWWM7ahrXd0MeHJvTSikOUshe5QN6lSkHBnz7AvW_mWECnhBs50O3Nqehwdy8gggghg-GH_Cnk31MNWMZYsTQJ5ogrWg78kPdUzyf4lNl3r2ax2627nomnLwN8hFXGDjNlLaFTYuoZ0RhQDmbZh1bl8xV2OJfH3-CUVQFJnkLo4sxnjWUUO8k_3KYSQM7sJAupe6z8EYWRucfngFjTCbxbk1IgmCwsunrzjNHBdx9PZThZbQOXeAY1n6AFRgT_lFRrm04Rfmjf9GqG68KNjkNE7fl3Ch-I5kmkHPAUosgyIDP66PByJLpeTYRmYiw2ahGpXlq2N8FSqFuUDWWYDb0SLBKQgyRIpoVzjMHlo3b6hs8l-Q-XfaWUMbWJooi6NtSSt_WYNYzOgbBaG3dD2JoM7GUzhdZ_BfCbsKKRf7z2Pn4JVQLGrQErb_fMnznYG8MJ1-8d-E8LEiwnDBV3kZqZmDA5nfGUP6BpE-N2jBMvsbExaa1iPbKdmCAlubDBv8nPl_zIqX6AbnIzKegyTSYOqtkk4dHaOHEAMQ33Aykd9DjZ6Po1NImi-X7Dd06yxhxIswhOOhgfLgIZttiK_dDvMRkYtQSk2uRiuPzwKAsi6b6ELCtMfKOjVikmDV5UzYRgc4Wob77xQaggqUfuCabEaHjhFXCQEbzu2JQQAsjiDzznozg6qdSZXHtca_DiTRDXrbKXAm6aJDuKqa8CzW7LAMVXKRe53g5jRtJEPie-DrqHZWwQmgGAhSFGYx737w5mXd9_tYoA1jWcBRp2-VnL8QKFrh8i8CSR-_CTnfQP15i4k8EdIQ_TN3SzC-pciDU86EdMO0orEjm-gaRftltxQJeajzdd-nKiqviUNWJafN-8CnmPUlPx4DM5euvoZG0swGbbSYqpvVJ5SNwC8TMjy9onmt74RKw5pMmYASDwwIw7iVTqi6wCZPcb1SaYCPXViUdUxoLhGxliEDk9Ol_VPaXy7m1xFCBU3SSovTaq_24p17u72aEHLBT10u-Lw8IvXvrXa5qW9xnlqfY0Dg8LGJrmNbLIgcYdjySosgVwmzagU-ZcegXy3IduJbvJDpJs6fszI1hEwcgYKNkAgyAAO0l988xeYRgMCkjSAw56uiHOK2u0SHc4JAolz4KrHiKtutL31OzLhY5wqArhJHlWQOjt09kWciFIE0H_Tm0qNn4dKS-7iIs3xtamapXmgynN1tKVyOvG-Kd5bAF8CWLMqM7H7y1TdZaPNtd5U33RDBkHrStV9cwSpE0wM-MSDA_mazpFKBMxwr7e-84-hlyHk56qr6jmXLg-tiTXdr8smZyx5yUvTwXGo5J8BSjycWGAWew5ElPD1mZotSwU1BGMOxdxXWIOjvmgK8U2kOCoMctEc6THMlDNK_L3eciP5Bv8LLvRbCsCxhglWiXIO5bsqqcXfpLbRHOTqWLqwEJSRtN7JJhiX4fDV3w7xw26TefGgimRvC9mPljONvLV84bUM1Btl1tCwaDPwNmhVg9PUU6aBt8Ll4vsZWuRz1PXF5myhiqvuIHWMtFZ7qf4x2iUow_osmxJ3FDoRfbhLPuh2ufn5qwbYA-JQ2bkWShzOwKI-5DjkIYqbY5q9kHNKouqGp1vwgZDHgLGh4K29-2YJ6tmLUU75ndFdm50u8oogphpM0cEbF0Zpx43O2EfbENwYa__G0Yzge4Fj0fSjLObltAen7ASQNCNWq4njqN9Df6wvFaJiYlqwLCG2YnQPstqcTJs2-HCOtf1iera-Jw-rYx2NBFJVbuXA2sQuQDnK3u3KZIR3kD55_6udKDI_KM-ig3Ot_kSwePyt5qh2Fn79SURmZWJB30SPKgU2zWChHuM7RRhoFBcSI0okZAXDCpEYr23rqxGjZHyxjXCu1yq5J8HDi88HacEYTyc2OR5ZZNpnLBGkQn_Y02_80w1sAEunj0gYjguOnplUadQZlGXbUMgOY5MaAeQgfnOJxPpz0Zc09tEaW4PZnuaGssT3TxRdbG93D_V3xK9El5-fEcJROH4kFLDRBMD7jh7_HwbHShenVW84xWwWPzChi9_hfXcCbadV55nIJEz8dqrmrXX7GFX3i9fylu8PCbjSb88gWugLvOjnVJVqspxhuwzRUvrqryfYlHHai8XyuhN7siIuE1VuLwqaBJ6gxYMKY6kO9nN9Ucy_uGbJKMgsbJBmpDpWRlj5MpNwNQh3094FpDUYxOOHBj7o4buG0FHQP1GaqELYkmfQUzND72lkzCyUABeCclbUmB62yBC0v0hnAOZdSvnq_9Cw5q5Fp04SmpgGaA1r6ObeoMWZs20m4bkiZVnRZ2AkfFcsmGY9mztiHFNt4p9I3JCjJlJITBuzJLiKT_b-qVoqkgFeSXDRmQyEn34Xiv5VnQQKIgNKEf2F2jYl_c1uUj8j4eBXazUKXSWjwLdvCcjM-rwZBTcYqsXmt0lAoWpQhVB_kF02VFhVKWZxXMDPoj0jq3cSgmUxOvW1WCdOhTWTtFqJz3OjkInI_RYSqe5wMWhiJQWTxO98pIwX_eADObOaF1Nu5lFMfZByh8z9QjyUPFZEi5FbHHWMjvh68lvn2U-2QycmrCjQ8bghG3TsRe49JbZWhzrrbGQL2mwkl497mL90a_m4U_j8qckG0RR0hWLK-n3Aou5_YgzSGlI5vTJLXvZqs93fDNWLj4UFAVxs1pghbMXIJzCWOAV5tcZTWp1Rcw1VgffVkV8508phY8bLlZZSC498ojyl_7KJuYynaw4-vvGQMNJrguKQXbjkyLTG-dTdqAyYo9tcvyWeKj2FIS6wZNJ0FgvhVNm2zYirxF4WUWEv7v3FUa5eKBXMadV7pD-PbwZ0S4p2V2H-7LvV3RjsdGqkZJfxeqW4PO91a9ZATYa9d4NzV4Qhgzn1raUw8uDjoVrdbKrd59c1eQgsTI6uOymXXYyV4QjBDSvovybR3qf9Wmm8cscfiLEOVXa5dJIZSuqgpFokWTe8dIa-6h40wzhy_jSe8Z3ORgKHSdtGEmCOI4dzDyN1mhHmcnUpLt_InYJI6ZIF9IFlHoo99qhkQh570uOHY1tDtNxw2LHC7jgbp1PKramuCJr_YKRU3D3hNKcSBcAcn6tFJmH4GBlactdL0N1XdNSdgUVCqvBM1XmeVEbBNgADzUieDA2R2FMZP4F1dGVmsrFONDDljfmIqOWt4jbGAHG0u27Nn1aVZ9cLpLK8yiHVtnLsy8V7jyJfdXZWScG_XC-6ASMH1i2bJRnNqkBdxAWyzwBGdi9Oo-W9MT7jfhFHtIwK9iHHu0WEr3Ufg9oYetijmDm02uqM7mzsoyQJGf-Y1I6Iew3xkyoITumQ5acYxfhQxzevZugdSeV04rWNXYe2geakPWKbGOdKPTorZuKcBcsvUF33J8JUqdtQDjx-l1hCssZBnwy-r-Yw3ejil73iPgMFn52Zy4lD3tBGmWDRwJpfsatIhPUn-rwJFtT4Z7aPNoiMyBUhfUXlUTFMiatcTzWW3U7ZxngXGg4_Op22-xEu-rBtR0LPtYaZ4kqovGdoLm5y_7D6U7uaYEZL7jI3WdhCO_NmUTMQ-QFlXs0JIBvTzeElEeQdf2CxRWxlIwVDPw3Bv3QGGaslbTIsAhE_5yonkzdVSsoGXTNCaEDhIfYUIFznlTS3TfdNeDJrcl_ascULp4YtVLHpYaL-2fngP8IgUde8JupadJInNwZR5wk0C1AGrjRNGJKBLtQjuO1DSj_D3EyzV32yp68-D3MnrwJkw19pM-4_g_dK9wFq9W1Ytoz5Pw2EawzfqInk7CauZo2hZmMC44zs1E81762ihOsH1rsG5bpP9pq5kCIxj4EopgSNDkFgsTfoVQ9ffyZmQSmaHH8JELO-WQEnQoOb-EbAKpzxOJVI0RLbFM6AuxzGTHVRQ_aJLpiX6bIwkaHVrtK3t2CKKMJjwpDsHJDRKV4S2R36vCbFTpsABTGZ-Lod7hHYcjRD_AL8QJYR3CJOrWocqR6eAt4r2sUjEJhh7IcVhnqUD-xktvyEcDHz6op6UjwEUGptdmVkNFd7X4F5lr004itf4ICdsUrPDQMNMCR5XXrqITzX4OVgIj6sAAMt7wkNlnS9R7P1zwG2tKk-OvdBoH-8S1ryll9-pUK2W1yV1K4xtrKZo3_2l-xpLNdS0RULf5K6xju4RZeoBXCy7WjJjBdBGxwYho3bCcILdOlRPOnvJ4Mo5K5E1QPhuxHN60lgkfbsAROwuQtpB_tBBFSiBzSv2m3qw2l3u8NRVDQAlymdLMyCvcdnM7H-W8J9mu0L4d0R0VWzdotJDd5CBe04rOERNxFocbprqWPMVC--Mexeat6p00NZBcbyzYjaWnybhx5cPjFgr8aO7DL7IGA0jk5Cp91yEpNad5zwkuy97w4V3rxrClOVZ2_9xk37JSlzahfI9Rs_GT79Q6LPrXOQ1Paj8nzoOVcBjbmfox8mGNGowh9AmHILECeRkSY1_xXwK0w584J0ROJcCEGRlHMD3fx_qYl0OJqZT03puGnq5f_yZArhpAn7OFlwV2iE7GVZIkvaWhSudYlrJ_Okjvm9Dp2x3XbRZqPvvnVEeWBsamIHlvf9g3DRsgDyaR41MEVielxQAcbXI-Excudk-C3KA1_tnnb2aylAWFofmTHQVwLeauCHSB42oH1RfeRGC98tcPWdtF6KAmx8IkFvbrEneVDJueE7-egaU1P5Z0wjLAJnCF-f3nkQAWS3bFUa52CArnynBAYCzg4aAGBJ91BUZhePSe2uQe5h3qCKDmh0ziv65LWbISboMfX5AhWzaI7oeFijsrfL1v163BWKJcFTDwiSpI5l1AQvecNFGoOU2RCpddgEl4SrboPXXs7hRE7V0q663b2caRMN5WNPTAX47TlpsOEdYhGkV4TK84jNxfWR4TU3TbgZiONaTM1S0UMJUKPstuRwmCSWJfxiyrPkR3VkvgF9ZsUJBLaX14IBpW07ccAv-lDQ5AEtHL3oF85Mf40zKMWVP4Qa7VPxpQfn4XWQ-4Wpsqi_A7vIvqsDOZVZM8wI5pO9peV_epaDdrZuIHQsmkij-prKaF-mDZj-IVY8OekYws7qaY6gGFLQGvHTIJTC9g1cA5M2T0xo0-Euikz-nNWw2rTZzLnZPAfKBEpqKgOslkt2mTWEd3KgGRAXu1Z0IFIgotiT0dENno8V8WqFAfsKNcNe26PglzPNJt2z9vTiTHCZrI3MFyEtOn90dSgaZoA7p8kQyPukd1di0zpNDHBg6jWyK5uCDIjktFJMh_RufkJrP55-nXi3zUYB7agnFbWYQbnM8wqLZCUpfOEaM-nM5aT7gP1j2rgNFtoKxievwoBGp4LYkd9HDh-2IeSzAGac91fISntj_I3nVke-n5TzIvg6wnMI5RS2hvYo5W0CU7NmIqCX4h7eTygKyeuznatOCgKPXQORcf9kYrMiLx7IWpr2bPtbf_0Z0lnoC4TbKgTqRUFUVNJ2b7gPJmsL6uV7zHQ05xwT6W_5ICLalEMkPTyqstzv56LfonO_CRRr9aEXONuZ7Ti-ZnCo7L2MfxOKYtqHXXj-JMu6LgDMRE_edctsCm7WEKGQCVKVtyU9Fhg4jRB0Rw9IFWGLTabFkyeCt7C5jZK60vrtxCfdBra-l3Kr_RQ2UrdLM4gB2-CtnK1QopLP5q9Z7JVDkWKfEszQuT4P76S_X1Hpqa3R4m5JCf3MR8iY3p3_HesCjy_9wMYoal7eLBVmEDoaRYcjzrWInMnxRty97UfR1Ng1YmmsJKItSSWLk1f2UuRrcbdqQGDg8xsrzWWpVQgswqWHh507gx1m9LdsRiPJxhm_qzfwibXQyyD-ZR17y7VO0joNIcK9uXyZbm_yuxqW_gbqd2q8G-n6-1Ombu4MqD3mqYlOtGkJ2-pTpMaEVu40hxjQnWnPeU6NyVjF3zi2e9uqnaIfrXNTsdqogoBQgtyz-nn8T9o1xqJdnmWl2YYWGhvHAW_h0C0bnDjDeFSSdVMS9nJNbgUdIxmSuziGxsjWtsUGL2Jv6Hjd0CvIU_Cc0qcXhePsgMsHAAO7CoBJnL85xIDaNrhWLNebCEXDujNYJgSLT_39e1_6zkouJ3x-OSSCK-nH34ewuO9xedB_Zd6XD_cTVqavxstIhCAhr2Veg_v7HFZRh69eGUsguH_ECH-wGsoONSRAJIXYFpeHLhUAvIRaZ92AHvZ3VKt_PjZZid_Y-tPo2OdhFHbIWXY26mo-h-2ySwWIw6ZYuiXV-YzM6xJxlhAnkRo2O6owF47P_f65B4uTtD4ixkeeMBqC0LRe3AmpVVkOrZ9htQObdQHcrPqNXzogA1XyRKs9qA0b1k-ktgLqMN4ZJNPSZn3wIa2Yw3hTs7so6TOkeYLI3alP22NDcPNGRrMBMnRhisVX_s6pDVJRVYn9NjRYwbUHwU_37dQMiTt9FSWazIuhs8xLDXkZBddSmB-vdBCNwTgURkFENQwEwQEpNyJKyYeBBMAcI40DHyyYD6hmPq-EKGtPva_7-oudu3UyhLir6Ka3UJLNKQRR3dXRXFFXyHlKnT7dZICfMP1R-5n8hqxAQP6A_Bqh86KeD2qI0Uppjwzn1wosqfIeIsjU-BquwMAKlpr7pJuv-I_IBw2v9MZozfnoLstIhChG8YmCnv3NXiA85Wfmk5BHa9pseQXKJWmjVddZyS9xT-jeW4zUYBB82sBlTCiJRHsVwbCYNVM0QeT2pzIJuB-1NnKy6p7FT4bJtszn7IQs6i9phxYNEIrg0m4fIpmBbA6lYuaBaihvoCiUMTWliNj5NEaptZNzNGUaqLn4hA4bE3Ua_JTYcE3xqZ2FGxX0MUgx5G1HW48djEYyGJPDWag42NZxSBje1diSo4Pn0qMNUqvJKvt0oGpDZlUpGI1jO3MJa_cksuV0XW-JylglSV7dRL2O8fNEx8T_jKojXD8Whqpp0MVnbv2c0QMbnyXTfdBco8xUzwLMUaPjZRHBWjHDGlarUFnQa79gE_iPAXrjguQ0wbrSf8BUpcNFoybxdA2l5wd2bxra_nrDk8p_OjCDH7Qw7QHpUXm7itEnnzTVK4cBUsmQ_4B4dTB_B4getE4PQFt-cbfgEilWewJfnODYZvbWLndI08ecQ1xH7MB8qfGM_XSmes_mlWEagVk92BPLmYClMkMCRfiZaJQJ85YoQzXkl8cTWiGMBSgcIm717-0L9wv-CsIHJ3fCblpw8CvnVicGoIDpVBpNIDyXLW6VNl_XdauV-_ObslJF5GfPhcBnlwrL2Clgyg5eY9ef0bINKAdVIubbReA8hX46x6Km-_8J2Q5x0uLLAt9sldG2lTmknklLCg5p7zFvvjADGxE0rFgGqb7ZH9BaYfrwp41AnwNFUpBl6xrp_564E0b3vDfJNzvsbVVIgfO8wre0Njg74FAzWFyM2im-MPf1wuV-wM58j5iYKv4cjeKjzQvV8aQPYI6WqcMpDtxZTxfYFyHggyH_OCrRxy5geGHlp_0azWvWbxMX_iYEU65Uf2CtoBr-n83-_Nol2jw5cYNXBxqumhrjsbehBQSla9wDnVMk1rUPhIV1irj9tbo1hklZGRCwTzLRKhbwE0AO_megZhT149gMeqSltWu-qp8ay-E0bybH5yOM5r1m2LwPhnUqPJkAWe0DUtmiMfJD4Bgr47rCEF1HXdsqnLHpmI-1E6V7b5LpMorIDUM8M5IQKlN5pfYgSq74zQV0hJq_gSKMNW1EbfJYtzOfVastVA6HfPCMYIPGqgaRwkQFoN8qd04rMnysDUhEiICHzOeNjSJ1XS8GO8G9-LOeA41eSjNi9mhKLuCvU8Fl_l9vrl83X4msk6b7T0FzbHto_YCjcf_T4btS-TrOlBBS7ZuFNEB7nCnyxqKovjS8TSrXIFKY_86WccWb1vU46Y-5nq3g_rco7mGmwvTjRTcg3A5oACPfFlnJBIHWOvNFNwVzg2Mhq5A20TbgFEk2I1TFqyD_GqgHlH1sfuuMFlj6Rg89TYgurU42fbIaNyp26lUwwiWkajQZfjdUnyJBoPFHkCF1D-gnHyHcMtdW3NjUKGEiotoTsWmTszLBBUf3vict6Xw4-xI_1uOcFPl8XoVZYb4hQB-mKRO5VUBLivriN0YG-896_PubswetzS3KM06nhKVMd9R6_7NwrgcwyRkbPpwt3OAhpfZRB_o_poNKP-sQ-vy1Br_0j2shbIodA7VWfs8Zy9G9N7hxNoelEjoB81VJ8k1EkvfgzViDE97mYeBz2IWQRilxFCvqsPVZzQFS9VbYY6SSmxOaj_4Ywo_iJqik1s_b2MbCckOk242P-sYuuhwKEY9fIcZDCrbka56flZEMOyHu1AB5dhikL0t7JKNsiztx7gLk0ApeHvemG4VBUlQIcHdvEaWCkRNRtluWDOyidO9_EJMur5WtfHYlcolZyoAYruCYN1LwHyO91Zptp24vOkRohtkuXFUM2UcoZyAkRMZAXiz6SYVt8qIjmiceeveQDuEyA8OZ21ay4_fQHuAUE5Q0yJNxrS0ONpRuyX003Nlj05n18pz_jWhCsPbcWUvFT3OMojdlP9hw8p30cl9_qMrnc2NoLwiH8r3Q52DkMb6t7IF6qn7om_Qh9gzUOa8GQXB9JTj7uRfe-Z0HkGrnpYA4ls98h7EKFbh5_BiYbK1w_bQQA_SpNJKpiaH-rg2lEemCwMaWvy2onx4WZaOrhTi0ArMkvHzK4lvh648DHri7T_NKGMzn2HDIgjfiksrXoe_2Q80zfpQPIFPc4w1-p08En9BLkkJhMxw7kR9pxcklI93HIvllBprYQhSJc8arZLvwsAUXgK_u-lS4mr7QjOHhETwFSeJ5q0EPX5X-Rns6dhtwtMmzA2IdO-ua-rFVmts2PEnV6WIVkso6eB5VyrjwNKF9bFAkwKB9HUG7SkmVLpw7ftdLf5o3pcpmGJNMjShvH5Dz7aNWYcF1szY-9MfXc2xYh87Z-TPShPOcPVPlkJW9jJEF0IqwferCUeLPmk1EEEtpQY4n3Rvb_e09vLiRh1AzG-fs5u9uSQasGC4nMpC-Xy0HSVXrf74yI1ihZvIbocLdfF96aLc--ctX6T5UWrQqbzgINuOh4euNqDQkL9stja2t5rHU1CExTMKreMXYPBeuXmVbOZ5hMOV8u-YpZphiV5j_d7mrliOW2VV9jaqjVzd52wD9OhEcGndln0oVq8pokC20Mfiv-gEsf9MaMWmooONrTqT4qppuFTnIKkVptTXfIKhTNhAipoL0OI9NnD9zUWz34gqB5Lap2eI-2aeTrcSrX6dHa9a9RpjPDw6J_TmNASWzljN5tYMzUKLSfp_lKA_hgt486-1-XqI9Nf5s5W83cTVQG1SSlwrttRPicuHhLG5yN-6fJdsdRJsiBea0Xo-trIn8oI4sAkV8otfzRfHXzvHkULWQp6GIwvmPvJlsTfvc9ykIb6tHt2RiB3hiIG7CY1KiWW10UWdKnLQ4JLlnMZPfVHT37oNOfIwQp9bobMovknjfAytiaqO4150RK2nohkrRBbNXl4KRovVw-8RbGEQhKMWwNdqUJLIRv7VsSUJzvSFmR7niWx7PNFdDHumXkqp3w6NdDdXdgHq-SmXgyyij-PtCCl5BnzYxwBN21Il9mrbXLMIw2_nDFqKetobnU3JM_dbIprciWiLTsfNJuf9uTmgrdyrddHzH3bsCQmaoSa-bsduKz7mWXfb2gTfTlpsAsTINsTXA-RK0kRrWsK2T_Q7y4egC-61VENoaGglA9WQ0BrusCv-iWWlqiSYHuUvIl8bHUVRv3NrvJqcueKbHfFWYUzifKt-X8os_D2F60WBU8X8AU-3ZWO4GZ-SKsM_dc5HQ5DlB4FA5WmxHQpV2jpZKKXC3gCrtsIoUM1_qQj50xUFP0hbhoYUv5LnrlRtZS-oIR4qMWlFHJC7YfGqpsPyrXMdd1TcWAaQc-2Vqf9C8Ank73FMQHe067Jr_gjZ_Ns6JIU--LwG3u-eUhR2geMAp2h0NVZ6iQpg1xiGGRp0oKzU3gB4h6hG52a_XPLRQFxRfzrM-YFUg-jaQbY1RLcDluTs992YmERGYp6O7ReB7e5zF0VKvlPPHpyoatmovJ08EaF6OizhoZyTRX_K9b2Ogx7oE56WDzNq2GDsh_SrEs8926cKmE-GMPUf0SWYH_gijQLCcnewLm2KUpSCAYc6argFKOmRhZn-V0bCMR-i5yn-FHb1PAm0aJ8n9XjnzAtHc483hU5wsssoDQk4axGRNXsDhPNeFnxb7VPz6gbkZFxJzfOkV5P0GkwYHnRLscTWsSmFWKABT_PinTp8htW0HpTbYl2461lNVGIDk9umH_5hDHNLQGOuFdmK4u-mbPVvrV0EtF1qfo7bCaZuOD26_jlpT_LXmY0MkCdnANK4ZlWQOjoCt965CU_TM-1MfdWno1DHuCcksSgXXBxoT8P_rQcIifD5QgN_9KBnjs1qflv-Wr8dGcov-oeJbuQdwrH-cQeHICNbuXJu69JN3P4xAf9RASRxczri8yb29Y4uJr1UUWMrlhtZ-wswlpOX0PmDKrctFR8EjyjShyXf_afyvWn67zHpy4ZffWOc4F8LtavRoSEq748_4bC1yeLe_4Oev2RyCFseZqSdDhEEIRWZZ4IzebsZjTyS02eIn_yZfCNZGfHZkMiuYv9jZPoi_1j1JZRCPsvA-gqak4KCH5x9oq4Yx4r9XTDjHNJJpVnsxCr6iho9P6-4jpv1UC2R_mfHshB7ZG0eyDX0PSmpQAfkuQ7LkIUoldkNJxBZ2JTUyahczlxjFrQxEGcs7EkY4DOMtge5pdFsQR3MD-A1po22Y02nRxwMcUs-TkhTjLYXSYhWD0PJn8ZZ8Eg-FB0wNsldgAWhfVkbI9Bcdtnk4WuZMM6uouKWeSe20JiJ36LMoATGcrMLaVcs34G2rlIH5ZczyL7fdpEet17-wQLI_qXGqSgJ2x_ZytBXi7tK_nsSsMSYhiMsp68U1LJWOpC1vopbHucll6w9t-rWJPm2iSN5iffaNrTvegfZkRPqgl6KNZJXBm8QOTxgHUVTqbo42SZJcEAnM9oH5UJRN8M17hYOHV_bo4-wEs5UcgB4ZrDUqHpm0v6fMrrLepaY0ARFR5Cr1hSPOKukf8uCzuDHDqRlqJgM3F2Wbv0XQXeG9S3q0bFyXQBqQlwfRtL1KDPUup__T6WmG43W03NUFkA4uM5qUp3nQ6uZ3IEAZVE_tSL31Cj1rIMzfjbgSwxb3vqia7PxRtg_RRUa3V5VjH3CUrOzuo3BIBpotqgnvYOxJds5afZuSKFhJO1Mmq-EsN1vLSv4Vc-VyVrUCBrFB_VBlY0rauF40XPuXzko5rA99_dcjPN4o9XGfYcaimDp-jrkTsxtF4ZdzA0lj4BDB84ZHERhcs_w7nPJZXfZ02sUgh0QrpMVRmfVsfO_RfZwiS1Ob2XebIfn84y6yF0rQAnQXe-pLFo2YQc8M5WPyNEAFm8MjSiLwDlZ-O8hYUeKolHdadeoZLNhaFchSa3h8C066vA-KbCqUMbiYL3gpnDOWx0vFykLVUfTU86-YmyeeTYZbDkQx_WyB0bYKBetQHco0WIXMTcBIDiTHpkElJvxd3nzR9ihByKGDkaht6ckcy6qlDMqnyp69xTwzsOKwpOr7jLVRXktJj8vvPbkhRKRq9OOxRFNkQ6jHaeviuTQgbV_mHB6jsMxkkmn8ZoKoWHq76_iK7VhR27Z5WXiX47xNOrlEIxBHLC3lPX4nX8WUqpF0zmMI0eR-6EiXu1H8RnS0Aic7zy_bQSzdLNeHUitSWLcXdp0Dw54l-5yk0zjT5LCRJ5rvsKevFPjy3_l0z0k6WsBLBFd_cFARTXI_ftsaTLiMbijdpevdg_9xCh2li8SFfDiwYaw14BEIfQHXnUwMZnI8KJ5xgnXquu3qsfz54AVZam_7xnSHh7vB33OjcDEDXjK-C2ckc_B1VVw1Do9c9P89wdf2kSXErAEPNzNc9-bVqyoIA1TD7DkO1RHVys3yWr_0Z8xbty6GdgJetKLH62iZi3LQyNt_TocQ9K4cmA3WCAh7VFByviXSp3DrrRaGYZdsIzeVdAVb9Po5MGT4aS_5XcAH4QMuEnyTXYq2MMfpRZITy3wVWsKn8ziVx6lvPFuE6Ld65QCAyB54o-PUJPa-1qiZcgzGBe81zSCjthY4qi7MKMoTVrsN5jWfbFgGytJDENNbMyUDa7SFaFmr5A9HV4sUgedfMLFENACEaWYsP-5hOd2miq35XClhq4MMoZMBfUxAjeHnVOzL8UJ61X4GdVgEZ-WZKxDMOXvBQcACF6OH4zy9Os54XqX6Pshn4LYL3u00FmMxjPxeti3dOYvnQ_GbQJLJ70cR52I9oSEGv85CEo-GuURO0tRGy0jKcHlQF8JvUObYOk8l5i_fUTFz-KlDSbj7TfP4ILdOvVoAEY9fv4w2e1VrBV62MZ_pBxD_-P-ujFgcs3_UgdDfjtZPP6CJCm-qCGXtRnoZXMV_IlJIeoxuqI8k0njx8XaKm75Yp6h7Sz1YONnjM3m6vS4TC8XLJJfJWSXsEBQyBmoV4wMHLbwUiE02Q4F1D1wff9TtPhYijzgiOjxojHQXpwStwty6YW2KLXRSZTZIDHPN6AI2IHdwNCAFsJHhdxgfxjQMVtZmq7aMoVUKYScFFJRQMsEi2KQlM9aNq9PvpVr-zu7ZDcSvddOM-rOKsvF_WW674gink0aNXefkfn7s-1jl61pn9y_lSMNalPu7uSsZCrRgNIDsdIH0mGQlobpLEOm2mmmjmZO0lVzmFonLlwS7mWLzF6U0Io42wcN7L3729XefafZoVNkY80sSrJv-c1tzIYu7O4hMAjzr7yKGfB0FE2h40Qo9wxYXALkbUpRrFiTr--cICeG3rGMR_wMgb9xG1ylThjhJM3tZbdQIp6VekCi0ne43ht_RBhnN3HDUoM4V-d45AfWCKNEgSnjEz-zMBtaE6R86yNG9TmDH5o6nusEuYIpXHi_0cTZdwotC4v83pm_3kRwu1CGQbVPVYzA-nG8LuRff5pEoyqt3L-8YlM8gXbYb8Z6YIiI80BoU1UE2fCAPlqfJFTRjXresCI0rTAuK6kBYVlVTj8AeXSpC4gbM42ZJ53jF_Pjue9xO0AU8SPgvnudEEapEJn_EcvRnfOhfwFYQuH_oL7PzaRYlSNPxhrUwTwAYGsKBYy3oEpcW2q6cUF9FIGvd-XaE2fOLaKdNuQBiKjVevZj11TQ1-gtX2bSKkGtZK3RXAWwG06-Q5CNkpeel50WZcHlxgEmhyH6mK0vIVSPfFsps3mhTSud2lFbtrn4kM2fXf2NbAA5f-loYnJn7uIw7Wlsq2PSbRKNhKgixg7HvE8xiuVXBNj8s7CtRf9o7sPdQ_CKUxkbVI5H-x55W1QRCaaKHSU5C8Q4YKGUHHVHzo52BtZ9lSEH1jgySkT8o-7ovqie-0RUAvq-jCB0Wa2EUX7sxbmdNFNH0IdR5D7kFMjUeaqiHUOg3uPWmraom8_bZgaL6w9B4heYz_i33D32hLHgG6TJ9AmfhROe0Haj5-bdylnKXWvkddln45hiCjidcL6y3eegc0c_9_6_jyIYBAK-3FSDh4DDM5knr6fCjk0mhcp4ZqhjZwaNL6p_BCRT5n3cGljw3vlS9LIYV252x7kzXOqSdnokCIQkps9uoZz5TJTgf7rO5wuAi_5A1shXs3C1pPLVDQAN22DEuA5h_OFE303OruQj5wVMePunau-350giYvpDvnq8DRuIfVkX1SC_tHqQOHrquO3uRRHibzKI9kRRU9GPKpJV6Te_KK-ydQ_vsaiVawAmTnvqXVa9mD1Q53QvZrWAYN8BwEMNj13McyG0woeWkfR4F9M8yxeoZHTSlXtxgU9UO9y2f_Q4Z1ESaefbCzNvxAuOuUCfot9iDatocbgWBlJ_PpktcQ6HmysXwp3veKKETRsBIyRSup9gR5gNDsU6hVgIPecRiZMtbYFetGoq7LdvbPK6COoIrOwdRJxNRehVzq3RUwuoAIEp2qRCoknEu4XTVtptCeKXaCzzpTfppYXIGgnbjneJNkWTE2ioHekD4bhdjEwE9BUk7tj2w2aK2HClfzNe-1lRi4v_UUV8nNi3hF02uZW4joCxHxac1eT-PEUpU5-k217o3cgIcANROqIFibgMeC8OWDE_umFKjlOrWndZGDbq6okS8_uCROmehwPOrjv1aQ3JgcdGKPBPQWmGr9zSu5Hu8ggvBy17VLq6KBpXit6wRVrc7A8_cj8DBupsAODEJ4Na0oUMRiLIOtYwnDl1SXjdBk9vq2Snd0Hk1KIbhsMvQo6KK4JzNBGhOF7BI231Pihst05rq3W-egDS9NFdnCaHLFI8cZqMm6vxP1rViN9ULXycT-gcWT9bwJuQ_EZgsjTwAY1G8ncfgDMeLOZ13Wdx7F8F-PLlIJJv8m9jOwLFrJukWVaK--NG6BFD5ByxsaEsH0xdPE6ECaAueUv1oy-bEPaaDjrpcJD02Umx7PdgZLCVXOgMzI4g7lruhhiGnKmYz2n_Ro-vrZ-MwtRZhG2X8amKxuG1DddR2DGS31EvFjSsnewrnNAK4oYBbgeIq32syW5vOK1H-Al2xPlXmObcC5s5pE8l4A121WhnfI-lA1dMOTM2szpjaI7gKUUk_2JaTn3dnKOnjpINENuXbGUsHITe9yAoVJhQYxZJQfsMkNmDlKi_vUpzuqvabfx00Zdh2Z9FJArPUmRDg8q2QE5TCD9oAEjW7AWbS93v7avC4eKICgNKrR_RnuzP7FbM3jB1u5F-v7jNNqbP25j3ebEH8EAjaKzITYORgjRjOHOGH1g3srNKdHceyz1HDNwc1AyJlGsFN4Z3Cwo_npQl6z40I3wHnI_KVDYqeXXebqVv6BNlKhAiZdSqM7cUHBB4gFoHloHiLGkELqZJ7_yjpRce4xZeJdghyC6y790MgEnCqsOKWQXT8-OlhH1usbfzecIfNdjV9ft_cGbZtObK-fBk2-IbqlENo2G6VVc_7a6GvSkMfYPlv3lSuaD0_h18wtZnyKMPUdsreZdyTEirsyU9uNFEce6p0ybnk4Pk5d0V8kuaj0fWJ1hlakWFvxbasM7tzwncrBFqA2z1IanXJQv5AhB2l10qQCFe_u74d0MajMTHg8YGt_X6NpGd9B9sHfIU5650uvMYln3pmWd032BOnDZS7dANC72YzbbY8gXRuiXDJYe_vDKtmnrFrEhJuey3gXC8aJ22EA6kcHgcdwifYQaftyuep9a09Iz0FkoiaSPaXKCQW0rOKw3Nlxl_k_eYC06XYV1GKGkh8bGIJyYqXzF0sCUNVbqv9GqRD8e8L9kJuGe6duoUS5_usAzFtK4JweY7kTnAxD-pr68gHThUumDJ-LyUJT9tDqJtRzBfqF7bwiuwJC3zABjzoPcouttkL9coZiFU49D4b1PidjbHU2_rMVNnIV2iW_LKeN7Nxb-0in-DEbidwrEYV2oqQLZb8yvvTIxHsuoHNJS-v-bAiu05I74_5mXImF4W4JTiSMnSzgicieo5473pwLtZ8o_6GwUyC_9MV7qUSslsn2y7E9gONtM7lpdvTenOmBKbTM9oGw2eLOZI8K5IaJ9mq6WULjHj8tcloqDrrz-rkPQC1nK3uA7VsJW8Xf3b2Rz8PgcoI1lBOU6FgeYunGE6Uav2ctkI10fP48wIByQoZ2UMpXfFlHJeTr7BewFxrQS2FlICHMmUZtsazMn9o1yUWMq7SvaWsTKd8cyDB7OGMpnnSI5NKGfaq7W1jpkB52viCTkz3EdIH0VdKzOzEoKrSP2QtaEmd7dfqGh6J7HJJbC0f9h_WWhZY_vBzhKbICS2RKSu48AuAVNp8611_k5SnhoCjJ-GpAx6xO9YG4cEVX36mrBhhYiTCdbFTIks-6zOkQLG_tQbBmUM1C7A2l4VmVXW16n7JYXgZjnE3DgIOayfEMdft9Qn89vF7miQ6km6QtW6-3NpJM8fKFSeFhL6jlinHIddAEsPPFqx43z62F_eJKlSmUyvbIV7QNyKiGVPnHuYrNi82Cn5iCwg1oXp7w4xich1Ous9K3hf5AQ24YgA8w5lTejl5zztHLVr-qmqfVQzbADQWLeNfra1o5CFRELgkeIc8O-g_oZChCCZeSOuoiNiTn1Nd0ZNoyljB5biBhTqT949beNGAO6pMJQb2GPGLZDyApYhFI8BuwkYUsFvJ2XnuUpmuCdLSQtWeJVBBHFguiqMWYZS4fQmsjNdkseINFD44hJX4TqVrCWl0YN2XJS5qjDDNlrupGtUO-PXM3tJINTNeBxhZgJ971JuFLMaWLNX3m9si3flei7l0TEenCm8n4bqzI28EXBa3U1meCqs3U6NGTw4tj5R0Cw0cmb3GjJYyf3mG-e9KmIgeY-j5g8AhDDVVAps81KvbfFPkB0VA1MdIgPIZ-JQEM56QL1UWKve2fBy8xUgJZNMU238vy8HMDLZuUdv_W_rKqUxVMYUGRrdr1UyNPvewbgwGo9xPFSk2kx4L0dqkDHBneGSrGi5dQCuo9MX4reIOrRQGm_ctxJgn6B8hkPI2deMtzErMc85vSnLG6HHYdTEtZrV4PkBkiJ9VQFmawvkmF8rWrCQgGPBeFuCVEsRj8pE6Sp2r6vXY700_v0jjd5Yz5iNRXICfb0EtiaX5g9t6T4Qm5LVne8nKjjAYrSh9B_t4hK-C0Z_Dkzh9M844Plh_w9Fdy6cSzr1ty1deNKiKNCvvnVfb_kAGm9V59-RtpY9N2YBur-ZhVx8Z3n_KUPpvbmZrw0aRct6a6uRWTXnkYb4miZLuKoC9oWSMd4PQnULoBnRteCmY8V01XOi-TGZo7EyI0jCBk8t15HvEZ1YwK-P0YlWKf4i0Kl7e21KTdVtxpBhASS-840oTVrVQjpk2-e6cyCXDZ17jI0aY6NHmtIitX03pkZ1fU9A-pAaYdurWmIhjre3o5ytibho-msTSUerejNKH0afaKQ6OkwMlF6seV-C3Ahm21qjWRf-DsOTbRbIR8Lhn1HqI_O0rYzx6WKlu1o4euw9nf12Cu1D0f1dhICSKHs1Vh6oULhe1qCNkOQsnZUxTW2t0-vxaQDHum5LgDRvN-YOp_LFEicmMl_j2hXynAcx0s-yL_80us9vDcpbPYfWBQHCAoIgXbajv5atIFoyWpjkeFqh5Y_Hh3ZiGInCC8H5yk77O0CKv3R-GYjqJNIhoD2LBwC4v5_M1GQZRKRKP48J6av19UeQutB6DAScm7_6YMojRjgWumH9-_YEZn2qBN5Ed0qwJ5P4aIHIkAWdSHxTSlffG5LxAXz0JzJ9cP9ItLTvdMDxzAVrEtmnYpr3wrbBXLFGrn4FCVOQlIh5e6SaFpBxyWfctpb47EwYjuOb5Rsb2IiVsske5vGNtvkQBWZnq0kUV2BXMxgBhBv0SYwQZKKWO6hhQXBADVqsn6lEGAn4qOJ4tj16il16_sNDP5Xss-Fdii6i-wCOaG7VO7dkUInF9FpFnvZeLzVB-z78mjVQFfO8wUk-UvGi3vO0rTNz8r9-K4IM6eO__5I9hdUZ43MTc6Q7HhoInzObH9ktuTV7MoPM5-c5Lqg5UfWiOvU0AWTr_Y2CmLItV8xpblT078Z4mbLbC9VYbjhfFqX8HD9OaGgYqFbUU8LU6G7teGyVjGUTjYpDFRjLgGre4WcpyHwCxrLIe48t2Rm7CDxARCNRTCJApy4JNz4MyZaDbvQwvCHC5NyVo3meKe3dKcXFU1Y5ir3LiNOuaoI7At_Tj7rufg4sh4xG0BdoFBDYQMj7Z9iX0Aflo-RYWkebt0TQlOAK8exwUaET6MsUsYbYLXFLwENbJFsKBnVy3Rvs8PZnZ_PwOYZjX9kNHX-f9Q263I3eyunurmSbOq1cYTJh212m9xP8BsSMftlTa4rmUCMEtnAFTa4ZrdzwqYusiUwWGCI2FDLJUM5zOpghCXA0O56n-_GiZOBXYbwPeC1lrYqh5DM84O064r24cmY_2GyBhW6IIN75eqH_O3WURmusuqZm3k4hGA6C9wMjMloMnfIWybF_bh__CLBDPY-MjzDWppqyrHFNXwpVaqZXvoQiPRCj8ccYO0Lt1RT39WaKvjtU8ENREcBpfkb42zSEzOMJHbkdRifh9gzmy9fOKf87uh_b7LvtXdVu18O-ExKdrTeLQLyxfhj5j7nhqi0XZxdvqKTDtJi8Q34gvEIh9kUsyWsIJBOkjwaGF8LOPw8on8OH8FJjpx2X7X9tMWeTaf3c3l4AHWNAZrnExnCfeDik5OrjpkgJcz8eri5tnrn3Wjlkr1usTU_MvhTFT0Xt8nTl-qkWaT6FueQkKV4JhApSPq8AcAbC_X_7fWSTqSAhU1a59DneMsHJpgTcxg2G5kr6B4_j6yGS7fUCHKFlDfuhD7UMgCV9UaxjmArdqwOkMSFKyRNmIZ37cxXTtdkEyw_WBLtfudInJgAhxhtH7tN3_l77TkZinzP8V2p1wNQSjhlr3kaOzmzwPfXw4zUTgxNhW-rSbtl8LBZIxsCeXDylYZDnXMX1gXOM7dqA6-m72F5AByhWovYWAwBsYMj-YYsb6az_TGi3oTRn0NH97De9cuAFmmY_pD4oA_WjFhdJmqko2rqDanBZrpFW4HAmLb51UtS4a1JPEmKTmryMt5R2oomfieduhpRwsuLHjNFPkWNevp763Rm_f5cFv7N2cN4KFsMCpxtqLc6Wo3bI4KRdOlE3LHlUnTE8z1kcsZ5AxCDfkM45Rm2XmTm9FTyBYhc57uL-WI04ry7-lffoVot8iGbILnE1RZ2lV3acncpsb32KWNORnvLyNm4a_99B1y1fN0kdIezt3mb_n_wcwouny3H08MOqjcxLCGnzE76MXtmmJkP_AsWIhfm14nghpSeaMeLneQKp4Q7lBauJjvJW45pS3w9ixHm_-BSx9xmhqOP3HI_uzD2tL0ze5SNMZ2pjpzbSy7K98zcpnxOK6ME_ZqGc0xrro3Cl00G-zCX7HhKRUwIuIjX1xFK6FIihxeOOhRHH7eLochkeYebjBr9IMJ2msubjIjOiQKcpz7FHOcQkOzE1QIptYCIqH7lAA3BapMO_vabqJwUZg_5CVFr_FICJDbW6iql9u_gShMSHfXlsGOf9shvO6jPstBpYhaUVJbmUdEFOUgQUyDIlnUTwGeEoYY9wHlrsdvTeJrz5r6da05C8WKVvSSh1-AsC4KY60-Sf5oAa1KGfKZYw6VvAQwziA3tp2hW1OpMekOR3HJXoi3ljSlXDaETDF5LRH9_P7RFhsgb9UZRW1XB6lyDJoVJ_rivzHHLK5bvP0u6R_2gNoeSRFui6usnp1IC09Wq8mc_cXB_I0QIxK1KfxsJVkCTPtLbyU-EQO57_FzKp9oWhv05iSbyINl3k8GU23qCc1x5gemJOOzJtMRQs0IBQMBedGt1XRfIsddBC7330qAALl_DncNFRyBr7mZnlj7i7pFitp6jyHLTKZGZIhY_429i52X9ZsIgD94jk2GuFeeRH2W-otE6jl8-NMH0ewgc43yu9JO5LJ6tt7NC66XW7qeuFziCM36CR3MIGuh6MzdBZ3z_wENd-nbJgvcBaEJzwMMMN1mwWE7yuZKbkLLG1XvTHlC0c5s5UI2wjUixGFAKQjVqcOFAG35-UkRi0p_lhwFqKGytqr-SZGEvo9NweyqELU2gDpwOREE46K4dJ9-a7tqEsXJvU7BtjU6GD7MGzg7bkT4KHRh3xuAEJD1uLkx_jVU6ntZCSVwg0HNeEeUi6XwpyA9mGKXdilNAU5qnBdzg2xA0h8Mq2UQw4_X3kol3Hm0Vb_mD_B8REizYehIF2FyxEuEtBL5_TQX_indtd_8fJN3vg_Kbrb4Djg0OffihlBlWRCpv6ct0RgEjLvHrl2liKPw0yMn77wYpul37bpSyMtkTgdglp5F5KEc9rZJmKc2djIaSy87rmCLcsLk7kvIfF7XdKGIVzuFTJlnMjz3oW8lGMzMm22pk4wb5apy2CcWps4b0ewLbkAvssGZaPimY34Wfytj4c_uhlz6Vad7NWE5cECVuv-VU_xdPY9he1DDZTVmNlyBnnk7F1mAg7UfglvTUb7gbVndre_buNT27uqoKJw65N6OJPidXyku65OuitEK9qYrV7T21NogmwFU2kj9vMCdlAfHoHyxa6k9nLxTDHHMiqUgkTtZdIEbYosQGEYp_dWPRO9VLpkY4-R3WNTV84DB_RJR-F1vXmZv_XSh2a7rkNaaOtp-FI5kyzkw5eVoatX4g7ZBP_VfhhCr7oGqat_0lUz1IoHcSCSDXE8ILf0Sva2E2jfqOZBlKWYMipSv-zU1TXRIyD_-Bigm0gHv_BsznYV6HbMYvHoU2V_UD9dwvhYLGsPQU39KZFxdkDlLaJRdpia3PcRl53hnho8GAHgfwObS-oxk1t61YmuFb3xjEQcRmANpkyQPLl02bWlZV08Az2rzBtHn749MYsR3Q5uDJ4KoiHYFRG-YUS5tOPylMzLiiSHCBJgWz4AhgGq3meeCakLNsZvLubms5rKP0hnwiPUWnA7O1uNQdxjpFINf_Whnn1p4SaULAoBOpNSOyaijwkoN4Thvx6ri3ohbkhSEOBkvmhWhk3_vHEyKciHes5ZKhSpIJ46BP-Rp652U7zjjBQLSUfwEcOdwUTT27-h3bj8k2IACzn63PN_81a9bmFmA3AvriGwFgu3sgdSyxbRzKuU0egL8CPBWcpCVvMDwbE9ypJRr0nCUeeVMx9n8fvzXpiCKj-H7vdN9jOLC58D1MQwhmba6WlCDRANhJK9UvNpn6Cc2-YnE5gmrJjtPf2VDvOR0rOm5zS0W_74L-f5JeNHu4_nJYas0MjA2F4Q8702vGJO-uyhfyHxtqSMJ5KLTTBl4czyaYeP2Hj39jh6fOf90CAWKbzgSNXBQvpWzezzr7nf_Gutq-wbEJnZfGCwNp9AlFT2yT7jMuD24BdDc43gEN9URtfhvP2781-P42DAaTtxKLycR5F8MZmyX4VAxC2tdeXSrmbQX89NcV1qz-SMHk9X9Vd3vz5NH-jn1gMWPc0KXkebP9ULQzmQK6jxdC8I6KsaM7ocWgYtK2YH4GnFzI6MpgbeQStD0ex9BSUq2_7TKPXQtPOYi6t4pOCDGyXz9Fj-_JJIbf7c2m56QQap0IEBZXDBMwLrEXPdPGNvuyj_yTvtlixBkGp2s7Q2ZJKhrI2JMy_FLsET9MP8ZegpEcZ-IYCFiIO14JMkX9vp5T5_pOvEUauc0Ok0MnHwsyu4HCD8g_NDkRMw0qE378VLWBAB6Q2Dg1EjK7F-i5X8S3D80-MvADrOpYbs5sTGGUv1uiGuO7VbRu1-FuwiIYImHx5-UyAYvMWRkCXS9srY14tRN76R2LJ7GhrdKOWZUTTrgfHFzdMDnNbniEhCLQ5CeFk3Ghnw5rIUVg05UUxjJLoM5uvHWEiiNMht6ykpo80zowkPcMqcgTzczXnQfKFQsX_55oblBdQspygJi6hG4y3FaE5tuPBfOtwRS4giuRJS3m62oLwae29UXoPd3hKVnWC-LcYx4rFRWkZewZWI7rL8hvIfRfIazuliTEXw-dhfsrMLoo5imRBGaldPwyc573t6_b7AuOvxfsXOETYaTGBJ32PrpszZR7wDmrAzBXOeg6QUu7F5IHIPbfeDiO_vXo6oIM1YGfpmKDS4XNoFQjeXZbaCMH570xHA90NTxdjy7V_UVjhkDQ-kwSSvwBDzRYxYqT3E6yuwIMGmZpiGjjcULXsHIfe3hO06JW1gU_dNDb8eGs8zYebRcDfXxuzvuerzkm9zeHY_kRVFx5Ju3s3KrpXp2sp8Ptl2vYSnOoPMizUaWunk3RdP5jlrR-QpZaBRE31VImYtYaM0ExG93q-hsHnRStYNs7JwtBqR-8LuRdE1aYZR2sWxDSJuGvGB32jQ9LoZu3DwqazB8Tx16kimNdWrLfZz0tTp4IgmU1-gRHG3IYkFJ-KT0psSWZCmXzCRfuo_LoiirRgdMx8kRAVSgCD9bCymmO-Ksm76vgW4WD1fNwxiZbugWZlWwQgCDaFN9PZJCE97laPlcRzuJIiZtqckb01LmukO1zUI3SLR9if5qHboWs7dHRD9L2-z6zI-YlGLqbTpVImLFIDRnhkQNcAmWn4OCVqY3pRkIxWpH2dcCOyonjHzG8CcoSjD8GFrp-69a_ChF0l9RsAwTAfhbMvpHuKeM5-F_cndX3e233ZSDxa9-KI6VMIcyBqy1Ndj5oH4i45HGEkKB_RbcmyNVGVRUF3u7hbMAPI-I6v-kbrcrpoP-sT0IYs-usC727Rzzf3VSWfA9UOvd5kweufbcFeA9EfEIn5LikR8GwBlYIxstxZbaTCzzS9aNhpMS7qQHyV2evsnVp4eNAAyQPWXGmnioQO0ohqiZ8Xpg7sc3_rQUXY23kzJmYHzZf9q2u3lerzzlyegibjk9QBfKwa_WhLlMX5IcRUJRwAGUYU6zVEcdRIchLFhYYTQFEEAYjhjyXx01PsX1tp0IB55D50Z0cp3oOrDHBWs_ZTtMRR6qhTqPNreCaGMMLYBQMF5_smwXEyQGLXjtpSRbzlKDeLUe7TnVQk6zfFtHU9ec3p1hRh8erm8tInReLgYuQphHY6ARTDo31enNAXwFaPcH6JSWgOEfCKzXsCUqaaySTdRHtUtY-_5QMfz2WXzUB--0TZT_aqtkjsHBuh0S7In0iskdg1KiGNosXvtQIjs6muCzBTsBXsRaov2m9Uchs5Xn-zveC5Dmn4zarbFhIxezxj0RcsIBLpqT8cALLZUIMXOJ9YgdP21nJgdjNwzgdYVWImgrIS6CRb5Eqtn1uh2K8ywmGuEBRR25frjuFWJNuocYt8gi-yPd3slYpggQo6Alb6-jiQ52qlgVtjWYiGG8U4F_1Zm8TlvMhWvKH7S8U59bKNbozK026GVlSxf-FGYVpghzSbcddTk3UWrtD-KXU-IGEi0BoIlfleIQv3ZE9Uj9djxWg4GuPNbppjEpDhD_O9h3efS-2XA_9fqL5S2hb8K9FuIObjcxS6J0ya7s5Kvf-O0mwRSd9WbfoHMqzsxZuiyzJWj2wWxT5KbxCURCBqRR7Tz0b-7s4ofgVTfQO9-7FT_KW6B5I1Acqrt1_BimumGJs7lZ4Yu8D9EMqyaP87sRrO8gv3r721i55E5oR-CNeeUfRvdB1rkmbrkscLVckRxwqepoFd_aiYjeMPXYSeh-eZNRMYe94DC_G-huRMCd4x62ytJ-O1J5kccXfD1Y6g8Qbv-CJ8dwcMYATgiRfx9LShZfVNbk0KnN8Zw2g0gHQcSp7Wz3_orSNFaOirzGQk2GvoDlzmjneLC18l4TvfjN8LB2KxqaBhsgAQUkGSo8iyerDrlJW9qZQi94_wtogGXbgLXXGsUK2Nru4OgnsYKnO8wOOTM0Z50pAkmGNEFi0k1XCpWbXCXumR1-8j-M0mVdsNihuuDq47TLGgFDc17GUP3Wg7kuKosHQmAlrGKLx5Hrh2vi7oCkCkdqI1wxzEc2lS--YSRwtYoTlEPeZ5WPF68KrainO9bMCS1xZ-O9e7b5GgEasLSkCPD1V0vokTTIq5-nfJg2kCUReYRW22iRZcn5cse7HndCRY7b7KPVv5K7VkINRSRdINW5RprbBy2Sn7T7e6MeJG416-VhKvQVw88rWOt62kH5emTldAS2D_u0pBIJlfCezqLip2eWCAICN95CkTOGA8-c2PRnnZ2_g87k2QzxMNzOY-z56eYRVxrAedgLwLyU6eMTP6T_12Zb0HDvFnnXAgJRYYD88Kp1OVB2jp1DBJHijVVkou3E5Vo_H2i4Ncd7LIF7ijiRUxdff2RMkIJhj2MebGwLOnTsReW-V5_iqLtofyZTJVMpqzNTnNNnV7ii2IevtvXS1gfauNLlglnIY6jxNt8SBouTetglmzUTu1C2pFexOQ6Mledr7o4IavHsMiTC9RxQGBXS__57qoOVHV-YPJbq5kLyW8oqFOV2uiISeTZOCD6rUT9cg5SIliPeKvkRP2ScoIhi3UIVBG9oIewKNQTwBnJr5fgk_wB8voQmeNjx-eO_UzvaSK_D2qCaN8wdckHWvDaQfEbMbfcerOKlQrm2aLm6Cmncl5kzVLabxX5Jdla5R6TG6_h5oaLdatk-atVA-IwZhYF6D2FOReRU8jNuXs18oME6mtJPHTxEXExmUTgm5aehonyO22cfKkPcrZkpK4iVHkkmdGp2E73dSugpIsrhbC3dOmeUpesrAqrDZczwMXHf0kfMXY-xEUI35hSJZypa_NMpSmkdvkmwlyisBcl4MO2Dk5nB5HA1JPH1jY_pmLeFNSp1U7fD7bCXP549XzHW0eIEiZJUndsHNtbys-pQATUDuWH-u1igQ6oN9Z9arUMMv3F5Tbb-Uw3Rmd8rkDfyBq-Dm3Bl_3TFAyuGzary7Fo2-TR9XAxz3U5PynIRXb3dJCBV4kSsgvM5EWYTj1zlVFP2UMU6JW6jNzWoRffdKfXPDs0K2x5cg9rWfTCHeZ5D3-caqphdC-li7oUn5xYhoIyEae8GqYdrhKcIGD998Li9cThouquGZOFAwo5yCqRXLFzryKcHUClzV2Yi26hSYJ51puCl743ZXebBT0DJcTrbtD1lw26XQ8rcB4R_2hZWykxLWAsF0LiLsDyXUvKpWqhX_xpf1Rgzw2jpi-8Q6JfqZDl0IugiGxKktDpQ3ZHJIr4-8n0DY2xTrX_vUTS_jOP-TOnM1Ejxams_EgsgOj56Rx2hoFAk8__TVLWKnnUoeLoL549TSmiDs4X5kLNv4NMIVPWe7Gz7ORbASVf_yhXCM8xSE8O-CiJqN9DIhRZIiOBdI-Lo8CLsJ3y0Y229T0vWBfcrhb9A0ZeEAE9oI-f27U6BZ1UpOwABiDeClh3nBobTZvNrLr1wEAsWN5RxVexRarXkd-EBDM0bzWu2K-2RzIfWAgscKYBr_WVTkf4IvUGpAxbYGNTRSI1oHkkIPfaIAzWayN4-8R3TAu-rAzgWsnU8E-Xzxd_Wu4orBsx2DF5h6nfSBReESsMFgAhGoYlWS9XGka8yqktEIHt27sdoDphOZ64yuZgO1zSl2G-Gmd2dgduBzXQjzHyvy_4rmbXAp0Kr6_YBbiyeYwFgxqI2wCugC6ghvCICYOUsXRGyZvkXX-1aXO9Q_Gj-I242O_q50WZ7rgiAicwdGd5DimVQiEgc1zTb_rXGYEGlfov6mEcuG-kYuvUZvyghjqc4Id594YtQsnxad3vw5MgdZiMhA8k-Z8AgtK_HPlWDJLQ-9dssdj3TSRkqcUUuoQLNXVosjanSurSG_ouWEujEYZGte772LwsLs2x8cWXmMUVbG8-bqK9E1aavFyk7q3AFPSDQGcsx3-IQpwGOrFI2sJfEwcYlJb0AGUc25rswXtikQvIEuSYPIsxtuGR83Yi5EkAws9Elwv9v6_UqupsqWR7k2N5j-UGfjiLVWCuUZUksudXhg2yDFJnoLoSJ9-UtY5k3IO7KWimItzLSMtd3A6OhRLrRQy3WO6VtbP7suQs9Yf5FHeQk9s8SHL8PWW1Epivk_s1BqzJLxtY6N7nlyGGdQpuVzr-awOBEyIBp7UDYRjKfjECxEAKAiEyh4UtbPSqXWxq2_yl43p2qaCkhvszYki4S7XsyTB1CSYj77rIjcZqKC2IQcidKJ2doQ0u_zxSDPXOvkR7G8JZVYZqWG_nn1c9Cmkh-bUzIibYphjzMtHtDa2qs3evQL2xQjPc_UdZIrCGIbNesFETD6QOsfXXgNO4Ephrq4XdU57Z19hv_X1wXj8-qNsQR_Spo2MW1jVfxyNqsgRfIky8xYZb9Sg8k4P9t6g3bYdG6QL6dVG1M0hWeuWoMrTadQ-xPT7lpZtqHc79-ye6Iuokq26pCPzrz9lPtAKrYlmCdN6N2hOPTGtvfKxAg3fbEYmkiGoSZ_M9-3Wb_V8GbriEnjtM-EZkaTdX3APy7dfhcR0mZhflGZxozCWo0iSpPPEORbHMayMiFaZnA_6j0HC8RIdOtNuI750rm8jN2Tl_yfROUe5bdn8GKZcKZumU6omijd02chIV6_63G--RH2Yt1EFI5fB6hbpcCYmxmbGj6rTxVQ43TDgsxG0g4fXNaqAXr-L6-vaprxN8P91RuxleasKKVv-YuqCYsmveIZfYeXPrC3upCD6UGE3Ixi3ludh40Tu9tgysiDCK32frcSN8DV-uRRwX2lVD4tTakXdDcEkcqFkNkmM8SowM1RnGtMTx9SXlDiC1ZiHhDG1TsSAtca8hvB8swXKzMfJonSCRg5CEwxnrpAW3w-EGp_T9ugGh5PJ9ohFv2g7rV3hqh7wV5uDNOdYoUrWn-OKpJ2FR6mOLXzp3DcAfSlvCiZ1QuBLiaiDa_6n5CWy5Sywj_dPLmRQo0Hye-30ff4LZ7OqbZuVS_P-b9Tz09CpYDw3eBfb5BpytWC3xS_2WIaQh865UoBS5utogI2Ogtr4mM7t3LFNfNGAwGLjsihfvCMNM1YHto3-ndHB53OEnmHg5Nu0f3hTaKUi7PLiJT4o2ZCyxgA3J0y6OrnJbyU0L5uw-hvxDH0GRzgcHxunLDyAsjAGBBSpYTJ2Pfr93N_9CBeOc7wrsHMlz1EnV30szekAt4hRppZhvQ9O38HdGe_cS7kwv_vT7SBuDnIzIu34LHpSJz_ixo-skA5noAovO0JQRCpsVLT6V1rI-3Qz9BM9XCdGGxtsv3PK6LgMNAp3Y4zkfma2OYmc34ICTx0asDkLIgKTSy1k_aLX9tu9OA8CHd5jgsSc1rKczv7fk4nrLAKb4jDsAsTX3UGkQJtA96LnPGENYTjh48v7dUR6M8xLEHU7j4TTXjrElzuOaPGNNA4r3mYJqJZo1tB6dzC8GlPHgFi_xhx0l3RczhJ3LcUXapFj1yzoqrK2mflUthGjkIZ8MS7xm29sfIJVteus5xV8OJgMdEIHaZl4XcEJm2GfWMZxPonH35JKldhfNg8ZrJGfXmmNpjJUJ_6j8Pdm_RmT4KFr5JJena5oR0i7C5cEoEG-YBMRntojL82a9nDKnTfIKux3oPgPurf4cuqkww4-rL5mLHEtCJuOXka60fNBqeFv7g69nx3uXWRdtV-yBrFDoJqi0X8yNIRqB8GBgl4xYcdxVMrvGiDfWMNgJgcCPFsc8kVtHY8KE_6juDhmqik4DRrpFqZgqoE-n62uYL5tYzxmul0JsgmXJPoa0vtt6YMLBxKEk3BdB7nzwFX4FTjBm_fs8BtRfMWIcedTCBt5DjeoOobFk5eZHRs7GmL04417WFbVlSYp-CQ_gGPq3dcW4jPUtiHG9L1_qhkckEUNEXLAV2YO5jG5eaWxt8f_DlDJixt2E1a8anKHIrgZziO1c5iMgOFoHM4SwELs2og5nxsGp30GKqkWGQfGjvsl5ZXDulB239QKW2h1aw0BHDQDNMGkv3vx4PJXgxnr07BV-0MkQ1olitDnbPw3AIDSlJmlaP868jCB8Mm95guj51GaZ4wSqSjpSEUMtyrhDw7KEGtG5YmzPH1CaHHPeu1VMcddUdCcDdB4zJJJpHRBul3SET4crXsvBFtltKzJFuSuSr0cVu1pjGDcmi4t18xN3P12Fd9fCwy8H8UHE24BCc3hQQMwDMRpe4rQ-7LAJ4EMyz8Ig55ots20Hf2eH4OlKXkqBLTZLAnDP6CG-ZrljRp1ThMUyhC47B7WG29gZZm7nhhjT-mhMg9eKTsXOi4r2ukSSxaBHRqemFYppIm5yKXp2zRyr9F-y3N24vAUnxVlIV1Tu0PP93x6IudnDHwojyUPLZtgJ9VB4wmYkeMfXNjd7cikq6z8gRXaFMptjhg3G4fo__6Pte97nxBnLzzm1XR7Tbc3TpKKcJwKspgfEA-kELbQpfPUOcGfqtgEvItYLwUGpfbXRQ3jDeFLpsv5LI_hRRQ-qn9KI1RcgDfJH_OrAWAVReDRvWevjnSHIVlWdhLD95KgxOQ_QumIYQDpUXYWv5hLltV7adSiig5CiaezlXDXMmCvM_IYTLDel8xwgfLFitY9G5LXSHpTb8UuW_vvp0iulkXP_Nss1VAEgwHnnOPSfI9Qk_1tIiedUDMkQSohYkrACrej4Nv9TcGxZDP_AdSTWxF_Yk0ometFRZVUUXnBjSZ8Ah_0iB5oXQXcTTlvpL40RXuneaPNpvfcBG89GZMAdt3W3UKDG5aiCDsFQxvFV8WE8RdnYZ0RKoR9_IdM0ZGiaViheyx6u4j1V0s8Pi3c94FnGqWWyjCvx60ytmeEZA-QXyR6txPzrxPpRcMccsnHd4GZBWIVISySnlekqyVdxc2C_lFTPtCZPhacnwESRZGrem7k7ONfr87EqJHJ1q5_dgNR8tBQYkwKH3fYHLZCj2mHGtd0tVm5lwLmXzpO_tB8S_eTFqoHAVFhCahApoPS_AuwkwizdENJJneDSLkgXURxXckZm-SjYkemUUXXOBG1pvJ65_3ZbB8WZGBvidp1Ex610QVzbGJrhbaA-K7jv5rdFYiV2W0Ns9uOip5maRLa_2ZcFc_AxHeDOqOhE_TA6tmIn46dy4h-hHZUetDLOsEiwQO8Gq4LUo8sHUx9KF6KZZ7-jeEbfCCqt-_pzCySH3Edr_hzn7JCKXjW-TzMUnOjG0CiqRN6qgMpbk4T04fKhPcmHz0D5SW2p3i74x4K63GUyqKj-Im8k5x11OO9m8KM7knhPzg2OrZQHH9vu2GuNgxaeGQ40jkeuBCFdNXZZpyiYnE8aoiYuwqie12gY80dJknjb-W_IVo4Utr2uvdF47_gfu0-S2Wj7_sz5LjWIJO-gyGWqHyk6OkO4jZ05gkV8m6bSutEdc70GrYvS-neoGD6mggqln9egL1ifnwYdBTxqrG-4BzZBSqYJaqdM_YkkEEvm1SkV7A87xFUSTD8Df1kM-g9y3_5Cbd05YkqCqScEQ4PPw8GdFMu-3yfBhMK3DLK8wniEWKD66upR2PfhYjAUe9wC_BAbmAE5Bkm9hQT8eYBndVHoDcvKDzDnUZqFR-IBgKoowxO5xf_JEB8__SlSWhpsP-pthBgdtmJeJSBmqJdmO0r5GWii_AL-oqMDprxVH_ryEyR5lyDk3Ocez9AEopWqRaVOk9kkgOxGaEndUip-UC0VgLwzrtw03tdV7QN_OGWWzZPSyB4t99JFSxd6kGaLeWxmuf_JMk1k4PiI32D4xen_Hvodsa7DTV_DmLQ-uW5Z5mnkJzIjD04l4eGCnNfUbhz2eqfJt6_aQKQdBcJj5QiJG4PPxNoN3Kem_4WzHLUcEMIAS2BR7kaYR5lEekf3UF0-vqzDn9JU3wu8pmkUR7LFlMfbK6vDG1IeXLtv-ssV6CedlcYZgls6ZDeEkKbrsKDpPnrwtzIoTC81nKO4h6aJ0UBOyeCwi5o8n1xifnULsbG-ePWP98pIy1Ls9MVPmOzujw8HupISna6ku5UUVUPCY2Bpi9UAhhOUpqVI4_AIITdKdYV8pltwxaZpMiRtYpbC0cl3WwIno7_L8j09aOepA1Im1s3MQR9ZJdWZo240cRU5ZPGo-XbJcaRxom0fyRUoWc_rQFkyb4UJRb1U4-OyQQxhlMKiw_qTMP62DDvDsvHRv1O2vJNmD_DsQBcTGZPqJDk12fSfYsrtQBrP2ercL6xCqsFSNX1bw8ar79C0Y9FzPRoiX1iEUXd9s2AX5OJlWP5btf22K2GATrCfTrx__aI1Z8D9PnrNu1uNViVjDf-U65xdVP4dwzHWhExESBHDpSxw79Vcn4R0ers7OB7QWJca1YIH7mUCiEgsbxpsIFOgGdf13MMb-GpYm0SvTZPSXkmkBgw8xG_gyU7hBa5jjAkXadiXSK7_M1mtnUL4HMUZ3CwChgaNKxqjrAL89052fDfmkx5i47af-pZPTLj7J0ajRb02KuV-TqD1Y20MqLqn-vq9fUN48TYO57uWc-tAmYzgWBPp93p_nMBpY6t04DqUQey_Sb7P_MwPKn1caRdhjhM85raqbIPw-smbHQ0nT-jZXZ5celdtANoYBghjzERJfFfueI-c39TLe8AVn9aSV6HkjKPFCiDoiaYT51hosDPmU8_ommzDWoLRr7ouqbnhYvyoiRiUy4LS98XBybCAeFlNEvD4D0JQwd5Dbnaa7sJyJCVa95heqbjOH_4rAUTBMTH1HUFV6Jw_8UDfNyh6ef2KaMWoNjs01rsQ8wafKj10p-MOIdt5Kn7fRHuYsKBkKQoAgu90jvKlFj0WWFRN1tULD7z9jwJaVXg2JXdG77YP4zTiYWm8-nZJQsQMfoq5M2xN6-P-uv3m1E7f5Ny4aFmfbyLAuOzjz8PU7FqErYK24JLULhlD31V1FLhQUrjqRFV8jmg7mKEEAMmat92w-e5po3aL9SivGTi7KRIH7zx3FGwPn8E5fAZs8wumV9-LrfdLlbUyYg7_fUke_TAxc3aZjAKXJ6JOxx9jjRMpMBSTkT4vcxwCyLU2sB0b21jFKQ27lkFq39DyKVmcZ8WLKf0bpDbqU8nXCfiixK-CDtMzNc3WaSo56gooMEw-gVwU_6Nu1bzvAF22_R1FuZLf6WQpZQ-YJbkBGkPF1EzUBNF0PZ6AtQ3NwOSUWEmBF0I2CZZoF0ZwCKl7X4UivBSrrhsBym3CFQnWzPzTvBzYO2PxelN8AI1q13tsgVBNa3nxQ4qALiOQqfGTx4YQMN6FMyoV6AUCbrzRkeDGnjODoFeXLI-aAYCSQ0cuvrYrDRjDuZ9kGSaKsQYoP7_HjT5wV_1mO5jdz5gAsd0MJ8XtI7C8zZMTUkL7VtcZFGF9wrMG-unYMlxo2cdYz8kMeeur_kzwWwVXum5tZJZs_tNIB7qd_lFOHtL2OY8ByeZwxRrEM8MfmhGAW6olN8wMM6AoxZ9bcLep2yEjGWrtcxLjnAceNogHDb0WNVrHwADEwc83ZxOYO7JiH_nMdC2VnsHVN1ytmgKD6ydl3QqaNl_uMKh3xjjBn29HwfH0VrVCEv28bOgLBlEjNrLTjjaFRok2l6qRMok-7LjAbwXc71y2c9UQPcLad_DNsfCKMDOp7AuR2CWGawxARoF2WYEx-QSgjrS79eJP82rwVAdhuIQDEafcrJltfBuK0bTxQ0BNxYusTKKTZ9z5MvA8X6I_dxOnIOjW-xKLCBmd7WkDhVigg6j7M2cHl8kocKUStUJX-fWI2XcD9TT9OwGBr0zkJpJced2-_Yn_QKmzN82vMrWAGBcJzsI55XugXTMhxWq-EvJt15MACOWzrZYSeQrykygIyWwsn3YzvCGKVYXZae6Y6C7Fve1e9mFBLEC9CJtzbZ7seVZ8nbv1wBwqJXlO1UXmKK6-X0n4d3cpYlKgjYUk4Q2CaDKEhHOGa7iqr5N8pxzHNg3Yve-svc6hraK5jeZQJ_ymX14S-EsrNQhc4jeFBp2YQGtXLvj2Svh1CpDUT1GeTx1WAHiwaeo3XWUMCRVN85i06AaonEkkq5hm53Lwj_NN-nRqqQjOQR-UgOfJKtQPBHa7lOAdlHmy8b8n3Gaz0JEp77oF_mJBpF9y8wHzobUzSbPNZ_THMQG9wIWJOVfeeJ5wbWw6m3llvquwCmRFD0SASU-1tj8OtrowPdtGqcV-2HOxhjiWzrXtB-2gumMYAuOuuHFZgGcQd8-h5fsZ9CEm7YiywanEb_-LhYLM1Lno5DoAP3Mwp3J6BpmZBzxxNykP_BJOrD_TIi0ukmZy5y64K45PS5Rr1l9tecajyGmBp5IRW0KJgjjTSAEoMZbV7lHcIU3FdwotFla1rjNB-Dru4lKt5Qe54mB05Wag2KMvXPNFGu6_zLtNXbw9VZh-lYjKos9-oV4zvO4osjqwaICv0FxkXd4RglF9zHugXen3ezG4kZ0JBz9g53AYkdJhFTpyhcP4tnxz14X0Jlh6l0HOD1x85NDG4pUHrQznVnPOoVA9ZoCeTVVouix0kH1aKWcJ5RNoDh4trNUkOZZtWGs-Spcs2WN1n6fVN9HXZ_4fjSOJnP5UuDBAKF2cMLXZNzagZv71hXDh40A3rA2lQjrZEmxo1JPJWQVWVUA6m5zLPJxOIjfxOGhnjv9-Qk6jXT1AH9ewG9f9mSYypzGxPlhnaGNO3dhVvmJaJsJUgQbJJ3QqJbmzJ6bSIDLr8DJsSbeUvZrVvZL0-XVT3Pkni86dvLjplQ0cm3yC8Q72bgz6H8e2JlIES1Bqok4HNXuxBxjPB2ITqft1Y4lpsEGALXuRbaYiBf_btK9Sy1QIyDEIm6CVx4I8f0Ce0-nKZMgfBYtz3WqqD2z97HsV6Ypa8invhIhB1DqHRZFLOeRxt-skWNGNFrWAdpuu6QylZJZjjgWcDGIZZT9li93sbHyBpvxYU1-QFCM7f8R3Mthyse9Sg8UElmhNS1ppsgZSWAHtcEw_b-qA1dp62MRV5P7CSMHzBiDmqBd3e9iwhRKP17l1duZHLWal73CIuC31wLX56DyYZK_PkUcE2iJWxwwOe-twOhbAGxr73vwZDqQGWvSbOhlOhE_vz9j-pZfHJZ6EwR8Gx7Oxf5zenpvCKE6CKoBYbUy2f-9aQECGAlr2Vuo6chhe3s89QdQEDYh4OKAWLqpcjjO26FIKv375cbrNHr0PyBS-8n0hCiWcqcoUPKYTZwuR62SRQ7pLHZJzkDKPkWFEh5vuB9Hr-uqTmjgAljZbxqKnE7yIs1Dyj_j87YbFRYR6fadxwphncLD9u56meAmuJR1X5Eg7T8TKwtv-FWil3Ljj0pVZEbE2V1FL_wKd29HBKEytgMWoIEQYxcVlfJg_tLy_uuNABf2SQOtqsDr68rYfNKwiEeg6_qy3vDhAEUwERzDmEm09-uLkuYioWqcF2a58RbXM5l6cIuH-GpVme4MYUSIeFxOl2Ghd2d5_ovrJAWD9FkmcrbFJxvGC7OPLyWJr317OJZuKZCLBReGTaik46CNbad3poVwQQ64QQ-2WxiM0iliFwynzw0wiM2HC6Ef7V_RO05G4QiaE_eNhyGFOISlCdEPtnmtbH1RaAQjqKBFJS-BvMVojvM3ylx4u1uCd67t1uRH8R0V8GIyIjdN5yvpEAZiZR1VqY9wSzaQv798Mb1rzOHiZCBO_hDrFqqyutTtg6nBTNek6WhhFF7nYSQasnjix_mNr66nKFBMeFS-1cwJynS4wsowoOZlCfERnYGFMWBtDR8Sht4wDz-hE_lF1lWelEPOegTSvnIy6DXlCy4oQv-woT4qF1LAMy6Ie8wvvtDy7LypnZ7GB-Rec_cJnb2DYT1K0F-sQ3sPcJsns-0Pn08Q5kXOP93eOtH5IahmHd3pqLlKHfajA4XMkPubwBBIWjAkx_2fCjf90hBbB3PbBPb54xffkT6tX-ziXfetbEobHq7F_NRhPiyB9rhaAiq4wML22471vonHtlnOFtrDvbEgBh0qKrWTVL9NWH3br_hV6jq73m3OzwvG2IaU7Ghw83wKVgjVVS5LCEdv_fnxTBfx9KW9pgalZhyTsM_2bTabGA1NylI7Dwi6Ayeixz3Hw3kXoRPkLt-srN_Gba8Tgy3alr8m7thfRnf7TQdP7aQXZJ_OROz8CwqsVBovTd5fC6ykCbI5K3WhMAxjQNfVMa2H9wZCHIcegRz-yeSgsFK4vBV11c8K-UObtIpQFKl4VKYjh6QP72NVPYN3yCx21HXQwhpzV_ef02CX_1PsfpCKBohksFPctXySlenphwGe90CSGcPlCPrPIJl585aaDgNPdZAr8N25FCTVAmcjlk00u28-_kdfqnrspBw3MNJbP-4jCq1waKVCW5HFmOZPb-JURlQFU9t9tx_tsuBxJ4g097Wt1hv345GFoHPjVfurVsiiyNSJtHF5IJo552lLGSj03XDZQFuAII7SzzrjRCG8ODO2sfG5xkd1dI9jv2dtWXkFrD7YdEQac9SEd5Gjdf-U8aXgabKPO9fIXfVgNSoThvbWA4xt-RnqL0I_wuUDYAi1qJmxUFTFdZFiIbNccuM7HZId3pg4azE8QG7gLmaSLn7QUqoGh4tQC2qz4xm3sxEGC5rt-qmGoHttglPp73-k8X0RJydlyJsNOp_IszmEZcjgviGSi_sI28MjQtmwKc-dyhkb1q7zpIO4lCvYgUCVZljZalUPOjpujFnhow9Xg158aXFIixg2Yb71RJIUPxE6ey4949KiuizkfyBVG26KhjRrLynE41oJsSJgQwhewn-0wTMfr7eGs2lngkQiev-QqeJJTvl7jsd6kxR41vPkUsDzQlAdprpsD2ykdnAsi-edwEuwg9YvJWIZur9eZgj7XQR9d37n62TB4uexwdY9ZNDvQRfFYwgYsArk-7ylBhwJXTGy8os7ZM4qPS_aUo3b0sPsRvK19X91jZJAue4peG5ergnV5K0kThF0GMRf3NO6qglQi7ZvwlG4UzeUdDXmBIoLmlWylaoep3whhhx0wGOE_Ysh21TD3cSM_J2pTC39dIGp1XAK1V8KJzLTyq7G3IEeoNX7lt0GoBkGeVftFgq0h9Fhxk3ETcCaRp9XsHXINfRDgSlr5MVvUHNvWV-7CF4FuQuPd2ZzAJN7p2bQw4YAsVlAZDlRSn2XMrFLtLyMJYbNhzk9epdzERUpYJihhWMgmOF7oisWLFzM_PYcXBmzL6QXOCAWlXds7SZXYSRMgIhznoW9k-5ZL3cNbd5liBouJm-JmWJYT4uEhG5Jyg9QalAwDxFORB8KCjNlMzUqJaLorbgzQCH7rNJEi457H7ZbWF596zEQf5v98MGhK5RC7g-ddwk9VMAuvWwGawgg1KA4LQHZdDSF2bxncedb0FTbfEanXqXhM1trwzwnHOOx-8QxDmZM5cuSgSRNXfiBNunnMCusNejqXAGEe4upywh6NdLB64IHIgp_uI7ue44oKi850Q_mildIncQjxxvyP4kQlv_RDrCesBQcgOoaj-wuIA4itR48MEYu3WuXo-l7AZS8OO8_JRfTEWcqf-oUqhdecYpDLxB2ozcZkW6Ul2CdHzI6u3D9dcbDW4uqcdSrawnRfopiERxHyRD38HjOBPLViFCMQuGl9UMiAjp83LLNOZw0-y8NC3kA68hpIjWgK4FebA05BjdeFU_ydBp6jynBm1LqcrdcvtsgvQKEgEi7k6l43sYCnK1T5ImqEdWjrb4hkE6dnLumfrox43rPtjUXDmSaYoKd2hVj5B8R7_g_lPEg2I8N0j2C7T2hRRuCfWTWhoerxsomJSbqGXygxPlIdrYZe4Hzh5rMIYj_zWD4ujcth_1T_8rr-zL3rv7gfc0qHKk_8cVDfxlj7UbySB0pSmDwTJ7VhwBfD4Yutv_5XbP3fMF4UDxBUBdkieWbJmILb4ITr7qYVROY7MEJ1BgvxiNN_6iEpFeIPf2VV03mVOvsuxhQcqjaV0o0YfhRTB3ApTm6Yc-55kYyeq0utvkNks98dZe2-9f4lsN0XAtFkY1dN0B6Fl4JQyQqJm3MK9q7yY5pDlp3kHF1G3xSnP4MkQZntc01s48WaJACZuB2UvMpAYXNlI-id2vMnnTWFzwxYx6dyP7EelGO-lxRzuWr_gtztpI6ek1GL8Q6bN6fUDPtsTjFWoDk4gKfbU0Fu_Jj3jYnE2lvTmACbHEDYqPdPZZedvxd-QXl_VGBiLuYmwZ1AEcDUPYL2sNA4DwufKWjiskoSmflls0DTjkyQM5VcRvAkj6YBEa6P8UTNKMQJZwfSlVeAbDjMPDL29U0KvapiGPksPhJq-cNHHjpdXKDC4fgd947R1AI6I7OgoJksM5a9Vuqtg3TPBCSWwJO0h0E_I2ZtqCCt9UIQIP_gcnvNHXzZ7nZZxAkBAaWPMmva-OUWhGUDwCM4JhY-JtszECV9a70JN4EYCYEoRCp84EEgUgcox1czOe--umXzE73Bb1239VBYDZXuHcFCQcFIQCPJR7yNaSkADZ4JuKgOOE3fxtmSbAOooY_YZDoQYgS64LfUe-NtJMb71ZGzuTWEqv7Uv51kxWeVdPuPPgCksr2aSmDMFyLF83xOGCCxo5JQ7c4BRStVchV1VAmSjgKo6VkyJP0iBUOIY-Qnf_42tQgxwQUMZPVi7bu6ncvTG8CBOjXpzh4zvaLnS2mieOXN-hXLrQBnB2rkbLR46wb45c8M1IBLEfvBzPM75xLkcmcJ1BZTl-0Ybirmf8xGpUwWbtuAIVb7uoIOCCIDeq1IhJ8DFtsWuzvKVsHCFrL8qJvCFtDUCifQObEp-ylLE9vYqD_rWVurnqM4IqCqdFeJG0hYEUjwes86BoSN59k2RaKooQcvHYfWcXPJLX4z4PdP2O5r_Z94mPYJJ4eD9UXQTmSzFbacvfboTDE9PD1ZMLC60fgtIfgiUs-jUlLgk0OD5tRUz6D97PMpAy2ij62HbQrrwjC0A4jRTPT3dCszb8f2FMtHJRuexIqRp8doL0mkmz8f4beZ4a65cXOGAeqQAK7oaU_qv-P2aY3ANCnK8cI7hSTSuJwlGJeImzVOZHXbW84mIow1kXUooTaiBoK_Rq5GFMuKHl5ku5iLPEt5sTax2-wdfZOI5ERcrsTjH33pr-RnxTjQ_gc1qj0zTZZ0pctYWVGuBjnaacEKpKtUAiFOY2HdaD1DZ9SRXiuXNmF07g-7BY_aEjzecemV7mvMn0C2vSpHPWB1145CeX7tpFCnxpv4uybKv63RJ905T6HELd3gTxnJDkOaS_BZ1GS5IkqWxreSpeQMDejz2jd0mYq-uc3jX6jYtBfI8f2wQHSr7PTWXMrVBk9gVs53AS_gDG5k9VHWr_Qai7IsBx_394fnnexPxT6zTiu9zKUce2wnjIyUgW6StugTdLJ5cCoZo1Iwv3umXWD4DZjg2dCx1aocA9u76OW7yORJBNoZV4inly15n0pDgvWp92qqX7WxNhnUUQaGcGLy4kZh2-nYoc42N5CM0NTgQc3XtUPwKmyfsc3pNn6Zz7HWWNmqH2gHYVpMMakb6JfyxevqE3FGhRwqKL9v9SK5tw2JFu7oerpDzLvbEwXGbsI8lnuOV9oIAiwPwy3pvZyQuqr9S7vA5X4S8TmUtksCkHYjkA2ll-MffNJE8_MKRVcIUwnSRrBspJATb7o_mraovTe2T9R7zrk_0iIJtckYQBWNTbB4ccaSFH-X8a5iHIQfLBQjdMMDyJa8zxVD5JO850493OzzZwonKT36fcZ6ZV7oQE6AARw33Lwu8KMWCCyH0RzE6W7iBS86u8aIeR_MdXiSISajcTtrj3b5veVwZUGAzJBksyhnlIO87-T9aynCEwaVUeFamGVp1qLiJfwOLnbgryPygopVq9eZfNvSnvrsLhrBJtZ9RXvfgNA6kvfrfd_ZmDmgTYefqyRGiu80pRW3XASnRNlc-jioSo2Is4s2D05PzeVIFD3Ju6NgCTH7nFd3VK3_JsCcudvKlJ5oldYehy40mOmX4_Hg4MKfMc3rjLvCiEE4x-OeE2T-920g27fKX6MAZI-_dfSfWJSLnJvVT3BihTICZdA-8x7VO2UJf1k4XBY2Wez4j7xsLmYW2Ezuy1DjS1tJs6eC5o0_j7JEws81hg37-jIEiVyv7b0PogOAM3zlEMECVIAt1geuaxvawEYMBztYTkRmYnXCD5EyzxqP3lLfgaRlUR-4SsmD-Uvmg6HlBrgId4VbVu11wNHLD1cje4__NQfK483GcvACYG0ODKVq8MJ4fbNmzirPADn59yBWNCJcOKm0ZidsPsNfIjfMkEeojhXJMF_xwSfhswsAHbVhw9VZrDCcLeQ5iOGAoKmU4p8SFz8igzRxf0Qm-KA4i_i7WnO_fsj0bQN432XQbSz7i4lqfP6wzSZ9njZw7fJ7rAXsXaph7xUsOhvNbYNBALQPNd0L7YVn-qVERfvLP78kWaVGumYxFRwYeUYilx73N832P_mzzurzrr3e3T6fTk5sc2DYnSdF--AWFjTAVHpA936rx01DF7CI3noCBtfnMPDWSsQQoBr2TtgoHjDNJMRqOtBc-jdi83vruhMbanF5KVXxH7SpNO1Y07n1ZvlgFQnkqzEek0BeEM-rPvGMB3bAprGBWzM4wv1fjRwkdAtgrDqTdfcHnaAgN7JKLIak9JTvfDjp7X8_Qp1o5ymQq5qP7p6W9rYefEdemg5iOJwrrdh41ZV1UgJ634Vovia9yzOaOhj-CJiMsvvIXE_bNco7XAFlX6oO5dR1JPf8rITQ9V80RzErPnxcKKMqzgC42svniwfdkaI_rBoquAY8H53lqKLREXsA6X_7PuASEmi_4qGvGFaC-Y1EvM1SDfr6Gd5qLvjnTRIcPV2OC4v-yQbXkK6rYZ4c5RIH3GDRwZZ7GvMmVo6mr4EJlZD7ixRarwQZzDkbVXthdHEFL3l2gabMAEHG4qbkot-dEFvoENJ6h3qiHs5h6c4bxlGemaYCIcmCYpK0xa-ndtfi8g9-g4K9HEQ59mLVFEeuUuEMAdhn3e7vj9CV6WpZaZ6z-BL7d3PF2Mld3tH9MwJZpuHPoRnIFh010X7j-V__bSxtQLKZYoiDqaFvtcRkjIiXO_yoHs-4lMFSGGA2uE9SaWyjPbpgLgHXRba7ZUkeCCaoWvPPeY3FB7oNg54o8aBbJBr1vzl9rlLt7iO82TLZiFUo_S_y62kxThX6-5Efenzhzs07unOYs_OXUl05RGbYzq6RA2SGCPpt1pGesoci8z5_R4eeICXRX2i4X4hBxO2DATnERw7Fp-z_7zBcmNGNZEZVOT7jmLVUEVszx4rTHXlv7Reev0gKAnBnb2apgGuceyBVDRq7uSOBxeF-R8nWG3WEHld6ZDuOPk_i8ukgveuNjTvDihTH6VgUIVr9T9jbmoMTAkdrMG1heDk4hpt122eDS6ztNFbfhPA3wMmrh_x7ssSoKhV-FhMd38b2t-5b0nQLmZVFsB1fJ5NQhl0bWmtu82yhFSAKeClIRYVznvj-0i2kNWKlorUj5gdmZ7WU6DZztBwds5QapxEeBl7IsuKWAuT7h0OKleJ5mRxYnigedi05RMgz9zzfAWTnT-xTa6hGjNZLRQ3hIUg7npb5DW0z4ONCOixdNA0ZJuL3un3-F0azCLlOMlF0e1oVDK_1fyL-71_vtmz7NZoT-5sHmARo4BEgUsFGtEnVAEleJX0Sc0IRUtLEWF8XrtIBr5gqIUvCMbdvsmcI_rKvkjc5Vn8xgoB5hwzdGIWilOmoSBJKzgJV-wDI0EOrnM9QCY727R3LuGcPGbBb-bvhAGLfXlWNfjaZjUa9hDnvTaxZNXbTnr7inn5cbzKwQhp0I2NI3UIuYKBTIWqjUrj2PVljbEDv1eENrXyteED7JaBiskdHTC72Y2-Q6EG3m3d8rEo7O6_0uC6_yDt6MIBFVY9qv2W0sRAmnyOSSkn7Pek_4BbVuOZhfB20kUfTbxtPWP0-nAz-aQr74H5FuuGnI0oz48GfuyDYZBBT2DDxGoj_DojL6pZQtVflmKHhI8bC6e9HLLiW5rm3k1O9-MMe-nPBgTZfCfeB7fVea2GrcFlpLc77R2kaqBcGKS6WVRXo7hnvmZa6fy9nLbZizu3BuFek2byDW_wKHvDArjgbl79QghKa7KdhVTxY4a-Iccol-ZP5aekDaYNuXnNiMYKJoRgd_wcfKv8JsabK_Pbovx2w5Bm5aOK6afUpqgRpjz7GVYcp8NDFXz9vYe5bEAM5_3P-xtrTdeOvn3YBwLJmAUX0CNmdDZvmNwVmYFYhoZSN2nZYcBB292miwt_uVQAc7gAgvgFfhpVT9yZVRZw9zygA06MOUrrTK2FpEv1D6veDPzG8kGdF9wat87bKBdlpzPGL-98GAn3y43EU11PWS78B6aXMXlDPgyWD3NMhcCzMrljQwzpRoqp9fYqzEqePmQqnfG3tTv9dLgJK9bpcPsMZ2JIWN1qx4AL_AAHrQZ1OCny2sC_maeJTwdLSTy5rPjK_8SKUBNzhocmcftDzJgt40OL2kj8XrCoghfZ6CrL8nrK3JD4Nx8d19DWCvpnnd7cdHR8dBQFZuVrUTreA13GMQv1FPO5qOkfl4dZWrqEn2guCBhVgB1TdR56mla5LWwK8zmRirhs01Pm-iskGpB9krw21wZFt0fcw-hsdpIaMnflqsSzstuGTAwqMQXM5lpVdNap65CwHpAhf92hi3JnQT5lrBb1l8debrp2R0JoHemutk9xLKxM8E-cT2C0a6ME-dVymUHh8SxrCeYyHQO_APaB-z7bP5pZgmiT222SK2OgMNPsTnckKtnZ7QUMZRyAQQkB_xIlV-t_DznhaZiXu1vEIHfzxk2ExoiiQdDY8fiFlGRAk-7iB1rgM7Mk7doAbQjEvMNKGa6H7tBUfe81o3jBEyipA7Qc103woenCBOzej7UvkotHz3ByWYVLhHklsUhng9i9TwAX7N3leCC9g6KYktsprHCptAoBpgb-RAOiRRegU7SyIyOpk22lptIUAYbXWHVMojgbL2G-ieNp0IE0Y_D61guSTG9yFbOUmUveprxC4orAwPSGOkAK_-TxiXiHDeN-jE27gdNAqkxYkg0ePkfJEaexRje347aYWDtSWMq8x_kLkLgb-4XDjtPJVM6ECA3r8cWBrd9FJMPOvBh_kKD4wPGu774FLy4btnvlNtxKDFxaFbUFpJA6OCul-um_8R32AL26UNSnoQkhzluC3V4vR2gfE7NR5-m4mz3EgrqS06NqrB8z1j61rzU0gVjmLbYuRJjZs5wM4WRHxPsMrXskbbJOTGhCqIz2YP8hhFvV6lIUlellSI2p4WNx0xMk1wktZ8jTrFbLiWS9mW3devuGqvjRmN0XiU1b00Jjd-XsvJyhvzAzqF3M-8Ru6MbnZH_EkQG3Agkhe0APEAh5QKHp7A2tnXcX5WFVQ6rGXXV4bwua8Yzd49kb0-9HtHsO9ZJp0sjCIdzEHRVawMTQiW8QXbnWE0I_Lj01o0DF-Alw1KZyAHxiMTn1YQ2-OEl16IdpAz0iMVuoibrdIIDM6g-B7EH0pFHnHTazmyJUhy88AWAbIsFFpLlEcYFffFsjPMj63d6RJQdaTfr6k681MzmoOQDyJoavFHuR1ty78e6Dk8qAPjm9G2dTpPXMImMxYkiidj0MX-AnE5g3eaILD6Q8lPuFImxaKc5yCXXGUgUqPoVHRzubZW3V-Iv3mjXx9RRgG3tWE_zsNCFXR9RUk28rJTk8dAsDRfNr64d2Pfc6nTvlHdB494Uwz0SHS0xkqAuPfa7uDNnt_kW7p6ikleQaAgxMKeq-C8OBnlAKO9sFmOM485bxHiFYsPJGv29_5ewe90Ors3R7ENayAXHzH0VVVe0c3QtExnwEGQ4zoqMubvU6X9GQ90xKibZ2Y6pWZfyEytmGMoBOAkSYe41wFS6Y3dAs4DqWyTp8LopI5mip23ZIiWKbJrygp16VekNV_CtUeiheYSBfShfnn2jGRKWEIV1YdZZgejz_TAKNKF-Z_z80AKhXkr4zPIw7OZxgrXaKMPTKT_GI40qODCBWRT7idBXclIpf3zl4LYABXMdDIZHtBnjDfMbXhLcnhIJ2ZIznaxKvPd3NwX5BEgmam2c_A4k2tek7_wqnyYWxvK57_FMzzqW-SDbRzlhjtj0EQyLsR85ibkcVgHs6j7Y2gFz45RXHB8BnBLXYBcRh8XFgyYCFjFJyZ0GJDywZtsFJClBMFxTpYIfVPtGsQI5M9YMTH0OFXN9rWSX4Uj9Cx90hrnBOWfE3NAll7xSMJ70oqiLQEJEDrMij0fZeW1hEfCRlL4wcEnaINBOPFTAS6HKg-Z7415mcRuuHnzYGjhYxBIZLd9FPpCXo1r4q4hEVlTm1iYhJbakCN7mMLd2ShlRMIzixCKRyJTJ4n1of09M5PWDk7bqE68vGMZIc1RN-aHuBuFe7ouHhhouAey5HvXK1gQDlGyA3PN0Onb40rxmgCnb4gYRnH2Z402BkARiI_-KEwp5y6PaQYhusFyuiel-b37xcc4L83iEOw9SmdpBGw5HF2gdIXiOEcYPWw5CdV9-KORQ_BwMlZK9winy_HirzFtpOXZM5l-I7jRp_7UMSRqMyvDy7svI8WrY5SHqW6sedU6aPN-ztn_wT9A9vbn-pF2NCcDDpqP1AoBeXSlT8PMQv0cfuohoMHXrj-lFAOVu3g6mZRIV3Y8MIf8F3Cbxkx-CzAK7fbK5IIVr6rcjlguK2MAG-6HdzXHjCDGscYQpbGuZlcrytK9rumJ951J3uyLn9BBTwF3LEwC_hYQ_KcqbujBkuFTFu0i3fYfDiaccHDEP9r-67t1FHpcH2bGI8VOfv9Zv2NOkQ8Okx5efX-vBQyqyo0oTkJjXEXNumrM-mY4FtzyxJCnQgbhCYWrOOfMFvTjSET0iEYVClxV9oUrasl20YboW7DABtb_pdb4kW5KrVAGI9-9M9dMUjSxQAHK4VX1HOOVbkggqjvegObSfP4DMGtMq49A_87Jy5oRBN2i4fXdzJm33V-eC1QPxaRCwbdD4541g3KCUIGKm9h5KvrqxiYW4IH7SBBW4-_SBXorpBoWjiZAGdXFoaO9-_irt_3QhHbw2-yWJ60WwFBYREAIuSVt6Jv3Gq_v9FsSYWiActMAUs8satMvMF47yQ-cvDMrO56woSPwYHYQ-lAKwnDZsxJnMTOQKNgW1MnMPhuU36d1tsH3pjPCJrTGxmxvuKHEPI_kgnKm5I-d9AiZS01pnsi4uJSjaH3qsFQ993TPYg3ieMxFaKkDNkqXbQkCF1TxdMmSvDsBVSHBkhJI8Rb5VdCXIsy27jebc6Mt5WKMjY-Qoxc8CjFaXTUgiisx85Ut_hRttW5U4x4AGH7xZYdXa7pWOzZo_uyeufdYe1NNsCGxwCdy_ApVV8fec3ypTjol3g2s8VmjVY7YK_8lOSf5gwSpSmTwtf70QbyHavchQi_KpoPluklctpr8mCICYmfMdbmNqW4c7hI7J1CcJqqeZ5rq6_lVxy52WvMiNXbCObAzxYrVtdRzH2FrAa-GrSp28jHKxEdi3UN-XiRgnzkHd3PXosazipektY0eHTxA705RlgJjKSRUsJzfAzZnxnY53-7s-37seLd43zzn_Bdvt9eOtO-u6qHIlrYffSegKjuiIYcFMPDCLglGYucxUF1ye93gL4z8YkZRPKwk35rnKrCEkuYMDgXgx2wI1u05_T-pMF5JXi4qTnSp-277mIWiYubydGevPugqDIv2dLfur4igqIw7-smTYV2kR93J8_JDrwdZKrzCaCNeGrpcCgL6XO7ylDmU7TMq0rHvohR7LLzvWgyNRRRLRDBM7B_sgl_taaWj2O1dtfoDhbVH3zwn75zyTvOlGDih2w8fpROjAqlRosbiSmUw3zSDp8Q4aaig_K8v8cuySEPNFvHtcdIfGQRD678EPpobmouilaPcu0bKnE3kK_uO4iBTd38gGnorid_wo2Ku_Mvh_9JN6uYnYQOAgyR714lbvEjuWkWc5SJI8KbXCHb9k8G6vDAGo2sH3xcqZtn1dnOC0XJCRa6CYFgQLVrS8WSV68HO97OkgqdcSbB1130VOHbPgln7KuaSGo9NTKrRsoMYK_fNxZs4zoAcWn4R_4ATdebkWbi_0ML9S-RbjQlbJiaR_3OlWvHDBYxdkQH19DwtbCrKUKBetYSztG_7X4VeBMn3JWLnj_rprMhYXjcxH501ilcqyvZo5GdtK7UTxe2_mA0pDcqPJXWGaUSARyq-weLWYWuHhsVru6qQre2StCCZwdYdJlKD_Z1hvlD7QgSHU6hK-Ey8LBIlIpYG3ezgMO7rzd-8E6wyZNLL7cGpr7d3R6BTJ52dugIUo9MNL1y1ZY6HkYOk8CRt0aZXdYIRXPXcAPetvo_V3dCheicVIOARblHeOCyWYfQk4bLyPfmPLvd9xSVa2kLebc1DUSTsbrjIYzYa3EKpaq9HSSJVafS2LbQtWLZ7K5iFk4IIylTE4pxV5dz5EeMAPrgIlSuT81tkT199udQSnf1ZPIsiA_6iUd4zOb049BsWt8aHNYeCUCZWuLJLECKPdrBk7oaOITXIeyKZGzLwzsRuLuQHfjXKROZBDZwjVOQRzWt2649_pLtiiC94n-PS0-lEdiVM20L-uelpZjknC6ui7gsTFB1pcejwHjlBy-TFZDOtaHEMkbBYKkLNWda8dooNDd3fN1-R_o404oxNhZPtafJ85mLbpNmi7AieEAd07d9qroLruoY5bBMgaY_8V2kqbr65VoHZzdPoycBejKE9ZT3cAQ_wNj25pK-kh6Y_C1_njqqyO9XwDM0-NknOYkw1Q-NGw0CEb7y-xvfVpUZIchhR53s928ontuVdXdoD446ajmAHwsoPySRC2srHTV0JzFHTIZ2zhVbXl7uRMkq0MlQ-RCBAFSoQxGjz0SzVzkAIizC5I3sZT2xIo09hfwZC78PTUe8XNeGvKgmIIOdTj1fm_bD11puVzmptuJY2d0r37_Wm7IYrqs2yVDzPchMMZoPS_H5dNux_LK4BNcmktJD5xTM2Z7UnTscmd86N4IDWnk7cYFojMlquxyTOexnRTjitVk2JoHtkug_JX9POcMeNDfpa6sGOQrDDIbg5CNYs-xjzr7VMxtjoIi_w34MEie9A4tKmIJGH_P6eSOnqGIGaPSQRIhpJuW79j9fbYjpPOKRUqaXMrCa-edJDFvHPnul13KSGk5cxgL57uKl2_q48AWDrFoOgvEF6QFIqlXga2JzEQt2kFTLzsy1Mk4z5PDO9fCd1OhLUVv0R1HajMA-jiPYapZbxEeyzveTiv-rmLufmlk9wM5qCj4JM75o6kArXrHmWn63SuOq2U0gmWd8UHL1mRH-Ld4SC4GyXhaE2Bm_ykDDVVxTdnMhkX6YrC53tLlKCdpHMwbJH8skqoqK6aHCekkkxT2EEQZAvIYSLhhZqtABj7KwVEGDeMvJLnEvwXkKjbmpCmTpYw0RFIMURIi4Uhx8ImG-l2fhY-GfaGDvSwFDwOhDy7L4q3D4Fr78Md5ugKMH8c4R3l64NIGHvTecT7GM5w0mh6o8CKY8j1U6aQPy80_fy0HHmcMVUrjSxazdwod_dvB6fj2ZBoXRTjeFa9rXOCyp9-C1iX5i63boIj_jcF40m-DKeVI7V9CQrOYfCk6xoxZ8PHwZKfAawi6N6emcxobB-UGCaQoJn3oHpLaM6dQ_u4JXwWad5YsHMTMn1JcY41Xt9LKkWb6-Lld5TVgYS4aEx7wOHi7LcovqL5XlavSRSQfdKY8Lf9M5WdX_Wuld_JxiXRlDaAxb8mBNmFDWgzDkylhPHfJp_fefumph4qDeHgtXmHK5s5lHEXMmnHt4ltT5-aI-QmY3DnT7Kdj2ctASjsovcpLNVZP7Qg1HPrjPaHwaTuWAF7wskDqMmMnQgxZMfDqi4G85nE1ztFjH_p4VGFUsyHL1NBb0XG_ILctX_roFR7mFi6msPDPdozbbFsaMVTGtG_HtKg3mwnB2BzyZQ66txk6Kl1EIzkjt0jNOuM-9OUDVXyoNJzYsTQB1YAVPRjIYCRyFp07qDKv_PiBliVoTkZNdMFGWnPspqCRsO2cN-q6kgntmgKJ0YSQ0MLb1vGIE-DNXPNO27EoguHVG-8gSFl6MicE7VT48_7PS9L51avD1xP5eC91YOAlluJH0UPUvN3GABX2Rh084SxfPtsaE4yfLXURPHGTQ34feEyRn5b_75uY8hvZA3AyrbZyz9NY45BWWL-E53lU9CsObhOd3STfOL3vFJB_P_bb_VTZOBPUjQPA1-JoltCu2R_CXcGK9Fsp0aVmEadG0ImZ7rJQEOjPVLb8AcYo3eZwc0Q0vJJ8S8a5x_tYu7YbmZQtzko73akcCn4WHQDHCH9HWm3d8iuGPluKHiU92SVWKz05miHRfFc3v5HXwFoEvrn4NJ03tKzG8mYUYtmOHPLd8I2Eh-8szRPQ6D_xQQGowCPED2tYK3mvSCNydx1N0ZBizmwNOqzunVJ4jU7Iyf1rHIPDJBkj4-0BI3kGfEq8Fs5QGv7pFDQLaXSQmrSTYAgtxiwWbQCImxjcDeRZLBR_FFhS-NgUxWhtPyiBNLME3lTxqoaBbvTaR9J63M_LnmNXSyXOA7aVXZo3fDIpaXtz-pRy8E5yh4HmS--d43Dsb5BrH94BhjFcTm8ynUlVxL4B7pSQxRpcG4Ht2QPC7ldccj5JUTsgSLlwVSlOOV4QUu7E0-cKs3Zf867TNbce4TGyczPz2LnTwhDOyHB2C_-hY9gngVtylxI40463OGO0yFX73zYAe4bEVVVssI_exNXrSdlrUTfUCsL-d_D28N_svTzRi2FjV_eXeJnz_e35AcGqeQ8OgYjpsV_0lvZq-fK3pcttB8ZVf--5f-eejwQyAgMqX6F_76bOv9pj_v2PBBhwPg7b527e6O-2r1RUst59gfmgaKBuJ5ruDmpuJm0nOiJRMAfi_OV-05L5lh39pOrt8-f9ed4qzU96mcJ2zpl7avbun1XmWfyEQ7EAT46ijWShUM8CyNa4m7Ka6t2coFfVNZpA3LGdk5u3d6thnkzvoIKoMUWd-p3OukAxkR64plU6REVjhZi9Cd3GIPhfxAis9005XOG-3h_GyA7I7qutxVAhXG2iq3hqybkV8b5OlXwcAqk1xeUM002d6iR9GJkke-azFsI4992AFmPA8rphRripVCimdGF97RKx9mG3xHsB3RedagwoV3triuu21rD3nWYkhyn8D3xk5JpzhzKMWIpG4Ru392AN6MeDmp1yZy0kOU-5EIZgfq2o24eJVovAsHns24DEwFIa5-n3udQAtTSJ0BMriBVoSslwuPkloWxyoHXGITHedm_qvHamWL4InLDB4a7Wq49XI23JYSYeb0hgk8J_19cX-3ty0XzFxNQytmNohv0BgkysfPmALeEL-Wq17Kw2FQ1rD1AgXs6E1kf7GapBLce0pW7xYYNbgiBm7oZfNpaFfn9Qx6cFWNII95hM6HYuNLKgsCqH8HBp6BApB7KQTSXnTdrt72ObobyJbtt_NMCNh_RvX9zowsSuHj4P-AzQiH1p9xknwWuAE_0swqJXgFsTNa2WWU6Xdn_7Th8F9XuSbcwiU1aKW84jdhSlDlnpvRckevYG6SucM9msRV40FEDq5QSR9oPrWcZgD1-I-lBQwapeMg9lrAXu0dEJXRDz_sOv5NzUzav47iAWiHXdzcLusIDCK3PVDLTp3Y35o5D44ErWfu0AUw0fV8ffB9tW0XGW-OASqdIPJVkx7xuRdhNDVnaFjc5EEcfiCj_hjjBSasm54XIoajxkZ6txgdzuZr9bDB0M8KG77vFMsS_ol-X-2ulA5xsP9PZqDwZdHUXl1RCz1v7fDXNkWlYL-tDChzjdNniD3YBGuKYzctlfhwRyZKtV4f58iesNgnLOn2taGGJ8vQ8_PUxrkoQ2IdYRsd62g6lgg0jAqKn6HOzUhMheOLiq4VzxjChd9X0PJn5_Sjf2iy3AwS80ErK-xiwV3gCbSQFGHxu9lWE-aiypw5uUl1yIzkbH1EVoR7W8Nq6aUuVwR2Qs7oqFOruAfW8UBANpHK_FdJMLR8QQo309B03kFvQ2pnZGHTEaIdVIRzyjCxLpZXiFx2VZBl_zQX3Jn_j5zbTbn7Oa33_LwlXxg_L3pZFrJPugCo7ew0cBrN7vHaMD9s9_GV4clW71WYON42nR-n1nJXN3pR2T617NEsIveOOYZhoIb4k3ZMu74iEbx9Qbk2CDhPjx3py4rLUgTnJyxni3ANQARVG1buyxuX_QdOxrCNdAlZR5fp6Y_r3s-gCgKFEQPE5KBCt9eZkn6lrP_WbJx4T9pm22xZI1KlRdV0Ew-tZTsRKfRC4CNjKE04tSDHfnbZDJcg91GlKCA6i5MFf8IcwuNlxrdfrGz4PJew_-KTulZzNdxKDZTgua2vJq_HrrfjNJofWTKFIUy3BlWlHH873hoXOUHO8Iy_0VBo5gBRCSMprSsXiRcd3BbSnYke_kMNv39fVHbX3KN4v0mHM9FrAXi9x65eSkvI-wOXrVt66Bg5-LvlhHrqzabY-q8qhv2QpWxqJuB44AaZqpU0Piqufwj6yb7eEevCPnu31zne5Y0kT0lUHwz9FpDZ4tBKNkT4hicjWszeV9EMCkjtU9npycN_JFgyyJAAzjhlQA2HyongA04PQRZZ117i3ctvL3rVVZiLQLM5l1V2lvMPsQGxXIi4Odmx9R1A0maHY_tjclrMxPMUL3azvvd0QzatP2UO7iDxWetq9LKUNgRakg0w6qSDXYk0zfqRHno66GY4lII4f9oEASGW2S2dsPLpeuWzM-Lvsmy_b_o-tAxzM5fHzjmwjrjMBqNV_Z5fuTftEU6Oik27Yp5_-di1YOROsYe4LBYhpGm-JZtLjVf9lJ1qZJHGHd4OAwbRJ5Z1maumxiUfhXafmDNXtCLw_hiwjlm4dcqFEbQ29_B2UVNbWIVBcBujrd-aNDKM442Pnj0AvNy-sxj5DRwz86GMvozzay9x5bE9SD71RqF9o3a1B-Obh1Z5E2mcqX9Cpd806916oNV48T9niyZoWyt-hlkRX9g-yvE0I45PfNYoZrAk8Skui_wQo-qQV9KU8kauSv_Tjtt9-L01O2u1ws2pYILZ3nMu4Aep_LwZj6JtKvQRsD0_yxA_cDcKQCIE5s4228DM5l3qY3IlmwEu25UbdIGdAs-AXI2H_CWOQEXArHd1_HWMLITgFg5uuwHVCXRW8q_5wrG8R1ulYGrr9pPuj8mRHLKheS01Wu7dSk-GXAY0xKuy_BO-jcSK226HTcTnCjS6kWpnUJlW_F58MwOaaetqOZZXE9t_8hHukk9rvOdhum01-IvaTTWeG0mz1NUn2q0UQe55HstFoPrebVgduksjOv_9ooagLE9hGYx0kMWOFIzHxBLpmOkBqm4m3f1BjsYkHh9QQEyd6wKV1D0fv5pGk0UdkSSVLWkBrZybv39FJD9c0cBcPk80in1w8fvJVC_FT5lrTTHu2fpeh5IFa0uVFZH-f7yAt4TcJlF7fRnnUdQj-7ctKTIRv51wPMawah5kMhl417P5pcWmIWcwDUQ8IHJXsE7OghATKrsxAa3wpFPG1LVryvx4Wg2jfXJe2adj2pW7dG5OfQslPXpfrIzkKeEQSqJV_FRNiGhkNIEJpKw4AxTE0Gq5TXMDhidCYAGRvXN62LDw_dSHrGnltWRDTggUYLV__RHb3VC0-usGEjQKgoihJKcON7MFm3VyiChN-sjzfR3NXkr7-2SYJmUxl3Yj-Xhyvs03fxStCbzP3Cty904gtuNM3iA2oUbKdOl5TsppNcJOTuGuA3kkwkR_FNY9rZ9zT-y5URPElfKW6-lut6ySont4-aSy0PZ5CcQp7wo6CTz3711MCXPhYwHtL5r94_SRjM9gzWKephrq5dlNtMsttnXJv-tnBAkjnhhW8UGyFjmJqU9QAykBWx8nmL_RgCYw9-jGDmvUeEXAT-zTUwk3rgSm-6o7UIXbS44vDTQ670DBbIvHZ74NqGWw4T5YDKjIaEe-fQBJ3M4zsjPOqizl-P9ge0S97MmzNq8pGWSu-lAujFugboGqSw2a1OzXmh1TdpALU3ztbjONOJ3Awr9nMQeRZDEPRzeS_L2vQNabeuIeJ1Mn8yzGL9hZFHemKX66efdRWlL2YxO-1i4HuYnwAJIS-Bvt3MwdzWYDxj-VdMsWYV6CWHGW2yTS-yOB3HKgZmWw3IGENq5KIrPnd5DbdtHNIEOL5JZsGADZRC0WXsUdUWR1tmpPS5dduyfnFFmzp5UgrrKAihlrCr906XFJTJBPFMJy_BtaydsT_uFvQF3JajG_XYiamq4GtR0ls5TDpT9L0TTN72vt-Z_aDNXsYtWmObsoOVdMwtdEXDwwf5WtUVm-jG-rco2ko5ZfMbOaZe2HP0WLleg-gSNfmCvQZ18NqRVO9pmJ_XObb4V4qMAlniKn1WeD82wFt4PrSLJE63U9hUETw9P30HbBTVcy58lOEleZYq66_u5d7Dng29iUfGG-RXobqzkfkwSh_D308nInwMprhsNUkVHZ5wY1SEzoBooeOWmLZnJ_i8qnujomGzpoKNSAkdaDU0hTid08AvWShnZvVlC45eGGt_GAcgstviJ64ZMiVhcxIxbP6c_sZFmFKjEq_y7ISQk8ucGNXJOLXSV8n4gjv9HwPo4FkUT_3qhsaqzel2jM7irBDkb6FJQYkAU3-resRY_O-LyREM5qiBKNLwLwyT5ql9OKXi9YE9m_DIpKrSDYuEpleYvQqAxWdJ-1uXHBDX-bTHRmlDdso8lffLoLRNCm--Mj6G1lj8BpXkJgwA7HySZaXODV2UP-Gkx-oqzTgqa54ymPeCru7TzMe63xawlu-3FreTBjf-9OdnQvAMfocYpP1httGUg9S2BFU_CSp9hyoK6aL3PLKCyObkX1vwvrI92P3lHKEpaCB5nwl58ESocullEv_KvnpESc5oLc2I-fJby63HyjEm1O113oGh1rIGruYPO9Ks6Yu8m0pxopmpEwoj7cet9gtNS3NPDMmZHP0FjX-t7SZUkfzG1lYGnQoiTsWTeG6W084xLUphvBSIJQwE2GpQXbZzY02UXSYwYvW3zRkS2faQ3buEINU0Sfe9u0QQI1yq-w3tFfnGn75kcLK4QLJPXcbxx0-tQBUuXHJhy_7naZKMCt2_rddF04zZHf9KtezTObO9g3YaV94cMYOBPq5tm9YPg4yQTLR8f9YiS8WaEsHHQ9MxVrwGcXFk00wjC0fToYBBy01YmUXQbY7QTwRlXClFuWAbaKcpw6Jw7KWWebJYLwvyGGkQTWKRda2bWGBCNz4g_Y9ROp5N2B6mKdAy8QQ-7IpFNfafIoU6E_P5vExHKbL7_zyeFGNwfKF9Ptb1lZO0140b14VKihtUdQ39u_nFCXbOrSRdfb0meNwYnjjY7HneDIxN8X_FyRrFsu_7E2WF6cJAR4YlBrcBz-eELf2CmeMYGXXfWCCExF7H0kUNsJ0SZl7-hV_BYvAs9fxhDlTjTgfKOBqQM7GkFqktdNaC-ncUy7AKT6JWzRp69vmxRn4NEcrzPuEDtpT-mb8RpLR03Xex4VIYId9KOXsMf-HmcDFb__bgqvl2cN2eWtGciOIBhxoQL7AJktiQ2DU43wipTm_8iUiFz05eRXst89pxfuLP7zzxyBpVMbVA-nisBr9Ll-l3_vQehvWQ0p0f_O5aIDVy93-Aj7KQ23CPzP1Q7Vol7jdQnOI11YYeW_LFppLMKEdf8hm6R8m0XTwkxaTgWYol29TGqaC8xb_Kj9zhP8js5sVUfdZAnpJxMfZkdveJTVv2X-Qg0Lc9AmFeuPJkEcRrXNZAzl6lNwLoX1AfP9jtJIZiW_UnN_hqv5xCLqx5dtMo3WCYX8y5Umr86nO69IRjqhMlMv-PxFQcTPEBMSk6hmb4Ug3Gu_I4ZuX1kEY94X8BGdhBbPMpPv2_arn2jkA464C83xVqJ4I7WmJD4IogN9FFUkSqibIke8OuTm40gKpgPUaB31hXh9pTl9kPnTzD1vNaWlnpQSzaqAKgFOZIStgXTCY8kCm1vblbgcQcAFzwh7-71VUbvmBc5inTF2vW5YNMj427oi17VIi4-xR3FdCGfLb96qCsqa8JleMfNvDpXlg6fmA4v_6gokfEmoR_6EZYzYIUHRaTf2nuKk46whX7Cyh9x8COKHq9VF-1L1ATKyfkUw7U4LjTVg9HyjqC_vnjtz-_zzT9NIPmgVVFHMgwMAu0HYkHF-QOKSN468hIa9oAIQXYVUzGZgJOr91v2L44KOrX_wNMzl9rj69DDe0bSG_LbtUr30PWDAnYMYcFqK1IffyflkK5j5V4Ibh6Z4lNQvnwrvBMUJx38TNy2FdjbGmrl6HjTqeY6D3e2zH8R_uHw_mqmNYZZW01iuzkbzxypwYhwBi4lgt9tlFkZCNBsq05dvCgssOYtrc-YE6J9ngvqY8gFqNlxOeJqjTKXRcLss6QsWiKVoikwXnqaljhX-BIolzYWtqv87ck-db8yce6N4-Qc7r2CSTNlIx5-tkoIdShtMIaY_1qnHmiNq84tG6e5FmGyunLh6QeAe0fVhSY6S9mTZ8Xcno8zi9AkzTz7j2p9r4OAf6rAeFvp7i01txcY_O8zmMczpDJrzGsjhl0TxiXpjUiHGUxjzlk9b-6K4rLbqWLresQ3vkFGK0FgTzrd2qXcxYPEqO7UMxsu9ksQCD-bGIi3mmdhw_znJnUf2KYAWFmFGts-a4SKpprGzP45J_Qc5Ux74cARQQTUPIQSmf_KKGl0RHfFaAKA8j47WG34Kt-2r6lFjm91bSvn31SQZN0EuyD-d-uf0ZON0KCxFV06fWgjrMDfWukuLdXNwe4tEESHybqE_Wv8NttYZF0ons1pGl7ozDZeXOzGRC15qLEhX18JVTlI16WIalgIUp1uILTdr_JlwlXnyMsn-IoqHQtpBaIQDWtV8amjOxGXBJWxQMs0drpaSxZNIKLqvMmgZzl3Fc2zU4fpMnYxY4n_KDyBsoL-lmF_u0kKypxCt72duiBYgdtaqm5gLaYPIiHzfZfS96YU_R_IJHQ-LWDN-Y3TzXnN8yt-flZQAN0L3EryASHtZstCyquJZhkY36zZbGgFgTeZeh8kfcB4GeSS2wedRk6QqODjPDd4YpVJbq_YwSER35i6CbseRo5Qz_AYS__s47fM0739eH7FssOSPrvZZUbzBlsn5LB6PSlKrZ9dgROEgrsSTcXuZpV4Gox_sFD57DrjSEZdC6g73J9RAW7N5LebVp3MLFJuAtWY9OgzHoD6WGjNtXw-rgCeNk0aHp6MhGI_30rPA4IbpT0yY70WM4upDYCdIe6bcrciqsFKDhfiq6ZhsVTomskyec9jMJREs3pTFgJmRZovUXOQTl-B0yCQODA6ulJLQikB_3dI5lSHK9XESC-3EDvZvG264KgYaH1m0A11-eKjXKwYqBXhp-GkOFGKRYK5ITRrl4AMl-5iC1YV6N4v1FINMddKcKO5q8VRKT9W2HwEtEgTWRuIfFJTXy77PkGir3ASNk1oCAYpFtaCOLa7m1Z2y5L8SJbPgPHUKKjehMtkxKnGDiKXq0KEqRdoD0uPG6RelvRUABxx67urFG9hU1YYGHayJQO0vUz5sqD1u6NJz7DlrNl_1ZpJ038nXGtfnGLvxVS3bvYUUyuZ0Tvbfc3uTJOtzTm_f1Ge3jc1GF1MKN4QSCv2nV7ZO0I5CZ2V6CzSVsRCmDBWh2IUYPtlNJ2-Qr8iNe6yaKjjJ5LohL78-1K-p5zpbKQGgThmOiuLN4TMB5EnEhDaYn_NWtbkBUlv2wx8tpPR19A1ZyhXUM-PAIefweC8Wmht_VQt4aqDcMvXI7rDFfOay82ePhlNGWSqqPZ-l-LlF5ngs41abBLwSJ2UwPDe_svbSJ1teuXDn8_cb7AYkPOft2PByzX7ug4hIOyZ127rGSKdj_Vp_qNUuvpcLP9A0WfJgjO_YnlHbDQV54L_JKl8BOAztrA6iugP6WoNH1roE_VfxGCTgn1Pv8NSDdhgoORztRuzjFQUtciEnTIQMNl4qVqA36yLn09XNl2OAd3d68hbEFfTA0y6PURkgBInqzhY_5OXoRLZXxCaY9zcGnKOYmQp0UZjWYHQDJJvkcspCspQ0ZnrLXR-0_k7YOzenK_A9HxCG7p7tqh2xNCzLl7HoHfWsb1VZL6eFPRB7Gy0A1lG0pmWa7ZF7F9UUF7kGO9Db7T25bupi-N-mKBB_Oi2HpjueHJzrxEUVPAEeYgnzGKM-lNwV3Z6NZ6Are1cfl3leSwv7Qu9-CHf9cl6kUQqgetMJ0-JUcB0FeUiGabYPJ-2HMQI2Sxn7B6iWYgJFik-Zqg5-yRCguUZb1dISzz30mgxzt4ZKTDzLTSuF96MgPRvwm9YgtJHL0l7epSXSg7ie4Ie8WbRwVXcLG82zBbg2d9WrBVwl9-jx34bhwkpxfI7IQfW780IL7jrrUH8WcEInpvgubPmuY0ahysxPO0koUaUWz7dh-T02h-D0RN1e830Fgl8uJM2HiLOix4FleosGPbJX-mcSBO1Bl-DAZ-ChpuG2dlkCbg7ZI3sQT3dIFxLp0Y8JrG7PRZ2Ijn0kOCVnF21jsQZxG_1aXYm38QPnzwx9DLe3wZnC8yNRst3A3G6d85cFq9Uq00SUt9BCR_U3I2FLcSK98_w2I2FExBLw54wBF6GiGRAYewBhR24y_St5J-Cq3NnGbGiQEIkue9ZChAPKGLnu0wpLRt1qqXp490-gx02rzwel9nIVBtFEIdHwZWcurOSlfP1wsogu0HTfNjQtChQbjO2aUIG8fF69m1pB-18pq0js3SDVGXs-62x-fn5kOwurvpkm2l5RMXIhl4kBxOF03f46tL_86zTDGxnbylvvmT6bxLrvDrHWjpsG07szzipaeq1NhCDdCiAznXVseEdFjGD6weT1fjnOxMdfUQZDAn-pjRcucNTUO3DG8-26-iSvPcZto30NrgOewqj5fqP1MtzWl6kcQebuu0dnaDmdGTfCQtPAsk6eiQht2E0cFe9wVyqMYdL2IwvrdQIYAtgprdjL8wALksVicMPzgZhkZD1t8Xo9510ZS7SGGDCoFm5njPyjI8XxBR366NMwW6DPie7Lyt89ooHKY9eAxzkeidnQXBLyMmXODaf966rVLD5GFuxLUcsxP5IgCM3X4LjCua4Zv8_X99q3ISh8n8wkV6oFRm4Pg3hLd1bKlPQFSkKvbONDgeS1CWi65Mflx_bIoLvcj0y0TwhbyBxiNZIwKdAz6mvkr_zPPv7rq8MqvFa7nPQynb93tvqJZO19RHRypC8n9wwlRCy_uyRPuNhVoN69JyRVfRToKP5yxAnVxmXCaX5YtSq8B3sryXni5oWEjuN7hc4wyPuzGLExgDiZmZs6OAuc_EjBkBHuZHMpR2Cf-gtAkh4fGBmQ-QbelEvXxmy8VuL6OXN0p-KaWmVV2pXja8PYDwmS9rCtXN69NBlO-mbCruyscpV67qEyxMiwlhOhYbbA-CUCzOM71usYT8hN82NgqPIOIQr9b6lKUYjPf6-3sRmcZBRnDVMoDqbcYx6GPdL_P2WNxYkW2fSxm-vNR2eev0TgzMWrSAiUrO8xLtgA19gRwfBkptx7j3uRSbDxVnjPC9GtFXbBmK_-9sb2ieB5bNd2hDribpnRa6fwYEdeh66oXewSgO2WPIlQkRs4RFcJyDABEIp3XAPxLUV317stS-RXsRJA59qqy_rUniH83azPVxep4zqqUN8EJzZYc8TVUlUVy9SMG1OxeE-pFUyoDeGtWqV2OoZbFKBmhJgjvWIt-rIdaXG-JUH4DOE88wsxDVdnjvjpNdmtn3rUyw90yY3gd20g0_VTIQzon_JlKpySHKhL934fmGF2bubCoVf8McbaBaMKe2v257sdMnKf_rFGmNUUwjH5Mf95KAn44j0vjiyrfaR6sHwTGLyssSA6CzuyVUGG09f5M_eQuGasbGs2Y6WvqfbtBTuLdGLtkP88GqAJfcCFQS1bkNCjMmgQg3TpGUbiHEqAYhC54gGXFCr7dkBYuyXHz0CU6jb5sk318NgwtUuvuZsX45vMmee1HVuB8OByyXipz9vFhlN64Iy63g5uPNz1vx5cIei50KhR7Z8LTiUZkwM9Rjhvra_jq4-ye1GFS3fybW-6nQZhbq_JA_18SbaLAYyMeIq9J4wN9oiYpjjsIYOuw2mpCaNrLXoKrXj5Grx0Lgl9wG7sTcBU6Q8Nk48mrqOo8jZ5PQQrxJ4XXActqSQfzHVZFqFja1kCY7ahFYJN2uXb_1tnxymZ63ASTeY7-Ql1SV65jHG3lbUuLM6-QbMYZiTm7tfrNlp3WT2uavquvpm3XliBWllHqeOcANPblZCEOSOyGs9vC_OM37WkKgQxsJBiAwRBZJeKo8XYaTRLXvICokhI0IgAfv-mPGDrFJIdE3axreA8pAnukVUChIZUV-ynxPwJytLOea9iGk19obPY8BLi-hiUPy7SdhTMkgYcJ9ihG9EttC2t1mXpcyzsOxwr0XkRTyc4nwG4enkHJBuXx63M3lwQPfCnpxM2u9uaKgx8AokRj1_rE__SISu_dgUw0lzLzdEFEYsx7GsMJGFtzMBVKtigsLvX7jbE19AdCaWf9s2nUT60WDZ4w1eXvPEQ5c_WnKxAybhKA4-PkEUs2x-feH026iuO5_6twxIV0RMKYhJKMx55Vmws8Ku43XQD8RHJCoeJoiN4l1UmMEAO4Pv22eHE7F560z_mBLaOGB5xpU6lfQHXOHMdWwmCATEe4QQcAWQGf5bOSA36qSnTKibpo3KKSGG6dmBSAOnubLE8-Uup9G6Chupef9le5P5wppigOy2EpZM2dfmhEq7krkmme5owhJb6fSFTeWYGhnPH6LJuoznDwQR_fE3JNOtTNYbUp2acKFTyPEUTxHzVz7hNIIcB8s33DZF7ju6_AakLRFZSTvR7yzAP9kJ0vo4NA5qeUctseOihA2BbqGeT6RBBRKPGKhJPO3Qm68twNGXMVICit8nuuA7XKEfD0_MLe05-sCro-rhNiSIJjcl5jYRqbL66NCz9ZoLOUc0hEzTPCbcrUq5DEl-Gyw7Yf6FRNxy0M5twlXoCh2UWS43TAe8QK-rYNxDjtaWIuhd4kfFibORUZXVDFDh6F4eYoCUad49Tz8r7BwUX0OHuB9iqrNndAwOCmvZzbR01ZRXL5kElTCm9EhG47kttAZFEo0Fc4tvUfwRBtHNTWeYAl48CcvFHWY-n3TwcWxv8NxbZ_mJC5T0HSQb3TT5aBkif0H37b9uchkaB7CeyTGTIHm4o7KQ2x7LG_m6DQhNZ6wf4WmdaF9R7V5mi-E8w_wYfwT7lBL8kOzKwBcr1N8wAKb_R8AQBcJNCnSeHiJ1rtgAXqxZAO9O6vA0mYcGKMJgFF2ekWu_XwPm3Da-VO2ffux0oMZsJ1DeWhcRE4hZ0j66d7kLRTNotnait1q3V-3dcU3gALAzXCiOi6Lw0HPUwRO2-24G2NriNrqtuk-fhUzRpvhRDjfpb2_zfu-vlWFtxj-LW5F-zablcY1g4rUnjJ02sGH9df28e_dThOu_MXblt-noX1lsTrsj4VvBmQlLkAt3LS2rZgisxBcsGpRSMXhnTMrW5XDAul5fCSdps9uJy3Fx0n25Ac_Ql5MLQsclADjaeyvZW4KZJk7jacM8sRLuHHjsctZ6bKq3hz7JM51e17gjiOcF186IeDOmlShS4eUWrSC1I5CFutY_qWUy4OM0rEdK1UUyOTnlUrZrG7BEoosJ5J1zqfPMivERs3PrBgOMwCmJSVLFlOA-0c0RsnMxEvlMd3eS8VwkU2isLRVrwIH5t6WGKr1q3y_N7aYLAO6mphEDHMx3A6QKI3YytZg-6YaPgRJFU5VjgLElR6htAseXI0Y4I022R2Ew8dpVo_uS7mI6E1wPRsOYW49mVH7CSN942BSPb5B3SPD_ZtcO4nfQHD8Bm9psexHEWWcfXLQMgqjsIq-NUJ9NglKHD_2JtkrVr_8AWduW80eEdxMbmqm7dJcePc3Zof406JcDbP8Yl6-eW9gRBxYGtD74lHujx3qEqKYu9J0Pz1dbHGDY8AAcIeJTClmqujR6ujivD7-RE94nwJUnhvSkv9G2C2PIHprzz5F1PI0V8LqOcgPGiliQ-fQrcGptGRhuArI7dfu6wVbnCuRHPhrPkke7JjRXV1dd5Q9r2AgmmIYhZRGPyXCxA7Z10Ht9MeBKcfE2Z-cwaq56Zh7qk4GXm_sxvYklmhBPkhmdtjDr199B6zffVsxXzzKmZOxvm9q7_dgimeNRQ2FGgaCqg4V317mdlFsAmMldws4xDkK88FurrPysnyBAWljz7SxUQLTpMi6PUny1fDTm5xE4W7NaJUOaWPxzVQ0zMEvo5xarK8_QOht1gq-Quk-mk6Fhvg1-8M3GvFiX4CKhBxI_5HaoPNrjH8wri7uk6dw6mNFfCZdDaR0xpg5cEpokPX7aeVIltq47lvwCPOuKS7fv--yGO4kHm4tEPYj8kATGUnZtSLF9t2oH76tQ1ZHwBbwpjS6krwXxvroBF4ZHTJSxncj1eWPNfJnZC4RMq3FOpzobkWfpuwDqW3lo5pPdq5d4bLHX425anNDW7MrPelzZPBDCx6tr_juyoRyTe6NGlUOu3oYuzdwFhWCXCTnMfXUovKE4kaUzVbE7jfxASQlLv6lyU29P6ArMtxwhHQWcHvbsperTQdNchLnO4um4tKUx34Rw38WA16PTTsij07QTTEi-587_eC3KG8zA4IXyzewoJO0zOSr-zZXx5BUMoSfdv901-8kscs_5hAuSeDY4yM8Khd6EgqD-GKxNtbuAk5E2pTflvtq5UgLCVnO60PbeTSWVsmOsXYzrCXR_ywPGWhEAr05C8rL37jQeCr9CkvLNu8dXjSE8hGy8pV9v_TcX4GyJVd3JV6tZznzW_-GZTKepmHtXuP7LrN_3EJ4cASNdJ24Ix3Pn97A_k_sUb1UojQr8nYn-_65lT2fNZZdaqqTEBBfBvSlZkO6H5gDcdUnj7ivuPYxivHbkiC08_ocqNtA0p19uUkD2rBejVKrqkNZJqmP4RykHiIhDreDeGK7pbtDQbve4nJztFzPt0-38fXP5-FxYO425UCfKFbNhW7em77FWSWQzbTvlMnXIm7ZIIh9vgfYX6Bur2-Wtr-HItTn_MGGoVxYrNNLsrT7SaOUO8yzTGSOOVJ7RE220cgu7byUQb2ua-mil0UDo2pKJaRkzsCutj-cTL-MdnaOFNZAMi0ejEh4eOIvuA-8raPvqp82qExuKwNhWRQOvLA-QdJgemC1Y-gl1yUSCNuLcsc4JgVPwtVuzPyX4sOAB0W6EEFp6x2S-Kza97YnsKgVf_pkGEYsEjw4R6N7l-HV7HNwEyHQYMPKCg-I878TQ66ojrZLQMoBi8l8b-zfEBfFfVccIk-VzBjpwZky4DYIREj7xC9gP_zpic3HzEXJkTCPpLsYfwMyCUazQua6qqI7jd2DAotLaahEyPIEOR8yK_i4vwAf_uvFfmBTC_fAMXfj5iTjpN4MqHudLPr6_M1oehPvFIYBeR9wx91ouaPScLwX6Gl5p3Xak__0UHypHYCqaLe1zyl5HcNrQyDKMbqYwWxXL3G-3SZQN1TwwQWw5f1rljzQPiioLSklUHfXgbLe5RJiBiUpgat84MsWy38BkjFm_WRVqvkfw_4mFdZfAdLqF_jm4nQTGyfF1QCaT_MiCHj811clnm7Ug0FCFdRsul-BGfuvx7CSWhzqYdNQXxi3P1fZUR0jRm6mA3mvjrIoHYIrs1df6g3cMJSP506tN8KQBj-NJPwmsflz-jr82-rQK7gxRHgi7m-fkLy0KsHIhS-j7KeysYvY51rVSfjWDP-OR5v41X_K1IpngF6S2-zohDIA1mfqCveQ4EL57Q8uSUi32Z5n-JwqTh-lQhbWawQq_TBqMaD0g53F6Gf2dR_fUVocDoXsjKwZnoqcrX8Pk1ANRzAGv8FP6_Llj9sfftUerzdhW3djFJn6KkBod8Jtw9kf3hRXX8ZurJ0svrdGBZVIfHWqaQEO7izqSziMvCopfgFkXKpWLaunSLd7YhQM3QdoI1DDupnipBjodb0S87mlPMqjumK_B84sjOmaLQAR8xMfCeQCJNmVvBeJe758ADBepMRiBipfER4CDgJf77hmzp-SGzTHjv3hXzzd1uVA6PSt9CdBAXNUlR0HqdofJkuX6Ui65ZCtsqkKCGzd0j3BfYd-g-By78Bguu_MwFC_f_1cJLnFHi86QJtXnmekUDsQe-Auk7rGAtg8zWGjmnzYRSRX_OEgE8g-VmobxtDvCqdfMfBL4L_G2S3j2RkqgNs8Due-cPr_ORmxJ2tVwYEx_nuMxpiVPXY5379WlTg2OgNaKXuAd0AP6JO99EzC97kqCTyhnh4YpcumRL5WEVoSuc35Q_NBwX-9PijqN_GZanBIzy_0bpZfkTOM5us7x99XP8vGTWFjgbXBi0CuyECRHZeRKHiQsP18p9UCTab1i8s0GiuLgAnO6e1ji5-GDvuW1a5Khk9FA-ybhdVvtwj4EqvKyrRs4FNleofYPBEszK2HFl9XJ2Rki_lEGdglRC6FiLbevSVe-fSZ8wdKlxN-E7G1xCABU2L58qilE60206wW653aL2JMY-WBd9QwvG318-rWlYSVZbViy-cwigc8GjrAQQM5oZNT7hP_bNT4zKOqHxjOrO6Ku_SXGLcsTJ7WRChWsEpF353-ViMIw0XKeXHBxtRp_bJBKNpb0CQtcZitVjDoFV88FghXLethxPEmBxwxrom2o3o7GfddCSkJxYztMFuNBJ_5zoANcJU9x59qa_ozzfATaejklyRAsIMWeeUxmx1ofxoZZzlQHu3-3_Q4q1ttfX2EsNfVrr7vYMZGveq77pX5T68Dwjmcttld8ubyFE1tvwuKkD_B7O8bh_vjGLSlAw8BVXKY7LEHfg-ORDysvNXmmznfnx5VOSf0djPkJ5J2ak5h-lzMakjwbs0-QdZq-boalhv1tJ1QrznlK6dlRnnvGSTarRu4lgn1ZFEBGZENXOZiLVxqrU2JGpzy8f7QGZN0lmtdNvjQ0wmQMRmvaw3j9NmYDVDES8bn-m9PvX8CVYHJWAZE5Oh246XMVfzY4ijtddaZpcX_7siIABZSBnfEHd1hlZN9UOf4Gbn9eVDJH2RZ3GJFmAhNhOAqum1t4uEP_vabAw4b0bP36NWRXD2jAn87sOIBWdEYUScLy-5grM7zmOhkHK-Et0xlOU7ByUG3gLVLvMc_DKcFbpw1QOw_FkWnCnGdDgE9820z-fmijE9ExLEJsAu6OnQyt4X3-uKIxhEWGJwNc8JGVxJ_6ILAIv9jOT1wEkjxnAmrDoTM5Xbf8vtXU2ApjFrUCPVuRDVxgtcApoIz3minoPvzBxQRvokfmdH_8wZZTZIF27x5tLrluCLxiqNx6OzKm307lf54t05qTpxHJrKkkaEU9WCVUuvnuH0NMEBPFp2Ykh8HbEXiqLn9mAnXWvnW0Thwd1gqBmBOEhgQnqB0mDAeGIC0Ai68KdEntcT6gLL7YpmXb1fQ2xHX8VxQJ4prMKYGe7aU2VHGIuKeVSdcVrPM5mWAFGWviKfPPx0dXWj_gXwsUZZ74HHneeZFCv7E8kU3Vg0qxk-DGr4H44Ns8sEtHv5Ql3DNmjm1e9C4sbw6_iN0WRMN6ChD-yBUsbtVj1m__etw6UU36AE9qGd0RbnsHT_ajUIM1qUNYg332FDSmV1rH8NBcpaR62pXDW7WpsXiC8C0oLqjmBV2x8Qv7LwpR8KZ610WmSVUdKP1nkLK7QpaaY41uytOsh0XT1NdGcdK6sCWF6JYzO3OtvI4lYosQv6lZA7vPGmR3xeAHuWABK-I00auR6tA2G8qWwNi-wUDvIYU40B58HKq5oCFT5bT6nP7Edkl1Uy3IE_YX-U-JUi62RjflW89cweEwejN5ywoWD4dYlbamcBBi0GDDPINpy04OcgggOFK_Rv57EYCy5gAewTcKDQ8vdp8xkpY45MIIbZ82QMxk0lhrNEuCUquUU1de7Ygd8oZ5YEluz6TqAmSd3Gg8Xx7yS0UCdECwm4Wz3m89ObHiyhzKJOrVaEIv2GHizMhZoBgt_0Z4GrEnvTCJr7Uv7Q-U0gf70Er3LbdhU48ovd-xogALA0yCiqiY_tpJ1dFoAHx8yiELCaT38lBWXUw20pEFBwynMXukF5zC58kUfGSoF43f8fHL293oijcTUNqZAOepwwrrdXLFeKB7sk507ANi6pNSQDvJFqT8ryGTzoqUwue4c7QCU00xx4dniVTV7UEteAJM9cyORy_gjH8BmzQQkNNqDJYt1VlxtOqSy6r20mFlW1bf133x77fJgAnlkfsvtphkIoI4vtNUm7JtBMQ7zPcvWnKDrWqUpsCxR4_MiA4Pwr6oLrqFFq9SMkHMHwvX1Qdssui4jC997HprdCyYfmmc_DPkDgG2JI9oWKrPpP-UVbnC2dxIEXiiM5XMHXaPvv8w72J0SssvutWYQbARaS5s3jtHWtgdWwUYwZX8YU3sp6GhRBFgjNxeNl9X6iq8NqCJ1EodxQdjhIVye3kofOJ0kU_xEfAgrrRGVh_t9Rdok4tGW9GEEqr_CWmO-k8HqA2Otd4u4t_HL3qEPapGmoyriC03hlx6ON_BEyRsSDwYGcB702Y311ImE9XkpQleyjxkdoON21b6-_EHcxHtjXhrXdkdWL5lSUjMJVl_3I7S3JKUyw4DNmpVsD-oJercZY-W6u--AwXRggrsC0DfgfcwkCg1paGJr5UKvT-3o3oounrbsN2A0_sBaV5D5bG2XIwSU5cJ3yn7duPoSyRcg815f-HQD6oQt_Ghzbd9i-xNKCdzuhWnUvWG1DoMgCu9JRHkglBp8h08cR0FPGlBluaTivz3ZBWqz45UkljVfNzxkgg5XcymUOCXC8LRtveT0yd-Ubeihvht86T65DIIn0N5CqobJVbfmJ34adlfCpArDn73hEPrkm-y0HibgQU73W2xZw8SLp4E8wNahVogCQlSwm9pxlS6gsVDJH3U0W0OOUToMd4FuOQ_84_gSjaNXk65IbVk3HCidryrl5DBlnCTpCdcvR3EmRFU4y5nmiH6lyrSgnD7iBlOQEOXH2wSFeQpzEM5jh_e5JT--oMa_rb60m_Yj4eqKyz5yhknke1BwJS-J4azS8-NCP_iucDOlp5Wh_XMbE3Vd_oM5-P3jLbWKsxoDP46yr1nuxbPHgW6b_13B9PRnCw4qfjaGqTymA8-o8JE0vNrqkn3hGevqGRCpxebpfwru0UrnopDlXJJ3d78WD3UjTrcKE6fihs5-MMtKEANnkZTNssPILFzFJFk8VKo8Ng0lX6BnunNlMBqjDpSS6KYC_NBVILtOu84AuYm7IUKaCrg-HgaTG5lwjq7JjHQB3B_BLxfNaBvJ94MK6GXnm2ypjNJuvyOAY8J7pjyEpkymwpjOd56l4IzAD7cmsYey_71JL8itINVTGCn5AWuFlyp01MsWfP_IRERiIdJKp9rypj1NxuSeIbEScPNPnTgnggA5P9HfjHDU0M96tx02K0epjU91pc72w2zHFGXKcMl-as6ORFAJ_Ss05Z0yQL2piz5kHXFSUm-MneSz-PwDdb6Wwedg0tFw4KaIjIielznSYXjA8fLTX2Q5Yzu1T6_VFfE11EeVuA3QDdZoumPnMcPtjhUVNwlpLH1uHzvvsWQaL6TGcKtzNOqxs06jXQ5jIM4sFcKlchjpmzz7nLfUU8KmjBhM1xTgbV__uiWk9534YB-5QaufavVl6X1TdfJ0NLHvguBbVs9n1msEYvr7jE9bM6CYcNGjvls6ZvqKXXahIFeXeTvIv6Yq--BtthiqkHNZvhMii64TDiufu_3Md8Wpd0vnKPQh_K8p9Iqqkb6kVCh9GJ_xsi8bS2zdjyZHNnL3QDwnWM7ArVVyoo08Wdn8UkmcQ7lte2vSIIZibv3MzTs3dxaoXWyB1BqlPrh7RIPF_POM1mW5NDW-iTtYVsDNPO-Y_siqDtoBiJ0vwmPeVmL0ARLTR7crC-o6tnJMK18FWWas-8MZPWK6_CN1zuV6F8CJH5h9mpRz3tRMqcgDBDLxs6pgUCVwP5ExJwOOoGZQ2OV5q5lc8AOAjH9N8M9Aogy9bxFe_aOCVmES6UZADf-9VLGus3uM9G2njgae2Rq1ljMKB21RE4KKPzI1EM2hJoeLi8tLsBcHuoRliG3__1SAm8sJyAWUrkKZrARAgvg2An1oO4QM3fpquhTeR6p0MeUbSzJS-be1F6-Ix5n_k5rrVmyswreCi7q6Npl5BvAhsB-26ZdRlYXiijrYsDa8jzSbSNz9PxdrSUwKGFqOjMU6OO3r02g6tD1Gd2_VMiM4LwenWg9-bB7QTcswo3H9HHVFRNPc8YPVi9OMSgNCYP2IV2WMVBZvCopr9lxtaJCnnp9ZZBiKT9lUliHGBbgLM1jUiPA6uBYAiKzyMVLrmJ-zmf4zGd9uwfH141XPqY35vpwnQvHcrWhWM26j-xBImOn3u32dmQMupUBRT4cPI_j50-JMrmksl0AXyD0kJLhecpLycdS9BeZ_sRDRPQI7GtvB_37BykgMnR6SuiMHwM9v2N49JTyNZnKc4y4jgIAct5prktDmPfhSmoSgXjC3wT5aoQcvBGdwsJVh_HNqAIvqSix-uO1OUmi9PNqlg_7dn-BcE57Ix4Fz5rt4Tpd2hdvmV23Wj6fJy8pcDVI3aRwrFZ8z6Pn7XX37FsYjx4ibVx68iQcZzJ4SSIM62NQXgFgvg3GW5JzQV1XI7k6pfAjvu9k_bXcGm-6e7FZn_Y_Wh_6oTUERYdR85N1dazUE7gwpAAutSa_7PLZXQ_mN84c_fOzd75Q9JQ5RZOcfEVt_m2Kc_UnN70xd5L6F9VUGit5hGKa27dvbGDN_O0QtNjtSU-9FNNn32DFA2ZHODHjbpdnu6Qudn4gfU_JNzpiZmln7Ey9NHOsFRe9ql0MTD3OReFM_yo0yiAdYAcV_yDMHk8RW2w9rYgrDCGnArqZztnkEoBQ-oTdE9OLQdzcxMh0BY2xeEJmkURwPUG3mboKGewVgAz9QhMX5aXxPzkdzJmc3WOPrrZf6w4RN9UOJhjLUpOkJ3F0zegJeVPd7MJhrfx3pmZlvK3GyT_GPgBqlJmfsdWnhpa3C7isj3_Cvssb1N1RqlbHvjQdaYWZelkvNVbQibwy8D_ssqDKQB1n6zz2b4P_FeK_zMxGXF8jvMScY9yYJvN6jq_-6PQZt0JmRYtxkEraiSOn4yNoyXEgQo0EQ2CdG6OzpT_kjHPMYxuT1i-VBu1sodgNlFREG2EuBmi0LgHqv2Oc9aIVcojFjKsAAk5LN3IvjDsajTYp6QFBse6sym8iRh36ZhHX2sFTaxKQ0uOW25ZAF27eo5GgN311DR4Z2ftJRV4KJx46PVeQRYjCeoAUmnT0sXt_O3DZcpYHCKCBovpuBg4Kz-wk9U7hcpLIhvDuffdE75TAAHYiYRW1eL6MoO85cY6jDucO00RtqaF9FlMOFOjdI9mij2g8dXIb0_nqW-3Y4FfpmbPx4x-6H0TxOoMAAyF5syUN8w2RJexoc1aBNyLnNmiFQF1IfwyIFMTmipUFK__uccMEL2traIQPr5dfHH-mCaE9HSZbgfghZpNe4gMo8NnIT7BScgtTPdlS4jI7hFAMyHMNpgAtN_piBFKMiGZJ9s63DLl1ewcgipF75keHUzy1awP4gM6_i1F-eT4xbtKiwDdisqXALVBmYsSF8fH0ImCfLmZT2RUXA8GCF4gEJCpBfN_yJyFZ6OFBL-hIKLpSLEb77-t-gJ93xeyy_Zaokta5cgYbN6R-gF_vBfZ4VqON8PMk_07w-l5fV6SGvk5eActmkbppV0ZEOfXqhgt5G6mewiy8_uNIqBHWxLDCegVoj1kjn_ItyyH6hWIXiXKpAs_0ATm0TjPE9CASuv8dhKrh4ZPOmpj-NUeYgr7lSypeLaqcb86R6azjepHOYYDVHWB8kxYxEx2AbolI8_-HZInxjS5ExlHyb8O7lMmxjQ-lYt-Wu0htQF5o7Cn1jGQ9l5uceY8ujIVyEzVMc2IsClllPuSajIcAp3m0jUL9Of2YcNYufw4AVVCC8DrUoClBQH2mliQmaxUvg7M6ViVh5qb_YedFhfyVwwSV9B3-3VlxLmnns6ayXHv9PqF5gf-tmbz6hyhpQi52CNePJdNKhlaPHrtyjp5GAHTAeSHNRc2-spLEKAFqYlx6aosOZKuDZRgoaBgpwEu7CqingAgslfm33iRoTNgjpCe-bQl13fCZWf-jvUFk1m5bBeiEnCJigUOqN-MaSsJKh2SG2O1cHVX3bI8lHrfh5uHHfRbAJwPEUyOrz96MCVEO7DIK_zAuKzmxp7_kRC0H13mE6oNN-L7c7ToMXlFaGvsK-FhPKqgzWYXlJmnI-fUKE8aTl2LK1Cz95AfiEwiT2bwJsyTPdfD8615s_LX-89EqcMiKsmCDHkl9-TDdmwID1pI5xzBZ-ZvtA4itjQwdajJf3s292H9POvpcStdppt4SmNAF3YaMDmqutzqLTAQrahLxptUh9RyOsNQuk9Gu48kl_VvHIGtUrd5A01nbqNLOE0k1swRgeNjf_1nmDyAmgKpxJO24VUlyBMfM1Y2CHZWYHd5Rl-MjoJRJ9tXE1gThDlsM2X1hS0i7RYI6zq0wI7VJI6iD9WTg9cNmtxpXllFI06cCxHJagqVHM24FXCAG6WWdwrL00B_ibEJc80Cs5blhlEqaMIQafJORQImkz97BgHrwW6eCdFJwrd745kfS4ktUd3hDYq-s9aNugu0eoYz7hLrc29DmA_Szzl5IbUSmBTMLsVUOM1i3cM92nO7bWugj8vRFQr_Udcw1W5QcvIFtJx9r6ypWqL_2q48yyuGYTmB9JrMaCoMEZt1zWtRLpuWSZEecDr3sWWaUQYvy51PZtpXnInQM4BrDukzVP4vDylCed8fw_2Oo21AvQ0chCWPGrYdiBKpqGv_E6tWu25bSe_nkbkBF0RQhRqaWGOkKFn9aBCRIRAQpctVe4C-isRunoe3RJ-R3j97MJSSqfDkKacUk25X7VgAw8XeII2bPRt5Gnn8dRed3ObYZUkiaLEFrUGRBEnPQuU5YoG6LWIdoZ-_xxqEskkUx0BIpwoaUET0gnc41L5X3Ev5lDBIBb-2KI2D80fgebC1RHlISzgfCUb4Bxr50Kuli9GpBHkRDjaC-HjARi2PlCRv3wp-ZeYnrnqK4nNgWyYQ6sc6Feq3Zd1r7aQEBfDwpETop--_D_AaIooe37yOIZk14p-3uNrzRww03SYnx_H1jC4Pm5IE3MjfKTwsSSqJzDt0UPaOW5P3LNiSBqI-38DNm4mwDF-IALbrZ2lcMs3-5OJjtdU5QiaH112Gp-qDpYxJ6RAKLr--nwAGsJAVafEhVr0v8I1D-wc0ixsI69T3VHu8fw-lHhaxoDB_WYyFFEjYdONtA5uYqsNHR8cVsNvB8oG6e6DdW7cOGys9b2GsSe6C4mcVW_qKYMvz4k3Hb8Jg7zKK5r9_scrYpr2bNI7R07ORVdrBhd-t9khkqqxA99QcpziDME5j10MyDct_pRNO7hAintgxUI99wmqQuqKvxboFaN4wt3JH1NM0u-SCiINjeNgWn29T0rrOZHwnH1sHR3vJQhoVh0ITF55DAzR5rqLpucB20H5OpLCkMnDB1c1CuHAurN3ZJf0SOhxZsu4rXTayVAcWiKp85C4VYmJShg-4jM8FUnhYTRfRnjrk9KApAy5aUmpYVCTScL6-DRTG1NzUHFmfjT2PhTUnwBPrltdNPPOzQGglTeqR27mI-k8gsmQAiPPxoCiuJ-B9zzyeiuzeMFfHXhItXiqa4QT3x47FiXwL6pJPwyUlrFMabE97N8KbbWjKBx3-bARkfVpQhNx8sBjhamZPkeu735DBiejdt5huB5dplFj2QG8mlAwtF6ieJPtbggWjYH5i6UprX-nozv3ChfxUgw-QwcBhZK37LwUFb-8254BfDfQIuOxPSLZlCPUOe-akRbet7lues8xbq1bj3BG7Uqd0OpvsljOfSDLXhQE5T3zqqPZpxPM3dnOJoaeWSenQMMw6hHj0BRXb6PALOZQfw7SfwtFIFYJ0YbNDBaNK8grHaKqXG0IynMn8N02u2o2E7Wgkb-wlK6_Sa2uNdRBBAe3DYU-nUYlArM_WUyWGEPE-lEui3KC09E_qlOnMgm_Y8fr9Q-J4ivJWG8rQPt8RiishtQ9APLBln_WTjsbfg2YJbLcutucKNorMpjv1ring9vYPjWRXFiWC9Y2p8PXatCC3q1SeOAbPq0ndMRgT8n08CTySFVG4Hd2fUiNpEsUGT9ykiYAXF2Ea9xz91m-mxD2N8JOrbrJw9Mk3l7Py6TTae6mJEVaKMUtMi3dOFK2Pglb-lS95Gs8A5Tdr-HPC5v0gu-I9t1JRgs0dN_jqk9f783BeXckoL-uLEkuHBSXi2TidhxIw609Is6wrWOO0XK7mFicC8X9PBcN5o51MI8TZwPCF7cVA-8aqVyP1_KWTecpdbqmfYmftrjTrZt658SlwrQQGUvMfriuuXX2aGf19Wl2ZZhILSp2Ph8YymXQlhls9qN6WzLs0es1FpPJJxnvBcW6DnMvZnBCiNzfYxNbBLeA9WxPQNHF6hoQVYEfVdduQYK49SBVgWXZ-KmTe47MCfQRJa7e6nECgygyHPwnfEgcOUT3sy5izy4lE8HiHvRck5V9KMAYtb4982u0o-lHlTNRqQAURTYRLHUOsN58vyrpubGP7eQV2cXLhmztGq7UOSqspIP9C9fcq27uyJgMQ3bQRwKUTO1H1vALs_m3rhzkGkFL4bCMk6AdlRrjuptM3SWPM97uq2m6us2fpBZyN17QjD50ClZzM--eLeaQBBy8X5w1YzN1BEC_Dsk85VBN5zomoraeuyIRzVQmuhLLO12CkHi5CW0FhAEABJ3z2iOxxBXGcgzMOb9zq8LHdyKFr8i6eyzcZXBcy7758y4dUpXaG1GXgNi5s75Q-WXhkAoGc6Qg5BZPqlIsSLRmzoePFAHYBUQ3MdA1R1Iq48KwRr7ZNKWc9olfIiUe3dfCl4hcW5vgH85wh_agpwUG_VEWZX9fYz4ec0ZWMHPsLLRx5xsuai2SulaGq3rK7GrqTxQbdOHZlk-na9xtdDW0KS_L2U5wYFzYhXRh__3U_WVQllMjmpPekxgQdkQvSNjLiiRbhU9RhCvTSOIrK1h-xn8qd0lk3F101VcbGNHdkJ7p2VlaTWf7tnwsKW5ppIjWrcfForzyB5iG-h3HRQCqloU2JLC8Ll0YNmJUHY5gIgdbcGVfLvLjcqf6binhecHXESqlXKMBs1OgaPZw_ATjQly1Qv_vJGMrW39Sp9NfF64YkGSKKMRqGzzU35YCGnN890lefbmP0nzDyVHRFhAt1o__XCA8GFV96QE0gNfzSdBG4KnUKKUEhjLAdfGhPKhnR8Y7nTHeU41oxN1DtFL2kkUxeP22b8kzAx9KQWq0j6h4SxnIx3FVAuSDaUZE3GOCRAtYQCNCba-GfRgR2zUxGWqUXmKMzb_ybq4hcCdd5oE-Fvi3Y9P-fSkZyFrp6F2ls7pq-bNeMEs8Yz7tbvH_j-oh4fN31siZ7JUllHSKllZpSnme0-CipJNwD-nDnSiIGJzz49c80HgaAmFg5L-n7sgTNwQUeobdtIg_o67uU74IyIcnGJSPbnICmY2BrufBQpJeVHI6pgZ-wGMtdaJkZ6rIMtni7wZzmS2AXJQbDglhcycdHKYGQmHdFZrJvgU_4LPxiVtkZrtS3zpHsAjY_XuVcfxXdlRtwmXJWwf1_E_1hSHkWCGabIn3Tu7UDpbUBtCvSpJe8yExUrkhrxXNmxDn3UZitu3UVpC500rL7zvncxWLOVbTGcAmbSwQjxDoxrAG_ZkulWM5s_sYZ33oWShcyn4yvnTNjhk3Tjy3NsS8uRago1cdVVqguTpzaIxfo15WzJx66wyNH3mnM9uCb3-hmfA7V_g16kRWjllx7PoZgObFQZyAXYm7Oxj0sp1TU9eezrOOL4CSYluGLLBsHRzHgg-g8L1yRhrYNgoX6iVy_YVAHOmJ3-UBBfcKTY3b72LhqPQhhDwCK0xdmJME51Cqz0WTQr1Cus0AfkszVdeUFe8JEbZAlxyUyE6ONotpHxVEnCrHglMizHRyE5aX2cjC0vzZsgk8Fr9niqonf3jORZYHz3iZZoHvxJ9mGkckZqXX9EkhyIyrAACfQXdJaYw7Zp5WPz0N3x8YfalLfxZjvHG5N6yeK3ZME7-DCNRCn9a1Pw9k8BPQWT8-RhYZyDoPgjHIaUJTWVaRL9okUAGNAA0TDttVmIZQPiNrYv6_qWqfr5KQauHIWn6yVFjDFM7H05-L5fXjuwWLbGvIm0Ohi9kVz6Zt3rSj5v4WLCy8dCdKiupUBPOW2atsaWVb27D6QT4j5tJSwmHONaFZ6vRxHrM2nuDJh1bQWG1kEsaFuKLZNaz8m8s4RRHU5h82qQGjN5lboEj0Z8iebzBzVaXysuE-Ci0Pz-_sAubR-5ziiZgdblHW5y6DrB6Wd6fiy3J4gTetqSaIFVgTSyvx282_5rk2BJpulm1mIC48W8AybZJS8Th18nyJOnOa49JJ0O2deoppihUOc2w9AcKAKM0ZUTU4AuS2U6kr0XXB9oyJB1ueRfTjAfFx-6wXsRlHuR0HMWV2Yne2UgDZ-t7IgYQv3Mig2QhPcmWJO5ypW2xE4zIzZQdhLo9BhbgmorQJCJxySTR8FaUR12Y0k9x0yT_YTVHQO8dGBx-748U7OR3sp_sGv7rtYCnxJZyo_gVdDnK4WrvV4Lxgp4xCcIK0j5I-b2oC3AsvvdwUFmx-DdhGc94LZFa1Gq3Gs-U-VxvrKOzGcf_nlIC7UA8A6oSqjTHAbWA9U0OFDGGPisII-Pnkl3RsJinXN00M9LjH0B-5VEPh0cQvtlbC_J-LYIDfDsPTJOLkf_sYInKK5Cat9UydYY9nY6mYmqc1-3tsXPg5g9MVBLPEJ9-ATQVz1Y6oV2fWKXLiv7IErB9kxIGQ1Z8OnTyOHjoWrIY450712B0PSRI3zlCHLPOrjV-BkXXrjUrrLSgXvbjFiOP0dbvmDtlU8eTcicjF_8WplBCY-v_nRY6FpDyRGquBd6v2MmB562TLoUj71jcveTO_BoOd_FZN24e2r1aTHxeS5mbPVrYXfyp3Hs3tuKQvU5Pyycz_-Op3Z_hsRXbqZegxdGecod-sO-u6zoZ-2NDkaDsVfuMLUM8uEk9MoGvY9cyIgYtie1mquQJwb6YttAb1T5OJV8iXzpUShqhlmKzka8k0dXzV-XxoX-PJ2GIQO9o1RvHvjrJ0bxNe7yeivtGS0b9yT2qBDWhxkuP_u5zcUNd978hqKtGMOdhh0hbZuI4kzhv-2s0e9hicu05JQQEZJXwLlfTjaEng9Etg7zh9NAoY70HihAVi-7tv52PNeZqxRj8or92uiPvoijQqDzBZ5QLB_lRuUkbV8_8qE1aepZXMrunSxV5tUpZ1at2UFPWM1uejKNfjOrDtSQqXPM0Xyypq4V2Dd4Eh56Jl5qqpSOROJ6SBZX9nq9SXHEpQzCy8nwORf77ViI1CJ67edENf2se6OtXfpp9fnVzzrOZJKWW41wCic9SKMmqLIt3G49BY7OMUbxHpVC1B4C8yv8Ujf84Xr08HXdt4_qLhEghdxsTEw5WSgbNHcT-vukBeag54f2zDwgM4wWJxzRJl4EFE4n5VtDA7dyyQyWItc1n_OOwDCXPYObyoMagkSqKnvPp0ykvGqkU5t9BdcG-tmDpUGj97U6E3Nh5YSZOUaWk9euJqxKziG1UmLOvkflKNSw3WmHDeS8JL0ZVCrq1pCaUyJcghkQNw19LgL3P4w5Ayh19-pi-DClI7eSkDb_PZaa3P12DO4pwoqwVGodXYaXyrYZioJgMy2FphjciBt0V8lxfhl5o8fLaxAHlJisYeQbLz8P-9VpLZsK6e6ap_lzlkuPODiyJfjcvXPPi2LYf9p71LFmv1evi2K4X74osN_jQ_SNnfGSBEO4UbKa5B16YGzNJmoLGEv81qOTeHiPJuQUwp8P8eSuwwbQg-gpwbWNo7wL7YhhQfTvkEtUnf5xHSAY3d1w0L2bU9qEvesG48qHE6hSXG93D6Nyw6brMPF0okPKSYKkkxbv4GCJKseowyZZPARGzJ8L-EBvJkWy03kutZoTtwsdcYVIBdKDaHa-2c_u5sB7w5E5LAmEd3OpMQNcOD5ROTadLBJXTta4ZvLkKjmk7TZY3rcf4g6dsujKa8WS_C4tJPhF2JfbbBB1qXIoDFv_9A_QVRs8v2zZeKfnADETpl1kimoe_wAU9KYCbVWBD2zhTg02-QDCt7qQ4RfBc8qnHeoD5koiqtEVswUE6fd7P7aFerJd0pbd_fW4pZKK2h5qTuETIAaSAhqlvNsrLJfkK2uQZNEc2ZR3OtfJdNaOkujqwk4Ad-owQP-97OAWexhvac1W6nYctmzOQ5HCoPhewST314dyxkU-IncKoUbO6xUgsXxedaq53GxVXyzljC820dCYl3XXhYfxbvtGiMfToSDfldy71s-6wHrK0RyvpOFC6WBuiEVs_vUX186njLcdj3QYaTioJ2fh-eV5-5SQCxq7d6zzJDXM2bGR0d5C8P-2A8-ymzriwuVnRrPbFwctvXHDgNUFC0ldbXZJVYbOlRbj2wPRaavp8oqe9cftDwVFZXrMTGmXEuLFSGh8Axwh1iu_GPWI_LJFke40I0V2WEm6NyBSzKzhXMa2WTtO9vN4ZkYNMvJeqMN5ewjX7ISszDpXSgXWOUacsSffnQx-l19MZdg8rkct0r_-m5oxX6PRW9DvbhVjh9eAHAFp_tzePM0DRWUC4U83sCgNJAF9T971YQhE4IsH-uUi2wcU5PFcUt7HFV-LqVaz_KwDEqAt3IiFGltR11UsZx50QCO6V6D4jKFwgzSpteqhYc9O4O2qKwbTaG6YsWb6Yc2j_6DZFNTeQMb5JLDZ14n9HZA3eP3WyIWegbnnUm17o78LvE2tkpuUkoh0QyAg36YuX-RY2ww0S_UZSwjv9TeGqUUsHJTjKKc1BJAyROkYQU39Dl1KymVc6S9KMceJEClDE79omw_jbwfMUOIX1D0faBh8V-9nOfoqbfmCgk7SRalkhyFNbHSwKInr1NRtGkxJoMfdBKG-GAc8OJB3i3aKqvxtRZ8JPAmLhDrn615ARv5Zi95h_PBmLTv3L4_SNipdCXY07-E1UOUJZQCigm-fJoD7ejuNr_oY9rmvI3RYE34fLgct9U0G3vOQYHPjHal5EUhSjCl5uByIAsF6_viB3MKEVLKpq1-f8DOoEPiPjjQVf7lw7I6DzxpRMrP9QwC2OL_-M_D6Yc1oObgWWtR2JFs2xbMIjS_VDsNv4Soes_3obb56CSOgiI8bQZNMvrEm_d8yYVChd1BpdB7CTsF4kOOO_45Cc0hfdmP2OllCRfkVJQvjStYWeb7myoH9e47M-DapyOo3cii83dLHY-IpAOc3o7JmL02wa4wWki_GBBWiEn3fxLEwqz-yJWxBgN0P8zK9PxZQxMo4HDakBpQ32uCHwMtAoFl8DJbhnXdeqfAPpBwxxIeKJYGMXIysXjgAvuhpy75fv1MQRnlslspIrrBmlGqRbr8w9DQPB4KEXvcpQ4AZj0GagGv6PwUQgER2t8d2JGIZz-4oINU180v4FYnECNcj5YtEJptw_yink-gV9v5ujg9KSO0hllr0-4PTCfdr-qPzkkROaCmQ7IbjAil1SDTOP0UNbDrCYvtBs_K0g68DqzXwjVC3sutZ0m3hXrSGpKl8ijRl82ZgWXPogLN_deCXyVFm00Q2MUJxaRFForTNS68ujHUwM7mv9zZRUZ7iqzRbmdRrP-kXOT5ugf-6SaC01zU4DyXIc16kWuErZ1UuaZ1ay8aVzYPa4HuiNuRQpwacmC4F2uGvS2ZiBoIjmVe0PUECZmDyqKUBUSizUT59lMj95yLYKCLn6P1kP01qE0mwQxoItq8Byd9WuzHjqVCow3m-rqU4R5_YoLQnIwduk4yPIys9HVdpToho49-0dKOa5opFXhXx0dzT6JKQC1Ga6ekrXV2zfRQJFn1OMDo0chWE4d_UKpCm9bMNY234-DLg6p_LowLVZzANCKpE3fhdm7X6T0rEh1N5v2Los2gKsQhY0MZIn-jwkZ0V0c520KJRJiGziUVMLACMHek8WxR1PylSiEcTBHX0PxL5gSi3K1NdXd4lI3TLwL1FRuInwrpPPSe__8oby1tIHXhXEb_-WEcjzIeaASmS0A23J51DLqc4ox8dGVXgPZ2wix5_bt5d0tfvb0m5LGsxV-5vxHskFdP11thDwqvtfHSsvTW_E4Rs31GAK83q5qJR3en3fpKmyb6Qo5an3y9vW5EfCwoh35NOiQYNbn9mcMypZ1fcyA5lfYlDz4ADzWqx6Foupqcesh90va9Bn1emG2QBfRIjqYiFdItUK_zMUSnQPcS5BXaAe0-YlhtUGehy25f21R2vDC0Xi5LofbuDGHoX0Z7FffdLGJlt7YxZc3sRP3-84Ms34IeTxWwFSTTO09SAdNXR42SsxfyWnbYpaVi7255svAyQVkhxRr8C3OF5ZMADV0CoqsxU659U014P_mMSkaR9E-_6YXWwWQx5_71T-pPBkEEZ_1UR2tj0_HiKS8g1UK97K6mmJ_dhToN2aa9J3P48ANSY1jUtWKZ9Ty6ByaXxm66JfRkFRazaEHaxsoyWUjeJB4aIrivP3Lu4OCjhBmvJzMYDxSyrQYF61M3Vdq4MY_Y93bEcIW-j5K29261d9wXD26HQckU2GVH2nRbYUha7Py0WFltCwaSBWAlNR0ECePRWMGoW9B3whIgxtBLBBVCWPcqJFMnBkVsjvlhopZI1lqE0bBVCb7nwzMYReXNligJ4OyFxhopzFkvUFwEkWU3bfGr2W9s0jYiT7Mafyxilrr3gAd1KqParXW30s2ueoNqze-PAtlWb1kWWbqqJxkbcpWCWD26a4u6Bn73AjRZs911w4r_pztdl0IJ-wZ9g5qdkRAxHaB-xMUTqpRZdOqTS5SYx81lKKyySnaPf-oQ94AjHVmR9AJ_8FxsJcqzrsK-l5Zyv1-tkFP5dCA0L3xTOTF7Q7u4VBzm6T9BH6QjRLK1GAXsXnE_19nBTRDkU5KZ8otWBLSIVHBJbeie4gAbeJTRwXYZxYjdVQ2w3jXwyyQhsg6VGNnZQcxXePFU2mPKMPIPpbwktYbMyT7SWhfgNxtcYzPb3CYTnm30U7iANtClDrKOCu2aGTer7oYp1gUR3XJ5oZrwA2dE4_8ClCjbYIYkUr-LyeaynPQeOTp8d7sG5RzmP4FzkH_G0mTZF-Vc8VBh8U0kB-Dp9PQMcIc2YrLTaWz5q7SyGuBpFRb1G2ENf8AccnJammrDktqPYofPXXVjRb-ZkwhEuozrVGX-lcV4XskENHBNik__ioRSaPGJO-kYiIpkeMLglJXME4J23gRW2beSsGsB1WkvjPgk7PBgzNtBxGm19o1fRKzeCxkJSfwqNdUVJIhcnudX7c2OTV_xJQRZ1HXTX0RDhlKgD4FODTWiixQ_q76LQRrq7b_6J_LtlrGU-zlejeDnFp4akG0aIH6Dy43qpklJjzaULUW_mjAw2qm2ABv0iPi21JvOk9a3fkrU5m7V003tGjkrEvBwQ-MpH8HLecdNwntFu_YKLhKNO2W_5vZdWgk9ycvzAdmWa2QhEIyn7eBh9bcxHe3OA82BQhUK6T_y_6GnAdT1bKfWTgnlxjjusWjh3ksrn5b5TlrZpKP4jC6AEi-W-7BwfJjtylI9vfb96wwy_I5e32uQ9EJEAfZoAucIVGjfOiRKUMATpL1cYbITV2YSksm62ToB6um0PqpkWTYzbx8z20blOH70YJ6IYOWOaBPGJTVOeVIrcpd4S1svEk84xflyuQFteORpNyPvuJ0MrqmWZ4ssGwsbFhIHWZLgpKfPwlFrO_Z6SloViFDD5WF67cBOqZZJjKyAHp4jATNsitAqgZS_kH42e_TfyQnqh0Gf30zPxaqt9FK6fKyRJzc4hPq2HAxKX_1kPoNftQs3gWaZQ3VFCuhmjFMtkUt3edPhdMN92rqS_eqnb8b1zGDdRVUe4kKnHAahF2xiBOXrBw4Du_l-KAJ_1y1b4ZlQs7zESmIYwchLisXVw8ZwTJel49bHWLAGW8hoFK7-v566oX1FYvD2XD5trUACZtEH6r8w_vRxNVpNPigJOMJ5EbHYmOTOi76NJltcEK3fIFqvIQpPeeHQ9OJK3stmXIJr_rBqRSTs0nJORZQUoDwun-FGQILr5wTb7g_zRT--TXY3gcbXT48CQNjp_DfIw6dEylDGptH7UEX-VuOk_TuQzmNk4poKItuJtGj5PBtvS8mWXrJWtJxp-la-j5wuQmR73RoZw2x7X6ZeSMcH6d42tiqWxDL65nXlFzFp-mzJoaoeiZSh8OZn7E9txpPNbvOsm0nhz_7jnixcORe5V8xTCov5AbO6wNsQ3QRU3y1q7Mod-a9nbDgiUOOkY00UhAdgiFGFEje2IZFrRSRU7BVYyY9LqvSvj8qjP4NVJaW3zXtxZvld26fcG_Fxh30yQl9J5NiYO5xRdOzQWwKZ0_dkNFN5RpznqiETC22JrPQNAgB8YWU7RVXrOBoyHTtxUuwwn4pWauuBXR1Nq-IWY9fe0GkCwwVyUq1XPnrQ7C8Kj7FnUUhOM3Qx_lHLXEhxAeRnmpv8aN2uH0BWPauE4O97vQMo04P0YaJtNxVnSYfKCpG_1VQpOwc1RROmm5hjd0mKRDS1J0CKzUm-PYLqnN52ofbzi1qVreMO1Cn7KRBJRnpI5EZc00RtMcH9YRREdIQ4gc_-9TEygEfyW77fQT-JxLTj_yk72RGcZKxjr6DW10t1gudlFT9B7mJmbP2FdoMQaEpKH8VR89OpazX_GZMbaoWCLlifCIg7DpLm-n6BUKf1JW2wtBnI-xCFahmb9dxUHOKTZ58Sq9_QFQwpIpdMhSs3QPN5T9UVWePaTsC80fhNhVdPQqrSLMaFIZrld6f3zK6UU3Lmwg0j783n907vU8iKb9D1MIJxeeq_QEjEbDKcwoxk7thfHnaoj5EeWyQGdtxGMVu1bL0GMVBBy-w4qNM3mlTy2FQkBhZ5uGSR1F3EZwqBXOd-HsDM8BbmOet2qyaSn8fVFf_a8PoBgCuTD6RRJuZ1IjnXolW0NhZLkGOQBY-eN_5Xcq5An0wjPv2m03elfAYck6ZR5trmS9voxwY8rytYdB_mpUrG_NaBtSPM1Gf_-APIBFwRdfSFmW8ph9dOWUzmtpp0blCg8dnSwFsrmvCoPopAVAVuhckkBeZsfKbI1IDIyBdJD5BFieyinof22KPoqG4v4WsoVa5x3XWnQ1gNTlEB1qnXTiLPqQeTA1cNe41Pusn80Cu12eDS2jX7OjzD8o9shBMONFLdxyzVnXSCyWwfgYCRJ0uaaEWwZpNC70NZ9jzOPD4yEG-PrVYCJBuXeGoDAp21hkEfKvAQEe6TfJ7ZXpSTU25lC0hsOMnmuS-oQ2aEx93jT-KDcMVpDCNK0Vwhsiq8HBUtdc0idREw1QykgGW-5S7cEH34fg0j1pMFk4sUfdAlNBvwquVmM6hXiCLhvfnu_eL6CIRYMlscVMZfDU4cXF-ORr1r8vFLs9S0WrSU602kPVo32CMJ9LTmbS7YCMfqXrc62ftpkf4vfL2s9eE6-AF_vM0kc5cSB9iDB2wP6acd95Y59h7xKKwTuEUEXONF5Y8yKIYJkyY0pNjLoRLvasro--GfNPov58kYMzmJcKalXBkPiWdogIgTskLTLc5KeYlHyx5RySrjURqlu1uLzMw2xq4Fa7_DjSh8H9DVcS9xJnwJ3GJcXvrl34uAAA3CtY55-hoNI3kEe4-50Qfg8NpVKJPAzCUfxaUJfNSQRPXAsa-e9JXk-aaMZE5l9_siR7posgCK3Eu_GO3AigmISWTPtedzLPqYUkflXen1PRPq-xzmqhursxRowlcbUpw2F526634un7CrbLjgb3Qr7gYttnmD0zwTPYicLiXkktSjgMEVxNqVzdW4o565WhyEx6kjS2h24MkEQgPVBfgFsVUn0fJIkr0yWZI5QlAtInNBXLGKe8GR3yU3ac_VLBYoATt6rI63n42hwkfQfL4GZCIWs5d8FKsaN0UQBbHSCB_T6d3pA60DIDz6-H5sy_H_Ydc9w58-ffEnJepf3mllx6jcTwVw4lIk_NVwt-HZzy0GAZJUKTcMXwbSP42fXQOh32qBjUK-bkbqQ-OWW8HwLQjFN0GYZLQxzylZhK_Dy0Tl8zjNHUzf9TQnmMl9IgO-o7DVZPQxFY1Y37PZS-z5QfAsZo7UH8gjXXLScrI8vPxLzzfBWHqTYq-g1OzOSd4EsxX3Oa1-YPtY2flKWOVFF9psk74Zy1myzA1j9WXJ4VD7he75lwd3oyBY8aIiloIW3kPneIqbQ41CnBa3pCg0crbwd47AxL2NGBpeIN5ojQJkMrtXdQhxQNDfvxA0z8BV5xUPWIHWYlG_EwQT1VMCJsH1ddur49uXqWkzAhSHyK0fukfD2cT96_wEz0-1kRNoKofmZkWDnE2XVzhGlcja4TSXa56Gfl7QZpd_6QnSQGMR1YKNXsQZbaPYX4eXIjmxWqjYbAAXFAJKNSQKLox1nkMEtEhJpY8k76X5Ij1yVGJZ_TBM8OWsEdFNKTO_-k1IpBdBpYDV2LXWnmLqJ_Xw73uU-iaY0NayyGgH4S-FccgAOwVxwKySAXqz6DZlIDoNEGwWj5c-M4eV7zsfWrOzYVyZM365lvtVIjqB2lxz2P90MeLIh3MmjNrfjUcQMCU461Dzus2aRc70Jo0TKhJOlHRPrfCCH75byt6NZNrF7F_-pR7EvT4xl6bWWOxAXSVXa3nS_KE52zFshEoO0w2ohNaWfINboAhnhbfiJD-ufWXVFGWnOd8hnRZJTzZia4hr7YA_GL-opyzhxKd8ukom-h0t6t1w8ZTwrWfYhG5-0nn53rskbxpBvLQ0dNMlb2JBIkVyd8Lrs8IIz6lhOOUR2bMW_NFjP08lqVRZ9nrFPGodq43xUmp7iF1X45qbN46_5pctCkFomXarxvX-HJ_B2XBqQkZh3jLFK9GCKqPzW949Cn6nJ89WSKozwp-bRkLTfAx6QNnNm3sm7dFxakrLPaYA6Jp5tLSHJ8xJOAb0P9kkb2WxSGdpmApNkdM6x1T2fv9nOpF-cax2OvnWpKsAf783PazAIIMGt6wm5kvfCsW_AySw9vMVmj3y9pPwi1gtgThT6I2xKavc_Rm7Kwaf6M25z-gKK-m06i3847zdkaWc0P5-7RZv55WWfHmvSGABtGGYHQWVJL-TDxQRYlgRKYlCtBEOn5ZkjYQTuG9ibHFju-Eb0eJYb-GMPR7XoGPiIoV_58KskVC3iR2B4o-Jx7gdD0TDOJ79v69cbzhgdr45DZictIrl6BSdqP3GVkrkWOWVdYwXTnQ7i_VN29IGBKRmttlSYBMCFqcWWwlIXdFa7flQuL9eMzNj_podgTW_P_lex7Zu_63wG0OPAP3Qmold6Aa1qxqYjYHB-gxZ5fqjy3S0GYDOW2fV42s5haWZcKD7maPt1bQV7IhFhQ-q6WTpqSBr4znPtRHSc3K8T7Mib76yV1AZXAjhyZwloFMvusD8rIzhXdqYaGzyuXWBDM-yJa-IoIBDt_DepSQfCBp8nQ1pFWC3zmBhXK-H45PPQyPSVnraJxvfQecVZ0Fd790LqndoMDA_8pL4bVf8B7HDjEBjmE4sVoFaCGtRBAFT0-yIWlJxWca75eS2ULI9hKYbKGg4WE-OXhWpDheNNzHkGmpkRD8ZcIvGGq-Koc5Q_p06JI22watX_pt6lsE78ny5t5MpuD76qcWva0F7OF74Cb_egUu0PRz2aBqWAsOCulJDCkNDSVxDEudrzO0VvecaufjmKkYbP9bzJc-KOG9XzVyVmAFWOHWO_qnLGpTyNawwD6-h9II5k6punolsRrp_g7Ks4HPjx-vdAXsBgDBbsS_8Hw7y5OQKhKGFfN1z7CNfmXlZqGa__lq1gjAPBPdvrfO3d1yEUsJgawAgMiqhvnlo1jY-_c24KnU0K8J-tp7wzB4MKdy63l7l12vCkcFcUqBjCKujxh8zol0Qjvt5UMz0ShH2tTtdKbs_V5NiPCgmK4bkEK0kiw_F4e5Rsk9J7GN-CcTuXQN_lBDasB4RXejByeL72eQG2zO3xQHbBHXuw4ulA_jcVuXW7K2g4Zmm2aV-ATdQs_Lu_UMxyrkQkpTiAwV9pxsJ9fcwnDBUvZXt-ezeXhhiQ0asp07Ec8zr0uEBDCTgvkymYrPUSh8Tnboz59Kb8p8ErO9m6FL8AONfDZzX4Zb6xJGLwDtMOkuuEEVmlq2VFXDgRSj4agkZ6zKlkZni-HaOHcTwqsrUcuM6uqHJwg3Ze8tNsTrYZ8LoJQsQ5lupoKCX2d5d2YuFDJcpDSCvo4RuFOKcEhW3ebrNVL3WFBnPdbziu9ivOaiHKQe7kXOoQHrhIwsGOpvcKc3_tg49quIDD41T7_C-aITwTu5JGkceEhM9nCRPC7ig8SHwuJ5K39vvnNAV_EmbXZ1D8kNMYW8EA09QccFZcA2eXI7S3CcqX3bydCoJrwWry72eJsnc6B-Tsq6LpEasWkC1J6BRO7r5PmaJ3R6yt17RXeYsPhNS2-2ONyeJXO4eSk4S12s8WBtjnADbLzFlqSobuZq5Yn2suRkpIltqaQyOkCqtA1GOekIew6pRYAXzDCInoXOjHKuyStBerk4-kbEhhEAp--IJnr6G6BfGTRFE_0JmA9Pb0RuoHUIZjpIFFtUa0YXmm-xb_D-ZG289Fp7hPb7wg5w2S430uuKJQbIr6MqzTKTYeIgTpS_Kao1JpIrdksyVv6sfZVatN8tL4E-tMRuVLteTpXLidvRCUtsPxzQv9ehsxry1V-ApC4DTpK3pmjQeex4q-ixf57MhSP9_dwUdus5jxs10CCK9r9KulQlboOlaCO3_so1RDgudTvFYkIZUUuQ9-Ub7gUFTAtz3BI6Idx4lGCByToPDWe5XTtDQoAZUOQ50beDfLtWtJTQAm17jndb4GB4gigUQExqJz6eZ4T_V-uw1H_4WYtgyDxt5Y0hjvn_Fr9pNaDWBAMxP03TIqrw9vQyO_Ct_NY35N5VNkAWE9c67ISxTgAMKZu1CTQOEkihDjV8uSXcAq3xZP02BcU_roSnqk8vsKgmfwMltnuOv9E7j4lbRZbHp3WO2MYr0ou291pD2as1qX64blYtEX5W4OV_-Tal5r-_p1yxCnLUM0QxGzPNeyapN2rKR7FtPDtNgIi6hR1vutTUrjB90dp1maE_Fte61C1m__pdOXdYVMy8BLKor0bO-knZdyrKW02xKrcleidXxfCCjdj4P2LF6xEnswPqE_mzRrryjO_vjXBzp0q46GFwRqcsBkwAfpMpeiOjsVBFT3036zbQh5OkKrrI2zgSVqjnm06jFFtMTBvmYy5yF-YJatUglimDbFxGZnQjhCWm_Vc_A95ndaCEa_FcXu0SQhcYxFkpBORDVCO33BswzxUSIZTlcd8moWgYbbPBfEjo_uvmZXkrI5gDBkFLgLqPnCqTXe85Z3t-RmOh9D98O1pJLSffdqZpov-tpUPSfO88CK3JW1sRUPcXDUtpx9pYDtCfuy20GK4Ckic6l0UuEPQ9qQrFodnqD_0Yv4vVLD-7HGXNLfH9KusspBYBhpUly1AKsTRbAdqo8m7SoFD_6J3GiU0nccfvLkd5BNAwl3HZ6EDobrseRadizsGvhhN1Y04XIq7qsNmn1Pwko5T8fWMJhXJ8Oo-nhQNr6oyhCtaDSF_u8CVec7an9lJSiotUOSdCdXQn-C3brVOtDQHC2j1xh-4pK_EA51-8hjThGn0AjFgr4lvbxyueeunfrtRsgvZEhTfq_YL09BqNn5qByPd23546vahOysVaQ-dp6TbJlVxSIAJSNsTH8qwi6RnsBWFtPJXoy8gEyg_Zp-He4Tbm1rIBMKsArFshAcy4zZ928a4mZsZny5Lwob1yvC0MQsz1tdJUDBSsxqxn0hw6S1zy2LBUaYZaZexSrO8SYH0ZfPd_gTs-yHTXSWmV6f1JfpgIhjY2l4G60x63pwcd1mYGgt7c6wLWj5CObcTqdKcmu5WBDqNAby1ahLJ7oZZ0kJ9efFGvftTiyGVpp_sW1eTOaEis_oZTOOlb99KktYYhzAJAp5kT5e5jSiwy3_8KMOhJMELi_xFgBMQEldpNKlFQ6NRAXQJUiqc-Rlwgfv5fKmJNmLzTu2QAuolulqHCQJXFPHZD69acPeESaLi5jPpkS9wmj6eKRGzd0dPql7pQ3qTNMANO5QFX6Jg5WIrC7IM-NslZ8F6VnZNutCwNCKtADEurfwS7sos21vCLYrbJKq8ag8HeOI31dK07FScRBRu7Qka9l0hzFlOGweCnsa55n84ccC5CySQsyd4LqXTq22APaV4vPygv72g_ErSCYGxTaq-OT9bpubSQvHVT-7ZTaz5gVz9VDeGoDIJN6oLBi36KElDBh-zOYot9qLWB04RT6Q8BghiAL0DVLQN1945wFJFtfzQ0a7OUs11qDmgSc-fmInBgY8MXlsPThstP4L2qescwEwUkGDGOeDe4cVIzm0UtUryRNtzuWCQPQz2YK0gP0UaJ2vm6RbkmFxwQKRQHxgzRmT3eAxCt6pvu_5qrXATrsWzsy8n54vMUCpEmPnWR0RS9tFWrrO9Srl5bNRAggrAVEPLsBS87LHD3wDBs0QZq_xyCbANZVWk445sthuWX2nD9Hn1sNsEY9XorWGrAygCZagod1ij8b2Q3039JZlOu6bN94GcNTENb9iq5w4_wZ2_Nw7gslnfj5UuxsKKMwMl-M_AryPpF0xbgbW0MPxcYu51-ZKchhmlO8pWTtzuGXMOX6nw8WbhiqedQnjCBOSjIJmGNkudKlYDutgg5tobVyxvx_LrgulIHz5DrDg9iJRob8LEwvnDN98E0da3yM_xMuSyCsLz5qFmHpAHlTghFY-ooE2qMj13qd2b7VG7qU-Il1EdUu5PcSDOb3BtfhmxVZmdXvtpMGmLNa2UKly94STHnujYLiP9VjAxDOAgJs-UURlX4ZR8t_MREHFbnvqPZLbqzJ-eSZ94I6686htT0f6AQoIYzLcIdzELpzV2m_HU3U1YfF8Gi9-QJQCPMDzD0WwaeEaTxXDtuwawNPUzhh9ovvngkZSKnKAGIg7D_iNxJ2ntv0392xd3OJliEVsRD9-r203ojepraC9HptOVSHPdBbyz-qldy2K9mzF7t6ZSfJcechaspPyrA_av7bgKozKnqFYbQymh-uf3Yze5N61uykjcn2HYPabVlRTKqyJK_gedXwUvsOFt77mx8gU9junSXhqIbR3ebcfKqYVy2utdRO4H3mB723k_WsrLv2MsoDGHnZPpgq_KSx7zuuuZPeId3hJNumywb2K6fLNUMNDW9iD_YSpC9iaFsaqjPBoxs9RjrbGmK938kuwujaXgimIJoKucLuX1N8rMbqHkVi56ct6Go2cpcFaZFwYfgwj9IyS2JLPy7etlhp6wDW-4os4n4AG8IFWxAnrKq4VPV5WgS7CgiD7aO-EU4ijHyspMrnNPM7bMj-gOoLSBip95243Ig4bu6PbTX1zbI5amrvHbqOsrvREVQACRq629xxyV4h-CvaIzEmLAqGbPRDC0B4bOiKlJ79KsRFqZvsxP1zQ2IswPSKW6mKXqDlMGHyuOQOJeKWeroXB69jEsd79kWJhDTNFfAt7JCl6C2b1h88M1oruo3ulIH4RvVKSUGsz-FIrXhxI-mgup3P-gi6PJjP2x4XJ3pjVwuQvbSm3M37TBJzxFoLcrgE9MxtJqEt1Mxt77qU3OKWHml3y8Z77_tPKyLWEczqBpVWfh5Q-niKPkSmjsy9-5GXCScHWZyV50CaagXArChe1FvIiIS_G3_aqZ-ul8437Cc3R0-YWJyWjgQvPQ-qgcnBsGZqiSqRXBhV5W8dJlrIHZ6refr58TC9V6yR7Q9oxL7mzPSStN53-sKDEtIyJsRgbLE-l6Z4_MLBitk8xDeQ9HKEJZID-PMt_pd5MUq2kJa4e63UzKLdS8kNY4kgPOp8P1ZfrY-3-QdcFRxqse66xinCk4rMXqmneqnwlgHGQTcRkiAFghEu_VdMXS3LVPEDJVrDwMT4HGvGk_vPeR1ysc0YEYyhkoLqAGZFDGnOauMNL-PLd_Vju_MIiDYoa7h3yuSuMGpSi4RzL3Dkotn0fXZXOHYVejmErshRYFqB1Qt0cZgq8vXYPowXCCDNTlnC5wFaH_4zqq22sCH4VyWK6_wl0ytk_zRVEayc4FlmW1SAk7kXaIQdqxPigXeMVpsirDapAQ_N3fN4AmMNtFZOWt_Fj8OMo-U8_n1zltEbeUJeARIPNaxbQYdfzrVwACx-izWSbqkhFIwDWLUc9JGzYBt9ZqzY2BOQBFhNzMjN2J2Ifa05AMP9WN_FIsFpxSI-I7dg6-kgBANXm5rzjIYrtOl17oNaEQ0BKzQ2Db1AaONTkuBHGXd71i8Jth0d6xG-4mAxme1OCW6D1HkQh_a69Y4JLcVaO2tuwaoIFZLVNbcMxQ2XZt_tVNdwnt3iPP6znzfvJpJqNDpxHZkSggKtn5timJT6lMuxJHPL9BGqsu3i1_J_q6wGgxrc-q45RFliMqvDz2vESJv6_sXzQluaObxNnMRWD6WA1iz4foLgax98v0efJE2iLZvy1-Kva7jXoPTp9P0RfyCESSncWgFP8HzsflERfX2WUnxsiy6NC1ybCnc-ZEUDZ7tzRxsDxtxSNR2nsfaWRMxEmkw80X9TlE17h5P3JHRsQSIWJd9FzU8AEg2WUFBQpT5n5RVxdg5JdfpNyGOypcGnwaAEwk5bDYBlCLOqtw4j-5yD2F2BheQKhC981dc7Xj_MNuAdhd7ojJjV2_T_J4-hdLBDNL5RCZhHHVL4HScRmIanZY5Vk8kQXpyDeXLxa0eYu7K6CMBa3m5k4Vjw9nZudgIK4s2SZ87CRrSU_OmNwm7twcamj6lTUBvOPap6QfnWqxZq-YPLPpIjjk_O43RKqcxv46pvCcjRGmlccEVsheYzE30knWlvGGilhWBohZuuH-E7wRePqv94j7xB_SB3_Uj1taHuTrnbNu3U0HzfHg_n4UDiwHMz9RhsHBrBHXOOAshhkuFOYHcd7-a209IQ_v-Gfqlq_TM_fZ28rmqZYVuiGvUUGeGQWXgOTANr-8iJgAJkvGVDzekHK8jA22vvPlJnb2ApUZZekGXX5XKXMPixs-tYushSNmPn2yLBKicndyMlsAt3TUh9_EOpiaGrYLSagmIW59P6_FRiQOWAm2afudYQsi3W7pXWSUbAj3IlpOQgR1r93icXz7AOhF2ezn5HGgZ2iwK8B3QYVZVgCkwlzxM0rT9a3BSrD9gp_B1Yubhn5WdFtvUTEQulZzUrc0NgMxAFQdv43lYm58uGo2X1OuhaBFOiQC2q5ahmrPFw-mmUnr__baIcvt7AtAzIHRwK3H-Jb4V3tAltR7srKhOneIgEFiqDwurPezN3Gp4EX5Hiq1fkQ_WgwQD2-cVv5924ndjJwGfihUNP8xndlmsI1G5Ysu5JEIYKOLtxprTiOYUHqcOsA8KdzWozTVq0OB4heBOiCdbgBEHxm7n2Fmb-zevdbQbU1-4fXjhmnP0BOALSVDxSlRnP2ntoxRk0CKGJNhqjbo6aSnLpGa8YHLW-KkHolH4HOp98pTmTCec0jr_XfiZaynGg3WOioXm2HR_YtqwUAlTOHzqzIV8Xvb3S1tse--AOFc9IXSzFVd7OQGuDAm1dr9Jjz9ZECJRXpWFVwvzvaAWcBSuQUIPIePQZZ5nOdQ0CfeythPcFcpgTWc5_6EJ3MGZqIsJzjv4OtYztiPw2WyTvihx2RJFp-mMYOHiAVCFXH_l_oveM2xWBH0-aoiYEVwjmQvroYBChQs1KshizeZpT_aAbrrKji641efjafuFWufefE7FGGDp4axg3BM1eobCKISZ84TxkvMu9TlQpGsIWNFq6AilljGOKP7FSjSo5j1XghNpXsNdPHX9abW6Hz2Gt9trBlqvgSkRVpq9HlGoQcwr2f_5EVsCm1GVRCM4LLg4xlK43SI2UMMgh9BX8f6FoogtJ4g_btEGZp9efHNKmK-sexqxV9Jlah5aEDwAfulDWz-81AHza202AfbnDXj7QFy9v5EXmwcZ37lVJMBSrcrTHOPolIo6woXjLOt5VhKlnUA5R1rmMlf3yvJcKA39YEYG2SpkTqZ8SjWosjfwiPc7ZO_cw46z8JEDnJMqeUICD4yovJriRjOSGT7-qu6MOW0qFt0WbiXg02IAE7XABRY11Xe_e8fuR3XjpguRRximKjM1SvyPSrvpdbCBa7zy9S__6KpsFeZz4MdqKzA-9Ifd0PShUCciKML-RlXlKCW6JCaVK76MblEsDPP9AFy2xm6v6rs2pOUA7lXAq6oorABWaV0e5APjZLi_RtjfD3is2f1hlysyuzGI_9oacq0pBh37HT6tOBp0LrP045VpyLeFk-GfYd7h-GkyhFJwxiXLgH4ejIcuf7fM35ucJ8rkgCQBdKfvXyNGokNBZ82LDMtEaI8sva5vChpjF1c8vxZLK8ikgnWigFugWPsZ0rpjObBSFYjVwB7xvn3uBJZdTi_qEDlqg3AQqrCdSC9MEwFWufH-ZDd8fWcOqN88nc-Sr1YbjN_cyXywbX2t7hVl4O2ivVA0y04WLK1bK3Dp94I-eqlRhyaLDoJKl4M3w_sJYqHcIfaedtanzlD6fxC8dHDg0Hu_NoiMf57YMFd1G3bWjpbgBz7cgx8-ty_bFaPtJcmcI2GS40rp2skMF1HiDa71lxk-RqdG__V9RfYCZhH-M4_JcqVQ79pOS5e2QmPE8Z_bDIKGQQVMP2SCFlMojNt2fQ0dvFZQSDfvCqfvBWDILaP0oWqwNNj4azEYXrjqRf4p31nVQZrQ12WNzUp59JvnPyr4LE22TSfJe2DiW28lA8U4J3M6Gy6nCdiWiln-E8w9bb_TAKAk5TSS6Yc33IZDeq_kEFQmzJcIwK9QauT4XMLQC_Dh1scCMiTtElGK3lLnJHw4gtbw0eCLyVDdECMTxqDYKPZa0XUyyKj6tmRfmyKCXj7KCfaDX7E1UgRDwI-cNHGgUwEffmgKVkox1duRZTy44620oB_gZAiiG5lxAk5oGujdpx1YWWwKZrWvwlKZk3UEIe3XbPCqV5mzYnmV1AWEBp_zLwhmOBwMKc7TRuHdpEG3nozH1gsXMCNSRqSdVrGlD-JxRU4KX3fwCCX-RhEHtSdkqMN_yzY9a9XqtzJoZEHdIagmlDD6VtGhscx0dwLLQQCw1KSftjL9Odzryc6HOxQBdW0ELF-v1Bo0M3fRJ_m1by2k6WBjhS_R5CNHQGgPBgbrT4NIr-fI_ZkZ52y5umvQwhfYZQioeMzB_FgC_VhIkwxTRCAblsUhRr8bb11R6LK4LEUc2palseu1uCuRS5k9dzKuYAJ-lu3f8g5xTVIgW6mx---8qDQE3ZSWwRiEln-LnFvnQvsVSskhJ8qINedTes5a1NwDRNZPpNdGzpy94VIaVscY-igJ12_iDppLdbaiNTThbT1uA8cWEI91m1WCPirNxpJz0DM6aSm2TgBNB8iX4a6yy7HGWx_oyanTGusEKsvdSzhS80AGzyCyVr8USgT90jIjEVUQzpS5J_2bghoWyuhDwR09qAYw9MBagWDcYVZFKEBxtAYWoKLO3l3cTtCd8roD87GZpqaLl3LaGNPOib5CxbxIjdH33DICM1Gj3cWtO94HPHIKu8pVkpxV7iZid1i_lg1244MrHT-fg13Woi0w69MOh9xkd4Jx5wu8if8HOCJZv5mACdEmFti5C-_p65dWttEphYe8d0lscQtXc8vtQI9zxcYX1a1_1tthO9fZXJl48Hvf2dxKkFGHnJjyynjnQid97dLHNP16bFPAHLEEttDlclEO7F28HlqoJGIALg0Eds0halOTDTv1YvKVEoiPgw6dNwZSvRrJ6X99CA3TJDiuAPB8eus-GbGvmHA5RUJJZG7SaQ_eLedG1Tn9_XZ87-3VEZZMP9o_gdVMUtEWGRsn7Wh38W-kIht2rA-JDI6QOFZV35ZjTltjkOJReLg0jNVgB6CrhdTNcydrwxcux-tDSw2K_Jb4K2C8xg3Eo9Z7VndK2No9atPsANbecCbtHbGv72TKoHO2BvC2L7FBO0o3b_mbuMy8zyTHPpnhIUpld8ELgifrRyafrUfVOLD4coVX_4tJWLzGqITwXGSdGfiRaUZ9i2GhumiCppP18yWbWGGwj16rohyYRSX-0B6N-6TK7XSfXVjBbhDiWXDkzoKSMlDvnKsg7G9JiAu4nKrYYCm7bglrc4wwzPYebDILcVB5oyGbrk48_LqAsCK5Hgswo67gOkgxZcyCwK0n-4igaWPRFjtIFexscUTBM5fw1ApWAndv61xXGQPhOXbfk4LC6PpOpd6DsR-Ol9PPYpxPxrXDND1hzxInXnPz3XW4UNdWHjpoFSo7NSxipbCr4BpaHxMunwUmJnzgYzBmbqaFVhrsSiKpcUwc9PpquzoGezOoZWncG4lBYY3WBI4i6SBlaFUGu_AeNL2M_mi9eSFLDkWhXwwYkAgkv9UC2GLfezNW8wX_CxhJrjPLQS-CIfOFVOb2CwSiuqDxKvPeV_66BToy000nEgQcvQZMg_ymiV8jgPMi5LximZJJtoDxETrGmksbdWRsMNpjMMhQgbjvN1gLx68mzln_o3ku_C1mNzmngDI8Ch1jDxUOXNGHMD5OmVZXKgGCaF-4ANUELSBdncjdkuqYmMzK4kdsMHKpDGncRxOJGcSoqd5dbI9bjfnsTKQUn5fMam-odeGPL9UMI2Jd5rumKmllc7_G-AS_aJ6SeIpP-ux1HxW18EU4fcYJ08isf76m0iKZYSVfvaEbogjFmssOliT7LDiULBwE4xEHasdpo9BWetiM6GXL_6TKEYYxZvW_oM21sb4LscAD9iN9gUfPThU6rXUAOYftWd2PamtgViSeR8iy7WYJa3dEgcxw3Iw5r8mYs3OWvyBnywTTiBh15swsdxC0nQSkZ2BTexbgYycLDlY6TQNuQJF0HD26hyNDN5tBIyfcRxtrBJUtQ7RUPnXp7E5KNISbhxUcgdt6-omHJXvx0DUgC7AB2_peEbm6X6ljPtXFtVgCaTpAATSsYTYfb9aHS2crqAc7Xe15kRAJ3YCr5b-cMjCyZbbUpz_SjjfhoOWpZ1RKkDJmxZ8yHiCirtFHE9rhmkrDFSApFNfHf4qg_BTRC9XcAG3BC6pEO-6PhUTYm3l7iAbhFJSY-ITmxcDJk_rF1u1NzI-O6XRT9r8Vpr7CYteFJ-qMZODOeZhmBuHP-vxa9bm5CaKM6Z1mrxpRzsJUo5ZxAizdgn10FaF5LG2IyMElyNpaOkpA4RI17UvDZIeOwxQAQz5xlhqz6v1GOkyniuGBa4s3jCW1MlYbYCVsj9rQWhiEekCigyX7_vEI-7UewMrFpuYYucEUFgB5_2_Tp8zD5U6vph1mvlKQ7rvx4T_MAp4VYOPwN9uzaMargxZmSFRc7edKtAvjAh313k7IxLQvGzRExlLdKIrEamJiMoaiTmWd2G2hmVwsRdKP_VtlR0kAv_Uft4geVWrtxEicMeAd6Naf2-DKpXVErrpouVy3LqlVmFEOKF6doy3Wr1IXpujU1KAe6RnQh_pFLKkRhEtApifdDwqJt8VxaGkWzfrfwl0ASzJBg_kfd-dTEeIWqEitcnMtHrQTYZVOwqtXn_4CfTVFZs7g4YN2Xe9uheoWDEh5Mqz_A5V6zjCuIEw4RYVnwogKRx_ki8FaHPegx5HAeBIfXlngiCiuxQXMKAFYXwpcAr0htcXM5z4SIhg_CjyZRczl5k_X1w3zAZBzyRm5N1yQ2yyilQnmCqQVvcJHPBibgbVgM1Zci9hMn42WhET2hRooU_bcWdrYLCqnO2eZht2IgkiJXWAqpx77Jv2lhTN0azQMUb7oYkR2_TBEXD5fQYXOdtvF4oElHWsecTqblnLVdYTPHS0jkvn9FgcYBv9uJAEgYwIWOO9mtWVHvPVOsCM8pTyB5-D4jx1l7GcjhUx6wZ-uypqnnHhZ-_Mn917o_m1hIPuD9lGYl10RlIcAt3g33vBZl2gPcQ5ndbtSPe04jwWuIwxdP-MA9gGTjSRQGllezl1nNmpto8Ifuqa1ZQFdKkCavn31bPvtTXKkcBgg50vgH9B15KU2g9N4l4Jvsr4MPT6Zjd_Fgg0KDx20ZI8ZnrjsUUh0SZ9BNYigi_N3c9ZDy0AFD7ltz5g0me5mbLir6WuM0EUSf_LIJHWYfsyaogzdI-4jHMzfg0VtQpRC0iRphWlMh13calSV0xIJJt13K-ik9S5kyGrK9wGhK0eD2v_KU6gxHZfRWAI_0ItBR5ni_XDvouOKgyDVXKceJY983bVzcI-ik2QRkdr6tRItkC3dktZuPT9s8o8FXItqXgQ-D05qhfK1VOBjl74VxOxvmOcgyU-vRZHqfZpruEtmG1R6d9ooe4Ysp-A-B-3eU_vzXju8yTnmdhIwccl7X03uYYiTqgm2E7_B0_59rreFpoh682o7UyE13BnxJcGbtuu_rle8UC3ZW50b8qQ9F11EwLbu1bcoBUhSFGKISZD7zOVf0UykhYq07aQhMg3N0T3R97CBxGoAWZ30vwGGvqy59UqEj_Oq0RP67x1RX0o5-HNKIACTZcMhEKuV-t38Bw32gUiEfKtFWUkAAPxk00eAulhqvlCq-L8tHmuj16fmvycL4sDp5_JxMHGXzVVZCc1oAdoAhn4AgALTNDIow1XaVU-0kWZxr5mT4WkampHScLvx76aqcR4CvfmCfwNGTIU_rVCBz2cbTcyoR4lQCLuRKcRCZMQVY1jjQTXbrY0WIsY4QGwfbVm2VMXjVcUZ9EFw14etsVPPlolO-2GM6vaOsz7IrnJysVxoiVyhfOrfWkiSh7EDNOYnO5bhNFoyLC-WzraYYGunfk-hkNs69YsUa2hmmSwmUIIR7Z3OwGMxypFxEAimMnpjik9PvsKHDhrzjAitQbwtZOdHlZ24Cs0lHSJgabQP3LMZNyzxUvEPaW49Nqel15cKXXJcMGtWFsggNLhMV7rTr026izlnnLYp37wlHrd8kcAK-26vC4O75IIyhK-n9X5weViM2PmYTP2oqqma7YXv_anVh0BvVRFTvFKpOT314-LeRdPwL2xD-JbsS5AZtVufuRVoBApdL3kPQbHycVp_z7ghvMdm9BsJW2DFfyAfmQluzfNEDg6xdwGpWOnXakrcgoZjHNlvw41OVHMr2LpYGdvtP5VmbO-CdqxdMT5pABflnCAgT4YoilIxlu-btzfS_Nv3C_ZwZ7JvbYiyi46AczpTtfc6nEbFYMBSYcR_Do_D_22uKdNyLrEFU_p5qBkvwCRJCZ4IR8BnkVDDQM97lcEtETy8D_qiNQhVqdDE9su-dfsoA45QcXXDClDw1OnokcdiGQRMxgHXNaHaKZpfRwlksawbgeglNg_66dIOS4hRq_4s9uKCsbfn4RFhvJZaGS-whKNE2J1h7zTXn6gpFQVHq7ruRF5uLbFtHjnqwdrWuX9j94pms-lLAd49Fpm0AUrIduTfDhcckKbmMCnosrT05rP2OouMLOsP2hg2SA16AFpTJPyNBQ6zvfBY-z14nrpNyinFkPery26iUKjjI1znmrI-e3WIZPieaxCnHG13Is0XhEtUMLcVmqkGHonC5q5klBaPDkW452sXSUowamXq-hgfnq9UdRNDvS08TNLlbj9UtC6grQu7krmTjtRr17klulYjd_1NYsSp9DgyER34e1dkZC6R5gNyIeDtCaUPwNyH5EzIvrj3Z3Wc77B3vMWZTwCL-pV73o6Ei6RW7jdHuE43tpOebtO8KbHe_1tQkXQhFsFAbnTscz23TuyIyFYUNMmVlMRxclYNdrQB4FikoG1GC5v6DhUICUtm9AZgRMJql-9PHjaIgZsKH2CUTGs7I2Jbf_8vanno0nOu4Fq_-AZCkbSDoUBh8DG2ZXm708bcEer9zWcedPBZEmTnWUKNe9nX_kNg_IwRyzIAPLnz7s6IQfBmCu1wmJsVE2WjpjROlgfVLz_2XUAQXAy8MbohbBL4m4Lyw-_B_8orLlewUjTemTB6hvm21PDt1CnHY-G6mj_fxe3BSkJ9pLoktVfDSd04bfk74GaaUf76_4zB3b4tQdMA_aGqaArNQWojpDza_3EZsr99ZqIpw_AKdnqw0kaCyP0DKzvZ82ikpgyizm_oq49AZ9AWdEn5kR59oBYIeZyyIL63ahOd95uadYqzaEZCR5VZOJM9RTe1pECfbYQghy6nYHBVdurtTefW6e3CEUfwZFlxuV67JPp0O0P46nvk9i-67FNiXaMzMdj3Kwc7wAycT-BppI4XhqwualbUPwAmDZWZc5SFsyGWTdG5KcG5HUgeMy-6iJjQVTqK6PudDJIeg3js5URcALUgZzK_6XIWZNB_wdIK6vCr2_dYp4pvGOW8M_MuamBxPzIzYuJKzkIZtWnqKfuvvPzvAVwOAjtlvW82qng212tBBIWXFJO47ezzQbV1GfgM_d04YTaBIJH-R71d4x9LP3dfVZCuCFQJuRyP_ry2ZjJnGUOpF16tAlvDbyHytE0LjaI0_0p4B6kPrvTIuAt_OD8nC2Pfkbc8uU6TBLmBz3hmoTrXBJzQDCRv9vILNeU6QCjrn_GXYZm2UW04p8MTkIgdkSdtVR0gdGmEHCRUXyRcqUUYaKieIroXVxUDS5GWfhPRPi7y0-lB6ruJkZWJIHSXbdocR9dEsyijK8vZ9buzBoIQC-LSFAA6MyGYxHaV8IuaCKgAnxF_bNIJ3y9KWvYipx3oG6MfB70urdduZDe-pkUnD7vLi19XqnR3bOPmcNeqQhWxLoV5TufL2BFhaDu7zVT9Cj4l2XowQ3jw6ZVN09bdaSSwo6kQ4G2irhIqE2WDnLlrP1S7h06Lgfh41m-Ay5-nV0aZlIDkA2p4dBQSpymDuXIJholIoM2Am5-adXr6cByR4mWq_LLJ0mzrqxgUCOFZ22EhdAetNAPK8YUD293U1Rj-NlKAKuIbNtHIQ_sHcn0bTUi0qDf5ZbuvNzYr-u4pf6thmiDmqsKRXaf5ngStvoh6C93SSGBnTiAfo--TZ6elVa1zHCLejfuFLXza8foNJc5BZWe-M0HKRdAeNg29X_zMWtJm8Lrbfdb1GJg4VmQsbShNV7Mt4WaiMf1STgJm5xnuXTi4NHvJARN4r-dD-v8ItDfG9a6mJXOZgXZgwXN4GbtCP7c-REoWzLLXBrNYoZaqyCMQPyMg8FxD7zc0XjK_DZwOmgKqCB5eh7qCin65PZENviC-k-QjjJ3IaY57kXJ_yXi5WVKa8guAXIeJhRSG6GLzMXLHVpQCyug4YBzB8q5gM_7L-A3mhvAAB_ThKFZtHYmq-pSQkCOVC_7hvsCq_Zmyuw8-idPq0aPs3tCwKE3d_nGrLAJf2ypRWfHElZYAU7rD9eR_5DwaMSRSW86p37VaN5X3KX9HJ3dyb-qql8UWEhmcw9YGbkXoTMhQEgHpyuQVXl7e_jKFF-hoWFWfJv_eNv-N950z4oB5odFDW5K42XKTrxDa--2DaBgBySyCybi-LLDRzGrfTYRYCTWkNct-kKFdz_mtqwExzCFOjD-2vq1J7NsukbULUt-8xZSqsHqaltRyRhOMg5EF8v_XxfqjplUZ4mFyW9T2UTNCLSjL3F1rpmmqsr0gJAK1SBeOjc4sFu-BmXe7gfXLst4BYzuXDbDoaU3dkXsS0jTYiqyxk5O57vBCGJdmvgHF-pxIwyG6vPJqD_c4X0OVzbqqkqi08H4Yz7HRpgiyFeA6aSW06-n3a86_-3VrDOg9fwoj5vzORAJqBM8yXsdHgfbLVDf-yzVYGRn1AStysPbTKT25mkxJpNtsQq6A0chpyBCT6Wde857rtWduqc88cmk2iUH5LjCasrX9GIw9DyMAzhV7fcvTswwhpSzkubzP4KIE6AKEsj2-wE_mdvWCJzsJHUzAns-rvFwHZoKq28Dt7U_qIJ3zNv2r9kd1NSWwyBNo0Bj0LxUPgRbW28EbFScaA7NELvBAOYYoOiAblU7yVePd_3AZ49YbkQ_Gb5BxzWWmuQBJijgbDUdmtBnKttd2IjIj0oGiP1b6nX4mHWPAcxBz0bgktjRa3LZBHcCi7DKkZtr-tcSWIDh-eBYHozscn_erk6SiNNF_mpnEQKwEHoWk4od1L0k7IqlB9S5IXDAv7EPlQhgGapewMhxuPBHoK2q67UEo3uIO7PukXblETBgmvrMJ3jafq-vvbgZvz3IaSIZpSVctnzxOAL6noTdeeJeLRA_DUXQUwN7_gl16vl9mAIq-mEHWiEJ-zz52AtbgJ3SyZFwkm36Vyjs8Og3O4YCSnO4YKHggZchg-fBov144R_fQkrg2AhHh3EaPIe8REDaHu7DhgEWhXN8FpwQXk467EBU4m-E9HQ4qFJm6PWiHXPpVeIeAFkYdaR5KS5Ch2dx1ldQVg0m-yutlRrNalcaUTEHccEXkkFB3Un05yXoeAqAzphtv1zkPQlGj0iiOAIJxkpBh9OwzJKTaYCa6Pb27El8TE8jcNJe9zVvtstZCUApmO5XjFt6eDyPWcIjGO7J9bimYOvBn_dTIcFS0eRYrPpXUpzT05Ei6Ye1sS2o1dAGSajYtrjdrzEK2ZYCO1U8pcUtcK-RwCnVMhGXnq1X-aGryOYOAYXhH_sjIFRrvI2g50lx_75jmLm6L3osO55fSj0HZKscBzrv1nUSs1AaeqA-s1wRHrD7wgdJksYHmue7kHQDAA1VwbO_VpAshzI6IXKd07wQJVOObmFZp9DbTGvSyx23UWeF5sY13O-mvTusLNwQ59ARXGJ1QRvb4KyeXZxYRuU4I5pcsqYHIFKX6t4qaUSEWZXqUMbW0xaJtWW3wYFM140tLspk8L1jr4g-SwJ_OZSVtOh45a2EIiHjBDWK9tYGSOfLJx9fT2pNjctqQJBQotr1tzh4j4BrgNwrU07Qki21eixpl-YNz_C4gorilgym4Os16Q5mYvfvw-VEKTuPAsW9QsEfclv-qhz5rPhA04V7UQBt5AE7MCtpmqH8stjJIF1y2s1ZjkPClVj2MYp7gQ8yyg-GQJj9oha0a3F4QnD0t3Oby1eB1jFl228IH7AxRcylbc-mtg0YalNuWxqNqIzA6-VUdns8GZY8-ZuBz7DSrfBl_OTl9xgHwGo7D0o_gmo1PTk4qLZCWkfKmRoySmds87MyUy4SHDGLVEReeaScmTD6K79F4fliIWN3C_EuZ8Aouie0uDg0W-2PPnqG4HSXMuU1nSdNggdqu_M0DjvbvuqbZzdprJXHFv7SKM55RV4Za4XwwNEbjjYlFSj5NvaCEPjMTPrbiA3b6zxhFt7Ztv9FiX6eks108QbphsYu1zfzURd9tkZKRUETLjHEHVC5qdtV8AWfIjiz4TZxfjE7ppp0g9mZ5CJrY4xxJE6r1fuk2WmC-4QSBkvxqdqx281Yp8JU7Obf2itDaBaPbxsuf8IJ7BkG2pcXRc6kEWJEYuWnbz-GimPXuA343ike0JfmzTieHdb1Y7rQ-hSohcn_mgshRoX2nfOCJZHDo65c1DX9i9BMEvDt7QB9LyiUrYvBEoi285taepJlKu43wIwCSLw7h--1ign4Qu3lP9isnOFANppC78Ncmle-D6FxsLxMpHil0orPpkS6SupwGA-4cQjADOdyRCKVwpvcqDP3eZDFRGoYGAQxdIVgj96Cp2OxXUm3a3ctkBR-pULebRukS2wkUA4yedpXiSD535_BU8S_8A1CD_2XLWlxmBWWXUkVJ6ld8FT-Jj1UiM5kZzBDfuUwxRMb4HEgVVQMK7KMt1s76vviUurHG4Ti-N2E7z5guzwQSJWrcQQGHx5ke0ZMm_i7dbsgbDivS9__mSq8bn8KBuOcxwJcWl8rkfgG9xvJG_JuBQmYFrX_-a49TGtwjncuJa_QQ4eqPOxGF4BCwVkNQ7JVW-tuQlvPT4NBRUNqFZ49VLAVEYo2peTr7vDfa4OiYUczQrbaNg3zC6Rcwc0Bfvb6pP9gQyn3jhzbCXIz1IzuDbwkQPSLbfufaSN4KJKnnfTq1MBqfh6vkUa3emJcyKlKzX54-Bac4Ws0xnGOnYgVRMfOQfVfJJQXPkK6Kqv3jP0nUNXNULsg8AjEIF-SphLR7DIjIZXnAov19Q-HmQGQEhAfMuev83lxWXErRvq67d4D7jW3jG5J8Og4jeIHNWnFeYaphqjyOn25JvokTPKz5S0oBdXArMwfrFoKFr9-lKa3J8M-xUoKPa-gqL3D5vgMhBWhXX_XvZ7cyBCl_ucg568MwleEH_iy5odA3iDVhuetbgUm93hxl174IkUAiuWcf_GARJwTV1JaffztdQh2zdR0DgBHPt5lGS9Ad-OphCTx5iW_z-35HeUsp4BkNvAr7qh8R-BzgjNPJbat6FYPxEE6vkyg-6VvDdTBtMbgGSM_teEuE0biiqZQ8L8h5uQE40gVjjp7S0MKenJbWUaR6HBD8o92ByjSdTYl9NS2KxNjem8HUuBSDR66UNDK_MI5BXtQEOyq4Wj8IloPzn9eetvW7nf-caAkuS3b3k1VzGuH-Cq-IXlznaFh1rx7CBa1Ezh30P6juwxmPa8tEUxbQRyGJpv8_yT1lmkAyv89Fb7M22HpxItI5sZEerqbrMFLZ8WoYjPYoxwASRNYIhc63MhiQlRPL4lsYr0admioeBfyCxAo6YSyAiBcKSrL15BcNORzbY6yJ-X_XXx6QhbhUOWiLpeZQyhUOjjJLI8Kyt-mQYo--GG3WqmcpQEHUP6Q7cu2CAAAf0UwYeaXFb3Egu2CdL8MOE7Irj5Dzrpg5LlD67R5jj5pbsdBVBuNNaBWQVZpI3KVr-U8uOQaVvEWA9gKD96TAY_7R7aHJML28KcPlBL2ASnaMW0qdBy76eC-dv-VHfUWpUtEyU3u5aBbQ2kwIQCuhyxkV3qwAPR_Ee9_Emqtrh78244hMrlDGc9QnRhzHfuGyrcJR9FWQoC7fQwhJaJDfNq1ZbnYnDR-Pt2sqRydx4KAED34cIN453iAOvDTeFRR2lye4ZJR1p7s3U3A9yLbaupGn2nTKPiOpIuYcnlDQ85Z4Wa5RlPwSNveFMEZE-d4_8dnu8j98BaT_TbbBcx163zvO7JmWUF0jjbpDi6-lBJwnZJSsww3hsmeNqAZJee_zZUEbka5evwOmO6oLI8MGlzYHzdo5lqdRF-uXDuzQN54-6xo73YJJ1jDnJlK70wRl0L3tdb6O7PrhP7mb_Q0KDqV2kYk-jj_OdXDaK2plXE_kMnKYb92R_GEZnlOFFq5_xEci_7u_V5yalQgoh9Jnb2nP7xv0XJHjrP8cZYGvsYXpqoxJLD7u-dPjmZnB-J-CAz_m68ewEFxWP_AdYdLMUe1Vd7Vqf5mwg6DAloNpsAArtONwh8_VrXwSyFMwcBhwNOzHNQoSh-EOYpOUkoxxxagSvqUb64Bgow-GmJlJyTJhCy8sXXS1n8BIZ1GOvIz9TPatYmpA0XFaRiMm6oXSygqViyj3ShXKU3VWcD7yEPzBoC7X0lzGa_2dYozZigfGdkjO6DDFJfNPTPvHbH3JIp6DR8vjqI1TDQhtZMsC_wYtp7oGlb0mkIdzOZv9ho0AzKYBA2g-RYbLivPM9vMnM_xdJMTU5NeMs3EX1l1YWEcSKFczd1UEe72QH6-GREK0hGF3L1sQpQPkyP6Sru7ebKIo3AOT94mt0ud4cSylHnTn6S3WDxBWYLZpgwe180O2AnyWLBRsz72kZlyCIKbjIcrVmirA1AtBdVqBlrfso3AH2KdgwH0Vp-T4or1EqkHWjornwwOoJr5bKnmWkk9aondK3eyHxM2ZCGoM6dKfrP0vSrQr7-PNSrpH2ej3rQgLtyfBJaMjbnLxpDGYmVdzvQRIAx0xMtXZLPMRu03NZWi1FxDUzWm49oBtl8Uo-x2zBoBYmbUFvY7mjNDOHL9nDyKSGI9T0Zj_4jRcgwZ_wbShjtsZU_ZS-Dk_ZXu472AIbOEhB-7QcLtHYnv_cjBOHsqsb8C9dYcNc0Jtxy1OaL4HV-rai6tnEDSWLV4oHxD42RESrMSlld_6pZzucavbFKBPJw5zgM9tXW50KIzhSCo-pkRYVXh_86x3SNPH4glbnvxPSxO1yUxQFRPmk7mfHWZgRX4WTAh3GEGPN2ZXgavE-GsqZn2dx70hdjoj2N-66dHmGJhz4ZkxFP6XRHPCGzDTRiw-xr_Q5uC0Szx8uXjwuTCdPcRmjg9yHTR8C-xTP765Oo2BEMj6nktuPrXdJ2DmNaffuel5PfL4-zAePjH3V363SQI2wt0quPInkOz1QEDghG5NWp9vds0roehXpY6a24mhzgGM9IUCXuZg7yvN_XqQSiONXDgUW0GkatevH2h41hBUKqzt7kgM4KfnYO__ffNFO35MQhGhGvsn3CaVNGnE1VQnyRSBm1qQry6ePGlgJNl5lGlOIjaG3--IXI29_WOqZwAZ_sz5POqor-EDHOZb-e0W-v0xqayHVbIBwSQSAj6LQa2N6iAbn7WxOTCW2pRBAr12GxepdklE8XqzOGU18J3SBrMmXgj8YK3Qp75fUvaS9cRQ20-jaObrHyYw8LkAcDk3ikb8Rpl_QQBNgvEnETjj46bnJsTmGTo85HXDcOJFbxe1Pw9srckT-zmq1j5E4R1XUHi8uChKxgE9yxUFcIxJmKaymDszw8RHoNIzWlaNxYLbFU1ucY5tHxkoK1DDXnzG8DQW2Cd5iqX2Qd_H1BHJs6HxcxtPeYcbFFSenMq37LV0PONwVL3U4XKWiGtQalZNzkzPKTBG5fdXrnaWdtY5892y8oXWX0SHrpMhwhx5q4-v7JuhniCx1ZTFOtaBstD_j12PPeH4tKVOESasXsgvEX7Sd2Q7ikIuCvCibLg--8r3sN7IhvuI4r60us5ghfTM-B9r-FWfHfnL0atMFUwGEvQuqHffSLhTkL_UMdkq0ZLdjWh_f6aghkDNGbekGLUZx4CHp_GhpjSOEkni_9nTIUp9xZry5RD13Kcbf6y90B5S1lYLV22cOfQlPIXmLe1cA6rgiLDoALuPB_br_UuXnxN97udhskvGOrlaTDfRg1ii_WRYU2RhIjbs6DUyIpgUopY8XHWpTbhdi3J_WSCMI4uYZUDEXjQV3--Wlgg04RSp1lHdtNqOVHJmDMTq-wLl1U-AcfeM4SGP2fBOkchuYgtiBf17CTD8wQJat41h2BVD7m7obTOA6ZU2abXvRZuXwTL7Xy9-m3z3b-5o9C1SOJMpO2eObloC5559CscRWShuWfrvqQaJCZiSb5iY0kEai6NpwU8FgR6-nfSyRw-LqPtxDZnG1V2h407DTPzutJtb9JN-2euEgT4SEYG9jlXUjxue3iV7syx_ctDLvReLRqdC6wRJ_5MAuu2jpOtGJNL0SiHff526dirC5GQLNiKc8VwXh9eCDO7vDd-Bk946VoouU9SKnK_HLwXOi2EK29h4zBuwEK78OAVyub20aTCnS5Vhbl6u_x4R23tmrV8zSk-Dy3BN2ab21Q_vkhENhl7xDriWOT6z837kgqWS2wHCg2BggvBXcLV-KQF0mXgnP1ISX-r51LJcyA5r9GkRKMlqkQxSlrkjQgwWLrhpLF94gHcNOqxILwSzpV9EHxJ9JdcElFWP5u8Z24T8MrL-JKglELcu8_q1T8u1wOOT4qPvf5y98yDtwf1iisOxYkYR0uoTDIE8a8Ly0CYGO1AVjc8x4Mpei1v4oVnSvxsHes0CmzZe8y2l2ZGzYtKmfOyos4jGJeSzwnbIzZvUbvc9HDsWlw9WxpwsWuxnMx_ntSdO20YMmT63cBXmYcMU6x6iohHO14eTHjXPuxFVajrZpHVYqG3XhehpOKX_BytOwaXQLl_A4HbWKg80TWHWGpGAm-t1O9cIJVbvqOM3rTSRNiDYlkNwmIGsT3G2v7SaZ0xvXkVxf2ZuWtrt_0wqYWlWLRhycA7dVy2YhG2wMw3eiIwBMCO1Sj2FJMnnDJMGkt1KK-ZWS1l7rVlcC6GgGDxtJ0o_Gto5TcUBfSHnlJ_L0AQrBjydTc8BLNdMQGM2m9NQ3kLZ6ZaCXYCn3qpkHEurQuAJ1be5nxy7lHULk-uaWypz5ciPAZNgkiNX7R__zJWIVvTvU5kyk2v6vk0PTDiSWg7G6LopR1vP5LM5R8i1SL4UShmQbxVCB82RKA0Setd2t2gLdwkrzeJDYrP4KgGMmY1K04USv6W0iUGKbR6juzXeY8Ylrv93hXNZ6VyqOPZ_yTJX25JadkPVZ_zniBsG9LE-4s0G9zqT42PJru5IW8-tBivp9wxhjGuBqSjywhBtPdfgW6q59G94YfQyG6db2k4Cw3Q77KaTpW-320BH7Y7lRyAnIoC53lP7Nl0BxfZu9ocsVx72asV4QBKfbHURLnRP0JZj1L8jAJw2cRXdI2njs3XONc3iBhcG_XRtJv3Ai4JzmuuLK-nZlHOUGppCjwe9vbtyYSxeql3ggiv6f-SnORJy-jz69agQFg6TU_f9GC15FKfqwYepmDsRThKLCtu5HM5vk8XHyaOjbLjmz1mJbQKPA_hyoVezi8xrb0E3Di8ic-TgR2UxnP5iRRAiAs8MTIIGiLPbUHUFR9KThw1umcFOswM-9Tzal-dV6E7qXhQSJu7TwdSodedMTSUn0mg1CMSj9CzY3Kg37_fctVO8NACNDl_qR03Omfl_jMT8oOIgPmTtHCrT4DSgGMGVKG596hAxixzr4CxxSRMVVen5JifD4cm5o3bupxsG2ylJJ7-19EPMadeURQqHgad5ACpdXQNEYbj7QM1WomESSWpgmZ1yAVhoiOThtxKBI3VRjc1mpVMrmAAVZp3cBs_Yy4ss5CRn-1U8jZhY9uU9XJxiBre_nOE373ka4zLoLnl-iKqnqCz8SKqAzAUqIT67psILSUwZT7roK7Q47hA1DBOknPsfDPOBtxH2J5BuuyP1flWW51JZ5GHlSg0DvnngzWj0BRSL6MgU6QKxzF_oiad8kFZaM-h3dRqooW7VhaYF7HHFFl1X7FNj5-LBfp0YqF-R5-2pFk8PDXktr9bUcr8YuW2IJy28dIFIkME0DdatV2tos54y-irRJM16UPR0JyZ9-3CfzuQ5idXf4C1bckBTJE-VSinefpH9mhCo7_Qq4Zy0gwPomIdnszXR46ZutqMrt6s0LVcU_-WZMi0bMsJPvmYCO8dAanjhuNMRvReRSxr5TjvKJK1kkRCqKLDaGfDsaZYIg3AQjv1pILW0zgGWsHCBROVYNa16g6aF-29qEQV_dwwN5pu5jRqHCGf-k-po1o0fOXDgcR59MQpRYv_YNU0yI8f1OG9CirreYc3wANICkl748_yTXgRxpfqIurKvArRGhBaXQlv0yh1L-Y5xCDh3wkhgmMITH_Yf2mLgY8-E1N23r00afxe_NB0tJZkKgTww0VVLwnUM6otb9PR4c8-6-Y9oXZhdyn4a116rwk-94TfbmE73rSmZHJVhWT3T86YTHd8lUpxQfAt7kl-RpXo9yV2wDmu7mSESUH6TQlnWnMuJWs0AgxwMmshXV-TPkqrLIrT9YLfgj2fhzGVoPt3a64-6GDEnbQGhYFKB_zLA-bL2BMK1QbsHR-YGvDg4eTwv02u7zCG6EyabVmwbbOYZ7dZXHGg4c-QFOBefHRLXDPnorxtsfgN5Cd7_NwhjfUDu5I1J1JRRUQHcSsRBCuzSvIBRjERv6jWyqZaHpfXNJDOsVQX7dus0mCO4g9i1ze2uewgOBBBlaFQzne89-eoHcAG2KFPiL_Rxg98VpiRGpAHKR80g4av0mlNZ6pgLneD2tPQJlCsKYo18dq6kmyCQS4bKDqtQk3pj4K0bjMT3geGobjoS7gC8WS-yqt5h_aQhUbWnLaLxNyqAhcE_Pdk3HzypUcjUoIRHwC6QhX6fn-HN6qis6rBUABRvONE4dRieDxwGL8FZgx5RKkXKW1jnfMtDPH4743prsEuvZ5A_YjLn464rHnzulguhqq2QEZKPkZSOsCB0K1n3fYkDH9tRLc4ko7Omk0-9BL2CEWdsS7w6OQdGkpPcH5ZRwqti0VMCLPDSN74Tv0ug5V7CNqAzP11ZwXCOpN1QYUeWssLp--XYHHKthgJTDNh2laeRKw7a8qykdmmnX-47CFyhxuHvghFc7I-gMsEAajJSixAfNIexGfSb5hX2AgZMq-HqbwEeEcKOTgCGrQKlMW5tY1thGqVEu_DVCD58aDrRhNqVFl6L7unzn4Y8cVYpApa0kblj2eGbxQLRm6ClhF_iM69paEZfeOO-45mM0Fc2xMkgxTJ6xjMzP5olNB8G_wstcIfVjzmOrTKlurOuqZtB87Mpni9xFqU5dDuApVDokHeOK7U28EXD3-mWrXUjnS7DYvGCSyzaZfk1mdtyQirdxAZ9IkKQ6I4iSQxCjwPw2u1rf8-0xc5COdjLCu-oOkfcLyd2bRZzv7s6AI7dwPu4JUQwKbYILu3YbxZVVIgg-IBFIVj95QtqUzxP9ZaSzK7SnyDL68i125OgOzFMkSlxD3ACY2jq8ZVdDu3lKx6B5CkV5pcgv4YvbVt5mJFAjePecI2q5KtsTMpgQsHxIvsHEEgBwF7DYUjW6AJxeHEzrkHq4ko_73Nknwm4fsy7S38MK8NDuIK7RqBDirWlcx_NmE9ZBVbYV6u5dOamcsNNKZWcZi4-IqUx-cNob1I6Beydq8oKgRT8dAqIEjUTk6HHFnQBnLVlFNfldFiLD-7XTnKeT424R4hK1-seCGiXLBaTtR1kLddb7m2nojXgIFhDR2EHjlQjQsvIkwkhPPyKKoe9k-yzykFa5Edlj4l7XrAE2Pp7Sa-B2K7G5VI9Pg1_CPXSouzl-J7IPQW-32m-FzoFTWl0tqohYbPwaSOUsvkgwH60oXybJFKd7qhrrlFsgf7JuP1q0dI8UOMHHlI0aSI4T5c7wULPkoGUPxS8quPuR39LQlkJyE-rkaRRFS7oAi6PFSY5X7HGKJJByCq8kMwdaHkaGhgui-M7Pq5PE7vSX14v3MZcip-RYNDeq5BAqUDlO9x8867IFGtLM5Qlax3AmPXNvrPtn3-mB5r5-w8ZCF5qxtlfE6PrFjzuH00jal4jMbJ6E3LhjY9CZRPZUOg8R0OZO6b39Zwoa_xsCexY-BBmLQ3Ycx7Ex1crM1E_W7ZyVVLWyITlmIu1sV-t5zzFeHFUru2MgvmMTEJtHvjPDCFM-fvyTCAogihoh1N2TxwIjvPH6GmPXRQt7g6V2F5VMes9cPxcpqEOo1z2viC5kG36QCqbgWNEL1f8tZIOU-WFlUncXjg_5js-mNB5QuCyVF92pSh2wsaPYal6n_hj5paN2pf2JzKIna1S0gjiOcENwNGj6WEXLfAfYsx1wGQi7xEeGF3LRTDOYbMzOlvQTxx-u8S3d1ua2Vybn0HF3VydBRZIiJjAFOx17zp1ss65fSe0JPEUewwsdL0j7uFqSYARTZCEPKzWLfQuu7Fc72fnD4hy_G4Fgr9xDzhWiTGBHJGqji5IUIKmm6oewOVlbaGAnEkir0B8CFC_4bFywOBqh4gb83X3t2mMoI0z_oNrHC_DDYJfMVL6PNIXYaKEPOW-T64X3676ReJAXQA9J9HDLF-Xlx_WoFBHBQY82R2mEm1K7L-CHtKvwY-rjZgIMSiFdlkak0y_hPACF2N51KfqlUpUkA4GTnBI0i0JsDIdXDt6dp_k3Ltt-ky0zpg983isUdFDGwQQ-jkI6SGC9Bk5ggKr7uH1cz1xaRX5UU6DtuCwH9Ou92U2Ds4hrxZaEC_YTGqqNlV8hapqtuABqJXDOwX0EKBOWsAlyXPC94483VjJY2PYs6Q6ZBxunWKsA8psMsUppIo_PYYJ7rNB0FHYb2H7EOyhHwajBma9dorNGZNsT068T9G-jhF-MsGhS37TZNFVhfdkK6pKNhwKw553xINDAL3JcsL04Gr0hiin5oMOHVQRLLgyVLUpq0O-9QB8pi6oWvikkvgCICbhB3YN3c1Qr7kI4TPxSNR7A42vqVZxp_DqNGpJ-AuSWy2raHXfhazFngCq0iBB18Zv1wDC_1rOONqfKU9N5RIPmP7jsCQfOn8G4-hdRZVY1lDNRL4Etxxh78YH6FinfhRCKAYu7-1c-HudI4U5ecFJUsB5ASc6iFycSDDAKcHCK0Xbj9ddFsTr5SAWLfNe7Bs9ogu5rSnn0ndQk3F5XIEhDxYA2a5rSxjj1Tx8z27J8KTAX59F98JENuxhDWYp5xnJ7v_My-F1DO92x1PUCAgJUigFg4490xt78cv_L0bIc4Afc5GHbyH5hXbdS6zmdSVTBKU00JuFdqqSF1Qaiu2Pi9OwPKNApDsuIp5Eafg5manRoB-Ow3Op6BFEMGaOkOILYV1bjF93-HWDq-md5bAP6_SZPkd3FgYYWeAeGheQ1t8ZpezAIQqD_LTJBZBIeG2T3hYF6G3i8h2XG7cr9UFHoHYRx1QbbSQ6QeK3TobClk2_ngcLDU6VCjXRvX7M6-xqY162KIDdqcTn1fO_xX0yWQcaA3CQiL49cKM3OCb1RpFgbbsF6VyeVm44UdskkPaGfjU-5kuJnVsOOV3XErXnt7vQORzeo5qqAMdujU-e6oeDAR1JJPjD50W5_Ya_-ZOT-Sfo5MfTe2OziUQuQmNIwPGixDmuwp1HPkxlzpborlMH-_3Y5xt3dHTGSKlYtulQTcfDmA-WUDavLjRQd5I0WHAZhM86s6Vmoo0_9RtweLy-VK59r6kB5j79iLp5Ki8_MYDgjQk-ipLu_9M1z65LAJ8SdK2LQRnWHlRSHHfaFyHpWmmjaZuA9aBnDa9VK_r7EBXK0Q6ssaHF-nPw0whU21a_KNPND4jzHgZahhb1FCGzk7gozlLgQuJbh18nAXfAwqXvia2RsUiPhNKK8r-Os7pVaS93bzalIczUgQ65V8pZK20laDrVFlZssmF8t6hF1CZZdybdK4XYJiQZ35CsXMKeWs_4s5IRgx4tmahjUJ4ElTC43HgbOuCEHfluRp7f7YFahzX48I1KqxiN6PXYFWU-WBV8I3t5qmSsk_WLAu5zzcTJ3Bg_G2cK2TcxysmwoR9imBufSJHVr7m9Qn-J0uYWRe-_0Gg2ZGjOistBCueuPpsAxIND3pALDa2xmCivLhw5hIkC5AolW9s5hquv9z03WfFUN0AFV0oaj5YDZKRsLJ8424JqkviZGtgoaw1-B7yEli-6fqq2PYj_jtBboiXTgIBk2Cr-edeKQrCIYOGCn3Hg8qR_WFEYJOiCzxLq-QTQCuUWarGqrXyLoUA16H9o_w-oSMT3yawQ8BtVGv23skj7P1zaM4Wy_JOeQqnUs4lf5NlnIxUW8leaJjOh3k2Q8gkg-DXzl9O3mXcR44eeaiJfI6wAWRsO-zEAfj84k9Ymi6NwYdRsxkXmnwhdcYGBl6zen1vHASg46Av7azxu1bTI23sgH4omBdmyyG8mpBUcC_XFSKi92r99cWgmSqz9UaMFZjbCTSHIwgPv7qFKZ8f-CjzgawQRZWHALg0h_os_TnRHnZiIpcnJCF6IK8pFUvWpWONkDj4S_4vZAbQr22khJYlQLzKqOgayj_6AlNYKKYGjY7JNANIYZWDNYkLK2fYfs_b5-wO6DzYS3bGcuDsztgicGmyICjOLJpyBVmbwhYkuuXF6fkk1A0uI3-Fh1sURBo6Q9X-MKfVYdPfvMotm9ey3u8wWvNbhCzybUfbZXS-undr0NgRNZAto6FdK_sWoyNCfTIf3Y8GWTidoWBWAnE2aa4SpqletH2u_vcb_ds6hT_bLL9c8Nf9bvDFS8NVUs06zM2nMJzfZFn5IjB_ybIJODDvcqNkwtXOrWXkcvEEJ-fzTpHPXpYBzrk86OdMyHn_B2D-FA96Ge9UeyzmWxxFepWmyXheTYel9aEEKyqbhKCaeAS15IzuAIHv1LTeNZpSbgoJyphtY0BPo2YUfNvd0QVGBcLssKf8y_-IZvVI8xrQvwhpEOh1Zowmn3OL2l_i6Hf5DURFKSF7JM5rkJc3UTN7wKAj6hCS1d5woZMJAc7GTzZvfrNs72K4Hujcnhy0n9YQ20SVYzITmHX0ko1amCj9HMuHjG8oBk56NnTIbIyuAdffLGaK_zsL8TmsKTFzhQeuKyGs1Bis7LLKseJdQ1cYls2MkHo5Tcwa1_LazaVS43JDP4K2e9dLYwYOQ8M7hIYays-CGJ9sKjgVsNesgXSKXBsMfWStNoZ-X6BDl9gJnadSBPXoD8Xn4YdHezB44_-zTUGH687Gatj0vipiZ_jSH7nX1Z5yPZOvKA42QgMEi6NGk3wxoKblmtmLmJOOCm6lVMmiEa-_2r0kZT_EXfmP045Cs4p2rdopYtPcLoXH4WXctYgpEP21RMjAexNgLOfhnk08TP4u-fW0HX-I6Y4GqtBTWQRRLHJntFOiww_nKdOVktXYJtlPSZEyj07QlwC9MhsRZsRvAB0wFlYlYosjF1jUtqGXQTajcf4npeEIIBSq0eA-HKHqNjAEyFwcS8Ji7YZfttP56JtLlFMhyZ5x9-hnd_iLZKhEr7894osK8mhUTd2tvjFVShLq2SI8GcInlNIO8H4NwXEyOSNLcMNcPEP_EoTsy9m3TM5E90bkIcRCisyfCZIwNZYzwsR4NKJBK2pTr-2TkVVMRXD5Uht2LWA28-8XA_IcUH84--wIM-tzQkPYaLS4fN-EZ_4k0BTYm1_D599DFEnXMiMA5m0efByTPnVjaSJsJp_FNJRxCtNfAdhM2AMsjpkprIIn2rLcwpWwJ_gF0dE1CEa23rgsB9Dr1C7P0IixNdiJX-zmvagxh0sLxIjhpDHqeD7sFD5PZsfULJv0p76jMnUu6dJQ2AcJP9H_Q-6ZHx8c0zUKGKJ3LnWtt3kQpJtXxga6IyE2_jVQoHSMsZZWv8GNfNYk_G5KmKwbMc8IUwyT1qhWDJqgeWbEfKQgZeR0KxCcOx_8t6SMrt5gMN4F18HW6Vrvups6ga2mySx53Ytl08RnRHwqsEpuqdxKE-kJD-XFvdGqlX3L82nE9f45srZ8PdszT8sP993ZPlMAN6wedQoFHPKH0HtmHrpLPUHbUr72QlJe6GyW6kQTxc5ntG2G5UdvqDhAp5VCfg-oIa_tTJ14N2XSvgjclwb8i_ssEE6GMfYV3__0BpsxSsF4VZhJLwQWLMKdovB8aYzRyzC4RmohAA_x6fGUo1utJCSW__3MLoVaLoUbxlb7iW3OnvbnRBZTPB7v-c1ulEEgm5B8Hfxg4UkFPz-WLZn5Q3auVNY4CkP5AQNJQvH6CW25c4ktJyvedMWb-K7Dt2WVh52hjKdoZszu0MrN2qL2AXTT3gBrW8Q7N1Pj5agwU2kBFcuAtdQ5Yxe20zm03LnEX45DEHUEeopu3ko3T-j9kHBglNG5Qj-NlUGoHHoLYWzQ7_Sd8s7xbsQwly01q1Gc0xg358DaCsvUlb20bEbQAR1jUbsaogv36oUnBCpOuYbyoIoVbdntegRdX_OTMxNwEWMXNvkQvo_YZ0iz8aP_W1W0dPdy8H8KETbtqWvkXAswqGW2rF-ArfPgxTxOb6TXEoXvICOgT-OP5RkqKct2_UfQ7jmdug9ELCZO47-0giMMi3B5FpsgDmf7k188-9d3g2ZdOqNgaw56o979iwsjz3l_XF9vRUxTmTRShgFd9TiUngAKcrPcLltm6cb6HS9htCrSD3-LhkzXK7G4_Yb5ELsSCt5RZkPYOemRQQofL9L99jOcXhp6ekpbbpptp6cEncg92oBT_fbfELhUN3YhFyvfliRMSOwAHI9fhCjt2yN7tv5zhT7T9Qil_Wz4JYxz6uq_D24dZ0oH-PMmI-RoG5QCzeqvFkSHLM2wTz0ZOsMElucRyfBJ1P0cH5fuAwsVd8YeMsVuzj_Lm6eM_9iN5rYMCoKne4hzryFzyB34qIQfhK26Zkil1HLawes0vW14ug4LW1NLrrjsIq0qZ7D9NaFlD3O8F23KPP0CbUcRqfe8D_ztMqJYuYXSY0_BxStbxzHG6j5Mc9Evtn6EkelcFFOE0Dkmk0JKKgUxZmM68ELf0-kue7c21DuY2zrw6E1MDucbI86acqNgwnGJomx0VPlUsSbWMKpJZnz10axzgIzkcpWty189TUsXxSCgJrA4uzyKH57mb9VpX3eBT7LylNueYneup2I-W2xAzEAsnHdmWLVOmVg_EQGB4uAIGQH9l6Jft7zzBqtb568vKtMWF0-ibOjtwY8tsEf-UMA8bjEq5bluVHQy6Hbmb4vOby2iHTcWF8NM39oVwCxuoouHlBZHbDoT-rxO2lYwqdUzvo7-NWpQewAsPGLJZkGPYWbhGBLNWud0iYcWDIuzf_aMM1PoJ_7O0c3s47uSjXq8d4c8DafndxZP46kfFvSMYYqd1XAYBPv7Ly2Avup-6uKplpPxdGcdxYusPYUbJNNyTKgmnC3yWjHJWp66f7wu3gPjKQrQVvi67d9595GWPmWCUkK_yuLYPp8a3SMD-4r7NNDfLeT_NJpWcowti4O8KTto-3Wk2aZlJKVJc-vnruKsdFzi9L7MIPgTeMbKiHJegOonGNzlHkSGF5Tbo9_RigJalnHPWRIdoCcmOR9UIuBwVk-3ZePn_DEGv8VIYb5OZU1HQR-PUAi-LvJdP_JwnXgjZXDI9OAzg53pDeHBEMYHDlEkkHarKWei-ydJG6_XBYP0zZEOqXpNFYgwPk0wUo_caIc9T2fzxNqRMKIO6f4HqOW_NKbuPZkWRns7FPMBeKUoV3j6xgMB2urGE8n471OvtMxLhQ6OG50dhGF8IHnsyLvMDuswIKwf_MMa22QxHY0SusA277WrkG9BTY2vdpA26nyRumsIcgr-fwWeZsEbhMFUpvkoAmKxY8FXJfvD7hjqAyXEwcOERqqGCzd5iloTSq7MOfH_NTyEtQ_hTXlH-ToX_BHxDcYltYJ_Bkg49KOy8PdOfM3xm9QH180a8egZ2XYmtpEhZayhCiFUKWXFbO3i5TkmNOsDVZh0VTbHOwF1YD8TOon6RKgjZmrPamCCx2mljKqmBauK0O2Yzsq9sBm1-ysDEkcmEh1hN2pG4Pv-fxmA4sVXIH4OeIO9YefeBuVJcdbIDgIJknUUPYFM-inLGfK70aEp7dDca_V_DPLt3TEjB8QbVsOtVm4sR_0WVw2O4P0kyC62MKw56Z1sqoGgST7UVR9TFGUAImXcfPU4sObvbdf9uuxIfz4jcdryOMsLu9NcLixZPV6D2j5umutlWTfzrTqdVVrSWMhWXP8EdIPZjJdVJk71IOjz20ceRrq-_xVOxxoUZW_sYjtheMAI23CW7p3wHw_a5nbzOt1RVasmhDSdy-rsfmQMlYSThow0i8COD6vlrtGSDrlumNMoRSyO1eqSR-mIl259vkVqI3kqee3SSAJCDIlr2DJtW29RNqqEyihsP_tsrcDlqaNb2JvRmsHOmeV1TVg2JdQJjP1vLzc_zrbtZ-wPGGE4DMPJZTW5w0pG8p8pUgdl2XDG3--kLuQ6RK0H6GFfb4p0apK55hLqo7xtYYYMWQnIy7R6D8_J--QUdhSXMN84CbI2eHFoJE8tacMK229aqqBrnSxRnmymxrBRR6UBzu5De1aPIABFZUimgqp3rmBFyes92N7WP3PiSu3e-xTeyRn6MEnPETZnp-3HAwF3FqpSUcPU9wzdoT8QQu51QRnIr0W0lw2Ym2Pi-TB7ygUDcprjtUmRWysTS2PedRNj0YQOwt5hf4TMxcWkk-LHNPnmuzRv4nKMBsJ-3KjDXFDKFEMKvAUpQHJQnPF18CZN-F6bx4-IZmWU4F9xR1QSQm9hsbdI_psMay5EtKvTdVU4FU0-i4RNW82Ql4w3ncwG7M6IEw5gkFFjZWT7fCaUV6gfPIE2AlqZD8r5-EYjQCeR2Q9IX7x7Pr8muPBdewe-2474nxhrQ43BDF4xxOhOFy-XZsMiO0eXwPiOfMpOjiz4HsnNJs1FJougT5m9vcTw7Mi3Q5vdMCFwpZs-r9ONly34bOfaZgT54a7DI5FSVwRBHQUs4RhPZazVWv0wn2Lxq82bLtK9DS_V0AaYC9iPqnOC5YmwA_yTZcym9axk9ztskEoSieNfnhKKDUgSorTt9ahJpazTI0Ro38FeT6DtLzoU3cOkcK4F85_QYkpplcaxayWDm8f1386bMQ962tXGZKmOSIiXxojRTV6v9EgeELzAXNhLJ_z5UqHEViOusxlSMjGxgJQ3T5EHEOrgfIdr-rsSE7yOKgvA8Pvrp-QrtYN9i8tq4jLGxpPZ9Juga4S3T3E-EYvc9-BPUC6mu_1QvGC3LgYyyJ4_9WHez_BAidV9rBkDNhUTFRS21qcPH6GNBX-xNV_orITgdUd5kHhq4gZWk-MNkNJXqmhs5oOPDjLnsKnwUIX_CpAabmiBKTVS89GfmBchF8eQLbYRtdm_tWz-3iJsEhg7QgtkcTdOFJedwQVorIufG05yDkN2IUYE0Q9qwTBYaan7HDpefYZy_4oQGLx3zyfDYC07lrG9yS2c3Dp0mAHIhnhY_hCrU0U4X7elZ5ypNA7GLy6dKYOaBqqiqUpjas4ijoJROwe_Sk9L4l5buUorRE4Bmmnln3LjJosqopWPesDQ8-PGXz0nucdgjjFDGVWywGSGj5J6HZolyQ_YyrDr79DSsYPUkT0XvoxiVFVziGzpAExal2alwEBKfydA5E0ZO4Ex-B1RDnye1zhsDnD3dxI7B9rM4xP700odBiT_djib2-LNO_yX-_G6TNB7jPXhzWl58OX_MzbiDoiQJvyiGTUBo9r4T6fpBam3AJKL--OgRePI9tAIeJhbWlCiK-T1PzpJC5yVn3qmzyb7MMUGdBmwoELgdTIaI90cAiYOulKAkaYrTh6zDoDVuCXk33TdG4qhYhWF_T4_hh00zkDnvN5C_8VwQlWWouhpHJqvdXOHuurV7_Vti2nYhyHWf78LHVbQdqR3NNRKwHg4avdRnHuOOnfRteicbnc3MFH2F6zQeHAXUths4iunp6QzDw38scnO7VIpO2Emm5Iya0s86AA6K0WiLfM3opZGHH9iWFzbChZG77KS6hnowLrVnskCQUhnVFgYMr77WaKDnAhWpoR_atAM6aAw1HFMTqcpifeYEt-SxYkddIBRPZtQwnYS4Ia8QhQg3z-BNK4x--BKnq6NfPUEtafpDLBXer5jB_YJ0nhHReSOubTnxV565hrITId2dv-amBGrywgp8fxG9K33YYJZTykeEH46KZcCt2Ott3kf0KT8_UEtVlwwtTdnHRUlh3Ip31BBOXHLanatv18EWX-nMhsAip_YwWSvEwt9L4duFvNOhgXvsiJ11qOmYSEVBJo10wTHWOHNZzRt_r7PDKK1ktxs7Q2j-y4-jyaK1S7urHp7sG50T1IdhnqE2UrspC41T2MFtIaG-3C5Lz1uAfPbqDQJVk0ojra-nLT47LOvVTrUpOtdC5ibuE3DoGBEhdnNqUP6OW02QlYz7QEIr8L0OCjfSXseJQTUts4gpf26zHuDf4Mo6LgAk5Qba3a8VNW8Ki2k_zXZRBIgD2VQoXeHa4uyat04B0HF1j3tMq_2YNSlvL_8xCl64gEcii8sXvuvw1lohfw0slLbAjEweTYd2j_02jic5e7Xd6OYBw6EeHJBlvWA57yW4SpxSD2-urXSjaG_KtsKG21LOvuiwEFWqjK2IERyyB9jIz0vis92ph_iZrJsuj5JyFq8vO91eXUT5o1fjH0qhOdsxHxwi8vuyE2ug8LTBMHEXRspMQnJrMFG5L80w9yYSJJ_MGIh-sg9fDrig1qgvI9wujwb-gWDLThas0HxjFGU0Hti2S64gdVdRD6DsWqjnqNsR-Ci6inq5vrmzMorhf_oJn5yM6UC2eRJ3ed7Pw8N-p_yZikX5JXwJj_2W2EgotkW9GeDlhyPcl3-arqlBiqNtak6eTlstYjElSpkpVC6VvfOcN-N-6ZNHXsPsR8XOdprrgDwwMu7XchIutyPcgcuwMzseDJhrDDEAqpO1Zo8L9QlDsRUgxBCsFGfsonjyHEhSClhpnFZfjgLvDHRA6K1yRP74AGArltRvIOVIlQn3ch4Gbl2hh3JbeleYJxLYTIA-WNUcJ1hxkeKt3u_AbUqlrHtUFF1UyMe_xsbPS4Thpd_b_Xn6oZPXqlrIMjkDRU1jIzV2DorLLFuFZwsfdwGeKYLPjPKRJlziNSc07lgGmMfv_mkNNKWC4M_KG-OOompCFbEJ1u2J9xVw66wunZTlZdlfxvGm2z4AXFYilA8XmVoGDwAyFmDt2p_SP_ddz6xmZB9MPeYo-CAdon2MDcxUiA0qSj123M8UQWJacUTUxl-ZH37m9AvaziOvuCCUU0ZqXfMfGyJtnL4xNpKxSTg-dmsQLVkok4_zZGw0lu-V1DmrBlzb2k2hEKglhKNn6TSNZ-0izrPV2KnToOZ6Id6EpCNJigptwLE90yBel0tH-UP-MSnc4eokmse8t13uC9rA7kRaBXrdHeRQvorOoHalzvi9OoIxpeUc_84sdYufF2rDy7S0V5Sb9Azpz4gbbYovBjDMohDhsiRbduuG2FoBx6Bvu-opzZAL817GO6hhexZaxEaEJEnJGRGIGGAtzv1rOK2EQSwUfmwRX5dAiEUVLrcZLtXRNrJeMtFSbOfwLbkGFv1T4W5sfw6BHC-176rvPq1hQc3xefkGEWf_weH300mcP0UK4z9AchfwWAPoxbR5HIs2X0kg9yoLMZ3BWlrbUwTDWbNwHoNXKJ9_qmp-NDZhQ2drLaBxlY3zhfOcH-3VkIPG2CWXsQsAsCJVPYh09M7hfuPOA4s0QrExQZiRy2vh_nuE3N0uMYI3m3TcYTm09gXEx6Uyyn7fW431Jb5af6lH6OeTrvFRdfM6IF50ZBrwEpXw1A9XcLwblGL_bv8ex7rhAJitWl88GmG3vl724H2SvduceAFbqN5tbsEDIB7TisqJDO3LdBsjDKCIuLWPuyQ1OSRwDE8qpkTfKKZTVrTtfaL3iEkImHCeilo9Xnk0zuvHIpItoXbVLTFq4TWcd-bZOQs9SFjP0XVBOaGuUw6GRnQqyaZRyKyuji6gdqIwzXJLwY_68cibFx-a0vlKBl9IqFYJe1O_Bi-n8YYswF7DP-eRr_B_lqim8uxvBy1P2qY5jBiX-bM4o9443WV7iA2tnoPogzBo8LXCVzU0IUC0YDHgGmqSo9YpT9dVEnzYjmctkT7O_K2QCm8-MT333IQLtR9znDHfOVoyjLvwMXVvM3TfTiStwDu0TC8YVgN0-hjjGns5cr61mSZygG4mtlSgS4KuvmbnbAOEfFDsBggkMzod9jEkKaCV935osWgVcaTvJ8CS595sWwkJIun_v48mp_vfhPuTu914XjYULhG2E2Z4UoO8InKmShYtDeq1bEocIGLXVlwvKW79orapc3urPYMsBfj2TSYvXTqDaWS3fwdDyNbLi7jhWh-h-T-hlHVqemN_JQrU0CX-9-HFKqcHTbmtew1Ya5fcFqvrrR_cW3Hdc4Q3aDV8dF0jzJnJlCP8GFMu_H-HbcNIpGlPZNF-tFFDTf6_uc7tYQU-8uCYaxaAb5H2rVuZn3hoflLxpDE2gE6DliN9NsGtkAn4LopmyBbYATRgHMLpy-Upd_l9eQI1XomixPT5KM99NeCAas2c5t-Q99l2MchCEkr6CoTVMxTcqccZn-Qu717gMHO1mgbtA_Fsjfg2er-hywY957NxmhQUcGzoEu7bYasLfqsj9414QOaLNqDQDO9u-RRcEOXCqgRScV0rilWDXqj31bSDb2M8VaiLBB63-mQSvN4W-l5UXsnby81_qyrv2nrREno6QRM7wB4dNt4PwpBmyBd3dCLgTb5FvhMmmk8rlH2cdepRDdD5vk8W6Wn5pXtbcFxadoUba3MeEMBZhoiZxgVG6a4eLA39E_tklGLHyAkreMlBQlfdyBJ8r8zqT8DEXrydqFVmYM8Dtju2jYRmZzb-P0hyhlx5PVkep78u4wUqGuqA5Ne7Lv7HLj7xI3XthGRvNN9sNwAJH2D08QKcDlSlIQfDqZe-2e_kgjg6Nh-Phj6p7kXuuWUs1X6vfEs6fY-3HJBu-bMa7_lP1UB0AW-deCRbBUeWmEIYphZM9K79pK-VTy4Vovx5hnmhpVtg_xr9pZwLnVmPuQO8iVzcaKNTuB0-zUfo-EYImbVJ7-plVYH1MOvmNu8-4IGoPI9AeuKfFIxSwGVsqQhAxGEhdLR49f4_d2iMA7zfx6W8_OuN07l1WtUL-4C34JCcplBocBNsUCuxpdpBRt28b4qs_MyodOFR-D2wbhOc7WOv8-rLOD-g18tOz2KnfWCIeunYURU83g2bwIVvabQewh-kINu74CZsQlNjibR-FyCNbZHY7X8mnfZ4ISVkrU-KAgsd2Vc4wl4ty9uQ8AG7atKRlpqJjbk3rPjGuJ-5cjtfjsSA8ttuiLuyiPK4DWO_zACvggrzHsODCZhaLkUI7joWzv-6bqQK0-9ffMzh0GV4fY5xKNhUlP4cKCPGpEQJlkg6AduoXzNq8st0mmqsGoDcX3cEY5P2saRBSRXptE85ZIRAvsaDLRsQHnhiAzy-QvVficHAIy2QtKya_OlH8rUNJhlhIVWvf9pE1nRVSW63U-mSaMKyHruuExLykl_zJTqwHPT5oPDrOl2mIwKbyu1Kwd5_vaEpfKkhqistpHazUWjA8OZzGbcwYly83kOvl_tdUcIZ2op1FOESI6zurezQp9-FiRU3GWJHgrHA0O2R3_l6Zp8kGf6MMPOoAeMnYZt8YX4YmWT-c4gFRofskbkoBAnrHIYLW07Z7cE5vnoMiUce4YQX33hNOZYxgJGovpdsRXDIXQiRCRTIR_vpcp30z0dHLhktdtvkvl2lFzD2WMMHSL_XRy0_ryeb9LV_ztv63-AKUOqa87viAMpMHiGeQAcIk_sx59S7iLY1CPZYraecQfixOTg8N7XAiOMGQTqYP-qj9PGoxEa_9aGWr5DMB8zIEx9o5S8Ygiq9_28P0A93m7SqGIInqOI6UvLgRa0-8NA7Ar9ZHercWUx20w8_QO4NUetUhoxI6FLp1cswnV_n3jx0r8vZZdLeh4-2TXyBqTDInRH2PQAEUfE8v9GKKWQT8UPWD4iZ_zU5XhIcb1G1J7yJrirse7vQmWO9Oec-Ss_seVFFsaMCL-22AU_vbh4rOZkbj2lm5HCO9rnJtMRdn8nuSEcO-2qZT-q3kqQuZTW2RLyS_te6HgeqqST4jovrAEzekdF3mijzahejIj1JHPit2m6d6wKmOQ_aqIqF8bMAbifs4lf2-tbwsF_-x_gLpdWEpO_nV_t0RyJwwWI0_MN0YtTCfp9wo1aWB-DkblRHe9GEasVn1QcF4-cjXY8widriMcMu9JT9UzCYyzrPTEy_kCERd0Uj80N3jhWWE9F6FpkZuQ2qAkZChkBdKFQKbu5jnAWk5afo5eQBjcAzg4TQhTsPK20Ek-3KfY8k2Deu5KcTw25cmmxP9me4r5sY2OLCAzZ-lPTL0U3gq45d9eSL_52RicZ_NRQbXn2QefhQ-mSqM-diFbFbbk1ehq4pnlupHWlccINKDVpXW6mZCAV-subcrNRvLGzXjV3S5wZ0g6b87c_LnFCGjMvgvk0JQbkFamPzN_H2VHrNuHy5NBzpFweaC_2vtGUn_HGL3NpqOM8LnjbJnkGuefDbHzYq9BVpC0afOgUUFcS01-MSKlcVqhJtSu2HywX35oKLfa5zGdv1JWkxToTpL8EY5kszl5pcl9VMpW79k3Y_h5jeYsO3qLsrvg2b6BMMlwXK02V4g-DeFHpmZCt2FMBuDegcO1ZhvzuzF0f663_XU5juob1j4_31H-FOcdQf7onPke3o3n3B-m79yQD6Zoxp3pfxF1TYJsNq7zpu4jQuJg63wgZ2w2GSXYWmbsdeEg32zZ0pF5owxwoe4FzktJZtWX3AWmnkVXQcvLk7SnXbmhoK74tGluiwMJSBfYnhZZ5yRqVB8FF5_HsRFv4Ic_FejxmuBa2XgOWONeNjurdw3I4MhjeZeq2yzVPOjbJxM0nVtJ6symclzss4OM_-0aACZxuu4fWv7treG3-0RS1YyQQqjxasO9bU1ghCvTXxIj8IatcAzU2OB5qi5z82aVMbMubtjQkJe2hcAYISRdAfUhqJ4dfwo-JAo8MxitHWNdaNuFV4sRc19qzXmVeiunqeNGVxm-1XjwlnITZGTvo-ukT-vg2XMGJRsQYZOta2uCKe4tlqVZaBeKkTSF-1TwKbkgkcOUaBdZSmWdBUVLGR7y6ofsoCqauPX5JPvYMpHJPjCSetdjFq9gNduR1LnYlb-uoMLLeFPnj2I5lG4EeLU33YFUWvkKr0xSF7s0DlufzRacbcv2wAL359BMAqu485dELi9rQq5vurAeODMPN3OqeIdiKK4JuULdNtBB_a2VAEtwkt3qCPFwW2rfg9Z8mp_ZZS6VyuzOTFBmFr_hxWBZhRdpP6rXuoOyl3tFXBGgMRfErR66giF7Mc1JT_ihm6gSgZFAhsasdjkcXXjnoybvzpuKFzrh8mRu_cc_Mx0GLSvM05BC0UDctAiCFRBB-c4a9XTzpKsy0LOQeaBbxyy57IsjNkqRC7iWY8vJEhkXdNdsOB0htkDkBhYhaIHLvczn82VhmuRFCZ857mW26CZGvU1J11EInP52zpuI8JBiSp2JTFiOUVBYbaUD2I4KuY2I1UhprsXBPK2cUSCEADiSYDPCrfKjHWLPGrDoh9Y98AAn3u8BNZo9bXeB4xtOdvqkzJ3gmO8wNewGb00muqo-WV9HDwm4zl2xjQposFfvDJTp4fnho_bAltZvofVXM0MPuVT15ftRvcvxdYwOasDKdD6QrDKGWVaFGEvF3MoATUt02C2JkZC0MHwwAZvZlWyIY6xlScz_Le4m7SV2Umcv9bPUqNdTQ6tomEPDDBc78jbgnAVi97mKJ-GEOHiR17-x4G-16MYLIWQYgqLSM1Kvj1HuNclfJurGLaSFEGgYyQDjXieXYFQUq43VOssUh7P2YQsrx8aAOBijCTeRH8HwO6lY8rS3GR_CuhXGxBmzCZsKZRox3mb2zC_bn8gufwCrlsfS5H5TIE6yvUUNpVleSkhSwLzDE8WvQvPf2E0zhoxWfV0ZTKzIteGdWcz4KjTGEEvhqsqfxIUp5iK6AXVtqnPlZGAFK-hn6r2iLhNtwe8mcH6RoON7txrAf7FJzpfHnXwm38OFVgy0GJAz5SIywze8MGE8GQ5utaAo998D0KSNVaLp3WSUYC3KIEvj-czE0IsvVuQsVChMXF_5FlqugAJAgba2_G8O837jA6sZC3EN4SMXIee4j8P9GPMFvH3WJ8qhttJon18L4B7F1Rv6TgX2-TQN9cHdIEfGqNXlQSuxBE_UTCsGZA5W9mn3MW_f2-00MvXanlHK3LsBEo7aExKqr7lfcjQIKZ9Jxk5XjhB2yynxOjn_4HvLU-l3EMrTInRNBo9JfmCxOh_486wXIOe9ltXqg35YI2rUgYQIsfEyRDhMKfy4DCoLpWDqXF4JnGtvjK6E4bOqt_iBmCcVt61S1Rhav2HsF-rCxn22VDlC3K7rcfBWkm0TfWmd7kbmstFoezsHm1bvDLbfNaA5ICZZy8ep9M6bQ7YLcKJ-2Sh7FMLL7uC8BYNHNpWIrg6XnVuztehQNDVQTeMJFwtOyN26BcCcKA9KIjzmVPWztL8pP2p-1cy7vYuv1yBVLA8pWBuGvp6Sx23mcne8wOBEtqhAWWZZUYQ7hiOSbB69dLl9gUldJm0a6hpJ1HPb7ufQrwcOJg2hUMQQQO0z7OyIkpyx1VwQoCpJE_PzoGAX1QENyzfwHNmIXmvkNQbL0ZR6YrCjaZss35puZjs3s-06izs_RZkVEMpVzXtmYvQ273SSP6DY-AFbnddOCpLjgVqjnTkwf21pb_8V1HlQciDsbNRy16Sn3UBAyHUygl-r8cdbzG5UjHTd41OUgl1kjTeq4qMG5sdUmrvxajULUzuDxFYMWIrxfyYrs9Qk-KLwN0E1MMltwFbKoakJPMTuA2KlulITxCQkrXto5H_A81xSsuevlfyUBDO_w95gqg4OKj1hyoyvUoyf47mwzfSNBVSa7vOMDXztsXo6jtwsXYk2S29fp-P2b3Jmhm5vh-c9H-RHUdpJOQhA9FIddBG99SxGB86m9Edgw6HPMzcgwUln889Ujp8FOCAwvutuyoZPZNilmDP1RSi12kZadpNLTOI4_GbyWRinVQY0YSM5TUA_AOJZdbOTeEM82YtmpLHKFZSmi1jswxyUL6klCo8-KCJYJhx2o2V1lopyfDTbhgAd6mdBXXNXtYDFiZ7Hm8Xzer5VSerpSnlLOsRax5ylVxrQrbqRycbw8WBbzFsUqmtFXDyiKoAkhdj93qEhZGkHdjiTi22QJ4Bee_W13G2Wbutkq1n6Hjfa-fLLMZz8Ra68kIp5hZS8wz8eyNaolxc0WfA3MSiiGtMY6vovCtgoruOQJrRXdGT2wEFgZrYFX7w7C35XNsw7SIle6xhWk8PlqQbv-PmuL2pH9HhDUeWP5sSi8qf6HIyplDZr8o5imKUO5h3z7cluAL-0sGei36fQPpyJAJDAQ60RNLu07pOTX1obQGp2GBhHQwz9OZhhTIRXoqvXV2YUNu952JN19jH6Qy7vu26HsyOVqwhlsVZoqZqr0FHQBFMyuOoTGifWJuW83mZJO6JOZWSkxnW9se0PfbeDJuHbQMYR468UsJkeFrRysriLma7HwSp_PwPlmAI4CGaqxmlMmqpXDQXuYHuyUD7bI5R2jRCAGUyGr7YLWmQNUYMFjv3_8SxS14t56BBJNAiVQT2gF3aioX97EUAFYZkXeobfm7Bmikrh_m8vIiD3FvwdkEGjW14Wt-hOzTTy6UfJ8oiupV_9P69Lixd2G5YmJSGV9vIyDsCcC9oyNJB7f3iNKetyPmfixKTpCmXoQOBVRX4FKo3aDh3jSf18vXeK5HuyHnWMcMFnvAQAjHgDyJNV0RVLXmP_nQtIkmQEcn_6yhHLAA8nOx6wZtvXQc6FTVQuIkOlgVHhrms837CM4Q6I9OpH6SUBDxqiN9E0tvm_GSbLslDVI-mAeScSLlyztgrc3qROaRXEYfp3pR0jaq3eT9TpFgKKEBNdCJoZ9U6YKiLRvbEibz0cEsXqsYskMgA70ypgpoPb2SBPXfyK9bI5k8xouM11rvoW8h57tXn5nkNVVat9X-QAuZy8H9GDmUhQPw8viZIXoBaEYmSyCuY8zxSxQ5gXdJeEwSWLTa1kC2LrQYzbXLPzK4ny-e0zw6btA-jvEqzntDI0J2wd6pXebshrHi-tVYKRzTkvbFchAPi86NOjh0-qssRB2JHfV1mKQ3id8wuaHQTQk1sU-QoE_96HVSlth_X7IYwoLEioT9iwqpI5p8YbswcTu0e-oYxoPvDmmM8DmB4IdOWTyj53hQHs9K5kkoNz1GwNjVWkDrggBEJR_Cs4AWo7pxO8X8RWY1iUjpzawE6MuTj1todv2wy7iGWtuAaDtBfMiFFRMLloHi4NAbr4mwt8K5GmJfOgCrHYY9rD9HhPcHG6Tl4XGyF4tkRB7m1VkRTBIrx-BpJV2ZGQL2TVPjchhUEwW5VGHjTYTKXA63StuD6CkdrdI8_baAEo6s8fJ6wnqxigFRhwqQkUU_UZP-YPCQS1FfLkjj8vsTuKEgtN0ksmWMaipAYPijwBLp4qKZ9MQzfSQW3eEflWXfz-D1o4G6r5PFJhbcQlafYQH0ux-JtehWwgV3UX4dJ-HijH_c8fRwX59vvNrovA0OMlhMHwX-llpD8RoxXligZ49RsYSfuKh4zgXoDjL-caCHcMg6XAIrJVTqe0Mxyh6YuXW8MQ_LiXsVpInesBpLuO4OKqRcnjxI98KbsTK8hyMn59NEfxncTmpU1LyPt8Fe5Slg-tlgGD74VK2JIY4jr988CFMjY-zyQALOxZt_mJZ-XTnn58W3IHLkYcYA_c1YwxlHnJUhRu4hbjQrUIj8pjSD8AmVsMkf5jupAJWTB7ONXaaXKgc2g6p0yK_Hd-ilGciKNVYq703hGJL61Kf3QaYZ0ijzrGUUbpBCL6Sq1evUGVy-ENM9HJDGi6YlehViv67IK1fZHGZO_II9kHJPUx5eXFHf3rNBOUtaFZDOgMXmKu8lAz3lTLjOuLkS-i5MqmZ8x3pB38gfj5WCt5cwN-QR7hZhmWhWx0x4HlM6OcPSMkSO59olr3w95nKtljOhDYD0ocqwKPWNEW2KbAevH6Eq12bYQdpml1jrXrgR_EN_iEy5CGKiKy7gI_JCr459301Qt1l5CLnKeTfpPTxXaqat0llTPFj49_3eIlG_vQm462zWxpt7K0Er_YaS0MCwhLgLXg18OZXGafex4F4dooG3T-cARtrGHL2o81j4wrWfvo4QebJoCmVHfNjkV8Z77QsTedYE49PpKPIeOkRk02e_ys-3IH096lWqcjpV2_VzgjXAnfdGJq_qPJvu3_bZs9MQiYw1CM4T4HqWF6EtULdRHl-xgX8L_22WfZ_dfSVyX1sfBER7P0xQxpKSPS1LHXiEGQJXEll1hjdRTxWXXjlUy9LsKJg8aphBo4UEX0lMIQViRpSJb_E_ZGp63wR2XOwUmnzabw32J3oY82k06H2lM-mUGTop7gwiQIbAM4S17nvynbURehhc7ExTc4WR4et-_5GF-PU8gxV5HHNW0FhYj7wa0wOCFMMadbhis_5w6y_jmnQ2-_1t9SrOtx3vliuyyBt6VHhR6Egq8iEOO5STE69txSDdu8OrT2-NszJwOogUXK6BzRf2-f8k_VfcUwCyx_S-nlrcDDHXL1EG9Xnthh8MuwRDlYK8PgWuWaLXj3LSTOp_BirAwKXa45avKrNv11EPkAw4Ly_ncP_aqb6y1gNRftX3308x07WgXqwJGZPLQZ0TD5_JZ2rbTZuVdadLdHFOyP-mTXK3RXvyfW94io1_-cYJ_PO2eKg7ul9IyBhc0128zGXPj4RaSERtbzJdRE-l2om7XiKJUdVf2k5QFDEW6Mu16tTdteQb-EokGqna7l0jimmZYTboojv8rs8KqyYC8a4bKYyGlJciEVaOh8iDnxLVgfqJG8O1dOEb1khL_Ca2jgpFUhteoSnpi0Ng6kMNE-8MYUD9FtfjtHN2o5OPdaAn9MXmpjRS-UWd0a5mWnWV2gwjeGoUU_dUV4DFo8Dyui_Q4CUnJxlbusXhQRXQYRyt7ZxCpjasv7Fa-vvdhabHgVjbUY71rwM5dx4hv1fZJyr6nHnfXgNAgwfB5d0OnABsJAaoBVcyReGYRqhFgzyu0xCVUWY4ucn1ekz0Xfc9degLzVIUmYfcE31dE9-mmaJwTYlf6PQ0v6_v-DR2Fc0BnTK0lYwt9uzwQ6vUcnvIKPPcWL_fvwevvtaSIu7abORb6p_P8r4CndvKHOWHllWHy45cfWiXzElCzZI5VJKvRN5xihzvebtITvs5uCNvsCBt4eSnI82-mi9zPxxRnX_fTC1sWSbEtu_6fsKEfG5QE-TU05aIEzrASiz2bYbKyEoeOpCvJPEPn6CAaDeP_dLi0QxDBQw2b0h-MONo6UAUp3OUmp61L4IVCgUWJhBLNJycy-R8lEg_b8gxaAbj1mtwfkewHhcRrJ4-le34qJ05KMq-8igW4clsGZKeiTBtC0vD7dGjA-dBSKME8LBNngxA7nr9GFNZAZC_L7D5hbl8KlTFp6FITG5UAz2_jXDLBGG5XuBlZOsIjpGMIjRDtJ-ciYpTEojf9214wpA7x3xBD7mtssCqLLfp5FSPmk3UB_NI2kN6oclU3Jojm1Rh2xIts0MkTLZg5FKBm5P7cxcjOBim6qzYXPES7Kz6yymRtIe_ePvR22N_m6XOfVX8thFttwjfTv2xqFZ30XvQjfnBQKS_R125yCVtBJEECe3TOqVqc33hyoRJrvM8EYc7QY_jH6H9LQy7pKBgeouPqllnuLzKqYWVoViloF6VRDOFA7TRcQqvzioEUQAfNHxYMF7Ghgku3QNAXEXdig9_9X2ab42PnJocBUrr-nsNVSqQBrrci6P2xef2zvnyPBVg6MmDoujrWpYur7NXigqyK9B4Y7RlHl7m6FHzguy1Nm38yn9xVQS2Wo3VQtu9-vCW5gmvIr06Q0I5VJqBIUGwQMAChCrveyYKy8zg2P-Bme9Ayjgljmpbh5M5GApwiEikCAZ1k4csvfc3Og0nHI6dIr4m3yVqLrLS4fpmg-fRQtgGMnBG9Kg0EIx-YpJztXUfFobk9z8lGovU043oM-ZXT4jc8xzMW3CqHZlLidpicLeR1oJ_E-xfpRXug8A0EYxxy9IMFpWewmTDnXJCi4qB5ODH9-z-bYoM98KcfFml6SGc4CWy3VDB-2Rl4j1aTBc7xJJDWT_tQNOFaO2WHoJhCgUURr1ro0K6Mt8YEUp9ESzJBLM-7vXJzLTPJl8ImAzeR3h97i_GCx9Mj2fiFoi4lsxNoUMMz-9vFj80OXy2ISQ-cYviywfBN2vOJx9pYFpN7hEnYPLGK1gf6keHIs6JVxi8aAVupfUQKexjnR8CL5LPK_VEXiHOgFPQ3EmNXt-jV68cO0YwM-jth9lh-Q06A1w0XtC1PXVyPo8HEMCwtCpIWoXA4sLZRJXJ66AmO8_LcRKydNBRQr1pf1S6BpXjltSX9sDhbKQfNxZSUGra639-aa2pWjVqP8uAajIQy9pDb9M-ouvMO7J2h9Za8BoWlt1AK-FThehfLbDtdwjaxBEwclRagWDgeMek79SdObPd2Do8x5YQDFCoYTZA_vFWhh1IdmF-iJ3PvKh3rdIW7a7IIN2KsgQA4FeYWZavyZ2dsZ8PzBeWYmwbhomaU3V1-xSJurzduXJvKYJXPLl7Ijp1_5x8aDcrck2L6d5IPx_fu1R824OuKvrK70buxpLvv9NmjGqGB6FbIoM7QI-QaNI8hL7Ppm-kJ1E04JSl27EF1QK4iPerkgwR7K51G_W8crHRb59nNVmrSjao5gRMv7wHprNx8n08z28PwBDMvpjF4QAUDCQrOy8VXs4D8PQo2YSVc_uuMmRqYa-NQ1scHTL5HeAW591ZsbMhDHSJXPeaGyO4xnFxp32RNOreZeVBPJ3-UAd_pNHOmX7biArr0MNAzBY9x3JgxbSdKetMEnwbpn3RS9d8I0MGmbXo1K0NF7fHvItyVxnLam7cfi8y6gUtDD7awXCmH5pCT8j5EMEo0bNGJxR5JK1E0-NzMHkRRJV712ZDs22SPga8cNuQx0jlLffPwbiWcN5D-wKs9LYFBsuCQrWIe_J1UkCF9FKKeZGILmxS2RpN51OZT5xpibFZqYLchmrDOKCs1PQzsUXgjLsPhsYcMj_2mCRPnJnTUsqwGnC6gIqh-Bu9UVi-mRRwDioWjFXS8uCxJgOIan4XAM_179eqQo8qQRFbhHvq5v1-QTuI1F0HrIexIWKnRdEYg2pfDh18kx6_i505v4zkwwFLmCGF1BoXa6UqvwJ4diVH3CrKhsy3lW6Iu_WhQmRJ74iulIXXmiGnp5TjGnbW8nkKELP2hYECijralaKzsXNyKa1eCF2-O56MgySl3YKNjnMmw2WrnVjVDjKtYQi01-NCgQkel9ENRzrji98oouIAxqZIo_rvQhG97Fm-BJLAAkfwuynDWCcw9J0BJeP9R73h7muXOOThQkaELJAZ2mUyr2LjewHp_pnVmBNIjMn0nh_xRsRx7lFrZpvvw-5bvJImdFldTaMObGssM3AymkMBT62WwiDpMmU3FCLAmzmuyUrE052UK7s7xfp4VBbBpaaLVyjCZwTBV_egWo8goOb8i2SfLD2OQjH86R6aVP-oWIRlRQ1SL_1c4ROhHIDhahEHyHIaYbiIsh-MZD2_TpsUp7MwDjzmp-cLXuibNZALiTgrWb_05XUoP6_sq858pBKM3hDSaFHWdBspc_nIgHAF9zVEnR9MtmJ4bGQp7CYoHE7OIIRikhl14ODkpL1FbUlmGWgWik3hZUjK0XID8p2PJKN4F5V6mhNEPBg6-5Gj7b1fMkCvYKTq8t_XnsRtAfEWObnBt2HoiKnTN8qR-3IaxvOxl-LLZcIRuFIVX1IlzkFlbRhaDZMVebbQumpLoyw7zptHeVn2sKgPMECGZ4x-G-bV9FDB-xYQ3Tcq3EXHjeCrK1l8GMQI383HxOkW9M5nWup89lI2DY0eIjrpS9Ns4XSnYeOhfaxrq_jwRTW_dXM0Vpghb6Et2wb4kb7ynsRNVRDZ7k9eW6iiLWJYpmI46nJm2b_EkfuLpH9wVAemdDfPxPZ9MSkPm06vtGYlkYDasuxs3C8J-TXk7jc8ne_dO9RMSouheZoe6VlbnBf-504ksqxqSQ1qjquJ9RTjEjsERaS5_4desmkaV9cSgU07V5tpcZTaUVEZBr9QbP0eFtVDCiDfT5D6N7907algX-a244x2DWxskWcGq03AaeAdhFOL1CCQ8TO35Lq7A-Kj7tfvAXOQ5UMH5M6F-bIxUYDT4_smfmnsDybWxA5sLRggygftoA64i3VP4X_k_z0uw2vyFcui6pgitYAsGmNlluLBJha_qX5FloXADvLuvZN4nZuRBvyIMxQWUEttV2LWtSS_BEXfVJz159VylU-zzKCf46wEl5XuellvwJRmOjTsSV6Y6a3i5cz8bAKVCACmiXB8G-AOs79QHfGFAiErfn6F02OqWlIuoYIAvNFnCg3DNZd304i5nqvujvaN1DGXu3L_Z_eWXUJH45Jps2u-5DxJ0AoaG1OA85pmbPvMN87C5UMgTRwXuBCJHmvps8Jsmi0tsR5fSHcjIF6DLBWnFVfCVUZkh0VFpadGbQ3BA3mzhRz1aihttT8EsCyzEvc9feRaMfYCyeSQOc8MxHI0_2z39AFn89S2pAkSbQcGk5xl5k3VREJqppdKUuaukmkZHMg93GJLRcWsuzifI22AUVBpLMirgTMHfxZoohkp6neDTyCvP33yy8mFDP22f2Sh-3lKnSwiV3oqhWwyAbvMKbLpufFcv71dYcPGBe4-nwtvBtL7jrPBrOgsD8uQIkGU60h0uYsMN34pViH3CvBvjd-qU_ymSJaRGBJSDpeR-eeUhD0Q0vm5eUan75ygULCAByRGFl8z6GFfOotSiO4N3B6R3QSb4F0AO5WgbzFYaIoEllE1R7HkUaamym4--MYIjDXIewxjelAq2SmEH0uNFtL5ngCEkLGSne-El5o4IKkorVxbwJYeCVV8enoBey4hO-ENy60zM7fTTc0bVzNd0HxuB3HxcNLjbkzrcQWsfL76daF5ItLF8c0fDoi-51mR-Ft4oF6OAG9iE6h_3s5cGMrD3xZ7C_IqExzQCQNvGB0pm5bERc8IUhb4kUmSNA4BxXuxoZFaDWFxvQl6PikHnU_baYgoEHM-vvK2rh5E3gkaGAg_ms0gAD5rMGi5DE3_xRvgpC9raWhi_nbhFGWY-Ddoh1MvB6IwMZm2yPhMt1ykx0KSbBqtL1fv-iHQW111jWsBIdUExsg_Ozw7JXmyeozYGz0Exh7ovldw0TBh6RR19jxkFGh1fWT11nfC2ulr4LdcNE6y0ySFCb7kXrxD0wk6yCqVPwTWxsTNJVfQzh6f2qdk6koHmJBAueGxvq8NRLR4Iw6DgqocjbltGIBPAqqGkrHXWdCpionEtXmbaLxKwDJrxzsOc4aLZ1RLFSZLbSZmAcFYSQ2t6vVIlhcRQ0USCg-uBI9v7JK5Ro0CNUkMv-kmKyCPfYxKQlno_gON5xHxI-W2tQdtBa1MSqiI_SzXyuEozgZN5yWcFG3Y_jbcwmB1e2XrJutDgu-SylRWNdEjulvAIYUc2JbSWcPD1WZR1Ccl3hCvJkq2mh9VLm-DC6Cf8W5bekvunIB1x8scLej9u1NgCP0ST9lmVg1jlB5ThztxfixkvSFtG0yFm78kSoIDn7B3GPA7WGFTCZvkOiDHFZBXflkZOsfxUQOXQzR2FEGJqHBFXOCnq_s695meID7p9XzMtA1MedNh3nqEcx-xICau0MT6ea-ePdC6kCyGzTAJ-DLf0v9O_nb8EmzylJ10kAhXlsjP_thJPJXZX7CJNSD2CTUN4DfkKuEj12TkMfJy98bIY1ytwR-NX9dhdP7Wgo5jyDacgW25olRB8-4N3hbQxRiNxhhqF34nwcxeRj2eYfk_2180lCi-p6AalARpI33Oaidf6N-nRHXxtPcI9fU2hiOT0YHxvyv14qcwz_o7Dugx4m70IGG0Qz8ZqoaKUbqN75d8GbmlH1yi-8bXZ4zeYR9op0aTUYiwxxITbJZwUwss9uSwlodle9H5OyxWj2WXs41_4YgAC4c9O-LgmTOqXJk2MOWQDUWcHAbmVwiW1xNTzM-CambPRbjdcJBtvKcgRdblpGnnoxlJp2Vb-PXk3cMZc4g5UqorH9tguyY9OsFt4oY76_nFGavkSVdRp2oRvA-13ZaY7-WaSZEkJco_kPNIrYsuycEOiwbXQNG160Nb1IWQ0hyijyfbF_guJrUDRGeG1RlXZpvS-0jDob6kiX49C1NQwLnOnHHQJqxa85QxVtLTRgomX4M-UNocoHms4Z2Cz2T2n5NZ3lZoslIJiZITiAVBPuMjannOMH0KUHmtKTBwdEDyRB3eUa0ay5BQiem6PouaxqHAL2tYec4tKRtHcNA0e1cfoNKetqXnVWBNn3GhPF5Tk2qa1RVotCOfbLn5UN6pVbW9Tzu28uH47-16tTo7RXH4uasMV-n-fu80FDdLIZzs1kKNu7UtkGvDtvg545SSbBaDnjxB7tKwVK1TlcCpExmBFEUXLiSczb1ZxGDDvH2sxXV8ZdcnMV6QO5OrOLTVvXclwzv8pxOoO8oUKlOIZQ1Bnym0VZ2d0EV6REkVQBDsaJL3fG_ioe1i3eynKnjQWVDv3MnH4paaahrEgCfL_3uEDlmHFjG1NvzAArLZbM89d6xBEliqlP-vht5zGojsdFHiaxsHPQOzYnT-6DNWe3vxl3bjxXR_ax9d_eVBguBzk-GLne8w7DzWEN4eYTFbmFzZSbYO6xYJf-uuztCI38hR3SS_dS7qxTWkLkTV5wClhCbcnonei9x0XmGJ_-YT3NZ88Fqs_5JDt41r1g0AWHfUr53lOUTdoL7FOxHZy0Yd9wf-4CyVLah-6psVxuqZl3TPtwFIjdD546Yc1ZR7VIdhJF1DoyJqMDdnaeG6Q4JjTxr31ZEHHem9r5xbN4BnrYqP2bO42TuxqhUyupOcwp4NXNrTuYjmVr6JRsFw9DfYW6c_uKJL2IVFQtfwDt1EC9CLzjwYPks8hCHHL9cEzaQut4jdr1RTjWMICKnH4H6Yhy-GBeKzS5MEEJcWIBwsJ0dgLMxK30NnuN6oUGcGr4DgHTg6gGkovglboUVym0yD4iwd9Kl6sE8SbZ6XLAu4EvxzeqURU0M3FWbqYPL1-1U_wJBw9UtnrhtAhznvgRcY9sAKqzJLauOCfUaF0RM8fOUhmECm6msUJZQABPdZMn-p6udkFkDwp3oPvRLS_DHsEI44tlv8kxaHqNVMKyjQxHpwjpo2YKZdWBLFbOZ7G8hBp_shaBAoQq1JDwLMgUpme8obTnfXD7NW7vAA2FY4xwtaIOh5izoo7qUIa4GtKORN1fY1lybUpb9XU4AvZOn46-OB8bkXbuTTv5xhXdZKi0Kl_0oPOlW3IeeHXr0CXqx413KA7n2cnw7PlYZyG_BjktjkLOBuTnZahPeK2Pbj7HrQirdLimfBcZxjdEk_3o0l9VnI-xlyFurbwgtYITx6dKtKYzdnN2ChwzJnqAj99Eaok9I28hEjRyabW6J5Em1yddux6WiTGasmNZYEHtkZu6GEvm_-fgX5aHWxd-HKMYRmVwQs73k3qPpfz3oynHWAl9NDYkpW9SMAke1eqJnuZ49S_RCC5l0KqBEOj4V7gQdz5AJoO4SWvXjWMcnkm5-7bHE2r6NNZt8dYc7PiBXzj-GvinW9-RQ3gaEOA0TUJfxF8osBU0s90IaR_r0MSqB1uN-M7Il9ZC9ak18JdvkImdEg_1U-gXJnvdkiqsE2MkRekHsBuFwcYdL22dEnancPulEw89HLFQ4IA1n7e6TOOkBRDxL-TsYar5_pH6fpVa--uow4fahLy5GT-AZGAbCbqW1_p2Unk31wsvV_EmBejI0gfMphUtGbz2s1aJQKhx9DV-Wg5Vpm70im3HF0M-8yy8HRq7c8L-HD3vnYDZ9CRrADwb2-2epfK2yKLuqsgmxuUEmlLJvaiBma2Y0-UMhl-EJDKWOcr0lX02bv98KhFUSw7eDxXAJHZrmXCGSQHFY5ARu8k3fLOWFDbBxdVobwEIVdl4vNoeUmzz79IxYcFqQ9IfUmPkCZmVHHY_PwZlXlRYNFgCmr7633kB2ZR-8Oy9s8ubPnPVOpiW3ZTIJYzwiCh5xJbphadHRleiC_KUuSQuOy7P_D_dwAXg4GAmIwF3i2SV0LHnH8wp1v6Ygr0MgAtpvv1xxqt1u35pH0jdqyUfyX8MsDi91SDOVmc0RIt_WJJufhVyZrPTdGtrljwDdmCbp1OBS5pSt0ttWMN2kkqEkHqH9PvAS3UT8O5Kg9NA5FVg1Xep0lUn1M4dcdRPLjPyQw2nMnzHjtat14sURaW7g45UleZb0fd0sz4CU2tRGlFA07qrIDZ2MOOcaR_ba_S4p9EHCy4xfoGvM8BetnxgGXGybEQfDiF14Zi6TR4EjN0U2rQYJi27kjUfIiPU0kzn5oAmUsdcr_6CrCzmn_7S7x8Dd2XREcPfS_1G3OV-uRvVAJWmvd38IVaNoscmpGzighHCwpu5mgOrLWHc8TcPoqdtPVCZ9cfMfI1fVLEwn9ehPqAmhnGx2ZnktxSLxzl8TSdkTWaZNM9l1Uw8bujqVcZ9D0d8PwROgThFVJsK3TnlyAdILW91cPobLvLuFhsJkuuQT1zzI8fHs3Q4rt8s_uwyN_6U5pL_guZnb7STw1-i4ARM_v-jpdtKyoJDSp7xmSHpp_RQOl225V42htEj5KFJ6CqiBjhvxnGFvX2L5ylwzFme_qzYNTpiIMMotJr2VfDybUlhedjXYMDjVYA6s_bWpXS9-fHQOQO_8rrMGPta18w3rxVsyqgWULSTrhGQ8ML4pqaGIoF0dUFqM6fW67wYpcj8LIhe2vTLyUtZETZZ2h6vr1ejIWiWEZYckdjGh4vQxFS-ci8yVpuER498DazCtENwChAWykcmM8NJMUKNm2WRIDYBagQ_o4ECxNVAlf4Gz8tb84Qzjs5Xx4xHf29UhinyiTTQnh3QY5wV366z9AZE7OybJvdobRNVXeVX7Ehew7WbPxWDvycm6q3995vzSStQAOc5LHQeY_0i7eoN1Tm1V6mvX9qP031ub_Lr6UYulEo4_Hm8kBdWd6A3tqckRWnId6bsJVMiOFiBk34sUMKSlf9tRJZOD_AsOwf4KWlLfS6AmemmRZRGm01aNEPWzk0YYc_Tp4V-Xc-F9KNT2GCp8AlbofVnmzFc8_DmfxJmJlKNN0HwrKRE53MBisEXwj5Z5ImPGGHE_4ql6e78qSRQ2hLQU-pvIjnFUNOxYPxbd1lTZ7EMLZetWGqi_IsKac-oHFMx75rbHRAdHwYZOFuwMVOYIal_DOw7CnolO_c6laJUHh34oIsMjEnmyFF0J8PjIzFlVFu3hGE0SzoDwqkQE2GBVS8bdtpyxgUOuopGWdbIZDGVmY05-Vlroy--DpUmI8sW9qjw_NLHSsEjE-9XT14wMAt8a31z-yfTAd2gIgidrhEQyAIR9ThmakCYBEtpMCG_MFgVbSTHxCwSiRLBM1kXKwCyCur24r0ZJ0oWnpunQ6J0oUdRCdM7MNsbILIoL1PFfCk0Pr6g4CqlftIzSzXuQX96xi0L1ZJ7TMEVIQoW428rm8UOf7Vu9ioyhypsVQKJBddJYEBx85awN61ZnuszGFDUQssQHJLGFZ_uR9riqul7MA_gC2ly0O34eUBcaXpDJMYRt2K5X7NzDVRtfoT9t62-cO0XtrbY2MGNkdznItHdj8KHRgkrMzePnD-L0ChMwwud1XeThZ_b2ZrsW_enXAZfGMlXeGacj8Fze9vcKze3oHQZI3A6OgrnW_FtPnAF9G0s3lgr8L3m2mwZ5Oad1r7uq_MwwR5FBYnm-r073c4fLoWD13fLt45yyXgJk8TZAIqhQuPQrrG_m3Y0OrQ4bX8lniZRaMsWkW8i4kuql8ujUxKJXMkPpu5AQKcZMBkdBHCS_mscFmVxhUGJh2n82UosnAc1J68gIvwOwwH0_uAfdVvTWKeVxOzAXG2K24FckpXqM9-5qbXSOXd-EG9g2aHEF6dUdUIk_sZAgK3rFrtPDy63hanVhWrA-agr8XlCNb1f70bzqk7JbZMhiRl9X7uiTnE3WsJVoyV-IZjQUZjKMfIw803ePN7XbE-h6d0c-XzPNVXyhzUgL3cxO6NUADDhMHHQGG-gOaiIyqRJIzNSmBGZdEqRTapiGJxkH5T46ZXUiRkDEC5oK4yTynJwyeob_lFTdUGn4CD_qrouiVfzu4STN94TWk270J0HMjNB-41u7VQ3o3y4QE28mE9cEf5lBjLPVImkWI-G_0eb9MUntecckPPtjTo7idL6vuxmRnyAYV900_nJG8ak8uZ1C2-hALF9D8agVlbuCEI3rnHz5Emo_evqSkNxkkdGm2_CnhY_fIyxlpO0-TCOJKiYZBorPm27ecgf7eRRbOpFu_tQebGiBqpD4fLNQOdDoKTV4zg7OLKdTLDSjwCHd9sot8EbprSBxXb_Boq82rksat4J7XPWhkp3b3T8dLeIKU62J5FWjg2S0bX-MXkOEwqtA4jdYKtRHgefEAB1WmphELfVb8dEcNyLgrfdWenaLdEJMl9YzD_D1goL9x3f2QNrM_NHpoF__lM3EAhm-KcsewIdW2X1CHq7L2WPLuIKllpycrZ96_BRFwLItbNQUCw0Hjns4upYi7Y7G5a5cj_M5va4H_kUCJURRhpTE2exHtaxKVYUYJRPLAZQpCVZ0Pxe2mLKPx0ko_cIkrsDgVAOK6RNxWMljbfqOXTF50Rx1IWDPna27-V9rS4c9Ka54KaKdVxR9Ic4pySFSznay30LtQN0YGrh8aI77lZZMvpLjcQjlf3mX0lG78xcLdouI7lwOR5vwylXsgk3EU5BAJHu--IjErNBnaXOKc8PYZoTmVAzEIsjCWcvWyg5tMoNIkiXoabxFj1Qpaw1JvKRybz8KldtexVosyx3xlk_MXvL8GMbKvG3vfCzbb824QqoojNdUccH8BcTczzyiAEA6rhTF3z6MuedZ0E_HjvcppjjMNjeI41s1n5R3Q7uFOQsh3spjLFadNX8EEJlPLjOMCboCJYTiCm7UB0LXHsdCAS9Kio3i-o1TxFC3yvUL8YvYN_78fymErDV-li56rdojUoyA-G3iL5bzd-v0ZrQwlBnMcXZhZVB3vkb3ke00c1om0EbGvyPjeBd8UtcbVxlckHs5EwYV38SlBvygU5-qEu5NP2CJLXEEGQ5t2NLZVy2Ip1SUj5VPT8kyfTimNLUFFfmPBMe2NWZ2RS-eib0rn0gXIGeJ1y-7_QRTptYoUclT5GUfdi1LkFokv2X68ASRPZC2q5Z9EtZt1LEGg5sVMoYvp1Rvre4RbYWl-WWAeszbvt51j5ku2VJVwIONSn9FHcnj9Bl_W65kxvonjOSdv_gY47mXOYRs-cxg8LLZa8IhjhtSIEJlHQ5WXVrZMNMcdYeitJTmbZwwf0auR4l5oBK23RNWN0QE8Safo3UKtilhWX5z1SVE-Vd0MuL9e2AthNjVKzJLm97K6aRYWAuRE9NPrpZnQl5oS1OYhihF_UE1bcHvnGpDKlg8B7OU37rx7toJrhq4wZeOZNsktvvNCN9g_kpwDODbbZryicZ2mLKNyIF3n_goXCzyX07fEEklyywVtGaab9MWyUkdgevCfgNtWB-CRPF_yoELcdxB3H7ULnkaE_hcUWCucj6aruRUHgd-ieJJY-XFtdRhRd7tM_6IJum5hOeUYNaOG-Z5_py7K-OiGb2lC1DhM4z5S75tRVRa7CVoILJ0ghejP8bPoj3IRLMIhWY_fgO_lV_lh_TRy1c5timtqB64LtatxRZEKOowhG3wQVRgpVNGzNYqzAMv-Y4re8X8xJhqBMAtNXBzmm7ezDca6tz8cUtCDPxjWqTx8rbiF2rx-OV0IELRHL_UYR9yOLlJk5V50AzOv39HgVLN9Y71K09KJpZA-2OSPiF2LxLLD-PNRdSry4XtwQr9V9jF8ODavvC8CzSfxO0N3ECVpVC53wwX3H6tuNymp7FOVDEss9Rtfi_6r_cwOHOC2uz6CK0BOg4zEqK4lKoX-Jf1D5b6tYA2WAEzsorpUK2jc_vxWO0hbwV09mBU_jiK1TcuvhO7JMUGVfjGesUFY6lp88Fe26SLc-iFd8R8eja5Xj7IpU7jehkRQHGrM93XMe3vHuWfkS-KHuhc9CA9latDTUyVriEXRNocIsLKwTqXni-5IZBtTeouNXpniTlLmWl7IL2SqX1RDP5vzhm2wXkPtWBchfeSal_DAALLG0TcEAg-EjxXFpPRsRE6Ou8ixevahPP2VxMeEjZK4YPfTS7njHtZ9RyOxAjYY-_zTRSol9u7RS31hAaJa8BHmn_tmfotz04ITmMBrQYbeagKX9BjL5e5U8qxYvCWxeoAEwhsjoN3Wm0SZdSlKJwa5GT_XC_nH_jvtMWhoq96mP7ab1YztDmCHTqN7isRvyRLatUiSCy-YiWY-9aCcMWUEkCsb9IkHcP6JxOPEssHZV9lBq-N9aMBf5V9WU2CtQEADAlKFVK32XuQSxBrWzW9nV2gy831CF0GgVw3BdIWAMFrG-5O4NJcY1YIgpo9skeamtzQ3xLhUJH6rMn_NNjhD4lMwzEWzpB1l3FkvvOwk-Mb8Ey7Hcc1ieX-kHxi0Wvi8w_f1VxpyUSEfWLdITUVz-4F81_PSvL8hqVA8p3n8-14nklQYIbF85Yub0Nqv1Or1VRBDSvTJcJt4qK4uJRmNoFqS3i2HCznn2jo_OGlsmNf_z_ncX3hhz7b1O2-of0v95uMrFnw49znHGSQfHc_lSeUfU3Oq5rzNLIwfawCcvwIHRMqS3mZ1tcQKZSHTYQ0v9KND4JFMz075zYSc4w7NDj_pZjdMXVz9iofT34cmeQzcDpHs8mXEgL7jerJofaaccEGVaLm3Kt7bOKbpkvi9bMSCTkSekET68Ne9axLfLSUpt5BQZathkb3z7_373oFSiVQd_Q8Be1i1mPE6jnnziq2K1vVkHVyXndQE0BkT3LNTOpf9hLQC9LkWN-0syIVh5ksfWNJBDtNYUpqvI6bjT_sunMLqGZRdWwJbP6BmwHwrVm2YTNRU9AZP058JFVWXG7pDTAOgoAMgu1nsLTfvKwAcXwcZ6JVL60rhBuFPoJKs3JXcgb1BdFS_ONvjjiNm_pKlS0WZ_jwDdSaVCdrovvlHFsF7x_4AUmiEfv4P_jDJnO4B583VtqRufn1ySi5XWzFhFPMWSSnJD8TwPzs0eb9tlYuSy7XC5xZ22gPbMxqFMOYH_apyl1Hdc66WOq_ry4i2gxc0qjbHLwozMPn_WeNxUn2BZ41kTIz4Ymr_DeETA2WDbIV7rI7oe4QG3qFjvlF6Fw7YnAtcrVbz_O0BmJEp9LeWvs8-_vV8p8cpdHkZw7d2U8wzbXrq2gh5HKvNOXBN9ZYyBQCAJLhPSiw5EyZjSE_GAKp0NEXyKLEEq0OSwFCoQZreSuBOudlDptficJFVc86T6ODUtITcQ-OsE0vdwoOxaaQt1_ZbxWSM6DeI8IKZznztVa3AUcN2IcOoZ-03bIkuus_eNIM3EAxd5d_o3AKNEnQY6e0UB1H-9kzLAoCHC2c1Pn-sa65FAHX78x2R-EZImkf-iMcSDamtx4Dxr5Uh73d8SLpu4hxtL_ymyoCCNhbJ8VBZMQVBTSp_jB4FeDwxZau5Z-BzLJiPhFQqmcuSV0pS4MTh5Q01TBX14XBkB-7cKa9IcUwX2FjYzGv61AZyycZ7Kytt4G-FI-FHQj_Arp1RtU6Q6pKXoe6XFRc2Lzyvy1hpcuJ_WgkWsSkymhwYm-CMrEJhsPMVYu24Nedyijpzfw2JsuEifHu6UV_YhjGPheUHmnWSMxRU7Vy3Q6d8yYZC7SdK5lyMNEbCLNZnNxARN-4JyoFAJqalKg2MMtXVFM5m0RxRInSrpGxC5aNXLYXXB7jMogxBbWnEtiUnEPCau0A6yvkwHdLdbjG17yI2tMPsI93EqFeY6phljGsEhm0nQONNh70tDEfZkogSydkRjPi3fr8UoJ9taOEki39d_fvIDfqK8dU_smbWflRzHJEqUlL5_IZpS50aQh2FCqJ4rzf1dsB0FJvuNV3R4DXY8SB-oorOHlQOqh1JeXrk8Dzvih3Mzat2s0ScJMra1QE6wkUfsJ691VJp_QLjbhtetvpYauGgGqDOwWc22ddmA6AwIT0lcuGI7_aU8bwbjNHTFHPzs41QJtt40AZMrExtuQ3jb8EScrtMmGGPccuJP4C2mwj2mV4tNc-WBEcezWV18ilFbTNlhBdLJTvFdtSDUk_5QdLGyEKmfSElOWvO7g2BrPGSsfCsAZZesuuZC_W0QczxaQZ5BgqSzFGPwDu9oLEHJCfRXJAaZmIX--LytB3hDV6dYWqLAEhpJU4czHnSJ4l3C1ESBsXH4XIWgv4eMPOHdr0MOEBmxkaQGAbjVjNYLMddU2XQaQ5npOGHyg2dWvbxUJ4ATNT2G_7WfaOKJDpMs14U-bVkWn8VgJTzi0WiUybdS9jZ5Y6B12ycF3XyRL3C-nM5g5TYtKSIhV4pkYdArFTCzFJN1PN6dstkT058dh6T7z1yePIB7cacyTmcKvhvYTLNnVQGQ_mlgfpR2TmYpBJ-ykawfVsg4tt1JfzeHiqVunSdS2j2Ost5LsqUyiYAVkGGuxTdDP5URJj704b2HfFjkvVBn07r8LQbu8R9EUwWRQ2ggbsu9OvOQl-P9y5oUuVyGEg2FEyXNXrsJSJUeMOhDLIBwkTN3RASlhOs8031U4zfDnLDAlqKIlrkmy6QJJGdzS9jH9sVzN4cIOZaIcR4fea0dt3ZVduG1ThTwSZlp1FwQ56Zi84e2k6zv1r3lFlKoQXN9aV-0Z21B8aq-Ya94C85Tk31w3HCnSKiq-odCVZTpNxVIymZKxAU67J6qHlv3mpB7pTwxAJZFziBZzWye00W6qlUbIwpAXbOQ1VX7p7TvwZUCYvatt-fQpSXqGEvnwHHLzvDPhV-eQOklPuZsqG7hLuDSO98wh3SJywB-KafEEIsfO7vh6R2-LojkkWvhg9LQwX-yy91Aho4A-1vc9SjplGpJHS26uD9g24t5vh2DgFib9exjiU-ItDH5l10q4u30YUptBGzUttvuk8TBk0NTWM5XV0jPnPu2SXl2ZT-lZK2ADWNLsjK--VmUYP0h1epoVlnop0nId5l3922Ve0N6eF_dY5aDl9dAzcZNcYSW3klfJlU4uYHo0HlkpD5psyjm4Ag4ceHHVZmz3FJeAMoKaw0GqX_LJY3yeiLpghtlcSNWTIANOCecGgIMDhuPKNxn4of5BTuTqWokXmqIH019lUXb8qMj5WBs_lMItcevnp730ZDs7IaHJKk6m3TSumEwdiVEXtIzrn9tcxirqad3FxMZ1wjN9SIDGTpE6U4wmiu_rTEzW1FHSCqExhWWSWHahQFCPzTd9kYo1Qc6hIEe7cd14REZ8boIp0CRLL861x0FN2iog8X0R37VmiO12IsJTg8B6xu1wvK0KKthYYqaZoh_000vRmaeHulaFQYrM1jXoFFAhzYCWe0U6h0_dqFTtf-WWh4GKBCRrJ6TF42BYVONOBrwmOMQYy2RC-Iiufe4C1ogGM6og5nadh1gsxJGwc2xzMmA3rhTQiqmJHXhALM1ZjCaESnec7xqUSbl5xT1x0m0VdTfbwORTBScC2vmw_VyUABCvJMF5jrOfjy9_Id06j_9pWh6loLAZIzZR5f6m6b9JLBDrgP1FlVSFQqj2eNKLk65wG4MBng3BqgEwr92VWNYYwMRV3kCmZOL2mj2Wm2Dar-56iiJe-lF5t_CWOoD_561sTW2kTzfj0JArqcqSh1CF8U_89jsmyFc11ye_GXIrVol3BywKlNEXbt8k8jM7wv9FhFib8cd-x4oR71CrhAKp_aWkc8Dk_VJp9Kca7RjDD6G3QummbeD6Mh7iIhwc4uR8u4sGW2HEPboip6cIVucg1X_m7-6s1DA_yl3ELL23k7fOk4JVbU8PMh2TFeyhaTwRMLSpbkL0R9kEA307tQYNg3_CBaUsBi8ZCLXG82UU7iecCP1usoEkBRP1jeYwIXCd-utQKnWkAWrEcIDP5N67ycoGaV7jKvBVJmgPtdA2-4DW-dzUvtra5LDVBGefQnRBCZRJLKKO7bPKnoypPNdV0myfE5MBdAa-IzBwwzbc6XOa8yLoLaV7hnrVOyhie-BYkZxgqBhh9BlXTqYG7UFX1twa02YHQoLcEBP8MRnS-SPjRTctANvRGrBoirtFs4giXmOo77E5T7pykiOknzOGtLWJyN7ysTQrPrSaF_ANpcRVMit_7A7AQ4SX8iC0qjc8oma0TWxU4oy86SUW4l0JGCswA9VU16y_f2ip_QFof_aWuaDjE8eJyAvQEBadTN1OMUIUuEMjIBuxdALOgIIR5xHhMFxmQk_49piAtUYBTu3wJV8tMF2sJfrPm8SNSCNepQyoKKiPDbTx9eorU-9jrTrt8dVyvq6QBnA0q-Q_MRl2bs8wUcJjKcBPoTz5yxPPiAeqlBBANaxY1i81tp-ckU3E_OU5qt9qLgAufbWZ16dZcSQzFppXffiXxW544t98BaP4OL5rfi4ttpHw98QpDkU3WMklVfM84JDFMr7OrR94a1izgDyUQoYWX42I12OvZSMMyoM8jcgW-1D4I4m9rXTTYdvCqnIVAVNc1sJOTtm62gM2hn1MObTP5vp5q3ShaCiZxp5cxYdjX2xaly9OpcULMwRNNB4ZKW-5lsHbUQqGnsWwV5Jc5vt3LHwH6TkAqfzmCqYcDCHIZFgjY_8aJSoA-_Q3LdjUTxdrK4DwmmKh-bpUnQNJS9tc6vazOra2dFs_CXfwQx7GkNGpRBFHwYQN9cQuYpNOF9sjW24ztDPvbJc6-6bDkxWCWgCcjT6XO81mgip9oBtxlAP6KG_Pp-IC74xI9lhjoV0Uk7tGcYeJbV8sxgk77O5UrVtho4DEcgbYcgb-8jXfGx_OkXwFFmxcDMoE_K9cV826P6BA2Vdw2vRtdkndR6pW_tCs5B2SLrAUVuBeytduW2YcTOaM9ySykPsjJeACAIcjvBOsbZNGENoUr3EoOxa66xH5JRiH_TRXZlhuLAw04m-gMSgjfr5g7Zj22xR-lIDudRU0X9_IYrRji-snAgAXRYOa-aWnU8Imxk-TMd5GN6Syh4-TUfodKqXK1aNOh5Ex5oivCcTrvgcebtnLYd9L34tlTt_Ud4ocgYcjGQl5lYAAPgeihJXATyQIZyzJLijgY6QskI-17CdNSZ2kZDtTSPIyKjEYxzPsYHqqkROwIfJ2Uw22tZb7P_8_cQeAs2KOZsOTmbp8YHdksLvli5RO0Iv4Zg1crp9Z3XjMp109YHSmh8dN88Z3id7QCi8GjBC7tgS9Tg1NoFWVaL-zLBKkf0DHLcr0U1aeKr8MnIFoa4w1V39y4aNBawxkonSLx99mrpENbnIv8gAxRfZ6O_GXnQuRLondktpIt5cGtJ3huv015VndYHtqOqRHHSrKzcQro4P_UO3bBy-3cZRS_jdSTVkhOfpplZqlf_g6YcKfJsr5C4Nr5sQldnhTV8VjAarbpcyDrIY4r-fRJDLkvH80NXwslSwrvsElfIyllXD1L_BqfV5OsMMCY0_1GDXFdcfsCQh_TNJphtm6YBEbkliqNFALS0XbW96oSKcXjED_KQ5glu1QZl0CyujB2eKJSVPzKw_6I_R32Qxyh_Npfc171ly11RVdpIJCVNd-e95FFMHq3cH13Ww7UvyQnF8dsShttxkFd_H-UVXXzw_XrBiaHBPHNxctbgzBI63PLozGc6f6PUad8p0L8eoO_vlBvqxHvV63QULRfVOpPpiVDbK5X2JoAWnBhsk95_s-PCA0aq3SHUdzvskEule1wRMOfd7rEwE9LslCHWnt3RVjK0QHfoM0s9CY04pWra5AKgQP-dJ2YqM8KE3UsBCI_QwU4JqjXUA5vnu_SCIuFoMVe6JeMaF_Am8oicfCgxg-ZmqEDMjR26cY2I2_FCLzcVXRmX5u5cHhf_mB6F2ZMRjL8z6WWdJz1Xcph-xG4T6Kc5TzvhNTbXHs52pzj3ibtWxLKoJJcGHYp4GN7FBgh_Lg7ygBdfwh6X-p2cyuXNvTMrwjZIXKXhS3ezEJEFMmk4PV6sX55aTRz6owwQcljZ3qPhjC47HSpsRBir52jB9rVjQMycqiRCAODRDdJWfWaw3K0pIv1YntzguOGcDPqvs4m-x9xrFHVEnV_h0shoBkcTLsHyW61zqmYsmG8P0jOSK_Ogn8ZiZ2a2a9k-yYdysdzgKNGoNSqYrdjhV-FG5QUhlChwIizBYQmt61baQyqGoKEIWF0u7fm7DGt-Y8lv-hPXWKpxhGVvdfjlFgBinaGn2hAxCrJr5afzY4CmYZ7TqumWVnsYqWiG2eXEEaK9KEbShUCZpzbxrTdGS3AptwtR3FzL2jUQNSl79OTzbxE3K7YQXnpL49TCA1LOvaazFFwY8ObNEVZsUGNBxpBwtdjBfZaNds7C_nhfBqvnCMxjmaiNoqGN7p1vH-oRJ-Dn8e26Y303bVCFytpNttR5ry2MS5px2wd1jjm570dQwsOuMK4Mp43GPi2OAom3pUg-Rb8k_BNxjoIw5r1LR_GwaSILe7z4lCqI72d4hGOWiusQ-Kah6nVAv1xg3Ez1wJofMaxU-tTtatOgZr32fkqE-6g6qu7WxFFBsz6tTZL5fxEmd4CekMMTfmz10S0Jwpvggt0V0jYDNZ05kay7vw6U_tgTW-huYUceHNqKhcgdOHQ27Cm6Y7aUlgMZD419EyGR3fAxDaTUu6acC23x8E7k0Jmge91dQQNd82eRN_DKD7nJRZRGuJ_71HadKoM1AlEoeIxFocw8bmyTrTuaXP68Xr1ohO_UBZqcUsG367PPJjUKT-UZ9vouc1332CgtL03_EkG3FXgi2OiBHQG2TyVci40c2urPltGVjo5dEp4Gx9mQi7eIHCUad5eknvL5I_7hkYKF_WRq_aY297XOSQg8j6ApxrSQqK5ewzhbaPcba9kGdgQ1xjKJ3meGZEl1qGe09uRUewBC5I1hq9lAsSTVVmds7VueGh3fDrgGuOHS7yBmOuAu31-jcP8RRpf7MChirsWCTtdgGnEy2MQ2i17madvJRLjpnXjGpi29aIwQPEAmc25Cas5G9tXuijsOahPNUh-DcNmXup-Qb2iaOAbzrYYe_vdPufB3mIsw1z8sX8pLJ2O1-r0pt7FgDcanbbkq-UF_EUrEHvHxjyRuojEtCqUw5t3bvxHxmRSwz6ifTgoE0zvrlEQoCAW2kiyOjVisDpEpllNjwClPWfxg9p5naQ6Vu_qrc8KbDjJtGXW1jXvII29wsUHQj82zvzBnjdBNboPSNPRv_yzz2iImSkfZ0rXfgQT8Bp7NhhdBIb-7WkbOK1AhuTjWaMOj5Hca4_KG77TVKCthWXT8um6-3fz-V4fHA_--eRf6eElj4Kan5VCVk04XnEre-PzxqxUj-BLKHPnMz0FExlUoNgHVVLenEdNQVNGXbdRMtPxTRWgBHEsu20BpwHmlrdPfxqUaAhVVy3yzVf2pmKmaOeOJphm7ymSfYlq4wWXmMHGysFslssfRkNU-jUKDHzrC5V208kh9huvkBLZrZx_hGw8tLXN7-MxuqXihneg0MfzCZDipdSC2OKkOccXZArvdc3qtELkO5bMlk6CXyztdHeaDhaPFUXfIDJyw3Yi2cItYcmh2v_QP7e4swa53FYrqk6Z_YZM2TRV2Nva0O6QVt_Hka__GRaPR3Xj0x4luxbxMGEwmODTs2GfkItzKmL_l4_4pDlfGRX2-LGb9WvSwlYLZAP9TOPP0dkPjz5WUnWSY8iIQmCZ1FjoapiuwMl2aGAbT1RM9opvyDNOn2NJIhCtfqzWegfAHAwtT-2pzz8phcLZbAAjsIOV6gucONv-hXMfzPxMdVThtCCwcIBHi3AAbsxBN9oF8f_7Y2LQiWDe2H8cwjYRB6SlMpUzzEWZUT2-2M444jVpoJTSCZMZfrEGJgK03uOG8e1-1ZfMtOY2X5lUdbuRuy13lsHtPwBTaB-VUT-kT9dt750YDzu4Mhd9gBzPT_69fkAAQYfw7iX_RJaXsVNcQbbe75C1ujRF0XzJOvVZQJ_KUeebMfmh4YzzgWdip5WCQzX1iSWL9AFFvdjZNJo0xA4njpdyvUzbhkNgFvAL6gTA6CguThIbuf-4g6uD-K3uL_JtYgkGkyImkR86Wogyz6cXbRmuHMXJ9OJiFHYVdBNVeN__euDqSwr-kSdGplOTRFJHalhEbl3Vxa36YRu1vuSXqECz-ENhE2wIJwJsxnn2sHhGhMzoYDqirBcTTTttl_DdGDiIZNIVT73A5oK2BOe4Wq7Ya56Xlwm98XqRldhRGhGCXM8sQ3YNZ_pm8Ts2vo0y1tDr4Xb66gQ1JtTaH2ieNOFPXTk6lb3W47i4YL-1bIJtBmjP41JwoWd2hGkPP0L50OOR9rjOUAnrm4rFTN6ZWp0mfkh6pZrlJTL3UZ6idQTRrvNQSa1KtB5Af897FzPlhPgP8D_5Tll8wc1vn5G5sKfmF0Jv4FDaATCrF9I8LO_e7DUNAUdzci7K_vHqPodxMI6EGDe3JPYTO1WE6fj0hT9RHFzI9Q3TdL7idLG0_p_21PiwSQyf-L-0elFBK9KzbIqbBzxBDWT6P3pMsplWSoVs5nrHdznEtOIG2-cZ81GI22Oqj9mfNAczFV8HS4vmRQZlaNsxNJOyyTUOs98uE2l-PfqBs2ipsZRv5R3aT-PdNSFbbyig6XhZVyhRmd_tEFhHSIjAkvmS_UmdqxVyxWGByzRDczt4mtmsH1-TXNeIsWCdcnY60QD6MYzJn3kH-SYpV1g9TSCeHKv0FTScwOvoKNl8zoCtTm_VMUEXDxH4IikSdMrA2Is29zREMkVqsiqaFef6LWvGTtCkvzjrPaFd38fZJ6qmjLdT70llLeRKNXM7B_S9o0rv838imY0roZSRfjB4ksXZMYMfliMtWpa539bjpu56dYPJMxiMD6m-IfI3Lq0vd7VdYCgpYWKdA3hW2wb4TUfA31jxRKEZB_hm2melSLyWiAuIDuFk01UwNlYVVP_ZKLuw2QZ2WbghCI-Yx14xik60vk0xN5-OU_kbDqzd7wk672qufjE4GD_fTYONrGtx3xgvS5q3WXP2P2tEH7HURJl5avxJ2iaht3gfn4kXHcHPx1hAbAyNi4mPbgmhAV3HvpK8PyGMFVfLQ7uvV2M9-mTQvWZom4Ezl40PTVRgfHBeSmiCFCYvGY-QpLb8I1bA4gfeveIhIVjmp3CesKKIb9ahdXLOBpW9uwzSKI2Z2MOXfLxqHXghE7m4dCJ_oxns3b9AJ-FicyzCAGQ_q2iGjzB4DpDbIO8nqhDnCDVvi6gFh727ftCeWzzCfMc87Dxo8oIXL7xz8ZDpA-9kPXbJkfYwIyDKJ4ERu8aYq1wDij_UNXGiPY9WRbyObeTtU9kvyNrtftu5INnzNcg2Zq6zGkC3w29g5q8XBRjeMXIppUd2-mBvX0Gg_8oBoxOc-84uI_yq2b7SwX-CF3v9Zu-tx4RmUAJK0jA5WD6xVMld2HJO-2Fk2-2dzRql8r2hIPNjXTeDrXHJStGpkuxqg3uC645AIzz-r6IBHVS-PQL4DdGD6GXtnrTQqzb3laB4-xdRqYvxo1I9z-WvXi1FGhlcnYpW00EwH5obGNALfAUwvRsDziuTT5aRF6qjmVaT_r-wOGAVtNzt2K18BKXNoRk3l2PMa27BVhUqg-UJlrO26JBHYOqylfT8o9vdD2UrSbFAmGoM2XD8MScpjlXBTSObYNhVwXVRuZYa9su9WgR2pI_CGZxOaB5VYXHs8dQdv3f8Dy4LLrVPFdOPZI7OGMlYou6cbvzuEgqjkJ4YI6Eei5bYjoAogEcJ4y_XI9uXBhlonmNq-aYu2kEKgqrTzyhyuRIS_znt7xliTTL_S0zCfkTm_5XS18BjirQz1JZAWWhJoDj_gSWykbyO91A7dkv20s-uMNYxDbIvbirLUkIOm4pJDME2Y6kcvfIch628zRaRKD4MXvCGrQxS2MFRVzcKesqUeP9x3upc_-VgnI9Ns4LDKbHueunluQJFZB7ol79ZFI340ZK8NEJ81uAfRRSFzJEgtW37PH1nvCIlezxx_VSVb8f2o80Ns-HUw6eyXzX2E2xsKIs38uDVInMWSR7lxg1wk7IeydOXwFxbHBxHalDvUmylVYsKgu3RKaaBoLk3EHyk3qxO38W0urAiuAhKN1Sco1rF4POOyz6gGoy1wt7Ke3suwvqFrBKwfZtH3EGT37N70zgLnKXNicClIDS8iLXaOz_-oiK-Zhqz-O-afsI0F2gRYEmh8aNAWiR9TPHMHJn-RzwlifpY91V5Epp7zY4Xbfr-Lt8NuwBsxc2YXh16C2YtNHpYcnSvLbFKMn1f2dmcWArqYopE-ieXD3m0p0cvAhJjeEMEbE2oNhX0l04Po5aQnaTkYvdWZD-bd1jZfpddCAzO7b2UC8Z2Sd8DjNBBnqJGVCYSwaWu5PIHGHEYh6cOd8k2miia3GqfJNIH81Ey-1m6XAnFsM_INR8hGcVZ8x_9iIkw7-HXgCXZfgidaSiNwrQNcS-x22OxYz7aJDRYKZPdHmmwRniPcokUi4XgOBkl7XmCdcEPtNtwgYbhZd7BzXo5OwzDe6ZZ6Ov7pE9CQ4XlfEYCAh4v98IYuVItX-VD62hjefBh0QnBV4ilyVR-FVvMnKuuYV6s4sViAw0qjY6AoIilC2PHnfRpf_ZbhlIws8Q_dnk2HeVdl6s9DY6nbq78Cfuuon8E7oz65gn6einX85uZcoXIydbkdAqa3VNMTJEzxG3CzMATYOPTD7n8OSzIe1LZA1X4Zx5WrsrEG8R2vU39DZxX1bh8-2qpxQsXpaiwStNal2DuEGo3uGhR2VRaayfuqsop7Fj1usyGGOx4ZFXQ1hmrosGQTmEImCX8IAA2E2OJLIJ73av9RNij0Vj_2bwMtUrNKZ5mcOq6YE2xyeDNP5P8B7eNoY_wpreEKS4-0KkkE2t5nyBxfECJFj22LRi6GrbnFstACXVP_inQN5THjfUroCcquUyJQ4016RFXuYUvTusR9FFoAQcFurX-N1X2JJcJlxa1fwLsX4ZB3l0mvUVTx8nsNAUz3VOxmwwdNIaRkEdNb9YTdKxShcwACLYfVkp2gUU5eculTEwOcUR9E1GAUTSk-lKsqMnoqsQ1UjZuxywqfq_j_Jcz2rg4UXfuELWqhBEIb42sk-wWSJwh4-3o8tEFVC775uUV5ZxzGQtaWHb3-qATrUdYRhlE3am1ClfI61HkenlfFlGBrwXB8za3ttCZLlLWX_HMp-XdSoSAYf1P3IZKXsN6XQMoXenoZ9wT1n-sy75xhzHxaClxeJp_hNQJNj3ixHwIlwYuZB3O3o5eCM-D0mPUSzIkQr2LvZzgw0Yz1VtHIzr7xkGkmrlSaYPpxJ_qWmSgxZp1swmxP5Nwpbcb4xXspiU_0lgxiVTXQjfzWGoI40_ujpTsG7fTyO-_3CYo65jCRqEJNB_1NjRw83j_rFYWngzx7R1iyhCuccX1hJoFq-mSS-0srCHl3iEiBaCjcDpWmk4vvT07-LhsOcsgKJ3iv5EhRvPifLS8Lt5ij-oEg4AiJIQf3-v6_-gie12XmmGGZ4FrlEaAt0Qe3-Hdr9kLwWDKTwGk4wtwvbHN90LqF3ec-41JzI3skg0NuufOkbpvbC7PCmBqu_WgOS3As7MANkj7LFNAypXrh6hXg_IeYjCsLYH-IqKVJxFCsfzHKo-baH-j_z1twShL_1JW5DkozojTr8IdbeAyyLFGiPS_T_ubYXs5wa36o7OLA_Af4ILuGlWVTRVtbXxlUOhqjf61TsuH3FJxVNUW8KqUihy2CS9hEWJvddTpk36gLcomGTEbuY4bwM8PmnQVoTnAtMp2OT_0GefsbSKKWdnaflkgYm-KS9GvPEMOE5Xr1b7jFx1TLcfB5bwmRYV4tx8s0N0BlSJfObB7ob2BykuveiGWjPcT4XULOjpnG7eage0u0XpyCkldlihuvqweCCl4MhcBmYX538US4OJOecXD57unWXcI7V2iBPFFGPQg4JBDw2wcUSyqmCHhJHfotPrhGrt6qC6UhhAYHXTBEsAJ1IAzJWkv6kHdVn0cev2o5XfJJibO8pEab21x1djJ5HXi_cW5ijjM_D_JYvs0t5pUE7nkOK5_CBDaABOSUzZUossy5Gz3J6DWIlBbWyStta2iGtCKqv7PAb-wxUK9Y7VdCnng5QwHB0x9SRWyN5FWbmDDma-xyHo5A_76ax7_nrByra7FD0j7pUWCipRMW0nf7haX11s4JjWepQujDMBCpUhn2DHPnfEPeW5H1nn1fx01NVFT9IBa3b581PSOQ2Y1McjORrhQxguO7f69HaOU6GT6y1UK70zfnwKUllZLPX71GTK0qdq5BfTmHmizBSE-KRCkxK8Tdw5C5BPSB4Szjbb9HjC7mmyKJDR65spCP-iLLYoi7xWdVFyI3UjSSQ_Y55Us3eOV9IhzViMklxWrgzlfhJjNtj7NnTgwpk6KiWgoMCGPBMkol7UUBUnxQZJSwg8CKrzcOhA7flv-EmxpXGU26NN4FeiMgcq4FFfNoQKmZKIfnyCOXSKrHjhiyUmsKjZAOfv0NZJtppUQAm5g6dkOQMe0q-VhlejGDCVsDzyJVqQMcT5mDUq__0uFaaYZeqFrM6UaOaNhToupFrgRPYhMSeVPEcVlFkgq75hJ9Mw8twNI9xO9RYmAHPMowjb29FUZR1XTls7I1xbG9Au4R2AOMVP-5-CWn_YYCXPsw2wF4Uljvi9eka-IU4X-KuNbc0_NQmCeq2FUCrUnOPAbfhHh6b48ebCs-R68GkcaVQ410O1lsEd_GIX3aEsVhFzkjOvx0JLFm7ZWZ5QjdbwhObIRlkABvMA2_7ZG1qN4MjkFY3KAgz68ouX91uUQznVrvDTUacMokYxGJKy8jVmvxkH-svwdAi-fL8NA3yyaN4UzKPNbQnKdmc_Yr_vJ6s2l2YRVig46d2iYK9L_YXcHjhzF2e8bgWgbeksax8GJbIF6W7porAljto_ALueu8MlfhQq_MrgWWW_O9Qk5P-AvS3BZyo5cJW7US-e7-ld_ICe3c_JZZij5sNzYBvxVcndXElpRmtUrkmpOuWsDEjLItIA9Q7UOHlvetivm1raNktX6RIGacwpVlryXqrEANDnkKX1dZXF7QXc-I-IE8L2jJsl_zDskzIry-rJxWJ44iOOo8deAAPSOpa9DnPbNDMq_07bygXHDp3Ho5PizDDrOGPF2ttFD7pAZeHXA-Bo9unJPYTDFACW4XUfaI7JqzgYuvw9otya5S4whNnTe4pcVAZ3AkoWhDjPYhFdwH0XNhM8fs2sdBmN2OwZN4bHQSZkQRZV8qivu4nGed-rhdrRSc18y0Q-dAg2cUUhYexJ3m2k1rp8ReV-B1-6T-OuhEI1uXaZgZ-XLzaetyruIpU16QV7R7knvCv-hsKpmg0bMZIycmiYcHn3WYZlJGf3Vz7WhY2895ssFLhSAEPs8EJNQ-zBhPcOE0VDPWtw3Rvoaa5rF2Wd1BOJcsgtWLleCjtzfQSZIWb50S3UdEqy9TXrwTl-l1YmHYU1oVDzFDS1oGFT4_7EdfwvVbbeiRy3-zawOdvkfGMG5sjeWSpkeXvGzVKCCOuETK8tryQM346A0xtTdUPeZh1NOrnyRIHAY7ctcMTQSC_N-Y-nJbZDH1Xl0VBGN0umuxfNMkvb0QeOo1w5GTJ4q7sgJsjBPSLSPRpVLap7L78m-t2DLhNabExnXqEL3Vcd6DsZ3uvcA0Q1Siq-fSapYngG0SgyfY1tHtSWEGYcAlX_hPbOXknnF9R4nlnyfiIDvrgcWOEspL2W8Qe6FkMP-d3XK7CQ7RMFUOWF6F-fLbdzWOdzpdiDSVoOwEe9OKNkQGTeK-iceEqb2HvPLTF1Rv4jLdyPyk32DHXPXCJg0iqokuJCol07T5UW4NA4ob7Sb75uASSdsn90k5ZSrUTNL7aTWhg8OhYIWyq19S6Sj2ZtYg845iaGuzefzGMe68DC6Q1xwjyR5IQ3pOUVJZpObKiF_4Ggnsocfckzoas4oSlmGj2LlRNJs7qhAvu8rXKsY0hErkePRmAtwG6S1gNAMuG5_VFtw6mRQRpSo22l_vIRN8bOPmsiN--lpcrtrkTnxE71ICycbCQkAJG56JAuHEOX9R5GOxpdJE-5Bl6z_w9OzF7q_W3udv-OdR-RCpLK0LNgDcI20hBbTy41d4-jD0P3SWyhU5x97T3kG2uu9iCoQOE970JnljYf1KbkKVOcO-rYgqJDIR6zjJ3dm5pT9t7ckOO7YexNgFgZ3krczVViic0TVCPIxtsgNP7ysELVMb7azFrWbsNeOuSXrJmlTWq98y2QHH1G-zXEN2PsqI_4i_zIK0MQBGbMu9UjNOTQ_C21wZ_Y0WU3nZJ4P2zpBZg_NKeVbwc5aN6MPtt4DVNshyfM0aqP9a3ogjOMtmPe9EqqBTJ1sI68mN6sAEOY8u0YQJ9wgdCgDSuZUNIjPvP6sH9SE6bhm0pxV_xUqaEXBBamDKurzz16OLSGtJ7F1ZpIc4DqWMU6jaBtY7C5CjGhiUKBx0OUSiWzEoTHNOV0Fk2Pa1vJxJBv7Tz2Wg8KMtu64GMrJnCq9QEvL2rKAxSyo1-_cts_R9qvdbF9A2sXeAptmXxRUMQNtcpsAQ68Zy0VZ80lXfKCp0MkRdYVJ0DrpbkJlqNeP_giQBDrHw8eT7cTfc7QD6MalYYwDe6xZSVkqHQV_dVKZYmthsaBV7WZde-2U416-0voOdAGqE5IzvornolrVLK0JUVZ3LOsCSgN3QjrEeCvfM4SFERcOP7sAMdxij19g4jn6kNQxByo3Q1rlOn-47yI7szWqeH61rbOXd2RUZLXekDb1lXNjbUkbEzHrgT3FDP0P4KdaRGt0FDukcX5ZTGNwIZWJngTUvpLR1Rx-9grICR3PvqZ1vTNfmNt3CXlyEpHLPRL1cxFixV9WNLH1HYoydY-UgxbH_7cgKqr5zBtCtiTwl0I7yNx5iimmjJ8PSxhLHDRYwVfAj9XI6Zy8iNwifBn4FmTcuKcYUbyhDfetsrPdt4juwp1DzubwT5yUGmep3aJXJE8DTjneu2ZCiGNKTT1NnoTWsK8dMsGTUJ1tyFPAYdIbp4oS2BhqHZrA0dVcLyB5wUpkXaK-lVJvHlF5fzcBQJpM5bJcayzOf22PvIJPlN-J6kOWmuM8iHcqBFU1ZcEDlKDELHlHx6B-_ltS9F1F66nx9uVRBRETuwe0M9MRsIJI0VmLHbtxf98xFseDJ3GBJODU25B7w_iFiigG29fJQTuEUonveRtNZgnlFd62cg-jS1R82e2_efk8K_cvg5-xa47OklnN8bSSth9nZDr7TvMJejbs5Cc-980aHjA7w3J9dQWrC-YWSJFVFBn4fGalZtsDToQy4jPfhqxRUsbjxSxzrxWrEF_IprortHNAZx1d9UpgUHgbzGOTAKZYrV5ooGNtlRoO0UZ_2BKSywElX7MaBCkJ06tNXFoQShqmP8Z324wX_HdddQ-vOKg-TDIghtpOBQvVqnyawYcbhwoe9NkvOY4sVa_m4mgKoozkN1onXAOUMqIURB-WUsMMLtD9s8KBwoSaN_DmUkb_nkH2gqOaCKcSKNaAUhdJ5OFXsmru69BXI92_ovguO3kdFVIwwypAoBfkIHteVrB7VAsYXgLjI5vRV75Tcfx2yFLvY4J24QCBikS-lMvuCq-rjGSqLhEbOYtyY3nxEQSaxJqQGeMlL5kd-0jNw6sZbdl6WGB7TFflZDAPQ9ugp7J_vpmO8sP5o1iXzI56-PK2mAOgWMybT2-r_Dbwrj8NL_-cFEF4j7piYnq-g7DMm7HdsqJxbyj56OhP3vXKeeOsZsT0teDnbgZ2Xpmgo92NgCSLOIxNU8dzEqP6OeCDOE0KBLO1j53bRJ_OIEbTsGwcQzfMEdrx-jjHOM0bldw2MDR5WUIke1nYqOWWWtN4hMkmtcbZKfPfEHEA5dJ6RsRvl46P6F6TpYv5leBRgUFKHcw3hLvkW2aqwsviyVj7gm5WtxZ9vLy_3r6ZpZ9D6V51RebzsUVMSO8Pgw9vha51adoI3f0jKbYLV7W6F_wpvaSor8KYlZdOaRTKO79R7QKuM0vpJMCHLTXtuRPiMDpf8qpcTxEkW5WK1RRx6f64flRSedIkWUtNcbOVejWLk8aDRQsLaCTW0bp1argX5M8LASyGscOwWyzf0FzQzWKP2FSJKa9XBJ4yQxtheuCSYiJJ898c1bem-UykrJlrHp0AmgXsbRlW0urqlsPDmeiUQHpam-b8APhpq_2q3Gl1ba0Cs42-61CrEZGHctXJfGprO2XYp9o1SLorSOB750K5tDb-o5kiVcwHIoAM5XBKYR3U9tmbSUyoSxt3KouZNM0ylb_2mp-jntWirRKG_ojFJYewqIpON4BDKw8qaV-Fu4giJ5xhjnIzasLwlNRIgBY_CUoKSyVrGanGP1PfA7C6fhOUzkb2G9XTmo9OKi1heD_Aj3WGfb4bBaLY2CGRcTPW8jl6Cl73_piV1bpJRYl0agU4hcxvy_ziVgj7xQ7nmpWPQyB2hcBZrDvNHviiS7q9Bl3v826MVgkcT1CrcVxvXD9_CEZeNjYnXiqBxCQPVVs2V8T4NdQ8ld3r2DXCjaXXO00ICa8sNEofh5Tc6TMqFpX3CphwVem8hX3KdpPzSGnWz90BQe81d2ugZCmYb2asvJlOcdnUbfo9sfpalIkJYLDFJRjOYGu3NHT6cdn7d4B9s06SrsPUMxtLuFfL0y5gZdzS5xLOmatU4DB_A8cgKSlqARH0FDSbwjeC5RYY5T_y1lFinWptvI9P7NPQ7r52J4AsDsUiS_WK6wYzV0QYTV80aMX4M_Mfkh8iowxQ6-aZ5_krxj0W8zN3T1jCeT30dlMrPh5NYTJUNi65bRAvuhLkgd_JCKX_HmYiyjt-TcztJn-Q1LSnlkIofkozX20TTUi5b1WLZUTtQB8oejz2xyDL7HhU5uF0IfqdzUiUvhl3axJVTsPFzyKoewaRvfYKNRgDicbOtE_Tvj6uqrHV_PY6xRiyW64c3Q6fu3yZzdjSKgNQQ-UuV0Cdl6RGacdBSW6B145JBv3eVSmMPFFK2DEVj-GZFUtx84wx7D8gZgQsFDtQSVdmN0kKrksnKq7tbMsHQizLH1F5KAWEg7djDtPU2SeIntcUFIsbha93mN3v8Mh9qO0AjxNX9Ly7WdrlS8W0Ms2TcbP63My4mAl7cyIQTwpb-CNBzJi6Hieg7KrLnMXGBRjQhHlcEcn1wJ7Vg1Lk3sTsuwEAW999eZthS7J-NSjCsIiKt9-Ihp_zNmILrUjJ_bRtdijDqEchv2Tsqe15M2lySdkv8nI2qCefDTnqpjA5O3-0LY5dlrEmmHdEqVndgXXjV3r2tA3f8Rxkdf0c-9s3sCAoZZWendnWUBhm7I0oe7CaiQLZ_eraaCL_ljd8VnaDaAbOg-3qMAMcsXOMhKehoDP0HU0eyGRPOE2n2zDrW6nLjfl_7LTxYo1oKIe5a03WxbtuT272A5XKsXqRQB6CTQMpoAFTBXzlk9d1W4g1ZelNx4oOtqyHb1bASCXZqaGQN_MI_9Q7wnBkzpnETkgSMZyOv41LGNsTX9JRwoTeQGE_FadsjgtV9ijMzoKrSXX3fR-HMfYUhYXH27jNd7I8LwpwrhdPvuFVG4PJ8Q6lwNbWuDMtJH0dktwgyAA74C6-7aW6dw7GTGg4BkFTP-tmttmOZvOUVQ8VutyznrFrj679SJulgYGMF9fz_zpAFWZEsTJH42THw3M60_AzIEz2-6q4-yow2Wx8XNL0wkPi-C0xcH-Og1Xd79JWY2b3e9jnkdZkhVLDyrMagKe7NQE_I22U2mP0oEG2OzbhgAQQVxvTPqHzPCXJGnq67zN9r6uWu0yCdrTQC_XE9f8m9nZpuW-BW1B18_PBPjLFBQ9whPzye8emZA8HVV0wnukzzALr3uEri-4vCn-VtOXCuFazBFyckELy7YUONgN71tvooCL2lwkeh9qJZdX4KFJykALNpqUON-iGSfRVLpeRzfPaF2XeDhVgxiTA3HK_5e_vVEtsT0YoHJKANcM4CwIDtfqqXrYgOGOVYgJ4TkGYIKeSHDOePEKDP5uAurS-LVnTZuSW0B-hPpoj4LtCC38PD5Lfs5Xn6F8ZqcN9N-M4g_Dqef8oPyJ82NEEdeVqKPbRXBE2Eq-OKvYtV6X7KooZGvsga2zeN1plom6fz64Nbv9Mr2jyFJsujLiPGM4cNU1r3Jvp_dQKk-yVFrPyjxhacus5ndN3Nwn6qcw4UdyVTwtm_P9X2NNPcFx7rYETIK575Capd_hxL8rUs9FHu2owNf_tQ8u51jzsUAR7QXN7Wy4Nv5WZRlO0dtw-jvJzo6dY9kl8poIRP6Q0KE6C8oMswWJ24eHkA0CWRE5Aue7_fMDw_wtoYXDVygoz_dFpGeCPzySiNTVA8aCHgO2NSd48CfN37wS-Y9csuAF3ekAL0XlpSCX1eMULG6IEonvkbVaUvI6R83D0cDcEqSe-5yILw-rpn9p8r6MzsjuksaKziYuAx1xIx-WVqO4WPK8Hcv_3RyPhtWlasJXEdJNsbbZTSENf5oN4R8AO8eIXVE0VRzkFYkRdksIIZeJuzKPgqo4qZ9Ga_4CiuSO9-dhe9bX02fo4HDG6OjskZRApGQUJkPaktHBWwDzPqO0WftjpF021F2Mf0MWc84mP80swfmyHyAnoQ-Sc5QmKhVs9sJuvAAZ5Zklo41YxlKdM4gN8mOeosWEkKEsyndwJdn47yexlZHS3AyN4pO5hY04Qh8-CJSlk0zAV33GQPiXjkkI_lmnaWCS5XtN3x7fC54EW7InZ-hpPgaO78KCl3dpTziYCEJZUHe-kIXR2Pt_Ql1I4ApZ2kkmsj7GCHGekyUCTJaXyltjku-lJEhhlHZKflbqd-FUGzmZamg3lE30_D6d5zwq4ZPhhtVKL2h9jsDDORUItaCOq_qBNpAmsOiagBi0Brmgpa5SNppeY1m9_gXymKgKZgD4WCz0gM80Ek0mYJLDT2gR1ukvN1QI3GQxkUs3mgY7gRB1nY7sj3BT2nheGPJsOO7bwf11FRkls0QM6iIAGL9xI80-0a9t8g70Yj_3cVUgfpQZ7_FVkMIj3E6lZc5fixaXKp0rmBbLp-DanPoM6pxoyOsRSPLf8MtYD9h89ZWnNwy_HAJg91waMp6IVEI2yGY59Zws7EgvM6pc9vWpesqnGL0mGmnX9wi25RNkxRLeY5MSSbug8YnaJoAQwVkpV70VzMS79-jMYIJLBf3m_vwyv6tHNod3Y4wAJh9VGueNPXthba6plw0Ktbqj-xLvHdHyQWcAzarg3SJBvPMY0of9EPQTeVy8IvIZsDCn71QiHpnEXa4IygxqWvpvv4BEtJ2NpbNMQN1BiKrSbFTDnRfUc-YPl8j-x6VV2G9Ce7HZ8xtOiF2WWodFjDky4IvCrrxPLYLFPr6DyLoeeyjZCvUUhk9quI7Za_FI7sd6mVhLIREsmybgOIl7EghreDTIpg5Jmq-W4P--JtHGL1LLfQ_3J5e48Q_fqwZRlcOyYkANUnGffmNIY8WmlJUSPmFlr5ukeORbsb55YGqnKeV_SBInH5omwlHnr3mTQs9yqCyn11F-PUVsjNFsQPg3RPGTYP_r9SSGx9zYfyoZzFXpd72KteGJQunEHAz3feQ3Um92QI2TGa0vwMmN6JmePUCIgkaqxq0PeXKjwIFWqTmm6ZbUgSdh1l2teVK729k2p5vMn3oGyItcnZr0dtImqk5F9E31a8dhHG0smwsoISs75weQHujYlCpa0otSnWf2wQ4NUANYuH_WNMZvbRTv66Do-ybwlUJ-LgrP7GF8ME2xE-FYjjnEJgnb6y-0GHxf1Md7ZEtjXphR9vA56LaFtWXgqk4ePI5IFca_tJPBWBuGx5A5KLpFClAsG2ZpHwFcFPeBG7At-mpdDc5BleM0guEx2ifYaKeA6PDc-AMREQodX-kVWUgczB0A2ZiaM-l7lU1NsM6rxyrD-PwQA21Xs8UStU6L2vO8NdSr3jsmEV8jABEPFIsiiY1fbFv1N7NbTuHYpabJrMUvcy8i9uSmImkrLxdF-iNcqcvkvdi7QuEgMP3nA1pGGcX6BWa8SwPUXtYUGFwFYxaNWTvQl5o3g0FXfFj-HfJPCFl4jNJWnvZIwzWOlq3WF4F_sUgOXq2hYNM_nvAXoS8V6AVO5nepJkxKLE8Tt5kMf3G-KTYcO-foEUR-W6gXLak6lmCGHkBFv0obAE-bBqFade5YDdqQwqLXl4l1EwD27eqsEj7w8QsSgN8_w3ReP6sTnArv57m7k_D_1zJTf_TKXkxbeQlnZU2UKfHw0vtqoQojzQjDHQ6GPJhcI7CMj9ReAs9rbzB9_R6pGmMwa0YX2Ik1JYjY_fG6fPBT0-NtdkhvXHpnRlzzog22bIH2TqSFukE5f1nUKdOBp-ZlHG4BtDopeEiHDVtMT5m_zP1bxa8-Ez-4lttu3PAnQ93KiqMbsMJD2bSZH8PKk1ii2V8YEJnIGcvwUUhgfY0fnxjM8B2x7qY2MuMStDrjhxoFLpYlSCM8CGBMAll7Voct_uNQOvG7u-CdrCYvE_ijykx4A3HHhVLl8bdpor-BdcPsvpuaJF3koRy-PHMA4rigZMyrhyj7MNOaKwlL_EgXf4ReZvCBB5_uGI4Y_CAcW5gCtQL5zQkTd4b2OPraqT4ZZI9xFUOylKQs2Sdp_pQ3SGxgPyb_uAwK_HkEMpO2GI4vWJP0VYURh5iXmZ7CedXy1j-r2OB5JLp31MCtIJY6ZyXWFFbRaUE1-sQGxIFZfPfk9dOV1Q1nzIXKlQn8ixkhAFoG2AMTofqMuncCCtKkRJdOEOKCEdt4ytxfyYgC-W3-BIYz7kkv3vz5nJXhr9hWdN9D-5CQjq4b27P2MkkfV_7wKrYMUUZWh2TOf95EZe_LAnEI3U4xzk7_xdX3sxHrld4f5mUY4HHwSEMV5hOWNXvCBTqjt29_z2nR3UWPKuYIA8D9G_LDrCXrpTTohF3fHjm9nLl5tQwXdl2nW45Ia5MQotzw9Uc7vB6q-OXqzgRaXDnrhiwuLqXPyDI1o6l0VyD9QECpDpMTghDaFCtBA4CSAzXiUp4in3V582wGtA2sHEU5PpDqqM9ReNqksRKXSqOYDGvTxxbXxKBiFgFD0l2TCYd8UQg1u2ZP3fjwwHfREFfwlmP8w1brQdQMlU9gLF2STHPi4S68vpTfj_81HIS2Y-vY4YzJltQYKDOTW8F0qPoWD6VFMBFJH5aDRxSdRnbRBfSARjPSZchOx-1F9PVVPLyi45CYw9ZNoRs8XQooRbcu1muKiarqedNkQhADDLGMlc2nevoJmkDVyqmOJsiSrSFgvyp6GfudKrETPjUTNNHeSJfNVMCVKkXKVK659OexgFy9Z4ni76-cXeMS1H4_qeCeyzPjHW67Zg7Yl3P5-aIWXAjz6ByAE5pYV9wk7gpmIPkF65Mj651X3lVGjTa-MiwH5kD9NFSznrQXcjcQlOElWvvxfryN2hDfQbr5L6Vd_SXAvomr_WU5phQbdeVwga1aXNIwvb-uUSbjNUDksBAIphwp0XGcj44WHuqyH8Ze3hL1mk9IG5j1ApXamvVGXabTt9GHrfYt4gl_ye-wTttNdBwaIOj2FvRSuE5EfYqUUhfhx4Q7EuFdn8Do2YOD58h5-R3u0O8TAXpaRE3HJ2AWOyOKxd3q4tduyESSH1v0qDlzByYO97__cuGk5c12ybc6iYuK0PqD3ot5KPb8K6IL_IqmwPouqAACXurnGN1EDgMhuP_m6veLdfettZtfdHKHDnbbvIp1UqAj6as58TJrgAvgS1pGL6BtYlxox7_KCRPdsq7JQPo9sw0fT8jzMcpmtuoZ76gjeFpXiW1jzAmxjAKced1adgXTC_IEyQXh3owk7CCVNjTKq1BJv3JhVkPlgm6Qz1GKRnUn9xuK_pt_K84viJVT5Yex4JnFP1PZLheCsSEalsOWneIhXOQ_u55LLnss2M3WWucQ6ktp2hw1FxEnkUx7KYfjKmC0a1OhGdvYOIS7GNL7u5yQ7qCO6Xl6okzD5raZTcsSB4OQe02SC9DeKtiyOSgyhZ7unhmf4TCm7T_WxVyobcT5C9HOx9xgwSKgN1-pESmWt_sXTHSN5W2UXtz9Dcpx1gbXxvHGIsJ3Smo67r0SyPu6pnrEpZBgkV1eKbmnWYMbrTNXgYLfx2dnuDEkNzlLDeQnxQ99yRfo59flJSLD38DhMNFhB7_j-cAwpHnCJkpoiRPVmTPKPXVTimzRsu5dVWH6-lkV6AeW0VCnBtPKU17DmbXIN1hqtqy4J42z6wOwDNlGwLxlXtiic7U4MhI7VLj2ckelNr8Zkv4DD31X43mA-IabimP7IVGXovKMpVDrT7vYT-rcxQAsORBZfnZPbuFUDem2rJFwkrYPmx6N-n4u4u1hP_kvwn29CJgNHQ67XNeYNvvGESssVFo3biL5Bcmcycd3tlfMD13QHPy1vXBGi3cbG5G-lkke3ErsyOngwtxq0oqVyIKp3-k3jgStAgVQ5oolJrdwmTbOIP2R_Nb_qXCHzfCTuT8NR12ZRxp4rtuB7zva8G-RThOlksTcWq3DUWUpnZzG4jTekPRFPvqTtIEiGCxAHQ2GzFtbvPKvrfJnC6EztieLs9VSSkC-Ocg_gSjgUwlAv5MJy9_Z7b8yx4KKpXyynShZX_zgNMWYJSevwhuCpZ37RfiGlZcm8PjJZC2afjhNaD-jpqRz7tgMH4TDSlOuiV14pw0cF8AlY-HvySiJEg7McMRdxAgpwIOZbFNj8Th7P08_RKYR-QHieqCr1i1Q9QwOzh1TO89KdDB-iO_L13A7x6EK9QYup3wPGlZaRAn_CSMb1jmMwJhez9S9m8_Gw-TRiY8Vd4HVT84Avv9CL3CsbuvouX8ufALajcFXeytov5f-VUexQm1K0t8DiRVbczGr5TSGlY0GcSRieD_1ty1B0pOXmaZRTa_S_RyVFpFxI5tU1aqclbzyZNKtVKHpK_fZYlwTOYUKDLCqF8XqaqGjZAtY9--MmKKgs4s23beJKKjLx96wrgWT6B2FeZkRl0KDskS8yd-JHlyqmOY4RhuNEvCMuNLNfJgdm-L5_jrw5ZcHpUcjNyufwlga9eZ1YFKppF9oSx2mIVzKlGipG-gq8PriHydAQ9b58p6O6_DDH_suxZ83raU0Lgm5Fe18PKpcMZhYDjmqWKq57unWa2UJm1AqQTcWsk4CdX3gPYIcdoIv5rJ1R06g_BD9X5j_xooZyy8jslfBIrfUM72MCyvD5AVuW4OGEyT6O9aXewxCSRWPIV22U4y8CCj6ZMhReqq4bFQnVs0rB_J6OUAAKa5rh0BEmr05u7wP7_uXXy9xTV4fk4Bbu4myFiev1NVWEIK6j1j2J2ytI4deOIrcgy6LSW5ldA__4v5JwWaF5QCLtQwMQ3OdjGdDWNAvv5_8MmlCL7P-IUj49HpVUpDNvXT6BRU_z7M2SS8srcZO2cqNTSyv2Bh5fzWErJY56wakpryOu0OXef18oWbUVVeOj05lhaKAyCKvFcLecBaLKg3-Bv_MJP40CC3RClsFzXQ2UhIyCw2VZbz6cz1co4qqHmeG7CX4DVPCnrqabGPnMZVZeMNNz9C4_qSvJjZaOEaxaFeJJL0fmnOe7qbqBWHzvdNsE8mc_YEdGHBvVRtSn4yK_b0IaDoAxIoI8r6gs0sLhN-btGW7hfK8ThlCWX9nHisURyJEMjTlZGPpAov2gAudNFUg7wr-iRrs_7n01n7zc15xrUO9Q4uIBfBdddP3nXiZO7PHLWoC0TnT3Z7eGDQtn2L6uWDdB1evfPqW8uFHrsTVr-e4H_4duZaWyY44QOATeEgJMBsFICvGtx5vezKNnu5ZEFG-EI79DnMULFpC_NCabURXZL-zrtopjZ_wG9ObYdqsqh12nQ5ygNAj4jp1d3uAJxjgWtedm-yGaCfDFBxBWSgyvIqmV_KtG5aSyeTRD58oNTFfnjYlojAHtHXU0d35XREoUOtGSiIR-RODjLnsFxM1kEzdsnyRGDiMsTnoPx1A0jfsKSgFf0TYi7sCLN7pxKLbVXICD32d0M4IVceMdnu05560rP6pFI-TUbpLBfD4PfJe46ZwLrkDjdxQkhX2UYTn0QCyNHStlFgxLfCShxcIg0bkQ8XlIAGggNDAaFMC4yKwNMkW4Lb8fIKTKpqa3Mz4lrCmMNLK5DLV4B7-luQ6heYwaoTSx4l2lrOL4uQ_FB6VVpyvVR3sLujOGZTcNXCTLB3hzESUoklK6shnD9BXJXyWzmgfaJb0m3jeDeLakM7lhFZ7x2cAEfuGO1Equx7NirND0tqoa9oeHkqlMam4w-3mJqbgmn9rpQz1QPG5Jr486PMEqZTghMdWhW0pgChGrORPnIy6BQLBEHxFUMcwNx-Mt6x8EROJZeVrXzKysyIA9rJMODOCmIYdq4q0hjRlHyj2oE90dwFr1B2Mr1SX3QWAscL0pjTe_ycsc2mj3sV2DgSmGNL116CEsVaGLy2FTXTsJmjmzXYlk02WCeUCMVySCcFFL5RRQbMh0fegWCbTqIGFFuXk2DLNW6bcZ94wPVxzJSeJf2mO_UGl1Mht2VXZEsPwsT3zpBEkslhNokOqZmY7PHuWk4lVjvo3Amr7tPwkDX3kJuqpDB2fhogfZ_7tex1c_EF1YmRwRt9Zq_-fWOmsDM13ZdNJn6SKnegL_dHpVAUbP5b1ukIoFUUlRL5R-qT-8A_lVEYZlAprkgnuEDrJuyRErVwEO72kHWoY-lRLkPqhUstXa9AndjWwaryUKfgzGYONkGg5Ossq-We0f_zGxivDE1VgbcAS-urEDdT0SoqJ-6E5G9nKx8HdhAAfAX39c2pVGxgBZPiGp9rErymBPvk00fer-hajWg4RzjTYiP_I85WQhoPQRMs1-prn53BqIh9p3ApPEMufjn_FwctnK2RDK6vIhiYNHKl7a7tri1VQSeKESO8_SShd12bpxuWhSr3qKy4rxuogUPWOrksLwQvisnJvfPM_huNMsWg_D07Z3N1dWncYHvFp8q45oEPjy1hsnUjDX15rGRXDqzjlglt2jHsjdt4dRN_lP21ESmX6RVSl33dMvHhXQ75Ts2TbmyFc0wksTsJ5KHzuBShKLfrmNSUkdhKfimdpQdoENV41fjwJnpnusN4gVljg2RO6ux5yMZcaaL1vr8fedWmPsC5N84YW7QQDAbusZOAbCt9wWX8syLtNBFz9lCzkKQNG4cJGq4675HUNcaA0Rt96tfYoW46ZelMWUjjNBFhxaprMWU0qSyJ3djc8FZwg97hLYMjyoX-43oCvzm6yO-w_nq6piH1V6DmCHFcXoHaohLnfRmSktfNNYL8ZjE6xctuOJn3TD0yTh--79JttipLTauhBHNEVGb6ADuTI-AengqFPdfTiCILFlBe8wMzwo1Zq3HRp6Z-TebUf7Ds2GsxOmMlB353JB1yEWnC6gMEW0HGL5tXNhrIijqwyQUhQ1yU5E1QA4p7FiDosuRTVVIbutfcuol9ahE9jZWDaggILgKLohfsXyFMVk6b9hmft49vwkl7RTRp_QEPUINi21kasQTY3RzT-qWj96CnH6g-7WdyrBj8ITlLg6J3kRF62b6Lkj-c3cduTWwKSLu4nNHkipTN0iaJs1S-aL4i_KSKvL5o4AUj-AIjd6yvBUt0ymOmYv22tHTb2fc-Jg9iqISJ-3py0kzZT7yC_p7V_H0k05jxagNoZAwUwh4Xv0UmqqiBg-_sfBV0FpXqW92udxNE6jUNO5EF_oxDFXdmVkaS0JzfWuWFEsVJgilrio1pIdKjETaKrI3uL9rL5LryIS8NmfUcS_a2-0JM__3co0NNd1EZBF4hwRqoS6ie1AWJ29dJ3fj6PMjnH8e_fB4f7WagG13S0DJAjTaGaPDnMnaMbtel4XXzGaCAiScSx0LEMcAloUUdQ2RB-TlGWqfl8QLd1P2gkeT4QplpEqHLaj13NxELW_NBNy1nWt4AIKnDMtGxPpK4GYKUqkM8PgzcEuUSxSwEPGjcnT8wijbHXj7GkXvXcgQpveVY64baMnVYy0qB7B0KwUhFqyVnYUQD5XOpEy4VRn9PUqL23et_1y1wnY0sVRKmtFTHxd0w3IIebNphh_Sp1G-v2kh65znokIPd6NQZkT8dwOprTvAgY8jqowMNWyAnMh2SryGhSY2r8W-QTQuuQABzXENHpUmePKXR-yZptl89eedRIznUbSsAUgfuFDuUyonf4bCqD-7_Tsmc1vJztG2RLKgM3khDUJRgVfjsGvZjjWBRnkySvy2bcG0qxIDiDRQKeKWlNRsbU6Or2X2hKZN1CxZAsmvrrpji0rUD1sm7wbMDmwTcljmXD5uEi2m6gn2DYqaMLKJeQr1yBxYXtBZkUt2K7yyhrS72yKvSGvRhOsc7EkUatJN8dyjbtorPfpumWqqvcE-ui2JgpzNzJMI5fkLia-WCAxq0DWejU8kN6-qhal-fHVpgrEkT9uju7-vjQmWNJ8986RWY2sFjBLgGSCl56kQmLBW61PH8UjifryITvgv_s6IsQSrTFAFO6CUnJxxukr_0SvV8j6WqgmH2EXQOTjdKWYGs3n_v48uJB9yzTFkYcqSCZI1HtZf5LT7XrNRp-zfiA6pL7_FAo-Prae7gUc3LGYegQ10LvuuFhDj9kvqXlfdvdK_irrcoIMkG6yKqxNjNIRxU6JrzFrECpMiaC5O1BRn_42BFt-gG-qNu2l4OG6sxKiL1QXbg_SEpX9oKyrTIdjzXHCVse5_YDvZtn8lkqutGf2dpeVDiJSzfk6JwuwwWWCaieb27aI4pt1HGjRQ_VHBpUcKi7AuKFcJEVXQQqfSge_S9Q-rxxwNXXNAJHD9BBlF3_-3GucBGna6A4nMRTQIrpPJhqmx_uvz_Urf01Us29TkSnXO2wqpMFmy6YbngMpGKFeSDYl4qIfuR4bMkrvYoJJcZZG00CI7Weh28xLXoFrc3j_-_Cd9Of0_Jkp0qXTSrwSketVzHxdfz5_vOfVNZMuw7SPCLwyFUKoiuShoggrZ7Szuc8Wl34yu1fJStnYnebo7MX57XKVecUP3_pCvCxfK1pyDomMwC9Ro_QP6V-NwFLKGQmqaf6KR4ESrJqhCyJNw7C_G7fonVVOXNhBW3jBxsxWk5bb8jDiN26qb_5bAPGDqHeznfG268d5tXGBgWPAQgKRzd9eHLoTcID3t9JgUevhJjsGolQRFUf1tZM7U9HQduao3CGcbHYQa4fEzuZ0dVTAuXF-aa-VP9GnEI6VZjaIq9xlVFw87SnIW4zeUyNC0z1GmvX3yGVERb4kRE2Vr3yS-zrVgLEFL5c1RXa1SGANNT7ucEVWvUcGfBfktsxAfu1nK2-f5AcRy5pBRN6oJI2NukomBQTUIQjmIJQyeqGot2U0ahQfoLZxMOvITNIC33UsPm8nNnqGedXtv8YxV9wz0Q8DWFR_uZwwP90BCbpWy5KRuTxp8tT1ULjSFlGX5y965u9J2la-DtJtblsnCoVUArRx0vl47cdO_vdQKOE8yPhd-Deso74l9hb-M4Ft9YhvA4LukZWzZGceYAvibA3GZwJapGWV4msixf4OBCIXRwVu9RUQnUQqyX7ZUnqi82HvYwsjTey1PXrMv7q4Behxw6oYcCrT6iFq_ejEtQkvg93kvsfAnBbnOaNq6Ik_LIxnLsFapXtMaR0CJ7NXkNB4TbxL225oqQyjZKgsy8ASVbLWGDXVJOwTJ6ZWVI4tAi3aTOFdFXKVIsUcihqi67tdICApnXj7fNvqrZbWgYrpNwBBfMgQsZTX35O2cndXvHD2d91RCoIsjxp_8FsTkSqU2a_Am-JXysJ1RI301cQYNxykG1bd025F3a4_VWk2dngGGWGAa2swv76zl5UBhyGzY0cn8xV-xXXfY13y2czt9xy5bwA3aSxZsQuunev1YswfaTCJRu1sdHZkZfJruofXAqACrGjeze7Aa4ws6CuOJFrdad928Dq5pL723fe8UvcUlHBrLL2dWggK1PN8-GNukaVicOazgd7DUDgnzLe06TrYZ6XHRlLKAsiESTpNRpXXlS3dP7I697oUbDqYMIEE6lxNtlHYN0KflHvCMhVZetkRr72SEVn-hMJjNafpy0VZ9OX_y406wngqrn_4-rG9PfLJ4uKNM8zXjic3CS7W0xnjrw8rVBEH2JExS3rmDjWOa4SQDsynWSzf8CQaUalU-S1QAiLAPUJnYZzM4Lp8D-oDTzuOKItXYgGVUriBetIIgVcBbRbAqpi6vjOSoXk7FNayAZBTOUm-3zYfq7wwvCY95XHFgB8B5IaFEpJxv_ehDUNyoXmPxd_CjAQjpVCLkjtXa_PL2x7RzU_oXMZnvS8tvdEeGoaxjWqfUH26NbOgbuZa4mNHwDwxg7m1J3AINlTjNVeWAPyzN8CXlB0vh0rTq3c9Sit04MDJeKT48twZK0YN3Im9oVQrOUktc64ptdxROyzgFXB8ehJsN3fSTPqmRQf6g5dnA_YSKvVEWwhKSse9Qznh-wh33-f36Jh4cb_qAO2bthKYLJtWwq13LrIfU_IC963i3N6vjXq7YNUo_azVjSwcvWjddjarLcH9k4NKdd-dGYP5WbGLLulIQHmtlKotuVcBaQgvM12iHWHnhbbvF5A5WKOuHCCYIQTEutBHBJNToCX2ozgaN9j1wjj_x0UfCQDHP05GgL3WviqipsSas06JJNVYV_WHktmn5535u8iKSez7oqfIam-boEOloj8Z8g3qcUU5MtwsVsLyvF4EodTz5Ac4rKwmYNx_dKoSeSYTrZQqOBfxjNDV1P7lSbss6BBSsWwpL-xtP1p3yi6SQuisOknszJyhVdzKlhEYETVuSOenikYpCMmT-PYTwlkk2TorbAcYJJLza9WJKe4jAwdIyryuEwI6F7WFL5F5pnZXg9hP0yJ7rL5Zm0eJXll2y4E5binZxbJhqlEeyrMK9mzTPA3R_40ZsPdegiexr4OPKa0NGTkCuNMrf3Io66Olg4uE_YA-s3sR9y_xuhr-pX91iYuHjztOfhlHHowrPGxQ_Y2gVv4iTW1FGovQ4gHXnL0v19SIaej-k1ODIE8XTdzZ1GfILQuKgOwk_hJFdza7W_-1YJ1iXPq4HK-E34LRXnoZFHw_DFIEYNYBEyecqezRW5y3FEoKo6gohGw03OKuimn-F240LwF6yVv6tGqRhfmQvomIx4hpP96PaiEo0wHZ3Er768JszPbVDHGbRyNadtnNFWp9dH6MRI6uBG9S9bNuhxq2V4nLPl32y_rmMAi9jWRN1v2xjPCXmQHBcVTZiHEwT_aDqciEIBvqtdVdKxt6JWdEYuSvwsXG7W6DOGoXEkTr7Mqf-0rIWJfPEVPioXMx_PdmiQ1oLou13a7S4H2Jv4sK04PVV6IGba9hkf5WqGdTfMomY2_otoCmxMswfdNiaKoL9Pi_Dwsko_KLjtMVoIemPC_l1qi5LQO_eTA51GAO-W2VsHWAQAbLaNT8QOpJldimLU4qf1PHAjwEmeS3o0SW3mvcTgnggxAYsw0BLl-_n3GtMy84p-ck7C2khSXvAGWdIMeb03kDZtoGpZiTu-04kYXo_-l2GHWH0b5gD8WYweGg9yNxT1unZcn-5WqxKQfdmwBpeFnfsWa9u04pSKRylDbGPO8iI3FArKhGVwIS-Y3fgy0SFnsBOYyqtWhkO65XsEuh9J9ltgsnGvABN6B2s_J0s0lO1iOBlrGI3tQgmw2UxDILDhJzwR-mxlIixFllLXpKp4WFcpBSkaNITxWn8CqX-wBo8QIdQjY1eRpSBgscOO_jy-NXO7sI9Q0nPR5T3NYFgzI4ir_iEoebOerl53NljVGXI6VMqCSv1HbvA9u3EHQBqwVsXFgLiaZuGTs0HoZj4hbnammidGhtkjcExoAWpcX3QKgwdW1iJRibdeuxiAOJpi8M5HSUUNDJY_V_lVXuFE-UTGAOjE_h9q25a8Ft_rH5MlQZOZ_yljut0MY4Sva9tsVViupk5xRtwM44dtHako9Shigz_B3R5ucakfuYj4YwrK7hrajxvJ7TT9JXu6xUO3pd7dPCKle1_S6BAK14gi6UHssfK8at1PEazc4xfG6YS8FZJ_RVD6LH8HbhwXoVUWW5A1wma5Da-qw5FmNlUT3vXmFeBZrK02rZNVNilf1oO-hk6-OeGQTQkk_nk4f-Re5IwvtDLLeoChxt4vpgv6ZYlhewQZESUWLwoUEeCFkeQtHCpq7lpECYvrY1Wkb76xeNH5gxRiu3qzKySI2xN2bQJmOeaTg9JWFFm_pfxiI_0mlU8EtqNozTXTh2ATnoPr-SGW_PGXVZEFH1WvXmkl5pYlZ1W6g7Rj_m17eZxkt6Ew9Re2J3ZTtAWJLkeCNzGBZ19AGQk8uiOCBCH40vzK-o6TI_BisJlf_2eT39TlvMXZSeHHaRL--9wEwNG6e-mp4q_8znP7gZC0DSqbYYrLh88GxDA0PnRikZJsnBQTYRnakq6ObeJ4NuWN5bQtOP50GCu9soLYSDV18RY10BHpbUabnkhs1G8Lea68j_OFcO6B8Ov16Ge_Q5m-FtJB1xVr3w6958M_CTX6xgTs_n9zt5NdgJq6_HBdiJcscRJnxGJa5Hr5JrT9MVqsd6Tvl6FSjWF7O-JST5isemySTLqecztM-_T389BpDH_EivRIdO66duyj3txajQ5GbE_-jBYUw4c1Wz1u0dzDw8XyPaLsvG-Rifqs9dFL3eyGSRGlmRr-7MwXG2fR_g67tlin9MgVfwpV6c1j7f3dB4tCEcUZpD1F6cNTIjlaJLXl0hLHOm0qNl0vloLvZWZs5LnMgwRP-4Xa2Wk2QiN-uvs9SBx73kSJgtdgCaMUi4vYMnE04HXogww3XfeTY1fbdriYOgiR9tXhSMrMBmqy2mlLdIztF-Fx27SZnMaUuuuo956W4hQGFqfO5aKlnUBnhOhc1Xo9C-4jtM3t5PKF-tzVN64axM-WCYSJP1VgW4eIq5cwPrMEGWsRfVaB8_W1pa0Cs86Ie-0QWvPRpesCMXYlFoYzreUiAwLrfVdDhBbr7TaLHZ_VLUp139WESkPmU5LcofRHrFiuAVqJVUuP2cNQ25ml-dXql3xWi0y3sRQOAutPGmfUaGTmc-ouaKL8uaI6CH96_ZjmnwdDcB0DJ5twZ_WAJtFijb1N0aiYShg82n3yK9yRLx5SyAra4TWFGtjsvPb-H_mssCWc4-_V_wo2mO0c_DyIF08sZW9dRqWTH7mvm6uv7E59BC5k4NfdAOQCLWyv9-0hX_9VAFjscZRuX78Aw04BzolhguIPcDCTWCIOg68evI1O0d08LciRtUmfqg0vb5t-BiSwcNK3Mp7LWQX-u3HuZGbIzdewCZhJXXyst7WbPATeKk4OicI8-2_fg3j1ATUdXKslXp3m9t1jpjF6mfy0IhnibIb4fB1WAwMDKnRAxOEpJhFXo7pJYL2kzgr5wZtRlZZKzM3AVTYD2k65la9XvliZdwNeqPSxPMSzT_DEYYDA1DkaFChe1kJDZIBxkw-68IfgqNucJ01oTgiEaKBr0qOgRUO0Mxh4DOIqZthiV24KOXecy9cczcfzmEtqiOJhI6RgsdWaKpSz1hp5uk1-MXhVmH8FrRvHSM_qCRjEDN6Nh1QHNiSnnTvyMfkpZQAmbMmcMBEdbZ2kmu7TYOERBJy4yd6v-DuVx8m-suXNAndDDzYJf-S2SyfY8kfeIV7Ke2R2d2K81pYiqxCSJVey1WspjINaWiDr-CRZZOLGjJWKbIWRmT5JRgOjGmoU1spPUtnqv2hqOde57t9JFQ7Ww6XL4tISv4fF5s2JAM70E_JY6VOXoy4Cd3rohc-VoSRj2dj2PtQxkyFfYZld3jwuvfEZkp3uAWfD3LfclAsMXBPnrgWDPZy10twIkfBfT3qP5CM0LflHdnzNYPb1Yq0J7KA0Sqn1NwK0hybTkUV6pg_hY2TaRIxOcEw-QdZZR_P9HBhiUW0ynvDRRRTLkfRN6_araCViV_w-RaDvJzIutxEyGBnVSzORxeIx4izJBqlDPUh8713aOKmsv1y0X7w9FjUBTGKHrF35zReRcfpKPGdtcF8KCsfCT7GojrVj0Nm78-C-WgeLE5KbLOkEPmmEsFQ3lpL-amab6OOcBVO3UAKDgSgdR44uVfk6UBn1_-rFOcXET6TEfnQMtDTSi2GgxdGZuedJUU2vt8bRVRPiO3qcH-CX4Qz9iGnGCGRz2RawRVxLROAS6VN2Pb9fSe4RUWiQG6iI5lNgXdbioHoLnAcescp3HiJCWGYqBoSP4kJS3HaziO8mmtXEtwAH7SDnKHulcs5hH7J4zBiwZececrP-2D4Qa9FMdHMnF24mQGNhaCZIr3oepclYHHQk8gTQlGogpQj79Pd38CbOvXoIH4yWBSscblTyQdEV7Su68x7ttIDxC0o00WkxnjJmjaOPJRQ7_qpg9zsMHSnHNblNwWihEb76tKnxuAJ-VDA1Kw8GPrqtbiffO1pRCJEsLOBllOsYr0IL9r8pmagg7fO7m4tou4eLNbtkNWyS31goox9gf2JBs0auHNlAjvZ7nh916soCkOeZaVBpf4OOhIyeT5ZRq-ZHMP6dTCGVRzEHMg3Nr0JH0BWTgXD778PynXHixXTOOHcVB9GBTTXXgO_B_HnvoeuLptm54D96oqZ6Wq_8XqeC0DtuXqyGUPAN8D74WcyhSsmzwnWYbMYriWI2za0usD4j_CHnbgbMsyrq-GxYZzmzDtnFnBSBBIoattizsAD_9yOOy6JClDO56-EIevNoQFpnt0e1xDWfysc5X7HsFRKZ38CaUjRYLjjO6rwb3KnJy8YUOCcZnf-1PyYUK6GEaeNVHitGdpsqkCQY5Tpy8A2AHv7a49azYgiVFov6cFIUPw0oNBwK5jjhSmL145Oergs44Vox8HDvSb5vELPr0xGqg7GmSnhyWmnDCOrvONqGGZ3JWzylL7fNFRFqBFLkP5Su9r5DJzmujCbXRgliGWEvXfWyv3TZlab9K6kDzGvxgdPY4GenkdDSGTVSHfquX-a8RDVW0ItHHxqBHK5-vXcf9AGVu3cz-hBwcrq00d8JlQhQkwe_7MEpmEhPtPyvMMFvtt-a3lCRCt2qSwLgG4rVIF-P-vh-k6kqIGA7Cnl0nGzFSSy4cbEP6HS2ICs9QRY1oFzHHO7LVp-k-CQgscZRJpfuSk6FBqFCiScFmHeSpE7HwHSl1gxogemZtRxTPXwMS2CkRciTeuGh10hSVSnrDgi8FMGCX6hZTkrgG5KAp28f19zBwH2gCXOEOP7hB46PLUEFiR8gaT-Np2612QGq1aN6swAi8CVm8Ed7Bv7Z8zlNmitP4pra9yrLoydlYQfXYt30mzNKQrDFnEBptFT7522Y50YcgiRR-3_7JaRooIXKyjNXJfc_fIRngd7HNbsN4qa8VtPj_H9C9H_S8UmT0YQUSa1yt175R3oSdxV-gpCXVpZHKvdaBJ41Sn58bHMoh-iqGPKNPu3a-m72I3g3RDtNY9DJluaS7moXuzab8vdJ5tywq7SpD_v8Qa5fmZHT3q1lXPyw4fwMhT-Zto6B1CA6qGybYZuVRtdsGjelPJxhmAaZt1IVBiiit3v_vTEtUtCZzvoX8dmRY2EvnRejFLSvgmiaQKDy5SUYiu68a6qDe-_RRrnuT3-R1GS8RAbPljoU_7uuFIIb3wR8f1AUccXJ_JeZuiXyhh-iQ4RYT0872mwMFTOpx-li0o66MbLndwpJFSeStRD5RvkONpnHX3Vt2osZ-7vhTL4rr72Y3RpEJpfYQgZQSRMquPggHbS6FR6yiV5JTWAVGrIBbs6jFkoqsTy_kP65KZXxmYrewQeFVxAfp8S-kxNMInNpSyli2qehjJ8EMWVaYO9tEOjXky7WNlP1O2KyRZIHOWbXa5LrqQjkOdr0Sd9WYG3S7ZFtmOqDpK5RE0ZJ0IvGAIupMepLxpPdQXMZb9fsRphFYpfoHKHGoryh3H5Ax20DMXpcq6-2DmCkYZImYEUr36wgoO_3aiLsE-JW0JPCstBVeRtDgpVY7T98fOfIX5c50Wq55BVLc7niQwvPVxaYqVND3ptB2QJdw8R506cCyhLTZ-ZMFfOKlORPSO6shq0cNa0SDlXR9e1UFD01pKgYtBahiKx-Tw1HxEbBrHdfenP5XObC4v7DJQvMuBBT9x9B20qOIYoE2UG_PsZs4-LI2pfeucotB0Oxr6fflNK5deleNyEHazHtVYSx4ex8PAVFNBMVTlh6L_jkmL3LYfC16QC8p73uAcec19EckpQ1vClyHy_i1-wrVkS7fMgj0RSefxAMnmF7o6ngyq-iHNFCQClJHpBQz7N4LfYi-R6PLm5Anu7bdRE1-aWdy1dR-vfJteXZErCs71wi-bwls0_butmrK61jZ3TcXx6gNzBTv2ASjSk8QqY2APjbVc4HHwBY2EeYZUHdSVZyIfFwp8ORXkY7DublZS6QaOkegdpQPDXl-XNQSsAYuIe6jhFK_2QcUqS4DOgbPzbq5FwjfJJpU3tY0XH6jKE1MlKvlWeTEEJYh-ET2vO1ckg96DJ6c3L_fIY_OMl5-0aHG5ZP2_PzgrKoqna5vcNzdfRF-bg-Z30kZQ8Ia2XMx5FpJ5Cvx_i8Ayh6aQaTwL4-Czt8bxC0NlA8Zr5ZFrCns_iO58VIEjkKJCfLZq3caOGiLsMjBMyM8yGhZOwHG7UCCT5fNDBpQu56KdOjeO_gdgZ8QVkRoSBnNyUGLYlQ1LTyGogsQvBbfjHXOF2YFYYEUcdKcQ7iHY4UmOPUowM1SOHhcF_PZMnrXBEpdq69I8sbDjxfi2w2x3pALMtlGM6Jmx0sriw_b2kVAqnpkh9vEwLmBXrB9B5fJUjesfLewtFHFH5YQQv4aY9f5sX1lQ3Nfev0QhTO0AgOQmVu9xgYGX7CupPkZJXKbZSKNPwd5A4ZEPbLSBEvz8wy4sHGoOVUVKG2N9hY3edKsKEHSdcpoCC4pe2rMY3J2lJ6gz0bfL90eIclMN6gLpBCteunbPsVpoLceJpqgS-czZbYTa9FPwe9Vmi8JxgXhTKhuFxic0gT4Qu_Vj7gTErxjrMUlc-QxhwT1WINlwp_KT72QK-o6MKFedd-a0oBlPi7Uan1h6hQ7XYHOQUK8B1eHoxTB4cF0kgQ8KKKvR8wHMFo4as8riAqO4TO31T5_4dICVnAXFkgUAwk-IyVmrBJmBYZDmNmG5f_JoNyOxoKV-vFMW3m05hIvpru8q3K-xKUPAM7xtmvBMv5xFRUPsC7CHNJzejPuET87n7wrC45ImntcV-HYJ_C5IRA2JklhAnDylYQRsgI3GJ1Qf3aNulxjkTHE1KBkB07ghBydY_-JflLqn89VC4RWXoyd-Gq8NjEKET4DBL8b0w8PS9tDF9yeTTnnqJ5Px2AnaRzNN25Rh7CZ8bhzIB4VnNuBuR6kVGK_hvtL_esh52kFOCB6WUkBD_2zp4EiBPWSf1IWtwEyG1HAWmlF3tHvd-4itYng0FTiajU8d_0XqVpR0Gd8oF9dnDzm2ln6miXEmPdXxUx5mfthINOgAFOImiQ2VPqNkXSrDVca5nM9mWbLKnIExkoEZu5Pdxxc7pV-ZYLnG-BxuG91NCOrVuy0JacOD_1SWs43mZZAq3yxmLUABtqz5ZnV5LvYn1uPIfXmXn8aleccBj8j9rmLO9T1RNtQPuyOcd2K27jN4GL1TX_YtMnhTZMkQwGcTeWtV4RCpMUmIW9peg9cFp9x7r-QIC_0oUuKOYGCib8dUnOVEIGKEb6beB5U5uf9lXg6cc0Y4RC-BsgKFpxmWqAfYQjkcxIVd8lUhqdrqNsT3QbTvZKTrAerMgSqVML8V4yPXI3bwk1onXEGO7yj0B9SqrhGotWBRySLYWX9W7m-uUAQGlVrR64jXMo_AXXlU1m1x5B5cYIO41pZm2wc2PcLkouKlwagrRMtiFykQj2cT9QxQ_gDnVeiVZo8YxaWzplv_ryTytfp6EfVvIa32FoL_ZFvu0EcpN9kcXO1tdQX97pdTwlXLq3xw7lyEKfseE5_PwiZIaqlMlvVP1WK_TZJmxE-XtHlVGwlCaMArp_tiSu5wlT2awkchP5wK5OZB8TN0ncpEQXSHYMnr8o884PXQCAjtcnfOeIYCVmlQJxUZyLCjrfH43hXbs7Kup1yM6EW54GZlzWakR9oz6lhWEBD1wuRPNCWxkXMrH7OTgDPHE-J1xHVa1hMnlg_3vRqd252jqI5iR84_kM_G5FEKhxEHTE36vK8bwmRGbIP9mvKTKWpMZg1B3xBILmZlunxbx7upCD4YIcHDxXWh58smlRaOi29O4dqRbm-3UUUOoWEu7wZWWUq-R6V6FHtSX7Xr4zWnmf-TOB9L-j4s9V9lRTFrwsccTaH_0CzvRVxZzaUEe1-ScYXI5hKorD4rBeEVOMl4fsMgd_tF_7t99DJsUWn9xSNpx5u4XwiK34a2ACaUUgpUb99wYzOLCtrcr4JkqHuIG6IQPPicu7MmJF97CtAeJDjEUlgHyOTlPvI4SDfmvI4D2R2WBjm6zejwMiohDbJfcw0WXs8_0fM0_KU8wfSQXeiJUaARf28v0XpkjcIx9z-q5uPobvPmT2lEsMH-IczaFzQ1DjZmfm5aZ2bk3UM0WNAMlVuyGZOoNWPBKkHbE01T3YpRIU1KcXQh45gN1TtxGd2V-QSatv1Jzo9lVngzlxreDUn2R9ydlBW9438uhiLa6Il6g-JOJ0N6Ie3ZrTik3xGEA3vc1eTX_sJwcRTxSp2JcYbsXu7KreXff3RJwjvBQruUumYmbXHZzfTTe6ja-ysGP_9U9FptKPtqewfEXYP2kqTjCHjU1iQs7KgvTdo7TE30mwW9S_xMXk6In0uRJiKhyJcNp_M4Ehk4VlJ4fe7OzLpPFW3PA9DnUTqUjl285nqjDtdvgFWR0ygNUppIbMwZ-ia8LetkXm4U7bCxl_8PEdsKtDHaFkfUipHm8fBdabeTjWDACkOcNSZkty8NM83TYKqLF7tHVlJZ44UVNrdliXP0wqaFH6vk2Jf99RrWby8aNpCFB_fDlIA7la0uFDJbBZqkitnn2iDg2TWrNPQE4Asg78vdEC5ECS81svwDBAUj6R9ebPOe_2Tx9OclImyLe432N9TiZEcUJXXzPn-NB6n79xzEDeQ8PtF_Pk8zvmgCdVwj4EEyL_iMsyxUOKbd4nknv0-IldB3h9PDRlZGTT5TQ4oKAFbRH09V8kGOaVqtdCINs9uX3bZlXuOFUMV3iOSVn0JUwJXXXCkqq5q57CndsRhajQiNJZY9g-fCnArY7vb2dnjR-4RtCPVkjCQWL3R7wcMWmh3xOw4CcdQua7WVBcnEv4CV1lYfwzspZeAPoAiEnzsYNgrHHfpvTXdvAyPZTZiAVjG_zaHDvOe7r4PrLWpi_aZKaTxFIDqJfn3Wqmsn3bynHsT5-o-LceTOTLhr9x4RJmZweKrDHeT3ILDk-NiprCdAfpvvtj6_pDnX4d4MxqEySTILNGjaYjT7lSeOETnaeh05mfZVlXwN2bLgTImz8-XEKq-4Hmuiy0q5zJpelf_ODCDAKsEuV1Cpr64mUFBInBP-aBW0YDjLweeKTD09SyY8iLvAFU0aRp3jp7qem9Gy8K4UpszO-HKpI78tjOHiHuf2FUra2aCrQosKLdp9ztSWs7i034ST-sYsg1y9IkHOroVmCHfHfl1KOmRsYk1_lMyD7Sev5XOd7cFDyGJgOAOOLxxPbp1zaYhRFpGlIZNAO4hCYNWeGRdDeMh6KtU-RvlPRF01zZq0V0A32yFGJ6K2v27IgFb6pOK-gWmcDRJqZJYbNvfV7msURxWMvt5QEydAcAVHClyXq22e3DntAS9KhJ4VsH_yUCoBCjLQhADb-XMH01vyB24Z6yPkucEWzRtsCLBV5ZGD748wH7Vs51ZoWMCpUMA8cogRB7VKoUJzB_eDhoPTdgJeIPSphAlqTW7QzXcGVyjpz7SgqHyfhKe-FOukY9OZBzYKJm7WrRVGzX1qX7kERMGw7h8gMkxFGlP89EaJIPckSNYTNbTYriV5SVGcvXwa0dL2BJrPysX3KDJXTAsuYzED88RiaL1W5MVoOMETqm37ZIN9o2xhBtRxahHbKN3uI0oizi8NTw5pdkn6BN8Aq4X3FI-xevoZNNV6MMjKv9KkjHTvXGlsPfTdIGk5MFl5jBsubp2E7PFdPLpZBvIkAZJV-yD6U8ihi_5WLke4AC2X0llYHaGIq98hg6IsSSVAz_3WZNq-MZzDTr4V_Ou3Bm80SA9Ov3Hcixl3fUlmkE2kHpio0hqSoQ4oa9xj9LJc1TY2D6PYya0pzxV3aGJIrhIhKC1kRLJO04eNAUS0GW9ADhxg6gP8ls41w9v4QX9Ixm2-8Vmz7rZPd8Z896ewKnBYsYOnZKHz45p65Xn4Up7WBbQD3zvsgZuLj-NOk3uddVQ4zULeyZF_yBIEEbeAYwG9pgfVKPdZ5ZwAJgIY4Gp0i1PwtJrgba7M75vMw6aIleeqg7RlftPtIZaIrFsXh05EF2MZd-r4FKB7dHBzJwML91d2cfaV3cWgaZHdYLCV1yHeuGVsbVZr3jD5lq_b_fUuQrpuPA1s29xFxKClKiaL9fDFxZpohv9eU5qNsghSl1UvaOcbeKSeEqxeqJv61MTs6nawowhhmbNqAB-XiUCqmEl-sWtVjQ9CeiLJvRVssU5z5SACaNqf0P12uKQPLDvE-KJcloWZt3KnKSoTK7SfDmLue0ADdao-IZlA03Dw-cnR2dcYfTdCTRYSt8WuVfJgSGuSHBiurimm7Wyz0YLuMDN_4jJvDhkrptk3pcrxNZAKkeYttT5Qly528zZLVzCmdnghCRNjU0dVwcFeFvirTlMbSVmgFxi-dfGVwoX7uFBtdB9kAJtkSTYi4vuS8O9cQxwIUCvVgBub82ROaMb1fTG1CO_pxwX3f5JeZHBQFCvqPQDUc3dVGVXwjNdU8_7RnzB34DMWfkJiINbJ3EDM996pLbU142LkFV33NWTKxvd9YnqtfLHWnwUWgqJmASFmPq_ZgCEksfHNWkRb9GId6fOhcgtSZvHctUR7g9GTN9eHGDYLQf4BvE5hQyTQska4dPGLfmMBHQUqoUqPBnxOiPYzMBCrkfFRaSkXJcWrOHwGMA2JZMfmn_4n1IaAdFn-rSHG0ZvB0t9lWrHIxhkb9ZlkBJkVXSIA7DkxJmVo0pGDAqjuPgkCuEFRyg1juW6M_uUGiul_JTwPfvnjPnYKmZUBXh9JlXI4AOX8YZIZU5h73zB2lk_ryisDDU6JzfdEmW22Ec0PCOWY61xAc45CQg1p5pR-DVw3PeBMgn9ickNI51azALwmqxPNgGlh2rvfQYxnBjpvM6tNIOwfmiOhiNUn5uCJriHzrTJ74ysbaevcFzzj0JLGxDuZNphRJQLuOjmLf7DqOf3wUMtaxk1zeovBf5QJcIk3I19j_DwJjD7_9CdraDJ-Ka_Gq6KzdQj6K-qj1HiJOG3dzFiMATQFmJuyCnb_yVJIzClVcJMdktOh798w2kuTJJDMFiDArNv7oEHb1mp6Y3oSPFQyc44ksnI_HJS4_-z3ZlMfuanh4IlGOM36SWwndEo5-dbmXDLITjRmc2qDirjUaseOdFcdubsgiUAd_E7f5IyNmX1ytQnyPvDY5TH6yhIGyftBXf9F4LKRxMPVV1onSibsus49IA07fnTVxFEWMkYSDmCamUaJanzIyMmrIy4n0zbFNH6pdccvsEI8m887zb87KizCddiASqNeeldN7np2F2Ob7orXWEzW_8N19Xq33_bg9E02qnNiXTPQ91JJbnTbfSOkDYbAx0N1kNUdxt0EI7JO07N40IddkKCwlRL1DXvU1wCRmX-yYeBhm2c_f4f1uIZkL9LfN5kHFxmeZlwXpo-Y3lIeaCoyy7qd_o4IKaWVcWpxhzOc0JHelW6DBeFec1lLmHZmhrO5TZLJXvVTv4UHshAx48hnWpTvq0AtKckU5dUm6-sSPVfZJna2sestwAHxAU0_16C7x7_YMVVnVXepADhBihgYay8KeM-Wr1hykNd7QpPLn0-6mu-A3mNTfVRb38fFQVQAEX3DLB2zSqkuvtg9G3PRxEM9yHaedoVJx2c1tq0cXw4euJg0bPn38VX3tUtl6bLV250d9Vxkg4VhvT8S7_WyPdS6KndFWKQWXuCWndEWyOkIWekLrmr_3J4-CBR39anOiLwX9T1etBdCoCfmEtz-ALkLGklM2zsNczbMQAEyrYyi1io6ETAiZaQGR3LO5oGkzDQWktkL56ZfHOWylwi9nzSAxhtJlSava1sbd4r6a0juClXc8ww1BHv4TckrTWpWfU7R4pK2EGvzuycxZIA541VMwrj8BulKiMs2fVFMyrLJUDYTR0lIrut1vcpg5NEBvwBe3Vd1RL1nAWZGTg1VKAcFvTYiXsHKR3IT61BIStRNV5dFLQ1XoEvgoSP8EcZqLy2dSWzjzaDlz1v49Hb2JoWLeQjYZtfrBUJpyPpWZGMv7D1nC6gBdXbdM-wnKBWaTupVYb5bAOBXbapknfbp7CYzyhaiYkYsZJq0tN1Et0vEHazKAhRKgKrVNdw_2nXrx9g8-E7OF0CD9m3NRvFbqGIb_d_OB7elPrGHkd6Bnafq0XGKVuO4FIui8MhvKYjssQZJIWqlT24CsJ0-PC74TvCMlR8_r2q6F8rTRJnbl9n6XquOIU1xDmbsmw0MbKNXxcyEvRXaEnRADPvvPITo2eoC1WvYOIL5LIhWpTQ8WNrBI0cZeycowvCjEZan-1ukY5ulY2AdCzJybBHoOCDAmudgjp89950dGOKTy1V5llYO29fn3O4Q5WjWPdrGGCOPvsbuZMn5lxtAH3-Vya-ayKgZ9gqHGoxT9cPf2uTQ8g0a46DmG0i9w3VF2Q8ZLMhDwv5xiuGKXAmAZkH28H0mSXOKKVP-hNV229T0jTONyGOcdPsd7Xsvif4lytIWCNjOuFWcR1Rqm5DF8GKiE6E9AkltJTRJHgM1bO6uM6k0JsED20FAAdVF0X5JrrRUM3R_VUYQ8RYvfAkDufdsJ0xAqR5im8vcKrsvwTDBXAICRiw8sPV8SzwnBpW3-dtKF9fyE2TOi63u36jf1g9ILNORdhA2QArHdnFGBdVtv7SAdTnSKMBLeTRl_WqTMKmoVFLJfMauddNVbSno5I45Eh7XwBtj7Ck0XvLXJ_xuUOG2_tTJtPqVYNlNPzGwG8skNjfUJf3xrLnk5ajY3p3bx9_npzOggOIzeiDNFANjuXN3DLFXgs58P8e-sFRKf0h8gmD3guz2Rf-3wBGl2LvjieSWJ6bancOEqvoauiijKRRGhiiGU-ayVhdyzcJMnhD8OScekXDZsR4RbGEyLmof1ofR2EmyzFyxojlDMbp7i0JktjxCrYNi_EGyplKRoAflqTQA2B9PqtNpZGoelgYtPSIng-dUcpItBymWKY4fanElG-tNqT9IQRB7rS-LPV_RdGRpmQlzHamuBaDYH_lyV7qNuEIfSLEriZfvTj3hDW7jkwDE_vSK2VnCFdvAltpyH876GX-tJ92p2JIFIp3dqAkbKm2UfILSktTVSVliATYhnFto9X5I2vEoxeV32wRtWUCmmy_mYL9JzIo-Dbh8xJFSEdgI_41HuQbiNraRmP_EAEHPDeFHYzSww5dQZuy3_0psQCbiBv--3lJtM9VZuyfmtx9uCCv4fXwGl0BpcS5md22bVOIXE6r9kosYu5bqITiDVqxuiQEqbC00m8dvZnenfzgioqG8_6PsoDD8mhHNJhhEK3Eq7YJ7N4afZygUsNpwGZmCFe4v2HaMU8KkvSLRaD75iYvj3BgK9h99ObK9x4N5jZl76pGF5e2vDZa5CuY09Ln2nmBO4Wjvj0Ykepg3Z3Ao8Dt6Y93nrKKvIt62d0cUSY1FnEwdbuQGo3J_X-qJ1IiLfUAx4MOGdle8FEu08uQFE3Uw1Ce0pO84yps1eZl_-Lxowqo-r7ypPsx1mfr46Q8HHL8tXsoIEzWgsezIvHfkQ3kO4zq0_LOX0XvsLzolWDwCsXHXSVI-1f67M7ogfnXTNlNao1F-6DkOlpbfonUuwbh7wRyPPx8S_TlJUOTHI8T2OOh9T-MiHOnBMuIaiZJ5cufymBhuDLfbeLluX7pEYLYXrP7CmMKv3Ht-yKMictkpkOFmXHqsmm3sBqzunhdohY2KwmhYXY7ug6zORt10wpVAb0NDiANqXpfBCaOTJx_EmeF97zThUGOw7cXtCwzoTujO9_Vbo29vLSroSXbCWJfyTQR2WFlrCol0eh2wZYScsxEH1NtBo40lxU3CZIoGIXr3n7jlFJr4A9m97gSnL7xAD7e7iPCjFketmxYdlZO_LfGZPDZJjUN4BDO7S5honYu3l33MzKCe1Mme6rby36wwElLldVbhdaRuDWSRiFH417G-gU1dAWAzJUGa1ueTSQ0eW-skaW4YiQziMh7B3w8KxTX2kZ6_DYXjOb-dYWcjEnseDER6vs1WD9ivKRs-L7an2h9n9dXUC26mpCQ92c7izwyS_9_bjSqQMEwO2jOpqCeg_Lx3tdM1xa58lKmmiArpq_q3WYq8MAqdhWNfCtyTXhpOU4daM81kRx1FnwwpF1-BrqWTGVhBzuFTYn83dMttn4qt2kdBZiYmB20dGGWcKlWaV1StCRFi-67kyfMbWXH9Hg7eI-ONC5BSgMO1HEbtO0LRHuW8o-s8M_RT9dtwO63YQnaIKQFcjAGB91ljKKyQ5oONM3fCQlu4GaeTO55_qUOlITfFAZNvdiO8qW-BCBkLglmyUqiUrQdH9Qgd2jgiOcWqPqgflN9XVomwm5fjMh01yPEHANqaZdVGZRT-mEEp0Nm7B7oBALoJOxLkN7g50XBW829JoA1rJpIo3iWOatWnQJwgOXtQmLKglki7_IiS7fcQwlRn6FhgiMUab3Sn0T6MtHVZ36S1mALeZ7YcGHAWP8fnGi3M4wgGjd4gS9n7kNUKDQgparkri3NJ2COuwSHcj6Mk5cypvjsUifiD5IPs1AieDQYIbTLbY_qMfEDlFT6EFkUvvElzGc0y3eYbWq8zHWJ3YouFmBIrGvpPjePtdGNGSGVDRu4RY7es_puImzjw2KEaofuz3fv5sbCAH4NYOwDNncJlKw-VXAya3fxDqIOt21NWmOp0m9TsUobpw81X3YBw35-sieNcwACP14uL3Gsdxad0uuTkOKtQbEGq2H3KsTzXmYix2BQ2qfRPE9SsAv1NrktuMTRypjcC_OlA-ieGgQ66cEkyfRdna4PFJdL9V9Vu00wUYYN1iHV4QfKAn_IOhTYRw1lIQTWmbMUzrhhHoYzbbUR4a_6sE9XYgvrnoqdnRXjdxXl4-_FA2Is0E-cBiBW0vgayiL-bQIqBaK5pLgGvwqJuU1-6aLh8NWgBWgVECfQD6vuJ7OyIJj00s9JJ2ujIjXdlvmmbjkNkEDhh22KjRgCbzbCXNxxHKJZOl4qZshuxFJqmIHn4_Vzi3AAQoHR_rPkg25eGDgHy9n2_nSzmxQoBnRIWqBbyhwFJdRDThDM8t-FoncEK8r7gnBcBW07EkdiFrbpxk8LgCZMd2mbocae8pSXwCwGa7gSV8_36_KdKZ0mtIExQRLtdogfgR4Xs2joNSRoL2yYpgUGH4bwHRzzn9ZcM9mOXlz8lZ63Rn_f4LQ6DhzPM_QR1v5Nr_0a1ri4BTxnuloOSOPRT5aXdiosUjEXxO7Y6TdFHptULickLDmJP1efM9BK4k0l-RC9Vp9O3Kmy4bqQZTvFqg71oXFV23Hr0MkD9o5K9KGAP_iUTx4n3FyC9yMWygAnSEi1hYn8HR6MnxOHP7qFUEMsAMc0bDWIBG-DAg3MgaQZ30fTK2V8vYWNtUOTpVbfbKsEfSLejQe65nYUnlpt_h0vYHq0da2KYU9hM7Km3cpx6CFgeMiMfOuHXDH8UmyNWOLTnRZRWqupPynT8QcDwRgXX_MoAReELldR2AzXPsBUPe_LIhFLm1b1uZR6S4aKTXalI6UNMZyid8V9D7tXjVdVorlnaCIzj38MoishQu5W0rE4zL7Bdxv5Gkjf0kND86veQaRpr-AeC64go3jb5SDwnJUmFvndp1901TXZ_tsX3S9xpUe6nz81uheMPXyehHVuvJX3DSDTLdJQH10Bk6dE1XWP5ZnuOwXnqq1Ym5o751P6QL7ppoARMjHz2WB6CERhPXrvYV2a-kEKIL-BMLRR84Yp4_hkczTBp1Jsd5B86GwzQkm7KKzCAahLgzNLB2bgaCv8ojwmLMf301jRLdQkTpg8y108VKk_83k8r61k62l_nT93Jh5pFdFK661RZ8lPumtuMkZcheM4z9BcpYccE5gG_cBxU9bdeJbJ33UyGeySZNMqr1m-zWAUGLvJKSnu9TRyHgNh2EYfyyOWxeLlx_HfMVoxpwbPfk4QmgJ0ab6JvSAafWmZmXEZndAED6WbnIwJATldPQ_gb6y5ayfEJVwJLEtRu_wgPm3qnT1ZFhpcHDlt-g_4SOPPg0opxAsVjkzpCFtX2I12PDuREWcGE9MRPLZL2IVMZc9q8--NFc8pSAKcK9wclBfBxYzx80SSLBLJKm8ECM1d8tsa4VMroKFCdR61goFPfsNnNbBH3Hw7VdmRe00p8e0ud29rZgr_0K4jbvemc7t9IwWaa4c9bhX6UkBwg4lEKVfrjvKvgCJSrMHCWqXo2lQ-_E3vRKe8UUvHARFrSN9Dj1ivwl2d2BCoxYTuI1XXO8K65xZ95fFx70xchKBDdPlpuVZvumDwFjA0Vn5VfC8AxtjVhfd86yRRalcxtWzLUscGv7sk1AgSd3AuRUbuusMsv-rdLlPMYtv15W3A3HSwfIMpFq3zmOleoRjoUgfmJ9vXeJnETPTdXn5y8kszXW0-V-P3yjicLxo56l8mCdaigigUz9yK0YlGXafd1XPkW3Sjdf2foIt5rxcFrlxbMN39zCFq_qxzhXg1ulrIHM_vl9S2L8K8Uf0b_YxHhui8II3D-5rLCPHC4Fg8KhJqk75IeCjoGgin40_Mre3_biQrmT5jGNxo5kTR7_emfhGEqQWrcTbDEp5PEg9eAQ4os6Exh5o9TLKqvO_x4CWf-Gr9MJzr4z2qzrgUEMmsx2c25A4PXCsgb8oQL_C2UWu8cO0qY7-_LRhxdb4HzVQcOX9VQS5Ywpy3Z5fXaJGCoXlssHOYyIYAs8LtGSdjfQFAcrtPozmB0xehC0VhvMmArexQQACXJQu4vNPXNmbF0bIqyrjkPoD3YNlqnot8jySyUve3frnHI0D2nnYhWmuDZKZi_njMn6i24rhMOltFQf5sxc-vmpkaE7JBabnAuf8cd2gTtU8QOUtQoMbK5e1ap8yR2dfeY_wtvGxVei-RHA_Z2quHg_2epIv-cNHEBKyD4meUBK_fuTbzNZnBHvVQ7E6PLLXR9a677N-Ul8R3v37VROAm02qwZDbTb9JH9bWL7oTo8Nh1hlq3q5PcPrPTCoXDhSp5nvVjaD6QwmkfwE6VNCVqbLvs2AkJj1LQhWtj-k4AY97XwI6SKUXGEi199TnQBe80mDYNpHWie6lUyWJbDSweRDvY-HMDJw3jjblCJPWOIC1P0mT4hJd6LIrihCxe6vE6NTmf2jT9LA3JSiEjCo2gkaraKVLCZLzVZfWvcEu03UrXap6LpJ_6UuX4E2ZMUooUO_IQvmQ9-ncflQO61HzSRUeOcx6fW8XPXh05_Cx145xCNb9SCahLNWNShXEF7cZEsQUuLOVflbhEglCanQ-gbHyAKXjEVKJzafrsKjk064gVYVlXzUmb-bd4wt8LUSGkgKV7EBymTr5vUOWtQzpuL1IXKL8kRftIPyKbhGiwZS7gnBU_uqFn2mavMn5tSn7podghRvhrjYcOhYIKswK6Z9jvR1SRTLVXgReT-ZeaCYNaUgm6nE-pRDtyg6dmLRVSjgmR4i1h1EOjG0CwJm8S3YMId-Vb2cR2lgamOPeNAsY-DwK02-yO9MwMvR9J3WmFvknr1St71QSjlYu4VIafylOXkkfwFJ2ZFN9-E71-zLBejKRa7iUpqD-DqzubzcAgXtVkLUIIALnz31bp05VPFiEYlZS1NSMMObyzqLkin5wqMq6p7Sgeg5NoSTE1U1EOb1-22vFyPnx39eqPWjFyzaK4nmSKI3PwWaX_4k5Kr3IQUWVKzgphETbr4Mg7-cfb-34yz23_CDakKoTwcjO48WSvJMC0lisQtU6yHgrTQzrMsEcV4U6pBZTmF1Wu7z78iKoP_VNyr9rmOqzxnXfTjahERdKVqFSM9DcZz2Qi07kdVwW2ZWEEZfgFU5SCB1zmr4ZNfjTbnZFvKeqaoKlaSJU76K3GobMfQD-95nsfuTJeJQzjP3hebY3-PwVjHYV7glzI-jXY_qUWuixQcH-OqwpW-kNIJiYFLfBUGUqljEKcgHaLX1nWVQSi5tkvyULevJAYxvxgvOjj4jRnbJBfAMzqVmcwnwAkVcodP4DJiHGw45laySDL2WjgsCs1v7HJ3i1tx8bpEJGkQ7oX4hagXFzkikxs8zPXuM0hdSUw6Hl5WfsEHjmXtUTCpcatRjp4do6u9rpaYsJr17kX9QzIcdGBjnDxVA5jrRIuRXRkKLe3iq9TZSfAk05nymMTw1tWeP0vW2nnrHIbMqVhj0D130KhqOj4hKArxacZanUyTMM8aH5sv9fK4TmjoKMeCJaGP0XnQow1ScuHM0eUepGrr_1Dtq93syqEVSLaQrtfoznzTl6q7bCk-eIMNK1D1R9ZByIVRkTYhW_4kDucx3UhTWWHR6mUShkFqzS3sdk5ROLCpDHeWK2bZMYjEdIp3c6XmQUmlOkXc36mXb8QsCyE_GML68Eop9zFzjB_EUT0259AMq9Hrp99gFEMNWCPoL2jEh1KUBazjsdNS5qi6mBKQS-HA3MMCUNw1XcgJDZf0M1jSWcfZjMtKCXwfc7z_3sBFlN0NbiqKczPYbYg3D92eukWtINKRE_P0FhwHnx6_zmRbz0ti0EyGeHdpIXMXTfx2MpW6s_PkCMmVovuZabcVd814uqWnBwCEeWgcvqup83f0iItQF3tur8o1O2Z-g9NbbDJKz3eUCA9ojMzlf48jhL4_L4opAxs9rliLvzHal2JCaXfOHYLmK8blWeFXiZYGMm0o1Xd5cBfqxPgUvQnU8jMyN3xRK1s6R_MfzM1PZ8KFodbiqzejdwDjS7oe_HiMpukKHobHPik1Ou0agkM3jlXyhYL3TaTvfyU4-L1BUWeicdBiu54gSIJkAZpWBoDGkPbv9so_01Ev9IhxM_k_i3pCz_JudBzJCr8jWRM-P7-eOCtehVKwFD0sOntm8DfYmYBeNnZCo6E2p1aZeWk2jzN_wcb50opmQ2IRu5vK4stITPWyc_m9Has8LbOUgwnl_1vY7snNzjmQyx2jNuMgEyiack6bDz8hJ_Pte4izGhPJ2H8mTnzNsie_BCkU8GKZJX8iHssMDXPPruRRTfzvmr_BsAlk7KoVbMw5rKSblQ1pDgDfCJTC1puhHZmpLW_Ohs2uRe0zbx-Fs7KvkUqOpWhaIdNRvOPPtprQJ1Z_QsNXh_Gwg2o9hFJfNlGIXts-w2HmOMzc6vo-nDHD94DMzF-EbIs7wNnvNsFaqQAkLAUYA-rrM8eHwPyw-8ThJU6f3HB81XNBo-0Eb7w9YVDFXAynGjJ50XLepCLQB-1LNUaOaiT5dCY9X5DbKKUnfsOvo58hrfpzeBQ0VhNuawWZGGJq-fhZULnrfNyFU4E9anp7iW6QRycJW3pkjZXnUT6_K8tY07CePB62zU7OY-MiyhUpv9o_gmXQW9O0s-yiB-eI71TClKJ0xUJY88AqO5cXqqYThkS3-4rB0GlnimG7n8-ds4MVp8mauNqfeuHDYkdmFXo8r4F8Gy_5omFnCZfV4OjRs1-4Thii54VjSx47B0Q_K5vSR8IqYQquhUDgXuBmVAXiUtGfdugy1MYsYPWW-YkNv27iP-frVPrKZ3fgdgUznVztniq9xTZys_QGpvo_U5-qK5MhpyZ0cZQk33nf0sPl7FvzBEf6RpWNtc_igP9FR8yeQ2SZu8q0PZRY84_vqXYUrMnNT_igPzOLyU8SOM7GJ4XBOzQ_Gsp7bhdE_WLnBOyyei3Y1gE5pUeksTnBRAQbVSnsOxaoYwrBVONuxlnkcYZgcst7fKpvXDIGmGy942xCLnVfN04VhaVxdArrqqPLQZLY-iobAjjwr8gM7FHSOGJsbkLIYKK7rvxNBMsOMr69uVRx_T0KaMr6AXHRUjRi-wUpu2VdfrKgkBQ4eAl_ywFJuqe6qqcQbUZqDTBbByGTB_HPZOyoN5efrNXEtsjGzX2HD-MjrguxlYt2NbA18jqgOrnxwkVAWa7RQiT-6QCG-9WSnRNw63Q-FcyKSupMQsXpjU4OzgJ1QQshsMwYDW16diW6H6NmrHuk-mcb8pxKdrXPkXVcpEzUv0IGHRSV2Jh195z_5ZHig9s7QZn02WYA2XtM1m7a_EWw4CKeHNI_dwl-yz2xbJ9VL1noJ8An99MZ_C-pMpSlj3EjJBcID-Xa4XYDUxx2hEpMf-cxHgaqGRExkgr200epI9I4ljdljgjZuaKhYaSYBAZ9aL8taizPb4YwZEqfJRm2apOyWAkPWHT1hqa6HmmDC1Ve51yqMIyqUj7fv3El2xTnHS_9X_X9laWIcHg3s1iVw_5fIEoECUSaUVKzlO_ob6mhjNoiHdXMQNy4Yqi1A1rrhiycx_64WICQH6mVEc4qRiMhkHVDaVNWs7uBL0KA3YAhgQv1iM3oaBOx2XDmWwJiqJaoDUtwy0-l_jdaarty5S3CQwanc8-vrTfSPp1vGRzoFKQzGiYEcgiduc9E3HPXX1cdwgghilYpPBRvZClHDumMHb6ZKQOppEfs-DutYZIee7t0HuwkGfwQfPU8ZNqvY-0gZU2s-6PEf_tGS0Q4FmiYKOifyM8LaGpYfKUoax8wS-neMXKFT7zyAg80hreIX315U8V3oYggLZogJam4DEsZbdSJ3bEpmWGr_5eTCllhVrkr8aRmWaKamT5NTw5TOtkflu2wU0Ncg0c7nqRB-WBRHJYLVhws7FMfcy7BMGZBUT_IE8rWHQo8U8dbLKoqPDfapS6N6me6QvwaS74MqiX92tAbYCU7xPZfmNTrJc8rli9_aNbqxNd5MNx2GPSmP-x5-_27Ca8F-wcDgswirTHAWGtPYcTbsn0G9UQn9Yb0E_zJ7O_LBJfrKamJu0Ih7OcbmZ6o33-Q7bZn1wwCILxnzdUIlJl_RotH6tdWk8hWieJad0rax4KOZqxkkwEpzkyDJ3VIXIGSs-Z8-zN8VcQ9MvHJzda1Re776nOSs_L82UrlhDfn9ZEvh9-5n1_MzBAlhQZRbbeB5wh3ytAIMDdj95lNgyQ5fr06WCOvQ6LxnXZ7o0iUZtboALmEx1b1xVvGbHMSs8cVVymd4nMH00bydYkmWtBzX73yapSL3v1LA_X_WE42wCHxi-ssqCmsw6vysUZSGSe5aLD9W1MIWb0mJ8tUFm5MfUIahRnqkWIV4CO2A3rSsOCoGZgDdRb5V6U6yr_rmxibXzG6Y1brt8iBo3EGbPwcJH8mLigkCWWjhMLyDSlRKO7ARfS7QB9DAzpCJXyOvoZJGIQIVCqSgHH6g1NbI74E0pmBbUqVuf4UT8sSKiBX0tYIUh2wcXZcpV54IuCerbvXCVRGNbGDrkW8J37RJhcd3dHtTX-cri6FlVKufGp96VrriUQmoPwzA-Xoauq3w5zOzLiZ4sTtd_AmUuybQc8tlcLEVna0dfNN2ZCBzGhwgQoJUFUilORHSFo_rElUM8cPRtN-7bQ9tmhoVvfCIgK3PGx9IpSseme6p3_zho_ywI4XTYA83jIBWZX5Pskde9UT7T0OEJrLzj2WmlnB2SzXrT9tkwtdrg4ydarE0LFPN7yWBXGkv4UsnkdOj31-c26Sosa_Ru1_BDg5rn7sbALaV6PjFDeS-d20YbHAPreEK0mV5nqxOaGK1_Zi8_3nW_lcrMaxL9BwxGDakH0nLlVdLR2BAgktWMCb7YfP62jTsk6G48H8vTz-iet6fCxwjPSrfqxfLUpiAuBnMRuXweJHnE2Gc5mWi0ViaZ0-qEgGeBTZa0g1O4aqzAR0Q57l_syMlm3fDv4BSJMetBu55DVYep5e9lTmE-fAyexofAC3gCg0qU8RQhil11Ku3P5Q1wBLjo25jJiP6S0hUWkGoUJtWFQdvDs5qAXqDIlCrGzy1UwRgNqr0gy2WW9z0_CTIeN1d9ElpeKXpGsI1kYmtMIfKPS6x-2X9dI4t3dsPC4WNkC0jrca8IgcarU6a_0eD1t3zdQPXhOsJPeXnh0K_w3zGoY-rjhcwUU9l6yqrE957dfbj0JrcbNyTAxJ_hYR5Dqk6yCjznVmoRcTObSKzBRgORAbll6q9W-V5fcGnV3zPSR_K-_3jhjKnftfGk7rBSWCsNErAC8rbSJdkf6ECE3_bgslxWZLw6VVPuYlVOI4uPhojNzxYsmlnATJsWJlhadqfboFKBbg8r0KBuCEEbsPkyX3T12Xsw_E7l9biHzFVV2F3QSGEbD3UCaZe58XMTzZXQgo3rPxYIFBm-rQveYLPvqCmi_lmP1vnLUa_-FhPxReFxwykLiPa3fLpVet8DXum3BK_2OsHqn2IFmKUkWjaLWyFUCUkpJY2Qs97mmXu3PbZU63fAOBIJny_UNRyLD8VJ35exH9cTMsGaznPpuIKOPPib4tenYE9T04f3HVqobIGhM0LcAUHCT0E02FHY4tSa5WHZkN4h_YdN6nVlxVEPM6d13TvQakXaKMbbt4BCksI_9nnNt70v4RoZKx-GyyyHK5I0RS6TGnhQExCzDJztozQBrOnDtUO6YRkXo8IjDPGVGKOpvwtU-CQO_ZcWqeWFZe_HFS4RY4WZ3UeBuJVMSRTCWP-x1sPFZ1Qcd39PaRJrA5Vs-UutWU4kgXLN3Si9Oiq8rToeXNG0N2URB_3d2OIuu-4Mwp3JjVQPBHGkvEEGbgPpMkq2P9_dvkKhnl9io_N21QuZaROywlWKZzezgks1TfOb8EDjmWEU5mGrW6kl9CWuoZEA0Fxj8lb8ibNQOsFFn6rcJfZ9h0wKRlNGxqHgIRdqy4ozVMFHJoZov6EyF-5Aiv67Ne_K9hPHa-V8lI8KtPpbcGWsqubWK8oat1lu4BW70yw_yDuSgCLp16J_HmCbCcwZc5L6Yh79lvF4ppfBWx-iKT2bzGDcqGKJbdKFZ-LD0B6WUaOdX73gKcNc3fwMeI3l7DDh1P9E6rGaztRfYECeZskjCLTALFVaUYghyl4EdYGik6dt4xZ9dy2zaTPx82weYYpkMXFnzBFN8GRtOiGL136sgHh_SHCApABNZFgykU6WFIAgpGa3uj2AdJSpmJnbhe4iV-1zSMMGmVBS86i5mQEf3SN2MBhxDwwr_1hex9H2HCnC0Xrg0WKRewUS-E7UcSh-5P6uiFMj_LoGRPdKdAR3cviJheBq3cZJvQmw7Cr5jKwh5rxwRtzy1s4wKJNaZa1XFHYWAOZIVvPVfQi5gGp4FqnI4CjjBj0EvT8Ms9iGkuf5dn5giT1flbWRzr4PHKtjX-cwJoU3S3esh8t3TKypCiprAQRLMy4ptKMKsk1IrAaxJfTzYOh1gv05L6nvX5MPWir7Qy1QJZ4DhiFbaooZpKkJkmk4FCN71KgKzgmOtGOXmEQ2m0pyzjRz6BV1ZT1Ey7QPyqJi0bX7PGYVBhx9zEx97jqM9dipmo669DfOuLcEe6XJIcXiC5Nra4Iq0D4OHaV1JGnBj7r_F8VTrXKRQ6P-T1wTbdO1YAFqH3MWDZZyC_NusZSahUJ0NL2gORhBDUGpMbuVme4tr1KAeT8cFYac6hkVuNbR9JHcIZrZLozeQxGEovj8JwEO51-AomtrUI_WANpcV77RcaYrlJ-9VPZegCjxlTuiiCuBC5aOwqzPN8NzQSETqwJO3ant9GqHIt9EC6mvcXaWGnIM4LewSkK2n68H-f5pd5o0wtfQwjnBgVNGnzMreclsFbcvQ10qGb5Ssl0kR8CQ_6Xh9GZyen3_irsP8W4P3iBJLru2Rl6dhZ7GH2SVfvOqe5-MglRsuhZLuxOi3N47FtDv-R_4NXBX2vWEfFLUPiUaHY4VBcjxhm8JIkmcLqb85h5lSgqdsSVr-xgoaX5tnskTwv9Vc6UevStk4qDdDuZIMRZyDwRCZvQb2AuaQoB7SFQQS0rvUQLF7sJEKJdbx0lV_de_Rr9f8ysrE52NmwhUM1EJCYOXTrgHinX9evqC57wCoM5Koo9meSwbzYnNRwpEllgUdf_aWQxAGK78ZGhU2ivuH2wgKwyPp088L54nADb2JW_AwqZ0FKXHWNMqGFGKS226cC98Ek18NHhq4piV2dsCMV9FXOzqiUibEQGx2R_zqaJddMYG_pUpsVFu2HGhkjs_1TJfe5nDLu0DmMgfeYerHjZBmAkyw_7mkGroSnI2DASoGZqCTq0ZMPeNBDAqIzVxEuDaiXIt2S49MZRv8u5A1-xLwvORjJt5zP564WOwZzMZSJ5jM9e7oR96v2rluYxeKwsm0u8ZIwh8gw6q2JWnMRi9KM6zVDN8Mz42vA6VuplL4i-oLM40X0rzPVyNuzyMD35t9ragRS5PELD0yqLU0GclKPEchvehwIU0ppkOwM0bW24vTGzRwWfWCVB0fM24b1WhtpyySGkdcotU-9Qzvp-i_3gigN_rtXCkeE9hu7Ox9Rt4993FuGMiVm7GBC2mggqnBfVq-khT6fvFQaW3Qk0w0_ZwZpvUVjevt0FA_JFe-fC3V3UMFxEiMMg4iNidSQ9hU-LVTQMxEWBnAEhIcdVWMdcipFkzlSToeMAdmSA2uZ7NYXYL9BdUotfk5wNS05x4JanS-h29NOwe1_ihLMdohnrkCqHanHhbjhojZ2cTXGQXjSqgcttVQ7GAMaXCnp-io00CZjV5FsmWq4O2YbMrYuP3diQuSDdZ-m4L0T7x_WYHctSyGpqgOSTuDrVILdTh20F5hHDHrDlxAdhvRiQL12VbIVPcpcl-MNmNpI7dnc9DAfpw_zR7qc-T3iWboZt-KJ0xlGfJv692c3XjvwHklmPfGS6iB0nHhUfbfHyAJYcZng6H9KqZgZ0STrJPPbU0NCgXnSzpVr815f1seISKYZQ_0rJbPXb9jCWIIabZyIz_htNTiJCwJDE2EE4aRI7JNgCH5BImxUSu13Zjgo6B5zh4ynOJk3u7y_Q245B2vHSAMQh3-GAC6Mz6ReEcquhuGuG2HEj_58VbbiRlUoiLCwXHkUNJ7nbFjNxCjnCFHlfqiMoHp_DrcYXM3l86-SLfOdn46PAKs1lYUpCg_dP-P8vBmLbnqo3hjk2-tn3Ka2T8lBYbY8mth0bC4ppEWlibu4cWTVroz94tjb6AiQjesVifdH39t1T9Fm6Dlzm3h68l5tldMxLhB1xj2Fd6b4PIXUv9CkJHe_4gcWEdjKxOUOfsmURB4otkVUgrnAfQctwykvfgAN1BQ-0JjQmyufdxi3qjMxm2Nog5xEzGVJ_aqPLqQKvsDgwqRchs1DA9-_Aj5HO8lb05PuFauwk4KjDDf0Uz8syq9nCryWnKYELE5jOVT-Id1yg69qtbfKSAxnrLdtRsG1RJGi9kaz8-A036N-k-X1DftgOz3TEyrYaK_O58ytNdFb6LpimO5EXG3EU7ujnPt_7lli0tW8XT8Ve85VCUk4No2KgZooAYkwwczXIFkel2iXXFJuoDK828K3wgcHhTDshV_bdLzunHAvfdMxOJnts8m69eSa4PisAspQa50qUNXDiCAhl7aiv_3FO7eZQ3cFXlW0vGwZRZJNLYNY_31EyNU7bxsc9TPEW4QPQjnTUFN0CxV0gFscVkK63aDQTiWL3HYggzvySu8kCU210vWthQmQtFTAUYMeCJGZZSkjMkPCYEOGuPaXWZpj58Xymvxq2baBgYoQzEI8m3GHMLcDZ9_Y4Gdw3exb45k16cGkXlWyV8KJxosw36Z-wiqvFKSSghE2FfhDtTuqfYJgTKCaJMWXDKVEcfPSuVmXHFBP-3EUPaUuqXlI1r7cJYovub93Yn4wKkbqOyQ3rSejbOMTMmeKqTa3IurGjfjNPeTe8FXSPi92U2gMiwlcFUOKAFcddTe6XS7aYx9aKWic-bk4IQ2ddtdzMZlvmxiF0KOouOEZt6zHHLpDYMdFwGZduAk8x6DYNVPyBonrpU0z-Q9h7v0KWUMqba0pPOz-e_ZqRBT1n-bHYYu7WR146RBS7pZOhATAhDl9EFqHhLk9fq6x-GI4r9vL7h0X8938MM8RXic-ds9DEYk9JQg1TCUXeDuY_HkeViBgj1cHmzuhVhg_XSRH4KxVRp9i-DkQUWeduUG2OrMvbK8ksyHB8Hh0O-9NAU_wO5Rgz_RXVPwXUx8PSgU-NzrT68PzJ6AM6vmjyhlz1YLy7oDHiO-GqbYncKkl8XVGMne2XX5cW8zgjvwlS6t57SI7Ullv2_0aSFIq3GSyq19hD0WjH-YkyICp5_cJJoVVNzXRfBOl1VQIkZKvZ-58Wb17U6r4j_aTtQ9tCLe5-N1752UvzqPZGGwWgGlfwFbN6f0_vnWiDWPU8xParJEcb6yC3L4JmWzr8w96I8ibaEZaAp9CliOGZ58A2qc0Y6RmjcLNoSTJsmqXuvxhaqKGUofu5aaAWzBSMkqGTSreOgca93yO8tUo66cSKTxasfb1DlkTAlg6FFj2fgpsOJJ0lFdFdyTE4dx1U5w577Ds8fbeq9rKzU2auKxZH21bbzfd39uPBhbTmH_rd9Qz6aEKoPQ-z_KzG4D28fbeQamf7YFlOWC0CrFia9aPhI1VSpTqAOlxeNRjpnam-PenSXPeTWRenV7wSB8fuF_kgibjiNsiqGKVDQBrL53js-ReJmxaha9ahti9BW1lqanqW4CIZpIx0FT0-QBo5BorvhfxhWRB0J8Y8eZIzyo-sC5X6l09oQoI7mbh1gMTaz01at6DuTwICQa7yLIm8AI6Eo-Rlj5F2IZWqK6UKwAbbBAtzZuY5qWwjVGkOJ6wKInhlNMOL3cA0M2NZFq-zvqnrQgZemS6tQbvC2VB8mdJ2jn-y6iMs9lKpSM7KXbCdPSDSoL7bl7iej6RQuWbKnimsRImpmErQeRwsoLQxGAxayX9tD-6OQRJ3wKW1uAI4aT_DRGCdh7eaFBCoOks9TnHd8HfbkGT_jhLsCJCsHt9MiofB4Yzkm4n6mkj5JfKRCtdpb9jCOTUdHxpJey5Cjou21FIALnU-_hxO2ZDc0Gz7krHKoiQS9rp85cwjrtA-zWmlqEgBn_8rx9JGpW9Dz0D_ySmSBT9H322bKLeGpHohpGMyV103u7Ddd-v1HrWL9eeAUet_8yjRdZuvuIs-npeK9iopXTt79GC2lW2bzHhZqNESyMO3CYzXCPVdXacfASLsTHMsZ62AdjLws1BfwtgVqxIVjXZ-9I0vBGxEEspEYb1oMhq6PDYBn_NAvHh9lNxVnFzKH5mxvtpaFXshLVOC6nSwrbd8HbemGkzwgghXqjWsqUPrTHKDjBHum07-49Hjd7EE3N6S4CCJl339lkwm7qu0a3p4D7XJYyx4Svc_ZZFnon4WI3mauurRQJJM9nzSjlMSDE-zXof6lEGrYXJjbvdwa3SmOOHOMkRXFzsdq8Is_qCEAIypk2HzJR0VoCzGUMxv0pcu1xXiC9AlqAKNMlXtrtYvcvVCrX7u5qLdWkeK2ykC8oLyDyNW9CqAZFSF18woj6UkOBQ0E1RejahJr8BbotkCuNZj-sMEOWl0VsHX01O_Iap4VOHJBvquH5bKrKJODcPTJXklxMbZwpyqSCqHvA2lVoFU_r99Axi4scARB1YbByHtYF3I8s3qJSsxZK9XufyJkZEEIeFigCXF4dmEk541g5QSFrtmv6GOYtxIEgYX47depo1kdy-1Im2EjBPBz6Mz9LJjf-e8qveyq1IYuLu0siqDdTQ8E_c1DVhQ3SKsHfm5cojzKyYXup2MG0e0dTEIPIxBAN3J9cy1R4tiNQO5C6MQWH4I4esX0GOKsvRUSsU85bHmVvqHIKSJNm6fYxrPBPs8as9k4PiouTyxgy79_7celq1t1AImiwBTHQWYpoJRw1wy8SIAk-062t92pepv9fIXuxcOlWeRreWMQhmmQJVZTJI6uBo2vCDa44lwrPl2kBnDnq1KDCEBrMLTX-tGrz3u_7T291bSiEeus_l9RZSxLnLiPDwoRCCWDvLhkvqPFfU1V7WN2FXiEa_JmnB4J0Nn345vAg_nmQfRV_9p8iMpgAzKnBYFp53hiFgxIZ7VvaD4YbQpu_L2o7ePXgzTVdDw6Yf_0fVPSnozZEPQjQnSKKUcGiWRsg18Ob6X1hbMf6JQ1cJ0QfZ99syRB5qzzxDS6YcdhtF4L2tcRBr2oVoQTs5HfT8n_n2jlzRTK2a3_enXrXp-NwQRITXf01Ld1BAPcs-mzlUGMAa3T1nhaIQX60a_WLHyd5c4oRwi445pc8LJYV66VR42tK0GLkGe_7asAk9d6Q3j2MMgdq0RCG6N5k6SmJRDnSZrWosrM115Jtphxk9p38MOBTjBbIvIqs51lJinQCQz_Ee60lFaDbaSLrbagib18TKXGFLUB61xqg9PfKUVfTLuhhEGfjEYAnvVmxWpvoA9JTYgEPPQfKR9N6Wn8z-oS1D4BnGYaIuk1qbMJ9eq8F4KK6kvvd0AfzRbjuNRWeBbh5yG9zfVDhKXgRKwZp5XpStBtlQ47GrijrWGozP5ru3tDsZQwUEX7_TJqWbIbKk_eFQystwAYccEoR5xbSzRlv9Xth-ZpN78oHyrDnpgGGNbu9Qn7XTL7yZ1bSNLe7rIaIu2HpoLCvGlXXa7v6Mqup_04hh5QwiOombrh5PdOSf3LnOPzJzrM8mFqZ4cWFxi4Wewe4p33GMqn3NuIbHyJ1DGxSQrLiRQwbqImbvomZT7Sk7M1h6HE0-jTW_gBKmMWyKNjnLNu5T8JVp_KaWrf8fHZDja-EDJuI-L8HZXNFUyML2MW24jZs-S99L-E4bCJ77D_GOq3fza7Ws_oDlQE1tW3QNB41EDGmZP4gYVjc-TXQekid3MqDu6EA0eY57PhuHLo5FSgCLYUoZxjJ8OUnSEUUOj60wGbqDDLYxpqlh0oj1qC8BopbtGkBHExBKH6N5l7uq3gYQTiV5txhDSVTXAoMj1nr0g_fZX624NAvteNEXamHPeaz_z-7k6qsKdfGoDJqbAWh41VBB3zhkMp1oFLKvZ11niVabK0N8eFfFr4jnV3f76R5dONfA2wkaed0n69xR0MThp7ZvUDNh5VSUY4L3XmRl1pKxdE8QRtrxQKvS5bhEk2jHvrlIyNHAV7zWUxH7BCz8CdGLTNAhSAJBYUF0fwdXriaqx6JLoXpZ3WPEB37nwFl4vi3ywUkiZI1lWcJ9ub7GZ392RoiIZQhjRukH7Dj7WZRPGZsqh_ol2997imoAkeLT4nH98t8xhyvHaXi2G7uDvpg4m2oFpW6DBt1BBB8_7-2pPAAYd0bR-_cRgGoba0nUbu3JgJl6hY9tiyuNSOr35Jhvi98mJB9W7Kk3x5ma4Ak81rQm9w2AAOLVq-_UZPIt9yepda6qJ6yFj-cZ9GF_jgkwpTv9BCklkBdCjNOymWCFRc6MhbBVMvvRPG6-NcUGpO-cyL5XOCJaPOc1HKdlSK0__0RAKvDFmho-2606mHFEmGDNqDPsHB8hFZX4j_h5djdV-i63-p2SK4TX_edBXAbK2AUY865I_Wq7Xif_0rQERCmENflq4J97nK_r3IZ6aY1dGjhAsaUxozUqie6nGCXdRyGui-UzQkIhAaU9oVCp96EN1GTkIU6sT-gWhzp_X50YFWAeYGsLwcobkgojep1uvH3Aq40ADrguE2-2PIOs7L48nzoci9VAo0n-SU-KtVnWaA5Hyvkz7d9-7Tizp_FN_tE_5JsP4AZdgQZNBLuWmbgYPrdZoSM9aUy2-VbSctkWHnQRRGOXmXjd7xH9j7H4IhcvcwPTWS2lbc8fwdmqvML7rqbkkEBi-XT6OqwUzdVmWTQ6nYdFX74DAxAWgELgteiavaVj9Y7X-frRxgIU4ITB8dcRATNII2odpEcizzPB-XQhC01rYAW-QkDZc0RUqdNTU8bz9q4mRm1d65YIr-yGB6KX912SCOTP95sVkOjg5W3zY2JRVu3W6WFaKmRC2U0MkYxouhToAB0rpSxjWfHv4kHd13qf9R9kyq5jwY3NLcSYXFWvFquMFiQnTKkEDnr13_9vqIAN7MeJECh8La4xnDrAOAHvQk3Ynj_zP1G_oC3CktwlGk0d03m2VAfXzvzhXIdwfckwjK0h2je0pvmHXn35BUMu5IRiX-IKzsZiRra5JKQKNLAAneAJsHaVwCyxCQ1HDFhJapRXWE0c9SqieSD50Mppv_nEEnwEEnNNLnn2hyC3TrDzmzCbLTFdHGkKPejPXS4Yx7jndWQojz9nkT_bAkXajdQXQX5nZhXIj2FPZCj0bXskjWYqEY7ZsHUCHGwsaik-jCAJrfe4pgAYIbB23s6QtxzayAjxIX1mBymp4GdUuw7IzHywZpiI2QRVPaI1-sM2aN28pZyKEg3-0jJnSDbusv-JlKi3DadigF5A-PgfbhO9yiRQ24214jHh3yMlk706INpWtvfM9tbF9ndY5v2YJ83tg6q-3JwXPmcWu6BaleUku7cvReyJTpO6E0n0D5MTIsBaCG6zUrhX_myqSVNBDhZMs1_nma2cRX2k769YMZuwb4T5sKpsMsO6wGEyarUtKIvf-Cn4HO9iPaoj4maueaeFP_X2_HLuwP1Q-0k7y56IOESR8EZh7LlE0onH284S2pm88kcm0oz6xURD8sv2jU4Psd9ZvWD9SITvXEeU0a-fIjl25lslpSxs95t7vHAP2-tF9tw1deKsD1GBEuzm3YHg_lylmdGX_PJP1kK18mtbBZ4T4fRIUPx_MBvmrgv35I2Ev9B2h9w-7dSCtbm0q1zsspJg7va9omdbTkZfbMXoNSldpYW2_zHLTIX6zougZkp-BhPmD8mAVm0b6GLbi6UbXXo1JJZOFTjTkbHfeCWDWMkX2O9152VvO1ZStuDtU9EjCsh8TpjxrI3EKVVwpileITKzeeDlS-FOE7oXGpWUErT97a9oiawHjFno8TYrJiDxd2mVR44wo8yw_bvtYfpfb0Y_mjLQfWkG82_3nySnYJlpNR_2QNTOjntGYTtfRmL_eqvmyfEbfevG1Yptnhxfw8Z04eb0Pa0iTQKbxl5iiPdEcdBwGapB4kBN11rIjC5-GRDHMc_AROzpliUNi_us-i_VRq-b4bBJDWTIQ1vS65O45fKgwkyMvq3sz3doVlo982tdiljJPGhb0LFUrCouxNdK2OsnOzeiyi7jpNQobkycHTfsgLXKP9XQ6KGE1wBlXPJcdMOeM9ysLUABgS2ByRFUmHUrNTZXfdRFiD2SFo9tZiaGIGYzOkUQ8ia3j-BhizQp0VamkjkHi-28SNadPhZBQgAR8BGxAQ-BuMbCyPZDOTRVRPxRAeA-h61ChxKa0LQ6wANn6USeEJs_ZBDpKyoHoHrR3aPMgHD38RoBUZE3oFC41rUvOPit-ZtFNCBvS3349u9zyjhk9U-qL86zEQ08oQsCVPlKd-hibiGGZw-fGe271DqWah0oOfaKiBCpy3kraaKVZAYezMj83g1clM2vsByN7D4ALk2pd0bMYtCuXJWyP9UFj2Hy6op0Llzk7cRee0dLZ1n8jv8nrG3IlDE036JkjCnHpeViFcWSu0HSHTd-FtYhTZnGdobEJAVEi-_6CFElRsj_Mvg1ZqdVikJ5dxTJBFTURRnLi872yT5DhrOd4YuP5xBPR8_5kelbHtG39ln7SpmO0g9k503Lze0dzAficalOwbmGD-scqtzmvJxgHp4qqAiVGsnboMF5aIaqDF9jy1Zm-D6hdPpbTm138zXzFOuwTH4ESHpO9nFRfTEfrI-mwvI30e2Ru86Z29S5s5qc2Qrr7NGpuUh13OQP0aPorEzMb2sALN2B6HEWGQIGj2TZwYGPj4NpfmJu1BIOqE7i-U8OHJx0oSaUIiV6HoQYoK0FqRe1OURT1F72A2SQTfUlE-Chr96mPHZxEH6_CW3gC2H39HjzvboE2xgjuR5_HRdkxSYTBajgkGqQr8p2YIXplpLa7ehMjsX5-GCbkssCNQsZkEUt0EMC6Kt-k-0PwSLIMobFqbYR73z7NCDafdvPeh7blQc6nHCqO4QW6wiki6X39Mxks-T_h_CFnjqmAseOTZqDly9Dh1RrF9pV6ehtHIbyg8bpybw2FMWLuYorpQL-qAGH2-z6SUzqlJ3p48RHW-x4hfKJVvsGVA4a1HwyPe1ztmV9heNgQ25cUtZl42Fm0xmDTOM9Fl1XORjAeLOMTCGkTjZOONuhBR0ZB5XUsWqM0joftLaEWzxBp-ARh6BB7Lu6htjVp3Dvzx90hUvAHIF01x9DURK0p96fw1HkOO1pS20DB7zJ-PhDje93jjMqMI1UuXeiB3qZptwO7UwV_tIh-hT0xdWH-LaLIUZnlJUxosq2n5I7DcVsc_3hjb5ZyADLqErFzsbRVrxSLibm3c3vzyGo-JJOGAFYxpOO3uEbX2_k6X2MFnlWNOx2lvo_pwcDzoREEG_-OAMb6ZgpXevOQnIFS-Q1AFyuzbNLYy8OFg1Rn7YYGg9RSPj7ri15kB2XbFyyhyuuID1-LFIB28RWGc7Un_XjNKSdfsyDD1Hsaza_24ZHs9-SgMDpVTIbEBI5a0VRgToeZME9BHkyP98IZ9M__jZkmO3OUUB-z1yGPJ3VmbN4CQRZOwzZwn9nbvJryJ5lq6vMpUSlhCFZK3ku5S-mt2mEDyD2vwWwMUszBzbLBztk0OXW_YdqgnuD15BdbDHkPLjmggEjkAjPf4obSAMcJcLQxtnsejI_zOWpCKE6kvIycUSfosX_RsS3ex0RKnSFVFgwJfuXTF0A_f9ljVtlsfk5KhEZNb8RqF6aSf5dkyrjD2oy76kJI1WWxt5-VBeV-f9JwhXgz9JSoLTWlHGtUdHgYs4NewK8j55suHYObEo7zEn09-4nMAj8vMGVEyqt5vwheRKyNbAmjcV_c2K9DkUFuSWHDKts94qTGAKxaZmqYJ02FB6HBDZXG9HFGfkVigGO0jPzFAcYvhP-UUpA7L8icq5YqyiQQiHuETtk3PBdlN6FUNsFwroNWTzO8CyhMHG8vNB2EGct3KbivpKH7iogK9KNBo88uibRXFBKLGhbWfrlzwfmOB_BJVS7ok7Ty5VQZZ5nEwFDOLbCtDnPx29G6dEpKHdqHaZ4eg7IYMU5hCajgs1G8c2ZwiPj4ZUKBbPdMKu2poh-jhs_yzhIHRzdkc-Uqh0WbEFrFWNeabN6JqZQZH_ZiXEp0U3QaIuNHt-Wuh4MBpA2BckyRQmpgzZ54_GOaKFfw6HkK3dciF9Mh3ntaNSZ0sMQHlRYzlk5vezgyzmjMggylTN72oeBG0ZCTxAPyqk_YoB06WJ-_4XCq5NkchjMmtEwpVeyDO7tFG6AcFKrJMKZYDGudqC71AwGMSGLnmICsi_HlHlH4rOmc0RdSazqYTguqblr0O6gRispnlHMh0XxPuXBgDRJHFVlyffsxC0kWdzk2nbjHvoxrcLMKi_Bxi3OEPMungGS96FYfZ8hAQwLqfaC2w8rteV_arI1HucU0sU4U-YHUXA-jVedgVpnDbz6SH-EpVLGppTQA7wJr5olEtchdpdJHbvQHvI5iW-NONiOociw0jMuR9HHrLc5epIsdRmLox-Kj83RUpwkh4U8XI75fY4EhbxdZwpVq0axv-_0s-EUcKhFT7ZdEJYnzjhkBwr-Kxk31LelLVS3kKzDR4lnOFaB4LIulb_9YL5cy2xjlF3ilnk16qAoQdCYkiG02-vUimHqrB3M8TEreSPb8WenO-Lx12xxQ5QVy_igsvDBSEOYM8x0qub_T5BFsGZ2OlDxgDLgsRMi_u0fwWbRus7ld3OzWfhyXpzldGXmWxVJy9sWygIJ0ccMtnvSXrJWj5gkE-lbu3sJYQs7zSZZ3SI7SWuRYLmZ2C6a9OnlPy-jjTm0kQFqngh_bRlwfJAU3FJQal5yDHBTJxtAH0f7YL820X6mOQr1fGABsFKftksCPtLyDCy6XppULOc2JFzdhxb7i3ZcR52FLdH_81EfdlFXi1Nr5d47mvu-pRdq01HZna_3Rj94Le_ant3guwXIJFKadCpYDA1907DUs_WWlgbgZ5C-FGLJva8yfHMFy2JQyzvydZVHv0qzYsuhs4VilS7211aDFa0ksTaONHtY4B9XQLPI5RXD9MRkHKF4om5eYaLLjJxOyD6nrDotAllsYYxo_PaLkL1TdMJHlNLsZXuhkvt9mC0524nhYj8AR-fGnfObgWnITduYD45SQNtODyMxx4Wr8nr56zUtp390GUnyAuu8KzZLiLsPDv4_ezwfVw1Tecs3EVE2D21gIUrwrOvKvAQP2sOYW2Ok7G5F1adf4FqeQI5RWn31PMYfPa0WLSu6ek8xDLutdTf3ROui-oLEWz5QFY0OAO1sKZPTR5eWKZDv1Soy4_uRfb6apdyAsoBF9tASgQH_Z2syxcR0ga5iZjEEoM3JKmq1G8Q7F7s9M8_Tp3FCvpLsburiPlgv8DS5nzQZYfp-hcuUHxYkslI9lGEtSdNWM9A2Iw2wR18NIK-SPbExC3GX-3UEgsgtUyqSVX3zE5BSnkfH78JFx_rXJktbJeh3zo2rvAeyN-HzECat8hU9OkeUgPqKsXTRYSi6XW0gYJAu21mSAsgmhrqIJqE_cN_6xF3FTFy8HIFMTyPLKkmoFVcibBmvhXbLe62UKvTozjCkhjTooj4HyFa64NR_7ZoxtLEp0ocB9GhGYIevZhWYnXrsLiinceYlvza8YmeqeflL4Dqy1ruDu3hoTCUGlPZaQtGL85a6Y7nB7Ka5SBtDBEtAghDnep2ktZCZMa4s9KmOTtOLz0NTcYhAF1ydpQZKu3053E0giArRwG60izTeAdfXk6Xj0eIc4OFxS4yL7CNpmeS-bN_wcWj3UMFYYlFEkOrzOYmLEj7RVzllaQkYV5bIQ9aGW_-Kn06iVYm1noCgZhzvYzaZI9HWWCAmxzU8fgBwz_ne65S1H4KWOXfmUh6hd2oNlW9i3djUVljTr0GzM21UtHZrtecty42xD_x70Dy2LQBhCIzgzxkSKoqMsRSas9fQTFe-KHs76ma-HX435dBVTPnn-xjQif4eS-TM977-BxnZRdVqY9eVGpZ-JD7drSR2Kr1I48v046ZlI6JLhEhGw_4aNUuFe4nx_uR7KWDzBlmEaSx9h-9kYo3av9sFzjo8JO6YM5DbJXMXmOzmilIxbgkU5zzx8kZkTGtc2w27oFOCsQosREURtZrMTz-qlky5ZgJOQObmt2jrBjxjqDphDuUmlpgukKUtpikhxtDmEjjgs1d2VBWSmY85T4S9gSGmqdvcZtvFf6XB5vfDG7jJJLYQVZhNdc71rbfW-rP6VT_EamykEi12ecnSQtLDHN1HRp_2UZQWP7VpF1T_qFmeR_3jrQU1Vt8_KdiDB0M56tuC_J05DPaI-tYJCXaIwnVD5tfLvrp2J6ldsHLWwZ4ONhGUz1HWJHe6NwKLdDmYetgo4whwswvCjgwWDvlxPaAD7WMZ0MjBKfNkDFUuuGjyrf2oA3Cl1wxe_iFKynjXEelVRtU3JdO2UeRAYgHQ4R3mbq9XWTuqUoirdIL2YE7Oos1OEr7JJZKm1kSGN61SwGKFVjNY6o-dyjU7eV90so-ACFckgSpi-z-usTpI2OtkrKy-HbzUxnFRMhxkdqLL96Vge1azXyXZ67gV5Y7eguZbOhAoAAZWlB2aE8MOwk1uA29q5MHs9pR9zleZtcr5ERRpgmXQK_u_vE8wS3giGmpFxeAabGwSfCT0pKPQZoBRM1DSHCTENFkAz6SDizcr604O9Z1PGXqQTDxJUYNPMZdaBGqBpt5VvMrAZhKQaKO1uh4a-wG49P-12XJKeVXT60yyRrj1GMr1KCz3b_tAiycRBmoB3kXUDCUAeiAKtbnWFdU2QMH7QDGvNwTnTfAuXeDuv1Vfekxs4rrgCXgty5gIt2HZ9RlSZLFo8bKtBgbupONbl4tIZaFessb00OeJrmDkCJa7yvnM-NBUicYO54g_PniIiqXFKJi1LBD_eUsh43BOKHN67Ta7o4GJbtCcoCSUmLa9mI_KH4NP2MPfgddsW-pB9bhNetDIMxS4FDNsGcsEPDNhFHnyfLi0eXkOFY64aNidlZD3CcHvg7IClQ50vaglo1zbQbS16SZdhYDRx2aPVXXX5zJ5twx6SyRN0w4nzcA4EDsqqqIYoLSqZN1jc7a2ZDNEpqKfPAdo4SBxqU84EZozIkjHmD5XEevVHjRJzPpg890nw7aKMXTemphnbvdT_T9eRPkkYjlQRx54N7RGIlAfl3p4z3s8AE-oCkMfSNowLDZUH6Dup1a5F0ABb7tCjsaewLlO9VtEtRUtolasY2KjdxkY3hLbS7EH_eXYz0MmanIwZ5NPxReD5lghVWK1t-F9NydTR64QVztkG18WIdVGGfbUzbPP5iBfAxHpHxuO244WroaVLmxyF2Y2PJs8F6V2eQw_fBmbGe2E_UJZb-4-NWwP-SUGhw1cW3Dp3n0cEFn-iGO8WeNWMsKmX8-Xkm0rTOMFrmryYvzUHZ5k35JSQlZJs3Lx3AkGEthOSM2KTkxcggoOOJo7oI8x4PJUP5FzMM6vXn783wv_L1Di8-OXXmMVwrqhyzzWiu-n9cty4CX_oDpscvHZNse9C9JCpaWFe1O6hgUNYvd495y8sGDowpprIkCiK94aT9E7D-bsiic1YOkKSzrNY4LR_qMlLrwc1goAWBo9UN971e_9JXQLI0kM2jmcCFcOc0kWc2vznLtYIMtIEJeUwhUa3-47IritikFqnaMo09v_pYNfKjo9w9p2JSYb-RsABpestu-TnQd8mxRyo4IMilHSXoVzZQ-nos6WcmtVFunA2V1oF2moD1ZhU19uWTuqFVa5kIHj6Tf65WYcp1_Q5LpPINVc3fkZfo6eI9t37fG7zVqkrTFDspPutK_grAXVGs7-ObOzbTDRXI146vARCxiIhPwM9zhqJrlBxdtvZjcDm8gVJPlGrOR3ZcBix673Up8Fb_WU9bvaYLy5oIb_lHPnJwF1WcVVjDXra2JjS54_QH07dlcUvUG1dxkMJ6IKD_tb9ZiXic7jnklpZSwDdOtUEh8FVtsUXe-l8sewa_y5nxvuuxZMFXQAuDIg0dUii63L73FrYmUcQHp-oSuphHgUG_tZt_IvIJonVIHsNIvqaQAAMuVXGin-rmG9QKqfTuP1sbM7jMJNUBq4DJcggI2M-gJ7Ysrzuq4a0XlYkg4b4iESkEBFBAPkfuscExAgl_W0hoTTaPpYcHgJ9RlGBqaRR7hPdPo2FOLvA7OppnMnYFF5p8P5_6tAh2dfhA7ecDkYtRdAE8JV2eQGxyQvzNDdqZkWU7thU5Bgo-tYKdUMVssfoihAe-Iao98a-N6gbAX0zwvzcm-QMw1kROjTlQCgBVk63k7j0RpY4GET86pawRkrS1GS8dH3ig8S0C3PURsVqxEi37owDxJ3dntX_HV4nxC2Gj3n-NOSdMPUnWBPp3jW79J0HCo10hrW72JQCnNA6tigHFKJ2bxWyS2yH3-zyEl3yqE3h0zf6gfnS1J6Wwrpc3yj9LfQX4GIZPd3g1OZSq-F65EXNGiugTMAteqAXBfVgbA3LABvltiPrza51H54vii7OGINdxp0VujOYiYgAc2BCa4vp0TGSB7wq-98Gbn6C9KZZScGM6dctr8MMVwosD-_yxYzzxIJAijQmN-DacOrnlZFVnIlX2FVlJcoyv4dW5tf1H7VGkzuqx-EmtHPSIYVXKEdfWVlYfYIJJTyPCIPCElnFKLm921dxjaCZ4zc0fQGqGc2OGuOdik2ljT2ltNB2DbpxYMobtgPM2kpFyTr72y4Co7i1vruPMVE2-WFoOQAsL6Qtz-pgZ8eq127PYue7cjxj7SIs39DaxhGtzXz0CeSgmC61pD3UmnlsThQ-tdhFAx_Xo6AyJ1Pc47OzlFzqNt40xrthLv_O0yAu0ZFNMyRRizjLgFjVUYfyFBW8Y7Eqa1ajWxTbyeCA1Uo_Y_K8tAePYwF4KXOknW87n0sS_zKWwv5sPVsFd65k3W0gy-oQFkX1YwkoVxlFFlSbfuoqALSQtNvWGD-uyFry65QtLbBGrGXSaAgnadilodeTh1957gq_o7zeN0qtJEMfUKiwXSAgCNa0QzdTAZkifiFy27SGgXRtm7K6GSxh9_8o5rOslK2_yTqGxvVtWQ_X321MoArzETrvxjWsQ-oefT4Y9cGmwcQNjWbczLoikS6ASd-16RFrIBJlrvx-O9CztobP3k1XUbWdCcYj1AOZAOEbNOYtOrWZ4mK2ZORBV9cv0hgOyjhMAxa27tt5-PudTMyzztYXm44xovqi9PIcJLw1ow6Tg5NO_-A-oT4PEZiz1jnqVjUm3WR_MhR2XUa7P8h7__JnS4F2ZUvFhLf1xvpqoOAxn5mLKI5KNhe5VQdz72Rykojox5gkinVUgYY-_jdEhjcSEL9cmC9Ec14HF0GKV12Gva4bJ1L8XgUCysrN08RaLeb6k4-bYP1EM3qWESPOi8HD_m2ApjtnTriDm7Rw36v3aZcJFK-00H8HylaVMylZI_pji_rFmWZhkhb05U5uAAZvJp8AwMT79kdDAKQP1VKID2tN5a-5T7h4zOriKJRuirpjjygzeJx4vIdRDznsRZQ86J49vr1GclvbCgYM8grG3UV8kzXPpuTN5TED9nbL4Pey97h4bw6OEjKg-4Dh2L22xpO3X-dvSroXYbjMbNrQDdOGk9dexCw5ZsuvmXXETw1uf66YY0bY4hHaG3qCSVF-FNRbyZHpmrr3wrIoMsSTKm4KqWJSMBPSfXXnOJkT5zGNaHuyCpzLevbfm-A7SpPF-3icRcEvGcgyP8eqxPMWtyfEaBkqaL5AgceRTrK4tExvNaCKi-CUXc5BOwWn9JPI8zodM3pKBVEtMcLUIBeFGPv_cK6pBonH2-7yHzDdFkQfBaa0cj6lYliOMOT7IyFmntkcBaniifchQ_mS-tnOrdhkW30P6BV_za11Nx2kMHzoYgPSSwGDmbCsNqrZ3jshOaSXk_aQ6YBoqgoYAiyynVgNdI0DO-ov9xugIVwR4DSi9gKCBCOYM_y__gYjyg_q4JMw_qP0F79nllXos5-3aGO4esUXCKxXyuYbYsGSkPRsR_o8QfXfjkZeaaXKGHWkP7J9QqqJYIuq9yNmycvlVAzgDKdffK5qCXlbHq1uJuzy22F8QPLMZp_iQiCtDgBAiy6xPcbFY4pTQWx73afMrOhHncb62qSPBJpMU4rpVpm4gnALw04EV7VrAK361vz6P3ts27Mu04ws2n-ZvFJprQWzQnsEMAfinZYo-3ViffLXfr3vlmRtjhc1O9t7aDbIZAXM-NvlYaPHKJL2RPeOn2CrgfnHFBZf3jYMSWR00SIJzhajMQiZOiFPCMtuE1Vd_9dle_jRa097br3Ou_mA1xH_vEAdhDrrfvk_bsvU6Y53NcquHIyctZnPwPuvXiD8b3mOMl7nf-dNSTVnas1S1oaVr_sumRGLAVqzp-4OV4VIs6GnKK4JNh9a1gxnNaNd4M4k9r7kwn_NKtQctmbvbETKW2-QgnHeBFApEI0CZKkrpozUaFhVBeRuVL_EuO_Ma1xq02Ct4m5gzCKW3Mgmb4cy-hA_fM2ngnpjPdINQls0r1JXJlXMaESXnju3FbdNOGNNZ9eh2aAxI9sDJDW6oW0RjWclEfmRnXLiECtd3z3Z-t0g6x8_jpiuUIQJE3ZoEzaufwL7NQdNYdrmBiWaUdcaO7YWWad2nRxxB6ovA2504GShVZDXFVOOV5-f5viWq3vwibIkDsJXKFmHGJraZo3BRiwbUs2NK2s-jNYvLcw-mEYTjrEuP8SVyaYKuyu6T0BcGRHtPHCIsLGmmDXU76bjJBllWYNA6Ete0gR52o1Bah6uGd3cQdAjiXV_UPIFYFqJK66T2QMYkUCgQjjxgEIaSPWgWP5U5ONra0-VVLOnUxBR5hsxHzNH0n-DxOJZLrYei6nz4xI-yuQy0oncfEHSd7Od5SRqoLCzKGNgxnt0NpYkgnuAbcR1gi7BHXPzL3PpbSDuySpLFxFHq4rBL75XqXkpoQdA6bw-rlhp8rChT-kpP2CQdc-IyJmLaZdSQz3POfNZ8phBA-d0rs9sgv9uAc62h-gpiWlwe3PSWy6SDhhUp8nKBeOQS5P5MAWvkxPfhXzFDIxrqsP8dRmiq6HuWcUJLWXXfP_oF-kd4zZvUS0vc3r7Nth1PBonwrmnDhZSUYmufoZiWSehBWu1EYQAhQYa_HprNs8g3Psq-eYSF39ePLmd0gH10IPa1B9F_Eaw4TdGwQMz07ktn-lY1cbz0CW0uYH1lpnH2ci3w_fHVNNinnpPO5XKPe4z-T2XN6hzJkBaGg2n3G1s7L8szPWggwhhQLy4L-EBsDHptr-o5_4hbYyBgAjHlEgc3EncLSmtEeNnsqHcHqLzArER-mm8PE1eOUZzYLzVy__NMpdRR9ZxDMZJoe-8jyiLQVIsQLAmCF7BAt9_ZLVCwzKcsRnrnMXXfGiIrqilUKS2QXadGsfkjxS9Bepp5UaDb1ZfjWKtpjcSHSqJTC4ENj1Qs9QHdF58wqPxEuA1hILlMB6KJqfcD9f-VxGTtxuEd87iOT9kSroYcdLZngDjSnm5Py3xW-neq7fGGRkm-gfRX-cgE2f7y4r78BvLbW0nyqkthZPubKcqcKCu0YbMoZTiHFHf3fNwgp3oodYgj14vbxyymxzKB2ZC_nNYNgH0kgXWS1_ybPb1ByedfUplXTPq7EPWEk6EtccUwXclWLUB83Xai4hDSAy3e4fLb7CfYUnBtKFBYCITSQLdnYl6hlnmCjztScOa2hroehaqihKYB8zBH9bbholpeaVMWJlFtrCI1EkGEbtPoMMmRfyJhiNm0CP2PlNmZUsAuyiVrGGmxBKOnm6isebKERllINQYnYOL1-42c3CSYTUYYruDJMWnrSFxn_M0QHsbvzJGJa6zndh18dxdmJ1vDs23dIhDvmsGoz2vgMbCKXi9W-XjS-w7ZzgqgwOoLQA_WMkiuqeNTPAqstpx8BvhLvp0ex6tuJWRjm_4K3eMbpJXiH0Ffks8QFZPzbsX5UVyDoDzSGTN39EosrAVKjuPDEQgZfo5vUPLkgYSbb0jecBm-BxKiBgH2ARjzGdG3nCmJsI1pDvWO_MZzq1yIN3fubHpl16k1gydk-WeFrui4W2OSLq-pxtR0jJkLfbA4SuxYwFMvvQRIDHLMUOPjwtD3Qdyy_AlMW8jsDLUOK0skbHmjmXzaLFz0EqL8d3orm9djzsSE-wDeq8WsoTSgK9l8rS8tdI23uqvPQ4HknH9TNFb8yLtaPglW9gYr9d90XsG4-sfqfVVXWpZvq4olEr6NkV-rTUQO9kp7_6SNs5es4yiejZYRGdgXNHIhwpin56GloSzFgbQ9SEIkTNYCkR3y1409USZLmXR9iGT1bEQKRAiZ4YRUX-RZfpgddgONAKwIjvzO1Ug22P6BJ4Y7qaKUpEbxScH_IByThtQE8r0DC3xyfV3m5cNmYgxVax1a95tOWtb9kW-ZHxlolHY5eJz8WO4oIrwAhrFbXysEQTiymY21hQrxFlDx_5EkdsDSk8DVjqXz7jNUNGox0kpdlTUzkI80OjImM-2keCK7IJXYWsf9k3eCSStrdJdcquXhBctvgc9D6NMQIIZ9d81GQJUU-sG43Z6OX2NQj2u0qSdwCDPBkYmL0HIvU0Yn8rz6oR_Omr6YgW3EoijFyRul5rzaWQNq0APqB32pHOeUzpHa9EgryKf_4VwGvspVLDVaXXE51uegWBW4_6WOsCXhZ2ob_wIoDFAXvh1xyI-Zs4KuHRERepf06xP1DUiPd0HzmCEYi9UIhUFWwOC0ZoFLZq9VF_ucJMho6ckWbYISLBrDe03OEki_EVx4gYMxryooGKVGhKButLk3bVbeui9un60ue1jOn1H9XvLtvtpNoSIZWJ-enXHQ8NQAk91AK4xUFonaVUyGcdF6U8cE6pl7CsJEnlmDEb_QY8uU-pCdpqjMzWlNnmbmyxBcrNCBaYFBbQSXoOqBD_mJ23aDUuXZKx8blQk3I7uH6SvfVo3Nk7DVxOgEPj64crWFxcrU7FL5ddDFR-29ofTcAbg8uRgQq2Gzn45R8xnb1SUFnEa_hsaW8YGPwFoNEihO67sCijV7AEDWBNjV1cDg2MlcZu8072avxApxqyHarMCgzOvlyshRh8_refobRp80wDMbf4IYtlDS57x-5quNdSpcXRhKTT5njIbYKSebaoSEuQlAEl4wl3yW3c1vo9-I-4qpS4C-_T6qMLwAQgDKHVzhx4Uq6RH_wfT4Fp-sp9m1uFpvdh8J7OLKHkHm_VwY-j_Gm-TzGO474XsjH5lrYEin76sMeIx3Hgjk0eBDLCs1IGgPHmPivnyvyNa38-xMWgNUfRi30mW8ZQw3Fx4wnIO7UcLv8xL0PhJ0kC1RItYp-6CBsyqRWgNcbZS5ZdEV1lqJreluy9Y5Pem8krALdiJ6ChbtV7FQtrbRYuhPh5L7CEf9zm653tM84kZtBb1uL6IJhjyxh2sN5b5t719Q8tBAYqF0IjXVSdMvxgtWFJ6Ap7pL7VtE2Bzuj0kT8FyDJApG9DvkwuMoRC9KgOp_THN6QPwsUIwPHMwisRwd7c-I6sEsMOu3ryUtn9uzCPLJa7kXWTfzx_MVj4XFzY7bqWxfrqIUxKFmsIoLUDvSyF8BUaaYF7WR1H5839mV-ehMED8hIYHNF1-zhgidz_bmm73pMRFX8pxn-cK9Lee87vXhMmB5r85SKgXY5AceLUaw8xoZoGiKHXYxhpibRfaNYHDMSJRKbxYOCFM9Cp_nuwCLu8CRLxQSHPe2fj41IMkoDKOOWR9uq8IDaf2Gb9wfO1cvfI-tGk1OiaT3Ov0aHivIKQ9Ua1tIe4nvkQyWM1zHQmqGWm0kjfWNJ140O3XX4Q7rJ5KgJm-gmzcpAnXJmTABD3lZMn6GaHDUg52vGdhca8vI7T7mM7eIbruhSvVhRa5XapACRZ50HS9z7pEieRbQP_NHQd2atQEIrdmrNTZFgXC6I2984hcKVGqQ2M31Px6zjMrHQLv6UBsIdBaY9WMRb9PGkTD_MEa46VqOPk1j6D81HJZfiI4mW1zYqlih-x8KxTG-hcPM63M6gkmpGTlvOgcAWJZZPGJSn4rvTgGeofEV_PIa65qeQ22G4pvNjldPVxArOMhVoyXJXh93h7-9-FrCW-YFMnPFGw0fZHbFcD-XcM9El2YGvtolZisAMHJqQqvoE3FgmI4a6593wycjoD3GL8pKWSEq_sjjN_5NiHySZGHWWJtpdF6bp9SiRBZZrLNzltKY9bSGFMyGtOm2GzH1BKDIqVxW4u42LylvjpAc7Og8hyk_GGZ0mJP6T3sfUCrfyzBriw6l_1Qc20OXXyOMt2chqrJmGl_GC1TbfcpVsG2raxE80yj7yrqtpl6Ov7Ah84Qk2vO3PX2kSKqJK7BziFl_pOiecKVPK3f7rzclXwRycpzq5_pKHPBAtQYZ4bGF1pfWvr5MtpXOdESvrLVs98XNTMPO4BCF6J50STjRDbzxALVN61eoEpvOpBu9wbVS9FQtqR9QTl6F7JcHYmeaqbVxwDA1ixcZvHc4aOosyiHizknox6t1lelZ4CGZImBiFrrFuRLayboP5XgizxiCbnlxBeWz-jvIE4jIaAPMpHghjwjuizvy8T2BbfsTKKz0VlaYdx0puN9BgWewjFP60NIe3hZKGbXxoO9mArmgnhVpV8oNw2XaxuwwHP3Ojv48bNZiIPtmd6180PIxTLvbXInxd9V-fC0ENueOZssQwEHTpThGZVKNmGhpCToWioE1uHu9M8malURaULUYkxMwZu1h3EELJc0V-gt81e3uUlkLbfGPlVxej-b6LGaINi1fSfgjklszue6Uiys5GmJ4vo6-iLq2Gm6dSsVfbOSFRqy1DVMMQ3aDgkhpeaw2LXFsCxMboue_RDuJbKI1j_iGcefv6Amgfqi-fWby4udXG8epqKbclJKtqfASvqg8YkTm_edJ-Zoles4Hejydu17EaVHAJMrWhXNDYoCsuckTq6Jl__1B46D_VBlFKyz7Y0IbAbPVIROr33gZSGbXuF6uGwUIlA6JnVg5R_M-vclOsENKLvOvmZcGzUU1BF7MUP9yTIDArJyE6J-BWSEE_GHEQ1yTqNMVcOXRPi1EXO6uHOBSjAVmexsBOkcAgBh2hiTS1vmLsD96Kn4zCjZWz3Bhw7pSeBn0hg_IKOvPbKPwBUTgfZhxwchk3Z4CFo3e3es7N7Ls3qASdcIwMtEO7n2vAUOf-L5qU5H2mQEskp1rjGI3Hevp5hGPmqI0xcADlyFhRTdyhNHCHu55ABDppGlYwLWn6CttoKgu1DcmwRH-FPwAdunS_ytQkiflxFjmAvHADkc59wraX3wHB483SmkLfVY1WI-ZcVz2iCSaLUnsoWIsIhhVwfFocS4sqLrNInEGyTeXyLDApzVnbdHPDjwTd68aNwdEMdCXkhAK0_Ejdrd8oJTQ6Yq2Xgzv-UPmohOjdooZr4nRqIKyYJcEG_kohShrfvnAEU6UDk1upbfljS8Y_04hj9txwsjlV3rHgBm_ncBeiU7e7D_W9dG0jXG72VVXUuCFmAfZIzLUpxOCaJHkD_M7n7bQj6Uj-sJh2g2CSFGXVpk0eM9scglPkbjE_vxlRF9SSr6VZZHtzXLeuIO9eCzP_IbrEKh50txhG0dLRmqj7rAvmVIDeQpJTpthSUP0jrdu5tIYtYdAK5Wui0e94HM9gDy2SuUBD4gkZS9HSrn9QyHbjj59BHviDOtx-MoVHzKlppzjjFT342vAqY_UlYI2LwF7_raO5ndyUMzGKNRYeK6Td5xRh21JyPzFc7vKGACJHxTrwaKSSQQAGyt4RHvmmgUHgjNjjSP0r0p0u9WWHA_LVbXGM0sEU9oo45x7QOhPkVZuTkaa-trDsZulNZm6i_AhC8DJ4fCQMqFgU8zKL2qmQNCYpmaVafi9L2DcnBznKaRcxt-pYJAbRTXkq4kF3cm2n6Soi3q1T7KUAs4SXTDbPcArVcaCfLXNRbdaNdGUhOraaA0YEdem6L5Fwn_VOJcQOqK69vO7UB0wY7K4Bff21sc-6NAdqpcVYJ3m4L4EcDeWKCxk2MY5Yq6Qbzvc_S0YEZDOYfBjc3gzUta96u7ccomsG1tES405abMXSzpQOe2qAKY_-omzhFoWuLkqHHnuoRixWIUYtcigsWY3-JYQww7Ck6nQ5UhvrLBd9PkuF_Xrji8CgBL0ka_loYF0Vo3lVG6nTHcoY3Gwmzliz0KGdZCtqxJyWmszu-ncgBAb6CdTGhgJNDsrG_M2fohefz_TKP3zPqJE5DXNh_EY2jC85UvZxaoCpc_ePLzefn2ksRmAMj8KJYiOBttq-QRd5hKNko2CWaWKPzEi9-rIHlkrJ1UPeby05Kv74u6z04l2TZ1LZ4e-DUBFQle7mhrFS9Xmjw9_ka-DqK0zFCOv9NP2Qtd1-6AEjhoecLt9nRsD4I2pCz-YA0_aQaFBVeOt0_FFmh5IPcl2ImEIrfWeoRXIJOD9vLCR75iZtf9pZHh0XZvlOWmNlbOEnM_2BCwglZpt_h3aeQFUhdAvxpk0jcjQCZh_3PSV5R5VIJCXMbAhdKhPEU7eUNwJD6Bg0zEgGsXGc_XKfiVx-y3qmAsdGmugc0I5q-0F60JuNgvc40NauWXxdklRzvNvyhDjuUfONiS9WOReyADM50DXdKSlqYsoQmBfPg0XSh3ARYIFPzo0BF-S1vEqQM9y-WufpPzG5-S2yi8UC4x8ipA6UNxhcymTLpE_m6v-R1VjpYgsoivQh_R2tRf4DUduZwM8m5eaE--ANuBTm6DBwRIPiu0UHegiaO1-5GQbo-mYpIoJm3z8TkLA6Dp6O2b47TLUMMOrvETTAp7b-7D3pUYhhIuNiNk8jzDSyRtQUfmQQCRJSJkfbNR3d4Saq7hAwcYS8XMZpbWwBoxPpr8H6Q_y9mDtshMMwUmFEUDmDAGt99mcs961iTCXV41usw2UJWZ3ed65feaYd2Lx08IB5RsuAVppmGMqAoIImCl2dPHHM00y3ovxrgRoOQbcg_V33C-XRXRxHYu8wgjfsOZGNxLxMTuzHZvCul0iY4iqn7WQLSS4Li9j6MjO4Aqml2krBqwY2OJb7eQqXDL1vtkbaRJM8t3oO_rbGkiYhQEu-xxujEc9-2splcemBuhnKpQTEcHSv01eNdISxzH9AwoZP0eXQUbspAZybZ4C_JfrA4waBhKIsnwY98ogIW-D6etLpbH3WGy_meydUGP50wwn2DBO8YAbou_gV07ml8JBaIKy8ZlxCTSATuhtKC7ivgCzhKc7P9PIjBjNqJlZcAgKt0FpvrmrazD842rrvCp63YwVHQRwJJKUGrQMm0jv2rj4GUoa18ZoAsUYocyqEmYVLlxgfwHSt1lhGfrAsM7d2ycaUoKRUbwoHtRQGDHFnxc_5DrMiwm55U1oIiloM9Wh4ZfKwjD6UIh9h0G49Rb3L5ipjOcrlCt1ZERvdlYe-_zhE4SU1Q_tcfvAG2NMDTR6opwiLidV55UyEnmsfOoO8ylX-LbByr6-owZ-0JcSzAI8SgjZuibqMiExDNSlaXzpl0wos0cN2hfjjj5n_Q7TPb6LwTBv1fHMdL-cHuXTBSvyk9btonDScM4bfOfrq_k6gEiwI32SPzBeodOGzRbIIBASbCjMcZUUNf4vDGdg3KH378ahxwM1iBFpma1DrXUCZ-ltMYSo_kis1uVa12SupxABkYa99CLt1hf3SoXV_DY76NV44sWg2cZDzx4ALYbo5yW9K06wK9OZ5gFFcWxIMQmHhtTRkr-3USCRNoy0hccDjgwaHekXLv0FG1kZBAjLIjjH_xsOiU5gE8JmFdYz-s3Nl74RReaUxuwy1UIsYySOJYC6-UqqTE-AFvoqURCEkHm56Om03jUgo9UzEkbKJKf0Nwcljvypm9-tc7W2oZx0LSgSUTTCw70N1emIMYkHuMH7imrIWScmW_Zdh99U3JEfZYqkM63WCqMqAbiHIXhuECqJkN3CY5tGGJkgf_5IA8yIasJ_YY7OAJq5HWcaoORMcXvd2a-YkRx_czSl_-mPyfbff9ylvfHYh8JegHG2Y32NaYjpbX0j44d9pKy1tlOnZA7Dq80T1RQE-758NW57p3G1IQtvGgiawLIIw4LwmK7FF_P_eCuRXCHQydc3ZVzzeMUoHQiwTDArFA7b9IyGyxAJggm_XGgffFpFWfBRxKGnj-LOZLIoXri6-q52jWI4cvMZCJHJ2ZjjSUOU-zznTwJZg3ZAAmP20it-wEZV_GZ1NfFyYUiWS_Nc3XSgDUmuBQv72J2RLU8f-AwZKQDQwUZye7fRWPkybNSJXyyI1G42CuLPzAvFufXnx-wrL4obEPDpeLhTPPIe9JPgpBH9HjybCPJnkGWgIYsbfhJLu4LJM_LuovQ0sBhm4LJqRFtwrW4ivPPJiM0n-YK5ZjeEvP1L8PBWX5YhsIF7izXSQs0waZAk8y87KKSwa13tiUKJZclisM7giT1U9kOSBTpuxFQXx6vEvfuaDsgwkAluD37R8QOX-siXsPD0tvS26AxzHboaNcOvaVPqLHvx4Cske6oCfIe5eEz3-_k4wxB5BL1C3vRy2HwT6IuDl-ddlmXFkFWavoFNWJVUXwaKttm0pSqtLKu-Mcja15cPljsdlvmmev8ZlLMpGB0XXwAh3Ut5BJRrBgG5bO1nez20hg8rrVHsu7_ryJBjaIiN6dzAhuBIeCjJdcHEm2J78MD193k1nsetS08v9y60ooFnE7dP4BJ3h9Ugo9GlnfbTvLhHG0LBLczrbgSIWYPAsEtCCnbIjczy9C3a77kIR10_dC4fOyYGJ8r984vITVj7x4p8j62ocj8m32wr6W9mpvDN1lF3E7yuFVSWd1U3oj_-XCuWmBVLKvnJE_hmXcI-SR3rieoPJbEQXt5hkvGrmwnQqWTLFN0qIIQtw5uTkLrgQD8BSHtDY_p9W4S91BrTL-FevpNCcuslN210r2FycEY6k0Wm8ogv1XCemVGjzo6v8xyz2GYYDUtDmkjeBJDYi7I6RE5euCWip2AbGF53BE7fXxrPXLUSEOWvHDdokLxjF6HIJmRipc4AGXrdXMNJYXHWMmGKCRZzLm5s_HVPyLQLSQNAVPyNDKix4-RbjNZh49BrzbVhMcwVnxs4DQhKx2bKW3d0HjKTJayMXTPxsEhyF_RvIwV742VGComyuvzATomMdqRyMnw_mdjGWwUXsmS4940d4arbu3FplqA-mxOFavIZbMCiYz1MOE1r4EO2imTY32jHS_e0yR_ppJDbvaFd1lfXEkFln4kMEreAItkUXRfIEE4SszGWAKKlzfkBsqUohtxNv70oOuKlkrNCYQm3j98IFVRP1Te6TSRlZPXuLWZVEF6qYBSr6A9OJ8_gSqyvnOTcFCFpVwDLibvMwp3OXiIYrcmiU8gTWYW7gh4Zy1j2V-GRjmCsdkccd15wm5WtW9lMg3jVYcOV3KiTk1sL-_bVuWy8atW-2C2uwtyfsiHxKtEDREktOP4W-8vd365MBO-2Yh9PidBz2BOfMZhGsrQ26i4LVLsly4R0L2T6A9_3SafJyldMkV6w9-XiE-Y4oRq8q4-Mf7ea8fEAF6F5kNBCuR91BSkl2fQ_fcHW7SKWlfKVxv2TPnlpWSX2Z72aLb_8L17wS9ItF8FmpsXKviS7pYSSzW0RmJE4Ww9Qr_voDoF0KLB1NzOdzybRPW8SZNYe7KU2JMWKzZNfpE6-F0u8rk0o_qZnHTXYeuQhxWcEuv1AVZUDChM7DMr1YQxfabbrV4LaYHmfysGlAGXC8PUShBVXmbuuShIZNx7kckEkYvH3pXv0nxnytWkJNrYhsxTgGmwhVKgNnSIQ25faEUmO4U-vWwgqRIeKTDQcv5N95QCbhLGAkrYnreBkSYxKY65iGxxlR__rfxFxEJsEHlG2Una5xGbBu8HTSdLK4YlW22OedRfD1wGK4_4yBwUcBsDuDHg66FpahgSnQmMn89H31pO4Za78Ns9ExRPrPmeGsEe7AutMUd-YdfBNrGYI3PGRyHnmCd_EAWrRwYDuC9Yl35S41cw0yBSgcBK5nA3FBPUSeRt9Wa-2wjdIBVCpe7XjdKYm_cmyxO5Uio0ZMLi6mSGMJScDODjb_nIRjp6biZ2-YWQY68xNX-pZPAZPFqCVj4Xntffr1HXL7w1i6CxZuSPdbZk1xrV3SzjVpk2457akUXkfo0k92rDwnS8oitKBjwmvR7ot-RivbEIGAM3Ohn2yzK1RA8S8P-toSsZpH2GGUtq2mTNX1yroC2LbOE09IeCbifAZg04_hQDCRPIuMEN0uXG6iaLXFCkYjp7kboi1D5qbVzgbRQ0ElDISpMfWAdFAfnqdVlBlaBZvy3ef6lJUTrpPmBDccDO0OGnTk-FaeU65K4J9mEPN-NCDKeNZ0sb92hGff9eFQfBiRxVMSLTLEh47KaZuaAnikW_s9cjES5kjxMse7XwERQ2TVYcCAZONvQnirt0d_iV6gwkkl9fs-gZmkAsRuKgzmT6XDAMvbCINmoFW2UJxfBmq1HGCP7PdNzkXJSca9Hh1IHuBlvrR-wGtfL-XtN-yQ0ujlBfI2mZAg-PUXQTikHK3Ue-nZcX5z11Me5unxJi_1jHtSXg8idX0d6ewI0eIAwQM3-r3RCt2DAo29l3SKXdLoE-YdQ7LgJPjstIhE4fbVes3nMpIBfUbSVxXIETpvMtiIO0z4LPYL_VGRnDZM4RNh2pGyTZyvr2M8oxQA-dKq6yXiMyXrFJ1vbWnnSuntjvwsZXBLM_6SPH7AWih_08cqjkjKJj_Eq2XJZY34W5qf2B8_Z7iC7p0USOLJajQivsNfLDWNOFnqW2seUu-fC6zNOchnjtl3QsqRskoG9JDqxsq7RDE4Au3ytii361mNVCgrve_fDnpRvjJpq8xKKUBcquBprLzqm2c3e6fDkGKvU7z4_jPtA5_cZUb5Df0YeTsuupg4Ai8wAQia2Rj-OQhI3uy9n_t3rB1Jj8bI7XGynKIEoEf5zSKZ7bffC1s7rX45YDU6ryNNUGyDGsy38EQoQu3Uz1jlpWGpbw0zg1_XoQFElpnh5LHw_C0s3ZzML1lgl-sLd_nqKzoyrn8Yn42x-vAQE5PJYX0PJ8oQZuPkj_x874bnVN-fBK7qkyfXD60yNoE-5smLxJUo-mznhVqzXQ0rYzZDRaIctntLTzpKaEaNfDAcHZ3I2lw5yGrMY5ToejbxuB5SEopUStM5Kf0UMtn9aqHF2Fnyz0THZvN2uRTsOydhVNy8k8K6nfm6uiucObHPnLXWquBEjCcld0Rs3UmXcxScgtuxhfULoSkRzGlBn30-E5sH3b9_Q6aVkK2G7KV4-SULlbSubfQym8X6NZVNsD5Chuvv2AVHsUjuVLrEe0JFzx23S7cat24qIgbGHYpXXVjM_nJCaOngSOv9wEM31DorEcCiYQ5KFwWNJQtEB247WkxJX8sWQ9-xJD9F4LHeAcmaG57nZHxhSUvW2bmqvWLDVq4k9WzDBJeNdcm40rrMJQzjJO06yNvZe8_sevQGCFDgKEL55GVpCBp63M91OZhm2WqaEwNNM06ZKOEN_RUM-0kMyEiG-54srMoH_a0w8gkFSEdCgr7gF0HFiiRsExQG_Wuc4Ng0ls8QQfYVJqQsb1gRME4W_0K7ZxJmwm73oiW-ERru-s9x2QDax6ukjL560d2p3gTBogR64OIaHGRtvt4YqnbRR5Scu-mbwB9IGFrTPilD7siR039mqs_7zkpqDoDBjPXlmUM3tShrHIHu-A8Ey9IigU6llEJD9g5YnImsDAjvFBoevVWHWaG9Yz6Fu5T-9zdd6XEdJEsQm-rEe-eXyhTnHDR-xJjxSwRhSXsxoyRWvhHJvTbhmKnemS0yct3WlYCMF4zlGWNe7Oh2xZ-0T8wbvaeDUs5UJ3O0PIYdOw_IaMeNrZPGEHWm16KMYXog5BG1sIVfRrlYSLIWE6PVaCinE-Sf-WQsgSJPT_rT_r9no8TBLsv34ezCLiGbIxb2ZmyTnZj-DEiipCdqNuJaXJYJZCLredEPraaALm8DBkdQHqCfil7rLUO256mmoHzYb4IeWw_N203SvurnpuOHo0kfFJBdYqztp65KjBbEGGtpqWsp5Q6BhXDy-zXimsiIMufyjqJW9AQhwhYwkmlm_cUkdpqPIvM2EoXFhcqjm3CINJ0pDbU50A4_r0Em15mx190vS7ZdgPGrUmp01OWbcoHMWVVOJAEM_wHGyYvNc51Ld2P7JY39qze6Hn5HQBVDWpaR2I4z2_TC3HjhIPPmBRtocn3O6xLRp1iM0TS_FaLn6iiNMS2B4LciEwEZ9DJkKKmYN69pjR5KSVgwEXXQGIPwACj3sqZxthM8g5FyE5B6C6e3FscauxbtuEONNKX_gXJIPWby05mxsizu7RIwuDv9CNYs4q83awXN7RYUD0I2ZCm5GUWNrH925yc6mlXuH8WVt_8or8AmYQZC7WzfRFYgUvV8kYqNhiinJzRlr8y7Yp9-P2dchOmyhPqSeZYJeFbZJU4JtMpNF7U_gpqPFNSzsTWEZN6rcutLmsPuKtUpuBFSph7ApONlwx7ucFwSy8UuMrxb8NKiWploqpXU7EqG6APkqBJnQvh2JQXnZ6O6EyIaZ7PRm2qnYtwgnhlkm6idMqhy1gcM-EuSaCsHXXImm0ARYUS_e0WEXigI88C2dLun3WbBD9fYmyF4VB4BGB40T-hSXjbYFH6BQ8eJ7e6whw_YQCeyQ4JLlbMidreqFyeZM-Hi-pkxZEetGbJzVkM-07VyKRjVxSs-PmbpFWfnh0OBwoWXDKI0IP5OXnLLtgEFyaOvNJcKOhoM8mXQbooMU1c5v6cZPQ5Bu4wToUKgucmyPkpo6aY2iqVnuzkT_Z0OfLvJO40Cki9NVFzGDg6GxBC5-qQTx8WJ9zdtrNpq2QEn0a1U1cNpg4DamxRuexNHzXA7xn-n34vrmyOFGOGP9fo0eAzy0X6mgMoicT33aHnnxD-mo2ZRM-gCklRqVEQttGl5pSeNH4RPJAtg0abJKnf06Sa9mQzada-fOppL69xb32MDXrARln-_p38jS6ihxZ0xMIhh6_QYXZrORD2-GFaYbR5n6IWBRDaD0AiA2ZsGAnuv6TE0uQBz2-Fw5CT_yd1T8rRwr2Qa1HffLPgk3o3H6maE1vGTwNent8UMzOfDe_gRdl4FBeAy_WqROzy5IJ8j0au5fstWvtgcin4q0YGFwn6DiZ2qnoKnnY_jW4KwWrN9h_DT3Ya7bW_RbRlxDjq8lulOOQz1hev4mEwQakGedAqWkg8GvXRg9d-P0f4a9UAuHBD6yGIMSTK7x6raEZQUwD8tpYIVU2Uz2QZnMfdqamDOMRgWvd0v9IT3Lfy_0VqUXA4kWvvyfmuPW8uRwIy0TbRokOg9brMjxP13zWr8G3bqxjBIow6Zk4wuNpnjmWizMyh5f8wQxm4-NmiwXlD-BSBaTvq8XPgmAFmDLmmdBAxYD9toHjIOAmxqW9i29PCqEGvuckqX5Q55M2umOM2sk7fKHBMlFD0IaADS538EfGKAoKuRD9inYhF-9jRvQUWQdaaiZBn_bYlQTUzZHV980Yu7av89OtVaDSatj4mqUiYc_cLxqD--4Eqa00GizQclj_Uy_rI5WNYVd020PvHgsT8kVp0UBNR8jUUW24FZJCDmHSbjnC8FgCeOK6p6jlzUaq0UENruv4IbeOC5wYWd1HKeqiBSrtFKMRwCbShb_0n_GMAdakvjJ4ulArkdWXToNljmq56rtjZmhW-0CEcrB4QrUb0sjKuv_PIuNL9jFAj8NxtVJg8lt3c3-J3_BbLXSqCEzSPeEQ2V3VlbvXxrof6tNc7S6zSc2eDardH4BwDM1AGKuap6XhLLlk1mTa1o8u0yrdMTQy6e1R_ssdP1VJCuQj4wUnVGQ0VA1EB_B9XFgtepZZ0LlRl81_tgTpjInlCXT4Np9hanQICYyPdByXGBxavEIPlIoYmO3TRgvJmseYsclskLQhs-BHAN3TwTllvXVpwJrAg-YZ_67GRpP4DuCBu6aIdc6SF0L5OubsghEdXHG0vi1SLC6ovTQubKOKCikd1Twep8Uzn3yPXRouRy5rJzDY3GQFEsMujr3-YAtI8nP3hWzKBGTbRubAPbIHWZb-FvoK7Bo0DaVBb331kkc0rKGSUQiIcAIJZtoqg1hPXaOI5VqvrwR-lHSl0txDo1GXf24Aj7jas2w4rvbvl8eXoi7BYzU7bNBWV6JI4rGQqCk-iW32T8iqPc34YCB872rRuUbPANiFzfFYd8VPyrjq0hKozkl7-SI3irI1I6zAOUDL70nsaXl0xDWow9wk5S4Pmp_hLhUirAAs0oU4C_-V95T_ZoqNnndbhpuoYlowubfXtGAwIm3kdfDOPM7KAYfqPanfS9wbElW-v9XZRg2EmgAe4kKWQUa8d02RDmxPOsupwWU2defJI701mFDv5IdhNUniRIw-eyXNUlVNmhpmICc6Fepa9YoBoHATXxTzFXfRD1W2aQLuJaQL5nN7XGZR1zYeYPgzBJI1WjbtwrfxMlCDZtJyyl1hlSNWnsxJvsjBPL4qZ3WQBwMG6fabKv6owmcWEkwlG5BaYVmsL-AyiNLzb5VCjzd3s5CBG1gai3Tccc6_8kCH6AC3Jk9BsmX8M-kXjE90ZrMAA0D2ZwNP3oZ2t_C_dsY4s2g5e8KCZdCt5qkUeWn9qm7erXhh8ezSkdjuGR-2Ajr6lNHTB9W-osnkzwNxUlCht4N0_0j3USSUGpaGQYqK_2uhBtesFfyFFLj-0i5Gf8WGAhqe5yqqjL05TgSX0x9dEc6VxOEktuM3l71JiJVAACyQyf-aOL2sm1GntpDQLuTscdp4D_4EbekwC5yNXqpZ6g-uaOgPsBMf7lOtM70u41cgihUWDssG4iuuwSWblM1DyVwGpokT2VJ_tBXeCNIkZfIrPJmxe5q5ZHlTxKniD3JfJfq__cLRwb-UX_ok5QbjjXgUShzDUsbMmdB6HB5J5BvHRtDXOY-pzS7DRPAbJpnlqp3hoFGqOQ8uKT30Nna4EqBsnYKPJycKURui2R57xfRJA0jWOCp4eYKSDI4NHyOArANs10WQdT0LiSc4FXK1xMbDGeeaiLBsiCXDjZ9Zv0YGs2IPc6WygEUdnhO7qGWfR0pXQixTx6tT9ODjkGDUDUGsHg6oasp5vv--5DovYsnRG9lQi_O0iirzOLJmAJqeT8fqN7_iVfToh2r_x3xErOQuz7OKFkCsWqLMC5kjyci3YYwSr3qxp9IdTt_vH_XRKZjzCXjypf2Qo5Nu5hGCQVD51RUXsrUo8QiOJBs7EM23f91fbm9l7QlSoDhpqP5ZgqofnJ2wZvZIMZsBg1fI9OkE5hy7aBQHiThjqgyYdQSi3AtyoWb0c7TpJRVD7NaYaKyAMBA3xDbMAVpSSlY7zf6_5KLmgYST4BdMNpisS_87hbVeA5vuxKsEcknBZhDc2LCiLLW3GN2XlTY8wtB397Mxyva6olPBDlXpphe3GdVBNbMvvmyz4FSdO7EhDL-sIRWmgTwfMg9mKWyfzVSoJ4LRpalG1wZWltP1lj4ZlbP79sYCI8ch_1TgPItqz4dRLon2xE4QoRDY8y0xfXdsggrxolu4ByfGg2A9W98aEg6Apd_cad_iBPTvYRfsK0bKPjKNPzx3hywcK8Nu42dSs2NIX5f-r7nCWWPnRrSrghyQafj0p6ddFmF8Lu12pUrNNlIekILH_n1Rn8Sa0OdKDvS09zPWmhMEF-Az9xqQ09EyBcet1toEYno5uCIP_s9Inl5EEyAR5dJe6Ym_5Z8qCUg4yF-vOrfVEKD1xZf_81-XtV-n14xXPAreDd2ffc51RvsNGJHrMF8u97R5s8_w9q0u0LqSJ_RD2hGzikhV9t4K_VSqG1wo6AdovG0V2Qbw-KFDiVleNtqOO5vc9O_iFQlH-isuHiUsFgbui0O_S4kyvu0j8M36qAQiFUP3qcDLD85xC33F3wUwTQT4GReT81VzGodx0lrLs-2FQB-3MWmU-R87ORIG8bXg_e2m_MavV3Ll0eYdqoFOwDfYvUai2jERebUowlalxfZew2KW9L7TlspvFotBGuCJWSuO5HaZY3RQW2r6cYLw_EyBxTnS7TUvB6ndwH_cSXIBOJ591-9QXJb5V1vSw7YVpFLTD0HCjgozSHMzhuZ8etzoMUBRuHISrAhPT8zMlHIijPApyn6bC_MznIoIe9UMvOGtjHj9PyNbSQKDHu36rKQIyOvRrP0ShHWrMchMR0ScysP_gm8GQkZ81iMahopdWgrrOEipdbyPQ9LgEjzrD46z-otWo7qfyidsVK5al4-wB0HXnJnbRxj6clv8FNSUccQW0v1tD4FXqQhfcU30kuwRvuuCb-bVIvKMTGEw29CBy54bE7QwsYYD5YMxkjKdaV1_6Q1dPQAHWf0_zgky4Tq9ipcPhjRGp1l0-0i3Uv6Z85FAAR0mspqlf-mjF6UFR3BLyii8hWRPx80pAX_39AwJlVdsZIXJyVYj07X_SY7x-wJ5HzihvSKQcG8dgBKAzRMrsMQCBdmbt_K7VMQQkixh1iEpZ8H7Z1H3b4YwxKTVtFW68AaipO1XZ1hj0hEhi2cJ1GpqQmTvv_n9O4kxZ73kb_u35wpO6m7HRhE3HaJZfPtfufXPNL_3U08erDWZMbKQaklAPtjBuLI-JIu8xeDj8fd0xEUZiJOmnhLqAjY20kV2bktueGgHYF2JOT8HMhDToMBGY6Q4oproZpHfr2dL6dB4kILMFP345HyIW7zlEfLJgixdviKBJdgba4vtnMKkJnlsDpzi4Q-8UhrE7zs1lOZHRimcK31ZzuHcpkZupXqn7xyyEKe-MsoItMGjYDSFkwsU_xmNMJrjkySU7TEPV6gccCj7Tf6IYHLKANqX9uX521DrspybO2xH1j-y73Bji_3pcOsHRvPteQONIr9ythdezn4eA98TKsG_9H_DTJep8_kJLpGl5SXU6hL7NfpssbnUWr9HUhvc7BjK3XE22FOaMenVtd6IfUm_dR2JbX-Os5HdtnJ5wVe0GMnk6JDsl3JLjyvi9Seam2EFIp1AYJCWGlQJ2vX8xQ45vpx8t8d9j0vsIc_J4hPe-65-I6HjYSjeOIyuZ4UeeUidsb5cGcDJTjJ8KgUaN2OufTDwbOmEML0_b_fWpbKo9BsAOEABE5kwRWnWRoPkYTGO4QjO0MJSyIVtHu1PivpCOUzEHPo8A6ou6wjSEoqSpONzoBZysp5BNMO7Ma0-SprLa_9TOjfegwrxDdRtafE5DFx0b3wf7gVs5OzUkiZzeFT1NZ6CAYkNrzo4yhGzuCfBLuZhVcCs7of--O-5vg10JyZdWPzrDOsRE7fhEfhE3dZZ7OfC98PoQ6Liva_UIQ3u3FLXzxyxaxa4rIMh8hDl6tL1LQqNtolmO0otjxziESeLlSZHiwzz4Ys52FznnzcxKo3cWXt3e0U_NFhSPDZAUvPqZ05sUCrCQxC1zNYCieueXUOjeWkiRuvRPcnGjesPct9P2CEqmDxIJ2OGADRY3BfVTcgKDKcSz2d_aLS1wKSkbTHzxlSksH68Hm6-wC7MlRnq5unt6QcT_GSFQ2WmRqn1VCO95-D8OUSTfum6vd1e_U148Np7o5zyAaqYKapqGhLX9XQFML1zx2Qwqkkt6DueshW6liH4lnK6iI2-CtYwKMqzVYzKehTLS-Y3-WG2VW966NgkWg4D1K09mpb0RlpQd6dOqWdglU_BJpd4h35FomRZf-1qjYA6eAt-8nBOkeFxTAhxi1o_j3Lfz-e2vj4iDh3XqQsrUPD1KwX8zeI0hYzrfY8g6aHUlROEeEPUdMZ0TuZUpYydzG11Wxv56woev-lDAD7WXftAkPNpUTZawaCKB66OZ0WGlWw8pMsRWM7c053myjA9aQJCXdBjjqM3TaNM6vV9bODzniOF9xZ113R1VvbTVccAkyhr5FYXGl8a8yCTCFsWHS76C0JvL4wLoegvzr3jwYxVaL6H5tpZuKFW-JUsIAkjZvI-smcDZVgBx3RbikhPdouEPzAY50ICApzT9KrXJ7nJ5H09yhZ6LEKO5JU1HETjLeFok88P7xSqZzsSK58rLSlh8fpJCyQrQ9M9GGfuX_yu4aBMKXFwN4a7godonti4tWrlSDlLP9QnvWP60w43UNjJrNxD-CRD34Fs-jDhAct0SXIxQ60W9NYL_RHxAaCaV_JD5UFTwawp_N1yDiFSolOGlvkqR3uyXm1vJrYkcaFkPOvqsxa5VHDd4Xl8mfbNupIxzqCeZlmEHVxeKb5hMWYmoSmsFqKBF6RdBB1aBgTKbV8kbnYm7qxPlYH72vcXGy3y6BDCkzeiZHWw9khFXDlCDL95wCLk66OEkzYks2sIqDliIVpSlyKnhxsqsDYh0IGoUaXuMJ7eTB_emQG_ErB8f6TQRBibMrUgEC0y2gQWaep0Grd3p-EGY_yJUUJJFJLmGW72Fs46LEkVpGwU_ijFEyDc9gPYbRCNPXVBKhtVwQYtY_NYfs511PeeJDw8GngF_TpTypiU6ntKcxnPa2cEHD7eZ6k6GXoKhauArsJ7DJ1f7_1OHiCLmHrY_b_PeeXNp1MWOL75nMCHUWY7Eswpf0DH6_8TTlToHdLHm-_IMZmIfUN9-nF_eUon_Mc1_hRY9wdD_9wivsuxHmlZ0hAgK8tuxk87MDNTCAIpHTfTpIIdBQCaXm7HcD5zvMysbRDzRCFqJM53DXibDQuleQv1EhmRKj_ow1GfI12AbQTny5wC9P2zqwLFfB1Kjnmqgx8qcH_3IDTmoouJVhscgfHbF-h-Cd4vSP5CLv8jlVceHVvMcWNeSXU6zx75Wr4Fd2LcM7YMa50S01LykMoxvvV6UARCFk_AInvGqKbGphuTdUf0CSdfT-M_wWgFIuPGsp5SX9h_5B2fwC-k23NmE4Jj4KOLdghrfFGfpHGXL8C73CZAvYEsbU-zk8HvBV6i4i4ffYzI0HNS8NQZizjowEX-Vk5Ty2EnUcHgXy4YXxZcXjAOR24KjGd-2iZqYgS7gLjtK4JCliFB2ilfpV8cf3KtS8Hj8U65kbzChiIh1iHINDdH3eeAU6xkr2YHfZK_xQjFs1Ch4k94c1kEU4K-51n0ixQgOdNKhWbjWztSbWi0Ib6ISwwm-pZVDUJMgi1IpvsiPHF9gnMFcyV_g4Xy_y8zbuDTO6GyBBukv8taS3xVIxkE4Gq56e5xobVJWcwFU-bZHi1O3QLCi8_SFF8bAghNWvmmEk4C1vNoCz6YI8Fu8EFv1vuAOnOos5BX2JbuVA5eagzaEWL2vxqK_T-fUKYXuQABetIHXtnoleXtt9a1sjfKw86-YMVmx1S3l7X4g098UhAdxaPX6V3ZFS7Kw2EJeAGnYZ4dLSDz5HURNEHQo_wKeSqRfaRHgEiVSEuceebIiu47jw-qLKXZupMzdG_JbD799KUCHwRroQs9M3Q-QISGOFht4SOZsYs8ZCNGhZOenh2fHLgieWq2DnIICe1axOUO_3tJwSeX_35USguugH9W_SQvuOmj_XiI8o7ztoMZjQltPBGGELCXzSmfQMD11i-mCOuwnhdUxJs5oUlFGV3rbDMGqrE5PBTJ9JCk9hAJ7M7GQq5K7oItQxMtgNmRMSlRME8FHeB6hV-pW4MIktKI6NvVT8xM6zZKP6KV0M_UZyqQlZaq6srqIAKAoZZZ1kCues-1P77CKkIBehpaYFG_ChihnNXvWO7PgwXPmA_v7QfB-EgvUqou6qLfUQXG4g5g_6dISNXVe0OP1E2u24qW5jzuJnKI6aJAio5r7702HH6kLRdmbrXt0wpcUSb-lj4EMflhT6gag7DbkqTVvZuPZRL4SjhPHflTNEDcfA9V7CpLp9-SXgJn0DKsmA1X8XrIfRQJE5-ZHkoF0zN_F2kaeaux37KI9F-Oh7lZSST_Y6gan5AHTw3By88dq4HxAkOBzAkQaIgZK_vEoZ81xnyHzYab0DmO4GqHPhHRhdKheodDYeKtpAQOjro9qnnt7konvcFSlWJgWoO_DuUc6m8tMALuvLMEvscUF4ChK9DxMJUkqddQellsyhHwGIW8HiHvUuXDw1S2tUSqRbA6uS9_zrFtgjMdFYMy5XRhnbLU10Pujwy_CKq3L9MZbu-njZYv1MroFuSZRlsqU0i2aR66dUrvxERH5j7-wezmrDhh1U42MX8ajteihjW75Am9Zt9HTW-APvH0yq3RVbvHVgygIyPQEJGesuxZ5rAcYSz1Bki0-MxhLwUd5n1LdsqP09LMfDXkLMNpu5c05F4Eg4UvSMSLGIB8ashOqGgBHjEXmAFNZaVg6xIqefcjR_SNKV5TO4zIOQk0TEbntYz54sT77os1IkRVZUHwTepKvvM6dXIwZG884OJiK-7QnMrLj2_8S-7CQk3Bmsze5-bfGnQHGHDjO0kczTD7p3WFrT_5HBltwam2O1tGm-2O56N1yC9vaDJ-wK7yqGt4i3vtfutBdjsVnUBB1csQTjhAR5ubKRu5Pi2rL81Sj8Sk1OEE9GNRa3gmurDlBhl0zDMCHKSQIXLwjZcR_P7fA-qRpKCSnQWFxs2kwMcbuIVmnaXc2ehvXk1Ikex7BVRj2HaMEXBAAgyjlIbuz88Te6TTHadAZn1KW0S1HrGhl_0HZA22p2ungZpUIQNdka_k8KwQXJJcn0uX7bhyqqVmENzCA25FGz7Q66SfX97V29AXaphgAawtDW6ZAjw_-JXd_HyG3xAjVO6Js6h60n5YS8KuFXfQlOEZXGKe0xfIt-TXMbpBSwJ1M1Emo-e-W5cVl_a-PSfQpB7K44XXozSafKAM7T-6MVGzwCQ16QhLsN-KpMFPuduGlMu6J1YyCoIoj9h1VXOLqffL5vzXaXq2jEvlR_M_TiBC3whRW0VHNpo4MS3qBFyblUjbMNhXa-Lk41cj9d3T5TMyKYjDRtKp6q1W1_Z5Q0aaQ1Pb_Md_crHfRAqPJq9ZeDzd93WS89X_ZZvdiDw6ftUqeAo_BjYIF--MiEt1QzXpd7iK7HoOMIbohEE-b1fJjZko2ATbdf2cD7_5dPIrBrKPQk4rYluuIUNmNnC8r7kR37R1Clg2Z5NMH0AUdD60VpNfhYPrIrrEHIjDbgHkRWjZVYwsk15ZOckvqsx22gSLcvL1YJSc1FhOlAaTqjOLZxdxMclGcKbQaedVMH3K1jffJeLMx6ZSxRMB5ZxX0_CyxCWLSHNHna9J5waUXKQBiskYlYCAMBUGIaABKoqa14M6j9vfaOkZSKeJkEqkDo0CiQBSuFo_kOa8Tsns1qNOB79SVDMWUJR0CyOL0riXYAT-lx22sBvTifMV33juUbHcyTqmnnKq4diamt65gnZPl7wLg42KKkETWY6Ueq_BMHkhNIu1UZ63y1pD0p9PKXsG5ayb0GYCWHYJvUdOighPSTcPXwJ4OV4k_TipriQ8DeqAYU3IQe7Z7_gSFL6Zkm0M_Od30OxhXkDZFwizgjLESwdHmLn4Pva8tbYNhKDY-z214e0GeEXTeg4OG-_TkcENMS0N3ELwNDqkthZfKpzHZEH6DNhX9MZXXYjpp9kftnkDgi9-samvp4pSC560ucy7s4WgkJj2kes6SryT1dSXr-tx_QGfmJ74WFlbwx0aUAuW-DO0RnGcTfIj27ItAiSlq5U1eQOBmlu0WAfDILqANufQhRbt9av0rDtSgtH23S95aJLCq9YjAGvTWdTgt7F6MDerwH9LnJEmtNzgw__TRz6mNdpUPSW__eGMocgXkzlARBi4p5DGtsvS-i7aScag5sZbfgkDnALgeAZpfPg9DJMIIH1ym8OkMeNmVBzNwmXK8yXV5ITXm_gffZR77Ix9r4TV3bQlj7h6dRahlwMcDl73lxRwpefsMkSWKA6aSuop5cybpt1wo9Yjk9Vs8O72UDxnkWzXa87tTneQlwY4dVjMEtDLXg7GhTksDTRca9AZagg9WOD4dJeIxcoUASUHlPDBZENW4YBVdZMu06acA6zcdh73qJrF2RY-4a5vmWgpeCdSwnDW4VK3uJaGox-Fwbyxx2KKhsGYgoG54vJfW0v2aEqVRWv7Em-961auXrbWbificX3j56YrSWx1i0eUHjytHpe-tlMHJbtoMTNpK8p7CeF-u2Imrl8NrEgsvyxNuNlFHHA8njY_4NHR5KHgDtNazC4gD0qwEXjmUd_n1FSjBKNcZMEAeE82l39GxYf_aWEkRSpQSHqo9ySyK8kJLDwiFYLe4levXEmag2mH5q4ABdMECdtHSdkegwRCkr8UbvBp-k0wSARMr1hoSqoeDAIvTt30Cq4A2qNpU_9vV_YKbnfU42wuOry7BJ4XhHWM4mxVRgQYVI-pvifcKGg_mD1aJj0esjYUhZNwAvqgEX3-NFuHPQ4CRPnKOCIAp6k8bNubiaUpXf_1bI9bziav4lteRGGSwDoXeur5kIZGUT_6zgIF3PLcCizPvZV650NLIhQiMoC2ARobFtsdD40qtndznPdzEtbviwGS5T8iqyQ4dz57PkcuqsdpxBtEEr1I_xC_hy61UPOwB52DEsUt6SDHsjN-bxSbDHr88iujgQyo5XKNvsQTQYzUuNmjmU4I3hFb0r2Rdefvhl4bIfSpxfWy1mcRx3nbMkw911lFics8YqjyP8fUvByWgu6eDNWol-cS8cNne_WKosK47qZr6TU2ltA4uHueUFvyTmdt7wJKb4aQjoLKvGQu06vzD3-FTmLMoOfDIwZnHCXnnH1uFS_iIdMN-OcJJMwrOixHngR9tP1jxhdKY-5k9eozv9YgT1k2jrk6xuJCQjkS29Zno77urgg7G4mw7ccYjZQCXt3pS9XYhoCqh5mGrHo9i4yAjNWEldgY32Sw7LcDrsTgEnjLJkIvpCW7yUFkGmRmCd9M2CJPZDb1kHhH2DcztdE6efYrYlMFq7PvRqL0LgRQeLiFn7UZdAII_caheV1kZS9YIrax4Uy7C45SpBwDlpINEXWHqFTi6L7iiX95zn2RPuI0idFEI76zE4KfrHSIFCTUjPbmut18pq8Xm695J6rh2Z4JJPebMqR_eY8riwAmRabuOd0f3zkka2ZUGv1LxvZQULhVOiSh2GIyYzpI7h1meTTXw9_77EUTSajrvqvx-KdnZamvr5Uhe3iwnmhnHrzYGSiovTWC_0XsifFtX1U9JQAAcsc3CsVknUjfRm8ehYQkUjpBO9_iR5UZBRBmZMlVyb0OJDizN5vfs3lbNDYVrDrDyeujeAwaoaFVuD_xNIeIlVCOhWlgPfXIwWIYyk6jbm_0VTruyJ3xpRDCGoraStY8Iytgm0BvgOhESrmo6sV430paB_sXZf4faPB08DkyVZr4GIBCHOfg50ZJbU4IIu62A9qUPgsPO9WzFwXDM5Rl7eQglyVpm5zuKYACrfc_tFlWL82t7WAjPHIt6LY6gnvWCPe5smy_Qby8dSrk5QNAbo1JHFKyKulqYMMPa9oABAPkh7pI51fNmfsUj83JxITyjnycQ8vqsQ6Pdktnt6pd5zMIufZZWsfV6FIU8mtG53j7bfAcpg2znAgqTv3sGq1hKkz1puSQlt8jd59ZLXDAXifywWINLWyI37zM8iN-_mC82ThkPV1XDSsuCd5OUNcnTC-i5PcPmm8oipsoZZR0_mjrBcrvyq9s6kTqb-U9R_TDu79P6ziuYF_0TdiILddJva_H0R0qrSeCA6HmKR51vzSMzsgZioB-8GM43GK5dkl4snkEt98YvY5E8vdS_imMXyuoyJQPG-4ucqEWAODi1dy5_ZTzO42p-IjjN4_g5KpRcstySRu-bItfY5ymkcdKeuhLHCGCr99phq2GV8LENPeuWwj6SK3QHHZj5iwTXFdVoIyROzMWWvGSORqkz0oh4P3nGZdI--kUAwr6mOyE-w2JIToR1XMAp6puit6k0XiHjjt1AEEZtBoZABmQzJXUYJnBFO5HWFPaHUnyTmIbjQ3lVjECMYv6toKpYBy_P0yMAKsi_DAjow6SznOW2Qn6JftVsyHLmADbU2ncROhcxfGJgTO2MVRaY8zzHag0i3BuIMyUHm57CdaPmqX9b4PWGJKJUn3KpFoYf7KMFz-0ed3IBnVkBQi5i3uT4GyfsDWtKWK-9ES70CRDwB6IYrJ4OPd4T1YCBj6ofKby3yjFmMHClZyld6Ckst4Tlk0eIC31RWXhnwPVzqPrs8JUOxSgh6-Kjv4OCcxH2hotyboO50aKUDoIrlnXyXu6JyswUWrzG0fGl4gwnGzMs1qLOccsza9WdL997rUgsqYCpQOJK5TqesHflhuPVAFzAFYX7IrQHpISWCt15GPKGpRoE0tmK3lBNwE9CjHkWW_vwclfIOCJKhCy11JdCj3Sx2MLyBYDmk1ycX_OxmsScRRJ8IpKR3ge7sriCAbmXf6rfjBr7r1UyPY33R4n17LzwNbtbm_5NH-_0Ro7T5wuq4SUXwxJL0JY-y9an5Ovl7VjcBNSCPKSeKjNrYRKerceL3HbguXpqbvyDBgyYCP9Gf40dhNBvoqtesO5ouO-7c9g-fKo1eZKiSzmm7Ndw0oW7Wbghyn6wZ7arBkC9X1jGvcjJ3Pj8ZuTAYh8zlRm1xRr4NuvLyOjT8IcTs3K4fzeOViI2h7aFbvIp7Mv5hb0VXW00y_cb21dPmnc47Z14erV3m4eK1AF9pgB4mlJdVtyZMAKyk9IyDvfGxGqgMBVHHspgSgxnnd5nm08UfoujXChl3DHTiZcuyJPCSgmGWkf5T2Q7kLl5RAA67E6qga1sSVAtRItF87RjF73jFU_4t0HU4veWelmQie8euKWb02F7_XxdMEFukjvoZAdt5Byzlp5J_nfD5mu-QUH17ePCX5IrPdefR8F4KLwluk-Hnp0g8DLf8Ei-g6xLLR9_Sp1UEAyOGkcQS_Chi7BobIHTHrVE4Vn19-e76wFjYdWP7ewe_qUtH39dQP3Grb4-2TN62zxEIvFXl1omu3vlpJw_klppQ5NK3lvcbCxox4QP8-WwNMCZfdXY6DXUL2yIwehvqpZGy1wG2Cclg8BQxWzMgBnE7Y_f40ylzULZ48OFPAxXmDbhXLsooI-9WQWdaP7aZSqFVe_vMLVURbyHv8GAwOmUQJZAZFd1xJYN536lHL2ZpIURtSfqwusn6rB0IxmqiJXCQNRL_1q7DKTmMTFKH3OFCo8Zf016X7WPQG5NfmWmZJO0G_svV4q0sAz2tnZNgKvdSei6YulRo7teVGiN7mhZok-rnQdcTCNn1Y495eJROqCPll00T2OI__QkH-ZOrOHNyyUi8_h4nhnd73i6dnbi9t7zPvn4oz4qpNeDLZgLvUAUsKYsRURQakua2JiBKNRbUTrw2Lj-YDJVGm29yCHaIrz9iAEaUqPvV8umIPunNADvExZAdt_vxOdgOgYAOqWJ4il-mOmrKYRQfk6l2Kz2WeV__O6tV0bwlB_k6iJl7XrwKDhfP65b5S8-lamqcHpj1oLn5_zujb7PpQu9Qs2bLjEa8qUeCH8cEzx37FsUiPzzhrQleWMuE4b9L8Mr_ViHFsBm4CkG1k6Wh9st3Bkho3RYq52mFaanaLrAwz13LxX8RiFy2tiSKcUawrHnwCKLQbzFJc8Sps_C7zvEAdm1-HWiE2f6vQ--TMQU2Cx5kSS9z-G6xBQvfspNeH6HKuOhLqYLKQ9dGFhpjUfoQdSJxy1jbg7RvsHumss97FiiA8FMyeerNXYtxxhQF-fu5PVju_wWxyunPNWOpUH3_Nkr7NfBInhxUbyDM7DDDAcIOXgMWELjSByOLT3OJ5KMN2-fojOZynErDvg8FV3IxhltPLqhrIzS1eeBtv88VxQ7AWNtp2h1HLmmGtVOAd8yU2X7nuKxfP4OYzuP0fMVhkChLK8Fea4ky4LeOf38PWVbGZO3uwXm5A6fGjH9x7zsJpJ1kD04nI4xRPGyobi3uAplHbMQh-AGpQFpcmYBHjJUXwrEC94_Uu0WRzeKLQ9HBIYXFqexBsK6E0ILnE6tRTeUAX7p2dTl7nCkvb-zMTVQDIEATcU4_xf2O-nhA0kxnTYMuQHvYYRPDCEoKPXV8naU2i1GOFfkJZwM0BxtgoWkAqfj6qkssVWPAhnQxo6aDovvmG8-ghMuZI-rbrPYFudWoJWz-BThNSILRsiguoBvLD2rpt3gwfOyRePqso9G0zMaOXZ8_XnkX_o_QX9Qt_W-HvJISrPTC_HYAaBldLm-hNAYTqVLv5dT7EsyCAFiesC3931-AejgE-dw4Z6RH5j_O6HRV4wePNZeu2p-M2kk5u6miDcDZ8abY6BdXPfp8JrTdKUb_eNBQJ77ERrg0OpvxGAwZXEviub4Rp3CDj_iYk_bFQ-gkuZiq62GLvcnBMhB0-Gs4yjEYnaxTU4f-gyw86KetedXo9dFT0ZOHDZySxc8dZqK6IF6wsGRTYnMvRFkCZXj8X0u-ey8ZoQM6_b_uZ56CBq0FnVUJYczCc_1MT18lj0DLAyy16TVppMITquBm_X7V8a1z26MwZRAVf2k_EXElQ8ElTtCHyM7cp4q7c-CSPX5Q4VRrbIrpZTWeD4L755ZD6a-DXp_rFWdOwDZEzo_r7dbgQdH1ay__zm80khlW7P-0L1pRpsEQNe0jvYnQSj_7ywaUM6sZfhicEnZ66qt9D2AK24ux06zGoGORuUJJH4P4CznYRddigm0It6TXJOwsfAMsOrNi2tPS02jxOtbh20OmaVo-73SskJqkMOWeFU1_UbirCvywTfRDEXa_Y8hNU3oqhIrtL6rHRe3w0dVwsKmwHqplfh_w5tLGvbO9iBF8YElzZQ6F9vd1oYnrOLX9yfjC58OV6BAiDIeIySXt-76nOSRGS6HvqnZHVViYdFG5qYUSiA27cyVp2paNK6J8XynQ0ueLIBgeHVVnz-0gxyl5olh0j8wlwHNV0vn3l3Yh_QY9QAoi7v5J0qa8lTjgVAANmin_SvvBCJKoZBe5D1zKnHD4exLDjYcYSGI1GGschfRcQS_wdwoBdvTr4gdZDR4kwq4fQRuDcZlpAHygPAKTfoAcEO-zRbLF-JhAYWIKgWJXahZT2yQ8ILK7PhZ_qo-uvln7-Znbo9my4ucOYyk_6VDhlbhpJEO6hPtml5kkVglByt8QFsHRVie2j2YsP_Pb3i0DK9cKU4Yn1sfDHbRXnMS4rvAldilwpnzZBlnLO6Ty9k_nZA_Vg5KkK0TIlMa7-fuBUGCPjRWqrWPIsqQHedm8Pz5YB20TwVCoreRYVJHeJ2ociqnp60XkRD_OMPtR8OnWh20DrtJbgD1fBlfJWEa8G4YU0XUi03hE9NH2-JmMh0lF1Hkepu6E6gEqLwhI24XZ6PWdium9ZjoIorX2KX9GzwL9VkCg67sXTR2Dwt2u9SAVSNGseyNdiOmozn1Q1pUWLX16mqZQ4A0pEZPI1jE48bhRYWp3GwDvGNcilmraTNR0W_dHl9HTVXr5I6Dafug9u5-03a6ZqTkjWGTqb5X0D6nwpoXQdximpyY1m0WMP_UaWbtwY_IcEOLncT-o9tJDzUlQpEaDuJA1p4VQ-e8jcUBKupqU1U11Y4vvuP07e82QqlxDgWTHyyxSX2uk_EF50M8QrwRwsHztk5HFRbDffTE0XXrRGzJCWeU6C180YDRb9Ay-xAgcigYOFO0vqhCgYsbH163S0En4vDsZ-D8U75-dOOdn1FJLgp_Ij37vFLCqg7SSViPqmsHoHAmFRDc2nztYPrfocj4_1uD1HnP7pkk6s0xmwE4dTX1H_m3g-dJRaWNK9EdCbMcLb9cIN_4JvNk6u80ZIsiOamswq6dq-fF31oBGO9nJSAPsdW_ISeszWLPQ750Kyi-lEhyevi1hvjdBmn8VuTcfVeAqP0m7So3749ZMGhsCauWR86emXGmZxi5ccCpQDyiVokkWKFRoI1m8Ho6lIiLcd-5ZoGWS4zqgXFpLGb8daDwlZiSrKXBGy-Iz7YiiVI8FwFHgOYbuOIU5vWDsIqqY8q45FKTIbZYpSsv0uav_ULgBclC8j1s88ps6uEmQTcBeTSHkLdezhThYePrPC0UJ95-jiWO4BOGXJpPaW1jKACBWHhIRS7krYmcjSwAtTu4ByvQ-a2tlzwiiaMqqb29jpBB_WQ4BUqZ_2BPBOKjxY1a1Sd4F1i2SkKMSlruLVcVX1XQ852qFVaY4DdfN1dHE3p-EzPgwcMFIzqSTTly4K0FtfLaTIjZkUow0wF4M0hR9uKT1E6Z4-QW5rPbnpowhVOFKuhjLwNelRhVQ6bPjrCbGLN2tZqJEqjt8PB9Dy1j8JMcyMPQ_15aMOlZmmfnnY01o8Nj23lp_sHWU1IrMiqoTW2-yib6s2J3Rcd9DS_aDAOv6i_DlPqa20q8x4HTwHLOjcqsPeJ7Pi46AQewaZoJcNS4QMBLXeiaoCc55iMmj_3e6_1dTVZR0ml_SATRgBFeIEFBi9B3Qd39c4I8gkaNIlffod6Tn98ZuAF3lzZpPJ94SFoluScEKbnQxpp5bsevpQQf1bflOVJrcs8KNtlt3kKvkDlgYc7hWh9-e--3OfxXnNrhdjHjzt1ymOn9xsbfYppA6bmTMsB-_RLmMDbKkRGaAiXYwISzZtl7CZxqVdmqkX1LC104d9nc6QJsFcg4ZT8hTY9cLrUBxgvCYHKb_geZfHjVgKXa_m300WF8d37WiqT5COsjb9do3R5enfsznUi6-JdIu7wEc1cyEqT1pwyh2W8nZYEu72c7UMm2_OgQ3wVCM_LZ5StKvh_Z52Zp959ennUDm_4x3BTRml4K9Aznu-9nkpkoRfsn8hn29Wrkdekxg_SJHymg1y5VF9Ye8XRMVsTmvc19xcl9oVpuZ_tnngMkPYxKWivHKQiSKhBPQnFJTEFdAi4i9gtC4uv9LyEcL43mYp_rwCtQC9954LnW7KdSqB-JQIxPYz279miVP3sTkbfpeoHd5uQEbpXK0_X7pvw1KLxWlUtq7wFfgDKkrrfpLcFWipABg4K5IwuLU0zQlkVrAuby5EQlGxVBjq3qTJbPEO-p8xX676FK8m3A6e1FPhox2-r1IBjtmwnNa0fe1CenGF6Mdnv3YXL6ay1mypwi6gC-F-E5JNKIbV7Ok3VnjLuyJOpCKzUrDg5nHdRidDuymGVVAOUVM4rvKUlytbL5PDnD2qmBKRCc64BdigPetqIdN96fGJf-QVM3SDDxN9FPaqyqzko9kyqx32HMg_GARQbv4pMhGQ4ZIE5yqU8EWQoD7Qzlijf367EDxBepHG1xjf0xWTBM9-Mempppd0NDbQCAXSfbfGaDdhhdyJs5N1q12lxaXueKlNN0zE4WgDZ7CIScqG4IuYCuq-qq536A-nV_ZZONfXhEfGXmzwPDBYFVNaPloya8Db1s_qkBWz3ThbFSml4n74TXhwR2KPdWMcd3QQ41zDZd_0usSKkl-94nmk9ZCmjjitmIbBizEH0M8VxXp3ftoMA3L9ElXecZqZEPjzPm6mEXigck2IV5uj5piLUd0XmHH1e7dQvTsbsp5RcNsTkwSKhdhPrP1t7ANv9RPwOtqx2aE1rTQZagsmJpyCEByzlJQpEgYwdooCNnhPYhSv74k9d29bLCM-SMBWa9FbgGkdw9FeKXRyBp9r4EVK0A6R6ExRT7W_i2U43m3IkMqXFIXxQA-XN4DSCYPRCgSjGzjF8fw-soQpCVabc_VPWrgvTJAYPfUcZsoXG_Kvx4IZbwjWSSxXWw6tYFY52psj6yuop7ul1kmiR6oIhqCtMbGLCF9ZHl1TRiQD0n0j_iiYC_By5p3MZxuN-FoLy6QoLZyiRX9r7nGZIF43JXB0qwJFN_r_eEH0hQ877IptFKWofBiHknPRd8bFtgOgg8915aaeyarCwCbNCpdVjMVMNNHMNt_GENaVl_PLZUMb-U8zJHbc9XwbSokNEw9YJvlw3NtDGE3S9wXQw7lgqSEbAixBqwEZRqkJMXNr06IrYGPvRmF5_P8od2_YdFlJGf0YsLC5g7fU8kA_uVAhDkrYc1AS-n5riXqxtqw9Yp757gT0R0GM7LB4vQ3OlBZlD5Dfx0urpP8alH5ugxKh40kB7NysYUl452tp4oqkfj-A7lBl3WW2YeeOTX4FiaG1jXsdztbwzzPxCUUVFsxTPDEcQuHbyZY6LDrpW4cZ-8bEFbBgutg4mCPBFaI06AlkTYD-Vq8WZAZQv51RQz5PlVgxUaaVnJoRvUsYSe7ctm2zZ_uojfg1KeDiIr9PANW8FyHjEsX2wABkq1MmjHz1acf2I2uU4qQtpeIRJEs83qsXnqt78zOlCyTSYiBnIftXsh0eZcagD4EwBcTJ4gP0jq3WbpQDiEb3t71zIjqnMPxT6vg2136w1q-R7JhjlB34cnWEquTgwSO6o6NktxLc9KLEXmvb187oqX3HyZ5M4b0nYiTIRrc62CYw7Weinw_YYbrM5TzULw_QojM_-yzpk0kd4ld8lkWlfnn5gNo159hCVPoZD72gNcn1cVqTyE-GJhnU9PaZQKLdKoLvNSVAVZldd8sVtQLc9hVFD3414n84c1PUhydUGMpvRblbMIDUUmLYSsY9eszBIMAbkV0ss_Tz1TUrAmYMILf3OU6rsrfAJAM0Zvz8dVmUmhEnt9re6OEYEs4-CtvMGOkjt-kuhBnzYE0JUOkN7U3fwFq-gMDSTw6f9zzlWs9S6xSXvdj6gTAJxzZmuwgtK5tP7n3k23EDd8qGjzfuuKVcIW2sKWhOufF08lQDrdvP56DahuhtZDWEOG5_hBWzlD2djqalzXpTNrnJg8axAQO7xUE8TCfbuxrjINOPVWiuuKsQBRcTICCi3MscfJKaVY-q4tDzP-AxXq7Cjaoekoa5Zqh7pmQJvuKk2Bg1ZeMxXfP9Acncjh-ti41QIoS8J0UTXivscBANFGrQdztR3cL0qZbT-ipe0l4tuk9psSQbIkJ5BxHQi8XMYd46uVtNRk8AUAy2nPszIq-eoBdsZ3KtuL-wGeS8R8hv7iShoNf5qFei5zNygmoRWiHeRnbCOjChRmudNaACR6WIGX7jaYOi3_MqjmqrDar3dzpQzltMvt2czAtlINZyouOwoPBSqU_yRC6x7SPcHRKlCU9NfoagsUY7czh88VgCzYF47xX-bEr4bNEfEAJbg8CtPMaKBzgbEHJjOtG-JbifpGtPDDLaL6IRqvp8-O0Oo0uAG6mrooQ6HxtioukVMrvaYCHCC19l45ShCCx3X0o6adYTxcREJGZ0ML3sYPhqrf6--OgtlXY4VT3HYuaqXb2WESg72oAGcVp-gYBtEfDzhwJN2g7qEqKAAGKOEFC15xiR8aYCgGRaQJxxouZ9-SBWiS8cK8vEeM4dCLF5v48KgdtR9qvGkGlY51k_YISDmMIm3pMm3Fe1rwHg_yXVV6b9LeJ9cEuHJFx5fATFkB6cyuyEg0Iuhbx8g9c7yObQi8nCkFrY57CgLSP2okH0htDogTgI-zw4K29ucnZSx1Iwb8X_rexemOIh7hwx6ovcWehmhBvGfm0dUHJwX_hI6HmdpSgdxK7qiyVZiiuiuRJkuKzz1FW59oWwcQqsgCmYt3ZLtLDwMivCx2tU3FNMy64ficlPf-uGcMthmhGEG9NjubilYOuSlT-hwUfhF_q1-OQgXe49onp-yNbJTtWrhoNJm7uG7Cw7lZhlay_KAmO7_Rjme6qZn2-DtZnraxiC4i99nH8FNw5pyCRqgN7LiPFOPyhgxewAgJxyvQgDIV-4BJnPCEFjWTH_OadbQoU4b9aTm2YuwfJCBExMcR1HSSETZ1oQnuOAf6wCclu4DnBVpuomDG4-rkiGYZn8sEXuJScdCmP49eJJQPGa3TAvQ5tnMIJo2N2g9AbpU1ehyqCIcdSdK1Ir9Y2JtSxJL3cBVwX5LKR-CNCED7NqGG0LT6JnI116CIuYu5qxIRwVEThFrHn6800pPcZeGA92Wvs_ZMY2w6aGra7OwBFtpXeoWE-FbkFPCTFkvcPO95A_aXFNRdp1Ev34dYSyj8JxfwJBFZt70WCs0NE7hK_DPcEkkfoHRiddgMYr0DO5L9tP-AfdWg9IEPdhOPKdW_Qk5pUP3KM7EnO2nfIewiBBbbjToTGaL3w2paDSRdEB7ZZLEofJhvWx03f9u0xi9Pjo0WMyR1wOIQdP1QFrzVrwifynbANex9gRtuqzgTtPWdsKS7tvFDZLr383WZ6edwTNO7lx8Bxn6IP4KADaNj2mb_3lqu9VlVxm5d8IBh9zQ0UIj3EqyXSKWgdttF51dpJBUmEZ7eglZ4GyITL061kGPdHll8pyhVwx_tOPN60PB1sNRvO3Tu4-hyGbFIVYGc3cLO959ZFFzViR2BZbQKtAlzElbK7-3-E3wrXyrJ28_JA1efOs4U_pUaEENblWBgotpReTXwp2lPZUMiULJ3NB-vgZu1r-qpR4VFLQshpUJkkl2NH8CCwIY5olBfGLS7JcXR9Cdec5VMcaAa8fXyy7U34AgdcCYyIZkG3QEzsSgfx3uDXFfwoHDeJlG8t6_SbepuaPbCS_GldF121GS81BHe1oiAwozXhNi861eOSmlR6Z_wpvfQv6qtWFIXXs9LW15IZG0KtL2DCx9zGfrncOWg0_6_zKlIrOvwDI0hzbvnTNZadOru32EQjjAQbA6IN6bNNcEHX2d05WLUl3uw_cfIncvcxYDjXBw5KsSjQJ2c0AjeVYB_fxhu2Df2HV8HzvkoVGwO2O09g3qAx7eqGDJjzAp8yUTniyLw_ubJ609xKxlXBn2S2B4aaeNJswvJivcSDy3hi1YVVwDwN8BSvAnjuU5qbPrbSweGD9FV3HNullfv_8StWMkTFWpwsok666AbpDHY5RHpZ9VKgToBGJXo0rDOn812ugN7d8QSEDjyApTh0Wti0ZiOuAXB2islMHxXYCKYTRzcDyyLvh3mUFU3vmG-DidSBYVwU0VKnXFDuxOGA-IaOpAukZmQrHi9_geHj6aAiO4Y6NeukAuppL38imWo9nemXreymkfp3jc0b5EmQS_aaIJ53Cpi6AuG1bbb8lb7apdYcjauz7WEWojOSbXEFwjt43aQR7ISFe-pUA7nIlZoiztYDgYNnjeM-lkVm5Q5Rq9sMKQwe2880rk5c0UDPo-6rEfW2-dSbsmpx8rTrT3osC4f_XMhLe8hADvTiaa1CqN0NuiQme2pbbCmg9Bo_zK09AhIdFGo6zdHR3kWMg7PH15oTqGyW86u2glAl2fvZSwS1-FDCrRHgwlvUrKdBxhNapxZNHrk6BFiGWJuBqzMk7v_nrtN_pNZFMQqVau09OUbbAta9vV0Bf32flDcyzeSFMbNguhaSOED_978ez3bJQAxu2GA3zSc2a2pZHtBauqSC9KAVKB_bz6FE2Zz_vtOapo1aaKKj0Q1NBWQpchZo5acyTHJcQyoJHL-N8tZcuiEVySxx9iq9s9pxC3O_HRm3GmsbqfzQX7omocSuNH7LXsQu1sWn566YHBEQhmmUpzQy0DBNzrvLnaAm_VYCE-C21vh1eBOgfHa4_LSa_XeuMO-vOpitOl_YE2tidTMd-irl94Jl0rL_GEO8oB7kcL59_MmBSs6U0hRV0Gx5g7FQQsC-o9vKeIBCFKEmaU7NB__R5fTyOZdeJqzQMYtl2Iki38Qhfb2AIJEYMK2zyYuYzAGfEqEh5kga8kX8f3NiFQ572zvmue9SXgUU3T9bfuRAB57qCkf70qQhJyDJSIoUonmDuf6m9rNmFj0oxedwmZKA7s-A4stHq1Kjx0xHTl_cNqMMS3pz69CZLoGL-_gQHqPR_EeO4Y4xqT_ViGhXuXiySCHS6EFBMkkE4L7MPaQKNa_2hp57CeKbVll3-ek-5avZ80x3WWrlgbigp02YxX_2iaQe6w-Ri4nK0UjWYPjCCvk57y--HjasSbtmR2x2YePIXx9qPfr9ISxl7USB1enOA8c42PtuipXiM0H9xYFLhq-3qncB36Qerpa0lT8EWvsip6QmUnoAxSss59A67EmfLbyVYDLNWeI02P3BCBwgwvZoRsRqAxgKH14L3kZDMK2QuZlDfEpxZ8jgQZLz1EWPKqAR5v857c2gpEeYaUtRJ5vFPZKLFsrG05ScGWIpjsGmv1GABLpB2x7IxFs7P2XCV8brJ9ZfaLK9ZHQCKKlTbGmt66qdS-F-Z3i6YkM40OzLC2smLdRHma2rV4v9S7Asryd1CN7fVBcUMN4X98BA886RYJYgqzr60ncm5giXZkbmmVr2UjiDFXQXVQ_2EJHuGmV45_swmeMbUYAMHuZuf09nv26YdvPaVYX44hW5cc0DpeF6ZM7K8gplIToTMXxtEEHSpjBeZQA4ocjeC_zJnnoOg1MIcVvtxBv0m09sD5MXJ0zvjWAMyOIJgIQCHZU7tdUUKLHjriRjQXrwrQhJ9C2b17Rdb3McLbAYKxd3yQPJEO6FZOmoYs2ZaK5Ta6vZ8QX1N0x11ZcJnT0y2vMfD8Bt4tcfs1IgIfB7DvP0_iYJVwVNJUYNtltWed_AV-2I8zfSYyZnJUYoPDJizjL6ShjepIezXJIegltTmOvnk8SOISYlHAChz2xHV-5V3NRSGcTPZQ68t5UA4xpa4y1JUTQITIYE-0YvkX3oAS1DvOBQJ0u_gpwDisWd92kffVP6VxRgJ2Gnz4dcbQdXFLtgAoCpp4yfu8P4IM7Yg7QHSn4RzMjN8LZHyMcpqNlNzuxyFuorOwVBdUPggziuozvfAAUbBfQ2FZweE7Z5WzZTRRatWhEtpLwJvYQaD0Y3Hs4Gb-yIfljvonhRVL4rPqWtLjNEveynNsomLtZG-WLN4OK1YxGNUjChlT98aTgKAUsWB0NPCL9eAzAvpWBHTpzYPdHoG4Z_D4dCXF2v4oBXHgZBH3-d5b1kbCK3HjvyECIIa8vGH9_eZWlwspHKY7smYkBO7GQoo5cvQADp7xJSqEq8yhIdV6ofXQJ52I8O5Owg2vmri6Luyqt7IcMl4K2UVSNL3BI5Lq7WuPrCPY3xE9ifh3CAbzCL7l66bCxFko-yYR0t2cwrgtu_7j1tlS2UuwNW-A_mQNEx2WBa0YriOqlnWFNqYUs74d4sjiTt9LRjD1bUNmvRqw_w1VsNsCeh4Nbf9MdTTOmUfejFoUAWUw1chwd8FHbd1FdqKmJm7bEemPkejQucJaN8kUvkgUsUrs7busubUCzt11TFpqsB_0WiF6IMHqMSANsemq6r_t-iHzCtPNRCp2nZaaYgmuXwXZ49RaX_quXl-CDvn0Fju_BDDROYPcyGNO_zf1lklXZl1JoE7eNJDgdv-1e6aOSoPNeZgZBc_2uIk6XwMdiQ_TT3hj6M0TFk4V54qj_BKWc3ZmbppRp1L7adjygGO24h4TuHadtYP4QcGVj39PaZa5G4McGxiyrsUoQ1HfX9E9WpdsU9drHMGp7GaDK3NUsrIUeJLD1w_84_Wg_CrSa7gMw2FkiAd204NjGTFRMav4omyYKZjmjpAzECnhm3tj1iJRboqdxknb81guq_gYKjYAo7SI9MCXWf5OAZj3Zq77S8v6apyXWQ-SNYCNFg3OyKQk-0r9tFxUNSvKuQwR2cBoI5qmIfMoqqPCL45ci0BFhviyV05NDt5m5_VdY6YGu5lzfEw1QBUSu8geFZdQh_S4hepxbCZ6xXpAI-EwXSz0HzBkw08bTdXtgtDGHLy5Bc-i6YzaeesjbV4HByL8MfX4YRjSOKnNWN0HikNJV5_iHk-JnDEdIMefm4EfX-y2EBg_iEZMZtiFJjH30bWtYi0slMngq0HUJVMQPPrxVWeg1qf-73FqICqbIDoDi72hELPC2aN7d36gj9Mphdq6-meu8cAWSccAz8t4UQnVtgGra4GHLsec-qSrENzC3MOAgEjL0GzUCmOIDwowuIn3ZKy0LS--yJiYkqqfAStvY_EXXL6KMuR2KTeG3ZmmSRYgfdW5r_YzqHB7c2_NHoellkhVZwGg7V8AARPJln5eqIOkQXHq2Hr6GMbVJVGP5bEuVYMo9zKgAoMP_lgY8WAC2ct10ETiHV_KV7_pClScW8SPiXgHuHf3Zi3uIbFbox7oTwr19aO8vROAw1QaCqwDSXqqA2Uaqv0qIdrlXF3BxX4gIXyM0ZLmFqoFngZqvQTHolq0QzsVDBrOAt3P4hfCISSgUxRz86DLONUi_1R4JxBAv68YeV-9QXqe90jm8QNCJFFEmUw3iRTJuFbqmlJ4tT8ORGTlBu9DJA46wbdspaDKgE3EoNQBvAEbMPBMIVFQEfWGypXzOUsr4VdEMUeXc_zSJqdJe8tjXT4Lr_Vl6YTVn6UQv6JYJ5cVhoYrIbhurGW_8R3hetiodqvH08p_gS1EpwZVPpQvlVLaXmHbXHAWSg-DlSrqcxH-kAVSGJ-s0ZChInVVVpiqGX9dKttphUbOQUVdV1dHYN8c8SvO6KlQNpIZ2kPq9KabYknrs49BmaP4UbG_9bBc725kT9zk_SvwGB7WFCLYgPQQCbwHZyNU2KRWNf5McigT8GIQJ5EckkD1Vs633M9vAC8P41CmZJ0bMLiF-T4vAsSG2vUNurHDQt31YQIgwrlVMuQ5cVw1N1_bm9GavT2Gw5WYIQY9dqvKNWbkWnux-JUA2EQURHI9dRHMHiipNVGH3KBDDkt_b6YC0ag9bY2hvKwPZmNWV3yf-2q7sU9-z3QHCYY_ZVms2KJ0dTTXsUaNFqj7_UAze2CL7oIMGdpjSrbLOhZjmvVtKjavufthzDxFwH5p8vVwaS2XQgjJA1rtPc0zivXYQHWlE-FNUt6om_eRmF-4Zs9QN6I-WgPJU2pAj34xHZNIkVKlG-QmyhqPH324HolBqbOK8v7aMtZVtHaDK7l7LPyVWaX9vGO3Vi_MHeEVGuyAJH-P8fbc4BnVqn5Cr2411uH8DWHvZUstINeM6VPQgPUrSgne3N7cDxQaur80P0VOxZg99MtcbpCoISVnKfB6SeuWogI_xgPQfhcmCmyfSRzEJhgwvNU2GRM2YMciraaNAypdyplzfs2-DAV3mHbdRnhz5Z-7f1K8plp2_pxp7kg9wgAUCH6RjImlK9hD6-sn1e4JHo2_yMEGLqaBIXvwhy8ZFYD3vVdhZSYo-GWufjSkoKGmMXQDIVZyG-qZycTgkJtfMJz1Np1zFVcR37vnkQZ_APd6p0CyQIJG_Hd1LiQweuk2Tn8j7DTwOn55YHw-036RREPVI7HDPWbcr7ljEp4qpnJ9REQxRNr1buFWncYBSzORQ5KV72HP59Pm7XzWVdnzwJIxO66ULnMA066gfe6Wr-3BD66jba90RNMsKMg0rgcuB1Q4HZCi3NPrChflBeKNSTIq8ld3zS49fAPJXqidLOcyvDDDzzySIDy-XoaY891SmpbaBw0CEptM3uxkZYZ047fTkGVYJI_gNOFX5RQKp9GSssdmWlaKG4TxAwRD8O85u3LRGus41qPe05F972Ekt_XNMCz0-CH4jg-yNVDusUpfF-Ua9svuPTkvLFLED7Pdqx121VxtWn1IjK7xolKtqvgjxAVL869oues79NFtLysb0l7mseuDssVy_kUn1x_Vy2B3fC5i0TKKJAY2PKRMCQp61OGzoLzf24kqZ6xykRqkdWh_DsoXuou9faouLq8vp2xP_GeGMqSRQBRWjYFkLmQ0n6-y4j4rL3HwGWTSnd6jLj8dK-Vo_kmzwZDDUYYQ-ig8lHJyyvFCVBA_JQlAi-RlDqkiWAu3ljtpYjrydHqKey25A54ftUibY3ko1G9WFzDozW1Wi17FO1_Cg-xFh1XfHNoBUHIPUY46cE0vVqkxC-PClPkpvr3fgRU142ZUSTA-WGL4EC8uwqwWdsMW0dAZ5F_m3udXvlpF3Q-sGa2c5kX3jOi3t6KgDUOjCzjWMWbQhl6SMhoBaRAOSf37V-W1bilEelfFOJUBlzfHLRluDORHJxMP6FQv0L_1xQHGfCTgy374QP4gDNqfHxzi9kmhGzbhEVUfxtaiWP7BCWB0Rq_xWypesacSlt4O1sPdfSdG-HYXL5KWKg2MUcuoN_Z9jG_9XndzdHH01MS4E9ouVfuORyFjG4KadXZ1sQbLieRzcu4iGt8j12GPrDMNdmP8qB_m-eFLhWRzrZc-W1hj1SH2aP5BBZspIY9ZNCHAMUYaMg25V8q57RLHnO9_Lhk9JJ3m_0B2N-0tpafpnFxnA4X-XcbOfOdOwmTwhmvrEPea68O-L35iEUzl1ntQBarUZYcQ9s9lSs_GAYeViOHUpv2BoH74b_khjoI_bWyWXqXGSTusmKhvU4VExyoODsjwpdnez8Iue6zECeXCHh1zYXUqcIVqh4OLC3xDIWQda8WO-FoyUSdDJZwkUPOWH4xdfwn0ZcllkHGdwiOZ5OgSCkxQjYHIYbdt3QwIGBfRPzeB6sAd8FhS9jxYYf90Z3KmUDY5YUcVyaMKsiI3MMGc1DNogHvIxM97Gdx1lHenO2JU9u_sGfjAHS4YunhZXdMzoRQYTA2zeduM-yCetvVrEfBeEyPlpuSABlsiw_9QnIQTgHt-l2gB5jZZB28ff5Zpwh3s87IsUP4lDbWhB4rayzydaP93sTAbquZSX546rO0H8MU6zPStpHDv8q--gDII8LW13_8F3WuZ-PUMOtJyby9WAOXQgIf5njmJtxISlBOct1S9tBBGrHpS680JPWQHkh9gCuk_V2y2Gely4R64i9-SK9Ggj3xHj9i5MLH5HlnHNucVlgVn3fHF6LrSyr_IyK2-jiDZwoOcHzO7KyPRYXrctCUpgSRIJqBB-1ndpJ5Hs1DBiToeXwB5LBGPXrA4LMoFMsocwSHM42xhtWibu26ruZqdXvShk8HFDgRU2UbLwOM4daQsv9sFPwisV6nddOHqhIH3fcFeeJ-ZR02XoESgdyxnbbjbe_50434Xc4MFWTSEh4g42NhM2i0TfdPQ0eFVSunVLZJaq1k3nBmDYJDczxcMTHPxMREOtb6eqZB1TlvntC-P7NGfssS99wFtKaffNROoKT-5-N6obtDPJAaCHSOO4toSzRZ1E7CqK0r1LnzBE3jYMisbSW9WN9-GXhTTJJLYXPmBIN7v-vILe_mz-f6O5XIJKOpa6tLeo15zlTEemR3Y0ysSYLj62W9M2_J903N4QYZZ2zirdIqDIFYJy-6UAPlWD7o-kMpfSbIK9CnKeKZF2jZkwovqtv1DlMLMxNOf-WqmBRGNExpx0AYvs8mvqEvzHUJYNe2U3gf2EHWGqWDx1z2O2Rd72P-YV7JpeyksxZ51d_lKzqS57SnEAP8-0y65QWMH35fG_uYrhuQYjwvw5YEkGGuo0F3Lk5Ty4rLDlsopB8xJAd4d1Dxrquu77t2MAi0MOikR2zvA3y4CUm0XcouLY9xpNjouxL4pWgsIpwhPdJg7fxE_HN9LHRFOZohMuHLsrvPJP96DNL8mvoYiD6mF0mj5NoA7Yfj_0bLsgzXgCcG0MqO60NuquY3eyW7pMhj0LWMuY7kqbVRPi3NJqax7xNqsW3vmR7-ZLT_oBgH5xtg94JJPgAt3fX5XlY5OP46L08aqhOEKsfW_EsfNO8jHRSmvC4tmixSU31niIs6dKzb9InPW-EyL084sug0KhExhWQ2ZYpsl6DJydGaWGpoJSKrNDESVWoPc2UUzvk-wpNOr5ArHSapGK6uoEzVxUY8Mtnxg-XrDR-5WNSZODUA7Gc9j84c6vcVSLD853Z6gZhCpuNpQmfIUofyAzKWzpkDJ5jvsqn2ffF-wa3p2gGhVsE9D-m_e1anr9qY35tebj4J2GFX7ShaWZ-K_MHiljRAeHpG8v88kCBwJlymlDhwFU5gyRBeHI48pcm3Vugdeppmy8sXOXqfBbrd7rWqWQM25TMzIgJ2Yn6Qj26_jj1EgRR6kuaIQOeU1GFA6i2wCWOBMN0GEDVtyJZwbP79V_2dgfhOwGmg9poaOcDpnV7BEaft6NtksCOOzrrm0XK04QDqLQBtvwTk0x42s2OOp-78_INIaPLd7N918CrSkKg1HLHtQEagp3aHt8tB0xhZMXOHM-x3FVRqVepqMvKyCUpclZxlT14T0Rs9d3UThUv1boLMMQpJ9pmOyck3u1Nc3CPbWzywNcWqyFTlcHuGeZN0KH_3kWSv7jjJVAEHOrxBJDSYh4U9sXloXAtY71ilfZz0Qhvig-KiA5qpwoFapzb3U0mjnU7ip6TEO7FnkMFdQMSD-xDNOd5B4cnSNob6m9vNoRNejuddIRoismYktCQiwYbqfSShEXsqd3kiCn7Q9pJv5HnYe5vuCUmVjJqYBxwrT78i7lGX47-laiEg3Ar1jMCQNBIE1AwRHBPkULBfnkoEX9y4u2wrj72iYELvZr3GR-Im1YwjLovW5kA13ZYhkGqwxk52lG4r-v_L77zAOyCYiSApjemWhTKHjCNhVAL5s8ssw6D8w63auOypRG3UL8quRTTg3pcMmEwuWqVicKIYASeUgB2GvENoo4h3YJwbd42Ap8OAUxgo-uEMm2pzKBsspL474Tw1bKPbofPJCEpM0_Kc318H7ztMMDUYZ39fxG0AZ4bF0nWuEP8tdsfhuwAdK5MbLfohIOA2MMtUh3Rx7j1Dor5bzFLyVtEZHqrIsQkHUTTLZOJhJO3po5a54yP2IeDFjZi5UxYwjLF1rRUphhba_h-eBAEk2x27V76NHIX4mny52gOHq7Dgvx0E3P0RT7OsrSVvkRZ5GiB_nlG95c8BX_CwOTYyx3IkXqKExFVAQ_3fvdiWRFy-wbE1NlTtj6ZvkEJqW8VILLANwUms_dZqoCcHNmOZEp2KDoSvrwhOrLpgJdNxhZOLahOGAkCbqcpAVNMoisJ6C9hBj84KnrpFpHsqw_VOKE6ZPruNgjmzWuedwV9FGaRvFQSfdcjADdooSoyNj0LsICYZrqoAlzKfYDmxjoBSAMe_SzzJRzBTlV5U66SUNDyhJQumfqyK2n5ZEjvLo9zEgj8nO6c1Q089jUdp_AeElV6SYWXQUNcE0hL2wJ0AvEDZpZ0sGi6ofyZXP_u2vAiUuKbsWb3NSlvPR2tow6bUYCpwlIxbWXKiiqrtDuemZ42T0hA4gIK9KIvo3a6SUspZOd1KiUqZAbsqESurGwF2cAH53RJOlxb5itB1vBPBsG6G4XITVUqbm-oBzelSoOjivF1bTknaSZwDUdEXQdUYFoa0547yW_0kYxv9bkhKGH7OGKNhGd_umPkt-BEAz3BoE72hEC2o8TfFLrBjE_BAoKQeFi4w5Q2ffXuelrIuqif2mxTZP6I_x6Hpv6fPitc-coUwEe_pczO4GPLRyw0TnoBQZJbKjvafprLZYCjH5vQQ2ytFFnfaVvaS_Okc20tCstYe4xCdwOmKnS-tqcnHcOdh_EkElhwdm2SmKrMvvaZGSIGvkyKZQSq2wylsO4FVyicFGgVHb32d-wlAN37-dG1jnu3HBSi4CxggoLR2YIuX8jPXiWAvxEhhy8Tg6VyCRUyuRXIaleIcixmmZ-GyuAedzpOIf2EwahxTS4lQO9ha36MJ9wFq3-PG8B2lZfY_66clhRkQ6UvxlkCFwkFagnotUBKVyuG_tGB-GuLqJ5l7ZoOve90LuU4_hUDKE3whn8GktFAkcuunb3AeUkPP--EfWGJPuoT3KGJx7JxIxHZQlTbiq164_1SyOlTeecgdDQrdplbvLGbqeGKc7RUxCrhnaleV_UuigsVrEVW5uwPBW3n5vhS3a_y4ylCwDQorzmwExnJAgkPXgviZqe0lxPDawvf7OXsT7Dg7LDjEwfPX6dzOFU4Jpg2HwRrTQB0Btgn79Imo68QxEj8N-KScK7S-pmlyYEOxYOlRRGmDYolpUbNom3dAzq0wvClEEzCfJXl60OyJJ5Oo_HWe7WqVhALqs7XWcntDE00JL5g_-TJ18tNuB2KjC-HzQEBwQwXvr09bzJm3Oup4Tk1LoFwfbSFwsrpNli6523AkUCTEIaklH5lrjOFU1kRbRLUoNgJvJDO186pQYULSnFNNsR-xtKZGxdtgMb94BvD9WuS0M5c6hp4R6xm5g3XQM0XB8l6aJOddvm9YH02YQ2OcRp9RWUXwYQ_C9qfLkHHIbCgg0HOFkE6CrDFd5Lq96MYrtyOGA_pc3-J9I9H7NRbSVm7wGiOeRWxaf4UE4h6c2uP0RueulL3DMDnJEIOvns2AxNxEvW3FWrHJHua3ppMTdLy2UwBDqzACxDnazv2OCa1-qc6b3v61SveLafjkGvD-SWr9jzWoB2_O86NxebyffWcGrEYwdot1yVBLuav12aBwmioWXwDsLD8JZ83KP05V5wVF4OFQ6cqMbejjmFPw3yHw8BNTI9ecBIQ6YEPfZpsy07jb2v2V5pS85U0CQoxjnRRSemZYF5XtjmLii7Q9uCYiD9_s6mXi2bzf02224HewQyrmNMKt8jwoXMpM9_H2Rsk7brgbgpyf1uJD_WRlpPFdE1DcmIL5bDOLvy1WpBC_nv_L1gI53BDK9Fi7BwU-f9LsJ343-HblkpqiTz5kr37SPKEAUCPij36rbbF3WwyAo8xDEPYIAHVELdlEr_zNa9kC4epGF4u_arBrC9R1_iFqv3sXE8V2Hk8hTBb8fE6dCedOQ93cLpdiYImLDaqxFJ-DEntaVpJ7ZfQfPVF_byQqjaVF6EPbtwBxnS6v_t-CpdOsZVnhAVgKu7c2M5Y3VstkvWYLZp3WhoChCHvKux-QFg1-pv22OvycdXJgSHzSiGA_m5SFhk_wUol1Jw1YRG92Yh5G1G15dTAiWEJHbHtk7RzWtfxQNgfH6Cm2TiksM56F53ezjYKhGYGc-mW5x5UgvhV5-2hZCmyyHDGlA6qeuybmSqCo9A8w0VqdYwBhRNTYpbZ0it5HTp5lL4kR_EvqGCOTfw0B06VExiGvD5kitA3GC9kPlnVFEEFhPmHGsT89aySLcfTez580nl2ePIjfuFPqsDsZDBVEOI1l_ZuIMO6KSiJMj03Vgan86Zx9z734hJtqZy3vkNl6qYM82SEGWIuIIM6mVpb1m66Yokf9BVL59_Btj4VsVbfWSSE9Gec6D1t3He_d7lF5fsbH1gYauuE7Y8yLc1Iv71LQv9pWTctdkQBQcLqqB8MDbCLa_Li0AIogSjgUpRFuuer6XW6Tm1RqlBLx0QDa6c1vu4XzWDXQVDKLxQtgr7g0ptZhspC3tp93xcD4c0n39N6thNXMmXn7cPnjwp3PV4pTQdxRE0tWumoK3PQ_z0z7KwZCkXva4-2oSCBIk3YQYSukWcj8ni5Wb-HCRASbkFqsVXcVsYynXilRTahL0_8pe9jJz-YuNp3LhKCtiWpBWkgrVgsn8XpD5AjU66pb5Q6o2TM77eMKu8EzUYcvHTBkmH3eT3P7-AapfYYdPIeexlVivgxZkozGlO0Vl2Sm2T1TdmPi54Qbs__xCHa567lAkF937M-A4I0H0VYLasE-XKLV9smoUkKAilQjPhLxWYfxQPpwqDbpKUvMlQBO32Sj7MOZyDu52seyR6J5R7tpqsczEUcnSPE56PiepENx0NykkH2HRg6qK3iSE1oZieclMyMHsT9LqXhCGNDyV5W2aQLU38OGzJdGCg_uYFqgKD47nmW7_HmMJcjVOaL-OZXEhojK2TEnc49ungaAaQdWMU5lBrUALCPPJdi8hMiNZOxS0TRgZ5WH4PoeZsCWul7VHBAYqu0z_YYwI1AoA7eIAmwCnyAcCduFlL1H9bz5mWLIh3V4aFIm_DL4J_5uROg-iB4lzgILSDzyVxws5ccTdWcJvTBNoIWLB5Pe1YbM34RZaeJSq43bQunHXYwy0Fu0ugzBMmhwYG1di_X-CMv4oacqNQqd8tJeIspf0AzmjoJmrHflVyq-iCTwEIvXFb_WHSzgX4Bw620p6Fao8lRrYHdYCZ0GEzmajAqOVDD0ul9WOY93jMv7guYcyCJ-BsXHYmVOWGo5iLbLFKC4txDdX2b4EOTSDKvE8x56J2V9y2JZrNzWZn-_bVqV-2NvkC7DPwEf3WNSFBoobp2YCUkrcvfzrbyY9pI8VStSNRHitGKJ12eFTCPN5VLbaJVfAMFY2-TlUwLfeLj-BMLSbH8f6PtKbFolxcnagkUOM7DCH3KmMCzxiIsK-aiD9IPs4SSuf39LUHRnVtkfIo30fj1e1JdWOUQ2Gtfu8glacSs7yOdIpNnDoDjEeT2NImoO1nW__k46akP50sEkQQw1iDUNdR2_Lwcq6hzaofAgAPQicO8iJGe8YAKbmhQuIq1EeJR5_SC4p_lPmtJKTCZUsLn3KLIJINYRQZ2mpaQ0kT06biA3i2B_ofMlxs4tKayngyCjfVvKlCIbD7lHDUQjAAALkVuyKdE-lynwTTfDvd36ZuFrf10eQN5w8tp-SSn_1WJKLRqkfWOrJbzJkfirBOokrKksa6YrV6UljT_ABQvO7XGevZwYM5QHBkOMv7i0Cu0LWe85oKSFK3mlTGVwvWNipJElTjCWa_QdsjoNwiBObdn6TC3-GguoCTRn8MGHepHx87C8Ir78nZMPDXY1089865Qb7Jud73z8NUfmE3pQUiOuHGUikjN9m_zhBI1dmrSS_sgIphD-RX2G81UQzkpIt5-aj26GlGpEMeC5PHDk8-ePPcZyB__8qX_LLMAwCGCu_iQnU5DVQDAvOdnbp5gzDAZIRG_7TXIKRIutS20SXMg1r6YnirMbKRU7_rklp3LkL2ihP7Lxy_6yvz1PrPZrQf_RNfY8pitZZ_BiLmbWk8zsHE9txIija_mkMBAzm1PFx9YZ_zoyTh3Gqr5jnsRCaxy1jcMg-gMOIB5hp3Xjjf4vhV2mXxUCFvvppurHc-ELkjUCAKhZP_HBRA6cqFx-2qid9Gaovg8Mz2Macw4XQ1ZV6QOivnBcJcGNQQuDsD6CPnQudY7xFYDyFaTmZSfodGBZh6dpcp8xPz4zgLUPH94jxjK1IjwDP6pQW1PRCtAU5OZS5ZgQC4m0Q7ojfX9U4tj8jdJ1IfX9q3U8LCdcHAj2bLyj2ekbzOUrfCBGmh-36WOHPTix3jGcRnIBm5GT3HtwkFIYLOwyf96ZL7Wpb_opzmoMeqMSna2XD9bU61GbiZJGj1lrq70zFbWDsCV5gNOtdeEN5KPTrdrFnW4LubRM7Cr8Gyc6fzyHE-v1T1AJiFeswhOEzZQVBnd1pS8zXkGYkNzr6iT0qUOpSAFKIp45wKmlYcePC4lsbXLA6YEehVe_d2wOqbMmkX0IRZ8h2y_yCWRGM6ujZaOB8bEPxjnhWAorNlOFlTZPEtQG_BqB9KXTgo4owpYd3biYXru0l5ZG2oUgfbjzPIEyflX-rWjN8o5UJi4Gdx2ApleGczIJQNkr-dV_kcvnP2ixkvp1yHTJkKSm8ipgt313M6VawdDffeSTYI04pz3o5LSzyJlMVRDPQNQf1RWAN2Wd7Rh3xgAZRiVbNeX5KDqpdvRviSmMYLZHwcGCC5qTLqbQBVUgVAXjSA153h_KonvTy_b41GB9pNdhdRmtaG9Ta-JdKJ8n-PQYXt-TDFX9uBx4S0JMlTadE9JDF_dGkBmkRD0uTPi1ydEQGiTu9mBYOLFkvTAuNAPervQGfpdgDPy3Nqw1iKWNQ1Zh_gCzZJPJ2zuguBlJ34zEJM-db4MqS1UQkDzT-eABevi7sbC2iK_C0Lm8DvHn04CiDMwCKVBGK761T4zxl-mCNPdZKdM6T0iBdLFOqC1NG5tf_XMaUeuhBpWqsExDWUiqaUF6_p4xuy9PmVrbLYchjwS_-xV2N4LuUOfzUyFLOie_lOOxeKz-UphPoZvSiiKwTv6VxB_HRwlexfhDFL8NnxjpyYLBQzsxnqTRlIZwB2UsTTZ3phBVzdiMKRUePCq3Y4w7BFU9KpI_kOW4njWOsXaT3oEjNShpS89q0aQWaakDU4TL7Qa61RPgxjvfWyLzSByTJt14k8GOelMcqWemCGR1wTl5J--6JT8NDCmgCo2EWCbKuX4GLlgmgeaX5INrxY3XbE0y74UbUmkPgGhytqb6H8PWhRYeHJ2dsjhsg_XJZNjsvXuKhq5K9vekSo0Y1zrsxvd5pXuTtlKN6DATkKfmqTC0sF2-2SpCSxLMAB23YxgNmW1Mf0CWt0Z09P-K4jvaXU9YtzmBeaFVhYTZ71H8f4UhKTw2c_q049UF6V9TG76-jwSWdlb1k9GdZWIFdaCCTKwHUXG8zlzqYlu3_C3lb3guvenlg02m3CmrPH4oCeWe3X7CWxHHn_gztsmJ-0NurFyT7Y3dUcD18Wz3PlOijMUd_m9y4sDpxqlu6LAdVTgio6VZ3UUQkizQ_eyCNrfsrhpu51ChHN-LKl2O0z4X7xc7YEXnd2yvWYWrqY47NkBOn0p9c78YCS7p_n7zwHEfTsoAcVa6gjvYf1NVDrm84zqJIjjmyEc7uZDNENMVJxnggmeHbVA2p8TCJ4wOk2f9H1xv8YZii1jOZT82pCJHyGZwkpwBAImpj-Fm4nfO4IVxSrb87eZgbbGP1ZgFqXQYzET2wH8QD_0-ka-1xpLRQnAm-1qjq9niQimY67x6wgtGkgYwyhpOoyavTt44bk3l33I6Mc1H6-iyoR9DrS0FihmWJWBcsxUIuPQiNl3FOdiWyXloNvH1vCXLqJ3XEqovwJSLOxC91UixzVZjgyoEQiiisOdxBLYyhstzus8kKM-XGZ_HYwgMpGb6T1XE1eJbfl30SPv_ai8s3uhEWsULVwFrxjCmvhEFyn9j3I-4BREJrZFNUJrvE2G3axMBPO-CTft_ztIT84-1yqCLfbR2kw-aJ3sQMIb-DNwwHoE46qqhWU_4nlwedPeEmSCu_L9FmRIbVa_4R2Sad8v782VbXINUPHYS7YGYP40FViC6GJghqmTygfkIZfT2YEPAd8ss1wVGc0jmT_YOBuYXI5OgKehj-Qh8qR4vNaWGDFzyDxsHuV2--MNzyX9cYipM00vHUb0o3uvOwIXDit3uSS09OoqeCbGaCQ1jP5RaSDYGT5YhJ8fibtMLIjZLd83J2jJwo3RUASqF6-DxUjMJBx7DfsQKq02G0uLbzIH-PkOFmzMQ_9reluLLP00GEGw_1qh2xg-3kVflYj1c_93KCcBeg7cFjvY-Nax_DVQqITP1mfmXQfErGo_B6UBmMY-LXpp9yVsZdYzukFCaWlUkT1kUnS9eIG1bEWdt3f7-jBhV6-Yph5hG6ZGEK2yoh_saYgg9ZpNKDe-NuyTgCSid8gHF9bprqE4MUr6-cwc31drIpeS6AxL7z4MQq4DFrDCX0GoAsYHx5Y0rWKFp2nuhQs44CCeyJPBjlMXHEAyuPGnkjmbjdIaAhThnAvUDEhtB9_pNd81T-PUfT3YKUhYyg_64VfAXZJORiXnMyeoyTB_NitOJq_ZSAKbU26gu7vs5wkq-9C01B61ceL96yBUNq-10S2SMyQOiWtCMy8elJ73YgwNkGWdgwSWKr9DJlEdojsyz_7wMNPDD6SBgYsTm_vSSf8bNQN1CqWzEz_s1nXqpbIwIoAsnScnd5VwWK6G1BkD7fi1k-1S0v0L2GgTIH0uQw2s5MI2Em-dRjpZnju_195JP7Wg47ESSatMaXpDyoZItFBJk6nxunGWbs2EB_5td_WjJNAcXDzsu0VbXwew-xgrZC1rcIzVqycfWrTwB2gzaTS_ncogGMe7kQh_ha7kee7ido0e2UMH9W0oau0TGAVcY9dop4plPvEtveQ2qpp5KQj36nE0fSz5oqBf-oj9yZRsf1A9SylYzkC1UR2sGDsZx_Uz1Bn6fm-58jPxpgZ2zP9cAM22a6ejEPQmMSvzjmXW5tq5ppZgGDQdCsT4kpq32tK0stI479EcB3UTiiVWxIXERil3ObF71ZulIjSfvP4d1VNU5xHYc0K0tnsOXKBqx8xunuep_k_JX_DV_uJicX8RHlebieuE85XmcyBaSP65DZvl2b2jV_cROQAILxSkWq5OXk5chhchh6mSvDunjW4KY99t594I8RqAJUnn8QCLqtAR2r61vSIbjqGmF9qY0GBp_bFKCaa9fd-UaiYXixaCP5Amp6CRg-hhEHm5yU9OkB3Yl3J0gz7U_B1L0brAh_KCBSw9elRaoWoeqYB9VS79FjJq6hb63AuAvjgbQC2pr1F4p5xyHVOxFjBrxtmJ2tr-WkVzcNOYZgWBVxdYyLRl27PcT6v3vZw6-yHA_-hsY6-EV7cvFmq_LxL_yQ5GDbSWky5903-_YPvgmpnJrx-SLPtWE_6Np618uRHlSTxAv3Cf30xF80AzT_2JnpZtfiV_5HcFk_bXKlQWlKzoEEx5-FQ4ILAv9a15UCIObX8LcyFvb7TBbPD2pHa9AKy4nr5tshcp3yruUCoqJROz2YpNSkL__XkY4BI5gVLs0mfdtn2RkYGEMoy_XxYOG4VifqkpxpfgVGFUU-PvDMbQuiB7mg8WBoYnkX6-0NQhOHSnYlM-VVdtQo3K4rl6GdehEoT8HiHPN1oFpMefFpbvQbTgxkrqcly_K62Y6RbG7kBvg0oEqSAMRjzl3f2U3MvcbbyMvDugh-Wl1eKvzqz9jQZn4zyDNJRMJmD8YUJekkSXV8YPRzQoUfTB5-cXJDpa0mo4p8Du3ITKTVtsBja6pBTWu48TOhBbaQWo4FT7ynZHNEu8h9wngTIEpSfG2plQtGGKEuc-1tFHG4it1_ggpYq1n9E5vYeyUK-DAqa40Dv0kx40dRj3b6UgWIQNM0mqWIRGn55dPXGADBcylehllKTmDPi_o32HZB2pqtkaCh5HFr--_Y6pjYUhOJ2He1PbvJHMtmsHtLLzvIedBL4Nvg1NfdazJBSYxU02DS5-4Dvwsp7zJXlj0n37c4AVhmmxkXlwBKiWaTkAU5EE_p9N1smLuusmSXd5TvN2rKKN_Md4DzohU_k7grSQiOLaIpUYsCQFN05hSrLN-hRn59io_WWMS410rvjibdEwEO5pWRpvhFnw_2yETFViSBXhY8xxxYLfCTnqMpoxJey-TBIE13734cIVIGgPeJvnkdwfqdHRZxgjM9GmZ0G3umQPkwx4J2nLE7en9cAWnnvHaGIShVdMI71Yju9fKMrigUVejQLHk1eknS12BvTtzyeUKIRN-NRAbMpFI_ul6oMO2kZtG1r2Znr3MkoqPke0ybuahAy7Wcu6l9V2tpjwQlw1QNvumngR9EmVHG5yyiKizPD4D5YLb1V9XThtHRD3EGTQ59ulSjNvhp9vSQFOQP_WEhSXVqMA1b0iLFUZ1sR6p71JXxo_NCfbaHfjQHdv7lzxUxMV0_w7h81B-Tur0j6NbkNHgi3sXABav8WaNdXNSZfVBynN-tJF-FJxnpzsrNYKVv82Yd7jW-0MS2YXwKBkS6N1Ncm_UPqHsBKD21IK10iCdZZ3azgiUPAldmdzJjrdpu9rsfWaUnfmGL4Pykmt5OaAISjfYRk4hfvJIBLDvGXS0VdhwNLT_L6a7joHODbBDBv8uxk56lpCs-lRfmdujv_9xpIjZPCOpnyR3vyL_Bpsaqnru7xJ0MrVSqH726ZRGclkbULFkjm_maO16rmtgogOp2JTwfJI1q8FpU7qKbKyfFHQzpmU4O8Aw7VyUb-tURv4cJmFoSc8ORSugMrQcXC8Tv7nZ7AYRf7Fo0EzCYK3I2JWC9hyOPp8H5P3jfPUkiLZdztddBj3fosNIr-VPhKTFRqnwwrVtQDBeIzb-Ey4lzdugoeMcnSNo1yoymRiLdJxU4olYebRRUnr3hzYOpSBs6uho33rdCqf0QvyjoczW-7mfTrW0pUrNSf7ic4Q4Q6OHRhFjYLLdySeTLUkgmU-Y8tg1gTHQFFfsxEUe1hW6H7PN1kHTM0Tix6bYQC7dbl5CdQoO-fFHJynnRKArxUxlqLUqT_QcjWFJfE4aM8XwKnNAB2f5eEHCfxg0d82xc85c0xNcft-EMdzzoBT_HkjPhzu1VCuFunJDiuf_wEHT1AGLx9hhh5P9GOzuOZ2OiF6FZe6_JE2vn91y59YneRSjk8C7mcYkkq8F3XI6ljqniHCNOTalPGqGvvjqeOJd8AdaTfGJ4lC1HT4IeJyRZ8oHsyJ6q3MMLCrxLmCJsOaWPxtc2OeObOYWzlxkWr4xOScr-1kZRrSOMzIfTRTxC-PhOlHGl9QAwSkaBOMmJFFgnj5ZSmstRatis-Q72V75uS_Q8877TgVRGc4XHxVADVaJnbdfa8pPnf8XyLOvgflaJHwtnltVDP1h2p5k3uBu8OS7_NyhazE5yhFPa5Fnks8tW4Ezobmm-vAi8oiDuTjIkUGIluwCewbBZA5QYzd1JIWKDL-nUacZn6lDS_G17kDEQx8WA4BT_aXrvkcELT60OY1wSNGxO83ORgBCpWGBlzlSOUDVDf33M3FaZ71mrxyofifWoO8ji8kaX8SYUn4kElFer8YRxx25Yc0seWhrVvz2H1D_H3iOfyconN5yYCBCGJqhOsaWm85ft5XKWwrvB03ikGsZUJaIurqKG6KteyUfpTwaa51XkZI8_aH4nM7Jmlfkrcto-zuCc3nJOCLkIcUy5GkmrR1QCKL690mJfCSQXcwzlYkZlVlrdzuV2nhPj8P9iVmpkPn9b_3Yu_-cxJ5UwI8YpQoFDfwRkL7TcBCAtGq80qxyxx0vLYSsZtoAjI4NKBLaXO4ee9iuzXUEnEK_hBmkhMGc37XXfg2Cx3mfgPeeewBJTBXIbZsTROg1IPN-SyDIWl5vTd9eMJaYQyOxhlk45Yd7SpgAzX9v_K-DTfIetwzdvY1L9MLOk2rwZtl61PUe8_U_0rLal4qbrkfKyVfv1aNYFRvYVCAUWO5tBE5efGBwSXGlPgRWcdL0vqBuVqnv64gRsy_MU26gKrqtQvEazo_ER8JpUL94-YuQhafGtf5R5tQnnFG1VQXsu6BXwxeRkBHkNvQ0bmHZP3eQXXaHd91uK3lxTuzhd3rmc0fAX_-2EMnqJ968rXoDz6WY3dOqbiy0cy1LTh1teRE1GyanEUtxphOKpGHHTAS6Eu3XhF1AnPdiiYOuOFQaq77DnjHV4PumPbXBfhbOn9MLuj-WJT_9fAIeUtvdRksywdr7yT7brQVKRv4vNva5Oqj32B2lih23ZGU9hba4-egUwgA1Kyhrfxt5-Scjvy47_TzrQEtg2HVOP31WN3fMmeKy7Tdf1_7vTWMSpCxE20nJRc5OPXFNtFdk4CJdFM1iea6ls0xmF2b1uYJaFidDX2fNIFaJxHQ2xpCfGgPab60nvGxI4aiFKDBZ85rnKSiGnD_X9ls_r9KCDcK4y7Beiv_VuljZlzd64v2eq78tpr4q7EwBNZZotdp8qstgf1FWi3QUzhl77h89IS2GxeE3ZmeiExuxwfBqsBxNr-sYysQWeS6z6Se57O7HwTHxkdOk7e8tUIHtwHYn8vec0VL4mxyynqkxX4X7vZHfZZGhwE2E7tRlip1EYHzkaOUdRnLdLCokSaGN169KltG0AHPpsoSHc5-lI426V3Ym_rSICvN8jlZH9wlkVKPkZzun0Z3sFikk_hd9TKnhxt8XMbIqvsFlPOnkp5JwzfaHqE6dGuxXGnkeJPxOcnmZVpYbiUc8SVREfX1J7t7oGRgCzFukVuIagVI9-gbj_c6Qgj2zDZH1m2FNtJC2W_HFvOGC6Yb_6oweW6JzS6VQwAbrDksb4-n-KQDx_aok7NTAB5_4QAXugri1myUYQQJ1d4TACleykz1c49Mxj9dCQLem028dsxuua5oSH8nzgapMqf-Ct2jUwJm5WgtY3o85q36XOcgB6_fKobpteugkMpflK8-XrHXIUisl4aqGAWKV_r5nxj5PpKUXqEi5LciTSdRWGBkv0BtmFDt-OqErgJcd9btf_Rlugd9Jium9OFOvGONDJ75Ij7NN4462yvTkXHYVlt5RqRPyHuxNnh3iLuzm-t6nzlkBtSfjyxXwrl0XXZXRtPu1tLVJPqrr7PvCXj0sUD9tJYIMvPtFcMbl9h-MEve9sMduy6Oexdpj3fn7st0c0JAyOczBjW0eBiUjymMk_92o13UBNR5U4HDoqVydp07L7yhZz3gWmgcLee-yvlv42J9li1ai-mgNJvdy4BXdOBMclajOmYwyj2FeFdWKsLBSHLZfLrjwIA4L1962Z2dXMyL04AlalIJtgQG9nN4tlKtMqWpe1vEgvgnj5G1Mjdcz-WYV8K9hcfrC2avWuXL_ethFQkxg8LsyxpW6E3nLeVKE-wYIRyoLh75P4P0sPjQkGi1RXBzSKz28LDr9n8izT2d1NgdD5jddqKtk9flb2dF9HrikNcrVwxg6UG75qlqeulUhYRY171NuYQYFvWbqYQG-c7QwWOuxgsYu2xDxorIh7vNS2hVepAzuqWUu19RteWnH5-8Sk-Z1mK-cX8bVDsdjtZhffvylE51lwgYiHHV53Q55o0aJoLM8hVpVEVdeKYqslzqWGgOPByLVzrxxAL1i-OCYo-2gD5kcGCfxDAHuuersUEuINkHE1FAb4arcgMh8v5SceOy2Sk-3qnuubEqWE1kBZCbs-uqjw9TPJ2mQ6-xLIXZER1qooZ_zjvtZBfKV0YjN2Mu7vIuPH3yCpVEDiMMn3EyrZudncQM-c2pSf8VZ72pBBZciMzwF4bkhxfV_R09MhaPsj4qAW874WBMTfPF7aNKJ3iX0pH7-1vvzrEGSKlWwzqCMxfu1I0QBR5WV5Jc-a2gr36QswFhJ6piCEmX_pN6UXPG6jtzWttmkUpN-2_JtO_pBclWU5HIX_jKomLhnrPlEOhS-tYEfGM-Asuts4K0mi-dy0Vdkj3QMXJBpNTHZDdbmEZCN92UMNDbPtwAX0V7-Je87j1FTgrycnClziuV_aMJ5ruCNzumjATSEFtuDfYELnCriZKwReogfKX5JwauAVD9V-jJAiw3v3mwZMlPHQ1T0wXBFH4VS4zt3ixmbaVb8rKHoo_A20G1LCIK-NNDQTN7qDm2w938EBnDm13fDtQwc-tiD1uYMbbaWfAKoLvwx3F1rD13vMktgq9lXcNUT5T4FMrVpCxAlpYZYqZDdvJmzc8MKOxgx2iGcqjTXIKJlxH2zxytpog1Zfj3xViQCP4sYERAxk3p-7qDx2gfCjGOzUNYYq_gIeKHJ7TAtKVtYD962NMVL-0fN3ko4-qACj_Euht3qzWEjtENKhNpLYTVMpUgq2p-qCNLjtP32gxAzYEI3_lkrAMEB_CNmxGTVKX6PcLCsh5cM0atEaNG1-0RQKEplU9G4xU4Y4DdHfLO7lfDtID6F8-oLPbci07Jh8l7uZHSW9Fmi4NtvlxKkiaug3cMcmx35b093dmD0hJOEpcG5xHCbrKqwaA4mYlnoXkawA3LZWF3tnsSU_-GdbM9JYfT9-2dTLu2WGRlef_l2hhLY47WPaHqjAJEEm6tofGiLi7VDB68bmkrK9Uuqi71T7aSvkmvMzk1_vM0K0bU3UY0XkOv2UNZ8ObUC1YYmEzONf5f_v_EEdfCb2N0gyVr0nNro88oNtOa72Eub7xA-GF2yqc78dIk4JJlC7Fm_SF4pD1K25zJAu2suYw-3bMOYPujcajIZAviDH3WFso7G6obi3gUgCeaDsLY30ZhNNUjahBUJHXcQjQ00Mf4Wv0zeikT6L2z334vLE_3sw25vK6i7wp726lK95w05qC3eK69dEtOF02z1AFsO7RsfaPJ_gbVxrM5NzgmPvHNw-9g2MiAd04gEti4LDGBuqEBhtJ7jIbvUG3Ag9dkzRyD1Pf8o6fcsq--i7nxchq_Av0XSeG-hpYwsRGYLmc69z9CcQzUJrvcJB1NGJARFgBvVxAiADnZRwzpH4vQhdQbUIHFE0wBbCPGs_h6CsqdcG5Sw0QHm-4tUSh--i5PZxMVMWZ9lNUEj9dwl_J5RSMeIhbnEw_I1yDeM0bwxO5bKGXBYHf0z8YuFBpIKNlg2xskgWpMFj6vZoey7q8Vf8Vp4fy9hRxFJihptF9YuHcg5x59KXGbX6vrigWBtf96OhcvEAqypP9PeXhs6wu94KDz_pRvfEsb8ShviBGUoKJHFpCCsT6O0BCxwyGUZ0QjPjgxnjlILCu9NWRI_9uyCBYfAF7zQMbemhs6Rj5TAnSNlSNalu7q_T0tmAFBq8QoOWWH0-x10OHeqRhiRfa26BSW3lXRyKB39o8-feO8uhg40mg6Cg_LrQy5tgQaJpKjv0dsXdyBxw_2UXHfs6vdURs9cFjJ2i5TKch9udfbISci0IcJYc0Rm2iGS4DgcXNEQzNPh1IZ0IxTY31acxTIjkCr9SYkds6coBcjh8hTvnT54Nffwqjjnt8_ZNDSXXa2dR_Qo7lPSzHp0Bn1UihiNe5UZJm2yoKlEMi2bMhKePM8GHgsrH6HWEIl8gH0X02dzu0ra5ArBtrLb_QEo_S4-qFhSm9GowpDTS2bEHwDoKw1iHCn0b_P2iUxGedv2jfghi4fJ3MWUv0Xh-yoKBAAq1JhelB_A3qaUFUNbE8BwkVMOisSTP8v-ka69-lmkIu0sZ2kVg6-8xmPE_Lk6uy9W3KVy9F95516Drn9BQkDL4q0kI4VAhpt9oAlPooAEjMnqi1hBerI74rF9jzHNPG64bVG8jTt7-lZHKuzIQnhayWK65PgUUPF1joyi876zHehWvtkODrTlU5auPXIYNGYbfm4PzuRWg75QqNTV5jwy5SJOIoeHGKpc7EIp4g8SnC49xwVHvpG0bd1mPuIUkrkiDkNR8zHU6WyQCCrDr5vkvlGcMtG5TZwLwhG-CJBy3LmSgRUb2Q3SpmK_l3w7boFNo2Qaf_0cuf1MMTAM48m6PKPxHl9tdbuule9PUumfBDQlkcP5hegd0FPthazO1Nt-hVjQVpe6ZFAT294qGtPsi7B6ZxB-ajKqCjJi8pXC0vFAMAqRpWBFwRiBRo9CP6eydj9T29GbnQH--43uYAqlbGok-ZUwIPwb3uToXj56kD19E3Iop3TzovOHV50Z1q28wImosSVo3V4NYVVGIx5veoJeSgnpsNhTj663z12COqzjjaLsA5JbETL5vWB7mc3THnOo-SD8jhGdwNcryFJNx3M634l7HVAioe1V6sWKdJM9tMcW96_gw5ZkMqWp2O2Vi9oX5FuyFkryqzJDVhuoFjzlbgVJyOOTLDdmyY_NAxaW3Ed7h-vyH2omQCivPSoGWUCz38nMHP5ouhNyklvIHmCworoKQl6-qOiF0IRwZQkp8Dshdxc14-H4AGa2WsyeNGcvx5BOYNYAFcTavw9J8X-z3veS_UuNq7Mf4ZTiZnK__wn5rU-ZfxH-mWTcKFV9UIVww8zIFcuQpLyG9XqBQ6AUUpDvI2xpy1TD5qCmCiM5IrbydJ45Yt2Q-kfqE2lpK0ENoDs9jJInG9zSYVPBieTUtOsqhVjmHvqM8oJIOXWgkdJhSk9Kz_u6Ugm1lbv6gD1MPLbvPJ5-gs_3Uw6D9OMSJSs42GU372PHVS2nTQyqIeHAQA5mm8zHcvc1BDsrCMyCBvZbBLM5pg8l20f5cNZmJIpEVmqFznVcbGuyPopPBg26ienJ5HLaLGCxbOK0D-fyUgUU8JSkdSkyhf5_hqUl5GXRzY2D90hv_x-9NEcPPz9WG2u82MP6OozgPLDV9vUKBKUTmncAF7p94aVuU5LzeuBRwZepFNEMcofRAnTo3A3jF4_4GgaSErNFTeq-3MCtkFGfdKylrrool1CerCOM3JCJKzwTXO7Q9t4DiAaXbRDjgLyXZYX4AEDjQb5qsRAIhwhDqOhtEvj_KpY2PlikKBCpVoQxUZxVm5CKlbHMVlWCeJHqNiKE0mCkFOijDrmv45YZyqEDRQwi7ag0qz0blCKtksuCVsrSykAiByUenIKn5Wmkf6BP5fofdKhXQPz-iSRcuVouTabtxQj1CPkC6MgQD7ptM5fUm8ZxFE-LarrB9erwLZNATVSZ1GNrAwFP7vDY7thu4Su_O9RmRlKvQnxUFXhH47TXdFNb5lTBqn8u0Dglxn0Ruzg0mbWq6WKFGIuE4Um0XlFzEQKsLvMJah9DYiWwPpewQ9_-Zmg79yvlPESdjqoDbwPy9K2vLTulQpcUF5-muVshhRuXUngTLWBHq_YIn_n0MKJFwssVCyb4sWk3DlFjziYpIacPBYs1OfQwsQDGfWIJNLaYhqLrssbWJhOwOAW6iMPA9WFlbGbYFMq5QCxOR9thrdxNzu3EVycCzC6I-11EN5QgjIUZksVzDhol2XEjuddlfzYcZnIrQWQxX0BCeVLLr5qqKszYf57BXisaPHGcjlXYtpilJdvgQd7JM-IrUoJjo3ok6x9bZW_nON6KyCSySorHiODQXGBR0_Z0VUhU-o3Xa_8zlKu5AVhwCR--w0ojFWrO6DGgfIE-JnOHosB2LJxIYpsYoruDb_LDPUcf9FQdKwsJofbJVBxa-423PN3kmap13EBawe4C799ACCyB4fRZKXU64GgBj22nIgmGZT-ak-g1sDV0SS9DAvPrZe8DrzvpvOEbez-COEuEQvqB26WvU1Qv0aOa1g85orSKLhr-Tx6e8SoAn2N0yaMq3qTwEa4FpNtx8YNBJPjVFu-I2HcHyqqArtq0QduqSp455rJRkYiSGbjIKaYJhz8vy33ZWvS77tEioV3YSu-qAaD1pUpuC2Dv1p1Iv09BlrRl3ryGprKYldLrD-sJcgjf7LFdH7qznYYU4BgjAE5kBropL1mZaZtv5W5quOpMd86HxjslgnS9cxodfHLJBVA9lMfKGBZ2II-tv-rFxr4PPBdiveMxwrRm-MtZz9J6ArOfAMuDt2D1LC5yqPPv6aE1snnFjGjT8LMv9uT_oAorfqcmB17DVy0-DAY5BFIf9e5NfjtstQ4VRNGrwf-p0DpclsoPVYNXvin69epFPPQ9LUd_mkyjV3XcQqvxRkQoQqhhhEbNmVlOQEoqhtiNxZks2ohL3qmla48aUOIEAmMiXWuWxfdYxKYpbBtgGfzIKNQaqXiUiqbhldDQ17rGFA7vrE0HPS7PX3lfzWDDJJFtKfqwtldEPqEe6b31M2EUgy6E2Gaya7YVYEmyeXkrPo5eqy2JeJJAGc2qyFUbICavCKoKKi2A8z7CQm_RX6Nuz9dENmCMg09RHi-ZEeEIEGOr8-2dq3zARmr_vw0YiCcCDrStWXHO5s1UW3M8G6h9f5UU01iGkW5SOz0aJmrW_SsEZBUN5z-dHyRp5On2OHt_T0VMPfoj_i4E6evPH7ictt9UBINYQhhmGPxlIMdPDsq3k1KmXP8LF2_3U1yIHSbM5UYWX6w9QdgYWWVSQT1mTVHn6lL-9yDcwo92NHB_cDrjTZ0EgYGE9uBINDCVr16yvfAMmYE6Xndu5jqW_tR1eai001TgZ4BCf1J9rHJc98uE4c6XJG6E9s0HNSB7PPafdzkHoqCytNQT3jyhOxfFdF1OZsjl6o88brnKKZLcGWh4oJyZi6wfdCzalJF5cQDNDYWGkRL5IwyDmREu07ckxbg1BYCKv8XS-Csw3_Re5lY3CnutmXe47kz9OoWyHWj0TWpN8g39iFvB5FDBPqsNeOVGMD7d6o-10JRqvB8avARwD_w4p2CpyRRPjo8ibCEiDm6bK39c1iKvYxuWCpz0h0M7fbD3Raf0bDdGFHqfhkK1upDOaoxh18R8IW9XqnfWbpseHg6OqfAv-GUkZKz7Axle83yr3aJINFuT8f9LPZb76PXiq4TpgPq5oWD49rZlVGvdiBTEGS5wJ8iSp8xQpwEyF1Lk8iAMOvC3D6aDnZHjdIyMiM_d-LQvW85RrBRAEhzV8c3bLCkgnn2DSgRNGC94AGz5JqoKOfA99-IBnx9O2e-nZSIUTnj3LhL4v22LdoFp-WaohSuH7dDGWeVuWbJV06AbuLdKMUj16vketjZhVgOn2lCr7LRnz-_ll9C404LQrM9O6_LYbAAhCrFOZww8-AQA5jcIIEqn_RkhI4wMXF4cMH0jSA8ZAtgMpqrWmUegEtbo7sluyvmD0c7BzNAA4AYD6juG3huN5Jam9Kt99K06KYrvWGf2ptBM_0Fb2ODKve7w5kaCCTdtWukCLBrX1OAdiidAV-gwSxyp7Y8e0wTVwE8JrhANWttDtcZ1E4zPq6eN42laR8ISz-ZuCChdvXoClVqjAj5kqsqqplJCJztNgQfzaIja5gMOB30OtCDY7IOj7BH5KqGvGo3bT5oIRgFEqHsNYov-5MJQ4oV8K8SGF3tZQeq6Pz5LY68GKzuP-2s5yPP-TK8S9l6th4X2Khix0TVck8w1cNX-bXg5DqaIg8TjcccTbn5X8s5bCrzvjKQd1hucEVBgjDJlzTyi5wOLiPG7XMgjsQ8Sw2frxN_xGMKXtXHR-kv00teMz6JSJd_HgE8I_HryaBXwfwHspM7bY-DL7TU-nIjb1dnzhDD1q6GjlXo53uJ_VD4iCp6v_A6LswmHMMLUeJgD5Jc_9dkr6rNtagGoDYXR6so-O0bOEBY13bKHiEf3c2OVUYm0SgQJ4mki-2cNXLDtl5IlyOps_4MaHrv-ecPNqgtr1Sim-VW8mEDm2EwA8OdSHnhczJv_JCHbj1P2GL_L75FN4O1zZun_zEWhIz7vJD2CAYPx3lm-lfHq7MX--nZ8dK6dT1aKK1D-3TL_JwVZXGWP97mbLYYgiRFh4bWGOQoMlLheWjFTIdQUJpqURvzw-Ql8SxHGFsjtw117Dc8qUYGHX-nBXm2LnO0Dbgp4f6z-t0WM0zoi3acbsWfHprV_Pf9IqJ-WrtaAoNLfk1WmFL7cYQUdsW7NnGUwrTtRMb5UcuPlCR2PwjEyTluFYdYfyDYHvRUN73xrHaZWG1F--m6_seJpAKhEzkctZL1eRDuNMLYFEbIEURq163MLJl2jpV72oE9OeHMpnGxAhgoSpltagxIStLNPn371wj9mVrTRXzV2dfqMHH_frklIv4DBCSzlTGAejFYsxVajnZiBJg7j_C1Kn9GCCYLD8V594L1TCAJJpcyqW8kULmY2dABlKCuFcfqz_IRyeKiB7zcllNhohHiyXZHaU9PFFkQWdAnLPUUhkHrzQ8R6nC4KCDWGp2dcL7_E3CTMbFg-jd8_bzuC3EXR-BQZ7jOwC5YXCqKnUvo4uSeUYD4XyuyhprmxYYyZCQk64XQQtNbmYGvVjoHQB9KPs086OWsqgWNF9EVG5IL8hTv5-X9qAHPfrf-nxB_7FjHIuJY3TgfBeVaB3JRrgynQfRRsWOJSelGAVBm4xuNE-AjEJFpeOT8fIWTTvS-u6lBqiVy_w2lDnC0PsImNe5RjQ6ej0A19OYY0XVLd7l_SL73SNGoGA3QOeg9V1tMAd8jkXrXsmYjHyNXMM9G6lByNVfzIUWZoN-KV2ffGGBOnBqXV70Z9zqLZT_lpdjiePP0Q965ggG4HJg9cQmdUssq97BaW3X82N1gcAernQcdC_tkvtUkIcXe3NRys_t8CLt09hK3XBPQPY8PvAnj6x_dYFEGLCDkp-O0zu7ryE9g8BDu0y7E1ZbyyM6GnpXEr17wRixPMQNtY35DBWDzOMK1NNZxCEHcGnuLCsSURvanMWaAFAyP-a0YyvW6S_bHnm-We_4sCpBpGR1prewrotRliiOqGkMFiOkD3zlQIF8XPKC0FsG3LR38LNlctFf4K5ikeKdei5MC5cJu90TIgXgGsYguISdkCZmMK2Vhm8j2h3xKRB6-XixA_JzOpHEgqtOVaSghSq7FG2kH7xX__F_x5sajHEBnZJorrxn4hMzP6M48mhqOZ7DV2JDUZfF6r2AkcrRJNdjtu6gwtpJd_vCteVb64uCKxDPjFpyL4l5TOlk4yDHB5e7RCjuAIXcJc2W8ZT1Q9YzhGhQg9YuiUEmDvE4uEOt5_BtIccWb05U4ihyfcmBwxwZWJigtH5advKqvgB7l06UYr9NkSU4AEENRMOM_oeA1A9YJKaIxu4uxdK3uO9QjkQm6azvayiDVyfeRrSRACvI8K9I1J3jRkAxhqnSVifeb6RVH-nvxuSX4iFyIehGk_uqcfhpBXOnBbRDxJKxHGysOpaXnaW-sqe3zmgZEolbH1e9jX6czwuCsrKhm7LWtsk53YExi50GVCqfpTLNUsD9uHRalG4uH6jvJcmPnuqfHusINb9GboZ4-uxS6CVNBC58yaGpBWCkjZBgnzlByvU9PJh46ioMRsH0KLEQkHIy9Xadukwe9TgsW_B3_gA52w6UTOaNUcBZrb-BCVo6YHf7Rul3NJNQ6JONryQhilK_J2dS_fai5C6tuIzkJnmpQ7Gr6t7WC4a2n1KBrebuLFRgLzrJmSW7NO08pTCA0t4kOFyHDQ5fMkizMwZjFQJsumkbVgC6p43jWttjsS25YWJCbht6i211Oze9Sh8CDoOEStsWa_SGfUh_-JtjQ4JqY2LBu3HW1TJCEpAKWKWK6kKp5EYWXrWApVodQp51Yq21xyR5nitOQuDWE_2NWRCdbWx8QwXQEgttjaxC1xZoSrswgMz0PQuqq4DMnqrALnmlYQeaz7_AtCL-y0D-c2p685Rc_TpWqKuRC0fSplBVBAfrkIF4UjEVsiko5jWYyEAdBFXqtxxzCjC--mciMy8agaC9ifvxynQ4YBc3vpUyt6xFkOOStMxG1Q2rEKIkBXys2UkEGMJTfPxhgn0RAfruRQjru9i-1GmP_NQqawnICNiDKreeViZhUIfnEdrT3vrRyu5-sK4ct-SbxqjcZ_Ey255R4szSIbUx4yA1aAOJf23Y9GrjTjsNzBlqULHwp7Nh5FJg0PHSlcqMEZyuM-cbdwWgERY9IRcl2gxCpi4-4YDUKgmRRqPLs5lEjcEonvxP0ofchfw8_mKNgZCsOMc05H6GybB9Wx02OVMHF5R8T23WUm8vyeGW-M7_pmQaPwsEaFritlMUfYD1665AsRP0tX3ieS8WYKeO0-A8QPJ-L-NYWRZ58nZs1cGWzOUITqU57djf1NMX2H4TEZbCDnEP80jDdxFeA3y0ZAu803gUlNtYcZvQHJ4s6h2qbMup6nd1YxqRZtJFxvJEJNQcK47XvT_VELUI2nWiD0YCJ3jWeUc0c8lqbukhrTMVHa-_RkV4zCNG8FnJRXeGzv9E9vjk_8jOqw-k9yQAgPqnZmvYM3u9_Hq_KdeljGMv8QOUfr3KO97j5AryZ657_6Vhx72lgwoFkokLhjofpqxZG7k3Er3_OZXr17SWtD9BRrNpd0lL3vZXQx5pqTT9-mjvWl0Y1uz_IEMBLzHsgp0HHDxrAqHeHCDlvAk3zosLLOEms5deIni_VP8fSK3c_koPAWHjPI16TRrC7ZQI4tsc3XAWZblBsLJaxbzzVUt1zNFd7HPBYbaJ80GNAwADl_IksD4noBjbY7Z8HPueHb7eVWxhHKyZR44hydmuMOeYGN7N9FsbTLsjJ3egAqANXLveMvlKBsqimT6kBWzp-sspTWtq57CZ46-wnhck-ZqNisi0eDupAfZZLbftNuMMgphCOD8tKcPQwSPSmathHRBSxWFpanT5U8r_O_-dAem7qiIH2ymBDo1pMN-zypqJBp4es0MHpCU770iR3EgX8hbGTHn6DwqGQ26m6esHwal_qF7z3y4Mn4V6a3cQa7xahu_pOyg0n1Byt5_RnCgllBqFV2bu4jNjeSGsP_OeFFRyJnRAMUkvEkThj3jjK9Sa-bG_FVBxsciM-PrEfeM5JUOTxSDfPDcmHMHD9o5EQOBIsx3elUxTna7uUL-HP8AIJK0DPHpIKEbnwQa15ZRJ21VWXR8vfM1KApshjN2YK4gGMEA5nKTJM_wE-cz79UUKhuMqSKWGANlsDZBQbJt04-ZYQaARD9L5sIyG8Dw-BsqSnfLorskoP_B8O-7DnBW7jGVQhJ5dijkhoSENKPPOlO_Q4nXvh7fAY8xO03ACmlLk-XMsW4BXbl51v2zrle96CcmQ4Kiu7ypvK75_0KGIIcX3zFbDczOXU0kZbDqkS-3NCJldVC5cK3ArlmDt2289mGDQPD-MhGP5of5JKVSwawneTFxugcU_2hN_BgXPEI-Q8Os9FxEeNWJiqPCdaOS_k5MaR_pyI-VqxvXnT2Z5w_X5nyOzNM_gzylYbkEZAnR2H3n8oykRK08oLe9GjeTl0bvPrjyeRLHvFyCtlY7NjORM_53ZR6-yvHTcLPNeZVs83dZlAoQN7zR2sOIfy_bjmi0O_CT8aziU0ogVzXrZinQmRRMjx8L7hS_ycLNV9u_q_kHc8BxBNOP6aiTbUxpi25iUag4xtwWx8O8WIhpPAJ39OQL42DRFO_-71uCcu2AdedEneSAzNuzHrTMVijUL24O4eiNk50vUYHweHl2zuehD6VJpKt4rsvEjUITzikZTTi22fzVhzkh74y-Nl1iuk-E2KzH4NSSiOn2TfVYr96-sAiqsNFROiq9ozoO85cIqvlq8H8pI1oJ5vkG2CZZT93XaCtFXkCnHxmDRHkjbKS17NQAv_-0wZ-AhePBOwS2buWngSgS7LlhOUn_H7qGvGCU2W97_VbrOkMEsSUbYg_oVMx_TR8AW-6EDTfg2T_d_j5QWqm4oz4CaT0i1VOZli9rsFn2ejAz9KjzzgjazXwXVjpQZgub4Z-lhbkk_XqSAYN7k6zMGjlLoQu6foER1oKr4wFHYpZ-G5S9J2uMtqeKtHYbpBeOyLSVfOMPKWVx72toSl6VoMa1XV1A-aIA_EDfutRyIcJud9ut3robHX7MGKdp9g9us4KwZ5xGEDvjbAr11Q81vFQYiqo43FbGJffi4C1kA_y9_R7PbVF4Yf0llTVJCZWJ5obVfRBfzh9s6kkTknSz4sWytIK2WERJcs9s2OuPwlVGoFoZQiQs8rESLGi6QqA3kVkJvkqh1Y0Zu8AHYy_e3etoVKgUJW5bKYNy1nL0iUi9HTdxxRe4gKN6vxah-tnDRUk3r-7VBbiv9JVmfXgiAxlFUSpxbl_Y9_p3JDLoJ90HIG8Q32wcPRaKj2r1Rv1hPa8Xz-mAMcFdDyDd1scq3VQWN9ADUR5tvo5RywuzGDpI-FUJKEWxpFZoPqhhhCopysKglL9mAJr7aA_gDMzpXhlqo4Xp_pVqOpn-n4ECOfApgpNT2ShNMWO75wpMsszDQ5slMJ03Mc1SbM-GL1CQ7yRcbu-0yAsKUbwPGtsh-ZtI6UP84qsQFpgCrR1-uchQ-9Ysi3VhAZ1iBJkxai_FAI1LwijtK_RiM7yN4fL2X5j1yxZkEy9d6OZhXD0ohDw7tRYbFYIGJ2-9VaR6cnxytOgK875hLk-tuobzGHIeE3gagkbG7oMMJ4dJ9fr-zqH2RCiUKdqHi4VwioVdb3huc3dPtzQZh7dfEBSftSoAOTeelUR0c8hrcyfZ9nEYJPkAkVqfehl2CaXI8EN_n1c5UunwBcdpAQB3x7HtBy2vZ4w1XefaXfLMo_GPmX3aVh88wV9YfALy2HFQbCkYk2FYuxdien9cHfkzij6vu7Oar3u0nhRIzunRQ2NRJud_JgHUh2YSVemWXPXqNJxwCi29RjCr9spC8HoiOCb09PJUfUFtAT0mRZUR_sKf86ZbZ_HfPXTeEgUYMeHABLrKFImTc0dgDpRI3vk5C0OKIxJ-fT4kRXhgRB6x3knrqbe95Z4GVKQ6WcP55XJANsDHGzfHYjCL_RX7grYzWzkD8HffdZPmqcdBUJcRL3WKXaCau2Po3NQBM0U3HMPoN3I9UkISqQnBOQYW77F855ckeQt6_V93eyYQEbCqOs4Mlknm5ki_uWvk1JmJqtwogODo3P5HuvqVeT14kEV6sPMIo8GsODtKpvbPMCdVwp3C5Q_Tn68aWlSI5QaxJFeF6rp3WvpnzxLmCQ3KyMQNh_1vxqge9TYoHZtwhyOvIFGg6-n0vJxfTgYODKjFEurrNBAm8HdaUfKNrPunVe4N4BqQMNPhtZ5hDxngqTLtX62iNIX1l2FYi6itZPBMQJyi3M9Cqjh9MmhpYAqxl93r4cz-pyf2MZWVciCSecqbilJj_eLF2hNUqPhEnjAanxmPuPgNFBIFVatfUUPcQYke8qtehFFfslKcv6QAcAGbdoxE2BAr4cRlnvmxleTdCB3FUw5E4yofb_jI5SFP9HxjGsgz_Iu4LgX_JniLQmznApM5qGFFd8JUqoIECfTfiaM78bD3hlLIhO5hrAB25MC2UrfrXIdvLLfF2W18yRPS-KSF5u3MWrT0OaEqphT0U4T29_7-mFGlCPCoo5XNfdJg3bS4U4FiVz6zCpjwECXFrI4J0H-uJxftRSS-8F7Ay-83Hcg_9ph_ggvh-LSAI7QT7TsiOeyOPKytBt4i42u7_LmJOUtWE3i4aF_CBQNhrKv54LUwWSgc66UJMX67B72oVoSPpLH5FI7MSKcQMCu1lhYLW7F4zb2V3_NlQgXGmZAn5eIXm9La_InzhuEHM8nLd7-6BYXmJnQaeFscTb1o1ENEvfyxLPZUn3h6LP5JykdZxtdktLVIKh90Izf2TvyfC8YKtmIhGdMchVqqUxDwmNjueqb_7pOHil1HWP7HeOugf9YxmZL9OUq4H9gdwJsXjFMveeS1O867NLT6SzEBiJsPUJFFTI6LFl9V_ZWN77G4J5VBGMhWL6b5PeegB2q646NaMOI9s0u2-gE8aPOs2RW7BNO4W1kC3gEvf5m9n6hj1GnhWhggHdtOH7HhtFgXlG--FEuf-8yF8QIx0qiWMwErKWFjFWrRbpLDASYbkwtzcYrx8anqbR9YgswJoUGL2El2tZNBaf4TLYvPqRTAO3SyjKTsUKNSl2ccmJa008VL8ZNyAsM2qCr80yx8rJ6psCU7NpyB-ScPT4AWacKKE5qC1iOO1U2vWSxJLQb0dojejXrI8UX5DqYljH3cpkbg92S8qzF8h3txMVQVNX_qbCe-zOA1YaRaz4e3dc6JFEHrIH6dQBIILTsrlfM8uDeaflErF4SX__ByLQyDd6vOLoSg00nU0pVrC_wC9u6v-v6bpdJLMOsaPuY6_e4m2K4PoL0KAeIwVh7-APXizr0zSRQl-fZ9kXDODutlVkKg8EkFa3bH4Gq_XAO16EfRUGc26C_mI85tGe19WyzDX9hFkLYOgpK_odmSkQAG3c6H1CVM4-_3VliAE7_3gJzwdS0Fekej0XCeZKkvqVyniKfKu8vB-MLrVJX6RZVCze5AEWhni0Uf4nRindpxuK5rfCXHOZmcq2HQ2-VG_2X2_a-w2acNi7zxq491E2CxRenHxU1r1Y9nJlzXoktpNZ3Ps602brngulxP4JnJeDA6xrTewcOguTJocqgGghgpkgtRwtM564yIrODqTn6UBsBbkn8kQCjMkKux5vIRzuDuexkbnd68xtwIqBOK8oz84GFF5SjmtKTS2hejZVp2mF-xRsPe97YW0huftK5h6qJqSEgPSv-d6wtkdX9ciNv71csFRqdUhWFOsdFvXO_NgjvTbiVSvFx7gXAh92QAforSigxXrS9YIHh3YaA9PBDxirmtfM_NzM_6ztlhozr9ZW6n_aZYEw8hedUociUM5Pv-PfzMpuShWKxZ_1jxpkNxVgbc8N2gqxn1TlkZof4sHUw9oeOP3NTHOz-OCun6YO5ZAPtn5J-mHlQ2IGN1w1dLo2TzKNRTOQHNcQr2UPgmZxCl6OMz7DCz0Ftm0b_fRkV-6nHchNaofmr5dVJhi89JY1-W8x0jeR2tlvHZy_r2K_R5lxz-kCq118A-j4MSzpuR2euKzITmeLE8jAC5mfT5Rs_wHlkMpXN5AXN8ErD9WuOqUdT37Z97_DZXAlY9rOIk7-TfYYLV2qdU4cH6fviE3HM_7tTui8nDLsYUqOwKpI1ud8za-q4RaPOeT2LUJZLgaNv28qNSiWXmmxtVZ6WkQaUHEE-nmKvwruAedfCvKigBgYe-UDge6AgWjX-gek4fHODyOKFu4eMTZ1rPMv1XXqz8z43pmqhw-6HNR84QZSDRErgmEjSQSWLNM1v31W8ZW9YdECJlbLnFdfk3Qfe2-C1KW2ufwMxriUDkfylTV-AsRvtIqOEvAfOKk5CdfBT7jOsZr4Sbp3089Y8f3CILUmubvHLll5G6TNikj6S9AV5Dvf5NMUIWEc54fYrwFRQs5kUBxo2C0WETon1JvQszXcO9GuNMqk9gLAmIuJ1kRUDejcweoM9WOID8V-bwbeUzQq4OdY_XqqH6R54M9zwdVIZOeVfeHKMtP_mzf3QKVUts1PYjmWhAOE92q5U8p_oJlfOxfltUSQiDmCjNvms5d4CaMFICl_CGTWNiCx_Ho5DXFYoZQmsiRLAF2spbiZGYv_5ZGjd5rA8IjbQwzND3BGJdzfwpdXNL_7h4nUOCWI0T4W7Ogdi_kXWxOr7xVkMoI8mizosbIhi67qF9KmO7biX2CCIENEVs5IZ4sXorbupqCqwRZx4xyNccxcyhAj4-9rSRszRK3o1Mjvg13jEjHmQAaK1nkCwbJpMo15HxqX8-5PqGVFtlGj-t2M2jWSl4aqIt7f7YdpeNFGc0tiNykDS5CozI7SKI4ZoL5KpHNMCGCfco1yJyRGXqC-IXbgfs27Q4PdfcIHh9H0m2sZ4zOLiW4M062OEkrU89TDFyDxBtTTSAV7XZfW50ygiGbPLv1ZBhK2o8smahVbfSYh7DtZreKue8jFLijVqFTLQqomBN6EyLkibrpKJbnaN-_Ae-G-u9zAxycDwE3Dy4NHlP_i6-l-WBeAjLO_nTpx9wXPtR5Ku4UjLUzOOV-N99NyrlLHDFlLTJd0oGI3Ir-xpKi0ZNILk71PSFbpPqaa5QTHaHmZ6T_XA6b-ZF9fRB4sK7fgW0OFL94Q3dlwJM43RJkdjZfG-NPwtpl3wZoAK9-ihR8eDuGnSbbepYEnlkhMfu_iaomNr4sW-TEDCFKxKj9tyHLnYYueenbUD7V2yUay4wwkuAFqhHdi3dvyu_yp8717bksevngtq19GGJCL1gXVg6Ye__fwUIyyyghzrB2CtJfYJnYa6u5z-uyWTSMXOjFeo80p6wJ_LyAlN95ENf0yA12EtDUSA_bjyQYuwzqEyDvEtqy6hTTpXr9M2VUGlA3Ax-ZDM8LiePD2Zf2skLcEfElBHrfBId7xCwrpXSprDhqs9WdkbxzP8Zxe3qMaQpCG_Dy3Xbw3REXOWHbmvJ2Xm76o5JkASUST9ZrS81TibwMsaGEsslb2fTXx8K3Hp77I5AKuhtpnGh493HZc1t7msiDbefofpPzHLrb3uumnjq1PwWzJaLoQFUzr3mwwaNyUyA1erxixvHfDRrjudFvOqB4z3OE0H3Glsp5ivVncaKDq96bOW6km7dvzcdSBjofcd8QHh1QekIfmQeJyvnsIw9g_HHiwvX0X34g00HniD_ulP20STA8G7fNU_gUKS5FLYacD2e2mtTRkp7SnF_n-IsGOkTAb5ZvOQVqIN3VlghydZhwjmf87S1sJ3wbVpWDBvtfhQ3froddNiUr3MGevk9E2twNjBiU-8SPzNoyJ9-HbMjPX3hfWamLKAAtnzYWAJ3RB-knmobYTjItdSAIXyl7i7LdNQRTCOntj-KIJn5mcsGBuTu-DjbqM6bxUG1A56c6JLrlqkDrAy7iDuch7kT-jg61xT4iZwOjU_LTgJkQelCNsvoIvoFOBDhmLyUcgq5asB6RlHgGyzAn9adK6pc1vcjUWYyocary7RINzr3IeXNaHnNFo7gtpIovDcsMUS7YwwysR5Iv81x-a7ynTckzAgmXYxdwSzgQ592V9IDhAXA2KqUKWa9z5clPsyUsP2RC6D3UJgmkJlMipV26Z-Hbzm1AYnvR6B7hdqwJZVmPivv79UHQXOZSmEFSx8phsQaEyVJwGGKB7r0xGqbKRcfO_lieR3373nbNJPSL0ku-0mMNoiB5hNbqpw5N0kyjqgsGf7JNkF3Hh7tQxvJVIIMorUJ4_PT0wf74X2DwyBu6LllcKVYeu2w6wm1IWciSo2MIODdOMqEdlzAqvZQaWmJdiqAuS-UUAXqieEjAS96sWj1uDLByFzKOFe9zc2znkAlxhts2Wyoei6f8tdnIH8CymSVkZyUpBKx45qy60JNn4MEzgItV8t2pPQDYltW2slsQlasnfjic85NEoHJ1OH8Ji_eaVCOxLAWFwvWKL-UOtjcs2BcWFN8wLKCDqEkdxZSkx5Zl51aFAdO1QjoTbN8wjZv9_EoHerMsETsT8vS0MJFTaG_M5cUNX8GshmRTde5G8VZFxytbqP9i17uIKeFki0fgIEnQnJU1b5SPboovwsCAPGOP-ORKlfQxMgM4vdgppCqgSjqiOKvNHlCLzFwClMVBYovZuZafKhtu5u55Nebccp5gtiCv8KazPyPB_D1LKbA5Y_m7iJVw3GKsfHvvYuEsz5jwpCW0kloWmQ1k4ZYcSQ8Hzl4R6_MpRGSvhWPuS03H6TLe8xvKQPOwUFULkWZFRFXjCeUJtyiFj78TC_qEpbg8hssEBTVt8wf_z0PapWqU-XSrx-jnj7UC4m1DJqkPck3zEm-W-2La1cw9alrAm_BqphQz4otDIgXTWrXDX814F6ZP6j8AVdTMlF4y5-n9mCz_xRcoaR3onQwXoaVv8PqZi6LBSMO-EUIgTQOrF6gcN8tiEmxhly0HBTlPVFc0e8famVay5ZEn-6y87saGytCIqvw0E7r8lQAgrjyOlrpnpXk9cHoA9fEh1HNgxu_8XuUHvA1Vam4X38ItrUxoiHs7DaqR1Tu2yz8LbCoCsG3CLva9zc44t4UgzSH5S-ngk89O2Mr0yTF5FrJUaBevAaFPcZ-Trcs_eMG7fMs2knHmNxtlgM_9-Rn3Of02l-ixBSHDG-1ffeN3xKPtJ2_Dliz3ooM1LnHV6clZ0vT9-l-fWli3Zn7i1wxiaVAoPGjyzUB1PV_LRmtZHe0UO9aaEM4__ZtGzYP6pxXEtwcTRPz9yFh7-2lKxs1gfpjyXNj_Nw_PvAzKmDXwFmxVydX-vOVuz1NyUIXOuNOsrC0ziprumxmhttOX5b7JiqITm5jFSe9LhtMp1CWuB4_NXuSbjz2XaFLk9bjeCAYIKOVR8LyPlgTJQSof-rlgRd9BGiJ2EJBHMwx7RWv_8NtJDmovanUltBHhGghqecS1O2MvTDrkHue8eym2ulXhxCl7ZBGewweFrT_NtDl95Pe_JpknVy53AsYqFDgQwVEomBg6SvULXYv0D2EkGKruMhhxgXMcrTSbV8j0oDmzWNQKPUXf95_c4AUVAb9YcD3TSUDvIERPX-TcD0LoY0MgTt93FFGkw8tH_Bo613yMYRwmrBcvFc2FcxSwOB7nlea3UD7Y7NEqj-7SjJiXOrVwvAMb-FnKaSlH4QH6ONg6Qtr2GMIdvuU6Y-oFgI-Tf03-9cFzwVK5QdtqYV9K-asPolU6ZJ4s-mFu62parRV-JuwzwkJJQXBD8lcFyvX1RcLZwyQ__PpQIoAYHfp9CTw9kDr58wX5PJBjUTRlSFciWVJL4-bHwT5TEYUdh07hfEbSs7lDjexi5V1LOG1kQEAlZm0eA6pO-r3dydS5YY09unpA-lBRgHXQK78mp1U139Ub96g7YdMvi4HmCciOsIjyZyl5DjljNUJzG82pfQlQAinE2v3wwFQaRDpCgUAW2JMegH1CQe2oMW6azZP4v_sjHQdE0j7EM65Ek5N0DyyQXaWp3Kc_agSSsgvLpv2tSZLvuLfvBdROhvK73mcJ2jJSpmYQX2bmmfFph_zQOvjhhaJ08dQqmiRK4I9cJtnhDteEZ8saYtEytucEV_rTaPTyPkbPPNMXE3lni7GgbCVaCacRH3fdAYh9bRB6ZLiIGXqPpuwWN5-j4X5ZGtZG_m78yMiGXeOxiQAw0XrYq6S3CoonrOX9Nqm1NGQD08SsBV0n5BiBGezGcdgMuBifPM86BTZp5AZCX7prDw3Fptw0YlOnUpr104yctpswD0usy6qfIF-w0vb28lxMlDqV2aB4lt0t1yQRKKw0FawrskUnmYZ9ubUDWkfwsAvfarAb1lWA1rRC7x7yVsOp2cRW-3S5CRSlU90RGd9xfq2myr7dxks6i4qMXu4Wz_tjGkpDCbL-1xWX9wvr2lVcJoFGT5dtJDCiYYc-iB_oN1qaM2fQaixbyA9TYX0NPqjyNMjBtLVBkMo5vgjTbyp0RCL7udEgNxRC4Cy36hF7RCZA0bNUtqy8wKJfwSaZdHWhe-9FL7NpyCugCDl1GZ9zfnCFp_G289S8L9eFDcucKEfzVos2cwcv0UcPxVxVkuWc3mntX-29ovnVM9-s1HQ4mWccDZXgSOsK1bn2UfM6cunkvbZ_TEVOXav9y7-HTbIo26L5sENLM8IEttR0nAm0MKeGZ9FP8ELujdCsggKSYm4RNf8U6G4csyN7-45y_bhTKs6uFw3cW8yPrE2_PmMqnkf8J8sVv-P81yP-KV3nckEQpSmv1ZeGa3d2IlMA1oyZZsrDxejVfe1AWzyy4dni9PGkdmUnOv1GPxCjkCvh320I2025yK2BxStMi1K7T2_KuD__ovvtdP5NJw3PlwE04zO_L7mIiuMujtZXvMFyWrvQrNfiguppD1yrNjPCJ956ZDcCz9e7OXwF8Zl1o74pajAtnGB3xshkh_lu1YaqsuxMx1Y6yfkf7lRZzhGXVyft1xYqoodwtKCLk4B-S9opXnrFKBGvKf1MpkAkQWytD5cS8Kt93hjGQpKDSYI-fT2kYFtlVVRcp5Q6v-CjFMl8cn1lXPEnES-yMnUmFm30W4ZyxsAp7kx7E17mbqVN2f4lvifGYjLvQoEkUARlKpS66RHRrVxVn9OA2kRipDOr8HrkARmRhLTVMSP6Mf-CsjhlJbZFZasvPiphjlbQ1xdMZXz1R2nOgDzPR-Ig44LYrF9Px4YzHNuZ97aU5ksrZAwZ43rJMMaKPR0nJihNC0-bgaUu0xY7DMy8rer5HQF18DtqTYSpW2BDb9VPMVvWstkl3Lq5ZFY59OItIgBjwdNoByGRm5iPk6-Q_eHn0Aysrgu4jNJZayPqIkpoq8-bnw9owyYIwLvozeYdxAUXb66Iedm5WbGBZBlqfKd-Y41CcabqJwrG2Bd4V29kgOU0_sa2r6PX1h4MONJg7nzBWVMJ1qs_XOJpP89rkdIFx3jGZ7cE3H-QZZ4lxQscdH7okjIza6IW4itEMQE1ODxrab2jfKPxyo4h4APb6J1tW4V-TMxxAag-Zx5tQuA96ELrOo93msQiXksW2iSBzA2NXEIPueU2Wilqk7y9gHZSGioBnBqnq1pJiMFRcDiLXMpTmAO8jNpZpUj5OrNy3rs8vGUpqbjl6fH8g8NN85zw6LPstrc_f6J4b4e9ki30HI8h2mgs4M3nHUen7C0mnWaz42PSoS4TIw40O9UuSK1PaVOEOCd2GXqA5tMEvvXnvOuwTbfzEBw8JtTyRMQIRkozxDmRtOBe2Ayl01hJM4v9VNEt8dpIcIwNXrMQGN8ja_gUYEnTz0Sk5YqO97AYCqzNmJ8vaRUeoyaECX0q41fuaEtPdq2qzAVEoqBm1ZHGx-g7H1SGw4sfH71iXRhHPurLAOjS4952GNkmMqAl_QRz3ARXiqk1-lAQFtkfWl1umMG0CdsXlwpScxnlsitd_xICqhh7iqb6z2Gu-QUcYHny5euSTnhTl0Q4X94CnEbb9EvOXiz68kDpDY_F9SI260-VTmX7zu7kr35lXreyhE3ERgOnOx2r1ywoLVTZL4VGSl45tfYo6IZuPmPoR51YTzWZ6vaxrlhMhICu0kI1RLBjbZQ4Ph2kC_BuaGy_K-PSHjlXFC-wYkFRTdFyHYo79dDvzrf9deEfeLCQ6BwFIWAgRC2EslCgiJ36M5Okv_tRyaCBZrDgYdUYj71qy8nFRQiyYen8nrOOCrQK9GNApkWXLPZnlPdVABb5Z5Af6ogiCCQ34yb2TP0TxavdkHP1kRUHx2gU8qmdVm6xxmF6rJhkFeV3iHaiBF1v1wkiGBo-w_9XvF2vOLXwEBOoUhkqTvk3d1D2hwY1kKT0zB68SSXR0C1nwDXvw6hmgpMfk8_JqcXFLxEulcGo9SYe1bpsmfbRttIOyUMSYCcH446Qk0f1c5K-VCQTYXi9QrgEw-QOBi8HxAVmSUvOcveQSuS76qpf_ZHLwwwICd42zYqvbySmqi44V02sDxWQrxTn-hJ14RoMmIfEBAW32XDODxhFJ3HnU8WTbLf8L5ugzi0Jri6t3z3EHz3J9NnHDgAJYWX-VzPVr47sOodY8QyTgnWZN6Dhy1eWxyZZOcREX2DNcIsTL0SCb44pbfyPuZ16zJ4CHVkCfu39y8qnjRip7MZG7_mCoDQF9K1fXesUaJgJZbUV-IYjwAXwFL-kH3rOYOdlwrxdSqK-wOdBaecNnkq37DfJZIvT4JlpJXezXbjd2dvPjlYD9BP8dHDCNjdCNnvIa1YG4jWIZ3v2FOQa-_sxkIjq0Ewp6tXd4P8DJCO05RgBnIws4Ln8EmQ_RraLFW-gP-021Za2MwEog6sCBaPtsdI8dFfNMNkkccxP8iFDpDV_aaPSfBSDL5QhhGwjK2SlnP76NoF-0NzimZiFhg0441VRr3Rw90cfcapnI5dtOeowgvkpCrrL10_k2VmvID-hxLV4hnMAuPF0bhcYmhR7W_J-VHs4MhXbOfuPI0gz0tgCGlrPrcPxl-HEs1FKJoP09Yi0yxav_dBwSnw26BfIoI2-NPtIHzBKlH_YOsTA28AgK_YMRygf9kik2Don3CBtqOzVzO3P-14ZtVGHm9fIIivAjRGcPWXGXMs0DQUrNXgAO9hBCo8Pw0X-XlXh6yU1iZnmiCHIMY4Q893EIJUAkOq6_1rbCv8SdhmdjoYk_Zul-Z012eaAsEyC2B48sGCB39F6saFJGnTOwOVUmhWuyee9-lSkz9vq_rJghzJHgH6-CJ8PmRSMkMYyExstahVLp6NKO6jsAIhWM2EZmpK9XwvnCWZygMoW9UW3M4e-qPw_vp8XwAWMxB4GU5lZVduG7-TjG1KpQa6M0FYVHaTQW2Fgsp9bPSkd9W3izmUzD8ChXeKCjpoKIilzxF78mCATuw0baBrlTPtiOXrUuMHPsvcMLMeX5zz7AT7h8Sj6akuRAIXOZYF1hwS7sWGvirU4xccAlVm6LSGJFcvhwz0-7tdQwgKEmn_PivQhkh1MQW-I_iSCCyz2MB70FfyFThfWLZRJ3z8JgXLSkfO2Rb7enbM0pkXch9TL-mrUozLqF2GEnKOPC2xqsDD0HJpbQUbiq-CxOm4-3Pz4-F8DJSyyFPoQKu45cV8ZDQUlhzOIMsqtkdY8k6Q3GrJi2FrvdO-4JX1z7HAyN0z-7A5sfyiOeXRNiZZuGAwkGgy3eHEVFxV1HyWRVnxU_kCq6FjGGf3itVHNJThY6yIXSyQ3KCe2Zdt6x_ChNC-t_rHlVqwiwkgKhq3Qtyg8NxF3QHfbCn3_GN8K4_IAHLNxiAFVJAKwTD_ES_gq7TEWeW1XcA8txI6WyK5F8jLsaPYGsx09fl-NY8waXvb9gz9XHiZ2IkYdhWYMt2Q3_jhMrHi7-jLQK5aK8WvAfZnD_awxeqRbZIfy5_J0YUedNOQ64sT70d2vqv90wXZHqT8YK5Nh32yu-_ZZ0l616lkc05Pa6OFN3K8pFlTSUPMSsXUGGbzMcZ4AN4aoNOk21p4RE78TUgZgNEOOVXQmWFGbty9w1jTZintuKBwoW2g_7avHb-c_9NXDImA5JfgWqchtIvNy7JLbL0LvJlwADaJAvEUhzWtA7HJHAUw6IQlAVhqGTcWRfweGNfFHkR6i4V360oOQl7NOgs9n_-8TnSe9zi0SoZAJoysvk-b9P-dYspDYmmq84QSX1GN0KAg3D0Til773LsigmHl5osrPdvFj-SaxNbdQyH1HQTTaXJ03_IQ3YYMOC1uWTbjsDVAaOn6g8qDuJZApioP2D_7JMb65iRNQVMrap_dr3MV47hNYGTfRizMWkeMTT5NKYJKj8OmOAvzFH2P_xsJO5_2sGYHE8A9OupxdDRXgrsXMiRKTWwkrS5edsDQj1RG1PhNVNzTBYcvfKeHbx0R2Jp7SPUR6ZTQueY6yNfB8gkVF0UwZRkBQderMxF8Obz2f9YzL6GJ42IhMQnXpnB-0gZQHuy0kAHNk0S0MRQ3ocUI-_vfriu26P8NwSSyHnev5yCO58tKIrdz4jIsuiEDNSyOls5M6SX-j-A26YMgnpYdkZVJINiFA1-x13u9U-w8EpKBUGcefCniGg8c1_DCVCf9uvakaLe3-eVCqW7WxQ1o4QrwzHFmXR7CXgdf_ojC-fp3hlgEMyu9TOh0-3EiMqei9BXgjkpmRzSDftlRDqXOb2clsRHHPG9kLWvQtTYTY268PYqmO9jN6C1I_Tpt60CoytCh16Y169_fpt4IuwlDRKpTfP945USqPey_sp1FaWEQXTnMhM78M89F4SDH_EM4PjB6vK7M0GrVrXC-hqI6fTx8emW1FM6KG9vY0aRGAY3L12LPiOVv59lj5HtadECmy5LCqiuMCaLnGtglCwJNMJhrfQtioBl-oMi7PKtG92wrvj83-f2QPKK2NxglHrwc1ZCZhbzWRP7WLt2V3BS5As9CZAH7opkT0p1dl5WYlA3PC0B1FYTHUayP_Fze3fOafyM3h2XI-6uDpT6RRmSUwM08aFHc1IYboSiEBLRrumd3qI63zETeEGRM4pMkVdfflGJz9I8iB26TCortqL7Ep984WRaHMOfxmPmGw1ofNYAkpNv0QmTwuJjWN9XxhqwI_gSYXzUK3gG-v2U0aN6kioMkEm2mJ9Pyc8I9clxddx6LJwPEdF9Bl8ry_p9ZSXY-xze4pgDILGhzrALReyn1V8RIiUaHLV4qyOEABFDHfPqYQ9fl468ghr_tzT8593tu5LR3kJB4SbkxjtbxyHmyPKFlNpRGs87Dn-Riwql_9Q0HJk9l-4P-NJN8Kyr7FnLDGCk_WJeGuFBgujsbfpp2YAf72UcHyFSyiIEbNT93CVy7rO-5ATF16f6kvcyUdWtMNPnamz8tVV5CPs5bs3BSUM7-Ozo7ML4JfnCzJhNf1MG5WMRiuXujvGSvRKTNAzpDL1GYsM69wyToWE0o49PuIubQWiWDd2u7216EWJ9LPkDB93ovBuRE1PdL8nYYp1vVByu5D6QRkeB9i0TDC3guDvc-LkdqvEs8dlRSNhbyvsJB-Y7Fwft_RDy0pbYo0tXVeZSmec0yVzac38G6QXVZBDk32M1UJh2VbJnY6FPLjQ_qr7Dvwp8SRnJBwcxLahnE5R_DuZZo6JU2Pqd7M_Jmt7O1YVI_ALOilOcHlNxgWwTL4uflWQvEW4FMPkMk-U2yh4grjsFtJhc8Go3wkA9D6lXDPJkqVWMozjterU1NvYA3EgzQv-phh24pzsK-ub0I9bmWVKJcaT-coXnJp8m7L8nYuAMcj590_bAldXCBNyEhQHjltAxG86-L0R8DNZavrkjRw8Kox-AYrcPSewqxnw7dbdDURcvyNVMpWtpd7KklcH3skuO-kEjakzWC21lxD9qfpu-QlZl9s0JaiGHrsXJuTilYd397Oc5bauoNlQSnmvMHeVgo13uLxdffkO6g1RvzihPy52Z4CnrUh5JxfrjduifISDNBb8djmEeF-NUCq4o3_KFfgvXlskTvuG5Fjw7R6eWvfcQZSiErQs4ic7USue-fr2DOPlXDgMVNiFe0B3Q-O-AI0gGntvLPsn-SpW0NzaiRMToP8peIlvKzXa1jucEqrcpn2uftFaZqUubFLSjxzNutaRcj13JTGaNqk00C8UwIy3zm-MkOZdRE-O_Kl2e4rgkyqgL0ZchW8YI9x5K5dX-0mtjlGAUqIjfqJybWk9JDaeQuFxLd635he-tCVETreqkUOg5LIxtiYkCwSFtOoKGOjK2mc0UXdcxo3_B11qnTEgg7gnYZ-zwFEjIkB63qAnL9--QejFOlMv9JDgjguvLcrSsMdqjDRrdZNpXRBGLDOlo1pffxu_-0s6vD_oJ5A3FQBxaicrccHVVsuSRFpE1ghZJaIhD2GQmp_s8cgfbZZVI-bPuHjwP_PZCuyWEvXUubFgIHjrrZlEvIt1fZ4X1kw4cyYEMW_oGKQDs6PP4M0TSGlUnBzaKcShdKYkhTW06F0bW-cT1aWXwxZWh--pOIzuLQHpJGU769G1zWR4QbvrkVdrl3qyLXBWWd9As89LkPfDcxo07VV6y2qSGoaQdy-GrbueOU2k2G9h0siZmE4deGTdEYODM21ydy7g8KH3kbHN9E1e4o3EyWB1mWYVRTAYgIWgjQefLCvt74ctyVhDEtGxS7plCjAlvky3gGCz2hgrW0dR1SDvVBgaAKcOvBPWSX6BWOIe3jix8PlRWGHeGCNmwtIooEzrbtjqB23fvEW1NYq-T1dPTvz67PNB3dv4Kik3cN7IECv5dCmuOTEwh5G6cKgbHmskQdzClP6m3xs3sygt9g5tcYAImfrewODsaGHg30hN5VbVfIX7uHFdGIo_XT-_CngabvGMl5VLJ_EaR7e2jPNtIpeIg_aRmx4bt_M3N2PnGqReMnrLV00oST_R-cuPjYaXt17kpTfyFXu57NMgFJfXknPrHRuedwnZh-O3gs5C3SATFegHLpt5lgwPNntr81vA-pxAuRl2Pjenp2DPCQ6zPWfKIopPBT9cx8h1j3cCwx2MSMF88ssw6CmGdJZ5aU3M8UJ08izD9yxB97vqscvZXW1jGJVbz4zVoD4crhFVLqrA2NXR110ssBWypBw6_rGaJcxZAKvSTMhaJn2Cq5XISR_U8_EdSra_bNcTeB-v-NtyjNsskiPnyzhUgBb0yop5OuLgl1mm_9Y_vUU7kNbEhJB-d_ORFFZpjoWENpdToO3790gUG1WIMuYSSESqLylqJJOeA-9UlqiuUjB2pXlntb5A1asePfpbPUKSorAWKHjlxsRCnR9wC6wmtHeU3PuMuZt4CiEF-9J2yhPgbDv2ec6Em6AQja9hwZARVg6RPzW_4jHsBHKJGj5AtTit7IU6J0xLqV3z_oA7BMW-pJFnTCnkipfBoQ3YasGocAC-nGotpe2AnelOUYPzGG61tyF9M7Vu1aO-V3V9OcFubdxaCi9B8VN8El-8hfdb8-VTzZ8I0qlEjNZs-E51bjsW2sfDUjFKBDDiL1R93BohcuiaPZBIhiAIYXLqvWTatLy2u4fX1JUURQIAAju8eatSmahxuBOKWF3kcPeKmvxQw8bmqu9oz9g4u4X1D_g7n10eD5_0m6UBPfsq-HqsQBR203JwfEkqa4JvB75CEMYPxuoaqD0x3umy1KvAq-toQhqi8BtZvxu8ONAFyb6_qHByMWGDYL38cVjW3J0uZRsRSJ8hfCApMx37RwK3uiQppW8eUAvoI0Sy2zv7-s8VRXIQHrw6zsHIr8_UM8GzDDqszYIh54XDJj1JRbBtVZZ21RbXtmEcNuDWVPEDX7anacT13sLLf8hycIgZaRsNtF22e6x4pruWTQM85PQChbBRA7jkYp_FD8JHtwQguvk3AT3ZoX0AHFtXidBuEbSuZTCizhJnz8SzKZHzTZx-jGO6SCRZcpb5ZIr727iTauey4pUhMtEmg_RV77wqIzw90-jQQExu8S5RayvRH55AzbVr4kkFlnZDiZ9HZyiDvvdZZ40DUEO_Cj7iw1FSVvIdReG9CD2DR7MVITFL4ig1qMmpvrI3k7E5UQchzL7uyJPYrvGIs0jtSvoHe_VF_gndyJ5h3aqymj5iEu6R0IPN9r26lywdkOdRePupbMxGXGfGoIzWHoDcL2bR9U3PJKyCjEZsoVEHNCGKqFV617d065FZdd6334FubQMgkZLlk41NdNugL4o4bQd4nVY2t61mLOUBCACYaMmx0ycssx7g5r_ssuhGYqXFNEFli6JnYYm_y0bo36elkQIY_3YKGbT4PjCp2YBKdJfB5f5AW62yYDQWdwxl0pTmhUhjwG6Nk4VsZCQXjiapvtu7J8FnxFCux6ZLouK5GhjG5oPjZN6-loKQab2m4o6eQEnGPeMK8Gdo8FHtGPmHxcNOaS2c5Jzd_oASA-KuD7J_1a7UsqNrsekf7py3IrJ7dqH7YCbTjjIbcQfV8jAKPdpKTaVwiT0Q6hYF7TqCfxTzbkKY7Qrkt7MKgVCzuB_RZmlSMNbSquRNcPNZ8c89fUIz8yPTfA1Zn7r_0-tJjGGUhStsrRKJFYS3X-BVSv7-WJHlkVDuAgQ9eg8ANb9Do6g675iwYabeG3odu7XD-NxKCqlVlxmRvecpGpb-B-voCnOnG9mIad6glghakk9NDY5rRE1sge6bYaWL5myPE01DBv9q9UEY2hLIByrvJWmHROTE2QlzJH8ep9HoqaCXjVxEKgSl3OtBwFcIm8WdnAfp1QBjQfH7XwvG3lngFP73OanxNL6cgdmnQWuPlFY6w4DocRkhECI4dmSas9DA7Rta7d5HM3lUo_ewzn07RlbuxFW-_xGhCdnZ7B5sVSIaxctRm2R80wQ9Y3zu-0QrxPDowtLOtF6S6b0E38PH-WEXIRSIeKNDlshfIOlRjml8vmlwhJbZX9wtAqzMX0E91uydaaN4NCPUb_FmcjXtwAiPKitm4kXNKSLpX_DMnMuzvt7HprRi35_lCC9mzUih0VxogEqKquMcrWAjYsdbR1TJX44PsHXVgO3xDO6xNCNwTpD-LcgfZZuO0t_H39WxlFbYtT2IEC-oFWq7yEdqvyuVJOddtSmj6JOoNf5u52Ew_Qj6lTTlUHBQh3bheXRKogkc5FdyqfF_wJUU9EZcIzX89t_spEfjzxd-EnmW3d6uavREbm7HeUVPQDOYrbVtNNe6UmC1tEAq4X2L47ZbfSWH3sYmwLIjq_bI-eZ0IdSgsY7KKpxVGluruQmJChatsHEu17nP81f3yWkxfYF86QFjTrqvV9l2gtGAx4gvtIEOORTIWkbbOQItkFJ-Klyo8xnvpvlaUEuF3gpabybWJNrZvABwfNBtCcDIvYRgbnQuT1LoUgvjl18lKFx9WsF_9_NfDhnbmWVtCCGWSmpseDL0OrZCoogd2R538tEbrNMJF38Szff5K0_H9VZ-Q-gSxg0NHqLJdgpHNrc318VJqB6ZkSbEOMjFX7VQLZBvE0mI-cKnmB_xC3c85E7IEa2o3FUKVF0QXkWmJDHld4xvy8cVni0wApMLgkST95ltLwbpm09XHyuSPeVSM2daDI0F42NeLT4AYrXMcu4Qy7P9TjpbwFTnk59M_Zm6B3AWg94GVcxK1De9KGlfIOllPTyTKWQSkWzUB5Z-lUH8G3Hd_GeCZAbzY_T-ExhbjrwN6z9w0JxUApah9Ibr_2ybDDiJjMZhVpCQI9HLqfhNQV3ouo4r2dPfMv_rIR64eaJS780mPEMgN62s6Dlu8xiR3DjpPoVTJuHhDLPEfA8BlGvpyul6x9xR3gYOYKFgV1_VzGwnqxc-EUMzUZ7ICxiBz96AGNcvxvSvKnfV4TIMZXlVqMj4cQer9GOYAEqKjLoZPafLiYj-gwNJPDZYpyPfzY2O3BHYs0BJL9Yh_DzrHxF5HRNhivq2zE25h0bomMb_3gqhCwEjK_qBPff0GT2p3BtcbEQ6joC-0ZSnferpox5WWuCCqEZ25V4MpXVgAuKmdcq7QYWBYZdDG4QO12-g_2iqJSvguVQT5Sg7vQd_FMiTwijW-TdVqx-Y54Q2um5_D4FxTkzjyD8jc1YkKEOdsM5H7N5l3HSyeKLGtz9KpF0tgDGfiyCemWGbFRnPe5sf5-etWx9YrDsKtHDcEM7wabVWK4i-aI4M9wUdfgXhwZcMwA1Otgb0enL77o2OVUsrOKQK0AUAMAOvF1fCHOBCYq2En_JoNHpzHnIqkrtJxIT-l3aoneRykqilSRJEi5CkvcZt9WAKQt_I3621nyMe9dwYqocjfoKelee4mbQbyBfCQTDZWmWadgq7yDR-9ypgTtw8WIfZVq7x--4TBy5Dt7DxhIBh5f7gmwSIf77wq1Ljr3uTRmcI2GIHZsxZzIDgVmQVyuvmGsxn_F8DVCip1MF62TVMd0qyrWuVChRCTxNb9-ex5ljhINIq6cwrfn022RnuOoN34s6QCuR_K8RhU2fosHqLjW5p2pDT5Q-JK3TOv1WwWW1PeOY3qSkAVw788wZ_i4pvGYOD5E-VBQSpbuWlbTM59m6nwwZPO1o4AHTeyT3eQ9RQ035Npi7SbnwwvKK45KYQPpQjivxk-NdA1nrZyNwu9feYZg-Lv16pQG3dGXWmG4jFzzsYufFuw-Gj_5qcNMsyS-FxyGUZ-0LOcwZVvVtPpnGXcNgECSQLisyxI0dpTwMChgj0EEEVNbueazeYJJlENweyx1XbnnD0w3qkBWrnh4aRlMDwVWVBYhCaHJG2OkNshLR3NRyEwMGTYCOSAy1JzNwKIcGFoIjBOLZJWS06NpLWh_JqVVxUgp3xlz7J1nBJ7VL5wBoCXWPDurJMJQ52x6wogrq0qQJ0BPFCCN-SNXZtgctRZT0-VLdX405ApXIUvcs-NbjD16J8x-PxStV2uJgzTemt2UCs0JjHAsdEKd3bQv7v5gktuGyUBHSo3_vTVshrsT_5c3OJtnBpfQvAPIdtePORbbPpODLXsmZOoObwoDZyTA9uz6mCy-BUjwUCXTH2NnAHgsgh8oEgQZXa8YywUu59-i1_3KZfQAJpfRvdvXaRt7QuK01XqLP6_J_QVQcWWzAfQTNqncRPBWse6mnEhUMSIer8dupGkkzcBOlCV890SFFTjLsLN7jyypdKjn6ikKIrLNGnGqVNYhDVb4Rmw5ywpP0xN0nDzMpZCSjfTBhwuQWwBnGGSlYqxNkacsKDL3QutV1l5qDIPK8Cf-_wQNlQnFbrofI_MJzXbrjt-COL3y4tc1aL9qWiAe7Qj3bw13pJoZdq8nApmjDtSIxUM1tdPuDDsRAlf0nYrAp2J6349JvTEmQpo5xk3bzhvSkgpt1iYNy1Cslq7tAA4FfH2me4oxbGUSrji4KUpIzsEMqlzX-IJZxireE73SIEbNRLh6TACPivN_42oYBSH4W0vzj4S2CKPRFiFb4kZlIkuMVDSebLzUt9dlW_Vsfrh0DWISS4Suj4MAePLSq7IIrX_jZRDfLfpxw9qe4Ai2Rifm1mHi2iuyBDcmXe66-ULhW0kZ308b-o4x24bKHg5Bxwdl01KX_t0v6oajblS8VNyGMM9YQcNuaRLyTkSHC_ZEfNT0KlyO71YMdxy9zz9l7IYCsed9I3G2lnwBNbu3nVXRz-HRM-46qcVUBusc68S0S44b2N3KNm0bd6ypLQ0nRrujSoSA4Lbok69JSjkGfS6khNi0Osuzn6-6_Gp3_yqe-_fan0B3obIjctVKyuJo9bo_V2PJ_-Oe6dkPYgO0AIHBDeveqoa__nu3auF--J-nIHCv7llnqDN2gtwFNvl7F1lWWWkWnd12pCQwJ1zsmkPio2QY46n9n-NQN0lGLqXINgotiMnOTIJzslK8563s58CRtAQyKD1U8zhTLBTliT7otVU5ArWGjvGifNLKrLb1sId8uuMJLH5kne5mqzTJLkM7EwCkRn8coRCeFdrx5B5fp39eAvGXWdsduPA-j3CbfrHeIH9leAAU4aeJtqpwMHKbnbnE9DcueV8FOx_9J8xeSujm6Eiu4AA-9i5QOxmJWZa-aTjsCP-BCBVd29gUk5E5sFM-E_0kCmye_vV1rU_VUlQZI6zATdFPadlZZFvucDx95cqdYqjYO4H6I19JrrKe1IT845WQvXD7_Stv97127sPY7IjjxpdHROTbJQjNmWSzp06rUM6LSkNaXnUyamBsZDiiMAdXUA2Mp7aRhXUCOqTwwUzvyIB4wPn0ziSKrvAtzJrJ25eAeknOvcvXj7U2vMhEKIRDLLuFDLq_igOUMLkQ5uohuo_INoDdVUoMhL-nwNdL6ftNgzf7QHhWFiOuVOVI7YmzYLNJ2wAVOrHf8sySZ6h8QdjsqvZukJZiocSQFIfHkOjw3tl7BvEAnTlCYKVexQgOmf-BO-YEXg4UDnf5nL5jknB1Qcqn6PDnE9qeEZUAQRtFjTh8O5rj9icyCE3oOcbhy8N_OGsXSeIRWh926-9LBXYQQ6raFyeVu111kU-cQt4D3E4Uvve9qZl6LUzFwOf-MhbsM2ziOcpCscd-4rTrrDeoFjy8ZbjJfC8pHYMX9m0UUNIp9qmVPrLsJSXkyDaoQXs0Cim526JSQIstSgloADVpYP8LJsjasa2lPy0iDXQpW6_BUPVcL7VDarjh3gMwGADRwXBFrutruxTPT3JyMwIVUcegUb-ZKh9nAJcKMRmxWNg92cfr_hnYzYpJYSupxib5-VSxAC7jZOihEVYyfHxbC08yhUVMR0rS3MLYRafJbW1CwJLA1JZoIWSf4gbKKSVI1WFMbXnb7_ULIdqk29qKAepshak4vNRlylSvVkHF05WF7Em0gkY1JiqOSrMpiAe4fEqLoUo7c5iuaphAAEr5eGyJx7jGfOxIklp-qoYr-elG0ZS_RxFJHPJcnnMWrdaKEZa4KLC0_UJQ7DbJS-lmI-AQ3TALpqviC9o3C_qtGLQYa-tQ4C18sQSDT3hxsmaSjllW_L5fWtK0T7KZiXjXRrZbB2XmBfNcML_VfZXsS3dKFfJTQ1ZrDO4lR_t24O7ayqnSqMeq1wPRpnN3z0W2vGTmh71IcvwSKeNkG4b0Nz9RPEZFz88kJ7I3x-AjkGd5Tn7hyRM-RrjErmaWlMtpNnxEbKyd08OG_RO2jcg2VVm7YboS9d4vILdqy9GyKmK7t6QxvR1833kNn_kyFwWX7SuI7fKbgaB16G13FJNqZtb-jabHBPhXkQZwGVr2Ma7XbAtPmRyxYCPGnxWyoYefBx3Z4qrd-mRlN_FenLObtWiFkT7aQA_tG5U5kDRWnKbei_tycBAzqM59a_gMFTePLUaLj2OzG3DWZtZ8bE-wVK9y0YsDaTgQCUirHcY0OhKCxBPfZaqztJ9b2ql91arTG5rGJg43Eu8fumtIoIVAdGrOMryaz2oEIU5HDZC8ymjybuYZEgEL3a5SnHp1PBHKowK94X54XM4KzeJ1OqLs-yPo5kZtmjOtgyirIWnsINb0xPyPMqOPhH0RGPs7BkYcJ4Htfxoz5KUJBYm1Mfcpg3sk0G0_mi6keiA_PLGVf4PrF5XwP9hiKBpjRpr7rm7B0xrtGRt5myLGwbJeuS7zvQCA77dauYOYxASlFf1b2v2vUoVbLXynmFqY-Fm3WdAAZr_letUi61bJlTrktLVVaO2dWHf3mVLD6U2ekuqrieg4obHHsP6_-HT_N8aWn0HXNkmseBEUuGzxl1jAGddhcg3LNPpGrXUZh3_65stCwxauvuQSL9v9xCB_FbM0dngFk7MXWZdbFCR1z388NpE7rZqDRD4bdnPrbcKxLr978rpDWhBDd-q4q9BZ8WDjfW1yy4AmAhaapXNubeZp_xzco2OTuXN8dpRZjvoW4Q7nk8RInHYgSNYPOy9kZ7tWZo0EqO2lG5pdggoA5wVik8wOBEgtpAat1L3dF0pvwco4w48PRokpZs1iewoJnQa8NbFFP0dUTnK87e6Bv7fjNLeHHXqa1SCi4gKUxxx-jjR8IJ3h5eu5bLS8zgPs39VHDXE73y7Fw4_oTkj2sO2tcyI26d8-F8TUW_4tF4zxUf45Qfsm7G88PfWqIESahczkR25f-C1TAZLlgaVww5TAWgUFu0FTOtHbG-DlW4a63ZZqfi3ITELLodYF99QNBjNzCGha6rLSVitEp7vy95stFrWWHMRraR0KfA3On96UUlt6JbihI6n9SVudDtxqt7y_vF0mda3jxi5ZSTznt-_asEzxJT4laGioYVBAFkXayAQam6hRy667qQQz6Wvci8L5jsLkhClB5WEWOhX1KRFcTDnw8D_urBpCP1efFmyEjwzTBXYXO09GG3b8uEzbdI1k1y0tnNd8aAig0IL8ifAWw5ZYdkoQMgDwDyxVhcdHfeZXiVbBf-nK-M-VQDlg410jTFzBo5DEVEHVyi_cczqrUjF4583IBbIU-9S6l4f_fAemXhr3vhgoSJDQm4PdZDSJpv3K66-yhwr6wO8o-fFPYWXftuXftx-TQIa8ZcTEmf0VB5NDUfsKy87FIFy4f82Sb2mnXz_mx3khONM6sbZxtvBy1s2VpSjgz9N9PGh3XGRy1bTRbA97trgmhP26iOyoNJc8TrrYR-uNKhorrjtnxjiR5k2RK9-wOD6oPMNLi5AgYyyip2bDaskm80P1Y526hNKuN5Jrh6kkYqnROTAA7S832jpd1OPYi1_zRECzqMqKMLVzZMYXPn3o9O_ujc_0fw75vQtyseoyGYh7vM1DC5YiHQrnNySIrYShXaSJvbKUkXuph0HpDa9P7Rll4F_6VFMRoRylutIzhKz3OfnPONjB9mmLiBu6BAZ8GwXX31BiccE2xqL9FRGt4vhzLGVGgzONLcgiPpBAwn75SmujvHf_XJRUnolpdq03maMkyCdpXpB3xs0OO-lMmgB7J8f8Xlr0ymhL0Yoo3Zo9yI4HbjTEK6VTs1S0NFrX3wtXFNTCrvh0ZOpwSnKwIv2h4QcKIXkDkOoq47injC_mohbBVFZy-3OMjTuCOGd4-Z8PIKNy5RjBX4YUkCnUTAPYu0HMWwwiOKJosvT_L_nN3P4VfF9txYcJ_905lDYRYEtOhRklVG5kI7l4YPNA3BL3Wjo5tPbcis1b1HsiyoBbBgQiqyOVg7-7_n0yLEmE-CTtAxx0YML09YrypaaNnG7UYRYJj_V_R1JSHFC7yotOeTgwDu-8nt45c5NBlXMhgjQ6b0-UYa_Gx_59rV3xrf_iKAnD5zZCIxJxHc58W0t9BWSPUn_y3gjdE-TaABrj9g6i4KaaBcxdyWtoUPq2s1ztNE0tIlnzIzF_UcXhOTpgwhxFZbFYlLo56snekHlgR_X28RVvX-MvP4lcGkoFZwOgxRGh06MFM2o25QEMvw6aSsRNaGXl7sZAKaHc_YNevhM-qXbpz6BGE3Gpq3PTr8U-JEmGfZ3rUoMBdsaknouR9b43si7z_bF9hMBwpK7aHxYGJIaXIQ9zIM7IbkfsiG29Z0Y8ZolL4jG2329MjUkcGdsMiCTxhzwiaDBYC3Ix73QM1Bs2TZKH1ZNxFtH-1E1juhZdFER3E2iQhl9BzcAt5BrgWc4jTZzEkyovlrOLuzaws0q7TgykMBjKy86LbVr-WLNmQQbsXZ-UrrdZwe3dFTeoBt3e4pA8jlTfvqpZuaCVdcIpDJ6H2tx1acuX7KL6fDjBmFMTtC0byCRr8S4FnQCXwXtzb9HUNutccE5qeiCRriTd4fH7zYWgf7oxLjWORQgd6DKDBy63IvNGU08LAYOwbst2AKOP7KdDQX2AM8SI6HUcQWSreqezJdoDmiCSO2wOCEFmZUlCBKxfbON2Kp9YjWtkxOF6zOITpTycwQg4QbXCOAzINVAXCUK4bwt8mdAVIC5RAGEHITiVjBt8bBRXq7W_KSwJCbvj06HtLNE0Ioi7JaI1uFTv_nWbBeZIaj8SZKjJvvkmlATJ4XxbRW27dxh_VV6o0agF7SxD9_hyoFQPNVVY5SSMgvHrWmpsQyoGeRTSk8IvpAB1zJeCUhaJDoBLEks3MONM-xs2lihlXPy4hlwa4Ghz6lJJObQdclijyC-NUZBQ7z5HoFRhMfVao9R6QcTmfKWX4EO99htmVzqZ9Y_vJtFPtWkOCEPuS6vEZXQVWgz2sUVwAMPnwaVZhMnwXEbadsRnr_aQKmbOpYZ6R0W2DLnf9fQh2QVdkLllV-cwLcw4u8Chdj2fDvYMjI0iZ7lAskhoha-9k5qq97sQ0cySEhqpTneG2qIMFv9v5nZQhkyIbiXUpCJY9OwIc4s-7xgOtO15LzaTL4-MI2Y6ouZ4WA3_EwHlq3k3sM2amIxQODBC_XiSeI0hb8GCkcuIUmpvVLh5G6POVzmwwfbqFDP52frb3XBv_R0RXqkwtoCbHZ_nzTKXESFlcEro6cO4kUT2ffBBWGEc3A-0Vf_kdSjwYFFBcY-lpehZU29OiiHcNaa6_u9zR-AgC_dp2YLeY5ekzD6M0_lhPKv2DQSQGQuvygseR0EPOTcaHZ2e0Uj4lKiijBGw0wIE3d1po7mJuMw4s-9AuGSGhANjPHsnXm8IAIQllRGwHCsUGst1RxMlSvVAUHTRsHhNPYnzaeRSQXWkVbBMnfYs9rkt_UZPKI0UZCygGORzuV22HvNL15a7RleyYdGip1z5gBOqb88SllypAeXKWaAxfE7DtExsrh8QDgmd86nGBme2CzPkaOoehfCoP8GZlp36l1UBCfWpoJ6_gAHjahWzLmM6Aci97bWrG8aSEOFM9nh8tyt2fTcwTIeT43w_mTVnozi2wEfqFRsIRd9jIUVJNUlYGK3yuXEnPk0jt_FbykDmXfVvgd5oMy6paLrrFhv-ncL5HJbpCOqCfDO-HNkdwB_FLcZvk4-WSFeJ2ysEj7G_HWkpJBD6v2E9IWniXt3b03RyrVd_RBHTRyJ3JMXrsTWEVDJzbnDYzZPtDPT1ZAOAYtldv-2PW3H6wELfRoaaAOttnA9Um8PdY6dodtZdeg19hU1WoSszyLn_HVSQQwG3pLb4z2S4oKh3TULcY6_K3rr2OPsvLOIYX-U0DD3qjrEYPfeq3IS2cW-VKOYMUFbDTVVTLCX15mPaMAm2_2CJtquR8uF-Iia2iDmTPsoggTPMnFRufOHoixOCljqwbaPUONFDlJDg3BSBPckY4yBl0VOodz_L93W_Uvh0D4xjnpEBNvAAFz6RNB2e6C4YtYCY4ckqHK2hXHIS2xRmXm0RIbX4qirFJMQYXYNqHOdfZG_QPAt-QAfD5q4kTdoiUpB95Zmdk4Yr2-eg8v8AJGwlwL6_KqFhkmsrwog71OXc0ePfiJTgvhDPHeS8Rcbyx_p_-YNV1moaCpr5_UCY4yVXMBuZN7pT-Px4pcPBIjw7YAdefi2TtQhxs-kNy4XhTyMp9GZPN7Z7UvS1VVSakvzWHGslWblzFrxb6Mh-Nr88DZhAUNWXumyKHhE8WRrngTDa4MjAuv285Dl77BQpfoXq8Cavrx0edzkeysL6-cvnAU5_sTI88BPzasdZNdnglnK0iVINaRqjqBXo0sYg0TetB4-NPXGSHI6CmozbFHbnxaP6Z3NEOrdHf52LnC3HHED-InS_kJOj4tnl2yqt8WwA7zFH-8MHdHP5bmH0MIdoBfUd4w7f2ln7keY6EamoFKf43fMmHMtlDRPIrkOZcQdXdam6drRBL_eoG8uJi4eI9DOXQJaU8XNwPvU-0aVzT2-Fj4KRLtmjIP4NprRGpWE5k1p9fWXD9Op8OeRRVXvlAz2Yx9LCvaFPXN8O-3vQIYJ_z8fWpbKd9CGi4cCyglhnO9O7wEhr4LjwNoYEkZHjX7vKFmldzB9GoQU0DNnkSUceKdsUCCJ7uYVobj1D9bTZeYgbIdbPMTioFNPLStKim-QPooSmtre0Z9G3mi9Rp3MiAfzLdvuR_Qa6XwTM6OQxnxEM6JzFnsYG-a-sn2MjIT9A8gBYisvSMAiqZj94uMfVMKukGwmva0FgvRDGwmWYs6w4okeyYlys6VEqLt4LTAPC5TQyL3vfNeLP-q6ucxI40lT5OT3IaKK3M6rCIwKi2jW3nbfJbibZ5-CHg-i-7hqKRbLLYcyN08NcO0sn_UBPX7tAG1QDWid5iAr0JfaHwOLy5P4qrLaNk2C_-Zsf1JAhYAdK3i62OyQ4FgHoINjm6v9PN-GeZlTMgzFNluZeFP08dTz--CVs7cSH4oNVgDyGoALXPfNEea1dMLcUZ93hKut4wqLCW--utxUVNUWS-7wBRiHobA1sl0My9eVO8c5QnLDaqHZlk2N8yf5XRAkwwHTVZPVP6HhOlF4JgjM-6TJI26390CGXBsnxeyQ32vBJljP6mdPc52hRZp7bU26UZIoiuWymPPjbL1glzWTkwnOHa8RJkYG_X2jgbvYlw1BoZpepO9Vh4JqTRL0Hoq084_2q8e_wUC9cfVg9qtCY-aTZnDel8C--dDA9ubzklBMUcaNOPDVxjda8D1dCCAo3tl683JbAts3_DXI5RYI-uYLHHdOBdDDeTU-iydYWjDDS3YK2bYW109XGHr9fISx_ePhXVE13MEEC4rE8zPGqxg278jmGcExn4F2nmp8K1YY4wx5qoQoKtVV3hkEGtHbEYu7QCybbOsEqMtmXZoDI8BsfHvrfNQdKagHwMgEP8ne2HAAEIOx0sPQv5yISZ9lUs5tuhT2bO6PLLocxeLY_UlXI5kSsJaQ8i0QLZ488bpXdFoHiLq03au9-6038FfJSIsVGQX_NUYA-jc39O8qRRuDhYN-Z7FNdX-UgCIyt97OiJugIHRsghDhkvNDtgoFeQWfcJIfDYsdCjiulJyqH0oKbWMvzYiahdrUnSdGWmqkOKBW0aqrHzuWMooFDDLEH2E2RxU62Yx76PXDv__RApNkCiPX47v4YabxxDIqvTd9TGVkcM2bIUmpNW5gFJO74dDSx4C-49I5CYvBXCuNZC2zLWYKC6QUwfKNrww142kvZ-yGAZOTukREgN8ZX58jpBBnqO-rHG4HhlfagZwLCnePenbpBDrQmSFAdQG2C5XL_NZIJtj4kyj1USqe6iQ4LJ8PD9NSHxgevNIlSA5GJd9AHuoTwIYVOPuwEVGpGD-sAm49yRJ814ZYo9GZG_FBx_Wu39uKIEM_vuOc939YVDgUDrS8Wit6Tj1o9Drr4zIkWli8sxBQEg9nQNtr9vm2QDEnTnvVB5wYCVxjqQa70s5-5RsEgV6Cl3qiQG2dpzPlwOpJIEdB-rxf-mqa2NT1Zwf5vpqTzHSV69yNbdfnRYfCM3h1l0-eeptIC7aWzV4JIG4uJQJYgIQ3rMejlRbvXArd3CQc1zaX56yfdNtLa4RRj-G2wbLnSfV9x9lG1nNePSj4QcxBCOyQC2KGfBuoAK4T8LxaBzIMQ38u6Z7nHGxpmrfJ-03ptQ5R9nNhpCYtljRDT_z4vvJiu2qqQSQ0SaXX3rQR1KqaogFpiZk9VyruVbHUvlxQy12lAXecGtRbZ5e2_ey-dC4DlvhaAL1i3vdfPaiWgChJ-zTNEklfBlFawNHPIoZYJd4ZqZll_RQ88SCpAq0rOzEq1PSji_26qEyc5j271TMLop6hgEc4JzEv1RUKDBQ5MZZhqlbq8PWg60y5xAnTzmlmImqcocvB-z9xV79y9DQO2IPDWx4tzRsfm22BKpNw7ynqfEwRBzRzMVrcXKCoGb_FUIbzpT5_Gxu6x6vuSb5JCF4-cPDCpQ1epR-Gqyz0gdFSifSmP3q4g1uAt-ETh391vqXBxfE75R--Je0oWNhv1JA81cmPBn6g2Yq452YKCiXpiRMVBU8KdbuZd4Gzjy_V8MhJNHBKY2SkCdIuA4wOSk3w4RV7X5JPaGWC0iFPBgFwKJ6Xy4YYTR00wBhr8xoIe0qMsq8cAs3V_a_bPfGi2Elji0HF9v7ljO2kiBmRITp25eoBDXwYHhmf3L8ndWMLAsPvjbu4LQLSb_IKLee5m2_7qa7QHM8U1IRY4xMxWmo0PjylU5EeHNEIzBwREkaWusXectj4zsjL6eEVBjY6qT9aQbJru_zNlzZj7ik2Cm-CjuIkyKjSZe9pAVNvyVN4da5AAW3H3ZF_r7PLqNzTZaHKeb5R4V-Be61tkvVEBGYwyYAhXKiw_MhtcPsNkyXYqgA6rTa4G3J9gQD6P75PuodxZmEeRZHcXKD8EUymP-tLDVx4ihYGSAOdf0kN83NGGpeswpiB5xSU6PEFAqBNxSihttbP25uwQLoRnFFBbkhzuhglz5Rac-X5CeNGdE1OHcRqoNFqQR9_OoPZGrxzoC_MBqI3N3seVXDhfCcaNXfZq3U3MXeAZTKb4L_1QC2TCzcBJfQYU4o1psjrdzyJ5hNNvjOuAmR-7orud3u8-GeuT_VNuzysnwiNxHSuisgkStC_fG6KO5FHahGAI1aFf6mZJN3Ik1bKHTVAeS9e-X-WEG3T4Gtj-U3xJbJYJdawFYfc5u7DnLTzOT8wJTC55Aru6NDTvizpWixJqJ-rw9uk1HzKCLqyI2BymrEuB4rCAVR4kziEdSRWks5snfMSqQLL8B-4CiYR43ljU6ej32C26e8uW0Pcc856GNYktUzsgvQOAm7Fje_1SThRdAFCxLrp9oaZb1vKuSXEX49YvlGKMdXKQEJL6wD3sz9NWk7JjAnADq1ERCL_y2iFQaD8UcDlhV_KVIiGFPMLeeq2YhN8nZbCYILlQ2IGB-aL8ZNKjXWUAUmbOU39BiK9rj7Q6I5180cMbcL7IO3-EBZckX3ozZU2U48VykI4UMaYA8VaHicnFiovlgTrZrGcijUd05IUzm0TMZMYwdlf-ENYTHuGfNEDy-jvBsQhsS7IUJgLgmWKJTOVIiFfy1MUF2_GCb47s3Hr45BP7SXBHRfhjTJ4YbU3esOnxQDsbEyY1Jra3fne6xU6kkslvHvg-MZplgjlqHUF7eNAyuz4qrNTX4Ui86GNaToWqqBh120oEZ-9LQX5q24VoWAc71GUfp1f0nAjreCjrEu3OeX4pn8YepeSmQNkP7pHEeaJvNHHJ6nOqKi_Y-kAoCm_fvp-kzUuArwLtuQJeamYb7gZDJp558kD_4F1T5SOr8UXo_Hwb8lmMY1LaNXj2F_mMDj0OB-2wLtEpiY4n09wAqAoVm5ZMS9il1lhHjKOkUBLNttu0GZlm7uIXDYc8QX4yRkC_D51w3SRcC-20aigjAQocB8VoLzol_0Sc5Apuqylehnp6ULiBBNkhhZWGjoy17LoSKpXt2GPPYn8wDSHqnhtVhEQ35wZ_4px-Tgh8KuEqN2BkvEf1C7lFoyRcDWw7WRKuzgy7HFv5iVHXe93y0NOc4kR8zQyyWU78_xWpWd9kEHn8mn5alpRbsfN0GNA5_1coORBgWfHWVMU_OWccLiRrBvRPAh5RI43jR2NdeG-e7yA2gYP6yCh0npZPOBzXSPug1JWv_bDYZOwI4NthxlU_AhGVv962_fThpLyB0oEiQOkqBJQh8CYlpS0OWwNK5luqhLYn8QHtq5R0wzaX8QK9t_D-V9nin1l6N7UW8rslv5_GqkkdVnRoEuPZyo0Zu8oGey89iDrx4slJ0qc4ZYqHxoPoYht4Wx78BDATh23Onx9zNUbAFbG2JmFAmdTAGClizsKMpLFhWNRQtEzTag7Du5zePIrCSaQO_lk7utYvFHJVmRhlwWZA3SNrkdZuFIgxW3rgf7FhzvoxBGnHAS3p_6beiXBNHoekD16kbmgF0rXvCaYbYeJeqSfbo2kD5D-IZoDIdBBiv0qWryA4KwCukPfKb6VKw9eZPm6s5imiLJhjF3AXhB2IZWMozK5jJTc2IvfCqfxlviFekw_oJXBnSgFTEKSUKkUiM9xoRWdTuee09kaxdJumislCBqeyhA0EZpBiSegJfmHw90tpLRDyk-E0zVDny-IXej2fUeoipoTbEamTMb4xcih3Q8aUxrjnLBChbmv35I5jq040TT9GYXNS2jmzE5BVb4qfdBJEg65f27h4xnWAYW9Ohn8S2wzMr7h-PEsW-3W9PJaKcfbhOHJcdOTuuoiJLL-SXK69j0tKUvDGE5iepFaK0uQT8c2-ubXbbCpMhVZP0GQSpLtYfuGaqTrveJZXc5M9OARepjkt0KYnoyp8U248lA_GhiH1-qqP3vCMF5Vi_aJ35aTlOfrxkwYyDFbz3yKRavbTGrxKZyLzNWChNGKasnQyBgbsGdpFH3hgTwSIYiiuhI5f70xQzF9NoFuWg9GkbD2hpI_CpHnOUaRkOgD7h7Y7nkzOGa_0FPR9n0d-UZ-wPBwwt_u2j8bVDFptEkz-Z4Xg4gxp9X9noTff1uNcQiPAR1kAl6cKnk7daiuL7LuNHpl_LuNpPq16vDa6Ii-JHv4z-TbmAOjembmNCrL_BmhzS6UHKG3cA3ekP4_yYTeeY6HRz3JgrV-hLWZiaHkS6aXb9U8zsmTzaVyzcwOSDkbkPJZHU35EbWhnPCjGk0IIh4Qay0cM6s6wp_FObJt8t0znwJDuZA_AqR9cIJvhgztykUdGpfBC4A3bpYADGFgldb7Q7jcmghymyMIAwWJn6zcCICSGvxh_RN8F2popC2R6KLB3nVVMaOkQ8BXtqU0XHgWAaNzIlFl2eCetCOYUl0gth3yTGGJnyAv0PcPN6NhYErZ3ld9FVZyDUegJu_SdgPukLTIRutxFVz3lnGZABgucnnvQDpWu4cmNeKh04SRvoHzIIhFQGi7VMTV6ItQu9eqoX9kE4e_kWjzYhMTuAPFUGW0bUXSt5Bs_o3ZLD6NAdU6zbJUehh8gnSV71kO4k4zqLP5eMRnvvat5ixPE7vwByTLRG4tiuMEvHHbkSHOgVqUC9ZJJA2-t6CG_A9jV1gbIwpz7j6c6DWhPrzI0H2QwO0QJfPR70XkQPpAS93QZn3uJ5OchDgHsD-7v3dukfSYK-NnP55YIMUKkma3szGmkPorH3PX2EPMTRTbYagOf_avDWKHCx_m66vo8o9lKO5349-3NB6pj307E7UC8wnH5uQ3FRWYf4ein-HdcBXgN_lsKmlXoa2Crcug4E3Fgz5zwbtBYUYqV1BmCINwzg_9FfS5Nu98YZCAhoJlj5N7xIvKmpI60HlGSgPx0BgVtwWH1CxoX-9eWtBU_kJt2HF8g1G1suwKEz42MNt_ESzVvHfv1xxdZJClh1_rhaVTK7qz1FQ-90MVQuYcy3uDXeNRv6_IgV1jSwUd4JjaB_TH1TexMEJMl5TCxetYVHPTfQ4M8GQ2Pl4X5Q_TUgRnxWcFFCXoUQmmWkrtQ3Z8HO5NzfYclhxs1brrcmkVeJtn2vyfHM0Y7fJAwxsrLjIwNSvOzboVsGUejklmW0FKXMMz4Pr1rZUjTCJI2Au7rgCPy3LxwuaxbCDEdlVBz4GvAaoah-9aLwiisaNEORac1UR9LVZuzzTB1my1uzfp-Y6Bu41Nlps92d112FW2kcaDXx1qC3Jhk3I5WBG0SC47h1C-lCfTH5IxM7Xwz0KVj6lm0gl7rOIoHkoEnA5YZSJyngiJbg7ujNmGSuUhGYQEM5zibodqYqqRVQ7P4geQFEK0Ov1TL9wR4vqOsEglelZFBi8PHs353-ilPKeI6scWSoC96-K1K1YxNzYgfUXEW9051rgb1Y1yFhgUzchxWqnA4QdFufKDkE2TQNnowZxw0ewcVLPoaMm9tNxULAXwYINPM2_xVgKjjDT7eHt_DtOTJYTogbXtChFwB-AcVQqEfgDPD6lyN62jAH-yqVAJdvhcVH22yxfXV-_yEj7v4Luhh4SRHxaTr2gQQP6VoizW7yCke8UoNv4B4iPX28253pYDY0vewTHSg1gmFLmDMNQARehYHX6NGkyOnrUJH_AnP0DQ89JOXH1LjB7ZOowpaKsUnINWk3Ec5vNCBLtD20KCyRIPs923EfaMuYA5aFJwIYm5AHDlsX-glJYJ_cEaC1vDdnG7kfRDqq-YoiT7hpZueVMT3rRS82HMGeJ2m6MSBQmyE0nSUAGQHH-Dc30Cz3kXrCpVeYRp_5nIsQFSTegSWHfMIPNoj_Z34jQHlnnMT1xO2SUTcU62ZalnyPEIArqlIo17zqTKTC3gLx4Ngn_HSVO32kv3xtzznU5U5bHdRRBr0W881arQKn2vC3hx93xPzEf01wHP9Ati4zJ8KqERqVfmeW_uPYdFq1WJT91dTUmCPhqPegcz-5niHyJzboCGnp-0QcvVjLFyOMxLnefzM3e4JSfrJYKOgxxJOzsGaGdOpn1DX0TSwM96I96CkrGN7DToBmHb4TyKKVQG0BbwacQoMsH4v6wfsbhEdiUS6BWNnwNwSmJnY1u80JVJm0iW5IbYeYuzc6Bx6KSUmnPBbCdB-T2YulunQ0UXGV4ojOH2chOXRuduWJIurMovrAg00aCK8TuA0c5wVbprztapxA_tCgNZ5U3iX9mb8_PHOKV5jVOHG94-1kNgLAbpGTB2014cTOrafKhEE5qhuGmQ3LCgKxyhHl1y5_I7JkfaHayeRz2eB-vg_RVxc3ZczXEgSsFQaeYvJ5NuopSvaEPtrVDC0a1d0jtGFS6jx50rLAqEZ5t5D52ncXb3kThV5Un8BfsPi8izhVa_nZvmc2eOeYAkl0djCEdOs8M6f61AMrBerEisATqpdz45QLmBpLPxTptOEOY5YyLt8paCSQ_V_o7-_REwlwzRIZByUvNR6WT0LhX3Mm8cHgGYOxgIhvUQGMn9r3TKFnZrGv5E8qXr472C20D3q6bgb6nAWL3O3FHs9x6PBr2IWn4QOoPMhtrE8sN_Rkd-h8Aemt_tdFpy9p35OGPmFAm2MXEKX4NRyqmg2LaXCgzTEZzI_CunBtVXYLsUEeUfliSVcYknikcUeqAsvbFbJw4-WeIPT64jYofhRiuvYQs9Q4U6BqHphP614PnE9fZDFjvakwC0cWxkf2_JIY8j7OIr6V9xphnfAPF-kqueTz5BqRwxiSI2xrmDmx22EX-xlmubx68J975MgNsGKG-tMKfOBABIUq1XCTE2MJSTh-qWC3o7cI4qNOxk_1onWQzBxjaZCMoOFDm-MREkh-9OhS-PstEQWlGFtZGntKc-5hW1zCnFGZ7ePaKDaewrgLdsLju7w7IzlaOJs07Z_QsZv1fMvTEfcmPMAavalw6RLCy7fNPfCNocmONyt_yNN1NE3LZtOkpkv-M6JRjQnKPmIlSpiF0YVJYy3Jy3hEz_nA3YIoH4J1L8x5NudVqdqKp8pcV5wuPCVC0SnuwM30sn62yxdnT0wgpev0SK81ylcsJyLnb7Z_qefkYAOf3l_o0eWBt4Axbmnh8UNvpjndsxzhvp1wzRHjguGswqxp_gnxOp4HsVFqZuErrUg4eNKgQfuYUvWf72eb4pgXZDS51bInhbTUzNp0ITYLpDzSdmTBR6Xf_GeS2qZeBml6614s5kJWQLG_Z8WBXbKnxyD1fADIyKDaehgkz1IGcdoA63aOzcC_dT4BxEV_9wpX49QngRznCCE0z3Cv4K7Gqmnq3e9fEDzPwR3tWXH4NHwxiZT6bV9IcdXf_8l7z0ijbKP2zd-1cCBvCQn01ZZn1PRHOfErm31rK0gDi7njN4BWQYbKjeOHnVhZbA47sneQ9HGopb93nntyFrX_XDY2gU9eAi2UY7LrnSPO8hki1wFmmbNEuxXeMF2HHDwZjwmjp642-b7Y9M9e9KqOWTWfUgfb_HMtIGs1Jifob5sYHr0r6lwqUgSqnG8lI8IeqceR5I9WG9IDNhrmLaYjzA34yey6C_9g4kt6R2E-LpvXxtVxNu2cLr1c2PJoNT6mHME85VQkjP2du-CT1rlysnvAcKWbl32E6jlK9ttrHbJDDiJZmu6y_Dx7XUsPwAEWkQgXyyH0oGMMdVOZSopNrPjveZHSI51xRch7ImVd2mpXomzBcXr6IzhOvkUm7j6J9mByQW0X9GDauDXZMu8oV0egXaw3ZcF-L-SzPT6zmu0OqRscybM8glT7UyHEiXTT6SSUDvr3wk_SuDhqr9Qoj5gx31KxoR9DOh9e1rR_bfouhNPlGOlGNeevOnZ6qxBhym851OVu87rVCeoUHyJhduG9ZtldRqQtkrPY8dpSDVVCECt3XAT7vMbFrkxlXZczGfkBPpAdSgLi0zEZx-AFM2bv3MNVrPGdz2KbiVVS41Y4zbhNlHEFpvz8hpRYace8m1Yc-w9Sw1n7oKVw81CqxGnEMooGtbiGUOJORtdF2fUrUXgDim4LuER_gx_EC1d2E6_LZ9yigCi9uJ93np-nW4noVb3M85jh25XdT-kV7d9xJw8QoNVHsn0V_e69SV5u8KWDbSGBGqmN8x6DEdQmhLqWOtIfN7EVMy_JKdURq8mvfsa8NFMO8AGP6_toKCd9uun7cGbaNKeCYGePg7RcVLAJzTpI2O0DmMTFJygzKdxUiCRoYc6hASFckab7e40K9pWfKyzIXn6VyN6Mqc3bGtg0AILw5yYa7wp26wt9B55_00Y4Vyt8ta1XA2e1uQLEjH0m-pQin_gZi8PjhqE1WZWrW-LIGt0tLWofT2_Uot6QZjImJs6LyGGWQtpWN8zIpLQI1C5va3lA9sKRqXAdvrvlhWfpEHldOlMkIo5eGglcZsdrnZAPuFauO0fTMkbPq_gMLaZQ4q73t3WaBTrxHIcrZ07pItFsvlpXZ60EncOzUFtPi0WClA-2_FF8Mx6gdVucMrRzA0DWTIIEK0hJ4tdrxSuLh65tjws8xkoS674TnBg9IOHwGXjy1pz64sYbJIzL2xI1ls25_Jflhz2nwWNbR1siLReQGQBtgWuxcKEvuWRA-SHZXIsyLBIwuQQ0rvmY0BgUbNcwnUWhzRN5EnyKCQuKIbfz5dT5tC66tLl_alUaGnfTsGOoXkOiUph8ykqMf0f4KzUVwYltHPd_SK6w_H2EucTke0HS1N4fVZLSRx_y0D-OyWOVIK8VnRHqWu79sDACWdXPfE6y9jO-sUaBx1UDqnLU33GjZc0aIRxIOiR9QjSny_8m5nmnZPLshkV4HygZJq_nZUqgOlPHbcJ2ur4ZjYvxlzsh9d7nBlx1bk9-75FGQTeyipcyvRcPjcM_FxjU4HpYjp5h5Pgm_6lbaMijWJU76wp1dupc5sLmTnQFkvN4RjIFseXWyKexcHN3iopy0--jdW2GvMu9dMhxDEQ55O6Fea91_-mniOIQWVfcfcLb12tch4Hw6G8Rck8ZRLJjqZdRbLwC1PquwuTHDrVjpOwMbIc-CJUHvLqW156S_13PBHwbQvVxngC9o4kwl3geb2isplCSCAyA1Ld-vysvMOL47_FDDzWfXsPMimqO4SkZxSEz587mFDIQdh4Q0w3gGMSFNzTcRTxu_qqROzCLHu1_2W-ZTPaRmlPx2LzkbLe8pIewaDPOJiyu8PSI_Gz8FVOGKvevlmOBtKeDRv7TH07BOnet2Lcf5oOGDCZByNOECWb5olBepop8a-X1tt5tp3aii0RHSNmaEnHWOIV94htSfOVinION-fvNNqPeXtC2Hdtw66I1C-UWGDO01-jzYu1IVszR4u97Ej3XfgWXQ08nkIx8H_YtbOepTXiNMyC4yGGUbuxGkQ2H9tefphui6ffazKwdewBbXsuIbYJM3Et2GxAmW2HArw3Y2gbSDsDrREiEPYCcm6TpWiOY33mliK2HaYmcGNgcyKrQNqad-C0hGi3gdMgng4FIYXJm0MttCA6az2TkS3GzJbhXDhUsxPLKSx3XOBj0uUneBHeTYOivRyYLpm8j9EzqdVqfh6k2L4mR_KCAyOwz6TRucu5biyeu9_b6wN59sKAxf_InU3w3Bx7Zeki4FVNGNubrVmnko0ZYNgwM3qY27SuMIbevunEpms0mkefG-RH4bd8eNcKuCokmJQMq6Y92maHqERxaXMG7kTldw0VbKiFY1V4nFhNexegfTsxG4ycvBgRgA1SlOItT9iwQufcngKOAsylnts45LqkXMq3abtdTRpQ0pR2KXxAhO7GRxRE8wtButrXZxdQu_BogeN28whD8sBAj6xFFwNanV1W9CgllQ1mJSA-Yt9bv7jGUKjYTxjyCvmoNt0bJDKM_kmlmkmp0HgyHPRNog5e-Umw1XigKfTuEHb49hJ7i5FGKUcTRkJ8_hDvL8M8uFkD4HqBRBcBYjPE75yC2R3FIxKsnFsgivEy2s_4CrCE5f7jQH_dIsjFvLXM26r9mNJIP3iZAlzq7sS8W0AfLG0N4n9hdcdDailuKC2tPqEWezbfvNqOeVJaAKnu56PjDNpDh5z2C94ugSodg2QJwjuz2e2_aYD81_dCAG4oFDJKRlGZRbFw_hm3rttrggAQAMbFDUSWAD14y4tFSVMdbXvXefS-AjsOmkbZSltYj83GmCsHnWuJumtKltnD5TrZE1txD8Qeqr6lYevHrgLr8VNNrAIWHYPSTqiSIjUWvzh0HB_DOnwWUiqX1dyVj0ly9TqLEBxjZFkbM1MOR-1utEvJ1H1rg-liJgynYJ-XMvJX_JXNRryyaQPnSHFPAWcC5pUR69P3sOBcGiJvHMWsl3di6_XOIj1ZRd8tyM67ghRsSoyZDSoC01pcxlo6X7WH1HFSJqhFG1pmkNhT-kt7kqVSsUF2LaTCQLAYO2SeUWxPo5kPfrDq981naXBOeMuRNhTV-NK3bXVjKIA2J0TIXfq-7PaTTVQjdc9em2herNxUKfS_cLjrLZpy7c8Eh14wsAFyNyYKoYJww0PA-0rM8MCB3EWai2Ntba_jUtA7z-RGGpE2poPnM3K4Re9U63YzcxjF0I6QHeBt6UqzY3_KUTb-mxDi7N8LYEoYI-oIykKeu3lJGL1ElV38AesFXnLBbrWj-Cd7WnFa3p35AqE6fFj_OCEag8U09KnFh36UqYNyrSfPLvXwktdhrGDNHfVrjCb3IIchAvKEnHU4YCaU0uxOA9k5n2eC945XH8AUzxgLoqt5gj1gKUj9Rdj2-0kG6bMCXuLus2TfTsi2IN_TdRtT-HED8eFCLf-uasSalITA7R1-mxQg_J2mUPuYffBM_rmZCRPZETTL2hHd2vTmiB-47h4UiqMBkB2A_urpqD_fsZDRYjuBpeS0BBQ6fZac3tHiRM6W5T0ThzovOIcsKvuivsqi0SyrU5tm-WQ_9phglHgop11lxZRrIaX_HHAJHGE9Z-p00dLeNZfHS8f7sRisSAn7Tsjk2uifHRF4_tKIEPWZ6UyaoQ75Aln1Yaef9VWuSLDkH-yL1Aw2AUcZjhJ8Zg1vOUtQB0Hc6yr0a6MGBeZhRB3CoJF5NaCCRFnIiKQYd5BZ29i3fyq4ZkIXyYYcTR951vSfu53M2Eo5pc6rarr8rOc12-FO2jHcR1-O4w_K1L_aIxpdZ6ekRM0m01_T8wG5MAwdTiZnEvzfguDfEVQy2kIS4sLGSMhcKQPdH76Vt_f8GmSFHdtsMwKXbD1f1CzXWDzmbzHajbQIB1zP7g_DNlWhf5Wq4ly0zQqh7-FuyKhce2_6N8Xzvb9BNkEsjehQpZG_0-ijlTmt-XpiA-2ALmABzhI_uBMPbbmgwDtGiUoQeQHAO7TrS8_e32kZeCO3pwooHFa94yfiUbbrCuwhe8-ByCFBXq5ZYm4HKUjGZdLhR9exDPFCC78DqoWbMCkUZgENYskIqWQCB781mCaLhWvSnUNU6cIIfI33JPCdjrhahi8DbN_a_fOBG5Pzc2j3_bHKiVtv3SlzPLSrvyvhIjBkx0QQ26LoYoSfdmgJcdtFe44XELGa6RXgCplsjUcM6XLFQnAyGjHBQwxf20h1yiS_ND2l4-uKdWJgRX5Ktk1b9KakbzgoEK_XHQY-5oBCo0l668HCevpr4ooyQLrS2bbeN1nvJW_XzJbImHTHUAqQGlpFjeQlWNenQhgkf44z4enB5i7pC7BSkSc8O71n17b67Ml9PwZyjoc-8rDzAVytxAjgNRAMgQhWfV3DMZ2NMWHNWeVEVXfK5PQi-STDOV_0Z1jtQW9ZfOfVJji8R8hAtwA_9bq29Kv-64tWZx_WnbTI2Tl5CrF2p8JJ4ZZVfJXnh8SdPdB6Lja4P32EPe_E63lJ2ld-eesjJ5dUH5StbOTw8K_kIqNt1v0SDahv_rcD6v9WKI0Yhi3Sb1Cc6VazuKjsT0fibnbm2cGCZBVHI_9cVfx5IMcssnZZTH1XX6ueoGB1TlsXdDDj1nw8QM4eeydB9nlNTG61vC8QnJCTHCVbZqXVyZozlxfKVKm_124Ck-RXp0Vq039pbDHxEUo5IihkNnekJCsfwPp6NuJK82pX0k05CRWAkFtXilBi3eKvjQJ7-Z0hMpMj_JfrvJvdKr4dBuxCZ0bXmX1psvZ41O29M9IFxa-J_OBYPawMDsFOzmbsU7xkvNf9bwaNDYoffGN3JXpisFxZj1Kx1t92aXlPZA76GUJLc-4upM0z59dldR1MOEfx4ENT92Zibyty7o74yEFjz32S0YxNzXM7jfH7ffwKKjViziEBZeC_MJEfZsOyO0gLgezkPznizl1VtaeyMk0OiAZjyJuGUSRXwx0JoMZpVFzRn8mcjcKm9avaBO2iJY7REbrGLf7BHaTDAnPHD2CPfRvQXblx3D3PucyIbGSrrWDSTKPvRTH-e8tAQug8-d4kpsUJpJ_k757kF0t-wgVn5Xdk0FvU9ypwnAOXa190pnbQmhYSchkZrxpF5L4a9lA12EOVg5-lR1c7_2xL8rHSHItdK5H8U_wKkqRMQNWZbIC1Q_Io-28gMQuhiIMFhERdeLoF2i4G_nyJ-mcfZzy1HDWxsqGTU_FkUHELRrsUO43sOjHmOrt7aXXkZ9D7t_GnQO5N-9sZK5P6v7ESe-lZIXt-G5LQ2WAY80NhlPMT7h7rgCOk680CYgJNEmTwvGd7PD-5lQw-5ebiiDTJ0hzayigtKu7X6bG7GcrMNt8WjLZFtbbDHE57TZ3bF4hKeXH_TZiJu_RgUCaXK5W_0QwJxnxFGZXwd6sHkZlwOslHcYqSwlO5JVvdGRIm7zoz-NbrqKTxo9rlUFvSjQovH_3EBrtck3vwocFC7GXAlcC2SYdwEhBskFqDAk7Bl02U0QrQZEtllA0UML3J8FqJHzHD9Drq9W8XGpfIQ4cYmqInZSqxsJLIpUywmDB9HIwq-Oz3Empsg5u_pfH6s5Dh6IYpzRaPR1IQvv8GSMm3LBTCIi-4ZU6aE5t3zvm4SYRX9FDMvVtguKDVR5i1uvimj8TNWeO7SZwmKjiTGKgBCQmp2g0td2JJlvOyR4VpksJqeJIz7y85yDyCXl2DhNpiHYFKkMvAoJLoiDNhAgIXhV-bY5TIql47AFE8dar8bnov-6Vrv_9NjGHpEIZUcgfW_NZZTJm6GYehJ23i6zrC_xRTXnSS-4GcisW1pcs0hVNxqSC2_ENIlFQfq18gZ2QeHNHx79BXMLpYuGC6z7e3rfSs3SEDH4JQLGkNDeTNg5Zx7uOd7vyVUVyseNtDT96K8t7WRGCFdxmmlRa-ubDhO3oh6z0XnXVVMPi_Qzv6uoRxC-Ien5X8cg4L1dAqtZfaGQaoUIXxHxomOMKrZxXUwQiIncBxXbySHyP33cmNaXwHkdKyEbJwfvlo6cNbdQSRpttOA3DrXaVR-sMbpipsSpC4N-R5ImZHZgHITCMpAv44UlTBsOF4qgzmxYifzR1Bdx6GNUdad3qI3FDTm35gOL0ovtJ5D_pMoKTmB2p9n_3QosRjbuFkG9NlrdzNs-YAeXmwpWcZvAd-bHKxb7aH3yxAZRXs4WzZ3xW_DPj2FS_cB6HxpXq9Rh46qG2MPRtAqV7vRhjjbVhrxlraIewW7ZS8pof9jWm1OJfm-JWL-vWMAfEEToyhfP34fOQ3HsE0zRgsT5VLQf89EN0jmcZSRHiADWFO76mdRnywNkFxHY7qDqVkrJXSAH-nTAWJM2ksHX0AT2IbqoDV2Odajpe_fMwYhkyoAE9p-7S7P0sH8zCeVwRqzsU4_FtJg6xArimnbRsAoUzKxU0aOuzXrpPEz1fekqalb5gX8SUyqgVQk5gROhmExqD7ppqIS1Li-nUcBvKmRmGpdLBbgTJRwng04IZNkPLA4IyJxTw8zeT0Kimw5JP6LBkx5y3fuSe8iy-Zd1vir3y2B2S5D--vxN_5It_6MrQDJi1G5AnZ9InbQb-wyLttQmYO7Ry6andOGgE2ffgP-0N8tFz2z4zK353xdKCAgN0hpNf72jnG0uj4dPGUP7x5jCQ-rKyy2Yq1X6NhK4QwdiLpFpZ8BQoRRFGFrSLvZlIbiGHupjvtHhaQnjGQulO2r7gLLMzTTEUjkW3u0N4wjaZeydNC2hn_IA7CgbYG0dhKK3KuzHW_WUr5-6pqMP28Mm6-tCS0jze3Wq5FVvNt2jakb2o0lZOBVh9xqKIR6a4xnUbjV6bpL67_B75Q_h8RXLGzUDdizrhpTR2OX6Rzp7x1hdIUTdbNPK6_X-U1YufR6fCW_3eUF579c4z5X4WHm3jueR5parojAbfgfYA2Xp4ltcC86EYngmTF9EqeGcRH_Z0RaKlim83LYM-HgdF7CIgYag7f5AedqZn5OY-2F0HkUISEqTVVWVv-Bo0tKbXbxkrGVpnreHbd8RX-fbrtenRXTulaQwxaOBdDV21aCMw4-zHQLyDTjA-YWnPYe7hp_8Ci0sBY9gPgUt3GIInqB_wPEzR1GGExTM_hLL59n7owWL20Zi9bp1DFZSLjGlikhtKxEWg1DDB0xz9XHfYQTP0r7x6lYieXCHPrBwpC8PuYGSqoVHZO4erONSLuZvEYlnOLU-Y06808z60kUOBvtNRSxItbh2-HcmIWntvWh7pqdsXHumW3uxAHHMXxImFelKLy6fpjG9sE9o4we-jd9c4fwXyusMmwabmiOabUGYICOMqmOVAhdIAkFXeq8aWf7syBkMPL-ekejlZ733wVhILYWvM6IjWCSmMuZ_ul6Zg7NUSuWw5TEunGS8QAq_cnrDzJKUMYLVXKR1p80zJkjsLYVrwQ4LoWOCY5zw8XzKju7TsF-lmoOLaMksGY4yWoMT994aCGlIffhEhmVErAFIrzsOoWhItyuOrQ22qb68BAmoEIWFhsfI0pvUVT6tsAyasQz8yhxTpRqPz9lJHZ0Px4ivg3wpbakLg8DsIrDlg2sw0F7Z02YRzuhKRADfeg0z4omQHEnRiJer6_fAMqH4CN_O28wi0105QnonbVxDZYKfmTf1yDz06m_E1dUixonJ2Dkpuc72M1WaWZQ_YDnug_a4j5FxKV-uEdDcxff9DX3b9sEHkv_jsbnGCYM3ee8M9UZ86OyOuaMi-1IGDU4gRPyh5pngNJkdB_d6xBAomkQFJTY480fUsOnKRW_hy0owNl2DSDP4BOp_7rBR3iG3m6AFc-nCaGK1uv8BY6Qmb7bqucahvNHsiQmE4NeqE9XNpGmUy_JjN-JTlb0rV_5t7maKlFPicxgrgX2Zjaic7YInp0SlU02Qrxn9SORvjK0Su0_nmalfrtuSMZyNLdWF6dxXrUNyXjB6u2cboAoMaYnKJhAh-JDXChQvPq58l6p5wQhleg7107LXgh7KYrRoKM-6Fgttuag6u1n2G-DKcdXXmVMBOVLBtRgqRqXkYW9PzDEfCbb0MaxsMcEB8WNYX9G8XgqQtDKCdc-OCjDQkT3n2Pp9GuCpJpAC-5lZjociQh7JqDwJIImS2KWlPE_e_uAHM-rrZy1OuDXjSHWdMoEmnrwmrKdjCGDEBOBVhGPTf8GP1zTvCZ4OqGFiWkSfx58iUWG1P2eKSgYeaIXZ3OrAmdunnNWK8JOzxeswjSUBzOoxHQZ1sjdsJHGpisEgxK3gM8usrUc-WiENOQHBQ0JZpIxqFWXLNDmInzpW6Q1vCWhtkq5CJ1D_dn1xSawu67p1y6s0PbiZ0LQ3Qmy5HKh49iSM0moXAvSwTlWGqaaOfcGI-vTXc0QPdURbkNVIJqw-CfjV5Txwno3XQRnokDbmTZUYqrDllW-eBmM3WJFXg_Jnh0X7ddU2kCErvXeZ4kKFEVctCWR57UHGvAKxYGW6xPYppPfHoEoS_Z0Zi9iU4gpBnnwKlh2h5_YrjArrNWBR4KAArncQOM68geHAR35_JfDFEEzfo9nJN81ceKVDYT2x78aBZchE6ezZGKqPHf4xETfMMDCGYs82crYwGiNiG-MS_WLFLxpcR7TSA9jWE04GpBFgKHKg36sA1KxBatYltw-87nmYoCWLYumNxgiE6pXJSTuQlU_mg8arWE6lNQCp6Yk0-4idmA0Osjx8yrQFZ03fRH_ReFQOR2caWfEQqSMB0eDcikhxorLnHNqnFDoEf5F1TzqOvgNzU5gJ0NIjeX_9-iCOfNsxwycGW1mr34z7osJEbf7jH5P_nY66xWAxNdyOI7ejq-uU8F8AVta2qYAnlpIt361-XXQiQfrgzcdEITPAIJjJ3l4gdx8VF7sIQ_ys2rQ02gRD8eHYoQWtqkbx900-n4B7JMctK08nHHHrFW01X2xo0ptQaCu50CPWfUsVPpgxSTWMJgCXln_6Vo3nsIEgXXSwYNJ4z4Trm56CQdzUqCdd0GdHMiD-wyHPEXwDe-7XSajRv-ycfZ1av2lifekjB4N7oFC5SRGJl3u4hOYfWw7km2odgZzXH6tH72UpTIsShW50iZ8-ihL1G9UAtcwA37xGf8TwMQhsOQb1jyRCEJMk22Gop78B2d4sD0u2cDMtgr2bpkv_vp--U3s-PKcgCyQizhcN8poc9kOimA3ywKCpGzNsnipZHCvzX9jmvOoBMqz1yVOWciKGUfiNNNn2mXqKGR9rTAHN-xDnZdyi8E76A81EI2HkqW42QDQVdD0WKqb311trPYP25AULe-yP2wUQv7IZdFo3zK1TELfSuTmNaYFc72VtO8hGEcIL5xTXqOQNYM1ZDqRMDr7FspJMvcqF-0x6Hk_9fD92QValrfGUfz_uJEv22XMIdBq8Flza6jzJL3tFRYZuFWYdwhZSeRf35rinqIbWktOh6yjqflwPNipf2h-hnepQBTwBSKy5SbKTnH-EkjOtZoYRqEKM_qAoNhKwj2UWxWO9fFnNWVrDypPaQquguyEGn8GSnJ7AoWOmfLgerD0kRWixjrDSmFXc_LZTFSSeJzfdrBf_liemlUmNRlESY5thwsBymW6bzd4LeJbmu8-EiQGffNPIG6auYjcJjRmN8c7knHBR05d3hOI8ZrBmFZ5YLa7rtGETixCpvLIYVL2V2vOjGNd-qcYIJxDFE0MFf5zAZVxNzmMTVmp-sKnvpJG4NnuGGtWNW-dC6hF0HfroA2jo5yvOMey_tU7__zrzrT6PwZgVyeIWpykahU-pw4O7ryXxoBoCDNb5TWRcjaMi98UJvcB_QqzD4xENklJ9uYXdV-elZzV42Xw-2ye79SAghJQIMmeP9Lj5hoyXjwWARUyjKiOm_7Xse0pOXQvXWmZtpRULBU8d5uph3xRXwVcdmbZm_fKxsfGGQenDE05wkSu8eH_vWVkM_YBSSS2lcRPVH6gsXWwhT-dGtqr95_MjtyIW-NdAB8GPQ-atIig84noEn_ql0WYDhSIvwdy2Y9rLK_dyrw3LNBG6caBuyF-HYaLlG0Mve6UbG0WyY_38hFtpXBudb1lZ7e9A-UX90Jwcf9Ov2dv6AJ7vt6LbEIddP82-PcTXicxa_IOLeqm4IMooNQ9rDC5i5PVEbx_6wz99U3hlZM0B0zAgSVIO-stNAamolowa0_Q8dHHjiVaOmDI_2mpiIXC-NyAX__JF21dm0ZH1-uuYOK5L9Zvu-3MT_JSKmAwIxS98muKmz4Sc8eZfQcyMQcUByXV9PGtzAoT3mUEhnmbkumjMxX0oZZxmBJ4KlJ2_1ZiTlcvZNhqEM1K_LQW4e52gbURq5JSF6p9W2Hj3zl0ez7PInwPL1X4aiGKnkS80zitiXphwBX-c5wzIiEekPI3A654kCdiYYX-B6-L592mSNfZr_RQvJ_ssxV-lxgmV0QOq9H-AyuUpN8o9VF7lCJxh0Fxzi4gER-LUD3883uXr1iQq9k0II6PvDFlGQkMIr51AzNv5vSHV4y1g-3F72SeL1DtWw0O6wB6vvbnZ2Vl1F-DCiQBuyqBYN-ReSHfIc4goLEEeJeoIglvLV1MsHlvh4ijH8fvxgyo3FHVLWTt-15Sj9iD9pLbGnp-gX5pGOQv099C5YhTG3hO39p8rjsYpZoUUye16NBX886V3BXfUM0mZR5-HshyeGCIw_alsHYmUqgXMKS3_1bkVwNfndqSwQQt0vlMaySSf7EirVmwi-k2I0rmU4cb4fRqCS6TPE5aTS1XoIKTCdmuFQBsKQajo9ECNhwDlmn-bkbrKlBWsk89LlmpBK6565IktsvBcGiTmnMh9JvX9T63zGEaLU4ENEJol5yFhb8lPUOOWJQWeK_O5o-y10YFwH6P1reZzYLc3SH2WDh4E40tE-FkgLZeEh9Lf0Pp4Xl_BHoa2RL2NMxP1lYXne5eOB3qE-lRgByFV8iSm2fRCyt4VBe-_XkTockv_8gdTxUf4sKgcmpuk0wSA2e-2-i-t3HC3yspmHrfy0si_Qu_kx6vBvNVYHluz6DJAZfD8fm6HsbtQSkLRbWg-cJlk4Z-NZ37Ei4saagkoIta3p0hLZKj0A1ibZRAR-OrsHpPTlr_NTToFMDgaddkdoLeoZw5AraIJW1BcGNHCYCjCmIvmTmdo2gF2pmafEq8kpgSe1GgQyuD0j8lENbGjkKo2XzI_LDbj7vPbTYk1V-KWNHEBzk94zWBaespWgIl9atUTjzopoA8qnjkktCAVSaPmMgJAuZTpkqjX1USgUtLIu2J5CZGGf9RwzWvvQ5DDHNGoyw82GaWHurJOoTcikqeEMO8A174YZ7X74bZb5a3hvrawjmbMiql8LVrfOP7AZU_S-gvJ3JDXsS8qCFoXwyYRcVFClS3mkiubt2X36fQ0niIQT1u-h7naB17VIWIM89IlFF9Er5W7CI0-fQIka554UYx17xVve6gMyIMvYYvhnHKu31eQi9rwplbjqf3Ik_1zYFRJp8ip1YZsUz8jR-9IWUB8gb7Ppizq7xkty4JQS12NXhBS7bsd6ba7xpStawUHJlMLx83oLontcJOuCdnacafU7PRrk2eC-jB7KHlHhWzlhcdhAZ-OU_MeebpRZ8oAdGy6p1dSY0bEN-i9X5BKgAwtxGCahIbTLfum-CN_9mXtReleu7qgAUrzaLfMscT5bmkDIqjGInLBZE-klr1noZqQvFCd8E13Qi_gyFdTnMpwrVwKcBnWuY8hCXyVMVXfnhJlGiiCotG_KTT7Tu6BG95F6KHOrihYPs4FaIRi4n2HY9KW_7XIlTQ1ZGorgUvJFyD_1XB8mDkx3hQwaka1lcLZ4zOEEIJuyPzfhQq3V0qFjLiVr2UKyuyD77bXrvqs4-qrETDp4uX12dhkuSLFZxwh0gChVLv7eCcRLJsNhs9-vXPTK228lT0bQ4_37KnX8OeQhM-1m_3ewmQfXqiyOuEhVQKQVrdHutreeI1AnRLKTgHu8v9WZouuMlC_azpWxyomMVNBONPCA6GiOFikSMkXsf4UYKYK4xagjp0HJ189jMLyx-Zlrqjt2FhhlWLbaZLkG1OHvx9A0DWe9FhrggQ-eufQPYuHAzUNlD0TZQ5IDDJNpCJTU_IOqYnuorrqbqueMnt4ILIASQlzwXY5hyGArdDc3FUmFgeRd-zFFJpNhjwo6bnOjPAOCXzBmC2iPjXcjKI239SpIlp2Lq7Tqu47sLqHd0_Pov_DXvl3YYzUcBJFmiDDUBH3Dz4dlfuDpAT4hDh0bCtX-4Lufq_4fobW2r9CT2E3CxNbqJgTzPAjuPtNrBSbCI3ph5EQWLi7Qyu2q5N-ai5I_3HsX8PUl3F9wt69-puuUYQ-XNuYfr7KK99TMt8t0gLyVvUBWaLI7yJ65tnQJe2wp24a38kaTkbv3Tbn73O4bz2amxTSjJBLlG3l1iJws8xeRXbVcGNHHswQHEcQ7ma0bLjBexidCwMTZHp1NkTFdSzNmMA5AtCuEAlyg409VtFWt2xbCwVhnmMRaumUuBa6xWbi1RCmAvMJNpEppZdtMkjAu6JzwcE36w7ErKeBT5c5els2Vz6dh874rgTHeyhWkglpZVzqQ1ZK6Un1Kn76qSOptBn4LX2pFqX3t6HZLGvSF1Ok7s2VFQwVLoCy8cGuMyAozAuNN0pWOOzLcElZzK2DG-r9QF7Oh3HpcJC5jJ4U6qT2tmu4iE5ut0fdlyAbm20-Cjqmpq9oeg7bYhX9zz6RdoAWEA5TmOEp8ZPW92iih7QDF7JPy1gnsQS7zSdeHjtHDMw-6No5jf29I6N3NfgP3uZmzlRHARn56LjQSpVcAlpPsoJWeNT0b5dW4jDD7faAJyf-iRcXsIJvINykRKuUFOSYqGTlgGxT_o45GK0WmxXNbtzYGjZigvWT4vANwBzCizdmMDBqKPvo-DeF2z70ocYMV0dTxmuM_bLelPZpb0ffMHAgmsv-m2XoEbHUZ6IwQmtjhNeJVfG-ZkeBTFGUQDxYTqEDjKPavacf06ORY1CsQ-z6MMQayRKUX-Yt9UpKjO8sm3T40XInuonj6-46Q-NOuEpFzYc2opXSGYdb1MmXefHoNRB8T0-7-ijNmk6GA1H52cIEGiBCsylW5y7GC3Rx5ykRFO19ri10HKrwPxdUfSVATxbtnn5XsmUTNzhewTivhSrD_JodOEDX7HUIsG74Scv4mn3i-2PkYTmJlOIYU5p26LkRhwDEwIWw6Cz9Jaadpb7zVBlDI9q9kxdPe_h5EwDYC_BE4rv5RVi8tawBIACcAO49jDG9qIcZr-uwdW47RFLX2v0sYGcGvDqe9XqEs9NS-CU6hxHKaVeL3SSfH6X4flAmS7XTkG2qfdWCOw1y7xQCeZBuoEhtaTxCkUDch_H_fgc_VyP8cJ3CFQx3mHvm800PXlA7fWYlnn8Lq1AGTnVXvISiU5C6rtG4Q3ikAHLzyS_-1G_5ovfOeQsdOnGZJPMudjTsp0yA9hg79psjbLs8lAA2kmxYCl_fvIXUy0UcpFZH032fUHg-SzBPiWFmfDcX6_aFB80DfmhlVQfgQGLPHBgrmDuI5W2exzuWt-Y3fNhDZLqYwQzJIIWkU47p5uacUDuSgItqOzhYwk7nHkbNewhc2BHcBsDACfp5wuWdtyfuXY_IdSrbr-Rb62w_4jx1QDj6EVhupzwj6VQOTMcah--EviU3nZMJ3hb-cj0n9Vwowx9eHpP-Tng0d_eZW9uNjTUHE3WI6wEZSOUXT4u9FvTTI2bZv6iav0WwOEloei0PhJn91S6mJg7LTJY_rtrParKUrGiLU987uLrpkniEr12jLHG50k1c58o-BEDwwN2wZibjuRIM-KAEWUqeK_eQBWmt1Z-4XFoghRIow_X_rrWXG_qB7XBDKqEljcTZaGxsDDJOabqBux9ZMAc-ouUgQAr9olaitdujoE_CIqyef4S-jn1ou31aLxp0dwcGudZc1PmuAg_c8uxFJIphY6dJ4gy4lL5Zaoao6vdxn1ifklEqZ-Uoc8li4_B7e2Wcj-gEEtNa8qaStexuBLaUq4_9q_TBhDYyClKAPiucX4DJtu3t7eUDPsj1o-UkWLS572LqxW1giEKpefpqpHnugzrJHlnu6OgLcPHsc8yxiG8vDZ--1GJZpEQF2oLx8LB584DIGAdySv-BemfodHkB2XOvkTL9OqujXL7AdIOrK3_q_-1O6hFasnepR517IRs1kuqMTz1nBL-KAW4okOlN0FtHlkjvG0w5XJXCsCYfmbTzKiKu9-kxfca8NU5rE0PrH3LOf1XLZSTotEBzzWa29NtS7fZrM6Bz2xlAZRAiyuayFANjXlDaPQCcyOHIeEEmQO62LJiCNVSZAcVG4-zZyrQeVH9vOlES62T6CFj9_iBnmS8rDLQaMf6CPQJxVp_14NRkXMeekTj_O2GdpG6zDnU6YyhSRnd7jtZQUZn4-QVLo6p7IRXvXer_0lPuPH1cdWCtpYoUji14nZlPvxnai2A-3gNQbdrVOchYvIVlCb568hHaf258yyXYVpZcotGaI2QyXDoXMbiRwS6a8WHbmikWvuU3BLrGzX0_a2ONlTQnW-siGQiy2Dl6UYc-wPG7tUfjl2exc1RYzTNU_Ml1q_4HlpY7rKGlmYDK857QLOm7qedDcn9uJE9b_5rJYi3HA5iUgnYrl8RTx8njVQZIV0IUQxdaznBr53hE92B9ssoYnBCKEHkfiXE-4kPLC_efRDARvketggjy241cnqxonEVJL3R78qz1PZ6baL-o3wm-DJnG0piA_khZzJqo93fS1UDENKzNmPhqnkK9Q5RHZrMBq8luotV5uQDLJJnsUY-qxfsp1WeDbmCU_4Npqu9Wakx-TEr3rNKzie3yLi5ZAu0wClE888xw7180B_3fo0xgfXwDHoe_gX0snl6BLaPJy5SCJjWp-lchVqupkH1ZaYevehUmRCfgY4i3Q2qQPOjIQ8_7FShbAnPE_0I2MJHxEUTp2WEGYwTShWpRAzIZOrH-TG9TRhZvEDEkbzJQ_JqzGTZryYNXPBFvhiiTQEu2Z0MkPsRbdkYFO2QVt5GiBhfSJ3AZQZwM7Lho0vit5GNe6a9VfXnYafS2wRCKBWQbWXqVOu6UQv7UjtdcblH2E0s606kRSmDem-YiViehxLzdkJbkLxUz-cDKRRmW_W6jIStBo1SiO2tnp661x15u_SvGvy26G0WkVqeKD1-It2_iDjgWXWeBk0712yBvY5QIvL3HO21wy7nPYDa-caag7ZsVPcx9p8mrZWLJbZXopIOVui4SQTGZQsDqQ3dWKOZHbY6k0DDFrkcSY63V1FwBGwswFstGBAQSSa5qExeJEHm3hPaw8UatMk1pdlN9EzmsbaZJlevsJR7Zb4yJkVNUXAm6A79YsvLhavaMTEsl9xHq4wSrCXUqtVyGmvyKYAtRs-TOdsDJhvzwzPIM6sdfFKp_IJQg20aCaB5FhTqF8kMxTJk48AfcnGELqkff8bCY-eX7LlK7TS6IRcriECsP8VsNCiUPrIIbLomHnY9lUBLFfbH6_afug_IhbTnL0QpteLh9bdFzRQcdVkkkLoHg10o16VyWSaiMQVxD0CG9l_Bs6Ii-PmTh1T4RRXXv9sxZrX3wLtS5BLFO3G9rSurLRQDO616vFt3JMQn7J6jmLpYnvayExLhrSerbOdz1zEU9ChK3NQ5kAToNuA4Vfec85S6goamC90KCWvVH7WECEFCAsYL3jfcPAoKbJKXYRVVK2VVDrBqKxXzGSB3OMPGriLHx-36U1i8qfQrnW_dUH0shMD5ugoTxayFmduFKxI894Objs9N14cDRu4FYq2niM11WFwRyZOSeUrkjZ8ONl5xID1ACTb3TmKIePjjJKp2Cr5E4q9ot_aU6Dh5n8SIpXcli75sWRM1vxU3wvcIWtFdSg4vWsD59RbttErgVvRhqFpdccTZ_d82NKobnO8JWF4zROTeCwjW2UzJo37GPbFwxTeTMNDM2qJJEvhD53XbKFYo_NI9PqDuP2kI6bv3GJO0ZPAewfwbHw3QJuJ8GolwSlQZb9gkggyER-GbAMBIhdUyPNJ0VNNs6c463wpx9XZkjwBQQbnl3zDUZIG8CrRrNuT01jERPlvHC06-m2rAcMZ5ftR0Rmhny2ijF2lsp9NBl8q8pBokq7NvhEuCQ48eJ64BfFa1FOGGgtJJortm_bK8ul3CVxisNbIFIhu8JARNmUHLS0Fy0-qItmKXLcHMFk1jgzirsuw9tvnV50EaCrtJgQw8cDT69E3YfYTLbSvlQZ8nYokOPJVlIAfCE42gqJY3CbI4xh05yrH1-S1zUAobKgpS9v9EaqG10jbZ8rrNfKo_iv5_0OWV0ni55Pn1uTeMCaU4TMrF-vX0NHpHI49P0c1e8tkyx5PaBgbYh4WOnkxgd41mL3JnIxDYsXsxK2ZmDGP7X7pjBOHhgUo5vcUU_GcuSsKvK-vYs0VYo6GHMpkNHCMC4R130JSBamq_s4ottsuU2kXt0lRMqOye773OD7enAaHQx1QaXfsp_Pyv1uEa_EB7kKQBXbbko5XC0KUQCm_lU9gdQsVIWWyYmMlkcZCiDTxlshIRRS64JB4nfxb0eXcxavAKH3z7xqMHnIUmPjK4bqRUguB8X4wTd9w3ihn4h_o_Gixn9PMUd6srxD4rcMWbKnMpiUGcbnWqxuGacL899goX6JKzFDGoyl7zzk7KXXpKOKoMWg-j6Ykry5zdWRMxqiDAFInZplvZGHhbkH55KRkjbYH0dRKZxcJUvrAODIxLNcalPgW77HTFcfomRAp59QUi_hZk_si8XZH7X_Qt-B7s7TMevcdykwoeYMWm_n0rSZ_BFWTCtq0veH6ODMRXlEa8qeyKZBntiGkfywDfaOSMEPIxdD0OIRhbsP6M5IpSVVmJXaFc7m_ykHQk0q_EoedyLH-DFojzr30W4ZQfmDlb0gup0IBXBhVYbGcbccTKO8LeJES44R2qF5TCqo2O1RO6N-Ldq8tOpM9XERCUfzV1-6zCcbi-tyCdUxZkMs66-F5Z4altheYXcwBpfM-Rc6rkooxlTosIFMgV6I7mZvQ1aKR61omRIH-uf-McGGSrylxQ4bdmn3LbeEJ2MGT-4RvdFAe1JqGKiU-mvSR2Gwtm8rVYMKDy8omGfd017bEGvv95C1iuk3pAwOyQoFwADhJD3EZAJc3rqoTBxb1vX4Jl3MYt4EjKE4B2fF_m-XeJg8USNTik4JRur84bNEpHZBtLn7ix8dnUynLdlRj_l8FCbli_3U7H9o-_IXCNH8bOc6JkJIR69q3th8Lrr_xlgtJpHS5n7HIql840IUXf90DrWmxKPpLrJpJhH78FS4290J6CIfGDkvAJE0NvAV12PqrVlkmlHvww5468PKX2RbKFNfBo4TCwUwtCYBjQihf4sVZZNWtABD0Ssbgfc8HPIAlPlfIFvIDvZ6rm6hL5YIw2NXzDYXLZUFb2Gx8oFBIqfVOoUwPNCTKt0KPN4bww32ydk2xXiE3e-3PcZFxBLw51sc9VjY2ALu9pVFufRc0397bnHYVyPV6NB9pES647AMpQG07pmE8jGCcXJ81k44w1FmM0o1o9urvgPpgVb2_6gaoNk0gQumDsDnbLjlcNAzov7adoFFFlG_pVg94DEAJUTRiiOti-ogPfzih029Zo_3WL3T2HG8T1B-AK44IWbebXE82djRlm32z3mRoYcNS9SAEV8OJtL8tP0jwuTyIk_lHYTPUEeT1PcvptDTL142Lbyheye4Bd6SV_D9blSWOFKxqEeGEq-goDtIlKtYhiphEurzNOCGmAynkHNx6N5ongciTi7K4g0w3LdZWc_-ELZ_tFZe3T8bkMJIAc_e3qg2AE4reOUvNU6q3kShzc54sa3JMaJ0cwFUyEgm3XJ3DL7qi37fmkloVZLDmaYoxudRgXzj-nJObpEmzQK0nzBMIjW-yFxxNEaMgkfwriBQvIeHhFVoVwkt4ZhkV7MhdL4cT7H639zltvgqSxb350omqmRo-d6dhXBD2oLVrDiRIPKvfriAUJZ_Uq4qHW8DQKS5zIgmZxwefCa7NRxc3K6ZAnKT5B8GnCz0Z4nEPwvXrbQSplfq17EzdtRy0EBqowJKOKZ9w8sJnadWWoBCg48bP-uoWJf4REtQL1CfaMII5KHZ7lO-mJHTXg2sq9nyLiTi3Ueza4-YybgxblW4Z1LdpOPyDO7sEJg7pb3Zedaxajg9RDcr8FveQAyb5pZUKqlkI8Ba12TOPuQaGJ5wY4LjSc6rZemET4b2V33I9zuX73TMy7Hik82tOyu1b5s2dp4e1upb3rAytZWKUuaWBp1nRJzO0jh2schkiT0iqwChznMTDkQqwwbgPWGBBlSmwwwFu1HfC0SsM9VPKjLhBOKjWFEQo-8XpBu1uDvylNS7aXIjsPWLQTkTjL-FoYr210Ttrw3Bxk-3Wd3VQuc4srqA_7UhTSXPbLsTEGpwuwtptKF7a8XDfh-XhOmylNBxfMHKVaiXoj1mqROxIqyTbM0Jba0yw1noIbLxLbAbGYC9G0OVUL-HztZH7div4TbsNlPtoQqsitv-EjO151hRaUL7lgCcRRSf-UafYuD2u_5cpdbyyivG8Tv-FyA9UfqO01XT28vrUtSEA9_nDcNFunLSffta3puDFn8quMRkZnZzZu33ktb-Kl3rT4wiGkCucP5I9hWjr2lt56I2a09r0PNdQaMALYBDhuOAYt5kds45EnnhXY7tYe5Aq9emW6tqvv549kEimxwe6QYQulPSHZLotX_3ZGdf5S-K6zrfv-36qknZelW_McHIXbKn7nkpQyTrco08Dg9C4cKF62o_hyI3SQAVVJyuwpvBEnlBQcX5d37PZfbulSn9wTrYNNHxymmvOUIQ-vC7lPB-SF7n_3J3VnMVEYdcIDbfmAN9P72XvDEJUpZcJ4coG3-6JTREKh5cUuE3ldAZVwApRwFTVMw_qdjQ34U4iau_BSEXH-rdivYmk0Q3Ul4iHNAeoFfsrEDFkbIPljLX7WjaONOSRZ179t6xLZR0dT-7HVb2CVSWjI6HUis_Qz7FzZfYrV-9M5q62C2VlJNCGhIB6VCUvULEoIRoT1PIdte6FlYFujscwwHW-IjJZyCmULoZfI-vT12rvzRYXezJOmlf68DXMGVZLgrK78KpKDiM3SVfsDKBozMNw-KnNwCJXOaYJWN11FQnQfvY_2rQD0MdcYmkD3VOcobbfJtDcKbqwqhj0lViamoIcBBSxeA6mrUeecrwcH4dOtpIX9joNWdLmlaSBKzZd5cb1Sz9tWIKV8CPD43JMnci_Bv3rzuAUJc1YV_dLqQAUFBFrQry21kj2aoOIMXTaAKht_2553RmpYQo2qq4pbMI6KZsKTIiab0H3OWyfOpmr8VrJy50GXGsac0yAQEvYfF8PmPP3lxwyl1Adc6xDMQVO-xBSxN7qSWVrbeutBUElhxRKkBJqufJFSoP58z5WAuhH1ayNXV1fEAz6DPG4eABgT7NqyrE5wn5F5lqWtl41crOgeN25aB5vjyvDCKo8-F6vhu11qF_YElCwSLPlIOzBgE8c34ep1kbYU9FwphaiuzhsZt-jktymSKXBrr2wpaaREfGKBrVLZHpncTuHikbkA_7zgIsBuEFizH7g9FXENAkc8WPqjT98GV6qYkK4V39uJaMkaGZ2wa8UwIPpBtw4ehPmfgSfe1Iz9OmcrLmlQ-ORRFrsskMidKtOWD_blIY4YtO4g-aD7bEcXHLARaGVHu-W82NMz_Bk1I5ew-mkUS7FMrNlx-yROOI3L0CaoBaYRosSumhtfnRQwscaBeOleFJJ_A2AwgMifm4aZmRhy5J-MSs-9EiYbxEokTdQBH2QUd13UM1gO1NfwPVNys9qaYllbM0lRhSxWrUiNQYO7aCNP6zA1qEn0p04dkYQuCH_2ttDajWWEQdQBtiFUeBEHqdPq1vS721ESAJIykJf1YihJxIOl8DJjHV6PnxAFb4M7kvGJmpQRIoriI06lm-eQ3Q1aqAwZUCL7NVzTfAuSHBXzWxmfoZGDm8rm3J-kCeTi2mahy9tuWMd0gBKzFDNmpK3P0LNxJZj7F8F_JLoISbQFvLlfARNfzPn0TmIL8dsmyWWJQiLHbW6X_mPdlTdzP5O-6o-fTJK95_hQ-qh6zF3aM1fiJPpewU_hLN0zAgatlR-oJhurHng-pNzMdmyd_1k-Lcln4pF54edoGg9qxRPf8Z1X-zofkpX-r1Vofiiw3_GHCWXeGtb-SWJzLOix3VWhQIIiICbu3DMS57isFbIc71B7Lx-lxQ6qXciBPUf4LK7HpIys0dsN8gshmuXv0OsXt9nX0_9bhWDp5A6DsrvTIy3u8nkWDsZ8KNuN6y-1or_1QLXeQcmIUDssRDEPYWApTmw6Z8tC2QjvDGlWNRNdzsrqW6wZeHq53S9yk7beyCbHRc4Idj_0pIa_n_zZv4pCt4l_QId4albcjtTAmWacmd5oetVmmRCXZ_RBHvpMw3SpsoJ7-ig-vliqaylLo4pPMzFeLKQnb2M-EGFgaw8LoDcrg7UX7ctMB9heTKdmFB4f1HD3iRU2tlmjam5KNkFcdUJwYE0Ry06njrXJLiQ4rAWH5_NXihS5oFMcGO4HKKmvkB5ciTRqCeDCsagfmYyIY-QTqTvYvJwjINc8f6ADcpX6zInuLx3u1OepyHD16_Fbp9NUX_U1EV9z8wi5_4KQAkqWQXenKHpx2kX6BEXiGuLz_ua2v1gL7S4CIfTMvQwwC1uEznhPmYvXvUauiuD71Iod__n-NULySR3SNa18NFwqpBf9E8EwA91cgkLNSr2ehzIGjxKz7aDdPX34NQjuRNrYQQBvzbllhUc1KhoYFHESGnNiUwJQ3NdhAy-ytH3YYnvoK_4G1UJq9WqgMPmvTctKw9CphDH7PYafpjAjR3HokLBQn1b98p3A32etxpvz0CbLfXQNEhP1oA3tpnGx9maZYkTAg2EBuofrWitch9Zfbgu5lRYtKiqLB--EmMRl-nJ6DWrvS2UsMXYSwOTFEi2c3POzswMXp7zN-Ki-f0yS_lX4igIus3ng68d9nPA5dafR8mhHd1d_avMln1H23rDs2nvHy7JUvVQyP8MxVpWdYsUKyEqFRQgsCQNbLcoV5hG1-D2jHuW2xQBYFg1xbxFI5zlk8QhQ2GlIX0XuoF5pLhU1THc6ywlrUob_JszoJDV3t82umNupNBds6To9sj7VUhyR-GOnWZChRnKNSrNsgNI8Z1DrtQ71OIoRl4JqYj5pBDGBDxqidOkRj2EqGrpB4oyt_mAKQkM1fi4xdXmpsbCLS7oudfJhkAIo34a_Gnn1m2Gl3YhhhHLpzAj2UN5ZFoA3bsccSJ-l51EoA2YAlD94RZnWbktf7iyuLsCh_rpO6xIs-AeGmW5badAxm4SAlmURdlz6M_JFJXexs_YyYxnvAQRNwyXAoHLsJghxJpX617kHv9ldeDKDjbgZ4aCTUrkLkzH9jXT3CkX9CHIX9ZVxgPCznYZ84NnYLSZZAFzbW7IttTwcy_5rUIxIALy2t-OOSJnz8sGKXOAJTVnasjg9W803qnEj3jQevwEADUZidnBFRPv74esE9fRD7AxKAMOEmkwfpOi4XDD1bFltcKTG3e7IM9IZQYDI5DDVMcevImvKeC_nwCgoJ5lGtrEYDkBe_0Q9IKt3MYk7urlf7ZKeP7G_X6EvX7tUtlDSlIo_KHGBCVHlHjp91cwD0dTuLJmY-JELWFZjyObKCXan8OH9B7tknmc1OxGnd9I3gIoqL7j4LS3FEZqKTeBbB4HPtW7AKcRXevQPaoeeAV-Q7cNXlfIek8EmRwDyPAMBi94rJHglIvkWXuGRJO3lCaHSWOdSyaajiiHOuGtZOeyaBYRHOGlnXPd26HRJxpKk-1kLAIDw42F-TIM40QE8uJqRa50QFV4BBAyhLYHiDLN3R7dyhNt0GnQ2EalTuzBUrFZYAGMFl5ocY39SpYe66UfYMA2Z9npDpUfvim72_KKg-nGFtFKra2_pO4Go0kLrRF6dNLruZcU1OPTj_O_m2kOQFQrLpkhIMju-98CoWPhJBZHx3NMRSpuDghXbF1R5eHjzAAVO2_deVcDZsJx4z6pkcI_7p5v9b6mcWUF_FfXQZK6uyTqnuUVMA9iGUxaLbC6W9By2kz8qZBbY7aAZon6p97tKyEqLJXylK_JIHEnXGrBUOJHZfDsir3hyAoWbVRi2PXQmJpBljVIGMESnZzuplBIQk3x07c8ibaB4CHZ7RhP4bUuKWAoAy385ddazr8QrJlDZepjAUz8GO-jBLJcTTdIza7LvJe_ZtfZ7euMaFy22VqZEy9BA0rS71GHoO4NKusDGUG2kD1VI4Wd21bL_j_MIBK64-GUgSX47pYMj7XgoISess_0Fuj0fnaSIHl-OUjyxVCBnZQM6_HwULPrJdp833he9ElxkA8meO_AKfvO6QNNWI2IK-QDi_IwiptalvYgecXA7-ABUDV38wO381A2TJ_K3z7w8e-30WfPXn6g46qTMWUYsHFCdFJ-SNvhEQ1MbmAwGsbfenTuXMCSCrdfXqR6wJkMrL-8akhUwnpZjjNvKjGsv4RvA_JV3P6nGIFxZyDQUutO9aq-aM4zjW-qBT0cWe787K9i7exP1s-SMaLgWSZMaNO0kvPtCfhx-_Lo-erj0KlSVejI9f6fTzsuLVcgKJHgfscO6ADeOMioSosbLx0CgwiM3kaN3MQ1JnQVpStN0-DFSnzEs1JBs3c4o2rfZnkJ66HvFpuKiZd2hDAsU6e7gSyBONjuLIDluB6T-a5EVnsb7p0J-njmqUCOYDs9Xo24aa3KXCueSV7S8Ll9oG9JH3wwfTP9sOJQLJoZctIwlZRzSERHkOiPU5IaTxsHR9kw4FSFya_LulpnxIfK5Q46CyBMGWjR7MDDO94viByAH9j38SYQYjXiYg_Pyv9Pw4wmWXZZ5LpUWlI9vt_EzajVUy9F12cG3LYhcab90nO4i1ym_XPvl8ncYt_Ee8FsG9TIRCVub0LoD35cBy9uGGJJhs22lQBom0gZuVlaVwNI_mrD-LHLT_HhaR33xp_1yCVZBe_wGSVhXVnRmPiX37joame5-PAQCY3WHJyWciQdcM1uJ4p9z8re9Z3Bbvz033BcJdi5uSoq1U6lOPRF_Wlv8p9w0fTyfHEQNvf44GE6Elq3lAX8Ax2Og7mnImSn2cvMQT6WPbQM27ebvKP6bwtQOHI26eRrvQ7qYU2D7FIO70WP1uLYzrJjWLjuyXgzJpXyikLaSWwb-HTjGbF5dP0PyCV-_oO-ChL6I-lgQGw6fQu7hmb3UaQvPugrSaRDhqCnZnOxVOAjzJ2mVI4pigs0GV-ButIfoF3cLrDvFCZMcHoN4PU3ec-kSY8pMTvSxtDW55BeXv1DqdI-FJGN9vjjTv6ni-O_YQscheQzLcqc-vvsl4QLa20BHiygdnw6ddVr7ik36WWNNgG4BxTnBZKkzqwfQ31Nc42FWRHEFVUO_gk2aJTvRpfoRlSlvznEhK_UF3R9e34foSwhmIl9swP9yZ_54MD_RapeoMmXvlsmrEU_76mVOjBnsjoxMkY0QMgNq_rEG7v1sx1fG3g-JvV-rhjU0pXLocz-jDHgsyetAY-6YYetzWR0Cvh-8QuuJnJCYV9NfTcZdIkNASycyWrKVlALakS-iaK5Zx2gGda2PFfYId3lp-JmzbHn308CZC2J43OIw-FeZtjSQmcHiHm-D-X35Xw_xyTm7peJlHB_LlD61rsAbCNt3Vr7vnj7ac4_PlhzVhxJIzVJoRKEmTAOsvUIRfRTUYnqNLswC4V8vHcTJ1id2tkUH26kQn-ANpNkuYg_OhhM90HlQAdYiAfVopo3RizxvAHsUXNffYkB7Fpm9D3PvBFI9OJ5whbIn0FCuGSD7OoWKTZMdFGsahYqgFrS0DRUEOFD8D-9qdYHJpTb_nTxk9ZI3gN8pjOWJlU4aZq6tkBjkjhTQRFDBR4uxLN3WuMAs1ICLNPIBuwb91Ou_mVAmuTe3U3c_GlPOypup0jiQQ_pnmoFyb0DeKVV-hNc4Kpyrmkovy6TsHQ9fslcIF1KMoLUDUdifCaEke7V7lxvxo1daf4QTNFHzhuf7bzZWbdBqMxARD5niXNP1Cs3sNLdf5UI8o399f-Jb0x7h2M1M92ZvyplLw2eq3eG2dnGCShf0aEANGoAyKL59Ge0NMVk6qkUsFvf2clkWyzwbPHZvEOGsD3YdaamXSRlnHXza2vbVlKlBrknlWms6rcL5fJDwXmVgYL_GVm_pyxaoqblo7ScSmK6Y9wp3z5Ce9KAWYbqseCKP7nYMTnCnxISaET_7LlRsNSJqy2kizMmNhFwXCi3qtNWKgvbHrPYSN_NlZs4egRa1qKNIA7VTY_eVK9SuVT6B7vwDksnQQDiUi1voww8zi6Am2jHagkFWFiyM8OT7lKgEuLgvENNeYSdyagDoozwYSHKOQmdDiTFU2gIs-EyzFKsn3AwIHaaEAAbDVambxEsHmTf3c6zjQh9R5BbedU8AST9uO2ayCLYSBG-G6C9GCU1DRXsJh7b0PTqxwly08zY3k4Zu19dBDRlpSXqtPmszIUaSWG3Sg-cIssP9iM6otus_WhcLgmzSLTBlXGFkS75sHow0UUFxePmFvFNhhxpfgj_r9ALSP_65Pcx7j3z_qEgNnOSSabOPca_ahRmh98ZCyTw-vxBCXhVeeqG49prD0WQp8n6TYkfLi-OzfHW50GNcrjoQW1UWKbVXGTuNhLfNs93UOQuZMG5DkaXVjADOZHK_z-jQi7Tq20O_7iW1KTTkAmHivAO44zRC8Ca0CXsQweKoUPPVR-uUk08FEdKbqumOONSpH_zhbm0f2ny1NqMlVKa0jYp3o4dS081JkzR6l0EBnQYHdHooJ1Zvil7w7xwVRWZMajxn63BD5vIfAGz2lB_T6pZIA2iwk5Lt9PwnQomuz5GuFouhwceZ9D4fFim7G_HqEsbyYmD_49YGkpRSX7OBz8LMe63cQTpk0bNEImFrmUp7wNKv7qrdCWifUKbaFToBxmKlYcyz-CzXPypVKZYBSsqxXBcT_ksEHbjTG3YAYlAwkKj6mgaDBiiYzXmiHmtGVa1b_6wsXfL5tJNRq_86LSxjspCON_rT2yF6nA15xa-BWILO0Q-WydVfBTL6w56N2WXr7bady5VnTQPNojb-LOqc3Y1FLYbVHC2VoZfpMRT7FAYr-E8p0oTNIUI7BZNOvJ7Ie-uBU6ZuYVAgfzYpIjHe7vXjjudY1yU1nPH6TVkxptCTPGooiXRh8x0sQCYe935hexZ5TCSQlumSgTfoClRS7KTLX1XpgUHfC9qu7tPQGWPEtGB86MF8X2OKtpo7UwUXCV-Z847mHHiVo0tvGrQnntdOyJzTe9gAK9lNxVg9uHu-nLUS0MWIaBJrk7INd4x1VU_j8MvpjaqNImYQD5l7-srPXn6cqXtOStG4KH9V43jVQop7hv-g5IxhzhlWa8pq3lFwThI589gRJrtgOEwJ0xZ3lmOb8lgH9db9wgts03MqwQJtZgMkNTjQ4-EAAcumlLA7GTV46dx6ccXX-8grDZRAJNlZS5Reg547WtUTRmKR55QtM9u2rHQc2DL1FMaU29vRFZyAAItXt9JTPLvBzdfOs3U5LQ4aBp17PRpBDSstjMfQqo2-B3GwG28ggGeKflPQ14lSjnKULRd7w8aRzKQ4uvxsen8gw_nlq6OsS7oWrwHXy34nzel-DJtamrRF2d_0PUaZsQFO2dNvsIS-suu8HAg9JwPtO7Cn8nmBApAu0WIwtsmfFfxl4cBMv2lJkzeI6emu_rgDj-d4H-irtZhoLl_bqk99RNGqWaZuPB_cbSVuJrf5u4H5B1BMWEpFt34T-MHpTtpRIDqK3OXn6gfifZLuAV61j8EgbVvY0FcGD5YPa3vePALUbdcRAKyOSGyyDUhvhfb21hJM1Ai5BhzF2bwmSQatfQvOXrR_Yx9rJBJA1sFJ3dLVH5I86s0rxmb6sCvs2vNFIL5z5LVj0gENKU7LcqLGHHHD1iOHZ7W21NGvu7KVyZrl50_K-6R1vd13Dzp-vJW6PJRI0ieKmirW_evzGDQc5-W_3juXj1wEOOFTiB72QUQMRDdLXQlvEuvHYKBidGCTPK-shOk_J_ZAzgvXegxKZoLzHFeaWKFKFtlXnJUpozEEYrQGOSJcB0mi5b3dNwNN3wrslHJKH9flgkNiinmNC3QAprMeEamI6nuwT2yjmtfUFq5xbokGIHbyrVXcyZrq0h0DhkXC1H_hxpk_RmTzqRoPT_Vt9IWWuOP5YLHVvQ5Q0YoTmelo9MyeKLH3jBOajTTKxMRHtCh5IIPdMmO2BwckwKKmSUvvwBMsy3kw6mJz1mmtGtxi1GS-K24CWleq3jnwRJidxPrOXJUwd6sjWq6GmIew756VI-1xlTRx0CIO09BZgeiyFA-eF2ZFMJcht1-vZFs7bMf1Q8YzltAFR5584M8eyJYFfgETFrQLmwpLM9BdhPt2r3yDmG8ADbqJT9mLodwdzqnYw2XnhJQHLqcaOuF28u-HArU-UM35FvKi1wBJcOtQk52NEFfu9ON2A3MMsOxS3rAkGPA8ZxUJyPf7vGI2MtI61H2tfmbvSKa3mpcjgQGeBO6atWYZrE1aGwiNR_yRPXw017FBoW3VvIVhy8IfGiRjF7vDu2KZHHBFVL3jd2x2M4msZO5hyikSdtn6X2MiRsJd4FYIi7kxFDvnpXZsI_W3AEyuNPsGkUJ_Yf6diKexj_5TsWtHiIP7anRVUQxck0LYKHz8zza305ygJrfHVmXuAyQd0Z56ACAvjM-aedagkWKoovJd3H949p2cIkpLxqv6dYUBscBlacyL_ACeVjoeaNJfQA9sM3H9awLMKq3T5XBna9KUIF7Mxlg4kBVhHRyPm4YI0U8__R7bxc1h3xF-hwYkg4pJ6V3Mw_tQv3I1ILYQvBYshlYBeI2ZeW4QfucaF3jDtARiIqoTvpLaAAYBhjnWsr19UyP47Hp_TifIEijI23GWjeGz0pvGtCTyDo6KIhByhhGcB66jn3vRm4-RmTDmul4B9p4HFamCVxVnOonkY-3swg-uGRwq1NydQGDSgwTOwooah_O1SpRmmOik-JL58qemszfhOCxFREemc_So1HRzW8D3TgdDS69SvPC8U6l_2Zq37Xk-uGXZeIOr25Zvh3gkkxyW7079ZAySJPTGIhit7rU3v4XcVUcsdJ_gg7vdMInqZFBlSH0ZkTuPOtUi2ApU7Ycd9L6fVY9jWGYCrTphIiVB25dNFZdAg0hEHVnT1RwuQgO76GL945zEeyn2gCfCf-ZiK2teIsJO3ypglUKmsXGPKnj9DsEqFECWFA-frFe5BF14k3IbGM_1WJiJvXZ3jetFAI1v7fNm16W9Gc5yBFyKNUwNbcHcKFqae7htKJvz3LHefFby7YZ1U6mOHEOfrcDGwY2GrvR6cJxubE6d7coKLEpIoqBf9TyjT5nawqcBeZ3XemYQ53llOxvXBj0yKkmAOCWcPdArnuhYpgicX-VWB7MEvWfBTMIBXo_CplFo2-MopQj5jT3wY-L8LiZXALFRHbxvPIp3EvDuPPIVNBUlZKxHuM6UYdE7nS8wxfxy8ztVz2yzmIe63N_RVDk5HTW6b9H0f18NzN3pY-fKzeU9T38tLrA-LqDNJOlYXlMQKuPxDmeUso9e_7_KnGlsh62xMwsurqrxbn62tjIIJ29R6N7cdZxrhvkE8yLSQyU33XUzZQXK-Tzbj2s-2mFSmYZEKvL6a23Bv0pBSlfQua0T7HfJdI979xPZQ-PkxX0y_HifNoICDAcrFcs4HghFppLWSlw7rY20v1SnqzXzsBFfPaAizJV6PRn0_xkdF66wv4gvyvB1qhwPCgZ6ij5OP9KoIsuSHjZaMhAATjO7CAt01R1haOGfLK5nzYpw_xQJbP5hGleSZDNOhq3-geEbonhfl9P2nYKH6UuRuRNoao6dRqEN5oWyoqVhynCcNVpgHdVnLqjyDtV6gL6Eaz0RrXFbc7OdspWkT7w4zRX5g_rM8gZSedJ7aBhnnfz8-c0ehiXdN4eTkOCITNCz_AInUdky2ZITTCI5VUhwBaFLBEahw239GxOZLOhB7ZMcq1zHtcp53wPIsJOZLoQC8V_JSjPSsPt185jxlgfWt5FfXeh8s6gybJpklzv-xb7mdo5x_yV4oxZHNnXAi-RZkRW3d4adxripdLLq7yayUSdY46ETJuFspgj3ekWHoeNydQRblNS07lkrmBn55uD9efsCcRPxN7S0uGQiiqakDVnMZZj6GeRV_kV0c1jIAFRQCCVCMvzyZEH97UL-lm1R8SL-XNeheIsnu4uayKDaoAtRhSdTN1mdtnF_RrhCRtA5oyDgLwHRlLk0xKj5QClfrFGu71ds2BjDy9vCgcDtAPsDekRrjx1WUByCpfLqKdd8s18wiFVbENKOrdUXGpAFEBJXIp81KMoJMoT3mKpXliq29fRji_1D_46V_4CrckFt3lcpI3FfUbJI7YMBuLP2m1U1jW0Mekt93WAKPcUk2Aba_euP6TYKrMixrDwA-jxKkUSMw3Cj4VgS0sQ-ifNgM7TLfuAYhTIqo0YFUKIyvEQWB0cx72mu97Y5xzoBQ8M4U9ft7NgorqSLh0w4VfnOH5QTQXwrBm3eiGf7fFuiIIWWxUGGh118hARB5tnaPOYlo3Gl5s661pisU-WJkbP10rnVvcsSh5dyLriKd9Vvi3fT54jXk9Vz5MCd2YT30odnKs4p4syD2b2keu_KdmVkg6ZU2K0OsrOboHhqIOrma1D0gL1Y9ouLyn1EH6W79f_1Brm8FFQ2W-wVaTg9zLjxRpzPyUAOa9Rtyrg8jX9mB9nkACK9T4W_qSqy4yJRq6HmnyDDDYdU8s2xs0Nr5BqSxfgriZkFg18eytI4dcSykdPHNTRLZedqTtR3_Fcl1fNeln9dRVaSRM0i1N2WElt6WQ9EQxR-NUKK5L4XGoE1O64sDh77t8n3qd-1DvteqAMhynH2N99WayWaA7-OM6B7BamSn8xHI3kVfnmYbtSIe6mZEC90w1k8m4bp1ogkOPc8ZQgww8wdk8JlnqVG-um1rYn0dlorccgG8lYD4LRYQrjpeid8CjN0TPZwf5wuno1xFNnRQtfRoDSqueeiWBFJH0smqqTdjR3XSpv1fefg-WFTsaf_LQeedkaBGvCniEaDa7IvApYaqzZumf9SA4Jha8nf2FbK3m8MV07OxHgcJEOCS1iHFHX_f4guaFo-o5ytrSKmROnUAZzntaSLK5zna0HPKPwGrw4Jol4WAA2rhgMGfHG_HSLfnQZ6GeTSapwF6ensIFSr1Lcjs6Rqp9kVobIaK2H99fdIlaUYEWUN195hWskHUfMkJ1yioKF9Hzh82oM5UhYOnwDVqaoIFuliDnvwltVpVGUABwN-6uUcV9KN2lVyOXGjgLx7LUfrr0vw9Xn6sCloUo1hNpatUw0c2bBBon3tvxo_K6nLzDp4pQEzhLaKO-aEEfs6ODICT1DtlwCiAoIBzZ5ZIfEBAubP6mPE1mVHYdYdY2S9prWdIywX_t6Oknb36jhtZnYBZ0OMuZN2TpalH9MLfuQF32eT2jFLe2BMIM-JGl82wgYxBZBqrYy026adRjfCqq1Sccryy8SJKuiOdIAKzOZ7wuUWx3NJnDzND5IybwPpY7omP7r3_7NlfkY11ChbpChS8n3y0SUSVlM8OS6ENzgrylDzQRAmgesDNPUnG6auYbofH1t9SfllzAknfIBc1szPn4w9yurwXM5RiuWkpDog0-5NE2Lr_N2amE7l-g-i_P_4IfSBIwGQmErWQ7QfrrmYwwbbp6Gdeo7biExs8VJc1bnz-bkDBlLEi4PjUp241VR5Ak-y_uA6NlJbnwr1t15ETJIZw7KsjNk3q7lXDUih3S5pbREWudAigFsXXJoZiRFIcpGhLqYbpP-Kcd8_wdI6CUZRaeBYCDlNeLETDlFqtrASaQiIV9ev81ESOMo2xh6-aPls8Hug8E00eClGVfi7Nnp65ag2bzQlDUKBPGbmhhFuZZPcOJFIfJDGL2PFWaZ7YK8d6cbyVB7jqna_0Tj2sfkA6DM1yxF4gLKYTy9QJWAmmeaU4zcQJej8zIpsCwKd3PLv2ZTZ_OHguR9772lzDBcv-jHq_ydiDj2tzz9144p28I_BZ61SpFYfFm1qOzYWHvMSvIVoe9pg6HvdTGBQ9aWQC_Vpqoym5lC9EGWmKcWClgYyZyAAZvySfRaBEn4OB-JtyBBG4gHFb4e0VfNpnKnn7GlE0v7BPNZdSVZoSK6xeQHhNmpIYPBLzcY2ZBwmRY__XJPbeSYk2Hj8G6Z_5a1xun_pO4MwCr19DKNkEGsEhOwxTEHiil4Nk135nRFK1fMd3hDd53qW9KEVvbtDaCe1_3oMam3RqGUYYUDgulGR2IsiDpgLsNw4obUK-23gGgvG71VwWeOrX1dqbvyOjuNoW9SJzh1yZkdS0FpT64B22xy7Kx7CEgpZrA0g_R02LIXmL2ASSas460gA8R2-uoy32fadb6CH5BC4H2s-KE2LeXlJvfNidLmBefv7TxAU6_nGTGUHpBrMG1CxCUPZta037VN2MIiWeFn7-MkjuazVNjjzqygETvDgNQeTSOnC4mKasWJby74kY_PkC9NDADpTSTfMi8Ipd3n4xnlImRgU5rM-uLD6sgjHCaDiCdWfagTszmr0grG8TG6FgAfGURLqxxQqkTKq-id7GgfE9frsvAONlHYDK8es1Dbug0XDsDPG_6mtlLDkDMGysBUMZFJ9NtoTQWnSTHWTjagJEzOuvuAEzFm5Fg_9oMJ2YwiHoTIY8n_PRFJs5qmX7-84zsxstBuFy-ngxiONzNuMSzGUlqLOjhIer7gm9JMVHZlkN0XWfrSrl1z20oqpTKMWtpz1KZ9J4hJ6AxLxV58teYTNVh6EKz-3kQXKtKJvx5HTYN50nsXvoRmp7xZejCAbSScjYUgiqdDYzy6BrO16vlXZjNAI1O3p9Vwf_ZSX3UP1PL7GZ5SiJChwbM1lVLx3UiH8F8Qc3k1Tt4crHG4fh_1-pm7_HKcyIekcfysfYeFLP2s1LxwNGUZp91y_8IlOQaCtnOlZD2GXAYORcLVR5Ai5IRLYJmc1LPLjspLed7-L_q5p2U8Fsr7AyRpM_BIompqx2qRVDxEpG3tu9SVjyntbteRrS0ZB9Wux519YCqnPHhXOUg6jEAXrXJ8MkFIbVm8LCdJIHzkiUA41-kUglzVBsHoRS5RtYDQzL29kYpPEaIXrvFJYJS8Er_Jy9_FY9K8ciFJYtv-nKtmTV08c3OoVez-NFKd7fM6PHTcpwargAlD8yntcKm-WNHqj3lpXnBqk5b7HYKnhoCkA0tFFnDaXu2XdtcDg9VAhWnhaoMH1ppijQ3Nxxg1mfaXGBOJcQJnvFEUet9vmjOvKIOchE_010Xv17JvEjgGPah2SvIG8pyKYhFelAgvsygw5kwmEgtJ16_T9Kdk_pB6JYPIfGnAKnLClWDbvjzu4A6Az-rFclzT90CVerQcwbryb5TxaC9A0VvLPEeI8GK_2A_np8FN7MzoCSGgDIkaF0Ztds7mBBCgAjy7MnSBanh1luk0ckuo8A8dHiIJRnWiM8_F380jz6zW6gqgFrySOAPSG4R6XDdFRAqIr_h2-nONZK_SCDcfpSubE7HoQvTI2HFqCOarRaSf5EhfKxRroOI_5bbwuUGVNxWRn32xNQskjtZ_vpO_czNZO_2YSyltKz7QHosYmAUKInr4zBgfHgDzp7NxdlEDRfeNw3KlcNbjGac-N8WsXFrEp9jVTiirYIcbvAt7h_bBFp-pPTKIRRG5Xi5zZMtaZnaJIg4YInE1yxaoOhqZPjaf5tR6yQdFCURZf0mjUWWInkbZlwJ6LQX-IkGNOkKLBYwBb7_8KuvVtFYjNcKWTitcd2ggp2VC7Mk2KZbY9713ULi2tXrBMyClxmey7nQefmC7058JMQS792RagPFbyPdjtCohH4LTm3GOdYZpFJPUd13OlkHZr9ZA1hqEtw0p_oundsQ7UNISdfCxiv8uVZN5FqhCF_4kpKcBCyZWA_1hoHaBNrbu27lm4Wgk4gSJF2SVP3BRKFglxbtfoITGBmfi122nBPAMucTEfN8ruwUnZj9k4Lu9Ckey0X_m9VwEtID4i4sSNZVRnoUu8Qd2JvNL8nG2jxmxbV7-59GvBlKhVUjlq9vDWtntE_vfZ_0kUred4GxsuwRW9H8twur_4SwAaybN-WtWGODL3503gWPXjGUWJecH56WrwXEd6-kbshzcsd-POen7hvLd_nx56Jd7ewOE_2bx7GOhcO38TV3u0jpUhftQNvmzXhUKVSJrvLzFxqZuxc3_dmouRh1L3FAvVZImMWZg-SFebMbzz6vMSAwfQW1g9S3tbDH_nmM-eGH7uvkGKWfa8FPSZea3G3sApoHLwmuD00yX4TyZvqT6uP8J-bFJPIsoMx5nNYENHa545FbTHmJsfKJoOR9iYOowxB-gxo4wP_CbUdTnQCyeHru5n0sRIzleRXY235AdWOw3lk4H31EXk44GYp7a-clZkdNdZUWmv4UQAtqr0kclvuPXTErtpmqyeMt5qMcEh_aKhv2u-U-RYVTh9nBNkaHR6n945v8Bwr7Ru4KRqPR4qcNgNu01GIRBGdjV-RGv7mjvZPDDIc9XvWSdsUpLLga1PjaL3ejm0031EcuRp5ZM4iuA6LwZv576bOT0BHbJ8Gy8jzjDrLHIJscn-SMaF04Pg3gRkVYi5AfRbOTerh1ljDsp01uvUTItGlbqzR2DFInwuiePGsEl1MM2FrurISFaiOVyPPJFgzFtuCbZRW0ORQOzIda85ckHAZfXygnokRlrJ2Y7ih_b6-rlJGh0X2f-Jgs2U9c29FoIbSopwV5Kn_v3lQalJR-xGSLRozPEwQ8_f2sd0GbmZ8QePj4cu9RipjYRz5pzbDAWrleTFP8DG7RuWjhJYYbA5TPUHErBMxGFwxGIrMWO1bPMw7RTo9zX8R71dKgkr1Df2l5BW7rvEr71o3RU3nsb_zyRyM-PWC8KHWRcKDsZ0-bCogFW5TKAu-RK-fDTXGOfF6qyrNm4dQvPqf18DbqDiK5z9Nu_e0iq_IoVfdPbZwKaQEEq2uLG2gNqnvkFlNUCZikG0TNxjygEbLS2JEMUKee4y5lS_gC2A4RNx2lyFcvpfcz8DBTQdrSJ9T2Ve34odrqLDC6UbYttmsnhMyJ40EpfZBbQk335KYaa1ZjXm0YivENWAGij8fICvLbAGtUZGa7i4Wj7GlDYz_eSD2jAo6-uvOs2KU8-M8tIzdgUa3wlT6redWhPKYi7HfdHxcgQGb5whrJ-kaZPO53nMrkUHpnAyrCQgR0Fs4Gx_yqnm-kOfF9Cua8-PuoOognFlQC0JrJFQ84fE79i5eFKXTUB6wQ1AuAoRYB09jVWsa_kqOUkVlK_Bs09Kb83d0Ju9R36ZUtThqB-FXZt4ftOAjuY-Dm3uOAeINSMQq38du5xNodhAii5XJWlQB1CL7zS0QfKCglaBeTyuykiw31VgafenNBe-fFFXTG7TuIc3Fbed-EOpY_yrNmUhGoDAf5DcoUX73QDRwMLzFJHbA1B1CpLhttKjG9t1amnRnyzQPDl3JlhP1RkhWmaWNCNiz_9oqbipBt8WwXmRMtA6018D2v-NOjKweZR7IoxK955LLw-5iAnSCinoksE7CQvC9tQppvdd9diZSAvGuS7bmzAJ56JBOqH4Odk0cr1jTo0okswZx06v6R6S6b4RXZKM2HEP7Yv7tEy1Xry5inGqtdvSHKShyil5rZweNcB0tA2GMdcKoYCQS1OI8FVElHr1ei9As-vJKkEaedsNiI6hH8R1xmdc_dX69ttGm7FQpSqT2x_WFdmQXR97uAw4vqF2bVg07S3BkoBPt88SZRrWwGJk6XlMAb_jhdqEI3dcg-BMBUtI_8fcoHX14bG3figLUDTy_lXf9njHx6Yh6rBJ5ujFihcpJvAQZttrg7wi-8hfkuHBxPkxLvhopZbMkLiQx8rMfpgAG7WwL-LPop5ERd20xZ1UOYQvqA9bAKrpY67NNYA-G97wCDn5YfP5UNCrl-In_69NKIUDc--aBMJwigarpnwU1ACR8-5FZ02faSXZg-7wQSGK1MZEjismicFvlC3YU1t8sIExQ5TzagQ3fEMoIXpajaYyFziaK04nFLpzwmaFAPuE7nZSZib_x5NkIsq73qifEBM860Hkoa7uSTKXRkkcJJ_rI8qd5fjBT6n4CWT_fwybr_lbuM5J03WEk28yhmEi3Zpw7dpYjcDRgoOVmRpkhZy9NyadvngmWheeQ2V0ZoUkXNwX_VoFm_H3-DTLUuV_5RbrDKus8N8CnK5kqng37qkzclWZdabxHDIKkzQAmoVTHBvJsY1ynQ-IslLcz2SYKkG-pux8j0UTPJv8NnXg9rJIxx8IF04dabJyT3s9tigVlT6qa9cUDER0iETqm47hEiUvqXBiIf3fGgxHNPHjFTI3x9usHiQNogm7KOoqr75Ziu8w_RrTgxzq1bVO4wgV49yB1dipmDk374dgM--9z1LDfAayrufJP0ioi4uL0kJprjJe6gRyeWejiw6aTHtQULHdW-t1iaMUo5bm1uTeVBVkHX3arAeU7R57c6LAFD9vV5nNa3L_9NgNSnStMtwijDQ6hYGwWHzmLSZxPWZHSHPEwdjNdBRAMH9vqNIZ_7AauWK1utn26FfbrX3s0-lfmifufzmkY6yJ0TZuywwimH48_4U2_ICC9mG9ayvIVW9bnhIkXk7r-BtXt_otDa45uerCPXJY8N-RMCGRb5aDntcErU1feOUu8iVDhBFyAXlozgL55CVE8HsBmOVhyEKRR5PTQ8j-XYgmCtLl9SOY5yc_ODlAOS_YiM7zV6tUPm5ihjQA7Jn9i5ZKZwYqqGbSYh059nxYBgRtogqibAoEVvtE6-WMyrN571wrJLhDnvmylkpPpS5ahkDwFkH5BfWdaa4Q-kKSvzvt1cDq0iZBsBvuuCnEGQsHeVEDgGoLSjepNAFzVnXd126X2-sOKkQNycxDtKk4WA7iM0j6yn2sqSIcmr8lIKXyrFR_Td8xXMSnXzVLUScY-zTRx4BGhCKssVfT6T3tH3cRzJsKESxG6YlTseyz3l2FYSw4j1TIWj698dzTmrrJZfFOgGZjYQCalQ8_RFY_Rv201Mb6i3DGqWVKN6URWmxZwLVmCHaQQp4IVOBTp7TAkKbMH-3QUTith1utAHMsdUy9jCRvGhI-Ji9vuYzl759ZeF7z7XoGfjdsuKefvnv036DXdGWreBt7PjTUF-qyxrLmrAZdZJ1OZlZ93f99qBacu97uZvxUHkUEZ9OXOco1WZ4UbLCdMC1vyY3ICblgLDwgMfvX3saEy3YtHeL-dDh3UuhLnlpCCxLUrUxw9EEBZxlX41CHdAjxXqL7MZZ5jMuV5MqvrwponkdqCHH6UktbEFcm3Q6W9mYzZsZdvSUmZ-TtSWzZwuHVdUTUhxIA57CntfGdUj4qruFJ0gqka-BoFO3U6t82Lfk1n6GuMm6_Ia_zvsjD8RDrcPbaYlWG5KnC8yFPSNDa0gyRsCbO_1WuqFcyYjCnvNjPiGVq8tTqvZjirfh6mbHa3UkuiY4DK97FvRgeQQD1iW0K1KmkXpbhRnszTH6hcKjWw6C-UqFYd6ERuknwxllJJcj0SA4mKkomLIrdHGitu7M8E0QzcypvyZ0dionqE4r3741oUh5mE9uGsdRSsLl4cmpF15Tt8EoSpMvq2iI3nQkf67xU3zzHXBurMIvRyGwrsKe6IOlYDu54_nbtQ1WCqSGcba6RS2lmgzNaNn-8D0ODdTMIOfRXFNYUKiPm6QebtoC_6X7f64zOIHViOAxcM6T4hu4khJR1IVDuXXLMEwWniqyy0HScEmZQ_NMMlA-eBys8IOCBMhFGJCgIXYe_ae6HSlGFyiE_FdNzB52Cs_7NUG7pnlMdov4Gtgt3RHQiCw4P6xO7xBcu7Tzh2pvuu0l8O1JDyS0GhgsBVMxH43bAIWVlxugdUFjWSkY7gV8gZSd2MCih8DhLdpPBSfTUGekXPLUDNp6BmtETo80Qd9c3QNvYWlfuWYAzAsQ3vO8MX8aeQ__QtByyiBo-brMSvjosdUsSQTI5xYLloV58K7Ft1sizXHwaYNuH_U2PESt3IR_-ILFI02pvjPsy54JBd_a5DdouBJtPUoLejiq6MGY6JDn_YlGm0tzSf7tuXhzB0AYPVYQlQUnTnpRUSIX5QUtbuZy3w_7pIziObLCEcJ5dAhG1EUUw8VPSlIU0m_KTc9RTeKZyP2WpjD42dH_rsWe1IkhWGo8U-vPYk6LFRlTlk1IeNuQIxXTbYeHlJxhRivwZOATVcMLPQs7LrfNIUa9lNQQ4tPVkTj-7IzJnmTcUcrEExGGy8OqIJFUjcCUJuHD_Vz2_93qj34igj0JybtVOG481Bmekm4wd68SRcUjy3sG3u5u2w8fiJ0pZj2cfAjG9QsAZEn7F3aBSGi84aJA61HbEUpw0sphUWA9kh7mCHJ54dc_vADh2kgdYizwtndWGfhw3RStaowf6zxhlr8SDl5bAeOZh_zaYmPAe-aIjQZTEGrpfp197su5j5bay4lwlMODgSzUdXRQcH5Y_AAijT00Og931Y3q8kenGbR5v-X8AbIFIBY2HQwUDoH7PmDNUVbyISgURa_TfQGOw7sHXXfDRy8nW8sc5Rv4FnTEha-LkzB_-F7r2lyW_-ZEvvk71TQ6RYhxhFArKH7OWmbo-Iyj4THllK8-rIMndc5oFvFz1X0mzhXA392ufYmUVYgcu2AlTm08q5dsYg7V5jmWllbA4sQKXf-9mDVo67gf16q8fd5A_nATNYUW2RkQTx1B7aFHVzdJK1Zfw4MHmifFGyYtyxgnKE6CJJb60U3Ou88axWR_1g46xYWy_X03uVBwwQg_EnEx0bMbEziexiXp1OW0SlcShApbcrX-pB7Ed8D5SDiDv55XJPOE996MC7yfmrRFG5bUHeW3U8j3RLT5zifuzS9yNA6fcjElezIMrg7zsmPuFUFVxE_qdzqnwgepAWBJ2kNdeYv0hWn2zMWJKhuM4qaAfN7DQkxadCgk2UyYU6k4oEm0GzKkZDwvovihHRn9yx2LG2s4064lt6C5ttYngs0tJQnwUyxYkWJV3USF_Hb4_JCW5m-JkMmfJQ4RC_NTOmoX5LNuhOSy0ClbrGKuqk4ZrGzzIhj25SX4pu5Di9BN9YeO2uf3aCnO61M-0U3kQLCb_DVkOTspNw-CGG9blSzjDdHoK5kKRMed9dEXOTd5ILFDsGachwh8V6D4gFw9w21_7pZKghpQ7zmuQBMU7iiGU2xwaIMvYN1wsYY9DO-4LES2hoogl0cyNtr0LgZOCAh2OQVIZjdcO2eUEZzkdq8n3WorsB-Q6Eo5sknfCl4Xfuy0aDbNUvZjXXfecJVlPW1TKv2NjbNRLt7EJIPsT0B_7YAxbiP0Y4Gj5ElCi5gCqiy86muXcjtgYBJK0fxY7eZBpvGos1k4niXcvF49O8O7uAdt0fWoficxxWi6edrnFVgkJlyBIKojeskhnJ-rTqmTvY5PBI8l0QAaPufOCDRmDOE3LvKy93FfQTbsgJmom2YGcsw_TbnmFDwVbiXNCuJw-qVzp16P85IH4fPffPWfmRKL2vNnV6MSE0ha4iltkaj4nXlI5lYf9PfsBw5MYdPrZuZ4Hi3eOwlv-p2mj-qefDrVTz2OXE9lJeNoiM1hLYAl2OnqXnjKguHErwJ5_JxDT1qb3VDUDCy6b5-4yH_bLqXSGnNOBxxpO5dMtVnWbBPxJNvy_DGp9aXAHMegKnhyfOs-Se7iSGbjVyjkxwpkaELzyXAIbc8j9JGd2UhC8bBHSlmK1OVOhdRZuMZHSedMJzESy5D0CwhgpYEO7R1aqHcO8uoUcZHqAuUd3JTdmum8o4i-ELxqL_4mCCQf4w5N1gy1-eIrDoLqYUbcN90H4v9bkf5I-FCNlNImcRzMjM-Y4wLahw47E_pssdHr4ah43Xr5O8IHsm6geII7WZo7zw4pefO9JPQE7VdjXKuTdXO9tGUMjZUv0zkRavC28g8eCimJz7qPV_7IZbRgBChhrzNEQwlitoEs06C71wvKPFRT1ef0BCE3CjRV2e_ALqybaFTEtuBPhr51mCZjD0NozaunlQ2dhJO2pfY01r7fJMhl5issyIEOBbNEYgivcsHnk7B-3JSSwjYZWTvrAT8MLxA21Tf_xDEeRKNoRXOksAp_3Br6EaLWuN4ihAk_qml5_2PaWj1nEYBqTaio-7BTKTYHHb2jIJJ8Rd6V6GavVBC0BqxVMZ2ciJcaeZfnmFLVvO_tSyj1l4hgNYkjiCQ9rwUpXJDFlWyapa1WP38Otc6ctG2UewNgMW1SKI1rqbYryq4COJGWd6KxU2iBTkcqEJ_l4YvyhF786y6YRwo2CS7y7sfdFohcLEEi5uUFouvjr5tX8AIfI4HXRCsEr3vuenRZ-qknlvEXzBSl24RXcXPeMXr-AGTMGDAXqy4Da98b01S48IUc3McZvPqgDqceq0TcGz8eWIJQRow5PSJXYhpNKZU5ngQaGWMFHeDM_ceDjfP0gxKf4MxOvVTE23FFBCkhzkdqw4knt4y6t_n3wyR0Acz_w6y6plvA-5FfvU49wC13v6UFTrju4H_5L6tPH-uCkQb1KHLEqz-9jvtYQljcaInH2LYpcEGrHLPLbqqUHBVc8J0QXsPjztvL6MZhrjII9Z7JfT7VjTkTTZF5cPMQBlWHd4SZ2DHl38vipvG-7vEavmLgCm7e-BxdRug0XqJ5MgCT4pSI5pZAacjIoJIzbkqBLT5DXJC77cZ41RR3JrCSMRU-V9mWOfSC2yCzt-_ZYl6tXHPfHGOTNhbTFWbG33Eho7JBYo9tEzqWAUC5hwAy3WP96ZRsRcQV0-2LEvakDnoVxBzN9d3JXSh-JfozoxQKUrjfDw6GsMuAXdD0XN7wdVWR75IEu13Bs5LBVhm3RRcaEiZhzo1TyiLWqdM-pSaT97Z8Q9fLi85mtFVIwYLfaml3moRlql0eWfyr4VXC0bXkKIl8W8iLUxuzpZvkr2PD-jca0xZFJgwhBP5hEkkNGoTshbKfB2V1DvGEQI6uzGVa4K-StxJLaB6Fnbqf0RTNIyRP5_NtD8wbtLQPd2hNBFceV3XO5wdqpPynvw5UyYYCuNDUPw4clOvkXvlnht1xj0ThjcH97lsRowZRBi4LzxzaUgNTm2TUNlIOlPhv3f22obUwXYo1_RCGTV3fCVkPaV0xLza0-fpnUfnh3Do52nGNXQr6JLZ1cEW2cyR9QMENVaERW4j5atpfIlFZlmSLC08pAvDqgUeq7_ukpB5R7zoNhaHFee39bKXvHuGe3dJ4z_MLC4_0Op-2TpKmeeiyshiul117OUTJLou_OWwB6-eKWYQILW7nXVRyRvxZygwtdd6riux0sR4wj1gaAE8DuWdvllZxZrgGj5u32eL2nkaANyKSf6kv0MiUl9U96QDwVbayzy7RyhEJJq1nRMitoNDwPD8oVd6v-CtkZAnb9NVS6Me0_hBHHDyYJKOOI4RKe-VB4suLrjWcvHA-g_RC7eLeYIrfylyTKJdzw814R-_WB6Tqp9k-FGXD7gpHuZO6t0P1kypb_iC99nwvvQoc066KiZwv15NbDEE4OMbG2qy8ui98Oe4PfnON8hJWuxHMeC0Fgeox1KEJDldnut4RXIyIdx21KOw-vwRwUZ2vsT8L99LMzCJVjrEuzUa59ynkNmeXTrXIzUZM_jXE8ShgRXZawq1kM1enzc-_SSZCqeX3ZSX6Sc9iW_8o_XmRfebqA7cJf1lATX_npaH1uAE3fhv6EUNC5c3u3Bvo-_IkS2bfi-VWhvrX83gmSTKDPpuFdFNHEUX91fiQKvxM70v0acjAJAePfItz7t31Q-YIK_zBKJD66aKzjfREG4tTGUXl2D_q9MbxXzqfGreI_yW9SMqS4tw3pmJV1gswHvwifKsfH9Wl_Rk-OsjztWaTBT9METD6gjzsd6OqSDaUCFV9cvZbx6Z1WS93G--NOqfzvg8e7rwPYVABVdR9aZqDUDPfxWeZbDf-RHKco_TJrJcxlt5BmWwTmQKvYt4INZEQPDul_7Nj9xutRe9OP3LCl6NX0bI6D5kgyjtgNcohQEbzDP5AlUQC7roP4_mbjhcp_kq77HctyjeeIUzzu7dM5kuPtUJHPP9DrIDDeC1l3Gcw2SQbO0DsWFg8HY_-77mf9OIOkI2yoTl13RWFrzhgkMDOqm_ItfP3uWWbEgrsfmEQgMScWrvnwuYbklYMWaRT3hMeViiupu-pJ5HpJ2MFYQ0kMtc_cxMHbZTSHSer8TJYdNzXfbNSOjTg1rk3962MwtSSCTo6rcYktxks71Sex53nsRP5frEysNP2aLRfMoZtIqXGFQhHEilIP7nJWiqzzupk3GSS-Q2pJ78gd9c6ZYTf4O21ADeBUwdRHW8yjFqoLd4s9RQuupitX7SEdDeBKSVfrfeu9UnTbdR9Syqel4snqJTDTlIqkHKRJHqZjXI79fvwPARtmXsoFmqKKH_lnEJznCczL7CM9trY4maERISCsUuHu9tq3M5fgJ3lrcmCY8gPlcaIkztIF2oHVqZZ96Jd7Ay2-CI78fiz2gBEs7K_R-F9UoB5Ou7dLenOpu2jMs9S2zcQk-IVDJMVTEIcmISDWVLFclnaizkg_IwKzQeHRi3wJTSgIY85eVaPbt1t_M9MHmkkjalCZ2REWcTkDRmUeGs8Zg8TLX6JE5Vh4gs7ZairiX3fAdXwSk6HI8saVN1dgXAH2v6VJbdUWfXepI76EB1xmAHmfEMJwg6-yNMugD8LWl103n8gFkCqD0XIklMQCK3MqtuVBT_8plEdV64hSTVUBSQAV64uXz7LonSYqCw6xXbfqqW55VqZitprZKkqmRkZ_NDgm6KF_6I6SDfhdJzIfA91WXjJCROmIUpmmwhYZ2wA27gAguvyW_7Io2fVqMhl0nuI_zrp6nE-7Dedh4owfpL_4z2-VijVvVw60s_6ENf0R9nNarwfWImxoexJfX2Ao9RAa6yIFO1OUiGHrfk-Q2jXc9wt98U5zJLKFbR-Fc5DSCY2xK0SPk68KZdhzWQ1J7EHXyAA8OSay9TpZv8DD1WTdhhduEv2EmA6NN4EKtAuDWXSQhvvI8GmG5E73uynozEr-g11g4bn6DfBo-zNzPET-jyaipugKhsjHHnZMBbu1QYJq2WPL2yP_ZpnGPUEpi88XLgBo1iehB0_wjVq05cAOwDJtyCMDh955tzhVi2jSeThJLK0Cxb6EZloG0z1R-EJ6qPFzdmTStJ6qGWedJNurjtgyfZZMYx6bCSn7XkRz3s__DX0L9Tn06ZJZfNdnsE155o9Nvy6XhrVbNqrvKNZ7BvQqIY8lqgkqduCXWr1IWlRH8w12Z82bDE6DCUzFXM5HdCRRYiAm_uzUyd0yA5yfO0FOQZVQQN6KddfVHpri62QDNzov3IFmmVCkK8mp8xqW2MGDglLTTa9HF5pA-py225e31QWINQrqYVawPV0YSw994PJd7eGuX2fXXmyj6nm8B4S8OigPjU0RfBp8DF4S9P0iRACzPFG2l1XP4zi8ZsIvzK_PN2rVMZvwtuNtxPpZ-EmNRd7yrZvgtlOnQC02ByYxxkQ_9AfS1_qDFpaIQq-j7G2xvBwZnRc11CemtFhNfe10ya5tmx8O6ArFttUp4ZjT9gNaAhr_zochIaaFCljYN3FZRlDPERUpOih1rc1x9imO0V--pZ7hplNVcpF1LRE6eFrWH5MIwItI5MvmtOBTOm46Twd7J6SDMZbyVzoJWt9oY-W5HA9yfD_-u7TJUaXWp77tBTx6DQqFiGlJCaTeG5I7OuUD8DKMnAQgEBxF2FN6CVWa1lwU9XQYsPAq9f4pczX24oUM-VMRPAU9z7Sk1EY2VpAGmiUogpFhzMYHiW-1AkC4u7J_IIQY0airkjSnUU23UWjiJKGrcIhgR8eU5iI2IXidM_S-NsAxSfxGjobNNyDmhmuKGt2_TGJZLPk02G_ALvDbASw3hiX1EH_pMqHts55f68dGgsrFwzg0M45eioprIzHRMxU-eRvAI6I0AfnQjCrvdhCeEafCPOcTwud2bcNqwwMKb8YSj2Cx37-yVmZBS5Aveolit6_77BuOnTBbjPKK5PmQHkNZftvtE0PIRseoG855UD0hMlFB-_rRxVIhfMaxiZ1w8GDBL1BQSpUrnR8xbu_GqS4YoG7YIoMJ6Ee2zt9LU7RpNgPlA2bw4AjaHigJPGQAcrkR19kgkIPdu59SzC0vN7YUdOh3NhSL3A5e5vGiTqJ2-h1VsXZ1mxIPs9M0uVtYuBLdpuDDv7jiErgWwJvJIjMo6EkcIsQeDhqium1rdtZWXkCLpPLPGxEWejJD16FKwzby9bwqp4aJHxIgF8sAaT0vKCGEAV62LoymXaEzMNg0Pp4_MZF7SFkXuuq_AGb6DqyUVIHtV08Za3wcEq_RZou5Gs6ku9Drep68hDiWPYR6Jz5QrqItTeTVqyBt20jULbs6-Efmo7Y8IYTG3-chVjG9IHaoyXtfZTNnxv-qdp0ffXsROkj7LNVXAO_BPuBjb4katKquDdyYApgwgOmPqIoKYU3Vk4f5W7hJ_I8i34gu0OQvue-vpCd9TVw1XaRN9fGfDN8cHzkuyVvP7iMUtW93PP6vuG4FeMKzXNWpF4NCZeHeSC7_tkoRiYnXSN71zN_Jvly5Min46TSj_0aAcVlqV1pI0l3yKvG6x3F2n_MaEPpB523g-CnV0A3gkc6LlatLYnNtg9n8EZWv2q1WCS8if4dtzu1ZP17Q44KNMCyYDSSP4fVdXOZxl_Ig8d97p1xixR6e6pwZKTptmX8_V1XwHS_kpdEerOwm4oQE1cs6LvyDzF3FT1vMYulTI6BwDbVSurZDVXhB4bOfbw-sm6zvmzkGvLSw9YhgndZWYhgf10S6oKicjWjfJ3JKz8ZEIgfpJMqb2eAnirHGv7xiwOdt6A-qdCs1dSg1R5G7dOoAvK9JqtNUpsTL8C7ZOrNx6y18gGtundlqbnZ8u4YHiKAPnXH1IhMbELa_GTB2ad3KWGMK0uS4CwkD3DiODLC4PROIXSrnzbki5QoVzjcw0UgzlSZV-UPQI580E8ZyxZPwt57egATSnrU8C5PMbdUZTntPx1UhFLqorH7FI7ibCXrrBQWNCS0t0t6x8c-5yf_mx1QL0JZrWLWz5u1ggVJ8OXPn0i6TdUa-kgfTU3yBTBLOVn8zGNkB8W9Jy_N_zinL8Ke9RNiVCTsKAbTpsxQLJhqRtI3azP8qzil__iVjUDhMDFkLvJ6V25MQo3ztRak9deKDTtd7pQ3K3dGdWq_hH3H8Do5GaRHaGJQ4vaU0zDKBUqZDb36a7-lQgPw-f_zepdkWxK4PL7S7wpPWVvfKIph4hZhpEWjN47MCYiRZtUm3M-7EQc3A_jMl_zJTpyVDxElcPrhDPSIBvm4VxQCwOUuEpY1GK3r8Ar98p4TUPkiugBFH4dAgaklavzxAu9FyZ3ZF-5yOiqNAyUeh1WxBaMOTUl1rzaYp1joyv5JZWIhstsZ5NE7cEF9D3yi5-kCMzjDarW69Eu0LLQ3CJNdmPZhN0gYBmOo7NxbGiY6Dfl5yRqKldBD003Y6mc3Lezqm01yPm9euw1kiDkHhQUVo5_W5XziG3xMY5DgKumUZ28-2OV0GDu1O2WOZMPqOCQKrbJxm-eiR88OQ5VL_R1TwhedLcFTkkGwDW1ENUfn5FXGO4onAylUtsTtZWAXS9XHmMYEVrKSK216Z7KKaaYOBTP3ro55jOtdT5sCEP46wS4ifyFQHZ-MunVCdqWSe9kMN3vYDUlbCG5KSnmXI8jHitVbhQ-WuzHrmPj8XVZeleHef365ssrpf7LMzaXSWZQvLyTUM2K2t-M8TJlsXdMag-Xd7iMsyiZVLq5CrjPFMPQ3DV7ClcdGqfz-HJqF_vK7_IHj79ikSCtOfhq-qxY8pdyxjw6CmpkdNbr0z_T1GXwN2XYOHwHblxnGyI6JxkVQazVQCQhjGXF22NEvvadv7pIsq7MGTLQ0wXwKcDTeTaJ_Tj-Co0kGputBJCbK7DGSH9g5JA_eqSxw0EtJHQkkIYY51LDsbCc2i71wmjD9ZYdyPLNFG95jUnkO1ZN8k2USgcntWk_Gz7Ou2oLaXbeyBL-kwImQKG9RGnLaQnrzxZzbBW_zdol3zQ_n_PSjVaCee6dLrWju2UyjJLgfQkT_kKcFnt-8prf-xzB3aZXQhYsaPUbBTKpgLKzo99JVTrgI9ToocmTzoq_2zHB6L_xKNVhaF9PRWrNbJvnk_4_of0-O5I1girFg4QS9ScDGE1RXdnwP67oyl8HNo-LA-SdZMrxVA2RY76OGmFjNJJ-sAzRPRHcO5f4fUS4lrVev6WC8DOtgIbH_jAoUTzy5XieYwV-FLZBtcE9Iq-sqfbxr1f12UHXSUjXOE_czGFi1RsqHdOXnCtPOmnwfOYNsopL99GTI33pBSo9S9zK6Mpexq9WlndPaOQ8_7bJMcbCvMHwGRYrrSPKHVlpc1tJ3t8wlh-i5W2shIA06IUb-9d0o8mUrbK7WGaCUbdYYQLruraxqHCSOUvKndhhUGPoE6rNgPzY9G_LDh3vlafXD9NxZNiJVOMgJwkRMgXlyXVCplNgXn0vkw2Ujp18rd4AunlFmnFest6ubq12GDwV7iLoGx2Q999ztMhts0GvKZBDyOQhXzCFNx6x7X8zxkyr65blj_KSIlu2x4Oc1uwd_uRbdcHH7vhcgOw_B0mIvMfnBskOCJOt-wPq8VmB_nypR9fXVX72EIlFDlCfCa6cXvCU2xzqhRwFg8NjsQ_IUyaRWC1BBdZsIJBUfvxJryIAUBy7UdSJYCXFbjcIj6MWRgoVxzl6UtIPhIJzZ44BGHyB62lZCpsSvoGlBTZWpQm6AkCMDmxHD9lhbToMMPOz1AJJkpHYVHp1pqmVzzDgUYaAHDSj96GcZIelYRNHejc9dRYdOC5qD4hAbXxJAM8x9-4rP-5ZLYpLE1Sbf4mSMWpVYIeVM6Lekh6VcyGraaggBdxuyZyqLU1FjzXataKx2ud4RCH5RqlKCsgiZeif6nvBaRYbrdiDg0V6BohVtPFSnnp745PGNCdDowC02CR1O1-pgbZ6iXm8Fctk2Gu3kTbO8aTbUogicqQ3ZjPq2-ihodXMORE3J0lFdazhLWE820kMl9qvS6rVus6kFGvWnahCe3dH_TD9kvMu-7PHv_FV-z57twvs4_nM0jteNeC7zzRFcuvs39zEXy_p5F4dTlAwjcQHKsAXaGDEF0qRLADEeSvM5HiBrMmpTpBahj4d8x6kYKjZjiVf6WQqOLcaSrtL1mYfV9gCQSF6g5ZEqULg3H6sxZtE50rVbZFhkbdmK9ZM2RVfkx_ELlPRaj__6R1ByKP6iRrjHJy64bOzdAE0N6zdMxJOgfKErA7FjfzKYK5Ro79VoiIBy6Cs10f1X9OU7AMmCl85D2OhkKU1MywLXzvuZUV-Up1B7WfMCZLjptpFVRUEX3Y6279IQAxtO2vDDUrFfIU5F8WvS55-en56rzO5ROa-7XeXEjXCWNGr1WfNzbJrHv9gPdmeaf-I7RjevEy6_GTSZEGFt8oDnhFmFH5prJpXnEeHnH-h72kliRjeckeXfaP1heoe9erkNMks5fJAOfqzuEbyfZJJzK-6XuMj328i8Y_D8-e2sznGoTJQ7OJI9FjlpbzuvUy2YhRl-Oy5c9Y974D1hzNJddeUQlNam6w70nrDLyhxxpz5ojjVVrsIUePnvBbnUnBAetfo54M0Q1lszczkp4P8HHPEv4jdoCRgd2ES26ic9EmUs0Fcp8aE1yDjMxPQNYpWxVd7TEl-fV8SiW8hvScdMAiNUV6p5t0CMBDL1FMsrwefPnvjXYwDE9-ukUGSVXz10s2O8qAx-uJyqmAvFkzUz-5v7giOrF0uSWGz4gMKPtLmAQLzYycVSfuliaNSuz7LyM9u6-IFbdXyIvyqFmBc-m4ckh4-4oLJ6jbqRiO8-FSrqkMXQqXz45WVpxGJjeEOmkpeOQy6HBmwmgvmcwwZYZPDoYoMhoUuDe-V2_64UflfiprlDz7JvIBGny9MHZG6d22ThhW91NkeK2_g3Aizu9AQALed-BKml-d7VpEbG7U9se5FIuFClr0J9aGVq2KCg0jm2H7I7nMUXu0jI8St9OLrZ4OrjcVeuBz3B-tRVvuE8XtQKMg0KF90s3ezRr-2Vy1aETr29mv2BtPbfPyLbZ2_wNBKb3_vQV8pXdjLAjuLjaau4qxo7XMMpjbouv97HJ2DOb-elfxt8W1x51icHQaYDP9Uo1sPJrZH4iv4DVkjyCXMmFs8u7HdIWKa_Auelb_ukGUNNJmOfjxlxUqq93oPcmhos0NVyz7pnWT6iMYXiUCrTAlwvLnNOQ2_DCx3NLayN1b1FLMYmfu0J0HmxVPRgqLssgGw4GgSbN8cgtxcIcPOJ78_JMcruu1SkbkcPo4lUfVkjabHHCZRTetIWh9Xk7KhZvUJHip1t28moZgCNsYjp0bgZATlfZX_Ne7wKetihw0nDGXEkd65fowRpa1wStOO9JYtR4pvhyVKeu8Heebb0W25MX1p_ZYwp_xqXJZkp2ARpW-XfRL4ZoLyfKhK_BHBm6OKngclyGpcfdrCLmh7Ho7xXm7h_HRJafziQ5G6hf1e7Y8PepxVfMK-euhexvmf1vgYfW2zsmvKAR7DVrjDFfF7wJcQ_igLfMjqBLwMPicQvO1btW9WbRygNsWXkEEDrCT5oLmEHYRyAfjJubfxIQksJygvD7hDl3D8Ld_oDiA8tRiA_2gafCh0I1KGNHBUzC6OLH-4B3hZ5LwBFsQc7XmEiCCWLfxg6UPWW_Vxa7VSwLKWA00IcB_R52rx39NlhrSdhqhu1Oojmi7E5w5VWPkXD-Q4O2Jhd3rH8Jiq0iisj8XORPTqqoFyi7JpUMu5UOVzJRobDf94PtmCBt5PUcgCIrYh5uRwY0zxIuQ9-hBLa7ewg3aqFxxfD_l_U5J8LlA9vGbw6w-p3vykMDyPiUCsG_ikSXapfGfx7ZDXjyg8eNoIIMuO-6rW3IKrtmMwXB_iUK3tImybzdTOagfzTZT-5ImGu8dZ9mAkOJXWyvEL6_7ohKcA4YDneLPYcdca1U6RAGaEcMVyrk9H9cGOZ-Q1_Wc7Mrq89YjcYqcCjFfhSArwBrle0YQd7PdaZbnP_TNEjibDFs4_Yri38xTSkFF-YfJpMmMCsQirixYeKwCedo8LTMBJ-_RfbAws21MfH-BauEXbJowkCZC8H2Lh7VZEiaZBicpeokSncUoY8Dmi_o2Vxg4shA76Y2xxrHFORVqDiUfco6Xum2LJzZsFUPArwgw9t99HZ757HPij5nHB0GSqhJ8U8xcKv7Qxx6jd2J3aaFb2PBshsqziw7vgYDzLnU_f77ktfxSCzo9ChlVTY9QJz3pACdlvjPwlucIrofvnyBcN5wo8StkzM3aeZDQYdVfHC93Y1F1uHuKgv8xeuVBzkKVaah7hk8eRTScnV3ly8IA00l_pLXSvwCv27XHSXHbeZf5qZ8YcQfkemSgMB0VbcSp6IpiG97WGDieDpcUG1XssnCFSNrfni0O_7jfCM3g0qYd9wtJJu6GtWssLpdxcVMdsbcsDU9z1ZuXLKnyk-Vn_kfHNfV0GLr6yYqJ4OonZ1HKQPEPsuUoXOXQ4yf_Duc1MSm8WSZV8GhrM-of9X6ljxSZNekbYUHP_d7Q6-k3pHo2oFmoqDUm4gkchK6X0O_2FeXMTr6BysQAiVAqX3e58-m-VipZZR_YYDwvmftG8sbVWX0ukInw5dkIfk3IUDsxcxzwTyC483-Sk0uaJLb4DXBHGKhq_ZBP5S_SVg7BFfFa8-CrKWRQo3cpi7hvYSLHxx4digwaFkhN05mOXcMq9vG9Clb58gx38U1XkBQpPBiPGmQOAaWDJqqj28liRYgwKGhcA0VeSLT_6fuk5eCSqQFHLglGVHUzTm0VQbeEHFcuhMfEqE-j5fYEXqJNXcDk2W_CWmnSN2HV9gwgg2-zLmeGh4xEQDK_c-1m_S8AtYLxFg-wVOBHC-8d_a3xWur5HvOyhhoW3QxwM0m6RlpQyryOsjWGjzrfxwt3j2XdFHCNHK-B3JzRY7oySOrP8uoOrPlydSZuaa1hw-d75MhV0L1fyql3FkKEq99K_J_V4Cc5rbdzdoPrP6EtH7MgCltCzvkgCCtfM1kvah5MkCPGxoViOxBJCyTSB2WNDGOsLMw8cHwnyV9Ulks-Qcxqxv3AuweFVxyyGVMxIjczrEJyd_dU_XFSJ8PSXdXrJK2s6knLX5KDGp61vlYuBZfQyyv7PBqVZMeEwMRWEd4y86mhXXggMNiCiG2RPcdIzeuxEJ1WSM2T-FId8KXvBUWiaOf-5K75ayFuSdLA-_meZJyJrHsuZDfz2Fw7eNDiHDyma8JzphKJkOdNEVcJHcubVVzgX5gx8bSzQ8DNi94gnawyWa5nlqr12-ds0lcuWl6ZX6o0FVZ0xdJ0U9X7xdGZRJ4QSf4i3AXJjvuBaCek3y3rmX4YZtOlqImt-i3Nyexhlo9alIiRHVBu5jjZUFt0y5WjMFMvYzMIWN8hkOurOvb8KPVt0uanKYCio9CXR4GdmYqbALHi1rajV-KHg1IfKBduBVl5E2uDFkK8G0-EkXe6DyADGOXS85IFIeQJvaN1fB4HT5uAPEVENFyQYe0ATZR5ilRdUCajf48oSsVEmEuDKHQNqhyWzWspqm54SMAYLaMJFdEdRqDwYL_-yN0jjimA9sRvSJiiVGYSxyFk4M8CLrMYXdoJv7mq5SFYbbpWgRNhzEC-KupVZVnK-olG0PAZwtB1MbQLD8X52M0jwqj13TO_1IDE9-uH-2a7g_KqQD5U_qzgTH46Ka85jOSlDnntYv0firIswbRISQycqAyx-TtDHbdEQdpQ0AFc25j1z-zaatWsACf5Q1yMyEBjXhH8FQt33XpiIzptvZqKj6d7kb5U6hmWR7CW5vSEoc0zkdXHwlcIuoBsuwqrpZac1GUaKssv5lTVzKMFw8LbgLCY2mT7dzIiXxXlwAHf3R--eKbrDV7wzYHClpg0gRqgQOaYnpuv3k3CUxRLCwl1Mxy3_TRzs9GhpMb7gDANxNNugAFMJRZXzwlhpTVApaYeyrShtyPeIZoBA1QrIvQlAnyW_uD9YM-doGtmckqVD7DavkjXkuuEjkV2wA3piC0nt5T5T1OPobHhG8c6kXt2UDZs4yxbeJXfjue_YRZNFJwtA2nUoNty3pYrRwd6X3gnwhovXDa2ALgUFZM-W0vmi8BemcrkY-4LYMf7UdfuwMfo_y1ZGGffItk8ogXxvSYJCiwn6fPtDfUxFTc39bi3vUDyfh4BQpH4uf5mEhP96PzJLOdi5W6iI7bPBsDgzG6nX8o4sSYIZ9HouUlehP9xLHLbS4qcJH469uSSHHZB2NeVAdCNG4p1W5hAd69QigltWjHVWW-rUB0J4XsWtP9F-svOB6pwWk04o2D7nkMXIGr6eRGyvThvDMyzU3UalfhPTq7ybOh7xpyPfGYfquBj8TC9H65BJp9ocYy9rvkQuuj8GVz9h8G2MllVfShOZmVpu34CE7OzIEQ2CIxAEXIC4PCOdSi9lWQu8RR67WsYTdjj8F5w3rCG-HHlgGvr1CgGzFVsh4ocp6p8yOhSBIRuoONomqfkBn4zWxjFKRP8Dpc4lIVOzVc1HpozD0a_SBDYLrRplVakoKaSHGBqY7nW0KbJdwXx0w6H6ol_cxlBwpWu_nDQrVy4oUCPGqCCEYpchKePGrZVOfmnXAlvATukQwhjJlG4cHc9-3XqKWRv7GAPPDV6qF_R8hbjg5kGwKOWu8i6vNIOXXgdmfQbmQWCUZw1YombqL7PgAcADXPloyoNUnoeuajfEVGCOO14Rla7VGboWJ4xsMBcCdGVg6NZldVnUCPnPPk_QfdptW_O4jn7IBq6sz0zUwxNHfy2hCc_foYXYWkquv8qY93GaUH1LmMPy1l6WVN04_ioRsxnVOpUWM1GldJJz5cawHUy9LdARSTM4QH-WgzG8C59ksOCovzFROPyA1Qvo2veXVswITokDWnyIdtHCeqcmPxSPIXYyDheZMaU8-4JizOR6jdvlCekr_bxgNDaMHpKS3nnoGZNeVYVj4MLBlsyPhNQ-fycWGvLV8DWczSIMiCcdRJ0_4byZp-HzfDlUaxfhJksYgd29Y4F9HBNvT9f60Bd8TW2i8TEjFfz_ER_KtT0tF_yw0_LhiYFh7PbgiqaAxt-ZjST0cmJw39jXdSXqpkEzDHFttkYDfVQ4XPuerBf31icIK62Ug1amK3un5jb9qUqOoFfvR_c2C6LR54RtGO3fhm_XJjMu--vRQT-Zke51NPiCuAEg9BcYC6_X6OJ19BlgVz8n9IXAd5-NbajPicp9gecOarHKUlIuBd2RP0TUeGgOBDrJ4DxCH-d_CrDwWEHiwkcVpozjegzuU5uYFSpTmoonyefSTEA43n0J7ejJJ4JiCU64wGpF73kPhHU3GXlcCy32HZwDQsK9-GW8sb1mLjfQrL6-lVJ9usmpMQIdJAb2n2iQIIiQp7X43StEr-Nadv_oLbTX7CAHzxpeLY4Dgq8O_9g0lEbXdE8TNWkYfcH6dxxQzVQUqOdcBXp1KTRwOrQU8OBLlxhtCenvJVI66KJjIPR_dVYFGuMHd5_15mMvzn_b4vuda61LR_Q-ohYE-N6gKIiKvN4Qc9KEbNW5vj9SW7MVGfx18FzTCDRpTnCTBb8nfP9u3b9UXaP-r8uUB4gmcHyrrTE-y9IBwUjKkhuwfdRVMInMQilOG_yh3sV3LlHGcvp-Ls0-vqW-hrsIrC9Pzb0NIv3Wvxq9VfioaaOWv_X1FYFSVPOojUl9w95aPqAgtwcHNXPko55CvHqgUd89kF3_cQ9QxVbc3cz3i3vTYDS1Odq99UabCqWXUQQUAwz5KrBeyNoJ4WJugWkb_BlJCN4sX1BN1W_sknVRN-LtjSrv3uFRHzNwZCOokVyfpwmwSasEG-d4RHD5pQZ14cJ4yiGkFJ2esy51LXqoFtCxidRX2pBEiyUf3P8qZvexNMGMUbKpQumlhjN6c-sxdWEHgTp0YIj538UaJxlCGPAKDKHhNoyhT8A_GKjlyrRVRmgJCuqvT5VxpEah7cT5eSzJK9bQis5u8CzC2LZB7njXmYFIdw3bHvMr-rrOSQKXx6dfDc6qWZYZKdpjBttqbE_mu2tlvIIDDUbBEz8eMMokfRljJ-8v5j-SixFohgqRQQlJhCJ2Fw42EldEWSsmFg-8xIYOZAW68SR_lIAiTrsA0P0HsXCQiKZD5lOtGZ5A1QkI2rqpxVrfoJHpWHupQbuNSBmTXQmsc_HjDtfg2aL2jdnU3Jf5-RohFDpqA-oBGISHnZ2weUWkdpcoDig7vYd4pytBAr8sH3RKTowJ9xfNCNSYxJZyhiXMnsUH8O60RsOLa4HCqdXmtdlkEdxMG16tGb2DtfbPSYeBJBMyiRX1_AJOkKor5iPFhkUKgnVMuYHJSGVfLeGRaBmlFHNvDH1NVM4T7YnPfl6jFUz6BJZZCwPDDwuWXVwrWN9h5wSuVKHQro7RmlQlDjQ-vsGh-hSL1qo_8KAnGD_NARpClY8XNl3IOEVyX1OREQIPgBwDZq79pYSmMDYhbzJZKxICbhB7JvE77CMXQk8v2UgzPts3nzDBQ--LmKGFVYLRguhdIjarrCcJin_Bf3c8_ss_DypU6exq05gNpxhDcVWhcOWuZEiLbgAKUeFwRNQLkMuZkEqbDA-nC9Pk_NaFE8NeS5oReesPygKfAJbPH1_Ut863IOTUt3z46_EoCE9gyZrX4S3GjCfGZWIgbl3pYPdps1MigsWnmcUcoBxWUn_BjCthBdga3mCYAmJAc6-GgJaILVqHx3yDJdONG4W-Xwqwe_vHDWtbQukZL2tvxn0vj4teieG7-xijcYlmY6qSJnjLQh4KtEaz6N0_c9mjtKjfc5V_e-lbPZe_IJoj8k0PKuki9HR6UsH30AR5jdZluqXeGEnKC5ktZKJ4gnrP_yU6xNKWusBBIStoig3S35dPkkQAUoV1Y-8fv0EzcfJGLGrCdjVdK7NtY1l0e_oqOMGpKpKiMXkrlKoO_q0jXa-lc19Z1I1Bs-yeb-mKqBMiJb0_YdNSNB28KPBFaed266E97I203xRC7E6muhE2cSMmMMuwTdGoMp-DzUv2mD5H1rMshUO82qAp3A5XaLvVJXYA1St6NjLHV_rRKbHiMZ28jMLJnIXEgKyRmLJPLhByVIsrg-E0kf_GJCpuY6TpktJuV9cYtcfE6UCozg1dA3vMBAy5HbIzk_fDAMWBv03TdZ3FSjKke5rn7OMPh6_Ro6HZNNLQwa7P53ZOR8abaCJUchY3zmcKGxEmMfp2iueA-ZWUyHY4b_7jOF4W4Ql6PjSep6YrUtoCKfKAI_4it3j54J965mZ8FkBRwTqf0pomSjbKAdcSb09xzIbUjaDTIpNzbh7-zukzuYFB3g26Yr29CiaUDZQAsFTa2VLzvRwXUDF9mon-vJr-uedWloPlJKg8Npuk-RvDbZJHYu_R3WMbAzshdeF5EzNSEPdoXHcC8k_Llk3X0sCKJMrtTxvcXSXIRL5p67vm7shrTwxUuCp_mqmb7iujBxl2n6T2rwQ2efoTulUmC_q0nA87SntW8eii4PqsTIkb-ckLlIPaEvMqGK3yuYUZEHM4hm4luqrf9mncWolPy9fuNPkKTjeCm08GcH9ZJiB4AkjPvLj2Xc76qn8UWAUBMW_zZMk01FCtiPYeg6NoGWYdOlvIBiEfULZcAoCG8dfzPeRypOsVy5qduFKNuIriPrpR9mkP6fPs4xh161RgvBSDdZsKOmuHFRucVFIPajGPnX3gOYAqrQgyXcsABTEDAyzwx9p4AdvLsy44Fifphb3WM7R65mji-ViqHWauoOci3rYKfYtrKkNeqcOumkGMYJ836RcwzAvN2tIyVODd5kRKfeewFm-adyek4bsv3CS3kv54SOm6GItnMztDiIIuJeIyc8p4ENjcYF4cl2SDIb0i0gakh5KW_r9tUE-Nae0mKikZWn6lt3kXtVH23JZ-w1Ag_YKx9lOcuO-fsakuRAScNB2LYIeMy-xQNObazFwZDsZ14_RtNnNRI-9_tdE-fEwBv1FXULK6fYCUGLxL5c4Y_jmNT7YSHk8k5Z2s7rup4yY0tg4NdwQqk1YJjiBX1Me-sbvchn19yd-pWbfa4yb9q-6VKWV9HXMl-zVyFY79eAKdtTyyETWyyk8vStX8Ryonwip8GJPCc1WMEjcO42RLFu8fh2UnwM6VYeZ2gfiC1WidpgP4nKZjg1_8A0E_DfhOJ2gsrVC2p98GL6QgFBowmcXSQWdidMqkSY_7qnz-sRdQ0JvTt6m9UWFCmzIvoQUhyFmA4UQAdfEXroX9zdIBZNizUyV4rvnjB5Iwt1EfBhsgJL0TF3-wG23TYTi4MbS-aQYF5-9nnwlESZEQszw0unyB0pzs_3hYghZfpFHxyLd66D0PbspRzZ48NmukX-ZUZKJ5rNonJMWao04h31oCKXO8EEWfbeKLDpgEYu1i1ivZOF99ngmb05RXzMABoYrKqfm08uVmCyiDA-o51NinupOjw1xXDMvmXRjdHJ5CCO1dCVWm9gac9DCWxhhBUXIy2IJlrpJUycR9ONSJ-gAGvJ-m6zU_l5M_WZrysBwWZPh1tdgMvx8TTU5popc7bMeBY-nnhaITDkyhYDjFnd6HTfXfu6vLyj0UwVrTK42tIIIHlja9KP8jGKGm6NVws4L-9NfnDbWdwNrLdMbcTITj0QdjZ5pZLToeY7WUDdnylGOAvrxvqvFnd4Vc8RD4bkV4DK-D7UybljXAlRomknR0pz_GMtEFcW6EDclSPbXFy_lKaOapnXMAxjsWx7h33fJAXi39hpxkwBx_l_dR7bByxbeRrtZ5_mBk3AuUo982fEACNnl8FMSzk70dgOYov0igmiuYtFMcWjQnCy-XZwRQrGrPySiKHNrV5B-n0BCoiXWVQOhyeyvCrDPHzLs3MlK9L9svFRk9aJbIMgN8UBHacnkJACmj9eEs2eBnigtsH85npozjiYV728KgUl1THmOJEyMw8IM3dbVB3HxBlHYX86aBylnyusYWcF2ocTwXO_tBWDeVvorJSK3TI15H3Q15WXqrl4so7DRfKzoRmYPdBoHHvbKVVH02bcidmGf75T-LvGaubTU-IwQigy4zWbulr5IjSOxWgUvdsxqp11rt1aFKGyI_x7vWLRvDxs2kYc0HfqkYT-LZ07l-rDBys1S7LVSZ-5ouSlGcZWbdJzh0juADS_qjauFt_Yo-VNSDSUV4cHeajf-7AylbsxJUCJZLIUXAsUFw4-N1eveux4Szadp2n1VSOTrOl-IsrozsyUwV9Et-4slugDUi6RMiekyfLdC3iqzOBTb2GaNCvwy7gBOwLvh5dT0Fwzrgnh3JGX1lYOSBG7MOtzzVQQNAd5S7LYQYLjWflqBAYQTmqyZERqs3ZMrUJavVg1kKvoqdwSUIb92LtLpl66eo0zHJdl_vHdKxJYOR6U67BP2NDhrzHhdlZH2tDCkARCJ1OV4YWg3utbiveINcK9jslNBJz0Vy3XSMrBbUEZMCJJufwpwWJ3C0FkNJyRiV3zKHK8TPmrfESHFyvegEMkxcSIsquXhd9O86Mh38lvZinwWZcNAAMrMzJfT-r3s74nJ1Tl6_jHS4bA7g-ptdUIA1D8UQkBAmwzHoE2eDuvP3qfz6mV8_0cOJgPqXR8xNrvRQtBC8EVC3R1yop_apEc2HkRkwwyChzvfr534Stk13lmq8B08D7379x2MKlSWCzsfc2s8rflk6e9LTj9IvfOvm135PG5mqYouhr5dnzpHh1Q6EzwWxynTZr0RufcFzjU4D22WSpzJqr37D1kC0Vq0Nm9CexTbR4MSIF2WdQ20Nrg7LRH3a_AnFXTU1xp6HxYc8tTu14UTY1Uzyiut7JF6osqTIc-_FCbxddJ_CNOT3QnoCJnaJqidqG9LXADBGdqiFHdGAH9SsuSKcrppVhYg2ISxGZA34J8kRXzBafpcO_JqKQkNNXaGZzq8WpN0Z04tNDTde5FgHg8jM52m6o-RwUB70aUFSqG_Ri0jj4ZmuIQUvTCTL-xQemYczBU1rNAcIrzXFxAywAoBaV3Z6L9xdHzCErNTFJjjE7ygeyl8Z66-TZ89DscUb7N1xJ8wHYhfXQ78g7RXNZAOyJo9GrSAfgkBpo0cmMPhUiVMAlBOijrzhj6-O6GHW1AdZ6mJaU27vifi0f-Ls-nhIt2a5VEmQ7xXr8R8idD6vYw6aiKShoEXkHizKqowei6ui6f-immFJ8nDGWeGYu4WOdZQi3Ou5HzN6GwUM5lmNYI9pTJq_TGNp7Yxj6xqSntfF380qgIf7WGmj3adwG-EqpQryAAWoQvRwhuGeLf4k7KEo8eShM1RHnUX0QSXj_CDT-iQnsULOE8NFII872svqNAiLV9JvzakvpP0QF81HwE4dSAyebA6hotBuzSKjKOdyQdQL8ztA3PVGSVdpVqVd0rgUrrL14QmKRxrDoXHovmyxqYuR5o0an2TFxngfUlUvGKMDtTx0e7Uq2mUzTGhv-AwW_7C8zyIMQo06Oj8M3pmrVC1vfZrC-VgD1Z1MRMh2nxoRWwakvGfMFD8whsooxHr4YiH39_ztzocNXAZ2HAi7UPWPcOBSv6WHSXJ4PMMniVp_FT4A5QRytyTtTeHr6WU4NTYg1qojpqPvFM0O2iMer4DYPAC1ihwF9LOf89Jgea_OE0XqMfZfrcN_-5X2jN1x23Rortd1Eucd74RhNirAA8jaUpU2R3BOwzPF3XFIQ25QiXAQbcfsVXo3XrqhDgTr_LNz4cWwaZgD2_141hitugBNDNwFvG1BNfX-ENMG93L-1NB-iDFYz5EJpg7hcL-i7u9n08UG188jm-bJkvz8pEGThyUOuYFYIOUbc27Y1gaIFA220_Rcinj9JBxWOOaI6mT_G5PUgcB73lbUz7RJy-cyYiKogkJ38B9uWMZCGxzAbaz-MY4_jbD2B2osF810DVOZys_n5fkA1h1ZeW-uo0rDmAsJm4N4lz66KjnfeAHeOE-LfNIe_nZcnf56-lZDwwOXosSxA07dNWqXLnvoqUcTUpMJz74z-9jVFqZi5qW2iA84orO4alKktu4bj3O-zawfv1MWXxRtVsm4f4TkPHpC8wgL6bVXqpH3-H7gTxzYkYXSk4zTmzz4Nf1HWNMTBFlWQPwClJrkOpVa12c6UZrX9K4dVoEbnl12MFJrCvMfWZoc1Tq8ptWm1pRkXkQNkaW3yi_d3bOcaJ9LYn2RFhL5_tZc2S2g4G9nwo4hQJ3ARK32xGddfju5NBLg9Ib1C-qTUY2wbW8jog6jNtajdMdip16T50_gsiPU0rx3V9Cbz12H9Stz-tCv6XibvcpWWPndsyH9MNFXV7GHSzw2j5FE4-iZIXJJm1GO2BvEypqGfOX37xXGSTRbspbIu0cgqgqHV19DbV_JodJcwhR4rsTgamyi1kA4p5JaBbghLtRIlkVQUo7fxpdACEP_1EAc81OhgALQTlOx0hFrotHnXnmnWSwnjiHRtw7K23waNZ_zrOm-_n-hNgi9sHKPpDDV32BcKF6jQAC0A8bY81TH2iq36rE-x3SEooxTJzgs8bnU6nzGJ_-qj-Kk0-Z_TVOEtEIEx0223mkAji8Wilsfr21j5coJxdLQLuOwDfPseOEGEzqrmbPGCmxGCbcBICWKjkw4iQwSjPIsilkEkjcTdfl4TAEvLvksl9LrYg6MKjXzOmT5xLY1Cj9P64vtBqdzKBh9FDyiOSL8SBzM2zunXat1sVr5O9wgJnvpiy6f-UEqMSPro-RYhndWjT1cw1vkn_QdHq73DGp0PgnaZ2Nq6RVw4E0AT3Zjx8JcGvq3U8HxKKmnOLhOvO1EPffAsvCfT0Br3tVML8wp3m89rUdMyhgCxSIrY05eBpA6OJ3xRun8oJHLZ3ct9U3hGp2urkFOOe68opJc5QK3e_j0SIzuddLoRREhA9dKnHs0h4JTaiwDwryjlIDOLjhYO5ZrWAocttwrLhj_NAj0TIxDTz9yvnth0xrul_Fj_ZCxr6dam9_VTHBxkilaHiHcxfim9QIbBeoePoAokK8qv2er8-6_SE0c7LmknmMk7v7wNSMjjawYdZq9KvlemebVkPpiN20I0CaOBofl_hoedo6k7ip586UN4BypzYk6L1GmDy_7xPzZQTJ0Lygkn4fjya48ghuBdLuwJapiMBpzNWL6zhHZJUBoFtvWcu2OpDesyZX2FV7sllwkP2m5be4yrxPt85dgvLKvD0URksXYKoAtHHq7FKoFaMGBJzm5hp0eOmXm9OHpPhT5EpJrDD9Yql9JUruZfLNHCsE0b0moXVvi4gMRMYwK2AiXfNtf9zxhYuQXQSb0b2DLL0lpvEmhSEZJq6tKWjR7Axyss81wM9APIS9K1HsjCNS-ZSPLn92Mt_LMB6-cP9sqhErpQNsxyCzCCIwGb34qqGgRFsALG_yOWJNbNtfs1Owh3CPsfMS8SZ0s4vWEqyIBCSs-KEA2UQQzqSBnZXcLXKxQKDzh1UoHQ7GyrFWfIoGclCe-BSMp27syK3oG3KtwI6qqJZE5co7qQHr_mVGyPoVQgoSfOMxAB1UJ0NVs-bZH6SC9G5-QQtqDGNkpOothZckRbBJVdHLjN4hij093ZURB1CV0w-iPn1QnL4GEUx-DeUP3-FxkDuEs3icpW-5SmgySA4-f0cs8NlkBYugjsyk7v5SFdIGMZF-xOJpvecFKcL9At6eamqIqY9hWQQ-sYoVgXEBQBmvIKuw3xxtIhZ-_0E_HNIXnvTfUSsM1VqBr0qqiEaIfYVp11x1_fOXpYjtcmHO-Xv3C9s3przi6a1YtuCEySW5jRnQvVQVr6Da1rYwtB-Uc2MIYnyPdzOuL6FY2y37DmFIIGpbEHnREtqvUwl5GKLMgUO3RdV1SobxudMC3Zti1qV1lPZ-YVXS0RMlTXAmp8icPV-lc1l9r3Mkt8-CBe7MMNEA3DUhI-KEcwgAZO7Fbhdjc2glxypKIYODDOqY9T13Au3Y6ebchY7nxbgjGf59VvCXxMb8wovHCUK9eQT6FdPWziGbFvIqTBa-SXFJrDJ7FMUmXM8WnGKlUiKCVSHuym3rDMJ62ZnQ0hbMW9rN24ya5SC11UL9i1o_ptfT7LYe6yrYSvfwhraUJ1po75tIbPHI-hUo0Yso6hrdJtxO4eEVaNpxkZKJwcDWQbnVPWuNVmuJsq2uGCLkljL5JykAqDwPbN_QIihSTU0amRBCP_hcFvXXN66UST7SAw6q1mi9cfHKP5sJ0yUE6UwXUVDWYK75cIRGh80SMfzo2pU11lkA7q_a5PlBPWuTCKW6S2x0tg8eMOmlVqmlUaK4NGbmZvALtfz8jWpX4BmwoMIMvzThtUJtWdtn1_03yBE_skHof-feMjBLdmOkulzWdpJviGP8BfjvLhBBRqzfUmPJU0SU8j0M3rCdtkm041epvI98VOVNOTz5HCTrCrq-KokQ3SssE13PtTkA7nunqKrqbhJsY6Y1huv9R3j2R4In0_OsNBFkzs284FiVviJJ2YvsChrfUoZiUTenYq8hg2DcIXmP0rI84a9RWdvd5BC2BSjy9G7GXPuf_bkiHwg2tElnRIUBB6_0fzH34pPWtkhPQMwW01ASPK7wZPUwjPfN0Tmt-Y2BO00vPjYuAnk-P3fHJJ8q0RhzGMimYgogF-9BEyJbCjNrS-zvrIJc7DH8PvaB0zjU0KrYIj4pR3k423p8TPEUQ6OBH1OOjmGxivADn2Ry1NuwmYahfoBW-WFeRkHC9jks3hn4IlXc7Opl7lgGg2TbZJWlBVmoSsbBjr8yeUfFPOdbCoOXw7GCQXF5tciaeBgK_sflI2hSDzQKdNc5W_42XdKRaGHOzBH4dxbl4xH8mW5Q4yP2oTyGrtD2HreVO8jQY3Fh8M0vMAf_OAF4LRb7oW_szWu89M0KXt9Q4-ipT40_0d99SduSIONBgsB3kqbuIWtrc_MLd-zY_v11-v3AUj3u9yvzn9l-FDQC9yAhql397D6JmW_rwk_l11ob32l-F9-1UBh6NOg0Dnw25tY6uGLvrrd7dTZiENqb3IoOrEcMImSAvndIdg9YwOjNypxKfPlJ5PxBha1isR-PSKWfCWphzriBD6fXbiCKdj0IB65UORaE-3ODLKjTLtm-elfU8-4V00YQh2fMDOie7-mggwMa3spGP5I_SrN9jFJFOGdjT4RyEcWaZr9SxAyWb-pJxDYeuTGHDjqG4_--2uZ8pQWtLfLoq-_u56fxpEThs-zvZHPNkMl7DX7rLJx9p4FJC6fvmvykGed-BeYCMp1E_WGLfKXZ4ASCSF4_FJFy4ElpxWI2YBewzec4sMdIFUcFtzDHaaJShpSaeAdZAsF3AkBaLaLs_b17wVsAl4DmXbHOsxJbzy1ssw2x0PKk2G4DQtW7UufDr4mI-ghLfjbrkAQNxXfRG3lGTuDaxsfiJVijxOTPPOUMMrgEPX0422JuXh6ffGeAqaaFkaf_7iECSo2ebxbdQVuZ9llBabiqmnb_qQdJ8-oM8VUajKmmlvWM4GRyDGVQzYvBFQX_eBRT87jeJOuwd-g2J0O0o1N113z3GuZB2UBARXMqn24k9_GZQGDV5ozTNbtI4_5TwYh4EQ8WWolm0nkV5pxm90GNExqT6-967HB525E6F737AKMpsCYfLeDXAPtKhTXFI5DPAbkof-zvwlbjTWt6c_h_WNGaSaQDa_E1Nqty5RbwLfdOBjJR33ZsGrLEzKRQAhRFRp2EFJuZtUpbvF8rZdSsj9zRlzCUGiwq9mt9FMv7dPAtYSA22-mGfT46HyYdFzXg1lfCiTZlsPCYq0swJ7YBNbAmx6uP8kfC-wZzePSQkpOmxlU33plEj0wiqCpqa2xEe2KSJe5341OShRhLv2Yi5L5jiq7nP1jL8Et0Mg0HJd4yH0Z7FiBrQyFtmgg29lpxC0jyzjD44vCoPW73NnDxNZUFwLkoeauFZe_Nu9t_6vFh1dpJilQfo9Fh7P3T04iH_HjUaC1VJCNsnIor1CLKSiA9t9-SbZIIT7YvuP8bUJMARLri48kr8mwLBgErPLzB7G_QR6j2DBx6chAU1hSWdjPjiaunYDzqjf2NVC4S60NQqayjeCozKzWVG46gh4WiDKojrVa57tfbB2UVkDqAux9oY0y3aeCEtJNpJVMnZhxRoVDkVeIy9eMb8PqZDVCQ5H6PY9U9lnuebCC48zznk6jETHdueWOJLrd-CrfzJdL5h-Gmx1rGRb3bYAWdFKK2_lFLM0U2tyJPIIdrm-qc7c5zB2fXn8MiYETtJtEplWo7c8wln-CS-E4VLtfkqlbjHW5WuK2pwLbRfY6CjCWH1IZjbjkvE1zyFPcxD80SgWtEpdEd33VZYz9PiLKqX2g-mSAi0hbTeKAyOIT1q6D8vz8FqoprfTuiQK_NsRNKS-DIWKGA0cnBqaBtj734jt_J9OD-rOBwg0-mQn8pQAdQtYH5rWsmFyvt5zt9bsgGAtgul5ovyGnT2t6gww23Z7tjaysFm7OP57DbQ_DQjcU3kzbKq_GYEl_w3_2PofjjaQ1qrOKnd1D7V6t16SDBkpNZ8G7aWALIHSMD5fKFZshGCgD2DPMG_Fd_Ti5PJ3jqQO7ndQXGTMWsUl2a8iGRCfnHik1bk9ayUfwHIQXDnrJl0Y2M-xJtsSrYMnUydSzWG9_qug3CXDhcYyH03RbUozvlDbgwTGQW83hfz1NoP66lMc4wg2RtARFlKmrxAOes_A8bJ9dKAQpoL0orbZNVdXO4s2_FsVPiFvNxg-wud3nXV6xi8CMJwIWExS49_J8614j8NlwBkKug5uTRSqI3v59RveW6ZwMttuAEQKzTLZeYATLV12q3r-zGiOh8eu-ZZxGwzai2ggpyjz0vQvROgn_EtBNcFCEtzjbCU76EJY3oj26X8BvNbC11o-xNxP9jbFrn2lPDTI3kghfneyAI3uJG3rBL5jpi4v93u7iqUbdP7BnyUlnsT1kvpiH-dQArlxS9ule0h3J8zzs-34WvDoLZs35wkpN9b0PWB287RFD8HEgl0xk8TTWYQbAPdF5iJBVx1TXNH0Z7GykWZTnL9usx-0nWJZ5CHYoxVzJbEC7lDzRAXNvJx3chosdEJZqFO5ySog7_g1qjX8c7ltGbToKFRFHy5YlarZ7ONJXqZZ0yEU_rFJkyDvURBUOVZsMUwY-s1qmeQnG1H99ojFrvBt7Yug_UIyOSOdO4vH-494YvkWZr7NawR50acb51z59j9VyAzHPl-CWrGYVPQN-DOWWeggGQ86RFpLNCxErmLMgxVNBrM5nwx_XMpqp5yjFruo6jNnPCm4XFIu8C0H74tRovg6YjXR_XptNNsa3PmsFfzOWqkpVZGjiZNceg6aOwHyJhWU810PXAsa-JsmLm5CBSLpjFWy7_A0zX-H125FQc2JMKWslnvlvS0HxMxSQXie_4fWiE1cqeJrxRU-GTpTdK5oMbmWAM2NSYeysKo7mOLMjknPIceO_tGV4OTqhU8ySoOQpWHg9WXkCsSyA5kbxhvlIcPGLP173PPCGR0DdfGYSQvATV0hvmC33MWr9h-AOdk4aR1u4IuksciIJIJKGTA_dIzi0FOOXg8ePg_uqDi3KFrFLUx65iC9wCqixu3CMgGpMgeXglWbsjjwdpYgXbvqhI1IP3PTmDAduBRyatHybnkFWk45BigZXDsdX-MoQfbdcaCcNB0W9FztCSFz1jLjDNQ53WGo0pyGolUmY3nzaA1zk3bSICxkJMjuv4V6IUcOsQvleTTSsBhe0QqZ36ABThlL9wpcE8Oj1W2lrFCG0Fq2Eys-Er0ibFq0pHr1HHpPxgsJJbTRoO5VxnG6lSNkWZW_DdWPnKnYysrQemoRT5eGmat97Iq4AWHcABif9ZuPYWluY33fkv42pMthnxOqAFUv4AnyJ_5EnzZwOYUd4viP7kh8rEDLv_WjMOxxCwHrCFj2Lk3S41UCyaMi5ZQqfCJFOCs5Lx8nzSKvNoFW13JcwS3S0DaFrYU6-nMtUdP_9ckRoXx6P4DdZ5dRwwOANCIYrEgo7zftboX2C3NZEh4SWA6Oid8V9IhHg50qWZe_3E818ve6vsiscXnlbWo7HGhxEbbo3UHSj6z8PBZEcILfP4lBYlZGllHgQoPN_TXoYnVxliYN2V5jgnYX2qtpHe6e-lG__uxn9unbJcyuTTnH4Vqvgd3hcEY4-izCOBsr8As9d9vDFCywV--n0uWdlzEHXAt_-ydz13Iaa_AnLfRO-3sLYl62cNzwn5jLM4fvnAqpd0xYNeGPske7IVyfaw-DWrUsIvTschw3dyUMXW5xuHNrZ8lsxr2BPGbQCO0ddFZ9LUt3_rETEE9ICnCvhuBx6OpVvwPI5iOCjVSzMHVnrpn8FXJhD71a3Dq3M20KfW8_dRnU_lY25svPDV2dGi2ZOaz-cblbUfmPpucjUDlR7rcnL4MBMBuz_xanWj4yEsOFvscJYlIQSjzWOllS0zPdl_KGWCJicrmoLA_q2cVquuSODsdi2cHeCzdKTZ4BrveEV8VD6UuTdScqASAEHYH00dnnPzuhHgMsQGIW22sBT9ZksdIEv-ZyjxCFcBxK4A9ZmBTK5il2jrGXkByhNMmCJyps5iHcgWPfwrV5YsEXV593HYggtXKiJNaDVeFbHqpWbgZosp2gzp064mO8AFeQChd0kL0uj1WDYPEmGKBaIP7njUBhBh2zBDqyhy0yHahDr_kwPrJ8OB2B2qI01fxDYJVsnxkL5AsC0hAq7cZ1AEvuIWdfkg2Pt0MJsp42uxK1Y9LmK-ZefUFGFXHOIWjonJAnkltgn8bEKllxuyxaA8E1VCUI-XsIow9LTWBNfOZ-uqqxD40Wv-RaJDyoA633APQFWpaLKyUQZ-Ku2bn4ZP_-BMxklcJ0mTvxTHGVpV_cSSK58NYqjoypn5i53AQpoozGoOsByiLixs3NUDYTcAy86K-hBj2dnsbij5aN5olwNJYARg1DQhjZLNZFakriqXweE92rPFatFz5_kNABoAJa5mUCqwnKUggEhFy69tI6wq2w-L0bfgMgIpxozU54pXxrQdoTdjP3KSdJaNbrRTXgSR94OTUQk9icVFQsLfOtT60V9mY_VsJAwS4ev-bKll5bbI5rSzzeobV3Tv5Cv07fL0-CkcJR-JXQygXjYVWAEfBRtcsA49aIp2Aln0Cn49DQyIRtcC2vIxl2uO1s7DjMdZJdKY4MO3ho3WNKjXZE_NUhBXet1sS8SkpxavqDdKJ06YuqgwS_9wp6rJyvbaDgzoKz-VG6HkJZX8s1igwbHG_7NWLKak8Sfysf2V0TH6EYTzJsqHCe009QHUel39wtCLUvXVcOM-LgXJ1iWZFJIjDt6eWMe_-RITiDLV9rkqZ9K4dCfmJ7Pub85ENuQBP3tnnemI-ONHitaEPZ_bZgE8BouA5ATwiuLQYn1pmelRR9Fk9ZiJvMdxoJYu8ekwRep2-az_Zi4x0XVdPBo_OY-6VWyonX26Reb1Z1w1enT9oMEQu4a6vBuMPyiFPyKeE3bpfjxz20LialI_0XAdlnjWr1wUT9pezHsbME2YhyOxzZz6FCJb7A-6pbS92qR1p4QxgEEI7TWsxYG0piALiR7vP66642r-C0ZfN-QyVU4aK3NUJrFf4cUTVkSUnAWxmJNWDlHZOm_E9DN56Ewlkqf63YcLoUS09iW7j81x9lw223skPnSwaW7K2q-GQC_X76Tb0NuADfPr7bmvad05u_BzpOsXXKGsvkh1B_zUZV3Fum6HGeUA_pGheDDdWgwMlfCERlh8tCJ-urVvHxhqooA2p_Xdf1Gq4zl-AyspTFrPwyuQ3lPDPMOQf0Jq8-5O6b6dHQ803iVM0ELYyWwKct211wDvdMBUFyYWOrue1euLGeuwOPjaXXkRDYS7JKuBoeohirmvE8OiDUtV7gm71xWXAZ4JIwrEn9ATcMgyHAMahAMoYz8WwFHj30Gs9LKKAzRNpRe4Uk-Z7NoBTrV03uroRE7sr9giBYqzPTIe6w_148ESb-fgWWbLocJ_w-1wy_TeD5nU2G6MqAKk98fc9YDG98bmpxzl45Q2AcGsuWDX04mGnazg-jlLsOji_h8ZOgW-24YkErfwSd-6CO1Yzrk1UarxKN1CMNqijd7joI7MXlu8QZysjvvqL3JugwEHnrDW_34DyWXfJvb9KqGvyESrI6NncMkGd9TJGsW1WyDpO_jWE1xzTYG8G5T47owIOdB_knQhiviGNOw5JYD7GzLltH9uToDaOKCu7m7v20LShfGGTu2W8DXgrmKOKrJcPK7LBZlBzXI6c1zg5PBqymB2iOpJfYCjsYYt-cp09sYptZ9K8UI84i2AawAwY2APuVnPOQaSmA2pdIePWolJR8znh24B3iDd8D_ZJCov6U02_2njU36Bskt3FHgc0qbgF4yuzlJZx17LEZW90MU_PIpywfohyoshh5xRfZuIb884mWF6ttoZqef9b_J8F9VeIxwdeCA3gWm9khx_WjA27lYPy6jTTzJ1qN4XsSj3cek7V1IOhht8UJpfKuUN8BVBcPXxfXhO-Z1RakQ1GxSnyeGpDDPXjgBkRmDVT14IUWZu2j-UOliB2Ym5o31qufNP5kE2v6crwV3Dpkrzzs4bsQ_75jI8aDn_8YlPB4zrOdxvst06GjaA1nhCsSNld1sOPiByeDTMKShWBahDEM725M1BWjD6Jfag8KJqXE47ZfA4WqUcJQ_1p0nhws6yO3MdnTUE6YqUpq_ysNwKhf6Yz5TpiqRavWRVfh43AC2LEPoXkSdwK-LihHjKiwDN6uy78ltc93gHehYvWZWKpQf1NIQuP5KXzW0AbjrHsO7_EEoDZE-9NVHBiJw9hNNPKDyjl5QpjDZgwZ5cqSZh-4nleT8e_dE8vKAT-YL9BzsgKhdLMgJ4sYMk1GwrWhF-2oWx0L5OppWIbYS2SwrV6QooPGgSU3Muto3n9hvDwB7b7xeZoHvKR4lm9tu-0cQTp9Km2blHqAyxXb3BUR9l4i2EPtlsUPsX_njdpYpPB2RPr8gF2MDr9oOCHhkAEA-pKMA4-yvBQe9UHA1AC4u6KUj06YqzzICdeNc6AD0VA5-LkZ6cu7b0sfKwm_rBIY2Rtmdl2u9zS-3HmALAlFDjWkubPmyhKDCxXrWBD6biJj-d6HxG_kg6gncSKz5L7R_ZFCFOMWTyb5I8Z44tgzuULQf-leO_b-l_xguAXYPtbCh5u2Y1GcY93tJtqHS_18qa-dkuTW3ivQPyuJL3fc1qObnIQiH49fTHy-e0sfhusG7IjW8GMPaO1vmfmtzqYWynGjyhbPgBvxQN_wLZAIRVli-oenbVkv63COaaL4-DsZMsKQ48OHyA_xAltReW8CjmUNTlsulhNzuQHxo1rkuDmrBecm1nkY_1IhoXz_9zYyOX3tBpbKxPLF1irQ4rPtXX8_SHAQprsXsxDDOA4aPfTsU_beMKmyVQc0fDitCsSzWLkcVMRiCWk9qxwcWX6pXqeUR2yidWCBl5jJMOPkHaDKmSM7gpNjPy5NjN-b4IbKPf9l4edYkKH1QIljJM82JaU67Ts5JlqDAb6SbXbpXGAh84SQqMlV6HduvQEbf5IkVjjc3Vk_-2NxFyiR6jEnqRtnWWvABhqGSLKEcFy8XSIivuz6w4Lm2LC5yfrRtzc0jZ3r5YrtPI7es0ZAdV_n0-GCeN3ozyLXuq9Ri7tRejcaXGebRy4hI5jvJ0vgRQUT98YgxoLbIpbYjX0B_5Vd0REG_HRoy4qfTz8lrArXNOfL235SCoEfBLFXaxTZf3mEB9z6estJpWNTEVgHRAKmf3tLtKC_TPYgoKjM82SoFn2uIH9fQm3Ubdt7a-lKZH2zwL9KsSEw7pizscjXc9ifldLgrE_54z6ieafQzWGdXy8IQJlsQxKBXnAOFuuRR07_fsgHXXEEhOZ32rG8YEm-62cQI-ngvgY7DAnQBUXhBy9vNKIDsb2_9Gnsm91RVJusQvk5YvpEx_RpULiakm42pGr5GLXnGmV_W_nC2qxcmuOPYlU7uWJTFEyyHz9CI9AbAfckiJbMslRIzuXyr33ikEZrV75zyazOubhQ4Xd7RIl7OlUqnIauLdIEj9Chx4ZlmoVWQuFRcvtTxLj38x8AUa00dBvI58OTvp4XvAdGjENLLjBSfMV8kpJuvZkd-Qbx_VV_BtZf2GzFw9v4uJEnVf5WcNW3TZqO1m54V_H_9usH1i_lCffGjWPPjO7yavFswpxopgGPyec31BiBwjETxKanALg7BftmRrXWdhEsFv444vhQXpG3TXLa7YBCz1adlZgc09XHK9Cz1i7rZx2a5sh30zN18zPj_pUpA1MTqQZBt4nFjKjTHvu2zhSBQK2AgX-yt-vtbzt9m4KXlDYD0vktf4SC2axHOR-Ced9SJIkSN7SzvZQYpaioipl78eeVZ0uHNuelEpkW_QFhBNMZf8GD4lSjmj7P87t3x46fJhhckoG5zPPG5RM_-dYbu6_KS35P28pC-vGy_2dT807ay4g82WJrhhGDncS9N2z47NusTqzS-Ti_gUO4sCzuqhYeNPVr7DeVt9s9m4OkYX5avJTUcQ7yQYwxa3XtZx5okAOfYHN-vV6q9OzrD7k1RPq0P5qwYtB25RpsqyeVGQ92hJaZiUhwvhrW5Csrk9vgCr4VsEkMi2XoBWflDiuooThjIXilaU3aFVLJZGW6eqqexnW1_Fo7msaaQ9kR18XI-7GZ2uGSOWR9UIEJ2aW_axEqPWw7jv2vGTyrt550_tESEUwoRAD8nrNelnICH7AKOOS1w3Dx9-0QQM-llo2JUVP2hxGe5GzY3FlC7wMnRYnvH6Cq2JMbJxoAYSwFbHjBzfUli2SWJ2rTm-UqAxBFj7I7H30tEOm_9okkx_ORL-JYOoQ1yRYvvvslVZGugsW9yvyWXYjiBhsFModpwfxpGCXUC8Og4yUVP65IyythT5UQE5Tz0o__hre8OCk_dhG89HgFK2GgtcDCt7FaSBNytyaKzhuVlJBnC1QMJLdzhHrKTp_wT6d68eC4yaB94ffophuO-pWxkcMCpU4CynEgOqjlAY1nHzZFFRMwHWdITjg4IKyz7U_OWN6ragUBYD_XWslb9gWlJmQIrf4Eo5tRs05xl7E-Zo7JKxLihe6LY9-a3BHNGFNJgp0P39WbD_BINejLywFzKesadPZhqcmNHbxdOuAhFWQKwCoU28AoFdbNVl1vbb-uXBFh-FduIiCcT3tUEMEo2ivAmbeRmqF42CGZespeZb-afoLSp50jlfIamPAamkJKjOkHhDNOfIWaB1i4wVImR8ymDIgDTxpEYfNJoRI7l9fBsxW482o3Oqj-rswbzUnxuB7o75YwL9UcypmnzFcL1eDGxeP5-jSyfPXDTIFAWnqD0gkK2kNI-4Dqr4b0tTAIH0HRPB5p0EiPDgide9qphKeiMeWMZqjUWqFjXoZEQVEGPYFYfOs91iCurhVRvF8qzZmDjrA_y4PljBAP4JA6lYNAV9lDKaKmVW6rxJ-1XrHgxnghQCW9ZjGGDkEzTJbEnVFA8M2ETECmftekOThyncpGYzit77TrMrFNqOzKpcyu_zx1jwrid7Obv9IER77vgK3tYyULZ55d7J7bY6rtfBZS6qaDNDwKSx7Bjeu8z_1oCJkkk4LjIBkS0yptZ7nmw6PKnm_7WY-NZfFQ9mBBaW9mj6rs1B3oizVlafFDzVqvvVyw2rINcSWoY3Mpb9QV1lyfDFeX-6vCRBXJfpwUi3LFt4RRZNPF4KzNA2LSQWcLrw91o-Z0DyqrjXF5ZyR_NRv0DKgUZOMbMlhTTPdeOd0noYrXEJikXj7gC8aV1T3DhVfwPl-oYwC1WX-k987exD2d31KSw0nxe_fxfOSwsiGx0iAFM1j3nzYQwryUGq09Z_coXDPtnbrr5o_zmtOrN3rRTiyDPXBp2wYh7DFuyRunkRsS9KJXPa8pzDvJbbhN0AVRht-L_5wGg2LiRy3nQRGGJP3cBMvCsR57jEuSww5GK0c2to6hWHlRMWZt5x6Y5pCbggYSLcvtCngHFRBcEWxN3RrjFq55fipOG4O6hRaWODIDvsWvp215Nmji7GZigIDgq3h6HEHDkPB5sN7wopeAbv2LM675_GqT-AXBlfjERUfS4JSRAsMYvFLprVMB-MHb9rN7Y7qRtxEEk81mRJ99gfZqjwwx0nZMyTT8FRU5iyc-z-AfE_W8Iw13SvUyxt3cjOh9BG9fOHX1XwuQNGuuaqwuYS6XRQcKtGsHDD3AiSniZB7Z7pve3oF6rEVMj7xW-cnbBzrP852LwHfkWgkP2tz-RbY18InLxRxFVjGxY8Vr3ta1EDLjLS0jstoGjjkan-ZrHTvlG7gy3jZJfrwtzhzzX-c4SwFXM6SxgXVUXQgsUqsqJVL4sIzazbQO79BTFXnANeklfQUaOI-RA2roaNvccgUtzDofg5wGBWqAD5SjEXLkpd0x6b7LYQR635m__Zh5rxJmIPqTC5hwpYUAdpJ0vU_GCtA5datoV3M-XdPDTp3o8CK86ajxEpQQz8Z7RQhfBLu2COwbRAKHcroA9X06G6ly9_2bDqSTu--lyU1S4iLmUX6CL1iuk26erEdRmiIFI5dA_Q6GhQ-ErH5kgfTkyCMlif7sKpa3dIVsHVegyTbZRtLCyUjS20ITguV9Bj6wP94FWBgx76CuFbU2cpoLAr8aKK0lzMumYSUIW0Ee51FoZyp5Mp_IYdbsUnS54tVhAYIa40euAG_21UO_gx0b7DGo-LLXkrQLyaYblE4_wAc3dQVn4xH40EuHnlSOhaERuQ2OcgUOwjkuEsgVg8Vs9JQ6VMWcu-QrJKgap3Iyfs1TGGYIw1Q2yM0d4yhDrxaA-_anFDG1etTma2Gl57VLBV6AmslLQQ1yPqzsfMOcvsuU9IzNsEpt5lvh44m4fd2ICJC46I28g5YX2dIvEbKRNv1wKqx-fHJsXZGwCalmA1oQG2BhoXy14wBcRg4e6SailOyo_0kY3naABJJH_aIkFCMkKTI6GYhZOFV53g53N1iB0kx4K2oPA3R1xHhzt1rsb2kfKR-FygmOE_ksg6_NGQ3slu6nGU67GgQL_xZJDlgPf83bzq4g-VwiEKCX8vYj2401WHL5Alx7XoOnnBEVCMK663HrcsEjYwCB4uEjtTmLI7lkAEiUYYO4ylw31mqURy0UthO2ZN6SCgwo-vMEGSgsGo-xZobLFYZ2ZMWqFmGTtig4XM3mss4Cv7-L9X5bE4xzecI0JI9Q0kL6jNmdyTA9r_nBEGiQr45TtbWEaZQv2NgY10tOsxyLxH6AYxtIzQZstz-9zmyhehG-uBGGi81PWtjA2RWqoGFEeeQZXPsdQ7KYyMPs1yxFBbLAt5M6KLDcdAnGyiA5zyQfnSAtvdWcnXlguDddDBsp1sfGtcgkGOuYUT3JvpXBfchXQV4H_BZ1QMOBs9o5AxQVR3SJqLwf5w8hmyXVF_ttJnisaVfnd-BtOszJdwAee857T3zjUbGrA-SpXe6WFdle3x502OzMkAH1BZ0cb1l1fxIlEIJb6IUwo1dj8xr8IFB1xef3-F5MLF6zqF1H90RDgPsCKzlOLvq__4o_R80kdU1kWtHJn54RGPw6JfWT28AFkmkwqe5wQBjvTNIi8CUNysp-oDqOfqYCKCTluhOInuYds5s7L1qr4L8NRC5CeBx6fENoh2hF81aPlPFICGwZ_sY-aPnxaPqH7uZNhRA6LJ_biwVICUEYfnNKIjb7yq95yClvjRPfPcto5UNNPbHynZBq8HtFCQ9NC1mnMGUyuKflk-VqT7oSXsLFtgJ_NfgEpJ1hqtkE-7B_kibRS-qZQFR-wLxBIiTvIgd74KlD4vrugrzkUnJr7R-X-kevHdYtdQPW5D0hw3xl_UrXKwPrKq1igdyNRbgTizQb9Bp7EhyNIOtGAINY3eSGJzy2FskEI26zTOYrB0IzguTue-3csg1cCuo5uTR4bKdl8Q9z6l8p2yqhhMSbDk6-9rb62jPlheYq1gi9L4j4giYPTDqwfLyC0DaXVayLtrnSQ3VLc5BDX6dtLuqqilkE1RziMXtw4L2COkd556XHFIvtsu0-fAMFEC-p0iJqH1YQ3aOy-aXXEEouC7ZpUYNmKczJhPEGYsAjgKVZFBcGtKSMEb5UlKW1U_rgyJEn9z_9rxAsMso24QuK61yd16XJgR8xRlqFo9GRj1HX70w0DkmIN5WVwR_zIo0U8nBgLMzoC93w-ckLxet7PMLoiJWFzZNqibD5UR9Ry9xQt251mGb48cJtgYAIag1-d91u0U4bXMdyKbpyJMM9lHkRwkKZquS58qEjPZLu_M1jCpfW7G58oFgJCyuUt5JD-hQGuUxls6_OU7R_NbbLYAFgsmRSenrRNtdilzJYe5cgjwl3-WZL5LHIHa_H-bH3MXErq8i4BtlP4jp7uUEU9NInPWqaLfU3N-ZfsNQ38QJ175NrNJdW2TOa3WWfPGHQID-JUBCQc6NoJEFfRAD0qOUyYYqoI3voGOqr8kAf8ir60qvFuQddHcFfsfRNBPeAHriJK75IbRgib1o6zn79K0iymvcl52Lv-EsKxdIywCT2i_DES7d_1p8LwjQyJG9nd-cKrOAaLYDs7Vc2rCtDHkxHfFNd60hlpVKtt5XBL2z9VowFpwXehdeNJEk_nmzBehwv7powK3LIsyOCDFD_oQbyFdBjCfodL9vwQgLRJtkq7qgsTSas06p8qG5yqP7dkKQ04p8IpUAm_6UKUQX53xF09ImkdZ0bnzJsL6kHaSiBoOmzqEz4Cf1L_EkyACqtPyovbDwxygd7ejD72781ELDptXA7wjHhE92-TltBhVwYoGOsiyzz1htfnlrMSUtdAl4xjA8NqXHiAlk2mdMUSGnx2oB2viyGPGd4RhZvDS-Sm85Ph_ZXZtVDkwSW90ndmqRu3yXVgC6COA8tbEzlXsit0Y1Y_vt9-a9bYYLgT7X843RfTV2G8GqFM5IpxO29OTFQebuCELUNTijSXbe2dWMHUbQBAnYbP5QLaGwasOxiqs-XKfqr6jk9m_WxxsVmySbyaeutCSqp0s1hQcrZYMvmExlTZPI4lM-wqc2L9XRzB8h_cP64Y4rfz2SXkC8fzlLaFeH6jqVvFUiFA4_7nLcM40T8MgJqeACgp47Na7mD4XOAUgQUn1KPq_3rraIlERLvfdEbs88fmgKMA_At9Ig7Z9WNdsqIwnF4p9pnvutTVKHzJvrhQgOPuY9LNGo_z4DHSckPdWcDPGqrerc-SYeWEjrXfuW8yHVwrBkf2YJZWEWBplhiViFlttwdJRrVwr4RjSXofjr2FuX744mT2IdcMyuNl6CI0Tl2hSVI9SXxAswfaj7LcKDX2dnTk1jNEbREmV1-jg5UYTnRmMX-yVKudUjb1PTZoJy8Gsl0kEaCDOvG88IFtEp4ncOSZqQQYaloM88U32ACDib8pnmnOYO6EFvuEzU8UdZxqB_z1R4UhL2Q3CfsTMsOBWy7EG8lAYd6zMtTX0ckn60KllaF9LIzV_0wIk4P2BmGUn2DBLKYx8_Ber6FmCecbMpwvXmZXbGg6nDUfFkR86NkXAeEQlrN-DasjQSy204r_dEQakUflTzpLNX2Bvx2HcxKdQZ2DUN0znGNXqmtuGTWKqYimbQzapc25WxH-tf4nh8Kd5ymmp89XV4Cn4WR0e7KWoksogdw7mje8aV5-1rYQ2Yqr-0D3OXpbbIXwIf3hknkuzYlhd_ZNC4ePS7vS0YecxhCREgQaojHdXe6Y7FsFHaTbWzp7aliEHiBvOPO_n81OLNRDVmMzGUV12ok0VJoJ9yTgd6RraeuYBVicTQ29jrEKZ9VUXE4j4CU2dx05Cl69yd5xBeVTIWVi-VrwR2bo28I3JF-PAa2a1WluUXs1I4I1d1F6RbKFf-a5jPQ76BgKKS44RCnHDNkAH_Ar18s97GMZNOQ4mqDI3DwXg9ePjn9TLv2e-Di2D8oGsjhbTZzr6vvfEzyG8JqWg-4R-nO4aJWFKXfD04Qv3czZ1w7gtpNaLbKYyBdC7IRKJ21HxUa8pK48it3f73O7HQfUQr0BN9to3xQHA0tb-yNJx-vB_dKq06_SWaAz7jq_W3lxhGE7ztAUhzeaXZMiwnVN17e-p_A9M8jxNc8gGDz4VsIdBSliU-RXWf8_rB5OtPYUfAF-FF3WNff2xsOBDe2NHUglpql0ID5FYSnM7eic7BmCzU0s2t370e06s_lktopnCMLPpSOInoF6jlpuZUDxbhsvh-7NxPgxtM1XYCVRe6lkFfXUlg-A3cD2ZDnJ_uuyHJ_bf2pZC3q4G_SqW-Fx7mRprA_nmj23SKFL-0QYlaGJBREelMA17UALkHFdjs3fHklZUQCGF4eGXUoguM_3jYckYyeVxFvkPD3veXRnLzelProHGbA5ZQWUYAg2sQwmCvxbIv7q5E4mnnbtHmvFuX1VUl7smiMMIv6whvidUdcwxXD_kHPCQOR988h1TiWTgkUXMpacFzJhh2Abw8sutV3fMrgFipbIH0FpCT8cOsQ7SwTT6oWPNYShBf7M25A9YnNBQ3ouq2EJcuaJXlQbUd92A7dmvFfiZ48h0n6cTuyqTc2SNkVKA-K_N2DvR-u4mT7tKMs_WARySwrP75L5HA0aKSbkf_SjojiCJOTUJxsAZgwOcCzRteaRhe38VohapT820vls6ScLtOLY8PgLYAjyORkxzWComJ8koiewrPl7rLbRyBKI-acnK2HXxAf9wooCMacZkaicNLjYgepC5EolDSJgLRhwYOWjPwBqnnTrd6QDsbzb5ldDb3TB5lud0EGx9Sz0jFmeopCfHlzD3CqtKVIKxQsITV3WAgGvpt3756cIAkiJyZlprcu_qYiWNgd9vXRP3S7HLIV3oKemkG3pUn6YAzKst3Io1BDn33zAf-ucNlRHzZ-56EizhjiujUzjecVebjTJIhIwClzH-Mdl_-YvL8LcOSbEW8ZuKOzlHzhSxkHnF6ZJ8EHoSA-uDE_JgwDpVcaDKMmXROtm1KjzZttzNDJyPclwY-Kw_4koicKsyHQQDVus35NXuak7L77ikkyI1TLgfOubcL7oMYbgakkrNKsM-nUFG3y3L6EX8pv4KI8hUVWMe0gYPXSJYl99X9uo2eAURvDsFYkBA9fejPqRu8kfrKy-acAI1XNWoxy7FfgPYKj1YjyDDz5ezMPUEHQaZ9EPvvOpsD_hefB0zXp6WfNY0Aa2uhdZU_MMPV1UuN68l-W9zfey07ez2Edzn9pvusFDDTC6V2fvLwCrzn-aozAfO79z1PFV2K-L8dY7mqL-NPDjBXChSYIzRqhCyM4B6s5QUrdahqItM4W1R26R3IFb_W1M7yKLbvm2U9UXhU8edSzt4Vg6Yqbi1DWy_M3WguRpG-GnfCWRwDfTyYAq1wdcwVkN9YdZcMi6t7YUmOiuHOx4IkH64GAb7nkaI4FgCAnTThTe1g3IDTX-CJAcXb6m9fpI0uxM9D1YuqdEGb5TaXTvaML4-uxchbIp2miY2zto3jWqXkV5QJQbryZXBfPIS5qHdJ741FsMuerfxzA0JGs64ymzZgrX50d7q5bdjzC8tmrJ9KFWKc9Yluz8SNc2fFy47GvIH7yAQzzvWLlX67ZjmeQ5Y6-HCroWvw5NDMn6JKAOsBUYtN_Hur2Ce7lF-SNMZvvdDBmny9oxBXJVcaEheOUIOozg6isvJmzNLOWYjEOjTEbYtZ5gQcCGQR657kF0By0zHmCT1PjUAMUMfXBXbCOlME7xMy_oVJ5qSNMJGpQ5MF6-eIrnFvMsPjNQtdAJ_2WA80aD0JrB5nu0hT64GFcgmG_wgLwe7ZsDQ5d-tuVCpn5TDOZgoG8-5-tjR1FXbcfUf3XkBjAzRHtKg0h34Ey6GAhnRX70c7Xj1mjy3iBZuEE8kBBzxTCUGWzU_4cQvBT4hCO-Xvk8SfPK1DZ3HbM0-QK8OWTRt1HZJOTOwtu_ffqaQc0lLjbYmA0_X8wPIlh0CtT_Fk2VqAGSqNNc8sSsTdCrfoDiHEbDsUlt9-ItUKQN7J5lCu3wj0aNkoO_Bp2krdAC4eNUATogoRDQc93lhHDyXEGOlj78Jkr03InztFLql36gx2mLo_lUxPCuoc41SvWibQlRKGds0mcgDxeebZOhInlB-aqokeSx-rOJRNm7Z8N5k36uO924fUpk9SB6Iqubwo-JVpY9zgSBMU_teNwg-z_4UR4wxwrtiM0hO40JF9xW-wzfvkFUYzja5lwZHTCxsW3Ne32fGm4r-Tv-bGAH-3KoOiDRHGA4Qo3Ds3jF7XA_CzMPRHY4i-8O7jJcLOxWTArucQfoGr7bslYxCzHFr3tc94GDQXbDaX64n28cvPjdBYYqgWPzijj5ryhEQ_lovc3NbWvnpIgATiYq5ZT_T_emNIQsezpQzevkKZ5dAwxw2cehpK8jztR8g9_mw6IQBS_V0kqgzZ3-V0MDsZpvKyOeMf7VSpL_jfuL4zzVowv9p610IbjfEvmXi4p6iPs44g-IQCzjrgM-uHEAg3HfpvIDp6GJGcnEl5DS6vkGeFwr4fGQmy3ltpRoIGnUWWrO0fwOHj2tGeMifu6g6FT7bFHDm8Mm7jeAw_4ShfVSsgwBpyLcU6BQNYG3O5NQ-RzPXpJasLrlWzgnUcvflKESge77Spquprw8ITFDu4s4qJs969zioCP0Q-YUr5NCzAQiGb4_y9oZtP9RNqE-F1rcbucMcnBTI9pJGp_5oF27UqvZX2ya1cwaD_EuTyCwv_nfit2yPL85luwBT73N8cTTEv0XvJ8fHyYgNuYU1nbf4YD7gNO4PUn9Fq2qzIOD9W2RvZ-rWDdq_pFw97WAQ0UTk2VdC1mferXIhsYd9rkFeEr6xN6n62lv9ZzlUU4iYFJ6WskLGfGCEUrUyNjdHDYb69yjqbmohVJBbCyJlOL-Pc4_5XnMMmt_Tg8GOLKc5vJNMjh8NsdZyoMg8iuhQNh8BGV9e1t0O9O8Ao15XHpX-WBQXdWrNXahQmvorus-SdKLZjKXSC8afu6Tvd4_5wKGm1ql4NLe0SwFv9a205WUk-TYZLI1TWn6n5N3lkcnT6Z3g0Eyc6vvqNyDf4Jzs63X0MrsFnSYSR_uUY-faCm_PXTmHudAeE2dvoomsniiXiL51NonJeey4005SWgN72sgQlTTq0G0OHtDs1XUDpfjItxGbt1vzo4lInzETkPLOFhZgn3CP2z4qJvTUMm9AGjtJG-CgNC3RYqQeJFetVRuPN4GDIlYdaGx8oF9Ir4HrRNAWHDAczbY8pzSZupHLf-NpZyUMGJIg7STNmOCwV2Hjrl_UF4A5uSSjM91rK1VzHIPbitXfqCkwWDMdkfhkQN9DkalwYS5UtDCgRPe2a4skJj3re4WyOxeWamWu6a8bkpnEzJog109GJLGPwdNVG_h8HEWKsagQke-IDaGbjsFJ0ypy_enfHzdJVgyfyJS-63njxWWDCeEfKuLI6LXs6eGEAh1wp2sEGmcLgNZO_R4XirWxYBYNVnf-ncSbgi5MviYZ8oU7p2IbNo8cGdckCcB5KbwVY9-N0R_OCMnfys_xFW_AnyJFYDsAA8Bxdwg7dLZMNO6OgtXz-Sek5SeS9FWii00WSejfHRCEmHjtYCZDjr2VKiysqcMc9VQQ1dK0UreZBQ42sa8vo7kwDin6VGgQadbfM2nPFHIi8ffL7vtHl789J46hTJ9z-vjTUSmH7tP5q0iby8m0e1v5KtR9EMmucq6ZgrkgEw46PUSd0V2PfC1lYFvffafyB6hL4Md2tQDXrCBRjODoT_3VCLN_yWCokxA_GwKiFgpOWT1zeO2RXNPIDfJYHh_UaC9PKMnYcMiIp1blA_icOQWgjkLNTGvI3jrX-4GdF_7PGJ-nNcfdGCa1xOz7pR2QC07R9siJw368-0poiwwxExdk17KkmOG5-C-Ephdl9SwJ4H0Y9TNhI4EKN0Dppqjerj9dDhQ7cG4tQ2IHH_S39FKr3hHPqxoiigFtM8UhEYA0xpmo2BzcdMY0qrC9MQ4TlTgDbPJM2pb4MOrNY1Tn_h4qIGk2fE0DqSUEQhOFBHPH1emIv7fLYVQr25W5HVUI6m0q6EVinJLxUmfqOK5lRPcQdSE7xtoRF1_h3bXxGYg9y5tULMMQg1zgRuBq6B6UiVWW7lr6iBPyI6fQYoa2y0MkpIA-PQtyh9YF_Dzb-NwZExfAy-BjebAqtC5PTZwbKioRX8m38JiSjdfez_vCQmqIAg-bSQdUY7kEIVAZQigGiVtpYd91U1kdQwjW0CcPkFEn8reHog9gQJLLHHdGTSEthHgFSoxvpffnzKSIdRWabLOse9j8OTxqisJUt3lvsRCPTXsVibghXXu6295yI-4TPutX5k9PEgdTWifR-flSYxUjEu3OdR-dXKi20fdAFmM1COgJLEpVdI4EIxhCi-1Mky_jkLpA5jIJcigOat2Q9_5B28KR-yP2Y05WktlHImOW9HASATA7-wrEQgk6GwsIWPoIlc8hVWtqgR_fTb9pJOT9jHbzvoHrK6yHCYMGiQeJnuIMjZz30Ee1p5FeCu9ZmJdgE0xxGYpnrha4t-NYSopnRgDNiqkavFGJJ78g8lVnlJ8ccbAfrhjhmYeKwKWbUan8wunSYguM55Pn9aasp3u2XRNlHDc7QbuvlISu2uPwi-oo5WgiQ5X2ksgFZiHNLFHwr3TEAYnK4p9b60BzK5uk5TZObcTaprjmjnW2kTgaMl-0lpIQGceB8A_H89QOXYW-DL0g2twc4Zvr30tiuZE2608NiwDoBp2IMDNBtHJJ6U_QIulSlpn7H4YkiYJV2lzimHF24zIEdwIA3EGa-WQ5gKbcGCAMtYl6D7vPWtxxW3IpTGu8RrTamMeUUY_q5TGkxn6dYTIzI-BNh-17tQnKQA2OrGm8WxkoH4SyS4OrRCnvl7BsrAx26OdF7WLQ2bOlSSXk7pbFAMONu_BRDbK_mpcZkKsmZIJGEI2gqIiRblcExS3--jGkFj1tzbJQBHYbcjmptmYlWCguk6ch1WL7z_ckOMHl3KRPorXfEKR-KwNXHn64BuLxZwDFDNxbCUvJ0Yw7olDDCeCIvNY81PDQR4aMnPNcSiXfDKEN8A_GhoC9vrTc95k-lXAb7DygiXlinqB31KWET2ZNdGOViypKsWbj10n44MoOK15xw3rQOhHtRWMFUs12Cr3wKBl3r-BGxz84weAosFSQLcakBAavy9jgpLbIBd7QZB-K5EoXjD9iQI0pp3NY8RWm6TomlTbPQzGRxglHZGIAKVZ7kKBr6WesPejuyYeipNLhBCWUJg0icY__VYnGrNX6ytz9rTeUJ4qNEOqu3SZc3DxUFDy0HVYsonIwD1GvUgB0DlvhmsSdZDnEAHhgytuC5DQXzmLIBLrX98uzgW2PgMsM5Tz8fX84tZfAA5MNE7Wf-6O7NlKGPvpPzhE6chZjc14vtgDtWM_LzyR3YylDWXK2hoaxUWJDNQSjQN1VGwnw4nB0IMZOOilllhUwmSnI8nGJKI46IISY2JE9j3tCZagebDjdFeq9mwEmIUgVgbAscvJjPXy5z3F5K9gKRdPqK565YN1fVlJeC-062GjgCNadsmOSusJ0HBEEeMU4FYNwEbzPEFrO71AhpmCjodcsUrsT1vveC4MxgaAPzCHBZuFzh7rr0xPLpLrPuD_6Xs1rgyZYKroaW0aDUHEW8KxTAC74t9fgSol1hdjWAWirGW9-akROm3x21V7uFwwqTmItV5_U2KAK50kOe3Q7GFcQF6BO0ptR8yM-MQLKpLmaCB2hLRQQuzmeS_Ysmd9vUHkT2pz4KatQQMnMZbNLIcnzvXvXHpXaJmJx5lEri2NHVWLE4xrptkoH3LxU-oFTKvCrrH3-X6QO9aXTcyAMgILOW_JaQuIcd8AQoAv31k0K5bZcLmQhu4zquIdikjVn_NBtcDKGcHZ_wT55yy1oPC5GJaKv_fg0SooOGHUf-WjcaYFA3uEczeAgrg8Z16X52ftqfMQDvZzIU7RoBIGX8r9C618Wa1OFc8B-hLf6ytFIhMoVdgfeYbSOICXS2gE-LDE3tyac0SpAAJJ4kGbOOBcvBUoUt1qggikj4nYlhJAjH5b7kAnCu68KKms2WEgd-w9MyeNfja6qDKhYfpvxzxh8xTKra7EefFX0qhTxBmCfrj7VH44k7iMR0Dz10HRrSwh03-caGk06UJLjm3cfDsIVgv8eOt97hWE84wcUByGkFFrbrZHF-v2l1fcwGKs_rAUcIFaeqvyKmLMpyDRFhJUtMS52tHJfAGHMBIjTNScXnHw_gOfsejRXz_mTIl1rQQz2tYq0_txo-rRXMOCDHajrhfwyFjjX_98gYBEpn3JHQ6KUVvef5tKu3eYLeeEchy19MRfSphg0g7oCc0MNICOf_pGoZOF4YLfVRXRO3OFywCfblcf0AW_iZZpD76S56HT8nzHwBuPlvq1zxa2clKhP3EthN7_Q8Lb6M-_Ir3onC6uX3kLLNkj5nj0STbDc09VX3Jdl_oe7YW4EznWi429AUU9CNmKqwUu8HR1jCRFV1wc7xhkXla1uLd4NFxgVdukp9WXDW8CbPhjSLl9LYu3M3IZdKWfM9juygteJ3qe8VI3w99-m0N4h4dM_BgHSMikMwzX-txkhX_Jg_m-q7E94chkWNFn_XCm0v4VrXg5_y-UG5itg3hatBVN7-4c8SUPqbsSQ9kQAnVvp6y3eApsgOBoO7XL4TJfo14hTsdstliZABCifWs6DNiBwnSMMsbSKXE-OuyZpCSIctcVVFinIQ7gf7mIlwGd4e5Mv6FPYWE4jUxhpIR9kjjmHK_-SOLxqElzWNkin_GNuitLnf9VgnCcfihLf8ARckUuYmEcBxqgg9zAOoj1QwholGRKZREWRnoKE8MFMulk5Fwb1BC_rZfTheUn7VUuJHyiot0pP2KsY8GK1Vqn902y4dxuhqe5G-nO5MlAl4zwnCrPJvGJO_b2DE_ciifKBc8kuniNeTPitbxnFysfXvGdavVgtvk6Py1ezWMxwylLUnOFfOlFlCna3jKYMnzlpV7ozJG3pNvvqlleXnQyQFIAxUM7K6MJlVz9jt03w7SxLWFTVYtUDIsopbcbJVQppA0vtz5eyMQBF0qFC9DRVDeX7RB07LNR2Yei1V56SN_IaXNGfneEU1E93OFYc-T2bpDjm9VLH3jSRjVBbXKFZCYQOUDZlBN5QS4_jaD7M5bux1opgsP7hneHRkqH6hA6b3VxU7KVRbrgNGI13l55-mlOS9qqgE2ZO_QlDAopzFLXUWC_X7oEbnE-y6AXUjxZu4iAXcsOUfT49SXrFOLhqyqI0jh3UaQflVNDuZV5RJBaJa2joNfXupq_czT-_uK2b0tmlF0aQid7wcrJqWYsH8ETUXkzx8pyZlJA_PkwC9_LJobGsf4LViSparPF1jJMOLiAUaHq8w_ZuEx-As70fCTlV2tqZa3Ay-Q_MbOsmfWBQiYg7CWSgcASC5YHwMRbYmjwnMtrzPsMuW5Sg684rdlr1LSCJUCq2AZgclXAC5r7tHig0V2kFnZ0wkrKDpjeIT-YUWaeThI6linashujcRVfUeiIkvx5pcB1uSkW1q454LtCJtz5vV32yMPAY8bSXVeNiOJi01p_89dAnReh2XFTUMTTiKi7K1bvXUU9HWbka53zRXaU4mX9gMwhy7wIXbnpBe0TpzNp9iFGFytpWuOrN3gPbsytDUS9TH0pe7uMWM0MmHsFGJrBf8yLs5M-q3ojTJf4kIU2sGf9AflyCd_tQ8v2LWIzSG5EkCMKVGUlkT7TS8hyEjRGn8UcIkTmBYy_rEjEhTao9esLvk8z7Zhm2kDVW30DYWtxpTxOudeiAys5UX_fIVUb8qIdBE6VJMOIuFuZpL_aQyWsqSf33hIDUsz_2xuxT8OXzPnzH28cIDlfY7BrLi6jgq4RuN6hYGWCZ7iJaprpZcGgR62s4WI2r9ySaFrfwmP1tb2OOmiANIJw3Con1E-cLorDKQsWqd9S8YrHC6EnRSOGNmJ2VJ6mai4mz0HYidlpFVEz6Mbq7FkagoW4vEk4OoJOj_hC_H-vb8z4MZ4EczWKFujhi0jQW4mstWjPgU8pvdzqFUfdQqemd_GUFmKm6_EjNqEL9YHclFdVxyA4CgEkcrf_wXJAPftE_UzbHLGbobzwt6Gzp9BJOPh0ZY0q-5h7catkOSxcigE5oiGVfSX_8I9BdKmx3hU3qx3CMJfDi7QVdabVb2fzg2Lu4XtkNIbkL4lpKrGJVQNczjdLaUuZl-uziB8eGGXRUD0sUm8k2CgbrE7SiwnTb0AzqUIOYcdP9ZAp5v7njukALsgCZNr-7uHj2ucaq_a6bSvD1-dfAS0ZjTQu6BD11__chQRB6_1U1tLo4Tb9rU5XYPjbE1-RPwXOCwKGgk5vbET5Lkf16axXL5gbSGoyjoNAN9XJ6vlc5e6TwJCc8OQeJaijjSe4Lm5Bjw_ejOulQePjtBYC3p2C7U74W-pms-wigKgjZVBZO9SM_1Xyf6xj3prOfcGZpFtEczpav3bBsOHJB9Y3lcxKrag7YkTJQCiOLaahDgi6PxVZCaIg7lnEOBTx6B94rVe9PeemGHfQfj2a3EwJJf2TZN1-uaMasZNocdrIAk_cF7EpCMjheZLOYj3dZPwaQ7oJNf90D_Znt_cljgoR110FFAV48amwLC8OxRS97tfNCbZoH22FPFMK0b5Q_LGQYPhGwEx3MKBtFFppzrsfXBYJfr94etaEiu0xUD5h7QNt_ATmAyd6JwTiatVv7s8b6NNXf7cdm_I8sngEporT_dQERYWe7QBwosFTfnrbpgt9TTJTufbo4dkiPTX3RBrZjgANxN0QUkjNSWpp7cwKcOK80AGl99U8lxak_m29ENXbXfSBMaDhhYuhaL__znTSU6798z7KYAGBWSET2aktgIV3eMUG54H1Or_wEu7mBA1e47pORolkhXjfFVogjT0Thn4FBuZKitKe5U5S92a9VrbPlIM5HYzq53fzyHlxD6OIOoqq7H6qnBauubM0cJ2y4bOiOhk5sDAWniJS6hbOzPHSShhZNtUA0q4iy_zXM6ytZqDSQLb8aDEVaeWwNKO-LVx0M-ktLg3_IHzIJe8MDmA9HmyuS6PvCc_49J3p3GLdlpgliF8qZxkaZ5k5ucCoU-A7ScaMq-rD74-dgjiEPKBTlyiep-Wf-3CiepYAVFZ5rYp9NNZhN7a2IAM3J2a2tx2Qsd-yvq7WSwuJ-xLmN6PDfjnXF8P3tiGHQ4CO74kmiasIBiwwXjbJomQu-Mwu9Wy5GOL9OVQH0PExNaNfPeLLh8umomZ4Swnmi25dFTkKD3qU_tmcbI3dGhizJNPv2SJLfDqD8H7xx0TJBHfAS68i2ufuRnQKdzg4XidTBSpNurVRZ_NZ8uvhw0hJzb-yJy7bl-tXsJ-yMGDgsi-e_Li1awr8XzbSyAIWnX8q-DExypWixMz38aBaJwDfEBOUkYbPKq38hLsnjSxnwMlkZyzorwwVAfNhRohIJoCD1ce7grAOU6qUMel5Ho0bvh_FzKQl65gfEzwO0xEXDg8DqM1kpqUidTsTu3j8a47muTACPXJl-esWd1WumfPCSU853-dNnHxYc9Ip0ztLxwvKcAHxGILUj0YQe-3AfaudmC7CIs_FkmPNkGm1XA-4uyXakB5q-XbvGyi0EcErJ0Rv5Dq75h9Qa9325loyOnVhIx8wnYLsPJdd_uhcWlyueS_DF2lUiy1uwPl9Y2A4WtqOy7fnCSdIyaOdTeirESzXmKORup8JHIlR9xDDyM3i7WeHinqQKAPZhtQaPk0rY8RPis85NSd8BSN43c_PO3Fxtej1oCaO89fEcqSaY4n55en3W9BUGAZ2NhZkVDQZAfpgl4ZiqPfz7siW1Tkasf61wwzUS17n_FwW51GH-aZNhEqTSVIlxKsdVnb8iOFe_9QQvAn1Yc8U0k5ROv-q_a521Q3Nb2KnWyKpGazJmxg0EPjLB6MXFCDUu3icBd79Psanu2QNhgzw-qDPohmYjPmAo8KtJcIpR4EQ6VoAxxBDz4J33qx7BOAjG02O9lxEjQwxdaLzbyHpRyUQC3ynrdcjMe1RuGAHfl0PvByiUFA5cUZNNbTLVeSE2ErSa6V5EdI6onZpxuKn_hVCPmSKCdkoKVdgBwGvgNdIktRTxfV0m25c5FXxUfOrLjHeNsxGQLk8pLb2qvfTW3gAwDMlUtKlbg_dSk3hR67-znnFmIzlKMv13jkQ4R7XWRaQhzhbG79XqbQbe_EdYVqFqk7x-UlJGXsgGio3WcjR5RHJYm1IMx8m3dInFkG8_k-eVAfFeBLNMFWOAAzoMjEHRRMwPKj5iBmsAv6nS44_cSGd0FZ6sfkAtD94WvfT3FVD0nRBeS10oSCZXW8-7IyFDkuQ72-Wbev4Tuxne9TArgQIhXIWytGElLo4ZrsXdYBSPtyOJVZMnqfrXsuQ8P5joFPsujaEWhZOmLrAjTtCycQpVNp-pR0Xd8PNmnCPILVUwTjlBdZ4X5tXRlO0DJU4XhRg5fsTjDXEXESOXX-tVEOpKJ41xbFLkuJI8C7QDpGDWD8A6u9Hr5qD4nEKL2SgwcD7Cm4v3frypxKVbn5TankORI_OoBRuFF0zsykOhfl64XzFw4ox0SanKCtrBHHZs7chRfCZWPd7a3HaKeDPtB5eb401joUVCTW9KtE6HEPIE3Iwn1WHGjCoIjT-I9BcJEzh22F3rfJj2Auu9SkSW9ADj1mkN02RbXDL_S_u1md01CtYqkHifguHKko8psk6KZ1xD63tayDiNRcEn6D7sXtpNwOwmK5MZuez_RLuGDKIN0dOky-41mHlFoS1h5m8SIzN2-BTxMjTb2FsEgWLF1hDRMF6i27JhgdJ4z86bI-X0UU6vsU2ylYNMhhZH_oL3KfB70AkNnsTGMZV_hApsy8oDq_GOEF1M9BwhuKhV4UEGVVIynl-2-DLnlWBN3iig2AcXYFclvx44919grnBxVTpXYriY7AyXFhYEmV_8Kuawvn5ADzg8YBM1rxp3czkoCixnrpFLGwMXFYLVTiB7i1QqoXASozMT7ADBwPsmwRq3Dgp8x9oOB48IPWbx7-RoMUEalK6cg90whjI3lC8G9zb5-UTWNmX8R3DfYkV8ImuM4Fbt8Uz9YaXLFWf0a2g0AfuXCx2P9Y-DZVNaArMBwhrm58ZyZTsEZkEK3xR-G1Pc850e09rjh22UYvzsIQ07A48erKpzKB9M6Cw-dOIYulIQj6JEcXA4fDEoeCd8EiVPzhO411OdlvDuERLtguW3V3JmM5Qp6N4LRrISvUDktj_1hcdEBc0Y4S9Gl2_a3jgGSGxecT09KtJiFhKBX5Ms2A1D00rIPFmKAkZSLk1NTSxgIcG2Bpslad0c_4InX_atP1NrEaz3Bw_PljrjcrOKKZ2nWdTdkN1q3T6wB1-ienRgZ_VhVKsug2HTvrh6N47dqJ91muO6FuqM5W03JZ-QBDIZ52lJI3X4B2Frwgq0B2DYqJ_kitZE38Mh61uO2lBV7ecsriDIYWhZnquBuQBXOjqcJAn2Rcwz111Azgg6Ik987cOyIv01hhlYQ-2cGvhhDtn66CDRfWHu_MrLH6CyAgqVPgIqboYLTU-jHsTLaiSOk-JEXBRCYQ4WCbddqaz2kcBzY5Jlk-AIBlUVRoj8i5nfiXbFvnc-JzegdXxjZ_CtpqFOulCQ7ZtSJIo8Cxzp9FGOYlFKaWeIL82t03JcTe1E49REccG3UPdJfORpzKrO7PF4ltf5kCoEvsgLtVkBwsW08tZOJbUlw3H-LIUz2dLlLrSM23k7MWuNdfpjGLqOU4FiPvsUJAx5s2mah50eLbtNbwu4z7ekzMKgUSmfRqtH3RIuOrCyU76X2253pj2qoiK2mLHg-KbbHHeoXygQby_AOK5PEqjNsw6VBnus2FQXigN-vj_oy5BH_M4DVw9bTn4txjFY7vNShJ6CzB-wJqt2vrP6pm_7rw5nUxG9rReJNUHUjLLn9X96Iz8qPS4Y9Bthdpt01wWzpVMVK1HCWoikqiBYIkjWeY1i5ZWUOzBKmZy-Nrk-DZn7oB4N1sRvWOFz1gKzcPsYHTrQg9Uf9j5u_9w-QyszTrdKE4i5CLCMxH8D8xZbkONAx7YmDbdE2-l5rkO4eydtq2-1WTSdBkpuC3MDl3ZMgSxsaOY0Ci9bdRnHiyX4XkkwzMYvA6tGdwG6q2z5FoNe0icj04vGYLMchGoVKmtWvmZwmm7PLVkIYtO_Cej9gh7ZDvg8GHSoQJFmVpM4yJYkAE62shDbY9KFkyst7jD8uY44nKMGdtQxVmAW5qbtJIAn53xxPnyOdp7pk_CScIyN6BCJe6rn-4AfiI43yOzqBNYt3VIQ51RY96DFzolgoqfiZpvvhV6OwS9xZads-vg4vV1U-FX6hVA7Kx1V_EwkhuK3gP2MJbMaac3eZHGT_rT3ZXF7WYqmT4qaDgEHdUGL5n19_4BohiVc3d6CfIrhL--BN2Oci2EODzso81D5nEedF_et0lIaDoltTxZF7ljxfccUsbZ0igNkW-5YS7xcpxEiZt-s6Q3wtbo0IqlP7Js5CtJaCBcpRzkgVitnar2XZXkyT1kff86LPYLBI9olKfPFcV82qplj2JU68mKLHNXAuwpoNGcNnoFzf7GKYIc0TO1mQvWMltWqYm50KxaEKF1w7PlGMsF7u2UBoMLVv7lx2rFjYAVxRPKo51TicEtu2Dub3m1ZgMXqebrWptN-j1y4aKAFjkp-CH0z9LeoB04_XSytteUAz_lHHLfECcxba3_r4JvQjz1Q9jclz1fPefSB5FV2tHBRU_I__-YNINq0r5nzgfsRAulGf10aITsvKywjgtk9a2-Jm2S8DCu4fPkP5aaEKq71PQY1nMQsQwsb00U5qC5iNLSv57mili-Fi3gJYtYpNWxDioHOdMIpjyg-Ukpnh2ppz3Mlglr0z0VtGmtHtLPGD2_bY2lzVOWERFexDBbtyCeqY0vCn-U_a06vH3ngxjZpFSiX_WsHfR1LFYlL9SblXSWcySSZpXvVOhg8ddR-P44XydiWija49LpgY-zcBlbUn4a1WYD7F55qels6FD9IZNkPkJLQfXAtWp3UesL63cPupISPI4-HZxoIRgwKBvL22c4mAOHUapbJJNurS6JV_TsvhnhoznTA-5FIu78enQwQp3J-hOpLSOlpFB4BFq7GJHDUTXpNJLrv-yPr9UN8m2yVOuw2L14AH-W00w79JEFiSPuqQlnII42NinVJYRHw_Fm9xTUNMwINz2StV9O91lql1yvO2rDw-KmpyVYG65ovgGZkWqCGWptyLcDEY_JXknbEdtzG1CAdLh0OcOv3gv_eswGbKYyDlkivW2iLfvT6-SlxIvWmOkg3Dk2DiQPCHh7lDmfE1AFf8zRIH6ApClTPCXeZy2PVI8ZE9r8eUkmml2a8NiVLmo0KoV1kDDfrTI469vQlFDBeh-1Eqrvfy98cpRuUdZfm08-vBfi_QallX6N3jpUcT16Ihz01GbwCR-zvCSXmI5G5m9LtAigiD6sq85No1Rwf7botv8pXqQT9eVAKfSZl7ijx4SbrfIIGgBJIKQi_NvU3cz3p3vd8d1hMHmd-zDm8LX4UEV1tOX_-Xp0wzsSX0DlOl4S64rvBMwZqN3729X8slzHtc5n3_GPducgGAsayFWPux4b1Fl1jbS6SFojS-m8IZi1N3vI1fvq4ASXlvMbacjqtKfkX_C0w2_5p3yMirPBec2jCGO9l3yjHHS-HrjsV2Ve819e6Rjf-jUBxNOZV2rFAuDNDpHr-7Q5Ydgp2jzF7uy38no83YvJ3_V2rM7hDTV89osKLvD1-e5h06iQ3NWNpeTVFPNO1cvUftZyUgQvcEwxYW1faR0gtkdbPMA2n3gb7YxMYWIN25xPqQLHBPx26RtsCqHPdH_GKhySSH-RBlauJ_PEe22B6k1_LF9bWojSvzJlVka1e3U_RpZiHTqudMZnR1ezxUrFxaVwiH9CwRPRFtSR6FibDatKL5SlukWF0KDXuLcy0rFTKHZQYx8lbb9Gl50ffriiZG7_cKFEH9gSL1H06A2BfWKtD6MmZLmo0f6Pb3TcwH7uRB6IpEpoUBrRqvRTIIUAneeD-BKqFrP7kNSGmoJdhcABzKgED0tRX6N_p-6BGN8-o74ProbX58eMzEfj5UMKixHaHvZR9uxAm47C2s8tFVaRp7o3NJVkcy5aFQZ8xmRV-dK6USBe5vRbFZHNFTABeMQC6rtrMhbKdjMlkDWrquZixU1KyzgijEZo9-EjTNFNNn5-nysvYKxd1aNaBQIUMG2V3ux5AMwZHbXY-LBlGGSy5UOkHnHXeeAXLvnwi7XkwB-jMzbBq9HVlh8mUOBBQH3bYxvSWYCPeWPxAEeoEMsHWFxqT9xd7qpwz6PIYj3wTNW443gWpbGttW9u5Eq-FcmbJ8RGMzteE4DWWXgdEL29EnOIEdNBu40LGQTF6IEeUoKnCOHXmFN78TbWY2hdFNAKML96VGfPADHD_JHaLk5zmtySelrfNOixM_kosZtO8SZ_DGweY1nUwkLZVQYaWOtLR2Y2YBk9yc-LvdiEGcEt21G9rZnwzyHr6Qbkc440QGCKwDLY-vuDqS_lyEbLsq2-03uFafPjrihUxgvaF0viM6rkTNUxK-R6-qC7S3vYPLo2oWNd_zR4hqq4nNPAao-Zw_sJGnjlVa1jh7fRaAhSFZLZEx5vDrdNymfvjY0_y39XwrJtQcMKfvtv0ackBX9Ltr6dhuDxQevUvUpqtU0DvIxCOTksVlrRBQH39r_E8xEGHfDS-zt2k8sG0zVAwktELU9m082SQWsgG_nUP3mhf3lGT93ViY6nJidvK8L4IW4INVPXyeUV1sxVd-BTYqZSdXYPhhdur3I3Aoc0-bv7KnnYY7TA-t49is7Z5zzw8A2KJEKNmvpuJ4URVfwymw7PyTUgJvmBDNKwzBwkELxp4gPNWMtCpDGlLwnzK-WBGdXxK4bixIhe8SsUxWMBqvX2I2LJU37bf-UlcNoeBxShs8zfv8oFIZ1ivQ7-_hpwNorvVNgv0k_0h6kSWO8GtrAYGuT1cB1EGenkaouBzynsb5k7IByzo8UGrUM3E2BUWi9UnzyMwVHEl-2j1Ct8nq50i6W2hTJ0clV-OBlKlmFWRYJtKXDftye8ft3V0d_5Kxo7-0-RylMjLwYCGAG05J3v0_BCevB8Wa4Y_sibYrAi7TPhGm0n5Z2NhZPZw7qnqIBzHpaC1BxHkQMIPEuZvIKoDMkr1MNgO_J1Tpcv742scNxIQstetQTV5xDEGpufXjC5QMNn4tFvAikyQgq3GqKCb2fhqEqSw020WmqQAYWyz_B4_9XZRn1ONBs6tlqxG38gIEkXb5Kloby3ZRJOXZlSKvPeMjojRZTfRrt4emQWtPwoO8HZ8bkS6839wjWaU-rJ602CTRTIf0U8GD1fq1HyAVcxxzKFu3pyLkmDRgd1tDXmySd_DMKiabeB-q-LMN60MZnZjsJfjNX4cQJt2UOYrTtYg4PhCVXeujcP3E7v8ZMtfpcqo5FFda9DxanUER84lyiOH5gzqeN2E2iUnLwONKtQPcTmss8_1dNDRxeIwyupQ9HGsELZXwrvOGiOAOMLQPoLoTfqxQd-d2nEFX4BsPnzGgoIGsSrd3ykk8nhEgDuJKXlaE8qckDrnXwLQdEppRJaVzN8NlhFlOLYwbjRqdmV8aN4vSWkEnaES6hAX3NHdPWfGRuXlHHuOsfL6dDqkfjmzSJbbx6k8qmdd_jFMg1l318GL2kpwCBSbV0dhpwj6nSGicmIRkQUFtiIjSTVfvhsh4mfzVx8BpIvwhc1vc2sO1tuJyCrJiArgAFxTap9J0P4S_y6XFAH05mYJYWhbhQ94tz3g48xpUWJKxnhpajeLVu3VldpL_Ma3KbM2Qtq4HAjupSob3zayIqF_x_9jOBlnaVAxTLh2RRhAF6I5jFqSrdtiOKrWSDMdAn8cUEQrqqOLg_VJ3m0kawe7fTaB1x2WrM9ebjaus9fLvjwi9_kMlm7e96PkQse7sEggdD6-WK4eNK0_F_6ktWNp34Cmi85iXvbAloavJKZFL8RCSLnlmyanDjUJ0xBBVGP6OsmUbqr0R9gTWu-iy3d-OEdADOCjECGCN8du73yefO9xfqRplNg7I3P7LLw1hwUYgTMI047i2vZEedDbG4dMwxcLNKvaidYX3fcBu9tJ92cNXR-TfBN1p3MQS7BM32Di7FvPAtfNptdPO7iQxpuOEeUsRmp7pY45DCdKvQh_9Dot7AU5h1jQ4MVRRlbPJFozwejCeZhOaBwXunBVxpilNSCMN6bJXb1hfsn1r942nml43N7D8y1fsrEbfGIMjgyyswi1SDtjrsuueqc8xWaqvnfh2lkS5w6q5hR23zSTWgcLFze68ds9fJqOaxhiUN5bolaHFkag_LG3FlZo8Ske3nxB3d85Ht_NE8ri9cVXcAB74fCzGoqDFMfRtIiSLUdgx17Crp7sCdxyymV65GbGSNKO5xOnALEIkAoJYJJ2FpR8VDsmQGBbukVFIgJ2Vjz2aXgCVBuudkn2mrW7KBEeI0PM0tk3MjGzRAzExoRBtzbCLgqzi2BN6iXcj72wzh9Qt3ZjkjEQoANrkUGVk5McLtBy69EBrOI8Yi-52sMpAuGPolP49OZcGI9RawX5S2r_xJftpBd9fd5cWiA6O1MS_D_-f4JE1NKtWqppcFkn60wU7cTajdBYUz5FhMkIma6gZN4ctzq0obk-ApWhep8pKO3s2Z9Gc6xPR5FGKJ1JhkaFIKBrPqDTm5FgfbJRjhTiDupizsp3thT5dQ9B0VW0NQ396HwV5GAceHdW16SgaX_Ri63H9iCJ2jv0uC8MQIageVUgJXi1KM0qwgTAFd6tA6rnCNz6Fopmgm2To17JbN8IWZNMPH_a1DcjuxJJQLWGPOgqFa0OOyx5Z7-xkPRp1KPL8G8jLHXhbR6INdRMshGQHdSZAMGiyS0o2hPB7IfD8cLujaG-HAAlAVbm8K6QF39TSWLI3ogpo9OjPnlt6M-1EYM_gAfZaH2ipiQ9MaY-i4pStvk3P8E2BNLzl9dqIteF9aps0LPvIXJY3SlX7f9ks9r35SwC_aBvNTMF-gAv4M1OJoEPSjc35gZMzXS2BfFhufYyeJJWNJvjB-omE1sjMGFYqpkoBEajsegQ9fEKQn6orJ3Ve7jcmrD55KusYPM-TM7cncua1MGM2I6wqPDm7iikP-UJKXvZzP2ZMlE-mPtWCaY7fcbs2jmbSHu_LI4XKaP5P1ULrDDCdjsJFp_wOuLWGKng2SG6DGJkJSKGSKWoYX4VxUt9u_rnoQJhvSOO61cTr1l-8P31NIymki9tc7j_EqAaxL9Dd3YzSxNvgwaR3yJV3EQ9pw5X3EX2YbBFJU4vv-ypmZ2xqdl15aQhXkQ9300rTu88oQpeO-YBgNPi8JiSFIhy0l_LW_QHSVrqbP_IemAcZuTomjuXuPUJdacR6V9R88r-bDiyhzsh6NUKoiWQVdtaEc2sHNhx36llyHDtaXg1PlHYpQ9051hsCuPQf-sHbpWE0NQmlC-MiPYJEPSHEHNgtNRdz7MIYR5iv8qmNBD7F-n94hOSckJwLjJmzEtBXYqC1_RtD0k8CFicYSV75OOXatE2pB967hJ2_Zi-DY15dy2hTUBRxfeAwQ4A7pm6jF5RSKB2mx4z3jxSKB3yb5J6AIVO3ADpLPb_MaXa0nFAdAE67eMP7nxEKtBkZ8JpuSkY2foMbvios78bTxIZsg3YgbimII-F8maMQXxyuJd6zLtPkGuFfbb0iTLDYuFYf3eYH6e_MAuHKoevcgkpID8p6kXZDayPfbZr0Sr7R5EwKJ3DhVb1W-7uBLBCVi7Atp2j9429VTOUbJHZ_BvNg1MJtisXgC7u8Reu8wVbQmNDaw4qFBOSC_hNcQJdZWvxDaZu-Du7fEmtmwO1RxpHGcTLgi7-I4AH02MjUddqYURDcDe17uQFlHdV6E9CsBgVlLXCCK7BwW19CA_wyxQGqxFkt1IZXo2n941pGbOfvJQ8qk7FqXsvjPhRdSutDRa8nmnVF4D60AlT3BABgm15-i8XEwUp-IM_ccILbMLfeBvDJmlt5hQ-osn0W4g-koKGW6yJeTpshPf08QuUoQZfEa-nx4obsXmtRpPJm2gwRFZI-SmCAie1rSxz1V0sZDOrVrJvHpQeXTugYdDFgeJNZTGgZZ1s8T-c9AwtjZ0jrahPrZYSl0F52Gw52vuBJOw4mUwgO8DSpj25VT-paV02NBM4d63OhF9oVl3Y7DVmleS8wBj2tVV4NNeMqFApAQy-PoqhpHXI-WSjhAdNFgDeKV7VhW9YPBOYNC-w_epnIJ5lTqHhxcHIQGtX42RX5CSsDLrYasTnOEgcqLLKDp-Emt5rI659wue-KQvgjOAecrHPuV6Cvh-QGN6Kl3NS7VxA6tuP5rEr_Dh0-DMHnaS_zi115rWS5pcCLwzfXaRLBBWeVqTvfwTn45gMp5AEBv-dOpoQ-o0tS9bMmtbZFud5O9eMPsq9tVAFKae4PW7glQY4807Ke_Ub2wD8uULcCGJOfboSIgyfvLNJEpQZ5eu0AGS6zs3As3pvll8xLWZzzHtRybXGklSIyc7RnqQqsXWF7ZJFUa1fArBB_ZIgtW2_KKIzZdDXZ5SEUFKQapHxMSas0tkv-DgPmg4q4QCBxjuA7sJd_99MuFj0O0BnEF2u0WFDVzOpZrstCxzwFsjmaNL8EKvkmsLW1L4577myNr5KhGyqIbrsL2X_Ygfo1mqkXaNI7Li1bVhgDLSMVIjOmizjMhHZ5o0BRzbRxTjJEXZJ6OOFBzAmiki5WAkf3p0G6wE7DeM3_5MOQg5Mhana0XK4aAyfhLWse_drK1DuCbu69wKUa55MlYp4vGCT3BmSfMjyeB6Fp1ZBgOGY9TAYbHfw4zK0bMH55VWaZilVT91ASNYHS3L8wD1PwdWcFN8ZeRWOlxPvrN5ubIqgaMbpw25PVfHZ-r8UVRQo0HKfKUcLemHhPNe-GZlTRRBZip-uU9f_OytS5admCsamZFtxi1-g2ZLd2MifJsR5Ze-t0WgvdtyldvP85KgpWqi2gxG1fWGvOs9Lj7zfP4E6PazpHlYDv3glN7tr-8n21ylB37VMwyUPGTjhQyfnNAAhp3NzxyvR6GbTqCLM8S2baSfAM1FaS39YrwWqvc9niwBLiXdxoOGR5dgS3x7cCXIRbYVWL8rdjdrL-0kuAXNZqROejhv2ck9n3zjGvbbcGbAF2OIr-hRnzwrcms-U71A_OI0c_ji1dZgI-7C_sOEL0Op5zpj0Bg2noU2FNVvKqxK6PgdKILQGrNaGYO_EjaezvWsemmoiFOA3gYar8WxeOhnhM3CkzsS-Ati9DH7hayqq9lmXRECicNNgxtTg8kwrZC46h1cDuWimERsRTmEU9n1_JpnCcpAQyMiBq4-QBFtzScjwRU7lBS7C-qt5JfbIX_MSdRcxwuq2j-eZGwx57JXF5jbtqeTr4rp3tpffvLGeQH8ykNVK14Qp_GwGwd0IK22d5J4yYftpT3PnIKTBaCy2kp12jzrtwGIH2FCgj5w0x2Z2pgKG0g6T8a5VZwsA8x-YdMACB5WEoWu_Kt9MEB7NW6aXWPaoG0U1VI6oMj-sKtSbG9fCNuxILUmF2Otnvc7eG__G33oPw4_VlrN-k3jKFco8GTMEp4-TKdNM75qBhAWfq_xgChUxu_WpMaOPLmmu4jHy-YoYdh5OttTVNryWhSJMliVlfSyKUBjYCR7Bhf9jxfLsyytEo0-R4ZkysJYhAC53-BTiQp-TMU6Bb6JQsfX-giI4K6NcwbOGwArNlVQy2lvKDEYFLpRpYt3YtOBzBCKeD0Y209Ghrny980irAtBHSbYne7Md0WBtHn2DiUHSiLUr2QAc7M6kNW4k5C4oMSfsMOfim3cNnMyEKuptaHyXeZW0eU6sanyOE0H86mpkdNzHShHiB_QKjo2_2-D0fBZntWXOLahwjtHk_0oVfDpTbLjTe5EcFKiT4eATn-pDej9Rz-v7lBHn0Uz811d-PI4bk93aEP9d5mxyMzGgykMyJiBxeqP-t5solGOUOHawqKlPyTnYr9c7gYAKCEMdNcE6F-9oRSQBPlGg5u0y4rxrlbWmfq7VKzWF9nm39tOJFpqLbl8ONVuGq5zAn8ANzoIEUJbDHsPOK0P765TNfOF6g3irl2aKtLltb8GLYjzs4Pw9OJ7ASo-0tcoKaB_cJzCFwG60McEGYEeqKqjsZ9mix5HKIrRRHCe6zk7pff6eeNx-7DBBEUGBNbfoUvqG5EUJaj93oG57lUnxQqDgpdltJlJBQJoGcWNlW6i8IdMag5uvG_tWJtDTMo9cyjc5ynmI_KGnfQMUp095CcK620llsD1Pm7KDDjMkHa5SNyIVaYTt45DLjchdNxuQ6oaKiGkwmJtuaBuuh0u4m6G6B3HFAmx5-HOaRAoIm955BpVmfrwR4rOVCpIfNlEnafCe9bQkzabJNt2otyMpB_q0pU5LTKq4Hh-fM0pZzHBoaI9_YuQHjZqBZ6F685nGBMVHWTxlZqKQ13v9sk8MKqamNMZ32kWuEyCa6JdAFWDTmh1xdDtviT7R2OfBY6TpIav9z13ourrhJjVuW7x_9RZuz2TYQ90pFsewP2dzjoU3-bPrMtzDI3p1ZLSZIYCeVaZSEk7zdeqobgdglaJ7X_skLDCWnkS0rgYZ58L1v5eykH2_gRHszT4plwaBY2HuUUho-IvxjjgiVCU0lO6RxTD278ZkClDsQ7iVs-TXasBcSrk4-_GpxyCRR-Thim2rRsAxsya-AB27No2NXhbLnhMO7ZWOZHtB9vEhCHV2piDNt7Fb4H4WjCcYQ4gvgnS-OA4uTYpi5upposzIdqief-rlYahC0yZJ91tC_h1W6SWFevZzllHXjt2gl5Ip-VsFEoU2JM8Ze1C7u3HpAWYsKzXzqprltlRpaXpQq3XVlS6JZUbyM3J5vEcndBevY33k7csvAuYeYCo6nja9Bm9B9NIa620v7HH-Sp08peXUJG-2p6LGFXZPTtEU6zRT6MR92r-yKyFDoOaXxa1ATCG2s2vVh-pNSQ-Qp7dyIXtPQJvvqH69FWCReutPNyTeznNgQrLFBDkNWybVp0zBghxHMTMP8Q0K3ZGCQXU7_JLaM1NygNOqRx6biuofAsnhEEcjzg7u64urm00rc8XJpz0UfXt_QkkeVLfcp9JfZC52zw2FrrHhSc2szz5YeboJKC1hBS93WMHovWqyc7f2nKujhw28S07KPDmXRdDHjIe1aU-C8Nc7qocT3C6ntwWoB3WQ-YIp4FWRO15q711sGawyZ9VBAI0QKAh5bEqWDcTRFFHTDqffHqJ64zilSIQ1kLFYax_g72VmB-sbV-pxfDJzw3Koi2mYkov51xW8aePFTHvs2MhmybVgmKYSM0yiYctet60UIJaPp7ZcudqPmb4hCwlUo7QChnxb4FMAtzkX3RmiO0jCv214rL-_AAxKW6DgboZ97-k-DEsWSGPvSJVVYtUPrLK3sxoVO918IUvfs27Z1XGKDMJtKfY4p9WuL4LbzNPWqd-0lUIa8x6-rEG0QKOkGWXkQj-IXqE2rlsjRmd--1-2Qzikn-416h_a8ijVcvo1k-BCglEUBfsMI5vos3edhjvyPQpUWEVpaaLigb9hDWVIh9bshgvcdTQsf8K2BQKLhkZUCXMjhsn2gUnzgoAhRz00qdmj6o9H-OCfDnyj8Boe8t1oMfXp-MM_34zpTX14iWFBhQyNkF29ikNLXpDXW83iA2thRMzBU9wT6O7NJ990SwVoxh-pjNv6-wuh_Naqwer-bvSIAAYCeO3XBusBRzDZgo7EITyS-w7jdolFDxcHAx3FktV_G4NIjgFhCJskcYD6BxpHub306VPSbiBvWEpn4K49_Am0p20GnIhVXDh3hui6-PPnEdhrxDOuSHMkfc5JGDLfM6ZKe5p6qTuBO611RSdOajeTh4uzPIz9rZqAmffDnsnFh1otNIogtX6TPWBuEnu5cHULhfI1hpqqRMHA8Z3-G_Qs-gd73jM-VrEiljq-t33QQrSugjtp4H1txmfijyJWFcGsVlXVLutKzyAyco7AwAqwm8Gej_QBmT5-qi-SEWKcTA8nMfcKWLAOYFb6be4eNDdj-IizuPJRRCFoPIuvbpj5fBWvk4DPz8JPf9pnpeMGs_-CF9l1rTEOMWlXvsxLk_Ou4Fumf-Qgnmaqbe6j7WJY3WVfNwlmXXLAevkt2YLYmEY0o8q-530UyrftkkK8ZUKargFyn0t3rJNomf5BhVLY53V9B8h-oG9P2vblztHPXhncdcZS6_okrjG8qAjyVYjumv7fHqCl5rYPXe667re_CIj2fhODNGZvDckwJwwLmHoHelK8MTWUK0lcfSjdGwuypV4Lln4DwkzOtvH3tAip2NBD_fx5_YI1C-tGAa3gdAk9dO2yLbyEARiVIXaqIiqqAKE7MapTzy5JDvtdgmjqsIXfU_AaTUVmKnvAX_R7zGIa5FkXtJPwDLpK0PTYSDzedyCKMRJVskoiaoP1aX_D4v2XXGaHi_tMP7D1WfsM3cEJBQY2QUUu9-tGNfOhRMIy1r6Sh3FPE_58cJY28APfx8ittmdIsHfwE5t-OkdmKkvkJ_7T-8oAZ6Tic6Tr-VXePSRlY5zZOXVhFFUGfllJWYDZzG5C9v_WnjsExubTbSp1q9cnXJlAfNc85Qv2jhiGUnGYv13SiHYXepWn5qQyVKDa2bpBRMey54v4naKLQrUowpTItK35FS3ITsgFqcAMytnz_UGTn_x7s_NREdLz-U8wcv8Y4oolOTlb4fEgX9J2l9S4F8VK7l-3zadPKnhYlxHFnHgXsQ7tF12zBNzPoLyta5rZdb0swSGdDs8GNt4LHLcjynchlnKqgBnO7DvIAkSbjmPFVcS87lFmjroHF9BW0Q48b4EoKApM6AWiE-Mqf8yMt9eGBywtkejXpYnqHrdhJ2Rs3D_T3dql-cigpac-euTybfzx7Fh7WKXintRv_CjPy3NHYFRcdnUvIyUAdPSgEm4bMe6qVE01vV8jD5HkLyFHjBYvmuYbuAofcnk0tp3gIfhkZD-rgCNNVXGxC18Fj6eQluMQkNat_ycDlhyzZ2gTJsWrSorfqlhlMEdg__SnmC8AxTGZLHVPlRQBbX0d_N0xV8x2SHN4iU-vYjN0GjIAqIOKhPgEEli_o5_tyD5-nGNciHEwZ7s50IN4ogEh5iJ9_rsBCIjMhBwm-pwNRXyXJPZD_RU4_7mf7JqJBthnFp3-0Gyjg7GJS109rh4oqDZVOzEKRrAP4lRN1Ftgl6Av7MqA4dFRea9FChKpxWZSkJMa3psMP6qlRMNlbSDOMQEhw8Tt4C_EPLx3RkBlTMRaRzkhwF2GiBZoVRoakMKOkaG2PUrm5erHei49N7y1H9dSLEcrZNW_c2jtKSlHhlIvC1MPAn9tlgS9noJmRaCFxwMkF8bLud4rL5w2JTO0QOsPjxzG_BPJmTL7TCJB2BS-poUbnayJrPqVLM1M4UhrzydGY3D6bM7ECrRcxYhP2zR_IyJaNw_16Y0oPdtF_6cffWKKModh_VzANKV2eETOF70M69zJP5DVipAXLqX-FdFptX84s0M-RbVVnNHo5cyufEDJI4RsET0W2A6W-gxu6TjdcflLStqpIAaELefKIpFle1tqgWab88xPsMhf-MA4h0nLj68rhXYpK4JyoXSONN8YeP0Df8R-rWYc1eXj44T5Nb5gCLqbgsIaH20Zfzqijljd8G8klPbygO5Py_ysyYiKleBjH8sGawYzCVmksMeav9GDMVmfdQuP-tpe1FaHTLx3J8Sqx_4ETC_n7jPvxF5p4iRog6WzU6-qDmvt3Q5dZDrVulAZpgTYVaSDg9M7zjAkkcqN6lZc6nc6zoxOHN0DthSlAplV9rUIRGQ5a3ykPklPlE8CwWTOvyJkwbd46KUukbwBJcf2dsxXiWXhwjlB6XfOKXR7atN2E4vkFn6jWqVJ-1GeZfCEV_79b7YUSNFB8rfjzZ7d-jDkxBy7RnOrRgp6UpXbvxHLJCQzayXLpNvg301bIj07zQ8HEDWEJDR_5_KE_l4xUdBvR0Z-MZLn6A3PWk2VtLG3Ti5fKw4SKKqalKRE-Ima6gUEyyZKRdQdJM9dA4s76iCPblh_naRl2dnNqVtSp1khfuwaVGEpafgijafALYjTZTdFHnrry91Bv5KneXkqSkJwcjoo5UCd9SGiYm4ppZALlr_EI-iz8RSraMgpkLDgIIjDl-S3NYwC-6X4I13ItnWq59_VLe54iQooK5LIpJw2mrTHwZ5AL1EMZIZYO5wcD4Qer2l28EPyTzKgJwfeQvlzH1ddjxjFPMO1mCyd6DRHUj7FM8SIafPwjV6cDrPv7bxoxYSqPOdOSb4Q3as8UfnK5kwMx8rj-hweRXBx1hebMkx2ojGzsPodOZnqSLfwfMPAhTj840wkbqc-ReHh1yPdZBLcbkd1n2EF15ms8WkHXQwb4M-CGcZ7FuuiPmjtPs7hTFcTQUfpgfECRRxpl5zTnYU9wbquUW4bGmv1jVJhIZKzjVT1OeT4_GvX7wr099KlP2U5XgCLz5-vwySabgCdV7zMHPP-P8IFGArI_E8UoLWF6qf0FPD-sb4hueNOb-8sDBqW7SvPtFlZAZo_gZyFzoJNB5_w7xDgYxQozzAgNe_o1K0QDLfDJ7heos4zfOSeofosaXyLvF5oaD57GTrGMEnUEmQrc35qVU7mk8M6umVNSUXOrTm9UYPWq053E9p2djZd-q_jlFqVBNzSvhD6f1SuRFRh8LOcbUu9mu7d3IYVj1q9AeFE5ZPx9D4-SGoVfKhrlsLRbCGZPMCXsFaNx2pfTE0vXU6gaI9wAIcoLPEw5COQoRtsZqjAhY1iDwLZfld3nuyp29McGwl5NCd3xyzPzFZmGVBueFQZzscneDkTMMJ71pP68BMBiYn9HmRj_CGHH-4JNyzDJpA_poQWbfm_GeMpUWq79jgjAboIS4Ei_SgrujwO9fmhOL2SJbc8iGsgoVw8zL4SvPUsq40Vr4gdgrNPi8QqZwOvHtoebKC0a9m6GFYUzfMqNosjAoJ5BetEsSfyG0chl1HpBwEGhecMWzgElt1mYOItTAyt70JrIVZoUUkiMEAPJK7bIB17QAy1t5lgcBabBsyih3M0NCIyFM5itC4BUpisEsm7xBwJDLB1JDyywOuOSXu-zcsyBUUDTLSh8u6Isyfkxy-HwfoFMEYQtr-_7QUSWOcIATTrJJBiNFAbXNGeHrGXhilIXgccKkqFTZJpQYmgcSkLDKx7Kl9zqemDNBTFkw3EDf3dvLe6GRWvQtMX7cuxs_h6KTPJYQ_02iuJyajGExUz3lLC-6ybWyUfiYY-wadr4fU_E1wZE_bwf1Fj9DyZ86Bdd_1D15NCZzdC24rdM38rUhqZAIpCMfIGyaqUOv8_JiFj34hc3GQlJ938mSJ-9eAVpUf-FOikkIgA29XssWZenr1K78ONIx6WTXLc9T_aqsN2ReaC-x9hzqQOZPXn9Y_yohWXLS9n-_WKUpx5LxZWF5jWB9wbiBRY_WySL2UUCkW5gTfAdVqFm72wbaZIrhA46pg7tgs8GIeOUNC24mWIhecyRGsRqp2YLL3Tdl_dRrOuKYuZsirEe4RsDEfX9NrpDz8grFvRChnTwTOkNO8VLLHbpgH8AQI9Ui-mRcfkNG_3MfPfYark57BYXOGtx7sghmKOOmMQt2j_vtqJccjcrYRlXzT3r0Y92R3JNpwrtps8fGkIHVLpR4vxLoLslupCQKEaZUQkhygCv2fmeU89n5eYrok44IQc_-c4lVk-jBIUWPii4B6faSvjFF49s1Tuu2VzQWOqdFZzEpOK5AT9drM3uRapDZkQwwjZhbIJDljL0Cif884Mqve1F6UAFUteBLru0j8S1DohLqdd_sF3LP5Z1xZl9Vp_teZpxaASmow4o9YnP5ddAjjc0xIpImpmfNRTjoUVMG3_lBPYkSoosivn8yKqmh9EIUf9kByL7Iy3TDQ5-dwHPUsLwo1JgOuFPP48Ify9enEQrQU-xMmVNU7PwiNMV4EMe4xI32Strz5h2fdhmpt5sJV5Wnip_OWq2KBnIP3AV_ux8SGTYF3t4Wv7dOrVJAenqojqWejr5bTgMIpNnQZNT3PdXTqVbjO0RqvWqehxbq1YOT49TcbVoCf7LUQfKrXzeEs9oC9ZnB8mUXk3CW_rT-CgogrsJDu9UeeiIvBQFyb1WptmxfDWUSLjHVKDyv7hsWdn4B4jAur1sW2VwkjizcRprOjQAGryK75YT2-b4iEfyVY-vv5SBAQORO6Xofainzw4aUzmo-WBgCXkmwOxtbsbOEL0uqiLa-296UWooeGlv16nYTtLQwFOTaQLTg96oWi2qc6SPb__xUniY8KTogEQ79bYq_GW8pQGRcqUHR7hSjPOCFR6E0E36SM3_kRqTvLmWftOvGmGX8Pxse_EcFbG2fpyvUUuJ_bc0vW2qj510zG1tyy-HV5pi-FkhWe6Wm6tj7NixZgPuAVsOZXAaQdZDmY0Od1mHuOJ0BrmM6Vty-WY2pG5FOPml_HNNwjMArQ1Y6crczbkmpEde9XvKCm-zsUbGTq-HYyNXcWs4YPrmKe7wC9d8CtsPTuCQjOukFIoFOvNvwMJE6pUpDkdzjQ8lcyjY23DRo_DgertKeadmZjogJhyLDgys4KErYJSluWJrcjCJp6q-q9PBF1Of8VaZ8h3VfzNETTycFNbIOhpZPw8-232R0u4lLGqefkzn_2VYxfwRsnpdpIsURohNOAN68dINZC8jCCaMaAepw64V4SE1r6uMVOa9oe9j-B87i1BZRe3erWBv50d1FcUcpOdxg_nyqwjooToP4sbNEdP64RiSmefAwPKiDShzHfSIhIrnZmoqbTuthuf-wzyxVDUaQq-Csmi-FqYWxwyJDlpR1DqFjh_U1Xgja8dk-WMygf487vLGR7Pa1fMOJR-GucvJjqEcJs94eer4yZFrEKCB8FiiGMa-pVUJnUVwbsOI4AXbzz2tG0PisQVfhpCSWa6yrYJmr1q_F47x_SBhUV8qXKW1JFZORJNhlCIGy0hjGyADIqRehg5BQFPJFhoYBRhL_ufCpw9Wb6AaH4MGl8SlupnNt9JMnJTc0RhHoSYxXUW1XxAldQh4HIjLc3as9fOJkvWUSTV3KPCcA33SY9pslIovXPPxRZqh1s5VhyGXYlz340FGu4j4jvbpcrcmm4pOIjhlv7rngYkPJTlXQQl2oHeKuMQvFHyzLNNrPgzOdZWAXA_iN0viaxs1Pz5kXBm3H-WHCYSx0l-EPl7S-Do2fe5AoqULCaCs2O7FxZFO5rDltccMruZ_x5zRn1kSQs-p1xfXSWn0zBlZqVoZRm2EmWsJVIXF_NAiLp4Gw6N-3fwG8tf-0UUGt4TBlTNqPmjGNd-ZeWzbJQPV7PxEKdngE0cSMFICV3lsRsK4r1ZxtgCSYTr45y3BTsIfdn6jGAgbvRt6SGrbF8WOFoEr2BRfza30wZYEKsG5s1zsic0BEdP0d4PgegnQOT_Su4SK2I6DRjZ6KSx6M-eIU_12A3D7wtJAYJ0wwhVSn3nfmb9_XnAVyVa0c4NcC4p3f6mF5hc9MNZp85Vx_3Zw74j75qYXVIRUOY6FSuHgSdaWlWHrY5p9FsnDaRVti8ae27gL0ANG1tVggoC56kq_uyTFex2j2CicA0pXQthNPN1ogQsrEq4FREJgfu4a3AIB_tmniG-GHPdrF71xTpK6ccrKp0sezgLGcRsT8fqY2BqTVxN2tDEysBpbqm1DLEQobzaQq3o-e4gWRdpWGgpC9v2JiuQwylrXCtCbEoxtw-XnY1RztG2Ly0UfrrFMG4vIp0xyGqUM1zi3mhLPNL64FTwf0gngllgJ_mZDc-RrA9175f60N6RFOjUefiN0unb8tAvXY74ND1z_Ie4B5hDloU8peh0YpcHFGfu8DcqP5Py8cDrGOe3CIYR-b1i2qk4IOAFV5aMf6RKlRc7uNxHjjjOx0wLDYwXiuin_P3gv9tYS90vKNDxtXnB8gDd1fh85d6nSzkUZHyBhForie7ftR2P0SKvKcFHu9e10C9V8d6fDUgsqAxG2a1UiBXSY0hVYJZZ4iQ6xiJUx225rsZ00-J9gaQ2RlZxHTBM35Rj0EQc5x_Q7DhISb9cDaU-Pl5beHFuPbzNDXb1aXlaJ8pSd-LC8wnOe-5pHRQY11utLrIGxSi8JXnx100xJjybl9UfkBl72HQPko5LuKUHjyGBn4PS6jsDOsJJDOhzzqJWqk0YYWIswZ3ojWBrP62Unv2kgU49JdC06IN0MzsCvIVvOh7hS-Zk5r9xsF43DCEcYHVoSWidoODLFywxIBRbXCbQ-e7a2LMzW3EluCZxY0A_d-myQtT4eQjGq_wqenHfCg33bvnAyZf8SV7H4r58RHfdskY5Uxx36cqqEX1QI34osMIbD4JeE8R2LN27VVbZC-BymXXU6tRGsmz9jM3wlorfUJDlEndbgjm4bWGkwt6cVqf3yFePpv0ZiJ943xDijBePw9rM_aQZ6af3g8Vw1zfWST-FZqHRkwXFe2FVDHZ1Wxl5cpXTh-ztcXrPjv2anFDcqUBggOmgijlTIpdUe6K0Es5S28qRLLNXHvZB-DpYeu5KGk6S47qBL6UPp0kA6lc2dLJOKzqJ5oLlYRQsgGKZMTnC_9i59j4XiwGjrhPnQyaALz83q4cO2qODZiOjMjehliGkv92Y6W3bC9MqNmjvHe1bzIMaXKHZc2eF7zUl1V-AazekAugUW09uEEz-CixZ51_jHzTxp27BiNdY1AoJNDmk6LMGt2uKsaOPHPbveZrfPTdeaqCO_i4BpJCJJXOA2QSlZ6wTYW8FK-A6ohieUgpLCSQMVoR2TwpQfQ-hA5q2z_xwGYEyY8hR-z4-r89XiGqkvDL5C2hqgu_egM3J_RlVlfQT0A_F8csPcdcN6_Sd-MozGf0Lk95lsrUtpUVuuR68h4tzksm2wmnUxUMHoTbTeG6kIK9Xoef4S4ZenUrU1vBusYnF7BLAopOeQjkst0uAtBvbPlOyKayFKV0EbOOWmKk4VCYnWiK0lx2GZ9hDV5tz-vFATkxvURjfBzzmIhPTP8fmHc18m3P7nEzELxXOspmdeC0V9iJxCCNAcC7x8la_W_rRKINZodg0qX7TjWWitqYnPIkp5CTlZ-iHxeiK4BOi85X4w3oP8Ke_ffKIbmd6c29-6vllbtmu997B0OY8YsxIc8hK9_LLjgaC2rSijDmVOn8eTEjbtNH5UBzBB0aXIUMOEaSdLRlnFhJGeI5kpD1qKqohcPH4R68plk-truUZtDVCiIPtP3WdILWvTrC21NdYuW1fob6Y3YbWBlFAu9LW7HoBFniS4NxggFxq1KulS_Hmb9g_TPjG7uPmp4HX8Eisf00n-SCxCL42kMAaJCcvA16kZiS5cHcO6PjvDy1AgCA96Cx5M7qS_qjhVNmNSwulg0TNYIkYUubx2Al3TRaxYbGLyvGDnHg7CK4OVDRswNEbJtNTw6fcFP5GwKCd8Hv_tiN4iUlFZvynnIHHvvS-fw47kRP-a0an9doNFoKsdDKChFKP4C7iopusNYsz0HgzIxHqmUF6ThcWsTpHJRcUDRLlZtP2XKEl6FebGKMDH1M86xOHpSaoKq7X7YNkIe-mYz1nAqZ3VjQRITgdPMWND4RlngtUnlT2obndVIXd_ZtICrRGE3upyfWlu1j86NIlnNIJHXKBcDyFDxZF7MSqYlMPTn3TrNuzSbMXvDCwl7yvvTb2yrGqZLQNY8T0Zm01YO5iX9vqDrQP0SmWnwaMTn7KqhzxGLjjWVHwVNUPo8n8bsWNM4XuH3LYulXu1lNgIR4VRP8cr0wjVZUutAkkPLbYbB3aYqWt7d056hZPjNbxmoTFK5aU8DAOwVGfOzaNAsGU-AJ_5-gQ5syt5-BovWdtMboJg7MRf-xlSnfcGGypmloX5TtbViIuiasBom4wgElpwQq8aT-aImt_JZcvRO86kO4ejqcgIfAp1LfcOCFLorR5JIBkZcvh7ZBG3VXXbrNszhSMiKJL7dUVHXnoEwNa_MC71Aw91oFjHI_9X4VODDnfHb4JA2Ra5_57n9lX0dXBgm2zqCS7A2gO2fmadj_ICiY-laYEH3iV9jJN2Od0DGzDXeXG3XVvLG1lN_LUqihL8Kn7H77e_rmOdniOzAznnUJHcI0JV1C7FAeGctf_odEqx5cG9byp60W_Q4wQQ-JsDZQro3e_el4AS3IrvnftzNQSWjILk8MFxri4fR3jzduI1upH1Etdbr5-dUUXjdmateBZBwvB8c4gbmlMAlDnDtYaRG876Ytx7BYuMBI4ZFNVZVrQa1yxBZr6CSddKqmWZ3-zQE_bLVhuL8-rr52p31Cv9k93agGEFPxFazsvwhoxP27PGt1HhttKsL6Nbeuy6zJ_iVXo_9haYp9xykp9oJmNuYRx8sOKZPMabslPN1kmOCGrrP72LVXi37bvo3lRxOGoPkvAO9mMFss5V1GutDescxDeDLGIripetR78gjBAKKB7maDZbi9lnDkETfhITmbsXhXJTATUU_Jz1dpy5yABpriQ0i6ccg9VZz9YkX0s2iINF9GQbzGSGIMvnF6dXoG0h_DYwVXNElEg3o__p86eyg9rp4NywqHnaIDRWvDMiv9HqehFrSW5ebbVyj6JTlmyhVit6VEKWoytC_IFk4zJuHEfchBpf6VWR4_E56fSACQpJxw32kBMlU4qvH2i_qkYE0ax861f6UIbVpevvw7ESTw1hrUQ4VdcWy7ZBxZuhcM5-ZVQs5q69X-EsFl2rZHnnJm6yTlccC66giUAnXkrYe5zAMR269fZUu5AyVjB_FT-lZBJSTouavtg2u5-ECPZ2kBSmcymfY8vSiOFIYx1QF0kpzw7BlipTS97KZQWnfzlVudP547t_3ulTsNbp75lvhGxmxaKDWEjiQHfysgT4Ea5z9Vh75FUO8yJKn5f-zeW_Zc6bnqMbrtSJb9xPjjTlN-sSuKG_L4c-4G0e5iRB4HJVwoMKE1F-fa0DtDdO45xjMKoUC5C_dElPbLb-2nvXAO1fFmx_wdABixpTFZeuI8sO9uBFrrrBWWoRm24nC3aJ5L0TFBczH7d8F1YAXhwZxzbR0DsEkT7rtJrUA5mYEZ2LQ5EDOff7gajLsp3mOYGzwuFkyHskWIKq52TuNAblReEWZY-13kykokVR4H4VGeM4JHrkExTlF1O432WHGMmBvmz1HOFKFmHYegY4tP0-98eFRK6t0qQcBYq35rNEGLEUgtERRPJ9MBR5dxG3t2KCcR9kKY4Mm-dcAMNM07Rq_lGFGzpZ8WvG_80hnR-18V8TeehKNZpnzFLXVuXhaQeDQZPok7y6-9QWCwtE3frvxRsMAq0iFtRcfO5oGyZEBdDxeXaAUuH64jo4whNZpr3mFng1T-J8O5H_fGg7VK-LAtS7Wpk57iZ-RSo5eH8Bk0_r9RYbdo8zSHLrEYTJiT4DVUiPVPF2JzmbOI0HxVaAN-7TVSt123BMLXV9KV77lZPEOdmzjMSzgkmw0CDjZPsEw7gQQj7A7FxEWzreBZ30dqmnGfXIL3opGbIPgseuZ1dkIXTC4ai1tjNC6nfcCrUH_36KI0oScuf-ZsZTbgWvk176Xlnbzo5lU-5LyCBuezsqji9439pPMGfUQaHdGH87fQkuvW4ZUVgkfN9HLgAnLLQvxV1i9uYAVUWhb-sC6XlC2QTDRWODGjs7mjF0S2YgrW83vs6BSMHParOdMbVYTcjPvUNJLE65rtWdrDVZkbTTDPwx1aSZh7O7V5wH6vd3I-aucD10XY646MSyqax-h3p2NdE5m9t7ILcnsBI7f0GeHm_l445M4IoJyrVrCAtaYm0cgn9bGdlEqptB5FVCZ4wsPGPnOo1mgXoIFHzIcvLnBnQC7GNp_-RWOWJ0rA3C4L1B3HerZJVdUsJYAvG2s5rGmr7FIl-RcqJb4W6l0Bo--oxiwqiXc8SMNosand-EhCQhIr9a7OKdmIIA00RaZo6rQDNuPnbtZ-xM4OVVdUCHBnaiPgW_Sf8eaEDgFkNdcLwElk2_4LNciggD43VUI3dhR0nH_Xt75M5K4z41hIk_L6khMviAgXO-2-iwCv88sW0rIv5_IRiNJy6b75oA9-kvL75yCHKY3RL27QBC4VRheBguyk8eg9CMsqxNsPoxD4qsElmeOj2GuiTSMlqakFz2-s_MiafV9d4AMFXyUZ-TvykJyzhXLwL2A4hc2DWCZ4jYf-KwIWVZpn87iO9xuM99Y-Tm4FALvIIpKNCigpcnAlJEmQwTfhv1AuzWv6_6PAyKgY_NIgjJ3jN9Km7z6elvQ1HsapkxWaFccE5YcyHB60nd5XRbbT13_C4D9VUF-tUT3fXR7CzbBMFJAIQwvIE2jyR_sG-ei5sHe3D-zzBnPDU6A-ewEmlmpFYY2Jy7kaabgRwtxlpIivzs7DlP0oGPu2IQ-0flpvBv5tkSExQCFZLM7-T6R8RyTL1TGr72tFnxGJxxwrW97u78eTAxFnS2DN2iniwKwH0KYXBN5VooTZyFiq6iqK49cZc0YenqoZJZ-R2MSuoICMlMem2IZwmopJ25R_fblPO_kdoiBVaDchP7PiexcMsh1fsPwCP3NQReLcw6XILHN5LvWpkJzHZBvfmM3_EXfozbYqlT7xexlVfK5RF2WEfxTS_XE_vxUwCXJ4FEFhotes2qLgQJgpQNVLfUmBO0s_sGhp9RbnywzD9ck7N-W59SL9FtqFq9GssMCxTlmUQ3nclWnqgVrtbwAYMSoxivDnR2cnqp6jBPyED9w88eYuiR85_QL_Bn7W0sobrqxjrIxIKXjlTv1W8OtXvON6bRp9kJq6ymvJ0dK_Cx-qQzlk53c8DyIJCiBfmcgyvdlAZzj8mG3ERH3Wh7ky8FnT3V56ibsEC8coMbdx9pCympNAgLgtQX5z0QS0hzKwOLa_ZWoactgIQGEDa8K5Ea37gOxAkzY0stErRn0xh5aswVT9CWuGqlaPCgOZG7HPp6cn45e0SApoRnJTfAG628JjzNOFudEe0Jmt6-nHBgh40BIVI5X3rP3QMaF6V6VVPrMWMUeazVbf1EMJZpItNcjFM-0tCrdI6D1lQHYnqAoA0Wl2kJ88Eu82rOjm9Bw9TgR7O7D85o7ytVPo1Ga1xPbkDb7hpgIaj01KOrCe8ocBnyZQDo8yZLmGUpWU-LFZ1J23vpFupzEddEFcaSi4pggBwZfc8gSES1WTOLAYHO5CDopOxUGg6bjRn9WDiQcZ8ehVB_ZxsBK3m13POOpDkaAW863Fxu1zE7hXPb3pq0kb4Cm53lVsNInqZgNIOWOsksmZKpuBg5kaFY_aiuwVbfv2RoVDOiyjXj5K-oohG0Vkl-oI0-eqN4ctPDvfeVQ__uliH_S-l2qdAqEHz399UiwOigReHv4JFEGqsaUdhcUxTtImiCQVVF7_t5MEMfrpLwv60dGoolJUCbFBEQ4JJOZ33nF9idG2k2DS_Hu2iKHKRMKYJ843fvNbYqG0jpURI8oDlWpBrUmOn4d_4OZCsgWaR8XVRWAYBqI6RYndee098OPNhb3ff4f17fDjipbb5epJ-Lj-hMn1zd34Fz9309MBmnu2vqddwKtmGFbKwKaHXxpT_Iop0raYRqh5-7VKjFrN7Qx2yTEJVUNDI59WIeOpzUn9tLPyC6oGAeytZfSbKcm6RXo9a8cUw-7uoP1nuNNDBWkry4O6c4II41op6ranND7-okf0tpyPS2wzi00IlviLyMb0oZVu25myqOt5d65fYy4oAw61uLuYO0edKOBhnk5GsprnhoUkaHdWQtdFW8l9cjoU_l0vR1HgGRDoG3ZskTIjl7rB9npcIZusdU1DeB8WgUHz_XbCh6bdcXtRw2bmxi1FxvjHnjxAXfSeYRYOmHViQ7iYjzBoByfeklMIZ0_Q-My-mTji0JW5Otqp8xR_5xOcsPnk01uTL8ucF2DxdPmwM03m-JQ8_K6X2t5aKmyP_MDgikmxQ1PNKKEYhudzOHrf-4PJ4gmkMjnBuXGCpjUmGwjoKnLrGMAq6IxNKMFb1X57oCIhjYABdgXxpRnkgW86UB-POjw08LYVOeEitdF5yz8a8tE9Hpd3qum59PfPwYwsqNWbbfNqet9UANUcoY0IZI3IQmeFIbU2MJY1uy9XOM3omzI-vPJ0JsED_nPUxrLtWqiQIvw5yrZDeQGacJT-rboisbiwDxNL5Stk8mAKKdMfRBEGqSVk8mCHN8oDFi4tvhhpjYy8JvUdLxzl-5Qfmz7RlOSQU8A4sI3gIzCLpkqCbhiWkbTyyZQKN4nn35aqwTnU62eMpt5ocvwzIncyt3fARa8-DmkdX8AJuZwKo1UC64-6ciHDmHTrEynBMmG8zYMCxo28Gmok8XQBXrs-tvb3X0X3o1u-XGZKvxr_LpOOBqTKYFWdFkf5VuNruixADO5tuImg_hqPBU_Tyk1CfdUWUIFvmT6XKGV56zNyw-GIH5hau1M_2DsschLbUA-Kw6pNmESMPUppId-H37SV8OmKFsFgPxD4LNukQE-iscOGkRmqYUmySHO9m-TQ2d5zP1YelN8_Lz8mgicRp_1nopC29PvkLtiVWLQJ-vnJwUEFBTileo2a0fGbjbgOuNQnE_987XQJhmtyZx5ZPUrLmgkQjWrVWMaOkMascXzF26kx4kVZl4q5w3D8PcWsHV9yF702MI2uq_ropQhAxB5sazdtmEFGgwO_myTlkRstrAqi5G4etPbmxUTP_GQ4fzfygYctJ0iBVIpB9RsyQhBEQDRVVUIpcXkq91o6aZZsmVXSv7FT0G0U7ayDS6vCd6RAbLm0ZuiHlDw77wsbtet9cQftOq95yj6Og0c-NDVTikpdBxhqY3_2W1Ge0ewoefuwQt9zYhBXYf4pGRKIMpRZ2rtSskUnrlVel-HKMYCJj8KzEe_7zEh6G3U5OAztl5_W3FAXyWVAJLpOztGya_QzUkMkL5hzwUXIII7pMf0D5rrAiKhV6_BlSpPGzbBMmxZtONlFbGYgbEijN7dqqc8BPf4AWuRN0e_6_aRoG_TLD4zxJJT1tv_QdSlD3wph7EweM_V_qo15hfN6pPj2iV57DVQYaj2Dg10nkN7HEnAZe1ohc3vG6IxRxn8WIXrwoPNPsLoL7OF9hzOMRPyQwh75z-j4LFpGHkpGB99XrC-vZ4CCj7dhpvRWw92omusJKouJMe-osGbgjuiJb_yTqQhBS2F-0fMdiwiEh4K16Gsaldycjs3jFNMi_vbxq61VUVrKdBLQY7X4Mc6N6dIyvP4cx0EcaY_kJX9BX3bZcJjWubKSbJAWkFanIP22YVHzKlj5WocDhYyZV-ZAjB4yS8FNbwh_Lc3NAvUOP04CZ7Zpi5BQtCWVSTutK2hpD0txifblJF4QDQwSDs11e2-vGrD36ju2RczjFYG5__fXOmeCQ0G5osZ9ifGp9PtKNigAsEdSP4nVRSVkxtUnWMzt5a4Ln_rnbIaOR5B3Jfib1-cKz1XlBrUT7vcPWBD5G_ieZmgLM90x-9RCxcDIR89fzifjERBIzE77lgl_TuLokMIGxp4y0kWAXGESMhoTTmWtbqU69M6aSm2OAotik8vOEZwel9fgRgo-jtTBL2Ix-6g4w2mh6IjFcbhC6EssQGj6Jq_P_6iKhXeMPJuQk2PRCVu9SB0XFh6mTuPYJ_45LSm6yBhdHp5xwdmaxLluHXOeuc8ZiFHkvo3VSwltLDzArRbVje35L_nqF4KfhUdlud_1q0zmKoLRyKrbVp2xFGDKok82aRnXqvN0sfNxtPgFGuXPKlepPuIJOiOLWPmdeYq40uBF3R7TUx_5w-f8leqX6i5QNz_qZl-vieikIWbYg2TkfW6AZ4IR-Sg7ejYO6846n8n226xh_JrdXb_rt56B_2d1Sg9IqGtDF_rbPdYF3c_VsdNUpRN8ZWUP_ord99UMBOFUvS0fGzWEMk7ZpNcpUF63gPAu5yVAYTf7T8Hp4oyWAIuZl3SUFM2gj4l73R7KktGaAxB-_IFILEBKy9OSQwYWJIoANwz-EqmL-6aiwNq2uFsMtvArcMXRx3d1tOajOEoPnYLrBjhfPaKNjwN22jtObmWbKQM8rbz51AB0Ue5NsEDe20o5ElX8fAS6VdOHlIKjm4Nln4thPrCBUaL6qU3E9JqP-cgSwjX6KgZ3CKoxA-mVxMnSWNmV1VN0ylLF5tGMKj3VZ6MSsV7ReNapHAL8cvXqd6mEEqqvAl_qN3Gg8MxvEh5uRo1Sp2h144XWledh1uch6mEdcA2PQ-O7LABTjMSTn9SXC1XzdQVEWl3KTGBeGLQBL0FR6J7zztWuYTmcD5j19BP6FMtJIvel7IxtKq3VeXIcWJkpFlkdHhnE9LmeNpAiz3moWzU5cXJRH7yJy6qcpXJ2az3O6pBYsVxUbDAGANDlBNk-grcCk9Z4G6mjhSfB6jVIx8qcxbF2W11XRSCfwenOGYkI_gqEPZgH0bYowDLZz8X12bvnjHZcPmS9KMuup0iKfU9cnCgj1RsCJG9FeP_kuVyLNQVJEaKj9hurIBfpxYxbXygchj5j-7EMVWsbJZKk19wGAzaHutoRpv6HEtlTDcrP_XiisdJ9V1faz6D9rTnMRRmI8j_n8LTgyjzeC6989EqZdqVhUq7OXXVRHZjXSWY-EL0_uSA9ahW-FK0mu18ryTNu4UMzEEuDH4-jEogW0iR0-3rjRD_TQlcnwbfWMtuFgCx95wVnKuLHvmdnJgwYBQLmN-lwz7v9-Xt-tLwdexsTz8wSoiuhvD8bWWzF8R-mO5mWN_aNr_ZustxVnkxLXI7XUJHkXST8rm-YjSJWhe8EvMeatcL6oRRW1gBUH6zZ28JUrdIupYO7mQZlYvYOCvrb3hJzfFTlkGleqMxOBgbi31rGoFmd9mMiGY6Ljv4yzP1gsO9_r3b2fap1vL5DO_a9jhiI16Lz9WoM9RRXuzibzkqczEYbJV8a_EdD0_3X2xAA_KcJ6PxwGgp_CbUw-h1HhYViVltVOI4B2NfJzcGSq_PU3w5-kPplwQ2Us9TSi7qi0l8DSiA5IbvjA3ICnZ27AKmvXewFXUBvyPnYs_q2mommWcnMP8zx9TTWnZurXJZcBkYqy3g2Xk-Y7m1zxT5Q-TtSPmMR7bOy3IbB_PALsjAogBOJG4KsOvoo1UGe5HTV-QsDDxw_Yc7Cz9QYziPW5VF4Te8BkSzKKw5C83hk3KpZ9cCk2yvL_WdsoizcwQqAZa-uobf3JWRi55-An-qwDQwi2OwShm0YenRTXnvoIIQcgsV_MSCQCDvNw0olCCIxF0r75W7eVu9GC-EnhXBG36Dp5SlO6XkQ62vGp-GFU_XKeIbshcQjatg3WcCPZzdN29uTLhLH_lVT34GD1Sc5oaOtoamCMIOJ0L-7GdRuy9wnF2Kb29yGvcUcviLzQpm2Gy3JjeDBj5zkMfvpNVyLU6ZFIl7FyuQCHavcCjX9vUVaSH8O1papgnzi1caC2CtD0eBjhcueIuPGhwHvriIaHU3doR5obF7tMWUiS7jM8e3NvmiWBm_fcgFyoC4eRd0c55fLTK8-o1r7gQ7bC12wHRJTkGQZ347axUVJO4v9FRwe6vO5VOG2YB0Y0x-JcD62rIV7QiIuiKSbzDF0zFtkxk-wLcX7dQ9s_tHL6DTTZGaZSdmB7-8Dmi9I0TOjoi6WCNjttGcOToPSzZY7H4SNqarl9wt2O9wGT6uA5a25Bs217-0I-seIYbghGgH94vIseysTYEE8bSN9pu6NOHto4jdH4rCvvji3xz287L0VyDAMpH959wfMwIu5ckL8xnI-AMG7C6s9LfHEA9xBTLRYcn-bzmgTMnx8qMIIkJ5l8VTEW802is-toL5v4nrBG2i_9AHtGJ9Vkq4YM7QG2DIxBkSVxQZB2w2UFWrJ_EO_06qAF4gOAPuNy3jVeKerVzhtfr5LjWgY5s0f-uwblwOHsxgxIkyI_HGKxeGjENJOjY6Tol04bis2ksytkEtzz_938PmufZ-SqMUKZX9KLdmuWwp3wKaSKznNpq5TQFckNSwhzCr6CK6SbP0qZMfGybX92_mzLZAzHyZn-zf4Cx2r_XMhx2S3P23BgiuuO29RYGookTLbIXswzbIrBWNS7Eslg6a_2LT-SOMqXDwCZG4pMn9FBB3AtQSDXHGaoL1OJRke-a_W8Zicv92965xUDtPEVEtLZ2wY90BvcY2WDbYleIHPKmIhtglB_rLk_5ZD0A4-lf-pHA1lWG6b3DkJRkONxUz_I3oPgFgbRJSf2BFjdwqF8SOGCujKZTRm8g_JNFG82GYttzlDJAvI-geMK3QaDv3QTGtptTed0zXvPRqk0wk7TW84tGxcrrHrnvS5_bl5Z2JmDlvsdLLPvkouBJsd-ZvigPjZfKzPqUonPUQjMYi5_GhN6V4Tzx-EoOo45qh1-xz3XSuR_OPs0S7M7AQxm2BJC2kwU3eslb1P4JsSRhfF7QhWzM-LXaJsFb6bykPhSuIUkIj3WWZ_Yu6prSYOMNhRgWevsHA6CV91LWhuAwUVY9vAMeu_OD9zZ0xkFJxvuWm7WzaOaTGEOcEVrCO-Vz4DQttBonblT7uD0gV76eL67k1d1lk0UCmaaZFM9BTagpQsKjyJmX4wGJXnad6JxC51Yjv02QoU2w-STMgLjHyjIskHWLZiqmbc3DBoc-REZrydqOOVPNS3oP-_ylAL_W9AFpZuKU9r5btW0xqd_hC619I-2l0ttRiP6NxhvKsZL5SoSjZue-TBEDbkVMfobFxnauFUaaj7Pz8xBJZ2CvEarQvMyvmAJxQiqat_2XqgTg5nuKWDTIbTa0KgcU2AAhbaf_3ngzF9JWos-jfvOoq6TB-lxgBZLiDM2U5reoIRYfhmOT331APa4-WK3FMWfrE9-GDLUx8u63xlQPN6mueFmyY_lbgZ_2Aby9uB6Q4DhBKFMiewy-DMO9dspgtEH6KYWXBhaQP6JDihXzbT9f4sjhGtxEr71N0Z42FQzgRC8zROiwX2isRd-Bg0Vuq9vpDrXNlQxZbAeOugqb0q_SfFadZz7o19WWUtPvlNOVM40j0Ee7aLvjXkH7bHKhSqK45foUwyX66dGrrzXW0EsKo0gxKEfBGSoTsqOqOJCZUf4OlLht0H4oGm9jwx8hwJyXF7Bw6WyLlYk5KuWFC9y6cnHrl5qRewaXxp9vhR565CnYi5MCisqoh0Y94gubwhIKtOHpoe0Klh5-Zc9RQvQRXlRL_-Z1l_uVgMWdIh-JZd2-bDSx1QpHoZlYP486qxRh-LsIERP5LlEynBUf8A7cq-Az2xYSoP9zHsB2468XE8Tn_QQAksEknH_zdXQ2xIUpZ9CjT1Gk7iX3107Ovz7_engVskRIGIii5y0fJIYD46NIybrlsA9n1apKhy-k_Pj8J40sfCpKGlHj99q3-Vee_R4DcV2n4Ed4EnTLUStP2cImY2fyQ0cj5GwzOz4VxjOt2YYgPO-ac_Ep5H_oMPibh7xjdi1uQd2jdKV7OmQnVdFL4mT-B23yWB8OD43xRxo0oIvCYqILC5xveAmOSMmO6qC-eMJUSz5WDZje-Ay2dgpubOaXPVtGYy_gIxAm70HCxCOgrU1fSDILptU5nI4lNkEfg_Y6ZU8rmZo7j5kcHBddJ4RwWo3Imyy-UKIul6YiKB6zSs8HpGx_YgR6K39ELhADxcBNF_z8Ufo-RQFWZJE4RK7gfmBjx1kL6hUg9cvp70uX58hCGZB267VU1ptwp7M39-LD7VGetviCnkD2WmYsvGCaGPezXDvvU5Vm3lb8XgqvRZ1L_63QTHALH0xPD2nanAoBk1MBqKxHzdR8ZkacyzRPbRHgqtKnh_3I0eXlUkrVC19rZVy0swjWMa77fVtvKMihFJZk_mIisyXk9I5dXUVhjCzOe3GZSBrvSDQHIVd8_pSYpFnCXYbC3C3hLf_-mO5d2VsrGlJDp2DrrxkAL_YvOmqMkE8KQzMC5-IvvFlxyEB0rYF1p_O2N8udusH271nDuSehHlbaUYfLINJnS-leSd_FlhKB_Gj3L6G4j7D5zpdOzcd-UUaQ-dMWhtaEk5qnjb7AxmVRzDj_0AvfsGI8N4mH9x-2rLz7ro3_Tx8nqLUCHPi2N5B568r9ZK8kMRM2Z6sFw2Gso_zQE5WHr8s8myAGXASHoW4u2Zi6FM6aUBISmHzZ43P8JbvMLhWRFZDUY1luJktgft5gAlQcX2ZkXpb22njSOcKtxt34bWmtnBBvrdYdDGBpy_lHs9evyLOzzBX009g96u35euSiI4suKmUeFklvcmjamLR_cVlwTzdsYf5AB1xCRPlrA5J3GRjR4SRBI1j_BSk-4Q4q-DK9p3uGREBTiGrjWaqScoVcf_gEIjV0qWKKaENpo2kI0Qo_1fOCLcXbvtUEFHLWmEUBPbst2LcFqCCBUw_RT5vO3uRTctm1LbQSGQixOO4MmzJjE0AMIf1kGIHSEHMJHrCe7lmlvXI8Tpby_viIm2hQjWny1d24CyHS0pXb4ROFkfLDy4FN5M_GY4ouTglgO4DSulRKHkFB72s5y1PGkazZTGcLchxAdZ5DrcswRMNXo6YRYeJsSh7xYcXetJ0ZOb1ptFcTI_dLwL8C3BSSQBCGh47efGX_KB_p6bnfYB-tMq45U6kXYMHJpDt96QazNtQCxTAe_orCAR4bS8cxRUsIPXYgNjbbzc2lWdHXyrSda8jtrt_eZSrb9Fug8tbR_fuh7hl49J2Q8T7MDxflAp4RoyxgaaTlnktzDX3vvWgjtogVODplC58mAcl6kAzz2RsuDHRf9QA7tZgaDEEGde0Pab6E7myUQjJDBfwVYxZ4ysTAk_dmL50QaPucUFhA-yYQf8OIY5_7NsUJyJychxpX_elWyabD3GelsAGIGMLRQjsp8d4lPkZEQ0n-ShQS1Wm33SmNiw9fmBasShEyAApReFKXvNegbIJ3VsmXtyfT4Ip1UyjzoUyv_J0h-S53EJZ0G-7LmBh6cMxzWsvZzQqsa6z6pQB2hDDg-NfswxUavt8aU3iZnwNYkUaol3HouK0l9JOBTx0n6qnCQXvCLwEJ87x7BxnL0Ex4lPk1mpUoyZgQbc-dNJbb4cxn_jbmuidNyhjEt-ZCqs-81n1uCV5opnZVjRMac6oMqvxs8Rez2EZyKgEUfLwK-YXV6apXGr5sW5PjywMMiyrH2Ohb_Ske-oRPXWqFCW9IiH5cJRZ7QZwkV_uqRfUhIU4abLs4D2mClRak-CTtoZavYXGdtOGpbFXDXLpMHDpamSQ-bQaN2_NsDOKkneKh0LyKgyB3XkGN0Lar2nZWU_l2heGqDcEjMp7QoO1xq7vqchHfmUJwJSia5TJfzriJpztN5WiMjxMCONw4Gf6vlCWylat4oLjuRti1ASc8B8COWMjDdgxmPEQ_z_FOnybWmgGCe4GIEsLKFKyI_0r0nxi77NzcB5nl6ZnxKiG3LpMCwuh2fYaHMkYaHcAqioJu9fEusi_XAAi9Wm-U65J7YY8wtCnclKT8nBaGhIgZUtGESaw_PbF51pFCue6w7SKSoQQ4nZlcu0wy4FTQP8fHuCFzJx9ZR-Wrsc5kNsm7nbQaDsrIWDIe7Jxp8Du0RaeeEoVuUTwIbN96LPUMPAcCpOoD01HIooRovKUintvU_X2oV1PSnyo1BSt_k5fUMiF49_5lW-2mNl7QLkGRRgnhEiLu_PYgIuMGcgCzDUKmvbC2cG_CT2V3eb2eULbnqKRjzHtsF_mHIxDhxvgXQLcx1udjA_vCjIfhZ7W9MDrSsI0HUGCrmXTNOsRajYZwrwEa78X3eSXaGOx0hYFayEGL0ZXOIBHduUB34W61iii8j_muz3z9RsryYJszK8HfkUE8uMA9N9kz0WrPOvqYmZhUmxCXZtG8X85M30CVf_Bq6n4vNseG07sRDfhoCLrwcyljeUPKOCFiiCy4R9CK05qoKacdACeO3FxGiEbKsdh9pFSblwACFQLFE6ycIGccASou6Jy5E9FC1j7wC-lIECkWvokppl7aijm28afMvzaHcywE-eRcbBXEGzAS3CNoLtSO2zPd09i7UcjutZSvAV-i7L9PTClRTmKYIMiTOHLxScsoHQ97VRSN-lvX3CAIOY2m5A9LFXwQDY8Ocb_z1Diu_9QhYe91FJlskSLvUcH_alYF-AbLqbg-p9isj6LqpSr5VEIHp_FbpgRcgs1AMdOnQjUBFSI7VQc8Mv9qaRPky0aWfi7OWdH1ckhORgOzAetM-uWKd7a5iV4YYbdGlHrsnwD-8mr3KLJT7e4g7OnPakOEEXbZctntA0E9xnARuCEXChRIruyFwJt4ftFuR1jRAX6wxr-MO0o0RU1rKAThWJ1_2u-uOzpe3r08Sywmke3yUXQf1F_11hW8PJZ0jff4rOXG29PKbQyCaq4Fa1e_ZSAuj6itRmyZCo3bV6X1uPUq7fC1zarDIQHqWx0COipeyfDVqKcRniIKY6q3kG-d_ayE_TC4vM7MCiYPHWLVwHdGU9YyLZ9L4td6jwQ14NcsP6nkgo7KJOWRcNg0az2aovwOOayPEAYyU9uhQpPIqEesltsEypuhz2Y68Jk3gcbeazJgvDpXXfFwo34fzTwkPWuzS3gLp-goLaZLMggeyaUteEyFCrIrAOrA0j3-52cdH1dOUcaeOH9PfU8GoYlyUNr1cC9g2ZJbPg7NwdAvyUPxR_4_csv0_ISU67XwMOqCeqRval1lli4v6ZvNntdCpwEdULB3ExdPYjrXMxLoQeP3ZRD1AwjJ7wZxXyHpXJSchD1BzeUkjcv7oSCSDEBudVrLmAS_mJ8bAdAT-7RfI8A-mC85uBP0VhB591nFUsUKGZthxYEEj3yRph0lvxM2WbIu31zMlfHswXVmwZABAB_mQYxlpRKSvduvrD8liFVUpW3yL2wiEpByn-_pna9GupWHDtKbZbwt6ck2o5bS6GgBj0Bi-SKqh9UQf4kk1Xho1DubJREDoMtZ5BuZ1piPaquZl7gFt2iWZpEwgg19Ym7tV1c9gHdIlNS4hESUNKPcgqnxM1TXXT5ld3F5xmnw9Au4TieNPmWDVfYy9_dpYNrT0QLBGLtR85qH1BzX0DzUX7swLdDP1WEu-E8ccZTQVoXwx6UVkYbwBpxdhkXttJU5sk3ogALJbmaI2QZoWaeVR123om4_sDRUWWBUrwPVZZtHOBzIZIQJzxWYcD4zeBUGusTih2zOtoBiUbWU6SvjjFe0x0WRUNsXSwNI8s4NsvQSnXJLgORDG0w-YAf_aHcfLebLHn9hKAUDiDu2iDE_ItD5Kjn4ElBilnlfDqbVv3-FDFIS5Zceuy4RVGEmtqOtFvq-yPAw_5aixp9ZOFWBj_Z-fynZSYk3RCVlfVA4C9MXlITvH7eDrf32VKVZy_SzzwSC1UyW69Q1vVcXXcvpder9xamIDo6ZcMCvDTwiawfwDG2nrEZnwRIYasg09Qc-xFX7LWkcDMTzmCTDBU3qAXnJI-rRgF2WwHzqj2zlUBneOW2HO7_XyWdAmiJJxKKdiCsJdVsZ4QHcqis-fjtKeXtvznorHVy4SqwaS_GcrStRL6RTdyd9K0jJKkL0Ud5uhUNnghmIc0H-RpyJWrBfQiOXE39fWcxCA0B0xcQ1KjLsm22eVp09TNKu8Qd8yYFazRNNzs_jWQuqyzbnrN7ZVQiKbLeC4oGkiwPSAwJ3nkwYGF-hBcKJTR9PQGpQ481OacNaDITfiyIMy8uNLK3dnQ7VXeu-47xemc5r7MESVH22eWGVf9PYfr1eLSc7bnJKr73wtmoA75U2f3J8Rpk0PazicvL2sMyJckrErlu8qrAv4eAhc9kAqUSpk18ZojbUxcQrYqlIqDYq0vpK44bZLBumu59cwnR87c0dY-u1e75uxkspvOvZn8JR-kEbU3xPu2Q0P5xexC__klUmSX7oShLabEkHaJMXRDCW7gLC8LGMn8KzLBaLXKSabAU13OM5Nceyy-sUVU8e88HVWsYAMiRsdKVatVfLDROEpnqFdRY7EHzxSUWY8IssBuIxGFRknDgiuGjiFzuC33mw0qWHG4e6jhbEKUvDFIBWJQOl8Et477gs1jZQPuMBlTuf2-bu4EyI41Lx8YatncFIuNbJUqZesGaXY_KyiwvDMvGdfBO3gKLenrHx2GFngOCJFSe4-3xW__xV6f9DHBQadGeSjS4MkzZQXQjMrZHxJo6TTlzs17v1hG4xjWC_wvravzO0lH0qAksOngZVOhQHgx8vjAb38g8Dal01Yk2wZBWbraJgRMF8Yd4XIWdcC_5iMm-vtU9j5aDL6PJR6p3CazztWX22jr9iisPiRWenAN4tyuCvVyNdQM4oOAl5Wdjiebsj42OykPn645mutHU2VDnikZBsm8OgCNBVcMomssiJLITJLDzNG8oA3k3ZQ-x0dtijwoAOGUMBES78h0eQU-zQZT7ibcuXuKpAzyFK681MS33BYSMkUhkfTo5dN09bfkpy1DnxKZ8hxUtSRc6wtVxHj6bMJvNyA69IASYfArK3yv89euc-k_NPl6htaWhymduEcBnDHNfxVD8JSqbK6v3Wt_dhRLC54NNmx91_nKetfj6CjucWAsRolnBJG5sHIxUe59CEJkvccSESP9Ij34vNXjWiDbLFuNJNLexujPMUa_Xy2sluD_8ta1KXV9amUggk5go7yLcLHHTxnigII9tJ776xEMGxyXTu0Ezb_vQEkBq810hjszECSuarOp6e3O9KGU1BLNFtoOCOglbCaf7IePtlKMHomu2KvO8OvX2fmtoDfT9vyl6Icq3FC6jHP9IiRcKIUeBuqXvvFPJkAdB65hZGyxrO4lIcIfxoKjM7oOQNUe5p397VbmihAdyDTFIGfJXlxsUMv2O3SiFaJ-ccPjf3aD_HbPfl8xlLz7q29aezmjTqo5DBL3wFgvoRtPVWwWbAdQDPPaECL9XbBAAJ6EqIn7o_V-t9WQ_9hDmYO4ObNwlQJPZWT1TgzWlBPwNAtFkr15Va_ZpGNVZ_IMSRPamMcnyk38r0z_HEMWeY8l7eBXrZxWCJGxvidS6MlyZokKxH1F4JTx65rTcldtuR-Aj1iJd9_PGh5xXm6xqor4HZou7uaVfB-UC5BWUgIT6vbmdWM-5sZ-x_KJ70DLfkP1E2ZFVBTMG6IFUgocKxtnmcm_dT0jw8jPkBbgf4OjIxzMfqxi1DUWuH5PLPBHbvZvqf3F0YyCc2qOapKsMIHpbLVAuZYNiZ5hlx1o7tEfj2ng5VRfuccPzpW5lHG0peWOfEE76CvbMTyX6Mx9SizwluwO-le2RqR-IGSFLChNNvkFAicTxJszmQ_WKrmf489IRuIvlB2xIjHRUuqUo9ca3rZkpMLpAQ91UhlIeLVN6mlCQ4NVmQOwtfcU_1diaRwaBdsTQcojbXQ3FbKcCw1R1MLwgKmyZ6hU791yQuNzIqvNg5oBr6kvQPUTLDPmoIrtq2Tby_1wVIs01RcZyDtrjsS3yZhHXBadr22QzUf2-es3F1QFI21kQ_xjPkw1Vhmsj1pVrXf7Aa6hunuXFVuaL1BTqe4eyfhLXqOFZmKeQOCL0jA6mcOoV0qj4jhOZezmtH5J0IkDsP-jhK0DWCazbVNBOusjPQLjICtb4vmHoArKEgUtPjrQbEnKSL7UTnvUXsyhuqq7rQTF5M4QWNjCrGAmXPmnx20TL0wsCbSkpsazM3MUBnYwTsfMKOydR8IqVHbr3xBy-WNlwwy9fywZNzSguW8OLQyuRiOgFUjrKfiNITL2QtI39iKfdsL2e6xQUzxg3oURmC5XVQKDVEY4ZgoRVf1-5aklJNnURWafBjgWcYBHVydWOfzh4D8YomNfo2rO-tyvpWiN8WGx76sD9FTzfHzLIfF8jpCAnnpHbFaBnrWnxSal2PI51wopTYkaLnsz-w84AmZdtz3JaVcRbKxKyg8pVCvX2WtDpUXLQFbNc3xgxF7-pgMa_Ct_i_ZWf9_h3rYih_vHCc6K4kQB-_lMK2d-EZvEWbvs41X5fCA1v2fLLFzZxvJBjO2hduUCQBZsgRviDhnuLLS4yBBWJh6eZFsznFRpzA6AN89Q3q0K8uhnWoq-O21RNb9ttArQ84hAOf-HeWpOHvy6jY_Hr0EfcTG9_CYAu-WOCM2cIEyfAWC2jUZccF6T7yQrpaS-x3X0QyZmLQ3CkgAaT1A3MbYnNsunrTOqD9LPD-sJOMwfk3HQt0MRpE1nrV8efOtAWrI7OEmvWj1NIs306Uh6HAuclM2oEHK5yggPjvtJFl_9UoXcdQqtRv_t-kmXSM6pVPVgpTkUmRT-DjlkBamDs6wFc4iUlQqPJTxUXPFSM-nwshOGuZhS-snNzwJ5AzGAOJzyniFoFle6ABgsMCUg4E7ZFIMT2Fotz2JaNHdcROdUPhu1ZSVLEo_EHrUqnXAycQ6x8i3HZk70Rn_1T9Ksq0dqFPNlrkXOVdipQsnGekGwq_vh4OvdIOw3xAOb6d0YshG5zOFdYnhuykrkR_ptK1r-t9CD48Y-3mPR3MlUu-Sj9d1qQS316sY92Aaa9IXN5Oy-HSqUWd9GFsW79Ka-RKrwaop5WA2_yd8pQwJ_hpuUvOYuDLffF3tCzPFiMxxc5kdHUKDAOSz2lnYTXvmobN9ZJQt512pCiX9DL8t_0upfSGIWsF5DA9gPOCjmLtr2O828Dpv1g_Qq2ODXBvH1SB3NH3pPeN-J1tmpljkF5yjmyEJPO8gLhfCv-MZJsulHy81_mdBad5qjfwAsQ3BVeyJqSFZzBS0fBheyXMiDw8lTNdsxK4Dy-dLuNdi9JDzRyj5Ujnc24VbIQJknTCmUlHOvhahdrzEONwYeDi2hO6f718ppF4yktrhzN57ayLtI-XE5gMg-d_Qvmya6_F3YR27NFI5Lvpk3BaM0tU1_DSH0S9B-fnwpOn6pGJkly4gHf13gNKHfpjtFO8Rdl8QlCl8ixQBxtwpNspvr7K_0KI4pMN7NYUWRKZ_1d4B8xdiVbRce-w20sZVYKJHUp10e8JnOMr323iClqjr5gknp6ht7D4OHPeQh4Gf6qtHrPlXQtzNLzdrIUhPvPtMkJuOHrwEJCPxLjNU_2RZzhrBVqCBCPuI1MNZOyd40TZorkaGNc6oKiH1tUi7uQ9T0KKtV2rERBI9kRFAEMeThnhcsZPDQiU0twt2WNS6JoGQV57Ek9nR9uJ74LLmfoH9DA3YZdG7qJlNdk2zAds6WO2AaCTOi85ny-WUbpf9-UPj7ikrTQR8RRFsvEvRMZZdWCXKtEf2NjI34mYWKDCiDG57QhYEjbCXqlgzzpwfRiyNj7X0NPQuirg1Iezpxzhp5hsFQGS58NKgoTrnXfYf8CvnEOtH-TiZmoiHKOCO6yZMKdYYBggZ8yyX_HlS78K6aQztihFz85KpkMkI4rfEYQGOgO9PlaHXeOCV03EBGZPLHoVGRtZnPMPjuQEuKKIgxaIrRBk9FCmTVxyC4i70iB62v9-UPeH9oYKcPKEbJIGX_KDuTJOcn_nH2u08jsdSzCP-YPM5pZecZ7iip06WUxMxgDQ647RZpXK2xWHdkCF9zhHXlBwBCBOsU9v6YpHiXHQZifBt5ul7b8r9psKlQAOFqMmNt8UbFP43AFOo98-56eFcng6lU54sak8kD7JE_MMLWf4eWSc8bKgtHNhhvnYXcL0uyBOZ6ph_dpP5fzvmu9nZ7eT-7tEvAVfOqiBYfjAc_0M_PJvNhHb0KZGzi5Y8Ya5ZjLzBGTsQ40sfkXRN_j7rZ6mTD30YYv9KepstIUf3B4iKH9kmh37U75xntvk1iNGODH2gs36KfZ8rky_BUYfYzasf4W-fARhhzgFlEz1GH0Z9Aa00r8-GXa65UccVpIIWDHhUTiQfWpmGyx_if1Vsl_ZBaq82GOCraVHuNYtYyDlvsRNKsOvxVkBv-MFFS_u0AZKsujmNX1kFN2dw0m2d5nalg7rroscROa8TBtSbduUJQIBO5UDle-fhhfm1PWHkITyJw35IgbLPQUrwmbmhXydwAxSIgS_UxHmDthpo58c35umXphp9QTrHbhxeQ_j_CMmZJAOsmPNH9wNLDMZjE9vmb3tI_4a2ngXpQoHOQnZ2cORk4LBlLVcM5eXSxG59irdijtpyqX-_NFfN9BeOAuVVXgqveF2ukJuY4PNDImLwd5m3PBld-M8Lw5eFAtkkbFvNh3AFiwbLutZ3NnUiPCUZfzjnyPORCIUx0Q4MtB9lUQTKw1RaOLJp6eTYuUCNbhHjM5soPCCTVsl1vKpHKfrK34d5icdVvUAkAQ9dEJoX1q-_MoU9Gm9AzVzxyMOmkHelWFrXAKOL3nohxiA7KOtlKM7SRF6hxqiDz28BxQHmuKMyoES550ImZbA6kzt9uhFFJM-Oe203HzV4sN2d0cdihiWAZofvVbPVRDzJ5UD9f9QoUYEPLXQrbLVxvsHynTppCL8vl06JdEH0ysvDomKVsu9ZHgsK3cTT88cJraV14EfToZSD7uf0WaP5I_V17UcdkCxOMKUFb2MfJopUkoyKBfTqNxztk6NhxGFlJ2imiz1ZCQxAQ6dNDv9P0pEJciQ4JehUV14tzIrnCWtMY47GL-1emUGb8qz7U5hclMaQt0OyX-RW7ZzahQLPZ8cgSxxFynRKKbSZ63NpXanCTjj5LQzDacfcEK3JN4dnxHNhbAQhqKEz39efDrwAJctGY4Se9rnsyflxRjtwkKtjPt8DGGlprWwHg_OPUcSfgxFRlol7ht_FJRvqLGTPjCflAOXkLW3GmZbtdms57aBISKXfrZp6AL9MmZfHT1thv5deJ5USAMk2VFcQDOU9Yh7GMtHmnF756iemR6cefzitF1oLs48Ai29HHXwvBmJzJ822WjFDlh384ka_kMtKwI6-UEAaf_m0CF4EjSDyw6sU6X8lTkNrWh9eaLQhqTC2llGNWSxRaZ2432W40OiivohBn3Vu6yv2SeaIshDXQjm89JakuUCJN_vAef-syo5dWplrOIcdVoH7d41bAMwDvB4YHBnmfSkPEU3P_tcXvILH-1fIfgf3IJ1rcK2rYdLhOJz6prjv308Go7Yd1LKT2fvoJzUiIHFORICIfc1VMLfo0nweghjW0fXVUOVKin6arE7lnVWF17IiZEBT4cxqRqNJiJa2Z3ZVUtl1CGCOy0gLIZ5UENaY2EjoR1vMEXhU8LQoyK8psKTNvC0lAo-Ba3i3Ef_ac5iyjZJKmClRxOBhhC1Za3HjnggclLRmhCouO5KEmEHTek_bC1NhixjnzyGHMbMb_05gflt82gCKyJjbz3Gto3hB0fOHqqXKDCpTtnG7xEeorT97WO09aQZKRmLFjsw9c1dyL6yJR1UulsDC8wJCgstJ3gp88yGOGe4C5b7JqmqcF0vYr_r2K8w9l2-9wdCr_4djbfunw23FmDQvLkXu08MYh7_BSqjJgnSMKn22OSnnR3yUF_kctevZq9i37fZaHgRd4Yi68CSSvOfqQ_5Iq2ynJqGZZmefUCH2qAr4h-irKPs-HqIKFmO2E1MVp-sCGT21tnU9elMJi-p6Glqo5dVZOJJ8PoLkB0uN04ERH_Q6hbNwQZBRABdBmLsBlpBCKDGihZ13SMOWQS9PZgX8etSPeBic8r_NC6EEVW_CGsoaKxGUNMOgI2KT2drQCV8KzK-ifMxdJu5r9WSPxDoHclJJIiH9wT9JCzmOXcpAE7NoqM7zm8OWH5-Sn1BO-I8698cvNZ9JzKfqz9H9Wniq6lmp84lQQfZCiaBHTYW5_D9nzNkTU8qTe_MfK8Undfe2baY4KtixwUVBWRXWWeolHYov5201siTaiL_vXqBxYAaqKL5ttuPk2AohWl7T2V4SDMwCUPFGFPC4m04mwxaxYrcwgAMcDSkCxji3unKv-tLgkTt8KDUqnRPKGwCg9Uard-tBiSZ_zafKCTcJEPuqgwXjtQcnKJzKsizgd0W5mjMX1Gdb9EOOGBh2t79G6recbsKBwggtziqCD-T71iwL9OftzdClX0EALhmvzyNYfvaq27B2Ax737u_8n9n-zWiPCLecrYDUmAlucepM-0p7Wrr2pVUsgyWfSjQYQ2RodTBppFmPpkEAWWexOkLl-QIsmHJQPKengZJm00dLYWq_sFe1c3e0s10Uuh5hQoyzsRh1HEIXmH0dpD3kt1wPDk5Hvziwla_uKi4Kfup-sZRBPsalgedw7aeLRpsOR7o1VAXTfwXzqOgrO23LPtLsQnzxOf9w9k9oitvIJ44sqCNFdMZ3EMKtPXZ2tlPxmJ9Ds7ra0Jxpio7roo-uvW5NySpPKzTVk2xJI5TrtHPFjHaMZOB6Q4IJ69H4yY-OOweZ2l3dJEIRJTlTKS8akEw_DrGDHmOfcaH3TsjEumomEgMfkNhGAWQKKsxWQo68L0ivvSGL2dyCjZOcN9d0FKaH2ZYoC6AAYwLvInNPb6rYWcbLbPJ-XEnJj2XVJXZffm0gNAjXja1zMtmuLq25J0K-RpAmbD4TIsEMx4PT8huBzeUSWDRyPsvKJXe_sqJpuXJ2UVkXUK7f9JVkSMGgkYnfUadVHE2YVTV9OzHsm8EIcmC2fym-RJEqJjwcETrWMVWpMABgskVWgNqR02PEILRC0uh4qtwhkGtRln9Po1gj5h3iXccNjRMawHm4ozSjoSF4GmMrIGojvhh9giKfU6brqcCcvkOHIJgwQBIz9DykJyH7KW8wvAZk8PVzKmxs00SPjnBl-AIwhXIeziJeAmFOYk7U1M-mHM_y_R2HdsJlv0Ri6Dxvz3_tbMVp1rwHTowoBXZCcdSBIZNAIWHdurCvZwDfjYTjy-XZPGUjuUeZkV1cJzJgrTOYAwoB4yOlWiXVuayCGixWxPMDUGwXk9EcnzhO8rXRMbEgoXqkzxDMGnSYIBNz57to2Ipv184uxhem4Hsst7mNWXl5hSW5SJn6MaYYZ7_n1psSQDokW3F9ZzOgGs8pkhOJhm0ppjxvyoYWxqoKtk4EBRG9cbxlC46ucYjqtYidGKPe4ljhIARpL85kwiEN6rulUMrCWlkIiWdL4u1bhkIdb6Or4bmlT2t5SGwU2YNBHAEvDQkiwC-1s3p4XIVfQjqYkjYxY98nA5sqgP7F62HZ_4731CRFp_pJwwfzc3jDlr6qmYryr2ROij94pycMD2Dh5yoRIaxm00Ozv-o_htfA5VMdXEoq8OWnsWfr4BZrl8A32bYxA-wrelPU9FcIh12S7c13gBCNNLzcuLANQghCmAltYOnOLemTvC7SM1Jx6W1wi-WjJyZGOH-fYV_EJ8qFtRcYwu8XY0yyPXe6eAVZ0kOrnEyY14AyXNytUk-m0q4h-RtZ-k8UDxwv_Q65c8tbI", + "proof": { + "signature": "eyJ4NWMiOlsiTUlJRGx6Q0NBbitnQXdJQkFnSUlRejNVYzBudVBYa3dEUVlKS29aSWh2Y05BUUVMQlFBd2JqRUxNQWtHQTFVRUJoTUNTVTR4Q3pBSkJnTlZCQWdNQWt0Qk1SSXdFQVlEVlFRSERBbENRVTVIUVV4UFVrVXhEVEFMQmdOVkJBb01CRWxKVkVJeEdqQVlCZ05WQkFzTUVVMVBVMGxRTFZSRlEwZ3RRMFZPVkVWU01STXdFUVlEVlFRRERBcE5UMU5KVUMxU1QwOVVNQjRYRFRJd01USXpNREEzTWpReU5sb1hEVEl6TVRJek1EQTNNalF5Tmxvd2RURUxNQWtHQTFVRUJoTUNTVTR4Q3pBSkJnTlZCQWdNQWt0Qk1SSXdFQVlEVlFRSERBbENRVTVIUVV4UFVrVXhEVEFMQmdOVkJBb01CRWxKVkVJeEdqQVlCZ05WQkFzTUVVMVBVMGxRTFZSRlEwZ3RRMFZPVkVWU01Sb3dHQVlEVlFRRERCRk5UMU5KVUMxTFJWSk9SVXd0VTBsSFRqQ0NBU0l3RFFZSktvWklodmNOQVFFQkJRQURnZ0VQQURDQ0FRb0NnZ0VCQUwwdW5CdGw0bjNZUXdhS0ROcU9Gd0l1eW4wajVTZ2FhM1NzM0NYbFVZVW5DdW9IRUpUakJEbEJpd2JTc2l1eUZtZ3ZBY2VvZG42R0cvc0ovVWZHWmNmSDBqQzluSnBXSVRHWWtHSFdXZGpCdHVyTWp3ZnJFd05KWlI1bFVwMUt4dC9HWUdWdGJYWjNFUTRld2ZLeXlKK1F4L2duTGNMMDdXTUpXUWNuUGg0bXpEOExBazllYjlINlE3aVRZcVhqSVpma3JjcHArdXZtak1rVi9LdFJlV0YrOHN6cjNqcFVFaXcwUHlJNnpabS9ITk9kTHU2TzdUd1hhanlRZUlEakJYdFJhclpEVVgzdXg4WTBWNmhpcDNCbDVMaXZ5a0VxWHhqcGRzbDlvV1ozcTBDOGFYdVVaYTFoamM5YnRLZlQ5M2VVcEJBUG5id0VkR21FNHlHbDNaVUNBd0VBQWFNeU1EQXdEd1lEVlIwVEFRSC9CQVV3QXdFQi96QWRCZ05WSFE0RUZnUVU0NWxuWHZRaUxPTDNFMFFHTno2VUlxMGpYdUl3RFFZSktvWklodmNOQVFFTEJRQURnZ0VCQUxMcFJHK0NNSE0xZWJzd2RnTkpDU1NWWUR6Yk1XOFdEbG1DdVJKZHdOc0hrOGV4TWROM3FJWndNZFJLR1hUZ3VPVGoyRVh3L2owZGVHYnRNUXg2MDFFQUkycm9QRkdrTEdjRnYyM08zTHNwUkhNNjdleE81OHpCZlQzemVUajZ1VkpiWTFNdUNjTDRmWVNNRlRDNXhFc0VEMHZsK0FHTWNSMnNxLzJzUC9NMzl1M0UxeGJjY3UrcUZmam1JakZGMTBsQlVBYjFVc3BuOUZxcm0yRGRremZsTHJBSFNybVRIYlNUQ1RNbURXMExJRmhlUXVHZlduNkNDOXdXK0xEZVd0T3B0VTNCRC82SklZSlZLelc3M0t3Q1lqVVg4dmNhYnorekVJUE40S3I1SlJTZDhVM08vcUJTbGpDRzF2d2JTUzk5UWhhcEt3SXlyN000ZktzZThHWT0iXSwieDV0I1MyNTYiOiIycFU1ejB2Vl94aVRfWUFZNk9YU1dJTndVRlhzbm1xdzd1RzJ5MmlmNnB3IiwiYWxnIjoiUlMyNTYifQ..pr2IgGX_HnusQoHAyt8W94vwaiUUL1ZmrrODvMi-lJVX220pPlQ4sQNIMJ9a1SwhpLZU0ZAbC2-7GbQZagJhUYEzH7cUr4VK0-VhUxqTBhjJeIs-mxXgnjuVm9fy9ufrSwih5KacJW8ud_lggKcHsn0f_873r5ruTTXeKAHdBxWBvEoFmGGNtdQs2XyUgK_UyFd39iBSLQ3o4iIEHs6zdYNpcn3u4ixBZVmOT1SSuR3hO4liPR0DmXXOSxS563IDkOZK1N_RLVneHqz-5q1iXd4PhEewobQ0vsCILB2ry-Y41p_xjYpErWuW4gn504nYe3EIQtBbYxFmQgg8TZExyA" + }, + "credentialType": "qrcode", + "protectionKey": "abc123" + } + } +} \ No newline at end of file diff --git a/src/test/resources/csshtml.html b/src/test/resources/csshtml.html new file mode 100644 index 00000000..44ff82f6 --- /dev/null +++ b/src/test/resources/csshtml.html @@ -0,0 +1,26 @@ + + + Colossal (movie) + + + + +

Colossal (2016)

+
Directed by Nacho Vigalondo
+
Gloria is an out-of-work party girl + forced to leave her life in New York City, and move back home. + When reports surface that a giant creature is destroying Seoul, + she gradually comes to the realization that she is somehow connected + to this phenomenon. +
+
Read more about this movie on + IMDB +
+ + \ No newline at end of file diff --git a/src/test/resources/emptyFile.html b/src/test/resources/emptyFile.html new file mode 100644 index 00000000..e69de29b diff --git a/src/test/resources/printTextFileJson.json b/src/test/resources/printTextFileJson.json new file mode 100644 index 00000000..2bf80de0 --- /dev/null +++ b/src/test/resources/printTextFileJson.json @@ -0,0 +1,9 @@ +{ + "name": "fullName,LastName", + "address": "addressLine1,addressLine2,addressLine3", + "region": "region", + "province": "province", + "city": "city", + "postalCode": "postalCode", + "phoneNumber": "phone" +} \ No newline at end of file