From 324cb16a748749dd2db5dadc2d2de048f13ee7d1 Mon Sep 17 00:00:00 2001 From: Benjamin Cavy Date: Mon, 1 Jul 2024 10:16:41 +0200 Subject: [PATCH] feat: export/import --- app/fr/maif/izanami/application.scala | 1 + .../datastores/ImportExportDatastore.scala | 450 +++++++++++++ app/fr/maif/izanami/env/env.scala | 1 + app/fr/maif/izanami/errors/Errors.scala | 32 +- app/fr/maif/izanami/models/ExportType.scala | 119 ++++ app/fr/maif/izanami/utils/helpers.scala | 38 ++ .../maif/izanami/web/ExportController.scala | 111 ++++ .../maif/izanami/web/ImportController.scala | 565 ++++++++-------- .../maif/izanami/web/SearchController.scala | 4 +- conf/routes | 5 +- datasets/with-users.ndjson | 20 + datasets/without-users.ndjson | 18 + izanami-frontend/index.html | 20 +- izanami-frontend/init.js | 44 -- izanami-frontend/package-lock.json | 27 +- izanami-frontend/package.json | 3 +- izanami-frontend/playwright.config.ts | 6 +- izanami-frontend/src/App.tsx | 6 +- .../src/components/FeatureTable.tsx | 4 +- .../src/components/ObjectInput.tsx | 104 +++ izanami-frontend/src/pages/tenantSettings.tsx | 605 ++++++++++++++++-- izanami-frontend/src/pages/webhooks.tsx | 82 +-- izanami-frontend/src/utils/queries.tsx | 47 +- izanami-frontend/src/utils/types.ts | 15 + izanami-frontend/tests/features.spec.ts | 17 +- izanami-frontend/tests/import-export.spec.ts | 95 +++ izanami-frontend/tests/izanami-test.ts | 2 +- .../tests/screenshots/export-import-v2.ts | 69 ++ .../tests/screenshots/import-v1.ts | 7 +- izanami-frontend/tests/testBuilder.ts | 373 ++++++++--- izanami-frontend/tests/webhooks.spec.ts | 19 +- .../default/generated.js | 10 +- manual/.docusaurus/client-modules.js | 8 +- .../version-current-metadata-prop-751.json | 13 + .../docusaurus-debug-all-content-673.json | 38 +- manual/.docusaurus/globalData.json | 5 + manual/.docusaurus/registry.js | 169 ++--- manual/.docusaurus/routes.js | 53 +- manual/.docusaurus/routesChunkNames.json | 357 ++++++----- manual/.docusaurus/site-metadata.json | 4 +- manual/docs/04-guides/14-transfer-data.mdx | 61 ++ manual/docs/04-guides/index.mdx | 1 + .../export-import-v2/export-button-hover.png | Bin 0 -> 93729 bytes .../export-import-v2/export-form.png | Bin 0 -> 82594 bytes .../export-import-v2/import-button-hover.png | Bin 0 -> 98354 bytes .../export-import-v2/import-form.png | Bin 0 -> 85750 bytes .../export-import-v2/imported-project.png | Bin 0 -> 57817 bytes public/swagger.json | 29 +- test/fr/maif/izanami/api/BaseAPISpec.scala | 6 +- 49 files changed, 2843 insertions(+), 820 deletions(-) create mode 100644 app/fr/maif/izanami/datastores/ImportExportDatastore.scala create mode 100644 app/fr/maif/izanami/models/ExportType.scala create mode 100644 app/fr/maif/izanami/utils/helpers.scala create mode 100644 app/fr/maif/izanami/web/ExportController.scala create mode 100644 datasets/with-users.ndjson create mode 100644 datasets/without-users.ndjson delete mode 100644 izanami-frontend/init.js create mode 100644 izanami-frontend/src/components/ObjectInput.tsx create mode 100644 izanami-frontend/tests/import-export.spec.ts create mode 100644 izanami-frontend/tests/screenshots/export-import-v2.ts create mode 100644 manual/docs/04-guides/14-transfer-data.mdx create mode 100644 manual/static/img/screenshots/export-import-v2/export-button-hover.png create mode 100644 manual/static/img/screenshots/export-import-v2/export-form.png create mode 100644 manual/static/img/screenshots/export-import-v2/import-button-hover.png create mode 100644 manual/static/img/screenshots/export-import-v2/import-form.png create mode 100644 manual/static/img/screenshots/export-import-v2/imported-project.png diff --git a/app/fr/maif/izanami/application.scala b/app/fr/maif/izanami/application.scala index a45a88fab..13a0b521a 100644 --- a/app/fr/maif/izanami/application.scala +++ b/app/fr/maif/izanami/application.scala @@ -90,6 +90,7 @@ class IzanamiComponentsInstances( lazy val eventController = wire[EventController] lazy val webhookController = wire[WebhookController] lazy val frontendController = wire[FrontendController] + lazy val exportController = wire[ExportController] lazy val searchController = wire[SearchController] override lazy val assets: Assets = wire[Assets] diff --git a/app/fr/maif/izanami/datastores/ImportExportDatastore.scala b/app/fr/maif/izanami/datastores/ImportExportDatastore.scala new file mode 100644 index 000000000..5bc60ae33 --- /dev/null +++ b/app/fr/maif/izanami/datastores/ImportExportDatastore.scala @@ -0,0 +1,450 @@ +package fr.maif.izanami.datastores + +import fr.maif.izanami.datastores.ImportExportDatastore.TableMetadata +import fr.maif.izanami.env.Env +import fr.maif.izanami.env.pgimplicits.EnhancedRow +import fr.maif.izanami.errors.{InternalServerError, IzanamiError, PartialImportFailure} +import fr.maif.izanami.models.{ExportedType, KeyRightType, ProjectRightType, WebhookRightType} +import fr.maif.izanami.models.ExportedType.exportedTypeToString +import fr.maif.izanami.utils.Datastore +import fr.maif.izanami.utils.syntax.implicits.BetterJsValue +import fr.maif.izanami.web.ExportController.TenantExportRequest +import fr.maif.izanami.web.ImportController.ImportConflictStrategy +import fr.maif.izanami.web.{ExportController, ImportController} +import io.vertx.core.json.JsonArray +import io.vertx.sqlclient.SqlConnection +import play.api.libs.json.{JsObject, Json} + +import java.util.concurrent.atomic.AtomicInteger +import scala.concurrent.Future + +class ImportExportDatastore(val env: Env) extends Datastore { + + private def tableMetadata(tenant: String, table: String): Future[Option[TableMetadata]] = { + env.postgresql.queryOne( + s""" + |SELECT ccu.constraint_name as pk_constraint, array_agg(distinct cs.column_name) as table_columns + |FROM pg_constraint co, information_schema.constraint_column_usage ccu, pg_namespace n, information_schema.columns cs + |WHERE co.contype='p' + |AND ccu.constraint_name=co.conname + |AND ccu.table_name=$$2 + |AND ccu.table_schema=$$1 + |AND co.connamespace=n.oid + |AND n.nspname=$$1 + |AND cs.table_schema=$$1 + |AND cs.table_name=$$2 + |AND cs.is_generated='NEVER' + |GROUP BY ccu.constraint_name + """.stripMargin, + List(tenant, table) + ) { r => + for ( + constraint <- r.optString("pk_constraint"); + columns <- r.optStringArray("table_columns") + ) yield TableMetadata(table = table, primaryKeyConstraint = constraint, tableColumns = columns.toSet) + } + } + + def importTenantData( + tenant: String, + entries: Map[ExportedType, Seq[JsObject]], + conflictStrategy: ImportConflictStrategy + ): Future[Either[IzanamiError, Unit]] = { + + Future + .sequence( + entries.toSeq + .sortBy { case (t, _) => + t.order + } + .map(t => tableMetadata(tenant, t._1.table).map(maybeMetdata => (maybeMetdata, t._2, t._1))) + ) + .flatMap(s => { + if (s.exists(_._1.isEmpty)) { + // TODO precise table in error + Future.successful(Left(InternalServerError(s"Failed to fetch metadata for one table"))) + } else { + env.postgresql.executeInTransaction(conn => { + s + .collect { case (Some(metadata), jsons, exportedType) => (metadata, jsons, exportedType) } + .foldLeft(Future.successful(Right(())): Future[Either[Map[ExportedType, Seq[JsObject]], Unit]])( + (agg, t) => { + agg.flatMap(previousResult => { + val f = conflictStrategy match { + case ImportController.MergeOverwrite => importTenantDataWithMergeOnConflict(tenant, t._1, t._2) + case ImportController.Skip => importTenantDataWithSkipOnConflict(tenant, t._1, t._2) + case ImportController.Fail if previousResult.isRight => + importTenantDataWithFailOnConflict(tenant, t._1, t._2, conn) + case _ => Future.successful(Right(())) + } + + f + .flatMap(e => { + updateUserTenantRightIfNeeded( + tenant, + entries, + if (conflictStrategy == ImportController.Fail) Some(conn) else None + ) + .map(_ => e) + }) + .map(either => + either.left.map(jsons => + jsons.map(json => Json.obj("row" -> json, "_type" -> exportedTypeToString(t._3))) + ) + ) + .map(either => + (either, previousResult) match { + case (Left(err), Left(errs)) => { + Left(errs + (t._3 -> err)) + } + case (Left(err), Right(_)) => Left(Map(t._3 -> err)) + case (Right(_), Right(_)) => Right(()) + case (Right(_), Left(errs)) => Left(errs) + } + ) + }) + } + ) + .map(either => either.left.map(failedElements => PartialImportFailure(failedElements))) + }) + } + }) + } + + def importTenantDataWithMergeOnConflict( + tenant: String, + metadata: TableMetadata, + rows: Seq[JsObject] + ): Future[Either[Seq[JsObject], Unit]] = { + + val vertxJsonArray = new JsonArray(Json.toJson(rows).toString()) + val cols = metadata.tableColumns.mkString(",") + + env.postgresql + .queryOne( + s""" + |INSERT INTO ${metadata.table} (${cols}) select ${cols} from json_populate_recordset(null::${metadata.table}, $$1) + |ON CONFLICT ON CONSTRAINT ${metadata.primaryKeyConstraint} DO UPDATE SET($cols)=(select $cols from json_populate_recordset(NULL::${metadata.table}, $$1)) + |""".stripMargin, + List(vertxJsonArray), + schemas = Set(tenant) + ) { _ => Some(()) } + .map(_ => Right(())) + .recoverWith { + case _ => { + logger.info(s"There has been import errors, switching to unit import mode for ${metadata.table}") + rows.foldLeft(Future.successful(Right(())): Future[Either[Seq[JsObject], Unit]])((facc, row) => { + facc.flatMap(acc => + env.postgresql + .queryOne( + s""" + |INSERT INTO ${metadata.table} (${cols}) select ${cols} from json_populate_record(null::${metadata.table}, $$1) + |ON CONFLICT ON CONSTRAINT ${metadata.primaryKeyConstraint} DO UPDATE SET($cols)=((select $cols from json_populate_record(NULL::${metadata.table}, $$1))) + |""".stripMargin, + List(row.vertxJsValue), + schemas = Set(tenant) + ) { _ => Some(()) } + .map(_ => Right(())) + .recoverWith { + case _ => { + logger.info(s"Import of following row failed for table ${metadata.table} : ${row}") + Future.successful(Left(row)) + } + } + .map(either => { + (either, acc) match { + case (Left(failedRow), Left(failedRows)) => Left(failedRows.appended(failedRow)) + case (Right(_), Right(_)) => Right(()) + case (Left(failedRow), Right(_)) => Left(Seq(failedRow)) + case (Right(_), Left(failedRows)) => Left(failedRows) + } + }) + ) + }) + } + } + } + + def importTenantDataWithFailOnConflict( + tenant: String, + metadata: TableMetadata, + rows: Seq[JsObject], + conn: SqlConnection + ): Future[Either[Seq[JsObject], Unit]] = { + val vertxJsonArray = new JsonArray(Json.toJson(rows).toString()) + val cols = metadata.tableColumns.mkString(",") + env.postgresql + .queryOne( + s""" + |INSERT INTO ${metadata.table} (${cols}) select ${cols} from json_populate_recordset(null::${metadata.table}, $$1) + |""".stripMargin, + List(vertxJsonArray), + schemas = Set(tenant), + conn = Some(conn) + ) { _ => Some(()) } + .map(_ => Right(())) + .recoverWith { + case _ => { + logger.info( + s"There has been import errors, since strategy is to fail on conflict, all elements will be attempted" + ) + rows.foldLeft(Future.successful(Right(())): Future[Either[Seq[JsObject], Unit]])((facc, row) => { + facc.flatMap { + case Left(failedRow) => Future.successful((Left(failedRow))) + case Right(_) => { + env.postgresql + .queryOne( + s""" + |INSERT INTO ${metadata.table} (${cols}) select ${cols} from json_populate_record(null::${metadata.table}, $$1) + |""".stripMargin, + List(row.vertxJsValue), + schemas = Set(tenant), + conn = Some(conn) + ) { _ => Some(()) } + .map(_ => Right(())) + .recoverWith { + case _ => { + logger.info(s"Import of following row failed for table ${metadata.table} : ${row}") + Future.successful(Left(Seq(row))) + } + } + } + } + }) + } + } + } + + def importTenantDataWithSkipOnConflict( + tenant: String, + metadata: TableMetadata, + rows: Seq[JsObject] + ): Future[Either[Seq[JsObject], Unit]] = { + val vertxJsonArray = new JsonArray(Json.toJson(rows).toString()) + val cols = metadata.tableColumns.mkString(",") + env.postgresql + .queryOne( + s""" + |INSERT INTO ${metadata.table} (${cols}) select ${cols} from json_populate_recordset(null::${metadata.table}, $$1) + |ON CONFLICT ON CONSTRAINT ${metadata.primaryKeyConstraint} DO NOTHING + |""".stripMargin, + List(vertxJsonArray), + schemas = Set(tenant) + ) { _ => Some(()) } + .map(_ => Right(())) + .recoverWith { + case _ => { + logger.info(s"There has been import errors, switching to unit import mode for ${metadata.table}") + rows.foldLeft(Future.successful(Right(())): Future[Either[Seq[JsObject], Unit]])((facc, row) => { + facc.flatMap(acc => + env.postgresql + .queryOne( + s""" + |INSERT INTO ${metadata.table} (${cols}) select ${cols} from json_populate_record(null::${metadata.table}, $$1) + |ON CONFLICT ON CONSTRAINT ${metadata.primaryKeyConstraint} DO NOTHING + |""".stripMargin, + List(row.vertxJsValue), + schemas = Set(tenant) + ) { _ => Some(()) } + .map(_ => Right(())) + .recoverWith { + case _ => { + logger.info(s"Import of following row failed for table ${metadata.table} : ${row}") + Future.successful(Left(row)) + } + } + .map(either => { + (either, acc) match { + case (Left(failedRow), Left(failedRows)) => Left(failedRows.appended(failedRow)) + case (Right(_), Right(_)) => Right(()) + case (Left(failedRow), Right(_)) => Left(Seq(failedRow)) + case (Right(_), Left(failedRows)) => Left(failedRows) + } + }) + ) + }) + } + } + } + + def exportTenantData( + tenant: String, + request: TenantExportRequest + ): Future[List[JsObject]] = { + val paramIndex = new AtomicInteger(1) + val projectFilter = request.projects match { + case ExportController.ExportItemList(projects) => Some(projects) + case _ => None + } + + val keyFilter = request.keys match { + case ExportController.ExportItemList(keys) => Some(keys) + case _ => None + } + + val webhookFilter = request.webhooks match { + case ExportController.ExportItemList(webhooks) => Some(webhooks) + case _ => None + } + + env.postgresql.queryAll( + s""" + |WITH project_results AS ( + | SELECT DISTINCT p.name as pname, p.id, (jsonb_build_object('_type', 'project', 'row', to_jsonb(p.*)::jsonb)) as result + | FROM projects p + | ${projectFilter.map(_ => s"WHERE p.name=ANY($$${paramIndex.getAndIncrement()})").getOrElse("")} + |), feature_results AS ( + | SELECT DISTINCT f.script_config, f.id as fid, f.name as fname, jsonb_build_object('_type', 'feature' , 'row', to_jsonb(f.*)) as result + | FROM project_results, features f + | WHERE f.project=project_results.pname + |), tag_results AS ( + | SELECT DISTINCT jsonb_build_object('_type', 'tag', 'row', row_to_json(t.*)::jsonb) as result + | FROM tags t ${projectFilter + .map(_ => """ + |, features_tags ft, feature_results + | WHERE ft.feature=feature_results.fid + | AND t.name=ft.tag""".stripMargin) + .getOrElse("")} + |), features_tags_results AS ( + | SELECT DISTINCT jsonb_build_object('_type', 'feature_tag', 'row', to_jsonb(ft.*)) as result + | FROM features_tags ft, feature_results + | WHERE ft.feature=feature_results.fid + |), overload_results AS ( + | SELECT DISTINCT fcs.project, fcs.local_context, fcs.global_context, jsonb_build_object('_type', 'overload', 'row', to_jsonb(fcs.*) - 'context' - 'context_path') as result + | FROM feature_contexts_strategies fcs, feature_results f, project_results p + | WHERE fcs.feature=f.fname + | AND fcs.project=p.pname + |), local_context_results AS ( + | SELECT DISTINCT jsonb_build_object('_type', 'local_context', 'row', to_jsonb(fc.*)) as result + | FROM feature_contexts fc${projectFilter + .map(_ => """ + | , overload_results ors + | WHERE fc.id = ors.local_context + | AND fc.project = ors.project""".stripMargin) + .getOrElse("")} + |), global_context_results AS ( + | SELECT DISTINCT jsonb_build_object('_type', 'global_context', 'row', to_jsonb(fc.*)) as result + | FROM global_feature_contexts fc${projectFilter + .map(_ => """ + | , overload_results ors + | WHERE fc.id = ors.global_context + |""".stripMargin) + .getOrElse("")} + |), key_results AS ( + | SELECT DISTINCT k.name, jsonb_build_object('_type', 'key', 'row', to_jsonb(k.*)) as result + | FROM apikeys k + | ${keyFilter.map(_ => s"WHERE k.name=ANY($$${paramIndex.getAndIncrement()})").getOrElse("")} + |), apikeys_projects_result AS ( + | SELECT DISTINCT jsonb_build_object('_type', 'apikey_project', 'row', to_jsonb(ap.*)) as result + | FROM apikeys_projects ap, key_results kr + | WHERE ap.apikey=kr.name + |), webhook_results AS ( + | SELECT DISTINCT w.id, w.name, jsonb_build_object('_type', 'webhook', 'row', to_jsonb(w.*)) as result + | FROM webhooks w + | ${webhookFilter.map(_ => s"WHERE w.name=ANY($$${paramIndex.getAndIncrement()})").getOrElse("")} + |), webhooks_features_result AS ( + | SELECT DISTINCT jsonb_build_object('_type', 'webhook_feature', 'row', to_jsonb(wf.*)) as result + | FROM webhooks_features wf, webhook_results w, feature_results + | WHERE wf.webhook=w.id + |), webhooks_projects_result AS ( + | SELECT DISTINCT jsonb_build_object('_type', 'webhook_project', 'row', to_jsonb(wp.*)) as result + | FROM webhooks_projects wp, webhook_results w, project_results + | WHERE wp.webhook=w.id + |), script_results AS ( + | SELECT DISTINCT jsonb_build_object('_type', 'script', 'row', to_jsonb(wsc.*)) as result + | FROM wasm_script_configurations wsc, feature_results fr + | WHERE wsc.id = fr.script_config + |)${if (request.userRights) """, users_webhooks_rights_result AS ( + | SELECT DISTINCT jsonb_build_object('_type', 'user_webhook_right', 'row', to_jsonb(uwr.*)) as result + | FROM users_webhooks_rights uwr, webhook_results + | WHERE uwr.webhook=webhook_results.name + |), project_rights AS ( + | SELECT DISTINCT jsonb_build_object('_type', 'project_right', 'row', to_jsonb(upr.*)) as result + | FROM users_projects_rights upr, project_results pr + | WHERE upr.project = pr.pname + |), key_rights AS ( + | SELECT DISTINCT jsonb_build_object('_type', 'key_right', 'row', to_jsonb(ukr.*)) as result + | FROM users_keys_rights ukr, key_results kr + | WHERE ukr.apikey=kr.name + |)""" else ""} + |SELECT result FROM tag_results + |UNION ALL + |SELECT result FROM project_results + |UNION ALL + |SELECT result FROM feature_results + |UNION ALL + |SELECT result FROM global_context_results + |UNION ALL + |SELECT result FROM local_context_results + |UNION ALL + |SELECT result FROM overload_results + |UNION ALL + |SELECT result FROM key_results + |UNION ALL + |SELECT result FROM features_tags_results + |UNION ALL + |SELECT result FROM apikeys_projects_result + |UNION ALL + |SELECT result FROM webhook_results + |UNION ALL + |SELECT result FROM webhooks_projects_result + |UNION ALL + |SELECT result FROM webhooks_features_result + |UNION ALL + |SELECT result FROM script_results + |${if (request.userRights) s"""UNION ALL + |SELECT result FROM users_webhooks_rights_result + |UNION ALL + |SELECT result FROM project_rights + |UNION ALL + |SELECT result FROM key_rights""" else ""} + |""".stripMargin, + List(projectFilter, keyFilter, webhookFilter).flatMap(_.toList).map(s => s.toArray), + schemas = Set(tenant) + ) { r => + { + r.optJsObject("result") + } + } + } + + def updateUserTenantRightIfNeeded( + tenant: String, + importedData: Map[ExportedType, Seq[JsObject]], + maybeConn: Option[SqlConnection] + ): Future[Unit] = { + val usernames = importedData + .collect { + case (WebhookRightType | ProjectRightType | KeyRightType, jsons) => { + jsons.map(json => (json \ "username").asOpt[String]) + } + } + .flatten + .collect { case Some(username) => + username + } + if (usernames.isEmpty) { + Future.successful(()) + } else { + env.postgresql + .queryRaw( + s""" + |INSERT INTO izanami.users_tenants_rights (username, tenant, level) VALUES(unnest($$1::text[]), $$2, 'READ') + |ON CONFLICT (username, tenant) DO NOTHING + |""".stripMargin, + List(usernames.toArray, tenant), + conn = maybeConn + ) { _ => Some(()) } + .map(_ => ()) + .recoverWith(ex => { + // User right on tenant may fail if user does not exist + Future.successful(()) + }) + } + } + +} + +object ImportExportDatastore { + case class TableMetadata(table: String, primaryKeyConstraint: String, tableColumns: Set[String]) +} diff --git a/app/fr/maif/izanami/env/env.scala b/app/fr/maif/izanami/env/env.scala index 892ddae2a..e85f3a53a 100644 --- a/app/fr/maif/izanami/env/env.scala +++ b/app/fr/maif/izanami/env/env.scala @@ -33,6 +33,7 @@ class Datastores(env: Env) { val configuration: ConfigurationDatastore = new ConfigurationDatastore(env) val webhook: WebhooksDatastore = new WebhooksDatastore(env) val stats: StatsDatastore = new StatsDatastore(env) + val exportDatastore: ImportExportDatastore = new ImportExportDatastore(env) val search : SearchDatastore = new SearchDatastore(env) def onStart(): Future[Unit] = { diff --git a/app/fr/maif/izanami/errors/Errors.scala b/app/fr/maif/izanami/errors/Errors.scala index d65ea347e..a66125092 100644 --- a/app/fr/maif/izanami/errors/Errors.scala +++ b/app/fr/maif/izanami/errors/Errors.scala @@ -1,7 +1,8 @@ package fr.maif.izanami.errors +import fr.maif.izanami.models.ExportedType import play.api.http.Status.{BAD_REQUEST, FORBIDDEN, INTERNAL_SERVER_ERROR, NOT_FOUND, UNAUTHORIZED} -import play.api.libs.json.{Json, Writes} +import play.api.libs.json.{JsObject, Json, Writes} import play.api.mvc.{Result, Results} import java.util.Objects @@ -39,7 +40,7 @@ case class MissingFeatureFields() extends IzanamiError(message = "Some fields are missing for feature object", status = BAD_REQUEST) case class FeatureNotFound(id: String) extends IzanamiError(message = s"Feature ${id} does not exists", status = NOT_FOUND) -case class KeyNotFound(name: String) extends IzanamiError(message = s"Key ${name} does not exists", status = NOT_FOUND) +case class KeyNotFound(name: String) extends IzanamiError(message = s"Key ${name} does not exists", status = NOT_FOUND) case class ProjectContextOrFeatureDoesNotExist(project: String, context: String, feature: String) extends IzanamiError( message = s"Project ${project}, context ${context} or feature ${feature} does not exist", @@ -124,9 +125,30 @@ case class WebhookCreationFailed( case class WebhookDoesNotExists(id: String) extends IzanamiError(message = s"No webhook with id $id", status = NOT_FOUND) -case class WebhookCallError(callStatus: Int, body: Option[String], hookName: String) extends IzanamiError(message = s"Webhook $hookName call failed with status $callStatus and response body ${body.getOrElse("No body")}", status = callStatus) -case class EventNotFound(tenant: String, event: Long) extends IzanamiError(message = s"Event $event not found", status = 500) -case class WebhookRetryCountExceeded() extends IzanamiError(message = s"Exceeded webhook retry count", status = 500) +case class WebhookCallError(callStatus: Int, body: Option[String], hookName: String) + extends IzanamiError( + message = s"Webhook $hookName call failed with status $callStatus and response body ${body.getOrElse("No body")}", + status = callStatus + ) +case class EventNotFound(tenant: String, event: Long) + extends IzanamiError(message = s"Event $event not found", status = 500) +case class WebhookRetryCountExceeded() extends IzanamiError(message = s"Exceeded webhook retry count", status = 500) +case class TableDoesNotExist(tenant: String, table: String) + extends IzanamiError(message = s"Table $table does not exist for tenant $tenant", status = 500) +case class ConflictingName(tenant: String, entityTpe: String, row: JsObject) + extends IzanamiError( + message = + s"An entity of type $entityTpe already exists in tenant $tenant with the same unique values but with different id. Row is ${row + .toString()}", + status = 400 + ) +case class GenericBadRequest(override val message: String) extends IzanamiError(message = message, status = 400) +case class PartialImportFailure(failedElements: Map[ExportedType, Seq[JsObject]]) extends IzanamiError(message= s"Some element couldn't be imported", status = 400) +case class ImportError(table: String, json: String, errorMessage: String) + extends IzanamiError( + message = s"Error key while inserting into table $table with error $errorMessage values $json : ", + status = 400 + ) object IzanamiError { implicit val errorWrite: Writes[IzanamiError] = { err => Json.obj( diff --git a/app/fr/maif/izanami/models/ExportType.scala b/app/fr/maif/izanami/models/ExportType.scala new file mode 100644 index 000000000..b60c09585 --- /dev/null +++ b/app/fr/maif/izanami/models/ExportType.scala @@ -0,0 +1,119 @@ +package fr.maif.izanami.models + +sealed trait ExportedType { + def order: Int + def table: String + def displayName: String +} +case object ScriptType extends ExportedType { + override def order: Int = 0 + override def table: String = "wasm_script_configurations" + override def displayName: String = "WASM Script" +} +case object ProjectType extends ExportedType { + override def order: Int = 1 + override def table: String = "projects" + override def displayName: String = "Project" +} +case object KeyType extends ExportedType { + override def order: Int = 2 + override def table: String = "apikeys" + override def displayName: String = "Key" +} +case object KeyProjectType extends ExportedType { + override def order: Int = 3 + override def table: String = "apikeys_projects" + override def displayName: String = "Key right on project" +} +case object GlobalContextType extends ExportedType { + override def order: Int = 4 + override def table: String = "global_feature_contexts" + override def displayName: String = "Global context" +} +case object LocalContextType extends ExportedType { + override def order: Int = 5 + override def table: String = "feature_contexts" + override def displayName: String = "Local context" +} +case object WebhookType extends ExportedType { + override def order: Int = 6 + override def table: String = "webhooks" + override def displayName: String = "Webhook" +} +case object TagType extends ExportedType { + override def order: Int = 7 + override def table: String = "tags" + override def displayName: String = "Tag" +} +case object FeatureType extends ExportedType { + override def order: Int = 8 + override def table: String = "features" + override def displayName: String = "Feature" +} +case object FeatureTagType extends ExportedType { + override def order: Int = 9 + override def table: String = "features_tags" + override def displayName: String = "Feature tags link" +} +case object OverloadType extends ExportedType { + override def order: Int = 10 + override def table: String = "feature_contexts_strategies" + override def displayName: String = "Feature overload" +} +case object ProjectRightType extends ExportedType { + override def order: Int = 11 + override def table: String = "users_projects_rights" + override def displayName: String = "User right on project" +} +case object KeyRightType extends ExportedType { + override def order: Int = 12 + + override def table: String = "users_keys_rights" + override def displayName: String = "User right on key" +} +case object WebhookRightType extends ExportedType { + override def order: Int = 13 + + override def table: String = "users_webhooks_rights" + override def displayName: String = "User right on webhook" +} +case object WebhookFeatureType extends ExportedType { + override def order: Int = 14 + + override def table: String = "webhooks_features" + override def displayName: String = "Webhook feature link" +} +case object WebhookProjectType extends ExportedType { + override def order: Int = 15 + override def table: String = "webhooks_projects" + override def displayName: String = "Webhook project link" +} + +object ExportedType { + val exportedTypeToExportedNameAssociation: Seq[(String, ExportedType)] = Seq( + ("project", ProjectType), + ("feature", FeatureType), + ("tag", TagType), + ("feature_tag", FeatureTagType), + ("overload", OverloadType), + ("local_context", LocalContextType), + ("global_context", GlobalContextType), + ("key", KeyType), + ("apikey_project", KeyProjectType), + ("webhook", WebhookType), + ("webhook_feature", WebhookFeatureType), + ("webhook_project", WebhookProjectType), + ("user_webhook_right", WebhookRightType), + ("project_right", ProjectRightType), + ("key_right", KeyRightType), + ("script", ScriptType) + ) + + def parseExportedType(typestr: String): Option[ExportedType] = { + exportedTypeToExportedNameAssociation.find(t => t._1 == typestr).map(t => t._2) + } + + def exportedTypeToString(exportedType: ExportedType): Option[String] = { + exportedTypeToExportedNameAssociation.find(t => t._2 == exportedType).map(t => t._1) + } +} diff --git a/app/fr/maif/izanami/utils/helpers.scala b/app/fr/maif/izanami/utils/helpers.scala new file mode 100644 index 000000000..c2678a64b --- /dev/null +++ b/app/fr/maif/izanami/utils/helpers.scala @@ -0,0 +1,38 @@ +package fr.maif.izanami.utils + +import scala.concurrent.{ExecutionContext, Future} + +object Helpers { + def sequence[A, B](seq: Seq[Either[A, B]]): Either[A, Seq[B]] = seq.foldRight(Right(Nil): Either[A, List[B]]) { + (e, acc) => for (xs <- acc; x <- e) yield x :: xs + } + + def sequence[A, B, C](seq: Seq[Either[A, B]], init: => C, acc: (C, A) => C): Either[C, Seq[B]] = + seq.foldRight(Right(Nil): Either[C, List[B]]) { + case (Left(err), Left(errAcc)) => Left(acc(errAcc, err)) + case (Left(err), Right(_)) => Left(acc(init, err)) + case (Right(v), Right(vs)) => Right(v :: vs) + case (Right(_), Left(errAcc)) => Left(errAcc) + } + + def chainFutures[E, R]( + futures: Seq[Future[Either[E, R]]] + )(implicit ec: ExecutionContext): Future[Either[Seq[E], Seq[R]]] = { + def act(fs: Seq[Future[Either[E, R]]], res: Either[Seq[E], Seq[R]]): Future[Either[Seq[E], Seq[R]]] = { + fs.headOption + .map(f => { + f.map(e => + (res, e) match { + case (Left(errs), Left(err)) => Left(errs.appended(err)) + case (_, Left(err)) => Left(Seq(err)) + case (Left(errs), _) => Left(errs) + case (Right(rs), Right(r)) => Right(rs.appended(r)) + } + ).flatMap(e => act(fs.tail, e)) + }) + .getOrElse(Future.successful(res)) + } + + act(futures, Right(Seq())) + } +} diff --git a/app/fr/maif/izanami/web/ExportController.scala b/app/fr/maif/izanami/web/ExportController.scala new file mode 100644 index 000000000..a09ce0979 --- /dev/null +++ b/app/fr/maif/izanami/web/ExportController.scala @@ -0,0 +1,111 @@ +package fr.maif.izanami.web + +import akka.util.ByteString +import fr.maif.izanami.env.Env +import fr.maif.izanami.models.Feature.lightweightFeatureWrite +import fr.maif.izanami.models.{LightWeightFeature, RightLevels} +import play.api.http.HttpEntity +import play.api.libs.json._ +import play.api.mvc._ + +import scala.concurrent.{ExecutionContext, Future} + +class ExportController( + val env: Env, + val controllerComponents: ControllerComponents, + val authAction: TenantAuthActionFactory +) extends BaseController { + implicit val ec: ExecutionContext = env.executionContext + + def exportTenantData(tenant: String): Action[JsValue] = authAction(tenant, RightLevels.Admin).async(parse.json) { + implicit request => + { + ExportController.tenantExportRequestReads + .reads(request.body) + .asEither + .map(req => { + env.datastores.exportDatastore.exportTenantData(tenant, req) + }) + .fold( + _ => Future.successful(BadRequest(Json.obj("message" -> "Bad body format"))), + futureResult => + futureResult.map(jsons => { + Result( + header = + ResponseHeader(200, Map("Content-Disposition" -> "attachment", "filename" -> "export.ndjson")), + body = HttpEntity.Streamed( + akka.stream.scaladsl.Source.single(ByteString(jsons.mkString("\n"), "UTF-8")), + None, + Some("application/x-ndjson") + ) + ) + }) + ) + } + } +} + +object ExportController { + val exportRequestReads: Reads[ExportRequest] = json => { + (json \ "tenants") + .asOpt[Map[String, TenantExportRequest]](Reads.map(tenantExportRequestReads)) + .map(projects => JsSuccess(ExportRequest(projects))) + .getOrElse(JsError("Bad body format")) + } + + val tenantExportRequestReads: Reads[TenantExportRequest] = json => { + (for ( + projects: ExportList <- (json \ "allProjects") + .asOpt[Boolean] + .flatMap(isAllProjects => + if (isAllProjects) Some(ExportAllItems) + else (json \ "projects").asOpt[Set[String]].map(set => ExportItemList(set)) + ); + keys: ExportList <- (json \ "allKeys") + .asOpt[Boolean] + .flatMap(isAllProjects => + if (isAllProjects) Some(ExportAllItems) + else (json \ "keys").asOpt[Set[String]].map(set => ExportItemList(set)) + ); + webhooks: ExportList <- (json \ "allWebhooks") + .asOpt[Boolean] + .flatMap(isAllProjects => + if (isAllProjects) Some(ExportAllItems) + else (json \ "webhooks").asOpt[Set[String]].map(set => ExportItemList(set)) + ); + userRights <- (json \ "userRights").asOpt[Boolean] + ) yield JsSuccess(TenantExportRequest(projects, keys, webhooks, userRights))).getOrElse(JsError("Bad body format")) + } + + val exportResultWrites: Writes[ExportResult] = exportResult => { + Json.obj( + "tenants" -> Json.toJson(exportResult.tenants)(Writes.map(tenantExportResultWrites)) + ) + } + + val tenantExportResultWrites: Writes[TenantExportResult] = exportResult => { + Json.obj("projects" -> Json.toJson(exportResult.projects)(Writes.map(projectExportResultWrites))) + } + + val projectExportResultWrites: Writes[ProjectExportResult] = exportResult => { + Json.obj("features" -> Json.toJson(exportResult.features)(Writes.list(lightweightFeatureWrite))) + } + + case class ExportRequest(tenants: Map[String, TenantExportRequest]) {} + case class TenantExportRequest(projects: ExportList, keys: ExportList, webhooks: ExportList, userRights: Boolean) + + sealed trait ExportList + case object ExportAllItems extends ExportList + case class ExportItemList(items: Set[String]) extends ExportList + + case class ExportResult( + tenants: Map[String, TenantExportResult] + ) + + case class TenantExportResult( + projects: Map[String, ProjectExportResult] + ) + + case class ProjectExportResult(features: List[LightWeightFeature]) + +} diff --git a/app/fr/maif/izanami/web/ImportController.scala b/app/fr/maif/izanami/web/ImportController.scala index 6819f2859..983c0268f 100644 --- a/app/fr/maif/izanami/web/ImportController.scala +++ b/app/fr/maif/izanami/web/ImportController.scala @@ -2,29 +2,16 @@ package fr.maif.izanami.web import akka.util.ByteString import fr.maif.izanami.env.Env -import fr.maif.izanami.errors.IzanamiError -import fr.maif.izanami.models.{ - AbstractFeature, - ApiKey, - CompleteFeature, - CompleteWasmFeature, - Feature, - RightLevels, - UserWithRights -} +import fr.maif.izanami.errors.{IzanamiError, PartialImportFailure} +import fr.maif.izanami.models.ExportedType.parseExportedType +import fr.maif.izanami.models.{AbstractFeature, ApiKey, CompleteFeature, CompleteWasmFeature, Feature, RightLevels, UserWithRights} import fr.maif.izanami.utils.syntax.implicits.BetterSyntax import fr.maif.izanami.v1.OldKey.{oldKeyReads, toNewKey} import fr.maif.izanami.v1.OldScripts.doesUseHttp import fr.maif.izanami.v1.OldUsers.{oldUserReads, toNewUser} import fr.maif.izanami.v1.{JavaScript, OldFeature, OldGlobalScript, WasmManagerClient} import fr.maif.izanami.wasm.WasmConfig -import fr.maif.izanami.web.ImportController.{ - extractProjectAndName, - parseStrategy, - readFile, - scriptIdToNodeCompatibleName, - unnest -} +import fr.maif.izanami.web.ImportController.{extractProjectAndName, parseStrategy, readFile, scriptIdToNodeCompatibleName, unnest} import fr.maif.izanami.web.ImportState.importResultWrites import io.otoroshi.wasm4s.scaladsl.WasmSourceKind.{Base64, Wasmo} import play.api.libs.Files @@ -182,9 +169,10 @@ class ImportController( } def importData( + version: Int, tenant: String, conflict: String, - timezone: String, + timezone: Option[String], deduceProject: Boolean, create: Option[Boolean], project: Option[String], @@ -192,268 +180,343 @@ class ImportController( inlineScript: Option[Boolean] ): Action[MultipartFormData[Files.TemporaryFile]] = tenantAuthAction(tenant, RightLevels.Admin).async(parse.multipartFormData) { implicit request => - val isBase64 = inlineScript.getOrElse(true) + if (version == 1) { + timezone + .map(tz => { + importV1Data( + request, + tenant, + conflict, + tz, + deduceProject, + create, + project, + projectPartSize, + inlineScript + ) + }) + .getOrElse(BadRequest(Json.obj("message" -> "Missing timezone")).future) + } else if (version == 2) { + importV2Data(request, tenant, conflict) + } else { + BadRequest(Json.obj("message" -> s"Invalid version: $version")).future + } + } - def runImport(id: UUID): Future[ImportResult] = { - val strategy = parseStrategy(conflict) + def importV2Data( + request: UserNameRequest[MultipartFormData[Files.TemporaryFile]], + tenant: String, + conflict: String + ): Future[Result] = { + val files: Map[String, URI] = request.body.files.map(f => (f.key, f.ref.path.toUri)).toMap + (for ( + conflictStrategy <- ImportController.parseStrategy(conflict); + uri <- files.get("export") + ) yield { + Try(scala.io.Source.fromFile(uri)).toEither.left + .map(ex => { + InternalServerError(Json.obj("message" -> "Failed to read file")).future + }) + .map(bf => { + bf.getLines() + .flatMap(line => { + (for ( + rowAsJson <- Json.parse(line).asOpt[JsObject]; + dbRow <- (rowAsJson \ "row").asOpt[JsObject]; + rowTypeStr <- (rowAsJson \ "_type").asOpt[String]; + rowType <- parseExportedType(rowTypeStr) + ) yield (rowType, dbRow)).toSeq + }) + .toSeq + .groupBy(_._1) + .view + .mapValues(v => v.map(_._2)) + .toMap + }) + .map(m => env.datastores.exportDatastore.importTenantData(tenant, m, conflictStrategy)) + .map(f => + f.map { + case Right(_) => Ok("") + case Left(PartialImportFailure(failedElements)) => { + //val r = failedElements.map { case (k, v) => (k.displayName, v) } + Conflict(Json.toJson(failedElements.values.flatten)) + } + case Left(err) => err.toHttpResponse + } + ) + }).toRight(Future.successful(BadRequest(Json.obj("message" -> "Missing export file")))).flatten.fold(r => r, r => r) + } - val files: Map[String, URI] = request.body.files.map(f => (f.key, f.ref.path.toUri)).toMap + def importV1Data( + request: UserNameRequest[MultipartFormData[Files.TemporaryFile]], + tenant: String, + conflict: String, + timezone: String, + deduceProject: Boolean, + create: Option[Boolean], + project: Option[String], + projectPartSize: Option[Int], + inlineScript: Option[Boolean] + ): Future[Result] = { + val isBase64 = inlineScript.getOrElse(true) - case class MigrationData( - features: Seq[CompleteFeature] = Seq(), - users: Seq[UserWithRights] = Seq(), - keys: Seq[ApiKey] = Seq(), - scripts: Seq[OldGlobalScript] = Seq(), - excludedScripts: Seq[OldGlobalScript] = Seq() - ) + def runImport(id: UUID): Future[ImportResult] = { + val strategy = parseStrategy(conflict) - val projectChoiceStrategy: ProjectChoiceStrategy = if (!deduceProject) { - // TODO handle missing project - FixedProject(project.get) - } else { - DeduceProject(projectPartSize.getOrElse(1)) - } + val files: Map[String, URI] = request.body.files.map(f => (f.key, f.ref.path.toUri)).toMap - val maybeEitherScripts = files - .get("scripts") - .map(uri => unnest(readFile(uri, OldFeature.globalScriptReads).map(_.map(Right(_))))) - .map(either => either.map(scripts => scripts.map(s => s.copy(id = scriptIdToNodeCompatibleName(s.id))))) - - val maybeEitherFeatures = files - .get("features") - .map(uri => - unnest( - readFile(uri, OldFeature.oldFeatureReads).map(features => { - val globalScriptById: Map[String, OldGlobalScript] = maybeEitherScripts - .flatMap(_.toOption.map(s => s.map(g => (g.id, g)).toMap)) - .getOrElse(Map()) - - features.map(feature => { - extractProjectAndName(feature, projectChoiceStrategy) - .flatMap { case (project, name) => - feature.toFeature(project, ZoneId.of(timezone), globalScriptById).map { - case (feature, maybeScript) => (feature.withName(name), maybeScript) - } + case class MigrationData( + features: Seq[CompleteFeature] = Seq(), + users: Seq[UserWithRights] = Seq(), + keys: Seq[ApiKey] = Seq(), + scripts: Seq[OldGlobalScript] = Seq(), + excludedScripts: Seq[OldGlobalScript] = Seq() + ) + + val projectChoiceStrategy: ProjectChoiceStrategy = if (!deduceProject) { + // TODO handle missing project + FixedProject(project.get) + } else { + DeduceProject(projectPartSize.getOrElse(1)) + } + + val maybeEitherScripts = files + .get("scripts") + .map(uri => unnest(readFile(uri, OldFeature.globalScriptReads).map(_.map(Right(_))))) + .map(either => either.map(scripts => scripts.map(s => s.copy(id = scriptIdToNodeCompatibleName(s.id))))) + + val maybeEitherFeatures = files + .get("features") + .map(uri => + unnest( + readFile(uri, OldFeature.oldFeatureReads).map(features => { + val globalScriptById: Map[String, OldGlobalScript] = maybeEitherScripts + .flatMap(_.toOption.map(s => s.map(g => (g.id, g)).toMap)) + .getOrElse(Map()) + + features.map(feature => { + extractProjectAndName(feature, projectChoiceStrategy) + .flatMap { case (project, name) => + feature.toFeature(project, ZoneId.of(timezone), globalScriptById).map { + case (feature, maybeScript) => (feature.withName(name), maybeScript) } - }) + } }) - ) + }) ) + ) - val users = files - .get("users") - .map(uri => readFile(uri, oldUserReads)) + val users = files + .get("users") + .map(uri => readFile(uri, oldUserReads)) - val keys = files - .get("keys") - .map(uri => readFile(uri, oldKeyReads)) + val keys = files + .get("keys") + .map(uri => readFile(uri, oldKeyReads)) - val errors = maybeEitherFeatures.map(e => e.swap.getOrElse(Seq())).toSeq.flatten + val errors = maybeEitherFeatures.map(e => e.swap.getOrElse(Seq())).toSeq.flatten - val eitherData = - if (Seq(maybeEitherFeatures, keys, users).forall(_.isEmpty)) { - Left(Seq("No file provided, nothing to import")) - } else if (errors.nonEmpty) { - Left(errors) + val eitherData = + if (Seq(maybeEitherFeatures, keys, users).forall(_.isEmpty)) { + Left(Seq("No file provided, nothing to import")) + } else if (errors.nonEmpty) { + Left(errors) + } else { + val projects = if (deduceProject) { + maybeEitherFeatures.flatMap(_.toOption.map(_.map(_._1.project))).getOrElse(Seq()).toSet } else { - val projects = if (deduceProject) { - maybeEitherFeatures.flatMap(_.toOption.map(_.map(_._1.project))).getOrElse(Seq()).toSet - } else { - Set(project.get) - } - val maybeEitherUsers = - users.map(t => unnest(t.map(users => users.map(u => toNewUser(tenant, u, projects, deduceProject))))) - val maybeEitherKeys = - keys.map(t => unnest(t.map(keys => keys.map(k => Right(toNewKey(tenant, k, projects, deduceProject)))))) - - val errors = Seq(maybeEitherUsers, maybeEitherKeys, maybeEitherScripts).foldLeft(Seq[String]()) { - case (s, Some(Left(errors))) => s.concat(errors) - case (s, _) => s - } + Set(project.get) + } + val maybeEitherUsers = + users.map(t => unnest(t.map(users => users.map(u => toNewUser(tenant, u, projects, deduceProject))))) + val maybeEitherKeys = + keys.map(t => unnest(t.map(keys => keys.map(k => Right(toNewKey(tenant, k, projects, deduceProject)))))) + + val errors = Seq(maybeEitherUsers, maybeEitherKeys, maybeEitherScripts).foldLeft(Seq[String]()) { + case (s, Some(Left(errors))) => s.concat(errors) + case (s, _) => s + } - val oldScripts = maybeEitherFeatures - .flatMap(_.toOption) - .toSeq - .flatten - .flatMap { - case (_, None) => None - case (feature, Some(s)) => { - val id = s"${feature.id}_script" - Some(OldGlobalScript(id = id, name = id, source = s, description = None)) - } - } - .concat(maybeEitherScripts.map(_.getOrElse(Seq())).getOrElse(Seq())) - - val (compatibleScripts, incompatibleScript) = oldScripts.partition(s => { - val isLangageSupported = s.source.language == JavaScript - val hasJsHttpCall = if (s.source.language == JavaScript) { - doesUseHttp(s.source.script) - } else { - false + val oldScripts = maybeEitherFeatures + .flatMap(_.toOption) + .toSeq + .flatten + .flatMap { + case (_, None) => None + case (feature, Some(s)) => { + val id = s"${feature.id}_script" + Some(OldGlobalScript(id = id, name = id, source = s, description = None)) } - isLangageSupported && !hasJsHttpCall - }) + } + .concat(maybeEitherScripts.map(_.getOrElse(Seq())).getOrElse(Seq())) - if (errors.nonEmpty) { - Left(errors) + val (compatibleScripts, incompatibleScript) = oldScripts.partition(s => { + val isLangageSupported = s.source.language == JavaScript + val hasJsHttpCall = if (s.source.language == JavaScript) { + doesUseHttp(s.source.script) } else { - Right( - MigrationData( - features = maybeEitherFeatures - .flatMap(either => either.toOption) - .toSeq - .flatMap(s => s.map(tuple => tuple._1)) - .map { - case CompleteWasmFeature( - id, - name, - project, - enabled, - WasmConfig(scriptName, _, _, _, _, _, _, _, _, _), - tags, - metadata, - description - ) if !compatibleScripts.exists(s => s.id == scriptName) => - Feature( - id = id, - name = name, - project = project, - enabled = enabled, - tags = tags, - metadata = metadata, - description = description, - conditions = Set() - ) - case f @ _ => f - }, - keys = maybeEitherKeys.map(_.getOrElse(Seq())).getOrElse(Seq()), - users = maybeEitherUsers.map(_.getOrElse(Seq())).getOrElse(Seq()), - scripts = compatibleScripts, - excludedScripts = incompatibleScript - ) - ) + false } + isLangageSupported && !hasJsHttpCall + }) + + if (errors.nonEmpty) { + Left(errors) + } else { + Right( + MigrationData( + features = maybeEitherFeatures + .flatMap(either => either.toOption) + .toSeq + .flatMap(s => s.map(tuple => tuple._1)) + .map { + case CompleteWasmFeature( + id, + name, + project, + enabled, + WasmConfig(scriptName, _, _, _, _, _, _, _, _, _), + tags, + metadata, + description + ) if !compatibleScripts.exists(s => s.id == scriptName) => + Feature( + id = id, + name = name, + project = project, + enabled = enabled, + tags = tags, + metadata = metadata, + description = description, + conditions = Set() + ) + case f @ _ => f + }, + keys = maybeEitherKeys.map(_.getOrElse(Seq())).getOrElse(Seq()), + users = maybeEitherUsers.map(_.getOrElse(Seq())).getOrElse(Seq()), + scripts = compatibleScripts, + excludedScripts = incompatibleScript + ) + ) } + } - (strategy, eitherData) match { - case (None, _) => ImportFailure(id, Seq("Unknown conflict handling strategy")).future - case (_, Left(errors)) => ImportFailure(id, errors).future - case (Some(conflictStrategy), Right(MigrationData(features, users, keys, scripts, excludedScripts))) => { - env.postgresql.executeInTransaction(conn => { - scripts - .foldLeft(Future.successful[Either[IzanamiError, Map[String, (String, ByteString)]]](Right(Map())))( - (f, script) => { - f.flatMap { - case Right(ids) => - wasmManagerClient - .transferLegacyJsScript(script.id, script.source.script, local = isBase64) - .map { - case Left(error) => Left(error) - case Right((id, wasm)) => Right(ids + (script.id -> (id, wasm))) - } - case left => Future.successful(left) - } + (strategy, eitherData) match { + case (None, _) => ImportFailure(id, Seq("Unknown conflict handling strategy")).future + case (_, Left(errors)) => ImportFailure(id, errors).future + case (Some(conflictStrategy), Right(MigrationData(features, users, keys, scripts, excludedScripts))) => { + env.postgresql.executeInTransaction(conn => { + scripts + .foldLeft(Future.successful[Either[IzanamiError, Map[String, (String, ByteString)]]](Right(Map())))( + (f, script) => { + f.flatMap { + case Right(ids) => + wasmManagerClient.transferLegacyJsScript(script.id, script.source.script, local = isBase64).map { + case Left(error) => Left(error) + case Right((id, wasm)) => Right(ids + (script.id -> (id, wasm))) + } + case left => Future.successful(left) } - ) - .flatMap { - case Left(err) => ImportFailure(id, Seq(err.message)).future - case Right(scriptIds) => { - val featureWithCorrectPath = features.map { - case f @ CompleteWasmFeature( - id, - name, - project, - enabled, - w @ WasmConfig( - scriptName, - source, - memoryPages, - functionName, - config, - allowedPaths, - wasi, - opa, - instances, - killOptions - ), - tags, - metadata, - description - ) => - f.copy(wasmConfig = - w.copy(source = - w.source.copy( - kind = if (isBase64) Base64 else Wasmo, - path = - if (isBase64) - java.util.Base64.getEncoder.encodeToString(scriptIds(scriptName)._2.toArray) - else scriptIds(scriptName)._1 - ) + } + ) + .flatMap { + case Left(err) => ImportFailure(id, Seq(err.message)).future + case Right(scriptIds) => { + val featureWithCorrectPath = features.map { + case f @ CompleteWasmFeature( + id, + name, + project, + enabled, + w @ WasmConfig( + scriptName, + source, + memoryPages, + functionName, + config, + allowedPaths, + wasi, + opa, + instances, + killOptions + ), + tags, + metadata, + description + ) => + f.copy(wasmConfig = + w.copy(source = + w.source.copy( + kind = if (isBase64) Base64 else Wasmo, + path = + if (isBase64) java.util.Base64.getEncoder.encodeToString(scriptIds(scriptName)._2.toArray) + else scriptIds(scriptName)._1 ) ) - case f => f - } - - env.datastores.features - .createFeaturesAndProjects( - tenant, - featureWithCorrectPath, - conflictStrategy, - user = request.user, - conn = Some(conn) ) - .flatMap { - case Left(errors) => Left(errors).future - case Right(_) => - env.datastores.apiKeys - .createApiKeys(tenant, keys, request.user, conflictStrategy, conn.some) - } - .flatMap { - case Left(err) => ImportFailure(id, err.map(err => err.message)).future - case Right(_) => - env.datastores.users - .createUserWithConn(users, conn, conflictStrategy) - .map { - case Left(error) => ImportFailure(id, Seq(error.message)) - case Right(_) => - ImportSuccess( - id = id, - features = features.size, - users = users.size, - scripts = scripts.size, - keys = keys.size, - incompatibleScripts = excludedScripts.map(s => s.id) - ) - } - } - + case f => f } + + env.datastores.features + .createFeaturesAndProjects( + tenant, + featureWithCorrectPath, + conflictStrategy, + user = request.user, + conn = Some(conn) + ) + .flatMap { + case Left(errors) => Left(errors).future + case Right(_) => + env.datastores.apiKeys + .createApiKeys(tenant, keys, request.user, conflictStrategy, conn.some) + } + .flatMap { + case Left(err) => ImportFailure(id, err.map(err => err.message)).future + case Right(_) => + env.datastores.users + .createUserWithConn(users, conn, conflictStrategy) + .map { + case Left(error) => ImportFailure(id, Seq(error.message)) + case Right(_) => + ImportSuccess( + id = id, + features = features.size, + users = users.size, + scripts = scripts.size, + keys = keys.size, + incompatibleScripts = excludedScripts.map(s => s.id) + ) + } + } + } - }) - } + } + }) } } + } - env.datastores.tenants - .markImportAsStarted() - .map { - case Left(err) => err.toHttpResponse - case Right(id) => { - Future { - runImport(id) - .map { - case s @ ImportSuccess(id, features, users, scripts, keys, incompatibleScripts) => - env.datastores.tenants.markImportAsSucceded(id, s) - case f @ ImportFailure(id, errors) => env.datastores.tenants.markImportAsFailed(id, f) - } - .recover(t => { - env.datastores.tenants.markImportAsFailed(id, ImportFailure(id, Seq(t.getMessage))) - }) - } - Accepted(Json.obj("id" -> id.toString)) + env.datastores.tenants + .markImportAsStarted() + .map { + case Left(err) => err.toHttpResponse + case Right(id) => { + Future { + runImport(id) + .map { + case s @ ImportSuccess(id, features, users, scripts, keys, incompatibleScripts) => + env.datastores.tenants.markImportAsSucceded(id, s) + case f @ ImportFailure(id, errors) => env.datastores.tenants.markImportAsFailed(id, f) + } + .recover(t => { + env.datastores.tenants.markImportAsFailed(id, ImportFailure(id, Seq(t.getMessage))) + }) } + Accepted(Json.obj("id" -> id.toString)) } - } + } + } } object ImportController { @@ -462,10 +525,6 @@ object ImportController { case object MergeOverwrite extends ImportConflictStrategy case object Skip extends ImportConflictStrategy - def sequence[A, B](seq: Seq[Either[A, B]]): Either[A, Seq[B]] = seq.foldRight(Right(Nil): Either[A, List[B]]) { - (e, acc) => for (xs <- acc; x <- e) yield x :: xs - } - def scriptIdToNodeCompatibleName(name: String): String = { name .replace("[", "-") diff --git a/app/fr/maif/izanami/web/SearchController.scala b/app/fr/maif/izanami/web/SearchController.scala index 79e6f0090..4b5413ebb 100644 --- a/app/fr/maif/izanami/web/SearchController.scala +++ b/app/fr/maif/izanami/web/SearchController.scala @@ -112,7 +112,7 @@ class SearchController( // We look for shortes local context parent, since before him all contexts will be global env.datastores.featureContext - .findLocalContexts(tenant, generateParentCandidates(parts.drop(1)).map(s => s"${project}_${s}")) + .findLocalContexts(tenant, generateParentCandidates(parts.toSeq.drop(1)).map(s => s"${project}_${s}")) .map(ctxs => { val parentLocalContext = ctxs.sortBy(_.length).headOption val parts: Seq[PathElement] = parentLocalContext @@ -120,7 +120,7 @@ class SearchController( val shortestLocalContextParts = lc.split("_") val parentLocalContextName = shortestLocalContextParts.last val globalContextParts = - generateParentCandidates(shortestLocalContextParts.dropRight(1).drop(1)) + generateParentCandidates(shortestLocalContextParts.toSeq.dropRight(1).drop(1)) .map(name => GlobalContextPathElement(name)) .toSeq .appended(ProjectPathElement(project)) diff --git a/conf/routes b/conf/routes index dbb61d2cc..dae734cee 100644 --- a/conf/routes +++ b/conf/routes @@ -90,7 +90,7 @@ PUT /api/admin/tenants/:tenant/local-scripts/:script DELETE /api/admin/local-scripts/_cache fr.maif.izanami.web.PluginController.clearWasmCache() DELETE /api/admin/tenants/:tenant/local-scripts/:script fr.maif.izanami.web.PluginController.deleteScript(tenant: String, script: String) -POST /api/admin/tenants/:tenant/_import fr.maif.izanami.web.ImportController.importData(tenant: String, conflict: String, timezone: String, deduceProject: Boolean, create: Option[Boolean], project: Option[String], projectPartSize: Option[Int], inlineScript: Option[Boolean]) +POST /api/admin/tenants/:tenant/_import fr.maif.izanami.web.ImportController.importData(version: Int, tenant: String, conflict: String, timezone: Option[String], deduceProject: Boolean ?= false, create: Option[Boolean], project: Option[String], projectPartSize: Option[Int], inlineScript: Option[Boolean]) GET /api/admin/tenants/:tenant/_import/:id fr.maif.izanami.web.ImportController.readImportStatus(tenant: String, id: String) DELETE /api/admin/tenants/:tenant/_import/:id fr.maif.izanami.web.ImportController.deleteImportStatus(tenant: String, id: String) @@ -108,6 +108,9 @@ PUT /api/admin/tenants/:tenant/webhooks/:webhook/users/:user/rights GET /api/admin/search fr.maif.izanami.web.SearchController.search(query: String) GET /api/admin/tenants/:tenant/search fr.maif.izanami.web.SearchController.searchForTenant(tenant: String, query: String) +POST /api/admin/tenants/:tenant/_export fr.maif.izanami.web.ExportController.exportTenantData(tenant: String) + + # Client application endpoints GET /api/v2/features/:id fr.maif.izanami.web.FeatureController.checkFeatureForContext(id: String, user: String ?= "", context: fr.maif.izanami.web.FeatureContextPath) POST /api/v2/features/:id fr.maif.izanami.web.FeatureController.checkFeatureForContext(id: String, user: String ?= "", context: fr.maif.izanami.web.FeatureContextPath) diff --git a/datasets/with-users.ndjson b/datasets/with-users.ndjson new file mode 100644 index 000000000..7ff405b11 --- /dev/null +++ b/datasets/with-users.ndjson @@ -0,0 +1,20 @@ +{"row":{"id":"92191ca6-6657-48d8-bdad-40a3aa52a77b","name":"super-tag","description":""},"_type":"tag"} +{"row":{"id":"3d506a95-3ad9-41eb-836c-dd70565f1922","name":"another-tag","description":"This is not a super tag"},"_type":"tag"} +{"row":{"id":"f049894f-fc2d-4335-b3a5-1a2a9af242b8","name":"test-project","description":""},"_type":"project"} +{"row":{"id":"00273cce-5b8e-447b-8a2e-0ba8d39bdea8","name":"simple feature","enabled":true,"project":"test-project","metadata":{},"conditions":[],"description":"","script_config":null},"_type":"feature"} +{"row":{"id":"b2d216b5-1023-4187-8b9f-7fa6e4ed2a3d","name":"user percentage and list feature","enabled":true,"project":"test-project","metadata":{},"conditions":[{"rule":{"percentage":20},"period":null},{"rule":{"users":["foo","bar"]},"period":null}],"description":"","script_config":null},"_type":"feature"} +{"row":{"id":"3ea1faa3-0e46-4df0-b245-04fbba42fcfd","name":"embeded opa wasm feature","enabled":false,"project":"test-project","metadata":{},"conditions":null,"description":"","script_config":"opa"},"_type":"feature"} +{"row":{"id":"3e887776-3c62-47a7-97f3-2d57dc3c1e76","name":"date condition feature","enabled":true,"project":"test-project","metadata":{},"conditions":[{"rule":{},"period":{"end":"2024-11-07T23:00:00Z","begin":"2024-09-22T22:00:00Z","timezone":"Europe/Paris","hourPeriods":[{"endTime":"17:00:00","startTime":"08:00:00"},{"endTime":"22:30:00","startTime":"20:00:00"}],"activationDays":{"days":["MONDAY","TUESDAY","WEDNESDAY","THURSDAY","FRIDAY"]}}},{"rule":{},"period":{"end":"2024-09-05T22:00:00Z","begin":"2024-09-01T22:00:00Z","timezone":"Europe/Paris","hourPeriods":[{"endTime":"09:00:00","startTime":"07:00:00"}],"activationDays":{"days":["MONDAY"]}}}],"description":"","script_config":null},"_type":"feature"} +{"row":{"id":"test-tenant_prod_mobile","name":"mobile","parent":"test-tenant_prod"},"_type":"global_context"} +{"row":{"id":"test-tenant_prod","name":"prod","parent":null},"_type":"global_context"} +{"row":{"id":"test-tenant_dev","name":"dev","parent":null},"_type":"global_context"} +{"row":{"id":"test-tenant_dev_mobile","name":"mobile","parent":"test-tenant_dev"},"_type":"global_context"} +{"row":{"id":"test-project_localctx","name":"localctx","parent":null,"project":"test-project","global_parent":null},"_type":"local_context"} +{"row":{"id":"test-project_dev_test-subcontext","name":"test-subcontext","parent":null,"project":"test-project","global_parent":"test-tenant_dev"},"_type":"local_context"} +{"row":{"id":"test-project_prod_local-suctx","name":"local-suctx","parent":null,"project":"test-project","global_parent":"test-tenant_prod"},"_type":"local_context"} +{"row":{"name":"mykey","admin":true,"legacy":false,"enabled":false,"clientid":"test-tenant_DeB4oc6M283Ne2yy","description":"","clientsecret":"mcY2zR5f60DbdYTeSmg84yM9Qi7oQSU4ZpvHmI1sErmyMbP1i9nfDCD8ux3OZDoE"},"_type":"key"} +{"row":{"level":"READ","project":"test-project","username":"fifou"},"_type":"project_right"} +{"row":{"level":"WRITE","project":"test-project","username":"foobar"},"_type":"project_right"} +{"row":{"level":"ADMIN","project":"test-project","username":"RESERVED_ADMIN_USER"},"_type":"project_right"} +{"row":{"level":"ADMIN","apikey":"mykey","username":"RESERVED_ADMIN_USER"},"_type":"key_right"} +{"row":{"id":"opa","config":{"opa":true,"name":"opa","wasi":true,"config":{},"source":{"kind":"Base64","opts":{},"path":"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"},"instances":1,"killOptions":{"immortal":false,"max_calls":2147483647,"max_memory_usage":0,"max_unused_duration":300000,"max_avg_call_duration":0},"memoryPages":100,"allowedHosts":["*"],"allowedPaths":{},"functionName":"execute","authorizations":{"httpAccess":true}}},"_type":"script"} \ No newline at end of file diff --git a/datasets/without-users.ndjson b/datasets/without-users.ndjson new file mode 100644 index 000000000..e8fc8d2c2 --- /dev/null +++ b/datasets/without-users.ndjson @@ -0,0 +1,18 @@ +{"row":{"id":"92191ca6-6657-48d8-bdad-40a3aa52a77b","name":"super-tag","description":""},"_type":"tag"} +{"row":{"id":"3d506a95-3ad9-41eb-836c-dd70565f1922","name":"another-tag","description":"This is not a super tag"},"_type":"tag"} +{"row":{"id":"f049894f-fc2d-4335-b3a5-1a2a9af242b8","name":"test-project","description":""},"_type":"project"} +{"row":{"id":"00273cce-5b8e-447b-8a2e-0ba8d39bdea8","name":"simple feature","enabled":true,"project":"test-project","metadata":{},"conditions":[],"description":"","script_config":null},"_type":"feature"} +{"row":{"id":"b2d216b5-1023-4187-8b9f-7fa6e4ed2a3d","name":"user percentage and list feature","enabled":true,"project":"test-project","metadata":{},"conditions":[{"rule":{"percentage":20},"period":null},{"rule":{"users":["foo","bar"]},"period":null}],"description":"","script_config":null},"_type":"feature"} +{"row":{"id":"3ea1faa3-0e46-4df0-b245-04fbba42fcfd","name":"embeded opa wasm feature","enabled":false,"project":"test-project","metadata":{},"conditions":null,"description":"","script_config":"opa"},"_type":"feature"} +{"row":{"id":"3e887776-3c62-47a7-97f3-2d57dc3c1e76","name":"date condition feature","enabled":true,"project":"test-project","metadata":{},"conditions":[{"rule":{},"period":{"end":"2024-11-07T23:00:00Z","begin":"2024-09-22T22:00:00Z","timezone":"Europe/Paris","hourPeriods":[{"endTime":"17:00:00","startTime":"08:00:00"},{"endTime":"22:30:00","startTime":"20:00:00"}],"activationDays":{"days":["MONDAY","TUESDAY","WEDNESDAY","THURSDAY","FRIDAY"]}}},{"rule":{},"period":{"end":"2024-09-05T22:00:00Z","begin":"2024-09-01T22:00:00Z","timezone":"Europe/Paris","hourPeriods":[{"endTime":"09:00:00","startTime":"07:00:00"}],"activationDays":{"days":["MONDAY"]}}}],"description":"","script_config":null},"_type":"feature"} +{"row":{"id":"test-tenant_prod_mobile","name":"mobile","parent":"test-tenant_prod"},"_type":"global_context"} +{"row":{"id":"test-tenant_prod","name":"prod","parent":null},"_type":"global_context"} +{"row":{"id":"test-tenant_dev","name":"dev","parent":null},"_type":"global_context"} +{"row":{"id":"test-tenant_dev_mobile","name":"mobile","parent":"test-tenant_dev"},"_type":"global_context"} +{"row":{"id":"test-project_localctx","name":"localctx","parent":null,"project":"test-project","global_parent":null},"_type":"local_context"} +{"row":{"id":"test-project_dev_test-subcontext","name":"test-subcontext","parent":null,"project":"test-project","global_parent":"test-tenant_dev"},"_type":"local_context"} +{"row":{"id":"test-project_prod_local-suctx","name":"local-suctx","parent":null,"project":"test-project","global_parent":"test-tenant_prod"},"_type":"local_context"} +{"row":{"name":"mykey","admin":true,"legacy":false,"enabled":false,"clientid":"test-tenant_DeB4oc6M283Ne2yy","description":"","clientsecret":"mcY2zR5f60DbdYTeSmg84yM9Qi7oQSU4ZpvHmI1sErmyMbP1i9nfDCD8ux3OZDoE"},"_type":"key"} +{"row":{"level":"ADMIN","project":"test-project","username":"RESERVED_ADMIN_USER"},"_type":"project_right"} +{"row":{"level":"ADMIN","apikey":"mykey","username":"RESERVED_ADMIN_USER"},"_type":"key_right"} +{"row":{"id":"opa","config":{"opa":true,"name":"opa","wasi":true,"config":{},"source":{"kind":"Base64","opts":{},"path":"AGFzbQEAAAABjQETYAR/f39/AGABfwBgAX8Bf2ADf39/AX9gAn9/AX9gAn9/AGADf39/AGAAAX9gAABgBH9/f38Bf2AFf39/f38Bf2AIf39/f3x/f38Bf2AHf39/f39/fwF/YAJ+fwBgAX4Bf2AFf39/f38AYAt/f39/f39/f39/fwF/YAZ/f39/f38Bf2AHf39/f39/fwACHwIDZW52CW9wYV9hYm9ydAABA2VudgZtZW1vcnkCAAIDfn0CBAMHBQwCBQUCCAkFAgQEBAMECgMDBAICBwEGCAgIAgEFAQEBAgIDAgICDQMCAwQCAgQEBAQEAgUFBQUBAAYCDgUGAgQHBwMEDwAJAAAQCwsIAQIBBAQDAwQRBgMDAwMAAwcDAwEBAQYGBgYGBAASCgMDBgMDAwUJBAcHCAQFAXABS0sGEgN/AUGAgAQLfwBBAQt/AEEDCwfuAxoGbWVtb3J5AgAQb3BhX2V2YWxfY3R4X25ldwAECm9wYV9tYWxsb2MAIBZvcGFfZXZhbF9jdHhfc2V0X2lucHV0AAUIb3BhX2V2YWwABhBvcGFfaGVhcF9wdHJfc2V0ABsPb3BhX3ZhbHVlX3BhcnNlABEOb3BhX3ZhbHVlX2R1bXAAGQ1vcGFfanNvbl9kdW1wABgVb3BhX2V2YWxfY3R4X3NldF9kYXRhAAgbb3BhX2V2YWxfY3R4X3NldF9lbnRyeXBvaW50AAkXb3BhX2V2YWxfY3R4X2dldF9yZXN1bHQACg5vcGFfanNvbl9wYXJzZQAQCG9wYV9mcmVlACEOb3BhX3ZhbHVlX2ZyZWUAPRBvcGFfaGVhcF9wdHJfZ2V0ABoVb3BhX2hlYXBfYmxvY2tzX3N0YXNoAB0Ub3BhX2hlYXBfc3Rhc2hfY2xlYXIAHhdvcGFfaGVhcF9ibG9ja3NfcmVzdG9yZQAfEm9wYV92YWx1ZV9hZGRfcGF0aABIFW9wYV92YWx1ZV9yZW1vdmVfcGF0aABJBGV2YWwABwhidWlsdGlucwB7C2VudHJ5cG9pbnRzAHwUb3BhX3dhc21fYWJpX3ZlcnNpb24DARpvcGFfd2FzbV9hYmlfbWlub3JfdmVyc2lvbgMCCAF9CVYCAEEBC0kzEhUWIiJNTnVdX3ZeYFRXVlUBJUpwQ0sBJUpwQwslJSUCAgICAgICAgElDFsCAyUMWwIlJSUlJSUMAwElDFsCAyUMWwIDJVsCAEHKAAsBegqKiAR9AwAACwMAAAsDAAALGwEBf0EQECAiAEIANwIAIABBCGpCADcCACAACwkAIAAgATYCAAtlAQF/IwBBEGsiByQAIAAEQEHZgwQQUwsgBRAbIAMgBBARIQAgByABNgIMIAdBADYCCCAHIAI2AgQgByAANgIAIAcQBxogBygCCCEAAn8gBgRAIAAQGQwBCyAAEBgLIAdBEGokAAtuAQN/QQgQICIBQQA2AgAQRiECQfClByABNgIAIAEgAjYCBCAAKAIAIQEgACgCBCECIAAQRyIDNgIIAkAgACgCDEUEQCABIAIQeiIABEAQRiIBQYunByAAED8gAyABEEILDAELQemnBxBTAAtBAAsJACAAIAE2AgQLCQAgACABNgIMCwcAIAAoAggLAwAACwMAAAt/AQN/IwBB8ABrIgIkACAArCACQUBrIgAQLCABrCACQRBqIgEQLEGXpwcQJyAAECdqIAEQJ2pBuqcHECdqQQVqIgQQICEDIAJBuqcHNgIMIAJBl6cHNgIAIAIgATYCCCACIAA2AgQgAyAEQY+FBCACEEwaIAMQUyACQfAAaiQAC94LAQZ/QQEhBAJAIAAoAgQiBSAAKAIQIgMgACgCACICa00NAANAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMsAAAiAUEiaw5cBAsLCwsLCwsLCwkLCwsLCwsLCwsLCwsLCgsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLBwsICwsLCwsLCwsCCwsLCwsLCwALCwsLAwELCwsLCwsFCwYLC0EAIQQgBSADayACakEESA0MQdiRBCADQQQQKA0MIAAgACgCEEEEajYCEEECDwtBACEEIAUgA2sgAmpBBEgNC0H6lgQgA0EEECgNCyAAIAAoAhBBBGo2AhBBAw8LQQAhBCAFIANrIAJqQQVIDQpBqZcEIANBBRAoDQogACAAKAIQQQVqNgIQQQQPC0EAIQQgACgCFEUgBSADayACakEESHINCUHIrwQgA0EEECgNCSAAIAAoAhAiAUEEajYCECABLAAEECoEQANAIAAgACgCECIBQQFqNgIQIAEsAAEQKg0ACwsgACgCECIBLQAAQSlHDQkgACABQQFqNgIQQQ4PCwJ/QQAhBAJAIAAoAhAiAS0AAEEiRw0AIAAgAUEBaiIDNgIIIAAgAzYCECAAKAIEIgUgAyAAKAIAIgJrTQ0AAkADQAJ/AkAgAy0AACIBQdwARwRAIAFBIkYNBCABQSBPDQFBAAwGCyAAIANBAWoiATYCEEEAIQQgASACayAFTw0EAkACQCABLQAAQSJrDlQABgYGBgYGBgYGBgYGAAYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGAAYGBgYGAAYGBgAGBgYGBgYGAAYGBgAGAAEGCyAAIANBAmoiAzYCEEEBDAILIAAgA0ECaiIBNgIQIAUgAWsgAmpBBEgNBCABLAAAECtFDQQgACgCECwAARArRQ0EIAAoAhAsAAIQK0UNBCAAKAIQLAADECtFDQQgACAAKAIQQQRqIgM2AhAgACgCBCEFIAAoAgAhAkEBDAELIAAgA0EBaiIDNgIQQQEgBCABQf4ASxsLIQQgAyACayAFSQ0AC0EADAILIAAgAzYCDCAAIANBAWo2AhBBB0EGIAQbIQQLIAQLDwsgACADQQFqNgIQQQgPCyAAIANBAWo2AhBBCQ8LIAAgA0EBajYCEEEKDwsgACADQQFqNgIQQQsPCyAAIANBAWo2AhBBDA8LIAAgA0EBajYCEEENDwsgARApRSABQS1HcUUEQAJ/QQAhBCAAIAAoAhAiAjYCCAJAIAItAAAiAUEtRgRAIAAgAkEBaiICNgIQIAAoAgQgAiAAKAIAa00NASACLQAAIQELAkAgAUH/AXFBMEYEQCAAIAJBAWoiAjYCEAwBC0EAIAHAEClFDQIaIAAoAgQgACgCECICIAAoAgBrTQ0AA0AgAiwAABApIAAoAhAhAkUNASAAIAJBAWoiAjYCECAAKAIEIAIgACgCAGtLDQALCwJAIAAoAgQiBiACIAAoAgAiA2tNBEAgAiEBDAELIAItAAAiAUEuRgR/IAAgAkEBaiICNgIQAkAgAiADayIBIAZPDQADQCACLAAAECkgACgCECECRQRAIAIgACgCACIDayEBIAAoAgQhBgwCCyAAIAJBAWoiAjYCECACIAAoAgAiA2siASAAKAIEIgZJDQALCyABIAZPBEAgAiEBDAILIAItAAAFIAELQSByQf8BcUHlAEcEQCACIQEMAQsgACACQQFqIgE2AhAgASADayIFIAZPDQECQAJAIAEtAABBK2sOAwABAAELIAAgAkECaiIBNgIQIAEgA2siBSAGTw0CCyAFIAZPDQADQCABLAAAECkgACgCECEBRQ0BIAAgAUEBaiIBNgIQIAAoAgQgASAAKAIAa0sNAAsLIAAgATYCDEEFIQQLIAQLDwsgARAqRQRAQQAPCyAAIAAoAhBBAWoiAzYCECAAKAIEIgUgAyAAKAIAIgJrSw0ACwsgBAuREgEPfwJAAkACQAJAAkACQAJAAkACQCABQQJrDg0AAQIDBAQGCAUICAgHCAtBARAgIgBBAToAACAADwtBARBADwtBABBADwsgACgCDCIGIAAoAggiAWsiAhAgIQQCQCACQQBMDQAgAkEDcSEDQQAhACABQX9zIAZqQQNPBEAgAkF8cSEHA0AgACAEaiIGIAAgAWoiBS0AADoAACAGQQFqIAVBAWotAAA6AAAgBkECaiAFQQJqLQAAOgAAIAZBA2ogBUEDai0AADoAACAHIABBBGoiAEcNAAsLIANFDQAgACABaiEBIAAgBGohAANAIAAgAS0AADoAACABQQFqIQEgAEEBaiEAIANBAWsiAw0ACwtBGBAgIgBBAToAECAAIAI2AgwgACAENgIIIABBgwQ7AQAgAA8LIAAoAggiAiEGIAAoAgwgAmshBEEAIQIjAEEQayIMJAACfyABQQZGBEAgBBAgIQECQCAEQQBMDQAgBEEDcSEFQQAhACAEQQFrQQNPBEAgBEF8cSEHA0AgACABaiICIAAgBmoiAy0AADoAACACQQFqIANBAWotAAA6AAAgAkECaiADQQJqLQAAOgAAIAJBA2ogA0EDai0AADoAACAHIABBBGoiAEcNAAsLIAVFDQAgACAGaiECIAAgAWohAANAIAAgAi0AADoAACACQQFqIQIgAEEBaiEAIAVBAWsiBQ0ACwsgASAEEEUMAQsCQAJ/IAQEQEEAIQADQAJAIAAgBmotAABB3ABHDQAgBiAAIAQQLyIBQX9GBEAgAEEBaiEAIAJBAWohAgwBCyAAQQVqIQAgARAuRQRAIAJBAmohAgwBCyACQQRqIQILIABBAWoiACAESQ0ACyAEIAJrECAiASAEQQBMDQEaIAEhAkEAIQADQAJAIAAgBmoiBS0AACIDQdwARwRAAkACQCADQSJHIANBIE9xRQRAQbGJBBBTDAELIAPAQQBIDQELIAIgAzoAACAAQQFqIQAgAkEBaiECDAILAn8gDEEMaiEFQX8hDgJAIAAgBE4NACAAIAZqIggtAAAiA0GAAXFFBEAgBUEBNgIAIAMMAgsgA0HgAXFBwAFGBEAgA0H+AXFBwAFGIABBAWoiByAETnINASAGIAdqLAAAIgdBAE4gB0H/AXFBvwFLcg0BIAVBAjYCACADQQZ0QcAPcSAHQT9xcgwCCyADQfABcUHgAUYEQCAAQQJqIgkgBE4NASAIQQFqLQAAIgdBoAFJIAdBvwFLIgpyIANB4AFHciAGIAlqLQAAIgjAQQBOckUgCEHAAUkiCXEgCSAKIAjAQQBOIgtyIg0gB8BBAE4iCiADQR9qQf8BcUELS3JyRXEgCSAKIANB7QFHciALIAdBnwFLcnJFcXJyQQEgDSAKIANB/gFxQe4BR3JyIAhBvwFLchtFDQEgBUEDNgIAIAhBP3EgA0EMdEGA4ANxIAdBP3FBBnRycgwCCyADQfgBcUHwAUcNACAAQQNqIgsgBE4NACAIQQFqLQAAIgdBkAFJIAdBvwFLIg1yIANB8AFHciAIQQJqLQAAIglBvwFLIAnAQQBOIgpyIAYgC2otAAAiCMBBAE5yckUgCEHAAUkiC3EgCyAJQb8BSyAIwEEATnIiDyAHwEEATiIQIANBD2pB/wFxQQJLciAKIA1ycnJFcXJFIBAgA0H0AUdyIAogB0GPAUtyciAIQb8BSyAPcnJxDQAgBUEENgIAIAhBP3EgA0ESdEGAgPAAcSAHQT9xQQx0ciAJQT9xQQZ0cnIhDgsgDgsiA0F/RgRAQY2kBBBTCyAMKAIMIABqIQAgAyACEDAgAmohAgwBCwJAAkACQAJAAkACQAJAAkACQCAFQQFqLAAAIgNBImsOVAAHBwcHBwcHBwcHBwcABwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcABwcHBwcBBwcHAgcHBwcHBwcDBwcHBAcFBgcLIAIgAzoAAAwHCyACQQg6AAAMBgsgAkEMOgAADAULIAJBCjoAAAwECyACQQ06AAAMAwsgAkEJOgAADAILIAYgACAEEC8iBUF/RgRAQc6IBBBTCyAAQQZqIQMgBRAuBH8gBiADIAQQLyIDQX9GBEBBzogEEFMLQf3/A0H9/wMgBUEKdEGAgIAbayADQYDIAGpyIANBgHBxQYCwA0cbIAVBgHBxQYCwA0cbIQUgAEEMagUgAwshACAFIAIQMCACaiECDAILQc6IBBBTDAELIABBAmohACACQQFqIQILIAAgBEgNAAsMAgsgBBAgCyIBIQILIAEgAiABaxBFCyAMQRBqJAAPC0EBIQFBEBAgIgJBADYCDCACQQU6AAAgAkIANwIEA0ACQAJAIAAQDiIDQQtrDgIFAAELIAFBAXFBASEBRQ0BCyAAIAMQDyIFBEBBACEEIAIoAggiASACKAIMIgNPBEAgAiADQQF0QQogAxsiATYCDCABQQN0ECAhBgJAIAIoAghFBEBBACEBDAELQQAhAwNAIAMgBmogAigCBCADaikCADcCACADQQhqIQMgBEEBaiIEIAIoAggiAUkNAAsLIAIoAgQiAwRAIAMQISACKAIIIQELIAIgBjYCBAsgAiABQQFqNgIIQRgQICIDIAGtNwMIIANBgwI7AQAgAigCBCABQQN0aiIBIAM2AgAgASAFNgIEQQAhAQwBBUEADwsACwALIAAQDiIBQQlGBEAQRg8LIAAgARAPIgFFBEBBAA8LAkACQCAAEA4iA0EJaw4FAAMDAAEDCwJAAkAgACgCFEUNABBHIgIgARBCIANBCUYNASAAIAAQDhAPIgFFDQADQCACIAEQQiAAEA4iAUEMRwRAIAFBCUcNAgwDCyAAIAAQDhAPIgENAAsLQQAhAgsgAg8LAkACQCAAIAAQDhAPIgJFDQAQRiIDIAEgAhA/AkAgABAOQQlrDgQCAQEAAQsgACAAEA4QDyICRQ0AA0AgABAOQQ1HDQEgACAAEA4QDyIBRQ0BIAMgAiABED8gABAOIgFBDEcEQCABQQlHDQIMAwsgACAAEA4QDyICDQALC0EAIQMLIAMPCxBHIQILIAILRAEBfyMAQSBrIgIkACACIAA2AhggAiABNgIMIAIgADYCCCACQQA2AhwgAkIANwMQIAJBCGoiACAAEA4QDyACQSBqJAALRAEBfyMAQSBrIgIkACACIAA2AhggAiABNgIMIAIgADYCCCACQQE2AhwgAkIANwMQIAJBCGoiACAAEA4QDyACQSBqJAALDAAgACABIAIQNBATC+MtAgl/AX5BfiECAkACQAJAAkACQAJAAkACQCABEDFBAWsOBwABAwIEBgUHCyAAKAIEIgEgACgCAGtBBGoiAyAAKAIIIgJLBEAgA0EBdCIHECAiA0UEQEF/DwsCQCACRQ0AIAJBA3EhBEEAIQEgAkEBa0EDTwRAQQAgAkF8cWshBUEBIQEDQCABIANqIgJBAWsgACgCACABakEBay0AADoAACACIAAoAgAgAWotAAA6AAAgAkEBaiAAKAIAIAFqQQFqLQAAOgAAIAJBAmogACgCACABakECai0AADoAACAFIAFBBGoiAWpBAUcNAAsgAUEBayEBCyAERQ0AA0AgASADaiAAKAIAIAFqLQAAOgAAIAFBAWohASAEQQFrIgQNAAsLIAAgBzYCCCAAKAIAIQEgACADNgIAIAAgAyAAKAIEIAFraiIBNgIECyABQe4AOgAAIAAoAgRB9QA6AAEgACgCBEHsADoAAiAAKAIEQewAOgADIAAgACgCBEEEajYCBEEADwsCfyAAKAIEIgIgACgCAGshAwJ/IAEtAAFFBEBBBSEHIANBBWoiASAAKAIIIgNLBEBBfyABQQF0IgUQICIERQ0DGgJAIANFDQAgA0EDcSEBQQAhAiADQQFrQQNPBEBBACADQXxxayEGQQEhAgNAIAIgBGoiA0EBayAAKAIAIAJqQQFrLQAAOgAAIAMgACgCACACai0AADoAACADQQFqIAAoAgAgAmpBAWotAAA6AAAgA0ECaiAAKAIAIAJqQQJqLQAAOgAAIAYgAkEEaiICakEBRw0ACyACQQFrIQILIAFFDQADQCACIARqIAAoAgAgAmotAAA6AAAgAkEBaiECIAFBAWsiAQ0ACwsgACAFNgIIIAAoAgAhASAAIAQ2AgAgACAEIAAoAgQgAWtqIgI2AgQLIAJB5gA6AAAgACgCBEHhADoAAUEEIQJBAyEBQewAIQNBAiEEQfMADAELQQQhByADQQRqIgEgACgCCCIDSwRAQX8gAUEBdCIFECAiBEUNAhoCQCADRQ0AIANBA3EhAUEAIQIgA0EBa0EDTwRAQQAgA0F8cWshBkEBIQIDQCACIARqIgNBAWsgACgCACACakEBay0AADoAACADIAAoAgAgAmotAAA6AAAgA0EBaiAAKAIAIAJqQQFqLQAAOgAAIANBAmogACgCACACakECai0AADoAACAGIAJBBGoiAmpBAUcNAAsgAkEBayECCyABRQ0AA0AgAiAEaiAAKAIAIAJqLQAAOgAAIAJBAWohAiABQQFrIgENAAsLIAAgBTYCCCAAKAIAIQEgACAENgIAIAAgBCAAKAIEIAFraiICNgIECyACQfQAOgAAQQMhAkECIQFB8gAhA0EBIQRB9QALIQUgACgCBCAEaiADOgAAIAAoAgQgAWogBToAACAAKAIEIAJqQeUAOgAAIAAgACgCBCAHajYCBEEACw8LIwBBEGsiByQAAn8gACgCBCICIAAoAgBrQQFqIgMgACgCCCIESwRAQX8gA0EBdCIGECAiBUUNARoCQCAERQ0AIARBA3EhA0EAIQIgBEEBa0EDTwRAQQAgBEF8cWshCEEBIQIDQCACIAVqIgRBAWsgACgCACACakEBay0AADoAACAEIAAoAgAgAmotAAA6AAAgBEEBaiAAKAIAIAJqQQFqLQAAOgAAIARBAmogACgCACACakECai0AADoAACAIIAJBBGoiAmpBAUcNAAsgAkEBayECCyADRQ0AA0AgAiAFaiAAKAIAIAJqLQAAOgAAIAJBAWohAiADQQFrIgMNAAsLIAAgBjYCCCAAKAIAIQIgACAFNgIAIAAgBSAAKAIEIAJraiICNgIECyACQSI6AAAgACAAKAIEQQFqIgI2AgQCQCABKAIEBEADQCAAAn8gASgCCCAKai0AACIEQSBJIARBIkZyIARB3ABGckUEQCACIAAoAgBrQQFqIgMgACgCCCIFSwRAQX8gA0EBdCIIECAiBkUNBhoCQCAFRQ0AIAVBA3EhA0EAIQIgBUEBa0EDTwRAQQAgBUF8cWshCUEBIQIDQCACIAZqIgVBAWsgACgCACACakEBay0AADoAACAFIAAoAgAgAmotAAA6AAAgBUEBaiAAKAIAIAJqQQFqLQAAOgAAIAVBAmogACgCACACakECai0AADoAACAJIAJBBGoiAmpBAUcNAAsgAkEBayECCyADRQ0AA0AgAiAGaiAAKAIAIAJqLQAAOgAAIAJBAWohAiADQQFrIgMNAAsLIAAgCDYCCCAAKAIAIQIgACAGNgIAIAAgBiAAKAIEIAJraiICNgIECyACIAQ6AAAgACgCBEEBagwBCyACIAAoAgBrQQFqIgMgACgCCCIFSwRAQX8gA0EBdCIIECAiBkUNBRoCQCAFRQ0AIAVBA3EhA0EAIQIgBUEBa0EDTwRAQQAgBUF8cWshCUEBIQIDQCACIAZqIgVBAWsgACgCACACakEBay0AADoAACAFIAAoAgAgAmotAAA6AAAgBUEBaiAAKAIAIAJqQQFqLQAAOgAAIAVBAmogACgCACACakECai0AADoAACAJIAJBBGoiAmpBAUcNAAsgAkEBayECCyADRQ0AA0AgAiAGaiAAKAIAIAJqLQAAOgAAIAJBAWohAiADQQFrIgMNAAsLIAAgCDYCCCAAKAIAIQIgACAGNgIAIAAgBiAAKAIEIAJraiICNgIECyACQdwAOgAAIAAgACgCBEEBaiICNgIEAkACQAJAAkACQAJAIARBCWsOGgQCBQUDBQUFBQUFBQUFBQUFBQUFBQUFBQUBAAsgBEHcAEcNBAsgAiAAKAIAa0EBaiIDIAAoAggiBUsEQEF/IANBAXQiCBAgIgZFDQkaAkAgBUUNACAFQQNxIQNBACECIAVBAWtBA08EQEEAIAVBfHFrIQlBASECA0AgAiAGaiIFQQFrIAAoAgAgAmpBAWstAAA6AAAgBSAAKAIAIAJqLQAAOgAAIAVBAWogACgCACACakEBai0AADoAACAFQQJqIAAoAgAgAmpBAmotAAA6AAAgCSACQQRqIgJqQQFHDQALIAJBAWshAgsgA0UNAANAIAIgBmogACgCACACai0AADoAACACQQFqIQIgA0EBayIDDQALCyAAIAg2AgggACgCACECIAAgBjYCACAAIAYgACgCBCACa2oiAjYCBAsgAiAEOgAAIAAoAgRBAWoMBAsgAiAAKAIAa0EBaiIDIAAoAggiBEsEQEF/IANBAXQiBhAgIgVFDQgaAkAgBEUNACAEQQNxIQNBACECIARBAWtBA08EQEEAIARBfHFrIQhBASECA0AgAiAFaiIEQQFrIAAoAgAgAmpBAWstAAA6AAAgBCAAKAIAIAJqLQAAOgAAIARBAWogACgCACACakEBai0AADoAACAEQQJqIAAoAgAgAmpBAmotAAA6AAAgCCACQQRqIgJqQQFHDQALIAJBAWshAgsgA0UNAANAIAIgBWogACgCACACai0AADoAACACQQFqIQIgA0EBayIDDQALCyAAIAY2AgggACgCACECIAAgBTYCACAAIAUgACgCBCACa2oiAjYCBAsgAkHuADoAACAAKAIEQQFqDAMLIAIgACgCAGtBAWoiAyAAKAIIIgRLBEBBfyADQQF0IgYQICIFRQ0HGgJAIARFDQAgBEEDcSEDQQAhAiAEQQFrQQNPBEBBACAEQXxxayEIQQEhAgNAIAIgBWoiBEEBayAAKAIAIAJqQQFrLQAAOgAAIAQgACgCACACai0AADoAACAEQQFqIAAoAgAgAmpBAWotAAA6AAAgBEECaiAAKAIAIAJqQQJqLQAAOgAAIAggAkEEaiICakEBRw0ACyACQQFrIQILIANFDQADQCACIAVqIAAoAgAgAmotAAA6AAAgAkEBaiECIANBAWsiAw0ACwsgACAGNgIIIAAoAgAhAiAAIAU2AgAgACAFIAAoAgQgAmtqIgI2AgQLIAJB8gA6AAAgACgCBEEBagwCCyACIAAoAgBrQQFqIgMgACgCCCIESwRAQX8gA0EBdCIGECAiBUUNBhoCQCAERQ0AIARBA3EhA0EAIQIgBEEBa0EDTwRAQQAgBEF8cWshCEEBIQIDQCACIAVqIgRBAWsgACgCACACakEBay0AADoAACAEIAAoAgAgAmotAAA6AAAgBEEBaiAAKAIAIAJqQQFqLQAAOgAAIARBAmogACgCACACakECai0AADoAACAIIAJBBGoiAmpBAUcNAAsgAkEBayECCyADRQ0AA0AgAiAFaiAAKAIAIAJqLQAAOgAAIAJBAWohAiADQQFrIgMNAAsLIAAgBjYCCCAAKAIAIQIgACAFNgIAIAAgBSAAKAIEIAJraiICNgIECyACQfQAOgAAIAAoAgRBAWoMAQsgAiAAKAIAa0EDaiIDIAAoAggiBUsEQEF/IANBAXQiCBAgIgZFDQUaAkAgBUUNACAFQQNxIQNBACECIAVBAWtBA08EQEEAIAVBfHFrIQlBASECA0AgAiAGaiIFQQFrIAAoAgAgAmpBAWstAAA6AAAgBSAAKAIAIAJqLQAAOgAAIAVBAWogACgCACACakEBai0AADoAACAFQQJqIAAoAgAgAmpBAmotAAA6AAAgCSACQQRqIgJqQQFHDQALIAJBAWshAgsgA0UNAANAIAIgBmogACgCACACai0AADoAACACQQFqIQIgA0EBayIDDQALCyAAIAg2AgggACgCACECIAAgBjYCACAAIAYgACgCBCACa2oiAjYCBAsgAkH1ADoAACAAKAIEQTA6AAEgACgCBEEwOgACIAAgACgCBEEDajYCBCAHIAQ2AgAgB0ENakEDQb+ABCAHEEwaIAAoAgQiAiAAKAIAa0ECaiIDIAAoAggiBEsEQCADQQF0IgYQICIFRQ0EAkAgBEUNACAEQQNxIQNBACECIARBAWtBA08EQEEAIARBfHFrIQhBASECA0AgAiAFaiIEQQFrIAAoAgAgAmpBAWstAAA6AAAgBCAAKAIAIAJqLQAAOgAAIARBAWogACgCACACakEBai0AADoAACAEQQJqIAAoAgAgAmpBAmotAAA6AAAgCCACQQRqIgJqQQFHDQALIAJBAWshAgsgA0UNAANAIAIgBWogACgCACACai0AADoAACACQQFqIQIgA0EBayIDDQALCyAAIAY2AgggACgCACECIAAgBTYCACAAIAUgACgCBCACa2oiAjYCBAsgAiAHLQANOgAAIAAoAgQgBy0ADjoAASAAKAIEQQJqCyICNgIEIApBAWoiCiABKAIESQ0ACwsgAiAAKAIAa0EBaiIDIAAoAggiAUsEQEF/IANBAXQiBRAgIgRFDQIaAkAgAUUNACABQQNxIQNBACECIAFBAWtBA08EQEEAIAFBfHFrIQZBASECA0AgAiAEaiIBQQFrIAAoAgAgAmpBAWstAAA6AAAgASAAKAIAIAJqLQAAOgAAIAFBAWogACgCACACakEBai0AADoAACABQQJqIAAoAgAgAmpBAmotAAA6AAAgBiACQQRqIgJqQQFHDQALIAJBAWshAgsgA0UNAANAIAIgBGogACgCACACai0AADoAACACQQFqIQIgA0EBayIDDQALCyAAIAU2AgggACgCACEBIAAgBDYCACAAIAQgACgCBCABa2oiAjYCBAsgAkEiOgAAIAAgACgCBEEBajYCBEEADAELQX8LIAdBEGokAA8LAn8CQAJAAkACQAJAIAEtAAFBAWsOAgABAgsgASkDCCMAQdAAayIEJAAgBBAsAn8gBBAnIgcgACgCBCIDIAAoAgBraiIBIAAoAggiBUsEQEF/IAFBAXQiBhAgIgNFDQEaAkAgBUUNACAFQQNxIQJBACEBIAVBAWtBA08EQEEAIAVBfHFrIQpBASEBA0AgASADaiIFQQFrIAAoAgAgAWpBAWstAAA6AAAgBSAAKAIAIAFqLQAAOgAAIAVBAWogACgCACABakEBai0AADoAACAFQQJqIAAoAgAgAWpBAmotAAA6AAAgCiABQQRqIgFqQQFHDQALIAFBAWshAQsgAkUNAANAIAEgA2ogACgCACABai0AADoAACABQQFqIQEgAkEBayICDQALCyAAIAY2AgggACgCACEBIAAgAzYCACAAIAMgACgCBCABa2oiAzYCBAsCQCAHRQ0AIAdBA3EhAgJAIAdBAWtBA0kEQEEAIQEMAQsgB0F8cSEFQQAhAQNAIAEgA2ogASAEaiIDLQAAOgAAIAAoAgQgAWpBAWogA0EBai0AADoAACAAKAIEIAFqQQJqIANBAmotAAA6AAAgACgCBCABakEDaiADQQNqLQAAOgAAIAAoAgQhAyAFIAFBBGoiAUcNAAsLIAJFDQADQCABIANqIAEgBGotAAA6AAAgAUEBaiEBIAAoAgQhAyACQQFrIgINAAsLIAAgAyAHajYCBEEACyAEQdAAaiQADAQLIAEoAgghBSABQQxqKAIAIgQgACgCBCIDIAAoAgBraiIBIAAoAggiB0sEQEF/IAFBAXQiBhAgIgNFDQQaAkAgB0UNACAHQQNxIQJBACEBIAdBAWtBA08EQEEAIAdBfHFrIQpBASEBA0AgASADaiIHQQFrIAAoAgAgAWpBAWstAAA6AAAgByAAKAIAIAFqLQAAOgAAIAdBAWogACgCACABakEBai0AADoAACAHQQJqIAAoAgAgAWpBAmotAAA6AAAgCiABQQRqIgFqQQFHDQALIAFBAWshAQsgAkUNAANAIAEgA2ogACgCACABai0AADoAACABQQFqIQEgAkEBayICDQALCyAAIAY2AgggACgCACEBIAAgAzYCACAAIAMgACgCBCABa2oiAzYCBAsgBEUNAiAEQQNxIQIgBEEBa0EDSQRAQQAhAQwCCyAEQXxxIQdBACEBA0AgASADaiABIAVqIgMtAAA6AAAgACgCBCABakEBaiADQQFqLQAAOgAAIAAoAgQgAWpBAmogA0ECai0AADoAACAAKAIEIAFqQQNqIANBA2otAAA6AAAgACgCBCEDIAcgAUEEaiIBRw0ACwwBC0GLhgQQU0F/DAILIAJFDQADQCABIANqIAEgBWotAAA6AAAgAUEBaiEBIAAoAgQhAyACQQFrIgINAAsLIAAgAyAEajYCBEEACw8LIAAgAUHbAEHdAEECEBQPCyAAKAIMRQRAIAAgAUHbAEHdAEEDEBQPCwJ/IAEtAABBBGsiAkH/AXFBBE0EfyABIALAQQJ0QZTkBGooAgBqKAIABUEAC0UEQCAAKAIEIgEgACgCAGtBBWoiAyAAKAIIIgJLBEBBfyADQQF0IgcQICIDRQ0CGgJAIAJFDQAgAkEDcSEEQQAhASACQQFrQQNPBEBBACACQXxxayEFQQEhAQNAIAEgA2oiAkEBayAAKAIAIAFqQQFrLQAAOgAAIAIgACgCACABai0AADoAACACQQFqIAAoAgAgAWpBAWotAAA6AAAgAkECaiAAKAIAIAFqQQJqLQAAOgAAIAUgAUEEaiIBakEBRw0ACyABQQFrIQELIARFDQADQCABIANqIAAoAgAgAWotAAA6AAAgAUEBaiEBIARBAWsiBA0ACwsgACAHNgIIIAAoAgAhASAAIAM2AgAgACADIAAoAgQgAWtqIgE2AgQLIAFB8wA6AAAgACgCBEHlADoAASAAKAIEQfQAOgACIAAoAgRBKDoAAyAAKAIEQSk6AAQgACAAKAIEQQVqNgIEQQAMAQsgACABQfsAQf0AQQMQFAsPCyAAIAFB+wBB/QBBBBAUIQILIAIL9wsCBn8BfiAAKAIEIgUgACgCAGtBAWoiBiAAKAIIIgdLBEAgBkEBdCIKECAiCEUEQEF/DwsCQCAHRQ0AIAdBA3EhBkEAIQUgB0EBa0EDTwRAQQAgB0F8cWshCUEBIQUDQCAFIAhqIgdBAWsgACgCACAFakEBay0AADoAACAHIAAoAgAgBWotAAA6AAAgB0EBaiAAKAIAIAVqQQFqLQAAOgAAIAdBAmogACgCACAFakECai0AADoAACAJIAVBBGoiBWpBAUcNAAsgBUEBayEFCyAGRQ0AA0AgBSAIaiAAKAIAIAVqLQAAOgAAIAVBAWohBSAGQQFrIgYNAAsLIAAgCjYCCCAAKAIAIQUgACAINgIAIAAgCCAAKAIEIAVraiIFNgIECyAFIAI6AAAgACAAKAIEQQFqNgIEQQAhBQJAA0BBACEIIwBBEGsiCiQAAkAgAUUNAAJAAkACQCABLQAAQQVrDgMAAQIDCyAFRQRAIAEoAghFDQMgASgCBCgCACEIDAMLIAUtAABBA0cNAgJ/AkACQAJAIAUtAAFBAWsOAgACAQsgBUEIagwCC0GchQQQUwwECyAFKAIIIAUoAgwgCkEIaiICEC0NAyACCykDACILQn9TDQIgC0IBfCILIAE1AghZDQIgASgCBCALp0EDdGooAgAhCAwCCwJAIAVFBEAgASgCCCIGRQ0DIAEoAgQhAgNAIAIoAgAiBw0CIAJBBGohAiAGQQFrIgYNAAsMAwsgBRAyIQIgASgCBCACIAEoAghwIgJBAnRqIQYDQCAGKAIAIgdBCGohBiAHKAIAIAUQMw0ACyAGKAIAIgcNACABKAIIIgYgAkEBaiICTQ0CIAEoAgQhCQNAIAkgAkECdGooAgAiBw0BIAYgAkEBaiICRw0ACwwCCyAHKAIAIQgMAQsCQCAFRQRAIAEoAggiBkUNAiABKAIEIQIDQCACKAIAIgcNAiACQQRqIQIgBkEBayIGDQALDAILIAUQMiECIAEoAgQgAiABKAIIcCICQQJ0aiEGA0AgBigCACIHQQRqIQYgBygCACAFEDMNAAsgBigCACIHDQAgASgCCCIGIAJBAWoiAk0NASABKAIEIQkDQCAJIAJBAnRqKAIAIgcNASAGIAJBAWoiAkcNAAsMAQsgBygCACEICyAKQRBqJAAgCCICBEAgBQRAIAAoAgQiBSAAKAIAa0EBaiIGIAAoAggiB0sEQCAGQQF0IgoQICIIRQRAQX8PCwJAIAdFDQAgB0EDcSEGQQAhBSAHQQFrQQNPBEBBACAHQXxxayEJQQEhBQNAIAUgCGoiB0EBayAAKAIAIAVqQQFrLQAAOgAAIAcgACgCACAFai0AADoAACAHQQFqIAAoAgAgBWpBAWotAAA6AAAgB0ECaiAAKAIAIAVqQQJqLQAAOgAAIAkgBUEEaiIFakEBRw0ACyAFQQFrIQULIAZFDQADQCAFIAhqIAAoAgAgBWotAAA6AAAgBUEBaiEFIAZBAWsiBg0ACwsgACAKNgIIIAAoAgAhBSAAIAg2AgAgACAIIAAoAgQgBWtqIgU2AgQLIAVBLDoAACAAIAAoAgRBAWo2AgQLIAAgASACIgUgBBEDACICRQ0BDAILCyAAKAIEIgUgACgCAGtBAWoiAiAAKAIIIgFLBEAgAkEBdCIEECAiAkUEQEF/DwsCQCABRQ0AIAFBA3EhBkEAIQUgAUEBa0EDTwRAQQAgAUF8cWshB0EBIQUDQCACIAVqIgFBAWsgACgCACAFakEBay0AADoAACABIAAoAgAgBWotAAA6AAAgAUEBaiAAKAIAIAVqQQFqLQAAOgAAIAFBAmogACgCACAFakECai0AADoAACAHIAVBBGoiBWpBAUcNAAsgBUEBayEFCyAGRQ0AA0AgAiAFaiAAKAIAIAVqLQAAOgAAIAVBAWohBSAGQQFrIgYNAAsLIAAgBDYCCCAAKAIAIQEgACACNgIAIAAgAiAAKAIEIAFraiIFNgIECyAFIAM6AAAgACAAKAIEQQFqNgIEQQAhAgsgAgsIACAAIAIQEwvGAwEHfyMAQSBrIgYkAAJAAkACQCAAKAIQRQRAIAIQMUEERw0BCyAAIAIQEyIDRQ0BDAILIAZBGGpBADYCACAGQRBqQgA3AwAgBkIANwMIIAZBCGogAhAXIgRFBEBBfSEDDAILIAAgBBBEIgUQEyEDIAUQPSAEECEgAw0BCyAAKAIEIgMgACgCAGtBAWoiBSAAKAIIIgRLBEAgBUEBdCIIECAiBUUEQEF/IQMMAgsCQCAERQ0AIARBA3EhB0EAIQMgBEEBa0EDTwRAQQAgBEF8cWshCUEBIQMDQCADIAVqIgRBAWsgACgCACADakEBay0AADoAACAEIAAoAgAgA2otAAA6AAAgBEEBaiAAKAIAIANqQQFqLQAAOgAAIARBAmogACgCACADakECai0AADoAACAJIANBBGoiA2pBAUcNAAsgA0EBayEDCyAHRQ0AA0AgAyAFaiAAKAIAIANqLQAAOgAAIANBAWohAyAHQQFrIgcNAAsLIAAgCDYCCCAAKAIAIQMgACAFNgIAIAAgBSAAKAIEIANraiIDNgIECyADQTo6AAAgACAAKAIEQQFqNgIEIAAgASACEDQQEyEDCyAGQSBqJAAgAwv7AgEFfwJAQYAIECAiAkUNACAAQYAINgIIIAAoAgAhAyAAIAI2AgAgACACIAAoAgQgA2tqNgIEIAAgARATDQAgACgCBCIBIAAoAgBrQQFqIgMgACgCCCICSwRAIANBAXQiBRAgIgNFDQECQCACRQ0AIAJBA3EhBEEAIQEgAkEBa0EDTwRAQQAgAkF8cWshBkEBIQEDQCABIANqIgJBAWsgACgCACABakEBay0AADoAACACIAAoAgAgAWotAAA6AAAgAkEBaiAAKAIAIAFqQQFqLQAAOgAAIAJBAmogACgCACABakECai0AADoAACAGIAFBBGoiAWpBAUcNAAsgAUEBayEBCyAERQ0AA0AgASADaiAAKAIAIAFqLQAAOgAAIAFBAWohASAEQQFrIgQNAAsLIAAgBTYCCCAAKAIAIQEgACADNgIAIAAgAyAAKAIEIAFraiIBNgIECyABQQA6AAAgACAAKAIEQQFqNgIEIAAoAgAPCyAAKAIAECFBAAs4AQF/IwBBIGsiASQAIAFBGGpBADYCACABQRBqQgA3AwAgAUIANwMIIAFBCGogABAXIAFBIGokAAs5AQF/IwBBIGsiASQAIAFBEGpCgICAgBA3AwAgAUIANwMIIAFBATYCGCABQQhqIAAQFyABQSBqJAALCQBBwKUHKAIAC94CAEH4ogdB6KIHNgIAQfCiB0H0ogc2AgBB6KIHQgA3AwBB2KIHQciiBzYCAEHQogdB1KIHNgIAQciiB0IANwMAQbiiB0Googc2AgBBsKIHQbSiBzYCAEGoogdCADcDAEGYogdBiKIHNgIAQZCiB0GUogc2AgBBiKIHQgA3AwBB+KEHQeihBzYCAEHwoQdB9KEHNgIAQeihB0IANwMAQcClByAANgIAQfyiB0EANgIAQfSiB0EANgIAQdyiB0EANgIAQdSiB0EANgIAQbyiB0EANgIAQbSiB0EANgIAQZyiB0EANgIAQZSiB0EANgIAQfyhB0EANgIAQfShB0EANgIAQZijB0GIowc2AgBBkKMHQZSjBzYCAEGIowdCADcCAEHQpQdCADcDAEHYpQdCADcDAEHgpQdCADcDAEHopQdCADcDAEGcowdBADYCAEGUowdBADYCAEHIpQdBADoAAAubBwELfwJAIABBFGoiBCAAQRBqKAIARgRAIABBGGooAgAgAEEIakYNAQsgAhBTCwJAIAFBGGooAgAiAyABQQhqIgVGDQBBwKUHKAIAIAMgAygCAGpBDGpPDQAgAhBTCwJAIABBNGoiBiAAQTBqKAIARgRAIABBOGooAgAgAEEoakYNAQsgAhBTCwJAIAFBOGooAgAiAyABQShqIgdGDQBBwKUHKAIAIAMgAygCAGpBDGpPDQAgAhBTCwJAIABB1ABqIgggAEHQAGooAgBGBEAgAEHYAGooAgAgAEHIAGpGDQELIAIQUwsCQCABQdgAaigCACIDIAFByABqIglGDQBBwKUHKAIAIAMgAygCAGpBDGpPDQAgAhBTCwJAIABB9ABqIgogAEHwAGooAgBGBEAgAEH4AGooAgAgAEHoAGpGDQELIAIQUwsCQCABQfgAaigCACIDIAFB6ABqIgtGDQBBwKUHKAIAIAMgAygCAGpBDGpPDQAgAhBTCwJAIABBlAFqIgwgAEGQAWooAgBGBEAgAEGYAWooAgAgAEGIAWpGDQELIAIQUwsCQCABQZgBaigCACIDIAFBiAFqIg1GDQBBwKUHKAIAIAMgAygCAGpBDGpPDQAgAhBTCyAAQQxqQQA2AgAgAUEQaiICKAIAIgMgAEEIajYCBCAAQRxqQQA2AgAgACADNgIQIABBGGogASgCGCIDNgIAIAMgBDYCCCAAQSxqQQA2AgAgASAFNgIYIAIgAUEUajYCACABQTBqIgIoAgAiAyAAQShqNgIEIABBPGpBADYCACAAIAM2AjAgAEE4aiABKAI4IgM2AgAgAyAGNgIIIABBzABqQQA2AgAgASAHNgI4IAIgAUE0ajYCACABQdAAaiICKAIAIgMgAEHIAGo2AgQgAEHcAGpBADYCACAAIAM2AlAgAEHYAGogASgCWCIDNgIAIAMgCDYCCCAAQewAakEANgIAIAEgCTYCWCACIAFB1ABqNgIAIAFB8ABqIgIoAgAiAyAAQegAajYCBCAAQfwAakEANgIAIAAgAzYCcCAAQfgAaiABKAJ4IgM2AgAgAyAKNgIIIABBjAFqQQA2AgAgASALNgJ4IAIgAUH0AGo2AgAgAUGQAWoiAigCACIDIABBiAFqNgIEIABBnAFqQQA2AgAgACADNgKQASAAQZgBaiABKAKYASIANgIAIAAgDDYCCCABIA02ApgBIAIgAUGUAWo2AgAL4wIAQcCgB0HgoQdBi5sEEBxB+KIHQeiiBzYCAEHwogdB9KIHNgIAQeiiB0IANwMAQdiiB0HIogc2AgBB0KIHQdSiBzYCAEHIogdCADcDAEG4ogdBqKIHNgIAQbCiB0G0ogc2AgBBqKIHQgA3AwBBmKIHQYiiBzYCAEGQogdBlKIHNgIAQYiiB0IANwMAQfihB0HooQc2AgBB8KEHQfShBzYCAEHooQdCADcDAEH8ogdBADYCAEH0ogdBADYCAEHcogdBADYCAEHUogdBADYCAEG8ogdBADYCAEG0ogdBADYCAEGcogdBADYCAEGUogdBADYCAEH8oQdBADYCAEH0oQdBADYCAEGYowdBiKMHNgIAQZCjB0GUowc2AgBBiKMHQgA3AgBB0KUHQgA3AwBB2KUHQgA3AwBB4KUHQgA3AwBB6KUHQgA3AwBBnKMHQQA2AgBBlKMHQQA2AgBByKUHQQA6AAAL9wEAQdihB0HIoQc2AgBB0KEHQdShBzYCAEHIoQdCADcDAEG4oQdBqKEHNgIAQbChB0G0oQc2AgBBqKEHQgA3AwBBmKEHQYihBzYCAEGQoQdBlKEHNgIAQYihB0IANwMAQfigB0HooAc2AgBB8KAHQfSgBzYCAEHooAdCADcDAEHYoAdByKAHNgIAQdCgB0HUoAc2AgBByKAHQgA3AwBB3KEHQQA2AgBB1KEHQQA2AgBBvKEHQQA2AgBBtKEHQQA2AgBBnKEHQQA2AgBBlKEHQQA2AgBB/KAHQQA2AgBB9KAHQQA2AgBB3KAHQQA2AgBB1KAHQQA2AgALhQIAQeChB0HAoAdBvJsEEBxB2KEHQcihBzYCAEHQoQdB1KEHNgIAQcihB0IANwMAQbihB0GooQc2AgBBsKEHQbShBzYCAEGooQdCADcDAEGYoQdBiKEHNgIAQZChB0GUoQc2AgBBiKEHQgA3AwBB+KAHQeigBzYCAEHwoAdB9KAHNgIAQeigB0IANwMAQdigB0HIoAc2AgBB0KAHQdSgBzYCAEHIoAdCADcDAEHcoQdBADYCAEHUoQdBADYCAEG8oQdBADYCAEG0oQdBADYCAEGcoQdBADYCAEGUoQdBADYCAEH8oAdBADYCAEH0oAdBADYCAEHcoAdBADYCAEHUoAdBADYCAAveCAEIfwJ/AkBB5KEHKAIAIABPDQBBASEBQYSiBygCACAATw0AQQIhAUGkogcoAgAgAE8NAEEDIQFB4KIHQcSiBygCACAASQ0BGgsgAUEFdEHgoQdqCyIEQRRqIQYCQAJAIAQtAAAEQCAEQRBqKAIAIgEgBkYNASABKAIEIgAgASgCCDYCCCABKAIIIAA2AgQgAUEANgIEDAILIAQoAgQhCEHIpQctAAAEQCMAQSBrIgMkAEGAowcQIyADQQA2AhQgA0IANwMIQfCiBygCACIBIANBCGo2AgQgA0EcakEANgIAIANBEGogATYCAEH4ogcoAgAiASADQRRqIgU2AgggA0EYaiABNgIAQfiiB0Hoogc2AgBB8KIHQfSiBzYCAAJAQZCjBygCACIBQZSjB0cEQANAIAUgAygCECICRgRAA0AgASgCBCICIAEoAgg2AgggASgCCCACNgIEIAFBADYCBCABQQA2AggCQAJAQfiiBygCACICQeiiB0YNACABIAIgAigCACIFakEMakcNACACIAUgASgCAGpBDGo2AgAMAQsgAUH0ogc2AgggAiABNgIIIAEgAjYCBCABKAIIIAE2AgQLQZCjBygCACIBQZSjB0cNAAwECwALIAEgAiABIAJJGyIBKAIEIgIgASgCCDYCCCABKAIIIAI2AgQgAUEANgIEIAFBADYCCAJAAkBB+KIHKAIAIgJB6KIHRg0AIAEgAiACKAIAIgdqQQxqRw0AIAIgByABKAIAakEMajYCAAwBCyABQfSiBzYCCCACIAE2AgggASACNgIEIAEoAgggATYCBAtBkKMHKAIAIgFBlKMHRw0ACwsgAygCECIBIAVGDQADQCABKAIEIgIgASgCCDYCCCABKAIIIAI2AgQgAUEANgIEIAFBADYCCAJAAkBB+KIHKAIAIgJB6KIHRg0AIAEgAiACKAIAIgdqQQxqRw0AIAIgByABKAIAakEMajYCAAwBCyABQfSiBzYCCCACIAE2AgggASACNgIEIAEoAgggATYCBAsgAygCECIBIAVHDQALC0HIpQdBADoAACADQSBqJAALIARBEGooAgAiASAGRg0AIAAgCGpBDGohBQNAAkACfyAFIAEoAgAiAk0EQCAAIAFqIgNBFGoiBiABKAIINgIAIANBDGoiBCACIABrQQxrNgIAIAEoAgQiAiAENgIIIANBEGogAjYCACABIAA2AgAgBigCACAENgIEIAFBBGoMAQsgASgCCCEDIAAgAksNASABKAIEIgAgAzYCCCABKAIIIAA2AgQgAUEEagtBADYCAAwDCyADIgEgBkcNAAsLIAQtAAAEQCAEKAIEIQALQcClB0HApQcoAgAiASAAQQxqIgNqIgQ2AgBBxKUHKAIAIARNBEAgA0EQdkEBaiIDQABBf0YEQEGrnAQQUwtBxKUHQcSlBygCACADQRB0ajYCAAsgAUEANgIEIAEgADYCAAsgAUEANgIIIAFBDGoLgAMBBn8CfwJAIABBDGsiAygCACIFQeShBygCAE0NAEEBIQFBhKIHKAIAIAVPDQBBAiEBQaSiBygCACAFTw0AQQMhAUHgogdBxKIHKAIAIAVJDQEaCyABQQV0QeChB2oLIgJBEGohBiACQQhqIQECQAJAIAItAABFBEAgAkEUaiEEA0ACQCABIQIgBigCACIBIANPDQAgAUEIaiEGIAEgBEcNAQsLIAMgAiACKAIAIgFqQQxqRgRAIAIgASAFakEMaiIENgIAIAIgBGpBDGoiASACKAIIRw0DIAIgASgCCCIANgIIIAAgAjYCBCACIAQgASgCAGpBDGo2AgAPCyACKAIIIgYgACAFaiIERwRAIAIhAQwCCyAAQQRrIgEgBCgCCDYCACACIAM2AgggAEEIayACNgIAIAMgBSAEKAIAakEMajYCACABKAIAIAM2AgQPCyAGKAIAIQYLIABBBGsiAiAGNgIAIAEgAzYCCCAAQQhrIAE2AgAgAigCACADNgIECwsDAAAL1AcBCH8jAEFAaiIDJAACQCAAQRBqKAIAIgEgAEEUaiIGRg0AIAEoAggiAiAGRg0AIAYgAigCCEcEQCADQTxqQQA2AgAgA0E4aiADQShqIgI2AgAgA0E0aiIEQQA2AgAgA0EwaiAENgIAIAJCADcDACADQRxqQQA2AgAgA0EYaiADQQhyNgIAIANBEGogA0EUaiIHNgIAIANBADYCFCADQgA3AwhBACECA0AgASgCBCIFIAEoAgg2AgggASgCCCAFNgIEIAFBADYCBCABIAMgAkEFdGoiBUEUajYCCCAFQRhqKAIAIgUgATYCCCABIAU2AgQgASgCCCABNgIEIAJBAXMhAiAAKAIQIgEgBkcNAAsgAxAjIANBIGoQIyAAQQhqIQUCQCAHIAMoAhAiAUcEQANAIAMoAjAiAiAERg0CIAEgAiABIAJJGyIBKAIEIgIgASgCCDYCCCABKAIIIAI2AgQgAUEANgIEIAFBADYCCAJAAkAgACgCGCICIAVGDQAgASACIAIoAgAiCGpBDGpHDQAgAiAIIAEoAgBqQQxqNgIADAELIAEgBjYCCCACIAE2AgggASACNgIEIAEoAgggATYCBAsgAygCECIBIAdHDQALCyADKAIwIgEgBEYNAgNAIAEoAgQiAiABKAIINgIIIAEoAgggAjYCBCABQQA2AgQgAUEANgIIAkACQCAAKAIYIgIgBUYNACABIAIgAigCACIHakEMakcNACACIAcgASgCAGpBDGo2AgAMAQsgASAGNgIIIAIgATYCCCABIAI2AgQgASgCCCABNgIECyADKAIwIgEgBEcNAAsMAgsgASAHRg0BA0AgASgCBCICIAEoAgg2AgggASgCCCACNgIEIAFBADYCBCABQQA2AggCQAJAIAAoAhgiAiAFRg0AIAEgAiACKAIAIgRqQQxqRw0AIAIgBCABKAIAakEMajYCAAwBCyABIAY2AgggAiABNgIIIAEgAjYCBCABKAIIIAE2AgQLIAMoAhAiASAHRw0ACwwBCyABIAJLBEAgASgCBCIEIAI2AgggASgCCCAENgIEIAFBADYCBCABQQA2AggCQCAAQRhqKAIAIgIgAEEIakYNACABIAIgAigCACIAakEMakcNACACIAAgASgCAGpBDGo2AgAMAgsgASAGNgIIIAIgATYCCCABIAI2AgQgASgCCCABNgIEDAELIAEgASgCACIAakEMaiACRw0AIAIoAgQiBCAGNgIIIAIoAgggBDYCBCACQQA2AgggASAAIAIoAgBqQQxqNgIAIAJBADYCBAsgA0FAayQAC9MBAQR/An8CQCAAQQxrIgMoAgAiAkHkoQcoAgBNDQBBASEBQYSiBygCACACTw0AQQIhAUGkogcoAgAgAk8NAEEDIQFB4KIHQcSiBygCACACSQ0BGgsgAUEFdEHgoQdqCyIELQAABEAgAEEEayIBIARBEGoiAigCADYCACACIAM2AgAgAEEIayAEQQhqNgIAIAEoAgAgAzYCBA8LIABBBGsiAUGQowcoAgA2AgBBkKMHIAM2AgAgAEEIa0GIowc2AgBByKUHQQE6AAAgASgCACADNgIECwMAAAuEAgIDfwF+IwBBQGoiASQAAkAgABAxQQNHDQAgAUEANgI8AkACQAJAAkAgAC0AAUEBaw4CAQADCxBjIQIgACgCDCIDQQFqECAgACgCCCADEFgiACADakEAOgAAIAIgAEGcpgcgAUE8ahBhIAEoAjwEQEHOigQQUwsgABAhDAELEGMhAiAAKQMIIgRCgICAgAh8Qv////8PWARAIAIgBKdB+KUHIAFBPGoQbwwBCyABIAQ3AwAgAUEQakEgQdWcBCABEExBIEYEQEHqgAQQUwsQYyICIAFBEGpB+KUHIAFBPGoQYQsgASgCPARAQceABBBTCwwBC0G1hgQQUwsgAUFAayQAIAILHQECfwNAIAAgAWogAUEBaiEBLQAADQALIAFBAWsLRQECfyACBEADQCAALQAAIgMgAS0AACIESQRAQX8PCyADIARLBEBBAQ8LIAFBAWohASAAQQFqIQAgAkEBayICDQALC0EACw4AIABBMGtB/wFxQQpJCykBAX8CfyAAQQprIgFBFk0EQEEBQQEgAXRBiYCAAnENARoLIABBCUYLCyoAIABBMGtB/wFxQQpJIABBwQBrQf8BcUEGSXIgAEHhAGtB/wFxQQZJcgvIAQIEfwF+IAAgAEI/hyIGfCAGhSEGIAEhAgNAIAJBoKMHKAIAIAYgBkIKfyIGQgp+fadqLQAAOgAAIAJBAWohAiAGQgBVDQALIABCAFMEfyACQS06AAAgAkEBagUgAgtBADoAAANAIAEgBGogBEEBaiICIQQtAAANAAsgAkECRwRAQQAhBANAIAEgBGoiAy0AACEFIAMgASACakECayIDLQAAOgAAIAMgBToAACACQQNrIQMgAkEBayECIARBAWoiBCADSQ0ACwsLfAIBfgJ/IAFBAEwEQEF/DwsgASAALQAAQS1GIgRKBEAgACAEaiEAIAEgBGshAQNAIAAtAAAiBUEwa0H/AXFBCUsEQEF+DwsgAEEBaiEAIANCCn4gBa1C/wGDfEIwfSEDIAFBAWsiAQ0ACwsgAkIAIAN9IAMgBBs3AwBBAAsNACAAQYBwcUGAsANGC4cDAQN/QX8hBQJAIAFBBmogAkoNACAAIAFqIgEtAABB3ABHDQAgAUEBai0AAEH1AEcNAAJAIAFBAmotAAAiAkEwayIAQf8BcUEKSQ0AIAJB4QBrQf8BcUEFTQRAIAJB1wBrIQAMAQsgAkHBAGtB/wFxQQVLDQEgAkE3ayEACwJAIAFBA2otAAAiAkEwayIEQf8BcUEKSQ0AIAJB4QBrQf8BcUEGTwRAIAJBwQBrQf8BcUEFSw0CIAJBN2shBAwBCyACQdcAayEECwJAIAFBBGotAAAiA0EwayICQf8BcUEKSQ0AIANB4QBrQf8BcUEGTwRAIANBwQBrQf8BcUEFSw0CIANBN2shAgwBCyADQdcAayECCwJAIAFBBWotAAAiA0EwayIBQf8BcUEKSQ0AIANB4QBrQf8BcUEGTwRAIANBwQBrQf8BcUEFSw0CIANBN2shAQwBCyADQdcAayEBCyABQf8BcSACQf8BcSAEQf8BcSAAQf8BcUEEdGpBBHRqQQR0aiEFCyAFC7cBACAAQf8ATQRAIAEgADoAAEEBDwsgAEH/D00EQCABIABBP3FBgAFyOgABIAEgAEEGdkHAAXI6AABBAg8LIABB//8DTQRAIAEgAEE/cUGAAXI6AAIgASAAQQx2QeABcjoAACABIABBBnZBP3FBgAFyOgABQQMPCyABIABBP3FBgAFyOgADIAEgAEESdkHwAXI6AAAgASAAQQZ2QT9xQYABcjoAAiABIABBDHZBP3FBgAFyOgABQQQLKQEBf0EEIQECQAJAAkAgAC0AACIAQQhrDgICAAELQQIPCyAAIQELIAELqwoDB38EfAJ+AkACQAJAAkACQAJAAkACQCAALQAAQQJrDggCAwQFAAEEAgcLIAAoAggiBEUNBgNAIAAoAgQgAkECdGooAgAiAQRAA0AgASgCABAyIANqIAEoAgQQMmohAyABKAIIIgENAAsgACgCCCEECyACQQFqIgIgBEkNAAsMBgsgACgCCCIERQ0FA0AgACgCBCACQQJ0aigCACIBBEADQCABKAIAEDIgA2ohAyABKAIEIgENAAsgACgCCCEECyAEIAJBAWoiAksNAAsMBQsgAC0AAUEBcw8LIwBBEGsiBSQAAnwCQAJAAkAgAC0AAUEBaw4CAAECCyAAKQMIuQwCCwJ/IAAoAgghAyAFQQhqIQFBfyAAQQxqKAIAIgJBAEwNABpEAAAAAAAA8L9EAAAAAAAA8D8gAy0AAEEtRiIAGyEKAkAgAQJ8AkAgACACTg0AA0AgACADai0AAEEwayIBQf8BcUEJSw0BIAhEAAAAAAAAJECiIAG3oCEIIAIgAEEBaiIARw0ACyAKIAiiDAELIAogCKIiCyAAIAJGDQAaIAAgA2otAAAiAUEuRgRAAkAgAEEBaiIAIAJODQBEmpmZmZmZuT8hCANAIAAgA2otAABBMGsiAUH/AXFBCUsNASAJIAggAbeioCEJIAhEAAAAAAAAJECjIQggAiAAQQFqIgBHDQALIAsgCiAJoqAMAgsgCyAKIAmioCILIAAgAkYNARogACADai0AACEBC0F+IQYgAUEgckH/AXFB5QBHDQFBASEHAkACQAJAIAMgAEEBaiIBai0AAEEraw4DAQIAAgsgAEECaiEBQX8hBwwBCyAAQQJqIQELAkACQCABIAJODQADQCABIANqLQAAIgBBMGtB/wFxQQlLDQEgBEEKbCAAakEwayEEIAIgAUEBaiIBRw0ACwwBCyABIAJHDQILQQEhAAJAIARBAEwNACAEQQdxIQIgBEEBa0EHTwRAQQAgBEF4cWshAQNAIABBgMLXL2whACABQQhqIgENAAsLIAJFDQADQCAAQQpsIQAgAkEBayICDQALCyALIAAgB2y3ogs5AwBBACEGCyAGCwRAQZmWBBBTCyAFKwMIDAELQb2FBBBTRAAAAAAAAAAACyAFQRBqJAC9IgynIgBB/wFxQZ+6sShzQZODgAhsIABBCHZB/wFxc0GTg4AIbCAAQRB2Qf8BcXNBk4OACGwgAEEYdnNBk4OACGwgDEIgiKdB/wFxc0GTg4AIbCAMQiiIp0H/AXFzQZODgAhsIAxCMIinQf8BcXNBk4OACGwgDEI4iKdzDwsgACgCBCICRQRAQcW78oh4DwsgACgCCCEBIAJBB3EhACACQQFrQQdJBEBBxbvyiHghAwwCC0EAIAJBeHFrIQJBxbvyiHghAwNAIAFBB2otAAAgAUEGai0AACABQQVqLQAAIAFBBGotAAAgAUEDai0AACABQQJqLQAAIAFBAWotAAAgAS0AACADQZODgAhsc0GTg4AIbHNBk4OACGxzQZODgAhsc0GTg4AIbHNBk4OACGxzQZODgAhsc0GTg4AIbHMhAyABQQhqIQEgAkEIaiICDQALDAELIAAoAggiBEUNASAErUIBfSENQQQhAgNAIAStIAxWBH8gACgCBCACaigCAAVBAAsQMiADaiEDIAwgDVENAiAMQgF8IQwgAkEIaiECIAAoAgghBAwACwALIABFDQADQCABLQAAIANBk4OACGxzIQMgAUEBaiEBIABBAWsiAA0ACwsgAwvTAwIGfwN+AkAgACABRg0AQQEhBCABRQ0AQX8hBCAARQ0AQQQhA0EEIQICQAJAAkAgAC0AACIFQQhrDgICAAELQQIhAgwBCyAFIQILAkACQAJAIAEtAAAiBUEIaw4CAgABC0ECIQMMAQsgBSEDCyACIANJDQBBASEEIAIgA0sNAEEAIQQCQAJAAkACQAJAAkACQCACQQFrDgcHAAECAwQFBgsgAC0AASABLQABaw8LIAAgARA1DwsCQCAAKAIIIAEoAgggASgCBCICIAAoAgQiAyACIANJGxAoIgINAEF/IQIgACgCBCIAIAEoAgQiAUkNACAAIAFLIQILIAIPCwJ/AkAgASgCCCIEIAAiAigCCCIAIAAgBEsiBhsiAwRAIAOtIQlBASEHQQQhBUIBIQggACEDDAELQX8gBiAAIARJGwwBCwNAAkAgCEIBfSIKIAOtVAR/IAIoAgQgBWooAgAFQQALIAE1AgggClYEfyABKAIEIAVqKAIABUEACxAzIgMNACAIIAlUIQcgCCAJUQ0AIAVBCGohBSAIQgF8IQggAigCCCEDDAELCyADQX8gBiAAIARJGyAHGwsPCyAAIAEQNg8LIAAgARA3DwtB/5YEEFMLIAQLqQICA38BfiMAQRBrIgQkAAJAIABFDQACQAJAAkAgAC0AAEEFaw4DAAECAwsgAS0AAEEDRw0CAn8CQAJAAkAgAS0AAUEBaw4CAAIBCyABQQhqDAILQZyFBBBTDAQLIAEoAgggASgCDCAEQQhqIgEQLQ0DIAELKQMAIgVCAFMNAiAFIAA1AghZDQIgACgCBCAFp0EDdGooAgQhAgwCCyABEDIhAyAAKAIEIAMgACgCCHBBAnRqKAIAIgBFDQEDQCAAKAIAIAEQMwRAIAAoAggiAA0BDAMLCyAAKAIEIQIMAQsgARAyIQMgACgCBCADIAAoAghwQQJ0aigCACIARQ0AA0AgACgCACABEDMEQCAAKAIEIgANAQwCCwsgACgCACECCyAEQRBqJAAgAgveBgIGfwJ+IwBBIGsiBiQAAkACQAJAAkACQAJAIAAtAAFBAWsOAgABAwsgBiAAKQMINwMYDAELIAAoAgggAEEMaigCACAGQRhqEC0NAgsCfwJAAkACQCABLQABQQFrDgIAAgELIAFBCGoMAgtBnIUEEFMMAwsgASgCCCABQQxqKAIAIAZBEGoiAhAtDQIgAgshAEF/IQEgBikDGCIIIAApAwAiCVMNAiAIIAlVIQEMAgtBnIUEEFMLIAAQJiEAIAEQJiECIAZBADYCDAJ/IAZBDGohBAJAIAAtAAAiAUEOcUUEQCACLQAAQQ5xRQ0BCyABQQxxRQRAIAItAABBDHFFDQELIAQgBCgCAEGAAnI2AgBB/////wcMAQsCf0EAIAAgAkYNABogAi0AACIHQQJxIQQgAC0AACIBQQJxBEAgB0EBcSABQQFxIgFrIAQNARpBASABQQF0awwBCyAHQQFxQQF0QQFrIAQNABogACgCDCIFQQBMBEBB3KUEEFMgACgCDCEFCyACKAIMIQMCQCAAKAIUIAVBAnRqQQRrKAIARQRAQQAhASADQQBMBEBB3KUEEFMgAigCDCEDCyACKAIUIANBAnRqQQRrKAIARQ0BIAItAABBAXFBAXRBAWsMAgsgA0EATARAQdylBBBTIAIoAgwhAwtBASAALQAAQQFxIgVBAXRrIAIoAhQgA0ECdGpBBGsoAgBFDQEaIAItAABBAXEiASAFRwRAIAEgBWsMAgsgACgCBCAAKAIIaiIHIAIoAgQgAigCCGoiBEcEQEEAIAVBAXRrIgFBf3MgB0EBayAEQQFrSA0CGiABQQFyDAILAn8gACgCBCIEIAIoAgQiAUcEQCAEIAFrIgFBAEoEQEEAIAIoAhQgACgCFCACKAIMIAAoAgwgARBxawwCCyAAKAIUIAIoAhQgACgCDCACKAIMQQAgAWsQcQwBCyAAKAIMIgFBAWohBSABQQJ0QQRrIQMDQEEAIAVBAWsiBUEATA0BGiACKAIUIANqIQcgACgCFCADaiADQQRrIQMoAgAiBCAHKAIAIgFGDQALQX9BASABIARLGwtBASAALQAAQQFxQQF0a2whAQsgAQsLIQEgBigCDARAQdOJBBBTCyAAEGYgAhBmCyAGQSBqJAAgAQuZCwISfwN+IAAQOCEKAkAgARA4IgsoAggiDyAKKAIIIhAgDyAQSRsiEwRAA0AgEUEDdCIIIAooAgRqKAIEIAsoAgQgCGooAgQQMyIGDQIgCigCBCAIaigCBCIDEDIhAkEAIRICf0EAIAAoAgQgAiAAKAIIcEECdGooAgAiBkUNABoCQCADRQRAA0AgBigCAEUNAiAGKAIIIgYNAAtBAAwCCwJAA0AgBigCACIFIANGDQICQCAFRQ0AQQQhBEEEIQICQAJAAkAgBS0AACIHQQhrDgICAAELQQIhAgwBCyAHIQILAkACQAJAIAMtAAAiB0EIaw4CAgABC0ECIQQMAQsgByEECyACIARHDQACQAJAAkACQAJAAkACQAJAIAJBAWsOBwsGAAECAwQFCyAFIAMQNSEJDAYLIAUoAgggAygCCCADKAIEIgIgBSgCBCIEIAIgBEkbECgNBiAFKAIEIgIgAygCBCIESQ0GIAIgBEshCQwFCwJAIAMoAggiDSAFKAIIIgwgDCANSyIJGyICBEAgAq0hFUEBIQ5CASEUQQQhAiAMIQcMAQsgDCANTw0FDAYLA0BBACEEAkAgFEIBfSIWIAetVAR/IAUoAgQgAmooAgAFIAQLIAM1AgggFlYEfyADKAIEIAJqKAIABSAECxAzIgQNACAUIBVUIQ4gFCAVUQ0AIAJBCGohAiAUQgF8IRQgBSgCCCEHDAELCyAEQX8gCSAMIA1JGyAOQQFxGyEJDAQLIAUgAxA2IQkMAwsgBSADEDchCQwCC0H/lgQQUwwFCyAFLQABIAMtAAFrIQkLIAlFDQILIAYoAggiBg0AC0EADAILQQAgBkUNARoLIAYoAgQLIAsoAgQgCGooAgQiAxAyIQICQCABKAIEIAIgASgCCHBBAnRqKAIAIgZFDQACQCADRQRAA0AgBigCAEUNAiAGKAIIIgYNAAwDCwALA0AgBigCACIFIANGDQECQAJAIAVFDQBBBCEEQQQhAgJAAkACQCAFLQAAIgdBCGsOAgIAAQtBAiECDAELIAchAgsCQAJAAkAgAy0AACIHQQhrDgICAAELQQIhBAwBCyAHIQQLIAIgBEcNAAJAAkACQAJAAkACQAJAAkAgAkEBaw4HCwYAAQIDBAULIAUgAxA1IQgMBgsgBSgCCCADKAIIIAMoAgQiAiAFKAIEIgQgAiAESRsQKA0GIAUoAgQiAiADKAIEIgRJDQYgAiAESyEIDAULAkAgAygCCCINIAUoAggiDCAMIA1LIggbIgIEQCACrSEVQQEhCUIBIRRBBCECIAwhBwwBCyAMIA1PDQUMBgsDQEEAIQQCQCAUQgF9IhYgB61UBH8gBSgCBCACaigCAAUgBAsgAzUCCCAWVgR/IAMoAgQgAmooAgAFIAQLEDMiBA0AIBQgFVQhCSAUIBVRDQAgAkEIaiECIBRCAXwhFCAFKAIIIQcMAQsLIARBfyAIIAwgDUkbIAlBAXEbIQgMBAsgBSADEDYhCAwDCyAFIAMQNyEIDAILQf+WBBBTDAULIAUtAAEgAy0AAWshCAsgCEUNAQsgBigCCCIGDQEMAwsLIAZFDQELIAYoAgQhEgsgEhAzIgYNAiARQQFqIhEgE0cNAAsLQQAhBiAPIBBGDQBBf0EBIA8gEEsbDwsgCigCBCIABEACQCAKKAIIRQ0AIAAoAgAQISAKKAIIQQJJDQBBCCEAQQEhAQNAIAooAgQgAGooAgAQISAAQQhqIQAgAUEBaiIBIAooAghJDQALCyAKKAIEECELIAoQISALKAIEIgAEQAJAIAsoAghFDQAgACgCABAhIAsoAghBAkkNAEEIIQBBASEBA0AgCygCBCAAaigCABAhIABBCGohACABQQFqIgEgCygCCEkNAAsLIAsoAgQQIQsgCxAhIAYLuRICDX8DfiAAKAIMIQRBEBAgIgggBDYCDCAIQQU6AAAgCEIANwIEAkAgBEUEQAwBCyAIIARBAXQ2AgwgBEEEdBAgIQcgCCgCCARAA0AgAiAHaiAIKAIEIAJqKQIANwIAIAJBCGohAiAKQQFqIgogCCgCCEkNAAsLIAgoAgQiBARAIAQQIQsgCCAHNgIECyAAKAIIIgIEQANAIAAoAgQgDEECdGooAgAiAwRAA0AgAygCACEOIAgoAggiBiAIKAIMIgRPBEAgCCAEQQF0QQogBBsiBDYCDCAEQQN0ECAhDQJAIAgoAghFBEBBACEGDAELQQAhAkEAIQoDQCACIA1qIAgoAgQgAmopAgA3AgAgAkEIaiECIApBAWoiCiAIKAIIIgZJDQALCyAIKAIEIgQEQCAEECEgCCgCCCEGCyAIIA02AgQLIAggBkEBajYCCEEYECAiCiAGrTcDCCAKQYMCOwEAIAgoAgQiByAGQQN0aiIEIA42AgQgBCAKNgIAIAMoAgQiAw0ACyAAKAIIIQILIAxBAWoiDCACSQ0ACwsgCCgCCEECTwRAQQEhBANAIAQhCgJAIAcgBEEBayIMQQN0IgZqKAIEIAcgBEEDdCIAaigCBCIFEDNBAEwNACAFRQRAIAAgCCgCBCIAakEEaiECIAAgBmooAgQhBwNAIAIgBzYCACAKQQFrIQogAkEQayACQQhrIQIoAgAiBw0ACwwBCwNAIAgoAgQiACAKQQN0aiAAIAwiCkEDdGooAgQ2AgQgACAKQQFrIgxBA3RqKAIEIgkgBUYgCUVyDQFBBCEDQQQhBwJAAkACQCAJLQAAIgBBCGsOAgIAAQtBAiEHDAELIAAhBwsCQAJAAkAgBS0AACIAQQhrDgICAAELQQIhAwwBCyAAIQMLIAMgB0sNAUEBIQsCQCADIAdJDQACQAJAAkACQAJAAkACQCAHQQFrDgcJBgABAgMEBQsgCSAFEDUhCwwGCyAJKAIIIAUoAgggBSgCBCIGIAkoAgQiACAAIAZLGxAoIgsNBSAJKAIEIgYgBSgCBCIASQ0HIAAgBkkhCwwFCwJAIAUoAggiAiAJKAIIIgYgAiAGSSILGyIABEAgAK0hEEEBIQ1CASEPQQQhByAGIQ4MAQsgAiAGTQ0FDAcLA0BBACEDQQAhAAJAIA9CAX0iESAOrVQEfyAJKAIEIAdqKAIABSAACyAFNQIIIBFWBH8gBSgCBCAHaigCAAUgAwsQMyIADQAgDyAQVCENIA8gEFENACAHQQhqIQcgD0IBfCEPIAkoAgghDgwBCwsgAEF/IAsgAiAGSxsgDUEBcRshCwwECyAJIAUQNiELDAMLIAkgBRA3IQsMAgtB/5YEEFMMAwsgCS0AASAFLQABayELCyALQQBKDQALCyAIKAIEIgcgCkEDdGogBTYCBCAEQQFqIgQgCCgCCEkNAAsLIAEoAgwhAEEQECAiBSAANgIMIAVBBToAACAFQgA3AgQCQCAARQRAQQAhAwwBCyAFIABBAXQ2AgwgAEEEdBAgIQMgBSgCCARAQQAhAkEAIQYDQCACIANqIAUoAgQgAmopAgA3AgAgAkEIaiECIAZBAWoiBiAFKAIISQ0ACwsgBSgCBCIABEAgABAhCyAFIAM2AgQLIAEoAggiAgRAQQAhAANAIAEoAgQgAEECdGooAgAiCwRAA0AgCygCACEKIAUoAggiByAFKAIMIgRPBEAgBSAEQQF0QQogBBsiBDYCDCAEQQN0ECAhAwJAIAUoAghFBEBBACEHDAELQQAhAkEAIQYDQCACIANqIAUoAgQgAmopAgA3AgAgAkEIaiECIAZBAWoiBiAFKAIIIgdJDQALCyAFKAIEIgQEQCAEECEgBSgCCCEHCyAFIAM2AgQLIAUgB0EBajYCCEEYECAiBiAHrTcDCCAGQYMCOwEAIAUoAgQiAyAHQQN0aiIEIAo2AgQgBCAGNgIAIAsoAgQiCw0ACyABKAIIIQILIABBAWoiACACSQ0ACwsgBSgCCCICQQJPBEBBASENA0ACQCADIA0iBkEBayIAQQN0IgRqKAIEIAMgBkEDdCIBaigCBCIJEDNBAEwNACAJRQRAIAUoAgQiACABakEEaiECIAAgBGooAgQhAwNAIAIgAzYCACAGQQFrIQYgAkEQayACQQhrIQIoAgAiAw0ACwwBCwNAIAUoAgQiASAGQQN0aiABIAAiBkEDdGooAgQ2AgQgASAAQQFrIgBBA3RqKAIEIgIgCUYgAkVyDQFBBCELQQQhAwJAAkACQCACLQAAIgFBCGsOAgIAAQtBAiEDDAELIAEhAwsCQAJAAkAgCS0AACIBQQhrDgICAAELQQIhCwwBCyABIQsLIAMgC0kNAUEBIQwCQCADIAtLDQACQAJAAkACQAJAAkACQCADQQFrDgcJBgABAgMEBQsgAiAJEDUhDAwGCyACKAIIIAkoAgggCSgCBCIEIAIoAgQiASABIARLGxAoIgwNBSACKAIEIgQgCSgCBCIBSQ0HIAEgBEkhDAwFCwJAIAkoAggiByACKAIIIgogByAKSSIMGyIBBEAgAa0hEEEBIQFCASEPQQQhAyAKIQQMAQsgByAKTQ0FDAcLA0BBACELQQAhDgJAIA9CAX0iESAErVQEfyACKAIEIANqKAIABSAOCyAJNQIIIBFWBH8gCSgCBCADaigCAAUgCwsQMyIEDQAgDyAQVCEBIA8gEFENACADQQhqIQMgD0IBfCEPIAIoAgghBAwBCwsgBEF/IAwgByAKSxsgAUEBcRshDAwECyACIAkQNiEMDAMLIAIgCRA3IQwMAgtB/5YEEFMMAwsgAi0AASAJLQABayEMCyAMQQBKDQALCyAFKAIEIgMgBkEDdGogCTYCBCANQQFqIg0gBSgCCCICSQ0ACwsCQAJAIAgoAggiA0UEQEEAIQMMAQsgAkUEQCADQQBHDwsgAq0hEEEEIQZCASEPA0BBACECQQAhByAPQgF9IhEgA61UBH8gCCgCBCAGaigCAAUgBwsgECARVgR/IAUoAgQgBmooAgAFIAILEDMiBw0CIAUoAgghAiAPIAgoAggiA61aDQEgBkEIaiEGIA8gAq0iEFogD0IBfCEPRQ0ACwtBfyEHIAIgA0sNACACIANJDwsgBwvkIgIafwV+IAAoAgwhA0EQECAiCyADNgIMIAtBBToAACALQgA3AgQCQCADRQRADAELIAsgA0EBdDYCDCADQQR0ECAhBSALKAIIBEBBACEDA0AgASAFaiALKAIEIAFqKQIANwIAIAFBCGohASADQQFqIgMgCygCCEkNAAsLIAsoAgQiAwRAIAMQIQsgCyAFNgIECyAAKAIIIgEEQANAIAAoAgQgCEECdGooAgAiBARAA0AgBCgCACEXIAsoAggiAiALKAIMIgNPBEAgCyADQQF0QQogAxsiAzYCDCADQQN0ECAhEgJAIAsoAghFBEBBACECDAELQQAhAUEAIQMDQCABIBJqIAsoAgQgAWopAgA3AgAgAUEIaiEBIANBAWoiAyALKAIIIgJJDQALCyALKAIEIgMEQCADECEgCygCCCECCyALIBI2AgQLIAsgAkEBajYCCEEYECAiAyACrTcDCCADQYMCOwEAIAsoAgQiBSACQQN0aiISIBc2AgQgEiADNgIAIAQoAggiBA0ACyAAKAIIIQELIAhBAWoiCCABSQ0ACwsgCygCCEECTwRAQQEhFwNAAkAgBSAXIhJBAWsiGUEDdCIAaigCBCAFIBJBA3QiA2ooAgQiDxAzQQBMDQAgD0UEQCADIAsoAgQiA2pBBGohASAAIANqKAIEIQMDQCABIAM2AgAgEkEBayESIAFBEGsgAUEIayEBKAIAIgMNAAsMAQsDQCALKAIEIgAgEkEDdGogACAZIhJBA3RqKAIENgIEIAAgEkEBayIZQQN0aigCBCIHIA9GIAdFcg0BQQQhAUEEIQMCQAJAAkAgBy0AACIAQQhrIgUOAgIAAQtBAiEDDAELIAAhAwsCQAJAAkAgDy0AACICQQhrIgQOAgIAAQtBAiEBDAELIAIhAQsgASADSw0BQQQhAUEEIQMCQAJAAkAgBA4CAgABC0ECIQMMAQsgAiEDCwJAAkACQCAFDgICAAELQQIhAQwBCyAAIQELQQEhEwJAAkAgASADSw0AAkACQAJAAkACQAJAIABBAWsOCQkFAAECAwQBBQcLIAcgDxA1IRMMBQsgBygCCCAPKAIIIA8oAgQiACAHKAIEIgMgACADSRsQKCITDQQgBygCBCIAIA8oAgQiA0kNByAAIANLIRMMBAsCQCAPKAIIIg4gBygCCCIAIAAgDksiExsiAwRAIAOtIRxBASEEQgEhG0EEIQEgACEFDAELIAAgDk8NBAwHCwNAQQAhA0EAIQICQCAbQgF9Ih0gBa1UBH8gBygCBCABaigCAAUgAgsgDzUCCCAdVgR/IA8oAgQgAWooAgAFIAMLEDMiAw0AIBsgHFQhBCAbIBxRDQAgAUEIaiEBIBtCAXwhGyAHKAIIIQUMAQsLIANBfyATIAAgDkkbIARBAXEbIRMMAwsgByAPEDYhEwwCCyAHKAIMIQBBEBAgIgogADYCDCAKQQU6AAAgCkIANwIEAkAgAEUEQEEAIQQMAQsgCiAAQQF0NgIMIABBBHQQICEEIAooAggEQEEAIQFBACEDA0AgASAEaiAKKAIEIAFqKQIANwIAIAFBCGohASADQQFqIgMgCigCCEkNAAsLIAooAgQiAARAIAAQIQsgCiAENgIECyAHKAIIIgEEQEEAIQ4DQCAHKAIEIA5BAnRqKAIAIgIEQANAIAIoAgAhCCAKKAIIIgUgCigCDCIATwRAIAogAEEBdEEKIAAbIgA2AgwgAEEDdBAgIQACQCAKKAIIRQRAQQAhBQwBC0EAIQFBACEDA0AgACABaiAKKAIEIAFqKQIANwIAIAFBCGohASADQQFqIgMgCigCCCIFSQ0ACwsgCigCBCIDBEAgAxAhIAooAgghBQsgCiAANgIECyAKIAVBAWo2AghBGBAgIgAgBa03AwggAEGDAjsBACAKKAIEIgQgBUEDdGoiAyAINgIEIAMgADYCACACKAIEIgINAAsgBygCCCEBCyAOQQFqIg4gAUkNAAsLIAooAghBAk8EQEEBIQ4DQAJAIAQgDiIDQQFrIgBBA3QiAmooAgQgBCADQQN0IgVqKAIEIgYQM0EATA0AIAZFBEAgCigCBCIAIAVqQQRqIQEgACACaigCBCEEA0AgASAENgIAIANBAWshAyABQRBrIAFBCGshASgCACIEDQALDAELA0AgCigCBCICIANBA3RqIAIgACIDQQN0aigCBDYCBCACIABBAWsiAEEDdGooAgQiCSAGRiAJRXINAUEEIQJBBCEEAkACQAJAIAktAAAiBUEIaw4CAgABC0ECIQQMAQsgBSEECwJAAkACQCAGLQAAIgVBCGsOAgIAAQtBAiECDAELIAUhAgsgAiAESw0BQQEhCAJAIAIgBEkNAAJAAkACQAJAAkACQAJAIARBAWsOBwkGAAECAwQFCyAJIAYQNSEIDAYLIAkoAgggBigCCCAGKAIEIgIgCSgCBCIFIAIgBUkbECgiCA0FIAkoAgQiAiAGKAIEIgVJDQcgAiAFSyEIDAULAkAgBigCCCIQIAkoAggiBSAFIBBLIggbIgIEQCACrSEdQgAhG0EBIREgBSEEDAELIAUgEE8NBQwHCwNAAkACQAJ/IAStIBtWBEAgCSgCBCAbpyICQQN0aigCBCIEIBsgBjUCCFQNARogBEUNAkEBIQEMAwsgGyAGNQIIWg0BIBunIQJBAAshBCAEIAYoAgQgAkEDdGooAgQiDEYNAEEBIQEgDEUNASAERQRAQX8hAQwCC0EEIRRBBCEHAkACQAJAIAQtAAAiAkEIaw4CAgABC0ECIQcMAQsgAiEHCwJAAkACQCAMLQAAIgJBCGsOAgIAAQtBAiEUDAELIAIhFAsgByAUSQRAQX8hAQwCCyAHIBRLDQECQAJAAkACQAJAAkACQAJAIAdBAWsOBwgGAQIDBAUAC0H/lgQQUwwHCyAEIAwQNSEBDAULIAQoAgggDCgCCCAMKAIEIgIgBCgCBCIBIAEgAksbECgiAQ0GIAQoAgQiAiAMKAIEIgFJBEBBfyEBDAcLIAEgAkkhAQwECwJAIAwoAggiFSAEKAIIIgIgAiAVSyIBGyIHBEAgB60hHkEBIRZBBCEHQgEhHCACIRgMAQsgAiAVTw0EQX8hAQwGCwNAQQAhFEEAIQ0CQCAcQgF9Ih8gGK1UBH8gBCgCBCAHaigCAAUgDQsgDDUCCCAfVgR/IAwoAgQgB2ooAgAFIBQLEDMiFA0AIBwgHlQhFiAcIB5RDQAgHEIBfCEcIAdBCGohByAEKAIIIRgMAQsLIBRBfyABIAIgFUkbIBYbIQEMAwsgBCAMEDYhAQwCCyAEIAwQNyEBDAELIAQtAAEgDC0AAWshAQsgAQ0BCyAbQgF8IhsgHVQhESAbIB1RBEBBACEBBSAJKAIIIQQMAgsLCyABQX8gCCAFIBBJGyARQQFxGyEIDAQLIAkgBhA2IQgMAwsgCSAGEDchCAwCC0H/lgQQUwwDCyAJLQABIAYtAAFrIQgLIAhBAEoNAAsLIAooAgQiBCADQQN0aiAGNgIEIA5BAWoiDiAKKAIISQ0ACwsgDygCDCEAQRAQICIGIAA2AgwgBkEFOgAAIAZCADcCBAJAIABFBEBBACECDAELIAYgAEEBdDYCDCAAQQR0ECAhAiAGKAIIBEBBACEBQQAhBQNAIAEgAmogBigCBCABaikCADcCACABQQhqIQEgBUEBaiIFIAYoAghJDQALCyAGKAIEIgAEQCAAECELIAYgAjYCBAsgDygCCCIBBEBBACEOA0AgDygCBCAOQQJ0aigCACIIBEADQCAIKAIAIQMgBigCCCIEIAYoAgwiAE8EQCAGIABBAXRBCiAAGyIANgIMIABBA3QQICEAAkAgBigCCEUEQEEAIQQMAQtBACEBQQAhBQNAIAAgAWogBigCBCABaikCADcCACABQQhqIQEgBUEBaiIFIAYoAggiBEkNAAsLIAYoAgQiAgRAIAIQISAGKAIIIQQLIAYgADYCBAsgBiAEQQFqNgIIQRgQICIAIAStNwMIIABBgwI7AQAgBigCBCICIARBA3RqIgUgAzYCBCAFIAA2AgAgCCgCBCIIDQALIA8oAgghAQsgDkEBaiIOIAFJDQALCyAGKAIIIgFBAk8EQEEBIQcDQAJAIAIgByIFQQFrIg5BA3QiAGooAgQgAiAFQQN0IgNqKAIEIgkQM0EATA0AIAlFBEAgAyAGKAIEIgNqQQRqIQEgACADaigCBCECA0AgASACNgIAIAVBAWshBSABQRBrIAFBCGshASgCACICDQALDAELA0AgBigCBCIAIAVBA3RqIAAgDiIFQQN0aigCBDYCBCAAIAVBAWsiDkEDdGooAgQiDCAJRiAMRXINAUEEIQhBBCECAkACQAJAIAwtAAAiAEEIaw4CAgABC0ECIQIMAQsgACECCwJAAkACQCAJLQAAIgBBCGsOAgIAAQtBAiEIDAELIAAhCAsgAiAISQ0BQQEhAAJAIAIgCEsNAAJAAkACQAJAAkACQAJAIAJBAWsOBwkGAAECAwQFCyAMIAkQNSEADAYLIAwoAgggCSgCCCAJKAIEIgAgDCgCBCIDIAAgA0kbECgiAA0FIAwoAgQiACAJKAIEIgNJDQcgACADSyEADAULAkAgCSgCCCIVIAwoAggiAyADIBVLIgAbIgIEQCACrSEdQgAhG0EBIRQgAyECDAELIAMgFU8NBQwHCwNAAkACQAJ/IAKtIBtWBEAgDCgCBCAbpyIIQQN0aigCBCICIBsgCTUCCFQNARogAkUNAkEBIQ0MAwsgGyAJNQIIWg0BIBunIQhBAAshAiACIAkoAgQgCEEDdGooAgQiEEYNAEEBIQ0gEEUNASACRQRAQX8hDQwCC0EEIQFBBCERAkACQAJAIAItAAAiBEEIaw4CAgABC0ECIREMAQsgBCERCwJAAkACQCAQLQAAIgRBCGsOAgIAAQtBAiEBDAELIAQhAQsgASARSwRAQX8hDQwCCyABIBFJDQECQAJAAkACQAJAAkACQAJAIBFBAWsOBwgGAQIDBAUAC0H/lgQQUwwHCyACIBAQNSENDAULIAIoAgggECgCCCAQKAIEIgEgAigCBCIEIAEgBEkbECgiDQ0GIAIoAgQiAiAQKAIEIgFJBEBBfyENDAcLIAEgAkkhDQwECwJAIBAoAggiFiACKAIIIgQgBCAWSyINGyIBBEAgAa0hHkEBIRpBBCERQgEhHCAEIQgMAQsgBCAWTw0EQX8hDQwGCwNAQQAhAUEAIRgCQCAcQgF9Ih8gCK1UBH8gAigCBCARaigCAAUgGAsgEDUCCCAfVgR/IBAoAgQgEWooAgAFIAELEDMiAQ0AIBwgHlQhGiAcIB5RDQAgHEIBfCEcIBFBCGohESACKAIIIQgMAQsLIAFBfyANIAQgFkkbIBobIQ0MAwsgAiAQEDYhDQwCCyACIBAQNyENDAELIAItAAEgEC0AAWshDQsgDQ0BCyAbQgF8IhsgHVQhFCAbIB1RBEBBACENBSAMKAIIIQIMAgsLCyANQX8gACADIBVJGyAUQQFxGyEADAQLIAwgCRA2IQAMAwsgDCAJEDchAAwCC0H/lgQQUwwDCyAMLQABIAktAAFrIQALIABBAEoNAAsLIAYoAgQiAiAFQQN0aiAJNgIEIAdBAWoiByAGKAIIIgFJDQALCyAKKAIIIgJFDQQgAUUNAUEAIQFBBCEFA0BBACEEIAEgAkkEfyAKKAIEIAVqKAIABSAECyAGKAIEIAVqKAIAEDMiEw0CIAYoAgghACABQQFqIgEgCigCCCICSQRAIAVBCGohBSAAIAFLDQELC0EBIRMgACACSQ0BDAQLIActAAEgDy0AAWshEwsgE0EASg0BDAILC0H/lgQQUwsgCygCBCIFIBJBA3RqIA82AgQgF0EBaiIXIAsoAghJDQALCyALC5IBAQN/AkAgACgCBCIEBEACfwJAIAAoAghFDQBBBCECQQEhAwNAIAIgBGpBBGsoAgAgARA6IAAoAgQgAmooAgAgARA6IAMgACgCCE8NASACQQhqIQIgA0EBaiEDIAAoAgQhBAwACwALIAAoAgQiAiABRQ0AGiACECQgABAkDwsQIQwBCyABRQ0AIAAQJA8LIAAQIQvEAQEBfwJAAkACQAJAAkACQAJAAkACQCAALQAAQQFrDgcAAAECAwQFBwsgAUUNBwwFCwJAAkAgAC0AAUECRw0AIAAtABBFDQAgACgCCCECIAFFDQEgAhAkDAYLIAFFDQcMBQsgAhAhDAYLAkAgAC0AAQRAIAAoAgghAiABRQ0BIAIQJAwFCyABRQ0GDAQLIAIQISAAECEPCyAAIAEQOQ8LIAAgARA7IAFFDQMMAQsgACABEDwgAUUNAgsgABAkCw8LIAAQIQuqBQEEfwJAIAAoAggiA0UNACABRQRAA0AgACgCBCAEQQJ0aigCACIFBEBBACEDA0AgAwRAAkACQAJAAkACQAJAAkAgAygCACICLQAAQQFrDgcFBQABAgMEBgsgAi0AAUECRw0EIAItABBFDQQgAigCCBAhDAQLIAItAAFFDQMgAigCCBAhDAMLIAJBABA5DAMLIAJBABA7DAELIAJBABA8CyACECELAkACQAJAAkACQAJAAkAgAygCBCICLQAAQQFrDgcFBQABAgMEBgsgAi0AAUECRw0EIAItABBFDQQgAigCCBAhDAQLIAItAAFFDQMgAigCCBAhDAMLIAJBABA5DAMLIAJBABA7DAELIAJBABA8CyACECELIAMQIQsgBSIDKAIIIgUNAAsgAygCAEEAEDogAygCBEEAEDogAxAhIAAoAgghAwsgBEEBaiIEIANJDQALDAELA0AgACgCBCAEQQJ0aigCACIFBEBBACEDA0AgAwRAAkACQAJAAkACQAJAAkAgAygCACICLQAAQQFrDgcFBQABAgMEBgsgAi0AAUECRw0EIAItABBFDQQgAigCCBAkDAQLIAItAAFFDQMgAigCCBAkDAMLIAJBARA5DAMLIAJBARA7DAELIAJBARA8CyACECQLAkACQAJAAkACQAJAAkAgAygCBCICLQAAQQFrDgcFBQABAgMEBgsgAi0AAUECRw0EIAItABBFDQQgAigCCBAkDAQLIAItAAFFDQMgAigCCBAkDAMLIAJBARA5DAMLIAJBARA7DAELIAJBARA8CyACECQLIAMQJAsgBSIDKAIIIgUNAAsgAygCAEEBEDogAygCBEEBEDogAxAkIAAoAgghAwsgBEEBaiIEIANJDQALCyAAKAIEIQAgAQRAIAAQJA8LIAAQIQu0AwEEfwJAIAAoAggiA0UNACABRQRAA0AgACgCBCAEQQJ0aigCACIFBEBBACEDA0AgAwRAAkACQAJAAkACQAJAAkAgAygCACICLQAAQQFrDgcFBQABAgMEBgsgAi0AAUECRw0EIAItABBFDQQgAigCCBAhDAQLIAItAAFFDQMgAigCCBAhDAMLIAJBABA5DAMLIAJBABA7DAELIAJBABA8CyACECELIAMQIQsgBSIDKAIEIgUNAAsgAygCAEEAEDogAxAhIAAoAgghAwsgBEEBaiIEIANJDQALDAELA0AgACgCBCAEQQJ0aigCACIFBEBBACEDA0AgAwRAAkACQAJAAkACQAJAAkAgAygCACICLQAAQQFrDgcFBQABAgMEBgsgAi0AAUECRw0EIAItABBFDQQgAigCCBAkDAQLIAItAAFFDQMgAigCCBAkDAMLIAJBARA5DAMLIAJBARA7DAELIAJBARA8CyACECQLIAMQJAsgBSIDKAIEIgUNAAsgAygCAEEBEDogAxAkIAAoAgghAwsgBEEBaiIEIANJDQALCyAAKAIEIQAgAQRAIAAQJA8LIAAQIQsIACAAQQAQOgv8CAIPfwN+IAEQMiEPIAAoAgQgDyAAKAIIcEECdGooAgAiBARAA0AgBCgCACABEDNFBEAgAwRAIAFBABA6CyAEIAI2AgQPCyAEKAIIIgQNAAsLIAAoAgxBAWq4IAAoAggiA7hEZmZmZmZm5j+iZUUEQEEQECAiBkEGOgAAIANBA3QQICEEIAZBADYCDEEBIQUgBiADQQF0IgM2AgggBiAENgIEIAMEQCAEQQA2AgAgA0EBayELIANBAmtBA08EQCALQXxxIQVBECEDQQAhBANAIAYoAgQgA2pBDGtBADYCACAGKAIEIANqQQhrQQA2AgAgBigCBCADakEEa0EANgIAIAYoAgQgA2pBADYCACADQRBqIQMgBSAEQQRqIgRHDQALIARBAWohBQsgC0EDcSEEIAVBAnQhAwNAIAYoAgQgA2pBADYCACADQQRqIQMgBEEBayIEDQALCyAAKAIIIgMEQANAIAAoAgQgDEECdGooAgAiDQRAA0AgDSILKAIIIQ0gCygCABAyIQNBACEEAkAgBigCBCADIAYoAghwQQJ0aiIQKAIAIgNFDQADQAJAIAsoAgAiByADKAIAIghGIAhFcg0AIAdFBEAgAyEEDAMLQQQhCUEEIQUCQAJAAkAgBy0AACIKQQhrDgICAAELQQIhBQwBCyAKIQULAkACQAJAIAgtAAAiCkEIaw4CAgABC0ECIQkMAQsgCiEJCyAFIAlJBEAgAyEEDAMLIAUgCUsNAAJAAkACQAJAAkACQAJAAkAgBUEBaw4HCAUAAQIDBAcLIAcgCBA1IQUMBQsgBygCCCAIKAIIIAgoAgQiBSAHKAIEIgkgBSAJSRsQKCIFDQQgBygCBCAIKAIETw0GIAMhBAwICwJAIAgoAggiDiAHKAIIIgkgCSAOSyISGyIFBEAgBa0hFEEBIRFBBCEFQgEhEyAJIQoMAQsgCSAOTw0GIAMhBAwICwNAAkAgE0IBfSIVIAqtVAR/IAcoAgQgBWooAgAFQQALIAg1AgggFVYEfyAIKAIEIAVqKAIABUEACxAzIgoNACATIBRUIREgEyAUUQ0AIBNCAXwhEyAFQQhqIQUgBygCCCEKDAELCyAKQX8gEiAJIA5JGyARGyEFDAMLIAcgCBA2IQUMAgsgByAIEDchBQwBCyAHLQABIAgtAAFrIQULIAVBAE4NASADIQQMAwtB/5YEEFMLIANBCGohECADKAIIIgMNAAsLIBAgCzYCACALIAQ2AgggBiAGKAIMQQFqNgIMIA0NAAsgACgCCCEDCyAMQQFqIgwgA0kNAAsLIAAoAgQQISAAIAYpAgQ3AgQgBhAhC0EMECAiAyACNgIEIAMgATYCACADQQA2AggCQCAAKAIEIA8gACgCCHBBAnRqIgIoAgAiBEUEQEEAIQQMAQsgASAEKAIAEDNBAEgNAAJAA0AgBCIBKAIIIgQEQCADKAIAIAQoAgAQM0EATg0BDAILC0EAIQQLIAFBCGohAgsgAiADNgIAIAMgBDYCCCAAIAAoAgxBAWo2AgwLDAAgACABIAJBABA+Cw0AQYenB0GJpwcgABsLGQEBf0EYECAiASAANwMIIAFBgwI7AQAgAQvkCAIQfwN+IAEQMiEOAkAgACgCBCAOIAAoAghwQQJ0aigCACIDBEADQCADKAIAIAEQM0UNAiADKAIEIgMNAAsLIAAoAgxBAWq4IAAoAggiArhEZmZmZmZm5j+iZUUEQEEQECAiBkEHOgAAIAJBA3QQICEDIAZBADYCDEEBIQQgBiACQQF0IgI2AgggBiADNgIEIAIEQCADQQA2AgAgAkEBayEKIAJBAmtBA08EQCAKQXxxIQVBECECQQAhAwNAIAYoAgQgAmpBDGtBADYCACAGKAIEIAJqQQhrQQA2AgAgBigCBCACakEEa0EANgIAIAYoAgQgAmpBADYCACACQRBqIQIgBSADQQRqIgNHDQALIANBAWohBAsgCkEDcSEDIARBAnQhAgNAIAYoAgQgAmpBADYCACACQQRqIQIgA0EBayIDDQALCyAAKAIIIgIEQANAIAAoAgQgDEECdGooAgAiCgRAA0AgCiILKAIEIQogCygCABAyIQJBACEDAkAgBigCBCACIAYoAghwQQJ0aiIPKAIAIgJFDQADQAJAIAsoAgAiByACKAIAIghGIAhFcg0AIAdFBEAgAiEDDAMLQQQhCUEEIQQCQAJAAkAgBy0AACIFQQhrDgICAAELQQIhBAwBCyAFIQQLAkACQAJAIAgtAAAiBUEIaw4CAgABC0ECIQkMAQsgBSEJCyAEIAlJBEAgAiEDDAMLIAQgCUsNAAJAAkACQAJAAkACQAJAAkAgBEEBaw4HCAUAAQIDBAcLIAcgCBA1IQQMBQsgBygCCCAIKAIIIAgoAgQiCSAHKAIEIgUgBSAJSxsQKCIEDQQgBygCBCAIKAIETw0GIAIhAwwICwJAIAgoAggiDSAHKAIIIgkgCSANSyIRGyIFBEAgBa0hE0EBIRBBBCEEQgEhEiAJIQUMAQsgCSANTw0GIAIhAwwICwNAAkAgEkIBfSIUIAWtVAR/IAcoAgQgBGooAgAFQQALIAg1AgggFFYEfyAIKAIEIARqKAIABUEACxAzIgUNACASIBNUIRAgEiATUQ0AIBJCAXwhEiAEQQhqIQQgBygCCCEFDAELCyAFQX8gESAJIA1JGyAQGyEEDAMLIAcgCBA2IQQMAgsgByAIEDchBAwBCyAHLQABIAgtAAFrIQQLIARBAE4NASACIQMMAwtB/5YEEFMLIAJBBGohDyACKAIEIgINAAsLIA8gCzYCACALIAM2AgQgBiAGKAIMQQFqNgIMIAoNAAsgACgCCCECCyAMQQFqIgwgAkkNAAsLIAAoAgQQISAAIAYpAgQ3AgQgBhAhC0EIECAiBSABNgIAIAVBADYCBAJAIAAoAgQgDiAAKAIIcEECdGoiAigCACIDRQRAQQAhAwwBCyABIAMoAgAQM0EASA0AAkADQCADIgEoAgQiAwRAIAUoAgAgAygCABAzQQBODQEMAgsLQQAhAwsgAUEEaiECCyACIAU2AgAgBSADNgIEIAAgACgCDEEBajYCDAsLAwAACyUBAn9BDBAgIgFBBDsBACAAECchAiABIAA2AgggASACNgIEIAELIAEBf0EMECAiAiAANgIIIAIgATYCBCACQYQCOwEAIAILcAECf0EQECAiAEEGOgAAIABBIBAgIgE2AgQgAUEANgIAIABCCDcCCCAAKAIEQQA2AgQgACgCBEEANgIIIAAoAgRBADYCDCAAKAIEQQA2AhAgACgCBEEANgIUIAAoAgRBADYCGCAAKAIEQQA2AhwgAAtwAQJ/QRAQICIAQQc6AAAgAEEgECAiATYCBCABQQA2AgAgAEIINwIIIAAoAgRBADYCBCAAKAIEQQA2AgggACgCBEEANgIMIAAoAgRBADYCECAAKAIEQQA2AhQgACgCBEEANgIYIAAoAgRBADYCHCAAC9oEAQd/QQMhCAJAIAFFDQAgAS0AACIEQQVHIARB/gFxQQhGcg0AIAEoAggiBUUNACAFQQJOBEAgBUEBayEDIAEoAgRBBGohBgNAAkAgBigCAC0AAEEEaw4FAAMDAwADCyAGQQhqIQYgA0EBayIDDQALCyAFQQBMDQAgBUEBayEJAkAgBUEBRgRAQQEhBSAAIQQMAQsDQEEAIQMgBSAHSwRAIAEoAgQgB0EDdGooAgQhAwsgACADEDQiBEUEQCAALQAAQQZHBEBBAg8LQRAQICIEQQY6AAAgBEEgECAiBjYCBEEAIQggBkEANgIAIARCCDcCCCAEKAIEQQA2AgQgBCgCBEEANgIIIAQoAgRBADYCDCAEKAIEQQA2AhAgBCgCBEEANgIUIAQoAgRBADYCGCAEKAIEQQA2AhwgAygCBBAgIQUgAygCBARAQQAhBgNAIAUgBmogAygCCCAGai0AADoAACAGQQFqIgYgAygCBCIISQ0ACwtBDBAgIgMgBTYCCCADIAg2AgQgA0GEAjsBACAAIAMgBEEBED4LIAEoAgghBSAEIQAgB0EBaiIHIAlHDQALC0EAIQMgBSAJSwRAIAEoAgQgCUEDdGooAgQhAwsgBCADEDQhBUECIQggBC0AAEEGRw0AIAMoAgQQICEHQQAhCEEAIQEgAygCBARAQQAhBgNAIAYgB2ogAygCCCAGai0AADoAACAGQQFqIgYgAygCBCIBSQ0ACwtBDBAgIgAgBzYCCCAAIAE2AgQgAEGEAjsBACAEIAAgAkEBED4gBUUNACAFQQEQOgsgCAv6AgEEf0EDIQQCQAJAIAFFDQAgAS0AACICQQVHIAJB/gFxQQhGcg0AIAEoAggiA0UNACADQQJOBEAgA0EBayEFIAEoAgRBBGohAgNAAkAgAigCAC0AAEEEaw4FAAMDAwADCyACQQhqIQIgBUEBayIFDQALCyADQQBMDQAgA0EBayEFIANBAUYEQEEBIQMMAgtBACECQQQhBANAIAAgAiADSQR/IAEoAgQgBGooAgAFQQALEDQiAARAIARBCGohBCABKAIIIQMgBSACQQFqIgJGDQMMAQsLQQAhBAsgBA8LIAAhAiADIAVLBH8gASgCBCAFQQN0aigCBAVBAAsiAxAyIQACQCACKAIEIAAgAigCCHBBAnRqIgEoAgAiAEUNACAAKAIAIAMQMwR/A0AgACIBKAIIIgBFDQIgACgCACADEDMNAAsgAUEIagUgAQsgACgCCDYCACACIAIoAgxBAWs2AgwgACgCAEEBEDogACgCBEEBEDogABAkC0EACwMAAAsDAAALsxsCD38EfiMAQRBrIhIkACASIAM2AgwCfyABIQcgAiEFIAMhBiMAQSBrIg4kAEEHQQggACIIGyEJA0AgBUECaiECA0ACQCAFLQAAIgAEQCAAQSVHDQFBACEAA0ACQEEBIQUCQAJAAkACQAJAIAJBAWsiCiwAACIBQSBrDhECBQUDBQUFBQUFBQEFAAUFBAULQQIhBQwDC0EEIQUMAgtBCCEFDAELQRAhBQsgAkEBaiECIAAgBXIhAAwBCwsCQCABQTBrQf8BcUEJTQRAQQAhBQNAIAVBCmwgAUH/AXFqQTBrIQUgCkEBaiIKLQAAIgFBMGtB/wFxQQpJDQALIAohAgwBC0EAIQUgAUEqRwRAIAohAgwBCyAAQQJyIAAgBigCACIBQQBIGyEAIAEgAUEfdSIDaiADcyEFIAZBBGohBiACLQAAIQELQQAhDAJAIAFB/wFxQS5HBEAgAiEKDAELIAJBAWohCiAAQYAIciEAIAItAAEiAUEwa0H/AXFBCU0EQANAIAxBCmwgAUH/AXFqQTBrIQwgCkEBaiIKLQAAIgFBMGtB/wFxQQpJDQALDAELIAFB/wFxQSpHDQAgBigCACIBQQAgAUEAShshDCACQQJqIQogBkEEaiEGIAItAAIhAQtBASEDQYACIQICQAJAAkACQAJAIAHAQegAa0Efdw4KAQIABAQEAwQEAwQLIAotAAEiAUHsAEcEQCAKQQFqIQogAEGAAnIhAAwEC0ECIQNBgAYhAgwCCyAKLQABIgFB6ABHBEAgCkEBaiEKIABBgAFyIQAMAwtBAiEDQcABIQIMAQtBgAQhAgsgACACciEAIAMgCmoiCi0AACEBCwJAAkACQAJAAkACQAJAAkACQAJAIAHAIgJBJWsOVAYHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHAgECBwcHBwcHBwcHBwcHBwcHBwAHBwcHBwcHBwcAAwACAQIHAAcHBwcHAAUHBwQHAAcHAAcLQQghA0EQIQICQAJAAkACQAJAIAFB/wFxIgFB2ABrDiEBAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAMAAAAAAAAAAAEACyAAQW9xIQBBCiECCyAAQSByIAAgAUHYAEYbIQAgAiEDIAFB5ABrDgYCAQEBAQIBC0ECIQMLIABBc3EhACADIQILIABBfnEgACAAQYAIcRshAAJAAkAgAUHkAGsOBgABAQEBAAELIABBgARxBEACQCAAIABBb3EgBkEHakF4cSIGKQMAIhRCAFIbIgNBgAhxBEBBACEBIBRQDQELIAKtIRUgFCAUQj+HIhN8IBOFIRMgA0EgcUHhAHNB9gFqIQ1BACEAA0AgACAOakEwIA0gEyATIBWAIhYgFX59pyIBQf4BcUEKSRsgAWo6AAAgAEEBaiEBIBMgFVQNASAAQR9JIAEhACAWIRMNAAsLIAZBCGohBiAJIAggBCAHIA4gASAUQj+IpyACIAwgBSADEE8hBCAKQQFqIQUMDgsgAEGAAnEEQAJAIAAgAEFvcSAGKAIAIgsbIg9BgAhxBEBBACEDIAtFDQELIAsgC0EfdSIAaiAAcyEAIA9BIHFB4QBzQfYBaiEQQQAhAQNAIAEgDmpBMCAQIAAgACACbiINIAJsayIDQf4BcUEKSRsgA2o6AAAgAUEBaiEDIAAgAkkNASABQR9JIAMhASANIQANAAsLIAZBBGohBiAJIAggBCAHIA4gAyALQR92IAIgDCAFIA8QTyEEIApBAWohBQwOCwJAIAAgAEFvcQJ/IABBwABxBEAgBiwAAAwBCyAGKAIAIgEgAEGAAXFFDQAaIAHBCyILGyIPQYAIcQRAQQAhAyALRQ0BCyALIAtBH3UiAGogAHMhACAPQSBxQeEAc0H2AWohEEEAIQEDQCABIA5qQTAgECAAIAAgAm4iDSACbGsiA0H+AXFBCkkbIANqOgAAIAFBAWohAyAAIAJJDQEgAUEfSSADIQEgDSEADQALCyAGQQRqIQYgCSAIIAQgByAOIAMgC0EfdiACIAwgBSAPEE8hBCAKQQFqIQUMDQsgAEGABHEEQAJAIAAgAEFvcSAGQQdqQXhxIgYpAwAiE0IAUhsiA0GACHEEQEEAIQEgE1ANAQsgAq0hFCADQSBxQeEAc0H2AWohDUEAIQADQCAAIA5qQTAgDSATIBMgFIAiFiAUfn2nIgFB/gFxQQpJGyABajoAACAAQQFqIQEgEyAUVA0BIABBH0kgASEAIBYhEw0ACwsgBkEIaiEGIAkgCCAEIAcgDiABQQAgAiAMIAUgAxBPIQQgCkEBaiEFDA0LIABBgAJxBEACQCAAIABBb3EgBigCACIBGyILQYAIcQRAQQAhAyABRQ0BCyALQSBxQeEAc0H2AWohD0EAIQADQCAAIA5qQTAgDyABIAEgAm4iDSACbGsiA0H+AXFBCkkbIANqOgAAIABBAWohAyABIAJJDQEgAEEfSSADIQAgDSEBDQALCyAGQQRqIQYgCSAIIAQgByAOIANBACACIAwgBSALEE8hBCAKQQFqIQUMDQsCQCAAIABBb3ECfyAAQcAAcQRAIAYtAAAMAQsgBigCACIBQf//A3EgASAAQYABcRsLIgEbIgtBgAhxBEBBACEDIAFFDQELIAtBIHFB4QBzQfYBaiEPQQAhAANAIAAgDmpBMCAPIAEgASACbiINIAJsayIDQf4BcUEKSRsgA2o6AAAgAEEBaiEDIAEgAkkNASAAQR9JIAMhACANIQENAAsLIAZBBGohBiAJIAggBCAHIA4gA0EAIAIgDCAFIAsQTyEEIApBAWohBQwMCyAGQQdqQXhxIgJBCGohBiAJIAggBCAHIAIrAwAgDCAFIABBIHIgACABQf8BcUHGAEYbEFAhBCAKQQFqIQUMCwsgAEGAEHIgACABQSByQf8BcUHnAEYbIQACQAJAIAFB/wFxQcUAaw4DAAEAAQsgAEEgciEACyAGQQdqQXhxIgFBCGohBiAJIAggBCAHIAErAwAgDCAFIAAQUSEEIApBAWohBQwKC0EBIQICQCAAQQJxIgMNAEECIQIgBUECSQ0AIAVBAWsiAEEDcSEBIAVBAmtBA08EQCAAQXxxIQ1BACEAA0BBICAIIAAgBGoiAiAHIAkRAABBICAIIAJBAWogByAJEQAAQSAgCCACQQJqIAcgCREAAEEgIAggAkEDaiAHIAkRAAAgDSAAQQRqIgBHDQALIAAgBGohBAsgBUEBaiECIAFFDQADQEEgIAggBCAHIAkRAAAgBEEBaiEEIAFBAWsiAQ0ACwsgBiwAACAIIAQgByAJEQAAIARBAWohBCAGQQRqIQYgA0UgAiAFT3INBSAFIAJBf3NqIAUgAmtBA3EiAARAA0BBICAIIAQgByAJEQAAIARBAWohBCACQQFqIQIgAEEBayIADQALC0EDSQ0FIAUgAmshAgNAQSAgCCAEIAcgCREAAEEgIAggBEEBaiAHIAkRAABBICAIIARBAmogByAJEQAAQSAgCCAEQQNqIAcgCREAACAEQQRqIQQgAkEEayICDQALDAULIAYoAgAiCyEBAkAgCy0AACIDRQ0AIAxBfyAMG0EBayECA0AgAUEBaiIBLQAARQ0BIAIiDUEBayECIA0NAAsLAn8gASALayIBIAwgASAMSRsgASAAQYAIcSINGyIBIABBAnEiDw0AGiABQQFqIQAgACABIAVPDQAaIAUgAWtBA3EiAwRAQQAhAgNAQSAgCCACIARqIAcgCREAACADIAJBAWoiAkcNAAsgAiAEaiEEIAAgAmohAAsgBSABQX9zakEDTwRAIAUgAGtBAWohAgNAQSAgCCAEIAcgCREAAEEgIAggBEEBaiAHIAkRAABBICAIIARBAmogByAJEQAAQSAgCCAEQQNqIAcgCREAACAEQQRqIQQgAkEEayICDQALCyALLQAAIQMgBUEBagshAQJAIANB/wFxRQ0AIAtBAWohAgNAIA0EQCAMRQ0CIAxBAWshDAsgA8AgCCAEIAcgCREAACAEQQFqIQQgAi0AACEDIAJBAWohAiADDQALCyAGQQRqIQYgD0UgASAFT3INBCAFIAFBf3NqIAUgAWtBA3EiAgRAA0BBICAIIAQgByAJEQAAIARBAWohBCABQQFqIQEgAkEBayICDQALC0EDSQ0EIAUgAWshAgNAQSAgCCAEIAcgCREAAEEgIAggBEEBaiAHIAkRAABBICAIIARBAmogByAJEQAAQSAgCCAEQQNqIAcgCREAACAEQQRqIQQgAkEEayICDQALDAQLAkAgAEEhciIAIABBb3EgBigCACICGyIBQYAIcQRAQQAhACACRQ0BC0EAIQUDQCAFIA5qIAJBD3FBMEE3IAJBDnFBCkkbajoAACAFQQFqIQAgAkEQSQ0BIAJBBHYhAiAFQR9JIAAhBQ0ACwsgBkEEaiEGIAkgCCAEIAcgDiAAQQBBECAMQQggARBPIQQgCkEBaiEFDAcLQSUgCCAEIAcgCREAAAwBCyACIAggBCAHIAkRAAALIARBAWohBAsgCkEBaiEFDAMLQQAgCCAEIAdBAWsgBCAHSRsgByAJEQAAIA5BIGokACAEDAMLIADAIAggBCAHIAkRAAAgAkEBaiECIAVBAWohBSAEQQFqIQQMAAsACwALIBJBEGokAAsUACACIANJBEAgASACaiAAOgAACwsCAAuGBwEDfwJAIApBAnEiDQ0AAkAgCUUEQEEAIQkMAQsgCkEBcUUNACAJIAYgCkEMcUEAR3JrIQkLIAVBH0sgBSAIT3JFBEAgBCAFakEwIAVBf3MgCGoiC0EfIAVrIgwgCyAMSRsiC0EBahBZGiAFIAtqQQFqIQULIApBAXFFIAUgCU9yIAVBH0tyDQAgBCAFakEwIAkgBUF/c2oiC0EfIAVrIgwgCyAMSRsiC0EBahBZGiAFIAtqQQFqIQULAkAgCkEQcQRAIAUgBUF/QX5BfyAHQRBGGyAFQQFGG2ogBSAIRyAFIAlHcSAFRSAKQYAIcXJyGyEFAkACQCAHQRBGBEAgCkEgcSIHRQRAQfgAIQggBUEgSQ0CCyAHRQ0CQdgAIQggBUEgSQ0BDAILIAdBAkcNAUHiACEIIAVBH0sNAQsgBCAFaiAIOgAAIAVBAWohBQsgBUEfSw0BIAQgBWpBMDoAACAFQQFqIQULIAVBH0sNAEEtIQgCQCAGDQBBKyEIIApBBHENAEEgIQggCkEIcUUNAQsgBCAFaiAIOgAAIAVBAWohBQsgAiEIAkAgCkEDcSAFIAlPcg0AIAkgBUF/c2oCQCAJIAVrQQNxIgdFBEAgBSEKDAELIAUhCgNAQSAgASAIIAMgABEAACAKQQFqIQogCEEBaiEIIAdBAWsiBw0ACwtBA0kNACAJIAprIQoDQEEgIAEgCCADIAARAABBICABIAhBAWogAyAAEQAAQSAgASAIQQJqIAMgABEAAEEgIAEgCEEDaiADIAARAAAgCEEEaiEIIApBBGsiCg0ACwsCQCAFRQ0AAkAgBUEBcUUEQCAFIQoMAQsgBCAFQQFrIgpqLAAAIAEgCCADIAARAAAgCEEBaiEICyAFQQFGDQADQCAEIApqIgVBAWssAAAgASAIIAMgABEAACAFQQJrLAAAIAEgCEEBaiADIAARAAAgCEECaiEIIApBAmsiCg0ACwsCQCANRSAIIAJrIAlPcg0AIAIgCWoiBCAIQX9zaiAEIAhrQQNxIgoEQANAQSAgASAIIAMgABEAACAIQQFqIQggCkEBayIKDQALC0EDSQ0AQQAgAmshAgNAQSAgASAIIAMgABEAAEEgIAEgCEEBaiADIAARAABBICABIAhBAmogAyAAEQAAQSAgASAIQQNqIAMgABEAACACIAhBBGoiCGogCUkNAAsLIAgLrBYCCX8DfCMAQSBrIg0kAAJAIAQgBGIEQCACIQUCQCAHQQNxIAZBA01yDQAgBkEEawJAIAZBA2tBA3EiCUUEQEEDIQgMAQtBAyEIA0BBICABIAUgAyAAEQAAIAhBAWohCCAFQQFqIQUgCUEBayIJDQALC0EDSQ0AIAYgCGshCANAQSAgASAFIAMgABEAAEEgIAEgBUEBaiADIAARAABBICABIAVBAmogAyAAEQAAQSAgASAFQQNqIAMgABEAACAFQQRqIQUgCEEEayIIDQALCyAHQQJxIQdBAiIIQYKOBGosAAAgASAFIAMgABEAACAFQQFqIQUDQCAIQYKOBGoiCUEBaywAACABIAUgAyAAEQAAIAlBAmssAAAgASAFQQFqIAMgABEAACAFQQJqIQUgCEECayIIDQALAkAgB0UgBSACayAGT3INACACIAZqIgcgBUF/c2ogByAFa0EDcSIIBEADQEEgIAEgBSADIAARAAAgBUEBaiEFIAhBAWsiCA0ACwtBA0kNAEEAIAJrIQIDQEEgIAEgBSADIAARAABBICABIAVBAWogAyAAEQAAQSAgASAFQQJqIAMgABEAAEEgIAEgBUEDaiADIAARAAAgAiAFQQRqIgVqIAZJDQALCwwBCyAERP///////+//YwRAIAdBAnEgAiEIAkAgB0EDcSAGQQVJcg0AIAZBA3EhBSAGQQVrQQNPBEBBACAGQQRrQXxxayEJA0BBICABIAggAyAAEQAAQSAgASAIQQFqIAMgABEAAEEgIAEgCEECaiADIAARAABBICABIAhBA2ogAyAAEQAAIAhBBGohCCAJQQRqIgkNAAsLIAVFDQADQEEgIAEgCCADIAARAAAgCEEBaiEIIAVBAWsiBQ0ACwtBLSABIAggAyAAEQAAQekAIAEgCEEBaiADIAARAABB7gAgASAIQQJqIAMgABEAAEHmACABIAhBA2ogAyAAEQAARSAIQQRqIgUgAmsgBk9yDQEgAiAGaiAIayIHQQVrIAdBA3EiCARAA0BBICABIAUgAyAAEQAAIAVBAWohBSAIQQFrIggNAAsLQQNJDQFBACACayECA0BBICABIAUgAyAAEQAAQSAgASAFQQFqIAMgABEAAEEgIAEgBUECaiADIAARAABBICABIAVBA2ogAyAAEQAAIAIgBUEEaiIFaiAGSQ0ACwwBCyAERP///////+9/ZARAIAIhCAJAIAdBA3FBBEEDIAdBBHEiCxsiCiAGT3INACAKQX9zIAZqAkAgBiAKa0EDcSIJRQRAIAohBQwBCyAKIQUDQEEgIAEgCCADIAARAAAgBUEBaiEFIAhBAWohCCAJQQFrIgkNAAsLQQNJDQAgBiAFayEFA0BBICABIAggAyAAEQAAQSAgASAIQQFqIAMgABEAAEEgIAEgCEECaiADIAARAABBICABIAhBA2ogAyAAEQAAIAhBBGohCCAFQQRrIgUNAAsLQfGmBEGckwQgCxshBSAKQQFxBEAgBSAKQQFrIgpqLAAAIAEgCCADIAARAAAgCEEBaiEICyAHQQJxQQAhCUEAIAprIQsgBSAKakECayEFIAIgBmoiDiAIayEKA0AgBUEBaiwAACABIAggCWoiDCADIAARAAAgBSwAACABIAxBAWogAyAAEQAAIAVBAmshBSAKQQJqIQogCyAJQQJqIglqDQALIAggCWohBUUgCCACayAJaiAGT3INASAOIAhrIAlrIgdBAWsgB0EDcQRAIAggCWohByAKQQNxIQhBACEFA0BBICABIAUgB2ogAyAAEQAAIAggBUEBaiIFRw0ACyAFIAdqIQULQQNJDQFBACACayECA0BBICABIAUgAyAAEQAAQSAgASAFQQFqIAMgABEAAEEgIAEgBUECaiADIAARAABBICABIAVBA2ogAyAAEQAAIAIgBUEEaiIFaiAGSQ0ACwwBCyAERAAAAABlzc3BYyAERAAAAABlzc1BZHIEQCAAIAEgAiADIAQgBSAGIAcQUSEFDAELRAAAAAAAAAAAIAShIAQgBEQAAAAAAAAAAGMbIRICfyAFQQYgB0GACHEbIgxBCkkEQEEAIQVBAQwBCyANQTBBHyAMQQprIgUgBUEfTxsiCEEBaiIFEFkaIAVBB3EhCSAIQQdPBEAgBUE4cSEIA0AgCCAKQQhqIgpHDQALIAwgCmshDCAKQQFrIQgLIAkEQCAKQQFrIQgDQCAIQQFqIQggDEEBayEMIAlBAWsiCQ0ACwsgCEEfSQshCwJ/IBICfyASmUQAAAAAAADgQWMEQCASqgwBC0GAgICAeAsiCrehIAxBA3RBgOUEaisDACIToiIRRAAAAAAAAPBBYyARRAAAAAAAAAAAZnEEQCARqwwBC0EACyEIAkAgESAIuKEiEUQAAAAAAADgP2QEQCATIAhBAWoiCLhlRQ0BIApBAWohCkEAIQgMAQsgEUQAAAAAAADgP2MNACAIRSAIQQFxciAIaiEICwJAAkAgDEUEQCAKIAogEiAKt6FEAAAAAAAA4D9jRXFqIQoMAQtBICEJIAtFDQEgBSANaiEPQQAhCQNAAkAgCSAPaiAIIAhBCm4iDkEKbGtBMHI6AAAgCUEBaiELIAhBCkkNACAFIAlqIAshCSAOIQhBH0kNAQsLIAUgC2oiCUEBayIIQR9JIQUgCyAMRiAIQR5LcgR/IAUFIAsgD2ohDiALQX9zIAxqIQtBACEFA0ACQCAFIA5qQTA6AAAgBUEBaiEIIAUgCWpBAWoiDEEfSw0AIAUgC0cgCCEFDQELCyAIIAlqIQkgDEEgSQtFDQEgCSANakEuOgAAIAlBAWohBQtBICEJIAVBH0sNAANAIAUgDWogCiAKQQptIghBCmxrQTBqOgAAIAVBAWohCSAKQQlqQRNJDQEgBUEfSSAJIQUgCCEKDQALCwJAIAdBA3EiCEEBRw0AIAlBH0sgCSAGIAdBDHFBAEcgBEQAAAAAAAAAAGNya0EAIAYbIgZPcg0AIAkgDWpBMCAGIAlBf3NqIgVBHyAJayIKIAUgCkkbIgVBAWoQWRogBSAJakEBaiEJCwJAIAlBH0sNAEEtIQUCQCAERAAAAAAAAAAAYw0AQSshBSAHQQRxDQBBICEFIAdBCHFFDQELIAkgDWogBToAACAJQQFqIQkLIAIhBQJAIAYgCU0gCHINACAGIAlBf3NqAkAgBiAJa0EDcSIKRQRAIAkhCAwBCyAJIQgDQEEgIAEgBSADIAARAAAgCEEBaiEIIAVBAWohBSAKQQFrIgoNAAsLQQNJDQAgBiAIayEIA0BBICABIAUgAyAAEQAAQSAgASAFQQFqIAMgABEAAEEgIAEgBUECaiADIAARAABBICABIAVBA2ogAyAAEQAAIAVBBGohBSAIQQRrIggNAAsLIAdBAnECQCAJRQ0AAkAgCUEBcUUEQCAJIQgMAQsgDSAJQQFrIghqLAAAIAEgBSADIAARAAAgBUEBaiEFCyAJQQFGDQADQCAIIA1qIglBAWssAAAgASAFIAMgABEAACAJQQJrLAAAIAEgBUEBaiADIAARAAAgBUECaiEFIAhBAmsiCA0ACwtFIAUgAmsgBk9yDQAgAiAGaiIHIAVBf3NqIAcgBWtBA3EiCARAA0BBICABIAUgAyAAEQAAIAVBAWohBSAIQQFrIggNAAsLQQNJDQBBACACayECA0BBICABIAUgAyAAEQAAQSAgASAFQQFqIAMgABEAAEEgIAEgBUECaiADIAARAABBICABIAVBA2ogAyAAEQAAIAIgBUEEaiIFaiAGSQ0ACwsgDUEgaiQAIAULhwkDCX8DfAF+IwBBIGsiCyQAAkAgBCAEYiAERP///////+//Y3IgBET////////vf2RyBEAgACABIAIgAyAEIAUgBiAHEFAhBwwBCwJ/IASaIAQgBEQAAAAAAAAAAGMbIhK9IhRC/////////weDQoCAgICAgID4P4S/RAAAAAAAAPi/oERhQ29jp4fSP6IgFEI0iKdB/w9xQf8Ha7dE+3mfUBNE0z+iRLPIYIsoisY/oKAiEZlEAAAAAAAA4EFjBEAgEaoMAQtBgICAgHgLIgm3IhFEFlW1u7FrAkCiAn8gEURxo3kJT5MKQKJEAAAAAAAA4D+gIhGZRAAAAAAAAOBBYwRAIBGqDAELQYCAgIB4CyIIt0TvOfr+Qi7mv6KgIhEgEaBEAAAAAAAAAEAgEaEgESARoiIRIBEgEUQAAAAAAAAsQKNEAAAAAAAAJECgo0QAAAAAAAAYQKCjoKNEAAAAAAAA8D+gIAhB/wdqrUI0hr+iIhEgEmQEQCARRAAAAAAAACRAoyERIAlBAWshCQtBBEEFIAlB4wBqQccBSRshCgJ/IAVBBiAHQYAIcSIIGyIFIAdBgBBxRQ0AGiASRC1DHOviNho/ZkUgEkQAAAAAgIQuQWNFckUEQCAFIAlKIQggCUF/cyEMQQAhCSAHQYAIciEHQQAhCiAFIAxqQQAgCBsMAQtBACAFRQ0AGiAFIAhBAEdrCyEFQQAhCCAAIAEgAiADIBIgEaMgEiAJGyISmiASIAREAAAAAAAAAABjGyAFQQAgBiAKayIFQQAgBSAGTRsiBSAKGyAFIAdBAnEiD0EBdhsgB0H/b3EQUCEMIApFBEAgDCEHDAELIAdBIHFB5QBzIAEgDCADIAARAAAgCSAJQR91IgVqIAVzIQcgCkEDayENQR8hDgNAAkAgCyAIIgVqIAcgB0EKbiIQQQpsa0EwcjoAACAOQQFrIQ4gDUEBayENIAhBAWohCCAHQQpJDQAgECEHIAVBH0kNAQsLIAVBHksgCCAKQQJrT3JFBEAgCCALakEwIAogCGtBA2siBUEfIAhrIgcgBSAHSRtBAWoQWRogDSAOIA0gDkkbIAhqQQFqIQgLIAhBH00EQCAIIAtqQS1BKyAJQQBIGzoAACAIQQFqIQgLIAxBAWohBwJAIAhBAXFFBEAgCCEFDAELIAsgCEEBayIFaiwAACABIAcgAyAAEQAAIAxBAmohBwsgCEEBRwRAA0AgBSALaiIIQQFrLAAAIAEgByADIAARAAAgCEECaywAACABIAdBAWogAyAAEQAAIAdBAmohByAFQQJrIgUNAAsLIA9FIAcgAmsgBk9yDQAgAiAGaiIFIAdBf3NqIAUgB2tBA3EiBQRAA0BBICABIAcgAyAAEQAAIAdBAWohByAFQQFrIgUNAAsLQQNJDQBBACACayECA0BBICABIAcgAyAAEQAAQSAgASAHQQFqIAMgABEAAEEgIAEgB0ECaiADIAARAABBICABIAdBA2ogAyAAEQAAIAIgB0EEaiIHaiAGSQ0ACwsgC0EgaiQAIAcLCQBBh7AEEAAACwcAIAAQAAALBgAgABAgCwYAIAAQIQsMACABECBBACABEFkLIgEBfyABECAgACAAQQxrKAIAIgIgASABIAJLGxBYIAAQIQuxAQEEfwJAIAJFDQAgAkEDcSEEIAJBAWtBA08EQCACQXxxIQYDQCAAIANqIgIgASADaiIFLQAAOgAAIAJBAWogBUEBai0AADoAACACQQJqIAVBAmotAAA6AAAgAkEDaiAFQQNqLQAAOgAAIAYgA0EEaiIDRw0ACwsgBEUNACABIANqIQIgACADaiEDA0AgAyACLQAAOgAAIAJBAWohAiADQQFqIQMgBEEBayIEDQALCyAAC7EBAQN/AkAgAkUNACACQQFrAkAgAkEHcSIERQRAIAAhAwwBCyAAIQMDQCADIAE6AAAgA0EBaiEDIAJBAWshAiAEQQFrIgQNAAsLQQdJDQADQCADIAE6AAAgA0EHaiABOgAAIANBBmogAToAACADQQVqIAE6AAAgA0EEaiABOgAAIANBA2ogAToAACADQQJqIAE6AAAgA0EBaiABOgAAIANBCGohAyACQQhrIgINAAsLIAALXwEDfyABBEBBASEDQQEhBANAAkAgAEEAIAAoAgAgBGoiAiACQYCU69wDRiIEGzYCACACQYCU69wDRw0AIABBBGohACABIANLIANBAWohAw0BCwsgBA8LQfKlBBBTQQELAwAAC6AIAhV/A34gAWlBAUcEQEG0qAQQUwsgAUEDTQRAQbSkBBBTCyABQQF2IQUgAigCAEECdEGoowdqKAIAIgStIRggAUECTwRAIAJBDGohCCAFQQJ0IRIgACEDA0AgCEEEajUCACEZIAMgEmoiDSgCACEHIAg1AgAhGiADQQRqIgkgDUEEaiITKAIAIgsgCSgCACIJaiIGIARBACAGIAtJG2siBiAEQQAgBCAGTRtrNgIAIAMgByADKAIAIgZqIg4gBEEAIAcgDksbayIOIARBACAEIA5NG2s2AgAgEyAZIAkgC2sgBEEAIAkgC0kbaq1+IBiCPgIAIA0gGiAGIAdrIARBACAGIAdJG2qtfiAYgj4CACAIQQhqIQggA0EIaiEDIApBAmoiCiAFSQ0ACwsCQCABQQRJDQAgAEEEaiEHQQIhDQNAIAVBAXYhCAJAIAEEQCAFQQF0IRIgBUECdCITIAhBAnQiDmohDyAFQQN0IRdBACELIAAhAwNAIAMgD2oiFCgCACEKIAMgE2oiDCgCACEJIAMgAyAOaiIVKAIAIgYgAygCACIQaiIRIARBACAGIBFLG2siESAEQQAgBCARTRtrNgIAIAwgCSAKaiIMIARBACAKIAxLG2siDCAEQQAgBCAMTRtrNgIAIBUgECAGayAEQQAgBiAQSxtqNgIAIBQgCSAKayAEQQAgCSAKSRtqNgIAIAMgF2ohAyALIBJqIgsgAUkNAAsgBUEDTQ0DIAFFDQFBAiAIIAhBAk0bIRQgBSAIakECdCEMQQEhCiAHIQUDQCACIAogDWxBAnRqQQxqNQIAIRlBACELIAUhAwNAIAMgAyAOaiIVKAIAIgkgAygCACIQaiIGIARBACAGIAlJG2siBiAEQQAgBCAGTRtrNgIAIAMgE2oiDyADIAxqIhEoAgAiBiAPKAIAIg9qIhYgBEEAIAYgFksbayIWIARBACAEIBZNG2s2AgAgFSAQIAlrIARBACAJIBBLG2qtIBl+IBiCPgIAIBEgDyAGayAEQQAgBiAPSxtqrSAZfiAYgj4CACADIBdqIQMgCyASaiILIAFJDQALIAVBBGohBSAKQQFqIgogFEcNAAsMAQsgBUEDTQ0CCyANQQF0IQ0gCCEFDAALAAtBASABIAFBAU0bIQhBACEDIAAhAkEAIQUDQCADIAVLBEAgAigCACEHIAIgACADQQJ0aiIEKAIANgIAIAQgBzYCAAsgAyABIAFBD0EfIAVBAWoiBUH//wNxIgMbIgdBCGsgByAFIAVBEHYgAxsiA0H/AXEiBxsiBEEEayAEIAMgA0EIdiAHGyIDQQ9xIgcbIgRBAmsgBCADIANBBHYgBxsiA0EDcSIHGyADIANBAnYgBxtBAXFrQQFqdmtzIQMgAkEEaiECIAUgCEcNAAsLXwEBfyABaUEBRwRAQbSoBBBTC0G0pAQhAwJAIAFBBE8EQEHYogQhAyABQYGAgDBJDQELIAMQUwsgAUF/IAIQcyICRQRAQQAPCyAAIAEgAhBcIAJBiKUHKAIAEQEAQQELXwEBfyABaUEBRwRAQbSoBBBTC0G0pAQhAwJAIAFBBE8EQEHYogQhAyABQYGAgDBJDQELIAMQUwsgAUEBIAIQcyICRQRAQQAPCyAAIAEgAhBcIAJBiKUHKAIAEQEAQQELkwYCDn8FfiMAQRBrIgkkACABQQNuIQhBhaQEIQMCQCABQTBPBEBB2KIEIQMgAUGBgIAwSQ0BCyADEFMLIAJBAnRBqKMHaigCACEDQX8hBSAJQQRqQX8gAhB0IAOtIRECQAJAIAhFBEAgAUF/IAIQciEEDAELIAAgCEECdCIKaiELIAk1AgwhEiAJNQIIIRMgCEEDdCEMIAAhBgNAIAYgBiAKaiINKAIAIgQgBigCACIFaiIHIANBACAEIAdLG2siByADQQAgAyAHTRtrIgcgBiAMaiIOKAIAIg9qIhAgA0EAIAcgEEsbayIHIANBACADIAdNG2s2AgAgDiAFIAStIhQgEn4gEYKnaiIEIANBACAEIAVJG2siBCADQQAgAyAETRtrIgQgD60iFSATfiARgqdqIgcgA0EAIAQgB0sbayIEIANBACADIARNG2s2AgAgDSAFIBMgFH4gEYKnaiIEIANBACAEIAVJG2siBSADQQAgAyAFTRtrIgUgEiAVfiARgqdqIgQgA0EAIAQgBUkbayIFIANBACADIAVNG2s2AgAgBkEEaiIGIAtJDQALIAFBfyACEHIhBCAIQQFrIgVFDQELIAAgCEECdGohBiAEIANwIgOtIhIgEn4gEYIhEkIBIRNBACEKA0AgBiATQv////8PgyITIAY1AgB+IBGCPgIAIAZBBGoiCyADrSIUIAs1AgB+IBGCPgIAIAZBCGohBiASIBN+IBGCIRMgEiAUfiARgqchAyAKQQJqIgogBUkNAAsgACAIQQN0aiEDIAStIhIgEn4gEYIiEiASfiARgiETQgEhFEEAIQYDQCADIBRC/////w+DIhQgAzUCAH4gEYI+AgAgA0EEaiIEIBJC/////w+DIhIgBDUCAH4gEYI+AgAgA0EIaiEDIBIgE34gEYIhEiATIBR+IBGCIRQgBkECaiIGIAVJDQALC0EBIQUCQCABQQBMDQAgACABQQJ0aiEBIAhBAnQhBgNAIAAgCCACEHVFBEBBACEFDAILIAAgBmoiACABSQ0ACwsgCUEQaiQAIAUL9wUCC38FfiMAQRBrIggkACABQQNuIQVBhaQEIQMCQAJAAkAgAUEwTwRAQdiiBCEDIAFBgYCAMEkNAQsgAxBTIAFBAEwNAQsgBUECdCEEIAAgAUECdGohByAAIQMDQCADIAUgAhB2RQRADAMLIAMgBGoiAyAHSQ0ACwsgAkECdEGoowdqKAIAIgOtIQ5BASEKIAFBASACEHIhCSABQQNPBEAgACAFQQJ0aiEEIAkgA3AiB60iDyAPfiAOgiEPQgEhEEEAIQEDQCAEIBBC/////w+DIhAgBDUCAH4gDoI+AgAgBEEEaiIGIAetIhEgBjUCAH4gDoI+AgAgBEEIaiEEIA8gEH4gDoIhECAPIBF+IA6CpyEHIAFBAmoiASAFSQ0ACyAAIAVBA3RqIQQgCa0iDyAPfiAOgiIPIA9+IA6CIRBCASERQQAhBwNAIAQgEUL/////D4MiESAENQIAfiAOgj4CACAEQQRqIgEgD0L/////D4MiDyABNQIAfiAOgj4CACAEQQhqIQQgDyAQfiAOgiEPIBAgEX4gDoIhESAHQQJqIgcgBUkNAAsLIAhBBGpBASACEHQgBUUNACAAIAVBAnQiB2ohBCAINQIMIQ8gCDUCCCEQIAVBA3QhBQNAIAAgACAHaiIJKAIAIgIgACgCACIBaiIGIANBACACIAZLG2siBiADQQAgAyAGTRtrIgYgACAFaiILKAIAIgxqIg0gA0EAIAYgDUsbayIGIANBACADIAZNG2s2AgAgCyABIAKtIhEgD34gDoKnaiICIANBACABIAJLG2siAiADQQAgAiADTxtrIgIgDK0iEiAQfiAOgqdqIgYgA0EAIAIgBksbayICIANBACACIANPG2s2AgAgCSABIBAgEX4gDoKnaiICIANBACABIAJLG2siASADQQAgASADTxtrIgEgDyASfiAOgqdqIgIgA0EAIAEgAksbayIBIANBACABIANPG2s2AgAgAEEEaiIAIARJDQALCyAIQRBqJAAgCgu6FAEQfyMAQRBrIg4kACAAIAAtAABB8AFxOgAAIABBADYCBCAAQQA2AgwCQAJAAkAgAS0AACIEQStrDgMBAgACCyAAIAAtAABBAXI6AABBASEFCyABLQABIQQgAUEBaiEBCwJAAkACQAJAAkACQAJAAkACQAJAAkACQCAEQf8BcSIGQckAaw4rBQYGBgYABgYGBgQGBgYGBgYGBgYGBgYGBgYGBgYGBgYFBgYGBgAGBgYGBAELIAEtAAFBIHJB4QBGDQEMAgsgBg0EDAgLIAEtAAJBIHJB7gBHDQAgACAFQQQQaiABLQADIgRFDQggAUEDaiEGIARBMEYNBAwFCwJAIARB/wFxIgZByQBrDgsCAwMDAwMDAwMDAQALIAZFDQYgBkHpAEcNAgwBCwJAIAEtAAFBIHJB7gBHDQAgAS0AAkEgckHhAEcNACABLQADQSByQe4ARw0AIAAgBUEIEGogAS0ABCIERQ0HIAFBBGohBiAEQTBGBEADQCAGQQFqIgYtAAAiBEEwRg0ACwsgBiEBIARBMGtBCU0EQANAIAFBAWoiAS0AACIEQTBrQQpJDQALCyAEDQZBACAGIAQbIgQtAABFDQcgASAEayIFIAIoAgAgAigCHGtNDQUMBgsgBEH/AXEiBkUNBSAGQckARg0AIAZB6QBHDQELIAEtAAFBIHJB7gBHDQAgAS0AAkEgckHmAEcNACABLQADIgIEQCACQckARyACQekAR3ENBSABLQAEQSByQe4ARw0FIAEtAAVBIHJB6QBHDQUgAS0ABkEgckH0AEcNBSABLQAHQSByQfkARw0FIAEtAAgNBQsgACAFQQIQagwFC0EAIQVBACEGA0ACQAJAAkACQCAEQf8BcSIHQeUARwRAIATAIgRBxQBHDQELIAUNCCABIQUgASEEIAEtAAFBK2sOAwEDAQMLIARBLkcNASAFIAlyQQAhBSABIQkgASEERQ0CDAcLIAFBAWohBAwBCyAHQTBrQQlLDQUgBgRAIAEhBAwBC0EAIQYgBQRAIAEhBAwBC0EAIQUCQAJAIAdBMEcNACABLQABIgRBMGtBCkkNASAEQS5HDQAgAS0AAkEwa0EKSQ0BCyABIQQgASEGDAELIAEhBAsgBEEBaiEBIAQtAAEiBA0ACyAGRQ0DAkAgBUUNAEHIpgdBADYCACAOQQxqIRAgBUEBaiIRIQgDQCAILQAAIQcgCEEBaiEIAn8gB0EJayIBQRdNBEBBAUEBIAF0QZuAgARxDQEaCyAHQQtGCw0ACwJ/AkACQAJAIAdBK2sOAwEAAgALQQEhDCAIDAILQQEhDAsgCC0AACEHIAhBAWoLIQFB/////wdBgICAgHggDBsiEgJ/AkACQCAHQTBHQQpyRQRAIAEtAABBIHJB+ABHDQEgAS0AASEHIAFBAmohAUEQDAMLIAdBMEcNAQtBMCEHC0EKCyIPbiENAkAgB0GAAXENACASIA0gD2xrIRMgByEIA0ACQCABIQQgDyAIQTBrQQlNBH8gB0EwawUgCEFfcUHBAGtBGk8NAUFJQal/IAhBwQBrQRpJGyAHagtB/wFxIgFMDQAgC0EASCEHQX8hCwJ/IAogBw0AGiAKIAogDUsNABogCiANRgRAIA0gASATSg0BGgtBASELIAogD2wgAWoLIQogBEEBaiEBIAQtAAAiCCEHIAhBgAFxRQ0BDAILCyAEIQELIBAEQCAQIAFBAWsgESALGzYCAAsgEiAKQQAgCmsgDBsgC0EASBshBEHIpgcoAgAiAUUEQAJAIBEtAABFDQAgDigCDC0AAA0AIAAgBDYCBCAFIQEMAgtByKYHQRY2AgAgACAENgIEDAULIAAgBDYCBCABQSJHDQQgBSEBIARB/////wdrQQFLDQQLIAEgBmshBSAJBEAgASAJQX9zaiIBQcD408oBSw0EIABBgICAgHggACgCBCIEIAFrIAQgAUGAgICAeHJIGzYCBCAFIAYgCUlrIQULIAVBwPjTygFLDQNBgZTr3AMhASAAKAIEIgRBgZTr3ANMBEBBgYCAgHghASAEQYCAgIB4Rw0DCyAAIAE2AgQMAgsDQCAGQQFqIgYtAAAiBEEwRg0ACwsgBiEBIARBMGtBCU0EQANAIAFBAWoiAS0AACIEQTBrQQpJDQALCyAEDQFBACAGIAQbIgQtAABFDQIgASAEayIFIAIoAgAgAigCHGtLDQELIAVBCW0iCiAKQXdsIAVqIgdBAEdqIgRFDQACfyAALAAAIgFBAEgEf0GQpwQQUyAALQAABSABC0HAAHEEQEGqpwQQUwtB+KQHKAIAIgEgACgCECIISgRAQfCcBBBTIAAoAhAhCEH4pAcoAgAhAQtBASELAkAgBCABIAEgBEgbIgEgCEYNACAALQAAQSBxBEAgASAITA0BIAAgASADEGQMAgsgACABIAMQZSELCyALC0UEQCAAQYAEIAMQawwCCyAAIAQ2AgwgACgCFCELAkAgB0EATA0AQQAhASALIARBAWsiBEECdGoiCEEANgIAIAdBAXFBASAFayAKQXdsRgR/QVAFQQAgB0F+cWshBQNAIAggBiAGIAlGaiIGLAAAIAFBCmxqQTBrIgE2AgAgCCAGQQFqIgYgBiAJRmoiBiwAACABQQpsakEwayIBNgIAIAZBAWohBiAFQQJqIgUNAAsgAUEKbEEwawshAUUNACAIIAEgBiAGIAlGaiIFLAAAajYCACAFQQFqIQYLIAQEQCAEQQJ0IAtqQQRrIQEDQCABQQA2AgAgASAGIAYgCUZqIgUsAABBMGsiBjYCACABIAVBAWoiBSAFIAlGaiIFLAAAIAZBCmxqQTBrIgY2AgAgASAFQQFqIgUgBSAJRmoiBSwAACAGQQpsakEwayIGNgIAIAEgBUEBaiIFIAUgCUZqIgUsAAAgBkEKbGpBMGsiBjYCACABIAVBAWoiBSAFIAlGaiIFLAAAIAZBCmxqQTBrIgY2AgAgASAFQQFqIgUgBSAJRmoiBSwAACAGQQpsakEwayIGNgIAIAEgBUEBaiIFIAUgCUZqIgUsAAAgBkEKbGpBMGsiBjYCACABIAVBAWoiBSAFIAlGaiIFLAAAIAZBCmxqQTBrIgY2AgAgASAFQQFqIgUgBSAJRmoiBSwAACAGQQpsakEwazYCACAFQQFqIQYgAUEEayEBIARBAWsiBA0ACwsgACgCDCIEQQBMBEBB3KUEEFMgACgCDCEECyAAAn8gACgCFCAEQQJ0akEEaygCACIBQeCkBygCAEkEQCABQdikBygCAEkEQEEBQQJB1KQHKAIAIAFLGwwCC0EDQQRB3KQHKAIAIAFLGwwBCyABQeikBygCAEkEQEEFQQZB5KQHKAIAIAFLGwwBCyABQfCkBygCAEkEQEEHQQhB7KQHKAIAIAFLGwwBC0EJQQpB9KQHKAIAIAFLGwsgBEEJbGpBCWs2AgggACACIAMQbAwBCyAAQQIgAxBrCyAOQRBqJAALNgEBfgJAIAGtQgKGIgNCIIhQBEAgACADp0GApQcoAgARBAAiAQ0BCyACQQE6AAAgACEBCyABC4YBAQN/QfikBygCACEBQRhB/KQHKAIAEQIAIgAEfwJAAkAgASABQf////8DcUcEQCAAQQA2AhQMAQsgACABQQJ0QfykBygCABECACICNgIUIAINAQsgAEGIpQcoAgARAQBBAA8LIAAgATYCECAAQQA2AgwgAEIANwIEIABBADoAACAABSACCwubAQECfyAAKAIUIQMgASAAKAIQSARAQdicBBBTCwJAIAEgAUH/////A3FGBEAgACABQQJ0QfykBygCABECACIENgIUIAQNAQsgACADNgIUIAAQZyAAEGggAEEANgIMIABCADcCBCACIAIoAgBBgARyNgIAQQAPCyAEIAMgACgCEEECdBBYGiAAIAE2AhAgACAALQAAQR9xOgAAQQELggEBAn8gACgCFCEDAkAgAUH/////A3EgAUcNACADIAFBAnRBgKUHKAIAEQQAIgRFDQAgACABNgIQIAAgBDYCFEEBDwsgACADNgIUQQEhAyABIAAoAhBKBH8gABBnIAAQaCAAQQA2AgwgAEIANwIEIAIgAigCAEGABHI2AgBBAAUgAwsLOwEBfyAALQAAIgFBH00EfyAAKAIUQYilBygCABEBACAALQAABSABC0EQcUUEQCAAQYilBygCABEBAAsLEwAgACAALQAAQfEBcUEEcjoAAAsQACAAIAAtAABB/gFxOgAAC7oDAQV/IAEoAgAiA0EJbSIHQXdsIANqIQUgACwAACIDQQBIBH9BkKcEEFMgAC0AAAUgAwtBwABxBEBBqqcEEFMLQfikBygCACIEIAAoAhAiBkoEQEHwnAQQUyAAKAIQIQZB+KQHKAIAIQQLAkACQCAFQQBHIAdqIgMgBCADIARKGyIEIAZGDQACfyAALQAAQSBxBEAgBCAGTA0CIAAgBCACEGQMAQsgACAEIAIQZQtFDQELIAAgAzYCDCAAIAEoAgA2AgggA0EBayEBIAVBAEoEQCAAKAIUIAFBAnRqIAVBAnRB0KQHaigCAEEBazYCACADQQJrIQELIAFBAEgNACAAKAIUIQIgASIDQQFqQQdxIgQEQCACIANBAnRqIQADQCAAQf+T69wDNgIAIABBBGshACADQQFrIQMgBEEBayIEDQALCyABQQdJDQAgA0EIaiEEIANBAnQgAmpBHGshAANAIABC/5Pr3PO/ss07NwIAIABBGGpC/5Pr3PO/ss07NwIAIABBEGpC/5Pr3PO/ss07NwIAIABBCGpC/5Pr3PO/ss07NwIAIABBIGshACAEQQhrIgRBB0oNAAsLC7QBAQN/IwBBEGsiBCQAIAAsAAAiA0EASARAQZCnBBBTIAAtAAAhAwsgA0HAAHEEQEGqpwQQUyAALQAAIQMLAkAgA0EgcQ0AQfikBygCACIFIAAoAhBODQAgBEEAOgAPIAAgACgCFCAFIARBD2oQYjYCFCAELQAPRQRAIABB+KQHKAIANgIQCyAALQAAIQMLIABBADYCDCAAQgA3AgQgACADQfABcSABIAJycjoAACAEQRBqJAALvgEBA38jAEEQayIEJAAgACwAACIDQQBIBEBBkKcEEFMgAC0AACEDCyADQcAAcQRAQaqnBBBTIAAtAAAhAwsCQCADQSBxDQBB+KQHKAIAIgUgACgCEE4NACAEQQA6AA8gACAAKAIUIAUgBEEPahBiNgIUIAQtAA9FBEAgAEH4pAcoAgA2AhALIAAtAAAhAwsgAEEANgIMIABCADcCBCAAIANB8AFxQQRyOgAAIAIgAigCACABcjYCACAEQRBqJAALrAoBA38CQCAALQAAIgNBDnEEQCADQQxxRQ0BIAEoAgAhAiABQRxqKAIAIQEjAEEQayIEJAACQCAAKAIMQQBMDQAgAiABayIBIAAoAghODQACQCABRQRAIAAsAAAiAUEASARAQZCnBBBTIAAtAAAhAQsgAUHAAHEEf0GqpwQQUyAALQAABSABC0EgcQ0BQfikBygCACIBIAAoAhBODQEgBEEAOgAPIAAgACgCFCABIARBD2oQYjYCFCAELQAPDQEgAEH4pAcoAgA2AhAMAQsgAUEJbSICIAJBd2wgAWoiAkEAR2ohAQJAIAJFBEAgACgCFCEFDAELIAAoAhQiBSABQQJ0akEEayIDIAMoAgAgAkECdEHQpAdqKAIAcDYCAAtBASABIAFBAEobIQMgAUECdCAFakEEayECAkADQCABQQJIDQEgAUEBayEBIAIoAgAgAkEEayECRQ0ACyABQQFqIQMLIAAsAAAiAUEASAR/QZCnBBBTIAAtAAAFIAELQcAAcQRAQaqnBBBTC0H4pAcoAgAiASAAKAIQIgJKBEBB8JwEEFMgACgCECECQfikBygCACEBCwJAIAMgASABIANIGyIBIAJGDQAgAC0AAEEgcQRAIAEgAkwNASAAIAEgBEEIahBkGgwBCyAAIAEgBEEIahBlGgsgACADNgIMIANBAEwEQEHcpQQQUyAAKAIMIQMLIAACfyAAKAIUIgIgA0EBayIFQQJ0aigCACIBQeCkBygCAEkEQCABQdikBygCAEkEQEEBQQJB1KQHKAIAIAFLGwwCC0EDQQRB3KQHKAIAIAFLGwwBCyABQeikBygCAEkEQEEFQQZB5KQHKAIAIAFLGwwBCyABQfCkBygCAEkEQEEHQQhB7KQHKAIAIAFLGwwBC0EJQQpB9KQHKAIAIAFLGwsgA0EJbGpBCWs2AgggA0EATARAQdylBBBTIAAoAgxBAWshBSAAKAIUIQILIAIgBUECdGooAgANAQsgAEIANwIICyAEQRBqJAAPCyAAIAEgAhBtIAAtAABBDnENACAAKAIIIgMgASgCACIETA0AIAAgAyAEayIEEG4hAyAAIAAoAgQgBGo2AgQgAgJ/AkACQAJAAn8CQAJAAkACQAJAAkACQCABQRhqKAIADggFCQIDAAQBBgkLIANBBEsMBgsgA0EFSw0GIANBBUcNByAAKAIUKAIAQQFxDAULIANFDQcgAC0AAEF/c0EBcQwECyADRQ0GIAAtAABBAXEMAwsgA0EFSwwCCyADQQBHDAELIAAoAhQoAgBBCnAiBEUgBEEFRnIgA0EAR3ELRQ0BCwJAIAAoAhQgACgCDBBaBEAgACgCFCAAKAIMQQJ0akEEa0HwpAcoAgA2AgAMAQsgACgCDCIFQQBMBEBB3KUEEFMgACgCDCEFCyAAAn8gACgCFCAFQQJ0akEEaygCACIEQeCkBygCAEkEQCAEQdikBygCAEkEQEEBQQJB1KQHKAIAIARLGwwCC0EDQQRB3KQHKAIAIARLGwwBCyAEQeikBygCAEkEQEEFQQZB5KQHKAIAIARLGwwBCyAEQfCkBygCAEkEQEEHQQhB7KQHKAIAIARLGwwBC0EJQQpB9KQHKAIAIARLGwsgBUEJbGpBCWsiBDYCCCAEIAEoAgBMDQEgAEEBEG4aIAAgASgCADYCCAsgACAAKAIEQQFqNgIEIAAgASACEG0LIAIgAigCACIAQYAgcjYCACADRQ0CIABBwCByDAELIAIoAgBBgCByCzYCAAsLmxsBEH8jAEEQayILJAACQCACAn8CQCAAKAIEIgMgACgCCGpBAWsiESABKAIEIgRKBEAgACgCDCIDQQBMBEBB3KUEEFMgACgCDCEDCyAAKAIUIANBAnRqQQRrKAIARQRAIAAgASgCBCIDNgIEIAEoAhwEQCAAIAMgASgCAGtBAWo2AgQLIAAsAAAiAUEASARAQZCnBBBTIAAtAAAhAQsCQCABQcAAcQR/QaqnBBBTIAAtAAAFIAELQSBxDQBB+KQHKAIAIgEgACgCEE4NACALQQA6AA0gACAAKAIUIAEgC0ENahBiNgIUIAstAA0NACAAQfikBygCADYCEAsgAEKBgICAEDcCCCAAKAIUQQA2AgAMAgsCQAJAAkACQAJAIAEoAhgOCQABAgMAAAABAAQLIAAtAAAiA8AiAUEASARAQZCnBBBTIAAtAAAhAQsgAUHAAHEEQEGqpwQQUyAALQAAIQELIANBAXEhAwJAIAFBIHENAEH4pAcoAgAiBCAAKAIQTg0AIAtBADoADiAAIAAoAhQgBCALQQ5qEGI2AhQgCy0ADkUEQCAAQfikBygCADYCEAsgAC0AACEBCyAAQQA2AgwgAEIANwIEIAAgAyABQfABcXJBAnI6AABBwDAMBgsgACABIAIQaSAAIAEoAgQgASgCAGtBAWo2AgRBwDAMBQsgAC0AAEEBcQRAIAAgASACEGkgACABKAIEIAEoAgBrQQFqNgIEQcAwDAULIABBAEECEGpBwDAMBAsgAC0AAEEBcUUEQCAAIAEgAhBpIAAgASgCBCABKAIAa0EBajYCBEHAMAwECyAAQQFBAhBqQcAwDAMLEFIACwJAIAEoAhxFDQAgAyAEIAEoAgBrQQFqIgRMDQACfyADIARrIQ0gAC0AAEEOcQRAQeSqBBBTCyANQQBIBEBBraYEEFMLIAAoAgwiA0EATARAQdylBBBTIAAoAgwhAwsgACgCFCADQQJ0akEEaygCAEEAIA0bRQRAQQEMAQtBACAAKAIIIA1qIgNrIQggA0EJbSIFQXdsIQYgACwAACIDQQBIBH9BkKcEEFMgAC0AAAUgAwtBwABxBEBBqqcEEFMLQfikBygCACIDIAAoAhAiBEoEQEHwnAQQUyAAKAIQIQRB+KQHKAIAIQMLAkAgBiAIRyAFaiIOIAMgAyAOSBsiAyAERg0AAn8gAC0AAEEgcQRAIAMgBEwNAiAAIAMgAhBkDAELIAAgAyACEGULDQBBAAwBCyAAKAIUIQwgACgCFCEJIAAoAgwiA0EAIAMgDk0bRQRAQZSRBBBTCwJAIA1BCW4iD0F3bCANaiIERQRAIANFDQEgA0EBayADQQNxIgYEQCADQQJ0IAlqQQRrIQUgAyAPakECdCAMakEEayEEA0AgBCAFKAIANgIAIAVBBGshBSAEQQRrIQQgA0EBayEDIAZBAWsiBg0ACwtBA0kNASADQQJ0IAlqQRBrIQUgAyAPakECdCAMakEQayEEA0AgBEEMaiAFQQxqKAIANgIAIARBCGogBUEIaigCADYCACAEQQRqIAVBBGooAgA2AgAgBCAFKAIANgIAIAVBEGshBSAEQRBrIQQgA0EEayIDDQALDAELIANBAmshBiAOQQFrIQogBEECdEHQpAdqKAIAIRAgA0ECdCAJakEEaygCACEFAkACQAJAAkBBCSAEayIHQQpPBEBB/KMEEFMMAQsgB0EESw0AQQAhBAJAAkACQAJAIAdBAWsOBAABAgMFCyAFIAVBCm4iBUF2bGohBAwECyAFIAVB5ABuIgVBnH9saiEEDAMLIAUgBUHoB24iBUGYeGxqIQQMAgsgBSAFQZDOAG4iBUHwsX9saiEEDAELAkACQAJAAkAgB0EFaw4EAAECAwULIAUgBUGgjQZuIgVB4PJ5bGohBAwDCyAFIAVBwIQ9biIFQcD7QmxqIQQMAgsgBSAFQYCt4gRuIgVBgNOde2xqIQQMAQsgBSAFQYDC1y9uIgVBgL6oUGxqIQQLIAUNAEEAIQUMAQsgDCAKQQJ0aiAFNgIAIA5BAmshCgsCQCAGQX9GBEAgBCEDDAELIAdBCk8EQCADQQFrIQggCSAGQQJ0aiEGIAwgCkECdGohCSAHQQVrIQoDQCAGKAIAIQdB/KMEEFMCQAJAAkACQAJAAkAgCg4FAAECAwQFCyAHQaCNBm4iBUHg8nlsIAdqIQMMBAsgB0HAhD1uIgVBwPtCbCAHaiEDDAMLIAdBgK3iBG4iBUGA0517bCAHaiEDDAILIAdBgMLXL24iBUGAvqhQbCAHaiEDDAELIAdBgJTr3ANuIgVBgOyUo3xsIAdqIQMLIAkgBSAEIBBsajYCACAGQQRrIQYgCUEEayEJIAMhBCAIQQFrIggNAAsMAQsgB0EFTwRAIANBAWshCCAJIAZBAnRqIQYgDCAKQQJ0aiEJIAdBBWshCgNAIAYoAgAhBwJAAkACQAJAAkACQCAKDgUEAwIBAAULIAdBgJTr3ANuIgVBgOyUo3xsIAdqIQMMBAsgB0GAwtcvbiIFQYC+qFBsIAdqIQMMAwsgB0GAreIEbiIFQYDTnXtsIAdqIQMMAgsgB0HAhD1uIgVBwPtCbCAHaiEDDAELIAdBoI0GbiIFQeDyeWwgB2ohAwsgCSAFIAQgEGxqNgIAIAZBBGshBiAJQQRrIQkgAyEEIAhBAWsiCA0ACwwBCyADQQFrIRIgCSAGQQJ0aiEJIAwgCkECdGohCgNAIAkoAgAhBiAHIQgCQAJAAkACQAJAAkAgBw4FBAMCAQAFCyAGIAZBkM4AbiIGQfCxf2xqIQgMAwsgBiAGQegHbiIGQZh4bGohCAwCCyAGIAZB5ABuIgZBnH9saiEIDAELIAYgBkEKbiIGQXZsaiEICyAGIQUgCCEDCyAKIAUgBCAQbGo2AgAgCUEEayEJIApBBGshCiADIQQgEkEBayISDQALCyAMIA9BAnRqIAMgEGw2AgALIA8EQCAMQQAgD0ECdBBZGgsgACAONgIMIAAgACgCBDYCBCAAIAAoAgggDWo2AgggACAALQAAQfABcSAALQAAQQ9xcjoAAEEBC0UNAyAAIAAoAgQgDWs2AgQgAiACKAIAQQFyNgIAIAAoAgwiA0EATARAQdylBBBTIAAoAgwhAwsgACgCFCADQQJ0akEEaygCAEUNA0GAwAAgESABKAIISA0CGgwDCyARIAEoAggiA04NAiADIAEoAgBrIAAoAgwiA0EATARAQdylBBBTIAAoAgwhAwtBAWohBCAAKAIUIANBAnRqQQRrKAIARQRAIAAoAgQgBE4NAyAAIAQ2AgQgACwAACIBQQBIBEBBkKcEEFMgAC0AACEBCwJAIAFBwABxBH9BqqcEEFMgAC0AAAUgAQtBIHENAEH4pAcoAgAiASAAKAIQTg0AIAtBADoADyAAIAAoAhQgASALQQ9qEGI2AhQgCy0ADw0AIABB+KQHKAIANgIQCyAAQoGAgIAQNwIIIAAoAhRBADYCAAwBCyACIAIoAgBBgMAAcjYCACAEIAAoAgQiA0wNAiAAIAQgA2sQbiEDIAAgBDYCBAJAAkACfwJAAkACQAJAAkACQAJAIAFBGGooAgAOCAUJAgMABAEGCQsgA0EESwwGCyADQQVLDQYgA0EFRw0HIAAoAhQoAgBBAXEMBQsgA0UNBiAALQAAQX9zQQFxDAQLIANFDQUgAC0AAEEBcQwDCyADQQVLDAILIANBAEcMAQsgACgCFCgCAEEKcCIBRSABQQVGciADQQBHcQtFDQELIAAoAhQgACgCDBBaIAAoAgwhCARAIAAsAAAiAUEASAR/QZCnBBBTIAAtAAAFIAELQcAAcQRAQaqnBBBTC0H4pAcoAgAiASAAKAIQIgRKBEBB8JwEEFMgACgCECEEQfikBygCACEBCwJAIAEgCEEBaiABIAhKGyIBIARGDQACfyAALQAAQSBxBEAgASAETA0CIAAgASACEGQMAQsgACABIAIQZQtFDQILIAAoAhQgACgCDEECdGpBATYCACAAIAAoAgxBAWoiCDYCDAsgCEEATARAQdylBBBTIAAoAgwhCAsgAAJ/IAAoAhQgCEECdGpBBGsoAgAiAUHgpAcoAgBJBEAgAUHYpAcoAgBJBEBBAUECQdSkBygCACABSxsMAgtBA0EEQdykBygCACABSxsMAQsgAUHopAcoAgBJBEBBBUEGQeSkBygCACABSxsMAQsgAUHwpAcoAgBJBEBBB0EIQeykBygCACABSxsMAQtBCUEKQfSkBygCACABSxsLIAhBCWxqQQlrNgIICyACIAIoAgAiAUGAIHI2AgAgA0UNAiACIAFBwKABcjYCACAAKAIMIgFBAEwEQEHcpQQQUyAAKAIMIQELIAAoAhQgAUECdGpBBGsoAgANAiMAQRBrIgEkACAALAAAIgNBAEgEQEGQpwQQUyAALQAAIQMLAkAgA0HAAHEEf0GqpwQQUyAALQAABSADC0EgcQ0AQfikBygCACIDIAAoAhBODQAgAUEAOgAPIAAgACgCFCADIAFBD2oQYjYCFCABLQAPDQAgAEH4pAcoAgA2AhALIABCgYCAgBA3AgggACgCFEEANgIAIAFBEGokAAtBAQsgAigCAHI2AgALIAtBEGokAAvNEgESfyMAQRBrIgwkACAALQAAQQ5xBEBB+aYEEFMLIAFBAEgEQEGtpgQQUwsgACgCDCIDQQBMBEBB3KUEEFMgACgCDCEDCwJAIAAoAhQiByADQQJ0IgJqQQRrKAIARSABRXINACABIAAoAggiBE4EQCACIAdqQQRrIQICQAJAIAEgBEcEQCADQQFqIQMDQCADQQFrIgNBAEoEQCACKAIAIAJBBGshAkUNAQsLIANBAEohAQwBCwJAAkACfyACKAIAIgJB4KQHKAIASQRAIAJB2KQHKAIASQRAQQFBAkHUpAcoAgAgAksbDAILQQNBBEHcpAcoAgAgAksbDAELIAJB6KQHKAIASQRAQQVBBkHkpAcoAgAgAksbDAELIAJB8KQHKAIASQRAQQdBCEHspAcoAgAgAksbDAELQQlBCkH0pAcoAgAgAksbCyIEQQFrIghBBE0EQEEAIQECQAJAAkACQCAIDgUFAAECAwYLIAIgAkEKbiICQXZsaiEBDAQLIAIgAkHkAG4iAkGcf2xqIQEMAwsgAiACQegHbiICQZh4bGohAQwCCyACIAJBkM4AbiICQfCxf2xqIQEMAQtBACEBAkACQAJAAkACQCAEQQZrDgUAAQIDBAYLIAIgAkGgjQZuIgJB4PJ5bGohAQwECyACIAJBwIQ9biICQcD7QmxqIQEMAwsgAiACQYCt4gRuIgJBgNOde2xqIQEMAgsgAiACQYDC1y9uIgJBgL6oUGxqIQEMAQsgAiACQYCU69wDbiICQYDslKN8bGohAQsgAiEFCyADQQJIIAFyRQRAIANBAnQgB2pBCGshAgNAIANBAWsiA0EASgRAIAIoAgAgAkEEayECRQ0BCwsgA0EASiEBCyAFDgYAAQEBAQABCyAFIAFBAEdqIQULIAAsAAAiAUEASARAQZCnBBBTIAAtAAAhAQsCQCABQcAAcQR/QaqnBBBTIAAtAAAFIAELQSBxDQBB+KQHKAIAIgEgACgCEE4NACAMQQA6AA8gACAAKAIUIAEgDEEPahBiNgIUIAwtAA8NACAAQfikBygCADYCEAsgAEKBgICAEDcCCCAAKAIUQQA2AgAMAQtBACECIAMiC0UEQEHIpQQQUwsCQAJAAkAgAUEJbiIFQXdsIAFqIggEQCAHIAVBAnRqKAIAIQNBACAIa0ECdEH0pAdqKAIAIRAgCEEKTwRAQfyjBBBTDAILIAhBBEsNAQJAAkACQAJAAkAgCEEBaw4EAAECAwQLIANBCm4iAkF2bCADaiEKDAYLIANB5ABuIgJBnH9sIANqIgNBCm4iCkF2bCADaiEGDAULIANB6AduIgJBmHhsIANqIgNB5ABuIgpBnH9sIANqIQYMBAsgAyADQZDOAG4iA0HwsX9saiEJCyAJQegHbiIKQZh4bCAJaiEGIAMhAgwCCwJAIAFBCUkNACAFQQJ0IAdqIgJBBGsoAgAiA0GAwtcvbiIKQYC+qFBsIANqIgYNACACQQhrIQQgBSEDA0AgA0EBayIDQQBKBEAgBCgCACAEQQRrIQRFDQELCyADQQBKIQYLIAsgBWsiA0UNAiADQQNxIQ1BACECIAVBf3MgC2pBA08EQCADQXxxIQkgByAFQQJ0aiELQQAhBANAIAQgB2oiAyAEIAtqIggoAgA2AgAgA0EEaiAIQQRqKAIANgIAIANBCGogCEEIaigCADYCACADQQxqIAhBDGooAgA2AgAgBEEQaiEEIAkgAkEEaiICRw0ACwsgDUUNAiAHIAJBAnRqIQQgByACIAVqQQJ0aiEDA0AgBCADKAIANgIAIANBBGohAyAEQQRqIQQgDUEBayINDQALDAILAn8CQAJ/AkACQAJAAkACQAJAIAhBBWsOBQAFAQIDBAsgA0GgjQZuIgJB4PJ5bCADaiIDQZDOAG4iCkHwsX9sIANqIQYMCAsgA0GAreIEbiICQYDTnXtsDAQLIANBgMLXL24iAkGAvqhQbAwDCyADQYCU69wDbiICQYDslKN8bAwCCyAIQQFrIglBCk8NAgwECyADQcCEPW4iAkHA+0JsCyEEIAhBAWshCSADIARqDAELQfyjBBBTQQALIQYCQAJAAkACQCAJQQVrDgQAAQIDBAsgBkGgjQZuIgpB4PJ5bCAGaiEGDAMLIAZBwIQ9biIKQcD7QmwgBmohBgwCCyAGQYCt4gRuIgpBgNOde2wgBmohBgwBCyAGQYDC1y9uIgpBgL6oUGwgBmohBgsgBiABQQlJckUEQCAFQQFqIQMgBUECdCAHakEEayEEA0AgA0EBayIDQQBKBEAgBCgCACAEQQRrIQRFDQELCyADQQBKIQYLIAsgBUEBaiIDSwRAIAcgA0ECdGohAyAIQQpJIREgCEEESyESIAhBBWshEyAFQX9zIAtqIg8hDSAHIQkDQCACIQsgAygCACEEAkACQAJAIBFFBEBB/KMEEFMMAQsgEg0AAkACQAJAAkAgCCIFDgUFAAECAwYLIAQgBEEKbiIEQXZsaiEFDAQLIAQgBEHkAG4iBEGcf2xqIQUMAwsgBCAEQegHbiIEQZh4bGohBQwCCyAEIARBkM4AbiIEQfCxf2xqIQUMAQsCQAJAAkACQAJAIBMOBQABAgMEBgsgBCAEQaCNBm4iBEHg8nlsaiEFDAQLIAQgBEHAhD1uIgRBwPtCbGohBQwDCyAEIARBgK3iBG4iBEGA0517bGohBQwCCyAEIARBgMLXL24iBEGAvqhQbGohBQwBCyAEIARBgJTr3ANuIgRBgOyUo3xsaiEFCyAEIQIgBSEOCyAJIA4gEGwgC2o2AgAgCUEEaiEJIANBBGohAyANQQFrIg0NAAsLIAJFDQAgByAPQQJ0aiACNgIACwJAAkAgCg4GAAEBAQEAAQsgCiAGQQBHaiEKCyAKIQUgACAAKAIIIAFrIgI2AgggAkEJbSIHQXdsIQQgACwAACIBQQBIBH9BkKcEEFMgAC0AAAUgAQtBwABxBEBBqqcEEFMLQfikBygCACIDIAAoAhAiAUoEQEHwnAQQU0H4pAcoAgAhAyAAKAIQIQELAkBBACACayAERyAHaiIHIAMgAyAHSBsiAiABRg0AIAAtAABBIHEEQCABIAJODQEgACACIAxBCGoQZBoMAQsgACACIAxBCGoQZRoLIAAgBzYCDAsgDEEQaiQAIAULgAUBBH8jAEEQayIGJAAgACwAACIEQQBIBEBBkKcEEFMgAC0AACEECwJAIARBwABxBH9BqqcEEFMgAC0AAAUgBAtBIHENAEH4pAcoAgAiBCAAKAIQTg0AIAZBADoADyAAIAAoAhQgBCAGQQ9qEGI2AhQgBi0ADw0AIABB+KQHKAIANgIQCyAAAn8gAUEASARAIABBADYCBCAAKAIUIgVBACABayIEQYCU69wDbiIHNgIEIAUgB0GA7JSjfGwgAWs2AgAgAEEBQQIgBEGAlOvcA0kbIgQ2AgwgACAALQAAQfABcUEBcjoAACAFIARBAnRqQQRrKAIAIgFB4KQHKAIASQRAIAFB2KQHKAIASQRAQQFBAkHUpAcoAgAgAUsbDAMLQQNBBEHcpAcoAgAgAUsbDAILIAFB6KQHKAIASQRAQQVBBkHkpAcoAgAgAUsbDAILIAFB8KQHKAIASQRAQQdBCEHspAcoAgAgAUsbDAILQQlBCkH0pAcoAgAgAUsbDAELIABBADYCBCAAKAIUIgUgAUGAlOvcA24iBDYCBCAFIARBgOyUo3xsIAFqNgIAIABBAUECIAFBgJTr3ANJGyIENgIMIAAgAC0AAEHwAXE6AAAgBSAEQQJ0akEEaygCACIBQeCkBygCAEkEQCABQdikBygCAEkEQEEBQQJB1KQHKAIAIAFLGwwCC0EDQQRB3KQHKAIAIAFLGwwBCyABQeikBygCAEkEQEEFQQZB5KQHKAIAIAFLGwwBCyABQfCkBygCAEkEQEEHQQhB7KQHKAIAIAFLGwwBC0EJQQpB9KQHKAIAIAFLGwsgBEEJbGpBCWs2AgggACACIAMQbCAGQRBqJAALAwAAC9kHAQp/IANFIAIgA0lyQQEgBBsEQEGLpQQQUwsCQAJAIARBCW4iCUF3bCAEaiIERQRAIANBAWohAiADQQJ0IAFqQQRrIQQgAyAJakECdCAAakEEayEDA0AgAkEBayICRQ0CIAQoAgAhASADKAIAIQUgBEEEayEEIANBBGshAyABIAVGDQALQX9BASABIAVLGw8LIARBAnRB0KQHaigCACEKIANBAnQgAWpBBGsoAgAhBQJAAkACQAJAQQkgBGsiCEEKTwRAQfyjBBBTDAELIAhBBEsNAAJAAkACQAJAIAhBAWsOBAABAgMFCyAFIAVBCm4iBUF2bGohBgwECyAFIAVB5ABuIgVBnH9saiEGDAMLIAUgBUHoB24iBUGYeGxqIQYMAgsgBSAFQZDOAG4iBUHwsX9saiEGDAELAkACQAJAAkAgCEEFaw4EAAECAwULIAUgBUGgjQZuIgVB4PJ5bGohBgwDCyAFIAVBwIQ9biIFQcD7QmxqIQYMAgsgBSAFQYCt4gRuIgVBgNOde2xqIQYMAQsgBSAFQYDC1y9uIgVBgL6oUGxqIQYLIAJBAWshBCAFRQRAQQAhBQwCCyAAIARBAnRqKAIAIgQgBUYNAEF/QQEgBCAFSRsPCyACQQJrIQQLAkAgA0ECayICQX9GBEAgBiEBDAELIANBAWshCyABIAJBAnRqIQMgACAEQQJ0aiECIAhBCkkhDCAIQQRLIQ0gCEEFayEOA0AgAygCACEEAkACQAJAIAxFBEBB/KMEEFMMAQsgDQ0AIAghBwJAAkACQAJAIAgOBQUAAQIDBgsgBCAEQQpuIgRBdmxqIQcMBAsgBCAEQeQAbiIEQZx/bGohBwwDCyAEIARB6AduIgRBmHhsaiEHDAILIAQgBEGQzgBuIgRB8LF/bGohBwwBCwJAAkACQAJAAkAgDg4FAAECAwQGCyAEIARBoI0GbiIEQeDyeWxqIQcMBAsgBCAEQcCEPW4iBEHA+0JsaiEHDAMLIAQgBEGAreIEbiIEQYDTnXtsaiEHDAILIAQgBEGAwtcvbiIEQYC+qFBsaiEHDAELIAQgBEGAlOvcA24iBEGA7JSjfGxqIQcLIAQhBSAHIQELIAIoAgAiBCAFIAYgCmxqIgZHBEBBf0EBIAQgBkkbDwsgA0EEayEDIAJBBGshAiABIQYgC0EBayILDQALCyAAIAlBAnRqKAIAIgIgASAKbCIBRw0BCyAJQQFqIQMgCUECdCAAakEEayEEA0AgA0EBayIDQQBKBEAgBCgCACAEQQRrIQRFDQELCyADQQBKDwtBf0EBIAEgAksbC+ABAgN/An4gAkECdCIDQaijB2ooAgAiBEEBayIFIABuIQIgA0G0owdqKAIAIQMCQCABQX9GBEAgBSACayICRQRAQQEPCyAErSEHQQEhAQNAAkAgAkEBcUUEQCADrSEGDAELIAOtIgYgAa1+IAeCpyEBCyACQQJJIAYgBn4gB4KnIQMgAkEBdiECRQ0ACwwBC0EBIQEgACAFSw0AIAStIQcDQAJAIAJBAXFFBEAgA60hBgwBCyADrSIGIAGtfiAHgqchAQsgAkEBSyAGIAZ+IAeCpyEDIAJBAXYhAg0ACwsgAQuDBAIGfwN+IABpQQFHBEBBtKgEEFMLAkACQCABQQFqDgMBAAEAC0HwpAQQUwsgAkEDTwRAQcakBBBTCwJAIABBAXYiCK1CAoYiCkIgiKcNACAKpyIEQQxqIgUgBEkNACAFQfykBygCABECACEDCyADIgVFBEBBAA8LIAJBAnQiBEGoowdqKAIAIgdBAWsiBiAAbiEDIARBtKMHaigCACEEAkAgAUF/RgRAIAetIQogBiADayIDRQRAQQEhAQwCC0EBIQEDQAJAIANBAXFFBEAgBK0hCQwBCyAErSIJIAGtfiAKgqchAQsgA0ECSSAJIAl+IAqCpyEEIANBAXYhA0UNAAsMAQsgB60hCkEBIQEgACAGSw0AA0ACQCADQQFxRQRAIAStIQkMAQsgBK0iCSABrX4gCoKnIQELIANBAUsgCSAJfiAKgqchBCADQQF2IQMNAAsLIAUgATYCCCAFIAc2AgQgBSACNgIAAkAgAEECSQ0AQQEhA0EBIAggCEEBTRsiBEEBcUEAIQIgAEEETwRAIAGtIQkgBUEQaiEDIARB/v///wdxIQBBASEEA0AgA0EEayAENgIAIAMgBK0gCX4gCoIiCz4CACADQQhqIQMgCSALfiAKgiILpyEEIAAgAkECaiICRw0ACyALpyEDC0UNACAFQQxqIAJBAnRqIAM2AgALIAUL/wECAn4DfyACQQJ0IgVBqKMHaigCACIGQQFrIgdBA24hAiAFQbSjB2ooAgAhBQJAIAFBf0YEQCAGrSEEIAcgAmsiAkUEQEEBIQEMAgtBASEBA0ACQCACQQFxRQRAIAWtIQMMAQsgBa0iAyABrX4gBIKnIQELIAJBAkkgAyADfiAEgqchBSACQQF2IQJFDQALDAELIAatIQRBASEBIAdBA0kNAANAAkAgAkEBcUUEQCAFrSEDDAELIAWtIgMgAa1+IASCpyEBCyACQQFLIAMgA34gBIKnIQUgAkEBdiECDQALCyAAIAE2AgQgAEEBNgIAIAAgAa0iAyADfiAEgj4CCAuQBQIMfwR+IAFpQQFHBEBBtKgEEFMLQamkBCEDAkAgAUEQTwRAQfOiBCEDIAFBgYCAEEkNAQsgAxBTCwJAIABBASABQf//A0tBBHQiAyADQQhyIAEgAUEQdiABQYCABEkbIgNBgAJJIgQbIgUgBUEEciADIANBCHYgBBsiA0EQSSIEGyIFIAVBAnIgAyADQQR2IAQbIgNBBEkiBBsgAyADQQJ2IAQbIgNBAUsiBGogAyAEdmpBAWsiAyADQQF2IgtrIgR0IgdBASALdCIIEHdFDQAgB0F/IAIQcyIJRQ0AIAAgAUECdGohDCABQQBKBEAgB0ECdCEFIAAhAwNAIAMgByAJEFwgAyAFaiIDIAxJDQALCyAAIAggBxB3RQRAIAlBiKUHKAIAEQEAQQAPCyACQQJ0QaijB2o1AgAhECABQX8gAhByIQ0gBARAQQIgByAHQQJNGyEOQQEhBQNAQQEhBiANIQQgBSEDA0ACQCADQQFxRQRAIAStIQ8MAQsgBK0iDyAGrX4gEIKnIQYLIANBAUsgDyAPfiAQgqchBCADQQF2IQMNAAsgACAFIAt0QQJ0aiEDIAatIg8gD34gEIIhD0IBIRFBACEEA0AgAyARQv////8PgyIRIAM1AgB+IBCCPgIAIANBBGoiCiAGrSISIAo1AgB+IBCCPgIAIANBCGohAyAPIBF+IBCCIREgDyASfiAQgqchBiAEQQJqIgQgCEkNAAsgBUEBaiIFIA5HDQALCyAHIAhHBEBBACEGIAlBiKUHKAIAEQEAIAhBfyACEHMiCUUNAQtBASEGIAFBAEoEQCAIQQJ0IQEDQCAAIAggCRBcIAAgAWoiACAMSQ0ACwsgCUGIpQcoAgARAQALIAYLkwUCDH8EfiABaUEBRwRAQbSoBBBTC0GppAQhAwJAIAFBEE8EQEHzogQhAyABQYGAgBBJDQELIAMQUwtBASABQf//A0tBBHQiAyADQQhyIAEgAUEQdiABQYCABEkbIgNBgAJJIgQbIgUgBUEEciADIANBCHYgBBsiA0EQSSIEGyIFIAVBAnIgAyADQQR2IAQbIgNBBEkiBBsgAyADQQJ2IAQbIgNBAUsiBGogAyAEdmpBAWsiBEEBdiILdCIHQQEgAhBzIghFBEBBAA8LIAAgAUECdGohDCABQQBKBEAgB0ECdCEFIAAhAwNAIAMgByAIEFwgAyAFaiIDIAxJDQALC0EBIAQgC2siA3QhBiACQQJ0QaijB2o1AgAhECABQQEgAhByIQ0gAwRAQQIgBiAGQQJNGyEOQQEhBQNAQQEhCSANIQQgBSEDA0ACQCADQQFxRQRAIAStIQ8MAQsgBK0iDyAJrX4gEIKnIQkLIANBAUsgDyAPfiAQgqchBCADQQF2IQMNAAsgACAFIAt0QQJ0aiEDIAmtIg8gD34gEIIhD0IBIRFBACEEA0AgAyARQv////8PgyIRIAM1AgB+IBCCPgIAIANBBGoiCiAJrSISIAo1AgB+IBCCPgIAIANBCGohAyAPIBF+IBCCIREgDyASfiAQgqchCSAEQQJqIgQgB0kNAAsgBUEBaiIFIA5HDQALCyAAIAYgBxB3RQRAIAhBiKUHKAIAEQEAQQAPCwJ/IAYgB0cEQCAIQYilBygCABEBAEEAIAZBASACEHMiCEUNARoLIAFBAEoEQCAGQQJ0IQEgACEDA0AgAyAGIAgQXCABIANqIgMgDEkNAAsLIAhBiKUHKAIAEQEAIAAgByAGEHdBAEcLC8gCAgN/AX4jAEEwayIDJAACQAJ/AkACQAJAIAKtIAGtfiIGQiCIUARAIAFpQQFHBEBB3qcEEFMLIAJpQQFHBEBBpagEEFMLIAEgAkYEQCAAIAIQeAwECyABIAFqIgQgAUkNASAGpyEFIAIgBEYEQEEAIAAgASACQQAQeUUNBRogACABEHggACAFQQF0QXxxaiABEHgMBAsgAiACaiIEIAJJDQIgASAERgRAIAAgAhB4IAAgBUEBdEF8cWogAhB4IAAgAiABQQEQeQ0EQQAMBQsQUgALIANBhJUENgIAIANB7AQ2AgQMBAsgA0GElQQ2AhAgA0HsBDYCFAwDCyADQYSVBDYCICADQewENgIkDAILQQELIANBMGokAA8LQaSjBygCABpBoJoEEFNBpKMHKAIAGkG5mgQQU0GkowcoAgAaQdGaBBBTEFIAC+sMAR1/IwBBgIAIayIKJAAgASECA0AgAiIGQQF2IQIgBkGAAUsNAAsgAQRAIAZBAnQhBSAGQQN0IRkgBkEEdCEQIAFBBHQhESAGQQNxIQ0gBkECayEaIAZBAWshEiABIAZsQQJ0IRxBACAGQXxxayETIAFBAnQiCEEEaiAGbCEdIAAhGANAIAEgD2whHiAYIhQhFyAPIRUDQCAAIBUgHmpBAnRqIQ4CQCAGRQ0AIApBgIAEaiEDIA4hAiASQQNPBEAgEyEEIBQhAiAOIQcDQCADIAIgBRBYIQsgByAIaiIMIAhqIgkgCGoiAyAIaiEHIAIgEWohAiAFIAtqIAwgBRBYIAVqIAkgBRBYIAVqIAMgBRBYIAVqIQMgBEEEaiIEDQALIAsgEGohAwsgDQRAIA0hBANAIAMgAiAFEFggBWohAyACIAhqIQIgBEEBayIEDQALCyAGRQ0AQQAhCQNAAkAgCSICQQFqIgkgBk8NACACIAZsIAlqIQMgBiAJbCACaiEEIBIgAmtBAXEEfyAKQYCABGoiCyADQQJ0aiIHKAIAIQwgByAEQQJ0IAtqIgcoAgA2AgAgByAMNgIAIAQgBmohBCADQQFqIQMgAkECagUgCQshByACIBpGDQAgBEECdCELIAYgB2shByAKQYCABGoiBCADQQJ0aiECIAQhAwNAIAIoAgAhDCACIAMgC2oiBCgCADYCACAEIAw2AgAgAkEEaiIEKAIAIQwgBCADIAVqIAtqIgQoAgA2AgAgBCAMNgIAIAMgGWohAyACQQhqIQIgB0ECayIHDQALCyAGIAlHDQALCwJAIA8gFUYEQCAGRQ0BIApBgIAEaiEDAkAgEkEDSQRAIA4hAgwBCyAKQYCABGohBCATIQcgFCECA0AgAiAEIgMgBRBYIAggDmogAyAFaiICIAUQWCAIaiACIAVqIgIgBRBYIAhqIAIgBWoiBCAFEFggCGohDiARaiECIAQgBWohBCAHQQRqIgcNAAsgAyAQaiEDCyANRQ0BIA0hBANAIAIgAyAFEFggCGohAiADIAVqIQMgBEEBayIEDQALDAELIAZFDQAgCiEDIAAgASAVbCAPakECdGoiDCECIBJBA0kiG0UEQCADIQQgEyEHIBchAiAMIQMDQCAEIAIgBRBYIRYgAyAIaiILIAhqIgkgCGoiBCAIaiEDIAIgEWohAiAFIBZqIAsgBRBYIAVqIAkgBRBYIAVqIAQgBRBYIAVqIQQgB0EEaiIHDQALIBAgFmohAwsgDQRAIA0hBANAIAMgAiAFEFggBWohAyACIAhqIQIgBEEBayIEDQALCyAGRQ0AQQAhCQNAAkAgCSICQQFqIgkgBk8NACACIAZsIAlqIQMgBiAJbCACaiEEIBIgAmtBAXEEfyAKIANBAnRqIgcoAgAhCyAHIAogBEECdGoiBygCADYCACAHIAs2AgAgBCAGaiEEIANBAWohAyACQQJqBSAJCyEHIAIgGkYNACAEQQJ0IRYgBiAHayEHIAogA0ECdGohAiAKIQMDQCACKAIAIQsgAiADIBZqIgQoAgA2AgAgBCALNgIAIAJBBGoiBCgCACELIAQgAyAFaiAWaiIEKAIANgIAIAQgCzYCACADIBlqIQMgAkEIaiECIAdBAmsiBw0ACwsgBiAJRw0ACyAGRQ0AIApBgIAEaiEDAkAgGwRAIAwhAgwBCyAKQYCABGohAyATIQQgFyECA0AgAiADIgcgBRBYIAggDGogAyAFaiICIAUQWCAIaiACIAVqIgIgBRBYIAhqIAIgBWoiAyAFEFggCGohDCARaiECIAMgBWohAyAEQQRqIgQNAAsgByAQaiEDCyANBEAgDSEEA0AgAiADIAUQWCAIaiECIAMgBWohAyAEQQFrIgQNAAsLIAZFDQAgCiEDAkAgGwRAIA4hAgwBCyATIQQgFCECA0AgAiADIgcgBRBYIAggDmogAyAFaiICIAUQWCAIaiACIAVqIgIgBRBYIAhqIAIgBWoiAyAFEFggCGohDiARaiECIAMgBWohAyAEQQRqIgQNAAsgByAQaiEDCyANRQ0AIA0hBANAIAIgAyAFEFggCGohAiADIAVqIQMgBEEBayIEDQALCyAXIBxqIRcgBSAUaiEUIAYgFWoiFSABSQ0ACyAYIB1qIRggBiAPaiIPIAFJDQALCyAKQYCACGokAAvDCAIafwN+IwBBkIACayIMJAAgASABIAFqIgRNBEAgAiAERwRAQe2nBBBTCyABQQJ2QQFqIgStQgKGQiCIUAR/IARBBEGEpQcoAgARBAAFQQALIhIEfyABRSACQQJJckUEQEECIAEgAxutIR8gAkEBayIVrSEgIAJBAXYiE0ECdCEZIAJBAXQhGiACIRRBASELA0ACQCALQR9xQQJ0QdCjB2oiFigCACASIAtBA3ZB/P///wFxaiIQKAIAcQ0AIAutIB9+Ih6nIBUgHiAggKdsayIFIAJsQQF2IRcgBSALRwRAIAIgC2xBAXYhD0EAIQggDEGQgAFqIQMgDEEQaiERA0AgAyAAIAggD2pBAnRqQYCAASATIAhrQQJ0IAhBgCBqIgkgE0kiDRsiChBYGiAXIQ4gBSEHIBEhBANAIAQiESAAIAggDmpBAnRqIgQgChBYIQYgBCADIgQgChBYGiASIAdBA3ZB/P///wFxaiIDIAMoAgAgB0EfcUECdEHQowdqKAIAcjYCACAHrSAffiIepyAVIB4gIICnbGsiByACbEEBdiEOIAYhAyAHIAtHDQALIAAgCCAOakECdGogBiAKEFgaIBAgECgCACAWKAIAcjYCACAJIQggBCEDIA0NAAsMAQsgACAUQQF0QXxxaiEHQQAhA0GAICEPIAxBkIABaiEEIAxBEGohCCAZIQ4DQCAIIAQgB0GAgAEgDiAPIBNJIhsbIgQQWCEIIAAgAyAXakECdGohGEEAIQUgBBAgIQoCQCAERQ0AIARBA3EhCSAEQQFrIhxBA08EQCAEQXxxIR0DQCAFIApqIgYgBSAHaiINLQAAOgAAIAZBAWogDUEBai0AADoAACAGQQJqIA1BAmotAAA6AAAgBkEDaiANQQNqLQAAOgAAIB0gBUEEaiIFRw0ACwsgCQRAIAUgB2ohBiAFIApqIQUDQCAFIAYtAAA6AAAgBkEBaiEGIAVBAWohBSAJQQFrIgkNAAsLIARFDQAgBEEDcSEJQQAhBSAcQQNPBEAgBEF8cSENA0AgBSAYaiIEIAUgCmoiBi0AADoAACAEQQFqIAZBAWotAAA6AAAgBEECaiAGQQJqLQAAOgAAIARBA2ogBkEDai0AADoAACANIAVBBGoiBUcNAAsLIAlFDQAgBSAKaiEGIAUgGGohBQNAIAUgBi0AADoAACAGQQFqIQYgBUEBaiEFIAlBAWsiCQ0ACwsgChAhIBAgECgCACAWKAIAcjYCACAPQYAgaiEPIA5BgIABayEOIAdBgIABaiEHIANBgCBqIQMhBCAbDQALCyAUIBpqIRQgC0ECaiILIAFNDQALCyASQYilBygCABEBAEEBBUEACyAMQZCAAmokAA8LIAxBhJUENgIAIAxB7AQ2AgRBpKMHKAIAGkGgmgQQU0GkowcoAgAaQbmaBBBTQaSjBygCABpB0ZoEEFMQUgALjQIBA38jAEEgayIDJAAgA0EIaiIBQtEFNwMIIAFBgwI7AQACf0HwpQcoAgAoAgQhACABEDIhBCAAKAIEIAQgACgCCHBBAnRqKAIAIgAEQANAIAAgACgCACABEDNFDQIaIAAoAggiAA0ACwtBAAsiAARAIAAoAgQhAgsgA0EgaiQAIAIiAARAIAAPCwJAAkBBACIBBEBBAEGHpwcQM0UNAQwCC0GHpwchAQsgAQRAAkAgAARAIAAgARAzRQ0BDAMLIAEhAAsLIABFBEACQCAABEAgAEGJpwcQM0UNAUEDQQkQDQALQYmnByEACwtC0QUQQSEBQfClBygCACgCBCABIAAQPyAADwtBBUEBEA0ACwQAEEYLFgEBfxBGIgBBp6cHEERCABBBED8gAAv5BgECf0HApQdBsKgHNgIAQQBAACEAQfiiB0Hoogc2AgBB8KIHQfSiBzYCAEHoogdCADcDAEHYogdByKIHNgIAQdCiB0HUogc2AgBByKIHQgA3AwBBuKIHQaiiBzYCAEGwogdBtKIHNgIAQaiiB0IANwMAQZiiB0GIogc2AgBBkKIHQZSiBzYCAEGIogdCADcDAEH4oQdB6KEHNgIAQfChB0H0oQc2AgBB6KEHQgA3AwBBxKUHIABBEHQ2AgBB/KIHQQA2AgBB9KIHQQA2AgBB3KIHQQA2AgBB1KIHQQA2AgBBvKIHQQA2AgBBtKIHQQA2AgBBnKIHQQA2AgBBlKIHQQA2AgBB/KEHQQA2AgBB9KEHQQA2AgBBmKMHQYijBzYCAEGQowdBlKMHNgIAQYijB0IANwIAQdClB0IANwMAQdilB0IANwMAQeClB0IANwMAQeilB0IANwMAQdCgB0HUoAc2AgBB2KAHQcigBzYCAEHwoAdB9KAHNgIAQfigB0HooAc2AgBBkKEHQZShBzYCAEGYoQdBiKEHNgIAQbChB0G0oQc2AgBBuKEHQaihBzYCAEHQoQdB1KEHNgIAQdihB0HIoQc2AgBByKAHQgA3AwBB6KAHQgA3AwBBiKEHQgA3AwBBqKEHQgA3AwBByKEHQgA3AwBBnKMHQQA2AgBBlKMHQQA2AgBByKUHQQA6AABB1KAHQQA2AgBB3KAHQQA2AgBB9KAHQQA2AgBB/KAHQQA2AgBBlKEHQQA2AgBBnKEHQQA2AgBBtKEHQQA2AgBBvKEHQQA2AgBB1KEHQQA2AgBB3KEHQQA2AgAjAEEQayIAJABB9KUHLQAARQRAQYCmB0HAh6y1fjYCAEH4pQdCkoCAgICIv6oZNwIAQZSmB0KAgICAEDcCAEGMpgdCgICAgMAANwIAQYSmB0K+lwE3AgBBhKYHQQA2AgBBpKYHQcCHrLV+NgIAQZymB0LA+NPKgYi/qhk3AgBBuKYHQoCAgIAQNwIAQbCmB0KAgICA4AA3AgBBqKYHQr6XATcCAEG0pgdBBDYCAEGopgdBADYCAEHApgcQYyIBNgIAIABBADYCDCABQQFBnKYHIABBDGoQbyAAKAIMBEBB84MEEFMLQfSlB0EBOgAACyAAQRBqJABBxKYHKAIARQRAQcSmB0GJqAdBJxAQNgIACwsLzagDBQBBgIAEC7SgA34AfABJbmZpbml0eQBBbnkAYXJyYXkAb3BhX21hbGxvYzogaWxsZWdhbCBidWlsdGluIGNhY2hlIGluZGV4ACUwMngAJXgAb3BhX251bWJlcl90b19iZjogaW52YWxpZCBudW1iZXIgeABvcGFfbnVtYmVyX3RvX2JmOiBvdmVyZmxvdwBIZWJyZXcAXHcATGlzdQBEaXZlc19Ba3VydQBOdXNodQBUZWx1Z3UATGltYnUAUGF1X0Npbl9IYXUATHUAbXVsX3NpemVfdCgpOiBvdmVyZmxvdzogY2hlY2sgdGhlIGNvbnRleHQAYWRkX3NpemVfdCgpOiBvdmVyZmxvdzogY2hlY2sgdGhlIGNvbnRleHQAc3ViX3NpemVfdCgpOiBvdmVyZmxvdzogY2hlY2sgdGhlIGNvbnRleHQAdW5leHBlY3RlZCBlbmQgb2YgaW5wdXQAVGFuZ3V0AGxpYm1wZGVjOiBpbnRlcm5hbCBlcnJvciBpbiBfbXBkX2Jhc2VfbmRpdm1vZDogcGxlYXNlIHJlcG9ydABLaGl0YW5fU21hbGxfU2NyaXB0AG9wYV9iaXRzX2FuZF9ub3QAQ3lwcmlvdABhZ2dyZWdhdGVzOiBpbnQAaW52YWxpZCByZXNlcnZlZCBhcmd1bWVudABtcGQ6IGluaXQAb3BhX2JpdHNfc2hpZnQAc2V0AERlc2VyZXQAVGFpX1ZpZXQAb2JqZWN0AEx0AGludmFsaWQgY2hhcmFjdGVyIGNsYXNzAEVneXB0aWFuX0hpZXJvZ2x5cGhzAEFuYXRvbGlhbl9IaWVyb2dseXBocwBNZXJvaXRpY19IaWVyb2dseXBocwBccwBacwBQcwBDcwAlczolczolczogJXMAb3BhX251bWJlcl90cnlfaW50OiBpbGxlZ2FsIHJlcHIAb3BhX251bWJlcl9hc19mbG9hdDogaWxsZWdhbCByZXByAG9wYV92YWx1ZV9zaGFsbG93X2NvcHlfbnVtYmVyOiBpbGxlZ2FsIHJlcHIAb3BhX2pzb25fd3JpdGVyX2VtaXRfbnVtYmVyOiBpbGxlZ2FsIHJlcHIAb3BhX251bWJlcl90b19iZjogaWxsZWdhbCByZXByAG9wYV9iaXRzX3hvcgBubyBhcmd1bWVudCBmb3IgcmVwZXRpdGlvbiBvcGVyYXRvcgBiYWQgcmVwZXRpdGlvbiBvcGVyYXRvcgBpbnZhbGlkIHBlcmwgb3BlcmF0b3IAbm8gZXJyb3IAdW5leHBlY3RlZCBlcnJvcgBvcGFfYml0c19vcgBoaSBjaGFyYWN0ZXIgc2hvdWxkIGJlIGdyZWF0ZXIgdGhhbiBsbyBjaGFyYWN0ZXIAdW5leHBlY3RlZCBsZW5ndGggb2YgbG8gY2hhcmFjdGVyAHVuZXhwZWN0ZWQgbGVuZ3RoIG9mIGhpIGNoYXJhY3RlcgBpbGxlZ2FsIHN0cmluZyBlc2NhcGUgY2hhcmFjdGVyAGRlbGltaXRlciBpcyBub3QgYSBzaW5nbGUgY2hhcmFjdGVyAGV4cGVjdGVkIGNsb3NlIHJhbmdlIGNoYXJhY3RlcgBpbGxlZ2FsIHVuZXNjYXBlZCBjaGFyYWN0ZXIAS2htZXIAb3BhX3ZhbHVlX2NvbXBhcmVfbnVtYmVyAG9wYV9hcml0aF9tdWx0aXBseTogaW52YWxpZCBudW1iZXIAb3BhX2FyaXRoX21pbnVzOiBpbnZhbGlkIG51bWJlcgBvcGFfYXJpdGhfcGx1czogaW52YWxpZCBudW1iZXIAb3BhX251bWJlcl90b19iZjogaW52YWxpZCBudW1iZXIAb3BhX2FyaXRoX2RpdmlkZTogaW52YWxpZCBudW1iZXIAb3BhX2FyaXRoX3JvdW5kOiBpbnZhbGlkIG51bWJlcgBNYWthc2FyAE15YW5tYXIAaW52YWxpZCBuYW1lZCBjYXB0dXJlIGdyb3VwAFpwAE1ybwBIYW51bm9vAE5rbwBXYW5jaG8AQm9wb21vZm8AU295b21ibwBNaWFvAExhbwBTbwBQbwBObwBMbwBDbwAlbwBvcGFfbnVtYmVyc19yYW5nZTogY29tcGFyaXNvbgBDb21tb24Ab3BhX2JpdHM6IGJpdHMgY29udmVyc2lvbgBvcGFfYml0czogYWJzIGNvbnZlcnNpb24Ab3BhX251bWJlcnNfcmFuZ2U6IGNvbnZlcnNpb24ATGF0aW4ATWVkZWZhaWRyaW4AdWxlbiA+PSB2bGVuAHVuZXhwZWN0ZWQgdG9rZW4ATWFyY2hlbgBEdXBsb3lhbgBBdmVzdGFuAFNhbWFyaXRhbgBUaWJldGFuAEVsYmFzYW4ASGF0cmFuAG5hbgBTaGF2aWFuAE9sZF9QZXJzaWFuAE9sZF9IdW5nYXJpYW4AQ2FyaWFuAEFybWVuaWFuAENhdWNhc2lhbl9BbGJhbmlhbgBDaG9yYXNtaWFuAE1vbmdvbGlhbgBJbnNjcmlwdGlvbmFsX1BhcnRoaWFuAEdlb3JnaWFuAEx5ZGlhbgBPbGRfU29nZGlhbgBMeWNpYW4AUGhvZW5pY2lhbgBPbGRfU291dGhfQXJhYmlhbgBPbGRfTm9ydGhfQXJhYmlhbgBib29sZWFuAE5hYmF0YWVhbgBNYW5pY2hhZWFuAEhhbgBNbgBuID4gMSAmJiBucGx1c20gPj0gbgBuID4gMCAmJiBtID49IG4AbiA+PSAwICYmIHN0YXRpY19jYXN0PHVpbnQxNl90PihuKSA9PSBuAEJhbXVtAEN1bmVpZm9ybQBBaG9tAGNwIDwgZGVjc3RyaW5nK21lbQBBZGxhbQBNYWxheWFsYW0AT2doYW0AU2lkZGhhbQBUYWlfVGhhbQBDaGFtAFNtAExtAG0gPiAwICYmIG4gPj0gbQBvcGFfYml0czogbXVsAEhhbmd1bAB0ICE9IF9fbnVsbABiICE9IF9fbnVsbABhICE9IF9fbnVsbABUYW1pbABwdXJlIHZpcnR1YWwAQ2FuYWRpYW5fQWJvcmlnaW5hbABabABObABMbABNZWV0ZWlfTWF5ZWsAR3JlZWsAQmF0YWsAU2sAUHNhbHRlcl9QYWhsYXZpAEluc2NyaXB0aW9uYWxfUGFobGF2aQBNZW5kZV9LaWtha3VpAFdhcmFuZ19DaXRpAEd1amFyYXRpAFRha3JpAFN5bG90aV9OYWdyaQBOYW5kaW5hZ2FyaQBEZXZhbmFnYXJpAGZuaQBNdWx0YW5pAE1haGFqYW5pAEJyYWhtaQBCZW5nYWxpAEJoYWlrc3VraQBLaG9qa2kAT2xfQ2hpa2kAS2FpdGhpAEtoYXJvc2h0aGkAR3VybXVraGkATW9kaQBNYXNhcmFtX0dvbmRpAEd1bmphbGFfR29uZGkAWWV6aWRpAEtodWRhd2FkaQBUaGFpAFZhaQBZaQBQaQBLYXlhaF9MaQBUaWZpbmFnaABvcGNvZGUoKSA9PSBrSW5zdEFsdCB8fCBvcGNvZGUoKSA9PSBrSW5zdEFsdE1hdGNoAEJhc3NhX1ZhaABzcmMvbGlibXBkZWMvdHlwZWFyaXRoLmgAVGFnYWxvZwBQYWhhd2hfSG1vbmcATnlpYWtlbmdfUHVhY2h1ZV9IbW9uZwBTaWduV3JpdGluZwBzdHJpbmcAb3BfID09IGtSZWdleHBMaXRlcmFsU3RyaW5nAFNvcmFfU29tcGVuZwBSZWphbmcAb3BhX2JpdHNfbmVnAG9wYV9udW1iZXJfYXNfZmxvYXQ6IGlsbGVnYWwgcmVmADAxMjM0NTY3ODlhYmNkZWYAUGYAQ2YAaW52YWxpZCByZXBldGl0aW9uIHNpemUATWVyb2l0aWNfQ3Vyc2l2ZQB0cnVlAGlsbGVnYWwgdmFsdWUATmV3X1RhaV9MdWUAb3BhX2JpdHNfbmVnYXRlAGZhbHNlAEJhbGluZXNlAEJ1Z2luZXNlAEphdmFuZXNlAFN1bmRhbmVzZQBaYW5hYmF6YXJfU3F1YXJlAGNvdWxkIG5vdCB1bnJlYWQgcnVuZQBvcGFfYml0czogbWludXMgb25lAG9wYV9iaXRzOiBhZGQgb25lAFBhbG15cmVuZQBCcmFpbGxlAGludmFsaWQgY2hhcmFjdGVyIGNsYXNzIHJhbmdlAGNvdWxkIG5vdCBwYXJzZSByYW5nZQBpbnN0X1tyb290XS5vcGNvZGUoKSA9PSBrSW5zdEFsdCB8fCBpbnN0X1tyb290XS5vcGNvZGUoKSA9PSBrSW5zdEJ5dGVSYW5nZQBPc2FnZQBDaGVyb2tlZQBzdHJpbmc6IGludmFsaWQgdW5pY29kZQBpbnZhbGlkIGVzY2FwZSBzZXF1ZW5jZQBQZQBNZQBUYWlfTGUAdW5leHBlY3RlZCBlbmQAb3BhX2JpdHNfYW5kAEJ1aGlkAGZwcmludGY6IG5vdCBpbXBsZW1lbnRlZABmd3JpdGU6IG5vdCBpbXBsZW1lbnRlZABmcHV0Yzogbm90IGltcGxlbWVudGVkAEluaGVyaXRlZABzdHJpbmdzOiBnZXQgdWludCBmYWlsZWQAb3BhX2hlYXBfYmxvY2tzX3N0YXNoKCkgY29uc2lzdGVuY3kgY2hlY2sgZmFpbGVkAG9wYV9oZWFwX2Jsb2Nrc19yZXN0b3JlKCkgY29uc2lzdGVuY3kgY2hlY2sgZmFpbGVkAHN0cmluZ3M6IHRydW5jYXRlIGZhaWxlZABwYXR0ZXJuIHRvbyBsYXJnZSAtIGNvbXBpbGUgZmFpbGVkAG9wYV9tYWxsb2M6IGZhaWxlZABvcGFfYml0czogYWRkAFxkAFBkAE5kACVkAG53b3JkcyA+PSByZXN1bHQtPmFsbG9jAE1QRF9NSU5BTExPQyA8PSByZXN1bHQtPmFsbG9jAENvcHRpYwBVZ2FyaXRpYwBHbGFnb2xpdGljAEV0aGlvcGljAFJ1bmljAE9sZF9QZXJtaWMAQ3lyaWxsaWMAT2xkX0l0YWxpYwBPbGRfVHVya2ljAEdvdGhpYwBBcmFiaWMARWx5bWFpYwBJbXBlcmlhbF9BcmFtYWljAE1hbmRhaWMAU3lyaWFjAFNjAFBjAE1jAENjAHNyYy9saWJtcGRlYy9tcGRlY2ltYWwuYwAlYgBPc21hbnlhAE9yaXlhAEhhbmlmaV9Sb2hpbmd5YQBUYWdiYW53YQBOZXdhAFRpcmh1dGEAU2F1cmFzaHRyYQBEb2dyYQBLYXRha2FuYQBIaXJhZ2FuYQBUaGFhbmEAQ2hha21hAFNpbmhhbGEAR3JhbnRoYQBMZXBjaGEAU2hhcmFkYQBLYW5uYWRhAFBoYWdzX1BhAHJlc3VsdCAhPSBhADAgPD0gc2l6ZV8AW14AWzpecHJpbnQ6XQBbOnByaW50Ol0AWzpeeGRpZ2l0Ol0AWzp4ZGlnaXQ6XQBbOl5kaWdpdDpdAFs6ZGlnaXQ6XQBbOl5wdW5jdDpdAFs6cHVuY3Q6XQBbOl5sb3dlcjpdAFs6bG93ZXI6XQBbOl51cHBlcjpdAFs6dXBwZXI6XQBbOl5hbG51bTpdAFs6YWxudW06XQBbOl5jbnRybDpdAFs6Y250cmw6XQBbOl5ibGFuazpdAFs6Ymxhbms6XQBbOl5hc2NpaTpdAFs6YXNjaWk6XQBbOl5ncmFwaDpdAFs6Z3JhcGg6XQBbOl5zcGFjZTpdAFs6c3BhY2U6XQBbOl53b3JkOl0AWzp3b3JkOl0AWzpeYWxwaGE6XQBbOmFscGhhOl0AbWlzc2luZyBdAHRyYWlsaW5nIFwAWwBaAGNwLWRlY3N0cmluZyA8IE1QRF9TU0laRV9NQVgAXFcAXFMAUABzTmFOAG4gPD0gMypNUERfTUFYVFJBTlNGT1JNXzJOAG4gPD0gTVBEX01BWFRSQU5TRk9STV8yTgBNAGxhIDw9IE1QRF9LQVJBVFNVQkFfQkFTRUNBU0UgfHwgdyAhPSBOVUxMAGxhIDw9IDMqKE1QRF9NQVhUUkFOU0ZPUk1fMk4vMikgfHwgdyAhPSBOVUxMAFxEAEMATGluZWFyX0IATGluZWFyX0EAZXhwIDw9IDkAbiA+PSA0OABpbGxlZ2FsIHV0Zi04AGludmFsaWQgVVRGLTgAbiA+PSAxNgB1bGVuID49IDQAcnNpemUgPj0gNABQMSA8PSBtb2RudW0gJiYgbW9kbnVtIDw9IFAzAGJhc2UgPj0gMgB+MQBzaWduID09IC0xIHx8IHNpZ24gPT0gMQB+MABtID4gMCAmJiBuID49IG0gJiYgc2hpZnQgPiAwAGRpZ2l0cyA+IDAAd2xlbiA+IDAgJiYgdWxlbiA+IDAAc2xlbiA+IDAAc3JjbGVuID4gMABkZWMtPmxlbiA+IDAAbSA+IDAgJiYgbiA+IDAAbSA+IDAAbWF4cHJlYyA+IDAgJiYgaW5pdHByZWMgPiAwAGxhID49IGxiICYmIGxiID4gMABuID49IDAAaSA+PSAwAGNhcnJ5WzBdID09IDAgJiYgY2FycnlbMV0gPT0gMCAmJiBjYXJyeVsyXSA9PSAwAC8ALgAtAGZuaSsALioAIW1wZF9pc3NwZWNpYWwocmVzdWx0KQAhbXBkX2lzY29uc3RfZGF0YShyZXN1bHQpACFtcGRfaXNzaGFyZWRfZGF0YShyZXN1bHQpAChvcF8pID09IChrUmVnZXhwUmVwZWF0KQBpc3Bvd2VyMihyb3dzKQBjb2xzID09IG11bF9zaXplX3QoMiwgcm93cykAKG9wXykgPT0gKGtSZWdleHBDaGFyQ2xhc3MpAGlzcG93ZXIyKGNvbHMpAGlzcG93ZXIyKG4pAChuKSA9PSAobSkAKG9wXykgPT0gKGtSZWdleHBMaXRlcmFsKQAobG8pIDw9IChoaSkAIWhhc19pbmRleChpKQAhY29udGFpbnMoaSkAKG9wY29kZSgpKSA9PSAoa0luc3RFbXB0eVdpZHRoKQAob3Bjb2RlKCkpID09IChrSW5zdEFsdE1hdGNoKQAob3BfKSA9PSAoa1JlZ2V4cExpdGVyYWxTdHJpbmcpAChvcGNvZGUoKSkgPT0gKGtJbnN0Q2FwdHVyZSkAKG9wXykgPT0gKGtSZWdleHBDYXB0dXJlKQAob3Bjb2RlKCkpID09IChrSW5zdEJ5dGVSYW5nZSkAbXBkX2lzaW5maW5pdGUoYikAbXBkX2lzaW50ZWdlcihhKQAhbXBkX2lzc3BlY2lhbChhKQB3YmFzZSA8PSAoMVU8PDE2KQB1YmFzZSA8PSAoMVU8PDE2KQByYmFzZSA8PSAoMVU8PDE2KQBzcmNiYXNlIDw9ICgxVTw8MTYpAChsbykgPD0gKDI1NSkAKGhpKSA8PSAoMjU1KQAoYykgPD0gKDI1NSkAKG4pID49ICgyKQAocHJlZml4X3NpemVfKSA+PSAoMikAKGlkKSA9PSAobmluc3RfLTEpAChwcmVmaXhfc2l6ZV8pID49ICgxKQAobG8pID49ICgwKQAoaGkpID49ICgwKQAoYykgPj0gKDApACh0LT5yZWYpID09ICgwKQAob3V0X29wY29kZV8pID09ICgwKQAoc3RhcnQoKSkgPT0gKDApAChydW5xLT5zaXplKCkpID09ICgwKQAoc2l6ZSkgPj0gKHN0YXRpY19jYXN0PHNpemVfdD4ocC1wMCkpACh0b3RhbCkgPT0gKHN0YXRpY19jYXN0PGludD4oZmxhdC5zaXplKCkpKQAobikgPD0gKHN0YXRpY19jYXN0PGludD4ocmFuZ2VzXy5zaXplKCkpKQAobikgPD0gKHEtPnNpemUoKSkAKG5zdGspIDw9IChzdGFja18uc2l6ZSgpKQAhaXAtPmxhc3QoKQBpZCA9PSAwIHx8IHByb2dfLT5pbnN0KGlkLTEpLT5sYXN0KCkAc2l6ZV8gPD0gbWF4X3NpemUoKQBpIDwgbWF4X3NpemUoKQBzaXplXyA8IG1heF9zaXplKCkAbWlzc2luZyApAHVuZXhwZWN0ZWQgKQBzZXQoACQAZmFsc2UgJiYgImlsbGVnYWwgaW5kZXgiACVzOiVkOiBlcnJvcjogACVzOiVkOiB3YXJuaW5nOiAAMDEyMzQ1Njc4OQAAAAAAAAAAAAAAAAAAMDEyMzQ1Njc4OWFiY2RlZgAAAAAAAAAAAAAAAAAAAAAwMTIzNDU2Nzg5QUJDREVGAAAAAAAAAAAAAAAAAAAAAEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXowMTIzNDU2Nzg5Ky8AAAAAAAAAAAAAAAAAAAAAQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVphYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ejAxMjM0NTY3ODktXwAAAAA9DwEAPQ8BAD0PAQAfBgEAVQ4BAD0PAQA9DwEARAABAAAAAAAAAAAAAAAAAAkADQABACAAhQBlAKAAgBbgFQAgCiABACggKSABAC8gXyAwAAAwADABAAAAAAAAAEEAAABaAAAAAAAAACAAAAAAAAAAYQAAAHoAAADg////AAAAAOD///+1AAAAtQAAAOcCAAAAAAAA5wIAAMAAAADWAAAAAAAAACAAAAAAAAAA2AAAAN4AAAAAAAAAIAAAAAAAAADgAAAA9gAAAOD///8AAAAA4P////gAAAD+AAAA4P///wAAAADg/////wAAAP8AAAB5AAAAAAAAAHkAAAAAAQAALwEAAAAAEQAAABEAAAARADABAAAwAQAAAAAAADn///8AAAAAMQEAADEBAAAY////AAAAABj///8yAQAANwEAAAAAEQAAABEAAAARADkBAABIAQAAAAARAAAAEQAAABEASgEAAHcBAAAAABEAAAARAAAAEQB4AQAAeAEAAAAAAACH////AAAAAHkBAAB+AQAAAAARAAAAEQAAABEAfwEAAH8BAADU/v//AAAAANT+//+AAQAAgAEAAMMAAAAAAAAAwwAAAIEBAACBAQAAAAAAANIAAAAAAAAAggEAAIUBAAAAABEAAAARAAAAEQCGAQAAhgEAAAAAAADOAAAAAAAAAIcBAACIAQAAAAARAAAAEQAAABEAiQEAAIoBAAAAAAAAzQAAAAAAAACLAQAAjAEAAAAAEQAAABEAAAARAI4BAACOAQAAAAAAAE8AAAAAAAAAjwEAAI8BAAAAAAAAygAAAAAAAACQAQAAkAEAAAAAAADLAAAAAAAAAJEBAACSAQAAAAARAAAAEQAAABEAkwEAAJMBAAAAAAAAzQAAAAAAAACUAQAAlAEAAAAAAADPAAAAAAAAAJUBAACVAQAAYQAAAAAAAABhAAAAlgEAAJYBAAAAAAAA0wAAAAAAAACXAQAAlwEAAAAAAADRAAAAAAAAAJgBAACZAQAAAAARAAAAEQAAABEAmgEAAJoBAACjAAAAAAAAAKMAAACcAQAAnAEAAAAAAADTAAAAAAAAAJ0BAACdAQAAAAAAANUAAAAAAAAAngEAAJ4BAACCAAAAAAAAAIIAAACfAQAAnwEAAAAAAADWAAAAAAAAAKABAAClAQAAAAARAAAAEQAAABEApgEAAKYBAAAAAAAA2gAAAAAAAACnAQAAqAEAAAAAEQAAABEAAAARAKkBAACpAQAAAAAAANoAAAAAAAAArAEAAK0BAAAAABEAAAARAAAAEQCuAQAArgEAAAAAAADaAAAAAAAAAK8BAACwAQAAAAARAAAAEQAAABEAsQEAALIBAAAAAAAA2QAAAAAAAACzAQAAtgEAAAAAEQAAABEAAAARALcBAAC3AQAAAAAAANsAAAAAAAAAuAEAALkBAAAAABEAAAARAAAAEQC8AQAAvQEAAAAAEQAAABEAAAARAL8BAAC/AQAAOAAAAAAAAAA4AAAAxAEAAMQBAAAAAAAAAgAAAAEAAADFAQAAxQEAAP////8BAAAAAAAAAMYBAADGAQAA/v///wAAAAD/////xwEAAMcBAAAAAAAAAgAAAAEAAADIAQAAyAEAAP////8BAAAAAAAAAMkBAADJAQAA/v///wAAAAD/////ygEAAMoBAAAAAAAAAgAAAAEAAADLAQAAywEAAP////8BAAAAAAAAAMwBAADMAQAA/v///wAAAAD/////zQEAANwBAAAAABEAAAARAAAAEQDdAQAA3QEAALH///8AAAAAsf///94BAADvAQAAAAARAAAAEQAAABEA8QEAAPEBAAAAAAAAAgAAAAEAAADyAQAA8gEAAP////8BAAAAAAAAAPMBAADzAQAA/v///wAAAAD/////9AEAAPUBAAAAABEAAAARAAAAEQD2AQAA9gEAAAAAAACf////AAAAAPcBAAD3AQAAAAAAAMj///8AAAAA+AEAAB8CAAAAABEAAAARAAAAEQAgAgAAIAIAAAAAAAB+////AAAAACICAAAzAgAAAAARAAAAEQAAABEAOgIAADoCAAAAAAAAKyoAAAAAAAA7AgAAPAIAAAAAEQAAABEAAAARAD0CAAA9AgAAAAAAAF3///8AAAAAPgIAAD4CAAAAAAAAKCoAAAAAAAA/AgAAQAIAAD8qAAAAAAAAPyoAAEECAABCAgAAAAARAAAAEQAAABEAQwIAAEMCAAAAAAAAPf///wAAAABEAgAARAIAAAAAAABFAAAAAAAAAEUCAABFAgAAAAAAAEcAAAAAAAAARgIAAE8CAAAAABEAAAARAAAAEQBQAgAAUAIAAB8qAAAAAAAAHyoAAFECAABRAgAAHCoAAAAAAAAcKgAAUgIAAFICAAAeKgAAAAAAAB4qAABTAgAAUwIAAC7///8AAAAALv///1QCAABUAgAAMv///wAAAAAy////VgIAAFcCAAAz////AAAAADP///9ZAgAAWQIAADb///8AAAAANv///1sCAABbAgAANf///wAAAAA1////XAIAAFwCAABPpQAAAAAAAE+lAABgAgAAYAIAADP///8AAAAAM////2ECAABhAgAAS6UAAAAAAABLpQAAYwIAAGMCAAAx////AAAAADH///9lAgAAZQIAACilAAAAAAAAKKUAAGYCAABmAgAARKUAAAAAAABEpQAAaAIAAGgCAAAv////AAAAAC////9pAgAAaQIAAC3///8AAAAALf///2oCAABqAgAARKUAAAAAAABEpQAAawIAAGsCAAD3KQAAAAAAAPcpAABsAgAAbAIAAEGlAAAAAAAAQaUAAG8CAABvAgAALf///wAAAAAt////cQIAAHECAAD9KQAAAAAAAP0pAAByAgAAcgIAACv///8AAAAAK////3UCAAB1AgAAKv///wAAAAAq////fQIAAH0CAADnKQAAAAAAAOcpAACAAgAAgAIAACb///8AAAAAJv///4ICAACCAgAAQ6UAAAAAAABDpQAAgwIAAIMCAAAm////AAAAACb///+HAgAAhwIAACqlAAAAAAAAKqUAAIgCAACIAgAAJv///wAAAAAm////iQIAAIkCAAC7////AAAAALv///+KAgAAiwIAACf///8AAAAAJ////4wCAACMAgAAuf///wAAAAC5////kgIAAJICAAAl////AAAAACX///+dAgAAnQIAABWlAAAAAAAAFaUAAJ4CAACeAgAAEqUAAAAAAAASpQAARQMAAEUDAABUAAAAAAAAAFQAAABwAwAAcwMAAAAAEQAAABEAAAARAHYDAAB3AwAAAAARAAAAEQAAABEAewMAAH0DAACCAAAAAAAAAIIAAAB/AwAAfwMAAAAAAAB0AAAAAAAAAIYDAACGAwAAAAAAACYAAAAAAAAAiAMAAIoDAAAAAAAAJQAAAAAAAACMAwAAjAMAAAAAAABAAAAAAAAAAI4DAACPAwAAAAAAAD8AAAAAAAAAkQMAAKEDAAAAAAAAIAAAAAAAAACjAwAAqwMAAAAAAAAgAAAAAAAAAKwDAACsAwAA2v///wAAAADa////rQMAAK8DAADb////AAAAANv///+xAwAAwQMAAOD///8AAAAA4P///8IDAADCAwAA4f///wAAAADh////wwMAAMsDAADg////AAAAAOD////MAwAAzAMAAMD///8AAAAAwP///80DAADOAwAAwf///wAAAADB////zwMAAM8DAAAAAAAACAAAAAAAAADQAwAA0AMAAML///8AAAAAwv///9EDAADRAwAAx////wAAAADH////1QMAANUDAADR////AAAAANH////WAwAA1gMAAMr///8AAAAAyv///9cDAADXAwAA+P///wAAAAD4////2AMAAO8DAAAAABEAAAARAAAAEQDwAwAA8AMAAKr///8AAAAAqv////EDAADxAwAAsP///wAAAACw////8gMAAPIDAAAHAAAAAAAAAAcAAADzAwAA8wMAAIz///8AAAAAjP////QDAAD0AwAAAAAAAMT///8AAAAA9QMAAPUDAACg////AAAAAKD////3AwAA+AMAAAAAEQAAABEAAAARAPkDAAD5AwAAAAAAAPn///8AAAAA+gMAAPsDAAAAABEAAAARAAAAEQD9AwAA/wMAAAAAAAB+////AAAAAAAEAAAPBAAAAAAAAFAAAAAAAAAAEAQAAC8EAAAAAAAAIAAAAAAAAAAwBAAATwQAAOD///8AAAAA4P///1AEAABfBAAAsP///wAAAACw////YAQAAIEEAAAAABEAAAARAAAAEQCKBAAAvwQAAAAAEQAAABEAAAARAMAEAADABAAAAAAAAA8AAAAAAAAAwQQAAM4EAAAAABEAAAARAAAAEQDPBAAAzwQAAPH///8AAAAA8f///9AEAAAvBQAAAAARAAAAEQAAABEAMQUAAFYFAAAAAAAAMAAAAAAAAABhBQAAhgUAAND///8AAAAA0P///6AQAADFEAAAAAAAAGAcAAAAAAAAxxAAAMcQAAAAAAAAYBwAAAAAAADNEAAAzRAAAAAAAABgHAAAAAAAANAQAAD6EAAAwAsAAAAAAAAAAAAA/RAAAP8QAADACwAAAAAAAAAAAACgEwAA7xMAAAAAAADQlwAAAAAAAPATAAD1EwAAAAAAAAgAAAAAAAAA+BMAAP0TAAD4////AAAAAPj///+AHAAAgBwAAJLn//8AAAAAkuf//4EcAACBHAAAk+f//wAAAACT5///ghwAAIIcAACc5///AAAAAJzn//+DHAAAhBwAAJ7n//8AAAAAnuf//4UcAACFHAAAnef//wAAAACd5///hhwAAIYcAACk5///AAAAAKTn//+HHAAAhxwAANvn//8AAAAA2+f//4gcAACIHAAAwokAAAAAAADCiQAAkBwAALocAAAAAAAAQPT//wAAAAC9HAAAvxwAAAAAAABA9P//AAAAAHkdAAB5HQAABIoAAAAAAAAEigAAfR0AAH0dAADmDgAAAAAAAOYOAACOHQAAjh0AADiKAAAAAAAAOIoAAAAeAACVHgAAAAARAAAAEQAAABEAmx4AAJseAADF////AAAAAMX///+eHgAAnh4AAAAAAABB4v//AAAAAKAeAAD/HgAAAAARAAAAEQAAABEAAB8AAAcfAAAIAAAAAAAAAAgAAAAIHwAADx8AAAAAAAD4////AAAAABAfAAAVHwAACAAAAAAAAAAIAAAAGB8AAB0fAAAAAAAA+P///wAAAAAgHwAAJx8AAAgAAAAAAAAACAAAACgfAAAvHwAAAAAAAPj///8AAAAAMB8AADcfAAAIAAAAAAAAAAgAAAA4HwAAPx8AAAAAAAD4////AAAAAEAfAABFHwAACAAAAAAAAAAIAAAASB8AAE0fAAAAAAAA+P///wAAAABRHwAAUR8AAAgAAAAAAAAACAAAAFMfAABTHwAACAAAAAAAAAAIAAAAVR8AAFUfAAAIAAAAAAAAAAgAAABXHwAAVx8AAAgAAAAAAAAACAAAAFkfAABZHwAAAAAAAPj///8AAAAAWx8AAFsfAAAAAAAA+P///wAAAABdHwAAXR8AAAAAAAD4////AAAAAF8fAABfHwAAAAAAAPj///8AAAAAYB8AAGcfAAAIAAAAAAAAAAgAAABoHwAAbx8AAAAAAAD4////AAAAAHAfAABxHwAASgAAAAAAAABKAAAAch8AAHUfAABWAAAAAAAAAFYAAAB2HwAAdx8AAGQAAAAAAAAAZAAAAHgfAAB5HwAAgAAAAAAAAACAAAAAeh8AAHsfAABwAAAAAAAAAHAAAAB8HwAAfR8AAH4AAAAAAAAAfgAAAIAfAACHHwAACAAAAAAAAAAIAAAAiB8AAI8fAAAAAAAA+P///wAAAACQHwAAlx8AAAgAAAAAAAAACAAAAJgfAACfHwAAAAAAAPj///8AAAAAoB8AAKcfAAAIAAAAAAAAAAgAAACoHwAArx8AAAAAAAD4////AAAAALAfAACxHwAACAAAAAAAAAAIAAAAsx8AALMfAAAJAAAAAAAAAAkAAAC4HwAAuR8AAAAAAAD4////AAAAALofAAC7HwAAAAAAALb///8AAAAAvB8AALwfAAAAAAAA9////wAAAAC+HwAAvh8AANvj//8AAAAA2+P//8MfAADDHwAACQAAAAAAAAAJAAAAyB8AAMsfAAAAAAAAqv///wAAAADMHwAAzB8AAAAAAAD3////AAAAANAfAADRHwAACAAAAAAAAAAIAAAA2B8AANkfAAAAAAAA+P///wAAAADaHwAA2x8AAAAAAACc////AAAAAOAfAADhHwAACAAAAAAAAAAIAAAA5R8AAOUfAAAHAAAAAAAAAAcAAADoHwAA6R8AAAAAAAD4////AAAAAOofAADrHwAAAAAAAJD///8AAAAA7B8AAOwfAAAAAAAA+f///wAAAADzHwAA8x8AAAkAAAAAAAAACQAAAPgfAAD5HwAAAAAAAID///8AAAAA+h8AAPsfAAAAAAAAgv///wAAAAD8HwAA/B8AAAAAAAD3////AAAAACYhAAAmIQAAAAAAAKPi//8AAAAAKiEAACohAAAAAAAAQd///wAAAAArIQAAKyEAAAAAAAC63///AAAAADIhAAAyIQAAAAAAABwAAAAAAAAATiEAAE4hAADk////AAAAAOT///9gIQAAbyEAAAAAAAAQAAAAAAAAAHAhAAB/IQAA8P///wAAAADw////gyEAAIQhAAAAABEAAAARAAAAEQC2JAAAzyQAAAAAAAAaAAAAAAAAANAkAADpJAAA5v///wAAAADm////ACwAAC4sAAAAAAAAMAAAAAAAAAAwLAAAXiwAAND///8AAAAA0P///2AsAABhLAAAAAARAAAAEQAAABEAYiwAAGIsAAAAAAAACdb//wAAAABjLAAAYywAAAAAAAAa8f//AAAAAGQsAABkLAAAAAAAABnW//8AAAAAZSwAAGUsAADV1f//AAAAANXV//9mLAAAZiwAANjV//8AAAAA2NX//2csAABsLAAAAAARAAAAEQAAABEAbSwAAG0sAAAAAAAA5NX//wAAAABuLAAAbiwAAAAAAAAD1v//AAAAAG8sAABvLAAAAAAAAOHV//8AAAAAcCwAAHAsAAAAAAAA4tX//wAAAAByLAAAcywAAAAAEQAAABEAAAARAHUsAAB2LAAAAAARAAAAEQAAABEAfiwAAH8sAAAAAAAAwdX//wAAAACALAAA4ywAAAAAEQAAABEAAAARAOssAADuLAAAAAARAAAAEQAAABEA8iwAAPMsAAAAABEAAAARAAAAEQAALQAAJS0AAKDj//8AAAAAoOP//yctAAAnLQAAoOP//wAAAACg4///LS0AAC0tAACg4///AAAAAKDj//9ApgAAbaYAAAAAEQAAABEAAAARAICmAACbpgAAAAARAAAAEQAAABEAIqcAAC+nAAAAABEAAAARAAAAEQAypwAAb6cAAAAAEQAAABEAAAARAHmnAAB8pwAAAAARAAAAEQAAABEAfacAAH2nAAAAAAAA/HX//wAAAAB+pwAAh6cAAAAAEQAAABEAAAARAIunAACMpwAAAAARAAAAEQAAABEAjacAAI2nAAAAAAAA2Fr//wAAAACQpwAAk6cAAAAAEQAAABEAAAARAJSnAACUpwAAMAAAAAAAAAAwAAAAlqcAAKmnAAAAABEAAAARAAAAEQCqpwAAqqcAAAAAAAC8Wv//AAAAAKunAACrpwAAAAAAALFa//8AAAAArKcAAKynAAAAAAAAtVr//wAAAACtpwAAracAAAAAAAC/Wv//AAAAAK6nAACupwAAAAAAALxa//8AAAAAsKcAALCnAAAAAAAA7lr//wAAAACxpwAAsacAAAAAAADWWv//AAAAALKnAACypwAAAAAAAOta//8AAAAAs6cAALOnAAAAAAAAoAMAAAAAAAC0pwAAv6cAAAAAEQAAABEAAAARAMKnAADDpwAAAAARAAAAEQAAABEAxKcAAMSnAAAAAAAA0P///wAAAADFpwAAxacAAAAAAAC9Wv//AAAAAManAADGpwAAAAAAAMh1//8AAAAAU6sAAFOrAABg/P//AAAAAGD8//9wqwAAv6sAADBo//8AAAAAMGj//yH/AAA6/wAAAAAAACAAAAAAAAAAQf8AAFr/AADg////AAAAAOD///8ABAEAJwQBAAAAAAAoAAAAAAAAACgEAQBPBAEA2P///wAAAADY////sAQBANMEAQAAAAAAKAAAAAAAAADYBAEA+wQBANj///8AAAAA2P///4AMAQCyDAEAAAAAAEAAAAAAAAAAwAwBAPIMAQDA////AAAAAMD///+gGAEAvxgBAAAAAAAgAAAAAAAAAMAYAQDfGAEA4P///wAAAADg////QG4BAF9uAQAAAAAAIAAAAAAAAABgbgEAf24BAOD///8AAAAA4P///wDpAQAh6QEAAAAAACIAAAAAAAAAIukBAEPpAQDe////AAAAAN7///8EAAAACAAAAAwAAAAMAAAABAAAAAAAAAAAAAAAPwAAACoAAABbAAAAewAAAAAAAAAAAAAAAAAAAAAAAAA/AAAAKgAAAFsAAAB7AAAAfQAAACwAAAAAAAAAXQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADwPwAAAAAAACRAAAAAAAAAWUAAAAAAAECPQAAAAAAAiMNAAAAAAABq+EAAAAAAgIQuQQAAAADQEmNBAAAAAITXl0EAAAAAZc3NQZAAAAAAAAAAAQAAAAEAAAABAAAAjNIBAJAAAAAAAAAAAQAAAAEAAAABAAAAWNMBAJEAAAAAAAAAAQAAAAEAAAABAAAAjNIBAAAAAAAAAAAAAAAAAAIAAAADAAAABQAAAAcAAAALAAAADQAAABEAAAATAAAAFwAAAB0AAAAfAAAAJQAAACkAAAArAAAALwAAADUAAAA7AAAAPQAAAEMAAABHAAAASQAAAE8AAABTAAAAWQAAAGEAAABlAAAAZwAAAGsAAABtAAAAcQAAAH8AAACDAAAAiQAAAIsAAACVAAAAlwAAAJ0AAACjAAAApwAAAK0AAACzAAAAtQAAAL8AAADBAAAAxQAAAMcAAADTAAAAAQAAAAsAAAANAAAAEQAAABMAAAAXAAAAHQAAAB8AAAAlAAAAKQAAACsAAAAvAAAANQAAADsAAAA9AAAAQwAAAEcAAABJAAAATwAAAFMAAABZAAAAYQAAAGUAAABnAAAAawAAAG0AAABxAAAAeQAAAH8AAACDAAAAiQAAAIsAAACPAAAAlQAAAJcAAACdAAAAowAAAKcAAACpAAAArQAAALMAAAC1AAAAuwAAAL8AAADBAAAAxQAAAMcAAADRAAAAAAAAAAAAAAATAAAAFAAAABUAAAAWAAAAFwAAABgAAAAAAAAAAAAAABkAAAAaAAAAGwAAABwAAAAdAAAAHgAAAAAAAAAAAAAAAAAAAAAAAAAiAAAAAAAAACMAAAAAAAAAJAAAAAAAAAAlAAAAAAAAACYAAAAAAAAAJwAAAAAAAAAoAAAAAAAAACkAAAAAAAAAAAAAAAAAAAAqAAAAKwAAACwAAAAtAAAALgAAAC8AAAAAAAAAAAAAACoAAAAwAAAAMQAAADIAAAAuAAAAHgAAADAAOQAJAAoADAANACAAIAAwADkAQQBaAF8AXwBhAHoATA4BAAEAAABwNQEAAQAAAAAAAAAAAAAA5REBAP////9wNQEAAQAAAAAAAAAAAAAAgwIBAAEAAAB0NQEAAwAAAAAAAAAAAAAAThEBAP////90NQEAAwAAAAAAAAAAAAAAjAABAAEAAACANQEABAAAAAAAAAAAAAAASxEBAP////+ANQEABAAAAAAAAAAAAAAABgAAADAAOQBBAFoAYQB6AEEAWgBhAHoAAAB/AAkACQAgACAAAAAfAH8AfwAwADkAIQB+AGEAegAgAH4AAAAAACEALwA6AEAAWwBgAHsAfgAJAA0AIAAgAEEAWgAAAAAAMAA5AEEAWgBfAF8AYQB6ADAAOQBBAEYAYQBmAAAAAAB6EAEAAQAAACQ2AQADAAAAAAAAAAAAAABvEAEA/////yQ2AQADAAAAAAAAAAAAAAALEQEAAQAAADA2AQACAAAAAAAAAAAAAAAAEQEA/////zA2AQACAAAAAAAAAAAAAAC5EAEAAQAAADg2AQABAAAAAAAAAAAAAACuEAEA/////zg2AQABAAAAAAAAAAAAAACkEAEAAQAAADw2AQACAAAAAAAAAAAAAACZEAEA/////zw2AQACAAAAAAAAAAAAAACPEAEAAQAAAEQ2AQACAAAAAAAAAAAAAACEEAEA/////0Q2AQACAAAAAAAAAAAAAAAmEAEAAQAAAEw2AQABAAAAAAAAAAAAAAAbEAEA/////0w2AQABAAAAAAAAAAAAAADOEAEAAQAAAFA2AQABAAAAAAAAAAAAAADDEAEA/////1A2AQABAAAAAAAAAAAAAABQEAEAAQAAAFQ2AQABAAAAAAAAAAAAAABFEAEA/////1Q2AQABAAAAAAAAAAAAAAD6DwEAAQAAAFg2AQABAAAAAAAAAAAAAADvDwEA/////1g2AQABAAAAAAAAAAAAAAA7EAEAAQAAAGA2AQAEAAAAAAAAAAAAAAAwEAEA/////2A2AQAEAAAAAAAAAAAAAADjEAEAAQAAAHA2AQACAAAAAAAAAAAAAADYEAEA/////3A2AQACAAAAAAAAAAAAAABlEAEAAQAAAHg2AQABAAAAAAAAAAAAAABaEAEA/////3g2AQABAAAAAAAAAAAAAAD3EAEAAQAAAIA2AQAEAAAAAAAAAAAAAADtEAEA/////4A2AQAEAAAAAAAAAAAAAAAQEAEAAQAAAJA2AQADAAAAAAAAAAAAAAAEEAEA/////5A2AQADAAAAAAAAAAAAAAAcAAAAAAAAAAAAAAAAAAAAswMBALwDAQDZDAEAKwIBADMMAQAVEQEAsRcBALsXAQAfEQEAYQMBAFELAQCFAwEAnQMBABsSAQDABQEAAAAAAAAAAAAqAAAAOQAAADoAAAAyAAAALgAAADsAAAAAAAAAAAAAADwAAAA9AAAAPgAAAD8AAABAAAAAQQAAAAAAAAAAAAAAPAAAAEIAAABDAAAARAAAAEUAAABGAAAAAAAAAAAAAAA8AAAARwAAAD4AAABIAAAASQAAAB4AAAAAAAAAQQAAAFoAAAAgAAAAYQAAAGoAAADg////awAAAGsAAAC/IAAAbAAAAHIAAADg////cwAAAHMAAAAMAQAAdAAAAHoAAADg////tQAAALUAAADnAgAAwAAAANYAAAAgAAAA2AAAAN4AAAAgAAAA3wAAAN8AAAC/HQAA4AAAAOQAAADg////5QAAAOUAAABGIAAA5gAAAPYAAADg////+AAAAP4AAADg/////wAAAP8AAAB5AAAAAAEAAC8BAAABAAAAMgEAADcBAAABAAAAOQEAAEgBAAD/////SgEAAHcBAAABAAAAeAEAAHgBAACH////eQEAAH4BAAD/////fwEAAH8BAADU/v//gAEAAIABAADDAAAAgQEAAIEBAADSAAAAggEAAIUBAAABAAAAhgEAAIYBAADOAAAAhwEAAIgBAAD/////iQEAAIoBAADNAAAAiwEAAIwBAAD/////jgEAAI4BAABPAAAAjwEAAI8BAADKAAAAkAEAAJABAADLAAAAkQEAAJIBAAD/////kwEAAJMBAADNAAAAlAEAAJQBAADPAAAAlQEAAJUBAABhAAAAlgEAAJYBAADTAAAAlwEAAJcBAADRAAAAmAEAAJkBAAABAAAAmgEAAJoBAACjAAAAnAEAAJwBAADTAAAAnQEAAJ0BAADVAAAAngEAAJ4BAACCAAAAnwEAAJ8BAADWAAAAoAEAAKUBAAABAAAApgEAAKYBAADaAAAApwEAAKgBAAD/////qQEAAKkBAADaAAAArAEAAK0BAAABAAAArgEAAK4BAADaAAAArwEAALABAAD/////sQEAALIBAADZAAAAswEAALYBAAD/////twEAALcBAADbAAAAuAEAALkBAAABAAAAvAEAAL0BAAABAAAAvwEAAL8BAAA4AAAAxAEAAMQBAAABAAAAxQEAAMUBAAD/////xgEAAMYBAAD+////xwEAAMcBAAD/////yAEAAMgBAAABAAAAyQEAAMkBAAD+////ygEAAMoBAAABAAAAywEAAMsBAAD/////zAEAAMwBAAD+////zQEAANwBAAD/////3QEAAN0BAACx////3gEAAO8BAAABAAAA8QEAAPEBAAD/////8gEAAPIBAAABAAAA8wEAAPMBAAD+////9AEAAPUBAAABAAAA9gEAAPYBAACf////9wEAAPcBAADI////+AEAAB8CAAABAAAAIAIAACACAAB+////IgIAADMCAAABAAAAOgIAADoCAAArKgAAOwIAADwCAAD/////PQIAAD0CAABd////PgIAAD4CAAAoKgAAPwIAAEACAAA/KgAAQQIAAEICAAD/////QwIAAEMCAAA9////RAIAAEQCAABFAAAARQIAAEUCAABHAAAARgIAAE8CAAABAAAAUAIAAFACAAAfKgAAUQIAAFECAAAcKgAAUgIAAFICAAAeKgAAUwIAAFMCAAAu////VAIAAFQCAAAy////VgIAAFcCAAAz////WQIAAFkCAAA2////WwIAAFsCAAA1////XAIAAFwCAABPpQAAYAIAAGACAAAz////YQIAAGECAABLpQAAYwIAAGMCAAAx////ZQIAAGUCAAAopQAAZgIAAGYCAABEpQAAaAIAAGgCAAAv////aQIAAGkCAAAt////agIAAGoCAABEpQAAawIAAGsCAAD3KQAAbAIAAGwCAABBpQAAbwIAAG8CAAAt////cQIAAHECAAD9KQAAcgIAAHICAAAr////dQIAAHUCAAAq////fQIAAH0CAADnKQAAgAIAAIACAAAm////ggIAAIICAABDpQAAgwIAAIMCAAAm////hwIAAIcCAAAqpQAAiAIAAIgCAAAm////iQIAAIkCAAC7////igIAAIsCAAAn////jAIAAIwCAAC5////kgIAAJICAAAl////nQIAAJ0CAAAVpQAAngIAAJ4CAAASpQAARQMAAEUDAABUAAAAcAMAAHMDAAABAAAAdgMAAHcDAAABAAAAewMAAH0DAACCAAAAfwMAAH8DAAB0AAAAhgMAAIYDAAAmAAAAiAMAAIoDAAAlAAAAjAMAAIwDAABAAAAAjgMAAI8DAAA/AAAAkQMAAKEDAAAgAAAAowMAAKMDAAAfAAAApAMAAKsDAAAgAAAArAMAAKwDAADa////rQMAAK8DAADb////sQMAALEDAADg////sgMAALIDAAAeAAAAswMAALQDAADg////tQMAALUDAABAAAAAtgMAALcDAADg////uAMAALgDAAAZAAAAuQMAALkDAAAFHAAAugMAALoDAAA2AAAAuwMAALsDAADg////vAMAALwDAAD5/P//vQMAAL8DAADg////wAMAAMADAAAWAAAAwQMAAMEDAAAwAAAAwgMAAMIDAAABAAAAwwMAAMUDAADg////xgMAAMYDAAAPAAAAxwMAAMgDAADg////yQMAAMkDAABdHQAAygMAAMsDAADg////zAMAAMwDAADA////zQMAAM4DAADB////zwMAAM8DAAAIAAAA0AMAANADAADC////0QMAANEDAAAjAAAA1QMAANUDAADR////1gMAANYDAADK////1wMAANcDAAD4////2AMAAO8DAAABAAAA8AMAAPADAACq////8QMAAPEDAACw////8gMAAPIDAAAHAAAA8wMAAPMDAACM////9AMAAPQDAACk////9QMAAPUDAACg////9wMAAPgDAAD/////+QMAAPkDAAD5////+gMAAPsDAAABAAAA/QMAAP8DAAB+////AAQAAA8EAABQAAAAEAQAAC8EAAAgAAAAMAQAADEEAADg////MgQAADIEAABOGAAAMwQAADMEAADg////NAQAADQEAABNGAAANQQAAD0EAADg////PgQAAD4EAABEGAAAPwQAAEAEAADg////QQQAAEIEAABCGAAAQwQAAEkEAADg////SgQAAEoEAAA8GAAASwQAAE8EAADg////UAQAAF8EAACw////YAQAAGIEAAABAAAAYwQAAGMEAAAkGAAAZAQAAIEEAAABAAAAigQAAL8EAAABAAAAwAQAAMAEAAAPAAAAwQQAAM4EAAD/////zwQAAM8EAADx////0AQAAC8FAAABAAAAMQUAAFYFAAAwAAAAYQUAAIYFAADQ////oBAAAMUQAABgHAAAxxAAAMcQAABgHAAAzRAAAM0QAABgHAAA0BAAAPoQAADACwAA/RAAAP8QAADACwAAoBMAAO8TAADQlwAA8BMAAPUTAAAIAAAA+BMAAP0TAAD4////gBwAAIAcAACS5///gRwAAIEcAACT5///ghwAAIIcAACc5///gxwAAIMcAACe5///hBwAAIQcAAABAAAAhRwAAIUcAACd5///hhwAAIYcAACk5///hxwAAIccAADb5///iBwAAIgcAADCiQAAkBwAALocAABA9P//vRwAAL8cAABA9P//eR0AAHkdAAAEigAAfR0AAH0dAADmDgAAjh0AAI4dAAA4igAAAB4AAGAeAAABAAAAYR4AAGEeAAA6AAAAYh4AAJUeAAABAAAAmx4AAJseAADF////nh4AAJ4eAABB4v//oB4AAP8eAAABAAAAAB8AAAcfAAAIAAAACB8AAA8fAAD4////EB8AABUfAAAIAAAAGB8AAB0fAAD4////IB8AACcfAAAIAAAAKB8AAC8fAAD4////MB8AADcfAAAIAAAAOB8AAD8fAAD4////QB8AAEUfAAAIAAAASB8AAE0fAAD4////UR8AAFEfAAAIAAAAUx8AAFMfAAAIAAAAVR8AAFUfAAAIAAAAVx8AAFcfAAAIAAAAWR8AAFkfAAD4////Wx8AAFsfAAD4////XR8AAF0fAAD4////Xx8AAF8fAAD4////YB8AAGcfAAAIAAAAaB8AAG8fAAD4////cB8AAHEfAABKAAAAch8AAHUfAABWAAAAdh8AAHcfAABkAAAAeB8AAHkfAACAAAAAeh8AAHsfAABwAAAAfB8AAH0fAAB+AAAAgB8AAIcfAAAIAAAAiB8AAI8fAAD4////kB8AAJcfAAAIAAAAmB8AAJ8fAAD4////oB8AAKcfAAAIAAAAqB8AAK8fAAD4////sB8AALEfAAAIAAAAsx8AALMfAAAJAAAAuB8AALkfAAD4////uh8AALsfAAC2////vB8AALwfAAD3////vh8AAL4fAACH4///wx8AAMMfAAAJAAAAyB8AAMsfAACq////zB8AAMwfAAD3////0B8AANEfAAAIAAAA2B8AANkfAAD4////2h8AANsfAACc////4B8AAOEfAAAIAAAA5R8AAOUfAAAHAAAA6B8AAOkfAAD4////6h8AAOsfAACQ////7B8AAOwfAAD5////8x8AAPMfAAAJAAAA+B8AAPkfAACA////+h8AAPsfAACC/////B8AAPwfAAD3////JiEAACYhAACD4v//KiEAACohAAAh3///KyEAACshAACa3///MiEAADIhAAAcAAAATiEAAE4hAADk////YCEAAG8hAAAQAAAAcCEAAH8hAADw////gyEAAIQhAAD/////tiQAAM8kAAAaAAAA0CQAAOkkAADm////ACwAAC4sAAAwAAAAMCwAAF4sAADQ////YCwAAGEsAAABAAAAYiwAAGIsAAAJ1v//YywAAGMsAAAa8f//ZCwAAGQsAAAZ1v//ZSwAAGUsAADV1f//ZiwAAGYsAADY1f//ZywAAGwsAAD/////bSwAAG0sAADk1f//biwAAG4sAAAD1v//bywAAG8sAADh1f//cCwAAHAsAADi1f//ciwAAHMsAAABAAAAdSwAAHYsAAD/////fiwAAH8sAADB1f//gCwAAOMsAAABAAAA6ywAAO4sAAD/////8iwAAPMsAAABAAAAAC0AACUtAACg4///Jy0AACctAACg4///LS0AAC0tAACg4///QKYAAEqmAAABAAAAS6YAAEumAAA9dv//TKYAAG2mAAABAAAAgKYAAJumAAABAAAAIqcAAC+nAAABAAAAMqcAAG+nAAABAAAAeacAAHynAAD/////facAAH2nAAD8df//fqcAAIenAAABAAAAi6cAAIynAAD/////jacAAI2nAADYWv//kKcAAJOnAAABAAAAlKcAAJSnAAAwAAAAlqcAAKmnAAABAAAAqqcAAKqnAAC8Wv//q6cAAKunAACxWv//rKcAAKynAAC1Wv//racAAK2nAAC/Wv//rqcAAK6nAAC8Wv//sKcAALCnAADuWv//sacAALGnAADWWv//sqcAALKnAADrWv//s6cAALOnAACgAwAAtKcAAL+nAAABAAAAwqcAAMOnAAABAAAAxKcAAMSnAADQ////xacAAMWnAAC9Wv//xqcAAManAADIdf//x6cAAMqnAAD/////9acAAPanAAD/////U6sAAFOrAABg/P//cKsAAL+rAAAwaP//If8AADr/AAAgAAAAQf8AAFr/AADg////AAQBACcEAQAoAAAAKAQBAE8EAQDY////sAQBANMEAQAoAAAA2AQBAPsEAQDY////gAwBALIMAQBAAAAAwAwBAPIMAQDA////oBgBAL8YAQAgAAAAwBgBAN8YAQDg////QG4BAF9uAQAgAAAAYG4BAH9uAQDg////AOkBACHpAQAiAAAAIukBAEPpAQDe////ZgEAAAAAAAAA6QEAS+kBAFDpAQBZ6QEAXukBAF/pAQAAAAAAAAAAAAAXAQAaFwEAHRcBACsXAQAwFwEAPxcBAABEAQBGRgEAAAYEBgYGCwYNBhoGHAYcBh4GHgYgBj8GQQZKBlYGbwZxBtwG3gb/BlAHfwegCLQItgjHCNMI4QjjCP8IUPvB+9P7Pf1Q/Y/9kv3H/fD9/f1w/nT+dv78/gAAAAAAAAAAYA4BAH4OAQAA7gEAA+4BAAXuAQAf7gEAIe4BACLuAQAk7gEAJO4BACfuAQAn7gEAKe4BADLuAQA07gEAN+4BADnuAQA57gEAO+4BADvuAQBC7gEAQu4BAEfuAQBH7gEASe4BAEnuAQBL7gEAS+4BAE3uAQBP7gEAUe4BAFLuAQBU7gEAVO4BAFfuAQBX7gEAWe4BAFnuAQBb7gEAW+4BAF3uAQBd7gEAX+4BAF/uAQBh7gEAYu4BAGTuAQBk7gEAZ+4BAGruAQBs7gEAcu4BAHTuAQB37gEAee4BAHzuAQB+7gEAfu4BAIDuAQCJ7gEAi+4BAJvuAQCh7gEAo+4BAKXuAQCp7gEAq+4BALvuAQDw7gEA8e4BAAAAAAAAAAAAMQVWBVkFigWNBY8FE/sX+wALAQA1CwEAOQsBAD8LAQAAG0sbUBt8G6Cm96YAaAEAOGoBAAAAAAAAAAAAAAAAANBqAQDtagEA8GoBAPVqAQDAG/Mb/Bv/GwAAAAAAAAAAgAmDCYUJjAmPCZAJkwmoCaoJsAmyCbIJtgm5CbwJxAnHCcgJywnOCdcJ1wncCd0J3wnjCeYJ/gkAAAAAAAAAAAAcAQAIHAEAChwBADYcAQA4HAEARRwBAFAcAQBsHAEA6gLrAgUxLzGgMb8xAAAAAAAQAQBNEAEAUhABAG8QAQB/EAEAfxABAAAo/ygAGhsaHhofGkAXUxcAAAAAAAAAAAAAHwB/AJ8ArQCtAAAGBQYcBhwG3QbdBg8HDwfiCOIIDhgOGAsgDyAqIC4gYCBkIGYgbyAA2P/4//7//vn/+/+9EAEAvRABAM0QAQDNEAEAMDQBADg0AQCgvAEAo7wBAHPRAQB60QEAAQAOAAEADgAgAA4AfwAOAAAADwD9/w8AAAAQAP3/EAAAFH8WsBj1GKACAQDQAgEAAAAAAAAAAAAwBQEAYwUBAG8FAQBvBQEAAAAfAH8AnwAAAAAAAAAAAK0ArQAABgUGHAYcBt0G3QYPBw8H4gjiCA4YDhgLIA8gKiAuIGAgZCBmIG8g//7//vn/+/8AAAAAAAAAAAAAAAC9EAEAvRABAM0QAQDNEAEAMDQBADg0AQCgvAEAo7wBAHPRAQB60QEAAQAOAAEADgAgAA4AfwAOAAAAAAAAAAAAABEBADQRAQA2EQEARxEBAACqNqpAqk2qUKpZqlyqX6qgE/UT+BP9E3Crv6uwDwEAyw8BAADg//gAAAAAAAAAAAAADwD9/w8AAAAQAP3/EAAAAEAAWwBgAHsAqQCrALkAuwC/ANcA1wD3APcAuQLfAuUC6QLsAv8CdAN0A34DfgOFA4UDhwOHAwUGBQYMBgwGGwYbBh8GHwZABkAG3QbdBuII4ghkCWUJPw4/DtUP2A/7EPsQ6xbtFjUXNhcCGAMYBRgFGNMc0xzhHOEc6RzsHO4c8xz1HPcc+hz6HAAgCyAOIGQgZiBwIHQgfiCAII4goCC/IAAhJSEnISkhLCExITMhTSFPIV8hiSGLIZAhJiRAJEokYCT/JwApcyt2K5Urlyv/KwAuUi7wL/svADAEMAYwBjAIMCAwMDA3MDwwPzCbMJwwoDCgMPsw/DCQMZ8xwDHjMSAyXzJ/Ms8y/zL/Mlgz/zPATf9NAKchp4iniqcwqDmoLqkuqc+pz6lbq1uraqtrqz79P/0Q/hn+MP5S/lT+Zv5o/mv+//7//gH/IP87/0D/W/9l/3D/cP+e/5//4P/m/+j/7v/5//3/AAAAAAABAQACAQEABwEBADMBAQA3AQEAPwEBAJABAQCcAQEA0AEBAPwBAQDhAgEA+wIBAOJvAQDjbwEAoLwBAKO8AQAA0AEA9dABAADRAQAm0QEAKdEBAGbRAQBq0QEAetEBAIPRAQCE0QEAjNEBAKnRAQCu0QEA6NEBAODSAQDz0gEAANMBAFbTAQBg0wEAeNMBAADUAQBU1AEAVtQBAJzUAQCe1AEAn9QBAKLUAQCi1AEApdQBAKbUAQCp1AEArNQBAK7UAQC51AEAu9QBALvUAQC91AEAw9QBAMXUAQAF1QEAB9UBAArVAQAN1QEAFNUBABbVAQAc1QEAHtUBADnVAQA71QEAPtUBAEDVAQBE1QEARtUBAEbVAQBK1QEAUNUBAFLVAQCl1gEAqNYBAMvXAQDO1wEA/9cBAHHsAQC07AEAAe0BAD3tAQAA8AEAK/ABADDwAQCT8AEAoPABAK7wAQCx8AEAv/ABAMHwAQDP8AEA0fABAPXwAQAA8QEArfEBAObxAQD/8QEAAfIBAALyAQAQ8gEAO/IBAEDyAQBI8gEAUPIBAFHyAQBg8gEAZfIBAADzAQDX9gEA4PYBAOz2AQDw9gEA/PYBAAD3AQBz9wEAgPcBANj3AQDg9wEA6/cBAAD4AQAL+AEAEPgBAEf4AQBQ+AEAWfgBAGD4AQCH+AEAkPgBAK34AQCw+AEAsfgBAAD5AQB4+QEAevkBAMv5AQDN+QEAU/oBAGD6AQBt+gEAcPoBAHT6AQB4+gEAevoBAID6AQCG+gEAkPoBAKj6AQCw+gEAtvoBAMD6AQDC+gEA0PoBANb6AQAA+wEAkvsBAJT7AQDK+wEA8PsBAPn7AQABAA4AAQAOACAADgB/AA4A4gPvA4As8yz5LP8sANj/3wAgAQCZIwEAACQBAG4kAQBwJAEAdCQBAIAkAQBDJQEAAAgBAAUIAQAICAEACAgBAAoIAQA1CAEANwgBADgIAQA8CAEAPAgBAD8IAQA/CAEAAASEBIcELwWAHIgcKx0rHXgdeB3gLf8tQKafpi7+L/4ABAEATwQBAAAAAAAAAAAAAAlQCVUJYwlmCX8J4Kj/qAAZAQAGGQEACRkBAAkZAQAMGQEAExkBABUZAQAWGQEAGBkBADUZAQA3GQEAOBkBADsZAQBGGQEAUBkBAFkZAQAAGAEAOxgBAAAAAAAAAAAAALwBAGq8AQBwvAEAfLwBAIC8AQCIvAEAkLwBAJm8AQCcvAEAn7wBAAAAAAAAAAAAADABAC40AQAwNAEAODQBAAAFAQAnBQEA4A8BAPYPAQAAEkgSShJNElASVhJYElgSWhJdEmASiBKKEo0SkBKwErIStRK4Er4SwBLAEsISxRLIEtYS2BIQExITFRMYE1oTXRN8E4ATmROALZYtoC2mLagtri2wLbYtuC2+LcAtxi3ILc4t0C3WLdgt3i0BqwarCasOqxGrFqsgqyarKKsuq6AQxRDHEMcQzRDNENAQ+hD8EP8QkBy6HL0cvxwALSUtJy0nLS0tLS0ALC4sMCxeLADgAQAG4AEACOABABjgAQAb4AEAIeABACPgAQAk4AEAJuABACrgAQAwAwEASgMBAAATAQADEwEABRMBAAwTAQAPEwEAEBMBABMTAQAoEwEAKhMBADATAQAyEwEAMxMBADUTAQA5EwEAPBMBAEQTAQBHEwEASBMBAEsTAQBNEwEAUBMBAFATAQBXEwEAVxMBAF0TAQBjEwEAZhMBAGwTAQBwEwEAdBMBAAAAAAAAAAAAcANzA3UDdwN6A30DfwN/A4QDhAOGA4YDiAOKA4wDjAOOA6EDowPhA/AD/wMmHSodXR1hHWYdah2/Hb8dAB8VHxgfHR8gH0UfSB9NH1AfVx9ZH1kfWx9bH10fXR9fH30fgB+0H7YfxB/GH9Mf1h/bH90f7x/yH/Qf9h/+HyYhJiFlq2WrAAAAAAAAAAAAAAAAQAEBAI4BAQCgAQEAoAEBAADSAQBF0gEAAAAAAAAAAACBCoMKhQqNCo8KkQqTCqgKqgqwCrIKswq1CrkKvArFCscKyQrLCs0K0ArQCuAK4wrmCvEK+Qr/CgAAAAAAAAAAYB0BAGUdAQBnHQEAaB0BAGodAQCOHQEAkB0BAJEdAQCTHQEAmB0BAKAdAQCpHQEAAQoDCgUKCgoPChAKEwooCioKMAoyCjMKNQo2CjgKOQo8CjwKPgpCCkcKSApLCk0KUQpRClkKXApeCl4KZgp2CoAumS6bLvMuAC/VLwUwBTAHMAcwITApMDgwOzAANL9NAE78nwD5bfpw+tn6AAAAAPBvAQDxbwEAAAACAN2mAgAApwIANLcCAEC3AgAduAIAILgCAKHOAgCwzgIA4OsCAAD4AgAd+gIAAAADAEoTAwAAEf8RLjAvMDExjjEAMh4yYDJ+MmCpfKkArKPXsNfG18vX+9eg/77/wv/H/8r/z//S/9f/2v/c/wAAAAAAAAAAAA0BACcNAQAwDQEAOQ0BACAXNBcAAAAAAAAAAAAAAADgCAEA8ggBAPQIAQD1CAEA+wgBAP8IAQAAAAAAAAAAAJEFxwXQBeoF7wX0BR37Nvs4+zz7Pvs++0D7QftD+0T7RvtP+0EwljCdMJ8wAAAAAAGwAQAesQEAULEBAFKxAQAA8gEAAPIBAAAAAAAAAAAAQAgBAFUIAQBXCAEAXwgBAAADbwOFBIYESwZVBnAGcAZRCVQJsBrAGtAc0hzUHOAc4hzoHO0c7Rz0HPQc+Bz5HMAd+R37Hf8dDCANINAg8CAqMC0wmTCaMAD+D/4g/i3+/QEBAP0BAQDgAgEA4AIBADsTAQA7EwEAZ9EBAGnRAQB70QEAgtEBAIXRAQCL0QEAqtEBAK3RAQAAAQ4A7wEOAGALAQByCwEAeAsBAH8LAQBACwEAVQsBAFgLAQBfCwEAgKnNqdCp2aneqd+pAAAAAIAQAQDBEAEAzRABAM0QAQCADIwMjgyQDJIMqAyqDLMMtQy5DLwMxAzGDMgMygzNDNUM1gzeDN4M4AzjDOYM7wzxDPIMAAAAAAAAAAAAAAAAoTD6MP0w/zDwMf8x0DL+MgAzVzNm/2//cf+d/wAAAAAAsAEAALABAGSxAQBnsQEAAKktqS+pL6kAAAAAAAAAAAAKAQADCgEABQoBAAYKAQAMCgEAEwoBABUKAQAXCgEAGQoBADUKAQA4CgEAOgoBAD8KAQBICgEAUAoBAFgKAQDkbwEA5G8BAACLAQDVjAEAgBfdF+AX6RfwF/kX4Bn/GQASAQAREgEAExIBAD4SAQCwEgEA6hIBAPASAQD5EgEAQQBaAGEAegCqAKoAtQC1ALoAugDAANYA2AD2APgAwQLGAtEC4ALkAuwC7ALuAu4CcAN0A3YDdwN6A30DfwN/A4YDhgOIA4oDjAOMA44DoQOjA/UD9wOBBIoELwUxBVYFWQVZBWAFiAXQBeoF7wXyBSAGSgZuBm8GcQbTBtUG1QblBuYG7gbvBvoG/Ab/Bv8GEAcQBxIHLwdNB6UHsQexB8oH6gf0B/UH+gf6BwAIFQgaCBoIJAgkCCgIKAhACFgIYAhqCKAItAi2CMcIBAk5CT0JPQlQCVAJWAlhCXEJgAmFCYwJjwmQCZMJqAmqCbAJsgmyCbYJuQm9Cb0JzgnOCdwJ3QnfCeEJ8AnxCfwJ/AkFCgoKDwoQChMKKAoqCjAKMgozCjUKNgo4CjkKWQpcCl4KXgpyCnQKhQqNCo8KkQqTCqgKqgqwCrIKswq1CrkKvQq9CtAK0ArgCuEK+Qr5CgULDAsPCxALEwsoCyoLMAsyCzMLNQs5Cz0LPQtcC10LXwthC3ELcQuDC4MLhQuKC44LkAuSC5ULmQuaC5wLnAueC58LowukC6gLqguuC7kL0AvQCwUMDAwODBAMEgwoDCoMOQw9DD0MWAxaDGAMYQyADIAMhQyMDI4MkAySDKgMqgyzDLUMuQy9DL0M3gzeDOAM4QzxDPIMBA0MDQ4NEA0SDToNPQ09DU4NTg1UDVYNXw1hDXoNfw2FDZYNmg2xDbMNuw29Db0NwA3GDQEOMA4yDjMOQA5GDoEOgg6EDoQOhg6KDowOow6lDqUOpw6wDrIOsw69Dr0OwA7EDsYOxg7cDt8OAA8AD0APRw9JD2wPiA+MDwAQKhA/ED8QUBBVEFoQXRBhEGEQZRBmEG4QcBB1EIEQjhCOEKAQxRDHEMcQzRDNENAQ+hD8EEgSShJNElASVhJYElgSWhJdEmASiBKKEo0SkBKwErIStRK4Er4SwBLAEsISxRLIEtYS2BIQExITFRMYE1oTgBOPE6AT9RP4E/0TARRsFm8WfxaBFpoWoBbqFvEW+BYAFwwXDhcRFyAXMRdAF1EXYBdsF24XcBeAF7MX1xfXF9wX3BcgGHgYgBiEGIcYqBiqGKoYsBj1GAAZHhlQGW0ZcBl0GYAZqxmwGckZABoWGiAaVBqnGqcaBRszG0UbSxuDG6AbrhuvG7ob5RsAHCMcTRxPHFocfRyAHIgckBy6HL0cvxzpHOwc7hzzHPUc9hz6HPocAB2/HQAeFR8YHx0fIB9FH0gfTR9QH1cfWR9ZH1sfWx9dH10fXx99H4AftB+2H7wfvh++H8IfxB/GH8wf0B/TH9Yf2x/gH+wf8h/0H/Yf/B9xIHEgfyB/IJAgnCACIQIhByEHIQohEyEVIRUhGSEdISQhJCEmISYhKCEoISohLSEvITkhPCE/IUUhSSFOIU4hgyGEIQAsLiwwLF4sYCzkLOss7izyLPMsAC0lLSctJy0tLS0tMC1nLW8tby2ALZYtoC2mLagtri2wLbYtuC2+LcAtxi3ILc4t0C3WLdgt3i0vLi8uBTAGMDEwNTA7MDwwQTCWMJ0wnzChMPow/DD/MAUxLzExMY4xoDG/MfAx/zEANL9NAE78nwCgjKTQpP2kAKUMphCmH6YqpiumQKZupn+mnaagpuWmF6cfpyKniKeLp7+nwqfKp/WnAagDqAWoB6gKqAyoIqhAqHOogqizqPKo96j7qPuo/aj+qAqpJakwqUapYKl8qYSpsqnPqc+p4Knkqeap76n6qf6pAKooqkCqQqpEqkuqYKp2qnqqeqp+qq+qsaqxqrWqtqq5qr2qwKrAqsKqwqrbqt2q4KrqqvKq9KoBqwarCasOqxGrFqsgqyarKKsuqzCrWqtcq2mrcKviqwCso9ew18bXy9f71wD5bfpw+tn6APsG+xP7F/sd+x37H/so+yr7Nvs4+zz7Pvs++0D7QftD+0T7Rvux+9P7Pf1Q/Y/9kv3H/fD9+/1w/nT+dv78/iH/Ov9B/1r/Zv++/8L/x//K/8//0v/X/9r/3P8AAAEACwABAA0AAQAmAAEAKAABADoAAQA8AAEAPQABAD8AAQBNAAEAUAABAF0AAQCAAAEA+gABAIACAQCcAgEAoAIBANACAQAAAwEAHwMBAC0DAQBAAwEAQgMBAEkDAQBQAwEAdQMBAIADAQCdAwEAoAMBAMMDAQDIAwEAzwMBAAAEAQCdBAEAsAQBANMEAQDYBAEA+wQBAAAFAQAnBQEAMAUBAGMFAQAABgEANgcBAEAHAQBVBwEAYAcBAGcHAQAACAEABQgBAAgIAQAICAEACggBADUIAQA3CAEAOAgBADwIAQA8CAEAPwgBAFUIAQBgCAEAdggBAIAIAQCeCAEA4AgBAPIIAQD0CAEA9QgBAAAJAQAVCQEAIAkBADkJAQCACQEAtwkBAL4JAQC/CQEAAAoBAAAKAQAQCgEAEwoBABUKAQAXCgEAGQoBADUKAQBgCgEAfAoBAIAKAQCcCgEAwAoBAMcKAQDJCgEA5AoBAAALAQA1CwEAQAsBAFULAQBgCwEAcgsBAIALAQCRCwEAAAwBAEgMAQCADAEAsgwBAMAMAQDyDAEAAA0BACMNAQCADgEAqQ4BALAOAQCxDgEAAA8BABwPAQAnDwEAJw8BADAPAQBFDwEAsA8BAMQPAQDgDwEA9g8BAAMQAQA3EAEAgxABAK8QAQDQEAEA6BABAAMRAQAmEQEARBEBAEQRAQBHEQEARxEBAFARAQByEQEAdhEBAHYRAQCDEQEAshEBAMERAQDEEQEA2hEBANoRAQDcEQEA3BEBAAASAQAREgEAExIBACsSAQCAEgEAhhIBAIgSAQCIEgEAihIBAI0SAQCPEgEAnRIBAJ8SAQCoEgEAsBIBAN4SAQAFEwEADBMBAA8TAQAQEwEAExMBACgTAQAqEwEAMBMBADITAQAzEwEANRMBADkTAQA9EwEAPRMBAFATAQBQEwEAXRMBAGETAQAAFAEANBQBAEcUAQBKFAEAXxQBAGEUAQCAFAEArxQBAMQUAQDFFAEAxxQBAMcUAQCAFQEArhUBANgVAQDbFQEAABYBAC8WAQBEFgEARBYBAIAWAQCqFgEAuBYBALgWAQAAFwEAGhcBAAAYAQArGAEAoBgBAN8YAQD/GAEABhkBAAkZAQAJGQEADBkBABMZAQAVGQEAFhkBABgZAQAvGQEAPxkBAD8ZAQBBGQEAQRkBAKAZAQCnGQEAqhkBANAZAQDhGQEA4RkBAOMZAQDjGQEAABoBAAAaAQALGgEAMhoBADoaAQA6GgEAUBoBAFAaAQBcGgEAiRoBAJ0aAQCdGgEAwBoBAPgaAQAAHAEACBwBAAocAQAuHAEAQBwBAEAcAQByHAEAjxwBAAAdAQAGHQEACB0BAAkdAQALHQEAMB0BAEYdAQBGHQEAYB0BAGUdAQBnHQEAaB0BAGodAQCJHQEAmB0BAJgdAQDgHgEA8h4BALAfAQCwHwEAACABAJkjAQCAJAEAQyUBAAAwAQAuNAEAAEQBAEZGAQAAaAEAOGoBAEBqAQBeagEA0GoBAO1qAQAAawEAL2sBAEBrAQBDawEAY2sBAHdrAQB9awEAj2sBAEBuAQB/bgEAAG8BAEpvAQBQbwEAUG8BAJNvAQCfbwEA4G8BAOFvAQDjbwEA428BAABwAQD3hwEAAIgBANWMAQAAjQEACI0BAACwAQAesQEAULEBAFKxAQBksQEAZ7EBAHCxAQD7sgEAALwBAGq8AQBwvAEAfLwBAIC8AQCIvAEAkLwBAJm8AQAA1AEAVNQBAFbUAQCc1AEAntQBAJ/UAQCi1AEAotQBAKXUAQCm1AEAqdQBAKzUAQCu1AEAudQBALvUAQC71AEAvdQBAMPUAQDF1AEABdUBAAfVAQAK1QEADdUBABTVAQAW1QEAHNUBAB7VAQA51QEAO9UBAD7VAQBA1QEARNUBAEbVAQBG1QEAStUBAFDVAQBS1QEApdYBAKjWAQDA1gEAwtYBANrWAQDc1gEA+tYBAPzWAQAU1wEAFtcBADTXAQA21wEATtcBAFDXAQBu1wEAcNcBAIjXAQCK1wEAqNcBAKrXAQDC1wEAxNcBAMvXAQAA4QEALOEBADfhAQA94QEATuEBAE7hAQDA4gEA6+IBAADoAQDE6AEAAOkBAEPpAQBL6QEAS+kBAADuAQAD7gEABe4BAB/uAQAh7gEAIu4BACTuAQAk7gEAJ+4BACfuAQAp7gEAMu4BADTuAQA37gEAOe4BADnuAQA77gEAO+4BAELuAQBC7gEAR+4BAEfuAQBJ7gEASe4BAEvuAQBL7gEATe4BAE/uAQBR7gEAUu4BAFTuAQBU7gEAV+4BAFfuAQBZ7gEAWe4BAFvuAQBb7gEAXe4BAF3uAQBf7gEAX+4BAGHuAQBi7gEAZO4BAGTuAQBn7gEAau4BAGzuAQBy7gEAdO4BAHfuAQB57gEAfO4BAH7uAQB+7gEAgO4BAInuAQCL7gEAm+4BAKHuAQCj7gEApe4BAKnuAQCr7gEAu+4BAAAAAgDdpgIAAKcCADS3AgBAtwIAHbgCACC4AgChzgIAsM4CAODrAgAA+AIAHfoCAAAAAwBKEwMAgQ6CDoQOhA6GDooOjA6jDqUOpQ6nDr0OwA7EDsYOxg7IDs0O0A7ZDtwO3w4AAAAAQQBaAGEAegCqAKoAugC6AMAA1gDYAPYA+AC4AuAC5AIAHSUdLB1cHWIdZR1rHXcdeR2+HQAe/x5xIHEgfyB/IJAgnCAqISshMiEyIU4hTiFgIYghYCx/LCKnh6eLp7+nwqfKp/Wn/6cwq1qrXKtkq2araasA+wb7If86/0H/Wv8AHDccOxxJHE0cTxwAAAAAABkeGSAZKxkwGTsZQBlAGUQZTxkAAAAAAAAAAAAAAAAABgEANgcBAEAHAQBVBwEAYAcBAGcHAQAAAAAAAAAAAAAAAQALAAEADQABACYAAQAoAAEAOgABADwAAQA9AAEAPwABAE0AAQBQAAEAXQABAIAAAQD6AAEA0KT/pLAfAQCwHwEAAAAAAAAAAAAAAAAAYQB6ALUAtQDfAPYA+AD/AAEBAQEDAQMBBQEFAQcBBwEJAQkBCwELAQ0BDQEPAQ8BEQERARMBEwEVARUBFwEXARkBGQEbARsBHQEdAR8BHwEhASEBIwEjASUBJQEnAScBKQEpASsBKwEtAS0BLwEvATEBMQEzATMBNQE1ATcBOAE6AToBPAE8AT4BPgFAAUABQgFCAUQBRAFGAUYBSAFJAUsBSwFNAU0BTwFPAVEBUQFTAVMBVQFVAVcBVwFZAVkBWwFbAV0BXQFfAV8BYQFhAWMBYwFlAWUBZwFnAWkBaQFrAWsBbQFtAW8BbwFxAXEBcwFzAXUBdQF3AXcBegF6AXwBfAF+AYABgwGDAYUBhQGIAYgBjAGNAZIBkgGVAZUBmQGbAZ4BngGhAaEBowGjAaUBpQGoAagBqgGrAa0BrQGwAbABtAG0AbYBtgG5AboBvQG/AcYBxgHJAckBzAHMAc4BzgHQAdAB0gHSAdQB1AHWAdYB2AHYAdoB2gHcAd0B3wHfAeEB4QHjAeMB5QHlAecB5wHpAekB6wHrAe0B7QHvAfAB8wHzAfUB9QH5AfkB+wH7Af0B/QH/Af8BAQIBAgMCAwIFAgUCBwIHAgkCCQILAgsCDQINAg8CDwIRAhECEwITAhUCFQIXAhcCGQIZAhsCGwIdAh0CHwIfAiECIQIjAiMCJQIlAicCJwIpAikCKwIrAi0CLQIvAi8CMQIxAjMCOQI8AjwCPwJAAkICQgJHAkcCSQJJAksCSwJNAk0CTwKTApUCrwJxA3EDcwNzA3cDdwN7A30DkAOQA6wDzgPQA9ED1QPXA9kD2QPbA9sD3QPdA98D3wPhA+ED4wPjA+UD5QPnA+cD6QPpA+sD6wPtA+0D7wPzA/UD9QP4A/gD+wP8AzAEXwRhBGEEYwRjBGUEZQRnBGcEaQRpBGsEawRtBG0EbwRvBHEEcQRzBHMEdQR1BHcEdwR5BHkEewR7BH0EfQR/BH8EgQSBBIsEiwSNBI0EjwSPBJEEkQSTBJMElQSVBJcElwSZBJkEmwSbBJ0EnQSfBJ8EoQShBKMEowSlBKUEpwSnBKkEqQSrBKsErQStBK8ErwSxBLEEswSzBLUEtQS3BLcEuQS5BLsEuwS9BL0EvwS/BMIEwgTEBMQExgTGBMgEyATKBMoEzATMBM4EzwTRBNEE0wTTBNUE1QTXBNcE2QTZBNsE2wTdBN0E3wTfBOEE4QTjBOME5QTlBOcE5wTpBOkE6wTrBO0E7QTvBO8E8QTxBPME8wT1BPUE9wT3BPkE+QT7BPsE/QT9BP8E/wQBBQEFAwUDBQUFBQUHBQcFCQUJBQsFCwUNBQ0FDwUPBREFEQUTBRMFFQUVBRcFFwUZBRkFGwUbBR0FHQUfBR8FIQUhBSMFIwUlBSUFJwUnBSkFKQUrBSsFLQUtBS8FLwVgBYgF0BD6EP0Q/xD4E/0TgByIHAAdKx1rHXcdeR2aHQEeAR4DHgMeBR4FHgceBx4JHgkeCx4LHg0eDR4PHg8eER4RHhMeEx4VHhUeFx4XHhkeGR4bHhseHR4dHh8eHx4hHiEeIx4jHiUeJR4nHiceKR4pHiseKx4tHi0eLx4vHjEeMR4zHjMeNR41HjceNx45HjkeOx47Hj0ePR4/Hj8eQR5BHkMeQx5FHkUeRx5HHkkeSR5LHkseTR5NHk8eTx5RHlEeUx5THlUeVR5XHlceWR5ZHlseWx5dHl0eXx5fHmEeYR5jHmMeZR5lHmceZx5pHmkeax5rHm0ebR5vHm8ecR5xHnMecx51HnUedx53HnkeeR57HnsefR59Hn8efx6BHoEegx6DHoUehR6HHoceiR6JHoseix6NHo0ejx6PHpEekR6THpMelR6dHp8enx6hHqEeox6jHqUepR6nHqceqR6pHqseqx6tHq0erx6vHrEesR6zHrMetR61Hrcetx65Hrkeux67Hr0evR6/Hr8ewR7BHsMewx7FHsUexx7HHskeyR7LHssezR7NHs8ezx7RHtEe0x7THtUe1R7XHtce2R7ZHtse2x7dHt0e3x7fHuEe4R7jHuMe5R7lHuce5x7pHuke6x7rHu0e7R7vHu8e8R7xHvMe8x71HvUe9x73Hvke+R77Hvse/R79Hv8eBx8QHxUfIB8nHzAfNx9AH0UfUB9XH2AfZx9wH30fgB+HH5Aflx+gH6cfsB+0H7Yftx++H74fwh/EH8Yfxx/QH9Mf1h/XH+Af5x/yH/Qf9h/3HwohCiEOIQ8hEyETIS8hLyE0ITQhOSE5ITwhPSFGIUkhTiFOIYQhhCEwLF4sYSxhLGUsZixoLGgsaixqLGwsbCxxLHEscyx0LHYseyyBLIEsgyyDLIUshSyHLIcsiSyJLIssiyyNLI0sjyyPLJEskSyTLJMslSyVLJcslyyZLJksmyybLJ0snSyfLJ8soSyhLKMsoyylLKUspyynLKksqSyrLKssrSytLK8sryyxLLEssyyzLLUstSy3LLcsuSy5LLssuyy9LL0svyy/LMEswSzDLMMsxSzFLMcsxyzJLMksyyzLLM0szSzPLM8s0SzRLNMs0yzVLNUs1yzXLNks2SzbLNss3SzdLN8s3yzhLOEs4yzkLOws7CzuLO4s8yzzLAAtJS0nLSctLS0tLUGmQaZDpkOmRaZFpkemR6ZJpkmmS6ZLpk2mTaZPpk+mUaZRplOmU6ZVplWmV6ZXplmmWaZbplumXaZdpl+mX6ZhpmGmY6ZjpmWmZaZnpmemaaZppmuma6Ztpm2mgaaBpoOmg6aFpoWmh6aHpommiaaLpoumjaaNpo+mj6aRppGmk6aTppWmlaaXppemmaaZppumm6YjpyOnJaclpyenJ6cppymnK6crpy2nLacvpzGnM6czpzWnNac3pzenOac5pzunO6c9pz2nP6c/p0GnQadDp0OnRadFp0enR6dJp0mnS6dLp02nTadPp0+nUadRp1OnU6dVp1WnV6dXp1mnWadbp1unXaddp1+nX6dhp2GnY6djp2WnZadnp2enaadpp2una6dtp22nb6dvp3GneKd6p3qnfKd8p3+nf6eBp4Gng6eDp4WnhaeHp4enjKeMp46njqeRp5Gnk6eVp5enl6eZp5mnm6ebp52nnaefp5+noaehp6Ono6elp6Wnp6enp6mnqaevp6+ntae1p7ent6e5p7mnu6e7p72nvae/p7+nw6fDp8inyKfKp8qn9qf2p/qn+qcwq1qrYKtoq3Crv6sA+wb7E/sX+0H/Wv8AAAAAKAQBAE8EAQDYBAEA+wQBAMAMAQDyDAEAwBgBAN8YAQBgbgEAf24BABrUAQAz1AEATtQBAFTUAQBW1AEAZ9QBAILUAQCb1AEAttQBALnUAQC71AEAu9QBAL3UAQDD1AEAxdQBAM/UAQDq1AEAA9UBAB7VAQA31QEAUtUBAGvVAQCG1QEAn9UBALrVAQDT1QEA7tUBAAfWAQAi1gEAO9YBAFbWAQBv1gEAitYBAKXWAQDC1gEA2tYBANzWAQDh1gEA/NYBABTXAQAW1wEAG9cBADbXAQBO1wEAUNcBAFXXAQBw1wEAiNcBAIrXAQCP1wEAqtcBAMLXAQDE1wEAydcBAMvXAQDL1wEAIukBAEPpAQCwAsECxgLRAuAC5ALsAuwC7gLuAnQDdAN6A3oDWQVZBUAGQAblBuYG9Af1B/oH+gcaCBoIJAgkCCgIKAhxCXEJRg5GDsYOxg78EPwQ1xfXF0MYQxinGqcaeBx9HCwdah14HXgdmx2/HXEgcSB/IH8gkCCcIHwsfSxvLW8tLy4vLgUwBTAxMDUwOzA7MJ0wnjD8MP4wFaAVoPik/aQMpgymf6Z/ppymnaYXpx+ncKdwp4iniKf4p/mnz6nPqeap5qlwqnCq3ardqvOq9Kpcq1+raatpq3D/cP+e/5//AAAAAEBrAQBDawEAk28BAJ9vAQDgbwEA4W8BAONvAQDjbwEAN+EBAD3hAQBL6QEAS+kBAKoAqgC6ALoAuwG7AcABwwGUApQC0AXqBe8F8gUgBj8GQQZKBm4GbwZxBtMG1QbVBu4G7wb6BvwG/wb/BhAHEAcSBy8HTQelB7EHsQfKB+oHAAgVCEAIWAhgCGoIoAi0CLYIxwgECTkJPQk9CVAJUAlYCWEJcgmACYUJjAmPCZAJkwmoCaoJsAmyCbIJtgm5Cb0JvQnOCc4J3AndCd8J4QnwCfEJ/An8CQUKCgoPChAKEwooCioKMAoyCjMKNQo2CjgKOQpZClwKXgpeCnIKdAqFCo0KjwqRCpMKqAqqCrAKsgqzCrUKuQq9Cr0K0ArQCuAK4Qr5CvkKBQsMCw8LEAsTCygLKgswCzILMws1CzkLPQs9C1wLXQtfC2ELcQtxC4MLgwuFC4oLjguQC5ILlQuZC5oLnAucC54LnwujC6QLqAuqC64LuQvQC9ALBQwMDA4MEAwSDCgMKgw5DD0MPQxYDFoMYAxhDIAMgAyFDIwMjgyQDJIMqAyqDLMMtQy5DL0MvQzeDN4M4AzhDPEM8gwEDQwNDg0QDRINOg09DT0NTg1ODVQNVg1fDWENeg1/DYUNlg2aDbENsw27Db0NvQ3ADcYNAQ4wDjIOMw5ADkUOgQ6CDoQOhA6GDooOjA6jDqUOpQ6nDrAOsg6zDr0OvQ7ADsQO3A7fDgAPAA9AD0cPSQ9sD4gPjA8AECoQPxA/EFAQVRBaEF0QYRBhEGUQZhBuEHAQdRCBEI4QjhAAEUgSShJNElASVhJYElgSWhJdEmASiBKKEo0SkBKwErIStRK4Er4SwBLAEsISxRLIEtYS2BIQExITFRMYE1oTgBOPEwEUbBZvFn8WgRaaFqAW6hbxFvgWABcMFw4XERcgFzEXQBdRF2AXbBduF3AXgBezF9wX3BcgGEIYRBh4GIAYhBiHGKgYqhiqGLAY9RgAGR4ZUBltGXAZdBmAGasZsBnJGQAaFhogGlQaBRszG0UbSxuDG6AbrhuvG7ob5RsAHCMcTRxPHFocdxzpHOwc7hzzHPUc9hz6HPocNSE4ITAtZy2ALZYtoC2mLagtri2wLbYtuC2+LcAtxi3ILc4t0C3WLdgt3i0GMAYwPDA8MEEwljCfMJ8woTD6MP8w/zAFMS8xMTGOMaAxvzHwMf8xADS/TQBO/J8AoBSgFqCMpNCk96QApQumEKYfpiqmK6Zupm6moKblpo+nj6f3p/en+6cBqAOoBagHqAqoDKgiqECoc6iCqLOo8qj3qPuo+6j9qP6oCqklqTCpRqlgqXyphKmyqeCp5Knnqe+p+qn+qQCqKKpAqkKqRKpLqmCqb6pxqnaqeqp6qn6qr6qxqrGqtaq2qrmqvarAqsCqwqrCqtuq3Krgquqq8qryqgGrBqsJqw6rEasWqyCrJqsoqy6rwKviqwCso9ew18bXy9f71wD5bfpw+tn6Hfsd+x/7KPsq+zb7OPs8+z77PvtA+0H7Q/tE+0b7sfvT+z39UP2P/ZL9x/3w/fv9cP50/nb+/P5m/2//cf+d/6D/vv/C/8f/yv/P/9L/1//a/9z/AAAAAAAAAAAAAAEACwABAA0AAQAmAAEAKAABADoAAQA8AAEAPQABAD8AAQBNAAEAUAABAF0AAQCAAAEA+gABAIACAQCcAgEAoAIBANACAQAAAwEAHwMBAC0DAQBAAwEAQgMBAEkDAQBQAwEAdQMBAIADAQCdAwEAoAMBAMMDAQDIAwEAzwMBAFAEAQCdBAEAAAUBACcFAQAwBQEAYwUBAAAGAQA2BwEAQAcBAFUHAQBgBwEAZwcBAAAIAQAFCAEACAgBAAgIAQAKCAEANQgBADcIAQA4CAEAPAgBADwIAQA/CAEAVQgBAGAIAQB2CAEAgAgBAJ4IAQDgCAEA8ggBAPQIAQD1CAEAAAkBABUJAQAgCQEAOQkBAIAJAQC3CQEAvgkBAL8JAQAACgEAAAoBABAKAQATCgEAFQoBABcKAQAZCgEANQoBAGAKAQB8CgEAgAoBAJwKAQDACgEAxwoBAMkKAQDkCgEAAAsBADULAQBACwEAVQsBAGALAQByCwEAgAsBAJELAQAADAEASAwBAAANAQAjDQEAgA4BAKkOAQCwDgEAsQ4BAAAPAQAcDwEAJw8BACcPAQAwDwEARQ8BALAPAQDEDwEA4A8BAPYPAQADEAEANxABAIMQAQCvEAEA0BABAOgQAQADEQEAJhEBAEQRAQBEEQEARxEBAEcRAQBQEQEAchEBAHYRAQB2EQEAgxEBALIRAQDBEQEAxBEBANoRAQDaEQEA3BEBANwRAQAAEgEAERIBABMSAQArEgEAgBIBAIYSAQCIEgEAiBIBAIoSAQCNEgEAjxIBAJ0SAQCfEgEAqBIBALASAQDeEgEABRMBAAwTAQAPEwEAEBMBABMTAQAoEwEAKhMBADATAQAyEwEAMxMBADUTAQA5EwEAPRMBAD0TAQBQEwEAUBMBAF0TAQBhEwEAABQBADQUAQBHFAEAShQBAF8UAQBhFAEAgBQBAK8UAQDEFAEAxRQBAMcUAQDHFAEAgBUBAK4VAQDYFQEA2xUBAAAWAQAvFgEARBYBAEQWAQCAFgEAqhYBALgWAQC4FgEAABcBABoXAQAAGAEAKxgBAP8YAQAGGQEACRkBAAkZAQAMGQEAExkBABUZAQAWGQEAGBkBAC8ZAQA/GQEAPxkBAEEZAQBBGQEAoBkBAKcZAQCqGQEA0BkBAOEZAQDhGQEA4xkBAOMZAQAAGgEAABoBAAsaAQAyGgEAOhoBADoaAQBQGgEAUBoBAFwaAQCJGgEAnRoBAJ0aAQDAGgEA+BoBAAAcAQAIHAEAChwBAC4cAQBAHAEAQBwBAHIcAQCPHAEAAB0BAAYdAQAIHQEACR0BAAsdAQAwHQEARh0BAEYdAQBgHQEAZR0BAGcdAQBoHQEAah0BAIkdAQCYHQEAmB0BAOAeAQDyHgEAsB8BALAfAQAAIAEAmSMBAIAkAQBDJQEAADABAC40AQAARAEARkYBAABoAQA4agEAQGoBAF5qAQDQagEA7WoBAABrAQAvawEAY2sBAHdrAQB9awEAj2sBAABvAQBKbwEAUG8BAFBvAQAAcAEA94cBAACIAQDVjAEAAI0BAAiNAQAAsAEAHrEBAFCxAQBSsQEAZLEBAGexAQBwsQEA+7IBAAC8AQBqvAEAcLwBAHy8AQCAvAEAiLwBAJC8AQCZvAEAAOEBACzhAQBO4QEATuEBAMDiAQDr4gEAAOgBAMToAQAA7gEAA+4BAAXuAQAf7gEAIe4BACLuAQAk7gEAJO4BACfuAQAn7gEAKe4BADLuAQA07gEAN+4BADnuAQA57gEAO+4BADvuAQBC7gEAQu4BAEfuAQBH7gEASe4BAEnuAQBL7gEAS+4BAE3uAQBP7gEAUe4BAFLuAQBU7gEAVO4BAFfuAQBX7gEAWe4BAFnuAQBb7gEAW+4BAF3uAQBd7gEAX+4BAF/uAQBh7gEAYu4BAGTuAQBk7gEAZ+4BAGruAQBs7gEAcu4BAHTuAQB37gEAee4BAHzuAQB+7gEAfu4BAIDuAQCJ7gEAi+4BAJvuAQCh7gEAo+4BAKXuAQCp7gEAq+4BALvuAQAAAAIA3aYCAACnAgA0twIAQLcCAB24AgAguAIAoc4CALDOAgDg6wIAAPgCAB36AgAAAAMAShMDAAAAAAAAAAAAxQHFAcgByAHLAcsB8gHyAYgfjx+YH58fqB+vH7wfvB/MH8wf/B/8HwAAAAAAAAAAQQBaAMAA1gDYAN4AAAEAAQIBAgEEAQQBBgEGAQgBCAEKAQoBDAEMAQ4BDgEQARABEgESARQBFAEWARYBGAEYARoBGgEcARwBHgEeASABIAEiASIBJAEkASYBJgEoASgBKgEqASwBLAEuAS4BMAEwATIBMgE0ATQBNgE2ATkBOQE7ATsBPQE9AT8BPwFBAUEBQwFDAUUBRQFHAUcBSgFKAUwBTAFOAU4BUAFQAVIBUgFUAVQBVgFWAVgBWAFaAVoBXAFcAV4BXgFgAWABYgFiAWQBZAFmAWYBaAFoAWoBagFsAWwBbgFuAXABcAFyAXIBdAF0AXYBdgF4AXkBewF7AX0BfQGBAYIBhAGEAYYBhwGJAYsBjgGRAZMBlAGWAZgBnAGdAZ8BoAGiAaIBpAGkAaYBpwGpAakBrAGsAa4BrwGxAbMBtQG1AbcBuAG8AbwBxAHEAccBxwHKAcoBzQHNAc8BzwHRAdEB0wHTAdUB1QHXAdcB2QHZAdsB2wHeAd4B4AHgAeIB4gHkAeQB5gHmAegB6AHqAeoB7AHsAe4B7gHxAfEB9AH0AfYB+AH6AfoB/AH8Af4B/gEAAgACAgICAgQCBAIGAgYCCAIIAgoCCgIMAgwCDgIOAhACEAISAhICFAIUAhYCFgIYAhgCGgIaAhwCHAIeAh4CIAIgAiICIgIkAiQCJgImAigCKAIqAioCLAIsAi4CLgIwAjACMgIyAjoCOwI9Aj4CQQJBAkMCRgJIAkgCSgJKAkwCTAJOAk4CcANwA3IDcgN2A3YDfwN/A4YDhgOIA4oDjAOMA44DjwORA6EDowOrA88DzwPSA9QD2APYA9oD2gPcA9wD3gPeA+AD4APiA+ID5APkA+YD5gPoA+gD6gPqA+wD7APuA+4D9AP0A/cD9wP5A/oD/QMvBGAEYARiBGIEZARkBGYEZgRoBGgEagRqBGwEbARuBG4EcARwBHIEcgR0BHQEdgR2BHgEeAR6BHoEfAR8BH4EfgSABIAEigSKBIwEjASOBI4EkASQBJIEkgSUBJQElgSWBJgEmASaBJoEnAScBJ4EngSgBKAEogSiBKQEpASmBKYEqASoBKoEqgSsBKwErgSuBLAEsASyBLIEtAS0BLYEtgS4BLgEugS6BLwEvAS+BL4EwATBBMMEwwTFBMUExwTHBMkEyQTLBMsEzQTNBNAE0ATSBNIE1ATUBNYE1gTYBNgE2gTaBNwE3ATeBN4E4ATgBOIE4gTkBOQE5gTmBOgE6ATqBOoE7ATsBO4E7gTwBPAE8gTyBPQE9AT2BPYE+AT4BPoE+gT8BPwE/gT+BAAFAAUCBQIFBAUEBQYFBgUIBQgFCgUKBQwFDAUOBQ4FEAUQBRIFEgUUBRQFFgUWBRgFGAUaBRoFHAUcBR4FHgUgBSAFIgUiBSQFJAUmBSYFKAUoBSoFKgUsBSwFLgUuBTEFVgWgEMUQxxDHEM0QzRCgE/UTkBy6HL0cvxwAHgAeAh4CHgQeBB4GHgYeCB4IHgoeCh4MHgweDh4OHhAeEB4SHhIeFB4UHhYeFh4YHhgeGh4aHhweHB4eHh4eIB4gHiIeIh4kHiQeJh4mHigeKB4qHioeLB4sHi4eLh4wHjAeMh4yHjQeNB42HjYeOB44HjoeOh48HjwePh4+HkAeQB5CHkIeRB5EHkYeRh5IHkgeSh5KHkweTB5OHk4eUB5QHlIeUh5UHlQeVh5WHlgeWB5aHloeXB5cHl4eXh5gHmAeYh5iHmQeZB5mHmYeaB5oHmoeah5sHmwebh5uHnAecB5yHnIedB50HnYedh54Hngeeh56HnwefB5+Hn4egB6AHoIegh6EHoQehh6GHogeiB6KHooejB6MHo4ejh6QHpAekh6SHpQelB6eHp4eoB6gHqIeoh6kHqQeph6mHqgeqB6qHqoerB6sHq4erh6wHrAesh6yHrQetB62HrYeuB64Hroeuh68Hrwevh6+HsAewB7CHsIexB7EHsYexh7IHsgeyh7KHswezB7OHs4e0B7QHtIe0h7UHtQe1h7WHtge2B7aHtoe3B7cHt4e3h7gHuAe4h7iHuQe5B7mHuYe6B7oHuoe6h7sHuwe7h7uHvAe8B7yHvIe9B70HvYe9h74Hvge+h76Hvwe/B7+Hv4eCB8PHxgfHR8oHy8fOB8/H0gfTR9ZH1kfWx9bH10fXR9fH18faB9vH7gfux/IH8sf2B/bH+gf7B/4H/sfAiECIQchByELIQ0hECESIRUhFSEZIR0hJCEkISYhJiEoISghKiEtITAhMyE+IT8hRSFFIYMhgyEALC4sYCxgLGIsZCxnLGcsaSxpLGssayxtLHAscixyLHUsdSx+LIAsgiyCLIQshCyGLIYsiCyILIosiiyMLIwsjiyOLJAskCySLJIslCyULJYsliyYLJgsmiyaLJwsnCyeLJ4soCygLKIsoiykLKQspiymLKgsqCyqLKosrCysLK4sriywLLAssiyyLLQstCy2LLYsuCy4LLosuiy8LLwsviy+LMAswCzCLMIsxCzELMYsxizILMgsyizKLMwszCzOLM4s0CzQLNIs0izULNQs1izWLNgs2CzaLNos3CzcLN4s3izgLOAs4iziLOss6yztLO0s8izyLECmQKZCpkKmRKZEpkamRqZIpkimSqZKpkymTKZOpk6mUKZQplKmUqZUplSmVqZWplimWKZaplqmXKZcpl6mXqZgpmCmYqZipmSmZKZmpmamaKZopmqmaqZspmymgKaApoKmgqaEpoSmhqaGpoimiKaKpoqmjKaMpo6mjqaQppCmkqaSppSmlKaWppammKaYppqmmqYipyKnJKckpyanJqcopyinKqcqpyynLKcupy6nMqcypzSnNKc2pzanOKc4pzqnOqc8pzynPqc+p0CnQKdCp0KnRKdEp0anRqdIp0inSqdKp0ynTKdOp06nUKdQp1KnUqdUp1SnVqdWp1inWKdap1qnXKdcp16nXqdgp2CnYqdip2SnZKdmp2anaKdop2qnaqdsp2ynbqdup3mnead7p3unfad+p4CngKeCp4KnhKeEp4anhqeLp4unjaeNp5CnkKeSp5KnlqeWp5inmKeap5qnnKecp56nnqegp6Cnoqeip6SnpKemp6anqKeop6qnrqewp7Sntqe2p7inuKe6p7qnvKe8p76nvqfCp8KnxKfHp8mnyaf1p/WnIf86/wAAAAAAAAAAAAAAAAAEAQAnBAEAsAQBANMEAQCADAEAsgwBAKAYAQC/GAEAQG4BAF9uAQAA1AEAGdQBADTUAQBN1AEAaNQBAIHUAQCc1AEAnNQBAJ7UAQCf1AEAotQBAKLUAQCl1AEAptQBAKnUAQCs1AEArtQBALXUAQDQ1AEA6dQBAATVAQAF1QEAB9UBAArVAQAN1QEAFNUBABbVAQAc1QEAONUBADnVAQA71QEAPtUBAEDVAQBE1QEARtUBAEbVAQBK1QEAUNUBAGzVAQCF1QEAoNUBALnVAQDU1QEA7dUBAAjWAQAh1gEAPNYBAFXWAQBw1gEAidYBAKjWAQDA1gEA4tYBAPrWAQAc1wEANNcBAFbXAQBu1wEAkNcBAKjXAQDK1wEAytcBAADpAQAh6QEAgAIBAJwCAQAgCQEAOQkBAD8JAQA/CQEAAANvA4MEiQSRBb0FvwW/BcEFwgXEBcUFxwXHBRAGGgZLBl8GcAZwBtYG3AbfBuQG5wboBuoG7QYRBxEHMAdKB6YHsAfrB/MH/Qf9BxYIGQgbCCMIJQgnCCkILQhZCFsI0wjhCOMIAwk6CTwJPglPCVEJVwliCWMJgQmDCbwJvAm+CcQJxwnICcsJzQnXCdcJ4gnjCf4J/gkBCgMKPAo8Cj4KQgpHCkgKSwpNClEKUQpwCnEKdQp1CoEKgwq8CrwKvgrFCscKyQrLCs0K4grjCvoK/woBCwMLPAs8Cz4LRAtHC0gLSwtNC1ULVwtiC2MLgguCC74LwgvGC8gLygvNC9cL1wsADAQMPgxEDEYMSAxKDE0MVQxWDGIMYwyBDIMMvAy8DL4MxAzGDMgMygzNDNUM1gziDOMMAA0DDTsNPA0+DUQNRg1IDUoNTQ1XDVcNYg1jDYENgw3KDcoNzw3UDdYN1g3YDd8N8g3zDTEOMQ40DjoORw5ODrEOsQ60DrwOyA7NDhgPGQ81DzUPNw83DzkPOQ8+Dz8PcQ+ED4YPhw+ND5cPmQ+8D8YPxg8rED4QVhBZEF4QYBBiEGQQZxBtEHEQdBCCEI0QjxCPEJoQnRBdE18TEhcUFzIXNBdSF1MXchdzF7QX0xfdF90XCxgNGIUYhhipGKkYIBkrGTAZOxkXGhsaVRpeGmAafBp/Gn8asBrAGgAbBBs0G0QbaxtzG4AbghuhG60b5hvzGyQcNxzQHNIc1BzoHO0c7Rz0HPQc9xz5HMAd+R37Hf8d0CDwIO8s8Sx/LX8t4C3/LSowLzCZMJowb6ZypnSmfaaepp+m8KbxpgKoAqgGqAaoC6gLqCOoJ6gsqCyogKiBqLSoxajgqPGo/6j/qCapLalHqVOpgKmDqbOpwKnlqeWpKao2qkOqQ6pMqk2qe6p9qrCqsKqyqrSqt6q4qr6qv6rBqsGq66rvqvWq9qrjq+qr7Kvtqx77HvsA/g/+IP4v/gAAAAD9AQEA/QEBAOACAQDgAgEAdgMBAHoDAQABCgEAAwoBAAUKAQAGCgEADAoBAA8KAQA4CgEAOgoBAD8KAQA/CgEA5QoBAOYKAQAkDQEAJw0BAKsOAQCsDgEARg8BAFAPAQAAEAEAAhABADgQAQBGEAEAfxABAIIQAQCwEAEAuhABAAARAQACEQEAJxEBADQRAQBFEQEARhEBAHMRAQBzEQEAgBEBAIIRAQCzEQEAwBEBAMkRAQDMEQEAzhEBAM8RAQAsEgEANxIBAD4SAQA+EgEA3xIBAOoSAQAAEwEAAxMBADsTAQA8EwEAPhMBAEQTAQBHEwEASBMBAEsTAQBNEwEAVxMBAFcTAQBiEwEAYxMBAGYTAQBsEwEAcBMBAHQTAQA1FAEARhQBAF4UAQBeFAEAsBQBAMMUAQCvFQEAtRUBALgVAQDAFQEA3BUBAN0VAQAwFgEAQBYBAKsWAQC3FgEAHRcBACsXAQAsGAEAOhgBADAZAQA1GQEANxkBADgZAQA7GQEAPhkBAEAZAQBAGQEAQhkBAEMZAQDRGQEA1xkBANoZAQDgGQEA5BkBAOQZAQABGgEAChoBADMaAQA5GgEAOxoBAD4aAQBHGgEARxoBAFEaAQBbGgEAihoBAJkaAQAvHAEANhwBADgcAQA/HAEAkhwBAKccAQCpHAEAthwBADEdAQA2HQEAOh0BADodAQA8HQEAPR0BAD8dAQBFHQEARx0BAEcdAQCKHQEAjh0BAJAdAQCRHQEAkx0BAJcdAQDzHgEA9h4BAPBqAQD0agEAMGsBADZrAQBPbwEAT28BAFFvAQCHbwEAj28BAJJvAQDkbwEA5G8BAPBvAQDxbwEAnbwBAJ68AQBl0QEAadEBAG3RAQBy0QEAe9EBAILRAQCF0QEAi9EBAKrRAQCt0QEAQtIBAETSAQAA2gEANtoBADvaAQBs2gEAddoBAHXaAQCE2gEAhNoBAJvaAQCf2gEAodoBAK/aAQAA4AEABuABAAjgAQAY4AEAG+ABACHgAQAj4AEAJOABACbgAQAq4AEAMOEBADbhAQDs4gEA7+IBANDoAQDW6AEAROkBAErpAQAAAQ4A7wEOAFARAQB2EQEA4B4BAPgeAQAAAAAAAAAAAAANDA0ODRANEg1EDUYNSA1KDU8NVA1jDWYNfw1ACFsIXgheCAAAAAAAAAAAAAAAAMAKAQDmCgEA6woBAPYKAQBwHAEAjxwBAJIcAQCnHAEAqRwBALYcAQAAAAAAAAAAAAAdAQAGHQEACB0BAAkdAQALHQEANh0BADodAQA6HQEAPB0BAD0dAQA/HQEARx0BAFAdAQBZHQEAAAAAAAAAAAADCQMJOwk7CT4JQAlJCUwJTglPCYIJgwm+CcAJxwnICcsJzAnXCdcJAwoDCj4KQAqDCoMKvgrACskKyQrLCswKAgsDCz4LPgtAC0ALRwtIC0sLTAtXC1cLvgu/C8ELwgvGC8gLygvMC9cL1wsBDAMMQQxEDIIMgwy+DL4MwAzEDMcMyAzKDMsM1QzWDAINAw0+DUANRg1IDUoNTA1XDVcNgg2DDc8N0Q3YDd8N8g3zDT4PPw9/D38PKxAsEDEQMRA4EDgQOxA8EFYQVxBiEGQQZxBtEIMQhBCHEIwQjxCPEJoQnBC2F7YXvhfFF8cXyBcjGSYZKRkrGTAZMRkzGTgZGRoaGlUaVRpXGlcaYRphGmMaZBptGnIaBBsEGzUbNRs7GzsbPRtBG0MbRBuCG4IboRuhG6YbpxuqG6ob5xvnG+ob7BvuG+4b8hvzGyQcKxw0HDUc4RzhHPcc9xwuMC8wI6gkqCeoJ6iAqIGotKjDqFKpU6mDqYOptKm1qbqpu6m+qcCpL6owqjOqNKpNqk2qe6p7qn2qfarrquuq7qrvqvWq9arjq+Sr5qvnq+mr6qvsq+yrAAAAAAAAAAAAAAAAABABAAAQAQACEAEAAhABAIIQAQCCEAEAsBABALIQAQC3EAEAuBABACwRAQAsEQEARREBAEYRAQCCEQEAghEBALMRAQC1EQEAvxEBAMARAQDOEQEAzhEBACwSAQAuEgEAMhIBADMSAQA1EgEANRIBAOASAQDiEgEAAhMBAAMTAQA+EwEAPxMBAEETAQBEEwEARxMBAEgTAQBLEwEATRMBAFcTAQBXEwEAYhMBAGMTAQA1FAEANxQBAEAUAQBBFAEARRQBAEUUAQCwFAEAshQBALkUAQC5FAEAuxQBAL4UAQDBFAEAwRQBAK8VAQCxFQEAuBUBALsVAQC+FQEAvhUBADAWAQAyFgEAOxYBADwWAQA+FgEAPhYBAKwWAQCsFgEArhYBAK8WAQC2FgEAthYBACAXAQAhFwEAJhcBACYXAQAsGAEALhgBADgYAQA4GAEAMBkBADUZAQA3GQEAOBkBAD0ZAQA9GQEAQBkBAEAZAQBCGQEAQhkBANEZAQDTGQEA3BkBAN8ZAQDkGQEA5BkBADkaAQA5GgEAVxoBAFgaAQCXGgEAlxoBAC8cAQAvHAEAPhwBAD4cAQCpHAEAqRwBALEcAQCxHAEAtBwBALQcAQCKHQEAjh0BAJMdAQCUHQEAlh0BAJYdAQD1HgEA9h4BAFFvAQCHbwEA8G8BAPFvAQBl0QEAZtEBAG3RAQBy0QEAiASJBL4avhrdIOAg4iDkIHCmcqZAbgEAmm4BAOCq9qrAq+2r8Kv5qwAAAAAAAAAAAOgBAMToAQDH6AEA1ugBAKAJAQC3CQEAvAkBAM8JAQDSCQEA/wkBAIAJAQCfCQEAAG8BAEpvAQBPbwEAh28BAI9vAQCfbwEAAAAAAAAAAAAAA28DgwSHBJEFvQW/Bb8FwQXCBcQFxQXHBccFEAYaBksGXwZwBnAG1gbcBt8G5AbnBugG6gbtBhEHEQcwB0oHpgewB+sH8wf9B/0HFggZCBsIIwglCCcIKQgtCFkIWwjTCOEI4wgCCToJOgk8CTwJQQlICU0JTQlRCVcJYgljCYEJgQm8CbwJwQnECc0JzQniCeMJ/gn+CQEKAgo8CjwKQQpCCkcKSApLCk0KUQpRCnAKcQp1CnUKgQqCCrwKvArBCsUKxwrICs0KzQriCuMK+gr/CgELAQs8CzwLPws/C0ELRAtNC00LVQtWC2ILYwuCC4ILwAvAC80LzQsADAAMBAwEDD4MQAxGDEgMSgxNDFUMVgxiDGMMgQyBDLwMvAy/DL8MxgzGDMwMzQziDOMMAA0BDTsNPA1BDUQNTQ1NDWINYw2BDYENyg3KDdIN1A3WDdYNMQ4xDjQOOg5HDk4OsQ6xDrQOvA7IDs0OGA8ZDzUPNQ83DzcPOQ85D3EPfg+AD4QPhg+HD40Plw+ZD7wPxg/GDy0QMBAyEDcQORA6ED0QPhBYEFkQXhBgEHEQdBCCEIIQhRCGEI0QjRCdEJ0QXRNfExIXFBcyFzQXUhdTF3IXcxe0F7UXtxe9F8YXxhfJF9MX3RfdFwsYDRiFGIYYqRipGCAZIhknGSgZMhkyGTkZOxkXGhgaGxobGlYaVhpYGl4aYBpgGmIaYhplGmwacxp8Gn8afxqwGr0avxrAGgAbAxs0GzQbNhs6GzwbPBtCG0IbaxtzG4AbgRuiG6UbqBupG6sbrRvmG+Yb6BvpG+0b7RvvG/EbLBwzHDYcNxzQHNIc1BzgHOIc6BztHO0c9Bz0HPgc+RzAHfkd+x3/HdAg3CDhIOEg5SDwIO8s8Sx/LX8t4C3/LSowLTCZMJowb6ZvpnSmfaaepp+m8KbxpgKoAqgGqAaoC6gLqCWoJqgsqCyoxKjFqOCo8aj/qP+oJqktqUepUamAqYKps6mzqbapuam8qb2p5anlqSmqLqoxqjKqNao2qkOqQ6pMqkyqfKp8qrCqsKqyqrSqt6q4qr6qv6rBqsGq7Krtqvaq9qrlq+Wr6Kvoq+2r7ase+x77AP4P/iD+L/4AAAAAAAAAAP0BAQD9AQEA4AIBAOACAQB2AwEAegMBAAEKAQADCgEABQoBAAYKAQAMCgEADwoBADgKAQA6CgEAPwoBAD8KAQDlCgEA5goBACQNAQAnDQEAqw4BAKwOAQBGDwEAUA8BAAEQAQABEAEAOBABAEYQAQB/EAEAgRABALMQAQC2EAEAuRABALoQAQAAEQEAAhEBACcRAQArEQEALREBADQRAQBzEQEAcxEBAIARAQCBEQEAthEBAL4RAQDJEQEAzBEBAM8RAQDPEQEALxIBADESAQA0EgEANBIBADYSAQA3EgEAPhIBAD4SAQDfEgEA3xIBAOMSAQDqEgEAABMBAAETAQA7EwEAPBMBAEATAQBAEwEAZhMBAGwTAQBwEwEAdBMBADgUAQA/FAEAQhQBAEQUAQBGFAEARhQBAF4UAQBeFAEAsxQBALgUAQC6FAEAuhQBAL8UAQDAFAEAwhQBAMMUAQCyFQEAtRUBALwVAQC9FQEAvxUBAMAVAQDcFQEA3RUBADMWAQA6FgEAPRYBAD0WAQA/FgEAQBYBAKsWAQCrFgEArRYBAK0WAQCwFgEAtRYBALcWAQC3FgEAHRcBAB8XAQAiFwEAJRcBACcXAQArFwEALxgBADcYAQA5GAEAOhgBADsZAQA8GQEAPhkBAD4ZAQBDGQEAQxkBANQZAQDXGQEA2hkBANsZAQDgGQEA4BkBAAEaAQAKGgEAMxoBADgaAQA7GgEAPhoBAEcaAQBHGgEAURoBAFYaAQBZGgEAWxoBAIoaAQCWGgEAmBoBAJkaAQAwHAEANhwBADgcAQA9HAEAPxwBAD8cAQCSHAEApxwBAKocAQCwHAEAshwBALMcAQC1HAEAthwBADEdAQA2HQEAOh0BADodAQA8HQEAPR0BAD8dAQBFHQEARx0BAEcdAQCQHQEAkR0BAJUdAQCVHQEAlx0BAJcdAQDzHgEA9B4BAPBqAQD0agEAMGsBADZrAQBPbwEAT28BAI9vAQCSbwEA5G8BAORvAQCdvAEAnrwBAGfRAQBp0QEAe9EBAILRAQCF0QEAi9EBAKrRAQCt0QEAQtIBAETSAQAA2gEANtoBADvaAQBs2gEAddoBAHXaAQCE2gEAhNoBAJvaAQCf2gEAodoBAK/aAQAA4AEABuABAAjgAQAY4AEAG+ABACHgAQAj4AEAJOABACbgAQAq4AEAMOEBADbhAQDs4gEA7+IBANDoAQDW6AEAROkBAErpAQAAAQ4A7wEOAAAAAAAAAAAAABYBAEQWAQBQFgEAWRYBAAAYARgEGAQYBhgOGBAYGRggGHgYgBiqGGAWAQBsFgEAQGoBAF5qAQBgagEAaWoBAG5qAQBvagEAAAAAAAAAAACAEgEAhhIBAIgSAQCIEgEAihIBAI0SAQCPEgEAnRIBAJ8SAQCpEgEAABCfEOCp/qlgqn+qAAAAAAAAAAAAAAAAMAA5ALIAswC5ALkAvAC+AGAGaQbwBvkGwAfJB2YJbwnmCe8J9An5CWYKbwrmCu8KZgtvC3ILdwvmC/ILZgxvDHgMfgzmDO8MWA1eDWYNeA3mDe8NUA5ZDtAO2Q4gDzMPQBBJEJAQmRBpE3wT7hbwFuAX6RfwF/kXEBgZGEYZTxnQGdoZgBqJGpAamRpQG1kbsBu5G0AcSRxQHFkccCBwIHQgeSCAIIkgUCGCIYUhiSFgJJsk6iT/JHYnkyf9LP0sBzAHMCEwKTA4MDowkjGVMSAyKTJIMk8yUTJfMoAyiTKxMr8yIKYppuam76YwqDWo0KjZqACpCanQqdmp8Kn5qVCqWarwq/mrEP8Z/wAAAAAHAQEAMwEBAEABAQB4AQEAigEBAIsBAQDhAgEA+wIBACADAQAjAwEAQQMBAEEDAQBKAwEASgMBANEDAQDVAwEAoAQBAKkEAQBYCAEAXwgBAHkIAQB/CAEApwgBAK8IAQD7CAEA/wgBABYJAQAbCQEAvAkBAL0JAQDACQEAzwkBANIJAQD/CQEAQAoBAEgKAQB9CgEAfgoBAJ0KAQCfCgEA6woBAO8KAQBYCwEAXwsBAHgLAQB/CwEAqQsBAK8LAQD6DAEA/wwBADANAQA5DQEAYA4BAH4OAQAdDwEAJg8BAFEPAQBUDwEAxQ8BAMsPAQBSEAEAbxABAPAQAQD5EAEANhEBAD8RAQDQEQEA2REBAOERAQD0EQEA8BIBAPkSAQBQFAEAWRQBANAUAQDZFAEAUBYBAFkWAQDAFgEAyRYBADAXAQA7FwEA4BgBAPIYAQBQGQEAWRkBAFAcAQBsHAEAUB0BAFkdAQCgHQEAqR0BAMAfAQDUHwEAACQBAG4kAQBgagEAaWoBAFBrAQBZawEAW2sBAGFrAQCAbgEAlm4BAODSAQDz0gEAYNMBAHjTAQDO1wEA/9cBAEDhAQBJ4QEA8OIBAPniAQDH6AEAz+gBAFDpAQBZ6QEAcewBAKvsAQCt7AEAr+wBALHsAQC07AEAAe0BAC3tAQAv7QEAPe0BAADxAQAM8QEA8PsBAPn7AQCACAEAnggBAKcIAQCvCAEAoBkBAKcZAQCqGQEA1xkBANoZAQDkGQEAAAAAAAAAAAAwADkAYAZpBvAG+QbAB8kHZglvCeYJ7wlmCm8K5grvCmYLbwvmC+8LZgxvDOYM7wxmDW8N5g3vDVAOWQ7QDtkOIA8pD0AQSRCQEJkQ4BfpFxAYGRhGGU8Z0BnZGYAaiRqQGpkaUBtZG7AbuRtAHEkcUBxZHCCmKabQqNmoAKkJqdCp2anwqfmpUKpZqvCr+asQ/xn/AAAAAAAAAAAAAAAAoAQBAKkEAQAwDQEAOQ0BAGYQAQBvEAEA8BABAPkQAQA2EQEAPxEBANARAQDZEQEA8BIBAPkSAQBQFAEAWRQBANAUAQDZFAEAUBYBAFkWAQDAFgEAyRYBADAXAQA5FwEA4BgBAOkYAQBQGQEAWRkBAFAcAQBZHAEAUB0BAFkdAQCgHQEAqR0BAGBqAQBpagEAUGsBAFlrAQDO1wEA/9cBAEDhAQBJ4QEA8OIBAPniAQBQ6QEAWekBAPD7AQD5+wEAgBmrGbAZyRnQGdoZ3hnfGQAUAQBbFAEAXRQBAGEUAQDAB/oH/Qf/BwAAAAAAAAAA7hbwFmAhgiGFIYghBzAHMCEwKTA4MDow5qbvpgAAAABAAQEAdAEBAEEDAQBBAwEASgMBAEoDAQDRAwEA1QMBAAAkAQBuJAEAAAAAAAAAAACyALMAuQC5ALwAvgD0CfkJcgt3C/AL8gt4DH4MWA1eDXANeA0qDzMPaRN8E/AX+RfaGdoZcCBwIHQgeSCAIIkgUCFfIYkhiSFgJJsk6iT/JHYnkyf9LP0skjGVMSAyKTJIMk8yUTJfMoAyiTKxMr8yMKg1qAAAAAAAAAAAAAAAAAcBAQAzAQEAdQEBAHgBAQCKAQEAiwEBAOECAQD7AgEAIAMBACMDAQBYCAEAXwgBAHkIAQB/CAEApwgBAK8IAQD7CAEA/wgBABYJAQAbCQEAvAkBAL0JAQDACQEAzwkBANIJAQD/CQEAQAoBAEgKAQB9CgEAfgoBAJ0KAQCfCgEA6woBAO8KAQBYCwEAXwsBAHgLAQB/CwEAqQsBAK8LAQD6DAEA/wwBAGAOAQB+DgEAHQ8BACYPAQBRDwEAVA8BAMUPAQDLDwEAUhABAGUQAQDhEQEA9BEBADoXAQA7FwEA6hgBAPIYAQBaHAEAbBwBAMAfAQDUHwEAW2sBAGFrAQCAbgEAlm4BAODSAQDz0gEAYNMBAHjTAQDH6AEAz+gBAHHsAQCr7AEArewBAK/sAQCx7AEAtOwBAAHtAQAt7QEAL+0BAD3tAQAA8QEADPEBAOFvAQDhbwEAcLEBAPuyAQAA4QEALOEBADDhAQA94QEAQOEBAEnhAQBO4QEAT+EBAIAWnBZQHH8cAAAAAAAAAACADAEAsgwBAMAMAQDyDAEA+gwBAP8MAQAAAAAAAAAAAAADAQAjAwEALQMBAC8DAQCACgEAnwoBAFADAQB6AwEAoAMBAMMDAQDIAwEA1QMBAAAPAQAnDwEAYAoBAH8KAQAADAEASAwBAAAAAAAAAAAAAQsDCwULDAsPCxALEwsoCyoLMAsyCzMLNQs5CzwLRAtHC0gLSwtNC1ULVwtcC10LXwtjC2YLdwsAAAAAAAAAALAEAQDTBAEA2AQBAPsEAQCABAEAnQQBAKAEAQCpBAEAIQAjACUAKgAsAC8AOgA7AD8AQABbAF0AXwBfAHsAewB9AH0AoQChAKcApwCrAKsAtgC3ALsAuwC/AL8AfgN+A4cDhwNaBV8FiQWKBb4FvgXABcAFwwXDBcYFxgXzBfQFCQYKBgwGDQYbBhsGHgYfBmoGbQbUBtQGAAcNB/cH+QcwCD4IXgheCGQJZQlwCXAJ/Qn9CXYKdgrwCvAKdwx3DIQMhAz0DfQNTw5PDloOWw4EDxIPFA8UDzoPPQ+FD4UP0A/UD9kP2g9KEE8Q+xD7EGATaBMAFAAUbhZuFpsWnBbrFu0WNRc2F9QX1hfYF9oXABgKGEQZRRkeGh8aoBqmGqgarRpaG2Ab/Bv/GzscPxx+HH8cwBzHHNMc0xwQICcgMCBDIEUgUSBTIF4gfSB+II0gjiAIIwsjKSMqI2gndSfFJ8Yn5ifvJ4MpmCnYKdsp/Cn9Kfks/Cz+LP8scC1wLQAuLi4wLk8uUi5SLgEwAzAIMBEwFDAfMDAwMDA9MD0woDCgMPsw+zD+pP+kDaYPpnOmc6Z+pn6m8qb3pnSod6jOqM+o+Kj6qPyo/KguqS+pX6lfqcGpzaneqd+pXKpfqt6q36rwqvGq66vrqz79P/0Q/hn+MP5S/lT+Yf5j/mP+aP5o/mr+a/4B/wP/Bf8K/wz/D/8a/xv/H/8g/zv/Pf8//z//W/9b/13/Xf9f/2X/AAEBAAIBAQCfAwEAnwMBANADAQDQAwEAbwUBAG8FAQBXCAEAVwgBAB8JAQAfCQEAPwkBAD8JAQBQCgEAWAoBAH8KAQB/CgEA8AoBAPYKAQA5CwEAPwsBAJkLAQCcCwEArQ4BAK0OAQBVDwEAWQ8BAEcQAQBNEAEAuxABALwQAQC+EAEAwRABAEARAQBDEQEAdBEBAHURAQDFEQEAyBEBAM0RAQDNEQEA2xEBANsRAQDdEQEA3xEBADgSAQA9EgEAqRIBAKkSAQBLFAEATxQBAFoUAQBbFAEAXRQBAF0UAQDGFAEAxhQBAMEVAQDXFQEAQRYBAEMWAQBgFgEAbBYBADwXAQA+FwEAOxgBADsYAQBEGQEARhkBAOIZAQDiGQEAPxoBAEYaAQCaGgEAnBoBAJ4aAQCiGgEAQRwBAEUcAQBwHAEAcRwBAPceAQD4HgEA/x8BAP8fAQBwJAEAdCQBAG5qAQBvagEA9WoBAPVqAQA3awEAO2sBAERrAQBEawEAl24BAJpuAQDibwEA4m8BAJ+8AQCfvAEAh9oBAIvaAQBe6QEAX+kBAAAAAAAAAAAAAGsBAEVrAQBQawEAWWsBAFtrAQBhawEAY2sBAHdrAQB9awEAj2sBAGAIAQB/CAEAwBoBAPgaAQAAAAAAAAAAAF8AXwA/IEAgVCBUIDP+NP5N/k/+P/8//wAAAAAAAAAALQAtAIoFigW+Bb4FABQAFAYYBhgQIBUgFy4XLhouGi46LjsuQC5ALhwwHDAwMDAwoDCgMDH+Mv5Y/lj+Y/5j/g3/Df+tDgEArQ4BAAAAAAApACkAXQBdAH0AfQA7DzsPPQ89D5wWnBZGIEYgfiB+II4gjiAJIwkjCyMLIyojKiNpJ2knaydrJ20nbSdvJ28ncSdxJ3Mncyd1J3UnxifGJ+cn5yfpJ+kn6yfrJ+0n7SfvJ+8nhCmEKYYphimIKYgpiimKKYwpjCmOKY4pkCmQKZIpkimUKZQplimWKZgpmCnZKdkp2ynbKf0p/SkjLiMuJS4lLicuJy4pLikuCTAJMAswCzANMA0wDzAPMBEwETAVMBUwFzAXMBkwGTAbMBswHjAfMD79Pv0Y/hj+Nv42/jj+OP46/jr+PP48/j7+Pv5A/kD+Qv5C/kT+RP5I/kj+Wv5a/lz+XP5e/l7+Cf8J/z3/Pf9d/13/YP9g/2P/Y/+7ALsAGSAZIB0gHSA6IDogAy4DLgUuBS4KLgouDS4NLh0uHS4hLiEuQKh3qAAAAAAACQEAGwkBAB8JAQAfCQEAqwCrABggGCAbIBwgHyAfIDkgOSACLgIuBC4ELgkuCS4MLgwuHC4cLiAuIC4AAAAAIQAjACUAJwAqACoALAAsAC4ALwA6ADsAPwBAAFwAXAChAKEApwCnALYAtwC/AL8AfgN+A4cDhwNaBV8FiQWJBcAFwAXDBcMFxgXGBfMF9AUJBgoGDAYNBhsGGwYeBh8GagZtBtQG1AYABw0H9wf5BzAIPgheCF4IZAllCXAJcAn9Cf0Jdgp2CvAK8Ap3DHcMhAyEDPQN9A1PDk8OWg5bDgQPEg8UDxQPhQ+FD9AP1A/ZD9oPShBPEPsQ+xBgE2gTbhZuFusW7RY1FzYX1BfWF9gX2hcAGAUYBxgKGEQZRRkeGh8aoBqmGqgarRpaG2Ab/Bv/GzscPxx+HH8cwBzHHNMc0xwWIBcgICAnIDAgOCA7ID4gQSBDIEcgUSBTIFMgVSBeIPks/Cz+LP8scC1wLQAuAS4GLgguCy4LLg4uFi4YLhkuGy4bLh4uHy4qLi4uMC45LjwuPy5BLkEuQy5PLlIuUi4BMAMwPTA9MPsw+zD+pP+kDaYPpnOmc6Z+pn6m8qb3pnSod6jOqM+o+Kj6qPyo/KguqS+pX6lfqcGpzaneqd+pXKpfqt6q36rwqvGq66vrqxD+Fv4Z/hn+MP4w/kX+Rv5J/kz+UP5S/lT+V/5f/mH+aP5o/mr+a/4B/wP/Bf8H/wr/Cv8M/wz/Dv8P/xr/G/8f/yD/PP88/2H/Yf9k/2X/AAAAAAAAAAAAAAAAAAEBAAIBAQCfAwEAnwMBANADAQDQAwEAbwUBAG8FAQBXCAEAVwgBAB8JAQAfCQEAPwkBAD8JAQBQCgEAWAoBAH8KAQB/CgEA8AoBAPYKAQA5CwEAPwsBAJkLAQCcCwEAVQ8BAFkPAQBHEAEATRABALsQAQC8EAEAvhABAMEQAQBAEQEAQxEBAHQRAQB1EQEAxREBAMgRAQDNEQEAzREBANsRAQDbEQEA3REBAN8RAQA4EgEAPRIBAKkSAQCpEgEASxQBAE8UAQBaFAEAWxQBAF0UAQBdFAEAxhQBAMYUAQDBFQEA1xUBAEEWAQBDFgEAYBYBAGwWAQA8FwEAPhcBADsYAQA7GAEARBkBAEYZAQDiGQEA4hkBAD8aAQBGGgEAmhoBAJwaAQCeGgEAohoBAEEcAQBFHAEAcBwBAHEcAQD3HgEA+B4BAP8fAQD/HwEAcCQBAHQkAQBuagEAb2oBAPVqAQD1agEAN2sBADtrAQBEawEARGsBAJduAQCabgEA4m8BAOJvAQCfvAEAn7wBAIfaAQCL2gEAXukBAF/pAQAoACgAWwBbAHsAewA6DzoPPA88D5sWmxYaIBogHiAeIEUgRSB9IH0gjSCNIAgjCCMKIwojKSMpI2gnaCdqJ2onbCdsJ24nbidwJ3AncidyJ3QndCfFJ8Un5ifmJ+gn6CfqJ+on7CfsJ+4n7ieDKYMphSmFKYcphymJKYkpiymLKY0pjSmPKY8pkSmRKZMpkymVKZUplymXKdgp2CnaKdop/Cn8KSIuIi4kLiQuJi4mLiguKC5CLkIuCDAIMAowCjAMMAwwDjAOMBAwEDAUMBQwFjAWMBgwGDAaMBowHTAdMD/9P/0X/hf+Nf41/jf+N/45/jn+O/47/j3+Pf4//j/+Qf5B/kP+Q/5H/kf+Wf5Z/lv+W/5d/l3+CP8I/zv/O/9b/1v/X/9f/2L/Yv8AAAAAgAsBAJELAQCZCwEAnAsBAKkLAQCvCwEAMKlTqV+pX6mgFuoW7hb4FgAAAAAAAAAAJAAkACsAKwA8AD4AXgBeAGAAYAB8AHwAfgB+AKIApgCoAKkArACsAK4AsQC0ALQAuAC4ANcA1wD3APcAwgLFAtIC3wLlAusC7QLtAu8C/wJ1A3UDhAOFA/YD9gOCBIIEjQWPBQYGCAYLBgsGDgYPBt4G3gbpBukG/Qb+BvYH9gf+B/8H8gnzCfoJ+wnxCvEKcAtwC/ML+gt/DH8MTw1PDXkNeQ0/Dj8OAQ8DDxMPEw8VDxcPGg8fDzQPNA82DzYPOA84D74PxQ/HD8wPzg/PD9UP2A+eEJ8QkBOZE20WbRbbF9sXQBlAGd4Z/xlhG2obdBt8G70fvR+/H8EfzR/PH90f3x/tH+8f/R/+H0QgRCBSIFIgeiB8IIogjCCgIL8gACEBIQMhBiEIIQkhFCEUIRYhGCEeISMhJSElISchJyEpISkhLiEuITohOyFAIUQhSiFNIU8hTyGKIYshkCEHIwwjKCMrIyYkQCRKJJwk6SQAJWcnlCfEJ8cn5SfwJ4IpmSnXKdwp+yn+KXMrdiuVK5cr/yvlLOosUC5RLoAumS6bLvMuAC/VL/Av+y8EMAQwEjATMCAwIDA2MDcwPjA/MJswnDCQMZExljGfMcAx4zEAMh4yKjJHMlAyUDJgMn8yijKwMsAy/zPATf9NkKTGpACnFqcgpyGniaeKpyioK6g2qDmod6p5qlurW6tqq2urKfsp+7L7wfv8/f39Yv5i/mT+Zv5p/mn+BP8E/wv/C/8c/x7/Pv8+/0D/QP9c/1z/Xv9e/+D/5v/o/+7//P/9/zcBAQA/AQEAeQEBAIkBAQCMAQEAjgEBAJABAQCcAQEAoAEBAKABAQDQAQEA/AEBAHcIAQB4CAEAyAoBAMgKAQA/FwEAPxcBANUfAQDxHwEAPGsBAD9rAQBFawEARWsBAJy8AQCcvAEAANABAPXQAQAA0QEAJtEBACnRAQBk0QEAatEBAGzRAQCD0QEAhNEBAIzRAQCp0QEArtEBAOjRAQAA0gEAQdIBAEXSAQBF0gEAANMBAFbTAQDB1gEAwdYBANvWAQDb1gEA+9YBAPvWAQAV1wEAFdcBADXXAQA11wEAT9cBAE/XAQBv1wEAb9cBAInXAQCJ1wEAqdcBAKnXAQDD1wEAw9cBAADYAQD/2QEAN9oBADraAQBt2gEAdNoBAHbaAQCD2gEAhdoBAIbaAQBP4QEAT+EBAP/iAQD/4gEArOwBAKzsAQCw7AEAsOwBAC7tAQAu7QEA8O4BAPHuAQAA8AEAK/ABADDwAQCT8AEAoPABAK7wAQCx8AEAv/ABAMHwAQDP8AEA0fABAPXwAQAN8QEArfEBAObxAQAC8gEAEPIBADvyAQBA8gEASPIBAFDyAQBR8gEAYPIBAGXyAQAA8wEA1/YBAOD2AQDs9gEA8PYBAPz2AQAA9wEAc/cBAID3AQDY9wEA4PcBAOv3AQAA+AEAC/gBABD4AQBH+AEAUPgBAFn4AQBg+AEAh/gBAJD4AQCt+AEAsPgBALH4AQAA+QEAePkBAHr5AQDL+QEAzfkBAFP6AQBg+gEAbfoBAHD6AQB0+gEAePoBAHr6AQCA+gEAhvoBAJD6AQCo+gEAsPoBALb6AQDA+gEAwvoBAND6AQDW+gEAAPsBAJL7AQCU+wEAyvsBAAAILQgwCD4IgKjFqM6o2agAAAAAAAAAACQAJACiAKUAjwWPBQsGCwb+B/8H8gnzCfsJ+wnxCvEK+Qv5Cz8OPw7bF9sXoCC/IDioOKj8/fz9af5p/gT/BP/g/+H/5f/m/wAAAAAAAAAA3R8BAOAfAQD/4gEA/+IBALDsAQCw7AEAgBEBAN8RAQBQBAEAfwQBAAAAAAAAAAAAgBUBALUVAQC4FQEA3RUBAADYAQCL2gEAm9oBAJ/aAQCh2gEAr9oBAAAAAAAAAAAAgQ2DDYUNlg2aDbENsw27Db0NvQ3ADcYNyg3KDc8N1A3WDdYN2A3fDeYN7w3yDfQN4REBAPQRAQAAAAAAAAAAAF4AXgBgAGAAqACoAK8ArwC0ALQAuAC4AMICxQLSAt8C5QLrAu0C7QLvAv8CdQN1A4QDhQO9H70fvx/BH80fzx/dH98f7R/vH/0f/h+bMJwwAKcWpyCnIaeJp4qnW6tbq2qra6uy+8H7Pv8+/0D/QP/j/+P/+/MBAP/zAQAAAAAAKwArADwAPgB8AHwAfgB+AKwArACxALEA1wDXAPcA9wD2A/YDBgYIBkQgRCBSIFIgeiB8IIogjCAYIRghQCFEIUshSyGQIZQhmiGbIaAhoCGjIaMhpiGmIa4hriHOIc8h0iHSIdQh1CH0If8iICMhI3wjfCObI7Mj3CPhI7cltyXBJcEl+CX/JW8mbybAJ8QnxyflJ/An/ycAKYIpmSnXKdwp+yn+Kf8qMCtEK0crTCsp+yn7Yv5i/mT+Zv4L/wv/HP8e/1z/XP9e/17/4v/i/+n/7P8AAAAAAAAAAAAAAADB1gEAwdYBANvWAQDb1gEA+9YBAPvWAQAV1wEAFdcBADXXAQA11wEAT9cBAE/XAQBv1wEAb9cBAInXAQCJ1wEAqdcBAKnXAQDD1wEAw9cBAPDuAQDx7gEAAAAAAAAAAACmAKYAqQCpAK4ArgCwALAAggSCBI0FjgUOBg8G3gbeBukG6Qb9Bv4G9gf2B/oJ+glwC3AL8wv4C/oL+gt/DH8MTw1PDXkNeQ0BDwMPEw8TDxUPFw8aDx8PNA80DzYPNg84DzgPvg/FD8cPzA/OD88P1Q/YD54QnxCQE5kTbRZtFkAZQBneGf8ZYRtqG3QbfBsAIQEhAyEGIQghCSEUIRQhFiEXIR4hIyElISUhJyEnISkhKSEuIS4hOiE7IUohSiFMIU0hTyFPIYohiyGVIZkhnCGfIaEhoiGkIaUhpyGtIa8hzSHQIdEh0yHTIdUh8yEAIwcjDCMfIyIjKCMrI3sjfSOaI7Qj2yPiIyYkQCRKJJwk6SQAJbYluCXAJcIl9yUAJm4mcCZnJ5QnvycAKP8oACsvK0UrRitNK3MrdiuVK5cr/yvlLOosUC5RLoAumS6bLvMuAC/VL/Av+y8EMAQwEjATMCAwIDA2MDcwPjA/MJAxkTGWMZ8xwDHjMQAyHjIqMkcyUDJQMmAyfzKKMrAywDL/M8BN/02QpMakKKgrqDaoN6g5qDmod6p5qv39/f3k/+T/6P/o/+3/7v/8//3/NwEBAD8BAQB5AQEAiQEBAIwBAQCOAQEAkAEBAJwBAQCgAQEAoAEBANABAQD8AQEAdwgBAHgIAQDICgEAyAoBAD8XAQA/FwEA1R8BANwfAQDhHwEA8R8BADxrAQA/awEARWsBAEVrAQCcvAEAnLwBAADQAQD10AEAANEBACbRAQAp0QEAZNEBAGrRAQBs0QEAg9EBAITRAQCM0QEAqdEBAK7RAQDo0QEAANIBAEHSAQBF0gEARdIBAADTAQBW0wEAANgBAP/ZAQA32gEAOtoBAG3aAQB02gEAdtoBAIPaAQCF2gEAhtoBAE/hAQBP4QEArOwBAKzsAQAu7QEALu0BAADwAQAr8AEAMPABAJPwAQCg8AEArvABALHwAQC/8AEAwfABAM/wAQDR8AEA9fABAA3xAQCt8QEA5vEBAALyAQAQ8gEAO/IBAEDyAQBI8gEAUPIBAFHyAQBg8gEAZfIBAADzAQD68wEAAPQBANf2AQDg9gEA7PYBAPD2AQD89gEAAPcBAHP3AQCA9wEA2PcBAOD3AQDr9wEAAPgBAAv4AQAQ+AEAR/gBAFD4AQBZ+AEAYPgBAIf4AQCQ+AEArfgBALD4AQCx+AEAAPkBAHj5AQB6+QEAy/kBAM35AQBT+gEAYPoBAG36AQBw+gEAdPoBAHj6AQB6+gEAgPoBAIb6AQCQ+gEAqPoBALD6AQC2+gEAwPoBAML6AQDQ+gEA1voBAAD7AQCS+wEAlPsBAMr7AQAwDwEAWQ8BAAAAAAAAAAAA0BABAOgQAQDwEAEA+RABAFAaAQCiGgEAgBu/G8AcxxwAqCyoAAAAAAAAAAAAAAAAAAcNBw8HSgdNB08HYAhqCAAXDBcOFxQXYBdsF24XcBdyF3MXUBltGXAZdBkAAAAAIBpeGmAafBp/GokakBqZGqAarRqAqsKq26rfqgAAAACAFgEAuBYBAMAWAQDJFgEAgguDC4ULiguOC5ALkguVC5kLmgucC5wLngufC6MLpAuoC6oLrgu5C74LwgvGC8gLygvNC9AL0AvXC9cL5gv6C8AfAQDxHwEA/x8BAP8fAQDgbwEA4G8BAABwAQD3hwEAAIgBAP+KAQAAjQEACI0BAAAMDAwODBAMEgwoDCoMOQw9DEQMRgxIDEoMTQxVDFYMWAxaDGAMYwxmDG8Mdwx/DIAHsQcBDjoOQA5bDgAAAAAAD0cPSQ9sD3EPlw+ZD7wPvg/MD84P1A/ZD9oPMC1nLW8tcC1/LX8tAAAAAAAAAACAFAEAxxQBANAUAQDZFAEAgAMBAJ0DAQCfAwEAnwMBAAClK6YAAAAAAAAAAAAAAADA4gEA+eIBAP/iAQD/4gEAoBgBAPIYAQD/GAEA/xgBAIAOAQCpDgEAqw4BAK0OAQCwDgEAsQ4BAACgjKSQpMakIAAgAKAAoACAFoAWACAKICggKSAvIC8gXyBfIAAwADAAGgEARxoBACggKCApICkgIAAgAKAAoACAFoAWACAKIC8gLyBfIF8gADAAMAAAAABiCAEAAQAAAAAAAAAAAAAA4EoBAAMAAABKCAEAAQAAAAAAAAAAAAAAAEsBAAMAAABYAgEAAQAAAAAAAAAAAAAAGEsBAAEAAADpDgEAAQAAACBLAQAWAAAAgEsBACMAAAAvBwEAAQAAAKBMAQAEAAAAAAAAAAAAAADZBgEAAQAAAAAAAAAAAAAAsEwBAAIAAACvCwEAAQAAAMBMAQACAAAAAAAAAAAAAAA6CAEAAQAAAMhMAQABAAAAzEwBAAEAAAB6CgEAAQAAAAAAAAAAAAAA4EwBAAIAAAAgCQEAAQAAAPBMAQACAAAAAAAAAAAAAAC4CQEAAQAAAABNAQAOAAAAAAAAAAAAAADACQEAAQAAAAAAAAAAAAAAQE0BAAQAAAD2BQEAAQAAAGBNAQADAAAAAAAAAAAAAACxCQEAAQAAAAAAAAAAAAAAcE0BAAMAAAArDAEAAQAAAIhNAQABAAAAAAAAAAAAAAC4CwEAAQAAAIxNAQACAAAAAAAAAAAAAAAaDQEAAQAAAJRNAQABAAAAAAAAAAAAAADoEQEAAQAAAKBNAQAQAAAA4E0BAAkAAADwCAEAAQAAAChOAQACAAAAAAAAAAAAAAAoBwEAAQAAAAAAAAAAAAAAME4BAAEAAAA4BwEAAQAAAAAAAAAAAAAAQE4BAAIAAAAhDwEAAQAAAFBOAQACAAAAAAAAAAAAAABOCwEAAQAAAGBOAQANAAAAoE4BAAcAAACeDwEAAQAAAAAAAAAAAAAA4E4BAAIAAACJCAEAAQAAAPBOAQAEAAAAAAAAAAAAAAC4DAEAAQAAAABPAQADAAAAAAAAAAAAAABLBwEAAQAAAAAAAAAAAAAADE8BAAEAAAAcBgEAAQAAABRPAQABAAAAIE8BAAIAAABABgEAAQAAADBPAQBbAAAAoFABAFIAAACODgEAAQAAADBTAQADAAAAAAAAAAAAAACMAgEAAQAAADxTAQABAAAAAAAAAAAAAABACAEAAQAAAAAAAAAAAAAAQFMBAAQAAADBAQEAAQAAAAAAAAAAAAAAYFMBAAYAAADDDgEAAQAAAJBTAQAIAAAAAAAAAAAAAAAQAgEAAQAAAAAAAAAAAAAAsFMBAAEAAACRCQEAAQAAAMBTAQAEAAAAAAAAAAAAAACUAAEAAQAAAAAAAAAAAAAA0FMBAAgAAAB/DwEAAQAAAAAAAAAAAAAAEFQBAAEAAADQBgEAAQAAAAAAAAAAAAAAIFQBAAUAAABDAgEAAQAAAAAAAAAAAAAAUFQBAAIAAADzBgEAAQAAAAAAAAAAAAAAYFQBAAEAAADwDgEAAQAAAAAAAAAAAAAAaFQBAAEAAACpDgEAAQAAAHBUAQAgAAAAAAAAAAAAAAB3BwEAAQAAAPBUAQAKAAAAAAAAAAAAAACeDgEAAQAAABhVAQACAAAAIFUBAAUAAADiDgEAAQAAAAAAAAAAAAAASFUBAAEAAACtDwEAAQAAAAAAAAAAAAAAUFUBAA8AAAAaCQEAAQAAANBVAQAhAAAAYFYBAAMAAABpCQEAAQAAAIBWAQAOAAAAAAAAAAAAAAAICgEAAQAAAAAAAAAAAAAAwFYBAAYAAADsCQEAAQAAAPBWAQAQAAAAAAAAAAAAAADmBwEAAQAAADBXAQALAAAAYFcBAAgAAACyCAEAAQAAAKBXAQAOAAAAAAAAAAAAAABODwEAAQAAAAAAAAAAAAAA4FcBAAIAAADjBQEAAQAAAPBXAQABAAAAAAAAAAAAAAD7BgEAAQAAAAAAAAAAAAAAAFgBAAMAAACFAAEAAQAAACBYAQAJAAAAAAAAAAAAAACODwEAAQAAAERYAQACAAAAUFgBAAMAAAD4DgEAAQAAAAAAAAAAAAAAcFgBAAIAAABoDQEAAQAAAIBYAQAUAAAA0FgBAAgAAAA5CQEAAQAAAAAAAAAAAAAAEFkBAAIAAABgBwEAAQAAAAAAAAAAAAAAIFkBAAIAAADBCwEAAQAAADBZAQADAAAAAAAAAAAAAADaCQEAAQAAAAAAAAAAAAAAQFkBAAIAAADEDwEAAQAAAFBZAQANAAAAAAAAAAAAAACFDwEAAQAAAJBZAQAHAAAAsFkBAAIAAAA2CgEAAQAAAMBZAQACAAAAAAAAAAAAAADhCQEAAQAAAAAAAAAAAAAA0FkBAAgAAACcAQEAAQAAAAAAAAAAAAAAEFoBAAIAAADNBAEAAQAAACBaAQAEAAAAAAAAAAAAAADKCQEAAQAAAAAAAAAAAAAAMFoBAAIAAAAdCgEAAQAAAAAAAAAAAAAAQFoBAAIAAADjEQEAAQAAAFBaAQB8AQAAQGABAPIAAAAMBgEAAQAAANBnAQALAAAAAAAAAAAAAACYBgEAAQAAAABoAQAgAAAAAAAAAAAAAAC1DwEAAQAAAIBoAQADAAAAAAAAAAAAAACtAAEAAQAAAJBoAQAFAAAAAAAAAAAAAADzEQEAAQAAAAAAAAAAAAAAsGgBAAMAAADqEQEAAQAAAAAAAAAAAAAA0GgBAAcAAACPAAEAAQAAAAhpAQABAAAADGkBAAEAAAAKCQEAAQAAACBpAQBjAgAAsHIBACIAAACRCAEAAQAAAMBzAQA3AAAAoHQBAAYAAAAZBgEAAQAAANB0AQAiAQAAYHkBAMcAAAAoAgEAAQAAAKB/AQAKAAAAAAAAAAAAAAC/AAEAAQAAANB/AQBZAgAAQIkBACUAAACTBwEAAQAAAAAAAAAAAAAAaIoBAAEAAACABwEAAQAAAAAAAAAAAAAAcIoBAAIAAACMEQEAAQAAAICKAQC7AAAAcI0BAGcAAACoCQEAAQAAAAAAAAAAAAAAqJABAAEAAACwBQEAAQAAAAAAAAAAAAAAsJABAAEAAABoCAEAAQAAAMCQAQAHAAAAAAAAAAAAAAAJDwEAAQAAANyQAQACAAAAAAAAAAAAAADbBwEAAQAAAAAAAAAAAAAA8JABAAIAAADIBgEAAQAAAAAAAAAAAAAAAJEBAAMAAAD6CQEAAQAAAAAAAAAAAAAAIJEBAAcAAAAeDwEAAQAAAGCRAQBtAAAAIJMBAEIAAAD0DAEAAQAAADCVAQAFAAAAAAAAAAAAAACeBgEAAQAAAAAAAAAAAAAARJUBAAEAAAANCQEAAQAAAEyVAQADAAAAAAAAAAAAAABPCQEAAQAAAAAAAAAAAAAAYJUBAAIAAABpCwEAAQAAAAAAAAAAAAAAcJUBAAMAAABuAgEAAQAAAAAAAAAAAAAAiJUBAAEAAAAHBgEAAQAAAAAAAAAAAAAAkJUBAAMAAADqBwEAAQAAALCVAQDSAAAAAJkBAHUAAAD1CQEAAQAAAAAAAAAAAAAAsJwBAAIAAABWBwEAAQAAAMCcAQAGAAAA2JwBAAEAAADfBQEAAQAAAAAAAAAAAAAA4JwBAAMAAACgCQEAAQAAAAAAAAAAAAAAAJ0BAAUAAAC4BQEAAQAAACidAQADAAAAAAAAAAAAAACKEQEAAQAAAECdAQBDAAAAUJ4BAEIAAADRBwEAAQAAAAAAAAAAAAAAYKABAAIAAACFCQEAAQAAAAAAAAAAAAAAcKABAAMAAABSDgEAAQAAAJCgAQAlAAAAMKEBABgAAACNCwEAAQAAAPChAQAEAAAAAAAAAAAAAABnDwEAAQAAAAAAAAAAAAAAAKIBAAIAAADrBQEAAQAAABCiAQACAAAAAAAAAAAAAAAHCQEAAQAAACCiAQAHAAAAQKIBAAUAAAAWBgEAAQAAAHCiAQAdAAAA8KIBACoAAACgAAEAAQAAAAAAAAAAAAAAQKQBAAIAAACyCgEAAQAAAAAAAAAAAAAAUKQBAAQAAAByCAEAAQAAAHCkAQABAAAAAAAAAAAAAADRCQEAAQAAAHSkAQABAAAAAAAAAAAAAAAaBwEAAQAAAAAAAAAAAAAAgKQBAAMAAADMDgEAAQAAAAAAAAAAAAAAoKQBAAIAAAC3BwEAAQAAAAAAAAAAAAAAsKQBAAEAAAC4DgEAAQAAAAAAAAAAAAAAuKQBAAEAAAAOBwEAAQAAAAAAAAAAAAAAwKQBAAIAAACHBwEAAQAAAAAAAAAAAAAA0KQBAAEAAAClBwEAAQAAAAAAAAAAAAAA2KQBAAEAAADXDgEAAQAAAAAAAAAAAAAA4KQBAAEAAABIDwEAAQAAAPCkAQAOAAAAAAAAAAAAAACyDAEAAQAAAAAAAAAAAAAAMKUBAAIAAABADwEAAQAAAAAAAAAAAAAAQKUBAAIAAABREQEAAQAAAFClAQCEAAAAYKcBADUAAAClCgEAAQAAAAAAAAAAAAAAEKkBAAUAAAAhDAEAAQAAAAAAAAAAAAAAOKkBAAEAAACzAAEAAQAAAAAAAAAAAAAAQKkBAAEAAAAbDwEAAQAAAFCpAQAGAAAAAAAAAAAAAABPDgEAAQAAAHCpAQARAAAAtKkBAAEAAADxDAEAAQAAAMCpAQBIAAAAAAAAAAAAAABLCwEAAQAAAOCqAQAKAAAAAAAAAAAAAADMDwEAAQAAAAirAQABAAAAAAAAAAAAAACaBwEAAQAAAAAAAAAAAAAAEKsBAAIAAAAzCgEAAQAAACCrAQALAAAAAAAAAAAAAAATBgEAAQAAAFCrAQCBAAAAYK0BADQAAACJAgEAAQAAAACvAQBLAAAAAAAAAAAAAAApCQEAAQAAAAAAAAAAAAAAMLABAAMAAAAFCwEAAQAAAEiwAQACAAAAAAAAAAAAAACyDgEAAQAAAFCwAQACAAAAAAAAAAAAAABPEQEAAQAAAGCwAQCUAAAAsLIBAFEAAADhBgEAAQAAADi1AQACAAAAAAAAAAAAAAB0DwEAAQAAAEC1AQACAAAAAAAAAAAAAAAYDwEAAQAAAFC1AQASAAAAoLUBAAMAAAC8DwEAAQAAAAAAAAAAAAAAuLUBAAEAAAAGBwEAAQAAAAAAAAAAAAAAwLUBAAEAAAB4CAEAAQAAAAAAAAAAAAAA0LUBAAIAAADJCgEAAQAAAAAAAAAAAAAA4LUBAAMAAAClDwEAAQAAAAC2AQAMAAAAMLYBAAEAAAAmCQEAAQAAAEC2AQAdAAAAtLYBAAEAAACOCAEAAQAAAMC2AQA1AAAAoLcBAAsAAAAQBgEAAQAAAAC4AQBwAAAAwLkBAEYAAACLBwEAAQAAAAAAAAAAAAAA8LsBAAEAAAD4CgEAAQAAAAAAAAAAAAAAALwBAAIAAAD/BQEAAQAAAAAAAAAAAAAAELwBAAEAAADKCwEAAQAAABi8AQACAAAAAAAAAAAAAAB4CQEAAQAAACC8AQABAAAAAAAAAAAAAAARDwEAAQAAADC8AQAEAAAAAAAAAAAAAACdCgEAAQAAAEC8AQACAAAAAAAAAAAAAABeDwEAAQAAAEi8AQADAAAAAAAAAAAAAAD3DAEAAQAAAFS8AQACAAAAAAAAAAAAAACACAEAAQAAAGC8AQAFAAAAAAAAAAAAAAAYAgEAAQAAAHS8AQACAAAAAAAAAAAAAAByCQEAAQAAAAAAAAAAAAAAgLwBAAIAAADdCAEAAQAAAJC8AQAQAAAA0LwBAAIAAABYAQEAAQAAAAAAAAAAAAAA4LwBAAQAAACmAAEAAQAAAAC9AQAMAAAAAAAAAAAAAACXDwEAAQAAADC9AQABAAAAAAAAAAAAAAAnCgEAAQAAADS9AQACAAAAAAAAAAAAAADrBgEAAQAAAEC9AQAHAAAAAAAAAAAAAAA/CgEAAQAAAFy9AQADAAAAAAAAAAAAAABsDwEAAQAAAAAAAAAAAAAAcL0BAAIAAACVDgEAAQAAAAAAAAAAAAAAgL0BAAIAAAAsCgEAAQAAAJC9AQABAAAAAAAAAAAAAADvBQEAAQAAAAAAAAAAAAAAoL0BAAIAAABdCQEAAQAAAAAAAAAAAAAAsL0BAAIAAAAWCgEAAQAAAAAAAAAAAAAAwL0BAAMAAAAwCgEAAQAAANi9AQACAAAAAAAAAAAAAAAsEQEAAQAAAOC9AQAIAAAAAAAAAAAAAADUCwEAAQAAAAAAAAAAAAAAAL4BAAEAAAAECQEAAQAAAAi+AQABAAAAAAAAAAAAAADcBQEAAQAAAAy+AQABAAAAAAAAAAAAAACGAgEAAQAAABC+AQAHAAAAAAAAAAAAAADAAAAAAEHAoAcLgAUBAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOgsBAFjTAQABAAB+AQAAeAEAAGwFAAAAHwAAAA0AAADt//93NgAAAAEAAPYAABA7AQAAAAIAAAAEAAAACAAAABAAAAAgAAAAQAAAAIAAAAAAAQAAAAIAAAAEAAAACAAAABAAAAAgAAAAQAAAAIAAAAAAAQAAAAIAAAAEAAAACAAAABAAAAAgAAAAQAAAAIAAAAAAAQAAAAIAAAAEAAAACAAAABAAAAAgAAAAQAAAAIABAAAACgAAAGQAAADoAwAAECcAAKCGAQBAQg8AgJaYAADh9QUAypo7AgAAAA8AAAAQAAAAEQAAABIAAAABAAAAAQAAAA0AAQABAAAArNIBAAEAAACw0gEAAQAAAAAA//8AAAEA//8QADYAAAA3AAAAAEHApQcLwAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQYCnBwuJAXJlc3VsdAAJAQkACAAAAAYAAACA0wEALi9wb2xpY2llcy5yZWdvAGV4YW1wbGUvY2FuX2FjY2VzcwB2YXIgYXNzaWdubWVudCBjb25mbGljdABvYmplY3QgaW5zZXJ0IGNvbmZsaWN0AGludGVybmFsOiBpbGxlZ2FsIGVudHJ5cG9pbnQgaWQAAEGJqAcLJ3siZzAiOiB7ImV4YW1wbGUiOiB7ImNhbl9hY2Nlc3MiOiA3NH19fQBkCXByb2R1Y2VycwEMcHJvY2Vzc2VkLWJ5AQxVYnVudHUgY2xhbmc9MTMuMC4xLSsrMjAyMTEwMjMxMjUzMTQrNzNkYWViM2Q1MDdmLTF+ZXhwMX4yMDIxMTAyMzEyNTg1OC4xMw=="},"instances":1,"killOptions":{"immortal":false,"max_calls":2147483647,"max_memory_usage":0,"max_unused_duration":300000,"max_avg_call_duration":0},"memoryPages":100,"allowedHosts":["*"],"allowedPaths":{},"functionName":"execute","authorizations":{"httpAccess":true}}},"_type":"script"} \ No newline at end of file diff --git a/izanami-frontend/index.html b/izanami-frontend/index.html index e6c4ee7b4..02bff044e 100644 --- a/izanami-frontend/index.html +++ b/izanami-frontend/index.html @@ -6,20 +6,15 @@ Izanami @@ -33,9 +28,12 @@
+ diff --git a/izanami-frontend/init.js b/izanami-frontend/init.js deleted file mode 100644 index b28b62c96..000000000 --- a/izanami-frontend/init.js +++ /dev/null @@ -1,44 +0,0 @@ -//const pg = require("pg"); - -async function cleanDatabase() { - /*const { Client } = pg; - - const client = new Client({ - user: "postgres", - host: "localhost", - database: "postgres", - password: "postgres", - port: 5432, - }); - await client.connect(); - - try { - const res = await client.query("SELECT * FROM izanami.tenants"); - const tenants = res.rows.map((r) => r.name); - - tenants.forEach(async (tenant) => { - await client.query(`DROP SCHEMA "${tenant}" CASCADE`); - }); - - await client.query("TRUNCATE TABLE izanami.tenants CASCADE"); - - await client.query( - "DELETE FROM izanami.users WHERE username != 'RESERVED_ADMIN_USER'" - ); - await client.query("TRUNCATE TABLE izanami.users_tenants_rights CASCADE"); - } catch (err) { - if (err.code === "42P01") { - // Database is not initialized, nothing to do - } else { - throw err; - } - } - - await client.end();*/ - return Promise.resolve(); -} - -//init(); -module.exports = { - cleanDatabase, -}; diff --git a/izanami-frontend/package-lock.json b/izanami-frontend/package-lock.json index 204304051..428fdd3d5 100644 --- a/izanami-frontend/package-lock.json +++ b/izanami-frontend/package-lock.json @@ -9,6 +9,7 @@ "version": "0.0.0", "dependencies": { "@codemirror/lang-json": "^6.0.1", + "@fortawesome/fontawesome-free": "^6.6.0", "@hookform/error-message": "^2.0.1", "@maif/react-forms": "1.6.3", "@mui/material": "^5.13.6", @@ -16,7 +17,7 @@ "@textea/json-viewer": "^3.1.1", "@uiw/react-codemirror": "^4.22.1", "@xiechao/codemirror-lang-handlebars": "^1.0.4", - "bootstrap": "^5.0.0", + "bootstrap": "5.2.0", "bootstrap-icons": "^1.8.2", "classnames": "^2.3.0", "date-fns": "^2.28.0", @@ -2464,10 +2465,9 @@ "integrity": "sha512-J4yDIIthosAsRZ5CPYP/jQvUAQtlZTTD/4suA08/FEnlxqW3sKS9iAhgsa9VYLZ6vDHn/ixJgIqRQPotoBjxIw==" }, "node_modules/@fortawesome/fontawesome-free": { - "version": "5.15.4", - "resolved": "https://registry.npmjs.org/@fortawesome/fontawesome-free/-/fontawesome-free-5.15.4.tgz", - "integrity": "sha512-eYm8vijH/hpzr/6/1CJ/V/Eb1xQFW2nnUKArb3z+yUWv7HTwj6M7SP957oMjfZjAHU6qpoNc2wQvIxBLWYa/Jg==", - "hasInstallScript": true, + "version": "6.6.0", + "resolved": "https://registry.npmjs.org/@fortawesome/fontawesome-free/-/fontawesome-free-6.6.0.tgz", + "integrity": "sha512-60G28ke/sXdtS9KZCpZSHHkCbdsOGEhIUGlwq6yhY74UpTiToIh8np7A8yphhM4BWsvNFtIvLpi4co+h9Mr9Ow==", "engines": { "node": ">=6" } @@ -2905,6 +2905,15 @@ "w3c-keyname": "^2.2.4" } }, + "node_modules/@maif/react-forms/node_modules/@fortawesome/fontawesome-free": { + "version": "5.15.4", + "resolved": "https://registry.npmjs.org/@fortawesome/fontawesome-free/-/fontawesome-free-5.15.4.tgz", + "integrity": "sha512-eYm8vijH/hpzr/6/1CJ/V/Eb1xQFW2nnUKArb3z+yUWv7HTwj6M7SP957oMjfZjAHU6qpoNc2wQvIxBLWYa/Jg==", + "hasInstallScript": true, + "engines": { + "node": ">=6" + } + }, "node_modules/@maif/react-forms/node_modules/@lezer/common": { "version": "0.15.12", "resolved": "https://registry.npmjs.org/@lezer/common/-/common-0.15.12.tgz", @@ -5030,9 +5039,9 @@ } }, "node_modules/bootstrap": { - "version": "5.3.3", - "resolved": "https://registry.npmjs.org/bootstrap/-/bootstrap-5.3.3.tgz", - "integrity": "sha512-8HLCdWgyoMguSO9o+aH+iuZ+aht+mzW0u3HIMzVu7Srrpv7EBBxTnrFlSCskwdY1+EOFQSm7uMJhNQHkdPcmjg==", + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/bootstrap/-/bootstrap-5.2.0.tgz", + "integrity": "sha512-qlnS9GL6YZE6Wnef46GxGv1UpGGzAwO0aPL1yOjzDIJpeApeMvqV24iL+pjr2kU4dduoBA9fINKWKgMToobx9A==", "funding": [ { "type": "github", @@ -5044,7 +5053,7 @@ } ], "peerDependencies": { - "@popperjs/core": "^2.11.8" + "@popperjs/core": "^2.11.5" } }, "node_modules/bootstrap-icons": { diff --git a/izanami-frontend/package.json b/izanami-frontend/package.json index 119b817ae..31bae5efa 100644 --- a/izanami-frontend/package.json +++ b/izanami-frontend/package.json @@ -11,6 +11,7 @@ }, "dependencies": { "@codemirror/lang-json": "^6.0.1", + "@fortawesome/fontawesome-free": "^6.6.0", "@hookform/error-message": "^2.0.1", "@maif/react-forms": "1.6.3", "@mui/material": "^5.13.6", @@ -18,7 +19,7 @@ "@textea/json-viewer": "^3.1.1", "@uiw/react-codemirror": "^4.22.1", "@xiechao/codemirror-lang-handlebars": "^1.0.4", - "bootstrap": "^5.0.0", + "bootstrap": "5.2.0", "bootstrap-icons": "^1.8.2", "classnames": "^2.3.0", "date-fns": "^2.28.0", diff --git a/izanami-frontend/playwright.config.ts b/izanami-frontend/playwright.config.ts index 393d478a2..b89a14957 100644 --- a/izanami-frontend/playwright.config.ts +++ b/izanami-frontend/playwright.config.ts @@ -13,8 +13,8 @@ export const STORAGE_STATE = path.join(__dirname, "playwright/.auth/user.json"); * See https://playwright.dev/docs/test-configuration. */ export default defineConfig({ - timeout: 120_000, - expect: { timeout: 10_000 }, + timeout: 180_000, + expect: { timeout: 12_000 }, testDir: "./tests", /* Run tests in files in parallel */ fullyParallel: true, @@ -47,7 +47,7 @@ export default defineConfig({ name: "chromium", dependencies: ["setup"], use: { ...devices["Desktop Chrome"], storageState: STORAGE_STATE }, - fullyParallel: true, + fullyParallel: false, }, /*{ diff --git a/izanami-frontend/src/App.tsx b/izanami-frontend/src/App.tsx index f0a67c080..48491131a 100644 --- a/izanami-frontend/src/App.tsx +++ b/izanami-frontend/src/App.tsx @@ -98,10 +98,12 @@ function redirectToLoginIfNotAuthenticated({ let mode = ""; function setupLightMode() { - mode = window.localStorage.getItem("izanami-dark-light-mode"); - if (!mode) { + const maybeMode = window.localStorage.getItem("izanami-dark-light-mode"); + if (!maybeMode) { mode = "dark"; window.localStorage.setItem("izanami-dark-light-mode", mode); + } else { + mode = maybeMode; } applyLightMode(); } diff --git a/izanami-frontend/src/components/FeatureTable.tsx b/izanami-frontend/src/components/FeatureTable.tsx index f9cbb55af..39ed1366a 100644 --- a/izanami-frontend/src/components/FeatureTable.tsx +++ b/izanami-frontend/src/components/FeatureTable.tsx @@ -1471,6 +1471,9 @@ export function FeatureTable(props: { ); diff --git a/izanami-frontend/src/components/ObjectInput.tsx b/izanami-frontend/src/components/ObjectInput.tsx new file mode 100644 index 000000000..bf418b222 --- /dev/null +++ b/izanami-frontend/src/components/ObjectInput.tsx @@ -0,0 +1,104 @@ +import * as React from "react"; + +export function ObjectInput(props: { + value: { name: string; value: string }[]; + onChange: (newValue: { name: string; value: string }[]) => void; + params?: { + nameLabel?: string; + valueLabel?: string; + addLabel?: string; + smallerFirstCol?: boolean; + }; +}) { + const arr = props.value; + + const { + nameLabel = "Header name", + valueLabel = "Header value", + addLabel = "Add header", + smallerFirstCol = true, + } = props.params || {}; + return ( +
+ {arr.length > 0 && ( +
+ + +
+ )} + {arr.map(({ name, value }, index) => ( +
+
+ { + const v = e.target.value; + props.onChange([ + ...arr + .slice(0, index) + .concat([{ name: v, value }]) + .concat(arr.slice(index + 1)), + ]); + }} + /> +
+
+ { + const v = e.target.value; + props.onChange([ + ...arr + .slice(0, index) + .concat([{ name, value: v }]) + .concat(arr.slice(index + 1)), + ]); + }} + /> +
+
+ +
+
+ ))} +
+
+
+ +
+
+
+ ); +} diff --git a/izanami-frontend/src/pages/tenantSettings.tsx b/izanami-frontend/src/pages/tenantSettings.tsx index 24ad4418d..066de0fe7 100644 --- a/izanami-frontend/src/pages/tenantSettings.tsx +++ b/izanami-frontend/src/pages/tenantSettings.tsx @@ -6,22 +6,31 @@ import { useNavigate, useParams } from "react-router-dom"; import { GenericTable } from "../components/GenericTable"; import queryClient from "../queryClient"; import { IzanamiContext, useTenantRight } from "../securityContext"; +import CodeMirror from "@uiw/react-codemirror"; import Select from "react-select"; import { deleteTenant, + fetchWebhooks, + importData, importIzanamiV1Data, inviteUsersToTenant, MutationNames, pollForImportResult, + queryKeys, queryTenant, queryTenantUsers, + requestExport, + tenantKeyQueryKey, tenantQueryKey, tenantUserQueryKey, updateTenant, updateUserRightsForTenant, userQueryKeyForTenant, + webhookQueryKey, } from "../utils/queries"; import { + ImportRequest, + IzanamiTenantExportRequest, IzanamiV1ImportRequest, TenantType, TLevel, @@ -36,11 +45,14 @@ import { Tooltip } from "../components/Tooltip"; import { customStyles } from "../styles/reactSelect"; import { DEFAULT_TIMEZONE, TimeZoneSelect } from "../components/TimeZoneSelect"; import { Loader } from "../components/Loader"; +import { ObjectInput } from "../components/ObjectInput"; export function TenantSettings(props: { tenant: string }) { const { tenant } = props; const [inviting, setInviting] = React.useState(false); const [v1ImportDisplayed, setV1ImportDisplayed] = React.useState(false); + const [exportDisplayed, setExportDisplayed] = React.useState(false); + const [importDisplayed, setImportDisplayed] = React.useState(false); const tenantQuery = useQuery(tenantQueryKey(tenant), () => queryTenant(tenant) @@ -65,6 +77,7 @@ export function TenantSettings(props: { tenant: string }) { ); const { askConfirmation } = React.useContext(IzanamiContext); + const formTitleRef = React.useRef(null); const navigate = useNavigate(); const [modification, setModification] = React.useState(false); @@ -105,63 +118,52 @@ export function TenantSettings(props: { tenant: string }) { )}
-

Danger zone

-
-
- Update the description of the tenant +

Update tenant information

+
+ Update description for this tenant - -
- - {modification && ( - setModification(false)} - /> - )} -
-
- Delete this tenant - -
+
-
-

Import data from V1

- {!v1ImportDisplayed ? ( + + {modification && ( + setModification(false)} + /> + )} + +
+ Delete this tenant - ) : ( +
+
+

Export / import data

+ {v1ImportDisplayed ? ( <> +

Import data from Izanami v1 instance

setV1ImportDisplayed(false)} submit={(data) => { @@ -215,6 +217,88 @@ export function TenantSettings(props: { tenant: string }) { }} /> + ) : exportDisplayed ? ( +
+ setExportDisplayed(false)} + submit={(request: IzanamiTenantExportRequest) => + requestExport(tenant, request).then(() => + setExportDisplayed(false) + ) + } + /> +
+ ) : importDisplayed ? ( +
+ setImportDisplayed(false)} + submit={(request) => { + return importData(tenant, request).then((importRes) => { + if (importRes) { + askConfirmation( + + ); + } else { + setImportDisplayed(false); + } + }); + }} + /> +
+ ) : ( + <> +
+ Import data from V1 Izanami instance + + +
+
+ Import data from another Izanami instance + +
+
+ Export data to transfer them to another instance + +
+ )} ); @@ -223,6 +307,155 @@ export function TenantSettings(props: { tenant: string }) { } } +function ImportError(props: { + conflictStrategy: ConflictStrategy; + failedElements: object[]; +}) { + const { conflictStrategy, failedElements } = props; + let explanation; + if (conflictStrategy === "fail") { + explanation = ( +

+ Some element couldn't be imported. +
+ Since you chose "Fail on conflict" import strategy, nothing has been + imported. +
First problematic row is displayed below, see Izanami's log for + details. +

+ ); + } else { + explanation = ( +

+ Some element couldn't be imported. +
+ Problematic rows are listed below, failure may be caused by either a non + solvable conflict or a technical error. +
+ See application logs for details. +
+ Non listed rows were imported correctly. +

+ ); + } + return ( +
+

Import failed !

+ {explanation} + JSON.stringify(obj)).join("\n")} + height="300px" + readOnly={true} + theme="dark" + /> +
+ ); +} + +function ImportForm(props: { + cancel: () => void; + submit: (request: ImportRequest) => Promise; +}) { + const { cancel, submit } = props; + + const methods = useForm({ + defaultValues: {}, + }); + const { + handleSubmit, + register, + control, + formState: { isSubmitting }, + } = methods; + + return ( + +
submit(data))} + > +

Import data

+ +
+
+ + {isSubmitting ? ( +
+ Loading... +
+ ) : ( + <> + + + )} +
+
+ + ); +} + function TenantUsers(props: { tenant: string }) { const { tenant } = props; const userQuery = useQuery(tenantUserQueryKey(tenant), () => @@ -384,6 +617,278 @@ const CONFLICT_STRATEGIES_OPTIONS = [ { label: "fail", value: "fail" }, ]; +type ConflictStrategy = "skip" | "overwrite" | "fail"; + +function ExportForm(props: { + cancel: () => void; + submit: (request: IzanamiTenantExportRequest) => Promise; +}) { + const { tenant } = useParams(); + const { cancel, submit } = props; + const methods = useForm({ + defaultValues: { + allProjects: true, + allKeys: true, + allWebhooks: true, + userRights: false, + webhooks: [], + projects: [], + keys: [], + }, + }); + + const { + handleSubmit, + register, + getValues, + watch, + formState: { isSubmitting }, + control, + } = methods; + + watch(["allProjects", "allKeys", "allWebhooks"]); + + const projectQuery = useQuery( + tenantQueryKey(tenant!), + () => queryTenant(tenant!), + { enabled: !getValues("allProjects") } + ); + + const keyQuery = useQuery( + tenantKeyQueryKey(tenant!), + () => queryKeys(tenant!), + { enabled: !getValues("allKeys") } + ); + + const webhookQuery = useQuery( + webhookQueryKey(tenant!), + () => fetchWebhooks(tenant!), + { enabled: !getValues("allWebhooks") } + ); + + return ( + <> + +
submit(data))} + className="sub_container d-flex flex-column" + style={{ + paddingLeft: "12px", + }} + > +

Export data

+ + {!getValues("allProjects") && + (projectQuery.isSuccess ? ( + + {!getValues("allKeys") && + (keyQuery.isSuccess ? ( + + {!getValues("allWebhooks") && + (webhookQuery.isSuccess ? ( + +
+
+ + {isSubmitting ? ( +
+ Loading... +
+ ) : ( + <> + + + )} +
+
+ + + ); +} + function IzanamiV1ImportForm(props: { cancel: () => void; submit: (request: IzanamiV1ImportRequest) => Promise; diff --git a/izanami-frontend/src/pages/webhooks.tsx b/izanami-frontend/src/pages/webhooks.tsx index 214c22442..88deec3a9 100644 --- a/izanami-frontend/src/pages/webhooks.tsx +++ b/izanami-frontend/src/pages/webhooks.tsx @@ -36,6 +36,7 @@ import { InvitationForm } from "../components/InvitationForm"; import { WebhookTransformationEditor } from "../components/Editor"; import Handlebars from "handlebars"; import { Row } from "@tanstack/react-table"; +import { ObjectInput } from "../components/ObjectInput"; export function WebHooks(props: { tenant: string }) { const [searchParams] = useSearchParams(); @@ -491,7 +492,7 @@ function WebHookCreationForm(props: { array: true, render: ({ value, onChange }) => { return ( - { onChange?.(newArray); @@ -715,82 +716,3 @@ function WebHookCreationForm(props: { return ; } } - -function Headers(props: { - value: { name: string; value: string }[]; - onChange: (newValue: { name: string; value: string }[]) => void; -}) { - const arr = props.value; - return ( -
- {arr.length > 0 && ( -
- - -
- )} - {arr.map(({ name, value }, index) => ( -
-
- { - const v = e.target.value; - props.onChange([ - ...arr - .slice(0, index) - .concat([{ name: v, value }]) - .concat(arr.slice(index + 1)), - ]); - }} - /> -
-
- { - const v = e.target.value; - props.onChange([ - ...arr - .slice(0, index) - .concat([{ name, value: v }]) - .concat(arr.slice(index + 1)), - ]); - }} - /> -
-
- -
-
- ))} -
-
- -
-
-
- ); -} diff --git a/izanami-frontend/src/utils/queries.tsx b/izanami-frontend/src/utils/queries.tsx index 5cd017f61..6b44cf17b 100644 --- a/izanami-frontend/src/utils/queries.tsx +++ b/izanami-frontend/src/utils/queries.tsx @@ -1,7 +1,9 @@ import { format } from "date-fns"; import { Configuration, + ImportRequest, isLightWasmFeature, + IzanamiTenantExportRequest, IzanamiV1ImportRequest, LightWebhook, Mailer, @@ -107,6 +109,49 @@ export function webhookUserQueryKey(tenant: string, webhook: string) { return `USERS-${tenant}-${webhook}`; } +export function importData( + tenant: string, + importRequest: ImportRequest +): Promise { + const data = new FormData(); + data.append("export", importRequest.file.item(0)!); + return fetch( + `/api/admin/tenants/${tenant}/_import?version=2&conflict=${importRequest.conflictStrategy}`, + { + method: "POST", + body: data, + } + ).then((resp) => { + if (resp.status >= 400) { + return resp.json(); + } else { + return null; + } + }); +} + +export function requestExport( + tenant: string, + exportRequest: IzanamiTenantExportRequest +) { + return fetch(`/api/admin/tenants/${tenant}/_export`, { + method: "POST", + headers: { + "content-type": "application/json", + }, + body: JSON.stringify(exportRequest), + }) + .then((resp) => resp.blob()) + .then((blob) => { + const objectUrl = URL.createObjectURL(blob); + const link: HTMLAnchorElement = document.createElement("a"); + link.href = objectUrl; + link.download = "export.ndjson"; // the default filename when the user saves the file + link.click(); + URL.revokeObjectURL(objectUrl); + }); +} + export function queryTenantUsers(tenant: string): Promise< { username: string; @@ -970,7 +1015,7 @@ export function handleFetchJsonResponse( return _handleFetchResponse(request, (response) => response.json()); } -function handleFetchWithoutResponse( +export function handleFetchWithoutResponse( request: Promise ): Promise { return _handleFetchResponse(request, () => Promise.resolve(undefined)); diff --git a/izanami-frontend/src/utils/types.ts b/izanami-frontend/src/utils/types.ts index 91df6c667..b1b5c3ecc 100644 --- a/izanami-frontend/src/utils/types.ts +++ b/izanami-frontend/src/utils/types.ts @@ -481,6 +481,21 @@ export interface Webhook { global: boolean; } +export type IzanamiTenantExportRequest = { + allProjects: boolean; + allKeys: boolean; + allWebhooks: boolean; + projects?: string[]; + keys?: string[]; + webhooks?: string[]; + userRights: boolean; +}; + +export type ImportRequest = { + file: FileList; + conflictStrategy: string; +}; + export interface LightWebhook { name: string; description: string; diff --git a/izanami-frontend/tests/features.spec.ts b/izanami-frontend/tests/features.spec.ts index 216f36d81..aa926e00b 100644 --- a/izanami-frontend/tests/features.spec.ts +++ b/izanami-frontend/tests/features.spec.ts @@ -12,8 +12,21 @@ test.use({ }); async function featureAction(page: Page, name: string) { - await page.getByLabel("actions").click(); - await page.getByRole("link", { name: name }).click({ force: true }); + const dropdownLocator = page.getByLabel("actions"); + const locator = page.getByRole("link", { name: name, exact: true }); + + await dropdownLocator.click(); + try { + await locator.waitFor(); + } catch { + try { + await dropdownLocator.click(); + await locator.waitFor(); + } catch { + await dropdownLocator.click(); + } + } + await locator.click({ force: true }); } test.describe("Project screen should", () => { diff --git a/izanami-frontend/tests/import-export.spec.ts b/izanami-frontend/tests/import-export.spec.ts new file mode 100644 index 000000000..07ec0acf6 --- /dev/null +++ b/izanami-frontend/tests/import-export.spec.ts @@ -0,0 +1,95 @@ +import test, { expect } from "@playwright/test"; +import { + TestSituationBuilder, + testFeature, + testGlobalContext, + testKey, + testLocalContext, + testOverload, + testTag, + testTenant, + testproject, +} from "./testBuilder"; +import { tenantFromTitleAndBrowser } from "./izanami-test"; + +test.describe("Export / import should", () => { + test("allow to export then import data", async ({ page, browser }, { + title, + }) => { + const tenantName = await tenantFromTitleAndBrowser(title, browser); + const emptyTenantName = `${tenantName}-empty-tenant`; + await TestSituationBuilder.newBuilder() + .withTenant( + testTenant(tenantName) + .withProject( + testproject("testproject") + .withFeature( + testFeature("f1").withOverload( + testOverload("testcontext", true) + ) + ) + .withContext( + testLocalContext("testcontext").withSubContext( + testLocalContext("localsubcontext") + ) + ) + ) + .withTag(testTag("my-tag")) + .withKey(testKey({ name: "my-key" })) + .withContext( + testGlobalContext("global-context").withSubContext( + testGlobalContext("subcontext") + ) + ) + ) + .withTenant(testTenant(emptyTenantName)) + .build(page); + + await page.goto(`/tenants/${tenantName}/settings`); + await page.getByRole("button", { name: "Export data" }).click(); + const downloadPromise = page.waitForEvent("download"); + + await page.getByRole("button", { name: "Export" }).click(); + const download = await downloadPromise; + // Wait for the download process to complete and save the downloaded file somewhere. + const filepath = "/tmp/" + download.suggestedFilename(); + await download.saveAs(filepath); + await page.goto(`/tenants/${emptyTenantName}/settings`); + await page.getByRole("button", { name: "Import data" }).click(); + await page.getByLabel("Exported file (ndjson)").setInputFiles(filepath); + await page.getByRole("button", { name: "Import" }).click(); + await expect(page.getByLabel("Exported file (ndjson)")).not.toBeVisible(); + + await page.getByRole("link", { name: "Projects" }).click(); + await expect(page.getByRole("link", { name: "testproject" })).toBeVisible(); + await page.getByRole("link", { name: "testproject" }).click(); + + await expect(page.getByRole("rowheader", { name: "f1" })).toBeVisible(); + + await expect(page.getByLabel("1 Overload")).toHaveText("1"); + await page.getByLabel("1 Overload").click(); + + await page.getByRole("rowheader", { name: "testcontext" }).click(); + await page.getByRole("link", { name: "Contexts", exact: true }).click(); + await page.getByRole("link", { name: "testcontext" }).click(); + await expect( + page.getByRole("link", { name: "localsubcontext" }) + ).toBeVisible(); + + await page.getByRole("link", { name: "Tags" }).click(); + await expect(page.getByRole("rowheader", { name: "my-tag" })).toBeVisible(); + + await page.getByRole("link", { name: "Keys" }).click(); + await expect(page.getByRole("rowheader", { name: "my-key" })).toBeVisible(); + + await page.goto(`/tenants/${emptyTenantName}/settings`); + await page.getByRole("button", { name: "Import data" }).click(); + await page.getByLabel("Exported file (ndjson)").setInputFiles(filepath); + await page.getByRole("combobox", { name: "On conflict" }).click(); + await page.getByText("Fail").click(); + await page.getByRole("button", { name: "Import" }).click(); + await expect( + page.getByRole("heading", { name: "Import failed !" }) + ).toBeVisible(); + }); +}); diff --git a/izanami-frontend/tests/izanami-test.ts b/izanami-frontend/tests/izanami-test.ts index 51041e195..fe7d9d227 100644 --- a/izanami-frontend/tests/izanami-test.ts +++ b/izanami-frontend/tests/izanami-test.ts @@ -1,6 +1,6 @@ import { test as base } from "@playwright/test"; -async function tenantFromTitleAndBrowser(title, browser) { +export async function tenantFromTitleAndBrowser(title, browser) { const browserName = (await browser.browserType()).name(); const neutralizedTitle = title.replaceAll(" ", "-").replaceAll(",", "-"); return `${browserName}-${neutralizedTitle}`; diff --git a/izanami-frontend/tests/screenshots/export-import-v2.ts b/izanami-frontend/tests/screenshots/export-import-v2.ts new file mode 100644 index 000000000..106e23591 --- /dev/null +++ b/izanami-frontend/tests/screenshots/export-import-v2.ts @@ -0,0 +1,69 @@ +import { + testBuilder, + testFeature, + testGlobalContext, + testKey, + testOverload, + testproject, + testTenant, +} from "../testBuilder"; +import { screenshotBuilder, setup } from "./utils"; + +export async function generate() { + const { page, browser } = await setup(true); + const screenshot = screenshotBuilder("export-import-v2")(page); + + await testBuilder() + .withTenant( + testTenant("bookstore") + .withContext(testGlobalContext("prod")) + .withProject( + testproject("webstore") + .withFeature( + testFeature("comments") + .withEnableStatus() + .withOverload(testOverload("prod", false)) + ) + .withFeature(testFeature("phone-support").withDisableStatus()) + ) + .withKey(testKey({ name: "adminkey", admin: true })) + ) + .withTenant(testTenant("target-bookstore")) + .build(page); + await page.goto("http://localhost:3000/tenants/bookstore/settings"); + const exportFormButtonLocator = page.getByRole("button", { + name: "Export data", + }); + await exportFormButtonLocator.focus(); + await screenshot("export-button-hover"); + await exportFormButtonLocator.click(); + + await screenshot("export-form"); + await page.getByRole("button", { name: "Export" }).click(); + + const downloadPromise = page.waitForEvent("download"); + const download = await downloadPromise; + // Wait for the download process to complete and save the downloaded file somewhere. + const filepath = "/tmp/" + download.suggestedFilename(); + await download.saveAs(filepath); + + await page.goto(`http://localhost:3000/tenants/target-bookstore/settings`); + + const importLocator = page.getByRole("button", { name: "Import data" }); + await importLocator.focus(); + await screenshot("import-button-hover"); + await importLocator.click(); + await screenshot("import-form"); + await page.getByLabel("Exported file (ndjson)").setInputFiles(filepath); + await page.getByRole("button", { name: "Import" }).click(); + await page.getByLabel("Exported file (ndjson)").waitFor({ + state: "hidden", + }); + + await page.goto(`http://localhost:3000/tenants/target-bookstore`); + await screenshot("imported-project"); + + await browser.close(); +} + +generate(); diff --git a/izanami-frontend/tests/screenshots/import-v1.ts b/izanami-frontend/tests/screenshots/import-v1.ts index 371de8da1..abdcb36bf 100644 --- a/izanami-frontend/tests/screenshots/import-v1.ts +++ b/izanami-frontend/tests/screenshots/import-v1.ts @@ -1,10 +1,5 @@ import { openActions, screenshotBuilder, setup } from "./utils"; -import { - testBuilder, - testFeature, - testTenant, - testproject, -} from "../testBuilder"; +import { testBuilder, testTenant } from "../testBuilder"; export async function generate() { const { page, browser } = await setup(true); diff --git a/izanami-frontend/tests/testBuilder.ts b/izanami-frontend/tests/testBuilder.ts index 91b18b759..a197c8b1c 100644 --- a/izanami-frontend/tests/testBuilder.ts +++ b/izanami-frontend/tests/testBuilder.ts @@ -1,5 +1,8 @@ -import { Page } from "@playwright/test"; -import { handleFetchJsonResponse } from "../src/utils/queries"; +import { Cookie, Page } from "@playwright/test"; +import { + handleFetchJsonResponse, + handleFetchWithoutResponse, +} from "../src/utils/queries"; type featureIdByName = [string, string]; @@ -14,6 +17,43 @@ export class TestSituationBuilder { return this; } + async buildLocalContextHierarchy( + page: Page, + tenant: TestTenant, + project: TestProject, + context: TestLocalContext, + parent = "" + ): Promise { + const cookie = await this.cookie(page); + await handleFetchJsonResponse( + fetch( + `http://localhost:9000/api/admin/tenants/${tenant.name}/projects/${ + project.name + }/contexts${parent.length > 0 ? `/${parent}` : ""}`, + { + method: "POST", + body: JSON.stringify({ name: context.name }), + headers: { + "Content-Type": "application/json", + cookie: cookie, + }, + } + ) + ).catch((err) => console.error("Failed to create context", err)); + + Promise.all( + context.subcontexts.map((c) => + this.buildLocalContextHierarchy( + page, + tenant, + project, + c, + `${parent}/${context.name}` + ) + ) + ); + } + async buildContextHierarchy( page: Page, tenant: TestTenant, @@ -49,95 +89,191 @@ export class TestSituationBuilder { return `${cookies[0].name}=${cookies[0].value}`; } + async createTenant(tenant: TestTenant, cookie: Cookie): Promise { + return handleFetchJsonResponse( + fetch(`http://localhost:9000/api/admin/tenants`, { + method: "POST", + headers: { + "Content-Type": "application/json", + cookie: `${cookie.name}=${cookie.value}`, + }, + body: JSON.stringify(tenant), + }) + ); + } + + async createTag( + tenant: TestTenant, + tag: TestTag, + cookie: Cookie + ): Promise { + return handleFetchJsonResponse( + fetch(`http://localhost:9000/api/admin/tenants/${tenant.name}/tags`, { + method: "POST", + body: JSON.stringify(tag), + headers: { + "Content-Type": "application/json", + cookie: `${cookie.name}=${cookie.value}`, + }, + }) + ); + } + + async createProject( + tenant: TestTenant, + project: TestProject, + cookie: Cookie + ): Promise { + return handleFetchJsonResponse( + fetch(`http://localhost:9000/api/admin/tenants/${tenant.name}/projects`, { + method: "POST", + headers: { + "Content-Type": "application/json", + cookie: `${cookie.name}=${cookie.value}`, + }, + body: JSON.stringify(project), + }) + ); + } + + async createFeature( + tenant: TestTenant, + project: TestProject, + feature: TestFeature, + cookie: Cookie + ): Promise { + return handleFetchJsonResponse( + fetch( + `http://localhost:9000/api/admin/tenants/${tenant.name}/projects/${project.name}/features`, + { + method: "POST", + body: JSON.stringify(feature), + headers: { + "Content-Type": "application/json", + cookie: `${cookie.name}=${cookie.value}`, + }, + } + ) + ); + } + + async createKey( + tenant: TestTenant, + key: TestKey, + cookie: Cookie + ): Promise { + return handleFetchJsonResponse( + fetch(`http://localhost:9000/api/admin/tenants/${tenant.name}/keys`, { + method: "POST", + body: JSON.stringify(key), + headers: { + "Content-Type": "application/json", + cookie: `${cookie.name}=${cookie.value}`, + }, + }) + ); + } + + async createWebhook( + tenant: TestTenant, + webhook: TestWebhook, + cookie: Cookie + ): Promise { + return handleFetchJsonResponse( + fetch(`http://localhost:9000/api/admin/tenants/${tenant.name}/webhooks`, { + method: "POST", + body: JSON.stringify(webhook), + headers: { + "Content-Type": "application/json", + cookie: `${cookie.name}=${cookie.value}`, + }, + }) + ); + } + + async createOverload( + tenant: TestTenant, + project: TestProject, + feature: TestFeature, + overload: TestOverload, + cookie: Cookie + ): Promise { + const { contextPath, ...rest } = overload; + + return handleFetchWithoutResponse( + fetch( + `http://localhost:9000/api/admin/tenants/${tenant.name}/projects/${ + project.name + }/contexts${contextPath ? `/${contextPath}` : ""}/features/${ + feature.name + }`, + { + method: "PUT", + body: JSON.stringify(rest), + headers: { + "Content-Type": "application/json", + cookie: `${cookie.name}=${cookie.value}`, + }, + } + ) + ); + } + async build(page: Page): Promise { - const cookies = await page.context().cookies(); + const cookie = (await page.context().cookies())[0]; return Promise.all( this.tenants.map((t) => - handleFetchJsonResponse( - fetch(`http://localhost:9000/api/admin/tenants`, { - method: "POST", - headers: { - "Content-Type": "application/json", - cookie: `${cookies[0].name}=${cookies[0].value}`, - }, - body: JSON.stringify(t), + this.createTenant(t, cookie) + .then(() => { + Promise.all( + t.contexts.map((c) => { + return this.buildContextHierarchy(page, t, c); + }) + ); }) - ) - .then((tenantResult) => { + .then(() => { return Promise.all( - this.tenants.flatMap((t) => - t.contexts.map((c) => { - this.buildContextHierarchy(page, t, c); - /*handleFetchJsonResponse( - fetch( - `http://localhost:9000/api/admin/tenants/${t.name}/contexts`, - { - method: "POST", - body: JSON.stringify({ name: c.name }), - headers: { - "Content-Type": "application/json", - cookie: `${cookies[0].name}=${cookies[0].value}`, - }, - } - ) - ).catch((err) => - console.error("Failed to create context", err) - );*/ - }) + t.webhooks.map((webhook) => + this.createWebhook(t, webhook, cookie) ) ); }) - .then((foo) => { - t.webhooks.map((webhook) => { - handleFetchJsonResponse( - fetch( - `http://localhost:9000/api/admin/tenants/${t.name}/webhooks`, - { - method: "POST", - body: JSON.stringify(webhook), - headers: { - "Content-Type": "application/json", - cookie: `${cookies[0].name}=${cookies[0].value}`, - }, - } - ) - ); - }); + .then(() => + Promise.all(t.tags.map((tag) => this.createTag(t, tag, cookie))) + ) + .then(() => { + return Promise.all( + t.keys.map((key) => this.createKey(t, key, cookie)) + ); }) - .then((contextResult) => + .then(() => Promise.all( t.projects.map((p) => - handleFetchJsonResponse( - fetch( - `http://localhost:9000/api/admin/tenants/${t.name}/projects`, - { - method: "POST", - headers: { - "Content-Type": "application/json", - cookie: `${cookies[0].name}=${cookies[0].value}`, - }, - body: JSON.stringify(p), - } + this.createProject(t, p, cookie) + .then(() => + Promise.all( + p.contexts.map((c) => + this.buildLocalContextHierarchy(page, t, p, c) + ) + ) ) - ).then((projectResult) => - Promise.all( - p.features.map((f) => - handleFetchJsonResponse( - fetch( - `http://localhost:9000/api/admin/tenants/${t.name}/projects/${p.name}/features`, - { - method: "POST", - body: JSON.stringify(f), - headers: { - "Content-Type": "application/json", - cookie: `${cookies[0].name}=${cookies[0].value}`, - }, - } - ) - ).then(({ id, name }) => [name, id!] as featureIdByName) + .then(() => + Promise.all( + p.features.map((f) => + this.createFeature(t, p, f, cookie) + .then( + ({ id, name }) => [name, id!] as featureIdByName + ) + .then((featureIds) => { + return Promise.all( + f.overloads.map((o) => + this.createOverload(t, p, f, o, cookie) + ) + ).then(() => featureIds); + }) + ) ) ) - ) ) ) ) @@ -188,16 +324,68 @@ export function testLocalContext(name: string): TestLocalContext { return new TestLocalContext(name); } +export function testTag(name: string, description?: string): TestTag { + return new TestTag(name, description); +} + +export function testKey(data: Partial & { name: string }): TestKey { + return new TestKey(data); +} + +export function testOverload( + contextPath: string, + enabled = false +): TestOverload { + return new TestOverload(contextPath, enabled); +} + +class TestTag { + name: string; + description?: string; + + constructor(name: string, description: string = "") { + this.name = name; + this.description = description; + } +} + +class TestKey { + name: string; + description?: string; + enabled: boolean; + admin: boolean; + projects?: string[]; + constructor(data: Partial & { name: string }) { + this.name = data.name; + this.description = data.description || ""; + this.enabled = data.enabled || true; + this.admin = data.admin || false; + this.projects = data.projects || []; + } +} + class TestTenant { name: string; projects: TestProject[] = []; contexts: TestGlobalContext[] = []; webhooks: TestWebhook[] = []; + tags: TestTag[] = []; + keys: TestKey[] = []; constructor(tenant: string) { this.name = tenant; } + withTag(tag: TestTag): TestTenant { + this.tags.push(tag); + return this; + } + + withKey(key: TestKey): TestTenant { + this.keys.push(key); + return this; + } + withProject(project: TestProject): TestTenant { this.projects.push(project); return this; @@ -289,8 +477,12 @@ class TestProject { class TestFeature { name: string; enabled = false; - constructor(name: string) { + overloads: TestOverload[] = []; + + constructor(name: string, enabled = false, overloads: TestOverload[] = []) { this.name = name; + this.enabled = enabled; + this.overloads = overloads; } withEnableStatus(): TestFeature { @@ -302,6 +494,31 @@ class TestFeature { this.enabled = false; return this; } + + withOverload(overload: TestOverload): TestFeature { + this.overloads.push(overload); + return this; + } +} + +class TestOverload { + contextPath: string; + enabled = false; + + constructor(contextPath: string, enabled = false) { + this.contextPath = contextPath; + this.enabled = enabled; + } + + withEnableStatus(): TestOverload { + this.enabled = true; + return this; + } + + withDisableStatus(): TestOverload { + this.enabled = false; + return this; + } } interface TestContext { diff --git a/izanami-frontend/tests/webhooks.spec.ts b/izanami-frontend/tests/webhooks.spec.ts index f044bdf6f..b0e1783b1 100644 --- a/izanami-frontend/tests/webhooks.spec.ts +++ b/izanami-frontend/tests/webhooks.spec.ts @@ -13,10 +13,21 @@ test.use({ }); async function webhookAction(page: Page, name: string) { - await page.getByLabel("actions").click(); - await page - .getByRole("link", { name: name, exact: true }) - .click({ force: true }); + const dropdownLocator = page.getByLabel("actions"); + const locator = page.getByRole("link", { name: name, exact: true }); + + await dropdownLocator.click(); + try { + await locator.waitFor(); + } catch { + try { + await dropdownLocator.click(); + await locator.waitFor(); + } catch { + await dropdownLocator.click(); + } + } + await locator.click({ force: true }); } test.describe("Webhook screen should", () => { diff --git a/manual/.docusaurus/@easyops-cn/docusaurus-search-local/default/generated.js b/manual/.docusaurus/@easyops-cn/docusaurus-search-local/default/generated.js index cf4b4b3da..2adfdcec0 100644 --- a/manual/.docusaurus/@easyops-cn/docusaurus-search-local/default/generated.js +++ b/manual/.docusaurus/@easyops-cn/docusaurus-search-local/default/generated.js @@ -1,12 +1,12 @@ -import lunr from "/home/runner/work/izanami/izanami/manual/node_modules/lunr/lunr.js"; -require("/home/runner/work/izanami/izanami/manual/node_modules/lunr-languages/lunr.stemmer.support.js")(lunr); +import lunr from "/Users/77199M/workspace/oss/izanami-v2/manual/node_modules/lunr/lunr.js"; +require("/Users/77199M/workspace/oss/izanami-v2/manual/node_modules/lunr-languages/lunr.stemmer.support.js")(lunr); require("@easyops-cn/docusaurus-search-local/dist/client/shared/lunrLanguageZh").lunrLanguageZh(lunr); -require("/home/runner/work/izanami/izanami/manual/node_modules/lunr-languages/lunr.multi.js")(lunr); +require("/Users/77199M/workspace/oss/izanami-v2/manual/node_modules/lunr-languages/lunr.multi.js")(lunr); export const language = ["en","zh"]; export const removeDefaultStopWordFilter = false; export const removeDefaultStemmer = false; -export { default as Mark } from "/home/runner/work/izanami/izanami/manual/node_modules/mark.js/dist/mark.js" -export const searchIndexUrl = "search-index{dir}.json?_=2055fba0"; +export { default as Mark } from "/Users/77199M/workspace/oss/izanami-v2/manual/node_modules/mark.js/dist/mark.js" +export const searchIndexUrl = "search-index{dir}.json?_=2674a70d"; export const searchResultLimits = 8; export const searchResultContextMaxLength = 50; export const explicitSearchResultPath = true; diff --git a/manual/.docusaurus/client-modules.js b/manual/.docusaurus/client-modules.js index 91bb32e5c..fbef0a2f1 100644 --- a/manual/.docusaurus/client-modules.js +++ b/manual/.docusaurus/client-modules.js @@ -1,6 +1,6 @@ export default [ - require("/home/runner/work/izanami/izanami/manual/node_modules/infima/dist/css/default/default.css"), - require("/home/runner/work/izanami/izanami/manual/node_modules/@docusaurus/theme-classic/lib/prism-include-languages"), - require("/home/runner/work/izanami/izanami/manual/node_modules/@docusaurus/theme-classic/lib/nprogress"), - require("/home/runner/work/izanami/izanami/manual/src/css/custom.css"), + require("/Users/77199M/workspace/oss/izanami-v2/manual/node_modules/infima/dist/css/default/default.css"), + require("/Users/77199M/workspace/oss/izanami-v2/manual/node_modules/@docusaurus/theme-classic/lib/prism-include-languages"), + require("/Users/77199M/workspace/oss/izanami-v2/manual/node_modules/@docusaurus/theme-classic/lib/nprogress"), + require("/Users/77199M/workspace/oss/izanami-v2/manual/src/css/custom.css"), ]; diff --git a/manual/.docusaurus/docusaurus-plugin-content-docs/default/version-current-metadata-prop-751.json b/manual/.docusaurus/docusaurus-plugin-content-docs/default/version-current-metadata-prop-751.json index 53c491dc9..ddbebc019 100644 --- a/manual/.docusaurus/docusaurus-plugin-content-docs/default/version-current-metadata-prop-751.json +++ b/manual/.docusaurus/docusaurus-plugin-content-docs/default/version-current-metadata-prop-751.json @@ -156,6 +156,13 @@ "href": "/izanami/docs/guides/webhooks", "docId": "guides/webhooks", "unlisted": false + }, + { + "type": "link", + "label": "Data transfer", + "href": "/izanami/docs/guides/transfer-data", + "docId": "guides/transfer-data", + "unlisted": false } ], "href": "/izanami/docs/guides/" @@ -316,6 +323,12 @@ "description": "To use remote script feature (in opposition to local script features, that we've seen previously), you'll need to instantiate WASMO in alongside Izanami.", "sidebar": "tutorialSidebar" }, + "guides/transfer-data": { + "id": "guides/transfer-data", + "title": "Data transfer", + "description": "This page covers features available only from 2.5.0", + "sidebar": "tutorialSidebar" + }, "guides/user-invitation": { "id": "guides/user-invitation", "title": "User invitation", diff --git a/manual/.docusaurus/docusaurus-plugin-debug/default/docusaurus-debug-all-content-673.json b/manual/.docusaurus/docusaurus-plugin-debug/default/docusaurus-debug-all-content-673.json index 8d681ccd1..8e981f058 100644 --- a/manual/.docusaurus/docusaurus-plugin-debug/default/docusaurus-debug-all-content-673.json +++ b/manual/.docusaurus/docusaurus-plugin-debug/default/docusaurus-debug-all-content-673.json @@ -34,8 +34,8 @@ }, "sidebar": "tutorialSidebar", "previous": { - "title": "Webhooks", - "permalink": "/izanami/docs/guides/webhooks" + "title": "Data transfer", + "permalink": "/izanami/docs/guides/transfer-data" }, "next": { "title": "Java client", @@ -498,6 +498,32 @@ "permalink": "/izanami/docs/guides/http-calls-in-scripts" } }, + { + "id": "guides/transfer-data", + "title": "Data transfer", + "description": "This page covers features available only from 2.5.0", + "source": "@site/docs/04-guides/14-transfer-data.mdx", + "sourceDirName": "04-guides", + "slug": "/guides/transfer-data", + "permalink": "/izanami/docs/guides/transfer-data", + "draft": false, + "unlisted": false, + "tags": [], + "version": "current", + "sidebarPosition": 14, + "frontMatter": { + "title": "Data transfer" + }, + "sidebar": "tutorialSidebar", + "previous": { + "title": "Webhooks", + "permalink": "/izanami/docs/guides/webhooks" + }, + "next": { + "title": "Clients", + "permalink": "/izanami/docs/clients/" + } + }, { "id": "guides/user-invitation", "title": "User invitation", @@ -546,8 +572,8 @@ "permalink": "/izanami/docs/guides/configuration" }, "next": { - "title": "Clients", - "permalink": "/izanami/docs/clients/" + "title": "Data transfer", + "permalink": "/izanami/docs/guides/transfer-data" } }, { @@ -778,6 +804,10 @@ { "type": "doc", "id": "guides/webhooks" + }, + { + "type": "doc", + "id": "guides/transfer-data" } ], "link": { diff --git a/manual/.docusaurus/globalData.json b/manual/.docusaurus/globalData.json index 6ee552c37..8c33d826b 100644 --- a/manual/.docusaurus/globalData.json +++ b/manual/.docusaurus/globalData.json @@ -105,6 +105,11 @@ "path": "/izanami/docs/guides/remote-script", "sidebar": "tutorialSidebar" }, + { + "id": "guides/transfer-data", + "path": "/izanami/docs/guides/transfer-data", + "sidebar": "tutorialSidebar" + }, { "id": "guides/user-invitation", "path": "/izanami/docs/guides/user-invitation", diff --git a/manual/.docusaurus/registry.js b/manual/.docusaurus/registry.js index efe22c4e3..75ccbdbdb 100644 --- a/manual/.docusaurus/registry.js +++ b/manual/.docusaurus/registry.js @@ -1,81 +1,90 @@ export default { - "0f98d465": [() => import(/* webpackChunkName: "0f98d465" */ "@site/v1/18-tutorials/index.mdx"), "@site/v1/18-tutorials/index.mdx", require.resolveWeak("@site/v1/18-tutorials/index.mdx")], - "12625af8": [() => import(/* webpackChunkName: "12625af8" */ "@site/v1/13-keys.mdx"), "@site/v1/13-keys.mdx", require.resolveWeak("@site/v1/13-keys.mdx")], - "144ae2b5": [() => import(/* webpackChunkName: "144ae2b5" */ "@site/v1/10-configs/01-ui.mdx"), "@site/v1/10-configs/01-ui.mdx", require.resolveWeak("@site/v1/10-configs/01-ui.mdx")], - "1457b77c": [() => import(/* webpackChunkName: "1457b77c" */ "/home/runner/work/izanami/izanami/manual/.docusaurus/@easyops-cn/docusaurus-search-local/default/plugin-route-context-module-100.json"), "/home/runner/work/izanami/izanami/manual/.docusaurus/@easyops-cn/docusaurus-search-local/default/plugin-route-context-module-100.json", require.resolveWeak("/home/runner/work/izanami/izanami/manual/.docusaurus/@easyops-cn/docusaurus-search-local/default/plugin-route-context-module-100.json")], - "1756af0d": [() => import(/* webpackChunkName: "1756af0d" */ "@site/docs/03-usages/01-features.mdx"), "@site/docs/03-usages/01-features.mdx", require.resolveWeak("@site/docs/03-usages/01-features.mdx")], - "17896441": [() => import(/* webpackChunkName: "17896441" */ "@theme/DocItem"), "@theme/DocItem", require.resolveWeak("@theme/DocItem")], - "1858d382": [() => import(/* webpackChunkName: "1858d382" */ "@site/docs/04-guides/13-webhooks.mdx"), "@site/docs/04-guides/13-webhooks.mdx", require.resolveWeak("@site/docs/04-guides/13-webhooks.mdx")], - "1a4e3797": [() => import(/* webpackChunkName: "1a4e3797" */ "@theme/SearchPage"), "@theme/SearchPage", require.resolveWeak("@theme/SearchPage")], - "1ad66b9e": [() => import(/* webpackChunkName: "1ad66b9e" */ "/home/runner/work/izanami/izanami/manual/.docusaurus/docusaurus-plugin-content-docs/default/plugin-route-context-module-100.json"), "/home/runner/work/izanami/izanami/manual/.docusaurus/docusaurus-plugin-content-docs/default/plugin-route-context-module-100.json", require.resolveWeak("/home/runner/work/izanami/izanami/manual/.docusaurus/docusaurus-plugin-content-docs/default/plugin-route-context-module-100.json")], - "22a808b3": [() => import(/* webpackChunkName: "22a808b3" */ "@site/v1/08-ui.mdx"), "@site/v1/08-ui.mdx", require.resolveWeak("@site/v1/08-ui.mdx")], - "2524d653": [() => import(/* webpackChunkName: "2524d653" */ "@site/docs/03-usages/03-organisation.mdx"), "@site/docs/03-usages/03-organisation.mdx", require.resolveWeak("@site/docs/03-usages/03-organisation.mdx")], - "28294f75": [() => import(/* webpackChunkName: "28294f75" */ "@site/docs/04-guides/01-env-contexts.mdx"), "@site/docs/04-guides/01-env-contexts.mdx", require.resolveWeak("@site/docs/04-guides/01-env-contexts.mdx")], - "28ea13a0": [() => import(/* webpackChunkName: "28ea13a0" */ "@site/v1/17-clients/03-node.mdx"), "@site/v1/17-clients/03-node.mdx", require.resolveWeak("@site/v1/17-clients/03-node.mdx")], - "2911da6f": [() => import(/* webpackChunkName: "2911da6f" */ "@site/docs/04-guides/09-user-invitation.mdx"), "@site/docs/04-guides/09-user-invitation.mdx", require.resolveWeak("@site/docs/04-guides/09-user-invitation.mdx")], - "2c55d6de": [() => import(/* webpackChunkName: "2c55d6de" */ "@site/v1/11-features-flipping/03-api.mdx"), "@site/v1/11-features-flipping/03-api.mdx", require.resolveWeak("@site/v1/11-features-flipping/03-api.mdx")], - "2e7f27e2": [() => import(/* webpackChunkName: "2e7f27e2" */ "@site/docs/04-guides/index.mdx"), "@site/docs/04-guides/index.mdx", require.resolveWeak("@site/docs/04-guides/index.mdx")], - "309e43de": [() => import(/* webpackChunkName: "309e43de" */ "@site/v1/12-experiments/01-ui.mdx"), "@site/v1/12-experiments/01-ui.mdx", require.resolveWeak("@site/v1/12-experiments/01-ui.mdx")], - "3651c730": [() => import(/* webpackChunkName: "3651c730" */ "@site/v1/11-features-flipping/index.mdx"), "@site/v1/11-features-flipping/index.mdx", require.resolveWeak("@site/v1/11-features-flipping/index.mdx")], - "37d37b99": [() => import(/* webpackChunkName: "37d37b99" */ "@site/v1/11-features-flipping/04-lock.mdx"), "@site/v1/11-features-flipping/04-lock.mdx", require.resolveWeak("@site/v1/11-features-flipping/04-lock.mdx")], - "38c1ccfe": [() => import(/* webpackChunkName: "38c1ccfe" */ "@site/v1/index.mdx"), "@site/v1/index.mdx", require.resolveWeak("@site/v1/index.mdx")], - "391f84ad": [() => import(/* webpackChunkName: "391f84ad" */ "@site/docs/04-guides/08-http-calls-in-scripts.mdx"), "@site/docs/04-guides/08-http-calls-in-scripts.mdx", require.resolveWeak("@site/docs/04-guides/08-http-calls-in-scripts.mdx")], - "39cf9c2b": [() => import(/* webpackChunkName: "39cf9c2b" */ "@site/docs/02-concepts/index.mdx"), "@site/docs/02-concepts/index.mdx", require.resolveWeak("@site/docs/02-concepts/index.mdx")], - "3cfbbc0f": [() => import(/* webpackChunkName: "3cfbbc0f" */ "@site/v1/17-clients/04-cli.mdx"), "@site/v1/17-clients/04-cli.mdx", require.resolveWeak("@site/v1/17-clients/04-cli.mdx")], - "3e4b204b": [() => import(/* webpackChunkName: "3e4b204b" */ "@site/v1/10-configs/index.mdx"), "@site/v1/10-configs/index.mdx", require.resolveWeak("@site/v1/10-configs/index.mdx")], - "404820e5": [() => import(/* webpackChunkName: "404820e5" */ "@site/v1/02-about.mdx"), "@site/v1/02-about.mdx", require.resolveWeak("@site/v1/02-about.mdx")], - "404d2a01": [() => import(/* webpackChunkName: "404d2a01" */ "@site/v1/18-tutorials/02-oauth2.mdx"), "@site/v1/18-tutorials/02-oauth2.mdx", require.resolveWeak("@site/v1/18-tutorials/02-oauth2.mdx")], - "44ca1fc6": [() => import(/* webpackChunkName: "44ca1fc6" */ "@site/v1/17-clients/01-jvm.mdx"), "@site/v1/17-clients/01-jvm.mdx", require.resolveWeak("@site/v1/17-clients/01-jvm.mdx")], - "45bf6ac8": [() => import(/* webpackChunkName: "45bf6ac8" */ "@site/docs/04-guides/06-local-scripts.mdx"), "@site/docs/04-guides/06-local-scripts.mdx", require.resolveWeak("@site/docs/04-guides/06-local-scripts.mdx")], - "4cb46bbe": [() => import(/* webpackChunkName: "4cb46bbe" */ "/home/runner/work/izanami/izanami/manual/.docusaurus/docusaurus-plugin-content-docs/v1/plugin-route-context-module-100.json"), "/home/runner/work/izanami/izanami/manual/.docusaurus/docusaurus-plugin-content-docs/v1/plugin-route-context-module-100.json", require.resolveWeak("/home/runner/work/izanami/izanami/manual/.docusaurus/docusaurus-plugin-content-docs/v1/plugin-route-context-module-100.json")], - "4e45aa8f": [() => import(/* webpackChunkName: "4e45aa8f" */ "@site/docs/04-guides/11-mailer-configuration.mdx"), "@site/docs/04-guides/11-mailer-configuration.mdx", require.resolveWeak("@site/docs/04-guides/11-mailer-configuration.mdx")], - "52d2f9c5": [() => import(/* webpackChunkName: "52d2f9c5" */ "@site/docs/04-guides/05-import-from-v1.mdx"), "@site/docs/04-guides/05-import-from-v1.mdx", require.resolveWeak("@site/docs/04-guides/05-import-from-v1.mdx")], - "54014a70": [() => import(/* webpackChunkName: "54014a70" */ "@site/v1/07-settings/database.mdx"), "@site/v1/07-settings/database.mdx", require.resolveWeak("@site/v1/07-settings/database.mdx")], - "55940994": [() => import(/* webpackChunkName: "55940994" */ "@site/docs/01-getstarted/index.mdx"), "@site/docs/01-getstarted/index.mdx", require.resolveWeak("@site/docs/01-getstarted/index.mdx")], - "5e95c892": [() => import(/* webpackChunkName: "5e95c892" */ "@theme/DocsRoot"), "@theme/DocsRoot", require.resolveWeak("@theme/DocsRoot")], - "5e9f5e1a": [() => import(/* webpackChunkName: "5e9f5e1a" */ "@generated/docusaurus.config"), "@generated/docusaurus.config", require.resolveWeak("@generated/docusaurus.config")], - "5ec15e41": [() => import(/* webpackChunkName: "5ec15e41" */ "@site/docs/04-guides/07-remote-script.mdx"), "@site/docs/04-guides/07-remote-script.mdx", require.resolveWeak("@site/docs/04-guides/07-remote-script.mdx")], - "604919e7": [() => import(/* webpackChunkName: "604919e7" */ "@site/v1/07-settings/settings.mdx"), "@site/v1/07-settings/settings.mdx", require.resolveWeak("@site/v1/07-settings/settings.mdx")], - "61d10066": [() => import(/* webpackChunkName: "61d10066" */ "@site/v1/10-configs/03-springconfig.mdx"), "@site/v1/10-configs/03-springconfig.mdx", require.resolveWeak("@site/v1/10-configs/03-springconfig.mdx")], - "62eca57d": [() => import(/* webpackChunkName: "62eca57d" */ "@site/v1/03-philosophy.mdx"), "@site/v1/03-philosophy.mdx", require.resolveWeak("@site/v1/03-philosophy.mdx")], - "64236327": [() => import(/* webpackChunkName: "64236327" */ "@site/docs/04-guides/10-key-configuration.mdx"), "@site/docs/04-guides/10-key-configuration.mdx", require.resolveWeak("@site/docs/04-guides/10-key-configuration.mdx")], - "6a24d81d": [() => import(/* webpackChunkName: "6a24d81d" */ "@site/v1/10-configs/02-api.mdx"), "@site/v1/10-configs/02-api.mdx", require.resolveWeak("@site/v1/10-configs/02-api.mdx")], - "6b55a23b": [() => import(/* webpackChunkName: "6b55a23b" */ "@site/v1/11-features-flipping/02-scripts.mdx"), "@site/v1/11-features-flipping/02-scripts.mdx", require.resolveWeak("@site/v1/11-features-flipping/02-scripts.mdx")], - "7329b9d1": [() => import(/* webpackChunkName: "7329b9d1" */ "~docs/v1/version-current-metadata-prop-751.json"), "~docs/v1/version-current-metadata-prop-751.json", require.resolveWeak("~docs/v1/version-current-metadata-prop-751.json")], - "7a055ef3": [() => import(/* webpackChunkName: "7a055ef3" */ "@site/v1/20-developers.mdx"), "@site/v1/20-developers.mdx", require.resolveWeak("@site/v1/20-developers.mdx")], - "7a3092a3": [() => import(/* webpackChunkName: "7a3092a3" */ "@site/v1/17-clients/05-spring-starter.mdx"), "@site/v1/17-clients/05-spring-starter.mdx", require.resolveWeak("@site/v1/17-clients/05-spring-starter.mdx")], - "80987477": [() => import(/* webpackChunkName: "80987477" */ "@site/docs/04-guides/12-configuration.mdx"), "@site/docs/04-guides/12-configuration.mdx", require.resolveWeak("@site/docs/04-guides/12-configuration.mdx")], - "83cf5a0e": [() => import(/* webpackChunkName: "83cf5a0e" */ "@site/v1/06-getizanami/01-binaries.mdx"), "@site/v1/06-getizanami/01-binaries.mdx", require.resolveWeak("@site/v1/06-getizanami/01-binaries.mdx")], - "858bfcaf": [() => import(/* webpackChunkName: "858bfcaf" */ "@site/docs/05-clients/01-java/index.mdx"), "@site/docs/05-clients/01-java/index.mdx", require.resolveWeak("@site/docs/05-clients/01-java/index.mdx")], - "868bc92e": [() => import(/* webpackChunkName: "868bc92e" */ "@site/v1/04-features.mdx"), "@site/v1/04-features.mdx", require.resolveWeak("@site/v1/04-features.mdx")], - "8a163022": [() => import(/* webpackChunkName: "8a163022" */ "@site/v1/07-settings/index.mdx"), "@site/v1/07-settings/index.mdx", require.resolveWeak("@site/v1/07-settings/index.mdx")], - "8c817def": [() => import(/* webpackChunkName: "8c817def" */ "@site/v1/09-api.mdx"), "@site/v1/09-api.mdx", require.resolveWeak("@site/v1/09-api.mdx")], - "915e538f": [() => import(/* webpackChunkName: "915e538f" */ "@site/v1/17-clients/index.mdx"), "@site/v1/17-clients/index.mdx", require.resolveWeak("@site/v1/17-clients/index.mdx")], - "935f2afb": [() => import(/* webpackChunkName: "935f2afb" */ "~docs/default/version-current-metadata-prop-751.json"), "~docs/default/version-current-metadata-prop-751.json", require.resolveWeak("~docs/default/version-current-metadata-prop-751.json")], - "95f95e10": [() => import(/* webpackChunkName: "95f95e10" */ "@site/docs/05-clients/01-java/02-error-handling.mdx"), "@site/docs/05-clients/01-java/02-error-handling.mdx", require.resolveWeak("@site/docs/05-clients/01-java/02-error-handling.mdx")], - "9af8677d": [() => import(/* webpackChunkName: "9af8677d" */ "@site/docs/04-guides/04-bulk-feature-modification.mdx"), "@site/docs/04-guides/04-bulk-feature-modification.mdx", require.resolveWeak("@site/docs/04-guides/04-bulk-feature-modification.mdx")], - "a5a0f36f": [() => import(/* webpackChunkName: "a5a0f36f" */ "/home/runner/work/izanami/izanami/manual/.docusaurus/docusaurus-plugin-content-pages/default/plugin-route-context-module-100.json"), "/home/runner/work/izanami/izanami/manual/.docusaurus/docusaurus-plugin-content-pages/default/plugin-route-context-module-100.json", require.resolveWeak("/home/runner/work/izanami/izanami/manual/.docusaurus/docusaurus-plugin-content-pages/default/plugin-route-context-module-100.json")], - "a7bd4aaa": [() => import(/* webpackChunkName: "a7bd4aaa" */ "@theme/DocVersionRoot"), "@theme/DocVersionRoot", require.resolveWeak("@theme/DocVersionRoot")], - "a94703ab": [() => import(/* webpackChunkName: "a94703ab" */ "@theme/DocRoot"), "@theme/DocRoot", require.resolveWeak("@theme/DocRoot")], - "aa63221d": [() => import(/* webpackChunkName: "aa63221d" */ "@site/docs/05-clients/01-java/03-sse.mdx"), "@site/docs/05-clients/01-java/03-sse.mdx", require.resolveWeak("@site/docs/05-clients/01-java/03-sse.mdx")], - "b35c709e": [() => import(/* webpackChunkName: "b35c709e" */ "@site/docs/03-usages/02-contexts.mdx"), "@site/docs/03-usages/02-contexts.mdx", require.resolveWeak("@site/docs/03-usages/02-contexts.mdx")], - "c4f5d8e4": [() => import(/* webpackChunkName: "c4f5d8e4" */ "@site/src/pages/index.js"), "@site/src/pages/index.js", require.resolveWeak("@site/src/pages/index.js")], - "cbc90340": [() => import(/* webpackChunkName: "cbc90340" */ "@site/docs/04-guides/02-multi-conditions-feature.mdx"), "@site/docs/04-guides/02-multi-conditions-feature.mdx", require.resolveWeak("@site/docs/04-guides/02-multi-conditions-feature.mdx")], - "cced1e3d": [() => import(/* webpackChunkName: "cced1e3d" */ "@site/v1/05-architecture.mdx"), "@site/v1/05-architecture.mdx", require.resolveWeak("@site/v1/05-architecture.mdx")], - "cdfb9db4": [() => import(/* webpackChunkName: "cdfb9db4" */ "@site/v1/17-clients/02-react.mdx"), "@site/v1/17-clients/02-react.mdx", require.resolveWeak("@site/v1/17-clients/02-react.mdx")], - "cf997756": [() => import(/* webpackChunkName: "cf997756" */ "@site/v1/18-tutorials/01-spring.mdx"), "@site/v1/18-tutorials/01-spring.mdx", require.resolveWeak("@site/v1/18-tutorials/01-spring.mdx")], - "d5980866": [() => import(/* webpackChunkName: "d5980866" */ "@site/v1/19-performances.mdx"), "@site/v1/19-performances.mdx", require.resolveWeak("@site/v1/19-performances.mdx")], - "d86837dc": [() => import(/* webpackChunkName: "d86837dc" */ "@site/docs/03-usages/04-request.mdx"), "@site/docs/03-usages/04-request.mdx", require.resolveWeak("@site/docs/03-usages/04-request.mdx")], - "d98f6b02": [() => import(/* webpackChunkName: "d98f6b02" */ "@site/docs/05-clients/01-java/01-cache.mdx"), "@site/docs/05-clients/01-java/01-cache.mdx", require.resolveWeak("@site/docs/05-clients/01-java/01-cache.mdx")], - "d9a19508": [() => import(/* webpackChunkName: "d9a19508" */ "@site/v1/06-getizanami/index.mdx"), "@site/v1/06-getizanami/index.mdx", require.resolveWeak("@site/v1/06-getizanami/index.mdx")], - "dc8f53ac": [() => import(/* webpackChunkName: "dc8f53ac" */ "@site/v1/06-getizanami/02-docker.mdx"), "@site/v1/06-getizanami/02-docker.mdx", require.resolveWeak("@site/v1/06-getizanami/02-docker.mdx")], - "dfda2e39": [() => import(/* webpackChunkName: "dfda2e39" */ "@site/v1/14-events.mdx"), "@site/v1/14-events.mdx", require.resolveWeak("@site/v1/14-events.mdx")], - "e157316e": [() => import(/* webpackChunkName: "e157316e" */ "@site/v1/12-experiments/02-api.mdx"), "@site/v1/12-experiments/02-api.mdx", require.resolveWeak("@site/v1/12-experiments/02-api.mdx")], - "e90300dd": [() => import(/* webpackChunkName: "e90300dd" */ "@site/v1/12-experiments/index.mdx"), "@site/v1/12-experiments/index.mdx", require.resolveWeak("@site/v1/12-experiments/index.mdx")], - "ea391ed7": [() => import(/* webpackChunkName: "ea391ed7" */ "@site/v1/16-authprovider.mdx"), "@site/v1/16-authprovider.mdx", require.resolveWeak("@site/v1/16-authprovider.mdx")], - "efe36f9c": [() => import(/* webpackChunkName: "efe36f9c" */ "@site/v1/11-features-flipping/01-ui.mdx"), "@site/v1/11-features-flipping/01-ui.mdx", require.resolveWeak("@site/v1/11-features-flipping/01-ui.mdx")], - "f09d0f18": [() => import(/* webpackChunkName: "f09d0f18" */ "@site/docs/03-usages/index.mdx"), "@site/docs/03-usages/index.mdx", require.resolveWeak("@site/docs/03-usages/index.mdx")], - "f3281aa5": [() => import(/* webpackChunkName: "f3281aa5" */ "@site/v1/15-metrics.mdx"), "@site/v1/15-metrics.mdx", require.resolveWeak("@site/v1/15-metrics.mdx")], - "f53bace1": [() => import(/* webpackChunkName: "f53bace1" */ "@site/docs/05-clients/index.mdx"), "@site/docs/05-clients/index.mdx", require.resolveWeak("@site/docs/05-clients/index.mdx")], - "f5ac983d": [() => import(/* webpackChunkName: "f5ac983d" */ "@site/v1/06-getizanami/03-fromsources.mdx"), "@site/v1/06-getizanami/03-fromsources.mdx", require.resolveWeak("@site/v1/06-getizanami/03-fromsources.mdx")], - "f7b0431a": [() => import(/* webpackChunkName: "f7b0431a" */ "@site/docs/04-guides/03-query-builder.mdx"), "@site/docs/04-guides/03-query-builder.mdx", require.resolveWeak("@site/docs/04-guides/03-query-builder.mdx")],}; + "__comp---site-src-pages-index-jsc-4-f-f99": [() => import(/* webpackChunkName: "__comp---site-src-pages-index-jsc-4-f-f99" */ "@site/src/pages/index.js"), "@site/src/pages/index.js", require.resolveWeak("@site/src/pages/index.js")], + "__comp---theme-debug-config-23-a-2ff": [() => import(/* webpackChunkName: "__comp---theme-debug-config-23-a-2ff" */ "@theme/DebugConfig"), "@theme/DebugConfig", require.resolveWeak("@theme/DebugConfig")], + "__comp---theme-debug-contentba-8-ce7": [() => import(/* webpackChunkName: "__comp---theme-debug-contentba-8-ce7" */ "@theme/DebugContent"), "@theme/DebugContent", require.resolveWeak("@theme/DebugContent")], + "__comp---theme-debug-global-dataede-0fa": [() => import(/* webpackChunkName: "__comp---theme-debug-global-dataede-0fa" */ "@theme/DebugGlobalData"), "@theme/DebugGlobalData", require.resolveWeak("@theme/DebugGlobalData")], + "__comp---theme-debug-registry-679-501": [() => import(/* webpackChunkName: "__comp---theme-debug-registry-679-501" */ "@theme/DebugRegistry"), "@theme/DebugRegistry", require.resolveWeak("@theme/DebugRegistry")], + "__comp---theme-debug-routes-946-699": [() => import(/* webpackChunkName: "__comp---theme-debug-routes-946-699" */ "@theme/DebugRoutes"), "@theme/DebugRoutes", require.resolveWeak("@theme/DebugRoutes")], + "__comp---theme-debug-site-metadata-68-e-3d4": [() => import(/* webpackChunkName: "__comp---theme-debug-site-metadata-68-e-3d4" */ "@theme/DebugSiteMetadata"), "@theme/DebugSiteMetadata", require.resolveWeak("@theme/DebugSiteMetadata")], + "__comp---theme-doc-item-178-a40": [() => import(/* webpackChunkName: "__comp---theme-doc-item-178-a40" */ "@theme/DocItem"), "@theme/DocItem", require.resolveWeak("@theme/DocItem")], + "__comp---theme-doc-roota-94-67a": [() => import(/* webpackChunkName: "__comp---theme-doc-roota-94-67a" */ "@theme/DocRoot"), "@theme/DocRoot", require.resolveWeak("@theme/DocRoot")], + "__comp---theme-doc-version-roota-7-b-5de": [() => import(/* webpackChunkName: "__comp---theme-doc-version-roota-7-b-5de" */ "@theme/DocVersionRoot"), "@theme/DocVersionRoot", require.resolveWeak("@theme/DocVersionRoot")], + "__comp---theme-docs-root-5-e-9-0b6": [() => import(/* webpackChunkName: "__comp---theme-docs-root-5-e-9-0b6" */ "@theme/DocsRoot"), "@theme/DocsRoot", require.resolveWeak("@theme/DocsRoot")], + "__comp---theme-search-page-1-a-4-d6f": [() => import(/* webpackChunkName: "__comp---theme-search-page-1-a-4-d6f" */ "@theme/SearchPage"), "@theme/SearchPage", require.resolveWeak("@theme/SearchPage")], + "allContent---izanami-docusaurus-debug-content-246-c61": [() => import(/* webpackChunkName: "allContent---izanami-docusaurus-debug-content-246-c61" */ "~debug/default/docusaurus-debug-all-content-673.json"), "~debug/default/docusaurus-debug-all-content-673.json", require.resolveWeak("~debug/default/docusaurus-debug-all-content-673.json")], + "config---izanami-5-e-9-485": [() => import(/* webpackChunkName: "config---izanami-5-e-9-485" */ "@generated/docusaurus.config"), "@generated/docusaurus.config", require.resolveWeak("@generated/docusaurus.config")], + "content---izanami-docs-clients-f-53-ddb": [() => import(/* webpackChunkName: "content---izanami-docs-clients-f-53-ddb" */ "@site/docs/05-clients/index.mdx"), "@site/docs/05-clients/index.mdx", require.resolveWeak("@site/docs/05-clients/index.mdx")], + "content---izanami-docs-clients-java-858-68f": [() => import(/* webpackChunkName: "content---izanami-docs-clients-java-858-68f" */ "@site/docs/05-clients/01-java/index.mdx"), "@site/docs/05-clients/01-java/index.mdx", require.resolveWeak("@site/docs/05-clients/01-java/index.mdx")], + "content---izanami-docs-clients-java-cached-98-38e": [() => import(/* webpackChunkName: "content---izanami-docs-clients-java-cached-98-38e" */ "@site/docs/05-clients/01-java/01-cache.mdx"), "@site/docs/05-clients/01-java/01-cache.mdx", require.resolveWeak("@site/docs/05-clients/01-java/01-cache.mdx")], + "content---izanami-docs-clients-java-error-handling-95-f-d67": [() => import(/* webpackChunkName: "content---izanami-docs-clients-java-error-handling-95-f-d67" */ "@site/docs/05-clients/01-java/02-error-handling.mdx"), "@site/docs/05-clients/01-java/02-error-handling.mdx", require.resolveWeak("@site/docs/05-clients/01-java/02-error-handling.mdx")], + "content---izanami-docs-clients-java-sseaa-6-ecb": [() => import(/* webpackChunkName: "content---izanami-docs-clients-java-sseaa-6-ecb" */ "@site/docs/05-clients/01-java/03-sse.mdx"), "@site/docs/05-clients/01-java/03-sse.mdx", require.resolveWeak("@site/docs/05-clients/01-java/03-sse.mdx")], + "content---izanami-docs-concepts-39-c-d27": [() => import(/* webpackChunkName: "content---izanami-docs-concepts-39-c-d27" */ "@site/docs/02-concepts/index.mdx"), "@site/docs/02-concepts/index.mdx", require.resolveWeak("@site/docs/02-concepts/index.mdx")], + "content---izanami-docs-getstarted-559-e25": [() => import(/* webpackChunkName: "content---izanami-docs-getstarted-559-e25" */ "@site/docs/01-getstarted/index.mdx"), "@site/docs/01-getstarted/index.mdx", require.resolveWeak("@site/docs/01-getstarted/index.mdx")], + "content---izanami-docs-guides-2-e-7-90c": [() => import(/* webpackChunkName: "content---izanami-docs-guides-2-e-7-90c" */ "@site/docs/04-guides/index.mdx"), "@site/docs/04-guides/index.mdx", require.resolveWeak("@site/docs/04-guides/index.mdx")], + "content---izanami-docs-guides-bulk-feature-modification-9-af-8db": [() => import(/* webpackChunkName: "content---izanami-docs-guides-bulk-feature-modification-9-af-8db" */ "@site/docs/04-guides/04-bulk-feature-modification.mdx"), "@site/docs/04-guides/04-bulk-feature-modification.mdx", require.resolveWeak("@site/docs/04-guides/04-bulk-feature-modification.mdx")], + "content---izanami-docs-guides-configuration-809-de6": [() => import(/* webpackChunkName: "content---izanami-docs-guides-configuration-809-de6" */ "@site/docs/04-guides/12-configuration.mdx"), "@site/docs/04-guides/12-configuration.mdx", require.resolveWeak("@site/docs/04-guides/12-configuration.mdx")], + "content---izanami-docs-guides-env-contexts-282-25d": [() => import(/* webpackChunkName: "content---izanami-docs-guides-env-contexts-282-25d" */ "@site/docs/04-guides/01-env-contexts.mdx"), "@site/docs/04-guides/01-env-contexts.mdx", require.resolveWeak("@site/docs/04-guides/01-env-contexts.mdx")], + "content---izanami-docs-guides-http-calls-in-scripts-391-d90": [() => import(/* webpackChunkName: "content---izanami-docs-guides-http-calls-in-scripts-391-d90" */ "@site/docs/04-guides/08-http-calls-in-scripts.mdx"), "@site/docs/04-guides/08-http-calls-in-scripts.mdx", require.resolveWeak("@site/docs/04-guides/08-http-calls-in-scripts.mdx")], + "content---izanami-docs-guides-import-from-v-152-d-389": [() => import(/* webpackChunkName: "content---izanami-docs-guides-import-from-v-152-d-389" */ "@site/docs/04-guides/05-import-from-v1.mdx"), "@site/docs/04-guides/05-import-from-v1.mdx", require.resolveWeak("@site/docs/04-guides/05-import-from-v1.mdx")], + "content---izanami-docs-guides-key-configuration-642-b12": [() => import(/* webpackChunkName: "content---izanami-docs-guides-key-configuration-642-b12" */ "@site/docs/04-guides/10-key-configuration.mdx"), "@site/docs/04-guides/10-key-configuration.mdx", require.resolveWeak("@site/docs/04-guides/10-key-configuration.mdx")], + "content---izanami-docs-guides-local-scripts-45-b-d3d": [() => import(/* webpackChunkName: "content---izanami-docs-guides-local-scripts-45-b-d3d" */ "@site/docs/04-guides/06-local-scripts.mdx"), "@site/docs/04-guides/06-local-scripts.mdx", require.resolveWeak("@site/docs/04-guides/06-local-scripts.mdx")], + "content---izanami-docs-guides-mailer-configuration-4-e-4-c62": [() => import(/* webpackChunkName: "content---izanami-docs-guides-mailer-configuration-4-e-4-c62" */ "@site/docs/04-guides/11-mailer-configuration.mdx"), "@site/docs/04-guides/11-mailer-configuration.mdx", require.resolveWeak("@site/docs/04-guides/11-mailer-configuration.mdx")], + "content---izanami-docs-guides-multi-conditions-featurecbc-67a": [() => import(/* webpackChunkName: "content---izanami-docs-guides-multi-conditions-featurecbc-67a" */ "@site/docs/04-guides/02-multi-conditions-feature.mdx"), "@site/docs/04-guides/02-multi-conditions-feature.mdx", require.resolveWeak("@site/docs/04-guides/02-multi-conditions-feature.mdx")], + "content---izanami-docs-guides-query-builderf-7-b-4f8": [() => import(/* webpackChunkName: "content---izanami-docs-guides-query-builderf-7-b-4f8" */ "@site/docs/04-guides/03-query-builder.mdx"), "@site/docs/04-guides/03-query-builder.mdx", require.resolveWeak("@site/docs/04-guides/03-query-builder.mdx")], + "content---izanami-docs-guides-remote-script-5-ec-5c2": [() => import(/* webpackChunkName: "content---izanami-docs-guides-remote-script-5-ec-5c2" */ "@site/docs/04-guides/07-remote-script.mdx"), "@site/docs/04-guides/07-remote-script.mdx", require.resolveWeak("@site/docs/04-guides/07-remote-script.mdx")], + "content---izanami-docs-guides-transfer-data-8-ec-d50": [() => import(/* webpackChunkName: "content---izanami-docs-guides-transfer-data-8-ec-d50" */ "@site/docs/04-guides/14-transfer-data.mdx"), "@site/docs/04-guides/14-transfer-data.mdx", require.resolveWeak("@site/docs/04-guides/14-transfer-data.mdx")], + "content---izanami-docs-guides-user-invitation-291-6dc": [() => import(/* webpackChunkName: "content---izanami-docs-guides-user-invitation-291-6dc" */ "@site/docs/04-guides/09-user-invitation.mdx"), "@site/docs/04-guides/09-user-invitation.mdx", require.resolveWeak("@site/docs/04-guides/09-user-invitation.mdx")], + "content---izanami-docs-guides-webhooks-185-6d1": [() => import(/* webpackChunkName: "content---izanami-docs-guides-webhooks-185-6d1" */ "@site/docs/04-guides/13-webhooks.mdx"), "@site/docs/04-guides/13-webhooks.mdx", require.resolveWeak("@site/docs/04-guides/13-webhooks.mdx")], + "content---izanami-docs-usages-contextsb-35-a79": [() => import(/* webpackChunkName: "content---izanami-docs-usages-contextsb-35-a79" */ "@site/docs/03-usages/02-contexts.mdx"), "@site/docs/03-usages/02-contexts.mdx", require.resolveWeak("@site/docs/03-usages/02-contexts.mdx")], + "content---izanami-docs-usages-f-09-ee0": [() => import(/* webpackChunkName: "content---izanami-docs-usages-f-09-ee0" */ "@site/docs/03-usages/index.mdx"), "@site/docs/03-usages/index.mdx", require.resolveWeak("@site/docs/03-usages/index.mdx")], + "content---izanami-docs-usages-features-175-9e5": [() => import(/* webpackChunkName: "content---izanami-docs-usages-features-175-9e5" */ "@site/docs/03-usages/01-features.mdx"), "@site/docs/03-usages/01-features.mdx", require.resolveWeak("@site/docs/03-usages/01-features.mdx")], + "content---izanami-docs-usages-organisation-252-2d5": [() => import(/* webpackChunkName: "content---izanami-docs-usages-organisation-252-2d5" */ "@site/docs/03-usages/03-organisation.mdx"), "@site/docs/03-usages/03-organisation.mdx", require.resolveWeak("@site/docs/03-usages/03-organisation.mdx")], + "content---izanami-docs-usages-requestd-86-68b": [() => import(/* webpackChunkName: "content---izanami-docs-usages-requestd-86-68b" */ "@site/docs/03-usages/04-request.mdx"), "@site/docs/03-usages/04-request.mdx", require.resolveWeak("@site/docs/03-usages/04-request.mdx")], + "content---izanami-v-1-38-c-105": [() => import(/* webpackChunkName: "content---izanami-v-1-38-c-105" */ "@site/v1/index.mdx"), "@site/v1/index.mdx", require.resolveWeak("@site/v1/index.mdx")], + "content---izanami-v-1-about-404-3f5": [() => import(/* webpackChunkName: "content---izanami-v-1-about-404-3f5" */ "@site/v1/02-about.mdx"), "@site/v1/02-about.mdx", require.resolveWeak("@site/v1/02-about.mdx")], + "content---izanami-v-1-api-8-c-8-676": [() => import(/* webpackChunkName: "content---izanami-v-1-api-8-c-8-676" */ "@site/v1/09-api.mdx"), "@site/v1/09-api.mdx", require.resolveWeak("@site/v1/09-api.mdx")], + "content---izanami-v-1-architecturecce-931": [() => import(/* webpackChunkName: "content---izanami-v-1-architecturecce-931" */ "@site/v1/05-architecture.mdx"), "@site/v1/05-architecture.mdx", require.resolveWeak("@site/v1/05-architecture.mdx")], + "content---izanami-v-1-authproviderea-3-644": [() => import(/* webpackChunkName: "content---izanami-v-1-authproviderea-3-644" */ "@site/v1/16-authprovider.mdx"), "@site/v1/16-authprovider.mdx", require.resolveWeak("@site/v1/16-authprovider.mdx")], + "content---izanami-v-1-clients-915-d28": [() => import(/* webpackChunkName: "content---izanami-v-1-clients-915-d28" */ "@site/v1/17-clients/index.mdx"), "@site/v1/17-clients/index.mdx", require.resolveWeak("@site/v1/17-clients/index.mdx")], + "content---izanami-v-1-clients-cli-3-cf-9a1": [() => import(/* webpackChunkName: "content---izanami-v-1-clients-cli-3-cf-9a1" */ "@site/v1/17-clients/04-cli.mdx"), "@site/v1/17-clients/04-cli.mdx", require.resolveWeak("@site/v1/17-clients/04-cli.mdx")], + "content---izanami-v-1-clients-jvm-44-c-096": [() => import(/* webpackChunkName: "content---izanami-v-1-clients-jvm-44-c-096" */ "@site/v1/17-clients/01-jvm.mdx"), "@site/v1/17-clients/01-jvm.mdx", require.resolveWeak("@site/v1/17-clients/01-jvm.mdx")], + "content---izanami-v-1-clients-node-28-e-d45": [() => import(/* webpackChunkName: "content---izanami-v-1-clients-node-28-e-d45" */ "@site/v1/17-clients/03-node.mdx"), "@site/v1/17-clients/03-node.mdx", require.resolveWeak("@site/v1/17-clients/03-node.mdx")], + "content---izanami-v-1-clients-reactcdf-b19": [() => import(/* webpackChunkName: "content---izanami-v-1-clients-reactcdf-b19" */ "@site/v1/17-clients/02-react.mdx"), "@site/v1/17-clients/02-react.mdx", require.resolveWeak("@site/v1/17-clients/02-react.mdx")], + "content---izanami-v-1-clients-spring-starter-7-a-3-7a6": [() => import(/* webpackChunkName: "content---izanami-v-1-clients-spring-starter-7-a-3-7a6" */ "@site/v1/17-clients/05-spring-starter.mdx"), "@site/v1/17-clients/05-spring-starter.mdx", require.resolveWeak("@site/v1/17-clients/05-spring-starter.mdx")], + "content---izanami-v-1-configs-3-e-4-2ff": [() => import(/* webpackChunkName: "content---izanami-v-1-configs-3-e-4-2ff" */ "@site/v1/10-configs/index.mdx"), "@site/v1/10-configs/index.mdx", require.resolveWeak("@site/v1/10-configs/index.mdx")], + "content---izanami-v-1-configs-api-6-a-2-69d": [() => import(/* webpackChunkName: "content---izanami-v-1-configs-api-6-a-2-69d" */ "@site/v1/10-configs/02-api.mdx"), "@site/v1/10-configs/02-api.mdx", require.resolveWeak("@site/v1/10-configs/02-api.mdx")], + "content---izanami-v-1-configs-springconfig-61-d-f30": [() => import(/* webpackChunkName: "content---izanami-v-1-configs-springconfig-61-d-f30" */ "@site/v1/10-configs/03-springconfig.mdx"), "@site/v1/10-configs/03-springconfig.mdx", require.resolveWeak("@site/v1/10-configs/03-springconfig.mdx")], + "content---izanami-v-1-configs-ui-144-a34": [() => import(/* webpackChunkName: "content---izanami-v-1-configs-ui-144-a34" */ "@site/v1/10-configs/01-ui.mdx"), "@site/v1/10-configs/01-ui.mdx", require.resolveWeak("@site/v1/10-configs/01-ui.mdx")], + "content---izanami-v-1-developers-7-a-0-9c7": [() => import(/* webpackChunkName: "content---izanami-v-1-developers-7-a-0-9c7" */ "@site/v1/20-developers.mdx"), "@site/v1/20-developers.mdx", require.resolveWeak("@site/v1/20-developers.mdx")], + "content---izanami-v-1-eventsdfd-d43": [() => import(/* webpackChunkName: "content---izanami-v-1-eventsdfd-d43" */ "@site/v1/14-events.mdx"), "@site/v1/14-events.mdx", require.resolveWeak("@site/v1/14-events.mdx")], + "content---izanami-v-1-experiments-apie-15-10a": [() => import(/* webpackChunkName: "content---izanami-v-1-experiments-apie-15-10a" */ "@site/v1/12-experiments/02-api.mdx"), "@site/v1/12-experiments/02-api.mdx", require.resolveWeak("@site/v1/12-experiments/02-api.mdx")], + "content---izanami-v-1-experiments-e-90-974": [() => import(/* webpackChunkName: "content---izanami-v-1-experiments-e-90-974" */ "@site/v1/12-experiments/index.mdx"), "@site/v1/12-experiments/index.mdx", require.resolveWeak("@site/v1/12-experiments/index.mdx")], + "content---izanami-v-1-experiments-ui-309-5ca": [() => import(/* webpackChunkName: "content---izanami-v-1-experiments-ui-309-5ca" */ "@site/v1/12-experiments/01-ui.mdx"), "@site/v1/12-experiments/01-ui.mdx", require.resolveWeak("@site/v1/12-experiments/01-ui.mdx")], + "content---izanami-v-1-features-868-d79": [() => import(/* webpackChunkName: "content---izanami-v-1-features-868-d79" */ "@site/v1/04-features.mdx"), "@site/v1/04-features.mdx", require.resolveWeak("@site/v1/04-features.mdx")], + "content---izanami-v-1-features-flipping-365-731": [() => import(/* webpackChunkName: "content---izanami-v-1-features-flipping-365-731" */ "@site/v1/11-features-flipping/index.mdx"), "@site/v1/11-features-flipping/index.mdx", require.resolveWeak("@site/v1/11-features-flipping/index.mdx")], + "content---izanami-v-1-features-flipping-api-2-c-5-4c6": [() => import(/* webpackChunkName: "content---izanami-v-1-features-flipping-api-2-c-5-4c6" */ "@site/v1/11-features-flipping/03-api.mdx"), "@site/v1/11-features-flipping/03-api.mdx", require.resolveWeak("@site/v1/11-features-flipping/03-api.mdx")], + "content---izanami-v-1-features-flipping-lock-37-d-be6": [() => import(/* webpackChunkName: "content---izanami-v-1-features-flipping-lock-37-d-be6" */ "@site/v1/11-features-flipping/04-lock.mdx"), "@site/v1/11-features-flipping/04-lock.mdx", require.resolveWeak("@site/v1/11-features-flipping/04-lock.mdx")], + "content---izanami-v-1-features-flipping-scripts-6-b-5-325": [() => import(/* webpackChunkName: "content---izanami-v-1-features-flipping-scripts-6-b-5-325" */ "@site/v1/11-features-flipping/02-scripts.mdx"), "@site/v1/11-features-flipping/02-scripts.mdx", require.resolveWeak("@site/v1/11-features-flipping/02-scripts.mdx")], + "content---izanami-v-1-features-flipping-uiefe-4c7": [() => import(/* webpackChunkName: "content---izanami-v-1-features-flipping-uiefe-4c7" */ "@site/v1/11-features-flipping/01-ui.mdx"), "@site/v1/11-features-flipping/01-ui.mdx", require.resolveWeak("@site/v1/11-features-flipping/01-ui.mdx")], + "content---izanami-v-1-getizanami-binaries-83-c-595": [() => import(/* webpackChunkName: "content---izanami-v-1-getizanami-binaries-83-c-595" */ "@site/v1/06-getizanami/01-binaries.mdx"), "@site/v1/06-getizanami/01-binaries.mdx", require.resolveWeak("@site/v1/06-getizanami/01-binaries.mdx")], + "content---izanami-v-1-getizanami-d-9-a-7e0": [() => import(/* webpackChunkName: "content---izanami-v-1-getizanami-d-9-a-7e0" */ "@site/v1/06-getizanami/index.mdx"), "@site/v1/06-getizanami/index.mdx", require.resolveWeak("@site/v1/06-getizanami/index.mdx")], + "content---izanami-v-1-getizanami-dockerdc-8-cc8": [() => import(/* webpackChunkName: "content---izanami-v-1-getizanami-dockerdc-8-cc8" */ "@site/v1/06-getizanami/02-docker.mdx"), "@site/v1/06-getizanami/02-docker.mdx", require.resolveWeak("@site/v1/06-getizanami/02-docker.mdx")], + "content---izanami-v-1-getizanami-fromsourcesf-5-a-707": [() => import(/* webpackChunkName: "content---izanami-v-1-getizanami-fromsourcesf-5-a-707" */ "@site/v1/06-getizanami/03-fromsources.mdx"), "@site/v1/06-getizanami/03-fromsources.mdx", require.resolveWeak("@site/v1/06-getizanami/03-fromsources.mdx")], + "content---izanami-v-1-keys-126-146": [() => import(/* webpackChunkName: "content---izanami-v-1-keys-126-146" */ "@site/v1/13-keys.mdx"), "@site/v1/13-keys.mdx", require.resolveWeak("@site/v1/13-keys.mdx")], + "content---izanami-v-1-metricsf-32-a4e": [() => import(/* webpackChunkName: "content---izanami-v-1-metricsf-32-a4e" */ "@site/v1/15-metrics.mdx"), "@site/v1/15-metrics.mdx", require.resolveWeak("@site/v1/15-metrics.mdx")], + "content---izanami-v-1-performancesd-59-76a": [() => import(/* webpackChunkName: "content---izanami-v-1-performancesd-59-76a" */ "@site/v1/19-performances.mdx"), "@site/v1/19-performances.mdx", require.resolveWeak("@site/v1/19-performances.mdx")], + "content---izanami-v-1-philosophy-62-e-298": [() => import(/* webpackChunkName: "content---izanami-v-1-philosophy-62-e-298" */ "@site/v1/03-philosophy.mdx"), "@site/v1/03-philosophy.mdx", require.resolveWeak("@site/v1/03-philosophy.mdx")], + "content---izanami-v-1-settings-8-a-1-b9e": [() => import(/* webpackChunkName: "content---izanami-v-1-settings-8-a-1-b9e" */ "@site/v1/07-settings/index.mdx"), "@site/v1/07-settings/index.mdx", require.resolveWeak("@site/v1/07-settings/index.mdx")], + "content---izanami-v-1-settings-database-540-759": [() => import(/* webpackChunkName: "content---izanami-v-1-settings-database-540-759" */ "@site/v1/07-settings/database.mdx"), "@site/v1/07-settings/database.mdx", require.resolveWeak("@site/v1/07-settings/database.mdx")], + "content---izanami-v-1-settings-settings-604-766": [() => import(/* webpackChunkName: "content---izanami-v-1-settings-settings-604-766" */ "@site/v1/07-settings/settings.mdx"), "@site/v1/07-settings/settings.mdx", require.resolveWeak("@site/v1/07-settings/settings.mdx")], + "content---izanami-v-1-tutorials-0-f-9-bed": [() => import(/* webpackChunkName: "content---izanami-v-1-tutorials-0-f-9-bed" */ "@site/v1/18-tutorials/index.mdx"), "@site/v1/18-tutorials/index.mdx", require.resolveWeak("@site/v1/18-tutorials/index.mdx")], + "content---izanami-v-1-tutorials-oauth-2404-9d8": [() => import(/* webpackChunkName: "content---izanami-v-1-tutorials-oauth-2404-9d8" */ "@site/v1/18-tutorials/02-oauth2.mdx"), "@site/v1/18-tutorials/02-oauth2.mdx", require.resolveWeak("@site/v1/18-tutorials/02-oauth2.mdx")], + "content---izanami-v-1-tutorials-springcf-9-f2f": [() => import(/* webpackChunkName: "content---izanami-v-1-tutorials-springcf-9-f2f" */ "@site/v1/18-tutorials/01-spring.mdx"), "@site/v1/18-tutorials/01-spring.mdx", require.resolveWeak("@site/v1/18-tutorials/01-spring.mdx")], + "content---izanami-v-1-ui-22-a-7e8": [() => import(/* webpackChunkName: "content---izanami-v-1-ui-22-a-7e8" */ "@site/v1/08-ui.mdx"), "@site/v1/08-ui.mdx", require.resolveWeak("@site/v1/08-ui.mdx")], + "plugin---izanami-49-c-56d": [() => import(/* webpackChunkName: "plugin---izanami-49-c-56d" */ "/Users/77199M/workspace/oss/izanami-v2/manual/.docusaurus/docusaurus-plugin-content-pages/default/plugin-route-context-module-100.json"), "/Users/77199M/workspace/oss/izanami-v2/manual/.docusaurus/docusaurus-plugin-content-pages/default/plugin-route-context-module-100.json", require.resolveWeak("/Users/77199M/workspace/oss/izanami-v2/manual/.docusaurus/docusaurus-plugin-content-pages/default/plugin-route-context-module-100.json")], + "plugin---izanami-docs-18-d-414": [() => import(/* webpackChunkName: "plugin---izanami-docs-18-d-414" */ "/Users/77199M/workspace/oss/izanami-v2/manual/.docusaurus/docusaurus-plugin-content-docs/default/plugin-route-context-module-100.json"), "/Users/77199M/workspace/oss/izanami-v2/manual/.docusaurus/docusaurus-plugin-content-docs/default/plugin-route-context-module-100.json", require.resolveWeak("/Users/77199M/workspace/oss/izanami-v2/manual/.docusaurus/docusaurus-plugin-content-docs/default/plugin-route-context-module-100.json")], + "plugin---izanami-docusaurus-debugf-75-018": [() => import(/* webpackChunkName: "plugin---izanami-docusaurus-debugf-75-018" */ "/Users/77199M/workspace/oss/izanami-v2/manual/.docusaurus/docusaurus-plugin-debug/default/plugin-route-context-module-100.json"), "/Users/77199M/workspace/oss/izanami-v2/manual/.docusaurus/docusaurus-plugin-debug/default/plugin-route-context-module-100.json", require.resolveWeak("/Users/77199M/workspace/oss/izanami-v2/manual/.docusaurus/docusaurus-plugin-debug/default/plugin-route-context-module-100.json")], + "plugin---izanami-searchaaf-832": [() => import(/* webpackChunkName: "plugin---izanami-searchaaf-832" */ "/Users/77199M/workspace/oss/izanami-v2/manual/.docusaurus/@easyops-cn/docusaurus-search-local/default/plugin-route-context-module-100.json"), "/Users/77199M/workspace/oss/izanami-v2/manual/.docusaurus/@easyops-cn/docusaurus-search-local/default/plugin-route-context-module-100.json", require.resolveWeak("/Users/77199M/workspace/oss/izanami-v2/manual/.docusaurus/@easyops-cn/docusaurus-search-local/default/plugin-route-context-module-100.json")], + "plugin---izanami-v-19-ad-71a": [() => import(/* webpackChunkName: "plugin---izanami-v-19-ad-71a" */ "/Users/77199M/workspace/oss/izanami-v2/manual/.docusaurus/docusaurus-plugin-content-docs/v1/plugin-route-context-module-100.json"), "/Users/77199M/workspace/oss/izanami-v2/manual/.docusaurus/docusaurus-plugin-content-docs/v1/plugin-route-context-module-100.json", require.resolveWeak("/Users/77199M/workspace/oss/izanami-v2/manual/.docusaurus/docusaurus-plugin-content-docs/v1/plugin-route-context-module-100.json")], + "version---izanami-docs-935-49b": [() => import(/* webpackChunkName: "version---izanami-docs-935-49b" */ "~docs/default/version-current-metadata-prop-751.json"), "~docs/default/version-current-metadata-prop-751.json", require.resolveWeak("~docs/default/version-current-metadata-prop-751.json")], + "version---izanami-v-1732-153": [() => import(/* webpackChunkName: "version---izanami-v-1732-153" */ "~docs/v1/version-current-metadata-prop-751.json"), "~docs/v1/version-current-metadata-prop-751.json", require.resolveWeak("~docs/v1/version-current-metadata-prop-751.json")],}; diff --git a/manual/.docusaurus/routes.js b/manual/.docusaurus/routes.js index 152f8f985..babe35c32 100644 --- a/manual/.docusaurus/routes.js +++ b/manual/.docusaurus/routes.js @@ -2,22 +2,57 @@ import React from 'react'; import ComponentCreator from '@docusaurus/ComponentCreator'; export default [ + { + path: '/izanami/__docusaurus/debug', + component: ComponentCreator('/izanami/__docusaurus/debug', 'ab4'), + exact: true + }, + { + path: '/izanami/__docusaurus/debug/config', + component: ComponentCreator('/izanami/__docusaurus/debug/config', '71e'), + exact: true + }, + { + path: '/izanami/__docusaurus/debug/content', + component: ComponentCreator('/izanami/__docusaurus/debug/content', '7bd'), + exact: true + }, + { + path: '/izanami/__docusaurus/debug/globalData', + component: ComponentCreator('/izanami/__docusaurus/debug/globalData', '1a4'), + exact: true + }, + { + path: '/izanami/__docusaurus/debug/metadata', + component: ComponentCreator('/izanami/__docusaurus/debug/metadata', 'd94'), + exact: true + }, + { + path: '/izanami/__docusaurus/debug/registry', + component: ComponentCreator('/izanami/__docusaurus/debug/registry', '49c'), + exact: true + }, + { + path: '/izanami/__docusaurus/debug/routes', + component: ComponentCreator('/izanami/__docusaurus/debug/routes', '108'), + exact: true + }, { path: '/izanami/search', - component: ComponentCreator('/izanami/search', '67a'), + component: ComponentCreator('/izanami/search', 'b82'), exact: true }, { path: '/izanami/docs', - component: ComponentCreator('/izanami/docs', 'd1a'), + component: ComponentCreator('/izanami/docs', '6f2'), routes: [ { path: '/izanami/docs', - component: ComponentCreator('/izanami/docs', '084'), + component: ComponentCreator('/izanami/docs', '150'), routes: [ { path: '/izanami/docs', - component: ComponentCreator('/izanami/docs', '598'), + component: ComponentCreator('/izanami/docs', '105'), routes: [ { path: '/izanami/docs/clients/', @@ -133,6 +168,12 @@ export default [ exact: true, sidebar: "tutorialSidebar" }, + { + path: '/izanami/docs/guides/transfer-data', + component: ComponentCreator('/izanami/docs/guides/transfer-data', '881'), + exact: true, + sidebar: "tutorialSidebar" + }, { path: '/izanami/docs/guides/user-invitation', component: ComponentCreator('/izanami/docs/guides/user-invitation', 'af4'), @@ -183,7 +224,7 @@ export default [ }, { path: '/izanami/v1', - component: ComponentCreator('/izanami/v1', '433'), + component: ComponentCreator('/izanami/v1', 'b1a'), routes: [ { path: '/izanami/v1', @@ -447,7 +488,7 @@ export default [ }, { path: '/izanami/', - component: ComponentCreator('/izanami/', 'a38'), + component: ComponentCreator('/izanami/', '89a'), exact: true }, { diff --git a/manual/.docusaurus/routesChunkNames.json b/manual/.docusaurus/routesChunkNames.json index 848f35309..251b81946 100644 --- a/manual/.docusaurus/routesChunkNames.json +++ b/manual/.docusaurus/routesChunkNames.json @@ -1,309 +1,356 @@ { - "/izanami/search-67a": { - "__comp": "1a4e3797", + "/izanami/__docusaurus/debug-ab4": { + "__comp": "__comp---theme-debug-config-23-a-2ff", "__context": { - "plugin": "1457b77c" + "plugin": "plugin---izanami-docusaurus-debugf-75-018" } }, - "/izanami/docs-d1a": { - "__comp": "5e95c892", + "/izanami/__docusaurus/debug/config-71e": { + "__comp": "__comp---theme-debug-config-23-a-2ff", "__context": { - "plugin": "1ad66b9e" + "plugin": "plugin---izanami-docusaurus-debugf-75-018" } }, - "/izanami/docs-084": { - "__comp": "a7bd4aaa", - "version": "935f2afb" + "/izanami/__docusaurus/debug/content-7bd": { + "__comp": "__comp---theme-debug-contentba-8-ce7", + "__context": { + "plugin": "plugin---izanami-docusaurus-debugf-75-018" + }, + "allContent": "allContent---izanami-docusaurus-debug-content-246-c61" + }, + "/izanami/__docusaurus/debug/globalData-1a4": { + "__comp": "__comp---theme-debug-global-dataede-0fa", + "__context": { + "plugin": "plugin---izanami-docusaurus-debugf-75-018" + } + }, + "/izanami/__docusaurus/debug/metadata-d94": { + "__comp": "__comp---theme-debug-site-metadata-68-e-3d4", + "__context": { + "plugin": "plugin---izanami-docusaurus-debugf-75-018" + } + }, + "/izanami/__docusaurus/debug/registry-49c": { + "__comp": "__comp---theme-debug-registry-679-501", + "__context": { + "plugin": "plugin---izanami-docusaurus-debugf-75-018" + } }, - "/izanami/docs-598": { - "__comp": "a94703ab" + "/izanami/__docusaurus/debug/routes-108": { + "__comp": "__comp---theme-debug-routes-946-699", + "__context": { + "plugin": "plugin---izanami-docusaurus-debugf-75-018" + } + }, + "/izanami/search-b82": { + "__comp": "__comp---theme-search-page-1-a-4-d6f", + "__context": { + "plugin": "plugin---izanami-searchaaf-832" + } + }, + "/izanami/docs-6f2": { + "__comp": "__comp---theme-docs-root-5-e-9-0b6", + "__context": { + "plugin": "plugin---izanami-docs-18-d-414" + } + }, + "/izanami/docs-150": { + "__comp": "__comp---theme-doc-version-roota-7-b-5de", + "version": "version---izanami-docs-935-49b" + }, + "/izanami/docs-105": { + "__comp": "__comp---theme-doc-roota-94-67a" }, "/izanami/docs/clients/-7b7": { - "__comp": "17896441", - "content": "f53bace1" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-clients-f-53-ddb" }, "/izanami/docs/clients/java/-37a": { - "__comp": "17896441", - "content": "858bfcaf" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-clients-java-858-68f" }, "/izanami/docs/clients/java/cache-625": { - "__comp": "17896441", - "content": "d98f6b02" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-clients-java-cached-98-38e" }, "/izanami/docs/clients/java/error-handling-d1a": { - "__comp": "17896441", - "content": "95f95e10" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-clients-java-error-handling-95-f-d67" }, "/izanami/docs/clients/java/sse-4df": { - "__comp": "17896441", - "content": "aa63221d" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-clients-java-sseaa-6-ecb" }, "/izanami/docs/concepts/-580": { - "__comp": "17896441", - "content": "39cf9c2b" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-concepts-39-c-d27" }, "/izanami/docs/getstarted/-9f8": { - "__comp": "17896441", - "content": "55940994" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-getstarted-559-e25" }, "/izanami/docs/guides/-7c0": { - "__comp": "17896441", - "content": "2e7f27e2" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-guides-2-e-7-90c" }, "/izanami/docs/guides/bulk-feature-modification-f37": { - "__comp": "17896441", - "content": "9af8677d" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-guides-bulk-feature-modification-9-af-8db" }, "/izanami/docs/guides/configuration-84e": { - "__comp": "17896441", - "content": "80987477" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-guides-configuration-809-de6" }, "/izanami/docs/guides/env-contexts-3a6": { - "__comp": "17896441", - "content": "28294f75" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-guides-env-contexts-282-25d" }, "/izanami/docs/guides/http-calls-in-scripts-d9d": { - "__comp": "17896441", - "content": "391f84ad" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-guides-http-calls-in-scripts-391-d90" }, "/izanami/docs/guides/import-from-v1-b45": { - "__comp": "17896441", - "content": "52d2f9c5" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-guides-import-from-v-152-d-389" }, "/izanami/docs/guides/key-configuration-fb7": { - "__comp": "17896441", - "content": "64236327" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-guides-key-configuration-642-b12" }, "/izanami/docs/guides/local-scripts-122": { - "__comp": "17896441", - "content": "45bf6ac8" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-guides-local-scripts-45-b-d3d" }, "/izanami/docs/guides/mailer-configuration-b6c": { - "__comp": "17896441", - "content": "4e45aa8f" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-guides-mailer-configuration-4-e-4-c62" }, "/izanami/docs/guides/multi-conditions-feature-39f": { - "__comp": "17896441", - "content": "cbc90340" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-guides-multi-conditions-featurecbc-67a" }, "/izanami/docs/guides/query-builder-b4b": { - "__comp": "17896441", - "content": "f7b0431a" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-guides-query-builderf-7-b-4f8" }, "/izanami/docs/guides/remote-script-e46": { - "__comp": "17896441", - "content": "5ec15e41" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-guides-remote-script-5-ec-5c2" + }, + "/izanami/docs/guides/transfer-data-881": { + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-guides-transfer-data-8-ec-d50" }, "/izanami/docs/guides/user-invitation-af4": { - "__comp": "17896441", - "content": "2911da6f" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-guides-user-invitation-291-6dc" }, "/izanami/docs/guides/webhooks-821": { - "__comp": "17896441", - "content": "1858d382" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-guides-webhooks-185-6d1" }, "/izanami/docs/usages/-f2d": { - "__comp": "17896441", - "content": "f09d0f18" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-usages-f-09-ee0" }, "/izanami/docs/usages/contexts-7d8": { - "__comp": "17896441", - "content": "b35c709e" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-usages-contextsb-35-a79" }, "/izanami/docs/usages/features-06a": { - "__comp": "17896441", - "content": "1756af0d" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-usages-features-175-9e5" }, "/izanami/docs/usages/organisation-d57": { - "__comp": "17896441", - "content": "2524d653" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-usages-organisation-252-2d5" }, "/izanami/docs/usages/request-944": { - "__comp": "17896441", - "content": "d86837dc" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-docs-usages-requestd-86-68b" }, - "/izanami/v1-433": { - "__comp": "5e95c892", + "/izanami/v1-b1a": { + "__comp": "__comp---theme-docs-root-5-e-9-0b6", "__context": { - "plugin": "4cb46bbe" + "plugin": "plugin---izanami-v-19-ad-71a" } }, "/izanami/v1-0b2": { - "__comp": "a7bd4aaa", - "version": "7329b9d1" + "__comp": "__comp---theme-doc-version-roota-7-b-5de", + "version": "version---izanami-v-1732-153" }, "/izanami/v1-995": { - "__comp": "a94703ab" + "__comp": "__comp---theme-doc-roota-94-67a" }, "/izanami/v1/-4b6": { - "__comp": "17896441", - "content": "38c1ccfe" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-38-c-105" }, "/izanami/v1/about-92c": { - "__comp": "17896441", - "content": "404820e5" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-about-404-3f5" }, "/izanami/v1/api-4d6": { - "__comp": "17896441", - "content": "8c817def" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-api-8-c-8-676" }, "/izanami/v1/architecture-13a": { - "__comp": "17896441", - "content": "cced1e3d" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-architecturecce-931" }, "/izanami/v1/authprovider-05e": { - "__comp": "17896441", - "content": "ea391ed7" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-authproviderea-3-644" }, "/izanami/v1/clients/-b28": { - "__comp": "17896441", - "content": "915e538f" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-clients-915-d28" }, "/izanami/v1/clients/cli-f96": { - "__comp": "17896441", - "content": "3cfbbc0f" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-clients-cli-3-cf-9a1" }, "/izanami/v1/clients/jvm-4da": { - "__comp": "17896441", - "content": "44ca1fc6" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-clients-jvm-44-c-096" }, "/izanami/v1/clients/node-afe": { - "__comp": "17896441", - "content": "28ea13a0" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-clients-node-28-e-d45" }, "/izanami/v1/clients/react-58a": { - "__comp": "17896441", - "content": "cdfb9db4" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-clients-reactcdf-b19" }, "/izanami/v1/clients/spring-starter-dfe": { - "__comp": "17896441", - "content": "7a3092a3" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-clients-spring-starter-7-a-3-7a6" }, "/izanami/v1/configs/-bf8": { - "__comp": "17896441", - "content": "3e4b204b" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-configs-3-e-4-2ff" }, "/izanami/v1/configs/api-a47": { - "__comp": "17896441", - "content": "6a24d81d" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-configs-api-6-a-2-69d" }, "/izanami/v1/configs/springconfig-1f0": { - "__comp": "17896441", - "content": "61d10066" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-configs-springconfig-61-d-f30" }, "/izanami/v1/configs/ui-18c": { - "__comp": "17896441", - "content": "144ae2b5" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-configs-ui-144-a34" }, "/izanami/v1/developers-811": { - "__comp": "17896441", - "content": "7a055ef3" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-developers-7-a-0-9c7" }, "/izanami/v1/events-f8b": { - "__comp": "17896441", - "content": "dfda2e39" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-eventsdfd-d43" }, "/izanami/v1/experiments/-0cf": { - "__comp": "17896441", - "content": "e90300dd" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-experiments-e-90-974" }, "/izanami/v1/experiments/api-5e6": { - "__comp": "17896441", - "content": "e157316e" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-experiments-apie-15-10a" }, "/izanami/v1/experiments/ui-22b": { - "__comp": "17896441", - "content": "309e43de" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-experiments-ui-309-5ca" }, "/izanami/v1/features-c6a": { - "__comp": "17896441", - "content": "868bc92e" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-features-868-d79" }, "/izanami/v1/features-flipping/-ab5": { - "__comp": "17896441", - "content": "3651c730" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-features-flipping-365-731" }, "/izanami/v1/features-flipping/api-e84": { - "__comp": "17896441", - "content": "2c55d6de" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-features-flipping-api-2-c-5-4c6" }, "/izanami/v1/features-flipping/lock-4e5": { - "__comp": "17896441", - "content": "37d37b99" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-features-flipping-lock-37-d-be6" }, "/izanami/v1/features-flipping/scripts-494": { - "__comp": "17896441", - "content": "6b55a23b" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-features-flipping-scripts-6-b-5-325" }, "/izanami/v1/features-flipping/ui-401": { - "__comp": "17896441", - "content": "efe36f9c" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-features-flipping-uiefe-4c7" }, "/izanami/v1/getizanami/-68e": { - "__comp": "17896441", - "content": "d9a19508" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-getizanami-d-9-a-7e0" }, "/izanami/v1/getizanami/binaries-206": { - "__comp": "17896441", - "content": "83cf5a0e" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-getizanami-binaries-83-c-595" }, "/izanami/v1/getizanami/docker-775": { - "__comp": "17896441", - "content": "dc8f53ac" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-getizanami-dockerdc-8-cc8" }, "/izanami/v1/getizanami/fromsources-1f1": { - "__comp": "17896441", - "content": "f5ac983d" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-getizanami-fromsourcesf-5-a-707" }, "/izanami/v1/keys-eb4": { - "__comp": "17896441", - "content": "12625af8" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-keys-126-146" }, "/izanami/v1/metrics-415": { - "__comp": "17896441", - "content": "f3281aa5" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-metricsf-32-a4e" }, "/izanami/v1/performances-22b": { - "__comp": "17896441", - "content": "d5980866" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-performancesd-59-76a" }, "/izanami/v1/philosophy-e21": { - "__comp": "17896441", - "content": "62eca57d" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-philosophy-62-e-298" }, "/izanami/v1/settings/-3c2": { - "__comp": "17896441", - "content": "8a163022" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-settings-8-a-1-b9e" }, "/izanami/v1/settings/database-f13": { - "__comp": "17896441", - "content": "54014a70" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-settings-database-540-759" }, "/izanami/v1/settings/settings-0b0": { - "__comp": "17896441", - "content": "604919e7" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-settings-settings-604-766" }, "/izanami/v1/tutorials/-d91": { - "__comp": "17896441", - "content": "0f98d465" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-tutorials-0-f-9-bed" }, "/izanami/v1/tutorials/oauth2-4ba": { - "__comp": "17896441", - "content": "404d2a01" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-tutorials-oauth-2404-9d8" }, "/izanami/v1/tutorials/spring-94e": { - "__comp": "17896441", - "content": "cf997756" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-tutorials-springcf-9-f2f" }, "/izanami/v1/ui-95e": { - "__comp": "17896441", - "content": "22a808b3" + "__comp": "__comp---theme-doc-item-178-a40", + "content": "content---izanami-v-1-ui-22-a-7e8" }, - "/izanami/-a38": { - "__comp": "c4f5d8e4", + "/izanami/-89a": { + "__comp": "__comp---site-src-pages-index-jsc-4-f-f99", "__context": { - "plugin": "a5a0f36f" + "plugin": "plugin---izanami-49-c-56d" }, - "config": "5e9f5e1a" + "config": "config---izanami-5-e-9-485" } } \ No newline at end of file diff --git a/manual/.docusaurus/site-metadata.json b/manual/.docusaurus/site-metadata.json index 932b97e7e..7a59194f7 100644 --- a/manual/.docusaurus/site-metadata.json +++ b/manual/.docusaurus/site-metadata.json @@ -17,9 +17,9 @@ "name": "@docusaurus/plugin-content-pages", "version": "3.1.1" }, - "docusaurus-plugin-sitemap": { + "docusaurus-plugin-debug": { "type": "package", - "name": "@docusaurus/plugin-sitemap", + "name": "@docusaurus/plugin-debug", "version": "3.1.1" }, "docusaurus-theme-classic": { diff --git a/manual/docs/04-guides/14-transfer-data.mdx b/manual/docs/04-guides/14-transfer-data.mdx new file mode 100644 index 000000000..500d77d78 --- /dev/null +++ b/manual/docs/04-guides/14-transfer-data.mdx @@ -0,0 +1,61 @@ +--- +title: Data transfer +--- + +import { Note } from "@site/src/components/Note"; +import exportButton from "@site/static/img/screenshots/export-import-v2/export-button-hover.png"; +import exportForm from "@site/static/img/screenshots/export-import-v2/export-form.png"; +import importedProject from "@site/static/img/screenshots/export-import-v2/imported-project.png"; +import importButton from "@site/static/img/screenshots/export-import-v2/import-button-hover.png"; +import importForm from "@site/static/img/screenshots/export-import-v2/import-form.png"; + +This page covers features available only from 2.5.0 + +Izanami allows you to export and import data from one instance to another. + + + To import data from an Izanami v1 instance, check [this + page](./import-from-v1) + + +## Exporting data + +Izanami allows to export data at tenant scope, you'll need admin right on tenant to export data. +Go to tenant setting page and click "Export data" button. + + + +You can either export everything from the tenant, or choose only some projects / webhooks / apikeys. + + + By default, Izanami won't export users rights, since some users may be missing + on target instance, which could fail your import completely when using "fail" + conflict startegy "see below". You can however check "Include user rights" if + your users are the same on both instance or if you don't care about a few + importing error (with skip / overwrite startegy, Izanami will import whatever + it can). + + + + +After clicking "Export" button, data will be downloaded in an ndjson file. + +## Importing data + +Once you've got your ndjson file, you can transfer your data to another Izanami instance. + +To do so, go to target tenant setting page on your other Izanami instance, and click "Import data" button. + + + +Indicate exported file in form, and choose a conflict handling strategy: + +- Fail : will fail and import nothing on conflict / error (for instance in case of missing user) +- Skip : Izanami will import everything that can be without conflict, and skip the rest +- Overwrite : Izanami will attempt to update conflicting elements with ndjson file data. + + + +Once import is finished, browse your tenant to see imported data. + + diff --git a/manual/docs/04-guides/index.mdx b/manual/docs/04-guides/index.mdx index 0ed5a9549..a020e6df7 100644 --- a/manual/docs/04-guides/index.mdx +++ b/manual/docs/04-guides/index.mdx @@ -17,6 +17,7 @@ This section presents several typical use cases of Izanami usage. - [Create remote script features to unlock full WASMO potential](./remote-script) - [Making an HTTP call inside a WASM script](./http-calls-in-scripts) - [Notify an external system of feature updates](./webhooks) +- [Transfer data between two Izanami instances / tenants](./transfer-data) ## Administration diff --git a/manual/static/img/screenshots/export-import-v2/export-button-hover.png b/manual/static/img/screenshots/export-import-v2/export-button-hover.png new file mode 100644 index 0000000000000000000000000000000000000000..ffea77a950a96a302ec02e921d20b6f52dc643ce GIT binary patch literal 93729 zcmcG#WmJ@3*glG4fTTzxARr)(NXU@Vl1g_-*HA+XgMuI}(k;?0-Jo>W5CTKj(A{-5 z{@!=3bJjW^&iU|v7E5NyJkRXe``-6;-Pe8Xz;}w$IFHC5p`oGSyp@qqMnk&~UfvzV zxC?%XQp?@}zwS6GON*fu^*>!hLwknyR^pASThivVtEQ^PwaBhhHXgRAKkp&)vmeS5 z?>42{a^8fp^~JUFNFw-_6HOv#p_68Er4xM#tvm@iy_}f_OrD~M|EQrTm-Bw1n(y~SXXAQO zUYPz!M7JNWO++`etX6)y#C+&Tj`G(P0Z&_areP^g@o%`Oy5@`6nx&NE-q)OiIG-8` zDslxCsbdU;UETK{z0s(<%=1af3tqc!f(s^-w|_o9#LVZh3Z}5WarTMR(hhjMyIkf!(RLnKpM=@7 zZatDvPd*xUU{?4EpH>bVruACcv!-$5L#UHu#vr0=Bx|elh2=~Xy%O2{Yo?H$XD_X> z^~_nw8zG8HsM6On!jl?aD1!0ZMfRC-uDSTD5sM3BnLD2tSF=J2K1M@740uC`7F?f< z+446g_=?aE-+$oX>cA$YAr8NpTtQGEf?JmfMpYD=)YB$FQQnuq5_1P@eKJml1%n5k6_5#yUZ8op&c70qSF$2{UpS@S28#WCLZhA&S9Yc-VY_fh({yGT9X z^>D6z-r6TD>~lFuEr($wao0=1y3gPwLBN@cg<-Pe{OxDmHTII!&r(g!H^L+CS)VyW zXifb-DwYo_w7W(nOma7+e12JBnK+ipHB!Ztn#yWl`K0=9;$%f%Vrgx^hI<1|mWZ6!~np@Z~`u*}S?uoGx z!=SsIUgRrle|OgIqLS#(6Ti_U!w9DSacvg{%}2)ET!s9u;tfHSHyAXmQ>9l=jkLtR zzFRw;V$xJTT1^$;l7(d|fG{gBIKL9w>IjnGnp~kS19v{$W2=Ap-*9}JpRM0nd9flf z6}n5~SH9i9)>+Rbp5?Bhevrlbsd>ghET>bNT@@nR5?$G0g+)hT zrc?KER-pufZf*7!4;d2{L4S`x?2yOG!@mf*?xRHV^7AatPqPWCf!l}LZ@4oHEiNub zQ^|f28~SOLo1ZV>bq=%D+Y+t9DvB3<_BA;4;CNr1Ioh#Cw@|(K{6q9aNF%Y&EcQ>d zIL624^+Lh(2bv8f>&dBX0(N9Hv(PxcWP)CtAeSUU7lqZT@FRLZm|66=m&<84Q6_CZ ziUfS<-0>gI-cyIgj!?>uMZGSp^uu?|LQyRNI3gaK7Ux5U!ots3<~`w&=YOhDghu#)c}jLu)&`;=^|YV&sYBQkD>a#j*CdSHo53%M-^omAovLi2clBWQvWXAt5f(3WlJp7XE6=gbWRV>~ z*T#+tTLbu!bA|TRS#0WwciXqQZ|cq)TQ`y)=Rbc*6BiRX-FR5V@E|NKEJetP_rRKp zEPbfj@*rzrVSz%Vthji`I9%9FEeEmoDELv;&R<3J&FFyw)fa@79qX{#@ayZxI9?KKm>Rh9v zW82zW`xE%{OYZsspyl#(-)*H}23#4x%V;_9}tZT-HH zq{4^({F&$2x%z^?4==t-efOeQFuKNdR)723AWd2@37fFX<=?cH01r#6*1@l5Cj%nz z>&viISIwB4y-X3=%wgAAcx)t$AJr5ep`I61u92CG5$e|4unK?s2j5oh+t`qT)Ujv zdQ&GkIV?7f7lc?V9J}@>qQX7 z=9L7ze>z*pWQ|%Kc{Hf!Z>_0n=(6GDh(2@M{q!(6C}_-17apDG8z@#3_tNWuafIa2 zZbS3Ydu{5`( zdFktu(HlocC$kv=M8{OXz-ppA!}j0DbW-?Y{YgSjqr}4vQt2fb<$nGJ+tBS9{TU@T zxK&F#j%1spSIztW{(kOu+(+08dv3Zur<&Db#Eu2gznHXQ1yqb6t`^*QD8)`I|ieJngE;4Lqg4GQkXd<1XHqS3c zWoT-enVM=KA#rbZQD_A`pRf5LG(t8ud-M_2sTMxK?%WRxTy<#wc! ztu$oT(bnd0=a+Wj_EpjGawMX#E0Q5xfqY8t%M(VWr?1`Sv}Xp1T%FL6r+r=Rc8bGW zD}56&{HeBZXo!zKdKQqnZm| zMm7BEf>wvW9+cET{&g;i@h`J|cp%vrRD>i~w^QAEZRhT`TGPFdX`mBBnh0T)t8I93 zyLzE2%+Y?|z7G@hpkl2oEt%MvaItXGook&3mOL?N;65rI~0|=G9tVgl&O+3>&X5S^W9)r!FCTa&j^e5z#|j z${!71@Pv1NOxUoqv!}c^`k)9^T%Q^F@%u;Ag|Z1(ykd5puKn3unlJJ#EgfA4eQ0FQ zGPw649s$;M61MsK3!r#?yVB(6G&s6R*DFrVsW!$0t)I09BYYnWmYrub(Dtjt`C&v(gcNS}Icqti=M9 zbc760F(7a>S=pJ{nVH$S$V2t@^)+w?Y?M+W6I)gf!0^&IEKlsV+mQN-&83^+iSXxs zNWP0k3ipJ;!pcfss_>K3;f?@*JR*#H+%x(|XUsiJ9piaBsY$*8xa#U^$K_Rki_Bho z32kjnPb1O))#O5!?<)o~!)vGIdTRKSDxW@m>QOw%R-!3rc1W5&bh-u?9<|`U`)Te- z!+@HYXES!hz~a7$K@*s>mx+A_g;zmlG7CAQ>pP7%+o9vLIXO9h4;Qn3{C>uvR6IGU z4LMbLPSCK6#BwNc2nc^#xo#s*9@$#DNn+srM#ZUNf1gEM%-_V+v@eAxabPujTOrd( z`GeR(c`o96`}3{oDn4F@F&o~SBRhEJ<5Q5fEy(J)up{A2@YMkUXUKH7xjKQEx8@Cc zXlsi1x+R|mpQop%_A3Ab07NipR2Y=rl1CEGQQH?)bZ{Gvcc`pcsx549E#IC;v+(a}P9eGQQ%EhQl(B~i*cHG+&vO!VYh z%rK>+*1Yr?od>CExL0YUp8o*#)G*@R($*Fmaj=e#4u@{F=;H6@pUuApf2GZfbFAns z?YVh3dV?hJCX zWj+u>Apmkvn6OAtSeThs<&Ph?%()>cJFAl6>Yy9k9s z0cHBJXaC;eJz&zFo&p-u?6FfbqfIvlJGvYW2EzQ)AgmI-k%u5qY;UA0%FAue9T3j& zW>BMpU5qW|?CcDRg?EPEblEj>Rb%Q1A4%H3bmih`_QcVWnUysJ-|@OR`c0chLt{?P3ufl-9z>57 zvt?{nPk%r3taO?2m6CofY^@l6!NP{Oi)RS(a$ZnTpLks&Aa_u&JaqkalqO9zOBTVK{bqx)0ZvWsinizTZpYZ(>d z4zJF4iWe~@mDoviSCq*nCMKpqb^|qxO17fjRnw?0Wxm?ig7S)r%*^beFBQ#VE#I>l z1^D@=1s3(U%QX}}A63CGLyuYZ-2_4Q>4*^~CdEf>Z7D1+4VNl6=u^*8|K`N*n~93I zq=X;Oi0P!Hr06Ox>PtvT44bC1#ol*xcBrVT+5y$vS`PF!>AvE%v;omi=^z^L)*xEH zc(%d(Bq@p?Yn4Orcj2~;eAgI->x z!n27+tekgTD>zb<^viR!LH%026hRNet{k#JR$I~~-*K4cd`Jp*pCM;nVSeUSWQy!S zc8o}c#r)6Q6M4OI`=Lm<+i=UYuM}&)qENq9Cd=L=`>e-6l&2InHBE#}tx(YM_|QB8 zq^HEDCXs30czLjQ#;hug(u_Xc`P5LAn$lhRh5P5PEnO?9<@FLm3EkRsS$NSL#I;{HSJh)-DbU%V_+mF5&)TYx#G}Nj?b_~iX#9Xp*Y*IHeB zcf^Wr%eHnJ)VaT{)Sh^9S&h69 zlhN0oIWyql;TuvbEk0VBFfYZVad2>eT{`LO8yslsb=JJoFj(E*rXnI5jXeik(GR~T zI^MFXOy>Dd@nC?2UKfQ`Y^$r|W1~g0)iWks4tV}WqZQtcIeF`Osg*Ypa3lESH6rvz z^MCT6@|rXPF^uRnD|`0>8w-ab`89-$e?=UDSDe2tbLrH1C=zR;R{~7&JY)a!IFE_|r zJhe5oeJT8P<@MZ_@&u^^t1ElTpuk=xTE6zaMr0|^6#E8ZN!V0H1A&!uB@z7mY2uLGw|_Mb#}@Khl_Y4-5{Ei+3%cBp8!-48Hn#3BZP z?l&|vWWsgS*vUp?VuF;Jyko7UsiBdLSbIuIN#uAxd3ow2a&>9tdFWeOza$|~+hBfB zh?tp}4Z?K295zo&04wLXY1s$4u|k^?A0MBXyuEbukMF~^i9GAPhKBl7oikl2Gbtyh zvc$wGz|Y+TXX0Nq;qoZvyNGEhb4p^$4q!f^47j=(l$I#qdH$7D@tN^%1#+G zKW*|PFdicZqIlI@I|$L=)7h0pE`W#@KHAvWuw2n6M=xWwuKU@WG9vUK-AMH^2Zdr0 z(vwQx%ia>vIvyUh%!#?V+P>JKGB|gWzr8}bOuCz*npR_l)XisVZ8reHea-BxDrM$x zNpUH*mg|8pjk5tW z&2tu(o|b7kcHXcs;;e9Vlx&;jn&lHl`Fi;FRk;c~n~-huDW)8i{{D5q4k9fM*@gF1 z@L6n6i&zVBufgw98)pTct*f#Gcn`r?<*pg13@%GgVkcgiPxZe9_1a@`Ityus9sYQa zVU?b`+FBE?iB`-fc$C5tCypB@moBV5!=Dxm;0H&|_p#9L-d-qnptaiF2q$C*={JKo za*;R;e8Q;89KF06Aby}BDJi*i>i)25L#+Qxt6%H!u}l6@gNGf>Rq?wQAz#1#Sk^A& z1zf(wxT7dxRgeLaHRUG2A;JNuo3L;SJ7oHzi)~h0-G#VMN0CIdc37-=a;)5WckmDD z@sM(EIY(+aouzc^hrOKB_lHLJu15a?wB_^vaOHml(lIqD{%hNH?(KCzed>-k7Zg9# zK%aC>Oz^V_6#}Hr=PecClnmFO(%qd3_^UL3)?xYaVc^?BONBmLg$jMCkjJ~|!g?8O zws}__I|R1D=(4i05v+vv0+-bUHz3g0ZfdSQ#tBY=>mlk~l{sVM=^nNscpre;_ zF+kJIc}>lM|9YzA0UaGd++=yQ-KEL;;QeBq$xCDP4GxX5)BOvJlw5I*t8HjnK>EN< zVqYXipEkM@?K3}aZ>Q2NnKy&$0c2@D_+q4DaFUQhy=9K;zs0U~sW!HdhQhT&(JIhc zo-6u(md!yhb>P5Y36{ zizSNmDWR^8hFqPKDObGA^L5J!lR$}u+{1!`yn3c!JhjkNNsPU>v!emEO?!LCZ{NOM zb8#`%_nzrbb=7XHyEDJOus%Oega0TYF(KbN?_$jXO_v4F6_11@HmExYD$U+$!ljg% z4Mbwu%)Fvps$Hd_&^ljFA0dMjSvUEsSj%IFYxdxUsc;gfr3 z#|#UuR)yP|BcS1-YahKMm-Ww(sN=;p9P6-`w4YY7RFb~aCGwdg^!gEWBNqoDePd2U zCh5MK=@ZbuI}8z3Su3FLO6yn6_7;}(wBI!b5`w!TAS;`yWjBVR7e_YC#-+uPAWm(i zlb5GiATfIKDok1}0hZLu5j)_Oz#>jkimUVdgC*)`Hp5&_tKMx9Ng zo}OOi#`0hZBIZ@RC-taJ4Z*NzZeG#3<54WA&;i1OcEF!MX<3z7d3kw1OMg~ZyBSVN z-4d|PcdkhqH>Xxg?$f+B$U#KN$tNDirB2Vtoh=s)Ik_J5eBnj?F}@Lm`{eXG3RNvM zJLg>Ii*A@AuX{5~mu$`q+L=8I=$pn@lf&MLqjQ|lug~QzEy}M|=#MpaDe2YhcDO0z zE8tTsm>Sw@hW9>x3J%#NRktfJNZx);6UB*5)0#2H2_`@IM76P^rL^&RXDG*$@vGHe zptS^6GI?SQt~C`##IJ};a>0BWM&RG^q_zu2#5URNf6jqW*s4vLN#-672KQV$iFjcZ zbRmDO#O>5E;Re3hVuS{Z7=gLvBu#>Nb-V1oLZ*aBEgpqB`OjQ!QNt-v47z0n|E^Ea zwk;Gcu8&;GX$;s$?Vx`+W&#zt*3o?N?r$9%<#hG7pHrzbIk&?%3Yu2X9t-j5AeS$X z98=yX!rJE_`ePturRr?8ZY#jzhA{d~r4(x3+T30oR@OdCpy1y0 zQXKUAuQVfU(O6X>1Y(n6y3h#^^)sYNTYX%=Q*xtND zzp~1P9bFO`O={drty}jCNK+ojKX-m1qU^^5p473cj>03LW11$c-!SeMaeWGAb(>E2 zGx{2iJej^=zJbwK(Io$ws(%^Glb|Xv;Mu^NY$S8hMF1MVx#Ex!gx6VhkO=hs*6ZR) z2mPl@>j%fImKh|j`?WVuADs@ML*oyLa8Qa2q-`j8v_`h_adH3q3i&OobC` zJ9B_%>S+uEEvOENqBN~1zBT(%7UXEw!4y;B`eZsBsXQV0KWlWAFdPz|&XjJ+-i3AH zyZR3x2oGP2QvdrxXdXjT`wLb4u@9x4lbCHaU6URkob@X=8%s1g0xyGEVcJ4;AyF|D zWQxQ_sX{hr!P%5>io^>gvOlihV9CX_ew`{(`2G$FR7O?^a&m!$#sQmi;WD11pJ^p} z&#Ig}54-oZhTq|deXUunLTa0ZrmY3YM-+c%QcZ(izFA(M%Wq#*r$d zD{TFmCc|jUp$9>p2+^)g1~*|-k%(a!DHNQ~(d(V<>`zxwHg19;b@s%Ya}aw#c&>JJ zvOXO@q2HfqIpcDuvMsvVd0af6b#dj)Zf!r8WK`+-DDT`Via!{q!x&0^nGp5a>>IW{%FOThe0r9V??;^x6tCuf;R2_| zZ-v;p&6~>;TZf$Le06p*Rd%7%0_o%TXUk6L)A&AhgUOTVAAP}O^kvrSGo$j)YeOz7 zK7?i!VX1i)+gTw7`CD%1)ob4IWt}ke>D@U2)c{w+*kO_(4pEUB-_?I&oe$eU+SBs0-VA$JXKXtm46f=a~JHZNoBS z{cZHO-f3|U+TN*7q(QrNdsPd#ryy6|9cOO|#2oKu{(qkfvgwOw|Nah4L2vH-uYm>o z|J@cA`3+xW(AMWoVM&SmkHp(?qoMiU_4xnlAoD@H6;QzS;Qqbe|6ct6`t*M;FL2xc z-IVr!;F0!n=!U{APER0QRr}xn8zq__zSzC06|Vlfbsd83(mi+YVHfvh)C_8!iC^vU zMy`zMQvUbGIrV$L!JF{VN%;3O4>RcuAY(7NMK{mA+i)K%&Cz~~wxGZ+$mLi)v+Ep& zy7Ev!^x39&)lk&6(-(u8YIg{#PSA2*DD zB8+bB@pBH&FeZ=XDN-*#by_|yG_8OB&U!|}S-R+a?7w0BXqpZ}JAE0xr+e75_n1W( z(_6Fo32=&F+fu7t>t<`5cvBTl*#A1BoyLvyIR8py4(V2HR}_>d@t^H|KyFU|NDwMy7cxrZHxM*R9yNsPx_mlmEkn_cq!tlq4{^pd1&q!VR&JA&wYfzYh90^0sr|(ouf4I%MXE_!uPk9n0t67jNb1 zHP|G7;jpOxAJqJ|{W%+HcowX8zjw5l;F-hL4nY3nJa&9BbvK1&9qukJrg72^8ozI$ zIAm(IF^`YEb-&JZwA`u~0H-QPo9^slcs6NxnIC0l#hWJIbK&!rWc)NDUGVF2^>?hj zCyO)NRAO1ueHSNPDHqRERrjb*JjolZN*V?W3-gWCxc`0WszUFlcPTAbuYz_8gk8SX zVwm1wc!!tqI{(M1m+`vr?y}v@yXRNW;_r{fIJeY#(U>+?uTUKQ4kp%Hewo{>NpM%i~@{ zuP99g63W=*60o;oI1~!b5bGmN_j=)z2PsYJS2i`)rB3%~T2mOaDC-}L5x#Ix!7yQK z4{Q8?JlNQ?(`&R&BH$YZrcWXcrDVeS%m$$~#c{r4c6T}f>v<5F7()*oCe6HyKKS7t zBjUQm?4K9mG1WV=|8EMa`;Ls!3SLqq6YqjY3#u)Xa<~xRfoj^*b zV}1Fzc{tH|Kv(}`^*i=e0k>@pkdSSQs3Q%Nw_enRr3aNe^EnRDC@-_dlIFw3{O!~f z?0CJ^%VtY2soV*HJl9?f7GUdz28PKsFIk=~-v3y}rgTM)(d?iQp5B>p=>pUR%_wAa zCMKzI!~_#q|7>ONJ};_dVWza~dv#O9PUE)(Q#UIop@;bW^1~qWPGbF~I`!8E^{XH< ztDkxe|Mefs7YdK25%d3jHTw%=0)mB$olROP&T;1@drt$tG~*r25^V*&nq)N*UNfuS z^J{B7q(3=D;=@|Ze>ZWyIJ85iFNxi&lmAe>4qZKzH3rG+AR=GL!}U zjiAbrbNz;#q?1!q+B#|g;QkHIN4O>pO_P<_)BWt(A!U-ESen>8Ej~s<0y!}D{`ajl zT*dGF(k&7_6zJrKK%8Oa))kYVpcw!D_?rl{_n$ozWsl8Q%_}YCDw~k+v3r3QBfAAv zKA6L0h>-bDvIR>kMjO!^|EdG@oEr;@i)S0X1VXi-FEEK~;diM2TmI_8=k)XrLmV`% zEiH6ROo7l@3j$VvN|{F~{9DFZq`J}Q)8FcXe&zPhx4v0LpL$q(n`-R&c27=ra_<4? z5;fpq(}u#7tBbERb=4q)wl(>vk9XBh*sZk7kM0A~fJuYb;B|H4 zgu&}V94g3vrr`WtB-ZxlB{ZEY!0 z#Qzc&cE~l34?RJkeld`=uRMs*beN;_%E}Ox$o~E?o$BhTM+yoGSF^P`K?AEjCS0{_ z5i-CZ_;1C~v#8PMe*OBj+!ISJ;If&W>RrpkD6goP0&!lStgz#GvtLxQb;@2=0|WL?||OP4^KfVrCinXi;Jm=31=6VnAq6yu`w4N6^2O6FJh4G zgqYX-{P!O|tgERR9UqU4i2;5TeRg1j5EB#A)zbsrMILemYinySFE2^SFSZJwL`7qF zK?8+6)F0Ol2*Nnn*xZSIrlzK9YHAFTf%yZg2f#c6T3Z?mo0|oQwL=fDs+J};{@1TD z?%fsps$E!_-1d8M4~WqiG!J~!($ib4I8q1jaB*E+U0t1>K|>vAnqUpt*w`8j-ajWe zJ3T!;Ki@yQtgNhTZf;K5PK=Cv0t}joedV8Z+3|32oE;o$-1a`WyYp-Gf%^sq2KxH? zfEhC_Ev>e;HY-c2c>H80WP^b?`0DD)+RDntPG;w`?`PG*LX8HI+i9|2JQqR(okH(} zKE7qg8enc=V$v!z3mvk^Fo;NXTL_$+GX(vH@eQR^;Rf3&UXQP0X{RmJ*K_OZ-JBs( z=@X4!o-Qtxqn7T1GeJZw$m!{mo!Qis6k#Z`8bt7I8&&>RG8oO*0K%Z~)gi(U-@stD zYQ|%u;bex+59ztnVB8T#6x_xTnOjg`vo#4?qA>%jO$Yq~VEMtCQ9)p+^P`P{WC6Yp ztzY?_R)Bir`{$ji>R}(>tY$lr>%+8nudT-l+S}W~gC@2q1zZY%T09_fBM;a2eUv(o z%4eq!yg+I-V6>&C!KPm&3w3M0w+C5|7dgASrV4x2?w-iipkTE;)?@bbFQu8IXTYF9 zv$b-O90r;0iexPG=1!LiO%QbFqRD7%^u9Vj!Xjqf-P@Z#4x``;!*^WijTiDf9{i3% zp~zmDX{H!mU!EN!s*Wg<|)>>AIqrZ@+NhW63|s2m*}N?5@@fm&E-HhDLw2{I7`rg$A|)n0)C zPCE?feNX9O_9F0^&U&2yi;#n~q?FWf=o3c8rw~}q$%(fYP+Qf74|-SFbcVyJ z8nVz+;oCJKy}d^iyz=pa@dK+nQ=m7P@DIwWK48F9RinhxENpCmJxJUi+x_}%)$%OA zxRIQgcx-f3O;uF_vTuf45JD<#q>E>_=z>DjX% zz<44g-f5*bqGuWG5{5|d|8u$7DWDk+ER%ltkzEpXfhz;4BBtGh{zjme0TB=Y zvYY|@%Grb0)AJ%DBLg@D{Ec7`y$>H2zSGNrzJiXnHueK?6O$zhyZWJ7zV)$#-Cc}F zk7Q+J;=odx^0#mT^$`;j6ZBctUv?SJEiCLKodzbPnz;47mLjA-eE8r2ahWW)EHmpX z4ZQ*?@cwcS*yx4*l^@!I(!>K?1o8}6iItLG4;@R3^KEWzX%y*Nl3h6hk4{bcxv;?x zl5rTpq}h~!=+xyQLMb31KqngfQ>_;Ct^-aV zpuDxTw2Y2cOe`WKRlaVnSyd!*I)!f9yW~M&gB~S2Tv&?C=e;M+L z%-{WNIaWwWNKRH(y--^cgN)ztIgJS-OQAeKOS}WagkNw3pl>-mtQ^_31iB>)3u5BM@vqEfpA(#ylr&3b;NajK9UTEX7)+F7%Pti> z&vn+TLoJ2N^igbNOJb*!7cnDIQM73_6&1w9gyj^8m&%LiZqQU1wr$Wi06?Uz zE&K4n!v_zBXG^1^qMDnFM)`V)Pj?gODTD>-W2O9ezFqL zH+s}YqJK)y*~wy$5me(~ZfzT@exQEh%ffqeQ9@MjlIneQ#M z5d=yUs^6S6-DJ|2XS)vll)S#aW>iW6GZ$`?_?Vcuom1Y{mMzp9lZK3p>|_=Wmyy8; zHQ^>#u(D#_A|VQt01HYR@zvX!gPr|0s>8w>d+r*7e(TPR*G|KUzn`DqmoIx~mmmmx zllWh~ejSJJxHg>Wb#aUXqp+)BQpvI}i5%6`0stpXEug+x|e6LuL z;FW}q2q~X!ZERR;IiUvAVCiXTMtuo9NWm%KWdZq{O{>(e5gQj*7=Hb+YCI3P=IY&F zokXPE<`R5dYGFY(w!*9|Gq8`9a}UAh%Ubq4-UJ6q>Sm^#h~B?{4-+pQhhOe>Am`2i z8h-KjXV?3{Ml;qL_ym4B9{}a( zF5Ucu{;)q)qyM_+&cNPeA|as&Wv4M|_QPcDsjRB<1pOg5x25G}92`90=*})H!=#a; z_TuJc$SN%@&B!p>{96L|*eKL6fKNNp`fIYf*xS1q?k&_`UizP(1MX-VE^>VxK+Q}T zq;Y*Jojw#75i!5KCA8XjaVn^<@7)MG?W(FH^K{bS^acnTsrI(y{_dcl5YU|e)g8H$ ztLg~1a~Dhj;F6wB*TSj9Zcv2SP&wJA1ndHwlIia0QA!q`wiU3PB4*bFbO#X>Y;632 zK{3w$@bAkQ(Gs8A%xq?D<;)H)Nr9SP`&TRY#>< za`-XVPzr7B{Lan*&dW^Hh%DG4-qk|ry@s5d$eOZ@4B&7kASeZHee$c7)zw=otRW{h z4BZacZlt8242B1d$`5sS%R-nxxdabUm~PbVG%o%$5R|O2BQ-a znr7}%1-69PjPB{_hAAw-eBl>cRl0|A7!wVid_AQwPto=wC(1diib<<=w>NL@oP+@~ zye0*V$K(AYBdWm9jqkX>^mbcGLR3_=swEGTW@D_dr?)p_h+}Jd`7>X>qH+3A=lzD5 zz(41hJ*9B(lWAZ?Y&`k%(C^!i-@gGl!52ft+1BW?ySnsu_AafPr`#sxNdd_5_Vfk{ zMN09+X>EVG>1vT$r_%OfHh~B1$_smKi1Yd3s=>#-i9EGf4udQ{r^RNaT+`;2j5%xQ58)(5Vc`svO=px;gC- z0mL6HqErZJnkqA3x5oqb>zYwY>OS_iiA z($W$jCc^<(z|X=DdTXLp)@ZR5sZqZF`VAtWXqe!l<%=U09h=YmQhFRwfA7pROu zFB}R=vF*ru_>K4ED;uKIp}%psV_R*28{6po9U6LrkihFaAm0uQ1Oow<7B=Zo01J+wdRh5wPm?>Je?L&!T_F`>i7?n^$VxoXqFKLagu=6_T&Yv{xce8NCZzj9W zOjOwcz2PF|<9-*QJpd4ZJAHc?a9}@tNMpiJtuR!Tkz9EzIG?r97F=!u9Hb!sPghuL z00$9#Chv|hZ{o@31Y%}J*lHw)PCD%G3X`&S z&oke@tg@X5jgLR8vu_9d7w`>G4vvmGpYG0c^KMI4(Z#DV6XEz2d$_@0u(B?B&jQmu zfX1ZQSXY2xAXw6ez)3e4B-zw!n~Il@&(*UE81A)VGL`5Hl#Sj4WKyRGq_lV((eV(# z7)QgQGGOq)R}9hvjzqC@=+6x^6tp2Ty(3KMaLyNy?>#zcP%#Y6vsI#|4N0Z;H#k3m z9RXeKvw}BdA`N5$C7MfFT@Cg0D5o8cFV8@ZKaHT%ikYsl)=*YfzU+(uoNrp#W9~Hs z;y9K1@qF#j65)?Wo$~GW+MPa`MT8+!CMT{p>R6bW&p#ZkzkR|0bddWG?mbsZ^rsmF z8!KvaJIn!G$K06@SRQd_H? zshpXWCA{BB2m4t(WC6|@G9-&zI8TDg%xt+k8USxkXD67#r+iSP97h9esq=B51UP#F zPJmQfMuNj%$Z7{b>20m8onSECT9~DonVF`hriDe$kcGUQTp4-D_{4O*SC^MX9xax9 zS<%oAQ=92pXF!yk#5Xtp*9)L)-k5!Rt%49d@&G!AB&g??Rln+N!qmrn@dP=&)>XfV z?JXA5t=o={jSkIB+lpLC%wC`e6CXL?2jx|a_8<;sQ@x}_+!ouzG6!(`Q-tc==9`z+ z5Qzy1K!q5wItp1b5$n7k{P-ej!Y1YtA|d#D_NH4(^mo+T$i}Pdi_}WH*e(;hrlYYC zvR92~$5V~vPBX}wQ68Su+tMXo*mklY{uLc9Ei3iATj?Fibw!GXpbBhnm!hVoPPonn zN4E|JM6%zk_~TFzbLa~?ud8YU`_5SpM^nZVfcd^1A!OnzEBIo74T+BPWHM&l+)69} zOf@zC4rj`Z7ic{pB3j>4 zvc(Dx4sN)=EpNy+Rs`3m6O)oKq>w=?&3IJy%Lqyy&tV z+*n$QicVI*U}9w^CnFgjLE4P6fs=l@g`uH=@j}+>4sS8}qG~fU=^>B=&R(UdD!Jzb z5i+W(x=0m)nzJpSAIOluYB%9t(XW@Geno?I+X}{x0xblrM~^JFwLXagG*;8mv5vQ* z7ZA9(JUakF0}u$n-i^^Ju7pn40>1t07iWy=ElFMOf2*L78JLg@6eOo9z`|3Ci|u4& zWWad}BO@BVU%Rt6*Hu6jyGqeBFt|CMvbzA+>8UEX)YXT7j9YL!@;l}N(>$KY<-1(f z2lwv-nN+XdZHPa=7JTX<}#5nG0A9ZYEtV1wE?JOLqf272(5tz2vD!VpybDo zA3J@ZNV&W`7+7{Z+nsL#=^coftiHAa0(GW6F;^F}H)F1RvS+ng!f6|3JH-^z!^6!j z&7e4C+d&gzW)biN8=<)2d>sp<+_PANqK_-_;9!@}_Lb$uu~e|g_lDOVo0?!gY~%DtC#;SB)zLZC*R{Y5VKsV za+(8X)jBy)TT9EbBJQDS{7R7N1V9o9^=aPv`ue%uAJS?ZaFAq>+mbxgY^u`s$^#rv zWON#`lagwWpp!0uID5)^d`$e+%V-X0iXJ%f0k$HH9Bu;S3>((ieh7$iIyzrdEodne zq$N1gK3X<9=Jt|O5yznx{s_RWd_$i$0?a)U`Mw$i(17rb;PmzGNpOk7vfsC0a6Y^7 zxu4+4#_mpwbQrMkBzSXncX#W1T{(-0hy+R~YinCgDFH>v$~~n|r*iO%JD{?S*B%>{ zwvCOAY<+zd#PHTJyT8A@TOQPU9V7Yk&Fq16pzpm*#G#~=e?7kgKQ-#;Pp0|vr;VN- zDc%m9($Z5gcHdu5NC2gb5I1*}QQYUxcLkMhiN+mnw0K7}s1k@NZocY*w+yzW76Qq{&+neW?KL~Iiqa?IOCNQiVHcCJ zvDpkwy3CsM$fz0h;=ip;9k}GcSzaJg1B>&(00%8?^Rb^KanIIZUB_~V`U^tjlRI)C z{efja^gnSRXiQ9`C=@YjzBknXyyi&vBFhI{UF&<& zSbIOuZ@&3v-tV1x|9jWCXFG~;uXW$ob)Dx?XFd966B(K3X0GT~=y~nN)!IMa0&-{* zSy&h%Fw*nwi6**1O(XuHi$ENl$?9=e%5Fyv3=G&H@W8zMHIs@n?qY5Nz@hm858|a+ z3Vx#)&acB`4l>R@K2al^6ZO9xx!C%2iKnM$hDHl`CSKmRFRqZI^L(=6$I8lT!~*`p zaU?pBQ!7tdLxYxrq6hGRKR@fqlb=$)IlLWJ!n0ivg|Y8Ja~fC|WS z1%#PV^~($RBU2qBEUU`%=?|0HF**@D2^&$+I4Trhk|hU?fT}0 zP4l_EPq#_GE(k@f`<`Wl5b-%FsmN~P10f`mh{?==|Fp$VzhZ^Rerq&jn(!QST+p zLP1JwZZ1{h+{9MDRP{{m%>IK17pJFt=2mEYVz3*>#GC=tTXLwl#r^^OWwWzs>FEGf zOpJ_j9Oq(YjuubMIEY{m`ug>f(DO`O10KE4pL4=epK7>1j;Agdo~f_wRM;k@y56Pk z-CdMgUR=iBL43C%8m;vw@oLX)j+CK$t*ntw^$ zhc_neX_%vL-o8=4@#sGB&EdsxK<){SAL7g4f7Dj*|3?m`L-pUht%tY&Cywj?iZ6U* z_}1R_?+P_I8sXOPn3%!#sUla8i;ugc*r~2D-&GnS_6j5Adz+t(`ums8xi6Iui>t07=v4|3^j=Y1k|Fm8^uDtZ~zprJa(1RF5?4v~=qHq2W3s*T4w!10XwWHSB@WJx;ujYx zBFlWGq^~$TJG!sCGg@Ex80Qy@!gue^?a?>4e&5)$Bamh@oH2VZxWh z#8}1P$?<-$)-p1(n=MPy*4F3c-OGEJp6ouDmXh*0Ik~p#mx%4^?|0Xf9zT9e%2XM4 z+ii3{E@M7pdV1O|b)%!Rqv^h_o5bd%Xg;g~3<{6_A?isk35puXhqqhXK7jq4#z!i) z@!9FSamqp)6(dDrMfWp5P^6iTq&a0E-ll~D9;=w*<~Et;v}jmpHR9<2v#)ke!2LFViXMmvk5JGJBU)RMw*ZmfTH#T-@BHZ$gTu zTcFDvc|8)3BpSm$PU=iqo?nZRirl-8?1QNFqU2fDe;KpV~f9ygaHT&!`FnTmkGy3Mh;GmbccYa<@K!AT*J8nDzE`XZR$Wjw?G}hPGt*ost z(kVTayNEIM2gQcf zD_%ZJ(UAMJva+((6UjIe=dFAD_Zk`+!hU<>l(Y}c#rWvxftF`_;8uBN)Bn8@Un6JK z1Rfy;D@5*VrGSM>oU#W6tx53es#D$%*o-Mq_JkJ$dTTV|14mY`81;|b#h>D&zf7wq zz@odU?+>I9@lT&%0YoU(y{?;1v4rCf4?h5NpmFWxzW=UP65of<_Iz{t%*w{Lm+70t zxADXFg7$=~w;h8v4S)-XFeJ~|>FM6k#V;l6M%dl@dV7sHQsK?)d|B4V;cl?f(Q195 zOTXgNX|804T)dUu=oiK2tNd_DQuGe@EMFD-2QY?iwDJf4SLLNMm-1r!-vPw+0`m0d zPm_wutlFuE(}D{Ie$V4*zN(Yx&8222y29`bpf6qfWq z^PAg0w}+gjYQW0ax0mY5ex`drQVv}k^0TrSctyu!^-XF2TR*>D+a+`^g~M0AoGgEG@0*Zk1OUvavwhOtg8C<~l9Jt0efKAsnT& zWm+KMSW5Pt!Y5}~^S)we&X+;h$=7B3JPDvf8!~HGEYg)S>n$Vk7TWpk+aFzGK8%Qt zHN|-MVo=Nr&D!4wtcI#W5#?pd8R)z<^5jw1s@cGd1AOvlk9-h1<$Kja^wsYj1>Z?X zM3hB8?QU@xE7EGNXsh~CRrN(~+zqoeh&8Sic9YS#Ihh^z|)oBS&2 zluT%%qB`18Qv%cZ;9%z1A2dxG*Aj<^>y)n0Sqq3*DQh@Y1E? zP|Fy}mLD$LJPRsZP}|+_&Ih~kjt5x3`DVxIkBT}r02j;dcGXZ)(p%T~f*lSQd`17K z7o$Ljq4|}QhrH*O=9D-Ch4D$W>E8QObz9heBC79*nB~@bw>xw}?b#OYnTu=!EH>*; z$3KpDXK!tCcfF(N9U5ctmjRu=|HVF^mi2GWa>a=jMVm2LxZen#ga@#~eHpv$@fu6R z%hS_1v(0yFs;|Zms6#N1*>0x(F^eLDvIU)M%x_7yNC;Q|EU+(9e_Z%gnXGpEwts;C z=KP!@d9R+W_zZ(H-IFJe4QoHhCma{kS}z3rKGI+&Q|orhSnj{oe@kCrm_aaJ;7kH`eVn(#pVrQdmF=n z2v*Cq%^X+Lgf41CwZYoTnqp(og)ZhvW9V*%Qt~TZYh?7i8H)G9o_Lc37l?_DCx54u5+2Q_y*Xv_6w#&no}gy^YBaUVB#osx7JE&ZL9sqPKt zF6&pPoU3(@oe^SfD=&;u2olntefMcp7!U`|SCO|>DHnQ&Dx>Gr5ATG^InIIZXo#`>jB<`32VmAo1E?oX4* zS=0G^lcglxnUW0ki5e|o!|IO<*T)`Jcjzsd-D35RrBt9Ku(PwDJarOS;9i)9XI6Ht zRGh1Ti+LjUJl`JCp$iBW+!#6pqFO%pb%T!$L+R1oBt5zgRUa;iQwW-OU1#;jKfz8D zQ?q~mI=Tt?o~>%cHcf!wLqb00YMPsAnGp!v%_^yT7`fqE4pFej zBgLavsz%CDv@zK}6ezApdeMGU^Xk>7vEGK()^nLJO$=*7BOX1%Cy7c3x8(wz!Y$id zh<+g4-OhBc|LGe%1gQS`Gx_Up)Dt46Rk{*IotNZ7`7UywcwO@Mo`F8Y1&4=r{KXn> zdGoq(rV5yMwfz2l+2UtQe(IqTsqyyWslV@d*5yyWX=!hzBxI;_c$fUOya2%o+CV+Q zr?eD;+~(nG>`4g;jf{GV%!fq_=Zy*Fx&79Eb^n?tnfqkZ5>-F(rXkZmc52YJ$Hc_o z0_u1s*5*h0hI`bmU$RYg|~G?ZV-Fe14~O-?F$@cPSOw6I^amZpXpTFC2E?J zRBvQA*>+KH^(CGLlvw0RuV3|o^V6m`GS;y&WdqqW->KcnbE){&#RT9YtGdfwM||VgoI^ncB@4QIQqS*r zZwbvwp(3_vvSE`C*0X*MSP6vZSz(E@-8th?7q8C97&iRbC|c&4;?aZN=i!G10mm5_ z>=&#AVMY^6d{M+^Hb-%49MCE*^_234hBPeR9~G3UNq6>=lQUj)Vb&7H+yDI{j`}8- z&D*ep$w9EwE53ApO!3y?%p14;$ReQ>XAY%Ea~)cYk7r%=Pfbm&H{!!HxVG7$s?_dz zkaS|M&ia)ejHQWXG0lv7ocFxB8rA*LOl>^{m-g&3>H$=A2BSZfIlYC=+W7Lav`xiv z-^4f9CAaoT)-D<=D$LC-Ko)~#fz3$RekyA2`oZHO%<+oK@@Dctq)g?$Ts~RBRjw!$ zsH~|eXaAAgjbLPSHmnwf8KRbif^D+W;%9FJ>?N5uA3R2)dg~U`yr%*bFnGXgUsc{k zMFZdoIS89;3)p_R3YQPJuhoC+(j9ym{-O|!=;h;(p3p*L--XJJ^wXg2Vi^NpqG=fo;$q@X4+`Sdro3q z$VAT~)+VICY`M0*rDeI(YpRVa)?RO#^harjvAaW0&!cmGv2~|S$plbCFGtMGXA;?u zCp+>ZFP+G-ekG6pTH9M2i(KYkVU^pByp6^|34W87{(wZ>&4%MOBd^j8YCZ`g6Cqdr zfr*(}VUTO%@<;7_J9%-HC_b9%S0Tcaks^7uW$lI?Ef3~1FP)g4TfnE>zTQ5#{&*c_ z^yMp8>Te*(o825Q{C zec-srkFKsFS^b3^ca5JXd0cO3Xvl`0YiVmsQ&bG#&>9@=mC^Rz>Fu%8n}UGgGq-)? zapuOx7j1w2M!<<7i(!`X#Q3;~sEF|1hf{XdRpnLT-uwar0lU9$=&hlFxzG0jF!t*n zipAjXe=R#YIzlxzI~0r8m2cdrFSHuIQTFDJJJc`Q(p#Stx82pdTl-N|vKhIaFBnMG z3(zz@AE8ax8#;*ho_C#{YHeku-h|ZIQ}@^)z~glKP^eK}yr_Imt@35fP74XFz*07R z_LGrD(eB*6b9HUSeWr;T#b~6ok3n%flzG_UFI-rj;}VOl1%frH?R#t&O}I3;^N9K> zT!VV1(^1#=6FogA4nI4i_(5*!BlOj|CQF=cdYW4Xfn5y#fq`SqQ6n~au4_vn@ zrW+gU3woi2Ym1vGW%$lvg>OX7&d%1bgvC0e9zz6cl=ZcF#Wvs0_v@Exshe1ys}x6R zUyI$bo|B(Dw}J*Ftd^12fmHNGLqo%)onf*{0_9;!qdrM5U2MKgxz(vl_l7{U9OlN3tvD$U_Kx(Dam{+D^WH1PV~|r*T}WB zHC{5*sMZz(4Hx@wcYoQE;tZrD+`n%^JYh2C`97FBs9k8k6GHLUiRYGkGI9iQxf#99 z74;Rh&0GR!0!oc>w6!4T$n_vC-H{I6?53_CrKJXV=&?m=ZH~`I%LX)f?*0ig`TTTL zy#1OgVBxEm>U^;?FgjUs%7&+CM9auyiSV=GJH2&l)110vLj26(;E!M$z-VBp7 z`nZ7_wVUdcFOxj9&r{`(%2=_sVs`FFyOpvqcfPB3bzdd;R?%^G=b9L*s8De<5!+J> z6*c7?>t=;jK97>WX!PeCL{|IWJF_iqiLHpYU4C3SuzSxg@%WS59(L8znLOMkBpu9u zm{9tXf$}ijTkY5G%jLR=$hv-3q(jswFbnCr`}e;9{6G^bC$XN-bdr3(xt!zHkFEp8`A}SSCdRUpSk54ph<9qLh`+jwLh|IoyGMR$Ao0WCOqkmwiKHc-xKHB4l97kqPW0w;s5}Iv3 zq~1-C{PN-%#{f{%W@=zL~I?k*M?(jtsKhdR49&|aGxbQc7<&K25s=^c~0 zd(Lr~aas4%wpc(jGmKn=149TGiu{~&HL~8ryZc-!x??uBgimijAy=iX%Ku=;6=Ki3 zW>pxZRBhZvtZj6B5`;xcT%GRT9K4?UA(Ig0 z*S|@suB=VZ%BrcXjglllNX=hgEr?is` zcSqYT3ak5$cSSRYUXznml$BN7zyAQP{lt+BJU3pM^E#>2(+6#>s^tpb%arK-lbt4= zK%|?0+~p}WQf*eAb9Bj6?`&u|N%f+zpn&1>%==@)>vvZD=keg-zTxD-xe=$_h8jp? zjgnwD(Rxc$^P``iq<6S##@YCUgpqh)rfusIjB95nn&pe(Z5R_wDxTcPQ)6G8UQRx* zTlt5>%q&^t7sTKH&ImArhhzRb-uX{~J=05b?u#Ra76YBD`h8rezoib!9U##m+xb<; zE+bF4I2plV8}iXSyIq&H)K%2AlqPhhzW%io0dy}aildDsmYGr5?Pb?)I4!bnoxhS# zdK1B2yQj(pa+|}Z^1#l=IV#%n4zd&uo$)xUel%nDo6g1R3emY8qIAL$NmVKWXnGb~ ze*XBOiBhJf>(ypZV4$=%Bsy8-4@cz1h0|PtP%&MOE?VL^)t;V|m?*!sB3pa8IAT>& zE?w*BaD3z5Sagvk+%J_`Cn#HE(Ir5Q&~3jyspB5o=^)pAY-8sYDtB?3&xr~AvuA{X zqgFP)&^?CqIQ9HcXEs&$)urdN!W??72ix(HXLusy1}Q14ao0GUSF&#Rl7h2Ua~dUyTykfo)HrhJ6sVWt+R1=Ekwlj?JN09W8Nd{ z)cH%}0%vZoUQf==4cZuBJ;$+^jI`e>cic86G0|u9(5XlK+WmQ~Sc8#)p^GKW7s%SB6FSEXbUMDG zW}6R40P{2>_sQ)8QYjxjvR~!puM9rWm0I%GWvDh-F|r$|-&k|9F9ZLF#1p)CSXM?X zoq=^ZS`Tex4G2EDA+@LU0KzgmmJAi?Bx0NOSPtlYHl&k+ID$Pg2(O4 z$Y-$|kI)k=jsIb64=VXv^g}t`ZvO42SL|Yh??V zU($T&PQt+xBqv}#p7Z^?@Z1tg-Dg?ZQS-&5AIY=UAaH%&OdyV zbl2`ym|xP~b~(1$jxY0U7_FF_xjI*86D9R1wdQR*9_FO#l{Tb)A=|FwnEtUSB`Yh2 z|M~dv_0>shqZx&yAheF+;@#jayKBRC8)w9c1gAEnHB?o}*->viX?YgvLWgc$IObup zZ}Mim*c(?IzOC^EbHQh+UeMCg9`}k+?1r91m~n?(#Pz3_Pi}0s^9B4Fu`#{slD&O> zY*-t3GmsC%9accd-WTzN_?qn|(Gi*7wmV%(MMX;cCH;A%5%1r*-A>s*ew39^PT3dc zury&Gs}P!JI2EcWw&pQ$gNp8m+>{RL1VGh(N^e(O+;9tQlx+mn4eMFsKD2#6sTmmH z-!R;~%(}~ItgdPOcXP9LuGLSStO|)8dyp;*d?Y@Baoc1VO2)zxlz$wY=VG>6Xa`Vm zFWO9WCl^CJ;TNf-_TD&e0itFq2&R~3+D~1kYzbh_RZ<4(f)g0x}`{+NBA8F z2e7^?s(=ivay#t1-Ik)MwGZ#}09vyIoTcvlpOVf*#hkp!*z2v>pC(PVnV7Em=F8VII=h+xWx2l474T+*OI<`c?swV zVVG+&$A1SO{McAJi_vE>R608@KAH$Xl|}HzB-TR1|3N zYyE|vt;87xfii%twdG^{{tpzzUX5Qrg64O8!JEnxy>IKUmK#Mz{-(-dpV3wXFZT0o za4C4}E3EaPq!;pd6qd|rw(UXf@zCu%ws*U(b)J3^*pcI?w-AUnOG7p=oueN$8{_?l z-^Mi+@$F8E!V zD!IE_YT8kdYFKlkZLGdshEV=Za?knnNoCFoQ+>8Oni4GiathZtIXG+)u$7v6d!^ym zWZ{c9w{C?*&e7IibOWV)%qs}^bYNv?s&(0^;3+{S9$lb}$Gnc$xszzv%+Gv-DuBxN8iP{cEOBPPG%XpKX z@gUvh^=-mGK^67QDXJG*TACv}txEOU>o_%2xJNV(hbSgVhG?G$U7` zQrjJc{0_l9BBe7FHpNXQ$@LpLzMS^_W5cOsZ|KKIQGeZY=igm=fbP5#Z0XoVq2tCLHsty@l17j=K>J&Z6d#LqJ=-3P3 zPWe?VyA-J;Y+z^D=h+KT47y6lFTHe!LzJ#u`T3_i`!Jz=i=5{rnSer=nEX_{mZm0Z z?vSnPCn$1qa}PyE`q#`_+g}@c+tAQ>M*e;OXm6Y3WJwhjeYHkH)2Q!WWmR{>6O7Kn z&L{%S+Oz9tKAsZ_Wfg5~@tdgG|HN;)Sdn?-ywcKAjD2T}D9w(>oI+r;z86-bCDqJY z^E}N6*U(YBZd5mCod1hRUE?bWz&_=}QCRshh|7?+<~W|xx>9^jJ#q2tw;ih?yM$K8 z$92XJKlA8%)BP*|r@@nueid=q@iug!+Jc)hYm(;pt_sOAk=^(c0QjRzqZU)Cn^{?0 zHwET02#QPHL*4eYMQmJLu`G620h`9|&F2G#NtvK@wb8@Sip3>?^4*=Yq0MpvUkX3k z1!-L!y7p+zoyy=pt_pa{&a+x-O4-7|$mt zv$`*jcnfRX$t7sqtBcuO_154F+{znK%{wLhqZES@CPg@S&vF#*57gvD;-|fm5@n)i zjN~;#1B1c-L6P~x+ep&CksYh6{q0DSt^#r14;3vqFPRTN7;1hw>8aO4M6o$C!-->p7*nH7?ISWd# z`Z)a;vd;k=D#SW(xZgpvISgE;!Ywto)z$ay+@7oHR=Za(-@f|DK2MA^0E3$GCBym2 zVez6e%&PeItt$fJ_3$yoyuG{146wuerx8m!gtWj5$43Qgy1Kf4wnjtQnHJx$ytzVB z7u;d^GQ~=N&&1%LFSnnN9Fwc{AeyoTckbGa2gA|PX++UkYGlvXGu3^4Wf-wg)7I41 z_Q6)Pvb8m+Mlm=vbaUvDxO|8(`1RimcSv5IABfC-aA#3@)kZ|E;HwiH_ zMiX7#dciy{A2-=b8DF|W>Es*W?K!`lP$T{m%Z*Z79~Eo(<4le>lc`5BBCG!U_g?e! zv=T#EQ!NOVUf)k_>50S4Yr`WDT{1#`=vg6mV<*ikJX&y!^u9%x~X-S6q zTD82kQm{oe6DW=F)p&95$L3*uPfw4{Uwvl9MagjIOH@h0AIt^$e$%E-=t-SD($@Ct z@<|@yK7Fp3#*rh>16Eh_oL@DzGo`a8gp!mc42}J4mLhrR4eR=QdS~Z7Y-}c=$@9F3 zo^3nuUNM73F)v4r;mL=kXvJd>S;^C%&~|DCbc zb5T)IJ#}M*Tka2j7gO`|$vqRc^ChH@bdPCh+*V!UtxX%kdojheeyrgQw~`t<*~zCE};B8oqWuNl{8EOY2w?lI6%5#9Dm zwbpz49un@u#E*{n;@i^SXR8!d*!CqOkBqZx4_0uKfJ)@UOpf zcaU%gLCPK*>IAc6sw}(&IEvoGp}z8p(QP^6^2xZQq|JUmMFuwk=bb@vSx_s(R%r*c zt{oAXl$4ah-7~F*VFwN#gd^ReU`7f=5)_eSCHD*sVP&@yCSHa^i(L0kb#|&T>0*!9 zU{(UUK?4eTF1&H_7=CT&LudVT2G5GSp3}2*5$smag^(e!~5fVNE~vQ4_821 zwh*aJcnWwIj^kMO>T!w^?(r>yUTD+neBDNBzd<)HNgxPy&pdk9)DN|p{D&jd)b`@f z@YBDR7_8!^uUkGDwr`(m&)O*RDg9c~=WSoK7NQZb<=zcoE!1`Jc95J3#Jd~h-QvGL z?f|EUC|{Hm6mP@Awnh*au+XFmH7;KgE$_Xjan{Z0YWN7++8StP7si@lvfe7P9i!6X zH}ANhG(=1+aoX1?_{eU_a%xe12i?J;ApP14Ey8dPx@?s!-OpT=xJNo5r)BEVlf5|8A6UyLGHL1GyA9m!v}^!u|I;h$K$Ks;dlgs^$~v)EGMLRBB;0P3*DkUyNbXSeE(>aZ$U*th6}N4crKR7?qX z)!QqwK&sG>6t_=9F>+V+0L=xXOIzCxKZ{CDogs{RzT1D! zu6nWMkcws<00Kba0}LW9=zw(J<66*3ch%KRhl>l6d=-5c7zh(IB|+tj+5?csb3@3{ z9UNU!@_F$hnBRoT6-OLY(V+Wt-8P(_Fnotg2KN1X!OLweEmiM%N*Wqw!NB2eZ7g+D z@AE7jV&&ueT~eY4!xOY~QMwlghKJ$uXGhWQBQ-a?BmUE;ldC7i#O|E&JI%rZEQF|! zAKxt%aFnSZ_8VP213czBUrFF`g>diqJAYUsA|v&1XJBt^iD@Q8)U~&-{dMo)91bc& zM8{WUtdl%Y5IWb;UJ@;$whOkU%-<;t{wnS7?CbR5YPS8 z4Z}-_Gs(A~GB+_fJ19MfeZ}@SZ{9%BshxSh2|n`1WNq=hM{o4`p?>|xScnXbpqLRDrF(ln zX{$iwj-+P~3SxBT^XCXisOvn>%iGc{dbw8Q4whQX-CmLw)Yjj>fATvZ^V}zog_hsy zi0g0-H(6nJB!&*HNiE$vdn7Dr)dpj4w3AlS0IcGPgJuTmWRKTy_vh(D)5*jE48s@pIhCYDl>)(-=XV8!pT%Dow9)9djJ@x8H?#=9&~bI^VZ@b_QA8_RL- zr|w66s?DgK*U?<28h!I<;E_fq!&Rvz$drJXi$a$b*BHz2qih$+a2nuvD1RU8zVGSj zK_&$ZXhLV_J@!(XcNfWLr)Fn|aqDi+-(SMLdj}0*e5a7#-7m#XMycvV-@KOa!RK9A zSTW?qu&Y2|fPL&dS;>GE#%CeFA|WARYE9A}<66Q)EU+pfVRQWSX*fj~YHXudARx!ppbcuQNH+k$48neZRMj+sCa{!)Fo1z+@p&2Kw?^Vp7uN z8e=r^X zTQAM{?B`u!lj@w>^pl;a&a=A3+Jy9(g+T0K4Qj8-#%3)fu3f8ua5qLS zh_GW8suA(c7GctWL zGTxc%>Fe80_edP{o`Z1((K(>SXnxoN!vXGmf`XZa1t~fT!2%p2BAT&{r)(Q$FlI1;#u*RcUKH8i|6`|GkW+Qbs(((pbl z9$2ZB)hACoxFCsuy<-lRdGQx~+yZdH!{HU85W6*YiLL$g;flw*_75j3-oHNzyDFlj zu}{JnZj>^5gX)H_(7!v1jchg5nDH2S;EwPVc+ zaX2_gKuJNXPt229)xV{#jw93P-t7s<+yhpku3@AVy{z*=6TS~$zI^fW+MV^~ALRp+ z2OLo416JxmRorr>rXW4W2CIX2?AT$PFb?k{HeSq{`B0?B{zrS^schU39dUv< zOT62&ce;%m@qK`P|9Rq3!^m!UtcfSSwhGWYT0!%u0}*KLZ^pT;&q%{fqpiZXitCSl zMoBQ*Ve6#}XLHNWk^LL<2UMVz`+BMr{rl9R;(@iPB8!x$ycnkq`?37MHYhr!eduh5 zrz2hja;EL?+x-KR$y5@Wk~Xa}GyRFV=Elh^Lh++qwC=ile8G7+I{vKmcwJk({P93B zgtZJvw(kw;fm;pJ@LuO34-Q!8D)=? zlZ$zRv3EK;IKVy%FB=s#^_Z`%B5lX+ojZ*(+i>APO7c%*tPSLyxb;wYj*N@316Ldy z6MoS91IS!=S?tIMv?-is7WZynV?L~?sEA5iNl8gr`CeUJb9vg`W2OH_%jD#|KM;RT zT?O9~KXdobvu|MEF@@iPEI^z&xo}aP>%yJs@cA^8Q=k$`N!e7BOp9MD+%o!gBRq~= zd~@2(4ibuYHk=hYx>hn)R=+|H76P{dS#AHo4xdIGKJqW|zq{Xx4I*0OPqIr_x_vFU z)*U;xLo)1mWhFA#e;Y|oFf=ei_BTKoV>enAr37bZ(%nlGfe||+)Y}{S>C&$&2QqjU z%}spH0UcIVR{o)29_1U*)Opx2m>Re6QtiFRBsqC8ZQr^cxo(hl-H2`U_YbV!{K|gN zTMyNddDR6%`N+vZ?j&-_)@MS&)3Weio3w@hED$`6Iqomrv)oUm$KrojQ+= zU;q1cBn+ZEzyAB%|BvQ=@Jejse>>v;RkzE{m6*6s$#C1GESK=(eOF$@rR&iAznbFa z$|N5k3gp{$h+mkPZ6WwUh`LT5{|AhL-;&>SbqzWGryVg@fCQ2z^+WZWD0>_hTneY! zNJ*xr(K@H&!O&7w#XJ-FkVC`UiBmOHAxtzIeJP^zU*CcGnTW>CSZkKJr}wAKl!i! z+i&*YpxFPTFBDNSd^qhO^2YP&hEjdJ5hncIKS_76>}TswRL0uK&h2PQ49du#a!Q)Em9L=26y%gXh#) z?x$L)?5r?1gH1KLPMo-{Fi>r-P={q_WOQ&G!Wfa*KrvTH@&Q{N3)_O8_jscr6yrTe zxGJ4$f+(lFv%2t0fgER`J=ZRG@hz`XFEj;vLiqo=oQGx4Dn4A=vwNpl;rPe{y)vy_ zJAKrnHh-aaYfO&vrMY+?>SQe0sUTAC65<92Wj#O-C=DU)i;Isx{NkrltlUInEP1CF zGF>sba?jTB_r;Cw4#2*Kszay`A8sh@L{J=b!DX))*23p@dDITUu3LuJj~^{9Edbl< zb}=w8!23wYXY?B7X58F%5_@cbmbse$_&J;|!nGmG5seIycj_`w!2xPS4X$NwXxRM8 z=p1r;rl+w}++FbFe1tIjv{SR|r2@?1yhC=yk&Lcf3-{Tiu`u*8d8JhMy zE~|h!YqYOVFXehX^rCmQaVgaQD;Ibo;)Baj9r? z)kOV9vDJW#xOnlw?u{qpVlYW;p<>##{n0np=$pByqEQ4X1o7&_*pDi%zaJDxL+0UU z{U`#+nW7+gX^Ou!Z|e+QZh~rZsDN49(?h4`1ED-diHST31Z*6;an&BtTw8ChGJCwn zHa}Ig_DaiKZWVr|2=Y+WKe%)mYK2e{N3_xNwl{A!EKam*I}RL$AJa(_SsKI?FZF+d z<#1kY^`H`M%eS{+$#oq|%r?4|kIT;z-XZ#K{1HmhOUVf(|J4F$WEj12=z77dp)JqCI;lXNM08*%w{-8SpDIXc}xI2@gCk zPa+4H>nfW1;;`aPR;-TRw|Ak9p<&)C+E`L(I1Zr`(>+WFUG4O$WeFoE-=CeC30LDj zPlCHMB$BqXzftoeDp8pgf2}CuSDuuamF8x?V*TpiD~SDCFSfdmuRRecv9q$F5p&6b znZUaQiHCB_qie*&F&X3IZEGMNUI zUQx}2_WvR)^M!uQ8^suxjMP+k5HE&Uu3EK$s~rZHeV8ESOE)ptn}sPWgz|r7rYGK9 zg|?0>>dw{N*O1tUX>8Jkm32e8hxu%TazCZe`T2Q~FqcrOH<*4c9=cYxI@OH+td!gb zB2>KB)#Kc3t2fwQR1Pd6>7Ym8>(Hm}np3iOxVNzM_9}C&$lObbqkhV) zt}{QWyPc;*i6p}g`z;pVZI3Rc7}cMoK~$ag`6%~?!>Qo)8AP4tXZp(8EdYg83shU$ z+k<}vJu+WQWQ_?JUgRBl#Fd7Co`;xUf==fT9$Vx;Vw5bF0ZYETjmu~P28NS7+ zi>s@|T>;+G$v?5~nm~E+@YM%U15Kwbap?dzs+!OgGH(IPmQn4_ZPV!A;2@qi&nfuS z@w4?b6VD?pw!_cn_oUHKiOabsip42Ij0@@&cj|!3#&jb&{UrQRycoy^^~&?-`(Saz z5I+b<;b&;bgrxhl$Gd<4AWkWD+|Sg~;5Pu03ys_MN8x!fd8rZg?d{Ik#__aIGMgVE z-O07tcLie_@7$^Bn_J)5K$4xRdoJ8X1@pbKIH4dIL1602DrVwZ0J62RvPPU1P)3xv zz`$f=WzqJt$bVG6em(s9SrmxG_}&Pkg3ha?L3|Hxb`QhhmX#CL(pupNeJDOV(5KZ^ zRdiJ1rU0XedXr-m$BrLw{r&r$Uoa&D1E;?Xpj;yz5zKYB;F|jWiNNVSHi#)HlLh?R z$;R3b4SHKr_4u6jl9Aci+s6u~t@6kLl(n)-+vLPsidpcOuf0E5ne>Gtr)%h@>D>Q@EBkgh2f_ z7GfK%h(TIUSWr-0SkY#oFjGIyPG}ym2%*Y>9+!d_*&?TQ^dJ;5HJLb|&cQ)S%Ilke zR171WtHrZ0xRe&~Gu=Z9h&MSS@^ksEob|{UMBYmkLr0Gg1j>D$NCf?;%nCmXl=}E0 zgY2s6YW=?Bzk1TU=lUN>8z31BF8JNP!h4x$1x$6cVMhZi41myZcRQb;AQADNWS)WP zeq;E-Jk@yWz*+P1rm-<52_6%76DjNfxQq^q7`rPG z?J^1QdZNg$F{KqGy+TOQoZc4|qR@dYurgP3a%^iZ54IVUp;anpC`fD0gorwh zG7C@pV#d{gB^bCk8rp$Zq|gPlc-*H5)q1t@l}uqxA`@`tzjXid0>%R*k~iCrl~FY_kI2i(jBYh z7aq)BCfp@pARF9M*a81(K(ox-+u)yH$*xA;j2%>l5T{-_`6fHiUQ4U9RGxOEWEuF} zo;|x_HHQhoEnWAvHaEsi+SK1x4veZ^KYQdk@c4}GdawWjF3}uJxHkds-(Ntoka}wp zBZ+;EFqBjN)sl!SZMP_vCylUG85tSDjYht4X=$jqd+5O?sj)~Pac0KG*Opk%of}!_ zI7~@7H#<8#hGfg;`g)9ple&CaGv96^bbykIN-Ck;$mb90g0?+hm*m1G8R+N`e4&ea z09vY@!exIgso2$~fn;`B%k~jb9BO1NfBy1?*~7FWX9g^d5o1u8xVsoXf2Lp5q~q+d zlFm-opU;o->20kx7mFeNvsv3+E3zJYm>wVv^!FI9#mw9fAU>8{0;8;lYQwf*Rj(W3 z1tVN5w)O=ceudbC&!3mU&CJ(|o_`Yj5s;gO@TJ#G zl9P)@#y_4OA}c}I01rER6{@GQGVjF40(%e+AQS=w$_(~*1`&r8HxfEpT4Bf8d(dwJ zSH_>FRpJ5|4;@NHHH8Z7ds`d!K_`R<5Mz)~YxQfG;o>#;YOU0 zhE;9>CKc6%OAsPbp!GsQ!Q*fO+^fz9i4;gSynd2LZW+;AEH$K3+^+lVuf@x4t^;A< zBBOJjFe^x=kK#JZ`E5jonp*n7Rqy*evTORu{VEtPOs?bu8jrP(UKXjay z);ZhYHM_XBIH9~XO4y#T_t{>!0C0~ZdfdcM2K80y%f6{if1F|=;BSYXL11o%90E2 zQt%%ipBxyl%@(N})mD#_9Sax<ysbTJ)*iq+r!(tJ6#U7 zq%qepByWI;18s_Ay+<0;5K$a4Lz^FEozaVAnHpmi z0YuSH@>}*?B9tTRtFf`sxVB09brZu$K0f6W6i1F6L9Kr+vL1<|DYbFHvZ*-KL9Qdq z!cb4|yxn;B6Mpy(V1iqj8W0_f zB#pXNUFZK?FCNUo6jX}4CMF4IRgZN9QXe_$;pGLIq7g%hBncx{dS~`wZX~Sfrpd7S zJI*v*$yFm zuL7yabLY;rW|{r!?)K)9}va0iq-)+ zO~DpLj@hn(?6*Nrqw`BfgwA2Y@Kt7d&lfEYa+JNx{?0zL8`!C1ngZBTW>V;vWRLLcrpkf(eO6K2Lvpl4}!l7+w{13$hl!1TbmpS#5l$&%Y^X&9ZQkBzQZLu-u76oRWobgweW0T^f!Qlod=|21oH{ zn|VjZjje8kCS;7TC!QR%%AM$QXB~6;<1V&Qi&GbxWmbO~MvE|rEAxj~MiYVJ;zgw6 zucrcI08sp3>H$?^FQD*tB;qE(SjI{0V|6MV;J6)qu<30-u3*N00u^@jk z(IDl`11=d6k~R$NZJW7sbaqx$sYkh1C(cZIWxcMXyyZst+KdZLgW=-Ss~&Di-BEm_0T% z6y{zuRM2gs9E+<)>y0WM^%SAJvy@?~6X!di4B{T4-N+g7MCW*2as|4_=+jVRN!D6o zA9U;RK#zSpvL3OX4N3b}haWmpb83bg_Mk|06bTKQ--(Y5qHt_=92`Cj=LqEwx9u2a z1wLwblzvCIj{T~oG>Fj?0b-j;m;>7hr(Wv9?=PFf!Pi&MHMya&J59}9;hBi>;z z6GXQe&8N-sohz$xWY;0jNALoL5UU5}(Uc~et! zZf>5Vv*Qq4Ag`~nQ`s9Y%d|zemi~!J8CEcBsv0>DE(ejEpg18fujQ_K=Es5=);xEY zpArq-q&^hABY#(Zug4x_y!g@WbYaTp>Havst+mpvw)R%qut#?W!P904hk1MN5v2q0 z(4MBhKVO2V&l@%&S{L~FK|)JGIQiqp&Ye5)#G+xxas^M28eF(OTN!c>4|1JR9jbS< zpe28IA|}$q17STOT@&@6O;NhokllK+SeqgJY32bnEq!NttdW}9vG(_K{;GF$1D&0q zsQ;M%v&CMv7?dQ=6L$8OZuM>U%#(Fph0Xx8kN`1M6{J_SxcaU5D)Zgq+q>zhWMpJ8 z4?)RGmp~wZKtepJk@9&|J{t!=+I$L8=)yLom>s7apWk#lbq_A8PTDkM|AVyyRnf;m!Zik=dq(KAU>nxIr4QGoGAkT4Ai(E~G|%`|hY4=M7qQK48*k8;oTwZO zw-**}M+b?S_kfTP)rBwwQYNHktUd`phN}L@C(jo#iotHfvz@h^IIKTu~Lx{onLD{7M4xW6#Dv3Qfg`43PCpNj~o^kR~I0Wfp3B!5Fx)bB5 zNHjHw?Gh+W)W=574jVIJ`OkHaWyw#8#+Dnzn*NI;SY5N9qT%E}jC6|o2mBPc)GP}sLDlH>Al=X9EW<@W8{iM%&zd|U^z zRS4x^T;V6;!1L)s9pBDUyAkfAVk8pYI09?AqWDHs@uSw7JxaH42O&L#nmXIGHO+g8 z6Hpq2jlsh9=HBvt3L!#A85u1M4P(WfQ<9UDan_<#*))=a{~7ws5E0o?{^3&v*ajCh zrY0xR0*l&>w_wb{s30wqN1Yw#YF=Ah*LyJ;Y)NNGAHp#>SQ8}6W?UO0Ue-4Q4quV< z_S!<*DQVxTFkx-x!}T0T_x*emDJ^s@J~!79$Bsem2NZ;I&O1>l0KVpE&-&tGe0qc9 z_aS<%q<=Ck#GL<(&-6|5`JqW^$u(hN@)#yfoLZP$h?KmAYNGz!Q$Tc6l&vghxzC>E zz8c#YBIL>{aOO{YyD)5nVtFwmV{B*HFW9ZOVCHm;_{9*rK@q3%&xD8^e|t7a;Nd`S zO*d%d;JTA{wJe->z4gx_J6$)4A_zDhJU9+TkQbw%X&^S2 zja+xp2o{Hpk!Id1`|7~lij7kj!c%j$S!&PLRv}^E`V4(qIj3Y3H4Fi$G}AN>B(VUg zBSr?z{#H^%;bv!R%YlIV(7VFXBZ{g}opqx)DB%WHW0T00o+84^`aC8bP1kUmqk)st zTnD8M4>#JE*t6Es7seKxQq>T5H2hc&TMULb0P_+Q#{>=MJ3i9iQI|mk1$K1G*ORrs>9xhF^4`o-?-WsGicC7s14qD85M|cuBgHU;m zjHttK_ymIv;i|3tLRpv#yI%#YCCFrk`gp`*bZc!WEc;%^+C*1j_hfV#(i^6VmXcsy z1Hr3ur&J-9J^5_xjzoBXu3BEza-|pMQNv(>`5Eau`?%udfZN^Y4N?fZI1xMF*ff%t zpKozbBdpqC^ZUyD%Xwsew24;6#D>V^zjxz7`hxEJhP0b@3vu+q_LdfgW0L<5ZSNh= z_5c6>YO7>KQ9>k&jF3HwqRdK0S&^N+d0CawGD--c2uaAu%u14kkn9z*_ul9Bs?Yax z&gF8>?{fY)zw^3u>D{IGtC#2NIUbMuxZSU}LbtBfcEX@{3-sL&ga=JR%s-sxUs>2a~c3S2XRjqxDX=u(* z0K0DMflf0bdLZyejyXQS!NpQnw~IY?ZAErvs+4s$eiqrlpBJ3Zn!ve|{~Lb`SF$>GXC+@%WP+!>Qc7=vgT8EbhTw{k+C zP6Uf1p==;|UN;!kbS|Z7qN`{%hq0geyvBFIsF};)7XyACD!)2E>I|{SmTfyfLI{b~ zdM_#I%Mx9L{2kT{5sZxuZJDT_U^6K7F8%gazCbpR?FKasjl=lLnS$*OZOH;zt)B!j znTkOMQ-$oJz!Ut313KS~i}j)$0m4Cku9k!A?< zlnA|Gy~~o<)avjJKWf5AaMS55e5< zOM5wjj@<+O=lmwM#2(kH$t{dQa`#RY>6Yl1?{re_Xy=Gd3sa=XD{@B&H@3G@XEVR~ ziDwusnhk(gt*=jd@o;ixdGNF+eD6#Pp}Y!)L##7OueniDVvRvo+Zt7mbE#tP&Ma0- zF9yWo0c_S;tx^RO6BF3%p6%=cZUV~7L#x)Y#Wons{9QM3;D&BAY5a zm@cwLp1B=nv;i)pnYlSkMzEQoqKstDFkQr^rxZ#HSUaFh4HKB%ch1`2x>sNS9dyWQ zRkN6dIL7G08yGnD9E0i|}@$RH!f1=`Cob4|0PhLy}i`^87hZxgNu57%zrkxaAb z>cPVpG&o6o)$uBtnGIX+oA6zgXL({Oa9A=nHY)12Cwv zw6%4>HWF|DGM$ZgC2sTP)#nQqUrB7ciGGp%=l$_jZ<n-4Q3?V|#*3Z* zepb&FBY%?T-)d_&Y&U~^g3<2~tal}Fn)%70*d6nhI(w{jhPM7@81%XFPKzD1nA zO?QH1$YCa09!k=gnOSXC?y5^ws%$E+k^mq%NKaqQ`?&1p#rrCBA_lKHE?*#h@c90V zGxlM*;fpmNqh#Yx^Rd`XjO8y5_5M4%J+E&0Gxnfx3#C?jGg`br(q^i<6ArxI^Y(4p z%I|6(Qf8ltqCs8z>FMF&lI5(@n<_2+wV^@*Z0E_9 z|M_fYoX(}O<*dd;#nE{pZ?Sk+>E!yjM11{F!qm*d0{QOU%sx}D?$Q^}yKD!>kNzXB z!#^&7VcR9Q>z?O4Z{3OqlbIR1RbR@Pxpzr*F=7OWBOOPZJ3DXT-FTJC)R1qPg0Mo{ zD6NRxuC}^*ln}FfdN=w!i12(sMQd@$msTd?jtADNQ4VY>+r4kL2T%jkn! zXwVU{r=g*aa&`aVmQskV5+l>ROsZ{&N=6Bb>HhweOSXOcc9tVEc=+%UMlZTOM=jmt zyOY^{zDf*$V<13mB~#ujd#~TO6LF_fHd~_CWBG*0>Hf#iEJI&W=qdT{th)@gSW>;q zRyC90nz!hCriP>S3AP`s(@`wZR8@@+<^()hLMp#83A)B9=1lZ!M|jP;$JO0=K< z-R<6$L0B}a>6XZe9zPe1F5v3qiLSM})-`<1DJ&Ed)nOz;a; zX~rP-kSbE<;X}h2r!&CZ!Y_wEQybe>^Jo44UBVvQPYTM)+0G2W%3r)@cx|Gl17}RE z_B_jz?Mu559srK(L&@W-A!p)Wc5@2gDN_qXx7aWOzBGHT-ar{VDb`DV5-gcLQxp(G zadPrtx6gB~+wKAGzscl3@@8q@Ed|Dx) zl(;?65>JZA$?F`Ue+KQji7q9bItTatyLJ>M{wyTLUVE$$jEp#NgqqjT-=_2Hop!+u z0Dfz>bJ4%I^_(Mo-*z*kYHm_xlNj@w3b3$W$;c5dIof@bx22G%)Wd7)rNo~tylU66 zh^d)P-YDHRfNUEn?BtEV|GU(((fq^WNfUok@3JkB2jJCK_>bK>McLb4`0vU=G%}qYCi1 z96B;NE~{O=Ax(P4KY2GZK&Fc&6aW70)KG>DiMUsndwZh?gj2Z|?VprRa&Q~a$quKy z_L99IOC`<6&yOJ*fy4Xud8?h{kiIxkqfMml!lubjRB^n&AFOx6($`)C%hOR>nx-vx zO=#h4TBPgsXDkAXPe#(p;-r*83n>Vu=oH*y4+NH_-a+l9IoM)|U&+d$;vR#VxcF6Z zv+BFxo?wXmva@sCvo`24t@GrVta;oS40b_PROuo0hqk}lG5)S2GAEdJFrvYR27P-T zX!J5@9rZzchD^G%xnLiI=rz{;RMIej^D3#ny9?d1yu3V0={`Y(PA?Quu|9IfdjkOK~q!{6`>{JTZIGP@YYpks^ zc>!6UYx^+O{qp4>cbE4fG)22#iLLQnlJSmRJ8mmvZ!IqE?)K6h`4}X*0b+QSveN4F zy}Nfu2$=1c04yvYXz_qY2x{RYpb~_J9(X{Lw>#15s_vU6Wk&x1iOJ%JQ!c@YFi+8- z7IvE(!lc#&UoHk%Fx(eex9M8&5Svxeo4#YoUYi@YzC333fs*AI2_iplv0MHmF6i;% zrmtMs5%yq*?~Y3|uWcNcR3fByB;UnO2yqPZ7Yrv{J~4OI1>S=&*nphN=Uhxo4Bibw z@o^ta3!d__UB-Y<3rSvF=5H|9=mKQ(liZuWsS)vE+j^j%&?$7Lk_JgZ2vwjmsLKK( zRFnx%DKjUc91nyZ@CjzFlDW$E8n{JQ5DW#C>&evayuGmZAlwVnn>}>YbdEo{c=z62 zj4umWbetuH9LL?N*Z#_rE3}O~UH)M^<%szRku5CZxh5=T(d!A9OIW7#Oau1*POoGm z#=%DNW?!(|hbGQq?V&&l_low#LeVp|3Y*dE%)W8yrV0SmKJ$-l^2 zfYDB|9uXGtyMd45sl8WkuQckONl3psoYFtLgo(mE`FCqZkb23+KcT$ZeHrusHqdk{ zVpU>AlqeoPdSo`GND4s(b}WI<$9+H&dO+DwmmWK=>O)E495i@P0yRfL>rQPV#khWS zo~#^ktw`3OPf9ti^yXZ+6!VI2VSiuWF=BUYczuEq3M!<-AlDo6WoWwVRlCu(th>VT znSot})XdaW81`&l8?&*y^a6H$Z*Pw(j)lN#T<0$zzN5v2)WJyYxK7r$k&`LI6>SE7 z`pA#4LNNEsF6>+BezyB$q-lUAOX7O24<$lCY0~ki0RzI7!-wfTxzaK*k6M^tu}$j$pMHwqU zx{9p)xgwj}yI{_iSC7#)^9fG;6Pwi25Tnn%qExN+=Ud|a3WHadTYmhw*+&!A-rVh8 zWLg%7Fa^-Pf(TV7WheX!<^a{}^Ow(l+x^AQ%qEYE<#b<>*;*;P2mws}#}N8BU;wwv)xAgn{CvbnNYGPDEJlBj(Qhbv(6yGYmi&|)S$ijkXY zb3M|H=5LjGbxpMtF+`+DZ$TEHeLS zfj;|g-e<`4@`?684l8NMR{ojb8WWzQ-h1b4X>IMxlHVYMg;ags2&+7Z0tA}QI05^1 z%HRZ`|IlRAG{nxht`o%l6Sg3fm?-%D+YXvFj6>x-h5BNyhzfmK7>4}*jXYHk#?%^z z45I{2oH)VC`Z_+o4|3%qCue_O-{qwxj6q>1YH88LTr8~E7Frej-Lv9rkmEAcH)7Z; z{q;VBR?^&dn%q@StVG_Gex2%fBt8B(V9UK~us^z33t+pLC(5gigr{))LwGL6^!!^@ z)vGNwx?Oc*BurAS+VSW&1(i?8;ot3(P{!7ZlbsFbY@ z3r5Ai$4+D)=soAMKHofi|5s-rKpX{-LFgW({GkegnZxVRFfOfke&)D)R3w*QgC{AJ z0i_hKy~F|bCl@igxE~V5=KFtOaRNz|l>HyFbu^2KLu!O`?(X8L4QQr+4QRZ3?;f#N zslLxoAET_rs}o`=89osR12EffuWDQuqm(kYu{xRc0Cgr%H}HTM=Q=w$jCB=7DQ~}7 zH82BHnIA5HAi0hfFuRHmUi}Fek_75S#U;v zx%mR_@m^YWx0_(@eJ)Arh@`u)#QLC045W(ipAr3foQKDn=(0v~>oi%G^Q5kmZ6D^P zVLWcjv(!21DJRp2nX+J|$Cx@7b>zsU+DS%tmNYp%9l|hz$GVqg)j?`%evcIg>5H%( zM$di&)4VVZtXDOJjqx!E7cZmw#>I8=9Ktp~i|B zaMDt;Eu17euDe*Y*wep;Ea>j1tpzM|zs9u)Ma8ePee~&22W2Nwb?D`EI(KTtajsa#J z4pqp4V2O6W30p(J)nx5ltLX7S^>(8SOj^ZVc=TPG4Q0hs+Icp(8dB?XqjeG%G2)Dq zkSI%(o@^*iZFp|SZ9bukiRaFrS{vddq?@j|O)19ff_A)HGK5G%sBj><}t zs;9@p9HISyaBOyd{==GoY2P%YYFU=;f(6pdx8WKs@FwT;;4DVpC;R$l@iA>12mI6@ zrv|mA*b6DuS1u9*Tya6h01xl$Xv1utQGgNbMqliPX_(7=TN5zsrQT=J2M1Kg$!BDm zx-uwMSa}x{a175ho;8+P`vepFDE23~xQw#S(2+&uS~+30m>lee3Hp`mWuCOTwj-U3 zT}JlcuNmEru|3&06IzW(YwN3*${LkAGJ6^A#=eWjjf0323u0g*OFWtv#fLazMch}9EB?3C10M<*w8;Cc4$jqh#)PXuQV z;pW@sQHW7p#A9F~kc37N`Vw@0`Wm}2v>;56&J5%tm|TU}^6XiXadY(WiK0TR9Hy<+ z-_)*Ld4hnhzn|vFk?)DwA3kK1=le?cqU+IeHV&P;H*db03cy~KgJ#c-B0RXTX+X~| z%BU8A#Gza)G5PrbW<*({s4|IreZsHc?`;5gUALPk)^!#nG>@XDH7u;CY!ckh0sKo6!fT)YrMREtJAO40|&W*H@zk~_R{N7AUxZIV*9pukV2s;g_o zOE;ty876$|3z^j}N3f~s*HQIAYklPyzBzF7r;4i4MrLO21rvlguyYD=T&Vno?ia{` z9nNh$+@lp6;@n8%;V#v3f&n)YBi90jH!?^w=g}e~Ub>d+WntJ`Eh%zykl*3uP?+=% z0jGl}pST^J-!l4-HJ;3Wrd?9hQ{!ei;3fFGudkJ{miV=t8N^+JJxh`r57VB~`~k2- z%Ca0(?f0X=$O z#`RCc)RfI(Py5)mw}b|oqGBeCW@7P-k$ItY*Yn#*>9lg^B{vTB=-WW6ZRHGR4rY-J zx4p*zRsB79DLb*k;)cCtC|s7I+kI9^B}FBJ`lw2@sFC1_Y2+A@qjJlfmrj;k;^vx zkU1Lfn)U?Kz?h*E>h&?LS`6rQcX#voqbTCF*2e@opTzuHtfWUIQDKH)!i4iX?{|bB zdA@cs=W|w{1@gSyh2+>c)WX`@B-|nA$m33D=WZG&FDaa)(tC!RBy>Gj>S1*mEqf6e zv`(Q@0AtoUYgo=np!S|KHf2cn2P`4=N5p&zCkl~Lna*$kHl4&yBM-U4debHS98${A z==Ir)+w-++19uc{!@Qiyy1XXKsa9X<^=CRo z-C9~Ta^w%;>rGzGg%g-&$g1>6J`3)<1SZ(ti>~#9Xf&45)VmYI895m{^MIw-y6_$O z9uGFf&{n>_j&Ak5d8z5WRvwxdR+LbCIXO{$a_nF1xa<3d%*!o|2OLD>67ZlvyV;;0 z24`UaTGx#crW!gr#zGmGGI~qr{BmJx66%v{FRo*{pzymhj%FCiZVBvJIA(et-ppYCZ-g)G<*uG)iXt( z=EKgf_Hj|FZ1FafLBm!@QE$Mj@pQjBts!6e!X3S0_tude@KnT3AmDOKkAd4Me>lcU zNQ*Z3OX*zcOeM`k)Qdvt(Ca7nKlnUKiv`YtVfgJZcTG=By!Lz8LVh(p zp>6nCyT@Q(AEwGbr`a|&&WH#~E8RKE3*%~hp$?_+cdZz%M$eQ{qHST`S@npRxd!Y0 z^*=%-86Fu;O;N2L-uV_5pWP}`e>UFl-jy@V+3DT<)Tp$T+Nv_SNy)19uIWz`k;FC( zA#Eh-6RzBAzcJ&j9M6CuI)8sT6$P#Cj6&-@g(Xb5wR*P5kdOuOTfJx^~|D{`E5T&167ND7iSvFJjrj-yu&mcWvi^ zM->t~QpVbwM&>4Wl|qW1KNxe%|3sr#(DCEP0Y89j0e`@=bArg(o`f_X4z$vLQMpkMe+nLJwYKn3ae}p2A%3;G&rMmqFLmp%+nu2MC=s+O$ zuPI1c;S+mS5#9P6d=(697Iza0M@C17+e%P~foF1&*N)CvbvGJYz3aZx^^Lp)r?2;b z0lciX%7Z?K#hjL|ZZXO}SzD+&T9#_XIh2U^5(UNf(kWs5T->VJ{(`)`ms$7EXV0WQ zdbC&UMP^cdF%PTL}CWDX-ECPbipJQ-w=p}EMP(zVX zj8PN*cl*2{8iU@#bk`UX!ATckQ?P7301_DK?>Eek;b%64kMiuAGMW zi|Nf#ifp3a!DV_Mwc9qi$=vBkaZ#M)LX9(;97QR}NkZrA?yHW?XPcJ5}h z9}~^Syd8uq>fybp8uNUd+PcbKnEK=pTv85gE6mFy4wm&nP3Ly`%9XM|n3LklI(*u| z$B0GjMB5094Cd0*ZyU*g6)iz03kP%BB`47m*q zL&L7)6Ts@sdDjhMfB&4x&=O7@U>96iElNk5Z}<-QhFVX#V6D3v64J_9QF{(kSw+S7 zgU+iG_m=W)GB0~iH^UnQM+-hkqZFhuxyCh-(3_2nm`5lg5vVzM9MiwC0SpG`S?aC5 zR@*Z(GiPS(G&GulpK(gpNmY-Ej#dgnP{{)e>%thHzacE#k;53e=f^SsQy8!LahLhBYcM4`|}oniOw9@MjKGm2wj7 z@rd5K2a>j|;dvfcs{%PBFHiVzck$Gxz2IdoFE8WmMDg4gVFm7R%y>hz*YJuO{|iNh zx!86L7ieQT5)oSCXCJw^lf)Ib_YM|3FVIRST;p{9_&TBEHhya!sl0CME=i`WbVe?lE z$yMQd%DAJ00HeZ0IN9e~OeuQ5pVUDlSScT=^_ei`GoE#hBm%i z46vi+0w)BVzZ<&U;OikJ&JyFw*d~c`Px0~}`V`LAKLZ0uZ#G3;XI?k)OoNT`CM6~7 z#vtTm#L_cT>yV}_Ed9jrH{i!7m|Wjb$?~mxAwrxL(ds-0Yk*Ol36Plv*z9)EX?5;= zP~=TmsJ-#P($MOaM}Fy-*#)0eE+Ni^yreT`|Bn`+!eL@mj>+R0ltJ?r z9v6zx-f=5}|GZhn9*dd3C(&GWP4JtUA5p8Giy83} z`fmZ`=k(K%8iEfA!{Gbp_J}Iq}_LkQ#05OG2tDzj*u`6+fQr#KKYfUWPA!U|){ln(11W4FNRh!~(k^oQ&>X2* z(Kn4!6@Z_*>9E56GjZkuVHS@N*6FLs=nG&6Lyjx4gWb8W_Qo)Ii>GcO@%WRkVO78& zB1+WR+1c;jjn(S5u6~C9H3)~z%`m9P53un{N7EV$2xdHxvg7DF%0_S>V)Lu2O2&~Q z3+EBLAhq^y&-{WK4HvZ(gynE!@S+eVDc)wh<^8|b8wp8H3#s?%?T7Jj;`RS3Yx3~k z;&$cQwf^4TbENgd4hw0RSi`GBWP2$|Q42<=ic-p#bJGNmK2Kz?$v+{^*P@6*n6k8o z?^xP(?V37j9-ZY4|BjQ9ec{N~@!!9n1_vKK_$dDYQMY{c^5wI{?lQK0TwaNR%l}%{ z`);XX{)3d+Q(j8&I41Teuj=U3Bm%V7c<=RRRx7KwXPW>*cM4#3c zZ(qy=J0{EgypLSRM&sgxDns1B=4MtI9ucC75qfTE}lQ z)x`Q@Rryl~L3@GLmO$*QsYLNvPTM~+;)`ff1WRf+b_(XPabg#oE(_8nYO`=VT~Ee! z)e|&+em>~bQc3S5r~6vNb@Jo`%FNB4jT$W>J;f3i_`s$A^0+{H=o#;QLIjj3T)ulS zyKiS#;Jj~EZ_aJKaI%Qd^W)CyGh!-;i`nN~yp&BW3 zUuEFp;_T*z|0IEfi0(x&^Q86FuIE6WIewrQv@}I3tzug#MJX^^ z_cfEL#gOlefPk=wNWH29*;EE~|Lk1ak!`vD^T6_ejR=cO;Y$-4b&!Wc;K zYi0{8ge*S6ttxfOM_zmlEbRK|I13e1>urpEJ(fM@Oat3lLo}XLLadJ+V}a-3!1#a% z|70SFL=drw5xAoxKF$nasmz4j{Z+=fRCTG`A(02?f3rA(w-J5DULEs-&d#}KkAm1G zpYRlY*Al&(XM1oT7wqc{RSQMxtZmFbfX-a>EKM?HwmN#}yhJ(+!3iBN_*4dH8 zYk!=A_|bEvH3>2WEMQ}-x*=8BX0wSU#hV({WLcS+lIvrQ>BSolxoggxG`b2&NE?I4 z!dh#H8T)@PdYQ!eRT9on`3S{dxNvG}O^bzAT^}zsmpvtXgU%Q$K+Bdos$QyWg@|a9 z7cZVElIA-s@86e--aOieHkWxNQkqAl)`rSaW(EoxUm9gr_z(_;OG=sjX0>_{p03U2 z!}^*1ed9ey^XIM=!3(NDaqd04ABqv_T5t%W=rW<55Vc<*D>^lPtqs~RNY;j8^M&k( zS9HSyW7k}_jG(*ar;mo+swT_dd)511R{4=0xW_`f@s&tgA2SlW!&T^I7CVkWAKN$n2$gUbR0Cd{27ivqWIlNo8Bq_%}3=B-XAYp#XWC7L?oRMdp$+mpfqPp+jx_!ilVQUX+marjcc)yVE zTbJ6M7xU$gF}3%w7++5q({5fJSwLYer6C)SMxO>l@k-_G=l2|GF zH;otGHtCN*+er*?!}Hj8-qSDtvJbmOq^XkPCS9mJQT1}+!Ufs*D@5Pitp(QaakuYy z>)90PzmZ6P6n-)d z`-0!lw+eZ7Z1%0}8?`)NGGOH6}y~)f(z{40H-aD6%|x6CW>=)Y$q)>zw`_ z$akO}f|3{-QWo*J!otES_1=uWN>b*mn8*WYD8h*7m5d)wdmBwoO*Fsr? zA#X$4;<&vAzA5Ft()utdYYoiPNY{zxbCnO~xL?_q5G@~ak@dknYPmqVD&5O!Iv=pc z=vm(+Wr)+();@ChaAb7Iy1gC6y)Z~ip*Y2MieJMt2-wdS}nnjqJteV*Hs)JL4$AXv~sy}W3m0$vS1A?0>i2+3a#?|K`6!6uq?`Y_NQX&4c|7FY6 zay$PkVVTCG>sHK9>TbL^SkTB=^~+sIdf<> z09QsHmE#dnQsRZ)kY#6s95#RJqWNE_dBX8-LYNxR26gy-Niwr?b6eF!o(0pzYK3i_7D6y{V71K6EGG zjxw0=LB)s46jbBw;W%&vyZC+Kv=%%}fk#KHt=qO@;&IV8)Kk5S3G<;EG3x{ERA zub&#VodXUk#B_(m<^B+E(6Cp5YF05uytT7aC%t)aV1P&_R##yQ37|X8A}V@= zCfak;U%vFNvBbw2WaL40E+)2$A_Q6a_b8z{Lq4S8frrnGpwWeB5Emc!Rswt)RRV}` zWHk5CpT(G!bzAmHHa5SmhR)8K!C4~23k5r9qMAo}AS+mbo%8)0sYJdNI*f9U>3T;; zAw>Yc9qb^Vt~g7>-n+9tp^BLjqFro4iCiQ|X;;KEXeJ{J0dthPu@h(g?w}01pia z9D=*%an$wuQ;P#JM}_7knrJwmxG?ULC2!xF19#+B6hoc^4!g9b=JRVDmS{emIwkHl zhdG#$~8jt=P9 zx2#SSa1H4L2|b!~z+`!fc24Gxt+Wehi6;VWbBJf&Og?t1p@S?J&{vK|(( zdwr2L&Uv@*C-`2-oj(r>8XnHol@+ixFMzG;-~gj+YH3K~BBP>qGo!V`AY=u`8W$%g zjuW@GFTV@ifZhz`xdBUq9X+RnS5u5IsQR#P86^S#Z zKaPSgtgFi%QiU!LLLIQmp!z|{JGPF8g988?20@D!bcc5XeP0ac?}pcxaAyN=URMW4 zNO<+p2jK1~<%MVnA`1vqi+m|FL90P%fZ!6H2S0t;fWv2uzR|R$k0R)S6bY9P&Mhd6 zE-krCP+viZZs)x_lnr=$Yb$zj>S@};laqQ-QeM6c-P_a1NMg0?ERmN7P&#@pXsFh_ zhBu^f1B8C{_2;OG%gHqkN6~1UL;=$uSZRi>4}s2rnu=^;29iWnK>+OGg*!@%3j?^N zQBmy}f;@9r$;c={H=Tl%)MaHj$xITAMMZ7x7iW*6>KuNN6=xJp;+*>PVFOs5O5=Uu zA2cv?iJCp!%Jt+mVW$s4Jai5 z44Z@mU~R~DN+A2)M{NxaInt^;hvfM9VEQum&I-_)9#CG@ z&U?-e#Dw6Xhx7Q{_jm8Gw!@}}JxK|qeZ}Xz zcAxLxh@R+qC9|J4e7R0ip=6q)f97Ne`=g5A)f#CR6B;0Q2E*6toRfJ^`#r{+B%??$ zN;c-xfBjN_b$KbOdrcMs+`>YNLwujBs<0OJp-tfvjO_q_0vTdR{G*U=>-7v z$TdOtFz2PiBzhlG9DD;nDNxS%@v2&!kq0{q3ei7C=ZRM~J>WgWL){w-xj-z1ecH2o z_w?*6988J0q2Xg6S4L7$uCfrafH<2->~Crs7#v&#=N60<)Cg?sh3)^qV^v8}u>)jT zl!Wn6K!yx-SaevJtXK=`&=olP^**M}m(8eqShnW`2yW%%;!;8@TObk&1jL+QDl4g_ zQK`oH_Bs?G>*cix9~>VapC1&rp&HY)6tb#whh`59`);?>L_ghhz13PVpJ0zw=yRG&l<9;f@KG(l7np>3&3=DgyL(q5oCjQWrS@Isw;L&r||Ec7II`ZS9V>HhDr9j{j*$2vH=}R&O!pfSnv2 zPdDvr*XGK0G5uh?0-eEO=X&4!`KIIuui)002%i8*2LDp!Z!GYM1{S~pVnJU}NC>`m zY{!q+J3g&2KyaUhj8ezqJs2hS z39j>k`&A61$8U33Z6M8-Y1q%;0^bL<6%#0NQDRqAB%@zVNJ>ILMkNg**CD^@xw-81 z{XV|FRMMWv+Ez?ZR98^gyQ;5rODAh6mmPS*xkXqKKB2S1o!=E` zU{U2f%coQl5l+iQi$&=BH*-^q7yN{rhGqz+Aco6&0WVrC2cz@VdTtLAe~=O0J{J{u zM#;x3C@9MDaA%7TrIRDK(}b11!rsmg{q2**^v{B))*2E(MDdhA&g`>T?c4@YiW_n@ zrOL(#rAERMW|sYBj!9%_eph;3xb&mt-f!jdm&^gMQM$$fT_A!^foOd?QKh?)d`5c; zf7+|0u&gdEQA$J0Uvtn`P%HEKgsZBi=GR1c8IBi}pQ1$-j-7>2?XbIDB?muQ<7i|% zP&|c&QGxVHP>*3_M_G74wdG4rOj8`eTqs3q&*h@xz&ZbI56P<%p+FnfbV#v&+HOg# z1-V>=-Xv=M)5Q3=5~H^YE9L-X5jaom=N(`tP)cph+#-<`Y-g)=*VI5?a9|tsJB~I1~N$KSob-;E=z6lpP!ndLkv@P z6C*{Yh{!B0$F;1BDvElXqKMvsjQi*J?emmRfXaJyn;SBrDnoNKGnmQyPOq&S1qq1wh;zZrRH~; z_0(DbYSUBCmIp~4q&e8obV)9N?n-kxuP6%X&z@nwnJw|!;Adu)+szUqSes#!)-fu?P_!oB@c_c72`b7;R@9VsGjKgrX)04X=1eP zsUGBPE?pm8JHGvx&hEIISBacL;F*E_)XYqzkadiF0=fsKlRLQgIfkGw*^wv-=S));kojFVd?-AEmj3uDyq|) zttN;3mQV7}LLlZ7yrWJM?MD;kSY^WF-OK?>;4areGJwduDgC4LD)W-NYl9NGz{DK`FWlhAvNT#Tmm=Nn=2WvUUa}Cdohewe%x7SP+ zJ6O1afNeTir0S;goHzlEHBZr81IFPnQEeaZbd4_{Ie*%O^ z0nZ!2A#5|aYrv4Y|WD z{A?lD&n;$OncTa*wC6tLOPeq_M6aTe)Tj2_5(2w?dr1Jj!S^-uG6wn>ftA_jAi`IF z$YEi$7g<|-ycohS?=9O{{=Vq`Y-Tuj_bQRbnRow>7C>jXcqyD!AxurXpKXz?PyX~5 zHkw8trGS`xjI8!`4fL9cmYW z6$#)>p|VBPgqP`nKtUw03Zr9i2w zVbZ|ucG9?Gv>ve{qz&*W;O~nQ{?ySD#q z`elA(;KcgaY@ON0Vd;y#_3=q{FTlh+eJCJQP0is~Qy_whv9^k^q~Yk@%sYI2*_C4+ z2R?lJHVt~RsFF>|qeow&f-`}(It$6ezXPCxLsUZ})I z?O*<+$`BW0PWlMB9CtWM0&knlBelOVllxO2K8yg6_`zA0S5SVj%hyh6YEv2*u**j} zgB=o#Pp9%A4|n(1SIrQT#8M>H`Jdgz+Rhdp2SB;0=^I$ELReFy=h%$mAhiDFyht;Y zGq1K%k!~kqfa>SG)KfzSjUO4yy;g~jovaT;ksAlUs!E(^YaU%4W6v!j)+)u_4@_DI z=!k7{EBDVXZ!WENJFhSGmC5)so-N$zUFhlHY}v_EmY)h*GX<9QUr-6op1OSSQAO{w zX7C3h)!(wi6oURh<8nbZb)A#c--?2Va-b1iV%nk)5k^d2Cwag;(9bM9ZU zb|a8NH@cv;t$oJf{PcQU^Qa}i!eR&pX$JRPI>laB6J|-;R<~#haA<4SmAdpRD<6r+ zN_G@JAyCb%mG5Sh++K>m!HeQyg~9d3!tVTn12*(qZ;}vD?||gkgPUs3rCf&i4)02M z50MbuiZ;NNPqXrU)XPl#>(ai#C#2r69pi7{XNhNldkmDYq4EQDJEX*_I*HUGylj%R znMmMhpvIH>+eUaUJ~!7HgGbWRpD4sUPjC;5F)OJUWC-)IWForCNY2>YeRGnBsIanQ zI?rK4?%&tjThGtT`}d>7h1bGlWn3PcSSF;<^Oe$ly0yd=kY-hp?$X<1lmu6hiu6_oMr%_UP@VTEadB!ba;LibPRQU+`gFu)W^*bbkm;IG8;1mVQ5^ zO;U^@n(v5-js`S$(@B`mRjIP8K2=pu*Y0d>YUM8+`}+M!oy4lPnqyP+pBWEBvk#&g zLR*N3^^$_DJB!o)ZvQ7+4Ix8sv+H^C?(;9+$Mx&$&OKm{8Ooo90cFs63SOco%*3d5 ziKpF2NW`ItF=c>CZ>>BgjuKrm9R#42m;3gSa^8yL6}S_TTYxr$H0rkA_0@`Sy*JmK zDK8ev%b8S;U&s)d^E#rDOAHlBNJyDKFa8J&+re{kbFFx3L?kdnkLqF6t?i#Cm=EdZ zrmZrz^^WAMjo?Bh@1^Bw*;xv@2M-UXDxHq2u|sy9_s&*5W&ROQ$<1meaR-~K-^Wka zpU$!~Ss$(Tl6ddeEfnjykem|r_h*p=?r`6XkYqc@6#jW?InAn?q;!0OtYhlQ`d_@BX>5ORYY^AxX+@veoJ-j@7@o ztUqqZYMMR=ub|aJclq}>7_c2=8ovK2As}w)0=q-lZ$vl4#_-&>n}zE; z@4br4yi2+N@cwUuvtTpcJbRRIjqw!l(TVN1)l)AiUBVjo!SMrb4Ww9)G(J;HpEq~{ zgB0^xRX|_ZLXx%Gxk9S;?>zn^Yi9+;(<(!Vz9pg{0Xwa~wjHcem$3v_1w6F7nSlzJ zxhbM`iudScj!-xFcT0c5dR+c#e55MonFQnnepL%3oCQ!!6jFP8AHD7C>PY5 zD$MK(Y@LbBA$yACGqLM~*pk9=1 zj4P+}o~#Lx*DXU_)xsr`Q3#~rL>I9k9S*|i!Oczk@E zS@#+L@{`;ryXO12@0Hoe(GunLNPkb|=j{>}WOIU>w&|P#>F~$|oMX;>i`+}gt$FHT z!R+@|ez*eI>B9eK*s|hSTmFbRl>mb?(#BI1Vb%8rw8=G+8keirTDKk-QWzrn16*Hx zJsmxDbxt=*8n;6wMh)rwh&DOZ8r+Swx`WR3s)`PP_@<_$AO!UZMyVaurg|B~$#6YD zAG?(HhjC-^1OQqKbFogFK0`zr0ak1~BMO@@_a7&VsOERHpUb43TDnctM5C2i_rr*APTNiB=uvOVhKAoa_nZc2mLA)xh5uWw97`13#%fWO zW0vvzT=C^J8P;T56#M;^GA$pJ-Q=Ys!=ad*=B{gXrp%rOMS6@89+*NPN(^UK@f0mR z9Y1OCZJueh7bV-s~nApebw+| zt&3rV3>|TozLl3l3v02GxiEMN!^3D?w`KuaU~i|Fz4^<@*HE-Qf-+8MXg4ZaHH5|S z4-yv|(`>K)-P=gK+wICIO_9ZZtZ>b#Pj51>=?+V`Qfm(#Gr@(2zZfsGVZ-N3V|fD+ z{Kk^&KO0kYZ&dW!1jY(m@kN+ApuDfN*T>H%li}lA;{(j+IYQN&uW2-2Yd&%N&-WO9 zPUo=l+rSKsI25@2#o43s9df|0&!BHe78e|Hi{u9jWLY|8NH9yKN~=7O;bkSM!u`gA zf9R}f+nRE4wiJ>ff2oJ3u=}Vq$EVdF9B5%^putulcl-q2Dm6gto+) zlxE1DKRwi!sd3_bbO9+|_S z0u4pLWyif%k)jkmb{bxO262G)OC;k|s4~U10Xmngh z)QaB<3hd~`i8(Jc-PS+z(_qq;hBCd(+jMq&2P?Dy+m zIqFW5mT>8V-vKEz(%!}-B{V5g(Rr0veEw?lmPI<)_epiajGKy$RuJr~)W*CJg7ws7uol&h_pKHip4E%l@lpD8tD^rdO9#D4|JTQ!G=;ICA&Ut+@^+>HCh^`( z#(MXQNoAYMHVEP&De{oD=9HN^sIiyY+dV^Evvsx9KMeXiZ5A5;%1Yt?0(C-(r@wRjWq7fn; z)QG4ZKNKz^>FG`>7^ zl!W3u)?^4(N?b>cb)x&M4F7$AivTmp|H0f_M^)9gU%%*Wpduh8l479}f+9+LZv;UE zRFsrPx}+NeK}7^aQbMFuK)O>xMQR*?T6+>>SH9lxFbQAPLl!zcFlvF87yV9wq7-*UH)?!Quv`)dEA zp!k3PfwPvje?KhAE*4R*b8<)a&h_Qxv-zH+7Js(jsZ;c+dH>4(1(Lsy=?Z1jh>W`8 z@tksxdbi(|;8#_yT-UQtl-B*<9<)u=Ykuw0R$X%#b+@Wg&XE7o?ZjbO$5LU<85dcv z#7-+lr~fEVrb{nAeb=USX`z#qu|v=*R!1r4f5}d!FZu0GsW7y%<=Ex9_Ytqh7O9Vr z3xSF8;lJNNsqQFB&yiivwQ^@wVCAPlg zTI-Lf4@X4)Y4IHLAa!XMNf7!jY9g#N%0c#GVPVAbV)H5;;mMPcL;a@`&t=-FkZIic zbnuZPQwxo2yRt*h@^0UcfSIu$TVGYE;q+SOS9WjKCpaIbr zJ#uhcjkA_YV7t{u(A)c4jglB-AqA;ZM7Ix7F%jA!M8E7t($X}8^$e~@sJwwK0dSdh z*p_(Z->GV9ItRN5o>1$KQnu~ATg;2M67v$9-ulw+ zYG+ZUeHrodLfh++p$WFlobNLX&lyH;@5x&iyHa!D-pWSntZxRuIW!NeOb5A(ftexy9yE;kCG1-uBg5kA{#eGyV1EO$Y3~h^axI@R;(8 zGMzWZVCV-#KJ8J~Ykb;e9_URXbthQkZ4~U!htR>Z?{TbjOslPx^VD9|oa#P5+=J;u z4PY7IJD}s{9@0vzh%B+HzEi@}*!iL|%W>c8aa{`!56sbfn&Vsddg~W!5v`P*9E*SC z=G5xqhH1r132%($+|VC$yRgnJlDV(@;Kx1pgLnB3-OGL8GIOcezAna8su1ZXy|2Us zQckPToEX@geKp7OQ*Ul$7&uQj{shmXu!M|Q+g6XqUPTz1^G{zi05?5LHzO_yMsool}7sMPy` z&UoFbhZ%1@ww+d}R784x#L$B3PgkmhDo<&LGLG(MrGi(~t^s037rXSQgXTOG)_3_X zve1+Uw=i}Vn+qxqEO3`*p>K>#y~yC;3q;>12@6gEef@Z4PIC(jF?8?SGsyK5U^%?@ zn!o1n7AN1<1pX_TSd;k|0vnseqle*7+?I8j1ETmds-p4HG^Ha$2gJ^X;%eu3=`gP?wO2n=fEUNMS^ z$Rc>#u&!T!d5baT`bqpE4KZIyNl6&=;8t_%Rwk0dRpkNJp_UguKt-j)|C%UXj}(@! zLqgF_{C%W|Gazl#6BB4}0Js3J7cpo3ltO&{c32(6ddg>*z>!w9F1iZDH>lNiWb?UanhS;RA8dmwjh0OGxmNS)+}) z$aq1OGw9dP3Ot+h_`+EDDFw&{AgMtVsu+4*Y#?%@J$dHGv|EDR za*2|8R(DCl;?>8+zWsBzooLzgUbwFYq(^UaIn|w)viM!o*zHZj%zA0{!6E9Q?Y;Zd z1B+SSHb(~-tWdx|!O)rPk;c;^sH+w%A-~V0x`W^Ppl`X)^2;j@tJDO-PPe@&eI=Lc zsI69l^FKUX5uGTDU!6aW7~Q+#ntMZ!{gh#N9`;LAI>mD+_F1{aoo#G`d42cfckA6^ zxP^ZpzSGV9MflGNHmA}$+G%MR@4x9G>~rBKBsl3A85l{MnI%gdBT|_9!;{e=MQit~ zUOEiI2=v1D8m!?2)EhJ~?9+BOHlsEOIQ?)t5#8L}JLcH!f(Hmd2kqX+>S&&sL83#} z)Y77#raW4UOsc1sA-Or>F9jP6=xux0Al$G*J8pk)pOT86{$#*6 z44|PEhlWd;Gm=-=69^v65sb5l&@Lna{wnQZ#3@-?YWb`2I69>?#DCKByPOrKGpH-N zJ6iY+T9U$hHzUSUFPW*Ud#lQl3fONJ$|W#{hUPgmVDG%wmt}Eb!R2lZL#Ilm2c_U{ z*Yj?qhoB%x9GstChH)d_{r5_h9tvmhJ>hns@%~aZH+PZg#nfY#Rq-N5?$K@h z%Cd~F<*zNt99 zRdDWSh{1=yot#oH4k)kHXqazj*@LwS8)>Si zaFQm(#UXM8jJ#gGvuGA&nY3bhwFwq*++RRq;PuC}We*$LGsFQI#t%53Oid74R0S=q5bmtVQ4H!(%$X-1au~vo{&1G0(~X;XJm&+(rmB%rV5PQ-60qPDEHVgJ>1H|GdKgUY3RFv!CvL_L)5giwkvaYMWe* z39x+~eFcHY#6R$c6LtmwtL=`YmC&`kwL|tk9Rax3nwCiMsy`Fqxxz zTmmT5o$Dg)Hz!Ks^$gs#18Vi_dWz)bB2-ls?KaCEBhmoZ%lcF&k$lq%mw8NVW2dW^ zrrTok5Qh@9Fk79ym{%K}sakydR$grFInfYTvOL+Cl`1uh0|cNHn&d@j zX=wDE*_4D^g@#w}`n7TQ7A!gb^cOJ;zH;@a=aZwlkN-Uy%Zoo>I##!m+Cz_!AN9C1 z{y|^J%R9?f*Olt6@IR*)YBowfQ*h;I8obYbK#3c1W@y0*Q;&Jg@%+J?uk+UY;tgN8 z3;N7*J-^*gyMAXjS0N%UuA^ea+|9{%nUrGNlzsEWBBJIp<&{qaG>GGH<4VV}VXBQT zDhP)S4VZDj1wPgngeev}F$MiKI4wNPXJf&Q_C@#!Hc^d;DmhA^yNIbb$a;0s!T^iqnz9V;wV%Ks~bmx*Cu}Z zi+hnb_~1L{)vdsqv@|k}FO;OqE8!A&Xo<-_As2kLLkx!N64r`52>zoNbR~`+ITC)b z&nged4=tV~)x4L}+Vqm#!OM0=5~iGx0r!29e)`nIj|A!hn=qEUBUo1LFclztr4X`< zrC=>ye|!+AfAK*p0_jMw*!oo&nK8%57wbj7j9oSrV~&1 z&M%+>Z`kSMdDUE=Vrgksm5T2~$&hJO;-LeCaWb>c{UbR!;Um@#p^dpCgFkVp<2%&e zeu(W@rG@2-Uaii#0T$Q7T3clsoAR&9q-;!Odj_1T2@GTx0H0ZDYCnLMrgr=jUe`>Kda$1ij6(ixjnnY$?y<(u?06O?Mfm^ z+4wwTyT4@Pb`do}g>HMpe!)ZK+`A#mSwx9@_T0I1XnCGJ3sDdX9$@QcVhQX%(Ttcy zO`;$krTwDw>*3CQZLV>8Rd4w%}c4@r$->j#}}!eq&Z7=bfJ*h7wVmk4Ws6$ z?R*)0YVnvtW`F#cBjbIXia-i>vQ?gkALiUB$pr;ov{)B(opJxkq^ySRqD-5Wofbxzp#blZx0rnj$r@f z#Np(Yn_#+m#a8IUe{tjI@Ef?7j)%_lRtg5w9GaoWV64O$e11FW8^#WQ{ zWIZUebweqsJ}+zMq}XyO1-czNPR7LjG^{T`xI?JN@O*~jhyDYX0|=6Hg`bOGue zz4(dW=L8?}YbnHH-Ty@?Wzy={X|OF>v5My!m{uU^$uCz&U8s|mH`Ues+4tiItNZHv zq{8rcQRb+?xa?3q1Ml*FJ$-!$;I_85R-!!oGPTQ1|LLo|zwf0Mt;xjL4s|*&%f@33 z<;QMhpL(+gH#U>-DDAtgQJ=RC`A>Z6 z@BXP?PwCWlrWJdcLyh$L%v@x@`8FTh7+nk0$SN9I-+I?|jdaiQWUHT&6x)PV45%$A^2~5s;L{EaP?-M6i#3YQd#GThnB&YDgrMV|vE1W;V|l+) z4PQa*Q)+g2z_?WAI`VBHi1&8i@TMfv8_2!p2cFSl|I}oaW|I0}EkJ_oYcUHJ=78$) zWRj`-($aEBEc~M|6t*9(h7fur%GvymqGH`H9y00!EGWZK;u;aYzC127K>G~e`$wm- zI4q3WyK_fW^fOf8#T^+54hhLM>?aVOT;{a1N|<~+y%H)y_A&II!s0Opna!C48FIEkKJ(IAt$ZI_awrKwRqVf=rOXW{GF+%g*>+BSv0uyVdk_Mt z4UA5hP+yJ1!Mek}Jn+REf)x)xsLqMh%FmzS6(9;K(aJu17QBkir7(v7Haf0!s;rCp0gUBO|Sijc1L2oP@Ij3f@K2m!GsKy}v*t8GJ@_ zx{eDmm`6D{OpsCvf)+shuyG#oSV&r#X3$N9odcx;#4%`WgVTmQh&LGuPTa$K-ue$% z1Z@m~E`Ty8;3dun65ps-gM+UI^#pgMWG0!8d{hrxvLk$j1rC&*S!B_^q9I73f7eu#lvR1NbvQgnv;y#sy{fyzRF;ttZLguW3wB5P97th;b0|ZX@ z*4N(bsj-Ae)wS_NzCA7MQLe+WL(WUnuCNc4tj}zruC*SnMmQK9x3cBX`0dWKHgZg6 zsi-we9~IW!p(eRNf8PE5O0;AOKksmw=$=GEdb@ZOACqX0ThpU*Z>n8<3%YNteE!{V zH(5?13+1a6gNm?Ox+ra`eD%?kJ{Q~I)=B#fUY%iws95YtJp4|(Ryi-`uuE?yoqBd) z*GKY*JGWQV^NRDDyCe>tjBkH^s$ko4_Nju+0`r+Lzi+1oW@+x_RwRiu+#{Y?BDy-H zEAeA(Rx2KNKjoA>eczbFWWq{s^r?H>#>jX5Oi<$EZsKxe5^;Jpou--$)kj@b6`b`p z)z(;|Kxv$cFPR3_8mvleO*3~l>z#$s5HTFsOz3BY67Lfg9hoH?XX7+(f@! zHC5|VtaQMr8B97vl`^8YV`D#0Cv}$WJ>+>}`Yb&e-UJlSM4m{KJ@Ga+`#TqV_{518 zfm5^1t(q2{#UgNE-A*<)G>sK9i@D;plNiYH`zI@k3kIpJq2!#wPoI#4XPcE3#*#5h z$`<9inFl^FhYlV1O{>+RAtCeu4azFFC3Y*#v}Ku8epEMg4C_I-*mY%xfx&O1@7{eF zH-?pZWo-sHOE@)JikBGFexr<@6zR|yZKymXaJIbJ>@XvBYig&=RncN^1_vhdC#6c< zv%JbRJ{5M&76q099@OJw9P@seA%as6jkmRmS1+2Lvv1Pb<|6GS(HoVi##H9N&n2I0 zS8{Xd&sj3Xru4p~Z^fso%-zcPPpQxhf9gN~y2I$%8B3|Sn+5rMUfjFLL`=J%NK{N5 z`>O4QP1>o?>Fw1Uc=0^da@VXP`4d9f-LuJRou{U+^2urtFeqM6pTuQd#->T6{%? zB)^ejo$<_DUOULKYz3M3r$TLvVW)yZKtO7!s5qS9?d{U%WQdJkVHUa-M`{9p&f@aS z$qUQ6rkBkh&uMGii-{dc5xy=3Ss(d$zlPKHAm{U}mU>kaOW}amY}X>9 zYqV*MGsAooIzJ3gsW!N%e>zufl4SfSPZmW9bVdoSnjCss~ym@#N+C$;9Yj+=O{ zd25G29xlk*_7sF@FYSZ|!%TJGR#X0r#9=`QYG?QqG2u~i7dkTJcD~}p6pucG#j@kx zavtNwqpLfKlv|SA=qpD^dRiJQX+B@^3r#aO5m>glRN?i^K=%3Ly8f}`_~nU+=mimV@{LP*_-S zEAOWN`@jEJbKi1zSWS@Bw%+DsdU_p^o%`dj7(PC>qxA2??E4IZ`M)(;KUW?c_aq~6 zbnDqISfJkhO!M#V2gMpQ4{x>Dt?}O7tGx5j$MZH-7{|91~vA4wt zj8&)L?`P|~H~f&q0i#4%ET%J*VNwt``a4h}$=!)kReTpk-kC)*MnO}>Y0gd&!HAEN zDjB*X7Y@C#LX2eRgI9u;Ua2LwWNI7bowK&z$ejQfmm)Fr?@Rp? zxNn$5h;^mQor&CwvJtMK#D$jRMm1b_7?5gTFUwbIMb+OMEF*kvU!+Q^L;rxNw`>@X z5uhSR{GU)l9|f$tMvD8%{X70VBYoSQ`hQF(kfv};NvU)C>9c1}c4HYEDgBbad^UD3 zHJNb-7jRmrAcPu-eF#EU+%7EnE8IZ{-Ob5y#lLTgjEtN7{>;gisQ~o8a~*%O_Wsr_ zJfd-uW_;0!J6K4_-VSKvONTKZhXh{GY4RjjHE6`Op^Pa{mS<-T4NWhi?;4n>1ZUCr zgGw5OHfghlY+OWEiu{8SVEma=oLV+to=qIFvgqJaY`KI~4GmxW2FeUdZN&c= z8JoW~_&-Qf6ccYBrc6@F8ipbvnk^a(@jKi((P`RE!?IuwEPijsVJYulH}9S)R^Lj_ zza4R&p963=&0%o<)fE)1M@Pi*0t*_XY-f@k#-u*^LwSJw?#==W3r7h7Ha)%JuSsbt zSnl-BBGzN7D+_oQDgyMZ@l!1=7k>CU>AVUK4wj7h)*IQ|*5<$(CH&{0mBv_6N+=nqFo5o8Yoljm6oOFY{jGfGI&;F;xr0R61l|hlQdny< z3~FE?SIl|`Ss#=!YSF^V@S2mdf&PaCq1tM|?D4>}p{6}e^XOMK82&Ki!~bh*5EG(D6SChrA;3XsR7Sno+H9Kn@#hWIoEfz zjL*y<0K&}VyjnHR^~j6bZ`)0|xi}V=m*u6U_w3)l(HBF}A=FW$f6lkkWX2HXHYVoi z-n>|j zo?g2`DnINF!M)b|#j_=fSxmR^J>rCq+L}Pb`=!GUW>Y3mNchq)?eX{e`e+EHUX;ty z9!6VVY$Rrii)uM$CMVbN&Z_n2LFpKv{biiB8sqMEnbh%a4F}#GLMN}qcZFgTN+GtH znuUH)I!<}8v}|tiO|gQn5Kt$2K4RUvwnG zbtXg7U_=d2l<>G>nb*Z|_fPyf226)NE?<#s^3~4>C63AQ_iUfDgNcn@;w>gOclYmq zNy*7ic-*?J1S=FZF;%@?yyk;Gnz2!=%oeakRD7x1Erxu2 zqzg++`b~-w_&wRKqEBwpY*5(jQ&9A7cKpY1Kh7){|9Nh;d`?cjYH7#(=`^zixhi;eyNV4p+4%k*2i=*5{r8FCItw%pE~T1|ohA3O zo@n7Ba{3i?2s-$K;1n)O7CI!yS-hh#B9*3p<;QdK!4id+*JH8eNoz>II^Emk{?Szx z1wX5*DC5QeUqO0GiiK^>)Sw0~0_*s}^~@1=L6QRbZQHi}@u2tD_lw(@CA=wpvw7#% zfdsAP&tJa$X(}?G-@HdKko|L9O7F)s7_wZi;of)uf?3Zk#p#QOUFPL2s0jS#J#A4= zRMb>)RHxW3j~*wZ*msb02lNPHlj{#CtyZhYu=-(Vbv@_9>#*07vA#%XLDUW!$`Des z1fS>T;!2k2*2z+Zpk1C+03#a+r5Jp$g6%uVnUtK&jL@ryo?xKLIXJL4NL2bL>bR9!~axWb!Mi<;Adf&axT6u*KSG`22SIv9~unx5>Ea-4esyT-iLP6)5}&fi}l(? zSfwWGdok^pkZ2{|T3E0h=(SkcgtkXmU{PB2O2Pq(!}9W#xX;q~=574eeM34XO-;%v`)jJ11e`kp0Y(_4En1<4>J>(Iu;Tbt($ zTcDGgGr{)a%2CZ+2W_jRLFm&0uiou%CUMc6XQyX1><2DUaV@C${FY3MEYc*g{Xq>TqJ@)Vl53Jyzl=i{%BRl&%>&b&$I=F?2sCdq@+>F83^ z(9^deZiHHvg7kD?N3-moQ~!QtB?h8S(=JGlzti-OOKcx0o8H$xw%WA^&J(AK6zIGk zbFcrruB#AJt}s46!9-i~4<=TobIEQX@R;W7W19K8q=Vl+v%&CIjvzS$fInla*Zw>; ziB{##ZK+>$1Z;j&*3AB`YDi`+yHuX({{8*^ZF{%<)lH)u`)^(R{}b`c|50~Cp>zR^ z=edOiA~%CM0yP`h0-L3(e15nL(8VQ4Vg17x)Zz;~E3h5yVS|74YTR6Z_OD;O=#xOs zNh)AF{;I*y#+I1EO~N7%F77=#Dyq4`0QsJVQ;LbS+js&)Lk0A!=?P!aMT^)`isqM=N0d zp0=OZ#e?NdzlMR_tDL7A0+Hkf!#mwaoR>GpiE0oQa9uvBD<>;@e`z$}Ez;P!9yVW! zh#g{|os>DsCE>G98jvThhffENZ{xFkGw{m+r9*hL!B6o(gBQgh;xDzKN6PnQVxOgpBqIYLG&jKB0@%SDtUAq58=RMx#$B%Zu zUzsuBC_DI)UI1N5hg3IJ(g@uVb-y52x}02ZYo zA2GD!XCBp3KW5LrS5`0=K-(2Yc2Rk_L-syCa`%S8VK%Cn100P3L0knakHG3GlREI=s$q7(N3 zjy+;rreusts@A_CJ+Td9I26pSjuy^?Zl)VWXt-~z;^iWPVW?Bh{{!(TU}s}{py&pF z9}H0Kftq<%aZ<;Qc$l`QKd$@d^B2-VAI zT@hN4jXoGvi|zy6MM6@Nis;n_c2>$>biVqW%?RS2)QK zB$4u^V{ZO&sx!LkidkD~bdCZezPl46$?tF6Sl7QJ=`&?5jiV{ve!vG^CpOWc~pUHq$e>mtP5-H<6#P`NZ6>AIwX zr#ug13f_9X#yz^=D%asq1O3|YvDu!xXWMZmOzEh0cB-W5>}1^NDS#{AaejEw#TR=D zV!&e?0p3RFxdcv~`qqB~s%5~7ui+{h)@1AO4n9`2odM(a=Y{ZTcd+(M{HEck{|VY5KQR@7|)6P8F^ zaWN*%`?6!~U|#P|uOr4}Mbku$TKUilO0w-ob52O00D zxwx`q;}kKwRaJEw`W`46RSt9tB+qTW*g6tf&=#R~!^^KCB5K@xun@VzZ4ar?FPuL3 zc#|RP&!3a=bJ#|uxFI0Rl&1?ca$J7!%P|A?YVaS` zAK`YB#oa<3**PZNrxKe{hA7%;O@;94o{$Uw$^udD8jvAqwvJZ9#0xK-V8rbs{;6wb zSnGrW`O%jmf;6q)*LqpcR)TS zxuQgz`OluU!a!p|7t7yD!EP zkeK&QK&Kz0Ly*GR$+&TI*Q5R>d9k}q2ixt~I)F`t-OV7X-&HK_XVh9#T01LT{2397 zPUAmLE%~1%Lo~W%XYP-sJr^fK;u2D$4@V@el~ahNvbK*pbz~ZuT8tot%>1AXK3I?s z;nBl~hL!2eF%7?`3ub}>1Jl%-?AdVursl=021%XOot_ede3%bwc`=`Hg=(Tx?Suz1 zf>J|qB1F!7vs3AdET&_Qw9p+q*z0Tt zQzE|%^%SMPmmNq`9my=FLa})x)!Oho-?&kCI~XvA_TNzv$u+e{0JXROJ$2uVax|4< z371CE<9K^L!0m0yfu9nz{XTuNoM*BwBmx&BAn5qTQ4uBGB>+HP&vxOKb3(Nf=`GGD zYL=FlOJX|kSx9yrA$zdP9wLe65vOzHySpOsbpxN4DgV5t0&3iB^X?8c5#qO~G?W(c zn310T-L2E@hO!Awi~J$kC=Ypg{mFyjjj|JYkgafY29_J9sa|tK!_kp2=~|<#jz|uv zv>dJA2klGOEmR8NL1favZ8+^w^B7C^T4qjHEBvycVtBS^7sVv4&C!xXl*wMey>Lo{ z)fQ0)UfpZi8TDhyuvz2yALYp>Hg0FVCoKH zLR&JS46vIllC++g1^omkgneIKxaZ7gq%mGKW32CB zPX8iW6iJb7P`TJ0y|HAYme{k4rPFL9^02ZmRVWKLBVmTVN+L0N4` z`lGSYszgw1Mkq~rGPM`r-^TqNR-JhTa3AGd40lx!*{$1qCVNk2IGO6SqZD^AG4hOG z`F3J6mNXQq=tIGOiO4tXccbi4uQ*(9e<*pxKL7-e!t4)IsQAyjlmAk?Y+g?q7P zcL@c-!6CPtBt$(Um?bOX`V>^9oo%}ObuEw9^dA(TU)||7RaTbGL~ap@G-Ae$NKx1P zH*ZS04=qO6wITR1(wv7Z!*$KB;7~37f&F+Z(tr^~-km}hS030Uqgm5-zL9+GnOT~B2X1Dg^=t*Bt!UR&RV8kj`AHp{Jo(6Eq5RT+ zwEzg6S*V@~^z*CV`g`4;#OAUVFyf4(en@e%oowUfzql|v>wx-&DH2suTcE|HaSS7< zc*7zHEuB1tyS<1!tlg92SC%x>IqPa?tkLn=VTilC{Ww`jTp*Oh=?=OWg#jS@|M+aOHx+|!SzZ9_WVjjfcq zSzzoSR&ASx3q2I~vu^&^HIT~0c20h%f=B>)4>{fsDt#EQC<(_;99wiZ%`IZIH%yyd@jt#IQI`jA7Lv^p&{vJ0g$VJc0tjapC3tP^P&D@R? z!hbI6a4mA4TyKEk+=A8@n&fYvrVXxAhYzb@9#!ev_CQWL#EYrnkL0p^lxR^>Qg#1X ze*6{qSwz{q%PFBMw3~=ApIq4x8{obb>B);)3Mqq$A3uU40F5kW2)L!eA2DON-4f7& z0;gG&r4U6z=jW^@{)F=7t5=sVK+*DJD>3)7vT_^i=ByVOCRwUzZ^vFg*~Vi5T-0PM zHI6GZ&cIV~&jYpCf$%io7_i3&qyzLA)oSA`h~5^q#=*ynXnGwH!OY6q+tuaLSGtWo z0lXt@*6PU(prk|=DTWNKKYpMXIL^-A={BO17$5J+f^xlNYhwmT85FiSfKb0prYGSM zCVXLdvHGa;9t~HhH#XRw`}m-6n_8S`MK&!E8%X5swiy8RO%r=9Xo#0NX!&s(l^)%$ zIsZ>vOv4ZCC)#;p01g9|#q(F{lgFG~O zRyldO)OISG*?hP#ulpS*VM z8UlE(p+rHoPt?>Wt7Si)pPz4k+5}~4 z3rG5B)9Zsc0BDEZ#727HayGdoHsH7cuH7s6%)jlXg=2Dr7Nb@tm0f2)hoxJl0k4{- z>*DP?fi$x6a3OotIc9ci=NW1+B5&=K&C1SpoBg!gPDU_8)~ay@#0kUTmmlPzhC;-R zu=Vh@I&n1Fz>_)Ed9Q}Q)Q}ItR3-8fU!v>*+&pFQ7kO-ErkXGC@d5a;yv`dFGjYMJ zV{q1s4j;JhUfEwg0!a=$J?h;aYx+=f;Qq=-(vy1+?gcC*%34})E*&;BH&;9joW^ZA zIe@{T5`v`_ml2&ekx}{n7Lq|0=mwU&khNGf1a>GIBWSnY_q>3vEGog%-J5-nC@}NW z)zP8Z`xp}f^dr$9LTflOml#6{3Ehz+1o*vgokl2@np%}ydeJ@@{)C0^9Py_o^Tf?; zGhsiq_ZQ$(DswrOyZza9+|&=I&hvopQ+9u2QlzSY(IwN@(PWAS{u zNu?n?BmVsFGjmIMP(@1>ZEer1#{{ag(@pO~&h?KUpUn&M1&EL3xsJLf*8=xWH;8TF zXXDiaA8~8lS}EsGPk5Iw%1hz{N&Y{czvohjvb?3ap?p|#eBATz8!8p~X|=M& zumFy^`)xC*ic;6aSThNqX;WF%YSiKU>g8j;pe*a*x8ugw*Zzp`aR2x{rT#+37nm_- zK6ArUbUQEcU4dPpe4`8-^_E7#+D)ZJ&aM7^+oP^C{Mb@l5m6JBrP}bC9dlRMw23RI z$i8h+$@ye43}0dm_rR>&ukgO^Y&b+j_dKD-4DoyD=KsQU$qx z`Uv;F+OY8p4(&DaoX;0`uKYIbeHFPlk`ulWJ+$5}D)aZ_{C1z}w!d@Bpjd2nX z%zDgfGu_jD=A8S9;SHor!(_+cTqj zo@p*uNZB+9m1E@5Hd!TMvnF}tM<^aVTH*5TKPFX4Nl@Ld?&0@s>4C4~F>1n6&K=I_ zkM`73BULet%rs zf*voYIz9SEe`fz?Y`-%#Zz%iuu}(3Qb^l_0(u{Aq!!&E9j&t`4EW&x~sL$;0X_zfq znc_2=eWT{``Mjv6LW}m~A+1Ppu3*mIkG3+gE8~Y`-`_9q92G4$)Y1IVrS6#VT`*^A zoTJ!V_t@sA?CIA0Tf;jqI97MvOq)0`0R6?VDtOtXs0A-va4;NwdUY&GW$T2 z_4-HG{5-GOlO{K16)V_#6c3#Z-{Ol($uvw&=3OdOvj;sq9xGy4afRDW^L6J(!9Rwis4CpK~ZbR#k!=$XBO*KQ!|9 z8uOEDM=oB?8Y11i9c5os&~xV_?-C{9Hk=%K}>d<&lwOT4~rr^98O8D#PqtKH*7=(qp%bC(KE>ufhI z@0U-V=bA9Oqq%-&Uei%t;my~YblS8yniXZCk2POjT&*H7o17d?3NvNJMaDh(VM^at zygmPENY96w{)zmtqUGlgT9Jx(3b;49 zM7ORdd)C%5y4wtQvR|zvJ5DVB@RPedtwTMErQnXIb?ltR{W$wx@Fn|2D zus-D9_ARR9g0iG}KW^MkHWTfzyXz_5*1HijV^*8elr8XUO8?uD?GomWoe=>a{L%=di8eFer|#l$Wcet3@HPzjf_RU7Ka8(rnvhyQ5FJ$~$J zW&Mt}7bf#xYes0_+n5O??{u~pY+9-d^4(Wle?yxu?T%+a%BgemZv!msK5X38uhPiI zJ06&P#I$FJqNJ5CCE$rNf@^_R>Y zTuIy+cAO^{DkGZrfmMv<`(jiocHg?f?{6%nP@5dw^XG}{}L0L z?$owF;Tyv|D9u;Dk0W#JiL{}d=GdPEpO++| zr^UbO^1aAJ?rVQ=x6#49kCFIdZ?W;`x65qDN_ocN+%iY!6K{Umt;s4+7_IQ~L+e}S zfYKv6aPm#YDPoXtO6PuEWG=`f1~A4~^!t#Ng?)P`6)kPn-KwD5iHeJ-iPZVtIc$tB zU+JAo8&niFdBlKW4mN&JZ;BN5Cx7=cbYTB;y6n2YgIg2i+~%+H{8J@}~d71X>9v0;Hp_FMQ85l5+s@&RQB6HPodTq9rTd{gT1| z4n%l(8=IP(pL|sdq-dCx(mtXW4UDs?X9 z)IRgw*2{pJm?6lqBg;gb6IhuaT=6 zDrjqr{?i?9NWjnw7POlTLEEJ3+2teOh%SMPLPAJe7{eq_JzZ~4RXUyt{R%YhYrlQ_ zH8%%)7t%zrv%r1?O*Fiehacu!i1WnO65Ch65dyC+VjFiwLIUH#7j+|vw>|*ZNI)-E zuneCcNq?tLj}to&$FbqDVKv&Y#=E(7`mT!IsJ%SGC{6`@XRg}RLW^8d4=wdt&+!0`7h$*Rh zdM5*~2Hj1$lb7zkL=>ihZf5U{J~K8{SC^anyU9Lq98Ch`7%uxDR;j!B$n+@ukLHA9RLFrthkVLwN=eaT7+Y$fjD6y!!?T8S{yR$i4PH~PbrfCf7$U!Sd z1V{I7ZQA=w9Rr@WE>hN-0y||~sXzo*rCS94|3+%+1dyW}zTTeD!7+@;HMyRX}3|)ErI! zqQXLqUVpo6B6Sb>58^&2+mcdle(7=lv7r5Wi=mQ3dUxi z3J~fEPZARol{v}D$dJH^gd`?_mk z>a+_70Et>W^{v>`Le0=~1`utvT+8ThdbrRAtn%Qm#7|1eX1-j4wVhp1)euI!^@eq=YcL@%1(*U5aWJqB)SuCjcmQZf=rV&NMEe8Cxr_922;Ke35WC zW`ouk4h@jdgy>lyEpQ2dEOyKTqYi&5KJ%`N`23if+kf4Af%7SR5F5bM*2iDroGs;;FH$Z>S{7l zQuI;WMj{~Iea&z7r&SVFTaiAA7+OSvAT<-iJQk=Q&oKd^gk`DUiiMz9ggSO*+-yBz;wE9#LLrD-@u@0u&ElP3*2K0)iLVCJu@T$b7FjPaDhir9-(>~ z=`trBcT<}5TWzfy$i;ZA7tBJVPZT(-@Qnt#1t7Vv9mlyf5|$jIqX+#|g!6Dq9OVSI z85CZ?qM-UECXy~-v3R@8fEFMmd`r{aG6vkpWJ@9D_TbclxgQ~VC92MCYb_jP?1O$@j{{T!D3II+z?vJg2Bg{kA4+-%Q<*6~zCSh>$~k*%;S( z_)X0eij%7N`SXhKruC-6yRF2jY0k&sp6?>S$@i*m1g$?xg8p%Kd2in{r?@tLeSV5e z?K7I$lQ;kUS6jP3#E+8PD?t8?eoNA?#YGY1v&fj3=nx1kb3^W~Q(4Zog)^k6{j5+V zsm6f4Mo&qJ{_v$LB*DN%B;b?u?%kWGiJ!D`ZN_eznkEsV-{ie>Jb*-+n>VRgSRinh z3kblXX>B%=eEITa<&Uv273Srsa0fT#Ake(`xg>gpF<2&3Qf87RJyy{tBxTb{Yr|Sv zQ{%(`hI!yX8^i{(typN`II2PEPUHp1$;I2Ry#qu0K{4>%Sata#&e40S0(5!=15}#Z*2?3DcZ0cmrIbohdc`gL@O&} z3k&GO@SCt#@dADCZP(3aIg&wrLep+UN9xyLoVt%e64X| zYddmylnS*unf zQ|0PT=TWxvi{FMD2P!Gtr~nCqWB@-C zi>tWxHTF`;l(%7dP0%n1h@S@cB6I9F8p52dJP#iQV2b)&?y*uzW0VmD`!`ju?(00y zP$lU&e7dVFQ7M7_1nz{E7n!W16%)-A5+f`&2Mz)>Kl<~ST!d(mVSicfDTUg>5&1~I zr+1;(tRv^u0wRyGre?u70o6rJL;c(qutsISf0d|ZQ~>YTUE@PpwqSIn$ZT!tkhC;o zYl=Pi;F@oRDX|0dV-wx~wTmu{Qb$)8U5x4JcoiQs&yPwRAdJcuqlAv$eMxBmCsr+c zP47|Ur=8QUhI-#>P(5c_XXp(oRnKQpb?bK8RW!1E%!!^j!`gu9u9qMh!`M z;b;+Te}L8670KI-r6Y&&|6v{$cQ#ojs%j?m`J)@I$Ei-;*hnSd%5 zbFCj>)?T?H4+fLfd$&qQ28Z|2y;taeBr7gX<@CBOciUrBii#Qs8FL=&C_v(3b@JPo zX4trnye;deSQCS6Zp0gG zP48LcSW}=DZ_{HaXTM<2MUe!y~4ZpXuacPeNM;1B1d|Piz`m#IE1=20r35& zgysC(5Lo{~Aj~d|L)|EF3@a)y{^FG}(~H;Cf%=i=q{B7>!F4S^e$Zn9DPGP-sfYiC z%F0}AVr0aCd`7PRG*LkWz;BeBh*Lk$j@`TEkrI~BL=034Qi%g&r@;`zTXwT$nb+PF z#tt$*uaGlj5ao)JJ{w;mwliCs%Ozum8ul#5%)a*h{3+f$=TL}ml3SxNgkRdy((+wC z;2lQTcW3evQ>?p0AhuV0Tkmz9_@=aYjve!$18w~MtqzPN)e<+jF9d6c*p{p@m-9d! z#JKtpH<*R8K>lmiRyMIyUr{$RFfwYkr4L16I5qPR^9IpL>e%z^r@Pb2kgwRvVD@RZ zB=S8xrPq<^AmL4iff=@A4cbxAjbT(J0^w_583F4dIPT5H-dw9g`%iC8svrQ8{rH#mZ$>{o_h;INV3SKv zwmtg#i2#&goHf&2iXO}7h+Q1zmP1RO zrNEXddtD>%+MGZ>Ak`Y7_WmP)h2n*ey-ALj!?{Ae1Ks_A}G=)cDr<8sdDn zpPc}vHp?XVn_d_cl~|!MQe|#_+HwqBClIhO^gqGQj%Y?&TH5xuHuyX0UEm)_rl!n^ z0A?|_aL_IE^kU=U?&Wp;tn_W#=C)geA?N^n*qIplV`~O_5ERisY6IhElhh|tZG2-`n?i|iQ3TDC2>836&g(zfG z&a0W5-;Z1MKbg36H|9PrI>y#T~Z|IcC77eid?CzpAa>dpCuK4z+w1WWWXf;FumD ztWIqRmELY??M2X-!a4ieaIxZrn_8DHHPsY5fGPf}qjPJlWNU4i@dC655E)b-m%%Qx zHd2V4k~9)hTu4@Bg1KRjDx90E+J_%Cy7KZAKK~x3Z0qP~T(e{%udJ&}DK3s&qEE}npeEh1aU%R5v}^Fp zaCXJr+@I2vLJPGzs`4=LxfPcyS1Pfk`PV(lGv|lYfv1 z9m$SDl(0#Zj3q-v5rw1(nX_fcm|5n^unVbO$hZ=csTCPBmXMYqB$=nkGLh@iC{f?^ zHsEc~*O>bxR3;~|=e|~^Q7%8X%yL=0hf3a@yyr7%fI*LdKREy(`e7g`4o)8%gBccmJ#EdlL z6=8<7s;X-0a8(lxM-^B5KjI|uqZ+W}tfPOOedW4i5c`+R zdUM!WWcnoIB6}yYmQSW!iWv7ye?|21{M;p_<*UPlOyth!cBI#x_Rk7Anb`P<`Yvj6 zjz3(=h>y4anrZ85fwyOWc)keTvkhBV4e-uEYOHsMLM)Yk_ky=eq_mr!G%dhjkQdS3iG_>c^JE)+~9pySwPO z?UmKGtQdAtcr?k8W&ZmMU?YnzqfoVvWA%)U$tx(d67|t&*;n3M|E~uwG$!ADwAuRf z0FJ3BL`o zqMFFXg&TBxdwu*-PwgpzcCYsCZdp+-2d|IrfhNu#T{lC1!!~5|su6Q7))p4|Vos1} zu&2`eq%Wv?<8cG8!39LFXYFg3C*9x3gb%8a@|+mEaf_OUtC=ySTJ5&eL+NZ@SFexr zSaTBH9ty-($TOVXz)oP0$1DU#jRy~p zq`x)`MZAcGxasYCZ$H!#Zr@7uO>Z_Dc;L^BFxy5;TS{7)DC+!1!}Z`#z8&)K54~p} zyz5;5>eVr{{leMQICV(4C)x7XB|XnR zw^4wJ)`F+*`;TcfY7n(6so7!-Ru^^-f6BX=D)~O|%v9jVI)Y zBC6Ft1QX<#w`?oQrVgdZBk?gIp?$_LK)x^0niDe%GnuG`@o_!vEN=`3w#x`>o}9%J z*Wy#jA3m5o7ube*q!WL9AUn^D_u12PE=^pzeBv^y9=LI102%b8_t~B{`>Et@Zz4GtUJ^2d7-6VTKX5cevPPW!jQ3B`ABWsw@jSZ z_-spjN>OtX6mt76m;c94Ej#5gTuShryADJ#T~WvFTU*Juo+TQt3A+iG zv}5vr-KtHyoQqlj_3q%Z4yE>F3#LQ@shd>`Pa8x!yYd9CZU2 z`1pnV@7Mf%%g>un|Cr`nL>iQaO~>DJ>ObDg@tq6P*S_cGZWj>61=3QeJgyBWT# zbx3FB`v5(_+~)q29rE>G2ypU>KjL|pK&)+c)>E+|1F7D>uA@YQl* z=HfAPy#rLlMES9ddsNbrl5}QyC#`R98RB)l(yK9fQZ@1U6S(UzUG`#Zf?y9?8$$SU=k&ccAuxHB%`s~_b zJ@_&Ecq7+dx8@}t>BNPXdYM%WAJ*?XJvXno_#%h>RG~#Yj>B8^Pn*d`U5g_Ot>lsZ zk>TM>T81s?maJhgN=r-EG&-B+p=E8IUKne_>L%d^C=EMHU{&A-?fSlJ@;4O#u!Z))OxK^e~`{%T&$lMy_dLD{INQi_Xffmiagv+Ow87{<`Y&cg-FPEyq_a zs=cKRT#G9k=PpUddWJH$JHO@mh%bjp7`^g!y!<>RE|p zxxIO7vO%JIGT4KeMU-y6NPF1Pl^XT%ireaG>!9f)Asg3s5|OD_3RUfKH7{M6w9Vak ziQuer6X$>X_4oVTx9H!dWJ3CCB-tLnl(u%{pX>Tb^8T0iJYcC`^vvz8w-LU}@TA2G zD<_kEyWcGAg|-Koigadf*c2d-F>YHMn_|_`G6{E?c+}r}LO*T)Inm2O_d{``jG#~S z!fYH*IVwkv2@VQWCRkT-DYkkbOMsL;_F|JCwLHcgU`Qwg%Q0Utw#8Q|1Dqs4ty@+e z2||!tUHw(qcY#z+VUf27X&M@O>zmYqFIt|T^uI@mL8dpD8%8^%osI_VB+d2Z$?8z0 zfi)l$cY7Bx5{0_K$Y)`2hr!n~*D?D86Nk0shBdk@ufGK758|53?PFSYUZ!^o3#_69 zO2Ds9mt*&C-Sg*>(};jkOkM^Ri2KT|DQ;ugx>=51xGLKQs6UHz88%>l21I-HPYW9f zmzGYa$8E~^f(JQ0Gks-vAk5DCbo}S#&4h-Y#r(|t+>2#0%<*(V2{j>Sc&0A8e@Y!e z){r81W3#%fp>yT|Po23q``=gtvpzj#WMo8z)Z;!73g40)x)fF$zSX0|G9P_a3^`^C zEP*zVz1AiiR;`aoN@eAm`nXLi!aZ9L`N(WZM!XGg^9NE;KgV7TT-|UaN@Mgf2M-pi zTlK=W8Hj|LS#s{C!lH}^RMPL+TQiIhPuJbjHP|;{B6V;jVFt%pR_13g&|SWz(hpyC zK6AK`It|#cHJFI*4RI^;OACj>-}l%rudvydn3M_?tG4FSRfK$ujubF@Gcal7xdLUB zpYI7JkE$CA)b;VlN!b~&56-bxx^f6UQN)AS%in8qkY#`J{v3p7%C3BA-g*1V*>{hyzqy&v zPaMqDUK;tNlgVCbuSv-OzYc<73WirOVb;r(MgC?`h4Q&`m@mR~FeV9q%D-ixGeEr| zB62?UV)WUk7-RIAu9KK?WyjC{Uy$X+B_&(ApkKw~P~txM#Ei#4NJ3DsuC*0-Om_BR zp-Ag^9wu5)F33xUqcqmw)vIK95nhTgEb}QrT~Q$d_li}h<$=Y42HV5IfoBHL3MJ>B zUHYkZx?n!{{WE~~XtSi?wf2I_z@t%4BntXu~BycyhGw0Qd(_nI*}1> zZGDJ~2ZpgSGRxrbkf)9=Ct1TA6LA<40M9uvy?`0-U|}CSr$*JX3$Po84jR}>Rae(> z5s`ZpeP|bb7X~9iFKY)~1nS=l(1?=q*xG?u&8OGU~qIj4dR12{t&;rE2|1(+Q+%FlmpRN^uJy-$CfiHir){+BN`lQq<$ z#cl`YxP9whTwL5xzwbB`zz9e-5F&z!T4}cl2tR^%34(b;$JOKggMB3j4w^gV7qwfW zNz}4w@U%dmd+`9;Cd4BCiNRtpuHN)y5mz`SJWWZ#wA6R^V!Sq>DGVs?>3}94n&x3& zB!;eH9MJThh)4HK&|fsn)1Sq&oZ? zU%g@7H}LfBqDIvr?0iS`T6!XHZs>o zu6TJZ)5|SiOaA_z>UD_Yf6@V1R?Q-d9BJ}^3;~NHPzRF;|L6epqwi!Gm9%$tmEhP# zpWo0R%*Az*`~F_ZYknrIXg*-X8E66y35PT*9bBP+>l76g>F^+;(!s?Aq0N{OM1`BY z#^T%r2hWEpW?;a9sv-XnncmooG4g@}3Ud`)Nx8W#mSVskr9?$RwgcLhJa#NFAOIVj zO;2f;;~@bO4BFofIwm%ri7}yw2`c-`%TGM0`PkUlH#j)^ZeQ370eu4l>`RFk`5{!A zuVS;uV4Re+G};znv>WLy@S_3ijVDBe4rVQvB4Bxb7GJ>Dsy81UV zxzK0jl}0KZEv;U`wLUPgp6pG1<9k+SfE_~oLAeqRk7wv&a&jne8g`Ey^*ib5qsU)K z(je#4&lAzCm;W`5VJn;Fr=7*cz|>X8$BD=^mT|VMOVh$$j_uLjwgd3DIN$#LJdy=Z z^Tfq@11tIr3fw2Bg-aiYi<0S&i@A(kym8`jqh;y)`lq@R5iCXp?qtAYegK}&5iMBF zHEaaJs+W)#Dk#Cu#&`sbr~dtCAOg0lo)yI3ZgV9Gd74C`oa2n;YTL_nolHkJw-jri zg>W4#(x%$l$K@viO;Av~j<*4SGY!4v)`2dewWTHQm^Z&TZ^Y0mfN3T4-PQ<4Wx0gs z=c9oSOm@IC-)J2ola*ufo-iB zK=mQQ@y_FVdU_!ljhNnU4ph@$%L_Ma18Q(qJ=RWy6`_xHECKfRzMg*NyRHa)pPWn0 zNc-YgKpXJq)uASd9v{t2?Xa!8U&4rO+U5Gkf&;h@Zr$D~$+-c%M+7qk;|$|~@uQI~ zD$?(I4kuhhO@epT?!?oW!K@3CBroq%bF#ex7~YUeR}N1uECWsfOl0Kk zhcHysVs#y}lasI!2)Lf6k!oXU>Atq|Li3MPo)#5H;Df_Zi+5%G3@9IR+gGh@M%@gkHomU11S0 z@$ny>PJrKT!VrmuvG1Y$n_t&EtoSD)Z7Goz z5EBy+%K>cOpR78N_#`_**w=H(6`l&Hjj;0IY``yb-1JG}?6I!;v9TZxO^ez`4h!$Y zQDDI@__==3+-%ueTsJl0xOGI$m1B4`O*NZiA3j7|`{W5XX?zPcHStnur={4c^Md0g z%L9al6y>&zFJG=sPVP@mmW!7Z1(i8SiZJ9qa6mv{FXPTPeb=VQ;pNdsff9pYw7+Vr zcJ|CWz0zeOvBbPY!JQ3HF1X){9uBzMZLB+_qM|x{gO_5d_wZrF<}I6d%Hy%!?(6CP zA-BfNQBPgIho9+=gK2eC3eJKr>}y)5Pq*vO8*{FtpVK-`6U8KbReLH!>Y&rySeJsu z{Fi2R%ed(~gNK&AR-W)F5oDd#Q7hxFMgEclUVlzAu84PwqxzBUmW9rQFgEYc(2t|! z%%^=^uaW&1`*efNQnk2;VX0%K3YG<@J%N~A<}r1f@45_!;VELPMUus``&2d9WEj5~ zjS34LTy^{!356qBS##hiMKhC=msGEcRLJas2Wcbx6i=U)J)mfB+}b^*ycAk=t#6}u z?|D;GQ#^`=v&h$uL*+>r1;-v;0E=hP1dsv3Q6akG5eu+s2qsY?VL4zkm{E8{Ajn;# z5|a`o{wGn#u^eAau;nOy{3Yo)!1}+HbnIrD#U}89#VWVGsw!|ue#@-{Y}((bT|PX6 zcOY4g*l3xgH8E2(uN{TGCw9Rn8B^~1DuO)l| z{q)1TPvhn-)^mB6>=6l{vF@1I)@;%wq^C2bQvi~Ju8 z*EtAwL2~$({@~!^`8GfKZ_1AFa*DEpXry7@AS859%5&N+Rz+29zrW1V@-#9B(V-C~ z2y)!Jf`yF>c&~Uy}kHC2$$p2n#msf%V!qj&0z-k@@sv)O1#;G3&wJ7N)Hz~lTk$y z_rMI`^)@mIjiVlq$94mSV@kV!ZQdukK9D0~(Gr7h?Z|Rpf|HVDp_+ z{aoo6Ugzk>Ex|&b7#&wt@ws|K-HATxtPSblOap(avXhk_t(<*?TdNw=4JMtJPq@~SrbSn=ywtNM-jl}Wo+2PE-%RB7 znAjp4Hq^aqM#1v>E<2sF)3cD#VSPbBjQ;81K}2+qVsaHGNF%ur2ZhE9lTI#?1-G{U z?Td6N)2fgxgWC%N=pOu%Atxb+VX+Gw6if~n-xF$98B<7`j|pY+?c3lGK${tWN5*b% z!4gTZD0QuyQb`qF7n9`df-BXnZXrJZWzeD!{H%3FA4SUtF3X=Gu!5XBmN(vE!L#4i zpsX9(fWe_%oHRi47Q9wx-jZdy8)CN8(Kx$0+P!K#)o{{pt)c4{)WsJ28y1Cr6y1;} z;|{??ve4k1@O|}I83*3AuP3$ReWu7pN18`Ho#r}zEOvW+!t=*Gm=kuu`$S{KHVzIC ztJm3M@g<&394c&#ht1EvV}(`L1>O54hdNp+!;K>4UQJveEmY?9>k~6Lhpf%wj82c< zw~WoS%^bS^alDL&e`Sk;+~|k&^siL4wh3FgAWQMTN1+6F!t=t3c+n&Bd1j{V@P-fJ zl9G~-rj@6E{B`SA1xy=|c#j?#CR@-~$9ql``sn-}A1}1?HfsFqaG1eUhUeC&gNNSF zhi7ao-_;bP&+j_Qr%qlR6L5P_JrLz)J6vt`*M(W>;WbBWZlZRsM{UM!QkJ;lQ=3p&2h(a-V-TBfW^85*e+T3~e0vdFKaskzxyY|o&h6qMBjQOHE4Yc2({ zXelUEuybhWy&moDJ+Gyus0#NhLToI?@^8F()4{sS2Vzl(^H7xbzBXPp3Ch=0kO^~Z zfEWO!QNC@5E4~kF0kbPt`~w2e80q`GhQ$6Nzt;Kl_ZFJd&mZ8p{^dTTZ|zrgc^^bI zyurx<%S-&nz#@Cx--`0D)8tEh&c*8JC50m}m|RM#ORm5o(Qq1{e2kJ~SZmixmz$%r zjg8F}Rv6Gd&B~f=@Lkx(#bec3P`dR6#6bo^4bnbdKjM%3-#e}Sd@tF%B-o?XtY;Hs zdl8{*SDzz=i;0!tbGo4e5W&ZWmFMDRm1&|RO}NMDY?OlhMk=Qk<0AmwG0Kmy`Pk8u zp%r^R^gA6LkN?G1?HFNN2%R+yHEqTA7{*ek4(fOu1jDm{(nm{Mi$liwdtH7{((crS zSH%=+2Q{*w{;OI?f!ID&2@tDan6T_V>SR2u|C>{g{@wrz<)#>X^X5&UOT(-byXO>j z0>mRYVR7fsQ@|???i@I_VJ_g^dP08>9}mx?7zs^CZ?5Qy^YdFZB`HHrdq}YKlx0i= zoD~o{0x1txUenx;oR%EeA<_n5a2*Oz{PwmsDFFciZtg!TAb%-shd)!^+$8k8bQLfa zdf(bAf$ttY8lD%=-n|1z+HR$boAzpWsNyIJ?)EES&eYb|(BNjE0Zb+5I`$cc4$!Ya zGuYqX!MZGiFbY7;GeY|B)$j`|I#O>m3>-hNr-!rY1$@%*hhZ~El+noSBA`2xf(PGM zlmz_PwT>N&mVH15$$*Umk&ckt*45S`(Be{|qZwjzJv}|k)+lp=B1|#jHrJe74Da3V z8~bw6z#yY_RBLvY3y_Ox)nBKcFq0w~QGy z;)aUhzes*gMy*SJItGEv-#)cd&Sk`Za=`cix05Tu0A?nu&cpJhq* z755K`CcFFKK?fQ`Mn)z=*f{?F{nrDNbK@PSscqPl+`J>qf_Ah}1%147n3;uTTfiF% zSn{neSH>6}HH=Mgg5w74*s%lMHSna)XiGnDQS~SLY8mB$O!IX!!D)Q>+$>vD`B#VY zZj#y?*^_X`YFb;}ApQdqCqiggo9nPAw@GjUm5GM37;$i@nh}nT^|(8*hD17a@SutA z9A>T{g5OR<1BXCO{&3iAPaDg5fDOGY#@6%=c8FfbWn_%J`T|gjz`%QLao$w^-4dtQ z2ViulHZzH(#~j}H7Y|euA9WPz3V0^J03!a}@MV=_m$C0OWS(_^9#`j^RBvq9peC`@ z&o1eH-pYP01^i5peJA`X9=BK>i4*{IDeXBC3uo}TC=1{paAINFy<_q{Nm$rxz7OaC z?7rb8?T~c0*0Azzm6E<$1#Q5SgakMf!_woa+(SE|o*x8nu>_0(xr%qP}WvP<(TlTu#PYNC?yCr2btMk zwYGklpP!-zGyD}kY1xE>iysS8L4@TvYGrC07dwlZ=-q6zTqYT>O#ws2Y|*DO+i_;C znYY6rd22KGwph*1x#c0C90L-}B%Mb=U7&7@T)#b`7mb&>I#s*-$nL;}-U@o0q6D9* zs|n{X85^&WzoKdQ(yZ8eC)>?TShtu*^1yt!j&Xu%#{n6pGX3cy%@lR^)j7n^tEsEf zvoor2Ueg0{Bp^2Su5lmVx%dJt5jU?rr%z~VzRXo%jfK7%6MPsmL$3`R6$&!Z@+S~S zfX33&MVJY5q96C!x_Kl10da5X_-90WU`Wu2NJKk78*pIfZ3tf>*0b&VHaz^fxmm%K zfo3y)az=JU^eR?NT0_4mJYTwM!{)`2Wo-Va^dIaL&&{G-m= zGiefpvvpH!wPyuHvkB+nGYWK1Pd21|>fZJx%`YP(XuLc_gR4YBVq)05LlO!fhyZpt zaN$4bxxC#ddM>N9jEtOR?{A6%y8tPdvfuCQ>U`_!iW4S6$J`0 ztw9wIZcZtg!PMj51;bUCIcP(bG*i+>J-vyTZOlm385hGF^J7}4B|XsR!n=PF@ba8&91D8ZeWPi0TQY6Q}Q#XyyivKUhaS zUhM2Ok=R0E(ES>R?0CxeW#@U0m8$q5zi$y@!qGSX_PV1Q2Jox?9NIY06H9PO}Z#g^L%p zan^i^szHOhVfP>F#Crh&kkw_TnjH>hJmsIZ_vQCuv0*$)FDmzMGu?K*rBQn@pL6La zI2m9Pbfmv-U0M^^Pl}T+>%47I5aPGQy&-UiL+lbA*YuogwnZz z@8*+}>uJA$OT>+4Ke=%^22}GlAN~XLspaiAetwy%(=B6~mFMT@em&w!L{o~Y>&^R1 z3BM$?|A4){E4DQIxX;{h1~sH% zE7QLRuEk zVg^we%Nf7d?|+mZny*vhcX-PC@W zQts*d!2F*q^&UHHB0~?;>^|af|4yC#7Jx!@+c5z(cGq$yAuabkH(xc>Lp+JxPp0WH zQEPaemY;n?iFQwugzDTI&)(@v z!#$zl@TB2c{5x}HM?4iMLTH+B;|i;;9i-;%yXO=JAH~o4I;r`N-aU-TgKPK87e9!K zpQ@Yy33Iuwql6ruI#AOc3IPi$Qgtx0r8gIn@wmUd7Fji$iy(ddeI^N*z8X4 zN*TWfbaV2DK=39Vegwp%dY3++RenVKX5L;@kq4*IK*|J*pyk58rsZR%jI*Zqn^Y4$ z7IU_zFwu?=Kkkb>aOmZM+F0d01fh~(Yni<8%^kizLXlOt zet%a;F$9{)MAK;CaFwm?n{Q|Kde{;H6}Ad|BF%vJ3_VoQ-_9pNlroKknS|hX%maH2 zr50z&huLon&MpohR6d_mitU!~S6Nd0(Yf7p4Ox)}?C(bkB}m?vMPq%geBvkg!td@} z0rv^}SiN^V^tWX*UXWh^y_6#*4i!x*VIS1td2IH%?@3bfBm}!_^QfZ+iu2w8<-Ayc zfJ)R(J*Rr4+Lx4yFMQwG5Vq%2L+M%*wn^7IVB6eI$H$^Z--4Z6# zb({h=3sZi-vlCIfM3ZXe{!=`isF!h^1Cwzb!WwV=TlE=RS5}UDYbHXECW*Y@^v|Og z8RzL+YviL!QcEOjI|c_oRP-Ea!l1^_dLCA5J%6YPi*7EN_&W*U%TB8wreENmPt153 zgv$H9cUP~p6Yo%bsh9KJQN5MR-ARF@7ok7ApZVJSGE=8?AgPT>&0z_Q5hxM-_YQu# zB6f);8D@6b7oGSjr8BUy6whc7#kR53YSDnWm`m4XJkgqS|?~sJGN_~{uJ>FNP$9ohaS~%=;y}U~Ez?vCliVGYKw5aWa5iI|XuQCZ=gpd{1 zHP6Om8ue}YX+H1ZZS!(nmUI%fT~Nb#9T=Vn3OH|udqwIT{^x258(3%b0?S||x z+%CRlXLo$7IOotT9(gJe#jiY2Do?Nc8y}KkqViKVcN4kcM?P=I;~-b{n$k?6B2T&C zx}?|p_BvH z*?wa)x@3$Id(zE?(2bV1VvY3$ymG8EiNoaj$4z2k)pUvVMcbyWS@{HO-Fed)v53Ej zW_dBr4bI;E1439}(A74DuP56JJ1eWL?sblk*_BUa>P(ZaHmr<{h?5v^Z*Mih@p+v(jPA@KON97O$I;%PHZ)lOq506` zg~z06R{_4h{R0DKE^qr%c(c#Au~J30~avQ0KMYw9;w z${qgm$Lplowb%0ZvIBPwype0#i2Y^Z7vJ$4X-7xLzMaRJND*_5^@L)rwU#uz>+YdG z`go}rn%T1pKDb=!sn@k-XQLy(b#RY~sfjW9 zD-W0;4HKso=(%ZMs(|~(x7Y%4?9dcowQX#6>aH%VhHg%Sh4#-b>+25GF4?VBHM^sU zCcjYdI8m~);?#RtE^1+8vOZ@XueP?76MS`L@D;UTA%B3Bl^X^XhK&Ywz!6y7B%3$h zDO+spFzu6EMN!EQSa*UK>7ISYB7MTBm-L!@gZDkX+JnqmR0UnZ8(Z3O^98hOj?)VN z_fg9oJ+qBJ#BcY5+edo*POy0)8ErXjsR);XVT%-&c&XLCWY&|o+(;Q_78aL5LXVBO z{1B1H&qJ#{jx0nBMeOYCgu+RcJjM#~=rtzJ-QgiMYm#Iq= zfB`U1|FG^N`+-fP7~-_Cln?7+D##s_n@(IKq!RtAh16GZ#+RKxIFkxw=Vj2O$GfgP zlQ`EY$kX%pVsE%s&yQ2QQuJT*=$vQrg}jeyWSS@ zq};ju`uaM68cpESF-*KTKfl(QPBNybu<$42w;w-#1gEF??5U$Sa7D>|&YUG6poTW* zd?KJ~iFtr4d_<9Y=;8gS(O^HT1}YraI&mr%!NO9I+Nr z@Vo7nJ#IfdpHvDaAixJN!RRg$JBa_=4eLm@*2a!j@!42umUU#88XmLX4s6@(*n4b4rdx4T|fk@NI)N57ATKTY2h5*$V9LT<4$ z@w4lgxU-v>W6@wSlR8T_g56f#TYw7s~1!uTW;MU&T*l(Z*tGzeplck=D z9f(I1gi+A*%dS3q-y<+m?QIwgl^12iqP!Pr0gfMb#1lT7rH`Lv*>5|08nWo>_@;ut z_m16xFAL|*>fITearX|F-qjMU)`;akTl|MdrX4UcwZeD9BrthTlUJ-Q0s23Siq9wN z$=5vo^qATRRZ||VgeF#C2A$g7Gj98_(z|)YlQNu2zjP|acd$txEB2Fh^msS2aM+m9 z=li>|ya{V1(lor=13NeK91jE5-?N_#77keNE}MkF;J`(G>~}=mcc|i$;>{-|lnaM- zyK8uicA?qAA(M#jb6@B3m2${=z4Eq9h=t9-NSc*`4&3-7#2str&hrnITmmBQ-Mc$v zl3iY2;eFG5;w1e=hC%Ck$pI!WFW>LjCwS7TrpHDU{wv9Retw=5yWNaax6*C?Flk7q zPzu`e8~3SUP|I7IM_B`(<5T0)K1I4#RaN!48$=41e5EhQftw)fYPYwy-PAUI|5;lz zOHv*g7*J4AalTx#pVF)}+Itj3)79D87ET_UnC^P|d;V*~*Iydu)SrHvan8`!*)J?T zsE*Fd%lm_y|0v{JR@P!m{$ua}okG_retv#0Z*OZQO)V|t)R>PgFE8(*N3A^ll0%hv z)_}VSKht=L^GSCS$75ONbS8>gPm-u;7vu&A)ydvket^!}7KGd1Ru zv|eiLvZkUEVqHc*@_y%S-XBGN7BYE@B^l%CGxO7EFQz3U#O02i9EPp6^+OD-%mceB zZQyzM*)k9g;KAcostoa;0;n-DFn9JJA^qAHKhc<9T$>o1g2zsGyduJn8D{Dv?=-77qi5lt-UWzTcqymxY$Stzx-&1XQ!!VR)`F zU~+O269a=jl!U{h8#r5p>dRNp-M2oM(TF7^#Q#t)QpnE=!X^ua0&sKduuG$CB_x6i z#PIQm4i~Bk#i((G&D=V7%M9D3T4G`bA7ynA;p3NkjXP+65iWr|e2~g(%n;RXX=|Hn zsimP|UakrDPmy|^zo7F(H|M9f-v-P?sTIIwnYveQ#d3+W_uKdEt{P4UKCzO}{J+E?HIX^p}Z&`?0=&L`iq5EL$y0Ey2E4+-qTp4ypGRCLQ=g`h+%Dr-P z^`K;KXUL_GkaYj(XxX7E+c+D%2*O&sx;7){HAb5b_76VGn3%n#_X$b%Jt$q}dk)LY zBjaNz7p*#LByVp};_sqinX0j{u=H~9v@AOW=VDc;Gf{Z&f6^^AEmOCx zxo(?VYYfJwXd=G!x=LWxl8sranDq`beVb`sK0(2KbGq`xR#ipCdbUh}p6$2vx{97& z6rZmHPfFrweF`+)j^Qd!$8hoE{8ReS^Zi2By+7Kewda~3kA1>E@Z;V|3%;+7jEHBTW<H3QC3!lCx%Z*7$rrv{4J&Wy!vwUY(QZ^iB|5F-LB6u`EP$nDx| zmoxlct$;nB-6#BJ+GDI|Uz|6{3GJA0Dt3E7R2VxOM(?QM>W7O3?8QiEJmk_^z z+e8p%+%>{nX-q^#in!EVT5}_VUucgl|u-(P7d^j*JXX zkeN+x*U+V>>^Ql&*o;>j4|l5E{m{Ttw&`Uqfc_5)(C|7gHB|t(R<2|L+npL6gzLZy zwzT_SS`8HNoOdp(cCc-S;S5U{g6Xz=7^Vkg$M3zRjtuxWay=<=$vA?&75Os&?F~cQ(5Td(ow|l zp5XLGuG*x@ibExjd^(>gOL|{>h)YJ@fLV*$_R2~S)Iy=6AMqtQ*&1DJ$Q56LPark< z#D*s&$8&3~EV;sJr}c5@&J=y!8#!YdCD4J4=d`eKJRbi;QCsm`9Xq(FBBMibZ@~G8a`YGLD zgq$HcIXM9FZj%<}Hs>a>jrtHAOdKqTldi9Job^L{(SdUNe6i_$WYqQ58DV;^>9>ks zzbdDEuH@g@ma@{`ueXHpJMqW_V-CQ7iOA9OX)>`4%cdxfs zo_~6ahesqDb+dJZB_lA}Kle4CpN-9~>GXlOQ(JFuuXp`c7JX+2)LskhizOJ`=JrifucZmy}5lat(jMR^4k z%u3Cqt*4h18{L(e9PhIw3O4A`(NVh`X=zD5T(dZhJQBgOdE`+z%<$>$S^UoDiI_ z!a}lc{J5ADcGKgOlI{7EK;2UABpHDe=Ld5Bfpp|qWuKY&>Fi23{q9jsa&?C#5$^53 z1!w1srd!~J`=C+2^2ErR|%sp0T{-B|qv7n%!u0+=M_V!Xw8y#I;T|=cT#e7myfzOm5MS^jhPo7ld=jUq- zZvp%6c;3C=xeveuTat_iDXXfcs-}j@I&xJAK#XPy?8%*``Wis>WMyTsn&`@qCGk3~ z^%FQt8!9dK!!iIC0`PRART*rImoLS{#5IaXz=J*A-K#1ql~q)zVC=m{GRf@LJsU3p znX+uh1B|8>7oU)jUa_iHu__Ku6oBuv0k0UG@phQDH#a9={^{=Rkd>9v1yHuiah3Y% zQ+$U&@vMx*Hy$YTp%W)vb*7{Ilg{Ix*Vfj4|Nfo%M9iZ$?N^L3ch?qeU^Su1&!nzp zz+_anTa9WIb(hlef7 zdG(eEs5m*_)7$u!zq2wkVfz~LaS`~tN%ohmw zIEcc#5^Y_(U7Ve_J=8WgHth6VgR6ZUJTeQa3s#d-15n0r(dOByVeDFbKN#s5L!bs7 zFe|yy$xW&k5T8n6y+3}Vywp5Qy5EEIHLb1dU#4=i{tlR%sjdhbr0w*&c<})6xiY)R z-}#)}GbE0En6b&5mA=1B#w=ZeKg%^eZeNCpraP|%I);)xWO&q!gZ`Fo!Dw{=8o)x z7jwE16>R(ZPF*e*;1@3ZZAGeN1wPe@31k z3*aRL71!et_1VzjmwP@6mVbgHNx!`EHW_`R+k4!<;21EI~wh>+!jGl8>j*{0td ztES$EH19S;E_2JQFSx34S^;0W(vwO^1m!VbpgG?*Tahaz5qR!OIlR6M9 z*GtAYPWW*!cgKe5v^ijtPUYJE(NLi2@P-!7Y6Ur5Pdr@z#XUhyGkUe*`Wr+Dyy^~n z>$yEsNdJV1+4YWg`|zwl$78w37-kYF4N3nFQAjy?x8=CIWSvbo{fnz-(LsAraee>IP#}4C~c$~1XF-mOn+Iy;~KYeVTcdD>r zk7`$9h#P)6d}6$p@kN0HDlC}myZvTn(yPXMaBz?`vV@7A>D2g!6|OeQI%T}$P?geZ zQl6)2v1xI!W{*;-1+oq@w1ovF4r7jQXdXSsmm(x2j1X7SQkz7kXL_DMDo_~pQa=)j zE~*hXq56(DwZI*Xot|zKW0i)RLSE_6O)6c#r#6QF@wHQ~*3WD2oF`+ou9#+Yr-pB9 zYYcIlKERef+jpyYuE5O4IFegeTo8AfItWv4I(+Kmm=eRKX2WV0YtfVM7K zr2cGBCoRP`6t8xDNuX%E5a{7i|4N0IuH>wq5P^7&6nZB?qjGf4;^@fNXyjJ^a(Xd; zzIx~x_o$UPeKf%yqF2V-nz-u&}s>qNtH!!mUXfD%4kDbn}O zO7rIN&e3)#s?BbS-NahGS`t`(I|Jno00{Hq1f zIvCC=eYEhnrnUwjBQPvXTE|-lq<&PKRWvj-Zblv|mFMkl$w#G(-kf^49#mUT!^;u4 z$ScdW{*0j<8OKWLVpU%dDIIpT<%sjkPG%e*9|s@Y_1wnA_9LdYSu|ZIODyDdv=j@u z)8r3CzkN)cN6H(QE@ zsxhvi!zUCF448m*9U;@XDNkhm=&VYm<*UE#N+&FM;3+A}tk-!xgh~_&GPd-L<1RZc z>c3+!1XRCq`ughfxB8H9+C-xZ|Gp?DMh$zDR9yLKM0K-tl;)>lK)rWo=6XNjpNg$& z82ULi#!H{H5-;b>uHR6lqwN{i7&?PuP4D(>DNBR`Kl2xCzd(B*rVziz)!nA$xQ@Xj zwL;cBSF$HN2Z+-Vd@^WL_K9NBd*wnm5Zq! znkZoWPhHXfB+3pY9C4>>G?Kbp-+)!=1;G~@f!GE3d#3AS-JrQsh3itWn`uxR9LTJ*Qp z1(Y%QktvrI)me{@@J0yLRfIS!da@F7l&1Cg>w&Pq16mQiDQk4^e@BEO%cG@xNkyl{ zUL;Uhvwq=-n%IGNfEzG(D%GNtB^gk)Q9i9wiY)Q)j>?y{q_-^bMA8SeCwyyV({W3! zdI_PD)Wo8ORCIh&O>LZ-Dw#;hpGX<^IIXU#igOF?!i@$!*d;YP~5NYh`DjB=iaM7umfy zdfm^Yt{VxZPehWK4vhx>>-$b;*2LZJhtaq)LG;h%ofpj@-2zs2&-teF#A0Afk_Zh)5GCwO9iORIk=Ss_jH4L;GX|cQs8pgF z&$mOU4VRHCh|$#Qc`kcsyL30yVO)xPSgyj9#Ej2ZiQN$bWE$$LZGD5aTr$TO?T_&! zaj}9_3QKQxD`PE-yf6Gtl9g&_Q$p30e!z(fZVtn|3C%tWlHc~bUP8T?CbsqaOz@H0 z>-w+iOgZ_J`HFW?P8M)=(NA^3w36DEm1PEQRH&43PzO4M-YvwKnlF@(#By>D%_ zw~?VJyF?z!T7Jk++U{HHb>jCXgwbf_o_dgsfXv)*cm$hGeM zy8l;jG53O?`XV`|s*o?vXJ6VBR=&(eemZaJ5O3CGXsMLT@I%&JS8#H67)Xom|4SAv z1{In|UaugJp2srK^=$qttit_QSVix&N}ISb2$WVRQ5^qDwaDcE-k~R2^Oic~C1|ljeYYqpc-7co89CKw; z9b()^iZn!muo@?A>#w*{ug^D29eGG${bh#j>>L~j^0oQ-y{(^p3)>*Es-~h+d$y8% zx}3ye%FfPCnr5@u7U5<%lmlGbI|x;v@ZRB&++)-?tLEnB`NhT7HZ~>2w@s(QCbh7T zQJ9{C<6x}J&C~&c=Nz9!|zbKm}Nk8Q+_$l5)*zCv$y$O5r>>{P+S{@9IaiHXy?eYfjljgj#1*#Ux>!!sTXCpzf&))qP*9MNkWgJ+4K6xj=@#oNS5{WQ zY=rj0?dF^M`{e<9=zUc&>m!{zWSco|<#RIaid|K8Ulw$k38@kL~<;_9 Hu4E~WaK7`Zq4VkG@CMY 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%0D2|G%GVrnrT@n4OT!%&zp)@XtTH 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 literal 0 HcmV?d00001 diff --git a/manual/static/img/screenshots/export-import-v2/import-button-hover.png b/manual/static/img/screenshots/export-import-v2/import-button-hover.png new file mode 100644 index 0000000000000000000000000000000000000000..aa2e16dd2066cd8c88b93ed89313a65338496786 GIT binary patch literal 98354 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%0DE$->7VL{>D$S`jZjmOCI2IHUl9o=? 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 Lrl$!ghg<&yf@3ej literal 0 HcmV?d00001 diff --git a/manual/static/img/screenshots/export-import-v2/imported-project.png b/manual/static/img/screenshots/export-import-v2/imported-project.png new file mode 100644 index 0000000000000000000000000000000000000000..72bdde43652b721e37fd2a8f48fc4ecceb850544 GIT binary patch literal 57817 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

(c&C?QX-*pA50a6ciM^)>EKS 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�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 literal 0 HcmV?d00001 diff --git a/public/swagger.json b/public/swagger.json index 14fa0c9a3..23c9dd854 100644 --- a/public/swagger.json +++ b/public/swagger.json @@ -220,22 +220,29 @@ }, "/api/_health": { "get": { - "summary": "respond when application is started", + "summary": "Indicate wether application is healthy", "tags": [ "Health" ], "operationId": "healthcheck", - "description": "This endpoint returns 200 with an empty body whenever Izanami is running.", + "description": "This endpoint returns both a body and status code that indicate application health. If status code if 200, Izanami is healthy, if status code is 500 there is something wrong (unreachable database, ...).", "responses": { "200": { - "description": "success", + "description": "Healthy", "content": { "application/json": { "schema": { - "type": "string", - "enum": [ - "" - ] + "$ref": "#/components/schemas/HealthStatus" + } + } + } + }, + "500": { + "description": "Unhealthy", + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/HealthStatus" } } } @@ -557,6 +564,14 @@ } } }, + "HealthStatus": { + "type": "object", + "properties": { + "database": { + "type": "boolean" + } + } + }, "Activation": { "type": "object", "properties": { diff --git a/test/fr/maif/izanami/api/BaseAPISpec.scala b/test/fr/maif/izanami/api/BaseAPISpec.scala index 0d84ce72c..7403e7f7a 100644 --- a/test/fr/maif/izanami/api/BaseAPISpec.scala +++ b/test/fr/maif/izanami/api/BaseAPISpec.scala @@ -499,7 +499,7 @@ object BaseAPISpec extends DefaultAwaitTimeout { val response = await(ws.url(s"${ADMIN_BASE_URL}/tenants/${tenant}/projects").withCookies(cookies: _*).get()) RequestResult(json = Try { response.json }, status = response.status) } - def fetchSearchEntities(searchQuery: String, cookies: Seq[WSCookie] = Seq()): RequestResult ={ + def fetchSearchEntities(searchQuery: String, cookies: Seq[WSCookie] = Seq()): RequestResult = { val response = await(ws.url(s"${ADMIN_BASE_URL}/search?query=${searchQuery}").withCookies(cookies: _*).get()) RequestResult(json = Try { response.json }, status = response.status) } @@ -2085,7 +2085,7 @@ object BaseAPISpec extends DefaultAwaitTimeout { BaseAPISpec.this.fetchProjects(tenant, cookies) } - def fetchSearchEntities (searchQuery: String): RequestResult = { + def fetchSearchEntities(searchQuery: String): RequestResult = { BaseAPISpec.this.fetchSearchEntities(searchQuery, cookies) } @@ -2644,7 +2644,7 @@ object BaseAPISpec extends DefaultAwaitTimeout { val response = await( ws.url( - s"${ADMIN_BASE_URL}/tenants/${tenant}/_import?timezone=${timezone}&conflict=${conflictStrategy}&deduceProject=${deduceProject}${Option(project) + s"${ADMIN_BASE_URL}/tenants/${tenant}/_import?version=1&timezone=${timezone}&conflict=${conflictStrategy}&deduceProject=${deduceProject}${Option(project) .map(p => s"&project=${p}") .getOrElse("")}${projectPartSize.map(p => s"&projectPartSize=${p}").getOrElse("")}&inlineScript=${inlineScript}" ).withCookies(cookies: _*)